Uses of Interface
org.djunits.quantity.def.Reference

Packages that use Reference

Package	Description
org.djunits.formatter	Methods to format quantity-related values for display.
org.djunits.quantity	The quantity package stores information about quantities with their units.
org.djunits.quantity.def	Definition classes for quantities.
org.djunits.vecmat.d1	1-element vector and matrix classes with a unit.
org.djunits.vecmat.d2	2-element vector and matrix classes with a unit.
org.djunits.vecmat.d3	3-element vector and matrix classes with a unit.
org.djunits.vecmat.def	Definition classes for vectors and matrices.
org.djunits.vecmat.dn	Square matrix implementations with dimension N.
org.djunits.vecmat.dnxm	Rectangular matrix implementations with dimension NxM.
org.djunits.vecmat.table	Two-dimensonal tables with quantities.

Uses of Reference in org.djunits.formatter

Methods in org.djunits.formatter with parameters of type Reference

Modifier and Type	Method	Description
(package private) static String	Formatter.formatReference(FormatContext ctx, Reference<?,?,?> reference)	Format the reference of an absolute value according to the context settings.

Uses of Reference in org.djunits.quantity

Classes in org.djunits.quantity that implement Reference

Modifier and Type	Class	Description
static final class	Direction.Reference	The reference class to define a reference point for the direction.
static final class	Position.Reference	The reference class to define a reference point for the position.
static final class	Temperature.Reference	The reference class to define a reference point for the absolute temperature.
static final class	Time.Reference	The reference class to define a reference point for the time.

Uses of Reference in org.djunits.quantity.def

Classes in org.djunits.quantity.def with type parameters of type Reference

Modifier and Type	Class	Description
class	AbsQuantity<A extends AbsQuantity<A,Q,R>,Q extends Quantity<Q>,R extends Reference<R,A,Q>>	AbsQuantity is an abstract class that stores the basic information about a absolute quantity.
interface	Reference<R extends Reference<R,A,Q>,A extends AbsQuantity<A,Q,R>,Q extends Quantity<Q>>	Reference contains information about the reference point or origin / zero point of an absolute quantity.

Classes in org.djunits.quantity.def that implement Reference

Modifier and Type	Class	Description
class	AbstractReference<R extends AbstractReference<R,A,Q>,A extends AbsQuantity<A,Q,R>,Q extends Quantity<Q>>	Reference contains information about the reference point or origin / zero point of an absolute quantity.

Fields in org.djunits.quantity.def with type parameters of type Reference

Modifier and Type	Field	Description
protected static final Map<Class<?>,Map<String,Reference<?,?,?>>>	AbstractReference.REFERENCES	Master registry: per concrete Reference subclass we keep a map of id to reference.

Methods in org.djunits.quantity.def with type parameters of type Reference

Modifier and Type	Method	Description
static <R extends Reference<R, ?, ?>> R	AbstractReference.get(Class<R> referenceClass, String id)	Fetch a reference by class and id.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	AbsQuantity.interpolate(A zero, A one, double ratio)	Interpolate between two absolute quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	AbsQuantity.max(A quantity1, A... quantities)	Return the maximum value of one or more quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	AbsQuantity.mean(A quantity1, A... quantities)	Return the mean of one or more quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	AbsQuantity.min(A quantity1, A... quantities)	Return the minimum value of one or more quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	AbsQuantity.of(double valueInUnit, String unitString, A example, R reference)	Returns an absolute quantity based on a value and the textual representation of the unit, which can be localized.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	AbsQuantity.sum(A quantity1, A... quantities)	Return the sum of one or more quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	AbsQuantity.valueOf(String text, A example, R reference)	Returns an absolute quantity for the textual representation of a value with a unit.

Methods in org.djunits.quantity.def that return types with arguments of type Reference

Modifier and Type	Method	Description
Map<String,Reference<?,?,?>>	AbstractReference.getReferenceMap()	Return a safe copy of the static reference map for this Reference subclass.
Map<String,Reference<?,?,?>>	Reference.getReferenceMap()	Return a safe copy of the static reference map for this Reference subclass.
protected static Map<String,Reference<?,?,?>>	AbstractReference.mapFor(Class<?> referenceClass)	Get or create the inner map for a specific Reference subclass.
static Map<String,Reference<?,?,?>>	AbstractReference.snapshotMap(Class<?> referenceClass)	Return a safe copy (snapshot) of the registry for a Reference subclass.

Uses of Reference in org.djunits.vecmat.d1

Methods in org.djunits.vecmat.d1 with type parameters of type Reference

Modifier and Type	Method	Description
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(double[][] gridInUnit, Unit<?,Q> unit, R reference)	Create an AbsMatrix1x1 with a unit, based on a 2-dimensional grid.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(double xInUnit, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(A absX)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(A[] absData)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(A[][] absGrid)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(Matrix1x1<Q> relativeMatrix, R reference)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(Q[][] grid, R reference)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(Q[] data, R reference)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(Q x, R reference)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create an AbsVector1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.of(double xInUnit, Unit<?,Q> unit, R reference)	Create an AbsVector1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.of(A absX)	Create an AbsVector1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.of(A[] absData)	Create an AbsVector1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.of(Vector1<Q> relativeVector, R reference)	Create an AbsVector1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.of(Q[] data, R reference)	Create an AbsVector1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.of(Q x, R reference)	Create an AbsVector1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.ofSi(double[][] gridSi, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrix1x1 with a unit, based on a 2-dimensional grid with SI-values.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrix1x1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create an AbsVector1 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector1<A,Q>	AbsVector1.ofSi(double xSi, Unit<?,Q> displayUnit, R reference)	Create an AbsVector1 without needing generics.

Methods in org.djunits.vecmat.d1 with parameters of type Reference

Modifier and Type	Method	Description
AbsMatrix1x1<A,Q>	AbsMatrix1x1.instantiate(Matrix1x1<Q> relativeMatrix, Reference<?,A,Q> reference)
AbsVector1<A,Q>	AbsVector1.instantiate(Vector1<Q> relativeVector, Reference<?,A,Q> reference)

Constructors in org.djunits.vecmat.d1 with parameters of type Reference

Modifier	Constructor	Description
	AbsMatrix1x1(Matrix1x1<Q> relativeMatrix, Reference<?,A,Q> reference)	Create a new AbsMatrix1x1 with a display unit and a reference point.
	AbsVector1(Vector1<Q> relativeVector, Reference<?,A,Q> reference)	Create a new AbsVector1 with a display unit and a reference point.

Uses of Reference in org.djunits.vecmat.d2

Methods in org.djunits.vecmat.d2 with type parameters of type Reference

Modifier and Type	Method	Description
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.of(double[][] gridInUnit, Unit<?,Q> unit, R reference)	Create an AbsMatrix2x2 with a unit, based on a 2-dimensional grid.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create an AbsMatrix2x2 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.of(A[] absData)	Create an AbsMatrix2x2 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.of(A[][] absGrid)	Create an AbsMatrix2x2 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.of(Matrix2x2<Q> relativeMatrix, R reference)	Create an AbsMatrix2x2 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.of(Q[][] grid, R reference)	Create an AbsMatrix2x2 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.of(Q[] data, R reference)	Create an AbsMatrix2x2 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create a AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.of(double xInUnit, double yInUnit, Unit<?,Q> unit, R reference)	Create a AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.of(A[] absData)	Create an AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.of(A absX, A absY)	Create an AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.of(Vector2.Col<Q> relativeVector, R reference)	Create an AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.of(Q[] data, R reference)	Create a AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.of(Q x, Q y, R reference)	Create a AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create a AbsVector2.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.of(double xInUnit, double yInUnit, Unit<?,Q> unit, R reference)	Create a AbsVector2.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.of(A[] absData)	Create an AbsVector2.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.of(A absX, A absY)	Create an AbsVector2.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.of(Vector2.Row<Q> relativeVector, R reference)	Create an AbsVector2.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.of(Q[] data, R reference)	Create a AbsVector2.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.of(Q x, Q y, R reference)	Create a AbsVector2.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.ofSi(double[][] gridSi, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrix2x2 with a unit, based on a 2-dimensional grid with SI-values.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrix2x2 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create a AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Col<A,Q>	AbsVector2.Col.ofSi(double xSi, double ySi, Unit<?,Q> displayUnit, R reference)	Create a AbsVector2.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create a AbsVector2.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector2.Row<A,Q>	AbsVector2.Row.ofSi(double xSi, double ySi, Unit<?,Q> displayUnit, R reference)	Create a AbsVector2.Row without needing generics.

Methods in org.djunits.vecmat.d2 with parameters of type Reference

Modifier and Type	Method	Description
AbsMatrix2x2<A,Q>	AbsMatrix2x2.instantiate(Matrix2x2<Q> relativeMatrix, Reference<?,A,Q> reference)
AbsVector2.Col<A,Q>	AbsVector2.Col.instantiate(Vector2.Col<Q> relativeVector, Reference<?,A,Q> reference)
AbsVector2.Row<A,Q>	AbsVector2.Row.instantiate(Vector2.Row<Q> relativeVector, Reference<?,A,Q> reference)

Constructors in org.djunits.vecmat.d2 with parameters of type Reference

Modifier	Constructor	Description
	AbsMatrix2x2(Matrix2x2<Q> relativeMatrix, Reference<?,A,Q> reference)	Create a new AbsMatrix2x2 with a display unit and a reference point.
	AbsVector2(VQ relativeVector, Reference<?,A,Q> reference)	Instantiate an AbsVector2.
	Col(Vector2.Col<Q> relativeVector, Reference<?,A,Q> reference)	Create a new AbsVector2 with absolute quantities, with a display unit and a reference point.
	Row(Vector2.Row<Q> relativeVector, Reference<?,A,Q> reference)	Create a new AbsVector2 with absolute quantities, with a display unit and a reference point.

Uses of Reference in org.djunits.vecmat.d3

Methods in org.djunits.vecmat.d3 with type parameters of type Reference

Modifier and Type	Method	Description
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.of(double[][] gridInUnit, Unit<?,Q> unit, R reference)	Create an AbsMatrix3x3 with a unit, based on a 2-dimensional grid.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create an AbsMatrix3x3 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.of(A[] absData)	Create an AbsMatrix3x3 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.of(A[][] absGrid)	Create an AbsMatrix3x3 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.of(Matrix3x3<Q> relativeMatrix, R reference)	Create an AbsMatrix3x3 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.of(Q[][] grid, R reference)	Create an AbsMatrix3x3 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.of(Q[] data, R reference)	Create an AbsMatrix3x3 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create a AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.of(double xInUnit, double yInUnit, double zInUnit, Unit<?,Q> unit, R reference)	Create a AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.of(A[] absData)	Create an AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.of(A absX, A absY, A absZ)	Create an AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.of(Vector3.Col<Q> relativeVector, R reference)	Create an AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.of(Q[] data, R reference)	Create a AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.of(Q x, Q y, Q z, R reference)	Create a AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create a AbsVector3.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.of(double xInUnit, double yInUnit, double zInUnit, Unit<?,Q> unit, R reference)	Create a AbsVector3.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.of(A[] absData)	Create an AbsVector3.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.of(A absX, A absY, A absZ)	Create an AbsVector3.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.of(Vector3.Row<Q> relativeVector, R reference)	Create an AbsVector3.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.of(Q[] data, R reference)	Create a AbsVector3.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.of(Q x, Q y, Q z, R reference)	Create a AbsVector3.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.ofSi(double[][] gridSi, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrix3x3 with a unit, based on a 2-dimensional grid with SI-values.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrix3x3 without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create a AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Col<A,Q>	AbsVector3.Col.ofSi(double xSi, double ySi, double zSi, Unit<?,Q> displayUnit, R reference)	Create a AbsVector3.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create a AbsVector3.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVector3.Row<A,Q>	AbsVector3.Row.ofSi(double xSi, double ySi, double zSi, Unit<?,Q> displayUnit, R reference)	Create a AbsVector3.Row without needing generics.

Methods in org.djunits.vecmat.d3 with parameters of type Reference

Modifier and Type	Method	Description
AbsMatrix3x3<A,Q>	AbsMatrix3x3.instantiate(Matrix3x3<Q> relativeMatrix, Reference<?,A,Q> reference)
AbsVector3.Col<A,Q>	AbsVector3.Col.instantiate(Vector3.Col<Q> relativeVector, Reference<?,A,Q> reference)
AbsVector3.Row<A,Q>	AbsVector3.Row.instantiate(Vector3.Row<Q> relativeVector, Reference<?,A,Q> reference)

Constructors in org.djunits.vecmat.d3 with parameters of type Reference

Modifier	Constructor	Description
	AbsMatrix3x3(Matrix3x3<Q> relativeMatrix, Reference<?,A,Q> reference)	Create a new AbsMatrix3x3 with a display unit and a reference point.
	AbsVector3(VQ relativeVector, Reference<?,A,Q> reference)	Instantiate an AbsVector3.
	Col(Vector3.Col<Q> relativeVector, Reference<?,A,Q> reference)	Create a new AbsVector3 with absolute quantities, with a display unit and a reference point.
	Row(Vector3.Row<Q> relativeVector, Reference<?,A,Q> reference)	Create a new AbsVector3 with absolute quantities, with a display unit and a reference point.

Uses of Reference in org.djunits.vecmat.def

Methods in org.djunits.vecmat.def that return Reference

Modifier and Type	Method	Description
Reference<?,A,Q>	AbsVectorMatrix.getReference()	Return the reference point for the absolute values.

Methods in org.djunits.vecmat.def with parameters of type Reference

Modifier and Type	Method	Description
abstract VMA	AbsVectorMatrix.instantiate(VMQ relVecMat, Reference<?,A,Q> newReference)	Return a new vector or matrix with the given SI or BASE values for the relative vector or matrix.
VMA	AbsVectorMatrix.instantiateSi(double[] siNew, Reference<?,A,Q> newReference)	Return a new vector or matrix with the given SI or BASE values for the relative vector or matrix.

Constructors in org.djunits.vecmat.def with parameters of type Reference

Modifier	Constructor	Description
	AbsMatrix(MQ matrix, Reference<?,A,Q> reference)	Create a new matrix of absolute values with a reference point.
	AbsSquareMatrix(MQ matrix, Reference<?,A,Q> reference)	Create a new square matrix of absolute values with a reference point.
	AbsTable(MQ matrix, Reference<?,A,Q> reference)	Create a new matrix of absolute values with a reference point.
	AbsVector(VQ vector, Reference<?,A,Q> reference)	Create a new vector of absolute values with a reference point.
	AbsVectorMatrix(VMQ relativeVecMat, Reference<?,A,Q> reference)	Create a new vector or matrix of absolute values with a reference point.

Uses of Reference in org.djunits.vecmat.dn

Methods in org.djunits.vecmat.dn with type parameters of type Reference

Modifier and Type	Method	Description
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.of(double[][] gridInUnit, Unit<?,Q> unit, R reference)	Create an AbsMatrixNxN with a unit, based on a 2-dimensional grid.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create an AbsMatrixNxN without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.of(A[] absData)	Create a AbsMatrixNxN without needing generics, based on a row-major array of absolute quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.of(A[][] absGrid)	Create a AbsMatrixNxN without needing generics, based on a row-major array of absolute quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.of(MatrixNxN<Q> relativeMatrix, R reference)	Create an AbsMatrixNxN without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.of(Q[][] grid, R reference)	Create an AbsMatrixNxN without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.of(Q[] data, R reference)	Create an AbsMatrixNxN without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Col<A,Q>	AbsVectorN.Col.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create a AbsVectorN.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Col<A,Q>	AbsVectorN.Col.of(A[] absData)	Create an AbsVectorN.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Col<A,Q>	AbsVectorN.Col.of(List<A> absData)	Create an AbsVectorN.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Col<A,Q>	AbsVectorN.Col.of(List<Q> data, R reference)	Create a new column VectorN with a unit, based on a quantity list that contains data.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Col<A,Q>	AbsVectorN.Col.of(VectorN.Col<Q> relativeVector, R reference)	Create an AbsVectorN.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Col<A,Q>	AbsVectorN.Col.of(Q[] data, R reference)	Create a AbsVectorN.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Row<A,Q>	AbsVectorN.Row.of(double[] dataInUnit, Unit<?,Q> unit, R reference)	Create a AbsVectorN.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Row<A,Q>	AbsVectorN.Row.of(A[] absData)	Create an AbsVectorN.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Row<A,Q>	AbsVectorN.Row.of(List<A> absData)	Create an AbsVectorN.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Row<A,Q>	AbsVectorN.Row.of(List<Q> data, R reference)	Create a new column VectorN with a unit, based on a quantity list that contains data.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Row<A,Q>	AbsVectorN.Row.of(VectorN.Row<Q> relativeVector, R reference)	Create an AbsVectorN.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Row<A,Q>	AbsVectorN.Row.of(Q[] data, R reference)	Create a AbsVectorN.Row without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.ofSi(double[][] gridSi, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrixNxN with a unit, based on a 2-dimensional grid with SI-values.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create an AbsMatrixNxN without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Col<A,Q>	AbsVectorN.Col.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create a AbsVectorN.Col without needing generics.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsVectorN.Row<A,Q>	AbsVectorN.Row.ofSi(double[] dataSi, Unit<?,Q> displayUnit, R reference)	Create a AbsVectorN.Row without needing generics.

Methods in org.djunits.vecmat.dn with parameters of type Reference

Modifier and Type	Method	Description
AbsMatrixNxN<A,Q>	AbsMatrixNxN.instantiate(MatrixNxN<Q> relativeMatrix, Reference<?,A,Q> reference)
AbsVectorN.Col<A,Q>	AbsVectorN.Col.instantiate(VectorN.Col<Q> relativeVector, Reference<?,A,Q> reference)
AbsVectorN.Row<A,Q>	AbsVectorN.Row.instantiate(VectorN.Row<Q> relativeVector, Reference<?,A,Q> reference)

Constructors in org.djunits.vecmat.dn with parameters of type Reference

Modifier	Constructor	Description
	AbsMatrixNxN(MatrixNxN<Q> relativeMatrix, Reference<?,A,Q> reference)	Create a new AbsMatrixNxN with a display unit and a reference point.
	AbsVectorN(VQ relativeVector, Reference<?,A,Q> reference)	Instantiate an AbsVectorN.
	Col(VectorN.Col<Q> relativeVector, Reference<?,A,Q> reference)	Create a new AbsVectorN with absolute quantities, with a display unit and a reference point.
	Row(VectorN.Row<Q> relativeVector, Reference<?,A,Q> reference)	Create a new AbsVectorN with absolute quantities, with a display unit and a reference point.

Uses of Reference in org.djunits.vecmat.dnxm

Methods in org.djunits.vecmat.dnxm with type parameters of type Reference

Modifier and Type	Method	Description
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.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.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.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.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.of(A[][] absGrid)	Create a AbsMatrixNxM without needing generics, based on a 2-dimensional grid of absolute quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.of(A[] absData, int rows, int cols)	Create a AbsMatrixNxM without needing generics, based on a row-major array of absolute quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.of(MatrixNxM<Q> relativeMatrix, R reference)	Create a AbsMatrixNxM without needing generics, based on a relative matrix.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.of(Q[][] grid, R reference)	Create a AbsMatrixNxM without needing generics, based on a 2-dimensional grid of quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.of(Q[] data, int rows, int cols, R reference)	Create a AbsMatrixNxM without needing generics, based on a row-major array of quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.ofSi(double[][] gridSi, Unit<?,Q> displayUnit, R reference)	Create a new AbsMatrixNxM with a unit, based on a 2-dimensional grid with SI-values.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.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.

Methods in org.djunits.vecmat.dnxm with parameters of type Reference

Modifier and Type	Method	Description
AbsMatrixNxM<A,Q>	AbsMatrixNxM.instantiate(MatrixNxM<Q> relativeMatrix, Reference<?,A,Q> reference)

Constructors in org.djunits.vecmat.dnxm with parameters of type Reference

Modifier	Constructor	Description
	AbsMatrixNxM(MatrixNxM<Q> relativeMatrix, Reference<?,A,Q> reference)	Create a new AbsMatrixNxM with a display unit and a reference point.

Uses of Reference in org.djunits.vecmat.table

Methods in org.djunits.vecmat.table with type parameters of type Reference

Modifier and Type	Method	Description
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.of(double[][] gridInUnit, Unit<?,Q> unit, R reference)	Create a new AbsQuantityTable with a unit, based on a 2-dimensional grid with values in the given unit.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.of(double[] dataInUnit, int rows, int cols, Unit<?,Q> unit, R reference)	Create a new AbsQuantityTable with a unit, based on a row-major array with values in the given unit.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.of(A[][] absGrid)	Create a AbsQuantityTable without needing generics, based on a 2-dimensional grid of absolute quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.of(A[] absData, int rows, int cols)	Create a AbsQuantityTable without needing generics, based on a row-major array of absolute quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.of(QuantityTable<Q> relativeTable, R reference)	Create a AbsQuantityTable without needing generics, based on a relative table.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.of(Q[][] grid, R reference)	Create a AbsQuantityTable without needing generics, based on a 2-dimensional grid of quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.of(Q[] data, int rows, int cols, R reference)	Create a AbsQuantityTable without needing generics, based on a row-major array of quantities.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.ofSi(double[][] gridSi, Unit<?,Q> displayUnit, R reference)	Create a new AbsQuantityTable with a unit, based on a 2-dimensional grid with SI-values.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.ofSi(double[] dataSi, int rows, int cols, Unit<?,Q> displayUnit, R reference)	Create a AbsQuantityTable without needing generics, based on a row-major array with SI-values.

Methods in org.djunits.vecmat.table with parameters of type Reference

Modifier and Type	Method	Description
AbsQuantityTable<A,Q>	AbsQuantityTable.instantiate(QuantityTable<Q> relativeTable, Reference<?,A,Q> reference)

Constructors in org.djunits.vecmat.table with parameters of type Reference

Modifier	Constructor	Description
	AbsQuantityTable(QuantityTable<Q> relativeTable, Reference<?,A,Q> reference)	Create a new AbsQuantityTable with a display unit and a reference point.