mirror of
https://github.com/juce-framework/JUCE.git
synced 2026-01-23 01:44:22 +00:00
Added JUCE_CONSTEXPR to a bunch of simple maths functions
This commit is contained in:
jules
parent
fe7f34f0fa
commit
6ddff42012
1 changed files with 40 additions and 45 deletions
|
|
@ -91,33 +91,33 @@ typedef unsigned int uint32;
|
|||
|
||||
/** Returns the larger of two values. */
|
||||
template <typename Type>
|
||||
Type jmax (const Type a, const Type b) { return (a < b) ? b : a; }
|
||||
JUCE_CONSTEXPR Type jmax (Type a, Type b) { return a < b ? b : a; }
|
||||
|
||||
/** Returns the larger of three values. */
|
||||
template <typename Type>
|
||||
Type jmax (const Type a, const Type b, const Type c) { return (a < b) ? ((b < c) ? c : b) : ((a < c) ? c : a); }
|
||||
JUCE_CONSTEXPR Type jmax (Type a, Type b, Type c) { return a < b ? (b < c ? c : b) : (a < c ? c : a); }
|
||||
|
||||
/** Returns the larger of four values. */
|
||||
template <typename Type>
|
||||
Type jmax (const Type a, const Type b, const Type c, const Type d) { return jmax (a, jmax (b, c, d)); }
|
||||
JUCE_CONSTEXPR Type jmax (Type a, Type b, Type c, Type d) { return jmax (a, jmax (b, c, d)); }
|
||||
|
||||
/** Returns the smaller of two values. */
|
||||
template <typename Type>
|
||||
Type jmin (const Type a, const Type b) { return (b < a) ? b : a; }
|
||||
JUCE_CONSTEXPR Type jmin (Type a, Type b) { return b < a ? b : a; }
|
||||
|
||||
/** Returns the smaller of three values. */
|
||||
template <typename Type>
|
||||
Type jmin (const Type a, const Type b, const Type c) { return (b < a) ? ((c < b) ? c : b) : ((c < a) ? c : a); }
|
||||
JUCE_CONSTEXPR Type jmin (Type a, Type b, Type c) { return b < a ? (c < b ? c : b) : (c < a ? c : a); }
|
||||
|
||||
/** Returns the smaller of four values. */
|
||||
template <typename Type>
|
||||
Type jmin (const Type a, const Type b, const Type c, const Type d) { return jmin (a, jmin (b, c, d)); }
|
||||
JUCE_CONSTEXPR Type jmin (Type a, Type b, Type c, Type d) { return jmin (a, jmin (b, c, d)); }
|
||||
|
||||
/** Remaps a normalised value (between 0 and 1) to a target range.
|
||||
This effectively returns (targetRangeMin + value0To1 * (targetRangeMax - targetRangeMin)).
|
||||
*/
|
||||
template <typename Type>
|
||||
Type jmap (Type value0To1, Type targetRangeMin, Type targetRangeMax)
|
||||
JUCE_CONSTEXPR Type jmap (Type value0To1, Type targetRangeMin, Type targetRangeMax)
|
||||
{
|
||||
return targetRangeMin + value0To1 * (targetRangeMax - targetRangeMin);
|
||||
}
|
||||
|
|
@ -135,14 +135,16 @@ template <typename Type>
|
|||
Type findMinimum (const Type* data, int numValues)
|
||||
{
|
||||
if (numValues <= 0)
|
||||
return Type();
|
||||
return {};
|
||||
|
||||
Type result (*data++);
|
||||
auto result = *data++;
|
||||
|
||||
while (--numValues > 0) // (> 0 rather than >= 0 because we've already taken the first sample)
|
||||
{
|
||||
const Type& v = *data++;
|
||||
if (v < result) result = v;
|
||||
auto v = *data++;
|
||||
|
||||
if (v < result)
|
||||
result = v;
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
@ -153,14 +155,16 @@ template <typename Type>
|
|||
Type findMaximum (const Type* values, int numValues)
|
||||
{
|
||||
if (numValues <= 0)
|
||||
return Type();
|
||||
return {};
|
||||
|
||||
Type result (*values++);
|
||||
auto result = *values++;
|
||||
|
||||
while (--numValues > 0) // (> 0 rather than >= 0 because we've already taken the first sample)
|
||||
{
|
||||
const Type& v = *values++;
|
||||
if (result < v) result = v;
|
||||
auto v = *values++;
|
||||
|
||||
if (result < v)
|
||||
result = v;
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
@ -172,17 +176,17 @@ void findMinAndMax (const Type* values, int numValues, Type& lowest, Type& highe
|
|||
{
|
||||
if (numValues <= 0)
|
||||
{
|
||||
lowest = Type();
|
||||
highest = Type();
|
||||
lowest = {};
|
||||
highest = {};
|
||||
}
|
||||
else
|
||||
{
|
||||
Type mn (*values++);
|
||||
Type mx (mn);
|
||||
auto mn = *values++;
|
||||
auto mx = mn;
|
||||
|
||||
while (--numValues > 0) // (> 0 rather than >= 0 because we've already taken the first sample)
|
||||
{
|
||||
const Type& v = *values++;
|
||||
auto v = *values++;
|
||||
|
||||
if (mx < v) mx = v;
|
||||
if (v < mn) mn = v;
|
||||
|
|
@ -218,9 +222,9 @@ Type jlimit (Type lowerLimit,
|
|||
{
|
||||
jassert (lowerLimit <= upperLimit); // if these are in the wrong order, results are unpredictable..
|
||||
|
||||
return (valueToConstrain < lowerLimit) ? lowerLimit
|
||||
: ((upperLimit < valueToConstrain) ? upperLimit
|
||||
: valueToConstrain);
|
||||
return valueToConstrain < lowerLimit ? lowerLimit
|
||||
: (upperLimit < valueToConstrain ? upperLimit
|
||||
: valueToConstrain);
|
||||
}
|
||||
|
||||
/** Returns true if a value is at least zero, and also below a specified upper limit.
|
||||
|
|
@ -263,17 +267,8 @@ bool isPositiveAndNotGreaterThan (int valueToTest, Type upperLimit) noexcept
|
|||
|
||||
//==============================================================================
|
||||
/** Handy function for avoiding unused variables warning. */
|
||||
template <typename Type1>
|
||||
void ignoreUnused (const Type1&) noexcept {}
|
||||
|
||||
template <typename Type1, typename Type2>
|
||||
void ignoreUnused (const Type1&, const Type2&) noexcept {}
|
||||
|
||||
template <typename Type1, typename Type2, typename Type3>
|
||||
void ignoreUnused (const Type1&, const Type2&, const Type3&) noexcept {}
|
||||
|
||||
template <typename Type1, typename Type2, typename Type3, typename Type4>
|
||||
void ignoreUnused (const Type1&, const Type2&, const Type3&, const Type4&) noexcept {}
|
||||
template <typename... Types>
|
||||
void ignoreUnused (Types&&...) noexcept {}
|
||||
|
||||
/** Handy function for getting the number of elements in a simple const C array.
|
||||
E.g.
|
||||
|
|
@ -284,9 +279,9 @@ void ignoreUnused (const Type1&, const Type2&, const Type3&, const Type4&) noexc
|
|||
@endcode
|
||||
*/
|
||||
template <typename Type, int N>
|
||||
int numElementsInArray (Type (&array)[N])
|
||||
JUCE_CONSTEXPR int numElementsInArray (Type (&array)[N])
|
||||
{
|
||||
ignoreUnused (array);
|
||||
(void) array;
|
||||
(void) sizeof (0[array]); // This line should cause an error if you pass an object with a user-defined subscript operator
|
||||
return N;
|
||||
}
|
||||
|
|
@ -362,16 +357,16 @@ const float float_Pi = MathConstants<float>::pi;
|
|||
|
||||
|
||||
/** Converts an angle in degrees to radians. */
|
||||
inline float degreesToRadians (float degrees) noexcept { return degrees * (float_Pi / 180.0f); }
|
||||
inline JUCE_CONSTEXPR float degreesToRadians (float degrees) noexcept { return degrees * (float_Pi / 180.0f); }
|
||||
|
||||
/** Converts an angle in degrees to radians. */
|
||||
inline double degreesToRadians (double degrees) noexcept { return degrees * (double_Pi / 180.0); }
|
||||
inline JUCE_CONSTEXPR double degreesToRadians (double degrees) noexcept { return degrees * (double_Pi / 180.0); }
|
||||
|
||||
/** Converts an angle in radians to degrees. */
|
||||
inline float radiansToDegrees (float radians) noexcept { return radians * (180.0f / float_Pi); }
|
||||
inline JUCE_CONSTEXPR float radiansToDegrees (float radians) noexcept { return radians * (180.0f / float_Pi); }
|
||||
|
||||
/** Converts an angle in radians to degrees. */
|
||||
inline double radiansToDegrees (double radians) noexcept { return radians * (180.0 / double_Pi); }
|
||||
inline JUCE_CONSTEXPR double radiansToDegrees (double radians) noexcept { return radians * (180.0 / double_Pi); }
|
||||
|
||||
|
||||
//==============================================================================
|
||||
|
|
@ -515,13 +510,13 @@ unsigned int truncatePositiveToUnsignedInt (FloatType value) noexcept
|
|||
//==============================================================================
|
||||
/** Returns true if the specified integer is a power-of-two. */
|
||||
template <typename IntegerType>
|
||||
bool isPowerOfTwo (IntegerType value)
|
||||
JUCE_CONSTEXPR bool isPowerOfTwo (IntegerType value)
|
||||
{
|
||||
return (value & (value - 1)) == 0;
|
||||
}
|
||||
|
||||
/** Returns the smallest power-of-two which is equal to or greater than the given integer. */
|
||||
inline int nextPowerOfTwo (int n) noexcept
|
||||
inline JUCE_CONSTEXPR int nextPowerOfTwo (int n) noexcept
|
||||
{
|
||||
--n;
|
||||
n |= (n >> 1);
|
||||
|
|
@ -539,7 +534,7 @@ inline int nextPowerOfTwo (int n) noexcept
|
|||
int findHighestSetBit (uint32 n) noexcept;
|
||||
|
||||
/** Returns the number of bits in a 32-bit integer. */
|
||||
inline int countNumberOfBits (uint32 n) noexcept
|
||||
inline JUCE_CONSTEXPR int countNumberOfBits (uint32 n) noexcept
|
||||
{
|
||||
n -= ((n >> 1) & 0x55555555);
|
||||
n = (((n >> 2) & 0x33333333) + (n & 0x33333333));
|
||||
|
|
@ -550,7 +545,7 @@ inline int countNumberOfBits (uint32 n) noexcept
|
|||
}
|
||||
|
||||
/** Returns the number of bits in a 64-bit integer. */
|
||||
inline int countNumberOfBits (uint64 n) noexcept
|
||||
inline JUCE_CONSTEXPR int countNumberOfBits (uint64 n) noexcept
|
||||
{
|
||||
return countNumberOfBits ((uint32) n) + countNumberOfBits ((uint32) (n >> 32));
|
||||
}
|
||||
|
|
@ -568,7 +563,7 @@ IntegerType negativeAwareModulo (IntegerType dividend, const IntegerType divisor
|
|||
|
||||
/** Returns the square of its argument. */
|
||||
template <typename NumericType>
|
||||
NumericType square (NumericType n) noexcept
|
||||
inline JUCE_CONSTEXPR NumericType square (NumericType n) noexcept
|
||||
{
|
||||
return n * n;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue