PatternRange.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_PATTERNRANGE_H
#define MYRAMATH_SPARSE_PATTERNRANGE_H

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

#include <utility>
#include <iosfwd>
#include <vector>

namespace myra {

// Forward declarations.
class intCRange;
class PatternRange;
class PatternIterator;
template<class T> class Array1;
template<class T> class Array2;
class OutputStream;

class LIBPUBLIC PatternRange
  {
  public:

    // Data pointers for underlying Pattern
    const int* Ao; // Offsets for each j into Ai[] data.
    const int* Ai; // Row indices (i) in compressed-sparse-column format.
     
    // Extents of this Range within underlying Pattern.
    int I0,I1;     // I-extents of Range
    int J0,J1;     // J-extents of Range
    bool sliced;   // If true, this PatternRange has been sliced.

    // Useful typedefs.
    typedef std::pair<PatternRange,PatternRange> Pair;

    PatternRange();

    PatternRange(const int* in_Ao, const int* in_Ai, int I, int J);

    void write(OutputStream& out) const;

    // ------------------------------------ Size and pattern queries.

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

    int n_nonzeros(int j) const;

    bool test(int i, int j) const;

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

    // ------------------------------------ Iterating.
    typedef PatternIterator Iterator;

    PatternIterator begin() const;
    PatternIterator end() const;

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

    // ------------------------------------ General slicing.

    PatternRange window(int i0, int i1, int j0, int j1) const ;

    Array2<PatternRange> windows(const intCRange& i, const intCRange& j) const;

    // ------------------------------------ Row slicing.
    
    PatternRange row(int i) const;

    PatternRange rows(int i0, int i1) const;

    Array1<PatternRange> rows(const intCRange& i) const;
    
    PatternRange top(int i) const;

    PatternRange cut_top(int i) const;

    Pair split_top(int i) const;

    PatternRange bottom(int i) const;

    PatternRange cut_bottom(int i) const;

    Pair split_bottom(int i) const;

    // ------------------------------------ Column slicing.

    PatternRange column(int j) const;

    PatternRange columns(int j0, int j1) const;

    Array1<PatternRange> columns(const intCRange& j) const;
    
    PatternRange left(int j) const;

    PatternRange cut_left(int j) const;

    Pair split_left(int j) const;

    PatternRange right(int j) const;

    PatternRange cut_right(int j) const;

    Pair split_right(int j) const;
    
  private:

    // Implementation details, helps make subranges.
    int I() const;
    int J() const;

    // Implementation detail for iterator compare, verifies both iterators are over same range.
    bool same (const PatternRange& that) const;

    // Implementation detail for iterator compare, verifies both iterators are over same range.
    bool notsame (const PatternRange& that) const;

    // A special memory location so that a default-constructed 0x0 PatternRange can point to valid Ai[] data
    static int Ai_zero;

    friend class PatternIterator;
    friend class Pattern;
    
  };

class LIBPUBLIC PatternIterator
  {
  public:

    void operator ++ ();
    bool operator == (const PatternIterator& that) const;
    bool operator != (const PatternIterator& that) const;

    int i() const;
    int j() const;
    
  private:

    // Implementation detail of increment()
    void seek();

    // Should call this when jay is modified, sets up traversal A(I0:I1,jay)
    void j_initialize(int jj);

    // Implementation detail of initialize(), returns offset to A(ii,jay)
    int i_initialize(int ii);
  
    // Copy of underlying range data.
    PatternRange r;

    // State members of iterator.
    int jay; // Column iterator jay
    int b;   // Offset to A(I0,jay), the begin of column jay
    int e;   // Offset to A(I1,jay), the end of column jay
    int o;   // Offset to current nonzero.

    friend class PatternRange;
    
  };

LIBPUBLIC bool operator == (const PatternRange& A, const PatternRange& B);
LIBPUBLIC bool operator != (const PatternRange& A, const PatternRange& B);

LIBPUBLIC std::ostream& operator << (std::ostream& out, const PatternRange& A);

} // namespace

#endif