Introduction

The math: module provides mathematical functions and constants.

Function usages are given in the same format as in the reference doc for the builtin module. In particular, all the commands in this module conform to the convention of numeric commands.

Variables

$math:e

Approximate value of e: 2.718281…. This variable is read-only.

$math:pi

Approximate value of π: 3.141592…. This variable is read-only.

Functions

math:abs

math:abs $number

Computes the absolute value $number. This function is exactness-preserving. Examples:

~> math:abs 2
▶ (num 2)
~> math:abs -2
▶ (num 2)
~> math:abs 10000000000000000000
▶ (num 10000000000000000000)
~> math:abs -10000000000000000000
▶ (num 10000000000000000000)
~> math:abs 1/2
▶ (num 1/2)
~> math:abs -1/2
▶ (num 1/2)
~> math:abs 1.23
▶ (num 1.23)
~> math:abs -1.23
▶ (num 1.23)

math:acos

math:acos $number

Outputs the arccosine of $number, in radians (not degrees). Examples:

~> math:acos 1
▶ (num 0.0)
~> math:acos 1.00001
▶ (num NaN)

math:acosh

math:acosh $number

Outputs the inverse hyperbolic cosine of $number. Examples:

~> math:acosh 1
▶ (num 0.0)
~> math:acosh 0
▶ (num NaN)

math:asin

math:asin $number

Outputs the arcsine of $number, in radians (not degrees). Examples:

~> math:asin 0
▶ (num 0.0)
~> math:asin 1
▶ (num 1.5707963267948966)
~> math:asin 1.00001
▶ (num NaN)

math:asinh

math:asinh $number

Outputs the inverse hyperbolic sine of $number. Examples:

~> math:asinh 0
▶ (num 0.0)
~> math:asinh inf
▶ (num +Inf)

math:atan

math:atan $number

Outputs the arctangent of $number, in radians (not degrees). Examples:

~> math:atan 0
▶ (num 0.0)
~> math:atan +inf
▶ (num 1.5707963267948966)

math:atan2

math:atan2 $y $x

Outputs the arc tangent of y/x in radians, using the signs of the two to determine the quadrant of the return value. Examples:

~> math:atan2 0 0
▶ (num 0.0)
~> math:atan2 1 1
▶ (num 0.7853981633974483)
~> math:atan2 -1 -1
▶ (num -2.356194490192345)

math:atanh

math:atanh $number

Outputs the inverse hyperbolic tangent of $number. Examples:

~> math:atanh 0
▶ (num 0.0)
~> math:atanh 1
▶ (num +Inf)

math:ceil

math:ceil $number

Computes the least integer greater than or equal to $number. This function is exactness-preserving.

The results for the special floating-point values -0.0, +0.0, -Inf, +Inf and NaN are themselves.

Examples:

~> math:ceil 1
▶ (num 1)
~> math:ceil 3/2
▶ (num 2)
~> math:ceil -3/2
▶ (num -1)
~> math:ceil 1.1
▶ (num 2.0)
~> math:ceil -1.1
▶ (num -1.0)

math:cos

math:cos $number

Computes the cosine of $number in units of radians (not degrees). Examples:

~> math:cos 0
▶ (num 1.0)
~> math:cos 3.14159265
▶ (num -1.0)

math:cosh

math:cosh $number

Computes the hyperbolic cosine of $number. Example:

~> math:cosh 0
▶ (num 1.0)

math:floor

math:floor $number

Computes the greatest integer less than or equal to $number. This function is exactness-preserving.

The results for the special floating-point values -0.0, +0.0, -Inf, +Inf and NaN are themselves.

Examples:

~> math:floor 1
▶ (num 1)
~> math:floor 3/2
▶ (num 1)
~> math:floor -3/2
▶ (num -2)
~> math:floor 1.1
▶ (num 1.0)
~> math:floor -1.1
▶ (num -2.0)

math:is-inf

math:is-inf &sign=0 $number

Tests whether the number is infinity. If sign > 0, tests whether $number is positive infinity. If sign < 0, tests whether $number is negative infinity. If sign == 0, tests whether $number is either infinity.

~> math:is-inf 123
▶ $false
~> math:is-inf inf
▶ $true
~> math:is-inf -inf
▶ $true
~> math:is-inf &sign=1 inf
▶ $true
~> math:is-inf &sign=-1 inf
▶ $false
~> math:is-inf &sign=-1 -inf
▶ $true

math:is-nan

math:is-nan $number

Tests whether the number is a NaN (not-a-number).

~> math:is-nan 123
▶ $false
~> math:is-nan (num inf)
▶ $false
~> math:is-nan (num nan)
▶ $true

math:log

math:log $number

Computes the natural (base e) logarithm of $number. Examples:

~> math:log 1.0
▶ (num 0.0)
~> math:log -2.3
▶ (num NaN)

math:log10

math:log10 $number

Computes the base 10 logarithm of $number. Examples:

~> math:log10 100.0
▶ (num 2.0)
~> math:log10 -1.7
▶ (num NaN)

math:log2

math:log2 $number

Computes the base 2 logarithm of $number. Examples:

~> math:log2 8
▶ (num 3.0)
~> math:log2 -5.3
▶ (num NaN)

math:max

math:max $number...

Outputs the maximum number in the arguments. If there are no arguments, an exception is thrown. If any number is NaN then NaN is output. This function is exactness-preserving.

Examples:

~> math:max 3 5 2
▶ (num 5)
~> math:max (range 100)
▶ (num 99)
~> math:max 1/2 1/3 2/3
▶ (num 2/3)

math:min

math:min $number...

Outputs the minimum number in the arguments. If there are no arguments an exception is thrown. If any number is NaN then NaN is output. This function is exactness-preserving.

Examples:

~> math:min
Exception: arity mismatch: arguments must be 1 or more values, but is 0 values
  [tty]:1:1-8: math:min
~> math:min 3 5 2
▶ (num 2)
~> math:min 1/2 1/3 2/3
▶ (num 1/3)

math:pow

math:pow $base $exponent

Outputs the result of raising $base to the power of $exponent.

This function produces an exact result when $base is exact and $exponent is an exact integer. Otherwise it produces an inexact result.

Examples:

~> math:pow 3 2
▶ (num 9)
~> math:pow -2 2
▶ (num 4)
~> math:pow 1/2 3
▶ (num 1/8)
~> math:pow 1/2 -3
▶ (num 8)
~> math:pow 9 1/2
▶ (num 3.0)
~> math:pow 12 1.1
▶ (num 15.38506624784179)

math:round

math:round $number

Outputs the nearest integer, rounding half away from zero. This function is exactness-preserving.

The results for the special floating-point values -0.0, +0.0, -Inf, +Inf and NaN are themselves.

Examples:

~> math:round 2
▶ (num 2)
~> math:round 1/3
▶ (num 0)
~> math:round 1/2
▶ (num 1)
~> math:round 2/3
▶ (num 1)
~> math:round -1/3
▶ (num 0)
~> math:round -1/2
▶ (num -1)
~> math:round -2/3
▶ (num -1)
~> math:round 2.5
▶ (num 3.0)

math:round-to-even

math:round-to-even $number

Outputs the nearest integer, rounding ties to even. This function is exactness-preserving.

The results for the special floating-point values -0.0, +0.0, -Inf, +Inf and NaN are themselves.

Examples:

~> math:round-to-even 2
▶ (num 2)
~> math:round-to-even 1/2
▶ (num 0)
~> math:round-to-even 3/2
▶ (num 2)
~> math:round-to-even 5/2
▶ (num 2)
~> math:round-to-even -5/2
▶ (num -2)
~> math:round-to-even 2.5
▶ (num 2.0)
~> math:round-to-even 1.5
▶ (num 2.0)

math:sin

math:sin $number

Computes the sine of $number in units of radians (not degrees). Examples:

~> math:sin 0
▶ (num 0.0)
~> math:sin 3.14159265
▶ (num 3.5897930298416118e-09)

math:sinh

math:sinh $number

Computes the hyperbolic sine of $number. Example:

~> math:sinh 0
▶ (num 0.0)

math:sqrt

math:sqrt $number

Computes the square-root of $number. Examples:

~> math:sqrt 0
▶ (num 0.0)
~> math:sqrt 4
▶ (num 2.0)
~> math:sqrt -4
▶ (num NaN)

math:tan

math:tan $number

Computes the tangent of $number in units of radians (not degrees). Examples:

~> math:tan 0
▶ (num 0.0)
~> math:tan 3.14159265
▶ (num -0.0000000035897930298416118)

math:tanh

math:tanh $number

Computes the hyperbolic tangent of $number. Example:

~> math:tanh 0
▶ (num 0.0)

math:trunc

math:trunc $number

Outputs the integer portion of $number. This function is exactness-preserving.

The results for the special floating-point values -0.0, +0.0, -Inf, +Inf and NaN are themselves.

Examples:

~> math:trunc 1
▶ (num 1)
~> math:trunc 3/2
▶ (num 1)
~> math:trunc 5/3
▶ (num 1)
~> math:trunc -3/2
▶ (num -1)
~> math:trunc -5/3
▶ (num -1)
~> math:trunc 1.7
▶ (num 1.0)
~> math:trunc -1.7
▶ (num -1.0)