std::sqrt(std::valarray)
De es.cppreference.net
| Definido en el encabezado <valarray>
|
||
template< class T >
valarray<T> sqrt( const valarray<T>& va );
|
||
Para cada elemento en va calcula la raíz cuadrada del valor del elemento.
Parámetros
| va | - | array de valores al que aplicar la operación |
Valor de retorno
Array de valores que contiene las raíces cuadradas de los valores en va .
Notas
Se utiliza una función no calificada (sqrt) para realizar el cálculo. Si dicha función no está disponible, se usa std::sqrt debido a la búsqueda dependiente de argumentos.
La función se puede implementar con un tipo de retorno diferente de std::valarray. En este caso, el tipo de reemplazo tiene las siguientes propiedades:
- Se proporcionan todas las
constfunciones miembro de std::valarray. - std::valarray, std::slice_array, std::gslice_array, std::mask_array y std::indirect_array se pueden construir a partir del tipo de reemplazo.
- Para cada función que tome un
const std::valarray<T>&excepto begin() y end()(desde C++11), se añadirán funciones idénticas que tomen los tipos de reemplazo; - Para cada función que tome dos argumentos
const std::valarray<T>&, se añadirán funciones idénticas que tomen cada combinación deconst std::valarray<T>&y tipos de reemplazo. - El tipo de retorno no añade más de dos niveles de anidamiento de plantillas sobre el tipo de argumento más profundamente anidado.
Implementación posible
template<class T> valarray<T> sqrt(const valarray<T>& va) { valarray<T> other = va; for (T& i : other) i = sqrt(i); return other; // se puede devolver un objeto proxy } |
Ejemplo
Encuentra todas las tres raíces (dos de las cuales pueden ser conjugadas complejas) de varias ecuaciones cúbicas simultáneamente.
Ejecutar este código
#include <cassert> #include <complex> #include <cstddef> #include <iostream> #include <numbers> #include <valarray> using CD = std::complex<double>; using VA = std::valarray<CD>; // devolver todas las n raíces complejas de un número complejo x dado 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; } // devuelve n raíces complejas de cada elemento en v; en el valarray de salida primero // sigue la secuencia de todas las n raíces de v[0], luego todas las n raíces 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; } // comparador de números de punto flotante que tolera un error de redondeo dado 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() { // coeficientes de entrada para el polinomio 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}; // el solver 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); // asignar memoria para raíces: 3 * número de polinomios cúbicos de entrada 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); }; // cribar 6 de 9 raíces generadas, dejando solo 3 raíces propias (por polinomio) 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 << "Ecuación cúbica deprimida: Raíz 1: \t\t Raíz 2: \t\t Raíz 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)); } }
Salida:
Ecuación cúbica deprimida: Raíz 1: Raíz 2: Raíz 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)
Véase también
|
aplica la función
std::pow
a dos valarrays o a un valarray y un valor
(plantilla de función) |
|
|
(C++11)
(C++11)
|
calcula la raíz cuadrada (
√
x
)
(función) |
|
raíz cuadrada compleja en el rango del semiplano derecho
(plantilla de función) |