Linear algebra procedures useful for 3D spatial transformations.

Collection Info

View Source
Collection
core
Path
math/linalg
Entries
1013
Constants 42
Jump to Constants
DEG_PER_RAD e E F16_EPSILON F32_EPSILON F64_EPSILON LN10 LN2 MATRIX1F16_IDENTITY MATRIX1F32_IDENTITY MATRIX1F64_IDENTITY MATRIX2F16_IDENTITY MATRIX2F32_IDENTITY MATRIX2F64_IDENTITY MATRIX3F16_IDENTITY MATRIX3F32_IDENTITY +26 more
Types 77
Jump to Types
Euler_Angle_Order Matrix1f16 Matrix1f32 Matrix1f64 Matrix1x1f16 Matrix1x1f32 Matrix1x1f64 Matrix1x2f16 Matrix1x2f32 Matrix1x2f64 Matrix1x3f16 Matrix1x3f32 Matrix1x3f64 Matrix1x4f16 Matrix1x4f32 Matrix1x4f64 +61 more
Procedures 679
Jump to Procedures
abs acos all angle_axis_from_quaternion_f16 angle_axis_from_quaternion_f32 angle_axis_from_quaternion_f64 angle_from_quaternion_f16 angle_from_quaternion_f32 angle_from_quaternion_f64 any array_cast asin atan atan2 axis_from_quaternion_f16 axis_from_quaternion_f32 +663 more
Procedure Groups 215
Jump to Procedure Groups
adjugate angle_axis_from_quaternion angle_between angle_from_quaternion axis_from_quaternion classify cofactor cross determinant dot equal euclidean_from_polar euler_angles_from_matrix3 euler_angles_from_matrix4 euler_angles_from_quaternion euler_angles_xyx_from_matrix3 +199 more
Variables 0

Source Files

Constants

42

MAX_F32_PRECISION #

Source 
MAX_F32_PRECISION :: 8

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

MAX_F64_PRECISION #

Source 
MAX_F64_PRECISION :: 16

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

QUATERNIONF16_IDENTITY #

Source 
QUATERNIONF16_IDENTITY :: Quaternionf16(1)

QUATERNIONF32_IDENTITY #

Source 
QUATERNIONF32_IDENTITY :: Quaternionf32(1)

QUATERNIONF64_IDENTITY #

Source 
QUATERNIONF64_IDENTITY :: Quaternionf64(1)

SQRT_FIVE #

Source 
SQRT_FIVE :: 2.23606797749978969640917366873127623

SQRT_THREE #

Source 
SQRT_THREE :: 1.73205080756887729352744634150587236

Types

77

Procedures

679

abs #

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

acos #

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

angle_axis_from_quaternion_f16 #

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

angle_axis_from_quaternion_f32 #

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

angle_axis_from_quaternion_f64 #

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

array_cast #

Source 
@(require_results)
array_cast :: proc "contextless" (v: $A/[$N]$T, $Elem_Type: typeid) -> (w: $$deferred_return) {…}

asin #

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

atan #

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

atan2 #

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

catmull_rom #

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

ceil #

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

clamp #

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

clamp_length #

Source 
@(require_results)
clamp_length :: proc "contextless" (v: $T/[$N]$E, a: $E) -> $$deferred_return {…}

classify_array #

Source 
@(require_results)
classify_array :: proc "contextless" (x: $A/[$N]$T) -> (out: $$deferred_return) {…}

cos #

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

cubic #

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

distance #

Source 
@(require_results)
distance :: proc "contextless" (p0, p1: $V/[$N]$E) -> $$deferred_return {…}

equal_array #

Source 
@(require_results)
equal_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: $$deferred_return) {…}

equal_single #

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

euclidean_from_polar_f16 #

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

euclidean_from_polar_f32 #

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

euclidean_from_polar_f64 #

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

euler_angles_xyx_from_matrix3_f16 #

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

euler_angles_xyx_from_matrix3_f32 #

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

euler_angles_xyx_from_matrix3_f64 #

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

euler_angles_xyx_from_matrix4_f16 #

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

euler_angles_xyx_from_matrix4_f32 #

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

euler_angles_xyx_from_matrix4_f64 #

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

euler_angles_xyx_from_quaternion_f16 #

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

euler_angles_xyx_from_quaternion_f32 #

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

euler_angles_xyx_from_quaternion_f64 #

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

euler_angles_xyz_from_matrix3_f16 #

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

euler_angles_xyz_from_matrix3_f32 #

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

euler_angles_xyz_from_matrix3_f64 #

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

euler_angles_xyz_from_matrix4_f16 #

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

euler_angles_xyz_from_matrix4_f32 #

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

euler_angles_xyz_from_matrix4_f64 #

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

euler_angles_xyz_from_quaternion_f16 #

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

euler_angles_xyz_from_quaternion_f32 #

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

euler_angles_xyz_from_quaternion_f64 #

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

euler_angles_xzx_from_matrix3_f16 #

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

euler_angles_xzx_from_matrix3_f32 #

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

euler_angles_xzx_from_matrix3_f64 #

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

euler_angles_xzx_from_matrix4_f16 #

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

euler_angles_xzx_from_matrix4_f32 #

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

euler_angles_xzx_from_matrix4_f64 #

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

euler_angles_xzx_from_quaternion_f16 #

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

euler_angles_xzx_from_quaternion_f32 #

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

euler_angles_xzx_from_quaternion_f64 #

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

euler_angles_xzy_from_matrix3_f16 #

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

euler_angles_xzy_from_matrix3_f32 #

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

euler_angles_xzy_from_matrix3_f64 #

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

euler_angles_xzy_from_matrix4_f16 #

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

euler_angles_xzy_from_matrix4_f32 #

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

euler_angles_xzy_from_matrix4_f64 #

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

euler_angles_xzy_from_quaternion_f16 #

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

euler_angles_xzy_from_quaternion_f32 #

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

euler_angles_xzy_from_quaternion_f64 #

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

euler_angles_yxy_from_matrix3_f16 #

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

euler_angles_yxy_from_matrix3_f32 #

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

euler_angles_yxy_from_matrix3_f64 #

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

euler_angles_yxy_from_matrix4_f16 #

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

euler_angles_yxy_from_matrix4_f32 #

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

euler_angles_yxy_from_matrix4_f64 #

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

euler_angles_yxy_from_quaternion_f16 #

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

euler_angles_yxy_from_quaternion_f32 #

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

euler_angles_yxy_from_quaternion_f64 #

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

euler_angles_yxz_from_matrix3_f16 #

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

euler_angles_yxz_from_matrix3_f32 #

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

euler_angles_yxz_from_matrix3_f64 #

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

euler_angles_yxz_from_matrix4_f16 #

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

euler_angles_yxz_from_matrix4_f32 #

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

euler_angles_yxz_from_matrix4_f64 #

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

euler_angles_yxz_from_quaternion_f16 #

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

euler_angles_yxz_from_quaternion_f32 #

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

euler_angles_yxz_from_quaternion_f64 #

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

euler_angles_yzx_from_matrix3_f16 #

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

euler_angles_yzx_from_matrix3_f32 #

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

euler_angles_yzx_from_matrix3_f64 #

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

euler_angles_yzx_from_matrix4_f16 #

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

euler_angles_yzx_from_matrix4_f32 #

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

euler_angles_yzx_from_matrix4_f64 #

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

euler_angles_yzx_from_quaternion_f16 #

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

euler_angles_yzx_from_quaternion_f32 #

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

euler_angles_yzx_from_quaternion_f64 #

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

euler_angles_yzy_from_matrix3_f16 #

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

euler_angles_yzy_from_matrix3_f32 #

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

euler_angles_yzy_from_matrix3_f64 #

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

euler_angles_yzy_from_matrix4_f16 #

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

euler_angles_yzy_from_matrix4_f32 #

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

euler_angles_yzy_from_matrix4_f64 #

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

euler_angles_yzy_from_quaternion_f16 #

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

euler_angles_yzy_from_quaternion_f32 #

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

euler_angles_yzy_from_quaternion_f64 #

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

euler_angles_zxy_from_matrix3_f16 #

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

euler_angles_zxy_from_matrix3_f32 #

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

euler_angles_zxy_from_matrix3_f64 #

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

euler_angles_zxy_from_matrix4_f16 #

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

euler_angles_zxy_from_matrix4_f32 #

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

euler_angles_zxy_from_matrix4_f64 #

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

euler_angles_zxy_from_quaternion_f16 #

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

euler_angles_zxy_from_quaternion_f32 #

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

euler_angles_zxy_from_quaternion_f64 #

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

euler_angles_zxz_from_matrix3_f16 #

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

euler_angles_zxz_from_matrix3_f32 #

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

euler_angles_zxz_from_matrix3_f64 #

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

euler_angles_zxz_from_matrix4_f16 #

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

euler_angles_zxz_from_matrix4_f32 #

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

euler_angles_zxz_from_matrix4_f64 #

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

euler_angles_zxz_from_quaternion_f16 #

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

euler_angles_zxz_from_quaternion_f32 #

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

euler_angles_zxz_from_quaternion_f64 #

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

euler_angles_zyx_from_matrix3_f16 #

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

euler_angles_zyx_from_matrix3_f32 #

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

euler_angles_zyx_from_matrix3_f64 #

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

euler_angles_zyx_from_matrix4_f16 #

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

euler_angles_zyx_from_matrix4_f32 #

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

euler_angles_zyx_from_matrix4_f64 #

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

euler_angles_zyx_from_quaternion_f16 #

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

euler_angles_zyx_from_quaternion_f32 #

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

euler_angles_zyx_from_quaternion_f64 #

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

euler_angles_zyz_from_matrix3_f16 #

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

euler_angles_zyz_from_matrix3_f32 #

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

euler_angles_zyz_from_matrix3_f64 #

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

euler_angles_zyz_from_matrix4_f16 #

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

euler_angles_zyz_from_matrix4_f32 #

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

euler_angles_zyz_from_matrix4_f64 #

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

euler_angles_zyz_from_quaternion_f16 #

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

euler_angles_zyz_from_quaternion_f32 #

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

euler_angles_zyz_from_quaternion_f64 #

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

exp #

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

exp10 #

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

exp2 #

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

face_forward #

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

floor #

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

fract #

Source 
@(require_results)
fract :: proc "contextless" (x: $T) -> $$deferred_return {…}

greater_than_array #

Source 
@(require_results)
greater_than_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: $$deferred_return) {…}

greater_than_equal_array #

Source 
@(require_results)
greater_than_equal_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: $$deferred_return) {…}

greater_than_equal_single #

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

greater_than_single #

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

hermite #

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

hermitian_adjoint #

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

identity_array_based_matrix #

Source 
@(require_results)
identity_array_based_matrix :: proc "contextless" ($T: typeid/[$N][$N]$E) -> (m: $$deferred_return) {…}

identity_matrix #

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

inverse_sqrt #

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

is_inf_array #

Source 
@(require_results)
is_inf_array :: proc "contextless" (x: $A/[$N]$T) -> (out: $$deferred_return) {…}

is_inf_single #

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

is_nan_array #

Source 
@(require_results)
is_nan_array :: proc "contextless" (x: $A/[$N]$T) -> (out: $$deferred_return) {…}

is_nan_single #

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

lerp #

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

less_than_array #

Source 
@(require_results)
less_than_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: $$deferred_return) {…}

less_than_equal_array #

Source 
@(require_results)
less_than_equal_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: $$deferred_return) {…}

less_than_equal_single #

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

less_than_single #

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

ln #

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

log #

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

log10 #

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

log2 #

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

matrix_cast #

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

matrix_comp_mul #

Source 
@(require_results)
matrix_comp_mul :: proc "contextless" (a, b: $M/matrix[0, 0]$E) -> (c: $$deferred_return) {…}

matrix_minor #

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

matrix_mul #

Source 
@(require_results)
matrix_mul :: proc "contextless" (a, b: $M/matrix[0, 0]$E) -> (c: $$deferred_return) {…}

matrix_mul_differ #

Source 
@(require_results)
matrix_mul_differ :: proc "contextless" (a: $A/matrix[0, 0]$E, b: $B/matrix[0, 0]$E) -> (c: matrix[0, 0]$E) {…}

matrix_mul_vector #

Source 
@(require_results)
matrix_mul_vector :: proc "contextless" (a: $A/matrix[3, 3]$E, b: $B/[3]$E) -> (c: $$deferred_return) {…}

matrix_ortho3d_f16 #

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

matrix_ortho3d_f32 #

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

matrix_ortho3d_f64 #

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

matrix_to_ptr #

Source 
@(require_results)
matrix_to_ptr :: proc "contextless" (m: ^$A/matrix[0, 0]$E) -> $$deferred_return {…}

matrix1x1_adjugate #

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

matrix1x1_cofactor #

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

matrix1x1_determinant #

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

matrix1x1_inverse #

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

matrix1x1_inverse_transpose #

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

matrix2_adjoint_f16 #

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

matrix2_adjoint_f32 #

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

matrix2_adjoint_f64 #

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

matrix2_determinant_f16 #

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

matrix2_determinant_f32 #

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

matrix2_determinant_f64 #

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

matrix2_from_matrix3_f16 #

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

matrix2_from_matrix3_f32 #

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

matrix2_from_matrix3_f64 #

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

matrix2_from_matrix4_f16 #

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

matrix2_from_matrix4_f32 #

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

matrix2_from_matrix4_f64 #

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

matrix2_from_scalar_f16 #

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

matrix2_from_scalar_f32 #

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

matrix2_from_scalar_f64 #

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

matrix2_inverse_f16 #

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

matrix2_inverse_f32 #

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

matrix2_inverse_f64 #

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

matrix2_inverse_transpose_f16 #

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

matrix2_inverse_transpose_f32 #

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

matrix2_inverse_transpose_f64 #

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

matrix2_orthonormalize_f16 #

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

matrix2_orthonormalize_f32 #

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

matrix2_orthonormalize_f64 #

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

matrix2_rotate_f16 #

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

matrix2_rotate_f32 #

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

matrix2_rotate_f64 #

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

matrix2x2_adjugate #

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

matrix2x2_cofactor #

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

matrix2x2_determinant #

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

matrix2x2_inverse #

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

matrix2x2_inverse_transpose #

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

matrix3_adjoint_f16 #

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

matrix3_adjoint_f32 #

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

matrix3_adjoint_f64 #

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

matrix3_determinant_f16 #

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

matrix3_determinant_f32 #

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

matrix3_determinant_f64 #

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

matrix3_from_derived_euler_angle_x_f16 #

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

matrix3_from_derived_euler_angle_x_f32 #

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

matrix3_from_derived_euler_angle_x_f64 #

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

matrix3_from_derived_euler_angle_y_f16 #

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

matrix3_from_derived_euler_angle_y_f32 #

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

matrix3_from_derived_euler_angle_y_f64 #

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

matrix3_from_derived_euler_angle_z_f16 #

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

matrix3_from_derived_euler_angle_z_f32 #

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

matrix3_from_derived_euler_angle_z_f64 #

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

matrix3_from_euler_angle_x_f16 #

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

matrix3_from_euler_angle_x_f32 #

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

matrix3_from_euler_angle_x_f64 #

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

matrix3_from_euler_angle_y_f16 #

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

matrix3_from_euler_angle_y_f32 #

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

matrix3_from_euler_angle_y_f64 #

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

matrix3_from_euler_angle_z_f16 #

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

matrix3_from_euler_angle_z_f32 #

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

matrix3_from_euler_angle_z_f64 #

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

matrix3_from_euler_angles_xy_f16 #

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

matrix3_from_euler_angles_xy_f32 #

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

matrix3_from_euler_angles_xy_f64 #

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

matrix3_from_euler_angles_xyx_f16 #

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

matrix3_from_euler_angles_xyx_f32 #

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

matrix3_from_euler_angles_xyx_f64 #

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

matrix3_from_euler_angles_xyz_f16 #

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

matrix3_from_euler_angles_xyz_f32 #

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

matrix3_from_euler_angles_xyz_f64 #

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

matrix3_from_euler_angles_xz_f16 #

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

matrix3_from_euler_angles_xz_f32 #

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

matrix3_from_euler_angles_xz_f64 #

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

matrix3_from_euler_angles_xzx_f16 #

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

matrix3_from_euler_angles_xzx_f32 #

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

matrix3_from_euler_angles_xzx_f64 #

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

matrix3_from_euler_angles_xzy_f16 #

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

matrix3_from_euler_angles_xzy_f32 #

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

matrix3_from_euler_angles_xzy_f64 #

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

matrix3_from_euler_angles_yx_f16 #

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

matrix3_from_euler_angles_yx_f32 #

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

matrix3_from_euler_angles_yx_f64 #

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

matrix3_from_euler_angles_yxy_f16 #

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

matrix3_from_euler_angles_yxy_f32 #

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

matrix3_from_euler_angles_yxy_f64 #

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

matrix3_from_euler_angles_yxz_f16 #

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

matrix3_from_euler_angles_yxz_f32 #

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

matrix3_from_euler_angles_yxz_f64 #

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

matrix3_from_euler_angles_yz_f16 #

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

matrix3_from_euler_angles_yz_f32 #

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

matrix3_from_euler_angles_yz_f64 #

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

matrix3_from_euler_angles_yzx_f16 #

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

matrix3_from_euler_angles_yzx_f32 #

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

matrix3_from_euler_angles_yzx_f64 #

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

matrix3_from_euler_angles_yzy_f16 #

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

matrix3_from_euler_angles_yzy_f32 #

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

matrix3_from_euler_angles_yzy_f64 #

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

matrix3_from_euler_angles_zx_f16 #

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

matrix3_from_euler_angles_zx_f32 #

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

matrix3_from_euler_angles_zx_f64 #

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

matrix3_from_euler_angles_zxy_f16 #

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

matrix3_from_euler_angles_zxy_f32 #

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

matrix3_from_euler_angles_zxy_f64 #

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

matrix3_from_euler_angles_zxz_f16 #

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

matrix3_from_euler_angles_zxz_f32 #

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

matrix3_from_euler_angles_zxz_f64 #

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

matrix3_from_euler_angles_zy_f16 #

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

matrix3_from_euler_angles_zy_f32 #

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

matrix3_from_euler_angles_zy_f64 #

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

matrix3_from_euler_angles_zyx_f16 #

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

matrix3_from_euler_angles_zyx_f32 #

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

matrix3_from_euler_angles_zyx_f64 #

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

matrix3_from_euler_angles_zyz_f16 #

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

matrix3_from_euler_angles_zyz_f32 #

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

matrix3_from_euler_angles_zyz_f64 #

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

matrix3_from_matrix2_f16 #

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

matrix3_from_matrix2_f32 #

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

matrix3_from_matrix2_f64 #

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

matrix3_from_matrix4_f16 #

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

matrix3_from_matrix4_f32 #

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

matrix3_from_matrix4_f64 #

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

matrix3_from_quaternion_f16 #

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

matrix3_from_quaternion_f32 #

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

matrix3_from_quaternion_f64 #

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

matrix3_from_scalar_f16 #

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

matrix3_from_scalar_f32 #

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

matrix3_from_scalar_f64 #

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

matrix3_from_yaw_pitch_roll_f16 #

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

matrix3_from_yaw_pitch_roll_f32 #

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

matrix3_from_yaw_pitch_roll_f64 #

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

matrix3_inverse_f16 #

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

matrix3_inverse_f32 #

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

matrix3_inverse_f64 #

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

matrix3_inverse_transpose_f16 #

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

matrix3_inverse_transpose_f32 #

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

matrix3_inverse_transpose_f64 #

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

matrix3_look_at_f16 #

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

matrix3_look_at_f32 #

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

matrix3_look_at_f64 #

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

matrix3_orthonormalize_f16 #

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

matrix3_orthonormalize_f32 #

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

matrix3_orthonormalize_f64 #

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

matrix3_rotate_f16 #

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

matrix3_rotate_f32 #

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

matrix3_rotate_f64 #

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

matrix3_scale_f16 #

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

matrix3_scale_f32 #

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

matrix3_scale_f64 #

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

matrix3x3_adjugate #

Source 
@(require_results)
matrix3x3_adjugate :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: $$deferred_return) {…}

matrix3x3_cofactor #

Source 
@(require_results)
matrix3x3_cofactor :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: $$deferred_return) {…}

matrix3x3_determinant #

Source 
@(require_results)
matrix3x3_determinant :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (det: $$deferred_return) {…}

matrix3x3_inverse #

Source 
@(require_results)
matrix3x3_inverse :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: $$deferred_return) {…}

matrix3x3_inverse_transpose #

Source 
@(require_results)
matrix3x3_inverse_transpose :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: $$deferred_return) {…}

matrix4_adjoint_f16 #

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

matrix4_adjoint_f32 #

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

matrix4_adjoint_f64 #

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

matrix4_cofactor_f16 #

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

matrix4_cofactor_f32 #

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

matrix4_cofactor_f64 #

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

matrix4_determinant_f16 #

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

matrix4_determinant_f32 #

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

matrix4_determinant_f64 #

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

matrix4_from_derived_euler_angle_x_f16 #

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

matrix4_from_derived_euler_angle_x_f32 #

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

matrix4_from_derived_euler_angle_x_f64 #

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

matrix4_from_derived_euler_angle_y_f16 #

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

matrix4_from_derived_euler_angle_y_f32 #

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

matrix4_from_derived_euler_angle_y_f64 #

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

matrix4_from_derived_euler_angle_z_f16 #

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

matrix4_from_derived_euler_angle_z_f32 #

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

matrix4_from_derived_euler_angle_z_f64 #

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

matrix4_from_euler_angle_x_f16 #

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

matrix4_from_euler_angle_x_f32 #

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

matrix4_from_euler_angle_x_f64 #

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

matrix4_from_euler_angle_y_f16 #

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

matrix4_from_euler_angle_y_f32 #

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

matrix4_from_euler_angle_y_f64 #

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

matrix4_from_euler_angle_z_f16 #

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

matrix4_from_euler_angle_z_f32 #

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

matrix4_from_euler_angle_z_f64 #

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

matrix4_from_euler_angles_xy_f16 #

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

matrix4_from_euler_angles_xy_f32 #

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

matrix4_from_euler_angles_xy_f64 #

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

matrix4_from_euler_angles_xyx_f16 #

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

matrix4_from_euler_angles_xyx_f32 #

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

matrix4_from_euler_angles_xyx_f64 #

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

matrix4_from_euler_angles_xyz_f16 #

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

matrix4_from_euler_angles_xyz_f32 #

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

matrix4_from_euler_angles_xyz_f64 #

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

matrix4_from_euler_angles_xz_f16 #

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

matrix4_from_euler_angles_xz_f32 #

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

matrix4_from_euler_angles_xz_f64 #

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

matrix4_from_euler_angles_xzx_f16 #

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

matrix4_from_euler_angles_xzx_f32 #

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

matrix4_from_euler_angles_xzx_f64 #

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

matrix4_from_euler_angles_xzy_f16 #

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

matrix4_from_euler_angles_xzy_f32 #

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

matrix4_from_euler_angles_xzy_f64 #

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

matrix4_from_euler_angles_yx_f16 #

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

matrix4_from_euler_angles_yx_f32 #

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

matrix4_from_euler_angles_yx_f64 #

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

matrix4_from_euler_angles_yxy_f16 #

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

matrix4_from_euler_angles_yxy_f32 #

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

matrix4_from_euler_angles_yxy_f64 #

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

matrix4_from_euler_angles_yxz_f16 #

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

matrix4_from_euler_angles_yxz_f32 #

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

matrix4_from_euler_angles_yxz_f64 #

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

matrix4_from_euler_angles_yz_f16 #

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

matrix4_from_euler_angles_yz_f32 #

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

matrix4_from_euler_angles_yz_f64 #

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

matrix4_from_euler_angles_yzx_f16 #

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

matrix4_from_euler_angles_yzx_f32 #

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

matrix4_from_euler_angles_yzx_f64 #

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

matrix4_from_euler_angles_yzy_f16 #

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

matrix4_from_euler_angles_yzy_f32 #

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

matrix4_from_euler_angles_yzy_f64 #

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

matrix4_from_euler_angles_zx_f16 #

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

matrix4_from_euler_angles_zx_f32 #

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

matrix4_from_euler_angles_zx_f64 #

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

matrix4_from_euler_angles_zxy_f16 #

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

matrix4_from_euler_angles_zxy_f32 #

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

matrix4_from_euler_angles_zxy_f64 #

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

matrix4_from_euler_angles_zxz_f16 #

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

matrix4_from_euler_angles_zxz_f32 #

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

matrix4_from_euler_angles_zxz_f64 #

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

matrix4_from_euler_angles_zy_f16 #

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

matrix4_from_euler_angles_zy_f32 #

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

matrix4_from_euler_angles_zy_f64 #

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

matrix4_from_euler_angles_zyx_f16 #

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

matrix4_from_euler_angles_zyx_f32 #

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

matrix4_from_euler_angles_zyx_f64 #

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

matrix4_from_euler_angles_zyz_f16 #

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

matrix4_from_euler_angles_zyz_f32 #

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

matrix4_from_euler_angles_zyz_f64 #

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

matrix4_from_matrix2_f16 #

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

matrix4_from_matrix2_f32 #

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

matrix4_from_matrix2_f64 #

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

matrix4_from_matrix3_f16 #

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

matrix4_from_matrix3_f32 #

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

matrix4_from_matrix3_f64 #

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

matrix4_from_quaternion_f16 #

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

matrix4_from_quaternion_f32 #

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

matrix4_from_quaternion_f64 #

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

matrix4_from_scalar_f16 #

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

matrix4_from_scalar_f32 #

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

matrix4_from_scalar_f64 #

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

matrix4_from_yaw_pitch_roll_f16 #

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

matrix4_from_yaw_pitch_roll_f32 #

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

matrix4_from_yaw_pitch_roll_f64 #

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

matrix4_infinite_perspective_f16 #

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

matrix4_infinite_perspective_f32 #

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

matrix4_infinite_perspective_f64 #

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

matrix4_inverse_f16 #

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

matrix4_inverse_f32 #

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

matrix4_inverse_f64 #

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

matrix4_inverse_transpose_f16 #

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

matrix4_inverse_transpose_f32 #

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

matrix4_inverse_transpose_f64 #

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

matrix4_look_at_f16 #

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

matrix4_look_at_f32 #

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

matrix4_look_at_f64 #

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

matrix4_look_at_from_fru_f16 #

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

matrix4_look_at_from_fru_f32 #

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

matrix4_look_at_from_fru_f64 #

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

matrix4_minor_f16 #

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

matrix4_minor_f32 #

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

matrix4_minor_f64 #

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

matrix4_orientation_f16 #

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

matrix4_orientation_f32 #

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

matrix4_orientation_f64 #

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

matrix4_perspective_f16 #

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

matrix4_perspective_f32 #

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

matrix4_perspective_f64 #

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

matrix4_rotate_f16 #

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

matrix4_rotate_f32 #

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

matrix4_rotate_f64 #

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

matrix4_scale_f16 #

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

matrix4_scale_f32 #

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

matrix4_scale_f64 #

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

matrix4_translate_f16 #

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

matrix4_translate_f32 #

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

matrix4_translate_f64 #

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

matrix4x4_adjugate #

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

matrix4x4_cofactor #

Source 
@(require_results)
matrix4x4_cofactor :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: $$deferred_return) {…}

matrix4x4_determinant #

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

matrix4x4_inverse #

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

matrix4x4_inverse_transpose #

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

max_double #

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

max_single #

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

max_triple #

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

min_double #

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

min_single #

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

min_triple #

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

mix #

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

mod #

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

not #

Source 
@(require_results)
not :: proc "contextless" (x: $A/[$N]bool) -> (out: $$deferred_return) {…}

not_equal_array #

Source 
@(require_results)
not_equal_array :: proc "contextless" (x, y: $A/[$N]$T) -> (out: $$deferred_return) {…}

not_equal_single #

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

pitch_yaw_roll_from_quaternion_f16 #

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

pitch_yaw_roll_from_quaternion_f32 #

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

pitch_yaw_roll_from_quaternion_f64 #

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

polar_from_euclidean_f16 #

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

polar_from_euclidean_f32 #

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

polar_from_euclidean_f64 #

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

pow #

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

projection #

Source 
@(require_results)
projection :: proc "contextless" (x, normal: $T/[$N]$E) -> $$deferred_return {…}

quaternion_angle_axis_f16 #

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

quaternion_angle_axis_f32 #

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

quaternion_angle_axis_f64 #

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

quaternion_between_two_vector3_f16 #

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

quaternion_between_two_vector3_f32 #

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

quaternion_between_two_vector3_f64 #

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

quaternion_cross #

Source 
@(require_results)
quaternion_cross :: proc "contextless" (q1, q2: $Q) -> (q3: $$deferred_return) {…}

quaternion_from_euler_angle_x_f16 #

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

quaternion_from_euler_angle_x_f32 #

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

quaternion_from_euler_angle_x_f64 #

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

quaternion_from_euler_angle_y_f16 #

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

quaternion_from_euler_angle_y_f32 #

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

quaternion_from_euler_angle_y_f64 #

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

quaternion_from_euler_angle_z_f16 #

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

quaternion_from_euler_angle_z_f32 #

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

quaternion_from_euler_angle_z_f64 #

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

quaternion_from_forward_and_up_f16 #

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

quaternion_from_forward_and_up_f32 #

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

quaternion_from_forward_and_up_f64 #

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

quaternion_from_matrix3_f16 #

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

quaternion_from_matrix3_f32 #

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

quaternion_from_matrix3_f64 #

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

quaternion_from_matrix4_f16 #

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

quaternion_from_matrix4_f32 #

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

quaternion_from_matrix4_f64 #

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

quaternion_from_pitch_yaw_roll_f16 #

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

quaternion_from_pitch_yaw_roll_f32 #

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

quaternion_from_pitch_yaw_roll_f64 #

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

quaternion_inverse #

Source 
@(require_results)
quaternion_inverse :: proc "contextless" (q: $Q) -> $$deferred_return {…}

quaternion_length #

Source 
@(require_results)
quaternion_length :: proc "contextless" (q: $Q) -> $$deferred_return {…}

quaternion_length2 #

Source 
@(require_results)
quaternion_length2 :: proc "contextless" (q: $Q) -> $$deferred_return {…}

quaternion_mul_quaternion #

Source 
@(require_results)
quaternion_mul_quaternion :: proc "contextless" (q1, q2: $Q) -> $$deferred_return {…}

quaternion_normalize #

Source 
@(require_results)
quaternion_normalize :: proc "contextless" (q: $Q) -> $$deferred_return {…}

quaternion_normalize0 #

Source 
@(require_results)
quaternion_normalize0 :: proc "contextless" (q: $Q) -> $$deferred_return {…}

quaternion128_mul_vector3 #

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

quaternion256_mul_vector3 #

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

quaternion64_mul_vector3 #

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

reflect #

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

refract #

Source 
@(require_results)
refract :: proc "contextless" (I, Normal: $V/[$N]$E, eta: $E) -> (out: $$deferred_return) {…}

round #

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

saturate #

Source 
@(require_results)
saturate :: proc "contextless" (x: $T) -> $$deferred_return {…}

scalar_cross #

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

scalar_dot #

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

scalar_triple_product #

Source 
@(require_results)
scalar_triple_product :: proc "contextless" (a, b, c: $T/[$N]$E) -> $$deferred_return {…}

sign #

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

sin #

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

smootherstep #

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

smoothstep #

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

sqrt #

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

step #

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

tan #

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

to_complex128 #

Source 
@(require_results)
to_complex128 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_complex32 #

Source 
@(require_results)
to_complex32 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_complex64 #

Source 
@(require_results)
to_complex64 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_degrees #

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

to_f16 #

Source 
@(require_results)
to_f16 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_f32 #

Source 
@(require_results)
to_f32 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_f64 #

Source 
@(require_results)
to_f64 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_i16 #

Source 
@(require_results)
to_i16 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_i32 #

Source 
@(require_results)
to_i32 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_i64 #

Source 
@(require_results)
to_i64 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_i8 #

Source 
@(require_results)
to_i8 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_int #

Source 
@(require_results)
to_int :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_quaternion128 #

Source 
@(require_results)
to_quaternion128 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_quaternion256 #

Source 
@(require_results)
to_quaternion256 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_quaternion64 #

Source 
@(require_results)
to_quaternion64 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_radians #

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

to_u16 #

Source 
@(require_results)
to_u16 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_u32 #

Source 
@(require_results)
to_u32 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_u64 #

Source 
@(require_results)
to_u64 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_u8 #

Source 
@(require_results)
to_u8 :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

to_uint #

Source 
@(require_results)
to_uint :: proc(v: $A/[$N]$T) -> $$deferred_return {…}

trace #

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

trunc #

Source 
@(require_results)
trunc :: proc "contextless" (x: $T) -> (out: $$deferred_return) {…}

unlerp #

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

vector_angle_between #

Source 
vector_angle_between :: proc "contextless" (a, b: $V/[$N]$E) -> $$deferred_return {…}

vector_cross2 #

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

vector_cross3 #

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

vector_dot #

Source 
@(require_results)
vector_dot :: proc "contextless" (a, b: $T/[$N]$E) -> (c: $$deferred_return) {…}

vector_length #

Source 
@(require_results)
vector_length :: proc "contextless" (v: $T/[$N]$E) -> $$deferred_return {…}

vector_length2 #

Source 
@(require_results)
vector_length2 :: proc "contextless" (v: $T/[$N]$E) -> $$deferred_return {…}

vector_normalize #

Source 
@(require_results)
vector_normalize :: proc "contextless" (v: $T/[$N]$E) -> $$deferred_return {…}

vector_normalize0 #

Source 
@(require_results)
vector_normalize0 :: proc "contextless" (v: $T/[$N]$E) -> $$deferred_return {…}

vector_slerp #

Source 
@(require_results)
vector_slerp :: proc "contextless" (x, y: $T/[$N]$E, a: $E) -> $$deferred_return {…}

vector_to_ptr #

Source 
@(require_results)
vector_to_ptr :: proc "contextless" (v: ^$V/[$N]$E) -> $$deferred_return {…}

vector_triple_product #

Source 
@(require_results)
vector_triple_product :: proc "contextless" (a, b, c: $T/[$N]$E) -> $$deferred_return {…}

vector2_orthogonal #

Source 
@(require_results)
vector2_orthogonal :: proc "contextless" (v: $V/[2]$E) -> $$deferred_return {…}

vector3_linear_to_srgb_f16 #

Source 
@(require_results)
vector3_linear_to_srgb_f16 :: proc "contextless" (col: [3]f16) -> [3]f16 {…}

vector3_linear_to_srgb_f32 #

Source 
@(require_results)
vector3_linear_to_srgb_f32 :: proc "contextless" (col: [3]f32) -> [3]f32 {…}

vector3_linear_to_srgb_f64 #

Source 
@(require_results)
vector3_linear_to_srgb_f64 :: proc "contextless" (col: [3]f64) -> [3]f64 {…}

vector3_orthogonal #

Source 
@(require_results)
vector3_orthogonal :: proc "contextless" (v: $V/[3]$E) -> $$deferred_return {…}

vector3_orthonormalize_f16 #

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

vector3_orthonormalize_f32 #

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

vector3_orthonormalize_f64 #

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

vector3_srgb_to_linear_f16 #

Source 
@(require_results)
vector3_srgb_to_linear_f16 :: proc "contextless" (col: [3]f16) -> [3]f16 {…}

vector3_srgb_to_linear_f32 #

Source 
@(require_results)
vector3_srgb_to_linear_f32 :: proc "contextless" (col: [3]f32) -> [3]f32 {…}

vector3_srgb_to_linear_f64 #

Source 
@(require_results)
vector3_srgb_to_linear_f64 :: proc "contextless" (col: [3]f64) -> [3]f64 {…}

vector4_hsl_to_rgb_f16 #

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

vector4_hsl_to_rgb_f32 #

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

vector4_hsl_to_rgb_f64 #

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

vector4_linear_to_srgb_f16 #

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

vector4_linear_to_srgb_f32 #

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

vector4_linear_to_srgb_f64 #

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

vector4_rgb_to_hsl_f16 #

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

vector4_rgb_to_hsl_f32 #

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

vector4_rgb_to_hsl_f64 #

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

vector4_srgb_to_linear_f16 #

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

vector4_srgb_to_linear_f32 #

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

vector4_srgb_to_linear_f64 #

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

Procedure Groups

215

swizzle #

Source 
swizzle :: proc{
	scalar_f32_swizzle1,
	scalar_f32_swizzle2,
	scalar_f32_swizzle3,
	scalar_f32_swizzle4,
	scalar_f64_swizzle1,
	scalar_f64_swizzle2,
	scalar_f64_swizzle3,
	scalar_f64_swizzle4,
	vector2f32_swizzle1,
	vector2f32_swizzle2,
	vector2f32_swizzle3,
	vector2f32_swizzle4,
	vector2f64_swizzle1,
	vector2f64_swizzle2,
	vector2f64_swizzle3,
	vector2f64_swizzle4,
	vector3f32_swizzle1,
	vector3f32_swizzle2,
	vector3f32_swizzle3,
	vector3f32_swizzle4,
	vector3f64_swizzle1,
	vector3f64_swizzle2,
	vector3f64_swizzle3,
	vector3f64_swizzle4,
	vector4f32_swizzle1,
	vector4f32_swizzle2,
	vector4f32_swizzle3,
	vector4f32_swizzle4,
	vector4f64_swizzle1,
	vector4f64_swizzle2,
	vector4f64_swizzle3,
	vector4f64_swizzle4,
}