Interface Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,B>>

All Superinterfaces:
Structure1D, Structure2D
All Known Subinterfaces:
DecompositionStore<N>, MatrixStore<N>, PhysicalStore<N>
All Known Implementing Classes:
AboveBelowStore, AbstractStore, BasicMatrix, ColumnsStore, ColumnsSupplier, ComposingStore, ConjugatedStore, DiagonalStore, FactoryStore, GenericStore, IdentityStore, ImageData, ImageData.SingleChannel, IterativeASS.SchurComplementSolver, LeftRightStore, LimitStore, LogicalStore, LowerHessenbergStore, LowerSymmetricStore, LowerTriangularStore, MatrixC128, MatrixH256, MatrixQ128, MatrixR032, MatrixR064, MatrixR128, OffsetStore, R032Store, R064Store, RawStore, RepeatedColumnsStore, RepeatedRowsStore, RowsStore, RowsSupplier, SelectingStore, ShadingStore, SingleStore, SparseStore, SuperimposedStore, TransjugatedStore, TransposedStore, UnaryOperatoStore, UpperHessenbergStore, UpperSymmetricStore, UpperTriangularStore, WrapperStore, ZeroStore
Enclosing interface:
Structure2D

public static interface Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,B>> extends Structure2D
  • Method Details

    • above

      B above(long numberOfRows)
    • above

      B above(S... above)
    • above

      B above(S above)
    • below

      B below(long numberOfRows)
    • below

      B below(S... below)
    • below

      B below(S below)
    • bidiagonal

      B bidiagonal(boolean upper)
    • column

      default B column(int column)
      See Also:
    • column

      default B column(long column)
      See Also:
    • columns

      B columns(int... columns)
      A selection (re-ordering) of columns. Note that it's ok to reference the same base column more than once, and any negative column reference/index will translate to a column of zeros. The number of columns in the resulting matrix is the same as the number of elements in the columns index array.
    • columns

      default B columns(long... columns)
      See Also:
    • conjugate

      B conjugate()
      Same as transpose() but in addition the elements are conjugated.
    • diagonal

      B diagonal()
      Returns:
      A diagonal matrix (main diagonal only)
    • diagonally

      B diagonally(S... diagonally)
    • hermitian

      B hermitian(boolean upper)
      Similar to symmetric(boolean) but in addition the mirrored elements are conjugated.
    • hessenberg

      B hessenberg(boolean upper)
    • left

      B left(long numberOfColumns)
    • left

      B left(S... left)
    • left

      B left(S left)
    • limits

      B limits(long rowLimit, long columnLimit)
      Setting either limit to < 0 is interpreted as "no limit" (useful when you only want to limit either the rows or columns, and don't know the size of the other)
    • offsets

      B offsets(long rowOffset, long columnOffset)
    • repeat

      B repeat(int rowsRepetitions, int columnsRepetitions)
      Will repeat this structure creating a new structure with a multiple of rows and columns.
      Parameters:
      rowsRepetitions - The number of times to repeat the rows
      columnsRepetitions - The number of times to repeat the columns
      Returns:
      The builder
    • right

      B right(long numberOfColumns)
    • right

      B right(S... right)
    • right

      B right(S right)
    • row

      default B row(int row)
      See Also:
    • row

      default B row(long row)
      See Also:
    • rows

      B rows(int... rows)
      A selection (re-ordering) of rows. Note that it's ok to reference the same base row more than once, and any negative row reference/index will translate to a row of zeros. The number of rows in the resulting matrix is the same as the number of elements in the rows index array.
    • rows

      default B rows(long... rows)
      See Also:
    • superimpose

      B superimpose(long row, long col, S matrix)
    • superimpose

      default B superimpose(S matrix)
    • symmetric

      B symmetric(boolean upper)
      Defines a symmetric Structure2D (matrix) by mirroring one half (diagonally) on the other.
      Parameters:
      upper - From where are the elements read?
    • transpose

      B transpose()
    • triangular

      B triangular(boolean upper, boolean assumeOne)
    • tridiagonal

      B tridiagonal()