Math.Pow(Double, Double) Метод

Ссылка

Определение

Пространство имен:: System

Сборка:: System.Runtime.Extensions.dll

Сборка:: System.Runtime.dll

Сборка:: mscorlib.dll

Сборка:: netstandard.dll

Исходный код:: Math.cs

Исходный код:: Math.cs

Исходный код:: Math.cs

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Возвращает указанное число, возведенное в указанную степень.

public:
 static double Pow(double x, double y);

public static double Pow (double x, double y);

static member Pow : double * double -> double

Public Shared Function Pow (x As Double, y As Double) As Double

Параметры

x: Double

Число двойной точности с плавающей запятой, возводимое в степень.

y: Double

Число двойной точности с плавающей запятой, задающее степень.

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

Double

Число x, возведенное в степень y.

Примеры

В следующем примере метод используется Pow для вычисления значения, которое является результатом повышения значения 2 до значения в диапазоне от 0 до 32.

int value = 2;
for (int power = 0; power <= 32; power++)
   Console.WriteLine($"{value}^{power} = {(long)Math.Pow(value, power):N0} (0x{(long)Math.Pow(value, power):X})");

// The example displays the following output:
//     2^0 = 1 (0x1)
//     2^1 = 2 (0x2)
//     2^2 = 4 (0x4)
//     2^3 = 8 (0x8)
//     2^4 = 16 (0x10)
//     2^5 = 32 (0x20)
//     2^6 = 64 (0x40)
//     2^7 = 128 (0x80)
//     2^8 = 256 (0x100)
//     2^9 = 512 (0x200)
//     2^10 = 1,024 (0x400)
//     2^11 = 2,048 (0x800)
//     2^12 = 4,096 (0x1000)
//     2^13 = 8,192 (0x2000)
//     2^14 = 16,384 (0x4000)
//     2^15 = 32,768 (0x8000)
//     2^16 = 65,536 (0x10000)
//     2^17 = 131,072 (0x20000)
//     2^18 = 262,144 (0x40000)
//     2^19 = 524,288 (0x80000)
//     2^20 = 1,048,576 (0x100000)
//     2^21 = 2,097,152 (0x200000)
//     2^22 = 4,194,304 (0x400000)
//     2^23 = 8,388,608 (0x800000)
//     2^24 = 16,777,216 (0x1000000)
//     2^25 = 33,554,432 (0x2000000)
//     2^26 = 67,108,864 (0x4000000)
//     2^27 = 134,217,728 (0x8000000)
//     2^28 = 268,435,456 (0x10000000)
//     2^29 = 536,870,912 (0x20000000)
//     2^30 = 1,073,741,824 (0x40000000)
//     2^31 = 2,147,483,648 (0x80000000)
//     2^32 = 4,294,967,296 (0x100000000)

open System

let value = 2
for power = 0 to 32 do
    printfn $"{value}^{power} = {Math.Pow(value, power) |> int64:N0} (0x{Math.Pow(value, power) |> int64:X})"

// The example displays the following output:
//     2^0 = 1 (0x1)
//     2^1 = 2 (0x2)
//     2^2 = 4 (0x4)
//     2^3 = 8 (0x8)
//     2^4 = 16 (0x10)
//     2^5 = 32 (0x20)
//     2^6 = 64 (0x40)
//     2^7 = 128 (0x80)
//     2^8 = 256 (0x100)
//     2^9 = 512 (0x200)
//     2^10 = 1,024 (0x400)
//     2^11 = 2,048 (0x800)
//     2^12 = 4,096 (0x1000)
//     2^13 = 8,192 (0x2000)
//     2^14 = 16,384 (0x4000)
//     2^15 = 32,768 (0x8000)
//     2^16 = 65,536 (0x10000)
//     2^17 = 131,072 (0x20000)
//     2^18 = 262,144 (0x40000)
//     2^19 = 524,288 (0x80000)
//     2^20 = 1,048,576 (0x100000)
//     2^21 = 2,097,152 (0x200000)
//     2^22 = 4,194,304 (0x400000)
//     2^23 = 8,388,608 (0x800000)
//     2^24 = 16,777,216 (0x1000000)
//     2^25 = 33,554,432 (0x2000000)
//     2^26 = 67,108,864 (0x4000000)
//     2^27 = 134,217,728 (0x8000000)
//     2^28 = 268,435,456 (0x10000000)
//     2^29 = 536,870,912 (0x20000000)
//     2^30 = 1,073,741,824 (0x40000000)
//     2^31 = 2,147,483,648 (0x80000000)
//     2^32 = 4,294,967,296 (0x100000000)

Public Module Example
   Public Sub Main
      Dim value As Integer = 2
      For power As Integer = 0 To 32
         Console.WriteLine("{0}^{1} = {2:N0} (0x{2:X})", _
                           value, power, CLng(Math.Pow(value, power)))
      Next
   End Sub
End Module
' The example displays the following output:
'     2^0 = 1 (0x1)
'     2^1 = 2 (0x2)
'     2^2 = 4 (0x4)
'     2^3 = 8 (0x8)
'     2^4 = 16 (0x10)
'     2^5 = 32 (0x20)
'     2^6 = 64 (0x40)
'     2^7 = 128 (0x80)
'     2^8 = 256 (0x100)
'     2^9 = 512 (0x200)
'     2^10 = 1,024 (0x400)
'     2^11 = 2,048 (0x800)
'     2^12 = 4,096 (0x1000)
'     2^13 = 8,192 (0x2000)
'     2^14 = 16,384 (0x4000)
'     2^15 = 32,768 (0x8000)
'     2^16 = 65,536 (0x10000)
'     2^17 = 131,072 (0x20000)
'     2^18 = 262,144 (0x40000)
'     2^19 = 524,288 (0x80000)
'     2^20 = 1,048,576 (0x100000)
'     2^21 = 2,097,152 (0x200000)
'     2^22 = 4,194,304 (0x400000)
'     2^23 = 8,388,608 (0x800000)
'     2^24 = 16,777,216 (0x1000000)
'     2^25 = 33,554,432 (0x2000000)
'     2^26 = 67,108,864 (0x4000000)
'     2^27 = 134,217,728 (0x8000000)
'     2^28 = 268,435,456 (0x10000000)
'     2^29 = 536,870,912 (0x20000000)
'     2^30 = 1,073,741,824 (0x40000000)
'     2^31 = 2,147,483,648 (0x80000000)
'     2^32 = 4,294,967,296 (0x100000000)

В следующей таблице указано возвращаемое значение, если для параметров и y заданы различные значения или диапазоны значенийx. Дополнительные сведения см. в разделах Double.PositiveInfinity, Double.NegativeInfinity и Double.NaN.

x	y	Возвращаемое значение
Любое значение, кроме `NaN`	±0	1
`NaN`	±0	1 (`NaN` на платформа .NET Framework)*
`NaN`	Любое значение, кроме 0	`NaN`*
±0	< 0 и нечетное целое число	`NegativeInfinity` или `PositiveInfinity`
±0	`NegativeInfinity`	`PositiveInfinity`
±0	`PositiveInfinity`	+0
±0	> 0 и нечетное целое число	±0
-1	`NegativeInfinity` или `PositiveInfinity`	1
+1	Любое значение, кроме `NaN`	1
+1	`NaN`	1 (`NaN` на платформа .NET Framework)*
Любое значение, кроме 1	`NaN`	`NaN`*
-1 < x < 1	`PositiveInfinity`	+0
< -1 или > 1	`PositiveInfinity`	`PositiveInfinity`
-1 < x < 1	`NegativeInfinity`	`PositiveInfinity`
< -1 или > 1	`NegativeInfinity`	+0
`PositiveInfinity`	< 0	+0
`PositiveInfinity`	> 0	`PositiveInfinity`
`NegativeInfinity`	< 0 и конечное и нечетное целое число	-0
`NegativeInfinity`	> 0 и конечное и нечетное целое число	`NegativeInfinity`
`NegativeInfinity`	< 0 и конечное, а не нечетное целое число	+0
`NegativeInfinity`	> 0 и конечное, а не нечетное целое число	`PositiveInfinity`
±0	< 0 и конечное, а не нечетное целое число	`PositiveInfinity`
±0	> 0 и конечное, а не нечетное целое число	+0
< 0, но не `NegativeInfinity`	Конечное не целое число	`NaN`

* Эти строки не отображаются в полном наборе правил для, pow как определено стандартом IEEE для Floating-Point арифметики. Они включены в эту функцию, так как .NET отключает исключения с плавающей запятой IEEE 754 и, следовательно, не различает qNaN (тихие значения NaN) и sNaN (сигнализация NaN). Спецификация IEEE 754 допускает отключение этого исключения.

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

Применяется к

См. также раздел

Sqrt(Double)