s2/ 0000755 0001750 0001751 00000000000 15014114452 010726 5 ustar nilesh nilesh s2/man/ 0000755 0001750 0001751 00000000000 14737212474 011517 5 ustar nilesh nilesh s2/man/s2_cell.Rd 0000644 0001750 0001751 00000004523 14737212474 013335 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-cell.R
\name{s2_cell}
\alias{s2_cell}
\alias{s2_cell_sentinel}
\alias{s2_cell_invalid}
\alias{as_s2_cell}
\alias{as_s2_cell.s2_cell}
\alias{as_s2_cell.character}
\alias{as_s2_cell.s2_geography}
\alias{as_s2_cell.wk_xy}
\alias{as_s2_cell.integer64}
\alias{new_s2_cell}
\title{Create S2 Cell vectors}
\usage{
s2_cell(x = character())
s2_cell_sentinel()
s2_cell_invalid()
as_s2_cell(x, ...)
\method{as_s2_cell}{s2_cell}(x, ...)
\method{as_s2_cell}{character}(x, ...)
\method{as_s2_cell}{s2_geography}(x, ...)
\method{as_s2_cell}{wk_xy}(x, ...)
\method{as_s2_cell}{integer64}(x, ...)
new_s2_cell(x)
}
\arguments{
\item{x}{The canonical S2 cell identifier as a character vector.}
\item{...}{Passed to methods}
}
\value{
An object of class s2_cell
}
\description{
The S2 cell indexing system forms the basis for spatial indexing
in the S2 library. On their own, S2 cells can represent points
or areas. As a union, a vector of S2 cells can approximate a
line or polygon. These functions allow direct access to the
S2 cell indexing system and are designed to have minimal overhead
such that looping and recursion have acceptable performance
when used within R code.
}
\details{
Under the hood, S2 cell vectors are represented in R as vectors
of type \code{\link[=double]{double()}}. This works because S2 cell identifiers are
64 bits wide, as are \code{double}s on all systems where R runs (The
same trick is used by the bit64 package to represent signed
64-bit integers). As a happy accident, \code{NA_real_} is not a valid
or meaningful cell identifier, so missing value support in the
way R users might expect is preserved. It is worth noting that
the underlying value of \code{s2_cell_sentinel()} would normally be
considered \code{NA}; however, as it is meaningful and useful when
programming with S2 cells, custom \code{is.na()} and comparison methods
are implemented such that \code{s2_cell_sentinel()} is greater than
all valid S2 cells and not considered missing. Users can and should
implement compiled code that uses the underlying bytes of the
vector, ensuring that the class of any returned object that should
be interpreted in this way is constructed with \code{new_s2_cell()}.
}
\examples{
s2_cell("4b59a0cd83b5de49")
as_s2_cell(s2_lnglat(-64, 45))
as_s2_cell(s2_data_cities("Ottawa"))
}
s2/man/s2_closest_feature.Rd 0000644 0001750 0001751 00000010671 14737212474 015606 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-matrix.R
\name{s2_closest_feature}
\alias{s2_closest_feature}
\alias{s2_closest_edges}
\alias{s2_farthest_feature}
\alias{s2_distance_matrix}
\alias{s2_max_distance_matrix}
\alias{s2_contains_matrix}
\alias{s2_within_matrix}
\alias{s2_covers_matrix}
\alias{s2_covered_by_matrix}
\alias{s2_intersects_matrix}
\alias{s2_disjoint_matrix}
\alias{s2_equals_matrix}
\alias{s2_touches_matrix}
\alias{s2_dwithin_matrix}
\alias{s2_may_intersect_matrix}
\title{Matrix Functions}
\usage{
s2_closest_feature(x, y)
s2_closest_edges(
x,
y,
k,
min_distance = -1,
max_distance = Inf,
radius = s2_earth_radius_meters()
)
s2_farthest_feature(x, y)
s2_distance_matrix(x, y, radius = s2_earth_radius_meters())
s2_max_distance_matrix(x, y, radius = s2_earth_radius_meters())
s2_contains_matrix(x, y, options = s2_options(model = "open"))
s2_within_matrix(x, y, options = s2_options(model = "open"))
s2_covers_matrix(x, y, options = s2_options(model = "closed"))
s2_covered_by_matrix(x, y, options = s2_options(model = "closed"))
s2_intersects_matrix(x, y, options = s2_options())
s2_disjoint_matrix(x, y, options = s2_options())
s2_equals_matrix(x, y, options = s2_options())
s2_touches_matrix(x, y, options = s2_options())
s2_dwithin_matrix(x, y, distance, radius = s2_earth_radius_meters())
s2_may_intersect_matrix(x, y, max_edges_per_cell = 50, max_feature_cells = 4)
}
\arguments{
\item{x, y}{Geography vectors, coerced using \code{\link[=as_s2_geography]{as_s2_geography()}}.
\code{x} is considered the source, where as \code{y} is considered the target.}
\item{k}{The number of closest edges to consider when searching. Note
that in S2 a point is also considered an edge.}
\item{min_distance}{The minimum distance to consider when searching for
edges. This filter is applied after the search is complete (i.e.,
may cause fewer than \code{k} values to be returned).}
\item{max_distance}{The maximum distance to consider when searching for
edges. This filter is applied before the search.}
\item{radius}{Radius of the earth. Defaults to the average radius of
the earth in meters as defined by \code{\link[=s2_earth_radius_meters]{s2_earth_radius_meters()}}.}
\item{options}{An \code{\link[=s2_options]{s2_options()}} object describing the polygon/polyline
model to use and the snap level.}
\item{distance}{A distance on the surface of the earth in the same units
as \code{radius}.}
\item{max_edges_per_cell}{For \code{\link[=s2_may_intersect_matrix]{s2_may_intersect_matrix()}},
this values controls the nature of the index on \code{y}, with higher values
leading to coarser index. Values should be between 10 and 50; the default
of 50 is adequate for most use cases, but for specialized operations users
may wish to use a lower value to increase performance.}
\item{max_feature_cells}{For \code{\link[=s2_may_intersect_matrix]{s2_may_intersect_matrix()}}, this value
controls the approximation of \code{x} used to identify potential intersections
on \code{y}. The default value of 4 gives the best performance for most operations,
but for specialized operations users may wish to use a higher value to increase
performance.}
}
\value{
A vector of length \code{x}.
}
\description{
These functions are similar to accessors and predicates, but instead of
recycling \code{x} and \code{y} to a common length and returning a vector of that
length, these functions return a vector of length \code{x} with each element
\code{i} containing information about how the entire vector \code{y} relates to
the feature at \code{x[i]}.
}
\examples{
city_names <- c("Vatican City", "San Marino", "Luxembourg")
cities <- s2_data_cities(city_names)
country_names <- s2_data_tbl_countries$name
countries <- s2_data_countries()
# closest feature returns y indices of the closest feature
# for each feature in x
country_names[s2_closest_feature(cities, countries)]
# farthest feature returns y indices of the farthest feature
# for each feature in x
country_names[s2_farthest_feature(cities, countries)]
# use s2_closest_edges() to find the k-nearest neighbours
nearest <- s2_closest_edges(cities, cities, k = 2, min_distance = 0)
city_names
city_names[unlist(nearest)]
# predicate matrices
country_names[s2_intersects_matrix(cities, countries)[[1]]]
# distance matrices
s2_distance_matrix(cities, cities)
s2_max_distance_matrix(cities, countries[1:4])
}
\seealso{
See pairwise predicate functions (e.g., \code{\link[=s2_intersects]{s2_intersects()}}).
}
s2/man/s2_cell_union_normalize.Rd 0000644 0001750 0001751 00000003020 14737212474 016614 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-cell-union.R
\name{s2_cell_union_normalize}
\alias{s2_cell_union_normalize}
\alias{s2_cell_union_contains}
\alias{s2_cell_union_intersects}
\alias{s2_cell_union_intersection}
\alias{s2_cell_union_union}
\alias{s2_cell_union_difference}
\alias{s2_covering_cell_ids}
\alias{s2_covering_cell_ids_agg}
\title{S2 cell union operators}
\usage{
s2_cell_union_normalize(x)
s2_cell_union_contains(x, y)
s2_cell_union_intersects(x, y)
s2_cell_union_intersection(x, y)
s2_cell_union_union(x, y)
s2_cell_union_difference(x, y)
s2_covering_cell_ids(
x,
min_level = 0,
max_level = 30,
max_cells = 8,
buffer = 0,
interior = FALSE,
radius = s2_earth_radius_meters()
)
s2_covering_cell_ids_agg(
x,
min_level = 0,
max_level = 30,
max_cells = 8,
buffer = 0,
interior = FALSE,
radius = s2_earth_radius_meters(),
na.rm = FALSE
)
}
\arguments{
\item{x, y}{An \link[=as_s2_geography]{s2_geography} or \code{\link[=s2_cell_union]{s2_cell_union()}}.}
\item{min_level, max_level}{The minimum and maximum levels to constrain the
covering.}
\item{max_cells}{The maximum number of cells in the covering. Defaults to
8.}
\item{buffer}{A distance to buffer outside the geography}
\item{interior}{Use \code{TRUE} to force the covering inside the geography.}
\item{radius}{The radius to use (e.g., \code{\link[=s2_earth_radius_meters]{s2_earth_radius_meters()}})}
\item{na.rm}{Remove NAs prior to computing aggregate?}
}
\description{
S2 cell union operators
}
s2/man/s2_geog_point.Rd 0000644 0001750 0001751 00000011764 14737212474 014555 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-constructors-formatters.R
\name{s2_geog_point}
\alias{s2_geog_point}
\alias{s2_make_line}
\alias{s2_make_polygon}
\alias{s2_geog_from_text}
\alias{s2_geog_from_wkb}
\alias{s2_as_text}
\alias{s2_as_binary}
\alias{s2_tessellate_tol_default}
\title{Create and Format Geography Vectors}
\usage{
s2_geog_point(longitude, latitude)
s2_make_line(longitude, latitude, feature_id = 1L)
s2_make_polygon(
longitude,
latitude,
feature_id = 1L,
ring_id = 1L,
oriented = FALSE,
check = TRUE
)
s2_geog_from_text(
wkt_string,
oriented = FALSE,
check = TRUE,
planar = FALSE,
tessellate_tol_m = s2_tessellate_tol_default()
)
s2_geog_from_wkb(
wkb_bytes,
oriented = FALSE,
check = TRUE,
planar = FALSE,
tessellate_tol_m = s2_tessellate_tol_default()
)
s2_as_text(
x,
precision = 16,
trim = TRUE,
planar = FALSE,
tessellate_tol_m = s2_tessellate_tol_default()
)
s2_as_binary(
x,
endian = wk::wk_platform_endian(),
planar = FALSE,
tessellate_tol_m = s2_tessellate_tol_default()
)
s2_tessellate_tol_default()
}
\arguments{
\item{longitude, latitude}{Vectors of latitude and longitude}
\item{feature_id, ring_id}{Vectors for which a change in
sequential values indicates a new feature or ring. Use \code{\link[=factor]{factor()}}
to convert from a character vector.}
\item{oriented}{TRUE if polygon ring directions are known to be correct
(i.e., exterior rings are defined counter clockwise and interior
rings are defined clockwise).}
\item{check}{Use \code{check = FALSE} to skip error on invalid geometries}
\item{wkt_string}{Well-known text}
\item{planar}{Use \code{TRUE} to force planar edges in import or export.}
\item{tessellate_tol_m}{The maximum number of meters to that a point must
be moved to satisfy the planar edge constraint.}
\item{wkb_bytes}{A \code{list()} of \code{raw()}}
\item{x}{An object that can be converted to an s2_geography vector}
\item{precision}{The number of significant digits to export when
writing well-known text. If \code{trim = FALSE}, the number of
digits after the decimal place.}
\item{trim}{Should trailing zeroes be included after the decimal place?}
\item{endian}{The endian-ness of the well-known binary. See \code{\link[wk:deprecated]{wk::wkb_translate_wkb()}}.}
}
\description{
These functions create and export \link[=as_s2_geography]{geography vectors}.
Unlike the BigQuery geography constructors, these functions do not sanitize
invalid or redundant input using \code{\link[=s2_union]{s2_union()}}. Note that when creating polygons
using \code{\link[=s2_make_polygon]{s2_make_polygon()}}, rings can be open or closed.
}
\examples{
# create point geographies using coordinate values:
s2_geog_point(-64, 45)
# create line geographies using coordinate values:
s2_make_line(c(-64, 8), c(45, 71))
# optionally, separate features using feature_id:
s2_make_line(
c(-64, 8, -27, -27), c(45, 71, 0, 45),
feature_id = c(1, 1, 2, 2)
)
# create polygon geographies using coordinate values:
# (rings can be open or closed)
s2_make_polygon(c(-45, 8, 0), c(64, 71, 90))
# optionally, separate rings and/or features using
# ring_id and/or feature_id
s2_make_polygon(
c(20, 10, 10, 30, 45, 30, 20, 20, 40, 20, 45),
c(35, 30, 10, 5, 20, 20, 15, 25, 40, 45, 30),
feature_id = c(rep(1, 8), rep(2, 3)),
ring_id = c(1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1)
)
# import and export well-known text
(geog <- s2_geog_from_text("POINT (-64 45)"))
s2_as_text(geog)
# import and export well-known binary
(geog <- s2_geog_from_wkb(wk::as_wkb("POINT (-64 45)")))
s2_as_binary(geog)
# import geometry from planar space
s2_geog_from_text(
"POLYGON ((0 0, 1 0, 0 1, 0 0))",
planar = TRUE,
tessellate_tol_m = 1
)
# export geographies into planar space
geog <- s2_make_polygon(c(179, -179, 179), c(10, 10, 11))
s2_as_text(geog, planar = TRUE)
# polygons containing a pole need an extra step
geog <- s2_data_countries("Antarctica")
geom <- s2_as_text(
s2_intersection(geog, s2_world_plate_carree()),
planar = TRUE
)
}
\seealso{
See \code{\link[=as_s2_geography]{as_s2_geography()}} for other ways to construct geography vectors.
BigQuery's geography function reference:
\itemize{
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_geogpoint}{ST_GEOGPOINT}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_makeline}{ST_MAKELINE}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_makepolygon}{ST_MAKEPOLYGON}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_geogfromtext}{ST_GEOGFROMTEXT}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_geogfromwkb}{ST_GEOGFROMWKB}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_astext}{ST_ASTEXT}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_asbinary}{ST_ASBINARY}
}
}
s2/man/figures/ 0000755 0001750 0001751 00000000000 14737212474 013163 5 ustar nilesh nilesh s2/man/figures/rc300.png 0000644 0001750 0001751 00000036526 14737212474 014534 0 ustar nilesh nilesh PNG
IHDR , D ; sRGB pHYs .# .#x?v iTXtXML:com.adobe.xmp
Adobe ImageReady
1
).= ;$IDATx E;k& d!B!NC yB5O}$, "Ld\6$3dL2۽]wzٲ`fvuթSN:}jm{YΊى.~_ys\'Z Us y9PoߐA RVg,}[R7Y*eEiJV 3^g0Z1Oʯ~U.rȁ{W' 뻮^ $-u+ XR9N1!m;n3o9ZJ͑r8Nj`0W /rȁ{/3RV˗?XNܗŃBA ǯ 2]JR \+pQ٣P:&>.㤙;*hmsEW ʺ|ٳ nx7]3uܭt~ Z;}A{M dd
2Wrҝ'79Ac5E#(0S0ʾ6R9sP V9PAā=
Z]%}æ' G8E7T^x/rȁ4hT
)X}Rẫ\,{5u]Y^@JTۇ1 Qȁ"0e~O
ee碵e9Q9pppU"`MIΗX?p/dMwYel4>Hn 2 P!]o 9|WZ_J)A"j%sǾԭ"eU=c[|7WZUI
| jdRvTpX\u^MpêFhok)Nζm/|^pSڰ+rݶf VqY8Ӟ4
e#m&Na?:jTYZ{12ܯTU -Ͱ'irWE-˙Z__ߐ6 *wpr*Dmm6F2ӦM+4iұG uFŅS7kh'u,:.F.e^MFte:ڻ&X:p7
vT% FT RC@AWeQSWW%\h]imIx vرUr ؇ Iill֑dNᅜZ%@ sPsTC/suJz֕R
RSc OL
+,VЀ) @!fNxXu5'IKX:-uE52EyEئNKp]tE K}ܸqDbd*;!^ٰaßB+,[SS3J1?%.8Nu`%
KkeK$;#*˱>%A(/c,6 ?cٿb;TWѧe 4jn[ngZ? GR).sMR::v"(WTTctAk]{Ɓ:MA|7^6.;2UO'|K|OvhH-Jw|X Hp IsGnݺ-ՓgɳByʉkljr]E>$n!JJlxq yN><3i'M=(a2ac~Iϫ7σY/{kӺ N7@XzVc
O`,e$7egm6^9qHUfRXm#ל/ _ qG Yr.:L~^Њ9ݕ-el2qij @ہI + ayLCo(U]mĚ ~
@`Fz'; AXo|/P'N |wBT~
? h!OՈ+ƊG "LˉSDq?$?盔-? ޜxPk
%Û^HKkj E (*x3Z<$ĿCÝFECOd<1
K*F.+?sYplyVHt& s9 RI y _3 E8J%_# aUNxsĈ mjM$eUEk CnϦ6zM<9ưKC|RFxm8ʃпQg B_Fn l~Ws
3)gҹ\x}`<\ P,yCs< G PQ/ /.ux( W }T|ΪoƣF,4 q6[6P"kjj.@(a`ueEEe34jZ*!MF
%␐ʢ|>>)+[ Y𥠜#UAc
!tq܀ͭtRR]\ì̕ÖAّ(O/t_YeS=M& h% џL^Y_ kϪ,ZE3qwҸϲJ |/^@k@|{.~Y.#:UN V=۹ū ػΟT )N.NJKe:ΎxGpU^C'wei.QmQ:ɂҵ뙺wmzQ-zQpFQV)g)5ʺ}+ 3{Zp Τ!̤YPI}:1""HjjT+(4xؾwן9w=틡w6'*8ϯm%Mc)Tm]4V2h1N _'a2~ zD}%h.Ѥ |/O}CЬW-لY{E;aQRdA%Lae]xltoAB<:RI]^B#!nS|I IƆX , & O/ey#Dr7cÐH $C< xC،<*彑gݥ3ׯ *VUv|5
%püy'4@Z;,3bFyif; 6 wylì%e
'eU*IGIEG^R۔K#Wb *9'ȃ>TJy@iifNN7\p zjWz#%:Hce3>$
꣺3p>8
jh6<}ןΘ#1bi y g<'
RN:+ai%\Y^ȉ7$5
1_5FKݲb]0DeG)3ϔ 9ބ N}EH6ԽSȩ\;S%3Ŵ>3NDaFcE}c zp_y\[V>l^Uȯg趽֎MR]C<]\MLsS)+uvf$JG_&JOf4É3܍ BhrNBZ;N3}ٙ\~BQIzیcԴn$#@ 9UptȾs} MuP' \r;Q~S 0| Z6F N
Rd@Q ^,5PX)htN~A\
\عmlllrB%?m; ֲRy34?}x˵ *%%>R|^a+ U [6]"
$ߦzXM]f $,E\7WZ"$/p_D *~)UZ#14o-~Ag5AEEsh .a%w1(x8Xq
s ~u4~͚Irj,RVHzI ǜ[Z qhԍ*nntBƙB>gr]ዔdㆍK#^rF虅:F> IY%@F^
qXSSCB
GR*N~/ n
^-|F,5=;{>Li
_TWmݛYnB ;0 o~O) 3xx^%2d,Mes竊¹IU=ٳO?t%콣4ɘ{Oz9K&x_vГgN[gDѝF05l9ALxiw4#@ΈڡQ$VYQai6uΡ UmW7mlTErbܚ e f-L~(4NklEEQ(X- РwcP7IiY(MC9t2ZaIv7FH,K@?IJĚLQ8 ZQBpn&BQСEY`alnV+70$LlfD7qJh2NuV]M@[ދ9["eOJhr*րW<(mLWrघ
f5cmݺ5Ki'~ |~ -H 2}~\*++1cnx*/&Kc䊹bn97kb{uuRJp,| )CMM sXU`}3*c1ػw
H8#e Bc:8MG ש0Qi"+0RF2V@cv7|
>=ڔ2TXac {hxK"ˣbKU8QRmn|ZPZds*)_wRGK Z͈
ܬ" vrY!i(kko{`w6@xr:
CCV㧸zѳ\į4Y!M+}Rc0ao3cR խ,lawǢhTR:4pRB ª\4|ڀ{ule!L~H:H/ -Țf۸_[T>ofZRRdΗ}?0˚5WS?a wynv]{_xa8YaJMxEknKt
"_ҏR,)^$VDcf29#yeQ
G016UTqTT&xY qee pzɯ
ß^EHr#c aJ*Jw&JP\8I5\ WtZ)C]G& WKcv'Z5tNDpEܫ&kPߡ5~5ȸQ0I 4*EeXGlh
}LςY os)t0^,!ڂf 1*}`< 7
̱%+cQb.`֖W9缲2QY1t]g>Wm*T8x+Ӌϴ3w'۵+ñi`i AF>*03Ac12 xyXJp%}eއsQ\$tpvHPކ(>ec{qa-Je444`MJkqW/A
NY%,T\FeƁ˅ r;%NJh -<+c%xNio볶B1DtzծsԱ;wnNGGݻw\#+-k?kH IY$q@cԭd8Wg ~ᎋ7N9nUt\qQs{렰
-1akjIƭb0nӌ%߽伆gµ< V(,tPFط-O=3gvG
H*Au)am:YT{Xv -4V_\H~vCD/ 17Kpt7ˬb| ŪJطV7jDJd-jOfx~ſcJk{
]AB9$k
L"FG-l᱉Ԡͺ%?f#o1@q
ږUCn$g_;kb`XMWϠj7iS a+PDFfԜJ>d62Ic
gy8 D/w(P' }0IL=ccϠW8} QjFoԨ緟hDJH!O%fA1NlM* $i 2fPAJu&a̪~0 NdMbV[
ӘnSN5- uI| jw xrgu5+f"ik
Ѡ&5wCUa@F4M
LZ!bVCwu@O횝#j:H,My<&
Crʚ(p'M(cLK( #j˃x>C"5VCz- _HGxUsfN~ex#Qb.VFF(u^{gΠ-u\4 QC؛j$`/)&}iӼ?oM":R`f6 pKHq8Uz ֭d4`~tZk}5N7 s;+56iR|RV⩔%ea(E(뼓Hf)Яn 8/ F <OE n%kY|1Z9_F)<ה 2Pm-^
(ecC*Zrjjj+{в[Iz;<
!d-y?ZEx+/ ªµH3 /O
f>+Rox6X)gd4,
GHmFy8 0!vO% 2݈ơ %ũ1N
kY9
s(+}9ę߅%tqķFpItCt'M u&pAd?
MP>Du;葆3Ն X4:(s9jWQ
"%j&(ʡgX:
oI)po{
ObwYtzڀ e~eįʗ+R7 #?GidC QAHȝ_fF4|G*'FuX;ke Rrx JqK>BXkeb3M"A Clx _$= ,m:=FX[0nc, } +n=c^呜Z"1J(< 6;X0*[WƅMܦs>χWƙU6ሮO3o9t
oGz574 >|gwevYoƅ8.sѢEGk i`F k
ⳌUqx7hFho#|S Gù/Il*x`=Ğ
B5xiow UFTiRz|!'"$8BD*x4!teA%X1rDw}*JZ H%bM~S(g#D">)<dz
e>`P*z hx*mSX'|v]8_ Xީ^ <@>Zc䃛4Z#NK-Ӊɋ2ކB^: w-p mq_cڴŗz3 y
:+J@J[+DK*,wنv
ƪǼ;
?9xTVGAtNsݔ .8]WS c}Q߹ P٤6/g^т6ܕ\ĜjsKB>C J'۾&uӌaqYD[0ƈNNEIuJQ^3x|(1hV"\JZ]8z
d{16,e
ngYh4l"ϣPHKFPn\?
ĝ8n֦/%op2 PQ#p6G>@0)Zxw!҄}7`&!C9Eצ
M'T](0n{eidpk
Ƅ^g=
oєG<!{f*8l) /m6.FRhLe67[(*)y.fYI9 Gў:n'\.N+y7ϓ8'8$!mCNT 1"z
R[Y7/ _M !::㛉VYՕ)$ݍ6],K]9g TB..f @k
fxJUP8~P| jTd,l
wi{>1QF@_ɥ {+-_Ќ࢟?U|DՐ)#R[
^Ga/=N}92Z T<*D DX\Ƚ]J)5g npW|DO~`(++=ϻ|JCv;keUDk'EyK[ڝ e ?a_)@m(PaVxp9P@}Z4XKl)E9pqpґ ~nߗvTB46jYkd|V1UOt$M+ z%FtŷbxE B)d
di,-
ˇ)>9PAˁ֠ThLИ@֦ut&0 THtGμijIw.i" ;ph)3]&Op &?i^m'w<&X[!*Sl~-F9PߝTJ -"Q6Ǭ8aOd
W)kmn9pK
}8mV;(a-9'Q2NSjhñ4tp
B0鎹V /9ps`,,,;|m;_J{4 2qĦ/cZjs=EʪceƎG/P_ PVfay|3 PtE9@A/y WF)c3ԘPE2?we'z w;،=і (
}N5
F+jjߖ ȁ":z9|YPv+a U+Zf kjϳrcyY{7b
7<|\xBc_£ :_-r w=/]E9g
+b8~
pI*( ͱV}̌#}EyIݢ/>갔Ύ6:tiNP,^XVφ:cV%l͉ґ. q)NKynҊE*r {@ ĉ(kgɶm2_aYFę˷q(Ϲofjk='{wkgE#ۻsf\CV^JO=۱Vh¢{6۾TN OE l 1,)M+f?ӻ%h>rl:O]w=$@RSEb&?QVW ,rȁ{faٵVX=VY +s,kfP~ڒRs9TGVaeLT 3u*hrW{YnN EY$ʪNJaE.8G
ܬ)dDvP3Ja#
sm{՞"HKN++rȁ{ga(Y :Ұg_vYSfv}BھmK?sf UW]է#P
o4ŧ" 89Qhd IENDB` s2/man/s2_data_tbl_countries.Rd 0000644 0001750 0001751 00000002613 14737212474 016261 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/data.R
\docType{data}
\name{s2_data_tbl_countries}
\alias{s2_data_tbl_countries}
\alias{s2_data_tbl_timezones}
\alias{s2_data_tbl_cities}
\alias{s2_data_countries}
\alias{s2_data_timezones}
\alias{s2_data_cities}
\title{Low-resolution world boundaries, timezones, and cities}
\format{
A data.frame with columns \code{name} (character), and
\code{geometry} (wk_wkb)
An object of class \code{data.frame} with 120 rows and 2 columns.
An object of class \code{data.frame} with 243 rows and 3 columns.
}
\source{
\href{https://www.naturalearthdata.com/}{Natural Earth Data}
}
\usage{
s2_data_tbl_countries
s2_data_tbl_timezones
s2_data_tbl_cities
s2_data_countries(name = NULL)
s2_data_timezones(utc_offset_min = NULL, utc_offset_max = utc_offset_min)
s2_data_cities(name = NULL)
}
\arguments{
\item{name}{The name of a country, continent, city, or \code{NULL}
for all features.}
\item{utc_offset_min, utc_offset_max}{Minimum and/or maximum timezone
offsets.}
}
\description{
Well-known binary versions of the \href{https://www.naturalearthdata.com/}{Natural Earth}
low-resolution world boundaries and timezone boundaries.
}
\examples{
head(s2_data_countries())
s2_data_countries("Germany")
s2_data_countries("Europe")
head(s2_data_timezones())
s2_data_timezones(-4)
head(s2_data_cities())
s2_data_cities("Cairo")
}
\keyword{datasets}
s2/man/s2_point.Rd 0000644 0001750 0001751 00000001632 14737212474 013545 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-point.R
\name{s2_point}
\alias{s2_point}
\alias{s2_point_crs}
\alias{as_s2_point}
\alias{as_s2_point.default}
\alias{as_s2_point.wk_xy}
\alias{as_s2_point.wk_xyz}
\title{Create an S2 Point Vector}
\usage{
s2_point(x, y, z)
s2_point_crs()
as_s2_point(x, ...)
\method{as_s2_point}{default}(x, ...)
\method{as_s2_point}{wk_xy}(x, ...)
\method{as_s2_point}{wk_xyz}(x, ...)
}
\arguments{
\item{x, y, z}{Vectors of latitude and longitude values in degrees.}
\item{...}{Unused}
}
\value{
An object with class s2_point
}
\description{
In S2 terminology, a "point" is a 3-dimensional unit vector representation
of an \code{\link[=s2_point]{s2_point()}}. Internally, all s2 objects are stored as
3-dimensional unit vectors.
}
\examples{
point <- s2_lnglat(-64, 45) # Halifax, Nova Scotia!
as_s2_point(point)
as.data.frame(as_s2_point(point))
}
s2/man/s2_contains.Rd 0000644 0001750 0001751 00000012432 14737212474 014232 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-predicates.R
\name{s2_contains}
\alias{s2_contains}
\alias{s2_within}
\alias{s2_covered_by}
\alias{s2_covers}
\alias{s2_disjoint}
\alias{s2_intersects}
\alias{s2_equals}
\alias{s2_intersects_box}
\alias{s2_touches}
\alias{s2_dwithin}
\alias{s2_prepared_dwithin}
\title{S2 Geography Predicates}
\usage{
s2_contains(x, y, options = s2_options(model = "open"))
s2_within(x, y, options = s2_options(model = "open"))
s2_covered_by(x, y, options = s2_options(model = "closed"))
s2_covers(x, y, options = s2_options(model = "closed"))
s2_disjoint(x, y, options = s2_options())
s2_intersects(x, y, options = s2_options())
s2_equals(x, y, options = s2_options())
s2_intersects_box(
x,
lng1,
lat1,
lng2,
lat2,
detail = 1000,
options = s2_options()
)
s2_touches(x, y, options = s2_options())
s2_dwithin(x, y, distance, radius = s2_earth_radius_meters())
s2_prepared_dwithin(x, y, distance, radius = s2_earth_radius_meters())
}
\arguments{
\item{x, y}{\link[=as_s2_geography]{geography vectors}. These inputs
are passed to \code{\link[=as_s2_geography]{as_s2_geography()}}, so you can pass other objects
(e.g., character vectors of well-known text) directly.}
\item{options}{An \code{\link[=s2_options]{s2_options()}} object describing the polygon/polyline
model to use and the snap level.}
\item{lng1, lat1, lng2, lat2}{A latitude/longitude range}
\item{detail}{The number of points with which to approximate
non-geodesic edges.}
\item{distance}{A distance on the surface of the earth in the same units
as \code{radius}.}
\item{radius}{Radius of the earth. Defaults to the average radius of
the earth in meters as defined by \code{\link[=s2_earth_radius_meters]{s2_earth_radius_meters()}}.}
}
\description{
These functions operate two geography vectors (pairwise), and return
a logical vector.
}
\section{Model}{
The geometry model indicates whether or not a geometry includes its boundaries.
Boundaries of line geometries are its end points.
OPEN geometries do not contain their boundary (\code{model = "open"}); CLOSED
geometries (\code{model = "closed"}) contain their boundary; SEMI-OPEN geometries
(\code{model = "semi-open"}) contain half of their boundaries, such that when two polygons
do not overlap or two lines do not cross, no point exist that belong to
more than one of the geometries. (This latter form, half-closed, is
not present in the OpenGIS "simple feature access" (SFA) standard nor DE9-IM on
which that is based). The default values for \code{\link[=s2_contains]{s2_contains()}} (open)
and covers/covered_by (closed) correspond to the SFA standard specification
of these operators.
}
\examples{
s2_contains(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c("POINT (5 5)", "POINT (-1 1)")
)
s2_within(
c("POINT (5 5)", "POINT (-1 1)"),
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))"
)
s2_covered_by(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c("POINT (5 5)", "POINT (-1 1)")
)
s2_covers(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c("POINT (5 5)", "POINT (-1 1)")
)
s2_disjoint(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c("POINT (5 5)", "POINT (-1 1)")
)
s2_intersects(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c("POINT (5 5)", "POINT (-1 1)")
)
s2_equals(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POLYGON ((10 0, 10 10, 0 10, 0 0, 10 0))",
"POLYGON ((-1 -1, 10 0, 10 10, 0 10, -1 -1))"
)
)
s2_intersects(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c("POINT (5 5)", "POINT (-1 1)")
)
s2_intersects_box(
c("POINT (5 5)", "POINT (-1 1)"),
0, 0, 10, 10
)
s2_touches(
"POLYGON ((0 0, 0 1, 1 1, 0 0))",
c("POINT (0 0)", "POINT (0.5 0.75)", "POINT (0 0.5)")
)
s2_dwithin(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c("POINT (5 5)", "POINT (-1 1)"),
0 # distance in meters
)
s2_dwithin(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
c("POINT (5 5)", "POINT (-1 1)"),
1e6 # distance in meters
)
}
\seealso{
Matrix versions of these predicates (e.g., \code{\link[=s2_intersects_matrix]{s2_intersects_matrix()}}).
BigQuery's geography function reference:
\itemize{
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_contains}{ST_CONTAINS}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_coveredby}{ST_COVEREDBY}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_covers}{ST_COVERS}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_disjoint}{ST_DISJOINT}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_equals}{ST_EQUALS}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_intersects}{ST_INTERSECTS}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_intersectsbox}{ST_INTERSECTSBOX}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_touches}{ST_TOUCHES}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_within}{ST_WITHIN}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_dwithin}{ST_DWITHIN}
}
}
s2/man/s2_boundary.Rd 0000644 0001750 0001751 00000016237 14737212474 014246 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-transformers.R
\name{s2_boundary}
\alias{s2_boundary}
\alias{s2_centroid}
\alias{s2_closest_point}
\alias{s2_minimum_clearance_line_between}
\alias{s2_difference}
\alias{s2_sym_difference}
\alias{s2_intersection}
\alias{s2_union}
\alias{s2_snap_to_grid}
\alias{s2_simplify}
\alias{s2_rebuild}
\alias{s2_buffer_cells}
\alias{s2_convex_hull}
\alias{s2_centroid_agg}
\alias{s2_coverage_union_agg}
\alias{s2_rebuild_agg}
\alias{s2_union_agg}
\alias{s2_convex_hull_agg}
\alias{s2_point_on_surface}
\title{S2 Geography Transformations}
\usage{
s2_boundary(x)
s2_centroid(x)
s2_closest_point(x, y)
s2_minimum_clearance_line_between(x, y)
s2_difference(x, y, options = s2_options())
s2_sym_difference(x, y, options = s2_options())
s2_intersection(x, y, options = s2_options())
s2_union(x, y = NULL, options = s2_options())
s2_snap_to_grid(x, grid_size)
s2_simplify(x, tolerance, radius = s2_earth_radius_meters())
s2_rebuild(x, options = s2_options())
s2_buffer_cells(
x,
distance,
max_cells = 1000,
min_level = -1,
radius = s2_earth_radius_meters()
)
s2_convex_hull(x)
s2_centroid_agg(x, na.rm = FALSE)
s2_coverage_union_agg(x, options = s2_options(), na.rm = FALSE)
s2_rebuild_agg(x, options = s2_options(), na.rm = FALSE)
s2_union_agg(x, options = s2_options(), na.rm = FALSE)
s2_convex_hull_agg(x, na.rm = FALSE)
s2_point_on_surface(x, na.rm = FALSE)
}
\arguments{
\item{x, y}{\link[=as_s2_geography]{geography vectors}. These inputs
are passed to \code{\link[=as_s2_geography]{as_s2_geography()}}, so you can pass other objects
(e.g., character vectors of well-known text) directly.}
\item{options}{An \code{\link[=s2_options]{s2_options()}} object describing the polygon/polyline
model to use and the snap level.}
\item{grid_size}{The grid size to which coordinates should be snapped;
will be rounded to the nearest power of 10.}
\item{tolerance}{The minimum distance between vertexes to use when
simplifying a geography.}
\item{radius}{Radius of the earth. Defaults to the average radius of
the earth in meters as defined by \code{\link[=s2_earth_radius_meters]{s2_earth_radius_meters()}}.}
\item{distance}{The distance to buffer, in units of \code{radius}.}
\item{max_cells}{The maximum number of cells to approximate a buffer.}
\item{min_level}{The minimum cell level used to approximate a buffer
(1 - 30). Setting this value too high will result in unnecessarily
large geographies, but may help improve buffers along long, narrow
regions.}
\item{na.rm}{For aggregate calculations use \code{na.rm = TRUE}
to drop missing values.}
}
\description{
These functions operate on one or more geography vectors and
return a geography vector.
}
\section{Model}{
The geometry model indicates whether or not a geometry includes its boundaries.
Boundaries of line geometries are its end points.
OPEN geometries do not contain their boundary (\code{model = "open"}); CLOSED
geometries (\code{model = "closed"}) contain their boundary; SEMI-OPEN geometries
(\code{model = "semi-open"}) contain half of their boundaries, such that when two polygons
do not overlap or two lines do not cross, no point exist that belong to
more than one of the geometries. (This latter form, half-closed, is
not present in the OpenGIS "simple feature access" (SFA) standard nor DE9-IM on
which that is based). The default values for \code{\link[=s2_contains]{s2_contains()}} (open)
and covers/covered_by (closed) correspond to the SFA standard specification
of these operators.
}
\examples{
# returns the boundary:
# empty for point, endpoints of a linestring,
# perimeter of a polygon
s2_boundary("POINT (-64 45)")
s2_boundary("LINESTRING (0 0, 10 0)")
s2_boundary("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")
# returns the area-weighted centroid, element-wise
s2_centroid("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")
s2_centroid("LINESTRING (0 0, 10 0)")
# s2_point_on_surface guarantees a point on surface
# Note: this is not the same as st_point_on_surface
s2_centroid("POLYGON ((0 0, 10 0, 1 1, 0 10, 0 0))")
s2_point_on_surface("POLYGON ((0 0, 10 0, 1 1, 0 10, 0 0))")
# returns the unweighted centroid of the entire input
s2_centroid_agg(c("POINT (0 0)", "POINT (10 0)"))
# returns the closest point on x to y
s2_closest_point(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POINT (0 90)" # north pole!
)
# returns the shortest possible line between x and y
s2_minimum_clearance_line_between(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POINT (0 90)" # north pole!
)
# binary operations: difference, symmetric difference, intersection and union
s2_difference(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))",
# 32 bit platforms may need to set snap rounding
s2_options(snap = s2_snap_level(30))
)
s2_sym_difference(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))",
# 32 bit platforms may need to set snap rounding
s2_options(snap = s2_snap_level(30))
)
s2_intersection(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))",
# 32 bit platforms may need to set snap rounding
s2_options(snap = s2_snap_level(30))
)
s2_union(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))",
# 32 bit platforms may need to set snap rounding
s2_options(snap = s2_snap_level(30))
)
# s2_convex_hull_agg builds the convex hull of a list of geometries
s2_convex_hull_agg(
c(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))"
)
)
# use s2_union_agg() to aggregate geographies in a vector
s2_coverage_union_agg(
c(
"POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
"POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))"
),
# 32 bit platforms may need to set snap rounding
s2_options(snap = s2_snap_level(30))
)
# snap to grid rounds coordinates to a specified grid size
s2_snap_to_grid("POINT (0.333333333333 0.666666666666)", 1e-2)
}
\seealso{
BigQuery's geography function reference:
\itemize{
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_boundary}{ST_BOUNDARY}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_centroid}{ST_CENTROID}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_closestpoint}{ST_CLOSESTPOINT}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_difference}{ST_DIFFERENCE}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_intersection}{ST_INTERSECTION}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_union}{ST_UNION}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_snaptogrid}{ST_SNAPTOGRID}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_simplify}{ST_SIMPLIFY}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_union_agg}{ST_UNION_AGG}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#s2_centroid_agg}{ST_CENTROID_AGG}
}
}
s2/man/s2_options.Rd 0000644 0001750 0001751 00000007761 14737212474 014120 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-options.R
\name{s2_options}
\alias{s2_options}
\alias{s2_snap_identity}
\alias{s2_snap_level}
\alias{s2_snap_precision}
\alias{s2_snap_distance}
\title{Geography Operation Options}
\usage{
s2_options(
model = NULL,
snap = s2_snap_identity(),
snap_radius = -1,
duplicate_edges = FALSE,
edge_type = "directed",
validate = FALSE,
polyline_type = "path",
polyline_sibling_pairs = "keep",
simplify_edge_chains = FALSE,
split_crossing_edges = FALSE,
idempotent = FALSE,
dimensions = c("point", "polyline", "polygon")
)
s2_snap_identity()
s2_snap_level(level)
s2_snap_precision(precision)
s2_snap_distance(distance)
}
\arguments{
\item{model}{One of 'open', 'semi-open' (default for polygons),
or 'closed' (default for polylines). See section 'Model'}
\item{snap}{Use \code{s2_snap_identity()}, \code{s2_snap_distance()}, \code{s2_snap_level()},
or \code{s2_snap_precision()} to specify how or if coordinate rounding should
occur.}
\item{snap_radius}{As opposed to the snap function, which specifies
the maximum distance a vertex should move, the snap radius (in radians) sets
the minimum distance between vertices of the output that don't cause vertices
to move more than the distance specified by the snap function. This can be used
to simplify the result of a boolean operation. Use -1 to specify that any
minimum distance is acceptable.}
\item{duplicate_edges}{Use \code{TRUE} to keep duplicate edges (e.g., duplicate
points).}
\item{edge_type}{One of 'directed' (default) or 'undirected'.}
\item{validate}{Use \code{TRUE} to validate the result from the builder.}
\item{polyline_type}{One of 'path' (default) or 'walk'. If 'walk',
polylines that backtrack are preserved.}
\item{polyline_sibling_pairs}{One of 'discard' (default) or 'keep'.}
\item{simplify_edge_chains}{Use \code{TRUE} to remove vertices that are within
\code{snap_radius} of the original vertex.}
\item{split_crossing_edges}{Use \code{TRUE} to split crossing polyline edges
when creating geometries.}
\item{idempotent}{Use \code{FALSE} to apply snap even if snapping is not necessary
to satisfy vertex constraints.}
\item{dimensions}{A combination of 'point', 'polyline', and/or 'polygon'
that can used to constrain the output of \code{\link[=s2_rebuild]{s2_rebuild()}} or a
boolean operation.}
\item{level}{A value from 0 to 30 corresponding to the cell level
at which snapping should occur.}
\item{precision}{A number by which coordinates should be multiplied
before being rounded. Rounded to the nearest exponent of 10.}
\item{distance}{A distance (in radians) denoting the maximum
distance a vertex should move in the snapping process.}
}
\description{
These functions specify defaults for options used to perform operations
and construct geometries. These are used in predicates (e.g., \code{\link[=s2_intersects]{s2_intersects()}}),
and boolean operations (e.g., \code{\link[=s2_intersection]{s2_intersection()}}) to specify the model for
containment and how new geometries should be constructed.
}
\section{Model}{
The geometry model indicates whether or not a geometry includes its boundaries.
Boundaries of line geometries are its end points.
OPEN geometries do not contain their boundary (\code{model = "open"}); CLOSED
geometries (\code{model = "closed"}) contain their boundary; SEMI-OPEN geometries
(\code{model = "semi-open"}) contain half of their boundaries, such that when two polygons
do not overlap or two lines do not cross, no point exist that belong to
more than one of the geometries. (This latter form, half-closed, is
not present in the OpenGIS "simple feature access" (SFA) standard nor DE9-IM on
which that is based). The default values for \code{\link[=s2_contains]{s2_contains()}} (open)
and covers/covered_by (closed) correspond to the SFA standard specification
of these operators.
}
\examples{
# use s2_options() to specify containment models, snap level
# layer creation options, and builder options
s2_options(model = "closed", snap = s2_snap_level(30))
}
s2/man/s2_cell_union.Rd 0000644 0001750 0001751 00000001446 14737212474 014546 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-cell-union.R
\name{s2_cell_union}
\alias{s2_cell_union}
\alias{as_s2_geography.s2_cell_union}
\alias{as_s2_cell_union}
\alias{as_s2_cell_union.s2_cell_union}
\alias{as_s2_cell_union.s2_cell}
\alias{as_s2_cell_union.character}
\title{Create S2 Cell Union vectors}
\usage{
s2_cell_union(x = list())
\method{as_s2_geography}{s2_cell_union}(x, ...)
as_s2_cell_union(x, ...)
\method{as_s2_cell_union}{s2_cell_union}(x, ...)
\method{as_s2_cell_union}{s2_cell}(x, ...)
\method{as_s2_cell_union}{character}(x, ...)
}
\arguments{
\item{x}{A \code{list()} of \code{\link[=s2_cell]{s2_cell()}} vectors.}
\item{...}{Passed to S3 methods}
}
\value{
An object of class "s2_cell_union".
}
\description{
Create S2 Cell Union vectors
}
s2/man/s2_bounds_cap.Rd 0000644 0001750 0001751 00000002653 14737212474 014535 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-bounds.R
\name{s2_bounds_cap}
\alias{s2_bounds_cap}
\alias{s2_bounds_rect}
\title{Compute feature-wise and aggregate bounds}
\usage{
s2_bounds_cap(x)
s2_bounds_rect(x)
}
\arguments{
\item{x}{An \code{\link[=s2_geography]{s2_geography()}} vector.}
}
\value{
Both functions return a \code{data.frame}:
\itemize{
\item \code{\link[=s2_bounds_rect]{s2_bounds_rect()}}: Columns \code{minlng}, \code{minlat}, \code{maxlng}, \code{maxlat} (degrees)
\item \code{\link[=s2_bounds_cap]{s2_bounds_cap()}}: Columns \code{lng}, \code{lat}, \code{angle} (degrees)
}
}
\description{
\code{\link[=s2_bounds_rect]{s2_bounds_rect()}} returns a bounding latitude-longitude
rectangle that contains the region; \code{\link[=s2_bounds_cap]{s2_bounds_cap()}} returns a bounding circle
represented by a centre point (lat, lng) and an angle. The bound may not be tight
for points, polylines and geometry collections. The rectangle returned may depend on
the order of points or polylines. \code{lng_lo} values larger than \code{lng_hi} indicate
regions that span the antimeridian, see the Fiji example.
}
\examples{
s2_bounds_cap(s2_data_countries("Antarctica"))
s2_bounds_cap(s2_data_countries("Netherlands"))
s2_bounds_cap(s2_data_countries("Fiji"))
s2_bounds_rect(s2_data_countries("Antarctica"))
s2_bounds_rect(s2_data_countries("Netherlands"))
s2_bounds_rect(s2_data_countries("Fiji"))
}
s2/man/s2_lnglat.Rd 0000644 0001750 0001751 00000001742 14737212474 013677 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-lnglat.R
\name{s2_lnglat}
\alias{s2_lnglat}
\alias{as_s2_lnglat}
\alias{as_s2_lnglat.default}
\alias{as_s2_lnglat.wk_xy}
\alias{as_s2_lnglat.wk_xyz}
\title{Create an S2 LngLat Vector}
\usage{
s2_lnglat(lng, lat)
as_s2_lnglat(x, ...)
\method{as_s2_lnglat}{default}(x, ...)
\method{as_s2_lnglat}{wk_xy}(x, ...)
\method{as_s2_lnglat}{wk_xyz}(x, ...)
}
\arguments{
\item{lat, lng}{Vectors of latitude and longitude values in degrees.}
\item{x}{A \code{\link[=s2_lnglat]{s2_lnglat()}} vector or an object that can be coerced to one.}
\item{...}{Unused}
}
\value{
An object with class s2_lnglat
}
\description{
This class represents a latitude and longitude on the Earth's surface.
Most calculations in S2 convert this to a \code{\link[=as_s2_point]{as_s2_point()}}, which is a
unit vector representation of this value.
}
\examples{
s2_lnglat(45, -64) # Halifax, Nova Scotia!
as.data.frame(s2_lnglat(45, -64))
}
s2/man/as_s2_geography.Rd 0000644 0001750 0001751 00000005000 14737212474 015055 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-geography.R
\name{as_s2_geography}
\alias{as_s2_geography}
\alias{s2_geography}
\alias{as_s2_geography.s2_geography}
\alias{as_s2_geography.wk_xy}
\alias{as_s2_geography.wk_wkb}
\alias{as_s2_geography.WKB}
\alias{as_s2_geography.blob}
\alias{as_s2_geography.wk_wkt}
\alias{as_s2_geography.character}
\alias{as_s2_geography.logical}
\alias{as_wkb.s2_geography}
\alias{as_wkt.s2_geography}
\title{Create an S2 Geography Vector}
\usage{
as_s2_geography(x, ...)
s2_geography()
\method{as_s2_geography}{s2_geography}(x, ...)
\method{as_s2_geography}{wk_xy}(x, ...)
\method{as_s2_geography}{wk_wkb}(x, ..., oriented = FALSE, check = TRUE)
\method{as_s2_geography}{WKB}(x, ..., oriented = FALSE, check = TRUE)
\method{as_s2_geography}{blob}(x, ..., oriented = FALSE, check = TRUE)
\method{as_s2_geography}{wk_wkt}(x, ..., oriented = FALSE, check = TRUE)
\method{as_s2_geography}{character}(x, ..., oriented = FALSE, check = TRUE)
\method{as_s2_geography}{logical}(x, ...)
\method{as_wkb}{s2_geography}(x, ...)
\method{as_wkt}{s2_geography}(x, ...)
}
\arguments{
\item{x}{An object that can be converted to an s2_geography vector}
\item{...}{Unused}
\item{oriented}{TRUE if polygon ring directions are known to be correct
(i.e., exterior rings are defined counter clockwise and interior
rings are defined clockwise).}
\item{check}{Use \code{check = FALSE} to skip error on invalid geometries}
}
\value{
An object with class s2_geography
}
\description{
Geography vectors are arrays of points, lines, polygons, and/or collections
of these. Geography vectors assume coordinates are longitude and latitude
on a perfect sphere.
}
\details{
The coercion function \code{\link[=as_s2_geography]{as_s2_geography()}} is used to wrap the input
of most functions in the s2 package so that you can use other objects with
an unambiguious interpretation as a geography vector. Geography vectors
have a minimal \link[vctrs:vctrs-package]{vctrs} implementation, so you can
use these objects in tibble, dplyr, and other packages that use the vctrs
framework.
}
\seealso{
\code{\link[=s2_geog_from_wkb]{s2_geog_from_wkb()}}, \code{\link[=s2_geog_from_text]{s2_geog_from_text()}}, \code{\link[=s2_geog_point]{s2_geog_point()}},
\code{\link[=s2_make_line]{s2_make_line()}}, \code{\link[=s2_make_polygon]{s2_make_polygon()}} for other ways to
create geography vectors, and \code{\link[=s2_as_binary]{s2_as_binary()}} and \code{\link[=s2_as_text]{s2_as_text()}}
for other ways to export them.
}
s2/man/wk_handle.s2_geography.Rd 0000644 0001750 0001751 00000005120 14737212474 016330 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/wk-utils.R
\name{wk_handle.s2_geography}
\alias{wk_handle.s2_geography}
\alias{s2_geography_writer}
\alias{wk_writer.s2_geography}
\alias{s2_trans_point}
\alias{s2_trans_lnglat}
\alias{s2_projection_plate_carree}
\alias{s2_projection_mercator}
\alias{s2_hemisphere}
\alias{s2_world_plate_carree}
\alias{s2_projection_orthographic}
\title{Low-level wk filters and handlers}
\usage{
\method{wk_handle}{s2_geography}(
handleable,
handler,
...,
s2_projection = s2_projection_plate_carree(),
s2_tessellate_tol = Inf
)
s2_geography_writer(
oriented = FALSE,
check = TRUE,
projection = s2_projection_plate_carree(),
tessellate_tol = Inf
)
\method{wk_writer}{s2_geography}(handleable, ...)
s2_trans_point()
s2_trans_lnglat()
s2_projection_plate_carree(x_scale = 180)
s2_projection_mercator(x_scale = 20037508.3427892)
s2_hemisphere(centre)
s2_world_plate_carree(epsilon_east_west = 0, epsilon_north_south = 0)
s2_projection_orthographic(centre = s2_lnglat(0, 0))
}
\arguments{
\item{handleable}{A geometry vector (e.g., \code{\link[wk:wkb]{wkb()}}, \code{\link[wk:wkt]{wkt()}}, \code{\link[wk:xy]{xy()}},
\code{\link[wk:rct]{rct()}}, or \code{\link[sf:sfc]{sf::st_sfc()}}) for which \code{\link[wk:wk_handle]{wk_handle()}} is defined.}
\item{handler}{A \link[wk:wk_handle]{wk_handler} object.}
\item{...}{Passed to the \code{\link[wk:wk_handle]{wk_handle()}} method.}
\item{oriented}{TRUE if polygon ring directions are known to be correct
(i.e., exterior rings are defined counter clockwise and interior
rings are defined clockwise).}
\item{check}{Use \code{check = FALSE} to skip error on invalid geometries}
\item{projection, s2_projection}{One of \code{\link[=s2_projection_plate_carree]{s2_projection_plate_carree()}} or
\code{\link[=s2_projection_mercator]{s2_projection_mercator()}}}
\item{tessellate_tol, s2_tessellate_tol}{An angle in radians.
Points will not be added if a line segment is within this
distance of a point.}
\item{x_scale}{The maximum x value of the projection}
\item{centre}{The center point of the orthographic projection}
\item{epsilon_east_west, epsilon_north_south}{Use a positive number to
define the edges of a Cartesian world slightly inward from -180, -90,
180, 90. This may be used to define a world outline for a projection where
projecting at the extreme edges of the earth results in a non-finite value.}
}
\value{
\itemize{
\item \code{s2_projection_plate_carree()}, \code{s2_projection_mercator()}: An external pointer
to an S2 projection.
}
}
\description{
Low-level wk filters and handlers
}
s2/man/s2_earth_radius_meters.Rd 0000644 0001750 0001751 00000001423 14737212474 016443 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-earth.R
\name{s2_earth_radius_meters}
\alias{s2_earth_radius_meters}
\title{Earth Constants}
\usage{
s2_earth_radius_meters()
}
\description{
According to Yoder (1995), the radius of the earth is
6371.01 km. These functions are used to set the
default radis for functions that return a distance
or accept a distance as input
(e.g., \code{\link[=s2_distance]{s2_distance()}} and \code{\link[=s2_dwithin]{s2_dwithin()}}).
}
\examples{
s2_earth_radius_meters()
}
\references{
Yoder, C.F. 1995. "Astrometric and Geodetic Properties of Earth and the
Solar System" in Global Earth Physics, A Handbook of Physical Constants,
AGU Reference Shelf 1, American Geophysical Union, Table 2.
\doi{10.1029/RF001p0001}
}
s2/man/s2_plot.Rd 0000644 0001750 0001751 00000002563 14737212474 013376 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/plot.R
\name{s2_plot}
\alias{s2_plot}
\title{Plot S2 Geographies}
\usage{
s2_plot(
x,
...,
asp = 1,
xlab = "",
ylab = "",
rule = "evenodd",
add = FALSE,
plot_hemisphere = FALSE,
simplify = TRUE,
centre = NULL
)
}
\arguments{
\item{x}{A \code{\link[wk:wkb]{wkb()}} or \code{\link[wk:wkt]{wkt()}}}
\item{...}{Passed to plotting functions for features: \code{\link[graphics:points]{graphics::points()}}
for point and multipoint geometries, \code{\link[graphics:lines]{graphics::lines()}} for linestring
and multilinestring geometries, and \code{\link[graphics:polypath]{graphics::polypath()}} for polygon
and multipolygon geometries.}
\item{asp, xlab, ylab}{Passed to \code{\link[graphics:plot.default]{graphics::plot()}}}
\item{rule}{The rule to use for filling polygons (see \code{\link[graphics:polypath]{graphics::polypath()}})}
\item{add}{Should a new plot be created, or should \code{handleable} be added to the
existing plot?}
\item{plot_hemisphere}{Plot the outline of the earth}
\item{simplify}{Use \code{FALSE} to skip the simplification step}
\item{centre}{The longitude/latitude point of the centre of the
orthographic projection}
}
\value{
The input, invisibly
}
\description{
Plot S2 Geographies
}
\examples{
s2_plot(s2_data_countries())
s2_plot(s2_data_cities(), add = TRUE)
}
s2/man/s2_interpolate.Rd 0000644 0001750 0001751 00000003321 14737212474 014737 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-accessors.R, R/s2-transformers.R
\name{s2_project}
\alias{s2_project}
\alias{s2_project_normalized}
\alias{s2_interpolate}
\alias{s2_interpolate_normalized}
\title{Linear referencing}
\usage{
s2_project(x, y, radius = s2_earth_radius_meters())
s2_project_normalized(x, y)
s2_interpolate(x, distance, radius = s2_earth_radius_meters())
s2_interpolate_normalized(x, distance_normalized)
}
\arguments{
\item{x}{A simple polyline geography vector}
\item{y}{A simple point geography vector. The point will be
snapped to the nearest point on \code{x} for the purposes of
interpolation.}
\item{radius}{Radius of the earth. Defaults to the average radius of
the earth in meters as defined by \code{\link[=s2_earth_radius_meters]{s2_earth_radius_meters()}}.}
\item{distance}{A distance along \code{x} in \code{radius} units.}
\item{distance_normalized}{A \code{distance} normalized to \code{\link[=s2_length]{s2_length()}} of
\code{x}.}
}
\value{
\itemize{
\item \code{s2_interpolate()} returns the point on \code{x}, \code{distance} meters
along the line.
\item \code{s2_interpolate_normalized()} returns the point on \code{x} interpolated
to a fraction along the line.
\item \code{s2_project()} returns the \code{distance} that \code{point} occurs along \code{x}.
\item \code{s2_project_normalized()} returns the \code{distance_normalized} along \code{x}
where \code{point} occurs.
}
}
\description{
Linear referencing
}
\examples{
s2_project_normalized("LINESTRING (0 0, 0 90)", "POINT (0 22.5)")
s2_project("LINESTRING (0 0, 0 90)", "POINT (0 22.5)")
s2_interpolate_normalized("LINESTRING (0 0, 0 90)", 0.25)
s2_interpolate("LINESTRING (0 0, 0 90)", 2501890)
}
s2/man/s2-package.Rd 0000644 0001750 0001751 00000002566 14737212474 013734 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-package.R
\docType{package}
\name{s2-package}
\alias{s2}
\alias{s2-package}
\title{s2: Spherical Geometry Operators Using the S2 Geometry Library}
\description{
Provides R bindings for Google's s2 library for geometric calculations on the sphere. High-performance constructors and exporters provide high compatibility with existing spatial packages, transformers construct new geometries from existing geometries, predicates provide a means to select geometries based on spatial relationships, and accessors extract information about geometries.
}
\seealso{
Useful links:
\itemize{
\item \url{https://r-spatial.github.io/s2/}
\item \url{https://github.com/r-spatial/s2}
\item \url{http://s2geometry.io/}
\item Report bugs at \url{https://github.com/r-spatial/s2/issues}
}
}
\author{
\strong{Maintainer}: Edzer Pebesma \email{edzer.pebesma@uni-muenster.de} (\href{https://orcid.org/0000-0001-8049-7069}{ORCID})
Authors:
\itemize{
\item Dewey Dunnington \email{dewey@fishandwhistle.net} (\href{https://orcid.org/0000-0002-9415-4582}{ORCID})
\item Ege Rubak \email{rubak@math.aau.dk}
}
Other contributors:
\itemize{
\item Jeroen Ooms \email{jeroen.ooms@stat.ucla.edu} (configure script) [contributor]
\item Google, Inc. (Original s2geometry.io source code) [copyright holder]
}
}
\keyword{internal}
s2/man/s2_is_collection.Rd 0000644 0001750 0001751 00000007425 14737212474 015250 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-accessors.R
\name{s2_is_collection}
\alias{s2_is_collection}
\alias{s2_is_valid}
\alias{s2_is_valid_detail}
\alias{s2_dimension}
\alias{s2_num_points}
\alias{s2_is_empty}
\alias{s2_area}
\alias{s2_length}
\alias{s2_perimeter}
\alias{s2_x}
\alias{s2_y}
\alias{s2_distance}
\alias{s2_max_distance}
\title{S2 Geography Accessors}
\usage{
s2_is_collection(x)
s2_is_valid(x)
s2_is_valid_detail(x)
s2_dimension(x)
s2_num_points(x)
s2_is_empty(x)
s2_area(x, radius = s2_earth_radius_meters())
s2_length(x, radius = s2_earth_radius_meters())
s2_perimeter(x, radius = s2_earth_radius_meters())
s2_x(x)
s2_y(x)
s2_distance(x, y, radius = s2_earth_radius_meters())
s2_max_distance(x, y, radius = s2_earth_radius_meters())
}
\arguments{
\item{x, y}{\link[=as_s2_geography]{geography vectors}. These inputs
are passed to \code{\link[=as_s2_geography]{as_s2_geography()}}, so you can pass other objects
(e.g., character vectors of well-known text) directly.}
\item{radius}{Radius of the earth. Defaults to the average radius of
the earth in meters as defined by \code{\link[=s2_earth_radius_meters]{s2_earth_radius_meters()}}.}
}
\description{
Accessors extract information about \link[=as_s2_geography]{geography vectors}.
}
\examples{
# s2_is_collection() tests for multiple geometries in one feature
s2_is_collection(c("POINT (-64 45)", "MULTIPOINT ((-64 45), (8 72))"))
# s2_dimension() returns 0 for point, 1 for line, 2 for polygon
s2_dimension(
c(
"GEOMETRYCOLLECTION EMPTY",
"POINT (-64 45)",
"LINESTRING (-64 45, 8 72)",
"POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
"GEOMETRYCOLLECTION (POINT (-64 45), LINESTRING (-64 45, 8 72))"
)
)
# s2_num_points() counts points
s2_num_points(c("POINT (-64 45)", "LINESTRING (-64 45, 8 72)"))
# s2_is_empty tests for emptiness
s2_is_empty(c("POINT (-64 45)", "POINT EMPTY"))
# calculate area, length, and perimeter
s2_area("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))")
s2_perimeter("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))")
s2_length(s2_boundary("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))"))
# extract x and y coordinates from points
s2_x(c("POINT (-64 45)", "POINT EMPTY"))
s2_y(c("POINT (-64 45)", "POINT EMPTY"))
# calculate minimum and maximum distance between two geometries
s2_distance(
"POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
"POINT (-64 45)"
)
s2_max_distance(
"POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
"POINT (-64 45)"
)
}
\seealso{
BigQuery's geography function reference:
\itemize{
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_iscollection}{ST_ISCOLLECTION}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_dimension}{ST_DIMENSION}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_numpoints}{ST_NUMPOINTS}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_isempty}{ST_ISEMPTY}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_area}{ST_AREA}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_length}{ST_LENGTH}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_perimeter}{ST_PERIMETER}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_x}{ST_X}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_y}{ST_Y}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_distance}{ST_DISTANCE}
\item \href{https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_maxdistance}{ST_MAXDISTANCE}
}
}
s2/man/s2_data_example_wkt.Rd 0000644 0001750 0001751 00000000637 14737212474 015731 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/data.R
\docType{data}
\name{s2_data_example_wkt}
\alias{s2_data_example_wkt}
\title{Example Geometries}
\format{
An object of class \code{list} of length 29.
}
\usage{
s2_data_example_wkt
}
\description{
These geometries are toy examples useful for testing various coordinate
shuffling operations in the s2 package.
}
\keyword{datasets}
s2/man/s2_cell_is_valid.Rd 0000644 0001750 0001751 00000003305 14737212474 015204 0 ustar nilesh nilesh % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/s2-cell.R
\name{s2_cell_is_valid}
\alias{s2_cell_is_valid}
\alias{s2_cell_debug_string}
\alias{s2_cell_to_lnglat}
\alias{s2_cell_center}
\alias{s2_cell_boundary}
\alias{s2_cell_polygon}
\alias{s2_cell_vertex}
\alias{s2_cell_level}
\alias{s2_cell_is_leaf}
\alias{s2_cell_is_face}
\alias{s2_cell_area}
\alias{s2_cell_area_approx}
\alias{s2_cell_parent}
\alias{s2_cell_child}
\alias{s2_cell_edge_neighbour}
\alias{s2_cell_contains}
\alias{s2_cell_distance}
\alias{s2_cell_max_distance}
\alias{s2_cell_may_intersect}
\alias{s2_cell_common_ancestor_level}
\alias{s2_cell_common_ancestor_level_agg}
\title{S2 cell operators}
\usage{
s2_cell_is_valid(x)
s2_cell_debug_string(x)
s2_cell_to_lnglat(x)
s2_cell_center(x)
s2_cell_boundary(x)
s2_cell_polygon(x)
s2_cell_vertex(x, k)
s2_cell_level(x)
s2_cell_is_leaf(x)
s2_cell_is_face(x)
s2_cell_area(x, radius = s2_earth_radius_meters())
s2_cell_area_approx(x, radius = s2_earth_radius_meters())
s2_cell_parent(x, level = -1L)
s2_cell_child(x, k)
s2_cell_edge_neighbour(x, k)
s2_cell_contains(x, y)
s2_cell_distance(x, y, radius = s2_earth_radius_meters())
s2_cell_max_distance(x, y, radius = s2_earth_radius_meters())
s2_cell_may_intersect(x, y)
s2_cell_common_ancestor_level(x, y)
s2_cell_common_ancestor_level_agg(x, na.rm = FALSE)
}
\arguments{
\item{x, y}{An \code{\link[=s2_cell]{s2_cell()}} vector}
\item{k}{An integer between 0 and 3}
\item{radius}{The radius to use (e.g., \code{\link[=s2_earth_radius_meters]{s2_earth_radius_meters()}})}
\item{level}{An integer between 0 and 30, inclusive.}
\item{na.rm}{Remove NAs prior to computing aggregate?}
}
\description{
S2 cell operators
}
s2/README.md 0000644 0001750 0001751 00000020450 15010321446 012205 0 ustar nilesh nilesh
# s2
[](https://github.com/r-spatial/s2/actions/workflows/R-CMD-check.yaml)
[](https://app.codecov.io/gh/r-spatial/s2)
[](https://cran.r-project.org/package=s2)
[](https://www.r-pkg.org/pkg/s2)
The s2 R package provides bindings to Google’s
[S2Geometry](http://s2geometry.io) library. The package exposes an API
similar to Google’s [BigQuery Geography
API](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions),
whose functions also operate on spherical geometries. Package
[sf](https://cran.r-project.org/package=sf) uses this package by default
for nearly all its geometrical operations on objects with ellipsoidal
(unprojected) coordinates; in cases where it doesn’t, such as
`st_relate()`, it emits a warning.
This package is a complete rewrite of an earlier CRAN package s2 with
versions up to 0.4-2, for which the sources are found
[here](https://github.com/spatstat/s2/).
## Installation
You can install the released version of s2 from
[CRAN](https://CRAN.R-project.org) with:
``` r
install.packages("s2")
```
And the development version from [GitHub](https://github.com/) with:
``` r
# install.packages("remotes")
remotes::install_github("r-spatial/s2")
```
The S2 package requires [Abseil](https://github.com/abseil/abseil-cpp)
and OpenSSL. You can install these using a system package manager on
most platforms:
- Windows: Both OpenSSL and Abseil are available from RTools since R 4.3
- MacOS: `brew install openssl abseil`
- Debian/Ubuntu: `apt-get install libssl-dev libabsl-dev`
- Fedora: `dnf install openssl-devel abseil-cpp-devel`
- Alpine: `apk add abseil-cpp`
## Example
The s2 package provides geometry transformers and predicates similar to
those found in [GEOS](https://libgeos.org), except instead of assuming a
planar geometry, s2’s functions work in latitude and longitude and
assume a spherical geometry:
``` r
library(s2)
s2_contains(
# polygon containing much of the northern hemisphere
"POLYGON ((-63.5 44.6, -149.75 61.20, 116.4 40.2, 13.5 52.51, -63.5 44.6))",
# ...should contain the north pole
"POINT (0 90)"
)
#> [1] TRUE
```
The [sf package](https://r-spatial.github.io/sf/) uses s2 for geographic
coordinates by default (this can be confirmed by calling
`sf::sf_use_s2()`). The sf package also supports creating s2 vectors
using `as_s2_geography()`:
``` r
library(dplyr)
library(sf)
nc_s2 <- read_sf(system.file("shape/nc.shp", package = "sf")) %>%
mutate(geometry = as_s2_geography(geometry)) %>%
as_tibble() %>%
select(NAME, geometry)
nc_s2
#> # A tibble: 100 × 2
#> NAME geometry
#>
#> 1 Ashe POLYGON ((-81.4528885 36.2395859, -81.4310379 36.2607193, -81.41…
#> 2 Alleghany POLYGON ((-81.1766739 36.4154434, -81.1533661 36.4247398, -81.13…
#> 3 Surry POLYGON ((-80.4530106 36.2570877, -80.4353104 36.5510445, -80.61…
#> 4 Currituck MULTIPOLYGON (((-75.9419327 36.2943382, -75.9575119 36.2594528, …
#> 5 Northampton POLYGON ((-77.1419601 36.4170647, -77.1393204 36.4564781, -77.12…
#> 6 Hertford POLYGON ((-76.7074966 36.2661324, -76.7413483 36.3151665, -76.92…
#> 7 Camden POLYGON ((-76.0173492 36.3377304, -76.0328751 36.3359756, -76.04…
#> 8 Gates POLYGON ((-76.46035 36.3738976, -76.5024643 36.4522858, -76.4983…
#> 9 Warren POLYGON ((-78.1347198 36.2365837, -78.1096268 36.2135086, -78.05…
#> 10 Stokes POLYGON ((-80.0240555 36.5450249, -80.0480957 36.5471344, -80.43…
#> # ℹ 90 more rows
```
Use accessors to extract information about geometries:
``` r
nc_s2 %>%
mutate(
area = s2_area(geometry),
perimeter = s2_perimeter(geometry)
)
#> # A tibble: 100 × 4
#> NAME geometry area perimeter
#>
#> 1 Ashe POLYGON ((-81.4528885 36.2395859, -81.4310379 3… 1.14e9 141627.
#> 2 Alleghany POLYGON ((-81.1766739 36.4154434, -81.1533661 3… 6.11e8 119876.
#> 3 Surry POLYGON ((-80.4530106 36.2570877, -80.4353104 3… 1.42e9 160458.
#> 4 Currituck MULTIPOLYGON (((-75.9419327 36.2943382, -75.957… 6.94e8 301644.
#> 5 Northampton POLYGON ((-77.1419601 36.4170647, -77.1393204 3… 1.52e9 211794.
#> 6 Hertford POLYGON ((-76.7074966 36.2661324, -76.7413483 3… 9.68e8 160780.
#> 7 Camden POLYGON ((-76.0173492 36.3377304, -76.0328751 3… 6.16e8 150430.
#> 8 Gates POLYGON ((-76.46035 36.3738976, -76.5024643 36.… 9.03e8 123170.
#> 9 Warren POLYGON ((-78.1347198 36.2365837, -78.1096268 3… 1.18e9 141073.
#> 10 Stokes POLYGON ((-80.0240555 36.5450249, -80.0480957 3… 1.23e9 140583.
#> # ℹ 90 more rows
```
Use predicates to subset vectors:
``` r
nc_s2 %>%
filter(s2_contains(geometry, "POINT (-80.9313 35.6196)"))
#> # A tibble: 1 × 2
#> NAME geometry
#>
#> 1 Catawba POLYGON ((-80.9312744 35.6195908, -81.0035782 35.6970558, -81.0547791…
```
Use transformers to create new geometries:
``` r
nc_s2 %>%
mutate(geometry = s2_boundary(geometry))
#> # A tibble: 100 × 2
#> NAME geometry
#>
#> 1 Ashe LINESTRING (-81.4528885 36.2395859, -81.4310379 36.2607193, -81.…
#> 2 Alleghany LINESTRING (-81.1766739 36.4154434, -81.1533661 36.4247398, -81.…
#> 3 Surry LINESTRING (-80.4530106 36.2570877, -80.4353104 36.5510445, -80.…
#> 4 Currituck MULTILINESTRING ((-75.9419327 36.2943382, -75.9575119 36.2594528…
#> 5 Northampton LINESTRING (-77.1419601 36.4170647, -77.1393204 36.4564781, -77.…
#> 6 Hertford LINESTRING (-76.7074966 36.2661324, -76.7413483 36.3151665, -76.…
#> 7 Camden LINESTRING (-76.0173492 36.3377304, -76.0328751 36.3359756, -76.…
#> 8 Gates LINESTRING (-76.46035 36.3738976, -76.5024643 36.4522858, -76.49…
#> 9 Warren LINESTRING (-78.1347198 36.2365837, -78.1096268 36.2135086, -78.…
#> 10 Stokes LINESTRING (-80.0240555 36.5450249, -80.0480957 36.5471344, -80.…
#> # ℹ 90 more rows
```
Finally, use the WKB or WKT exporters to export to sf or some other
package:
``` r
nc_s2 %>%
mutate(geometry = st_as_sfc(s2_as_binary(geometry))) %>%
st_as_sf()
#> Simple feature collection with 100 features and 1 field
#> Geometry type: GEOMETRY
#> Dimension: XY
#> Bounding box: xmin: -84.32385 ymin: 33.88199 xmax: -75.45698 ymax: 36.58965
#> CRS: NA
#> # A tibble: 100 × 2
#> NAME geometry
#>
#> 1 Ashe POLYGON ((-81.45289 36.23959, -81.43104 36.26072, -81.41233 36.2…
#> 2 Alleghany POLYGON ((-81.17667 36.41544, -81.15337 36.42474, -81.1384 36.41…
#> 3 Surry POLYGON ((-80.45301 36.25709, -80.43531 36.55104, -80.61105 36.5…
#> 4 Currituck MULTIPOLYGON (((-75.94193 36.29434, -75.95751 36.25945, -75.9137…
#> 5 Northampton POLYGON ((-77.14196 36.41706, -77.13932 36.45648, -77.12733 36.4…
#> 6 Hertford POLYGON ((-76.7075 36.26613, -76.74135 36.31517, -76.92408 36.39…
#> 7 Camden POLYGON ((-76.01735 36.33773, -76.03288 36.33598, -76.04395 36.3…
#> 8 Gates POLYGON ((-76.46035 36.3739, -76.50246 36.45229, -76.49834 36.50…
#> 9 Warren POLYGON ((-78.13472 36.23658, -78.10963 36.21351, -78.05835 36.2…
#> 10 Stokes POLYGON ((-80.02406 36.54502, -80.0481 36.54713, -80.43531 36.55…
#> # ℹ 90 more rows
```
## Acknowledgment
This project gratefully acknowledges financial
[support](https://r-consortium.org/) from the
s2/R/ 0000755 0001750 0001751 00000000000 14737245171 011145 5 ustar nilesh nilesh s2/R/vctrs.R 0000644 0001750 0001751 00000001112 14737212474 012424 0 ustar nilesh nilesh
vec_proxy.s2_geography <- function(x, ...) {
unclass(x)
}
vec_restore.s2_geography <- function(x, ...) {
new_s2_geography(x)
}
vec_ptype_abbr.s2_geography <- function(x, ...) {
"s2_geography"
}
vec_proxy.s2_cell <- function(x, ...) {
unclass(x)
}
vec_restore.s2_cell <- function(x, ...) {
new_s2_cell(x)
}
vec_ptype_abbr.s2_cell <- function(x, ...) {
"s2cell"
}
vec_proxy.s2_cell_union <- function(x, ...) {
unclass(x)
}
vec_restore.s2_cell_union <- function(x, ...) {
new_s2_cell_union(x)
}
vec_ptype_abbr.s2_cell_union <- function(x, ...) {
"s2cellunion"
}
s2/R/s2-transformers.R 0000644 0001750 0001751 00000024314 14737245171 014343 0 ustar nilesh nilesh
#' S2 Geography Transformations
#'
#' These functions operate on one or more geography vectors and
#' return a geography vector.
#'
#' @inheritParams s2_is_collection
#' @param na.rm For aggregate calculations use `na.rm = TRUE`
#' to drop missing values.
#' @param grid_size The grid size to which coordinates should be snapped;
#' will be rounded to the nearest power of 10.
#' @param options An [s2_options()] object describing the polygon/polyline
#' model to use and the snap level.
#' @param distance The distance to buffer, in units of `radius`.
#' @param max_cells The maximum number of cells to approximate a buffer.
#' @param min_level The minimum cell level used to approximate a buffer
#' (1 - 30). Setting this value too high will result in unnecessarily
#' large geographies, but may help improve buffers along long, narrow
#' regions.
#' @param tolerance The minimum distance between vertexes to use when
#' simplifying a geography.
#'
#' @inheritSection s2_options Model
#'
#' @export
#'
#' @seealso
#' BigQuery's geography function reference:
#'
#' - [ST_BOUNDARY](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_boundary)
#' - [ST_CENTROID](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_centroid)
#' - [ST_CLOSESTPOINT](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_closestpoint)
#' - [ST_DIFFERENCE](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_difference)
#' - [ST_INTERSECTION](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_intersection)
#' - [ST_UNION](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_union)
#' - [ST_SNAPTOGRID](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_snaptogrid)
#' - [ST_SIMPLIFY](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_simplify)
#' - [ST_UNION_AGG](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_union_agg)
#' - [ST_CENTROID_AGG](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#s2_centroid_agg)
#'
#' @examples
#' # returns the boundary:
#' # empty for point, endpoints of a linestring,
#' # perimeter of a polygon
#' s2_boundary("POINT (-64 45)")
#' s2_boundary("LINESTRING (0 0, 10 0)")
#' s2_boundary("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")
#'
#' # returns the area-weighted centroid, element-wise
#' s2_centroid("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")
#' s2_centroid("LINESTRING (0 0, 10 0)")
#'
#' # s2_point_on_surface guarantees a point on surface
#' # Note: this is not the same as st_point_on_surface
#' s2_centroid("POLYGON ((0 0, 10 0, 1 1, 0 10, 0 0))")
#' s2_point_on_surface("POLYGON ((0 0, 10 0, 1 1, 0 10, 0 0))")
#'
#' # returns the unweighted centroid of the entire input
#' s2_centroid_agg(c("POINT (0 0)", "POINT (10 0)"))
#'
#' # returns the closest point on x to y
#' s2_closest_point(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POINT (0 90)" # north pole!
#' )
#'
#' # returns the shortest possible line between x and y
#' s2_minimum_clearance_line_between(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POINT (0 90)" # north pole!
#' )
#'
#' # binary operations: difference, symmetric difference, intersection and union
#' s2_difference(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))",
#' # 32 bit platforms may need to set snap rounding
#' s2_options(snap = s2_snap_level(30))
#' )
#'
#' s2_sym_difference(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))",
#' # 32 bit platforms may need to set snap rounding
#' s2_options(snap = s2_snap_level(30))
#' )
#'
#' s2_intersection(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))",
#' # 32 bit platforms may need to set snap rounding
#' s2_options(snap = s2_snap_level(30))
#' )
#'
#' s2_union(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))",
#' # 32 bit platforms may need to set snap rounding
#' s2_options(snap = s2_snap_level(30))
#' )
#'
#' # s2_convex_hull_agg builds the convex hull of a list of geometries
#' s2_convex_hull_agg(
#' c(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))"
#' )
#' )
#'
#' # use s2_union_agg() to aggregate geographies in a vector
#' s2_coverage_union_agg(
#' c(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POLYGON ((5 5, 15 5, 15 15, 5 15, 5 5))"
#' ),
#' # 32 bit platforms may need to set snap rounding
#' s2_options(snap = s2_snap_level(30))
#' )
#'
#' # snap to grid rounds coordinates to a specified grid size
#' s2_snap_to_grid("POINT (0.333333333333 0.666666666666)", 1e-2)
#'
#'
s2_boundary <- function(x) {
new_s2_geography(cpp_s2_boundary(as_s2_geography(x)))
}
#' @rdname s2_boundary
#' @export
s2_centroid <- function(x) {
new_s2_geography(cpp_s2_centroid(as_s2_geography(x)))
}
#' @rdname s2_boundary
#' @export
s2_closest_point <- function(x, y) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
new_s2_geography(cpp_s2_closest_point(recycled[[1]], recycled[[2]]))
}
#' @rdname s2_boundary
#' @export
s2_minimum_clearance_line_between <- function(x, y) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
new_s2_geography(cpp_s2_minimum_clearance_line_between(recycled[[1]], recycled[[2]]))
}
#' @rdname s2_boundary
#' @export
s2_difference <- function(x, y, options = s2_options()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
new_s2_geography(cpp_s2_difference(recycled[[1]], recycled[[2]], options))
}
#' @rdname s2_boundary
#' @export
s2_sym_difference <- function(x, y, options = s2_options()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
new_s2_geography(cpp_s2_sym_difference(recycled[[1]], recycled[[2]], options))
}
#' @rdname s2_boundary
#' @export
s2_intersection <- function(x, y, options = s2_options()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
new_s2_geography(cpp_s2_intersection(recycled[[1]], recycled[[2]], options))
}
#' @rdname s2_boundary
#' @export
s2_union <- function(x, y = NULL, options = s2_options()) {
x <- as_s2_geography(x)
if (is.null(y)) {
new_s2_geography(cpp_s2_unary_union(x, options))
} else {
recycled <- recycle_common(x, as_s2_geography(y))
new_s2_geography(cpp_s2_union(recycled[[1]], recycled[[2]], options))
}
}
#' @rdname s2_boundary
#' @export
s2_snap_to_grid <- function(x, grid_size) {
s2_rebuild(
x,
options = s2_options(
snap = s2_snap_precision(10^(-log10(grid_size))),
duplicate_edges = TRUE
)
)
}
#' @rdname s2_boundary
#' @export
s2_simplify <- function(x, tolerance, radius = s2_earth_radius_meters()) {
s2_rebuild(x, options = s2_options(snap_radius = tolerance / radius, simplify_edge_chains = TRUE))
}
#' @rdname s2_boundary
#' @export
s2_rebuild <- function(x, options = s2_options()) {
new_s2_geography(cpp_s2_rebuild(as_s2_geography(x), options))
}
#' @rdname s2_boundary
#' @export
s2_buffer_cells <- function(x, distance, max_cells = 1000, min_level = -1,
radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), distance / radius, max_cells, min_level)
new_s2_geography(cpp_s2_buffer_cells(recycled[[1]], recycled[[2]], recycled[[3]], recycled[[4]]))
}
#' @rdname s2_boundary
#' @export
s2_convex_hull <- function(x) {
new_s2_geography(cpp_s2_convex_hull(as_s2_geography(x)))
}
#' @rdname s2_boundary
#' @export
s2_centroid_agg <- function(x, na.rm = FALSE) {
new_s2_geography(cpp_s2_centroid_agg(as_s2_geography(x), naRm = na.rm))
}
#' @rdname s2_boundary
#' @export
s2_coverage_union_agg <- function(x, options = s2_options(), na.rm = FALSE) {
new_s2_geography(cpp_s2_coverage_union_agg(as_s2_geography(x), options, na.rm))
}
#' @rdname s2_boundary
#' @export
s2_rebuild_agg <- function(x, options = s2_options(), na.rm = FALSE) {
new_s2_geography(cpp_s2_rebuild_agg(as_s2_geography(x), options, na.rm))
}
#' @rdname s2_boundary
#' @export
s2_union_agg <- function(x, options = s2_options(), na.rm = FALSE) {
new_s2_geography(cpp_s2_union_agg(s2_union(x, options = options), options, na.rm))
}
#' @rdname s2_boundary
#' @export
s2_convex_hull_agg <- function(x, na.rm = FALSE) {
new_s2_geography(cpp_s2_convex_hull_agg(as_s2_geography(x), na.rm))
}
#' Linear referencing
#'
#' @param x A simple polyline geography vector
#' @param y A simple point geography vector. The point will be
#' snapped to the nearest point on `x` for the purposes of
#' interpolation.
#' @param distance A distance along `x` in `radius` units.
#' @param distance_normalized A `distance` normalized to [s2_length()] of
#' `x`.
#' @inheritParams s2_is_collection
#'
#' @return
#' - `s2_interpolate()` returns the point on `x`, `distance` meters
#' along the line.
#' - `s2_interpolate_normalized()` returns the point on `x` interpolated
#' to a fraction along the line.
#' - `s2_project()` returns the `distance` that `point` occurs along `x`.
#' - `s2_project_normalized()` returns the `distance_normalized` along `x`
#' where `point` occurs.
#' @export
#'
#' @examples
#' s2_project_normalized("LINESTRING (0 0, 0 90)", "POINT (0 22.5)")
#' s2_project("LINESTRING (0 0, 0 90)", "POINT (0 22.5)")
#' s2_interpolate_normalized("LINESTRING (0 0, 0 90)", 0.25)
#' s2_interpolate("LINESTRING (0 0, 0 90)", 2501890)
#'
s2_interpolate <- function(x, distance, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), distance / radius)
length <- cpp_s2_length(recycled[[1]])
new_s2_geography(
cpp_s2_interpolate_normalized(recycled[[1]], distance / radius / length)
)
}
#' @rdname s2_interpolate
#' @export
s2_interpolate_normalized <- function(x, distance_normalized) {
recycled <- recycle_common(as_s2_geography(x), distance_normalized)
new_s2_geography(
cpp_s2_interpolate_normalized(recycled[[1]], distance_normalized)
)
}
#' @rdname s2_boundary
#' @export
s2_point_on_surface <- function(x, na.rm = FALSE) {
new_s2_geography(cpp_s2_point_on_surface(as_s2_geography(x)))
}
s2/R/RcppExports.R 0000644 0001750 0001751 00000031524 14737231173 013563 0 ustar nilesh nilesh # Generated by using Rcpp::compileAttributes() -> do not edit by hand
# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
cpp_s2_init <- function() {
invisible(.Call(`_s2_cpp_s2_init`))
}
cpp_s2_is_collection <- function(geog) {
.Call(`_s2_cpp_s2_is_collection`, geog)
}
cpp_s2_is_valid <- function(geog) {
.Call(`_s2_cpp_s2_is_valid`, geog)
}
cpp_s2_is_valid_reason <- function(geog) {
.Call(`_s2_cpp_s2_is_valid_reason`, geog)
}
cpp_s2_dimension <- function(geog) {
.Call(`_s2_cpp_s2_dimension`, geog)
}
cpp_s2_num_points <- function(geog) {
.Call(`_s2_cpp_s2_num_points`, geog)
}
cpp_s2_is_empty <- function(geog) {
.Call(`_s2_cpp_s2_is_empty`, geog)
}
cpp_s2_area <- function(geog) {
.Call(`_s2_cpp_s2_area`, geog)
}
cpp_s2_length <- function(geog) {
.Call(`_s2_cpp_s2_length`, geog)
}
cpp_s2_perimeter <- function(geog) {
.Call(`_s2_cpp_s2_perimeter`, geog)
}
cpp_s2_x <- function(geog) {
.Call(`_s2_cpp_s2_x`, geog)
}
cpp_s2_y <- function(geog) {
.Call(`_s2_cpp_s2_y`, geog)
}
cpp_s2_project_normalized <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_project_normalized`, geog1, geog2)
}
cpp_s2_distance <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_distance`, geog1, geog2)
}
cpp_s2_max_distance <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_max_distance`, geog1, geog2)
}
cpp_s2_bounds_cap <- function(geog) {
.Call(`_s2_cpp_s2_bounds_cap`, geog)
}
cpp_s2_bounds_rect <- function(geog) {
.Call(`_s2_cpp_s2_bounds_rect`, geog)
}
cpp_s2_cell_union_normalize <- function(cellUnionVector) {
.Call(`_s2_cpp_s2_cell_union_normalize`, cellUnionVector)
}
cpp_s2_cell_union_is_na <- function(cellUnionVector) {
.Call(`_s2_cpp_s2_cell_union_is_na`, cellUnionVector)
}
cpp_s2_cell_union_contains <- function(cellUnionVector1, cellUnionVector2) {
.Call(`_s2_cpp_s2_cell_union_contains`, cellUnionVector1, cellUnionVector2)
}
cpp_s2_cell_union_contains_cell <- function(cellUnionVector, cellIdVector) {
.Call(`_s2_cpp_s2_cell_union_contains_cell`, cellUnionVector, cellIdVector)
}
cpp_s2_cell_union_intersects <- function(cellUnionVector1, cellUnionVector2) {
.Call(`_s2_cpp_s2_cell_union_intersects`, cellUnionVector1, cellUnionVector2)
}
cpp_s2_cell_union_intersection <- function(cellUnionVector1, cellUnionVector2) {
.Call(`_s2_cpp_s2_cell_union_intersection`, cellUnionVector1, cellUnionVector2)
}
cpp_s2_cell_union_union <- function(cellUnionVector1, cellUnionVector2) {
.Call(`_s2_cpp_s2_cell_union_union`, cellUnionVector1, cellUnionVector2)
}
cpp_s2_cell_union_difference <- function(cellUnionVector1, cellUnionVector2) {
.Call(`_s2_cpp_s2_cell_union_difference`, cellUnionVector1, cellUnionVector2)
}
cpp_s2_geography_from_cell_union <- function(cellUnionVector) {
.Call(`_s2_cpp_s2_geography_from_cell_union`, cellUnionVector)
}
cpp_s2_covering_cell_ids <- function(geog, min_level, max_level, max_cells, buffer, interior) {
.Call(`_s2_cpp_s2_covering_cell_ids`, geog, min_level, max_level, max_cells, buffer, interior)
}
cpp_s2_covering_cell_ids_agg <- function(geog, min_level, max_level, max_cells, buffer, interior, naRm) {
.Call(`_s2_cpp_s2_covering_cell_ids_agg`, geog, min_level, max_level, max_cells, buffer, interior, naRm)
}
cpp_s2_cell_sentinel <- function() {
.Call(`_s2_cpp_s2_cell_sentinel`)
}
cpp_s2_cell_from_string <- function(cellString) {
.Call(`_s2_cpp_s2_cell_from_string`, cellString)
}
cpp_s2_cell_from_lnglat <- function(lnglat) {
.Call(`_s2_cpp_s2_cell_from_lnglat`, lnglat)
}
cpp_s2_cell_to_lnglat <- function(cellId) {
.Call(`_s2_cpp_s2_cell_to_lnglat`, cellId)
}
cpp_s2_cell_to_cell_union <- function(cellId) {
.Call(`_s2_cpp_s2_cell_to_cell_union`, cellId)
}
cpp_s2_cell_is_na <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_is_na`, cellIdVector)
}
cpp_s2_cell_sort <- function(cellIdVector, decreasing) {
.Call(`_s2_cpp_s2_cell_sort`, cellIdVector, decreasing)
}
cpp_s2_cell_range <- function(cellIdVector, naRm) {
.Call(`_s2_cpp_s2_cell_range`, cellIdVector, naRm)
}
cpp_s2_cell_unique <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_unique`, cellIdVector)
}
cpp_s2_cell_to_string <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_to_string`, cellIdVector)
}
cpp_s2_cell_debug_string <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_debug_string`, cellIdVector)
}
cpp_s2_cell_is_valid <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_is_valid`, cellIdVector)
}
cpp_s2_cell_center <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_center`, cellIdVector)
}
cpp_s2_cell_polygon <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_polygon`, cellIdVector)
}
cpp_s2_cell_vertex <- function(cellIdVector, k) {
.Call(`_s2_cpp_s2_cell_vertex`, cellIdVector, k)
}
cpp_s2_cell_level <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_level`, cellIdVector)
}
cpp_s2_cell_area <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_area`, cellIdVector)
}
cpp_s2_cell_area_approx <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_area_approx`, cellIdVector)
}
cpp_s2_cell_parent <- function(cellIdVector, level) {
.Call(`_s2_cpp_s2_cell_parent`, cellIdVector, level)
}
cpp_s2_cell_child <- function(cellIdVector, k) {
.Call(`_s2_cpp_s2_cell_child`, cellIdVector, k)
}
cpp_s2_cell_edge_neighbour <- function(cellIdVector, k) {
.Call(`_s2_cpp_s2_cell_edge_neighbour`, cellIdVector, k)
}
cpp_s2_cell_cummax <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_cummax`, cellIdVector)
}
cpp_s2_cell_cummin <- function(cellIdVector) {
.Call(`_s2_cpp_s2_cell_cummin`, cellIdVector)
}
cpp_s2_cell_eq <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_eq`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_neq <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_neq`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_lt <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_lt`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_lte <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_lte`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_gte <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_gte`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_gt <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_gt`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_contains <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_contains`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_may_intersect <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_may_intersect`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_distance <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_distance`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_max_distance <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_max_distance`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_common_ancestor_level <- function(cellIdVector1, cellIdVector2) {
.Call(`_s2_cpp_s2_cell_common_ancestor_level`, cellIdVector1, cellIdVector2)
}
cpp_s2_cell_common_ancestor_level_agg <- function(cellId) {
.Call(`_s2_cpp_s2_cell_common_ancestor_level_agg`, cellId)
}
s2_geography_full <- function(x) {
.Call(`_s2_s2_geography_full`, x)
}
cpp_s2_geography_is_na <- function(geog) {
.Call(`_s2_cpp_s2_geography_is_na`, geog)
}
s2_lnglat_from_s2_point <- function(s2_point) {
.Call(`_s2_s2_lnglat_from_s2_point`, s2_point)
}
s2_point_from_s2_lnglat <- function(s2_lnglat) {
.Call(`_s2_s2_point_from_s2_lnglat`, s2_lnglat)
}
cpp_s2_closest_feature <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_closest_feature`, geog1, geog2)
}
cpp_s2_farthest_feature <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_farthest_feature`, geog1, geog2)
}
cpp_s2_closest_edges <- function(geog1, geog2, n, min_distance, max_distance) {
.Call(`_s2_cpp_s2_closest_edges`, geog1, geog2, n, min_distance, max_distance)
}
cpp_s2_may_intersect_matrix <- function(geog1, geog2, maxEdgesPerCell, maxFeatureCells, s2options) {
.Call(`_s2_cpp_s2_may_intersect_matrix`, geog1, geog2, maxEdgesPerCell, maxFeatureCells, s2options)
}
cpp_s2_contains_matrix <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_contains_matrix`, geog1, geog2, s2options)
}
cpp_s2_within_matrix <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_within_matrix`, geog1, geog2, s2options)
}
cpp_s2_intersects_matrix <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_intersects_matrix`, geog1, geog2, s2options)
}
cpp_s2_equals_matrix <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_equals_matrix`, geog1, geog2, s2options)
}
cpp_s2_touches_matrix <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_touches_matrix`, geog1, geog2, s2options)
}
cpp_s2_dwithin_matrix <- function(geog1, geog2, distance) {
.Call(`_s2_cpp_s2_dwithin_matrix`, geog1, geog2, distance)
}
cpp_s2_distance_matrix <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_distance_matrix`, geog1, geog2)
}
cpp_s2_max_distance_matrix <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_max_distance_matrix`, geog1, geog2)
}
cpp_s2_contains_matrix_brute_force <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_contains_matrix_brute_force`, geog1, geog2, s2options)
}
cpp_s2_within_matrix_brute_force <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_within_matrix_brute_force`, geog1, geog2, s2options)
}
cpp_s2_intersects_matrix_brute_force <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_intersects_matrix_brute_force`, geog1, geog2, s2options)
}
cpp_s2_disjoint_matrix_brute_force <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_disjoint_matrix_brute_force`, geog1, geog2, s2options)
}
cpp_s2_equals_matrix_brute_force <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_equals_matrix_brute_force`, geog1, geog2, s2options)
}
cpp_s2_dwithin_matrix_brute_force <- function(geog1, geog2, distance) {
.Call(`_s2_cpp_s2_dwithin_matrix_brute_force`, geog1, geog2, distance)
}
cpp_s2_intersects <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_intersects`, geog1, geog2, s2options)
}
cpp_s2_equals <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_equals`, geog1, geog2, s2options)
}
cpp_s2_contains <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_contains`, geog1, geog2, s2options)
}
cpp_s2_touches <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_touches`, geog1, geog2, s2options)
}
cpp_s2_dwithin <- function(geog1, geog2, distance) {
.Call(`_s2_cpp_s2_dwithin`, geog1, geog2, distance)
}
cpp_s2_prepared_dwithin <- function(geog1, geog2, distance) {
.Call(`_s2_cpp_s2_prepared_dwithin`, geog1, geog2, distance)
}
cpp_s2_intersects_box <- function(geog, lng1, lat1, lng2, lat2, detail, s2options) {
.Call(`_s2_cpp_s2_intersects_box`, geog, lng1, lat1, lng2, lat2, detail, s2options)
}
cpp_s2_intersection <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_intersection`, geog1, geog2, s2options)
}
cpp_s2_union <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_union`, geog1, geog2, s2options)
}
cpp_s2_difference <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_difference`, geog1, geog2, s2options)
}
cpp_s2_sym_difference <- function(geog1, geog2, s2options) {
.Call(`_s2_cpp_s2_sym_difference`, geog1, geog2, s2options)
}
cpp_s2_coverage_union_agg <- function(geog, s2options, naRm) {
.Call(`_s2_cpp_s2_coverage_union_agg`, geog, s2options, naRm)
}
cpp_s2_union_agg <- function(geog, s2options, naRm) {
.Call(`_s2_cpp_s2_union_agg`, geog, s2options, naRm)
}
cpp_s2_centroid_agg <- function(geog, naRm) {
.Call(`_s2_cpp_s2_centroid_agg`, geog, naRm)
}
cpp_s2_rebuild_agg <- function(geog, s2options, naRm) {
.Call(`_s2_cpp_s2_rebuild_agg`, geog, s2options, naRm)
}
cpp_s2_closest_point <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_closest_point`, geog1, geog2)
}
cpp_s2_minimum_clearance_line_between <- function(geog1, geog2) {
.Call(`_s2_cpp_s2_minimum_clearance_line_between`, geog1, geog2)
}
cpp_s2_centroid <- function(geog) {
.Call(`_s2_cpp_s2_centroid`, geog)
}
cpp_s2_point_on_surface <- function(geog) {
.Call(`_s2_cpp_s2_point_on_surface`, geog)
}
cpp_s2_boundary <- function(geog) {
.Call(`_s2_cpp_s2_boundary`, geog)
}
cpp_s2_rebuild <- function(geog, s2options) {
.Call(`_s2_cpp_s2_rebuild`, geog, s2options)
}
cpp_s2_unary_union <- function(geog, s2options) {
.Call(`_s2_cpp_s2_unary_union`, geog, s2options)
}
cpp_s2_interpolate_normalized <- function(geog, distanceNormalized) {
.Call(`_s2_cpp_s2_interpolate_normalized`, geog, distanceNormalized)
}
cpp_s2_buffer_cells <- function(geog, distance, maxCells, minLevel) {
.Call(`_s2_cpp_s2_buffer_cells`, geog, distance, maxCells, minLevel)
}
cpp_s2_convex_hull <- function(geog) {
.Call(`_s2_cpp_s2_convex_hull`, geog)
}
cpp_s2_convex_hull_agg <- function(geog, naRm) {
.Call(`_s2_cpp_s2_convex_hull_agg`, geog, naRm)
}
s2/R/data.R 0000644 0001750 0001751 00000003674 14737212474 012213 0 ustar nilesh nilesh
#' Low-resolution world boundaries, timezones, and cities
#'
#' Well-known binary versions of the [Natural Earth](https://www.naturalearthdata.com/)
#' low-resolution world boundaries and timezone boundaries.
#'
#' @param name The name of a country, continent, city, or `NULL`
#' for all features.
#' @param utc_offset_min,utc_offset_max Minimum and/or maximum timezone
#' offsets.
#'
#' @format A data.frame with columns `name` (character), and
#' `geometry` (wk_wkb)
#' @source [Natural Earth Data](https://www.naturalearthdata.com/)
#' @examples
#' head(s2_data_countries())
#' s2_data_countries("Germany")
#' s2_data_countries("Europe")
#'
#' head(s2_data_timezones())
#' s2_data_timezones(-4)
#'
#' head(s2_data_cities())
#' s2_data_cities("Cairo")
#'
"s2_data_tbl_countries"
#' @rdname s2_data_tbl_countries
"s2_data_tbl_timezones"
#' @rdname s2_data_tbl_countries
"s2_data_tbl_cities"
#' @rdname s2_data_tbl_countries
#' @export
s2_data_countries <- function(name = NULL) {
df <- s2::s2_data_tbl_countries
if (is.null(name)) {
wkb <- df$geometry
} else {
wkb <- df$geometry[(df$name %in% name) | (df$continent %in% name)]
}
as_s2_geography(wkb)
}
#' @rdname s2_data_tbl_countries
#' @export
s2_data_timezones <- function(utc_offset_min = NULL, utc_offset_max = utc_offset_min) {
df <- s2::s2_data_tbl_timezones
if (is.null(utc_offset_min)) {
wkb <- df$geometry
} else {
matches <- (df$utc_offset >= utc_offset_min) & (df$utc_offset <= utc_offset_max)
wkb <- df$geometry[matches]
}
as_s2_geography(wkb)
}
#' @rdname s2_data_tbl_countries
#' @export
s2_data_cities <- function(name = NULL) {
df <- s2::s2_data_tbl_cities
if (is.null(name)) {
wkb <- df$geometry
} else {
wkb <- df$geometry[df$name %in% name]
}
as_s2_geography(wkb)
}
#' Example Geometries
#'
#' These geometries are toy examples useful for testing various coordinate
#' shuffling operations in the s2 package.
#'
"s2_data_example_wkt"
s2/R/s2-matrix.R 0000644 0001750 0001751 00000016501 14737212474 013121 0 ustar nilesh nilesh
#' Matrix Functions
#'
#' These functions are similar to accessors and predicates, but instead of
#' recycling `x` and `y` to a common length and returning a vector of that
#' length, these functions return a vector of length `x` with each element
#' `i` containing information about how the entire vector `y` relates to
#' the feature at `x[i]`.
#'
#' @inheritParams s2_is_collection
#' @inheritParams s2_contains
#' @param x,y Geography vectors, coerced using [as_s2_geography()].
#' `x` is considered the source, where as `y` is considered the target.
#' @param k The number of closest edges to consider when searching. Note
#' that in S2 a point is also considered an edge.
#' @param min_distance The minimum distance to consider when searching for
#' edges. This filter is applied after the search is complete (i.e.,
#' may cause fewer than `k` values to be returned).
#' @param max_distance The maximum distance to consider when searching for
#' edges. This filter is applied before the search.
#' @param max_edges_per_cell For [s2_may_intersect_matrix()],
#' this values controls the nature of the index on `y`, with higher values
#' leading to coarser index. Values should be between 10 and 50; the default
#' of 50 is adequate for most use cases, but for specialized operations users
#' may wish to use a lower value to increase performance.
#' @param max_feature_cells For [s2_may_intersect_matrix()], this value
#' controls the approximation of `x` used to identify potential intersections
#' on `y`. The default value of 4 gives the best performance for most operations,
#' but for specialized operations users may wish to use a higher value to increase
#' performance.
#'
#' @return A vector of length `x`.
#' @export
#'
#' @seealso
#' See pairwise predicate functions (e.g., [s2_intersects()]).
#'
#' @examples
#' city_names <- c("Vatican City", "San Marino", "Luxembourg")
#' cities <- s2_data_cities(city_names)
#' country_names <- s2_data_tbl_countries$name
#' countries <- s2_data_countries()
#'
#' # closest feature returns y indices of the closest feature
#' # for each feature in x
#' country_names[s2_closest_feature(cities, countries)]
#'
#' # farthest feature returns y indices of the farthest feature
#' # for each feature in x
#' country_names[s2_farthest_feature(cities, countries)]
#'
#' # use s2_closest_edges() to find the k-nearest neighbours
#' nearest <- s2_closest_edges(cities, cities, k = 2, min_distance = 0)
#' city_names
#' city_names[unlist(nearest)]
#'
#' # predicate matrices
#' country_names[s2_intersects_matrix(cities, countries)[[1]]]
#'
#' # distance matrices
#' s2_distance_matrix(cities, cities)
#' s2_max_distance_matrix(cities, countries[1:4])
#'
s2_closest_feature <- function(x, y) {
cpp_s2_closest_feature(as_s2_geography(x), as_s2_geography(y))
}
#' @rdname s2_closest_feature
#' @export
s2_closest_edges <- function(x, y, k, min_distance = -1, max_distance = Inf,
radius = s2_earth_radius_meters()) {
stopifnot(k >= 1)
cpp_s2_closest_edges(
as_s2_geography(x),
as_s2_geography(y),
k,
min_distance / radius,
max_distance / radius
)
}
#' @rdname s2_closest_feature
#' @export
s2_farthest_feature <- function(x, y) {
cpp_s2_farthest_feature(as_s2_geography(x), as_s2_geography(y))
}
#' @rdname s2_closest_feature
#' @export
s2_distance_matrix <- function(x, y, radius = s2_earth_radius_meters()) {
cpp_s2_distance_matrix(as_s2_geography(x), as_s2_geography(y)) * radius
}
#' @rdname s2_closest_feature
#' @export
s2_max_distance_matrix <- function(x, y, radius = s2_earth_radius_meters()) {
cpp_s2_max_distance_matrix(as_s2_geography(x), as_s2_geography(y)) * radius
}
#' @rdname s2_closest_feature
#' @export
s2_contains_matrix <- function(x, y, options = s2_options(model = "open")) {
cpp_s2_contains_matrix(as_s2_geography(x), as_s2_geography(y), options)
}
#' @rdname s2_closest_feature
#' @export
s2_within_matrix <- function(x, y, options = s2_options(model = "open")) {
cpp_s2_within_matrix(as_s2_geography(x), as_s2_geography(y), options)
}
#' @rdname s2_closest_feature
#' @export
s2_covers_matrix <- function(x, y, options = s2_options(model = "closed")) {
cpp_s2_contains_matrix(as_s2_geography(x), as_s2_geography(y), options)
}
#' @rdname s2_closest_feature
#' @export
s2_covered_by_matrix <- function(x, y, options = s2_options(model = "closed")) {
cpp_s2_within_matrix(as_s2_geography(x), as_s2_geography(y), options)
}
#' @rdname s2_closest_feature
#' @export
s2_intersects_matrix <- function(x, y, options = s2_options()) {
cpp_s2_intersects_matrix(as_s2_geography(x), as_s2_geography(y), options)
}
#' @rdname s2_closest_feature
#' @export
s2_disjoint_matrix <- function(x, y, options = s2_options()) {
# disjoint is the odd one out, in that it requires a negation of intersects
# this is inconvenient to do on the C++ level, and is easier to maintain
# with setdiff() here (unless somebody complains that this is slow)
intersection <- cpp_s2_intersects_matrix(as_s2_geography(x), as_s2_geography(y), options)
Map(setdiff, list(seq_along(y)), intersection)
}
#' @rdname s2_closest_feature
#' @export
s2_equals_matrix <- function(x, y, options = s2_options()) {
cpp_s2_equals_matrix(as_s2_geography(x), as_s2_geography(y), options)
}
#' @rdname s2_closest_feature
#' @export
s2_touches_matrix <- function(x, y, options = s2_options()) {
cpp_s2_touches_matrix(as_s2_geography(x), as_s2_geography(y), options)
}
#' @rdname s2_closest_feature
#' @export
s2_dwithin_matrix <- function(x, y, distance, radius = s2_earth_radius_meters()) {
cpp_s2_dwithin_matrix(as_s2_geography(x), as_s2_geography(y), distance / radius)
}
#' @rdname s2_closest_feature
#' @export
s2_may_intersect_matrix <- function(x, y, max_edges_per_cell = 50, max_feature_cells = 4) {
cpp_s2_may_intersect_matrix(
as_s2_geography(x), as_s2_geography(y),
max_edges_per_cell, max_feature_cells,
s2_options()
)
}
# ------- for testing, non-indexed versions of matrix operators -------
s2_contains_matrix_brute_force <- function(x, y, options = s2_options()) {
cpp_s2_contains_matrix_brute_force(as_s2_geography(x), as_s2_geography(y), options)
}
s2_within_matrix_brute_force <- function(x, y, options = s2_options()) {
cpp_s2_within_matrix_brute_force(as_s2_geography(x), as_s2_geography(y), options)
}
s2_covers_matrix_brute_force <- function(x, y, options = s2_options(model = "closed")) {
cpp_s2_contains_matrix_brute_force(as_s2_geography(x), as_s2_geography(y), options)
}
s2_covered_by_matrix_brute_force <- function(x, y, options = s2_options(model = "closed")) {
cpp_s2_within_matrix_brute_force(as_s2_geography(x), as_s2_geography(y), options)
}
s2_intersects_matrix_brute_force <- function(x, y, options = s2_options()) {
cpp_s2_intersects_matrix_brute_force(as_s2_geography(x), as_s2_geography(y), options)
}
s2_disjoint_matrix_brute_force <- function(x, y, options = s2_options()) {
cpp_s2_disjoint_matrix_brute_force(as_s2_geography(x), as_s2_geography(y), options)
}
s2_equals_matrix_brute_force <- function(x, y, options = s2_options()) {
cpp_s2_equals_matrix_brute_force(as_s2_geography(x), as_s2_geography(y), options)
}
s2_dwithin_matrix_brute_force <- function(x, y, distance,
radius = s2_earth_radius_meters()) {
cpp_s2_dwithin_matrix_brute_force(
as_s2_geography(x),
as_s2_geography(y),
distance / radius
)
}
s2/R/wk-utils.R 0000644 0001750 0001751 00000007605 14737212474 013057 0 ustar nilesh nilesh
#' Low-level wk filters and handlers
#'
#' @inheritParams wk::wk_handle
#' @param projection,s2_projection One of [s2_projection_plate_carree()] or
#' [s2_projection_mercator()]
#' @param tessellate_tol,s2_tessellate_tol An angle in radians.
#' Points will not be added if a line segment is within this
#' distance of a point.
#' @param x_scale The maximum x value of the projection
#' @param centre The center point of the orthographic projection
#' @param epsilon_east_west,epsilon_north_south Use a positive number to
#' define the edges of a Cartesian world slightly inward from -180, -90,
#' 180, 90. This may be used to define a world outline for a projection where
#' projecting at the extreme edges of the earth results in a non-finite value.
#' @inheritParams as_s2_geography
#'
#' @return
#' - `s2_projection_plate_carree()`, `s2_projection_mercator()`: An external pointer
#' to an S2 projection.
#' @importFrom wk wk_handle
#' @export
#'
wk_handle.s2_geography <- function(handleable, handler, ...,
s2_projection = s2_projection_plate_carree(),
s2_tessellate_tol = Inf) {
stopifnot(is.null(s2_projection) || inherits(s2_projection, "s2_projection"))
attr(handleable, "s2_projection") <- s2_projection
if (identical(s2_tessellate_tol, Inf)) {
.Call(c_s2_handle_geography, handleable, wk::as_wk_handler(handler))
} else {
attr(handleable, "s2_tessellate_tol") <- as.double(s2_tessellate_tol)[1]
.Call(c_s2_handle_geography_tessellated, handleable, wk::as_wk_handler(handler))
}
}
#' @rdname wk_handle.s2_geography
#' @export
s2_geography_writer <- function(oriented = FALSE, check = TRUE,
projection = s2_projection_plate_carree(),
tessellate_tol = Inf) {
stopifnot(is.null(projection) || inherits(projection, "s2_projection"))
wk::new_wk_handler(
.Call(
c_s2_geography_writer_new,
as.logical(oriented)[1],
as.logical(check)[1],
projection,
as.double(tessellate_tol[1])
),
"s2_geography_writer"
)
}
#' @rdname wk_handle.s2_geography
#' @importFrom wk wk_writer
#' @method wk_writer s2_geography
#' @export
wk_writer.s2_geography <- function(handleable, ...) {
s2_geography_writer()
}
#' @rdname wk_handle.s2_geography
#' @export
s2_trans_point <- function() {
wk::new_wk_trans(.Call(c_s2_trans_s2_point_new))
}
#' @rdname wk_handle.s2_geography
#' @export
s2_trans_lnglat <- function() {
wk::new_wk_trans(.Call(c_s2_trans_s2_lnglat_new))
}
#' @rdname wk_handle.s2_geography
#' @export
s2_projection_plate_carree <- function(x_scale = 180) {
structure(
.Call(c_s2_projection_plate_carree, as.double(x_scale)[1]),
class = "s2_projection"
)
}
#' @rdname wk_handle.s2_geography
#' @export
s2_projection_mercator <- function(x_scale = 20037508.3427892) {
structure(
.Call(c_s2_projection_mercator, as.double(x_scale)[1]),
class = "s2_projection"
)
}
#' @rdname wk_handle.s2_geography
#' @export
s2_hemisphere <- function(centre) {
cap_to_polygon(centre, pi / 2)
}
#' @rdname wk_handle.s2_geography
#' @export
s2_world_plate_carree <- function(epsilon_east_west = 0, epsilon_north_south = 0) {
s2_make_polygon(
c(
-180 + epsilon_east_west, 0, 180 - epsilon_east_west,
180 - epsilon_east_west, 180 - epsilon_east_west, 0,
-180 + epsilon_east_west, -180 + epsilon_east_west
),
c(
-90 + epsilon_north_south, -90 + epsilon_north_south,
-90 + epsilon_north_south, 0, 90 - epsilon_north_south,
90 - epsilon_north_south, 90 - epsilon_north_south, 0
),
oriented = TRUE
)
}
#' @rdname wk_handle.s2_geography
#' @export
s2_projection_orthographic <- function(centre = s2_lnglat(0, 0)) {
centre <- as_s2_lnglat(centre)
centre <- as.matrix(centre)
structure(
.Call(c_s2_projection_orthographic, centre[1:2]),
class = "s2_projection"
)
}
s2/R/s2-options.R 0000644 0001750 0001751 00000014022 14737212474 013304 0 ustar nilesh nilesh
#' Geography Operation Options
#'
#' These functions specify defaults for options used to perform operations
#' and construct geometries. These are used in predicates (e.g., [s2_intersects()]),
#' and boolean operations (e.g., [s2_intersection()]) to specify the model for
#' containment and how new geometries should be constructed.
#'
#' @param model One of 'open', 'semi-open' (default for polygons),
#' or 'closed' (default for polylines). See section 'Model'
#' @param snap Use `s2_snap_identity()`, `s2_snap_distance()`, `s2_snap_level()`,
#' or `s2_snap_precision()` to specify how or if coordinate rounding should
#' occur.
#' @param snap_radius As opposed to the snap function, which specifies
#' the maximum distance a vertex should move, the snap radius (in radians) sets
#' the minimum distance between vertices of the output that don't cause vertices
#' to move more than the distance specified by the snap function. This can be used
#' to simplify the result of a boolean operation. Use -1 to specify that any
#' minimum distance is acceptable.
#' @param duplicate_edges Use `TRUE` to keep duplicate edges (e.g., duplicate
#' points).
#' @param edge_type One of 'directed' (default) or 'undirected'.
#' @param polyline_type One of 'path' (default) or 'walk'. If 'walk',
#' polylines that backtrack are preserved.
#' @param polyline_sibling_pairs One of 'discard' (default) or 'keep'.
#' @param simplify_edge_chains Use `TRUE` to remove vertices that are within
#' `snap_radius` of the original vertex.
#' @param split_crossing_edges Use `TRUE` to split crossing polyline edges
#' when creating geometries.
#' @param idempotent Use `FALSE` to apply snap even if snapping is not necessary
#' to satisfy vertex constraints.
#' @param validate Use `TRUE` to validate the result from the builder.
#' @param level A value from 0 to 30 corresponding to the cell level
#' at which snapping should occur.
#' @param distance A distance (in radians) denoting the maximum
#' distance a vertex should move in the snapping process.
#' @param precision A number by which coordinates should be multiplied
#' before being rounded. Rounded to the nearest exponent of 10.
#' @param dimensions A combination of 'point', 'polyline', and/or 'polygon'
#' that can used to constrain the output of [s2_rebuild()] or a
#' boolean operation.
#'
#' @section Model:
#' The geometry model indicates whether or not a geometry includes its boundaries.
#' Boundaries of line geometries are its end points.
#' OPEN geometries do not contain their boundary (`model = "open"`); CLOSED
#' geometries (`model = "closed"`) contain their boundary; SEMI-OPEN geometries
#' (`model = "semi-open"`) contain half of their boundaries, such that when two polygons
#' do not overlap or two lines do not cross, no point exist that belong to
#' more than one of the geometries. (This latter form, half-closed, is
#' not present in the OpenGIS "simple feature access" (SFA) standard nor DE9-IM on
#' which that is based). The default values for [s2_contains()] (open)
#' and covers/covered_by (closed) correspond to the SFA standard specification
#' of these operators.
#'
#' @export
#'
#' @examples
#' # use s2_options() to specify containment models, snap level
#' # layer creation options, and builder options
#' s2_options(model = "closed", snap = s2_snap_level(30))
#'
s2_options <- function(model = NULL,
snap = s2_snap_identity(),
snap_radius = -1,
duplicate_edges = FALSE,
edge_type = "directed",
validate = FALSE,
polyline_type = "path",
polyline_sibling_pairs = "keep",
simplify_edge_chains = FALSE,
split_crossing_edges = FALSE,
idempotent = FALSE,
dimensions = c("point", "polyline", "polygon")) {
# check snap radius (passing in a huge snap radius can cause problems)
if (snap_radius > 3) {
stop(
"Snap radius is too large. Did you pass in a snap radius in meters instead of radians?",
call. = FALSE
)
}
structure(
list(
# model needs to be "unset" by default because there are differences in polygon
# and polyline handling by default that are good defaults to preserve
model = if (is.null(model)) -1 else match_option(model[1], c("open", "semi-open", "closed"), "model"),
snap = snap,
snap_radius = snap_radius,
duplicate_edges = duplicate_edges,
edge_type = match_option(edge_type[1], c("directed", "undirected"), "edge_type"),
validate = validate,
polyline_type = match_option(polyline_type[1], c("path", "walk"), "polyline_type"),
polyline_sibling_pairs = match_option(
polyline_sibling_pairs,
c("discard", "keep"),
"polyline_sibling_pairs"
),
simplify_edge_chains = simplify_edge_chains,
split_crossing_edges = split_crossing_edges,
idempotent = idempotent,
dimensions = match_option(dimensions, c("point", "polyline", "polygon"), "dimensions")
),
class = "s2_options"
)
}
#' @rdname s2_options
#' @export
s2_snap_identity <- function() {
structure(list(), class = "snap_identity")
}
#' @rdname s2_options
#' @export
s2_snap_level <- function(level) {
if (level > 30) {
stop("`level` must be an intger between 1 and 30", call. = FALSE)
}
structure(list(level = level), class = "snap_level")
}
#' @rdname s2_options
#' @export
s2_snap_precision <- function(precision) {
stopifnot(precision <= 1e17) # https://github.com/r-spatial/s2/issues/248
structure(list(exponent = round(log10(precision))), class = "snap_precision")
}
#' @rdname s2_options
#' @export
s2_snap_distance <- function(distance) {
structure(list(distance = distance), class = "snap_distance")
}
match_option <- function(x, options, arg) {
result <- match(x, options)
if (any(is.na(result))) {
stop(
sprintf("`%s` must be one of %s", arg, paste0('"', options, '"', collapse = ", ")),
call. = FALSE
)
}
result
}
s2/R/s2-predicates.R 0000644 0001750 0001751 00000013066 14737212474 013743 0 ustar nilesh nilesh
#' S2 Geography Predicates
#'
#' These functions operate two geography vectors (pairwise), and return
#' a logical vector.
#'
#' @inheritParams s2_is_collection
#' @inheritParams s2_boundary
#' @param distance A distance on the surface of the earth in the same units
#' as `radius`.
#' @param lng1,lat1,lng2,lat2 A latitude/longitude range
#' @param detail The number of points with which to approximate
#' non-geodesic edges.
#'
#' @inheritSection s2_options Model
#'
#' @export
#'
#' @seealso
#' Matrix versions of these predicates (e.g., [s2_intersects_matrix()]).
#'
#' BigQuery's geography function reference:
#'
#' - [ST_CONTAINS](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_contains)
#' - [ST_COVEREDBY](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_coveredby)
#' - [ST_COVERS](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_covers)
#' - [ST_DISJOINT](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_disjoint)
#' - [ST_EQUALS](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_equals)
#' - [ST_INTERSECTS](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_intersects)
#' - [ST_INTERSECTSBOX](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_intersectsbox)
#' - [ST_TOUCHES](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_touches)
#' - [ST_WITHIN](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_within)
#' - [ST_DWITHIN](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_dwithin)
#'
#' @examples
#' s2_contains(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c("POINT (5 5)", "POINT (-1 1)")
#' )
#'
#' s2_within(
#' c("POINT (5 5)", "POINT (-1 1)"),
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))"
#' )
#'
#' s2_covered_by(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c("POINT (5 5)", "POINT (-1 1)")
#' )
#'
#' s2_covers(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c("POINT (5 5)", "POINT (-1 1)")
#' )
#'
#' s2_disjoint(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c("POINT (5 5)", "POINT (-1 1)")
#' )
#'
#' s2_intersects(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c("POINT (5 5)", "POINT (-1 1)")
#' )
#'
#' s2_equals(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' "POLYGON ((10 0, 10 10, 0 10, 0 0, 10 0))",
#' "POLYGON ((-1 -1, 10 0, 10 10, 0 10, -1 -1))"
#' )
#' )
#'
#' s2_intersects(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c("POINT (5 5)", "POINT (-1 1)")
#' )
#'
#' s2_intersects_box(
#' c("POINT (5 5)", "POINT (-1 1)"),
#' 0, 0, 10, 10
#' )
#'
#' s2_touches(
#' "POLYGON ((0 0, 0 1, 1 1, 0 0))",
#' c("POINT (0 0)", "POINT (0.5 0.75)", "POINT (0 0.5)")
#' )
#'
#' s2_dwithin(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c("POINT (5 5)", "POINT (-1 1)"),
#' 0 # distance in meters
#' )
#'
#' s2_dwithin(
#' "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
#' c("POINT (5 5)", "POINT (-1 1)"),
#' 1e6 # distance in meters
#' )
#'
s2_contains <- function(x, y, options = s2_options(model = "open")) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
cpp_s2_contains(recycled[[1]], recycled[[2]], options)
}
#' @rdname s2_contains
#' @export
s2_within <- function(x, y, options = s2_options(model = "open")) {
s2_contains(y, x, options)
}
#' @rdname s2_contains
#' @export
s2_covered_by <- function(x, y, options = s2_options(model = "closed")) {
s2_covers(y, x, options)
}
#' @rdname s2_contains
#' @export
s2_covers <- function(x, y, options = s2_options(model = "closed")) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
cpp_s2_contains(recycled[[1]], recycled[[2]], options)
}
#' @rdname s2_contains
#' @export
s2_disjoint <- function(x, y, options = s2_options()) {
!s2_intersects(x, y, options)
}
#' @rdname s2_contains
#' @export
s2_intersects <- function(x, y, options = s2_options()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
cpp_s2_intersects(recycled[[1]], recycled[[2]], options)
}
#' @rdname s2_contains
#' @export
s2_equals <- function(x, y, options = s2_options()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
cpp_s2_equals(recycled[[1]], recycled[[2]], options)
}
#' @rdname s2_contains
#' @export
s2_intersects_box <- function(x, lng1, lat1, lng2, lat2, detail = 1000, options = s2_options()) {
recycled <- recycle_common(as_s2_geography(x), lng1, lat1, lng2, lat2, detail)
cpp_s2_intersects_box(
recycled[[1]],
recycled[[2]], recycled[[3]],
recycled[[4]], recycled[[5]],
detail = recycled[[6]],
s2options = options
)
}
#' @rdname s2_contains
#' @export
s2_touches <- function(x, y, options = s2_options()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
cpp_s2_touches(recycled[[1]], recycled[[2]], options)
}
#' @rdname s2_contains
#' @export
s2_dwithin <- function(x, y, distance, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y), distance / radius)
cpp_s2_dwithin(recycled[[1]], recycled[[2]], recycled[[3]])
}
#' @rdname s2_contains
#' @export
s2_prepared_dwithin <- function(x, y, distance, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y), distance / radius)
cpp_s2_prepared_dwithin(recycled[[1]], recycled[[2]], recycled[[3]])
}
s2/R/plot.R 0000644 0001750 0001751 00000007563 14737212474 012261 0 ustar nilesh nilesh
#' Plot S2 Geographies
#'
#' @inheritParams wk::wk_plot
#' @param plot_hemisphere Plot the outline of the earth
#' @param centre The longitude/latitude point of the centre of the
#' orthographic projection
#' @param simplify Use `FALSE` to skip the simplification step
#'
#' @return The input, invisibly
#' @export
#'
#' @examples
#' s2_plot(s2_data_countries())
#' s2_plot(s2_data_cities(), add = TRUE)
#'
s2_plot <- function(x, ..., asp = 1, xlab = "", ylab = "",
rule = "evenodd", add = FALSE,
plot_hemisphere = FALSE,
simplify = TRUE,
centre = NULL) {
x <- as_s2_geography(x)
if (add) {
last <- last_plot_env$centre
centre <- if (is.null(last)) s2_lnglat(0, 0) else last
} else if (is.null(centre)) {
centre <- s2_centroid_agg(x, na.rm = TRUE)
}
centre <- as_s2_lnglat(centre)
projection <- s2_projection_orthographic(centre)
hemisphere_bounds_poly <- cap_to_polygon(centre, (pi / 2) - 1e-5)
if (plot_hemisphere) {
bbox_projected <- wk::rct(-1, -1, 1, 1)
} else if (!add) {
bbox_projected <- wk::wk_handle(
x,
wk::wk_bbox_handler(),
s2_projection = projection,
s2_tessellate_tol = s2_tessellate_tol_default()
)
}
wk::wk_plot(
wk::xy(),
bbox = bbox_projected,
asp = asp, xlab = xlab, ylab = ylab,
add = add
)
if (!add) {
last_plot_env$centre <- centre
}
if (plot_hemisphere) {
wk::wk_plot(wk::crc(0, 0, 1), add = TRUE)
}
# estimate resolution. In user coords, this can be though of in radians
# (at the centre of the plot)
usr <- graphics::par("usr")
usr_x <- usr[1:2]
usr_y <- usr[3:4]
device_x <- graphics::grconvertX(usr_x, to = "device")
device_y <- graphics::grconvertY(usr_y, to = "device")
scale_x <- diff(device_x) / diff(usr_x)
scale_y <- diff(device_y) / diff(usr_y)
scale <- min(abs(scale_x), abs(scale_y))
resolution_usr_rad <- 0.25 / scale
# limit output to dimensions in input
dimensions_in_input <- setdiff(unique(s2_dimension(x)), NA_character_)
if (simplify) {
x_hemisphere <- s2_intersection(
x,
hemisphere_bounds_poly,
options = s2_options(
snap = s2_snap_distance(resolution_usr_rad),
snap_radius = resolution_usr_rad,
simplify_edge_chains = TRUE,
dimensions = c("point", "polyline", "polygon")[dimensions_in_input + 1]
)
)
} else {
x_hemisphere <- s2_intersection(
x,
hemisphere_bounds_poly,
options = s2_options(
dimensions = c("point", "polyline", "polygon")[dimensions_in_input + 1]
)
)
}
x_hemisphere[s2_is_empty(x_hemisphere)] <- as_s2_geography("POINT EMPTY")
x_hemisphere_planar <- wk::wk_handle(
x_hemisphere,
wk::wkb_writer(),
s2_projection = projection,
# if this is too small we can get a stack overflow since the
# tessellation is recursive
s2_tessellate_tol = max(0.002, resolution_usr_rad * 4)
)
wk::wk_plot(
x_hemisphere_planar,
...,
rule = rule,
add = TRUE
)
invisible(x)
}
#' @export
plot.s2_geography <- function(x, ...) {
s2_plot(x, ...)
}
#' @export
plot.s2_cell_union <- function(x, ...) {
s2_plot(x, ...)
invisible(x)
}
#' @export
plot.s2_cell <- function(x, ...) {
if (all(s2_cell_is_leaf(x), na.rm = TRUE)) {
s2_plot(s2_cell_center(x), ...)
} else {
s2_plot(s2_cell_polygon(x), ...)
}
invisible(x)
}
cap_to_polygon <- function(centre = s2_lnglat(0, 0), radius_rad) {
centre <- as_s2_lnglat(centre)
rad_proj <- sin(radius_rad)
points <- wk::xy(
c(0, rad_proj, 0, -rad_proj, 0),
c(rad_proj, 0, -rad_proj, 0, rad_proj)
)
points_s2 <- wk::wk_handle(
points,
s2_geography_writer(
projection = s2_projection_orthographic(centre)
)
)
s2_make_polygon(s2_x(points_s2), s2_y(points_s2))
}
last_plot_env <- new.env(parent = emptyenv())
last_plot_env$centre <- NULL
s2/R/s2-geography.R 0000644 0001750 0001751 00000013147 14737212474 013605 0 ustar nilesh nilesh
#' Create an S2 Geography Vector
#'
#' Geography vectors are arrays of points, lines, polygons, and/or collections
#' of these. Geography vectors assume coordinates are longitude and latitude
#' on a perfect sphere.
#'
#' The coercion function [as_s2_geography()] is used to wrap the input
#' of most functions in the s2 package so that you can use other objects with
#' an unambiguious interpretation as a geography vector. Geography vectors
#' have a minimal [vctrs][vctrs::vctrs-package] implementation, so you can
#' use these objects in tibble, dplyr, and other packages that use the vctrs
#' framework.
#'
#' @param x An object that can be converted to an s2_geography vector
#' @param oriented TRUE if polygon ring directions are known to be correct
#' (i.e., exterior rings are defined counter clockwise and interior
#' rings are defined clockwise).
#' @param check Use `check = FALSE` to skip error on invalid geometries
#' @param ... Unused
#'
#' @return An object with class s2_geography
#' @export
#'
#' @seealso
#' [s2_geog_from_wkb()], [s2_geog_from_text()], [s2_geog_point()],
#' [s2_make_line()], [s2_make_polygon()] for other ways to
#' create geography vectors, and [s2_as_binary()] and [s2_as_text()]
#' for other ways to export them.
#'
as_s2_geography <- function(x, ...) {
UseMethod("as_s2_geography")
}
#' @rdname as_s2_geography
#' @export
s2_geography <- function() {
new_s2_geography(list())
}
#' @rdname as_s2_geography
#' @export
as_s2_geography.s2_geography <- function(x, ...) {
x
}
#' @rdname as_s2_geography
#' @export
as_s2_geography.wk_xy <- function(x, ...) {
x <- as_s2_lnglat(x)
df <- unclass(x)
s2_geog_point(df[[1]], df[[2]])
}
#' @rdname as_s2_geography
#' @export
as_s2_geography.wk_wkb <- function(x, ..., oriented = FALSE, check = TRUE) {
if (identical(wk::wk_is_geodesic(x), FALSE)) {
# points and an empty vector are OK and shouldn't trigger an error
meta <- wk::wk_meta(x)
if (!all(meta$geometry_type %in% c(1, 4, NA), na.rm = TRUE)) {
stop(
paste0(
"Can't create s2_geography from Cartesian wkb().\n",
"Use `wk_set_geodesic(x, TRUE)` to assert that edges can be\n",
"interpolated along the sphere."
),
call. = FALSE
)
}
}
wk::wk_handle(
x,
s2_geography_writer(oriented = oriented, check = check)
)
}
#' @rdname as_s2_geography
#' @export
as_s2_geography.WKB <- function(x, ..., oriented = FALSE, check = TRUE) {
s2_geog_from_wkb(x, oriented = oriented, check = check)
}
#' @rdname as_s2_geography
#' @export
as_s2_geography.blob <- function(x, ..., oriented = FALSE, check = TRUE) {
s2_geog_from_wkb(x, oriented = oriented, check = check)
}
#' @rdname as_s2_geography
#' @export
as_s2_geography.wk_wkt <- function(x, ..., oriented = FALSE, check = TRUE) {
if (identical(wk::wk_is_geodesic(x), FALSE)) {
# points and an empty vector are OK and shouldn't trigger an error
meta <- wk::wk_meta(x)
if (!all(meta$geometry_type %in% c(1, 4, NA), na.rm = TRUE)) {
stop(
paste0(
"Can't create s2_geography from Cartesian wkt().\n",
"Use `wk_set_geodesic(x, TRUE)` to assert that edges can be\n",
"interpolated along the sphere."
),
call. = FALSE
)
}
}
wk::wk_handle(
x,
s2_geography_writer(oriented = oriented, check = check)
)
}
#' @rdname as_s2_geography
#' @export
as_s2_geography.character <- function(x, ..., oriented = FALSE, check = TRUE) {
s2_geog_from_text(x, oriented = oriented, check = check)
}
#' @rdname as_s2_geography
#' @export
as_s2_geography.logical <- function(x, ...) {
stopifnot(isTRUE(x))
new_s2_geography(s2_geography_full(TRUE))
}
#' @importFrom wk as_wkb
#' @rdname as_s2_geography
#' @export
as_wkb.s2_geography <- function(x, ...) {
wkb <- wk::wk_handle(x, wk::wkb_writer())
wk::wk_is_geodesic(wkb) <- TRUE
wk::wk_crs(wkb) <- wk::wk_crs_longlat()
wkb
}
#' @importFrom wk as_wkt
#' @rdname as_s2_geography
#' @export
as_wkt.s2_geography <- function(x, ...) {
wkt <- wk::wk_handle(x, wk::wkt_writer())
wk::wk_is_geodesic(wkt) <- TRUE
wk::wk_crs(wkt) <- wk::wk_crs_longlat()
wkt
}
#' @importFrom wk wk_crs
#' @export
wk_crs.s2_geography <- function(x) {
wk::wk_crs_longlat()
}
#' @importFrom wk wk_set_crs
#' @export
wk_set_crs.s2_geography <- function(x, crs) {
if (!wk::wk_crs_equal(crs, wk::wk_crs(x))) {
warning("Setting the crs of s2_geography() is not supported")
}
x
}
#' @importFrom wk wk_is_geodesic
#' @export
wk_is_geodesic.s2_geography <- function(x) {
TRUE
}
#' @importFrom wk wk_set_geodesic
#' @export
wk_set_geodesic.s2_geography <- function(x, geodesic) {
if (!isTRUE(geodesic)) {
stop("Can't set geodesic of s2_geography to FALSE")
}
x
}
new_s2_geography <- function(x) {
structure(x, class = c("s2_geography", "wk_vctr"))
}
#' @export
is.na.s2_geography <- function(x) {
cpp_s2_geography_is_na(x)
}
#' @export
`[<-.s2_geography` <- function(x, i, value) {
x <- unclass(x)
x[i] <- as_s2_geography(value)
new_s2_geography(x)
}
#' @export
`[[<-.s2_geography` <- function(x, i, value) {
x <- unclass(x)
x[i] <- as_s2_geography(value)
new_s2_geography(x)
}
#' @export
format.s2_geography <- function(x, ..., max_coords = 5, precision = 9, trim = TRUE) {
wk::wk_format(x, precision = precision, max_coords = max_coords, trim = trim)
}
# this is what gets called by the RStudio viewer, for which
# format() is best suited (s2_as_text() is more explicit for WKT output)
#' @export
as.character.s2_geography <- function(x, ..., max_coords = 5, precision = 9, trim = TRUE) {
format(x, ..., max_coords = max_coords, precision = precision, trim = trim)
}
s2/R/s2-package.R 0000644 0001750 0001751 00000000417 14737212474 013207 0 ustar nilesh nilesh #' @keywords internal
"_PACKAGE"
# The following block is used by usethis to automatically manage
# roxygen namespace tags. Modify with care!
## usethis namespace: start
#' @useDynLib s2, .registration = TRUE
#' @importFrom Rcpp sourceCpp
## usethis namespace: end
NULL
s2/R/s2-point.R 0000644 0001750 0001751 00000002603 14737212474 012744 0 ustar nilesh nilesh
#' Create an S2 Point Vector
#'
#' In S2 terminology, a "point" is a 3-dimensional unit vector representation
#' of an [s2_point()]. Internally, all s2 objects are stored as
#' 3-dimensional unit vectors.
#'
#' @param x,y,z Vectors of latitude and longitude values in degrees.
#' @param ... Unused
#'
#' @return An object with class s2_point
#' @export
#'
#' @examples
#' point <- s2_lnglat(-64, 45) # Halifax, Nova Scotia!
#' as_s2_point(point)
#' as.data.frame(as_s2_point(point))
#'
s2_point <- function(x, y, z) {
wk::xyz(x, y, z, crs = s2_point_crs())
}
#' @rdname s2_point
#' @export
s2_point_crs <- function() {
structure(list(), class = "s2_point_crs")
}
#' @export
format.s2_point_crs <- function(x, ...) {
"s2_point_crs"
}
#' @rdname s2_point
#' @export
as_s2_point <- function(x, ...) {
UseMethod("as_s2_point")
}
#' @rdname s2_point
#' @export
as_s2_point.default <- function(x, ...) {
as_s2_point(wk::as_xy(x))
}
#' @rdname s2_point
#' @export
as_s2_point.wk_xy <- function(x, ...) {
stopifnot(wk::wk_crs_equal(wk::wk_crs(x), wk::wk_crs_longlat()))
wk::new_wk_xyz(
s2_point_from_s2_lnglat(x),
crs = s2_point_crs()
)
}
#' @rdname s2_point
#' @export
as_s2_point.wk_xyz <- function(x, ...) {
wk::wk_set_crs(
wk::as_xy(x, dims = c("x", "y", "z")),
s2_point_crs()
)
}
#' @export
as_s2_point.character <- function(x, ...) {
as_s2_point(wk::new_wk_wkt(x))
}
s2/R/utils.R 0000644 0001750 0001751 00000004405 14737212474 012433 0 ustar nilesh nilesh
new_data_frame <- function(x) {
structure(x, row.names = c(NA, length(x[[1]])), class = "data.frame")
}
recycle_common <- function(...) {
dots <- list(...)
lengths <- vapply(dots, length, integer(1))
non_constant_lengths <- unique(lengths[lengths != 1])
if (length(non_constant_lengths) == 0) {
final_length <- 1
} else if(length(non_constant_lengths) == 1) {
final_length <- non_constant_lengths
} else {
lengths_label <- paste0(non_constant_lengths, collapse = ", ")
stop(sprintf("Incompatible lengths: %s", lengths_label))
}
lapply(dots, rep_len, final_length)
}
# The problems object is generated when building or processing an s2_geography():
# instead of attaching to the object as an attribute, this function is
# called from Rcpp if there were any problems to format them in a
# human-readable way. Theoretically one could change this to only warn
# instead of stop (error values are set to NA/NULL).
stop_problems_create <- function(feature_id, problem) {
n <- length(feature_id)
feature_label <- if (n != 1) "features" else "feature"
stop_problems(
feature_id,
problem,
sprintf("Found %d %s with invalid spherical geometry.", n, feature_label)
)
}
stop_problems_process <- function(feature_id, problem) {
n <- length(feature_id)
error_label <- if (n != 1) "errors" else "error"
stop_problems(
feature_id,
problem,
sprintf("Encountered %d processing %s.", n, error_label)
)
}
stop_problems <- function(feature_id, problem, header) {
n <- length(feature_id)
if (n > 10) {
feature_id <- feature_id[1:10]
problem <- problem[1:10]
more <- sprintf("\n...and %s more", n - 10)
} else {
more <- ""
}
msg <- paste0(
header, "\n",
paste0("[", feature_id + 1, "] ", problem , collapse = "\n"),
more
)
stop(msg, call. = FALSE)
}
expect_wkt_equal <- function(x, y, precision = 16) {
testthat::expect_equal(
wk::wk_format(
as_s2_geography(x),
precision = precision,
trim = TRUE,
max_coords = .Machine$integer.max
),
wk::wk_format(
as_s2_geography(y),
precision = precision,
trim = TRUE,
max_coords = .Machine$integer.max
)
)
}
expect_near <- function(x, y, epsilon) {
testthat::expect_true(abs(y - x) < epsilon)
}
s2/R/s2-accessors.R 0000644 0001750 0001751 00000013067 14737212474 013606 0 ustar nilesh nilesh
#' S2 Geography Accessors
#'
#' Accessors extract information about [geography vectors][as_s2_geography].
#'
#' @param x,y [geography vectors][as_s2_geography]. These inputs
#' are passed to [as_s2_geography()], so you can pass other objects
#' (e.g., character vectors of well-known text) directly.
#' @param radius Radius of the earth. Defaults to the average radius of
#' the earth in meters as defined by [s2_earth_radius_meters()].
#'
#' @export
#'
#' @seealso
#' BigQuery's geography function reference:
#'
#' - [ST_ISCOLLECTION](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_iscollection)
#' - [ST_DIMENSION](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_dimension)
#' - [ST_NUMPOINTS](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_numpoints)
#' - [ST_ISEMPTY](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_isempty)
#' - [ST_AREA](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_area)
#' - [ST_LENGTH](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_length)
#' - [ST_PERIMETER](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_perimeter)
#' - [ST_X](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_x)
#' - [ST_Y](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_y)
#' - [ST_DISTANCE](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_distance)
#' - [ST_MAXDISTANCE](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_maxdistance)
#'
#' @examples
#' # s2_is_collection() tests for multiple geometries in one feature
#' s2_is_collection(c("POINT (-64 45)", "MULTIPOINT ((-64 45), (8 72))"))
#'
#' # s2_dimension() returns 0 for point, 1 for line, 2 for polygon
#' s2_dimension(
#' c(
#' "GEOMETRYCOLLECTION EMPTY",
#' "POINT (-64 45)",
#' "LINESTRING (-64 45, 8 72)",
#' "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
#' "GEOMETRYCOLLECTION (POINT (-64 45), LINESTRING (-64 45, 8 72))"
#' )
#' )
#'
#' # s2_num_points() counts points
#' s2_num_points(c("POINT (-64 45)", "LINESTRING (-64 45, 8 72)"))
#'
#' # s2_is_empty tests for emptiness
#' s2_is_empty(c("POINT (-64 45)", "POINT EMPTY"))
#'
#' # calculate area, length, and perimeter
#' s2_area("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))")
#' s2_perimeter("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))")
#' s2_length(s2_boundary("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))"))
#'
#' # extract x and y coordinates from points
#' s2_x(c("POINT (-64 45)", "POINT EMPTY"))
#' s2_y(c("POINT (-64 45)", "POINT EMPTY"))
#'
#' # calculate minimum and maximum distance between two geometries
#' s2_distance(
#' "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
#' "POINT (-64 45)"
#' )
#' s2_max_distance(
#' "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
#' "POINT (-64 45)"
#' )
#'
s2_is_collection <- function(x) {
cpp_s2_is_collection(as_s2_geography(x))
}
#' @rdname s2_is_collection
#' @export
s2_is_valid <- function(x) {
cpp_s2_is_valid(as_s2_geography(x, check = FALSE))
}
#' @rdname s2_is_collection
#' @export
s2_is_valid_detail <- function(x) {
x <- as_s2_geography(x, check = FALSE)
data.frame(
is_valid = cpp_s2_is_valid(x),
reason = cpp_s2_is_valid_reason(x),
stringsAsFactors = FALSE
)
}
#' @rdname s2_is_collection
#' @export
s2_dimension <- function(x) {
cpp_s2_dimension(as_s2_geography(x))
}
#' @rdname s2_is_collection
#' @export
s2_num_points <- function(x) {
cpp_s2_num_points(as_s2_geography(x))
}
#' @rdname s2_is_collection
#' @export
s2_is_empty <- function(x) {
cpp_s2_is_empty(as_s2_geography(x))
}
#' @rdname s2_is_collection
#' @export
s2_area <- function(x, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), radius)
cpp_s2_area(recycled[[1]]) * radius ^ 2
}
#' @rdname s2_is_collection
#' @export
s2_length <- function(x, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), radius)
cpp_s2_length(recycled[[1]]) * radius
}
#' @rdname s2_is_collection
#' @export
s2_perimeter <- function(x, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), radius)
cpp_s2_perimeter(recycled[[1]]) * radius
}
#' @rdname s2_is_collection
#' @export
s2_x <- function(x) {
cpp_s2_x(as_s2_geography(x))
}
#' @rdname s2_is_collection
#' @export
s2_y <- function(x) {
cpp_s2_y(as_s2_geography(x))
}
# document these with the other linear referencers
#' @rdname s2_interpolate
#' @export
s2_project <- function(x, y, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y), radius)
length <- cpp_s2_length(recycled[[1]]) * radius
cpp_s2_project_normalized(recycled[[1]], recycled[[2]]) * length
}
#' @rdname s2_interpolate
#' @export
s2_project_normalized <- function(x, y) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y))
cpp_s2_project_normalized(recycled[[1]], recycled[[2]])
}
#' @rdname s2_is_collection
#' @export
s2_distance <- function(x, y, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y), radius)
cpp_s2_distance(recycled[[1]], recycled[[2]]) * radius
}
#' @rdname s2_is_collection
#' @export
s2_max_distance <- function(x, y, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), as_s2_geography(y), radius)
cpp_s2_max_distance(recycled[[1]], recycled[[2]]) * radius
}
s2/R/s2-bounds.R 0000644 0001750 0001751 00000002355 14737212474 013111 0 ustar nilesh nilesh
#' Compute feature-wise and aggregate bounds
#'
#' [s2_bounds_rect()] returns a bounding latitude-longitude
#' rectangle that contains the region; [s2_bounds_cap()] returns a bounding circle
#' represented by a centre point (lat, lng) and an angle. The bound may not be tight
#' for points, polylines and geometry collections. The rectangle returned may depend on
#' the order of points or polylines. `lng_lo` values larger than `lng_hi` indicate
#' regions that span the antimeridian, see the Fiji example.
#'
#' @param x An [s2_geography()] vector.
#' @export
#' @return Both functions return a `data.frame`:
#'
#' - [s2_bounds_rect()]: Columns `minlng`, `minlat`, `maxlng`, `maxlat` (degrees)
#' - [s2_bounds_cap()]: Columns `lng`, `lat`, `angle` (degrees)
#'
#' @examples
#' s2_bounds_cap(s2_data_countries("Antarctica"))
#' s2_bounds_cap(s2_data_countries("Netherlands"))
#' s2_bounds_cap(s2_data_countries("Fiji"))
#'
#' s2_bounds_rect(s2_data_countries("Antarctica"))
#' s2_bounds_rect(s2_data_countries("Netherlands"))
#' s2_bounds_rect(s2_data_countries("Fiji"))
#'
s2_bounds_cap <- function(x) {
cpp_s2_bounds_cap(as_s2_geography(x))
}
#' @rdname s2_bounds_cap
#' @export
s2_bounds_rect <- function(x) {
cpp_s2_bounds_rect(as_s2_geography(x))
}
s2/R/s2-cell-union.R 0000644 0001750 0001751 00000011700 14737212474 013656 0 ustar nilesh nilesh
#' Create S2 Cell Union vectors
#'
#' @param x A `list()` of [s2_cell()] vectors.
#' @param ... Passed to S3 methods
#'
#' @return An object of class "s2_cell_union".
#' @export
#'
s2_cell_union <- function(x = list()) {
x <- as.list(x)
input_na <- vapply(x, is.null, logical(1))
union <- vector("list", length(x))
union[input_na] <- list(NULL)
union[!input_na] <- lapply(x[!input_na], as_s2_cell)
new_s2_cell_union(union)
}
#' @rdname s2_cell_union
#' @export
as_s2_geography.s2_cell_union <- function(x, ...) {
new_s2_geography(cpp_s2_geography_from_cell_union(as_s2_cell_union(x)))
}
#' @rdname s2_cell_union
#' @export
as_s2_cell_union <- function(x, ...) {
UseMethod("as_s2_cell_union")
}
#' @rdname s2_cell_union
#' @export
as_s2_cell_union.s2_cell_union <- function(x, ...) {
x
}
#' @rdname s2_cell_union
#' @export
as_s2_cell_union.s2_cell <- function(x, ...) {
cpp_s2_cell_to_cell_union(x)
}
#' @rdname s2_cell_union
#' @export
as_s2_cell_union.character <- function(x, ...) {
split <- strsplit(x, "\\s*;\\s*")
split[is.na(x)] <- list(NULL)
s2_cell_union(split)
}
new_s2_cell_union <- function(x) {
stopifnot(typeof(x) == "list")
structure(x, class = c("s2_cell_union", "wk_vctr"))
}
#' @export
is.na.s2_cell_union <- function(x, ...) {
cpp_s2_cell_union_is_na(x)
}
#' @export
format.s2_cell_union <- function(x, ...) {
formatted <- vapply(
unclass(x),
function(e) paste0(as.character(e), collapse = ";"),
character(1)
)
formatted[is.na(x)] <- ""
formatted
}
#' @export
as.character.s2_cell_union <- function(x, ...) {
formatted <- vapply(
unclass(x),
function(e) paste0(as.character(e), collapse = ";"),
character(1)
)
formatted[is.na(x)] <- NA_character_
formatted
}
#' @export
print.s2_cell_union <- function(x, ...) {
utils::str(x, ...)
invisible(x)
}
#' @method unlist s2_cell_union
#' @export
unlist.s2_cell_union <- function(x, recursive = TRUE, use.names = TRUE) {
unlisted <- unlist(unclass(x), recursive = recursive, use.names = use.names)
new_s2_cell(as.double(unlisted))
}
#' @importFrom utils str
#' @export
str.s2_cell_union <- function(object, ..., indent.str = "") {
cat(sprintf("%s\n%s", indent.str, length(object), indent.str))
str(unclass(object), ..., indent.str = indent.str)
invisible(object)
}
#' S2 cell union operators
#'
#' @param x,y An [s2_geography][as_s2_geography] or [s2_cell_union()].
#' @param min_level,max_level The minimum and maximum levels to constrain the
#' covering.
#' @param max_cells The maximum number of cells in the covering. Defaults to
#' 8.
#' @param buffer A distance to buffer outside the geography
#' @param interior Use `TRUE` to force the covering inside the geography.
#' @inheritParams s2_cell_is_valid
#'
#' @export
#'
s2_cell_union_normalize <- function(x) {
cpp_s2_cell_union_normalize(as_s2_cell_union(x))
}
#' @rdname s2_cell_union_normalize
#' @export
s2_cell_union_contains <- function(x, y) {
if (inherits(y, "s2_cell")) {
recycled <- recycle_common(as_s2_cell_union(x), y)
cpp_s2_cell_union_contains_cell(recycled[[1]], recycled[[2]])
} else {
cpp_s2_cell_union_contains(as_s2_cell_union(x), as_s2_cell_union(y))
}
}
#' @rdname s2_cell_union_normalize
#' @export
s2_cell_union_intersects <- function(x, y) {
cpp_s2_cell_union_intersects(as_s2_cell_union(x), as_s2_cell_union(y))
}
#' @rdname s2_cell_union_normalize
#' @export
s2_cell_union_intersection <- function(x, y) {
cpp_s2_cell_union_intersection(as_s2_cell_union(x), as_s2_cell_union(y))
}
#' @rdname s2_cell_union_normalize
#' @export
s2_cell_union_union <- function(x, y) {
cpp_s2_cell_union_union(as_s2_cell_union(x), as_s2_cell_union(y))
}
#' @rdname s2_cell_union_normalize
#' @export
s2_cell_union_difference <- function(x, y) {
cpp_s2_cell_union_difference(as_s2_cell_union(x), as_s2_cell_union(y))
}
#' @rdname s2_cell_union_normalize
#' @export
s2_covering_cell_ids <- function(x, min_level = 0, max_level = 30,
max_cells = 8, buffer = 0,
interior = FALSE,
radius = s2_earth_radius_meters()) {
recycled <- recycle_common(as_s2_geography(x), buffer / radius)
cpp_s2_covering_cell_ids(
recycled[[1]],
min_level,
max_level,
max_cells,
recycled[[2]],
interior
)
}
#' @rdname s2_cell_union_normalize
#' @export
s2_covering_cell_ids_agg <- function(x, min_level = 0, max_level = 30,
max_cells = 8, buffer = 0,
interior = FALSE,
radius = s2_earth_radius_meters(),
na.rm = FALSE) {
distance <- as.numeric(buffer / radius)
stopifnot(length(distance) == 1)
if (is.na(distance)) {
return(new_s2_cell_union(list(NULL)))
}
cpp_s2_covering_cell_ids_agg(
as_s2_geography(x),
min_level,
max_level,
max_cells,
distance,
interior,
na.rm
)
}
s2/R/s2-cell.R 0000644 0001750 0001751 00000017714 14737212474 012543 0 ustar nilesh nilesh
#' Create S2 Cell vectors
#'
#' The S2 cell indexing system forms the basis for spatial indexing
#' in the S2 library. On their own, S2 cells can represent points
#' or areas. As a union, a vector of S2 cells can approximate a
#' line or polygon. These functions allow direct access to the
#' S2 cell indexing system and are designed to have minimal overhead
#' such that looping and recursion have acceptable performance
#' when used within R code.
#'
#' Under the hood, S2 cell vectors are represented in R as vectors
#' of type [double()]. This works because S2 cell identifiers are
#' 64 bits wide, as are `double`s on all systems where R runs (The
#' same trick is used by the bit64 package to represent signed
#' 64-bit integers). As a happy accident, `NA_real_` is not a valid
#' or meaningful cell identifier, so missing value support in the
#' way R users might expect is preserved. It is worth noting that
#' the underlying value of `s2_cell_sentinel()` would normally be
#' considered `NA`; however, as it is meaningful and useful when
#' programming with S2 cells, custom `is.na()` and comparison methods
#' are implemented such that `s2_cell_sentinel()` is greater than
#' all valid S2 cells and not considered missing. Users can and should
#' implement compiled code that uses the underlying bytes of the
#' vector, ensuring that the class of any returned object that should
#' be interpreted in this way is constructed with `new_s2_cell()`.
#'
#' @param x The canonical S2 cell identifier as a character vector.
#' @param ... Passed to methods
#'
#' @return An object of class s2_cell
#' @export
#'
#' @examples
#' s2_cell("4b59a0cd83b5de49")
#' as_s2_cell(s2_lnglat(-64, 45))
#' as_s2_cell(s2_data_cities("Ottawa"))
#'
s2_cell <- function(x = character()) {
new_s2_cell(cpp_s2_cell_from_string(x))
}
#' @rdname s2_cell
#' @export
s2_cell_sentinel <- function() {
cpp_s2_cell_sentinel()
}
#' @rdname s2_cell
#' @export
s2_cell_invalid <- function() {
new_s2_cell(0)
}
#' @rdname s2_cell
#' @export
as_s2_cell <- function(x, ...) {
UseMethod("as_s2_cell")
}
#' @rdname s2_cell
#' @export
as_s2_cell.s2_cell <- function(x, ...) {
x
}
#' @rdname s2_cell
#' @export
as_s2_cell.character <- function(x, ...) {
s2_cell(x)
}
#' @rdname s2_cell
#' @export
as_s2_cell.s2_geography <- function(x, ...) {
cpp_s2_cell_from_lnglat(list(s2_x(x), s2_y(x)))
}
#' @rdname s2_cell
#' @export
as_s2_cell.wk_xy <- function(x, ...) {
cpp_s2_cell_from_lnglat(as_s2_lnglat(x))
}
#' @rdname s2_cell
#' @export
as_s2_cell.integer64 <- function(x, ...) {
storage <- unclass(x)
storage[is.na(x)] <- NA_real_
new_s2_cell(storage)
}
#' @rdname s2_cell
#' @export
new_s2_cell <- function(x) {
stopifnot(is.double(x))
structure(x, class = c("s2_cell", "wk_vctr"))
}
# registered in zzz.R
as.integer64.s2_cell <- function(x, ...) {
# We store 64-bit integegers the same way bit64 does so we can just set the
# class attribute and propagate NA values in the way that bit64 expects them.
x_is_na <- is.na(x)
class(x) <- "integer64"
x[x_is_na] <- bit64::NA_integer64_
x
}
#' @export
as.character.s2_cell <- function(x, ...) {
cpp_s2_cell_to_string(x)
}
#' @export
format.s2_cell <- function(x, ...) {
format(as.character(x), quote = FALSE, ...)
}
#' @export
as.list.s2_cell <- function(x, ...) {
lapply(NextMethod(), new_s2_cell)
}
#' @export
`[<-.s2_cell` <- function(x, i, value) {
replacement <- as_s2_cell(value)
x <- unclass(x)
x[i] <- replacement
new_s2_cell(x)
}
#' @export
`[[<-.s2_cell` <- function(x, i, value) {
x[i] <- value
x
}
#' @export
unique.s2_cell <- function(x, ...) {
cpp_s2_cell_unique(x)
}
#' @export
sort.s2_cell <- function(x, decreasing = FALSE, ...) {
cpp_s2_cell_sort(x, decreasing)
}
#' @export
is.na.s2_cell <- function(x) {
cpp_s2_cell_is_na(x)
}
#' @export
is.numeric.s2_cell <- function(x, ...) {
FALSE
}
#' @export
Ops.s2_cell <- function(e1, e2) {
switch(
.Generic,
"==" = cpp_s2_cell_eq(e1, e2),
"!=" = cpp_s2_cell_neq(e1, e2),
"<" = cpp_s2_cell_lt(e1, e2),
"<=" = cpp_s2_cell_lte(e1, e2),
">=" = cpp_s2_cell_gte(e1, e2),
">" = cpp_s2_cell_gt(e1, e2),
stop("Arithmetic operations are not meaningful for type 's2_cell'", call. = FALSE)
)
}
#' @export
Math.s2_cell <- function(x, ...) {
switch(
.Generic,
"cummax" = cpp_s2_cell_cummax(x),
"cummin" = cpp_s2_cell_cummin(x),
stop("Arithmetic operations are not meaningful for type 's2_cell'", call. = FALSE)
)
}
#' @export
Summary.s2_cell <- function(x, ..., na.rm = FALSE) {
switch(
.Generic,
"min" = cpp_s2_cell_range(x, na.rm)[1],
"max" = cpp_s2_cell_range(x, na.rm)[2],
"range" = cpp_s2_cell_range(x, na.rm),
stop("Arithmetic operations are not meaningful for type 's2_cell'", call. = FALSE)
)
}
#' S2 cell operators
#'
#' @param x,y An [s2_cell()] vector
#' @param level An integer between 0 and 30, inclusive.
#' @param k An integer between 0 and 3
#' @param radius The radius to use (e.g., [s2_earth_radius_meters()])
#' @param na.rm Remove NAs prior to computing aggregate?
#' @export
#'
s2_cell_is_valid <- function(x) {
cpp_s2_cell_is_valid(x)
}
# exporters
#' @rdname s2_cell_is_valid
#' @export
s2_cell_debug_string <- function(x) {
cpp_s2_cell_debug_string(x)
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_to_lnglat <- function(x) {
lnglat <- cpp_s2_cell_to_lnglat(x)
s2_lnglat(lnglat[[1]], lnglat[[2]])
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_center <- function(x) {
cpp_s2_cell_center(x)
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_boundary <- function(x) {
s2_boundary(cpp_s2_cell_polygon(x))
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_polygon <- function(x) {
cpp_s2_cell_polygon(x)
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_vertex <- function(x, k) {
recycled <- recycle_common(x, k)
cpp_s2_cell_vertex(recycled[[1]], recycled[[2]])
}
# accessors
#' @rdname s2_cell_is_valid
#' @export
s2_cell_level <- function(x) {
cpp_s2_cell_level(x)
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_is_leaf <- function(x) {
s2_cell_level(x) == 30L
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_is_face <- function(x) {
s2_cell_level(x) == 0L
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_area <- function(x, radius = s2_earth_radius_meters()) {
cpp_s2_cell_area(x) * radius ^ 2
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_area_approx <- function(x, radius = s2_earth_radius_meters()) {
cpp_s2_cell_area_approx(x) * radius ^ 2
}
# transversers
#' @rdname s2_cell_is_valid
#' @export
s2_cell_parent <- function(x, level = -1L) {
recycled <- recycle_common(x, level)
cpp_s2_cell_parent(recycled[[1]], recycled[[2]])
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_child <- function(x, k) {
recycled <- recycle_common(x, k)
cpp_s2_cell_child(recycled[[1]], recycled[[2]])
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_edge_neighbour <- function(x, k) {
recycled <- recycle_common(x, k)
cpp_s2_cell_edge_neighbour(recycled[[1]], recycled[[2]])
}
# binary operators
#' @rdname s2_cell_is_valid
#' @export
s2_cell_contains <- function(x, y) {
cpp_s2_cell_contains(x, y)
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_distance <- function(x, y, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(x, y, radius)
cpp_s2_cell_distance(recycled[[1]], recycled[[2]]) * radius
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_max_distance <- function(x, y, radius = s2_earth_radius_meters()) {
recycled <- recycle_common(x, y, radius)
cpp_s2_cell_max_distance(recycled[[1]], recycled[[2]]) * radius
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_may_intersect <- function(x, y) {
cpp_s2_cell_may_intersect(x, y)
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_common_ancestor_level <- function(x, y) {
cpp_s2_cell_common_ancestor_level(x, y)
}
#' @rdname s2_cell_is_valid
#' @export
s2_cell_common_ancestor_level_agg <- function(x, na.rm = FALSE) {
x_na <- is.na(x)
if (any(x_na) && !na.rm) {
return(NA_integer_)
}
cpp_s2_cell_common_ancestor_level_agg(x[!x_na])
}
s2/R/s2-earth.R 0000644 0001750 0001751 00000001204 14737212474 012712 0 ustar nilesh nilesh
#' Earth Constants
#'
#' According to Yoder (1995), the radius of the earth is
#' 6371.01 km. These functions are used to set the
#' default radis for functions that return a distance
#' or accept a distance as input
#' (e.g., [s2_distance()] and [s2_dwithin()]).
#'
#' @export
#'
#' @references
#' Yoder, C.F. 1995. "Astrometric and Geodetic Properties of Earth and the
#' Solar System" in Global Earth Physics, A Handbook of Physical Constants,
#' AGU Reference Shelf 1, American Geophysical Union, Table 2.
#' \doi{10.1029/RF001p0001}
#'
#' @examples
#' s2_earth_radius_meters()
#'
s2_earth_radius_meters <- function() {
6371.01 * 1000
}
s2/R/s2-lnglat.R 0000644 0001750 0001751 00000002514 14737212474 013075 0 ustar nilesh nilesh
#' Create an S2 LngLat Vector
#'
#' This class represents a latitude and longitude on the Earth's surface.
#' Most calculations in S2 convert this to a [as_s2_point()], which is a
#' unit vector representation of this value.
#'
#' @param lat,lng Vectors of latitude and longitude values in degrees.
#' @param x A [s2_lnglat()] vector or an object that can be coerced to one.
#' @param ... Unused
#'
#' @return An object with class s2_lnglat
#' @export
#'
#' @examples
#' s2_lnglat(45, -64) # Halifax, Nova Scotia!
#' as.data.frame(s2_lnglat(45, -64))
#'
s2_lnglat <- function(lng, lat) {
wk::xy(lng, lat, crs = wk::wk_crs_longlat())
}
#' @rdname s2_lnglat
#' @export
as_s2_lnglat <- function(x, ...) {
UseMethod("as_s2_lnglat")
}
#' @rdname s2_lnglat
#' @export
as_s2_lnglat.default <- function(x, ...) {
as_s2_lnglat(wk::as_xy(x))
}
#' @rdname s2_lnglat
#' @export
as_s2_lnglat.wk_xy <- function(x, ...) {
wk::wk_set_crs(
wk::as_xy(x, dims = c("x", "y")),
wk::wk_crs_longlat()
)
}
#' @rdname s2_lnglat
#' @export
as_s2_lnglat.wk_xyz <- function(x, ...) {
if (wk::wk_crs_equal(wk::wk_crs(x), s2_point_crs())) {
wk::new_wk_xy(
s2_lnglat_from_s2_point(x),
crs = wk::wk_crs_longlat()
)
} else {
NextMethod()
}
}
#' @export
as_s2_lnglat.character <- function(x, ...) {
as_s2_lnglat(wk::new_wk_wkt(x))
}
s2/R/zzz.R 0000644 0001750 0001751 00000003407 14737212474 012131 0 ustar nilesh nilesh
# nocov start
.onLoad <- function(...) {
# call c++ init
cpp_s2_init()
# dynamically register vctrs dependencies
for (cls in c("s2_geography", "s2_cell", "s2_cell_union")) {
s3_register("vctrs::vec_proxy", cls)
s3_register("vctrs::vec_restore", cls)
s3_register("vctrs::vec_ptype_abbr", cls)
}
s3_register("bit64::as.integer64", "s2_cell")
}
s3_register <- function(generic, class, method = NULL) {
stopifnot(is.character(generic), length(generic) == 1)
stopifnot(is.character(class), length(class) == 1)
pieces <- strsplit(generic, "::")[[1]]
stopifnot(length(pieces) == 2)
package <- pieces[[1]]
generic <- pieces[[2]]
caller <- parent.frame()
get_method_env <- function() {
top <- topenv(caller)
if (isNamespace(top)) {
asNamespace(environmentName(top))
} else {
caller
}
}
get_method <- function(method, env) {
if (is.null(method)) {
get(paste0(generic, ".", class), envir = get_method_env())
} else {
method
}
}
method_fn <- get_method(method)
stopifnot(is.function(method_fn))
# Always register hook in case package is later unloaded & reloaded
setHook(
packageEvent(package, "onLoad"),
function(...) {
ns <- asNamespace(package)
# Refresh the method, it might have been updated by `devtools::load_all()`
method_fn <- get_method(method)
registerS3method(generic, class, method_fn, envir = ns)
}
)
# Avoid registration failures during loading (pkgload or regular)
if (!isNamespaceLoaded(package)) {
return(invisible())
}
envir <- asNamespace(package)
# Only register if generic can be accessed
if (exists(generic, envir)) {
registerS3method(generic, class, method_fn, envir = envir)
}
invisible()
}
# nocov end
s2/R/s2-constructors-formatters.R 0000644 0001750 0001751 00000015105 14737212474 016550 0 ustar nilesh nilesh
#' Create and Format Geography Vectors
#'
#' These functions create and export [geography vectors][as_s2_geography].
#' Unlike the BigQuery geography constructors, these functions do not sanitize
#' invalid or redundant input using [s2_union()]. Note that when creating polygons
#' using [s2_make_polygon()], rings can be open or closed.
#'
#' @inheritParams s2_is_collection
#' @inheritParams as_s2_geography
#' @param precision The number of significant digits to export when
#' writing well-known text. If `trim = FALSE`, the number of
#' digits after the decimal place.
#' @param trim Should trailing zeroes be included after the decimal place?
#' @param endian The endian-ness of the well-known binary. See [wk::wkb_translate_wkb()].
#' @param longitude,latitude Vectors of latitude and longitude
#' @param wkt_string Well-known text
#' @param wkb_bytes A `list()` of `raw()`
#' @param planar Use `TRUE` to force planar edges in import or export.
#' @param tessellate_tol_m The maximum number of meters to that a point must
#' be moved to satisfy the planar edge constraint.
#' @param feature_id,ring_id Vectors for which a change in
#' sequential values indicates a new feature or ring. Use [factor()]
#' to convert from a character vector.
#'
#' @export
#'
#' @seealso
#' See [as_s2_geography()] for other ways to construct geography vectors.
#'
#' BigQuery's geography function reference:
#'
#' - [ST_GEOGPOINT](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_geogpoint)
#' - [ST_MAKELINE](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_makeline)
#' - [ST_MAKEPOLYGON](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_makepolygon)
#' - [ST_GEOGFROMTEXT](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_geogfromtext)
#' - [ST_GEOGFROMWKB](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_geogfromwkb)
#' - [ST_ASTEXT](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_astext)
#' - [ST_ASBINARY](https://cloud.google.com/bigquery/docs/reference/standard-sql/geography_functions#st_asbinary)
#'
#' @examples
#' # create point geographies using coordinate values:
#' s2_geog_point(-64, 45)
#'
#' # create line geographies using coordinate values:
#' s2_make_line(c(-64, 8), c(45, 71))
#'
#' # optionally, separate features using feature_id:
#' s2_make_line(
#' c(-64, 8, -27, -27), c(45, 71, 0, 45),
#' feature_id = c(1, 1, 2, 2)
#' )
#'
#' # create polygon geographies using coordinate values:
#' # (rings can be open or closed)
#' s2_make_polygon(c(-45, 8, 0), c(64, 71, 90))
#'
#' # optionally, separate rings and/or features using
#' # ring_id and/or feature_id
#' s2_make_polygon(
#' c(20, 10, 10, 30, 45, 30, 20, 20, 40, 20, 45),
#' c(35, 30, 10, 5, 20, 20, 15, 25, 40, 45, 30),
#' feature_id = c(rep(1, 8), rep(2, 3)),
#' ring_id = c(1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1)
#' )
#'
#' # import and export well-known text
#' (geog <- s2_geog_from_text("POINT (-64 45)"))
#' s2_as_text(geog)
#'
#' # import and export well-known binary
#' (geog <- s2_geog_from_wkb(wk::as_wkb("POINT (-64 45)")))
#' s2_as_binary(geog)
#'
#' # import geometry from planar space
#' s2_geog_from_text(
#' "POLYGON ((0 0, 1 0, 0 1, 0 0))",
#' planar = TRUE,
#' tessellate_tol_m = 1
#' )
#'
#' # export geographies into planar space
#' geog <- s2_make_polygon(c(179, -179, 179), c(10, 10, 11))
#' s2_as_text(geog, planar = TRUE)
#'
#' # polygons containing a pole need an extra step
#' geog <- s2_data_countries("Antarctica")
#' geom <- s2_as_text(
#' s2_intersection(geog, s2_world_plate_carree()),
#' planar = TRUE
#' )
#'
s2_geog_point <- function(longitude, latitude) {
wk::wk_handle(wk::xy(longitude, latitude), s2_geography_writer())
}
#' @rdname s2_geog_point
#' @export
s2_make_line <- function(longitude, latitude, feature_id = 1L) {
wk::wk_handle(
wk::xy(longitude, latitude),
wk::wk_linestring_filter(
s2_geography_writer(),
feature_id = as.integer(feature_id)
)
)
}
#' @rdname s2_geog_point
#' @export
s2_make_polygon <- function(longitude, latitude, feature_id = 1L, ring_id = 1L,
oriented = FALSE, check = TRUE) {
wk::wk_handle(
wk::xy(longitude, latitude),
wk::wk_polygon_filter(
s2_geography_writer(oriented = oriented, check = check),
feature_id = as.integer(feature_id),
ring_id = as.integer(ring_id)
)
)
}
#' @rdname s2_geog_point
#' @export
s2_geog_from_text <- function(wkt_string, oriented = FALSE, check = TRUE,
planar = FALSE,
tessellate_tol_m = s2_tessellate_tol_default()) {
attributes(wkt_string) <- NULL
wkt <- wk::new_wk_wkt(wkt_string, geodesic = TRUE)
wk::validate_wk_wkt(wkt)
wk::wk_handle(
wkt,
s2_geography_writer(
oriented = oriented,
check = check,
tessellate_tol = if (planar) {
tessellate_tol_m / s2_earth_radius_meters()
} else {
Inf
}
)
)
}
#' @rdname s2_geog_point
#' @export
s2_geog_from_wkb <- function(wkb_bytes, oriented = FALSE, check = TRUE,
planar = FALSE,
tessellate_tol_m = s2_tessellate_tol_default()) {
attributes(wkb_bytes) <- NULL
wkb <- wk::new_wk_wkb(wkb_bytes)
wk::validate_wk_wkb(wkb)
wk::wk_handle(
wkb,
s2_geography_writer(
oriented = oriented,
check = check,
tessellate_tol = if (planar) {
tessellate_tol_m / s2_earth_radius_meters()
} else {
Inf
}
)
)
}
#' @rdname s2_geog_point
#' @export
s2_as_text <- function(x, precision = 16, trim = TRUE,
planar = FALSE,
tessellate_tol_m = s2_tessellate_tol_default()) {
wkt <- wk::wk_handle(
as_s2_geography(x),
wk::wkt_writer(precision = precision, trim = trim),
s2_tessellate_tol = if (planar) {
tessellate_tol_m / s2_earth_radius_meters()
} else {
Inf
}
)
attributes(wkt) <- NULL
wkt
}
#' @rdname s2_geog_point
#' @export
s2_as_binary <- function(x, endian = wk::wk_platform_endian(),
planar = FALSE,
tessellate_tol_m = s2_tessellate_tol_default()) {
structure(
wk::wk_handle(
as_s2_geography(x),
wk::wkb_writer(endian = endian),
s2_tessellate_tol = if (planar) {
tessellate_tol_m / s2_earth_radius_meters()
} else {
Inf
}
),
class = "blob"
)
}
#' @rdname s2_geog_point
#' @export
s2_tessellate_tol_default <- function() {
100
}
s2/tools/ 0000755 0001750 0001751 00000000000 15014104735 012071 5 ustar nilesh nilesh s2/tools/winlibs.R 0000644 0001750 0001751 00000001777 14737212474 013712 0 ustar nilesh nilesh
# This script is used to support R 4.0, 4.1, and 4.2 on Windows, which do not have
# OpenSSL available via pkg-config. It places the headers in windows/openssl/include
# and the libs for this R version/arch in windows/openssl/lib to simplify the
# configure/makevars setup.
openssl_version <- "1.1.1k"
if(file.exists("windows/openssl/include/openssl/ssl.h")) {
cat("Using previously downloaded rwinlibs openssl")
} else {
cat(sprintf("Downloading OpenSSL %s from rwinlibs", openssl_version))
download.file(sprintf("https://github.com/rwinlib/openssl/archive/v%s.zip", openssl_version),
"lib.zip", quiet = TRUE)
dir.create("../windows", showWarnings = FALSE)
unzip("lib.zip", exdir = "windows")
file.rename("windows/openssl-1.1.1k", "windows/openssl")
crt <- if (packageVersion("base") >= "4.2.0") "-ucrt" else ""
libs <- list.files(
sprintf("windows/openssl/lib/%s%s", .Platform$r_arch, crt),
full.names = TRUE
)
file.copy(libs, "windows/openssl/lib")
unlink("lib.zip")
}
s2/tools/build_absl.sh 0000755 0001750 0001751 00000003343 14737212474 014546 0 ustar nilesh nilesh
# https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Using-cmake
: ${R_HOME=`R RHOME`}
if test -z "${R_HOME}"; then
echo "could not determine R_HOME"
exit 1
fi
# Do our best to pass on the user MAKEFLAGS. This can result in much faster
# compilation of the vendored library.
MAKEFLAGS=`${R_HOME}/bin/Rscript -e 'readRenviron("~/.R/Makevars"); cat(Sys.getenv("MAKEFLAGS"))'`
if test -z "$MAKE"; then MAKE="`which make`"; fi
if ${MAKE} --version ; then
echo "Using MAKE=$MAKE $MAKEFLAGS"
else
echo "make not found"
exit 1
fi
if test -z "$CMAKE"; then CMAKE="`which cmake`"; fi
if test -z "$CMAKE"; then CMAKE=/Applications/CMake.app/Contents/bin/cmake; fi
if "${CMAKE}" --version ; then
echo "Using CMAKE=$CMAKE"
echo "Using MAKE=$MAKE $MAKEFLAGS"
else
echo "cmake not found"
exit 1
fi
CC=`"${R_HOME}/bin/R" CMD config CC`
CXX="`${R_HOME}/bin/R CMD config CXX17` `${R_HOME}/bin/R CMD config CXX17STD`"
CFLAGS=`"${R_HOME}/bin/R" CMD config CFLAGS`
R_CPPFLAGS=`"${R_HOME}/bin/R" CMD config CPPFLAGS`
R_CXXFLAGS=`"${R_HOME}/bin/R" CMD config CXX17FLAGS`
LDFLAGS=`"${R_HOME}/bin/R" CMD config LDFLAGS`
CMAKE_INSTALL_PREFIX="$1"
if [ ! -d "tools/build/abseil-cpp" ]; then
mkdir -p "tools/build/abseil-cpp"
fi
cd "tools/build/abseil-cpp"
"${CMAKE}" \
-G "Unix Makefiles" \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
-DCMAKE_COLOR_MAKEFILE=OFF \
-DCMAKE_CXX_FLAGS_RELEASE="${R_CPPFLAGS} ${R_CXXFLAGS} ${WIN_CPPFLAGS}" \
-DBUILD_SHARED_LIBS=OFF \
-DCMAKE_POSITION_INDEPENDENT_CODE=ON \
-DCMAKE_INSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}" \
-DCMAKE_CXX_STANDARD=17 \
-DABSL_PROPAGATE_CXX_STD=ON \
"../../vendor/abseil-cpp" &&
${MAKE} ${MAKEFLAGS} &&
"${CMAKE}" --install .
cd ../../..
s2/tools/docker/ 0000755 0001750 0001751 00000000000 15010321446 013334 5 ustar nilesh nilesh s2/tools/docker/fedora.dockerfile 0000644 0001750 0001751 00000000610 14737212474 016641 0 ustar nilesh nilesh
ARG IMAGE=fedora:latest
FROM ${IMAGE}
RUN dnf install -y R cmake abseil-cpp-devel openssl-devel
# Make sure we can use all cores to install things
RUN mkdir ~/.R && echo "MAKEFLAGS = -j$(nproc)" > ~/.R/Makevars
RUN R -e 'install.packages(c("wk", "bit64", "Rcpp", "testthat"), repos = "https://cloud.r-project.org")'
CMD R CMD INSTALL /s2 --preclean && R -e 'testthat::test_local("/s2")'
s2/tools/docker/alpine.dockerfile 0000644 0001750 0001751 00000000566 14737212474 016663 0 ustar nilesh nilesh
ARG IMAGE=alpine:latest
FROM ${IMAGE}
RUN apk add bash R R-dev abseil-cpp-dev
# Make sure we can use all cores to install things
RUN mkdir ~/.R && echo "MAKEFLAGS = -j$(nproc)" > ~/.R/Makevars
RUN R -e 'install.packages(c("wk", "bit64", "Rcpp", "testthat"), repos = "https://cloud.r-project.org")'
CMD R CMD INSTALL /s2 --preclean && R -e 'testthat::test_local("/s2")'
s2/tools/docker/debian-clang.dockerfile 0000644 0001750 0001751 00000001462 15010321446 017674 0 ustar nilesh nilesh
ARG IMAGE=debian:testing
FROM ${IMAGE}
RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
r-base cmake libcurl4-openssl-dev libssl-dev clang-19
# Not all versions of ubuntu/debian have libabsl-dev
RUN apt-get install -y libabsl-dev || true
# Make sure we can use all cores to install things
RUN mkdir ~/.R && echo "MAKEFLAGS = -j$(nproc)" > ~/.R/Makevars
# Use clang if that's what we're up to. Probably not complete
# (e.g., doesn't consider C++11 or 14 or 20 or 23 compilers)
RUN echo "CC=clang-19" >> ~/.R/Makevars
RUN echo "CXX=clang++-19" >> ~/.R/Makevars
RUN echo "CXX17=clang++-19" >> ~/.R/Makevars
RUN R -e 'install.packages(c("wk", "bit64", "Rcpp", "testthat"), repos = "https://cloud.r-project.org")'
CMD R CMD INSTALL /s2 --preclean && R -e 'testthat::test_local("/s2")'
s2/tools/docker/debian.dockerfile 0000644 0001750 0001751 00000001053 14737212474 016625 0 ustar nilesh nilesh
ARG IMAGE=debian:testing
FROM ${IMAGE}
RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
r-base cmake libcurl4-openssl-dev libssl-dev
# Not all versions of ubuntu/debian have libabsl-dev
RUN apt-get install -y libabsl-dev || true
# Make sure we can use all cores to install things
RUN mkdir ~/.R && echo "MAKEFLAGS = -j$(nproc)" > ~/.R/Makevars
RUN R -e 'install.packages(c("wk", "bit64", "Rcpp", "testthat"), repos = "https://cloud.r-project.org")'
CMD R CMD INSTALL /s2 --preclean && R -e 'testthat::test_local("/s2")'
s2/tools/test_openssl.c 0000644 0001750 0001751 00000000155 14737212474 014773 0 ustar nilesh nilesh #include
#if OPENSSL_VERSION_NUMBER < 0x10000000L
#error OpenSSL version too old
#endif
s2/tools/vendor/ 0000755 0001750 0001751 00000000000 14737212474 013401 5 ustar nilesh nilesh s2/tools/vendor/abseil-cpp/ 0000755 0001750 0001751 00000000000 15014104735 015405 5 ustar nilesh nilesh s2/tools/vendor/abseil-cpp/LICENSE 0000644 0001750 0001751 00000026141 14737212474 016431 0 ustar nilesh nilesh
Apache License
Version 2.0, January 2004
https://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
s2/tools/vendor/abseil-cpp/absl/ 0000755 0001750 0001751 00000000000 14737212474 016341 5 ustar nilesh nilesh s2/tools/vendor/abseil-cpp/absl/crc/ 0000755 0001750 0001751 00000000000 14737212474 017110 5 ustar nilesh nilesh s2/tools/vendor/abseil-cpp/absl/crc/crc32c.h 0000644 0001750 0001751 00000016132 14737212474 020343 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// -----------------------------------------------------------------------------
// File: crc32c.h
// -----------------------------------------------------------------------------
//
// This header file defines the API for computing CRC32C values as checksums
// for arbitrary sequences of bytes provided as a string buffer.
//
// The API includes the basic functions for computing such CRC32C values and
// some utility functions for performing more efficient mathematical
// computations using an existing checksum.
#ifndef ABSL_CRC_CRC32C_H_
#define ABSL_CRC_CRC32C_H_
#include
#include
#include "absl/crc/internal/crc32c_inline.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
//-----------------------------------------------------------------------------
// crc32c_t
//-----------------------------------------------------------------------------
// `crc32c_t` defines a strongly-typed integer for holding a CRC32C value.
//
// Some operators are intentionally omitted. Only equality operators are defined
// so that `crc32c_t` can be directly compared. Methods for putting `crc32c_t`
// directly into a set are omitted because this is bug-prone due to checksum
// collisions. Use an explicit conversion to the `uint32_t` space for operations
// that treat `crc32c_t` as an integer.
class crc32c_t final {
public:
crc32c_t() = default;
constexpr explicit crc32c_t(uint32_t crc) : crc_(crc) {}
crc32c_t(const crc32c_t&) = default;
crc32c_t& operator=(const crc32c_t&) = default;
explicit operator uint32_t() const { return crc_; }
friend bool operator==(crc32c_t lhs, crc32c_t rhs) {
return static_cast(lhs) == static_cast(rhs);
}
friend bool operator!=(crc32c_t lhs, crc32c_t rhs) { return !(lhs == rhs); }
template
friend void AbslStringify(Sink& sink, crc32c_t crc) {
absl::Format(&sink, "%08x", static_cast(crc));
}
private:
uint32_t crc_;
};
namespace crc_internal {
// Non-inline code path for `absl::ExtendCrc32c()`. Do not call directly.
// Call `absl::ExtendCrc32c()` (defined below) instead.
crc32c_t ExtendCrc32cInternal(crc32c_t initial_crc,
absl::string_view buf_to_add);
} // namespace crc_internal
// -----------------------------------------------------------------------------
// CRC32C Computation Functions
// -----------------------------------------------------------------------------
// ComputeCrc32c()
//
// Returns the CRC32C value of the provided string.
crc32c_t ComputeCrc32c(absl::string_view buf);
// ExtendCrc32c()
//
// Computes a CRC32C value from an `initial_crc` CRC32C value including the
// `buf_to_add` bytes of an additional buffer. Using this function is more
// efficient than computing a CRC32C value for the combined buffer from
// scratch.
//
// Note: `ExtendCrc32c` with an initial_crc of 0 is equivalent to
// `ComputeCrc32c`.
//
// This operation has a runtime cost of O(`buf_to_add.size()`)
inline crc32c_t ExtendCrc32c(crc32c_t initial_crc,
absl::string_view buf_to_add) {
// Approximately 75% of calls have size <= 64.
if (buf_to_add.size() <= 64) {
uint32_t crc = static_cast(initial_crc);
if (crc_internal::ExtendCrc32cInline(&crc, buf_to_add.data(),
buf_to_add.size())) {
return crc32c_t{crc};
}
}
return crc_internal::ExtendCrc32cInternal(initial_crc, buf_to_add);
}
// ExtendCrc32cByZeroes()
//
// Computes a CRC32C value for a buffer with an `initial_crc` CRC32C value,
// where `length` bytes with a value of 0 are appended to the buffer. Using this
// function is more efficient than computing a CRC32C value for the combined
// buffer from scratch.
//
// This operation has a runtime cost of O(log(`length`))
crc32c_t ExtendCrc32cByZeroes(crc32c_t initial_crc, size_t length);
// MemcpyCrc32c()
//
// Copies `src` to `dest` using `memcpy()` semantics, returning the CRC32C
// value of the copied buffer.
//
// Using `MemcpyCrc32c()` is potentially faster than performing the `memcpy()`
// and `ComputeCrc32c()` operations separately.
crc32c_t MemcpyCrc32c(void* dest, const void* src, size_t count,
crc32c_t initial_crc = crc32c_t{0});
// -----------------------------------------------------------------------------
// CRC32C Arithmetic Functions
// -----------------------------------------------------------------------------
// The following functions perform arithmetic on CRC32C values, which are
// generally more efficient than recalculating any given result's CRC32C value.
// ConcatCrc32c()
//
// Calculates the CRC32C value of two buffers with known CRC32C values
// concatenated together.
//
// Given a buffer with CRC32C value `crc1` and a buffer with
// CRC32C value `crc2` and length, `crc2_length`, returns the CRC32C value of
// the concatenation of these two buffers.
//
// This operation has a runtime cost of O(log(`crc2_length`)).
crc32c_t ConcatCrc32c(crc32c_t crc1, crc32c_t crc2, size_t crc2_length);
// RemoveCrc32cPrefix()
//
// Calculates the CRC32C value of an existing buffer with a series of bytes
// (the prefix) removed from the beginning of that buffer.
//
// Given the CRC32C value of an existing buffer, `full_string_crc`; The CRC32C
// value of a prefix of that buffer, `prefix_crc`; and the length of the buffer
// with the prefix removed, `remaining_string_length` , return the CRC32C
// value of the buffer with the prefix removed.
//
// This operation has a runtime cost of O(log(`remaining_string_length`)).
crc32c_t RemoveCrc32cPrefix(crc32c_t prefix_crc, crc32c_t full_string_crc,
size_t remaining_string_length);
// RemoveCrc32cSuffix()
//
// Calculates the CRC32C value of an existing buffer with a series of bytes
// (the suffix) removed from the end of that buffer.
//
// Given a CRC32C value of an existing buffer `full_string_crc`, the CRC32C
// value of the suffix to remove `suffix_crc`, and the length of that suffix
// `suffix_len`, returns the CRC32C value of the buffer with suffix removed.
//
// This operation has a runtime cost of O(log(`suffix_len`))
crc32c_t RemoveCrc32cSuffix(crc32c_t full_string_crc, crc32c_t suffix_crc,
size_t suffix_length);
// operator<<
//
// Streams the CRC32C value `crc` to the stream `os`.
inline std::ostream& operator<<(std::ostream& os, crc32c_t crc) {
return os << absl::StreamFormat("%08x", static_cast(crc));
}
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_CRC_CRC32C_H_
s2/tools/vendor/abseil-cpp/absl/crc/BUILD.bazel 0000644 0001750 0001751 00000012411 14737212474 020765 0 ustar nilesh nilesh # Copyright 2022 The Abseil Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
load(
"//absl:copts/configure_copts.bzl",
"ABSL_DEFAULT_COPTS",
"ABSL_DEFAULT_LINKOPTS",
"ABSL_TEST_COPTS",
)
package(default_visibility = ["//visibility:private"])
licenses(["notice"])
cc_library(
name = "cpu_detect",
srcs = [
"internal/cpu_detect.cc",
],
hdrs = ["internal/cpu_detect.h"],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:private"],
deps = [
"//absl/base",
"//absl/base:config",
],
)
cc_library(
name = "crc_internal",
srcs = [
"internal/crc.cc",
"internal/crc_internal.h",
"internal/crc_x86_arm_combined.cc",
],
hdrs = [
"internal/crc.h",
"internal/crc32_x86_arm_combined_simd.h",
],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:private"],
deps = [
":cpu_detect",
"//absl/base",
"//absl/base:config",
"//absl/base:core_headers",
"//absl/base:dynamic_annotations",
"//absl/base:endian",
"//absl/base:prefetch",
"//absl/base:raw_logging_internal",
"//absl/memory",
"//absl/numeric:bits",
],
)
cc_library(
name = "crc32c",
srcs = [
"crc32c.cc",
"internal/crc32c_inline.h",
"internal/crc_memcpy_fallback.cc",
"internal/crc_memcpy_x86_64.cc",
"internal/crc_non_temporal_memcpy.cc",
],
hdrs = [
"crc32c.h",
"internal/crc32c.h",
"internal/crc_memcpy.h",
],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:public"],
deps = [
":cpu_detect",
":crc_internal",
":non_temporal_memcpy",
"//absl/base:config",
"//absl/base:core_headers",
"//absl/base:dynamic_annotations",
"//absl/base:endian",
"//absl/base:prefetch",
"//absl/strings",
"//absl/strings:str_format",
],
)
cc_test(
name = "crc32c_test",
srcs = ["crc32c_test.cc"],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:private"],
deps = [
":crc32c",
"//absl/strings",
"//absl/strings:str_format",
"@com_google_googletest//:gtest_main",
],
)
cc_library(
name = "non_temporal_arm_intrinsics",
hdrs = ["internal/non_temporal_arm_intrinsics.h"],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:private"],
deps = [
"//absl/base:config",
],
)
cc_library(
name = "non_temporal_memcpy",
hdrs = ["internal/non_temporal_memcpy.h"],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:private"],
deps = [
":non_temporal_arm_intrinsics",
"//absl/base:config",
"//absl/base:core_headers",
],
)
cc_test(
name = "crc_memcpy_test",
size = "large",
srcs = ["internal/crc_memcpy_test.cc"],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
shard_count = 3,
visibility = ["//visibility:private"],
deps = [
":crc32c",
"//absl/memory",
"//absl/random",
"//absl/random:distributions",
"//absl/strings",
"@com_google_googletest//:gtest_main",
],
)
cc_test(
name = "non_temporal_memcpy_test",
srcs = ["internal/non_temporal_memcpy_test.cc"],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:private"],
deps = [
":non_temporal_memcpy",
"@com_google_googletest//:gtest_main",
],
)
cc_library(
name = "crc_cord_state",
srcs = ["internal/crc_cord_state.cc"],
hdrs = ["internal/crc_cord_state.h"],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//absl/strings:__pkg__"],
deps = [
":crc32c",
"//absl/base:config",
"//absl/numeric:bits",
"//absl/strings",
],
)
cc_test(
name = "crc_cord_state_test",
srcs = ["internal/crc_cord_state_test.cc"],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
visibility = ["//visibility:private"],
deps = [
":crc32c",
":crc_cord_state",
"@com_google_googletest//:gtest_main",
],
)
cc_binary(
name = "crc32c_benchmark",
testonly = 1,
srcs = ["crc32c_benchmark.cc"],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
tags = [
"benchmark",
],
visibility = ["//visibility:private"],
deps = [
":crc32c",
"//absl/memory",
"//absl/strings",
"@com_github_google_benchmark//:benchmark_main",
],
)
s2/tools/vendor/abseil-cpp/absl/crc/internal/ 0000755 0001750 0001751 00000000000 14737212474 020724 5 ustar nilesh nilesh s2/tools/vendor/abseil-cpp/absl/crc/internal/crc_cord_state.h 0000644 0001750 0001751 00000013361 14737212474 024057 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_CRC_CORD_STATE_H_
#define ABSL_CRC_INTERNAL_CRC_CORD_STATE_H_
#include
#include
#include
#include "absl/base/config.h"
#include "absl/crc/crc32c.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
// CrcCordState is a copy-on-write class that holds the chunked CRC32C data
// that allows CrcCord to perform efficient substring operations. CrcCordState
// is used as a member variable in CrcCord. When a CrcCord is converted to a
// Cord, the CrcCordState is shallow-copied into the root node of the Cord. If
// the converted Cord is modified outside of CrcCord, the CrcCordState is
// discarded from the Cord. If the Cord is converted back to a CrcCord, and the
// Cord is still carrying the CrcCordState in its root node, the CrcCord can
// re-use the CrcCordState, making the construction of the CrcCord cheap.
//
// CrcCordState does not try to encapsulate the CRC32C state (CrcCord requires
// knowledge of how CrcCordState represents the CRC32C state). It does
// encapsulate the copy-on-write nature of the state.
class CrcCordState {
public:
// Constructors.
CrcCordState();
CrcCordState(const CrcCordState&);
CrcCordState(CrcCordState&&);
// Destructor. Atomically unreferences the data.
~CrcCordState();
// Copy and move operators.
CrcCordState& operator=(const CrcCordState&);
CrcCordState& operator=(CrcCordState&&);
// A (length, crc) pair.
struct PrefixCrc {
PrefixCrc() = default;
PrefixCrc(size_t length_arg, absl::crc32c_t crc_arg)
: length(length_arg), crc(crc_arg) {}
size_t length = 0;
// TODO(absl-team): Memory stomping often zeros out memory. If this struct
// gets overwritten, we could end up with {0, 0}, which is the correct CRC
// for a string of length 0. Consider storing a scrambled value and
// unscrambling it before verifying it.
absl::crc32c_t crc = absl::crc32c_t{0};
};
// The representation of the chunked CRC32C data.
struct Rep {
// `removed_prefix` is the crc and length of any prefix that has been
// removed from the Cord (for example, by calling
// `CrcCord::RemovePrefix()`). To get the checksum of any prefix of the
// cord, this value must be subtracted from `prefix_crc`. See `Checksum()`
// for an example.
//
// CrcCordState is said to be "normalized" if removed_prefix.length == 0.
PrefixCrc removed_prefix;
// A deque of (length, crc) pairs, representing length and crc of a prefix
// of the Cord, before removed_prefix has been subtracted. The lengths of
// the prefixes are stored in increasing order. If the Cord is not empty,
// the last value in deque is the contains the CRC32C of the entire Cord
// when removed_prefix is subtracted from it.
std::deque prefix_crc;
};
// Returns a reference to the representation of the chunked CRC32C data.
const Rep& rep() const { return refcounted_rep_->rep; }
// Returns a mutable reference to the representation of the chunked CRC32C
// data. Calling this function will copy the data if another instance also
// holds a reference to the data, so it is important to call rep() instead if
// the data may not be mutated.
Rep* mutable_rep() {
if (refcounted_rep_->count.load(std::memory_order_acquire) != 1) {
RefcountedRep* copy = new RefcountedRep;
copy->rep = refcounted_rep_->rep;
Unref(refcounted_rep_);
refcounted_rep_ = copy;
}
return &refcounted_rep_->rep;
}
// Returns the CRC32C of the entire Cord.
absl::crc32c_t Checksum() const;
// Returns true if the chunked CRC32C cached is normalized.
bool IsNormalized() const { return rep().removed_prefix.length == 0; }
// Normalizes the chunked CRC32C checksum cache by subtracting any removed
// prefix from the chunks.
void Normalize();
// Returns the number of cached chunks.
size_t NumChunks() const { return rep().prefix_crc.size(); }
// Helper that returns the (length, crc) of the `n`-th cached chunked.
PrefixCrc NormalizedPrefixCrcAtNthChunk(size_t n) const;
// Poisons all chunks to so that Checksum() will likely be incorrect with high
// probability.
void Poison();
private:
struct RefcountedRep {
std::atomic count{1};
Rep rep;
};
// Adds a reference to the shared global empty `RefcountedRep`, and returns a
// pointer to the `RefcountedRep`. This is an optimization to avoid unneeded
// allocations when the allocation is unlikely to ever be used. The returned
// pointer can be `Unref()`ed when it is no longer needed. Since the returned
// instance will always have a reference counter greater than 1, attempts to
// modify it (by calling `mutable_rep()`) will create a new unshared copy.
static RefcountedRep* RefSharedEmptyRep();
static void Ref(RefcountedRep* r) {
assert(r != nullptr);
r->count.fetch_add(1, std::memory_order_relaxed);
}
static void Unref(RefcountedRep* r) {
assert(r != nullptr);
if (r->count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
delete r;
}
}
RefcountedRep* refcounted_rep_;
};
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_CRC_INTERNAL_CRC_CORD_STATE_H_
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc_x86_arm_combined.cc 0000644 0001750 0001751 00000071632 14737212474 025217 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Hardware accelerated CRC32 computation on Intel and ARM architecture.
#include
#include
#include "absl/base/attributes.h"
#include "absl/base/config.h"
#include "absl/base/dynamic_annotations.h"
#include "absl/base/internal/endian.h"
#include "absl/base/prefetch.h"
#include "absl/crc/internal/cpu_detect.h"
#include "absl/crc/internal/crc.h"
#include "absl/crc/internal/crc32_x86_arm_combined_simd.h"
#include "absl/crc/internal/crc_internal.h"
#include "absl/memory/memory.h"
#include "absl/numeric/bits.h"
#if defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD) || \
defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
#define ABSL_INTERNAL_CAN_USE_SIMD_CRC32C
#endif
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
#if defined(ABSL_INTERNAL_CAN_USE_SIMD_CRC32C)
// Implementation details not exported outside of file
namespace {
// Some machines have CRC acceleration hardware.
// We can do a faster version of Extend() on such machines.
class CRC32AcceleratedX86ARMCombined : public CRC32 {
public:
CRC32AcceleratedX86ARMCombined() {}
~CRC32AcceleratedX86ARMCombined() override {}
void ExtendByZeroes(uint32_t* crc, size_t length) const override;
uint32_t ComputeZeroConstant(size_t length) const;
private:
CRC32AcceleratedX86ARMCombined(const CRC32AcceleratedX86ARMCombined&) =
delete;
CRC32AcceleratedX86ARMCombined& operator=(
const CRC32AcceleratedX86ARMCombined&) = delete;
};
// Constants for switching between algorithms.
// Chosen by comparing speed at different powers of 2.
constexpr size_t kSmallCutoff = 256;
constexpr size_t kMediumCutoff = 2048;
#define ABSL_INTERNAL_STEP1(crc) \
do { \
crc = CRC32_u8(static_cast(crc), *p++); \
} while (0)
#define ABSL_INTERNAL_STEP2(crc) \
do { \
crc = \
CRC32_u16(static_cast(crc), absl::little_endian::Load16(p)); \
p += 2; \
} while (0)
#define ABSL_INTERNAL_STEP4(crc) \
do { \
crc = \
CRC32_u32(static_cast(crc), absl::little_endian::Load32(p)); \
p += 4; \
} while (0)
#define ABSL_INTERNAL_STEP8(crc, data) \
do { \
crc = CRC32_u64(static_cast(crc), \
absl::little_endian::Load64(data)); \
data += 8; \
} while (0)
#define ABSL_INTERNAL_STEP8BY2(crc0, crc1, p0, p1) \
do { \
ABSL_INTERNAL_STEP8(crc0, p0); \
ABSL_INTERNAL_STEP8(crc1, p1); \
} while (0)
#define ABSL_INTERNAL_STEP8BY3(crc0, crc1, crc2, p0, p1, p2) \
do { \
ABSL_INTERNAL_STEP8(crc0, p0); \
ABSL_INTERNAL_STEP8(crc1, p1); \
ABSL_INTERNAL_STEP8(crc2, p2); \
} while (0)
namespace {
uint32_t multiply(uint32_t a, uint32_t b) {
V128 shifts = V128_From2x64(0, 1);
V128 power = V128_From2x64(0, a);
V128 crc = V128_From2x64(0, b);
V128 res = V128_PMulLow(power, crc);
// Combine crc values
res = V128_ShiftLeft64(res, shifts);
return static_cast(V128_Extract32<1>(res)) ^
CRC32_u32(0, static_cast(V128_Low64(res)));
}
// Powers of crc32c polynomial, for faster ExtendByZeros.
// Verified against folly:
// folly/hash/detail/Crc32CombineDetail.cpp
constexpr uint32_t kCRC32CPowers[] = {
0x82f63b78, 0x6ea2d55c, 0x18b8ea18, 0x510ac59a, 0xb82be955, 0xb8fdb1e7,
0x88e56f72, 0x74c360a4, 0xe4172b16, 0x0d65762a, 0x35d73a62, 0x28461564,
0xbf455269, 0xe2ea32dc, 0xfe7740e6, 0xf946610b, 0x3c204f8f, 0x538586e3,
0x59726915, 0x734d5309, 0xbc1ac763, 0x7d0722cc, 0xd289cabe, 0xe94ca9bc,
0x05b74f3f, 0xa51e1f42, 0x40000000, 0x20000000, 0x08000000, 0x00800000,
0x00008000, 0x82f63b78, 0x6ea2d55c, 0x18b8ea18, 0x510ac59a, 0xb82be955,
0xb8fdb1e7, 0x88e56f72, 0x74c360a4, 0xe4172b16, 0x0d65762a, 0x35d73a62,
0x28461564, 0xbf455269, 0xe2ea32dc, 0xfe7740e6, 0xf946610b, 0x3c204f8f,
0x538586e3, 0x59726915, 0x734d5309, 0xbc1ac763, 0x7d0722cc, 0xd289cabe,
0xe94ca9bc, 0x05b74f3f, 0xa51e1f42, 0x40000000, 0x20000000, 0x08000000,
0x00800000, 0x00008000,
};
} // namespace
// Compute a magic constant, so that multiplying by it is the same as
// extending crc by length zeros.
uint32_t CRC32AcceleratedX86ARMCombined::ComputeZeroConstant(
size_t length) const {
// Lowest 2 bits are handled separately in ExtendByZeroes
length >>= 2;
int index = absl::countr_zero(length);
uint32_t prev = kCRC32CPowers[index];
length &= length - 1;
while (length) {
// For each bit of length, extend by 2**n zeros.
index = absl::countr_zero(length);
prev = multiply(prev, kCRC32CPowers[index]);
length &= length - 1;
}
return prev;
}
void CRC32AcceleratedX86ARMCombined::ExtendByZeroes(uint32_t* crc,
size_t length) const {
uint32_t val = *crc;
// Don't bother with multiplication for small length.
switch (length & 3) {
case 0:
break;
case 1:
val = CRC32_u8(val, 0);
break;
case 2:
val = CRC32_u16(val, 0);
break;
case 3:
val = CRC32_u8(val, 0);
val = CRC32_u16(val, 0);
break;
}
if (length > 3) {
val = multiply(val, ComputeZeroConstant(length));
}
*crc = val;
}
// Taken from Intel paper "Fast CRC Computation for iSCSI Polynomial Using CRC32
// Instruction"
// https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/crc-iscsi-polynomial-crc32-instruction-paper.pdf
// We only need every 4th value, because we unroll loop by 4.
constexpr uint64_t kClmulConstants[] = {
0x09e4addf8, 0x0ba4fc28e, 0x00d3b6092, 0x09e4addf8, 0x0ab7aff2a,
0x102f9b8a2, 0x0b9e02b86, 0x00d3b6092, 0x1bf2e8b8a, 0x18266e456,
0x0d270f1a2, 0x0ab7aff2a, 0x11eef4f8e, 0x083348832, 0x0dd7e3b0c,
0x0b9e02b86, 0x0271d9844, 0x1b331e26a, 0x06b749fb2, 0x1bf2e8b8a,
0x0e6fc4e6a, 0x0ce7f39f4, 0x0d7a4825c, 0x0d270f1a2, 0x026f6a60a,
0x12ed0daac, 0x068bce87a, 0x11eef4f8e, 0x1329d9f7e, 0x0b3e32c28,
0x0170076fa, 0x0dd7e3b0c, 0x1fae1cc66, 0x010746f3c, 0x086d8e4d2,
0x0271d9844, 0x0b3af077a, 0x093a5f730, 0x1d88abd4a, 0x06b749fb2,
0x0c9c8b782, 0x0cec3662e, 0x1ddffc5d4, 0x0e6fc4e6a, 0x168763fa6,
0x0b0cd4768, 0x19b1afbc4, 0x0d7a4825c, 0x123888b7a, 0x00167d312,
0x133d7a042, 0x026f6a60a, 0x000bcf5f6, 0x19d34af3a, 0x1af900c24,
0x068bce87a, 0x06d390dec, 0x16cba8aca, 0x1f16a3418, 0x1329d9f7e,
0x19fb2a8b0, 0x02178513a, 0x1a0f717c4, 0x0170076fa,
};
enum class CutoffStrategy {
// Use 3 CRC streams to fold into 1.
Fold3,
// Unroll CRC instructions for 64 bytes.
Unroll64CRC,
};
// Base class for CRC32AcceleratedX86ARMCombinedMultipleStreams containing the
// methods and data that don't need the template arguments.
class CRC32AcceleratedX86ARMCombinedMultipleStreamsBase
: public CRC32AcceleratedX86ARMCombined {
protected:
// Update partialCRC with crc of 64 byte block. Calling FinalizePclmulStream
// would produce a single crc checksum, but it is expensive. PCLMULQDQ has a
// high latency, so we run 4 128-bit partial checksums that can be reduced to
// a single value by FinalizePclmulStream later. Computing crc for arbitrary
// polynomialas with PCLMULQDQ is described in Intel paper "Fast CRC
// Computation for Generic Polynomials Using PCLMULQDQ Instruction"
// https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf
// We are applying it to CRC32C polynomial.
ABSL_ATTRIBUTE_ALWAYS_INLINE void Process64BytesPclmul(
const uint8_t* p, V128* partialCRC) const {
V128 loopMultiplicands = V128_Load(reinterpret_cast(k1k2));
V128 partialCRC1 = partialCRC[0];
V128 partialCRC2 = partialCRC[1];
V128 partialCRC3 = partialCRC[2];
V128 partialCRC4 = partialCRC[3];
V128 tmp1 = V128_PMulHi(partialCRC1, loopMultiplicands);
V128 tmp2 = V128_PMulHi(partialCRC2, loopMultiplicands);
V128 tmp3 = V128_PMulHi(partialCRC3, loopMultiplicands);
V128 tmp4 = V128_PMulHi(partialCRC4, loopMultiplicands);
V128 data1 = V128_LoadU(reinterpret_cast(p + 16 * 0));
V128 data2 = V128_LoadU(reinterpret_cast(p + 16 * 1));
V128 data3 = V128_LoadU(reinterpret_cast(p + 16 * 2));
V128 data4 = V128_LoadU(reinterpret_cast(p + 16 * 3));
partialCRC1 = V128_PMulLow(partialCRC1, loopMultiplicands);
partialCRC2 = V128_PMulLow(partialCRC2, loopMultiplicands);
partialCRC3 = V128_PMulLow(partialCRC3, loopMultiplicands);
partialCRC4 = V128_PMulLow(partialCRC4, loopMultiplicands);
partialCRC1 = V128_Xor(tmp1, partialCRC1);
partialCRC2 = V128_Xor(tmp2, partialCRC2);
partialCRC3 = V128_Xor(tmp3, partialCRC3);
partialCRC4 = V128_Xor(tmp4, partialCRC4);
partialCRC1 = V128_Xor(partialCRC1, data1);
partialCRC2 = V128_Xor(partialCRC2, data2);
partialCRC3 = V128_Xor(partialCRC3, data3);
partialCRC4 = V128_Xor(partialCRC4, data4);
partialCRC[0] = partialCRC1;
partialCRC[1] = partialCRC2;
partialCRC[2] = partialCRC3;
partialCRC[3] = partialCRC4;
}
// Reduce partialCRC produced by Process64BytesPclmul into a single value,
// that represents crc checksum of all the processed bytes.
ABSL_ATTRIBUTE_ALWAYS_INLINE uint64_t
FinalizePclmulStream(V128* partialCRC) const {
V128 partialCRC1 = partialCRC[0];
V128 partialCRC2 = partialCRC[1];
V128 partialCRC3 = partialCRC[2];
V128 partialCRC4 = partialCRC[3];
// Combine 4 vectors of partial crc into a single vector.
V128 reductionMultiplicands =
V128_Load(reinterpret_cast(k5k6));
V128 low = V128_PMulLow(reductionMultiplicands, partialCRC1);
V128 high = V128_PMulHi(reductionMultiplicands, partialCRC1);
partialCRC1 = V128_Xor(low, high);
partialCRC1 = V128_Xor(partialCRC1, partialCRC2);
low = V128_PMulLow(reductionMultiplicands, partialCRC3);
high = V128_PMulHi(reductionMultiplicands, partialCRC3);
partialCRC3 = V128_Xor(low, high);
partialCRC3 = V128_Xor(partialCRC3, partialCRC4);
reductionMultiplicands = V128_Load(reinterpret_cast(k3k4));
low = V128_PMulLow(reductionMultiplicands, partialCRC1);
high = V128_PMulHi(reductionMultiplicands, partialCRC1);
V128 fullCRC = V128_Xor(low, high);
fullCRC = V128_Xor(fullCRC, partialCRC3);
// Reduce fullCRC into scalar value.
reductionMultiplicands = V128_Load(reinterpret_cast(k5k6));
V128 mask = V128_Load(reinterpret_cast(kMask));
V128 tmp = V128_PMul01(reductionMultiplicands, fullCRC);
fullCRC = V128_ShiftRight<8>(fullCRC);
fullCRC = V128_Xor(fullCRC, tmp);
reductionMultiplicands = V128_Load(reinterpret_cast(k7k0));
tmp = V128_ShiftRight<4>(fullCRC);
fullCRC = V128_And(fullCRC, mask);
fullCRC = V128_PMulLow(reductionMultiplicands, fullCRC);
fullCRC = V128_Xor(tmp, fullCRC);
reductionMultiplicands = V128_Load(reinterpret_cast(kPoly));
tmp = V128_And(fullCRC, mask);
tmp = V128_PMul01(reductionMultiplicands, tmp);
tmp = V128_And(tmp, mask);
tmp = V128_PMulLow(reductionMultiplicands, tmp);
fullCRC = V128_Xor(tmp, fullCRC);
return static_cast(V128_Extract32<1>(fullCRC));
}
// Update crc with 64 bytes of data from p.
ABSL_ATTRIBUTE_ALWAYS_INLINE uint64_t Process64BytesCRC(const uint8_t* p,
uint64_t crc) const {
for (int i = 0; i < 8; i++) {
crc =
CRC32_u64(static_cast(crc), absl::little_endian::Load64(p));
p += 8;
}
return crc;
}
// Generated by crc32c_x86_test --crc32c_generate_constants=true
// and verified against constants in linux kernel for S390:
// https://github.com/torvalds/linux/blob/master/arch/s390/crypto/crc32le-vx.S
alignas(16) static constexpr uint64_t k1k2[2] = {0x0740eef02, 0x09e4addf8};
alignas(16) static constexpr uint64_t k3k4[2] = {0x1384aa63a, 0x0ba4fc28e};
alignas(16) static constexpr uint64_t k5k6[2] = {0x0f20c0dfe, 0x14cd00bd6};
alignas(16) static constexpr uint64_t k7k0[2] = {0x0dd45aab8, 0x000000000};
alignas(16) static constexpr uint64_t kPoly[2] = {0x105ec76f0, 0x0dea713f1};
alignas(16) static constexpr uint32_t kMask[4] = {~0u, 0u, ~0u, 0u};
// Medium runs of bytes are broken into groups of kGroupsSmall blocks of same
// size. Each group is CRCed in parallel then combined at the end of the
// block.
static constexpr size_t kGroupsSmall = 3;
// For large runs we use up to kMaxStreams blocks computed with CRC
// instruction, and up to kMaxStreams blocks computed with PCLMULQDQ, which
// are combined in the end.
static constexpr size_t kMaxStreams = 3;
};
#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
alignas(16) constexpr uint64_t
CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::k1k2[2];
alignas(16) constexpr uint64_t
CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::k3k4[2];
alignas(16) constexpr uint64_t
CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::k5k6[2];
alignas(16) constexpr uint64_t
CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::k7k0[2];
alignas(16) constexpr uint64_t
CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::kPoly[2];
alignas(16) constexpr uint32_t
CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::kMask[4];
constexpr size_t
CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::kGroupsSmall;
constexpr size_t CRC32AcceleratedX86ARMCombinedMultipleStreamsBase::kMaxStreams;
#endif // ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
template
class CRC32AcceleratedX86ARMCombinedMultipleStreams
: public CRC32AcceleratedX86ARMCombinedMultipleStreamsBase {
ABSL_ATTRIBUTE_HOT
void Extend(uint32_t* crc, const void* bytes, size_t length) const override {
static_assert(num_crc_streams >= 1 && num_crc_streams <= kMaxStreams,
"Invalid number of crc streams");
static_assert(num_pclmul_streams >= 0 && num_pclmul_streams <= kMaxStreams,
"Invalid number of pclmul streams");
const uint8_t* p = static_cast(bytes);
const uint8_t* e = p + length;
uint32_t l = *crc;
uint64_t l64;
// We have dedicated instruction for 1,2,4 and 8 bytes.
if (length & 8) {
ABSL_INTERNAL_STEP8(l, p);
length &= ~size_t{8};
}
if (length & 4) {
ABSL_INTERNAL_STEP4(l);
length &= ~size_t{4};
}
if (length & 2) {
ABSL_INTERNAL_STEP2(l);
length &= ~size_t{2};
}
if (length & 1) {
ABSL_INTERNAL_STEP1(l);
length &= ~size_t{1};
}
if (length == 0) {
*crc = l;
return;
}
// length is now multiple of 16.
// For small blocks just run simple loop, because cost of combining multiple
// streams is significant.
if (strategy != CutoffStrategy::Unroll64CRC) {
if (length < kSmallCutoff) {
while (length >= 16) {
ABSL_INTERNAL_STEP8(l, p);
ABSL_INTERNAL_STEP8(l, p);
length -= 16;
}
*crc = l;
return;
}
}
// For medium blocks we run 3 crc streams and combine them as described in
// Intel paper above. Running 4th stream doesn't help, because crc
// instruction has latency 3 and throughput 1.
if (length < kMediumCutoff) {
l64 = l;
if (strategy == CutoffStrategy::Fold3) {
uint64_t l641 = 0;
uint64_t l642 = 0;
const size_t blockSize = 32;
size_t bs = static_cast(e - p) / kGroupsSmall / blockSize;
const uint8_t* p1 = p + bs * blockSize;
const uint8_t* p2 = p1 + bs * blockSize;
for (size_t i = 0; i + 1 < bs; ++i) {
ABSL_INTERNAL_STEP8BY3(l64, l641, l642, p, p1, p2);
ABSL_INTERNAL_STEP8BY3(l64, l641, l642, p, p1, p2);
ABSL_INTERNAL_STEP8BY3(l64, l641, l642, p, p1, p2);
ABSL_INTERNAL_STEP8BY3(l64, l641, l642, p, p1, p2);
PrefetchToLocalCache(
reinterpret_cast(p + kPrefetchHorizonMedium));
PrefetchToLocalCache(
reinterpret_cast(p1 + kPrefetchHorizonMedium));
PrefetchToLocalCache(
reinterpret_cast(p2 + kPrefetchHorizonMedium));
}
// Don't run crc on last 8 bytes.
ABSL_INTERNAL_STEP8BY3(l64, l641, l642, p, p1, p2);
ABSL_INTERNAL_STEP8BY3(l64, l641, l642, p, p1, p2);
ABSL_INTERNAL_STEP8BY3(l64, l641, l642, p, p1, p2);
ABSL_INTERNAL_STEP8BY2(l64, l641, p, p1);
V128 magic = *(reinterpret_cast(kClmulConstants) + bs - 1);
V128 tmp = V128_From2x64(0, l64);
V128 res1 = V128_PMulLow(tmp, magic);
tmp = V128_From2x64(0, l641);
V128 res2 = V128_PMul10(tmp, magic);
V128 x = V128_Xor(res1, res2);
l64 = static_cast(V128_Low64(x)) ^
absl::little_endian::Load64(p2);
l64 = CRC32_u64(static_cast(l642), l64);
p = p2 + 8;
} else if (strategy == CutoffStrategy::Unroll64CRC) {
while ((e - p) >= 64) {
l64 = Process64BytesCRC(p, l64);
p += 64;
}
}
} else {
// There is a lot of data, we can ignore combine costs and run all
// requested streams (num_crc_streams + num_pclmul_streams),
// using prefetch. CRC and PCLMULQDQ use different cpu execution units,
// so on some cpus it makes sense to execute both of them for different
// streams.
// Point x at first 8-byte aligned byte in string.
const uint8_t* x = RoundUp<8>(p);
// Process bytes until p is 8-byte aligned, if that isn't past the end.
while (p != x) {
ABSL_INTERNAL_STEP1(l);
}
size_t bs = static_cast(e - p) /
(num_crc_streams + num_pclmul_streams) / 64;
const uint8_t* crc_streams[kMaxStreams];
const uint8_t* pclmul_streams[kMaxStreams];
// We are guaranteed to have at least one crc stream.
crc_streams[0] = p;
for (size_t i = 1; i < num_crc_streams; i++) {
crc_streams[i] = crc_streams[i - 1] + bs * 64;
}
pclmul_streams[0] = crc_streams[num_crc_streams - 1] + bs * 64;
for (size_t i = 1; i < num_pclmul_streams; i++) {
pclmul_streams[i] = pclmul_streams[i - 1] + bs * 64;
}
// Per stream crc sums.
uint64_t l64_crc[kMaxStreams] = {l};
uint64_t l64_pclmul[kMaxStreams] = {0};
// Peel first iteration, because PCLMULQDQ stream, needs setup.
for (size_t i = 0; i < num_crc_streams; i++) {
l64_crc[i] = Process64BytesCRC(crc_streams[i], l64_crc[i]);
crc_streams[i] += 16 * 4;
}
V128 partialCRC[kMaxStreams][4];
for (size_t i = 0; i < num_pclmul_streams; i++) {
partialCRC[i][0] = V128_LoadU(
reinterpret_cast(pclmul_streams[i] + 16 * 0));
partialCRC[i][1] = V128_LoadU(
reinterpret_cast(pclmul_streams[i] + 16 * 1));
partialCRC[i][2] = V128_LoadU(
reinterpret_cast(pclmul_streams[i] + 16 * 2));
partialCRC[i][3] = V128_LoadU(
reinterpret_cast(pclmul_streams[i] + 16 * 3));
pclmul_streams[i] += 16 * 4;
}
for (size_t i = 1; i < bs; i++) {
// Prefetch data for next iterations.
for (size_t j = 0; j < num_crc_streams; j++) {
PrefetchToLocalCache(
reinterpret_cast(crc_streams[j] + kPrefetchHorizon));
}
for (size_t j = 0; j < num_pclmul_streams; j++) {
PrefetchToLocalCache(reinterpret_cast(pclmul_streams[j] +
kPrefetchHorizon));
}
// We process each stream in 64 byte blocks. This can be written as
// for (int i = 0; i < num_pclmul_streams; i++) {
// Process64BytesPclmul(pclmul_streams[i], partialCRC[i]);
// pclmul_streams[i] += 16 * 4;
// }
// for (int i = 0; i < num_crc_streams; i++) {
// l64_crc[i] = Process64BytesCRC(crc_streams[i], l64_crc[i]);
// crc_streams[i] += 16*4;
// }
// But unrolling and interleaving PCLMULQDQ and CRC blocks manually
// gives ~2% performance boost.
l64_crc[0] = Process64BytesCRC(crc_streams[0], l64_crc[0]);
crc_streams[0] += 16 * 4;
if (num_pclmul_streams > 0) {
Process64BytesPclmul(pclmul_streams[0], partialCRC[0]);
pclmul_streams[0] += 16 * 4;
}
if (num_crc_streams > 1) {
l64_crc[1] = Process64BytesCRC(crc_streams[1], l64_crc[1]);
crc_streams[1] += 16 * 4;
}
if (num_pclmul_streams > 1) {
Process64BytesPclmul(pclmul_streams[1], partialCRC[1]);
pclmul_streams[1] += 16 * 4;
}
if (num_crc_streams > 2) {
l64_crc[2] = Process64BytesCRC(crc_streams[2], l64_crc[2]);
crc_streams[2] += 16 * 4;
}
if (num_pclmul_streams > 2) {
Process64BytesPclmul(pclmul_streams[2], partialCRC[2]);
pclmul_streams[2] += 16 * 4;
}
}
// PCLMULQDQ based streams require special final step;
// CRC based don't.
for (size_t i = 0; i < num_pclmul_streams; i++) {
l64_pclmul[i] = FinalizePclmulStream(partialCRC[i]);
}
// Combine all streams into single result.
uint32_t magic = ComputeZeroConstant(bs * 64);
l64 = l64_crc[0];
for (size_t i = 1; i < num_crc_streams; i++) {
l64 = multiply(static_cast(l64), magic);
l64 ^= l64_crc[i];
}
for (size_t i = 0; i < num_pclmul_streams; i++) {
l64 = multiply(static_cast(l64), magic);
l64 ^= l64_pclmul[i];
}
// Update p.
if (num_pclmul_streams > 0) {
p = pclmul_streams[num_pclmul_streams - 1];
} else {
p = crc_streams[num_crc_streams - 1];
}
}
l = static_cast(l64);
while ((e - p) >= 16) {
ABSL_INTERNAL_STEP8(l, p);
ABSL_INTERNAL_STEP8(l, p);
}
// Process the last few bytes
while (p != e) {
ABSL_INTERNAL_STEP1(l);
}
#undef ABSL_INTERNAL_STEP8BY3
#undef ABSL_INTERNAL_STEP8BY2
#undef ABSL_INTERNAL_STEP8
#undef ABSL_INTERNAL_STEP4
#undef ABSL_INTERNAL_STEP2
#undef ABSL_INTERNAL_STEP1
*crc = l;
}
};
} // namespace
// Intel processors with SSE4.2 have an instruction for one particular
// 32-bit CRC polynomial: crc32c
CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() {
CpuType type = GetCpuType();
switch (type) {
case CpuType::kIntelHaswell:
case CpuType::kAmdRome:
case CpuType::kAmdNaples:
case CpuType::kAmdMilan:
return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
3, 1, CutoffStrategy::Fold3>();
// PCLMULQDQ is fast, use combined PCLMULQDQ + CRC implementation.
case CpuType::kIntelCascadelakeXeon:
case CpuType::kIntelSkylakeXeon:
case CpuType::kIntelBroadwell:
case CpuType::kIntelSkylake:
return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
3, 2, CutoffStrategy::Fold3>();
// PCLMULQDQ is slow, don't use it.
case CpuType::kIntelIvybridge:
case CpuType::kIntelSandybridge:
case CpuType::kIntelWestmere:
return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
3, 0, CutoffStrategy::Fold3>();
case CpuType::kArmNeoverseN1:
return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
1, 1, CutoffStrategy::Unroll64CRC>();
#if defined(__aarch64__)
default:
// Not all ARM processors support the needed instructions, so check here
// before trying to use an accelerated implementation.
if (SupportsArmCRC32PMULL()) {
return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
1, 1, CutoffStrategy::Unroll64CRC>();
} else {
return nullptr;
}
#else
default:
// Something else, play it safe and assume slow PCLMULQDQ.
return new CRC32AcceleratedX86ARMCombinedMultipleStreams<
3, 0, CutoffStrategy::Fold3>();
#endif
}
}
std::vector> NewCRC32AcceleratedX86ARMCombinedAll() {
auto ret = std::vector>();
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
ret.push_back(absl::make_unique>());
return ret;
}
#else // !ABSL_INTERNAL_CAN_USE_SIMD_CRC32C
std::vector> NewCRC32AcceleratedX86ARMCombinedAll() {
return std::vector>();
}
// no hardware acceleration available
CRCImpl* TryNewCRC32AcceleratedX86ARMCombined() { return nullptr; }
#endif
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc32c.h 0000644 0001750 0001751 00000002357 14737212474 022163 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_CRC32C_H_
#define ABSL_CRC_INTERNAL_CRC32C_H_
#include "absl/base/config.h"
#include "absl/crc/crc32c.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
// Modifies a CRC32 value by removing `length` bytes with a value of 0 from
// the end of the string.
//
// This is the inverse operation of ExtendCrc32cByZeroes().
//
// This operation has a runtime cost of O(log(`length`))
//
// Internal implementation detail, exposed for testing only.
crc32c_t UnextendCrc32cByZeroes(crc32c_t initial_crc, size_t length);
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_CRC_INTERNAL_CRC32C_H_
s2/tools/vendor/abseil-cpp/absl/crc/internal/cpu_detect.cc 0000644 0001750 0001751 00000017006 14737212474 023356 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/crc/internal/cpu_detect.h"
#include
#include
#include "absl/base/config.h"
#if defined(__aarch64__) && defined(__linux__)
#include
#include
#endif
#if defined(_WIN32) || defined(_WIN64)
#include
#endif
#if defined(__x86_64__) || defined(_M_X64)
#if ABSL_HAVE_BUILTIN(__cpuid)
// MSVC-equivalent __cpuid intrinsic declaration for clang-like compilers
// for non-Windows build environments.
extern void __cpuid(int[4], int);
#elif !defined(_WIN32) && !defined(_WIN64)
// MSVC defines this function for us.
// https://learn.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex
static void __cpuid(int cpu_info[4], int info_type) {
__asm__ volatile("cpuid \n\t"
: "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]),
"=d"(cpu_info[3])
: "a"(info_type), "c"(0));
}
#endif // !defined(_WIN32) && !defined(_WIN64)
#endif // defined(__x86_64__) || defined(_M_X64)
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
#if defined(__x86_64__) || defined(_M_X64)
namespace {
enum class Vendor {
kUnknown,
kIntel,
kAmd,
};
Vendor GetVendor() {
// Get the vendor string (issue CPUID with eax = 0).
int cpu_info[4];
__cpuid(cpu_info, 0);
std::string vendor;
vendor.append(reinterpret_cast(&cpu_info[1]), 4);
vendor.append(reinterpret_cast(&cpu_info[3]), 4);
vendor.append(reinterpret_cast(&cpu_info[2]), 4);
if (vendor == "GenuineIntel") {
return Vendor::kIntel;
} else if (vendor == "AuthenticAMD") {
return Vendor::kAmd;
} else {
return Vendor::kUnknown;
}
}
CpuType GetIntelCpuType() {
// To get general information and extended features we send eax = 1 and
// ecx = 0 to cpuid. The response is returned in eax, ebx, ecx and edx.
// (See Intel 64 and IA-32 Architectures Software Developer's Manual
// Volume 2A: Instruction Set Reference, A-M CPUID).
// https://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-software-developer-vol-2a-manual.html
// https://learn.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex
int cpu_info[4];
__cpuid(cpu_info, 1);
// Response in eax bits as follows:
// 0-3 (stepping id)
// 4-7 (model number),
// 8-11 (family code),
// 12-13 (processor type),
// 16-19 (extended model)
// 20-27 (extended family)
int family = (cpu_info[0] >> 8) & 0x0f;
int model_num = (cpu_info[0] >> 4) & 0x0f;
int ext_family = (cpu_info[0] >> 20) & 0xff;
int ext_model_num = (cpu_info[0] >> 16) & 0x0f;
int brand_id = cpu_info[1] & 0xff;
// Process the extended family and model info if necessary
if (family == 0x0f) {
family += ext_family;
}
if (family == 0x0f || family == 0x6) {
model_num += (ext_model_num << 4);
}
switch (brand_id) {
case 0: // no brand ID, so parse CPU family/model
switch (family) {
case 6: // Most PentiumIII processors are in this category
switch (model_num) {
case 0x2c: // Westmere: Gulftown
return CpuType::kIntelWestmere;
case 0x2d: // Sandybridge
return CpuType::kIntelSandybridge;
case 0x3e: // Ivybridge
return CpuType::kIntelIvybridge;
case 0x3c: // Haswell (client)
case 0x3f: // Haswell
return CpuType::kIntelHaswell;
case 0x4f: // Broadwell
case 0x56: // BroadwellDE
return CpuType::kIntelBroadwell;
case 0x55: // Skylake Xeon
if ((cpu_info[0] & 0x0f) < 5) { // stepping < 5 is skylake
return CpuType::kIntelSkylakeXeon;
} else { // stepping >= 5 is cascadelake
return CpuType::kIntelCascadelakeXeon;
}
case 0x5e: // Skylake (client)
return CpuType::kIntelSkylake;
default:
return CpuType::kUnknown;
}
default:
return CpuType::kUnknown;
}
default:
return CpuType::kUnknown;
}
}
CpuType GetAmdCpuType() {
// To get general information and extended features we send eax = 1 and
// ecx = 0 to cpuid. The response is returned in eax, ebx, ecx and edx.
// (See Intel 64 and IA-32 Architectures Software Developer's Manual
// Volume 2A: Instruction Set Reference, A-M CPUID).
// https://learn.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex
int cpu_info[4];
__cpuid(cpu_info, 1);
// Response in eax bits as follows:
// 0-3 (stepping id)
// 4-7 (model number),
// 8-11 (family code),
// 12-13 (processor type),
// 16-19 (extended model)
// 20-27 (extended family)
int family = (cpu_info[0] >> 8) & 0x0f;
int model_num = (cpu_info[0] >> 4) & 0x0f;
int ext_family = (cpu_info[0] >> 20) & 0xff;
int ext_model_num = (cpu_info[0] >> 16) & 0x0f;
if (family == 0x0f) {
family += ext_family;
model_num += (ext_model_num << 4);
}
switch (family) {
case 0x17:
switch (model_num) {
case 0x0: // Stepping Ax
case 0x1: // Stepping Bx
return CpuType::kAmdNaples;
case 0x30: // Stepping Ax
case 0x31: // Stepping Bx
return CpuType::kAmdRome;
default:
return CpuType::kUnknown;
}
break;
case 0x19:
switch (model_num) {
case 0x1: // Stepping B0
return CpuType::kAmdMilan;
default:
return CpuType::kUnknown;
}
break;
default:
return CpuType::kUnknown;
}
}
} // namespace
CpuType GetCpuType() {
switch (GetVendor()) {
case Vendor::kIntel:
return GetIntelCpuType();
case Vendor::kAmd:
return GetAmdCpuType();
default:
return CpuType::kUnknown;
}
}
bool SupportsArmCRC32PMULL() { return false; }
#elif defined(__aarch64__) && defined(__linux__)
#ifndef HWCAP_CPUID
#define HWCAP_CPUID (1 << 11)
#endif
#define ABSL_INTERNAL_AARCH64_ID_REG_READ(id, val) \
asm("mrs %0, " #id : "=r"(val))
CpuType GetCpuType() {
// MIDR_EL1 is not visible to EL0, however the access will be emulated by
// linux if AT_HWCAP has HWCAP_CPUID set.
//
// This method will be unreliable on heterogeneous computing systems (ex:
// big.LITTLE) since the value of MIDR_EL1 will change based on the calling
// thread.
uint64_t hwcaps = getauxval(AT_HWCAP);
if (hwcaps & HWCAP_CPUID) {
uint64_t midr = 0;
ABSL_INTERNAL_AARCH64_ID_REG_READ(MIDR_EL1, midr);
uint32_t implementer = (midr >> 24) & 0xff;
uint32_t part_number = (midr >> 4) & 0xfff;
if (implementer == 0x41 && part_number == 0xd0c) {
return CpuType::kArmNeoverseN1;
}
}
return CpuType::kUnknown;
}
bool SupportsArmCRC32PMULL() {
uint64_t hwcaps = getauxval(AT_HWCAP);
return (hwcaps & HWCAP_CRC32) && (hwcaps & HWCAP_PMULL);
}
#else
CpuType GetCpuType() { return CpuType::kUnknown; }
bool SupportsArmCRC32PMULL() { return false; }
#endif
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
s2/tools/vendor/abseil-cpp/absl/crc/internal/non_temporal_arm_intrinsics.h 0000644 0001750 0001751 00000006267 14737212474 026711 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_NON_TEMPORAL_ARM_INTRINSICS_H_
#define ABSL_CRC_INTERNAL_NON_TEMPORAL_ARM_INTRINSICS_H_
#include "absl/base/config.h"
#ifdef __aarch64__
#include
typedef int64x2_t __m128i; /* 128-bit vector containing integers */
#define vreinterpretq_m128i_s32(x) vreinterpretq_s64_s32(x)
#define vreinterpretq_s64_m128i(x) (x)
// Guarantees that every preceding store is globally visible before any
// subsequent store.
// https://msdn.microsoft.com/en-us/library/5h2w73d1%28v=vs.90%29.aspx
static inline __attribute__((always_inline)) void _mm_sfence(void) {
__sync_synchronize();
}
// Load 128-bits of integer data from unaligned memory into dst. This intrinsic
// may perform better than _mm_loadu_si128 when the data crosses a cache line
// boundary.
//
// dst[127:0] := MEM[mem_addr+127:mem_addr]
//
// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_lddqu_si128
#define _mm_lddqu_si128 _mm_loadu_si128
// Loads 128-bit value. :
// https://msdn.microsoft.com/zh-cn/library/f4k12ae8(v=vs.90).aspx
static inline __attribute__((always_inline)) __m128i _mm_loadu_si128(
const __m128i *p) {
return vreinterpretq_m128i_s32(vld1q_s32((const int32_t *)p));
}
// Stores the data in a to the address p without polluting the caches. If the
// cache line containing address p is already in the cache, the cache will be
// updated.
// https://msdn.microsoft.com/en-us/library/ba08y07y%28v=vs.90%29.aspx
static inline __attribute__((always_inline)) void _mm_stream_si128(__m128i *p,
__m128i a) {
#if ABSL_HAVE_BUILTIN(__builtin_nontemporal_store)
__builtin_nontemporal_store(a, p);
#else
vst1q_s64((int64_t *)p, vreinterpretq_s64_m128i(a));
#endif
}
// Sets the 16 signed 8-bit integer values.
// https://msdn.microsoft.com/en-us/library/x0cx8zd3(v=vs.90).aspx
static inline __attribute__((always_inline)) __m128i _mm_set_epi8(
signed char b15, signed char b14, signed char b13, signed char b12,
signed char b11, signed char b10, signed char b9, signed char b8,
signed char b7, signed char b6, signed char b5, signed char b4,
signed char b3, signed char b2, signed char b1, signed char b0) {
int8_t __attribute__((aligned(16)))
data[16] = {(int8_t)b0, (int8_t)b1, (int8_t)b2, (int8_t)b3,
(int8_t)b4, (int8_t)b5, (int8_t)b6, (int8_t)b7,
(int8_t)b8, (int8_t)b9, (int8_t)b10, (int8_t)b11,
(int8_t)b12, (int8_t)b13, (int8_t)b14, (int8_t)b15};
return (__m128i)vld1q_s8(data);
}
#endif // __aarch64__
#endif // ABSL_CRC_INTERNAL_NON_TEMPORAL_ARM_INTRINSICS_H_
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc32c_inline.h 0000644 0001750 0001751 00000004074 14737212474 023517 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_CRC32C_INLINE_H_
#define ABSL_CRC_INTERNAL_CRC32C_INLINE_H_
#include
#include "absl/base/config.h"
#include "absl/base/internal/endian.h"
#include "absl/crc/internal/crc32_x86_arm_combined_simd.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
// CRC32C implementation optimized for small inputs.
// Either computes crc and return true, or if there is
// no hardware support does nothing and returns false.
inline bool ExtendCrc32cInline(uint32_t* crc, const char* p, size_t n) {
#if defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD) || \
defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
constexpr uint32_t kCrc32Xor = 0xffffffffU;
*crc ^= kCrc32Xor;
if (n & 1) {
*crc = CRC32_u8(*crc, static_cast(*p));
n--;
p++;
}
if (n & 2) {
*crc = CRC32_u16(*crc, absl::little_endian::Load16(p));
n -= 2;
p += 2;
}
if (n & 4) {
*crc = CRC32_u32(*crc, absl::little_endian::Load32(p));
n -= 4;
p += 4;
}
while (n) {
*crc = CRC32_u64(*crc, absl::little_endian::Load64(p));
n -= 8;
p += 8;
}
*crc ^= kCrc32Xor;
return true;
#else
// No hardware support, signal the need to fallback.
static_cast(crc);
static_cast(p);
static_cast(n);
return false;
#endif // defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD) ||
// defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
}
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_CRC_INTERNAL_CRC32C_INLINE_H_
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc_memcpy_x86_64.cc 0000644 0001750 0001751 00000041573 14737212474 024404 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Simultaneous memcopy and CRC-32C for x86-64. Uses integer registers because
// XMM registers do not support the CRC instruction (yet). While copying,
// compute the running CRC of the data being copied.
//
// It is assumed that any CPU running this code has SSE4.2 instructions
// available (for CRC32C). This file will do nothing if that is not true.
//
// The CRC instruction has a 3-byte latency, and we are stressing the ALU ports
// here (unlike a traditional memcopy, which has almost no ALU use), so we will
// need to copy in such a way that the CRC unit is used efficiently. We have two
// regimes in this code:
// 1. For operations of size < kCrcSmallSize, do the CRC then the memcpy
// 2. For operations of size > kCrcSmallSize:
// a) compute an initial CRC + copy on a small amount of data to align the
// destination pointer on a 16-byte boundary.
// b) Split the data into 3 main regions and a tail (smaller than 48 bytes)
// c) Do the copy and CRC of the 3 main regions, interleaving (start with
// full cache line copies for each region, then move to single 16 byte
// pieces per region).
// d) Combine the CRCs with CRC32C::Concat.
// e) Copy the tail and extend the CRC with the CRC of the tail.
// This method is not ideal for op sizes between ~1k and ~8k because CRC::Concat
// takes a significant amount of time. A medium-sized approach could be added
// using 3 CRCs over fixed-size blocks where the zero-extensions required for
// CRC32C::Concat can be precomputed.
#ifdef __SSE4_2__
#include
#endif
#ifdef _MSC_VER
#include
#endif
#include
#include
#include
#include
#include "absl/base/dynamic_annotations.h"
#include "absl/base/optimization.h"
#include "absl/base/prefetch.h"
#include "absl/crc/crc32c.h"
#include "absl/crc/internal/cpu_detect.h"
#include "absl/crc/internal/crc_memcpy.h"
#include "absl/strings/string_view.h"
#ifdef ABSL_INTERNAL_HAVE_X86_64_ACCELERATED_CRC_MEMCPY_ENGINE
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
namespace {
inline crc32c_t ShortCrcCopy(char* dst, const char* src, std::size_t length,
crc32c_t crc) {
// Small copy: just go 1 byte at a time: being nice to the branch predictor
// is more important here than anything else
uint32_t crc_uint32 = static_cast(crc);
for (std::size_t i = 0; i < length; i++) {
uint8_t data = *reinterpret_cast(src);
crc_uint32 = _mm_crc32_u8(crc_uint32, data);
*reinterpret_cast(dst) = data;
++src;
++dst;
}
return crc32c_t{crc_uint32};
}
constexpr size_t kIntLoadsPerVec = sizeof(__m128i) / sizeof(uint64_t);
// Common function for copying the tails of multiple large regions.
template
inline void LargeTailCopy(crc32c_t* crcs, char** dst, const char** src,
size_t region_size, size_t copy_rounds) {
std::array<__m128i, vec_regions> data;
std::array int_data;
while (copy_rounds > 0) {
for (size_t i = 0; i < vec_regions; i++) {
size_t region = i;
auto* vsrc =
reinterpret_cast(*src + region_size * region);
auto* vdst = reinterpret_cast<__m128i*>(*dst + region_size * region);
// Load the blocks, unaligned
data[i] = _mm_loadu_si128(vsrc);
// Store the blocks, aligned
_mm_store_si128(vdst, data[i]);
// Compute the running CRC
crcs[region] = crc32c_t{static_cast(
_mm_crc32_u64(static_cast(crcs[region]),
static_cast(_mm_extract_epi64(data[i], 0))))};
crcs[region] = crc32c_t{static_cast(
_mm_crc32_u64(static_cast(crcs[region]),
static_cast(_mm_extract_epi64(data[i], 1))))};
}
for (size_t i = 0; i < int_regions; i++) {
size_t region = vec_regions + i;
auto* usrc =
reinterpret_cast(*src + region_size * region);
auto* udst = reinterpret_cast(*dst + region_size * region);
for (size_t j = 0; j < kIntLoadsPerVec; j++) {
size_t data_index = i * kIntLoadsPerVec + j;
int_data[data_index] = *(usrc + j);
crcs[region] = crc32c_t{static_cast(_mm_crc32_u64(
static_cast(crcs[region]), int_data[data_index]))};
*(udst + j) = int_data[data_index];
}
}
// Increment pointers
*src += sizeof(__m128i);
*dst += sizeof(__m128i);
--copy_rounds;
}
}
} // namespace
template
class AcceleratedCrcMemcpyEngine : public CrcMemcpyEngine {
public:
AcceleratedCrcMemcpyEngine() = default;
AcceleratedCrcMemcpyEngine(const AcceleratedCrcMemcpyEngine&) = delete;
AcceleratedCrcMemcpyEngine operator=(const AcceleratedCrcMemcpyEngine&) =
delete;
crc32c_t Compute(void* __restrict dst, const void* __restrict src,
std::size_t length, crc32c_t initial_crc) const override;
};
template
crc32c_t AcceleratedCrcMemcpyEngine::Compute(
void* __restrict dst, const void* __restrict src, std::size_t length,
crc32c_t initial_crc) const {
constexpr std::size_t kRegions = vec_regions + int_regions;
constexpr uint32_t kCrcDataXor = uint32_t{0xffffffff};
constexpr std::size_t kBlockSize = sizeof(__m128i);
constexpr std::size_t kCopyRoundSize = kRegions * kBlockSize;
// Number of blocks per cacheline.
constexpr std::size_t kBlocksPerCacheLine = ABSL_CACHELINE_SIZE / kBlockSize;
char* dst_bytes = static_cast(dst);
const char* src_bytes = static_cast(src);
// Make sure that one prefetch per big block is enough to cover the whole
// dataset, and we don't prefetch too much.
static_assert(ABSL_CACHELINE_SIZE % kBlockSize == 0,
"Cache lines are not divided evenly into blocks, may have "
"unintended behavior!");
// Experimentally-determined boundary between a small and large copy.
// Below this number, spin-up and concatenation of CRCs takes enough time that
// it kills the throughput gains of using 3 regions and wide vectors.
constexpr size_t kCrcSmallSize = 256;
// Experimentally-determined prefetch distance. Main loop copies will
// prefeth data 2 cache lines ahead.
constexpr std::size_t kPrefetchAhead = 2 * ABSL_CACHELINE_SIZE;
// Small-size CRC-memcpy : just do CRC + memcpy
if (length < kCrcSmallSize) {
crc32c_t crc =
ExtendCrc32c(initial_crc, absl::string_view(src_bytes, length));
memcpy(dst, src, length);
return crc;
}
// Start work on the CRC: undo the XOR from the previous calculation or set up
// the initial value of the CRC.
// initial_crc ^= kCrcDataXor;
initial_crc = crc32c_t{static_cast(initial_crc) ^ kCrcDataXor};
// Do an initial alignment copy, so we can use aligned store instructions to
// the destination pointer. We align the destination pointer because the
// penalty for an unaligned load is small compared to the penalty of an
// unaligned store on modern CPUs.
std::size_t bytes_from_last_aligned =
reinterpret_cast(dst) & (kBlockSize - 1);
if (bytes_from_last_aligned != 0) {
std::size_t bytes_for_alignment = kBlockSize - bytes_from_last_aligned;
// Do the short-sized copy and CRC.
initial_crc =
ShortCrcCopy(dst_bytes, src_bytes, bytes_for_alignment, initial_crc);
src_bytes += bytes_for_alignment;
dst_bytes += bytes_for_alignment;
length -= bytes_for_alignment;
}
// We are going to do the copy and CRC in kRegions regions to make sure that
// we can saturate the CRC unit. The CRCs will be combined at the end of the
// run. Copying will use the SSE registers, and we will extract words from
// the SSE registers to add to the CRC. Initially, we run the loop one full
// cache line per region at a time, in order to insert prefetches.
// Initialize CRCs for kRegions regions.
crc32c_t crcs[kRegions];
crcs[0] = initial_crc;
for (size_t i = 1; i < kRegions; i++) {
crcs[i] = crc32c_t{kCrcDataXor};
}
// Find the number of rounds to copy and the region size. Also compute the
// tail size here.
size_t copy_rounds = length / kCopyRoundSize;
// Find the size of each region and the size of the tail.
const std::size_t region_size = copy_rounds * kBlockSize;
const std::size_t tail_size = length - (kRegions * region_size);
// Holding registers for data in each region.
std::array<__m128i, vec_regions> vec_data;
std::array int_data;
// Main loop.
while (copy_rounds > kBlocksPerCacheLine) {
// Prefetch kPrefetchAhead bytes ahead of each pointer.
for (size_t i = 0; i < kRegions; i++) {
absl::PrefetchToLocalCache(src_bytes + kPrefetchAhead + region_size * i);
absl::PrefetchToLocalCache(dst_bytes + kPrefetchAhead + region_size * i);
}
// Load and store data, computing CRC on the way.
for (size_t i = 0; i < kBlocksPerCacheLine; i++) {
// Copy and CRC the data for the CRC regions.
for (size_t j = 0; j < vec_regions; j++) {
// Cycle which regions get vector load/store and integer load/store, to
// engage prefetching logic around vector load/stores and save issue
// slots by using the integer registers.
size_t region = (j + i) % kRegions;
auto* vsrc =
reinterpret_cast(src_bytes + region_size * region);
auto* vdst =
reinterpret_cast<__m128i*>(dst_bytes + region_size * region);
// Load and CRC data.
vec_data[j] = _mm_loadu_si128(vsrc + i);
crcs[region] = crc32c_t{static_cast(_mm_crc32_u64(
static_cast(crcs[region]),
static_cast(_mm_extract_epi64(vec_data[j], 0))))};
crcs[region] = crc32c_t{static_cast(_mm_crc32_u64(
static_cast(crcs[region]),
static_cast(_mm_extract_epi64(vec_data[j], 1))))};
// Store the data.
_mm_store_si128(vdst + i, vec_data[j]);
}
// Preload the partial CRCs for the CLMUL subregions.
for (size_t j = 0; j < int_regions; j++) {
// Cycle which regions get vector load/store and integer load/store, to
// engage prefetching logic around vector load/stores and save issue
// slots by using the integer registers.
size_t region = (j + vec_regions + i) % kRegions;
auto* usrc =
reinterpret_cast(src_bytes + region_size * region);
auto* udst =
reinterpret_cast(dst_bytes + region_size * region);
for (size_t k = 0; k < kIntLoadsPerVec; k++) {
size_t data_index = j * kIntLoadsPerVec + k;
// Load and CRC the data.
int_data[data_index] = *(usrc + i * kIntLoadsPerVec + k);
crcs[region] = crc32c_t{static_cast(_mm_crc32_u64(
static_cast(crcs[region]), int_data[data_index]))};
// Store the data.
*(udst + i * kIntLoadsPerVec + k) = int_data[data_index];
}
}
}
// Increment pointers
src_bytes += kBlockSize * kBlocksPerCacheLine;
dst_bytes += kBlockSize * kBlocksPerCacheLine;
copy_rounds -= kBlocksPerCacheLine;
}
// Copy and CRC the tails of each region.
LargeTailCopy(crcs, &dst_bytes, &src_bytes,
region_size, copy_rounds);
// Move the source and destination pointers to the end of the region
src_bytes += region_size * (kRegions - 1);
dst_bytes += region_size * (kRegions - 1);
// Finalize the first CRCs: XOR the internal CRCs by the XOR mask to undo the
// XOR done before doing block copy + CRCs.
for (size_t i = 0; i + 1 < kRegions; i++) {
crcs[i] = crc32c_t{static_cast(crcs[i]) ^ kCrcDataXor};
}
// Build a CRC of the first kRegions - 1 regions.
crc32c_t full_crc = crcs[0];
for (size_t i = 1; i + 1 < kRegions; i++) {
full_crc = ConcatCrc32c(full_crc, crcs[i], region_size);
}
// Copy and CRC the tail through the XMM registers.
std::size_t tail_blocks = tail_size / kBlockSize;
LargeTailCopy<0, 1>(&crcs[kRegions - 1], &dst_bytes, &src_bytes, 0,
tail_blocks);
// Final tail copy for under 16 bytes.
crcs[kRegions - 1] =
ShortCrcCopy(dst_bytes, src_bytes, tail_size - tail_blocks * kBlockSize,
crcs[kRegions - 1]);
// Finalize and concatenate the final CRC, then return.
crcs[kRegions - 1] =
crc32c_t{static_cast(crcs[kRegions - 1]) ^ kCrcDataXor};
return ConcatCrc32c(full_crc, crcs[kRegions - 1], region_size + tail_size);
}
CrcMemcpy::ArchSpecificEngines CrcMemcpy::GetArchSpecificEngines() {
#ifdef UNDEFINED_BEHAVIOR_SANITIZER
// UBSAN does not play nicely with unaligned loads (which we use a lot).
// Get the underlying architecture.
CpuType cpu_type = GetCpuType();
switch (cpu_type) {
case CpuType::kUnknown:
case CpuType::kAmdRome:
case CpuType::kAmdNaples:
case CpuType::kIntelCascadelakeXeon:
case CpuType::kIntelSkylakeXeon:
case CpuType::kIntelSkylake:
case CpuType::kIntelBroadwell:
case CpuType::kIntelHaswell:
case CpuType::kIntelIvybridge:
return {
/*.temporal=*/new FallbackCrcMemcpyEngine(),
/*.non_temporal=*/new CrcNonTemporalMemcpyAVXEngine(),
};
// INTEL_SANDYBRIDGE performs better with SSE than AVX.
case CpuType::kIntelSandybridge:
return {
/*.temporal=*/new FallbackCrcMemcpyEngine(),
/*.non_temporal=*/new CrcNonTemporalMemcpyEngine(),
};
default:
return {/*.temporal=*/new FallbackCrcMemcpyEngine(),
/*.non_temporal=*/new FallbackCrcMemcpyEngine()};
}
#else
// Get the underlying architecture.
CpuType cpu_type = GetCpuType();
switch (cpu_type) {
// On Zen 2, PEXTRQ uses 2 micro-ops, including one on the vector store port
// which data movement from the vector registers to the integer registers
// (where CRC32C happens) to crowd the same units as vector stores. As a
// result, using that path exclusively causes bottlenecking on this port.
// We can avoid this bottleneck by using the integer side of the CPU for
// most operations rather than the vector side. We keep a vector region to
// engage some of the prefetching logic in the cache hierarchy which seems
// to give vector instructions special treatment. These prefetch units see
// strided access to each region, and do the right thing.
case CpuType::kAmdRome:
case CpuType::kAmdNaples:
return {
/*.temporal=*/new AcceleratedCrcMemcpyEngine<1, 2>(),
/*.non_temporal=*/new CrcNonTemporalMemcpyAVXEngine(),
};
// PCLMULQDQ is slow and we don't have wide enough issue width to take
// advantage of it. For an unknown architecture, don't risk using CLMULs.
case CpuType::kIntelCascadelakeXeon:
case CpuType::kIntelSkylakeXeon:
case CpuType::kIntelSkylake:
case CpuType::kIntelBroadwell:
case CpuType::kIntelHaswell:
case CpuType::kIntelIvybridge:
return {
/*.temporal=*/new AcceleratedCrcMemcpyEngine<3, 0>(),
/*.non_temporal=*/new CrcNonTemporalMemcpyAVXEngine(),
};
// INTEL_SANDYBRIDGE performs better with SSE than AVX.
case CpuType::kIntelSandybridge:
return {
/*.temporal=*/new AcceleratedCrcMemcpyEngine<3, 0>(),
/*.non_temporal=*/new CrcNonTemporalMemcpyEngine(),
};
default:
return {/*.temporal=*/new FallbackCrcMemcpyEngine(),
/*.non_temporal=*/new FallbackCrcMemcpyEngine()};
}
#endif // UNDEFINED_BEHAVIOR_SANITIZER
}
// For testing, allow the user to specify which engine they want.
std::unique_ptr CrcMemcpy::GetTestEngine(int vector,
int integer) {
if (vector == 3 && integer == 0) {
return std::make_unique>();
} else if (vector == 1 && integer == 2) {
return std::make_unique>();
}
return nullptr;
}
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_INTERNAL_HAVE_X86_64_ACCELERATED_CRC_MEMCPY_ENGINE
s2/tools/vendor/abseil-cpp/absl/crc/internal/cpu_detect.h 0000644 0001750 0001751 00000003336 14737212474 023221 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_CPU_DETECT_H_
#define ABSL_CRC_INTERNAL_CPU_DETECT_H_
#include "absl/base/config.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
// Enumeration of architectures that we have special-case tuning parameters for.
// This set may change over time.
enum class CpuType {
kUnknown,
kIntelHaswell,
kAmdRome,
kAmdNaples,
kAmdMilan,
kIntelCascadelakeXeon,
kIntelSkylakeXeon,
kIntelBroadwell,
kIntelSkylake,
kIntelIvybridge,
kIntelSandybridge,
kIntelWestmere,
kArmNeoverseN1,
};
// Returns the type of host CPU this code is running on. Returns kUnknown if
// the host CPU is of unknown type, or if detection otherwise fails.
CpuType GetCpuType();
// Returns whether the host CPU supports the CPU features needed for our
// accelerated implementations. The CpuTypes enumerated above apart from
// kUnknown support the required features. On unknown CPUs, we can use
// this to see if it's safe to use hardware acceleration, though without any
// tuning.
bool SupportsArmCRC32PMULL();
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_CRC_INTERNAL_CPU_DETECT_H_
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc_memcpy_fallback.cc 0000644 0001750 0001751 00000005217 14737212474 025200 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include
#include
#include "absl/base/config.h"
#include "absl/crc/crc32c.h"
#include "absl/crc/internal/crc_memcpy.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
absl::crc32c_t FallbackCrcMemcpyEngine::Compute(void* __restrict dst,
const void* __restrict src,
std::size_t length,
crc32c_t initial_crc) const {
constexpr size_t kBlockSize = 8192;
absl::crc32c_t crc = initial_crc;
const char* src_bytes = reinterpret_cast(src);
char* dst_bytes = reinterpret_cast(dst);
// Copy + CRC loop - run 8k chunks until we are out of full chunks. CRC
// then copy was found to be slightly more efficient in our test cases.
std::size_t offset = 0;
for (; offset + kBlockSize < length; offset += kBlockSize) {
crc = absl::ExtendCrc32c(crc,
absl::string_view(src_bytes + offset, kBlockSize));
memcpy(dst_bytes + offset, src_bytes + offset, kBlockSize);
}
// Save some work if length is 0.
if (offset < length) {
std::size_t final_copy_size = length - offset;
crc = absl::ExtendCrc32c(
crc, absl::string_view(src_bytes + offset, final_copy_size));
memcpy(dst_bytes + offset, src_bytes + offset, final_copy_size);
}
return crc;
}
// Compile the following only if we don't have
#ifndef ABSL_INTERNAL_HAVE_X86_64_ACCELERATED_CRC_MEMCPY_ENGINE
CrcMemcpy::ArchSpecificEngines CrcMemcpy::GetArchSpecificEngines() {
CrcMemcpy::ArchSpecificEngines engines;
engines.temporal = new FallbackCrcMemcpyEngine();
engines.non_temporal = new FallbackCrcMemcpyEngine();
return engines;
}
std::unique_ptr CrcMemcpy::GetTestEngine(int /*vector*/,
int /*integer*/) {
return std::make_unique();
}
#endif // ABSL_INTERNAL_HAVE_X86_64_ACCELERATED_CRC_MEMCPY_ENGINE
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc_memcpy.h 0000644 0001750 0001751 00000010312 14737212474 023213 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_CRC_MEMCPY_H_
#define ABSL_CRC_INTERNAL_CRC_MEMCPY_H_
#include
#include
#include "absl/base/config.h"
#include "absl/crc/crc32c.h"
// Defined if the class AcceleratedCrcMemcpyEngine exists.
#if defined(__x86_64__) && defined(__SSE4_2__)
#define ABSL_INTERNAL_HAVE_X86_64_ACCELERATED_CRC_MEMCPY_ENGINE 1
#elif defined(_MSC_VER) && defined(__AVX__)
#define ABSL_INTERNAL_HAVE_X86_64_ACCELERATED_CRC_MEMCPY_ENGINE 1
#endif
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
class CrcMemcpyEngine {
public:
virtual ~CrcMemcpyEngine() = default;
virtual crc32c_t Compute(void* __restrict dst, const void* __restrict src,
std::size_t length, crc32c_t initial_crc) const = 0;
protected:
CrcMemcpyEngine() = default;
};
class CrcMemcpy {
public:
static crc32c_t CrcAndCopy(void* __restrict dst, const void* __restrict src,
std::size_t length,
crc32c_t initial_crc = crc32c_t{0},
bool non_temporal = false) {
static const ArchSpecificEngines engines = GetArchSpecificEngines();
auto* engine = non_temporal ? engines.non_temporal : engines.temporal;
return engine->Compute(dst, src, length, initial_crc);
}
// For testing only: get an architecture-specific engine for tests.
static std::unique_ptr GetTestEngine(int vector,
int integer);
private:
struct ArchSpecificEngines {
CrcMemcpyEngine* temporal;
CrcMemcpyEngine* non_temporal;
};
static ArchSpecificEngines GetArchSpecificEngines();
};
// Fallback CRC-memcpy engine.
class FallbackCrcMemcpyEngine : public CrcMemcpyEngine {
public:
FallbackCrcMemcpyEngine() = default;
FallbackCrcMemcpyEngine(const FallbackCrcMemcpyEngine&) = delete;
FallbackCrcMemcpyEngine operator=(const FallbackCrcMemcpyEngine&) = delete;
crc32c_t Compute(void* __restrict dst, const void* __restrict src,
std::size_t length, crc32c_t initial_crc) const override;
};
// CRC Non-Temporal-Memcpy engine.
class CrcNonTemporalMemcpyEngine : public CrcMemcpyEngine {
public:
CrcNonTemporalMemcpyEngine() = default;
CrcNonTemporalMemcpyEngine(const CrcNonTemporalMemcpyEngine&) = delete;
CrcNonTemporalMemcpyEngine operator=(const CrcNonTemporalMemcpyEngine&) =
delete;
crc32c_t Compute(void* __restrict dst, const void* __restrict src,
std::size_t length, crc32c_t initial_crc) const override;
};
// CRC Non-Temporal-Memcpy AVX engine.
class CrcNonTemporalMemcpyAVXEngine : public CrcMemcpyEngine {
public:
CrcNonTemporalMemcpyAVXEngine() = default;
CrcNonTemporalMemcpyAVXEngine(const CrcNonTemporalMemcpyAVXEngine&) = delete;
CrcNonTemporalMemcpyAVXEngine operator=(
const CrcNonTemporalMemcpyAVXEngine&) = delete;
crc32c_t Compute(void* __restrict dst, const void* __restrict src,
std::size_t length, crc32c_t initial_crc) const override;
};
// Copy source to destination and return the CRC32C of the data copied. If an
// accelerated version is available, use the accelerated version, otherwise use
// the generic fallback version.
inline crc32c_t Crc32CAndCopy(void* __restrict dst, const void* __restrict src,
std::size_t length,
crc32c_t initial_crc = crc32c_t{0},
bool non_temporal = false) {
return CrcMemcpy::CrcAndCopy(dst, src, length, initial_crc, non_temporal);
}
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_CRC_INTERNAL_CRC_MEMCPY_H_
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc32_x86_arm_combined_simd.h 0000644 0001750 0001751 00000017776 14737212474 026253 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_CRC32_X86_ARM_COMBINED_SIMD_H_
#define ABSL_CRC_INTERNAL_CRC32_X86_ARM_COMBINED_SIMD_H_
#include
#include "absl/base/config.h"
// -------------------------------------------------------------------------
// Many x86 and ARM machines have CRC acceleration hardware.
// We can do a faster version of Extend() on such machines.
// We define a translation layer for both x86 and ARM for the ease of use and
// most performance gains.
// This implementation requires 64-bit CRC instructions (part of SSE 4.2) and
// PCLMULQDQ instructions. 32-bit builds with SSE 4.2 do exist, so the
// __x86_64__ condition is necessary.
#if defined(__x86_64__) && defined(__SSE4_2__) && defined(__PCLMUL__)
#include
#define ABSL_CRC_INTERNAL_HAVE_X86_SIMD
#elif defined(_MSC_VER) && !defined(__clang__) && defined(__AVX__)
// MSVC AVX (/arch:AVX) implies SSE 4.2 and PCLMULQDQ.
#include
#define ABSL_CRC_INTERNAL_HAVE_X86_SIMD
#elif defined(__aarch64__) && defined(__LITTLE_ENDIAN__) && \
defined(__ARM_FEATURE_CRC32) && defined(ABSL_INTERNAL_HAVE_ARM_NEON) && \
defined(__ARM_FEATURE_CRYPTO)
#include
#include
#define ABSL_CRC_INTERNAL_HAVE_ARM_SIMD
#endif
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
#if defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD) || \
defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
#if defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD)
using V128 = uint64x2_t;
#else
using V128 = __m128i;
#endif
// Starting with the initial value in |crc|, accumulates a CRC32 value for
// unsigned integers of different sizes.
uint32_t CRC32_u8(uint32_t crc, uint8_t v);
uint32_t CRC32_u16(uint32_t crc, uint16_t v);
uint32_t CRC32_u32(uint32_t crc, uint32_t v);
uint32_t CRC32_u64(uint32_t crc, uint64_t v);
// Loads 128 bits of integer data. |src| must be 16-byte aligned.
V128 V128_Load(const V128* src);
// Load 128 bits of integer data. |src| does not need to be aligned.
V128 V128_LoadU(const V128* src);
// Polynomially multiplies the high 64 bits of |l| and |r|.
V128 V128_PMulHi(const V128 l, const V128 r);
// Polynomially multiplies the low 64 bits of |l| and |r|.
V128 V128_PMulLow(const V128 l, const V128 r);
// Polynomially multiplies the low 64 bits of |r| and high 64 bits of |l|.
V128 V128_PMul01(const V128 l, const V128 r);
// Polynomially multiplies the low 64 bits of |l| and high 64 bits of |r|.
V128 V128_PMul10(const V128 l, const V128 r);
// Produces a XOR operation of |l| and |r|.
V128 V128_Xor(const V128 l, const V128 r);
// Produces an AND operation of |l| and |r|.
V128 V128_And(const V128 l, const V128 r);
// Sets two 64 bit integers to one 128 bit vector. The order is reverse.
// dst[63:0] := |r|
// dst[127:64] := |l|
V128 V128_From2x64(const uint64_t l, const uint64_t r);
// Shift |l| right by |imm| bytes while shifting in zeros.
template
V128 V128_ShiftRight(const V128 l);
// Extracts a 32-bit integer from |l|, selected with |imm|.
template
int V128_Extract32(const V128 l);
// Extracts the low 64 bits from V128.
int64_t V128_Low64(const V128 l);
// Left-shifts packed 64-bit integers in l by r.
V128 V128_ShiftLeft64(const V128 l, const V128 r);
#endif
#if defined(ABSL_CRC_INTERNAL_HAVE_X86_SIMD)
inline uint32_t CRC32_u8(uint32_t crc, uint8_t v) {
return _mm_crc32_u8(crc, v);
}
inline uint32_t CRC32_u16(uint32_t crc, uint16_t v) {
return _mm_crc32_u16(crc, v);
}
inline uint32_t CRC32_u32(uint32_t crc, uint32_t v) {
return _mm_crc32_u32(crc, v);
}
inline uint32_t CRC32_u64(uint32_t crc, uint64_t v) {
return static_cast(_mm_crc32_u64(crc, v));
}
inline V128 V128_Load(const V128* src) { return _mm_load_si128(src); }
inline V128 V128_LoadU(const V128* src) { return _mm_loadu_si128(src); }
inline V128 V128_PMulHi(const V128 l, const V128 r) {
return _mm_clmulepi64_si128(l, r, 0x11);
}
inline V128 V128_PMulLow(const V128 l, const V128 r) {
return _mm_clmulepi64_si128(l, r, 0x00);
}
inline V128 V128_PMul01(const V128 l, const V128 r) {
return _mm_clmulepi64_si128(l, r, 0x01);
}
inline V128 V128_PMul10(const V128 l, const V128 r) {
return _mm_clmulepi64_si128(l, r, 0x10);
}
inline V128 V128_Xor(const V128 l, const V128 r) { return _mm_xor_si128(l, r); }
inline V128 V128_And(const V128 l, const V128 r) { return _mm_and_si128(l, r); }
inline V128 V128_From2x64(const uint64_t l, const uint64_t r) {
return _mm_set_epi64x(static_cast(l), static_cast(r));
}
template
inline V128 V128_ShiftRight(const V128 l) {
return _mm_srli_si128(l, imm);
}
template
inline int V128_Extract32(const V128 l) {
return _mm_extract_epi32(l, imm);
}
inline int64_t V128_Low64(const V128 l) { return _mm_cvtsi128_si64(l); }
inline V128 V128_ShiftLeft64(const V128 l, const V128 r) {
return _mm_sll_epi64(l, r);
}
#elif defined(ABSL_CRC_INTERNAL_HAVE_ARM_SIMD)
inline uint32_t CRC32_u8(uint32_t crc, uint8_t v) { return __crc32cb(crc, v); }
inline uint32_t CRC32_u16(uint32_t crc, uint16_t v) {
return __crc32ch(crc, v);
}
inline uint32_t CRC32_u32(uint32_t crc, uint32_t v) {
return __crc32cw(crc, v);
}
inline uint32_t CRC32_u64(uint32_t crc, uint64_t v) {
return __crc32cd(crc, v);
}
inline V128 V128_Load(const V128* src) {
return vld1q_u64(reinterpret_cast(src));
}
inline V128 V128_LoadU(const V128* src) {
return vld1q_u64(reinterpret_cast(src));
}
// Using inline assembly as clang does not generate the pmull2 instruction and
// performance drops by 15-20%.
// TODO(b/193678732): Investigate why the compiler decides not to generate
// such instructions and why it becomes so much worse.
inline V128 V128_PMulHi(const V128 l, const V128 r) {
uint64x2_t res;
__asm__ __volatile__("pmull2 %0.1q, %1.2d, %2.2d \n\t"
: "=w"(res)
: "w"(l), "w"(r));
return res;
}
inline V128 V128_PMulLow(const V128 l, const V128 r) {
return reinterpret_cast(vmull_p64(
reinterpret_cast(vget_low_p64(vreinterpretq_p64_u64(l))),
reinterpret_cast(vget_low_p64(vreinterpretq_p64_u64(r)))));
}
inline V128 V128_PMul01(const V128 l, const V128 r) {
return reinterpret_cast(vmull_p64(
reinterpret_cast(vget_high_p64(vreinterpretq_p64_u64(l))),
reinterpret_cast(vget_low_p64(vreinterpretq_p64_u64(r)))));
}
inline V128 V128_PMul10(const V128 l, const V128 r) {
return reinterpret_cast(vmull_p64(
reinterpret_cast(vget_low_p64(vreinterpretq_p64_u64(l))),
reinterpret_cast(vget_high_p64(vreinterpretq_p64_u64(r)))));
}
inline V128 V128_Xor(const V128 l, const V128 r) { return veorq_u64(l, r); }
inline V128 V128_And(const V128 l, const V128 r) { return vandq_u64(l, r); }
inline V128 V128_From2x64(const uint64_t l, const uint64_t r) {
return vcombine_u64(vcreate_u64(r), vcreate_u64(l));
}
template
inline V128 V128_ShiftRight(const V128 l) {
return vreinterpretq_u64_s8(
vextq_s8(vreinterpretq_s8_u64(l), vdupq_n_s8(0), imm));
}
template
inline int V128_Extract32(const V128 l) {
return vgetq_lane_s32(vreinterpretq_s32_u64(l), imm);
}
inline int64_t V128_Low64(const V128 l) {
return vgetq_lane_s64(vreinterpretq_s64_u64(l), 0);
}
inline V128 V128_ShiftLeft64(const V128 l, const V128 r) {
return vshlq_u64(l, vreinterpretq_s64_u64(r));
}
#endif
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_CRC_INTERNAL_CRC32_X86_ARM_COMBINED_SIMD_H_
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc_cord_state.cc 0000644 0001750 0001751 00000007336 14737212474 024222 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/crc/internal/crc_cord_state.h"
#include
#include "absl/base/config.h"
#include "absl/numeric/bits.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
CrcCordState::RefcountedRep* CrcCordState::RefSharedEmptyRep() {
static CrcCordState::RefcountedRep* empty = new CrcCordState::RefcountedRep;
assert(empty->count.load(std::memory_order_relaxed) >= 1);
assert(empty->rep.removed_prefix.length == 0);
assert(empty->rep.prefix_crc.empty());
Ref(empty);
return empty;
}
CrcCordState::CrcCordState() : refcounted_rep_(new RefcountedRep) {}
CrcCordState::CrcCordState(const CrcCordState& other)
: refcounted_rep_(other.refcounted_rep_) {
Ref(refcounted_rep_);
}
CrcCordState::CrcCordState(CrcCordState&& other)
: refcounted_rep_(other.refcounted_rep_) {
// Make `other` valid for use after move.
other.refcounted_rep_ = RefSharedEmptyRep();
}
CrcCordState& CrcCordState::operator=(const CrcCordState& other) {
if (this != &other) {
Unref(refcounted_rep_);
refcounted_rep_ = other.refcounted_rep_;
Ref(refcounted_rep_);
}
return *this;
}
CrcCordState& CrcCordState::operator=(CrcCordState&& other) {
if (this != &other) {
Unref(refcounted_rep_);
refcounted_rep_ = other.refcounted_rep_;
// Make `other` valid for use after move.
other.refcounted_rep_ = RefSharedEmptyRep();
}
return *this;
}
CrcCordState::~CrcCordState() {
Unref(refcounted_rep_);
}
crc32c_t CrcCordState::Checksum() const {
if (rep().prefix_crc.empty()) {
return absl::crc32c_t{0};
}
if (IsNormalized()) {
return rep().prefix_crc.back().crc;
}
return absl::RemoveCrc32cPrefix(
rep().removed_prefix.crc, rep().prefix_crc.back().crc,
rep().prefix_crc.back().length - rep().removed_prefix.length);
}
CrcCordState::PrefixCrc CrcCordState::NormalizedPrefixCrcAtNthChunk(
size_t n) const {
assert(n < NumChunks());
if (IsNormalized()) {
return rep().prefix_crc[n];
}
size_t length = rep().prefix_crc[n].length - rep().removed_prefix.length;
return PrefixCrc(length,
absl::RemoveCrc32cPrefix(rep().removed_prefix.crc,
rep().prefix_crc[n].crc, length));
}
void CrcCordState::Normalize() {
if (IsNormalized() || rep().prefix_crc.empty()) {
return;
}
Rep* r = mutable_rep();
for (auto& prefix_crc : r->prefix_crc) {
size_t remaining = prefix_crc.length - r->removed_prefix.length;
prefix_crc.crc = absl::RemoveCrc32cPrefix(r->removed_prefix.crc,
prefix_crc.crc, remaining);
prefix_crc.length = remaining;
}
r->removed_prefix = PrefixCrc();
}
void CrcCordState::Poison() {
Rep* rep = mutable_rep();
if (NumChunks() > 0) {
for (auto& prefix_crc : rep->prefix_crc) {
// This is basically CRC32::Scramble().
uint32_t crc = static_cast(prefix_crc.crc);
crc += 0x2e76e41b;
crc = absl::rotr(crc, 17);
prefix_crc.crc = crc32c_t{crc};
}
} else {
// Add a fake corrupt chunk.
rep->prefix_crc.emplace_back(0, crc32c_t{1});
}
}
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc_internal.h 0000644 0001750 0001751 00000015633 14737212474 023550 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_CRC_INTERNAL_H_
#define ABSL_CRC_INTERNAL_CRC_INTERNAL_H_
#include
#include
#include
#include "absl/base/internal/raw_logging.h"
#include "absl/crc/internal/crc.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
// Prefetch constants used in some Extend() implementations
constexpr int kPrefetchHorizon = ABSL_CACHELINE_SIZE * 4; // Prefetch this far
// Shorter prefetch distance for smaller buffers
constexpr int kPrefetchHorizonMedium = ABSL_CACHELINE_SIZE * 1;
static_assert(kPrefetchHorizon >= 64, "CRCPrefetchHorizon less than loop len");
// We require the Scramble() function:
// - to be reversible (Unscramble() must exist)
// - to be non-linear in the polynomial's Galois field (so the CRC of a
// scrambled CRC is not linearly affected by the scrambled CRC, even if
// using the same polynomial)
// - not to be its own inverse. Preferably, if X=Scramble^N(X) and N!=0, then
// N is large.
// - to be fast.
// - not to change once defined.
// We introduce non-linearity in two ways:
// Addition of a constant.
// - The carries introduce non-linearity; we use bits of an irrational
// (phi) to make it unlikely that we introduce no carries.
// Rotate by a constant number of bits.
// - We use floor(degree/2)+1, which does not divide the degree, and
// splits the bits nearly evenly, which makes it less likely the
// halves will be the same or one will be all zeroes.
// We do both things to improve the chances of non-linearity in the face of
// bit patterns with low numbers of bits set, while still being fast.
// Below is the constant that we add. The bits are the first 128 bits of the
// fractional part of phi, with a 1 ored into the bottom bit to maximize the
// cycle length of repeated adds.
constexpr uint64_t kScrambleHi = (static_cast(0x4f1bbcdcU) << 32) |
static_cast(0xbfa53e0aU);
constexpr uint64_t kScrambleLo = (static_cast(0xf9ce6030U) << 32) |
static_cast(0x2e76e41bU);
class CRCImpl : public CRC { // Implementation of the abstract class CRC
public:
using Uint32By256 = uint32_t[256];
CRCImpl() = default;
~CRCImpl() override = default;
// The internal version of CRC::New().
static CRCImpl* NewInternal();
// Fill in a table for updating a CRC by one word of 'word_size' bytes
// [last_lo, last_hi] contains the answer if the last bit in the word
// is set.
static void FillWordTable(uint32_t poly, uint32_t last, int word_size,
Uint32By256* t);
// Build the table for extending by zeroes, returning the number of entries.
// For a in {1, 2, ..., ZEROES_BASE-1}, b in {0, 1, 2, 3, ...},
// entry j=a-1+(ZEROES_BASE-1)*b
// contains a polynomial Pi such that multiplying
// a CRC by Pi mod P, where P is the CRC polynomial, is equivalent to
// appending a*2**(ZEROES_BASE_LG*b) zero bytes to the original string.
static int FillZeroesTable(uint32_t poly, Uint32By256* t);
virtual void InitTables() = 0;
private:
CRCImpl(const CRCImpl&) = delete;
CRCImpl& operator=(const CRCImpl&) = delete;
};
// This is the 32-bit implementation. It handles all sizes from 8 to 32.
class CRC32 : public CRCImpl {
public:
CRC32() = default;
~CRC32() override = default;
void Extend(uint32_t* crc, const void* bytes, size_t length) const override;
void ExtendByZeroes(uint32_t* crc, size_t length) const override;
void Scramble(uint32_t* crc) const override;
void Unscramble(uint32_t* crc) const override;
void UnextendByZeroes(uint32_t* crc, size_t length) const override;
void InitTables() override;
private:
// Common implementation guts for ExtendByZeroes and UnextendByZeroes().
//
// zeroes_table is a table as returned by FillZeroesTable(), containing
// polynomials representing CRCs of strings-of-zeros of various lengths,
// and which can be combined by polynomial multiplication. poly_table is
// a table of CRC byte extension values. These tables are determined by
// the generator polynomial.
//
// These will be set to reverse_zeroes_ and reverse_table0_ for Unextend, and
// CRC32::zeroes_ and CRC32::table0_ for Extend.
static void ExtendByZeroesImpl(uint32_t* crc, size_t length,
const uint32_t zeroes_table[256],
const uint32_t poly_table[256]);
uint32_t table0_[256]; // table of byte extensions
uint32_t zeroes_[256]; // table of zero extensions
// table of 4-byte extensions shifted by 12 bytes of zeroes
uint32_t table_[4][256];
// Reverse lookup tables, using the alternate polynomial used by
// UnextendByZeroes().
uint32_t reverse_table0_[256]; // table of reverse byte extensions
uint32_t reverse_zeroes_[256]; // table of reverse zero extensions
CRC32(const CRC32&) = delete;
CRC32& operator=(const CRC32&) = delete;
};
// Helpers
// Return a bit mask containing len 1-bits.
// Requires 0 < len <= sizeof(T)
template
T MaskOfLength(int len) {
// shift 2 by len-1 rather than 1 by len because shifts of wordsize
// are undefined.
return (T(2) << (len - 1)) - 1;
}
// Rotate low-order "width" bits of "in" right by "r" bits,
// setting other bits in word to arbitrary values.
template
T RotateRight(T in, int width, int r) {
return (in << (width - r)) | ((in >> r) & MaskOfLength(width - r));
}
// RoundUp(p) returns the lowest address >= p aligned to an N-byte
// boundary. Requires that N is a power of 2.
template
const uint8_t* RoundUp(const uint8_t* p) {
static_assert((alignment & (alignment - 1)) == 0, "alignment is not 2^n");
constexpr uintptr_t mask = alignment - 1;
const uintptr_t as_uintptr = reinterpret_cast(p);
return reinterpret_cast((as_uintptr + mask) & ~mask);
}
// Return a newly created CRC32AcceleratedX86ARMCombined if we can use Intel's
// or ARM's CRC acceleration for a given polynomial. Return nullptr otherwise.
CRCImpl* TryNewCRC32AcceleratedX86ARMCombined();
// Return all possible hardware accelerated implementations. For testing only.
std::vector> NewCRC32AcceleratedX86ARMCombinedAll();
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_CRC_INTERNAL_CRC_INTERNAL_H_
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc_non_temporal_memcpy.cc 0000644 0001750 0001751 00000006445 14737212474 026142 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include
#include "absl/base/config.h"
#include "absl/crc/crc32c.h"
#include "absl/crc/internal/crc_memcpy.h"
#include "absl/crc/internal/non_temporal_memcpy.h"
#include "absl/strings/string_view.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
crc32c_t CrcNonTemporalMemcpyEngine::Compute(void* __restrict dst,
const void* __restrict src,
std::size_t length,
crc32c_t initial_crc) const {
constexpr size_t kBlockSize = 8192;
crc32c_t crc = initial_crc;
const char* src_bytes = reinterpret_cast(src);
char* dst_bytes = reinterpret_cast(dst);
// Copy + CRC loop - run 8k chunks until we are out of full chunks.
std::size_t offset = 0;
for (; offset + kBlockSize < length; offset += kBlockSize) {
crc = absl::ExtendCrc32c(crc,
absl::string_view(src_bytes + offset, kBlockSize));
non_temporal_store_memcpy(dst_bytes + offset, src_bytes + offset,
kBlockSize);
}
// Save some work if length is 0.
if (offset < length) {
std::size_t final_copy_size = length - offset;
crc = ExtendCrc32c(crc,
absl::string_view(src_bytes + offset, final_copy_size));
non_temporal_store_memcpy(dst_bytes + offset, src_bytes + offset,
final_copy_size);
}
return crc;
}
crc32c_t CrcNonTemporalMemcpyAVXEngine::Compute(void* __restrict dst,
const void* __restrict src,
std::size_t length,
crc32c_t initial_crc) const {
constexpr size_t kBlockSize = 8192;
crc32c_t crc = initial_crc;
const char* src_bytes = reinterpret_cast(src);
char* dst_bytes = reinterpret_cast(dst);
// Copy + CRC loop - run 8k chunks until we are out of full chunks.
std::size_t offset = 0;
for (; offset + kBlockSize < length; offset += kBlockSize) {
crc = ExtendCrc32c(crc, absl::string_view(src_bytes + offset, kBlockSize));
non_temporal_store_memcpy_avx(dst_bytes + offset, src_bytes + offset,
kBlockSize);
}
// Save some work if length is 0.
if (offset < length) {
std::size_t final_copy_size = length - offset;
crc = ExtendCrc32c(crc,
absl::string_view(src_bytes + offset, final_copy_size));
non_temporal_store_memcpy_avx(dst_bytes + offset, src_bytes + offset,
final_copy_size);
}
return crc;
}
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
s2/tools/vendor/abseil-cpp/absl/crc/internal/crc.cc 0000644 0001750 0001751 00000035427 14737212474 022015 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Implementation of CRCs (aka Rabin Fingerprints).
// Treats the input as a polynomial with coefficients in Z(2),
// and finds the remainder when divided by an irreducible polynomial
// of the appropriate length.
// It handles all CRC sizes from 8 to 128 bits.
// It's somewhat complicated by having separate implementations optimized for
// CRC's <=32 bits, <= 64 bits, and <= 128 bits.
// The input string is prefixed with a "1" bit, and has "degree" "0" bits
// appended to it before the remainder is found. This ensures that
// short strings are scrambled somewhat and that strings consisting
// of all nulls have a non-zero CRC.
//
// Uses the "interleaved word-by-word" method from
// "Everything we know about CRC but afraid to forget" by Andrew Kadatch
// and Bob Jenkins,
// http://crcutil.googlecode.com/files/crc-doc.1.0.pdf
//
// The idea is to compute kStride CRCs simultaneously, allowing the
// processor to more effectively use multiple execution units. Each of
// the CRCs is calculated on one word of data followed by kStride - 1
// words of zeroes; the CRC starting points are staggered by one word.
// Assuming a stride of 4 with data words "ABCDABCDABCD", the first
// CRC is over A000A000A, the second over 0B000B000B, and so on.
// The CRC of the whole data is then calculated by properly aligning the
// CRCs by appending zeroes until the data lengths agree then XORing
// the CRCs.
#include "absl/crc/internal/crc.h"
#include
#include "absl/base/internal/endian.h"
#include "absl/base/internal/raw_logging.h"
#include "absl/base/prefetch.h"
#include "absl/crc/internal/crc_internal.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
namespace {
// Constants
#if defined(__i386__) || defined(__x86_64__)
constexpr bool kNeedAlignedLoads = false;
#else
constexpr bool kNeedAlignedLoads = true;
#endif
// We express the number of zeroes as a number in base ZEROES_BASE. By
// pre-computing the zero extensions for all possible components of such an
// expression (numbers in a form a*ZEROES_BASE**b), we can calculate the
// resulting extension by multiplying the extensions for individual components
// using log_{ZEROES_BASE}(num_zeroes) polynomial multiplications. The tables of
// zero extensions contain (ZEROES_BASE - 1) * (log_{ZEROES_BASE}(64)) entries.
constexpr int ZEROES_BASE_LG = 4; // log_2(ZEROES_BASE)
constexpr int ZEROES_BASE = (1 << ZEROES_BASE_LG); // must be a power of 2
constexpr uint32_t kCrc32cPoly = 0x82f63b78;
uint32_t ReverseBits(uint32_t bits) {
bits = (bits & 0xaaaaaaaau) >> 1 | (bits & 0x55555555u) << 1;
bits = (bits & 0xccccccccu) >> 2 | (bits & 0x33333333u) << 2;
bits = (bits & 0xf0f0f0f0u) >> 4 | (bits & 0x0f0f0f0fu) << 4;
return absl::gbswap_32(bits);
}
// Polynomial long multiplication mod the polynomial of degree 32.
void PolyMultiply(uint32_t* val, uint32_t m, uint32_t poly) {
uint32_t l = *val;
uint32_t result = 0;
auto onebit = uint32_t{0x80000000u};
for (uint32_t one = onebit; one != 0; one >>= 1) {
if ((l & one) != 0) {
result ^= m;
}
if (m & 1) {
m = (m >> 1) ^ poly;
} else {
m >>= 1;
}
}
*val = result;
}
} // namespace
void CRCImpl::FillWordTable(uint32_t poly, uint32_t last, int word_size,
Uint32By256* t) {
for (int j = 0; j != word_size; j++) { // for each byte of extension....
t[j][0] = 0; // a zero has no effect
for (int i = 128; i != 0; i >>= 1) { // fill in entries for powers of 2
if (j == 0 && i == 128) {
t[j][i] = last; // top bit in last byte is given
} else {
// each successive power of two is derived from the previous
// one, either in this table, or the last table
uint32_t pred;
if (i == 128) {
pred = t[j - 1][1];
} else {
pred = t[j][i << 1];
}
// Advance the CRC by one bit (multiply by X, and take remainder
// through one step of polynomial long division)
if (pred & 1) {
t[j][i] = (pred >> 1) ^ poly;
} else {
t[j][i] = pred >> 1;
}
}
}
// CRCs have the property that CRC(a xor b) == CRC(a) xor CRC(b)
// so we can make all the tables for non-powers of two by
// xoring previously created entries.
for (int i = 2; i != 256; i <<= 1) {
for (int k = i + 1; k != (i << 1); k++) {
t[j][k] = t[j][i] ^ t[j][k - i];
}
}
}
}
int CRCImpl::FillZeroesTable(uint32_t poly, Uint32By256* t) {
uint32_t inc = 1;
inc <<= 31;
// Extend by one zero bit. We know degree > 1 so (inc & 1) == 0.
inc >>= 1;
// Now extend by 2, 4, and 8 bits, so now `inc` is extended by one zero byte.
for (int i = 0; i < 3; ++i) {
PolyMultiply(&inc, inc, poly);
}
int j = 0;
for (uint64_t inc_len = 1; inc_len != 0; inc_len <<= ZEROES_BASE_LG) {
// Every entry in the table adds an additional inc_len zeroes.
uint32_t v = inc;
for (int a = 1; a != ZEROES_BASE; a++) {
t[0][j] = v;
PolyMultiply(&v, inc, poly);
j++;
}
inc = v;
}
ABSL_RAW_CHECK(j <= 256, "");
return j;
}
// Internal version of the "constructor".
CRCImpl* CRCImpl::NewInternal() {
// Find an accelearated implementation first.
CRCImpl* result = TryNewCRC32AcceleratedX86ARMCombined();
// Fall back to generic implementions if no acceleration is available.
if (result == nullptr) {
result = new CRC32();
}
result->InitTables();
return result;
}
// The 32-bit implementation
void CRC32::InitTables() {
// Compute the table for extending a CRC by one byte.
Uint32By256* t = new Uint32By256[4];
FillWordTable(kCrc32cPoly, kCrc32cPoly, 1, t);
for (int i = 0; i != 256; i++) {
this->table0_[i] = t[0][i];
}
// Construct a table for updating the CRC by 4 bytes data followed by
// 12 bytes of zeroes.
//
// Note: the data word size could be larger than the CRC size; it might
// be slightly faster to use a 64-bit data word, but doing so doubles the
// table size.
uint32_t last = kCrc32cPoly;
const size_t size = 12;
for (size_t i = 0; i < size; ++i) {
last = (last >> 8) ^ this->table0_[last & 0xff];
}
FillWordTable(kCrc32cPoly, last, 4, t);
for (size_t b = 0; b < 4; ++b) {
for (int i = 0; i < 256; ++i) {
this->table_[b][i] = t[b][i];
}
}
int j = FillZeroesTable(kCrc32cPoly, t);
ABSL_RAW_CHECK(j <= static_cast(ABSL_ARRAYSIZE(this->zeroes_)), "");
for (int i = 0; i < j; i++) {
this->zeroes_[i] = t[0][i];
}
delete[] t;
// Build up tables for _reversing_ the operation of doing CRC operations on
// zero bytes.
// In C++, extending `crc` by a single zero bit is done by the following:
// (A) bool low_bit_set = (crc & 1);
// crc >>= 1;
// if (low_bit_set) crc ^= kCrc32cPoly;
//
// In particular note that the high bit of `crc` after this operation will be
// set if and only if the low bit of `crc` was set before it. This means that
// no information is lost, and the operation can be reversed, as follows:
// (B) bool high_bit_set = (crc & 0x80000000u);
// if (high_bit_set) crc ^= kCrc32cPoly;
// crc <<= 1;
// if (high_bit_set) crc ^= 1;
//
// Or, equivalently:
// (C) bool high_bit_set = (crc & 0x80000000u);
// crc <<= 1;
// if (high_bit_set) crc ^= ((kCrc32cPoly << 1) ^ 1);
//
// The last observation is, if we store our checksums in variable `rcrc`,
// with order of the bits reversed, the inverse operation becomes:
// (D) bool low_bit_set = (rcrc & 1);
// rcrc >>= 1;
// if (low_bit_set) rcrc ^= ReverseBits((kCrc32cPoly << 1) ^ 1)
//
// This is the same algorithm (A) that we started with, only with a different
// polynomial bit pattern. This means that by building up our tables with
// this alternate polynomial, we can apply the CRC algorithms to a
// bit-reversed CRC checksum to perform inverse zero-extension.
const uint32_t kCrc32cUnextendPoly =
ReverseBits(static_cast((kCrc32cPoly << 1) ^ 1));
FillWordTable(kCrc32cUnextendPoly, kCrc32cUnextendPoly, 1, &reverse_table0_);
j = FillZeroesTable(kCrc32cUnextendPoly, &reverse_zeroes_);
ABSL_RAW_CHECK(j <= static_cast(ABSL_ARRAYSIZE(this->reverse_zeroes_)),
"");
}
void CRC32::Extend(uint32_t* crc, const void* bytes, size_t length) const {
const uint8_t* p = static_cast(bytes);
const uint8_t* e = p + length;
uint32_t l = *crc;
auto step_one_byte = [this, &p, &l]() {
int c = (l & 0xff) ^ *p++;
l = this->table0_[c] ^ (l >> 8);
};
if (kNeedAlignedLoads) {
// point x at first 4-byte aligned byte in string. this might be past the
// end of the string.
const uint8_t* x = RoundUp<4>(p);
if (x <= e) {
// Process bytes until finished or p is 4-byte aligned
while (p != x) {
step_one_byte();
}
}
}
const size_t kSwathSize = 16;
if (static_cast(e - p) >= kSwathSize) {
// Load one swath of data into the operating buffers.
uint32_t buf0 = absl::little_endian::Load32(p) ^ l;
uint32_t buf1 = absl::little_endian::Load32(p + 4);
uint32_t buf2 = absl::little_endian::Load32(p + 8);
uint32_t buf3 = absl::little_endian::Load32(p + 12);
p += kSwathSize;
// Increment a CRC value by a "swath"; this combines the four bytes
// starting at `ptr` and twelve zero bytes, so that four CRCs can be
// built incrementally and combined at the end.
const auto step_swath = [this](uint32_t crc_in, const std::uint8_t* ptr) {
return absl::little_endian::Load32(ptr) ^
this->table_[3][crc_in & 0xff] ^
this->table_[2][(crc_in >> 8) & 0xff] ^
this->table_[1][(crc_in >> 16) & 0xff] ^
this->table_[0][crc_in >> 24];
};
// Run one CRC calculation step over all swaths in one 16-byte stride
const auto step_stride = [&]() {
buf0 = step_swath(buf0, p);
buf1 = step_swath(buf1, p + 4);
buf2 = step_swath(buf2, p + 8);
buf3 = step_swath(buf3, p + 12);
p += 16;
};
// Process kStride interleaved swaths through the data in parallel.
while ((e - p) > kPrefetchHorizon) {
PrefetchToLocalCacheNta(
reinterpret_cast(p + kPrefetchHorizon));
// Process 64 bytes at a time
step_stride();
step_stride();
step_stride();
step_stride();
}
while (static_cast(e - p) >= kSwathSize) {
step_stride();
}
// Now advance one word at a time as far as possible. This isn't worth
// doing if we have word-advance tables.
while (static_cast(e - p) >= 4) {
buf0 = step_swath(buf0, p);
uint32_t tmp = buf0;
buf0 = buf1;
buf1 = buf2;
buf2 = buf3;
buf3 = tmp;
p += 4;
}
// Combine the results from the different swaths. This is just a CRC
// on the data values in the bufX words.
auto combine_one_word = [this](uint32_t crc_in, uint32_t w) {
w ^= crc_in;
for (size_t i = 0; i < 4; ++i) {
w = (w >> 8) ^ this->table0_[w & 0xff];
}
return w;
};
l = combine_one_word(0, buf0);
l = combine_one_word(l, buf1);
l = combine_one_word(l, buf2);
l = combine_one_word(l, buf3);
}
// Process the last few bytes
while (p != e) {
step_one_byte();
}
*crc = l;
}
void CRC32::ExtendByZeroesImpl(uint32_t* crc, size_t length,
const uint32_t zeroes_table[256],
const uint32_t poly_table[256]) {
if (length != 0) {
uint32_t l = *crc;
// For each ZEROES_BASE_LG bits in length
// (after the low-order bits have been removed)
// we lookup the appropriate polynomial in the zeroes_ array
// and do a polynomial long multiplication (mod the CRC polynomial)
// to extend the CRC by the appropriate number of bits.
for (int i = 0; length != 0;
i += ZEROES_BASE - 1, length >>= ZEROES_BASE_LG) {
int c = length & (ZEROES_BASE - 1); // pick next ZEROES_BASE_LG bits
if (c != 0) { // if they are not zero,
// multiply by entry in table
// Build a table to aid in multiplying 2 bits at a time.
// It takes too long to build tables for more bits.
uint64_t m = zeroes_table[c + i - 1];
m <<= 1;
uint64_t m2 = m << 1;
uint64_t mtab[4] = {0, m, m2, m2 ^ m};
// Do the multiply one byte at a time.
uint64_t result = 0;
for (int x = 0; x < 32; x += 8) {
// The carry-less multiply.
result ^= mtab[l & 3] ^ (mtab[(l >> 2) & 3] << 2) ^
(mtab[(l >> 4) & 3] << 4) ^ (mtab[(l >> 6) & 3] << 6);
l >>= 8;
// Reduce modulo the polynomial
result = (result >> 8) ^ poly_table[result & 0xff];
}
l = static_cast(result);
}
}
*crc = l;
}
}
void CRC32::ExtendByZeroes(uint32_t* crc, size_t length) const {
return CRC32::ExtendByZeroesImpl(crc, length, zeroes_, table0_);
}
void CRC32::UnextendByZeroes(uint32_t* crc, size_t length) const {
// See the comment in CRC32::InitTables() for an explanation of the algorithm
// below.
*crc = ReverseBits(*crc);
ExtendByZeroesImpl(crc, length, reverse_zeroes_, reverse_table0_);
*crc = ReverseBits(*crc);
}
void CRC32::Scramble(uint32_t* crc) const {
// Rotate by near half the word size plus 1. See the scramble comment in
// crc_internal.h for an explanation.
constexpr int scramble_rotate = (32 / 2) + 1;
*crc = RotateRight(static_cast(*crc + kScrambleLo),
32, scramble_rotate) &
MaskOfLength(32);
}
void CRC32::Unscramble(uint32_t* crc) const {
constexpr int scramble_rotate = (32 / 2) + 1;
uint64_t rotated = RotateRight(static_cast(*crc), 32,
32 - scramble_rotate);
*crc = (rotated - kScrambleLo) & MaskOfLength(32);
}
// Constructor and destructor for base class CRC.
CRC::~CRC() {}
CRC::CRC() {}
// The "constructor" for a CRC32C with a standard polynomial.
CRC* CRC::Crc32c() {
static CRC* singleton = CRCImpl::NewInternal();
return singleton;
}
} // namespace crc_internal
ABSL_NAMESPACE_END
} // namespace absl
s2/tools/vendor/abseil-cpp/absl/crc/internal/non_temporal_memcpy.h 0000644 0001750 0001751 00000013332 14737212474 025146 0 ustar nilesh nilesh // Copyright 2022 The Abseil Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef ABSL_CRC_INTERNAL_NON_TEMPORAL_MEMCPY_H_
#define ABSL_CRC_INTERNAL_NON_TEMPORAL_MEMCPY_H_
#ifdef _MSC_VER
#include
#endif
#ifdef __SSE__
#include
#endif
#ifdef __SSE2__
#include
#endif
#ifdef __SSE3__
#include
#endif
#ifdef __AVX__
#include
#endif
#ifdef __aarch64__
#include "absl/crc/internal/non_temporal_arm_intrinsics.h"
#endif
#include
#include
#include
#include
#include "absl/base/config.h"
#include "absl/base/optimization.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace crc_internal {
// This non-temporal memcpy does regular load and non-temporal store memory
// copy. It is compatible to both 16-byte aligned and unaligned addresses. If
// data at the destination is not immediately accessed, using non-temporal
// memcpy can save 1 DRAM load of the destination cacheline.
constexpr size_t kCacheLineSize = ABSL_CACHELINE_SIZE;
// If the objects overlap, the behavior is undefined.
inline void *non_temporal_store_memcpy(void *__restrict dst,
const void *__restrict src, size_t len) {
#if defined(__SSE3__) || defined(__aarch64__) || \
(defined(_MSC_VER) && defined(__AVX__))
// This implementation requires SSE3.
// MSVC cannot target SSE3 directly, but when MSVC targets AVX,
// SSE3 support is implied.
uint8_t *d = reinterpret_cast(dst);
const uint8_t *s = reinterpret_cast(src);
// memcpy() the misaligned header. At the end of this if block, is
// aligned to a 64-byte cacheline boundary or == 0.
if (reinterpret_cast