Add cast functions to types packages

Author: tomas-novotny

math.go

@@ -79,3 +79,13 @@ func EqualDelta[T Number](a, b T, delta float64) bool {
 func equalDelta(a, b, delta float64) bool {
 	return math.Abs(a-b) <= delta
 }
+
+// Transform applies a function to each element in a slice
+func Transform[S ~[]E, E any, T any](input S, fn func(E) T) []T {
+	output := make([]T, len(input))
+	for i, v := range input {
+		output[i] = fn(v)
+	}
+
+	return output
+}

polygon.go

@@ -1,11 +1,11 @@
 package geom
 
-// Polygon is a 2D polygon with 3+ transform.
+// Polygon is a 2D polygon with 3+ vertices.
 type Polygon[T Number] struct {
 	Vertices []Point[T]
 }
 
-// Center returns the polygon centroid computed as the average of its transform.
+// Center returns the polygon centroid computed as the average of its vertices.
 func (p Polygon[T]) Center() Point[T] {
 	var x, y T
 	l := T(len(p.Vertices))
@@ -16,9 +16,9 @@ func (p Polygon[T]) Center() Point[T] {
 	return Point[T]{x / l, y / l}
 }
 
-// Translate creates a new Polygon translated by the given vector (applied to all transform).
+// Translate creates a new Polygon translated by the given vector (applied to all vertices).
 func (p Polygon[T]) Translate(vector Vector[T]) Polygon[T] {
-	return Polygon[T]{transform(p.Vertices, func(e Point[T]) Point[T] {
+	return Polygon[T]{Transform(p.Vertices, func(e Point[T]) Point[T] {
 		return e.Add(vector)
 	})}
 }
@@ -31,24 +31,15 @@ func (p Polygon[T]) MoveTo(point Point[T]) Polygon[T] {
 // Scale creates a new Polygon uniformly scaled about its centroid by the factor.
 func (p Polygon[T]) Scale(scale float64) Polygon[T] {
 	center := p.Center()
-	return Polygon[T]{transform(p.Vertices, func(point Point[T]) Point[T] {
+	return Polygon[T]{Transform(p.Vertices, func(point Point[T]) Point[T] {
 		return center.Add(point.Subtract(center).Multiply(scale))
 	})}
 }
 
 // ScaleXY creates a new Polygon scaled about its centroid by the factors.
 func (p Polygon[T]) ScaleXY(scaleX, scaleY float64) Polygon[T] {
 	center := p.Center()
-	return Polygon[T]{transform(p.Vertices, func(point Point[T]) Point[T] {
+	return Polygon[T]{Transform(p.Vertices, func(point Point[T]) Point[T] {
 		return center.Add(point.Subtract(center).MultiplyXY(scaleX, scaleY))
 	})}
 }
-
-func transform[S ~[]E, E any, T any](input S, fn func(E) T) []T {
-	output := make([]T, len(input))
-	for i, v := range input {
-		output[i] = fn(v)
-	}
-
-	return output
-}

polygon_regular.go

@@ -4,7 +4,7 @@ import (
 	"math"
 )
 
-// RegularPolygon is a polygon with equally spaced transform around a center.
+// RegularPolygon is a polygon with equally spaced Transform around a center.
 type RegularPolygon[T Number] struct {
 	Center Point[T]
 	Size   Size[T]
@@ -16,17 +16,17 @@ func RP[T Number](center Point[T], size Size[T], n int) RegularPolygon[T] {
 	return RegularPolygon[T]{center, size, n}
 }
 
-// Triangle creates a RegularPolygon with 3 transform.
+// Triangle creates a RegularPolygon with 3 Transform.
 func Triangle[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
 	return RegularPolygon[T]{center, size, 3}
 }
 
-// Square creates a RegularPolygon with 4 transform.
+// Square creates a RegularPolygon with 4 Transform.
 func Square[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
 	return RegularPolygon[T]{center, size, 4}
 }
 
-// Hexagon creates a RegularPolygon with 6 transform.
+// Hexagon creates a RegularPolygon with 6 Transform.
 func Hexagon[T Number](center Point[T], size Size[T]) RegularPolygon[T] {
 	return RegularPolygon[T]{center, size, 6}
 }
@@ -51,7 +51,7 @@ func (rp RegularPolygon[T]) ScaleXY(scaleX, scaleY float64) RegularPolygon[T] {
 	return RegularPolygon[T]{rp.Center, rp.Size.ScaleXY(scaleX, scaleY), rp.N}
 }
 
-// Vertices returns the polygon transform in order starting from angle 0, counter-clockwise.
+// Vertices returns the polygon Transform in order starting from angle 0, counter-clockwise.
 func (rp RegularPolygon[T]) Vertices() []Point[T] {
 	initAngle := 0.0
 	angleStep := 2 * math.Pi / float64(rp.N)

rectangle.go

@@ -23,6 +23,11 @@ func RectangleFromMinMax[T Number](min, max Point[T]) Rectangle[T] {
 	return RectangleFromMin(min, S(max.Subtract(min).XY()))
 }
 
+// RectangleFromSize creates a Rectangle from zero point and size.
+func RectangleFromSize[T Number](size Size[T]) Rectangle[T] {
+	return Rectangle[T]{P[T](0, 0), size}
+}
+
 // Translate creates a new Rectangle translated by the given vector.
 func (r Rectangle[T]) Translate(vector Vector[T]) Rectangle[T] {
 	return Rectangle[T]{r.Center.Add(vector), r.Size}

types/floats/types.go

@@ -10,3 +10,37 @@ type Line = geom.Line[float64]
 type Rectangle = geom.Rectangle[float64]
 type Polygon = geom.Polygon[float64]
 type RegularPolygon = geom.RegularPolygon[float64]
+
+func ToPoint[T geom.Number](point geom.Point[T]) Point {
+	return Point{float64(point.X()), float64(point.Y())}
+}
+
+func ToVector[T geom.Number](vector geom.Vector[T]) Vector {
+	return Vector{float64(vector.X()), float64(vector.Y())}
+}
+
+func ToSize[T geom.Number](size geom.Size[T]) Size {
+	return Size{float64(size.Width()), float64(size.Height())}
+}
+
+func ToCircle[T geom.Number](circle geom.Circle[T]) Circle {
+	return Circle{ToPoint(circle.Center), float64(circle.Radius)}
+}
+
+func ToLine[T geom.Number](line geom.Line[T]) Line {
+	return Line{ToPoint(line.Start), ToPoint(line.End)}
+}
+
+func ToRectangle[T geom.Number](rectangle geom.Rectangle[T]) Rectangle {
+	return Rectangle{ToPoint(rectangle.Center), ToSize(rectangle.Size)}
+}
+
+func ToPolygon[T geom.Number](polygon geom.Polygon[T]) Polygon {
+	return Polygon{geom.Transform(polygon.Vertices, func(point geom.Point[T]) Point {
+		return ToPoint(point)
+	})}
+}
+
+func ToRegularPolygon[T geom.Number](polygon geom.RegularPolygon[T]) RegularPolygon {
+	return RegularPolygon{ToPoint(polygon.Center), ToSize(polygon.Size), polygon.N}
+}

types/ints/types.go

@@ -10,3 +10,37 @@ type Line = geom.Line[int]
 type Rectangle = geom.Rectangle[int]
 type Polygon = geom.Polygon[int]
 type RegularPolygon = geom.RegularPolygon[int]
+
+func ToPoint[T geom.Number](point geom.Point[T]) Point {
+	return Point{geom.Cast[int](float64(point.X)), geom.Cast[int](float64(point.Y))}
+}
+
+func ToVector[T geom.Number](vector geom.Vector[T]) Vector {
+	return Vector{geom.Cast[int](float64(vector.X)), geom.Cast[int](float64(vector.Y))}
+}
+
+func ToSize[T geom.Number](size geom.Size[T]) Size {
+	return Size{geom.Cast[int](float64(size.Width)), geom.Cast[int](float64(size.Height))}
+}
+
+func ToCircle[T geom.Number](circle geom.Circle[T]) Circle {
+	return Circle{ToPoint(circle.Center), geom.Cast[int](float64(circle.Radius))}
+}
+
+func ToLine[T geom.Number](line geom.Line[T]) Line {
+	return Line{ToPoint(line.Start), ToPoint(line.End)}
+}
+
+func ToRectangle[T geom.Number](rectangle geom.Rectangle[T]) Rectangle {
+	return Rectangle{ToPoint(rectangle.Center), ToSize(rectangle.Size)}
+}
+
+func ToPolygon[T geom.Number](polygon geom.Polygon[T]) Polygon {
+	return Polygon{geom.Transform(polygon.Vertices, func(point geom.Point[T]) Point {
+		return ToPoint(point)
+	})}
+}
+
+func ToRegularPolygon[T geom.Number](polygon geom.RegularPolygon[T]) RegularPolygon {
+	return RegularPolygon{ToPoint(polygon.Center), ToSize(polygon.Size), polygon.N}
+}