CVarVector.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#ifndef imath_CVarVector_included
#define imath_CVarVector_included
 
 
// STL includes
#include <vector>
 
// Qt includes
#include <QtCore/QtGlobal>
#include <QtCore/QtMath>
#include <QtCore/QVector>
 
// ICF 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){
        int element = m_elements[i];
        int vectorElement = vector.m_elements[i];
        if (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){
        int element = m_elements[i];
        int vectorElement = vector.m_elements[i];
        if (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){
        int element = m_elements[i];
        int vectorElement = vector.m_elements[i];
        if (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){
        int element = m_elements[i];
        int vectorElement = vector.m_elements[i];
        if (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
 
 
#endif // !imath_CVarVector_included