Numerinus.Geometry 1.0.1

Numerinus.Geometry

Geometry module for the Numerinus mathematical suite. Built on Numerinus.Core and Numerinus.Algebra, this package provides immutable 2D and 3D geometric types, shape calculations, and affine transformations.

Installation

dotnet add package Numerinus.Geometry

Project Structure

Numerinus.Geometry/ Vectors/ Vector2.cs 2D vector with X, Y components Vector3.cs 3D vector with X, Y, Z components Points/ Point2D.cs 2D point with X, Y coordinates Point3D.cs 3D point with X, Y, Z coordinates Shapes/ Circle.cs Circle with area, circumference, arc calculations Triangle.cs Triangle with full geometric analysis Rectangle.cs Rectangle with area, perimeter, diagonal, incircle, circumcircle Square.cs Square extending Rectangle with side-specific formulas Transforms/ Transform2D.cs 2D affine transformation using 3x3 homogeneous matrix

Dependencies

This module depends on: Numerinus.Core for Scalar, IArithmetic, NumerinusConstants Numerinus.Algebra for Matrix(Scalar) used in Transform2D

Quick Start

Vector2

using Numerinus.Geometry.Vectors;

var v1 = new Vector2(3, 4);
var v2 = new Vector2(1, 2);

var sum     = v1 + v2;
var scaled  = v1 * 2.0;
var length  = v1.Magnitude;
var unit    = v1.Normalise();
var dot     = Vector2.Dot(v1, v2);
var angle   = Vector2.AngleBetween(Vector2.UnitX, Vector2.UnitY);
var dist    = Vector2.Distance(v1, v2);

Vector3

using Numerinus.Geometry.Vectors;

var a = new Vector3(1, 0, 0);
var b = new Vector3(0, 1, 0);

var cross   = Vector3.Cross(a, b);
var dot     = Vector3.Dot(a, b);
var unit    = a.Normalise();

Point2D

using Numerinus.Geometry.Points;

var p1 = new Point2D(0, 0);
var p2 = new Point2D(3, 4);

var dist    = p1.DistanceTo(p2);
var mid     = p1.MidpointTo(p2);
var distSq  = Point2D.DistanceSquared(p1, p2);
var moved   = p1 + new Vector2(1, 1);
var dir     = p2 - p1;

Point3D

using Numerinus.Geometry.Points;

var p1 = new Point3D(0, 0, 0);
var p2 = new Point3D(1, 2, 3);

var dist = p1.DistanceTo(p2);
var mid  = p1.MidpointTo(p2);

Circle

using Numerinus.Geometry.Shapes;

var c = new Circle(5);

var area            = c.Area;
var circumference   = c.Circumference;
var diameter        = c.Diameter;
var arcLen          = c.ArcLengthDegrees(90);
var arcArea         = c.ArcAreaDegrees(90);
var arcBoundary     = c.ArcPlusRadiusLengthDegrees(90);
var angle           = c.AngleDegreesFromArcLength(arcLen);

var fromCirc    = Circle.FromCircumference(31.415);
var fromArea    = Circle.FromArea(78.539);
var fromDiam    = Circle.FromDiameter(10);

Rectangle

using Numerinus.Geometry.Shapes;

var r = new Rectangle(6, 4);

var area                = r.Area;
var perimeter           = r.Perimeter;
var diagonal            = r.Diagonal;
var halfDiagonal        = r.HalfDiagonal;
var diagAngle           = r.DiagonalAngleDegrees;
var longerSide          = r.LongerSide;
var shorterSide         = r.ShorterSide;
var centreToLonger      = r.CentreToLongerSide;
var centreToShorter     = r.CentreToShorterSide;
var incircleRadius      = r.IncircleRadius;
var circumcircleRadius  = r.CircumcircleRadius;
var incircle            = r.Incircle;
var circumcircle        = r.Circumcircle;
var isSquare            = r.IsSquare;

var fromArea        = Rectangle.FromAreaAndWidth(24, 6);
var fromPerimeter   = Rectangle.FromPerimeterAndWidth(20, 6);
var fromDiagonal    = Rectangle.FromDiagonalAndWidth(10, 6);

Square

using Numerinus.Geometry.Shapes;

var s = new Square(5);

var side                = s.Side;
var area                = s.Area;
var perimeter           = s.Perimeter;
var diagonal            = s.Diagonal;
var halfDiagonal        = s.HalfDiagonal;
var diagAngle           = s.DiagonalAngleDegrees;
var incircleRadius      = s.IncircleRadius;
var circumcircleRadius  = s.CircumcircleRadius;
var incircle            = s.Incircle;
var circumcircle        = s.Circumcircle;

var fromArea        = Square.FromArea(25);
var fromPerimeter   = Square.FromPerimeter(20);
var fromDiagonal    = Square.FromDiagonal(7.071);
var fromCircumR     = Square.FromCircumradius(3.535);
var fromInradius    = Square.FromInradius(2.5);

Triangle � from sides only (SSS)

using Numerinus.Geometry.Shapes;

var t = new Triangle(3, 4, 5);

var area        = t.Area;
var perimeter   = t.Perimeter;
var angleA      = t.AngleADegrees;
var angleB      = t.AngleBDegrees;
var angleC      = t.AngleCDegrees;
var heightA     = t.HeightA;
var inradius    = t.IncircleRadius;
var circumR     = t.CircumcircleRadius;
var incircle    = t.Incircle;
var circumcircle = t.Circumcircle;

var isRight     = t.IsRightAngle;
var isAcute     = t.IsAcute;
var isObtuse    = t.IsObtuse;
var isEquil     = t.IsEquilateral;

Triangle � from vertices (centroid, centres available)

using Numerinus.Geometry.Points;
using Numerinus.Geometry.Shapes;

var t = new Triangle(
    new Point2D(0, 0),
    new Point2D(4, 0),
    new Point2D(0, 3));

var centroid            = t.Centroid;
var incircleCentre      = t.IncircleCentre;
var circumcircleCentre  = t.CircumcircleCentre;

Triangle � factory constructors

var sas   = Triangle.FromTwoSidesAndAngleDegrees(4, 5, 60);
var aas   = Triangle.FromOneSideAndTwoAnglesDegrees(5, 60, 80);
var eq    = Triangle.Equilateral(6);
var iso   = Triangle.Isoceles(4, 7);
var right = Triangle.RightAngle(3, 4);

Transform2D

using Numerinus.Geometry.Transforms;
using Numerinus.Geometry.Points;

var point = new Point2D(1, 0);

var moved   = Transform2D.Translation(5, 3).Apply(point);
var rotated = Transform2D.RotationDegrees(90).Apply(point);
var scaled  = Transform2D.Scale(2).Apply(point);

var combined = Transform2D.Translation(5, 0)
             * Transform2D.RotationDegrees(45)
             * Transform2D.Scale(2);

var result = combined.Apply(point);

API Reference

Vector2 � Numerinus.Geometry.Vectors

Immutable readonly struct. Represents a 2D direction or displacement.

Properties X, Y Scalar components Magnitude Length: sqrt(x2 + y2) MagnitudeSquared Length squared, no sqrt cost Zero (0, 0) UnitX (1, 0) UnitY (0, 1)

Methods Normalise() Returns unit vector in same direction Dot(a, b) Scalar dot product: AxBx + AyBy AngleBetween(a, b) Angle in radians between two vectors Distance(a, b) Euclidean distance between tip points

Operators v1 + v2, v1 - v2 Component-wise add / subtract v * scalar, scalar * v Scale vector v / scalar Divide vector -v Negate

Vector3 � Numerinus.Geometry.Vectors

Immutable readonly struct. Represents a 3D direction or displacement.

Properties X, Y, Z Magnitude, MagnitudeSquared Zero, UnitX, UnitY, UnitZ

Methods Normalise() Dot(a, b) AxBx + AyBy + Az*Bz Cross(a, b) Perpendicular vector (3D only) AngleBetween(a, b) Distance(a, b)

Operators v1 + v2, v1 - v2, v * s, v / s, -v

Point2D � Numerinus.Geometry.Points

Immutable readonly struct. Represents a fixed position in 2D space.

Properties X, Y Origin (0, 0)

Methods DistanceTo(other) Distance(a, b) DistanceSquared(a, b) MidpointTo(other) Midpoint(a, b) ToVector2() FromVector2(v)

Operators point + vector Translate point point - vector Translate in reverse point - point Returns Vector2 direction

Point3D � Numerinus.Geometry.Points

Immutable readonly struct. Represents a fixed position in 3D space.

Properties X, Y, Z Origin (0, 0, 0)

Methods DistanceTo(other), Distance(a, b), DistanceSquared(a, b) MidpointTo(other), Midpoint(a, b) ToVector3(), FromVector3(v)

Operators point + vector, point - vector, point - point (returns Vector3)

Circle � Numerinus.Geometry.Shapes

Immutable class. Defined by radius. All arc methods accept radians or degrees.

Construction new Circle(radius) Circle.FromDiameter(d) r = d / 2 Circle.FromCircumference(c) r = C / (2 * Pi) Circle.FromArea(a) r = sqrt(A / Pi)

Properties Radius, Diameter, Circumference, Area

Arc Methods (radians) ArcLength(theta) r * theta ArcArea(theta) 0.5 * r2 * theta ArcPlusRadiusLength(theta) Arc + 2r

Arc Methods (degrees) ArcLengthDegrees(theta) ArcAreaDegrees(theta) ArcPlusRadiusLengthDegrees(theta)

Reverse AngleFromArcLength(arcLen) theta = arcLen / r AngleDegreesFromArcLength(arcLen)

Rectangle � Numerinus.Geometry.Shapes

Immutable class. Defined by width and height. All four angles are 90 degrees. Square is a subclass of Rectangle.

Construction new Rectangle(width, height) Rectangle.FromAreaAndWidth(area, width) h = area / width Rectangle.FromPerimeterAndWidth(perimeter, width) h = (perimeter / 2) - width Rectangle.FromDiagonalAndWidth(diagonal, width) h = sqrt(diagonal2 - width2)

Properties Width, Height LongerSide, ShorterSide Perimeter 2 * (width + height) Area width * height Diagonal sqrt(width2 + height2) HalfDiagonal diagonal / 2 DiagonalAngleDegrees atan(height / width) in degrees DiagonalAngleRadians atan(height / width) in radians CentreToLongerSide shorter side / 2 CentreToShorterSide longer side / 2 IncircleRadius shorter side / 2 CircumcircleRadius diagonal / 2 Incircle Returns Circle touching both longer sides Circumcircle Returns Circle passing through all 4 corners IsSquare True if width equals height

Square � Numerinus.Geometry.Shapes

Immutable sealed class. Extends Rectangle. All four sides are equal. Inherits all Rectangle properties. Square-specific members override with exact formulas.

Construction new Square(side) Square.FromArea(area) side = sqrt(area) Square.FromPerimeter(perimeter) side = perimeter / 4 Square.FromDiagonal(diagonal) side = diagonal / sqrt(2) Square.FromCircumradius(R) side = R * sqrt(2) Square.FromInradius(r) side = 2 * r

Properties (all inherited from Rectangle plus) Side Same as Width Diagonal side * sqrt(2) HalfDiagonal side * sqrt(2) / 2 DiagonalAngleDegrees Always 45 DiagonalAngleRadians Always Pi / 4 IncircleRadius side / 2 CircumcircleRadius side * sqrt(2) / 2 Incircle Returns Circle touching all 4 sides Circumcircle Returns Circle passing through all 4 corners

Triangle � Numerinus.Geometry.Shapes

Immutable class. Two construction modes: sides only, or vertex positions.

Construction � sides new Triangle(a, b, c) Three side lengths (SSS) Triangle.FromTwoSidesAndAngle(a, b, angleRad) SAS Triangle.FromTwoSidesAndAngleDegrees(a, b, angleDeg) Triangle.FromOneSideAndTwoAngles(a, angleA, angleB) AAS Triangle.FromOneSideAndTwoAnglesDegrees(a, aA, aB) Triangle.Equilateral(side) Triangle.Isoceles(base, leg) Triangle.RightAngle(legA, legB)

Construction � vertices new Triangle(Point2D a, Point2D b, Point2D c)

Side-based properties (always available) SideA, SideB, SideC Perimeter, SemiPerimeter Area Heron's formula AngleADegrees/Radians, AngleBDegrees/Radians, AngleCDegrees/Radians HeightA, HeightB, HeightC Inradius, Circumradius IncircleRadius, CircumcircleRadius Incircle, Circumcircle Returns Circle

Vertex-based properties (requires Point2D constructor) A, B, C Vertex positions HasVertices Centroid Intersection of medians IncircleCentre Weighted vertex average by opposite side CircumcircleCentre Perpendicular bisector intersection

Classification IsEquilateral, IsIsoceles, IsScalene IsRightAngle, IsAcute, IsObtuse

Transform2D � Numerinus.Geometry.Transforms

Immutable class. Wraps a 3x3 homogeneous Matrix(Scalar) for 2D affine transformations. Uses homogeneous coordinates [x, y, 1] so translation, rotation and scaling are all expressed as matrix multiplication.

Construction Transform2D.Identity Transform2D.Translation(tx, ty) Transform2D.Rotation(angleRadians) Transform2D.RotationDegrees(angleDegrees) Transform2D.Scale(factor) Transform2D.Scale(sx, sy)

Composition t1 * t2 Applies t2 first then t1 (standard matrix multiplication order)

Apply Apply(Point2D) Translation + rotation + scale affect position Apply(Vector2) Only rotation + scale applied, translation ignored

Key Design Notes

All types are immutable. Every operation returns a new instance.

Vector vs Point distinction. Use Vector2 or Vector3 for directions and displacements. Use Point2D or Point3D for fixed positions in space. Applying Transform2D.Translation to a vector has no effect, which is mathematically correct.

Transform composition order. When combining transforms with *, the rightmost is applied first. To scale then rotate then translate, write: Transform2D.Translation(...) * Transform2D.Rotation(...) * Transform2D.Scale(...)

Triangle vertex requirement. Centroid, IncircleCentre and CircumcircleCentre require the triangle to be constructed from Point2D vertices. Accessing them on a sides-only triangle throws InvalidOperationException. IncircleRadius and CircumcircleRadius are always available since they only need side lengths.

Square extends Rectangle. Square inherits every Rectangle property. Members that have exact closed-form formulas for a square (Diagonal, IncircleRadius, DiagonalAngleDegrees, etc.) are overridden with the precise square formula. Rectangle.IsSquare returns true when width equals height within floating-point tolerance, so a Rectangle can also be checked without casting.

Related Modules

Numerinus.Core IArithmetic(T), Scalar, ComplexNumber, Accuracy, constants Numerinus.Algebra Matrix(T), linear algebra Numerinus.Statistics Statistical functions and distributions

License

Copyright (c) 2026 Sunil Chaware. Licensed under the MIT License. https://opensource.org/licenses/MIT