Operadores do espaço de nomes de concorrência (AMP)

Os seguintes operadores são definidos no Concurrency namespace (AMP):

operador==

Determina se os argumentos especificados são iguais.

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
O ranking dos argumentos da tupla.

_Lhs
Uma das tuplas para comparar.

_Rhs
Uma das tuplas para comparar.

Valor de retorno

true se as tuplas forem iguais; caso contrário, false.

operador!=

Determina se os argumentos especificados não são iguais.

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
O ranking dos argumentos da tupla.

_Lhs
Uma das tuplas para comparar.

_Rhs
Uma das tuplas para comparar.

Valor de retorno

true se as tuplas não forem iguais; caso contrário, false.

Operador+

Calcula a soma por componente dos 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
O ranking dos argumentos da tupla.

_Lhs
Um dos argumentos a acrescentar.

_Rhs
Um dos argumentos a acrescentar.

Valor de retorno

Soma dos componentes dos argumentos especificados.

operador-

Calcula a diferença componente a componente entre os 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
O ranking dos argumentos da tupla.

_Lhs
O argumento do qual se subtrai algo.

_Rhs
O argumento para subtrair.

Valor de retorno

A diferença em relação aos componentes entre os argumentos especificados.

operador*

Calcula o produto por componentes dos 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
O ranking dos argumentos da tupla.

_Lhs
Uma das tuplas para multiplicar.

_Rhs
Uma das tuplas para multiplicar.

Valor de retorno

O produto por componente dos argumentos especificados.

operador/

Calcula o quociente componente a componente dos 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
O ranking dos argumentos da tupla.

_Lhs
A tupla a dividir.

_Rhs
A tupla pela qual dividir.

Valor de retorno

O quociente dos argumentos especificados, componente por componente.

Operador%

Calcula o módulo do primeiro argumento especificado pelo 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
O ranking dos argumentos da tupla.

_Lhs
A tupla a partir da qual o módulo é calculado.

_Rhs
A tupla pela qual calcular o módulo.

Valor de retorno

O resultado do primeiro argumento especificado é o módulo do segundo argumento especificado.

Consulte também

Espaço de Nomes de Concorrência