package core:math/linalg

Source

Euler_Angle_Order :: enum int {
	// Tait-Bryan
	XYZ, 
	XZY, 
	YXZ, 
	YZX, 
	ZXY, 
	ZYX, 
	// Proper Euler
	XYX, 
	XZX, 
	YXY, 
	YZY, 
	ZXZ, 
	ZYZ, 
}

Matrix1f16 :: matrix[1, 1]f16

Matrix1f32 :: matrix[1, 1]f32

Matrix1f64 :: matrix[1, 1]f64

Matrix1x1f16 :: matrix[1, 1]f16

Matrix1x1f32 :: matrix[1, 1]f32

Matrix1x1f64 :: matrix[1, 1]f64

Matrix1x2f16 :: matrix[1, 2]f16

Matrix1x2f32 :: matrix[1, 2]f32

Matrix1x2f64 :: matrix[1, 2]f64

Matrix1x3f16 :: matrix[1, 3]f16

Matrix1x3f32 :: matrix[1, 3]f32

Matrix1x3f64 :: matrix[1, 3]f64

Matrix1x4f16 :: matrix[1, 4]f16

Matrix1x4f32 :: matrix[1, 4]f32

Matrix1x4f64 :: matrix[1, 4]f64

Matrix2f16 :: matrix[2, 2]f16

Matrix2f32 :: matrix[2, 2]f32

Matrix2f64 :: matrix[2, 2]f64

Matrix2x1f16 :: matrix[2, 1]f16

Matrix2x1f32 :: matrix[2, 1]f32

Matrix2x1f64 :: matrix[2, 1]f64

Matrix2x2f16 :: matrix[2, 2]f16

Matrix2x2f32 :: matrix[2, 2]f32

Matrix2x2f64 :: matrix[2, 2]f64

Matrix2x3f16 :: matrix[2, 3]f16

Matrix2x3f32 :: matrix[2, 3]f32

Matrix2x3f64 :: matrix[2, 3]f64

Matrix2x4f16 :: matrix[2, 4]f16

Matrix2x4f32 :: matrix[2, 4]f32

Matrix2x4f64 :: matrix[2, 4]f64

Matrix3f16 :: matrix[3, 3]f16

Matrix3f32 :: matrix[3, 3]f32

Matrix3f64 :: matrix[3, 3]f64

Matrix3x1f16 :: matrix[3, 1]f16

Matrix3x1f32 :: matrix[3, 1]f32

Matrix3x1f64 :: matrix[3, 1]f64

Matrix3x2f16 :: matrix[3, 2]f16

Matrix3x2f32 :: matrix[3, 2]f32

Matrix3x2f64 :: matrix[3, 2]f64

Matrix3x3f16 :: matrix[3, 3]f16

Matrix3x3f32 :: matrix[3, 3]f32

Matrix3x3f64 :: matrix[3, 3]f64

Matrix3x4f16 :: matrix[3, 4]f16

Matrix3x4f32 :: matrix[3, 4]f32

Matrix3x4f64 :: matrix[3, 4]f64

Matrix4f16 :: matrix[4, 4]f16

Matrix4f32 :: matrix[4, 4]f32

Matrix4f64 :: matrix[4, 4]f64

Matrix4x1f16 :: matrix[4, 1]f16

Matrix4x1f32 :: matrix[4, 1]f32

Matrix4x1f64 :: matrix[4, 1]f64

Matrix4x2f16 :: matrix[4, 2]f16

Matrix4x2f32 :: matrix[4, 2]f32

Matrix4x2f64 :: matrix[4, 2]f64

Matrix4x3f16 :: matrix[4, 3]f16

Matrix4x3f32 :: matrix[4, 3]f32

Matrix4x3f64 :: matrix[4, 3]f64

Matrix4x4f16 :: matrix[4, 4]f16

Matrix4x4f32 :: matrix[4, 4]f32

Matrix4x4f64 :: matrix[4, 4]f64

Quaternionf16 :: quaternion64

Quaternionf32 :: quaternion128

Quaternionf64 :: quaternion256

Scalar_Components :: enum u8 {
	x = 0, 
	r = 0, 
}

Vector2_Components :: enum u8 {
	x = 0, 
	y = 1, 
	r = 0, 
	g = 1, 
}

Vector2f16 :: [2]f16

Vector2f32 :: [2]f32

Vector2f64 :: [2]f64

Vector3_Components :: enum u8 {
	x = 0, 
	y = 1, 
	z = 2, 
	r = 0, 
	g = 1, 
	b = 2, 
}

Vector3f16 :: [3]f16

Vector3f32 :: [3]f32

Vector3f64 :: [3]f64

Vector4_Components :: enum u8 {
	x = 0, 
	y = 1, 
	z = 2, 
	w = 3, 
	r = 0, 
	g = 1, 
	b = 2, 
	a = 3, 
}

Vector4f16 :: [4]f16

Vector4f32 :: [4]f32

Vector4f64 :: [4]f64

DEG_PER_RAD: f64 : 360.0 / TAU

E: f64 : 2.71828182845904523536

F16_EPSILON: f64 : 1e-3

F32_EPSILON: f64 : 1e-7

F64_EPSILON: f64 : 1e-15

LN10: f64 : 2.30258509299404568401799145468436421

LN2: f64 : 0.693147180559945309417232121458176568

MATRIX1F16_IDENTITY: matrix[1, 1]f16 : Matrix1f16(1)

MATRIX1F32_IDENTITY: matrix[1, 1]f32 : Matrix1f32(1)

MATRIX1F64_IDENTITY: matrix[1, 1]f64 : Matrix1f64(1)

MATRIX2F16_IDENTITY: matrix[2, 2]f16 : Matrix2f16(1)

MATRIX2F32_IDENTITY: matrix[2, 2]f32 : Matrix2f32(1)

MATRIX2F64_IDENTITY: matrix[2, 2]f64 : Matrix2f64(1)

MATRIX3F16_IDENTITY: matrix[3, 3]f16 : Matrix3f16(1)

MATRIX3F32_IDENTITY: matrix[3, 3]f32 : Matrix3f32(1)

MATRIX3F64_IDENTITY: matrix[3, 3]f64 : Matrix3f64(1)

MATRIX4F16_IDENTITY: matrix[4, 4]f16 : Matrix4f16(1)

MATRIX4F32_IDENTITY: matrix[4, 4]f32 : Matrix4f32(1)

MATRIX4F64_IDENTITY: matrix[4, 4]f64 : Matrix4f64(1)

MAX_F32_PRECISION: int : 8

MAX_F64_PRECISION: int : 16

PI: f64 : 3.14159265358979323846264338327950288

QUATERNIONF16_IDENTITY: quaternion64 : Quaternionf16(1)

QUATERNIONF32_IDENTITY: quaternion128 : Quaternionf32(1)

QUATERNIONF64_IDENTITY: quaternion256 : Quaternionf64(1)

RAD_PER_DEG: f64 : TAU / 360.0

SQRT_FIVE: f64 : 2.23606797749978969640917366873127623

SQRT_THREE: f64 : 1.73205080756887729352744634150587236

SQRT_TWO: f64 : 1.41421356237309504880168872420969808

TAU: f64 : 6.28318530717958647692528676655900576

VECTOR3F16_X_AXIS: [3]f16 : Vector3f16{1, 0, 0}

VECTOR3F16_Y_AXIS: [3]f16 : Vector3f16{0, 1, 0}

VECTOR3F16_Z_AXIS: [3]f16 : Vector3f16{0, 0, 1}

VECTOR3F32_X_AXIS: [3]f32 : Vector3f32{1, 0, 0}

VECTOR3F32_Y_AXIS: [3]f32 : Vector3f32{0, 1, 0}

VECTOR3F32_Z_AXIS: [3]f32 : Vector3f32{0, 0, 1}

VECTOR3F64_X_AXIS: [3]f64 : Vector3f64{1, 0, 0}

VECTOR3F64_Y_AXIS: [3]f64 : Vector3f64{0, 1, 0}

VECTOR3F64_Z_AXIS: [3]f64 : Vector3f64{0, 0, 1}

e: f64 : E

π: f64 : PI

τ: f64 : TAU

abs :: proc "contextless" (a: $T) -> (out: $T) {…}

acos :: proc "contextless" (x: $T) -> (out: $T) {…}

all :: proc "contextless" (x: $A/[0]bool) -> (out: bool) {…}

angle_axis_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (angle: f16, axis: [3]f16) {…}

angle_axis_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (angle: f32, axis: [3]f32) {…}

angle_axis_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (angle: f64, axis: [3]f64) {…}

angle_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> f16 {…}

angle_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> f32 {…}

angle_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> f64 {…}

any :: proc "contextless" (x: $A/[0]bool) -> (out: bool) {…}

array_cast :: proc "contextless" (v: $A/[0]$T, $Elem_Type: typeid) -> (w: [0]typeid) {…}

asin :: proc "contextless" (x: $T) -> (out: $T) {…}

atan :: proc "contextless" (x: $T) -> (out: $T) {…}

atan2 :: proc "contextless" (y, x: $T) -> (out: $T) {…}

axis_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> [3]f16 {…}

axis_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> [3]f32 {…}

axis_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> [3]f64 {…}

catmull_rom :: proc "contextless" (v1, v2, v3, v4: $T/[0]$E, s: $E) -> $T/[0]$E {…}

ceil :: proc "contextless" (x: $T) -> (out: $T) {…}

clamp :: proc "contextless" (x, a, b: $T) -> (out: $T) {…}

clamp_length :: proc "contextless" (v: $T/[0]$E, a: $E) -> $T/[0]$E {…}

classify_array :: proc "contextless" (x: $A/[0]$T) -> (out: [0]math.Float_Class) {…}

classify_single :: proc "contextless" (x: $T) -> math.Float_Class {…}

cos :: proc "contextless" (x: $T) -> (out: $T) {…}

cubic :: proc "contextless" (v1, v2, v3, v4: $T/[0]$E, s: $E) -> $T/[0]$E {…}

distance :: proc "contextless" (p0, p1: $V/[0]$E) -> $E {…}

equal_array :: proc "contextless" (x, y: $A/[0]$T) -> (out: [0]bool) {…}

equal_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

euclidean_from_polar_f16 :: proc "contextless" (polar: [2]f16) -> [3]f16 {…}

euclidean_from_polar_f32 :: proc "contextless" (polar: [2]f32) -> [3]f32 {…}

euclidean_from_polar_f64 :: proc "contextless" (polar: [2]f64) -> [3]f64 {…}

euler_angles_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

euler_angles_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

euler_angles_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

euler_angles_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

euler_angles_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

euler_angles_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

euler_angles_from_quaternion_f16 :: proc "contextless" (m: quaternion64, order: Euler_Angle_Order) -> (t1, t2, t3: f16) {…}

euler_angles_from_quaternion_f32 :: proc "contextless" (m: quaternion128, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {…}

euler_angles_from_quaternion_f64 :: proc "contextless" (m: quaternion256, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {…}

euler_angles_xyx_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_xyx_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_xyx_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_xyx_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_xyx_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_xyx_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_xyx_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_xyx_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_xyx_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_xyz_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_xyz_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_xyz_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_xyz_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_xyz_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_xyz_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_xyz_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_xyz_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_xyz_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_xzx_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_xzx_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_xzx_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_xzx_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_xzx_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_xzx_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_xzx_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_xzx_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_xzx_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_xzy_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_xzy_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_xzy_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_xzy_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_xzy_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_xzy_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_xzy_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_xzy_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_xzy_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_yxy_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_yxy_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_yxy_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_yxy_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_yxy_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_yxy_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_yxy_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_yxy_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_yxy_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_yxz_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_yxz_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_yxz_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_yxz_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_yxz_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_yxz_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_yxz_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_yxz_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_yxz_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_yzx_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_yzx_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_yzx_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_yzx_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_yzx_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_yzx_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_yzx_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_yzx_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_yzx_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_yzy_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_yzy_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_yzy_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_yzy_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_yzy_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_yzy_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_yzy_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_yzy_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_yzy_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_zxy_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_zxy_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_zxy_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_zxy_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_zxy_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_zxy_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_zxy_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_zxy_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_zxy_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_zxz_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_zxz_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_zxz_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_zxz_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_zxz_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_zxz_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_zxz_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_zxz_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_zxz_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_zyx_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_zyx_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_zyx_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_zyx_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_zyx_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_zyx_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_zyx_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_zyx_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_zyx_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

euler_angles_zyz_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (t1, t2, t3: f16) {…}

euler_angles_zyz_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (t1, t2, t3: f32) {…}

euler_angles_zyz_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (t1, t2, t3: f64) {…}

euler_angles_zyz_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (t1, t2, t3: f16) {…}

euler_angles_zyz_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (t1, t2, t3: f32) {…}

euler_angles_zyz_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (t1, t2, t3: f64) {…}

euler_angles_zyz_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (t1, t2, t3: f16) {…}

euler_angles_zyz_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (t1, t2, t3: f32) {…}

euler_angles_zyz_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (t1, t2, t3: f64) {…}

exp :: proc "contextless" (x: $T) -> (out: $T) {…}

exp10 :: proc "contextless" (x: $T) -> (out: $T) {…}

exp2 :: proc "contextless" (x: $T) -> (out: $T) {…}

face_forward :: proc "contextless" (N, I, N_ref: $T) -> (out: $T) {…}

floor :: proc "contextless" (x: $T) -> (out: $T) {…}

fract :: proc "contextless" (x: $T) -> $T {…}

greater_than_array :: proc "contextless" (x, y: $A/[0]$T) -> (out: [0]bool) {…}

greater_than_equal_array :: proc "contextless" (x, y: $A/[0]$T) -> (out: [0]bool) {…}

greater_than_equal_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

greater_than_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

hadamard_product :: intrinsics.hadamard_product

hermite :: proc "contextless" (v1, t1, v2, t2: $T/[0]$E, s: $E) -> $T/[0]$E {…}

hermitian_adjoint :: proc "contextless" (m: $M/matrix[0, 0]$T) -> $M/matrix[0, 0]$T {…}

identity_array_based_matrix :: proc "contextless" ($T: typeid/[0][0]$E) -> (m: $/[0][0]$E) {…}

identity_matrix :: proc "contextless" ($T: typeid/matrix[0, 0]$E) -> $/matrix[0, 0]$E {…}

inverse_sqrt :: proc "contextless" (x: $T) -> (out: $T) {…}

is_inf_array :: proc "contextless" (x: $A/[0]$T) -> (out: [0]bool) {…}

is_inf_single :: proc "contextless" (x: $T) -> bool {…}

is_nan_array :: proc "contextless" (x: $A/[0]$T) -> (out: [0]bool) {…}

is_nan_single :: proc "contextless" (x: $T) -> bool {…}

lerp :: proc "contextless" (a, b, t: $T) -> (out: $T) {…}

less_than_array :: proc "contextless" (x, y: $A/[0]$T) -> (out: [0]bool) {…}

less_than_equal_array :: proc "contextless" (x, y: $A/[0]$T) -> (out: [0]bool) {…}

less_than_equal_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

less_than_single :: proc "contextless" (x, y: $T) -> (out: bool) {…}

ln :: proc "contextless" (x: $T) -> (out: $T) {…}

log :: proc "contextless" (x, b: $T) -> (out: $T) {…}

log10 :: proc "contextless" (x: $T) -> (out: $T) {…}

log2 :: proc "contextless" (x: $T) -> (out: $T) {…}

matrix1x1_adjugate :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: $M/matrix[1, 1]$T) {…}

matrix1x1_cofactor :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: $M/matrix[1, 1]$T) {…}

matrix1x1_determinant :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: $T) {…}

matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: $M/matrix[1, 1]$T) {…}

matrix1x1_inverse_transpose :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: $M/matrix[1, 1]$T) {…}

matrix2_adjoint_f16 :: proc "contextless" (m: matrix[2, 2]f16) -> (c: matrix[2, 2]f16) {…}

matrix2_adjoint_f32 :: proc "contextless" (m: matrix[2, 2]f32) -> (c: matrix[2, 2]f32) {…}

matrix2_adjoint_f64 :: proc "contextless" (m: matrix[2, 2]f64) -> (c: matrix[2, 2]f64) {…}

matrix2_determinant_f16 :: proc "contextless" (m: matrix[2, 2]f16) -> f16 {…}

matrix2_determinant_f32 :: proc "contextless" (m: matrix[2, 2]f32) -> f32 {…}

matrix2_determinant_f64 :: proc "contextless" (m: matrix[2, 2]f64) -> f64 {…}

matrix2_from_matrix3_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (r: matrix[2, 2]f16) {…}

matrix2_from_matrix3_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (r: matrix[2, 2]f32) {…}

matrix2_from_matrix3_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (r: matrix[2, 2]f64) {…}

matrix2_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (r: matrix[2, 2]f16) {…}

matrix2_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (r: matrix[2, 2]f32) {…}

matrix2_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (r: matrix[2, 2]f64) {…}

matrix2_from_scalar_f16 :: proc "contextless" (f: f16) -> (m: matrix[2, 2]f16) {…}

matrix2_from_scalar_f32 :: proc "contextless" (f: f32) -> (m: matrix[2, 2]f32) {…}

matrix2_from_scalar_f64 :: proc "contextless" (f: f64) -> (m: matrix[2, 2]f64) {…}

matrix2_inverse_f16 :: proc "contextless" (m: matrix[2, 2]f16) -> (c: matrix[2, 2]f16) {…}

matrix2_inverse_f32 :: proc "contextless" (m: matrix[2, 2]f32) -> (c: matrix[2, 2]f32) {…}

matrix2_inverse_f64 :: proc "contextless" (m: matrix[2, 2]f64) -> (c: matrix[2, 2]f64) {…}

matrix2_inverse_transpose_f16 :: proc "contextless" (m: matrix[2, 2]f16) -> (c: matrix[2, 2]f16) {…}

matrix2_inverse_transpose_f32 :: proc "contextless" (m: matrix[2, 2]f32) -> (c: matrix[2, 2]f32) {…}

matrix2_inverse_transpose_f64 :: proc "contextless" (m: matrix[2, 2]f64) -> (c: matrix[2, 2]f64) {…}

matrix2_orthonormalize_f16 :: proc "contextless" (m: matrix[2, 2]f16) -> (r: matrix[2, 2]f16) {…}

matrix2_orthonormalize_f32 :: proc "contextless" (m: matrix[2, 2]f32) -> (r: matrix[2, 2]f32) {…}

matrix2_orthonormalize_f64 :: proc "contextless" (m: matrix[2, 2]f64) -> (r: matrix[2, 2]f64) {…}

matrix2_rotate_f16 :: proc "contextless" (angle_radians: f16) -> matrix[2, 2]f16 {…}

matrix2_rotate_f32 :: proc "contextless" (angle_radians: f32) -> matrix[2, 2]f32 {…}

matrix2_rotate_f64 :: proc "contextless" (angle_radians: f64) -> matrix[2, 2]f64 {…}

matrix2x2_adjugate :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: $M/matrix[2, 2]$T) {…}

matrix2x2_cofactor :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: $M/matrix[2, 2]$T) {…}

matrix2x2_determinant :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: $T) {…}

matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: $M/matrix[2, 2]$T) {…}

matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: $M/matrix[2, 2]$T) {…}

matrix3_adjoint_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> (adjoint: matrix[3, 3]f16) {…}

matrix3_adjoint_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> (adjoint: matrix[3, 3]f32) {…}

matrix3_adjoint_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> (adjoint: matrix[3, 3]f64) {…}

matrix3_determinant_f16 :: proc "contextless" (m: matrix[3, 3]f16) -> f16 {…}

matrix3_determinant_f32 :: proc "contextless" (m: matrix[3, 3]f32) -> f32 {…}

matrix3_determinant_f64 :: proc "contextless" (m: matrix[3, 3]f64) -> f64 {…}

matrix3_from_derived_euler_angle_x_f16 :: proc "contextless" (angle_x: f16, angular_velocity_x: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_derived_euler_angle_x_f32 :: proc "contextless" (angle_x: f32, angular_velocity_x: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_derived_euler_angle_x_f64 :: proc "contextless" (angle_x: f64, angular_velocity_x: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_derived_euler_angle_y_f16 :: proc "contextless" (angle_y: f16, angular_velocity_y: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_derived_euler_angle_y_f32 :: proc "contextless" (angle_y: f32, angular_velocity_y: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_derived_euler_angle_y_f64 :: proc "contextless" (angle_y: f64, angular_velocity_y: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_derived_euler_angle_z_f16 :: proc "contextless" (angle_z: f16, angular_velocity_z: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_derived_euler_angle_z_f32 :: proc "contextless" (angle_z: f32, angular_velocity_z: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_derived_euler_angle_z_f64 :: proc "contextless" (angle_z: f64, angular_velocity_z: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angle_x_f16 :: proc "contextless" (angle_x: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angle_x_f32 :: proc "contextless" (angle_x: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angle_x_f64 :: proc "contextless" (angle_x: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angle_y_f16 :: proc "contextless" (angle_y: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angle_y_f32 :: proc "contextless" (angle_y: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angle_y_f64 :: proc "contextless" (angle_y: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angle_z_f16 :: proc "contextless" (angle_z: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angle_z_f32 :: proc "contextless" (angle_z: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angle_z_f64 :: proc "contextless" (angle_z: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angles_f16 :: proc "contextless" (t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angles_f32 :: proc "contextless" (t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angles_f64 :: proc "contextless" (t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angles_xy_f16 :: proc "contextless" (angle_x, angle_y: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angles_xy_f32 :: proc "contextless" (angle_x, angle_y: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angles_xy_f64 :: proc "contextless" (angle_x, angle_y: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angles_xyx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angles_xyx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angles_xyx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angles_xyz_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angles_xyz_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angles_xyz_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angles_xz_f16 :: proc "contextless" (angle_x, angle_z: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angles_xz_f32 :: proc "contextless" (angle_x, angle_z: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angles_xz_f64 :: proc "contextless" (angle_x, angle_z: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angles_xzx_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: matrix[3, 3]f16) {…}

matrix3_from_euler_angles_xzx_f32 :: proc "contextless" (t1, t2, t3: f32) -> (m: matrix[3, 3]f32) {…}

matrix3_from_euler_angles_xzx_f64 :: proc "contextless" (t1, t2, t3: f64) -> (m: matrix[3, 3]f64) {…}

matrix3_from_euler_angles_xzy_f16 :: proc "contextless" (t1, t2, t3: f16) -> (m: matrix[3, 3]f16) {…}