Array Operations#

Defines

LIBRAPID_BINARY_FUNCTOR(NAME_, OP_)

LIBRAPID_BINARY_COMPARISON_FUNCTOR(NAME_, OP_)

LIBRAPID_UNARY_KERNEL_GETTER

LIBRAPID_BINARY_KERNEL_GETTER

LIBRAPID_UNARY_SHAPE_EXTRACTOR

LIBRAPID_BINARY_SHAPE_EXTRACTOR

LIBRAPID_UNARY_FUNCTOR(NAME, OP)

IS_ARRAY_OP

IS_ARRAY_OP_ARRAY

IS_ARRAY_OP_WITH_SCALAR

template<typename ShapeType, typename StorageType> struct DescriptorExtractor<array::ArrayContainer<ShapeType, StorageType>>

#include <operations.hpp>

Extracts the Descriptor type of an ArrayContainer object. In this case, the Descriptor is Trivial

Template Parameters

ShapeType – The shape type of the ArrayContainer
StorageType – The storage type of the ArrayContainer

Public Types

using Type = ::librapid::detail::descriptor::Trivial

template<typename T, typename S> struct DescriptorExtractor<array::GeneralArrayView<T, S>>

#include <operations.hpp>

Extracts the Descriptor type of an ArrayView object

Template Parameters: T – The Array type of the ArrayView

Public Types

using Type = ::librapid::detail::descriptor::Trivial

template<typename Descriptor, typename Functor, typename ...Args> struct DescriptorExtractor<::librapid::detail::Function<Descriptor, Functor, Args...>>

#include <operations.hpp>

Extracts the Descriptor type of a Function object

Template Parameters

Descriptor – The descriptor of the Function
Functor – The functor type of the Function
Args – The argument types of the Function

Public Types

using Type = Descriptor

template<> struct TypeInfo<::librapid::detail::Plus>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "plus"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "addArrays"

static constexpr const char *kernelNameScalarRhs = "addArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "addArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::Minus>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "minus"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "subArrays"

static constexpr const char *kernelNameScalarRhs = "subArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "subArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::Multiply>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "multiply"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "mulArrays"

static constexpr const char *kernelNameScalarRhs = "mulArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "mulArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::Divide>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "divide"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "divArrays"

static constexpr const char *kernelNameScalarRhs = "divArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "divArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::LessThan>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "less than"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "lessThanArrays"

static constexpr const char *kernelNameScalarRhs = "lessThanArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "lessThanArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::GreaterThan>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "greater than"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "greaterThanArrays"

static constexpr const char *kernelNameScalarRhs = "greaterThanArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "greaterThanArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::LessThanEqual>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "less than or equal"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "lessThanEqualArrays"

static constexpr const char *kernelNameScalarRhs = "lessThanEqualArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "lessThanEqualArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::GreaterThanEqual>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "greater than or equal"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "greaterThanEqualArrays"

static constexpr const char *kernelNameScalarRhs = "greaterThanEqualArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "greaterThanEqualArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::ElementWiseEqual>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "element wise equal"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "elementWiseEqualArrays"

static constexpr const char *kernelNameScalarRhs = "elementWiseEqualArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "elementWiseEqualArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::ElementWiseNotEqual>

#include <operations.hpp>

Public Static Functions

template<typename T1, typename T2> static inline constexpr const char *getKernelNameImpl(std::tuple<T1, T2> args)

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename First, typename Second> static inline auto getShapeImpl(const std::tuple<First, Second> &tup)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "element wise not equal"

static constexpr const char *filename = "arithmetic"

static constexpr const char *kernelName = "elementWiseNotEqualArrays"

static constexpr const char *kernelNameScalarRhs = "elementWiseNotEqualArraysScalarRhs"

static constexpr const char *kernelNameScalarLhs = "elementWiseNotEqualArraysScalarLhs"

template<> struct TypeInfo<::librapid::detail::Neg>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "negate"

static constexpr const char *filename = "negate"

static constexpr const char *kernelName = "negateArrays"

template<> struct TypeInfo<::librapid::detail::Sin>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "sin"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "sinArrays"

template<> struct TypeInfo<::librapid::detail::Cos>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "cos"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "cosArrays"

template<> struct TypeInfo<::librapid::detail::Tan>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "tan"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "tanArrays"

template<> struct TypeInfo<::librapid::detail::Asin>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "arcsin"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "asinArrays"

template<> struct TypeInfo<::librapid::detail::Acos>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "arcos"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "acosArrays"

template<> struct TypeInfo<::librapid::detail::Atan>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "arctan"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "atanArrays"

template<> struct TypeInfo<::librapid::detail::Sinh>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "hyperbolic sine"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "sinhArrays"

template<> struct TypeInfo<::librapid::detail::Cosh>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "hyperbolic cosine"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "coshArrays"

template<> struct TypeInfo<::librapid::detail::Tanh>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "hyperbolic tangent"

static constexpr const char *filename = "trigonometry"

static constexpr const char *kernelName = "tanhArrays"

template<> struct TypeInfo<::librapid::detail::Exp>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "exponent"

static constexpr const char *filename = "expLogPow"

static constexpr const char *kernelName = "expArrays"

template<> struct TypeInfo<::librapid::detail::Log>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "logarithm"

static constexpr const char *filename = "expLogPow"

static constexpr const char *kernelName = "logArrays"

template<> struct TypeInfo<::librapid::detail::Log2>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "logarithm base 2"

static constexpr const char *filename = "expLogPow"

static constexpr const char *kernelName = "log2Arrays"

template<> struct TypeInfo<::librapid::detail::Log10>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "logarithm base 10"

static constexpr const char *filename = "expLogPow"

static constexpr const char *kernelName = "log10Arrays"

template<> struct TypeInfo<::librapid::detail::Sqrt>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "square root"

static constexpr const char *filename = "expLogPow"

static constexpr const char *kernelName = "sqrtArrays"

template<> struct TypeInfo<::librapid::detail::Cbrt>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "cube root"

static constexpr const char *filename = "expLogPow"

static constexpr const char *kernelName = "cbrtArrays"

template<> struct TypeInfo<::librapid::detail::Abs>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "absolute value"

static constexpr const char *filename = "abs"

static constexpr const char *kernelName = "absArrays"

template<> struct TypeInfo<::librapid::detail::Floor>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "floor"

static constexpr const char *filename = "floorCeilRound"

static constexpr const char *kernelName = "floorArrays"

template<> struct TypeInfo<::librapid::detail::Ceil>

#include <operations.hpp>

Public Static Functions

template<typename ...Args> static inline constexpr const char *getKernelName(std::tuple<Args...> args)

template<typename ...Args> static inline auto getShape(const std::tuple<Args...> &args)

Public Static Attributes

static constexpr const char *name = "ceiling"

static constexpr const char *filename = "floorCeilRound"

static constexpr const char *kernelName = "ceilArrays"

namespace librapid

Functions

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto sin (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Sin, VAL >

Calculate the sine of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \sin(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Sine function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto cos (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Cos, VAL >

Calculate the cosine of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \cos(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Cosine function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto tan (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Tan, VAL >

Calculate the tangent of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \tan(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Tangent function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto asin (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Asin, VAL >

Calculate the arcsine of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \sin^{-1}(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Arcsine function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto acos (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Acos, VAL >

Calculate the arccosine of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \cos^{-1}(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Arccosine function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto atan (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Atan, VAL >

Calculate the arctangent of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \tan^{-1}(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Arctangent function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto sinh (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Sinh, VAL >

Calculate the hyperbolic sine of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \sinh(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Hyperbolic sine function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto cosh (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Cosh, VAL >

Calculate the hyperbolic cosine of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \cosh(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Hyperbolic cosine function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto tanh (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Tanh, VAL >

Calculate the hyperbolic tangent of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \tanh(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Hyperbolic tangent function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto exp (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Exp, VAL >

Raise e to the power of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = e^{A_i}\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Exponential function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto log (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Log, VAL >

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \ln(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Natural logarithm function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto log10 (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Log10, VAL >

Compute the base 10 logarithm of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \log_{10}(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Base 10 logarithm function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto log2 (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Log2, VAL >

Compute the base 2 logarithm of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \log_{2}(A_i)\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Base 2 logarithm function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto sqrt (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Sqrt, VAL >

Compute the square root of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \sqrt{A_i}\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Square root function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto cbrt (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Cbrt, VAL >

Compute the cube root of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \sqrt[3]{A_i}\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Cube root function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto abs (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Abs, VAL >

Compute the absolute value of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = |A_i|\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Absolute value function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto floor (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Floor, VAL >

Compute the floor of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \lfloor A_i \rfloor\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Floor function object

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto ceil (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Ceil, VAL >

Compute the ceiling of each element in the array.

\(R = \{ R_0, R_1, R_2, ... \} \) \text{ where } \(R_i = \lceil A_i \rceil\)

Template Parameters: VAL – Type of the input
Parameters: val – The input array or function
Returns: Ceiling function object

namespace array

Functions

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator+ (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::Plus, LHS, RHS >

Element-wise array addition.

Performs element-wise addition on two arrays. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise sum of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator- (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::Minus, LHS, RHS >

Element-wise array subtraction.

Performs element-wise subtraction on two arrays. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise difference of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator* (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::Multiply, LHS, RHS >

Element-wise array multiplication.

Performs element-wise multiplication on two arrays. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise product of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator/ (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::Divide, LHS, RHS >

Element-wise array division.

Performs element-wise division on two arrays. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise division of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator< (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::LessThan, LHS, RHS >

Element-wise array comparison, checking whether a < b for all a, b in input arrays.

Performs an element-wise comparison on two arrays, checking if the first value is less than the second. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise comparison of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator> (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::GreaterThan, LHS, RHS >

Element-wise array comparison, checking whether a > b for all a, b in input arrays.

Performs an element-wise comparison on two arrays, checking if the first value is greater than the second. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise comparison of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator<= (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::LessThanEqual, LHS, RHS >

Element-wise array comparison, checking whether a <= b for all a, b in input arrays.

Performs an element-wise comparison on two arrays, checking if the first value is less than or equal to the second. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise comparison of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator>= (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::GreaterThanEqual, LHS, RHS >

Element-wise array comparison, checking whether a >= b for all a, b in input arrays.

Performs an element-wise comparison on two arrays, checking if the first value is greater than or equal to the second. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise comparison of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator== (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::ElementWiseEqual, LHS, RHS >

Element-wise array comparison, checking whether a == b for all a, b in input arrays.

Performs an element-wise comparison on two arrays, checking if the first value is equal to the second. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise comparison of the two arrays

template<class LHS, class RHS, typename std::enable_if_t< detail::isArrayOpArray< LHS, RHS >(), int > = 0> auto operator!= (LHS &&lhs, RHS &&rhs) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< LHS, RHS >, detail::ElementWiseNotEqual, LHS, RHS >

Element-wise array comparison, checking whether a != b for all a, b in input arrays.

Performs an element-wise comparison on two arrays, checking if the first value is not equal to the second. They must both be the same size and of the same data type.

Template Parameters

LHS – Type of the LHS element
RHS – Type of the RHS element

Parameters

lhs – The first array
rhs – The second array

Returns

The element-wise comparison of the two arrays

template<class VAL, typename std::enable_if_t< detail::isArrayOp< VAL >(), int > = 0> auto operator- (VAL &&val) LIBRAPID_RELEASE_NOEXCEPT -> detail::Function< typetraits::DescriptorType_t< VAL >, detail::Neg, VAL >

Negate each element in the array.

Template Parameters: VAL – Type to negate
Parameters: val – The input array or function
Returns: Negation function object

namespace detail

Functions

template<typename desc, typename Functor, typename ...Args> auto makeFunction(Args&&... args)

Construct a new function object with the given functor type and arguments.

Template Parameters

desc – Functor descriptor
Functor – Function type
Args – Argument types

Parameters

args – Arguments passed to the function

Returns

A new Function instance

template<typename VAL> constexpr bool isArrayOp()

template<typename LHS, typename RHS> constexpr bool isArrayOpArray()

template<typename LHS, typename RHS> constexpr bool isArrayOpWithScalar()

struct Plus

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct Minus

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct Multiply

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct Divide

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct Neg

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct LessThan

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct GreaterThan

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct LessThanEqual

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct GreaterThanEqual

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct ElementWiseEqual

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct ElementWiseNotEqual

#include <operations.hpp>

Public Functions

template<typename T, typename V> inline auto operator()(const T &lhs, const V &rhs) const

template<typename Packet> inline auto packet(const Packet &lhs, const Packet &rhs) const

struct Sin

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Cos

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Tan

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Asin

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Acos

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Atan

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Sinh

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Cosh

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Tanh

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Exp

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Log

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Log2

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Log10

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Sqrt

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Cbrt

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Abs

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Floor

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

struct Ceil

#include <operations.hpp>

Public Functions

template<typename T> inline auto operator()(const T &arg) const

template<typename Packet> inline auto packet(const Packet &arg) const

namespace typetraits

Typedefs

template<typename ...Args> using DescriptorType_t = typename DescriptorType<Args...>::Type

A simplification of the DescriptorType to reduce code size