Interface PhysicalStore<N extends java.lang.Comparable<N>>

    • Method Detail

      • asList

        java.util.List<N> asList()
        Returns:
        The elements of the physical store as a fixed size (1 dimensional) list. The elements may be accessed either row or colomn major.
      • indexOfLargestInColumn

        default int indexOfLargestInColumn​(int row,
                                           int col)
      • indexOfLargestInRow

        default int indexOfLargestInRow​(int row,
                                        int col)
      • indexOfLargestOnDiagonal

        default int indexOfLargestOnDiagonal​(int row,
                                             int col)
      • transformLeft

        void transformLeft​(Householder<N> transformation,
                           int firstColumn)
      • transformLeft

        void transformLeft​(Rotation<N> transformation)

        As in MatrixStore.premultiply(Access1D) where the left/parameter matrix is a plane rotation.

        Multiplying by a plane rotation from the left means that [this] gets two of its rows updated to new combinations of those two (current) rows.

        There are two ways to transpose/invert a rotation. Either you negate the angle or you interchange the two indeces that define the rotation plane.

        See Also:
        transformRight(Rotation)
      • transformRight

        void transformRight​(Householder<N> transformation,
                            int firstRow)
      • transformRight

        void transformRight​(Rotation<N> transformation)

        As in MatrixStore.multiply(MatrixStore) where the right/parameter matrix is a plane rotation.

        Multiplying by a plane rotation from the right means that [this] gets two of its columns updated to new combinations of those two (current) columns.

        There result is undefined if the two input indeces are the same (in which case the rotation plane is undefined).

        See Also:
        transformLeft(Rotation)