Table 12.2 lists the constructors and assignment operations for complex. The constructors provide the ability to pass the initial values of the real and the imaginary parts. If they are not passed, they are initialized by the default constructor of the value type.

The assignment operators are the only way to modify the value of an existing complex number. The computed assignment operators +=, −=, *=, and /= add, subtract, multiply, and divide the value of the second operand to, from, by, and into the real part of the first operand.

The auxiliary polar() function provides the ability to create a complex number that is initialized by polar coordinates (magnitude and phase angle in radians):

// create a complex number initialized from polar coordinates
   std::complex<double> c2(std::polar(4.2,0.75));

A problem exists when you have an implicit type conversion during the creation. For example, this notation works:

   std::complex<float> c2(std::polar(4.2,0.75));      // OK

However, the following notation with the equal sign does not:

   std::complex<float> c2 = std::polar(4.2,0.75);     // ERROR

This problem is discussed in the next subsection.

The auxiliary conj() function provides the ability to create a complex number that is initialized by the conjugated complex value of another complex number (a conjugated complex value is the value with a negated imaginary part):

   std::complex<double> c1(1.1,5.5);
   std::complex<double> c2(conj (c1)) ; // initialize c2 with
                                             // complex<double>(1.1,−5.5)

The constructors of the specializations for float, double, and long double are designed in such a way that safe conversions such as complex<float> to complex<double> are allowed to be implicit, but less safe conversions such as complex<long double> to complex<double> must be explicit (see page 542 for the declarations in detail):

   std::complex<float> cf;
   std::complex<double> cd;
   std::complex<long double> cld;
   ...
   std:: complex<double> cd1 = cf;    // OK: safe conversion
   std::complex<double> cd2 = cld;    // ERROR: no implicit conversion
   std::complex<double> cd3(cld);     // OK: explicit conversion

In addition, there are no constructors from any other complex type defined. In particular, you can't convert a complex with an integral value type into a complex with value type float, double, or long double. However, you can convert the values by passing the real and imaginary parts as separate arguments:

   std::complex<double> cd;
   std::complex<int> ci;
   ...
   std::complex<double> cd4 = ci;    // ERROR: no implicit conversion
   std::complex<double> cd5(ci);     // ERROR: no explicit conversion
   std::complex<double> cd6(ci.real(), ci.imag());  // OK

Unfortunately, the assignment operators allow less safe conversions. They are provided as template functions for all types. So, you can assign any complex type as long as the value types are convertible^[1]:

   std::complex<double> cd;
   std::complex<long double> cld;
   std::complex<int> ci;
   ...
   cd = ci;     // OK
   cd = cld;    // OK

This problem also relates to polar() and conj(). For example, the following notation works fine:

   std::complex<float> c2(std::polar(4.2,0.75));    // OK

But, the notation with the equal sign does not:

   std::complex<float> c2 = std::polar(4.2,0.75);   // ERROR

The reason for this is that the expression

   std::polar(4.2,0.75)

creates a temporary complex<double> and the implicit conversion from complex<double> to complex<float> is not defined.^[2]

and

   X x;
   Y y = x; // implicit conversion

The former creates a new object of type Y by using an explicit conversion from type X, whereas the latter creates a new object of type Y by using an implicit conversion.

Table 12.3 shows the different functions provided to access the attributes of complex numbers.

Table 12.3. Operations for Value Access of Class complex<>

Expression	Effect
c.real()	Returns the value of the real part (as a member function)
real(c)	Returns the value of the real part (as a global function)
c.imag()	Returns the value of the imaginary part (as a member function)
imag(c)	Returns the value of the imaginary part (as a global function)
abs(c)	Returns the absolute value of c
norm(c)	Returns the squared absolute value of c(c.real()2 + c.imag()2)
arg(c)	Returns the angle of the polar representation of c (equivalent to atan2(c.imag(), c.real()) as phase angle)

Note that real() and imag() provide only read access to the real and the imaginary parts. To change only the real part or only the imaginary part you must assign a new complex number. For example, the following statement sets the imaginary part of c to 3.7:

   std::complex<double> c;
   ...
   c = std::complex<double>(c.real(),3.7);

To compare complex numbers, you can only check for equality (Table 12.4). The operators == and != are defined as global functions so that one of the operands may be a scalar value. If you use a scalar value as the operand it is interpreted as the real part, with the imaginary part having the default value of its type (which is usually 0).

Other comparison operations, such as operator <, are not defined. Although it is not impossible to define an ordering for complex values, such orderings are neither very intuitive nor very useful. Note, for example, that the magnitude of complex numbers by itself is not a good basis to order complex values because two complex values can be very different and yet have identical magnitude (1 and −1 are two such numbers). An add hoc criterion can be added to create a valid ordering. For example, given two complex values c1 and c2, you could deem c1 < c2 when |c1| < |c2| or, if both magnitudes are equal, when arg(c1) < arg(c2). However, such a criterion invariably has little or no mathematical meaning.^[3]

As a consequence, you can't use complex as the element type of an associative container (provided you use no user-defined sorting criterion). This is because associative containers use the function object less<>, which calls operator <, to be able to sort the elements (see Section 5.10.1,).

By implementing a user-defined operator < you could sort complex numbers and use them in associative containers. Note that you should be very careful not to pollute the standard namespace. For example:

   template <class T>
   bool operator< (const std::complex<T>& c1,
                   const std::complex<T>& c2)
   {
       return std::abs(c1)<std::abs(c2) ||
              (std::abs(c1)==std::abs(c2) &&
               std::arg(c1)<std::arg(c2));
   }

Complex numbers provide the four basic arithmetic operations and the negative and positive signs (Table 12.5).

Class complex provides the common I/O operators << and >> (Table 12.6).

The output operator writes the complex number with respect to the current stream state with the format:

(realpart, imagpart)

In particular, the output operator is defined as equivalent to the following implementation:

   template <class T, class charT, class traits>
   std::basic_ostream<charT, traits>&
   operator<< (std::basic_ostream<charT, traits>& strm,
               const std::complex<T>& c)
   {
       // temporary value string to do the output with one argument
       std::basic_ostringstream<charT, traits> s;

       s.flags (strm.flags());         // copy stream flags
       s.imbue (strm.getloc());        // copy stream locale
       s.precision(strm.precision());  // copy stream precision
// prepare the value string
       s << '(' << c.real() << ',' << c.imag() << ')';

       // write the value string
       strm << s.str();

       return strm;
   }

The input operator provides the ability to read a complex number with one of the following formats:

   (realpart, imagpart)
   (realpart)
   realpart

If none of the formats fits according to the next characters in the input stream, the ios::failbit is set, which might throw a corresponding exception (see Section 13.4.4,).

Unfortunately, you can't specify the separator of complex numbers between the real and the imaginary parts. So if you have a comma as a "decimal point" (as is the case in German), I/O looks really strange. For example, a complex number with 4.6 as the real part and 2.7 as the imaginary part would be written as

   (4,6,2,7)

See page 532 for an example of how to use the I/O operations.

Table 12.7 lists the transcendental functions (trigonometric, exponential, and so on) for complex.

Table 12.7. Transcendental Functions of Class complex<>

Expression	Effect
pow(c, 3)	Complex power c3
pow(c, 1.7)	Complex power c1.7
pow(c1, c2)	Complex power c1c2
pow(1.7, c)	Complex power 1.7c
exp(c)	Base e exponential of c (ec)
sqrt(c)	Square root of c ()
log(c)	Complex natural logarithm of c with base e (ln c)
log10(c)	Complex common logarithm of c with base 10 (lg c)
sin(c)	Sine of c (sin c)
cos(c)	Cosine of c (cos c)
tan(c)	Tangent of c (tan c)
sinh(c)	Hyperbolic sine of c (sinh c)
cosh(c)	Hyperbolic cosine of c (cosh c)
tanh(c)	Hyperbolic tangent of c (tanh c)

complex:: value_type

complex::complex ()

complex::complex (const T& re)

complex::complex (const T& re, const T& im)

complex polar (const T& rho)

complex polar (const T& rho, const T& theta)

complex conj (const complex& cmplx)

complex :: complex (const complex& cmplx)

complex& complex::operator = (const complex& cmplx)

complex& complex::operator += (const complex& cmplx)

complex& complex::operator −= (const complex& cmplx)

complex& complex::operator *= (const complex& cmplx)

complex& complex::operator /= (const complex& cmplx)

Note that the assignment operators are the only functions that allow you to modify the value of an existing complex.

T complex :: real () const

T real (const complex& cmplx)

T complex::imag () const

T imag (const complex& cmplx)

T abs (const complex& cmplx)

T norm (const complex& cmplx)

T arg (const complex& cmplx)

ostream& operator << (ostream& strm, const complex& cmplx)

istream& operator >> (istream& strm, complex& cmplx)

complex operator+ (const complex& cmplx)

complex operator- (const complex& cmplx)

complex binary-op (const complex& cmplx1, const complex& cmplx2)

complex binary-op (const complex& cmplx, const T& value)

complex binary-op (const T& value, const complex& cmplx)

bool comparison (const complex& cmplx1, const complex& cmplx2)

bool comparison (const complex& cmplx, const T& value)

bool comparison (const T& value, const complex& cmplx)

complex pow (const complex& base, int exp)

complex pow (const complex& base, const T& exp)

complex pow (const complex& base, const complex& exp)

complex pow (const T& base, const complex& exp)

complex exp (const complex& cmplx)

complex sqrt (const complex& cmplx)

complex log (const complex& cmplx)

complex log10 (const complex& cmplx)

complex sin (const complex& cmplx)

complex cos (const complex& cmplx)

complex tan (const complex& cmplx)

complex sinh (const complex& cmplx)

complex cosh (const complex& cmplx)

complex tanh (const complex& cmplx)

Valarrays are declared in the header file <valarray>:

   #include <valarray>

In particular, in <valarray> the following classes are declared:

   namespace std {
       template<class T> class valarray;               // numeric array of type T

       class slice;                                    // slice out of a valarray
       template<class T> class slice_array;

       class gslice;                                   // a generalized slice
       template<class T> class gslice_array;

       template<class T> class mask_array;             // a masked valarray

       template<class T> class indirect_array;         // an indirected valarray
   }

The classes have the following meanings:

All classes are templatized for the type of the elements. In principle, the type could be any data type. However, according to the nature of valarrays it should be a numeric data type.

When you create a valarray you usually pass the number of elements as a parameter:

   std::valarray<int> va1(10);              // valarray of ten ints with value 0
   std::valarray<float> va2(5.7, 10);       // valarray of ten floats with value 5.7
                                            // (note the order)

If you pass one argument, it is used as the size. The elements are initialized by the default constructor of their type. Elements of fundamental data types are initialized by zero (see Section 2.2.2, for a description of why fundamental data types may be initialized by a default constructor). If you pass a second value, the first is used as the initial value for the elements, whereas the second specifies the number of elements. Note that the order of passing two arguments to the constructor differs from that of all other classes of the C++ standard library. All STL container classes use the first numeric argument as the number of elements and the second argument as the initial value.

You can also initialize a valarray with an ordinary array:

   int array[] = { 3, 6, 18, 3, 22 };

   // initialize valarray by elements of an ordinary array
   std::valarray<int> va3(array, sizeof (array)/sizeof (array[0]));

   // initialize by the second to the fourth element
   std::valarray<int> va4(array+1, 3);

The valarray creates copies of the passed values. Thus, you can pass temporary data for initialization.

For valarrays, the subscript operator is defined to access the element of a valarray. As usual, the first element has the index 0:

   va[0] = 3 * va[1] + va[2];

In addition, all ordinary numeric operators are defined (addition, subtraction, multiplication, modulo, negation, bit operators, comparison operators, and logical operators, as well as all assignment operators). These operators are called for each element in the valarrays that is processed by the operation. Thus, the result of a valarray operation is a valarray that has the same number of elements as the operands and that contains the result of the elementwise computation. For example, the statement

   va1 = va2 * va3;

is equivalent to

   va1[0] = va2[0] * va3[0];
   va1[1] = va2[1] * va3[1];
   va1[2] = va2[2] * va3[2];
   ...

If the number of elements of the combined valarrays differs, the result is undefined.

Of course, the operations are available only if the element's type supports them. And the exact meaning of the operation depends on the meaning of the operation for the elements. Thus, all of these operations simply do the same for each element or pair of elements in the valarrays they process.

For binary operations, one of the operands may be a single value of the element's type. In this case, the single value is combined with each element of the valarray that is used as the other operand. For example, the statement

   va1 = 4 * va2;

is equivalent to

   va1[0] = 4 * va2[0];
   va1[1] = 4 * va2[1];
   va1[2] = 4 * va2[2];
   ...

Note that the type of the single value has to match exactly the element type of the valarray. Thus, the previous example works only if the element type is int. The following statement would fail:

   std::valarray<double> va(20);
   ...
   va = 4 * va;    // ERROR: type mismatch

The schema of binary operations also applies to comparison operators. Thus, operator == does not return a single Boolean value that shows whether both valarrays are equal. Instead, it returns a new valarray with the same number of elements of type bool, where each value is the result of the individual comparison. For example, in the following code

   std::valarray<double> val(10);
   std::valarray<double> va2(10);
   std::valarray<bool> vab(10);
   ...
   vab = (va1 == va2);

the last statement is equivalent to

   vab[0] = (va1[0] == va2[0]);
   vab[1] = (va1[1] == va2[1]);
   vab[2] = (va1[2] == va2[2]);
   ...
   vab[9] = (va1 [9] == va2[9]);

For this reason, you can't sort valarrays by using operator <, and you can't use them as elements in STL containers if the test for equality is performed with operator == (see Section 5.10.1, for the requirements of elements of STL containers).

The following program demonstrates a simple use of valarrays:

// num/val1.cpp

   #include <iostream>
   #include <valarray>
   using namespace std;

   // print valarray
   template <class T>
   void printValarray (const valarray<T>& va)
   {
       for (int i=0; i<va.size(); i++) {
           cout << va[i] << ' ';
       }
       cout << endl;
   }
   int main()
   {
       // define two valarrays with ten elements
       valarray<double> va1(10), va2(10);

       // assign values 0.0, 1.1, up to 9.9 to the first valarray
       for (int i=0; i<10; i++) {
           va1[i] = i * 1.1;
       }

       // assign
−1 to all elements of the second valarray
       va2 = −1;

       // print both valarrays
       printValarray(va1);
       printValarray(va2);

       // print minimum, maximum, and sum of the first valarray
       cout << "min(): " << va1.min() << endl;
       cout << "max(): " << va1.max() << endl;
       cout << "sum(): " << va1.sum() << endl;

       // assign values of the first to the second valarray
       va2 = va1;

       // remove all elements of the first valarray
       va1.resize (0);

       // print both valarrays again
       printValarray(va1);
       printValarray(va2);
   }

The program has the following output:

   0 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9
   −1 −1 −1 −1 −1 −1 −1 −1 −1 −1
   min(): 0
   max(): 9.9
   sum(): 49.5

   0 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9

The transcendental operations (trigonometric and exponential) are defined as equivalent to the numeric operators. The operations are performed with all elements in the valarrays, and for binary operations, one of the operands may be a single value, which is used as one operand, with all elements of the valarrays as the other operand.

All of these operations are defined as global functions instead of member functions. This is to provide automatic type conversion for subsets of valarrays for both operands (subsets of valarrays are covered in Section 12.2.2,).

Here is a second example of the use of valarrays. It demonstrates the use of transcendental operations:

// num/val2.cpp

   #include <iostream>
   #include <valarray>
   using namespace std;

   // print valarray
   template <class T>
   void printValarray (const valarray<T>& va)
   {
       for (int i=0; i<va.size(); i++) {
           cout << va[i] << ' ';
       }
       cout << endl;
   }

   int main()
   {

       // create and initialize valarray with nine elements
       valarray<double> va(9);
       for (int i=0; i<va.size(); i++) {
            va[i] = i * 1.1;
       }

       // print valarray
       printValarray(va);

       // double values in the valarray
       va *= 2.0;

       // print valarray again
       printValarray(va);

       // create second valarray initialized by the values of the first plus 10
       valarray<double> vb(va+10.0);

       // print second valarray
       printValarray(vb);

       // create third valarray as a result of processing both existing valarrays
       valarray<double> vc;
       vc = sqrt(va) + vb/2.0 - 1.0;

       // print third valarray
       printValarray(vc);
   }

The program has the following output:

   0 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8
   0 2.2 4.4 6.6 8.8 11 13.2 15.4 17.6
   10 12.2 14.4 16.6 18.8 21 23.2 25.4 27.6
   4 6.58324 8.29762 9.86905 11.3665 12.8166 14.2332 15.6243 16.9952

Before I start with the individual subsets, I have to mention a general problem. The handling of valarray subsets is not well designed. You can create subsets easily, but you can't combine them easily with other subsets. Unfortunately, you almost always need an explicit type conversion to valarray. This is because the C++ standard library does not specify that valarray subsets provide the same operations as valarrays.

For example, to multiply two subsets and assign the result to a third subset, you can't write the following:

// ERROR: conversions missing
    va[std::slice(0,4,3)]
        = va[std::slice (1,4,3)] * va[std::slice (2,4,3)];

Instead, you have to code by using a new-style cast (see page 19)^[5]:

    va[std::slice (0,4,3)]
        = static_cast<std::valarray<double> >(va[std::slice (1,4,3)]) *
          static_cast<std::valarray<double> >(va[std::slice (2,4,3)]);

or by using an old-style cast:

   va[std::slice(0,4,3)]
       = std::valarray<double>(va[std::slice (1,4,3)]) *
         std::valarray<double>(va[std::slice (2,4,3)]);

This is tedious and error prone. Even worse, without good optimization it may cost performance because each cast creates a temporary object, which could be avoided without the cast.

To make the handling a bit more convenient, you can use the following template function:

   /* template to convert valarray subset into valarray
    */
   template <class T>
   inline
   std::valarray<typename T::value_type> VA (const T& valarray_subset)
   {
       return std::valarray<typename T::value_type>(valarray_subset);
   }

By using this template, you could write

   va[std::slice (0,4,3)] = VA(va[std::slice (1,4,3)]) *
                            VA(va[std::slice (2,4,3)]); // OK

However, the performance penalty remains.

If you use a certain element type you could also use a simple type definition:

   typedef valarray<double> VAD;

By using this type definition you could also write

   va[std::slice (0,4,3)] = VAD(va[std::slice(1,4,3)]) *
                            VAD (va[std::slice (2,4,3)]); // OK

provided the elements of va have type double.

A slice defines a set of indices that has three properties:

You can pass these three properties exactly in the same order as parameters to the constructor of class slice. For example, the following expression specifies four elements, starting with index 2 with distance 3:

   std::slice (2,4,3)

In other words, the expression specifies the following set of indices:

   2  5  8  11

The stride may be negative. For example, the expression

   std::slice (9,5,-2)

specifies the following indices:

   9  7  5  3  1

To define the subset of a valarray, you simply use a slice as an argument of the subscript operator. For example, the following expression specifies the subset of the valarray va that contains the elements with the indices 2, 5, 8, and 11:

   va[std::slice (2,4,3)]

It's up to the caller to ensure that all these indices are valid.

If the subset qualified by a slice is a subset of a constant valarray, the subset is a new valarray. If the valarray is nonconstant, the subset has reference semantics to the original valarray. The auxiliary class slice_array is provided for this:

   namespace std {
       class slice;

       template <class T>
       class slice_array;

       template <class T>
       class valarray {
         public:
           // slice of a constant valarray returns a new valarray
           valarray<T> operator[] (slice) const;

           // slice of a variable valarray returns a slice_array
           slice_array<T> operator[] (slice);
           ...
       };
   }

For slice_arrays, the following operations are defined:

For any other operation you have to convert the subset to a valarray (see page 554). Note that the class slice_array<> is intended purely as an internal helper class for slices, and it should be transparent to the user. Thus, all constructors and the assignment operator of class slice_array<> are private.

For example, the statement

   va[std::slice (2,4,3)] = 2;

assigns 2 to the third, sixth, ninth, and twelfth elements of the valarray va. It is equivalent to the following statements:

   va[2] = 2;
   va[5] = 2;
   va[8] = 2;
   va[11] = 2;

As another example, the following statement squares the values of the elements with index 2, 5, 8, and 11:

   va[std::slice (2,4,3)]
       *= std::valarray<double>(va[std::slice(2,4,3)]);

As mentioned on page 554, you can't write

   va[std::slice (2,4,3)] *= va[std::slice (2,4,3)]; //            ERROR

But using the VA() template function mentioned on page 555, you can write

   va[std::slice(2,4,3)] *= VA(va[std::slice (2,4,3)]);      // OK

By passing different slices of the same valarray you can combine different subsets and store the result in another subset of the valarray. For example, the statement

   va[std::slice (0,4,3)] = VA(va[std::slice (1,4,3)]) *
                            VA(va[std::slice (2,4,3)]);

is equivalent to the following:

   va[0] = va[1] * va[2];
   va[3] = va[4] * va[5];
   va[6] = va[7] * va[8];
   va[9] = va[10] * va[11];

If you consider your valarray as a two-dimensional matrix, this example is nothing else but vector multiplication (Figure 12.1). However, note that the order of the individual assignments is not defined. Therefore, the behavior is undefined if the destination subset contains elements that are used in the source subsets.

Figure 12.1. Vector Multiplication by Valarray Slices

In the same way, more complicated statements are possible. For example:

   va[std::slice (0,100,3)]
       = std::pow(VA(va[std::slice (1,100,3)]) * 5.0,
                  VA(va[std::slice (2,100,3)]));

Note again that a single value, such as 5.0 in this example, has to match the element type of the valarray exactly.

The following program demonstrates a complete example of using valarray slices:

// num/slice1.cpp

   #include <iostream>
   #include <valarray>
   using namespace std;

   // print valarray line-by-line
   template<class T>
   void printValarray (const valarray<T>& va, int num)
   {
       for (int i=0; i<va.size()/num; ++i) {
           for (int j=0; j<num; ++j) {
               cout << va[i*num+j] << ' ';
           }
           cout << endl;
       }
       cout << endl;
   }

   int main()
   {
       /* valarray with 12 elements
* - four rows
* - three columns
*/
       valarray<double> va(12);

       // fill valarray with values
       for (int i=0; i<12; i++) {
           va[i] = i;
       }

       printValarray (va, 3);

       // first column = second column raised to the third column
       va [slice (0,4,3)] = pow (valarray<double>(va[slice (1,4,3)]),
                                 valarray<double>(va[slice (2,4,3)]));

       printValarray (va, 3);

       // create valarray with three times the third element of va
       valarray<double> vb(va[slice (2,4,0)]);

       // multiply the third column by the elements of vb
       va[slice (2,4,3)] *= vb;

       printValarray (va, 3);

       // print the square root of the elements in the second row
       printValarray (sqrt(valarray<double>(va[slice (3,3,1)])), 3);

       // double the elements in the third row
       va[slice (2,4,3)] = valarray<double>(va[slice (2,4,3)]) * 2.0;

       printValarray (va, 3);
   }

The program has the following output:

   0 1 2
   3 4 5
   6 7 8
   9 10 11

   1 1 2
   1024 4 5
   5.7648e+006 7 8
   1e+011 10 11

   1 1 4
   1024 4 10
   5.7648e+006 7 16
   1e+011 10 22

   32 2 3.16228

   1 1 8
   1024 4 20
   5.7648e+006 7 32
   1e+011 10 44

General slices, or gslices, are the general form of slices. Similar to slices, which provide the ability to handle a subset that is one dimension out of two dimensions, gslices allow the handling of subsets of multidimensional arrays. In principle, gslices have the same properties as slices:

Unlike slices, however, the number and distance of elements in a gslice are arrays of values. The number of elements in such an array is equivalent to the number of dimensions used. For example, if a gslice has the state

   start:  2
   size:   [ 4 ]
   stride: [ 3 ]

then the gslice is equivalent to a slice because the array handles one dimension. Thus, it defines four elements with distance 3, starting with index 2:

   2  5  8  11

However, if a gslice has the state

   start:  2
   size:   [ 2 4]
   stride: [ 10 3]

then the gslice handles two dimensions. The smallest index handles the highest dimension. Thus, this gslice specifies starting from index 2, twice with distance 10, four elements with distance 3:

    2  5  8 11
   12 15 18 21

Here is an example of a slice with three dimensions:

   start:  2
   size:   [  3  2 4 ]
   stride: [ 30 10 3 ]

It specifies starting from index 2, three times with distance 30, twice with distance 10, four elements with distance 3:

    2  5  8 11
   12 15 18 21

   32 35 38 41
   42 45 48 51

   62 65 68 71
   72 75 78 81

The ability to use arrays to define size and stride is the only difference between gslices and slices. Apart from this, gslices behave the same as slices:

The following program demonstrates the use of valarray gslices:

// num/gslice1.cpp

   #include <iostream>
   #include <valarray>
   using namespace std;

   // print three-dimensional valarray line-by-line
   template<class T>
   void printValarray3D (const valarray<T>& va, int dim1, int dim2)
   {
       for (int i=0; i<va.size()/(dim1*dim2); ++i) {
           for (int j=0; j<dim2; ++j) {
               for (int k=0; k<dim1; ++k) {
                   cout << va[i*dim1*dim2+j*dim1+k] << ' ';
               }
               cout << '
';
           }
           cout << '
';
       }
       cout << endl;
   }

   int main()
   {
       /* valarray with 24 elements
* - two groups
* -four rows
* - three columns
*/
       valarray<double> va(24);
       // fill valarray with values
       for (int i=0; i<24; i++) {
           va[i] = i;
       }
       // print valarray
       printValarray3D (va, 3, 4);
       // we need two two-dimensional subsets of three times 3 values
// in two 12-element arrays
       size_t lengthvalues[] = { 2, 3 };
       size_t stridevalues[] = { 12, 3 };
       valarray<size_t> length(lengthvalues, 2);
       valarray<size_t> stride(stridevalues, 2);
       // assign the second column of the first three rows
// to the first column of the first three rows
       va[gslice (0, length, stride)]
           = valarray<double>(va[gslice (1, length, stride)]);
       // add and assign the third of the first three rows
// to the first of the first three rows
       va[gslice (0, length, stride)]
           += valarray<double>(va[gslice (2, length, stride)]);
       // print valarray
       printValarray3D (va, 3, 4);
   }

The program has the following output:

   0  1  2
   3  4  5
   6  7  8
   9  10  11

   12  13  14
   15  16  17
   18  19  20
   21  22  23

   3  1  2
   9  4  5
   15  7  8
   9  10  11

   27  13  14
   33  16  17
   39  19  20
   21  22  23

Mask arrays provide another way to define a subset of a valarray. You can mask the elements with a Boolean expression. For example, in the expression

   va[va > 7]

the subexpression

   va > 7

returns a valarray with the size of va, where for each element a Boolean value states whether the element is greater than 7. The Boolean valarray is used by the subscript operator to specify all elements for which the Boolean expression yields true. Thus,

   va[va > 7]

specifies the subset of elements in the valarray va that is greater than 7.

Apart from this, mask arrays behave the same as all valarray subsets:

The following program demonstrates the use of masked subsets of valarrays:

   // num/masked1.cpp
   #include <iostream>
   #include <valarray>
   using namespace std;
   // print valarray line-by-line
   template<class T>
   void printValarray (const valarray<T>& va, int num)
   {
       for (int i=0; i<va.size()/num; ++i) {
           for (int j=0; j<num; ++j) {
               cout << va[i*num+j] << ' ';
           }
           cout << endl;
       }
       cout << endl;
   }
   int main()
   {
       /* valarray with 12 elements
* - four rows
* - three columns
*/
       valarray<double> va(12);
       // fill valarray with values
       for (int i=0; i<12; i++) {
           va[i] = i;
       }
       printValarray (va, 3);
       // assign 77 to all values that are less than 5
       va[va<5.0] = 77.0;
       // add 100 to all values that are greater than 5 and less than 9
       va[va>5.0 && va<9.0]
           = valarray<double>(va[va>5.0 && va<9.0]) + 100.0;
       printValarray (va, 3);
   }

The program has the following output:

   0  1  2
   3  4  5
   6  7  8
   9  10  11

   77  77 77
   77  77 5
   106  107  108
   9 10  11

Note that the type of a numeric value that is compared with the valarray has to match the type of the valarray exactly. So, using an int value to compare it with a valarray of doubles would not compile:

   valarray<double> va(12);
   ...
   va[va<5] = 77;      // ERROR

The fourth and last way to define a subset of a valarray is provided by indirect arrays. Here you simply define the subset of a valarray by passing an array of indices. Note that the indices that specify the subset don't have to be sorted and may occur twice.

Apart from this, indirect arrays behave the same as all valarray subsets:

The following program demonstrates how to use indirect arrays:

   // num/indi1.cpp


   #include <iostream>
   #include <valarray>
   using namespace std;


   // print valarray as two-dimensional array
   template<class T>
   void printValarray (const valarray<T>& va, int num)
   {
       for (int i=0; i<va.size()/num; i++) {
           for (int j=0; j<num; j++) {
               cout << va[i*num+j] << ' ';
           }
           cout << endl;
       }
       cout << endl;
   }
   int main()
   {
       // create valarray for 12 elements
       valarray<double> va(12);
       // initialize valarray by values 1.01, 2.02, ... 12.12
       for (int i=0; i<12; i++) {
           va[i] = (i+1) * 1.01;
       }
       printValarray(va, 4);
       /* create array of indexes
        * - note: element type has to be size_t
        */
       valarray<size_t> idx(4);
       idx[0] = 8;
       idx[1] = 0;
       idx[2] = 3;
       idx[3] = 7;
       // use array of indexes to print the ninth, first, fourth, and eighth elements
       printValarray(valarray<double>(va[idx]), 4);
       // change the first and fourth elements and print them again indirectly
       va[0] = 11.11;
       va[3] = 44.44;
       printValarray(valarray<double>(va[idx]), 4);
       // now select the second, third, sixth, and ninth elements
// and assign 99 to them
       idx[0] = 1;
       idx[1] = 2;
       idx[2] = 5;
       idx[3] = 8;
       va[idx] = 99;
       // print the whole valarray again
       printValarray (va, 4);
   }

The valarray idx is used to define the subset of the elements in valarray va. The program has the following output:

   1.01 2.02 3.03 4.04
   5.05 6.06 7.07 8.08
   9.09 10.1 11.11 12.12

   9.09 1.01 4.04 8.08

   9.09 11.11 44.44 8.08

   11.11 99 99 44.44
   5.05 99 7.07 8.08
   99 10.1 11.11 12.12

valarray::valarray ()

explicit valarray::valarray (size_t num)

valarray::valarray (const T& value, size_t num)

valarray::valarray (const T* array, size_t num)

valarray::valarray (const valarray& va)

valarray::~valarray ()

In addition, you can create valarrays initialized by objects of the internal auxiliary classes slice_array, gslice_array, mask_array, and indirect_array. See pages 575, 577, 578, and 579, respectively, for details about these classes.

valarray& valarray::operator = (const valarray& va)

valarray& valarray::operator = (const T& value)

In addition, you can assign values of the internal auxiliary classes slice_array, gslice_array, mask_array, and indirect_array. See pages 575, 577, 578, and 579, respectively, for details about these classes.

Class valarray provides the following member functions.

size_t valarray::size () const

void valarray::resize (size_t num)

void valarray::resize (size_t num, T value)

T valarray::min () const

T valarray::max () const

T valarray::sum () const

valarray valarray::shift (int num) const

valarray valarray::cshift (int num) const

valarray valarray::apply (T op (T)) const

valarray valarray::apply (T op (const T&)) const

T & valarray::operator [ ] (size_t idx)

T valarray::operator [ ] (size_t idx) const

Unary valarray operators have the following format:

valarray valarray:: unary-op () const

The binary operators for valarrays (except comparison and assignment operators) have the following format:

valarray binary-op (const valarray& va1, const valarray& va2)

valarray binary-op (const valarray& va, const T& value)

valarray binary-op (const T& value, const valarray& va)

The logical and comparison operators follow the same schema. However, their return values are a valarray of Boolean values:

valarray<bool> logical-op (const valarray& va1, const valarray& va2)

valarray<bool> logical-op (const valarray& va, const T& value)

valarray<bool> logical-op (const T& value, const valarray& va)

Similarly, computed assignment operators are defined for valarrays:

valarray& valarray::assign-op (const valarray& va)

valarray& valarray::assign-op (const T& value)

valarray abs (const valarray& va)

valarray pow (const valarray& va1, const valarray& va2)

valarray pow (const valarray& va, const T& value)

valarray pow (const T& value, const valarray& va)

valarray exp (const valarray& va)

valarray sqrt (const valarray& va)

valarray log (const valarray& va)

valarray log10 (const valarray& va)

valarray sin (const valarray& va)

valarray cos (const valarray& va)

valarray tan (const valarray& va)

valarray sinh (const valarray& va)

valarray cosh (const valarray& va)

valarray tanh (const valarray& va)

valarray asin (const valarray& va)

valarray acos (const valarray& va)

valarray atan (const valarray& va)

valarray atan2 (const valarray& va1, const valarray& va2)

valarray atan2 (const valarray& va, const T& value)

valarray atan2 (const T& value, const valarray& va)

Objects of class slice_array are created by using a slice as the index of a nonconstant valarray:

   namespace std {
       template<class T>
       class valarray {
         public:
           ...
           slice_array<T> operator[] (slice);
           ...
        };
   }

The exact definition of the public interface of class slice is as follows:

   namespace std {
       class slice {
         public:
           slice (); // empty subset
           slice (size_t start, size_t size, size_t stride);
           size_t start() const;
           size_t size() const;
           size_t stride() const;
       };
   }

The default constructor creates an empty subset. With the start(), size(), and stride() member functions, you can query the properties of a slice.

The class slice_array provides the following operations:

   namespace std {
       template <class T>
       class slice_array {
         public:
           typedef T value_type;


           void operator= (const T&);
           void operator= (const valarray<T>&) const;
           void operator*= (const valarray<T>&) const;
           void operator/= (const valarray<T>&) const;
           void operator%= (const valarray<T>&) const;
           void operator+= (const valarray<T>&) const;
           void operator−= (const valarray<T>&) const;
           void operator~= (const valarray<T>&) const;
           void operator&= (const valarray<T>&) const;
           void operator|= (const valarray<T>&) const;
           void operator<<=(const valarray<T>&) const;
           void operator>>=(const valarray<T>&) const;
           ~slice_array();
         private:
           slice_array();
           slice_array(const slice_array&);
           slice_array& operator=(const slice_array&);
           ...
       };
   }

Note that class slice_array<> is intended purely as an internal helper class for slices and should be transparent to the user. Thus, all constructors and the assignment operator of class slice_array<> are private.

Objects of class gslice_array are created by using a gslice as the index of a nonconstant valarray:

   namespace std {
       template<class T>
       class valarray {
         public:
           ...
           gslice_array<T> operator[] (const gslice&);
           ...
       };
   }

The exact definition of the public interface of gslice is as follows:

   namespace std {
       class gslice {
         public:
           gslice (); // empty subset
           gslice (size_t start,
                  const valarray<size_t>& size,
                  const valarray<size_t>& stride);
           size_t start() const;
           valarray<size_t> size() const;
           valarray<size_t> stride() const;
       };
   }

The default constructor creates an empty subset. With the start(), size(), and stride() member functions you can query the properties of a gslice.

The class gslice_array provides the following operations:

   namespace std {
       template <class T>
       class gslice_array {
         public:
           typedef T value_type;


           void operator= (const T&);
           void operator= (const valarray<T>&) const;
           void operator*= (const valarray<T>&) const;
           void operator/= (const valarray<T>&) const;
           void operator%= (const valarray<T>&) const;
           void operator+= (const valarray<T>&) const;
           void operator−= (const valarray<T>&) const;
           void operator~= (const valarray<T>&) const;
           void operator&= (const valarray<T>&) const;
           void operator|= (const valarray<T>&) const;
           void operator<<=(const valarray<T>&) const;
           void operator>>=(const valarray<T>&) const;
           ~gslice_array();
         private:
           gslice_array();
           gslice_array(const gslice_array<T>&);
           gslice_array& operator=(const gslice_array<T>&);
           ...
       };
   }

As with slice_array<>, note that class gslice_array<> is intended purely as an internal helper class for gslices and should be transparent to the user. Thus, all constructors and the assignment operator of class gslice_array<> are private.

Objects of class mask_array are created by using a valarray<bool> as the index of a nonconstant valarray:

   namespace std {
       template<class T>
       class valarray {
         public:
          ...
          mask_array<T> operator[] (const valarray<bool>&);
          ...
      };
   }

The class mask_array provides the following operations:

   namespace std {
       template <class T>
       class mask_array {
         public:
           typedef T value_type;


           void operator= (const T&);
           void operator= (const valarray<T>&) const;
           void operator*= (const valarray<T>&) const;
           void operator/= (const valarray<T>&) const;
           void operator%= (const valarray<T>&) const;
           void operator+= (const valarray<T>&) const;
           void operator−= (const valarray<T>&) const;
           void operator^= (const valarray<T>&) const;
           void operator&= (const valarray<T>&) const;
           void operator|= (const valarray<T>&) const;
           void operator<<=(const valarray<T>&) const;
           void operator>>=(const valarray<T>&) const;
           ~mask_array();
         private:
           mask_array();
           mask_array(const mask_array<T>&);
           mask_array& operator=(const mask_array<T>&);
           ...
       };
   }

Again, note that class mask_array<> is intended purely as an internal helper class and should be transparent to the user. Thus, all constructors and the assignment operator of class mask_array<> are private.

Objects of class indirect_array are created by using a valarray<size_t> as the index of a nonconstant valarray:

   namespace std {
       template<class T>
       class valarray {
         public:
          ...
          indirect_array<T> operator[] (const valarray<size_t>&);
          ...
       };
   }

The class indirect_array provides the following operations:

   namespace std {
       template <class T>
       class indirect_array {
         public:
          typedef T value_type;


          void operator= (const T&);
          void operator= (const valarray<T>&) const;
          void operator*= (const valarray<T>&) const;
          void operator/= (const valarray<T>&) const;
          void operator%= (const valarray<T>&) const;
          void operator+= (const valarray<T>&) const;
          void operator−= (const valarray<T>&) const;
          void operator~= (const valarray<T>&) const;
          void operator&= (const valarray<T>&) const;
          void operator|= (const valarray<T>&) const;
          void operator<<=(const valarray<T>&) const;
          void operator>>=(const valarray<T>&) const;
          ~indirect_array();
        private:
          indirect_array();
          indirect_array(const indirect_array<T>&);
          indirect_array& operator=(const indirect_array<T>&);
          ...
      };
   }

As usual, class indirect--array <> is intended purely as an internal helper class and should be transparent to the user. Thus, all constructors and the assignment operator of indirect_array<> are private.