Use Rat64 throughout

internal/exact/bently_ottmann_test.go

@@ -21,14 +21,8 @@ func TestBentlyOttmann(t *testing.T) {
 			description: "single segments",
 			segments: []exact.Segment{
 				{
-					A: exact.XY64{
-						X: 0,
-						Y: 0,
-					},
-					B: exact.XY64{
-						X: 1,
-						Y: 1,
-					},
+					A: exact.XY64{X: 0, Y: 0}.ToRat(),
+					B: exact.XY64{X: 1, Y: 1}.ToRat(),
 				},
 			},
 			want: nil,

internal/exact/segment.go

@@ -1,12 +1,12 @@
 package exact
 
 type Segment struct {
-	A, B XY64
+	A, B XYRat
 }
 
 type Intersection struct {
 	Empty bool
-	A, B  XY64
+	A, B  XYRat
 }
 
 func SegmentIntersection(segA, segB Segment) Intersection {
@@ -16,10 +16,10 @@ func SegmentIntersection(segA, segB Segment) Intersection {
 		panic("invalid segment")
 	}
 
-	v1 := segA.A.ToRat()
-	v2 := segA.B.ToRat()
-	v3 := segB.A.ToRat()
-	v4 := segB.B.ToRat()
+	v1 := segA.A
+	v2 := segA.B
+	v3 := segB.A
+	v4 := segB.B
 
 	// d := (x1-x2)*(y3-y4)-(y1-y2)*(x3-x4)
 	sub12 := v1.Sub(v2)
@@ -42,11 +42,9 @@ func SegmentIntersection(segA, segB Segment) Intersection {
 		if v2.Less(v3) || v4.Less(v1) {
 			return Intersection{Empty: true}
 		}
-		min := v2.Min(v4)
-		max := v1.Max(v3)
 		return Intersection{
-			A: max.ToXY64(),
-			B: min.ToXY64(),
+			A: v1.Max(v3),
+			B: v2.Min(v4),
 		}
 	}
 
@@ -59,7 +57,7 @@ func SegmentIntersection(segA, segB Segment) Intersection {
 	u := div(sub21.Cross(sub13), d)
 
 	if inUnitInterval(t) && inUnitInterval(u) {
-		pt := sub21.Scale(t).Add(v1).ToXY64()
+		pt := sub21.Scale(t).Add(v1)
 		return Intersection{A: pt, B: pt}
 	}
 

internal/exact/segment_test.go

@@ -4,36 +4,41 @@ import (
 	"fmt"
 	"testing"
 
+	"math/big"
+
 	. "github.com/peterstace/simplefeatures/internal/exact"
 )
 
 func TestSegmentIntersection(t *testing.T) {
 	var (
-		p00 = XY64{X: 0, Y: 0}
-		p10 = XY64{X: 1, Y: 0}
-		p01 = XY64{X: 0, Y: 1}
-		p11 = XY64{X: 1, Y: 1}
-		p21 = XY64{X: 2, Y: 1}
-		p02 = XY64{X: 0, Y: 2}
-		p22 = XY64{X: 2, Y: 2}
-		p20 = XY64{X: 2, Y: 0}
-		p40 = XY64{X: 4, Y: 0}
-		p60 = XY64{X: 6, Y: 0}
-		p42 = XY64{X: 4, Y: 2}
-		p63 = XY64{X: 6, Y: 3}
+		p00 = XY64{X: 0, Y: 0}.ToRat()
+		p10 = XY64{X: 1, Y: 0}.ToRat()
+		p01 = XY64{X: 0, Y: 1}.ToRat()
+		p11 = XY64{X: 1, Y: 1}.ToRat()
+		p21 = XY64{X: 2, Y: 1}.ToRat()
+		p02 = XY64{X: 0, Y: 2}.ToRat()
+		p22 = XY64{X: 2, Y: 2}.ToRat()
+		p20 = XY64{X: 2, Y: 0}.ToRat()
+		p40 = XY64{X: 4, Y: 0}.ToRat()
+		p60 = XY64{X: 6, Y: 0}.ToRat()
+		p42 = XY64{X: 4, Y: 2}.ToRat()
+		p63 = XY64{X: 6, Y: 3}.ToRat()
 	)
-	ln := func(a, b XY64) Segment {
+	ln := func(a, b XYRat) Segment {
 		return Segment{A: a, B: b}
 	}
 
-	e := func(xy XY64) XY64 {
+	neg := func(r *big.Rat) *big.Rat {
+		return new(big.Rat).Neg(r)
+	}
+	e := func(xy XYRat) XYRat {
 		return xy
 	}
-	p := func(xy XY64) XY64 {
-		return XY64{X: -xy.Y, Y: xy.X}
+	p := func(xy XYRat) XYRat {
+		return XYRat{X: neg(xy.Y), Y: xy.X}
 	}
-	q := func(xy XY64) XY64 {
-		return XY64{X: -xy.X, Y: xy.Y}
+	q := func(xy XYRat) XYRat {
+		return XYRat{X: neg(xy.X), Y: xy.Y}
 	}
 
 	for _, tc := range []struct {
@@ -162,7 +167,7 @@ func TestSegmentIntersection(t *testing.T) {
 	} {
 		t.Run(tc.description, func(t *testing.T) {
 			for flip := 0; flip < 8; flip++ {
-				for groupIdx, group := range [][]func(XY64) XY64{
+				for groupIdx, group := range [][]func(XYRat) XYRat{
 					{e},
 					{p},
 					{p, p},
@@ -186,13 +191,15 @@ func TestSegmentIntersection(t *testing.T) {
 						}
 
 						want := tc.inter
-						for _, fn := range group {
-							want.A = fn(want.A)
-							want.B = fn(want.B)
-							segA.A = fn(segA.A)
-							segA.B = fn(segA.B)
-							segB.A = fn(segB.A)
-							segB.B = fn(segB.B)
+						if !want.Empty {
+							for _, fn := range group {
+								want.A = fn(want.A)
+								want.B = fn(want.B)
+								segA.A = fn(segA.A)
+								segA.B = fn(segA.B)
+								segB.A = fn(segB.A)
+								segB.B = fn(segB.B)
+							}
 						}
 
 						got := SegmentIntersection(segA, segB)