std:: sqrt (std::valarray)

Pour chaque élément dans va calcule la racine carrée de la valeur de l'élément.

Paramètres

Valeur de retour

Tableau de valeurs contenant les racines carrées des valeurs dans va .

Notes

La fonction non qualifiée ( sqrt ) est utilisée pour effectuer le calcul. Si une telle fonction n'est pas disponible, std:: sqrt est utilisée en raison de la recherche dépendante des arguments .

La fonction peut être implémentée avec un type de retour différent de std::valarray . Dans ce cas, le type de remplacement possède les propriétés suivantes :

• Toutes const les fonctions membres de std::valarray sont fournies.
• std::valarray , std::slice_array , std::gslice_array , std::mask_array et std::indirect_array peuvent être construits à partir du type de remplacement.
• Pour chaque fonction prenant un const std:: valarray < T > & sauf begin() et end() (depuis C++11) , des fonctions identiques prenant les types de remplacement doivent être ajoutées ;
• Pour chaque fonction prenant deux const std:: valarray < T > & arguments, des fonctions identiques prenant chaque combinaison de const std:: valarray < T > & et types de remplacement doivent être ajoutées.
• Le type de retour n'ajoute pas plus de deux niveaux d'imbrication de templates par rapport au type d'argument le plus profondément imbriqué.

Implémentation possible

template<class T>
valarray<T> sqrt(const valarray<T>& va)
{
    valarray<T> other = va;
    for (T& i : other)
        i = sqrt(i);
    return other; // un objet proxy peut être retourné
}

Exemple

#include <cassert>
#include <complex>
#include <cstddef>
#include <iostream>
#include <numbers>
#include <valarray>
using CD = std::complex<double>;
using VA = std::valarray<CD>;
// retourne toutes les n racines complexes d'un nombre complexe x donné
VA root(CD x, unsigned n)
{
    const double mag = std::pow(std::abs(x), 1.0 / n);
    const double step = 2.0 * std::numbers::pi / n;
    double phase = std::arg(x) / n;
    VA v(n);
    for (std::size_t i{}; i != n; ++i, phase += step)
        v[i] = std::polar(mag, phase);
    return v;
}
// retourne n racines complexes de chaque élément dans v ; dans le valarray de sortie d'abord
// passe la séquence de toutes les n racines de v[0], puis toutes les n racines de v[1], etc.
VA root(VA v, unsigned n)
{
    VA o(v.size() * n);
    VA t(n);
    for (std::size_t i = 0; i != v.size(); ++i)
    {
        t = root(v[i], n);
        for (unsigned j = 0; j != n; ++j)
            o[n * i + j] = t[j];
    }
    return o;
}
// comparateur de nombres à virgule flottante qui tolère une erreur d'arrondi donnée
inline bool is_equ(CD x, CD y, double tolerance = 0.000'000'001)
{
    return std::abs(std::abs(x) - std::abs(y)) < tolerance;
}
int main()
{
    // coefficients d'entrée pour le polynôme x³ + p·x + q
    const VA p{1, 2, 3, 4, 5, 6, 7, 8};
    const VA q{1, 2, 3, 4, 5, 6, 7, 8};
    // le solveur
    const VA d = std::sqrt(std::pow(q / 2, 2) + std::pow(p / 3, 3));
    const VA u = root(-q / 2 + d, 3);
    const VA n = root(-q / 2 - d, 3);
    // allouer de la mémoire pour les racines : 3 * nombre de polynômes cubiques d'entrée
    VA x[3];
    for (std::size_t t = 0; t != 3; ++t)
        x[t].resize(p.size());
    auto is_proper_root = [](CD a, CD b, CD p) { return is_equ(a * b + p / 3.0, 0.0); };
    // éliminer 6 des 9 racines générées, ne laissant que 3 racines appropriées (par polynôme)
    for (std::size_t i = 0; i != p.size(); ++i)
        for (std::size_t j = 0, r = 0; j != 3; ++j)
            for (std::size_t k = 0; k != 3; ++k)
                if (is_proper_root(u[3 * i + j], n[3 * i + k], p[i]))
                    x[r++][i] = u[3 * i + j] + n[3 * i + k];
    std::cout << "Équation cubique déprimée :   Racine 1 : \t\t Racine 2 : \t\t Racine 3 :\n";
    for (std::size_t i = 0; i != p.size(); ++i)
    {
        std::cout << "x³ + " << p[i] << "·x + " << q[i] << " = 0  "
                  << std::fixed << x[0][i] << "  " << x[1][i] << "  " << x[2][i]
                  << std::defaultfloat << '\n';
        assert(is_equ(std::pow(x[0][i], 3) + x[0][i] * p[i] + q[i], 0.0));
        assert(is_equ(std::pow(x[1][i], 3) + x[1][i] * p[i] + q[i], 0.0));
        assert(is_equ(std::pow(x[2][i], 3) + x[2][i] * p[i] + q[i], 0.0));
    }
}

Équation cubique dépressive:   Racine 1:              Racine 2:                 Racine 3:
x³ + (1,0)·x + (1,0) = 0  (-0.682328,0.000000)  (0.341164,1.161541)  (0.341164,-1.161541)
x³ + (2,0)·x + (2,0) = 0  (-0.770917,0.000000)  (0.385458,1.563885)  (0.385458,-1.563885)
x³ + (3,0)·x + (3,0) = 0  (-0.817732,0.000000)  (0.408866,1.871233)  (0.408866,-1.871233)
x³ + (4,0)·x + (4,0) = 0  (-0.847708,0.000000)  (0.423854,2.130483)  (0.423854,-2.130483)
x³ + (5,0)·x + (5,0) = 0  (-0.868830,0.000000)  (0.434415,2.359269)  (0.434415,-2.359269)
x³ + (6,0)·x + (6,0) = 0  (-0.884622,0.000000)  (0.442311,2.566499)  (0.442311,-2.566499)
x³ + (7,0)·x + (7,0) = 0  (-0.896922,0.000000)  (0.448461,2.757418)  (0.448461,-2.757418)
x³ + (8,0)·x + (8,0) = 0  (-0.906795,0.000000)  (0.453398,2.935423)  (0.453398,-2.935423)

Voir aussi