cplusplus.com
C++ : Reference : Miscellaneous : valarray : valarray : valarray operators
 
cplusplus.com
Information
Documentation
Reference
Articles
Forum
Reference
C Library
IOstream Library
Strings library
STL Containers
STL Algorithms
Miscellaneous
Miscellaneous
complex
exception
functional
iterator
limits
locale
memory
new
numeric
stdexcept
typeinfo
utility
valarray
valarray
classes:
gslice
gslice_array
indirect_array
mask_array
slice
slice_array
valarray
global functions:
abs
acos
asin
atan
atan2
cos
cosh
exp
log
log10
pow
sin
sinh
sqrt
tan
tanh
valarray
valarray operators
valarray::valarray
valarray::~valarray
member functions:
valarray::apply
valarray::cshift
valarray::max
valarray::min
valarray::operator=
valarray::operator[]
valarray::resize
valarray::shift
valarray::size
valarray::sum


valarray operators

functions
*** valarray member functions
 ***
valarray<T> operator+() const;
valarray<T> operator-() const;
valarray<T> operator~() const;
valarray<bool> operator!() const;

valarray<T>& operator*= (const valarray<T>& rhs);
valarray<T>& operator/= (const valarray<T>& rhs);
valarray<T>& operator%= (const valarray<T>& rhs);
valarray<T>& operator+= (const valarray<T>& rhs);
valarray<T>& operator-= (const valarray<T>& rhs);
valarray<T>& operator^= (const valarray<T>& rhs);
valarray<T>& operator&= (const valarray<T>& rhs);
valarray<T>& operator|= (const valarray<T>& rhs);
valarray<T>& operator<<= (const valarray<T>& rhs);
valarray<T>& operator>>= (const valarray<T>& rhs);

valarray<T>& operator*= (const T& val);
valarray<T>& operator/= (const T& val);
valarray<T>& operator%= (const T& val);
valarray<T>& operator+= (const T& val);
valarray<T>& operator-= (const T& val);
valarray<T>& operator^= (const T& val);
valarray<T>& operator&= (const T& val);
valarray<T>& operator|= (const T& val);
valarray<T>& operator<<= (const T& val);
valarray<T>& operator>>= (const T& val);

*** global functions: ***
template <class T> valarray<T> operator* (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator* (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator* (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator/ (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator/ (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator/ (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator% (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator% (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator% (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator+ (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator+ (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator+ (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator- (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator- (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator- (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator^ (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator^ (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator^ (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator& (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator& (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator& (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator| (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator| (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator| (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator<< (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator<< (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator<< (const valarray<T>& lhs, const T& val);

template <class T> valarray<T> operator>> (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<T> operator>> (const T& val, const valarray<T>& rhs);
template <class T> valarray<T> operator>> (const valarray<T>& lhs, const T& val);

template <class T> valarray<bool> operator&& (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<bool> operator&& (const T& val, const valarray<T>& rhs);
template <class T> valarray<bool> operator&& (const valarray<T>& lhs, const T& val);

template <class T> valarray<bool> operator|| (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<bool> operator|| (const T& val, const valarray<T>& rhs);
template <class T> valarray<bool> operator|| (const valarray<T>& lhs, const T& val);

template <class T> valarray<bool> operator== (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<bool> operator== (const T& val, const valarray<T>& rhs);
template <class T> valarray<bool> operator== (const valarray<T>& lhs, const T& val);

template <class T> valarray<bool> operator!= (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<bool> operator!= (const T& val, const valarray<T>& rhs);
template <class T> valarray<bool> operator!= (const valarray<T>& lhs, const T& val);

template <class T> valarray<bool> operator< (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<bool> operator< (const T& val, const valarray<T>& rhs);
template <class T> valarray<bool> operator< (const valarray<T>& lhs, const T& val);

template <class T> valarray<bool> operator> (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<bool> operator> (const T& val, const valarray<T>& rhs);
template <class T> valarray<bool> operator> (const valarray<T>& lhs, const T& val);

template <class T> valarray<bool> operator<= (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<bool> operator<= (const T& val, const valarray<T>& rhs);
template <class T> valarray<bool> operator<= (const valarray<T>& lhs, const T& val);

template <class T> valarray<bool> operator>= (const valarray<T>& lhs, const valarray<T>& rhs);
template <class T> valarray<bool> operator>= (const T& val, const valarray<T>& rhs);
template <class T> valarray<bool> operator>= (const valarray<T>& lhs, const T& val);

Valarray operators

Each of this functions performs their respective operation on all the elements in the valarray.

When both the left-hand side argument and the right-side one are valarrays, the operation is performed between the corresponding elements in each array (the first element in the left with the first in the right, the second with the second, and so on...).

When one of the arguments is a value, the operation is applied to all the elements in the valarray against that value.

The class also overloads operator= and operator[] (see their corresponding references for more info).

Parameters

val
Value to use either as left-hand or right-hand operand agains all the elements in the valarray.
T is the template parameter of class valarray (i.e., its elements' type).
lhs
Left-hand side valarray object.
rhs
Right-hand side valarray object.

Return value

For the unary operators, a new valarray object with the modified values.
For the compund assignment operators, the left-hand side valarray object.
For the binary operators, a new valarray object with the results of performing the operation.
For the comparison operators, an array of bool elements with the result of the comparisons.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
// valarray operators example
#include <iostream>
#include <valarray>
using namespace std;

int main ()
{
  int init[]= {10,20,30,40};
                                //     foo:           bar:

  valarray<int> foo (init, 4);  //  10 20 30 40    
  valarray<int> bar (25,4);     //  10 20 30 40    25 25 25 25

  bar += foo;                   //  10 20 30 40    35 45 55 65

  foo = bar + 10;               //  45 55 65 75    35 45 55 65

  foo -= 10;                    //  35 45 55 65    35 45 55 65

  valarray<bool> comp = (foo==bar);

  if ( comp.min() == true )
	  cout << "They are equal.\n";
  else
	  cout << "They are not equal.\n";

  return 0;
}


Output:

They are equal.

See also

valarray::operator= Assign content (public member function )
valarray::operator[] Access element or subscript (public member function)