TFastVector.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 <cstring>
#include <initializer_list>
 
// ACF includes
#include <iser/IArchive.h>
#include <iser/CArchiveTag.h>
#include <imath/TVector.h>
 
 
namespace imath
{
 
 
template <int MaxSize, class Element = double>
class TFastVector
{
public:
       typedef Element ElementType;
 
       enum{
              MAX_ELEMENTS_COUNT = MaxSize
       };
 
       TFastVector();
 
       explicit TFastVector(int componentsCount, const Element& value = Element());
 
       TFastVector(const TFastVector<MaxSize, Element>& vector);
 
       TFastVector(std::initializer_list<Element> values);
 
       template <int Size>
       TFastVector(const imath::TVector<Size, Element>& vector)
       :      m_elementsCount(Size)
       {
              Q_ASSERT(Size <= MaxSize);
 
              for (int i = 0; i < Size; ++i){
                     m_elements[i] = vector[i];
              }
       }
 
       int GetElementsCount() const;
 
       bool SetElementsCount(int count, const Element& value = Element());
 
       bool EnsureElementsCount(int count, const Element& value = Element());
 
       const Element& GetElement(int i) const;
 
       Element& GetElementRef(int i);
 
       void SetElement(int i, const Element& value);
 
       void Clear();
 
       void SetElementsFrom(const TFastVector& vector, const Element& expansionValue = Element());
 
       void Translate(const TFastVector<MaxSize, Element>& vector);
 
       TFastVector<MaxSize, Element> GetTranslated(const TFastVector<MaxSize, Element>& vector);
 
       void GetTranslated(const TFastVector<MaxSize, Element>& vector, TFastVector<MaxSize, Element>& result);
 
       void ScaledCumulate(const TFastVector<MaxSize, Element>& vector, Element scale);
 
       bool IsNull(Element tolerance = I_BIG_EPSILON) const;
 
       Element GetDotProduct(const TFastVector<MaxSize, Element>& vector) const;
 
       Element GetLength2() const;
       Element GetLength() const;
 
       Element GetDistance2(const TFastVector<MaxSize, Element>& vector) const;
 
       Element GetDistance(const TFastVector<MaxSize, Element>& vector) const;
 
       Element GetElementsSum() const;
 
       bool Normalize(Element length = 1.0);
       bool GetNormalized(TFastVector<MaxSize, Element>& result, Element length = 1.0) const;
 
       void GetMinimal(const TFastVector<MaxSize, Element>& vector, TFastVector<MaxSize, Element>& result) const;
       void GetMaximal(const TFastVector<MaxSize, Element>& vector, TFastVector<MaxSize, Element>& result) const;
 
       bool Serialize(iser::IArchive& archive);
 
       bool operator==(const TFastVector<MaxSize, Element>& vector) const;
       bool operator!=(const TFastVector<MaxSize, Element>& vector) const;
       bool operator<(const TFastVector<MaxSize, Element>& vector) const;
       bool operator>(const TFastVector<MaxSize, Element>& vector) const;
       bool operator<=(const TFastVector<MaxSize, Element>& vector) const;
       bool operator>=(const TFastVector<MaxSize, Element>& vector) const;
 
       TFastVector<MaxSize, Element> operator-() const;
 
       TFastVector<MaxSize, Element> operator+(const TFastVector<MaxSize, Element>& vector) const;
       TFastVector<MaxSize, Element> operator-(const TFastVector<MaxSize, Element>& vector) const;
       TFastVector<MaxSize, Element> operator*(Element scalar) const;
       TFastVector<MaxSize, Element> operator/(Element scalar) const;
 
       TFastVector<MaxSize, Element>& operator=(const TFastVector<MaxSize, Element>& vector);
 
       TFastVector<MaxSize, Element>& operator+=(const TFastVector<MaxSize, Element>& vector);
       TFastVector<MaxSize, Element>& operator-=(const TFastVector<MaxSize, Element>& vector);
       TFastVector<MaxSize, Element>& operator*=(Element scalar);
       TFastVector<MaxSize, Element>& operator/=(Element scalar);
 
       const Element& operator[](int i) const;
       Element& operator[](int i);
 
protected:
       Element m_elements[MaxSize];
       int m_elementsCount;
};
 
 
// inline methods
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>::TFastVector()
:      m_elementsCount(0)
{
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>::TFastVector(int componentsCount, const Element& value)
:      m_elementsCount(qMin(MaxSize, componentsCount))
{
       for (int i = 0; i < m_elementsCount; ++i){
              m_elements[i] = value;
       }
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>::TFastVector(const TFastVector<MaxSize, Element>& vector)
:      m_elementsCount(vector.m_elementsCount)
{
       Q_ASSERT(m_elementsCount <= MaxSize);
 
       std::memcpy(m_elements, vector.m_elements, sizeof(Element) * m_elementsCount);
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>::TFastVector(std::initializer_list<Element> values)
:      m_elementsCount(qMin(MaxSize, static_cast<int>(values.size())))
{
       Q_ASSERT(values.size() <= MaxSize);
 
       for (int i = 0; i < m_elementsCount; ++i){
              m_elements[i] = *(values.begin() + i);
       }
}
 
 
template <int MaxSize, class Element>
inline int TFastVector<MaxSize, Element>::GetElementsCount() const
{
       return m_elementsCount;
}
 
 
template <int MaxSize, class Element>
inline bool TFastVector<MaxSize, Element>::SetElementsCount(int count, const Element& value)
{
       if (count <= MaxSize){
              for (int i = m_elementsCount; i < count; ++i){
                     m_elements[i] = value;
              }
 
              m_elementsCount = count;
 
              return true;
       }
       else{
              return false;
       }
}
 
 
template <int MaxSize, class Element>
inline bool TFastVector<MaxSize, Element>::EnsureElementsCount(int count, const Element& value)
{
       if (count <= MaxSize){
              if (m_elementsCount < count){
                     for (int i = m_elementsCount; i < count; ++i){
                            m_elements[i] = value;
                     }
 
                     m_elementsCount = count;
              }
 
              return true;
       }
       else{
              return false;
       }
}
 
 
template <int MaxSize, class Element>
inline const Element& TFastVector<MaxSize, Element>::GetElement(int i) const
{
       Q_ASSERT(i >= 0);
       Q_ASSERT(i < m_elementsCount);
 
       return m_elements[i];
}
 
 
template <int MaxSize, class Element>
inline Element& TFastVector<MaxSize, Element>::GetElementRef(int i)
{
       Q_ASSERT(i >= 0);
       Q_ASSERT(i < m_elementsCount);
 
       return m_elements[i];
}
 
 
template <int MaxSize, class Element>
inline void TFastVector<MaxSize, Element>::SetElement(int i, const Element& value)
{
       Q_ASSERT(i >= 0);
       Q_ASSERT(i < m_elementsCount);
 
       m_elements[i] = value;
}
 
 
template <int MaxSize, class Element>
inline void TFastVector<MaxSize, Element>::Clear()
{
       for (int i = 0; i < m_elementsCount; ++i){
              m_elements[i] = 0.0;
       }
}
 
 
template <int MaxSize, class Element>
inline void TFastVector<MaxSize, Element>::Translate(const TFastVector<MaxSize, Element>& vector)
{
       int commonSize = qMin(m_elementsCount, vector.m_elementsCount);
       for (int i = 0; i < commonSize; ++i){
              m_elements[i] += vector.m_elements[i];
       }
}
 
 
template <int MaxSize, class Element>
inline void TFastVector<MaxSize, Element>::ScaledCumulate(const TFastVector<MaxSize, Element>& vector, Element scale)
{
       if (m_elementsCount < vector.m_elementsCount){
              int i = 0;
              for (; i < m_elementsCount; ++i){
                     m_elements[i] += vector.m_elements[i] * scale;
              }
 
              for (; i < vector.m_elementsCount; ++i){
                     m_elements[i] = vector.m_elements[i] * scale;
              }
 
              m_elementsCount = vector.m_elementsCount;
       }
       else{
              for (int i = 0; i < vector.m_elementsCount; ++i){
                     m_elements[i] += vector.m_elements[i] * scale;
              }
       }
}
 
 
template <int MaxSize, class Element>
void TFastVector<MaxSize, Element>::SetElementsFrom(const TFastVector& vector, const Element& expansionValue)
{
       int commonSize = qMin(m_elementsCount, vector.m_elementsCount);
 
       for (int i = 0; i < commonSize; ++i){
              SetElement(i, vector[i]);
       }
 
       for (int i = commonSize; i < m_elementsCount; ++i){
              SetElement(i, expansionValue);
       }
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element> TFastVector<MaxSize, Element>::GetTranslated(const TFastVector<MaxSize, Element>& vector)
{
       return *this + vector;
}
 
 
template <int MaxSize, class Element>
void TFastVector<MaxSize, Element>::GetTranslated(const TFastVector<MaxSize, Element>& vector, TFastVector<MaxSize, Element>& result)
{
 
       result = *this;
       result.Translate(vector);
}
 
 
template <int MaxSize, class Element>
inline bool TFastVector<MaxSize, Element>::IsNull(Element tolerance) const
{
       return GetLength2() <= tolerance * tolerance;
}
 
 
template <int MaxSize, class Element>
inline Element TFastVector<MaxSize, Element>::GetDotProduct(const TFastVector<MaxSize, Element>& vector) const
{
       Element retVal = 0.0;
 
       int commonSize = qMin(m_elementsCount, vector.m_elementsCount);
       for (int i = 0; i < commonSize; ++i){
              retVal +=  m_elements[i] * vector.m_elements[i];
       }
 
       return retVal;
}
 
 
template <int MaxSize, class Element>
inline Element TFastVector<MaxSize, Element>::GetLength2() const
{
       return GetDotProduct(*this);
}
 
 
template <int MaxSize, class Element>
inline Element TFastVector<MaxSize, Element>::GetLength() const
{
       return qSqrt(GetLength2());
}
 
 
template <int MaxSize, class Element>
inline Element TFastVector<MaxSize, Element>::GetDistance2(const TFastVector<MaxSize, Element>& vector) const
{
       return (*this - vector).GetLength2();
}
 
 
template <int MaxSize, class Element>
inline Element TFastVector<MaxSize, Element>::GetDistance(const TFastVector<MaxSize, Element>& vector) const
{
       return qSqrt(GetDistance2(vector));
}
 
 
// operators
 
template <int MaxSize, class Element>
inline bool TFastVector<MaxSize, Element>::operator==(const TFastVector<MaxSize, Element>& vector) const
{
       if (m_elementsCount != vector.m_elementsCount){
              return false;
       }
 
       for (int i = 0; i < m_elementsCount; ++i){
              if (m_elements[i] != vector.m_elements[i]){
                     return false;
              }
       }
 
       return true;
}
 
 
template <int MaxSize, class Element>
inline bool TFastVector<MaxSize, Element>::operator!=(const TFastVector<MaxSize, Element>& vector) const
{
       return !operator==(vector);
}
 
 
template <int MaxSize, class Element>
bool TFastVector<MaxSize, Element>::operator<(const TFastVector<MaxSize, Element>& vector) const
{
       int commonSize = qMin(m_elementsCount, vector.m_elementsCount);
       for (int i = 0; i < commonSize; ++i){
              if (m_elements[i] > vector.m_elements[i]){
                     return false;
              }
              else if (m_elements[i] < vector.m_elements[i]){
                     return true;
              }
       }
 
       return m_elementsCount < vector.m_elementsCount;
}
 
 
template <int MaxSize, class Element>
bool TFastVector<MaxSize, Element>::operator>(const TFastVector<MaxSize, Element>& vector) const
{
       int commonSize = qMin(m_elementsCount, vector.m_elementsCount);
       for (int i = 0; i < commonSize; ++i){
              if (m_elements[i] > vector.m_elements[i]){
                     return true;
              }
              else if (m_elements[i] < vector.m_elements[i]){
                     return false;
              }
       }
 
       return m_elementsCount > vector.m_elementsCount;
}
 
 
template <int MaxSize, class Element>
bool TFastVector<MaxSize, Element>::operator<=(const TFastVector<MaxSize, Element>& vector) const
{
       int commonSize = qMin(m_elementsCount, vector.m_elementsCount);
       for (int i = 0; i < commonSize; ++i){
              if (m_elements[i] > vector.m_elements[i]){
                     return false;
              }
              else if (m_elements[i] < vector.m_elements[i]){
                     return true;
              }
       }
 
       return m_elementsCount <= vector.m_elementsCount;
}
 
 
template <int MaxSize, class Element>
bool TFastVector<MaxSize, Element>::operator>=(const TFastVector<MaxSize, Element>& vector) const
{
       int commonSize = qMin(m_elementsCount, vector.m_elementsCount);
       for (int i = 0; i < commonSize; ++i){
              if (m_elements[i] > vector.m_elements[i]){
                     return true;
              }
              else if (m_elements[i] < vector.m_elements[i]){
                     return false;
              }
       }
 
       return m_elementsCount >= vector.m_elementsCount;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>& TFastVector<MaxSize, Element>::operator=(const TFastVector<MaxSize, Element>& vector)
{
       m_elementsCount = vector.m_elementsCount;
       Q_ASSERT(m_elementsCount < MaxSize);
 
       for (int i = 0; i < m_elementsCount; ++i){
              m_elements[i] = vector.m_elements[i];
       }
 
       return *this;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>& TFastVector<MaxSize, Element>::operator+=(const TFastVector<MaxSize, Element>& vector)
{
       if (m_elementsCount < vector.m_elementsCount){
              int i = 0;
              for (; i < m_elementsCount; ++i){
                     m_elements[i] += vector.m_elements[i];
              }
 
              for (; i < vector.m_elementsCount; ++i){
                     m_elements[i] = vector.m_elements[i];
              }
 
              m_elementsCount = vector.m_elementsCount;
       }
       else{
              for (int i = 0; i < vector.m_elementsCount; ++i){
                     m_elements[i] += vector.m_elements[i];
              }
       }
 
       return *this;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>& TFastVector<MaxSize, Element>::operator-=(const TFastVector<MaxSize, Element>& vector)
{
       if (m_elementsCount < vector.m_elementsCount){
              int i = 0;
              for (; i < m_elementsCount; ++i){
                     m_elements[i] -= vector.m_elements[i];
              }
 
              for (; i < vector.m_elementsCount; ++i){
                     m_elements[i] = -vector.m_elements[i];
              }
 
              m_elementsCount = vector.m_elementsCount;
       }
       else{
              for (int i = 0; i < vector.m_elementsCount; ++i){
                     m_elements[i] -= vector.m_elements[i];
              }
       }
 
       return *this;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>& TFastVector<MaxSize, Element>::operator*=(Element scalar)
{
       for (int i = 0; i < m_elementsCount; ++i){
              m_elements[i] *= scalar;
       }
 
       return *this;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element>& TFastVector<MaxSize, Element>::operator/=(Element scalar)
{
       for (int i = 0; i < m_elementsCount; ++i){
              m_elements[i] /= scalar;
       }
 
       return *this;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element> TFastVector<MaxSize, Element>::operator-() const
{
       TFastVector<MaxSize, Element> retVal(*this);
 
       for (int i = 0; i < m_elementsCount; ++i){
              retVal.m_elements[i] = -m_elements[i];
       }
 
       return retVal;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element> TFastVector<MaxSize, Element>::operator+(const TFastVector<MaxSize, Element>& vector) const
{
       TFastVector<MaxSize, Element> retVal(*this);
 
       retVal += vector;
 
       return retVal;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element> TFastVector<MaxSize, Element>::operator-(const TFastVector<MaxSize, Element>& vector) const
{
       TFastVector<MaxSize, Element> retVal(*this);
 
       retVal -= vector;
 
       return retVal;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element> TFastVector<MaxSize, Element>::operator*(Element scalar) const
{
       TFastVector<MaxSize, Element> retVal(*this);
 
       retVal *= scalar;
 
       return retVal;
}
 
 
template <int MaxSize, class Element>
inline TFastVector<MaxSize, Element> TFastVector<MaxSize, Element>::operator/(Element scalar) const
{
       TFastVector<MaxSize, Element> retVal(*this);
 
       retVal /= scalar;
 
       return retVal;
}
 
 
template <int MaxSize, class Element>
const Element& TFastVector<MaxSize, Element>::operator[](int i) const
{
       Q_ASSERT(i >= 0);
       Q_ASSERT(i < m_elementsCount);
 
       return m_elements[i];
}
 
 
template <int MaxSize, class Element>
Element& TFastVector<MaxSize, Element>::operator[](int i)
{
       Q_ASSERT(i >= 0);
       Q_ASSERT(i < MaxSize);
 
       return m_elements[i];
}
 
 
// public methods
 
template <int MaxSize, class Element>
Element TFastVector<MaxSize, Element>::GetElementsSum() const
{
       Element retVal = 0;
 
       for (int i = 0; i < m_elementsCount; ++i){
              retVal += m_elements[i];
       }
 
       return retVal;
}
 
 
template <int MaxSize, class Element>
bool TFastVector<MaxSize, Element>::Normalize(Element length)
{
       Element isLength = GetLength();
 
       Element proportion = isLength / length;
 
       if (qAbs(proportion) > I_BIG_EPSILON){
              for (int i = 0; i < m_elementsCount; ++i){
                     m_elements[i] = m_elements[i] / proportion;
              }
 
              return true;
       }
       else{
              return false;
       }
}
 
 
template <int MaxSize, class Element>
bool TFastVector<MaxSize, Element>::GetNormalized(TFastVector<MaxSize, Element>& result, Element length) const
{
       result = *this;
 
       return result.Normalize(length);
}
 
 
template <int MaxSize, class Element>
void TFastVector<MaxSize, Element>::GetMinimal(const TFastVector<MaxSize, Element>& vector, TFastVector<MaxSize, Element>& result) const
{
       int elementsCount = qMin(GetElementsCount(), vector.GetElementsCount());
 
       result.SetElementsCount(elementsCount);
 
       for (int i = 0; i < elementsCount; ++i){
              result.SetElement(i, qMin(GetElement(i), vector.GetElement(i)));
       }
}
 
 
template <int MaxSize, class Element>
void TFastVector<MaxSize, Element>::GetMaximal(const TFastVector<MaxSize, Element>& vector, TFastVector<MaxSize, Element>& result) const
{
       int elementsCount = qMin(GetElementsCount(), vector.GetElementsCount());
 
       result.SetElementsCount(elementsCount);
 
       for (int i = 0; i < elementsCount; ++i){
              result.SetElement(i, qMax(GetElement(i), vector.GetElement(i)));
       }
}
 
 
template <int MaxSize, class Element>
bool TFastVector<MaxSize, Element>::Serialize(iser::IArchive& archive)
{
       bool retVal = true;
 
       static iser::CArchiveTag elementsTag("Elements", "List of vector element", iser::CArchiveTag::TT_MULTIPLE);
       static iser::CArchiveTag elementTag("Element", "Single vector element", iser::CArchiveTag::TT_LEAF, &elementsTag);
 
       retVal = retVal && archive.BeginMultiTag(elementsTag, elementTag, m_elementsCount);
 
       if (!retVal || (m_elementsCount > MaxSize)){
              if (!archive.IsStoring()){
                     m_elementsCount = 0;
              }
 
              return false;
       }
 
       for (int i = 0; i < m_elementsCount; ++i){
              retVal = retVal && archive.BeginTag(elementTag);
              retVal = retVal && archive.Process(m_elements[i]);
              retVal = retVal && archive.EndTag(elementTag);
       }
 
       retVal = retVal && archive.EndTag(elementsTag);
 
       return retVal;
}
 
 
// related global functions
 
template <int MaxSize, class Element>
inline uint qHash(const TFastVector<MaxSize, Element>& v, uint seed = 0)
{
       uint retVal = seed;
 
       int elementsCount = v.GetElementsCount();
       for (int i = 0; i < elementsCount; ++i){
              double element = v[i];
 
              retVal = (retVal << 1) ^ *((uint*)&element) + 1;
       }
 
       return retVal;
}
 
 
} // namespace imath