Le moyen le plus efficace de la mise en œuvre de fonction pow() en virgule flottante

Oui, le Soleil peut (Oracle maintenant, je suppose):

fdlibm, la "librement distribuable de la bibliothèque math", a sqrt et pow, ainsi que de nombreuses autres fonctions mathématiques.

Ils sont assez high-tech implémentations, bien que, et bien sûr rien n'est jamais le "plus efficace" de la mise en œuvre de quelque chose comme cela. Êtes-vous après le code source, ou êtes-vous plus vraiment à la recherche pour pow et sqrt, mais en réalité la recherche d'une éducation en floating-point des algorithmes de programmation?

OriginalL'auteur Steve Jessop

Notez que si votre jeu d'instruction est une instruction pour la racine carrée ou la puissance, vous allez être beaucoup mieux l'aide de cette. Le x87 instructions en virgule flottante, par exemple, ont une instruction fsqrt, et le SSE2 ajouts comprennent une autre instruction sqrtsd, qui sont probablement va être beaucoup plus rapide que la plupart des solutions écrit en C. En effet, au moins gcc utilise les deux instructions lors de la compilation a lieu sur une machine x86.

De pouvoir, cependant, les choses deviennent un peu glauque. Il y a une instruction dans le x87 instruction à virgule flottante qui peut être utilisé pour calculer n*log2(n), à savoir fyl2x. Une autre instruction, fldl2e, magasins log2(e) en virgule flottante, la pile. Vous pourriez vouloir donner à ces un look.

Vous pouvez également jeter un oeil à la façon dont chaque C des bibliothèques de le faire. dietlibc, par exemple, utilise simplement fsqrt:

sqrt:
    fldl 4(%esp)
    fsqrt
    ret

glibc utilise du Soleil de mise en œuvre pour les machines sur lesquelles un matériel de la racine carrée d'instruction n'est pas disponible (sous sysdeps/ieee754/flt-32/e-sqrtf.c), et utilise fsqrt sur le jeu d'instructions x86 (bien que gcc peut être invité à utiliser à la place la sqrtsd l'instruction.)

OriginalL'auteur susmits

double ipow(int base, int exp)
{

bool flag=0;
if(exp<0) {flag=1;exp*=-1;}
int result = 1;
while (exp)
{
    if (exp & 1)
        result *= base;
    exp >>= 1;
    base *= base;
}
if(flag==0)
return result;
else
return (1.0/result);
}
//most suitable way to implement power function for integer to power integer

OriginalL'auteur Shivendra

Le moyen le plus rapide, je pense, de faire un pow() serait le long de ces lignes (remarque, c'est assez compliqué):

//raise x^y
double pow(double x, int y) {
    int power;
    map<int, double> powers;
    for (power = 1; power < y; power *= 2, x *= x)
        powers.insert(power, x);

    while (power > y) {
        //figure out how to get there
        map<int, double>::iterator p = powers.lower_bound(power - y);
        //p is an iterator that points to the biggest power we have that doesn't go over power - y
        power -= p->first;
        x /= p->second;
    }

    return x;
}

Je n'ai aucune idée sur la façon de mettre en œuvre une virgule pouvoir. Ma meilleure supposition serait d'utiliser les logarithmes.

Edit: je suis d'essayer logarithmique solution (basé sur y), par opposition à un linéaire de la solution que vous proposez. Permettez-moi de faire ce travail et de le modifier, parce que je sais que ça fonctionne.

Edit 2: Héhé, mon mauvais. d'alimentation *= 2 au lieu de pouvoir++

OriginalL'auteur hehewaffles