Standardize naming

tomas-novotny · tomas-novotny · commit 784ac8cab898 · 2025-08-25T15:08:38.000+02:00
diff --git a/README.md b/README.md
@@ -121,10 +121,11 @@ func (s Size[T]) AspectRatio() float64
 
 
 // Dimension operations
-func (s Size[T]) Scaled(factor float64) Size[T]
-func (s Size[T]) ScaledXY(scaleX, scaleY float64) Size[T]
-func (s Size[T]) Expand(deltaWidth, deltaHeight T) Size[T]
-func (s Size[T]) Shrunk(deltaWidth, deltaHeight T) Size[T]
+func (s Size[T]) Scale(factor float64) Size[T]
+func (s Size[T]) ScaleXY(factorX, factorY float64) Size[T]
+func (s Size[T]) Grow(amount T) Size[T]
+func (s Size[T]) GrowXY(amountX, amountY T) Size[T]
+func (s Size[T]) Shrink(amountX, amountY T) Size[T]
 
 // Utilities
 func (s Size[T]) Equal(other Size[T]) bool
diff --git a/circle.go b/circle.go
@@ -27,22 +27,22 @@ func (c Circle[T]) MoveTo(point Point[T]) Circle[T] {
 }
 
 // Multiple creates a new Circle with radius scaled by the given factor.
-func (c Circle[T]) Scale(scale float64) Circle[T] {
-	return Circle[T]{c.Center, Multiple(c.Radius, scale)}
+func (c Circle[T]) Scale(factor float64) Circle[T] {
+	return Circle[T]{c.Center, Multiple(c.Radius, factor)}
 }
 
 // Resize creates a new Circle with the given radius.
 func (c Circle[T]) Resize(radius T) Circle[T] {
 	return Circle[T]{c.Center, radius}
 }
 
-// Expand creates a new Circle with radius increased by amount.
-func (c Circle[T]) Expand(amount T) Circle[T] {
+// Grow creates a new Circle with radius increased by amount.
+func (c Circle[T]) Grow(amount T) Circle[T] {
 	return Circle[T]{c.Center, c.Radius + amount}
 }
 
-// Shrunk creates a new Circle with radius decreased by amount.
-func (c Circle[T]) Shrunk(amount T) Circle[T] {
+// Shrink creates a new Circle with radius decreased by amount.
+func (c Circle[T]) Shrink(amount T) Circle[T] {
 	return Circle[T]{c.Center, c.Radius - amount}
 }
 
diff --git a/circle_test.go b/circle_test.go
@@ -34,13 +34,13 @@ func TestCircle_Resize(t *testing.T) {
 }
 
 func TestCircle_Expand(t *testing.T) {
-	testCircle(t, C(P(1, 2), 10).Expand(8), 1, 2, 18)
-	testCircle(t, C(P(0.4, -0.25), 1.2).Expand(3.1), 0.4, -0.25, 4.3)
+	testCircle(t, C(P(1, 2), 10).Grow(8), 1, 2, 18)
+	testCircle(t, C(P(0.4, -0.25), 1.2).Grow(3.1), 0.4, -0.25, 4.3)
 }
 
 func TestCircle_Shrunk(t *testing.T) {
-	testCircle(t, C(P(1, 2), 10).Shrunk(8), 1, 2, 2)
-	testCircle(t, C(P(0.4, -0.25), 1.2).Shrunk(0.3), 0.4, -0.25, 0.9)
+	testCircle(t, C(P(1, 2), 10).Shrink(8), 1, 2, 2)
+	testCircle(t, C(P(0.4, -0.25), 1.2).Shrink(0.3), 0.4, -0.25, 0.9)
 }
 
 func TestCircle_Area(t *testing.T) {
@@ -107,8 +107,8 @@ func TestCircle_Immutable(t *testing.T) {
 	c1.MoveTo(P(4, 3))
 	c1.Scale(2)
 	c1.Resize(15)
-	c1.Expand(1)
-	c1.Shrunk(2)
+	c1.Grow(1)
+	c1.Shrink(2)
 
 	testCircle(t, c1, 1, 2, 10)
 }
diff --git a/math.go b/math.go
@@ -25,8 +25,8 @@ func ToDegrees(radians float64) float64 {
 }
 
 // Multiple multiple number by scale factor
-func Multiple[T Number](a T, scale float64) T {
-	return Cast[T](float64(a) * scale)
+func Multiple[T Number](a T, factor float64) T {
+	return Cast[T](float64(a) * factor)
 }
 
 // Divide divide number by scale factor
diff --git a/point.go b/point.go
@@ -31,23 +31,23 @@ func (p Point[T]) Subtract(point Point[T]) Vector[T] {
 }
 
 // Multiply creates a new Point by multiplying the given value to the current point.
-func (p Point[T]) Multiply(scale float64) Point[T] {
-	return Point[T]{Multiple(p.X, scale), Multiple(p.Y, scale)}
+func (p Point[T]) Multiply(factor float64) Point[T] {
+	return Point[T]{Multiple(p.X, factor), Multiple(p.Y, factor)}
 }
 
 // MultiplyXY creates a new Point by multiplying the given values to the current point.
-func (p Point[T]) MultiplyXY(scaleX, scaleY float64) Point[T] {
-	return Point[T]{Multiple(p.X, scaleX), Multiple(p.Y, scaleY)}
+func (p Point[T]) MultiplyXY(factorX, factorY float64) Point[T] {
+	return Point[T]{Multiple(p.X, factorX), Multiple(p.Y, factorY)}
 }
 
 // Divide creates a new Point by dividing the given value to the current point.
-func (p Point[T]) Divide(scale float64) Point[T] {
-	return Point[T]{Divide(p.X, scale), Divide(p.Y, scale)}
+func (p Point[T]) Divide(factor float64) Point[T] {
+	return Point[T]{Divide(p.X, factor), Divide(p.Y, factor)}
 }
 
 // DivideXY creates a new Point by dividing the given values to the current point.
-func (p Point[T]) DivideXY(scaleX, scaleY float64) Point[T] {
-	return Point[T]{Divide(p.X, scaleX), Divide(p.Y, scaleY)}
+func (p Point[T]) DivideXY(factorX, factorY float64) Point[T] {
+	return Point[T]{Divide(p.X, factorX), Divide(p.Y, factorY)}
 }
 
 // DistanceTo return euclidean distance from the current point to the given point.
diff --git a/polygon.go b/polygon.go
@@ -29,17 +29,17 @@ 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] {
+func (p Polygon[T]) Scale(factor float64) Polygon[T] {
 	center := p.Center()
 	return Polygon[T]{Transform(p.Vertices, func(point Point[T]) Point[T] {
-		return center.Add(point.Subtract(center).Multiply(scale))
+		return center.Add(point.Subtract(center).Multiply(factor))
 	})}
 }
 
 // ScaleXY creates a new Polygon scaled about its centroid by the factors.
-func (p Polygon[T]) ScaleXY(scaleX, scaleY float64) Polygon[T] {
+func (p Polygon[T]) ScaleXY(factorX, factorY float64) Polygon[T] {
 	center := p.Center()
 	return Polygon[T]{Transform(p.Vertices, func(point Point[T]) Point[T] {
-		return center.Add(point.Subtract(center).MultiplyXY(scaleX, scaleY))
+		return center.Add(point.Subtract(center).MultiplyXY(factorX, factorY))
 	})}
 }
diff --git a/rectangle.go b/rectangle.go
@@ -39,38 +39,38 @@ func (r Rectangle[T]) MoveTo(point Point[T]) Rectangle[T] {
 }
 
 // Multiple creates a new Rectangle with size uniformly scaled by the factor.
-func (r Rectangle[T]) Scale(scale float64) Rectangle[T] {
-	return Rectangle[T]{r.Center, r.Size.Scale(scale)}
+func (r Rectangle[T]) Scale(factor float64) Rectangle[T] {
+	return Rectangle[T]{r.Center, r.Size.Scale(factor)}
 }
 
 // ScaleXY creates a new Rectangle with size scaled by the given factors.
-func (r Rectangle[T]) ScaleXY(scaleX, scaleY float64) Rectangle[T] {
-	return Rectangle[T]{r.Center, r.Size.ScaleXY(scaleX, scaleY)}
+func (r Rectangle[T]) ScaleXY(factorX, factorY float64) Rectangle[T] {
+	return Rectangle[T]{r.Center, r.Size.ScaleXY(factorX, factorY)}
 }
 
 // Resize creates a new Rectangle with the given size.
 func (r Rectangle[T]) Resize(size Size[T]) Rectangle[T] {
 	return Rectangle[T]{r.Center, size}
 }
 
-// Shrunk creates a new Rectangle with size expanded by the same delta in both dimensions.
-func (r Rectangle[T]) Expand(delta T) Rectangle[T] {
-	return Rectangle[T]{r.Center, r.Size.Expand(delta)}
+// Grow creates a new Rectangle with size expanded by the same amount in both dimensions.
+func (r Rectangle[T]) Grow(amount T) Rectangle[T] {
+	return Rectangle[T]{r.Center, r.Size.Grow(amount)}
 }
 
-// Shrunk creates a new Rectangle with size expanded by the given deltas along X and Y.
-func (r Rectangle[T]) ExpandXY(deltaWidth, deltaHeight T) Rectangle[T] {
-	return Rectangle[T]{r.Center, r.Size.ExpandXY(deltaWidth, deltaHeight)}
+// GrowXY creates a new Rectangle with size expanded by the given amounts along X and Y.
+func (r Rectangle[T]) GrowXY(amountX, amountY T) Rectangle[T] {
+	return Rectangle[T]{r.Center, r.Size.GrowXY(amountX, amountY)}
 }
 
-// Shrunk creates a new Rectangle with size reduced by the same delta in both dimensions.
-func (r Rectangle[T]) Shrunk(delta T) Rectangle[T] {
-	return Rectangle[T]{r.Center, r.Size.Shrunk(delta)}
+// Shrink creates a new Rectangle with size reduced by the same amount in both dimensions.
+func (r Rectangle[T]) Shrink(amount T) Rectangle[T] {
+	return Rectangle[T]{r.Center, r.Size.Shrink(amount)}
 }
 
-// Shrunk creates a new Rectangle with size reduced by the given deltas along X and Y.
-func (r Rectangle[T]) ShrunkXY(deltaWidth, deltaHeight T) Rectangle[T] {
-	return Rectangle[T]{r.Center, r.Size.ShrunkXY(deltaWidth, deltaHeight)}
+// Shrink creates a new Rectangle with size reduced by the given amounts along X and Y.
+func (r Rectangle[T]) ShrinkXY(amountX, amountY T) Rectangle[T] {
+	return Rectangle[T]{r.Center, r.Size.ShrinkXY(amountX, amountY)}
 }
 
 // Width returns the rectangle width.
diff --git a/rectangle_test.go b/rectangle_test.go
@@ -43,17 +43,17 @@ func TestRectangle_Resize(t *testing.T) {
 }
 
 func TestRectangle_Expand(t *testing.T) {
-	testRect(t, R(P(1, 2), S(3, 4)).Expand(2), 1, 2, 5, 6)
-	testRect(t, R(P(1, 2), S(3, 4)).ExpandXY(2, 3), 1, 2, 5, 7)
-	testRect(t, R(P(0.4, -0.25), S(1.2, 3.4)).Expand(0.1), 0.4, -0.25, 1.3, 3.5)
-	testRect(t, R(P(0.4, -0.25), S(1.2, 3.4)).ExpandXY(0.1, 0.2), 0.4, -0.25, 1.3, 3.6)
+	testRect(t, R(P(1, 2), S(3, 4)).Grow(2), 1, 2, 5, 6)
+	testRect(t, R(P(1, 2), S(3, 4)).GrowXY(2, 3), 1, 2, 5, 7)
+	testRect(t, R(P(0.4, -0.25), S(1.2, 3.4)).Grow(0.1), 0.4, -0.25, 1.3, 3.5)
+	testRect(t, R(P(0.4, -0.25), S(1.2, 3.4)).GrowXY(0.1, 0.2), 0.4, -0.25, 1.3, 3.6)
 }
 
 func TestRectangle_Shrunk(t *testing.T) {
-	testRect(t, R(P(1, 2), S(3, 4)).Shrunk(1), 1, 2, 2, 3)
-	testRect(t, R(P(1, 2), S(3, 4)).ShrunkXY(1, 2), 1, 2, 2, 2)
-	testRect(t, R(P(0.4, -0.25), S(1.2, 3.4)).Shrunk(0.1), 0.4, -0.25, 1.1, 3.3)
-	testRect(t, R(P(0.4, -0.25), S(1.2, 3.4)).ShrunkXY(0.1, 0.2), 0.4, -0.25, 1.1, 3.2)
+	testRect(t, R(P(1, 2), S(3, 4)).Shrink(1), 1, 2, 2, 3)
+	testRect(t, R(P(1, 2), S(3, 4)).ShrinkXY(1, 2), 1, 2, 2, 2)
+	testRect(t, R(P(0.4, -0.25), S(1.2, 3.4)).Shrink(0.1), 0.4, -0.25, 1.1, 3.3)
+	testRect(t, R(P(0.4, -0.25), S(1.2, 3.4)).ShrinkXY(0.1, 0.2), 0.4, -0.25, 1.1, 3.2)
 }
 
 func TestRectangle_Width(t *testing.T) {
@@ -146,10 +146,10 @@ func TestRectangle_Immutable(t *testing.T) {
 	r.Scale(2)
 	r.ScaleXY(3, 4)
 	r.Resize(S(5, 6))
-	r.Expand(1)
-	r.ExpandXY(1, 2)
-	r.Shrunk(2)
-	r.ShrunkXY(2, 3)
+	r.Grow(1)
+	r.GrowXY(1, 2)
+	r.Shrink(2)
+	r.ShrinkXY(2, 3)
 
 	testRect(t, r, 1, 2, 3, 4)
 }
diff --git a/regular_polygon.go b/regular_polygon.go
@@ -42,13 +42,13 @@ func (rp RegularPolygon[T]) MoveTo(point Point[T]) RegularPolygon[T] {
 }
 
 // Multiple creates a new RegularPolygon with size scaled by the given factor.
-func (rp RegularPolygon[T]) Scale(scale float64) RegularPolygon[T] {
-	return RegularPolygon[T]{rp.Center, rp.Size.Scale(scale), rp.N}
+func (rp RegularPolygon[T]) Scale(factor float64) RegularPolygon[T] {
+	return RegularPolygon[T]{rp.Center, rp.Size.Scale(factor), rp.N}
 }
 
 // Multiple creates a new RegularPolygon with size scaled by the given factors.
-func (rp RegularPolygon[T]) ScaleXY(scaleX, scaleY float64) RegularPolygon[T] {
-	return RegularPolygon[T]{rp.Center, rp.Size.ScaleXY(scaleX, scaleY), rp.N}
+func (rp RegularPolygon[T]) ScaleXY(factorX, factorY float64) RegularPolygon[T] {
+	return RegularPolygon[T]{rp.Center, rp.Size.ScaleXY(factorX, factorY), rp.N}
 }
 
 // Vertices returns the polygon vertices in order starting from angle 0, counter-clockwise.
diff --git a/size.go b/size.go
@@ -14,33 +14,33 @@ func S[T Number](width, height T) Size[T] {
 }
 
 // Scale creates a new Size scaled by the given factor in both dimensions.
-func (s Size[T]) Scale(scale float64) Size[T] {
-	return Size[T]{Multiple(s.Width, scale), Multiple(s.Height, scale)}
+func (s Size[T]) Scale(factor float64) Size[T] {
+	return Size[T]{Multiple(s.Width, factor), Multiple(s.Height, factor)}
 }
 
 // ScaleXY creates a new Size scaled by the given factors along X and Y.
-func (s Size[T]) ScaleXY(scaleX, scaleY float64) Size[T] {
-	return Size[T]{Multiple(s.Width, scaleX), Multiple(s.Height, scaleY)}
+func (s Size[T]) ScaleXY(factorX, factorY float64) Size[T] {
+	return Size[T]{Multiple(s.Width, factorX), Multiple(s.Height, factorY)}
 }
 
-// Expand creates a new Size expanded by the same delta in both dimensions.
-func (s Size[T]) Expand(delta T) Size[T] {
-	return Size[T]{s.Width + delta, s.Height + delta}
+// Grow creates a new Size expanded by the same delta in both dimensions.
+func (s Size[T]) Grow(amount T) Size[T] {
+	return Size[T]{s.Width + amount, s.Height + amount}
 }
 
-// ExpandXY creates a new Size expanded by the given deltas along X and Y.
-func (s Size[T]) ExpandXY(deltaWidth, deltaHeight T) Size[T] {
-	return Size[T]{s.Width + deltaWidth, s.Height + deltaHeight}
+// GrowXY creates a new Size expanded by the given amounts along X and Y.
+func (s Size[T]) GrowXY(amountX, amountY T) Size[T] {
+	return Size[T]{s.Width + amountX, s.Height + amountY}
 }
 
-// Shrunk creates a new Size reduced by the same delta in both dimensions.
-func (s Size[T]) Shrunk(delta T) Size[T] {
-	return Size[T]{s.Width - delta, s.Height - delta}
+// Shrink creates a new Size reduced by the same delta in both dimensions.
+func (s Size[T]) Shrink(amount T) Size[T] {
+	return Size[T]{s.Width - amount, s.Height - amount}
 }
 
-// ShrunkXY creates a new Size reduced by the given deltas along X and Y.
-func (s Size[T]) ShrunkXY(deltaWidth, deltaHeight T) Size[T] {
-	return Size[T]{s.Width - deltaWidth, s.Height - deltaHeight}
+// ShrinkXY creates a new Size reduced by the given amounts along X and Y.
+func (s Size[T]) ShrinkXY(amountX, amountY T) Size[T] {
+	return Size[T]{s.Width - amountX, s.Height - amountY}
 }
 
 // Area returns the size's area (width * height).
diff --git a/size_test.go b/size_test.go
@@ -20,17 +20,17 @@ func TestSize_Scale(t *testing.T) {
 }
 
 func TestSize_Expand(t *testing.T) {
-	testSize(t, S(2, 3).Expand(2), 4, 5)
-	testSize(t, S(2, 3).ExpandXY(2, 3), 4, 6)
-	testSize(t, S(0.4, 0.25).Expand(0.1), 0.5, 0.35)
-	testSize(t, S(0.4, 0.25).ExpandXY(0.1, 0.2), 0.5, 0.45)
+	testSize(t, S(2, 3).Grow(2), 4, 5)
+	testSize(t, S(2, 3).GrowXY(2, 3), 4, 6)
+	testSize(t, S(0.4, 0.25).Grow(0.1), 0.5, 0.35)
+	testSize(t, S(0.4, 0.25).GrowXY(0.1, 0.2), 0.5, 0.45)
 }
 
 func TestSize_Shrunk(t *testing.T) {
-	testSize(t, S(2, 3).Shrunk(1), 1, 2)
-	testSize(t, S(2, 3).ShrunkXY(1, 2), 1, 1)
-	testSize(t, S(0.4, 0.25).Shrunk(0.1), 0.3, 0.15)
-	testSize(t, S(0.4, 0.25).ShrunkXY(0.1, 0.2), 0.3, 0.05)
+	testSize(t, S(2, 3).Shrink(1), 1, 2)
+	testSize(t, S(2, 3).ShrinkXY(1, 2), 1, 1)
+	testSize(t, S(0.4, 0.25).Shrink(0.1), 0.3, 0.15)
+	testSize(t, S(0.4, 0.25).ShrinkXY(0.1, 0.2), 0.3, 0.05)
 }
 
 func TestSize_Area(t *testing.T) {
@@ -97,10 +97,10 @@ func TestSize_Immutable(t *testing.T) {
 
 	s.Scale(2)
 	s.ScaleXY(2, 3)
-	s.Expand(1)
-	s.ExpandXY(1, 2)
-	s.Shrunk(1)
-	s.ShrunkXY(1, 2)
+	s.Grow(1)
+	s.GrowXY(1, 2)
+	s.Shrink(1)
+	s.ShrinkXY(1, 2)
 
 	testSize(t, s, 2, 3)
 }
diff --git a/vector.go b/vector.go
@@ -44,23 +44,23 @@ func (v Vector[T]) SubtractXY(deltaX, deltaY T) Vector[T] {
 }
 
 // Multiply creates a new Vector by multiplying the given value to the current vector.
-func (v Vector[T]) Multiply(scale float64) Vector[T] {
-	return Vector[T]{Multiple(v.X, scale), Multiple(v.Y, scale)}
+func (v Vector[T]) Multiply(factor float64) Vector[T] {
+	return Vector[T]{Multiple(v.X, factor), Multiple(v.Y, factor)}
 }
 
 // MultiplyXY creates a new Vector by multiplying the given values to the current vector.
-func (v Vector[T]) MultiplyXY(scaleX, scaleY float64) Vector[T] {
-	return Vector[T]{Multiple(v.X, scaleX), Multiple(v.Y, scaleY)}
+func (v Vector[T]) MultiplyXY(factorX, factorY float64) Vector[T] {
+	return Vector[T]{Multiple(v.X, factorX), Multiple(v.Y, factorY)}
 }
 
 // Divide creates a new Vector by dividing the given value to the current vector.
-func (v Vector[T]) Divide(scale float64) Vector[T] {
-	return Vector[T]{Divide(v.X, scale), Divide(v.Y, scale)}
+func (v Vector[T]) Divide(factor float64) Vector[T] {
+	return Vector[T]{Divide(v.X, factor), Divide(v.Y, factor)}
 }
 
 // DivideXY creates a new Vector by dividing the given values to the current vector.
-func (v Vector[T]) DivideXY(scaleX, scaleY float64) Vector[T] {
-	return Vector[T]{Divide(v.X, scaleX), Divide(v.Y, scaleY)}
+func (v Vector[T]) DivideXY(factorX, factorY float64) Vector[T] {
+	return Vector[T]{Divide(v.X, factorX), Divide(v.Y, factorY)}
 }
 
 // Negate creates a new Vector with opposite direction.

Original file line number	Diff line number	Diff line change
`@@ -27,22 +27,22 @@ func (c Circle[T]) MoveTo(point Point[T]) Circle[T] {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`// Multiple creates a new Circle with radius scaled by the given factor.`
`30`		`-func (c Circle[T]) Scale(scale float64) Circle[T] {`
`31`		`- return Circle[T]{c.Center, Multiple(c.Radius, scale)}`
	`30`	`+func (c Circle[T]) Scale(factor float64) Circle[T] {`
	`31`	`+ return Circle[T]{c.Center, Multiple(c.Radius, factor)}`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`// Resize creates a new Circle with the given radius.`
`35`	`35`	`func (c Circle[T]) Resize(radius T) Circle[T] {`
`36`	`36`	`return Circle[T]{c.Center, radius}`
`37`	`37`	`}`
`38`	`38`
`39`		`-// Expand creates a new Circle with radius increased by amount.`
`40`		`-func (c Circle[T]) Expand(amount T) Circle[T] {`
	`39`	`+// Grow creates a new Circle with radius increased by amount.`
	`40`	`+func (c Circle[T]) Grow(amount T) Circle[T] {`
`41`	`41`	`return Circle[T]{c.Center, c.Radius + amount}`
`42`	`42`	`}`
`43`	`43`
`44`		`-// Shrunk creates a new Circle with radius decreased by amount.`
`45`		`-func (c Circle[T]) Shrunk(amount T) Circle[T] {`
	`44`	`+// Shrink creates a new Circle with radius decreased by amount.`
	`45`	`+func (c Circle[T]) Shrink(amount T) Circle[T] {`
`46`	`46`	`return Circle[T]{c.Center, c.Radius - amount}`
`47`	`47`	`}`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -34,13 +34,13 @@ func TestCircle_Resize(t *testing.T) {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`func TestCircle_Expand(t *testing.T) {`
`37`		`- testCircle(t, C(P(1, 2), 10).Expand(8), 1, 2, 18)`
`38`		`- testCircle(t, C(P(0.4, -0.25), 1.2).Expand(3.1), 0.4, -0.25, 4.3)`
	`37`	`+ testCircle(t, C(P(1, 2), 10).Grow(8), 1, 2, 18)`
	`38`	`+ testCircle(t, C(P(0.4, -0.25), 1.2).Grow(3.1), 0.4, -0.25, 4.3)`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`func TestCircle_Shrunk(t *testing.T) {`
`42`		`- testCircle(t, C(P(1, 2), 10).Shrunk(8), 1, 2, 2)`
`43`		`- testCircle(t, C(P(0.4, -0.25), 1.2).Shrunk(0.3), 0.4, -0.25, 0.9)`
	`42`	`+ testCircle(t, C(P(1, 2), 10).Shrink(8), 1, 2, 2)`
	`43`	`+ testCircle(t, C(P(0.4, -0.25), 1.2).Shrink(0.3), 0.4, -0.25, 0.9)`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`func TestCircle_Area(t *testing.T) {`
`@@ -107,8 +107,8 @@ func TestCircle_Immutable(t *testing.T) {`
`107`	`107`	`c1.MoveTo(P(4, 3))`
`108`	`108`	`c1.Scale(2)`
`109`	`109`	`c1.Resize(15)`
`110`		`- c1.Expand(1)`
`111`		`- c1.Shrunk(2)`
	`110`	`+ c1.Grow(1)`
	`111`	`+ c1.Shrink(2)`
`112`	`112`
`113`	`113`	`testCircle(t, c1, 1, 2, 10)`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@ func ToDegrees(radians float64) float64 {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`// Multiple multiple number by scale factor`
`28`		`-func Multiple[T Number](a T, scale float64) T {`
`29`		`- return Cast[T](float64(a) * scale)`
	`28`	`+func Multiple[T Number](a T, factor float64) T {`
	`29`	`+ return Cast[T](float64(a) * factor)`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`// Divide divide number by scale factor`
Original file line number	Diff line number	Diff line change
`@@ -31,23 +31,23 @@ func (p Point[T]) Subtract(point Point[T]) Vector[T] {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`// Multiply creates a new Point by multiplying the given value to the current point.`
`34`		`-func (p Point[T]) Multiply(scale float64) Point[T] {`
`35`		`- return Point[T]{Multiple(p.X, scale), Multiple(p.Y, scale)}`
	`34`	`+func (p Point[T]) Multiply(factor float64) Point[T] {`
	`35`	`+ return Point[T]{Multiple(p.X, factor), Multiple(p.Y, factor)}`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`// MultiplyXY creates a new Point by multiplying the given values to the current point.`
`39`		`-func (p Point[T]) MultiplyXY(scaleX, scaleY float64) Point[T] {`
`40`		`- return Point[T]{Multiple(p.X, scaleX), Multiple(p.Y, scaleY)}`
	`39`	`+func (p Point[T]) MultiplyXY(factorX, factorY float64) Point[T] {`
	`40`	`+ return Point[T]{Multiple(p.X, factorX), Multiple(p.Y, factorY)}`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`// Divide creates a new Point by dividing the given value to the current point.`
`44`		`-func (p Point[T]) Divide(scale float64) Point[T] {`
`45`		`- return Point[T]{Divide(p.X, scale), Divide(p.Y, scale)}`
	`44`	`+func (p Point[T]) Divide(factor float64) Point[T] {`
	`45`	`+ return Point[T]{Divide(p.X, factor), Divide(p.Y, factor)}`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`// DivideXY creates a new Point by dividing the given values to the current point.`
`49`		`-func (p Point[T]) DivideXY(scaleX, scaleY float64) Point[T] {`
`50`		`- return Point[T]{Divide(p.X, scaleX), Divide(p.Y, scaleY)}`
	`49`	`+func (p Point[T]) DivideXY(factorX, factorY float64) Point[T] {`
	`50`	`+ return Point[T]{Divide(p.X, factorX), Divide(p.Y, factorY)}`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`// DistanceTo return euclidean distance from the current point to the given point.`
Original file line number	Diff line number	Diff line change
`@@ -42,13 +42,13 @@ func (rp RegularPolygon[T]) MoveTo(point Point[T]) RegularPolygon[T] {`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`// Multiple creates a new RegularPolygon with size scaled by the given factor.`
`45`		`-func (rp RegularPolygon[T]) Scale(scale float64) RegularPolygon[T] {`
`46`		`- return RegularPolygon[T]{rp.Center, rp.Size.Scale(scale), rp.N}`
	`45`	`+func (rp RegularPolygon[T]) Scale(factor float64) RegularPolygon[T] {`
	`46`	`+ return RegularPolygon[T]{rp.Center, rp.Size.Scale(factor), rp.N}`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`// Multiple creates a new RegularPolygon with size scaled by the given factors.`
`50`		`-func (rp RegularPolygon[T]) ScaleXY(scaleX, scaleY float64) RegularPolygon[T] {`
`51`		`- return RegularPolygon[T]{rp.Center, rp.Size.ScaleXY(scaleX, scaleY), rp.N}`
	`50`	`+func (rp RegularPolygon[T]) ScaleXY(factorX, factorY float64) RegularPolygon[T] {`
	`51`	`+ return RegularPolygon[T]{rp.Center, rp.Size.ScaleXY(factorX, factorY), rp.N}`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`// Vertices returns the polygon vertices in order starting from angle 0, counter-clockwise.`