Provided by: elvish_0.18.0-1_amd64 
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 {#math:e}
$math:e
Approximate value of e (https://en.wikipedia.org/wiki/E_(mathematical_constant)):
2.718281.... This variable is read-only.
$math:pi {#math:pi}
$math:pi
Approximate value of π (https://en.wikipedia.org/wiki/Pi): 3.141592.... This variable is
read-only.
Functions
math:abs {#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}
math:acos $number
Outputs the arccosine of $number, in radians (not degrees). Examples:
~> math:acos 1
▶ (float64 1)
~> math:acos 1.00001
▶ (float64 NaN)
math:acosh {#math:acosh}
math:acosh $number
Outputs the inverse hyperbolic cosine of $number. Examples:
~> math:acosh 1
▶ (float64 0)
~> math:acosh 0
▶ (float64 NaN)
math:asin {#math:asin}
math:asin $number
Outputs the arcsine of $number, in radians (not degrees). Examples:
~> math:asin 0
▶ (float64 0)
~> math:asin 1
▶ (float64 1.5707963267948966)
~> math:asin 1.00001
▶ (float64 NaN)
math:asinh {#math:asinh}
math:asinh $number
Outputs the inverse hyperbolic sine of $number. Examples:
~> math:asinh 0
▶ (float64 0)
~> math:asinh inf
▶ (float64 +Inf)
math:atan {#math:atan}
math:atan $number
Outputs the arctangent of $number, in radians (not degrees). Examples:
~> math:atan 0
▶ (float64 0)
~> math:atan $math:inf
▶ (float64 1.5707963267948966)
math:atanh {#math:atanh}
math:atanh $number
Outputs the inverse hyperbolic tangent of $number. Examples:
~> math:atanh 0
▶ (float64 0)
~> math:atanh 1
▶ (float64 +Inf)
math:ceil {#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: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:cos {#math:cos}
math:cos $number
Computes the cosine of $number in units of radians (not degrees). Examples:
~> math:cos 0
▶ (float64 1)
~> math:cos 3.14159265
▶ (float64 -1)
math:cosh {#math:cosh}
math:cosh $number
Computes the hyperbolic cosine of $number. Example:
~> math:cosh 0
▶ (float64 1)
math:floor {#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}
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}
math:is-nan $number
Tests whether the number is a NaN (not-a-number).
~> math:is-nan 123
▶ $false
~> math:is-nan (float64 inf)
▶ $false
~> math:is-nan (float64 nan)
▶ $true
math:log {#math:log}
math:log $number
Computes the natural (base e) logarithm of $number. Examples:
~> math:log 1.0
▶ (float64 1)
~> math:log -2.3
▶ (float64 NaN)
math:log10 {#math:log10}
math:log10 $number
Computes the base 10 logarithm of $number. Examples:
~> math:log10 100.0
▶ (float64 2)
~> math:log10 -1.7
▶ (float64 NaN)
math:log2 {#math:log2}
math:log2 $number
Computes the base 2 logarithm of $number. Examples:
~> math:log2 8
▶ (float64 3)
~> math:log2 -5.3
▶ (float64 NaN)
math:max {#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}
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 17], line 1: math:min
~> math:min 3 5 2
▶ (num 2)
~> math:min 1/2 1/3 2/3
▶ (num 1/3)
math:pow {#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}
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}
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}
math:sin $number
Computes the sine of $number in units of radians (not degrees). Examples:
~> math:sin 0
▶ (float64 0)
~> math:sin 3.14159265
▶ (float64 3.5897930298416118e-09)
math:sinh {#math:sinh}
math:sinh $number
Computes the hyperbolic sine of $number. Example:
~> math:sinh 0
▶ (float64 0)
math:sqrt {#math:sqrt}
math:sqrt $number
Computes the square-root of $number. Examples:
~> math:sqrt 0
▶ (float64 0)
~> math:sqrt 4
▶ (float64 2)
~> math:sqrt -4
▶ (float64 NaN)
math:tan {#math:tan}
math:tan $number
Computes the tangent of $number in units of radians (not degrees). Examples:
~> math:tan 0
▶ (float64 0)
~> math:tan 3.14159265
▶ (float64 -0.0000000035897930298416118)
math:tanh {#math:tanh}
math:tanh $number
Computes the hyperbolic tangent of $number. Example:
~> math:tanh 0
▶ (float64 0)
math:trunc {#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)