Uses of Class
org.djunits.quantity.def.Quantity

Packages that use Quantity

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.unit	Base classes to encode and store units.
org.djunits.value	Generic functions for Quantity, Vector and Matrix.
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.operations	Interfaces for Vector and Matrix operations.
org.djunits.vecmat.storage	Storage objects for larger vectors and matrices (dense/sparse, double/float).
org.djunits.vecmat.table	Two-dimensonal tables with quantities.

Uses of Quantity in org.djunits.formatter

Methods in org.djunits.formatter that return Quantity

Modifier and Type	Method	Description
(package private) Quantity<?>	QuantityFormatter.quantity()	Return the value as a quantity.

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

Modifier and Type	Method	Description
static String	QuantityFormatter.format(Quantity<?> quantity, QuantityFormat quantityFormat)	Format a quantity according to a given QuantityFormat.

Constructors in org.djunits.formatter with parameters of type Quantity

Modifier	Constructor	Description
(package private)	QuantityFormatter(Quantity<?> quantity, QuantityFormatContext ctx)

Uses of Quantity in org.djunits.quantity

Subclasses of Quantity in org.djunits.quantity

Modifier and Type	Class	Description
class	AbsorbedDose	Absorbed dose is the energy deposited by ionizing radiation per unit mass, measured in grays (Gy).
class	Acceleration	Acceleration is the rate of change of velocity over time, measured in meters per second squared (m/s2).
class	AmountOfSubstance	Amount of substance is the quantity representing the number of entities, measured in moles (mol).
class	Angle	Angle is the measure of rotation between two intersecting lines, expressed in radians (rad) or degrees.
class	AngularAcceleration	Angular acceleration is the rate of change of angular velocity over time, measured in radians per second squared (rad/s2).
class	AngularVelocity	Angular velocity is the rate of rotation around an axis, measured in radians per second (rad/s).
class	Area	Area is a measure of a two-dimensional surface, expressed in square meters (m2).
class	ArealObjectDensity	Areal object density counts the number of objects per unit of area, measured in number per square meter (/m2).
class	CatalyticActivity	Catalytic Activty is the rate of catalytic reaction per unit amount of catalyst, and is expressed in katal (kat), which is mol/s.
class	Density	Density is mass per unit volume of a substance, measured in kilograms per cubic meter (kg/m3).
class	Dimensionless	Dimensionless quantity.
class	Duration	Duration is the interval of time between two events, measured in seconds (s).
class	ElectricalCapacitance	ElectricalCapacitance denotes the ability of an object to store electric charge, and is expressed in farad.
class	ElectricalConductance	Electrical conductance measures the ease with which an electric current passes, and is expressed in siemens.
class	ElectricalInductance	Inductance is the tendency of an electrical conductor to oppose a change in the electric current flowing through it.
class	ElectricalResistance	Electrical resistence measures the opposition to the flow of an electric current, and is expressed in ohm.
class	ElectricCharge	Electric charge denotes the electrostatic attraction or repulsion in the presence of other matter with charge, and is expressed in coulomb.
class	ElectricCurrent	ElectricCurrent is the net rate of flow of electric charge through a surface.
class	ElectricPotential	ElectricPotential is the difference in electric potential energy per unit of electric charge between two points in a static electric field.
class	Energy	Energy is a physical quantity representing the capacity to do work, measured in joules (J).
class	EquivalentDose	Equivalent dose is a measure of radiation exposure accounting for biological effect, expressed in sieverts (Sv).
class	FlowMass	Flow mass: The rate of mass passing through a surface per unit time, measured in kilograms per second (kg/s).
class	FlowVolume	Flow volume is the rate of volume passing through a surface per unit time, measured in cubic meters per second (m3/s).
class	Force	Force is an interaction that changes the motion of an object, measured in newtons (N).
class	Frequency	Frequency encodes the number of events per unit of duration.
class	Illuminance	Illuminance is the luminous flux incident on a surface per unit area, measured in lux (lx).
class	Length	Length is the measure of distance between two points, expressed in meters (m).
class	LinearDensity	Linear density is mass per unit length of an object, measured in kilograms per meter (kg/m).
class	LinearObjectDensity	Linear object density counts the number of objects per unit of length, measured in number per meter (/m).
class	LuminousFlux	Luminous flux is the total perceived power of light emitted by a source, measured in lumens (lm).
class	LuminousIntensity	Luminous intensity is the luminous flux emitted per unit solid angle, measured in candelas (cd).
class	MagneticFlux	Magnetic flux is the total magnetic field passing through a given area, measured in webers (Wb).
class	MagneticFluxDensity	Magnetic flux density is the strength of the magnetic field per unit area, measured in teslas (T).
class	Mass	Mass is the amount of matter in an object, measured in kilograms (kg).
class	Momentum	Momentum is the product of an object's mass and velocity, measured in kilogram meters per second (kgm/s).
class	Power	Power is the rate of energy transfer or work done per unit time, measured in watts (W).
class	Pressure	Pressure is the force exerted per unit area, measured in pascals (Pa).
class	RadioActivity	Radioactivity is the rate of nuclear decay events, measured in becquerels (Bq).
class	SIQuantity	SI quantity, with arbitrary SI unit.
class	SolidAngle	Solid angle is the two-dimensional angle in three-dimensional space, measured in steradians (sr).
class	Speed	Speed is the rate of change of position over time.
class	TemperatureDifference	TemperatureDifference is a measure of (difference in) thermal state or average kinetic energy of particles, measured in kelvins (K).
class	Torque	Torque is a measure of rotational force about an axis, measured in newton meters (Nm).
class	Volume	Volume is the amount of three-dimensional space occupied by matter, measured in cubic meters (m3).
class	VolumetricObjectDensity	Volumetric object density counts the number of objects per unit of volume, measured in number per cubic meter (/m3).

Uses of Quantity in org.djunits.quantity.def

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

Modifier and Type	Class	Description
class	AbsQuantity<A extends AbsQuantity<A,Q,R>,Q extends Quantity<Q>,R extends Reference<R,A,Q>>	AbsQuantity stores the basic information about a absolute quantity and implements the basic operations that hold for all absolute quantities.
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.
class	ComparableAbsQuantity<A extends ComparableAbsQuantity<A,Q,R>,Q extends Quantity<Q>,R extends Reference<R,A,Q>>	ComparableAbsQuantity is an abstract class that stores the basic information about an absolute quantity that is comparable.
class	Quantity<Q extends Quantity<Q>>	Quantity is an abstract class that stores the basic information about a 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.

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

Modifier and Type	Method	Description
<TQ extends Quantity<TQ>> TQ	Quantity.as(UnitInterface<TQ> targetUnit)	Return the quantity 'as' a known quantity, using a unit to express the result in.
static <A extends ComparableAbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	ComparableAbsQuantity.interpolate(A zero, A one, double ratio)	Interpolate between two absolute quantities.
static <Q extends Quantity<Q>> Q	Quantity.interpolate(Q zero, Q one, double ratio)	Interpolate between two quantities.
static <A extends ComparableAbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	ComparableAbsQuantity.max(A quantity1, A... quantities)	Return the maximum value of one or more quantities.
static <Q extends Quantity<Q>> Q	Quantity.max(Q quantity1, Q... quantities)	Return the maximum value of one or more quantities.
static <A extends ComparableAbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	ComparableAbsQuantity.mean(A quantity1, A... quantities)	Return the mean of one or more quantities.
static <Q extends Quantity<Q>> Q	Quantity.mean(Q quantity1, Q... quantities)	Return the mean of one or more quantities.
static <A extends ComparableAbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> A	ComparableAbsQuantity.min(A quantity1, A... quantities)	Return the minimum value of one or more quantities.
static <Q extends Quantity<Q>> Q	Quantity.min(Q quantity1, Q... 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 <Q extends Quantity<Q>> Q	Quantity.of(double valueInUnit, String unitString, Q example)	Returns a quantity based on a value and the textual representation of the unit, which can be localized.
static <Q extends Quantity<Q>> Q	Quantity.sum(Q quantity1, Q... 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.
static <Q extends Quantity<Q>> Q	Quantity.valueOf(String text, Q example)	Returns a quantity for the textual representation of a value with a unit.

Methods in org.djunits.quantity.def that return Quantity

Modifier and Type	Method	Description
Quantity<?>	Quantity.reciprocal()	Return the reciprocal of this quantity (1/q).

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

Modifier and Type	Method	Description
SIQuantity	Quantity.divide(Quantity<?> quantity)	Divide this quantity by another quantity, and return a SIQuantity as the result.
static <Q extends Quantity<Q>> Q	Quantity.max(Q quantity1, Q... quantities)	Return the maximum value of one or more quantities.
static <Q extends Quantity<Q>> Q	Quantity.mean(Q quantity1, Q... quantities)	Return the mean of one or more quantities.
static <Q extends Quantity<Q>> Q	Quantity.min(Q quantity1, Q... quantities)	Return the minimum value of one or more quantities.
SIQuantity	Quantity.multiply(Quantity<?> quantity)	Multiply this quantity with another quantity, and return a SIQuantity as the result.
static SIQuantity	Quantity.product(Quantity<?> quantity1, Quantity<?>... quantities)	Return the product of one or more quantities.
static <Q extends Quantity<Q>> Q	Quantity.sum(Q quantity1, Q... quantities)	Return the sum of one or more quantities.

Uses of Quantity in org.djunits.unit

Classes in org.djunits.unit with type parameters of type Quantity

Modifier and Type	Class	Description
class	AbstractUnit<Q extends Quantity<Q>>	The AbstractUnit is the parent class of all units, and encodes the common behavior of the units.
interface	UnitInterface<Q extends Quantity<Q>>	UnitInterface defines the contract for a unit.

Uses of Quantity in org.djunits.value

Classes in org.djunits.value with type parameters of type Quantity

Modifier and Type	Interface	Description
interface	Value<Q extends Quantity<Q>>	Value is the generic interface for all Scalar, Vector and Matrix classes that forces implementation of a few unit- and value-related methods.

Uses of Quantity in org.djunits.vecmat.d1

Classes in org.djunits.vecmat.d1 with type parameters of type Quantity

Modifier and Type	Class	Description
class	AbsMatrix1x1<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	AbsMatrix1x1 implements a matrix with 1x1 absolute quantities with a reference point.
class	AbsVector1<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	AbsVector1 implements a vector with one real-valued entry representing an absolute quantity.
class	Matrix1x1<Q extends Quantity<Q>>	Matrix1x1 implements a matrix with 1x1 real-valued entries.
class	Vector1<Q extends Quantity<Q>>	Vector1 implements a vector with one real-valued entry.

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

Modifier and Type	Method	Description
<TQ extends Quantity<TQ>> Matrix1x1<TQ>	Matrix1x1.as(UnitInterface<TQ> targetUnit)	Return the matrix 'as' a matrix with a known quantity, using a unit to express the result in.
<TQ extends Quantity<TQ>> Vector1<TQ>	Vector1.as(UnitInterface<TQ> targetUnit)	Return the vector 'as' a vector with a known quantity, using a unit to express the result in.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix1x1<A,Q>	AbsMatrix1x1.of(double[][] gridInUnit, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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 <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.of(double[][] gridInUnit, UnitInterface<Q> unit)	Create a new Matrix1x1 with a unit, based on a 2-dimensional grid.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a Matrix1x1 without needing generics.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.of(double xInUnit, UnitInterface<Q> unit)	Create a Matrix1x1 without needing generics.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.of(Q data)	Create a Matrix1x1 without needing generics.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.of(Q[] data)	Create a Matrix1x1 without needing generics.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.of(Q[][] grid)	Create a Matrix1x1 without needing generics.
static <Q extends Quantity<Q>> Vector1<Q>	Vector1.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a Vector1 without needing generics.
static <Q extends Quantity<Q>> Vector1<Q>	Vector1.of(double xInUnit, UnitInterface<Q> unit)	Create a Vector1 without needing generics.
static <Q extends Quantity<Q>> Vector1<Q>	Vector1.of(Q x)	Create a Vector1 without needing generics.
static <Q extends Quantity<Q>> Vector1<Q>	Vector1.of(Q[] data)	Create a Vector1 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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<Q> displayUnit, R reference)	Create an AbsVector1 without needing generics.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.ofSi(double[][] gridSi, UnitInterface<Q> displayUnit)	Create a new Matrix1x1 with a unit, based on a 2-dimensional grid with SI-values.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a Matrix1x1 without needing generics.
static <Q extends Quantity<Q>> Vector1<Q>	Vector1.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a Vector1 without needing generics.
static <Q extends Quantity<Q>> Vector1<Q>	Vector1.ofSi(double xSi, UnitInterface<Q> displayUnit)	Create a Vector1 without needing generics.

Methods in org.djunits.vecmat.d1 that return Quantity

Modifier and Type	Method	Description
Q[]	Vector1.getScalarArray()

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

Modifier and Type	Method	Description
Matrix1x1<SIQuantity>	Matrix1x1.multiplyEntries(Quantity<?> quantity)
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>> AbsVector1<A,Q>	AbsVector1.of(Q[] data, R reference)	Create an AbsVector1 without needing generics.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.of(Q[] data)	Create a Matrix1x1 without needing generics.
static <Q extends Quantity<Q>> Matrix1x1<Q>	Matrix1x1.of(Q[][] grid)	Create a Matrix1x1 without needing generics.
static <Q extends Quantity<Q>> Vector1<Q>	Vector1.of(Q[] data)	Create a Vector1 without needing generics.

Uses of Quantity in org.djunits.vecmat.d2

Classes in org.djunits.vecmat.d2 with type parameters of type Quantity

Modifier and Type	Class	Description
class	AbsMatrix2x2<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	AbsMatrix2x2 implements a matrix with 2x2 absolute quantities with a reference point.
class	AbsVector2<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,VA extends AbsVector2<A,Q,VA,VQ,VAT>,VQ extends Vector2<Q,VQ,?,?,?>,VAT extends AbsVector2<A,Q,VAT,?,VA>>	AbsVector2 implements a vector with two real-valued entries representing an absolute quantity.
static class	AbsVector2.Col<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	Column vector for AbsVector2 with absolute quantities.
static class	AbsVector2.Row<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	Row vector for AbsVector2 with absolute quantities.
class	Matrix2x2<Q extends Quantity<Q>>	Matrix2x2 implements a matrix with 2x2 real-valued entries.
class	Vector2<Q extends Quantity<Q>,V extends Vector2<Q,V,SI,H,VT>,SI extends Vector2<SIQuantity,SI,?,?,?>,H extends Vector2<?,?,?,?,?>,VT extends Vector2<Q,VT,?,?,V>>	Vector2 implements a vector with two real-valued entries.
static class	Vector2.Col<Q extends Quantity<Q>>	Vector2.Col implements a column vector with two real-valued entries.
static class	Vector2.Row<Q extends Quantity<Q>>	Vector2.Row implements a row vector with two real-valued entries.

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

Modifier and Type	Method	Description
<TQ extends Quantity<TQ>> Matrix2x2<TQ>	Matrix2x2.as(UnitInterface<TQ> targetUnit)	Return the matrix 'as' a matrix with a known quantity, using a unit to express the result in.
<TQ extends Quantity<TQ>> Vector2.Col<TQ>	Vector2.Col.as(UnitInterface<TQ> targetUnit)	Return the vector 'as' a vector with a known quantity, using a unit to express the result in.
<TQ extends Quantity<TQ>> Vector2.Row<TQ>	Vector2.Row.as(UnitInterface<TQ> targetUnit)	Return the vector 'as' a vector with a known quantity, using a unit to express the result in.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix2x2<A,Q>	AbsMatrix2x2.of(double[][] gridInUnit, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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 <Q extends Quantity<Q>> Matrix2x2<Q>	Matrix2x2.of(double[][] gridInUnit, UnitInterface<Q> unit)	Create a new Matrix2x2 with a unit, based on a 2-dimensional grid with values in the given unit.
static <Q extends Quantity<Q>> Matrix2x2<Q>	Matrix2x2.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a new Matrix2x2 with a unit, based on a row-major array with values in the given unit.
static <Q extends Quantity<Q>> Matrix2x2<Q>	Matrix2x2.of(Q[] data)	Create a Matrix2x2 without needing generics, based on a row-major array of quantities.
static <Q extends Quantity<Q>> Matrix2x2<Q>	Matrix2x2.of(Q[][] grid)	Create a Matrix2x2 without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> Vector2.Col<Q>	Vector2.Col.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a Vector2.Col without needing generics.
static <Q extends Quantity<Q>> Vector2.Col<Q>	Vector2.Col.of(double xInUnit, double yInUnit, UnitInterface<Q> unit)	Create a Vector2.Col without needing generics.
static <Q extends Quantity<Q>> Vector2.Col<Q>	Vector2.Col.of(Q[] data)	Create a Vector2.Col without needing generics.
static <Q extends Quantity<Q>> Vector2.Col<Q>	Vector2.Col.of(Q x, Q y)	Create a Vector2.Col without needing generics.
static <Q extends Quantity<Q>> Vector2.Row<Q>	Vector2.Row.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a Vector2.Row without needing generics.
static <Q extends Quantity<Q>> Vector2.Row<Q>	Vector2.Row.of(double xInUnit, double yInUnit, UnitInterface<Q> unit)	Create a Vector2.Row without needing generics.
static <Q extends Quantity<Q>> Vector2.Row<Q>	Vector2.Row.of(Q[] data)	Create a Vector2.Row without needing generics.
static <Q extends Quantity<Q>> Vector2.Row<Q>	Vector2.Row.of(Q x, Q y)	Create a Vector2.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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<Q> displayUnit, R reference)	Create a AbsVector2.Row without needing generics.
static <Q extends Quantity<Q>> Matrix2x2<Q>	Matrix2x2.ofSi(double[][] gridSi, UnitInterface<Q> displayUnit)	Create a new Matrix2x2 with a unit, based on a 2-dimensional grid with SI-values.
static <Q extends Quantity<Q>> Matrix2x2<Q>	Matrix2x2.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a Matrix2x2 without needing generics, based on a row-major array with SI-values.
static <Q extends Quantity<Q>> Vector2.Col<Q>	Vector2.Col.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a Vector2.Col without needing generics.
static <Q extends Quantity<Q>> Vector2.Col<Q>	Vector2.Col.ofSi(double xSi, double ySi, UnitInterface<Q> displayUnit)	Create a Vector2.Col without needing generics.
static <Q extends Quantity<Q>> Vector2.Row<Q>	Vector2.Row.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a Vector2.Row without needing generics.
static <Q extends Quantity<Q>> Vector2.Row<Q>	Vector2.Row.ofSi(double xSi, double ySi, UnitInterface<Q> displayUnit)	Create a Vector2.Row without needing generics.

Methods in org.djunits.vecmat.d2 that return Quantity

Modifier and Type	Method	Description
Q[]	Vector2.getScalarArray()

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

Modifier and Type	Method	Description
Matrix2x2<SIQuantity>	Matrix2x2.multiplyEntries(Quantity<?> quantity)
Vector2.Col<SIQuantity>	Vector2.Col.multiplyEntries(Quantity<?> quantity)
Vector2.Row<SIQuantity>	Vector2.Row.multiplyEntries(Quantity<?> quantity)
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(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.Row<A,Q>	AbsVector2.Row.of(Q[] data, R reference)	Create a AbsVector2.Row without needing generics.
static <Q extends Quantity<Q>> Matrix2x2<Q>	Matrix2x2.of(Q[] data)	Create a Matrix2x2 without needing generics, based on a row-major array of quantities.
static <Q extends Quantity<Q>> Matrix2x2<Q>	Matrix2x2.of(Q[][] grid)	Create a Matrix2x2 without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> Vector2.Col<Q>	Vector2.Col.of(Q[] data)	Create a Vector2.Col without needing generics.
static <Q extends Quantity<Q>> Vector2.Row<Q>	Vector2.Row.of(Q[] data)	Create a Vector2.Row without needing generics.

Uses of Quantity in org.djunits.vecmat.d3

Classes in org.djunits.vecmat.d3 with type parameters of type Quantity

Modifier and Type	Class	Description
class	AbsMatrix3x3<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	AbsMatrix3x3 implements a matrix with 3x3 absolute quantities with a reference point.
class	AbsVector3<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,VA extends AbsVector3<A,Q,VA,VQ,VAT>,VQ extends Vector3<Q,VQ,?,?,?>,VAT extends AbsVector3<A,Q,VAT,?,VA>>	AbsVector3 implements a vector with three real-valued entries representing an absolute quantity.
static class	AbsVector3.Col<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	Column vector for AbsVector3 with absolute quantities.
static class	AbsVector3.Row<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	Row vector for AbsVector3 with absolute quantities.
class	Matrix3x3<Q extends Quantity<Q>>	Matrix3x3 implements a matrix with 3x3 real-valued entries.
class	Vector3<Q extends Quantity<Q>,V extends Vector3<Q,V,SI,H,VT>,SI extends Vector3<SIQuantity,SI,?,?,?>,H extends Vector3<?,?,?,?,?>,VT extends Vector3<Q,VT,?,?,V>>	Vector3 implements a vector with three real-valued entries.
static class	Vector3.Col<Q extends Quantity<Q>>	Vector3.Col implements a column vector with three real-valued entries.
static class	Vector3.Row<Q extends Quantity<Q>>	Vector3.Row implements a row vector with three real-valued entries.

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

Modifier and Type	Method	Description
<TQ extends Quantity<TQ>> Matrix3x3<TQ>	Matrix3x3.as(UnitInterface<TQ> targetUnit)	Return the matrix 'as' a matrix with a known quantity, using a unit to express the result in.
<TQ extends Quantity<TQ>> Vector3.Col<TQ>	Vector3.Col.as(UnitInterface<TQ> targetUnit)	Return the vector 'as' a vector with a known quantity, using a unit to express the result in.
<TQ extends Quantity<TQ>> Vector3.Row<TQ>	Vector3.Row.as(UnitInterface<TQ> targetUnit)	Return the vector 'as' a vector with a known quantity, using a unit to express the result in.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrix3x3<A,Q>	AbsMatrix3x3.of(double[][] gridInUnit, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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 <Q extends Quantity<Q>> Matrix3x3<Q>	Matrix3x3.of(double[][] gridInUnit, UnitInterface<Q> unit)	Create a new Matrix3x3 with a unit, based on a 2-dimensional grid with values in the given unit.
static <Q extends Quantity<Q>> Matrix3x3<Q>	Matrix3x3.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a new Matrix3x3 with a unit, based on a row-major array with values in the given unit.
static <Q extends Quantity<Q>> Matrix3x3<Q>	Matrix3x3.of(Q[] data)	Create a Matrix3x3 without needing generics, based on a row-major array of quantities.
static <Q extends Quantity<Q>> Matrix3x3<Q>	Matrix3x3.of(Q[][] grid)	Create a Matrix3x3 without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> Vector3.Col<Q>	Vector3.Col.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a Vector3.Col without needing generics.
static <Q extends Quantity<Q>> Vector3.Col<Q>	Vector3.Col.of(double xInUnit, double yInUnit, double zInUnit, UnitInterface<Q> unit)	Create a Vector3.Col without needing generics.
static <Q extends Quantity<Q>> Vector3.Col<Q>	Vector3.Col.of(Q[] data)	Create a Vector3.Col without needing generics.
static <Q extends Quantity<Q>> Vector3.Col<Q>	Vector3.Col.of(Q x, Q y, Q z)	Create a Vector3.Col without needing generics.
static <Q extends Quantity<Q>> Vector3.Row<Q>	Vector3.Row.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a Vector3.Row without needing generics.
static <Q extends Quantity<Q>> Vector3.Row<Q>	Vector3.Row.of(double xInUnit, double yInUnit, double zInUnit, UnitInterface<Q> unit)	Create a Vector3.Row without needing generics.
static <Q extends Quantity<Q>> Vector3.Row<Q>	Vector3.Row.of(Q[] data)	Create a Vector3.Row without needing generics.
static <Q extends Quantity<Q>> Vector3.Row<Q>	Vector3.Row.of(Q x, Q y, Q z)	Create a Vector3.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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<Q> displayUnit, R reference)	Create a AbsVector3.Row without needing generics.
static <Q extends Quantity<Q>> Matrix3x3<Q>	Matrix3x3.ofSi(double[][] gridSi, UnitInterface<Q> displayUnit)	Create a new Matrix3x3 with a unit, based on a 2-dimensional grid with SI-values.
static <Q extends Quantity<Q>> Matrix3x3<Q>	Matrix3x3.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a Matrix3x3 without needing generics, based on a row-major array with SI-values.
static <Q extends Quantity<Q>> Vector3.Col<Q>	Vector3.Col.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a Vector3.Col without needing generics.
static <Q extends Quantity<Q>> Vector3.Col<Q>	Vector3.Col.ofSi(double xSi, double ySi, double zSi, UnitInterface<Q> displayUnit)	Create a Vector3.Col without needing generics.
static <Q extends Quantity<Q>> Vector3.Row<Q>	Vector3.Row.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a Vector3.Row without needing generics.
static <Q extends Quantity<Q>> Vector3.Row<Q>	Vector3.Row.ofSi(double xSi, double ySi, double zSi, UnitInterface<Q> displayUnit)	Create a Vector3.Row without needing generics.

Methods in org.djunits.vecmat.d3 that return Quantity

Modifier and Type	Method	Description
Q[]	Vector3.getScalarArray()

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

Modifier and Type	Method	Description
Matrix3x3<SIQuantity>	Matrix3x3.multiplyEntries(Quantity<?> quantity)
Vector3.Col<SIQuantity>	Vector3.Col.multiplyEntries(Quantity<?> quantity)
Vector3.Row<SIQuantity>	Vector3.Row.multiplyEntries(Quantity<?> quantity)
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(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.Row<A,Q>	AbsVector3.Row.of(Q[] data, R reference)	Create a AbsVector3.Row without needing generics.
static <Q extends Quantity<Q>> Matrix3x3<Q>	Matrix3x3.of(Q[] data)	Create a Matrix3x3 without needing generics, based on a row-major array of quantities.
static <Q extends Quantity<Q>> Matrix3x3<Q>	Matrix3x3.of(Q[][] grid)	Create a Matrix3x3 without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> Vector3.Col<Q>	Vector3.Col.of(Q[] data)	Create a Vector3.Col without needing generics.
static <Q extends Quantity<Q>> Vector3.Row<Q>	Vector3.Row.of(Q[] data)	Create a Vector3.Row without needing generics.

Uses of Quantity in org.djunits.vecmat.def

Classes in org.djunits.vecmat.def with type parameters of type Quantity

Modifier and Type	Class	Description
class	AbsMatrix<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,MA extends AbsMatrix<A,Q,MA,MQ,MAT>,MQ extends Matrix<Q,MQ,?,?,?>,MAT extends AbsMatrix<A,Q,MAT,?,MA>>	AbsMatrix contains a number of standard operations on matrices that contain absolute quantities.
class	AbsSquareMatrix<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,MA extends AbsSquareMatrix<A,Q,MA,MQ>,MQ extends SquareMatrix<Q,MQ,?,?>>	AbsSquareMatrix defines a number of operations that can be applied to square matrixes with absolute quantity values.
class	AbsTable<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,MA extends AbsTable<A,Q,MA,MQ,MAT>,MQ extends Table<Q,MQ,?,?,?>,MAT extends AbsTable<A,Q,MAT,?,MA>>	AbsTable contains a number of standard operations on 2-dimensional tables that contain absolute quantities.
class	AbsVector<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,VA extends AbsVector<A,Q,VA,VQ,VAT>,VQ extends Vector<Q,VQ,?,?,?>,VAT extends AbsVector<A,Q,VAT,?,VA>>	AbsVector contains the contract for Vector classes with absolute values.
static interface	AbsVector.Col<V extends Value<Q>,Q extends Quantity<Q>>	Formatting methods for absolute column vector.
static interface	AbsVector.Row<V extends Value<Q>,Q extends Quantity<Q>>	Formatting methods for absolute row vector.
class	AbsVectorMatrix<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,VMA extends AbsVectorMatrix<A,Q,VMA,VMQ,VMAT>,VMQ extends VectorMatrix<Q,VMQ,?,?,?>,VMAT extends AbsVectorMatrix<A,Q,VMAT,?,VMA>>	AbsVectorMatrix contains a number of standard operations on vectors and matrices of absolute quantities.
class	Matrix<Q extends Quantity<Q>,M extends Matrix<Q,M,SI,H,MT>,SI extends Matrix<SIQuantity,SI,?,?,?>,H extends Matrix<?,?,?,?,?>,MT extends Matrix<Q,MT,?,?,M>>	Matrix contains a number of standard operations on matrices of relative quantities.
class	SquareDenseMatrix<Q extends Quantity<Q>,M extends SquareDenseMatrix<Q,M,SI,H>,SI extends SquareDenseMatrix<SIQuantity,SI,?,?>,H extends SquareDenseMatrix<?,?,?,?>>	SquareDenseMatrix implements the core functions for a matrix with n x n real-valued entries.
class	SquareMatrix<Q extends Quantity<Q>,M extends SquareMatrix<Q,M,SI,H>,SI extends SquareMatrix<SIQuantity,SI,?,?>,H extends SquareMatrix<?,?,?,?>>	SquareMatrix defines a number of operations that can be applied to square matrixes, such as transpose, invert, and determinant.
class	Table<Q extends Quantity<Q>,T extends Table<Q,T,SI,H,TT>,SI extends Table<SIQuantity,SI,?,?,?>,H extends Table<?,?,?,?,?>,TT extends Table<Q,TT,?,?,T>>	Table contains a number of standard operations on 2-dimensional tables of relative quantities.
class	Vector<Q extends Quantity<Q>,V extends Vector<Q,V,SI,H,VT>,SI extends Vector<SIQuantity,SI,?,?,?>,H extends Vector<?,?,?,?,?>,VT extends Vector<Q,VT,?,?,V>>	Vector contains the contract for Vector classes that contain relative quantity values.
static interface	Vector.Col<V extends Value<Q>,Q extends Quantity<Q>>	Formatting methods for column vector.
static interface	Vector.Row<V extends Value<Q>,Q extends Quantity<Q>>	Formatting methods for row vector.
class	VectorMatrix<Q extends Quantity<Q>,VM extends VectorMatrix<Q,VM,SI,H,VMT>,SI extends VectorMatrix<SIQuantity,SI,?,?,?>,H extends VectorMatrix<?,?,?,?,?>,VMT extends VectorMatrix<Q,VMT,?,?,VM>>	VectorMatrix contains a number of standard operations on vectors and matrices of relative quantities.

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

Modifier and Type	Method	Description
Q[]	Table.getColumnScalars(int col)	Retrieve a column (0-based) from the table or matrix as an array of scalars.
Q[]	SquareMatrix.getDiagonalScalars()	Retrieve the main diagonal of the matrix as an array of scalars.
Q[]	Table.getRowScalars(int row)	Retrieve a row (0-based) from the table or matrix as an array of scalars.
Q[]	Table.getScalarArray()	Return a row-major array of quantities for this QuantityTable.
abstract Q[]	Vector.getScalarArray()	Return the vector as an array of scalars.
Q[][]	Table.getScalarGrid()	Return the table or matrix as a 2D array of scalars.
Q[]	Table.mgetColumnScalars(int mCol)	Retrieve a column (1-based) from the table or matrix as an array of scalars.
Q[]	Table.mgetRowScalars(int mRow)	Retrieve a row (1-based) from the table or matrix as an array of scalars.

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

Modifier and Type	Method	Description
SI	VectorMatrix.multiplyEntries(Quantity<?> quantity)

Uses of Quantity in org.djunits.vecmat.dn

Classes in org.djunits.vecmat.dn with type parameters of type Quantity

Modifier and Type	Class	Description
class	AbsMatrixNxN<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	AbsMatrixNxN implements a matrix with NxN absolute quantities with a reference point.
class	AbsVectorN<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>,VA extends AbsVectorN<A,Q,VA,VQ,VAT>,VQ extends VectorN<Q,VQ,?,?,?>,VAT extends AbsVectorN<A,Q,VAT,?,VA>>	AbsVectorN implements a vector with three real-valued entries representing an absolute quantity.
static class	AbsVectorN.Col<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	Column vector for AbsVectorN with absolute quantities.
static class	AbsVectorN.Row<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	Row vector for AbsVectorN with absolute quantities.
class	MatrixNxN<Q extends Quantity<Q>>	MatrixNxN implements a square matrix with NxN real-valued entries.
class	VectorN<Q extends Quantity<Q>,V extends VectorN<Q,V,SI,H,VT>,SI extends VectorN<SIQuantity,SI,?,?,?>,H extends VectorN<?,?,?,?,?>,VT extends VectorN<Q,VT,?,?,V>>	VectorN.java.
static class	VectorN.Col<Q extends Quantity<Q>>	VectorN.Col implements a column vector with real-valued entries.
static class	VectorN.Row<Q extends Quantity<Q>>	VectorN.Row implements a row vector with real-valued entries.

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

Modifier and Type	Method	Description
<TQ extends Quantity<TQ>> MatrixNxN<TQ>	MatrixNxN.as(UnitInterface<TQ> targetUnit)	Return the matrix "as" a matrix with a known quantity, using a unit to express the result in.
<TQ extends Quantity<TQ>> VectorN.Col<TQ>	VectorN.Col.as(UnitInterface<TQ> targetUnit)	Return the vector 'as' a vector with a known quantity, using a unit to express the result in.
<TQ extends Quantity<TQ>> VectorN.Row<TQ>	VectorN.Row.as(UnitInterface<TQ> targetUnit)	Return the vector 'as' a vector with a known quantity, using a unit to express the result in.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.of(double[][] gridInUnit, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<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 <Q extends Quantity<Q>> MatrixNxN<Q>	MatrixNxN.of(double[][] gridInUnit, UnitInterface<Q> unit)	Create a new MatrixNxN with a unit, based on a 2-dimensional grid with values in the given unit.
static <Q extends Quantity<Q>> MatrixNxN<Q>	MatrixNxN.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a new MatrixNxN with a unit, based on a row-major array with values in the given unit.
static <Q extends Quantity<Q>> MatrixNxN<Q>	MatrixNxN.of(Q[] data)	Create a MatrixNxN without needing generics, based on a row-major array of quantities.
static <Q extends Quantity<Q>> MatrixNxN<Q>	MatrixNxN.of(Q[][] grid)	Create a MatrixNxN without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> VectorN.Col<Q>	VectorN.Col.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a new column VectorN with a unit, based on a double[] array that contains data in the given unit.
static <Q extends Quantity<Q>> VectorN.Col<Q>	VectorN.Col.of(List<Q> data)	Create a new column VectorN with a unit, based on a quantity list that contains data.
static <Q extends Quantity<Q>> VectorN.Col<Q>	VectorN.Col.of(Q[] data)	Create a new column VectorN with a unit, based on a quantity array that contains data.
static <Q extends Quantity<Q>> VectorN.Row<Q>	VectorN.Row.of(double[] dataInUnit, UnitInterface<Q> unit)	Create a new row VectorN with a unit, based on a double[] array that contains data in the given unit.
static <Q extends Quantity<Q>> VectorN.Row<Q>	VectorN.Row.of(List<Q> data)	Create a new row VectorN with a unit, based on a quantity list that contains data.
static <Q extends Quantity<Q>> VectorN.Row<Q>	VectorN.Row.of(Q[] data)	Create a new row VectorN with a unit, based on a quantity array that contains data.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxN<A,Q>	AbsMatrixNxN.ofSi(double[][] gridSi, UnitInterface<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, UnitInterface<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, UnitInterface<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, UnitInterface<Q> displayUnit, R reference)	Create a AbsVectorN.Row without needing generics.
static <Q extends Quantity<Q>> MatrixNxN<Q>	MatrixNxN.ofSi(double[][] gridSi, UnitInterface<Q> displayUnit)	Create a new MatrixNxN with a unit, based on a 2-dimensional grid with SI-values.
static <Q extends Quantity<Q>> MatrixNxN<Q>	MatrixNxN.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a MatrixNxN without needing generics, based on a row-major array with SI-values.
static <Q extends Quantity<Q>> VectorN.Col<Q>	VectorN.Col.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a new column VectorN with a unit, based on a double[] array that contains SI data.
static <Q extends Quantity<Q>> VectorN.Col<Q>	VectorN.Col.ofSi(DataGridSi<?> dataSi, UnitInterface<Q> displayUnit)	Create a new column VectorN with a unit, based on a DataGridSi storage object that contains SI data.
static <Q extends Quantity<Q>> VectorN.Row<Q>	VectorN.Row.ofSi(double[] dataSi, UnitInterface<Q> displayUnit)	Create a new row VectorN with a unit, based on a double[] array that contains SI data.
static <Q extends Quantity<Q>> VectorN.Row<Q>	VectorN.Row.ofSi(DataGridSi<?> dataSi, UnitInterface<Q> displayUnit)	Create a new row VectorN with a unit, based on a DataGridSi storage object that contains SI data.

Methods in org.djunits.vecmat.dn that return Quantity

Modifier and Type	Method	Description
Q[]	VectorN.getScalarArray()

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

Modifier and Type	Method	Description
MatrixNxN<SIQuantity>	MatrixNxN.multiplyEntries(Quantity<?> quantity)
VectorN.Col<SIQuantity>	VectorN.Col.multiplyEntries(Quantity<?> quantity)
VectorN.Row<SIQuantity>	VectorN.Row.multiplyEntries(Quantity<?> quantity)
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(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(Q[] data, R reference)	Create a AbsVectorN.Row without needing generics.
static <Q extends Quantity<Q>> MatrixNxN<Q>	MatrixNxN.of(Q[] data)	Create a MatrixNxN without needing generics, based on a row-major array of quantities.
static <Q extends Quantity<Q>> MatrixNxN<Q>	MatrixNxN.of(Q[][] grid)	Create a MatrixNxN without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> VectorN.Col<Q>	VectorN.Col.of(Q[] data)	Create a new column VectorN with a unit, based on a quantity array that contains data.
static <Q extends Quantity<Q>> VectorN.Row<Q>	VectorN.Row.of(Q[] data)	Create a new row VectorN with a unit, based on a quantity array that contains data.

Uses of Quantity in org.djunits.vecmat.dnxm

Classes in org.djunits.vecmat.dnxm with type parameters of type Quantity

Modifier and Type	Class	Description
class	AbsMatrixNxM<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	AbsMatrixNxM implements a matrix with NxM absolute quantities with a reference point.
class	MatrixNxM<Q extends Quantity<Q>>	MatrixNxM implements a matrix with NxM real-valued entries.

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

Modifier and Type	Method	Description
<TQ extends Quantity<TQ>> MatrixNxM<TQ>	MatrixNxM.as(UnitInterface<TQ> targetUnit)	Return the matrix 'as' a matrix with a known quantity, using a unit to express the result in.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsMatrixNxM<A,Q>	AbsMatrixNxM.of(double[][] gridInUnit, UnitInterface<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, UnitInterface<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 <Q extends Quantity<Q>> MatrixNxM<Q>	MatrixNxM.of(double[][] gridInUnit, UnitInterface<Q> unit)	Create a new MatrixNxM with a unit, based on a 2-dimensional grid with values in the given unit.
static <Q extends Quantity<Q>> MatrixNxM<Q>	MatrixNxM.of(double[] dataInUnit, int rows, int cols, UnitInterface<Q> unit)	Create a new MatrixNxM with a unit, based on a row-major array with values in the given unit.
static <Q extends Quantity<Q>> MatrixNxM<Q>	MatrixNxM.of(Q[][] grid)	Create a MatrixNxM without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> MatrixNxM<Q>	MatrixNxM.of(Q[] data, int rows, int cols)	Create a MatrixNxM 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, UnitInterface<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, UnitInterface<Q> displayUnit, R reference)	Create a AbsMatrixNxM without needing generics, based on a row-major array with SI-values.
static <Q extends Quantity<Q>> MatrixNxM<Q>	MatrixNxM.ofSi(double[][] gridSi, UnitInterface<Q> displayUnit)	Create a new MatrixNxM with a unit, based on a 2-dimensional grid with SI-values.
static <Q extends Quantity<Q>> MatrixNxM<Q>	MatrixNxM.ofSi(double[] dataSi, int rows, int cols, UnitInterface<Q> displayUnit)	Create a MatrixNxM without needing generics, based on a row-major array with SI-values.

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

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(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 <Q extends Quantity<Q>> MatrixNxM<Q>	MatrixNxM.of(Q[][] grid)	Create a MatrixNxM without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> MatrixNxM<Q>	MatrixNxM.of(Q[] data, int rows, int cols)	Create a MatrixNxM without needing generics, based on a row-major array of quantities.

Uses of Quantity in org.djunits.vecmat.operations

Classes in org.djunits.vecmat.operations with type parameters of type Quantity

Modifier and Type	Interface	Description
interface	Normed<Q extends Quantity<Q>>	Normed calculates a norm of an element, expressed as a quantity.

Methods in org.djunits.vecmat.operations with parameters of type Quantity

Modifier and Type	Method	Description
default SI	Hadamard.divideEntries(Quantity<?> quantity)	Divide the entries of this vector, matrix or table by the given quantity.
SI	Hadamard.multiplyEntries(Quantity<?> quantity)	Multiply the entries of this vector, matrix or table by the given quantity.

Uses of Quantity in org.djunits.vecmat.storage

Classes in org.djunits.vecmat.storage with type parameters of type Quantity

Modifier and Type	Class	Description
class	DoubleSparseValue<Q extends Quantity<Q>>	Double-precision data point for a matrix that can be used for constructing sparse matrices.
class	FloatSparseValue<Q extends Quantity<Q>>	Float-precision data point for a matrix that can be used for constructing sparse matrices.

Methods in org.djunits.vecmat.storage with type parameters of type Quantity

Modifier and Type	Method	Description
static <Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(double[][] gridInUnit, UnitInterface<Q> unit)	Instantiate a data object based on a row x column double[][] array in a given unit.
static <Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(double[] dataInUnit, int rows, int cols, UnitInterface<Q> unit)	Instantiate a data object based on a row-major double[] array in a given unit.
static <A extends AbsQuantity<A, Q, ?>, Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(A[][] absGrid)	Instantiate a data object with a A[rows][cols].
static <A extends AbsQuantity<A, Q, ?>, Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(A[] absData, int rows, int cols)	Instantiate a data object based on a row-major A[] array.
static <A extends AbsQuantity<A, Q, ?>, Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(List<A> absData, int rows, int cols)	Instantiate a data object based on a row-major list of absolute quantities.
static <Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(Q[][] grid)	Instantiate a data object with a Q[rows][cols].
static <Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(Q[] data, int rows, int cols)	Instantiate a data object based on a row-major Q[] array.
static <Q extends Quantity<Q>> DenseFloatDataSi	DenseFloatDataSi.of(double[][] gridInUnit, UnitInterface<Q> unit)	Instantiate a data object with a double[rows][cols].
static <Q extends Quantity<Q>> DenseFloatDataSi	DenseFloatDataSi.of(double[] dataInUnit, int rows, int cols, UnitInterface<Q> unit)	Instantiate a data object with one array in row-major format.
static <Q extends Quantity<Q>> DenseFloatDataSi	DenseFloatDataSi.of(float[][] gridInUnit, UnitInterface<Q> unit)	Instantiate a data object with a float[rows][cols].
static <Q extends Quantity<Q>> DenseFloatDataSi	DenseFloatDataSi.of(float[] dataInUnit, int rows, int cols, UnitInterface<Q> unit)	Instantiate a data object with one array in row-major format.
static <Q extends Quantity<Q>> DenseFloatDataSi	DenseFloatDataSi.of(Q[][] grid)	Instantiate a data object with a Q[rows][cols].
static <Q extends Quantity<Q>> DenseFloatDataSi	DenseFloatDataSi.of(Q[] data, int rows, int cols)	Instantiate a data object with one array in row-major format.
<Q extends Quantity<Q>> void	SparseDoubleDataSi.storeSparse(Q[] denseData)	Store sparse data[] and indexes[].
<Q extends Quantity<Q>> void	SparseDoubleDataSi.storeSparse(Q[][] denseData)	Store sparse data[] and indexes[].
<Q extends Quantity<Q>> void	SparseFloatDataSi.storeSparse(Q[] denseData)	Store sparse data[] and indexes[].
<Q extends Quantity<Q>> void	SparseFloatDataSi.storeSparse(Q[][] denseData)	Store sparse data[] and indexes[].

Methods in org.djunits.vecmat.storage with parameters of type Quantity

Modifier and Type	Method	Description
static <Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(Q[][] grid)	Instantiate a data object with a Q[rows][cols].
static <Q extends Quantity<Q>> DenseDoubleDataSi	DenseDoubleDataSi.of(Q[] data, int rows, int cols)	Instantiate a data object based on a row-major Q[] array.
static <Q extends Quantity<Q>> DenseFloatDataSi	DenseFloatDataSi.of(Q[][] grid)	Instantiate a data object with a Q[rows][cols].
static <Q extends Quantity<Q>> DenseFloatDataSi	DenseFloatDataSi.of(Q[] data, int rows, int cols)	Instantiate a data object with one array in row-major format.
<Q extends Quantity<Q>> void	SparseDoubleDataSi.storeSparse(Q[] denseData)	Store sparse data[] and indexes[].
<Q extends Quantity<Q>> void	SparseDoubleDataSi.storeSparse(Q[][] denseData)	Store sparse data[] and indexes[].
<Q extends Quantity<Q>> void	SparseFloatDataSi.storeSparse(Q[] denseData)	Store sparse data[] and indexes[].
<Q extends Quantity<Q>> void	SparseFloatDataSi.storeSparse(Q[][] denseData)	Store sparse data[] and indexes[].

Constructors in org.djunits.vecmat.storage with parameters of type Quantity

Modifier	Constructor	Description
	SparseDoubleDataSi(Q[][] denseData)	Instantiate a data object with a dense double[rows][cols].
	SparseDoubleDataSi(Q[] sparseData, int[] indexes, int rows, int cols)	Instantiate a data object with one array in row-major format.
	SparseDoubleDataSi(Q[] denseData, int rows, int cols)	Instantiate a data object with one array in row-major format.
	SparseFloatDataSi(Q[][] denseData)	Instantiate a data object with a dense double[rows][cols].
	SparseFloatDataSi(Q[] sparseData, int[] indexes, int rows, int cols)	Instantiate a data object with one array in row-major format.
	SparseFloatDataSi(Q[] denseData, int rows, int cols)	Instantiate a data object with one array in row-major format.

Uses of Quantity in org.djunits.vecmat.table

Classes in org.djunits.vecmat.table with type parameters of type Quantity

Modifier and Type	Class	Description
class	AbsQuantityTable<A extends AbsQuantity<A,Q,?>,Q extends Quantity<Q>>	AbsQuantityTable implements a table containing absolute quantities with a reference point.
class	QuantityTable<Q extends Quantity<Q>>	QuantityTable is a two-dimensonal table with quantities.

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

Modifier and Type	Method	Description
<TQ extends Quantity<TQ>> QuantityTable<TQ>	QuantityTable.as(UnitInterface<TQ> targetUnit)	Return the QuantityTable 'as' a QuantityTable with a known quantity, using a unit to express the result in.
static <A extends AbsQuantity<A, Q, R>, Q extends Quantity<Q>, R extends Reference<R, A, Q>> AbsQuantityTable<A,Q>	AbsQuantityTable.of(double[][] gridInUnit, UnitInterface<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, UnitInterface<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 <Q extends Quantity<Q>> QuantityTable<Q>	QuantityTable.of(double[][] gridInUnit, UnitInterface<Q> unit)	Create a new QuantityTable with a unit, based on a 2-dimensional grid with values in the given unit.
static <Q extends Quantity<Q>> QuantityTable<Q>	QuantityTable.of(double[] dataInUnit, int rows, int cols, UnitInterface<Q> unit)	Create a new QuantityTable with a unit, based on a row-major array with values in the given unit.
static <Q extends Quantity<Q>> QuantityTable<Q>	QuantityTable.of(Q[][] grid)	Create a QuantityTable without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> QuantityTable<Q>	QuantityTable.of(Q[] data, int rows, int cols)	Create a QuantityTable 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, UnitInterface<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, UnitInterface<Q> displayUnit, R reference)	Create a AbsQuantityTable without needing generics, based on a row-major array with SI-values.
static <Q extends Quantity<Q>> QuantityTable<Q>	QuantityTable.ofSi(double[][] gridSi, UnitInterface<Q> displayUnit)	Create a new QuantityTable with a unit, based on a 2-dimensional grid with SI-values.
static <Q extends Quantity<Q>> QuantityTable<Q>	QuantityTable.ofSi(double[] dataSi, int rows, int cols, UnitInterface<Q> displayUnit)	Create a QuantityTable without needing generics, based on a row-major array with SI-values.

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

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(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 <Q extends Quantity<Q>> QuantityTable<Q>	QuantityTable.of(Q[][] grid)	Create a QuantityTable without needing generics, based on a 2-dimensional grid of quantities.
static <Q extends Quantity<Q>> QuantityTable<Q>	QuantityTable.of(Q[] data, int rows, int cols)	Create a QuantityTable without needing generics, based on a row-major array of quantities.