/**
<div style="width:800px;text-align:justify;">

@page axfunctionlist AX Supported Functions

This page holds the full list of functions currently supported by AX. It is
usually automatically updated from the most recent output of the @ref vdbaxbinary
"vdb_ax binary's" function option.

@section axfunccontents Functions
<ul style="height: 500px; display:flex; flex-direction:column; flex-wrap:wrap;">
    <li> @ref axabs "abs"</li>
    <li> @ref axacos "acos"</li>
    <li> @ref axacosh "acosh"</li>
    <li> @ref axaddtogroup "addtogroup"</li>
    <li> @ref axasin "asin"</li>
    <li> @ref axasinh "asinh"</li>
    <li> @ref axatan "atan"</li>
    <li> @ref axatan2 "atan2"</li>
    <li> @ref axatanh "atanh"</li>
    <li> @ref axatof "atof"</li>
    <li> @ref axatoi "atoi"</li>
    <li> @ref axcbrt "cbrt"</li>
    <li> @ref axceil "ceil"</li>
    <li> @ref axclamp "clamp"</li>
    <li> @ref axcos "cos"</li>
    <li> @ref axcosh "cosh"</li>
    <li> @ref axcross "cross"</li>
    <li> @ref axcurlsimplexnoise "curlsimplexnoise"</li>
    <li> @ref axdeletepoint "deletepoint"</li>
    <li> @ref axdeterminant "determinant"</li>
    <li> @ref axdiag "diag"</li>
    <li> @ref axdot "dot"</li>
    <li> @ref axeuclideanmod "euclideanmod"</li>
    <li> @ref axexp "exp"</li>
    <li> @ref axexp2 "exp2"</li>
    <li> @ref axexternal "external"</li>
    <li> @ref axexternalv "externalv"</li>
    <li> @ref axfabs "fabs"</li>
    <li> @ref axfit "fit"</li>
    <li> @ref axfloor "floor"</li>
    <li> @ref axfloormod "floormod"</li>
    <li> @ref axgetcoordx "getcoordx"</li>
    <li> @ref axgetcoordy "getcoordy"</li>
    <li> @ref axgetcoordz "getcoordz"</li>
    <li> @ref axgetvoxelpws "getvoxelpws"</li>
    <li> @ref axhash "hash"</li>
    <li> @ref axidentity3 "identity3"</li>
    <li> @ref axidentity4 "identity4"</li>
    <li> @ref axingroup "ingroup"</li>
    <li> @ref axlength "length"</li>
    <li> @ref axlengthsq "lengthsq"</li>
    <li> @ref axlerp "lerp"</li>
    <li> @ref axlog "log"</li>
    <li> @ref axlog10 "log10"</li>
    <li> @ref axlog2 "log2"</li>
    <li> @ref axmax "max"</li>
    <li> @ref axmin "min"</li>
    <li> @ref axnormalize "normalize"</li>
    <li> @ref axpolardecompose "polardecompose"</li>
    <li> @ref axpostscale "postscale"</li>
    <li> @ref axpow "pow"</li>
    <li> @ref axprescale "prescale"</li>
    <li> @ref axpretransform "pretransform"</li>
    <li> @ref axprint "print"</li>
    <li> @ref axrand "rand"</li>
    <li> @ref axrand32 "rand32"</li>
    <li> @ref axremovefromgroup "removefromgroup"</li>
    <li> @ref axround "round"</li>
    <li> @ref axsign "sign"</li>
    <li> @ref axsignbit "signbit"</li>
    <li> @ref axsimplexnoise "simplexnoise"</li>
    <li> @ref axsin "sin"</li>
    <li> @ref axsinh "sinh"</li>
    <li> @ref axsqrt "sqrt"</li>
    <li> @ref axtan "tan"</li>
    <li> @ref axtanh "tanh"</li>
    <li> @ref axtrace "trace"</li>
    <li> @ref axtransform "transform"</li>
    <li> @ref axtranspose "transpose"</li>
    <li> @ref axtruncatemod "truncatemod"</li>
</ul><hr>


@anchor axabs
@par abs
 Computes the absolute value of an integer number.
@code{.c}
int64(int64 n);
int32(int32 n);
double(double n);
float(float n);
@endcode

@anchor axacos
@par acos
 Computes the principal value of the arc cosine of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axacosh
@par acosh
 Computes the inverse hyperbolic cosine of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axaddtogroup
@par addtogroup
 Add the current point to the given group name, effectively setting its membership to true. If the
 group does not exist, it is implicitly created. This function has no effect if the point
 already belongs to the given group.
@code{.c}
void(string);
@endcode

@anchor axasin
@par asin
 Computes the principal value of the arc sine of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axasinh
@par asinh
 Computes the inverse hyperbolic sine of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axatan
@par atan
 Computes the principal value of the arc tangent of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axatan2
@par atan2
 Computes the arc tangent of y/x using the signs of arguments to determine the correct quadrant.
@code{.c}
double(double y; double x);
float(float y; float x);
@endcode

@anchor axatanh
@par atanh
 Computes the inverse hyperbolic tangent of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axatof
@par atof
 Parses the string input, interpreting its content as a floating point number and returns its value
 as a double.
@code{.c}
double(i8* str);
@endcode

@anchor axatoi
@par atoi
 Parses the string input interpreting its content as an integral number, which is returned as a value
 of type int.
@code{.c}
int32(i8* str);
@endcode

@anchor axcbrt
@par cbrt
 Computes the cubic root of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axceil
@par ceil
 Computes the smallest integer value not less than arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axclamp
@par clamp
 Clamps the first argument to the minimum second argument value and maximum third argument value
@code{.c}
double(double in; double min; double max);
float(float in; float min; float max);
int64(int64 in; int64 min; int64 max);
int32(int32 in; int32 min; int32 max);
@endcode

@anchor axcos
@par cos
 Computes the cosine of arg (measured in radians).
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axcosh
@par cosh
 Computes the hyperbolic cosine of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axcross
@par cross
 Returns the length of the given vector
@code{.c}
vec3d(vec3d a; vec3d b);
vec3f(vec3f a; vec3f b);
vec3i(vec3i a; vec3i b);
@endcode

@anchor axcurlsimplexnoise
@par curlsimplexnoise
 Generates divergence-free 3D noise, computed using a curl function on Simplex Noise.
@code{.c}
vec3d(vec3d pos);
vec3d(double pos; double; double);
@endcode

@anchor axdeletepoint
@par deletepoint
 Delete the current point from the point set. Note that this does not stop AX execution - any
 additional AX commands will be executed on the point and it will remain accessible until the
 end of execution.
@code{.c}
void();
@endcode

@anchor axdeterminant
@par determinant
 Returns the determinant of a matrix.
@code{.c}
double(mat3d mat);
float(mat3f mat);
double(mat4d mat);
float(mat4f mat);
@endcode

@anchor axdiag
@par diag
 Create a diagonal matrix from a vector, or return the diagonal components of a matrix as a vector.
@code{.c}
vec3d(mat3d vec);
vec3f(mat3f vec);
vec4d(mat4d vec);
vec4f(mat4f vec);
mat3d(vec3d mat);
mat3f(vec3f mat);
mat4d(vec4d mat);
mat4f(vec4f mat);
@endcode

@anchor axdot
@par dot
 Computes the dot product of two vectors.
@code{.c}
double(vec3d a; vec3d b);
float(vec3f a; vec3f b);
int32(vec3i a; vec3i b);
@endcode

@anchor axeuclideanmod
@par euclideanmod
 Euclidean modulo, where by the result of the division operator on (dividend / divisor) is floored or
 ceiled depending on its sign, guaranteeing that the return value is always positive. The
 remainder is thus calculated with D - d * (d < 0 ? ceil(D/d) : floor(D/d)). This is NOT equal
 to a%b in AX. See truncatemod(), floormod().
@code{.c}
double(double dividend; double divisor);
float(float dividend; float divisor);
int64(int64 dividend; int64 divisor);
int32(int32 dividend; int32 divisor);
int16(int16 dividend; int16 divisor);
@endcode

@anchor axexp
@par exp
 Computes e (Euler's number, 2.7182818...) raised to the given power arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axexp2
@par exp2
 Computes 2 raised to the given power arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axexternal
@par external
 Find a custom user parameter with a given name of type 'float' in the Custom data provided to the AX
 compiler. If the data can not be found, or is not of the expected type 0.0f is returned.
@code{.c}
float(string str);
@endcode

@anchor axexternalv
@par externalv
 Find a custom user parameter with a given name of type 'vector float' in the Custom data provided to
 the AX compiler. If the data can not be found, or is not of the expected type { 0.0f, 0.0f,
 0.0f } is returned.
@code{.c}
vec3f(string str);
@endcode

@anchor axfabs
@par fabs
 Computes the absolute value of a floating point value arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axfit
@par fit
 Fit the first argument to the output range by first clamping the value between the second and third
 input range arguments and then remapping the result to the output range fourth and fifth
 arguments
@code{.c}
double(double value; double omin; double omax; double nmin; double nmax);
float(float value; float omin; float omax; float nmin; float nmax);
double(int64 value; int64 omin; int64 omax; int64 nmin; int64 nmax);
double(int32 value; int32 omin; int32 omax; int32 nmin; int32 nmax);
@endcode

@anchor axfloor
@par floor
 Computes the largest integer value not greater than arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axfloormod
@par floormod
 Floored modulo, where the result of the division operator on (dividend / divisor) is floored. The
 remainder is thus calculated with D - d * floor(D/d). This is the implemented modulo % operator
 of AX. This is equal to the python % implementation. See trucnatemod(), euclideanmod().
@code{.c}
double(double dividend; double divisor);
float(float dividend; float divisor);
int64(int64 dividend; int64 divisor);
int32(int32 dividend; int32 divisor);
int16(int16 dividend; int16 divisor);
@endcode

@anchor axgetcoordx
@par getcoordx
 Returns the current voxel's X index value in index space as an integer.
@code{.c}
int32();
@endcode

@anchor axgetcoordy
@par getcoordy
 Returns the current voxel's Y index value in index space as an integer.
@code{.c}
int32();
@endcode

@anchor axgetcoordz
@par getcoordz
 Returns the current voxel's Z index value in index space as an integer.
@code{.c}
int32();
@endcode

@anchor axgetvoxelpws
@par getvoxelpws
 Returns the current voxel's position in world space as a vector float.
@code{.c}
vec3f();
@endcode

@anchor axhash
@par hash
 Return a hash of the provided string.
@code{.c}
int64(string str);
@endcode

@anchor axidentity3
@par identity3
 Returns the 3x3 identity matrix
@code{.c}
mat3f();
@endcode

@anchor axidentity4
@par identity4
 Returns the 4x4 identity matrix
@code{.c}
mat4f();
@endcode

@anchor axingroup
@par ingroup
 Return whether or not the current point is a member of the given group name. This returns false if
 the group does not exist.
@code{.c}
bool(string);
@endcode

@anchor axlength
@par length
 Returns the length of the given vector
@code{.c}
double(vec2d v);
float(vec2f v);
double(vec2i v);
double(vec3d v);
float(vec3f v);
double(vec3i v);
double(vec4d v);
float(vec4f v);
double(vec4i v);
@endcode

@anchor axlengthsq
@par lengthsq
 Returns the squared length of the given vector
@code{.c}
double(vec2d v);
float(vec2f v);
int32(vec2i v);
double(vec3d v);
float(vec3f v);
int32(vec3i v);
double(vec4d v);
float(vec4f v);
int32(vec4i v);
@endcode

@anchor axlerp
@par lerp
 Performs bilinear interpolation between the values. If the amount is outside the range 0 to 1, the
 values will be extrapolated linearly. If amount is 0, the first value is returned. If it is 1,
 the second value is returned. This implementation is guaranteed to be monotonic.
@code{.c}
double(double a; double b; double amount);
float(float a; float b; float amount);
@endcode

@anchor axlog
@par log
 Computes the natural (base e) logarithm of arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axlog10
@par log10
 Computes the common (base-10) logarithm of arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axlog2
@par log2
 Computes the binary (base-2) logarithm of arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axmax
@par max
 Returns the larger of the given values.
@code{.c}
double(double a; double b);
float(float a; float b);
int64(int64 a; int64 b);
int32(int32 a; int32 b);
@endcode

@anchor axmin
@par min
 Returns the smaller of the given values.
@code{.c}
double(double a; double b);
float(float a; float b);
int64(int64 a; int64 b);
int32(int32 a; int32 b);
@endcode

@anchor axnormalize
@par normalize
 Returns the normalized result of the given vector.
@code{.c}
vec3d(vec3d v);
vec3f(vec3f v);
vec3d(vec3i v);
@endcode

@anchor axpolardecompose
@par polardecompose
 Decompose an invertible 3x3 matrix into its orthogonal (unitary) matrix and symmetric matrix
 components. If the determinant of the unitary matrix is 1 it is a rotation, otherwise if it is
 -1 there is some part reflection.
@code{.c}
bool(mat3d input; mat3d unitary; mat3d symmetric);
bool(mat3f input; mat3f unitary; mat3f symmetric);
@endcode

@anchor axpostscale
@par postscale
 Post-scale a given matrix by the provided vector.
@code{.c}
void(mat4d transform; vec3d vec);
void(mat4f transform; vec3f vec);
@endcode

@anchor axpow
@par pow
 Computes the value of the first argument raised to the power of the second argument.
@code{.c}
double(double base; double exp);
float(float base; float exp);
double(double base; int32 exp);
@endcode

@anchor axprescale
@par prescale
 Pre-scale a given matrix by the provided vector.
@code{.c}
void(mat4d transform; vec3d vec);
void(mat4f transform; vec3f vec);
@endcode

@anchor axpretransform
@par pretransform
 Return the transformed vector by transpose of this matrix. This function is equivalent to
 pre-multiplying the matrix.
@code{.c}
vec3d(mat3d vec; vec3d mat);
vec3f(mat3f vec; vec3f mat);
vec3d(mat4d vec; vec3d mat);
vec3f(mat4f vec; vec3f mat);
vec4d(mat4d vec; vec4d mat);
vec4f(mat4f vec; vec4f mat);
@endcode

@anchor axprint
@par print
 Prints the input to the standard output stream. Warning: This will be run for every element.
@code{.c}
void(double n);
void(float n);
void(int64 n);
void(int32 n);
void(string n);
void(vec2i n);
void(vec2f n);
void(vec2d n);
void(vec3i n);
void(vec3f n);
void(vec3d n);
void(vec4i n);
void(vec4f n);
void(vec4d n);
void(mat3f n);
void(mat3d n);
void(mat4f n);
void(mat4d n);
@endcode

@anchor axrand
@par rand
 Creates a random number based on the provided seed. The number will be in the range of 0 to 1. The
 same number is produced for the same seed. Note that if rand is called without a seed the
 previous state of the random number generator is advanced for the currently processing element.
 This state is determined by the last call to rand() with a given seed. If rand is not called
 with a seed, the generator advances continuously across different elements which can produce
 non-deterministic results. It is important that rand is always called with a seed at least once
 for deterministic results.
@code{.c}
double();
double(double seed);
double(int64 seed);
@endcode

@anchor axrand32
@par rand32
 Creates a random number based on the provided 32 bit seed. The number will be in the range of 0 to
 1. The same number is produced for the same seed. NOTE: This function does not share the same
 random number generator as rand(). rand32() may provide a higher throughput on some
 architectures, but will produce different results to rand(). NOTE: If rand32 is called without
 a seed the previous state of the random number generator is advanced for the currently
 processing element. This state is determined by the last call to rand32() with a given seed. If
 rand32 is not called with a seed, the generator advances continuously across different elements
 which can produce non-deterministic results. It is important that rand32 is always called with
 a seed at least once for deterministic results.
@code{.c}
double();
double(double seed);
double(int32 seed);
@endcode

@anchor axremovefromgroup
@par removefromgroup
 Remove the current point from the given group name, effectively setting its membership to false.
 This function has no effect if the group does not exist.
@code{.c}
void(string);
@endcode

@anchor axround
@par round
 Computes the nearest integer value to arg (in floating-point format), rounding halfway cases away
 from zero.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axsign
@par sign
 Implements signum, determining if the input is negative, zero or positive. Returns -1 for a negative
 number, 0 for the number zero, and +1 for a positive number. Note that this function does not
 check the sign of floating point +/-0.0 values. See signbit().
@code{.c}
int32(double n);
int32(float n);
int32(int64 n);
int32(int32 n);
@endcode

@anchor axsignbit
@par signbit
 Determines if the given floating point number input is negative. Returns true if arg is negative,
 false otherwise. Will return true for -0.0, false for +0.0
@code{.c}
bool(double n);
bool(float n);
@endcode

@anchor axsimplexnoise
@par simplexnoise
 Compute simplex noise at coordinates x, y and z. Coordinates which are not provided will be set to
 0.
@code{.c}
double(double x);
double(double x; double y);
double(double x; double y; double z);
double(vec3d pos);
@endcode

@anchor axsin
@par sin
 Computes the sine of arg (measured in radians).
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axsinh
@par sinh
 Computes the hyperbolic sine of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axsqrt
@par sqrt
 Computes the square root of arg.
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axtan
@par tan
 Computes the tangent of arg (measured in radians).
@code{.c}
double(double n);
float(float n);
@endcode

@anchor axtanh
@par tanh
 Computes the hyperbolic tangent of the input.
@code{.c}
double(double arg);
float(float arg);
@endcode

@anchor axtrace
@par trace
 Return the trace of a matrix, the sum of the diagonal elements.
@code{.c}
double(mat3d mat);
float(mat3f mat);
double(mat4d mat);
float(mat4f mat);
@endcode

@anchor axtransform
@par transform
 Return the transformed vector by the provided matrix. This function is equivalent to
 post-multiplying the matrix, i.e. vec * mult.
@code{.c}
vec3d(vec3d vec; mat3d mat);
vec3f(vec3f vec; mat3f mat);
vec3d(vec3d vec; mat4d mat);
vec3f(vec3f vec; mat4f mat);
vec4d(vec4d vec; mat4d mat);
vec4f(vec4f vec; mat4f mat);
@endcode

@anchor axtranspose
@par transpose
 Returns the transpose of a matrix
@code{.c}
mat3d(mat3d mat);
mat3f(mat3f mat);
mat4d(mat4d mat);
mat4f(mat4f mat);
@endcode

@anchor axtruncatemod
@par truncatemod
 Truncated modulo, where the result of the division operator on (dividend / divisor) is truncated.
 The remainder is thus calculated with D - d * trunc(D/d). This is equal to the C/C++ %
 implementation. This is NOT equal to a%b in AX. See floormod(), euclideanmod().
@code{.c}
double(double dividend; double divisor);
float(float dividend; float divisor);
int64(int64 dividend; int64 divisor);
int32(int32 dividend; int32 divisor);
int16(int16 dividend; int16 divisor);
@endcode


</div>
*/
