math

const double DBL_MIN_NORMAL

const float E

const float EPSILON

const double EPSILON_DBL

const double E_DBL

const float FLT_MIN_NORMAL

const float INFINITY

const double INFINITY_DBL

const float LN10

const double LN10_DBL

const float LN2

const double LN2_DBL

const float LOG10E

const double LOG10E_DBL

const float LOG2E

const double LOG2E_DBL

const float NAN

const double NAN_DBL

const float PI

const float PI2

const double PI2_DBL

const float PIHALF

const double PIHALF_DBL

const double PI_DBL

const float SQRT2

const double SQRT2_DBL

const float TAU

const double TAU_DBL

const float TODEGREES

const double TODEGREES_DBL

const float TORADIANS

const double TORADIANS_DBL

static AffineTransform AffineTransform(float3 translation, quaternion rotation)

static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale)

static AffineTransform AffineTransform(float3 translation, float3x3 rotationScale)

static AffineTransform AffineTransform(float3x3 rotationScale)

static AffineTransform AffineTransform(float4x4 m)

static AffineTransform AffineTransform(float3x4 m)

static AffineTransform AffineTransform(RigidTransform rigid)

static float3 Euler(quaternion q, RotationOrder order = RotationOrder.Default)

static float3 EulerXYZ(quaternion q)

static float3 EulerXZY(quaternion q)

static float3 EulerYXZ(quaternion q)

static float3 EulerYZX(quaternion q)

static float3 EulerZXY(quaternion q)

static float3 EulerZYX(quaternion q)

static RigidTransform RigidTransform(quaternion rot, float3 pos)

static RigidTransform RigidTransform(float3x3 rotation, float3 translation)

static RigidTransform RigidTransform(float4x4 transform)

static int2 abs(int2 x)

static int3 abs(int3 x)

static int4 abs(int4 x)

static float2 abs(float2 x)

static float3 abs(float3 x)

static float4 abs(float4 x)

static double2 abs(double2 x)

static double3 abs(double3 x)

static double4 abs(double4 x)

static int abs(int x)

static long abs(long x)

static float abs(float x)

static double abs(double x)

static float2 acos(float2 x)

static float3 acos(float3 x)

static float4 acos(float4 x)

static double2 acos(double2 x)

static double3 acos(double3 x)

static double4 acos(double4 x)

static float acos(float x)

static double acos(double x)

static bool all(int2 x)

static bool all(int3 x)

static bool all(int4 x)

static bool all(uint2 x)

static bool all(uint3 x)

static bool all(uint4 x)

static bool all(float2 x)

static bool all(float3 x)

static bool all(float4 x)

static bool all(double2 x)

static bool all(double3 x)

static bool all(double4 x)

static bool all(bool2 x)

static bool all(bool3 x)

static bool all(bool4 x)

static float angle(quaternion q1, quaternion q2)

static bool any(int2 x)

static bool any(int3 x)

static bool any(int4 x)

static bool any(uint2 x)

static bool any(uint3 x)

static bool any(uint4 x)

static bool any(float2 x)

static bool any(float3 x)

static bool any(float4 x)

static bool any(double2 x)

static bool any(double3 x)

static bool any(double4 x)

static bool any(bool2 x)

static bool any(bool3 x)

static bool any(bool4 x)

static double asdouble(long x)

static double asdouble(ulong x)

static float2 asfloat(int2 x)

static float2 asfloat(uint2 x)

static float3 asfloat(int3 x)

static float3 asfloat(uint3 x)

static float4 asfloat(int4 x)

static float4 asfloat(uint4 x)

static float asfloat(int x)

static float asfloat(uint x)

static float2 asin(float2 x)

static float3 asin(float3 x)

static float4 asin(float4 x)

static double2 asin(double2 x)

static double3 asin(double3 x)

static double4 asin(double4 x)

static float asin(float x)

static double asin(double x)

static int2 asint(float2 x)

static int2 asint(uint2 x)

static int3 asint(float3 x)

static int3 asint(uint3 x)

static int4 asint(float4 x)

static int4 asint(uint4 x)

static int asint(int x)

static int asint(uint x)

static int asint(float x)

static long aslong(ulong x)

static long aslong(double x)

static uint2 asuint(float2 x)

static uint2 asuint(int2 x)

static uint3 asuint(float3 x)

static uint3 asuint(int3 x)

static uint4 asuint(float4 x)

static uint4 asuint(int4 x)

static uint asuint(int x)

static uint asuint(uint x)

static uint asuint(float x)

static ulong asulong(long x)

static ulong asulong(double x)

static float2 atan(float2 x)

static float3 atan(float3 x)

static float4 atan(float4 x)

static double2 atan(double2 x)

static double3 atan(double3 x)

static double4 atan(double4 x)

static float atan(float x)

static double atan(double x)

static float2 atan2(float2 x, float2 y)

static float3 atan2(float3 x, float3 y)

static float4 atan2(float4 x, float4 y)

static double2 atan2(double2 x, double2 y)

static double3 atan2(double3 x, double3 y)

static double4 atan2(double4 x, double4 y)

static float atan2(float y, float x)

static double atan2(double y, double x)

static float3 back()

static int bitmask(bool4 value)

static bool2 bool2(bool x, bool y)

static bool2 bool2(bool2 xy)

static bool2 bool2(bool v)

static bool2x2 bool2x2(bool2 c0, bool2 c1)

static bool2x2 bool2x2(bool m00, bool m01, bool m10, bool m11)

static bool2x2 bool2x2(bool v)

static bool2x3 bool2x3(bool2 c0, bool2 c1, bool2 c2)

static bool2x3 bool2x3(bool m00, bool m01, bool m02, bool m10, bool m11, bool m12)

static bool2x3 bool2x3(bool v)

static bool2x4 bool2x4(bool2 c0, bool2 c1, bool2 c2, bool2 c3)

static bool2x4 bool2x4(bool m00, bool m01, bool m02, bool m03, bool m10, bool m11, bool m12, bool m13)

static bool2x4 bool2x4(bool v)

static bool3 bool3(bool x, bool y, bool z)

static bool3 bool3(bool x, bool2 yz)

static bool3 bool3(bool2 xy, bool z)

static bool3 bool3(bool3 xyz)

static bool3 bool3(bool v)

static bool3x2 bool3x2(bool3 c0, bool3 c1)

static bool3x2 bool3x2(bool m00, bool m01, bool m10, bool m11, bool m20, bool m21)

static bool3x2 bool3x2(bool v)

static bool3x3 bool3x3(bool3 c0, bool3 c1, bool3 c2)

static bool3x3 bool3x3(bool m00, bool m01, bool m02, bool m10, bool m11, bool m12, bool m20, bool m21, bool m22)

static bool3x3 bool3x3(bool v)

static bool3x4 bool3x4(bool3 c0, bool3 c1, bool3 c2, bool3 c3)

static bool3x4 bool3x4(bool m00, bool m01, bool m02, bool m03, bool m10, bool m11, bool m12, bool m13, bool m20, bool m21, bool m22, bool m23)

static bool3x4 bool3x4(bool v)

static bool4 bool4(bool x, bool y, bool z, bool w)

static bool4 bool4(bool x, bool y, bool2 zw)

static bool4 bool4(bool x, bool2 yz, bool w)

static bool4 bool4(bool x, bool3 yzw)

static bool4 bool4(bool2 xy, bool z, bool w)

static bool4 bool4(bool2 xy, bool2 zw)

static bool4 bool4(bool3 xyz, bool w)

static bool4 bool4(bool4 xyzw)

static bool4 bool4(bool v)

static bool4x2 bool4x2(bool4 c0, bool4 c1)

static bool4x2 bool4x2(bool m00, bool m01, bool m10, bool m11, bool m20, bool m21, bool m30, bool m31)

static bool4x2 bool4x2(bool v)

static bool4x3 bool4x3(bool4 c0, bool4 c1, bool4 c2)

static bool4x3 bool4x3(bool m00, bool m01, bool m02, bool m10, bool m11, bool m12, bool m20, bool m21, bool m22, bool m30, bool m31, bool m32)

static bool4x3 bool4x3(bool v)

static bool4x4 bool4x4(bool4 c0, bool4 c1, bool4 c2, bool4 c3)

static bool4x4 bool4x4(bool m00, bool m01, bool m02, bool m03, bool m10, bool m11, bool m12, bool m13, bool m20, bool m21, bool m22, bool m23, bool m30, bool m31, bool m32, bool m33)

static bool4x4 bool4x4(bool v)

static float2 ceil(float2 x)

static float3 ceil(float3 x)

static float4 ceil(float4 x)

static double2 ceil(double2 x)

static double3 ceil(double3 x)

static double4 ceil(double4 x)

static float ceil(float x)

static double ceil(double x)

static int2 ceillog2(int2 x)

static int2 ceillog2(uint2 x)

static int3 ceillog2(int3 x)

static int3 ceillog2(uint3 x)

static int4 ceillog2(int4 x)

static int4 ceillog2(uint4 x)

static int ceillog2(int x)

static int ceillog2(uint x)

static int2 ceilpow2(int2 x)

static uint2 ceilpow2(uint2 x)

static int3 ceilpow2(int3 x)

static uint3 ceilpow2(uint3 x)

static int4 ceilpow2(int4 x)

static uint4 ceilpow2(uint4 x)

static int ceilpow2(int x)

static long ceilpow2(long x)

static uint ceilpow2(uint x)

static ulong ceilpow2(ulong x)

static float2 chgsign(float2 x, float2 y)

static float3 chgsign(float3 x, float3 y)

static float4 chgsign(float4 x, float4 y)

static float chgsign(float x, float y)

static int2 clamp(int2 valueToClamp, int2 lowerBound, int2 upperBound)

static int3 clamp(int3 valueToClamp, int3 lowerBound, int3 upperBound)

static int4 clamp(int4 valueToClamp, int4 lowerBound, int4 upperBound)

static uint2 clamp(uint2 valueToClamp, uint2 lowerBound, uint2 upperBound)

static uint3 clamp(uint3 valueToClamp, uint3 lowerBound, uint3 upperBound)

static uint4 clamp(uint4 valueToClamp, uint4 lowerBound, uint4 upperBound)

static float2 clamp(float2 valueToClamp, float2 lowerBound, float2 upperBound)

static float3 clamp(float3 valueToClamp, float3 lowerBound, float3 upperBound)

static float4 clamp(float4 valueToClamp, float4 lowerBound, float4 upperBound)

static double2 clamp(double2 valueToClamp, double2 lowerBound, double2 upperBound)

static double3 clamp(double3 valueToClamp, double3 lowerBound, double3 upperBound)

static double4 clamp(double4 valueToClamp, double4 lowerBound, double4 upperBound)

static int clamp(int valueToClamp, int lowerBound, int upperBound)

static uint clamp(uint valueToClamp, uint lowerBound, uint upperBound)

static long clamp(long valueToClamp, long lowerBound, long upperBound)

static ulong clamp(ulong valueToClamp, ulong lowerBound, ulong upperBound)

static float clamp(float valueToClamp, float lowerBound, float upperBound)

static double clamp(double valueToClamp, double lowerBound, double upperBound)

static int cmax(int2 x)

static int cmax(int3 x)

static int cmax(int4 x)

static uint cmax(uint2 x)

static uint cmax(uint3 x)

static uint cmax(uint4 x)

static float cmax(float2 x)

static float cmax(float3 x)

static float cmax(float4 x)

static double cmax(double2 x)

static double cmax(double3 x)

static double cmax(double4 x)

static int cmin(int2 x)

static int cmin(int3 x)

static int cmin(int4 x)

static uint cmin(uint2 x)

static uint cmin(uint3 x)

static uint cmin(uint4 x)

static float cmin(float2 x)

static float cmin(float3 x)

static float cmin(float4 x)

static double cmin(double2 x)

static double cmin(double3 x)

static double cmin(double4 x)

static quaternion conjugate(quaternion q)

static float2 cos(float2 x)

static float3 cos(float3 x)

static float4 cos(float4 x)

static double2 cos(double2 x)

static double3 cos(double3 x)

static double4 cos(double4 x)

static float cos(float x)

static double cos(double x)

static float2 cosh(float2 x)

static float3 cosh(float3 x)

static float4 cosh(float4 x)

static double2 cosh(double2 x)

static double3 cosh(double3 x)

static double4 cosh(double4 x)

static float cosh(float x)

static double cosh(double x)

static int2 countbits(int2 x)

static int2 countbits(uint2 x)

static int3 countbits(int3 x)

static int3 countbits(uint3 x)

static int4 countbits(int4 x)

static int4 countbits(uint4 x)

static int countbits(int x)

static int countbits(uint x)

static int countbits(long x)

static int countbits(ulong x)

static float3 cross(float3 x, float3 y)

static double3 cross(double3 x, double3 y)

static int csum(int2 x)

static int csum(int3 x)

static int csum(int4 x)

static uint csum(uint2 x)

static uint csum(uint3 x)

static uint csum(uint4 x)

static float csum(float2 x)

static float csum(float3 x)

static float csum(float4 x)

static double csum(double2 x)

static double csum(double3 x)

static double csum(double4 x)

static void decompose(AffineTransform a, out float3 translation, out quaternion rotation, out float3 scale)

static float2 degrees(float2 x)

static float3 degrees(float3 x)

static float4 degrees(float4 x)

static double2 degrees(double2 x)

static double3 degrees(double3 x)

static double4 degrees(double4 x)

static float degrees(float x)

static double degrees(double x)

static int determinant(int2x2 m)

static int determinant(int3x3 m)

static int determinant(int4x4 m)

static float determinant(float2x2 m)

static float determinant(float3x3 m)

static float determinant(float4x4 m)

static double determinant(double2x2 m)

static double determinant(double3x3 m)

static double determinant(double4x4 m)

static float distance(float2 x, float2 y)

static float distance(float3 x, float3 y)

static float distance(float4 x, float4 y)

static double distance(double2 x, double2 y)

static double distance(double3 x, double3 y)

static double distance(double4 x, double4 y)

static float distance(float x, float y)

static double distance(double x, double y)

static float distancesq(float2 x, float2 y)

static float distancesq(float3 x, float3 y)

static float distancesq(float4 x, float4 y)

static double distancesq(double2 x, double2 y)

static double distancesq(double3 x, double3 y)

static double distancesq(double4 x, double4 y)

static float distancesq(float x, float y)

static double distancesq(double x, double y)

static int dot(int2 x, int2 y)

static int dot(int3 x, int3 y)

static int dot(int4 x, int4 y)

static uint dot(uint2 x, uint2 y)

static uint dot(uint3 x, uint3 y)

static uint dot(uint4 x, uint4 y)

static float dot(float2 x, float2 y)

static float dot(float3 x, float3 y)

static float dot(float4 x, float4 y)

static double dot(double2 x, double2 y)

static double dot(double3 x, double3 y)

static double dot(double4 x, double4 y)

static int dot(int x, int y)

static uint dot(uint x, uint y)

static float dot(float x, float y)

static double dot(double x, double y)

static float dot(quaternion a, quaternion b)

static double2 double2(double x, double y)

static double2 double2(double2 xy)

static double2 double2(double v)

static double2 double2(bool v)

static double2 double2(bool2 v)

static double2 double2(int v)

static double2 double2(int2 v)

static double2 double2(uint v)

static double2 double2(uint2 v)

static double2 double2(half v)

static double2 double2(half2 v)

static double2 double2(float v)

static double2 double2(float2 v)

static double2x2 double2x2(double2 c0, double2 c1)

static double2x2 double2x2(double m00, double m01, double m10, double m11)

static double2x2 double2x2(double v)

static double2x2 double2x2(bool v)

static double2x2 double2x2(bool2x2 v)

static double2x2 double2x2(int v)

static double2x2 double2x2(int2x2 v)

static double2x2 double2x2(uint v)

static double2x2 double2x2(uint2x2 v)

static double2x2 double2x2(float v)

static double2x2 double2x2(float2x2 v)

static double2x3 double2x3(double2 c0, double2 c1, double2 c2)

static double2x3 double2x3(double m00, double m01, double m02, double m10, double m11, double m12)

static double2x3 double2x3(double v)

static double2x3 double2x3(bool v)

static double2x3 double2x3(bool2x3 v)

static double2x3 double2x3(int v)

static double2x3 double2x3(int2x3 v)

static double2x3 double2x3(uint v)

static double2x3 double2x3(uint2x3 v)

static double2x3 double2x3(float v)

static double2x3 double2x3(float2x3 v)

static double2x4 double2x4(double2 c0, double2 c1, double2 c2, double2 c3)

static double2x4 double2x4(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13)

static double2x4 double2x4(double v)

static double2x4 double2x4(bool v)

static double2x4 double2x4(bool2x4 v)

static double2x4 double2x4(int v)

static double2x4 double2x4(int2x4 v)

static double2x4 double2x4(uint v)

static double2x4 double2x4(uint2x4 v)

static double2x4 double2x4(float v)

static double2x4 double2x4(float2x4 v)

static double3 double3(double x, double y, double z)

static double3 double3(double x, double2 yz)

static double3 double3(double2 xy, double z)

static double3 double3(double3 xyz)

static double3 double3(double v)

static double3 double3(bool v)

static double3 double3(bool3 v)

static double3 double3(int v)

static double3 double3(int3 v)

static double3 double3(uint v)

static double3 double3(uint3 v)

static double3 double3(half v)

static double3 double3(half3 v)

static double3 double3(float v)

static double3 double3(float3 v)

static double3x2 double3x2(double3 c0, double3 c1)

static double3x2 double3x2(double m00, double m01, double m10, double m11, double m20, double m21)

static double3x2 double3x2(double v)

static double3x2 double3x2(bool v)

static double3x2 double3x2(bool3x2 v)

static double3x2 double3x2(int v)

static double3x2 double3x2(int3x2 v)

static double3x2 double3x2(uint v)

static double3x2 double3x2(uint3x2 v)

static double3x2 double3x2(float v)

static double3x2 double3x2(float3x2 v)

static double3x3 double3x3(double3 c0, double3 c1, double3 c2)

static double3x3 double3x3(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22)

static double3x3 double3x3(double v)

static double3x3 double3x3(bool v)

static double3x3 double3x3(bool3x3 v)

static double3x3 double3x3(int v)

static double3x3 double3x3(int3x3 v)

static double3x3 double3x3(uint v)

static double3x3 double3x3(uint3x3 v)

static double3x3 double3x3(float v)

static double3x3 double3x3(float3x3 v)

static double3x4 double3x4(double3 c0, double3 c1, double3 c2, double3 c3)

static double3x4 double3x4(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23)

static double3x4 double3x4(double v)

static double3x4 double3x4(bool v)

static double3x4 double3x4(bool3x4 v)

static double3x4 double3x4(int v)

static double3x4 double3x4(int3x4 v)

static double3x4 double3x4(uint v)

static double3x4 double3x4(uint3x4 v)

static double3x4 double3x4(float v)

static double3x4 double3x4(float3x4 v)

static double4 double4(double x, double y, double z, double w)

static double4 double4(double x, double y, double2 zw)

static double4 double4(double x, double2 yz, double w)

static double4 double4(double x, double3 yzw)

static double4 double4(double2 xy, double z, double w)

static double4 double4(double2 xy, double2 zw)

static double4 double4(double3 xyz, double w)

static double4 double4(double4 xyzw)

static double4 double4(double v)

static double4 double4(bool v)

static double4 double4(bool4 v)

static double4 double4(int v)

static double4 double4(int4 v)

static double4 double4(uint v)

static double4 double4(uint4 v)

static double4 double4(half v)

static double4 double4(half4 v)

static double4 double4(float v)

static double4 double4(float4 v)

static double4x2 double4x2(double4 c0, double4 c1)

static double4x2 double4x2(double m00, double m01, double m10, double m11, double m20, double m21, double m30, double m31)

static double4x2 double4x2(double v)

static double4x2 double4x2(bool v)

static double4x2 double4x2(bool4x2 v)

static double4x2 double4x2(int v)

static double4x2 double4x2(int4x2 v)

static double4x2 double4x2(uint v)

static double4x2 double4x2(uint4x2 v)

static double4x2 double4x2(float v)

static double4x2 double4x2(float4x2 v)

static double4x3 double4x3(double4 c0, double4 c1, double4 c2)

static double4x3 double4x3(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22, double m30, double m31, double m32)

static double4x3 double4x3(double v)

static double4x3 double4x3(bool v)

static double4x3 double4x3(bool4x3 v)

static double4x3 double4x3(int v)

static double4x3 double4x3(int4x3 v)

static double4x3 double4x3(uint v)

static double4x3 double4x3(uint4x3 v)

static double4x3 double4x3(float v)

static double4x3 double4x3(float4x3 v)

static double4x4 double4x4(double4 c0, double4 c1, double4 c2, double4 c3)

static double4x4 double4x4(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23, double m30, double m31, double m32, double m33)

static double4x4 double4x4(double v)

static double4x4 double4x4(bool v)

static double4x4 double4x4(bool4x4 v)

static double4x4 double4x4(int v)

static double4x4 double4x4(int4x4 v)

static double4x4 double4x4(uint v)

static double4x4 double4x4(uint4x4 v)

static double4x4 double4x4(float v)

static double4x4 double4x4(float4x4 v)

static float3 down()

static float2 exp(float2 x)

static float3 exp(float3 x)

static float4 exp(float4 x)

static double2 exp(double2 x)

static double3 exp(double3 x)

static double4 exp(double4 x)

static float exp(float x)

static double exp(double x)

static quaternion exp(quaternion q)

static float2 exp10(float2 x)

static float3 exp10(float3 x)

static float4 exp10(float4 x)

static double2 exp10(double2 x)

static double3 exp10(double3 x)

static double4 exp10(double4 x)

static float exp10(float x)

static double exp10(double x)

static float2 exp2(float2 x)

static float3 exp2(float3 x)

static float4 exp2(float4 x)

static double2 exp2(double2 x)

static double3 exp2(double3 x)

static double4 exp2(double4 x)

static float exp2(float x)

static double exp2(double x)

static float2 f16tof32(uint2 x)

static float3 f16tof32(uint3 x)

static float4 f16tof32(uint4 x)

static float f16tof32(uint x)

static uint2 f32tof16(float2 x)

static uint3 f32tof16(float3 x)

static uint4 f32tof16(float4 x)

static uint f32tof16(float x)

The nearest half (as its bits), rounding halfway cases away from zero; infinities stay infinite and NaNs become quiet NaNs. Only the top 12 mantissa bits count, as in the package.

static float2 faceforward(float2 n, float2 i, float2 ng)

static float3 faceforward(float3 n, float3 i, float3 ng)

static float4 faceforward(float4 n, float4 i, float4 ng)

static double2 faceforward(double2 n, double2 i, double2 ng)

static double3 faceforward(double3 n, double3 i, double3 ng)

static double4 faceforward(double4 n, double4 i, double4 ng)

static float4x4 fastinverse(float4x4 m)

static float3x4 fastinverse(float3x4 m)

static double4x4 fastinverse(double4x4 m)

static double3x4 fastinverse(double3x4 m)

The inverse of a rotation (orthonormal columns) followed by a translation.

The inverse of a rotation (orthonormal columns) followed by a translation.

static float2 float2(float x, float y)

static float2 float2(float2 xy)

static float2 float2(float v)

static float2 float2(bool v)

static float2 float2(bool2 v)

static float2 float2(int v)

static float2 float2(int2 v)

static float2 float2(uint v)

static float2 float2(uint2 v)

static float2 float2(half v)

static float2 float2(half2 v)

static float2 float2(double v)

static float2 float2(double2 v)

static float2x2 float2x2(float2 c0, float2 c1)

static float2x2 float2x2(float m00, float m01, float m10, float m11)

static float2x2 float2x2(float v)

static float2x2 float2x2(bool v)

static float2x2 float2x2(bool2x2 v)

static float2x2 float2x2(int v)

static float2x2 float2x2(int2x2 v)

static float2x2 float2x2(uint v)

static float2x2 float2x2(uint2x2 v)

static float2x2 float2x2(double v)

static float2x2 float2x2(double2x2 v)

static float2x3 float2x3(float2 c0, float2 c1, float2 c2)

static float2x3 float2x3(float m00, float m01, float m02, float m10, float m11, float m12)

static float2x3 float2x3(float v)

static float2x3 float2x3(bool v)

static float2x3 float2x3(bool2x3 v)

static float2x3 float2x3(int v)

static float2x3 float2x3(int2x3 v)

static float2x3 float2x3(uint v)

static float2x3 float2x3(uint2x3 v)

static float2x3 float2x3(double v)

static float2x3 float2x3(double2x3 v)

static float2x4 float2x4(float2 c0, float2 c1, float2 c2, float2 c3)

static float2x4 float2x4(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13)

static float2x4 float2x4(float v)

static float2x4 float2x4(bool v)

static float2x4 float2x4(bool2x4 v)

static float2x4 float2x4(int v)

static float2x4 float2x4(int2x4 v)

static float2x4 float2x4(uint v)

static float2x4 float2x4(uint2x4 v)

static float2x4 float2x4(double v)

static float2x4 float2x4(double2x4 v)

static float3 float3(float x, float y, float z)

static float3 float3(float x, float2 yz)

static float3 float3(float2 xy, float z)

static float3 float3(float3 xyz)

static float3 float3(float v)

static float3 float3(bool v)

static float3 float3(bool3 v)

static float3 float3(int v)

static float3 float3(int3 v)

static float3 float3(uint v)

static float3 float3(uint3 v)

static float3 float3(half v)

static float3 float3(half3 v)

static float3 float3(double v)

static float3 float3(double3 v)

static float3x2 float3x2(float3 c0, float3 c1)

static float3x2 float3x2(float m00, float m01, float m10, float m11, float m20, float m21)

static float3x2 float3x2(float v)

static float3x2 float3x2(bool v)

static float3x2 float3x2(bool3x2 v)

static float3x2 float3x2(int v)

static float3x2 float3x2(int3x2 v)

static float3x2 float3x2(uint v)

static float3x2 float3x2(uint3x2 v)

static float3x2 float3x2(double v)

static float3x2 float3x2(double3x2 v)

static float3x3 float3x3(float3 c0, float3 c1, float3 c2)

static float3x3 float3x3(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22)

static float3x3 float3x3(float v)

static float3x3 float3x3(bool v)

static float3x3 float3x3(bool3x3 v)

static float3x3 float3x3(int v)

static float3x3 float3x3(int3x3 v)

static float3x3 float3x3(uint v)

static float3x3 float3x3(uint3x3 v)

static float3x3 float3x3(double v)

static float3x3 float3x3(double3x3 v)

static float3x3 float3x3(float4x4 f4x4)

static float3x3 float3x3(quaternion rotation)

static float3x4 float3x4(float3 c0, float3 c1, float3 c2, float3 c3)

static float3x4 float3x4(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23)

static float3x4 float3x4(float v)

static float3x4 float3x4(bool v)

static float3x4 float3x4(bool3x4 v)

static float3x4 float3x4(int v)

static float3x4 float3x4(int3x4 v)

static float3x4 float3x4(uint v)

static float3x4 float3x4(uint3x4 v)

static float3x4 float3x4(double v)

static float3x4 float3x4(double3x4 v)

static float3x4 float3x4(AffineTransform transform)

static float4 float4(float x, float y, float z, float w)

static float4 float4(float x, float y, float2 zw)

static float4 float4(float x, float2 yz, float w)

static float4 float4(float x, float3 yzw)

static float4 float4(float2 xy, float z, float w)

static float4 float4(float2 xy, float2 zw)

static float4 float4(float3 xyz, float w)

static float4 float4(float4 xyzw)

static float4 float4(float v)

static float4 float4(bool v)

static float4 float4(bool4 v)

static float4 float4(int v)

static float4 float4(int4 v)

static float4 float4(uint v)

static float4 float4(uint4 v)

static float4 float4(half v)

static float4 float4(half4 v)

static float4 float4(double v)

static float4 float4(double4 v)

static float4x2 float4x2(float4 c0, float4 c1)

static float4x2 float4x2(float m00, float m01, float m10, float m11, float m20, float m21, float m30, float m31)

static float4x2 float4x2(float v)

static float4x2 float4x2(bool v)

static float4x2 float4x2(bool4x2 v)

static float4x2 float4x2(int v)

static float4x2 float4x2(int4x2 v)

static float4x2 float4x2(uint v)

static float4x2 float4x2(uint4x2 v)

static float4x2 float4x2(double v)

static float4x2 float4x2(double4x2 v)

static float4x3 float4x3(float4 c0, float4 c1, float4 c2)

static float4x3 float4x3(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22, float m30, float m31, float m32)

static float4x3 float4x3(float v)

static float4x3 float4x3(bool v)

static float4x3 float4x3(bool4x3 v)

static float4x3 float4x3(int v)

static float4x3 float4x3(int4x3 v)

static float4x3 float4x3(uint v)

static float4x3 float4x3(uint4x3 v)

static float4x3 float4x3(double v)

static float4x3 float4x3(double4x3 v)

static float4x4 float4x4(float4 c0, float4 c1, float4 c2, float4 c3)

static float4x4 float4x4(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33)

static float4x4 float4x4(float v)

static float4x4 float4x4(bool v)

static float4x4 float4x4(bool4x4 v)

static float4x4 float4x4(int v)

static float4x4 float4x4(int4x4 v)

static float4x4 float4x4(uint v)

static float4x4 float4x4(uint4x4 v)

static float4x4 float4x4(double v)

static float4x4 float4x4(double4x4 v)

static float4x4 float4x4(float3x3 rotation, float3 translation)

static float4x4 float4x4(quaternion rotation, float3 translation)

static float4x4 float4x4(RigidTransform transform)

static float4x4 float4x4(AffineTransform transform)

static float2 floor(float2 x)

static float3 floor(float3 x)

static float4 floor(float4 x)

static double2 floor(double2 x)

static double3 floor(double3 x)

static double4 floor(double4 x)

static float floor(float x)

static double floor(double x)

static int2 floorlog2(int2 x)

static int2 floorlog2(uint2 x)

static int3 floorlog2(int3 x)

static int3 floorlog2(uint3 x)

static int4 floorlog2(int4 x)

static int4 floorlog2(uint4 x)

static int floorlog2(int x)

static int floorlog2(uint x)

static float2 fmod(float2 x, float2 y)

static float3 fmod(float3 x, float3 y)

static float4 fmod(float4 x, float4 y)

static double2 fmod(double2 x, double2 y)

static double3 fmod(double3 x, double3 y)

static double4 fmod(double4 x, double4 y)

static float fmod(float x, float y)

static double fmod(double x, double y)

static float3 forward()

static float3 forward(quaternion q)

static float2 frac(float2 x)

static float3 frac(float3 x)

static float4 frac(float4 x)

static double2 frac(double2 x)

static double3 frac(double3 x)

static double4 frac(double4 x)

static float frac(float x)

static double frac(double x)

static half half(half x)

static half half(float v)

static half half(double v)

static half2 half2(half x, half y)

static half2 half2(half2 xy)

static half2 half2(half v)

static half2 half2(float v)

static half2 half2(float2 v)

static half2 half2(double v)

static half2 half2(double2 v)

static half3 half3(half x, half y, half z)

static half3 half3(half x, half2 yz)

static half3 half3(half2 xy, half z)

static half3 half3(half3 xyz)

static half3 half3(half v)

static half3 half3(float v)

static half3 half3(float3 v)

static half3 half3(double v)

static half3 half3(double3 v)

static half4 half4(half x, half y, half z, half w)

static half4 half4(half x, half y, half2 zw)

static half4 half4(half x, half2 yz, half w)

static half4 half4(half x, half3 yzw)

static half4 half4(half2 xy, half z, half w)

static half4 half4(half2 xy, half2 zw)

static half4 half4(half3 xyz, half w)

static half4 half4(half4 xyzw)

static half4 half4(half v)

static half4 half4(float v)

static half4 half4(float4 v)

static half4 half4(double v)

static half4 half4(double4 v)

static uint hash(bool2 v)

static uint hash(bool2x2 v)

static uint hash(bool2x3 v)

static uint hash(bool2x4 v)

static uint hash(bool3 v)

static uint hash(bool3x2 v)

static uint hash(bool3x3 v)

static uint hash(bool3x4 v)

static uint hash(bool4 v)

static uint hash(bool4x2 v)

static uint hash(bool4x3 v)

static uint hash(bool4x4 v)

static uint hash(double2 v)

static uint hash(double2x2 v)

static uint hash(double2x3 v)

static uint hash(double2x4 v)

static uint hash(double3 v)

static uint hash(double3x2 v)

static uint hash(double3x3 v)

static uint hash(double3x4 v)

static uint hash(double4 v)

static uint hash(double4x2 v)

static uint hash(double4x3 v)

static uint hash(double4x4 v)

static uint hash(float2 v)

static uint hash(float2x2 v)

static uint hash(float2x3 v)

static uint hash(float2x4 v)

static uint hash(float3 v)

static uint hash(float3x2 v)

static uint hash(float3x3 v)

static uint hash(float3x4 v)

static uint hash(float4 v)

static uint hash(float4x2 v)

static uint hash(float4x3 v)

static uint hash(float4x4 v)

static uint hash(half2 v)

static uint hash(half3 v)

static uint hash(half4 v)

static uint hash(int2 v)

static uint hash(int2x2 v)

static uint hash(int2x3 v)

static uint hash(int2x4 v)

static uint hash(int3 v)

static uint hash(int3x2 v)

static uint hash(int3x3 v)

static uint hash(int3x4 v)

static uint hash(int4 v)

static uint hash(int4x2 v)

static uint hash(int4x3 v)

static uint hash(int4x4 v)

static uint hash(uint2 v)

static uint hash(uint2x2 v)

static uint hash(uint2x3 v)

static uint hash(uint2x4 v)

static uint hash(uint3 v)

static uint hash(uint3x2 v)

static uint hash(uint3x3 v)

static uint hash(uint3x4 v)

static uint hash(uint4 v)

static uint hash(uint4x2 v)

static uint hash(uint4x3 v)

static uint hash(uint4x4 v)

static uint hash(half v)

static uint hash(void* pBuffer, int numBytes, uint seed = 0)

static uint hash(quaternion q)

static uint hash(RigidTransform t)

static uint hash(AffineTransform a)

A hash of a block of memory (xxHash32).

static uint2 hashwide(bool2 v)

static uint2 hashwide(bool2x2 v)

static uint2 hashwide(bool2x3 v)

static uint2 hashwide(bool2x4 v)

static uint3 hashwide(bool3 v)

static uint3 hashwide(bool3x2 v)

static uint3 hashwide(bool3x3 v)

static uint3 hashwide(bool3x4 v)

static uint4 hashwide(bool4 v)

static uint4 hashwide(bool4x2 v)

static uint4 hashwide(bool4x3 v)

static uint4 hashwide(bool4x4 v)

static uint2 hashwide(double2 v)

static uint2 hashwide(double2x2 v)

static uint2 hashwide(double2x3 v)

static uint2 hashwide(double2x4 v)

static uint3 hashwide(double3 v)

static uint3 hashwide(double3x2 v)

static uint3 hashwide(double3x3 v)

static uint3 hashwide(double3x4 v)

static uint4 hashwide(double4 v)

static uint4 hashwide(double4x2 v)

static uint4 hashwide(double4x3 v)

static uint4 hashwide(double4x4 v)

static uint2 hashwide(float2 v)

static uint2 hashwide(float2x2 v)

static uint2 hashwide(float2x3 v)

static uint2 hashwide(float2x4 v)

static uint3 hashwide(float3 v)

static uint3 hashwide(float3x2 v)

static uint3 hashwide(float3x3 v)

static uint3 hashwide(float3x4 v)

static uint4 hashwide(float4 v)

static uint4 hashwide(float4x2 v)

static uint4 hashwide(float4x3 v)

static uint4 hashwide(float4x4 v)

static uint2 hashwide(half2 v)

static uint3 hashwide(half3 v)

static uint4 hashwide(half4 v)

static uint2 hashwide(int2 v)

static uint2 hashwide(int2x2 v)

static uint2 hashwide(int2x3 v)

static uint2 hashwide(int2x4 v)

static uint3 hashwide(int3 v)

static uint3 hashwide(int3x2 v)

static uint3 hashwide(int3x3 v)

static uint3 hashwide(int3x4 v)

static uint4 hashwide(int4 v)

static uint4 hashwide(int4x2 v)

static uint4 hashwide(int4x3 v)

static uint4 hashwide(int4x4 v)

static uint2 hashwide(uint2 v)

static uint2 hashwide(uint2x2 v)

static uint2 hashwide(uint2x3 v)

static uint2 hashwide(uint2x4 v)

static uint3 hashwide(uint3 v)

static uint3 hashwide(uint3x2 v)

static uint3 hashwide(uint3x3 v)

static uint3 hashwide(uint3x4 v)

static uint4 hashwide(uint4 v)

static uint4 hashwide(uint4x2 v)

static uint4 hashwide(uint4x3 v)

static uint4 hashwide(uint4x4 v)

static uint4 hashwide(quaternion q)

static uint4 hashwide(RigidTransform t)

static uint4 hashwide(AffineTransform a)

static int2 int2(int x, int y)

static int2 int2(int2 xy)

static int2 int2(int v)

static int2 int2(bool v)

static int2 int2(bool2 v)

static int2 int2(uint v)

static int2 int2(uint2 v)

static int2 int2(float v)

static int2 int2(float2 v)

static int2 int2(double v)

static int2 int2(double2 v)

static int2x2 int2x2(int2 c0, int2 c1)

static int2x2 int2x2(int m00, int m01, int m10, int m11)

static int2x2 int2x2(int v)

static int2x2 int2x2(bool v)

static int2x2 int2x2(bool2x2 v)

static int2x2 int2x2(uint v)

static int2x2 int2x2(uint2x2 v)

static int2x2 int2x2(float v)

static int2x2 int2x2(float2x2 v)

static int2x2 int2x2(double v)

static int2x2 int2x2(double2x2 v)

static int2x3 int2x3(int2 c0, int2 c1, int2 c2)

static int2x3 int2x3(int m00, int m01, int m02, int m10, int m11, int m12)

static int2x3 int2x3(int v)

static int2x3 int2x3(bool v)

static int2x3 int2x3(bool2x3 v)

static int2x3 int2x3(uint v)

static int2x3 int2x3(uint2x3 v)

static int2x3 int2x3(float v)

static int2x3 int2x3(float2x3 v)

static int2x3 int2x3(double v)

static int2x3 int2x3(double2x3 v)

static int2x4 int2x4(int2 c0, int2 c1, int2 c2, int2 c3)

static int2x4 int2x4(int m00, int m01, int m02, int m03, int m10, int m11, int m12, int m13)

static int2x4 int2x4(int v)

static int2x4 int2x4(bool v)

static int2x4 int2x4(bool2x4 v)

static int2x4 int2x4(uint v)

static int2x4 int2x4(uint2x4 v)

static int2x4 int2x4(float v)

static int2x4 int2x4(float2x4 v)

static int2x4 int2x4(double v)

static int2x4 int2x4(double2x4 v)

static int3 int3(int x, int y, int z)

static int3 int3(int x, int2 yz)

static int3 int3(int2 xy, int z)

static int3 int3(int3 xyz)

static int3 int3(int v)

static int3 int3(bool v)

static int3 int3(bool3 v)

static int3 int3(uint v)

static int3 int3(uint3 v)

static int3 int3(float v)

static int3 int3(float3 v)

static int3 int3(double v)

static int3 int3(double3 v)

static int3x2 int3x2(int3 c0, int3 c1)

static int3x2 int3x2(int m00, int m01, int m10, int m11, int m20, int m21)

static int3x2 int3x2(int v)

static int3x2 int3x2(bool v)

static int3x2 int3x2(bool3x2 v)

static int3x2 int3x2(uint v)

static int3x2 int3x2(uint3x2 v)

static int3x2 int3x2(float v)

static int3x2 int3x2(float3x2 v)

static int3x2 int3x2(double v)

static int3x2 int3x2(double3x2 v)

static int3x3 int3x3(int3 c0, int3 c1, int3 c2)

static int3x3 int3x3(int m00, int m01, int m02, int m10, int m11, int m12, int m20, int m21, int m22)

static int3x3 int3x3(int v)

static int3x3 int3x3(bool v)

static int3x3 int3x3(bool3x3 v)

static int3x3 int3x3(uint v)

static int3x3 int3x3(uint3x3 v)

static int3x3 int3x3(float v)

static int3x3 int3x3(float3x3 v)

static int3x3 int3x3(double v)

static int3x3 int3x3(double3x3 v)

static int3x4 int3x4(int3 c0, int3 c1, int3 c2, int3 c3)

static int3x4 int3x4(int m00, int m01, int m02, int m03, int m10, int m11, int m12, int m13, int m20, int m21, int m22, int m23)

static int3x4 int3x4(int v)

static int3x4 int3x4(bool v)

static int3x4 int3x4(bool3x4 v)

static int3x4 int3x4(uint v)

static int3x4 int3x4(uint3x4 v)

static int3x4 int3x4(float v)

static int3x4 int3x4(float3x4 v)

static int3x4 int3x4(double v)

static int3x4 int3x4(double3x4 v)

static int4 int4(int x, int y, int z, int w)

static int4 int4(int x, int y, int2 zw)

static int4 int4(int x, int2 yz, int w)

static int4 int4(int x, int3 yzw)

static int4 int4(int2 xy, int z, int w)

static int4 int4(int2 xy, int2 zw)

static int4 int4(int3 xyz, int w)

static int4 int4(int4 xyzw)

static int4 int4(int v)

static int4 int4(bool v)

static int4 int4(bool4 v)

static int4 int4(uint v)

static int4 int4(uint4 v)

static int4 int4(float v)

static int4 int4(float4 v)

static int4 int4(double v)

static int4 int4(double4 v)

static int4x2 int4x2(int4 c0, int4 c1)

static int4x2 int4x2(int m00, int m01, int m10, int m11, int m20, int m21, int m30, int m31)

static int4x2 int4x2(int v)

static int4x2 int4x2(bool v)

static int4x2 int4x2(bool4x2 v)

static int4x2 int4x2(uint v)

static int4x2 int4x2(uint4x2 v)

static int4x2 int4x2(float v)

static int4x2 int4x2(float4x2 v)

static int4x2 int4x2(double v)

static int4x2 int4x2(double4x2 v)

static int4x3 int4x3(int4 c0, int4 c1, int4 c2)

static int4x3 int4x3(int m00, int m01, int m02, int m10, int m11, int m12, int m20, int m21, int m22, int m30, int m31, int m32)

static int4x3 int4x3(int v)

static int4x3 int4x3(bool v)

static int4x3 int4x3(bool4x3 v)

static int4x3 int4x3(uint v)

static int4x3 int4x3(uint4x3 v)

static int4x3 int4x3(float v)

static int4x3 int4x3(float4x3 v)

static int4x3 int4x3(double v)

static int4x3 int4x3(double4x3 v)

static int4x4 int4x4(int4 c0, int4 c1, int4 c2, int4 c3)

static int4x4 int4x4(int m00, int m01, int m02, int m03, int m10, int m11, int m12, int m13, int m20, int m21, int m22, int m23, int m30, int m31, int m32, int m33)

static int4x4 int4x4(int v)

static int4x4 int4x4(bool v)

static int4x4 int4x4(bool4x4 v)

static int4x4 int4x4(uint v)

static int4x4 int4x4(uint4x4 v)

static int4x4 int4x4(float v)

static int4x4 int4x4(float4x4 v)

static int4x4 int4x4(double v)

static int4x4 int4x4(double4x4 v)

static float2x2 inverse(float2x2 m)

static float3x3 inverse(float3x3 m)

static float4x4 inverse(float4x4 m)

static double2x2 inverse(double2x2 m)

static double3x3 inverse(double3x3 m)

static double4x4 inverse(double4x4 m)

static quaternion inverse(quaternion q)

static RigidTransform inverse(RigidTransform t)

static AffineTransform inverse(AffineTransform a)

static bool2 isfinite(float2 x)

static bool3 isfinite(float3 x)

static bool4 isfinite(float4 x)

static bool2 isfinite(double2 x)

static bool3 isfinite(double3 x)

static bool4 isfinite(double4 x)

static bool isfinite(float x)

static bool isfinite(double x)

static bool2 isinf(float2 x)

static bool3 isinf(float3 x)

static bool4 isinf(float4 x)

static bool2 isinf(double2 x)

static bool3 isinf(double3 x)

static bool4 isinf(double4 x)

static bool isinf(float x)

static bool isinf(double x)

static bool2 isnan(float2 x)

static bool3 isnan(float3 x)

static bool4 isnan(float4 x)

static bool2 isnan(double2 x)

static bool3 isnan(double3 x)

static bool4 isnan(double4 x)

static bool isnan(float x)

static bool isnan(double x)

static bool2 ispow2(int2 x)

static bool2 ispow2(uint2 x)

static bool3 ispow2(int3 x)

static bool3 ispow2(uint3 x)

static bool4 ispow2(int4 x)

static bool4 ispow2(uint4 x)

static bool ispow2(int x)

static bool ispow2(uint x)

static float3 left()

static float length(float2 x)

static float length(float3 x)

static float length(float4 x)

static double length(double2 x)

static double length(double3 x)

static double length(double4 x)

static float length(float x)

static double length(double x)

static float length(quaternion q)

static float lengthsq(float2 x)

static float lengthsq(float3 x)

static float lengthsq(float4 x)

static double lengthsq(double2 x)

static double lengthsq(double3 x)

static double lengthsq(double4 x)

static float lengthsq(float x)

static double lengthsq(double x)

static float lengthsq(quaternion q)

static float2 lerp(float2 start, float2 end, float t)

static float2 lerp(float2 start, float2 end, float2 t)

static float3 lerp(float3 start, float3 end, float t)

static float3 lerp(float3 start, float3 end, float3 t)

static float4 lerp(float4 start, float4 end, float t)

static float4 lerp(float4 start, float4 end, float4 t)

static double2 lerp(double2 start, double2 end, double t)

static double2 lerp(double2 start, double2 end, double2 t)

static double3 lerp(double3 start, double3 end, double t)

static double3 lerp(double3 start, double3 end, double3 t)

static double4 lerp(double4 start, double4 end, double t)

static double4 lerp(double4 start, double4 end, double4 t)

static float lerp(float start, float end, float t)

static double lerp(double start, double end, double t)

static float2 log(float2 x)

static float3 log(float3 x)

static float4 log(float4 x)

static double2 log(double2 x)

static double3 log(double3 x)

static double4 log(double4 x)

static float log(float x)

static double log(double x)

static quaternion log(quaternion q)

static float2 log10(float2 x)

static float3 log10(float3 x)

static float4 log10(float4 x)

static double2 log10(double2 x)

static double3 log10(double3 x)

static double4 log10(double4 x)

static float log10(float x)

static double log10(double x)

static float2 log2(float2 x)

static float3 log2(float3 x)

static float4 log2(float4 x)

static double2 log2(double2 x)

static double3 log2(double3 x)

static double4 log2(double4 x)

static float log2(float x)

static double log2(double x)

static int2 lzcnt(int2 x)

static int2 lzcnt(uint2 x)

static int3 lzcnt(int3 x)

static int3 lzcnt(uint3 x)

static int4 lzcnt(int4 x)

static int4 lzcnt(uint4 x)

static int lzcnt(int x)

static int lzcnt(uint x)

static int lzcnt(long x)

static int lzcnt(ulong x)

static int2 mad(int2 mulA, int2 mulB, int2 addC)

static int3 mad(int3 mulA, int3 mulB, int3 addC)

static int4 mad(int4 mulA, int4 mulB, int4 addC)

static uint2 mad(uint2 mulA, uint2 mulB, uint2 addC)

static uint3 mad(uint3 mulA, uint3 mulB, uint3 addC)

static uint4 mad(uint4 mulA, uint4 mulB, uint4 addC)

static float2 mad(float2 mulA, float2 mulB, float2 addC)

static float3 mad(float3 mulA, float3 mulB, float3 addC)

static float4 mad(float4 mulA, float4 mulB, float4 addC)

static double2 mad(double2 mulA, double2 mulB, double2 addC)

static double3 mad(double3 mulA, double3 mulB, double3 addC)

static double4 mad(double4 mulA, double4 mulB, double4 addC)

static int mad(int mulA, int mulB, int addC)

static uint mad(uint mulA, uint mulB, uint addC)

static long mad(long mulA, long mulB, long addC)

static ulong mad(ulong mulA, ulong mulB, ulong addC)

static float mad(float mulA, float mulB, float addC)

static double mad(double mulA, double mulB, double addC)

static int2 max(int2 x, int2 y)

static int3 max(int3 x, int3 y)

static int4 max(int4 x, int4 y)

static uint2 max(uint2 x, uint2 y)

static uint3 max(uint3 x, uint3 y)

static uint4 max(uint4 x, uint4 y)

static float2 max(float2 x, float2 y)

static float3 max(float3 x, float3 y)

static float4 max(float4 x, float4 y)

static double2 max(double2 x, double2 y)

static double3 max(double3 x, double3 y)

static double4 max(double4 x, double4 y)

static int max(int x, int y)

static uint max(uint x, uint y)

static long max(long x, long y)

static ulong max(ulong x, ulong y)

static float max(float x, float y)

static double max(double x, double y)

static int2 min(int2 x, int2 y)

static int3 min(int3 x, int3 y)

static int4 min(int4 x, int4 y)

static uint2 min(uint2 x, uint2 y)

static uint3 min(uint3 x, uint3 y)

static uint4 min(uint4 x, uint4 y)

static float2 min(float2 x, float2 y)

static float3 min(float3 x, float3 y)

static float4 min(float4 x, float4 y)

static double2 min(double2 x, double2 y)

static double3 min(double3 x, double3 y)

static double4 min(double4 x, double4 y)

static int min(int x, int y)

static uint min(uint x, uint y)

static long min(long x, long y)

static ulong min(ulong x, ulong y)

static float min(float x, float y)

static double min(double x, double y)

static float2 modf(float2 x, out float2 i)

static float3 modf(float3 x, out float3 i)

static float4 modf(float4 x, out float4 i)

static double2 modf(double2 x, out double2 i)

static double3 modf(double3 x, out double3 i)

static double4 modf(double4 x, out double4 i)

static float modf(float x, out float i)

static double modf(double x, out double i)

static int mul(int a, int b)

static int mul(int2 a, int2 b)

static int mul(int3 a, int3 b)

static int mul(int4 a, int4 b)

static int2 mul(int2 a, int2x2 b)

static int3 mul(int2 a, int2x3 b)

static int4 mul(int2 a, int2x4 b)

static int2 mul(int3 a, int3x2 b)

static int3 mul(int3 a, int3x3 b)

static int4 mul(int3 a, int3x4 b)

static int2 mul(int4 a, int4x2 b)

static int3 mul(int4 a, int4x3 b)

static int4 mul(int4 a, int4x4 b)

static int2 mul(int2x2 a, int2 b)

static int2x2 mul(int2x2 a, int2x2 b)

static int2x3 mul(int2x2 a, int2x3 b)

static int2x4 mul(int2x2 a, int2x4 b)

static int2 mul(int2x3 a, int3 b)

static int2x2 mul(int2x3 a, int3x2 b)

static int2x3 mul(int2x3 a, int3x3 b)

static int2x4 mul(int2x3 a, int3x4 b)

static int2 mul(int2x4 a, int4 b)

static int2x2 mul(int2x4 a, int4x2 b)

static int2x3 mul(int2x4 a, int4x3 b)

static int2x4 mul(int2x4 a, int4x4 b)

static int3 mul(int3x2 a, int2 b)

static int3x2 mul(int3x2 a, int2x2 b)

static int3x3 mul(int3x2 a, int2x3 b)

static int3x4 mul(int3x2 a, int2x4 b)

static int3 mul(int3x3 a, int3 b)

static int3x2 mul(int3x3 a, int3x2 b)

static int3x3 mul(int3x3 a, int3x3 b)

static int3x4 mul(int3x3 a, int3x4 b)

static int3 mul(int3x4 a, int4 b)

static int3x2 mul(int3x4 a, int4x2 b)

static int3x3 mul(int3x4 a, int4x3 b)

static int3x4 mul(int3x4 a, int4x4 b)

static int4 mul(int4x2 a, int2 b)

static int4x2 mul(int4x2 a, int2x2 b)

static int4x3 mul(int4x2 a, int2x3 b)

static int4x4 mul(int4x2 a, int2x4 b)

static int4 mul(int4x3 a, int3 b)

static int4x2 mul(int4x3 a, int3x2 b)

static int4x3 mul(int4x3 a, int3x3 b)

static int4x4 mul(int4x3 a, int3x4 b)

static int4 mul(int4x4 a, int4 b)

static int4x2 mul(int4x4 a, int4x2 b)

static int4x3 mul(int4x4 a, int4x3 b)

static int4x4 mul(int4x4 a, int4x4 b)

static uint mul(uint a, uint b)

static uint mul(uint2 a, uint2 b)

static uint mul(uint3 a, uint3 b)

static uint mul(uint4 a, uint4 b)

static uint2 mul(uint2 a, uint2x2 b)

static uint3 mul(uint2 a, uint2x3 b)

static uint4 mul(uint2 a, uint2x4 b)

static uint2 mul(uint3 a, uint3x2 b)

static uint3 mul(uint3 a, uint3x3 b)

static uint4 mul(uint3 a, uint3x4 b)

static uint2 mul(uint4 a, uint4x2 b)

static uint3 mul(uint4 a, uint4x3 b)

static uint4 mul(uint4 a, uint4x4 b)

static uint2 mul(uint2x2 a, uint2 b)

static uint2x2 mul(uint2x2 a, uint2x2 b)

static uint2x3 mul(uint2x2 a, uint2x3 b)

static uint2x4 mul(uint2x2 a, uint2x4 b)

static uint2 mul(uint2x3 a, uint3 b)

static uint2x2 mul(uint2x3 a, uint3x2 b)

static uint2x3 mul(uint2x3 a, uint3x3 b)

static uint2x4 mul(uint2x3 a, uint3x4 b)

static uint2 mul(uint2x4 a, uint4 b)

static uint2x2 mul(uint2x4 a, uint4x2 b)

static uint2x3 mul(uint2x4 a, uint4x3 b)

static uint2x4 mul(uint2x4 a, uint4x4 b)

static uint3 mul(uint3x2 a, uint2 b)

static uint3x2 mul(uint3x2 a, uint2x2 b)

static uint3x3 mul(uint3x2 a, uint2x3 b)

static uint3x4 mul(uint3x2 a, uint2x4 b)

static uint3 mul(uint3x3 a, uint3 b)

static uint3x2 mul(uint3x3 a, uint3x2 b)

static uint3x3 mul(uint3x3 a, uint3x3 b)

static uint3x4 mul(uint3x3 a, uint3x4 b)

static uint3 mul(uint3x4 a, uint4 b)

static uint3x2 mul(uint3x4 a, uint4x2 b)

static uint3x3 mul(uint3x4 a, uint4x3 b)

static uint3x4 mul(uint3x4 a, uint4x4 b)

static uint4 mul(uint4x2 a, uint2 b)

static uint4x2 mul(uint4x2 a, uint2x2 b)

static uint4x3 mul(uint4x2 a, uint2x3 b)

static uint4x4 mul(uint4x2 a, uint2x4 b)

static uint4 mul(uint4x3 a, uint3 b)

static uint4x2 mul(uint4x3 a, uint3x2 b)

static uint4x3 mul(uint4x3 a, uint3x3 b)

static uint4x4 mul(uint4x3 a, uint3x4 b)

static uint4 mul(uint4x4 a, uint4 b)

static uint4x2 mul(uint4x4 a, uint4x2 b)

static uint4x3 mul(uint4x4 a, uint4x3 b)

static uint4x4 mul(uint4x4 a, uint4x4 b)

static float mul(float a, float b)

static float mul(float2 a, float2 b)

static float mul(float3 a, float3 b)

static float mul(float4 a, float4 b)

static float2 mul(float2 a, float2x2 b)

static float3 mul(float2 a, float2x3 b)

static float4 mul(float2 a, float2x4 b)

static float2 mul(float3 a, float3x2 b)

static float3 mul(float3 a, float3x3 b)

static float4 mul(float3 a, float3x4 b)

static float2 mul(float4 a, float4x2 b)

static float3 mul(float4 a, float4x3 b)

static float4 mul(float4 a, float4x4 b)

static float2 mul(float2x2 a, float2 b)

static float2x2 mul(float2x2 a, float2x2 b)

static float2x3 mul(float2x2 a, float2x3 b)

static float2x4 mul(float2x2 a, float2x4 b)

static float2 mul(float2x3 a, float3 b)

static float2x2 mul(float2x3 a, float3x2 b)

static float2x3 mul(float2x3 a, float3x3 b)

static float2x4 mul(float2x3 a, float3x4 b)

static float2 mul(float2x4 a, float4 b)

static float2x2 mul(float2x4 a, float4x2 b)

static float2x3 mul(float2x4 a, float4x3 b)

static float2x4 mul(float2x4 a, float4x4 b)

static float3 mul(float3x2 a, float2 b)

static float3x2 mul(float3x2 a, float2x2 b)

static float3x3 mul(float3x2 a, float2x3 b)

static float3x4 mul(float3x2 a, float2x4 b)

static float3 mul(float3x3 a, float3 b)

static float3x2 mul(float3x3 a, float3x2 b)

static float3x3 mul(float3x3 a, float3x3 b)

static float3x4 mul(float3x3 a, float3x4 b)

static float3 mul(float3x4 a, float4 b)

static float3x2 mul(float3x4 a, float4x2 b)

static float3x3 mul(float3x4 a, float4x3 b)

static float3x4 mul(float3x4 a, float4x4 b)

static float4 mul(float4x2 a, float2 b)

static float4x2 mul(float4x2 a, float2x2 b)

static float4x3 mul(float4x2 a, float2x3 b)

static float4x4 mul(float4x2 a, float2x4 b)

static float4 mul(float4x3 a, float3 b)

static float4x2 mul(float4x3 a, float3x2 b)

static float4x3 mul(float4x3 a, float3x3 b)

static float4x4 mul(float4x3 a, float3x4 b)

static float4 mul(float4x4 a, float4 b)

static float4x2 mul(float4x4 a, float4x2 b)

static float4x3 mul(float4x4 a, float4x3 b)

static float4x4 mul(float4x4 a, float4x4 b)

static double mul(double a, double b)

static double mul(double2 a, double2 b)

static double mul(double3 a, double3 b)

static double mul(double4 a, double4 b)

static double2 mul(double2 a, double2x2 b)

static double3 mul(double2 a, double2x3 b)

static double4 mul(double2 a, double2x4 b)

static double2 mul(double3 a, double3x2 b)

static double3 mul(double3 a, double3x3 b)

static double4 mul(double3 a, double3x4 b)

static double2 mul(double4 a, double4x2 b)

static double3 mul(double4 a, double4x3 b)

static double4 mul(double4 a, double4x4 b)

static double2 mul(double2x2 a, double2 b)

static double2x2 mul(double2x2 a, double2x2 b)

static double2x3 mul(double2x2 a, double2x3 b)

static double2x4 mul(double2x2 a, double2x4 b)

static double2 mul(double2x3 a, double3 b)

static double2x2 mul(double2x3 a, double3x2 b)

static double2x3 mul(double2x3 a, double3x3 b)

static double2x4 mul(double2x3 a, double3x4 b)

static double2 mul(double2x4 a, double4 b)

static double2x2 mul(double2x4 a, double4x2 b)

static double2x3 mul(double2x4 a, double4x3 b)

static double2x4 mul(double2x4 a, double4x4 b)

static double3 mul(double3x2 a, double2 b)

static double3x2 mul(double3x2 a, double2x2 b)

static double3x3 mul(double3x2 a, double2x3 b)

static double3x4 mul(double3x2 a, double2x4 b)

static double3 mul(double3x3 a, double3 b)

static double3x2 mul(double3x3 a, double3x2 b)

static double3x3 mul(double3x3 a, double3x3 b)

static double3x4 mul(double3x3 a, double3x4 b)

static double3 mul(double3x4 a, double4 b)

static double3x2 mul(double3x4 a, double4x2 b)

static double3x3 mul(double3x4 a, double4x3 b)

static double3x4 mul(double3x4 a, double4x4 b)

static double4 mul(double4x2 a, double2 b)

static double4x2 mul(double4x2 a, double2x2 b)

static double4x3 mul(double4x2 a, double2x3 b)

static double4x4 mul(double4x2 a, double2x4 b)

static double4 mul(double4x3 a, double3 b)

static double4x2 mul(double4x3 a, double3x2 b)

static double4x3 mul(double4x3 a, double3x3 b)

static double4x4 mul(double4x3 a, double3x4 b)

static double4 mul(double4x4 a, double4 b)

static double4x2 mul(double4x4 a, double4x2 b)

static double4x3 mul(double4x4 a, double4x3 b)

static double4x4 mul(double4x4 a, double4x4 b)

static quaternion mul(quaternion a, quaternion b)

static float3 mul(quaternion q, float3 v)

static RigidTransform mul(RigidTransform a, RigidTransform b)

static float4 mul(RigidTransform a, float4 pos)

static AffineTransform mul(AffineTransform a, AffineTransform b)

static AffineTransform mul(float3x3 a, AffineTransform b)

static AffineTransform mul(AffineTransform a, float3x3 b)

static float4 mul(AffineTransform a, float4 pos)

The rotation b then a.

static float3x3 mulScale(float3x3 m, float3 s)

Each column scaled by a component: m.c0 * s.x, m.c1 * s.y, m.c2 * s.z.

static quaternion nlerp(quaternion q1, quaternion q2, float t)

static float2 normalize(float2 x)

static float3 normalize(float3 x)

static float4 normalize(float4 x)

static double2 normalize(double2 x)

static double3 normalize(double3 x)

static double4 normalize(double4 x)

static quaternion normalize(quaternion q)

static float2 normalizesafe(float2 x, float2 defaultvalue = new float2())

static float3 normalizesafe(float3 x, float3 defaultvalue = new float3())

static float4 normalizesafe(float4 x, float4 defaultvalue = new float4())

static double2 normalizesafe(double2 x, double2 defaultvalue = new double2())

static double3 normalizesafe(double3 x, double3 defaultvalue = new double3())

static double4 normalizesafe(double4 x, double4 defaultvalue = new double4())

static quaternion normalizesafe(quaternion q)

static quaternion normalizesafe(quaternion q, quaternion defaultvalue)

static void orthonormal_basis(float3 normal, out float3 basis1, out float3 basis2)

static void orthonormal_basis(double3 normal, out double3 basis1, out double3 basis2)

Two unit vectors that with normal make an orthonormal basis (Frisvad's construction).

static float3x3 orthonormalize(float3x3 i)

Gram-Schmidt on the first two columns; the third is their cross product (the identity when they're degenerate).

static float2 pow(float2 x, float2 y)

static float3 pow(float3 x, float3 y)

static float4 pow(float4 x, float4 y)

static double2 pow(double2 x, double2 y)

static double3 pow(double3 x, double3 y)

static double4 pow(double4 x, double4 y)

static float pow(float x, float y)

static double pow(double x, double y)

static float2 project(float2 a, float2 ontoB)

static float3 project(float3 a, float3 ontoB)

static float4 project(float4 a, float4 ontoB)

static double2 project(double2 a, double2 ontoB)

static double3 project(double3 a, double3 ontoB)

static double4 project(double4 a, double4 ontoB)

static float2 projectsafe(float2 a, float2 ontoB, float2 defaultValue = new float2())

static float3 projectsafe(float3 a, float3 ontoB, float3 defaultValue = new float3())

static float4 projectsafe(float4 a, float4 ontoB, float4 defaultValue = new float4())

static double2 projectsafe(double2 a, double2 ontoB, double2 defaultValue = new double2())

static double3 projectsafe(double3 a, double3 ontoB, double3 defaultValue = new double3())

static double4 projectsafe(double4 a, double4 ontoB, double4 defaultValue = new double4())

static float3x3 pseudoinverse(float3x3 m)

The inverse, or for singular matrices the Moore-Penrose pseudoinverse (through an SVD).

static quaternion quaternion(float x, float y, float z, float w)

static quaternion quaternion(float4 value)

static quaternion quaternion(float3x3 m)

static quaternion quaternion(float4x4 m)

static float2 radians(float2 x)

static float3 radians(float3 x)

static float4 radians(float4 x)

static double2 radians(double2 x)

static double3 radians(double3 x)

static double4 radians(double4 x)

static float radians(float x)

static double radians(double x)

static float2 rcp(float2 x)

static float3 rcp(float3 x)

static float4 rcp(float4 x)

static double2 rcp(double2 x)

static double3 rcp(double3 x)

static double4 rcp(double4 x)

static float rcp(float x)

static double rcp(double x)

static float2 reflect(float2 i, float2 n)

static float3 reflect(float3 i, float3 n)

static float4 reflect(float4 i, float4 n)

static double2 reflect(double2 i, double2 n)

static double3 reflect(double3 i, double3 n)

static double4 reflect(double4 i, double4 n)

static float2 refract(float2 i, float2 n, float indexOfRefraction)

static float3 refract(float3 i, float3 n, float indexOfRefraction)

static float4 refract(float4 i, float4 n, float indexOfRefraction)

static double2 refract(double2 i, double2 n, double indexOfRefraction)

static double3 refract(double3 i, double3 n, double indexOfRefraction)

static double4 refract(double4 i, double4 n, double indexOfRefraction)

static float2 remap(float2 srcStart, float2 srcEnd, float2 dstStart, float2 dstEnd, float2 x)

static float3 remap(float3 srcStart, float3 srcEnd, float3 dstStart, float3 dstEnd, float3 x)

static float4 remap(float4 srcStart, float4 srcEnd, float4 dstStart, float4 dstEnd, float4 x)

static double2 remap(double2 srcStart, double2 srcEnd, double2 dstStart, double2 dstEnd, double2 x)

static double3 remap(double3 srcStart, double3 srcEnd, double3 dstStart, double3 dstEnd, double3 x)

static double4 remap(double4 srcStart, double4 srcEnd, double4 dstStart, double4 dstEnd, double4 x)

static float remap(float srcStart, float srcEnd, float dstStart, float dstEnd, float x)

static double remap(double srcStart, double srcEnd, double dstStart, double dstEnd, double x)

static int2 reversebits(int2 x)

static uint2 reversebits(uint2 x)

static int3 reversebits(int3 x)

static uint3 reversebits(uint3 x)

static int4 reversebits(int4 x)

static uint4 reversebits(uint4 x)

static int reversebits(int x)

static long reversebits(long x)

static uint reversebits(uint x)

static ulong reversebits(ulong x)

static float3 right()

static int2 rol(int2 x, int n)

static uint2 rol(uint2 x, int n)

static int3 rol(int3 x, int n)

static uint3 rol(uint3 x, int n)

static int4 rol(int4 x, int n)

static uint4 rol(uint4 x, int n)

static int rol(int x, int n)

static uint rol(uint x, int n)

static long rol(long x, int n)

static ulong rol(ulong x, int n)

static int2 ror(int2 x, int n)

static uint2 ror(uint2 x, int n)

static int3 ror(int3 x, int n)

static uint3 ror(uint3 x, int n)

static int4 ror(int4 x, int n)

static uint4 ror(uint4 x, int n)

static int ror(int x, int n)

static uint ror(uint x, int n)

static long ror(long x, int n)

static ulong ror(ulong x, int n)

static float3 rotate(float4x4 a, float3 b)

static double3 rotate(double4x4 a, double3 b)

static float3 rotate(quaternion q, float3 v)

static float3 rotate(RigidTransform a, float3 dir)

static float3 rotate(AffineTransform a, float3 dir)

static quaternion rotation(float3x3 m)

The rotation part of a rotation-and-scale matrix.

static float2 round(float2 x)

static float3 round(float3 x)

static float4 round(float4 x)

static double2 round(double2 x)

static double3 round(double3 x)

static double4 round(double4 x)

static float round(float x)

static double round(double x)

static float2 rsqrt(float2 x)

static float3 rsqrt(float3 x)

static float4 rsqrt(float4 x)

static double2 rsqrt(double2 x)

static double3 rsqrt(double3 x)

static double4 rsqrt(double4 x)

static float rsqrt(float x)

static double rsqrt(double x)

static float2 saturate(float2 x)

static float3 saturate(float3 x)

static float4 saturate(float4 x)

static double2 saturate(double2 x)

static double3 saturate(double3 x)

static double4 saturate(double4 x)

static float saturate(float x)

static double saturate(double x)

static float3x3 scaleMul(float3 s, float3x3 m)

Each row scaled by a component.

static int2 select(int2 falseValue, int2 trueValue, bool test)

static int2 select(int2 falseValue, int2 trueValue, bool2 test)

static int3 select(int3 falseValue, int3 trueValue, bool test)

static int3 select(int3 falseValue, int3 trueValue, bool3 test)

static int4 select(int4 falseValue, int4 trueValue, bool test)

static int4 select(int4 falseValue, int4 trueValue, bool4 test)

static uint2 select(uint2 falseValue, uint2 trueValue, bool test)

static uint2 select(uint2 falseValue, uint2 trueValue, bool2 test)

static uint3 select(uint3 falseValue, uint3 trueValue, bool test)

static uint3 select(uint3 falseValue, uint3 trueValue, bool3 test)

static uint4 select(uint4 falseValue, uint4 trueValue, bool test)

static uint4 select(uint4 falseValue, uint4 trueValue, bool4 test)

static float2 select(float2 falseValue, float2 trueValue, bool test)

static float2 select(float2 falseValue, float2 trueValue, bool2 test)

static float3 select(float3 falseValue, float3 trueValue, bool test)

static float3 select(float3 falseValue, float3 trueValue, bool3 test)

static float4 select(float4 falseValue, float4 trueValue, bool test)

static float4 select(float4 falseValue, float4 trueValue, bool4 test)

static double2 select(double2 falseValue, double2 trueValue, bool test)

static double2 select(double2 falseValue, double2 trueValue, bool2 test)

static double3 select(double3 falseValue, double3 trueValue, bool test)

static double3 select(double3 falseValue, double3 trueValue, bool3 test)

static double4 select(double4 falseValue, double4 trueValue, bool test)

static double4 select(double4 falseValue, double4 trueValue, bool4 test)

static int select(int falseValue, int trueValue, bool test)

static uint select(uint falseValue, uint trueValue, bool test)

static long select(long falseValue, long trueValue, bool test)

static ulong select(ulong falseValue, ulong trueValue, bool test)

static float select(float falseValue, float trueValue, bool test)

static double select(double falseValue, double trueValue, bool test)

static bool shuffle(bool2 left, bool2 right, ShuffleComponent x)

static bool2 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y)

static bool3 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static bool4 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static bool shuffle(bool3 left, bool3 right, ShuffleComponent x)

static bool2 shuffle(bool3 left, bool3 right, ShuffleComponent x, ShuffleComponent y)

static bool3 shuffle(bool3 left, bool3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static bool4 shuffle(bool3 left, bool3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static bool shuffle(bool4 left, bool4 right, ShuffleComponent x)

static bool2 shuffle(bool4 left, bool4 right, ShuffleComponent x, ShuffleComponent y)

static bool3 shuffle(bool4 left, bool4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static bool4 shuffle(bool4 left, bool4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static double shuffle(double2 left, double2 right, ShuffleComponent x)

static double2 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y)

static double3 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static double4 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static double shuffle(double3 left, double3 right, ShuffleComponent x)

static double2 shuffle(double3 left, double3 right, ShuffleComponent x, ShuffleComponent y)

static double3 shuffle(double3 left, double3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static double4 shuffle(double3 left, double3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static double shuffle(double4 left, double4 right, ShuffleComponent x)

static double2 shuffle(double4 left, double4 right, ShuffleComponent x, ShuffleComponent y)

static double3 shuffle(double4 left, double4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static double4 shuffle(double4 left, double4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static float shuffle(float2 left, float2 right, ShuffleComponent x)

static float2 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y)

static float3 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static float4 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static float shuffle(float3 left, float3 right, ShuffleComponent x)

static float2 shuffle(float3 left, float3 right, ShuffleComponent x, ShuffleComponent y)

static float3 shuffle(float3 left, float3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static float4 shuffle(float3 left, float3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static float shuffle(float4 left, float4 right, ShuffleComponent x)

static float2 shuffle(float4 left, float4 right, ShuffleComponent x, ShuffleComponent y)

static float3 shuffle(float4 left, float4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static float4 shuffle(float4 left, float4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static int shuffle(int2 left, int2 right, ShuffleComponent x)

static int2 shuffle(int2 left, int2 right, ShuffleComponent x, ShuffleComponent y)

static int3 shuffle(int2 left, int2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static int4 shuffle(int2 left, int2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static int shuffle(int3 left, int3 right, ShuffleComponent x)

static int2 shuffle(int3 left, int3 right, ShuffleComponent x, ShuffleComponent y)

static int3 shuffle(int3 left, int3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static int4 shuffle(int3 left, int3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static int shuffle(int4 left, int4 right, ShuffleComponent x)

static int2 shuffle(int4 left, int4 right, ShuffleComponent x, ShuffleComponent y)

static int3 shuffle(int4 left, int4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static int4 shuffle(int4 left, int4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static uint shuffle(uint2 left, uint2 right, ShuffleComponent x)

static uint2 shuffle(uint2 left, uint2 right, ShuffleComponent x, ShuffleComponent y)

static uint3 shuffle(uint2 left, uint2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static uint4 shuffle(uint2 left, uint2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static uint shuffle(uint3 left, uint3 right, ShuffleComponent x)

static uint2 shuffle(uint3 left, uint3 right, ShuffleComponent x, ShuffleComponent y)

static uint3 shuffle(uint3 left, uint3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static uint4 shuffle(uint3 left, uint3 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static uint shuffle(uint4 left, uint4 right, ShuffleComponent x)

static uint2 shuffle(uint4 left, uint4 right, ShuffleComponent x, ShuffleComponent y)

static uint3 shuffle(uint4 left, uint4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)

static uint4 shuffle(uint4 left, uint4 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)

static int2 sign(int2 x)

static int3 sign(int3 x)

static int4 sign(int4 x)

static float2 sign(float2 x)

static float3 sign(float3 x)

static float4 sign(float4 x)

static double2 sign(double2 x)

static double3 sign(double3 x)

static double4 sign(double4 x)

static int sign(int x)

static float sign(float x)

static double sign(double x)

static float2 sin(float2 x)

static float3 sin(float3 x)

static float4 sin(float4 x)

static double2 sin(double2 x)

static double3 sin(double3 x)

static double4 sin(double4 x)

static float sin(float x)

static double sin(double x)

static void sincos(float2 x, out float2 s, out float2 c)

static void sincos(float3 x, out float3 s, out float3 c)

static void sincos(float4 x, out float4 s, out float4 c)

static void sincos(double2 x, out double2 s, out double2 c)

static void sincos(double3 x, out double3 s, out double3 c)

static void sincos(double4 x, out double4 s, out double4 c)

static void sincos(float x, out float s, out float c)

static void sincos(double x, out double s, out double c)

static float2 sinh(float2 x)

static float3 sinh(float3 x)

static float4 sinh(float4 x)

static double2 sinh(double2 x)

static double3 sinh(double3 x)

static double4 sinh(double4 x)

static float sinh(float x)

static double sinh(double x)

static quaternion slerp(quaternion q1, quaternion q2, float t)

static float2 smoothstep(float2 xMin, float2 xMax, float2 x)

static float3 smoothstep(float3 xMin, float3 xMax, float3 x)

static float4 smoothstep(float4 xMin, float4 xMax, float4 x)

static double2 smoothstep(double2 xMin, double2 xMax, double2 x)

static double3 smoothstep(double3 xMin, double3 xMax, double3 x)

static double4 smoothstep(double4 xMin, double4 xMax, double4 x)

static float smoothstep(float xMin, float xMax, float x)

static double smoothstep(double xMin, double xMax, double x)

static float2 sqrt(float2 x)

static float3 sqrt(float3 x)

static float4 sqrt(float4 x)

static double2 sqrt(double2 x)

static double3 sqrt(double3 x)

static double4 sqrt(double4 x)

static float sqrt(float x)

static double sqrt(double x)

static int2 square(int2 x)

static int3 square(int3 x)

static int4 square(int4 x)

static uint2 square(uint2 x)

static uint3 square(uint3 x)

static uint4 square(uint4 x)

static float2 square(float2 x)

static float3 square(float3 x)

static float4 square(float4 x)

static double2 square(double2 x)

static double3 square(double3 x)

static double4 square(double4 x)

static int square(int x)

static uint square(uint x)

static float square(float x)

static double square(double x)

static float2 step(float2 threshold, float2 x)

static float3 step(float3 threshold, float3 x)

static float4 step(float4 threshold, float4 x)

static double2 step(double2 threshold, double2 x)

static double3 step(double3 threshold, double3 x)

static double4 step(double4 threshold, double4 x)

static float step(float threshold, float x)

static double step(double threshold, double x)

static float2 tan(float2 x)

static float3 tan(float3 x)

static float4 tan(float4 x)

static double2 tan(double2 x)

static double3 tan(double3 x)

static double4 tan(double4 x)

static float tan(float x)

static double tan(double x)

static float2 tanh(float2 x)

static float3 tanh(float3 x)

static float4 tanh(float4 x)

static double2 tanh(double2 x)

static double3 tanh(double3 x)

static double4 tanh(double4 x)

static float tanh(float x)

static double tanh(double x)

static float3 transform(float4x4 a, float3 b)

static double3 transform(double4x4 a, double3 b)

static float3 transform(RigidTransform a, float3 pos)

static float3 transform(AffineTransform a, float3 pos)

static bool2x2 transpose(bool2x2 v)

static bool3x2 transpose(bool2x3 v)

static bool4x2 transpose(bool2x4 v)

static bool2x3 transpose(bool3x2 v)

static bool3x3 transpose(bool3x3 v)

static bool4x3 transpose(bool3x4 v)

static bool2x4 transpose(bool4x2 v)

static bool3x4 transpose(bool4x3 v)

static bool4x4 transpose(bool4x4 v)

static double2x2 transpose(double2x2 v)

static double3x2 transpose(double2x3 v)

static double4x2 transpose(double2x4 v)

static double2x3 transpose(double3x2 v)

static double3x3 transpose(double3x3 v)

static double4x3 transpose(double3x4 v)

static double2x4 transpose(double4x2 v)

static double3x4 transpose(double4x3 v)

static double4x4 transpose(double4x4 v)

static float2x2 transpose(float2x2 v)

static float3x2 transpose(float2x3 v)

static float4x2 transpose(float2x4 v)

static float2x3 transpose(float3x2 v)

static float3x3 transpose(float3x3 v)

static float4x3 transpose(float3x4 v)

static float2x4 transpose(float4x2 v)

static float3x4 transpose(float4x3 v)

static float4x4 transpose(float4x4 v)

static int2x2 transpose(int2x2 v)

static int3x2 transpose(int2x3 v)

static int4x2 transpose(int2x4 v)

static int2x3 transpose(int3x2 v)

static int3x3 transpose(int3x3 v)

static int4x3 transpose(int3x4 v)

static int2x4 transpose(int4x2 v)

static int3x4 transpose(int4x3 v)

static int4x4 transpose(int4x4 v)

static uint2x2 transpose(uint2x2 v)

static uint3x2 transpose(uint2x3 v)

static uint4x2 transpose(uint2x4 v)

static uint2x3 transpose(uint3x2 v)

static uint3x3 transpose(uint3x3 v)

static uint4x3 transpose(uint3x4 v)

static uint2x4 transpose(uint4x2 v)

static uint3x4 transpose(uint4x3 v)

static uint4x4 transpose(uint4x4 v)

static float2 trunc(float2 x)

static float3 trunc(float3 x)

static float4 trunc(float4 x)

static double2 trunc(double2 x)

static double3 trunc(double3 x)

static double4 trunc(double4 x)

static float trunc(float x)

static double trunc(double x)

static int2 tzcnt(int2 x)

static int2 tzcnt(uint2 x)

static int3 tzcnt(int3 x)

static int3 tzcnt(uint3 x)

static int4 tzcnt(int4 x)

static int4 tzcnt(uint4 x)

static int tzcnt(int x)

static int tzcnt(uint x)

static int tzcnt(long x)

static int tzcnt(ulong x)

static uint2 uint2(uint x, uint y)

static uint2 uint2(uint2 xy)

static uint2 uint2(uint v)

static uint2 uint2(bool v)

static uint2 uint2(bool2 v)

static uint2 uint2(int v)

static uint2 uint2(int2 v)

static uint2 uint2(float v)

static uint2 uint2(float2 v)

static uint2 uint2(double v)

static uint2 uint2(double2 v)

static uint2x2 uint2x2(uint2 c0, uint2 c1)

static uint2x2 uint2x2(uint m00, uint m01, uint m10, uint m11)

static uint2x2 uint2x2(uint v)

static uint2x2 uint2x2(bool v)

static uint2x2 uint2x2(bool2x2 v)

static uint2x2 uint2x2(int v)

static uint2x2 uint2x2(int2x2 v)

static uint2x2 uint2x2(float v)

static uint2x2 uint2x2(float2x2 v)

static uint2x2 uint2x2(double v)

static uint2x2 uint2x2(double2x2 v)

static uint2x3 uint2x3(uint2 c0, uint2 c1, uint2 c2)

static uint2x3 uint2x3(uint m00, uint m01, uint m02, uint m10, uint m11, uint m12)

static uint2x3 uint2x3(uint v)

static uint2x3 uint2x3(bool v)

static uint2x3 uint2x3(bool2x3 v)

static uint2x3 uint2x3(int v)

static uint2x3 uint2x3(int2x3 v)

static uint2x3 uint2x3(float v)

static uint2x3 uint2x3(float2x3 v)

static uint2x3 uint2x3(double v)

static uint2x3 uint2x3(double2x3 v)

static uint2x4 uint2x4(uint2 c0, uint2 c1, uint2 c2, uint2 c3)

static uint2x4 uint2x4(uint m00, uint m01, uint m02, uint m03, uint m10, uint m11, uint m12, uint m13)

static uint2x4 uint2x4(uint v)

static uint2x4 uint2x4(bool v)

static uint2x4 uint2x4(bool2x4 v)

static uint2x4 uint2x4(int v)

static uint2x4 uint2x4(int2x4 v)

static uint2x4 uint2x4(float v)

static uint2x4 uint2x4(float2x4 v)

static uint2x4 uint2x4(double v)

static uint2x4 uint2x4(double2x4 v)

static uint3 uint3(uint x, uint y, uint z)

static uint3 uint3(uint x, uint2 yz)

static uint3 uint3(uint2 xy, uint z)

static uint3 uint3(uint3 xyz)

static uint3 uint3(uint v)

static uint3 uint3(bool v)

static uint3 uint3(bool3 v)

static uint3 uint3(int v)

static uint3 uint3(int3 v)

static uint3 uint3(float v)

static uint3 uint3(float3 v)

static uint3 uint3(double v)

static uint3 uint3(double3 v)

static uint3x2 uint3x2(uint3 c0, uint3 c1)

static uint3x2 uint3x2(uint m00, uint m01, uint m10, uint m11, uint m20, uint m21)

static uint3x2 uint3x2(uint v)

static uint3x2 uint3x2(bool v)

static uint3x2 uint3x2(bool3x2 v)

static uint3x2 uint3x2(int v)

static uint3x2 uint3x2(int3x2 v)

static uint3x2 uint3x2(float v)

static uint3x2 uint3x2(float3x2 v)

static uint3x2 uint3x2(double v)

static uint3x2 uint3x2(double3x2 v)

static uint3x3 uint3x3(uint3 c0, uint3 c1, uint3 c2)

static uint3x3 uint3x3(uint m00, uint m01, uint m02, uint m10, uint m11, uint m12, uint m20, uint m21, uint m22)

static uint3x3 uint3x3(uint v)

static uint3x3 uint3x3(bool v)

static uint3x3 uint3x3(bool3x3 v)

static uint3x3 uint3x3(int v)

static uint3x3 uint3x3(int3x3 v)

static uint3x3 uint3x3(float v)

static uint3x3 uint3x3(float3x3 v)

static uint3x3 uint3x3(double v)

static uint3x3 uint3x3(double3x3 v)

static uint3x4 uint3x4(uint3 c0, uint3 c1, uint3 c2, uint3 c3)

static uint3x4 uint3x4(uint m00, uint m01, uint m02, uint m03, uint m10, uint m11, uint m12, uint m13, uint m20, uint m21, uint m22, uint m23)

static uint3x4 uint3x4(uint v)

static uint3x4 uint3x4(bool v)

static uint3x4 uint3x4(bool3x4 v)

static uint3x4 uint3x4(int v)

static uint3x4 uint3x4(int3x4 v)

static uint3x4 uint3x4(float v)

static uint3x4 uint3x4(float3x4 v)

static uint3x4 uint3x4(double v)

static uint3x4 uint3x4(double3x4 v)

static uint4 uint4(uint x, uint y, uint z, uint w)

static uint4 uint4(uint x, uint y, uint2 zw)

static uint4 uint4(uint x, uint2 yz, uint w)

static uint4 uint4(uint x, uint3 yzw)

static uint4 uint4(uint2 xy, uint z, uint w)

static uint4 uint4(uint2 xy, uint2 zw)

static uint4 uint4(uint3 xyz, uint w)

static uint4 uint4(uint4 xyzw)

static uint4 uint4(uint v)

static uint4 uint4(bool v)

static uint4 uint4(bool4 v)

static uint4 uint4(int v)

static uint4 uint4(int4 v)

static uint4 uint4(float v)

static uint4 uint4(float4 v)

static uint4 uint4(double v)

static uint4 uint4(double4 v)

static uint4x2 uint4x2(uint4 c0, uint4 c1)

static uint4x2 uint4x2(uint m00, uint m01, uint m10, uint m11, uint m20, uint m21, uint m30, uint m31)

static uint4x2 uint4x2(uint v)

static uint4x2 uint4x2(bool v)

static uint4x2 uint4x2(bool4x2 v)

static uint4x2 uint4x2(int v)

static uint4x2 uint4x2(int4x2 v)

static uint4x2 uint4x2(float v)

static uint4x2 uint4x2(float4x2 v)

static uint4x2 uint4x2(double v)

static uint4x2 uint4x2(double4x2 v)

static uint4x3 uint4x3(uint4 c0, uint4 c1, uint4 c2)

static uint4x3 uint4x3(uint m00, uint m01, uint m02, uint m10, uint m11, uint m12, uint m20, uint m21, uint m22, uint m30, uint m31, uint m32)

static uint4x3 uint4x3(uint v)

static uint4x3 uint4x3(bool v)

static uint4x3 uint4x3(bool4x3 v)

static uint4x3 uint4x3(int v)

static uint4x3 uint4x3(int4x3 v)

static uint4x3 uint4x3(float v)

static uint4x3 uint4x3(float4x3 v)

static uint4x3 uint4x3(double v)

static uint4x3 uint4x3(double4x3 v)

static uint4x4 uint4x4(uint4 c0, uint4 c1, uint4 c2, uint4 c3)

static uint4x4 uint4x4(uint m00, uint m01, uint m02, uint m03, uint m10, uint m11, uint m12, uint m13, uint m20, uint m21, uint m22, uint m23, uint m30, uint m31, uint m32, uint m33)

static uint4x4 uint4x4(uint v)

static uint4x4 uint4x4(bool v)

static uint4x4 uint4x4(bool4x4 v)

static uint4x4 uint4x4(int v)

static uint4x4 uint4x4(int4x4 v)

static uint4x4 uint4x4(float v)

static uint4x4 uint4x4(float4x4 v)

static uint4x4 uint4x4(double v)

static uint4x4 uint4x4(double4x4 v)

static quaternion unitexp(quaternion q)

static quaternion unitlog(quaternion q)

static float2 unlerp(float2 start, float2 end, float2 x)

static float3 unlerp(float3 start, float3 end, float3 x)

static float4 unlerp(float4 start, float4 end, float4 x)

static double2 unlerp(double2 start, double2 end, double2 x)

static double3 unlerp(double3 start, double3 end, double3 x)

static double4 unlerp(double4 start, double4 end, double4 x)

static float unlerp(float start, float end, float x)

static double unlerp(double start, double end, double x)

static float3 up()