Go 1.21 added builtin min and max methods meaning we no longer need to make our own.

rsned · rsned · commit a06e4b3e40b5 · 2025-05-19T00:13:31.000-07:00
diff --git a/s2/builder_snapper.go b/s2/builder_snapper.go
@@ -264,9 +264,9 @@ func (sf CellIDSnapper) MinVertexSeparation() s1.Angle {
 	//    0.5 * MaxDiagMetric.Value(level) when snapped.
 	minEdge := s1.Angle(MinEdgeMetric.Value(sf.level))
 	maxDiag := s1.Angle(MaxDiagMetric.Value(sf.level))
-	return maxAngle(minEdge,
+	return max(minEdge,
 		// per 2 above, a little less than 2 / sqrt(13)
-		maxAngle(0.548*sf.snapRadius,
+		max(0.548*sf.snapRadius,
 			sf.snapRadius-0.5*maxDiag))
 }
 
@@ -317,8 +317,8 @@ func (sf CellIDSnapper) MinEdgeVertexSeparation() s1.Angle {
 
 	// Otherwise, these bounds hold for any snapRadius.
 	vertexSep := sf.MinVertexSeparation()
-	return maxAngle(0.397*minDiag, // sqrt(3/19) in the plane
-		maxAngle(0.219*sf.snapRadius, // 2*sqrt(3/247) in the plane
+	return max(0.397*minDiag, // sqrt(3/19) in the plane
+		max(0.219*sf.snapRadius, // 2*sqrt(3/247) in the plane
 			0.5*(vertexSep/sf.snapRadius)*vertexSep))
 }
 
@@ -429,14 +429,14 @@ func (sf IntLatLngSnapper) exponentForMaxSnapRadius(snapRadius s1.Angle) int {
 	// When choosing an exponent, we need to account for the error bound of
 	// (9 * sqrt(2) + 1.5) * dblEpsilon added by minSnapRadiusForExponent.
 	snapRadius -= (9*math.Sqrt2 + 1.5) * dblEpsilon
-	snapRadius = maxAngle(snapRadius, 1e-30)
+	snapRadius = max(snapRadius, 1e-30)
 	exponent := math.Log10((1 / math.Sqrt2) / snapRadius.Degrees())
 
 	// There can be small errors in the calculation above, so to ensure that
 	// this function is the inverse of minSnapRadiusForExponent we subtract a
 	// small error tolerance.
-	return maxInt(minIntSnappingExponent,
-		minInt(maxIntSnappingExponent, int(math.Ceil(exponent-2*dblEpsilon))))
+	return max(minIntSnappingExponent,
+		min(maxIntSnappingExponent, int(math.Ceil(exponent-2*dblEpsilon))))
 }
 
 // MinVertexSeparation reports the minimum separation between vertices depending on
@@ -457,7 +457,7 @@ func (sf IntLatLngSnapper) MinVertexSeparation() s1.Angle {
 	//    only select a new site when it is at least snapRadius away from all
 	//    existing sites, and snapping a vertex can move it by up to
 	//    ((1 / sqrt(2)) * sf.to) degrees.
-	return maxAngle(0.471*sf.snapRadius, // sqrt(2)/3 in the plane
+	return max(0.471*sf.snapRadius, // sqrt(2)/3 in the plane
 		sf.snapRadius-s1.Degree*s1.Angle(1/math.Sqrt2)*sf.to)
 }
 
@@ -489,8 +489,8 @@ func (sf IntLatLngSnapper) MinEdgeVertexSeparation() s1.Angle {
 	//    bound approaches 0.5 * snapRadius as the snap radius becomes large
 	//    relative to the grid spacing.
 	vertexSep := sf.MinVertexSeparation()
-	return maxAngle(0.277*s1.Degree*sf.to, // 1/sqrt(13) in the plane
-		maxAngle(0.222*sf.snapRadius, // 2/9 in the plane
+	return max(0.277*s1.Degree*sf.to, // 1/sqrt(13) in the plane
+		max(0.222*sf.snapRadius, // 2/9 in the plane
 			0.5*(vertexSep/sf.snapRadius)*vertexSep))
 }
 
diff --git a/s2/builder_snapper_test.go b/s2/builder_snapper_test.go
@@ -50,7 +50,7 @@ func TestCellIDSnapperLevelToFromSnapRadius(t *testing.T) {
 		if got := f.levelForMaxSnapRadius(radius); got != level {
 			t.Errorf("levelForMaxSnapRadius(%v) = %v, want %v", radius, got, level)
 		}
-		if got, want := f.levelForMaxSnapRadius(0.999*radius), minInt(level+1, MaxLevel); got != want {
+		if got, want := f.levelForMaxSnapRadius(0.999*radius), min(level+1, MaxLevel); got != want {
 			t.Errorf("levelForMaxSnapRadius(0.999*%v) = %v, want %v (level %d)", radius, got, want, level)
 		}
 	}
@@ -84,7 +84,7 @@ func TestIntLatLngSnapperExponentToFromSnapRadius(t *testing.T) {
 		if got := sf.exponentForMaxSnapRadius(radius); got != exp {
 			t.Errorf("exponentForMaxSnapRadius(%v) = %v, want %v", radius, got, exp)
 		}
-		if got, want := sf.exponentForMaxSnapRadius(0.999*radius), minInt(exp+1, maxIntSnappingExponent); got != want {
+		if got, want := sf.exponentForMaxSnapRadius(0.999*radius), min(exp+1, maxIntSnappingExponent); got != want {
 			t.Errorf("exponentForMaxSnapRadius(%v) = %v, want %v", 0.999*radius, got, want)
 		}
 	}
diff --git a/s2/cell.go b/s2/cell.go
@@ -622,7 +622,7 @@ func (c Cell) distanceInternal(targetXYZ Point, toInterior bool) s1.ChordAngle {
 		// arbitrary quadrilaterals after they are projected onto the sphere.
 		// Therefore the simplest approach is just to find the minimum distance to
 		// any of the four edges.
-		return minChordAngle(edgeDistance(-dir00, c.uv.X.Lo),
+		return min(edgeDistance(-dir00, c.uv.X.Lo),
 			edgeDistance(dir01, c.uv.X.Hi),
 			edgeDistance(-dir10, c.uv.Y.Lo),
 			edgeDistance(dir11, c.uv.Y.Hi))
@@ -633,7 +633,7 @@ func (c Cell) distanceInternal(targetXYZ Point, toInterior bool) s1.ChordAngle {
 	// tests above, because (1) the edges don't meet at right angles and (2)
 	// there are points on the far side of the sphere that are both above *and*
 	// below the cell, etc.
-	return minChordAngle(c.vertexChordDist2(target, false, false),
+	return min(c.vertexChordDist2(target, false, false),
 		c.vertexChordDist2(target, true, false),
 		c.vertexChordDist2(target, false, true),
 		c.vertexChordDist2(target, true, true))
@@ -651,7 +651,7 @@ func (c Cell) MaxDistance(target Point) s1.ChordAngle {
 	// First check the 4 cell vertices.  If all are within the hemisphere
 	// centered around target, the max distance will be to one of these vertices.
 	targetUVW := faceXYZtoUVW(int(c.face), target)
-	maxDist := maxChordAngle(c.vertexChordDist2(targetUVW, false, false),
+	maxDist := max(c.vertexChordDist2(targetUVW, false, false),
 		c.vertexChordDist2(targetUVW, true, false),
 		c.vertexChordDist2(targetUVW, false, true),
 		c.vertexChordDist2(targetUVW, true, true))
@@ -685,7 +685,7 @@ func (c Cell) DistanceToEdge(a, b Point) s1.ChordAngle {
 
 	// First, check the minimum distance to the edge endpoints A and B.
 	// (This also detects whether either endpoint is inside the cell.)
-	minDist := minChordAngle(c.Distance(a), c.Distance(b))
+	minDist := min(c.Distance(a), c.Distance(b))
 	if minDist == 0 {
 		return minDist
 	}
@@ -717,7 +717,7 @@ func (c Cell) MaxDistanceToEdge(a, b Point) s1.ChordAngle {
 	// If the maximum distance from both endpoints to the cell is less than π/2
 	// then the maximum distance from the edge to the cell is the maximum of the
 	// two endpoint distances.
-	maxDist := maxChordAngle(c.MaxDistance(a), c.MaxDistance(b))
+	maxDist := max(c.MaxDistance(a), c.MaxDistance(b))
 	if maxDist <= s1.RightChordAngle {
 		return maxDist
 	}
diff --git a/s2/cellid_test.go b/s2/cellid_test.go
@@ -296,7 +296,7 @@ func TestCellIDAllNeighbors(t *testing.T) {
 
 		// testAllNeighbors computes approximately 2**(2*(diff+1)) cell ids,
 		// so it's not reasonable to use large values of diff.
-		maxDiff := minInt(6, MaxLevel-id.Level()-1)
+		maxDiff := min(6, MaxLevel-id.Level()-1)
 		level := id.Level() + randomUniformInt(maxDiff)
 
 		// We compute AllNeighbors, and then add in all the children of id
diff --git a/s2/cellunion.go b/s2/cellunion.go
@@ -491,7 +491,7 @@ func (cu *CellUnion) ExpandAtLevel(level int) {
 func (cu *CellUnion) ExpandByRadius(minRadius s1.Angle, maxLevelDiff int) {
 	minLevel := MaxLevel
 	for _, cid := range *cu {
-		minLevel = minInt(minLevel, cid.Level())
+		minLevel = min(minLevel, cid.Level())
 	}
 
 	// Find the maximum level such that all cells are at least "minRadius" wide.
@@ -501,7 +501,7 @@ func (cu *CellUnion) ExpandByRadius(minRadius s1.Angle, maxLevelDiff int) {
 		// The easiest way to handle this is to expand twice.
 		cu.ExpandAtLevel(0)
 	}
-	cu.ExpandAtLevel(minInt(minLevel+maxLevelDiff, radiusLevel))
+	cu.ExpandAtLevel(min(minLevel+maxLevelDiff, radiusLevel))
 }
 
 // Equal reports whether the two CellUnions are equal.
diff --git a/s2/cellunion_test.go b/s2/cellunion_test.go
@@ -933,9 +933,9 @@ func TestCellUnionExpand(t *testing.T) {
 		// that figures out an appropriate cell level to use for the expansion.
 		minLevel := MaxLevel
 		for _, cid := range covering {
-			minLevel = minInt(minLevel, cid.Level())
+			minLevel = min(minLevel, cid.Level())
 		}
-		expandLevel := minInt(minLevel+maxLevelDiff, MinWidthMetric.MaxLevel(radius))
+		expandLevel := min(minLevel+maxLevelDiff, MinWidthMetric.MaxLevel(radius))
 
 		// Generate a covering for the expanded cap, and measure the new maximum
 		// distance from the cap center to any point in the covering.
diff --git a/s2/edge_crossings_test.go b/s2/edge_crossings_test.go
@@ -120,8 +120,8 @@ func TestEdgeutilIntersectionError(t *testing.T) {
 		if got, want := pointDist, intersectionError; got > want {
 			t.Errorf("%v.Distance(%v) = %v want <= %v", expected, actual, got, want)
 		}
-		maxEdgeDist = maxAngle(maxEdgeDist, maxAngle(distAB, distCD))
-		maxPointDist = maxAngle(maxPointDist, pointDist)
+		maxEdgeDist = max(maxEdgeDist, max(distAB, distCD))
+		maxPointDist = max(maxPointDist, pointDist)
 	}
 }
 
diff --git a/s2/edge_distances.go b/s2/edge_distances.go
@@ -60,7 +60,7 @@ func UpdateMinDistance(x, a, b Point, minDist s1.ChordAngle) (s1.ChordAngle, boo
 // than maxDist, and if so, returns the updated value and true.
 // Otherwise it returns false. The case A == B is handled correctly.
 func UpdateMaxDistance(x, a, b Point, maxDist s1.ChordAngle) (s1.ChordAngle, bool) {
-	dist := maxChordAngle(ChordAngleBetweenPoints(x, a), ChordAngleBetweenPoints(x, b))
+	dist := max(ChordAngleBetweenPoints(x, a), ChordAngleBetweenPoints(x, b))
 	if dist > s1.RightChordAngle {
 		dist, _ = updateMinDistance(Point{x.Mul(-1)}, a, b, dist, true)
 		dist = s1.StraightChordAngle - dist
diff --git a/s2/edge_query_test.go b/s2/edge_query_test.go
@@ -448,7 +448,7 @@ func generateEdgeQueryWithTargets(opts *edgeQueryBenchmarkOptions, query *EdgeQu
 	numTargets := maxTargetsPerIndex
 	if opts.targetType == queryTypeIndex {
 		// Limit the total number of target edges to reduce the benchmark running times.
-		numTargets = minInt(numTargets, 500000/opts.numTargetEdges)
+		numTargets = min(numTargets, 500000/opts.numTargetEdges)
 	}
 
 	for i := 0; i < numTargets; i++ {
diff --git a/s2/edge_tessellator.go b/s2/edge_tessellator.go
@@ -196,7 +196,7 @@ type EdgeTessellator struct {
 func NewEdgeTessellator(p Projection, tolerance s1.Angle) *EdgeTessellator {
 	return &EdgeTessellator{
 		projection:      p,
-		scaledTolerance: s1.ChordAngleFromAngle(maxAngle(tolerance, minTessellationTolerance)),
+		scaledTolerance: s1.ChordAngleFromAngle(max(tolerance, minTessellationTolerance)),
 	}
 }
 
@@ -287,5 +287,5 @@ func (e *EdgeTessellator) estimateMaxError(pa r2.Point, a Point, pb r2.Point, b
 	mid2 := Interpolate(t2, a, b)
 	pmid1 := e.projection.Unproject(e.projection.Interpolate(t1, pa, pb))
 	pmid2 := e.projection.Unproject(e.projection.Interpolate(t2, pa, pb))
-	return maxChordAngle(ChordAngleBetweenPoints(mid1, pmid1), ChordAngleBetweenPoints(mid2, pmid2))
+	return max(ChordAngleBetweenPoints(mid1, pmid1), ChordAngleBetweenPoints(mid2, pmid2))
 }
diff --git a/s2/index_cell_data.go b/s2/index_cell_data.go
@@ -314,7 +314,7 @@ func (d *indexCellData) dimRangeEdges(dim0, dim1 int) []edgeAndIDChain {
 	size := 0
 
 	for dim := dim0; dim <= dim1; dim++ {
-		start = minInt(start, d.dimRegions[dim].start)
+		start = min(start, d.dimRegions[dim].start)
 		size += d.dimRegions[dim].size
 	}
 
diff --git a/s2/lax_loop.go b/s2/lax_loop.go
@@ -69,7 +69,7 @@ func (l *LaxLoop) Edge(e int) Edge {
 }
 func (l *LaxLoop) Dimension() int                 { return 2 }
 func (l *LaxLoop) ReferencePoint() ReferencePoint { return referencePointForShape(l) }
-func (l *LaxLoop) NumChains() int                 { return minInt(1, l.numVertices) }
+func (l *LaxLoop) NumChains() int                 { return min(1, l.numVertices) }
 func (l *LaxLoop) Chain(i int) Chain              { return Chain{0, l.numVertices} }
 func (l *LaxLoop) ChainEdge(i, j int) Edge {
 	var k int
diff --git a/s2/lax_polyline.go b/s2/lax_polyline.go
@@ -40,10 +40,10 @@ func LaxPolylineFromPolyline(p Polyline) *LaxPolyline {
 	return LaxPolylineFromPoints(p)
 }
 
-func (l *LaxPolyline) NumEdges() int                     { return maxInt(0, len(l.vertices)-1) }
+func (l *LaxPolyline) NumEdges() int                     { return max(0, len(l.vertices)-1) }
 func (l *LaxPolyline) Edge(e int) Edge                   { return Edge{l.vertices[e], l.vertices[e+1]} }
 func (l *LaxPolyline) ReferencePoint() ReferencePoint    { return OriginReferencePoint(false) }
-func (l *LaxPolyline) NumChains() int                    { return minInt(1, l.NumEdges()) }
+func (l *LaxPolyline) NumChains() int                    { return min(1, l.NumEdges()) }
 func (l *LaxPolyline) Chain(i int) Chain                 { return Chain{0, l.NumEdges()} }
 func (l *LaxPolyline) ChainEdge(i, j int) Edge           { return Edge{l.vertices[j], l.vertices[j+1]} }
 func (l *LaxPolyline) ChainPosition(e int) ChainPosition { return ChainPosition{0, e} }
diff --git a/s2/point.go b/s2/point.go
@@ -334,7 +334,7 @@ func (p Point) IsNormalizable() bool {
 	//
 	// The fastest way to ensure this is to test whether the largest component of
 	// the result has a magnitude of at least 2**-242.
-	return maxFloat64(math.Abs(p.X), math.Abs(p.Y), math.Abs(p.Z)) >= math.Ldexp(1, -242)
+	return max(math.Abs(p.X), math.Abs(p.Y), math.Abs(p.Z)) >= math.Ldexp(1, -242)
 }
 
 // EnsureNormalizable scales a vector as necessary to ensure that the result can
@@ -355,7 +355,7 @@ func (p Point) EnsureNormalizable() Point {
 		// Note that we must scale by a power of two to avoid rounding errors.
 		// The code below scales "p" such that the largest component is
 		// in the range [1, 2).
-		pMax := maxFloat64(math.Abs(p.X), math.Abs(p.Y), math.Abs(p.Z))
+		pMax := max(math.Abs(p.X), math.Abs(p.Y), math.Abs(p.Z))
 
 		// This avoids signed overflow for any value of Ilogb().
 		return Point{p.Mul(math.Ldexp(2, -1-math.Ilogb(pMax)))}
diff --git a/s2/point_measures.go b/s2/point_measures.go
@@ -66,7 +66,7 @@ func PointArea(a, b, c Point) float64 {
 	s := 0.5 * (sa + sb + sc)
 	if s >= 3e-4 {
 		// Consider whether Girard's formula might be more accurate.
-		dmin := s - maxAngle(sa, sb, sc)
+		dmin := s - max(sa, sb, sc)
 		if dmin < 1e-2*s*s*s*s*s {
 			// This triangle is skinny enough to use Girard's formula.
 			area := GirardArea(a, b, c)
diff --git a/s2/polyline.go b/s2/polyline.go
@@ -190,7 +190,7 @@ func (p *Polyline) ReferencePoint() ReferencePoint {
 
 // NumChains reports the number of contiguous edge chains in this Polyline.
 func (p *Polyline) NumChains() int {
-	return minInt(1, p.NumEdges())
+	return min(1, p.NumEdges())
 }
 
 // Chain returns the i-th edge Chain in the Shape.
@@ -578,7 +578,7 @@ func (p *Polyline) Uninterpolate(point Point, nextVertex int) float64 {
 	}
 	// The ratio can be greater than 1.0 due to rounding errors or because the
 	// point is not exactly on the polyline.
-	return minFloat64(1.0, float64(lengthToPoint/sum))
+	return min(1.0, float64(lengthToPoint/sum))
 }
 
 // TODO(roberts): Differences from C++.
diff --git a/s2/polyline_alignment.go b/s2/polyline_alignment.go
@@ -271,11 +271,11 @@ func (w *window) dilate(radius int) *window {
 
 	newStrides := make([]columnStride, w.rows)
 	for row := 0; row < w.rows; row++ {
-		prevRow := maxInt(0, row-radius)
-		nextRow := minInt(row+radius, w.rows-1)
+		prevRow := max(0, row-radius)
+		nextRow := min(row+radius, w.rows-1)
 		newStrides[row] = columnStride{
-			start: maxInt(0, w.strides[prevRow].start-radius),
-			end:   minInt(w.strides[nextRow].end+radius, w.cols),
+			start: max(0, w.strides[prevRow].start-radius),
+			end:   min(w.strides[nextRow].end+radius, w.cols),
 		}
 	}
 
@@ -458,7 +458,7 @@ func dynamicTimewarp(a, b *Polyline, w *window) *vertexAlignment {
 			uCost := costs.boundsCheckedTableCost(row-1, col-0, prev)
 			lCost := costs.boundsCheckedTableCost(row-0, col-1, curr)
 
-			costs[row][col] = minFloat64(dCost, uCost, lCost) +
+			costs[row][col] = min(dCost, uCost, lCost) +
 				(*a)[row].Sub((*b)[col].Vector).Norm()
 		}
 		prev = curr
@@ -473,7 +473,7 @@ func dynamicTimewarp(a, b *Polyline, w *window) *vertexAlignment {
 	// this incurs is larger than the cost to simply redo the comparisons.
 	// It's probably worth revisiting this assumption in the future.
 	// As it turns out, the following code ends up effectively free.
-	warpPath := make([]warpPair, 0, maxInt(rows, cols))
+	warpPath := make([]warpPair, 0, max(rows, cols))
 	row := rows - 1
 	col := cols - 1
 	curr = w.checkedColumnStride(row)
diff --git a/s2/polyline_alignment_test.go b/s2/polyline_alignment_test.go
@@ -345,7 +345,7 @@ func bruteForceCost(table costTable, i, j int) float64 {
 	} else if j == 0 {
 		return bruteForceCost(table, i-1, j) + table[i][j]
 	} else {
-		return minFloat64(bruteForceCost(table, i-1, j-1),
+		return min(bruteForceCost(table, i-1, j-1),
 			bruteForceCost(table, i-1, j),
 			bruteForceCost(table, i, j-1)) +
 			table[i][j]
diff --git a/s2/rect.go b/s2/rect.go
@@ -468,7 +468,7 @@ func (r *Rect) decode(d *decoder) {
 // The latlng must be valid.
 func (r Rect) DistanceToLatLng(ll LatLng) s1.Angle {
 	if r.Lng.Contains(float64(ll.Lng)) {
-		return maxAngle(0, ll.Lat-s1.Angle(r.Lat.Hi), s1.Angle(r.Lat.Lo)-ll.Lat)
+		return max(0, ll.Lat-s1.Angle(r.Lat.Hi), s1.Angle(r.Lat.Lo)-ll.Lat)
 	}
 
 	i := s1.IntervalFromEndpoints(r.Lng.Hi, r.Lng.ComplementCenter())
@@ -505,7 +505,7 @@ func (r Rect) DirectedHausdorffDistance(other Rect) s1.Angle {
 //
 //	H(A, B) = max{h(A, B), h(B, A)}.
 func (r Rect) HausdorffDistance(other Rect) s1.Angle {
-	return maxAngle(r.DirectedHausdorffDistance(other),
+	return max(r.DirectedHausdorffDistance(other),
 		other.DirectedHausdorffDistance(r))
 }
 
@@ -567,14 +567,14 @@ func directedHausdorffDistance(lngDiff s1.Angle, a, b r1.Interval) s1.Angle {
 	// Cases A1 and B1.
 	aLo := PointFromLatLng(LatLng{s1.Angle(a.Lo), 0})
 	aHi := PointFromLatLng(LatLng{s1.Angle(a.Hi), 0})
-	maxDistance := maxAngle(
+	maxDistance := max(
 		DistanceFromSegment(aLo, bLo, bHi),
 		DistanceFromSegment(aHi, bLo, bHi))
 
 	if lngDiff <= math.Pi/2 {
 		// Case A2.
 		if a.Contains(0) && b.Contains(0) {
-			maxDistance = maxAngle(maxDistance, lngDiff)
+			maxDistance = max(maxDistance, lngDiff)
 		}
 		return maxDistance
 	}
@@ -583,20 +583,20 @@ func directedHausdorffDistance(lngDiff s1.Angle, a, b r1.Interval) s1.Angle {
 	p := bisectorIntersection(b, bLng)
 	pLat := LatLngFromPoint(p).Lat
 	if a.Contains(float64(pLat)) {
-		maxDistance = maxAngle(maxDistance, p.Angle(bLo.Vector))
+		maxDistance = max(maxDistance, p.Angle(bLo.Vector))
 	}
 
 	// Case B3.
 	if pLat > s1.Angle(a.Lo) {
 		intDist, ok := interiorMaxDistance(r1.Interval{Lo: a.Lo, Hi: math.Min(float64(pLat), a.Hi)}, bLo)
 		if ok {
-			maxDistance = maxAngle(maxDistance, intDist)
+			maxDistance = max(maxDistance, intDist)
 		}
 	}
 	if pLat < s1.Angle(a.Hi) {
 		intDist, ok := interiorMaxDistance(r1.Interval{Lo: math.Max(float64(pLat), a.Lo), Hi: a.Hi}, bHi)
 		if ok {
-			maxDistance = maxAngle(maxDistance, intDist)
+			maxDistance = max(maxDistance, intDist)
 		}
 	}
 
diff --git a/s2/rect_test.go b/s2/rect_test.go
diff --git a/s2/regioncoverer.go b/s2/regioncoverer.go

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ func TestCellIDSnapperLevelToFromSnapRadius(t *testing.T) {`
`50`	`50`	`if got := f.levelForMaxSnapRadius(radius); got != level {`
`51`	`51`	`t.Errorf("levelForMaxSnapRadius(%v) = %v, want %v", radius, got, level)`
`52`	`52`	`}`
`53`		`- if got, want := f.levelForMaxSnapRadius(0.999*radius), minInt(level+1, MaxLevel); got != want {`
	`53`	`+ if got, want := f.levelForMaxSnapRadius(0.999*radius), min(level+1, MaxLevel); got != want {`
`54`	`54`	`t.Errorf("levelForMaxSnapRadius(0.999*%v) = %v, want %v (level %d)", radius, got, want, level)`
`55`	`55`	`}`
`56`	`56`	`}`
`@@ -84,7 +84,7 @@ func TestIntLatLngSnapperExponentToFromSnapRadius(t *testing.T) {`
`84`	`84`	`if got := sf.exponentForMaxSnapRadius(radius); got != exp {`
`85`	`85`	`t.Errorf("exponentForMaxSnapRadius(%v) = %v, want %v", radius, got, exp)`
`86`	`86`	`}`
`87`		`- if got, want := sf.exponentForMaxSnapRadius(0.999*radius), minInt(exp+1, maxIntSnappingExponent); got != want {`
	`87`	`+ if got, want := sf.exponentForMaxSnapRadius(0.999*radius), min(exp+1, maxIntSnappingExponent); got != want {`
`88`	`88`	`t.Errorf("exponentForMaxSnapRadius(%v) = %v, want %v", 0.999*radius, got, want)`
`89`	`89`	`}`
`90`	`90`	`}`
Original file line number	Diff line number	Diff line change
`@@ -491,7 +491,7 @@ func (cu *CellUnion) ExpandAtLevel(level int) {`
`491`	`491`	`func (cu *CellUnion) ExpandByRadius(minRadius s1.Angle, maxLevelDiff int) {`
`492`	`492`	`minLevel := MaxLevel`
`493`	`493`	`for _, cid := range *cu {`
`494`		`- minLevel = minInt(minLevel, cid.Level())`
	`494`	`+ minLevel = min(minLevel, cid.Level())`
`495`	`495`	`}`
`496`	`496`
`497`	`497`	`// Find the maximum level such that all cells are at least "minRadius" wide.`
`@@ -501,7 +501,7 @@ func (cu *CellUnion) ExpandByRadius(minRadius s1.Angle, maxLevelDiff int) {`
`501`	`501`	`// The easiest way to handle this is to expand twice.`
`502`	`502`	`cu.ExpandAtLevel(0)`
`503`	`503`	`}`
`504`		`- cu.ExpandAtLevel(minInt(minLevel+maxLevelDiff, radiusLevel))`
	`504`	`+ cu.ExpandAtLevel(min(minLevel+maxLevelDiff, radiusLevel))`
`505`	`505`	`}`
`506`	`506`
`507`	`507`	`// Equal reports whether the two CellUnions are equal.`
Original file line number	Diff line number	Diff line change
`@@ -120,8 +120,8 @@ func TestEdgeutilIntersectionError(t *testing.T) {`
`120`	`120`	`if got, want := pointDist, intersectionError; got > want {`
`121`	`121`	`t.Errorf("%v.Distance(%v) = %v want <= %v", expected, actual, got, want)`
`122`	`122`	`}`
`123`		`- maxEdgeDist = maxAngle(maxEdgeDist, maxAngle(distAB, distCD))`
`124`		`- maxPointDist = maxAngle(maxPointDist, pointDist)`
	`123`	`+ maxEdgeDist = max(maxEdgeDist, max(distAB, distCD))`
	`124`	`+ maxPointDist = max(maxPointDist, pointDist)`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
Original file line number	Diff line number	Diff line change
`@@ -448,7 +448,7 @@ func generateEdgeQueryWithTargets(opts edgeQueryBenchmarkOptions, query EdgeQu`
`448`	`448`	`numTargets := maxTargetsPerIndex`
`449`	`449`	`if opts.targetType == queryTypeIndex {`
`450`	`450`	`// Limit the total number of target edges to reduce the benchmark running times.`
`451`		`- numTargets = minInt(numTargets, 500000/opts.numTargetEdges)`
	`451`	`+ numTargets = min(numTargets, 500000/opts.numTargetEdges)`
`452`	`452`	`}`
`453`	`453`
`454`	`454`	`for i := 0; i < numTargets; i++ {`
Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ type EdgeTessellator struct {`
`196`	`196`	`func NewEdgeTessellator(p Projection, tolerance s1.Angle) *EdgeTessellator {`
`197`	`197`	`return &EdgeTessellator{`
`198`	`198`	`projection: p,`
`199`		`- scaledTolerance: s1.ChordAngleFromAngle(maxAngle(tolerance, minTessellationTolerance)),`
	`199`	`+ scaledTolerance: s1.ChordAngleFromAngle(max(tolerance, minTessellationTolerance)),`
`200`	`200`	`}`
`201`	`201`	`}`
`202`	`202`
`@@ -287,5 +287,5 @@ func (e *EdgeTessellator) estimateMaxError(pa r2.Point, a Point, pb r2.Point, b`
`287`	`287`	`mid2 := Interpolate(t2, a, b)`
`288`	`288`	`pmid1 := e.projection.Unproject(e.projection.Interpolate(t1, pa, pb))`
`289`	`289`	`pmid2 := e.projection.Unproject(e.projection.Interpolate(t2, pa, pb))`
`290`		`- return maxChordAngle(ChordAngleBetweenPoints(mid1, pmid1), ChordAngleBetweenPoints(mid2, pmid2))`
	`290`	`+ return max(ChordAngleBetweenPoints(mid1, pmid1), ChordAngleBetweenPoints(mid2, pmid2))`
`291`	`291`	`}`