12.6.2. Математические Функции

Таблица 12.12. Математические Функции

Имя	Описание
`ABS()`	Возвратите абсолютное значение
`ACOS()`	Возвратите арккосинус
`ASIN()`	Возвратите арксинус
`ATAN2()`, `ATAN()`	Возвратите арктангенс этих двух параметров
`ATAN()`	Возвратите арктангенс
`CEIL()`	Возвратите самое маленькое целочисленное значение не меньше чем параметр
`CEILING()`	Возвратите самое маленькое целочисленное значение не меньше чем параметр
`CONV()`	Преобразуйте числа между различными основаниями системы счисления
`COS()`	Возвратите косинус
`COT()`	Возвратите котангенс
`CRC32()`	Вычислите значение контроля циклическим избыточным кодом
`DEGREES()`	Преобразуйте радианы в градусы
`EXP()`	Возведите в степень
`FLOOR()`	Возвратите самое большое целочисленное значение, не больше чем параметр
`LN()`	Возвратите натуральный логарифм параметра
`LOG10()`	Возвратите основу 10 логарифмов параметра
`LOG2()`	Возвратите основу 2 логарифма параметра
`LOG()`	Возвратите натуральный логарифм первого параметра
`MOD()`	Возвратите остаток
`PI()`	Возвратите значение пи
`POW()`	Возвратите параметр, повышенный до указанного питания
`POWER()`	Возвратите параметр, повышенный до указанного питания
`RADIANS()`	Возвратите параметр, преобразованный в радианы
`RAND()`	Возвратите случайное значение с плавающей точкой
`ROUND()`	Вокруг параметра
`SIGN()`	Возвратите знак параметра
`SIN()`	Возвратите синус параметра
`SQRT()`	Возвратите квадратный корень параметра
`TAN()`	Возвратите касательную параметра
`TRUNCATE()`	Усеченный к конкретному количеству десятичных разрядов

Весь математический возврат функций NULL в случае ошибки.

ABS(X)

Возвращает абсолютное значение X.
```
mysql> SELECT ABS(2);        -> 2mysql> SELECT ABS(-32);        -> 32
```
Эту функцию безопасно использовать с BIGINT значения.
ACOS(X)

Возвращает арккосинус X, то есть, значение, косинус которого X. Возвраты NULL если X не находится в диапазоне -1 к 1.
```
mysql> SELECT ACOS(1);        -> 0mysql> SELECT ACOS(1.0001);        -> NULLmysql> SELECT ACOS(0);        -> 1.5707963267949
```

ASIN(X)

Возвращает арксинус X, то есть, значение, синус которого X. Возвраты NULL если X не находится в диапазоне -1 к 1.

mysql> SELECT ASIN(0.2);        -> 0.20135792079033mysql> SELECT ASIN('foo');+-------------+| ASIN('foo') |+-------------+|           0 |+-------------+1 row in set, 1 warning (0.00 sec)mysql> SHOW WARNINGS;+---------+------+-----------------------------------------+| Level   | Code | Message                                 |+---------+------+-----------------------------------------+| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |+---------+------+-----------------------------------------+

ATAN(X)

Возвращает арктангенс X, то есть, значение, касательная которого X.
```
mysql> SELECT ATAN(2);        -> 1.1071487177941mysql> SELECT ATAN(-2);        -> -1.1071487177941
```
ATAN(Y,X), ATAN2(Y,X)

Возвращает арктангенс этих двух переменных X и Y. Это подобно вычислению арктангенса Y / X, за исключением того, что знаки обоих параметров используются, чтобы определить квадрант результата.
```
mysql> SELECT ATAN(-2,2);        -> -0.78539816339745mysql> SELECT ATAN2(PI(),0);        -> 1.5707963267949
```
CEIL(X)

CEIL() синоним для CEILING().
CEILING(X)

Возвращает самое маленькое целочисленное значение не меньше чем X.
```
mysql> SELECT
                    CEILING(1.23);        -> 2mysql> SELECT
                    CEILING(-1.23);        -> -1
```
Для точного значения числовые параметры у возвращаемого значения есть точное значение числовой тип. Для строки или параметров с плавающей точкой, у возвращаемого значения есть тип с плавающей точкой.
CONV(N,from_base,to_base)

Преобразовывает числа между различными основаниями системы счисления. Возвращает строковое представление числа N, преобразованный из основы from_base базироваться to_base. Возвраты NULL если какой-либо параметр NULL. Параметр N интерпретируется как целое число, но может быть определен как целое число или строка. Минимальная основа 2 и максимальная основа 36. Если to_base отрицательное число, N расценивается как число со знаком. Иначе, N обрабатывается как без знака. CONV() работы с 64-разрядной точностью.
```
mysql> SELECT
                    CONV('a',16,2);        -> '1010'mysql> SELECT
                    CONV('6E',18,8);        -> '172'mysql> SELECT
                    CONV(-17,10,-18);        -> '-H'mysql> SELECT
                    CONV(10+'10'+'10'+0xa,10,10);        -> '40'
```
COS(X)

Возвращает косинус X, где X дается в радианах.
```
mysql> SELECT COS(PI());        -> -1
```

COT(X)

Возвращает котангенс X.

mysql> SELECT COT(12);        -> -1.5726734063977mysql> SELECT COT(0);        -> NULL

CRC32(expr)

Вычисляет значение контроля циклическим избыточным кодом и возвращает 32-разрядное значение без знака. Результат NULL если параметр NULL. Параметром, как ожидают, будет строка, и (если возможный) обрабатывается как тот, если это не.
```
mysql> SELECT
                    CRC32('MySQL');        -> 3259397556mysql> SELECT
                    CRC32('mysql');        -> 2501908538
```

DEGREES(X)

Возвращает параметр X, преобразованный от радианов до градусов.

mysql> SELECT
                    DEGREES(PI());        -> 180mysql> SELECT
                    DEGREES(PI() / 2);        -> 90

EXP(X)

Возвращает значение e (основа натуральных логарифмов) возведенный в степень X. Инверсия этой функции LOG() (использование единственного параметра только) или LN().
```
mysql> SELECT EXP(2);        -> 7.3890560989307mysql> SELECT
                    EXP(-2);        -> 0.13533528323661mysql> SELECT
                    EXP(0);        -> 1
```
FLOOR(X)

Возвращает самое большое целочисленное значение, не больше чем X.
```
mysql> SELECT
                    FLOOR(1.23);        -> 1mysql> SELECT
                    FLOOR(-1.23);        -> -2
```
Для точного значения числовые параметры у возвращаемого значения есть точное значение числовой тип. Для строки или параметров с плавающей точкой, у возвращаемого значения есть тип с плавающей точкой.
FORMAT(X,D)

Форматирует число X к формату как '#,###,###.##', округленный к D десятичные разряды, и возвраты результат как строка. Для получения дополнительной информации см. Раздел 12.5, "Строковые функции".
HEX(N_or_S)

Эта функция может использоваться, чтобы получить шестнадцатеричное представление десятичного числа или строки; способ, которым это делает так, изменяется согласно типу параметра. См. описание этой функции в Разделе 12.5, "Строковых функциях", для деталей.
LN(X)

Возвращает натуральный логарифм X; то есть, основной-e логарифм X. Если X меньше чем или равно 0, тогда NULL возвращается.
```
mysql> SELECT LN(2);        -> 0.69314718055995mysql> SELECT LN(-2);        -> NULL
```
Эта функция синонимична с LOG(X). Инверсия этой функции EXP() функция.
LOG(X), LOG(B,X)

Если вызвано с одним параметром, эта функция возвращает натуральный логарифм X. Если X меньше чем или равно 0, тогда NULL возвращается.

Инверсия этой функции (когда вызвано с единственным параметром) EXP() функция.
```
mysql> SELECT LOG(2);        -> 0.69314718055995mysql> SELECT LOG(-2);        -> NULL
```
Если вызвано с двумя параметрами, эта функция возвращает логарифм X к основе B. Если X меньше чем или равно 0, или если B меньше чем или равно 1, тогда NULL возвращается.
```
mysql> SELECT
                    LOG(2,65536);        -> 16mysql> SELECT
                    LOG(10,100);        -> 2mysql> SELECT
                    LOG(1,100);        -> NULL
```
LOG(B,X) эквивалентно LOG(X) / LOG(B).
LOG2(X)

Возвращает основу 2 логарифма X.
```
mysql> SELECT
                    LOG2(65536);        -> 16mysql> SELECT
                    LOG2(-100);        -> NULL
```
LOG2() полезно для обнаружения, какого количества битов число требует для хранения. Эта функция эквивалентна выражению LOG(X) / LOG(2).

LOG10(X)

Возвращает основу 10 логарифмов X.

mysql> SELECT LOG10(2);        -> 0.30102999566398mysql> SELECT LOG10(100);        -> 2mysql> SELECT LOG10(-100);        -> NULL

LOG10(X) эквивалентно LOG(10,X).

MOD(N,M), N % M, N MOD M

Работа по модулю. Возвращает остаток от N разделенный на M.
```
mysql> SELECT MOD(234,
                    10);        -> 4mysql> SELECT 253 % 7;        -> 1mysql> SELECT MOD(29,9);        -> 2mysql> SELECT 29 MOD 9;        -> 2
```
Эту функцию безопасно использовать с BIGINT значения.

MOD() также работы над значениями, которые имеют дробную часть и возвращают точный остаток после подразделения:
```
mysql> SELECT
                    MOD(34.5,3);        -> 1.5
```
MOD(N,0) возвраты NULL.
PI()

Возвращает значение π (пи). Число значения по умолчанию выведенных на экран десятичных разрядов семь, но MySQL использует полное значение двойной точности внутренне.
```
mysql> SELECT PI();        -> 3.141593mysql> SELECT PI()+0.000000000000000000;        -> 3.141592653589793116
```

POW(X,Y)

Возвращает значение X возведенный в степень Y.

mysql> SELECT POW(2,2);        -> 4mysql> SELECT POW(2,-2);        -> 0.25

POWER(X,Y)

Это - синоним для POW().
RADIANS(X)

Возвращает параметр X, преобразованный от градусов до радианов. (Отметьте, что π радианы равняются 180 градусам.)
```
mysql> SELECT
                    RADIANS(90);        -> 1.5707963267949
```
RAND(), RAND(N)

Возвращает случайное значение с плавающей точкой v в диапазоне 0 <= v < 1.0. Если постоянный целочисленный параметр N определяется, это используется в качестве значения семени, которое производит повторимую последовательность значений столбцов. В следующем примере отметьте что последовательности значений, произведенных RAND(3) те же самые оба места, где это происходит.
```
mysql> CREATE TABLE t (i
                    INT);Query OK, 0 rows affected (0.42 sec)mysql> INSERT
                    INTO t VALUES(1),(2),(3);Query OK, 3 rows affected (0.00 sec)Records: 3  Duplicates: 0  Warnings: 0mysql> SELECT i, RAND() FROM t;+------+------------------+| i    | RAND()           |+------+------------------+|    1 | 0.61914388706828 ||    2 | 0.93845168309142 ||    3 | 0.83482678498591 |+------+------------------+3 rows in set (0.00 sec)mysql> SELECT i, RAND(3) FROM t;+------+------------------+| i    | RAND(3)          |+------+------------------+|    1 | 0.90576975597606 ||    2 | 0.37307905813035 ||    3 | 0.14808605345719 |+------+------------------+3 rows in set (0.00 sec)mysql> SELECT i, RAND() FROM t;+------+------------------+| i    | RAND()           |+------+------------------+|    1 | 0.35877890638893 ||    2 | 0.28941420772058 ||    3 | 0.37073435016976 |+------+------------------+3 rows in set (0.00 sec)mysql> SELECT i, RAND(3) FROM t;+------+------------------+| i    | RAND(3)          |+------+------------------+|    1 | 0.90576975597606 ||    2 | 0.37307905813035 ||    3 | 0.14808605345719 |+------+------------------+3 rows in set (0.01 sec)
```
С постоянным инициализатором семя инициализируется однажды, когда оператор компилируется до выполнения. Если непостоянный инициализатор (такой как имя столбца) используется в качестве параметра, семя инициализируется со значением для каждого вызова RAND(). (Одна импликация этого то, что для равных значений аргументов, RAND() возвратит то же самое значение каждый раз.)

Получить случайное целое число R в диапазоне i <= R < j, используйте выражение FLOOR(i + RAND() * (j – i)). Например, чтобы получить случайное целое число в диапазоне диапазон 7 <= R < 12, Вы могли использовать следующий оператор:
```
SELECT FLOOR(7 + (RAND() * 5));
```
RAND() в a WHERE пункт переоценивается каждый раз WHERE выполняется.

Невозможно использовать столбец с RAND() значения в ORDER BY пункт, потому что ORDER BY оценил бы столбец многократно. Однако, можно получить строки в произвольном порядке как это:
```
mysql> SELECT * FROM tbl_name ORDER BY RAND();
```
ORDER BY RAND() объединенный с LIMIT полезно для выбора случайной выборки из ряда строк:
```
mysql> SELECT * FROM table1, table2 WHERE
                    a=b AND c<d -> ORDER BY RAND() LIMIT
                    1000;
```
RAND() не предназначается, чтобы быть совершенным случайным генератором. Это - быстрый способ генерировать случайные числа по требованию, который переносим между платформами для той же самой версии MySQL.

Эта функция опасна для основанной на операторе репликации. Предупреждение регистрируется, если Вы используете эту функцию когда binlog_format устанавливается в STATEMENT. (Ошибка #49222)
ROUND(X), ROUND(X,D)

Округляет параметр X к D десятичные разряды. Округляющийся алгоритм зависит от типа данных X. D значения по умолчанию к 0, если не определенный. D может быть отрицательным, чтобы вызвать D цифры уехали десятичной точки значения X стать нулем.
```
mysql> SELECT
                    ROUND(-1.23);        -> -1mysql> SELECT
                    ROUND(-1.58);        -> -2mysql> SELECT
                    ROUND(1.58);        -> 2mysql> SELECT
                    ROUND(1.298, 1);        -> 1.3mysql> SELECT
                    ROUND(1.298, 0);        -> 1mysql> SELECT
                    ROUND(23.298, -1);        -> 20
```
Тип возврата является тем же самым типом как тот из первого параметра (предполагающий, что это - целое число, дважды, или десятичное число). Это означает, что для целочисленного параметра, результатом является целое число (никакие десятичные разряды):
```
mysql> SELECT ROUND(150.000,2),
                    ROUND(150,2);+------------------+--------------+| ROUND(150.000,2) | ROUND(150,2) |+------------------+--------------+|           150.00 |          150 |+------------------+--------------+
```
ROUND() использует следующие правила в зависимости от типа первого параметра:
- Для чисел точного значения, ROUND() использует "круглую половину далеко от нуля" или "вокруг к самому близкому" правилу: значение с дробной частью.5 или больше окружается к следующему целому числу если положительный или вниз к следующему целому числу если отрицание. (Другими словами это округляется далеко от нуля.) Значение с дробной частью меньше чем.5 округляются в меньшую сторону до следующего целого числа если положительный или до следующего целого числа если отрицание.
- Для чисел приближенного значения результат зависит от библиотеки C. На многих системах это означает это ROUND() использует "вокруг для самого близкого даже" правила: значение с любой дробной частью округляется к самому близкому даже целое число.
Следующие шоу в качестве примера, как округление отличается для точных и приближенных значений:
```
mysql> SELECT ROUND(2.5),
                    ROUND(25E-1);+------------+--------------+| ROUND(2.5) | ROUND(25E-1) |+------------+--------------+| 3          |            2 |+------------+--------------+
```
Для получения дополнительной информации см. Раздел 12.19, "Математика Точности".
SIGN(X)

Возвращает знак параметра как -1, 0, или 1, В зависимости от ли X отрицательно, нуль, или положителен.
```
mysql> SELECT SIGN(-32);        -> -1mysql> SELECT SIGN(0);        -> 0mysql> SELECT SIGN(234);        -> 1
```

SIN(X)

Возвращает синус X, где X дается в радианах.

mysql> SELECT SIN(PI());        -> 1.2246063538224e-16mysql> SELECT ROUND(SIN(PI()));        -> 0

SQRT(X)

Возвращает квадратный корень неотрицательного числа X.

mysql> SELECT SQRT(4);        -> 2mysql> SELECT
                    SQRT(20);        -> 4.4721359549996mysql> SELECT
                    SQRT(-16);        -> NULL

TAN(X)

Возвращает касательную X, где X дается в радианах.

mysql> SELECT TAN(PI());        -> -1.2246063538224e-16mysql> SELECT TAN(PI()+1);        -> 1.5574077246549

TRUNCATE(X,D)

Возвращает число X, усеченный к D десятичные разряды. Если D 0, у результата нет никакой десятичной точки или дробной части. D может быть отрицательным, чтобы вызвать D цифры уехали десятичной точки значения X стать нулем.
```
mysql> SELECT
                    TRUNCATE(1.223,1);        -> 1.2mysql> SELECT
                    TRUNCATE(1.999,1);        -> 1.9mysql> SELECT
                    TRUNCATE(1.999,0);        -> 1mysql> SELECT
                    TRUNCATE(-1.999,1);        -> -1.9mysql> SELECT
                    TRUNCATE(122,-2);       -> 100mysql> SELECT
                    TRUNCATE(10.28*100,0);       -> 1028
```
Все числа округляются к нулю.