Mathematical constants and functions. More...

#include <CesiumUtility/Math.h>

Static Public Member Functions
template<glm::length_t L, typename T, glm::qualifier Q>
static constexpr glm::vec< L, T, Q >	relativeEpsilonToAbsolute (const glm::vec< L, T, Q > &a, const glm::vec< L, T, Q > &b, double relativeEpsilon) noexcept
	Converts a relative to an absolute epsilon, for the epsilon-equality check between two values.

static constexpr double	relativeEpsilonToAbsolute (double a, double b, double relativeEpsilon) noexcept
	Converts a relative to an absolute epsilon, for the epsilon-equality check between two values.

template<glm::length_t L, typename T, glm::qualifier Q>
static bool constexpr	equalsEpsilon (const glm::vec< L, T, Q > &left, const glm::vec< L, T, Q > &right, double relativeEpsilon) noexcept
	Checks whether two values are equal up to a given relative epsilon.

static constexpr bool	equalsEpsilon (double left, double right, double relativeEpsilon) noexcept
	Checks whether two values are equal up to a given relative epsilon.

static constexpr bool	equalsEpsilon (double left, double right, double relativeEpsilon, double absoluteEpsilon) noexcept
	Determines if two values are equal using an absolute or relative tolerance test.

template<glm::length_t L, typename T, glm::qualifier Q>
static constexpr bool	equalsEpsilon (const glm::vec< L, T, Q > &left, const glm::vec< L, T, Q > &right, double relativeEpsilon, double absoluteEpsilon) noexcept
	Determines if two values are equal using an absolute or relative tolerance test.

template<typename T, glm::qualifier Q>
static constexpr bool	equalsEpsilon (const glm::mat< 4, 4, T, Q > &left, const glm::mat< 4, 4, T, Q > &right, double relativeEpsilon, double absoluteEpsilon) noexcept
	Determines if two values are equal using an absolute or relative tolerance test.

static constexpr double	sign (double value) noexcept
	Returns the sign of the value.

static constexpr double	signNotZero (double value) noexcept
	Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.

static double	negativePiToPi (double angle) noexcept
	Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.

static double	zeroToTwoPi (double angle) noexcept
	Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.

static double	mod (double m, double n) noexcept
	The modulo operation that also works for negative dividends.

static constexpr double	degreesToRadians (double angleDegrees) noexcept
	Converts degrees to radians.

static constexpr double	radiansToDegrees (double angleRadians) noexcept
	Converts radians to degrees.

static double	lerp (double p, double q, double time) noexcept
	Computes the linear interpolation of two values.

static constexpr double	clamp (double value, double min, double max) noexcept
	Constrain a value to lie between two values.

static double	toSNorm (double value, double rangeMaximum=255.0) noexcept
	Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum].

static constexpr double	fromSNorm (double value, double rangeMaximum=255.0) noexcept
	Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].

static double	convertLongitudeRange (double angle) noexcept

static double	roundUp (double value, double tolerance) noexcept
	Rounds a value up to the nearest integer, like `ceil`, except that if the value is very close to the lower integer it is rounded down (like `floor`) instead.

static double	roundDown (double value, double tolerance) noexcept
	Rounds a value down to the nearest integer, like `floor`, except that if the value is very close to the higher integer it is rounded up (like `ceil`) instead.

Static Public Attributes
static constexpr double	Epsilon1 = 1e-1
	0.1

static constexpr double	Epsilon2 = 1e-2
	0.01

static constexpr double	Epsilon3 = 1e-3
	0.001

static constexpr double	Epsilon4 = 1e-4
	0.0001

static constexpr double	Epsilon5 = 1e-5
	0.00001

static constexpr double	Epsilon6 = 1e-6
	0.000001

static constexpr double	Epsilon7 = 1e-7
	0.0000001

static constexpr double	Epsilon8 = 1e-8
	0.00000001

static constexpr double	Epsilon9 = 1e-9
	0.000000001

static constexpr double	Epsilon10 = 1e-10
	0.0000000001

static constexpr double	Epsilon11 = 1e-11
	0.00000000001

static constexpr double	Epsilon12 = 1e-12
	0.000000000001

static constexpr double	Epsilon13 = 1e-13
	0.0000000000001

static constexpr double	Epsilon14 = 1e-14
	0.00000000000001

static constexpr double	Epsilon15 = 1e-15
	0.000000000000001

static constexpr double	Epsilon16 = 1e-16
	0.0000000000000001

static constexpr double	Epsilon17 = 1e-17
	0.00000000000000001

static constexpr double	Epsilon18 = 1e-18
	0.000000000000000001

static constexpr double	Epsilon19 = 1e-19
	0.0000000000000000001

static constexpr double	Epsilon20 = 1e-20
	0.00000000000000000001

static constexpr double	Epsilon21 = 1e-21
	0.000000000000000000001

static constexpr double	OnePi = 3.14159265358979323846
	Pi.

static constexpr double	TwoPi = OnePi * 2.0
	Two times pi.

static constexpr double	PiOverTwo = OnePi / 2.0
	Pi divided by two.

static constexpr double	PiOverFour = OnePi / 4.0
	Pi divided by four.

static constexpr double	GoldenRatio = 1.61803398874989484
	The golden ratio, (1.0 + sqrt(5.0)) / 2.0.

Detailed Description

Mathematical constants and functions.

Definition at line 13 of file Math.h.

Member Function Documentation

◆ clamp()

static constexpr double CesiumUtility::Math::clamp	(	double	value,
		double	min,
		double	max )

inlinestaticconstexprnoexcept

Constrain a value to lie between two values.

Parameters

value	The value to constrain.
min	The minimum value.
max	The maximum value.

Returns: The value clamped so that min <= value <= max.

Definition at line 403 of file Math.h.

◆ convertLongitudeRange()

static double CesiumUtility::Math::convertLongitudeRange ( double angle )

inlinestaticnoexcept

Converts a longitude value, in radians, to the range [-Math::OnePi, Math::OnePi).

Parameters

angle The longitude value, in radians, to convert to the range [-Math::OnePi, Math::OnePi).

Returns: The equivalent longitude value in the range [-Math::OnePi, Math::OnePi).

  // Convert 270 degrees to -90 degrees longitude
  double longitude = CesiumUtility::Math::convertLongitudeRange(
      CesiumUtility::Math::degreesToRadians(270.0));

Definition at line 447 of file Math.h.

◆ degreesToRadians()

static constexpr double CesiumUtility::Math::degreesToRadians ( double angleDegrees )

inlinestaticconstexprnoexcept

Converts degrees to radians.

Parameters

angleDegrees The angle to convert in degrees.

Returns: The corresponding angle in radians.

Definition at line 367 of file Math.h.

◆ equalsEpsilon() [1/5]

template<typename T, glm::qualifier Q>

static constexpr bool CesiumUtility::Math::equalsEpsilon	(	const glm::mat< 4, 4, T, Q > &	left,
		const glm::mat< 4, 4, T, Q > &	right,
		double	relativeEpsilon,
		double	absoluteEpsilon )

inlinestaticconstexprnoexcept

Determines if two values are equal using an absolute or relative tolerance test.

This is useful to avoid problems due to roundoff error when comparing floating-point values directly. The values are first compared using an absolute tolerance test. If that fails, a relative tolerance test is performed. Use this test if you are unsure of the magnitudes of left and right.

Template Parameters

T	value value type.
Q	The GLM qualifier type.

Parameters

left	The first value to compare.
right	The other value to compare.
relativeEpsilon	The maximum inclusive delta between `left` and `right` for the relative tolerance test.
absoluteEpsilon	The maximum inclusive delta between `left` and `right` for the absolute tolerance test.

Returns: true if the values are equal within the epsilon; otherwise, false.

Definition at line 265 of file Math.h.

◆ equalsEpsilon() [2/5]

template<glm::length_t L, typename T, glm::qualifier Q>

static bool constexpr CesiumUtility::Math::equalsEpsilon	(	const glm::vec< L, T, Q > &	left,
		const glm::vec< L, T, Q > &	right,
		double	relativeEpsilon )

inlinestaticconstexprnoexcept

Checks whether two values are equal up to a given relative epsilon.

Template Parameters

L	The length type.
T	value value type.
Q	The GLM qualifier type.

Parameters

left	The first value.
right	The second value.
relativeEpsilon	The relative epsilon.

Returns: Whether the values are epsilon-equal

Definition at line 153 of file Math.h.

◆ equalsEpsilon() [3/5]

template<glm::length_t L, typename T, glm::qualifier Q>

static constexpr bool CesiumUtility::Math::equalsEpsilon	(	const glm::vec< L, T, Q > &	left,
		const glm::vec< L, T, Q > &	right,
		double	relativeEpsilon,
		double	absoluteEpsilon )

inlinestaticconstexprnoexcept

Determines if two values are equal using an absolute or relative tolerance test.

This is useful to avoid problems due to roundoff error when comparing floating-point values directly. The values are first compared using an absolute tolerance test. If that fails, a relative tolerance test is performed. Use this test if you are unsure of the magnitudes of left and right.

Template Parameters

L	The length type.
T	value value type.
Q	The GLM qualifier type.

Parameters

left	The first value to compare.
right	The other value to compare.
relativeEpsilon	The maximum inclusive delta between `left` and `right` for the relative tolerance test.
absoluteEpsilon	The maximum inclusive delta between `left` and `right` for the absolute tolerance test.

Returns: true if the values are equal within the epsilon; otherwise, false.

Definition at line 228 of file Math.h.

◆ equalsEpsilon() [4/5]

static constexpr bool CesiumUtility::Math::equalsEpsilon	(	double	left,
		double	right,
		double	relativeEpsilon )

inlinestaticconstexprnoexcept

Checks whether two values are equal up to a given relative epsilon.

Parameters

left	The first value.
right	The second value.
relativeEpsilon	The relative epsilon.

Returns: Whether the values are epsilon-equal

Definition at line 169 of file Math.h.

◆ equalsEpsilon() [5/5]

static constexpr bool CesiumUtility::Math::equalsEpsilon	(	double	left,
		double	right,
		double	relativeEpsilon,
		double	absoluteEpsilon )

inlinestaticconstexprnoexcept

Determines if two values are equal using an absolute or relative tolerance test.

This is useful to avoid problems due to roundoff error when comparing floating-point values directly. The values are first compared using an absolute tolerance test. If that fails, a relative tolerance test is performed. Use this test if you are unsure of the magnitudes of left and right.

Parameters

left	The first value to compare.
right	The other value to compare.
relativeEpsilon	The maximum inclusive delta between `left` and `right` for the relative tolerance test.
absoluteEpsilon	The maximum inclusive delta between `left` and `right` for the absolute tolerance test.

Returns: true if the values are equal within the epsilon; otherwise, false.

  bool a = CesiumUtility::Math::equalsEpsilon(
      0.0,
      0.01,
      CesiumUtility::Math::Epsilon2); // true
  bool b = CesiumUtility::Math::equalsEpsilon(
      0.0,
      0.1,
      CesiumUtility::Math::Epsilon2); // false
  bool c = CesiumUtility::Math::equalsEpsilon(
      3699175.1634344,
      3699175.2,
      CesiumUtility::Math::Epsilon7); // true
  bool d = CesiumUtility::Math::equalsEpsilon(
      3699175.1634344,
      3699175.2,
      CesiumUtility::Math::Epsilon9); // false

Definition at line 194 of file Math.h.

◆ fromSNorm()

static constexpr double CesiumUtility::Math::fromSNorm	(	double	value,
		double	rangeMaximum = 255.0 )

inlinestaticconstexprnoexcept

Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].

Parameters

value	SNORM value in the range [0, rangeMaximum].
rangeMaximum	The maximum value in the SNORM range, 255 by default.

Returns: Scalar in the range [-1.0, 1.0].

See also: Math::toSNorm

Definition at line 432 of file Math.h.

◆ lerp()

static double CesiumUtility::Math::lerp	(	double	p,
		double	q,
		double	time )

inlinestaticnoexcept

Computes the linear interpolation of two values.

Parameters

p	The start value to interpolate.
q	The end value to interpolate.
time	The time of interpolation generally in the range `[0.0, 1.0]`.

Returns: The linearly interpolated value.

double n = CesiumUtility::Math::lerp(0.0, 2.0, 0.5); // returns 1.0

Definition at line 391 of file Math.h.

◆ mod()

static double CesiumUtility::Math::mod	(	double	m,
		double	n )

inlinestaticnoexcept

The modulo operation that also works for negative dividends.

Parameters

m	The dividend.
n	The divisor.

Returns: The remainder.

Definition at line 352 of file Math.h.

◆ negativePiToPi()

static double CesiumUtility::Math::negativePiToPi ( double angle )

inlinestaticnoexcept

Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.

Parameters

angle The angle in radians.

Returns: The angle in the range [-Math::OnePi, Math::OnePi].

Definition at line 316 of file Math.h.

◆ radiansToDegrees()

static constexpr double CesiumUtility::Math::radiansToDegrees ( double angleRadians )

inlinestaticconstexprnoexcept

Converts radians to degrees.

Parameters

angleRadians The angle to convert in radians.

Returns: The corresponding angle in degrees.

Definition at line 377 of file Math.h.

◆ relativeEpsilonToAbsolute() [1/2]

template<glm::length_t L, typename T, glm::qualifier Q>

static constexpr glm::vec< L, T, Q > CesiumUtility::Math::relativeEpsilonToAbsolute	(	const glm::vec< L, T, Q > &	a,
		const glm::vec< L, T, Q > &	b,
		double	relativeEpsilon )

inlinestaticconstexprnoexcept

Converts a relative to an absolute epsilon, for the epsilon-equality check between two values.

Template Parameters

L	The length type.
T	value value type.
Q	The GLM qualifier type.

Parameters

a	The first value.
b	The second value.
relativeEpsilon	The relative epsilon.

Returns: The absolute epsilon.

Definition at line 117 of file Math.h.

◆ relativeEpsilonToAbsolute() [2/2]

static constexpr double CesiumUtility::Math::relativeEpsilonToAbsolute	(	double	a,
		double	b,
		double	relativeEpsilon )

inlinestaticconstexprnoexcept

Converts a relative to an absolute epsilon, for the epsilon-equality check between two values.

Parameters

a	The first value.
b	The second value.
relativeEpsilon	The relative epsilon.

Returns: The absolute epsilon.

Definition at line 133 of file Math.h.

◆ roundDown()

static double CesiumUtility::Math::roundDown	(	double	value,
		double	tolerance )

inlinestaticnoexcept

Rounds a value down to the nearest integer, like floor, except that if the value is very close to the higher integer it is rounded up (like ceil) instead.

Parameters

value	The value to round.
tolerance	The tolerance. If the value is closer than this to the higher integer, it is rounded up instead.

Returns: The rounded value.

Definition at line 492 of file Math.h.

◆ roundUp()

static double CesiumUtility::Math::roundUp	(	double	value,
		double	tolerance )

inlinestaticnoexcept

Rounds a value up to the nearest integer, like ceil, except that if the value is very close to the lower integer it is rounded down (like floor) instead.

Parameters

value	The value to round.
tolerance	The tolerance. If the value is closer than this to the lower integer, it is rounded down instead.

Returns: The rounded value.

Definition at line 472 of file Math.h.

◆ sign()

static constexpr double CesiumUtility::Math::sign ( double value )

inlinestaticconstexprnoexcept

Returns the sign of the value.

This is 1 if the value is positive, -1 if the value is negative, or 0 if the value is 0.

Parameters

value The value to return the sign of.

Returns: The sign of value.

Definition at line 287 of file Math.h.

◆ signNotZero()

static constexpr double CesiumUtility::Math::signNotZero ( double value )

inlinestaticconstexprnoexcept

Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.

This is similar to Math::sign except that returns 1.0 instead of 0.0 when the input value is 0.0.

Parameters

value The value to return the sign of.

Returns: The sign of value.

Definition at line 305 of file Math.h.

◆ toSNorm()

static double CesiumUtility::Math::toSNorm	(	double	value,
		double	rangeMaximum = 255.0 )

inlinestaticnoexcept

Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum].

Parameters

value	The scalar value in the range [-1.0, 1.0].
rangeMaximum	The maximum value in the mapped range, 255 by default.

Returns: A SNORM value, where 0 maps to -1.0 and rangeMaximum maps to 1.0.

See also: Math::fromSNorm

Definition at line 417 of file Math.h.

◆ zeroToTwoPi()

static double CesiumUtility::Math::zeroToTwoPi ( double angle )

inlinestaticnoexcept

Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.

Parameters

angle The angle in radians.

Returns: The angle in the range [0, Math::TwoPi].

Definition at line 332 of file Math.h.

Member Data Documentation

◆ Epsilon1

double CesiumUtility::Math::Epsilon1 = 1e-1

staticconstexpr

0.1

Definition at line 16 of file Math.h.

◆ Epsilon10

double CesiumUtility::Math::Epsilon10 = 1e-10

staticconstexpr

0.0000000001

Definition at line 43 of file Math.h.

◆ Epsilon11

double CesiumUtility::Math::Epsilon11 = 1e-11

staticconstexpr

0.00000000001

Definition at line 46 of file Math.h.

◆ Epsilon12

double CesiumUtility::Math::Epsilon12 = 1e-12

staticconstexpr

0.000000000001

Definition at line 49 of file Math.h.

◆ Epsilon13

double CesiumUtility::Math::Epsilon13 = 1e-13

staticconstexpr

0.0000000000001

Definition at line 52 of file Math.h.

◆ Epsilon14

double CesiumUtility::Math::Epsilon14 = 1e-14

staticconstexpr

0.00000000000001

Definition at line 55 of file Math.h.

◆ Epsilon15

double CesiumUtility::Math::Epsilon15 = 1e-15

staticconstexpr

0.000000000000001

Definition at line 58 of file Math.h.

◆ Epsilon16

double CesiumUtility::Math::Epsilon16 = 1e-16

staticconstexpr

0.0000000000000001

Definition at line 61 of file Math.h.

◆ Epsilon17

double CesiumUtility::Math::Epsilon17 = 1e-17

staticconstexpr

0.00000000000000001

Definition at line 64 of file Math.h.

◆ Epsilon18

double CesiumUtility::Math::Epsilon18 = 1e-18

staticconstexpr

0.000000000000000001

Definition at line 67 of file Math.h.

◆ Epsilon19

double CesiumUtility::Math::Epsilon19 = 1e-19

staticconstexpr

0.0000000000000000001

Definition at line 70 of file Math.h.

◆ Epsilon2

double CesiumUtility::Math::Epsilon2 = 1e-2

staticconstexpr

0.01

Definition at line 19 of file Math.h.

◆ Epsilon20

double CesiumUtility::Math::Epsilon20 = 1e-20

staticconstexpr

0.00000000000000000001

Definition at line 73 of file Math.h.

◆ Epsilon21

double CesiumUtility::Math::Epsilon21 = 1e-21

staticconstexpr

0.000000000000000000001

Definition at line 76 of file Math.h.

◆ Epsilon3

double CesiumUtility::Math::Epsilon3 = 1e-3

staticconstexpr

0.001

Definition at line 22 of file Math.h.

◆ Epsilon4

double CesiumUtility::Math::Epsilon4 = 1e-4

staticconstexpr

0.0001

Definition at line 25 of file Math.h.

◆ Epsilon5

double CesiumUtility::Math::Epsilon5 = 1e-5

staticconstexpr

0.00001

Definition at line 28 of file Math.h.

◆ Epsilon6

double CesiumUtility::Math::Epsilon6 = 1e-6

staticconstexpr

0.000001

Definition at line 31 of file Math.h.

◆ Epsilon7

double CesiumUtility::Math::Epsilon7 = 1e-7

staticconstexpr

0.0000001

Definition at line 34 of file Math.h.

◆ Epsilon8

double CesiumUtility::Math::Epsilon8 = 1e-8

staticconstexpr

0.00000001

Definition at line 37 of file Math.h.

◆ Epsilon9

double CesiumUtility::Math::Epsilon9 = 1e-9

staticconstexpr

0.000000001

Definition at line 40 of file Math.h.

◆ GoldenRatio

double CesiumUtility::Math::GoldenRatio = 1.61803398874989484

staticconstexpr

The golden ratio, (1.0 + sqrt(5.0)) / 2.0.

Definition at line 101 of file Math.h.

◆ OnePi

double CesiumUtility::Math::OnePi = 3.14159265358979323846

staticconstexpr

Pi.

Definition at line 81 of file Math.h.

◆ PiOverFour

double CesiumUtility::Math::PiOverFour = OnePi / 4.0

staticconstexpr

Pi divided by four.

Definition at line 96 of file Math.h.

◆ PiOverTwo

double CesiumUtility::Math::PiOverTwo = OnePi / 2.0

staticconstexpr

Pi divided by two.

Definition at line 91 of file Math.h.

◆ TwoPi

double CesiumUtility::Math::TwoPi = OnePi * 2.0

staticconstexpr

Two times pi.

Definition at line 86 of file Math.h.

The documentation for this class was generated from the following file:

/home/runner/work/cesium-native/cesium-native/CesiumUtility/include/CesiumUtility/Math.h

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

◆ clamp()

◆ convertLongitudeRange()

◆ degreesToRadians()

◆ equalsEpsilon() [1/5]

◆ equalsEpsilon() [2/5]

◆ equalsEpsilon() [3/5]

◆ equalsEpsilon() [4/5]

◆ equalsEpsilon() [5/5]

◆ fromSNorm()

◆ lerp()

◆ mod()

◆ negativePiToPi()

◆ radiansToDegrees()

◆ relativeEpsilonToAbsolute() [1/2]

◆ relativeEpsilonToAbsolute() [2/2]

◆ roundDown()

◆ roundUp()

◆ sign()

◆ signNotZero()

◆ toSNorm()

◆ zeroToTwoPi()

Member Data Documentation

◆ Epsilon1

◆ Epsilon10

◆ Epsilon11

◆ Epsilon12

◆ Epsilon13

◆ Epsilon14

◆ Epsilon15

◆ Epsilon16

◆ Epsilon17

◆ Epsilon18

◆ Epsilon19

◆ Epsilon2

◆ Epsilon20

◆ Epsilon21

◆ Epsilon3

◆ Epsilon4

◆ Epsilon5

◆ Epsilon6

◆ Epsilon7

◆ Epsilon8

◆ Epsilon9

◆ GoldenRatio

◆ OnePi

◆ PiOverFour

◆ PiOverTwo

◆ TwoPi