org.apache.sysds.runtime.data

## Class DenseBlock

- java.lang.Object
- - org.apache.sysds.runtime.data.DenseBlock

All Implemented Interfaces:
  Serializable

Direct Known Subclasses:
  DenseBlockDRB, DenseBlockLDRB

    public abstract class DenseBlock
    extends Object
    implements Serializable

This DenseBlock is an abstraction for different dense, row-major matrix formats. For efficient dense operations, this API does not expose a row but a row-block abstraction, where a block can contain one or many contiguous rows.

See Also:
  Serialized Form

### Nested Class Summary

Nested Classes
`static class` `DenseBlock.Type`

### Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
`abstract int` `blockSize()` Get the number of rows per block, except last one.
`abstract int` `blockSize(int bix)` Get the number of rows of the given block.
`abstract long` `capacity()` Get the total length of allocated blocks.
`abstract long` `countNonZeros()` Compute the number of non-zero values, which potentially makes a full pass over the underlying blocks.
`abstract int` `countNonZeros(int r)` Compute the number of non-zero values for the given row, which potentially makes a full pass over the underlying row.
`abstract long` `countNonZeros(int rl, int ru, int cl, int cu)` Compute the number of non-zero values, which potentially makes a full pass over the underlying blocks in the row range.
`static double` `estimateMemory(long nrows, long ncols)`
`abstract double` `get(int[] ix)` Get the value of a given cell
`abstract double` `get(int r, int c)` Get the value for a given row and column.
`int` `getCumODims(int i)` Get the ith cumulative dimensions size of the dense block, without row.
`int` `getDim(int i)` Get the ith dimensions size of the dense block.
`abstract long` `getLong(int[] ix)` Get the value of a given cell as long
`void` `getNextIndexes(int[] ix)` Calculates the next index array.
`abstract String` `getString(int[] ix)` Get the value of a given cell as a String
`abstract void` `incr(int r, int c)` Increments the given value for a given row and column.
`abstract void` `incr(int r, int c, double delta)` Increments the given value for a given row and column by delta.
`abstract int` `index(int r)` Get the block index for a given row.
`abstract boolean` `isContiguous()` Indicates if the dense block has a single underlying block, i.e., if numBlocks==1.
`abstract boolean` `isContiguous(int rl, int ru)` Indicates if the dense block has a single underlying block for the given row range.
`abstract boolean` `isNumeric()` Indicates if the dense block is numeric.
`abstract int` `numBlocks()` Get the number of allocated blocks.
`int` `numDims()` Get the number of dimensions.
`int` `numRows()` Get the number of rows.
`abstract int` `pos(int r)` Get the position for a given row within its associated block.
`abstract int` `pos(int[] ix)` Get the position for a given cell within the associated block.
`abstract int` `pos(int r, int c)` Get the position for a given row and column within the associated block.
`void` `reset()` Resets the dense block by deleting non-zero values.
`void` `reset(int[] dims)` Resets the dense block by deleting non-zero values.
`void` `reset(int[] dims, double v)` Resets the dense block by deleting non-zeros.
`void` `reset(int rlen, int clen)` Resets the dense block by deleting non-zeros.
`void` `reset(int rlen, int[] odims)` Resets the dense block by deleting non-zeros.
`abstract void` `reset(int rlen, int[] odims, double v)` Resets the dense block by setting the given value.
`void` `reset(int rlen, int clen, double v)` Resets the dense block by setting the given value.
`abstract DenseBlock` `set(DenseBlock db)` Copy the given dense block.
`abstract DenseBlock` `set(double v)` Set the given value for the entire dense block (fill).
`abstract DenseBlock` `set(int[] ix, double v)` Set the specified cell to the given value.
`abstract DenseBlock` `set(int[] ix, long v)` Set the specified cell to the given value.
`abstract DenseBlock` `set(int[] ix, String v)` Set the specified cell to the given value.
`abstract DenseBlock` `set(int r, double[] v)` Copy the given vector into the given row.
`abstract DenseBlock` `set(int r, int c, double v)` Set the given value for a given row and column.
`DenseBlock` `set(int rl, int ru, int cl, int cu, DenseBlock db)` Copy the given dense block into the specified index range.
`abstract DenseBlock` `set(int rl, int ru, int cl, int cu, double v)` Set the given value for an entire index range of the dense block (fill).
`DenseBlock` `set(int r, KahanObject kbuff)` Copy the given kahan object sum and correction into the given row.
`DenseBlock` `set(KahanObject kbuff)` Copy the given kahan object sum and correction.
`DenseBlock` `set(String s)` Set the given string for the entire dense block (fill).
`void` `setDims(int[] dims)` Set the dimensions of the dense MatrixBlock.
`long` `size()` Get the length of the dense block as the product of all dimensions.
`abstract int` `size(int bix)` Get the length of the given block.
`String` `toString()`
`abstract double[]` `values(int r)` Get the allocated block for the given row.
`abstract double[]` `valuesAt(int bix)` Get an allocated block.

### Methods inherited from class java.lang.Object

`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Method Detail

#### getDim

    public final int getDim(int i)

Get the ith dimensions size of the dense block.

Parameters:
  `i` - the number of dimension to get
Returns:
  the size of the dimension

#### getCumODims

    public final int getCumODims(int i)

Get the ith cumulative dimensions size of the dense block, without row.

Parameters:
  `i` - the number of the cumulative dimension to get (0 equals the second dimension!)
Returns:
  the size of the dimension cumulative with all following dimensions

#### reset

    public final void reset()

Resets the dense block by deleting non-zero values. After this call all countNonZeros() calls are guaranteed to return 0.

#### reset

    public final void reset(int[] dims)

Resets the dense block by deleting non-zero values. After this call all countNonZeros() calls are guaranteed to return 0. If the new dimensions exceed the current capacity, the underlying storage is extended accordingly.

Parameters:
  `dims` - length and size of dimensions.

#### reset

    public final void reset(int[] dims,
                            double v)

Resets the dense block by deleting non-zeros.

Parameters:
  `dims` - lenth and size of dimensions
  `v` - value

#### reset

    public final void reset(int rlen,
                            int clen)

Resets the dense block by deleting non-zeros.

Parameters:
  `rlen` - number of rows
  `clen` - number of columns

#### reset

    public final void reset(int rlen,
                            int[] odims)

Resets the dense block by deleting non-zeros.

Parameters:
  `rlen` - number of rows
  `odims` - offsets of other dimensions

#### reset

    public final void reset(int rlen,
                            int clen,
                            double v)

Resets the dense block by setting the given value.

Parameters:
  `rlen` - number of rows
  `clen` - number of columns
  `v` - value

#### reset

    public abstract void reset(int rlen,
                               int[] odims,
                               double v)

Resets the dense block by setting the given value.

Parameters:
  `rlen` - number of rows
  `odims` - other dimensions
  `v` - value

#### estimateMemory

    public static double estimateMemory(long nrows,
                                        long ncols)

#### setDims

    public void setDims(int[] dims)

Set the dimensions of the dense MatrixBlock.

Parameters:
  `dims` - The dimensions to set, first dimension is rows, second cols.

#### numRows

    public final int numRows()

Get the number of rows.

Returns:
  number of rows

#### numDims

    public final int numDims()

Get the number of dimensions.

Returns:
  number of dimensions, min 2

#### numBlocks

    public abstract int numBlocks()

Get the number of allocated blocks.

Returns:
  number of blocks

#### blockSize

    public abstract int blockSize()

Get the number of rows per block, except last one.

Returns:
  number of rows in block

#### blockSize

    public abstract int blockSize(int bix)

Get the number of rows of the given block.

Parameters:
  `bix` - block index
Returns:
  number of rows in block

#### isNumeric

    public abstract boolean isNumeric()

Indicates if the dense block is numeric.

Returns:
  true if numeric (FP, INT, BOOLEAN)

#### isContiguous

    public abstract boolean isContiguous()

Indicates if the dense block has a single underlying block, i.e., if numBlocks==1.

Returns:
  true if single block

#### isContiguous

    public abstract boolean isContiguous(int rl,
                                         int ru)

Indicates if the dense block has a single underlying block for the given row range.

Parameters:
  `rl` - row lower index
  `ru` - row upper index (inclusive)
Returns:
  true if single block in row range

#### size

    public final long size()

Get the length of the dense block as the product of all dimensions.

Returns:
  length

#### size

    public abstract int size(int bix)

Get the length of the given block.

Parameters:
  `bix` - block index
Returns:
  length

#### capacity

    public abstract long capacity()

Get the total length of allocated blocks.

Returns:
  capacity

#### countNonZeros

    public abstract long countNonZeros()

Compute the number of non-zero values, which potentially makes a full pass over the underlying blocks.

Returns:
  number of non-zeros

#### countNonZeros

    public abstract int countNonZeros(int r)

Compute the number of non-zero values for the given row, which potentially makes a full pass over the underlying row.

Parameters:
  `r` - row index
Returns:
  number of non-zeros

#### countNonZeros

    public abstract long countNonZeros(int rl,
                                       int ru,
                                       int cl,
                                       int cu)

Compute the number of non-zero values, which potentially makes a full pass over the underlying blocks in the row range.

Parameters:
  `rl` - row lower index
  `ru` - row upper index (exclusive)
  `cl` - column lower index
  `cu` - column upper index (exclusive)
Returns:
  number of non-zeros

#### values

    public abstract double[] values(int r)

Get the allocated block for the given row. This call is equivalent to valuesAt(indexes(r)).

Parameters:
  `r` - row index
Returns:
  block

#### valuesAt

    public abstract double[] valuesAt(int bix)

Get an allocated block.

Parameters:
  `bix` - block index
Returns:
  block

#### index

    public abstract int index(int r)

Get the block index for a given row.

Parameters:
  `r` - row index
Returns:
  block index

#### pos

    public abstract int pos(int r)

Get the position for a given row within its associated block.

Parameters:
  `r` - row index
Returns:
  block position

#### pos

    public abstract int pos(int r,
                            int c)

Get the position for a given row and column within the associated block.

Parameters:
  `r` - row index
  `c` - column index
Returns:
  block position

#### pos

    public abstract int pos(int[] ix)

Get the position for a given cell within the associated block.

Parameters:
  `ix` - cell indexes
Returns:
  block position

#### incr

    public abstract void incr(int r,
                              int c)

Increments the given value for a given row and column.

Parameters:
  `r` - row index
  `c` - column index

#### incr

    public abstract void incr(int r,
                              int c,
                              double delta)

Increments the given value for a given row and column by delta.

Parameters:
  `r` - row index
  `c` - column index
  `delta` - increment value

#### set

    public abstract DenseBlock set(double v)

Set the given value for the entire dense block (fill).

Parameters:
  `v` - value
Returns:
  self

#### set

    public DenseBlock set(String s)

Set the given string for the entire dense block (fill). Generally the string will be parsed, except for string DenseBlock.

Parameters:
  `s` - string
Returns:
  self

#### set

    public abstract DenseBlock set(int rl,
                                   int ru,
                                   int cl,
                                   int cu,
                                   double v)

Set the given value for an entire index range of the dense block (fill).

Parameters:
  `rl` - row lower index
  `ru` - row upper index (exclusive)
  `cl` - column lower index
  `cu` - column upper index (exclusive)
  `v` - value
Returns:
  self

#### set

    public abstract DenseBlock set(int r,
                                   int c,
                                   double v)

Set the given value for a given row and column.

Parameters:
  `r` - row index
  `c` - column index
  `v` - value
Returns:
  self

#### set

    public abstract DenseBlock set(int r,
                                   double[] v)

Copy the given vector into the given row.

Parameters:
  `r` - row index
  `v` - value vector
Returns:
  self

#### set

    public abstract DenseBlock set(DenseBlock db)

Copy the given dense block.

Parameters:
  `db` - dense block
Returns:
  self

#### set

    public DenseBlock set(int rl,
                          int ru,
                          int cl,
                          int cu,
                          DenseBlock db)

Copy the given dense block into the specified index range.

Parameters:
  `rl` - row lower index
  `ru` - row upper index (exclusive)
  `cl` - column lower index
  `cu` - column upper index (exclusive)
  `db` - dense block
Returns:
  self

#### getNextIndexes

    public void getNextIndexes(int[] ix)

Calculates the next index array. Note that if the given index array was the last element, the next index will be outside of range.

Parameters:
  `ix` - the index array which will be incremented to the next index array

#### set

    public DenseBlock set(KahanObject kbuff)

Copy the given kahan object sum and correction.

Parameters:
  `kbuff` - kahan object
Returns:
  self

#### set

    public abstract DenseBlock set(int[] ix,
                                   double v)

Set the specified cell to the given value.

Parameters:
  `ix` - cell indexes
  `v` - value
Returns:
  self

#### set

    public abstract DenseBlock set(int[] ix,
                                   long v)

Set the specified cell to the given value.

Parameters:
  `ix` - cell indexes
  `v` - value
Returns:
  self

#### set

    public abstract DenseBlock set(int[] ix,
                                   String v)

Set the specified cell to the given value.

Parameters:
  `ix` - cell indexes
  `v` - value as String
Returns:
  self

#### set

    public DenseBlock set(int r,
                          KahanObject kbuff)

Copy the given kahan object sum and correction into the given row.

Parameters:
  `r` - row index
  `kbuff` - kahan object
Returns:
  self

#### get

    public abstract double get(int r,
                               int c)

Get the value for a given row and column.

Parameters:
  `r` - row index
  `c` - column index
Returns:
  value

#### get

    public abstract double get(int[] ix)

Get the value of a given cell

Parameters:
  `ix` - cell indexes
Returns:
  value

#### getString

    public abstract String getString(int[] ix)

Get the value of a given cell as a String

Parameters:
  `ix` - cell indexes
Returns:
  value as String

#### getLong

    public abstract long getLong(int[] ix)

Get the value of a given cell as long

Parameters:
  `ix` - cell indexes
Returns:
  value as long

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`