x^y in c

<math.h>

Hallo,

ja und jetzt? Kommt ne Fehlermeldung oder ...?

Marcus

P.S

auch ne Möglichkeit:
<code>
int i;
int erg=1;
for (i=1;i<=y;i++){
erg*=x;
}
<\code>

Keine Wurzel möglich!

#include <math.h>
Damit linkt er dir die Float-Libs mit ein, kann ziemlich viel
Speicher kosten.

Damit es klarer wird, verwende casting:
erg=(integer)(pow(float)x,(float)y));

Dürfte der Compiler zwar automatisch machen, aber dann wir gleich beim
Lesen des Codes offensichtlich, was er macht.

Wenn Du nur int als Eingangsvariablen hast und Du den Wertebereich
eingrenzen kannst z.B. auf 16 oder 32 bit integer, kannst Du auch eine
For-Schleife mit Multiplikationen machen:
erg=1;
for(i=1;i<y;i++){erg*=x;}

ungeprüfter Code - nur als Denkanstoß zu verstehen!

Wie Profi schon erwähnte, ist es etwas übertrieben, wegen einer
Integer-Potenz große Teile der Floatingpoint-Bibliothek mit zu
schleppen.

Für Exponenten bis 3 schreibe ich das Produkt meist aus:

y = x * x;
y = x  x  x;

Zweierpotenzen (2^y) kann man auch durch Shift-Operationen darstellen:

1 << y;

Für größere oder zur Compile-Zeit nicht bekannte Exponenten bietet sich
die Schleifenlösung von Marcus bzw. Profi an. Insbesondere bei größeren
Exponenten reduziert folgende Funktion die Anzahl der benötigten
Multiplikationen (maximal 2*ld(y+1)-1 statt y):

|  int ipow(int b, int e) {
|    int p = 1;
|
|    for(;;) {
|      if(e & 1)
|        p *= b;
|      e >>= 1;
|      if(e == 0)
|        break;
|      b *= b;
|    }
|    return p;
|  }
|
|  /* ... */
|    erg = ipow(x, y);


So werden bspw. für 2^28 nur 7 statt 28 Multiplikationen benötigt, was
bei Prozessoren ohne Hardware-Multiplizierer schon einiges an
Geschwindigkeit bringt.

Zu meiner "Verteidigung" wegen "<math.h>":
SO wie ich den Ursprungstread verstanden habe, hat "anfänger" nach
der Potenzfunktion gefragt. Ich war der Meinung, dass man die in der
math.h findet.
Hätte ich Bedarf daran, würde ich sie mir auch selber programmieren...