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: [].}
-
用例:
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.
関連:
- sum proc
- cumsum proc for the in-place version
用例:
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.
関連:
- sum proc
- cumsummed proc for a version which returns cumsummed sequence
用例:
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.
関連:
- cbrt proc for cubic root
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.
関連:
- sqrt proc for square root
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.
関連:
- lgamma proc for a natural log of gamma function
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.}
- ソース 編集
proc tgamma(x: float64): float64 {...}{.deprecated: "Deprecated since v0.19.0; use \'gamma\' instead", importc: "tgamma", header: "<math.h>", noSideEffect.}
- Source Edit The gamma function
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.
関連:
- gamma proc for gamma function
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.
関連:
- round proc for rounding to the specific number of decimal places
- floor proc
- ceil proc
- trunc proc
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.}
- ソース 編集
proc fmod(x, y: float64): float64 {...}{.deprecated: "Deprecated since v0.19.0; use \'mod\' instead", importc: "fmod", header: "<math.h>", noSideEffect.}
- x divided by y. ソース 編集 Computes the remainder of
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).
関連:
- floorMod proc for Python-like (% operator) behavior
( 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.}
-
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.
関連:
- system.div proc for integer division
- floorMod proc for Python-like (% operator) behavior
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
ソース 編集