IntPower

Kolumbus

Hallo Gemeinschaft,

ich wollte gern im Programm die Integerzahlen x und y potenzieren, sprich: "x hoch y" rechnen.
Über die Forumsuche im VCL-Forum habe ich einen Hinweis auf die Funktion Power() gefunden.
Dann habe ich in die Hilfe von meinem BCB3 bei Index "Power" eingegeben und einen Eintrag dazu gefunden. Von diesem Eintrag aus bin ich über "siehe auch" zu IntPower() gelangt, was scheinbar meinen Zweck erfüllt. Als einzubindende Unit ist "Math" angegeben.
Also habe ich die math.h eingebunden ( #include <math> ) und geschrieben:

int x=2, y=3, Ergebnis=1;
Ergebnis*= IntPower(x, y);

woraufhin mein Compiler meldet, er kenne die Funktion IntPower() nicht. Auch die Funktion Power() kennt er nicht.
Dann hab ich aus Borland/Builder3/include die math.h geöffnet und eine Funktion ldxep() entdeckt. Der Compiler meckerte bei deren Verwendung nun zwar nicht mehr, aber ein richtiges Ergebnis bekam ich auch nicht...
Also wieder ins Forum und pow() gefunden, ausprobiert, nun stimmt das Ergebnis.

Fragen: Was habe ich falsch gemacht? Habe ich die Hilfe falsch interpretiert? Oder was ist verkehrt gelaufen? Das Ganze verwirrt mich mal wieder sehr!

Hier nochmal das Zitat aus meiner BCB3-Hilfe:

Die Funktion IntPower errechnet die Potenz aus einer Basis und einem ganzzahligen Exponenten.

Unit

Math

Kategorie

Arithmetik

extern PACKAGE Extended __fastcall IntPower(Extended Base, int Exponent);

Beschreibung

IntPower gibt das Ergebnis von Basis (Parameter Base) hoch Exponent zurück.

Braunstein

Um IntPower verwenden zu können musst du Math.hpp einbinden. Mit #include <math> bindest du den Standardheader ein der diese Funktion natürlich nicht kennt (kein C++Standard).

Bist dir sicher? Das doch VCL und kein C++

Braunstein

IntPower ist ja auch VCL.

Wohl mein Fehler, falsch gelesen, da ich davon ausging das math.hpp == <math> wäre. Scheint wohl nicht so zu sein.

Kolumbus

Danke Braunstein, mit #include <math.hpp> funktioniert auch IntPower.

Was ist denn besser, A:math.h und pow nutzen oder B:math.hpp und IntPower nutzen?
Gibts da ne Faustregel? Ich würde denken, letzteres ist besser, weil ich es in der Hilfe nachlesen kann und es für VCL gemacht ist!?!

akari

Hallo

Wenn man es richtig macht

#include <cmath>
...
std::pow(...)

dann ist es am besten, denn das ist konform zum C++ Standard.

bis bald
akari

Braunstein

Wenn es um Geschwindigkeit geht sollte IntPower besser sein. Da hier aber nur zwei ints im Spiel sind kann man die Funktion auch schnell selbst schreiben.

Der Vollständigkeit halber kannst Du Dir auch des Potenzberechnungs-Metaprogrammierungsbeispiel bei wikipedia ansehen (wenn's ganz schnell gehen soll)

http://de.wikipedia.org/wiki/C-Plusplus-Metaprogrammierung

Schurke

mach doch mal

#include <math.h>
...
int x,y;
...
x = (int)pow(x,y);
...

akari

Hallo

@Schurke : Und was von dem was du hier gepostest hast wurde noch nicht von anderen gepostet?

bis bald
akari

Braunstein

zudem es noch falsch ist. Richtig heißt es

#include <cmath>

Kolumbus

Jetzt verwirrt ihr mich schon wieder:

pow funktioniert bei mir mit #include <math>

IntPower funktioniert bei mir mit #include <Math.hpp>

@witte_: Das soll Geschwindigkeit bringen, richtig? Ich glaube für Templates bin ich noch nicht bereit...

Braunstein

Das Beispiel für Template-Metaprogrammierung aus dem Link bringt dir nur was, wenn beide Parameter zur Compilezeit feststehen. Da kannst du dir das auch selber vorher ausrechnen und eintragen. Wenn nur der Exponent feststeht kann man sowas machen

template<int exp>
int ipow(int val)
{
  for( int i=0; i<exp; ++i)
    val *= val;
  return val;
}

Ein guter Compiler merkt, dass das Ende der Schleife zur Compilezeit feststeht und optimiert sie dann raus (loop unrolling). Auch das kann man natürlich mit Metaprogrammierung selber machen.