api/rs_core_math.spec

#
# Copyright (C) 2014 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

header:
summary: Mathematical functions
description:
 Most mathematical functions can be applied to scalars and vectors.
 When applied to vectors, a vector of the function applied to each entry
 of the input is returned.

 For example:<br/>
 <code>
 float3 a, b;<br/>
 // The following call sets<br/>
 //   a.x to sin(b.x),<br/>
 //   a.y to sin(b.y), and<br/>
 //   a.z to sin(b.z).<br/>
 a = sin(b);<br/>
 </code>

 A few functions like @distance() and @length() interpret instead the input
 as a single vector in n-dimensional space.

 The precision of the mathematical operations is affected by the pragmas
# TODO Create an anchor for the section of http://developer.android.com/guide/topics/renderscript/compute.html that details rs_fp_* and link them here.
 rs_fp_relaxed and rs_fp_full.

 Different precision/speed tradeoffs can be achieved by using three variants
 of common math functions.  Functions with a name starting with<ul>
 <li>native_ may have custom hardware implementations with weaker precision,</li>
 <li>half_ may perform internal computations using 16 bit floats, and</li>
 <li>fast_ are n-dimensional space computations that may use 16 bit floats.
 </ul>
end:

function: abs
version: 9
attrib: const
w: 1, 2, 3, 4
t: i8, i16, i32
ret: u#2#1
arg: #2#1 v
summary: Absolute value of an integer
description:
 Returns the absolute value of an integer.

 For floats, use @fabs().
end:

function: acos
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Inverse cosine
description:
 Returns the inverse cosine, in radians.

 See also @native_acos().
end:

function: acosh
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Inverse hyperbolic cosine
description:
 Returns the inverse hyperbolic cosine, in radians.

 See also @native_acosh().
end:

function: acospi
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Inverse cosine divided by pi
description:
 Returns the inverse cosine in radians, divided by pi.

 To get an inverse cosine measured in degrees, use <code>acospi(a) * 180.f</code>.

 See also @native_acospi().
end:

function: asin
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Inverse sine
description:
 Returns the inverse sine, in radians.

 See also @native_asin().
end:

function: asinh
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Inverse hyperbolic sine
description:
 Returns the inverse hyperbolic sine, in radians.

 See also @native_asinh().
end:

function: asinpi
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Inverse sine divided by pi
description:
 Returns the inverse sine in radians, divided by pi.

 To get an inverse sine measured in degrees, use <code>asinpi(a) * 180.f</code>.

 See also @native_asinpi().
end:

function: atan
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Inverse tangent
description:
 Returns the inverse tangent, in radians.

 See also @native_atan().
end:

function: atan2
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 numerator, "The numerator"
arg: #2#1 denominator, "The denominator.  Can be 0."
summary: Inverse tangent of a ratio
description:
 Returns the inverse tangent of <code>(numerator / denominator)</code>, in radians.

 See also @native_atan2().
end:

function: atan2pi
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 numerator, "The numerator"
arg: #2#1 denominator, "The denominator.  Can be 0."
summary: Inverse tangent of a ratio, divided by pi
description:
 Returns the inverse tangent of <code>(numerator / denominator)</code>, in radians, divided by pi.

 To get an inverse tangent measured in degrees, use <code>atan2pi(n, d) * 180.f</code>.

 See also @native_atan2pi().
end:

function: atanh
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Inverse hyperbolic tangent
description:
 Returns the inverse hyperbolic tangent, in radians.

 See also @native_atanh().
end:

function: atanpi
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Inverse tangent divided by pi
description:
 Returns the inverse tangent in radians, divided by pi.

 To get an inverse tangent measured in degrees, use <code>atanpi(a) * 180.f</code>.

 See also @native_atanpi().
end:

function: cbrt
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Cube root
description:
 Returns the cube root.

 See also @native_cbrt().
end:

function: ceil
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Smallest integer not less than a value
description:
 Returns the smallest integer not less than a value.

 For example, <code>ceil(1.2f)</code> returns 2.f, and <code>ceil(-1.2f)</code> returns -1.f.

 See also @floor().
end:

function: clamp
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 value, "Value to be clamped."
arg: #2#1 min_value, "Lower bound, a scalar or matching vector."
arg: #2#1 max_value, above(min_value), "High bound, must match the type of low."
summary: Restrain a value to a range
description:
 Clamps a value to a specified high and low bound.  clamp() returns min_value
 if value &lt; min_value, max_value if value &gt; max_value, otherwise value.

 There are two variants of clamp: one where the min and max are scalars applied
 to all entries of the value, the other where the min and max are also vectors.

 If min_value is greater than max_value, the results are undefined.
end:

function: clamp
version: 9
attrib: const
w: 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 value
arg: #2 min_value
arg: #2 max_value, above(min_value)
end:

function: clamp
version: 19
attrib: const
w: 1, 2, 3, 4
t: u8, u16, u32, u64, i8, i16, i32, i64
ret: #2#1
arg: #2#1 value
arg: #2#1 min_value
arg: #2#1 max_value, above(min_value)
end:

function: clamp
version: 19
attrib: const
w: 2, 3, 4
t: u8, u16, u32, u64, i8, i16, i32, i64
ret: #2#1
arg: #2#1 value
arg: #2 min_value
arg: #2 max_value, above(min_value)
end:

function: clz
version: 9
attrib: const
w: 1, 2, 3, 4
t: u8, u16, u32, i8, i16, i32
ret: #2#1
arg: #2#1 value
summary: Number of leading 0 bits
description:
 Returns the number of leading 0-bits in a value.

 For example, <code>clz((char)0x03)</code> returns 6.
end:

function: convert_#3#1
version: 9
attrib: const
w: 2, 3, 4
t: u8, u16, u32, i8, i16, i32, f32
t: u8, u16, u32, i8, i16, i32, f32
ret: #3#1
arg: #2#1 v, compatible(#3)
summary: Converts numerical vectors
description:
 Component wise conversion from a numerical type to another.

 Conversions of floating point values to integer will truncate.

 Conversions of numbers too large to fit the destination type yield undefined results.
 For example, converting a float that contains 1.0e18 to a short is undefined.
 Use @clamp() to avoid this.
end:

function: convert_#3#1
version: 21
attrib: const
w: 2, 3, 4
t: u64, i64, f64
t: u64, i64, f64
ret: #3#1
arg: #2#1 v, compatible(#3)
end:

function: convert_#3#1
version: 21
attrib: const
w: 2, 3, 4
t: u64, i64, f64
t: u8, u16, u32, i8, i16, i32, f32
ret: #3#1
arg: #2#1 v, compatible(#3)
end:

function: convert_#3#1
version: 21
attrib: const
w: 2, 3, 4
t: u8, u16, u32, i8, i16, i32, f32
t: u64, i64, f64
ret: #3#1
arg: #2#1 v, compatible(#3)
end:

function: copysign
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 magnitude_value
arg: #2#1 sign_value
summary: Copies the sign of a number to another
description:
 Copies the sign from sign_value to magnitude_value.

 The value returned is either magnitude_value or -magnitude_value.

 For example, <code>copysign(4.0f, -2.7f)</code> returns -4.0f and <code>copysign(-4.0f, 2.7f)</code> returns 4.0f.
end:

function: cos
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Cosine
description:
 Returns the cosine of an angle measured in radians.

 See also @native_cos().
end:

function: cosh
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Hypebolic cosine
description:
 Returns the hypebolic cosine of v, where v is measured in radians.

 See also @native_cosh().
end:

function: cospi
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Cosine of a number multiplied by pi
description:
 Returns the cosine of <code>(v * pi)</code>, where <code>(v * pi)</code> is measured in radians.

 To get the cosine of a value measured in degrees, call <code>cospi(v / 180.f)</code>.

 See also @native_cospi().
end:

function: cross
version: 9
attrib: const
w: 3, 4
t: f32
ret: #2#1
arg: #2#1 left_vector
arg: #2#1 right_vector
summary: Cross product of two vectors
description:
 Computes the cross product of two vectors.
test: vector
end:

function: degrees
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Converts radians into degrees
description:
 Converts from radians to degrees.
end:

function: distance
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2
arg: #2#1 left_vector
arg: #2#1 right_vector
summary: Distance between two points
description:
 Compute the distance between two points.

 See also @fast_distance(), @native_distance().
test: vector
end:

function: dot
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2
arg: #2#1 left_vector
arg: #2#1 right_vector
summary: Dot product of two vectors
description:
 Computes the dot product of two vectors.
test: vector
end:

function: erf
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Mathematical error function
description:
 Returns the error function.
end:

function: erfc
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Mathematical complementary error function
description:
 Returns the complementary error function.
end:

function: exp
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: e raised to a number
description:
 Returns e raised to v, i.e. e ^ v.

 See also @native_exp().
end:

function: exp10
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: 10 raised to a number
description:
 Returns 10 raised to v, i.e. 10.f ^ v.

 See also @native_exp10().
end:

function: exp2
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: 2 raised to a number
description:
 Returns 2 raised to v, i.e. 2.f ^ v.

 See also @native_exp2().
end:

function: expm1
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: e raised to a number minus one
description:
 Returns e raised to v minus 1, i.e. (e ^ v) - 1.

 See also @native_expm1().
end:

function: fabs
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Absolute value of a float
description:
 Returns the absolute value of the float v.

 For integers, use @abs().
end:

function: fast_distance
version: 17
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2
arg: #2#1 left_vector
arg: #2#1 right_vector
summary: Approximate distance between two points
description:
 Computes the approximate distance between two points.

 The precision is what would be expected from doing the computation using 16 bit floating point values.

 See also @distance(), @native_distance().
test: vector
end:

function: fast_length
version: 17
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2
arg: #2#1 v
summary: Approximate length of a vector
description:
 Computes the approximate length of a vector.

 The precision is what would be expected from doing the computation using 16 bit floating point values.

 See also @length(), @native_length().
test: vector
end:

function: fast_normalize
version: 17
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate normalized vector
description:
 Approximately normalizes a vector.

 For vectors of size 1, returns -1.f for negative values, 0.f for null values, and 1.f for positive values.

 The precision is what would be expected from doing the computation using 16 bit floating point values.

 See also @normalize(), @native_normalize().
test: vector
end:

function: fdim
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
summary: Positive difference between two values
description:
 Returns the positive difference between two values.

 If a &gt; b, returns (a - b) otherwise returns 0f.
end:

function: floor
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Smallest integer not greater than a value
description:
 Returns the smallest integer not greater than a value.

 For example, <code>floor(1.2f)</code> returns 1.f, and <code>floor(-1.2f)</code> returns -2.f.

 See also @ceil().
end:

function: fma
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 multiplicand1
arg: #2#1 multiplicand2
arg: #2#1 offset
summary: Multiply and add
description:
 Multiply and add.  Returns <code>(multiplicand1 * multiplicand2) + offset</code>.

 This function is similar to @mad().  fma() retains full precision of the
 multiplied result and rounds only after the addition.  @mad() rounds after the
 multiplication and the addition.  This extra precision is not guaranteed in
 rs_fp_relaxed mode.
end:

function: fmax
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
summary: Maximum of two floats
description:
 Returns the maximum of a and b, i.e. <code>(a &lt; b ? b : a)</code>.

 The @max() function returns identical results but can be applied to more data types.
end:

function: fmax
version: 9
attrib: const
w: 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2 b
end:

function: fmin
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
summary: Minimum of two floats
description:
 Returns the minimum of a and b, i.e. <code>(a &gt; b ? b : a)</code>.

 The @min() function returns identical results but can be applied to more data types.
end:

function: fmin
version: 9
attrib: const
w: 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2 b
end:

function: fmod
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 numerator
arg: #2#1 denominator
summary: Modulo
description:
 Returns the remainder of (numerator / denominator), where the quotient is rounded towards zero.

 The function @remainder() is similar but rounds toward the closest interger.
 For example, <code>fmod(-3.8f, 2.f)</code> returns -1.8f (-3.8f - -1.f * 2.f)
 while <code>@remainder(-3.8f, 2.f)</code> returns 0.2f (-3.8f - -2.f * 2.f).
end:

function: fract
version: 9
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, "Input value."
arg: #2#1* floor, "If floor is not null, *floor will be set to the floor of v."
summary: Positive fractional part
description:
 Returns the positive fractional part of v, i.e. <code>v - floor(v)</code>.

 For example, <code>fract(1.3f, &val)</code> returns 0.3f and sets val to 1.f.
 <code>fract(-1.3f, &val)</code> returns 0.7f and sets val to -2.f.
end:

function: fract
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
inline:
 #2#1 unused;
 return fract(v, &unused);
end:

function: frexp
version: 9
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, "Input value."
arg: int#1* exponent, "If exponent is not null, *exponent will be set to the exponent of v."
summary: Binary mantissa and exponent
description:
 Returns the binary mantissa and exponent of v, i.e. <code>v == mantissa * 2 ^ exponent</code>.

 The mantissa is always between 0.5 (inclusive) and 1.0 (exclusive).

 See @ldexp() for the reverse operation.  See also @logb() and @ilogb().
end:

function: half_recip
version: 17
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Reciprocal computed to 16 bit precision
description:
 Returns the approximate reciprocal of a value.

 The precision is that of a 16 bit floating point value.

 See also @native_recip().
end:

function: half_rsqrt
version: 17
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Reciprocal of a square root computed to 16 bit precision
description:
 Returns the approximate value of <code>(1.f / sqrt(value))</code>.

 The precision is that of a 16 bit floating point value.

 See also @rsqrt(), @native_rsqrt().
end:

function: half_sqrt
version: 17
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Square root computed to 16 bit precision
description:
 Returns the approximate square root of a value.

 The precision is that of a 16 bit floating point value.

 See also @sqrt(), @native_sqrt().
end:

function: hypot
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
summary: Hypotenuse
description:
 Returns the hypotenuse, i.e. <code>sqrt(a * a + b * b)</code>.

 See also @native_hypot().
end:

function: ilogb
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: int#1
arg: float#1 v
summary: Base two exponent
description:
 Returns the base two exponent of a value, where the mantissa is between
 1.f (inclusive) and 2.f (exclusive).

 For example, <code>ilogb(8.5f)</code> returns 3.

 Because of the difference in mantissa, this number is one less than
 is returned by @frexp().

 @logb() is similar but returns a float.
test: custom
end:

function: ldexp
version: 9
attrib: const
w: 1, 2, 3, 4
ret: float#1
arg: float#1 mantissa, "The mantissa"
arg: int#1 exponent, "The exponent, a single component or matching vector."
summary: Creates a floating point from mantissa and exponent
description:
 Returns the floating point created from the mantissa and exponent,
 i.e. (mantissa * 2 ^ exponent).

 See @frexp() for the reverse operation.
end:

function: ldexp
version: 9
attrib: const
w: 2, 3, 4
ret: float#1
arg: float#1 mantissa
arg: int exponent
end:

function: length
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2
arg: #2#1 v
summary: Length of a vector
description:
 Computes the length of a vector.

 See also @fast_length(), @native_length().
test: vector
end:

function: lgamma
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Natural logarithm of the gamma function
description:
 Returns the natural logarithm of the absolute value of the gamma function,
 i.e. <code>@log(@fabs(@tgamma(v)))</code>.

 See also @tgamma().
end:

function: lgamma
version: 9
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
arg: int#1* sign_of_gamma, "If sign_of_gamma is not null, *sign_of_gamma will be set to -1.f if the gamma of v is negative, otherwise to 1.f."
test: custom
#TODO Temporary until bionic & associated drivers are fixed
end:

function: log
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Natural logarithm
description:
 Returns the natural logarithm.

 See also @native_log().
end:

function: log10
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Base 10 logarithm
description:
 Returns the base 10 logarithm.

 See also @native_log10().
end:

function: log1p
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Natural logarithm of a value plus 1
description:
 Returns the natural logarithm of <code>(v + 1.f)</code>.

 See also @native_log1p().
end:

function: log2
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Base 2 logarithm
description:
 Returns the base 2 logarithm.

 See also @native_log2().
end:

function: logb
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Base two exponent
description:
 Returns the base two exponent of a value, where the mantissa is between
 1.f (inclusive) and 2.f (exclusive).

 For example, <code>logb(8.5f)</code> returns 3.f.

 Because of the difference in mantissa, this number is one less than
 is returned by frexp().

 @ilogb() is similar but returns an integer.
end:

function: mad
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 multiplicand1
arg: #2#1 multiplicand2
arg: #2#1 offset
summary: Multiply and add
description:
 Multiply and add.  Returns <code>(multiplicand1 * multiplicand2) + offset</code>.

 This function is similar to @fma().  @fma() retains full precision of the
 multiplied result and rounds only after the addition.  mad() rounds after the
 multiplication and the addition.  In rs_fp_relaxed mode, mad() may not do the
 rounding after multiplicaiton.
end:

function: max
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
summary: Maximum
description:
 Returns the maximum value of two arguments.
end:

function: max
version: 9 20
attrib: const
w: 1
t: i8, i16, i32, u8, u16, u32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
inline:
 return (a > b ? a : b);
end:

function: max
version: 9 20
attrib: const
w: 2
t: i8, i16, i32, u8, u16, u32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
inline:
 #2#1 tmp;
 tmp.x = (a.x > b.x ? a.x : b.x);
 tmp.y = (a.y > b.y ? a.y : b.y);
 return tmp;
end:

function: max
version: 9 20
attrib: const
w: 3
t: i8, i16, i32, u8, u16, u32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
inline:
 #2#1 tmp;
 tmp.x = (a.x > b.x ? a.x : b.x);
 tmp.y = (a.y > b.y ? a.y : b.y);
 tmp.z = (a.z > b.z ? a.z : b.z);
 return tmp;
end:

function: max
version: 9 20
attrib: const
w: 4
t: i8, i16, i32, u8, u16, u32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
inline:
 #2#1 tmp;
 tmp.x = (a.x > b.x ? a.x : b.x);
 tmp.y = (a.y > b.y ? a.y : b.y);
 tmp.z = (a.z > b.z ? a.z : b.z);
 tmp.w = (a.w > b.w ? a.w : b.w);
 return tmp;
end:

function: max
version: 21
attrib: const
w: 1, 2, 3, 4
t: i8, i16, i32, i64, u8, u16, u32, u64
ret: #2#1
arg: #2#1 a
arg: #2#1 b
end:

function: min
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
summary: Minimum
description:
 Returns the minimum value of two arguments.
end:

function: min
version: 9 20
attrib: const
w: 1
t: i8, i16, i32, u8, u16, u32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
inline:
 return (a < b ? a : b);
end:

function: min
version: 9 20
attrib: const
w: 2
t: i8, i16, i32, u8, u16, u32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
inline:
 #2#1 tmp;
 tmp.x = (a.x < b.x ? a.x : b.x);
 tmp.y = (a.y < b.y ? a.y : b.y);
 return tmp;
end:

function: min
version: 9 20
attrib: const
w: 3
t: i8, i16, i32, u8, u16, u32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
inline:
 #2#1 tmp;
 tmp.x = (a.x < b.x ? a.x : b.x);
 tmp.y = (a.y < b.y ? a.y : b.y);
 tmp.z = (a.z < b.z ? a.z : b.z);
 return tmp;
end:

function: min
version: 9 20
attrib: const
w: 4
t: i8, i16, i32, u8, u16, u32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
inline:
 #2#1 tmp;
 tmp.x = (a.x < b.x ? a.x : b.x);
 tmp.y = (a.y < b.y ? a.y : b.y);
 tmp.z = (a.z < b.z ? a.z : b.z);
 tmp.w = (a.w < b.w ? a.w : b.w);
 return tmp;
end:

function: min
version: 21
attrib: const
w: 1, 2, 3, 4
t: i8, i16, i32, i64, u8, u16, u32, u64
ret: #2#1
arg: #2#1 a
arg: #2#1 b
end:

function: mix
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 start
arg: #2#1 stop
arg: #2#1 fraction
summary: Mixes two values
description:
 Returns start + ((stop - start) * fraction).

 This can be useful for mixing two values.  For example, to create a new color that is 40% color1 and 60% color2, use <code>mix(color1, color2, 0.6f)</code>.
end:

function: mix
version: 9
attrib: const
w: 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 start
arg: #2#1 stop
arg: #2 fraction
end:

function: modf
version: 9
w: 1, 2, 3, 4
t: f32
ret: #2#1, "The floating point portion of the value."
arg: #2#1 v, "Source value"
arg: #2#1* integral_part, "*integral_part will be set to the integral portion of the number."
summary: Integral and fractional components
description:
 Returns the integral and fractional components of a number.

 Both components will have the same sign as x.  For example, for an input of -3.72f, iret will be set to -3.f and .72f will be returned.
end:

function: nan
version: 9
attrib: const
w: 1
t: f32
ret: #2#1
arg: uint#1 v, "Not used."
#TODO We're not using the argument.  Once we do, add this documentation line:
# The argument is embedded into the return value and can be used to distinguish various NaNs.
summary: Not a Number
description:
 Returns a NaN value (Not a Number).
end:

function: native_acos
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Approximate inverse cosine
description:
 Returns the approximate inverse cosine, in radians.

 This function yields undefined results from input values less than -1 or greater
 than 1.

 See also @acos().
# TODO Temporary
test: limited(0.0005)
end:

function: native_acosh
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate inverse hyperbolic cosine
description:
 Returns the approximate inverse hyperbolic cosine, in radians.

 See also @acosh().
# TODO Temporary
test: limited(0.0005)
end:

function: native_acospi
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Approximate inverse cosine divided by pi
description:
 Returns the approximate inverse cosine in radians, divided by pi.

 To get an inverse cosine measured in degrees, use <code>acospi(a) * 180.f</code>.

 This function yields undefined results from input values less than -1 or greater
 than 1.

 See also @acospi().
# TODO Temporary
test: limited(0.0005)
end:

function: native_asin
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Approximate inverse sine
description:
 Returns the approximate inverse sine, in radians.

 This function yields undefined results from input values less than -1 or greater
 than 1.

 See also @asin().
# TODO Temporary
test: limited(0.0005)
end:

function: native_asinh
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate inverse hyperbolic sine
description:
 Returns the approximate inverse hyperbolic sine, in radians.

 See also @asinh().
# TODO Temporary
test: limited(0.0005)
end:

function: native_asinpi
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Approximate inverse sine divided by pi
description:
 Returns the approximate inverse sine in radians, divided by pi.

 To get an inverse sine measured in degrees, use <code>asinpi(a) * 180.f</code>.

 This function yields undefined results from input values less than -1 or greater
 than 1.

 See also @asinpi().
# TODO Temporary
test: limited(0.0005)
end:

function: native_atan
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Approximate inverse tangent
description:
 Returns the approximate inverse tangent, in radians.

 See also @atan().
# TODO Temporary
test: limited(0.0005)
end:

function: native_atan2
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 numerator, "The numerator"
arg: #2#1 denominator, "The denominator.  Can be 0."
summary: Approximate inverse tangent of a ratio
description:
 Returns the approximate inverse tangent of <code>(numerator / denominator)</code>, in radians.

 See also @atan2().
# TODO Temporary
test: limited(0.0005)
end:

function: native_atan2pi
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 numerator, "The numerator"
arg: #2#1 denominator, "The denominator.  Can be 0."
summary: Approximate inverse tangent of a ratio, divided by pi
description:
 Returns the approximate inverse tangent of <code>(numerator / denominator)</code>, in radians, divided by pi.

 To get an inverse tangent measured in degrees, use <code>atan2pi(n, d) * 180.f</code>.

 See also @atan2pi().
# TODO Temporary
test: limited(0.0005)
end:

function: native_atanh
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Approximate inverse hyperbolic tangent
description:
 Returns the approximate inverse hyperbolic tangent, in radians.

 See also @atanh().
# TODO Temporary
test: limited(0.0005)
end:

function: native_atanpi
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-1,1)
summary: Approximate inverse tangent divided by pi
description:
 Returns the approximate inverse tangent in radians, divided by pi.

 To get an inverse tangent measured in degrees, use <code>atanpi(a) * 180.f</code>.

 See also @atanpi().
# TODO Temporary
test: limited(0.0005)
end:

function: native_cbrt
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate cube root
description:
 Returns the approximate cubic root.

 See also @cbrt().
end:

function: native_cos
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate cosine
description:
 Returns the approximate cosine of an angle measured in radians.

 See also @cos().
end:

function: native_cosh
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate hypebolic cosine
description:
 Returns the approximate hypebolic cosine.

 See also @cosh().
end:

function: native_cospi
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate cosine of a number multiplied by pi
description:
 Returns the approximate cosine of (v * pi), where (v * pi) is measured in radians.

 To get the cosine of a value measured in degrees, call <code>cospi(v / 180.f)</code>.

 See also @cospi().
end:

function: native_distance
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2
arg: #2#1 left_vector
arg: #2#1 right_vector
summary: Approximate distance between two points
description:
 Computes the approximate distance between two points.

 See also @distance(), @fast_distance().
test: vector
end:

function: native_divide
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 left_vector
arg: #2#1 right_vector
summary: Approximate division
description:
 Computes the approximate division of two values.
end:

function: native_exp
version: 18
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-86,86)
summary: Approximate e raised to a number
description:
 Fast approximate exp.

 It is valid for inputs from -86.f to 86.f.  The precision is no worse than what would be expected from using 16 bit floating point values.

 See also @exp().
test: limited
end:

function: native_exp10
version: 18
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-37,37)
summary: Approximate 10 raised to a number
description:
 Fast approximate exp10.

 It is valid for inputs from -37.f to 37.f.  The precision is no worse than what would be expected from using 16 bit floating point values.

 See also @exp10().
test: limited
end:

function: native_exp2
version: 18
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(-125,125)
summary: Approximate 2 raised to a number
description:
 Fast approximate exp2.

 It is valid for inputs from -125.f to 125.f.  The precision is no worse than what would be expected from using 16 bit floating point values.

 See also @exp2().
test: limited
end:

function: native_expm1
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate e raised to a number minus one
description:
 Returns the approximate (e ^ v) - 1.

 See also @expm1().
end:

function: native_hypot
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 a
arg: #2#1 b
summary: Approximate hypotenuse
description:
 Returns the approximate native_sqrt(a * a + b * b)

 See also @hypot().
end:

function: native_length
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2
arg: #2#1 v
summary: Approximate length of a vector
description:
 Compute the approximate length of a vector.

 See also @length(), @fast_length().
test: vector
end:

function: native_log
version: 18
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(10e-10,10e10)
summary: Approximate natural logarithm
description:
 Fast approximate log.

 It is not accurate for values very close to zero.

 See also @log().
test: limited
end:

function: native_log10
version: 18
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(10e-10,10e10)
summary: Approximate base 10 logarithm
description:
 Fast approximate log10.

 It is not accurate for values very close to zero.

 See also @log10().
test: limited
end:

function: native_log1p
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate natural logarithm of a value plus 1
description:
 Returns the approximate natural logarithm of (v + 1.0f)

 See also @log1p().
end:

function: native_log2
version: 18
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v, range(10e-10,10e10)
summary: Approximate base 2 logarithm
description:
 Fast approximate log2.

 It is not accurate for values very close to zero.

 See also @log2().
test: limited
end:

function: native_normalize
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary:  Approximately normalize a vector
description:
 Approximately normalizes a vector.

 See also @normalize(), @fast_normalize().
test: vector
end:

function: native_powr
version: 18
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 base, range(0,256), "Must be between 0.f and 256.f.  The function is not accurate for values very close to zero."
arg: #2#1 exponent, range(-15,15), "Must be between -15.f and 15.f."
summary: Approximate positive base raised to an exponent
description:
 Fast approximate (base ^ exponent).

 See also @powr().
test: limited
end:

function: native_recip
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate reciprocal
description:
 Returns the approximate approximate reciprocal of a value.

 See also @half_recip().
end:

function: native_rootn
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
arg: int#1 n
summary: Approximate nth root
description:
 Compute the approximate Nth root of a value.

 See also @rootn().
end:

function: native_rsqrt
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate reciprocal of a square root
description:
 Returns approximate (1 / sqrt(v)).

 See also @rsqrt(), @half_rsqrt().
end:

function: native_sin
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate sine
description:
 Returns the approximate sine of an angle measured in radians.

 See also @sin().
end:

function: native_sincos
version: 21
w: 1, 2, 3, 4
t: f32
ret: #2#1, "sine"
arg: #2#1 v, "The incoming value in radians."
arg: #2#1* cos, "*cos will be set to the cosine value."
summary: Approximate sine and cosine
description:
 Returns the approximate sine and cosine of a value.

 See also @sincos().
# TODO Temporary
test: limited(0.0005)
end:

function: native_sinh
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate hyperbolic sine
description:
 Returns the approximate hyperbolic sine of a value specified in radians.

 See also @sinh().
end:

function: native_sinpi
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate sine of a number multiplied by pi
description:
 Returns the approximate sine of (v * pi), where (v * pi) is measured in radians.

 To get the sine of a value measured in degrees, call <code>sinpi(v / 180.f)</code>.

 See also @sinpi().
end:

function: native_sqrt
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate square root
description:
 Returns the approximate sqrt(v).

 See also @sqrt(), @half_sqrt().
end:

function: native_tan
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate tangent
description:
 Returns the approximate tangent of an angle measured in radians.
end:

function: native_tanh
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate hyperbolic tangent
description:
 Returns the approximate hyperbolic tangent of a value.

 See also @tanh().
end:

function: native_tanpi
version: 21
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Approximate tangent of a number multiplied by pi
description:
 Returns the approximate tangent of (v * pi), where (v * pi) is measured in radians.

 To get the tangent of a value measured in degrees, call <code>tanpi(v / 180.f)</code>.

 See also @tanpi().
end:

function: nextafter
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
arg: #2#1 target
summary: Next floating point number
description:
 Returns the next representable floating point number from v towards target.

 In rs_fp_relaxed mode, a denormalized input value may not yield the next
 denormalized  value, as support of denormalized values is optional in
 relaxed mode.
end:

function: normalize
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Normalize a vector
description:
 Normalize a vector.

 For vectors of size 1, returns -1.f for negative values, 0.f for null values, and 1.f for positive values.

 See also @fast_normalize(), @native_normalize().
test: vector
end:

function: pow
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 base
arg: #2#1 exponent
summary: Base raised to an exponent
description:
 Returns base raised to the power exponent, i.e. base ^ exponent.

 @pown() and @powr() are similar.  @pown() takes an integer exponent. @powr() assumes the base to be non-negative.
end:

function: pown
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 base
arg: int#1 exponent
summary: Base raised to an integer exponent
description:
 Returns base raised to the power exponent, i.e. base ^ exponent.

 @pow() and @powr() are similar.  The both take a float exponent. @powr() also assumes the base to be non-negative.
end:

function: powr
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 base, range(0,3000)
arg: #2#1 exponent
summary: Positive base raised to an exponent
description:
 Returns base raised to the power exponent, i.e. base ^ exponent.  base must be &gt;= 0.

 @pow() and @pown() are similar.  They both make no assumptions about the base.  @pow() takes a float exponent while @pown() take an integer.

 See also @native_powr().
end:

function: radians
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Converts degrees into radians
description:
 Converts from degrees to radians.
end:

function: remainder
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 numerator
arg: #2#1 denominator
summary: Remainder of a division
description:
 Returns the remainder of (numerator / denominator), where the quotient is rounded towards the nearest integer.

 The function @fmod() is similar but rounds toward the closest interger.
 For example, <code>@fmod(-3.8f, 2.f)</code> returns -1.8f (-3.8f - -1.f * 2.f)
 while <code>remainder(-3.8f, 2.f)</code> returns 0.2f (-3.8f - -2.f * 2.f).
end:

function: remquo
version: 9
w: 1, 2, 3, 4
t: f32
ret: #2#1, "The remainder, precise only for the low three bits."
arg: #2#1 numerator, "The numerator."
arg: #2#1 denominator, "The denominator."
arg: int#1* quotient, "*quotient will be set to the integer quotient."
summary: Remainder and quotient of a division
description:
 Returns the quotient and the remainder of (numerator / denominator).

 Only the sign and lowest three bits of the quotient are guaranteed to be accurate.

 This function is useful for implementing periodic functions.  The low three bits of the quotient gives the quadrant and the remainder the distance within the quadrant.  For example, an implementation of @sin(x) could call <code>remquo(x, PI / 2.f, &quadrant)</code> to reduce very large value of x to something within a limited range.

 Example: <code>remquo(-23.5f, 8.f, &quot)</code> sets the lowest three bits of quot to 3 and the sign negative.  It returns 0.5f.
test: custom
end:

function: rint
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Round to even
description:
 Rounds to the nearest integral value.

 rint() rounds half values to even.  For example, <code>rint(0.5f)</code> returns 0.f and <code>rint(1.5f)</code> returns 2.f.  Similarly, <code>rint(-0.5f)</code> returns -0.f and <code>rint(-1.5f)</code> returns -2.f.

 @round() is similar but rounds away from zero.  @trunc() truncates the decimal fraction.
end:

function: rootn
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
arg: int#1 n
summary: Nth root
description:
 Compute the Nth root of a value.

 See also @native_rootn().
end:

function: round
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Round away from zero
description:
 Round to the nearest integral value.

 round() rounds half values away from zero.  For example, <code>round(0.5f)</code> returns 1.f and <code>round(1.5f)</code> returns 2.f.  Similarly, <code>round(-0.5f)</code> returns -1.f and <code>round(-1.5f)</code> returns -2.f.

 @rint() is similar but rounds half values toward even.  @trunc() truncates the decimal fraction.
end:

function: rsqrt
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Reciprocal of a square root
description:
 Returns (1 / sqrt(v)).

 See also @half_rsqrt(), @native_rsqrt().
end:

function: sign
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Sign of a value
description:
 Returns the sign of a value.

 if (v &lt; 0) return -1.f;
 else if (v &gt; 0) return 1.f;
 else return 0.f;
end:

function: sin
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Sine
description:
 Returns the sine of an angle measured in radians.

 See also @native_sin().
end:

function: sincos
version: 9
w: 1, 2, 3, 4
t: f32
ret: #2#1, "sine of v"
arg: #2#1 v, "The incoming value in radians"
arg: #2#1* cos, "*cos will be set to the cosine value."
summary: Sine and cosine
description:
 Returns the sine and cosine of a value.

 See also @native_sincos().
end:

function: sinh
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Hyperbolic sine
description:
 Returns the hyperbolic sine of v, where v is measured in radians.

 See also @native_sinh().
end:

function: sinpi
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Sine of a number multiplied by pi
description:
 Returns the sine of (v * pi), where (v * pi) is measured in radians.

 To get the sine of a value measured in degrees, call <code>sinpi(v / 180.f)</code>.

 See also @native_sinpi().
end:

function: sqrt
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Square root
description:
 Returns the square root of a value.

 See also @half_sqrt(), @native_sqrt().
end:

function: step
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 edge
arg: #2#1 v
summary: 0 if less than a value, 0 otherwise
description:
 Returns 0.f if v &lt; edge, 1.f otherwise.

 This can be useful to create conditional computations without using loops and branching instructions.  For example, instead of computing <code>(a[i] &lt; b[i]) ? 0.f : @atan2(a[i], b[i])</code> for the corresponding elements of a vector, you could instead use <code>step(a, b) * @atan2(a, b)</code>.
end:

function: step
version: 9
attrib: const
w: 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 edge
arg: #2 v
end:

function: step
version: 21
attrib: const
w: 2, 3, 4
t: f32
ret: #2#1
arg: #2 edge
arg: #2#1 v
end:

function: tan
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Tangent
description:
 Returns the tangent of an angle measured in radians.

 See also @native_tan().
end:

function: tanh
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Hyperbolic tangent
description:
 Returns the hyperbolic tangent of a value.

 See also @native_tanh().
end:

function: tanpi
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Tangent of a number multiplied by pi
description:
 Returns the tangent of (v * pi), where (v * pi) is measured in radians.

 To get the tangent of a value measured in degrees, call <code>tanpi(v / 180.f)</code>.

 See also @native_tanpi().
end:

function: tgamma
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Gamma function
description:
 Returns the gamma function of a value.

 See also @lgamma().
end:

function: trunc
version: 9
attrib: const
w: 1, 2, 3, 4
t: f32
ret: #2#1
arg: #2#1 v
summary: Truncates a floating point
description:
 Rounds to integral using truncation.

 For example, <code>trunc(1.7f)</code> returns 1.f and <code>trunc(-1.7f)</code> returns -1.f.

 See @rint() and @round() for other rounding options.
end: