math

Constructive mathematics is naturally typed. -- Simon Thompson

Basic math routines for Nim.

Note that the trigonometric functions naturally operate on radians. The helper functions degToRad and radToDeg provide conversion between radians and degrees.

import math
from sequtils import map

let a = [0.0, PI/6, PI/4, PI/3, PI/2]

echo a.map(sin)
# @[0.0, 0.499…, 0.707…, 0.866…, 1.0]

echo a.map(tan)
# @[0.0, 0.577…, 0.999…, 1.732…, 1.633…e+16]

echo cos(degToRad(180.0))
# -1.0

echo sqrt(-1.0)
# nan   (use `complex` module)

This module is available for the JavaScript target.

関連:

  • complex module for complex numbers and their mathematical operations
  • rationals module for rational numbers and their mathematical operations
  • fenv module for handling of floating-point rounding and exceptions (overflow, zero-divide, etc.)
  • random module for fast and tiny random number generator
  • mersenne module for Mersenne twister random number generator
  • stats module for statistical analysis
  • strformat module for formatting floats for print
  • system module Some very basic and trivial math operators are on system directly, to name a few shr, shl, xor, clamp, etc.

FloatClass = enum
  fcNormal,                   ## value is an ordinary nonzero floating point value
  fcSubnormal,                ## value is a subnormal (a very small) floating point value
  fcZero,                     ## value is zero
  fcNegZero,                  ## value is the negative zero
  fcNan,                      ## value is Not-A-Number (NAN)
  fcInf,                      ## value is positive infinity
  fcNegInf                    ## value is negative infinity
Describes the class a floating point value belongs to. This is the type that is returned by classify proc.   ソース 編集

定数

PI = 3.141592653589793
The circle constant PI (Ludolph's number)   Source Edit
TAU = 6.283185307179586
The circle constant TAU (= 2 * PI)   Source Edit
E = 2.718281828459045
Euler's number   Source Edit
MaxFloat64Precision = 16
Maximum number of meaningful digits after the decimal point for Nim's float64 type.   ソース 編集
MaxFloat32Precision = 8
Maximum number of meaningful digits after the decimal point for Nim's float32 type.   ソース 編集
MaxFloatPrecision = 16
Maximum number of meaningful digits after the decimal point for Nim's float type.   ソース 編集

プロシージャ

proc binom(n, k: int): int {...}{.noSideEffect, raises: [], tags: [].}
Computes the binomial coefficient.

用例:

doAssert binom(6, 2) == binom(6, 4)
doAssert binom(6, 2) == 15
doAssert binom(-6, 2) == 1
doAssert binom(6, 0) == 1
  ソース 編集
proc fac(n: int): int {...}{.raises: [], tags: [].}

Computes the factorial of a non-negative integer n.

関連:

用例:

doAssert fac(3) == 6
doAssert fac(4) == 24
doAssert fac(10) == 3628800
  ソース 編集
proc classify(x: float): FloatClass {...}{.raises: [], tags: [].}

Classifies a floating point value.

Returns x's class as specified by FloatClass enum.

用例:

doAssert classify(0.3) == fcNormal
doAssert classify(0.0) == fcZero
doAssert classify(0.3 / 0.0) == fcInf
doAssert classify(-0.3 / 0.0) == fcNegInf
  ソース 編集
proc isPowerOfTwo(x: int): bool {...}{.noSideEffect, raises: [], tags: [].}

Returns true, if x is a power of two, false otherwise.

Zero and negative numbers are not a power of two.

関連:

用例:

doAssert isPowerOfTwo(16) == true
doAssert isPowerOfTwo(5) == false
doAssert isPowerOfTwo(0) == false
doAssert isPowerOfTwo(-16) == false
  ソース 編集
proc nextPowerOfTwo(x: int): int {...}{.noSideEffect, raises: [], tags: [].}

Returns x rounded up to the nearest power of two.

Zero and negative numbers get rounded up to 1.

関連:

用例:

doAssert nextPowerOfTwo(16) == 16
doAssert nextPowerOfTwo(5) == 8
doAssert nextPowerOfTwo(0) == 1
doAssert nextPowerOfTwo(-16) == 1
  ソース 編集
proc countBits32(n: int32): int {...}{.noSideEffect, deprecated: "Deprecated since v0.20.0; use \'bitops.countSetBits\' instead",
                              raises: [], tags: [].}
Deprecated: Deprecated since v0.20.0; use 'bitops.countSetBits' instead

用例:

doAssert countBits32(7) == 3
doAssert countBits32(8) == 1
doAssert countBits32(15) == 4
doAssert countBits32(16) == 1
doAssert countBits32(17) == 2
  ソース 編集
proc sum[T](x: openArray[T]): T {...}{.noSideEffect.}

Computes the sum of the elements in x.

If x is empty, 0 is returned.

関連:

用例:

doAssert sum([1, 2, 3, 4]) == 10
doAssert sum([-1.5, 2.7, -0.1]) == 1.1
  ソース 編集
proc prod[T](x: openArray[T]): T {...}{.noSideEffect.}

Computes the product of the elements in x.

If x is empty, 1 is returned.

関連:

用例:

doAssert prod([1, 2, 3, 4]) == 24
doAssert prod([-4, 3, 5]) == -60
  ソース 編集
proc cumsummed[T](x: openArray[T]): seq[T]

Return cumulative (aka prefix) summation of x.

関連:

用例:

let a = [1, 2, 3, 4]
doAssert cumsummed(a) == @[1, 3, 6, 10]
  ソース 編集
proc cumsum[T](x: var openArray[T])

Transforms x in-place (must be declared as var) into its cumulative (aka prefix) summation.

関連:

用例:

var a = [1, 2, 3, 4]
cumsum(a)
doAssert a == @[1, 3, 6, 10]
  ソース 編集
proc sqrt(x: float32): float32 {...}{.importc: "sqrtf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc sqrt(x: float64): float64 {...}{.importc: "sqrt", header: "<math.h>", noSideEffect.}

Computes the square root of x.

関連:

echo sqrt(4.0)  ## 2.0
echo sqrt(1.44) ## 1.2
echo sqrt(-4.0) ## nan
  ソース 編集
proc cbrt(x: float32): float32 {...}{.importc: "cbrtf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc cbrt(x: float64): float64 {...}{.importc: "cbrt", header: "<math.h>", noSideEffect.}

Computes the cubic root of x.

関連:

echo cbrt(8.0)   ## 2.0
echo cbrt(2.197) ## 1.3
echo cbrt(-27.0) ## -3.0
  ソース 編集
proc ln(x: float32): float32 {...}{.importc: "logf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc ln(x: float64): float64 {...}{.importc: "log", header: "<math.h>", noSideEffect.}

Computes the natural logarithm of x.

関連:

echo ln(exp(4.0)) ## 4.0
echo ln(1.0))     ## 0.0
echo ln(0.0)      ## -inf
echo ln(-7.0)     ## nan
  ソース 編集
proc log[T: SomeFloat](x, base: T): T {...}{.noSideEffect.}

Computes the logarithm of x to base base.

関連:

echo log(9.0, 3.0)  ## 2.0
echo log(32.0, 2.0) ## 5.0
echo log(0.0, 2.0)  ## -inf
echo log(-7.0, 4.0) ## nan
echo log(8.0, -2.0) ## nan
  ソース 編集
proc log10(x: float32): float32 {...}{.importc: "log10f", header: "<math.h>", noSideEffect.}
  ソース 編集
proc log10(x: float64): float64 {...}{.importc: "log10", header: "<math.h>", noSideEffect.}

Computes the common logarithm (base 10) of x.

関連:

echo log10(100.0)  ## 2.0
echo log10(0.0)    ## nan
echo log10(-100.0) ## -inf
  ソース 編集
proc exp(x: float32): float32 {...}{.importc: "expf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc exp(x: float64): float64 {...}{.importc: "exp", header: "<math.h>", noSideEffect.}

Computes the exponential function of x (e^x).

関連:

echo exp(1.0)     ## 2.718281828459045
echo ln(exp(4.0)) ## 4.0
echo exp(0.0)     ## 1.0
echo exp(-1.0)    ## 0.3678794411714423
  ソース 編集
proc sin(x: float32): float32 {...}{.importc: "sinf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc sin(x: float64): float64 {...}{.importc: "sin", header: "<math.h>", noSideEffect.}

Computes the sine of x.

関連:

echo sin(PI / 6)         ## 0.4999999999999999
echo sin(degToRad(90.0)) ## 1.0
  ソース 編集
proc cos(x: float32): float32 {...}{.importc: "cosf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc cos(x: float64): float64 {...}{.importc: "cos", header: "<math.h>", noSideEffect.}

Computes the cosine of x.

関連:

echo cos(2 * PI)         ## 1.0
echo cos(degToRad(60.0)) ## 0.5000000000000001
  ソース 編集
proc tan(x: float32): float32 {...}{.importc: "tanf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc tan(x: float64): float64 {...}{.importc: "tan", header: "<math.h>", noSideEffect.}

Computes the tangent of x.

関連:

echo tan(degToRad(45.0)) ## 0.9999999999999999
echo tan(PI / 4)         ## 0.9999999999999999
  ソース 編集
proc sinh(x: float32): float32 {...}{.importc: "sinhf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc sinh(x: float64): float64 {...}{.importc: "sinh", header: "<math.h>", noSideEffect.}

Computes the hyperbolic sine of x.

関連:

echo sinh(0.0)            ## 0.0
echo sinh(1.0)            ## 1.175201193643801
echo sinh(degToRad(90.0)) ## 2.301298902307295
  ソース 編集
proc cosh(x: float32): float32 {...}{.importc: "coshf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc cosh(x: float64): float64 {...}{.importc: "cosh", header: "<math.h>", noSideEffect.}

Computes the hyperbolic cosine of x.

関連:

echo cosh(0.0)            ## 1.0
echo cosh(1.0)            ## 1.543080634815244
echo cosh(degToRad(90.0)) ## 2.509178478658057
  ソース 編集
proc tanh(x: float32): float32 {...}{.importc: "tanhf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc tanh(x: float64): float64 {...}{.importc: "tanh", header: "<math.h>", noSideEffect.}

Computes the hyperbolic tangent of x.

関連:

echo tanh(0.0)            ## 0.0
echo tanh(1.0)            ## 0.7615941559557649
echo tanh(degToRad(90.0)) ## 0.9171523356672744
  ソース 編集
proc arccos(x: float32): float32 {...}{.importc: "acosf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc arccos(x: float64): float64 {...}{.importc: "acos", header: "<math.h>", noSideEffect.}

Computes the arc cosine of x.

関連:

echo radToDeg(arccos(0.0)) ## 90.0
echo radToDeg(arccos(1.0)) ## 0.0
  ソース 編集
proc arcsin(x: float32): float32 {...}{.importc: "asinf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc arcsin(x: float64): float64 {...}{.importc: "asin", header: "<math.h>", noSideEffect.}

Computes the arc sine of x.

関連:

echo radToDeg(arcsin(0.0)) ## 0.0
echo radToDeg(arcsin(1.0)) ## 90.0
  ソース 編集
proc arctan(x: float32): float32 {...}{.importc: "atanf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc arctan(x: float64): float64 {...}{.importc: "atan", header: "<math.h>", noSideEffect.}

Calculate the arc tangent of x.

関連:

echo arctan(1.0) ## 0.7853981633974483
echo radToDeg(arctan(1.0)) ## 45.0
  ソース 編集
proc arctan2(y, x: float32): float32 {...}{.importc: "atan2f", header: "<math.h>",
                                  noSideEffect.}
  ソース 編集
proc arctan2(y, x: float64): float64 {...}{.importc: "atan2", header: "<math.h>", noSideEffect.}

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).

関連:

echo arctan2(1.0, 0.0) ## 1.570796326794897
echo radToDeg(arctan2(1.0, 0.0)) ## 90.0
  ソース 編集
proc arcsinh(x: float32): float32 {...}{.importc: "asinhf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc arcsinh(x: float64): float64 {...}{.importc: "asinh", header: "<math.h>", noSideEffect.}
Computes the inverse hyperbolic sine of x.   ソース 編集
proc arccosh(x: float32): float32 {...}{.importc: "acoshf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc arccosh(x: float64): float64 {...}{.importc: "acosh", header: "<math.h>", noSideEffect.}
Computes the inverse hyperbolic cosine of x.   ソース 編集
proc arctanh(x: float32): float32 {...}{.importc: "atanhf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc arctanh(x: float64): float64 {...}{.importc: "atanh", header: "<math.h>", noSideEffect.}
Computes the inverse hyperbolic tangent of x.   ソース 編集
proc cot[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the cotangent of x (1 / tan(x)).   ソース 編集
proc sec[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the secant of x (1 / cos(x)).   ソース 編集
proc csc[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the cosecant of x (1 / sin(x)).   ソース 編集
proc coth[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the hyperbolic cotangent of x (1 / tanh(x)).   ソース 編集
proc sech[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the hyperbolic secant of x (1 / cosh(x)).   ソース 編集
proc csch[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the hyperbolic cosecant of x (1 / sinh(x)).   ソース 編集
proc arccot[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the inverse cotangent of x.   ソース 編集
proc arcsec[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the inverse secant of x.   ソース 編集
proc arccsc[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the inverse cosecant of x.   ソース 編集
proc arccoth[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the inverse hyperbolic cotangent of x.   ソース 編集
proc arcsech[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the inverse hyperbolic secant of x.   ソース 編集
proc arccsch[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Computes the inverse hyperbolic cosecant of x.   ソース 編集
proc hypot(x, y: float32): float32 {...}{.importc: "hypotf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc hypot(x, y: float64): float64 {...}{.importc: "hypot", header: "<math.h>", noSideEffect.}
Computes the hypotenuse of a right-angle triangle with x and y as its base and height. Equivalent to sqrt(x*x + y*y).
echo hypot(4.0, 3.0) ## 5.0
  ソース 編集
proc pow(x, y: float32): float32 {...}{.importc: "powf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc pow(x, y: float64): float64 {...}{.importc: "pow", header: "<math.h>", noSideEffect.}

Computes x to power raised of y.

To compute power between integers (e.g. 2^6), use ^ proc.

関連:

echo pow(100, 1.5)  ## 1000.0
echo pow(16.0, 0.5) ## 4.0
  ソース 編集
proc erf(x: float32): float32 {...}{.importc: "erff", header: "<math.h>", noSideEffect.}
  ソース 編集
proc erf(x: float64): float64 {...}{.importc: "erf", header: "<math.h>", noSideEffect.}

Computes the error function for x.

Note: Not available for JS backend.

  ソース 編集
proc erfc(x: float32): float32 {...}{.importc: "erfcf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc erfc(x: float64): float64 {...}{.importc: "erfc", header: "<math.h>", noSideEffect.}

Computes the complementary error function for x.

Note: Not available for JS backend.

  ソース 編集
proc gamma(x: float32): float32 {...}{.importc: "tgammaf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc gamma(x: float64): float64 {...}{.importc: "tgamma", header: "<math.h>", noSideEffect.}

Computes the the gamma function for x.

Note: Not available for JS backend.

関連:

echo gamma(1.0)  # 1.0
echo gamma(4.0)  # 6.0
echo gamma(11.0) # 3628800.0
echo gamma(-1.0) # nan
  ソース 編集
proc tgamma(x: float32): float32 {...}{.deprecated: "Deprecated since v0.19.0; use \'gamma\' instead",
                               importc: "tgammaf", header: "<math.h>", noSideEffect.}
Deprecated: Deprecated since v0.19.0; use 'gamma' instead
  ソース 編集
proc tgamma(x: float64): float64 {...}{.deprecated: "Deprecated since v0.19.0; use \'gamma\' instead",
                               importc: "tgamma", header: "<math.h>", noSideEffect.}
Deprecated: Deprecated since v0.19.0; use 'gamma' instead
The gamma function   Source Edit
proc lgamma(x: float32): float32 {...}{.importc: "lgammaf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc lgamma(x: float64): float64 {...}{.importc: "lgamma", header: "<math.h>", noSideEffect.}

Computes the natural log of the gamma function for x.

Note: Not available for JS backend.

関連:

echo lgamma(1.0)  # 1.0
echo lgamma(4.0)  # 1.791759469228055
echo lgamma(11.0) # 15.10441257307552
echo lgamma(-1.0) # inf
  ソース 編集
proc floor(x: float32): float32 {...}{.importc: "floorf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc floor(x: float64): float64 {...}{.importc: "floor", header: "<math.h>", noSideEffect.}

Computes the floor function (i.e., the largest integer not greater than x).

関連:

echo floor(2.1)  ## 2.0
echo floor(2.9)  ## 2.0
echo floor(-3.5) ## -4.0
  ソース 編集
proc ceil(x: float32): float32 {...}{.importc: "ceilf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc ceil(x: float64): float64 {...}{.importc: "ceil", header: "<math.h>", noSideEffect.}

Computes the ceiling function (i.e., the smallest integer not smaller than x).

関連:

echo ceil(2.1)  ## 3.0
echo ceil(2.9)  ## 3.0
echo ceil(-2.1) ## -2.0
  ソース 編集
proc round(x: float32): float32 {...}{.importc: "roundf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc round(x: float64): float64 {...}{.importc: "round", header: "<math.h>", noSideEffect.}

Rounds a float to zero decimal places.

Used internally by the round proc when the specified number of places is 0.

関連:

echo round(3.4) ## 3.0
echo round(3.5) ## 4.0
echo round(4.5) ## 5.0
  ソース 編集
proc trunc(x: float32): float32 {...}{.importc: "truncf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc trunc(x: float64): float64 {...}{.importc: "trunc", header: "<math.h>", noSideEffect.}

Truncates x to the decimal point.

関連:

echo trunc(PI) # 3.0
echo trunc(-1.85) # -1.0
  ソース 編集
proc fmod(x, y: float32): float32 {...}{.deprecated: "Deprecated since v0.19.0; use \'mod\' instead",
                               importc: "fmodf", header: "<math.h>", noSideEffect.}
Deprecated: Deprecated since v0.19.0; use 'mod' instead
  ソース 編集
proc fmod(x, y: float64): float64 {...}{.deprecated: "Deprecated since v0.19.0; use \'mod\' instead",
                               importc: "fmod", header: "<math.h>", noSideEffect.}
Deprecated: Deprecated since v0.19.0; use 'mod' instead
Computes the remainder of x divided by y.   ソース 編集
proc `mod`(x, y: float32): float32 {...}{.importc: "fmodf", header: "<math.h>", noSideEffect.}
  ソース 編集
proc `mod`(x, y: float64): float64 {...}{.importc: "fmod", header: "<math.h>", noSideEffect.}

Computes the modulo operation for float values (the remainder of x divided by y).

関連:

( 6.5 mod  2.5) ==  1.5
(-6.5 mod  2.5) == -1.5
( 6.5 mod -2.5) ==  1.5
(-6.5 mod -2.5) == -1.5
  ソース 編集
proc round[T: float32 | float64](x: T; places: int): T {...}{.
    deprecated: "use strformat module instead", noSideEffect.}
Deprecated: use strformat module instead

Decimal rounding on a binary floating point number.

This function is NOT reliable. Floating point numbers cannot hold non integer decimals precisely. If places is 0 (or omitted), round to the nearest integral value following normal mathematical rounding rules (e.g. round(54.5) -> 55.0). If places is greater than 0, round to the given number of decimal places, e.g. round(54.346, 2) -> 54.350000000000001421…. If places is negative, round to the left of the decimal place, e.g. round(537.345, -1) -> 540.0

echo round(PI, 2) ## 3.14
echo round(PI, 4) ## 3.1416
  ソース 編集
proc floorDiv[T: SomeInteger](x, y: T): T {...}{.noSideEffect.}

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.

関連:

echo floorDiv( 13,  3) #  4
echo floorDiv(-13,  3) # -5
echo floorDiv( 13, -3) # -5
echo floorDiv(-13, -3) #  4
  ソース 編集
proc floorMod[T: SomeNumber](x, y: T): T {...}{.noSideEffect.}

Floor modulus is conceptually defined as x - (floorDiv(x, y) * y).

This proc behaves the same as the % operator in Python.

関連:

echo floorMod( 13,  3) #  1
echo floorMod(-13,  3) #  2
echo floorMod( 13, -3) # -2
echo floorMod(-13, -3) # -1
  ソース 編集
proc c_frexp(x: float32; exponent: var int32): float32 {...}{.importc: "frexp",
    header: "<math.h>", noSideEffect.}
  ソース 編集
proc c_frexp(x: float64; exponent: var int32): float64 {...}{.importc: "frexp",
    header: "<math.h>", noSideEffect.}
  ソース 編集
proc frexp[T, U](x: T; exponent: var U): T {...}{.noSideEffect.}

Split a number into mantissa and exponent.

frexp calculates the mantissa m (a float greater than or equal to 0.5 and less than 1) and the integer value n such that x (the original float value) equals m * 2**n. frexp stores n in exponent and returns m.

var x: int
echo frexp(5.0, x) # 0.625
echo x # 3
  ソース 編集
proc log2(x: float32): float32 {...}{.importc: "log2f", header: "<math.h>", noSideEffect.}
  ソース 編集
proc log2(x: float64): float64 {...}{.importc: "log2", header: "<math.h>", noSideEffect.}

Computes the binary logarithm (base 2) of x.

関連:

echo log2(8.0)  # 3.0
echo log2(1.0)  # 0.0
echo log2(0.0)  # -inf
echo log2(-2.0) # nan
  ソース 編集
proc splitDecimal[T: float32 | float64](x: T): tuple[intpart: T, floatpart: T] {...}{.
    noSideEffect.}

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.

echo splitDecimal(5.25)  # (intpart: 5.0, floatpart: 0.25)
echo splitDecimal(-2.73) # (intpart: -2.0, floatpart: -0.73)
  ソース 編集
proc degToRad[T: float32 | float64](d: T): T {...}{.inline.}

Convert from degrees to radians.

関連:

echo degToRad(180.0) # 3.141592653589793
  ソース 編集
proc radToDeg[T: float32 | float64](d: T): T {...}{.inline.}

Convert from radians to degrees.

関連:

echo degToRad(2 * PI) # 360.0
  ソース 編集
proc sgn[T: SomeNumber](x: T): int {...}{.inline.}

Sign function.

Returns:

  • -1 for negative numbers and NegInf,
  • 1 for positive numbers and Inf,
  • 0 for positive zero, negative zero and NaN
echo sgn(5)    # 1
echo sgn(0)    # 0
echo sgn(-4.1) # -1
  ソース 編集
proc `^`[T](x: T; y: Natural): T

Computes x to the power y.

Exponent y must be non-negative, use pow proc for negative exponents.

関連:

用例:

assert -3.0 ^ 0 == 1.0
assert -3 ^ 1 == -3
assert -3 ^ 2 == 9
assert -3.0 ^ 3 == -27.0
assert -3.0 ^ 4 == 81.0
  ソース 編集
proc gcd[T](x, 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."

関連:

用例:

doAssert gcd(13.5, 9.0) == 4.5
  ソース 編集
proc gcd(x, y: SomeInteger): SomeInteger

Computes the greatest common (positive) divisor of x and y, using binary GCD (aka Stein's) algorithm.

関連:

用例:

doAssert gcd(12, 8) == 4
doAssert gcd(17, 63) == 1
  ソース 編集
proc lcm[T](x, y: T): T

Computes the least common multiple of x and y.

関連:

用例:

doAssert lcm(24, 30) == 120
doAssert lcm(13, 39) == 39
  ソース 編集