Логарифм в java
Класс Math
Класс Math содержит методы для выполнения основных числовых операций, таких как нахождение экспоненты, логарифма, квадратного корня и т. д.
Класс содержит две константы типа double: E и PI. Все методы в классе Math статичны.
Тип | Метод | Описание |
---|---|---|
double | abs(double a) | Возвращает абсолютное значение (модуль) числа типа double. |
float | abs(float a) | Возвращает абсолютное значение (модуль) числа типа float . |
int | abs(int a) | Возвращает абсолютное значение (модуль) числа типа int. |
long | abs(long a) | Возвращает абсолютное значение (модуль) числа типа long. |
double | acos(double a) | Возвращает арккосинус значения. Возвращенный угол находится в диапазоне от 0 до pi. |
double | asin(double a) | Возвращает арксинус значения. Возвращенный угол в диапазоне от -pi/2 до pi/2. |
double | atan(double a) | Возвращает арктангенс значения. Возвращенный угол в диапазоне от-pi/2 до pi/2. |
double | cbrt(double a) | Возвращает кубический корень аргумента. |
double | ceil(double a) | Возвращает наименьшее целое число, которое больше аргумента. |
double | copySign(double magnitude, double sign) | Возвращает аргумент с тем же знаком, что у второго аргумента. |
double | copySign(float magnitude, float sign) | Возвращает аргумент с тем же знаком, что у второго аргумента. |
double | cos(double a) | Возвращает косинус аргумента. |
double | cosh(double x) | Возвращает гиперболический косинус аргумента. |
int | decrementExact(int a) | Возвращает значение аргумента уменьшенное на единицу. |
long | decrementExact(long a) | Возвращает значение аргумента уменьшенное на единицу. |
double | exp(double a) | Возвращает экспоненту аргумента. |
double | floor(double a) | Возвращает наибольшее целое число, которое меньше или равно аргументу. |
double | hypot(double x, double y) | Возвращает длину гипотенузы (sqrt(x 2 +y 2 )). |
double | IEEEremainder(double f1, double f2) | Возвращает остаток от деления f1 на f2. |
int | incrementExact(int a) | Возвращает значение аргумента увеличенное на единицу. |
long | incrementExact(long a) | Возвращает значение аргумента увеличенное на единицу. |
double | log(double a) | Возвращает натуральный логарифм (по основанию e). |
double | log10(double a) | Возвращает логарифм по основанию 10. |
double | max(double a, double b) | Возвращает больший из аргументов. |
float | max(float a, float b) | Возвращает больший из аргументов. |
int | max(int a, int b) | Возвращает больший из аргументов. |
long | max(long a, long b) | Возвращает больший из аргументов. |
double | min(double a, double b) | Возвращает меньший из аргументов. |
float | min(float a, float b) | Возвращает меньший из аргументов. |
int | min(int a, int b) | Возвращает меньший из аргументов. |
long | min(long a, long b) | Возвращает меньший из аргументов. |
int | multiplyExact(int x, int y) | Возвращает произведение аргументов (x*y). |
long | multiplyExact(long x, long y) | Возвращает произведение аргументов (x*y). |
int | negateExact(int a) | Возвращает отрицательное значение аргумента. |
long | negateExact(long a) | Возвращает отрицательное значение аргумента. |
double | pow(double a, double b) | Возвращает значение первого аргумента, возведенное в степень второго аргумента. |
double | random() | Возвращает случайное число от 0.0 (включительно) до 1 (не включительно). |
double | rint(double a) | Возвращает округленное значение аргумента. |
int | round(double a) | Возвращает округленное значение аргумента. |
double | signum(double a) | Возвращает знак аргумента. |
floa | signum(float a) | Возвращает знак аргумента. |
double | sin(double a) | Возвращает синус аргумента. |
double | sinh(double a) | Возвращает гиперболический синус аргумента. |
doubl | sqrt(double a) | Возвращает квадратный корень аргумента. |
int | subtractExact(int x, int y) | Возвращает разность аргументов (x-y). |
long | subtractExact(long x, long y) | Возвращает разность аргументов (x-y). |
double | tan(double a) | Возвращает тангенс аргумента. |
double | tanh(double a) | Возвращает гиперболический тангенс аргумента. |
doubl | toDegrees() | Преобразует радианы в градусы. |
int | toIntExact(long value) | Преобразует аргумент типа long в int. |
doubl | toRadians() | Преобразует градусы в радианы. |
abs(double a) — возвращает абсолютное значение (модуль) числа типа double.
abs(float a) — возвращает абсолютное значение (модуль) числа типа float .
abs(int a) — возвращает абсолютное значение (модуль) числа типа int.
abs(long a) — возвращает абсолютное значение (модуль) числа типа long.
acos(double a) — возвращает арккосинус значения. Возвращенный угол находится в диапазоне от 0 до pi.
asin(double a) — возвращает арксинус значения. Возвращенный угол в диапазоне от -pi/2 до pi/2.
atan(double a) — возвращает арктангенс значения. Возвращенный угол в диапазоне от-pi/2 до pi/2.
cbrt(double a) — возвращает кубический корень аргумента.
ceil(double a) — возвращает наименьшее целое число, которое больше аргумента.
copySign(double magnitude, double sign) — возвращает аргумент с тем же знаком, что у второго аргумента.
copySign(float magnitude, float sign) — возвращает аргумент с тем же знаком, что у второго аргумента.
cos(double a) — возвращает косинус аргумента.
cosh(double x) — возвращает гиперболический косинус аргумента.
decrementExact(int a) — возвращает значение аргумента уменьшенное на единицу.
decrementExact(long a) — возвращает значение аргумента уменьшенное на единицу.
exp(double a) — возвращает экспоненту аргумента.
floor(double a) — возвращает наибольшее целое число, которое меньше или равно аргументу.
hypot(double x, double y) — возвращает длину гипотенузы (sqrt(x 2 +y 2 )).
IEEEremainder(double f1, double f2) — возвращает остаток от деления f1 на f2.
incrementExact(int a) — возвращает значение аргумента увеличенное на единицу.
incrementExact(long a) — возвращает значение аргумента увеличенное на единицу.
log(double a) — возвращает натуральный логарифм (по основанию e).
log10(double a) — возвращает логарифм по основанию 10.
max(double a, double b) — возвращает больший из аргументов.
max(float a, float b) — возвращает больший из аргументов.
max(int a, int b) — возвращает больший из аргументов.
max(long a, long b) — возвращает больший из аргументов.
min(double a, double b) — возвращает меньший из аргументов.
min(float a, float b) — возвращает меньший из аргументов.
min(int a, int b) — возвращает меньший из аргументов.
min(long a, long b) — возвращает меньший из аргументов.
multiplyExact(int x, int y) — возвращает произведение аргументов (x*y).
multiplyExact(long x, long y) — возвращает произведение аргументов (x*y).
negateExact(int a) — возвращает отрицательное значение аргумента.
negateExact(long a) — возвращает отрицательное значение аргумента.
pow(double a, double b) — возвращает значение первого аргумента, возведенное в степень второго аргумента (a b )
random() — возвращает случайное число от 0.0 (включительно) до 1 (не включительно).
rint(double a) — возвращает округленное значение аргумента.
round(double a) — возвращает округленное значение аргумента.
signum(double a) — возвращает знак аргумента.
signum(float a) — возвращает знак аргумента.
sin(double a) — возвращает синус аргумента.
sinh(double a) — возвращает гиперболический синус аргумента.
sqrt(double a) — возвращает квадратный корень аргумента.
subtractExact(int x, int y) — возвращает разность аргументов (x-y).
subtractExact(long x, long y) — возвращает разность аргументов (x-y).
tan(double a) — возвращает тангенс аргумента.
tanh(double a) — возвращает гиперболический тангенс аргумента.
toDegrees() — преобразует радианы в градусы.
toIntExact(long value) — преобразует аргумент типа long в int.
toRadians() — преобразует градусы в радианы.
Класс Math и пакет java.math
Класс Math содержит методы, связанные с геометрией и тригонометрией и прочей математики. Методы реализованы как static, поэтому можно сразу вызывать через Math.methodName() без создания экземпляра класса.
В классе определены две константы типа double: E и PI.
Популярные методы для тригонометрических функций принимают параметр типа double, выражающий угол в радианах.
- sin(double d)
- cos(double d)
- tan(double d)
- asin(double d)
- acos(double d)
- atan(double d)
- atan2(double y, double x)
Существуют также гиперболические функции: sinh(), cosh(), tanh().
Из них хорошо знакомы возведение в степень — pow(2.0, 3.0) вернёт 8.0.
Также популярен метод для извлечения квадратного корня — sqrt(4.0). Если аргумент меньше нуля, то возвращается NaN. Похожий метод cbrt() извлекает кубический корень. Если аргумент отрицательный, то и возвращаемое значение будет отрицательным: -27.0-> -3.0.
- abs() — возвращает абсолютное значение аргумента
- ceil() — возвращает наименьшее целое число, которое больше аргумента
- floor() — возвращает наибольшее целое число, которое меньше или равно аргументу
- max() — возвращает большее из двух чисел
- min() — возвращает меньшее из двух чисел
- nextAfter() — возвращает следующее значение после аргумента в заданном направлении
- nextUp() — возвращает следующее значение в положительном направлении
- rint() — возвращает ближайшее целое к аргументу
- round() — возвращает аргумент, округлённый вверх до ближайшего числа
- ulp() — возвращает дистанцию между значением и ближайшим большим значением
- copySign() — возвращает аргумент с тем же знаком, что у второго аргумента
- getExponent() — возвращает экспоненту
- IEEEremainder() — возвращает остаток от деления
- hypot() — возвращает длину гипотенузы
- random() — возвращает случайное число между 0 и 1 (единица в диапазон не входит)
- signum() — возвращает знак значения
- toDegrees() — преобразует радианы в градусы
- toRadians() — преобразует градусы в радианы
Вычислим наибольшее и наименьшее числа из двух заданных значений.
Большие числа
Если вам не хватает точности основных типов для представления целых и вещественных чисел, то можно использовать классы BigInteger и BigDecimal из пакета java.math, которые предназначены для выполнения действий с числами, состоящими из произвольного количества цифр.
Для преобразования обычного числа в число с произвольной точностью (называемое большим числом) вызывается статический метод valueOf():
При работе с большими числами нельзя использовать привычные математические операции с помощью + или * и т.п. Вместо них следует использовать специальные методы add() (сложение), multiply() (умножение), divide() (деление) и т.д.
В обычной практике эти числа используются редко.
Логарифм в java
В уроке 8 мы затронули логические операторы, они нам были необходимы для формирования логического выражения в условиях if. Этот урок будет посвящен математике в Java, и поэтому мы рассмотрим подробнее арифметические операторы и частично возможности класса Math.
Но для начала, выясним, что же такое операторы. Операторы это специальные символы, отвечающие за ту или иную операцию, например сложение, умножение, сравнение. Все операторы в Java можно разбить на 4 класса — арифметические, битовые, операторы сравнения и логические.
Арифметические операторы в Java
Для стандартных арифметических операций, таких как сложение, вычитание, умножение, деление в Java используются традиционные символы, к которым мы привыкли со школы:
Примечание: при операции деления, если оба аргумента являются целыми числами, то в результате получим целое число. Дробная часть, если такая имеется, отбросится. Если хотим получить число с дробной частью, то нужно, чтобы один из аргументов был типа double. Это можно указать в самом выражении при помощи добавления после числа .0 или .d. Пример:
В Java также имеется специальный оператор %, обозначающий остаток от делния.
Пример использования: дан массив целых чисел, вывести на консоль только те числа, которые делятся на 3.
Операции с присваиванием
Рассмотрим задачу вывода на экран 10 первых четных чисел чисел
мы можем записать сокращенно
+= это оператор сложения с присваиванием. Подобные операторы есть для всех основных 5 операций, рассмотренных выше
Пример использования: Найти факториал числа 7.
Инкрементирование и декрементирование
Инкремент, обозначается ++ и увеличивает значение переменной на единицу. Декремент обозначается — и уменьшает значение на единицу. С инкрементом и декрементом мы часто встречаемся в цикле for.
Инкремент и декремент бывают двух форм
Различие префиксной и постфиксной формы проявляется только тогда, когда эти операции присутствуют в выражениях. Если форма префиксная, то сначала произойдет увеличение (или уменьшение) переменной на единицу, а потом с новым значением будет произведены дальнейшие вычисления. Если форма постфиксная, то расчет выражения будет происходить со старым значением переменной, а переменная увеличится (или уменьшится) на единицу после вычисления выражения. Пример
В первом случае сначала переменная a увеличится на 1, потом произойдет вычисление всего выражения. Во втором случае произойдет вычисление выражения при старом значении b = 3, и после вычисления b увеличится на 1, на результат в postfix это уже не повлияет.
Если вы поняли принцип работы постфиксного и префиксного инкремента/декремента, то предлагаю решить в уме такую задачу:
Вопрос: чему в итоге равны x и y? После того, как вы сделали предположение, проверьте его в java.
Задача со зведочкой. Дан код:
Какие числа будут выведены на экран? Почему? Разобраться самостоятельно.
Примечание: инкремент и декремент применяются только к переменной. Выражение вида 7++ считается недопустимым.
Математические функции и константы (класс Math)
Для решения задач нередко требуется использование математических функций. В Java такие функции включены в класс Math. Для того, чтобы использовать методы класса Math, нужно подключить его в начале .java файла с вашим кодом.
Developer notes
About Java, Oracle and related.
08 ноября 2008
Новые функции в Java Math
Если в проекте много «математики» , то код получается не красивый и сложно понимаемый, приходиться писать множество комментариев , что бы было понятно что к чему.
Но SUN идёт на встречу разработчикам, и в каждой новой версии добавляет всё новые функции в основной математический класс — java.lang.Math
Новое в Java 1.5 :
log10(double a) — логарифм с основанием 10
cbrt(double a) — корень кубический
ulp(double d) — на сколько я понял это модуль разницы между параметром d преобразованным в float и ближайшим по возрастанию double значением. поправьте если я не прав!
signum(double d) — возвращает знак числа: 0, если d=0; -1.0 если d 0;
sinh(double x) —
cosh(double x) — — гиперболические синус, косинус и тангес
tanh(double x)- /
hypot(double x, double y) — гипотенуза
expm1(double x) — = exp(x) — 1
log1p(double x) — = ln(x+1)
Новое в 1.6
copySign(double magnitude, double sign)
getExponent(double d)
nextAfter(double start, double direction)
nextUp(double d)
scalb(double d, int scaleFactor)
Всё красиво, всё удобно — чего только стоит функция гипотенузы. Но всё имеет свои минусы, тут они также есть.
Если сравнить производительность, например той же функции hypot (x,y)
c более привычным способом получения значения гипотенузы Math.sqrt(x*x + y*y) , то получим достаточно интересные результаты, а именно — разница в скорости выполнении различается почти в 100 раз. причём как это не удивительно , но не в пользу нововведённой функции.
Итак , мой тестовый класс:
public class RealType <
public static void main(String[] s) throws Exception <
long start1;
int counter = 0;
double temp = 0;
for (int k=0; k
start1 = System.currentTimeMillis();
for (int i=0; i
for (int j=0; j
temp = Math.sqrt(i*i + j*j);
counter++;
>
>
System.out.println(«Spent time to run sqrt » + counter + » times : » + (System.currentTimeMillis() — start1));
counter = 0;
start1 = System.currentTimeMillis();
for (int i=0; i
for (int j=0; j
temp = Math.hypot(i, j);
counter++;
>
>
System.out.println(«Spent time to run hypot » + counter + » times : » + (System.currentTimeMillis() — start1));
>
>
>
После выполнения я получил приблизительно следующие результаты:
Spent time to run sqrt 5000000 times : 63
Spent time to run hypot 5000000 times : 4109
Spent time to run sqrt 5000000 times : 47
Spent time to run hypot 5000000 times : 4172
Spent time to run sqrt 5000000 times : 47
Spent time to run hypot 5000000 times : 4140
Spent time to run sqrt 5000000 times : 47
Spent time to run hypot 5000000 times : 4157
Spent time to run sqrt 5000000 times : 46
Spent time to run hypot 5000000 times : 4172
Тоесть, скорость выполнения одного вызова функции на моём компьютере занимает 800 наносекунд для hypot и 9 наносекунд для sqrt.
Для того что бы понять откуда такая разница, пришлось порытся в исходниках и посмотреть что собой представляет нативная hypot . Поиски привели меня к hypot_e.c и выглядит он следующим образом:
#ifdef __STDC__
double __ieee754_hypot(double x, double y)
#else
double __ieee754_hypot(x,y)
double x, y;
#endif
<
double a=x,b=y,t1,t2,y1,y2,w;
int j,k,ha,hb;
ha = __HI(x)&0x7fffffff; /* high word of x */
hb = __HI(y)&0x7fffffff; /* high word of y */
if(hb > ha) else
__HI(a) = ha; /* a
__HI(b) = hb; /* b
if((ha-hb)>0x3c00000)
k=0;
if(ha > 0x5f300000) < /* a>2**500 */
if(ha >= 0x7ff00000) < /* Inf or NaN */
w = a+b; /* for sNaN */
if(((ha&0xfffff)|__LO(a))==0) w = a;
if(((hb^0x7ff00000)|__LO(b))==0) w = b;
return w;
>
/* scale a and b by 2**-600 */
ha -= 0x25800000; hb -= 0x25800000; k += 600;
__HI(a) = ha;
__HI(b) = hb;
>
if(hb <>
if(hb
if((hb|(__LO(b)))==0) return a;
t1=0;
__HI(t1) = 0x7fd00000; /* t1=2^1022 */
b *= t1;
a *= t1;
k -= 1022;
> else < /* scale a and b by 2^600 */
ha += 0x25800000; /* a *= 2^600 */
hb += 0x25800000; /* b *= 2^600 */
k -= 600;
__HI(a) = ha;
__HI(b) = hb;
>
>
/* medium size a and b */
w = a-b;
if (w>b) <
t1 = 0;
__HI(t1) = ha;
t2 = a-t1;
w = sqrt(t1*t1-(b*(-b)-t2*(a+t1)));
> else <
a = a+a;
y1 = 0;
__HI(y1) = hb;
y2 = b — y1;
t1 = 0;
__HI(t1) = ha+0x00100000;
t2 = a — t1;
w = sqrt(t1*y1-(w*(-w)-(t1*y2+t2*b)));
>
if(k!=0) <
t1 = 1.0;
__HI(t1) += (k
return t1*w;
> else return w;
>
Теперь всё становится ясным, такое количество дополнительных проверок не могут обойтись дёшево. Совсем другой вопрос всегда ли нужны они! Решать вам.