sqrt und pow

Veranschaulicht, wie sqrt verwendet und Kriegsgefangen Standardvorlagenbibliothek (STL) funktioniert in Visual C++.

template<class T>
inline valarray<T> sqrt(
   const valarray<T>& x
);
template<class T>
inline valarray<T> pow(
   const valarray<T>& x,
   const valarray<T>& y
);
template<class T>
inline valarray<T> pow(
   const valarray<T> x,
   const T& y
);
template<class T>
inline valarray<T> pow(
   const T& x,
   const valarray<T>& y
);

Hinweise

Hinweis
Die Klasse/Parameternamen im Prototyp stimmen nicht mit der Version in der Headerdatei ab.Einige wurden geändert, um die Lesbarkeit zu verbessern.

sqrt gibt ein Objekt der Klasse valarray<T> zurück, von denen jedes Element am Index I die Quadratwurzel von x[I] ist.pow verfügt über drei Vorlagen.Die erste Vorlagenfunktion gibt ein Objekt der Klasse valarray<T> zurück, von denen jedes Element am Index Ix[I] potenziert mit der y[I] ist.Die zweite Vorlagenfunktion speichert im Element I x[I] potenziert mit der *y.*Die dritte Vorlagenfunktion speichert im Element anzeigen x, das zur Potenz von y[I] ausgelöst wird.

Beispiel

// sqrtpow.cpp
// compile with: /EHsc

#include <iostream>                 // for i/o functions
#include <valarray>                 // for valarray
#include <cmath>                    // for sqrt() and pow()

using namespace std ;

#define ARRAY_SIZE  3               // array size

int main()
{
   // Set val_array to contain values 1, 4, 9 for the following test
   valarray<double> val_array(ARRAY_SIZE);
   int i;
   for (i = 0; i < ARRAY_SIZE; i++)
      val_array[i] = (i+1) * (i+1);

   // Display the size of val_array
   cout << "Size of val_array = " << val_array.size() << endl;

   // Display the values of val_array before calling sqrt() and pow().
   cout << "The values in val_array:" << endl << "[";
   for (i = 0; i < ARRAY_SIZE; i++)
      cout << " " << val_array[i];
   cout << " ]" << endl << endl;

   // Initialize rev_valarray that is the reverse of val_array.
   valarray<double> rev_valarray(ARRAY_SIZE);
   for (i = 0; i < ARRAY_SIZE; i++)
      rev_valarray[i] = val_array[ARRAY_SIZE - i - 1];

   // Display the size of rev_valarray.
   cout << "Size of rev_valarray = " << rev_valarray.size() << endl;

   // Display the values of rev_valarray.
   cout << "The values in rev_valarray:" << endl << "[";
   for (i = 0; i < ARRAY_SIZE; i++)
      cout << " " << rev_valarray[i];
   cout << " ]" << endl << endl;

   // rvalue_array to hold the return value from calling the sqrt() and
   // pow() functions.
   valarray<double> rvalue_array;

   // ----------------------------------------------------------------
   // sqrt() - display the content of rvalue_array
   // ----------------------------------------------------------------

   // Display the result of val_array after calling sqrt().
   rvalue_array = sqrt(val_array);
   cout << "The result of val_array after calling sqrt():"
        << endl << "[";
   for (i = 0; i < ARRAY_SIZE; i++)
      cout << " " << rvalue_array[i];
   cout << " ]" << endl << endl;

   // ----------------------------------------------------------------
   // pow() - display the content of rvalue_array
   // ----------------------------------------------------------------

   // This template function returns an object of class valarray<T>,
   // each of whose elements at I is x[I] raised to the power of y[I].
   rvalue_array = pow(val_array, rev_valarray);
   cout << "The result after calling pow(val_array, rev_valarray):"
        << endl << "[";
   for (i = 0; i < ARRAY_SIZE; i++)
      cout << " " << rvalue_array[i];
   cout << " ]" << endl << endl;

   // This template function stores in element I x[I] raised to the
   // power of y, where y=2.0.
   rvalue_array = pow(val_array, 2.0);
   cout << "The result after calling pow(val_array, 2.0):" 
        << endl << "[";
   for (i = 0; i < ARRAY_SIZE; i++)
      cout << " " << rvalue_array[i];
   cout << " ]" << endl << endl;

   // This template function stores in element I x raised to the
   // y[I] power, where x=2.0.
   rvalue_array = pow(2.0, val_array);
   cout << "The result after calling pow(2.0, val_array):"
        << endl << "[";
   for (i = 0; i < ARRAY_SIZE; i++)
      cout << " " << rvalue_array[i];
   cout << " ]" << endl;
}

Output

Size of val_array = 3
The values in val_array:
[ 1 4 9 ]

Size of rev_valarray = 3
The values in rev_valarray:
[ 9 4 1 ]

The result of val_array after calling sqrt():
[ 1 2 3 ]

The result after calling pow(val_array, rev_valarray):
[ 1 256 9 ]

The result after calling pow(val_array, 2.0):
[ 1 16 81 ]

The result after calling pow(2.0, val_array):
[ 2 16 512 ]

Anforderungen

Header: <valarray>

Siehe auch

Konzepte

Standardvorlagenbibliotheks-Beispiele