## Double Functions

The double functions are those functions that:

- take one or more arguments that are double expressions and
- return a double value

Some terms that are used in this document:

- radians
- pi

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
  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)
  deg2rad | convert degrees to radians | deg2rad(360) = 2 * pi
  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.
  rad2deg | convert radians to degrees | rad2deg(2 * pi) = 360
  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
  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.

- additional functions

  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.