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/MYRAMATH_EXPORT.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 MYRAMATH_EXPORT PatternCouplet
  {
  public:

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

    // Constructs from (i,j) arguments.
    PatternCouplet(int ii, int jj)
      : i(ii), j(jj) { }

    // Default constructs, i = j = 0.
    PatternCouplet()
      : i(0), j(0) { }
    
  };

class MYRAMATH_EXPORT PatternBuilder
  {

  public:

    // Useful typedefs.
    typedef PatternCouplet Couplet;
    typedef std::vector<Couplet> Couplets;
    typedef const Couplet* Iterator;

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

    // Default constructor, makes empty PatternBuilder with size = 0x0
    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);

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

    Iterator begin() const;
    Iterator end() const;

    std::pair<int,int> size() 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;

    // Internal contents.
    Couplets couplets;

    // Compresses couplets into CSC-compatible order.
    void compress();
    
  };

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

} // namespace

#endif