Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
Export (0) Print
Expand All
abs
Expand Minimize
Important This document may not represent best practices for current development, links to downloads and other resources may no longer be valid. Current recommended version can be found here.

sqrt and pow 

Illustrates how to use the sqrt and pow Standard Template Library (STL) functions 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
);

NoteNote

The class/parameter names in the prototype do not match the version in the header file. Some have been modified to improve readability.

sqrt returns an object of class valarray<T>, each of whose elements at index I is the square root of x[I]. pow has three template functions. The first template function returns an object of class valarray<T>, each of whose elements at index I is x[I] raised to the power of y[I]. The second template function stores in element I x[I] raised to the power of y. The third template function stores in element I x raised to the power of y[I].

// 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;
}

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 ]

Header: <valarray>

Community Additions

ADD
Show:
© 2015 Microsoft