feat: added vector4d

Author: mrdav30

src/FixedMathSharp/Numerics/Extensions/Fixed4x4.Extensions.cs

@@ -48,6 +48,12 @@ public static Vector3d TransformPoint(this Fixed4x4 matrix, Vector3d point)
         return Fixed4x4.TransformPoint(matrix, point);
     }
 
+    /// <inheritdoc cref="Fixed4x4.Transform(Fixed4x4, Vector4d)" />
+    public static Vector4d Transform(this Fixed4x4 matrix, Vector4d vector)
+    {
+        return Fixed4x4.Transform(matrix, vector);
+    }
+
     /// <inheritdoc cref="Fixed4x4.InverseTransformPoint(Fixed4x4, Vector3d)" />
     public static Vector3d InverseTransformPoint(this Fixed4x4 matrix, Vector3d point)
     {

src/FixedMathSharp/Numerics/Extensions/Vector4d.Extensions.cs

@@ -0,0 +1,73 @@
+using System.Runtime.CompilerServices;
+
+namespace FixedMathSharp;
+
+/// <summary>
+/// Provides extension methods for the Vector4d type to support additional vector operations and comparisons.
+/// </summary>
+public static partial class Vector4dExtensions
+{
+    #region Vector4d Operations
+
+    /// <summary>
+    /// Clamps each component of the vector to the range [-1, 1] and returns the clamped vector.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4d ClampOneInPlace(this Vector4d v)
+    {
+        v.x = v.x.ClampOne();
+        v.y = v.y.ClampOne();
+        v.z = v.z.ClampOne();
+        v.w = v.w.ClampOne();
+        return v;
+    }
+
+    #endregion
+
+    #region Conversion
+
+    /// <inheritdoc cref="Vector4d.Abs(Vector4d)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4d Abs(this Vector4d value)
+    {
+        return Vector4d.Abs(value);
+    }
+
+    /// <inheritdoc cref="Vector4d.Sign(Vector4d)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4d Sign(this Vector4d value)
+    {
+        return Vector4d.Sign(value);
+    }
+
+    #endregion
+
+    #region Equality
+
+    /// <summary>
+    /// Compares two vectors for approximate equality, allowing a fixed absolute difference.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool FuzzyEqualAbsolute(this Vector4d me, Vector4d other, Fixed64 allowedDifference)
+    {
+        return (me.x - other.x).Abs() <= allowedDifference &&
+               (me.y - other.y).Abs() <= allowedDifference &&
+               (me.z - other.z).Abs() <= allowedDifference &&
+               (me.w - other.w).Abs() <= allowedDifference;
+    }
+
+    /// <summary>
+    /// Compares two vectors for approximate equality, allowing a fractional difference.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool FuzzyEqual(this Vector4d me, Vector4d other, Fixed64? percentage = null)
+    {
+        Fixed64 p = percentage ?? Fixed64.Epsilon;
+        return me.x.FuzzyComponentEqual(other.x, p) &&
+               me.y.FuzzyComponentEqual(other.y, p) &&
+               me.z.FuzzyComponentEqual(other.z, p) &&
+               me.w.FuzzyComponentEqual(other.w, p);
+    }
+
+    #endregion
+}

src/FixedMathSharp/Numerics/Fixed4x4.cs

@@ -175,6 +175,32 @@ public Fixed4x4(
         this.m30 = m30; this.m31 = m31; this.m32 = m32; this.m33 = m33;
     }
 
+    /// <summary>
+    /// Creates a matrix from four row vectors.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Fixed4x4 FromRows(Vector4d row0, Vector4d row1, Vector4d row2, Vector4d row3)
+    {
+        return new Fixed4x4(
+            row0.x, row0.y, row0.z, row0.w,
+            row1.x, row1.y, row1.z, row1.w,
+            row2.x, row2.y, row2.z, row2.w,
+            row3.x, row3.y, row3.z, row3.w);
+    }
+
+    /// <summary>
+    /// Creates a matrix from four column vectors.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Fixed4x4 FromColumns(Vector4d column0, Vector4d column1, Vector4d column2, Vector4d column3)
+    {
+        return new Fixed4x4(
+            column0.x, column1.x, column2.x, column3.x,
+            column0.y, column1.y, column2.y, column3.y,
+            column0.z, column1.z, column2.z, column3.z,
+            column0.w, column1.w, column2.w, column3.w);
+    }
+
     #endregion
 
     #region Properties
@@ -1279,6 +1305,15 @@ private static bool FullInvert(Fixed4x4 matrix, out Fixed4x4 result)
         return true;
     }
 
+    /// <summary>
+    /// Transforms a 4D vector by a 4x4 matrix, preserving the computed W component.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Vector4d Transform(Fixed4x4 matrix, Vector4d vector)
+    {
+        return Vector4d.Transform(matrix, vector);
+    }
+
     /// <summary>
     /// Transforms a point from local space to world space using this transformation matrix.
     /// </summary>

src/FixedMathSharp/Numerics/Vector2d.cs

@@ -847,6 +847,15 @@ public readonly Vector3d ToVector3d(Fixed64 z)
         return new Vector3d(x, z, y);
     }
 
+    /// <summary>
+    /// Converts this <see cref="Vector2d"/> to a <see cref="Vector4d"/> with explicit Z and W components.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly Vector4d ToVector4d(Fixed64 z, Fixed64 w)
+    {
+        return new Vector4d(x, y, z, w);
+    }
+
     /// <summary>
     /// Deconstructs the current instance into its X and Y coordinate values as single-precision floating-point numbers.
     /// </summary>

src/FixedMathSharp/Numerics/Vector3d.cs

@@ -1538,6 +1538,15 @@ public Vector2d ToVector2d()
         return new Vector2d(x, z);
     }
 
+    /// <summary>
+    /// Converts this <see cref="Vector3d"/> to a <see cref="Vector4d"/> with an explicit W component.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Vector4d ToVector4d(Fixed64 w)
+    {
+        return new Vector4d(x, y, z, w);
+    }
+
     /// <summary>
     /// Deconstructs the vector into its X, Y, and Z components as single-precision floating-point values.
     /// </summary>