`<valarray>`, operatory

Artykuł
10/12/2023

`operator!=`

Sprawdza, czy odpowiednie elementy dwóch obiektów o równych rozmiarach valarray są nierówne, czy też wszystkie elementy obiektu valarray są nierówne do określonej wartości.

template <class Type>
valarray<bool>
operator!=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator!=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator!=(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
valarray Obiekt, którego elementy mają być testowane pod kątem nierówności względem innego valarray obiektu lub wartości typu elementu do porównania z każdym elementem valarrayw obiekcie .

right
valarray Obiekt, którego elementy mają być testowane pod kątem nierówności względem innego valarray obiektu lub wartości typu elementu do porównania z każdym elementem valarrayw obiekcie .

Wartość zwracana

A valarray wartości logicznych, z których każda jest:

true jeśli odpowiednie elementy są nierówne.
false jeśli odpowiednie elementy są równe.

Uwagi

Pierwszy operator szablonu zwraca obiekt klasy valarray<bool>, z których I każdy ma wartość left[I] != right[I].

Drugi operator szablonu przechowuje left[I] != right element .I

Trzeci operator szablonu przechowuje left != right[I] element I.

Przykład

// valarray_op_ne.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL != vaR );
   cout << "The element-by-element result of "
        << "the not equal comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the not equal comparison test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator%`

Uzyskuje pozostałą część dzielenia odpowiednich elementów dwóch obiektów o równym rozmiarze valarray lub dzielenia przez określoną wartość lub dzielenia valarray określonej wartości przez valarraywartość .

template <class Type>
valarray<Type>
operator%(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator%(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator%(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Wartość lub valarray która służy jako dywidenda, do której należy podzielić inną wartość lub valarray wartość.

right
Wartość lub valarray , która służy jako dzielnik i który dzieli inną wartość lub valarray.

Wartość zwracana

Element valarray , którego elementy są elementami mądre reszty left podzielone przez right.

Przykład

// valarray_op_rem.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 6 ), vaR ( 6 );
   valarray<int> vaREM ( 6 );
   for ( i = 0 ; i < 6 ; i += 2 )
      vaL [ i ] =  53;
   for ( i = 1 ; i < 6 ; i += 2 )
      vaL [ i ] =  -67;
   for ( i = 0 ; i < 6 ; i++ )
      vaR [ i ] =  3*i+1;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaREM = ( vaL % vaR );
   cout << "The remainders from the element-by-element "
        << "division is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaREM [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 53 -67 53 -67 53 -67 ).
The initial Right valarray is: ( 1 4 7 10 13 16 ).
The remainders from the element-by-element division is the
valarray: ( 0 -3 4 -7 1 -3 ).

`operator&`

Uzyskuje bitowe wartości AND między odpowiednimi elementami dwóch obiektów o równym rozmiarze valarray lub między a valarray określoną wartością typu elementu.

template <class Type>
valarray<Type>
operator&(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator&(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator&(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z bitową wartością AND lub określoną wartością typu elementu, która ma być połączona bitowo AND z każdym elementem valarray.

right
Drugi z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z bitowym elementem AND, lub określoną wartością typu elementu, które mają być łączone bitowo AND z każdym elementem valarray.

Wartość zwracana

A valarray , których elementy są elementami mądrą kombinacją bitowej operacji AND operacji left i right.

Uwagi

Operację bitową można używać tylko do manipulowania bitami w char typach danych i int typach danych i wariantach, a nie na floattypach danych , , doublelong double, , voidbool lub innych, bardziej złożonych typach danych.

Bitowa tabela AND ma tę samą tabelę prawdy co logiczne AND, ale ma zastosowanie do typu danych na poziomie poszczególnych bitów. Element operator&& ma zastosowanie na poziomie elementu, zliczając wszystkie wartości inne niżzerowe jako true, a wynik jest wartościami valarray logicznymi. Bitowe and operator&, z kolei, może spowodować valarray wartości inne niż 0 lub 1, w zależności od wyniku operacji bitowej.

Przykład

// valarray_op_bitand.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaBWA ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i+1;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaBWA = ( vaL & vaR );
   cout << "The element-by-element result of "
        << "the bitwise operator & is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaBWA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 0 2 0 4 0 6 0 8 0 10 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the bitwise operator & is the
valarray: ( 0 0 0 0 0 4 0 0 0 8 ).

`operator&&`

Uzyskuje wartość logiczną AND między odpowiednimi elementami dwóch obiektów o równym rozmiarze valarray lub między a valarray określoną wartością valarray typu elementu.

template <class Type>
valarray<bool>
operator&&(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator&&(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator&&(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z logicznym AND, lub określoną wartością typu elementu do połączenia z każdym elementem valarrayelementu .

Prawo
Drugi z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z logicznym AND, lub określoną wartością typu elementu do połączenia z każdym elementem elementu valarray.

Wartość zwracana

Element valarray , którego elementy są typu bool i są mądrą kombinacją logicznej left operacji AND i right.

Uwagi

Wartość logiczna AND operator&& ma zastosowanie na poziomie elementu, zliczając wszystkie wartości inne niżzerowe jako true, a wynik jest wartościami logicznymi valarray . Bitowa wersja AND, operator&z kolei, może spowodować valarray wartości inne niż 0 lub 1, w zależności od wyniku operacji bitowej.

Przykład

// valarray_op_logand.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaLAA ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is:  ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaLAA = ( vaL && vaR );
   cout << "The element-by-element result of "
        << "the logical AND operator&& is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 0 0 0 2 0 4 0 6 0 8 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the logical AND operator&& is the
valarray: ( 0 0 0 1 0 1 0 1 0 1 ).

`operator>`

Sprawdza, czy elementy jednego valarray elementu są większe niż elementy o takim samym rozmiarze valarray, czy też wszystkie elementy valarray elementu są większe lub mniejsze niż określona wartość.

template <class Type>
valarray<bool>
operator>(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator>(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator>(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których elementy mają być porównywane, lub określona wartość do porównania z każdym elementem valarrayobiektu .

right
Drugi z dwóch valarray obiektów, których elementy mają być porównywane, lub określona wartość do porównania z każdym elementem valarrayelementu .

Wartość zwracana

A valarray wartości logicznych, z których każda jest:

trueleft jeśli element lub wartość jest większa niż odpowiadający mu right element lub wartość.
falseleft jeśli element lub wartość nie jest większa niż odpowiedni right element lub wartość.

Uwagi

Jeśli liczba elementów w dwóch valarray obiektach nie jest równa, wynik jest niezdefiniowany.

Przykład

// valarray_op_gt.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i - 1;

   cout << "The initial Left valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL > vaR );
   cout << "The element-by-element result of "
        << "the greater than comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the greater than comparison test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator>=`

Sprawdza, czy elementy jednego valarray elementu są większe lub równe elementom o takim samym rozmiarze valarray, czy też wszystkie elementy valarray elementu są większe lub równe lub mniejsze lub równe określonej wartości.

template <class Type>
valarray<bool>
operator>=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator>=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator>=(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których elementy mają być porównywane, lub określona wartość do porównania z każdym elementem valarrayobiektu .

right
Drugi z dwóch valarray obiektów, których elementy mają być porównywane, lub określona wartość do porównania z każdym elementem valarrayelementu .

Wartość zwracana

A valarray wartości logicznych, z których każda jest:

trueleft jeśli element lub wartość jest większa lub równa odpowiadającemu mu right elementowi lub wartości.
falseleft jeśli element lub wartość jest mniejsza niż odpowiedni right element lub wartość.

Uwagi

Jeśli liczba elementów w dwóch valarray obiektach nie jest równa, wynik jest niezdefiniowany.

Przykład

// valarray_op_ge.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i - 1;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL >= vaR );
   cout << "The element-by-element result of "
        << "the greater than or equal test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the greater than or equal test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator>>`

Przesuwa bity w prawo dla każdego elementu valarray określonej liczby pozycji lub przez liczbę elementów mądry określoną przez sekundę valarray.

template <class Type>
valarray<Type>
operator>>(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator>>(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator>>(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Wartość, która ma zostać przesunięta lub valarray których elementy mają zostać przesunięte.

right
Wartość wskazująca ilość przesunięcia w prawo lub valarray którego elementy wskazują na liczbę elementów z prawej strony.

Wartość zwracana

Element valarray , którego elementy zostały przesunięte w prawo o określoną kwotę.

Uwagi

Podpisane numery mają swoje znaki zachowane.

Przykład

// valarray_op_rs.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  64;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -64;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL >> vaR );
   cout << "The element-by-element result of "
        << "the right shift is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 64 -64 64 -64 64 -64 64 -64 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the right shift is the
valarray: ( 64 -32 16 -8 4 -2 1 -1 ).

`operator<`

Sprawdza, czy elementy jednego valarray są mniejsze niż elementy o takim samym rozmiarze valarray, czy też wszystkie elementy valarray elementu są większe lub mniejsze niż określona wartość.

template <class Type>
valarray<bool>
operator<(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator<(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator<(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których elementy mają być porównywane, lub określona wartość do porównania z każdym elementem valarrayobiektu .

right
Drugi z dwóch valarray obiektów, których elementy mają być porównywane, lub określona wartość do porównania z każdym elementem valarrayelementu .

Wartość zwracana

A valarray wartości logicznych, z których każda jest:

trueleft jeśli element lub wartość jest mniejsza niż odpowiedni right element lub wartość.
falseleft jeśli element lub wartość nie jest mniejsza niż odpowiedni right element lub wartość.

Uwagi

Jeśli liczba elementów w dwóch valarray obiektach nie jest równa, wynik jest niezdefiniowany.

Przykład

// valarray_op_lt.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL < vaR );
   cout << "The element-by-element result of "
        << "the less-than comparison test is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the less-than comparison test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator<=`

Sprawdza, czy elementy jednego valarray są mniejsze lub równe elementom o takim samym rozmiarze valarray, czy też wszystkie elementy elementu valarray są większe lub równe lub mniejsze lub równe określonej wartości.

template <class Type>
valarray<bool>
operator<=(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator<=(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator<=(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których elementy mają być porównywane, lub określona wartość do porównania z każdym elementem valarrayobiektu .

right
Drugi z dwóch valarray obiektów, których elementy mają być porównywane, lub określona wartość do porównania z każdym elementem valarrayelementu .

Wartość zwracana

A valarray wartości logicznych, z których każda jest:

trueleft jeśli element lub wartość jest mniejsza lub równa odpowiadającemu mu right elementowi lub wartości.
falseleft jeśli element lub wartość jest większa niż odpowiadający mu right element lub wartość.

Uwagi

Jeśli liczba elementów w dwóch valarray obiektach nie jest równa, wynik jest niezdefiniowany.

Przykład

// valarray_op_le.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i - 1;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL <= vaR );
   cout << "The element-by-element result of "
        << "the less than or equal test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( -1 0 1 2 3 4 5 6 7 8 ).
The element-by-element result of the less than or equal test is the
valarray: ( 0 0 1 0 1 0 1 0 1 0 ).

`operator<<`

Lewe przesunięcie bitów dla każdego elementu valarray określonej liczby pozycji lub przez liczbę elementów mądry określonej przez sekundę valarray.

template <class Type>
valarray<Type>
operator<<(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator<<(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator<<(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Wartość, która ma zostać przesunięta lub valarray których elementy mają zostać przesunięte.

right
Wartość wskazująca ilość przesunięcia w lewo lub valarray , których elementy wskazują mądry element przesunięcia w lewo.

Wartość zwracana

Element valarray , którego elementy zostały przesunięte w lewo o określoną kwotę.

Uwagi

Podpisane numery mają swoje znaki zachowane.

Przykład

// valarray_op_ls.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  1;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL << vaR );
   cout << "The element-by-element result of "
        << "the left shift is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 1 -1 1 -1 1 -1 1 -1 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the left shift is the
valarray: ( 1 -2 4 -8 16 -32 64 -128 ).

`operator*`

Uzyskuje produkt mądry element między odpowiednimi elementami dwóch obiektów o równym rozmiarze valarray lub między wartością a valarray określoną.

template <class Type>
valarray<Type>
operator*(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator*(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator*(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których elementy mają zostać pomnożone, lub określona wartość, która ma zostać pomnożona z każdym elementem valarrayobiektu .

right
Druga z dwóch valarray obiektów, których elementy mają być mnożone, lub określona wartość, która ma zostać pomnożona z każdym elementem valarrayobiektu .

Wartość zwracana

A valarray , których elementy są elementami mądry produkt i leftright.

Przykład

// valarray_op_eprod.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  2;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL * vaR );
   cout << "The element-by-element result of "
        << "the multiplication is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 2 -1 2 -1 2 -1 2 -1 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the multiplication is the
valarray: ( 0 -1 4 -3 8 -5 12 -7 ).

`operator+`

Uzyskuje sumę mądry elementów między odpowiednimi elementami dwóch obiektów o równych rozmiarach valarray lub między a valarray określoną wartością.

template <class Type>
valarray<Type>
operator+(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator+(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator+(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których elementy mają zostać dodane, lub określona wartość do dodania z każdym elementem obiektu valarray.

right
Drugi z dwóch valarray obiektów, których elementy mają zostać dodane, lub określona wartość do dodania z każdym elementem valarrayobiektu .

Wartość zwracana

Element valarray , którego elementy są sumą left elementów i right.

Przykład

// valarray_op_esum.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  2;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL + vaR );
   cout << "The element-by-element result of "
        << "the sum is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 2 -1 2 -1 2 -1 2 -1 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the sum is the
valarray: ( 2 0 4 2 6 4 8 6 ).

`operator-`

Uzyskuje mądry różnicę między odpowiednimi elementami dwóch obiektów o równych rozmiarach valarray lub między a valarray określoną wartością.

template <class Type>
valarray<Type>
operator-(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator-(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator-(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Wartość lub valarray która służy jako minuend, wartość, z której mają być odejmowane inne wartości lub valarray obiekty w tworzeniu różnicy.

right
Wartość lub valarray która służy jako odejmowana, wartość, która ma zostać odejmowana od innych wartości lub valarray obiektów tworząc różnicę.

Wartość zwracana

Element valarray , którego elementy są mądrą left różnicą elementów i right.

Uwagi

Terminologia arytmetyczna używana podczas opisywania odejmowania:

difference = minuend - subtrahend

Przykład

// valarray_op_ediff.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   valarray<int> vaNE ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  10;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL - vaR );
   cout << "The element-by-element result of "
        << "the difference is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 10 0 10 0 10 0 10 0 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the difference is the
valarray: ( 10 -1 8 -3 6 -5 4 -7 ).

`operator/`

Uzyskuje iloraz mądry elementu między odpowiednimi elementami dwóch obiektów o równym rozmiarze valarray lub między a valarray określoną wartością.

template <class Type>
valarray<Type>
operator/(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator/(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator/(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Wartość lub valarray która służy jako dywidenda, do której należy podzielić inną wartość lub valarray jest podzielona w tworzeniu ilorazu.

right
Wartość lub valarray , która służy jako dzielnik, i która dzieli inną wartość lub valarray tworząc iloraz.

Wartość zwracana

Element valarray , którego elementy są ilorazem mądrym dzielenia left przez rightelement .

Uwagi

Terminologia arytmetyczna używana podczas opisywania podziału:

quotient = dywidenda / dzielnika

Przykład

// valarray_op_equo.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<double> vaL ( 6 ), vaR ( 6 );
   valarray<double> vaNE ( 6 );
   for ( i = 0 ; i < 6 ; i += 2 )
      vaL [ i ] =  100;
   for ( i = 1 ; i < 6 ; i += 2 )
      vaL [ i ] =  -100;
   for ( i = 0 ; i < 6 ; i++ )
      vaR [ i ] =  2*i;

   cout << "The initial Left valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL / vaR );
   cout << "The element-by-element result of "
        << "the quotient is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 100 -100 100 -100 100 -100 ).
The initial Right valarray is: ( 0 2 4 6 8 10 ).
The element-by-element result of the quotient is the
valarray: ( inf -50 25 -16.6667 12.5 -10 ).

`operator==`

Sprawdza, czy odpowiednie elementy dwóch obiektów o równym rozmiarze valarray są równe, czy też wszystkie elementy elementu valarray są równe określonej wartości.

template <class Type>
valarray<bool>
operator==(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator==(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator==(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których elementy mają być testowane pod kątem równości, lub określona wartość do porównania z każdym valarray elementem.

right
Drugi z dwóch valarray obiektów, których elementy mają być testowane pod kątem równości, lub określona wartość do porównania z każdym valarray elementem.

Wartość zwracana

A valarray wartości logicznych, z których każda jest:

true jeśli odpowiednie elementy są równe.
false jeśli odpowiednie elementy nie są równe.

Uwagi

Pierwszy operator szablonu zwraca obiekt klasy valarray<bool>, z których I każdy ma wartość left[I] == right[I]. Drugi operator szablonu przechowuje left[I] == right element .I Trzeci operator szablonu przechowuje left == right[I] element I.

Przykład

// valarray_op_eq.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaNE ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial Left valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaNE = ( vaL == vaR );
   cout << "The element-by-element result of "
        << "the equality comparison test is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNE [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is: ( 0 1 -2 3 -4 5 -6 7 -8 9 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the equality comparison test is the
valarray: ( 1 1 0 1 0 1 0 1 0 1 ).

`operator^`

Uzyskuje bitowo wyłączny OR (XOR) między odpowiednimi elementami dwóch obiektów o równym rozmiarze valarray lub między a valarray określoną wartością typu elementu.

template <class Type>
valarray<Type>
operator^(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator^(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator^(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z bitowym XOR lub określoną wartością typu elementu, które mają być łączone przez bitowy XOR z każdym elementem valarray.

right
Drugi z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z bitowym XOR lub określoną wartością typu elementu, które mają być łączone przez bitowy XOR z każdym elementem valarray.

Wartość zwracana

Element valarray , którego elementy są elementami mądre kombinacji bitowej operacji XOR operacji left i right.

Uwagi

Bitowe wyłączne OR (XOR) ma następujące semantyki: Biorąc pod uwagę bity b1 i b2, b1 XOR b2 jest 1, jeśli dokładnie jeden z bitów wynosi 1; 0, jeśli oba bity są 0 lub jeśli oba bity są 1.

Przykład

// valarray_op_xor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaLAA ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  1;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;

   cout << "The initial Left valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaLAA = ( vaL ^ vaR );
   cout << "The element-by-element result of "
        << "the bitwise XOR operator^ is the\n"
        << "valarray: ( ";
           for ( i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 1 0 1 0 1 0 1 0 1 0 ).
The initial Right valarray is: ( 0 0 1 3 3 4 6 6 7 9 ).
The element-by-element result of the bitwise XOR operator^ is the
valarray: ( 1 0 0 3 2 4 7 6 6 9 ).

`operator|`

Uzyskuje bitowe OR między odpowiednimi elementami dwóch obiektów o równych rozmiarach valarray lub między a valarray określoną wartością typu elementu.

template <class Type>
valarray<Type>
operator|(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<Type>
operator|(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<Type>
operator|(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z bitowym OR lub określoną wartością typu elementu, które mają być łączone bitowo OR z każdym elementem valarray.

right
Drugi z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z bitowym OR lub określoną wartością typu elementu, które mają być połączone bitowo OR z każdym elementem valarray.

Wartość zwracana

Element valarray , którego elementy są elementami mądrą kombinacją bitowej operacji OR operacji left i right.

Uwagi

Bitowa tabela OR ma tę samą tabelę prawdy co logiczny OR, ale ma zastosowanie do typu danych na poziomie poszczególnych bitów. Biorąc pod uwagę bity b1 i b2, b1 LUB b2 jest 1, jeśli co najmniej jeden z bitów wynosi 1, lub 0, jeśli oba bity są 0. Wartość logiczna OR operator|| ma zastosowanie na poziomie elementu, zliczając wszystkie wartości inne niżzerowe jako true, a wynik jest wartościami valarray logicznymi. Bitowe or operator|, z kolei, może spowodować valarray wartości inne niż 0 lub 1, w zależności od wyniku operacji bitowej.

Przykład

// valarray_op_bitor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<int> vaLAA ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  1;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;

   cout << "The initial Left valarray is:  ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaLAA = ( vaL | vaR );
   cout << "The element-by-element result of "
        << "the bitwise OR operator| is the\n"
        << "valarray: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaLAA [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 1 0 1 0 1 0 1 0 1 0 ).
The initial Right valarray is: ( 0 0 1 3 3 4 6 6 7 9 ).
The element-by-element result of the bitwise OR operator| is the
valarray: ( 1 0 1 3 3 4 7 6 7 9 ).

`operator||`

Uzyskuje wartość logiczną OR między odpowiednimi elementami dwóch obiektów o równym rozmiarze valarray lub między a valarray określoną wartością valarray typu elementu.

template <class Type>
valarray<bool>
operator||(
    const valarray<Type>& left,
    const valarray<Type>& right);

template <class Type>
valarray<bool>
operator||(
    const valarray<Type>& left,
    const Type& right);

template <class Type>
valarray<bool>
operator||(
    const Type& left,
    const valarray<Type>& right);

Parametry

left
Pierwszy z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z logicznym OR lub określoną wartością typu elementu, które mają być łączone z każdym elementem valarrayobiektu .

right
Drugi z dwóch valarray obiektów, których odpowiednie elementy mają być łączone z logicznym OR lub określoną wartością typu elementu do połączenia z każdym elementem valarrayelementu .

Wartość zwracana

Element valarray , którego elementy są typu bool i są mądrą kombinacją logicznej operacji OR i leftright.

Uwagi

Wartość logiczna OR operator|| ma zastosowanie na poziomie elementu, zliczając wszystkie wartości inne niżzerowe jako true, a wynik jest wartościami valarray logicznymi. Bitowa wersja OR, operator|natomiast , może spowodować valarray wartość inną niż 0 lub 1, w zależności od wyniku operacji bitowej.

Przykład

// valarray_op_logor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   valarray<bool> vaLOR ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  0;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  0;

   cout << "The initial Left valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaLOR = ( vaL || vaR );
   cout << "The element-by-element result of "
        << "the logical OR operator|| is the\n"
        << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaLOR [ i ] << " ";
   cout << ")." << endl;
}

The initial Left valarray is:  ( 0 0 0 2 0 4 0 6 0 8 ).
The initial Right valarray is: ( 0 0 0 3 0 0 6 0 0 9 ).
The element-by-element result of the logical OR operator|| is the
valarray: ( 0 0 0 1 0 1 1 1 0 1 ).

<valarray>, operatory

operator!=

Parametry

Wartość zwracana

Uwagi

Przykład

operator%

Parametry

Wartość zwracana

Przykład

operator&

Parametry

Wartość zwracana

Uwagi

Przykład

operator&&

Parametry

Wartość zwracana

Uwagi

Przykład

operator>

Parametry

Wartość zwracana

Uwagi

Przykład

operator>=

Parametry

Wartość zwracana

Uwagi

Przykład

operator>>

Parametry

Wartość zwracana

Uwagi

Przykład

operator<

Parametry

Wartość zwracana

Uwagi

Przykład

operator<=

Parametry

Wartość zwracana

Uwagi

Przykład

operator<<

Parametry

Wartość zwracana

Uwagi

Przykład

operator*

Parametry

Wartość zwracana

Przykład

operator+

Parametry

Wartość zwracana

Przykład

operator-

Parametry

Wartość zwracana

Uwagi

Przykład

operator/

Parametry

Wartość zwracana

Uwagi

Przykład

operator==

Parametry

Wartość zwracana

Uwagi

Przykład

operator^

Parametry

Wartość zwracana

Uwagi

Przykład

operator|

Parametry

`<valarray>`, operatory

`operator!=`

`operator%`

`operator&`

`operator&&`

`operator>`

`operator>=`

`operator>>`

`operator<`

`operator<=`

`operator<<`

`operator*`

`operator+`

`operator-`

`operator/`

`operator==`

`operator^`

`operator|`

`operator||`