sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Quantities and Units/MeasurementRefCalculations.sysml

@@ -0,0 +1,30 @@
+standard library package MeasurementRefCalculations {
+	doc
+	/*
+	 * This package package defines calculations on MeasurementUnits and CoordinateFrames.
+	 */
+	 
+    private import ScalarValues::String;
+    private import ScalarValues::Real;
+    private import MeasurementReferences::MeasurementUnit;
+    private import MeasurementReferences::ScalarMeasurementReference;
+    private import MeasurementReferences::CoordinateFrame;
+        
+    /* MeasurementUnit operations */
+    calc def '*' specializes DataFunctions::'*' { in x: MeasurementUnit[1]; in y: MeasurementUnit[1]; return : MeasurementUnit[1]; }
+    calc def '/' specializes DataFunctions::'/' { in x: MeasurementUnit[1]; in y: MeasurementUnit[1]; return : MeasurementUnit[1]; }
+    calc def '**' specializes DataFunctions::'**' { in x: MeasurementUnit[1]; in y: Real[1]; return : MeasurementUnit[1]; }
+    calc def '^' specializes DataFunctions::'^' { in x: MeasurementUnit[1]; in y: Real[1]; return : MeasurementUnit[1]; }
+
+    /* CoordinateFrame and MeasurementUnit operations */
+    calc def 'CoordinateFrame*' specializes DataFunctions::'*' { in x: CoordinateFrame[1]; in y: MeasurementUnit[1]; return : CoordinateFrame[1]; }
+    calc def 'CoordinateFrame/' specializes DataFunctions::'/' { in x: CoordinateFrame[1]; in y: MeasurementUnit[1]; return : CoordinateFrame[1]; }
+
+    calc def ToString specializes BaseFunctions::ToString { 
+        doc 
+        /*
+         * Returns the Unicode string symbol representing a scalar measurement reference.
+         */
+        in x: ScalarMeasurementReference[1]; return : String[1];
+    }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Quantities and Units/MeasurementReferences.sysml

@@ -0,0 +1,526 @@
+standard library package MeasurementReferences {
+	doc
+	/*
+	 * This package defines the representations for measurement references.
+	 */
+
+	private import Collections::Array;
+	private import Collections::List;
+	private import ScalarValues::*;
+	private import VectorValues::ThreeVectorValue;
+
+	private import SequenceFunctions::size;
+	private import SequenceFunctions::equals;
+	private import ControlFunctions::forAll;
+	private import Quantities::QuantityDimension;
+	private import Quantities::VectorQuantityValue;
+	private import Quantities::scalarQuantities;
+	private import Quantities::ScalarQuantityValue;
+	private import Quantities::SystemOfQuantities;
+	private import ISQSpaceTime::angularMeasure;
+
+	attribute def TensorMeasurementReference :> Array {
+		doc
+		/*
+		 * TensorMeasurementReference is the most general AttributeDefinition to represent measurement references.
+		 *
+		 * The concept "measurement reference" is defined in [VIM] "quantity" NOTE 2 as "A reference can be a measurement unit,
+		 * a measurement procedure, a reference material, or a combination of such.", see https://jcgm.bipm.org/vim/en/1.1.html .
+		 * In addition [VIM] "quantity" NOTE 5 states that "A quantity as defined here is a scalar. However, a vector or a tensor, 
+		 * the components of which are quantities, is also considered to be a quantity". However, the rest of [VIM] does not explicitly 
+		 * define how tensor and vector quantities can be or should be supported.
+		 *
+		 * In this package, in line with TensorQuantityValue in package Quantities, the most general kind of measurement reference
+		 * is TensorMeasurementReference that represents a measurement reference for any order of tensor quantity. Since the order can 
+		 * also be one or zero, this includes vector and scalar quantities. The specializations VectorMeasurementReference and 
+		 * ScalarMeasurementReference are defined to specifically represent measurement references for vector and scalar quantities.
+		 * 
+		 * TensorMeasurementReference specializes Array, which provides its multi-dimensional structure. The order of a tensor is equivalent
+		 * to the rank of an Array.
+		 * 
+		 * Attribute isBound specifies whether the vector space product is bound (isBound is true) or free (isBound is false).
+		 * 
+		 * Attribute mRefs specifies the scalar measurement references for all dimensions of a tensor quantity.
+		 *
+		 * The short name of a TensorMeasurementReference is the unique symbol by which the measurement reference is known.
+		 * The name of a TensorMeasurementReference is spelled-out human readable name of the measurement reference.
+		 *
+		 * For example, typical measurement references for (scalar) quantity speed are declared with the following humanId and name:
+		 * <'m/s'> and 'metre per second',
+		 * <'km/h'> and 'kilometre per hour',
+		 * <'mi/h'> and 'mile per hour'.
+		 *
+		 * A measurement reference can have zero or more definitionalQuantityValues that allow to specify
+		 * quantity values that carry a particular meaning or relevance for the measurement reference.
+		 */
+	
+		attribute isBound: Boolean[1] default false;
+		attribute order :>> rank;
+		attribute mRefs: ScalarMeasurementReference[1..*] nonunique :>> elements;
+		attribute definitionalQuantityValues: DefinitionalQuantityValue[0..*];
+	}
+
+	attribute def VectorMeasurementReference :> TensorMeasurementReference {
+		doc
+		/*
+		 * A VectorMeasurementReference is a specialization of TensorMeasurementReference for vector quantities that are
+		 * typed by a VectorQuantityValue. Its order is one. Implicitly, it defines a vector space of dimension `n` = dimensions[1].
+		 * The magnitudes of the `n` basis unit vectors that span the vector space are defined by the mRefs which each are
+		 * a ScalarMeasurementReference, typically a MeasurementUnit or an IntervalScale.
+		 * 
+		 * Attribute isOrthogonal declares whether the basis vectors of the vector space are orthogonal, i.e., whether all
+		 * inner products of any pair of basis vectors are equal to zero.
+		 * 
+		 * A pair of a specialization of VectorQuantityValue and a specialization of VectorMeasurementReference can also be used to
+		 * define a vector space for state vectors as used in state-space representation models.
+		 */
+	
+		attribute :>> dimensions: Positive[0..1];
+		attribute isOrthogonal: Boolean[1] default true;
+	}
+
+	abstract attribute def ScalarMeasurementReference :> VectorMeasurementReference {
+		doc
+		/*
+		 * A ScalarMeasurementReference is a specialization of VectorMeasurementReference for scalar quantities
+		 * that are typed by a ScalarQuantityValue and for components of tensor or vector quantities.
+		 * Its order is zero. A ScalarMeasurementReference is also a generalization of MeasurementUnit and MeasurementScale.
+		 * It establishes how to interpret the numerical value (num) of a ScalarQuantityValue or a component of
+		 * a tensor or vector quantity value, and establishes its actual quantity dimension.
+		 *
+		 * Attribute mRefs is bound to self for a ScalarMeasurementReference, for consistency with tensor and vector measurement references,
+		 * as the dimension or component of a scalar quantity is itself.
+		 */
+	
+		attribute :>> dimensions = ();
+		attribute :>> isOrthogonal = true;
+		attribute :>> mRefs = self;
+		attribute quantityDimension: QuantityDimension[1];
+	}
+	
+	attribute def CoordinateFrame :> VectorMeasurementReference {
+		doc
+		/*
+		 * CoordinateFrame is a VectorMeasurementReference with the specific purpose to quantify (i.e., coordinatize) a vector space, 
+		 * and locate and orient it with respect to another CoordinateFrame.
+		 * 
+		 * Optional attribute transformation enables specification of the location and orientation of this CoordinateFrame as dependent
+		 * and nested with respect to another (reference) coordinate frame. Typically the other CoordinateFrame is the frame of 
+		 * the next higher element (Object, Item or Part) in a composite structure.
+		 */
+	
+		attribute transformation: CoordinateTransformation[0..1] {
+			attribute :>> target = that;
+		}
+	}
+
+    attribute def '3dCoordinateFrame' :> CoordinateFrame {
+        doc
+    	/*
+         * Most general 3-dimensional coordinate frame
+         */
+        attribute :>> dimensions = 3;
+    }
+    alias ThreeDCoordinateFrame for '3dCoordinateFrame';
+
+    abstract attribute def CoordinateTransformation {
+        doc
+        /*
+	     * CoordinateTransformation is the most general representation of the transformation of a target VectorMeasurementReference 
+	     * with respect to a source VectorMeasurementReference.
+	     */
+	 	attribute source: VectorMeasurementReference[1];
+	 	attribute target: VectorMeasurementReference[1];
+	 	assert constraint validSourceTargetDimensions { source.dimensions == target.dimensions }
+    }
+
+	attribute def CoordinateFramePlacement :> CoordinateTransformation {
+    	doc
+    	/*
+    	 * CoordinateFramePlacement is a CoordinateTransformation by placement of the target frame in the source frame.
+    	 *  
+    	 * Attribute origin specifies the location of the origin of the target frame as a vector in the source frame.
+    	 * 
+    	 * Attribute basisDirections specifies the orientation of the target frame by specifying the directions of 
+    	 * the respective basis vectors of the target frame via direction vectors in the source frame. An empty sequence of
+    	 * basisDirections signifies no change of orientation of the target coordinate frame.
+    	 */
+
+		attribute origin : VectorQuantityValue[1];
+		attribute basisDirections : VectorQuantityValue[0..*] ordered nonunique;
+		assert constraint validOriginDimensions { origin.dimensions == source.dimensions }
+		assert constraint { size(basisDirections) == 0 or size(basisDirections) == source.dimensions#(1)}
+        assert constraint validateBasisDirections { basisDirections->forAll { in basisDirection : VectorQuantityValue; 
+            basisDirection.dimensions->equals(source.dimensions) }
+        }
+	 }
+
+	abstract attribute def TranslationOrRotation {
+		doc
+		/*
+		 * TranslationOrRotation is an abstract union of Translation and Rotation
+		 */
+	}
+
+	attribute def Translation :> TranslationOrRotation {
+		doc
+		/*
+		 * Representation of a translation with respect to a coordinate frame
+		 * 
+		 * Attribute translationVector specifies the displacement vector that constitutes the translation.
+		 */
+	
+		attribute translationVector : VectorQuantityValue[1];
+	}
+
+	attribute def Rotation :> TranslationOrRotation {
+		doc
+		/*
+		 * Representation of a rotation about an axis over an angle
+		 * 
+		 * Attribute axisDirection specifies the direction of the rotation axis.
+		 * Attribute angle specifies the angle of rotation, where a positive value implies right-handed rotation.
+		 * Attribute isIntrinsic asserts whether the intermediate coordinate frame moves with the rotation or not, 
+		 * i.e. whether an instrinsic or extrinsic rotation is specified.
+		 * 
+		 * See https://en.wikipedia.org/wiki/Davenport_chained_rotations for details.
+		 */
+	
+		attribute axisDirection : VectorQuantityValue[1];
+		attribute angle :>> angularMeasure;
+		attribute isIntrinsic : Boolean[1] default true;
+	}
+
+	attribute def TranslationRotationSequence :> CoordinateTransformation, List {
+	doc
+	/*
+	 * Coordinate frame transformation specified by a sequence of translations and/or rotations
+	 *
+	 * Note: This is a coordinate transformation that is convenient for interpretation by humans.
+	 * In particular a sequence of rotations about the principal axes of a coordinate frame is much more easy understandable 
+	 * than a rotation about an arbitrary axis.
+	 * Any sequence can be reduced to a single combination of a translation and a rotation about a particular axis, but in general 
+	 * the original sequence cannot be retrieved as there are infinitely many sequences representing the reduced transformation.
+	 */
+	
+		attribute :>> elements : TranslationOrRotation[1..*] ordered nonunique;
+	}
+
+	attribute def AffineTransformationMatrix3d :> CoordinateTransformation, Array {
+		doc
+		/*
+		 * AffineTransformationMatrix3d is a three dimensional CoordinateTransformation specified via an affine transformation matrix
+		 *
+		 * The interpretation of the matrix is as follows:
+		 * - the upper left 3x3 matrix represents the rotation matrix
+		 * - the uper right 3x1 column vector represents the translation vector
+		 * - the bottom row must be the row vector (0, 0, 0, 1).
+		 *
+		 * I.e. the matrix has the following form:
+		 * ( R, R, R, T,
+		 *   R, R, R, T,
+		 *   R, R, R, T,
+		 *   0, 0, 0, 1 )
+		 * where the cells marked R form the rotation matrix and the cells marked T form the translation vector.
+		 * 
+		 * Note: See https://en.wikipedia.org/wiki/Transformation_matrix, under affine transformations for a general explanation.
+		 */
+	
+		    attribute rotationMatrix : Array {
+				attribute :>> elements : Real[9] ordered nonunique;
+				attribute :>> dimensions = (3, 3);
+		    }
+			attribute translationVector : ThreeVectorValue[1] { :>> elements : Real[3]; }
+			attribute :>> dimensions = (4, 4);
+			attribute :>> elements : Real[16] ordered nonunique = (
+				rotationMatrix.elements#(1), rotationMatrix.elements#(2), rotationMatrix.elements#(3), translationVector#(1),
+				rotationMatrix.elements#(4), rotationMatrix.elements#(5), rotationMatrix.elements#(6), translationVector#(2),
+				rotationMatrix.elements#(7), rotationMatrix.elements#(8), rotationMatrix.elements#(9), translationVector#(3),
+				0, 0, 0, 1);
+			assert constraint validSourceDimensions { source.dimensions == 3 }
+	}
+
+	attribute def NullTransformation :> AffineTransformationMatrix3d {
+		doc
+		/*
+		 * NullTransformation is a three dimensional CoordinateTransformation that places the target CoordinateFrame at the
+		 * same position and orientation as the source CoordinateFrame.
+		 */
+		 attribute :>> rotationMatrix {
+		     attribute :>> elements = (1, 0, 0, 0, 1, 0, 0, 0, 1);
+		 }
+		 attribute :>> translationVector {
+		     attribute :>> elements = (0, 0, 0);
+		 }
+ 	}
+
+	attribute nullTransformation : NullTransformation [1];
+
+	abstract attribute def MeasurementUnit :> ScalarMeasurementReference {
+		doc
+		/*
+		 * Representation of a measurement unit.
+		 *
+		 * Note: MeasurementUnit directly specializes ScalarMeasurementReference in order to allow for efficient and intuitive definition of a ratio scale.
+		 *
+		 * A MeasurementUnit can be used in two ways:
+		 * 1. Directly as the mRef in a ScalarQuantityValue, which implies that the effective measurement reference is a ratio scale defined by the unit.
+		 * 2. As the unit of a MeasurementScale.
+		 *
+		 * A MeasurementUnit specifies one or more UnitPowerFactors.
+		 */
+	
+		attribute :>> isBound = false;
+		attribute unitPowerFactors: UnitPowerFactor[0..*] ordered;
+		attribute unitConversion: UnitConversion[0..1];
+        assert constraint hasValidUnitPowerFactors : VerifyUnitPowerFactors {
+        	in unitPowerFactors = MeasurementUnit::unitPowerFactors;
+        	in quantityDimension = MeasurementUnit::quantityDimension;
+		}
+	}
+
+
+	abstract attribute def SimpleUnit :> MeasurementUnit {
+		doc
+		/*
+		 * Representation of a measurement unit that does not depend on any other measurement unit.
+		 */
+	
+		private attribute simpleUnitSelf: SimpleUnit = self;
+	    attribute :>> unitPowerFactors: UnitPowerFactor[1] {
+			attribute unit :>> UnitPowerFactor::unit = simpleUnitSelf;
+			attribute exponent :>> UnitPowerFactor::exponent = 1;
+		}
+	}
+
+
+	abstract attribute def DerivedUnit :> MeasurementUnit {
+		doc
+		/*
+		 * Representation of a derived measurement unit that depends on one or more powers of other measurement units.
+		 *
+		 * VIM defines "derived unit" as "measurement unit for a derived quantity", see https://jcgm.bipm.org/vim/en/1.11.html .
+		 */
+	}
+
+
+	attribute def UnitPowerFactor {
+		doc
+		/*
+		 * Representation of a measurement unit power factor, which is a tuple
+		 * of a referenced measurement unit and an exponent.
+		 */
+	
+		attribute unit: MeasurementUnit;
+		attribute exponent: Real;
+	}
+
+	abstract attribute def UnitConversion {
+		doc
+		/*
+		 * Representation of the linear conversion relationship between one measurement unit and another measurement unit, that acts as a reference.
+		 *
+		 * Attribute isExact asserts whether the conversionFactor is exact or not. By default it is set true.
+		 */
+	
+		attribute referenceUnit: MeasurementUnit;
+		attribute conversionFactor: Real;
+		attribute isExact: Boolean default true;
+	}
+
+	attribute def ConversionByConvention :> UnitConversion {
+		doc
+		/*
+		 * Representation of a UnitConversion that is defined according to some convention.
+		 */
+	}
+
+	attribute def ConversionByPrefix :> UnitConversion {
+		doc
+		/*
+		 * Representation of a UnitConversion that is defined through reference to a named unit prefix,
+		 * that in turn represents a decimal or binary multiple or sub-multiple, as defined in ISO/IEC 80000-1.
+		 *
+		 * Note: The actual value of the conversion factor is derived from the definition of the unit prefix.
+		 *
+		 * Examples: kilometre for conversion factor 1000 with reference unit metre, nanofarad for 1E-9 farad.
+		 */
+	
+		attribute prefix: UnitPrefix[1];
+		attribute conversionFactor redefines UnitConversion::conversionFactor = prefix.conversionFactor;
+	}
+
+	attribute def UnitPrefix {
+		doc
+		/*
+		 * Representation of a multiple or sub-multiple measurement unit prefix as defined in ISO/IEC 80000-1.
+		 */
+	
+		attribute longName: String;
+		attribute symbol: String;
+		attribute conversionFactor: Real;
+	}
+
+
+	abstract attribute def MeasurementScale :> ScalarMeasurementReference {
+		doc
+		/*
+		 * Representation of a non-ratio measurement scale as opposed to a ratio measurement scale defined by a MeasurementUnit.
+		 *
+		 * Note: A ratio scale is implied by direct use of a MeasurementUnit as the mRef in a ScalarQuantityValue.
+		 */
+	
+		attribute unit: MeasurementUnit;
+		attribute quantityValueMapping: QuantityValueMapping[0..1];
+	}
+
+	attribute def OrdinalScale :> MeasurementScale {
+		doc
+		/*
+		 * Representation of an ordinal measurement scale.
+		 */
+	}
+
+	attribute def IntervalScale :> MeasurementScale, CoordinateFrame {
+		doc
+		/*
+		 * Representation of an interval measurement scale.
+		 *
+		 * An IntervalScale is also a CoordinateFrame
+		 * The offset of one interval measurement scale w.r.t. another interval or ratio scale is defined through a quantityValueMapping, see MeasurementReference.
+		 */
+	
+		attribute :>> isBound = true;
+	}
+
+	attribute def CyclicRatioScale :> MeasurementScale {
+		doc
+		/*
+		 * Representation of a ratio measurement scale with a periodic cycle.
+		 *
+		 * Note: The magnitude of the periodic cycle is defined by the modulus of the scale.
+		 * Example: Planar angle with modulus 360 degrees, therefore on such a cyclic ratio scale,
+		 * an angle of 450 degrees is equivalent to an angle of 90 degrees, and -60 degrees is equivalent to 300 degrees.
+		 */
+	
+		attribute modulus: Number;
+	}
+
+	attribute def LogarithmicScale :> MeasurementScale {
+		doc
+		/*
+		 * Representation of a logarithmic measurement scale
+		 *
+		 * The magnitude v of a ratio quantity value expressed on a logarithmic scale
+		 * for a magnitude x of a quantity value expressed on a ratio scale is computed as follows:
+		 *   v = f * log_base( (x / x_ref )^a )
+	     * where:
+		 *   f is a multiplication factor,
+	     *   log_base is the log function for the given logarithm base,
+	     *   x is the actual quantity,
+	     *   x_ref is a reference quantity,
+	     *   a is an exponent.
+		 */
+	
+		attribute logarithmBase: Number;
+		attribute factor: Number;
+		attribute exponent: Number;
+		attribute referenceQuantity: ScalarQuantityValue[0..1];
+	}
+
+	attribute def QuantityValueMapping {
+		doc
+		/*
+		 * Representation of the mapping of equivalent quantity values expressed on two different MeasurementReferences
+		 *
+		 * A QuantityValueMapping specifies a mapping from a given mappedQuantityValue owned by the MeasurementReference
+		 * that owns the QuantityValueMapping to a referenceQuantityValue owned by another MeasurementReference.
+		 *
+		 * Example: The mapping between the temperature value of 0.01 degree Celsius on the celsius temperature scale
+		 * to the equivalent temperature value of 273.16 K on the kelvin temperature scale,
+		 * would specify a mappedQuantityValue referencing the
+		 * the DefinitionalQuantityValue (0.01, "absolute thermodynamic temperature of the triple point of water")
+		 * of the celsius interval scale, and a referenceQuantityValue referencing the
+		 * DefinitionalQuantityValue (273.16, "absolute thermodynamic temperature of the triple point of water")
+		 * of the kelvin ratio scale.
+		 */
+	
+		attribute mappedQuantityValue: DefinitionalQuantityValue;
+		attribute referenceQuantityValue: DefinitionalQuantityValue;
+	}
+
+	attribute def DefinitionalQuantityValue {
+		doc
+		/*
+		 * Representation of a particular quantity value that is used in the definition of a TensorMeasurementReference
+		 *
+		 * Typically such a particular value is defined by convention. It can be used to define a selected reference value,
+		 * such as the meaning of zero on a measurement scale or the origin of a top-level coordinate frame.
+		 *
+		 * Example: The 'kelvin' MeasurementReference for thermodynamic temperature could have a
+		 * DefinitionalQuantityValue {
+		 *     :>> num = 273.16;
+		 *     :>> definition = "thermodynamic temperature of the triple point of Vienna Standard Mean Ocean Water in kelvin";
+		 * }
+		 * that is value of the definition of the scale.
+		 */
+	
+		attribute num: Number[1..*];
+		attribute definition: String;
+	}
+
+	attribute def DimensionOneUnit :> DerivedUnit {
+		doc
+		/*
+		 * Explicit definition of "unit of dimension one", also known as "dimensionless unit".
+		 */
+	
+		attribute :>> unitPowerFactors = ();
+	}
+	attribute def DimensionOneValue :> ScalarQuantityValue {
+		doc
+		/*
+		 * A ScalarQuantityValue with a DimensionOneUnit.
+		 */
+		attribute :>> num: Real;
+		attribute :>> mRef: DimensionOneUnit;
+	}
+	attribute dimensionOneQuantities : DimensionOneValue[*] nonunique :> scalarQuantities;
+
+	attribute one : DimensionOneUnit[1] = new DimensionOneUnit();
+
+	attribute def CountValue :> DimensionOneValue {
+		doc
+		/*
+		 * Explicit definition of a generic "count" quantity as a DimensionOneValue.
+		 */
+	}
+	attribute countQuantities : CountValue[*] nonunique :> dimensionOneQuantities;
+
+	attribute def SystemOfUnits {
+		doc
+		/*
+		 * A SystemOfUnits represents the essentials of [VIM] concept "system of units" (https://jcgm.bipm.org/vim/en/1.13.html), defined as a
+		 * "set of base units and derived units, together with their multiples and submultiples, defined in accordance with given rules,
+		 * for a given system of quantities".
+		 * The base units are a particular selection of measurement units for each of the base quantities of a system of quantities,
+		 * that form the basis on top of which all other (derived) units are defined.
+		 *
+		 * Attribute systemOfQuantities speficies the associated SystemOfQuantities.
+		 */
+	
+		attribute longName: String[1];
+		attribute systemOfQuantities : SystemOfQuantities[1];
+		attribute baseUnits: SimpleUnit[1..*] ordered;
+	}
+
+    constraint def VerifyUnitPowerFactors {
+		doc
+		/*
+		 * Constraint definition to verify that the given unit power factors comply with the required quantity dimension
+		 */
+	
+    	in unitPowerFactors: UnitPowerFactor[*] ordered;
+    	in quantityDimension: QuantityDimension[1];
+	}
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Quantities and Units/Quantities.sysml

@@ -0,0 +1,107 @@
+standard library package Quantities {
+	doc
+	/*
+	 * This package defines the root representations for quantities and their values.
+	 */
+
+	private import Collections::*;
+	private import ScalarValues::NumericalValue;
+	private import ScalarValues::Number;
+	private import ScalarValues::Real;
+	private import ScalarValues::Natural;
+	private import ScalarValues::Boolean;
+	private import ScalarValues::String;
+	private import VectorValues::NumericalVectorValue;
+	private import VectorValues::ThreeVectorValue;
+
+	abstract attribute def TensorQuantityValue :> Array {
+		doc
+		/*
+		 * The value of a quantity is a tuple of one or more numbers (i.e. mathematical number values) and a reference to a measurement reference.
+		 * The most general case is a multi-dimensional, tensor quantity of any order. In engineering, the majority of quantities used are 
+		 * scalar and vector quantities, that are tensor quantities of order 0 and 1 respectively.
+		 * The measurement reference used to express a quantity value must have a type, dimensions and order that match the quantity, i.e.,
+		 * a TensorQuantityValue must use a TensorMeasurementReference, a VectorQuantityValue a VectorMeasurementReference, 
+		 * and a ScalarQuantityValue a ScalarMeasurementReference. See package MeasurementReferences for details.
+		 */
+	
+		attribute isBound: Boolean;
+		attribute num: Number[1..*] ordered nonunique :>> elements;
+		attribute mRef: MeasurementReferences::TensorMeasurementReference;
+        attribute :>> dimensions = mRef.dimensions;
+		attribute order :>> rank;
+        attribute contravariantOrder: Natural;
+        attribute covariantOrder: Natural;
+
+        assert constraint orderSum { contravariantOrder + covariantOrder == order }
+        assert constraint boundMatch { (isBound == mRef.isBound) or (not isBound and mRef.isBound) }
+	}
+
+	abstract attribute def VectorQuantityValue :> TensorQuantityValue, NumericalVectorValue {
+		attribute :>> mRef: MeasurementReferences::VectorMeasurementReference;
+	}
+
+	abstract attribute def ScalarQuantityValue :> VectorQuantityValue, NumericalValue {
+		attribute :>> mRef: MeasurementReferences::ScalarMeasurementReference;
+	}
+	
+	abstract attribute tensorQuantities: TensorQuantityValue[*] nonunique {
+		doc
+		/*
+		 * Quantities are defined as self-standing features that can be used to consistently specify quantities as 
+		 * features of occurrences. Each single quantity feature is subsetting the root feature tensorQuantities. 
+		 * In other words, the codomain of a quantity feature is a suitable specialization of TensorQuantityValue.
+		 */
+	}
+	abstract attribute vectorQuantities: VectorQuantityValue[*] nonunique :> tensorQuantities;
+	abstract attribute scalarQuantities: ScalarQuantityValue[*] nonunique :> vectorQuantities;
+
+	abstract attribute def '3dVectorQuantityValue' :> VectorQuantityValue, ThreeVectorValue {
+        doc
+    	/*
+    	 * Most general representation of real 3-vector quantities
+    	 */
+
+        attribute :>> num: Real[3];
+	}
+	alias ThreeDVectorQuantityValue for '3dVectorQuantityValue';
+	
+    /*
+     * Define generic aliases QuantityValue and quantities for the top level quantity attribute def and attribute.
+     */
+	alias QuantityValue for TensorQuantityValue;
+	alias quantities for tensorQuantities;
+
+	attribute def SystemOfQuantities {
+		doc
+		/*
+		 * A SystemOfQuantities represents the essentials of [VIM] concept "system of quantities" (https://jcgm.bipm.org/vim/en/1.3.html), defined as a
+		 * "set of quantities together with a set of noncontradictory equations relating those quantities".
+		 * In order to establish such a set of noncontradictory equations a set of base quantities is selected. Subsequently the system of quantities is 
+		 * completed by adding derived quantities which are products of powers of the base quantities.
+		 */
+	
+		attribute baseQuantities: ScalarQuantityValue[*] ordered :> scalarQuantities;
+	}
+
+	attribute def QuantityPowerFactor {
+		doc
+		/*
+		 * Representation of a quantity power factor, being the combination of a quantity and an exponent.
+		 * 
+		 * A sequence of QuantityPowerFactors for the baseQuantities of a SystemOfQuantities define the QuantityDimension of a scalar quantity.
+		 */
+	
+		attribute quantity: ScalarQuantityValue[1];
+		attribute exponent: Real[1];
+	}
+
+	attribute def QuantityDimension {
+		doc
+		/*
+		 * Representation of quantity dimension, which is the product of powers of the set of base quantities defined for a particular system of quantities, units and scales.
+		 */
+	
+		 attribute quantityPowerFactors: QuantityPowerFactor[*] ordered;
+	}
+}