Java возведение целых чисел в степень

Метод Math.pow()

Метод Math.pow() — возводит значение первого аргумента в степень второго аргумента, тем самым позволяет осуществить быстрое возведение в степень любых значений.

Синтаксис

double pow(double base, double exponent) 

Параметры

Подробная информация о параметрах:

Возвращаемое значение

• В Java Math.pow() возвращает double значение первого аргумента, возведенное в степень второго аргумента.

Пример 1: возведение числа в квадрат и куб

Для возведения любого числа в квадрат с помощью метода Math.pow() необходимо в качестве второго аргумента использовать значение 2, а для возведения в куб — 3 и т.д. Заметьте, для вывода на экран целого значения используется «%.0f», так как метод возвращает double значение.

Получим следующий результат:

Число 3 в квадрате равно 9 Число 5 в квадрате равно 25.0 Число 2 в кубе равно 8 Число 3 в кубе равно 27.0 

Пример 2: возведение числа в дробную степень

Получим следующий результат:

Значение 10,635 в степени 3,76 равно 7253,256 pow(10,635, 3,760) = 7253,256 Значение 2 в степени 3,76 равно 13,548 pow(2, 3,760) = 13,548 

Пример 3: возведение числа в отрицательную степень

Получим следующий результат:

Значение 7,525 в степени -1,49 равно 0,049 pow(7,525, -1,490) = 0,049 Значение 2 в степени -2 равно 0,25 pow(2, -2) = 0,25 

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

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

Получим следующий результат:

Значение -7,525 в степени 1,49 равно NaN pow(-7,525, 1,490) = NaN Значение -7,525 в степени 2 равно 56,626 pow(-7,525, 2) = 56,626 Значение -7,525 в степени 3 равно -426,108 pow(-7,525, 3) = -426,108 Значение -2 в степени 2 равно 4 pow(-2, 2) = 4 Значение -2 в степени 3 равно -8 pow(-2, 3) = -8 

Пример 5: возведение каждого числа в квадрат и вывод на экран

Получим следующий результат:

Значение 1 в квадрате равно 1 Значение 2 в квадрате равно 4 Значение 3 в квадрате равно 9 Значение 4 в квадрате равно 16 Значение 5 в квадрате равно 25 Значение 6 в квадрате равно 36 Значение 7 в квадрате равно 49 Значение 8 в квадрате равно 64 Значение 9 в квадрате равно 81 Значение 10 в квадрате равно 100 

Источник

Как выполнить возведение в степень в Java

Hello world! Погуглить что-нибудь или попросить помощи на форуме — обычное дело даже для опытного программиста. Но есть в разработке насколько базовые и простые темы, что их должен знать даже зеленый новичок. И вот одна из таких тем. Сегодня поговорим о том, как выполняется возведение в степень в языке Java. Представим на секундочку, что вам дали задачу: найти число в определенной степени. Звучит довольно просто, но каким образом реализовать решение? Давайте рассмотрим самый распространенный способ и несколько альтернативных. А прежде чем “нырнуть” в решения, вначале вспомним, что такое возведение числа в степень: Возведение в степень — это действие, при котором одно число умножается на само себя несколько раз. Число, которое умножается, называется основанием, а количество раз умножения — показателем. Ну а результат этого самоумножения основания называется возведением в степень. Например, для 8 — это 2 в третьей степени, поскольку 2х2×2=8. Возведение какого-либо числа во вторую степень указывает на то, что мы делаем его множителем два раза, и как правило эта степень называется квадратной. То есть 4 в квадрате = 4х4 = 16. Итак, память мы освежили, а теперь переходим непосредственно к способам применения pow в Java — метода для возведения в степень.

Math pow Самый простой способ решения поставленной задачи — использовать класс Math. Это то решение, которое вы будете использовать в большинстве случаев. Класс Math содержит методы, связанные с тригонометрией, геометрией и другими аспектами математики. В нём методы реализованы как статические, поэтому можно сразу вызывать через имя класса Math без создания объекта класса. Как у нас будет выглядеть возведение в степень:

 public static int pow(int value, int powValue)

 public static int pow(int value)

 public static void main(String[] args)

 public static void main(String[] args) < System.out.println(Solution.pow(7, 4)); >public static int pow(int value, int powValue) < int result = 1; for (int i = 1; i return result; > 

Алгоритм весьма прост: мы как бы задаём точку отсчета result, и далее умножаем его на наше значение value столько раз, сколько отработает цикл с powValue (powValue количество раз)
Рекурсия Следующий способ будет немного более экзотическим, но от этого не менее крутым. Рекурсия — это средство, которое позволяет методу вызывать самого себя. В Java такой механизм присутствует, и такие методы, соответственно, называются рекурсивными. Многие, если не все алгоритмические задачки, можно решать рекурсивно. Данная тоже не будет исключением, поэтому давайте взглянем, как можно возвести число в определенную степень рекурсивным способом:

 public static int pow(int value, int powValue) < if (powValue == 1) < return value; >else < return value * pow(value, powValue - 1); >> 

1. Условие выхода из рекурсии, или другими словами, когда у нас значение степени достигнет единицы, нас начнёт выбрасывать назад.
2. Сам механизм умножения value на результат вызова этого же метода, но с powValue — 1.

Ну а теперь пришло время взглянуть на более ленивые способы, а именно — способы “из коробки”.

BigInteger Главное назначение класса BigInteger состоит в хранении целых чисел произвольной величины, но при этом в нём есть различные арифметические методы, позволяющие вести работу с этими огромными (ну или не очень) числами. Подробнее о BigInteger можно почитать вот в этой статье. Итак, как же будет выглядеть возведение в степень с помощью BigInteger в Java?

 public static int pow(int value, int powValue)

Довольно просто и без заморочек, не правда ли?

Ну вот, на сегодня все! Теперь вы знаете о самых разных способах возведения в степень. Согласитесь, это была несложная тема 🙂

Источник

Class Math

The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.

Unlike some of the numeric methods of class StrictMath , all implementations of the equivalent functions of class Math are not defined to return the bit-for-bit same results. This relaxation permits better-performing implementations where strict reproducibility is not required.

By default many of the Math methods simply call the equivalent method in StrictMath for their implementation. Code generators are encouraged to use platform-specific native libraries or microprocessor instructions, where available, to provide higher-performance implementations of Math methods. Such higher-performance implementations still must conform to the specification for Math .

The quality of implementation specifications concern two properties, accuracy of the returned result and monotonicity of the method. Accuracy of the floating-point Math methods is measured in terms of ulps, units in the last place. For a given floating-point format, an ulp of a specific real number value is the distance between the two floating-point values bracketing that numerical value. When discussing the accuracy of a method as a whole rather than at a specific argument, the number of ulps cited is for the worst-case error at any argument. If a method always has an error less than 0.5 ulps, the method always returns the floating-point number nearest the exact result; such a method is correctly rounded. A correctly rounded method is generally the best a floating-point approximation can be; however, it is impractical for many floating-point methods to be correctly rounded. Instead, for the Math class, a larger error bound of 1 or 2 ulps is allowed for certain methods. Informally, with a 1 ulp error bound, when the exact result is a representable number, the exact result should be returned as the computed result; otherwise, either of the two floating-point values which bracket the exact result may be returned. For exact results large in magnitude, one of the endpoints of the bracket may be infinite. Besides accuracy at individual arguments, maintaining proper relations between the method at different arguments is also important. Therefore, most methods with more than 0.5 ulp errors are required to be semi-monotonic: whenever the mathematical function is non-decreasing, so is the floating-point approximation, likewise, whenever the mathematical function is non-increasing, so is the floating-point approximation. Not all approximations that have 1 ulp accuracy will automatically meet the monotonicity requirements.

The platform uses signed two’s complement integer arithmetic with int and long primitive types. The developer should choose the primitive type to ensure that arithmetic operations consistently produce correct results, which in some cases means the operations will not overflow the range of values of the computation. The best practice is to choose the primitive type and algorithm to avoid overflow. In cases where the size is int or long and overflow errors need to be detected, the methods whose names end with Exact throw an ArithmeticException when the results overflow.

IEEE 754 Recommended Operations

The 2019 revision of the IEEE 754 floating-point standard includes a section of recommended operations and the semantics of those operations if they are included in a programming environment. The recommended operations present in this class include sin , cos , tan , asin , acos , atan , exp , expm1 , log , log10 , log1p , sinh , cosh , tanh , hypot , and pow . (The sqrt operation is a required part of IEEE 754 from a different section of the standard.) The special case behavior of the recommended operations generally follows the guidance of the IEEE 754 standard. However, the pow method defines different behavior for some arguments, as noted in its specification. The IEEE 754 standard defines its operations to be correctly rounded, which is a more stringent quality of implementation condition than required for most of the methods in question that are also included in this class.

Источник