svector.h

#ifndef SVECTOR_H
#define SVECTOR_H
 
#include <vector>
 
#include "element.h"
 
namespace svec {
 
class NormalizedSVector;
 
class SVector {
  public:
    // Constructors
 
    SVector() = default;
 
    SVector(const Element& elm);
 
    SVector(const Element* const buff);
 
    // Get Functions
 
    Value sum() const;
 
    std::size_t NNZ() const noexcept;
 
    bool isEmpty() const noexcept;
 
    Value getMinValue() const;
 
    Value getMaxValue() const;
 
    Label getMaxLabel() const;
 
    const Element* data() const noexcept;
 
    bool containsNaN() const;
 
    std::vector<Element>::const_iterator begin() const noexcept;
 
    std::vector<Element>::const_iterator end() const noexcept;
 
    // Modifiers
 
    void add(const SVector& a, const Value& C = 1.0);
 
    void add(const NormalizedSVector& a, const Value& C = 1.0);
 
    void normalize(const Value& total = 1.0);
 
    void chop(const Value& ref = 0.0);
 
    void zeroEntry(const Label& l);
 
    void clear() noexcept;
 
    friend SVector fma(const SVector& a, const Value& C, const SVector& b);
    friend SVector operator/(const SVector& a, const Value& C);
    friend SVector operator*(const SVector& a, const Value& C);
 
  private:
    std::vector<Element> vec;
};
 
class NormalizedSVector {
  public:
    NormalizedSVector()
    {
        factor = 0;
    };
 
    NormalizedSVector(const SVector& a, const Value& total = 1.0);
 
    inline operator SVector() const
    {
        return base * factor;
    }
 
    inline void clear() noexcept
    {
        base.clear();
        factor = 0;
    }
 
    friend void SVector::add(const NormalizedSVector& a, const Value& C);
 
  private:
    SVector base;
    Value factor;
};
 
SVector fma(const SVector& a, const Value& C, const SVector& b);
 
SVector operator/(const SVector& a, const Value& C);
 
SVector operator*(const SVector& a, const Value& C);
 
inline SVector::SVector(const Element& elm) : vec(1, elm)
{
}
 
inline std::size_t SVector::NNZ() const noexcept
{
    return vec.size();
}
 
inline bool SVector::isEmpty() const noexcept
{
    return vec.empty();
}
 
inline const Element* SVector::data() const noexcept
{
    return vec.data();
}
 
inline std::vector<Element>::const_iterator SVector::begin() const noexcept
{
    return vec.cbegin();
}
inline std::vector<Element>::const_iterator SVector::end() const noexcept
{
    return vec.cend();
}
 
inline void SVector::clear() noexcept
{
    vec.clear();
    // vec.shrink_to_fit();
}
 
} // namespace svec
 
#endif