Util

Util#

Overview#

The namespace polyhedralGravity::util contains utility for operations on iterable Containers, Constants and syntactic sugar for using the third party dependency thrust.

Documentation#

namespace util#

Typedefs

template<typename T, size_t M, size_t N> using Matrix = std::array<std::array<T, N>, M>#: Alias for a two-dimensional array with size M and N. M is the major size!

Functions

template<typename Container, typename BinOp> Container applyBinaryFunction(const Container &lhs, const Container &rhs, BinOp binOp)#

Applies a binary function to elements of two containers piece by piece. The objects must be iterable and should have the same size!

Template Parameters:

Container – an iterable object like an array or vector
BinOp – a binary function to apply

Parameters:

lhs – the first container
rhs – the second container
binOp – a binary function like +, -, *, /

Returns:

a container containing the result

template<typename Container, typename Scalar, typename BinOp> Container applyBinaryFunction(const Container &lhs, const Scalar &scalar, BinOp binOp)#

Applies a binary function to elements of one container piece by piece. The objects must be iterable. The resulting container consists of the containers’ object after the application of the binary function with the scalar as a parameter.

Template Parameters:

Container – an iterable object like an array or vector
Scalar – a scalar to use on each element
BinOp – a binary function to apply

Parameters:

lhs – the first container
scalar – a scalar to use on each element
binOp – a binary function like +, -, *, /

Returns:

a container containing the result

template<typename Container> Container operator-(const Container &lhs, const Container &rhs)#

Applies the Operation Minus to two Containers piece by piece.

{1, 2, 3} - {1, 1, 1} = {0, 1, 2} 

Template Parameters:

Container – an iterable object like an array or vector

Parameters:

lhs – minuend
rhs – subtrahend

Returns:

the difference

template<typename Container> Container operator+(const Container &lhs, const Container &rhs)#

Applies the Operation Plus to two Containers piece by piece.

{1, 2, 3} + {1, 1, 1} = {2, 3, 4} 

Template Parameters:

Container – an iterable object like an array or vector

Parameters:

lhs – addend
rhs – addend

Returns:

the sum

template<typename Container> Container operator*(const Container &lhs, const Container &rhs)#

Applies the Operation * to two Containers piece by piece.

{1, 2, 3} * {2, 2, 2} = {2, 4, 6} 

Template Parameters:

Container – an iterable object like an array or vector

Parameters:

lhs – multiplicand
rhs – multiplicand

Returns:

the product

template<typename Container> Container operator/(const Container &lhs, const Container &rhs)#

Applies the Operation / to two Containers piece by piece.

{1, 2, 3} / {1, 2, 3} = {1, 1, 1} 

Template Parameters:

Container – an iterable object like an array or vector

Parameters:

lhs – multiplicand
rhs – multiplicand

Returns:

the product

template<typename Container, typename Scalar> Container operator+(const Container &lhs, const Scalar &scalar)#

Applies the Operation + to a Container and a Scalar.

{1, 2, 3} + 2 = {3, 4, 5} 

Template Parameters:

Container – an iterable object like an array or vector
Scalar – a scalar to use on each element

Parameters:

lhs – addend
scalar – addend

Returns:

a Container

template<typename Container, typename Scalar> Container operator-(const Container &lhs, const Scalar &scalar)#

Applies the Operation to a Container and a Scalar.

{1, 2, 3} - 2 = {-1, 0, 1} 

Template Parameters:

Container – an iterable object like an array or vector
Scalar – a scalar to use on each element

Parameters:

lhs – minuend
scalar – subtrahend

Returns:

a Container

template<typename Container, typename Scalar> Container operator*(const Container &lhs, const Scalar &scalar)#

Applies the Operation to a Container and a Scalar.

{1, 2, 3} * 2 = {2, 4, 6} 

Template Parameters:

Container – an iterable object like an array or vector
Scalar – a scalar to use on each element

Parameters:

lhs – multiplicand
scalar – multiplicand

Returns:

a Container

template<typename Container, typename Scalar> Container operator/(const Container &lhs, const Scalar &scalar)#

Applies the Operation / to a Container and a Scalar.

{2, 4, 6} / 2 = {1, 2, 3} 

Template Parameters:

Container – an iterable object like an array or vector
Scalar – a scalar to use on each element

Parameters:

lhs – the dividend
scalar – the divisor

Returns:

a Container

template<typename Container> double euclideanNorm(const Container &container)#

Applies the Euclidean norm/ L2-norm to a Container (e.g., a vector)

Template Parameters:: Container – must be iterable
Parameters:: container – e.g. a vector
Returns:: a double containing the L2 norm

template<typename Container> Container abs(const Container &container)#

Computes the absolute value for each value in the given container

Template Parameters:: Container – an iterable container, containing numerical values
Parameters:: container – the container
Returns:: a container with the modified values

template<typename T> T det(const Matrix<T, 3, 3> &matrix)#

Computes the determinant with the Sarrus rule for a 3x3 matrix. Notice that for square matrices \(det(A) = det(A^T)\).

Template Parameters:: T – a numerical value
Parameters:: matrix – the 3x3 matrix
Returns:: the determinant

template<typename T, size_t M, size_t N> Matrix<T, M, N> transpose(const Matrix<T, M, N> &matrix)#

Computes the transposed of a mxn matrix.

Template Parameters:

T – the type of the matrix elements
M – the row number
N – the column number

Parameters:

matrix – the matrix to transpose

Returns:

the transposed

template<typename T> std::array<T, 3> cross(const std::array<T, 3> &lhs, const std::array<T, 3> &rhs)#

Returns the cross-product of two cartesian vectors.

Template Parameters:

T – a number

Parameters:

lhs – left vector
rhs – right vector

Returns:

cross product

template<typename T> std::array<T, 3> normal(const std::array<T, 3> &first, const std::array<T, 3> &second)#

Calculates the normal N as (first * second) / |first * second| with * being the cross product and first, second as cartesian vectors.

Template Parameters:

T – numerical type

Parameters:

first – first cartesian vector
second – second cartesian vector

Returns:

the normal (normed)

template<typename T> T dot(const std::array<T, 3> &lhs, const std::array<T, 3> &rhs)#

Returns the dot product of two cartesian vectors.

Template Parameters:

T – a number

Parameters:

lhs – left vector
rhs – right vector

Returns:

dot product

template<typename T> int sgn(T val, double cutoffEpsilon)#

Implements the signum function with a certain EPSILON to absorb rounding errors.

Template Parameters:

T – a numerical (floating point) value

Parameters:

val – the value itself
cutoffEpsilon – the cut-off radius around zero to return 0

Returns:

-1, 0, 1 depending on the sign and the given EPSILON

template<typename T, size_t M, size_t N> std::array<T, M + N> concat(const std::array<T, M> &first, const std::array<T, N> &second)#

Concatenates two std::array of different sizes to one array.

Template Parameters:

T – the shared type of the arrays
M – the size of the first container
N – the size of the second container

Parameters:

first – the first array
second – the second array

Returns:

a new array of size M+N with type T

template<typename T> T surfaceArea(const Matrix<T, 3, 3> &triangle)#

Calculates the surface area of a triangle consisting of three cartesian vertices.

Template Parameters:: T – numerical type
Returns:: surface area

template<typename T> bool isCriticalDifference(const T &first, const T &second)#

Calculates the magnitude between two values and return true if the magnitude between the exponents in greater than 17.

Template Parameters:

T – numerical type

Parameters:

first – first number
second – second number

Returns:

true if the difference is too huge, so that floating point absorption will happen

template<class ...Ts> overloaded(Ts...) -> overloaded<Ts...>#

This function template provides deduction guides for the overloaded struct. It deduces the template arguments for overloaded based on its constructor arguments thus saving you from explicitly mentioning them while instantiation. https://en.cppreference.com/w/cpp/utility/variant/visit

Template Parameters:: Ts – A template parameter pack representing all types that will be passed to the overloaded struct.
Parameters:: Ts – Variable numbers of parameters to pass to the overloaded struct.
Returns:: This doesn’t return a value, but rather assists in the creation of an overloaded object. The type of the object will be overloaded<Ts…>.

template<typename ...Ts> auto operator+(const std::tuple<Ts...> &t1, const std::tuple<Ts...> &t2)#

Adds the contents of two tuples of the same size and types with the operator +.

Template Parameters:

Ts – types of the tuples

Parameters:

t1 – first tuple
t2 – second tuple

Returns:

a new tuple with the added values

template<typename T, size_t N> std::ostream &operator<<(std::ostream &os, const std::array<T, N> &array)#

Operator << for an array of any size.

Template Parameters:

T – type of the array, must have an << operator overload
N – size of the array

Parameters:

os – the ostream
array – the array itself

Returns:

ostream

template<typename T> std::ostream &operator<<(std::ostream &os, const std::set<T> &set)#

Operator << for a set.

Template Parameters:

T – type of the set, must have an << operator overload

Parameters:

os – the ostream
set – the set itself

Returns:

ostream

template<typename FloatType> bool almostEqualUlps(FloatType lhs, FloatType rhs, int ulpDistance)#

Function for comparing closeness of two floating point numbers using ULP (Units in the Last Place) method.

Util

Contents

Util#

Overview#

Documentation#