/// <auto-generated/>
/// This code is automatically generated by a T4 template.
/// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
/// </auto-generated>

using System.Numerics;
using System.Runtime.CompilerServices;

namespace Misaki.HighPerformance.Mathematics.SPMD;


public static unsafe partial class MathV
{
# region Vector2

    // Creation Functions

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Create<TLane, TNumber>(in TLane x, in TLane y)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = x,
            y = y,
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> CreateVector2<TLane, TNumber>(in TLane value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = value,
            y = value,
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> LoadVector2<TLane, TNumber>(TNumber* pSrc)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var width = TLane.LaneWidth;

        var x = stackalloc TNumber[width];
        var y = stackalloc TNumber[width];

        for (var i = 0; i < width; i++)
        {
            x[i] = pSrc[i * 2 + 0];
            y[i] = pSrc[i * 2 + 1];
        }

        return new Vector2<TLane, TNumber>
        {
            x = TLane.Load(x),
            y = TLane.Load(y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> LoadVector2<TLane, TNumber>(ref TNumber src)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return LoadVector2<TLane, TNumber>((TNumber*)Unsafe.AsPointer(ref src));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Load<TLane, TNumber>(TNumber* px, TNumber* py)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Load(px),
            y = TLane.Load(py),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Load<TLane, TNumber>(ref TNumber x, ref TNumber y)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Load(ref x),
            y = TLane.Load(ref y),
        };
    }

    // Math Functions

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Abs<TLane, TNumber>(in Vector2<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Abs(vector.x),
            y = TLane.Abs(vector.y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Dot<TLane, TNumber>(in Vector2<TLane, TNumber> a, in Vector2<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return a.x * b.x + a.y * b.y;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Sqrt<TLane, TNumber>(in Vector2<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Sqrt(vector.x),
            y = TLane.Sqrt(vector.y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Rsqrt<TLane, TNumber>(in Vector2<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Rsqrt(vector.x),
            y = TLane.Rsqrt(vector.y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Normalize<TLane, TNumber>(in Vector2<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return vector * TLane.Rsqrt(Dot(vector, vector));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Reflect<TLane, TNumber>(in Vector2<TLane, TNumber> incident, in Vector2<TLane, TNumber> normal)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var dot = Dot(incident, normal);
        return incident - normal * (dot + dot);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Min<TLane, TNumber>(in Vector2<TLane, TNumber> a, in Vector2<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Min(a.x, b.x),
            y = TLane.Min(a.y, b.y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Max<TLane, TNumber>(in Vector2<TLane, TNumber> a, in Vector2<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Max(a.x, b.x),
            y = TLane.Max(a.y, b.y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Clamp<TLane, TNumber>(in Vector2<TLane, TNumber> value, in Vector2<TLane, TNumber> min, in Vector2<TLane, TNumber> max)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Min(Max(value, min), max);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Saturate<TLane, TNumber>(in Vector2<TLane, TNumber> value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Clamp(value, CreateVector2<TLane, TNumber>(TLane.Zero), CreateVector2<TLane, TNumber>(TLane.One));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Lerp<TLane, TNumber>(in Vector2<TLane, TNumber> a, in Vector2<TLane, TNumber> b, TLane t)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return a + (b - a) * t;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Length<TLane, TNumber>(in Vector2<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return TLane.Sqrt(Dot(vector, vector));
    }
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane LengthSquared<TLane, TNumber>(in Vector2<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Dot(vector, vector);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Distance<TLane, TNumber>(in Vector2<TLane, TNumber> a, in Vector2<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var diff = b - a;
        return TLane.Sqrt(Dot(diff, diff));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane DistanceSquared<TLane, TNumber>(in Vector2<TLane, TNumber> a, in Vector2<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var diff = b - a;
        return Dot(diff, diff);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Step<TLane, TNumber>(in Vector2<TLane, TNumber> edge, in Vector2<TLane, TNumber> value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Select(value >= edge, Vector2<TLane, TNumber>.One, Vector2<TLane, TNumber>.Zero);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Smoothstep<TLane, TNumber>(Vector2<TLane, TNumber> xMin, Vector2<TLane, TNumber> xMax, Vector2<TLane, TNumber> x)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var t = Saturate((x - xMin) / (xMax - xMin));
        var two = TLane.Create(TNumber.CreateTruncating(2));
        var three = TLane.Create(TNumber.CreateTruncating(3));

        return t * t * (CreateVector2<TLane, TNumber>(three) - (CreateVector2<TLane, TNumber>(two) * t));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Select<TLane, TNumber>(TLane condition, in Vector2<TLane, TNumber> a, in Vector2<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Select(condition, b.x, a.x),
            y = TLane.Select(condition, b.y, a.y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector2<TLane, TNumber> Select<TLane, TNumber>(Vector2<TLane, TNumber> condition, in Vector2<TLane, TNumber> a, in Vector2<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector2<TLane, TNumber>
        {
            x = TLane.Select(condition.x, b.x, a.x),
            y = TLane.Select(condition.y, b.y, a.y),
        };
    }

# endregion

# region Vector3

    // Creation Functions

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Create<TLane, TNumber>(in TLane x, in TLane y, in TLane z)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = x,
            y = y,
            z = z,
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> CreateVector3<TLane, TNumber>(in TLane value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = value,
            y = value,
            z = value,
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> LoadVector3<TLane, TNumber>(TNumber* pSrc)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var width = TLane.LaneWidth;

        var x = stackalloc TNumber[width];
        var y = stackalloc TNumber[width];
        var z = stackalloc TNumber[width];

        for (var i = 0; i < width; i++)
        {
            x[i] = pSrc[i * 3 + 0];
            y[i] = pSrc[i * 3 + 1];
            z[i] = pSrc[i * 3 + 2];
        }

        return new Vector3<TLane, TNumber>
        {
            x = TLane.Load(x),
            y = TLane.Load(y),
            z = TLane.Load(z),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> LoadVector3<TLane, TNumber>(ref TNumber src)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return LoadVector3<TLane, TNumber>((TNumber*)Unsafe.AsPointer(ref src));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Load<TLane, TNumber>(TNumber* px, TNumber* py, TNumber* pz)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Load(px),
            y = TLane.Load(py),
            z = TLane.Load(pz),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Load<TLane, TNumber>(ref TNumber x, ref TNumber y, ref TNumber z)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Load(ref x),
            y = TLane.Load(ref y),
            z = TLane.Load(ref z),
        };
    }

    // Math Functions

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Abs<TLane, TNumber>(in Vector3<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Abs(vector.x),
            y = TLane.Abs(vector.y),
            z = TLane.Abs(vector.z),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Dot<TLane, TNumber>(in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return a.x * b.x + a.y * b.y + a.z * b.z;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Sqrt<TLane, TNumber>(in Vector3<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Sqrt(vector.x),
            y = TLane.Sqrt(vector.y),
            z = TLane.Sqrt(vector.z),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Rsqrt<TLane, TNumber>(in Vector3<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Rsqrt(vector.x),
            y = TLane.Rsqrt(vector.y),
            z = TLane.Rsqrt(vector.z),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Normalize<TLane, TNumber>(in Vector3<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return vector * TLane.Rsqrt(Dot(vector, vector));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Reflect<TLane, TNumber>(in Vector3<TLane, TNumber> incident, in Vector3<TLane, TNumber> normal)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var dot = Dot(incident, normal);
        return incident - normal * (dot + dot);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Min<TLane, TNumber>(in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Min(a.x, b.x),
            y = TLane.Min(a.y, b.y),
            z = TLane.Min(a.z, b.z),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Max<TLane, TNumber>(in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Max(a.x, b.x),
            y = TLane.Max(a.y, b.y),
            z = TLane.Max(a.z, b.z),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Clamp<TLane, TNumber>(in Vector3<TLane, TNumber> value, in Vector3<TLane, TNumber> min, in Vector3<TLane, TNumber> max)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Min(Max(value, min), max);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Saturate<TLane, TNumber>(in Vector3<TLane, TNumber> value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Clamp(value, CreateVector3<TLane, TNumber>(TLane.Zero), CreateVector3<TLane, TNumber>(TLane.One));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Lerp<TLane, TNumber>(in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b, TLane t)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return a + (b - a) * t;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Length<TLane, TNumber>(in Vector3<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return TLane.Sqrt(Dot(vector, vector));
    }
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane LengthSquared<TLane, TNumber>(in Vector3<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Dot(vector, vector);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Distance<TLane, TNumber>(in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var diff = b - a;
        return TLane.Sqrt(Dot(diff, diff));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane DistanceSquared<TLane, TNumber>(in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var diff = b - a;
        return Dot(diff, diff);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Step<TLane, TNumber>(in Vector3<TLane, TNumber> edge, in Vector3<TLane, TNumber> value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Select(value >= edge, Vector3<TLane, TNumber>.One, Vector3<TLane, TNumber>.Zero);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Smoothstep<TLane, TNumber>(Vector3<TLane, TNumber> xMin, Vector3<TLane, TNumber> xMax, Vector3<TLane, TNumber> x)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var t = Saturate((x - xMin) / (xMax - xMin));
        var two = TLane.Create(TNumber.CreateTruncating(2));
        var three = TLane.Create(TNumber.CreateTruncating(3));

        return t * t * (CreateVector3<TLane, TNumber>(three) - (CreateVector3<TLane, TNumber>(two) * t));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Select<TLane, TNumber>(TLane condition, in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Select(condition, b.x, a.x),
            y = TLane.Select(condition, b.y, a.y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Select<TLane, TNumber>(Vector3<TLane, TNumber> condition, in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = TLane.Select(condition.x, b.x, a.x),
            y = TLane.Select(condition.y, b.y, a.y),
        };
    }

# endregion

# region Vector4

    // Creation Functions

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Create<TLane, TNumber>(in TLane x, in TLane y, in TLane z, in TLane w)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = x,
            y = y,
            z = z,
            w = w,
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> CreateVector4<TLane, TNumber>(in TLane value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = value,
            y = value,
            z = value,
            w = value,
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> LoadVector4<TLane, TNumber>(TNumber* pSrc)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var width = TLane.LaneWidth;

        var x = stackalloc TNumber[width];
        var y = stackalloc TNumber[width];
        var z = stackalloc TNumber[width];
        var w = stackalloc TNumber[width];

        for (var i = 0; i < width; i++)
        {
            x[i] = pSrc[i * 4 + 0];
            y[i] = pSrc[i * 4 + 1];
            z[i] = pSrc[i * 4 + 2];
            w[i] = pSrc[i * 4 + 3];
        }

        return new Vector4<TLane, TNumber>
        {
            x = TLane.Load(x),
            y = TLane.Load(y),
            z = TLane.Load(z),
            w = TLane.Load(w),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> LoadVector4<TLane, TNumber>(ref TNumber src)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return LoadVector4<TLane, TNumber>((TNumber*)Unsafe.AsPointer(ref src));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Load<TLane, TNumber>(TNumber* px, TNumber* py, TNumber* pz, TNumber* pw)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Load(px),
            y = TLane.Load(py),
            z = TLane.Load(pz),
            w = TLane.Load(pw),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Load<TLane, TNumber>(ref TNumber x, ref TNumber y, ref TNumber z, ref TNumber w)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Load(ref x),
            y = TLane.Load(ref y),
            z = TLane.Load(ref z),
            w = TLane.Load(ref w),
        };
    }

    // Math Functions

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Abs<TLane, TNumber>(in Vector4<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Abs(vector.x),
            y = TLane.Abs(vector.y),
            z = TLane.Abs(vector.z),
            w = TLane.Abs(vector.w),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Dot<TLane, TNumber>(in Vector4<TLane, TNumber> a, in Vector4<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Sqrt<TLane, TNumber>(in Vector4<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Sqrt(vector.x),
            y = TLane.Sqrt(vector.y),
            z = TLane.Sqrt(vector.z),
            w = TLane.Sqrt(vector.w),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Rsqrt<TLane, TNumber>(in Vector4<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Rsqrt(vector.x),
            y = TLane.Rsqrt(vector.y),
            z = TLane.Rsqrt(vector.z),
            w = TLane.Rsqrt(vector.w),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Normalize<TLane, TNumber>(in Vector4<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return vector * TLane.Rsqrt(Dot(vector, vector));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Reflect<TLane, TNumber>(in Vector4<TLane, TNumber> incident, in Vector4<TLane, TNumber> normal)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var dot = Dot(incident, normal);
        return incident - normal * (dot + dot);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Min<TLane, TNumber>(in Vector4<TLane, TNumber> a, in Vector4<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Min(a.x, b.x),
            y = TLane.Min(a.y, b.y),
            z = TLane.Min(a.z, b.z),
            w = TLane.Min(a.w, b.w),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Max<TLane, TNumber>(in Vector4<TLane, TNumber> a, in Vector4<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Max(a.x, b.x),
            y = TLane.Max(a.y, b.y),
            z = TLane.Max(a.z, b.z),
            w = TLane.Max(a.w, b.w),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Clamp<TLane, TNumber>(in Vector4<TLane, TNumber> value, in Vector4<TLane, TNumber> min, in Vector4<TLane, TNumber> max)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Min(Max(value, min), max);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Saturate<TLane, TNumber>(in Vector4<TLane, TNumber> value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Clamp(value, CreateVector4<TLane, TNumber>(TLane.Zero), CreateVector4<TLane, TNumber>(TLane.One));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Lerp<TLane, TNumber>(in Vector4<TLane, TNumber> a, in Vector4<TLane, TNumber> b, TLane t)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return a + (b - a) * t;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Length<TLane, TNumber>(in Vector4<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return TLane.Sqrt(Dot(vector, vector));
    }
    
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane LengthSquared<TLane, TNumber>(in Vector4<TLane, TNumber> vector)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Dot(vector, vector);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane Distance<TLane, TNumber>(in Vector4<TLane, TNumber> a, in Vector4<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var diff = b - a;
        return TLane.Sqrt(Dot(diff, diff));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static TLane DistanceSquared<TLane, TNumber>(in Vector4<TLane, TNumber> a, in Vector4<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var diff = b - a;
        return Dot(diff, diff);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Step<TLane, TNumber>(in Vector4<TLane, TNumber> edge, in Vector4<TLane, TNumber> value)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return Select(value >= edge, Vector4<TLane, TNumber>.One, Vector4<TLane, TNumber>.Zero);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Smoothstep<TLane, TNumber>(Vector4<TLane, TNumber> xMin, Vector4<TLane, TNumber> xMax, Vector4<TLane, TNumber> x)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        var t = Saturate((x - xMin) / (xMax - xMin));
        var two = TLane.Create(TNumber.CreateTruncating(2));
        var three = TLane.Create(TNumber.CreateTruncating(3));

        return t * t * (CreateVector4<TLane, TNumber>(three) - (CreateVector4<TLane, TNumber>(two) * t));
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Select<TLane, TNumber>(TLane condition, in Vector4<TLane, TNumber> a, in Vector4<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Select(condition, b.x, a.x),
            y = TLane.Select(condition, b.y, a.y),
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector4<TLane, TNumber> Select<TLane, TNumber>(Vector4<TLane, TNumber> condition, in Vector4<TLane, TNumber> a, in Vector4<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector4<TLane, TNumber>
        {
            x = TLane.Select(condition.x, b.x, a.x),
            y = TLane.Select(condition.y, b.y, a.y),
        };
    }

# endregion


# region Vector3 Specific

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Vector3<TLane, TNumber> Cross<TLane, TNumber>(in Vector3<TLane, TNumber> a, in Vector3<TLane, TNumber> b)
        where TLane : ISPMD<TLane, TNumber>
        where TNumber : unmanaged, INumber<TNumber>, IBinaryNumber<TNumber>, IMinMaxValue<TNumber>, IBitwiseOperators<TNumber, TNumber, TNumber>
    {
        return new Vector3<TLane, TNumber>
        {
            x = a.y * b.z - a.z * b.y,
            y = a.z * b.x - a.x * b.z,
            z = a.x * b.y - a.y * b.x,
        };
    }

# endregion
}