SparseMatrixBuilder.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_SPARSE_SPARSEMATRIXBUILDER_H
#define MYRAMATH_SPARSE_SPARSEMATRIXBUILDER_H

#include <myramath/MYRAMATH_EXPORT.h>
#include <myramath/utility/Number.h>

#include <vector>
#include <map>
#include <iosfwd>

namespace myra {

// Forward declarations.
class Pattern;
class PatternRange;
class InputStream;
class OutputStream;
template<class Number> class SparseMatrix;
template<class Number> class CSparseMatrixRange;
template<class Number> class Matrix;

template<class Number> class MYRAMATH_EXPORT SparseMatrixTriplet
  {
  public:

    // Data members, all public.
    int i;
    int j;
    Number value;

    // Constructs from (i,j,value) arguments.
    SparseMatrixTriplet(int ii, int jj, Number vv)
      : i(ii), j(jj), value(vv) { }

    // Constructs from (i,j) and zero-initializes value.
    SparseMatrixTriplet(int ii, int jj)
      : i(ii), j(jj), value(0) { }
    
    // Default constructs, i = j = value = 0.
    SparseMatrixTriplet()
      : i(0), j(0), value(0) { }
    
  };

template<class Number> class MYRAMATH_EXPORT SparseMatrixBuilder
  {
  public:
  
    // Useful typedefs.
    typedef SparseMatrixTriplet<Number> Triplet;
    typedef std::vector<Triplet> Triplets;
    typedef const Triplet* Iterator;

    // ------------------------------------ Construction, serialization, value semantics.

    SparseMatrixBuilder();

    explicit SparseMatrixBuilder(int in_I, int in_J);
    explicit SparseMatrixBuilder(std::pair<int,int> in_IJ);
    
    SparseMatrixBuilder(const SparseMatrixBuilder& that);

    void swap(SparseMatrixBuilder& that);

#ifdef MYRAMATH_ENABLE_CPP11
    SparseMatrixBuilder(SparseMatrixBuilder&& that);
#endif

    SparseMatrixBuilder& operator = (SparseMatrixBuilder that);

    SparseMatrixBuilder& operator = (const CSparseMatrixRange<Number>& that);

    explicit SparseMatrixBuilder(const CSparseMatrixRange<Number>& that);
    
    explicit SparseMatrixBuilder(InputStream& in);

    void write(OutputStream& out) const;

   ~SparseMatrixBuilder();

    // ------------------------------------ Iterators.
    
    Iterator begin() const;
    Iterator end() const;
    
    std::pair<int,int> size() const;

    // ------------------------------------ Manipulating numeric contents.
    
    Number& operator () (int i, int j);

    // Erases a single structural nonzero. Note this is *exceedingly* slow, linear complexity.
    void erase(int i, int j);

    void operator += (const SparseMatrixBuilder& that);
    void operator += (const CSparseMatrixRange<Number>& that);

    void operator -= (const SparseMatrixBuilder& that);
    void operator -= (const CSparseMatrixRange<Number>& that);

    void operator *= (Number alpha);

    void operator /= (Number alpha);

    // ------------------------------------ Static generators.

    static SparseMatrixBuilder<Number> identity(int IJ);

    static SparseMatrixBuilder<Number> random(int I, int J, int N);

    static SparseMatrixBuilder<Number> random(const PatternRange& P);

    Pattern make_Pattern() const;

    SparseMatrix<Number> make_SparseMatrix() const;

    Matrix<Number> make_Matrix() const;

  private:

    // Throws if IJ is not the same size as *this.
    void check_size(const std::pair<int,int>& IJ) const;
  
    // Holds size.
    int I;
    int J;

    // Internal contents.
    Triplets triplets;
    
    // Compresses triplets into CSC-compatible order.
    void compress();
    
  };

template<class Number> class ReflectNumber< SparseMatrixTriplet<Number> >
  { public: typedef Number type; };

template<class Number> class ReflectNumber< SparseMatrixBuilder<Number> >
  { public: typedef Number type; };

MYRAMATH_EXPORT SparseMatrixBuilder<NumberS> operator + (const SparseMatrixBuilder<NumberS>& A, const SparseMatrixBuilder<NumberS>& B);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberD> operator + (const SparseMatrixBuilder<NumberD>& A, const SparseMatrixBuilder<NumberD>& B);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberC> operator + (const SparseMatrixBuilder<NumberC>& A, const SparseMatrixBuilder<NumberC>& B);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberZ> operator + (const SparseMatrixBuilder<NumberZ>& A, const SparseMatrixBuilder<NumberZ>& B);

MYRAMATH_EXPORT SparseMatrixBuilder<NumberS> operator - (const SparseMatrixBuilder<NumberS>& A, const SparseMatrixBuilder<NumberS>& B);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberD> operator - (const SparseMatrixBuilder<NumberD>& A, const SparseMatrixBuilder<NumberD>& B);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberC> operator - (const SparseMatrixBuilder<NumberC>& A, const SparseMatrixBuilder<NumberC>& B);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberZ> operator - (const SparseMatrixBuilder<NumberZ>& A, const SparseMatrixBuilder<NumberZ>& B);

MYRAMATH_EXPORT SparseMatrixBuilder<NumberS> operator * (const SparseMatrixBuilder<NumberS>& A, NumberS alpha);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberD> operator * (const SparseMatrixBuilder<NumberD>& A, NumberD alpha);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberC> operator * (const SparseMatrixBuilder<NumberC>& A, NumberC alpha);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberZ> operator * (const SparseMatrixBuilder<NumberZ>& A, NumberZ alpha);

MYRAMATH_EXPORT SparseMatrixBuilder<NumberS> operator * (NumberS alpha, const SparseMatrixBuilder<NumberS>& A);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberD> operator * (NumberD alpha, const SparseMatrixBuilder<NumberD>& A);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberC> operator * (NumberC alpha, const SparseMatrixBuilder<NumberC>& A);
MYRAMATH_EXPORT SparseMatrixBuilder<NumberZ> operator * (NumberZ alpha, const SparseMatrixBuilder<NumberZ>& A);

MYRAMATH_EXPORT std::ostream& operator << (std::ostream& out, const SparseMatrixBuilder<NumberS>& A);
MYRAMATH_EXPORT std::ostream& operator << (std::ostream& out, const SparseMatrixBuilder<NumberD>& A);
MYRAMATH_EXPORT std::ostream& operator << (std::ostream& out, const SparseMatrixBuilder<NumberC>& A);
MYRAMATH_EXPORT std::ostream& operator << (std::ostream& out, const SparseMatrixBuilder<NumberZ>& A);

} // namespace

#endif