Magnum::Math namespace

Math library.

Template classes for matrix and vector calculations.

This library is built as part of Magnum by default. To use this library with CMake, find the Magnum package and link to the Magnum::Magnum target:

find_package(Magnum REQUIRED)

# ...
target_link_libraries(your-app PRIVATE Magnum::Magnum)

See Downloading and building, Usage with CMake, Operations with matrices and vectors and 2D and 3D transformations for more information.

Namespaces

namespace Algorithms
Algorithms.
namespace Distance
Functions for calculating distances.
namespace Intersection
Functions for calculating intersections.
namespace Literals
Math literals.

Classes

template<UnsignedInt order, UnsignedInt dimensions, class T>
class Bezier
Bézier curve.
template<std::size_t size>
class BitVector new in Git master
Vector of bits.
template<class T>
class Color3
Color in linear RGB color space.
template<class T = Float>
class Color4
Color in linear RGBA color space.
template<class T>
struct ColorHsv new in 2019.10
HSV color.
template<class T>
class Complex
Complex number.
template<class T>
struct Constants
Numeric constants.
template<class T>
class CubicHermite
Cubic Hermite spline point.
template<class T>
class Deg
Angle in degrees.
template<class T>
class Dual
Dual number.
template<class T>
class DualComplex
Dual complex number.
template<class T>
class DualQuaternion
Dual quaternion.
template<class T>
class Frustum
Camera frustum.
class Half
Half-precision float literal.
struct IdentityInitT
Identity initialization tag type.
template<class T>
struct IsFloatingPoint new in 2019.10
Whether T is floating-point.
template<class T>
struct IsIntegral new in 2019.10
Whether T is integral.
template<class T>
struct IsScalar new in 2019.10
Whether T is an arithmetic scalar type.
template<class T>
struct IsUnitless new in 2019.10
Whether T is a unitless type.
template<class T>
struct IsVector new in 2019.10
Whether T is an arithmetic vector type.
template<std::size_t size, class T>
class Matrix
Square matrix.
template<class T>
class Matrix3
2D transformation matrix
template<class T>
class Matrix4
3D transformation matrix
template<class T>
class Nanoseconds new in Git master
Nanoseconds.
template<class T>
class Quaternion
Quaternion.
template<class T>
class Rad
Angle in radians.
template<UnsignedInt dimensions, class T>
class Range
N-dimensional range.
template<class T>
class Range2D
Two-dimensional range.
template<class T>
class Range3D
Three-dimensional range.
template<std::size_t cols, std::size_t rows, class T>
class RectangularMatrix
Rectangular matrix.
template<class T>
class Seconds new in Git master
Seconds.
struct StrictWeakOrdering
A functor which implements strict weak ordering.
template<class T>
struct TypeTraits
Traits class for builtin arithmetic types.
template<template<class> class Derived, class T>
class Unit
Base class for units.
template<std::size_t size, class T>
class Vector
Vector.
template<class T>
class Vector2
Two-component vector.
template<class T>
class Vector3
Three-component vector.
template<class T>
class Vector4
Four-component vector.
struct ZeroInitT
Zero initialization tag type.

Typedefs

template<UnsignedInt dimensions, class T>
using QuadraticBezier = Bezier<2, dimensions, T>
Quadratic Bézier curve.
template<class T>
using QuadraticBezier2D = QuadraticBezier<2, T>
Two-dimensional quadratic Bézier curve.
template<class T>
using QuadraticBezier3D = QuadraticBezier<3, T>
Three-dimensional quadratic Bézier curve.
template<UnsignedInt dimensions, class T>
using CubicBezier = Bezier<3, dimensions, T>
Cubic Bézier curve.
template<class T>
using CubicBezier2D = CubicBezier<2, T>
Two-dimensional cubic Bézier curve.
template<class T>
using CubicBezier3D = CubicBezier<3, T>
Three-dimensional cubic Bézier curve.
template<std::size_t size>
using BoolVector = BitVector<size> deprecated in Git master
Vector of bits.
template<class T>
using CubicHermite1D = CubicHermite<T>
Scalar cubic Hermite spline point.
template<class T>
using CubicHermite2D = CubicHermite<Vector2<T>>
Two-dimensional cubic Hermite spline point.
template<class T>
using CubicHermite3D = CubicHermite<Vector3<T>>
Three-dimensional cubic Hermite spline point.
template<class T>
using CubicHermiteComplex = CubicHermite<Complex<T>>
Cubic Hermite spline complex number.
template<class T>
using CubicHermiteQuaternion = CubicHermite<Quaternion<T>>
Cubic Hermite spline quaternion.
template<class T>
using Matrix2x2 = Matrix<2, T>
2x2 matrix
template<class T>
using Matrix3x3 = Matrix<3, T>
3x3 matrix
template<class T>
using Matrix4x4 = Matrix<4, T>
4x4 matrix
template<class T>
using Range1D = Range<1, T>
One-dimensional range.
template<class T>
using Matrix2x1 = RectangularMatrix<2, 1, T> new in Git master
Matrix with 2 columns and 1 row.
template<class T>
using Matrix2x3 = RectangularMatrix<2, 3, T>
Matrix with 2 columns and 3 rows.
template<class T>
using Matrix2x4 = RectangularMatrix<2, 4, T>
Matrix with 2 columns and 4 rows.
template<class T>
using Matrix3x1 = RectangularMatrix<3, 1, T> new in Git master
Matrix with 3 columns and 1 row.
template<class T>
using Matrix3x2 = RectangularMatrix<3, 2, T>
Matrix with 3 columns and 2 rows.
template<class T>
using Matrix3x4 = RectangularMatrix<3, 4, T>
Matrix with 3 columns and 4 rows.
template<class T>
using Matrix4x1 = RectangularMatrix<4, 1, T> new in Git master
Matrix with 4 columns and 1 row.
template<class T>
using Matrix4x2 = RectangularMatrix<4, 2, T>
Matrix with 4 columns and 2 rows.
template<class T>
using Matrix4x3 = RectangularMatrix<4, 3, T>
Matrix with 4 columns and 3 rows.
using NoInitT = Magnum::NoInitT deprecated in 2020.06
No initialization tag type.
template<class T>
using UnderlyingTypeOf = typename Implementation::UnderlyingType<T>::Type new in 2019.10
Underlying type of a math type.

Functions

template<class T>
auto operator<<(Utility::Debug& debug, const Unit<Rad, T>& value) -> Utility::Debug&
Debug output operator.
template<class T>
auto operator<<(Utility::Debug& debug, const Unit<Deg, T>& value) -> Utility::Debug&
Debug output operator.
template<UnsignedInt order, UnsignedInt dimensions, class T>
auto operator<<(Debug& debug, const Bezier<order, dimensions, T>& value) -> Utility::Debug&
Debug output operator.
template<std::size_t size>
auto operator<<(Debug& debug, const BitVector<size>& value) -> Debug& new in Git master
Debug output operator.
template<class T>
auto xyYToXyz(const Vector3<T>& xyY) -> Vector3<T>
Convert color from CIE xyY representation to CIE XYZ.
template<class T>
auto xyzToXyY(const Vector3<T>& xyz) -> Vector3<T>
Convert color from CIE XYZ representation to CIE xyY
template<class T>
auto operator<<(Debug& debug, const ColorHsv<T>& value) -> Debug&
Debug output operator.
auto operator<<(Debug& debug, const Color3<UnsignedByte>& value) -> Debug&
Debug output operator.
auto operator<<(Debug& debug, const Color4<UnsignedByte>& value) -> Debug&
Debug output operator.
void yFlipBc1InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
Y-flip BC1 texture blocks in-place.
void yFlipBc2InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
Y-flip BC2 texture blocks in-place.
void yFlipBc3InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
Y-flip BC3 texture blocks in-place.
void yFlipBc4InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
Y-flip BC4 texture blocks in-place.
void yFlipBc5InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
Y-flip BC5 texture blocks in-place.
template<class T>
auto dot(const Complex<T>& a, const Complex<T>& b) -> T
Dot product of two complex numbers.
template<class T>
auto angle(const Complex<T>& normalizedA, const Complex<T>& normalizedB) -> Rad<T>
Angle between normalized complex numbers.
template<class T>
auto operator*(const Vector2<T>& vector, const Complex<T>& complex) -> Complex<T>
Multiply a vector with a complex number.
template<class T>
auto lerp(const Complex<T>& normalizedA, const Complex<T>& normalizedB, T t) -> Complex<T>
Linear interpolation of two complex numbers.
template<class T>
auto slerp(const Complex<T>& normalizedA, const Complex<T>& normalizedB, T t) -> Complex<T>
Spherical linear interpolation of two complex numbers.
template<class T>
auto operator<<(Debug& debug, const Complex<T>& value) -> Debug&
Debug output operator.
template<class T>
auto operator<<(Debug& debug, const CubicHermite<T>& value) -> Debug&
Debug output operator.
template<class T, class U>
auto select(const CubicHermite<T>& a, const CubicHermite<T>& b, U t) -> T
Constant interpolation of two cubic Hermite spline points.
template<class T, class U>
auto lerp(const CubicHermite<T>& a, const CubicHermite<T>& b, U t) -> T
Linear interpolation of two cubic Hermite points.
template<class T>
auto lerp(const CubicHermiteComplex<T>& a, const CubicHermiteComplex<T>& b, T t) -> Complex<T>
Linear interpolation of two cubic Hermite complex numbers.
template<class T>
auto lerp(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t) -> Quaternion<T>
Linear interpolation of two cubic Hermite quaternions.
template<class T>
auto lerpShortestPath(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t) -> Quaternion<T>
Linear shortest-path interpolation of two cubic Hermite quaternions.
template<class T>
auto slerp(const CubicHermiteComplex<T>& a, const CubicHermiteComplex<T>& b, T t) -> Complex<T>
Spherical linear interpolation of two cubic Hermite complex numbers.
template<class T>
auto slerp(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t) -> Quaternion<T>
Spherical linear interpolation of two cubic Hermite quaternions.
template<class T>
auto slerpShortestPath(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t) -> Quaternion<T>
Spherical linear shortest-path interpolation of two cubic Hermite quaternions.
template<class T, class U>
auto splerp(const CubicHermite<T>& a, const CubicHermite<T>& b, U t) -> T
Spline interpolation of two cubic Hermite points.
template<class T>
auto splerp(const CubicHermiteComplex<T>& a, const CubicHermiteComplex<T>& b, T t) -> Complex<T>
Spline interpolation of two cubic Hermite complex numbers.
template<class T>
auto splerp(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t) -> Quaternion<T>
Spline interpolation of two cubic Hermite quaternions.
template<class T>
auto operator<<(Debug& debug, const Dual<T>& value) -> Debug&
Debug output operator.
template<class T>
auto sqrt(const Dual<T>& dual) -> Dual<T>
Square root of dual number.
template<class T>
auto sincos(const Dual<Rad<T>>& angle) -> Containers::Pair<Dual<T>, Dual<T>>
Sine and cosine of dual angle.
template<class T>
auto operator<<(Debug& debug, const DualComplex<T>& value) -> Debug&
Debug output operator.
template<class T>
auto sclerp(const DualQuaternion<T>& normalizedA, const DualQuaternion<T>& normalizedB, const T t) -> DualQuaternion<T>
Screw linear interpolation of two dual quaternions.
template<class T>
auto sclerpShortestPath(const DualQuaternion<T>& normalizedA, const DualQuaternion<T>& normalizedB, const T t) -> DualQuaternion<T>
Screw linear shortest-path interpolation of two dual quaternions.
template<class T>
auto operator<<(Debug& debug, const DualQuaternion<T>& value) -> Debug&
Debug output operator.
template<class T>
auto operator<<(Debug& debug, const Frustum<T>& value) -> Debug&
Debug output operator.
template<class Integral>
auto div(Integral x, Integral y) -> Containers::Pair<Integral, Integral>
Integer division with remainder.
auto binomialCoefficient(UnsignedInt n, UnsignedInt k) -> UnsignedLong new in Git master
Binomial coefficient.
auto popcount(UnsignedInt number) -> UnsignedInt new in Git master
Count of bits set in a number.
auto popcount(UnsignedLong number) -> UnsignedInt new in Git master
template<std::size_t size, class T>
auto reflect(const Vector<size, T>& vector, const Vector<size, T>& normal) -> Vector<size, T> new in 2020.06
Reflect a vector.
template<std::size_t size, class T>
auto refract(const Vector<size, T>& vector, const Vector<size, T>& normal, T eta) -> Vector<size, T> new in 2020.06
Refract a vector.
auto operator<<(Debug& debug, Half value) -> Debug&
Debug output operator.
template<class T>
auto dot(const Quaternion<T>& a, const Quaternion<T>& b) -> T
Dot product between two quaternions.
template<class T>
auto halfAngle(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB) -> Rad<T>
Half-angle between normalized quaternions.
template<class T>
auto angle(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB) -> Rad<T> deprecated in Git master
Half-angle between normalized quaternions.
template<class T>
auto lerp(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB, T t) -> Quaternion<T>
Linear interpolation of two quaternions.
template<class T>
auto lerpShortestPath(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB, T t) -> Quaternion<T>
Linear shortest-path interpolation of two quaternions.
template<class T>
auto slerp(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB, T t) -> Quaternion<T>
Spherical linear interpolation of two quaternions.
template<class T>
auto slerpShortestPath(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB, T t) -> Quaternion<T>
Spherical linear shortest-path interpolation of two quaternions.
template<class T>
auto operator<<(Debug& debug, const Quaternion<T>& value) -> Debug&
Debug output operator.
template<UnsignedInt dimensions, class T>
auto join(const Range<dimensions, T>& a, const Range<dimensions, T>& b) -> Range<dimensions, T>
Join two ranges.
template<UnsignedInt dimensions, class T>
auto join(const Range<dimensions, T>& a, const Vector<dimensions, T>& b) -> Range<dimensions, T> new in Git master
Join a range and a point.
template<UnsignedInt dimensions, class T>
auto intersect(const Range<dimensions, T>& a, const Range<dimensions, T>& b) -> Range<dimensions, T>
Intersect two ranges.
template<UnsignedInt dimensions, class T>
auto intersects(const Range<dimensions, T>& a, const Range<dimensions, T>& b) -> bool
Whether two ranges intersect.
template<UnsignedInt dimensions, class T>
auto operator<<(Debug& debug, const Range<dimensions, T>& value) -> Debug&
Debug output operator.
template<std::size_t cols, std::size_t rows, class T>
auto operator<<(Debug& debug, const Magnum::Math::RectangularMatrix<cols, rows, T>& value) -> Debug&
Debug output operator.
template<char ... components, class T>
auto gather(const T& vector) -> Implementation::TypeForSize<sizeof...(components), T>::Type constexpr new in 2019.10
Gather Vector components.
template<char ... components, class T>
auto scatter(const T& vector, const Vector<sizeof...(components), typename T::Type>& values) -> T constexpr new in 2019.10
Scatter Vector components.
auto operator<<(Utility::Debug& debug, const Unit<Nanoseconds, Long>& value) -> Utility::Debug& new in Git master
Debug output operator.
auto operator<<(Utility::Debug& debug, const Unit<Seconds, Float>& value) -> Utility::Debug& new in Git master
Debug output operator.
template<class T>
auto equal(T a, T b) -> std::enable_if<IsScalar<T>::value, bool>::type new in 2019.10
Equality comparison of scalar types.
template<class T>
auto notEqual(T a, T b) -> std::enable_if<IsScalar<T>::value, bool>::type new in 2019.10
Non-equality comparison of scalar types.
template<std::size_t size, class T>
auto dot(const Vector<size, T>& a, const Vector<size, T>& b) -> T
Dot product of two vectors.
template<std::size_t size, class FloatingPoint>
auto angle(const Vector<size, FloatingPoint>& normalizedA, const Vector<size, FloatingPoint>& normalizedB) -> Rad<FloatingPoint>
Angle between normalized vectors.
template<std::size_t size, class T>
auto equal(const Vector<size, T>& a, const Vector<size, T>& b) -> BitVector<size> new in 2019.10
Component-wise equality comparison.
template<std::size_t size, class T>
auto notEqual(const Vector<size, T>& a, const Vector<size, T>& b) -> BitVector<size> new in 2019.10
Component-wise non-equality comparison.
template<std::size_t size, class T>
auto operator<<(Debug& debug, const Vector<size, T>& value) -> Debug&
Debug output operator.
template<class T>
auto cross(const Vector2<T>& a, const Vector2<T>& b) -> T
2D cross product
template<class T>
auto cross(const Vector3<T>& a, const Vector3<T>& b) -> Vector3<T>
Cross product
template<class T>
auto planeEquation(const Vector3<T>& p0, const Vector3<T>& p1, const Vector3<T>& p2) -> Vector4<T>
Create a plane equation from three points.
template<class T>
auto planeEquation(const Vector3<T>& normal, const Vector3<T>& point) -> Vector4<T>
Create a plane equation from a normal and a point.

Variables

Magnum::NoInitT NoInit deprecated in 2020.06 constexpr
No initialization tag.
ZeroInitT ZeroInit constexpr
Zero initialization tag.
IdentityInitT IdentityInit constexpr
Identity initialization tag.

Trigonometric functions

Unlike std::sin() and friends, those take or return strongly-typed units to prevent degrees being accidentally interpreted as radians and such. See Deg and Rad for more information.

template<class T>
auto sin(Rad<T> angle) -> T
Sine.
template<class T>
auto cos(Rad<T> angle) -> T
Cosine.
template<class T>
auto sincos(Rad<T> angle) -> Containers::Pair<T, T>
Sine and cosine.
template<class T>
auto tan(Rad<T> angle) -> T
Tangent.
template<class T>
auto asin(T value) -> Rad<T>
Arc sine.
template<class T>
auto acos(T value) -> Rad<T>
Arc cosine.
template<class T>
auto atan(T value) -> Rad<T>
Arc tangent.

Scalar/vector functions

These functions are overloaded for both scalar and vector types, including Deg and Rad. Scalar versions function exactly as their possible STL equivalents, vector overloads perform the operations component-wise.

template<class T>
auto isInf(T value) -> std::enable_if<IsScalar<T>::value, bool>::type new in 2019.10
If given number is a positive or negative infinity.
template<std::size_t size, class T>
auto isInf(const Vector<size, T>& value) -> BitVector<size> new in 2019.10
template<class T>
auto isNan(T value) -> std::enable_if<IsScalar<T>::value, bool>::type new in 2019.10
If given number is a NaN.
template<std::size_t size, class T>
auto isNan(const Vector<size, T>& value) -> BitVector<size> new in 2019.10
template<class T>
auto min(T value, T min) -> std::enable_if<IsScalar<T>::value, T>::type constexpr
Minimum.
template<std::size_t size, class T>
auto min(const Vector<size, T>& value, const Vector<size, T>& min) -> Vector<size, T>
template<std::size_t size, class T>
auto min(const Vector<size, T>& value, T min) -> Vector<size, T>
template<class T>
auto max(T a, T b) -> std::enable_if<IsScalar<T>::value, T>::type constexpr
Maximum.
template<std::size_t size, class T>
auto max(const Vector<size, T>& value, const Vector<size, T>& max) -> Vector<size, T>
template<std::size_t size, class T>
auto max(const Vector<size, T>& value, T max) -> Vector<size, T>
template<class T>
auto minmax(T a, T b) -> std::enable_if<IsScalar<T>::value, Containers::Pair<T, T>>::type
Minimum and maximum of two values.
template<std::size_t size, class T>
auto minmax(const Vector<size, T>& a, const Vector<size, T>& b) -> Containers::Pair<Vector<size, T>, Vector<size, T>>
template<class T>
auto clamp(T value, T min, T max) -> std::enable_if<IsScalar<T>::value, T>::type constexpr
Clamp value.
template<std::size_t size, class T>
auto clamp(const Vector<size, T>& value, const Vector<size, T>& min, const Vector<size, T>& max) -> Vector<size, T>
template<std::size_t size, class T>
auto clamp(const Vector<size, T>& value, T min, T max) -> Vector<size, T>
template<class T>
auto sign(T scalar) -> std::enable_if<IsScalar<T>::value, UnderlyingTypeOf<T>>::type
Sign.
template<std::size_t size, class T>
auto sign(const Vector<size, T>& a) -> Vector<size, UnderlyingTypeOf<T>>
template<class T>
auto abs(T a) -> std::enable_if<IsScalar<T>::value, T>::type
Absolute value.
template<std::size_t size, class T>
auto abs(const Vector<size, T>& a) -> Vector<size, T>
template<class T>
auto floor(T a) -> std::enable_if<IsScalar<T>::value, T>::type
Nearest not larger integer.
template<std::size_t size, class T>
auto floor(const Vector<size, T>& a) -> Vector<size, T>
template<class T>
auto round(T a) -> std::enable_if<IsScalar<T>::value, T>::type
Round value to nearest integer.
template<std::size_t size, class T>
auto round(const Vector<size, T>& a) -> Vector<size, T>
template<class T>
auto ceil(T a) -> std::enable_if<IsScalar<T>::value, T>::type
Nearest not smaller integer.
template<std::size_t size, class T>
auto ceil(const Vector<size, T>& a) -> Vector<size, T>
template<class T>
auto fmod(T a, T b) -> std::enable_if<IsScalar<T>::value, T>::type new in Git master
Floating point division remainder.
template<std::size_t size, class T>
auto fmod(const Vector<size, T>& a, const Vector<size, T>& b) -> Vector<size, T> new in Git master
template<std::size_t size, class T>
auto fmod(const Vector<size, T>& a, T b) -> Vector<size, T> new in Git master
template<class T, class U>
auto lerp(const T& a, const T& b, U t) -> T
Linear interpolation of two values.
template<class T>
auto lerp(const T& a, const T& b, bool t) -> T
template<std::size_t size, class T>
auto lerp(const Vector<size, T>& a, const Vector<size, T>& b, const BitVector<size>& t) -> Vector<size, T>
template<std::size_t size>
auto lerp(const BitVector<size>& a, const BitVector<size>& b, const BitVector<size>& t) -> BitVector<size>
template<class T>
auto lerpInverted(T a, T b, T lerp) -> UnderlyingTypeOf<typename std::enable_if<IsScalar<T>::value, T>::type>
Inverse linear interpolation of two values.
template<std::size_t size, class T>
auto lerpInverted(const Vector<size, T>& a, const Vector<size, T>& b, const Vector<size, T>& lerp) -> Vector<size, UnderlyingTypeOf<T>>
template<class T, class U>
auto select(const T& a, const T& b, U t) -> T constexpr
Constant interpolation of two values.
template<class T>
auto fma(T a, T b, T c) -> std::enable_if<IsScalar<T>::value, T>::type
Fused multiply-add.
template<std::size_t size, class T>
auto fma(const Vector<size, T>& a, const Vector<size, T>& b, const Vector<size, T>& c) -> Vector<size, T>

Exponential and power functions

Unlike scalar/vector functions these don't work on Deg / Rad as the resulting unit can't be easily expressed.

auto log(UnsignedInt base, UnsignedInt number) -> UnsignedInt
Integral logarithm.
auto log2(UnsignedInt number) -> UnsignedInt
Base-2 integral logarithm.
template<class T>
auto log(T number) -> T
Natural logarithm.
template<class T>
auto exp(T exponent) -> T
Natural exponential.
template<UnsignedInt exponent, class T>
auto pow(T base) -> std::enable_if<IsScalar<T>::value, T>::type constexpr
Integral power.
template<UnsignedInt exponent, std::size_t size, class T>
auto pow(const Vector<size, T>& base) -> Vector<size, T>
template<class T>
auto pow(T base, T exponent) -> std::enable_if<IsScalar<T>::value, T>::type
Power.
template<std::size_t size, class T>
auto pow(const Vector<size, T>& base, T exponent) -> Vector<size, T>
template<class T>
auto sqrt(T a) -> std::enable_if<IsScalar<T>::value, T>::type
Square root.
template<std::size_t size, class T>
auto sqrt(const Vector<size, T>& a) -> Vector<size, T>
template<class T>
auto sqrtInverted(T a) -> std::enable_if<IsScalar<T>::value, T>::type
Inverse square root.
template<std::size_t size, class T>
auto sqrtInverted(const Vector<size, T>& a) -> Vector<size, T>

Batch functions

These functions process an ubounded range of values, as opposed to single vectors or scalars.

template<class T>
auto isInf(const Containers::StridedArrayView1D<const T>& range) -> auto
If any number in the range is a positive or negative infinity.
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
auto isInf(Iterable&& range) -> auto new in 2020.06
template<class T>
auto isInf(std::initializer_list<T> list) -> auto
template<class T, std::size_t size>
auto isInf(const T(&array)[size]) -> auto
template<class T>
auto isNan(const Containers::StridedArrayView1D<const T>& range) -> auto
If any number in the range is a NaN.
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
auto isNan(Iterable&& range) -> auto new in 2020.06
template<class T>
auto isNan(std::initializer_list<T> list) -> auto
template<class T, std::size_t size>
auto isNan(const T(&array)[size]) -> auto
template<class T>
auto min(const Containers::StridedArrayView1D<const T>& range) -> T
Minimum of a range.
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
auto min(Iterable&& range) -> T new in 2020.06
template<class T>
auto min(std::initializer_list<T> list) -> T
template<class T, std::size_t size>
auto min(const T(&array)[size]) -> T
template<class T>
auto max(const Containers::StridedArrayView1D<const T>& range) -> T
Maximum of a range.
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
auto max(Iterable&& range) -> T new in 2020.06
template<class T>
auto max(std::initializer_list<T> list) -> T
template<class T, std::size_t size>
auto max(const T(&array)[size]) -> T
template<class T>
auto minmax(const Containers::StridedArrayView1D<const T>& range) -> Containers::Pair<T, T>
Minimum and maximum of a range.
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
auto minmax(Iterable&& range) -> Containers::Pair<T, T> new in 2020.06
template<class T>
auto minmax(std::initializer_list<T> list) -> Containers::Pair<T, T>
template<class T, std::size_t size>
auto minmax(const T(&array)[size]) -> Containers::Pair<T, T>

Packing and unpacking functions

Similarly to scalar/vector functions these work on both scalars and vectors, including Deg and Rad.

template<class FloatingPoint, class Integral>
auto unpack(const Integral& value) -> FloatingPoint
Unpack integral value into a floating-point representation.
template<class FloatingPoint, class Integral, UnsignedInt bits>
auto unpack(const Integral& value) -> FloatingPoint
Unpack integer bits into a floating-point representation.
template<class Integral, class FloatingPoint>
auto pack(const FloatingPoint& value) -> Integral
Pack floating-point value into an integer representation.
template<class Integral, UnsignedInt bits, class FloatingPoint>
auto pack(FloatingPoint value) -> Integral
Pack floating-point value into integer bits.
auto packHalf(Float value) -> UnsignedShort
Pack 32-bit float value into 16-bit half-float representation.
template<std::size_t size>
auto packHalf(const Vector<size, Float>& value) -> Vector<size, UnsignedShort>
auto unpackHalf(UnsignedShort value) -> Float
Unpack 16-bit half-float value into 32-bit float representation.
template<std::size_t size>
auto unpackHalf(const Vector<size, UnsignedShort>& value) -> Vector<size, Float>

Batch packing functions

These functions process an ubounded range of values, as opposed to single vectors or scalars.

void unpackInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
Unpack unsigned integral values into a floating-point representation.
void unpackInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
void unpackInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
Unpack signed integral values into a floating-point representation.
void unpackInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
void packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in 2020.06
Pack floating-point values into an integer representation.
void packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Byte>& dst) new in 2020.06
void packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in 2020.06
void packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Short>& dst) new in 2020.06
void packHalfInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in 2020.06
Pack 32-bit float values into 16-bit half-float representation.
void unpackHalfInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
Unpack a range of 16-bit half-float values into 32-bit float representation.
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
Cast integer values into a 32-bit floating-point representation.
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
Cast integer values into a 64-bit floating-point representation.
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in 2020.06
Cast 32-bit floating-point values into an integer representation.
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Byte>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Short>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Int>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in Git master
Cast 64-bit floating-point values into an integer representation.
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Byte>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Short>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Int>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in Git master
Cast integer values into a differently sized type.
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Short>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Int>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Int>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Long>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Long>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Long>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Int>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Short>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Byte>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Short>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Byte>& dst) new in 2020.06
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Byte>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
Cast 32-bit floating-point values into a 64-bit floating-point representation.
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Float>& dst) new in Git master
Cast 64-bit floating-point values into a 32-bit floating-point representation.
void castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in Git master
Copy values.
void castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Byte>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Short>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Int>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Long>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Float>& dst) new in Git master
void castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master

Typedef documentation

#include <Magnum/Math/Bezier.h>
template<UnsignedInt dimensions, class T>
using Magnum::Math::QuadraticBezier = Bezier<2, dimensions, T>

Quadratic Bézier curve.

Convenience alternative to Bezier<2, dimensions, T>. See Bezier for more information.

#include <Magnum/Math/Bezier.h>
template<class T>
using Magnum::Math::QuadraticBezier2D = QuadraticBezier<2, T>

Two-dimensional quadratic Bézier curve.

Convenience alternative to QuadraticBezier<2, T>. See QuadraticBezier and Bezier for more information.

#include <Magnum/Math/Bezier.h>
template<class T>
using Magnum::Math::QuadraticBezier3D = QuadraticBezier<3, T>

Three-dimensional quadratic Bézier curve.

Convenience alternative to QuadraticBezier<3, T>. See QuadraticBezier and Bezier for more information.

#include <Magnum/Math/Bezier.h>
template<UnsignedInt dimensions, class T>
using Magnum::Math::CubicBezier = Bezier<3, dimensions, T>

Cubic Bézier curve.

Convenience alternative to Bezier<3, dimensions, T>. See Bezier for more information.

#include <Magnum/Math/Bezier.h>
template<class T>
using Magnum::Math::CubicBezier2D = CubicBezier<2, T>

Two-dimensional cubic Bézier curve.

Convenience alternative to CubicBezier<2, T>. See CubicBezier and Bezier for more information.

#include <Magnum/Math/Bezier.h>
template<class T>
using Magnum::Math::CubicBezier3D = CubicBezier<3, T>

Three-dimensional cubic Bézier curve.

Convenience alternative to CubicBezier<3, T>. See CubicBezier and Bezier for more information.

#include <Magnum/Math/BoolVector.h>
template<std::size_t size>
using Magnum::Math::BoolVector = BitVector<size>

Vector of bits.

#include <Magnum/Math/CubicHermite.h>
template<class T>
using Magnum::Math::CubicHermite1D = CubicHermite<T>

Scalar cubic Hermite spline point.

Convenience alternative to CubicHermite<T>. See CubicHermite for more information.

#include <Magnum/Math/CubicHermite.h>
template<class T>
using Magnum::Math::CubicHermite2D = CubicHermite<Vector2<T>>

Two-dimensional cubic Hermite spline point.

Convenience alternative to CubicHermite<Vector2<T>>. See CubicHermite for more information.

#include <Magnum/Math/CubicHermite.h>
template<class T>
using Magnum::Math::CubicHermite3D = CubicHermite<Vector3<T>>

Three-dimensional cubic Hermite spline point.

Convenience alternative to CubicHermite<Vector2<T>>. See CubicHermite for more information.

#include <Magnum/Math/CubicHermite.h>
template<class T>
using Magnum::Math::CubicHermiteComplex = CubicHermite<Complex<T>>

Cubic Hermite spline complex number.

Convenience alternative to CubicHermite<Complex<T>>. See CubicHermite for more information.

#include <Magnum/Math/CubicHermite.h>
template<class T>
using Magnum::Math::CubicHermiteQuaternion = CubicHermite<Quaternion<T>>

Cubic Hermite spline quaternion.

Convenience alternative to CubicHermite<Quaternion<T>>. See CubicHermite for more information.

#include <Magnum/Math/Matrix.h>
template<class T>
using Magnum::Math::Matrix2x2 = Matrix<2, T>

2x2 matrix

Convenience alternative to Matrix<2, T>. See Matrix for more information.

#include <Magnum/Math/Matrix.h>
template<class T>
using Magnum::Math::Matrix3x3 = Matrix<3, T>

3x3 matrix

Convenience alternative to Matrix<3, T>. See Matrix for more information. Note that this is different from Matrix3, which contains additional functions for transformations in 2D.

#include <Magnum/Math/Matrix.h>
template<class T>
using Magnum::Math::Matrix4x4 = Matrix<4, T>

4x4 matrix

Convenience alternative to Matrix<4, T>. See Matrix for more information. Note that this is different from Matrix4, which contains additional functions for transformations in 3D.

#include <Magnum/Math/Range.h>
template<class T>
using Magnum::Math::Range1D = Range<1, T>

One-dimensional range.

Convenience alternative to Range<1, T>. See Range for more information.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix2x1 = RectangularMatrix<2, 1, T> new in Git master

Matrix with 2 columns and 1 row.

Convenience alternative to RectangularMatrix<2, 1, T>. See RectangularMatrix for more information. There's no 1-column 2-row matrix typedef, use Vector2 instead.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix2x3 = RectangularMatrix<2, 3, T>

Matrix with 2 columns and 3 rows.

Convenience alternative to RectangularMatrix<2, 3, T>. See RectangularMatrix for more information.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix2x4 = RectangularMatrix<2, 4, T>

Matrix with 2 columns and 4 rows.

Convenience alternative to RectangularMatrix<2, 4, T>. See RectangularMatrix for more information.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix3x1 = RectangularMatrix<3, 1, T> new in Git master

Matrix with 3 columns and 1 row.

Convenience alternative to RectangularMatrix<3, 1, T>. See RectangularMatrix for more information. There's no 1-column 3-row matrix typedef, use Vector3 instead.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix3x2 = RectangularMatrix<3, 2, T>

Matrix with 3 columns and 2 rows.

Convenience alternative to RectangularMatrix<3, 2, T>. See RectangularMatrix for more information.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix3x4 = RectangularMatrix<3, 4, T>

Matrix with 3 columns and 4 rows.

Convenience alternative to RectangularMatrix<3, 4, T>. See RectangularMatrix for more information.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix4x1 = RectangularMatrix<4, 1, T> new in Git master

Matrix with 4 columns and 1 row.

Convenience alternative to RectangularMatrix<4, 1, T>. See RectangularMatrix for more information. There's no 1-column 4-row matrix typedef, use Vector4 instead.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix4x2 = RectangularMatrix<4, 2, T>

Matrix with 4 columns and 2 rows.

Convenience alternative to RectangularMatrix<4, 2, T>. See RectangularMatrix for more information.

#include <Magnum/Math/RectangularMatrix.h>
template<class T>
using Magnum::Math::Matrix4x3 = RectangularMatrix<4, 3, T>

Matrix with 4 columns and 3 rows.

Convenience alternative to RectangularMatrix<4, 3, T>. See RectangularMatrix for more information.

typedef Magnum::NoInitT Magnum::Math::NoInitT
#include <Magnum/Math/Tags.h>

No initialization tag type.

#include <Magnum/Math/TypeTraits.h>
template<class T>
using Magnum::Math::UnderlyingTypeOf = typename Implementation::UnderlyingType<T>::Type new in 2019.10

Underlying type of a math type.

For builtin scalar types returns the type itself, for wrapped types like Deg or Rad returns the underlying builtin type, for vector and matrix types the type of their components.

For scalar types it's guaranteed that the input type is always explicitly convertible to the output type and the output type is usable with standard APIs such as std::isinf().

Function documentation

#include <Magnum/Math/Angle.h>
template<class T>
Utility::Debug& Magnum::Math::operator<<(Utility::Debug& debug, const Unit<Rad, T>& value)

Debug output operator.

#include <Magnum/Math/Angle.h>
template<class T>
Utility::Debug& Magnum::Math::operator<<(Utility::Debug& debug, const Unit<Deg, T>& value)

Debug output operator.

#include <Magnum/Math/Bezier.h>
template<UnsignedInt order, UnsignedInt dimensions, class T>
Utility::Debug& Magnum::Math::operator<<(Debug& debug, const Bezier<order, dimensions, T>& value)

Debug output operator.

#include <Magnum/Math/BitVector.h>
template<std::size_t size>
Debug& Magnum::Math::operator<<(Debug& debug, const BitVector<size>& value) new in Git master

Debug output operator.

In order to avoid potential confusion, prints the value as a comma-separated sequence of binary literals, so the output corresponds to how the value would be constructed. For example,

Debug{} << BitVector4{0b1010}
        << Math::BitVector<19>{0b00001000, 0b00000011, 0b100};

prints as

BitVector(0b1010) BitVector(0b00001000, 0b00000011, 0b100)

Note that this, on the other hand, makes mapping to bit indices less obvious — see Bit indexing for more information.

#include <Magnum/Math/Color.h>
template<class T>
Vector3<T> Magnum::Math::xyYToXyz(const Vector3<T>& xyY)

Convert color from CIE xyY representation to CIE XYZ.

\[ \begin{array}{rcl} X & = & \dfrac{Y}{y}x \\ Z & = & \dfrac{Y}{y}(1 - x - y) \end{array} \]

#include <Magnum/Math/Color.h>
template<class T>
Vector3<T> Magnum::Math::xyzToXyY(const Vector3<T>& xyz)

Convert color from CIE XYZ representation to CIE xyY

\[ \begin{array}{rcl} x & = & \dfrac{X}{X + Y + Z} \\ y & = & \dfrac{Y}{X + Y + Z} \end{array} \]

#include <Magnum/Math/Color.h>
template<class T>
Debug& Magnum::Math::operator<<(Debug& debug, const ColorHsv<T>& value)

Debug output operator.

Debug& Magnum::Math::operator<<(Debug& debug, const Color3<UnsignedByte>& value)
#include <Magnum/Math/Color.h>

Debug output operator.

If Debug::Flag::Color is enabled or Debug::color was set immediately before, prints the value as an ANSI 24bit color escape sequence using two successive Unicode block characters (to have it roughly square). To preserve at least some information when text is copied, the square consists of one of the five ░▒▓█ shades, however the color is set for both foreground and background so the actual block character is indistinguishable when seen on a terminal.

If Debug::Flag::Color is enabled and Debug::Flag::DisableColors is set, only the shaded character is used, without any ANSI color escape sequence.

If Debug::Flag::Color is not enabled, the value is printed as a hex color (e.g. #ff33aa). Other underlying types are handled by operator<<(Debug&, const Vector<size, T>&).

For example, the following snippet:

Debug{Debug::Flag::Color} << 0xdcdcdc_rgb << 0xa5c9ea_rgb << 0x3bd267_rgb
    << 0xc7cf2f_rgb << 0xcd3431_rgb << 0x2f83cc_rgb << 0x747474_rgb;

prints the following on terminals that support it:

██ ██ ██ ██ ██ ▓▓ ▒▒

Debug& Magnum::Math::operator<<(Debug& debug, const Color4<UnsignedByte>& value)
#include <Magnum/Math/Color.h>

Debug output operator.

If Debug::Flag::Color is enabled or Debug::color was set immediately before, prints the value as an ANSI 24bit color escape sequence using two successive Unicode block characters (to have it roughly square). To preserve at least some information when text is copied, the square consists of one of the five ░▒▓█ shades. The square shade is calculated as a product of Color4::value() and Color4::a(). If calculated color value is less than alpha, the colored square has the color set for both background and foreground, otherwise the background is left at the default.

If Debug::Flag::Color is enabled and Debug::Flag::DisableColors is set, only the shaded character is used, without any ANSI color escape sequence.

If Debug::Flag::Color is not enabled, the value is printed as a hex color (e.g. #ff33aaff). Other underlying types are handled by operator<<(Debug&, const Vector<size, T>&).

For example, the following snippet:

Debug{Debug::Flag::Color}
    << 0x3bd26700_rgba << 0x3bd26733_rgba << 0x3bd26766_rgba
    << 0x3bd26799_rgba << 0x3bd267cc_rgba << 0x3bd267ff_rgba;

prints the following on terminals that support it:

      ░░ ▒▒ ▓▓ ██

void Magnum::Math::yFlipBc1InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
#include <Magnum/Math/ColorBatch.h>

Y-flip BC1 texture blocks in-place.

Performs a Y flip of given 3D image by flipping block order and modifying internal block representation to encode the same information, just upside down. No decoding or re-encoding of the block data is performed, thus the operation is lossless. However note that this operation flips full blocks — if size of the actual image isn't whole blocks, the flipped image will be shifted compared to the original, possibly with garbage data appearing in the first few rows.

First dimension is expected to be image slices, second block rows, third 2D blocks, fourth the 64-bit 4x4 block data, i.e. the last dimension is expected to be contiguous with size of 8.

void Magnum::Math::yFlipBc2InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
#include <Magnum/Math/ColorBatch.h>

Y-flip BC2 texture blocks in-place.

Performs a Y flip of given 3D image by flipping block order and modifying internal block representation to encode the same information, just upside down. No decoding or re-encoding of the block data is performed, thus the operation is lossless. However note that this operation flips full blocks — if size of the actual image isn't whole blocks, the flipped image will be shifted compared to the original, possibly with garbage data appearing in the first few rows.

First dimension is expected to be image slices, second block rows, third 2D blocks, fourth the 128-bit 4x4 block data, i.e. the last dimension is expected to be contiguous with size of 16.

void Magnum::Math::yFlipBc3InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
#include <Magnum/Math/ColorBatch.h>

Y-flip BC3 texture blocks in-place.

Performs a Y flip of given 3D image by flipping block order and modifying internal block representation to encode the same information, just upside down. No decoding or re-encoding of the block data is performed, thus the operation is lossless. However note that this operation flips full blocks — if size of the actual image isn't whole blocks, the flipped image will be shifted compared to the original, possibly with garbage data appearing in the first few rows.

First dimension is expected to be image slices, second block rows, third 2D blocks, fourth the 128-bit 4x4 block data, i.e. the last dimension is expected to be contiguous with size of 16. As BC3 is internally a 64-bit BC4 block for alpha followed by a 64-bit BC1 block for RGB, the operation is the same as performing yFlipBc4InPlace() on the first half and yFlipBc1InPlace() on second half of each block.

void Magnum::Math::yFlipBc4InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
#include <Magnum/Math/ColorBatch.h>

Y-flip BC4 texture blocks in-place.

Performs a Y flip of given 3D image by flipping block order and modifying internal block representation to encode the same information, just upside down. No decoding or re-encoding of the block data is performed, thus the operation is lossless. However note that this operation flips full blocks — if size of the actual image isn't whole blocks, the flipped image will be shifted compared to the original, possibly with garbage data appearing in the first few rows.

First dimension is expected to be image slices, second block rows, third 2D blocks, fourth the 64-bit 4x4 block data, i.e. the last dimension is expected to be contiguous with size of 8.

void Magnum::Math::yFlipBc5InPlace(const Containers::StridedArrayView4D<char>& blocks) new in Git master
#include <Magnum/Math/ColorBatch.h>

Y-flip BC5 texture blocks in-place.

Performs a Y flip of given 3D image by flipping block order and modifying internal block representation to encode the same information, just upside down. No decoding or re-encoding of the block data is performed, thus the operation is lossless. However note that this operation flips full blocks — if size of the actual image isn't whole blocks, the flipped image will be shifted compared to the original, possibly with garbage data appearing in the first few rows.

First dimension is expected to be image slices, second block rows, third 2D blocks, fourth the 128-bit 4x4 block data, i.e. the last dimension is expected to be contiguous with size of 16. As BC5 is internally two 64-bit BC4 blocks, the operation is the same as performing yFlipBc4InPlace() on both halves of each block.

#include <Magnum/Math/Complex.h>
template<class T>
T Magnum::Math::dot(const Complex<T>& a, const Complex<T>& b)

Dot product of two complex numbers.

\[ c_0 \cdot c_1 = a_0 a_1 + b_0 b_1 \]

#include <Magnum/Math/Complex.h>
template<class T>
Rad<T> Magnum::Math::angle(const Complex<T>& normalizedA, const Complex<T>& normalizedB)

Angle between normalized complex numbers.

Expects that both complex numbers are normalized.

\[ \theta = \arccos \left( \frac{Re(c_0 \cdot c_1))}{|c_0| |c_1|} \right) = \arccos (a_0 a_1 + b_0 b_1) \]

To avoid numerical issues when two complex numbers are very close to each other, the dot product is clamped to the $ [-1, +1] $ range before being passed to $ \arccos $ .

#include <Magnum/Math/Complex.h>
template<class T>
Complex<T> Magnum::Math::operator*(const Vector2<T>& vector, const Complex<T>& complex)

Multiply a vector with a complex number.

Same as Complex::operator*(const Vector2<T>&) const.

#include <Magnum/Math/Complex.h>
template<class T>
Complex<T> Magnum::Math::lerp(const Complex<T>& normalizedA, const Complex<T>& normalizedB, T t)

Linear interpolation of two complex numbers.

Parameters
normalizedA First complex number
normalizedB Second complex number
t Interpolation phase (from range $ [0; 1] $ )

Expects that both complex numbers are normalized.

\[ c_{LERP} = \frac{(1 - t) c_A + t c_B}{|(1 - t) c_A + t c_B|} \]

#include <Magnum/Math/Complex.h>
template<class T>
Complex<T> Magnum::Math::slerp(const Complex<T>& normalizedA, const Complex<T>& normalizedB, T t)

Spherical linear interpolation of two complex numbers.

Parameters
normalizedA First complex number
normalizedB Second complex number
t Interpolation phase (from range $ [0; 1] $ )

Expects that both complex numbers are normalized. If the complex numbers are the same, returns the first argument.

\[ \begin{array}{rcl} \theta & = & \arccos \left( \frac{c_A \cdot c_B}{|c_A| |c_B|} \right) = \arccos(c_A \cdot c_B) \\[6pt] c_{SLERP} & = & \cfrac{\sin((1 - t) \theta) c_A + \sin(t \theta) c_B}{\sin(\theta)} \end{array} \]

#include <Magnum/Math/Complex.h>
template<class T>
Debug& Magnum::Math::operator<<(Debug& debug, const Complex<T>& value)

Debug output operator.

#include <Magnum/Math/CubicHermite.h>
template<class T>
Debug& Magnum::Math::operator<<(Debug& debug, const CubicHermite<T>& value)

Debug output operator.

#include <Magnum/Math/CubicHermite.h>
template<class T, class U>
T Magnum::Math::select(const CubicHermite<T>& a, const CubicHermite<T>& b, U t)

Constant interpolation of two cubic Hermite spline points.

Parameters
a First spline point
b Second spline point
t Interpolation phase (from range $ [0; 1] $ )

Given segment points $ \boldsymbol{p}_i $ , in-tangents $ \boldsymbol{m}_i $ and out-tangents $ \boldsymbol{n}_i $ , the interpolated value $ \boldsymbol{p} $ at phase $ t $ is:

\[ \boldsymbol{p}(t) = \begin{cases} \boldsymbol{p}_a, & t < 1 \\ \boldsymbol{p}_b, & t \ge 1 \end{cases} \]

Equivalent to calling select(const T&, const T&, U) on CubicHermite::point() extracted from both a and b.

#include <Magnum/Math/CubicHermite.h>
template<class T, class U>
T Magnum::Math::lerp(const CubicHermite<T>& a, const CubicHermite<T>& b, U t)

Linear interpolation of two cubic Hermite points.

Parameters
a First spline point
b Second spline point
t Interpolation phase (from range $ [0; 1] $ )

Given segment points $ \boldsymbol{p}_i $ , in-tangents $ \boldsymbol{m}_i $ and out-tangents $ \boldsymbol{n}_i $ , the interpolated value $ \boldsymbol{p} $ at phase $ t $ is:

\[ \boldsymbol{p}(t) = (1 - t) \boldsymbol{p}_a + t \boldsymbol{p}_b \]

Equivalent to calling lerp(const T&, const T&, U) on CubicHermite::point() extracted from both a and b.

#include <Magnum/Math/CubicHermite.h>
template<class T>
Complex<T> Magnum::Math::lerp(const CubicHermiteComplex<T>& a, const CubicHermiteComplex<T>& b, T t)

Linear interpolation of two cubic Hermite complex numbers.

Equivalent to calling lerp(const Complex<T>&, const Complex<T>&, T) on CubicHermite::point() extracted from a and b. Compared to lerp(const CubicHermite<T>&, const CubicHermite<T>&, U) this adds a normalization step after. Expects that CubicHermite::point() is a normalized complex number in both a and b.

#include <Magnum/Math/CubicHermite.h>
template<class T>
Quaternion<T> Magnum::Math::lerp(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t)

Linear interpolation of two cubic Hermite quaternions.

Equivalent to calling lerp(const Quaternion<T>&, const Quaternion<T>&, T) on CubicHermite::point() extracted from a and b. Compared to lerp(const CubicHermite<T>&, const CubicHermite<T>&, U) this adds a normalization step after. Expects that CubicHermite::point() is a normalized quaternion in both a and b.

#include <Magnum/Math/CubicHermite.h>
template<class T>
Quaternion<T> Magnum::Math::lerpShortestPath(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t)

Linear shortest-path interpolation of two cubic Hermite quaternions.

Equivalent to calling lerpShortestPath(const Quaternion<T>&, const Quaternion<T>&, T) on CubicHermite::point() extracted from a and b. Expects that CubicHermite::point() is a normalized quaternion in both a and b.

Note that rotations interpolated with this function may go along a completely different path compared to splerp(const CubicHermiteQuaternion<T>&, const CubicHermiteQuaternion<T>&, T). Use lerp(const CubicHermiteQuaternion<T>&, const CubicHermiteQuaternion<T>&, T) for behavior that is consistent with spline interpolation.

#include <Magnum/Math/CubicHermite.h>
template<class T>
Quaternion<T> Magnum::Math::slerp(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t)

Spherical linear interpolation of two cubic Hermite quaternions.

Equivalent to calling slerp(const Quaternion<T>&, const Quaternion<T>&, T) on CubicHermite::point() extracted from a and b. Expects that CubicHermite::point() is a normalized quaternion in both a and b.

#include <Magnum/Math/CubicHermite.h>
template<class T>
Quaternion<T> Magnum::Math::slerpShortestPath(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t)

Spherical linear shortest-path interpolation of two cubic Hermite quaternions.

Equivalent to calling slerpShortestPath(const Quaternion<T>&, const Quaternion<T>&, T) on CubicHermite::point() extracted from a and b. Expects that CubicHermite::point() is a normalized quaternion in both a and b.

Note that rotations interpolated with this function may go along a completely different path compared to splerp(const CubicHermiteQuaternion<T>&, const CubicHermiteQuaternion<T>&, T). Use slerp(const CubicHermiteQuaternion<T>&, const CubicHermiteQuaternion<T>&, T) for spherical linear interpolation with behavior that is consistent with spline interpolation.

#include <Magnum/Math/CubicHermite.h>
template<class T, class U>
T Magnum::Math::splerp(const CubicHermite<T>& a, const CubicHermite<T>& b, U t)

Spline interpolation of two cubic Hermite points.

Parameters
a First spline point
b Second spline point
t Interpolation phase

Given segment points $ \boldsymbol{p}_i $ , in-tangents $ \boldsymbol{m}_i $ and out-tangents $ \boldsymbol{n}_i $ , the interpolated value $ \boldsymbol{p} $ at phase $ t $ is:

\[ \boldsymbol{p}(t) = (2 t^3 - 3 t^2 + 1) \boldsymbol{p}_a + (t^3 - 2 t^2 + t) \boldsymbol{n}_a + (-2 t^3 + 3 t^2) \boldsymbol{p}_b + (t^3 - t^2)\boldsymbol{m}_b \]

#include <Magnum/Math/CubicHermite.h>
template<class T>
Complex<T> Magnum::Math::splerp(const CubicHermiteComplex<T>& a, const CubicHermiteComplex<T>& b, T t)

Spline interpolation of two cubic Hermite complex numbers.

Unlike splerp(const CubicHermite<T>&, const CubicHermite<T>&, U) this adds a normalization step after. Given segment points $ \boldsymbol{p}_i $ , in-tangents $ \boldsymbol{m}_i $ and out-tangents $ \boldsymbol{n}_i $ , the interpolated value $ \boldsymbol{p} $ at phase $ t $ is:

\[ \begin{array}{rcl} \boldsymbol{p'}(t) & = & (2 t^3 - 3 t^2 + 1) \boldsymbol{p}_a + (t^3 - 2 t^2 + t) \boldsymbol{n}_a + (-2 t^3 + 3 t^2) \boldsymbol{p}_b + (t^3 - t^2)\boldsymbol{m}_b \\ \boldsymbol{p}(t) & = & \cfrac{\boldsymbol{p'}(t)}{|\boldsymbol{p'}(t)|} \end{array} \]

Expects that CubicHermite::point() is a normalized complex number in both a and b.

#include <Magnum/Math/CubicHermite.h>
template<class T>
Quaternion<T> Magnum::Math::splerp(const CubicHermiteQuaternion<T>& a, const CubicHermiteQuaternion<T>& b, T t)

Spline interpolation of two cubic Hermite quaternions.

Unlike splerp(const CubicHermite<T>&, const CubicHermite<T>&, U) this adds a normalization step after. Given segment points $ \boldsymbol{p}_i $ , in-tangents $ \boldsymbol{m}_i $ and out-tangents $ \boldsymbol{n}_i $ , the interpolated value $ \boldsymbol{p} $ at phase $ t $ is:

\[ \begin{array}{rcl} \boldsymbol{p'}(t) & = & (2 t^3 - 3 t^2 + 1) \boldsymbol{p}_a + (t^3 - 2 t^2 + t) \boldsymbol{n}_a + (-2 t^3 + 3 t^2) \boldsymbol{p}_b + (t^3 - t^2)\boldsymbol{m}_b \\ \boldsymbol{p}(t) & = & \cfrac{\boldsymbol{p'}(t)}{|\boldsymbol{p'}(t)|} \end{array} \]

Expects that CubicHermite::point() is a normalized quaternion in both a and b.

#include <Magnum/Math/Dual.h>
template<class T>
Debug& Magnum::Math::operator<<(Debug& debug, const Dual<T>& value)

Debug output operator.

#include <Magnum/Math/Dual.h>
template<class T>
Dual<T> Magnum::Math::sqrt(const Dual<T>& dual)

Square root of dual number.

\[ \sqrt{\hat a} = \sqrt{a_0} + \epsilon \frac{a_\epsilon}{2 \sqrt{a_0}} \]

#include <Magnum/Math/Dual.h>
template<class T>
Containers::Pair<Dual<T>, Dual<T>> Magnum::Math::sincos(const Dual<Rad<T>>& angle)

Sine and cosine of dual angle.

\[ \begin{array}{rcl} sin(\hat a) & = & sin(a_0) + \epsilon a_\epsilon cos(a_0) \\ cos(\hat a) & = & cos(a_0) - \epsilon a_\epsilon sin(a_0) \end{array} \]

#include <Magnum/Math/DualComplex.h>
template<class T>
Debug& Magnum::Math::operator<<(Debug& debug, const DualComplex<T>& value)

Debug output operator.

#include <Magnum/Math/DualQuaternion.h>
template<class T>
DualQuaternion<T> Magnum::Math::sclerp(const DualQuaternion<T>& normalizedA, const DualQuaternion<T>& normalizedB, const T t)

Screw linear interpolation of two dual quaternions.

Parameters
normalizedA First dual quaternion
normalizedB Second dual quaternion
t Interpolation phase (from range $ [0; 1] $ )

Expects that both dual quaternions are normalized. If the real parts are the same or one is a negation of the other, returns the DualQuaternion::rotation() (real) part combined with interpolated DualQuaternion::translation():

\[ \begin{array}{rcl} d & = & q_{A_0} \cdot q_{B_0} \\[5pt] {\hat q}_{ScLERP} & = & 2 \left[(1 - t)(q_{A_\epsilon} q_{A_0}^*)_V + t (q_{B_\epsilon} q_{B_0}^*)_V \right] q_A, ~ {\color{m-primary} \text{if} ~ d \ge 1} \end{array} \]

otherwise, the interpolation is performed as:

\[ \begin{array}{rcl} l + \epsilon m & = & \hat q_A^* \hat q_B \\[5pt] \frac{\hat a} 2 & = & \arccos \left( l_S \right) - \epsilon m_S \frac 1 {|\boldsymbol{l}_V|} \\[5pt] \hat {\boldsymbol n} & = & \boldsymbol n_0 + \epsilon \boldsymbol n_\epsilon, ~~~~~~~~ \boldsymbol n_0 = \boldsymbol{l}_V \frac 1 {|\boldsymbol{l}_V|}, ~~~~~~~~ \boldsymbol n_\epsilon = \left(\boldsymbol{m}_V - {\boldsymbol n}_0 \frac {a_\epsilon} 2 l_S \right)\frac 1 {|\boldsymbol{l}_V|} \\[5pt] {\hat q}_{ScLERP} & = & \hat q_A (\hat q_A^* \hat q_B)^t = \hat q_A \left[ \hat {\boldsymbol n} \sin \left( t \frac {\hat a} 2 \right), \cos \left( t \frac {\hat a} 2 \right) \right] \end{array} \]

Note that this function does not check for shortest path interpolation, see sclerpShortestPath() for an alternative.

#include <Magnum/Math/DualQuaternion.h>
template<class T>
DualQuaternion<T> Magnum::Math::sclerpShortestPath(const DualQuaternion<T>& normalizedA, const DualQuaternion<T>& normalizedB, const T t)

Screw linear shortest-path interpolation of two dual quaternions.

Parameters
normalizedA First dual quaternion
normalizedB Second dual quaternion
t Interpolation phase (from range $ [0; 1] $ )

Unlike sclerp(const DualQuaternion<T>&, const DualQuaternion<T>&, T) this function interpolates on the shortest path. Expects that both dual quaternions are normalized. If the real parts are the same or one is a negation of the other, returns the DualQuaternion::rotation() (real) part combined with interpolated DualQuaternion::translation():

\[ \begin{array}{rcl} d & = & q_{A_0} \cdot q_{B_0} \\[5pt] {\hat q}_{ScLERP} & = & 2 \left((1 - t)(q_{A_\epsilon} q_{A_0}^*)_V + t (q_{B_\epsilon} q_{B_0}^*)_V \right) (q_{A_0} + \epsilon [\boldsymbol{0}, 0]), ~ {\color{m-primary} \text{if} ~ d \ge 1} \end{array} \]

otherwise, the interpolation is performed as:

\[ \begin{array}{rcl} l + \epsilon m & = & \begin{cases} \phantom{-}\hat q_A^* \hat q_B, & d \ge 0 \\ -\hat q_A^* \hat q_B, & d < 0 \\ \end{cases} \\[15pt] \frac{\hat a} 2 & = & \arccos \left( l_S \right) - \epsilon m_S \frac 1 {|\boldsymbol{l}_V|} \\[5pt] \hat {\boldsymbol n} & = & \boldsymbol n_0 + \epsilon \boldsymbol n_\epsilon, ~~~~~~~~ \boldsymbol n_0 = \boldsymbol{l}_V \frac 1 {|\boldsymbol{l}_V|}, ~~~~~~~~ \boldsymbol n_\epsilon = \left(\boldsymbol{m}_V - {\boldsymbol n}_0 \frac {a_\epsilon} 2 l_S \right)\frac 1 {|\boldsymbol{l}_V|} \\[5pt] {\hat q}_{ScLERP} & = & \hat q_A (\hat q_A^* \hat q_B)^t = \hat q_A \left[ \hat {\boldsymbol n} \sin \left( t \frac {\hat a} 2 \right), \cos \left( t \frac {\hat a} 2 \right) \right] \end{array} \]

#include <Magnum/Math/DualQuaternion.h>
template<class T>
Debug& Magnum::Math::operator<<(Debug& debug, const DualQuaternion<T>& value)

Debug output operator.

#include <Magnum/Math/Frustum.h>
template<class T>
Debug& Magnum::Math::operator<<(Debug& debug, const Frustum<T>& value)

Debug output operator.

#include <Magnum/Math/Functions.h>
template<class Integral>
Containers::Pair<Integral, Integral> Magnum::Math::div(Integral x, Integral y)

Integer division with remainder.

Example usage:

Containers::Pair<Int, Int> quotientRemainder = Math::div(57, 6); // {9, 3}

Equivalent to the following, but possibly done in a single CPU instruction:

Int quotient = 57/6;
Int remainder = 57%6;

UnsignedLong Magnum::Math::binomialCoefficient(UnsignedInt n, UnsignedInt k) new in Git master
#include <Magnum/Math/Functions.h>

Binomial coefficient.

Returns the number of combinations of $ n $ things taken $ k $ at a time, with $ n \ge k \ge 0 $ :

\[ \begin{pmatrix} n \\ k \end{pmatrix} = \frac{n! (n - k)!}{k!} = \frac{n (n - 1) (n - 2) ~ \cdots ~ (n - (k - 1))}{k (k - 1) ~ \cdots ~ 1} = \prod_{i=1}^k \frac{n + 1 - i}{i} \]

UnsignedInt Magnum::Math::popcount(UnsignedInt number) new in Git master
#include <Magnum/Math/Functions.h>

Count of bits set in a number.

Expands to __builtin_popcount / __builtin_popcountll on GCC and Clang, uses the Counting bits set, in parallel implementation from Sean Eron Anderson Bit Twiddling Hacks page on MSVC and elsewhere.

See also Containers::BitArrayView::count() for a variant optimized for running on large sequences of bits.

UnsignedInt Magnum::Math::popcount(UnsignedLong number) new in Git master
#include <Magnum/Math/Functions.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::reflect(const Vector<size, T>& vector, const Vector<size, T>& normal) new in 2020.06

Reflect a vector.

Reflects the vector off a surface given the surface outward normal. Expects that the normal vector is normalized. For a vector $ \boldsymbol{v} $ and a normal $ \boldsymbol{n} $ , the reflection vector $ \boldsymbol{r} $ is calculated as:

\[ \boldsymbol{r} = \boldsymbol{v} - 2 (\boldsymbol{n} \cdot \boldsymbol{v}) \boldsymbol{n} \]

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::refract(const Vector<size, T>& vector, const Vector<size, T>& normal, T eta) new in 2020.06

Refract a vector.

Refracts a vector through a medium given the surface outward normal and ratio of indices of refraction eta. Expects that both vector and normal is normalized. For a vector $ \boldsymbol{v} $ , normal $ \boldsymbol{n} $ and a ratio of indices of refraction $ \eta $ , the refraction vector $ \boldsymbol{r} $ is calculated as:

\[ \begin{array}{rcl} \eta & = & \cfrac{\text{IOR}_\text{source}}{\text{IOR}_\text{destination}} \\[10pt] k & = & 1 - \eta^2 (1 - (\boldsymbol{n} \cdot \boldsymbol{v})^2) \\ \boldsymbol{r} & = & \begin{cases} \boldsymbol{0}, & \text{if} ~ k < 0 \\ \eta \boldsymbol{v} - (\eta (\boldsymbol{n} \cdot \boldsymbol{v}) + \sqrt{k}) \boldsymbol{n}, & \text{if} ~ k \ge 0 \end{cases} \end{array} \]

Wikipedia has a List of refractive indices.

Debug& Magnum::Math::operator<<(Debug& debug, Half value)
#include <Magnum/Math/Half.h>

Debug output operator.

Prints the value with 4 significant digits.

#include <Magnum/Math/Quaternion.h>
template<class T>
T Magnum::Math::dot(const Quaternion<T>& a, const Quaternion<T>& b)

Dot product between two quaternions.

\[ p \cdot q = \boldsymbol p_V \cdot \boldsymbol q_V + p_S q_S \]

#include <Magnum/Math/Quaternion.h>
template<class T>
Rad<T> Magnum::Math::halfAngle(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB)

Half-angle between normalized quaternions.

Expects that both quaternions are normalized.

\[ \theta = \arccos \left( \frac{p \cdot q}{|p| |q|} \right) = \arccos(p \cdot q) \]

To avoid numerical issues when two complex numbers are very close to each other, the dot product is clamped to the $ [-1, +1] $ range before being passed to $ \arccos $ .

#include <Magnum/Math/Quaternion.h>
template<class T>
Rad<T> Magnum::Math::angle(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB)

Half-angle between normalized quaternions.

#include <Magnum/Math/Quaternion.h>
template<class T>
Quaternion<T> Magnum::Math::lerp(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB, T t)

Linear interpolation of two quaternions.

Parameters
normalizedA First quaternion
normalizedB Second quaternion
t Interpolation phase (from range $ [0; 1] $ )

Expects that both quaternions are normalized.

\[ q_{LERP} = \frac{(1 - t) q_A + t q_B}{|(1 - t) q_A + t q_B|} \]

Note that this function does not check for shortest path interpolation, see lerpShortestPath(const Quaternion<T>&, const Quaternion<T>&, T) for an alternative.

#include <Magnum/Math/Quaternion.h>
template<class T>
Quaternion<T> Magnum::Math::lerpShortestPath(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB, T t)

Linear shortest-path interpolation of two quaternions.

Parameters
normalizedA First quaternion
normalizedB Second quaternion
t Interpolation phase (from range $ [0; 1] $ )

Unlike lerp(const Quaternion<T>&, const Quaternion<T>&, T), this interpolates on the shortest path at some performance expense. Expects that both quaternions are normalized.

\[ \begin{array}{rcl} d & = & q_A \cdot q_B \\[5pt] q'_A & = & \begin{cases} \phantom{-}q_A, & d \ge 0 \\ -q_A, & d < 0 \end{cases} \\[15pt] q_{LERP} & = & \cfrac{(1 - t) q'_A + t q_B}{|(1 - t) q'_A + t q_B|} \end{array} \]

#include <Magnum/Math/Quaternion.h>
template<class T>
Quaternion<T> Magnum::Math::slerp(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB, T t)

Spherical linear interpolation of two quaternions.

Parameters
normalizedA First quaternion
normalizedB Second quaternion
t Interpolation phase (from range $ [0; 1] $ )

Expects that both quaternions are normalized. If the quaternions are nearly the same or one is a negation of the other, it falls back to a linear interpolation (shortest-path to avoid a degenerate case of returning a zero quaternion for $ t = 0.5 $ ), but without post-normalization as the interpolation result can still be considered sufficiently normalized:

\[ \begin{array}{rcl} d & = & q_A \cdot q_B \\[5pt] q_{SLERP} & = & (1 - t) \left\{ \begin{array}{lr} \phantom{-}q_A, & d \ge 0 \\ -q_A, & d < 0 \end{array} \right\} + t q_B, ~ {\color{m-primary} \text{if} ~ |d| \ge 1 - \frac{\epsilon}{2}} \end{array} \]

Otherwise, the interpolation is performed as:

\[ \begin{array}{rcl} \theta & = & \arccos \left( \frac{q_A \cdot q_B}{|q_A| |q_B|} \right) = \arccos(q_A \cdot q_B) = \arccos(d) \\[5pt] q_{SLERP} & = & \cfrac{\sin((1 - t) \theta) q_A + \sin(t \theta) q_B}{\sin(\theta)} \end{array} \]

Note that this function does not check for shortest path interpolation, see slerpShortestPath(const Quaternion<T>&, const Quaternion<T>&, T) for an alternative.

#include <Magnum/Math/Quaternion.h>
template<class T>
Quaternion<T> Magnum::Math::slerpShortestPath(const Quaternion<T>& normalizedA, const Quaternion<T>& normalizedB, T t)

Spherical linear shortest-path interpolation of two quaternions.

Parameters
normalizedA First quaternion
normalizedB Second quaternion
t Interpolation phase (from range $ [0; 1] $ )

Unlike slerp(const Quaternion<T>&, const Quaternion<T>&, T) this function interpolates on the shortest path. Expects that both quaternions are normalized. If the quaternions are nearly the same or one is a negation of the other, it falls back to a linear interpolation (shortest-path to avoid a degenerate case of returning a zero quaternion for $ t = 0.5 $ ) but without post-normalization as the interpolation result can still be considered sufficiently normalized:

\[ \begin{array}{rcl} d & = & q_A \cdot q_B \\[15pt] q'_A & = & \begin{cases} \phantom{-}q_A, & d \ge 0 \\ -q_A, & d < 0 \end{cases} \\[15pt] q_{SLERP} & = & (1 - t) q'_A + t q_B, ~ {\color{m-primary} \text{if} ~ |d| \ge 1 - \frac{\epsilon}{2}} \end{array} \]

Otherwise, the interpolation is performed as:

\[ \begin{array}{rcl} \theta & = & \arccos \left( \frac{|q'_A \cdot q_B|}{|q'_A| |q_B|} \right) = \arccos(|q'_A \cdot q_B|) = \arccos(|d|) \\[5pt] q_{SLERP} & = & \cfrac{\sin((1 - t) \theta) q'_A + \sin(t \theta) q_B}{\sin(\theta)} \end{array} \]

#include <Magnum/Math/Quaternion.h>
template<class T>
Debug& Magnum::Math::operator<<(Debug& debug, const Quaternion<T>& value)

Debug output operator.

#include <Magnum/Math/Range.h>
template<UnsignedInt dimensions, class T>
Range<dimensions, T> Magnum::Math::join(const Range<dimensions, T>& a, const Range<dimensions, T>& b)

Join two ranges.

Returns a range that contains both input ranges. If one of the ranges is empty, only the other is returned. Results are undefined if any range has a negative size.

#include <Magnum/Math/Range.h>
template<UnsignedInt dimensions, class T>
Range<dimensions, T> Magnum::Math::join(const Range<dimensions, T>& a, const Vector<dimensions, T>& b) new in Git master

Join a range and a point.

Returns a range that contains both the input range and the point. Compared to join(const Range<dimensions, T>&, const Range<dimensions, T>&) there's no special casing for an empty range. Results are undefined if the range has a negative size.

#include <Magnum/Math/Range.h>
template<UnsignedInt dimensions, class T>
Range<dimensions, T> Magnum::Math::intersect(const Range<dimensions, T>& a, const Range<dimensions, T>& b)

Intersect two ranges.

Returns a range that covers the intersection of both ranges. If the intersection is empty, a default-constructed range is returned. The range minimum is interpreted as inclusive, maximum as exclusive. Results are undefined if any range has a negative size.

#include <Magnum/Math/Range.h>
template<UnsignedInt dimensions, class T>
bool Magnum::Math::intersects(const Range<dimensions, T>& a, const Range<dimensions, T>& b)

Whether two ranges intersect.

Returns true if the following holds for all dimensions $ i $ , false otherwise.

\[ \bigwedge_i (\operatorname{max}(A)_i > \operatorname{min}(B)_i) \land (\operatorname{min}(A)_i < \operatorname{max}(B)_i) \]

The range minimum is interpreted as inclusive, maximum as exclusive. Results are undefined if any range has a negative size.

#include <Magnum/Math/Range.h>
template<UnsignedInt dimensions, class T>
Debug& Magnum::Math::operator<<(Debug& debug, const Range<dimensions, T>& value)

Debug output operator.

#include <Magnum/Math/RectangularMatrix.h>
template<std::size_t cols, std::size_t rows, class T>
Debug& Magnum::Math::operator<<(Debug& debug, const Magnum::Math::RectangularMatrix<cols, rows, T>& value)

Debug output operator.

#include <Magnum/Math/Swizzle.h>
template<char ... components, class T>
Implementation::TypeForSize<sizeof...(components), T>::Type Magnum::Math::gather(const T& vector) constexpr new in 2019.10

Gather Vector components.

Creates a new vector from given components. Example:

Vector4i original(-1, 2, 3, 4);

auto vec = Math::gather<'w', '1', '0', 'x', 'y', 'z'>(original);
        // vec == { 4, 1, 0, -1, 2, 3 }

You can use letters 'x', 'y', 'z', 'w' and 'r', 'g', 'b', 'a' for addressing components or letters '0' and '1' for zero and one. Alternatively you can also address components using their numeric index — which is especially useful when your input has more than four components. Count of elements is unlimited, but must be at least one. If the resulting vector is two, three or four-component, corresponding Vector2, Vector3, Vector4, Color3 or Color4 specialization is returned.

#include <Magnum/Math/Swizzle.h>
template<char ... components, class T>
T Magnum::Math::scatter(const T& vector, const Vector<sizeof...(components), typename T::Type>& values) constexpr new in 2019.10

Scatter Vector components.

Parameters
vector Vector to update
values Values to update it with
Returns Updated vector

Returns a copy of vector with particular components updated from values. Inverse to gather(), supporting the same component addressing except for '0' and '1'. Example:

Vector4 vec{1.5f, 3.0f, 0.1f, 1.1f};
Vector2 coords{5.0f, -2.0f};
vec = Math::scatter<'z', 'w'>(vec, coords); // { 1.5, 3.0, 5.0, -2.0 }

/* Combine the two for more advanced swizzles */
Vector4 vec2;
vec2 = Math::scatter<'w', 'x', 'y'>(vec2, Math::gather<'x', 'w', 'y'>(vec));

Utility::Debug& Magnum::Math::operator<<(Utility::Debug& debug, const Unit<Nanoseconds, Long>& value) new in Git master
#include <Magnum/Math/Time.h>

Debug output operator.

Utility::Debug& Magnum::Math::operator<<(Utility::Debug& debug, const Unit<Seconds, Float>& value) new in Git master
#include <Magnum/Math/Time.h>

Debug output operator.

#include <Magnum/Math/TypeTraits.h>
template<class T>
std::enable_if<IsScalar<T>::value, bool>::type Magnum::Math::equal(T a, T b) new in 2019.10

Equality comparison of scalar types.

Calls TypeTraits<T>::equals() — using fuzzy compare for floating-point types and doing equality comparison on integral types. Scalar complement to equal(const Vector<size, T>& a, const Vector<size, T>&).

#include <Magnum/Math/TypeTraits.h>
template<class T>
std::enable_if<IsScalar<T>::value, bool>::type Magnum::Math::notEqual(T a, T b) new in 2019.10

Non-equality comparison of scalar types.

Calls TypeTraits<T>::equals() — using fuzzy compare for floating-point types and doing equality comparison on integral types. Scalar complement to notEqual(const Vector<size, T>& a, const Vector<size, T>&).

#include <Magnum/Math/Vector.h>
template<std::size_t size, class T>
T Magnum::Math::dot(const Vector<size, T>& a, const Vector<size, T>& b)

Dot product of two vectors.

Returns 0 when two vectors are perpendicular, > 0 when two vectors are in the same general direction, 1 when two normalized vectors are parallel, < 0 when two vectors are in opposite general direction and -1 when two normalized vectors are antiparallel.

\[ \boldsymbol a \cdot \boldsymbol b = \sum_{i=0}^{n-1} \boldsymbol a_i \boldsymbol b_i \]

#include <Magnum/Math/Vector.h>
template<std::size_t size, class FloatingPoint>
Rad<FloatingPoint> Magnum::Math::angle(const Vector<size, FloatingPoint>& normalizedA, const Vector<size, FloatingPoint>& normalizedB)

Angle between normalized vectors.

Expects that both vectors are normalized. Enabled only for floating-point types.

\[ \theta = \arccos \left( \frac{\boldsymbol a \cdot \boldsymbol b}{|\boldsymbol a| |\boldsymbol b|} \right) = \arccos (\boldsymbol a \cdot \boldsymbol b) \]

To avoid numerical issues when two vectors are very close to each other, the dot product is clamped to the $ [-1, +1] $ range before being passed to $ \arccos $ .

#include <Magnum/Math/Vector.h>
template<std::size_t size, class T>
BitVector<size> Magnum::Math::equal(const Vector<size, T>& a, const Vector<size, T>& b) new in 2019.10

Component-wise equality comparison.

Unlike Vector::operator==() returns a BitVector instead of a single value. Vector complement to equal(T, T).

#include <Magnum/Math/Vector.h>
template<std::size_t size, class T>
BitVector<size> Magnum::Math::notEqual(const Vector<size, T>& a, const Vector<size, T>& b) new in 2019.10

Component-wise non-equality comparison.

Unlike Vector::operator!=() returns a BitVector instead of a single value. Vector complement to notEqual(T, T).

#include <Magnum/Math/Vector.h>
template<std::size_t size, class T>
Debug& Magnum::Math::operator<<(Debug& debug, const Vector<size, T>& value)

Debug output operator.

#include <Magnum/Math/Vector2.h>
template<class T>
T Magnum::Math::cross(const Vector2<T>& a, const Vector2<T>& b)

2D cross product

2D version of a cross product, also called a perp-dot product, equivalent to calling cross(const Vector3<T>&, const Vector3<T>&) with Z coordinate set to 0 and extracting only Z coordinate from the result (X and Y coordinates are always zero). Returns 0 either when one of the vectors is zero or they are parallel or antiparallel and 1 when two normalized vectors are perpendicular.

\[ \boldsymbol a \times \boldsymbol b = \boldsymbol a_\bot \cdot \boldsymbol b = a_xb_y - a_yb_x \]

If $ \boldsymbol{a} $ , $ \boldsymbol{b} $ and $ \boldsymbol{c} $ are corners of a triangle, $ \frac{1}{2}|(\boldsymbol{c} - \boldsymbol{b}) \times (\boldsymbol{a} - \boldsymbol{b})| $ is its area. Value of a 2D cross product is also related to a distance of a point and a line, see Distance::linePoint(const Vector2<T>&, const Vector2<T>&, const Vector2<T>&) for more information.

#include <Magnum/Math/Vector3.h>
template<class T>
Vector3<T> Magnum::Math::cross(const Vector3<T>& a, const Vector3<T>& b)

Cross product

Result has length of 0 either when one of them is zero or they are parallel or antiparallel and length of 1 when two normalized vectors are perpendicular.

\[ \boldsymbol a \times \boldsymbol b = \begin{pmatrix}a_yb_z - a_zb_y \\ a_zb_x - a_xb_z \\ a_xb_y - a_yb_x \end{pmatrix} \]

If $ \boldsymbol{a} $ , $ \boldsymbol{b} $ and $ \boldsymbol{c} $ are corners of a triangle in a counterclockwise order, $ (\boldsymbol{c} - \boldsymbol{b}) \times (\boldsymbol{a} - \boldsymbol{b}) $ gives the direction of its normal, and $ \frac{1}{2}|(\boldsymbol{c} - \boldsymbol{b}) \times (\boldsymbol{a} - \boldsymbol{b})| $ is its area. Length of a cross product is also related to a distance of a point and a line, see Distance::linePoint(const Vector3<T>&, const Vector3<T>&, const Vector3<T>&) for more information.

#include <Magnum/Math/Vector4.h>
template<class T>
Vector4<T> Magnum::Math::planeEquation(const Vector3<T>& p0, const Vector3<T>& p1, const Vector3<T>& p2)

Create a plane equation from three points.

Assuming the three points form a triangle in a counter-clockwise winding, creates a plane equation in the following form:

\[ ax + by + cz + d = 0 \]

The first three coefficients describe the scaled normal $ \boldsymbol{n} = (a, b, c)^T $ and are calculated using a cross product. The coefficient $ d $ is calculated using a dot product with the normal $ \boldsymbol{n} $ using the first point in order to satisfy the equation when assigning $ \boldsymbol{p_i} $ to $ x $ , $ y $ , $ z $ .

\[ \begin{array}{rcl} \boldsymbol{n} & = & (\boldsymbol{p_1} - \boldsymbol{p_0}) \times (\boldsymbol{p_2} - \boldsymbol{p_0}) \\ d & = & - \boldsymbol{n} \cdot \boldsymbol{p_0} \end{array} \]

#include <Magnum/Math/Vector4.h>
template<class T>
Vector4<T> Magnum::Math::planeEquation(const Vector3<T>& normal, const Vector3<T>& point)

Create a plane equation from a normal and a point.

Creates a plane equation in the following form:

\[ ax + by + cz + d = 0 \]

The first three coefficients describe the scaled normal $ \boldsymbol{n} = (a, b, c)^T $ , the coefficient $ d $ is calculated using a dot product with the normal $ \boldsymbol{n} $ using the point $ \boldsymbol{p} $ in order to satisfy the equation when assigning $ \boldsymbol{p} $ to $ x $ , $ y $ , $ z $ .

\[ d = - \boldsymbol{n} \cdot \boldsymbol{p} \]

#include <Magnum/Math/Functions.h>
template<class T>
T Magnum::Math::sin(Rad<T> angle)

Sine.

#include <Magnum/Math/Functions.h>
template<class T>
T Magnum::Math::cos(Rad<T> angle)

Cosine.

#include <Magnum/Math/Functions.h>
template<class T>
Containers::Pair<T, T> Magnum::Math::sincos(Rad<T> angle)

Sine and cosine.

On GCC, this uses the __builtin_sincos intrinsic (or its f / l suffixed variants), which may be faster than calculating sine and cosine separately. On other compilers this might result in the optimizer picking up the combined instruction as well.

#include <Magnum/Math/Functions.h>
template<class T>
T Magnum::Math::tan(Rad<T> angle)

Tangent.

#include <Magnum/Math/Functions.h>
template<class T>
Rad<T> Magnum::Math::asin(T value)

Arc sine.

#include <Magnum/Math/Functions.h>
template<class T>
Rad<T> Magnum::Math::acos(T value)

Arc cosine.

#include <Magnum/Math/Functions.h>
template<class T>
Rad<T> Magnum::Math::atan(T value)

Arc tangent.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, bool>::type Magnum::Math::isInf(T value) new in 2019.10

If given number is a positive or negative infinity.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
BitVector<size> Magnum::Math::isInf(const Vector<size, T>& value) new in 2019.10

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, bool>::type Magnum::Math::isNan(T value) new in 2019.10

If given number is a NaN.

Equivalent to value != value.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
BitVector<size> Magnum::Math::isNan(const Vector<size, T>& value) new in 2019.10

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::min(T value, T min) constexpr

Minimum.

NaNs passed in the value parameter are propagated.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::min(const Vector<size, T>& value, const Vector<size, T>& min)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::min(const Vector<size, T>& value, T min)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::max(T a, T b) constexpr

Maximum.

NaNs passed in the value parameter are propagated.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::max(const Vector<size, T>& value, const Vector<size, T>& max)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::max(const Vector<size, T>& value, T max)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Containers::Pair<Vector<size, T>, Vector<size, T>> Magnum::Math::minmax(const Vector<size, T>& a, const Vector<size, T>& b)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::clamp(T value, T min, T max) constexpr

Clamp value.

Values smaller than min are set to min, values larger than max are set to max. Equivalent to:

Math::min(Math::max(value, min), max)

NaNs passed in value parameter are propagated.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::clamp(const Vector<size, T>& value, const Vector<size, T>& min, const Vector<size, T>& max)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::clamp(const Vector<size, T>& value, T min, T max)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, UnderlyingTypeOf<T>>::type Magnum::Math::sign(T scalar)

Sign.

Returns 1 if x > 0, 0 if x = 0 and -1 if x < 0.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, UnderlyingTypeOf<T>> Magnum::Math::sign(const Vector<size, T>& a)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::abs(T a)

Absolute value.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::abs(const Vector<size, T>& a)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::floor(T a)

Nearest not larger integer.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::floor(const Vector<size, T>& a)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::round(T a)

Round value to nearest integer.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::round(const Vector<size, T>& a)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::ceil(T a)

Nearest not smaller integer.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::ceil(const Vector<size, T>& a)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::fmod(T a, T b) new in Git master

Floating point division remainder.

Parameters
a Numerator
b Denumerator

Calculates the remainder $ r $ of a floating point division:

\[ r = a - b ~ \operatorname{trunc}(\frac{a}{b}) \]

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::fmod(const Vector<size, T>& a, const Vector<size, T>& b) new in Git master

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::fmod(const Vector<size, T>& a, T b) new in Git master

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T, class U>
T Magnum::Math::lerp(const T& a, const T& b, U t)

Linear interpolation of two values.

Parameters
a First value
b Second value
t Interpolation phase (from range $ [0; 1] $ )

The interpolation for vectors is done as in following, similarly for scalars:

\[ \boldsymbol{v_{LERP}} = (1 - t) \boldsymbol{v_A} + t \boldsymbol{v_B} \]

See select() for constant interpolation using the same API and splerp() for spline interpolation.

#include <Magnum/Math/Functions.h>
template<class T>
T Magnum::Math::lerp(const T& a, const T& b, bool t)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::lerp(const Vector<size, T>& a, const Vector<size, T>& b, const BitVector<size>& t)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Similar to the above, but instead of multiplication and addition it just does component-wise selection from either a or b based on values in t.

#include <Magnum/Math/Functions.h>
template<std::size_t size>
BitVector<size> Magnum::Math::lerp(const BitVector<size>& a, const BitVector<size>& b, const BitVector<size>& t)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
UnderlyingTypeOf<typename std::enable_if<IsScalar<T>::value, T>::type> Magnum::Math::lerpInverted(T a, T b, T lerp)

Inverse linear interpolation of two values.

Parameters
a First value
b Second value
lerp Interpolated value

Returns interpolation phase t:

\[ t = \frac{\boldsymbol{v_{LERP}} - \boldsymbol{v_A}}{\boldsymbol{v_B} - \boldsymbol{v_A}} \]

Useful in combination with lerp() for mapping values from one range to another — for example, the following snippet maps a from a range $ [ -1; +1 ] $ to a range $ [ 5\degree; 15\degree ] $ ; the second expression combines that with clamp() to ensure the value is in bounds:

Deg b = Math::lerp(5.0_degf, 15.0_degf,
    Math::lerpInverted(-1.0f, 1.0f, a));
Deg bClamped = Math::lerp(5.0_degf, 15.0_degf, Math::clamp(
    Math::lerpInverted(-1.0f, 1.0f, a), 0.0f, 1.0f));

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, UnderlyingTypeOf<T>> Magnum::Math::lerpInverted(const Vector<size, T>& a, const Vector<size, T>& b, const Vector<size, T>& lerp)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T, class U>
T Magnum::Math::select(const T& a, const T& b, U t) constexpr

Constant interpolation of two values.

Parameters
a First value
b Second value
t Interpolation phase

A constant interpolation counterpart to lerp():

\[ \boldsymbol{v}_i = \begin{cases} \boldsymbol{v_A}_i, & t_i < 1 \\ \boldsymbol{v_B}_i, & t_i \ge 1 \end{cases} \]

Equivalent to calling Math::lerp(a, b, t >= U(1)).

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::fma(T a, T b, T c)

Fused multiply-add.

Computes and returns $ ab + c $ . On some architectures might be faster than doing the computation manually. Works only on types that satisfy IsUnitless.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::fma(const Vector<size, T>& a, const Vector<size, T>& b, const Vector<size, T>& c)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

UnsignedInt Magnum::Math::log(UnsignedInt base, UnsignedInt number)
#include <Magnum/Math/Functions.h>

Integral logarithm.

Returns integral logarithm of given number with given base.

UnsignedInt Magnum::Math::log2(UnsignedInt number)
#include <Magnum/Math/Functions.h>

Base-2 integral logarithm.

Returns integral logarithm of given number with base 2.

#include <Magnum/Math/Functions.h>
template<class T>
T Magnum::Math::log(T number)

Natural logarithm.

Returns natural (base $ e $ ) logarithm of given number.

#include <Magnum/Math/Functions.h>
template<class T>
T Magnum::Math::exp(T exponent)

Natural exponential.

Returns $ e^x $ .

#include <Magnum/Math/Functions.h>
template<UnsignedInt exponent, class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::pow(T base) constexpr

Integral power.

Returns integral power of base to the exponent. Works only on types that satisfy IsUnitless.

#include <Magnum/Math/Functions.h>
template<UnsignedInt exponent, std::size_t size, class T>
Vector<size, T> Magnum::Math::pow(const Vector<size, T>& base)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::pow(T base, T exponent)

Power.

Returns power of base to the exponent. Works only on types that satisfy IsUnitless.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::pow(const Vector<size, T>& base, T exponent)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::sqrt(T a)

Square root.

Works only on types that satisfy IsUnitless.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::sqrt(const Vector<size, T>& a)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Functions.h>
template<class T>
std::enable_if<IsScalar<T>::value, T>::type Magnum::Math::sqrtInverted(T a)

Inverse square root.

Works only on types that satisfy IsUnitless.

#include <Magnum/Math/Functions.h>
template<std::size_t size, class T>
Vector<size, T> Magnum::Math::sqrtInverted(const Vector<size, T>& a)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
auto Magnum::Math::isInf(const Containers::StridedArrayView1D<const T>& range)

If any number in the range is a positive or negative infinity.

For scalar types returns true as soon as it finds an infinite value, false otherwise. For vector types, returns BitVector with bits set to 1 if any value has that component infinite. If the range is empty, returns false or a BitVector with no bits set.

#include <Magnum/Math/FunctionsBatch.h>
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
auto Magnum::Math::isInf(Iterable&& range) new in 2020.06

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Converts range to Containers::StridedArrayView1D and calls the above overload. Works with any type that's convertible to Containers::StridedArrayView.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
auto Magnum::Math::isInf(std::initializer_list<T> list)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T, std::size_t size>
auto Magnum::Math::isInf(const T(&array)[size])

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
auto Magnum::Math::isNan(const Containers::StridedArrayView1D<const T>& range)

If any number in the range is a NaN.

For scalar types returns true as soon as it finds a NaN value, false otherwise. For vector types, returns BitVector with bits set to 1 if any value has that component NaN. If the range is empty, returns false or a BitVector with no bits set.

#include <Magnum/Math/FunctionsBatch.h>
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
auto Magnum::Math::isNan(Iterable&& range) new in 2020.06

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Converts range to Containers::StridedArrayView1D and calls the above overload. Works with any type that's convertible to Containers::StridedArrayView.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
auto Magnum::Math::isNan(std::initializer_list<T> list)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T, std::size_t size>
auto Magnum::Math::isNan(const T(&array)[size])

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
T Magnum::Math::min(const Containers::StridedArrayView1D<const T>& range)

Minimum of a range.

If the range is empty, returns default-constructed value. NaNs are ignored, unless the range is all NaNs.

#include <Magnum/Math/FunctionsBatch.h>
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
T Magnum::Math::min(Iterable&& range) new in 2020.06

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Converts range to Containers::StridedArrayView1D and calls the above overload. Works with any type that's convertible to Containers::StridedArrayView.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
T Magnum::Math::min(std::initializer_list<T> list)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T, std::size_t size>
T Magnum::Math::min(const T(&array)[size])

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
T Magnum::Math::max(const Containers::StridedArrayView1D<const T>& range)

Maximum of a range.

If the range is empty, returns default-constructed value. NaNs are ignored, unless the range is all NaNs.

#include <Magnum/Math/FunctionsBatch.h>
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
T Magnum::Math::max(Iterable&& range) new in 2020.06

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Converts range to Containers::StridedArrayView1D and calls the above overload. Works with any type that's convertible to Containers::StridedArrayView.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
T Magnum::Math::max(std::initializer_list<T> list)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T, std::size_t size>
T Magnum::Math::max(const T(&array)[size])

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
Containers::Pair<T, T> Magnum::Math::minmax(const Containers::StridedArrayView1D<const T>& range)

Minimum and maximum of a range.

If the range is empty, returns default-constructed values. NaNs are ignored, unless the range is all NaNs.

#include <Magnum/Math/FunctionsBatch.h>
template<class Iterable, class T = decltype(Implementation::stridedArrayViewTypeFor(std::declval<Iterable && >()))>
Containers::Pair<T, T> Magnum::Math::minmax(Iterable&& range) new in 2020.06

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Converts range to Containers::StridedArrayView1D and calls the above overload. Works with any type that's convertible to Containers::StridedArrayView.

#include <Magnum/Math/FunctionsBatch.h>
template<class T>
Containers::Pair<T, T> Magnum::Math::minmax(std::initializer_list<T> list)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/FunctionsBatch.h>
template<class T, std::size_t size>
Containers::Pair<T, T> Magnum::Math::minmax(const T(&array)[size])

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Packing.h>
template<class FloatingPoint, class Integral>
FloatingPoint Magnum::Math::unpack(const Integral& value)

Unpack integral value into a floating-point representation.

Converts integral value from full range of given unsigned integral type to value in range $ [0, 1] $ or from signed integral to range $ [-1, 1] $ .

#include <Magnum/Math/Packing.h>
template<class FloatingPoint, class Integral, UnsignedInt bits>
FloatingPoint Magnum::Math::unpack(const Integral& value)

Unpack integer bits into a floating-point representation.

Alternative to the above with ability to specify how many bits of the integral representation to use. Example usage:

Float a = Math::unpack<Float, UnsignedShort>(8191);     // 0.124987f
Float b = Math::unpack<Float, UnsignedShort, 14>(8191); // 0.499969f
Float c = Math::unpack<Float, 14>(8191u);               // 0.499969f
Float d = Math::unpack<Float, 14>(8191);                // 1.0f

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Magnum/Math/Packing.h>
template<class Integral, class FloatingPoint>
Integral Magnum::Math::pack(const FloatingPoint& value)

Pack floating-point value into an integer representation.

Converts floating-point value in range $ [0, 1] $ to full range of given unsigned integral type or range $ [-1, 1] $ to full range of given signed integral type.

#include <Magnum/Math/Packing.h>
template<class Integral, UnsignedInt bits, class FloatingPoint>
Integral Magnum::Math::pack(FloatingPoint value)

Pack floating-point value into integer bits.

Alternative to the above with ability to specify how many bits of the integral representation to use. Example usage:

auto a = Math::pack<UnsignedShort>(0.5f);     // 32767
auto b = Math::pack<UnsignedShort, 14>(0.5f); // 8191

UnsignedShort Magnum::Math::packHalf(Float value)
#include <Magnum/Math/Packing.h>

Pack 32-bit float value into 16-bit half-float representation.

See Wikipedia for more information about half floats. NaNs are converted to NaNs and infinities to infinities, though their exact bit pattern is not preserved. Note that rounding mode is unspecified in order to save some cycles.

Implementation based on CC0 / public domain code by Fabian Giesen, https://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/ .

#include <Magnum/Math/Packing.h>
template<std::size_t size>
Vector<size, UnsignedShort> Magnum::Math::packHalf(const Vector<size, Float>& value)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Float Magnum::Math::unpackHalf(UnsignedShort value)
#include <Magnum/Math/Packing.h>

Unpack 16-bit half-float value into 32-bit float representation.

See Wikipedia for more information about half floats. NaNs are converted to NaNs and infinities to infinities, though their exact bit pattern is not preserved.

Implementation based on CC0 / public domain code by Fabian Giesen, https://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/ .

#include <Magnum/Math/Packing.h>
template<std::size_t size>
Vector<size, Float> Magnum::Math::unpackHalf(const Vector<size, UnsignedShort>& value)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::unpackInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

Unpack unsigned integral values into a floating-point representation.

Parameters
src in Source integral values
dst out Destination floating-point values

Converts integral values from full range of given unsigned integral type to floating-point values in range $ [0, 1] $ . Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::unpackInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::unpackInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

Unpack signed integral values into a floating-point representation.

Parameters
src in Source integral values
dst out Destination floating-point values

Converts integral values from full range of given signed integral type to floating-point values in range $ [-1, 1] $ . Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::unpackInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

Pack floating-point values into an integer representation.

Parameters
src in Source floating-point values
dst out Destination integral values

Converts floating-point value in range $ [0, 1] $ to full range of given unsigned integral type or range $ [-1, 1] $ to full range of given signed integral type. Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Byte>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::packInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Short>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::packHalfInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

Pack 32-bit float values into 16-bit half-float representation.

Parameters
src in Source 32-bit float values
dst out Destination 16-bit half-float values

See Wikipedia for more information about half floats. Unlike packHalf() this function is a faster table-based implementation at the expense of using more memory, thus more suitable for batch conversions of large data amounts. Expects that src and dst have the same size and that the second dimension in both is contiguous.

Algorithm used: Jeroen van der Zijp – Fast Half Float Conversions, 2008, ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf

void Magnum::Math::unpackHalfInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

Unpack a range of 16-bit half-float values into 32-bit float representation.

Parameters
src in Source floating-point values
dst out Destination integral values

See Wikipedia for more information about half floats. Unlike unpackHalf() this function is a faster table-based implementation at the expense of using more memory, thus more suitable for batch conversions of large data amounts. Expects that src and dst have the same size and that the second dimension in both is contiguous.

Algorithm used: Jeroen van der Zijp – Fast Half Float Conversions, 2008, ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

Cast integer values into a 32-bit floating-point representation.

Parameters
src in Source integral values
dst out Destination float values

Unlike packInto(), this function performs only an equivalent of Float(a) over the range, so e.g. 135 becomes 135.0f. Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Float>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

Cast integer values into a 64-bit floating-point representation.

Parameters
src in Source integral values
dst out Destination float values

Unlike packInto(), this function performs only an equivalent of Double(a) over the range, so e.g. 135 becomes 135.0. Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

Cast 32-bit floating-point values into an integer representation.

Parameters
src in Source float values
dst out Destination integral values

Unlike packInto(), this function performs only an equivalent of T(a) over the range, so e.g. 135.0f becomes 135. Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Byte>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Short>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Int>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

Cast 64-bit floating-point values into an integer representation.

Parameters
src in Source double values
dst out Destination integral values

Unlike packInto(), this function performs only an equivalent of T(a) over the range, so e.g. 135.0 becomes 135. Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Byte>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Short>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Int>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

Cast integer values into a differently sized type.

Parameters
src in Source values
dst out Destination values

Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Short>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Int>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Int>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Long>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Long>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Long>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Int>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Short>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Byte>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Short>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Byte>& dst) new in 2020.06
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Byte>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

Cast 32-bit floating-point values into a 64-bit floating-point representation.

Parameters
src in Source float values
dst out Destination double values

This function performs an equivalent of Double(a) over the range, so e.g. 135.0f becomes 135.0. Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Float>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

Cast 64-bit floating-point values into a 32-bit floating-point representation.

Parameters
src in Source double values
dst out Destination float values

This function performs an equivalent of Float(a) over the range, so e.g. 135.0 becomes 135.0f. Second dimension is meant to contain vector/matrix components, or have a size of 1 for scalars. Expects that src and dst have the same size and that the second dimension in both is contiguous.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedByte>& src, const Containers::StridedArrayView2D<UnsignedByte>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

Copy values.

Parameters
src in Source values
dst out Destination values

Provided for convenience when writing generic code, delegates to Utility::copy(). Expects that src and dst have the same size, for consistency with other castInto() expects also that the second dimension in both is contiguous even though it's not required by Utility::copy().

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Byte>& src, const Containers::StridedArrayView2D<Byte>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedShort>& src, const Containers::StridedArrayView2D<UnsignedShort>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Short>& src, const Containers::StridedArrayView2D<Short>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedInt>& src, const Containers::StridedArrayView2D<UnsignedInt>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Int>& src, const Containers::StridedArrayView2D<Int>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const UnsignedLong>& src, const Containers::StridedArrayView2D<UnsignedLong>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Long>& src, const Containers::StridedArrayView2D<Long>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Float>& src, const Containers::StridedArrayView2D<Float>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Magnum::Math::castInto(const Containers::StridedArrayView2D<const Double>& src, const Containers::StridedArrayView2D<Double>& dst) new in Git master
#include <Magnum/Math/PackingBatch.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Variable documentation

Magnum::NoInitT Magnum::Math::NoInit constexpr
#include <Magnum/Math/Tags.h>

No initialization tag.

ZeroInitT Magnum::Math::ZeroInit constexpr
#include <Magnum/Math/Tags.h>

Zero initialization tag.

Use for construction with all elements set to zero.

IdentityInitT Magnum::Math::IdentityInit constexpr
#include <Magnum/Math/Tags.h>

Identity initialization tag.

Use for construction with transformation set to identity.