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

    • Method Detail

      • 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)
      • 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:
        columns(int[])
      • 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)
      • 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:
        rows(int[])
      • 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()