Class AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>

Type Parameters:
A - the absolute quantity type
Q - the corresponding relative quantity type
All Implemented Interfaces:
Serializable, Value<AbsMatrixNxM<A,Q>,Q>

public class AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>> extends AbsMatrix<A,Q,AbsMatrixNxM<A,Q>,MatrixNxM<Q>,AbsMatrixNxM<A,Q>>
AbsMatrixNxM implements a matrix with NxM absolute quantities with a reference point. The matrix is immutable, except for the display unit, which can be changed.

Copyright (c) 2026-2026 Delft University of Technology, Jaffalaan 5, 2628 BX Delft, the Netherlands. All rights reserved. See for project information https://djunits.org. The DJUNITS project is distributed under a three-clause BSD-style license.

Author:
Alexander Verbraeck
See Also:
  • Constructor Details

    • AbsMatrixNxM

      public AbsMatrixNxM(MatrixNxM<Q> relativeMatrix, Reference<?,A,Q> reference)
      Create a new AbsMatrixNxM with a display unit and a reference point.
      Parameters:
      relativeMatrix - the matrix values {a_ij} expressed in the displayUnit
      reference - the reference point for the absolute values
  • Method Details

    • instantiate

      public AbsMatrixNxM<A,Q> instantiate(MatrixNxM<Q> relativeMatrix, Reference<?,A,Q> reference)
      Description copied from class: AbsVectorMatrix
      Return a new vector or matrix with the given SI or BASE values for the relative vector or matrix.
      Specified by:
      instantiate in class AbsVectorMatrix<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>,MatrixNxM<Q extends Quantity<Q>>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>>
      Parameters:
      relativeMatrix - the underlying relative vector or matrix with SI values relative to the reference point
      reference - the reference point for the relative SI values
      Returns:
      a new matrix with the provided SI or BASE values
    • getRowVector

      public AbsVectorN.Row<A,Q> getRowVector(int row)
      Description copied from class: AbsTable
      Return a quantity row (0-based) from the vector or matrix. Note that the specific vector to return can be tightened by the implementing class.
      Specified by:
      getRowVector in class AbsTable<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>,MatrixNxM<Q extends Quantity<Q>>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>>
      Parameters:
      row - the row number to retrieve (0-based)
      Returns:
      a row vector with the data at the given row
    • mgetRowVector

      public AbsVectorN.Row<A,Q> mgetRowVector(int mRow)
      Description copied from class: AbsTable
      Return a quantity row (1-based) from the vector or matrix. Note that the specific vector to return can be tightened by the implementing class.
      Specified by:
      mgetRowVector in class AbsTable<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>,MatrixNxM<Q extends Quantity<Q>>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>>
      Parameters:
      mRow - the row number to retrieve (1-based)
      Returns:
      a row vector with the data at the given row
    • getColumnVector

      public AbsVectorN.Col<A,Q> getColumnVector(int col)
      Description copied from class: AbsTable
      Return a quantity column (0-based) from the vector or matrix. Note that the specific vector to return can be tightened by the implementing class.
      Specified by:
      getColumnVector in class AbsTable<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>,MatrixNxM<Q extends Quantity<Q>>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>>
      Parameters:
      col - the column number to retrieve (0-based)
      Returns:
      a column vector with the data at the given column
    • mgetColumnVector

      public AbsVectorN.Col<A,Q> mgetColumnVector(int mCol)
      Description copied from class: AbsTable
      Return a quantity column (1-based) from the vector or matrix. Note that the specific vector to return can be tightened by the implementing class.
      Specified by:
      mgetColumnVector in class AbsTable<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>,MatrixNxM<Q extends Quantity<Q>>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>>
      Parameters:
      mCol - the column number to retrieve (1-based)
      Returns:
      a column vector with the data at the given column
    • transpose

      public AbsMatrixNxM<A,Q> transpose()
      Description copied from class: AbsVectorMatrix
      Return a transposed absolute vector or matrix, where rows and columns have been swapped.
      Specified by:
      transpose in class AbsVectorMatrix<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>,MatrixNxM<Q extends Quantity<Q>>,AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>>
      Returns:
      a transposed absolute vector or matrix, where rows and columns have been swapped
    • of

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> of(double[] dataInUnit, int rows, int cols, Unit<?,Q> unit, R reference)
      Create a new AbsMatrixNxM with a unit, based on a row-major array with values in the given unit.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      dataInUnit - the matrix values {a11, a12, ..., A1M, ..., aN1, aN2, ..., aNM} expressed in the unit
      rows - the number of rows
      cols - the number of columns
      unit - the unit of the data, also used as the display unit
      reference - the reference point for the absolute quantities
      Returns:
      a new AbsMatrixNxM with a unit
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols, or when the number of rows or columns is not positive
    • ofSi

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> ofSi(double[] dataSi, int rows, int cols, Unit<?,Q> displayUnit, R reference)
      Create a AbsMatrixNxM without needing generics, based on a row-major array with SI-values.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      dataSi - the matrix values {a11, a12, ..., A1M, ..., aN1, aN2, ..., aNM} as an array using SI units
      rows - the number of rows
      cols - the number of columns
      displayUnit - the display unit to use
      reference - the reference point for the absolute quantities
      Returns:
      a new AbsMatrixNxM with a unit
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols, or when the number of rows or columns is not positive
    • of

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> of(Q[] data, int rows, int cols, R reference)
      Create a AbsMatrixNxM without needing generics, based on a row-major array of quantities. The unit is taken from the first quantity in the array.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      data - the matrix values {a11, a12, ..., A1M, ..., aN1, aN2, ..., aNM} expressed as an array of quantities
      rows - the number of rows
      cols - the number of columns
      reference - the reference point for the absolute quantities
      Returns:
      a new AbsMatrixNxM with a unit
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols, or when the number of rows or columns is not positive
    • of

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> of(A[] absData, int rows, int cols)
      Create a AbsMatrixNxM without needing generics, based on a row-major array of absolute quantities. The unit is taken from the first quantity in the grid. The reference points have to be all the same.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      absData - the table values {a11, a12, ..., A1M, ..., aN1, aN2, ..., aNM} expressed as an array of absolute quantities
      rows - the number of rows
      cols - the number of columns
      Returns:
      a new AbsMatrixNxM with a display unit and reference point
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols
    • ofSi

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> ofSi(double[][] gridSi, Unit<?,Q> displayUnit, R reference)
      Create a new AbsMatrixNxM with a unit, based on a 2-dimensional grid with SI-values.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      gridSi - the matrix values {{a11, a12, ..., A1M}, ..., {aN1, aN2, ..., aNM}} expressed in the SI or base unit
      displayUnit - the unit of the data, which will also be used as the display unit
      reference - the reference point for the absolute quantities
      Returns:
      a new AbsMatrixNxM with a unit
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols
    • of

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> of(double[][] gridInUnit, Unit<?,Q> unit, R reference)
      Create a new AbsMatrixNxM with a unit, based on a 2-dimensional grid with values in the given unit.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      gridInUnit - the matrix values {{a11, a12, ..., A1M}, ..., {aN1, aN2, ..., aNM}} expressed in the unit
      unit - the unit of the values, also used as the display unit
      reference - the reference point for the absolute quantities
      Returns:
      a new AbsMatrixNxM with a unit
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols
    • of

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> of(Q[][] grid, R reference)
      Create a AbsMatrixNxM without needing generics, based on a 2-dimensional grid of quantities. The unit is taken from the first quantity in the grid.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      grid - the matrix values {{a11, a12, ..., A1M}, ..., {aN1, aN2, ..., aNM}} expressed as a 2-dimensional array of quantities
      reference - the reference point for the absolute quantities
      Returns:
      a new AbsMatrixNxM with a unit
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols
    • of

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> of(A[][] absGrid)
      Create a AbsMatrixNxM without needing generics, based on a 2-dimensional grid of absolute quantities. The unit is taken from the first quantity in the grid. The reference points have to be all the same.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      absGrid - the table values {{a11, a12, ..., A1M}, ..., {aN1, aN2, ..., aNM}} expressed as a 2-dimensional array of absolute quantities
      Returns:
      a new AbsMatrixNxM with a display unit and reference point
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols
    • of

      public static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q> of(MatrixNxM<Q> relativeMatrix, R reference)
      Create a AbsMatrixNxM without needing generics, based on a relative matrix. The unit is taken from the first quantity in the grid.
      Type Parameters:
      A - the absolute quantity type
      Q - the quantity type
      R - the reference type
      Parameters:
      relativeMatrix - the relative matrix with values relative to the reference point
      reference - the reference point for the absolute quantities
      Returns:
      a new AbsMatrixNxM with a unit
      Throws:
      IllegalArgumentException - when the size of the data object is not equal to rows*cols