SparseArray1.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_SparseArray1_h__)
#error This file is an implementation detail of the class SparseArray.
#endif

#include "../defs.h"

#include <vector>

BEGIN_NAMESPACE_ADS


template<typename T>
class SparseArray<1, T> : public ArrayContainer<T> {
  //
  // Private types.
  //

private:

  typedef ArrayTypes<T> Types;
  typedef ArrayContainer<T> Base;

  //
  // Public Types.
  //

public:

  typedef typename Types::value_type value_type;

  typedef typename Types::parameter_type parameter_type;

  typedef typename Types::unqualified_value_type unqualified_value_type;

  typedef typename Types::pointer pointer;
  typedef typename Types::const_pointer const_pointer;

  typedef typename Types::iterator iterator;
  typedef typename Types::const_iterator const_iterator;

  typedef typename Types::reference reference;
  typedef typename Types::const_reference const_reference;


  typedef typename Types::size_type size_type;
  typedef typename Types::difference_type difference_type;


  typedef Array<1,int>::const_iterator IndexConstIterator;

  //
  // Data.
  //

protected:

  Array<1,int> _indices;
  value_type _null;

  //
  // Using
  //

public:

  // Accessors.
  using Base::size;
  using Base::empty;
  using Base::max_size;
  using Base::begin;
  using Base::end;
  using Base::data;
  using Base::operator[];

  // Manipulators.
  //using Base::begin;
  //using Base::end;
  //using Base::data;
  using Base::negate;

  // File I/O.
  using Base::write_elements_ascii;
  using Base::write_elements_binary;
  using Base::read_elements_ascii;
  using Base::read_elements_binary;

public:

  //--------------------------------------------------------------------------
  // @{

  SparseArray() :
    Base(),
    _indices(),
    _null()
  {}


  template<typename IndexForwardIter, typename ValueForwardIter>
  SparseArray(IndexForwardIter indicesBeginning, IndexForwardIter indicesEnd,
              ValueForwardIter valuesBeginning, ValueForwardIter valuesEnd,
              parameter_type nullValue = value_type());

  template<typename IndexForwardIter, typename ValueForwardIter>
  void
  rebuild(IndexForwardIter indicesBeginning, IndexForwardIter indicesEnd,
          ValueForwardIter valuesBeginning, ValueForwardIter valuesEnd,
          parameter_type nullValue);

  template<typename IndexForwardIter, typename ValueForwardIter>
  void
  rebuild(IndexForwardIter indicesBeginning, IndexForwardIter indicesEnd,
          ValueForwardIter valuesBeginning, ValueForwardIter valuesEnd) {
    rebuild(indicesBeginning, indicesEnd, valuesBeginning, valuesEnd, 
            getNull());
  }

  template<typename T2, bool A>
  SparseArray(const Array<1,T2,A>& array, parameter_type nullValue);


  explicit
  SparseArray(const size_type size) :
    Base(size),
    _indices(size),
    _null()
  {}


  void
  rebuild(const size_type size) {
    Base::rebuild(size);
    _indices.rebuild(size);
  }

  SparseArray(const SparseArray& other) :
    Base(other),
    _indices(other._indices),
    _null(other._null)
  {}

  ~SparseArray()
  {}

  // @}
  //--------------------------------------------------------------------------
  // @{

  SparseArray& 
  operator=(const SparseArray& other) {
    if (&other != this) {
      Base::operator=(other);
      _indices = other._indices;
      _null = other._null;
    }
    return *this;
  }

  template<typename T2, bool A>
  SparseArray& 
  operator=(const Array<1,T2,A>& array);

  // @}
  //--------------------------------------------------------------------------
  // @{

  static
  int
  getRank() {
    return 1;
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  size_type 
  getMemoryUsage() const {
    return Base::getMemoryUsage() + _indices.getMemoryUsage();
  }

  parameter_type
  getNull() const {
    return _null;
  }

  bool
  isNull(const int i) const;

  bool
  isNonNull(const int i) const {
    return ! isNull(i);
  }

  parameter_type
  operator()(const int i) const;

  bool
  operator==(const SparseArray& x) const {
    return (Base::operator==(x) && _indices == x._indices && _null == x._null);
  }

  bool
  operator!=(const SparseArray& x) const {
    return ! operator==(x);
  }

  template<typename T2, bool A>
  void
  fill(ads::Array<1,T2,A>* array) const;

  template<typename T2, bool A>
  void
  fillNonNull(ads::Array<1,T2,A>* array) const;

  const Array<1,int>&
  getIndices() const {
    return _indices;
  }

  int
  getIndex(const int n) const {
    return _indices[n];
  }

  IndexConstIterator
  getIndicesBeginning() const {
    return _indices.begin();
  }

  IndexConstIterator
  getIndicesEnd() const {
    return _indices.end();
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  swap(SparseArray& other) {
    Base::swap(other);
    _indices.swap(other._indices);
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  SparseArray& 
  operator=(parameter_type x) {
    Base::operator=(x);
    return *this;
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  put(std::ostream& out) const;

  void
  get(std::istream& in);

  // @}
};


//-----------------------------------------------------------------------------


template<typename T>
int
countNonNullElementsInUnion(const SparseArray<1, T>& a, 
                            const SparseArray<1, T>& b);


template<typename T>
void
computeSum(const SparseArray<1, T>& x, const SparseArray<1, T>& y, 
           SparseArray<1, T>* result);


template<typename T>
void
computeDifference(const SparseArray<1, T>& x, const SparseArray<1, T>& y, 
                  SparseArray<1, T>* result);


template<typename T>
void
computeProduct(const SparseArray<1, T>& x, const SparseArray<1, T>& y, 
               SparseArray<1, T>* result);



template<typename T, typename BinaryFunction>
void
computeBinaryOperation(const SparseArray<1, T>& x, const SparseArray<1, T>& y, 
                       SparseArray<1, T>* result, 
                       const BinaryFunction& function);


//---------------------------------------------------------------------------
// Operations with arrays and sparse arrays.
//---------------------------------------------------------------------------

template<typename T1, bool A, typename T2>
Array<1,T1,A>& 
operator+=(Array<1,T1,A>& x, const SparseArray<1,T2> & y);

template<typename T1, bool A, typename T2>
Array<1,T1,A>& 
operator-=(Array<1,T1,A>& x, const SparseArray<1,T2> & y);

template<typename T1, bool A, typename T2>
Array<1,T1,A>& 
operator*=(Array<1,T1,A>& x, const SparseArray<1,T2> & y);

template<typename T1, bool A, typename T2>
Array<1,T1,A>& 
operator/=(Array<1,T1,A>& x, const SparseArray<1,T2> & y);

template<typename T1, bool A, typename T2>
Array<1,T1,A>& 
operator%=(Array<1,T1,A>& x, const SparseArray<1,T2> & y);

template<typename T1, bool A, typename T2, typename T3>
void
scaleAdd(Array<1,T1,A>* x, const T2 a, const SparseArray<1,T3> & y);



//---------------------------------------------------------------------------
// Operations with FixedArray's and sparse arrays.
//---------------------------------------------------------------------------

template<int _N, typename _T1, typename _T2>
FixedArray<_N, _T1>& 
operator+=(FixedArray<_N, _T1>& x, const SparseArray<1, _T2>& y);

template<int _N, typename _T1, typename _T2>
FixedArray<_N, _T1>& 
operator-=(FixedArray<_N, _T1>& x, const SparseArray<1, _T2>& y);

template<int _N, typename _T1, typename _T2>
FixedArray<_N, _T1>& 
operator*=(FixedArray<_N, _T1>& x, const SparseArray<1, _T2>& y);

template<int _N, typename _T1, typename _T2>
FixedArray<_N, _T1>& 
operator/=(FixedArray<_N, _T1>& x, const SparseArray<1, _T2>& y);

template<int _N, typename _T1, typename _T2>
FixedArray<_N, _T1>& 
operator%=(FixedArray<_N, _T1>& x, const SparseArray<1, _T2>& y);

template<int _N, typename _T1, typename _T2, typename _T3>
void
scaleAdd(FixedArray<_N, _T1>* x, const _T2 a, const SparseArray<1, _T3>& y);


END_NAMESPACE_ADS

#define __ads_SparseArray1_ipp__
#include "SparseArray1.ipp"
#undef __ads_SparseArray1_ipp__

---