Binary operator for scalar maximum. More...

#include <max.hpp>

Public Types
template<typename V = default_vec>
using	vec_type = typename V::template vec_type< T >

Static Public Member Functions
static constexpr int	complexity ()
	Estimate the complexity of operator. More...

static constexpr T	apply (const T &x, E value) noexcept
	Apply the unary operator on lhs and rhs. More...

template<typename V = default_vec>
static vec_type< V >	load (const vec_type< V > &lhs, const vec_type< V > &rhs) noexcept
	Compute several applications of the operator at a time. More...

template<typename X , typename Y , typename YY >
static auto	gpu_compute_hint (const X &x, const Y &y, YY &&yy) noexcept
	Compute the result of the operation using the GPU. More...

template<typename X , typename Y , typename YY >
static YY &	gpu_compute (const X &x, const Y &y, YY &yy) noexcept
	Compute the result of the operation using the GPU. More...

static std::string	desc () noexcept
	Returns a textual representation of the operator. More...

Static Public Attributes
static constexpr bool	linear = true
	Indicates if the operator is linear or not.

static constexpr bool	thread_safe = true
	Indicates if the operator is thread safe or not.

static constexpr bool	desc_func = true
	Indicates if the description must be printed as function.

template<vector_mode_t V>
static constexpr bool	vectorizable = !is_complex_t<T>
	Indicates if the expression is vectorizable using the given vector mode. More...

template<typename L , typename R >
static constexpr bool	gpu_computable
	Indicates if the operator can be computed on GPU. More...

Detailed Description

template<typename T, typename E>
struct etl::max_binary_op< T, E >

Binary operator for scalar maximum.

Member Typedef Documentation

◆ vec_type

template<typename T , typename E >

template<typename V = default_vec>

using etl::max_binary_op< T, E >::vec_type = typename V::template vec_type<T>

The vectorization type for V

Member Function Documentation

◆ apply()

template<typename T , typename E >

static constexpr T etl::max_binary_op< T, E >::apply	(	const T &	x,
		E	value
	)

inlinestaticnoexcept

Apply the unary operator on lhs and rhs.

Parameters

x	The left hand side value on which to apply the operator
value	The right hand side value on which to apply the operator

Returns: The result of applying the binary operator on lhs and rhs

◆ complexity()

template<typename T , typename E >

static constexpr int etl::max_binary_op< T, E >::complexity ( )

inlinestatic

Estimate the complexity of operator.

Returns: An estimation of the complexity of the operator

◆ desc()

template<typename T , typename E >

static std::string etl::max_binary_op< T, E >::desc ( )

inlinestaticnoexcept

Returns a textual representation of the operator.

Returns: a string representing the operator

◆ gpu_compute()

template<typename T , typename E >

template<typename X , typename Y , typename YY >

static YY& etl::max_binary_op< T, E >::gpu_compute	(	const X &	x,
		const Y &	y,
		YY &	yy
	)

inlinestaticnoexcept

Compute the result of the operation using the GPU.

Parameters

x	The expression of the unary operation
y	The expression into which to store the reuslt

◆ gpu_compute_hint()

template<typename T , typename E >

template<typename X , typename Y , typename YY >

static auto etl::max_binary_op< T, E >::gpu_compute_hint	(	const X &	x,
		const Y &	y,
		YY &&	yy
	)

inlinestaticnoexcept

Compute the result of the operation using the GPU.

Parameters

x	The expression of the unary operation

Returns: The result of applying the unary operator on x. The result must be a GPU computed expression.

◆ load()

template<typename T , typename E >

template<typename V = default_vec>

static vec_type<V> etl::max_binary_op< T, E >::load	(	const vec_type< V > &	lhs,
		const vec_type< V > &	rhs
	)

inlinestaticnoexcept

Compute several applications of the operator at a time.

Parameters

lhs	The left hand side vector
rhs	The right hand side vector

Template Parameters

V	The vectorization mode

Returns: a vector containing several results of the operator

Member Data Documentation

◆ gpu_computable

template<typename T , typename E >

template<typename L , typename R >

constexpr bool etl::max_binary_op< T, E >::gpu_computable

static

Initial value:

= (all_single_precision<L, R> && impl::egblas::has_smax3) || (all_double_precision<L, R> && impl::egblas::has_dmax3)
                                           || (all_complex_single_precision<L, R> && impl::egblas::has_cmax3)
                                           || (all_complex_double_precision<L, R> && impl::egblas::has_zmax3)

Indicates if the operator can be computed on GPU.

◆ vectorizable

template<typename T , typename E >

template<vector_mode_t V>

constexpr bool etl::max_binary_op< T, E >::vectorizable = !is_complex_t<T>

static

Indicates if the expression is vectorizable using the given vector mode.

Template Parameters

V	The vector mode

The documentation for this struct was generated from the following file:

include/etl/op/binary/max.hpp

Public Types

Static Public Member Functions

Static Public Attributes

Detailed Description

template<typename T, typename E> struct etl::max_binary_op< T, E >

Member Typedef Documentation

◆ vec_type

Member Function Documentation

◆ apply()

◆ complexity()

◆ desc()

◆ gpu_compute()

◆ gpu_compute_hint()

◆ load()

Member Data Documentation

◆ gpu_computable

◆ vectorizable

template<typename T, typename E>
struct etl::max_binary_op< T, E >