Utiliser les fonctions exponentielles de STL en C++

1. Utilisez la fonction std::exp pour calculer les puissances du nombre d’Euler
2. Utilisez la fonction std::exp2 pour calculer les puissances de deux
3. Utilisez la fonction std::pow pour calculer les puissances du nombre donné
4. Utilisez la fonction std::log pour calculer le logarithme népérien du nombre donné

Cet article présentera les fonctions STL pour le calcul de l’exponentielle en C++.

Utilisez la fonction std::exp pour calculer les puissances du nombre d’Euler

La fonction std::exp fait partie de l’en-tête <cmath> avec de nombreuses fonctions mathématiques courantes. Le premier calcule le nombre d’Euler élevé à la puissance donnée, qui est passé comme seul argument.

La fonction std::exp a plusieurs surcharges pour float, double, long double et même le type intégral, mais cette dernière renvoie toujours une valeur à virgule flottante double. Si le débordement se produit, l’une des valeurs suivantes est retournée +HUGE_VAL, +HUGE_VALF, ou +HUGE_VALL.

Notez qu’il existe des valeurs de retour spéciales pour plusieurs arguments comme +-0, +-INFINITY et NaN. Tous ces cas sont illustrés dans l’exemple de code suivant.

#include <cmath>
#include <iomanip>
#include <iostream>

using std::cout;
using std::endl;

int main() {
  cout << "exp(1) = e¹ = " << std::setprecision(16) << std::exp(1) << '\n'
       << "exp(10)  = " << std::exp(10) << '\n'
       << "exp(100) = " << std::exp(100) << '\n';

  cout << "exp(-0) = " << std::exp(-0.0) << '\n'
       << "exp(+Inf) = " << std::exp(+INFINITY) << '\n'
       << "exp(NaN) = " << std::exp(NAN) << '\n'
       << "exp(-Inf) = " << std::exp(-INFINITY) << '\n';

  return EXIT_SUCCESS;
}

Production:

exp(1) = e¹ = 2.718281828459045
exp(10)  = 22026.46579480672
exp(100) = 2.688117141816136e+43
exp(-0) = 1
exp(+Inf) = inf
exp(NaN) = nan
exp(-Inf) = 0

Utilisez la fonction std::exp2 pour calculer les puissances de deux

D’autre part, nous avons la fonction std::exp2 pour calculer les puissances de deux. Les surcharges de cette fonction renvoient des valeurs à virgule flottante mais peuvent également accepter des types intégraux. Notez que std::exp2 a des valeurs spéciales similaires pour des arguments tels que +-0, +-INFINITY et NaN.

#include <cmath>
#include <iomanip>
#include <iostream>

using std::cout;
using std::endl;

int main() {
  cout << "exp2(4) = " << std::exp2(4) << '\n'
       << "exp2(0.5) = " << std::exp2(0.5) << '\n'
       << "exp2(10) = " << std::exp2(10) << '\n';

  cout << "exp2(-0) = " << std::exp2(-0.0) << '\n'
       << "exp2(+Inf) = " << std::exp2(+INFINITY) << '\n'
       << "exp2(NaN) = " << std::exp2(NAN) << '\n'
       << "exp2(-Inf) = " << std::exp2(-INFINITY) << '\n';

  return EXIT_SUCCESS;
}

Production:

exp2(4) = 16
exp2(0.5) = 1.41421
exp2(10) = 1024
exp2(-0) = 1
exp2(+Inf) = inf
exp2(NaN) = nan
exp2(-Inf) = 0

Utilisez la fonction std::pow pour calculer les puissances du nombre donné

La fonction std::pow permet de calculer la valeur du nombre élevé à la puissance donnée. Le nombre de base et la valeur de puissance sont spécifiés comme premier et deuxième arguments, respectivement.

std::pow a plusieurs surcharges pour les types à virgule flottante ainsi que les valeurs intégrales, mais ces dernières sont converties en type double et peuvent même être promues en long double si l’un des arguments est également long double. Notez également que std::pow ne peut pas être utilisé pour calculer la racine d’un nombre négatif.

#include <cmath>
#include <iomanip>
#include <iostream>

using std::cout;
using std::endl;

int main() {
  cout << "pow(2, 10) = " << std::pow(2, 10) << '\n'
       << "pow(10, 0.5) = " << std::pow(10, 0.5) << '\n'
       << "pow(-25, -2) = " << std::pow(-25, -2) << '\n';

  cout << "pow(-1, NAN) = " << std::pow(-1, NAN) << '\n'
       << "pow(+1, NAN) = " << std::pow(+1, NAN) << '\n'
       << "pow(INFINITY, 2) = " << std::pow(INFINITY, 2) << '\n'
       << "pow(INFINITY, -1) = " << std::pow(INFINITY, -1) << '\n';

  return EXIT_SUCCESS;
}

Production:

pow(2, 10) = 1024
pow(10, 0.5) = 3.16228
pow(-25, -2) = 0.0016
pow(-1, NAN) = nan
pow(+1, NAN) = 1
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0

Utilisez la fonction std::log pour calculer le logarithme népérien du nombre donné

La famille de fonctions std::log est également fournie dans <cmath> pour calculer divers logarithmes pour les valeurs numériques données. La fonction std::log calcule le logarithme népérien, et similaire aux fonctions précédentes, elle a plusieurs surcharges pour les types à virgule flottante et intégrale.

#include <cmath>
#include <iomanip>
#include <iostream>

using std::cout;
using std::endl;

int main() {
  cout << "log(10) = " << std::log(10) << '\n'
       << "log(100) = " << std::log(100) << '\n';

  cout << "log(1) = " << std::log(1) << '\n'
       << "log(+Inf) = " << std::log(INFINITY) << '\n';

  return EXIT_SUCCESS;
}

Production:

log(10) = 2.30259
log(100) = 4.60517
log(1) = 0
log(+Inf) = inf