An SparseVector class – a sparse vector object. More...

#include <SparseVector.h>

Public Member Functions
	SparseVector (const std::size_t &max)
	Constructor for a non-filled vector, to be filled by the user. More...

	SparseVector (const SparseVector &source)
	Copy constructor. More...

SparseVector &	operator= (const SparseVector &source)
	Assignment operator. More...

iter	begin ()
	Not a full iterator implementation – just a pass through to the storage container. More...

citer	begin () const
	Not a full iterator implementation – just a pass through to the storage container. More...

iter	end ()
	Not a full iterator implementation – just a pass through to the storage container. More...

citer	end () const
	Not a full iterator implementation – just a pass through to the storage container. More...

void	resize (const std::size_t &length)
	Resize the maximum length of the sparse vector. More...

void	clear ()
	Remove all elements from the sparse vector. More...

void	erase (const iter &pos)
	Erase an element from the vector. More...

void	erase (const std::size_t &index)
	Erase an element from th vector. More...

void	swap (const std::size_t &i, const std::size_t &j)
	Swap elements i and j. More...

void	swap (SparseVector< _Type > &X)
	Swap ALL elements with those of another SparseVector. More...

std::size_t	size () const
	Find the (max) size of the vector. More...

std::size_t	nelts () const
	Find the number of non-zero elements in the vector. More...

_Type &	set (const std::size_t &i)
	Set an element of the vector. More...

const _Type &	get (const std::size_t &i) const
	Get an element of the vector. More...

const _Type &	operator[] (const std::size_t &i) const
	Equivalent to the 'get' method. More...

_Type &	operator[] (const std::size_t &i)
	Equivalent to the 'set' method. More...

SparseVector< _Type >	operator+ (const SparseVector< _Type > &X) const
	Operator overloading for sparse vector addition. More...

SparseVector< _Type >	operator+ () const
	Overloading for +. More...

SparseVector< _Type >	operator- (const SparseVector< _Type > &X) const
	Operator overloading for sparse vector subtraction. More...

SparseVector< _Type >	operator- () const
	Overloading for -. More...

SparseVector< _Type >	operator* (const _Type &m) const
	Overloading multiplication for a scalar. More...

SparseVector< _Type > &	operator*= (const _Type &m)
	Overloading *= for scalar multiplication. More...

SparseVector< _Type > &	operator-= (const SparseVector< _Type > &X)
	Overloading -= for sparse vectors. More...

SparseVector< _Type > &	operator+= (const SparseVector< _Type > &X)
	Overloading += for sparse vectors. More...

citer	find (std::size_t i) const
	Look for an element index. More...

const _Type	dot (const SparseVector< _Type > &x) const
	A dot product. More...

double	one_norm () const
	l1-norm. More...

double	two_norm () const
	l2-norm. More...

double	inf_norm () const
	Infinity norm. More...

void	scale (const _Type &scale)
	Scale each element of the vector. More...

void	add (const SparseVector< _Type > &X)
	Add a vector, element wise. More...

void	sub (const SparseVector< _Type > &X)
	Subtract a vector, element wise. More...

std::size_t	nearest_index (const _Type &value) const
	Find the index of the element NEAREST in value to that specified. More...

std::size_t	maxabs_index () const
	Find the index of the maximum element in the vector. More...

std::size_t	minabs_index () const
	Find the index of the maximum element in the vector. More...

void	dump () const
	Output the sparse vector's contents. More...

Detailed Description

template<typename _Type>
class CppNoddy::SparseVector< _Type >

An SparseVector class – a sparse vector object.

This is templated but intended ONLY for double or std::complex<double>.

Definition at line 20 of file SparseVector.h.

Constructor & Destructor Documentation

◆ SparseVector() [1/2]

template<typename _Type >

CppNoddy::SparseVector< _Type >::SparseVector ( const std::size_t & max )

explicit

Constructor for a non-filled vector, to be filled by the user.

Parameters

max	A maximum size for the sparse vector, used in geometry checking.

Definition at line 18 of file SparseVector.cpp.

18 : ZERO(0.0), MAX_SIZE(max)

19 {}

◆ SparseVector() [2/2]

template<typename _Type >

CppNoddy::SparseVector< _Type >::SparseVector ( const SparseVector< _Type > & source )

Copy constructor.

Parameters

source The source object to be copied

Definition at line 22 of file SparseVector.cpp.

                                                                     {
    *this = source;
  }

Member Function Documentation

◆ add()

template<typename _Type >

void CppNoddy::SparseVector< _Type >::add ( const SparseVector< _Type > & X )

Add a vector, element wise.

Parameters

X	The vector to be added to this object.

Definition at line 249 of file SparseVector.cpp.

                                 {
    *this += X;
  }

◆ begin() [1/2]

template<typename _Type >

std::map< std::size_t, _Type >::iterator CppNoddy::SparseVector< _Type >::begin

inline

Not a full iterator implementation – just a pass through to the storage container.

Return an iterator pointing to the beginning of the encpsulated STL map storage

Definition at line 240 of file SparseVector.h.

                                                                                {
    return MAP_VEC.begin();
  }

◆ begin() [2/2]

template<typename _Type >

std::map< std::size_t, _Type >::const_iterator CppNoddy::SparseVector< _Type >::begin

inline

Not a full iterator implementation – just a pass through to the storage container.

Return a constant iterator pointing to the beginning of the encapsulated STL map storage

Definition at line 245 of file SparseVector.h.

                                                                                            {
    return MAP_VEC.begin();
  }

◆ clear()

template<typename _Type >

void CppNoddy::SparseVector< _Type >::clear

Remove all elements from the sparse vector.

Definition at line 181 of file SparseVector.cpp.

                                  {
    MAP_VEC.clear();
  }

◆ dot()

template<typename _Type >

const _Type CppNoddy::SparseVector< _Type >::dot ( const SparseVector< _Type > & x ) const

A dot product.

Parameters

x	The vector to be "dotted" with.

Todo:

Using a 'get' (aka find) here is slooow

obviously this can be improved.

Definition at line 186 of file SparseVector.cpp.

                                                                         {
#ifdef PARANOID
    if(X.size() != size()) {
      std::string problem;
      problem = " The SparseVector.dot method is trying to use \n";
      problem += " two vectors of unequal length \n";
      throw ExceptionGeom(problem, size(), X.size());
    }
#endif
    SparseVector<_Type> temp(X);
    _Type sum(0.0);
    for(iter pos = temp.MAP_VEC.begin(); pos != temp.MAP_VEC.end(); ++pos) {
      std::size_t index = pos -> first;
      /// \todo Using a 'get' (aka find) here is slooow
      /// - obviously this can be improved.
      // the get method returns 0.0 if not stored
      temp[ index ] *= get(index);
    }
    return sum;
  }

References CppNoddy::SparseVector< _Type >::size().

◆ dump()

template<typename _Type >

void CppNoddy::SparseVector< _Type >::dump

Output the sparse vector's contents.

Definition at line 317 of file SparseVector.cpp.

                                       {
    std::cout.precision(6);
    if(MAP_VEC.begin() == MAP_VEC.end()) {
      std::cout << "[ Empty vector ]\n";
    } else {
      for(citer pos = MAP_VEC.begin(); pos != MAP_VEC.end(); ++pos) {
        std::cout << "[ " << pos -> first << " ]" << " = " << pos -> second << " ";
      }
      std::cout << "\n";
    }
  }

◆ end() [1/2]

template<typename _Type >

std::map< std::size_t, _Type >::iterator CppNoddy::SparseVector< _Type >::end

inline

Not a full iterator implementation – just a pass through to the storage container.

Return an iterator pointing to the end of the encapsulated STL map storage

Definition at line 250 of file SparseVector.h.

                                                                              {
    return MAP_VEC.end();
  }

◆ end() [2/2]

template<typename _Type >

std::map< std::size_t, _Type >::const_iterator CppNoddy::SparseVector< _Type >::end

inline

Not a full iterator implementation – just a pass through to the storage container.

Return a constant iterator pointing to the end of the encapsulated STL map storage

Definition at line 255 of file SparseVector.h.

                                                                                          {
    return MAP_VEC.end();
  }

◆ erase() [1/2]

template<typename _Type >

void CppNoddy::SparseVector< _Type >::erase ( const iter & pos )

inline

Erase an element from the vector.

Parameters

pos	An std::map< std::size_t, _Type >::iterator to the map element

Definition at line 333 of file SparseVector.h.

                                                        {
    MAP_VEC.erase(pos);
  }

◆ erase() [2/2]

template<typename _Type >

void CppNoddy::SparseVector< _Type >::erase ( const std::size_t & index )

inline

Erase an element from th vector.

Parameters

index The index of the element to be erased

Definition at line 328 of file SparseVector.h.

                                                               {
    MAP_VEC.erase(index);
  }

◆ find()

template<typename _Type >

citer CppNoddy::SparseVector< _Type >::find ( std::size_t i ) const

inline

Look for an element index.

Parameters

i	The index of the element to search for

Definition at line 151 of file SparseVector.h.

                                  {
      citer pos;
      pos = MAP_VEC.find(i);
      return pos;
    }

◆ get()

template<typename _Type >

const _Type & CppNoddy::SparseVector< _Type >::get ( const std::size_t & i ) const

inline

Get an element of the vector.

Parameters

i	The index to be accessed

Returns: The contents of the element, including a zero if the element has not been set

Definition at line 299 of file SparseVector.h.

                                                                       {
#ifdef PARANOID
    if(i >= size()) {
      std::string problem;
      problem = " The SparseVector.get method is trying to access \n";
      problem += " outside the container. \n";
      throw ExceptionRange(problem, size(), i);
    }
#endif
    citer pos;
    pos = MAP_VEC.find(i);
    if(pos != MAP_VEC.end()) {
      return pos -> second;
    } else {
      return ZERO;
    }
  }

◆ inf_norm()

template<typename _Type >

double CppNoddy::SparseVector< _Type >::inf_norm

Infinity norm.

Returns: The maximum (abs) element in the vector.

Definition at line 230 of file SparseVector.cpp.

                                             {
    double max(0.0);
    // Return the maximum (abs) element in the vector
    for(citer pos = MAP_VEC.begin(); pos != MAP_VEC.end(); ++pos) {
      if(std::abs(pos -> second) > max) {
        max = std::abs(pos -> second);
      }
    }
    return max;
  }

◆ maxabs_index()

template<typename _Type >

std::size_t CppNoddy::SparseVector< _Type >::maxabs_index

Find the index of the maximum element in the vector.

Returns: The index of the maximum element.

Definition at line 275 of file SparseVector.cpp.

                                                    {
    citer location(MAP_VEC.begin());
    double max(std::abs(location -> second));
    citer start(++location);
    for(citer pos = start; pos != MAP_VEC.end(); ++pos) {
      if(std::abs(pos -> second) > max) {
        max = std::abs(pos -> second);
        location = pos;
      }
    }
    return location -> first;
  }

◆ minabs_index()

template<typename _Type >

std::size_t CppNoddy::SparseVector< _Type >::minabs_index

Find the index of the maximum element in the vector.

Returns: The index of the maximum element.

Definition at line 289 of file SparseVector.cpp.

                                                    {
    citer location(MAP_VEC.begin());
    double min(std::abs(location -> second));
    citer start(++location);
    for(citer pos = start; pos != MAP_VEC.end(); ++pos) {
      if(std::abs(pos -> second) < min) {
        min = std::abs(pos -> second);
        location = pos;
      }
    }
    return location -> first;
  }

◆ nearest_index()

template<typename _Type >

std::size_t CppNoddy::SparseVector< _Type >::nearest_index ( const _Type & value ) const

Find the index of the element NEAREST in value to that specified.

Parameters

value The value to search for.

Returns: The index of the element with value that minimises the difference.

Definition at line 260 of file SparseVector.cpp.

                                                                       {
    citer location(MAP_VEC.begin());
    _Type min_diff(location -> second - value);
    citer start(++location);
    for(citer pos = start; pos != MAP_VEC.end(); ++pos) {
      _Type diff(pos -> second - value);
      if(std::abs(diff) < std::abs(min_diff)) {
        min_diff = diff;
        location = pos;
      }
    }
    return location -> first;
  }

◆ nelts()

template<typename _Type >

std::size_t CppNoddy::SparseVector< _Type >::nelts

inline

Find the number of non-zero elements in the vector.

Definition at line 323 of file SparseVector.h.

                                                    {
    return MAP_VEC.size();
  }

◆ one_norm()

template<typename _Type >

double CppNoddy::SparseVector< _Type >::one_norm

l1-norm.

Returns: The square-root of the sum of the squares divided by number of elts.

Definition at line 208 of file SparseVector.cpp.

                                             {
    // Accumulate the ABS values of the container entries
    // using a fuction object.
    double sum(0.0);
    for(citer pos = MAP_VEC.begin(); pos != MAP_VEC.end(); ++pos) {
      sum += std::abs(pos -> second);
    }
    return sum;
  }

Referenced by main().

◆ operator*()

template<typename _Type >

SparseVector< _Type > CppNoddy::SparseVector< _Type >::operator* ( const _Type & m ) const

Overloading multiplication for a scalar.

Parameters

m	The scalar to multiply by

Returns: The scalar multiplication of the vector

Definition at line 168 of file SparseVector.cpp.

                                                                         {
    SparseVector<_Type> temp(*this);
    temp *= m;
    return temp;
  }

References m.

◆ operator*=()

template<typename _Type >

SparseVector< _Type > & CppNoddy::SparseVector< _Type >::operator*= ( const _Type & m )

Overloading *= for scalar multiplication.

Parameters

m	The scalar to multiply by

Definition at line 37 of file SparseVector.cpp.

                                                                     {
    for(iter pos = MAP_VEC.begin(); pos != MAP_VEC.end(); ++pos) {
      pos -> second *= m;
    }
    return *this;
  }

References m.

◆ operator+() [1/2]

template<typename _Type >

SparseVector< _Type > CppNoddy::SparseVector< _Type >::operator+

inline

Overloading for +.

Returns: +this

Definition at line 351 of file SparseVector.h.

                                                                  {
    return * this;
  }

◆ operator+() [2/2]

template<typename _Type >

SparseVector< _Type > CppNoddy::SparseVector< _Type >::operator+ ( const SparseVector< _Type > & X ) const

Operator overloading for sparse vector addition.

Parameters

X	A sparse vector to be added

Returns: The sum of this and the passed vector X

Definition at line 131 of file SparseVector.cpp.

                                                                                       {
#ifdef PARANOID
    if(X.size() != size()) {
      std::string problem;
      problem = " The SparseVector.operator+ method is trying to use \n";
      problem += " two vectors of unequal length \n";
      throw ExceptionGeom(problem, size(), X.size());
    }
#endif
    SparseVector<_Type> temp(*this);
    temp += X;
    return temp;
  }

References CppNoddy::SparseVector< _Type >::size().

◆ operator+=()

template<typename _Type >

SparseVector< _Type > & CppNoddy::SparseVector< _Type >::operator+= ( const SparseVector< _Type > & X )

Overloading += for sparse vectors.

Parameters

X	The sparse vector to be added

Returns: Adds X to the 'this' vector

Definition at line 88 of file SparseVector.cpp.

                                                                                   {
#ifdef PARANOID
    if(X.size() != size()) {
      std::string problem;
      problem = " The SparseVector.operator+= method is trying to use \n";
      problem += " two vectors of unequal length \n";
      throw ExceptionGeom(problem, size(), X.size());
    }
#endif
    citer pos_ro = X.MAP_VEC.begin();
    iter pos_rw = MAP_VEC.begin();
    do {
      std::size_t index_rw = pos_rw -> first;
      std::size_t index_ro = pos_ro -> first;
      if(index_rw == index_ro) {
        // element in both vectors
        pos_rw -> second += pos_ro -> second;
        ++pos_rw;
        ++pos_ro;
      }
      if(index_rw > index_ro) {
        // element is in X but not 'this'
        set
        (index_ro) = pos_ro -> second;
        ++pos_ro;
      }
      if(index_rw < index_ro) {
        // element is in 'this' but not X
        ++pos_rw;
      }
    } while(pos_ro != X.MAP_VEC.end() && pos_rw != MAP_VEC.end());
    if(pos_ro != X.MAP_VEC.end()) {
      // need to finish the X data
      do {
        set
        (pos_ro -> first) = pos_ro -> second;
        ++pos_ro;
      } while(pos_ro != X.MAP_VEC.end());
    }
    return *this;
  }

References CppNoddy::SparseVector< _Type >::size().

◆ operator-() [1/2]

template<typename _Type >

SparseVector< _Type > CppNoddy::SparseVector< _Type >::operator-

Overloading for -.

Returns: The negative of the vector

Definition at line 161 of file SparseVector.cpp.

                                                           {
    SparseVector<_Type> temp(*this);
    temp *= -1.0;
    return temp;
  }

◆ operator-() [2/2]

template<typename _Type >

SparseVector< _Type > CppNoddy::SparseVector< _Type >::operator- ( const SparseVector< _Type > & X ) const

Operator overloading for sparse vector subtraction.

Parameters

X	A sparse vector to be subtracted

Returns: The subtraction of this and the passed vector X

Definition at line 146 of file SparseVector.cpp.

                                                                                       {
#ifdef PARANOID
    if(X.size() != size()) {
      std::string problem;
      problem = " The SparseVector.operator- method is trying to use \n";
      problem += " two vectors of unequal length \n";
      throw ExceptionGeom(problem, size(), X.size());
    }
#endif
    SparseVector<_Type> temp(*this);
    temp -= X;
    return temp;
  }

References CppNoddy::SparseVector< _Type >::size().

◆ operator-=()

template<typename _Type >

SparseVector< _Type > & CppNoddy::SparseVector< _Type >::operator-= ( const SparseVector< _Type > & X )

Overloading -= for sparse vectors.

Parameters

X	The sparse vector to be subtracted

Returns: Subtracts X from the 'this' vector

Definition at line 45 of file SparseVector.cpp.

                                                                                   {
#ifdef PARANOID
    if(X.size() != size()) {
      std::string problem;
      problem = " The SparseVector.operator-= method is trying to use \n";
      problem += " two vectors of unequal length \n";
      throw ExceptionGeom(problem, size(), X.size());
    }
#endif
    citer pos_ro = X.MAP_VEC.begin();
    iter pos_rw = MAP_VEC.begin();
    do {
      std::size_t index_rw = pos_rw -> first;
      std::size_t index_ro = pos_ro -> first;
      if(index_rw == index_ro) {
        // element in both vectors
        pos_rw -> second -= pos_ro -> second;
        ++pos_rw;
        ++pos_ro;
      }
      if(index_rw > index_ro) {
        // element is in X but not 'this'
        set
        (index_ro) = -(pos_ro -> second);
        ++pos_ro;
      }
      if(index_rw < index_ro) {
        // element is in 'this' but not X
        ++pos_rw;
      }
    } while(pos_ro != X.MAP_VEC.end() && pos_rw != MAP_VEC.end());
    if(pos_ro != X.MAP_VEC.end()) {
      // need to finish the X data
      do {
        set
        (pos_ro -> first) = -(pos_ro -> second);
        ++pos_ro;
      } while(pos_ro != X.MAP_VEC.end());
    }
    return *this;
  }

References CppNoddy::SparseVector< _Type >::size().

◆ operator=()

template<typename _Type >

SparseVector< _Type > & CppNoddy::SparseVector< _Type >::operator= ( const SparseVector< _Type > & source )

Assignment operator.

Parameters

source The source object for the assignment

Returns: The newly assigned object

Definition at line 27 of file SparseVector.cpp.

                                                                                       {
    if(this == &source)
      return * this;
    MAP_VEC = source.MAP_VEC;
    ZERO = source.ZERO;
    MAX_SIZE = source.MAX_SIZE;
    return *this;
  }

◆ operator[]() [1/2]

template<typename _Type >

_Type & CppNoddy::SparseVector< _Type >::operator[] ( const std::size_t & i )

inline

Equivalent to the 'set' method.

Definition at line 260 of file SparseVector.h.

                                                                  {
#ifdef PARANOID
    if(i >= size()) {
      std::string problem;
      problem = " The SparseVector.operator[] method is trying to access \n";
      problem += " outside the container. \n";
      throw ExceptionRange(problem, size(), i);
    }
#endif
    return MAP_VEC[ i ];
  }

◆ operator[]() [2/2]

template<typename _Type >

const _Type & CppNoddy::SparseVector< _Type >::operator[] ( const std::size_t & i ) const

inline

Equivalent to the 'get' method.

Definition at line 273 of file SparseVector.h.

                                                                              {
#ifdef PARANOID
    if(i >= size()) {
      std::string problem;
      problem = " The SparseVector.operator[] method is trying to access \n";
      problem += " outside the container. \n";
      throw ExceptionRange(problem, size(), i);
    }
#endif
    return get(i);
  }

◆ resize()

template<typename _Type >

void CppNoddy::SparseVector< _Type >::resize ( const std::size_t & length )

Resize the maximum length of the sparse vector.

The maximum length is used in geometry checking.

Parameters

length The new maximum length of the vector

Definition at line 176 of file SparseVector.cpp.

                                                          {
    MAX_SIZE = length;
  }

◆ scale()

template<typename _Type >

void CppNoddy::SparseVector< _Type >::scale ( const _Type & scale )

Scale each element of the vector.

Parameters

scale The value to scale each element by.

Definition at line 242 of file SparseVector.cpp.

                                                    {
    for(iter pos = MAP_VEC.begin(); pos != MAP_VEC.end(); ++pos) {
      pos -> second *= scale;
    }
  }

◆ set()

template<typename _Type >

_Type & CppNoddy::SparseVector< _Type >::set ( const std::size_t & i )

inline

Set an element of the vector.

Parameters

i	The index to be accessed

Returns: A reference to the element

Definition at line 286 of file SparseVector.h.

                                                           {
#ifdef PARANOID
    if(i >= size()) {
      std::string problem;
      problem = " The SparseVector.set method is trying to access \n";
      problem += " outside the container. \n";
      throw ExceptionRange(problem, size(), i);
    }
#endif
    return MAP_VEC[ i ];
  }

◆ size()

template<typename _Type >

std::size_t CppNoddy::SparseVector< _Type >::size

inline

Find the (max) size of the vector.

Definition at line 318 of file SparseVector.h.

                                                   {
    return MAX_SIZE;
  }

Referenced by CppNoddy::SparseVector< _Type >::dot(), CppNoddy::SparseVector< _Type >::operator+(), CppNoddy::SparseVector< _Type >::operator+=(), CppNoddy::SparseVector< _Type >::operator-(), CppNoddy::SparseVector< _Type >::operator-=(), and CppNoddy::SparseVector< _Type >::swap().

◆ sub()

template<typename _Type >

void CppNoddy::SparseVector< _Type >::sub ( const SparseVector< _Type > & X )

Subtract a vector, element wise.

Parameters

X	The vector to be subtracted from this object.

Definition at line 255 of file SparseVector.cpp.

                                                            {
    *this -= X;
  }

◆ swap() [1/2]

template<typename _Type >

void CppNoddy::SparseVector< _Type >::swap	(	const std::size_t &	i,
		const std::size_t &	j
	)

Swap elements i and j.

Parameters

i	The index of the element to swap.
j	The index of the other element to swap.

Definition at line 303 of file SparseVector.cpp.

                                                     {
#ifdef PARANOID
    if(i >= size() || j >= size()) {
      std::string problem;
      problem = " The SparseVector.swap method is trying to access \n";
      problem += " outside the container. \n";
      throw ExceptionRange(problem, size(), std::max(i, j));
    }
#endif
    std::swap<_Type>(MAP_VEC[ i ], MAP_VEC[ j ]);
  }

◆ swap() [2/2]

template<typename _Type >

void CppNoddy::SparseVector< _Type >::swap ( SparseVector< _Type > & X )

inline

Swap ALL elements with those of another SparseVector.

Parameters

X	The sparse vector to exchange with

Definition at line 338 of file SparseVector.h.

                                                              {
#ifdef PARANOID
    if(X.size() != size()) {
      std::string problem;
      problem = " The SparseVector.swap method is trying to use \n";
      problem += " two vectors of unequal length \n";
      throw ExceptionGeom(problem, size(), X.size());
    }
#endif
    MAP_VEC.swap(X.MAP_VEC);
  }

References CppNoddy::SparseVector< _Type >::size().

◆ two_norm()

template<typename _Type >

double CppNoddy::SparseVector< _Type >::two_norm

l2-norm.

No attention paid to possible overflow for large vectors.

Returns: The square-root of the sum of the squares divided by number of elts.

Definition at line 219 of file SparseVector.cpp.

                                             {
    // Accumulate the ABS values of the container entries SQUARED
    // using a fuction object.
    double sum(0.0);
    for(citer pos = MAP_VEC.begin(); pos != MAP_VEC.end(); ++pos) {
      sum += std::pow(std::abs(pos -> second), 2);
    }
    return sum;
  }

The documentation for this class was generated from the following files:

include/SparseVector.h
src/SparseVector.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ SparseVector() [1/2]

◆ SparseVector() [2/2]

Member Function Documentation

◆ add()

◆ begin() [1/2]

◆ begin() [2/2]

◆ clear()

◆ dot()

◆ dump()

◆ end() [1/2]

◆ end() [2/2]

◆ erase() [1/2]

◆ erase() [2/2]

◆ find()

◆ get()

◆ inf_norm()

◆ maxabs_index()

◆ minabs_index()

◆ nearest_index()

◆ nelts()

◆ one_norm()

◆ operator*()

◆ operator*=()

◆ operator+() [1/2]

◆ operator+() [2/2]

◆ operator+=()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator-=()

◆ operator=()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ resize()

◆ scale()

◆ set()

◆ size()

◆ sub()

◆ swap() [1/2]

◆ swap() [2/2]

◆ two_norm()