sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Function Library/SequenceFunctions.kerml

@@ -0,0 +1,111 @@
+standard library package SequenceFunctions {
+	doc
+	/*
+	 * This package defines functions that operate on general sequences of values. (For functions that
+	 * operate on Collection values, see CollectionFunctions.)
+	 */
+
+	private import Base::Anything;
+	private import Occurrences::SelfSameLifeLink;
+	private import ScalarValues::*;
+	private import ControlFunctions::*;
+	
+	function '#' specializes BaseFunctions::'#' { in seq: Anything[0..*] ordered nonunique; in index: Positive[1];
+		return : Anything[0..1];
+	}
+	
+	function equals{ in x: Anything[0..*] ordered nonunique; in y: Anything[0..*] ordered nonunique; 
+		return : Boolean[1] =
+			size(x) == size(y) and
+			(1..size(x))->forAll {in i; x#(i) == y#(i)};
+	}
+
+	function same{ in x: Anything[0..*] ordered nonunique; in y: Anything[0..*] ordered nonunique;
+		return : Boolean[1] =
+			size(x) == size(y) and
+			(1..size(x))->forAll {in i; x#(i) === y#(i)};
+	}
+
+	function size{ in seq: Anything[0..*] nonunique;
+		return : Natural[1] = if isEmpty(seq)? 0 else size(tail(seq)) + 1;
+	}
+	function isEmpty{ in seq: Anything[0..*] nonunique;
+		return : Boolean[1] = seq == null;
+	}
+	function notEmpty{ in seq: Anything[0..*] nonunique;
+		return : Boolean[1] = not isEmpty(seq);
+	}
+	function includes{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;
+		return : Boolean[1] = seq2->forAll {in x; seq1->exists{in y; x == y}};
+	}
+	function includesOnly{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;
+		return : Boolean[1] = seq1->includes(seq2) and seq2->includes(seq1);
+	}
+	function excludes{ in seq1: Anything[0..*] nonunique; in seq2: Anything[0..*] nonunique;
+		return : Boolean[1] = seq2->forAll {in x; seq1->excludes(x)};
+	}
+	
+	function union{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique;
+		return : Anything[0..*] ordered nonunique = (seq1, seq2);
+	}
+	function intersection{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique;
+		return : Anything[0..*] ordered nonunique = seq1->select {in x; seq2->includes(x)};
+	}
+	function including{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;
+		return : Anything[0..*] ordered nonunique = union(seq, values);
+	}
+	function includingAt{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;
+		in index: Positive[1];
+		return : Anything[0..*] ordered nonunique = 
+			(seq->subsequence(1, index - 1), values, seq->subsequence(index + 1));
+	}
+	function excluding{ in seq: Anything[0..*] ordered nonunique; in values: Anything[0..*];
+		return : Anything[0..*] ordered nonunique = seq->reject {in x; values->includes(x)};
+	}
+	function excludingAt{ in seq: Anything[0..*] ordered nonunique;
+		in startIndex: Positive[1]; in endIndex: Positive[1] default startIndex;
+		return : Anything[0..*] ordered nonunique = 
+			(seq->subsequence(1, startIndex - 1), seq->subsequence(endIndex + 1));
+	}
+	
+	function subsequence{ in seq: Anything[0..*] ordered nonunique; 
+		in startIndex: Positive[1]; in endIndex: Positive[1] default size(seq);
+		return : Anything[0..*] = (startIndex..endIndex)->collect {in i; seq#(i)};
+	}
+	function head{ in seq: Anything[0..*] ordered nonunique;
+		return : Anything[0..1] = seq#(1);
+	}
+	function tail{ in seq: Anything[0..*] ordered nonunique;
+		return : Anything[0..*] ordered nonunique = subsequence(seq, 2);
+	}
+	function last{ in seq: Anything[0..*] ordered nonunique;
+		return : Anything[0..1] = seq#(size(seq));
+	}
+	
+	behavior add { inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;
+		private feature newSeq = seq->including(values);
+		feature redefines endShot: add {
+			binding seq = newSeq;
+		}
+	}	
+	behavior addAt { inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*] ordered nonunique;
+		in index: Positive[1];
+		private feature newSeq = seq->includingAt(values, index);
+		feature redefines endShot: addAt {
+			binding seq = newSeq;
+		}
+	}
+	behavior remove{ inout seq: Anything[0..*] ordered nonunique; in values: Anything[0..*];
+		private feature newSeq = seq->excluding(values);
+		feature redefines endShot: remove {
+			binding seq = newSeq;
+		}
+	}
+	behavior removeAt{ inout seq: Anything[0..*] ordered nonunique;
+		in startIndex: Positive[1]; in endIndex: Positive[1] default startIndex;
+		private feature newSeq = seq->excludingAt(startIndex, endIndex);
+		feature redefines endShot: removeAt {
+			binding seq = newSeq;
+		}
+	}
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Function Library/StringFunctions.kerml

@@ -0,0 +1,25 @@
+standard library package StringFunctions {
+	doc
+	/*
+	 * This package defines functions on String values, including those corresponding to string concatenation 
+	 * and comparison operators in the KerML expression notation.
+	 */
+
+	public import ScalarValues::*;
+	
+	function '+' specializes ScalarFunctions::'+' { in x: String[1]; in y:String[1]; return : String[1]; }
+	
+	function Length{ in x: String[1]; return : Natural[1]; }
+	function Substring{ in x: String[1]; in lower: Integer[1]; in upper: Integer[1]; return : String[1]; }
+	
+	function '<' specializes ScalarFunctions::'<' { in x: String[1]; in y: String[1]; return : Boolean[1]; }
+	function '>' specializes ScalarFunctions::'>' { in x: String[1]; in y: String[1]; return : Boolean[1]; }
+	function '<=' specializes ScalarFunctions::'<=' { in x: String[1]; in y: String[1]; return : Boolean[1]; }
+	function '>=' specializes ScalarFunctions::'>=' { in x: String[1]; in y: String[1]; return : Boolean[1]; }
+
+	function '==' specializes DataFunctions::'==' { in x: String[0..1]; in y: String[0..1]; return : Boolean[1]; }
+	
+	function ToString specializes BaseFunctions::ToString { in x: String[1];
+		return : String[1] = x;
+	}
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Function Library/TrigFunctions.kerml

@@ -0,0 +1,35 @@
+standard library package TrigFunctions {
+	doc
+	/*
+	 * This package defines basic trigonometric functions on real numbers.
+	 */
+
+	public import ScalarValues::Real;
+	
+	feature pi : Real;
+	inv piPrecision { RealFunctions::round(pi * 1E20) == 314159265358979323846.0 }
+	
+	function deg { in theta_rad : Real[1];
+		return : Real[1] = theta_rad * 180 / pi;
+	}
+	function rad { in theta_deg : Real;
+		return : Real[1] = theta_deg * pi / 180;
+	}
+	
+	datatype UnitBoundedReal :> Real {
+		inv unitBound { -1.0 <= that & that <= 1.0 }
+	}
+	
+	function sin { in theta : Real[1]; return : UnitBoundedReal[1]; }
+	function cos { in theta : Real[1]; return : UnitBoundedReal[1]; }
+	function tan { in theta : Real[1]; 
+        return : Real = sin(theta) / cos(theta);
+	}
+	function cot { in theta : Real; 
+        return : Real = cos(theta) / sin(theta);
+	}
+	
+	function arcsin { in x : UnitBoundedReal[1]; return : Real[1]; }
+	function arccos { in x : UnitBoundedReal[1]; return : Real[1]; }
+	function arctan { in x : Real[1]; return : Real[1]; }
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Function Library/VectorFunctions.kerml

@@ -0,0 +1,273 @@
+standard library package VectorFunctions {
+	doc
+	/*
+	 * This package defines abstract functions on VectorValues corresponding to the algebraic operations
+	 * provided by a vector space with inner product. It also includes concrete implementations of these
+	 * functions specifically for CartesianVectorValues.
+	 */
+
+	private import ScalarValues::NumericalValue;
+	private import ScalarValues::Positive;
+	private import ScalarValues::Real;
+	private import ScalarValues::Boolean;
+	private import NumericalFunctions::*;
+	private import RealFunctions::sqrt;
+	private import TrigFunctions::arccos;
+	private import SequenceFunctions::size;
+	private import ControlFunctions::*;
+	
+	public import VectorValues::*;
+	
+	/* Generic arithmetic functions for all VectorValues. */
+	
+	abstract function isZeroVector {
+		doc
+		/*
+		 * Return whether a VectorValue is a zero vector.
+		 */
+		 
+		in v: VectorValue[1]; 
+		return : Boolean[1]; 
+	}
+	
+	abstract function '+' specializes DataFunctions::'+' {
+		doc
+		/*
+		 * With two arguments, returns the sum of two VectorValues. With one argument, returns that VectorValue.
+		 */
+		 
+	 	in v: VectorValue[1]; 
+	 	in w: VectorValue[0..1]; 
+		return u: VectorValue[1];
+		inv zeroAddition { w == null or isZeroVector(w) implies u == w }
+		inv commutivity { w != null implies u == w + v }
+	}
+	
+	abstract function '-' specializes DataFunctions::'-' {
+		doc
+		/*
+		 * With two arguments, returns the difference of two VectorValues. With one arguments, returns the inverse
+		 * of the given VectorValue, that is, the VectorValue that, when added to the original VectorValue, results in
+		 * the zeroVector.
+		 */
+	 
+		in v: VectorValue[1]; 
+		in w: VectorValue[0..1]; 
+		return u: VectorValue[1];
+		inv negation { w == null implies isZeroVector(v + u) }
+		inv difference { w != null implies v + u == w }
+	}
+	
+	abstract function sum0 {
+		doc
+		/*
+		 * Return the sum of a collection of VectorValues. If the collection is empty, return a given zero vector.
+		 */
+	 
+		in coll: VectorValue[*] nonunique; 
+		in zero: VectorValue[1]; 
+		inv precondition { isZeroVector(zero) }
+		return s: VectorValue[1] = coll->reduce '+' ?? zero;
+	}
+
+	/* Functions specific to NumericalVectorValues. */
+	
+	function VectorOf {
+		doc
+		/*
+		 * Construct a NumericalVectorValue whose elements are a non-empty list of component NumericalValues.
+		 * The dimension of the NumericalVectorValue is equal to the number of components.
+		 */
+	 
+		in components: NumericalValue[1..*] ordered nonunique; 
+		return : NumericalVectorValue[1] {
+			:>> dimension = size(components);
+			:>> elements = components;
+		}
+	}
+	
+	abstract function scalarVectorMult specializes DataFunctions::'*' {
+		doc
+		/*
+		 * Scalar product of a NumericalValue and a NumericalVectorValue.
+		 */
+	 
+		in x: NumericalValue[1]; 
+		in v: NumericalVectorValue[1];
+		return w: NumericalVectorValue[1];
+		inv scaling { norm(w) == x * norm(v) }
+		inv zeroLength { isZeroVector(w) implies isZero(norm(w))}
+	}
+	alias '*' for scalarVectorMult;
+	
+	abstract function vectorScalarMult specializes DataFunctions::'*' {
+		doc
+		/*
+		 * Scalar product of a NumericalVectorValue and a NumericalValue, which has the same value as the scalar product of the
+		 * NumericalValue and the NumericalVectorValue.
+		 */
+	 
+		in v: NumericalVectorValue[1]; 
+		in x: NumericalValue[1];
+		return w: NumericalVectorValue[1] default scalarVectorMult(x, v);
+	}
+	
+	abstract function vectorScalarDiv specializes DataFunctions::'/' {
+		doc
+		/*
+		 * Scalar quotient of a NumericalVectorValue and a NumericalValue, defined as the scalar product of the inverse of the 
+		 * NumericalValue and the NumericalVectorValue.
+		 */
+	 
+		in v: NumericalVectorValue[1]; 
+		in x: NumericalValue[1];
+		return w: NumericalVectorValue[1] = scalarVectorMult(1.0 / x, v);
+	}
+
+	abstract function inner specializes DataFunctions::'*' {
+		doc
+		/*
+		 * Inner product of two NumericalVectorValues.
+		 */
+	 
+		in v: NumericalVectorValue[1]; 
+		in w: NumericalVectorValue[1];
+		return x: NumericalValue[1];
+		inv commmutivity { x == inner(w, v) }
+		inv zeroInner { isZeroVector(v) or isZeroVector(w) implies isZero(x)}
+	}
+	
+	abstract function norm {
+		doc
+		/*
+		 * The norm (magnitude) of a NumericalVectorValue, as a NumericalValue.
+		 */
+	 
+		in v: NumericalVectorValue[1]; 
+		return l : NumericalValue[1];
+		inv squareNorm { l * l == inner(v,v) }
+		inv lengthZero { isZero(l) == isZeroVector(v) }
+	}
+	
+	abstract function angle {
+		doc
+		/*
+		 * The angle between two NumericalVectorValues, as a NumericalValue.
+		 */
+		 
+	 	in v: NumericalVectorValue[1]; 
+	 	in w: NumericalVectorValue[1]; 
+		return theta: NumericalValue[1];
+		inv commutivity { theta == angle(w, v) }
+		inv lengthInsensitive { theta == angle(w / norm(w), v / norm(v)) }
+	}
+	
+	/* Specialized functions with concrete definitions for CartesianVectorValues. */
+	
+	function CartesianVectorOf {
+		doc
+		/*
+		 * Construct a CartesianVectorValue whose elements are a non-empty list of Real components.
+		 * The dimension of the NumericalVectorValue is equal to the number of components.
+		 */
+	 
+		in components: Real[*] ordered nonunique; 
+		return : CartesianVectorValue[1] {
+			:>> dimension = size(components);
+			:>> elements = components;
+		}
+	}
+	function CartesianThreeVectorOf specializes CartesianVectorOf { 
+		in components: Real[3] ordered nonunique;
+		return : CartesianThreeVectorValue[1] {
+		    feature :>> CartesianVectorOf::result::dimension, CartesianThreeVectorValue::dimension;
+		}
+	}
+	
+	feature cartesianZeroVector: CartesianVectorValue[3] =
+		(
+			CartesianVectorOf(0.0),
+			CartesianVectorOf((0.0, 0.0)),
+			CartesianThreeVectorOf((0.0, 0.0, 0.0))
+		) {
+		doc
+		/*
+		 * Cartesian zero vectors of 1, 2 and 3 dimensions.
+		 */
+	}
+	feature cartesian3DZeroVector: CartesianThreeVectorValue[1] =
+		cartesianZeroVector#(3);
+	
+	function isCartesianZeroVector specializes isZeroVector {
+		doc
+		/*
+		 * A CartesianVectorValue is a zero vector if all its elements are zero.
+		 */
+	 
+		in v: CartesianVectorValue[1]; 
+		return : Boolean[1] = v.elements->forAll{in x; x == 0.0};
+	}
+	
+	function 'cartesian+' specializes '+' { 
+		in v: CartesianVectorValue[1]; 
+		in w: CartesianVectorValue[0..1];
+		inv precondition { w != null implies v.dimension == w.dimension }
+		return u: CartesianVectorValue[1] =
+			if w == null? v
+			else CartesianVectorOf(
+				(1..w.dimension)->collect{in i : Positive; v#(i) + w#(i)}
+			);
+	}
+	
+	function 'cartesian-' specializes '-' { 
+		in v: CartesianVectorValue[1]; 
+		in w: CartesianVectorValue[0..1];
+		inv precondition { w != null implies v.dimension == w.dimension }
+		return u: CartesianVectorValue[1] =
+			CartesianVectorOf(
+				if w == null? CartesianVectorOf(v.elements->collect{in x : Real; -x})
+				else CartesianVectorOf(
+					(1..v.dimension)->collect{in i : Positive; v#(i) - w#(i)}
+				)
+			);
+	}
+	
+	function cartesianScalarVectorMult specializes scalarVectorMult { 
+		in x: Real[1]; 
+		in v: CartesianVectorValue[1];
+		return w: CartesianVectorValue[1] =
+			CartesianVectorOf(
+				v.elements->collect{in y : Real; x * y}
+			);
+	}
+	function cartesianVectorScalarMult specializes vectorScalarMult { 
+		in v: CartesianVectorValue[1]; 
+		in x: Real[1]; 
+		return w: CartesianVectorValue[1] = cartesianScalarVectorMult(x, v);
+	}
+	
+	function cartesianInner specializes inner { 
+		in v: CartesianVectorValue[1]; 
+		in w : CartesianVectorValue[1];
+		inv precondition { v.dimension == w.dimension }
+		return x: Real[1] =
+			(1..v.dimension)->collect{in i : Positive; v#(i) * w#(i)}->reduce RealFunctions::'+';
+	}
+	
+	function cartesianNorm specializes norm { 
+		in v: CartesianVectorValue[1];
+		return l : NumericalValue[1] = sqrt(cartesianInner(v, v));
+	}
+	
+	function cartesianAngle specializes angle { 
+		in v: CartesianVectorValue[1]; in w: CartesianVectorValue[1];
+		inv precondition { v.dimension == w.dimension }
+		return theta: Real[1] = arccos(cartesianInner(v, w) / (norm(v) * norm(w)));
+	}
+	
+	function sum { 
+		in coll: CartesianThreeVectorValue[*];
+		return : CartesianThreeVectorValue[1] = sum0(coll, cartesian3DZeroVector);
+	}
+	
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/.meta.json

@@ -0,0 +1,22 @@
+{
+  "index": {
+    "Base": "Base.kerml",
+    "Clocks": "Clocks.kerml",
+    "ControlPerformances": "ControlPerformances.kerml",
+    "FeatureReferencingPerformances": "FeatureReferencingPerformances.kerml",
+    "KerML": "KerML.kerml",
+    "Links": "Links.kerml",
+    "Metaobjects": "Metaobjects.kerml",
+    "Objects": "Objects.kerml",
+    "Observation": "Observation.kerml",
+    "Occurrences": "Occurrences.kerml",
+    "Performances": "Performances.kerml",
+    "SpatialFrames": "SpatialFrames.kerml",
+    "StatePerformances": "StatePerformances.kerml",
+    "Transfers": "Transfers.kerml",
+    "TransitionPerformances": "TransitionPerformances.kerml",
+    "Triggers": "Triggers.kerml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/KerML/20250201"
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/.project.json

@@ -0,0 +1,15 @@
+{
+  "name": "Kernel Semantic Library",
+  "version": "1.0.0",
+  "description": "Standard semantic library for the Kernel Modeling Language (KerML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.0.0"
+    }
+  ]
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Semantic Library/Base.kerml

@@ -0,0 +1,95 @@
+standard library package Base {
+	doc 
+	/*
+	 * This package defines the classifiers and features that provide the bases for the typing
+	 * of all elements in the language.
+	 */
+	 		
+	abstract classifier Anything {
+		doc
+		/*
+	     * Anything is the top level generalized type in the language. 
+	     */
+		
+		feature self: Anything[1] subsets things chains things.that {
+			doc
+			/*
+			 * The source of a SelfLink of this thing to itself. self is thus a feature that
+			 * relates everything to itself. It is also the value of the nested "that" feature
+			 * of all other things featured by this thing.
+			 */
+		}
+	}
+	
+	abstract datatype DataValue specializes Anything {
+		doc
+		/*
+		 * Value is the most general classifier of entities that are values that do not change
+		 * over time.
+		 */
+		
+		feature self: DataValue redefines Anything::self;
+	}
+	
+	abstract feature things: Anything [1..*] nonunique {
+		doc
+		/*
+		 * things is the top-level feature in the language.
+		 */
+
+		feature that : Anything[1] {
+			doc
+			/*
+			 * For each value of things, the "featuring instance" of that value. 
+			 * This is enforced by declaring Anything::self to be the chaining of things.that, 
+			 * restricting it the single value of self.
+			 */			
+		}
+	}
+	
+	abstract feature dataValues: DataValue[0..*] nonunique subsets things {
+		doc
+		/*
+		 * dataValues is a specialization of things restricted to type DataValue.
+		 */
+	}
+		 
+	abstract feature naturals: ScalarValues::Natural[0..*] subsets dataValues {
+		doc
+		/*
+		 * naturals is a specialization of dataValues restricted to type Natural. 
+		 * It is the root feature of all multiplicities, which map from a feature to
+		 * the set of Natural numbers representing allowable cardinalities of the feature.
+		 */
+	}
+	
+	multiplicity exactlyOne [1..1] {
+		doc
+		/*
+		 * exactlyOne is a multiplicity range requiring a cardinality of exactly one.
+		 */
+	}
+	
+	multiplicity zeroOrOne [0..1] {
+		doc
+		/*
+		 * zeroOrOne is a multiplicity range requiring a cardinality of zero or one.
+		 */		
+	}
+	
+	multiplicity oneToMany [1..*] {
+		doc
+		/*
+		 * oneToMany is a multiplicity range allowing any cardinality of one or more.
+		 */
+	}
+	
+	multiplicity zeroToMany [0..*] {
+		doc
+		/*
+		 * zeroToMany is a multiplicity range allowing any cardinality of zero or more
+		 * (that is, no restriction).
+		 */
+	}
+	
+}