VectorOfElements-VectorOfElements Operations <br>

## Functions

VectorOfElements | assignmentSafe (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator- (const VectorOfElements &a)
VectorOfElements | operator+= (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator-= (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator*= (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator/= (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator+ (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator- (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator* (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator/ (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator% (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator== (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator!= (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator> (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator< (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator<= (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator>= (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator&& (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator|| (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | operator! (const VectorOfElements &a)
VectorOfElements | crossProduct (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | l2 (const VectorOfElements &a)
VectorOfElements | productOfElements (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | productOfElements (const VectorOfElements &a)
VectorOfElements | divisionOfElements (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | min (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | min (const VectorOfElements &a, const VectorOfElements &b, TypeID type)
VectorOfElements | minAbs (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | max (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | max (const VectorOfElements &a, const VectorOfElements &b, TypeID type)
VectorOfElements | copysign (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | copysign (const VectorOfElements &a, const VectorOfElements &b, TypeID t)
VectorOfElements | sign (const VectorOfElements &a)
VectorOfElements | excerpt (const VectorOfElements &source, const VectorOfElements &filter)
VectorOfElements | select (const VectorOfElements &a, const VectorOfElements &b, const VectorOfElements &c)
VectorOfElements | select (const VectorOfElements &a, const VectorOfElements &b, const VectorOfElements &c, TypeID t)
VectorOfElements | select (const VectorOfElements &b, const VectorOfElements &c, TypeID t)
VectorOfElements | mad (const VectorOfElements &a, const VectorOfElements &b, const VectorOfElements &c)
VectorOfElements | mad (const VectorOfElements &a, const VectorOfElements &b, const VectorOfElements &c, TypeID t)
VectorOfElements | log (const VectorOfElements &a)
VectorOfElements | log10 (const VectorOfElements &a)
VectorOfElements | powI (const VectorOfElements &a, unsigned int i)
VectorOfElements | exp (const VectorOfElements &a)
VectorOfElements | sqrt (const VectorOfElements &a)
VectorOfElements | rsqrt (const VectorOfElements &a)
VectorOfElements | fabs (const VectorOfElements &a)
VectorOfElements | abs (const VectorOfElements &a)
VectorOfElements | abs_diff (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElements | floor (const VectorOfElements &a)
VectorOfElements | convert (acl::TypeID type, const VectorOfElements &a, bool strong=true)
VectorOfElements | minElement (const VectorOfElements &a)
VectorOfElements | minAbsElement (const VectorOfElements &a)
VectorOfElements | maxElement (const VectorOfElements &a)
VectorOfElements | sumOfElements (const VectorOfElements &a)
VectorOfElements | andOfElements (const VectorOfElements &a)
VectorOfElements | orOfElements (const VectorOfElements &a)
VectorOfElements | cat (const VectorOfElements &a, const VectorOfElements &b)
VectorOfElementsData | cat (const VectorOfElementsData &a, const VectorOfElementsData &b)
VectorOfElements | cat (const VectorOfElements &a, const VectorOfElements &b, const VectorOfElements &c)
VectorOfElements | cat (const VectorOfElements *a, unsigned int n)
VectorOfElements | catN (const VectorOfElements &a, unsigned int n)
template<typename T >
VectorOfElements | operator+= (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator-= (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator*= (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator/= (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator+ (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator+ (const T &a, const VectorOfElements &b)
template<typename T >
VectorOfElements | operator- (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator- (const T &a, const VectorOfElements &b)
template<typename T >
VectorOfElements | operator* (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator* (const T &a, const VectorOfElements &b)
template<typename T >
VectorOfElements | operator/ (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator% (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator/ (const T &b, const VectorOfElements &a)
template<typename T >
VectorOfElements | operator% (const T &b, const VectorOfElements &a)
template<typename T >
VectorOfElements | operator> (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator> (const T &b, const VectorOfElements &a)
template<typename T >
VectorOfElements | operator< (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator< (const T &b, const VectorOfElements &a)
template<typename T >
VectorOfElements | operator>= (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator>= (const T &b, const VectorOfElements &a)
template<typename T >
VectorOfElements | operator<= (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator<= (const T &b, const VectorOfElements &a)
template<typename T >
VectorOfElements | operator== (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator== (const T &b, const VectorOfElements &a)
template<typename T >
VectorOfElements | operator!= (const VectorOfElements &a, const T &b)
template<typename T >
VectorOfElements | operator!= (const T &b, const VectorOfElements &a)

## Detailed Description

## Function Documentation

## abs()

VectorOfElements abs | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing result element-wise operation abs(a);

## abs_diff()

VectorOfElements abs_diff | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing result element-wise operation abs_diff(a, b);

## andOfElements()

VectorOfElements andOfElements | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing a && operation result of elements

## assignmentSafe()

VectorOfElements assignmentSafe | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing assignment operation result `a=`b``

## cat() [1/4]

VectorOfElements cat | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Concatinates two vectors `a` and `b` \( cat\left( \left[\begin{array}{c} a_1\\a_2\\...\\a_n\\ \end{array}\right], \left[\begin{array}{c} b_1\\b_2\\...\\b_m\\ \end{array}\right] \right)= \left[\begin{array}{c} a_1\\a_2\\ \vdots \\a_n\\ b_1\\b_2\\ \vdots \\b_m\\ \end{array}\right]. \)

## cat() [2/4]

VectorOfElements cat | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b,
|  | const VectorOfElements & | c
| ) |  |

related

Concatinates three vectors `a` `b` and `c` \( cat\left( \left[\begin{array}{c} a_1\\...\\a_n\\ \end{array}\right], \left[\begin{array}{c} b_1\\...\\b_m\\ \end{array}\right], \left[\begin{array}{c} c_1\\...\\c_l\\ \end{array}\right] \right)= \left[\begin{array}{c} a_1\\...\\a_n\\ b_1\\...\\b_m\\ c_1\\...\\c_l\\ \end{array}\right]. \)

## cat() [3/4]

VectorOfElements cat | ( | const VectorOfElements * | a,
|  | unsigned int | n
| ) |  |

related

Concatinates `n` VectorOfElements `a`

## cat() [4/4]

VectorOfElementsData cat | ( | const VectorOfElementsData & | a,
|  | const VectorOfElementsData & | b
| ) |  |

related

Concatinates two vectors `a` and `b` \( cat\left( \left[\begin{array}{c} a_1\\a_2\\...\\a_n\\ \end{array}\right], \left[\begin{array}{c} b_1\\b_2\\...\\b_m\\ \end{array}\right] \right)= \left[\begin{array}{c} a_1\\a_2\\ \vdots \\a_n\\ b_1\\b_2\\ \vdots \\b_m\\ \end{array}\right]. \)

## catN()

VectorOfElements catN | ( | const VectorOfElements & | a,
|  | unsigned int | n
| ) |  |

related

Concatinates VectorOfElements `a` to itself `n` times

## convert()

VectorOfElements convert | ( | acl::TypeID | type,
|  | const VectorOfElements & | a,
|  | bool | strong = `true`
| ) |  |

related

Creates VectorOfElements with openCL type casting;

## copysign() [1/2]

VectorOfElements copysign | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

returns a with sign of b copysign(a,b)

## copysign() [2/2]

VectorOfElements copysign | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b,
|  | TypeID | t
| ) |  |

related

returns a with sign of b copysign(a,b) with type specification

## crossProduct()

VectorOfElements crossProduct | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements `c` which elements are crossproduct of corresponding elements of `a` and `b`

The function is defined for 2D and 3D cases

## divisionOfElements()

VectorOfElements divisionOfElements | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements `c` which elements are division of corresponding elements of `a` and `b`

## excerpt()

VectorOfElements excerpt | ( | const VectorOfElements & | source,
|  | const VectorOfElements & | filter
| ) |  |

related

Creates VectorOfElements which elements are result of excerpt operation of `source` and `filter` elements

The `filter` shoule have only 1 component

## exp()

VectorOfElements exp | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing result exp(a); a should contain only one element

## fabs()

VectorOfElements fabs | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing result element-wise operation fabs(a);

## floor()

VectorOfElements floor | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing result element-wise operation \( floor(a_i) \)

## l2()

VectorOfElements l2 | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements `b` corresponding to a scala product a*a

The function is defined for 2D and 3D cases

Definition at line 751 of file aclVectorOfElementsOperations.h.

## log()

VectorOfElements log | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing result log(a); a should contain only one element

## log10()

VectorOfElements log10 | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing result log10(a); a should contain only one element

## mad() [1/2]

VectorOfElements mad | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b,
|  | const VectorOfElements & | c
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a`, `b` and `c` For a scalar type, result = a * b + c

## mad() [2/2]

VectorOfElements mad | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b,
|  | const VectorOfElements & | c,
|  | TypeID | t
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a`, `b` and `c` with type specification For a scalar type, result = a * b + c

## max() [1/2]

VectorOfElements max | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements `c` which elements are max of corresponding elements of `a` and `b`

## max() [2/2]

VectorOfElements max | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b,
|  | TypeID | type
| ) |  |

related

Creates VectorOfElements `c` which elements are max of corresponding elements of `a` and `b` with type specification

## maxElement()

VectorOfElements maxElement | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing a min element

## min() [1/2]

VectorOfElements min | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements `c` which elements are min of corresponding elements of `a` and `b`

## min() [2/2]

VectorOfElements min | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b,
|  | TypeID | type
| ) |  |

related

Creates VectorOfElements `c` which elements are min of corresponding elements of `a` and `b` with type specification

## minAbs()

VectorOfElements minAbs | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements `c` which elements are min of corresponding elements of `a` and `b`

## minAbsElement()

VectorOfElements minAbsElement | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing an element with minimal absolute value

## minElement()

VectorOfElements minElement | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing a min element

## operator!()

VectorOfElements operator! | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing operation result of element `a`

## operator!=() [1/3]

template<typename T >

VectorOfElements operator!= | ( | const T & | b,
|  | const VectorOfElements & | a
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double `b`

The function creates automaticaly a constant of a corresponding type

## operator!=() [2/3]

template<typename T >

VectorOfElements operator!= | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double `b`

The function creates automaticaly a constant of a corresponding type

## operator!=() [3/3]

VectorOfElements operator!= | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a` and `b`

## operator%() [1/3]

template<typename T >

VectorOfElements operator% | ( | const T & | b,
|  | const VectorOfElements & | a
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator%() [2/3]

template<typename T >

VectorOfElements operator% | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator%() [3/3]

VectorOfElements operator% | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

## operator&&()

VectorOfElements operator&& | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a` && `b`

## operator*() [1/3]

template<typename T >

VectorOfElements operator* | ( | const T & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator*() [2/3]

template<typename T >

VectorOfElements operator* | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator*() [3/3]

VectorOfElements operator* | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

In case of sizes of `a` and `b` are equal the product is a scalar (dot) product. If one of sizes is 1 than the function results product of a scalar on vector

## operator*=() [1/2]

template<typename T >

VectorOfElements operator*= | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator*=() [2/2]

VectorOfElements operator*= | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

It is assumed that size of `b` is 1

## operator+() [1/3]

template<typename T >

VectorOfElements operator+ | ( | const T & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator+() [2/3]

template<typename T >

VectorOfElements operator+ | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator+() [3/3]

VectorOfElements operator+ | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

## operator+=() [1/2]

template<typename T >

VectorOfElements operator+= | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator+=() [2/2]

VectorOfElements operator+= | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

## operator-() [1/4]

template<typename T >

VectorOfElements operator- | ( | const T & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator-() [2/4]

VectorOfElements operator- | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing operation result of element `a`

## operator-() [3/4]

template<typename T >

VectorOfElements operator- | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator-() [4/4]

VectorOfElements operator- | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

## operator-=() [1/2]

template<typename T >

VectorOfElements operator-= | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator-=() [2/2]

VectorOfElements operator-= | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

## operator/() [1/3]

template<typename T >

VectorOfElements operator/ | ( | const T & | b,
|  | const VectorOfElements & | a
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator/() [2/3]

template<typename T >

VectorOfElements operator/ | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator/() [3/3]

VectorOfElements operator/ | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

## operator/=() [1/2]

template<typename T >

VectorOfElements operator/= | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator/=() [2/2]

VectorOfElements operator/= | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and `b`

It is supposed that size of `b` is 1

## operator<() [1/3]

template<typename T >

VectorOfElements operator< | ( | const T & | b,
|  | const VectorOfElements & | a
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator<() [2/3]

template<typename T >

VectorOfElements operator< | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator<() [3/3]

VectorOfElements operator< | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a` and `b`

## operator<=() [1/3]

template<typename T >

VectorOfElements operator<= | ( | const T & | b,
|  | const VectorOfElements & | a
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator<=() [2/3]

template<typename T >

VectorOfElements operator<= | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator<=() [3/3]

VectorOfElements operator<= | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a` and `b`

## operator==() [1/3]

template<typename T >

VectorOfElements operator== | ( | const T & | b,
|  | const VectorOfElements & | a
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double `b`

The function creates automaticaly a constant of a corresponding type

## operator==() [2/3]

template<typename T >

VectorOfElements operator== | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator==() [3/3]

VectorOfElements operator== | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a` and `b`

## operator>() [1/3]

template<typename T >

VectorOfElements operator> | ( | const T & | b,
|  | const VectorOfElements & | a
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator>() [2/3]

template<typename T >

VectorOfElements operator> | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator>() [3/3]

VectorOfElements operator> | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a` and `b`

## operator>=() [1/3]

template<typename T >

VectorOfElements operator>= | ( | const T & | b,
|  | const VectorOfElements & | a
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator>=() [2/3]

template<typename T >

VectorOfElements operator>= | ( | const VectorOfElements & | a,
|  | const T & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements of `a` and a double

The function creates automaticaly a constant of a corresponding type

## operator>=() [3/3]

VectorOfElements operator>= | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a` and `b`

## operator||()

VectorOfElements operator|| | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a` || `b`

## orOfElements()

VectorOfElements orOfElements | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing a || operation result of elements

## powI()

VectorOfElements powI | ( | const VectorOfElements & | a,
|  | unsigned int | i
| ) |  |

related

Creates VectorOfElements containing result a^i; a should contain only one element

## productOfElements() [1/2]

VectorOfElements productOfElements | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements `c` which element is a product of all elements of `a`

## productOfElements() [2/2]

VectorOfElements productOfElements | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b
| ) |  |

related

Creates VectorOfElements `c` which elements are product of corresponding elements of `a` and `b`

## rsqrt()

VectorOfElements rsqrt | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing result exp(a); a should contain only one element

Examples
  testPrivateVar.cc.

## select() [1/3]

VectorOfElements select | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b,
|  | const VectorOfElements & | c
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a`, `b` and `c` For a scalar type, result = c ? b : a

The function can operate in two modes: `c` has 1 components and several components.

## select() [2/3]

VectorOfElements select | ( | const VectorOfElements & | a,
|  | const VectorOfElements & | b,
|  | const VectorOfElements & | c,
|  | TypeID | t
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a`, `b` and `c` For a scalar type, result = c ? b : a, with type specification

The function can operate in two modes: `c` has 1 components and several components.

## select() [3/3]

VectorOfElements select | ( | const VectorOfElements & | b,
|  | const VectorOfElements & | c,
|  | TypeID | t
| ) |  |

related

Creates VectorOfElements containing operation result of elements `a`, `b` and `c` For a scalar type, result = c ? b : 0, with type specification

The function can operate in two modes: `c` has 1 components and several components.

## sign()

VectorOfElements sign | ( | const VectorOfElements & | a | ) |

related

returns sign of a

## sqrt()

VectorOfElements sqrt | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing result exp(a); a should contain only one element

## sumOfElements()

VectorOfElements sumOfElements | ( | const VectorOfElements & | a | ) |

related

Creates VectorOfElements containing a sum of elements