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/utility/detail/LIBPUBLIC.h>
#include <myramath/utility/Number.h>

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

namespace myra {

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

template<class Number> class LIBPUBLIC SparseMatrixBuilder
  {
  public:
  
    // Useful typedefs.
    typedef std::map<int,Number> Column;
    typedef std::vector<Column> Columns;
    typedef typename Column::const_iterator 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(int j) const;
    Iterator end(int j) const;

    // ------------------------------------ Manipulating numeric contents.

    const Number& operator () (int i, int j) const;
    
    Number& operator () (int i, int j);

    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);

    // ------------------------------------ Symbolic queries.

    bool test(int i, int j) const;

    PatternBuilder pattern() const;

    std::vector<int> pattern(int j) const;

    std::pair<int,int> size() const;

    int n_nonzeros(int j) const;
    int n_nonzeros() const;

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

    static SparseMatrixBuilder<Number> identity(int IJ);

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

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

    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;

    // Numeric contents.
    Columns columns;
  };

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

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

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

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

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

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

} // namespace

#endif