Comment élever à la puissance des œuvres? Est-il intéressant d'utiliser pow(x, 2)?

Est-il plus efficace de la multiplication que d'élever à la puissance 2 en c++?

Je suis en train de faire finale détaillée des optimisations. Sera le compilateur de traiter
x*x le même que pow(x,2)? Si je me souviens bien, la multiplication a été
mieux, pour certaines raisons, mais peut-être qu'il n'a pas d'importance en c++11.

Grâce

  • Dépend de l'optimiseur (ou de la fonction de mise en œuvre, le cas échéant, prend soin de lui. Regardez les produits de l'assemblée ou de l'évaluer.
  • J'imagine x << 1 est ce qui se passe réellement.
  • x^2 est pas d'élever à la puissance 2!
  • J'espère que le compilateur ne pas traiter x*x le même que x^2 parce que ^ est XOR pas pow.
  • ah oui désolé, je voulais dire pow au lieu de ^
InformationsquelleAutor user2381422 | 2013-05-23
  1. 20

    Si vous êtes à la comparaison de multiplication avec le pow() fonction de la bibliothèque standard, alors oui, la multiplication est certainement plus rapide.

    • oui je voulais dire pow, merci!
    • J'ai besoin d'attendre 5 min à accepter votre réponse 😉
    InformationsquelleAutor John Kugelman
  2. 6

    J'en général, vous ne devriez pas vous inquiéter à propos de pico-optimisations comme ça, sauf si vous avez preuve qu'il s'agit d'un hot-spot (c'est à dire, sauf si vous avez profilé votre code en vertu des scénarios réalistes et ont identifié un certain morceau de code. Aussi garder à l'esprit que vos trucs astucieux peut effectivement causer des performances des régressions dans les nouveaux processeurs, où vos hypothèses ne sont plus valables.

    Algorithmique changements sont où vous pourrez obtenir la plupart de coup pour votre informatique de l'argent. Se concentrer sur cela.

    Bricoler avec les multiplications et faire intelligent bits-hackery... hein pas tellement bang, il y* Parce que la génération actuelle de l'optimisation des compilateurs est vraiment tout à fait excellent à leur travail. Cela ne veut pas dire qu'ils ne peuvent pas être battu. Ils peuvent, mais pas facilement et, probablement, seulement par quelques personnes comme Agner Brouillard.

    * il y a, bien sûr, des exceptions.

    • +1 pour le "Ils peuvent, mais pas facilement et, probablement, seulement par quelques personnes comme Agner le Brouillard." N'est-ce pas que la vérité!
    • Curieusement, la différence entre pow() et la multiplication EST en fait un algorithme de différence. 😉 Examiner si l'OP a demandé la même chose avec un autre exemple et le libellé: "pow(x, 8) exprime mon intention plus clairement que xxxxxxxx. Est de multiplication plus rapide?" On peut l'appeler un pico-optimisation, mais passer de la pow() pour la multiplication est techniquement une algorithmique (+ constante) l'amélioration. (...et par rapport à la naïve séquentielle de la multiplication, "x2 = xx; x4 = x2*x2; reponse = x4*x4;" est aussi un handcoded expansion d'un algorithmiquement amélioration de la puissance entière de la fonction.)
    • La différence peut être algorithmiques sur le plan conceptuel, mais je suis assez sûr que le compilateur comprend ce pow est et ce que la sémantique et donc peut (généralement) de l'optimiser assez bien sur son propre. Donc, sauf si il y a dur la preuve que c'est un point d'accès, ce genre de chose qui devrait être considéré comme un micro-optimisation.
    • Il y a encore deux problèmes: 1.) En prenant cette attitude dans l'ensemble de votre base de code signifie que vous pourriez avoir beaucoup de pow()'s qui doivent être remplacés par des multiplications (plus d'une centaine de semblable omniprésente questions). Les problèmes de performances sont souvent isolés à "quelques points chauds", mais seulement lorsque le programme a été codé dans un habituellement de manière efficace pour commencer. Écrit tout d'une "performance" dernier " point de vue signifie qu'au lieu de quelques points chauds, votre programme peut être constamment lent partout (plus commun que les gens de plus en plus de l'abus et de mal appliquer le "optimisation prématurée" maxime).
    • 2.) Des Questions de ce genre sont importants, parce qu'ils ne sont pas isolés à overanalyzing certains très spécifiques bloc de code. Au lieu de cela, ils sont idiomatiques questions qui permettent aux gens de développer les compétences habituellement code de choses efficacement sur une base cohérente. Développer de bonnes habitudes à l'aide des écrous et des boulons de niveau, peut sauver une tonne de profilage de temps, car le montant de l'effort qu'il faut pour isoler les points chauds (sans parler de corriger omniprésente de la lenteur) dépasse de loin le montant de l'effort qu'il faut pour écrire de base "bloc de construction" code de manière efficace la première fois (une fois que vous avez appris).
    • Je ne suis pas en désaccord avec vous; comme une question de fait, je pense que nous sommes d'accord sur le plan conceptuel, mais d'aborder la question sous des angles légèrement différents. Je pense certainement qu'il faut essayer d'écrire du code efficace pour commencer, et que signifie apprendre ce qui fonctionne et ne pas faire une différence dans que contexte. Mais c'est tout à fait différente de la micro-optimisation, comme vous allez.
    • Aussi méfiez-vous de la foi aveugle dans les compilateurs: Même il y a dix ans, la plupart des gens ont pris les compilateurs effectué des optimisations sur une échelle, ils n'ont toujours pas aujourd'hui. (Au micro-niveau d'optimisation, planification d'instructions encore des avantages de la réorganisation des lignes de code source!) pow() est rarement remplacé avec entier intrinsèques: Habituellement le plein int->float->pow->int est fait, et de prisonniers de guerre ne peut pas être optimisé car fp mathématiques n'est pas associatif. Test rapide: Avec GCC 4.8, pow(i, 2) est aussi rapide que j'ai - je, mais pow(i, 4) est de 115 fois plus lent que jeii - je. Avec Clang 3.3, c'est 337 fois plus lent, car il permet d'optimiser le multiplie mieux.
    • Viens de voir votre commentaire: Micro-optimisation, comme vous allez est brutalement lent/façon improductive de code, surtout si vous avez emporté et écriture illisible peu-se tourner les code (qui ne sera probablement pas aider), ou si vous passez beaucoup de temps à la réorganisation des instructions à l'aide du planificateur de tâches, etc. Il n'est jamais une bonne idée d'écrire illisible "optimisations" avant le profilage, mais si vous êtes à décider entre les deux tout aussi lisible versions de idiomatique code de propagation à travers la base de code, d'investissement au début de la "habituelle processus d'apprentissage" est probablement sage...même si cela signifie la micro-optimisation bossez la première fois autour.

    InformationsquelleAutor Nik Bougalis
  3. 5

    Quand il s'agit de performance, de toujours faire des mesures pour sauvegarder vos hypothèses. Ne faites jamais confiance à la théorie, sauf si vous avez un indice de référence qui prouve que la théorie du droit.

    Aussi, gardez à l'esprit que x ^ 2 ne pas rendement le carré de 2 en C++:

    #include <iostream>

int main()
{
    int x = 4;
    std::cout << (x ^ 2); //Prints 6
}

    Live exemple.

    InformationsquelleAutor Andy Prowl
  4. 2

    La mise en œuvre de pow() implique généralement des logarithmes, de multiplication et de expononentiaton, donc il va CERTAINEMENT prendre plus de temps qu'une simple multiplication. Plus moderne haut de gamme des processeurs peuvent faire la multiplication dans un couple de clockcycles pour les valeurs entières, et une douzaine de cycles de virgule flottante de se multiplier. l'exponentiation est fait comme un complexe (microcoded) instructions qui prend quelques dizaines de cycles ou plus, ou comme une série de multiplications et d'additions (généralement avec une alternance de nombres positifs et négatifs, mais pas certain). L'Exponentiation est un processus similaire.

    Sur le bas de la fourchette des processeurs (par exemple, le BRAS ou plus des processeurs x86), les résultats sont encore pire. Des centaines de cycles dans une opération de virgule flottante, ou dans certains processeurs, même les calculs en virgule flottante d'un certain nombre d'opérations sur entiers que de suivre les mêmes étapes que le flotteur instructions sur plusieurs processeurs avancés, de sorte que le temps pris pour pow() pourrait être des milliers de cycles, contre une dizaine pour une multiplication.

    Quel que soit le choix, c'est toute la calcul sera beaucoup plus qu'une simple multiplication.

    La pow() fonction est utile lorsque l'exposant est soit grand ou pas un entier. Même pour un nombre relativement grand des exposants, vous pouvez faire le calcul par la quadrature ou de cubage à plusieurs reprises, et il sera plus rapide que pow().

    Bien sûr, parfois, le compilateur peut être en mesure de comprendre ce que vous voulez faire, et de le faire comme une suite de multiplications comme une optimisation. Mais je ne voudrais pas compter sur cela.

    Enfin, comme TOUJOURS, pour des questions de performances: Si c'est vraiment important de votre code, puis de mesurer votre compilateur peut être plus intelligent que vous mince. Si la performance n'est pas important, puis effectuer le calcul le rend le code plus lisible.

    InformationsquelleAutor Mats Petersson
  5. 1

    pow est une fonction de la bibliothèque, pas un opérateur. À moins que le compilateur est capable d'optimiser l'appel (qui a légitimement le faire en tirant parti de ses connaissances sur le comportement des fonctions de bibliothèque standard), l'appel de pow() va imposer la charge d'un appel de fonction et de tous les trucs supplémentaires le pow() fonction de a à faire.

    Le deuxième argument de pow() ne doit pas être un nombre entier; par exemple pow(x, 1.0/3.0) vous donnera une approximation de la racine cubique de x. C'est un assez calculs sophistiqués. Il pourrait tomber en arrière, à plusieurs reprises, la multiplication si le second argument est une petite valeur intégrale, mais il faut ensuite vérifier qu'au moment de l'exécution.

    Si le numéro que vous voulez carré est un nombre entier, pow impliquera de le convertir à double, puis en convertissant le résultat d'un type entier, qui est relativement coûteux et peut causer de petites erreurs d'arrondi.

    À l'aide de x * x est très susceptible d'être plus rapide et plus fiable que pow(x, 2), et c'est plus simple. (Dans la plupart des contextes, la simplicité et la fiabilité sont plus importantes que la vitesse.)

    InformationsquelleAutor Keith Thompson
  6. 0

    C/C++ n'est pas un natif de la "puissance" de l'opérateur. ^ est le bit à bit ou exclusif (xor). Ainsi dit, le pow fonction est probablement ce que vous cherchez.

    En fait, pour la quadrature d'un nombre entier, x*x est le plus immédiat, et certains compilateur peut optimiser le fonctionnement de la machine si elle est disponible.

    InformationsquelleAutor Stefano Sanfilippo
  7. 0

    Vous devriez lire le lien suivant
    Pourquoi ne pas GCC optimiser un*un*un*un*un*un (a*a*a)*(a*a*a)?

    pow(x,2) qui est la plus susceptible d'être converti xx. Toutefois, la hausse des puissances comme les pow(x,4) ne peut pas être fait de manière aussi optimale que possible. Par exemple pow(x,4) peut être fait en 3 multiplications xxxx ou dans les deux (xx)(x*x) en fonction de la façon dont strict vous avez besoin de virgule flottante, la définition (par défaut je pense qu'il va utiliser 3 multiplications.

    Il serait intéressant de voir ce que par exemple pow(x*x,2) produit avec et sans -ffast-math.

    InformationsquelleAutor
  8. 0

    vous devriez regarder dans boost.les mathématiques de la fonction pow modèle. il prend l'exposant en tant que paramètre de modèle et de calculer automatiquement, par exemple, pow<4>(x) (x*x)*(x*x).

    http://www.boost.org/doc/libs/1_53_0/libs/math/doc/sf_and_dist/html/math_toolkit/special/powers/ct_pow.html

    InformationsquelleAutor mariomulansky