`<valarray>` – operátory

`operator!=`

Testuje, zda jsou odpovídající prvky dvou objektů stejné velikosti valarray nerovné, nebo zda jsou všechny prvky objektu valarray nerovné se zadanou hodnotou.

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
Objekt valarray , jehož prvky mají být testovány na nerovnosti proti jinému valarray objektu, nebo hodnotu typu elementu porovnat s každým prvkem v objektu valarray.

right
Objekt valarray , jehož prvky mají být testovány na nerovnosti proti jinému valarray objektu, nebo hodnotu typu elementu porovnat s každým prvkem v objektu valarray.

Vrácená hodnota

A valarray logických hodnot, z nichž každá je:

true jsou-li odpovídající prvky nerovné.
false pokud jsou odpovídající prvky stejné.

Poznámky

První operátor šablony vrátí objekt třídy valarray<bool>, každý z jehož prvků I je left[I] != right[I].

Druhý operátor šablony je uložen left[I] != right v elementu I.

Třetí operátor šablony ukládá left != right[I] v elementu I.

Příklad

// 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%`

Získá zbytek dělení odpovídajících prvků dvou objektů stejné velikosti valarray , nebo dělení valarray podle zadané hodnoty nebo dělení zadané hodnoty hodnotou 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
Hodnota nebo valarray která slouží jako dividenda, do které se má dělit jiná hodnota nebo valarray se má dělit.

right
Hodnota nebo valarray která slouží jako dělitel a která rozděluje jinou hodnotu nebo valarray.

Vrácená hodnota

Avalarray, jehož prvky jsou zbytek prvku-moudrý dělený rightleft .

Příklad

// 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&`

Získá bitový operátor AND mezi odpovídajícími prvky dvou objektů stejné velikosti valarray nebo mezi valarray a zadanou hodnotou typu prvku.

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
První ze dvou valarray objektů, jejichž odpovídající prvky mají být kombinovány s bitovou and, nebo zadanou hodnotu typu prvku, které mají být sloučeny bitovou bitové A s každým prvkem .valarray

right
Druhý ze dvou valarray objektů, jejichž příslušné prvky mají být kombinovány s bitovou and, nebo zadanou hodnotu typu prvku, která má být sloučena bitovou bitovým operátorem AND s každým prvkem .valarray

Návratová hodnota

A valarray , jehož prvky jsou prvek-moudrý kombinace bitové AND operace left a right.

Poznámky

Bitovou operaci lze použít pouze k manipulaci s bity v char datových typech a int variantách a nikoli na float, double, , long double, voidbool nebo jiných, složitějších datových typech.

Bitový operátor AND má stejnou tabulku pravdy jako logický operátor AND, ale vztahuje se na datový typ na úrovni jednotlivých bitů. Platí operator&& na úrovni prvku, počítá všechny nenulové hodnoty jako truea výsledkem je valarray logická hodnota. Bitový operátor AND operator&naproti tomu může mít za následek jinou valarray hodnotu než 0 nebo 1 v závislosti na výsledku bitové operace.

Příklad

// 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&&`

Získá logickou hodnotu AND mezi odpovídajícími prvky dvou objektů stejné velikosti valarray nebo mezi valarray a zadanou hodnotou valarray typu prvku.

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
První ze dvou valarray objektů, jejichž příslušné prvky mají být kombinovány s logickou and, nebo zadanou hodnotu typu prvku, která má být sloučena s každým prvkem valarrayprvku .

Vpravo
Druhý ze dvou valarray objektů, jejichž příslušné prvky mají být kombinovány s logickou and, nebo zadanou hodnotu typu prvku, které mají být kombinovány s každým prvkem objektu valarray.

Vrácená hodnota

A valarray , jehož prvky jsou typu bool a jsou kombinací logické operace left AND a right.

Poznámky

Logický operátor AND operator&& se použije na úrovni prvku, počítá všechny nenulové hodnoty jako truea výsledkem je valarray logická hodnota. Bitová verze funkce AND naopak operator&může mít za následek jinou valarray hodnotu než 0 nebo 1 v závislosti na výsledku bitové operace.

Příklad

// 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>`

Testuje, zda jsou prvky jednoho valarray větší než prvky stejné velikosti valarray, nebo zda jsou všechny prvky určitého valarray prvku větší nebo menší než zadaná hodnota.

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
První ze dvou valarray objektů, jejichž prvky mají být porovnány, nebo zadanou hodnotu, která se má porovnat s každým prvkem objektu valarray.

right
Druhá ze dvou valarray objektů, jejichž prvky mají být porovnány, nebo zadanou hodnotu, která se má porovnat s každým prvkem objektu valarray.

Vrácená hodnota

A valarray logických hodnot, z nichž každá je:

trueleft pokud je prvek nebo hodnota větší než odpovídající right prvek nebo hodnota.
falseleft pokud prvek nebo hodnota není větší než odpovídající right prvek nebo hodnota.

Poznámky

Pokud počet prvků ve dvou valarray objektech není roven, výsledek není definován.

Příklad

// 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>=`

Testuje, zda jsou prvky jednoho valarray prvku větší než nebo rovno prvkům stejné velikosti valarray, nebo zda jsou všechny prvky valarray určitého prvku větší nebo rovno nebo menší než nebo rovno zadané hodnotě.

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
První ze dvou valarray objektů, jejichž prvky mají být porovnány, nebo zadanou hodnotu, která se má porovnat s každým prvkem objektu valarray.

right
Druhá ze dvou valarray objektů, jejichž prvky mají být porovnány, nebo zadanou hodnotu, která se má porovnat s každým prvkem objektu valarray.

Vrácená hodnota

A valarray logických hodnot, z nichž každá je:

trueleft pokud je prvek nebo hodnota větší nebo rovna odpovídajícímu right prvku nebo hodnotě.
falseleft pokud je prvek nebo hodnota menší než odpovídající right prvek nebo hodnota.

Poznámky

Pokud počet prvků ve dvou valarray objektech není stejný, výsledek není definován.

Příklad

// 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>>`

Posune bity pro každý prvek zadaného valarray počtu pozic pravým tlačítkem myši nebo o množství prvku určeného sekundou 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
Hodnota, která se má posunout, nebo valarray jejíž prvky mají být posunuty.

right
Hodnota označující velikost pravého posunu nebo valarray jehož prvky označují množství pravého posunu.

Vrácená hodnota

A valarray jehož prvky byly posunuty doprava o zadanou částku.

Poznámky

Znaménka mají zachované značky.

Příklad

// 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<`

Testuje, zda jsou prvky jednoho valarray menší než prvky stejné velikosti valarray, nebo zda jsou všechny prvky určitého valarray prvku větší nebo menší než zadaná hodnota.

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
První ze dvou valarray objektů, jejichž prvky mají být porovnány, nebo zadanou hodnotu, která se má porovnat s každým prvkem objektu valarray.

right
Druhá ze dvou valarray objektů, jejichž prvky mají být porovnány, nebo zadanou hodnotu, která se má porovnat s každým prvkem objektu valarray.

Vrácená hodnota

A valarray logických hodnot, z nichž každá je:

trueleft pokud je prvek nebo hodnota menší než odpovídající right prvek nebo hodnota.
falseleft pokud prvek nebo hodnota není menší než odpovídající right prvek nebo hodnota.

Poznámky

Pokud počet prvků ve dvou valarray objektech není stejný, výsledek není definován.

Příklad

// 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<=`

Testuje, zda jsou prvky jednoho valarray prvku menší nebo rovno prvkům stejné velikosti valarray, nebo zda jsou všechny prvky valarray určitého prvku větší nebo rovno nebo menší než nebo rovno zadané hodnotě.

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
První ze dvou valarray objektů, jejichž prvky mají být porovnány, nebo zadanou hodnotu, která se má porovnat s každým prvkem objektu valarray.

right
Druhá ze dvou valarray objektů, jejichž prvky mají být porovnány, nebo zadanou hodnotu, která se má porovnat s každým prvkem objektu valarray.

Vrácená hodnota

A valarray logických hodnot, z nichž každá je:

trueleft pokud je prvek nebo hodnota menší nebo rovna odpovídajícímu right prvku nebo hodnotě.
falseleft pokud je prvek nebo hodnota větší než odpovídající right prvek nebo hodnota.

Poznámky

Pokud počet prvků ve dvou valarray objektech není stejný, výsledek není definován.

Příklad

// 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<<`

Levý posune bity pro každý prvek zadaného valarray počtu pozic, nebo o množství moudrého prvku určeného sekundou 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
Hodnota, která se má posunout, nebo valarray jejíž prvky mají být posunuty.

right
Hodnota označující množství levého posunu nebo valarray jehož prvky označují množství levého posunu.

Vrácená hodnota

A valarray , jehož prvky byly posunuty o zadanou částku.

Poznámky

Znaménka mají zachované značky.

Příklad

// 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*`

Získá prvek-moudrý součin mezi odpovídajícími prvky dvou stejně velkých valarray objektů, nebo mezi valarray a zadanou hodnotou.

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
První ze dvou valarray objektů, jejichž prvky mají být vynásobeny, nebo zadanou hodnotu, která se má vynásobit každým prvkem objektu valarray.

right
Druhý ze dvou valarray objektů, jejichž prvky mají být vynásobeny, nebo zadanou hodnotu, která má být vynásobena každým prvkem objektu valarray.

Vrácená hodnota

A valarray , jehož prvky jsou prvek-moudrý left součin a right.

Příklad

// 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+`

Získá součet prvku mezi odpovídajícími prvky dvou objektů stejné velikosti valarray nebo mezi valarray a zadanou hodnotou.

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
První ze dvou valarray objektů, jejichž prvky mají být přidány, nebo zadanou hodnotu, která má být přidána s každým prvkem objektu valarray.

right
Druhý ze dvou valarray objektů, jejichž prvky mají být přidány, nebo zadanou hodnotu, která má být přidána s každým prvkem objektu valarray.

Vrácená hodnota

A valarray , jehož prvky jsou prvek-moudrý left součet a right.

Příklad

// 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-`

Získá rozdíl mezi odpovídajícími prvky dvou objektů stejné velikosti valarray nebo mezi valarray a zadanou hodnotou.

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
Hodnota, valarray která slouží jako minuend, hodnota, ze které se mají odečíst jiné hodnoty nebo valarray objekty při vytváření rozdílu.

right
Hodnota, valarray která slouží jako subtrahend, hodnota, která se má odečíst od jiných hodnot nebo valarray objektů při vytváření rozdílu.

Vrácená hodnota

A valarray , jejichž prvky jsou element-moudrý rozdíl left a right.

Poznámky

Aritmetická terminologie použitá při popisu odčítání:

difference = minuend - subtrahend

Příklad

// 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/`

Získá podíl prvku moudrý mezi odpovídajícími prvky dvou stejně velkých valarray objektů nebo mezi valarray a zadanou hodnotou.

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
Hodnota nebo valarray která slouží jako dividenda, do které se má dělit jiná hodnota nebo valarray je rozdělena do vytvoření podílu.

right
Hodnota, která valarray slouží jako dělitel a která rozděluje jinou hodnotu nebo valarray při tvorbě podílu.

Vrácená hodnota

A valarray jehož prvky jsou element-moudrý left podíl děleno right.

Poznámky

Aritmetická terminologie použitá při popisu dělení:

quotient = dividenda / dělitel

Příklad

// 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==`

Testuje, zda jsou odpovídající prvky dvou objektů stejné velikosti valarray stejné, nebo zda jsou všechny prvky valarray rovny zadané hodnotě.

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
První ze dvou valarray objektů, jejichž prvky mají být testovány na rovnost, nebo zadanou hodnotu, která se má porovnat s každým valarray prvkem.

right
Druhý ze dvou valarray objektů, jejichž prvky mají být testovány pro rovnost, nebo zadanou hodnotu pro porovnání s každým valarray prvkem.

Návratová hodnota

A valarray logických hodnot, z nichž každá je:

true pokud jsou odpovídající prvky stejné.
false pokud odpovídající prvky nejsou stejné.

Poznámky

První operátor šablony vrátí objekt třídy valarray<bool>, každý z jehož prvků I je left[I] == right[I]. Druhý operátor šablony je uložen left[I] == right v elementu I. Třetí operátor šablony ukládá left == right[I] v elementu I.

Příklad

// 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^`

Získá bitové výhradní OR (XOR) mezi odpovídajícími prvky dvou stejně velkých valarray objektů nebo mezi valarray a zadanou hodnotou typu prvku.

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
První ze dvou valarray objektů, jejichž odpovídající prvky mají být kombinovány s bitovou XOR, nebo zadanou hodnotu typu prvku, která má být sloučena bitovou XOR s každým prvkem objektu valarray.

right
Druhý ze dvou valarray objektů, jejichž odpovídající prvky mají být kombinovány s bitovou XOR, nebo zadanou hodnotu typu prvku, které mají být sloučeny bitovou XOR s každým prvkem prvku valarray.

Vrácená hodnota

A valarray , jehož prvky jsou prvek-moudrý kombinace bitové XOR operace left a right.

Poznámky

Bitové exkluzivní or (XOR) má následující sémantiku: Dané bity b1 a b2, b1 XOR b2 je 1, pokud přesně jeden z bitů je 1; 0, pokud jsou oba bity 0 nebo pokud jsou oba bity 1.

Příklad

// 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|`

Získá bitové OR mezi odpovídajícími prvky dvou objektů stejné velikosti valarray nebo mezi valarray a zadanou hodnotou typu prvku.

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
První ze dvou valarray objektů, jejichž příslušné prvky mají být kombinovány s bitovou or, nebo zadanou hodnotu typu prvku, které mají být sloučeny bitovou bitové OR s každým prvkem prvku valarray.

right
Druhá ze dvou valarray objektů, jejichž odpovídající prvky mají být kombinovány s bitovou or, nebo zadanou hodnotu typu prvku, která má být sloučena bitovou bitové OR s každým prvkem prvku valarray.

Vrácená hodnota

A valarray , jehož prvky jsou prvek-moudrá kombinace bitové OR operace left a right.

Poznámky

Bitový operátor OR má stejnou tabulku pravdy jako logická hodnota OR, ale vztahuje se na datový typ na úrovni jednotlivých bitů. Dané bity b1 a b2, b1 NEBO b2 je 1, pokud alespoň jeden z bitů je 1, nebo 0, pokud jsou oba bity 0. Logický operátor OR operator|| se použije na úrovni prvku, počítá všechny nenulové hodnoty jako truea výsledkem je valarray logická hodnota. Bitový operátor OR operator|naopak může mít za následek jinou valarray hodnotu než 0 nebo 1 v závislosti na výsledku bitové operace.

Příklad

// 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||`

Získá logickou hodnotu OR mezi odpovídajícími prvky dvou objektů stejné velikosti valarray nebo mezi valarray a zadanou hodnotou valarray typu prvku.

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
První ze dvou valarray objektů, jejichž příslušné prvky mají být kombinovány s logickou or, nebo zadanou hodnotu typu prvku, která má být kombinována s každým prvkem prvku valarray.

right
Druhý ze dvou valarray objektů, jejichž příslušné prvky mají být kombinovány s logickou or, nebo zadanou hodnotu typu prvku, která má být sloučena s každým prvkem prvku valarray.

Vrácená hodnota

A valarray , jejichž prvky jsou typu bool a jsou prvek-moudrá kombinace logické OR operace left a right.

Poznámky

Logický operátor OR operator|| se použije na úrovni prvku, počítá všechny nenulové hodnoty jako truea výsledkem je valarray logická hodnota. Bitové verze OR, operator|naproti tomu může mít za následek jinou valarray hodnotu než 0 nebo 1 v závislosti na výsledku bitové operace.

Příklad

// 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 ).

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-11-07

Sdílet prostřednictvím

<valarray> – operátory

operator!=

Parametry

Vrácená hodnota

Poznámky

Příklad

operator%

Parametry

Vrácená hodnota

Příklad

operator&

Parametry

Návratová hodnota

Poznámky

Příklad

operator&&

Parametry

Vrácená hodnota

Poznámky

Příklad

operator>

Parametry

Vrácená hodnota

Poznámky

Příklad

operator>=

Parametry

Vrácená hodnota

Poznámky

Příklad

operator>>

Parametry

Vrácená hodnota

Poznámky

Příklad

operator<

Parametry

Vrácená hodnota

Poznámky

Příklad

operator<=

Parametry

Vrácená hodnota

Poznámky

Příklad

operator<<

Parametry

Vrácená hodnota

Poznámky

Příklad

operator*

Parametry

Vrácená hodnota

Příklad

operator+

Parametry

Vrácená hodnota

Příklad

operator-

Parametry

Vrácená hodnota

Poznámky

Příklad

operator/

Parametry

Vrácená hodnota

Poznámky

Příklad

operator==

Parametry

Návratová hodnota

Poznámky

Příklad

operator^

Parametry

Vrácená hodnota

Poznámky

Příklad

operator|

`<valarray>` – operátory

`operator!=`

`operator%`

`operator&`

`operator&&`

`operator>`

`operator>=`

`operator>>`

`operator<`

`operator<=`

`operator<<`

`operator*`

`operator+`

`operator-`

`operator/`

`operator==`

`operator^`

`operator|`

`operator||`