Introducing ITABaser namespace, starting with data classes

parent 6dc041dc
...@@ -24,8 +24,9 @@ ...@@ -24,8 +24,9 @@
// STL // STL
#include <cmath> #include <cmath>
#include <numeric>
#include <limits> #include <limits>
#include <numeric>
#include <vector>
namespace ITAConstants namespace ITAConstants
{ {
...@@ -58,6 +59,12 @@ namespace ITAConstants ...@@ -58,6 +59,12 @@ namespace ITAConstants
static float MINUS_INFINITY_F = -std::numeric_limits< float >::infinity(); static float MINUS_INFINITY_F = -std::numeric_limits< float >::infinity();
static double INFINITY_D = std::numeric_limits< double >::infinity(); static double INFINITY_D = std::numeric_limits< double >::infinity();
static double MINUS_INFINITY_D = -std::numeric_limits< double >::infinity(); static double MINUS_INFINITY_D = -std::numeric_limits< double >::infinity();
static std::vector< float > THIRD_OCTAVE_CENTER_FREQUENCIES_ISO_F = { 20, 25, 31.5f, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500, 16000, 20000 };
static std::vector< double > THIRD_OCTAVE_CENTER_FREQUENCIES_ISO_D = { 20, 25, 31.5f, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500, 16000, 20000 };
static std::vector< float > OCTAVE_CENTER_FREQUENCIES_ISO_F = { 31.5f, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000 };
static std::vector< double > OCTAVE_CENTER_FREQUENCIES_ISO_D = { 31.5f, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000 };
}; };
#endif // INCLUDE_WATCHER_ITA_CONSTANTS #endif // INCLUDE_WATCHER_ITA_CONSTANTS
...@@ -25,62 +25,67 @@ ...@@ -25,62 +25,67 @@
#include <string> #include <string>
//! Single channel finite impulse response class / FIR filter namespace ITABase
/**
* ITASampleBuffer with a sampling rate = finite impulse response.
* For multi channel FIR filter, @sa ITAMultichannelFiniteImpulseResponse
*/
class ITA_BASE_API CITAFiniteImpulseResponse : public ITASampleBuffer
{ {
public:
//! Create empty FIR filter
/**
* Requires initialization to be used, otherwise methods will throw ITAException.
*/
CITAFiniteImpulseResponse();
//! Create FIR filter of certain size with given sampling frequency //! Single channel finite impulse response class / FIR filter
/** /**
* \param iLength Length (size) of buffer in samples * ITASampleBuffer with a sampling rate = finite impulse response.
* For multi channel FIR filter, @sa ITAMultichannelFiniteImpulseResponse
*/ */
explicit CITAFiniteImpulseResponse( const int iLength, const float fSampleRate, const bool bZeroInit = true ); class ITA_BASE_API CFiniteImpulseResponse : public ITASampleBuffer
{
public:
//! Create empty FIR filter
/**
* Requires initialization to be used, otherwise methods will throw ITAException.
*/
CFiniteImpulseResponse();
//! Copy constructor as pointer //! Create FIR filter of certain size with given sampling frequency
/** /**
* \param pSource Pointer to source buffer * \param iLength Length (size) of buffer in samples
*/ */
CITAFiniteImpulseResponse( const CITAFiniteImpulseResponse* pSource ); explicit CFiniteImpulseResponse( const int iLength, const float fSampleRate, const bool bZeroInit = true );
//! Copy constructor as reference //! Copy constructor as pointer
/** /**
* \param pbSource Reference to source buffer * \param pSource Pointer to source buffer
*/ */
CITAFiniteImpulseResponse( const CITAFiniteImpulseResponse& sbSource ); CFiniteImpulseResponse( const CFiniteImpulseResponse* pSource );
virtual inline ~CITAFiniteImpulseResponse() {}; //! Copy constructor as reference
/**
* \param pbSource Reference to source buffer
*/
CFiniteImpulseResponse( const CFiniteImpulseResponse& sbSource );
//! Sampling frequency of FIR filter (double of Nyquist frequency) virtual inline ~CFiniteImpulseResponse() {};
float GetSampleRate() const;
//! Nyquist frequency of FIR filter (half of sample rate) //! Sampling frequency of FIR filter (double of Nyquist frequency)
float GetNyquistFrequency() const; float GetSampleRate() const;
//! Nyquist frequency of FIR filter (half of sample rate)
float GetNyquistFrequency() const;
//! Initialize
/**
* (Re-)Initialize a sample buffer
*
* @param[in] iLength Number of new samples
* @param[in] fSampleRate Sampling rate of FIR filter (double of Nyquist frequency)
* @param[in] bZeroInit Init with zeros
*/
void Init( const int iLength, const float fSampleRate, const bool bZeroInit = true );
//! Initialize
/**
* (Re-)Initialize a sample buffer
*
* @param[in] iLength Number of new samples
* @param[in] fSampleRate Sampling rate of FIR filter (double of Nyquist frequency)
* @param[in] bZeroInit Init with zeros
*/
void Init( const int iLength, const float fSampleRate, const bool bZeroInit = true );
private:
//! Disable this Init method from sample buffer
void Init( int, bool );
private: float m_fSampleRate; //!< Sampling rate
//! Disable this Init method from sample buffer };
void Init( int, bool );
float m_fSampleRate; //!< Sampling rate }
};
#endif // INCLUDE_WATCHER_ITA_FINITE_IMPULSE_RESPONSE #endif // INCLUDE_WATCHER_ITA_FINITE_IMPULSE_RESPONSE
...@@ -26,84 +26,89 @@ ...@@ -26,84 +26,89 @@
// STL includes // STL includes
#include <vector> #include <vector>
class ITAHDFTSpectrum; namespace ITABase
//! Multi-channel half-sided discrete fourier spectra
/**
*
* This class describes DFT spectrum data with variable number channels
* and provides functionality for manipulation and math operations.
*
* This class extends the \ITAHDFTSpectrum for multi-channel applications.
*
*/
class ITA_BASE_API ITAHDFTSpectra
{ {
public:
//! Constructor that initializes the class CHDFTSpectrum;
ITAHDFTSpectra( const float fSampleRate, const int iNumChannels, const int iDFTSize, const bool bZeroInit=true );
//! Constructor that uses a non-empty HDFTSpectrum vector //! Multi-channel half-sided discrete fourier spectra
ITAHDFTSpectra( const std::vector< ITAHDFTSpectrum* >& vpSpectrumVec );
//! Standard destructor
~ITAHDFTSpectra();
//! Return number of channels
/** /**
* \return Number of spectra / dimension of filter *
* This class describes DFT spectrum data with variable number channels
* and provides functionality for manipulation and math operations.
*
* This class extends the \ITAHDFTSpectrum for multi-channel applications.
*
*/ */
int GetNumChannels() const; class ITA_BASE_API CHDFTSpectra
{
public:
//! Return DFT size //! Constructor that initializes the
/** CHDFTSpectra( const float fSampleRate, const int iNumChannels, const int iDFTSize, const bool bZeroInit = true );
* \return Number of coeffs + 1 for DC value
*/ //! Constructor that uses a non-empty HDFTSpectrum vector
int GetDFTSize() const; CHDFTSpectra( const std::vector< CHDFTSpectrum* >& vpSpectrumVec );
//! Standard destructor
~CHDFTSpectra();
//! Return number of channels
/**
* \return Number of spectra / dimension of filter
*/
int GetNumChannels() const;
//! Return DFT size
/**
* \return Number of coeffs + 1 for DC value
*/
int GetDFTSize() const;
//! Return sampling rate
double GetSampleRate() const;
//! Return sampling rate //! Adds the given spectra channel-wise
double GetSampleRate() const; void add( const CHDFTSpectra* );
//! Adds the given spectra channel-wise //! Subtracts the given spectra channel-wise
void add( const ITAHDFTSpectra* ); void sub( const CHDFTSpectra* );
//! Subtracts the given spectra channel-wise //! Multiplies the given spectra channel-wise
void sub( const ITAHDFTSpectra* ); void mul( const CHDFTSpectra* );
//! Multiplies the given spectra channel-wise //! Multiplies the conjugate of the given spectra without data copy channel-wise
void mul( const ITAHDFTSpectra* ); void mul_conj( const CHDFTSpectra* );
//! Multiplies the conjugate of the given spectra without data copy channel-wise //! Multiplies a scalar
void mul_conj( const ITAHDFTSpectra* ); void mul_scalar( double );
//! Multiplies a scalar //! Divides the given spectra channel-wise
void mul_scalar( double ); void div( const CHDFTSpectra* );
//! Divides the given spectra channel-wise //! Set unity (all coefficiants real one)
void div( const ITAHDFTSpectra* ); void SetUnity();
//! Set unity (all coefficiants real one) //! Set unity (all coefficiants real one)
void SetUnity(); void SetZero();
//! Set unity (all coefficiants real one) //! Copy from another Spectra
void SetZero(); void CopyFrom( const CHDFTSpectra* otherSpectra );
//! Copy from another Spectra //! Returns maximum energy from all spectra
void CopyFrom(const ITAHDFTSpectra* otherSpectra); float GetMaxEnergy( int* piChannelIndex = nullptr ) const;
//! Returns maximum energy from all spectra //! Subscript operator gives direct access to spectrum channel
float GetMaxEnergy( int* piChannelIndex = nullptr ) const; const CHDFTSpectrum* operator[]( const int ) const;
CHDFTSpectrum* operator[]( const int );
//! Subscript operator gives direct access to spectrum channel private:
const ITAHDFTSpectrum* operator[]( const int ) const; //! Standard constructor
ITAHDFTSpectrum* operator[]( const int ); CHDFTSpectra();
private: std::vector< CHDFTSpectrum* > m_vpSpectra; //! DFT spectra
//! Standard constructor };
ITAHDFTSpectra();
std::vector< ITAHDFTSpectrum* > m_vpSpectra; //! DFT spectra }
};
#endif // INCLUDE_WATCHER_ITA_HDFT_SPECTRA #endif // INCLUDE_WATCHER_ITA_HDFT_SPECTRA
This diff is collapsed.
...@@ -22,76 +22,81 @@ ...@@ -22,76 +22,81 @@
#include <ITABaseDefinitions.h> #include <ITABaseDefinitions.h>
#include <ITASpectrum.h> #include <ITASpectrum.h>
// Forward for aliasing classes namespace ITABase
class CITAGainMagnitudeSpectrum;
//! A factor magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/**
* This alias class is used to give the user a hint that the underlying data should be treated as linear values (factors)
* or gains, because a magnitude spectrum does not specify on that. It is used like a CITAMagnitudeSpectrum.
* There is no real difference between a factor and a gain except that gains are commonly used in DSP (i.e. for "gain" control
* of audio signal channels) and factors are more common in acoustic materials such as absorption and transmission "factor".
*/
typedef CITAGainMagnitudeSpectrum CITAFactorMagnitudeSpectrum;
//! Magnitude spectrum of arbitrary size and base frequencies
/**
* Implementation class for magnitude spectra, that does not specify on underlying data. To be more precise in your code and
* for validation of data it is recommended to use the alias classes CITADecibelMagnitudeSpectrum, CITAGainMagnitudeSpectrum or CITAFactorMagnitudeSpectrum,
* which implement the abstract methods and are ready to use.
*
* Will raise CITAException on errors.
*
* @sa CITAThirdOctaveSpectrum, CITAPhaseSpectrum, CITAHDFTSpectrum
*
*/
class ITA_BASE_API CITAMagnitudeSpectrum : public CITASpectrum
{ {
public:
CITAMagnitudeSpectrum( const int nNumBands ); // Forward for aliasing classes
virtual inline ~CITAMagnitudeSpectrum() {}; class CGainMagnitudeSpectrum;
std::vector< float > GetMagnitudesCopy() const; //! A factor magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
const std::vector< float >& GetMagnitudes() const; /**
* This alias class is used to give the user a hint that the underlying data should be treated as linear values (factors)
void SetMagnitudes( const std::vector< float >& vfMagnitudes ); * or gains, because a magnitude spectrum does not specify on that. It is used like a CITAMagnitudeSpectrum.
void SetMagnitude( const int iFrequencyBandIndex, const float fMagnitudeValue ); * There is no real difference between a factor and a gain except that gains are commonly used in DSP (i.e. for "gain" control
* of audio signal channels) and factors are more common in acoustic materials such as absorption and transmission "factor".
bool CompareEqualValues( const CITAMagnitudeSpectrum& oOtherSpectrum, const float fThreshold = 10.0e-10 ) const; */
}; typedef CGainMagnitudeSpectrum CFactorMagnitudeSpectrum;
//! Magnitude spectrum of arbitrary size and base frequencies
//! A decibel magnitude spectrum with values that have been transformed into logarithmic scale. Values are mostly between -\infinity and 0, but can also exceed. /**
/** * Implementation class for magnitude spectra, that does not specify on underlying data. To be more precise in your code and
* This alias class is used to give the user a hint that the underlying data should be treated as decibel values (log scale), * for validation of data it is recommended to use the alias classes CITADecibelMagnitudeSpectrum, CITAGainMagnitudeSpectrum or CITAFactorMagnitudeSpectrum,
* because a magnitude spectrum does not specify on that. It is used like a CITAMagnitudeSpectrum. * which implement the abstract methods and are ready to use.
*/ *
class ITA_BASE_API CITADecibelMagnitudeSpectrum : public CITAMagnitudeSpectrum * Will raise CITAException on errors.
{ *
public: * @sa CITAThirdOctaveSpectrum, CITAPhaseSpectrum, CITAHDFTSpectrum
CITADecibelMagnitudeSpectrum( const int nNumBands ); *
virtual ~CITADecibelMagnitudeSpectrum(); */
class ITA_BASE_API CMagnitudeSpectrum : public CITASpectrum
void SetIdentity(); {
void SetZero(); public:
bool IsIdentity() const; CMagnitudeSpectrum( const int nNumBands );
bool IsZero() const; virtual inline ~CMagnitudeSpectrum() {};
};
std::vector< float > GetMagnitudesCopy() const;
//! A gain magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed. const std::vector< float >& GetMagnitudes() const;
/**
* @sa CITAFactorMagnitudeSpectrum void SetMagnitudes( const std::vector< float >& vfMagnitudes );
*/ void SetMagnitude( const int iFrequencyBandIndex, const float fMagnitudeValue );
class ITA_BASE_API CITAGainMagnitudeSpectrum : public CITAMagnitudeSpectrum
{ bool CompareEqualValues( const CMagnitudeSpectrum& oOtherSpectrum, const float fThreshold = 10.0e-10 ) const;
public: };
CITAGainMagnitudeSpectrum( const int nNumBands );
virtual ~CITAGainMagnitudeSpectrum();
//! A decibel magnitude spectrum with values that have been transformed into logarithmic scale. Values are mostly between -\infinity and 0, but can also exceed.
void SetIdentity(); /**
void SetZero(); * This alias class is used to give the user a hint that the underlying data should be treated as decibel values (log scale),
bool IsIdentity() const; * because a magnitude spectrum does not specify on that. It is used like a CITAMagnitudeSpectrum.
bool IsZero() const; */
}; class ITA_BASE_API CDecibelMagnitudeSpectrum : public CMagnitudeSpectrum
{
public:
CDecibelMagnitudeSpectrum( const int nNumBands );
virtual ~CDecibelMagnitudeSpectrum();
void SetIdentity();
void SetZero();
bool IsIdentity() const;
bool IsZero() const;
};
//! A gain magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/**
* @sa CITAFactorMagnitudeSpectrum
*/
class ITA_BASE_API CGainMagnitudeSpectrum : public CMagnitudeSpectrum
{
public:
CGainMagnitudeSpectrum( const int nNumBands );
virtual ~CGainMagnitudeSpectrum();
void SetIdentity();
void SetZero();
bool IsIdentity() const;
bool IsZero() const;
};
}
#endif // INCLUDE_WATCHER_ITA_MAGNITUDE_SPECTRUM #endif // INCLUDE_WATCHER_ITA_MAGNITUDE_SPECTRUM
...@@ -23,153 +23,153 @@ ...@@ -23,153 +23,153 @@
#include <ITAMagnitudeSpectrum.h> #include <ITAMagnitudeSpectrum.h>
#include <ITAConstants.h> #include <ITAConstants.h>
//! Third octave magnitude spectrum namespace ITABase
/**
* Class for third octave magnitude spectra with predefined center frequencies.
*
* Will raise CITAException on errors.
*
* @sa CITAWholeOctaveMagnitudeSpectrum
*/
class CITAThirdOctaveMagnitudeSpectrum : public CITAMagnitudeSpectrum
{ {
public:
inline CITAThirdOctaveMagnitudeSpectrum()
: CITAMagnitudeSpectrum( GetNumBands() )
{
m_vfCenterFrequencies = GetCenterFrequencies();
};
inline static int GetNumBands() //! Third octave magnitude spectrum
/**
* Class for third octave magnitude spectra with predefined center frequencies.
*
* Will raise CITAException on errors.
*
* @sa CITAWholeOctaveMagnitudeSpectrum
*/
class CThirdOctaveMagnitudeSpectrum : public CMagnitudeSpectrum
{ {
return 31; public:
}; inline CThirdOctaveMagnitudeSpectrum()
: CMagnitudeSpectrum( GetNumBands() )
{
m_vfCenterFrequencies = GetCenterFrequencies();
};
inline static std::vector< float > GetCenterFrequencies() inline static int GetNumBands()
{
return
{ {
20, 25, 31.5f, 40, 50, 63, 80, 100, 125, 160, 200, return 31;
250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000,
2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500, 16000, 20000
}; };
};
virtual inline ~CITAThirdOctaveMagnitudeSpectrum() {}; inline static std::vector< float > GetCenterFrequencies()
{
return ITAConstants::THIRD_OCTAVE_CENTER_FREQUENCIES_ISO_F;
};
virtual inline bool CompareEqualValues( const CITAThirdOctaveMagnitudeSpectrum& oOtherSpectrum, const float fThreshold = 10.0e-10 ) virtual inline ~CThirdOctaveMagnitudeSpectrum() {};
{
return CITASpectrum::CompareEqualValues( oOtherSpectrum, fThreshold );
};
protected: virtual inline bool CompareEqualValues( const CThirdOctaveMagnitudeSpectrum& oOtherSpectrum, const float fThreshold = 10.0e-10 )
void SetCenterFrequencies( const std::vector< float >& vfCenterFrequencies ); {
}; return CITASpectrum::CompareEqualValues( oOtherSpectrum, fThreshold );
};
//! Implementation of magnitude spectrum for gain values protected:
class CITAThirdOctaveGainMagnitudeSpectrum : public CITAThirdOctaveMagnitudeSpectrum void SetCenterFrequencies( const std::vector< float >& vfCenterFrequencies );
{ };
public:
inline CITAThirdOctaveGainMagnitudeSpectrum() //! Implementation of magnitude spectrum for gain values
: CITAThirdOctaveMagnitudeSpectrum() class CThirdOctaveGainMagnitudeSpectrum : public CThirdOctaveMagnitudeSpectrum
{ {
public:
inline CThirdOctaveGainMagnitudeSpectrum()
: CThirdOctaveMagnitudeSpectrum()
{
}; };
virtual ~CITAThirdOctaveGainMagnitudeSpectrum() {}; virtual ~CThirdOctaveGainMagnitudeSpectrum() {};
inline void SetIdentity() inline void SetIdentity()
{ {
for( size_t n = 0; n < m_vfValues.size(); n++ ) for( size_t n = 0; n < m_vfValues.size(); n++ )
m_vfValues[ n ] = 1.0f; m_vfValues[ n ] = 1.0f;
}; };
inline void SetZero() inline void SetZero()
{ {
for( size_t n = 0; n < m_vfValues.size(); n++ ) for( size_t n = 0; n < m_vfValues.size(); n++ )
m_vfValues[ n ] = 0.0f; m_vfValues[ n ] = 0.0f;
}; };
inline bool IsIdentity() const inline bool IsIdentity() const
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
{ {
if( m_vfValues[ n ] != 1.0f ) for( size_t n = 0; n < m_vfValues.size(); n++ )
return false; {
} if( m_vfValues[ n ] != 1.0f )
return false;
}
return true; return true;
}; };
inline bool IsZero() const inline bool IsZero() const
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
{ {
if( m_vfValues[ n ] != 0.0f ) for( size_t n = 0; n < m_vfValues.size(); n++ )
return false; {
} if( m_vfValues[ n ] != 0.0f )
return false;
}
return true; return true;
};
}; };
};
//! A factor magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed. //! A factor magnitude spectrum with linear values that are greater zero and usually between 0..1, but can also exceed.
/** /**
* This alias class is used to give the user a hint that the underlying data should be treated as linear values (factors) * This alias class is used to give the user a hint that the underlying data should be treated as linear values (factors)
* or gains, because a magnitude spectrum does not specify on that. It is used like a CITAThirdOctaveMagnitudeSpectrum. * or gains, because a magnitude spectrum does not specify on that. It is used like a CITAThirdOctaveMagnitudeSpectrum.
* There is no real difference between a factor and a gain except that gains are commonly used in DSP (i.e. for "gain" control * There is no real difference between a factor and a gain except that gains are commonly used in DSP (i.e. for "gain" control
* of audio signal channels) and factors are more common in acoustic materials such as absorption and transmission "factor". * of audio signal channels) and factors are more common in acoustic materials such as absorption and transmission "factor".
*/ */
typedef CITAThirdOctaveGainMagnitudeSpectrum CITAThirdOctaveFactorMagnitudeSpectrum; typedef CThirdOctaveGainMagnitudeSpectrum CITAThirdOctaveFactorMagnitudeSpectrum;
//! A decibel magnitude spectrum with values that have been transformed into logarithmic scale. Values are mostly between -\infinity and 0, but can also exceed. //! A decibel magnitude spectrum with values that have been transformed into logarithmic scale. Values are mostly between -\infinity and 0, but can also exceed.
class CITAThirdOctaveDecibelMagnitudeSpectrum : public CITAThirdOctaveMagnitudeSpectrum class CITAThirdOctaveDecibelMagnitudeSpectrum : public CThirdOctaveMagnitudeSpectrum
{
public:
inline CITAThirdOctaveDecibelMagnitudeSpectrum()
: CITAThirdOctaveMagnitudeSpectrum()
{ {
public:
inline CITAThirdOctaveDecibelMagnitudeSpectrum()
: CThirdOctaveMagnitudeSpectrum()
{
}; };
virtual ~CITAThirdOctaveDecibelMagnitudeSpectrum() {}; virtual ~CITAThirdOctaveDecibelMagnitudeSpectrum() {};
inline void SetIdentity() inline void SetIdentity()
{ {
for( size_t n = 0; n < m_vfValues.size(); n++ ) for( size_t n = 0; n < m_vfValues.size(); n++ )
m_vfValues[ n ] = 0.0f; m_vfValues[ n ] = 0.0f;
}; };
inline void SetZero() inline void SetZero()
{ {
for( size_t n = 0; n < m_vfValues.size(); n++ ) for( size_t n = 0; n < m_vfValues.size(); n++ )
m_vfValues[ n ] = ITAConstants::MINUS_INFINITY_F; m_vfValues[ n ] = ITAConstants::MINUS_INFINITY_F;
}; };
inline bool IsIdentity() const inline bool IsIdentity() const
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
{ {
if( m_vfValues[ n ] != 0.0f ) for( size_t n = 0; n < m_vfValues.size(); n++ )
return false; {
} if( m_vfValues[ n ] != 0.0f )
return false;
}
return true; return true;
}; };
inline bool IsZero() const inline bool IsZero() const
{
for( size_t n = 0; n < m_vfValues.size(); n++ )
{ {
if( m_vfValues[ n ] != ITAConstants::MINUS_INFINITY_F ) for( size_t n = 0; n < m_vfValues.size(); n++ )
return false; {
} if( m_vfValues[ n ] != ITAConstants::MINUS_INFINITY_F )
return false;