Synopsis

#include <boost/math/tools/norms.hpp>

namespace boost{ namespace math{ namespace tools {

    template<class Container>
    auto l0_pseudo_norm(Container const & c);

    template<class ForwardIterator>
    auto l0_pseudo_norm(ForwardIterator first, ForwardIterator last);

    template<class ForwardIterator>
    size_t hamming_distance(ForwardIterator first1, ForwardIterator last1, ForwardIterator first2);

    template<class Container>
    size_t hamming_distance(Container const & u, Container const & v);

    template<class Container>
    auto l1_norm(Container const & c);

    template<class ForwardIterator>
    auto l1_norm(ForwardIterator first, ForwardIterator last);

    template<class Container>
    auto l1_distance(Container const & v1, Container const & v2);

    template<class ForwardIterator>
    auto l1_distance(ForwardIterator first1, ForwardIterator last1, ForwardIterator first2);

    template<class Container>
    auto l2_norm(Container const & c);

    template<class ForwardIterator>
    auto l2_norm(ForwardIterator first, ForwardIterator last);

    template<class Container>
    auto l2_distance(Container const & v1, Container const & v2);

    template<class ForwardIterator>
    auto l2_distance(ForwardIterator first1, ForwardIterator last1, ForwardIterator first2);

    template<class Container>
    auto sup_norm(Container const & c);

    template<class ForwardIterator>
    auto sup_norm(ForwardIterator first, ForwardIterator last);

    template<class Container>
    auto sup_distance(Container const & v1, Container const & v2);

    template<class ForwardIterator>
    auto sup_distance(ForwardIterator first1, ForwardIterator last1, ForwardIterator first2);

    template<class Container>
    auto lp_norm(Container const & c, unsigned p);

    template<class ForwardIterator>
    auto lp_norm(ForwardIterator first, ForwardIterator last, unsigned p);

    template<class Container>
    auto lp_distance(Container const & v1, Container const & v2, unsigned p);

    template<class ForwardIterator>
    auto lp_distance(ForwardIterator first1, ForwardIterator last1, ForwardIterator first2, unsigned p);

    template<class Container>
    auto total_variation(Container const & c);

    template<class ForwardIterator>
    auto total_variation(ForwardIterator first, ForwardIterator last);

}}}

Description

The file boost/math/tools/norms.hpp is a set of facilities for computing scalar values traditionally useful in numerical analysis from vectors.

Our examples use std::vector<double> to hold the data, but this not required. In general, you can store your data in an Eigen array, an Armadillo vector, std::array, and for many of the routines, a std::forward_list. These routines are usable in float, double, long double, and Boost.Multiprecision precision, as well as their complex extensions whenever the computation is well-defined. Integral datatypes are supported for most routines.

ℓ^∞ norm

Computes the supremum norm of a dataset:

std::vector<double> v{-3, 2, 1};
double sup = boost::math::tools::sup_norm(v.cbegin(), v.cend());
// sup = 3

std::vector<std::complex<double>> v{{0, -8}, {1,1}, {-3,2}};
// Range call:
double sup = boost::math::tools::sup_norm(v);
// sup = 8

Supports real, integral, and complex arithmetic. Container must be forward iterable and is not modified.

ℓ^∞ distance

Computes the supremum norm distance between two vectors:

std::vector<double> v{-3, 2, 1};
std::vector<double> w{6, -2, 1};
double sup = boost::math::tools::sup_distance(w, v);
// sup = 9

Supports real, integral, and complex arithmetic. Container must be forward iterable and is not modified. If the input it integral, the output is a double precision float.

ℓ^p norm

std::vector<double> v{-8, 0, 0};
double sup = boost::math::tools::lp_norm(v.cbegin(), v.cend(), 7);
// sup = 8

std::vector<std::complex<double>> v{{1, 0}, {0,1}, {0,-1}};
double sup = boost::math::tools::lp_norm(v.cbegin(), v.cend(), 3);
// sup = cbrt(3)

Supports both real, integral, and complex arithmetic. If the input is integral, the output is a double precision float. The container must be forward iterable and the contents are not modified.

Only supports integral p for two reasons: The computation is much slower for real p, and the non-integral ℓ^p norm is rarely used.

ℓ^p distance

std::vector<double> v{-8, 0, 0};
std::vector<double> w{8, 0, 0};
double dist = boost::math::tools::lp_distance(v, w, 7);
// dist = 16

std::vector<std::complex<double>> v{{1, 0}, {0,1}, {0,-1}};
double dist = boost::math::tools::lp_distance(v, v, 3);
// dist = 0

Supports both real, integral, and complex arithmetic. If the input is integral, the output is a double precision float. The container must be forward iterable and the contents are not modified.

Only supports integer p.

ℓ⁰ pseudo-norm

Counts the number of non-zero elements in a container.

std::vector<double> v{0,0,1};
size_t count = boost::math::tools::l0_pseudo_norm(v.begin(), v.end());
// count = 1

Supports real, integral, and complex numbers. The container must be forward iterable and the contents are not modified. Note that this measure is not robust against numerical noise and is therefore not as useful as (say) the Hoyer sparsity in numerical applications. Works with real, complex, and integral inputs.

Hamming Distance

Compute the number of non-equal elements between two vectors w and v:

std::vector<double> v{0,0,1};
std::vector<double> w{1,0,0};
size_t count = boost::math::tools::hamming_distance(w, v);
// count = 2

Works for any datatype for which the operator != is defined.

ℓ¹ norm

The ℓ¹ norm is a special case of the ℓ^p norm, but is much faster:

std::vector<double> v{1,1,1};
double l1 = boost::math::tools::l1_norm(v.begin(), v.end());
// l1 = 3

Requires a forward iterable input, does not modify input data, and works with real, integral, and complex numbers.

ℓ¹ distance

Computes the ℓ¹ distance between two vectors:

std::vector<double> v{1,1,1};
std::vector<double> w{1,1,1};
double dist = boost::math::tools::l1_distance(w, v);
// dist = 0

Requires a forward iterable inputs, does not modify input data, and works with real, integral, and complex numbers. If the input type is integral, the output is a double precision float.

ℓ² norm

The ℓ² norm is again a special case of the ℓ^p norm, but is much faster:

std::vector<double> v{1,1,1};
double l2 = boost::math::tools::l2_norm(v.begin(), v.end());
// l2 = sqrt(3)

Requires a forward iterable input, does not modify input data, and works with real, complex and integral data. If the input is integral, the output is a double precision float.

ℓ² distance

Compute the ℓ² distance between two vectors w and v:

std::vector<double> v{1,1,1};
std::vector<double> w{1,2,1};
double dist = boost::math::tools::l2_distance(w, v);
// dist = 1

Requires a forward iterable input, does not modify input data, and works with real, complex numbers, and integral data. If the input type is integral, the output is a double precision float.

Total Variation

std::vector<double> v{1,1,1};
double tv = boost::math::tools::total_variation(v.begin(), v.end());
// no variation in v, so tv = 0.
v = {0,1};
double tv = boost::math::tools::total_variation(v.begin(), v.end());
// variation is 1, so tv = 1.
std::vector<int> v{1,1,1};
double tv = boost::math::tools::total_variation(v);

The total variation only supports real numbers and integers. If the input is integral, the output is a double precision float.

All the constituent operations to compute the total variation are well-defined for complex numbers, but the computed result is not meaningful; a 2D total variation is more appropriate. The container must be forward iterable, and the contents are not modified.

As an aside, the total variation is not technically a norm, since TV(v) = 0 does not imply v = 0. However, it satisfies the triangle inequality and is absolutely 1-homogeneous, so it is a seminorm, and hence is grouped with the other norms here.

References