feat: slightly optimize CellsToMultiPolygon and LatLng#String (#86)

Before:
```
BenchmarkCellsToMultiPolygon-16       589149          2022 ns/op         344 B/op          8 allocs/op
BenchmarkLatLng_String-16        6480610           184.2 ns/op        40 B/op          3 allocs/op
```

After:
```
BenchmarkCellsToMultiPolygon-16       600781          2006 ns/op         200 B/op          5 allocs/op
BenchmarkLatLng_String-16            9569876           126.4 ns/op        24 B/op          1 allocs/op
```

Author: justinhwang

bench_test.go

@@ -10,46 +10,53 @@ var (
 		Lat: 37,
 		Lng: -122,
 	}
-	cell, _  = LatLngToCell(geo, 15)
-	addr     = cell.String()
-	geoBndry CellBoundary
-	cells    []Cell
-	disks    [][]Cell
+	latlngStr string
+	cell, _   = LatLngToCell(geo, 15)
+	addr      = cell.String()
+	geoBndry  CellBoundary
+	cells     []Cell
+	disks     [][]Cell
 )
 
 func BenchmarkToString(b *testing.B) {
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		addr = cell.String()
 	}
 }
 
 func BenchmarkFromString(b *testing.B) {
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		//nolint:gosec // IndexFromString returns uint64 and fixing that to detect integer overflows will break package API. Let's skip it for now.
 		cell = Cell(IndexFromString("850dab63fffffff"))
 	}
 }
 
+func BenchmarkLatLng_String(b *testing.B) {
+	for range b.N {
+		latlngStr = geo.String()
+	}
+}
+
 func BenchmarkCellToLatLng(b *testing.B) {
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		geo, _ = CellToLatLng(cell)
 	}
 }
 
 func BenchmarkLatLngToCell(b *testing.B) {
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		cell, _ = LatLngToCell(geo, 15)
 	}
 }
 
 func BenchmarkCellToBoundary(b *testing.B) {
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		geoBndry, _ = CellToBoundary(cell)
 	}
 }
 
 func BenchmarkGridDisk(b *testing.B) {
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		cells, _ = cell.GridDisk(10)
 	}
 }
@@ -61,7 +68,7 @@ func BenchmarkGridRing(b *testing.B) {
 }
 
 func BenchmarkPolyfill(b *testing.B) {
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		cells, _ = PolygonToCells(validGeoPolygonHoles, 13)
 	}
 }
@@ -71,7 +78,7 @@ func BenchmarkGridDisksUnsafe(b *testing.B) {
 
 	b.ResetTimer()
 
-	for n := 0; n < b.N; n++ {
+	for range b.N {
 		disks, _ = GridDisksUnsafe(cells, 10)
 	}
 }

h3.go

@@ -32,7 +32,6 @@ import "C"
 
 import (
 	"errors"
-	"fmt"
 	"math"
 	"strconv"
 	"strings"
@@ -72,6 +71,15 @@ const (
 	RadsToDegs = 180.0 / math.Pi
 )
 
+const (
+	latLngFloatPrecision = 5
+	// latLngStringSize is the size to pre-allocate the buffer for.
+	// Given latLngFloatPrecision, a typical string is "(DD.DDDDD, -DDD.DDDDD)"
+	// which is ~25-30 bytes. 32 is a safe and efficient capacity to start with
+	// to avoid re-allocation.
+	latLngStringSize = 32
+)
+
 // PolygonToCells containment modes
 const (
 	ContainmentCenter          ContainmentMode = C.CONTAINMENT_CENTER           // Cell center is contained in the shape
@@ -122,7 +130,6 @@ var (
 )
 
 type (
-
 	// Cell is an Index that identifies a single hexagon cell at a resolution.
 	Cell int64
 
@@ -468,7 +475,7 @@ func PolygonToCells(polygon GeoPolygon, resolution int) ([]Cell, error) {
 // and then any newly found hexagons are used to test again until no new
 // hexagons are found.
 func PolygonToCellsExperimental(polygon GeoPolygon, resolution int, mode ContainmentMode, maxNumCellsReturn ...int64) ([]Cell, error) {
-	var maxNumCells int64 = math.MaxInt64
+	maxNumCells := int64(math.MaxInt64)
 	if len(maxNumCellsReturn) > 0 {
 		maxNumCells = maxNumCellsReturn[0]
 	}
@@ -519,30 +526,55 @@ func CellsToMultiPolygon(cells []Cell) ([]GeoPolygon, error) {
 		return nil, err
 	}
 
-	ret := []GeoPolygon{}
+	currPoly := cLinkedGeoPolygon
+	var countPoly int
+	for currPoly != nil {
+		countPoly++
+		currPoly = currPoly.next
+	}
+
+	ret := make([]GeoPolygon, countPoly)
 
 	// traverse polygons for linked list of polygons
-	currPoly := cLinkedGeoPolygon
+	currPoly = cLinkedGeoPolygon
+	countPoly = 0
 	for currPoly != nil {
-		loops := []GeoLoop{}
+		currLoop := currPoly.first
+		var countLoop int
+		for currLoop != nil {
+			countLoop++
+			currLoop = currLoop.next
+		}
+		loops := make([]GeoLoop, countLoop)
 
 		// traverse loops for a polygon
-		currLoop := currPoly.first
+		currLoop = currPoly.first
+		countLoop = 0
 		for currLoop != nil {
-			loop := []LatLng{}
+			currPt := currLoop.first
+			var countPt int
+			for currPt != nil {
+				countPt++
+				currPt = currPt.next
+			}
+			loop := make([]LatLng, countPt)
 
 			// traverse points for a loop
-			currPt := currLoop.first
+			currPt = currLoop.first
+			countPt = 0
 			for currPt != nil {
-				loop = append(loop, latLngFromC(currPt.vertex))
+				loop[countPt] = latLngFromC(currPt.vertex)
+				countPt++
 				currPt = currPt.next
 			}
 
-			loops = append(loops, loop)
+			loops[countLoop] = loop
+			countLoop++
 			currLoop = currLoop.next
 		}
 
-		ret = append(ret, GeoPolygon{GeoLoop: loops[0], Holes: loops[1:]})
+		ret[countPoly] = GeoPolygon{GeoLoop: loops[0], Holes: loops[1:]}
+		countPoly++
 		currPoly = currPoly.next
 	}
 
@@ -669,7 +701,7 @@ func EdgeLengthM(e DirectedEdge) (float64, error) {
 func NumCells(resolution int) int {
 	// NOTE: this is a mathematical operation, no need to call into H3 library.
 	// See h3api.h for formula derivation.
-	return 2 + 120*intPow(7, (resolution)) //nolint:mnd // math formula
+	return 2 + 120*intPow(7, resolution) //nolint:mnd // math formula
 }
 
 // Res0Cells returns all the cells at resolution 0.
@@ -1059,11 +1091,10 @@ func maxGridDiskSize(k int) int {
 }
 
 func latLngFromC(cg C.LatLng) LatLng {
-	g := LatLng{}
-	g.Lat = RadsToDegs * float64(cg.lat)
-	g.Lng = RadsToDegs * float64(cg.lng)
-
-	return g
+	return LatLng{
+		Lat: RadsToDegs * float64(cg.lat),
+		Lng: RadsToDegs * float64(cg.lng),
+	}
 }
 
 func cellBndryFromC(cb *C.CellBoundary) CellBoundary {
@@ -1229,7 +1260,13 @@ func intsFromC(chs []C.int) []int {
 }
 
 func (g LatLng) String() string {
-	return fmt.Sprintf("(%.5f, %.5f)", g.Lat, g.Lng)
+	buf := make([]byte, 0, latLngStringSize)
+	buf = append(buf, '(')
+	buf = strconv.AppendFloat(buf, g.Lat, 'f', latLngFloatPrecision, 64) //nolint:mnd // float bit size
+	buf = append(buf, ',', ' ')
+	buf = strconv.AppendFloat(buf, g.Lng, 'f', latLngFloatPrecision, 64) //nolint:mnd // float bit size
+	buf = append(buf, ')')
+	return string(buf)
 }
 
 func (g LatLng) toCPtr() *C.LatLng {