## Double Functions

The double functions are those functions that:

Some terms that are used in this document:

The set of available double functions is:

• one argument functions:

Function Name Description Notes
acsc inverse cosecant acsc(value) = asin(1.0 / value)
acsch inverse hyperbolic cosecant acsch(value) = asinh(1.0 / value)
acos inverse cosine result = cos(value), value = acos(result)

The cosine accepts an angle measured in radians and returns a value between -1 and 1 so the inverse cosine expects a value between -1 and 1 and returns an angle in radians.

0 <= result <= pi

acosh inverse hyperbolic cosine acosh(value) = log(value + sqrt(value * value - 1.0))
acot inverse cotangent acot(value) = atan(1.0 / value)
acoth inverse hyperbolic cotangent acoth(value) = atanh(1.0 / value)
asec inverse secant asec(value) = acos(1.0 / value)
asech inverse hyperbolic cosecant asech(value) = acosh(1.0 / value)
asin inverse sin result = sin(value), value = asin(result)

The sine accepts an angle measured in radians and returns a value between -1 and 1 so the inverse sine expects a value between -1 and 1 and returns an angle in radians.

0 <= result <= pi

asinh inverse hyperbolic sine asinh(value) = log(value + sqrt(value * value + 1.0))
atan inverse tangent result = tan(value), value = atan(result)

The tangent accepts an angle measured in radians and returns a real number so the inverse tangent accepts a real number and retuns an angle measured in radians.

-pi/2 <= result <= pi/2

atanh inverse hyperbolic tangent atanh(value) = log((value + 1.0) / (value - 1.0)) / 2.0
bernoulli bernoulli numbers bernoulli(n) = the nth bernoulli number (n < 40)
bit_not bitwise not bit_not(value) = value is rounded to an integer and is then returned with each 0 bit turned to a 1 and vice versa. bit_not(12312322) = -12312323.
ceil ceiling function This function rounds its argument upward to the nearest integer. For example:

ceil(1.9) == 2.0.

cos cosine The cosine expects arguments passed to it to be numbers measured in radians. The cosine is a cyclical function with a period of 2 * pi, that is - every 2 * pi it repeats itself so:

cos(0) == cos(2 * pi) == cos(-2 * pi) == cos(4 * pi)

-1 <= cos(value) <= 1

cosh hyperbolic cosine cosh(value) = (exp(value) + exp(-value)) / 2.0
cot cotangent cot(value) = cos(value) / sin(value)
coth hyperbolic cotangent coth(value) = cosh(value) / sinh(value)
csc cosecant csc(value) = 1.0 / sin(value)
csch hyperbolic cosecant csch(value) = 1.0 / sinh(value)
euler euler numbers euler(n) = the nth euler number (n < 40)
exp exponential The value of the exponential function is the result of raising euler's number (approximately 2.7182818284590452354) to the power of the argument supplied. exp(value) is:

2.7182818284590452354 ^ (x)

Where '^' means "raised to the power of"

abs absolute value The absolute value of a real number x is defined as:

abs(x) = x (if x >= 0) example: abs(2) = 2
abs(x) = -x (if x < 0) example: abs(-1) = 1

Note that abs(x) is always positive.

fabs absolute value alternate name for abs
fact factorial fact(value) = value * (value - 1) * (value - 2) * ... * 1
floor floor This function rounds its argument downward to the nearest integer. For example:

floor(1.2) == 1.0.

get_entry_red access color table rgb values This function returns the red component for the specified color table entry index. For example:
```      colors { define { [255 0 0] } }

formula {
println(get_entry_red(0));
...
```
Will print out '255'
get_entry_green access color table rgb values This function returns the green component for the specified color table entry index.
get_entry_blue access color table rgb values This function returns the blue component for the specified color table entry index.
log natural log The log of x is the power that euler's number (approximately 2.7182818284590452354) must be raised to to equal x. The natural log is the inverse of the exp function, that is:

log(exp(x)) == x

Note that the natural logarithm function expects its argument to be greater than zero.

log10 log base 10 The value of log10(x) is the power that 10 needs to be raised to to be equal to x. For example:

log10(100) == 2 (since 10 * 10 == 100)

Like the natural logarithm, log10 expects its argument to be greater than zero.

sec secant sec(value) = 1.0 / cos(value)
sech hyperbolic secant sech(value) = 1.0 / cosh(value)
sin sine The sine expects arguments passed to it to be numbers measured in radians. The sine is a cyclical function with a period of 2 * pi, that is - every 2 * pi it repeats itself so:

sin(0) == sin(2 * pi) == sin(-2 * pi) == sin(4 * pi)

-1 <= sin(value) <= 1

sinh hyperbolic sine sinh(value) = (exp(value) - exp(-value)) / 2.0
sqrt square root The square root of x is the number that when multipled by itself is equal to x. For example:

sqrt(4) == 2.

The square root expects its argument to be greater than or equal to zero.

tan tangent tan(value) = sin(value) / cos(value)
tanh hyperbolic tangent tanh(value) = sinh(value) / cosh(value)

• two argument functions:

Function Name Description Notes
atan2 the inverse tangent Similar to atan except that two arguments are used - also, the range of returned values is different. With the exception of the range of return values, the following is true:

atan2(y, x) == atan(y / x)

-pi <= atan2(y, x) <= pi

bit_and bitwise and The bitwise and of the two supplied arguments (each rounded to integers). bit_and(5, 2) = 0
bit_or bitwise or The bitwise or of the two supplied arguments (each rounded to integers). bit_or(5, 2) = 7
bit_shl bitwise left shift The shift the bits of the first argument left by the number of positions specified by the second argument (both rounded to integers). bit_shl(1, 5) = 32
bit_shr bitwise right shift The shift the bits of the first argument right by the number of positions specified by the second argument (both rounded to integers). bit_shr(64, 3) = 8
bit_xor bitwise exclusive or The bitwise xor of the two supplied arguments (each rounded to integers). bit_xor(5, 3) = 6
mod the modulus or remainder function To compute mod(x, y) calculate the value 'n' by dividing x by y and rounding the result towards zero to an integer.

The return value of mod(x, y) then is: x - n * y

The mod function expects that its second argument is not zero.

Some examples:
mod(10, 2) == 0
mod(10.1, 2) == 0.1
mod(10.5, 2) == 0.5
mod(11, 2) == 1.0
mod(11.2, 2) == 0.2
mod(11.5, 2) == 1.5
mod(12, 2) == 0

the returned value is a real number >= 0 and less than the first argument. In the above examples, note that 2 is the second argument to mod and that the result is always less than 2.

NOTE: You can also write mod(x, y) as "x % y"

fmod the modulus or remainder function alternate name for 'mod'
pow the power function This function raises the first argument to the power of the second argument

Here are some examples

pow(2, 3) == 8 (2 * 2 * 2)
pow(3, 4) == 91 (3 * 3 * 3 * 3)

The pow function can handle any two real values except when the first argument is negative and the second argument is not an integer.

NOTE: You can also write pow(x, y) as "x ^ y"

min the minimum function if a <= b then min(a, b) = a
if a < b then min(a, b) = b
max the maximum function if a >= b then max(a, b) = a
if a < b then max(a, b) = b
gamma the gamma function This function can be used to adjust color values.

0 <= first argument <= 255

0 < second argument

gamma(x, y) = 255 * ((x/255) ^ (1 / y))

values of y closer towards zero produce darker colors, values of y farther from zero produce lighter colors

• three argument functions:

Function Name Description Notes
get_sin_color maps value (0 <= value <= 1) to an rgb value (0 <= rgb <= 255) This function is very useful when doing direct color fractals. Its arguments:

first argument (value to be mapped) => 0 <= value <= 1
second argument (start value) => 0 <= value <= 255
third argument (step value) => 0 < value

This function produces a smooth color gradient using a sin and cos transformation of the original value (0 <= value <= 1). It returns a value between 0 and 255.

get_cos_color like 'get_sin_color', maps value (0 <= value <= 1) to an rgb value (0 <= rgb <= 255) This function is very useful when doing direct color fractals. Its arguments:

first argument (value to be mapped) => 0 <= value <= 1
second argument (start value) => 0 <= value <= 255
third argument (scale value) => 0 < value

This function uses the following formula to compute its return value:

offset = pi * (offset / 255.0)
result = cos(offset + pi + scale * value * 2 * pi)
return(127.5 * (1.0 + result));

Again, like 'get_sin_color' it returns a value between 0 and 255.

get_hsv_red Given h, s and v - return the red component that results from performing a hsv => rgb conversion
get_hsv_green Given h, s and v - return the green component that results from performing a hsv => rgb conversion
get_hsv_blue Given h, s and v - return the blue component that results from performing a hsv => rgb conversion

map_color - can accept a variable number of arguments. It is also useful for making direct color fractals. The general format of map_color is:

map_color(value : colors : percentages)

The first argument 'value' will be a number: 0 <= value <= 1

The 'colors' argument will be a comma separated list of values between 0 and 255.

The 'percentages' argument will be a comma saparated list of values between 0 and 100 (0% and 100%).

Here's an example of how map color might be used:

\$value = .5;
\$result = map_color(\$value : 0, 255 : 100);

In this example, a \$value of 0 would return 0, a \$value of 1 would return 255. This map_color statement says: "The interval [0, 255] is to be 100% of the color range we want to map [0, 1] onto"

Another example:

\$value = .5;
\$result = map_color(\$value : 0, 255, 0 : 50, 50);

In this case we'll spend 50% on the interval [0, 255] and 50% on the interval [255, 0] so a value of 0 or 1 will give us back 0 whereas a value of .5 will give us 255.

Finally, note that there will always be one less percentage value than there were color values. This is because the percentage values indicate how much of the range will be used up between two colors.

text_intersect(text, origin, \$height, \$thickness, point) - this function allows the use of a string of text as a trapping region (similar to what we describe here).

This is basically a fun or experimental function and at the moment it only supports lower case letters, upper case letters and spaces.

If you call text_intersect and get back a value of -1 then the supplied point does not interesect the text string, a value between 0 and 1 indicates that the point does intersect the text with zero meaning "right on the text" whereas one meaning "just on the edge of the text". This makes the use of gamma correction for 3D effects easy to accomplish, for example.

The 'origin' is the starting point of the text, the 'height' is the height of the text, the 'thickness' is the thickness of the letters and 'point' is the point to be tested to see if it falls within the boundary of the text string.