PatternBuilder.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_PATTERNBUILDER_H
#define MYRAMATH_SPARSE_PATTERNBUILDER_H

#include <myramath/utility/detail/LIBPUBLIC.h>

#include <vector>
#include <set>
#include <unordered_set>
#include <iosfwd>

namespace myra {

// Forward declarations.
class InputStream;
class OutputStream;
class intCRange;
class Pattern;
class PatternRange;

class LIBPUBLIC PatternBuilder
  {

  public:

    typedef std::set<int> Column;
    typedef std::vector<Column> Columns;
    typedef Column::const_iterator Iterator;

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

    PatternBuilder();

    explicit PatternBuilder (std::pair<int,int> IJ);
    explicit PatternBuilder (int in_I, int in_J);

    PatternBuilder(const PatternBuilder& that);

    void swap(PatternBuilder& that);

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

    PatternBuilder& operator = (PatternBuilder that);

    PatternBuilder& operator = (const PatternRange& that);

    explicit PatternBuilder(const PatternRange& that);

    explicit PatternBuilder(InputStream& in);

    void write(OutputStream& out) const;

    // ------------------------------------ Manipulating symbolic contents.

    void insert(int i, int j);

    // Prefer insert_column() over this, due to internal column-based layout.
    void insert_row(int i, const intCRange& j_pattern);
    
    // Prefer this over insert_row(), due to internal column-based layout.
    void insert_column(const intCRange& i_pattern, int j);

    void insert_tensor(const intCRange& i_pattern, const intCRange& j_pattern);

    void insert_tensor(const intCRange& ij_pattern);

    void insert(const PatternBuilder& that, int i_offset = 0, int j_offset = 0);    
    void insert(const PatternRange& that, int i_offset = 0, int j_offset = 0);

    void erase(int i, int j);

    void erase(const PatternBuilder& that, int i_offset = 0, int j_offset = 0);    
    void erase(const PatternRange& that, int i_offset = 0, int j_offset = 0);

    // ------------------------------------ Iterators.

    Iterator begin(int j) const;
    Iterator end  (int j) const;

    // ------------------------------------ Querying symbolic contents.

    bool test(int i, int j) const;
    
    std::vector<int> pattern(int j) const;

    const Column& column(int j) const;

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

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

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

    static PatternBuilder identity(int IJ);

    static PatternBuilder random(std::pair<int,int> IJ, int N);
    static PatternBuilder random(int I, int J, int N);

    Pattern make_Pattern() const;
  
  private:

    // Implementation detail of constructors.
    void constructor_detail(int in_I, int in_J);
  
    // Holds size.
    int I;
    int J;

    // Numeric contents.
    Columns columns;
  };

LIBPUBLIC PatternBuilder operator+ (const PatternBuilder& P1, const PatternBuilder& P2);

LIBPUBLIC PatternBuilder operator- (const PatternBuilder& P1, const PatternBuilder& P2);

LIBPUBLIC PatternBuilder operator* (const PatternBuilder& P1, const PatternBuilder& P2);

LIBPUBLIC std::ostream& operator << (std::ostream& out, const PatternBuilder& p);

} // namespace

#endif