std/math

Конструктивная математика естественно типизирована. -- Саймон Томпсон

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

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

Пример:

import std/math
from std/fenv import epsilon
from std/random import rand

proc generateGaussianNoise(mu: float = 0.0, sigma: float = 1.0): (float, float) =
  # Generates values from a normal distribution.
  # Translated from https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform#Implementation.
  var u1: float
  var u2: float
  while true:
    u1 = rand(1.0)
    u2 = rand(1.0)
    if u1 > epsilon(float): break
  let mag = sigma * sqrt(-2 * ln(u1))
  let z0 = mag * cos(2 * PI * u2) + mu
  let z1 = mag * sin(2 * PI * u2) + mu
  (z0, z1)

echo generateGaussianNoise()

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

См. также

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

эта функция использует побитовые сравнения из компиляторов C, которые не всегда доступны.

Импорты

since, bitops, fenv, countbits_impl

Типы

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. Источник Редактировать

Константы

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

Процедуры

func `^`[T: SomeNumber](x: T; y: Natural): T: Вычисляет x в степени y.

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

См. также:

pow func для отрицательных показателей степени или чисел с плавающей точкой

sqrt func

cbrt func

Пример:

doAssert -3 ^ 0 == 1 doAssert -3 ^ 1 == -3 doAssert -3 ^ 2 == 9
Источник Редактировать
func almostEqual[T: SomeFloat](x, y: T; unitsInLastPlace: Natural = 4): bool {. inline.}: Проверяет, являются ли два значения с плавающей точкой почти равными, используя машинный эпсилон.

unitsInLastPlace — это максимальное количество единиц в последнем разряде разницы, допускаемой при сравнении двух чисел. Чем больше значение, тем больше допускается погрешность. Значение 0 означает, что два числа должны быть точно одинаковыми, чтобы считаться равными.

Машинный эпсилон должен быть масштабирован до величины используемых значений и умножен на желаемую точность в ULP, если только разница не является субнормальной.

Пример:

doAssert almostEqual(PI, 3.14159265358979) doAssert almostEqual(Inf, Inf) doAssert not almostEqual(NaN, NaN)
Источник Редактировать
func arccos(x: float32): float32 {.importc: "acosf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Источник Редактировать
func arccos(x: float64): float64 {.importc: "acos", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет арккосинус x.

См. также:

cos func

Пример:

doAssert almostEqual(radToDeg(arccos(0.0)), 90.0) doAssert almostEqual(radToDeg(arccos(1.0)), 0.0)
Источник Редактировать
func arccosh(x: float32): float32 {.importc: "acoshf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Источник Редактировать
func arccosh(x: float64): float64 {.importc: "acosh", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет обратный гиперболический косинус x.

См. также:

cosh func

Источник Редактировать
func arccot[T: float32 | float64](x: T): T: Вычисляет арккотангенс x (arctan(1/x)). Источник Редактировать
func arccoth[T: float32 | float64](x: T): T: Вычисляет обратный гиперболический котангенс x (arctanh(1/x)). Источник Редактировать
func arccsc[T: float32 | float64](x: T): T: Вычисляет арккосеканс x (arcsin(1/x)). Источник Редактировать
func arccsch[T: float32 | float64](x: T): T: Вычисляет обратный гиперболический косеканс x (arcsinh(1/x)). Источник Редактировать
func arcsec[T: float32 | float64](x: T): T: Вычисляет арксеканс x (arccos(1/x)). Источник Редактировать
func arcsech[T: float32 | float64](x: T): T: Вычисляет обратный гиперболический секанс x (arccosh(1/x)). Источник Редактировать
func arcsin(x: float32): float32 {.importc: "asinf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Источник Редактировать
func arcsin(x: float64): float64 {.importc: "asin", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет арксинус x.

См. также:

sin func

Пример:

doAssert almostEqual(radToDeg(arcsin(0.0)), 0.0) doAssert almostEqual(radToDeg(arcsin(1.0)), 90.0)
Источник Редактировать
func arcsinh(x: float32): float32 {.importc: "asinhf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Источник Редактировать
func arcsinh(x: float64): float64 {.importc: "asinh", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет обратный гиперболический синус x.

См. также:

sinh func

Источник Редактировать
func arctan(x: float32): float32 {.importc: "atanf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Источник Редактировать
func arctan(x: float64): float64 {.importc: "atan", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет арктангенс x.

См. также:

arctan2 func

tan func

Пример:

doAssert almostEqual(arctan(1.0), 0.7853981633974483) doAssert almostEqual(radToDeg(arctan(1.0)), 45.0)
Источник Редактировать
func arctan2(y, x: float32): float32 {.importc: "atan2f", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Источник Редактировать
func arctan2(y, x: float64): float64 {.importc: "atan2", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет арктангенс y/x.

Он выдает правильные результаты даже когда результирующий угол близок к PI/2 или -PI/2 (x близок к 0).

См. также:

arctan func

Пример:

doAssert almostEqual(arctan2(1.0, 0.0), PI / 2.0) doAssert almostEqual(radToDeg(arctan2(1.0, 0.0)), 90.0)
Источник Редактировать
func arctanh(x: float32): float32 {.importc: "atanhf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Источник Редактировать
func arctanh(x: float64): float64 {.importc: "atanh", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет обратный гиперболический тангенс x.

См. также:

tanh func

Источник Редактировать
func binom(n, k: int): int {....raises: [], tags: [], forbids: [].}: Вычисляет биномиальный коэффициент.
Пример:

doAssert binom(6, 2) == 15 doAssert binom(-6, 2) == 1 doAssert binom(6, 0) == 1
Источник Редактировать
func cbrt(x: float32): float32 {.importc: "cbrtf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Источник Редактировать
func cbrt(x: float64): float64 {.importc: "cbrt", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет кубический корень из x.

См. также:

sqrt func для квадратного корня

Пример:

doAssert almostEqual(cbrt(8.0), 2.0) doAssert almostEqual(cbrt(2.197), 1.3) doAssert almostEqual(cbrt(-27.0), -3.0)
Источник Редактировать

func ceil(x: float32): float32 {.importc: "ceilf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func ceil(x: float64): float64 {.importc: "ceil", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет функцию потолка (т.е. наименьшее целое число, не меньшее, чем x).

См. также:

функция floor

функция round

функция trunc

Пример:

doAssert ceil(2.1) == 3.0 doAssert ceil(2.9) == 3.0 doAssert ceil(-2.1) == -2.0
Исходный код Редактировать
func ceilDiv[T: SomeInteger](x, y: T): T {.inline.}: Целочисленное деление с округлением вверх концептуально определяется как ceil(x / y).

Предполагается x >= 0 и y > 0 (и x + y - 1 <= high(T) если T — какое-то целое без знака).

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

У этой функции есть указанное ограничение по вводу, так как это позволяет компилятору генерировать более быстрый код, и она редко используется с отрицательными значениями или целыми без знака, близкими к high(T)/2. Если вам нужна функция ceilDiv которая работает с любым вводом, смотрите: https://github.com/demotomohiro/divmath.

См. также:

процедура system.div для целочисленного деления

функция floorDiv для целочисленного деления с округлением вниз.

Пример:

assert ceilDiv(12, 3) == 4 assert ceilDiv(13, 3) == 5
Исходный код Редактировать
func clamp[T](val: T; bounds: Slice[T]): T {.inline.}: Подобно system.clamp, но принимает срез, поэтому вы можете легко ограничить значение в пределах диапазона.
Пример:

assert clamp(10, 1 .. 5) == 5 assert clamp(1, 1 .. 3) == 1 type A = enum a0, a1, a2, a3, a4, a5 assert a1.clamp(a2..a4) == a2 assert clamp((3, 0), (1, 0) .. (2, 9)) == (2, 9) doAssertRaises(AssertionDefect): discard clamp(1, 3..2) # invalid bounds
Исходный код Редактировать
func classify(x: float): FloatClass {....raises: [], tags: [], forbids: [].}: Классифицирует значение с плавающей запятой.

Возвращает класс значения 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
Исходный код Редактировать
func copySign[T: SomeFloat](x, y: T): T {.inline.}: Возвращает значение с модулем x и знаком y; это работает даже если x или y — NaN, бесконечность или ноль, все из которых могут нести знак.
Пример:

doAssert copySign(10.0, 1.0) == 10.0 doAssert copySign(10.0, -1.0) == -10.0 doAssert copySign(-Inf, -0.0) == -Inf doAssert copySign(NaN, 1.0).isNaN doAssert copySign(1.0, copySign(NaN, -1.0)) == -1.0
Исходный код Редактировать
func cos(x: float32): float32 {.importc: "cosf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func cos(x: float64): float64 {.importc: "cos", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет косинус x.

См. также:

функция arccos

Пример:

doAssert almostEqual(cos(2 * PI), 1.0) doAssert almostEqual(cos(degToRad(60.0)), 0.5)
Исходный код Редактировать
func cosh(x: float32): float32 {.importc: "coshf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func cosh(x: float64): float64 {.importc: "cosh", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет гиперболический косинус x.

См. также:

функция arccosh

Пример:

doAssert almostEqual(cosh(0.0), 1.0) doAssert almostEqual(cosh(1.0), 1.543080634815244)
Исходный код Редактировать
func cot[T: float32 | float64](x: T): T: Вычисляет котангенс x (1/tan(x)). Исходный код Редактировать
func coth[T: float32 | float64](x: T): T: Вычисляет гиперболический котангенс x (1/tanh(x)). Исходный код Редактировать
func csc[T: float32 | float64](x: T): T: Вычисляет косеканс x (1/sin(x)). Исходный код Редактировать
func csch[T: float32 | float64](x: T): T: Вычисляет гиперболический косеканс x (1/sinh(x)). Исходный код Редактировать
func cumsum[T](x: var openArray[T]): Преобразует x непосредственно (должно быть объявлено как var ) в её кумулятивное (т.е. префиксное) суммирование.

См. также:

функция sum

функция cumsummed для версии, которая возвращает кумулятивно суммированную последовательность

Пример:

var a = [1, 2, 3, 4] cumsum(a) doAssert a == @[1, 3, 6, 10]
Исходный код Редактировать
func cumsummed[T](x: openArray[T]): seq[T]: Возвращает кумулятивное (т.е. префиксное) суммирование x.

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

См. также:

функция sum

функция cumsum для ин-плейс версии

Пример:

doAssert cumsummed([1, 2, 3, 4]) == @[1, 3, 6, 10]
Исходный код Редактировать
func degToRad[T: float32 | float64](d: T): T {.inline.}: Преобразование из градусов в радианы.

См. также:

функция radToDeg

Пример:

doAssert almostEqual(degToRad(180.0), PI)
Исходный код Редактировать
func divmod[T: SomeInteger](x, y: T): (T, T) {.inline.}: Специализированные инструкции для вычисления как деления, так и остатка от деления. Структура возвращаемых значений: (частное, остаток)
Пример:

doAssert divmod(5, 2) == (2, 1) doAssert divmod(5, -3) == (-1, 2)
Исходный код Редактировать
func erf(x: float32): float32 {.importc: "erff", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func erf(x: float64): float64 {.importc: "erf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет функцию ошибки для x.

Примечание: Не доступно для JS-бекенда.
Исходный код Редактировать
func erfc(x: float32): float32 {.importc: "erfcf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func erfc(x: float64): float64 {.importc: "erfc", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет дополнительную функцию ошибки для x.

Примечание: Не доступно для JS-бекенда.
Исходный код Редактировать

func euclDiv[T: SomeInteger](x, y: T): T: Возвращает целочисленное частное от деления x на y.
Пример:

doAssert euclDiv(13, 3) == 4 doAssert euclDiv(-13, 3) == -5 doAssert euclDiv(13, -3) == -4 doAssert euclDiv(-13, -3) == 5
Исходный код Редактировать
func euclMod[T: SomeNumber](x, y: T): T: Возвращает целочисленный остаток от деления x на y. euclMod(x, y) неотрицательно.
Пример:

doAssert euclMod(13, 3) == 1 doAssert euclMod(-13, 3) == 2 doAssert euclMod(13, -3) == 1 doAssert euclMod(-13, -3) == 2
Исходный код Редактировать
func exp(x: float32): float32 {.importc: "expf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func exp(x: float64): float64 {.importc: "exp", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет экспоненциальную функцию от x (e^x).

См. также:

функция ln

Пример:

doAssert almostEqual(exp(1.0), E) doAssert almostEqual(ln(exp(4.0)), 4.0) doAssert almostEqual(exp(0.0), 1.0)
Исходный код Редактировать
func fac(n: int): int {....raises: [], tags: [], forbids: [].}: Вычисляет факториал неотрицательного целого числа n.

См. также:

функция prod

Пример:

doAssert fac(0) == 1 doAssert fac(4) == 24 doAssert fac(10) == 3628800
Исходный код Редактировать
func floor(x: float32): float32 {.importc: "floorf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func floor(x: float64): float64 {.importc: "floor", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет функцию floor (т.е. наибольшее целое число, не большее чем x).

См. также:

функция ceil

функция round

функция trunc

Пример:

doAssert floor(2.1) == 2.0 doAssert floor(2.9) == 2.0 doAssert floor(-3.5) == -4.0
Исходный код Редактировать
func floorDiv[T: SomeInteger](x, y: T): T: Целочисленное деление по принципу floor определяется как floor(x / y).

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

См. также:

процедура system.div для целочисленного деления

функция floorMod для поведения, подобного Python (% оператор)

Пример:

doAssert floorDiv( 13, 3) == 4 doAssert floorDiv(-13, 3) == -5 doAssert floorDiv( 13, -3) == -5 doAssert floorDiv(-13, -3) == 4
Исходный код Редактировать
func floorMod[T: SomeNumber](x, y: T): T: Модуль по принципу floor концептуально определяется как x - (floorDiv(x, y) * y).

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

См. также:

функция mod

функция floorDiv

Пример:

doAssert floorMod( 13, 3) == 1 doAssert floorMod(-13, 3) == 2 doAssert floorMod( 13, -3) == -2 doAssert floorMod(-13, -3) == -1
Исходный код Редактировать
func frexp[T: float32 | float64](x: T): tuple[frac: T, exp: int] {.inline.}: Разделяет x на нормализованную дробь frac и целую степень 2 exp, такую, что abs(frac) in 0.5..<1 и x == frac * 2 ^ exp, за исключением особых случаев, показанных ниже.
Пример:

doAssert frexp(8.0) == (0.5, 4) doAssert frexp(-8.0) == (-0.5, 4) doAssert frexp(0.0) == (0.0, 0) # special cases: when sizeof(int) == 8: doAssert frexp(-0.0).frac.signbit # signbit preserved for +-0 doAssert frexp(Inf).frac == Inf # +- Inf preserved doAssert frexp(NaN).frac.isNaN
Исходный код Редактировать
func frexp[T: float32 | float64](x: T; exponent: var int): T {.inline.}: Перегрузка frexp, которая вызывает (result, exponent) = frexp(x).
Пример:

var x: int doAssert frexp(5.0, x) == 0.625 doAssert x == 3
Исходный код Редактировать
func gamma(x: float32): float32 {.importc: "tgammaf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func gamma(x: float64): float64 {.importc: "tgamma", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет гамма-функцию для x.

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

См. также:

функцию lgamma для натурального логарифма гамма-функции

Пример:

doAssert almostEqual(gamma(1.0), 1.0) doAssert almostEqual(gamma(4.0), 6.0) doAssert almostEqual(gamma(11.0), 3628800.0)
Исходный код Редактировать
func gcd(x, y: SomeInteger): SomeInteger: Вычисляет наибольший общий делитель (положительный) x и y, используя алгоритм бинарного НОД (алгоритм Штейна).

См. также:

функцию gcd для версии с плавающей точкой

функцию lcm

Пример:

doAssert gcd(12, 8) == 4 doAssert gcd(17, 63) == 1
Исходный код Редактировать
func 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
Исходный код Редактировать
func gcd[T](x: openArray[T]): T: Вычисляет наибольший общий делитель (положительный) элементов x.

См. также:

функцию gcd для версии с двумя аргументами

Пример:

doAssert gcd(@[13.5, 9.0]) == 4.5
Исходный код Редактировать
func hypot(x, y: float32): float32 {.importc: "hypotf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Редактировать
func hypot(x, y: float64): float64 {.importc: "hypot", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет длину гипотенузы прямоугольного треугольника с x как основанием и y как высотой. Эквивалентно sqrt(x*x + y*y).
Пример:

doAssert almostEqual(hypot(3.0, 4.0), 5.0)
Исходный код Редактировать
func isNaN(x: SomeFloat): bool {.inline.}: Возвращает, является ли x числом с плавающей точкой NaN, более эффективно, чем через classify(x) == fcNan. Работает даже с --passc:-ffast-math.
Пример:

doAssert NaN.isNaN doAssert not Inf.isNaN doAssert not isNaN(3.1415926)
Исходный код Редактировать
func isPowerOfTwo(x: int): bool {....raises: [], tags: [], forbids: [].}: Возвращает true, если x является степенью двойки, false в противном случае.

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

См. также:

функцию nextPowerOfTwo

Пример:

doAssert isPowerOfTwo(16) doAssert not isPowerOfTwo(5) doAssert not isPowerOfTwo(0) doAssert not isPowerOfTwo(-16)
Исходный код Редактировать

func lcm[T](x, y: T): T: Вычисляет наименьшее общее кратное x и y.

См. также:

функция gcd

Пример:

doAssert lcm(24, 30) == 120 doAssert lcm(13, 39) == 39
Исходный код Изменить
func lcm[T](x: openArray[T]): T: Вычисляет наименьшее общее кратное элементов x.

См. также:

функция lcm для версии с двумя аргументами

Пример:

doAssert lcm(@[24, 30]) == 120
Исходный код Изменить
func lgamma(x: float32): float32 {.importc: "lgammaf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func lgamma(x: float64): float64 {.importc: "lgamma", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет натуральный логарифм гамма-функции для x.

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

См. также:

функция gamma для гамма-функции

Исходный код Изменить
func ln(x: float32): float32 {.importc: "logf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func ln(x: float64): float64 {.importc: "log", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет натуральный логарифм от x.

См. также:

функция log

функция log10

функция log2

функция exp

Пример:

doAssert almostEqual(ln(exp(4.0)), 4.0) doAssert almostEqual(ln(1.0), 0.0) doAssert almostEqual(ln(0.0), -Inf) doAssert ln(-7.0).isNaN
Исходный код Изменить
func log[T: SomeFloat](x, base: T): T: Вычисляет логарифм x по основанию base.

См. также:

функция ln

функция log10

функция log2

Пример:

doAssert almostEqual(log(9.0, 3.0), 2.0) doAssert almostEqual(log(0.0, 2.0), -Inf) doAssert log(-7.0, 4.0).isNaN doAssert log(8.0, -2.0).isNaN
Исходный код Изменить
func log2(x: float32): float32 {.importc: "log2f", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func log2(x: float64): float64 {.importc: "log2", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет двоичный логарифм (основание 2) от x.

См. также:

функция log

функция log10

функция ln

Пример:

doAssert almostEqual(log2(8.0), 3.0) doAssert almostEqual(log2(1.0), 0.0) doAssert almostEqual(log2(0.0), -Inf) doAssert log2(-2.0).isNaN
Исходный код Изменить
func log10(x: float32): float32 {.importc: "log10f", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func log10(x: float64): float64 {.importc: "log10", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет десятичный логарифм (основание 10) от x.

См. также:

функция ln

функция log

функция log2

Пример:

doAssert almostEqual(log10(100.0) , 2.0) doAssert almostEqual(log10(0.0), -Inf) doAssert log10(-100.0).isNaN
Исходный код Изменить
func `mod`(x, y: float32): float32 {.importc: "fmodf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func `mod`(x, y: float64): float64 {.importc: "fmod", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет операцию модуль для чисел с плавающей точкой (остаток от деления x на y).

См. также:

функция floorMod для поведения, аналогичного Python (% оператор)

Пример:

doAssert 6.5 mod 2.5 == 1.5 doAssert -6.5 mod 2.5 == -1.5 doAssert 6.5 mod -2.5 == 1.5 doAssert -6.5 mod -2.5 == -1.5
Исходный код Изменить
func nextPowerOfTwo(x: int): int {....raises: [], tags: [], forbids: [].}: Возвращает x, округлённое вверх до ближайшей степени двойки.

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

См. также:

функция isPowerOfTwo

Пример:

doAssert nextPowerOfTwo(16) == 16 doAssert nextPowerOfTwo(5) == 8 doAssert nextPowerOfTwo(0) == 1 doAssert nextPowerOfTwo(-16) == 1
Исходный код Изменить
func pow(x, y: float32): float32 {.importc: "powf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func pow(x, y: float64): float64 {.importc: "pow", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет x в степени y.

Для вычисления степени между целыми числами (например, 2^6), используйте функцию ^.

См. также:

функция ^

функция sqrt

функция cbrt

Пример:

doAssert almostEqual(pow(100, 1.5), 1000.0) doAssert almostEqual(pow(16.0, 0.5), 4.0)
Исходный код Изменить
func prod[T](x: openArray[T]): T: Вычисляет произведение элементов в x.

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

См. также:

функция sum

функция fac

Пример:

doAssert prod([1, 2, 3, 4]) == 24 doAssert prod([-4, 3, 5]) == -60
Исходный код Изменить
func radToDeg[T: float32 | float64](d: T): T {.inline.}: Преобразует из радиан в градусы.

См. также:

функция degToRad

Пример:

doAssert almostEqual(radToDeg(2 * PI), 360.0)
Исходный код Изменить
func round(x: float32): float32 {.importc: "roundf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func round(x: float64): float64 {.importc: "round", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Округляет число с плавающей точкой до нулей десятичных знаков.

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

См. также:

функция round для округления до определённого числа десятичных знаков

функция floor

функция ceil

функция trunc

Пример:

doAssert round(3.4) == 3.0 doAssert round(3.5) == 4.0 doAssert round(4.5) == 5.0
Исходный код Изменить
func round[T: float32 | float64](x: T; places: int): T: Десятичное округление двоичного числа с плавающей точкой.

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

Пример:

doAssert round(PI, 2) == 3.14 doAssert round(PI, 4) == 3.1416
Исходный код Изменить

func sec[T: float32 | float64](x: T): T: Вычисляет секанс от x (1/cos(x)). Исходный код Изменить
func sech[T: float32 | float64](x: T): T: Вычисляет гиперболический секанс от x (1/cosh(x)). Исходный код Изменить
func 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 signbit(x: SomeFloat): bool {.inline.}: Возвращает true, если x отрицательно, в противном случае false.
Пример:

doAssert not signbit(0.0) doAssert signbit(-0.0) doAssert signbit(-0.1) doAssert not signbit(0.1)
Исходный код Изменить
func sin(x: float32): float32 {.importc: "sinf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func sin(x: float64): float64 {.importc: "sin", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет синус от x.

См. также:

функция arcsin

Пример:

doAssert almostEqual(sin(PI / 6), 0.5) doAssert almostEqual(sin(degToRad(90.0)), 1.0)
Исходный код Изменить
func sinh(x: float32): float32 {.importc: "sinhf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func sinh(x: float64): float64 {.importc: "sinh", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет гиперболический синус от x.

См. также:

функция arcsinh

Пример:

doAssert almostEqual(sinh(0.0), 0.0) doAssert almostEqual(sinh(1.0), 1.175201193643801)
Исходный код Изменить
func splitDecimal[T: float32 | float64](x: T): tuple[intpart: T, floatpart: T]: Разделяет 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)
Исходный код Изменить
func sqrt(x: float32): float32 {.importc: "sqrtf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func sqrt(x: float64): float64 {.importc: "sqrt", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет квадратный корень из x.

См. также:

cbrt func для кубового корня

Пример:

doAssert almostEqual(sqrt(4.0), 2.0) doAssert almostEqual(sqrt(1.44), 1.2)
Исходный код Изменить
func sum[T](x: openArray[T]): T: Вычисляет сумму элементов в x.

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

См. также:

prod func

cumsum func

cumsummed func

Пример:

doAssert sum([1, 2, 3, 4]) == 10 doAssert sum([-4, 3, 5]) == 4
Исходный код Изменить
func tan(x: float32): float32 {.importc: "tanf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func tan(x: float64): float64 {.importc: "tan", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет тангенс от x.

См. также:

функция arctan

Пример:

doAssert almostEqual(tan(degToRad(45.0)), 1.0) doAssert almostEqual(tan(PI / 4), 1.0)
Исходный код Изменить
func tanh(x: float32): float32 {.importc: "tanhf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func tanh(x: float64): float64 {.importc: "tanh", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Вычисляет гиперболический тангенс от x.

См. также:

функция arctanh

Пример:

doAssert almostEqual(tanh(0.0), 0.0) doAssert almostEqual(tanh(1.0), 0.7615941559557649)
Исходный код Изменить
func trunc(x: float32): float32 {.importc: "truncf", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Исходный код Изменить
func trunc(x: float64): float64 {.importc: "trunc", header: "<math.h>", ...raises: [], tags: [], forbids: [].}: Округляет x до целого числа.

См. также:

функция floor

функция ceil

функция round

Пример:

doAssert trunc(PI) == 3.0 doAssert trunc(-1.85) == -1.0
Исходный код Изменить