CVarVector.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// STL includes
#include <vector>
 
// Qt includes
#include <QtCore/QtGlobal>
#if QT_VERSION >= 0x050000
#include <QtCore/QtMath>
#else
#include <QtCore/qmath.h>
#endif
#include <QtCore/QVector>
 
// ACF includes
#include <imath/TVector.h>
 
 
namespace iser
{
       class IArchive;
}
 
 
namespace imath
{
 
 
class CVarVector
{
public:
       typedef std::vector<double> Elements;
 
       CVarVector();
 
       explicit CVarVector(int componentsCount, double value = 0);
 
       template <typename Iterator>
       CVarVector(Iterator beginIter, Iterator endIter);
 
       CVarVector(const CVarVector& vector);
 
       template <int Size>
       CVarVector(const TVector<Size, double>& vector);
 
       bool IsEmpty() const;
 
       int GetElementsCount() const;
 
       bool SetElementsCount(int count, double value = 0);
 
       double GetElement(int index) const;
 
       double& GetElementRef(int index);
 
       void SetElement(int index, double value);
 
       void SetAllElements(double value);
 
       void Reset();
 
       void Reset(int elementsCount, double value);
 
       void Clear();
 
       void SetElementsFrom(const CVarVector& vector, double expansionValue = 0);
 
       const Elements& GetElements() const;
 
       Elements& GetElementsRef();
 
       bool EnsureElementsCount(int count, double value = 0);
 
       void Translate(const CVarVector& vector);
 
       CVarVector GetTranslated(const CVarVector& vector);
 
       void GetTranslated(const CVarVector& vector, CVarVector& result);
 
       void ScaledCumulate(const CVarVector& vector, double scale);
 
       bool IsNull(double tolerance = I_BIG_EPSILON) const;
 
       double GetDotProduct(const CVarVector& vector) const;
 
       double GetLength2() const;
 
       double GetLength() const;
 
       double GetDistance2(const CVarVector& vector) const;
 
       double GetDistance(const CVarVector& vector) const;
 
       double GetElementsSum() const;
 
       bool Normalize(double length = 1.0);
 
       bool GetNormalized(CVarVector& result, double length = 1.0) const;
 
       void GetMinimal(const CVarVector& vector, CVarVector& result) const;
 
       void GetMaximal(const CVarVector& vector, CVarVector& result) const;
 
       bool Serialize(iser::IArchive& archive);
 
       bool operator==(const CVarVector& vector) const;
       bool operator!=(const CVarVector& vector) const;
       bool operator<(const CVarVector& vector) const;
       bool operator>(const CVarVector& vector) const;
       bool operator<=(const CVarVector& vector) const;
       bool operator>=(const CVarVector& vector) const;
 
       CVarVector operator-() const;
 
       CVarVector operator+(const CVarVector& vector) const;
       CVarVector operator-(const CVarVector& vector) const;
       CVarVector operator*(double scalar) const;
       CVarVector operator/(double scalar) const;
 
       CVarVector& operator+=(const CVarVector& vector);
       CVarVector& operator-=(const CVarVector& vector);
       CVarVector& operator*=(double scalar);
       CVarVector& operator/=(double scalar);
 
       CVarVector& operator=(const CVarVector& vector);
 
       double operator[](int i) const;
       double& operator[](int i);
 
private:
       Elements m_elements;
};
 
 
// inline constructors
 
inline CVarVector::CVarVector()
{
}
 
 
inline CVarVector::CVarVector(int componentsCount, double value)
:      m_elements(componentsCount, value)
{
}
 
 
inline CVarVector::CVarVector(const CVarVector& vector)
:      m_elements(vector.m_elements)
{
}
 
 
template <typename Iterator>
inline CVarVector::CVarVector(Iterator beginIter, Iterator endIter)
:      m_elements(beginIter, endIter)
{
}
 
 
// inline methods
 
inline bool CVarVector::IsEmpty() const
{
       return m_elements.empty();
}
 
 
inline int CVarVector::GetElementsCount() const
{
       return int(m_elements.size());
}
 
 
inline bool CVarVector::SetElementsCount(int count, double value)
{
       Q_ASSERT(count >= 0);
 
       int oldCount = int(m_elements.size());
 
       m_elements.resize(count);
 
       for (int i = oldCount; i < count; ++i){
              m_elements[i] = value;
       }
 
       return true;
}
 
 
inline double CVarVector::GetElement(int i) const
{
       return operator[](i);
}
 
 
inline double& CVarVector::GetElementRef(int i)
{
       return operator[](i);
}
 
 
inline void CVarVector::SetElement(int i, double value)
{
       operator[](i) = value;
}
 
 
inline void CVarVector::SetAllElements(double value)
{
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] = value;
       }
}
 
 
inline void CVarVector::Reset()
{
       m_elements.clear();
}
 
 
inline void CVarVector::Clear()
{
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] = 0;
       }
}
 
 
inline void CVarVector::Reset(int elementsCount, double value)
{
       m_elements.resize(elementsCount);
 
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] = value;
       }
}
 
 
inline const CVarVector::Elements& CVarVector::GetElements() const
{
       return m_elements;
}
 
 
inline CVarVector::Elements& CVarVector::GetElementsRef()
{
       return m_elements;
}
 
 
inline void CVarVector::Translate(const CVarVector& vector)
{
       Q_ASSERT(GetElementsCount() == vector.GetElementsCount());
 
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] += vector.m_elements[i];
       }
}
 
 
inline CVarVector CVarVector::GetTranslated(const CVarVector& vector)
{
       return *this + vector;
}
 
 
inline void CVarVector::GetTranslated(const CVarVector& vector, CVarVector& result)
{
       result = *this + vector;
}
 
 
inline void CVarVector::ScaledCumulate(const CVarVector& vector, double scale)
{
       Q_ASSERT(GetElementsCount() == vector.GetElementsCount());
 
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] += vector.m_elements[i] * scale;
       }
}
 
 
inline bool CVarVector::IsNull(double tolerance) const
{
       return GetLength2() <= tolerance * tolerance;
}
 
 
inline double CVarVector::GetDotProduct(const CVarVector& vector) const
{
       Q_ASSERT(GetElementsCount() == vector.GetElementsCount());
 
       double retVal = 0.0;
 
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              retVal += m_elements[i] * vector.m_elements[i];
       }
 
       return retVal;
}
 
 
inline double CVarVector::GetLength2() const
{
       return GetDotProduct(*this);
}
 
 
inline double CVarVector::GetLength() const
{
       return qSqrt(GetLength2());
}
 
 
inline double CVarVector::GetDistance2(const CVarVector& vector) const
{
       return (*this - vector).GetLength2();
}
 
 
inline double CVarVector::GetDistance(const CVarVector& vector) const
{
       return qSqrt(GetDistance2(vector));
}
 
 
// operators
 
inline bool CVarVector::operator==(const CVarVector& vector) const
{
       if (m_elements.size() != vector.m_elements.size()){
              return false;
       }
 
       bool retVal = true;
       for (         Elements::const_iterator iter1 = m_elements.begin(), iter2 = vector.m_elements.begin();
                            iter1 != m_elements.end();
                            ++iter1,++iter2){
              retVal = retVal && qFuzzyCompare(*iter1, *iter2);
       }
 
       return retVal;
}
 
 
inline bool CVarVector::operator!=(const CVarVector& vector) const
{
       return !operator==(vector);
}
 
 
inline bool CVarVector::operator<(const CVarVector& vector) const
{
       int count = int(m_elements.size());
       int vectorCount = int(vector.m_elements.size());
       int commonSize = qMin(count, vectorCount);
       for (int i = 0; i < commonSize; ++i){
              double element = m_elements[i];
              double vectorElement = vector.m_elements[i];
              if (!qFuzzyCompare(element, vectorElement)){
                     return m_elements[i] < vectorElement;
              }
       }
 
       return count < vectorCount;
}
 
 
inline bool CVarVector::operator>(const CVarVector& vector) const
{
       int count = int(m_elements.size());
       int vectorCount = int(vector.m_elements.size());
       int commonSize = qMin(count, vectorCount);
       for (int i = 0; i < commonSize; ++i){
              double element = m_elements[i];
              double vectorElement = vector.m_elements[i];
              if (!qFuzzyCompare(element, vectorElement)){
                     return element > vectorElement;
              }
       }
 
       return count > vectorCount;
}
 
 
inline bool CVarVector::operator<=(const CVarVector& vector) const
{
       int count = int(m_elements.size());
       int vectorCount = int(vector.m_elements.size());
       int commonSize = qMin(count, vectorCount);
       for (int i = 0; i < commonSize; ++i){
              double element = m_elements[i];
              double vectorElement = vector.m_elements[i];
              if (!qFuzzyCompare(element, vectorElement)){
                     return element < vectorElement;
              }
       }
 
       return count <= vectorCount;
}
 
 
inline bool CVarVector::operator>=(const CVarVector& vector) const
{
       int count = int(m_elements.size());
       int vectorCount = int(vector.m_elements.size());
       int commonSize = qMin(count, vectorCount);
       for (int i = 0; i < commonSize; ++i){
              double element = m_elements[i];
              double vectorElement = vector.m_elements[i];
              if (!qFuzzyCompare(element, vectorElement)){
                     return element > vectorElement;
              }
       }
 
       return count >= vectorCount;
}
 
 
inline CVarVector& CVarVector::operator+=(const CVarVector& vector)
{
       Q_ASSERT(GetElementsCount() == vector.GetElementsCount());
 
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] += vector.m_elements[i];
       }
 
       return *this;
}
 
 
inline CVarVector& CVarVector::operator-=(const CVarVector& vector)
{
       Q_ASSERT(GetElementsCount() == vector.GetElementsCount());
 
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] -= vector.m_elements[i];
       }
 
       return *this;
}
 
 
inline CVarVector& CVarVector::operator*=(double scalar)
{
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] *= scalar;
       }
 
       return *this;
}
 
 
inline CVarVector& CVarVector::operator/=(double scalar)
{
       int elementsCount = GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              m_elements[i] /= scalar;
       }
 
       return *this;
}
 
 
inline CVarVector& CVarVector::operator=(const CVarVector& vector)
{
       SetElementsCount(vector.GetElementsCount(), 0);
       SetElementsFrom(vector);
 
       return *this;
}
 
 
inline CVarVector CVarVector::operator-() const
{
       int elementsCount = GetElementsCount();
 
       CVarVector retVal(elementsCount);
 
       for (int i = 0; i < elementsCount; ++i){
              retVal.m_elements[i] = -m_elements[i];
       }
 
       return retVal;
}
 
 
inline CVarVector CVarVector::operator+(const CVarVector& vector) const
{
       CVarVector retVal(*this);
 
       retVal += vector;
 
       return retVal;
}
 
 
inline CVarVector CVarVector::operator-(const CVarVector& vector) const
{
       CVarVector retVal(*this);
 
       retVal -= vector;
 
       return retVal;
}
 
 
inline CVarVector CVarVector::operator*(double scalar) const
{
       CVarVector retVal(*this);
 
       retVal *= scalar;
 
       return retVal;
}
 
 
inline CVarVector CVarVector::operator/(double scalar) const
{
       CVarVector retVal(*this);
 
       retVal /= scalar;
 
       return retVal;
}
 
 
inline double CVarVector::operator[](int i) const
{
       Q_ASSERT(i >= 0);
       Q_ASSERT(i < GetElementsCount());
 
       return m_elements[i];
}
 
 
inline double& CVarVector::operator[](int i)
{
       Q_ASSERT(i >= 0);
       Q_ASSERT(i < GetElementsCount());
 
       return m_elements[i];
}
 
 
// template methods
 
template <int Size>
CVarVector::CVarVector(const TVector<Size, double>& vector)
{
       m_elements.resize(Size);
 
       for (int i = 0; i < Size; ++i){
              m_elements[i] = vector[i];
       }
}
 
 
} // namespace imath