Operadores de namespace de concurrencia (AMP)

Los operadores siguientes se definen en el espacio de nombres (AMP):

operator==

Determina si los argumentos especificados son iguales.

template <
    int _Rank,
    template <int> class _Tuple_type
>
bool operator== (
    const _Tuple_type<_Rank>& _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp);

Parámetros

_Rank
Clasificación de los argumentos de la tupla.

_Lhs
Una de las tuplas que se van a comparar.

_Rhs
Una de las tuplas que se van a comparar.

Valor devuelto

si las tuplas son iguales; de lo contrario, .

operator!=

Determina si los argumentos especificados no son iguales.

template <
    int _Rank,
    template <int> class _Tuple_type
>
bool operator!= (
    const _Tuple_type<_Rank>& _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp);

Parámetros

_Rank
Clasificación de los argumentos de la tupla.

_Lhs
Una de las tuplas que se van a comparar.

_Rhs
Una de las tuplas que se van a comparar.

Valor devuelto

si las tuplas no son iguales; de lo contrario, .

operator+

Calcula la suma de todos los componentes de los argumentos especificados.

template <
    int _Rank,
    template <int> class _Tuple_type
>
class _Tuple_type> _Tuple_type<_Rank>   operator+(
    const _Tuple_type<_Rank>& _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp,cpu);

template <
    int _Rank,
    template <int> class _Tuple_type
>
class _Tuple_type> _Tuple_type<_Rank>   operator+(
    const _Tuple_type<_Rank>& _Lhs,
    typename _Tuple_type<_Rank>::value_type _Rhs) restrict(amp,cpu);

template <
    int _Rank,
    template <int> class _Tuple_type
>
class _Tuple_type> _Tuple_type<_Rank>   operator+(
    typename _Tuple_type<_Rank>::value_type _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp,cpu);

Parámetros

_Rank
Clasificación de los argumentos de la tupla.

_Lhs
Uno de los argumentos que añadir.

_Rhs
Uno de los argumentos que añadir.

Valor devuelto

Suma de todos los componentes de los argumentos especificados.

operador

Calcula la diferencia de todos los componentes entre los argumentos especificados.

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator-(
    const _Tuple_type<_Rank>& _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp,cpu);

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator-(
    const _Tuple_type<_Rank>& _Lhs,
    typename _Tuple_type<_Rank>::value_type _Rhs) restrict(amp,cpu);

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator-(
    typename _Tuple_type<_Rank>::value_type _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp,cpu);

Parámetros

_Rank
Clasificación de los argumentos de la tupla.

_Lhs
Argumento del que se va a restar.

_Rhs
El argumento a restar.

Valor devuelto

Diferencia componente por componente entre los argumentos especificados.

operator*

Calcula el producto de todos los componentes de los argumentos especificados.

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator*(
    const _Tuple_type<_Rank>& _Lhs,
    typename _Tuple_type<_Rank>::value_type _Rhs) restrict(amp,cpu);

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator*(
    typename _Tuple_type<_Rank>::value_type _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp, cpu);

Parámetros

_Rank
Clasificación de los argumentos de la tupla.

_Lhs
Una de las tuplas que se van a multiplicar.

_Rhs
Una de las tuplas que se van a multiplicar.

Valor devuelto

Producto de todos los componentes de los argumentos especificados.

operador

Calcula el cociente de todos los componentes de los argumentos especificados.

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator/(
    const _Tuple_type<_Rank>& _Lhs,
    typename _Tuple_type<_Rank>::value_type _Rhs) restrict(amp,cpu);

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator/(
    typename _Tuple_type<_Rank>::value_type _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp,cpu);

Parámetros

_Rank
Clasificación de los argumentos de la tupla.

_Lhs
Tupla que se va a dividir.

_Rhs
La tupla por la que se dividirá.

Valor devuelto

Cociente de todos los componentes de los argumentos especificados.

operator%

Calcula el módulo del primer argumento especificado dividido por el segundo argumento especificado.

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator%(
    const _Tuple_type<_Rank>& _Lhs,
    typename _Tuple_type<_Rank>::value_type _Rhs) restrict(amp,cpu);

template <
    int _Rank,
    template <int> class _Tuple_type
>
_Tuple_type<_Rank>   operator%(
    typename _Tuple_type<_Rank>::value_type _Lhs,
    const _Tuple_type<_Rank>& _Rhs) restrict(amp,cpu);

Parámetros

_Rank
Clasificación de los argumentos de la tupla.

_Lhs
Tupla a partir de la cual se calcula el módulo.

_Rhs
Tupla por la que se va a modular.

Valor devuelto

El resultado del primer argumento especificado modula el segundo argumento especificado.

Consulte también

Espacio de nombres de simultaneidad