math

nimony/lib/std/math.nim

type Arithmetic = concept
  func +(x: Self, y: Self): Self
  func -(x: Self, y: Self): Self
  func *(x: Self, y: Self): Self
  func mod(x: Self, y: Self): Self
  func ==(x: Self, y: Self): bool
  func <(x: Self, y: Self): bool
  func <=(x: Self, y: Self): bool

type IntegerArithmetic = concept of Arithmetic
  func div(x: Self, y: Self): Self
  func inc(x: var Self, y: Self)
  func dec(x: var Self, y: Self)

type SignedArithmetic = concept of Arithmetic
  func -(x: Self): Self

type FloatArithmetic = concept of SignedArithmetic
  func /(x: Self, y: Self): Self

type HasSqrt = concept
  func sqrt(x: Self): Self

type HasExp = concept
  func exp(x: Self): Self

type HasLn = concept
  func ln(x: Self): Self

type HasSin = concept
  func sin(x: Self): Self

type HasCos = concept
  func cos(x: Self): Self

type HasHypot = concept
  func hypot(x: Self, y: Self): Self

type HasArctan2 = concept
  func arctan2(y: Self, x: Self): Self

const PI: float64
The circle constant PI (Ludolph's number).
const TAU: float64
The circle constant TAU (= 2 * PI).
const E: float64
Euler's number.
const MaxFloat64Precision: int64
Maximum number of meaningful digits after the decimal point for Nim's float64 type.
const MaxFloat32Precision: int64
Maximum number of meaningful digits after the decimal point for Nim's float32 type.
const MaxFloatPrecision: int64
Maximum number of meaningful digits after the decimal point for Nim's float type.
const MinFloatNormal: float64
Smallest normal number for Nim's float type (= 2^-1022).

type FloatClass = enum
  fcNormal = (0, "fcNormal")
  fcSubnormal = (1, "fcSubnormal")
  fcZero = (2, "fcZero")
  fcNegZero = (3, "fcNegZero")
  fcNan = (4, "fcNan")
  fcInf = (5, "fcInf")
  fcNegInf = (6, "fcNegInf")

func dollar`.FloatClass(e: FloatClass): string
func signbit(x: T): bool
Returns true if x is negative, false otherwise.
func copySign(x: float32; y: float32): float32
func copySign(x: float64; y: float64): float64
Returns a value with the magnitude of x and the sign of y; this works even if x or y are NaN, infinity or zero, all of which can carry a sign.
func classify(x: T): FloatClass
Classifies a floating point value.
Returns x's class as specified by the FloatClass enum<#FloatClass>_.
func isNaN(x: T): bool
Returns whether x is a NaN, more efficiently than via classify(x) == fcNan.
func almostEqual(x: T; y: T; unitsInLastPlace: int64): bool
Checks if two float values are almost equal, using the machine epsilon.
unitsInLastPlace is the max number of units in the last place difference tolerated when comparing two numbers. The larger the value, the more error is allowed. A 0 value means that two numbers must be exactly the same to be considered equal.
The machine epsilon has to be scaled to the magnitude of the values used and multiplied by the desired precision in ULPs unless the difference is subnormal.
func sgn(x: T): int64
Sign function.
Returns:
- -1 for negative numbers and NegInf,
- 1 for positive numbers and Inf,
- 0 for positive zero, negative zero and NaN
func frexp(x: T): tuple[frac: T, exp: int64]
Splits x into a normalized fraction frac and an integral power of 2 exp, such that abs(frac) in 0.5..<1 and x == frac * 2 ^ exp, except for special cases shown below.
func floor(x: float32): float32
func floor(x: float64): float64
Computes the floor function (i.e. the largest integer not greater than x).
See also:
func ceil(x: float32): float32
func ceil(x: float64): float64
Computes the ceiling function (i.e. the smallest integer not smaller than x).
See also:
func round(x: float32): float32
func round(x: float64): float64
Returns the nearest integer value to x, rounding halfway cases away from zero.
See also:
func trunc(x: float32): float32
func trunc(x: float64): float64
Returns the nearest integer not greater in magnitude than x.
See also:
func mod(x: float32; y: float32): float32
func mod(x: float64; y: float64): float64
Computes the modulo operation for float values (the remainder of x divided by y).
See also:
- floorMod func for Python-like (% operator) behavior
func floorMod(x: T; y: T): T
Floor modulo is conceptually defined as x - (floorDiv(x, y) * y).
This func behaves the same as the % operator in Python.
See also:
- mod func
- floorDiv func
func floorDiv(x: T; y: T): T
Floor division is conceptually defined as floor(x / y).
This is different from the system.div operator, which is defined as trunc(x / y). That is, div rounds towards 0 and floorDiv rounds down.
See also:
- system.div func for integer division
- floorMod func for Python-like (% operator) behavior
func euclDiv(x: T; y: T): T
Returns euclidean division of x by y.
func euclMod(x: T; y: T): T
Returns euclidean modulo of x by y. euclMod(x, y) is non-negative.
func ceilDiv(x: T; y: T): T
Ceil division is conceptually defined as ceil(x / y).
Assumes x >= 0 and y > 0 (and x + y - 1 <= high(T) if T is SomeUnsignedInt).
This is different from the system.div operator, which works like trunc(x / y). That is, div rounds towards 0 and ceilDiv rounds up.
This function has the above input limitation, because that allows the compiler to generate faster code and it is rarely used with negative values or unsigned integers close to high(T)/2. If you need a ceilDiv that works with any input, see: https://github.com/demotomohiro/divmath.
See also:
- system.div func for integer division
- floorDiv func for integer division which rounds down.
func divmod(x: T; y: T): tuple[T, T]
Computes both division and modulus. Return structure is: (quotient, remainder)
func sum(x: openArray[T]): T
Computes the sum of the elements in x.
If x is empty, 0 is returned.
See also:
- prod func
func cumsum(x: var openArray[T])
Transforms x in-place (must be declared as var) into its cumulative (aka prefix) summation.
See also:
- sum func
- cumsummed func for a version which
returns a cumsummed sequence
func prod(x: openArray[T]): T
Computes the product of the elements in x.
If x is empty, 1 is returned.
See also:
- sum func
- fac func
func cumprod(x: var openArray[T])
Transforms x in-place (must be declared as var) into its product.
See also:
- prod func
- cumproded func for a version which
returns cumproded sequence
func sqrt(x: float32): float32
func sqrt(x: float64): float64
Computes the square root of x.
See also:
- cbrt func for the cube root
func cbrt(x: float32): float32
func cbrt(x: float64): float64
Computes the cube root of x.
See also:
- sqrt func for the square root
func pow(x: float32; y: float32): float32
func pow(x: float64; y: float64): float64
Computes x raised to the power of y.
You may use the ^ func instead.
See also:
func hypot(x: float32; y: float32): float32
func hypot(x: float64; y: float64): float64
Computes the length of the hypotenuse of a right-angle triangle with x as its base and y as its height. Equivalent to sqrt(x*x + y*y).
func exp(x: float32): float32
func exp(x: float64): float64
Computes the exponential function of x (e^x).
See also:
- ln func
func ln(x: float32): float32
func ln(x: float64): float64
Computes the natural logarithm of x.
See also:
func log2(x: float32): float32
func log2(x: float64): float64
Computes the binary logarithm (base 2) of x.
See also:
func log10(x: float32): float32
func log10(x: float64): float64
Computes the common logarithm (base 10) of x.
See also:
func log1p(x: float32): float32
func log1p(x: float64): float64
Computes the natural logarithm of 1 + x.
See also:
func log(x: T; base: T): T
Computes the logarithm of x to base base.
See also:
func ^(x: T; y: int64): T
Computes x to the power of y.
The exponent y must be non-negative, use pow for negative exponents.
See also:
- ^ func for negative exponent or floats
- pow func for float32 or float64 output
- sqrt func
- cbrt func
func isPowerOfTwo(x: int64): bool
Returns true, if x is a power of two, false otherwise.
Zero and negative numbers are not a power of two.
See also:
- nextPowerOfTwo func
func nextPowerOfTwo(x: int64): int64
Returns x rounded up to the nearest power of two.
Zero and negative numbers get rounded up to 1.
See also:
- isPowerOfTwo func
func degToRad(d: T): T
Converts from degrees to radians.
See also:
- radToDeg func
func radToDeg(r: T): T
Converts from radians to degrees.
See also:
- degToRad func
func sin(x: float32): float32
func sin(x: float64): float64
Computes the sine of x.
See also:
- arcsin func
func cos(x: float32): float32
func cos(x: float64): float64
Computes the cosine of x.
See also:
- arccos func
func tan(x: float32): float32
func tan(x: float64): float64
Computes the tangent of x.
See also:
- arctan func
func arcsin(x: float32): float32
func arcsin(x: float64): float64
Computes the arc sine of x.
See also:
- sin func
func arccos(x: float32): float32
func arccos(x: float64): float64
Computes the arc cosine of x.
See also:
- cos func
func arctan(x: float32): float32
func arctan(x: float64): float64
Calculate the arc tangent of x.
See also:
- arctan2 func
- tan func
func arctan2(y: float32; x: float32): float32
func arctan2(y: float64; x: float64): float64
Calculate the arc tangent of y/x.
It produces correct results even when the resulting angle is near PI/2 or -PI/2 (x near 0).
See also:
- arctan func
func sinh(x: float32): float32
func sinh(x: float64): float64
Computes the hyperbolic sine of x.
See also:
- arcsinh func
func cosh(x: float32): float32
func cosh(x: float64): float64
Computes the hyperbolic cosine of x.
See also:
- arccosh func
func tanh(x: float32): float32
func tanh(x: float64): float64
Computes the hyperbolic tangent of x.
See also:
- arctanh func
func arcsinh(x: float32): float32
func arcsinh(x: float64): float64
Computes the inverse hyperbolic sine of x.
See also:
- sinh func
func arccosh(x: float32): float32
func arccosh(x: float64): float64
Computes the inverse hyperbolic cosine of x.
See also:
- cosh func
func arctanh(x: float32): float32
func arctanh(x: float64): float64
Computes the inverse hyperbolic tangent of x.
See also:
- tanh func
func erf(x: float32): float32
func erf(x: float64): float64
Computes the error function for x.
func erfc(x: float32): float32
func erfc(x: float64): float64
Computes the complementary error function for x.
func gamma(x: float32): float32
func gamma(x: float64): float64
Computes the gamma function for x.
See also:
- lgamma func for the natural logarithm of the gamma function
func lgamma(x: float32): float32
func lgamma(x: float64): float64
Computes the natural logarithm of the gamma function for x.
See also:
- gamma func for gamma function
func cot(x: float32): float32
func cot(x: float64): float64
func sec(x: float32): float32
func sec(x: float64): float64
func csc(x: float32): float32
func csc(x: float64): float64
func coth(x: float32): float32
func coth(x: float64): float64
func sech(x: float32): float32
func sech(x: float64): float64
func csch(x: float32): float32
func csch(x: float64): float64
func arccot(x: float32): float32
func arccot(x: float64): float64
func arcsec(x: float32): float32
func arcsec(x: float64): float64
func arccsc(x: float32): float32
func arccsc(x: float64): float64
func arccoth(x: float32): float32
func arccoth(x: float64): float64
func arcsech(x: float32): float32
func arcsech(x: float64): float64
func arccsch(x: float32): float32
func arccsch(x: float64): float64
func splitDecimal(x: T): tuple[intpart: T, floatpart: T]
Breaks x into an integer and a fractional part.
Returns a tuple containing intpart and floatpart, representing the integer part and the fractional part, respectively.
Both parts have the same sign as x. Analogous to the modf function in C.
func fac(n: int64): int64
Computes the factorial of a non-negative integer n.
See also:
- prod func
func binom(n: int64; k: int64): int64
Computes the binomial coefficient.
func gcd(x: T; y: T): T
Computes the greatest common (positive) divisor of x and y.
Note that for floats, the result cannot always be interpreted as "greatest decimal z such that z*N == x and z*M == y where N and M are positive integers".
See also:
- gcd func for an integer version
- lcm func
func gcd(x: openArray[T]): T
Computes the greatest common (positive) divisor of the elements of x.
See also:
- gcd func for a version with two arguments
func lcm(x: T; y: T): T
Computes the least common multiple of x and y.
See also:
- gcd func
func lcm(x: openArray[T]): T
Computes the least common multiple of the elements of x.
See also:
- lcm func for a version with two arguments