Hallo,
nutzt man in c++ immer noch die c Funktion pow aus math.h zum potenzieren?

Bestimmt, aber es gibt auch cmath.

Ich habe 2 Integerzahle: i und j.

Ich möchte nun i multiplizieren mit 5^4 und anschließend mit j vergleichen.

bool foocompare(int i, int j, float a, float b)
{
  return i * std::pow(a,b) == j;
}

int i,j;
i*=pow(5,4);
if(i <Vergleichsoperator> j)
{
    // Mache irgendwas
}

Der Vergleichoperator ist ein Operator wie <, >, >=, <=, ==, !=
Allerdings ist anzumerken, dass der Datentyp int für solche Operationen nicht ganz so gut geeignet ist wie double. Sollte das Ergebnis von pow() eine Kommazahl sein, gingen die Nachkommatellen verloren, da int nur Ganzzahlen speichert.

MfG, Jochen

(i==(5*std::pow(5,1)))

Die Potenz steht übrigens schon zur Compilezeit fest. Aber pow will keine Integer als Argumente.

Das Problem ist, bei mir meckert der Compiler schon hier:

(i==(5*std::pow(5,1)))

Die Potenz steht übrigens schon zur Compilezeit fest. Aber pow will keine Integer als Argumente.

if vergessen?

Zur Not kannst du ja noch "manuell" casten:

if(i==(5*std::pow((double)5,(double)1))){/*...*/}

MfG, Jochen

int my_pow(int base, unsigned int exp)
{
  if(exp == 0)
    return 1;

  int ret_val = 1;

  while(exp > 1)
  {
    if(exp%1)
    {
      --exp;
      ret_val *= base;
      continue;
    }

    base *= base;
    exp /= 2;
  };

  return ret_val * base;
}

bb

int my_pow(int base, unsigned int exp)
{
    if(exp == 0) return 1;
    int ret_val = 1;

    for(int c=1;c<=exp;c++)
    {
        ret_val*=base;
    }

    return ret_val;
}

MfG, Jochen

Das geht aber noch einfacher mit einer for-Schleife:

vom code her kürzer, aber von der laufzeit länger

bb

MfG, Jochen.

vom code her kürzer, aber von der laufzeit länger

Ach, das wird der Compiler schon optimieren...

unskilled schrieb:

vom code her kürzer, aber von der laufzeit länger

Ach, das wird der Compiler schon optimieren...

aber ja - wenn die zahlen eh compile-zeit-konstanten sind, machts absolut keinen unterschied

Kann ich nicht auch einfach den Compiler die Zahl berechnen lassen? Denn es ist eh eine Konstante.

Das geht mit Template-Metaprogrammierung. In etwa so:

template<int base, unsigned int exp>
struct pow
{
	static const int value = base * pow<base, exp-1>::value;
};

template<int base>
struct pow<base, 0>
{
	static const int value = 1;
};

// ...

cout << pow<5,4>::value << endl;    // Ausgabe: 625

Dabei gehen aber als "Parameter" wirklich nur zur Complilezeit auswertbare Integer-Konstanten.

vom code her kürzer, aber von der laufzeit länger

Hier, hab ich gerade Programmiert:

#include <iostream>
#include <windows.h>
using namespace std;

int my_pow1(int base,int exp)
{
  if(exp == 0)
    return 1;

  int ret_val = 1;

  while(exp > 1)
  {
    if(exp%1)
    {
      --exp;
      ret_val *= base;
      continue;
    }

    base *= base;
    exp /= 2;
  };

  return ret_val * base;
} 

int my_pow2(int base,int exp)
{
    if(exp == 0) return 1;
    int ret_val = 1;

    for(int c=1;c<=exp;c++)
    {
        ret_val*=base;
    }

    return ret_val;
} 

int main()
{
	int c,d,e;
	c=50000000;
	d=4;
	e=5;
	DWORD dwStartTime = clock();
	for(int i=0;i<c;i++)my_pow1(d,e);
	DWORD dwEndTime = clock();
	cout << "Zeit 1: " << dwEndTime-dwStartTime << " ms" << endl;
	dwStartTime = clock();
	for(int i=0;i<c;i++)my_pow2(d,e);
	dwEndTime = clock();
	cout << "Zeit 2: " << dwEndTime-dwStartTime << " ms" << endl;
	getchar();
	return 0;
}

Ausgabe:

Zeit 1: 640 ms
Zeit 2: 358 ms

Laut Ausgabe ist meine Version schneller

Außerdem: Optimierungen ausgeschaltet? Bei mir ergeben nämlich beide Null weil eine Schleife deiner Form einfach wegoptimiert wird. Und wenn ich dafür sorge, dass die Schleife nicht wegoptimiert wird, dann wird die Funktion zu 1024 (bzw. zu 256) wegoptimiert. Erst wenn ich alles von der Benutzereingabe abhängig mache, bekomme ich ein brauchbares Ergebnis:

int main()
{
    long int c,d,e;
    cin >> c;
    cin >> d;
    cin >> e;
    int counter=0;
    for(long int i=0;i<c;i++) counter+=my_pow1(d,e);
    // for(long int i=0;i<c;i++) counter+=my_pow2(d,e);
    cout<<counter<<endl;
    return 0;
}

Dann braucht die (falsche) Version von my_pow1 gute 14.5 s für 1 Gigadurchlauf. my_pow2 braucht dafür gute 12 s.

entweder if(exp&1) oder if(exp%2)
ja gut - zur geschwindigkeit:
bei kleinen exponenten ist nat. deine version schneller
bei höheren sollte meine schneller sein

bb