Spec-Zone.ru › Nim 1

math

Конструктивная математика естественным образом типизирована. -- Simon Thompson

Базовые математические функции для Nim.

Обратите внимание, что тригонометрические функции естественным образом работают с радианами. Вспомогательные функции degToRad и radToDeg обеспечивают преобразование между радианами и градусами.

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)

Этот модуль доступен для целевой платформы JavaScript.

См. также:

  • модуль complex для комплексных чисел и их математических операций
  • модуль rationals для рациональных чисел и их математических операций
  • модуль fenv для обработки округления чисел с плавающей запятой и исключений (переполнение, деление на ноль и т. д.)
  • модуль random для быстрого и компактного генератора случайных чисел
  • модуль mersenne для генератора случайных чисел Mersenne Twister
  • модуль stats для статистического анализа
  • модуль strformat для форматирования чисел с плавающей запятой для вывода
  • модуль system Некоторые очень базовые и тривиальные математические операторы находятся непосредственно в модуле system, например shr, shl, xor, clamp, и т.д.

Импорты

since, bitops

Типы

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
Описывает класс, к которому принадлежит значение с плавающей запятой. Это тип, возвращаемый процедурой classify proc. Исходный код Редактировать

Константы

PI = 3.141592653589793
Постоянная числа π (число Людольфа) Исходный код Редактировать 
TAU = 6.283185307179586
Постоянная числа Т ( = 2 * π) Исходный код Редактировать 
E = 2.718281828459045
Число Эйлера Исходный код Редактировать 
MaxFloat64Precision = 16
Максимальное количество значащих цифр после запятой для типа Nim float64. Исходный код Редактировать 
MaxFloat32Precision = 8
Максимальное количество значащих цифр после запятой для типа Nim float32. Исходный код Редактировать 
MaxFloatPrecision = 16
Максимальное количество значащих цифр после запятой для типа Nim float. Исходный код Редактировать 
MinFloatNormal = 2.225073858507201e-308
Наименьшее нормализованное число для типа Nim float (= 2^-1022). Исходный код Редактировать

Процедуры

proc binom(n, k: int): int {...}{.noSideEffect, raises: [], tags: [].}
Вычисляет биномиальный коэффициент.

Пример:

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: [].}

Вычисляет факториал неотрицательного целого числа n.

См. также:

  • prod proc

Пример:

doAssert fac(3) == 6
doAssert fac(4) == 24
doAssert fac(10) == 3628800
Исходный код Изменить 
proc classify(x: float): FloatClass {...}{.raises: [], tags: [].}

Классифицирует значение с плавающей точкой.

Возвращает класс значения x согласно перечислению FloatClass.

Пример:

doAssert classify(0.3) == fcNormal
doAssert classify(0.0) == fcZero
doAssert classify(0.3/0.0) == fcInf
doAssert classify(-0.3/0.0) == fcNegInf
doAssert classify(5.0e-324) == fcSubnormal
Исходный код Изменить 
proc isPowerOfTwo(x: int): bool {...}{.noSideEffect, raises: [], tags: [].}

Возвращает true, если x является степенью двойки, false в противном случае.

Нулевые и отрицательные числа не являются степенями двойки.

См. также:

  • nextPowerOfTwo proc

Пример:

doAssert isPowerOfTwo(16) == true
doAssert isPowerOfTwo(5) == false
doAssert isPowerOfTwo(0) == false
doAssert isPowerOfTwo(-16) == false
Исходный код Изменить 
proc nextPowerOfTwo(x: int): int {...}{.noSideEffect, raises: [], tags: [].}

Возвращает x, округлённое до ближайшей степени двойки.

Нулевые и отрицательные числа округляются до 1.

См. также:

  • isPowerOfTwo proc

Пример:

doAssert nextPowerOfTwo(16) == 16
doAssert nextPowerOfTwo(5) == 8
doAssert nextPowerOfTwo(0) == 1
doAssert nextPowerOfTwo(-16) == 1
Исходный код Изменить 
proc sum[T](x: openArray[T]): T {...}{.noSideEffect.}

Вычисляет сумму элементов в x.

Если x пуста, возвращается 0.

См. также:

  • prod proc
  • cumsum proc
  • cumsummed proc

Пример:

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

Вычисляет произведение элементов в x.

Если x пуста, возвращается 1.

См. также:

  • sum proc
  • fac proc

Пример:

doAssert prod([1, 2, 3, 4]) == 24
doAssert prod([-4, 3, 5]) == -60
Исходный код Изменить 
proc cumsummed[T](x: openArray[T]): seq[T]

Возвращает кумулятивное (префиксное) суммирование x.

См. также:

  • sum proc
  • cumsum proc для варианта in-place

Пример:

let a = [1, 2, 3, 4]
doAssert cumsummed(a) == @[1, 3, 6, 10]
Исходный код Изменить 
proc cumsum[T](x: var openArray[T])

Преобразует x in-place (должна быть объявлена как var ) в её кумулятивное (префиксное) суммирование.

См. также:

  • sum proc
  • cumsummed proc для варианта, возвращающего последовательность cumsum

Пример:

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

Вычисляет квадратный корень из x.

См. также:

  • cbrt proc для кубического корня
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.}

Вычисляет кубический корень из x.

См. также:

  • sqrt proc для квадратного корня
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.}

Вычисляет натуральный логарифм x.

См. также:

  • log proc
  • log10 proc
  • log2 proc
  • exp proc
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.}

Вычисляет логарифм x по основанию base.

См. также:

  • ln proc
  • log10 proc
  • log2 proc
  • exp proc
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.}

Вычисляет десятичный логарифм (основание 10) x.

См. также:

  • ln proc
  • log proc
  • log2 proc
  • exp proc
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.}

Вычисляет экспоненциальную функцию от x (e^x).

См. также:

  • ln proc
  • log proc
  • log10 proc
  • log2 proc
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.}

Вычисляет синус от x.

См. также:

  • cos proc
  • tan proc
  • arcsin proc
  • sinh proc
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.}

Вычисляет косинус от x.

См. также:

  • sin proc
  • tan proc
  • arccos proc
  • cosh proc
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.}

Вычисляет тангенс от x.

См. также:

  • функцию sin
  • функцию cos
  • функцию arctan
  • функцию tanh
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.}

Вычисляет гиперболический синус от x.

См. также:

  • функцию cosh
  • функцию tanh
  • функцию arcsinh
  • функцию sin
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.}

Вычисляет гиперболический косинус от x.

См. также:

  • функцию sinh
  • функцию tanh
  • функцию arccosh
  • функцию cos
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.}

Вычисляет гиперболический тангенс от x.

См. также:

  • функцию sinh
  • функцию cosh
  • функцию arctanh
  • функцию tan
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.}

Вычисляет арккосинус от x.

См. также:

  • функцию arcsin
  • функцию arctan
  • функцию arctan2
  • функцию cos
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.}

Вычисляет арксинус от x.

См. также:

  • функцию arccos
  • функцию arctan
  • функцию arctan2
  • функцию sin
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.}

Вычисляет арктангенс от x.

См. также:

  • функцию arcsin
  • функцию arccos
  • функцию arctan2
  • функцию tan
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.}

Вычисляет арктангенс от y / x.

Возвращает корректные результаты даже при значениях угла, близких к pi/2 или -pi/2 (x близко к 0).

См. также:

  • функцию arcsin
  • функцию arccos
  • функцию arctan
  • функцию tan
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.}
Вычисляет обратный гиперболический синус от x. Исходный код Изменить 
proc arccosh(x: float32): float32 {...}{.importc: "acoshf", header: "<math.h>",
                                    noSideEffect.}
Исходный код Изменить 
proc arccosh(x: float64): float64 {...}{.importc: "acosh", header: "<math.h>",
                                    noSideEffect.}
Вычисляет обратный гиперболический косинус от x. Исходный код Изменить 
proc arctanh(x: float32): float32 {...}{.importc: "atanhf", header: "<math.h>",
                                    noSideEffect.}
Исходный код Изменить 
proc arctanh(x: float64): float64 {...}{.importc: "atanh", header: "<math.h>",
                                    noSideEffect.}
Вычисляет обратный гиперболический тангенс от x. Исходный код Изменить 
proc cot[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет котангенс от x (1 / tan(x)). Исходный код Изменить 
proc sec[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет секанс от x (1 / cos(x)). Исходный код Изменить 
proc csc[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет косеканс от x (1 / sin(x)). Исходный код Изменить 
proc coth[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет гиперболический котангенс от x (1 / tanh(x)). Исходный код Изменить 
proc sech[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет гиперболический секанс от x (1 / cosh(x)). Исходный код Изменить 
proc csch[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет гиперболический косеканс от x (1 / sinh(x)). Исходный код Изменить 
proc arccot[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет обратный котангенс от x. Исходный код Изменить 
proc arcsec[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет обратный секанс от x. Исходный код Изменить 
proc arccsc[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет обратный косеканс от x. Исходный код Изменить 
proc arccoth[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет обратный гиперболический котангенс от x. Исходный код Изменить 
proc arcsech[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет обратную гиперболическую секанс x. Исходный код Редактировать 
proc arccsch[T: float32 | float64](x: T): T {...}{.noSideEffect.}
Вычисляет обратную гиперболическую косеканс 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.}
Вычисляет гипотенузу прямоугольного треугольника с x и y в качестве основания и высоты. Эквивалентно 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.}

Вычисляет x в степени y.

Для вычисления степени целых чисел (например, 26) используйте ^ proc.

См. также:

  • ^ proc
  • sqrt proc
  • cbrt 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.}

Вычисляет функцию ошибки для x.

Примечание: Не доступно для JS бэкенда.

Исходный код Редактировать 
proc erfc(x: float32): float32 {...}{.importc: "erfcf", header: "<math.h>",
                                 noSideEffect.}
Исходный код Редактировать 
proc erfc(x: float64): float64 {...}{.importc: "erfc", header: "<math.h>",
                                 noSideEffect.}

Вычисляет дополнительную функцию ошибки для x.

Примечание: Не доступно для JS бэкенда.

Исходный код Редактировать 
proc gamma(x: float32): float32 {...}{.importc: "tgammaf", header: "<math.h>",
                                  noSideEffect.}
Исходный код Редактировать 
proc gamma(x: float64): float64 {...}{.importc: "tgamma", header: "<math.h>",
                                  noSideEffect.}

Вычисляет функцию гамма для x.

Примечание: Не доступно для JS бэкенда.

См. также:

  • lgamma proc для натурального логарифма функции гамма
echo gamma(1.0)  # 1.0
echo gamma(4.0)  # 6.0
echo gamma(11.0) # 3628800.0
echo gamma(-1.0) # nan
Исходный код Редактировать 
proc lgamma(x: float32): float32 {...}{.importc: "lgammaf", header: "<math.h>",
                                   noSideEffect.}
Исходный код Редактировать 
proc lgamma(x: float64): float64 {...}{.importc: "lgamma", header: "<math.h>",
                                   noSideEffect.}

Вычисляет натуральный логарифм функции гамма для x.

Примечание: Не доступно для JS бэкенда.

См. также:

  • gamma proc для функции гамма
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.}

Вычисляет функцию floor (т.е., наибольшее целое число, не большее чем x).

См. также:

  • ceil proc
  • round proc
  • trunc proc
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.}

Вычисляет функцию ceiling (т.е., наименьшее целое число, не меньшее чем x).

См. также:

  • floor proc
  • round proc
  • trunc proc
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.}

Округляет число с плавающей точкой до нуля знаков после запятой.

Используется внутри round proc, когда заданное число знаков после запятой равно 0.

См. также:

  • round proc для округления до заданного числа знаков после запятой
  • 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.}

Отбрасывает x после десятичной точки.

См. также:

  • floor proc
  • ceil proc
  • round proc
echo trunc(PI) # 3.0
echo trunc(-1.85) # -1.0
Исходный код Редактировать 
proc `mod`(x, y: float32): float32 {...}{.importc: "fmodf", header: "<math.h>",
                                     noSideEffect.}
Исходный код Редактировать 
proc `mod`(x, y: float64): float64 {...}{.importc: "fmod", header: "<math.h>",
                                     noSideEffect.}

Вычисляет операцию modulo для чисел с плавающей точкой (остаток от деления x на y).

См. также:

  • floorMod proc для поведения оператора % в Python
( 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 {...}{.noSideEffect.}

Десятичное округление двоичного числа с плавающей точкой.

Эта функция НЕ надёжна. Числа с плавающей точкой не могут точно хранить нецелые десятичные значения. Если places равно 0 (или опущено), округляется до ближайшего целого значения по обычным математическим правилам округления (например, round(54.5) -> 55.0). Если places больше 0, округляется до заданного числа знаков после запятой, например, round(54.346, 2) -> 54.350000000000001421…. Если places отрицательно, округляется до левой части десятичной точки, например, 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(x / y).

Это отличается от оператора system.div, который определяется как trunc(x / y). То есть, div округляется к 0, а floorDiv округляется вниз.

См. также:

  • system.div proc для целочисленного деления
  • floorMod proc для поведения оператора % в Python
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.}

Модуль по наименьшему целому концептуально определяется как x - (floorDiv(x, y) * y).

Эта процедура ведет себя так же, как оператор % в Python.

См. также:

  • mod proc
  • floorDiv proc
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.}

Разделить число на мантиссу и порядок.

frexp вычисляет мантиссу m (вещественное число, большее или равное 0,5 и меньшее 1) и целое значение n, такое что x (исходное вещественное значение) равно m * 2**n. frexp сохраняет n в exponent и возвращает m.

Пример:

var x: int
doAssert frexp(5.0, x) == 0.625
doAssert x == 3
Источник Изменить 
proc log2(x: float32): float32 {...}{.importc: "log2f", header: "<math.h>",
                                 noSideEffect.}
Источник Изменить 
proc log2(x: float64): float64 {...}{.importc: "log2", header: "<math.h>",
                                 noSideEffect.}

Вычисляет двоичный логарифм (основание 2) от x.

См. также:

  • лог процедура
  • log10 процедура
  • ln процедура
  • exp процедура
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.}

Разбивает x на целую и дробную части.

Возвращает кортеж, содержащий intpart и floatpart соответственно, представляющие целую и дробную части.

Обе части имеют тот же знак, что и x. Аналогично функции modf в C.

Пример:

doAssert splitDecimal(5.25) == (intpart: 5.0, floatpart: 0.25)
doAssert splitDecimal(-2.73) == (intpart: -2.0, floatpart: -0.73)
Источник Изменить 
proc degToRad[T: float32 | float64](d: T): T {...}{.inline.}

Преобразовать из градусов в радианы.

См. также:

  • radToDeg процедура

Пример:

doAssert degToRad(180.0) == 3.141592653589793
Источник Изменить 
proc radToDeg[T: float32 | float64](d: T): T {...}{.inline.}

Преобразовать из радиан в градусы.

См. также:

  • degToRad процедура

Пример:

doAssert radToDeg(2 * PI) == 360.0
Источник Изменить 
proc sgn[T: SomeNumber](x: T): int {...}{.inline.}

Функция знака.

Возвращает:

  • -1 для отрицательных чисел и NegInf,
  • 1 для положительных чисел и Inf,
  • 0 для положительного нуля, отрицательного нуля и NaN

Пример:

doAssert sgn(5) == 1
doAssert sgn(0) == 0
doAssert sgn(-4.1) == -1
Источник Изменить 
proc `^`[T: SomeNumber](x: T; y: Natural): T

Вычисляет x в степени y.

Экспонента y должна быть неотрицательной, используйте pow процедуру для отрицательных показателей.

См. также:

  • pow процедура для отрицательных показателей или вещественных чисел
  • sqrt процедура
  • cbrt процедура

Пример:

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

Вычисляет наибольший общий (положительный) делитель x и y.

Обратите внимание, что для вещественных чисел результат не всегда может быть интерпретирован как "наибольший десятичный z такой, что z*N == x and z*M == y, где N и M - положительные целые числа."

См. также:

  • gcd процедура для целочисленной версии
  • lcm процедура

Пример:

doAssert gcd(13.5, 9.0) == 4.5
Источник Изменить 
proc gcd(x, y: SomeInteger): SomeInteger

Вычисляет наибольший общий (положительный) делитель x и y, используя алгоритм бинарного НОД (также известный как алгоритм Штейна).

См. также:

  • gcd процедура для вещественной версии
  • lcm процедура

Пример:

doAssert gcd(12, 8) == 4
doAssert gcd(17, 63) == 1
Источник Изменить 
proc gcd[T](x: openArray[T]): T

Вычисляет наибольший общий (положительный) делитель элементов x.

См. также:

  • gcd процедура для целочисленной версии

Пример:

doAssert gcd(@[13.5, 9.0]) == 4.5
Источник Изменить 
proc lcm[T](x, y: T): T

Вычисляет наименьшее общее кратное x и y.

См. также:

  • gcd процедура

Пример:

doAssert lcm(24, 30) == 120
doAssert lcm(13, 39) == 39
Источник Изменить 
proc lcm[T](x: openArray[T]): T

Вычисляет наименьшее общее кратное элементов x.

См. также:

  • gcd процедура для целочисленной версии

Пример:

doAssert lcm(@[24, 30]) == 120
Источник Изменить

© 2006–2021 Andreas Rumpf
Licensed under the MIT License.
https://nim-lang.org/docs/math.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API