x^y in c

[anfänger (Gast)]

hi ich habe eine Frage zu C, eine absolute Anfängerfrage..

ich will in C x^y ausrechnen.

meine idee
int x;
int y;
int erg;
erg = pow(x,y);

und schon sollte nach alles was ich gefunden habe in erg das Ergebinss
sein. als Testwerte habe ich x=2 und y=3 genommen so dass erg auch ein
Int sein sollte.
Ist pow die richtige Funktion? Irgendwie steh ich voll auf der Leitung,
so dass mir ohne hilfe wohl kein Licht aufgeht...

Irgendwelche Anregungen eurerseits wären mir eine Hilfe.

[Rahul (Gast)]

<math.h>

[Marcus (Gast)]

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!

[Michael W. (mictronics)]

Warum liest Du nicht mal in einem Tutorial nach?

http://crasseux.com/books/ctutorial/Mathematical-functions.html#Mathematical%20functions

[Profi (Gast)]

#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!

[yalu (Gast)]

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.

[Rahul (Gast)]

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...