package core:math/linalg

⌘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

    Matrix1f16 ¶

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

    Matrix1f32 ¶

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

    Matrix1f64 ¶

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

    Matrix1x1f16 ¶

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

    Matrix1x1f32 ¶

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

    Matrix1x1f64 ¶

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

    Matrix1x2f16 ¶

    Matrix1x2f16 :: matrix[1, 2]f16

    Matrix1x2f32 ¶

    Matrix1x2f32 :: matrix[1, 2]f32

    Matrix1x2f64 ¶

    Matrix1x2f64 :: matrix[1, 2]f64

    Matrix1x3f16 ¶

    Matrix1x3f16 :: matrix[1, 3]f16

    Matrix1x3f32 ¶

    Matrix1x3f32 :: matrix[1, 3]f32

    Matrix1x3f64 ¶

    Matrix1x3f64 :: matrix[1, 3]f64

    Matrix1x4f16 ¶

    Matrix1x4f16 :: matrix[1, 4]f16

    Matrix1x4f32 ¶

    Matrix1x4f32 :: matrix[1, 4]f32

    Matrix1x4f64 ¶

    Matrix1x4f64 :: matrix[1, 4]f64

    Matrix2f16 ¶

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

    Matrix2f32 ¶

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

    Matrix2f64 ¶

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

    Matrix2x1f16 ¶

    Matrix2x1f16 :: matrix[2, 1]f16

    Matrix2x1f32 ¶

    Matrix2x1f32 :: matrix[2, 1]f32

    Matrix2x1f64 ¶

    Matrix2x1f64 :: matrix[2, 1]f64

    Matrix2x2f16 ¶

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

    Matrix2x2f32 ¶

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

    Matrix2x2f64 ¶

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

    Matrix2x3f16 ¶

    Matrix2x3f16 :: matrix[2, 3]f16

    Matrix2x3f32 ¶

    Matrix2x3f32 :: matrix[2, 3]f32

    Matrix2x3f64 ¶

    Matrix2x3f64 :: matrix[2, 3]f64

    Matrix2x4f16 ¶

    Matrix2x4f16 :: matrix[2, 4]f16

    Matrix2x4f32 ¶

    Matrix2x4f32 :: matrix[2, 4]f32

    Matrix2x4f64 ¶

    Matrix2x4f64 :: matrix[2, 4]f64

    Matrix3f16 ¶

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

    Matrix3f32 ¶

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

    Matrix3f64 ¶

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

    Matrix3x1f16 ¶

    Matrix3x1f16 :: matrix[3, 1]f16

    Matrix3x1f32 ¶

    Matrix3x1f32 :: matrix[3, 1]f32

    Matrix3x1f64 ¶

    Matrix3x1f64 :: matrix[3, 1]f64

    Matrix3x2f16 ¶

    Matrix3x2f16 :: matrix[3, 2]f16

    Matrix3x2f32 ¶

    Matrix3x2f32 :: matrix[3, 2]f32

    Matrix3x2f64 ¶

    Matrix3x2f64 :: matrix[3, 2]f64

    Matrix3x3f16 ¶

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

    Matrix3x3f32 ¶

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

    Matrix3x3f64 ¶

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

    Matrix3x4f16 ¶

    Matrix3x4f16 :: matrix[3, 4]f16

    Matrix3x4f32 ¶

    Matrix3x4f32 :: matrix[3, 4]f32

    Matrix3x4f64 ¶

    Matrix3x4f64 :: matrix[3, 4]f64

    Matrix4f16 ¶

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

    Matrix4f32 ¶

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

    Matrix4f64 ¶

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

    Matrix4x1f16 ¶

    Matrix4x1f16 :: matrix[4, 1]f16

    Matrix4x1f32 ¶

    Matrix4x1f32 :: matrix[4, 1]f32

    Matrix4x1f64 ¶

    Matrix4x1f64 :: matrix[4, 1]f64

    Matrix4x2f16 ¶

    Matrix4x2f16 :: matrix[4, 2]f16

    Matrix4x2f32 ¶

    Matrix4x2f32 :: matrix[4, 2]f32

    Matrix4x2f64 ¶

    Matrix4x2f64 :: matrix[4, 2]f64

    Matrix4x3f16 ¶

    Matrix4x3f16 :: matrix[4, 3]f16

    Matrix4x3f32 ¶

    Matrix4x3f32 :: matrix[4, 3]f32

    Matrix4x3f64 ¶

    Matrix4x3f64 :: matrix[4, 3]f64

    Matrix4x4f16 ¶

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

    Matrix4x4f32 ¶

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

    Matrix4x4f64 ¶

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

    Vector2_Components ¶

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

    Vector2f16 ¶

    Vector2f16 :: [2]f16

    Vector2f32 ¶

    Vector2f32 :: [2]f32

    Vector2f64 ¶

    Vector2f64 :: [2]f64

    Vector3_Components ¶

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

    Vector4_Components ¶

    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 ¶

    Vector4f16 :: [4]f16

    Vector4f32 ¶

    Vector4f32 :: [4]f32

    Vector4f64 ¶

    Vector4f64 :: [4]f64

    Constants

    DEG_PER_RAD ¶

    DEG_PER_RAD :: 360.0 / TAU

    E ¶

    E :: 2.71828182845904523536

    F16_EPSILON ¶

    F16_EPSILON :: 1e-3

    F32_EPSILON ¶

    F32_EPSILON :: 1e-7

    F64_EPSILON ¶

    F64_EPSILON :: 1e-15

    LN10 ¶

    LN10 :: 2.30258509299404568401799145468436421

    LN2 ¶

    LN2 :: 0.693147180559945309417232121458176568

    MATRIX1F16_IDENTITY ¶

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

    MATRIX1F32_IDENTITY ¶

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

    MATRIX1F64_IDENTITY ¶

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

    MATRIX2F16_IDENTITY ¶

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

    MATRIX2F32_IDENTITY ¶

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

    MATRIX2F64_IDENTITY ¶

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

    MATRIX3F16_IDENTITY ¶

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

    MATRIX3F32_IDENTITY ¶

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

    MATRIX3F64_IDENTITY ¶

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

    MATRIX4F16_IDENTITY ¶

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

    MATRIX4F32_IDENTITY ¶

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

    MATRIX4F64_IDENTITY ¶

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

    MAX_F32_PRECISION ¶

    MAX_F32_PRECISION :: 8
     

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

    MAX_F64_PRECISION ¶

    MAX_F64_PRECISION :: 16
     

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

    PI ¶

    PI :: 3.14159265358979323846264338327950288

    QUATERNIONF16_IDENTITY ¶

    QUATERNIONF16_IDENTITY: quaternion64 : Quaternionf16(1)

    QUATERNIONF32_IDENTITY ¶

    QUATERNIONF32_IDENTITY: quaternion128 : Quaternionf32(1)

    QUATERNIONF64_IDENTITY ¶

    QUATERNIONF64_IDENTITY: quaternion256 : Quaternionf64(1)

    RAD_PER_DEG ¶

    RAD_PER_DEG :: TAU / 360.0

    SQRT_FIVE ¶

    SQRT_FIVE :: 2.23606797749978969640917366873127623

    SQRT_THREE ¶

    SQRT_THREE :: 1.73205080756887729352744634150587236

    SQRT_TWO ¶

    SQRT_TWO :: 1.41421356237309504880168872420969808

    TAU ¶

    TAU :: 6.28318530717958647692528676655900576

    VECTOR3F16_X_AXIS ¶

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

    VECTOR3F16_Y_AXIS ¶

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

    VECTOR3F16_Z_AXIS ¶

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

    VECTOR3F32_X_AXIS ¶

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

    VECTOR3F32_Y_AXIS ¶

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

    VECTOR3F32_Z_AXIS ¶

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

    VECTOR3F64_X_AXIS ¶

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

    VECTOR3F64_Y_AXIS ¶

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

    VECTOR3F64_Z_AXIS ¶

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

    e ¶

    e :: E

    π ¶

    π :: PI

    τ ¶

    τ :: TAU

    Variables

    This section is empty.

    Procedures

    abs ¶

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

    acos ¶

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

    all ¶

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

    angle_axis_from_quaternion_f16 ¶

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

    angle_axis_from_quaternion_f32 ¶

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

    angle_axis_from_quaternion_f64 ¶

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

    angle_from_quaternion_f16 ¶

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

    angle_from_quaternion_f32 ¶

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

    angle_from_quaternion_f64 ¶

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

    any ¶

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

    array_cast ¶

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

    asin ¶

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

    atan ¶

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

    atan2 ¶

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

    axis_from_quaternion_f16 ¶

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

    axis_from_quaternion_f32 ¶

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

    axis_from_quaternion_f64 ¶

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

    catmull_rom ¶

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

    ceil ¶

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

    clamp ¶

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

    classify_array ¶

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

    classify_single ¶

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

    cos ¶

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

    cubic ¶

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

    distance ¶

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

    equal_array ¶

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

    equal_single ¶

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

    euclidean_from_polar_f16 ¶

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

    euclidean_from_polar_f32 ¶

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

    euclidean_from_polar_f64 ¶

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

    euler_angles_from_matrix3_f16 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

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

    euler_angles_from_quaternion_f32 ¶

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

    euler_angles_from_quaternion_f64 ¶

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

    euler_angles_xyx_from_matrix3_f16 ¶

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

    euler_angles_xyx_from_matrix3_f32 ¶

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

    euler_angles_xyx_from_matrix3_f64 ¶

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

    euler_angles_xyx_from_matrix4_f16 ¶

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

    euler_angles_xyx_from_matrix4_f32 ¶

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

    euler_angles_xyx_from_matrix4_f64 ¶

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

    euler_angles_xyx_from_quaternion_f16 ¶

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

    euler_angles_xyx_from_quaternion_f32 ¶

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

    euler_angles_xyx_from_quaternion_f64 ¶

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

    euler_angles_xyz_from_matrix3_f16 ¶

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

    euler_angles_xyz_from_matrix3_f32 ¶

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

    euler_angles_xyz_from_matrix3_f64 ¶

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

    euler_angles_xyz_from_matrix4_f16 ¶

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

    euler_angles_xyz_from_matrix4_f32 ¶

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

    euler_angles_xyz_from_matrix4_f64 ¶

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

    euler_angles_xyz_from_quaternion_f16 ¶

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

    euler_angles_xyz_from_quaternion_f32 ¶

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

    euler_angles_xyz_from_quaternion_f64 ¶

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

    euler_angles_xzx_from_matrix3_f16 ¶

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

    euler_angles_xzx_from_matrix3_f32 ¶

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

    euler_angles_xzx_from_matrix3_f64 ¶

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

    euler_angles_xzx_from_matrix4_f16 ¶

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

    euler_angles_xzx_from_matrix4_f32 ¶

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

    euler_angles_xzx_from_matrix4_f64 ¶

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

    euler_angles_xzx_from_quaternion_f16 ¶

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

    euler_angles_xzx_from_quaternion_f32 ¶

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

    euler_angles_xzx_from_quaternion_f64 ¶

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

    euler_angles_xzy_from_matrix3_f16 ¶

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

    euler_angles_xzy_from_matrix3_f32 ¶

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

    euler_angles_xzy_from_matrix3_f64 ¶

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

    euler_angles_xzy_from_matrix4_f16 ¶

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

    euler_angles_xzy_from_matrix4_f32 ¶

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

    euler_angles_xzy_from_matrix4_f64 ¶

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

    euler_angles_xzy_from_quaternion_f16 ¶

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

    euler_angles_xzy_from_quaternion_f32 ¶

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

    euler_angles_xzy_from_quaternion_f64 ¶

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

    euler_angles_yxy_from_matrix3_f16 ¶

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

    euler_angles_yxy_from_matrix3_f32 ¶

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

    euler_angles_yxy_from_matrix3_f64 ¶

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

    euler_angles_yxy_from_matrix4_f16 ¶

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

    euler_angles_yxy_from_matrix4_f32 ¶

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

    euler_angles_yxy_from_matrix4_f64 ¶

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

    euler_angles_yxy_from_quaternion_f16 ¶

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

    euler_angles_yxy_from_quaternion_f32 ¶

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

    euler_angles_yxy_from_quaternion_f64 ¶

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

    euler_angles_yxz_from_matrix3_f16 ¶

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

    euler_angles_yxz_from_matrix3_f32 ¶

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

    euler_angles_yxz_from_matrix3_f64 ¶

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

    euler_angles_yxz_from_matrix4_f16 ¶

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

    euler_angles_yxz_from_matrix4_f32 ¶

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

    euler_angles_yxz_from_matrix4_f64 ¶

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

    euler_angles_yxz_from_quaternion_f16 ¶

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

    euler_angles_yxz_from_quaternion_f32 ¶

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

    euler_angles_yxz_from_quaternion_f64 ¶

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

    euler_angles_yzx_from_matrix3_f16 ¶

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

    euler_angles_yzx_from_matrix3_f32 ¶

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

    euler_angles_yzx_from_matrix3_f64 ¶

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

    euler_angles_yzx_from_matrix4_f16 ¶

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

    euler_angles_yzx_from_matrix4_f32 ¶

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

    euler_angles_yzx_from_matrix4_f64 ¶

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

    euler_angles_yzx_from_quaternion_f16 ¶

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

    euler_angles_yzx_from_quaternion_f32 ¶

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

    euler_angles_yzx_from_quaternion_f64 ¶

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

    euler_angles_yzy_from_matrix3_f16 ¶

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

    euler_angles_yzy_from_matrix3_f32 ¶

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

    euler_angles_yzy_from_matrix3_f64 ¶

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

    euler_angles_yzy_from_matrix4_f16 ¶

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

    euler_angles_yzy_from_matrix4_f32 ¶

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

    euler_angles_yzy_from_matrix4_f64 ¶

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

    euler_angles_yzy_from_quaternion_f16 ¶

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

    euler_angles_yzy_from_quaternion_f32 ¶

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

    euler_angles_yzy_from_quaternion_f64 ¶

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

    euler_angles_zxy_from_matrix3_f16 ¶

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

    euler_angles_zxy_from_matrix3_f32 ¶

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

    euler_angles_zxy_from_matrix3_f64 ¶

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

    euler_angles_zxy_from_matrix4_f16 ¶

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

    euler_angles_zxy_from_matrix4_f32 ¶

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

    euler_angles_zxy_from_matrix4_f64 ¶

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

    euler_angles_zxy_from_quaternion_f16 ¶

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

    euler_angles_zxy_from_quaternion_f32 ¶

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

    euler_angles_zxy_from_quaternion_f64 ¶

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

    euler_angles_zxz_from_matrix3_f16 ¶

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

    euler_angles_zxz_from_matrix3_f32 ¶

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

    euler_angles_zxz_from_matrix3_f64 ¶

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

    euler_angles_zxz_from_matrix4_f16 ¶

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

    euler_angles_zxz_from_matrix4_f32 ¶

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

    euler_angles_zxz_from_matrix4_f64 ¶

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

    euler_angles_zxz_from_quaternion_f16 ¶

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

    euler_angles_zxz_from_quaternion_f32 ¶

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

    euler_angles_zxz_from_quaternion_f64 ¶

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

    euler_angles_zyx_from_matrix3_f16 ¶

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

    euler_angles_zyx_from_matrix3_f32 ¶

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

    euler_angles_zyx_from_matrix3_f64 ¶

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

    euler_angles_zyx_from_matrix4_f16 ¶

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

    euler_angles_zyx_from_matrix4_f32 ¶

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

    euler_angles_zyx_from_matrix4_f64 ¶

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

    euler_angles_zyx_from_quaternion_f16 ¶

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

    euler_angles_zyx_from_quaternion_f32 ¶

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

    euler_angles_zyx_from_quaternion_f64 ¶

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

    euler_angles_zyz_from_matrix3_f16 ¶

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

    euler_angles_zyz_from_matrix3_f32 ¶

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

    euler_angles_zyz_from_matrix3_f64 ¶

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

    euler_angles_zyz_from_matrix4_f16 ¶

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

    euler_angles_zyz_from_matrix4_f32 ¶

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

    euler_angles_zyz_from_matrix4_f64 ¶

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

    euler_angles_zyz_from_quaternion_f16 ¶

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

    euler_angles_zyz_from_quaternion_f32 ¶

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

    euler_angles_zyz_from_quaternion_f64 ¶

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

    exp ¶

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

    exp10 ¶

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

    exp2 ¶

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

    face_forward ¶

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

    floor ¶

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

    fract ¶

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

    greater_than_array ¶

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

    greater_than_equal_array ¶

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

    greater_than_equal_single ¶

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

    greater_than_single ¶

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

    hadamard_product ¶

    hadamard_product :: intrinsics.hadamard_product

    hermite ¶

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

    hermitian_adjoint ¶

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

    identity_array_based_matrix ¶

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

    identity_matrix ¶

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

    inverse_sqrt ¶

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

    is_inf_array ¶

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

    is_inf_single ¶

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

    is_nan_array ¶

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

    is_nan_single ¶

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

    lerp ¶

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

    less_than_array ¶

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

    less_than_equal_array ¶

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

    less_than_equal_single ¶

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

    less_than_single ¶

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

    ln ¶

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

    log ¶

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

    log10 ¶

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

    log2 ¶

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

    matrix1x1_adjugate ¶

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

    matrix1x1_determinant ¶

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

    matrix1x1_inverse ¶

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

    matrix1x1_inverse_transpose ¶

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

    matrix2_adjoint_f16 ¶

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

    matrix2_adjoint_f32 ¶

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

    matrix2_adjoint_f64 ¶

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

    matrix2_determinant_f16 ¶

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

    matrix2_determinant_f32 ¶

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

    matrix2_determinant_f64 ¶

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

    matrix2_from_matrix3_f16 ¶

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

    matrix2_from_matrix3_f32 ¶

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

    matrix2_from_matrix3_f64 ¶

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

    matrix2_from_matrix4_f16 ¶

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

    matrix2_from_matrix4_f32 ¶

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

    matrix2_from_matrix4_f64 ¶

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

    matrix2_from_scalar_f16 ¶

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

    matrix2_from_scalar_f32 ¶

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

    matrix2_from_scalar_f64 ¶

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

    matrix2_inverse_f16 ¶

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

    matrix2_inverse_f32 ¶

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

    matrix2_inverse_f64 ¶

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

    matrix2_inverse_transpose_f16 ¶

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

    matrix2_inverse_transpose_f32 ¶

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

    matrix2_inverse_transpose_f64 ¶

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

    matrix2_orthonormalize_f16 ¶

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

    matrix2_orthonormalize_f32 ¶

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

    matrix2_orthonormalize_f64 ¶

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

    matrix2_rotate_f16 ¶

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

    matrix2_rotate_f32 ¶

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

    matrix2_rotate_f64 ¶

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

    matrix2x2_adjugate ¶

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

    matrix2x2_determinant ¶

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

    matrix2x2_inverse ¶

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

    matrix2x2_inverse_transpose ¶

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

    matrix3_adjoint_f16 ¶

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

    matrix3_adjoint_f32 ¶

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

    matrix3_adjoint_f64 ¶

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

    matrix3_determinant_f16 ¶

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

    matrix3_determinant_f32 ¶

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

    matrix3_determinant_f64 ¶

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

    matrix3_from_derived_euler_angle_x_f16 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

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

    matrix3_from_euler_angle_x_f32 ¶

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

    matrix3_from_euler_angle_x_f64 ¶

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

    matrix3_from_euler_angle_y_f16 ¶

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

    matrix3_from_euler_angle_y_f32 ¶

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

    matrix3_from_euler_angle_y_f64 ¶

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

    matrix3_from_euler_angle_z_f16 ¶

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

    matrix3_from_euler_angle_z_f32 ¶

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

    matrix3_from_euler_angle_z_f64 ¶

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

    matrix3_from_euler_angles_f16 ¶

    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 ¶

    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 ¶

    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 ¶

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

    matrix3_from_euler_angles_xy_f32 ¶

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

    matrix3_from_euler_angles_xy_f64 ¶

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

    matrix3_from_euler_angles_xyx_f16 ¶

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

    matrix3_from_euler_angles_xyx_f32 ¶

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

    matrix3_from_euler_angles_xyx_f64 ¶

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

    matrix3_from_euler_angles_xyz_f16 ¶

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

    matrix3_from_euler_angles_xyz_f32 ¶

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

    matrix3_from_euler_angles_xyz_f64 ¶

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

    matrix3_from_euler_angles_xz_f16 ¶

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

    matrix3_from_euler_angles_xz_f32 ¶

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

    matrix3_from_euler_angles_xz_f64 ¶

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

    matrix3_from_euler_angles_xzx_f16 ¶

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

    matrix3_from_euler_angles_xzx_f32 ¶

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

    matrix3_from_euler_angles_xzx_f64 ¶

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

    matrix3_from_euler_angles_xzy_f16 ¶

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

    matrix3_from_euler_angles_xzy_f32 ¶

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

    matrix3_from_euler_angles_xzy_f64 ¶

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

    matrix3_from_euler_angles_yx_f16 ¶

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

    matrix3_from_euler_angles_yx_f32 ¶

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

    matrix3_from_euler_angles_yx_f64 ¶

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

    matrix3_from_euler_angles_yxy_f16 ¶

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

    matrix3_from_euler_angles_yxy_f32 ¶

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

    matrix3_from_euler_angles_yxy_f64 ¶

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

    matrix3_from_euler_angles_yxz_f16 ¶

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

    matrix3_from_euler_angles_yxz_f32 ¶

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

    matrix3_from_euler_angles_yxz_f64 ¶

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

    matrix3_from_euler_angles_yz_f16 ¶

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

    matrix3_from_euler_angles_yz_f32 ¶

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

    matrix3_from_euler_angles_yz_f64 ¶

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

    matrix3_from_euler_angles_yzx_f16 ¶

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

    matrix3_from_euler_angles_yzx_f32 ¶

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

    matrix3_from_euler_angles_yzx_f64 ¶

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

    matrix3_from_euler_angles_yzy_f16 ¶

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

    matrix3_from_euler_angles_yzy_f32 ¶

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

    matrix3_from_euler_angles_yzy_f64 ¶

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

    matrix3_from_euler_angles_zx_f16 ¶

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

    matrix3_from_euler_angles_zx_f32 ¶

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

    matrix3_from_euler_angles_zx_f64 ¶

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

    matrix3_from_euler_angles_zxy_f16 ¶

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

    matrix3_from_euler_angles_zxy_f32 ¶

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

    matrix3_from_euler_angles_zxy_f64 ¶

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

    matrix3_from_euler_angles_zxz_f16 ¶

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

    matrix3_from_euler_angles_zxz_f32 ¶

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

    matrix3_from_euler_angles_zxz_f64 ¶

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

    matrix3_from_euler_angles_zy_f16 ¶

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

    matrix3_from_euler_angles_zy_f32 ¶

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

    matrix3_from_euler_angles_zy_f64 ¶

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

    matrix3_from_euler_angles_zyx_f16 ¶

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

    matrix3_from_euler_angles_zyx_f32 ¶

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

    matrix3_from_euler_angles_zyx_f64 ¶

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

    matrix3_from_euler_angles_zyz_f16 ¶

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

    matrix3_from_euler_angles_zyz_f32 ¶

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

    matrix3_from_euler_angles_zyz_f64 ¶

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

    matrix3_from_matrix2_f16 ¶

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

    matrix3_from_matrix2_f32 ¶

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

    matrix3_from_matrix2_f64 ¶

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

    matrix3_from_matrix4_f16 ¶

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

    matrix3_from_matrix4_f32 ¶

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

    matrix3_from_matrix4_f64 ¶

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

    matrix3_from_quaternion_f16 ¶

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

    matrix3_from_quaternion_f32 ¶

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

    matrix3_from_quaternion_f64 ¶

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

    matrix3_from_scalar_f16 ¶

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

    matrix3_from_scalar_f32 ¶

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

    matrix3_from_scalar_f64 ¶

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

    matrix3_from_yaw_pitch_roll_f16 ¶

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

    matrix3_from_yaw_pitch_roll_f32 ¶

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

    matrix3_from_yaw_pitch_roll_f64 ¶

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

    matrix3_inverse_f16 ¶

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

    matrix3_inverse_f32 ¶

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

    matrix3_inverse_f64 ¶

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

    matrix3_inverse_transpose_f16 ¶

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

    matrix3_inverse_transpose_f32 ¶

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

    matrix3_inverse_transpose_f64 ¶

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

    matrix3_look_at_f16 ¶

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

    matrix3_look_at_f32 ¶

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

    matrix3_look_at_f64 ¶

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

    matrix3_orthonormalize_f16 ¶

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

    matrix3_orthonormalize_f32 ¶

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

    matrix3_orthonormalize_f64 ¶

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

    matrix3_rotate_f16 ¶

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

    matrix3_rotate_f32 ¶

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

    matrix3_rotate_f64 ¶

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

    matrix3_scale_f16 ¶

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

    matrix3_scale_f32 ¶

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

    matrix3_scale_f64 ¶

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

    matrix3x3_adjugate ¶

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

    matrix3x3_determinant ¶

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

    matrix3x3_inverse ¶

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

    matrix3x3_inverse_transpose ¶

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

    matrix4_adjoint_f16 ¶

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

    matrix4_adjoint_f32 ¶

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

    matrix4_adjoint_f64 ¶

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

    matrix4_cofactor_f16 ¶

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

    matrix4_cofactor_f32 ¶

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

    matrix4_cofactor_f64 ¶

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

    matrix4_determinant_f16 ¶

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

    matrix4_determinant_f32 ¶

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

    matrix4_determinant_f64 ¶

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

    matrix4_from_derived_euler_angle_x_f16 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

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

    matrix4_from_euler_angle_x_f32 ¶

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

    matrix4_from_euler_angle_x_f64 ¶

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

    matrix4_from_euler_angle_y_f16 ¶

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

    matrix4_from_euler_angle_y_f32 ¶

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

    matrix4_from_euler_angle_y_f64 ¶

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

    matrix4_from_euler_angle_z_f16 ¶

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

    matrix4_from_euler_angle_z_f32 ¶

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

    matrix4_from_euler_angle_z_f64 ¶

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

    matrix4_from_euler_angles_f16 ¶

    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 ¶

    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 ¶

    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 ¶

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

    matrix4_from_euler_angles_xy_f32 ¶

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

    matrix4_from_euler_angles_xy_f64 ¶

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

    matrix4_from_euler_angles_xyx_f16 ¶

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

    matrix4_from_euler_angles_xyx_f32 ¶

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

    matrix4_from_euler_angles_xyx_f64 ¶

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

    matrix4_from_euler_angles_xyz_f16 ¶

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

    matrix4_from_euler_angles_xyz_f32 ¶

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

    matrix4_from_euler_angles_xyz_f64 ¶

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

    matrix4_from_euler_angles_xz_f16 ¶

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

    matrix4_from_euler_angles_xz_f32 ¶

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

    matrix4_from_euler_angles_xz_f64 ¶

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

    matrix4_from_euler_angles_xzx_f16 ¶

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

    matrix4_from_euler_angles_xzx_f32 ¶

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

    matrix4_from_euler_angles_xzx_f64 ¶

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

    matrix4_from_euler_angles_xzy_f16 ¶

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

    matrix4_from_euler_angles_xzy_f32 ¶

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

    matrix4_from_euler_angles_xzy_f64 ¶

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

    matrix4_from_euler_angles_yx_f16 ¶

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

    matrix4_from_euler_angles_yx_f32 ¶

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

    matrix4_from_euler_angles_yx_f64 ¶

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

    matrix4_from_euler_angles_yxy_f16 ¶

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

    matrix4_from_euler_angles_yxy_f32 ¶

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

    matrix4_from_euler_angles_yxy_f64 ¶

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

    matrix4_from_euler_angles_yxz_f16 ¶

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

    matrix4_from_euler_angles_yxz_f32 ¶

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

    matrix4_from_euler_angles_yxz_f64 ¶

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

    matrix4_from_euler_angles_yz_f16 ¶

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

    matrix4_from_euler_angles_yz_f32 ¶

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

    matrix4_from_euler_angles_yz_f64 ¶

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

    matrix4_from_euler_angles_yzx_f16 ¶

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

    matrix4_from_euler_angles_yzx_f32 ¶

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

    matrix4_from_euler_angles_yzx_f64 ¶

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

    matrix4_from_euler_angles_yzy_f16 ¶

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

    matrix4_from_euler_angles_yzy_f32 ¶

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

    matrix4_from_euler_angles_yzy_f64 ¶

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

    matrix4_from_euler_angles_zx_f16 ¶

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

    matrix4_from_euler_angles_zx_f32 ¶

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

    matrix4_from_euler_angles_zx_f64 ¶

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

    matrix4_from_euler_angles_zxy_f16 ¶

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

    matrix4_from_euler_angles_zxy_f32 ¶

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

    matrix4_from_euler_angles_zxy_f64 ¶

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

    matrix4_from_euler_angles_zxz_f16 ¶

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

    matrix4_from_euler_angles_zxz_f32 ¶

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

    matrix4_from_euler_angles_zxz_f64 ¶

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

    matrix4_from_euler_angles_zy_f16 ¶

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

    matrix4_from_euler_angles_zy_f32 ¶

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

    matrix4_from_euler_angles_zy_f64 ¶

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

    matrix4_from_euler_angles_zyx_f16 ¶

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

    matrix4_from_euler_angles_zyx_f32 ¶

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

    matrix4_from_euler_angles_zyx_f64 ¶

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

    matrix4_from_euler_angles_zyz_f16 ¶

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

    matrix4_from_euler_angles_zyz_f32 ¶

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

    matrix4_from_euler_angles_zyz_f64 ¶

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

    matrix4_from_matrix2_f16 ¶

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

    matrix4_from_matrix2_f32 ¶

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

    matrix4_from_matrix2_f64 ¶

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

    matrix4_from_matrix3_f16 ¶

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

    matrix4_from_matrix3_f32 ¶

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

    matrix4_from_matrix3_f64 ¶

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

    matrix4_from_quaternion_f16 ¶

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

    matrix4_from_quaternion_f32 ¶

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

    matrix4_from_quaternion_f64 ¶

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

    matrix4_from_scalar_f16 ¶

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

    matrix4_from_scalar_f32 ¶

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

    matrix4_from_scalar_f64 ¶

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

    matrix4_from_trs_f16 ¶

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

    matrix4_from_trs_f32 ¶

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

    matrix4_from_trs_f64 ¶

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

    matrix4_from_yaw_pitch_roll_f16 ¶

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

    matrix4_from_yaw_pitch_roll_f32 ¶

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

    matrix4_from_yaw_pitch_roll_f64 ¶

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

    matrix4_infinite_perspective_f16 ¶

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

    matrix4_infinite_perspective_f32 ¶

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

    matrix4_infinite_perspective_f64 ¶

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

    matrix4_inverse_f16 ¶

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

    matrix4_inverse_f32 ¶

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

    matrix4_inverse_f64 ¶

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

    matrix4_inverse_transpose_f16 ¶

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

    matrix4_inverse_transpose_f32 ¶

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

    matrix4_inverse_transpose_f64 ¶

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

    matrix4_look_at_f16 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

    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 ¶

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

    matrix4_minor_f32 ¶

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

    matrix4_minor_f64 ¶

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

    matrix4_orientation_f16 ¶

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

    matrix4_orientation_f32 ¶

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

    matrix4_orientation_f64 ¶

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

    matrix4_perspective_f16 ¶

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

    matrix4_perspective_f32 ¶

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

    matrix4_perspective_f64 ¶

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

    matrix4_rotate_f16 ¶

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

    matrix4_rotate_f32 ¶

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

    matrix4_rotate_f64 ¶

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

    matrix4_scale_f16 ¶

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

    matrix4_scale_f32 ¶

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

    matrix4_scale_f64 ¶

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

    matrix4_translate_f16 ¶

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

    matrix4_translate_f32 ¶

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

    matrix4_translate_f64 ¶

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

    matrix4x4_adjugate ¶

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

    matrix4x4_determinant ¶

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

    matrix4x4_inverse ¶

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

    matrix4x4_inverse_transpose ¶

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

    matrix_cast ¶

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

    matrix_comp_mul ¶

    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 ¶

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

    matrix_mul ¶

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

    matrix_mul_differ ¶

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

    matrix_mul_vector ¶

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

    matrix_ortho3d_f16 ¶

    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 ¶

    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 ¶

    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 ¶

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

    max_double ¶

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

    max_single ¶

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

    max_triple ¶

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

    min_double ¶

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

    min_single ¶

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

    min_triple ¶

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

    mix ¶

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

    mod ¶

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

    not ¶

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

    not_equal_array ¶

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

    not_equal_single ¶

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

    outer_product ¶

    outer_product :: intrinsics.outer_product

    pitch_from_quaternion_f16 ¶

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

    pitch_from_quaternion_f32 ¶

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

    pitch_from_quaternion_f64 ¶

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

    pitch_yaw_roll_from_quaternion_f16 ¶

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

    pitch_yaw_roll_from_quaternion_f32 ¶

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

    pitch_yaw_roll_from_quaternion_f64 ¶

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

    polar_from_euclidean_f16 ¶

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

    polar_from_euclidean_f32 ¶

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

    polar_from_euclidean_f64 ¶

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

    pow ¶

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

    projection ¶

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

    quaternion128_angle_between ¶

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

    quaternion128_dot ¶

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

    quaternion128_mul_vector3 ¶

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

    quaternion256_angle_between ¶

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

    quaternion256_dot ¶

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

    quaternion256_mul_vector3 ¶

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

    quaternion64_angle_between ¶

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

    quaternion64_dot ¶

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

    quaternion64_mul_vector3 ¶

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

    quaternion_angle_axis_f16 ¶

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

    quaternion_angle_axis_f32 ¶

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

    quaternion_angle_axis_f64 ¶

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

    quaternion_between_two_vector3_f16 ¶

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

    quaternion_between_two_vector3_f32 ¶

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

    quaternion_between_two_vector3_f64 ¶

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

    quaternion_cross ¶

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

    quaternion_from_euler_angle_x_f16 ¶

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

    quaternion_from_euler_angle_x_f32 ¶

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

    quaternion_from_euler_angle_x_f64 ¶

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

    quaternion_from_euler_angle_y_f16 ¶

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

    quaternion_from_euler_angle_y_f32 ¶

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

    quaternion_from_euler_angle_y_f64 ¶

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

    quaternion_from_euler_angle_z_f16 ¶

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

    quaternion_from_euler_angle_z_f32 ¶

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

    quaternion_from_euler_angle_z_f64 ¶

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

    quaternion_from_euler_angles_f16 ¶

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

    quaternion_from_euler_angles_f32 ¶

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

    quaternion_from_euler_angles_f64 ¶

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

    quaternion_from_forward_and_up_f16 ¶

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

    quaternion_from_forward_and_up_f32 ¶

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

    quaternion_from_forward_and_up_f64 ¶

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

    quaternion_from_matrix3_f16 ¶

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

    quaternion_from_matrix3_f32 ¶

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

    quaternion_from_matrix3_f64 ¶

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

    quaternion_from_matrix4_f16 ¶

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

    quaternion_from_matrix4_f32 ¶

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

    quaternion_from_matrix4_f64 ¶

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

    quaternion_from_pitch_yaw_roll_f16 ¶

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

    quaternion_from_pitch_yaw_roll_f32 ¶

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

    quaternion_from_pitch_yaw_roll_f64 ¶

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

    quaternion_from_scalar_f16 ¶

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

    quaternion_from_scalar_f32 ¶

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

    quaternion_from_scalar_f64 ¶

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

    quaternion_inverse ¶

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

    quaternion_length ¶

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

    quaternion_length2 ¶

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

    quaternion_look_at_f16 ¶

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

    quaternion_look_at_f32 ¶

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

    quaternion_look_at_f64 ¶

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

    quaternion_mul_quaternion ¶

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

    quaternion_nlerp_f16 ¶

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

    quaternion_nlerp_f32 ¶

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

    quaternion_nlerp_f64 ¶

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

    quaternion_normalize ¶

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

    quaternion_normalize0 ¶

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

    quaternion_slerp_f16 ¶

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

    quaternion_slerp_f32 ¶

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

    quaternion_slerp_f64 ¶

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

    quaternion_squad_f16 ¶

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

    quaternion_squad_f32 ¶

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

    quaternion_squad_f64 ¶

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

    reflect ¶

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

    refract ¶

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

    roll_from_quaternion_f16 ¶

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

    roll_from_quaternion_f32 ¶

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

    roll_from_quaternion_f64 ¶

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

    round ¶

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

    saturate ¶

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

    scalar_cross ¶

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

    scalar_dot ¶

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

    scalar_f32_swizzle1 ¶

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

    scalar_f32_swizzle2 ¶

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

    scalar_f32_swizzle3 ¶

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

    scalar_f32_swizzle4 ¶

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

    scalar_f64_swizzle1 ¶

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

    scalar_f64_swizzle2 ¶

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

    scalar_f64_swizzle3 ¶

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

    scalar_f64_swizzle4 ¶

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

    scalar_triple_product ¶

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

    sign ¶

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

    sin ¶

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

    smootherstep ¶

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

    smoothstep ¶

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

    sqrt ¶

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

    step ¶

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

    tan ¶

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

    to_complex128 ¶

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

    to_complex32 ¶

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

    to_complex64 ¶

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

    to_degrees ¶

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

    to_f32 ¶

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

    to_f64 ¶

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

    to_i16 ¶

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

    to_i32 ¶

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

    to_i64 ¶

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

    to_i8 ¶

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

    to_int ¶

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

    to_quaternion128 ¶

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

    to_quaternion256 ¶

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

    to_quaternion64 ¶

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

    to_radians ¶

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

    to_u16 ¶

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

    to_u32 ¶

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

    to_u64 ¶

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

    to_u8 ¶

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

    to_uint ¶

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

    trace ¶

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

    transpose ¶

    transpose :: intrinsics.transpose

    unlerp ¶

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

    vector2_orthogonal ¶

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

    vector2f32_swizzle1 ¶

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

    vector2f32_swizzle2 ¶

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

    vector2f32_swizzle3 ¶

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

    vector2f32_swizzle4 ¶

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

    vector2f64_swizzle1 ¶

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

    vector2f64_swizzle2 ¶

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

    vector2f64_swizzle3 ¶

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

    vector2f64_swizzle4 ¶

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

    vector3_orthogonal ¶

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

    vector3_orthonormalize_f16 ¶

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

    vector3_orthonormalize_f32 ¶

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

    vector3_orthonormalize_f64 ¶

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

    vector3f32_swizzle1 ¶

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

    vector3f32_swizzle2 ¶

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

    vector3f32_swizzle3 ¶

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

    vector3f32_swizzle4 ¶

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

    vector3f64_swizzle1 ¶

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

    vector3f64_swizzle2 ¶

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

    vector3f64_swizzle3 ¶

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

    vector3f64_swizzle4 ¶

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

    vector4_hsl_to_rgb_f16 ¶

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

    vector4_hsl_to_rgb_f32 ¶

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

    vector4_hsl_to_rgb_f64 ¶

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

    vector4_linear_to_srgb_f16 ¶

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

    vector4_linear_to_srgb_f32 ¶

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

    vector4_linear_to_srgb_f64 ¶

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

    vector4_rgb_to_hsl_f16 ¶

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

    vector4_rgb_to_hsl_f32 ¶

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

    vector4_rgb_to_hsl_f64 ¶

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

    vector4_srgb_to_linear_f16 ¶

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

    vector4_srgb_to_linear_f32 ¶

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

    vector4_srgb_to_linear_f64 ¶

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

    vector4f32_swizzle1 ¶

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

    vector4f32_swizzle2 ¶

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

    vector4f32_swizzle3 ¶

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

    vector4f32_swizzle4 ¶

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

    vector4f64_swizzle1 ¶

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

    vector4f64_swizzle2 ¶

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

    vector4f64_swizzle3 ¶

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

    vector4f64_swizzle4 ¶

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

    vector_angle_between ¶

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

    vector_cross2 ¶

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

    vector_cross3 ¶

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

    vector_dot ¶

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

    vector_length ¶

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

    vector_length2 ¶

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

    vector_normalize ¶

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

    vector_normalize0 ¶

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

    vector_slerp ¶

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

    vector_to_ptr ¶

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

    vector_triple_product ¶

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

    yaw_from_quaternion_f16 ¶

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

    yaw_from_quaternion_f32 ¶

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

    yaw_from_quaternion_f64 ¶

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

    Procedure Groups

    Source Files

    Generation Information

    Generated with odin version dev-2024-11 (vendor "odin") Windows_amd64 @ 2024-11-20 21:11:50.681510300 +0000 UTC