Standardize Zero method naming to IsZero across all types, add Empty, Bounds, and Equal

Author: tomas-novotny

README.md

@@ -65,7 +65,7 @@ func (p Point[T]) AngleTo(point Point[T]) float64
 
 // Utilities
 func (p Point[T]) Equal(point Point[T]) bool
-func (p Point[T]) Zero() bool
+func (p Point[T]) IsZero() bool
 ```
 
 ### Vector
@@ -105,7 +105,7 @@ func (v Vector[T]) Abs() Vector[T]
 
 // Utilities
 func (v Vector[T]) Equal(vector Vector[T]) bool
-func (v Vector[T]) Zero() bool
+func (v Vector[T]) IsZero() bool
 func (v Vector[T]) Unit() bool
 func (v Vector[T]) Less(value T) bool
 func (v Vector[T]) String() string
@@ -134,7 +134,7 @@ func (s Size[T]) ShrinkXY(amountX, amountY T) Size[T]
 
 // Utilities
 func (s Size[T]) Equal(other Size[T]) bool
-func (s Size[T]) Zero() bool
+func (s Size[T]) IsZero() bool
 func (s Size[T]) String() string
 ```
 
@@ -150,7 +150,6 @@ type Circle[T Number] struct {
 func (c Circle[T]) Area() float64
 func (c Circle[T]) Circumference() float64
 func (c Circle[T]) Diameter() T
-func (c Circle[T]) Bounds() Rectangle[T]
 
 // Transformations
 func (c Circle[T]) Translate(vector Vector[T]) Circle[T]
@@ -167,6 +166,8 @@ func (c Circle[T]) Contains(point Point[T]) bool
 
 // Utilities
 func (c Circle[T]) Equal(circle Circle[T]) bool
+func (c Circle[T]) IsZero() bool
+func (c Circle[T]) Bounds() Rectangle[T]
 func (c Circle[T]) String() string
 ```
 
@@ -211,6 +212,8 @@ func (r Rectangle[T]) Contains(point Point[T]) bool
 
 // Utilities
 func (r Rectangle[T]) Equal(other Rectangle[T]) bool
+func (r Rectangle[T]) IsZero() bool
+func (r Rectangle[T]) Bounds() Rectangle[T]
 func (r Rectangle[T]) ToPolygon() Polygon[T]
 func (r Rectangle[T]) String() string
 ```
@@ -235,6 +238,8 @@ func (l Line[T]) Length() float64
 
 // Utilities
 func (l Line[T]) Equal(other Line[T]) bool
+func (l Line[T]) IsZero() bool
+func (l Line[T]) Bounds() Rectangle[T]
 func (l Line[T]) String() string
 ```
 
@@ -253,6 +258,9 @@ func (p Polygon[T]) Translate(vector Vector[T]) Polygon[T]
 func (p Polygon[T]) MoveTo(center Point[T]) Polygon[T]
 func (p Polygon[T]) Scale(factor float64) Polygon[T]
 func (p Polygon[T]) ScaleXY(factorX, factorY float64) Polygon[T]
+
+// Utilities
+func (p Polygon[T]) Empty() bool
 ```
 
 ### Regular Polygon
@@ -274,6 +282,10 @@ func (rp RegularPolygon[T]) Scale(factor float64) RegularPolygon[T]
 func (rp RegularPolygon[T]) ScaleXY(factorX, factorY float64) RegularPolygon[T]
 
 // Utilities
+func (rp RegularPolygon[T]) Equal(polygon RegularPolygon[T]) bool
+func (rp RegularPolygon[T]) IsZero() bool
+func (rp RegularPolygon[T]) Empty() bool
+func (rp RegularPolygon[T]) Bounds() Rectangle[T]
 func (rp RegularPolygon[T]) ToPolygon() Polygon[T]
 ```
 

circle.go

@@ -71,6 +71,11 @@ func (c Circle[T]) Equal(circle Circle[T]) bool {
 	return c.Center.Equal(circle.Center) && Equal(c.Radius, circle.Radius)
 }
 
+// IsZero checks if center point and radius are zero.
+func (c Circle[T]) IsZero() bool {
+	return c.Center.IsZero() && Equal(c.Radius, 0)
+}
+
 // Contains checks if the given point lies inside the circle.
 func (c Circle[T]) Contains(point Point[T]) bool {
 	return c.Center.Subtract(point).Less(c.Radius)

line.go

@@ -1,6 +1,8 @@
 package geom
 
-import "fmt"
+import (
+	"fmt"
+)
 
 // Line is a 2D line.
 type Line[T Number] struct {
@@ -43,11 +45,21 @@ func (l Line[T]) Length() float64 {
 	return l.Direction().Length()
 }
 
+// Bounds returns the axis-aligned bounding rectangle.
+func (l Line[T]) Bounds() Rectangle[T] {
+	return Rectangle[T]{Center: l.Midpoint(), Size: S(l.Direction().Abs().XY())}
+}
+
 // Equal checks if the start and end points of the lines are equal.
 func (l Line[T]) Equal(other Line[T]) bool {
 	return l.Start.Equal(other.Start) && l.End.Equal(other.End)
 }
 
+// IsZero checks if start and end points are zero.
+func (l Line[T]) IsZero() bool {
+	return l.Start.IsZero() && l.End.IsZero()
+}
+
 // String returns a string representation of the Line.
 func (l Line[T]) String() string {
 	return fmt.Sprintf("L(%s;%s)", l.Start.String(), l.End.String())

point.go

@@ -80,8 +80,8 @@ func (p Point[T]) Equal(point Point[T]) bool {
 	return Equal(p.X, point.X) && Equal(p.Y, point.Y)
 }
 
-// Zero checks if X and Y values are 0.
-func (p Point[T]) Zero() bool {
+// IsZero checks if X and Y values are 0.
+func (p Point[T]) IsZero() bool {
 	return p.Equal(Point[T]{})
 }
 

point_test.go

@@ -75,15 +75,15 @@ func TestPoint_Equal(t *testing.T) {
 	assert.True(t, P(0.4, -0.25).Equal(P(0.4, -0.250001)))
 }
 
-func TestPoint_Zero(t *testing.T) {
-	assert.False(t, P(1, 2).Zero())
-	assert.True(t, P(0, -0).Zero())
-	assert.True(t, ZeroPoint[int]().Zero())
-
-	assert.False(t, P(0.4, -0.25).Zero())
-	assert.True(t, P(0.0, 0.0).Zero())
-	assert.True(t, P(0.0, 0.000001).Zero())
-	assert.True(t, ZeroPoint[float64]().Zero())
+func TestPoint_IsZero(t *testing.T) {
+	assert.False(t, P(1, 2).IsZero())
+	assert.True(t, P(0, -0).IsZero())
+	assert.True(t, ZeroPoint[int]().IsZero())
+
+	assert.False(t, P(0.4, -0.25).IsZero())
+	assert.True(t, P(0.0, 0.0).IsZero())
+	assert.True(t, P(0.0, 0.000001).IsZero())
+	assert.True(t, ZeroPoint[float64]().IsZero())
 }
 
 func TestPoint_XY(t *testing.T) {

polygon.go

@@ -43,3 +43,8 @@ func (p Polygon[T]) ScaleXY(factorX, factorY float64) Polygon[T] {
 		return center.Add(point.Subtract(center).MultiplyXY(factorX, factorY))
 	})}
 }
+
+// Empty checks if number of vertices is zero.
+func (p Polygon[T]) Empty() bool {
+	return len(p.Vertices) == 0
+}

rectangle.go

@@ -23,11 +23,6 @@ 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}
@@ -147,11 +142,21 @@ func (r Rectangle[T]) AspectRatio() float64 {
 	return r.Size.AspectRatio()
 }
 
+// Bounds returns the axis-aligned bounding rectangle.
+func (r Rectangle[T]) Bounds() Rectangle[T] {
+	return r
+}
+
 // Equal checks for equal center and size values using tolerant numeric comparison.
 func (r Rectangle[T]) Equal(other Rectangle[T]) bool {
 	return r.Center.Equal(other.Center) && r.Size.Equal(other.Size)
 }
 
+// IsZero checks if center point and size are zero.
+func (r Rectangle[T]) IsZero() bool {
+	return r.Center.IsZero() && r.Size.IsZero()
+}
+
 // Contains reports whether the given point lies within or on the rectangle bounds.
 func (r Rectangle[T]) Contains(point Point[T]) bool {
 	minPoint, maxPoint := r.Min(), r.Max()

regular_polygon.go

@@ -64,7 +64,27 @@ func (rp RegularPolygon[T]) Vertices() []Point[T] {
 	return vertices
 }
 
+// Bounds returns the axis-aligned bounding rectangle.
+func (rp RegularPolygon[T]) Bounds() Rectangle[T] {
+	return Rectangle[T]{rp.Center, rp.Size}
+}
+
 // ToPolygon converts the regular polygon into a generic Polygon with computed vertices.
 func (rp RegularPolygon[T]) ToPolygon() Polygon[T] {
 	return Polygon[T]{rp.Vertices()}
 }
+
+// Equal checks if center point, size and number of vertices are equal.
+func (rp RegularPolygon[T]) Equal(polygon RegularPolygon[T]) bool {
+	return rp.Center.Equal(polygon.Center) && rp.Size.Equal(polygon.Size) && rp.N == polygon.N
+}
+
+// IsZero checks if center point, size and number of vertices are zero.
+func (rp RegularPolygon[T]) IsZero() bool {
+	return rp.Center.IsZero() && rp.Size.IsZero() && rp.N == 0
+}
+
+// Empty checks if number of vertices is zero.
+func (rp RegularPolygon[T]) Empty() bool {
+	return rp.N == 0
+}

size.go

@@ -1,6 +1,8 @@
 package geom
 
-import "fmt"
+import (
+	"fmt"
+)
 
 // Size is a 2D size.
 type Size[T Number] struct {
@@ -63,8 +65,8 @@ func (s Size[T]) Equal(other Size[T]) bool {
 	return Equal(s.Width, other.Width) && Equal(s.Height, other.Height)
 }
 
-// Zero checks if width and height values are 0.
-func (s Size[T]) Zero() bool {
+// IsZero checks if width and height values are 0.
+func (s Size[T]) IsZero() bool {
 	return s.Equal(Size[T]{})
 }
 

size_test.go

@@ -56,10 +56,10 @@ func TestSize_Equal(t *testing.T) {
 	assert.True(t, S(0.4, -0.25).Equal(S(0.4, -0.250001)))
 }
 
-func TestSize_Zero(t *testing.T) {
-	assert.False(t, S(1, 2).Zero())
-	assert.True(t, S(0, 0).Zero())
-	assert.True(t, S[float64](0.0, 0.000001).Zero())
+func TestSize_IsZero(t *testing.T) {
+	assert.False(t, S(1, 2).IsZero())
+	assert.True(t, S(0, 0).IsZero())
+	assert.True(t, S[float64](0.0, 0.000001).IsZero())
 }
 
 func TestSize_XY(t *testing.T) {