Округл (round) округление значений в excel
Содержание:
- Методы
- Round() в Go 1.10
- Способы округления чисел
- Функция round() – использование
- Округление через формат ячеек
- Привязка к диапазону
- Округление с помощью эпсилона
- Round(Decimal, Int32)
- Функции, связанные с делением
- Функция round в Python– примеры работы
- Округление чисел
- Как округлить до целого числа
- Тригонометрические функции в языке SQL
Методы
Математики разработали множество различных методов округления. Это включает в себя простое усечение, округление вверх, в меньшую сторону, до половины вверх, до половины в меньшую сторону, а также половины от нуля и до четного.
Например, округление от нуля до половины применяется Европейской комиссией по экономическим и финансовым вопросам при конвертации валют в евро. Некоторые страны, такие как Швеция, Нидерланды, Новая Зеландия и Южная Африка, следуют правилу под названием «округление денежных средств», «округление пенни».
происходит, когда минимальная расчетная единица меньше наименьшего физического достоинства валюты. Сумма, подлежащая выплате за транзакцию с наличными, округляется до ближайшего кратного значения минимальной доступной денежной единицы, тогда как транзакции, оплаченные другими способами, не округляются.
В Южной Африке с 2002 года округление наличных денег производится до ближайших 5 центов. Обычно такое округление не применяется к электронным безналичным платежам.
Напротив, округление от половины до четного является стратегией по умолчанию для Python, Numpy и Pandas и используется встроенной функцией round(), о которой уже упоминалось ранее. Он принадлежит к категории методов округления до ближайшего и также известен как конвергентное округление, округление статистики, по голландскому языку, по Гауссу, по нечетному и четному. Этот метод определен в IEEE 754 и работает таким образом, что «если дробная часть x равна 0,5, то y является ближайшим к x четным целым числом».
Предполагается, что «вероятности связи в наборе данных при округлении в меньшую или большую сторону равны», что обычно и имеет место на практике. Хотя эта стратегия не полностью совершенна, она дает заметные результаты.
В таблице ниже приведены практические примеры округления в Python для этого метода:
| original value | rounded to | |----------------|------------| | 23.3 | 23 | | 23.5 | 24 | | 24.0 | 24 | | 24.5 | 24 | | 24.8 | 25 | | 25.5 | 26 |
Round() в Go 1.10
Для тех, кто не знаком с устройством float (я в их числе), этот код выглядит совершенно непонятно. Попробуем разобраться, что же он делает:
Похоже, что мы берём битовое представление числа, сдвигаем его и применяем маску. Согласно :
Рассматривая приведённые выше константы, мы видим, что сдвиг составляет 64 — 11 — 1, что означает 64 бита на число, 11 из которых используются для показателя степени, один — для знака и 52 оставшихся бита — для мантиссы. Это означает, что используемый сдвиг удаляет биты мантиссы, а маска удаляет бит знака, оставляя нас только с показателем степени.
В полученном числе показатель степени записан не как он есть, а с прибавлением числа 1023 (это делается для того чтобы записывать отрицательные показатели для очень маленьких чисел), что означает, что мы должны вычесть 1023 из e, вычисленного выше, чтобы получить фактический показатель. Иными словами, если e < bias, то мы имеем отрицательный показатель степени, что означает, что абсолютное значение float должно быть < 1. Действительно, дальше мы видим:
Здесь бит маскируется знаковым битом, это используется только для сохранения правильного знака: теперь мы можем полностью игнорировать мантиссу. Мы можем это сделать, потому что в этом случае нас интересует только показатель степени. Так как используется основание степени 2, а e < bias, мы знаем, что наименьший показатель, который может быть, равен -1, а 2 ^ -1 = 0,5. Кроме того, мантисса имеет некоторое значение 1.X. Таким образом, в зависимости от показателя наше число находится либо в диапазоне (0,5, 1), либо в диапазоне (0, 0,5). Поэтому во втором случае для правильного округления нам нужно добавить к числу единицу. Фух. Подробнее это описано в википедии.
Теперь разберём второй случай:
Наверное, вы думаете, что условие в этой ветке должно быть e > bias, чтобы покрыть все случаи с положительным показателем степени. Но вместо этого тут используется только их часть. Использование сдвига здесь особенно интересно, потому что кажется, что оно несравнимо с bias. Первое — это число битов смещения, а второе — численное смещение. Но, поскольку числа с плавающей точкой представлены как (1.мантисса) * 2 ^ X, то если X больше числа битов в мантиссе, мы гарантированно получим значение без дробной части. То есть показатель степени сместил десятичную точку вправо настолько, что мантисса окончательно пропала. Таким образом, выражение в этой ветке игнорирует числа с плавающей точкой, которые уже округлены.
Первая строка тут простая: вычитаем bias из e и получаем реальное значение показателя степени. Вторая строка добавляет к значению 0,5. Это работает, потому что старший бит мантиссы добавляет 0,5 к финальной сумме (см. представление в статье “Википедии” ниже). В этом случае эта сумма переполняет 52-битные границы мантиссы, показатель степени будет увеличен на 1. Значение показателя степени не сможет переполниться до знакового бита, так как оно не может быть больше bias+shift из примера выше. В любом случае, дробная часть очищается. Таким образом, если дробная часть была больше или равна 0,5, она будет увеличена на 1, в противном случае будет отброшена. Хитро и не очевидно до тех пор, пока мы не посмотрим глубже.
Способы округления чисел
Для округления чисел придумано много способов, они не лишены недостатков, однако часто используются для решения задач. Разберёмся в тонкостях каждого из них.
Если используется стандартная библиотека math, то в начале кода её необходимо подключить. Сделать это можно, например, с помощью инструкции: .
math.ceil() — округление чисел в большую сторону
Функция получила своё имя от термина «ceiling», который используется в математике для описания числа, которое больше или равно заданному.
Любая дробь находится в целочисленном интервале, например, 1.2 лежит между 1 и 2. Функция определяет, какая из границ интервала наибольшая и записывает её в результат округления.
Пример:
math.ceil(5.15) # = 6 math.ceil(6.666) # = 7 math.ceil(5) # = 5
Важно помнить, что функция определяет наибольшее число с учётом знака. То есть результатом округления числа -0.9 будет 0, а не -1.
math.floor() — округление чисел в меньшую сторону
Функция округляет дробное число до ближайшего целого, которое меньше или равно исходному. Работает аналогично функции , но с округлением в противоположную сторону.
Пример:
math.floor(7.9) # = 7 math.floor(9.999) # = 9 math.floor(-6.1) # = -7
math.trunc() — отбрасывание дробной части
Возвращает целое число, не учитывая его дробную часть. То есть никакого округления не происходит, Python просто забывает о дробной части, приводя число к целочисленному виду.
Примеры:
math.trunc(5.51) # = 5 math.trunc(-6.99) # = -6
Избавиться от дробной части можно с помощью обычного преобразования числа к типу int. Такой способ полностью эквивалентен использованию .
Примеры:
int(5.51) # = 5 int(-6.99) # = -6
Нормальное округление
Python позволяет реализовать нормальное арифметическое округление, использовав функцию преобразования к типу int.
И хотя работает по другому алгоритму, результат её использования для положительных чисел полностью аналогичен выводу функции floor(), которая округляет числа «вниз». Для отрицательных аналогичен функции ceil().
Примеры:
math.floor(9.999) # = 9 int(9.999) # = 9 math.ceil(-9.999) # = -9 int(-9.999) # = -9
Чтобы с помощью функции int() округлить число по математическим правилам, необходимо добавить к нему 0.5, если оно положительное, и -0.5, если оно отрицательное.
Тогда операция принимает такой вид: int(num + (0.5 if num > 0 else -0.5)). Чтобы каждый раз не писать условие, удобно сделать отдельную функцию:
def int_r(num):
num = int(num + (0.5 if num > 0 else -0.5))
return num
Функция работает также, как стандартная функция округление во второй версии Python (арифметическое округление).
Примеры:
int_r(11.5) # = 12 int_r(11.4) # = 11 int_r(-0.991) # = -1 int_r(1.391) # = 1
round() — округление чисел
round() — стандартная функция округления в языке Python. Она не всегда работает так, как ожидается, а её алгоритм различается в разных версиях Python.
В Python 2
Во второй версии Python используется арифметическое округление. Оно обладает постоянно растущей погрешностью, что приводит к появлению неточностей и ошибок.
Увеличение погрешности вызвано неравным количеством цифр, определяющих, в какую сторону округлять. Всего 4 цифры на конце приводят к округлению «вниз», и 5 цифр к округлению «вверх».
Помимо этого, могут быть неточности, например, если округлить число 2.675 до второго знака, получится число 2.67 вместо 2.68. Это происходит из-за невозможности точно представить десятичные числа типа «float» в двоичном коде.
В Python 3
В третьей версии Python используется банковское округление. Это значит, что округление происходит до самого близкого чётного.
Такой подход не избавляет от ошибок полностью, но уменьшает шанс их возникновения и позволяет программисту добиться большей точности при вычислениях.
Примеры:
round(3.5) # = 4 round(9.5) # = 10 round(6.5) # = 6 round(-6.5) # = -6 round(-7.5) # = -8
Но если вам по каким то причинам нужно округление как в Python 2, то можно воспользоваться функцией написанной нами выше на основе приведения к целому числу.
Округление до сотых
У функции есть ещё один аргумент. Он показывает до какого количества знаков после запятой следует округлять. Таким образом, если нам надо в Python округлить до сотых, этому параметру следует задать значение 2.
Пример округления до нужного знака:
round(3.555, 2) # = 3.56 round(9.515,1) # = 9.5 round(6.657,2) # = 6.66
Функция round() – использование
Функция round() нашла применение в различных областях деятельности человека. Фактически везде, где может понадобиться округление чисел, требует использования этой функции.
Вообще, задача функции – сделать число более читаемым. Поэтому она используется сейчас в тех ситуациях, когда надо показывать «красивые» числа. Для реальных вычислений функцию лучше не использовать, так, как искажения в вычислениях при их большом количестве могут быть колоссальными.
Многие слышали об эффекте бабочки. Если выражать его в метафорической форме, то он звучит следующим образом: если на одном конце света бабочка взмахивает крыльями, в другой стороне планеты из-за этого возникнет ураган. Почему так? Потому что подавляющее количество систем, существующих в мире, нелинейные. И это же правило касается современных компьютерных приложений.
К слову, этот эффект был открыт Эдвардом Лоренцом. Он и не был математиком вовсе, но по роду его деятельности ему повезло сделать такое открытие. Он помог полностью перевернуть понимание того, как устроена эта наука. Когда-то он пытался создать прогноз погоды. Та задача, которая перед ним стояла, не была трудной. Необходимо было предоставить вводные данные, а дальше математическая модель на компьютере уже должна была сама прогнозировать погоду. Но в самой модели результаты одних вычислений использовались и дальше. И в этом была основная проблема.
В один момент ему захотелось повторить изначальные расчеты в этой цепочке. И оказалось, что они не сошлись. Он упорно пытался найти решение проблемы. Причина была в том, что Лоренц округлял значения до трех знаков после запятой. Вообще, разница между округленным значением и реальным, была очень маленькая. Тем не менее, прогнозы стали принципиально отличаться друг от друга.
В целом, у первых вычислений в цепочке соответствие значений друг к другу было. Тем не менее, чем дальше они продвигались по ней, тем больше оказывалась разница. В результате, один прогноз говорил, что будет тихая солнечная погода, а второй предсказывал сильнейшие дожди.
В то время компьютеры еще плохо справлялись с настолько точными расчетами. В результате, и был установлен эффект бабочки, который говорит, что в нелинейных системах малые изменения на входе или на каком-то звене цепи могут приводить к колоссальным отличиям результатов на выходе.
К слову, человек часто недооценивает малые числа, но практика показывает, что они в совокупности могут привести к катастрофическим последствиям. Так, в 2008 году произошло то, что казалось невозможным: целая совокупность маловероятных событий сошлись в одной точке во времени. Да и пандемия, которая сейчас, началась с одного случая заражения. Так что нужно следить за точностью вычислений.
Впрочем, все равно нужно знать, как работать с округлением чисел в Python. Ведь выводить информацию пользователю все равно нужно в удобном для чтении виде. Поэтому приступаем к рассмотрению синтаксиса и примеров использования функции round().
Округление через формат ячеек
Также можно выставить округление с помощью настроек формата ячеек. Для этого, нужно выделить диапазон ячеек на листе, кликнуть правой кнопкой мыши, и в появившемся меню выбрать пункт «Формат ячеек».
В открывшемся окне настроек формата ячеек нужно перейти во вкладку «Число». Если формат данных указан не числовой, то нужно выбрать именно числовой формат, иначе вы не сможете регулировать округление. В центральной части окна около надписи «Число десятичных знаков» просто указываем цифрой то число знаков, которое желаем видеть при округлении. После этого, выполняем клик по кнопке «OK».
Привязка к диапазону
Иногда нужно получить значение х, которое должно находиться в пределах определенного диапазона. Например, нужно значение от 1 до 100, но мы получаем значение 123. Чтобы исправить это, можно использовать min() (возвращает наименьшее из чисел) и max (возвращает максимально допустимое число).
Использование:
var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
Можно создать функцию или расширение класса Number:
Number.prototype.clamp = function(min, max) {
return Math.min(Math.max(this, min), max);
};
Использование:
(numInput).clamp(lowBound, highBound);
Округление с помощью эпсилона
Альтернативный метод JavaScript, позволяющий осуществить округление до десятых, был введен в ES6 (также известном, как JavaScript 2015). «Машинный эпсилон» обеспечивает разумный предел погрешности при сравнении двух чисел с плавающей запятой. Без округления, сравнения могут дать результаты, подобные следующим:
0.1 + 0.2 === 0.3 > false
Math.EPSILON может быть использован в функции для получения корректного сравнения:
function epsEqu(x, y) {
return Math.abs(x - y) < Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
Функция принимает два аргумента: один содержит вычисления, второй ожидаемый (округленный) результат. Она возвращает сравнение этих двух параметров:
epsEqu(0.1 + 0.2, 0.3) > true
Все современные браузеры поддерживают математические функции ES6. Но если необходимо обеспечить поддержку в старых браузерах, то нужно использовать полифиллы.
Round(Decimal, Int32)
Math.Round(d, decimals) rounds a decimal value to a specified number of fractional digits , and rounds midpoint values to the nearest even number.
Syntax
The syntax of Round(d, decimals) method is
Math.Round(Decimal d, Int32 decimals)
where
| Parameter | Description |
|---|---|
| d | The decimal number to be rounded. |
| decimals | The number of decimal places in the return value. |
Return Value
The method returns value.
Example 2 – Round(d, decimals)
In this example, we will take some decimal values and round them to specific number of decimal points using Math.Round() method.
C# Program
using System;
class Example {
static void Main(string[] args) {
Decimal d, result;
Int32 decimals;
d = 10.2563M;
decimals = 2;
result = Math.Round(d, decimals);
Console.WriteLine($"Round({d}, {decimals}) = {result}");
d = 10.63524M;
decimals = 1;
result = Math.Round(d, decimals);
Console.WriteLine($"Round({d}, {decimals}) = {result}");
d = 10.5M;
decimals = 0;
result = Math.Round(d, decimals);
Console.WriteLine($"Round({d}, {decimals}) = {result}");
}
}
Output
Round(10.2563, 2) = 10.26 Round(10.63524, 1) = 10.6 Round(10.5, 0) = 10
Функции, связанные с делением
Функция ЧАСТНОЕ
Выполняет самое простое деление.
Синтаксис: =ЧАСТНОЕ(делимое; делитель), где все аргументы являются обязательными и должны представляться числами.
Пример использования:
=ЧАСТНОЕ(8;4) – возвращаемое значение 2.
Можно воспользоваться альтернативой функции: =8/2.
Функция ОСТАТ
Возвращает остаток от деления двух чисел.
Синтаксис: =ОСТАТ(делимое; делитель), где все аргументы являются обязательными и должны иметь числовое значение.
Знак остатка всегда совпадает со знаком делителя.
Пример использования:
Сама функция из-за алгоритма своего вычисления выдает результат обработки чисел с разными знаками, который возможно Вы от нее ожидать не будете. Подробнее:
=ОСТАТ(8;3) – результат выполнения функции 2.=ОСТАТ(-8;3) – результат выполнения функции 1. Хотя скорее всего Вы будете ожидать результат 2. Так происходит из-за алгоритма функции: =делимое – делитель*ЦЕЛОЕ(делимое/делитель). В связи с тем, что ЦЕЛОЕ округляет дробные значения до меньшего целого, то результат деления (-8/3) равняется -2,6666 и, соответственно, будет округлен до -3, а не до 2, как в случае с положительными числами. Чтобы избавиться от такого эффекта необходимо не округлять число, а просто отбрасывать дробную часть: =делимое – делитель*ОТБР(делимое/делитель).=-8-3*ОТБР(-8/3) – результат -2.=ОСТАТ(-8;-3) – функция вернет результат -2.
Функция НОД
Вычисляет наибольший общий делитель для всех аргументов, на который они делятся без остатка. Наибольший делитель всегда целое число.
Синтаксис:
=НОД(число1; ; …). Максимальное число аргументов 255, минимальное 1. Аргументы являются числами, ссылками на ячейки или диапазонами ячеек, которые содержат числа. Значения аргументов должны быть всегда положительными числами.
Пример использования:
=НОД(8;4) – результат выполнения 4.=НОД(6;4) – результат выполнения 2.
Функция НОК
Вычисляет наименьшее общее кратное для всех аргументов.
Синтаксис и описание аргументов аналогичны функции НОД.
Пример использования:
=НОК(8;4) – результат выполнения 8.=НОК(6;4) – результат выполнения 12.
Функция round в Python– примеры работы
Пример 1 – использование одного параметра в функции
# Целые числа a = 12 round (a) print (a) # Десятичные числа b = 21.7 c = 21.4 print(round(b)) print(round(c))
В выводе окажутся следующие значения:
12
22
21
Как работает этот код? Сначала мы объявили переменную a, которой присвоили значение 12. После этого, мы применили к ней функцию round(), использовав в качестве ее аргумента нашу переменную. А потом мы дали инструкцию напечатать значение этой переменной.
Следующий блок – это демонстрация работы функции с десятичными числами. Сначала мы создали две переменные b и c, после чего дали команду напечатать их округленное значение. Соответственно, получились значения 12, 22 и 21, согласно всем описанным выше законам.
Пример 2 – оба параметра
А теперь давайте рассмотрим такой вариант кода и разберем его составляющие.
# когда последняя цифра 5 a = 5.465 print(round(a, 2)) # когда последняя цифра >=5 b = 5.476 print(round(b, 2)) # когда последняя цифра меньше 5 c = 5.473 print(round(c, 2))
В каждом из вариантов использования функции round() мы использовали два параметра – название переменной, значение которой нужно округлить и разряд. Во всех случаях мы округляли до сотых. Следовательно, использовали цифру 2.
А дальше функция работает по всем описанным выше законам.
В первом примере мы показали, как работает функция, когда последняя цифра – 5. Во втором – если она больше пяти, а в третьем – если меньше 5. Видим, что в первом случае округление произошло в меньшую сторону, во втором – в большую, а в третьем – в меньшую.
5.46
5.48
5.47
Округление чисел
Для нахождения приближенного значения применяется такое действие как округление чисел.
Слово «округление» говорит само за себя. Округлить число значит сделать его круглым. Круглым называется число, которое оканчивается нулём. Например, следующие числа являются круглыми:
10, 20, 30, 100, 300, 700, 1000
Любое число можно сделать круглым. Процедуру, при которой число делают круглым, называют округлением числá.
Мы уже занимались «округлением» чисел, когда делили большие числа. Напомним, что для этого мы оставляли без изменения цифру, образующую старший разряд, а остальные цифры заменяли нулями. Но это были лишь наброски, которые мы делали для облегчения деления. Своего рода лайфхак. По факту, это даже не являлось округлением чисел. Именно поэтому в начале данного абзаца мы взяли слово округление в кавычки.
На самом деле, суть округления заключается в том, чтобы найти ближайшее значение от исходного. При этом, число может быть округлено до определённого разряда — до разряда десятков, разряда сотен, разряда тысяч.
Рассмотрим простой пример на округление. Дано число 17. Требуется округлить его до разряда десятков.
Не забегая вперёд попробуем понять, что означает «округлить до разряда десятков». Когда говорят округлить число 17, то надо понимать, что от нас требуют найти ближайшее круглое число от числá 17. Причём в ходе этого поиска возможно изменения коснутся и той цифры, которая располагается в разряде десятков числá 17 (т.е цифры 1).
Предстáвим числа от 10 до 20 с помощью следующего рисунка:
На рисунке видно, что для числá 17 ближайшее круглое число это число 20. Значит ответ к задаче таким и будет: «17 приближённо равно 20″
17 ≈ 20
Мы нашли приближённое значение для 17, то есть округлили его до разряда десятков. Видно, что после округления в разряде десятков появилась новая цифра 2.
Попробуем найти приближённое число для числа 12. Для этого снова предстáвим числа от 10 до 20 с помощью рисунка:
На рисунке видно, что ближайшее круглое число для 12 это число 10. Значит ответ к задаче таким и будет: 12 приближённо равно 10
12 ≈ 10
Мы нашли приближённое значение для 12, то есть округлили его до разряда десятков. В этот раз цифра 1, которая стояла в разряде десятков в числе 12, не пострадала от округления. Почему так получилось мы расскажем позже.
Попробуем найти ближайшее число для числá 15. Снова предстáвим числа от 10 до 20 с помощью рисунка:
На рисунке видно, что число 15 одинаково удалено от круглых чисел 10 и 20. Возникает вопрос: которое из этих круглых чисел будет приближённым значением для числа 15? Для таких случаев условились принимать бóльшее число за приближённое. 20 больше чем 10, поэтому приближённое значение для 15 будет число 20
15 ≈ 20
Округлять можно и большие числа. Естественно, для них делать рисунки и изображать числа не представляется возможным. Для них существует свой способ. Например, округлим число 1456 до разряда десятков.
Итак, мы должны округлить 1456 до разряда десятков. Разряд десятков начинается на пятёрке:
Теперь о существовании первых цифр 1 и 4 временно забываем. Остается число 56
Теперь смотрим, какое круглое число находится ближе к числу 56. Очевидно, что ближайшее круглое число для 56 это число 60. Значит заменяем число 56 на число 60
Значит при округлении числа 1456 до разряда десятков полýчим 1460
1456 ≈ 1460
Видно, что после округления числа 1456 до разряда десятков, изменения коснулись и самогó разряда десятков. В новом полученном числе в разряде десятков теперь располагается цифра 6, а не 5.
Округлять числа можно не только до разряда десятков. Округлять число можно до разряда сотен, тысяч, десятков тысяч и так далее.
После того, как станóвится ясно, что округление это ни что иное как поиск ближáйшего числá, можно применять готовые правила, которые значительно облегчают округление чисел.
Как округлить до целого числа
Как показано в предыдущем примере, достаточно просто убрать цифры в дробной части из формулы, как число сразу становится целым. Вот, как осуществляется округление! Но с помощью формулы можно получить настоящее целое число, а описанный выше способ – визуальный. Но логика не меняется в зависимости от того, реальный или визуальный результат будет отображаться. Все равно нужно выставлять ноль знаков.
Также возможно применение функций ОКРУГЛВВЕРХ и ОКРУГЛВНИЗ, чтобы оставлять только круглое число. Соответственно, первая округляет в сторону вверх, а вторая – в противоположном направлении по отношению к первой. В случае с отрицательными значениями – все наоборот, потому что округление осуществляется по модулю
Тригонометрические функции в языке SQL
Кратенько пройдемся по тригонометрическим функциям:
- COS (x) — косинус угла x;
- SIN (x) — синус угла x;
- TAN (x) — тангенс угла x;
- COT (x) — котангенс угла x.
Везде x задается в радианах. Примеры:
SELECT COS (PI ())
Результат: -1
SELECT SIN (PI ()/2)
Результат: 1
SELECT TAN (PI ()/4)
Результат: 1
SELECT COT (PI ()/3)
Результат: 0.577350269189626
Функции ACOS (x) и ASIN (x) вычисляют соответственно арккосинус и арксинус числа x, т.е. функции возвращают величину, косинус или синус которой равен x. При этом если значение x не находится в диапазоне от -1 до 1, то функции возвращают NULL. Например:
SELECT ASIN (-1)
Результат: -1.5707963267949
SELECT ACOS (-1)
Результат: 3.14159265358979
SELECT ACOS (1.1)
Результат: NULL
Функция ATAN (x) вычисляет арктангенс числа x, т.е. возвращает величину, тангенс которой равен x. Пример:
SELECT ATAN (3);
Результат: 1.24904577239825
Для преобразования радиан в градусы и обратно используются функции DEGREES (x) и RADIANS (x) соответственно:
SELECT DEGREES (PI ())
Результат: 180
SELECT RADIANS (180)
Результат: 3.14
