package core:math/linalg
Source

⌘K
Ctrl+K
or
/

    Overview

    core:math/linalg implements linear algebra procedures useful for 3D spatial transformations

    Index

    Types (77)
    Variables (0)

    This section is empty.

    Procedures (666)
    Procedure Groups (212)

    Types

    Euler_Angle_Order ¶
    Source

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

    Matrix1f16 ¶
    Source

    Matrix1f16 :: matrix[1, 1]f16
    Related Constants

    Matrix1f32 ¶
    Source

    Matrix1f32 :: matrix[1, 1]f32
    Related Constants

    Matrix1f64 ¶
    Source

    Matrix1f64 :: matrix[1, 1]f64
    Related Constants

    Matrix1x1f16 ¶
    Source

    Matrix1x1f16 :: matrix[1, 1]f16
    Related Constants

    Matrix1x1f32 ¶
    Source

    Matrix1x1f32 :: matrix[1, 1]f32
    Related Constants

    Matrix1x1f64 ¶
    Source

    Matrix1x1f64 :: matrix[1, 1]f64
    Related Constants

    Matrix1x2f16 ¶
    Source

    Matrix1x2f16 :: matrix[1, 2]f16

    Matrix1x2f32 ¶
    Source

    Matrix1x2f32 :: matrix[1, 2]f32

    Matrix1x2f64 ¶
    Source

    Matrix1x2f64 :: matrix[1, 2]f64

    Matrix1x3f16 ¶
    Source

    Matrix1x3f16 :: matrix[1, 3]f16

    Matrix1x3f32 ¶
    Source

    Matrix1x3f32 :: matrix[1, 3]f32

    Matrix1x3f64 ¶
    Source

    Matrix1x3f64 :: matrix[1, 3]f64

    Matrix1x4f16 ¶
    Source

    Matrix1x4f16 :: matrix[1, 4]f16

    Matrix1x4f32 ¶
    Source

    Matrix1x4f32 :: matrix[1, 4]f32

    Matrix1x4f64 ¶
    Source

    Matrix1x4f64 :: matrix[1, 4]f64

    Matrix2f16 ¶
    Source

    Matrix2f16 :: matrix[2, 2]f16
    Related Constants

    Matrix2f32 ¶
    Source

    Matrix2f32 :: matrix[2, 2]f32
    Related Constants

    Matrix2f64 ¶
    Source

    Matrix2f64 :: matrix[2, 2]f64
    Related Constants

    Matrix2x1f16 ¶
    Source

    Matrix2x1f16 :: matrix[2, 1]f16

    Matrix2x1f32 ¶
    Source

    Matrix2x1f32 :: matrix[2, 1]f32

    Matrix2x1f64 ¶
    Source

    Matrix2x1f64 :: matrix[2, 1]f64

    Matrix2x2f16 ¶
    Source

    Matrix2x2f16 :: matrix[2, 2]f16
    Related Constants

    Matrix2x2f32 ¶
    Source

    Matrix2x2f32 :: matrix[2, 2]f32
    Related Constants

    Matrix2x2f64 ¶
    Source

    Matrix2x2f64 :: matrix[2, 2]f64
    Related Constants

    Matrix2x3f16 ¶
    Source

    Matrix2x3f16 :: matrix[2, 3]f16

    Matrix2x3f32 ¶
    Source

    Matrix2x3f32 :: matrix[2, 3]f32

    Matrix2x3f64 ¶
    Source

    Matrix2x3f64 :: matrix[2, 3]f64

    Matrix2x4f16 ¶
    Source

    Matrix2x4f16 :: matrix[2, 4]f16

    Matrix2x4f32 ¶
    Source

    Matrix2x4f32 :: matrix[2, 4]f32

    Matrix2x4f64 ¶
    Source

    Matrix2x4f64 :: matrix[2, 4]f64

    Matrix3f16 ¶
    Source

    Matrix3f16 :: matrix[3, 3]f16
    Related Constants

    Matrix3f32 ¶
    Source

    Matrix3f32 :: matrix[3, 3]f32
    Related Constants

    Matrix3f64 ¶
    Source

    Matrix3f64 :: matrix[3, 3]f64
    Related Constants

    Matrix3x1f16 ¶
    Source

    Matrix3x1f16 :: matrix[3, 1]f16

    Matrix3x1f32 ¶
    Source

    Matrix3x1f32 :: matrix[3, 1]f32

    Matrix3x1f64 ¶
    Source

    Matrix3x1f64 :: matrix[3, 1]f64

    Matrix3x2f16 ¶
    Source

    Matrix3x2f16 :: matrix[3, 2]f16

    Matrix3x2f32 ¶
    Source

    Matrix3x2f32 :: matrix[3, 2]f32

    Matrix3x2f64 ¶
    Source

    Matrix3x2f64 :: matrix[3, 2]f64

    Matrix3x3f16 ¶
    Source

    Matrix3x3f16 :: matrix[3, 3]f16
    Related Constants

    Matrix3x3f32 ¶
    Source

    Matrix3x3f32 :: matrix[3, 3]f32
    Related Constants

    Matrix3x3f64 ¶
    Source

    Matrix3x3f64 :: matrix[3, 3]f64
    Related Constants

    Matrix3x4f16 ¶
    Source

    Matrix3x4f16 :: matrix[3, 4]f16

    Matrix3x4f32 ¶
    Source

    Matrix3x4f32 :: matrix[3, 4]f32

    Matrix3x4f64 ¶
    Source

    Matrix3x4f64 :: matrix[3, 4]f64

    Matrix4f16 ¶
    Source

    Matrix4f16 :: matrix[4, 4]f16
    Related Constants

    Matrix4f32 ¶
    Source

    Matrix4f32 :: matrix[4, 4]f32
    Related Constants

    Matrix4f64 ¶
    Source

    Matrix4f64 :: matrix[4, 4]f64
    Related Constants

    Matrix4x1f16 ¶
    Source

    Matrix4x1f16 :: matrix[4, 1]f16

    Matrix4x1f32 ¶
    Source

    Matrix4x1f32 :: matrix[4, 1]f32

    Matrix4x1f64 ¶
    Source

    Matrix4x1f64 :: matrix[4, 1]f64

    Matrix4x2f16 ¶
    Source

    Matrix4x2f16 :: matrix[4, 2]f16

    Matrix4x2f32 ¶
    Source

    Matrix4x2f32 :: matrix[4, 2]f32

    Matrix4x2f64 ¶
    Source

    Matrix4x2f64 :: matrix[4, 2]f64

    Matrix4x3f16 ¶
    Source

    Matrix4x3f16 :: matrix[4, 3]f16

    Matrix4x3f32 ¶
    Source

    Matrix4x3f32 :: matrix[4, 3]f32

    Matrix4x3f64 ¶
    Source

    Matrix4x3f64 :: matrix[4, 3]f64

    Matrix4x4f16 ¶
    Source

    Matrix4x4f16 :: matrix[4, 4]f16
    Related Constants

    Matrix4x4f32 ¶
    Source

    Matrix4x4f32 :: matrix[4, 4]f32
    Related Constants

    Matrix4x4f64 ¶
    Source

    Matrix4x4f64 :: matrix[4, 4]f64
    Related Constants

    Quaternionf16 ¶
    Source

    Quaternionf16 :: quaternion64

    Quaternionf32 ¶
    Source

    Quaternionf32 :: quaternion128

    Quaternionf64 ¶
    Source

    Quaternionf64 :: quaternion256

    Scalar_Components ¶
    Source

    Scalar_Components :: enum u8 {
	x = 0, 
	r = 0, 
}
    Related Procedures With Parameters

    Vector2_Components ¶
    Source

    Vector2_Components :: enum u8 {
	x = 0, 
	y = 1, 
	r = 0, 
	g = 1, 
}
    Related Procedures With Parameters

    Vector2f16 ¶
    Source

    Vector2f16 :: [2]f16

    Vector2f32 ¶
    Source

    Vector2f32 :: [2]f32

    Vector2f64 ¶
    Source

    Vector2f64 :: [2]f64

    Vector3_Components ¶
    Source

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

    Vector3f16 ¶
    Source

    Vector3f16 :: [3]f16
    Related Constants

    Vector3f32 ¶
    Source

    Vector3f32 :: [3]f32
    Related Constants

    Vector3f64 ¶
    Source

    Vector3f64 :: [3]f64
    Related Constants

    Vector4_Components ¶
    Source

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

    Vector4f16 ¶
    Source

    Vector4f16 :: [4]f16

    Vector4f32 ¶
    Source

    Vector4f32 :: [4]f32

    Vector4f64 ¶
    Source

    Vector4f64 :: [4]f64

    Constants

    DEG_PER_RAD ¶
    Source

    DEG_PER_RAD :: 360.0 / TAU

    E ¶
    Source

    E :: 2.71828182845904523536

    F16_EPSILON ¶
    Source

    F16_EPSILON :: 1e-3

    F32_EPSILON ¶
    Source

    F32_EPSILON :: 1e-7

    F64_EPSILON ¶
    Source

    F64_EPSILON :: 1e-15

    LN10 ¶
    Source

    LN10 :: 2.30258509299404568401799145468436421

    LN2 ¶
    Source

    LN2 :: 0.693147180559945309417232121458176568

    MATRIX1F16_IDENTITY ¶
    Source

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

    MATRIX1F32_IDENTITY ¶
    Source

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

    MATRIX1F64_IDENTITY ¶
    Source

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

    MATRIX2F16_IDENTITY ¶
    Source

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

    MATRIX2F32_IDENTITY ¶
    Source

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

    MATRIX2F64_IDENTITY ¶
    Source

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

    MATRIX3F16_IDENTITY ¶
    Source

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

    MATRIX3F32_IDENTITY ¶
    Source

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

    MATRIX3F64_IDENTITY ¶
    Source

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

    MATRIX4F16_IDENTITY ¶
    Source

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

    MATRIX4F32_IDENTITY ¶
    Source

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

    MATRIX4F64_IDENTITY ¶
    Source

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

    MAX_F32_PRECISION ¶
    Source

    MAX_F32_PRECISION :: 8
     

    Maximum number of meaningful digits after the decimal point for 'f32'

    MAX_F64_PRECISION ¶
    Source

    MAX_F64_PRECISION :: 16
     

    Maximum number of meaningful digits after the decimal point for 'f64'

    PI ¶
    Source

    PI :: 3.14159265358979323846264338327950288

    QUATERNIONF16_IDENTITY ¶
    Source

    QUATERNIONF16_IDENTITY: quaternion64 : Quaternionf16(1)

    QUATERNIONF32_IDENTITY ¶
    Source

    QUATERNIONF32_IDENTITY: quaternion128 : Quaternionf32(1)

    QUATERNIONF64_IDENTITY ¶
    Source

    QUATERNIONF64_IDENTITY: quaternion256 : Quaternionf64(1)

    RAD_PER_DEG ¶
    Source

    RAD_PER_DEG :: TAU / 360.0

    SQRT_FIVE ¶
    Source

    SQRT_FIVE :: 2.23606797749978969640917366873127623

    SQRT_THREE ¶
    Source

    SQRT_THREE :: 1.73205080756887729352744634150587236

    SQRT_TWO ¶
    Source

    SQRT_TWO :: 1.41421356237309504880168872420969808

    TAU ¶
    Source

    TAU :: 6.28318530717958647692528676655900576

    VECTOR3F16_X_AXIS ¶
    Source

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

    VECTOR3F16_Y_AXIS ¶
    Source

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

    VECTOR3F16_Z_AXIS ¶
    Source

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

    VECTOR3F32_X_AXIS ¶
    Source

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

    VECTOR3F32_Y_AXIS ¶
    Source

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

    VECTOR3F32_Z_AXIS ¶
    Source

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

    VECTOR3F64_X_AXIS ¶
    Source

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

    VECTOR3F64_Y_AXIS ¶
    Source

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

    VECTOR3F64_Z_AXIS ¶
    Source

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

    e ¶
    Source

    e :: E

    π ¶
    Source

    π :: PI

    τ ¶
    Source

    τ :: TAU

    Variables

    This section is empty.

    Procedures

    abs ¶
    Source

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

    acos ¶
    Source

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

    all ¶
    Source

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

    angle_axis_from_quaternion_f16 ¶
    Source

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

    angle_axis_from_quaternion_f32 ¶
    Source

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

    angle_axis_from_quaternion_f64 ¶
    Source

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

    angle_from_quaternion_f16 ¶
    Source

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

    angle_from_quaternion_f32 ¶
    Source

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

    angle_from_quaternion_f64 ¶
    Source

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

    any ¶
    Source

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

    array_cast ¶
    Source

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

    asin ¶
    Source

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

    atan ¶
    Source

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

    atan2 ¶
    Source

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

    axis_from_quaternion_f16 ¶
    Source

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

    axis_from_quaternion_f32 ¶
    Source

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

    axis_from_quaternion_f64 ¶
    Source

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

    catmull_rom ¶
    Source

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

    ceil ¶
    Source

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

    clamp ¶
    Source

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

    classify_array ¶
    Source

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

    classify_single ¶
    Source

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

    cos ¶
    Source

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

    cubic ¶
    Source

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

    distance ¶
    Source

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

    equal_array ¶
    Source

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

    equal_single ¶
    Source

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

    euclidean_from_polar_f16 ¶
    Source

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

    euclidean_from_polar_f32 ¶
    Source

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

    euclidean_from_polar_f64 ¶
    Source

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

    euler_angles_from_matrix3_f16 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

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

    euler_angles_from_quaternion_f32 ¶
    Source

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

    euler_angles_from_quaternion_f64 ¶
    Source

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

    euler_angles_xyx_from_matrix3_f16 ¶
    Source

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

    euler_angles_xyx_from_matrix3_f32 ¶
    Source

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

    euler_angles_xyx_from_matrix3_f64 ¶
    Source

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

    euler_angles_xyx_from_matrix4_f16 ¶
    Source

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

    euler_angles_xyx_from_matrix4_f32 ¶
    Source

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

    euler_angles_xyx_from_matrix4_f64 ¶
    Source

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

    euler_angles_xyx_from_quaternion_f16 ¶
    Source

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

    euler_angles_xyx_from_quaternion_f32 ¶
    Source

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

    euler_angles_xyx_from_quaternion_f64 ¶
    Source

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

    euler_angles_xyz_from_matrix3_f16 ¶
    Source

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

    euler_angles_xyz_from_matrix3_f32 ¶
    Source

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

    euler_angles_xyz_from_matrix3_f64 ¶
    Source

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

    euler_angles_xyz_from_matrix4_f16 ¶
    Source

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

    euler_angles_xyz_from_matrix4_f32 ¶
    Source

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

    euler_angles_xyz_from_matrix4_f64 ¶
    Source

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

    euler_angles_xyz_from_quaternion_f16 ¶
    Source

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

    euler_angles_xyz_from_quaternion_f32 ¶
    Source

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

    euler_angles_xyz_from_quaternion_f64 ¶
    Source

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

    euler_angles_xzx_from_matrix3_f16 ¶
    Source

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

    euler_angles_xzx_from_matrix3_f32 ¶
    Source

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

    euler_angles_xzx_from_matrix3_f64 ¶
    Source

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

    euler_angles_xzx_from_matrix4_f16 ¶
    Source

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

    euler_angles_xzx_from_matrix4_f32 ¶
    Source

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

    euler_angles_xzx_from_matrix4_f64 ¶
    Source

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

    euler_angles_xzx_from_quaternion_f16 ¶
    Source

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

    euler_angles_xzx_from_quaternion_f32 ¶
    Source

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

    euler_angles_xzx_from_quaternion_f64 ¶
    Source

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

    euler_angles_xzy_from_matrix3_f16 ¶
    Source

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

    euler_angles_xzy_from_matrix3_f32 ¶
    Source

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

    euler_angles_xzy_from_matrix3_f64 ¶
    Source

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

    euler_angles_xzy_from_matrix4_f16 ¶
    Source

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

    euler_angles_xzy_from_matrix4_f32 ¶
    Source

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

    euler_angles_xzy_from_matrix4_f64 ¶
    Source

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

    euler_angles_xzy_from_quaternion_f16 ¶
    Source

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

    euler_angles_xzy_from_quaternion_f32 ¶
    Source

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

    euler_angles_xzy_from_quaternion_f64 ¶
    Source

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

    euler_angles_yxy_from_matrix3_f16 ¶
    Source

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

    euler_angles_yxy_from_matrix3_f32 ¶
    Source

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

    euler_angles_yxy_from_matrix3_f64 ¶
    Source

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

    euler_angles_yxy_from_matrix4_f16 ¶
    Source

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

    euler_angles_yxy_from_matrix4_f32 ¶
    Source

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

    euler_angles_yxy_from_matrix4_f64 ¶
    Source

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

    euler_angles_yxy_from_quaternion_f16 ¶
    Source

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

    euler_angles_yxy_from_quaternion_f32 ¶
    Source

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

    euler_angles_yxy_from_quaternion_f64 ¶
    Source

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

    euler_angles_yxz_from_matrix3_f16 ¶
    Source

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

    euler_angles_yxz_from_matrix3_f32 ¶
    Source

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

    euler_angles_yxz_from_matrix3_f64 ¶
    Source

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

    euler_angles_yxz_from_matrix4_f16 ¶
    Source

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

    euler_angles_yxz_from_matrix4_f32 ¶
    Source

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

    euler_angles_yxz_from_matrix4_f64 ¶
    Source

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

    euler_angles_yxz_from_quaternion_f16 ¶
    Source

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

    euler_angles_yxz_from_quaternion_f32 ¶
    Source

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

    euler_angles_yxz_from_quaternion_f64 ¶
    Source

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

    euler_angles_yzx_from_matrix3_f16 ¶
    Source

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

    euler_angles_yzx_from_matrix3_f32 ¶
    Source

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

    euler_angles_yzx_from_matrix3_f64 ¶
    Source

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

    euler_angles_yzx_from_matrix4_f16 ¶
    Source

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

    euler_angles_yzx_from_matrix4_f32 ¶
    Source

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

    euler_angles_yzx_from_matrix4_f64 ¶
    Source

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

    euler_angles_yzx_from_quaternion_f16 ¶
    Source

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

    euler_angles_yzx_from_quaternion_f32 ¶
    Source

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

    euler_angles_yzx_from_quaternion_f64 ¶
    Source

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

    euler_angles_yzy_from_matrix3_f16 ¶
    Source

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

    euler_angles_yzy_from_matrix3_f32 ¶
    Source

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

    euler_angles_yzy_from_matrix3_f64 ¶
    Source

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

    euler_angles_yzy_from_matrix4_f16 ¶
    Source

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

    euler_angles_yzy_from_matrix4_f32 ¶
    Source

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

    euler_angles_yzy_from_matrix4_f64 ¶
    Source

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

    euler_angles_yzy_from_quaternion_f16 ¶
    Source

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

    euler_angles_yzy_from_quaternion_f32 ¶
    Source

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

    euler_angles_yzy_from_quaternion_f64 ¶
    Source

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

    euler_angles_zxy_from_matrix3_f16 ¶
    Source

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

    euler_angles_zxy_from_matrix3_f32 ¶
    Source

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

    euler_angles_zxy_from_matrix3_f64 ¶
    Source

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

    euler_angles_zxy_from_matrix4_f16 ¶
    Source

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

    euler_angles_zxy_from_matrix4_f32 ¶
    Source

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

    euler_angles_zxy_from_matrix4_f64 ¶
    Source

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

    euler_angles_zxy_from_quaternion_f16 ¶
    Source

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

    euler_angles_zxy_from_quaternion_f32 ¶
    Source

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

    euler_angles_zxy_from_quaternion_f64 ¶
    Source

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

    euler_angles_zxz_from_matrix3_f16 ¶
    Source

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

    euler_angles_zxz_from_matrix3_f32 ¶
    Source

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

    euler_angles_zxz_from_matrix3_f64 ¶
    Source

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

    euler_angles_zxz_from_matrix4_f16 ¶
    Source

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

    euler_angles_zxz_from_matrix4_f32 ¶
    Source

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

    euler_angles_zxz_from_matrix4_f64 ¶
    Source

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

    euler_angles_zxz_from_quaternion_f16 ¶
    Source

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

    euler_angles_zxz_from_quaternion_f32 ¶
    Source

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

    euler_angles_zxz_from_quaternion_f64 ¶
    Source

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

    euler_angles_zyx_from_matrix3_f16 ¶
    Source

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

    euler_angles_zyx_from_matrix3_f32 ¶
    Source

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

    euler_angles_zyx_from_matrix3_f64 ¶
    Source

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

    euler_angles_zyx_from_matrix4_f16 ¶
    Source

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

    euler_angles_zyx_from_matrix4_f32 ¶
    Source

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

    euler_angles_zyx_from_matrix4_f64 ¶
    Source

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

    euler_angles_zyx_from_quaternion_f16 ¶
    Source

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

    euler_angles_zyx_from_quaternion_f32 ¶
    Source

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

    euler_angles_zyx_from_quaternion_f64 ¶
    Source

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

    euler_angles_zyz_from_matrix3_f16 ¶
    Source

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

    euler_angles_zyz_from_matrix3_f32 ¶
    Source

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

    euler_angles_zyz_from_matrix3_f64 ¶
    Source

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

    euler_angles_zyz_from_matrix4_f16 ¶
    Source

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

    euler_angles_zyz_from_matrix4_f32 ¶
    Source

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

    euler_angles_zyz_from_matrix4_f64 ¶
    Source

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

    euler_angles_zyz_from_quaternion_f16 ¶
    Source

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

    euler_angles_zyz_from_quaternion_f32 ¶
    Source

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

    euler_angles_zyz_from_quaternion_f64 ¶
    Source

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

    exp ¶
    Source

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

    exp10 ¶
    Source

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

    exp2 ¶
    Source

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

    face_forward ¶
    Source

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

    floor ¶
    Source

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

    fract ¶
    Source

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

    greater_than_array ¶
    Source

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

    greater_than_equal_array ¶
    Source

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

    greater_than_equal_single ¶
    Source

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

    greater_than_single ¶
    Source

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

    hadamard_product ¶

    hadamard_product :: intrinsics.hadamard_product

    hermite ¶
    Source

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

    hermitian_adjoint ¶
    Source

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

    identity_array_based_matrix ¶
    Source

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

    identity_matrix ¶
    Source

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

    inverse_sqrt ¶
    Source

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

    is_inf_array ¶
    Source

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

    is_inf_single ¶
    Source

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

    is_nan_array ¶
    Source

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

    is_nan_single ¶
    Source

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

    lerp ¶
    Source

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

    less_than_array ¶
    Source

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

    less_than_equal_array ¶
    Source

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

    less_than_equal_single ¶
    Source

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

    less_than_single ¶
    Source

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

    ln ¶
    Source

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

    log ¶
    Source

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

    log10 ¶
    Source

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

    log2 ¶
    Source

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

    matrix1x1_adjugate ¶
    Source

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

    matrix1x1_determinant ¶
    Source

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

    matrix1x1_inverse ¶
    Source

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

    matrix1x1_inverse_transpose ¶
    Source

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

    matrix2_adjoint_f16 ¶
    Source

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

    matrix2_adjoint_f32 ¶
    Source

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

    matrix2_adjoint_f64 ¶
    Source

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

    matrix2_determinant_f16 ¶
    Source

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

    matrix2_determinant_f32 ¶
    Source

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

    matrix2_determinant_f64 ¶
    Source

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

    matrix2_from_matrix3_f16 ¶
    Source

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

    matrix2_from_matrix3_f32 ¶
    Source

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

    matrix2_from_matrix3_f64 ¶
    Source

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

    matrix2_from_matrix4_f16 ¶
    Source

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

    matrix2_from_matrix4_f32 ¶
    Source

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

    matrix2_from_matrix4_f64 ¶
    Source

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

    matrix2_from_scalar_f16 ¶
    Source

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

    matrix2_from_scalar_f32 ¶
    Source

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

    matrix2_from_scalar_f64 ¶
    Source

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

    matrix2_inverse_f16 ¶
    Source

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

    matrix2_inverse_f32 ¶
    Source

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

    matrix2_inverse_f64 ¶
    Source

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

    matrix2_inverse_transpose_f16 ¶
    Source

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

    matrix2_inverse_transpose_f32 ¶
    Source

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

    matrix2_inverse_transpose_f64 ¶
    Source

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

    matrix2_orthonormalize_f16 ¶
    Source

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

    matrix2_orthonormalize_f32 ¶
    Source

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

    matrix2_orthonormalize_f64 ¶
    Source

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

    matrix2_rotate_f16 ¶
    Source

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

    matrix2_rotate_f32 ¶
    Source

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

    matrix2_rotate_f64 ¶
    Source

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

    matrix2x2_adjugate ¶
    Source

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

    matrix2x2_determinant ¶
    Source

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

    matrix2x2_inverse ¶
    Source

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

    matrix2x2_inverse_transpose ¶
    Source

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

    matrix3_adjoint_f16 ¶
    Source

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

    matrix3_adjoint_f32 ¶
    Source

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

    matrix3_adjoint_f64 ¶
    Source

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

    matrix3_determinant_f16 ¶
    Source

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

    matrix3_determinant_f32 ¶
    Source

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

    matrix3_determinant_f64 ¶
    Source

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

    matrix3_from_derived_euler_angle_x_f16 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

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

    matrix3_from_euler_angle_x_f32 ¶
    Source

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

    matrix3_from_euler_angle_x_f64 ¶
    Source

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

    matrix3_from_euler_angle_y_f16 ¶
    Source

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

    matrix3_from_euler_angle_y_f32 ¶
    Source

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

    matrix3_from_euler_angle_y_f64 ¶
    Source

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

    matrix3_from_euler_angle_z_f16 ¶
    Source

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

    matrix3_from_euler_angle_z_f32 ¶
    Source

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

    matrix3_from_euler_angle_z_f64 ¶
    Source

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

    matrix3_from_euler_angles_f16 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

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

    matrix3_from_euler_angles_xy_f32 ¶
    Source

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

    matrix3_from_euler_angles_xy_f64 ¶
    Source

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

    matrix3_from_euler_angles_xyx_f16 ¶
    Source

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

    matrix3_from_euler_angles_xyx_f32 ¶
    Source

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

    matrix3_from_euler_angles_xyx_f64 ¶
    Source

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

    matrix3_from_euler_angles_xyz_f16 ¶
    Source

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

    matrix3_from_euler_angles_xyz_f32 ¶
    Source

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

    matrix3_from_euler_angles_xyz_f64 ¶
    Source

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

    matrix3_from_euler_angles_xz_f16 ¶
    Source

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

    matrix3_from_euler_angles_xz_f32 ¶
    Source

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

    matrix3_from_euler_angles_xz_f64 ¶
    Source

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

    matrix3_from_euler_angles_xzx_f16 ¶
    Source

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

    matrix3_from_euler_angles_xzx_f32 ¶
    Source

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

    matrix3_from_euler_angles_xzx_f64 ¶
    Source

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

    matrix3_from_euler_angles_xzy_f16 ¶
    Source

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

    matrix3_from_euler_angles_xzy_f32 ¶
    Source

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

    matrix3_from_euler_angles_xzy_f64 ¶
    Source

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

    matrix3_from_euler_angles_yx_f16 ¶
    Source

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

    matrix3_from_euler_angles_yx_f32 ¶
    Source

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

    matrix3_from_euler_angles_yx_f64 ¶
    Source

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

    matrix3_from_euler_angles_yxy_f16 ¶
    Source

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

    matrix3_from_euler_angles_yxy_f32 ¶
    Source

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

    matrix3_from_euler_angles_yxy_f64 ¶
    Source

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

    matrix3_from_euler_angles_yxz_f16 ¶
    Source

    matrix3_from_euler_angles_yxz_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: matrix[3, 3]f16) {…}

    matrix3_from_euler_angles_yxz_f32 ¶
    Source

    matrix3_from_euler_angles_yxz_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: matrix[3, 3]f32) {…}

    matrix3_from_euler_angles_yxz_f64 ¶
    Source

    matrix3_from_euler_angles_yxz_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: matrix[3, 3]f64) {…}

    matrix3_from_euler_angles_yz_f16 ¶
    Source

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

    matrix3_from_euler_angles_yz_f32 ¶
    Source

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

    matrix3_from_euler_angles_yz_f64 ¶
    Source

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

    matrix3_from_euler_angles_yzx_f16 ¶
    Source

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

    matrix3_from_euler_angles_yzx_f32 ¶
    Source

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

    matrix3_from_euler_angles_yzx_f64 ¶
    Source

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

    matrix3_from_euler_angles_yzy_f16 ¶
    Source

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

    matrix3_from_euler_angles_yzy_f32 ¶
    Source

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

    matrix3_from_euler_angles_yzy_f64 ¶
    Source

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

    matrix3_from_euler_angles_zx_f16 ¶
    Source

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

    matrix3_from_euler_angles_zx_f32 ¶
    Source

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

    matrix3_from_euler_angles_zx_f64 ¶
    Source

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

    matrix3_from_euler_angles_zxy_f16 ¶
    Source

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

    matrix3_from_euler_angles_zxy_f32 ¶
    Source

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

    matrix3_from_euler_angles_zxy_f64 ¶
    Source

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

    matrix3_from_euler_angles_zxz_f16 ¶
    Source

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

    matrix3_from_euler_angles_zxz_f32 ¶
    Source

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

    matrix3_from_euler_angles_zxz_f64 ¶
    Source

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

    matrix3_from_euler_angles_zy_f16 ¶
    Source

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

    matrix3_from_euler_angles_zy_f32 ¶
    Source

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

    matrix3_from_euler_angles_zy_f64 ¶
    Source

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

    matrix3_from_euler_angles_zyx_f16 ¶
    Source

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

    matrix3_from_euler_angles_zyx_f32 ¶
    Source

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

    matrix3_from_euler_angles_zyx_f64 ¶
    Source

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

    matrix3_from_euler_angles_zyz_f16 ¶
    Source

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

    matrix3_from_euler_angles_zyz_f32 ¶
    Source

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

    matrix3_from_euler_angles_zyz_f64 ¶
    Source

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

    matrix3_from_matrix2_f16 ¶
    Source

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

    matrix3_from_matrix2_f32 ¶
    Source

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

    matrix3_from_matrix2_f64 ¶
    Source

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

    matrix3_from_matrix4_f16 ¶
    Source

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

    matrix3_from_matrix4_f32 ¶
    Source

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

    matrix3_from_matrix4_f64 ¶
    Source

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

    matrix3_from_quaternion_f16 ¶
    Source

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

    matrix3_from_quaternion_f32 ¶
    Source

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

    matrix3_from_quaternion_f64 ¶
    Source

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

    matrix3_from_scalar_f16 ¶
    Source

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

    matrix3_from_scalar_f32 ¶
    Source

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

    matrix3_from_scalar_f64 ¶
    Source

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

    matrix3_from_yaw_pitch_roll_f16 ¶
    Source

    matrix3_from_yaw_pitch_roll_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: matrix[3, 3]f16) {…}

    matrix3_from_yaw_pitch_roll_f32 ¶
    Source

    matrix3_from_yaw_pitch_roll_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: matrix[3, 3]f32) {…}

    matrix3_from_yaw_pitch_roll_f64 ¶
    Source

    matrix3_from_yaw_pitch_roll_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: matrix[3, 3]f64) {…}

    matrix3_inverse_f16 ¶
    Source

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

    matrix3_inverse_f32 ¶
    Source

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

    matrix3_inverse_f64 ¶
    Source

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

    matrix3_inverse_transpose_f16 ¶
    Source

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

    matrix3_inverse_transpose_f32 ¶
    Source

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

    matrix3_inverse_transpose_f64 ¶
    Source

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

    matrix3_look_at_f16 ¶
    Source

    matrix3_look_at_f16 :: proc "contextless" (eye, centre: [3]f16, up: [3]f16) -> matrix[3, 3]f16 {…}

    matrix3_look_at_f32 ¶
    Source

    matrix3_look_at_f32 :: proc "contextless" (eye, centre: [3]f32, up: [3]f32) -> matrix[3, 3]f32 {…}

    matrix3_look_at_f64 ¶
    Source

    matrix3_look_at_f64 :: proc "contextless" (eye, centre: [3]f64, up: [3]f64) -> matrix[3, 3]f64 {…}

    matrix3_orthonormalize_f16 ¶
    Source

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

    matrix3_orthonormalize_f32 ¶
    Source

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

    matrix3_orthonormalize_f64 ¶
    Source

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

    matrix3_rotate_f16 ¶
    Source

    matrix3_rotate_f16 :: proc "contextless" (angle_radians: f16, v: [3]f16) -> (rot: matrix[3, 3]f16) {…}

    matrix3_rotate_f32 ¶
    Source

    matrix3_rotate_f32 :: proc "contextless" (angle_radians: f32, v: [3]f32) -> (rot: matrix[3, 3]f32) {…}

    matrix3_rotate_f64 ¶
    Source

    matrix3_rotate_f64 :: proc "contextless" (angle_radians: f64, v: [3]f64) -> (rot: matrix[3, 3]f64) {…}

    matrix3_scale_f16 ¶
    Source

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

    matrix3_scale_f32 ¶
    Source

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

    matrix3_scale_f64 ¶
    Source

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

    matrix3x3_adjugate ¶
    Source

    matrix3x3_adjugate :: proc "contextless" (m: $A/matrix[3, 3]$T) -> (y: $A/matrix[3, 3]$T) {…}

    matrix3x3_determinant ¶
    Source

    matrix3x3_determinant :: proc "contextless" (m: $A/matrix[3, 3]$T) -> (det: $T) {…}

    matrix3x3_inverse ¶
    Source

    matrix3x3_inverse :: proc "contextless" (x: $A/matrix[3, 3]$T) -> (y: $A/matrix[3, 3]$T) {…}

    matrix3x3_inverse_transpose ¶
    Source

    matrix3x3_inverse_transpose :: proc "contextless" (x: $A/matrix[3, 3]$T) -> (y: $A/matrix[3, 3]$T) {…}

    matrix4_adjoint_f16 ¶
    Source

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

    matrix4_adjoint_f32 ¶
    Source

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

    matrix4_adjoint_f64 ¶
    Source

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

    matrix4_cofactor_f16 ¶
    Source

    matrix4_cofactor_f16 :: proc "contextless" (m: matrix[4, 4]f16, c, r: int) -> f16 {…}

    matrix4_cofactor_f32 ¶
    Source

    matrix4_cofactor_f32 :: proc "contextless" (m: matrix[4, 4]f32, c, r: int) -> f32 {…}

    matrix4_cofactor_f64 ¶
    Source

    matrix4_cofactor_f64 :: proc "contextless" (m: matrix[4, 4]f64, c, r: int) -> f64 {…}

    matrix4_determinant_f16 ¶
    Source

    matrix4_determinant_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (determinant: f16) {…}

    matrix4_determinant_f32 ¶
    Source

    matrix4_determinant_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (determinant: f32) {…}

    matrix4_determinant_f64 ¶
    Source

    matrix4_determinant_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (determinant: f64) {…}

    matrix4_from_derived_euler_angle_x_f16 ¶
    Source

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

    matrix4_from_derived_euler_angle_x_f32 ¶
    Source

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

    matrix4_from_derived_euler_angle_x_f64 ¶
    Source

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

    matrix4_from_derived_euler_angle_y_f16 ¶
    Source

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

    matrix4_from_derived_euler_angle_y_f32 ¶
    Source

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

    matrix4_from_derived_euler_angle_y_f64 ¶
    Source

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

    matrix4_from_derived_euler_angle_z_f16 ¶
    Source

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

    matrix4_from_derived_euler_angle_z_f32 ¶
    Source

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

    matrix4_from_derived_euler_angle_z_f64 ¶
    Source

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

    matrix4_from_euler_angle_x_f16 ¶
    Source

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

    matrix4_from_euler_angle_x_f32 ¶
    Source

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

    matrix4_from_euler_angle_x_f64 ¶
    Source

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

    matrix4_from_euler_angle_y_f16 ¶
    Source

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

    matrix4_from_euler_angle_y_f32 ¶
    Source

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

    matrix4_from_euler_angle_y_f64 ¶
    Source

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

    matrix4_from_euler_angle_z_f16 ¶
    Source

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

    matrix4_from_euler_angle_z_f32 ¶
    Source

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

    matrix4_from_euler_angle_z_f64 ¶
    Source

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

    matrix4_from_euler_angles_f16 ¶
    Source

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

    matrix4_from_euler_angles_f32 ¶
    Source

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

    matrix4_from_euler_angles_f64 ¶
    Source

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

    matrix4_from_euler_angles_xy_f16 ¶
    Source

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

    matrix4_from_euler_angles_xy_f32 ¶
    Source

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

    matrix4_from_euler_angles_xy_f64 ¶
    Source

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

    matrix4_from_euler_angles_xyx_f16 ¶
    Source

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

    matrix4_from_euler_angles_xyx_f32 ¶
    Source

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

    matrix4_from_euler_angles_xyx_f64 ¶
    Source

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

    matrix4_from_euler_angles_xyz_f16 ¶
    Source

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

    matrix4_from_euler_angles_xyz_f32 ¶
    Source

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

    matrix4_from_euler_angles_xyz_f64 ¶
    Source

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

    matrix4_from_euler_angles_xz_f16 ¶
    Source

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

    matrix4_from_euler_angles_xz_f32 ¶
    Source

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

    matrix4_from_euler_angles_xz_f64 ¶
    Source

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

    matrix4_from_euler_angles_xzx_f16 ¶
    Source

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

    matrix4_from_euler_angles_xzx_f32 ¶
    Source

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

    matrix4_from_euler_angles_xzx_f64 ¶
    Source

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

    matrix4_from_euler_angles_xzy_f16 ¶
    Source

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

    matrix4_from_euler_angles_xzy_f32 ¶
    Source

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

    matrix4_from_euler_angles_xzy_f64 ¶
    Source

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

    matrix4_from_euler_angles_yx_f16 ¶
    Source

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

    matrix4_from_euler_angles_yx_f32 ¶
    Source

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

    matrix4_from_euler_angles_yx_f64 ¶
    Source

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

    matrix4_from_euler_angles_yxy_f16 ¶
    Source

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

    matrix4_from_euler_angles_yxy_f32 ¶
    Source

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

    matrix4_from_euler_angles_yxy_f64 ¶
    Source

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

    matrix4_from_euler_angles_yxz_f16 ¶
    Source

    matrix4_from_euler_angles_yxz_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: matrix[4, 4]f16) {…}

    matrix4_from_euler_angles_yxz_f32 ¶
    Source

    matrix4_from_euler_angles_yxz_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: matrix[4, 4]f32) {…}

    matrix4_from_euler_angles_yxz_f64 ¶
    Source

    matrix4_from_euler_angles_yxz_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: matrix[4, 4]f64) {…}

    matrix4_from_euler_angles_yz_f16 ¶
    Source

    matrix4_from_euler_angles_yz_f16 :: proc "contextless" (angle_y, angle_z: f16) -> (m: matrix[4, 4]f16) {…}

    matrix4_from_euler_angles_yz_f32 ¶
    Source

    matrix4_from_euler_angles_yz_f32 :: proc "contextless" (angle_y, angle_z: f32) -> (m: matrix[4, 4]f32) {…}

    matrix4_from_euler_angles_yz_f64 ¶
    Source

    matrix4_from_euler_angles_yz_f64 :: proc "contextless" (angle_y, angle_z: f64) -> (m: matrix[4, 4]f64) {…}

    matrix4_from_euler_angles_yzx_f16 ¶
    Source

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

    matrix4_from_euler_angles_yzx_f32 ¶
    Source

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

    matrix4_from_euler_angles_yzx_f64 ¶
    Source

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

    matrix4_from_euler_angles_yzy_f16 ¶
    Source

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

    matrix4_from_euler_angles_yzy_f32 ¶
    Source

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

    matrix4_from_euler_angles_yzy_f64 ¶
    Source

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

    matrix4_from_euler_angles_zx_f16 ¶
    Source

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

    matrix4_from_euler_angles_zx_f32 ¶
    Source

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

    matrix4_from_euler_angles_zx_f64 ¶
    Source

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

    matrix4_from_euler_angles_zxy_f16 ¶
    Source

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

    matrix4_from_euler_angles_zxy_f32 ¶
    Source

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

    matrix4_from_euler_angles_zxy_f64 ¶
    Source

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

    matrix4_from_euler_angles_zxz_f16 ¶
    Source

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

    matrix4_from_euler_angles_zxz_f32 ¶
    Source

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

    matrix4_from_euler_angles_zxz_f64 ¶
    Source

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

    matrix4_from_euler_angles_zy_f16 ¶
    Source

    matrix4_from_euler_angles_zy_f16 :: proc "contextless" (angle_z, angle_y: f16) -> (m: matrix[4, 4]f16) {…}

    matrix4_from_euler_angles_zy_f32 ¶
    Source

    matrix4_from_euler_angles_zy_f32 :: proc "contextless" (angle_z, angle_y: f32) -> (m: matrix[4, 4]f32) {…}

    matrix4_from_euler_angles_zy_f64 ¶
    Source

    matrix4_from_euler_angles_zy_f64 :: proc "contextless" (angle_z, angle_y: f64) -> (m: matrix[4, 4]f64) {…}

    matrix4_from_euler_angles_zyx_f16 ¶
    Source

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

    matrix4_from_euler_angles_zyx_f32 ¶
    Source

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

    matrix4_from_euler_angles_zyx_f64 ¶
    Source

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

    matrix4_from_euler_angles_zyz_f16 ¶
    Source

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

    matrix4_from_euler_angles_zyz_f32 ¶
    Source

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

    matrix4_from_euler_angles_zyz_f64 ¶
    Source

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

    matrix4_from_matrix2_f16 ¶
    Source

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

    matrix4_from_matrix2_f32 ¶
    Source

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

    matrix4_from_matrix2_f64 ¶
    Source

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

    matrix4_from_matrix3_f16 ¶
    Source

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

    matrix4_from_matrix3_f32 ¶
    Source

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

    matrix4_from_matrix3_f64 ¶
    Source

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

    matrix4_from_quaternion_f16 ¶
    Source

    matrix4_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (m: matrix[4, 4]f16) {…}

    matrix4_from_quaternion_f32 ¶
    Source

    matrix4_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (m: matrix[4, 4]f32) {…}

    matrix4_from_quaternion_f64 ¶
    Source

    matrix4_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (m: matrix[4, 4]f64) {…}

    matrix4_from_scalar_f16 ¶
    Source

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

    matrix4_from_scalar_f32 ¶
    Source

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

    matrix4_from_scalar_f64 ¶
    Source

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

    matrix4_from_trs_f16 ¶
    Source

    matrix4_from_trs_f16 :: proc "contextless" (t: [3]f16, r: quaternion64, s: [3]f16) -> matrix[4, 4]f16 {…}

    matrix4_from_trs_f32 ¶
    Source

    matrix4_from_trs_f32 :: proc "contextless" (t: [3]f32, r: quaternion128, s: [3]f32) -> matrix[4, 4]f32 {…}

    matrix4_from_trs_f64 ¶
    Source

    matrix4_from_trs_f64 :: proc "contextless" (t: [3]f64, r: quaternion256, s: [3]f64) -> matrix[4, 4]f64 {…}

    matrix4_from_yaw_pitch_roll_f16 ¶
    Source

    matrix4_from_yaw_pitch_roll_f16 :: proc "contextless" (yaw, pitch, roll: f16) -> (m: matrix[4, 4]f16) {…}

    matrix4_from_yaw_pitch_roll_f32 ¶
    Source

    matrix4_from_yaw_pitch_roll_f32 :: proc "contextless" (yaw, pitch, roll: f32) -> (m: matrix[4, 4]f32) {…}

    matrix4_from_yaw_pitch_roll_f64 ¶
    Source

    matrix4_from_yaw_pitch_roll_f64 :: proc "contextless" (yaw, pitch, roll: f64) -> (m: matrix[4, 4]f64) {…}

    matrix4_infinite_perspective_f16 ¶
    Source

    matrix4_infinite_perspective_f16 :: proc "contextless" (fovy, aspect, near: f16, flip_z_axis: bool = true) -> (m: matrix[4, 4]f16) {…}

    matrix4_infinite_perspective_f32 ¶
    Source

    matrix4_infinite_perspective_f32 :: proc "contextless" (fovy, aspect, near: f32, flip_z_axis: bool = true) -> (m: matrix[4, 4]f32) {…}

    matrix4_infinite_perspective_f64 ¶
    Source

    matrix4_infinite_perspective_f64 :: proc "contextless" (fovy, aspect, near: f64, flip_z_axis: bool = true) -> (m: matrix[4, 4]f64) {…}

    matrix4_inverse_f16 ¶
    Source

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

    matrix4_inverse_f32 ¶
    Source

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

    matrix4_inverse_f64 ¶
    Source

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

    matrix4_inverse_transpose_f16 ¶
    Source

    matrix4_inverse_transpose_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (inverse_transpose: matrix[4, 4]f16) {…}

    matrix4_inverse_transpose_f32 ¶
    Source

    matrix4_inverse_transpose_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (inverse_transpose: matrix[4, 4]f32) {…}

    matrix4_inverse_transpose_f64 ¶
    Source

    matrix4_inverse_transpose_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (inverse_transpose: matrix[4, 4]f64) {…}

    matrix4_look_at_f16 ¶
    Source

    matrix4_look_at_f16 :: proc "contextless" (eye, centre, up: [3]f16, flip_z_axis: bool = true) -> (m: matrix[4, 4]f16) {…}

    matrix4_look_at_f32 ¶
    Source

    matrix4_look_at_f32 :: proc "contextless" (eye, centre, up: [3]f32, flip_z_axis: bool = true) -> (m: matrix[4, 4]f32) {…}

    matrix4_look_at_f64 ¶
    Source

    matrix4_look_at_f64 :: proc "contextless" (eye, centre, up: [3]f64, flip_z_axis: bool = true) -> (m: matrix[4, 4]f64) {…}

    matrix4_look_at_from_fru_f16 ¶
    Source

    matrix4_look_at_from_fru_f16 :: proc "contextless" (eye, f, r, u: [3]f16, flip_z_axis: bool = true) -> (m: matrix[4, 4]f16) {…}

    matrix4_look_at_from_fru_f32 ¶
    Source

    matrix4_look_at_from_fru_f32 :: proc "contextless" (eye, f, r, u: [3]f32, flip_z_axis: bool = true) -> (m: matrix[4, 4]f32) {…}

    matrix4_look_at_from_fru_f64 ¶
    Source

    matrix4_look_at_from_fru_f64 :: proc "contextless" (eye, f, r, u: [3]f64, flip_z_axis: bool = true) -> (m: matrix[4, 4]f64) {…}

    matrix4_minor_f16 ¶
    Source

    matrix4_minor_f16 :: proc "contextless" (m: matrix[4, 4]f16, c, r: int) -> f16 {…}

    matrix4_minor_f32 ¶
    Source

    matrix4_minor_f32 :: proc "contextless" (m: matrix[4, 4]f32, c, r: int) -> f32 {…}

    matrix4_minor_f64 ¶
    Source

    matrix4_minor_f64 :: proc "contextless" (m: matrix[4, 4]f64, c, r: int) -> f64 {…}

    matrix4_orientation_f16 ¶
    Source

    matrix4_orientation_f16 :: proc "contextless" (normal, up: [3]f16) -> matrix[4, 4]f16 {…}

    matrix4_orientation_f32 ¶
    Source

    matrix4_orientation_f32 :: proc "contextless" (normal, up: [3]f32) -> matrix[4, 4]f32 {…}

    matrix4_orientation_f64 ¶
    Source

    matrix4_orientation_f64 :: proc "contextless" (normal, up: [3]f64) -> matrix[4, 4]f64 {…}

    matrix4_perspective_f16 ¶
    Source

    matrix4_perspective_f16 :: proc "contextless" (fovy, aspect, near, far: f16, flip_z_axis: bool = true) -> (m: matrix[4, 4]f16) {…}

    matrix4_perspective_f32 ¶
    Source

    matrix4_perspective_f32 :: proc "contextless" (fovy, aspect, near, far: f32, flip_z_axis: bool = true) -> (m: matrix[4, 4]f32) {…}

    matrix4_perspective_f64 ¶
    Source

    matrix4_perspective_f64 :: proc "contextless" (fovy, aspect, near, far: f64, flip_z_axis: bool = true) -> (m: matrix[4, 4]f64) {…}

    matrix4_rotate_f16 ¶
    Source

    matrix4_rotate_f16 :: proc "contextless" (angle_radians: f16, v: [3]f16) -> matrix[4, 4]f16 {…}

    matrix4_rotate_f32 ¶
    Source

    matrix4_rotate_f32 :: proc "contextless" (angle_radians: f32, v: [3]f32) -> matrix[4, 4]f32 {…}

    matrix4_rotate_f64 ¶
    Source

    matrix4_rotate_f64 :: proc "contextless" (angle_radians: f64, v: [3]f64) -> matrix[4, 4]f64 {…}

    matrix4_scale_f16 ¶
    Source

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

    matrix4_scale_f32 ¶
    Source

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

    matrix4_scale_f64 ¶
    Source

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

    matrix4_translate_f16 ¶
    Source

    matrix4_translate_f16 :: proc "contextless" (v: [3]f16) -> matrix[4, 4]f16 {…}

    matrix4_translate_f32 ¶
    Source

    matrix4_translate_f32 :: proc "contextless" (v: [3]f32) -> matrix[4, 4]f32 {…}

    matrix4_translate_f64 ¶
    Source

    matrix4_translate_f64 :: proc "contextless" (v: [3]f64) -> matrix[4, 4]f64 {…}

    matrix4x4_adjugate ¶
    Source

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

    matrix4x4_determinant ¶
    Source

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

    matrix4x4_inverse ¶
    Source

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

    matrix4x4_inverse_transpose ¶
    Source

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

    matrix_cast ¶
    Source

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

    matrix_comp_mul ¶
    Source

    matrix_comp_mul :: proc "contextless" (a, b: $/matrix[0, 0]$T) -> (c: $/matrix[0, 0]$T) {…}

    matrix_flatten ¶

    matrix_flatten :: intrinsics.matrix_flatten

    matrix_minor ¶
    Source

    matrix_minor :: proc "contextless" (m: $/matrix[0, 0]$T, #any_int row, #any_int column: int) -> (minor: $T) {…}

    matrix_mul ¶
    Source

    matrix_mul :: proc "contextless" (a, b: $/matrix[0, 0]$T) -> (c: $/matrix[0, 0]$T) {…}

    matrix_mul_differ ¶
    Source

    matrix_mul_differ :: proc "contextless" (a, b: $/matrix[0, 0]$T) -> (c: matrix[0, 0]$T) {…}

    matrix_mul_vector ¶
    Source

    matrix_mul_vector :: proc "contextless" (a: $A/matrix[3, 3]$T, b: $T/[3]$T) -> (c: $T/[3]$T) {…}

    matrix_ortho3d_f16 ¶
    Source

    matrix_ortho3d_f16 :: proc "contextless" (
	left, right, bottom, top, near, far: f16, 
	flip_z_axis:                         bool = true, 
) -> (m: matrix[4, 4]f16) {…}

    matrix_ortho3d_f32 ¶
    Source

    matrix_ortho3d_f32 :: proc "contextless" (
	left, right, bottom, top, near, far: f32, 
	flip_z_axis:                         bool = true, 
) -> (m: matrix[4, 4]f32) {…}

    matrix_ortho3d_f64 ¶
    Source

    matrix_ortho3d_f64 :: proc "contextless" (
	left, right, bottom, top, near, far: f64, 
	flip_z_axis:                         bool = true, 
) -> (m: matrix[4, 4]f64) {…}

    matrix_to_ptr ¶
    Source

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

    max_double ¶
    Source

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

    max_single ¶
    Source

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

    max_triple ¶
    Source

    max_triple :: proc "contextless" (a, b, c: $T) -> $T {…}

    min_double ¶
    Source

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

    min_single ¶
    Source

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

    min_triple ¶
    Source

    min_triple :: proc "contextless" (a, b, c: $T) -> $T {…}

    mix ¶
    Source

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

    mod ¶
    Source

    mod :: proc "contextless" (x, m: $T) -> $T {…}

    not ¶
    Source

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

    not_equal_array ¶
    Source

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

    not_equal_single ¶
    Source

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

    outer_product ¶

    outer_product :: intrinsics.outer_product

    pitch_from_quaternion_f16 ¶
    Source

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

    pitch_from_quaternion_f32 ¶
    Source

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

    pitch_from_quaternion_f64 ¶
    Source

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

    pitch_yaw_roll_from_quaternion_f16 ¶
    Source

    pitch_yaw_roll_from_quaternion_f16 :: proc "contextless" (q: quaternion64) -> (pitch, yaw, roll: f16) {…}

    pitch_yaw_roll_from_quaternion_f32 ¶
    Source

    pitch_yaw_roll_from_quaternion_f32 :: proc "contextless" (q: quaternion128) -> (pitch, yaw, roll: f32) {…}

    pitch_yaw_roll_from_quaternion_f64 ¶
    Source

    pitch_yaw_roll_from_quaternion_f64 :: proc "contextless" (q: quaternion256) -> (pitch, yaw, roll: f64) {…}

    polar_from_euclidean_f16 ¶
    Source

    polar_from_euclidean_f16 :: proc "contextless" (euclidean: [3]f16) -> [3]f16 {…}

    polar_from_euclidean_f32 ¶
    Source

    polar_from_euclidean_f32 :: proc "contextless" (euclidean: [3]f32) -> [3]f32 {…}

    polar_from_euclidean_f64 ¶
    Source

    polar_from_euclidean_f64 :: proc "contextless" (euclidean: [3]f64) -> [3]f64 {…}

    pow ¶
    Source

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

    projection ¶
    Source

    projection :: proc "contextless" (x, normal: $T/[0]$T) -> $T/[0]$T {…}

    quaternion128_angle_between ¶
    Source

    quaternion128_angle_between :: proc "contextless" (a, b: $T/quaternion128) -> f32 {…}

    quaternion128_dot ¶
    Source

    quaternion128_dot :: proc "contextless" (a, b: $T/quaternion128) -> (c: f32) {…}

    quaternion128_mul_vector3 ¶
    Source

    quaternion128_mul_vector3 :: proc "contextless" (q: $T/quaternion128, v: $V/[3]$F/f32) -> $V/[3]$F/f32 {…}

    quaternion256_angle_between ¶
    Source

    quaternion256_angle_between :: proc "contextless" (a, b: $T/quaternion256) -> f64 {…}

    quaternion256_dot ¶
    Source

    quaternion256_dot :: proc "contextless" (a, b: $T/quaternion256) -> (c: f64) {…}

    quaternion256_mul_vector3 ¶
    Source

    quaternion256_mul_vector3 :: proc "contextless" (q: $T/quaternion256, v: $V/[3]$F/f64) -> $V/[3]$F/f64 {…}

    quaternion64_angle_between ¶
    Source

    quaternion64_angle_between :: proc "contextless" (a, b: $T/quaternion64) -> f16 {…}

    quaternion64_dot ¶
    Source

    quaternion64_dot :: proc "contextless" (a, b: $T/quaternion64) -> (c: f16) {…}

    quaternion64_mul_vector3 ¶
    Source

    quaternion64_mul_vector3 :: proc "contextless" (q: $T/quaternion64, v: $V/[3]$F/f16) -> $V/[3]$F/f16 {…}

    quaternion_angle_axis_f16 ¶
    Source

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

    quaternion_angle_axis_f32 ¶
    Source

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

    quaternion_angle_axis_f64 ¶
    Source

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

    quaternion_between_two_vector3_f16 ¶
    Source

    quaternion_between_two_vector3_f16 :: proc "contextless" (from, to: [3]f16) -> (q: quaternion64) {…}

    quaternion_between_two_vector3_f32 ¶
    Source

    quaternion_between_two_vector3_f32 :: proc "contextless" (from, to: [3]f32) -> (q: quaternion128) {…}

    quaternion_between_two_vector3_f64 ¶
    Source

    quaternion_between_two_vector3_f64 :: proc "contextless" (from, to: [3]f64) -> (q: quaternion256) {…}

    quaternion_cross ¶
    Source

    quaternion_cross :: proc "contextless" (q1, q2: $T) -> (q3: $T) {…}

    quaternion_from_euler_angle_x_f16 ¶
    Source

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

    quaternion_from_euler_angle_x_f32 ¶
    Source

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

    quaternion_from_euler_angle_x_f64 ¶
    Source

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

    quaternion_from_euler_angle_y_f16 ¶
    Source

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

    quaternion_from_euler_angle_y_f32 ¶
    Source

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

    quaternion_from_euler_angle_y_f64 ¶
    Source

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

    quaternion_from_euler_angle_z_f16 ¶
    Source

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

    quaternion_from_euler_angle_z_f32 ¶
    Source

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

    quaternion_from_euler_angle_z_f64 ¶
    Source

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

    quaternion_from_euler_angles_f16 ¶
    Source

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

    quaternion_from_euler_angles_f32 ¶
    Source

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

    quaternion_from_euler_angles_f64 ¶
    Source

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

    quaternion_from_forward_and_up_f16 ¶
    Source

    quaternion_from_forward_and_up_f16 :: proc "contextless" (forward, up: [3]f16) -> quaternion64 {…}

    quaternion_from_forward_and_up_f32 ¶
    Source

    quaternion_from_forward_and_up_f32 :: proc "contextless" (forward, up: [3]f32) -> quaternion128 {…}

    quaternion_from_forward_and_up_f64 ¶
    Source

    quaternion_from_forward_and_up_f64 :: proc "contextless" (forward, up: [3]f64) -> quaternion256 {…}

    quaternion_from_matrix3_f16 ¶
    Source

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

    quaternion_from_matrix3_f32 ¶
    Source

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

    quaternion_from_matrix3_f64 ¶
    Source

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

    quaternion_from_matrix4_f16 ¶
    Source

    quaternion_from_matrix4_f16 :: proc "contextless" (m: matrix[4, 4]f16) -> (q: quaternion64) {…}

    quaternion_from_matrix4_f32 ¶
    Source

    quaternion_from_matrix4_f32 :: proc "contextless" (m: matrix[4, 4]f32) -> (q: quaternion128) {…}

    quaternion_from_matrix4_f64 ¶
    Source

    quaternion_from_matrix4_f64 :: proc "contextless" (m: matrix[4, 4]f64) -> (q: quaternion256) {…}

    quaternion_from_pitch_yaw_roll_f16 ¶
    Source

    quaternion_from_pitch_yaw_roll_f16 :: proc "contextless" (pitch, yaw, roll: f16) -> quaternion64 {…}

    quaternion_from_pitch_yaw_roll_f32 ¶
    Source

    quaternion_from_pitch_yaw_roll_f32 :: proc "contextless" (pitch, yaw, roll: f32) -> quaternion128 {…}

    quaternion_from_pitch_yaw_roll_f64 ¶
    Source

    quaternion_from_pitch_yaw_roll_f64 :: proc "contextless" (pitch, yaw, roll: f64) -> quaternion256 {…}

    quaternion_from_scalar_f16 ¶
    Source

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

    quaternion_from_scalar_f32 ¶
    Source

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

    quaternion_from_scalar_f64 ¶
    Source

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

    quaternion_inverse ¶
    Source

    quaternion_inverse :: proc "contextless" (q: $T) -> $T {…}

    quaternion_length ¶
    Source

    quaternion_length :: proc "contextless" (q: $T) -> $T {…}

    quaternion_length2 ¶
    Source

    quaternion_length2 :: proc "contextless" (q: $T) -> $T {…}

    quaternion_look_at_f16 ¶
    Source

    quaternion_look_at_f16 :: proc "contextless" (eye, centre: [3]f16, up: [3]f16) -> quaternion64 {…}

    quaternion_look_at_f32 ¶
    Source

    quaternion_look_at_f32 :: proc "contextless" (eye, centre: [3]f32, up: [3]f32) -> quaternion128 {…}

    quaternion_look_at_f64 ¶
    Source

    quaternion_look_at_f64 :: proc "contextless" (eye, centre: [3]f64, up: [3]f64) -> quaternion256 {…}

    quaternion_mul_quaternion ¶
    Source

    quaternion_mul_quaternion :: proc "contextless" (q1, q2: $T) -> $T {…}

    quaternion_nlerp_f16 ¶
    Source

    quaternion_nlerp_f16 :: proc "contextless" (a, b: quaternion64, t: f16) -> (c: quaternion64) {…}

    quaternion_nlerp_f32 ¶
    Source

    quaternion_nlerp_f32 :: proc "contextless" (a, b: quaternion128, t: f32) -> (c: quaternion128) {…}

    quaternion_nlerp_f64 ¶
    Source

    quaternion_nlerp_f64 :: proc "contextless" (a, b: quaternion256, t: f64) -> (c: quaternion256) {…}

    quaternion_normalize ¶
    Source

    quaternion_normalize :: proc "contextless" (q: $T) -> $T {…}

    quaternion_normalize0 ¶
    Source

    quaternion_normalize0 :: proc "contextless" (q: $T) -> $T {…}

    quaternion_slerp_f16 ¶
    Source

    quaternion_slerp_f16 :: proc "contextless" (x, y: quaternion64, t: f16) -> (q: quaternion64) {…}

    quaternion_slerp_f32 ¶
    Source

    quaternion_slerp_f32 :: proc "contextless" (x, y: quaternion128, t: f32) -> (q: quaternion128) {…}

    quaternion_slerp_f64 ¶
    Source

    quaternion_slerp_f64 :: proc "contextless" (x, y: quaternion256, t: f64) -> (q: quaternion256) {…}

    quaternion_squad_f16 ¶
    Source

    quaternion_squad_f16 :: proc "contextless" (q1, q2, s1, s2: quaternion64, h: f16) -> quaternion64 {…}

    quaternion_squad_f32 ¶
    Source

    quaternion_squad_f32 :: proc "contextless" (q1, q2, s1, s2: quaternion128, h: f32) -> quaternion128 {…}

    quaternion_squad_f64 ¶
    Source

    quaternion_squad_f64 :: proc "contextless" (q1, q2, s1, s2: quaternion256, h: f64) -> quaternion256 {…}

    reflect ¶
    Source

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

    refract ¶
    Source

    refract :: proc "contextless" (I, Normal: $T/[0]$T, eta: $T) -> (out: $T/[0]$T) {…}

    roll_from_quaternion_f16 ¶
    Source

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

    roll_from_quaternion_f32 ¶
    Source

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

    roll_from_quaternion_f64 ¶
    Source

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

    round ¶
    Source

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

    saturate ¶
    Source

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

    scalar_cross ¶
    Source

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

    scalar_dot ¶
    Source

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

    scalar_f32_swizzle1 ¶
    Source

    scalar_f32_swizzle1 :: proc "contextless" (f: f32, c0: Scalar_Components) -> f32 {…}

    scalar_f32_swizzle2 ¶
    Source

    scalar_f32_swizzle2 :: proc "contextless" (f: f32, c0, c1: Scalar_Components) -> [2]f32 {…}

    scalar_f32_swizzle3 ¶
    Source

    scalar_f32_swizzle3 :: proc "contextless" (f: f32, c0, c1, c2: Scalar_Components) -> [3]f32 {…}

    scalar_f32_swizzle4 ¶
    Source

    scalar_f32_swizzle4 :: proc "contextless" (f: f32, c0, c1, c2, c3: Scalar_Components) -> [4]f32 {…}

    scalar_f64_swizzle1 ¶
    Source

    scalar_f64_swizzle1 :: proc "contextless" (f: f64, c0: Scalar_Components) -> f64 {…}

    scalar_f64_swizzle2 ¶
    Source

    scalar_f64_swizzle2 :: proc "contextless" (f: f64, c0, c1: Scalar_Components) -> [2]f64 {…}

    scalar_f64_swizzle3 ¶
    Source

    scalar_f64_swizzle3 :: proc "contextless" (f: f64, c0, c1, c2: Scalar_Components) -> [3]f64 {…}

    scalar_f64_swizzle4 ¶
    Source

    scalar_f64_swizzle4 :: proc "contextless" (f: f64, c0, c1, c2, c3: Scalar_Components) -> [4]f64 {…}

    scalar_triple_product ¶
    Source

    scalar_triple_product :: proc "contextless" (a, b, c: $T/[0]$T) -> $T {…}

    sign ¶
    Source

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

    sin ¶
    Source

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

    smootherstep ¶
    Source

    smootherstep :: proc "contextless" (e0, e1, x: $T) -> $T {…}

    smoothstep ¶
    Source

    smoothstep :: proc "contextless" (e0, e1, x: $T) -> $T {…}

    sqrt ¶
    Source

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

    step ¶
    Source

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

    tan ¶
    Source

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

    to_complex128 ¶
    Source

    to_complex128 :: proc(v: $T/[0]$T) -> [0]complex128 {…}

    to_complex32 ¶
    Source

    to_complex32 :: proc(v: $T/[0]$T) -> [0]complex32 {…}

    to_complex64 ¶
    Source

    to_complex64 :: proc(v: $T/[0]$T) -> [0]complex64 {…}

    to_degrees ¶
    Source

    to_degrees :: proc "contextless" (radians: $T) -> (out: $T) {…}

    to_f32 ¶
    Source

    to_f32 :: proc(v: $T/[0]$T) -> [0]f32 {…}

    to_f64 ¶
    Source

    to_f64 :: proc(v: $T/[0]$T) -> [0]f64 {…}

    to_i16 ¶
    Source

    to_i16 :: proc(v: $T/[0]$T) -> [0]i16 {…}

    to_i32 ¶
    Source

    to_i32 :: proc(v: $T/[0]$T) -> [0]i32 {…}

    to_i64 ¶
    Source

    to_i64 :: proc(v: $T/[0]$T) -> [0]i64 {…}

    to_i8 ¶
    Source

    to_i8 :: proc(v: $T/[0]$T) -> [0]i8 {…}

    to_int ¶
    Source

    to_int :: proc(v: $T/[0]$T) -> [0]int {…}

    to_quaternion128 ¶
    Source

    to_quaternion128 :: proc(v: $T/[0]$T) -> [0]quaternion128 {…}

    to_quaternion256 ¶
    Source

    to_quaternion256 :: proc(v: $T/[0]$T) -> [0]quaternion256 {…}

    to_quaternion64 ¶
    Source

    to_quaternion64 :: proc(v: $T/[0]$T) -> [0]quaternion64 {…}

    to_radians ¶
    Source

    to_radians :: proc "contextless" (degrees: $T) -> (out: $T) {…}

    to_u16 ¶
    Source

    to_u16 :: proc(v: $T/[0]$T) -> [0]u16 {…}

    to_u32 ¶
    Source

    to_u32 :: proc(v: $T/[0]$T) -> [0]u32 {…}

    to_u64 ¶
    Source

    to_u64 :: proc(v: $T/[0]$T) -> [0]u64 {…}

    to_u8 ¶
    Source

    to_u8 :: proc(v: $T/[0]$T) -> [0]u8 {…}

    to_uint ¶
    Source

    to_uint :: proc(v: $T/[0]$T) -> [0]uint {…}

    trace ¶
    Source

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

    transpose ¶

    transpose :: intrinsics.transpose

    unlerp ¶
    Source

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

    vector2_orthogonal ¶
    Source

    vector2_orthogonal :: proc "contextless" (v: $T/[2]$T) -> $T/[2]$T {…}

    vector2f32_swizzle1 ¶
    Source

    vector2f32_swizzle1 :: proc "contextless" (v: [2]f32, c0: Vector2_Components) -> f32 {…}

    vector2f32_swizzle2 ¶
    Source

    vector2f32_swizzle2 :: proc "contextless" (v: [2]f32, c0, c1: Vector2_Components) -> [2]f32 {…}

    vector2f32_swizzle3 ¶
    Source

    vector2f32_swizzle3 :: proc "contextless" (v: [2]f32, c0, c1, c2: Vector2_Components) -> [3]f32 {…}

    vector2f32_swizzle4 ¶
    Source

    vector2f32_swizzle4 :: proc "contextless" (v: [2]f32, c0, c1, c2, c3: Vector2_Components) -> [4]f32 {…}

    vector2f64_swizzle1 ¶
    Source

    vector2f64_swizzle1 :: proc "contextless" (v: [2]f64, c0: Vector2_Components) -> f64 {…}

    vector2f64_swizzle2 ¶
    Source

    vector2f64_swizzle2 :: proc "contextless" (v: [2]f64, c0, c1: Vector2_Components) -> [2]f64 {…}

    vector2f64_swizzle3 ¶
    Source

    vector2f64_swizzle3 :: proc "contextless" (v: [2]f64, c0, c1, c2: Vector2_Components) -> [3]f64 {…}

    vector2f64_swizzle4 ¶
    Source

    vector2f64_swizzle4 :: proc "contextless" (v: [2]f64, c0, c1, c2, c3: Vector2_Components) -> [4]f64 {…}

    vector3_orthogonal ¶
    Source

    vector3_orthogonal :: proc "contextless" (v: $T/[3]$T) -> $T/[3]$T {…}

    vector3_orthonormalize_f16 ¶
    Source

    vector3_orthonormalize_f16 :: proc "contextless" (x, y: [3]f16) -> (z: [3]f16) {…}

    vector3_orthonormalize_f32 ¶
    Source

    vector3_orthonormalize_f32 :: proc "contextless" (x, y: [3]f32) -> (z: [3]f32) {…}

    vector3_orthonormalize_f64 ¶
    Source

    vector3_orthonormalize_f64 :: proc "contextless" (x, y: [3]f64) -> (z: [3]f64) {…}

    vector3f32_swizzle1 ¶
    Source

    vector3f32_swizzle1 :: proc "contextless" (v: [3]f32, c0: Vector3_Components) -> f32 {…}

    vector3f32_swizzle2 ¶
    Source

    vector3f32_swizzle2 :: proc "contextless" (v: [3]f32, c0, c1: Vector3_Components) -> [2]f32 {…}

    vector3f32_swizzle3 ¶
    Source

    vector3f32_swizzle3 :: proc "contextless" (v: [3]f32, c0, c1, c2: Vector3_Components) -> [3]f32 {…}

    vector3f32_swizzle4 ¶
    Source

    vector3f32_swizzle4 :: proc "contextless" (v: [3]f32, c0, c1, c2, c3: Vector3_Components) -> [4]f32 {…}

    vector3f64_swizzle1 ¶
    Source

    vector3f64_swizzle1 :: proc "contextless" (v: [3]f64, c0: Vector3_Components) -> f64 {…}

    vector3f64_swizzle2 ¶
    Source

    vector3f64_swizzle2 :: proc "contextless" (v: [3]f64, c0, c1: Vector3_Components) -> [2]f64 {…}

    vector3f64_swizzle3 ¶
    Source

    vector3f64_swizzle3 :: proc "contextless" (v: [3]f64, c0, c1, c2: Vector3_Components) -> [3]f64 {…}

    vector3f64_swizzle4 ¶
    Source

    vector3f64_swizzle4 :: proc "contextless" (v: [3]f64, c0, c1, c2, c3: Vector3_Components) -> [4]f64 {…}

    vector4_hsl_to_rgb_f16 ¶
    Source

    vector4_hsl_to_rgb_f16 :: proc "contextless" (h, s, l: f16, a: f16 = 1) -> [4]f16 {…}

    vector4_hsl_to_rgb_f32 ¶
    Source

    vector4_hsl_to_rgb_f32 :: proc "contextless" (h, s, l: f32, a: f32 = 1) -> [4]f32 {…}

    vector4_hsl_to_rgb_f64 ¶
    Source

    vector4_hsl_to_rgb_f64 :: proc "contextless" (h, s, l: f64, a: f64 = 1) -> [4]f64 {…}

    vector4_linear_to_srgb_f16 ¶
    Source

    vector4_linear_to_srgb_f16 :: proc "contextless" (col: [4]f16) -> [4]f16 {…}

    vector4_linear_to_srgb_f32 ¶
    Source

    vector4_linear_to_srgb_f32 :: proc "contextless" (col: [4]f32) -> [4]f32 {…}

    vector4_linear_to_srgb_f64 ¶
    Source

    vector4_linear_to_srgb_f64 :: proc "contextless" (col: [4]f64) -> [4]f64 {…}

    vector4_rgb_to_hsl_f16 ¶
    Source

    vector4_rgb_to_hsl_f16 :: proc "contextless" (col: [4]f16) -> [4]f16 {…}

    vector4_rgb_to_hsl_f32 ¶
    Source

    vector4_rgb_to_hsl_f32 :: proc "contextless" (col: [4]f32) -> [4]f32 {…}

    vector4_rgb_to_hsl_f64 ¶
    Source

    vector4_rgb_to_hsl_f64 :: proc "contextless" (col: [4]f64) -> [4]f64 {…}

    vector4_srgb_to_linear_f16 ¶
    Source

    vector4_srgb_to_linear_f16 :: proc "contextless" (col: [4]f16) -> [4]f16 {…}

    vector4_srgb_to_linear_f32 ¶
    Source

    vector4_srgb_to_linear_f32 :: proc "contextless" (col: [4]f32) -> [4]f32 {…}

    vector4_srgb_to_linear_f64 ¶
    Source

    vector4_srgb_to_linear_f64 :: proc "contextless" (col: [4]f64) -> [4]f64 {…}

    vector4f32_swizzle1 ¶
    Source

    vector4f32_swizzle1 :: proc "contextless" (v: [4]f32, c0: Vector4_Components) -> f32 {…}

    vector4f32_swizzle2 ¶
    Source

    vector4f32_swizzle2 :: proc "contextless" (v: [4]f32, c0, c1: Vector4_Components) -> [2]f32 {…}

    vector4f32_swizzle3 ¶
    Source

    vector4f32_swizzle3 :: proc "contextless" (v: [4]f32, c0, c1, c2: Vector4_Components) -> [3]f32 {…}

    vector4f32_swizzle4 ¶
    Source

    vector4f32_swizzle4 :: proc "contextless" (v: [4]f32, c0, c1, c2, c3: Vector4_Components) -> [4]f32 {…}

    vector4f64_swizzle1 ¶
    Source

    vector4f64_swizzle1 :: proc "contextless" (v: [4]f64, c0: Vector4_Components) -> f64 {…}

    vector4f64_swizzle2 ¶
    Source

    vector4f64_swizzle2 :: proc "contextless" (v: [4]f64, c0, c1: Vector4_Components) -> [2]f64 {…}

    vector4f64_swizzle3 ¶
    Source

    vector4f64_swizzle3 :: proc "contextless" (v: [4]f64, c0, c1, c2: Vector4_Components) -> [3]f64 {…}

    vector4f64_swizzle4 ¶
    Source

    vector4f64_swizzle4 :: proc "contextless" (v: [4]f64, c0, c1, c2, c3: Vector4_Components) -> [4]f64 {…}

    vector_angle_between ¶
    Source

    vector_angle_between :: proc "contextless" (a, b: $T/[0]$T) -> $T {…}

    vector_cross2 ¶
    Source

    vector_cross2 :: proc "contextless" (a, b: $T/[2]$T) -> $T {…}

    vector_cross3 ¶
    Source

    vector_cross3 :: proc "contextless" (a, b: $T/[3]$T) -> (c: $T/[3]$T) {…}

    vector_dot ¶
    Source

    vector_dot :: proc "contextless" (a, b: $T/[0]$T) -> (c: $T) {…}

    vector_length ¶
    Source

    vector_length :: proc "contextless" (v: $T/[0]$T) -> $T {…}

    vector_length2 ¶
    Source

    vector_length2 :: proc "contextless" (v: $T/[0]$T) -> $T {…}

    vector_normalize ¶
    Source

    vector_normalize :: proc "contextless" (v: $T/[0]$T) -> $T/[0]$T {…}

    vector_normalize0 ¶
    Source

    vector_normalize0 :: proc "contextless" (v: $T/[0]$T) -> $T/[0]$T {…}

    vector_slerp ¶
    Source

    vector_slerp :: proc "contextless" (x, y: $T/[0]$T, a: $T) -> $T/[0]$T {…}

    vector_to_ptr ¶
    Source

    vector_to_ptr :: proc "contextless" (v: ^$T/[0]$T) -> ^$T {…}

    vector_triple_product ¶
    Source

    vector_triple_product :: proc "contextless" (a, b, c: $T/[0]$T) -> $T/[0]$T {…}

    yaw_from_quaternion_f16 ¶
    Source

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

    yaw_from_quaternion_f32 ¶
    Source

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

    yaw_from_quaternion_f64 ¶
    Source

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

    Procedure Groups

    adjugate ¶
    Source

    angle_axis_from_quaternion ¶
    Source

    angle_between ¶
    Source

    angle_from_quaternion ¶
    Source

    axis_from_quaternion ¶
    Source

    classify ¶
    Source

    classify :: proc{
	classify_single,
	classify_array,
}

    cross ¶
    Source

    determinant ¶
    Source

    dot ¶
    Source

    equal ¶
    Source

    equal :: proc{
	equal_single,
	equal_array,
}

    euclidean_from_polar ¶
    Source

    euler_angles_from_matrix3 ¶
    Source

    euler_angles_from_matrix4 ¶
    Source

    euler_angles_from_quaternion ¶
    Source

    euler_angles_xyx_from_matrix3 ¶
    Source

    euler_angles_xyx_from_matrix4 ¶
    Source

    euler_angles_xyx_from_quaternion ¶
    Source

    euler_angles_xyz_from_matrix3 ¶
    Source

    euler_angles_xyz_from_matrix4 ¶
    Source

    euler_angles_xyz_from_quaternion ¶
    Source

    euler_angles_xzx_from_matrix3 ¶
    Source

    euler_angles_xzx_from_matrix4 ¶
    Source

    euler_angles_xzx_from_quaternion ¶
    Source

    euler_angles_xzy_from_matrix3 ¶
    Source

    euler_angles_xzy_from_matrix4 ¶
    Source

    euler_angles_xzy_from_quaternion ¶
    Source

    euler_angles_yxy_from_matrix3 ¶
    Source

    euler_angles_yxy_from_matrix4 ¶
    Source

    euler_angles_yxy_from_quaternion ¶
    Source

    euler_angles_yxz_from_matrix3 ¶
    Source

    euler_angles_yxz_from_matrix4 ¶
    Source

    euler_angles_yxz_from_quaternion ¶
    Source

    euler_angles_yzx_from_matrix3 ¶
    Source

    euler_angles_yzx_from_matrix4 ¶
    Source

    euler_angles_yzx_from_quaternion ¶
    Source

    euler_angles_yzy_from_matrix3 ¶
    Source

    euler_angles_yzy_from_matrix4 ¶
    Source

    euler_angles_yzy_from_quaternion ¶
    Source

    euler_angles_zxy_from_matrix3 ¶
    Source

    euler_angles_zxy_from_matrix4 ¶
    Source

    euler_angles_zxy_from_quaternion ¶
    Source

    euler_angles_zxz_from_matrix3 ¶
    Source

    euler_angles_zxz_from_matrix4 ¶
    Source

    euler_angles_zxz_from_quaternion ¶
    Source

    euler_angles_zyx_from_matrix3 ¶
    Source

    euler_angles_zyx_from_matrix4 ¶
    Source

    euler_angles_zyx_from_quaternion ¶
    Source

    euler_angles_zyz_from_matrix3 ¶
    Source

    euler_angles_zyz_from_matrix4 ¶
    Source

    euler_angles_zyz_from_quaternion ¶
    Source

    greater_than ¶
    Source

    greater_than :: proc{
	greater_than_single,
	greater_than_array,
}

    greater_than_equal ¶
    Source

    greater_than_equal :: proc{
	greater_than_equal_single,
	greater_than_equal_array,
}

    identity ¶
    Source

    inner_product ¶
    Source

    inverse ¶
    Source

    inverse_transpose ¶
    Source

    is_inf ¶
    Source

    is_inf :: proc{
	is_inf_single,
	is_inf_array,
}

    is_nan ¶
    Source

    is_nan :: proc{
	is_nan_single,
	is_nan_array,
}

    length ¶
    Source

    length :: proc{
	vector_length,
	quaternion_length,
}

    length2 ¶
    Source

    length2 :: proc{
	vector_length2,
	quaternion_length2,
}

    less_than ¶
    Source

    less_than :: proc{
	less_than_single,
	less_than_array,
}

    less_than_equal ¶
    Source

    less_than_equal :: proc{
	less_than_equal_single,
	less_than_equal_array,
}

    matrix2_adjoint ¶
    Source

    matrix2_determinant ¶
    Source

    matrix2_from_matrix3 ¶
    Source

    matrix2_from_matrix4 ¶
    Source

    matrix2_from_scalar ¶
    Source

    matrix2_inverse ¶
    Source

    matrix2_inverse_transpose ¶
    Source

    matrix2_orthonormalize ¶
    Source

    matrix2_rotate ¶
    Source

    matrix3_adjoint ¶
    Source

    matrix3_determinant ¶
    Source

    matrix3_from_derived_euler_angle_x ¶
    Source

    matrix3_from_derived_euler_angle_y ¶
    Source

    matrix3_from_derived_euler_angle_z ¶
    Source

    matrix3_from_euler_angle_x ¶
    Source

    matrix3_from_euler_angle_y ¶
    Source

    matrix3_from_euler_angle_z ¶
    Source

    matrix3_from_euler_angles ¶
    Source

    matrix3_from_euler_angles_xy ¶
    Source

    matrix3_from_euler_angles_xyx ¶
    Source

    matrix3_from_euler_angles_xyz ¶
    Source

    matrix3_from_euler_angles_xz ¶
    Source

    matrix3_from_euler_angles_xzx ¶
    Source

    matrix3_from_euler_angles_xzy ¶
    Source

    matrix3_from_euler_angles_yx ¶
    Source

    matrix3_from_euler_angles_yxy ¶
    Source

    matrix3_from_euler_angles_yxz ¶
    Source

    matrix3_from_euler_angles_yz ¶
    Source

    matrix3_from_euler_angles_yzx ¶
    Source

    matrix3_from_euler_angles_yzy ¶
    Source

    matrix3_from_euler_angles_zx ¶
    Source

    matrix3_from_euler_angles_zxy ¶
    Source

    matrix3_from_euler_angles_zxz ¶
    Source

    matrix3_from_euler_angles_zy ¶
    Source

    matrix3_from_euler_angles_zyx ¶
    Source

    matrix3_from_euler_angles_zyz ¶
    Source

    matrix3_from_matrix2 ¶
    Source

    matrix3_from_matrix4 ¶
    Source

    matrix3_from_quaternion ¶
    Source

    matrix3_from_scalar ¶
    Source

    matrix3_from_yaw_pitch_roll ¶
    Source

    matrix3_inverse ¶
    Source

    matrix3_inverse_transpose ¶
    Source

    matrix3_look_at ¶
    Source

    matrix3_orthonormalize ¶
    Source

    matrix3_rotate ¶
    Source

    matrix3_scale ¶
    Source

    matrix4_adjoint ¶
    Source

    matrix4_cofactor ¶
    Source

    matrix4_determinant ¶
    Source

    matrix4_from_derived_euler_angle_x ¶
    Source

    matrix4_from_derived_euler_angle_y ¶
    Source

    matrix4_from_derived_euler_angle_z ¶
    Source

    matrix4_from_euler_angle_x ¶
    Source

    matrix4_from_euler_angle_y ¶
    Source

    matrix4_from_euler_angle_z ¶
    Source

    matrix4_from_euler_angles ¶
    Source

    matrix4_from_euler_angles_xy ¶
    Source

    matrix4_from_euler_angles_xyx ¶
    Source

    matrix4_from_euler_angles_xyz ¶
    Source

    matrix4_from_euler_angles_xz ¶
    Source

    matrix4_from_euler_angles_xzx ¶
    Source

    matrix4_from_euler_angles_xzy ¶
    Source

    matrix4_from_euler_angles_yx ¶
    Source

    matrix4_from_euler_angles_yxy ¶
    Source

    matrix4_from_euler_angles_yxz ¶
    Source

    matrix4_from_euler_angles_yz ¶
    Source

    matrix4_from_euler_angles_yzx ¶
    Source

    matrix4_from_euler_angles_yzy ¶
    Source

    matrix4_from_euler_angles_zx ¶
    Source

    matrix4_from_euler_angles_zxy ¶
    Source

    matrix4_from_euler_angles_zxz ¶
    Source

    matrix4_from_euler_angles_zy ¶
    Source

    matrix4_from_euler_angles_zyx ¶
    Source

    matrix4_from_euler_angles_zyz ¶
    Source

    matrix4_from_matrix2 ¶
    Source

    matrix4_from_matrix3 ¶
    Source

    matrix4_from_quaternion ¶
    Source

    matrix4_from_scalar ¶
    Source

    matrix4_from_trs ¶
    Source

    matrix4_from_yaw_pitch_roll ¶
    Source

    matrix4_infinite_perspective ¶
    Source

    matrix4_inverse ¶
    Source

    matrix4_inverse_transpose ¶
    Source

    matrix4_look_at ¶
    Source

    matrix4_look_at_from_fru ¶
    Source

    matrix4_minor ¶
    Source

    matrix4_orientation ¶
    Source

    matrix4_perspective ¶
    Source

    matrix4_rotate ¶
    Source

    matrix4_scale ¶
    Source

    matrix4_translate ¶
    Source

    matrix_ortho3d ¶
    Source

    max ¶
    Source

    max :: proc{
	max_single,
	max_double,
	max_triple,
}

    min ¶
    Source

    min :: proc{
	min_single,
	min_double,
	min_triple,
}

    mul ¶
    Source

    normalize ¶
    Source

    normalize :: proc{
	vector_normalize,
	quaternion_normalize,
}

    normalize0 ¶
    Source

    normalize0 :: proc{
	vector_normalize0,
	quaternion_normalize0,
}

    not_equal ¶
    Source

    not_equal :: proc{
	not_equal_single,
	not_equal_array,
}

    orthogonal ¶
    Source

    orthogonal :: proc{
	vector2_orthogonal,
	vector3_orthogonal,
}

    orthonormalize ¶
    Source

    pitch_from_quaternion ¶
    Source

    pitch_yaw_roll_from_quaternion ¶
    Source

    polar_from_euclidean ¶
    Source

    quaternion_angle_axis ¶
    Source

    quaternion_between_two_vector3 ¶
    Source

    quaternion_from_euler_angle_x ¶
    Source

    quaternion_from_euler_angle_y ¶
    Source

    quaternion_from_euler_angle_z ¶
    Source

    quaternion_from_euler_angles ¶
    Source

    quaternion_from_forward_and_up ¶
    Source

    quaternion_from_matrix3 ¶
    Source

    quaternion_from_matrix4 ¶
    Source

    quaternion_from_pitch_yaw_roll ¶
    Source

    quaternion_from_scalar ¶
    Source

    quaternion_look_at ¶
    Source

    quaternion_mul_vector3 ¶
    Source

    quaternion_nlerp ¶
    Source

    quaternion_slerp ¶
    Source

    quaternion_squad ¶
    Source

    roll_from_quaternion ¶
    Source

    scalar_swizzle ¶
    Source

    swizzle ¶
    Source

    to_matrix2f ¶
    Source

    to_matrix2f16 ¶
    Source

    to_matrix2f32 ¶
    Source

    to_matrix2f64 ¶
    Source

    to_matrix3 ¶
    Source

    to_matrix3f16 ¶
    Source

    to_matrix3f32 ¶
    Source

    to_matrix3f64 ¶
    Source

    to_matrix4 ¶
    Source

    to_matrix4f16 ¶
    Source

    to_matrix4f32 ¶
    Source

    to_matrix4f64 ¶
    Source

    to_ptr ¶
    Source

    to_ptr :: proc{
	vector_to_ptr,
	matrix_to_ptr,
}

    to_quaternion ¶
    Source

    to_quaternionf16 ¶
    Source

    to_quaternionf32 ¶
    Source

    to_quaternionf64 ¶
    Source

    vector2_swizzle ¶
    Source

    vector3_orthonormalize ¶
    Source

    vector3_swizzle ¶
    Source

    vector4_hsl_to_rgb ¶
    Source

    vector4_linear_to_srgb ¶
    Source

    vector4_rgb_to_hsl ¶
    Source

    vector4_srgb_to_linear ¶
    Source

    vector4_swizzle ¶
    Source

    vector_cross ¶
    Source

    vector_cross :: proc{
	scalar_cross,
	vector_cross2,
	vector_cross3,
}

    yaw_from_quaternion ¶
    Source

    Source Files

    Generation Information

    Generated with odin version dev-2024-04 (vendor "odin") Windows_amd64 @ 2024-04-24 21:08:59.256830700 +0000 UTC