std.math

Содержит элементарные математические функции (степени, корни и тригонометрические функции), а также низкоуровневые операции с плавающей точкой. Математические специальные функции доступны в std.mathspecial.

Функциональность тесно следует стандарту IEEE754-2008 для арифметики с плавающей точкой, включая использование имён в стиле camelCase вместо имён в стиле C99 (нижнего регистра). Все эти функции работают корректно, когда им передаются бесконечности или NaN.

В настоящее время поддерживаются следующие форматы IEEE «real»:

• 64-битный большой порядок байт «double» (например, PowerPC)
• 128-битный большой порядок байт «quadruple» (например, SPARC)
• 64-битный малый порядок байт «double» (например, x86-SSE2)
• 80-битный малый порядок байт, с неявным битом «real80» (например, x87, Itanium)
• 128-битный малый порядок байт «quadruple» (не реализован ни на одном известном процессоре!)
• Не-IEEE 128-битный большой порядок байт «doubledouble» (например, PowerPC) имеет частичную поддержку

Лицензия:

Лицензия Boost 1.0.

Авторы:

Walter Bright, Don Clugston, Перевод библиотеки математических функций CEPHES на D выполнен Iain Buclaw и David Nadlinger

Исходный код

std/math.d

перечисление real E;

e = 2.718281...

перечисление real LOG2T;

log₂10 = 3.321928...

перечисление real LOG2E;

log₂e = 1.442695...

перечисление real LOG2;

log₁₀2 = 0.301029...

перечисление real LOG10E;

log₁₀e = 0.434294...

перечисление real LN2;

ln 2 = 0.693147...

перечисление real LN10;

ln 10 = 2.302585...

перечисление real PI;

π = 3.141592...

перечисление real PI_2;

π / 2 = 1.570796...

перечисление real PI_4;

π / 4 = 0.785398...

перечисление real M_1_PI;

1 / π = 0.318309...

перечисление real M_2_PI;

2 / π = 0.636619...

перечисление real M_2_SQRTPI;

2 / √π = 1.128379...

перечисление real SQRT2;

√2 = 1.414213...

перечисление real SQRT1_2;

√½ = 0.707106...

чистый без исключений @nogc авто abs(Num)(Num x)
Ограничения: если (is(immutable(Num) == immutable(short)) || is(immutable(Num) == immutable(byte)) || is(typeof(Num.init >= 0)) && is(typeof(-Num.init)));

Вычисляет абсолютное значение числа.

Параметры:

Num	(параметр шаблона) тип числа
Num x	вещественное числовое значение

Возвращает:

Абсолютное значение числа. Если число с плавающей точкой или целое, тип возвращаемого значения будет таким же, как и входного.

Ограничения

Не работает корректно для целых типов со знаком и значения Num.min.

Примеры:

ditto

assert(isIdentical(abs(-0.0L), 0.0L));
assert(isNaN(abs(real.nan)));
writeln(abs(-real.infinity)); // real.infinity
writeln(abs(-56)); // 56
writeln(abs(2321312L)); // 2321312L

чистый без исключений @nogc @safe real cos(real x);

чистый без исключений @nogc @safe double cos(double x);

чистый без исключений @nogc @safe float cos(float x);

Возвращает косинус x. x в радианах.

Специальные значения

x	cos(x)	ошибка?
НЕ ЧИСЛО	НЕ ЧИСЛО	да
±∞	НЕ ЧИСЛО	да

Ошибки:

Результаты не определены, если |x| >= 2⁶⁴.

Примеры:

writeln(cos(0.0)); // 1.0
assert(cos(1.0).approxEqual(0.540));
assert(cos(3.0).approxEqual(-0.989));

чистый без исключений @nogc @safe real sin(real x);

чистый без исключений @nogc @safe double sin(double x);

чистый без исключений @nogc @safe float sin(float x);

Возвращает синус x. x в радианах.

Специальные значения

x	sin(x)	ошибка?
НЕ ЧИСЛО	НЕ ЧИСЛО	да
±0.0	±0.0	нет
±∞	НЕ ЧИСЛО	да

Параметры:

real x

угол в радианах (а не градусах)

Возвращает:

синус x

См. также:

cos , tan , asin

Ошибки:

Результаты не определены, если |x| >= 2⁶⁴.

Примеры:

import std.math : sin, PI;
import std.stdio : writefln;

void someFunc()
{
  real x = 30.0;
  auto result = sin(x * (PI / 180)); // convert degrees to radians
  writefln("The sine of %s degrees is %s", x, result);
}

чистый без исключений @nogc @safe real tan(real x);

чистый без исключений @nogc @safe double tan(double x);

чистый без исключений @nogc @safe float tan(float x);

Возвращает тангенс x. x в радианах.

Специальные значения

x	tan(x)	ошибка?
НЕ ЧИСЛО	НЕ ЧИСЛО	да
±0.0	±0.0	нет
±∞	НЕ ЧИСЛО	да

Примеры:

assert(isIdentical(tan(0.0), 0.0));
assert(tan(PI).approxEqual(0));
assert(tan(PI / 3).approxEqual(sqrt(3.0)));

чистый без исключений @nogc @safe real acos(real x);

чистый без исключений @nogc @safe double acos(double x);

чистый без исключений @nogc @safe float acos(float x);

Вычисляет арккосинус x, возвращая значение в диапазоне от 0 до π.

Специальные значения

x	acos(x)	ошибка?
>1.0	НЕ ЧИСЛО	да
<-1.0	НЕ ЧИСЛО	да
НЕ ЧИСЛО	НЕ ЧИСЛО	да

Примеры:

assert(acos(0.0).approxEqual(1.570));
assert(acos(0.5).approxEqual(std.math.PI / 3));
assert(acos(PI).isNaN);

чистый без исключений @nogc @safe real asin(real x);

чистый без исключений @nogc @safe double asin(double x);

чистый без исключений @nogc @safe float asin(float x);

Вычисляет арксинус x, возвращая значение в диапазоне от -π/2 до π/2.

Специальные значения

x	asin(x)	ошибка?
±0.0	±0.0	нет
>1.0	НЕ ЧИСЛО	да
<-1.0	НЕ ЧИСЛО	да

Примеры:

assert(isIdentical(asin(0.0), 0.0));
assert(asin(0.5).approxEqual(PI / 6));
assert(asin(PI).isNaN);

чистый без исключений @nogc @safe real atan(real x);

чистый без исключений @nogc @safe double atan(double x);

чистый без исключений @nogc @safe float atan(float x);

Вычисляет арктангенс x, возвращая значение в диапазоне от -π/2 до π/2.

Специальные значения

x	atan(x)	ошибка?
±0.0	±0.0	нет
±∞	НЕ ЧИСЛО	да

Примеры:

assert(isIdentical(atan(0.0), 0.0));
assert(atan(sqrt(3.0)).approxEqual(PI / 3));

чистый без исключений @nogc @trusted real atan2(real y, real x);

чистый без исключений @nogc @safe double atan2(double y, double x);

чистый без исключений @nogc @safe float atan2(float y, float x);

Вычисляет арктангенс y / x, возвращая значение в диапазоне от -π до π.

Специальные значения

y	x	atan(y, x)
НЕ ЧИСЛО	любое	НЕ ЧИСЛО
любое	НЕ ЧИСЛО	НЕ ЧИСЛО
±0.0	>0.0	±0.0
±0.0	+0.0	±0.0
±0.0	<0.0	±π
±0.0	-0.0	±π
>0.0	±0.0	π/2
<0.0	±0.0	-π/2
>0.0	∞	±0.0
±∞	любое	±π/2
>0.0	-∞	±π
±∞	∞	±π/4
±∞	-∞	±3π/4

Примеры:

assert(atan2(1.0, sqrt(3.0)).approxEqual(PI / 6));

чистый без исключений @nogc @safe real cosh(real x);

чистый без исключений @nogc @safe double cosh(double x);

чистый без исключений @nogc @safe float cosh(float x);

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

Специальные значения

x	cosh(x)	ошибка?
±∞	±0.0	нет

Примеры:

writeln(cosh(0.0)); // 1.0
assert(cosh(1.0).approxEqual((E + 1.0 / E) / 2));

чистый без исключений @nogc @safe real sinh(real x);

чистый без исключений @nogc @safe double sinh(double x);

чистый без исключений @nogc @safe float sinh(float x);

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

Специальные значения

x	sinh(x)	ошибка?
±0.0	±0.0	нет
±∞	±∞	нет

Примеры:

enum sinh1 = (E - 1.0 / E) / 2;
import std.meta : AliasSeq;
static foreach (F; AliasSeq!(float, double, real))
{
    assert(isIdentical(sinh(F(0.0)), F(0.0)));
    assert(sinh(F(1.0)).approxEqual(F(sinh1)));
}

чистый без исключений @nogc @safe real tanh(real x);

чистый без исключений @nogc @safe double tanh(double x);

чистый без исключений @nogc @safe float tanh(float x);

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

Специальные значения

x	tanh(x)	ошибка?
±0.0	±0.0	нет
±∞	±1.0	нет

Примеры:

assert(isIdentical(tanh(0.0), 0.0));
assert(tanh(1.0).approxEqual(sinh(1.0) / cosh(1.0)));

чистый без исключений @nogc @safe real acosh(real x);

чистый без исключений @nogc @safe double acosh(double x);

чистый без исключений @nogc @safe float acosh(float x);

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

Математически, acosh(x) = log(x + sqrt( x*x - 1))

Область X	Диапазон Y
1..∞	0..∞

Специальные значения

x	acosh(x)
NAN	NAN
<1	NAN
1	0
+∞	+∞

Примеры:

assert(isNaN(acosh(0.9)));
assert(isNaN(acosh(real.nan)));
assert(isIdentical(acosh(1.0), 0.0));
writeln(acosh(real.infinity)); // real.infinity
assert(isNaN(acosh(0.5)));

pure nothrow @nogc @safe real asinh(real x);

pure nothrow @nogc @safe double asinh(double x);

pure nothrow @nogc @safe float asinh(float x);

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

Математически,

asinh(x) =  log( x + sqrt( x*x + 1 )) // if x >= +0
asinh(x) = -log(-x + sqrt( x*x + 1 )) // if x <= -0

Специальные значения

x	asinh(x)
NAN	NAN
±0	±0
±∞	±∞

Примеры:

assert(isIdentical(asinh(0.0), 0.0));
assert(isIdentical(asinh(-0.0), -0.0));
writeln(asinh(real.infinity)); // real.infinity
writeln(asinh(-real.infinity)); // -real.infinity
assert(isNaN(asinh(real.nan)));

pure nothrow @nogc @safe real atanh(real x);

pure nothrow @nogc @safe double atanh(double x);

pure nothrow @nogc @safe float atanh(float x);

Вычисляет обратную гиперболическую тангенс x, возвращая значение от -1 до 1.

Математически, atanh(x) = log( (1+x)/(1-x) ) / 2

Область X	Диапазон Y
-∞..∞	-1 .. 1

Специальные значения

x	acosh(x)
NAN	NAN
±0	±0
-∞	-0

Примеры:

assert(isIdentical(atanh(0.0), 0.0));
assert(isIdentical(atanh(-0.0),-0.0));
assert(isNaN(atanh(real.nan)));
assert(isNaN(atanh(-real.infinity)));
writeln(atanh(0.0)); // 0

pure nothrow @nogc @safe long rndtol(real x);

pure nothrow @nogc @safe long rndtol(double x);

pure nothrow @nogc @safe long rndtol(float x);

Возвращает x, округленное до целого значения long с использованием текущего режима округления. Если целое значение x больше long.max, результат неопределен.

Примеры:

writeln(rndtol(1.0)); // 1L
writeln(rndtol(1.2)); // 1L
writeln(rndtol(1.7)); // 2L
writeln(rndtol(1.0001)); // 1L

pure nothrow @nogc @safe float sqrt(float x);

pure nothrow @nogc @safe double sqrt(double x);

pure nothrow @nogc @safe real sqrt(real x);

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

Специальные значения

x	sqrt(x)	Недействительно?
-0.0	-0.0	нет
<0.0	NAN	да
+∞	+∞	нет

Примеры:

assert(sqrt(2.0).feqrel(1.4142) > 16);
assert(sqrt(9.0).feqrel(3.0) > 16);

assert(isNaN(sqrt(-1.0f)));
assert(isNaN(sqrt(-1.0)));
assert(isNaN(sqrt(-1.0L)));

pure nothrow @nogc @trusted real exp(real x);

pure nothrow @nogc @safe double exp(double x);

pure nothrow @nogc @safe float exp(float x);

Вычисляет e^x.

Специальные значения

x	ex
+∞	+∞
-∞	+0.0
NAN	NAN

Примеры:

writeln(exp(0.0)); // 1.0
assert(exp(3.0).feqrel(E * E * E) > 16);

pure nothrow @nogc @trusted real expm1(real x);

pure nothrow @nogc @safe double expm1(double x);

pure nothrow @nogc @safe float expm1(float x);

Вычисляет значение натурального логарифма по основанию (e), возведенного в степень x, минус 1.

Для очень малых x, expm1(x) более точен, чем exp(x)-1.

Специальные значения

x	ex-1
±0.0	±0.0
+∞	+∞
-∞	-1.0
NAN	NAN

Примеры:

assert(isIdentical(expm1(0.0), 0.0));
assert(expm1(1.0).feqrel(1.71828) > 16);
assert(expm1(2.0).feqrel(6.3890) > 16);

pure nothrow @nogc @trusted real exp2(real x);

pure nothrow @nogc @safe double exp2(double x);

pure nothrow @nogc @safe float exp2(float x);

Вычисляет 2^x.

Специальные значения

x	exp2(x)
+∞	+∞
-∞	+0.0
NAN	NAN

Примеры:

assert(isIdentical(exp2(0.0), 1.0));
assert(exp2(2.0).feqrel(4.0) > 16);
assert(exp2(8.0).feqrel(256.0) > 16);

pure nothrow @nogc @trusted T frexp(T)(const T value, out int exp)
Constraints: if (isFloatingPoint!T);

Разделить значение с плавающей точкой на мантиссу и показатель степени.

Возвращает:

Вычисляет и возвращает x и exp, такие что value =x*2^exp и .5 <= |x| < 1.0 x имеет тот же знак, что и значение.

Специальные значения

value	возвращает	exp
±0.0	±0.0	0
+∞	+∞	int.max
-∞	-∞	int.min
±NAN	±NAN	int.min

Примеры:

int exp;
real mantissa = frexp(123.456L, exp);

assert(approxEqual(mantissa * pow(2.0L, cast(real) exp), 123.456L));

assert(frexp(-real.nan, exp) && exp == int.min);
assert(frexp(real.nan, exp) && exp == int.min);
assert(frexp(-real.infinity, exp) == -real.infinity && exp == int.min);
assert(frexp(real.infinity, exp) == real.infinity && exp == int.max);
assert(frexp(-0.0, exp) == -0.0 && exp == 0);
assert(frexp(0.0, exp) == 0.0 && exp == 0);

pure nothrow @nogc @trusted int ilogb(T)(const T x)
Constraints: if (isFloatingPoint!T);

pure nothrow @nogc @safe int ilogb(T)(const T x)
Constraints: if (isIntegral!T && isUnsigned!T);

pure nothrow @nogc @safe int ilogb(T)(const T x)
Constraints: if (isIntegral!T && isSigned!T);

Извлекает показатель степени x как целое значение со знаком.

Если x не является специальным значением, результат такой же, как cast(int) logb(x).

Специальные значения

x	ilogb(x)	Ошибка диапазона?
0	FP_ILOGB0	да
±∞	int.max	нет
NAN	FP_ILOGBNAN	нет

Примеры:

writeln(ilogb(1)); // 0
writeln(ilogb(3)); // 1
writeln(ilogb(3.0)); // 1
writeln(ilogb(100_000_000)); // 26

writeln(ilogb(0)); // FP_ILOGB0
writeln(ilogb(0.0)); // FP_ILOGB0
writeln(ilogb(double.nan)); // FP_ILOGBNAN
writeln(ilogb(double.infinity)); // int.max

alias FP_ILOGB0 = core.stdc.math.FP_ILOGB0;

alias FP_ILOGBNAN = core.stdc.math.FP_ILOGBNAN;

Специальные значения возврата ilogb.

Примеры:

writeln(ilogb(0)); // FP_ILOGB0
writeln(ilogb(0.0)); // FP_ILOGB0
writeln(ilogb(double.nan)); // FP_ILOGBNAN

pure nothrow @nogc @safe real ldexp(real n, int exp);

pure nothrow @nogc @safe double ldexp(double n, int exp);

pure nothrow @nogc @safe float ldexp(float n, int exp);

Вычислить n * 2^exp

Ссылки

frexp

Примеры:

import std.meta : AliasSeq;
static foreach (T; AliasSeq!(float, double, real))
{{
    T r;

    r = ldexp(3.0L, 3);
    writeln(r); // 24

    r = ldexp(cast(T) 3.0, cast(int) 3);
    writeln(r); // 24

    T n = 3.0;
    int exp = 3;
    r = ldexp(n, exp);
    writeln(r); // 24
}}

pure nothrow @nogc @safe real log(real x);

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

Специальные значения

x	log(x)	деление на 0?	Недействительно?
±0.0	-∞	да	нет
<0.0	NAN	нет	да
+∞	+∞	нет	нет

Примеры:

assert(feqrel(log(E), 1) >= real.mant_dig - 1);

pure nothrow @nogc @safe real log10(real x);

Вычислить логарифм по основанию 10 x.

Специальные значения

x	log10(x)	деление на 0?	Недействительно?
±0.0	-∞	да	нет
<0.0	NAN	нет	да
+∞	+∞	нет	нет

Примеры:

assert(fabs(log10(1000) - 3) < .000001);

pure nothrow @nogc @safe real log1p(real x);

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

Для очень малых x, log1p(x) будет более точным, чем log(1 + x).

Специальные значения

x	log1p(x)	деление на 0?	Недействительно?
±0.0	±0.0	нет	нет
-1.0	-∞	да	нет
<-1.0	-NAN	нет	да
+∞	+∞	нет	нет

Примеры:

assert(isIdentical(log1p(0.0), 0.0));
assert(log1p(1.0).feqrel(0.69314) > 16);

writeln(log1p(-1.0)); // -real.infinity
assert(isNaN(log1p(-2.0)));
assert(log1p(real.nan) is real.nan);
assert(log1p(-real.nan) is -real.nan);
writeln(log1p(real.infinity)); // real.infinity

pure nothrow @nogc @safe real log2(real x);

Вычисляет логарифм по основанию 2 от x: log₂x

Специальные значения

x	log2(x)	деление на 0?	Недействительно?
±0.0	-∞	да	нет
<0.0	NAN	нет	да
+∞	+∞	нет	нет

Примеры:

assert(approxEqual(log2(1024.0L), 10));

nothrow @nogc @trusted real logb(real x);

Извлекает показатель степени x как целое значение со знаком.

Если x является субнормальным, он обрабатывается так, как если бы он был нормализован. Для положительного конечного x:

1 <= x * FLT_RADIX^-logb(x) < FLT_RADIX

Значения по умолчанию

x	logb(x)	деление на 0?
±∞	+∞	нет
±0.0	-∞	да

Примеры:

writeln(logb(1.0)); // 0
writeln(logb(100.0)); // 6

writeln(logb(0.0)); // -real.infinity
writeln(logb(real.infinity)); // real.infinity
writeln(logb(-real.infinity)); // real.infinity

nothrow @nogc @trusted real fmod(real x, real y);

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

Возвращает:

Значение x - i * y, где i — количество раз, когда y можно полностью вычесть из x. Результат имеет тот же знак, что и x.

Значения по умолчанию

x	y	fmod(x, y)	ошибка?
±0.0	не 0.0	±0.0	нет
±∞	любое	НЕЧЁТНОСТЬ	да
любое	±0.0	НЕЧЁТНОСТЬ	да
!=±∞	±∞	x	нет

Примеры:

assert(isIdentical(fmod(0.0, 1.0), 0.0));
assert(fmod(5.0, 3.0).feqrel(2.0) > 16);
assert(isNaN(fmod(5.0, 0.0)));

nothrow @nogc @trusted real modf(real x, ref real i);

Разделяет x на целую и дробную части, каждая из которых имеет тот же знак, что и x. Целая часть хранится в i.

Возвращает:

Дробная часть x.

Значения по умолчанию

x	i (на входе)	modf(x, i)	i (на выходе)
±∞	любое	±0.0	±∞

Примеры:

real frac;
real intpart;

frac = modf(3.14159, intpart);
assert(intpart.feqrel(3.0) > 16);
assert(frac.feqrel(0.14159) > 16);

pure nothrow @nogc @safe real scalbn(real x, int n);

pure nothrow @nogc @safe double scalbn(double x, int n);

pure nothrow @nogc @safe float scalbn(float x, int n);

Эффективно вычисляет x * 2ⁿ.

scalbn обрабатывает подпоток и переполнение так же, как основные арифметические операторы.

Значения по умолчанию

x	scalb(x)
±∞	±∞
±0.0	±0.0

Примеры:

writeln(scalbn(0x1.2345678abcdefp0L, 999)); // 0x1.2345678abcdefp999L
writeln(scalbn(-real.infinity, 5)); // -real.infinity
writeln(scalbn(2.0, 10)); // 2048.0
writeln(scalbn(2048.0f, -10)); // 2.0f

nothrow @nogc @trusted real cbrt(real x);

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

Значения по умолчанию

x	cbrt(x)	ошибка?
±0.0	±0.0	нет
НЕЧЁТНОСТЬ	НЕЧЁТНОСТЬ	да
±∞	±∞	нет

Примеры:

assert(cbrt(1.0).feqrel(1.0) > 16);
assert(cbrt(27.0).feqrel(3.0) > 16);
assert(cbrt(15.625).feqrel(2.5) > 16);

pure nothrow @nogc @safe real fabs(real x);

pure nothrow @nogc @trusted double fabs(double d);

pure nothrow @nogc @trusted float fabs(float f);

Возвращает |x|

Значения по умолчанию

x	fabs(x)
±0.0	+0.0
±∞	+∞

Примеры:

assert(isIdentical(fabs(0.0f), 0.0f));
assert(isIdentical(fabs(-0.0f), 0.0f));
writeln(fabs(-10.0f)); // 10.0f

assert(isIdentical(fabs(0.0), 0.0));
assert(isIdentical(fabs(-0.0), 0.0));
writeln(fabs(-10.0)); // 10.0

assert(isIdentical(fabs(0.0L), 0.0L));
assert(isIdentical(fabs(-0.0L), 0.0L));
writeln(fabs(-10.0L)); // 10.0L

pure nothrow @nogc @safe real hypot(real x, real y);

Вычисляет длину гипотенузы прямоугольного треугольника со сторонами длины x и y. Гипотенуза — значение квадратного корня из суммы квадратов x и y:

sqrt(x² + y²)

Обратите внимание, что hypot(x, y), hypot(y, x) и hypot(x, -y) эквивалентны.

Значения по умолчанию

x	y	hypot(x, y)	ошибка?
x	±0.0	|x|	нет
±∞	y	+∞	нет
±∞	НЕЧЁТНОСТЬ	+∞	нет

Примеры:

assert(hypot(1.0, 1.0).feqrel(1.4142) > 16);
assert(hypot(3.0, 4.0).feqrel(5.0) > 16);
writeln(hypot(real.infinity, 1.0)); // real.infinity
writeln(hypot(real.infinity, real.nan)); // real.infinity

pure nothrow @nogc @trusted real ceil(real x);

pure nothrow @nogc @trusted double ceil(double x);

pure nothrow @nogc @trusted float ceil(float x);

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

Примеры:

writeln(ceil(+123.456L)); // +124
writeln(ceil(-123.456L)); // -123
writeln(ceil(-1.234L)); // -1
writeln(ceil(-0.123L)); // 0
writeln(ceil(0.0L)); // 0
writeln(ceil(+0.123L)); // 1
writeln(ceil(+1.234L)); // 2
writeln(ceil(real.infinity)); // real.infinity
assert(isNaN(ceil(real.nan)));
assert(isNaN(ceil(real.init)));

pure nothrow @nogc @trusted real floor(real x);

pure nothrow @nogc @trusted double floor(double x);

pure nothrow @nogc @trusted float floor(float x);

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

Примеры:

writeln(floor(+123.456L)); // +123
writeln(floor(-123.456L)); // -124
writeln(floor(+123.0L)); // +123
writeln(floor(-124.0L)); // -124
writeln(floor(-1.234L)); // -2
writeln(floor(-0.123L)); // -1
writeln(floor(0.0L)); // 0
writeln(floor(+0.123L)); // 0
writeln(floor(+1.234L)); // 1
writeln(floor(real.infinity)); // real.infinity
assert(isNaN(floor(real.nan)));
assert(isNaN(floor(real.init)));

Unqual!F quantize(alias rfunc = rint, F)(const F val, const F unit)
Constraints: if (is(typeof(rfunc(F.init)) : F) && isFloatingPoint!F);

Округлить val до кратного unit. rfunc указывает функцию округления, которую следует использовать; по умолчанию это rint, которая использует текущий режим округления.

Примеры:

writeln(12345.6789L.quantize(0.01L)); // 12345.68L
writeln(12345.6789L.quantize!floor(0.01L)); // 12345.67L
writeln(12345.6789L.quantize(22.0L)); // 12342.0L

Примеры:

writeln(12345.6789L.quantize(0)); // 12345.6789L
assert(12345.6789L.quantize(real.infinity).isNaN);
assert(12345.6789L.quantize(real.nan).isNaN);
writeln(real.infinity.quantize(0.01L)); // real.infinity
assert(real.infinity.quantize(real.nan).isNaN);
assert(real.nan.quantize(0.01L).isNaN);
assert(real.nan.quantize(real.infinity).isNaN);
assert(real.nan.quantize(real.nan).isNaN);

Unqual!F quantize(real base, alias rfunc = rint, F, E)(const F val, const E exp)
Constraints: if (is(typeof(rfunc(F.init)) : F) && isFloatingPoint!F && isIntegral!E);

Unqual!F quantize(real base, long exp = 1, alias rfunc = rint, F)(const F val)
Constraints: if (is(typeof(rfunc(F.init)) : F) && isFloatingPoint!F);

Округлить val до кратного pow(base, exp). rfunc указывает функцию округления, которую следует использовать; по умолчанию это rint, которая использует текущий режим округления.

Примеры:

writeln(12345.6789L.quantize!10(-2)); // 12345.68L
writeln(12345.6789L.quantize!(10, -2)); // 12345.68L
writeln(12345.6789L.quantize!(10, floor)(-2)); // 12345.67L
writeln(12345.6789L.quantize!(10, -2, floor)); // 12345.67L

writeln(12345.6789L.quantize!22(1)); // 12342.0L
writeln(12345.6789L.quantize!22); // 12342.0L

pure nothrow @nogc @safe real nearbyint(real x);

Округляет x до ближайшего целого значения, используя текущий режим округления.

В отличие от функций rint, nearbyint не вызывает исключение FE_INEXACT.

Примеры:

writeln(nearbyint(0.4)); // 0
writeln(nearbyint(0.5)); // 0
writeln(nearbyint(0.6)); // 1
writeln(nearbyint(100.0)); // 100

assert(isNaN(nearbyint(real.nan)));
writeln(nearbyint(real.infinity)); // real.infinity
writeln(nearbyint(-real.infinity)); // -real.infinity

pure nothrow @nogc @safe real rint(real x);

pure nothrow @nogc @safe double rint(double x);

pure nothrow @nogc @safe float rint(float x);

Округляет x до ближайшего целого значения, используя текущий режим округления.

Если возвращаемое значение не равно x, генерируется исключение FE_INEXACT.

nearbyint выполняет ту же операцию, но не устанавливает исключение FE_INEXACT.

Примеры:

version (IeeeFlagsSupport) resetIeeeFlags();
writeln(rint(0.4)); // 0
version (IeeeFlagsSupport) assert(ieeeFlags.inexact);

writeln(rint(0.5)); // 0
writeln(rint(0.6)); // 1
writeln(rint(100.0)); // 100

assert(isNaN(rint(real.nan)));
writeln(rint(real.infinity)); // real.infinity
writeln(rint(-real.infinity)); // -real.infinity

pure nothrow @nogc @trusted long lrint(real x);

Округляет x до ближайшего целого значения, используя текущий режим округления.

Это, как правило, самый быстрый способ преобразования числа с плавающей запятой в целое число. Обратите внимание, что результаты этой функции зависят от режима округления, если дробная часть x равна точно 0,5. При использовании по умолчанию (равные значения округляются до ближайшего чётного целого) lrint(4.5) == 4, lrint(5.5)==6.

Примеры:

writeln(lrint(4.5)); // 4
writeln(lrint(5.5)); // 6
writeln(lrint(-4.5)); // -4
writeln(lrint(-5.5)); // -6

writeln(lrint(int.max - 0.5)); // 2147483646L
writeln(lrint(int.max + 0.5)); // 2147483648L
writeln(lrint(int.min - 0.5)); // -2147483648L
writeln(lrint(int.min + 0.5)); // -2147483648L

nothrow @nogc @trusted auto round(real x);

Возвращает значение x, округлённое до ближайшего целого. Если дробная часть x равна точно 0,5, возвращаемое значение округляется в сторону от нуля.

Возвращает:

Значение real.

Примеры:

writeln(round(4.5)); // 5
writeln(round(5.4)); // 5
writeln(round(-4.5)); // -5
writeln(round(-5.1)); // -5

nothrow @nogc @trusted long lround(real x);

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

Если дробная часть x равна точно 0,5, возвращаемое значение округляется в сторону от нуля.

Эта функция не реализована для Digital Mars C runtime.

Примеры:

version (CRuntime_DigitalMars) {}
else
{
    writeln(lround(0.49)); // 0
    writeln(lround(0.5)); // 1
    writeln(lround(1.5)); // 2
}

pure nothrow @nogc @trusted real trunc(real x);

Возвращает целую часть x, отбрасывая дробную часть. Это также известно как округление «обрезанием». pure на всех платформах.

Примеры:

writeln(trunc(0.01)); // 0
writeln(trunc(0.49)); // 0
writeln(trunc(0.5)); // 0
writeln(trunc(1.5)); // 1

nothrow @nogc @trusted real remainder(real x, real y);

nothrow @nogc @trusted real remquo(real x, real y, out int n);

Вычислите остаток x REM y, следуя IEC 60559.

REM — это значение x - y * n, где n — целое число, ближайшее к точному значению x / y. Если |n - x / y| == 0,5, n чётное. Если результат равен нулю, он имеет тот же знак, что и x. В противном случае знак результата — знак x / y. Режим точности не влияет на функции остатка.

remquo возвращает n в параметре n.

Значения по умолчанию

x	y	remainder(x, y)	n	ошибка?
±0.0	не 0.0	±0.0	0.0	нет
±∞	любое	-НЕЧЁТНОСТЬ	?	да
любое	±0.0	±НЕЧЁТНОСТЬ	?	да
!= ±∞	±∞	x	?	нет

Примеры:

assert(remainder(5.1, 3.0).feqrel(-0.9) > 16);
assert(remainder(-5.1, 3.0).feqrel(0.9) > 16);
writeln(remainder(0.0, 3.0)); // 0.0

assert(isNaN(remainder(1.0, 0.0)));
assert(isNaN(remainder(-1.0, 0.0)));

Примеры:

int n;

assert(remquo(5.1, 3.0, n).feqrel(-0.9) > 16 && n == 2);
assert(remquo(-5.1, 3.0, n).feqrel(0.9) > 16 && n == -2);
assert(remquo(0.0, 3.0, n) == 0.0 && n == 0);

struct IeeeFlags;

Флаги состояния исключений IEEE ('постоянные биты')

Эти флаги указывают на возникновение исключительного условия с плавающей точкой. Они указывают, что был сгенерирован NaN или бесконечность, что результат неточен или был встречен сигнализирующий NaN. Если исключения с плавающей точкой включены (не замаскированы), вместо установки этих флагов будет сгенерировано аппаратное исключение.

Примеры:

static void func() {
    int a = 10 * 10;
}
pragma(inline, false) static void blockopt(ref real x) {}
real a = 3.5;
// Set all the flags to zero
resetIeeeFlags();
assert(!ieeeFlags.divByZero);
blockopt(a); // avoid constant propagation by the optimizer
// Perform a division by zero.
a /= 0.0L;
writeln(a); // real.infinity
assert(ieeeFlags.divByZero);
blockopt(a); // avoid constant propagation by the optimizer
// Create a NaN
a *= 0.0L;
assert(ieeeFlags.invalid);
assert(isNaN(a));

// Check that calling func() has no effect on the
// status flags.
IeeeFlags f = ieeeFlags;
func();
writeln(ieeeFlags); // f

const nothrow @nogc @property @safe bool inexact();

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

Пример

x = sin(0.1);

const nothrow @nogc @property @safe bool underflow();

Ноль был сгенерирован при переполнении

Пример

x = real.min*real.epsilon/2;

const nothrow @nogc @property @safe bool overflow();

Бесконечность была сгенерирована при переполнении

Пример

x = real.max*2;

const nothrow @nogc @property @safe bool divByZero();

Бесконечность была сгенерирована при делении на ноль

Пример

x = 3/0.0;

const nothrow @nogc @property @safe bool invalid();

Была сгенерирована машинная NaN.

Пример

x = real.infinity * 0.0;

nothrow @nogc @trusted void resetIeeeFlags();

Установить все флаги состояния с плавающей точкой в значение false.

Примеры:

pragma(inline, false) static void blockopt(ref real x) {}
resetIeeeFlags();
real a = 3.5;
blockopt(a); // avoid constant propagation by the optimizer
a /= 0.0L;
blockopt(a); // avoid constant propagation by the optimizer
writeln(a); // real.infinity
assert(ieeeFlags.divByZero);

resetIeeeFlags();
assert(!ieeeFlags.divByZero);

pure nothrow @nogc @property @trusted IeeeFlags ieeeFlags();

Возвращает:

снимок текущего состояния флагов статуса с плавающей точкой

Примеры:

pragma(inline, false) static void blockopt(ref real x) {}
resetIeeeFlags();
real a = 3.5;
blockopt(a); // avoid constant propagation by the optimizer

a /= 0.0L;
writeln(a); // real.infinity
assert(ieeeFlags.divByZero);
blockopt(a); // avoid constant propagation by the optimizer

a *= 0.0L;
assert(isNaN(a));
assert(ieeeFlags.invalid);

struct FloatingPointControl;

Управлять аппаратным обеспечением с плавающей точкой

Изменить режим округления IEEE754 с плавающей точкой и аппаратные исключения с плавающей точкой.

По умолчанию, режим округления — roundToNearest, и все аппаратные исключения отключены. Для большинства приложений отладка проще, если исключения деления на ноль, переполнения и некорректной операции включены. Эти три объединены в значение severeExceptions для удобства. Обратите особое внимание, что если invalidException включен, при использовании неинициализированной переменной с плавающей точкой будет сгенерирована аппаратная ловушка.

Все изменения временны. Предыдущее состояние восстанавливается по окончании области видимости.

Пример

{
    FloatingPointControl fpctrl;

    // Enable hardware exceptions for division by zero, overflow to infinity,
    // invalid operations, and uninitialized floating-point variables.
    fpctrl.enableExceptions(FloatingPointControl.severeExceptions);

    // This will generate a hardware exception, if x is a
    // default-initialized floating point variable:
    real x; // Add `= 0` or even `= real.nan` to not throw the exception.
    real y = x * 3.0;

    // The exception is only thrown for default-uninitialized NaN-s.
    // NaN-s with other payload are valid:
    real z = y * real.nan; // ok

    // The set hardware exceptions and rounding modes will be disabled when
    // leaving this scope.
}

Примеры:

FloatingPointControl fpctrl;

fpctrl.rounding = FloatingPointControl.roundDown;
writeln(lrint(1.5)); // 1.0

fpctrl.rounding = FloatingPointControl.roundUp;
writeln(lrint(1.4)); // 2.0

fpctrl.rounding = FloatingPointControl.roundToNearest;
writeln(lrint(1.5)); // 2.0

alias RoundingMode = uint;

roundToNearest

roundDown

roundUp

roundToZero

roundingMask

Режимы округления IEEE. Режим по умолчанию — roundToNearest.

roundingMask = Маска всех режимов округления.

nothrow @nogc @property @trusted void rounding(RoundingMode newMode);

Изменить режим округления аппаратного обеспечения с плавающей точкой

Изменение режима округления в середине функции может повлиять на оптимизацию выражений с плавающей точкой, поскольку оптимизатор предполагает, что режим округления не меняется. Лучше всего изменить режим округления только в начале функции и сохранить его до возврата функции. Также лучше добавить строку:

pragma(inline, false);

в качестве первой строки функции, чтобы она не была встроена.

Параметры:

RoundingMode newMode

новый режим округления

static pure nothrow @nogc @property @trusted RoundingMode rounding();

Возвращает:

текущий активный режим округления

alias ExceptionMask = uint;

subnormalException

inexactException

underflowException

overflowException

divByZeroException

invalidException

severeExceptions

allExceptions

Аппаратные исключения IEEE. По умолчанию все исключения замаскированы (отключены).

severeExceptions = Исключения переполнения, деления на ноль и некорректной операции.

static pure nothrow @nogc @property @safe bool hasExceptionTraps();

Возвращает:

true, если текущий FPU поддерживает отлов исключений

nothrow @nogc @trusted void enableExceptions(ExceptionMask exceptions);

Включить (разоблачить) определенные аппаратные исключения. Несколько исключений могут быть объединены через операцию OR.

nothrow @nogc @trusted void disableExceptions(ExceptionMask exceptions);

Отключить (замаскировать) определенные аппаратные исключения. Несколько исключений могут быть объединены через операцию OR.

static pure nothrow @nogc @property @trusted ExceptionMask enabledExceptions();

Возвращает:

исключения, которые в настоящее время включены (не замаскированы)

pure nothrow @nogc @trusted bool isNaN(X)(X x)
Constraints: if (isFloatingPoint!X);

Определяет, является ли x NaN.

Параметры:

X x	число с плавающей точкой.

Возвращает:

true если x является NaN.

Примеры:

assert( isNaN(float.init));
assert( isNaN(-double.init));
assert( isNaN(real.nan));
assert( isNaN(-real.nan));
assert(!isNaN(cast(float) 53.6));
assert(!isNaN(cast(real)-53.6));

pure nothrow @nogc @trusted bool isFinite(X)(X x);

Определяет, является ли x конечным.

Параметры:

X x	число с плавающей точкой.

Возвращает:

true если x является конечным.

Примеры:

assert( isFinite(1.23f));
assert( isFinite(float.max));
assert( isFinite(float.min_normal));
assert(!isFinite(float.nan));
assert(!isFinite(float.infinity));

pure nothrow @nogc @trusted bool isNormal(X)(X x);

Определяет, является ли x нормализованным.

Нормализованное число не должно быть нулём, субнормальным, бесконечным или NAN.

Параметры:

X x	число с плавающей точкой.

Возвращает:

true если x нормализован.

Примеры:

float f = 3;
double d = 500;
real e = 10e+48;

assert(isNormal(f));
assert(isNormal(d));
assert(isNormal(e));
f = d = e = 0;
assert(!isNormal(f));
assert(!isNormal(d));
assert(!isNormal(e));
assert(!isNormal(real.infinity));
assert(isNormal(-real.max));
assert(!isNormal(real.min_normal/4));

pure nothrow @nogc @trusted bool isSubnormal(X)(X x);

Определяет, является ли x субнормальным.

Субнормальные числа (также известные как «денормализованные числа»), имеют 0 экспоненту и 0 бит значимых разрядов мантиссы.

Параметры:

X x	число с плавающей точкой.

Возвращает:

true если x — денормализованное число.

Примеры:

import std.meta : AliasSeq;

static foreach (T; AliasSeq!(float, double, real))
{{
    T f;
    for (f = 1.0; !isSubnormal(f); f /= 2)
        assert(f != 0);
}}

pure nothrow @nogc @trusted bool isInfinity(X)(X x)
Constraints: if (isFloatingPoint!X);

Определяет, является ли x ±∞.

Параметры:

X x	число с плавающей точкой.

Возвращает:

true если x является ±∞.

Примеры:

assert(!isInfinity(float.init));
assert(!isInfinity(-float.init));
assert(!isInfinity(float.nan));
assert(!isInfinity(-float.nan));
assert(isInfinity(float.infinity));
assert(isInfinity(-float.infinity));
assert(isInfinity(-1.0f / 0.0f));

pure nothrow @nogc @trusted bool isIdentical(real x, real y);

Является ли двоичное представление x идентичным y?

Примеры:

assert( isIdentical(0.0, 0.0));
assert( isIdentical(1.0, 1.0));
assert( isIdentical(real.infinity, real.infinity));
assert( isIdentical(-real.infinity, -real.infinity));

assert(!isIdentical(0.0, -0.0));
assert(!isIdentical(real.nan, -real.nan));
assert(!isIdentical(real.infinity, -real.infinity));

pure nothrow @nogc @trusted int signbit(X)(X x);

Возвращает 1, если бит знака e установлен, 0 — если нет.

Примеры:

assert(!signbit(float.nan));
assert(signbit(-float.nan));
assert(!signbit(168.1234f));
assert(signbit(-168.1234f));
assert(!signbit(0.0f));
assert(signbit(-0.0f));
assert(signbit(-float.max));
assert(!signbit(float.max));

assert(!signbit(double.nan));
assert(signbit(-double.nan));
assert(!signbit(168.1234));
assert(signbit(-168.1234));
assert(!signbit(0.0));
assert(signbit(-0.0));
assert(signbit(-double.max));
assert(!signbit(double.max));

assert(!signbit(real.nan));
assert(signbit(-real.nan));
assert(!signbit(168.1234L));
assert(signbit(-168.1234L));
assert(!signbit(0.0L));
assert(signbit(-0.0L));
assert(signbit(-real.max));
assert(!signbit(real.max));

pure nothrow @nogc @trusted R copysign(R, X)(R to, X from)
Constraints: if (isFloatingPoint!R && isFloatingPoint!X);

pure nothrow @nogc @trusted R copysign(R, X)(X to, R from)
Constraints: if (isIntegral!X && isFloatingPoint!R);

Параметры:

R to	числовое значение для использования
X from	значение знака для использования

Возвращает:

значение, составленное из to с битом знака from.

Примеры:

writeln(copysign(1.0, 1.0)); // 1.0
writeln(copysign(1.0, -0.0)); // -1.0
writeln(copysign(1UL, -1.0)); // -1.0
writeln(copysign(-1.0, -1.0)); // -1.0

writeln(copysign(real.infinity, -1.0)); // -real.infinity
assert(copysign(real.nan, 1.0) is real.nan);
assert(copysign(-real.nan, 1.0) is real.nan);
assert(copysign(real.nan, -1.0) is -real.nan);

pure nothrow @nogc @safe F sgn(F)(F x)
Constraints: if (isFloatingPoint!F || isIntegral!F);

Возвращает -1 если x < 0, x если x == 0, 1 если x > 0, и NAN если x==NAN.

Примеры:

writeln(sgn(168.1234)); // 1
writeln(sgn(-168.1234)); // -1
writeln(sgn(0.0)); // 0
writeln(sgn(-0.0)); // 0

pure nothrow @nogc @trusted real NaN(ulong payload);

Создайте тихий NAN, сохраняя целое число внутри полезной нагрузки.

Для чисел с плавающей запятой максимальный размер полезной нагрузки составляет 0x3F_FFFF. Для чисел двойной точности — 0x3_FFFF_FFFF_FFFF. Для 80-битных или 128-битных вещественных чисел — 0x3FFF_FFFF_FFFF_FFFF.

Примеры:

real a = NaN(1_000_000);
assert(isNaN(a));
writeln(getNaNPayload(a)); // 1_000_000

pure nothrow @nogc @trusted ulong getNaNPayload(real x);

Извлечь целую полезную нагрузку из NAN.

Возвращает:

целую полезную нагрузку как ulong. Для чисел с плавающей запятой максимальный размер полезной нагрузки составляет 0x3F_FFFF. Для чисел двойной точности — 0x3_FFFF_FFFF_FFFF. Для 80-битных или 128-битных вещественных чисел — 0x3FFF_FFFF_FFFF_FFFF.

Примеры:

real a = NaN(1_000_000);
assert(isNaN(a));
writeln(getNaNPayload(a)); // 1_000_000

pure nothrow @nogc @trusted real nextUp(real x);

pure nothrow @nogc @trusted double nextUp(double x);

pure nothrow @nogc @trusted float nextUp(float x);

Вычислить следующее по величине значение с плавающей запятой после x.

Возвращает наименьшее число, большее x, которое может быть представлено как вещественное число; таким образом, оно даёт следующую точку на числовой прямой IEEE.

Значения особых случаев

x	nextUp(x)
-∞	-real.max
±0.0	real.min_normal*real.epsilon
real.max	∞
∞	∞
NAN	NAN

Примеры:

assert(nextUp(1.0 - 1.0e-6).feqrel(0.999999) > 16);
assert(nextUp(1.0 - real.epsilon).feqrel(1.0) > 16);

pure nothrow @nogc @safe real nextDown(real x);

pure nothrow @nogc @safe double nextDown(double x);

pure nothrow @nogc @safe float nextDown(float x);

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

Возвращает наибольшее число, меньшее x, которое может быть представлено как вещественное число; таким образом, оно даёт предыдущую точку на числовой прямой IEEE.

Значения особых случаев

x	nextDown(x)
∞	real.max
±0.0	-real.min_normal*real.epsilon
-real.max	-∞
-∞	-∞
NAN	NAN

Примеры:

writeln(nextDown(1.0 + real.epsilon)); // 1.0

pure nothrow @nogc @safe T nextafter(T)(const T x, const T y);

Вычисляет следующее представимое значение после x в направлении y.

Если y > x, результат будет следующим по величине значением с плавающей запятой; если y < x, результат будет следующим по величине значением. Если x == y, результат — y. Если x или y — NaN, результат — NaN.

Примечания

Эта функция обычно не очень полезна; почти всегда лучше использовать более быстрые функции nextUp() или nextDown() вместо неё.

Исключение FE_INEXACT и FE_OVERFLOW будет возбуждено, если x конечное, а результат функции — бесконечный. Исключение FE_INEXACT и FE_UNDERFLOW будет возбуждено, если значение функции — субнормальное, и x не равно y.

Примеры:

float a = 1;
assert(is(typeof(nextafter(a, a)) == float));
assert(nextafter(a, a.infinity) > a);
assert(isNaN(nextafter(a, a.nan)));
assert(isNaN(nextafter(a.nan, a)));

double b = 2;
assert(is(typeof(nextafter(b, b)) == double));
assert(nextafter(b, b.infinity) > b);
assert(isNaN(nextafter(b, b.nan)));
assert(isNaN(nextafter(b.nan, b)));

real c = 3;
assert(is(typeof(nextafter(c, c)) == real));
assert(nextafter(c, c.infinity) > c);
assert(isNaN(nextafter(c, c.nan)));
assert(isNaN(nextafter(c.nan, c)));

pure nothrow @nogc @safe real fdim(real x, real y);

Возвращает положительную разность между x и y.

Эквивалентно fmax(x-y, 0).

Возвращает:

Значения особых случаев

x, y	fdim(x, y)
x > y	x - y
x <= y	+0.0

Примеры:

writeln(fdim(2.0, 0.0)); // 2.0
writeln(fdim(-2.0, 0.0)); // 0.0
writeln(fdim(real.infinity, 2.0)); // real.infinity
assert(isNaN(fdim(real.nan, 2.0)));
assert(isNaN(fdim(2.0, real.nan)));
assert(isNaN(fdim(real.nan, real.nan)));

pure nothrow @nogc @safe F fmax(F)(const F x, const F y)
Constraints: if (__traits(isFloating, F));

Возвращает большее из x и y.

Если один из аргументов — NaN, возвращается другой.

См. также:

std.algorithm.comparison.max быстрее, так как не выполняет проверку isNaN.

Примеры:

import std.meta : AliasSeq;
static foreach (F; AliasSeq!(float, double, real))
{
    writeln(fmax(F(0.0), F(2.0))); // 2.0
    writeln(fmax(F(-2.0), 0.0)); // F(0.0)
    writeln(fmax(F.infinity, F(2.0))); // F.infinity
    writeln(fmax(F.nan, F(2.0))); // F(2.0)
    writeln(fmax(F(2.0), F.nan)); // F(2.0)
}

pure nothrow @nogc @safe F fmin(F)(const F x, const F y)
Constraints: if (__traits(isFloating, F));

Возвращает меньшее из x и y.

Если один из аргументов — NaN, возвращается другой.

См. также:

std.algorithm.comparison.min быстрее, так как не выполняет проверку isNaN.

Примеры:

import std.meta : AliasSeq;
static foreach (F; AliasSeq!(float, double, real))
{
    writeln(fmin(F(0.0), F(2.0))); // 0.0
    writeln(fmin(F(-2.0), F(0.0))); // -2.0
    writeln(fmin(F.infinity, F(2.0))); // 2.0
    writeln(fmin(F.nan, F(2.0))); // 2.0
    writeln(fmin(F(2.0), F.nan)); // 2.0
}

pure nothrow @nogc @safe real fma(real x, real y, real z);

Возвращает (x * y) + z, округляя только один раз в соответствии с текущим режимом округления.

Ошибки:

В настоящее время не реализовано — округляет дважды.

Примеры:

writeln(fma(0.0, 2.0, 2.0)); // 2.0
writeln(fma(2.0, 2.0, 2.0)); // 6.0
writeln(fma(real.infinity, 2.0, 2.0)); // real.infinity
assert(fma(real.nan, 2.0, 2.0) is real.nan);
assert(fma(2.0, 2.0, real.nan) is real.nan);

pure nothrow @nogc @trusted Unqual!F pow(F, G)(F x, G n)
Constraints: if (isFloatingPoint!F && isIntegral!G);

Вычислить значение x ⁿ, где n — целое число

Примеры:

writeln(pow(2.0, 5)); // 32.0
assert(pow(1.5, 9).feqrel(38.4433) > 16);
assert(pow(real.nan, 2) is real.nan);
writeln(pow(real.infinity, 2)); // real.infinity

pure nothrow @nogc @trusted typeof(Unqual!F.init * Unqual!G.init) pow(F, G)(F x, G n)
Constraints: if (isIntegral!F && isIntegral!G);

Вычислить степень двух целых чисел.

Параметры:

F x	основание
G n	показатель степени

Возвращает:

x в степени n. Если n отрицательно, результат равен 1 / pow(x, -n), который вычисляется как целочисленное деление с остатком. Это может привести к ошибке деления на ноль. Если и x, и n равны 0, результат равен 1.

Исключения:

Если x равен 0, а n отрицательно, результат такой же, как при делении на ноль.

Примеры:

writeln(pow(2, 3)); // 8
writeln(pow(3, 2)); // 9

writeln(pow(2, 10)); // 1_024
writeln(pow(2, 20)); // 1_048_576
writeln(pow(2, 30)); // 1_073_741_824

writeln(pow(0, 0)); // 1

writeln(pow(1, -5)); // 1
writeln(pow(1, -6)); // 1
writeln(pow(-1, -5)); // -1
writeln(pow(-1, -6)); // 1

writeln(pow(-2, 5)); // -32
writeln(pow(-2, -5)); // 0
writeln(pow(cast(double)-2, -5)); // -0.03125

pure nothrow @nogc @trusted real pow(I, F)(I x, F y)
Constraints: if (isIntegral!I && isFloatingPoint!F);

Вычисляет степени целого числа до числа с плавающей запятой.

Примеры:

writeln(pow(2, 5.0)); // 32.0
writeln(pow(7, 3.0)); // 343.0
assert(pow(2, real.nan) is real.nan);
writeln(pow(2, real.infinity)); // real.infinity

pure nothrow @nogc @trusted Unqual!(Largest!(F, G)) pow(F, G)(F x, G y)
Constraints: if (isFloatingPoint!F && isFloatingPoint!G);

Вычисляет x^y.

Значения особых случаев

x	y	pow(x, y)	div 0	недействительно?
любое	±0.0	1.0	нет	нет
|x| > 1	+∞	+∞	нет	нет
|x| < 1	+∞	+0.0	нет	нет
|x| > 1	-∞	+0.0	нет	нет
|x| < 1	-∞	+∞	нет	нет
+∞	> 0.0	+∞	нет	нет
+∞	< 0.0	+0.0	нет	нет
-∞	нечётное целое > 0.0	-∞	нет	нет
-∞	> 0.0, не нечётное целое	+∞	нет	нет
-∞	нечётное целое < 0.0	-0.0	нет	нет
-∞	< 0.0, не нечётное целое	+0.0	нет	нет
±1.0	±∞	-NAN	нет	да
< 0.0	конечное, нецелое	NAN	нет	да
±0.0	нечётное целое < 0.0	±∞	да	нет
±0.0	< 0.0, не нечётное целое	+∞	да	нет
±0.0	нечётное целое > 0.0	±0.0	нет	нет
±0.0	> 0.0, не нечётное целое	+0.0	нет	нет

Примеры:

writeln(pow(1.0, 2.0)); // 1.0
writeln(pow(0.0, 0.0)); // 1.0
assert(pow(1.5, 10.0).feqrel(57.665) > 16);

// special values
writeln(pow(1.5, real.infinity)); // real.infinity
writeln(pow(0.5, real.infinity)); // 0.0
writeln(pow(1.5, -real.infinity)); // 0.0
writeln(pow(0.5, -real.infinity)); // real.infinity
writeln(pow(real.infinity, 1.0)); // real.infinity
writeln(pow(real.infinity, -1.0)); // 0.0
writeln(pow(-real.infinity, 1.0)); // -real.infinity
writeln(pow(-real.infinity, 2.0)); // real.infinity
writeln(pow(-real.infinity, -1.0)); // -0.0
writeln(pow(-real.infinity, -2.0)); // 0.0
assert(pow(1.0, real.infinity) is -real.nan);
writeln(pow(0.0, -1.0)); // real.infinity
writeln(pow(real.nan, 0.0)); // 1.0

Unqual!(Largest!(F, H)) powmod(F, G, H)(F x, G n, H m)
Constraints: if (isUnsigned!F && isUnsigned!G && isUnsigned!H);

Вычисляет значение положительного целого x, возведённого в степень n, по модулю m.

Параметры:

F x	основание
G n	показатель степени
H m	модуль

Возвращает:

x в степени n, по модулю m. Тип возвращаемого значения — наибольший из типов x и m. Функция требует, чтобы все значения имели беззнаковые типы.

Примеры:

writeln(powmod(1U, 10U, 3U)); // 1
writeln(powmod(3U, 2U, 6U)); // 3
writeln(powmod(5U, 5U, 15U)); // 5
writeln(powmod(2U, 3U, 5U)); // 3
writeln(powmod(2U, 4U, 5U)); // 1
writeln(powmod(2U, 5U, 5U)); // 2

pure nothrow @nogc @trusted int feqrel(X)(const X x, const X y)
Constraints: if (isFloatingPoint!X);

С какой точностью x равно y?

Возвращает:

количество бит мантиссы, равных в x и y. Например, 0x1.F8p+60 и 0x1.F1p+60 равны по 5 битам точности.

Значения особых случаев

x	y	feqrel(x, y)
x	x	real.mant_dig
x	>= 2*x	0
x	<= x/2	0
NAN	любое	0
любое	NAN	0

Примеры:

writeln(feqrel(2.0, 2.0)); // 53
writeln(feqrel(2.0f, 2.0f)); // 24
writeln(feqrel(2.0, double.nan)); // 0

// Test that numbers are within n digits of each
// other by testing if feqrel > n * log2(10)

// five digits
assert(feqrel(2.0, 2.00001) > 16);
// ten digits
assert(feqrel(2.0, 2.00000000001) > 33);

pure nothrow @nogc @trusted Unqual!(CommonType!(T1, T2)) poly(T1, T2)(T1 x, in T2[] A)
Constraints: if (isFloatingPoint!T1 && isFloatingPoint!T2);

pure nothrow @nogc @safe Unqual!(CommonType!(T1, T2)) poly(T1, T2, int N)(T1 x, ref const T2[N] A)
Constraints: if (isFloatingPoint!T1 && isFloatingPoint!T2 && (N > 0) && (N <= 10));

Вычислить многочлен A(x) = a₀ + a₁x + a₂x² + a₃x³; ...

Использует правило Хорнера A(x) = a₀ + x(a₁ + x(a₂ + x(a₃ + ...)))

Параметры:

T1 x	значение для вычисления.
T2[] A	массив коэффициентов a0, a1 и т. д.

Примеры:

real x = 3.1L;
static real[] pp = [56.1L, 32.7L, 6];

writeln(poly(x, pp)); // (56.1L + (32.7L + 6.0L * x) * x)

bool approxEqual(T, U, V)(T value, U reference, V maxRelDiff = 0.01, V maxAbsDiff = 1e-05);

Определяет, приблизительно ли значение равно эталонному значению, допускает максимальное относительное и максимальное абсолютное отклонение.

Параметры:

T value	Значение для сравнения.
U reference	Эталонное значение.
V maxRelDiff	Максимальное допустимое отклонение относительно reference. Установка в 0.0 отключает эту проверку. По умолчанию 1e-2.
V maxAbsDiff	Максимальное абсолютное отклонение. Это особенно полезно для сравнения значений с нулём. Установка в 0.0 отключает эту проверку. По умолчанию 1e-5.

Возвращает:

true если value приблизительно равно reference по одному из критериев. Достаточно, если value удовлетворяет одному из двух критериев. Если один элемент является диапазоном, а другой — одиночным значением, результат — логическое «И» вызовов approxEqual для каждого элемента диапазона против одиночного элемента. Если оба элемента являются диапазонами, approxEqual возвращает true, только если диапазоны имеют одинаковое количество элементов и если approxEqual возвращает true для каждой пары элементов.

См. также:

Используйте feqrel, чтобы получить количество совпадающих битов в мантиссе.

Примеры:

assert(approxEqual(1.0, 1.0099));
assert(!approxEqual(1.0, 1.011));
assert(approxEqual(0.00001, 0.0));
assert(!approxEqual(0.00002, 0.0));

assert(approxEqual(3.0, [3, 3.01, 2.99])); // several reference values is strange
assert(approxEqual([3, 3.01, 2.99], 3.0)); // better

float[] arr1 = [ 1.0, 2.0, 3.0 ];
double[] arr2 = [ 1.001, 1.999, 3 ];
assert(approxEqual(arr1, arr2));

Примеры:

// relative comparison depends on reference, make sure proper
// side is used when comparing range to single value. Based on
// https://issues.dlang.org/show_bug.cgi?id=15763
auto a = [2e-3 - 1e-5];
auto b = 2e-3 + 1e-5;
assert(a[0].approxEqual(b));
assert(!b.approxEqual(a[0]));
assert(a.approxEqual(b));
assert(!b.approxEqual(a));

Примеры:

assert(!approxEqual(0.0,1e-15,1e-9,0.0));
assert(approxEqual(0.0,1e-15,1e-9,1e-9));
assert(!approxEqual(1.0,3.0,0.0,1.0));

assert(approxEqual(1.00000000099,1.0,1e-9,0.0));
assert(!approxEqual(1.0000000011,1.0,1e-9,0.0));

Примеры:

// maybe unintuitive behavior
assert(approxEqual(1000.0,1010.0));
assert(approxEqual(9_090_000_000.0,9_000_000_000.0));
assert(approxEqual(0.0,1e30,1.0));
assert(approxEqual(0.00001,1e-30));
assert(!approxEqual(-1e-30,1e-30,1e-2,0.0));

bool isClose(T, U, V = CommonType!(FloatingPointBaseType!T, FloatingPointBaseType!U))(T lhs, U rhs, V maxRelDiff = CommonDefaultFor!(T, U), V maxAbsDiff = 0.0);

Определяет, приблизительно ли два значения равны, допускает максимальное относительное и максимальное абсолютное отклонение.

Параметры:

T lhs	Первый элемент для сравнения.
U rhs	Второй элемент для сравнения.
V maxRelDiff	Максимальное допустимое относительное отклонение. Установка в 0.0 отключает эту проверку. Значение по умолчанию зависит от типа lhs и rhs: приблизительно половина количества десятичных знаков точности меньшего типа.
V maxAbsDiff	Максимальное абсолютное отклонение. Это особенно полезно для сравнения значений с нулём. Установка в 0.0 отключает эту проверку. По умолчанию 0.0.

Возвращает:

true если два элемента приблизительно равны по одному из критериев. Достаточно, если value удовлетворяет одному из двух критериев. Если один элемент является диапазоном, а другой — одиночным значением, результат — логическое «И» вызовов isClose для каждого элемента диапазона против одиночного элемента. Если оба элемента являются диапазонами, isClose возвращает true, только если диапазоны имеют одинаковое количество элементов и если isClose возвращает true для каждой пары элементов.

См. также:

Используйте feqrel для получения количества совпадающих битов в мантиссе.

Примеры:

assert(isClose(1.0,0.999_999_999));
assert(isClose(0.001, 0.000_999_999_999));
assert(isClose(1_000_000_000.0,999_999_999.0));

assert(isClose(17.123_456_789, 17.123_456_78));
assert(!isClose(17.123_456_789, 17.123_45));

// use explicit 3rd parameter for less (or more) accuracy
assert(isClose(17.123_456_789, 17.123_45, 1e-6));
assert(!isClose(17.123_456_789, 17.123_45, 1e-7));

// use 4th parameter when comparing close to zero
assert(!isClose(1e-100, 0.0));
assert(isClose(1e-100, 0.0, 0.0, 1e-90));
assert(!isClose(1e-10, -1e-10));
assert(isClose(1e-10, -1e-10, 0.0, 1e-9));
assert(!isClose(1e-300, 1e-298));
assert(isClose(1e-300, 1e-298, 0.0, 1e-200));

// different default limits for different floating point types
assert(isClose(1.0f, 0.999_99f));
assert(!isClose(1.0, 0.999_99));
static if (real.sizeof > double.sizeof)
    assert(!isClose(1.0L, 0.999_999_999L));

Примеры:

assert(isClose([1.0, 2.0, 3.0], [0.999_999_999, 2.000_000_001, 3.0]));
assert(!isClose([1.0, 2.0], [0.999_999_999, 2.000_000_001, 3.0]));
assert(!isClose([1.0, 2.0, 3.0], [0.999_999_999, 2.000_000_001]));

assert(isClose([2.0, 1.999_999_999, 2.000_000_001], 2.0));
assert(isClose(2.0, [2.0, 1.999_999_999, 2.000_000_001]));

pure nothrow @nogc @trusted int cmp(T)(const(T) x, const(T) y)
Constraints: if (isFloatingPoint!T);

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

Порядок определяется следующим образом:

• Все числа в [-∞, +∞] упорядочиваются так же, как при встроенном сравнении, за исключением -0.0, которое меньше +0.0;
• Если бит знака установлен (то есть это 'отрицательное'), NAN меньше любого числа; если бит знака не установлен (это 'положительное'), NAN больше любого числа;
• NANы одного знака упорядочиваются по содержимому ('отрицательные' — в обратном порядке).

Возвращает:

отрицательное значение, если x предшествует y в указанном выше порядке; 0, если x и y идентичны, и положительное значение в противном случае.

См. также:

isIdentical

Стандарты:

Соответствует IEEE 754-2008

Примеры:

Большинство чисел упорядочены естественным образом.

assert(cmp(-double.infinity, -double.max) < 0);
assert(cmp(-double.max, -100.0) < 0);
assert(cmp(-100.0, -0.5) < 0);
assert(cmp(-0.5, 0.0) < 0);
assert(cmp(0.0, 0.5) < 0);
assert(cmp(0.5, 100.0) < 0);
assert(cmp(100.0, double.max) < 0);
assert(cmp(double.max, double.infinity) < 0);

writeln(cmp(1.0, 1.0)); // 0

Примеры:

Положительные и отрицательные нули различны.

assert(cmp(-0.0, +0.0) < 0);
assert(cmp(+0.0, -0.0) > 0);

Примеры:

В зависимости от знака, NANы идут к одному из концов спектра.

assert(cmp(-double.nan, -double.infinity) < 0);
assert(cmp(double.infinity, double.nan) < 0);
assert(cmp(-double.nan, double.nan) < 0);

Примеры:

NANы одного знака упорядочиваются по содержимому.

assert(cmp(NaN(10), NaN(20)) < 0);
assert(cmp(-NaN(20), -NaN(10)) < 0);

T nextPow2(T)(const T val)
Constraints: if (isIntegral!T);

T nextPow2(T)(const T val)
Constraints: if (isFloatingPoint!T);

Возвращает следующую степень двойки после val. T может быть любым встроенным числовым типом.

Если операция приведёт к переполнению/подполнению, функция вернёт 0.

Параметры:

T val

любое число

Возвращает:

следующую степень двойки после val

Примеры:

writeln(nextPow2(2)); // 4
writeln(nextPow2(10)); // 16
writeln(nextPow2(4000)); // 4096

writeln(nextPow2(-2)); // -4
writeln(nextPow2(-10)); // -16

writeln(nextPow2(uint.max)); // 0
writeln(nextPow2(uint.min)); // 0
writeln(nextPow2(size_t.max)); // 0
writeln(nextPow2(size_t.min)); // 0

writeln(nextPow2(int.max)); // 0
writeln(nextPow2(int.min)); // 0
writeln(nextPow2(long.max)); // 0
writeln(nextPow2(long.min)); // 0

Примеры:

writeln(nextPow2(2.1)); // 4.0
writeln(nextPow2(-2.0)); // -4.0
writeln(nextPow2(0.25)); // 0.5
writeln(nextPow2(-4.0)); // -8.0

writeln(nextPow2(double.max)); // 0.0
writeln(nextPow2(double.infinity)); // double.infinity

T truncPow2(T)(const T val)
Constraints: if (isIntegral!T);

T truncPow2(T)(const T val)
Constraints: if (isFloatingPoint!T);

Возвращает последнюю степень двойки перед val. <>> может быть любым встроенным числовым типом.

Параметры:

T val

любое число

Возвращает:

последнюю степень двойки перед val

Примеры:

writeln(truncPow2(3)); // 2
writeln(truncPow2(4)); // 4
writeln(truncPow2(10)); // 8
writeln(truncPow2(4000)); // 2048

writeln(truncPow2(-5)); // -4
writeln(truncPow2(-20)); // -16

writeln(truncPow2(uint.max)); // int.max + 1
writeln(truncPow2(uint.min)); // 0
writeln(truncPow2(ulong.max)); // long.max + 1
writeln(truncPow2(ulong.min)); // 0

writeln(truncPow2(int.max)); // (int.max / 2) + 1
writeln(truncPow2(int.min)); // int.min
writeln(truncPow2(long.max)); // (long.max / 2) + 1
writeln(truncPow2(long.min)); // long.min

Примеры:

writeln(truncPow2(2.1)); // 2.0
writeln(truncPow2(7.0)); // 4.0
writeln(truncPow2(-1.9)); // -1.0
writeln(truncPow2(0.24)); // 0.125
writeln(truncPow2(-7.0)); // -4.0

writeln(truncPow2(double.infinity)); // double.infinity

pure nothrow @nogc @safe bool isPowerOf2(X)(const X x)
Constraints: if (isNumeric!X);

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

Обратите внимание, что только положительные числа могут быть целыми степенями двойки. Эта функция всегда возвращает false если x отрицательно или равно нулю.

Параметры:

X x	число для проверки

Возвращает:

true если x является целой степенью двойки.

Примеры:

assert( isPowerOf2(1.0L));
assert( isPowerOf2(2.0L));
assert( isPowerOf2(0.5L));
assert( isPowerOf2(pow(2.0L, 96)));
assert( isPowerOf2(pow(2.0L, -77)));

assert(!isPowerOf2(-2.0L));
assert(!isPowerOf2(-0.5L));
assert(!isPowerOf2(0.0L));
assert(!isPowerOf2(4.315));
assert(!isPowerOf2(1.0L / 3.0L));

assert(!isPowerOf2(real.nan));
assert(!isPowerOf2(real.infinity));

Примеры:

assert( isPowerOf2(1));
assert( isPowerOf2(2));
assert( isPowerOf2(1uL << 63));

assert(!isPowerOf2(-4));
assert(!isPowerOf2(0));
assert(!isPowerOf2(1337u));