ArrayUtils Namespace Reference

Collection of utility functions and operators for iterable data containers. More...

Namespaces
	is_container_impl
	Type trait to check if a given type is a container.

Classes
struct	is_container

Functions
template<class Container >
std::string	to_string (const Container &container, const std::string &delimiter=", ", const std::array< std::string, 2 > &surround={"[", "]"})
template<class Container , class F >
Container	elementWisePairOp (const Container &lhs, const Container &rhs, F binaryFunction)
template<class Scalar , class Container , class F >
Container	elementWiseScalarOp (const Scalar &lhs, const Container &rhs, F binaryFunction)
template<class Container >
auto	L2Norm (const Container &c)
template<>
auto	L2Norm< std::array< double, 3 > > (const std::array< double, 3 > &c)
template<class Container >
auto	L2NormSquared (const Container &c)
template<>
auto	L2NormSquared< std::array< double, 3 > > (const std::array< double, 3 > &c)

Detailed Description

Collection of utility functions and operators for iterable data containers.

Collection of utility functions and operators for iterable data containers like std::array, std::vector, etc.

Function Documentation

elementWisePairOp()

template<class Container , class F >

Container ArrayUtils::elementWisePairOp ( const Container &  lhs, const Container &  rhs, F  binaryFunction  )

inline

Applies an element wise binary function F to two containers.

If the containers differ in size the F is only applied to as many elements as are in the smaller container.

Template Parameters

Container	Type for both containers.
F	Type of binary function.

Parameters

lhs
rhs
binaryFunction

Returns

Element wise F(lhs, rhs).

Definition at line 127 of file ArrayUtils.h.

                                                                                                 {
    Container ret = lhs;
    auto retIter = std::begin(ret);
    auto lhsIter = std::cbegin(lhs);
    const auto lhsEnd = std::cend(lhs);
    auto rhsIter = std::cbegin(rhs);
    const auto rhsEnd = std::cend(rhs);
 
    for (; lhsIter != lhsEnd and rhsIter != rhsEnd; ++lhsIter, ++rhsIter, ++retIter) {
        *retIter = binaryFunction(*lhsIter, *rhsIter);
    }
 
    return ret;
}

elementWiseScalarOp()

template<class Scalar , class Container , class F >

Container ArrayUtils::elementWiseScalarOp ( const Scalar &  lhs, const Container &  rhs, F  binaryFunction  )

inline

Applies a binary function F to with a scalar to every element in a container.

Template Parameters

Scalar	Type of scalar value.
Container	Type of the container.
F

Parameters

lhs
rhs
binaryFunction

Returns

Element wise F(lhs, rhs).

Definition at line 154 of file ArrayUtils.h.

                                                                                                {
    Container ret = rhs;
    auto retIter = std::begin(ret);
    auto rhsIter = std::cbegin(rhs);
    const auto rhsEnd = std::cend(rhs);
 
    for (; rhsIter != rhsEnd; ++rhsIter, ++retIter) {
        *retIter = binaryFunction(lhs, *rhsIter);
    }
 
    return ret;
}

L2Norm()

template<class Container >

auto ArrayUtils::L2Norm

(

const Container &

c

)

Calculates the L2 norm for a given container.

Template Parameters

Container

Parameters

c

Returns

sqrt(sum_i(c[i]*c[i])).

Definition at line 174 of file ArrayUtils.h.

                                {
    return std::sqrt(std::accumulate(std::cbegin(c), std::cend(c), 0.0, [](auto a, auto b) { return a + b * b; }));
}

L2Norm< std::array< double, 3 > >()

template<>

auto ArrayUtils::L2Norm< std::array< double, 3 > > ( const std::array< double, 3 > &  c )

inline

Specialization of L2Norm for std::array<double, 3>.

Returns

sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]).

Definition at line 183 of file ArrayUtils.h.

                                                                      {
    return std::sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);
}

L2NormSquared()

template<class Container >

auto ArrayUtils::L2NormSquared

(

const Container &

c

)

Calculates the L2 norm for a given container.

Template Parameters

Container

Parameters

c

Returns

sqrt(sum_i(c[i]*c[i])).

Definition at line 194 of file ArrayUtils.h.

                                       {
    return std::accumulate(std::cbegin(c), std::cend(c), 0.0, [](auto a, auto b) { return a + b * b; });
}

L2NormSquared< std::array< double, 3 > >()

template<>

auto ArrayUtils::L2NormSquared< std::array< double, 3 > > ( const std::array< double, 3 > &  c )

inline

Specialization of L2Norm for std::array<double, 3>.

Returns

c[0]*c[0] + c[1]*c[1] + c[2]*c[2].

Definition at line 203 of file ArrayUtils.h.

                                                                             {
    return c[0] * c[0] + c[1] * c[1] + c[2] * c[2];
}

to_string()

template<class Container >

std::string ArrayUtils::to_string	(	const Container &	container,
		const std::string &	delimiter = ", ",
		const std::array< std::string, 2 > &	surround = {"[", "]"}
	)

Generates a string representation of a container which fulfills the Container requirement (provide cbegin and cend).

Template Parameters

Container

Type of Container.

Parameters

container	Container to be converted to string.
delimiter	String that is put between items.
surround	Strings to be put before and after the listing (e.g. brackets).

Returns

String representation of container.

Definition at line 97 of file ArrayUtils.h.

                                                                             {"[", "]"}) {
    auto iter = std::cbegin(container);
    const auto end = std::cend(container);
    if (iter == end) {
        return surround[0] + surround[1];
    }
    std::ostringstream strStream;
    strStream << surround[0] << *iter;
    for (++iter; iter != end; ++iter) {
        strStream << delimiter << *iter;
    }
    strStream << surround[1];
    return strStream.str();
}