Init Point and Vector

tomas-novotny · tomas-novotny · commit f5ae62d694cb · 2025-08-17T14:38:51.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,3 +7,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 
 ## [Unreleased](https://github.com/gravitton/geometry/compare/v1.0.0...master)
+### Added
+- `Point`
+- `Vector`
diff --git a/README.md b/README.md
@@ -8,7 +8,7 @@
 [![Go Dev Reference][ico-go-dev-reference]][link-go-dev-reference]
 [![Software License][ico-license]][link-licence]
 
-2D geometry library for game development.
+Generic immutable 2D geometry library for game development.
 
 
 ## Installation
@@ -24,7 +24,7 @@ go get github.com/gravitton/geometry
 package main
 
 import (
-	"github.com/gravitton/geometry"
+	geom "github.com/gravitton/geometry"
 )
 ```
 
diff --git a/constraints.go b/constraints.go
@@ -0,0 +1,5 @@
+package geom
+
+type Number interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~float32 | ~float64
+}
diff --git a/doc.go b/doc.go
@@ -1 +1 @@
-package geometry
+package geom
diff --git a/format.go b/format.go
@@ -0,0 +1,19 @@
+package geom
+
+import (
+	"fmt"
+)
+
+// IsInt checks if Number is integer value
+func IsInt[T Number](value T) bool {
+	return float64(value) == float64(int(value))
+}
+
+// ToString format Number as numeric string
+func ToString[T Number](value T) string {
+	if IsInt(value) {
+		return fmt.Sprintf("%+d", int(value))
+	} else {
+		return fmt.Sprintf("%+.2f", float64(value))
+	}
+}
diff --git a/format_test.go b/format_test.go
@@ -0,0 +1,44 @@
+package geom
+
+import (
+	"github.com/gravitton/assert"
+	"math"
+	"testing"
+)
+
+func TestIsInt(t *testing.T) {
+	testIsInt(t, 1, true)
+	testIsInt(t, -2, true)
+	testIsInt(t, 986, true)
+	testIsInt(t, 1.0, true)
+	testIsInt(t, -2.0, true)
+	testIsInt(t, 189.2, false)
+	testIsInt(t, -9.3333, false)
+	testIsInt(t, 1.000001, false)
+	testIsInt(t, 23.0000000, true)
+	testIsInt(t, math.NaN(), false)
+	testIsInt(t, math.Inf(1), false)
+}
+
+func TestToString(t *testing.T) {
+	testToString(t, 3, "+3")
+	testToString(t, -2, "-2")
+	testToString(t, 0.0000, "+0")
+	testToString(t, 1.00, "+1")
+	testToString(t, 29.59, "+29.59")
+	testToString(t, 1.001, "+1.00")
+	testToString(t, 1.009, "+1.01")
+	testToString(t, -1.011, "-1.01")
+}
+
+func testIsInt[T Number](t *testing.T, value T, expected bool) {
+	t.Helper()
+
+	assert.Equal(t, IsInt(value), expected)
+}
+
+func testToString[T Number](t *testing.T, value T, expected string) {
+	t.Helper()
+
+	assert.Equal(t, ToString(value), expected)
+}
diff --git a/go.mod b/go.mod
@@ -1,3 +1,5 @@
 module github.com/gravitton/geometry
 
 go 1.24
+
+require github.com/gravitton/assert v0.4.0
diff --git a/go.sum b/go.sum
@@ -0,0 +1,2 @@
+github.com/gravitton/assert v0.4.0 h1:uZVoJb79XoUpDYq0GBUHCJI3sS6mieOmoq+ZuXf2wvc=
+github.com/gravitton/assert v0.4.0/go.mod h1:t/H52Szce7uofC0H1sN9yLZsj1TBvky5sGmrFiaxypY=
diff --git a/math.go b/math.go
@@ -0,0 +1,45 @@
+package geom
+
+import "math"
+
+const (
+	Delta float64 = 1e-6
+)
+
+// Midpoint calculate midpoint (point exactly halfway between two points)
+// Shorthand for `lerp(a, b, 0.5)`
+// TODO: fix rounding for int numbers
+func Midpoint[T Number](a, b T) T {
+	return T(midpoint(float64(a), float64(b)))
+}
+
+func midpoint(a, b float64) float64 {
+	// optimized `a + (b-a)/2.0`
+	// return lerp(a, b, 0.5)
+	return (a + b) / 2.0
+}
+
+// Lerp calculate linear interpolation (point along a line between two points based on a given ratio)
+// TODO: fix rounding for int numbers
+func Lerp[T Number](a, b T, t float64) T {
+	return T(lerp(float64(a), float64(b), t))
+}
+
+func lerp(a, b, t float64) float64 {
+	// optimized `a + (b-a)*t`
+	return a*(1-t) + b*t
+}
+
+// Equal checks for nearly-equal values in Delta
+func Equal[T Number](a, b T) bool {
+	return EqualDelta(a, b, Delta)
+}
+
+// Equal checks for nearly-equal values in given delta
+func EqualDelta[T Number](a, b T, delta float64) bool {
+	return equalDelta(float64(a), float64(b), delta)
+}
+
+func equalDelta(a, b, delta float64) bool {
+	return math.Abs(a-b) <= delta
+}
diff --git a/math_test.go b/math_test.go
@@ -0,0 +1,24 @@
+package geom
+
+import (
+	"github.com/gravitton/assert"
+	"testing"
+)
+
+func TestMidpoint(t *testing.T) {
+	assert.Equal(t, Midpoint(1, 4), 2)
+	assert.Equal(t, Midpoint(1, 5), 3)
+	assert.Equal(t, Midpoint(1, 6), 3)
+
+	assert.Equal(t, Midpoint(1.0, 6.0), 3.5)
+}
+
+func TestLerp(t *testing.T) {
+	assert.Equal(t, Lerp(1, 4, 0.25), 1)
+	assert.Equal(t, Lerp(1, 5, 0.25), 2)
+	assert.Equal(t, Lerp(1, 6, 0.25), 2)
+
+	assert.Equal(t, Lerp(1.0, 6.0, 0.25), 2.25)
+	assert.Equal(t, Lerp(1.0, 6.0, 0.75), 4.75)
+
+}
diff --git a/point.go b/point.go
@@ -0,0 +1,57 @@
+package geom
+
+import (
+	"fmt"
+)
+
+// Point is a 2D point.
+type Point[T Number] struct {
+	X T `json:"x"`
+	Y T `json:"y"`
+}
+
+// Pt is shorthand for Point[T]{x, y}.
+func Pt[T Number](x, y T) Point[T] {
+	return Point[T]{x, y}
+}
+
+// Add creates a new Point by adding the given vector to the current point.
+func (p Point[T]) Add(change Vector[T]) Point[T] {
+	return Point[T]{p.X + change.X, p.Y + change.Y}
+}
+
+// Sub creates a new Vector by subtracting the given point from the current point.
+func (p Point[T]) Sub(other Point[T]) Vector[T] {
+	return Vector[T]{p.X - other.X, p.Y - other.Y}
+}
+
+// Midpoint creates a new Point between current and given points
+func (p Point[T]) Midpoint(other Point[T]) Point[T] {
+	return Point[T]{Midpoint(p.X, other.X), Midpoint(p.Y, other.Y)}
+}
+
+// Lerp creates a new Point in linear interpolation towards given point
+func (p Point[T]) Lerp(other Point[T], t float64) Point[T] {
+	return Point[T]{Lerp(p.X, other.X, t), Lerp(p.Y, other.Y, t)}
+}
+
+// Equal checks for equal X and Y values with given point.
+func (p Point[T]) Equal(other Point[T]) bool {
+	return Equal(p.X, other.X) && Equal(p.Y, other.Y)
+}
+
+// Zero checks if X and Y values are 0.
+func (p Point[T]) Zero() bool {
+	// return Equal(p.X, 0) && Equal(p.Y, 0)
+	return p.Equal(Point[T]{})
+}
+
+// String returns a string representing the point.
+func (p Point[T]) String() string {
+	return fmt.Sprintf("(%s,%s)", ToString(p.X), ToString(p.Y))
+}
+
+// ZeroPoint creates a new Point with zero values (0,0).
+func ZeroPoint[T Number]() Point[T] {
+	return Point[T]{}
+}
diff --git a/point_test.go b/point_test.go
@@ -0,0 +1,94 @@
+package geom
+
+import (
+	"encoding/json"
+	"github.com/gravitton/assert"
+	"testing"
+)
+
+func TestPoint_New(t *testing.T) {
+	testPoint(t, Pt(10, 16), 10, 16)
+	testPoint(t, Pt[float64](0.16, 204), 0.16, 204.0)
+
+	testPoint(t, ZeroPoint[int](), 0, 0)
+}
+
+func TestPoint_Add(t *testing.T) {
+	testPoint(t, Pt(1, 2).Add(Vec(3, -2)), 4, 0)
+	testPoint(t, Pt(0.4, -0.25).Add(Vec(100.1, -0.1)), 100.5, -0.35)
+}
+
+func TestPoint_Sub(t *testing.T) {
+	testVector(t, Pt(1, 2).Sub(Pt(3, -3)), -2, 5)
+	testVector(t, Pt(0.4, -0.25).Sub(Pt(100.1, -0.1)), -99.7, -0.15)
+}
+
+func TestPoint_Midpoint(t *testing.T) {
+	testPoint(t, Pt(1, 2).Midpoint(Pt(3, -3)), 2, 0)
+	testPoint(t, Pt(0.4, -0.25).Midpoint(Pt(100.1, -0.1)), 50.25, -0.175)
+}
+
+func TestPoint_Lerp(t *testing.T) {
+	testPoint(t, Pt(1, 2).Lerp(Pt(3, -3), 0.3), 1, 0)
+	testPoint(t, Pt(0.4, -0.25).Lerp(Pt(100.1, -0.1), 0.1), 10.37, -0.235)
+}
+
+func TestPoint_Equal(t *testing.T) {
+	assert.False(t, Pt(1, 2).Equal(Pt(3, -3)))
+	assert.True(t, Pt(1, 2).Equal(Pt(1, 2)))
+
+	assert.False(t, Pt(0.4, -0.25).Equal(Pt(100.1, -0.1)))
+	assert.True(t, Pt(0.4, -0.25).Equal(Pt(0.4, -0.25)))
+	assert.True(t, Pt(0.4, -0.25).Equal(Pt(0.4, -0.250001)))
+}
+
+func TestPoint_Zero(t *testing.T) {
+	assert.False(t, Pt(1, 2).Zero())
+	assert.True(t, Pt(0, -0).Zero())
+	assert.True(t, ZeroPoint[int]().Zero())
+
+	assert.False(t, Pt(0.4, -0.25).Zero())
+	assert.True(t, Pt(0.0, -0.0).Zero())
+	assert.True(t, Pt(0.0, 0.000001).Zero())
+	assert.True(t, ZeroPoint[float64]().Zero())
+}
+
+func TestPoint_String(t *testing.T) {
+	assert.Equal(t, Pt(10, 16).String(), "(+10,+16)")
+	assert.Equal(t, Pt(100, -34.0000115).String(), "(+100,-34.00)")
+}
+
+func TestPoint_Marshall(t *testing.T) {
+	assert.JSON(t, Pt(10, 16), `{"x":10,"y":16}`)
+	assert.JSON(t, Pt(100, -34.0000115), `{"x":100.0,"y":-34.0000115}`)
+}
+
+func TestPoint_Unmarshall(t *testing.T) {
+	var p1 Point[int]
+	assert.NoError(t, json.Unmarshal([]byte(`{"x":10,"y":16}`), &p1))
+	testPoint(t, p1, 10, 16)
+
+	var p2 Point[float64]
+	assert.NoError(t, json.Unmarshal([]byte(`{"x":10.1,"y":-34.0000115}`), &p2))
+	testPoint(t, p2, 10.1, -34.0000115)
+}
+
+func TestPoint_Immutable(t *testing.T) {
+	p1 := Pt(1, 2)
+	p2 := Pt(3, -3)
+
+	p1.Add(Vec(3, -2))
+	p1.Sub(p2)
+	p1.Midpoint(p2)
+	p1.Lerp(p2, 0.1)
+
+	testPoint(t, p1, 1, 2)
+	testPoint(t, p2, 3, -3)
+}
+
+func testPoint[T Number](t *testing.T, p Point[T], x, y T) {
+	t.Helper()
+
+	assert.EqualDelta(t, float64(p.X), float64(x), Delta)
+	assert.EqualDelta(t, float64(p.Y), float64(y), Delta)
+}
diff --git a/vector.go b/vector.go
diff --git a/vector_test.go b/vector_test.go

-Original file line number
+Diff line change
@@ @@ -1,3 +1,5 @@ @@
 module github.com/gravitton/geometry
 go 1.24
++
 +require github.com/gravitton/assert v0.4.0
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+github.com/gravitton/assert v0.4.0 h1:uZVoJb79XoUpDYq0GBUHCJI3sS6mieOmoq+ZuXf2wvc=`
	`2`	`+github.com/gravitton/assert v0.4.0/go.mod h1:t/H52Szce7uofC0H1sN9yLZsj1TBvky5sGmrFiaxypY=`