# Maths Functions¶

The following maths functions are defined on both scalar and vector float types, i.e. `float, float1, float2, float3` and `float4`.

On vectors the math function is applied to each component element-wise. For example: `sin(float2(1.0f, 2.0f))` is equivalent to `float2(sin(1.0f), sin(2.0f))`.

When a function takes multiple arguments the same logic is applied to each argument element-wise. See the SpecificationMathsKernel for an example of the following maths functions used in a single kernel.

## Trigonometric functions¶

``````// floatn sin(floatn a);
pixel = sin(pixel);
// floatn cos(floatn a);
pixel = cos(pixel);
// floatn tan(floatn a);
pixel = tan(pixel);
// floatn asin(floatn a);
pixel = asin(pixel);
// floatn acos(floatn a);
pixel = acos(pixel);
// floatn atan(floatn a);
pixel = atan(pixel);
// floatn atan2(floatn a, floatn b);
pixel = atan2(pixel, pixel);
``````

## Logarithmic, exponential and power functions¶

``````// floatn exp(floatn x);
// Returns the natural exponent, e^x.
pixel = exp(pixel);
// floatn log(floatn x);
// Returns the natural log, log x of base e.
pixel = log(pixel);
// floatn log2(floatn x);
// Returns the log x of base 2.
pixel = log2(pixel);
// floatn log10(floatn x);
// Returns the log x of base 10.
pixel = log10(pixel);
// floatn pow(floatn x, floatn a);
// Returns x^a.
pixel = pow(pixel, pixel);
// floatn sqrt(floatn x);
// Returns the positive square root of x.
pixel = sqrt(pixel);
// floatn rsqrt(floatn x);
// Returns the inverse square root of x, i.e. 1.0f/sqrt(x).
pixel = rsqrt(pixel + 1.0f);
``````

## Rounding functions¶

``````// floatn floor(floatn x);
// Returns x rounded to an integer towards negative infinity.
pixel = floor(pixel);
// floatn ceil(floatn x);
// Returns x rounded to an integer towards positive infinity.
pixel = ceil(pixel);
``````

## Absolute and sign functions¶

``````// floatn fabs(floatn x);
// Returns the absolute value of x.
pixel = fabs(pixel);

// floatn sign(floatn x);
// Returns the value of the sign bit of x i.e. 1.0f for positive values,
// -1.0f for negative values and 0.0f for +/-0.0f.
pixel = sign(pixel);
``````

## Remainder functions¶

``````// floatn fmod(floatn x, floatn y);
// Returns the floating point remainder of the division of x / y.
pixel = fmod(pixel, SampleType(dst)(0.5f));
``````

## Clamping functions¶

``````// floatn min(floatn x, floatn y);
pixel = min(pixel, SampleType(dst)(0.5f));
// floatn max(floatn x, floatn y);
pixel = max(pixel, SampleType(dst)(0.5f));
// floatn clamp(floatn x, floatn y, floatn z);
pixel = clamp(pixel, SampleType(dst)(0.0f), SampleType(dst)(1.0f));
``````

## Special maths functions¶

These functions don’t follow the standard pattern on vectors like the above functions, but instead compute something bespoke.

``````// float dot(floatn x, floatn y);
// Returns the dot product of x dot y.
float dotProduct = dot(pixel, pixel);

// float3 cross(float3 x, float3 y);
// Returns the cross product of x cross y.
float3 crossProduct = cross(float3(1.0f, 2.0f, 3.0f), float3(4.0f, 5.0f, 6.0f));

// int length(floatn x);
// Returns the number of elements in a vector i.e. length(float2(1.0f, 2.0f)) -> 2
int len = length(pixel);

// floatn normalize(floatn x);
// Returns the L2-Norm of x.
pixel = normalize(pixel);

// float median(float data[], int size);
// Returns the median value in an array of data of length size.
float arr[6] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
float med = median(arr, 6);
``````