Java возведение в квадрат

Математические вычисления и класс Math

Последнее обновление: 28.10.2018

Для выполнения различных математических операций в Java в пакете java.lang определен класс
Math. Рассмотрим его основные методы:

• : возвращает абсолютное значение для аргумента value

  double result = Math.abs(-13.5); // 13.5
  

• : возвращает арккосинус value. Параметр value должен иметь значение от -1 до 1

  double result = Math.acos(1); // 0.0
  

• : возвращает арксинус value. Параметр value должен иметь значение от -1 до 1

• : возвращает арктангенс value

• : возвращает кубический корень числа value

  double result = Math.cbrt(27); // 3
  

• : возвращает наименьшее целое число с плавающей точкой, которое не меньше value

  double result = Math.ceil(2.34); // 3
  

• : возвращает косинус угла d

• : возвращает гиперболический косинус угла d

• : возвращает основание натурального логарифма, возведенное в степень d

• : возвращает наибольшее целое число, которое не больше d

  double result = Math.floor(2.56); // 2
  

• : возвращает целочисленный результат деления a на b

  System.out.println(Math.floorDiv(1, 2)); // 0
  System.out.println(Math.floorDiv(7, 2)); // 3
  System.out.println(Math.floorDiv(9, 2)); // 4
  

• : возвращает натуральный логарифм числа a

• : возвращает натуральный логарифм числа (d + 1)

• : возвращает десятичный логарифм числа d

• : возвращает максимальное число из a и b

• : возвращает минимальное число из a и b

• : возвращает число a, возведенное в степень b

• : возвращает случайное число от 0.0 до 1.0

• : возвращает число double, которое представляет ближайшее к числу value целое число

  System.out.println(Math.rint(2)); // 2.0
  System.out.println(Math.rint(2.3)); // 2.0
  System.out.println(Math.rint(2.5)); // 2.0
  System.out.println(Math.rint(2.5001)); // 3.0
  System.out.println(Math.rint(2.8)); // 3.0
  

• : возвращает число d, округленное до ближайшего целого числа

  System.out.println(Math.round(2.3)); // 2
  System.out.println(Math.round(2.5)); // 3
  System.out.println(Math.round(2.5001)); // 3
  System.out.println(Math.round(2.8)); // 3
  

• : возвращает произведение числа value на 2 в степени factor

  System.out.println(Math.scalb(5, 3)); // 5*2*2*2 = 40
  System.out.println(Math.scalb(3, 4)); // 3*2*2*2*2 = 48
  

• : возвращает число 1, если число value положительное, и -1, если значение value отрицательное. Если value равно 0, то возвращает 0

  System.out.println(Math.signum(2.3)); // 1
  System.out.println(Math.signum(-2.3)); // -1
  

• : возвращает синус угла value

• : возвращает гиперболический синус угла value

• : возвращает квадратный корень числа value

  double result1 = Math.sqrt(16); // 4
  

• : возвращает тангенс угла value

• : возвращает гиперболический тангенс угла value

• переводит радианы в градусы и — градусы в радианы

  System.out.println(Math.toDegrees(3.14159)); // 180
  System.out.println(Math.toRadians(90)); // 1,57079....
  

Также класс Math определяет две константы: и . Например, вычислим площадь круга:

import java.util.Scanner;

public class Program {
  
    public static void main(String[] args) {
          
        Scanner in = new Scanner(System.in);
        
        System.out.print("Введите радиус круга: ");
        int radius = in.nextInt();
        long area = Math.round(Math.PI * Math.pow(radius, 2));
        System.out.printf("Площадь круга с радиусом %d равна %d \n", radius, area);
    }
}

Консольный вывод:

Введите радиус круга: 10
Площадь круга с радиусом 10 равна 314

НазадВперед

Типы данных

Последнее обновление: 26.10.2018

Одной из основных особенностей Java является то, что данный язык является строго типизированным. А это значит, что каждая переменная и константа
представляет определенный тип и данный тип строго определен. Тип данных определяет диапазон значений, которые может хранить переменная или константа.

Итак, рассмотрим систему встроенных базовых типов данных, которая используется для создания переменных в Java. А она представлена следующими типами.

• boolean: хранит значение или

  boolean isActive = false;
  boolean isAlive = true;
  

• byte: хранит целое число от до и занимает 1 байт

  byte a = 3;
  byte b = 8;
  

• short: хранит целое число от до и занимает 2 байта

  short a = 3;
  short b = 8;
  

• int: хранит целое число от до и занимает 4 байта

  int a = 4;
  int b = 9;
  

• long: хранит целое число от до и занимает
  8 байт

  long a = 5;
  long b = 10;
  

• double: хранит число с плавающей точкой от до и
  занимает 8 байт

  double x = 8.5;
  double y = 2.7;
  

  В качестве разделителя целой и дробной части в дробных литералах используется точка.

• float: хранит число с плавающей точкой от до и
  занимает 4 байта

  float x = 8.5F;
  float y = 2.7F;
  

• char: хранит одиночный символ в кодировке UTF-16 и занимает 2 байта, поэтому диапазон хранимых значений от
  до

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

Целые числа

Все целочисленные литералы, например, числа 10, 4, -5, воспринимаются как значения типа int, однако мы можем присваивать целочисленные литералы
другим целочисленным типам: byte, long, short. В этом случае Java автоматически осуществляет соответствующие
преобразования:

byte a = 1;
short b = 2;
long c = 2121;

Однако если мы захотим присвоить переменной типа long очень большое число, которое выходит за пределы допустимых значений для типа int,
то мы столкнемся с ошибкой во время компиляции:

long num = 2147483649;

Здесь число 2147483649 является допустимым для типа long, но выходит за предельные значения для типа int. И так как все целочисленные
значения по умолчанию расцениваются как значения типа int, то компилятор укажет нам на ошибку. Чтобы решить проблему, надо добавить к числу суффикс
l или L, который указывает, что число представляет тип long:

long num = 2147483649L;

Как правило, значения для целочисленных переменных задаются в десятичной системе счисления, однако мы можем применять и другие системы счисления.
Например:

int num111 = 0x6F; // 16-тиричная система, число 111
int num8 = 010; // 8-ричная система, число 8
int num13 = 0b1101; // 2-ичная система, число 13

Для задания шестнадцатеричного значения после символов 0x указывается число в шестнадцатеричном формате.
Таким же образом восьмеричное значение указывается после символа , а двоичное значение — после символов 0b.

Также целые числа поддерживают разделение разрядов числа с помощью знака подчеркивания:

int x = 123_456;
int y = 234_567__789;
System.out.println(x); 	// 123456
System.out.println(y); 	// 234567789

Числа с плавающей точкой

При присвоении переменной типа float дробного литерала с плавающей точкой, например, 3.1, 4.5 и т.д., Java автоматически рассматривает этот литерал как значение типа .
И чтобы указать, что данное значение должно рассматриваться как , нам надо использовать суффикс f:

float fl = 30.6f;
double db = 30.6;

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

Символы и строки

В качестве значения переменная символьного типа получает одиночный символ, заключенный в одинарные кавычки: .
Кроме того, переменной символьного типа также можно присвоить целочисленное значение от до . В этом случае
переменная опять же будет хранить символ, а целочисленное значение будет указывать на номер символа в таблице символов Unicode (UTF-16). Например:

char ch=102; // символ 'f'
System.out.println(ch);

Еще одной формой задания символьных переменных является шестнадцатеричная форма: переменная получает значение в шестнадцатеричной форме,
которое следует после символов «\u». Например, опять же будет хранить символ ‘f’.

Символьные переменные не стоит путать со строковыми, ‘a’ не идентично «a». Строковые переменные представляют объект , который
в отличие от char или int не является примитивным типом в Java:

String hello = "Hello...";
System.out.println(hello);

НазадВперед

Прямоугольные треугольники и Евклидовы нормы

Любой учащийся старших классов школы знает теорему Пифагора: квадрат гипотенузы прямоугольного треугольника равен сумме квадратов катетов (c2 = a2 + b2).

Те из вас, кто изучал физику и высшую математику в ВУЗах, знают, что это соотношение встречается далеко не только в прямоугольных треугольниках. Например, это также квадрат Евклидовой нормы R2, длина двухмерного вектора, часть неравенства треугольника и т.д. На самом деле все это представляет собой примеры различных взглядов на одно и то же соотношение, но смысл в том, что теорема Пифагора значительно важнее, чем может показаться на первый взгляд.

В Java 5 был добавлен метод , выполняющий именно эту операцию (это хороший пример того, как может быть полезна данная библиотека). Наивный вариант вычисления суммы квадратов мог бы выглядеть примерно так:

public static double hypot(double x, double y){
  return Math.sqrt (x*x + y*y);
}

В реальности же код несколько более сложен (листинг 2). Первое, что бросается в глаза – это то, что метод реализован на языке С для максимальной производительности. Кроме того, видно, что были предприняты все меры для минимизации погрешности вычисления. Более того, в зависимости от относительного размера переменных и выбираются разные алгоритмы.

Листинг 2. Использующаяся на практике реализация метода

/*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunSoft, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice 
 * is preserved.
 * ====================================================
 */

#include "fdlibm.h"

#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) {a=y;b=x;j=ha; ha=hb;hb=j;} else {a=x;b=y;}
       __HI(a) = ha;       /* a <- |a| */
       __HI(b) = hb;       /* b <- |b| */
       if((ha-hb)>0x3c00000) {return a+b;} /* x/y > 2**60 */
       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 < 0x20b00000) {       /* b < 2**-500 */
           if(hb <= 0x000fffff) {       /* subnormal b or 0 */       
              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;
           }
       }
    /* если a и 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<<20);
           return t1*w;
       } else return w;
}

На самом деле, будете вы использовать именно эту реализацию или одну из нескольких похожих, зависит от используемой JVM для вашей платформы. Однако, скорее всего, именно эта функция будет использоваться при работе со стандартной JDK от Sun (другие поставщики JDK могут попытаться разработать более быстродействующую реализацию этой функции).

Этот код (а также большая часть нативного кода реализации математических функций из библиотеки Java Development Library от Sun) был позаимствована из открытой библиотеки , созданной в Sun примерно 15 лет назад. Эта библиотека была специально спроектирована для реализации стандарта IEE754, а также обеспечения точности вычислений, возможно даже ценой некоторой потери производительности.

2.3 Сужение типов

А что насчет остальных вариантов? Что делать, если нужно переменной типа присвоить значение переменной типа ?

Представьте, что переменная — это корзина. У нас есть корзины разных размеров: 1, 2, 4 и 8 байт. При перекладывании пирожков из меньшей корзины в большую проблем не будет. А вот при перекладывании из большей в меньшую часть пирожков может потеряться.

Это преобразование — от типа большего размера к меньшему — называют сужением типа. При таком присваивании часть числа может просто не поместиться в новую переменную и «остаться за бортом».

При сужении типа мы должны явно показать компилятору, что мы не ошиблись, и отбрасывание части числа сделано осознанно. Для этого используется оператор приведения типа. Это имя типа в круглых скобочках.

В таких ситуациях Java-компилятор требует от программиста указывать оператор преобразования типа. Выглядит в общем виде он так:

Примеры:

Код	Описание
	Каждый раз нужно явно указывать оператор преобразования типа

В данном случае равно , и это кажется излишним. А что если бы было больше?

Код	Описание

Миллион отлично помещается и в тип , и в тип . А вот при присваивании миллиона переменной типа два первых байта были отброшены, и остались только два последних байта. А при присваивании типу вообще остался один последний байт.

Устройство чисел в памяти:

Тип	Двоичная запись	Десятичная запись
	0b00000000000011110100001001000000
	0b0100001001000000
	0b01000000

Тип

Тип , как и тип , занимает два байта, но для их преобразования в друг друга всегда нужно использовать оператор приведения типа. Все дело в том, что тип знаковый, и может содержать значения от до , а тип беззнаковый, и может содержать значения от до .

В нельзя сохранить отрицательные числа, которые могут храниться в . А в нельзя сохранить числа больше , которые могут храниться в .

Гиперболические тригонометрические функции

Гиперболические тригонометрические функции имеют такое же отношение к гиперболам, как обычные тригонометрические функции к окружностям. Представьте себе, что значения этих функций нанесены на Декартову плоскость для всех возможных значений аргумента t.

x = r cos(t)
y = r sin(t)

В результате у вас получится окружность радиуса r. Теперь представьте, что вместо обычных синуса и косинуса используются функции sinh и cosh.

x = r cosh(t)
y = r sinh(t)

В этом случае вы нарисуете равнобочную гиперболу, в которой точкой, наиболее близкой к началу координат, является r.

О гиперболических функциях можно рассуждать следующим образом: известно, что sin(x) равен (eix — e-ix, а cos(x) = (eix + e-ix)/2. Функции sinh и cosh можно получить, убрав мнимую единицу из этих формул, т.е. sinh(x) = (ex — e-x)/2, а cosh(x) = (ex + e-x)/2.

В Java 5 были добавлены все три метода: , и . При этом в состав класса пока не были включены обратные гиперболические функции: acosh, asinh и atanh.

График функции cosh(z) имеет вид свисающего каната, закрепленного с обоих концов. Он известен под именем цепная линия (catenary). В листинге 5 показан текст простой программы, рисующей цепную линию при помощи функции .

Листинг 5. Рисование цепной линии при помощи функции

import java.awt.*;

public class Catenary extends Frame {

    private static final int WIDTH = 200;
    private static final int HEIGHT = 200;
    private static final double MIN_X = -3.0;
    private static final double MAX_X = 3.0;
    private static final double MAX_Y = 8.0;

    private Polygon catenary = new Polygon();

    public Catenary(String title) {
        super(title);
        setSize(WIDTH, HEIGHT);
        for (double x = MIN_X; x <= MAX_X; x += 0.1) {
            double y = Math.cosh(x);
            int scaledX = (int) (x * WIDTH/(MAX_X - MIN_X) + WIDTH/2.0);
            int scaledY = (int) (y * HEIGHT/MAX_Y);
            // В компьютерной графике ось y направлена вниз, а не вверх
            // (как в Декартовых координатах), поэтому необходимо изменить знак
            scaledY = HEIGHT - scaledY;
            catenary.addPoint(scaledX, scaledY);
        }
    }

    public static void main(String[] args) {
        Frame f = new Catenary("Catenary");
        f.setVisible(true);
    }

    public void paint(Graphics g) {
        g.drawPolygon(catenary);
    }

}

График показан на рисунке 1.

Теория чисел

math.factorial(x)

Возвращает факториал указанного числа x.

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

Если x не является целым числом (int) или если x является отрицательным, то будет вызвано исключение ValueError.

math.gcd(x)

Возвращает наибольший общий делитель (НОД) двух целых чисел a и b.

Если оба числа отличны от нуля, то будет возвращено число, которое всегда делит оба эти числа:

В случае если числа a и b являются взаимно простыми, то будет возвращена \(1\):

Если одно из чисел равно нулю, то будет возвращено, другое, отличное от \(0\) число:

Если оба числа равны \(0\), то функция вернет \(0\):

Указанные числа должны быть целыми (тип int), но могут быть как положительными, так и отрицательными:

Доступно в Python с версии 3.5.

math.frexp(x)

Возвращает кортеж из двух чисел таких что .

Число m принадлежит к типу float и всегда является таким, что , даже для тех случаев, когда значением x является произвольная степень двойки. Число e всегда целое (int):

Если x равен \(0\), то будет возвращено .

Чаще всего данная функция используется тогда, когда представление чисел типа float не должно зависеть от архитектуры используемой машины.

math.ldexp(x, i)

Возвращает , т.е. является обратной к функции .

math.fabs(x)

Возвращает абсолютное значение (модуль) числа x. Результат всегда типа float.

Данная функция в отличии от встроенной функции не обрабатывает комплексные числа:

math.fmod(x)

Возвращает остаток от деления числа x на число y, вычисленный так, как это определено в библиотеке языка C.

Данная функция направлена на то, что бы результат был максимально приближен к значению для некоторого целого числа n, что бы этот результат имел тот же знак, что и x, что бы разность .

Для чисел типа float данная функция является предпочтительнее чем команда , которая в свою очередь является предпочтительной для чисел типа int, так как для некоторых случаев (например, при и ) команда может вообще выдать неправильный результат.

math.modf(x)

Возвращает кортеж из двух чисел где f – дробная, а w – целая часть числа x. Результат всегда имеет тип float.

math.fsum(iterable)

Возвращает точную сумму значений в итерируемом объекте iterable. Возвращаемый результат всегда типа float.

Может показаться, что эта сумма будет точной всегда, но на самом деле это не так:

Многое зависит от используемой платформы, точнее от сборки компилятора языка C, который используется на данной платформе. Если вам нужны точные арифметические операции с десятичными дробями, то воспользуйтесь модулем decimal.

math.copysign(x, y)

Возвращает число x со знаком числа y. Возвращаемый результат всегда типа float

Если используемой платформой поддерживаются нули со знаком, то знак второго аргумента так же будет копироваться:

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

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

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

Для таких ситуаций, в которых мы готовы считаться с некоторой погрешностью и подходит функция :

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

Параметр (relative tolerances) – это относительный допуск, определяемый как максимально допустимая разница между числами и относительно большего из них по модулю. По умолчанию, , это гарантирует, что числа и будут одинаковы, в пределах 9 десятичных цифр. Что бы числа считались равными, если они, допустим, отличаются меньше чем на 0.1%, то достаточно установить , но в любом случае данный параметр, должен быть больше нуля:

Параметр (absolute tolerances) – это минимальный абсолютный допуск, который определяет как сравнивать значения близкие к нулю. Данный параметр должен быть не меньше нуля:

Данная функция эквивалентна команде . Значения inf, -inf считаются близкими только сами к себе, а NaN не является близким ни к одному значению, включая само NaN.

1.1 Список примитивных типов

В Java есть 8 базовых примитивных типов. Примитивными их называют потому, что значения этих типов не являются объектами и хранятся прямо внутри переменных.

Вот таблица, которая содержит краткую информацию по этим типам:

Тип	Размер, байт	Диапазон значений	Значение по умолчанию	Описание
	1	-128 .. 127	Самое маленькое целое — один байт
	2	-32,768 .. 32,767	Короткое целое, два байта
	4	-2*109 .. 2*109	Целое число, 4 байта
	8	-9*1018 .. 9*1018		Длинное целое, 8 байт
	4	-1038 .. 1038		Дробное, 4 байта
	8	-10308 .. 10308		Дробное, двойной длины, 8 байт
	1	,		Логический тип (только & )
	2	0 .. 65,535		Символы, 2 байта, все больше 0

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

Кстати, важный нюанс. Если вы объявили переменную-класса (поле класса) или статическую переменную-класса, и не присвоили ей никакого значения, она инициализируется значением по умолчанию. Список таких значений приведен в таблице.

Локальные переменные методов не имеют значений по умолчанию, и если вы не присвоили такой переменной никакого значения, она считается не инициализированной и использовать ее значение нельзя.

Но давайте вернемся к примитивным типам и рассмотрим их подробнее

2.1 Приведение типов

Переменные примитивных типов (за исключением типа ) используются для хранения разных типов чисел. И хоть типы переменных всегда неизменны, есть место, где можно проводить преобразование типов. И место это — присваивание.

Можно присваивать друг другу переменные разных типов. При этом значение, взятое из переменной одного типа, будет преобразовано в значение другого типа и присвоено второй переменной. В связи с этим можно выделить два вида преобразования типов: расширение и сужение.

Расширение типа похоже на перекладывание из маленькой корзинки в большую — операция проходит незаметно и безболезненно. Сужение типа — это перекладывание из большой корзинки в маленькую: места может не хватить, и что-то придётся выбросить.

Вот типы, отсортированные по размеру «корзинки»:

1.4 Минимум и максимум из нескольких чисел

Есть еще одно полезное применение функций и .

Это вычисление минимума (или максимума) из нескольких чисел или переменных. Функции очень удобно вызывать друг в друге.

Вот как можно записать минимум из 3-х чисел:

А что? Очень удобно: вычисляем минимум пары чисел, а затем возвращаем меньшее число из найденного и оставшегося.

Минимум из четырех чисел получается аналогично:

Хотя можно эту формулу записать немного понятнее:

Для функции все аналогично.

Использование оператора или тернарного оператора сделало бы эти записи немного более громоздкими. А использование функций и — просто идеальное решение.

Пример 4: возведение отрицательного числа степень

Заметьте, что при возведении отрицательного числа в дробную степень мы не получим результат (NaN).

Данная статья написана командой Vertex Academy. Это одна из статей из нашего «Самоучителя по Java.»

Условие задачи:

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

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

Комментарии к задаче:

Изначально Вам необходимо вывести общую формулу возведения числа в степень.

Как видите, на картинке выше мы показали, что общая формула возведения в степень — это a в степени b. Поэтому в методе мы написали следующее:

Мы использовали цикл for

Причем обратите внимание, что в цикле for мы написали i. И, таким образом, в консоли было выведено число 73

И, таким образом, в консоли было выведено число 73.

Надеемся — наша статья была Вам полезна. Есть возможность записаться на наши курсы по Java. Детальную информацию смотрите у нас на сайте.

вот мой код. По какой-то причине мой ИМТ вычисляется неправильно. Когда я проверяю выход на калькуляторе для этого: (10/((10/100)^2))) Я получаю 1000, но в моей программе, я получаю 5. Не знаю, что я делаю не так. Вот мой код:

java.lang.Math

Класс java.lang.Math содержит некоторые предопределённые константы и методы, позволяющие вычислять синус, косинус, возводить в степень и т. д.

Константы:

Java

public static final double E = 2.7182818284590452354;

1	publicstaticfinaldoubleE=2.7182818284590452354;

Основание натурального логарифма.

Java

public static final double PI = 3.14159265358979323846;

1	publicstaticfinaldoublePI=3.14159265358979323846;

Число . Отношение длины окружности к длине её диаметра.

Методы:

Java

public static double sin(double a)

1	publicstaticdoublesin(doublea)

Возвращает синус угла
a . Угол задаётся в радианах.

Java

public static double cos(double a)

1	publicstaticdoublecos(doublea)

Возвращает косинус угла
a . Угол задаётся в радианах.

Java

public static double tan(double a)

1	publicstaticdoubletan(doublea)

Возвращает тангенс угла
a . Угол задаётся в радианах.

Java

public static double asin(double a)

1	publicstaticdoubleasin(doublea)

Возвращает арксинус угла
a . Угол задаётся в радианах.

Java

public static double acos(double a)

1	publicstaticdoubleacos(doublea)

Возвращает арккосинус угла
a . Угол задаётся в радианах.

Java

public static double atan(double a)

1	publicstaticdoubleatan(doublea)

Возвращает арктангенс угла
a . Угол задаётся в радианах.

Java

public static double log(double a)

1	publicstaticdoublelog(doublea)

Возвращает натуральный логарифм угла
a . Угол задаётся в радианах.

Java

public static double sqrt(double a)

1	publicstaticdoublesqrt(doublea)

Возвращает квадратный корень от 
a .

Java

public static double pow(double a,
double b)

1 2	publicstaticdoublepow(doublea, doubleb)

Возвращает
a  возведённое в степень
b .

Java

public static long round(double a)

1	publicstaticlonground(doublea)

Возвращает округлённое значение
a .

и другие методы.

Цикл статей «Учебник Java 8».

Следующая статья — «Java 8 строки».
Предыдущая статья — «Java 8 перечисления».

6 ответов

^ в java не означает повышение до мощности. Это означает XOR.

вы можете использовать java Math.pow()

и вы можете рассмотреть возможность использования double вместо int -это:

отметим, что 199/100 возвращает 1.

это означает 2 в степени 4 (2^4)

ваш расчет, вероятно, виновник. Попробуйте использовать:

так как height и 100 являются целыми числами, вы, вероятно, получили неправильный ответ при делении. Однако, 100.0 — это двойной. Я предлагаю вам сделать weight двойной также. Кроме того, ^ оператор не для державы. Используйте Math.pow() метод вместо этого.

^ не является оператором, который вы хотите. Вы ищете pow функции java.lang.Math .

можно использовать Math.pow(value, power) .

слишком поздно для операции, конечно, но все же. Перестановка выражения как:

устраняет всю плавающую точку и преобразует деление на константу в умножение, которое должно выполняться быстрее. Целочисленная точность, вероятно, адекватна для этого приложения, но если это не так, то:

Добрый вечер. Хелп.

нужно каждое число возвести в квадрат и вывести на экранПример:а = 3 б = 5результ:91625

public class MathDemo <

public static void main(String[] args) <

// get two double numbers int x = 3; int y = 2;

public static void main(String[] args) <System.out.println(«Введите число»);Scanner x= new Scanner(System.in);// get two double numbersint xch = x.nextInt();System.out.println(«Введите степень»);int ystep = x.nextInt();x.close();// print x raised by y and then y raised by xSystem.out.println( + xch + » в степени » + ystep + » =» + Math.pow(xch, ystep));>>

public static void main(String args[]) <int a = 1; // Начальное число int b = 10; // Конечное число

// Возведение каждого числа в квадрат и вывод на экран for (int i = a; i Andrew Malets Ученик (111) 1 год назад

Знак

Метод преобразует положительные числа в 1.0, отрицательные – в -1.0, а ноль оставляет без изменений. По сути, она просто возвращает знак числа. Это может быть полезно при реализации интерфейса .

Существуют две версии этого метода: для типов и . Метод может показаться тривиальным, однако необходим для корректной обработки специальных случаев, встречающихся при вычислениях с плавающей точкой, например NaN, а также положительные и отрицательные нули. NaN считается равным нулю, а знаком положительного и отрицательного нуля считается положительный и отрицательный ноль соответственно. Например, допустим, что вам потребовалось реализовать данный метод, и вы выбрали наивное решение, подобное показанному в листинге 6.

Листинг 6. Ошибочная реализация метода

public static double signum(double x) {
  if (x == 0.0) return 0;
  else if (x < 0.0) return -1.0;
  else return 1.0;
}

Во-первых, этот метод преобразует положительные нули в отрицательные (отрицательные нули могут выглядеть несколько странно, однако они являются неотъемлемой частью спецификации IEEE 754). Во-вторых, в соответствии с этим методом значение NaN является положительным. Поэтому на практике используется реализация, показанная в листинге 7, которая несколько сложнее, но зато корректно обрабатывает специальные случаи.

Листинг 7. Корректная реализация метода , использующаяся на практике

public static double signum(double d) {
    return (d == 0.0 || isNaN(d))?d:copySign(1.0, d);
}

public static double copySign(double magnitude, double sign) {
    return rawCopySign(magnitude, (isNaN(sign)?1.0d:sign));
}

public static double rawCopySign(double magnitude, double sign) {
    return Double.longBitsToDouble((Double.doubleToRawLongBits(sign) &
                                   (DoubleConsts.SIGN_BIT_MASK)) |
                                   (Double.doubleToRawLongBits(magnitude) &
                                   (DoubleConsts.EXP_BIT_MASK |
                                    DoubleConsts.SIGNIF_BIT_MASK)));
}