Bagikan melalui


Math.Pow(Double, Double) Metode

Definisi

Mengembalikan angka tertentu yang dinaikkan ke pangkat dua yang ditentukan.

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

Parameter

x
Double

Angka floating-point presisi ganda yang akan dinaikkan ke daya.

y
Double

Angka floating-point presisi ganda yang menentukan daya.

Mengembalikan

Angka x yang dinaikkan ke daya y.

Contoh

Contoh berikut menggunakan Pow metode untuk menghitung nilai yang dihasilkan dari menaikkan 2 hingga daya mulai dari 0 hingga 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)

Keterangan

Tabel berikut menunjukkan nilai yang dikembalikan saat berbagai nilai atau rentang nilai ditentukan untuk x parameter dan y . Untuk informasi selengkapnya, lihat Double.PositiveInfinity, Double.NegativeInfinity, and Double.NaN.

x y Nilai kembali
Nilai apa pun kecuali NaN ±0 1
NaN ±0 1 (NaN pada .NET Framework)*
NaN Nilai apa pun kecuali 0 NaN*
±0 < 0 dan bilangan bulat ganjil NegativeInfinity atau PositiveInfinity
±0 NegativeInfinity PositiveInfinity
±0 PositiveInfinity +0
±0 > 0 dan bilangan bulat ganjil ±0
-1 NegativeInfinity atau PositiveInfinity 1
+1 Nilai apa pun kecuali NaN 1
+1 NaN 1 (NaN pada .NET Framework)*
Nilai apa pun kecuali 1 NaN NaN*
-1 < x < 1 PositiveInfinity +0
< -1 atau > 1 PositiveInfinity PositiveInfinity
-1 < x < 1 NegativeInfinity PositiveInfinity
< -1 atau > 1 NegativeInfinity +0
PositiveInfinity < 0 +0
PositiveInfinity > 0 PositiveInfinity
NegativeInfinity < Bilangan bulat 0 dan terbatas dan ganjil -0
NegativeInfinity > Bilangan bulat 0 dan terbatas dan ganjil NegativeInfinity
NegativeInfinity < 0 dan terbatas dan bukan bilangan bulat aneh +0
NegativeInfinity > 0 dan terbatas dan bukan bilangan bulat aneh PositiveInfinity
±0 < 0 dan terbatas dan bukan bilangan bulat aneh PositiveInfinity
±0 > 0 dan terbatas dan bukan bilangan bulat aneh +0
< 0 tetapi tidak NegativeInfinity Bilangan bulat terbatas NaN

* Baris ini tidak muncul dalam seperangkat aturan lengkap untuk pow seperti yang didefinisikan oleh Standar IEEE untuk Floating-Point Aritmatika. Mereka disertakan di sini karena .NET menonaktifkan pengecualian titik mengambang IEEE 754 dan dengan demikian tidak membedakan antara qNaN (NaN tenang) dan sNaN (memberi sinyal NaN). Spesifikasi IEEE 754 memungkinkan penonaktifan pengecualian ini.

Metode ini memanggil runtime C yang mendasarinya, dan hasil yang tepat atau rentang input yang valid mungkin berbeda antara sistem operasi atau arsitektur yang berbeda.

Berlaku untuk

Lihat juga