Jaka jest funkcja C ++ do podniesienia liczby do potęgi?

Jak podnieść liczbę do potęgi?

2^1

2^2

2^3

itp...

pow () w bibliotece cmath. Więcej informacji tutaj . Nie zapomnij umieścić #include<cmath>na początku pliku.

std::poww <cmath>nagłówku ma następujące przeciążenia:

pow(float, float);
pow(float, int);
pow(double, double); // taken over from C
pow(double, int);
pow(long double, long double);
pow(long double, int);

Teraz nie możesz tak po prostu zrobić

pow(2, N)

z N jest int, ponieważ nie wie, który z float, doublelub long doublewersja powinna zająć, i pojawi się błąd dwuznaczności. Wszystkie trzy wymagałyby konwersji z int na zmiennoprzecinkowe, a wszystkie trzy są równie kosztowne!

Dlatego upewnij się, że wpisano pierwszy argument, aby idealnie pasował do jednego z tych trzech. Zwykle używamdouble

pow(2.0, N)

Znowu jakiś prawnik mnie bzdura. Często sam wpadałem w tę pułapkę, więc ostrzegam cię przed tym.

W C ++ operatorem „^” jest bitowe OR. Nie działa na podniesienie do potęgi. X << n jest przesunięciem liczby binarnej w lewo, które jest tym samym, co pomnożenie x przez 2 n razy i może być użyte tylko wtedy, gdy podniesie się 2 do potęgi. Funkcja POW to funkcja matematyczna, która działa ogólnie.

Powinieneś umieć używać normalnych metod języka C.

#include <cmath>

pow(2,3)

jeśli używasz systemu podobnego do uniksowego, man cmath

Czy o to pytasz?

Sujal

Użyj funkcji pow (x, y): Zobacz tutaj

Po prostu dołącz math.h i gotowe.

Chociaż pow( base, exp )jest to świetna sugestia, należy pamiętać, że zazwyczaj działa ona w trybie zmiennoprzecinkowym.

Może to być to, czego chcesz, ale nie musi: w niektórych systemach prosta pętla mnożenia na akumulatorze będzie szybsza dla typów całkowitych.

A zwłaszcza w przypadku kwadratu, równie dobrze możesz po prostu pomnożyć liczby razem, zmiennoprzecinkowe lub całkowite; tak naprawdę nie jest to spadek czytelności (IMHO) i unikasz narzutu wydajności wywołania funkcji.

Nie mam wystarczającej reputacji, aby komentować, ale jeśli lubisz pracować z QT, mają swoją własną wersję.

    #include <QtCore/qmath.h>
    qPow(x, y); // returns x raised to the y power.

Lub jeśli nie używasz QT, cmath ma w zasadzie to samo.

    #include <cmath>
    double x = 5, y = 7; //As an example, 5 ^ 7 = 78125
    pow(x, y); //Should return this: 78125

jeśli chcesz zajmować się tylko base_2, zalecam użycie operatora przesunięcia w lewo << zamiast biblioteki matematycznej .

przykładowy kod :

int exp = 16;
for(int base_2 = 1; base_2 < (1 << exp); (base_2 <<= 1)){
std::cout << base_2 << std::endl;
}

przykładowe wyjście:

1   2   4   8   16  32  64  128  256  512  1024  2048  4096  8192  16384  32768

#include <iostream>
#include <conio.h>

using namespace std;

double raiseToPow(double ,int) //raiseToPow variable of type double which takes arguments (double, int)

void main()
{
    double x; //initializing the variable x and i 
    int i;
    cout<<"please enter the number"; 
    cin>>x;
    cout<<"plese enter the integer power that you want this number raised to";
    cin>>i;
    cout<<x<<"raise to power"<<i<<"is equal to"<<raiseToPow(x,i);
}

// definicja funkcji raiseToPower

double raiseToPow(double x, int power)
{
    double result;
    int i;
    result =1.0;
    for (i=1, i<=power;i++)
    {
        result = result*x;
    }
    return(result);
}

To jest pow lub powf in <math.h>

Nie ma specjalnego operatora infix, takiego jak w Visual Basic czy Pythonie

Wiele odpowiedzi sugerowało pow()lub podobne alternatywy lub własne implementacje. Jednakże, biorąc pod uwagę przykłady ( 2^1, 2^2i 2^3) w swoim pytaniu, to myślę, czy wystarczy, aby podnieść 2do potęgi całkowitej. Jeśli tak jest, proponuję użyć 1 << ndo 2^n.

pow(2.0,1.0)
pow(2.0,2.0)
pow(2.0,3.0)

Tytuł Twojego pytania jest mylący. Aby po prostu wyrównać , użyj 2*2.

Zwróć uwagę, że użycie pow(x,y)jest mniej wydajne niż x*x*xy razy, jak pokazano i odpowiedział tutaj https://stackoverflow.com/a/2940800/319728 .

Więc jeśli masz zamiar używać wydajności x*x*x.

int power (int i, int ow) // works only for ow >= 1
{ // but does not require <cmath> library!=)
    if (ow > 1)
    {
         i = i * power (i, ow - 1);
    }
    return i;
}

cout << power(6,7); //you can enter variables here

Korzystam z biblioteki cmathlub math.hw celu korzystania z pow()funkcji biblioteki, która dba o uprawnienia

#include<iostream>
#include<cmath>

int main()
{
    double number,power, result;
    cout<<"\nEnter the number to raise to power: ";
    cin>>number;
    cout<<"\nEnter the power to raise to: ";
    cin>>power;

    result = pow(number,power);

    cout<<"\n"<< number <<"^"<< power<<" = "<< result;

    return 0;
}

Najpierw dodaj, #include <cmath>a następnie możesz użyć powmetody w swoim kodzie, na przykład:

pow(3.5, 3);

Które 3.5 to podstawa, a 3 to exp

użyj funkcji pow () w bibliotece cmath, tgmath lub math.h.

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
int a,b;
cin >> a >> b;
cout << pow(a,b) << endl; // this calculates a^b

return 0;
}

zwróć uwagę, że jeśli podasz dane wejściowe do potęgi jako dowolny typ danych inny niż long double, wówczas odpowiedź zostanie podwyższona do typu double. to znaczy, że będzie pobierał dane wejściowe i dawał wynik jako podwójny. dla długich podwójnych wejść typem zwracanym jest long double. za zmianę odpowiedzi na int use, int c = (int) pow (a, b)

Pamiętaj jednak, że w przypadku niektórych liczb może to skutkować liczbą mniejszą niż prawidłowa odpowiedź. więc na przykład musisz obliczyć 5 ^ 2, wtedy odpowiedź może zostać zwrócona jako 24,99999999999 na niektórych kompilatorach. po zmianie typu danych na int odpowiedź będzie wynosić 24 zamiast 25 poprawna odpowiedź. Więc zrób to

int c=(int)(pow(a,b)+0.5)

Teraz twoja odpowiedź będzie poprawna. również w przypadku bardzo dużych liczb dane są tracone przy zmianie typu danych double do long int. na przykład piszesz

long long int c=(long long int)(pow(a,b)+0.5);

i podaj dane wejściowe a = 3 i b = 38, to wynikiem będzie 1350851717672992000, podczas gdy poprawna odpowiedź to 1350851717672992089, dzieje się tak, ponieważ funkcja pow () zwraca 1.35085e + 18, która jest promowana do int jako 1350851717672992000. Sugeruję napisanie a niestandardowa funkcja zasilania dla takich scenariuszy, jak: -

long long int __pow (long long int a, long long int b)
{
long long int q=1;
for (long long int i=0;i<=b-1;i++)
{
q=q*a;
}

return q;
}

a potem dzwoniąc do niego, kiedy chcesz,

int main()
{
long long int a,b;
cin >> a >> b;

long long int c=__pow(a,b);
cout << c << endl;

return 0;
}

W przypadku liczb większych niż zakres long long int, użyj biblioteki boost lub łańcuchów.