update ref

Author: Philiphil

r2/rect.go

@@ -18,7 +18,7 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/golang/geo/r1"
+	"github.com/philiphil/geo/r1"
 )
 
 // Point represents a point in ℝ².

r2/rect_test.go

@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/golang/geo/r1"
+	"github.com/philiphil/geo/r1"
 )
 
 var (

r3/vector.go

@@ -18,7 +18,7 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/golang/geo/s1"
+	"github.com/philiphil/geo/s1"
 )
 
 // Vector represents a point in ℝ³.
@@ -146,9 +146,9 @@ func (v Vector) SmallestComponent() Axis {
 
 // Cmp compares v and ov lexicographically and returns:
 //
-//   -1 if v <  ov
-//    0 if v == ov
-//   +1 if v >  ov
+//	-1 if v <  ov
+//	 0 if v == ov
+//	+1 if v >  ov
 //
 // This method is based on C++'s std::lexicographical_compare. Two entities
 // are compared element by element with the given operator. The first mismatch

s1/example_test.go

@@ -18,7 +18,7 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/golang/geo/s1"
+	"github.com/philiphil/geo/s1"
 )
 
 func ExampleInterval_DirectedHausdorffDistance() {

s2/cap.go

@@ -19,8 +19,8 @@ import (
 	"io"
 	"math"
 
-	"github.com/golang/geo/r1"
-	"github.com/golang/geo/s1"
+	"github.com/philiphil/geo/r1"
+	"github.com/philiphil/geo/s1"
 )
 
 var (
@@ -52,10 +52,10 @@ var (
 // radius (r), the maximum chord length from the cap's center (d), and the
 // radius of cap's base (a).
 //
-//     h = 1 - cos(r)
-//       = 2 * sin^2(r/2)
-//   d^2 = 2 * h
-//       = a^2 + h^2
+//	  h = 1 - cos(r)
+//	    = 2 * sin^2(r/2)
+//	d^2 = 2 * h
+//	    = a^2 + h^2
 //
 // The zero value of Cap is an invalid cap. Use EmptyCap to get a valid empty cap.
 type Cap struct {

s2/cap_test.go

@@ -18,8 +18,8 @@ import (
 	"math"
 	"testing"
 
-	"github.com/golang/geo/r3"
-	"github.com/golang/geo/s1"
+	"github.com/philiphil/geo/r3"
+	"github.com/philiphil/geo/s1"
 )
 
 const (

s2/cell.go

@@ -18,10 +18,10 @@ import (
 	"io"
 	"math"
 
-	"github.com/golang/geo/r1"
-	"github.com/golang/geo/r2"
-	"github.com/golang/geo/r3"
-	"github.com/golang/geo/s1"
+	"github.com/philiphil/geo/r1"
+	"github.com/philiphil/geo/r2"
+	"github.com/philiphil/geo/r3"
+	"github.com/philiphil/geo/s1"
 )
 
 // Cell is an S2 region object that represents a cell. Unlike CellIDs,

s2/cell_test.go

@@ -19,8 +19,8 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/golang/geo/r2"
-	"github.com/golang/geo/s1"
+	"github.com/philiphil/geo/r2"
+	"github.com/philiphil/geo/s1"
 )
 
 // maxCellSize is the upper bounds on the number of bytes we want the Cell object to ever be.

s2/cellid.go

@@ -23,10 +23,10 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/golang/geo/r1"
-	"github.com/golang/geo/r2"
-	"github.com/golang/geo/r3"
-	"github.com/golang/geo/s1"
+	"github.com/philiphil/geo/r1"
+	"github.com/philiphil/geo/r2"
+	"github.com/philiphil/geo/r3"
+	"github.com/philiphil/geo/s1"
 )
 
 // CellID uniquely identifies a cell in the S2 cell decomposition.
@@ -39,15 +39,15 @@ import (
 // Sequentially increasing cell IDs follow a continuous space-filling curve
 // over the entire sphere. They have the following properties:
 //
-//  - The ID of a cell at level k consists of a 3-bit face number followed
-//    by k bit pairs that recursively select one of the four children of
-//    each cell. The next bit is always 1, and all other bits are 0.
-//    Therefore, the level of a cell is determined by the position of its
-//    lowest-numbered bit that is turned on (for a cell at level k, this
-//    position is 2 * (maxLevel - k)).
+//   - The ID of a cell at level k consists of a 3-bit face number followed
+//     by k bit pairs that recursively select one of the four children of
+//     each cell. The next bit is always 1, and all other bits are 0.
+//     Therefore, the level of a cell is determined by the position of its
+//     lowest-numbered bit that is turned on (for a cell at level k, this
+//     position is 2 * (maxLevel - k)).
 //
-//  - The ID of a parent cell is at the midpoint of the range of IDs spanned
-//    by its children (or by its descendants at any level).
+//   - The ID of a parent cell is at the midpoint of the range of IDs spanned
+//     by its children (or by its descendants at any level).
 //
 // Leaf cells are often used to represent points on the unit sphere, and
 // this type provides methods for converting directly between these two
@@ -373,9 +373,9 @@ func (ci CellID) LatLng() LatLng { return LatLngFromPoint(Point{ci.rawPoint()})
 
 // ChildBegin returns the first child in a traversal of the children of this cell, in Hilbert curve order.
 //
-//    for ci := c.ChildBegin(); ci != c.ChildEnd(); ci = ci.Next() {
-//        ...
-//    }
+//	for ci := c.ChildBegin(); ci != c.ChildEnd(); ci = ci.Next() {
+//	    ...
+//	}
 func (ci CellID) ChildBegin() CellID {
 	ol := ci.lsb()
 	return CellID(uint64(ci) - ol + ol>>2)
@@ -644,7 +644,7 @@ func stToIJ(s float64) int {
 // s2.CellIDs are considered to be closed sets. The returned cell will
 // always contain the given point, i.e.
 //
-//   CellFromPoint(p).ContainsPoint(p)
+//	CellFromPoint(p).ContainsPoint(p)
 //
 // is always true.
 func cellIDFromPoint(p Point) CellID {
@@ -839,19 +839,19 @@ func expandEndpoint(u, maxV, sinDist float64) float64 {
 // it contains all points within 5km of the original cell. You can then
 // test whether a point lies within the expanded bounds like this:
 //
-//   if u, v, ok := faceXYZtoUV(face, point); ok && bound.ContainsPoint(r2.Point{u,v}) { ... }
+//	if u, v, ok := faceXYZtoUV(face, point); ok && bound.ContainsPoint(r2.Point{u,v}) { ... }
 //
 // Limitations:
 //
-//  - Because the rectangle is drawn on one of the six cube-face planes
-//    (i.e., {x,y,z} = +/-1), it can cover at most one hemisphere. This
-//    limits the maximum amount that a rectangle can be expanded. For
-//    example, CellID bounds can be expanded safely by at most 45 degrees
-//    (about 5000 km on the Earth's surface).
+//   - Because the rectangle is drawn on one of the six cube-face planes
+//     (i.e., {x,y,z} = +/-1), it can cover at most one hemisphere. This
+//     limits the maximum amount that a rectangle can be expanded. For
+//     example, CellID bounds can be expanded safely by at most 45 degrees
+//     (about 5000 km on the Earth's surface).
 //
-//  - The implementation is not exact for negative distances. The resulting
-//    rectangle will exclude all points within the given distance of the
-//    boundary but may be slightly smaller than necessary.
+//   - The implementation is not exact for negative distances. The resulting
+//     rectangle will exclude all points within the given distance of the
+//     boundary but may be slightly smaller than necessary.
 func expandedByDistanceUV(uv r2.Rect, distance s1.Angle) r2.Rect {
 	// Expand each of the four sides of the rectangle just enough to include all
 	// points within the given distance of that side. (The rectangle may be
@@ -872,7 +872,7 @@ func expandedByDistanceUV(uv r2.Rect, distance s1.Angle) r2.Rect {
 // a given range (a tiling). This example shows how to generate a tiling
 // for a semi-open range of leaf cells [start, limit):
 //
-//   for id := start.MaxTile(limit); id != limit; id = id.Next().MaxTile(limit)) { ... }
+//	for id := start.MaxTile(limit); id != limit; id = id.Next().MaxTile(limit)) { ... }
 //
 // Note that in general the cells in the tiling will be of different sizes;
 // they gradually get larger (near the middle of the range) and then

s2/cellid_test.go

@@ -19,8 +19,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/golang/geo/r2"
-	"github.com/golang/geo/s1"
+	"github.com/philiphil/geo/r2"
+	"github.com/philiphil/geo/s1"
 )
 
 func TestCellIDFromFace(t *testing.T) {