package core:math/linalg/hlsl
Overview
HLSL-like mathematics library plus numerous other utility procedures.
Index
abs_… (20)
acos_… (12)
acosh_… (12)
adjugate_… (4)
all_… (4)
any_… (4)
- asdouble_uint
- asdouble_uint2
asfloat_… (44)
asin_… (12)
asinh_… (12)
asint_… (44)
asuint_… (14)
atan2_… (12)
atan_… (12)
atanh_… (12)
ceil_… (12)
clamp_… (20)
cofactor_… (4)
cos_… (12)
cosh_… (12)
cross_… (4)
degrees_… (12)
determinant_… (4)
distance_… (12)
dot_… (20)
equal_… (20)
exp2_… (12)
exp_… (12)
faceforward_… (12)
floor_… (12)
fmod_… (12)
frac_… (12)
greaterThanEqual_… (20)
greaterThan_… (20)
- hermitian_adjoint
inverse_… (20)
isfinite_… (12)
isinf_… (12)
isnan_… (12)
length_… (12)
lerp_… (12)
lessThanEqual_… (20)
lessThan_… (20)
log10_… (12)
log2_… (12)
log_… (12)
- matrix_minor
max_… (20)
min_… (20)
normalize_… (12)
notEqual_… (20)
not_… (4)
pow_… (12)
radians_… (12)
rcp_… (12)
reflect_… (12)
refract_… (12)
round_… (12)
rsqrt_… (12)
saturate_… (20)
scalarTripleProduct_… (4)
sign_… (20)
sin_… (12)
sinh_… (12)
smoothstep_… (12)
sqrt_… (12)
step_… (12)
tan_… (12)
tanh_… (12)
- trace
- transpose
vectorTripleProduct_… (4)
Related Procedures With Parameters
Related Procedures With Returns
Related Procedures With Parameters
Related Procedures With Returns
Related Procedures With Parameters
Related Procedures With Returns
Related Procedures With Parameters 113
Related Procedures With Returns
double1x1 :: matrix[1, 1]f64
Related Procedures With Parameters
double1x2 :: matrix[1, 2]f64
double1x3 :: matrix[1, 3]f64
double1x4 :: matrix[1, 4]f64
Related Procedures With Parameters 110
Related Procedures With Returns
double2x1 :: matrix[2, 1]f64
double2x2 :: matrix[2, 2]f64
Related Procedures With Parameters
double2x3 :: matrix[2, 3]f64
double2x4 :: matrix[2, 4]f64
Related Procedures With Parameters 114
double3x1 :: matrix[3, 1]f64
double3x2 :: matrix[3, 2]f64
double3x3 :: matrix[3, 3]f64
Related Procedures With Parameters
double3x4 :: matrix[3, 4]f64
Related Procedures With Parameters 108
double4x1 :: matrix[4, 1]f64
double4x2 :: matrix[4, 2]f64
double4x3 :: matrix[4, 3]f64
double4x4 :: matrix[4, 4]f64
Related Procedures With Parameters
Related Procedures With Parameters 117
Related Procedures With Returns
float1x1 :: matrix[1, 1]f32
Odin matrices are stored internally as Column-Major, which matches the internal layout of HLSL by default
Related Procedures With Parameters
float1x2 :: matrix[1, 2]f32
Related Procedures With Parameters
float1x3 :: matrix[1, 3]f32
Related Procedures With Parameters
float1x4 :: matrix[1, 4]f32
Related Procedures With Parameters
Related Procedures With Parameters 114
Related Procedures With Returns
float2x1 :: matrix[2, 1]f32
Related Procedures With Parameters
float2x2 :: matrix[2, 2]f32
Related Procedures With Parameters
float2x3 :: matrix[2, 3]f32
Related Procedures With Parameters
float2x4 :: matrix[2, 4]f32
Related Procedures With Parameters
Related Procedures With Parameters 120
Related Procedures With Returns
float3x1 :: matrix[3, 1]f32
Related Procedures With Parameters
float3x2 :: matrix[3, 2]f32
Related Procedures With Parameters
float3x3 :: matrix[3, 3]f32
Related Procedures With Parameters
float3x4 :: matrix[3, 4]f32
Related Procedures With Parameters
Related Procedures With Parameters 114
Related Procedures With Returns
float4x1 :: matrix[4, 1]f32
Related Procedures With Parameters
float4x2 :: matrix[4, 2]f32
Related Procedures With Parameters
float4x3 :: matrix[4, 3]f32
Related Procedures With Parameters
float4x4 :: matrix[4, 4]f32
Related Procedures With Parameters
Aliases (not distict) of types
Related Procedures With Parameters 111
Related Procedures With Returns
half1x1 :: matrix[1, 1]f16
Related Procedures With Parameters
half1x2 :: matrix[1, 2]f16
half1x3 :: matrix[1, 3]f16
half1x4 :: matrix[1, 4]f16
Related Procedures With Parameters 108
half2x1 :: matrix[2, 1]f16
half2x2 :: matrix[2, 2]f16
Related Procedures With Parameters
half2x3 :: matrix[2, 3]f16
half2x4 :: matrix[2, 4]f16
Related Procedures With Parameters 114
half3x1 :: matrix[3, 1]f16
half3x2 :: matrix[3, 2]f16
half3x3 :: matrix[3, 3]f16
Related Procedures With Parameters
half3x4 :: matrix[3, 4]f16
Related Procedures With Parameters 108
half4x1 :: matrix[4, 1]f16
half4x2 :: matrix[4, 2]f16
half4x3 :: matrix[4, 3]f16
half4x4 :: matrix[4, 4]f16
Related Procedures With Parameters
Related Procedures With Parameters
Related Procedures With Returns
int1x1 :: matrix[1, 1]i32
Related Procedures With Parameters
int1x2 :: matrix[1, 2]i32
Related Procedures With Parameters
int1x3 :: matrix[1, 3]i32
Related Procedures With Parameters
int1x4 :: matrix[1, 4]i32
Related Procedures With Parameters
Related Procedures With Parameters
Related Procedures With Returns
int2x1 :: matrix[2, 1]i32
Related Procedures With Parameters
int2x2 :: matrix[2, 2]i32
Related Procedures With Parameters
int2x3 :: matrix[2, 3]i32
Related Procedures With Parameters
int2x4 :: matrix[2, 4]i32
Related Procedures With Parameters
Related Procedures With Parameters
Related Procedures With Returns
int3x1 :: matrix[3, 1]i32
Related Procedures With Parameters
int3x2 :: matrix[3, 2]i32
Related Procedures With Parameters
int3x3 :: matrix[3, 3]i32
Related Procedures With Parameters
int3x4 :: matrix[3, 4]i32
Related Procedures With Parameters
Related Procedures With Parameters
Related Procedures With Returns
int4x1 :: matrix[4, 1]i32
Related Procedures With Parameters
int4x2 :: matrix[4, 2]i32
Related Procedures With Parameters
int4x3 :: matrix[4, 3]i32
Related Procedures With Parameters
int4x4 :: matrix[4, 4]i32
Related Procedures With Parameters
Related Procedures With Parameters
Related Procedures With Returns
Related Procedures With Parameters
Related Procedures With Returns
Related Procedures With Parameters
Related Procedures With Returns
Related Procedures With Parameters
Related Procedures With Returns
E :: 2.71828182845904523536
LN10 :: 2.30258509299404568401799145468436421
LN2 :: 0.693147180559945309417232121458176568
PI :: 3.14159265358979323846264338327950288
SQRT_FIVE :: 2.23606797749978969640917366873127623
SQRT_THREE :: 1.73205080756887729352744634150587236
SQRT_TWO :: 1.41421356237309504880168872420969808
TAU :: 6.28318530717958647692528676655900576
This section is empty.
@(require_results)
abs_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
abs_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
abs_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
abs_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
abs_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
abs_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
abs_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
abs_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
abs_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
abs_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
abs_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
abs_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
abs_int :: proc "c" (x: i32) -> i32 {…}
@(require_results)
abs_int2 :: proc "c" (x: [2]i32) -> [2]i32 {…}
@(require_results)
abs_int3 :: proc "c" (x: [3]i32) -> [3]i32 {…}
@(require_results)
abs_int4 :: proc "c" (x: [4]i32) -> [4]i32 {…}
@(require_results)
abs_uint :: proc "c" (x: u32) -> u32 {…}
@(require_results)
abs_uint2 :: proc "c" (x: [2]u32) -> [2]u32 {…}
@(require_results)
abs_uint3 :: proc "c" (x: [3]u32) -> [3]u32 {…}
@(require_results)
abs_uint4 :: proc "c" (x: [4]u32) -> [4]u32 {…}
@(require_results)
acos_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
acos_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
acos_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
acos_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
acos_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
acos_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
acos_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
acos_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
acos_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
acos_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
acos_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
acos_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
acosh_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
acosh_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
acosh_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
acosh_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
acosh_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
acosh_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
acosh_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
acosh_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
acosh_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
acosh_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
acosh_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
acosh_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
adjugate_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) {…}
@(require_results)
adjugate_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) {…}
@(require_results)
adjugate_matrix3x3 :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: M) {…}
@(require_results)
adjugate_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) {…}
@(require_results)
all_bool :: proc "c" (v: bool) -> bool {…}
@(require_results)
all_bool2 :: proc "c" (v: [2]bool) -> bool {…}
@(require_results)
all_bool3 :: proc "c" (v: [3]bool) -> bool {…}
@(require_results)
all_bool4 :: proc "c" (v: [4]bool) -> bool {…}
@(require_results)
any_bool :: proc "c" (v: bool) -> bool {…}
@(require_results)
any_bool2 :: proc "c" (v: [2]bool) -> bool {…}
@(require_results)
any_bool3 :: proc "c" (v: [3]bool) -> bool {…}
@(require_results)
any_bool4 :: proc "c" (v: [4]bool) -> bool {…}
@(require_results)
asdouble_uint :: proc "c" (lowbits, highbits: u32) -> f64 {…}
@(require_results)
asdouble_uint2 :: proc "c" (lowbits, highbits: [2]u32) -> [2]f64 {…}
@(require_results)
asfloat_float :: proc "c" (v: f32) -> f32 {…}
@(require_results)
asfloat_float1x1 :: proc "c" (v: matrix[1, 1]f32) -> matrix[1, 1]f32 {…}
@(require_results)
asfloat_float1x2 :: proc "c" (v: matrix[1, 2]f32) -> matrix[1, 2]f32 {…}
@(require_results)
asfloat_float1x3 :: proc "c" (v: matrix[1, 3]f32) -> matrix[1, 3]f32 {…}
@(require_results)
asfloat_float1x4 :: proc "c" (v: matrix[1, 4]f32) -> matrix[1, 4]f32 {…}
@(require_results)
asfloat_float2 :: proc "c" (v: [2]f32) -> [2]f32 {…}
@(require_results)
asfloat_float2x1 :: proc "c" (v: matrix[2, 1]f32) -> matrix[2, 1]f32 {…}
@(require_results)
asfloat_float2x2 :: proc "c" (v: matrix[2, 2]f32) -> matrix[2, 2]f32 {…}
@(require_results)
asfloat_float2x3 :: proc "c" (v: matrix[2, 3]f32) -> matrix[2, 3]f32 {…}
@(require_results)
asfloat_float2x4 :: proc "c" (v: matrix[2, 4]f32) -> matrix[2, 4]f32 {…}
@(require_results)
asfloat_float3 :: proc "c" (v: [3]f32) -> [3]f32 {…}
@(require_results)
asfloat_float3x1 :: proc "c" (v: matrix[3, 1]f32) -> matrix[3, 1]f32 {…}
@(require_results)
asfloat_float3x2 :: proc "c" (v: matrix[3, 2]f32) -> matrix[3, 2]f32 {…}
@(require_results)
asfloat_float3x3 :: proc "c" (v: matrix[3, 3]f32) -> matrix[3, 3]f32 {…}
@(require_results)
asfloat_float3x4 :: proc "c" (v: matrix[3, 4]f32) -> matrix[3, 4]f32 {…}
@(require_results)
asfloat_float4 :: proc "c" (v: [4]f32) -> [4]f32 {…}
@(require_results)
asfloat_float4x1 :: proc "c" (v: matrix[4, 1]f32) -> matrix[4, 1]f32 {…}
@(require_results)
asfloat_float4x2 :: proc "c" (v: matrix[4, 2]f32) -> matrix[4, 2]f32 {…}
@(require_results)
asfloat_float4x3 :: proc "c" (v: matrix[4, 3]f32) -> matrix[4, 3]f32 {…}
@(require_results)
asfloat_float4x4 :: proc "c" (v: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}
@(require_results)
asfloat_int :: proc "c" (v: i32) -> f32 {…}
@(require_results)
asfloat_int1x1 :: proc "c" (v: matrix[1, 1]i32) -> matrix[1, 1]f32 {…}
@(require_results)
asfloat_int1x2 :: proc "c" (v: matrix[1, 2]i32) -> matrix[1, 2]f32 {…}
@(require_results)
asfloat_int1x3 :: proc "c" (v: matrix[1, 3]i32) -> matrix[1, 3]f32 {…}
@(require_results)
asfloat_int1x4 :: proc "c" (v: matrix[1, 4]i32) -> matrix[1, 4]f32 {…}
@(require_results)
asfloat_int2 :: proc "c" (v: [2]i32) -> [2]f32 {…}
@(require_results)
asfloat_int2x1 :: proc "c" (v: matrix[2, 1]i32) -> matrix[2, 1]f32 {…}
@(require_results)
asfloat_int2x2 :: proc "c" (v: matrix[2, 2]i32) -> matrix[2, 2]f32 {…}
@(require_results)
asfloat_int2x3 :: proc "c" (v: matrix[2, 3]i32) -> matrix[2, 3]f32 {…}
@(require_results)
asfloat_int2x4 :: proc "c" (v: matrix[2, 4]i32) -> matrix[2, 4]f32 {…}
@(require_results)
asfloat_int3 :: proc "c" (v: [3]i32) -> [3]f32 {…}
@(require_results)
asfloat_int3x1 :: proc "c" (v: matrix[3, 1]i32) -> matrix[3, 1]f32 {…}
@(require_results)
asfloat_int3x2 :: proc "c" (v: matrix[3, 2]i32) -> matrix[3, 2]f32 {…}
@(require_results)
asfloat_int3x3 :: proc "c" (v: matrix[3, 3]i32) -> matrix[3, 3]f32 {…}
@(require_results)
asfloat_int3x4 :: proc "c" (v: matrix[3, 4]i32) -> matrix[3, 4]f32 {…}
@(require_results)
asfloat_int4 :: proc "c" (v: [4]i32) -> [4]f32 {…}
@(require_results)
asfloat_int4x1 :: proc "c" (v: matrix[4, 1]i32) -> matrix[4, 1]f32 {…}
@(require_results)
asfloat_int4x2 :: proc "c" (v: matrix[4, 2]i32) -> matrix[4, 2]f32 {…}
@(require_results)
asfloat_int4x3 :: proc "c" (v: matrix[4, 3]i32) -> matrix[4, 3]f32 {…}
@(require_results)
asfloat_int4x4 :: proc "c" (v: matrix[4, 4]i32) -> matrix[4, 4]f32 {…}
@(require_results)
asfloat_uint :: proc "c" (v: u32) -> f32 {…}
@(require_results)
asfloat_uint2 :: proc "c" (v: [2]u32) -> [2]f32 {…}
@(require_results)
asfloat_uint3 :: proc "c" (v: [3]u32) -> [3]f32 {…}
@(require_results)
asfloat_uint4 :: proc "c" (v: [4]u32) -> [4]f32 {…}
@(require_results)
asin_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
asin_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
asin_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
asin_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
asin_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
asin_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
asin_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
asin_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
asin_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
asin_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
asin_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
asin_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
asinh_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
asinh_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
asinh_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
asinh_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
asinh_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
asinh_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
asinh_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
asinh_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
asinh_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
asinh_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
asinh_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
asinh_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
asint_float :: proc "c" (v: f32) -> i32 {…}
@(require_results)
asint_float1x1 :: proc "c" (v: matrix[1, 1]f32) -> matrix[1, 1]i32 {…}
@(require_results)
asint_float1x2 :: proc "c" (v: matrix[1, 2]f32) -> matrix[1, 2]i32 {…}
@(require_results)
asint_float1x3 :: proc "c" (v: matrix[1, 3]f32) -> matrix[1, 3]i32 {…}
@(require_results)
asint_float1x4 :: proc "c" (v: matrix[1, 4]f32) -> matrix[1, 4]i32 {…}
@(require_results)
asint_float2 :: proc "c" (v: [2]f32) -> [2]i32 {…}
@(require_results)
asint_float2x1 :: proc "c" (v: matrix[2, 1]f32) -> matrix[2, 1]i32 {…}
@(require_results)
asint_float2x2 :: proc "c" (v: matrix[2, 2]f32) -> matrix[2, 2]i32 {…}
@(require_results)
asint_float2x3 :: proc "c" (v: matrix[2, 3]f32) -> matrix[2, 3]i32 {…}
@(require_results)
asint_float2x4 :: proc "c" (v: matrix[2, 4]f32) -> matrix[2, 4]i32 {…}
@(require_results)
asint_float3 :: proc "c" (v: [3]f32) -> [3]i32 {…}
@(require_results)
asint_float3x1 :: proc "c" (v: matrix[3, 1]f32) -> matrix[3, 1]i32 {…}
@(require_results)
asint_float3x2 :: proc "c" (v: matrix[3, 2]f32) -> matrix[3, 2]i32 {…}
@(require_results)
asint_float3x3 :: proc "c" (v: matrix[3, 3]f32) -> matrix[3, 3]i32 {…}
@(require_results)
asint_float3x4 :: proc "c" (v: matrix[3, 4]f32) -> matrix[3, 4]i32 {…}
@(require_results)
asint_float4 :: proc "c" (v: [4]f32) -> [4]i32 {…}
@(require_results)
asint_float4x1 :: proc "c" (v: matrix[4, 1]f32) -> matrix[4, 1]i32 {…}
@(require_results)
asint_float4x2 :: proc "c" (v: matrix[4, 2]f32) -> matrix[4, 2]i32 {…}
@(require_results)
asint_float4x3 :: proc "c" (v: matrix[4, 3]f32) -> matrix[4, 3]i32 {…}
@(require_results)
asint_float4x4 :: proc "c" (v: matrix[4, 4]f32) -> matrix[4, 4]i32 {…}
@(require_results)
asint_int :: proc "c" (v: i32) -> i32 {…}
@(require_results)
asint_int1x1 :: proc "c" (v: matrix[1, 1]i32) -> matrix[1, 1]i32 {…}
@(require_results)
asint_int1x2 :: proc "c" (v: matrix[1, 2]i32) -> matrix[1, 2]i32 {…}
@(require_results)
asint_int1x3 :: proc "c" (v: matrix[1, 3]i32) -> matrix[1, 3]i32 {…}
@(require_results)
asint_int1x4 :: proc "c" (v: matrix[1, 4]i32) -> matrix[1, 4]i32 {…}
@(require_results)
asint_int2 :: proc "c" (v: [2]i32) -> [2]i32 {…}
@(require_results)
asint_int2x1 :: proc "c" (v: matrix[2, 1]i32) -> matrix[2, 1]i32 {…}
@(require_results)
asint_int2x2 :: proc "c" (v: matrix[2, 2]i32) -> matrix[2, 2]i32 {…}
@(require_results)
asint_int2x3 :: proc "c" (v: matrix[2, 3]i32) -> matrix[2, 3]i32 {…}
@(require_results)
asint_int2x4 :: proc "c" (v: matrix[2, 4]i32) -> matrix[2, 4]i32 {…}
@(require_results)
asint_int3 :: proc "c" (v: [3]i32) -> [3]i32 {…}
@(require_results)
asint_int3x1 :: proc "c" (v: matrix[3, 1]i32) -> matrix[3, 1]i32 {…}
@(require_results)
asint_int3x2 :: proc "c" (v: matrix[3, 2]i32) -> matrix[3, 2]i32 {…}
@(require_results)
asint_int3x3 :: proc "c" (v: matrix[3, 3]i32) -> matrix[3, 3]i32 {…}
@(require_results)
asint_int3x4 :: proc "c" (v: matrix[3, 4]i32) -> matrix[3, 4]i32 {…}
@(require_results)
asint_int4 :: proc "c" (v: [4]i32) -> [4]i32 {…}
@(require_results)
asint_int4x1 :: proc "c" (v: matrix[4, 1]i32) -> matrix[4, 1]i32 {…}
@(require_results)
asint_int4x2 :: proc "c" (v: matrix[4, 2]i32) -> matrix[4, 2]i32 {…}
@(require_results)
asint_int4x3 :: proc "c" (v: matrix[4, 3]i32) -> matrix[4, 3]i32 {…}
@(require_results)
asint_int4x4 :: proc "c" (v: matrix[4, 4]i32) -> matrix[4, 4]i32 {…}
@(require_results)
asint_uint :: proc "c" (v: u32) -> i32 {…}
@(require_results)
asint_uint2 :: proc "c" (v: [2]u32) -> [2]i32 {…}
@(require_results)
asint_uint3 :: proc "c" (v: [3]u32) -> [3]i32 {…}
@(require_results)
asint_uint4 :: proc "c" (v: [4]u32) -> [4]i32 {…}
@(require_results)
asuint_double :: proc "c" (v: f64) -> (lowbits, highbits: u32) {…}
@(require_results)
asuint_double2 :: proc "c" (v: [2]f64) -> (lowbits, highbits: [2]u32) {…}
@(require_results)
asuint_float :: proc "c" (v: f32) -> u32 {…}
@(require_results)
asuint_float2 :: proc "c" (v: [2]f32) -> [2]u32 {…}
@(require_results)
asuint_float3 :: proc "c" (v: [3]f32) -> [3]u32 {…}
@(require_results)
asuint_float4 :: proc "c" (v: [4]f32) -> [4]u32 {…}
@(require_results)
asuint_int :: proc "c" (v: i32) -> u32 {…}
@(require_results)
asuint_int2 :: proc "c" (v: [2]i32) -> [2]u32 {…}
@(require_results)
asuint_int3 :: proc "c" (v: [3]i32) -> [3]u32 {…}
@(require_results)
asuint_int4 :: proc "c" (v: [4]i32) -> [4]u32 {…}
@(require_results)
asuint_uint :: proc "c" (v: u32) -> u32 {…}
@(require_results)
asuint_uint2 :: proc "c" (v: [2]u32) -> [2]u32 {…}
@(require_results)
asuint_uint3 :: proc "c" (v: [3]u32) -> [3]u32 {…}
@(require_results)
asuint_uint4 :: proc "c" (v: [4]u32) -> [4]u32 {…}
@(require_results)
atan2_double :: proc "c" (y, x: f64) -> f64 {…}
Related Procedure Groups
@(require_results)
atan2_double2 :: proc "c" (y, x: [2]f64) -> [2]f64 {…}
Related Procedure Groups
@(require_results)
atan2_double3 :: proc "c" (y, x: [3]f64) -> [3]f64 {…}
Related Procedure Groups
@(require_results)
atan2_double4 :: proc "c" (y, x: [4]f64) -> [4]f64 {…}
Related Procedure Groups
@(require_results)
atan2_float :: proc "c" (y, x: f32) -> f32 {…}
Related Procedure Groups
@(require_results)
atan2_float2 :: proc "c" (y, x: [2]f32) -> [2]f32 {…}
Related Procedure Groups
@(require_results)
atan2_float3 :: proc "c" (y, x: [3]f32) -> [3]f32 {…}
Related Procedure Groups
@(require_results)
atan2_float4 :: proc "c" (y, x: [4]f32) -> [4]f32 {…}
Related Procedure Groups
@(require_results)
atan2_half :: proc "c" (y, x: f16) -> f16 {…}
@(require_results)
atan2_half2 :: proc "c" (y, x: [2]f16) -> [2]f16 {…}
@(require_results)
atan2_half3 :: proc "c" (y, x: [3]f16) -> [3]f16 {…}
@(require_results)
atan2_half4 :: proc "c" (y, x: [4]f16) -> [4]f16 {…}
@(require_results)
atan_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
atan_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
atan_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
atan_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
atan_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
atan_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
atan_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
atan_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
atan_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
atan_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
atan_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
atan_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
atanh_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
atanh_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
atanh_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
atanh_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
atanh_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
atanh_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
atanh_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
atanh_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
atanh_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
atanh_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
atanh_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
atanh_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
ceil_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
ceil_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
ceil_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
ceil_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
ceil_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
ceil_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
ceil_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
ceil_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
ceil_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
ceil_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
ceil_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
ceil_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
clamp_double :: proc "c" (x, y, z: f64) -> f64 {…}
@(require_results)
clamp_double2 :: proc "c" (x, y, z: [2]f64) -> [2]f64 {…}
@(require_results)
clamp_double3 :: proc "c" (x, y, z: [3]f64) -> [3]f64 {…}
@(require_results)
clamp_double4 :: proc "c" (x, y, z: [4]f64) -> [4]f64 {…}
@(require_results)
clamp_float :: proc "c" (x, y, z: f32) -> f32 {…}
@(require_results)
clamp_float2 :: proc "c" (x, y, z: [2]f32) -> [2]f32 {…}
@(require_results)
clamp_float3 :: proc "c" (x, y, z: [3]f32) -> [3]f32 {…}
@(require_results)
clamp_float4 :: proc "c" (x, y, z: [4]f32) -> [4]f32 {…}
@(require_results)
clamp_half :: proc "c" (x, y, z: f16) -> f16 {…}
@(require_results)
clamp_half2 :: proc "c" (x, y, z: [2]f16) -> [2]f16 {…}
@(require_results)
clamp_half3 :: proc "c" (x, y, z: [3]f16) -> [3]f16 {…}
@(require_results)
clamp_half4 :: proc "c" (x, y, z: [4]f16) -> [4]f16 {…}
@(require_results)
clamp_int :: proc "c" (x, y, z: i32) -> i32 {…}
@(require_results)
clamp_int2 :: proc "c" (x, y, z: [2]i32) -> [2]i32 {…}
@(require_results)
clamp_int3 :: proc "c" (x, y, z: [3]i32) -> [3]i32 {…}
@(require_results)
clamp_int4 :: proc "c" (x, y, z: [4]i32) -> [4]i32 {…}
@(require_results)
clamp_uint :: proc "c" (x, y, z: u32) -> u32 {…}
@(require_results)
clamp_uint2 :: proc "c" (x, y, z: [2]u32) -> [2]u32 {…}
@(require_results)
clamp_uint3 :: proc "c" (x, y, z: [3]u32) -> [3]u32 {…}
@(require_results)
clamp_uint4 :: proc "c" (x, y, z: [4]u32) -> [4]u32 {…}
@(require_results)
cofactor_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) {…}
@(require_results)
cofactor_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) {…}
@(require_results)
cofactor_matrix3x3 :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: M) {…}
@(require_results)
cofactor_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) {…}
@(require_results)
cos_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
cos_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
cos_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
cos_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
cos_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
cos_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
cos_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
cos_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
cos_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
cos_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
cos_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
cos_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
cosh_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
cosh_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
cosh_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
cosh_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
cosh_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
cosh_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
cosh_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
cosh_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
cosh_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
cosh_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
cosh_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
cosh_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
cross_double3 :: proc "c" (a, b: [3]f64) -> (c: [3]f64) {…}
@(require_results)
cross_float3 :: proc "c" (a, b: [3]f32) -> (c: [3]f32) {…}
@(require_results)
cross_half3 :: proc "c" (a, b: [3]f16) -> (c: [3]f16) {…}
@(require_results)
cross_int3 :: proc "c" (a, b: [3]i32) -> (c: [3]i32) {…}
@(require_results)
degrees_double :: proc "c" (radians: f64) -> f64 {…}
@(require_results)
degrees_double2 :: proc "c" (radians: [2]f64) -> [2]f64 {…}
@(require_results)
degrees_double3 :: proc "c" (radians: [3]f64) -> [3]f64 {…}
@(require_results)
degrees_double4 :: proc "c" (radians: [4]f64) -> [4]f64 {…}
@(require_results)
degrees_float :: proc "c" (radians: f32) -> f32 {…}
@(require_results)
degrees_float2 :: proc "c" (radians: [2]f32) -> [2]f32 {…}
@(require_results)
degrees_float3 :: proc "c" (radians: [3]f32) -> [3]f32 {…}
@(require_results)
degrees_float4 :: proc "c" (radians: [4]f32) -> [4]f32 {…}
@(require_results)
degrees_half :: proc "c" (radians: f16) -> f16 {…}
@(require_results)
degrees_half2 :: proc "c" (radians: [2]f16) -> [2]f16 {…}
@(require_results)
degrees_half3 :: proc "c" (radians: [3]f16) -> [3]f16 {…}
@(require_results)
degrees_half4 :: proc "c" (radians: [4]f16) -> [4]f16 {…}
@(require_results)
determinant_matrix1x1 :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: T) {…}
@(require_results)
determinant_matrix2x2 :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: T) {…}
@(require_results)
determinant_matrix3x3 :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (det: T) {…}
@(require_results)
determinant_matrix4x4 :: proc "contextless" (m: $M/matrix[4, 4]$T) -> (det: T) {…}
@(require_results)
distance_double :: proc "c" (x, y: f64) -> f64 {…}
@(require_results)
distance_double2 :: proc "c" (x, y: [2]f64) -> f64 {…}
@(require_results)
distance_double3 :: proc "c" (x, y: [3]f64) -> f64 {…}
@(require_results)
distance_double4 :: proc "c" (x, y: [4]f64) -> f64 {…}
@(require_results)
distance_float :: proc "c" (x, y: f32) -> f32 {…}
@(require_results)
distance_float2 :: proc "c" (x, y: [2]f32) -> f32 {…}
@(require_results)
distance_float3 :: proc "c" (x, y: [3]f32) -> f32 {…}
@(require_results)
distance_float4 :: proc "c" (x, y: [4]f32) -> f32 {…}
@(require_results)
distance_half :: proc "c" (x, y: f16) -> f16 {…}
@(require_results)
distance_half2 :: proc "c" (x, y: [2]f16) -> f16 {…}
@(require_results)
distance_half3 :: proc "c" (x, y: [3]f16) -> f16 {…}
@(require_results)
distance_half4 :: proc "c" (x, y: [4]f16) -> f16 {…}
@(require_results)
dot_double :: proc "c" (a, b: f64) -> f64 {…}
@(require_results)
dot_double2 :: proc "c" (a, b: [2]f64) -> f64 {…}
@(require_results)
dot_double3 :: proc "c" (a, b: [3]f64) -> f64 {…}
@(require_results)
dot_double4 :: proc "c" (a, b: [4]f64) -> f64 {…}
@(require_results)
dot_float :: proc "c" (a, b: f32) -> f32 {…}
@(require_results)
dot_float2 :: proc "c" (a, b: [2]f32) -> f32 {…}
@(require_results)
dot_float3 :: proc "c" (a, b: [3]f32) -> f32 {…}
@(require_results)
dot_float4 :: proc "c" (a, b: [4]f32) -> f32 {…}
@(require_results)
dot_half :: proc "c" (a, b: f16) -> f16 {…}
@(require_results)
dot_half2 :: proc "c" (a, b: [2]f16) -> f16 {…}
@(require_results)
dot_half3 :: proc "c" (a, b: [3]f16) -> f16 {…}
@(require_results)
dot_half4 :: proc "c" (a, b: [4]f16) -> f16 {…}
@(require_results)
dot_int :: proc "c" (a, b: i32) -> i32 {…}
@(require_results)
dot_int2 :: proc "c" (a, b: [2]i32) -> i32 {…}
@(require_results)
dot_int3 :: proc "c" (a, b: [3]i32) -> i32 {…}
@(require_results)
dot_int4 :: proc "c" (a, b: [4]i32) -> i32 {…}
@(require_results)
dot_uint :: proc "c" (a, b: u32) -> u32 {…}
@(require_results)
dot_uint2 :: proc "c" (a, b: [2]u32) -> u32 {…}
@(require_results)
dot_uint3 :: proc "c" (a, b: [3]u32) -> u32 {…}
@(require_results)
dot_uint4 :: proc "c" (a, b: [4]u32) -> u32 {…}
@(require_results)
equal_double :: proc "c" (a, b: f64) -> bool {…}
@(require_results)
equal_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}
@(require_results)
equal_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}
@(require_results)
equal_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}
@(require_results)
equal_float :: proc "c" (a, b: f32) -> bool {…}
@(require_results)
equal_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}
@(require_results)
equal_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}
@(require_results)
equal_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}
@(require_results)
equal_half :: proc "c" (a, b: f16) -> bool {…}
@(require_results)
equal_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}
@(require_results)
equal_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}
@(require_results)
equal_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}
@(require_results)
equal_int :: proc "c" (a, b: i32) -> bool {…}
@(require_results)
equal_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}
@(require_results)
equal_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}
@(require_results)
equal_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}
@(require_results)
equal_uint :: proc "c" (a, b: u32) -> bool {…}
@(require_results)
equal_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}
@(require_results)
equal_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}
@(require_results)
equal_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}
@(require_results)
exp2_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
exp2_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
exp2_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
exp2_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
exp2_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
exp2_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
exp2_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
exp2_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
exp2_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
exp2_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
exp2_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
exp2_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
exp_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
exp_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
exp_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
exp_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
exp_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
exp_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
exp_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
exp_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
exp_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
exp_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
exp_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
exp_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
faceforward_double :: proc "c" (N, I, Nref: f64) -> f64 {…}
@(require_results)
faceforward_double2 :: proc "c" (N, I, Nref: [2]f64) -> [2]f64 {…}
@(require_results)
faceforward_double3 :: proc "c" (N, I, Nref: [3]f64) -> [3]f64 {…}
@(require_results)
faceforward_double4 :: proc "c" (N, I, Nref: [4]f64) -> [4]f64 {…}
@(require_results)
faceforward_float :: proc "c" (N, I, Nref: f32) -> f32 {…}
@(require_results)
faceforward_float2 :: proc "c" (N, I, Nref: [2]f32) -> [2]f32 {…}
@(require_results)
faceforward_float3 :: proc "c" (N, I, Nref: [3]f32) -> [3]f32 {…}
@(require_results)
faceforward_float4 :: proc "c" (N, I, Nref: [4]f32) -> [4]f32 {…}
@(require_results)
faceforward_half :: proc "c" (N, I, Nref: f16) -> f16 {…}
@(require_results)
faceforward_half2 :: proc "c" (N, I, Nref: [2]f16) -> [2]f16 {…}
@(require_results)
faceforward_half3 :: proc "c" (N, I, Nref: [3]f16) -> [3]f16 {…}
@(require_results)
faceforward_half4 :: proc "c" (N, I, Nref: [4]f16) -> [4]f16 {…}
@(require_results)
floor_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
floor_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
floor_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
floor_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
floor_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
floor_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
floor_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
floor_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
floor_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
floor_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
floor_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
floor_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
fmod_double :: proc "c" (x, y: f64) -> f64 {…}
@(require_results)
fmod_double2 :: proc "c" (x, y: [2]f64) -> [2]f64 {…}
@(require_results)
fmod_double3 :: proc "c" (x, y: [3]f64) -> [3]f64 {…}
@(require_results)
fmod_double4 :: proc "c" (x, y: [4]f64) -> [4]f64 {…}
@(require_results)
fmod_float :: proc "c" (x, y: f32) -> f32 {…}
@(require_results)
fmod_float2 :: proc "c" (x, y: [2]f32) -> [2]f32 {…}
@(require_results)
fmod_float3 :: proc "c" (x, y: [3]f32) -> [3]f32 {…}
@(require_results)
fmod_float4 :: proc "c" (x, y: [4]f32) -> [4]f32 {…}
@(require_results)
fmod_half :: proc "c" (x, y: f16) -> f16 {…}
@(require_results)
fmod_half2 :: proc "c" (x, y: [2]f16) -> [2]f16 {…}
@(require_results)
fmod_half3 :: proc "c" (x, y: [3]f16) -> [3]f16 {…}
@(require_results)
fmod_half4 :: proc "c" (x, y: [4]f16) -> [4]f16 {…}
@(require_results)
frac_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
frac_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
frac_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
frac_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
frac_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
frac_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
frac_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
frac_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
frac_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
frac_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
frac_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
frac_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
greaterThanEqual_double :: proc "c" (a, b: f64) -> bool {…}
@(require_results)
greaterThanEqual_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}
@(require_results)
greaterThanEqual_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}
@(require_results)
greaterThanEqual_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}
@(require_results)
greaterThanEqual_float :: proc "c" (a, b: f32) -> bool {…}
@(require_results)
greaterThanEqual_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}
@(require_results)
greaterThanEqual_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}
@(require_results)
greaterThanEqual_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}
@(require_results)
greaterThanEqual_half :: proc "c" (a, b: f16) -> bool {…}
@(require_results)
greaterThanEqual_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}
@(require_results)
greaterThanEqual_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}
@(require_results)
greaterThanEqual_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}
@(require_results)
greaterThanEqual_int :: proc "c" (a, b: i32) -> bool {…}
@(require_results)
greaterThanEqual_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}
@(require_results)
greaterThanEqual_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}
@(require_results)
greaterThanEqual_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}
@(require_results)
greaterThanEqual_uint :: proc "c" (a, b: u32) -> bool {…}
@(require_results)
greaterThanEqual_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}
@(require_results)
greaterThanEqual_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}
@(require_results)
greaterThanEqual_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}
@(require_results)
greaterThan_double :: proc "c" (a, b: f64) -> bool {…}
@(require_results)
greaterThan_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}
@(require_results)
greaterThan_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}
@(require_results)
greaterThan_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}
@(require_results)
greaterThan_float :: proc "c" (a, b: f32) -> bool {…}
@(require_results)
greaterThan_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}
@(require_results)
greaterThan_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}
@(require_results)
greaterThan_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}
@(require_results)
greaterThan_half :: proc "c" (a, b: f16) -> bool {…}
@(require_results)
greaterThan_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}
@(require_results)
greaterThan_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}
@(require_results)
greaterThan_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}
@(require_results)
greaterThan_int :: proc "c" (a, b: i32) -> bool {…}
@(require_results)
greaterThan_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}
@(require_results)
greaterThan_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}
@(require_results)
greaterThan_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}
@(require_results)
greaterThan_uint :: proc "c" (a, b: u32) -> bool {…}
@(require_results)
greaterThan_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}
@(require_results)
greaterThan_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}
@(require_results)
greaterThan_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}
@(require_results)
hermitian_adjoint :: proc "contextless" (m: $M/matrix[0, 0]$T) -> M {…}
@(require_results)
inverse_double1x1 :: proc "c" (m: matrix[1, 1]f64) -> matrix[1, 1]f64 {…}
@(require_results)
inverse_double2x2 :: proc "c" (m: matrix[2, 2]f64) -> matrix[2, 2]f64 {…}
@(require_results)
inverse_double3x3 :: proc "c" (m: matrix[3, 3]f64) -> matrix[3, 3]f64 {…}
@(require_results)
inverse_double4x4 :: proc "c" (m: matrix[4, 4]f64) -> matrix[4, 4]f64 {…}
@(require_results)
inverse_float1x1 :: proc "c" (m: matrix[1, 1]f32) -> matrix[1, 1]f32 {…}
@(require_results)
inverse_float2x2 :: proc "c" (m: matrix[2, 2]f32) -> matrix[2, 2]f32 {…}
@(require_results)
inverse_float3x3 :: proc "c" (m: matrix[3, 3]f32) -> matrix[3, 3]f32 {…}
@(require_results)
inverse_float4x4 :: proc "c" (m: matrix[4, 4]f32) -> matrix[4, 4]f32 {…}
@(require_results)
inverse_half1x1 :: proc "c" (m: matrix[1, 1]f16) -> matrix[1, 1]f16 {…}
@(require_results)
inverse_half2x2 :: proc "c" (m: matrix[2, 2]f16) -> matrix[2, 2]f16 {…}
@(require_results)
inverse_half3x3 :: proc "c" (m: matrix[3, 3]f16) -> matrix[3, 3]f16 {…}
@(require_results)
inverse_half4x4 :: proc "c" (m: matrix[4, 4]f16) -> matrix[4, 4]f16 {…}
@(require_results)
inverse_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) {…}
@(require_results)
inverse_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) {…}
@(require_results)
inverse_matrix3x3 :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) {…}
@(require_results)
inverse_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) {…}
@(require_results)
inverse_transpose_matrix1x1 :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) {…}
@(require_results)
inverse_transpose_matrix2x2 :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) {…}
@(require_results)
inverse_transpose_matrix3x3 :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: M) {…}
@(require_results)
inverse_transpose_matrix4x4 :: proc "contextless" (x: $M/matrix[4, 4]$T) -> (y: M) {…}
@(require_results)
isfinite_double :: proc "c" (x: f64) -> bool {…}
@(require_results)
isfinite_double2 :: proc "c" (x: [2]f64) -> [2]bool {…}
@(require_results)
isfinite_double3 :: proc "c" (x: [3]f64) -> [3]bool {…}
@(require_results)
isfinite_double4 :: proc "c" (x: [4]f64) -> [4]bool {…}
@(require_results)
isfinite_float :: proc "c" (x: f32) -> bool {…}
@(require_results)
isfinite_float2 :: proc "c" (x: [2]f32) -> [2]bool {…}
@(require_results)
isfinite_float3 :: proc "c" (x: [3]f32) -> [3]bool {…}
@(require_results)
isfinite_float4 :: proc "c" (x: [4]f32) -> [4]bool {…}
@(require_results)
isfinite_half :: proc "c" (x: f16) -> bool {…}
@(require_results)
isfinite_half2 :: proc "c" (x: [2]f16) -> [2]bool {…}
@(require_results)
isfinite_half3 :: proc "c" (x: [3]f16) -> [3]bool {…}
@(require_results)
isfinite_half4 :: proc "c" (x: [4]f16) -> [4]bool {…}
@(require_results)
isinf_double :: proc "c" (x: f64) -> bool {…}
@(require_results)
isinf_double2 :: proc "c" (x: [2]f64) -> [2]bool {…}
@(require_results)
isinf_double3 :: proc "c" (x: [3]f64) -> [3]bool {…}
@(require_results)
isinf_double4 :: proc "c" (x: [4]f64) -> [4]bool {…}
@(require_results)
isinf_float :: proc "c" (x: f32) -> bool {…}
@(require_results)
isinf_float2 :: proc "c" (x: [2]f32) -> [2]bool {…}
@(require_results)
isinf_float3 :: proc "c" (x: [3]f32) -> [3]bool {…}
@(require_results)
isinf_float4 :: proc "c" (x: [4]f32) -> [4]bool {…}
@(require_results)
isinf_half :: proc "c" (x: f16) -> bool {…}
@(require_results)
isinf_half2 :: proc "c" (x: [2]f16) -> [2]bool {…}
@(require_results)
isinf_half3 :: proc "c" (x: [3]f16) -> [3]bool {…}
@(require_results)
isinf_half4 :: proc "c" (x: [4]f16) -> [4]bool {…}
@(require_results)
isnan_double :: proc "c" (x: f64) -> bool {…}
@(require_results)
isnan_double2 :: proc "c" (x: [2]f64) -> [2]bool {…}
@(require_results)
isnan_double3 :: proc "c" (x: [3]f64) -> [3]bool {…}
@(require_results)
isnan_double4 :: proc "c" (x: [4]f64) -> [4]bool {…}
@(require_results)
isnan_float :: proc "c" (x: f32) -> bool {…}
@(require_results)
isnan_float2 :: proc "c" (x: [2]f32) -> [2]bool {…}
@(require_results)
isnan_float3 :: proc "c" (x: [3]f32) -> [3]bool {…}
@(require_results)
isnan_float4 :: proc "c" (x: [4]f32) -> [4]bool {…}
@(require_results)
isnan_half :: proc "c" (x: f16) -> bool {…}
@(require_results)
isnan_half2 :: proc "c" (x: [2]f16) -> [2]bool {…}
@(require_results)
isnan_half3 :: proc "c" (x: [3]f16) -> [3]bool {…}
@(require_results)
isnan_half4 :: proc "c" (x: [4]f16) -> [4]bool {…}
@(require_results)
length_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
length_double2 :: proc "c" (x: [2]f64) -> f64 {…}
@(require_results)
length_double3 :: proc "c" (x: [3]f64) -> f64 {…}
@(require_results)
length_double4 :: proc "c" (x: [4]f64) -> f64 {…}
@(require_results)
length_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
length_float2 :: proc "c" (x: [2]f32) -> f32 {…}
@(require_results)
length_float3 :: proc "c" (x: [3]f32) -> f32 {…}
@(require_results)
length_float4 :: proc "c" (x: [4]f32) -> f32 {…}
@(require_results)
length_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
length_half2 :: proc "c" (x: [2]f16) -> f16 {…}
@(require_results)
length_half3 :: proc "c" (x: [3]f16) -> f16 {…}
@(require_results)
length_half4 :: proc "c" (x: [4]f16) -> f16 {…}
@(require_results)
lerp_double :: proc "c" (x, y, t: f64) -> f64 {…}
@(require_results)
lerp_double2 :: proc "c" (x, y, t: [2]f64) -> [2]f64 {…}
@(require_results)
lerp_double3 :: proc "c" (x, y, t: [3]f64) -> [3]f64 {…}
@(require_results)
lerp_double4 :: proc "c" (x, y, t: [4]f64) -> [4]f64 {…}
@(require_results)
lerp_float :: proc "c" (x, y, t: f32) -> f32 {…}
@(require_results)
lerp_float2 :: proc "c" (x, y, t: [2]f32) -> [2]f32 {…}
@(require_results)
lerp_float3 :: proc "c" (x, y, t: [3]f32) -> [3]f32 {…}
@(require_results)
lerp_float4 :: proc "c" (x, y, t: [4]f32) -> [4]f32 {…}
@(require_results)
lerp_half :: proc "c" (x, y, t: f16) -> f16 {…}
@(require_results)
lerp_half2 :: proc "c" (x, y, t: [2]f16) -> [2]f16 {…}
@(require_results)
lerp_half3 :: proc "c" (x, y, t: [3]f16) -> [3]f16 {…}
@(require_results)
lerp_half4 :: proc "c" (x, y, t: [4]f16) -> [4]f16 {…}
@(require_results)
lessThanEqual_double :: proc "c" (a, b: f64) -> bool {…}
@(require_results)
lessThanEqual_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}
@(require_results)
lessThanEqual_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}
@(require_results)
lessThanEqual_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}
@(require_results)
lessThanEqual_float :: proc "c" (a, b: f32) -> bool {…}
@(require_results)
lessThanEqual_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}
@(require_results)
lessThanEqual_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}
@(require_results)
lessThanEqual_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}
@(require_results)
lessThanEqual_half :: proc "c" (a, b: f16) -> bool {…}
@(require_results)
lessThanEqual_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}
@(require_results)
lessThanEqual_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}
@(require_results)
lessThanEqual_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}
@(require_results)
lessThanEqual_int :: proc "c" (a, b: i32) -> bool {…}
@(require_results)
lessThanEqual_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}
@(require_results)
lessThanEqual_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}
@(require_results)
lessThanEqual_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}
@(require_results)
lessThanEqual_uint :: proc "c" (a, b: u32) -> bool {…}
@(require_results)
lessThanEqual_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}
@(require_results)
lessThanEqual_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}
@(require_results)
lessThanEqual_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}
@(require_results)
lessThan_double :: proc "c" (a, b: f64) -> bool {…}
@(require_results)
lessThan_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}
@(require_results)
lessThan_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}
@(require_results)
lessThan_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}
@(require_results)
lessThan_float :: proc "c" (a, b: f32) -> bool {…}
@(require_results)
lessThan_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}
@(require_results)
lessThan_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}
@(require_results)
lessThan_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}
@(require_results)
lessThan_half :: proc "c" (a, b: f16) -> bool {…}
@(require_results)
lessThan_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}
@(require_results)
lessThan_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}
@(require_results)
lessThan_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}
@(require_results)
lessThan_int :: proc "c" (a, b: i32) -> bool {…}
@(require_results)
lessThan_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}
@(require_results)
lessThan_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}
@(require_results)
lessThan_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}
@(require_results)
lessThan_uint :: proc "c" (a, b: u32) -> bool {…}
@(require_results)
lessThan_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}
@(require_results)
lessThan_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}
@(require_results)
lessThan_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}
@(require_results)
log10_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
log10_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
log10_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
log10_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
log10_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
log10_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
log10_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
log10_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
log10_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
log10_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
log10_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
log10_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
log2_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
log2_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
log2_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
log2_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
log2_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
log2_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
log2_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
log2_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
log2_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
log2_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
log2_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
log2_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
log_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
log_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
log_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
log_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
log_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
log_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
log_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
log_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
log_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
log_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
log_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
log_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
matrix_minor :: proc "contextless" (
m: $M/matrix[0, 0]$T,
#any_int row, #any_int column: i32,
) -> (minor: T) {…}
@(require_results)
max_double :: proc "c" (x, y: f64) -> f64 {…}
@(require_results)
max_double2 :: proc "c" (x, y: [2]f64) -> [2]f64 {…}
@(require_results)
max_double3 :: proc "c" (x, y: [3]f64) -> [3]f64 {…}
@(require_results)
max_double4 :: proc "c" (x, y: [4]f64) -> [4]f64 {…}
@(require_results)
max_float :: proc "c" (x, y: f32) -> f32 {…}
@(require_results)
max_float2 :: proc "c" (x, y: [2]f32) -> [2]f32 {…}
@(require_results)
max_float3 :: proc "c" (x, y: [3]f32) -> [3]f32 {…}
@(require_results)
max_float4 :: proc "c" (x, y: [4]f32) -> [4]f32 {…}
@(require_results)
max_half :: proc "c" (x, y: f16) -> f16 {…}
@(require_results)
max_half2 :: proc "c" (x, y: [2]f16) -> [2]f16 {…}
@(require_results)
max_half3 :: proc "c" (x, y: [3]f16) -> [3]f16 {…}
@(require_results)
max_half4 :: proc "c" (x, y: [4]f16) -> [4]f16 {…}
@(require_results)
max_int :: proc "c" (x, y: i32) -> i32 {…}
@(require_results)
max_int2 :: proc "c" (x, y: [2]i32) -> [2]i32 {…}
@(require_results)
max_int3 :: proc "c" (x, y: [3]i32) -> [3]i32 {…}
@(require_results)
max_int4 :: proc "c" (x, y: [4]i32) -> [4]i32 {…}
@(require_results)
max_uint :: proc "c" (x, y: u32) -> u32 {…}
@(require_results)
max_uint2 :: proc "c" (x, y: [2]u32) -> [2]u32 {…}
@(require_results)
max_uint3 :: proc "c" (x, y: [3]u32) -> [3]u32 {…}
@(require_results)
max_uint4 :: proc "c" (x, y: [4]u32) -> [4]u32 {…}
@(require_results)
min_double :: proc "c" (x, y: f64) -> f64 {…}
@(require_results)
min_double2 :: proc "c" (x, y: [2]f64) -> [2]f64 {…}
@(require_results)
min_double3 :: proc "c" (x, y: [3]f64) -> [3]f64 {…}
@(require_results)
min_double4 :: proc "c" (x, y: [4]f64) -> [4]f64 {…}
@(require_results)
min_float :: proc "c" (x, y: f32) -> f32 {…}
@(require_results)
min_float2 :: proc "c" (x, y: [2]f32) -> [2]f32 {…}
@(require_results)
min_float3 :: proc "c" (x, y: [3]f32) -> [3]f32 {…}
@(require_results)
min_float4 :: proc "c" (x, y: [4]f32) -> [4]f32 {…}
@(require_results)
min_half :: proc "c" (x, y: f16) -> f16 {…}
@(require_results)
min_half2 :: proc "c" (x, y: [2]f16) -> [2]f16 {…}
@(require_results)
min_half3 :: proc "c" (x, y: [3]f16) -> [3]f16 {…}
@(require_results)
min_half4 :: proc "c" (x, y: [4]f16) -> [4]f16 {…}
@(require_results)
min_int :: proc "c" (x, y: i32) -> i32 {…}
@(require_results)
min_int2 :: proc "c" (x, y: [2]i32) -> [2]i32 {…}
@(require_results)
min_int3 :: proc "c" (x, y: [3]i32) -> [3]i32 {…}
@(require_results)
min_int4 :: proc "c" (x, y: [4]i32) -> [4]i32 {…}
@(require_results)
min_uint :: proc "c" (x, y: u32) -> u32 {…}
@(require_results)
min_uint2 :: proc "c" (x, y: [2]u32) -> [2]u32 {…}
@(require_results)
min_uint3 :: proc "c" (x, y: [3]u32) -> [3]u32 {…}
@(require_results)
min_uint4 :: proc "c" (x, y: [4]u32) -> [4]u32 {…}
@(require_results)
normalize_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
normalize_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
normalize_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
normalize_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
normalize_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
normalize_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
normalize_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
normalize_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
normalize_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
normalize_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
normalize_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
normalize_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
notEqual_double :: proc "c" (a, b: f64) -> bool {…}
@(require_results)
notEqual_double2 :: proc "c" (a, b: [2]f64) -> [2]bool {…}
@(require_results)
notEqual_double3 :: proc "c" (a, b: [3]f64) -> [3]bool {…}
@(require_results)
notEqual_double4 :: proc "c" (a, b: [4]f64) -> [4]bool {…}
@(require_results)
notEqual_float :: proc "c" (a, b: f32) -> bool {…}
@(require_results)
notEqual_float2 :: proc "c" (a, b: [2]f32) -> [2]bool {…}
@(require_results)
notEqual_float3 :: proc "c" (a, b: [3]f32) -> [3]bool {…}
@(require_results)
notEqual_float4 :: proc "c" (a, b: [4]f32) -> [4]bool {…}
@(require_results)
notEqual_half :: proc "c" (a, b: f16) -> bool {…}
@(require_results)
notEqual_half2 :: proc "c" (a, b: [2]f16) -> [2]bool {…}
@(require_results)
notEqual_half3 :: proc "c" (a, b: [3]f16) -> [3]bool {…}
@(require_results)
notEqual_half4 :: proc "c" (a, b: [4]f16) -> [4]bool {…}
@(require_results)
notEqual_int :: proc "c" (a, b: i32) -> bool {…}
@(require_results)
notEqual_int2 :: proc "c" (a, b: [2]i32) -> [2]bool {…}
@(require_results)
notEqual_int3 :: proc "c" (a, b: [3]i32) -> [3]bool {…}
@(require_results)
notEqual_int4 :: proc "c" (a, b: [4]i32) -> [4]bool {…}
@(require_results)
notEqual_uint :: proc "c" (a, b: u32) -> bool {…}
@(require_results)
notEqual_uint2 :: proc "c" (a, b: [2]u32) -> [2]bool {…}
@(require_results)
notEqual_uint3 :: proc "c" (a, b: [3]u32) -> [3]bool {…}
@(require_results)
notEqual_uint4 :: proc "c" (a, b: [4]u32) -> [4]bool {…}
@(require_results)
not_bool :: proc "c" (v: bool) -> bool {…}
@(require_results)
not_bool2 :: proc "c" (v: [2]bool) -> [2]bool {…}
@(require_results)
not_bool3 :: proc "c" (v: [3]bool) -> [3]bool {…}
@(require_results)
not_bool4 :: proc "c" (v: [4]bool) -> [4]bool {…}
@(require_results)
pow_double :: proc "c" (x, y: f64) -> f64 {…}
@(require_results)
pow_double2 :: proc "c" (x, y: [2]f64) -> [2]f64 {…}
@(require_results)
pow_double3 :: proc "c" (x, y: [3]f64) -> [3]f64 {…}
@(require_results)
pow_double4 :: proc "c" (x, y: [4]f64) -> [4]f64 {…}
@(require_results)
pow_float :: proc "c" (x, y: f32) -> f32 {…}
@(require_results)
pow_float2 :: proc "c" (x, y: [2]f32) -> [2]f32 {…}
@(require_results)
pow_float3 :: proc "c" (x, y: [3]f32) -> [3]f32 {…}
@(require_results)
pow_float4 :: proc "c" (x, y: [4]f32) -> [4]f32 {…}
@(require_results)
pow_half :: proc "c" (x, y: f16) -> f16 {…}
@(require_results)
pow_half2 :: proc "c" (x, y: [2]f16) -> [2]f16 {…}
@(require_results)
pow_half3 :: proc "c" (x, y: [3]f16) -> [3]f16 {…}
@(require_results)
pow_half4 :: proc "c" (x, y: [4]f16) -> [4]f16 {…}
@(require_results)
radians_double :: proc "c" (degrees: f64) -> f64 {…}
@(require_results)
radians_double2 :: proc "c" (degrees: [2]f64) -> [2]f64 {…}
@(require_results)
radians_double3 :: proc "c" (degrees: [3]f64) -> [3]f64 {…}
@(require_results)
radians_double4 :: proc "c" (degrees: [4]f64) -> [4]f64 {…}
@(require_results)
radians_float :: proc "c" (degrees: f32) -> f32 {…}
@(require_results)
radians_float2 :: proc "c" (degrees: [2]f32) -> [2]f32 {…}
@(require_results)
radians_float3 :: proc "c" (degrees: [3]f32) -> [3]f32 {…}
@(require_results)
radians_float4 :: proc "c" (degrees: [4]f32) -> [4]f32 {…}
@(require_results)
radians_half :: proc "c" (degrees: f16) -> f16 {…}
@(require_results)
radians_half2 :: proc "c" (degrees: [2]f16) -> [2]f16 {…}
@(require_results)
radians_half3 :: proc "c" (degrees: [3]f16) -> [3]f16 {…}
@(require_results)
radians_half4 :: proc "c" (degrees: [4]f16) -> [4]f16 {…}
@(require_results)
rcp_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
rcp_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
rcp_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
rcp_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
rcp_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
rcp_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
rcp_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
rcp_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
rcp_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
rcp_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
rcp_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
rcp_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
reflect_double :: proc "c" (I, N: f64) -> f64 {…}
@(require_results)
reflect_double2 :: proc "c" (I, N: [2]f64) -> [2]f64 {…}
@(require_results)
reflect_double3 :: proc "c" (I, N: [3]f64) -> [3]f64 {…}
@(require_results)
reflect_double4 :: proc "c" (I, N: [4]f64) -> [4]f64 {…}
@(require_results)
reflect_float :: proc "c" (I, N: f32) -> f32 {…}
@(require_results)
reflect_float2 :: proc "c" (I, N: [2]f32) -> [2]f32 {…}
@(require_results)
reflect_float3 :: proc "c" (I, N: [3]f32) -> [3]f32 {…}
@(require_results)
reflect_float4 :: proc "c" (I, N: [4]f32) -> [4]f32 {…}
@(require_results)
reflect_half :: proc "c" (I, N: f16) -> f16 {…}
@(require_results)
reflect_half2 :: proc "c" (I, N: [2]f16) -> [2]f16 {…}
@(require_results)
reflect_half3 :: proc "c" (I, N: [3]f16) -> [3]f16 {…}
@(require_results)
reflect_half4 :: proc "c" (I, N: [4]f16) -> [4]f16 {…}
@(require_results)
refract_double :: proc "c" (i, n, eta: f64) -> f64 {…}
@(require_results)
refract_double2 :: proc "c" (i, n: [2]f64, eta: f64) -> [2]f64 {…}
@(require_results)
refract_double3 :: proc "c" (i, n: [3]f64, eta: f64) -> [3]f64 {…}
@(require_results)
refract_double4 :: proc "c" (i, n: [4]f64, eta: f64) -> [4]f64 {…}
@(require_results)
refract_float :: proc "c" (i, n, eta: f32) -> f32 {…}
@(require_results)
refract_float2 :: proc "c" (i, n: [2]f32, eta: f32) -> [2]f32 {…}
@(require_results)
refract_float3 :: proc "c" (i, n: [3]f32, eta: f32) -> [3]f32 {…}
@(require_results)
refract_float4 :: proc "c" (i, n: [4]f32, eta: f32) -> [4]f32 {…}
@(require_results)
refract_half :: proc "c" (i, n, eta: f16) -> f16 {…}
@(require_results)
refract_half2 :: proc "c" (i, n: [2]f16, eta: f16) -> [2]f16 {…}
@(require_results)
refract_half3 :: proc "c" (i, n: [3]f16, eta: f16) -> [3]f16 {…}
@(require_results)
refract_half4 :: proc "c" (i, n: [4]f16, eta: f16) -> [4]f16 {…}
@(require_results)
round_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
round_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
round_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
round_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
round_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
round_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
round_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
round_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
round_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
round_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
round_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
round_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
rsqrt_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
rsqrt_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
rsqrt_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
rsqrt_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
rsqrt_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
rsqrt_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
rsqrt_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
rsqrt_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
rsqrt_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
rsqrt_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
rsqrt_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
rsqrt_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
saturate_double :: proc "c" (v: f64) -> f64 {…}
@(require_results)
saturate_double2 :: proc "c" (v: [2]f64) -> [2]f64 {…}
@(require_results)
saturate_double3 :: proc "c" (v: [3]f64) -> [3]f64 {…}
@(require_results)
saturate_double4 :: proc "c" (v: [4]f64) -> [4]f64 {…}
@(require_results)
saturate_float :: proc "c" (v: f32) -> f32 {…}
@(require_results)
saturate_float2 :: proc "c" (v: [2]f32) -> [2]f32 {…}
@(require_results)
saturate_float3 :: proc "c" (v: [3]f32) -> [3]f32 {…}
@(require_results)
saturate_float4 :: proc "c" (v: [4]f32) -> [4]f32 {…}
@(require_results)
saturate_half :: proc "c" (v: f16) -> f16 {…}
@(require_results)
saturate_half2 :: proc "c" (v: [2]f16) -> [2]f16 {…}
@(require_results)
saturate_half3 :: proc "c" (v: [3]f16) -> [3]f16 {…}
@(require_results)
saturate_half4 :: proc "c" (v: [4]f16) -> [4]f16 {…}
@(require_results)
saturate_int :: proc "c" (v: i32) -> i32 {…}
@(require_results)
saturate_int2 :: proc "c" (v: [2]i32) -> [2]i32 {…}
@(require_results)
saturate_int3 :: proc "c" (v: [3]i32) -> [3]i32 {…}
@(require_results)
saturate_int4 :: proc "c" (v: [4]i32) -> [4]i32 {…}
@(require_results)
saturate_uint :: proc "c" (v: u32) -> u32 {…}
@(require_results)
saturate_uint2 :: proc "c" (v: [2]u32) -> [2]u32 {…}
@(require_results)
saturate_uint3 :: proc "c" (v: [3]u32) -> [3]u32 {…}
@(require_results)
saturate_uint4 :: proc "c" (v: [4]u32) -> [4]u32 {…}
@(require_results)
scalarTripleProduct_double3 :: proc "c" (a, b, c: [3]f64) -> f64 {…}
@(require_results)
scalarTripleProduct_float3 :: proc "c" (a, b, c: [3]f32) -> f32 {…}
@(require_results)
scalarTripleProduct_half3 :: proc "c" (a, b, c: [3]f16) -> f16 {…}
@(require_results)
scalarTripleProduct_int3 :: proc "c" (a, b, c: [3]i32) -> i32 {…}
@(require_results)
sign_double :: proc "c" (x: f64) -> i32 {…}
@(require_results)
sign_double2 :: proc "c" (x: [2]f64) -> [2]i32 {…}
@(require_results)
sign_double3 :: proc "c" (x: [3]f64) -> [3]i32 {…}
@(require_results)
sign_double4 :: proc "c" (x: [4]f64) -> [4]i32 {…}
@(require_results)
sign_float :: proc "c" (x: f32) -> i32 {…}
@(require_results)
sign_float2 :: proc "c" (x: [2]f32) -> [2]i32 {…}
@(require_results)
sign_float3 :: proc "c" (x: [3]f32) -> [3]i32 {…}
@(require_results)
sign_float4 :: proc "c" (x: [4]f32) -> [4]i32 {…}
@(require_results)
sign_half :: proc "c" (x: f16) -> i32 {…}
@(require_results)
sign_half2 :: proc "c" (x: [2]f16) -> [2]i32 {…}
@(require_results)
sign_half3 :: proc "c" (x: [3]f16) -> [3]i32 {…}
@(require_results)
sign_half4 :: proc "c" (x: [4]f16) -> [4]i32 {…}
@(require_results)
sign_int :: proc "c" (x: i32) -> i32 {…}
@(require_results)
sign_int2 :: proc "c" (x: [2]i32) -> [2]i32 {…}
@(require_results)
sign_int3 :: proc "c" (x: [3]i32) -> [3]i32 {…}
@(require_results)
sign_int4 :: proc "c" (x: [4]i32) -> [4]i32 {…}
@(require_results)
sign_uint :: proc "c" (x: u32) -> i32 {…}
@(require_results)
sign_uint2 :: proc "c" (x: [2]u32) -> [2]i32 {…}
@(require_results)
sign_uint3 :: proc "c" (x: [3]u32) -> [3]i32 {…}
@(require_results)
sign_uint4 :: proc "c" (x: [4]u32) -> [4]i32 {…}
@(require_results)
sin_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
sin_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
sin_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
sin_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
sin_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
sin_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
sin_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
sin_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
sin_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
sin_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
sin_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
sin_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
sinh_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
sinh_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
sinh_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
sinh_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
sinh_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
sinh_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
sinh_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
sinh_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
sinh_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
sinh_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
sinh_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
sinh_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
smoothstep_double :: proc "c" (edge0, edge1, x: f64) -> f64 {…}
@(require_results)
smoothstep_double2 :: proc "c" (edge0, edge1, x: [2]f64) -> [2]f64 {…}
@(require_results)
smoothstep_double3 :: proc "c" (edge0, edge1, x: [3]f64) -> [3]f64 {…}
@(require_results)
smoothstep_double4 :: proc "c" (edge0, edge1, x: [4]f64) -> [4]f64 {…}
@(require_results)
smoothstep_float :: proc "c" (edge0, edge1, x: f32) -> f32 {…}
@(require_results)
smoothstep_float2 :: proc "c" (edge0, edge1, x: [2]f32) -> [2]f32 {…}
@(require_results)
smoothstep_float3 :: proc "c" (edge0, edge1, x: [3]f32) -> [3]f32 {…}
@(require_results)
smoothstep_float4 :: proc "c" (edge0, edge1, x: [4]f32) -> [4]f32 {…}
@(require_results)
smoothstep_half :: proc "c" (edge0, edge1, x: f16) -> f16 {…}
@(require_results)
smoothstep_half2 :: proc "c" (edge0, edge1, x: [2]f16) -> [2]f16 {…}
@(require_results)
smoothstep_half3 :: proc "c" (edge0, edge1, x: [3]f16) -> [3]f16 {…}
@(require_results)
smoothstep_half4 :: proc "c" (edge0, edge1, x: [4]f16) -> [4]f16 {…}
@(require_results)
sqrt_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
sqrt_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
sqrt_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
sqrt_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
sqrt_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
sqrt_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
sqrt_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
sqrt_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
sqrt_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
sqrt_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
sqrt_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
sqrt_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
step_double :: proc "c" (edge, x: f64) -> f64 {…}
@(require_results)
step_double2 :: proc "c" (edge, x: [2]f64) -> [2]f64 {…}
@(require_results)
step_double3 :: proc "c" (edge, x: [3]f64) -> [3]f64 {…}
@(require_results)
step_double4 :: proc "c" (edge, x: [4]f64) -> [4]f64 {…}
@(require_results)
step_float :: proc "c" (edge, x: f32) -> f32 {…}
@(require_results)
step_float2 :: proc "c" (edge, x: [2]f32) -> [2]f32 {…}
@(require_results)
step_float3 :: proc "c" (edge, x: [3]f32) -> [3]f32 {…}
@(require_results)
step_float4 :: proc "c" (edge, x: [4]f32) -> [4]f32 {…}
@(require_results)
step_half :: proc "c" (edge, x: f16) -> f16 {…}
@(require_results)
step_half2 :: proc "c" (edge, x: [2]f16) -> [2]f16 {…}
@(require_results)
step_half3 :: proc "c" (edge, x: [3]f16) -> [3]f16 {…}
@(require_results)
step_half4 :: proc "c" (edge, x: [4]f16) -> [4]f16 {…}
@(require_results)
tan_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
tan_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
tan_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
tan_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
tan_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
tan_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
tan_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
tan_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
tan_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
tan_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
tan_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
tan_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
tanh_double :: proc "c" (x: f64) -> f64 {…}
@(require_results)
tanh_double2 :: proc "c" (x: [2]f64) -> [2]f64 {…}
@(require_results)
tanh_double3 :: proc "c" (x: [3]f64) -> [3]f64 {…}
@(require_results)
tanh_double4 :: proc "c" (x: [4]f64) -> [4]f64 {…}
@(require_results)
tanh_float :: proc "c" (x: f32) -> f32 {…}
@(require_results)
tanh_float2 :: proc "c" (x: [2]f32) -> [2]f32 {…}
@(require_results)
tanh_float3 :: proc "c" (x: [3]f32) -> [3]f32 {…}
@(require_results)
tanh_float4 :: proc "c" (x: [4]f32) -> [4]f32 {…}
@(require_results)
tanh_half :: proc "c" (x: f16) -> f16 {…}
@(require_results)
tanh_half2 :: proc "c" (x: [2]f16) -> [2]f16 {…}
@(require_results)
tanh_half3 :: proc "c" (x: [3]f16) -> [3]f16 {…}
@(require_results)
tanh_half4 :: proc "c" (x: [4]f16) -> [4]f16 {…}
@(require_results)
trace :: proc "contextless" (m: $M/matrix[0, 0]$T) -> (trace: T) {…}
transpose :: intrinsics.transpose
transpose :: proc(m: $M/matrix[$R, $C]$E) -> matrix[C, R]E {…}
@(require_results)
vectorTripleProduct_double3 :: proc "c" (a, b, c: [3]f64) -> [3]f64 {…}
@(require_results)
vectorTripleProduct_float3 :: proc "c" (a, b, c: [3]f32) -> [3]f32 {…}
@(require_results)
vectorTripleProduct_half3 :: proc "c" (a, b, c: [3]f16) -> [3]f16 {…}
@(require_results)
vectorTripleProduct_int3 :: proc "c" (a, b, c: [3]i32) -> [3]i32 {…}
abs :: proc{
abs_int,
abs_uint,
abs_half,
abs_float,
abs_double,
abs_half2,
abs_half3,
abs_half4,
abs_float2,
abs_float3,
abs_float4,
abs_double2,
abs_double3,
abs_double4,
abs_int2,
abs_int3,
abs_int4,
abs_uint2,
abs_uint3,
abs_uint4,
}
acos :: proc{
acos_half,
acos_float,
acos_double,
acos_half2,
acos_half3,
acos_half4,
acos_float2,
acos_float3,
acos_float4,
acos_double2,
acos_double3,
acos_double4,
}
acosh :: proc{
acosh_half,
acosh_float,
acosh_double,
acosh_half2,
acosh_half3,
acosh_half4,
acosh_float2,
acosh_float3,
acosh_float4,
acosh_double2,
acosh_double3,
acosh_double4,
}
asfloat :: proc{
asfloat_float,
asfloat_float2,
asfloat_float3,
asfloat_float4,
asfloat_int,
asfloat_int2,
asfloat_int3,
asfloat_int4,
asfloat_uint,
asfloat_uint2,
asfloat_uint3,
asfloat_uint4,
asfloat_float1x1,
asfloat_float2x2,
asfloat_float3x3,
asfloat_float4x4,
asfloat_float1x2,
asfloat_float1x3,
asfloat_float1x4,
asfloat_float2x1,
asfloat_float2x3,
asfloat_float2x4,
asfloat_float3x1,
asfloat_float3x2,
asfloat_float3x4,
asfloat_float4x1,
asfloat_float4x2,
asfloat_float4x3,
asfloat_int1x1,
asfloat_int2x2,
asfloat_int3x3,
asfloat_int4x4,
asfloat_int1x2,
asfloat_int1x3,
asfloat_int1x4,
asfloat_int2x1,
asfloat_int2x3,
asfloat_int2x4,
asfloat_int3x1,
asfloat_int3x2,
asfloat_int3x4,
asfloat_int4x1,
asfloat_int4x2,
asfloat_int4x3,
}
asin :: proc{
asin_half,
asin_float,
asin_double,
asin_half2,
asin_half3,
asin_half4,
asin_float2,
asin_float3,
asin_float4,
asin_double2,
asin_double3,
asin_double4,
}
asinh :: proc{
asinh_half,
asinh_float,
asinh_double,
asinh_half2,
asinh_half3,
asinh_half4,
asinh_float2,
asinh_float3,
asinh_float4,
asinh_double2,
asinh_double3,
asinh_double4,
}
asint :: proc{
asint_float,
asint_float2,
asint_float3,
asint_float4,
asint_int,
asint_int2,
asint_int3,
asint_int4,
asint_uint,
asint_uint2,
asint_uint3,
asint_uint4,
asint_float1x1,
asint_float2x2,
asint_float3x3,
asint_float4x4,
asint_float1x2,
asint_float1x3,
asint_float1x4,
asint_float2x1,
asint_float2x3,
asint_float2x4,
asint_float3x1,
asint_float3x2,
asint_float3x4,
asint_float4x1,
asint_float4x2,
asint_float4x3,
asint_int1x1,
asint_int2x2,
asint_int3x3,
asint_int4x4,
asint_int1x2,
asint_int1x3,
asint_int1x4,
asint_int2x1,
asint_int2x3,
asint_int2x4,
asint_int3x1,
asint_int3x2,
asint_int3x4,
asint_int4x1,
asint_int4x2,
asint_int4x3,
}
asuint :: proc{
asuint_float,
asuint_float2,
asuint_float3,
asuint_float4,
asuint_int,
asuint_int2,
asuint_int3,
asuint_int4,
asuint_uint,
asuint_uint2,
asuint_uint3,
asuint_uint4,
asuint_double,
asuint_double2,
}
atan :: proc{
atan_half,
atan_float,
atan_double,
atan_half2,
atan_half3,
atan_half4,
atan_float2,
atan_float3,
atan_float4,
atan_double2,
atan_double3,
atan_double4,
atan2_float,
atan2_double,
atan2_float2,
atan2_float3,
atan2_float4,
atan2_double2,
atan2_double3,
atan2_double4,
}
atan2 :: proc{
atan2_half,
atan2_float,
atan2_double,
atan2_half2,
atan2_half3,
atan2_half4,
atan2_float2,
atan2_float3,
atan2_float4,
atan2_double2,
atan2_double3,
atan2_double4,
}
atanh :: proc{
atanh_half,
atanh_float,
atanh_double,
atanh_half2,
atanh_half3,
atanh_half4,
atanh_float2,
atanh_float3,
atanh_float4,
atanh_double2,
atanh_double3,
atanh_double4,
}
ceil :: proc{
ceil_half,
ceil_float,
ceil_double,
ceil_half2,
ceil_half3,
ceil_half4,
ceil_float2,
ceil_float3,
ceil_float4,
ceil_double2,
ceil_double3,
ceil_double4,
}
clamp :: proc{
clamp_int,
clamp_uint,
clamp_half,
clamp_float,
clamp_double,
clamp_half2,
clamp_half3,
clamp_half4,
clamp_float2,
clamp_float3,
clamp_float4,
clamp_double2,
clamp_double3,
clamp_double4,
clamp_int2,
clamp_int3,
clamp_int4,
clamp_uint2,
clamp_uint3,
clamp_uint4,
}
cos :: proc{
cos_half,
cos_float,
cos_double,
cos_half2,
cos_half3,
cos_half4,
cos_float2,
cos_float3,
cos_float4,
cos_double2,
cos_double3,
cos_double4,
}
cosh :: proc{
cosh_half,
cosh_float,
cosh_double,
cosh_half2,
cosh_half3,
cosh_half4,
cosh_float2,
cosh_float3,
cosh_float4,
cosh_double2,
cosh_double3,
cosh_double4,
}
degrees :: proc{
degrees_half,
degrees_float,
degrees_double,
degrees_half2,
degrees_half3,
degrees_half4,
degrees_float2,
degrees_float3,
degrees_float4,
degrees_double2,
degrees_double3,
degrees_double4,
}
distance :: proc{
distance_half,
distance_float,
distance_double,
distance_half2,
distance_half3,
distance_half4,
distance_float2,
distance_float3,
distance_float4,
distance_double2,
distance_double3,
distance_double4,
}
dot :: proc{
dot_int,
dot_uint,
dot_half,
dot_float,
dot_double,
dot_half2,
dot_half3,
dot_half4,
dot_float2,
dot_float3,
dot_float4,
dot_double2,
dot_double3,
dot_double4,
dot_int2,
dot_int3,
dot_int4,
dot_uint2,
dot_uint3,
dot_uint4,
}
equal :: proc{
equal_half,
equal_float,
equal_double,
equal_int,
equal_uint,
equal_half2,
equal_float2,
equal_double2,
equal_int2,
equal_uint2,
equal_half3,
equal_float3,
equal_double3,
equal_int3,
equal_uint3,
equal_half4,
equal_float4,
equal_double4,
equal_int4,
equal_uint4,
}
exp :: proc{
exp_half,
exp_float,
exp_double,
exp_half2,
exp_half3,
exp_half4,
exp_float2,
exp_float3,
exp_float4,
exp_double2,
exp_double3,
exp_double4,
}
exp2 :: proc{
exp2_half,
exp2_float,
exp2_double,
exp2_half2,
exp2_half3,
exp2_half4,
exp2_float2,
exp2_float3,
exp2_float4,
exp2_double2,
exp2_double3,
exp2_double4,
}
faceforward :: proc{
faceforward_half,
faceforward_float,
faceforward_double,
faceforward_half2,
faceforward_half3,
faceforward_half4,
faceforward_float2,
faceforward_float3,
faceforward_float4,
faceforward_double2,
faceforward_double3,
faceforward_double4,
}
floor :: proc{
floor_half,
floor_float,
floor_double,
floor_half2,
floor_half3,
floor_half4,
floor_float2,
floor_float3,
floor_float4,
floor_double2,
floor_double3,
floor_double4,
}
fmod :: proc{
fmod_half,
fmod_float,
fmod_double,
fmod_half2,
fmod_half3,
fmod_half4,
fmod_float2,
fmod_float3,
fmod_float4,
fmod_double2,
fmod_double3,
fmod_double4,
}
frac :: proc{
frac_half,
frac_float,
frac_double,
frac_half2,
frac_half3,
frac_half4,
frac_float2,
frac_float3,
frac_float4,
frac_double2,
frac_double3,
frac_double4,
}
greaterThan :: proc{
greaterThan_half,
greaterThan_float,
greaterThan_double,
greaterThan_int,
greaterThan_uint,
greaterThan_half2,
greaterThan_float2,
greaterThan_double2,
greaterThan_int2,
greaterThan_uint2,
greaterThan_half3,
greaterThan_float3,
greaterThan_double3,
greaterThan_int3,
greaterThan_uint3,
greaterThan_half4,
greaterThan_float4,
greaterThan_double4,
greaterThan_int4,
greaterThan_uint4,
}
greaterThanEqual :: proc{
greaterThanEqual_half,
greaterThanEqual_float,
greaterThanEqual_double,
greaterThanEqual_int,
greaterThanEqual_uint,
greaterThanEqual_half2,
greaterThanEqual_float2,
greaterThanEqual_double2,
greaterThanEqual_int2,
greaterThanEqual_uint2,
greaterThanEqual_half3,
greaterThanEqual_float3,
greaterThanEqual_double3,
greaterThanEqual_int3,
greaterThanEqual_uint3,
greaterThanEqual_half4,
greaterThanEqual_float4,
greaterThanEqual_double4,
greaterThanEqual_int4,
greaterThanEqual_uint4,
}
inverse :: proc{
inverse_half1x1,
inverse_half2x2,
inverse_half3x3,
inverse_half4x4,
inverse_float1x1,
inverse_float2x2,
inverse_float3x3,
inverse_float4x4,
inverse_double1x1,
inverse_double2x2,
inverse_double3x3,
inverse_double4x4,
inverse_matrix1x1,
inverse_matrix2x2,
inverse_matrix3x3,
inverse_matrix4x4,
}
isfinite :: proc{
isfinite_half,
isfinite_half2,
isfinite_half3,
isfinite_half4,
isfinite_float,
isfinite_float2,
isfinite_float3,
isfinite_float4,
isfinite_double,
isfinite_double2,
isfinite_double3,
isfinite_double4,
}
isfinite returns true if the number is neither positive-infinite, negative-infinite, nor Not-A-Number
isinf :: proc{
isinf_half,
isinf_half2,
isinf_half3,
isinf_half4,
isinf_float,
isinf_float2,
isinf_float3,
isinf_float4,
isinf_double,
isinf_double2,
isinf_double3,
isinf_double4,
}
isinf returns true if the number is either positive-infinite or negative-infinite
isnan :: proc{
isnan_half,
isnan_half2,
isnan_half3,
isnan_half4,
isnan_float,
isnan_float2,
isnan_float3,
isnan_float4,
isnan_double,
isnan_double2,
isnan_double3,
isnan_double4,
}
isnan returns true if the input value is the special case of Not-A-Number
length :: proc{
length_half,
length_float,
length_double,
length_half2,
length_half3,
length_half4,
length_float2,
length_float3,
length_float4,
length_double2,
length_double3,
length_double4,
}
lerp :: proc{
lerp_half,
lerp_float,
lerp_double,
lerp_half2,
lerp_half3,
lerp_half4,
lerp_float2,
lerp_float3,
lerp_float4,
lerp_double2,
lerp_double3,
lerp_double4,
}
lessThan :: proc{
lessThan_half,
lessThan_float,
lessThan_double,
lessThan_int,
lessThan_uint,
lessThan_half2,
lessThan_float2,
lessThan_double2,
lessThan_int2,
lessThan_uint2,
lessThan_half3,
lessThan_float3,
lessThan_double3,
lessThan_int3,
lessThan_uint3,
lessThan_half4,
lessThan_float4,
lessThan_double4,
lessThan_int4,
lessThan_uint4,
}
lessThanEqual :: proc{
lessThanEqual_half,
lessThanEqual_float,
lessThanEqual_double,
lessThanEqual_int,
lessThanEqual_uint,
lessThanEqual_half2,
lessThanEqual_float2,
lessThanEqual_double2,
lessThanEqual_int2,
lessThanEqual_uint2,
lessThanEqual_half3,
lessThanEqual_float3,
lessThanEqual_double3,
lessThanEqual_int3,
lessThanEqual_uint3,
lessThanEqual_half4,
lessThanEqual_float4,
lessThanEqual_double4,
lessThanEqual_int4,
lessThanEqual_uint4,
}
log :: proc{
log_half,
log_float,
log_double,
log_half2,
log_half3,
log_half4,
log_float2,
log_float3,
log_float4,
log_double2,
log_double3,
log_double4,
}
log10 :: proc{
log10_half,
log10_float,
log10_double,
log10_half2,
log10_half3,
log10_half4,
log10_float2,
log10_float3,
log10_float4,
log10_double2,
log10_double3,
log10_double4,
}
log2 :: proc{
log2_half,
log2_float,
log2_double,
log2_half2,
log2_half3,
log2_half4,
log2_float2,
log2_float3,
log2_float4,
log2_double2,
log2_double3,
log2_double4,
}
max :: proc{
max_int,
max_uint,
max_half,
max_float,
max_double,
max_half2,
max_half3,
max_half4,
max_float2,
max_float3,
max_float4,
max_double2,
max_double3,
max_double4,
max_int2,
max_int3,
max_int4,
max_uint2,
max_uint3,
max_uint4,
}
min :: proc{
min_half,
min_int,
min_uint,
min_float,
min_double,
min_half2,
min_half3,
min_half4,
min_float2,
min_float3,
min_float4,
min_double2,
min_double3,
min_double4,
min_int2,
min_int3,
min_int4,
min_uint2,
min_uint3,
min_uint4,
}
normalize :: proc{
normalize_half,
normalize_float,
normalize_double,
normalize_half2,
normalize_half3,
normalize_half4,
normalize_float2,
normalize_float3,
normalize_float4,
normalize_double2,
normalize_double3,
normalize_double4,
}
notEqual :: proc{
notEqual_half,
notEqual_float,
notEqual_double,
notEqual_int,
notEqual_uint,
notEqual_half2,
notEqual_float2,
notEqual_double2,
notEqual_int2,
notEqual_uint2,
notEqual_half3,
notEqual_float3,
notEqual_double3,
notEqual_int3,
notEqual_uint3,
notEqual_half4,
notEqual_float4,
notEqual_double4,
notEqual_int4,
notEqual_uint4,
}
pow :: proc{
pow_half,
pow_float,
pow_double,
pow_half2,
pow_half3,
pow_half4,
pow_float2,
pow_float3,
pow_float4,
pow_double2,
pow_double3,
pow_double4,
}
radians :: proc{
radians_half,
radians_float,
radians_double,
radians_half2,
radians_half3,
radians_half4,
radians_float2,
radians_float3,
radians_float4,
radians_double2,
radians_double3,
radians_double4,
}
rcp :: proc{
rcp_half,
rcp_float,
rcp_double,
rcp_half2,
rcp_half3,
rcp_half4,
rcp_float2,
rcp_float3,
rcp_float4,
rcp_double2,
rcp_double3,
rcp_double4,
}
reflect :: proc{
reflect_half,
reflect_float,
reflect_double,
reflect_half2,
reflect_half3,
reflect_half4,
reflect_float2,
reflect_float3,
reflect_float4,
reflect_double2,
reflect_double3,
reflect_double4,
}
refract :: proc{
refract_half,
refract_float,
refract_double,
refract_half2,
refract_half3,
refract_half4,
refract_float2,
refract_float3,
refract_float4,
refract_double2,
refract_double3,
refract_double4,
}
round :: proc{
round_half,
round_float,
round_double,
round_half2,
round_half3,
round_half4,
round_float2,
round_float3,
round_float4,
round_double2,
round_double3,
round_double4,
}
rsqrt :: proc{
rsqrt_half,
rsqrt_float,
rsqrt_double,
rsqrt_half2,
rsqrt_half3,
rsqrt_half4,
rsqrt_float2,
rsqrt_float3,
rsqrt_float4,
rsqrt_double2,
rsqrt_double3,
rsqrt_double4,
}
saturate :: proc{
saturate_int,
saturate_uint,
saturate_half,
saturate_float,
saturate_double,
saturate_half2,
saturate_half3,
saturate_half4,
saturate_float2,
saturate_float3,
saturate_float4,
saturate_double2,
saturate_double3,
saturate_double4,
saturate_int2,
saturate_int3,
saturate_int4,
saturate_uint2,
saturate_uint3,
saturate_uint4,
}
sign :: proc{
sign_half,
sign_int,
sign_uint,
sign_float,
sign_double,
sign_half2,
sign_half3,
sign_half4,
sign_float2,
sign_float3,
sign_float4,
sign_double2,
sign_double3,
sign_double4,
sign_int2,
sign_int3,
sign_int4,
sign_uint2,
sign_uint3,
sign_uint4,
}
sin :: proc{
sin_half,
sin_float,
sin_double,
sin_half2,
sin_half3,
sin_half4,
sin_float2,
sin_float3,
sin_float4,
sin_double2,
sin_double3,
sin_double4,
}
sinh :: proc{
sinh_half,
sinh_float,
sinh_double,
sinh_half2,
sinh_half3,
sinh_half4,
sinh_float2,
sinh_float3,
sinh_float4,
sinh_double2,
sinh_double3,
sinh_double4,
}
smoothstep :: proc{
smoothstep_half,
smoothstep_float,
smoothstep_double,
smoothstep_half2,
smoothstep_half3,
smoothstep_half4,
smoothstep_float2,
smoothstep_float3,
smoothstep_float4,
smoothstep_double2,
smoothstep_double3,
smoothstep_double4,
}
sqrt :: proc{
sqrt_half,
sqrt_float,
sqrt_double,
sqrt_half2,
sqrt_half3,
sqrt_half4,
sqrt_float2,
sqrt_float3,
sqrt_float4,
sqrt_double2,
sqrt_double3,
sqrt_double4,
}
step :: proc{
step_half,
step_float,
step_double,
step_half2,
step_half3,
step_half4,
step_float2,
step_float3,
step_float4,
step_double2,
step_double3,
step_double4,
}
tan :: proc{
tan_half,
tan_float,
tan_double,
tan_half2,
tan_half3,
tan_half4,
tan_float2,
tan_float3,
tan_float4,
tan_double2,
tan_double3,
tan_double4,
}
tanh :: proc{
tanh_half,
tanh_float,
tanh_double,
tanh_half2,
tanh_half3,
tanh_half4,
tanh_float2,
tanh_float3,
tanh_float4,
tanh_double2,
tanh_double3,
tanh_double4,
}
Source Files
Generated with odin version dev-2026-11 (vendor "odin") Windows_amd64 @ 2026-11-18 21:05:19.828955300 +0000 UTC