c++ upphöjt i

pow(), finns i <cmath>

[edit] .. såg inte att du skrev utan något matte bibliotek.

Att multiplicera med 2 flera gånger kan du göra väldigt snabbt genom shift-left operationen.
Om du på det sättet lyckas bryta ner din bas(b) till 2 så kan du skriva en relativt snabb metod för att räkna ut b^e

x^y = e^(ln(x^y)) = e^(y * ln x) alt 10 ^ (y * log x)

jag förutsätter att c++ har nån inbyggd funktion för antingen e och ln eller 10^ och log

edit: vände på x o y

^ som i xor? Jag tror det är det som c++ använder den operatorn till.

ne, jag kan inte c++, tänkte mig ^ som upphöjt i.

Hm... Med roten ur kan du ju höja upp i en halv, en fjärdedel, en åttondel osv.

Just 3.1 är ju ett bra svårt tal. Men om du kan tillåta närmevärden så kan jag fulhacka mig till en lösning.

Sqrt betyder upphöjt i 1/2, right? Så om man tänker sig att 3.1 =~ 3.09375 = 99/32 så är 2^31 =~ sqrt(sqrt(sqrt(sqrt(sqrt(2^99))))). Svaret är rätt med en decimals noggrannhet.

Man kan såklart göra det ännu mer extremt fast det blir nog rätt svårt att automatisera det. Det bästa jag kan komma på annars är nog nåt taylorpolynom, men det är ju rätt svår matte.

använd pow. den är så standard det kan bli.

z=x^y <=> z=pow(x,y);

Å andra sidan har pow krånglat åt mig. Kommer inte riktigt ihåg vad jag skulle göra, men den kunde det inte iaf.

Jag skulle typ göra det i en loop. Orkar inte tänka efter så noga men jag tänker mig att det skulle se ut ungefär såhära.

for (int loop=0; loop < y; y++) {
x+x*2
}

EDIT:
Tänker fel... ska prova rätta.
Äääsch, jag är ju helt slut i huvet ikväll.

hm, nu är inte jag helt vaken. men nått sånt här kanske?

int power(int x, int y)
{
   if (y == 0) return 1;
   return x*power(x, --y);
}

Edit: nej, oj. missade att du ville höja upp med ett decimaltal. får skylla på min höga feber.

Om du kombinerar Delights formel för att göra om den till e^z kan du approximera den med e^x = x^0/0! + x^1/1! + .. + x^n/n!
http://mathworld.wolfram.com/ExponentialFunction.html
Dock har jag inte funderat på hur stort n behöver vara för att det ska bli en bra approximation...

Eller så kan man skriva om e^x till cosh(x)+sinh(x), fast gmpxx har inte trigonometriska funktioner heller om jag såg rätt.

Edit: Med approximeringen behövde n vara ~25 för att den skulle ge samma resultat som pythons inbyggda power funktion ger på 2^3.1. Dock säger det givetvis inget hur det är i talen som du tänker räkna på

Att upphöja till ett heltal är lätt att göra. Att upphöja till 1/2^n kan du göra genom att använda sqrt flera gånger. Så skriv exponenten på binär form och dela upp i termer som du beräknar var för sig.

Exempel: 15.6875 = 15+1/2+1/8+1/16, så
a^15.6875 = a^15 * a^(1/2) * a^(1/8) * a^(1/16) = a^15 * sqrt(a) * sqrt(sqrt(sqrt(a))) * sqrt(sqrt(sqrt(sqrt(a)))

Skulle man inte förresten kunna lägga in en stor logaritmtabell och använda?

ln(2^3.1) = 3.1*ln 2

Man låter datorn slå upp ln 2, och får 0.6931... Då blir 3.1*ln2 = 2.1488.

Sen låter man datorn slå baklänges i tabellen och man ser vilket tal som 2.1488 är logaritmen av - dvs vad e^2.1488 är. Då har man sitt svar, nämligen 8.57.

Programmet blir förstås ganska stort (nån MB), men det bör å andra sidan gå fort att exekvera. Nackdelen är att man ändå måste ha mattebiblioteket till hands när man skapar tabellen.

Lite som att gå över ån efter vatten...
För övrigt tycker jag knappt att man kan kalla math.h för ett mattebibliotek. Den är faktiskt standard i alla kompilatorer...
#include <math.h>
double z=pow(x,y); är vad jag föreslår.

vad jag föreslår är att du läser alla post innan du postar.

Alltså, hela tråden handlar ju om att gå över ån efter vatten. Nu har vi kommit på tre olika sätt att göra det på: McLaurinutveckling, logaritmtabell och upprepad kvadratrotsanvändning.

Kan man använda mattebibliotek vore det förstås överlägset enklast.