sysmledgraph 0.7.0

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

@@ -0,0 +1,117 @@
+standard library package ControlFunctions {
+	doc
+	/*
+	 * This package defines functions that correspond to operators in the KerML expression notation 
+	 * for which one or more operands are expressions whose evaluation is determined by another operand.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::ScalarValue;
+	private import ScalarValues::Boolean;
+	private import ScalarFunctions::min;
+	private import ScalarFunctions::max;
+	
+	abstract function '.' {
+		in feature source : Anything[0..*] nonunique {
+	  		abstract feature target : Anything[0..*] nonunique;
+	  	}	  	
+	  	private feature chain chains source.target;
+	    chain
+	}
+	
+	abstract function 'if' { 
+		in test: Boolean[1];
+		in expr thenValue[0..1] { return : Anything[0..*] ordered nonunique; }
+		in expr elseValue[0..1] { return : Anything[0..*] ordered nonunique; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function '??' {
+		in firstValue: Anything[0..*] ordered nonunique;
+		in expr secondValue[0..1] { return : Anything[0..*] ordered nonunique; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	function 'and' {
+		in firstValue: Boolean[1];
+		in expr secondValue[0..1] { return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	function 'or'{
+		in firstValue: Boolean[1];
+		in expr secondValue[0..1] { return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	function 'implies'{
+		in firstValue: Boolean[1];
+		in expr secondValue[0..1] { return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	abstract function collect { 
+		in collection: Anything[0..*] ordered nonunique;
+		in expr mapper[0..*] { in argument: Anything[1]; return : Anything[0..*] ordered nonunique; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function select { 
+		in collection: Anything[0..*] ordered nonunique; 
+		in expr selector[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	function selectOne { 
+		in collection: Anything[0..*] ordered nonunique;
+		in expr selector1[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Anything[0..1] = collection->select {in x; selector1(x)}#(1);
+	}
+	
+	abstract function reject{ 
+		in collection: Anything[0..*] ordered nonunique; 
+		in expr rejector[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function reduce { 
+		in collection: Anything[0..*] ordered nonunique; 
+		in expr reducer[0..*] { in firstArg: Anything[1]; in secondArg: Anything[1]; return : Anything[1]; }
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function forAll { 
+		in collection: Anything[0..*] ordered nonunique; 
+		in expr test[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	abstract function exists { 
+		in collection: Anything[0..*] ordered nonunique;
+		in expr test[0..*] { in argument: Anything[1]; return : Boolean[1]; }
+		return : Boolean[1];
+	}
+	
+	function allTrue {
+		in collection: Boolean[0..*]; 
+		return : Boolean[1] = collection->forAll {in x; x};
+	}
+	
+	function anyTrue {
+		in collection: Boolean[0..*];
+		return : Boolean[1] = collection->exists {in x; x};
+	}
+	
+	function minimize {
+		in collection: ScalarValue[1..*];
+		in expr fn[0..*] { in argument: ScalarValue[1]; return : ScalarValue[1]; }
+		return : ScalarValue[1] = collection->collect {in x; fn(x)}->reduce min;
+	}
+	
+	function maximize { 
+		in collection: ScalarValue[1..*];
+		in expr fn[0..*] { in argument: ScalarValue[1]; return : ScalarValue[1]; }
+		return : ScalarValue = collection->collect {in x; fn(x)}->reduce max;
+	}
+	
+}

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

@@ -0,0 +1,43 @@
+standard library package DataFunctions {
+	doc
+	/*
+	 * This package defines the abstract base functions corresponding to all the unary and binary operators 
+	 * in the KerML expression notation that might be defined on various kinds of DataValues.
+	 */
+
+	private import Base::DataValue;
+	private import ScalarValues::Boolean;
+	private import ControlFunctions::reduce;	
+	
+	abstract function '==' specializes BaseFunctions::'==' { in x: DataValue[0..1]; in y: DataValue[0..1]; 
+		return : Boolean[1];
+	}
+	function '===' specializes BaseFunctions::'==='{ in x: DataValue[0..1]; in y: DataValue[0..1]; 
+		return : Boolean[1] = x == y;
+	}
+	
+	abstract function '+' { in x: DataValue[1]; in y: DataValue[0..1]; return : DataValue[1]; }
+	abstract function '-' { in x: DataValue[1]; in y: DataValue[0..1]; return : DataValue[1]; }
+	abstract function '*' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '/' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '**' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '^' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '%' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	
+	abstract function 'not' { in x: DataValue[1]; return : DataValue[1]; }
+	abstract function 'xor' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+
+	abstract function '~' { in x: DataValue[1]; return : DataValue[1]; }
+	abstract function '|' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '&' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	
+	abstract function '<' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
+	abstract function '>' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
+	abstract function '<=' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
+	abstract function '>=' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
+	
+	abstract function max { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function min { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	
+	abstract function '..' { in lower: DataValue[1]; in upper: DataValue[1]; return : DataValue[0..*] ordered; }	
+}

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

@@ -0,0 +1,43 @@
+standard library package IntegerFunctions {
+	doc
+	/*
+	 * This package defines functions on Integer values, including concrete specializations of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	
+	function abs specializes RationalFunctions::abs { in x: Integer[1]; return : Natural[1]; }
+	
+	function '+' specializes RationalFunctions::'+' { in x: Integer[1]; in y: Integer[0..1]; return : Integer[1]; }
+	function '-' specializes RationalFunctions::'-' { in x: Integer[1]; in y: Integer[0..1]; return : Integer[1]; }
+	function '*' specializes RationalFunctions::'*' { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
+	function '/' specializes RationalFunctions::'/' { in x: Integer[1]; in y: Integer[1]; return : Rational[1]; }
+	function '**' specializes RationalFunctions::'**' { in x: Integer[1]; in y: Natural[1]; return : Integer[1]; }
+	function '^' specializes RationalFunctions::'^' { in x: Integer[1]; in y: Natural[1]; return : Integer[1]; }
+	function '%' specializes NumericalFunctions::'%' { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
+	
+	function '<' specializes RationalFunctions::'<' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
+	function '>' specializes RationalFunctions::'>' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
+	function '<=' specializes RationalFunctions::'<=' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
+	function '>=' specializes RationalFunctions::'>=' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
+
+	function max specializes RationalFunctions::max { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
+	function min specializes RationalFunctions::min { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
+
+	function '==' specializes DataFunctions::'==' { in x: Integer[0..1]; in y: Integer[0..1]; return : Boolean[1]; }
+	
+	function '..' specializes ScalarFunctions::'..' { in lower: Integer[1]; in upper: Integer[1]; return : Integer[0..*]; }
+	
+	function ToString specializes RationalFunctions::ToString { in x: Integer[1]; return : String[1]; }
+	function ToNatural { in x: Integer[1]; return : Natural[1]; }
+	function ToInteger { in x: String[1]; return : Integer[1]; }
+	
+	function sum specializes RationalFunctions::sum { in collection: Integer[0..*]; 
+		return : Integer[1] default NumericalFunctions::sum0(collection, 0);
+	}
+	
+	function product specializes RationalFunctions::product { in collection: Integer[0..*];
+		return : Integer[1] default NumericalFunctions::product1(collection, 1);
+	}
+}	

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

@@ -0,0 +1,27 @@
+standard library package NaturalFunctions {
+	doc
+	/*
+	 * This package defines functions on Natural values, including concrete specialization of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	
+	function '+' specializes IntegerFunctions::'+' { in x: Natural[1]; in y: Natural[0..1]; return : Natural[1]; }
+	function '*' specializes IntegerFunctions::'*' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+	function '/' specializes IntegerFunctions::'/' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+	function '%' specializes IntegerFunctions::'%' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+	
+	function '<' specializes IntegerFunctions::'<' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
+	function '>' specializes IntegerFunctions::'>' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
+	function '<=' specializes IntegerFunctions::'<=' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
+	function '>=' specializes IntegerFunctions::'>=' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }	
+
+	function max specializes IntegerFunctions::max { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+	function min specializes IntegerFunctions::min { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+
+	function '==' specializes IntegerFunctions::'==' { in x: Natural[0..1]; in y: Natural[0..1]; return : Boolean[1]; }
+	
+	function ToString specializes IntegerFunctions::ToString { in x: Natural[1]; return : String[1]; }
+	function ToNatural{ in x: String[1]; return : Natural[1]; }
+}	

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

@@ -0,0 +1,43 @@
+standard library package NumericalFunctions {
+	doc
+	/*
+	 * This package defines abstract functions on Numerical values for general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	private import ControlFunctions::reduce;
+	
+	abstract function isZero{ in x: NumericalValue[1]; return : Boolean; }
+	abstract function isUnit{ in x : NumericalValue[1]; return : Boolean; }
+	
+	abstract function abs{ in x: NumericalValue[1]; return : NumericalValue[1]; }
+		
+	abstract function '+' specializes ScalarFunctions::'+' { in x: NumericalValue[1]; in y: NumericalValue[0..1]; return : NumericalValue[1]; }
+	abstract function '-' specializes ScalarFunctions::'-' { in x: NumericalValue[1]; in y: NumericalValue[0..1]; return : NumericalValue[1]; }
+	abstract function '*' specializes ScalarFunctions::'*' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function '/' specializes ScalarFunctions::'/' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function '**' specializes ScalarFunctions::'**' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function '^' specializes ScalarFunctions::'^' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function '%' specializes ScalarFunctions::'%' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	
+	abstract function '<' specializes ScalarFunctions::'<' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
+	abstract function '>' specializes ScalarFunctions::'>' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
+	abstract function '<=' specializes ScalarFunctions::'<=' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
+	abstract function '>=' specializes ScalarFunctions::'>=' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
+	
+	abstract function max specializes ScalarFunctions::max { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function min specializes ScalarFunctions::min { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	
+	abstract function sum { in collection: ScalarValue[0..*]; return : ScalarValue[1]; }	
+	abstract function product { in collection: ScalarValue[0..*]; return : ScalarValue[1]; }
+	
+	function sum0 { in collection: NumericalValue[0..*]; in zero: ScalarValue[1]; 
+ 		inv { isZero(zero) }		
+        return : ScalarValue = collection->reduce '+' ?? zero;
+	}
+	
+	function product1 { in collection: ScalarValue[0..*]; in one: ScalarValue[1]; 
+		inv { isUnit(one) }		
+        return : ScalarValue = collection->reduce '*' ?? one;
+	}
+}

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

@@ -0,0 +1,154 @@
+standard library package OccurrenceFunctions {
+	doc
+	/*
+	 * This package defines utility functions that operate on occurrences, primarily related to 
+	 * time during which those occurrences exist.
+	 */
+	
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensDuring;
+	private import ScalarValues::Boolean;
+	private import ScalarValues::Positive;
+	private import SequenceFunctions::notEmpty;
+	private import SequenceFunctions::size;
+	private import SequenceFunctions::add;
+	private import SequenceFunctions::addAt;
+	private import SequenceFunctions::remove;
+	private import SequenceFunctions::removeAt;
+	private import ControlFunctions::forAll;
+	 
+	function '==='  specializes BaseFunctions::'===' { 
+		doc
+		/*
+		 * Test whether two occurrences are portions of the same life. That is, whether they 
+		 * represent different portions of the same entity (colloquially, whether they have
+		 * the same "identity").
+		 */
+		 
+		in x: Occurrence[0..1]; 
+		in y: Occurrence[0..1];
+		
+		return : Boolean[1] = x.portionOfLife == y.portionOfLife;
+	}
+	
+	function isDuring {
+		doc
+		/*
+		 * Test whether a performance of this function happens during the input occurrence.
+		 */
+		
+		in occ: Occurrence[1];
+		
+		private connector all during: HappensDuring[0..1] from self to occ;
+		
+		return : Boolean[1] = notEmpty(during);
+	}
+	
+	function create {
+		doc
+		/*
+		 * Ensure that the start of a given occurrence happens during a performance of this
+		 * function. The occurrence is also returned from the function.
+		 */
+		
+		inout occ: Occurrence[1];
+			
+		private connector : HappensDuring from occ.startShot to self;	
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	function destroy {
+		doc
+		/*
+		 * Ensure that the end of a given occurrence happens during a performance of this
+		 * function. The occurrence is also returned from the function.
+		 */
+
+		inout occ: Occurrence[0..1];
+		
+		private connector : HappensDuring from [0..1] occ.endShot to self;
+		
+		return : Occurrence[0..1] = occ;
+	}
+	
+	function addNew {
+		doc
+		/*
+		 * Add a newly created occurrence to the given group of occurrences and return the
+		 * new occurrence.
+		 */
+
+		inout group: Occurrence[0..*] nonunique;
+		inout occ: Occurrence[1];
+		
+		private composite step : add {
+			inout seq1 = group;
+			in seq2 = create(occ);
+		}
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	function addNewAt {
+		doc
+		/*
+		 * Add a newly created occurrence to the given ordered group of occurrences at the given
+		 * index and return the new occurrence.
+		 */
+
+		inout group: Occurrence[0..*] ordered nonunique;
+		inout occ: Occurrence[1];
+		in index: Positive[1];
+		
+		private composite step : addAt {
+			inout seq = group;
+			in values = create(occ);
+			in startIndex = index;
+		}
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	behavior removeOld {
+		doc
+		/*
+		 * Remove a given occurrence from a group of occurrences and destroy it.
+		 */
+
+		inout group: Occurrence[0..*] nonunique;
+		inout occ: Occurrence[0..1];
+		
+		private composite step removeStep : remove {
+			inout seq = group;
+			in values = occ;
+		}
+		private succession removeStep then destroyStep;
+		private composite step destroyStep : destroy {
+			inout occ = removeOld::occ;
+		}
+		
+	}
+	
+	behavior removeOldAt {
+		doc
+		/*
+		 * Removes the occurrence at a given index in an ordered group of occurrences 
+		 * and destroy it.
+		 */
+		inout group: Occurrence[0..*] ordered nonunique;
+		in index: Positive[1];
+		
+		private feature oldOcc = group#(index);
+		
+		private composite step removeStep : remove {
+			inout seq = group;
+			in index = removeOldAt::index;
+		}
+		private succession removeStep then destroyStep;
+		private composite step destroyStep : destroy {
+			inout occ = oldOcc;
+		}
+		
+	}
+}

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

@@ -0,0 +1,49 @@
+standard library package RationalFunctions {
+	doc
+	/*
+	 * This package defines Functions on Rational values, including concrete specializations of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	
+	function rat { in numer: Integer[1]; in denum: Integer[1]; return : Rational[1]; }
+	function numer { in rat: Rational[1]; return : Integer[1]; }
+	function denom { in rat: Rational[1]; return : Integer[1]; }
+	
+	function abs specializes RealFunctions::abs { in x: Rational[1]; return : Rational[1]; }
+
+	function '+' specializes RealFunctions::'+' { in x: Rational[1]; in y: Rational[0..1]; return : Rational[1]; }
+	function '-' specializes RealFunctions::'-' { in x: Rational[1]; in y: Rational[0..1]; return : Rational[1]; }
+	function '*' specializes RealFunctions::'*' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	function '/' specializes RealFunctions::'/' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	function '**' specializes RealFunctions::'**' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	function '^' specializes RealFunctions::'^' { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	
+	function '<' specializes RealFunctions::'<' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }
+	function '>' specializes RealFunctions::'>' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }
+	function '<=' specializes RealFunctions::'<=' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }
+	function '>=' specializes RealFunctions::'>=' { in x: Rational[1]; in y: Rational[1]; return : Boolean[1]; }
+
+	function max specializes RealFunctions::max { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+	function min specializes RealFunctions::min { in x: Rational[1]; in y: Rational[1]; return : Rational[1]; }
+
+	function '==' specializes RealFunctions::'==' { in x: Rational[0..1]; in y: Rational[0..1]; return : Boolean[1]; }
+	
+	function gcd{ in x: Rational[1]; in y: Rational[1]; return : Integer[1]; }
+		
+	function floor specializes RealFunctions::floor { in x: Rational[1]; return : Integer[1]; }
+	function round specializes RealFunctions::round { in x: Rational[1]; return : Integer[1]; }
+	
+	function ToString specializes RealFunctions::ToString { in x: Rational[1]; return : String[1]; }
+	function ToInteger{ in x: Rational[1]; return : Integer[1]; }
+	function ToRational{ in x: String[1]; return : Rational[1]; }
+	
+	function sum specializes RealFunctions::sum { in collection: Rational[0..*];
+		return : Rational[1] default NumericalFunctions::sum0(collection, rat(0, 1));
+	}
+	
+	function product specializes RealFunctions::product { in collection: Rational[0..*];
+		return : Rational[1] default NumericalFunctions::product1(collection, rat(1, 1));
+	}	
+}

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

@@ -0,0 +1,56 @@
+standard library package RealFunctions {
+	doc
+	/*
+	 * This package defines Functions on Real values, including concrete specializations of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	
+	function re :> ComplexFunctions::re{ in x: Real[1]; 
+        return : Real[1] = x;
+	}
+	function im :> ComplexFunctions::im{ in x: Real[1]; 
+        return : Real[1] = 0.0;
+	}
+	
+	function abs specializes ComplexFunctions::abs { in x: Real[1]; return : Real[1]; }
+	function arg specializes ComplexFunctions::arg { in x: Real[1]; 
+        return : Real[1] = 0.0;
+	}
+
+	function '+' specializes ComplexFunctions::'+' { in x: Real[1]; in y: Real[0..1]; return : Real[1]; }
+	function '-' specializes ComplexFunctions::'-' { in x: Real[1]; in y: Real[0..1]; return : Real[1]; }
+	function '*' specializes ComplexFunctions::'*' { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	function '/' specializes ComplexFunctions::'/' { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	function '**' specializes ComplexFunctions::'**' { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	function '^' specializes ComplexFunctions::'^' { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	
+	function '<' specializes NumericalFunctions::'<' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }
+	function '>' specializes NumericalFunctions::'>' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }
+	function '<=' specializes NumericalFunctions::'<=' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }
+	function '>=' specializes NumericalFunctions::'>=' { in x: Real[1]; in y: Real[1]; return : Boolean[1]; }
+
+	function max specializes NumericalFunctions::max { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+	function min specializes NumericalFunctions::min { in x: Real[1]; in y: Real[1]; return : Real[1]; }
+
+	function '==' specializes ComplexFunctions::'==' { in x: Real[0..1]; in y: Real[0..1]; return : Boolean[1]; }
+			
+	function sqrt{ in x: Real[1]; return : Real[1]; }
+
+	function floor{ in x: Real[1]; return : Integer[1]; }
+	function round{ in x: Real[1]; return : Integer[1]; }
+	
+	function ToString specializes ComplexFunctions::ToString { in x: Real[1]; return : String[1]; }
+	function ToInteger{ in x: Real[1]; return : Integer[1]; }
+	function ToRational{ in x: Real[1]; return : Rational[1]; }
+	function ToReal{ in x: String[1]; return : Real[1]; }
+	
+	function sum specializes ComplexFunctions::sum { in collection: Real[0..*]; 
+        return : Real default NumericalFunctions::sum0(collection, 0.0);
+	}
+	
+	function product specializes ComplexFunctions::product { in collection: Real[0..*]; 
+        return : Real default NumericalFunctions::product1(collection, 1.0);
+	}	
+}

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

@@ -0,0 +1,33 @@
+standard library package ScalarFunctions {
+	doc
+	/*
+	 * This package defines abstract functions that specialize the DataFunctions for use with ScalarValues. 
+	 */
+
+	public import ScalarValues::*;
+	
+	abstract function '+' specializes DataFunctions::'+' { in x: ScalarValue[1]; in y: ScalarValue[0..1]; return : ScalarValue[1]; }
+	abstract function '-' specializes DataFunctions::'-' { in x: ScalarValue[1]; in y: ScalarValue[0..1]; return : ScalarValue[1]; }
+	abstract function '*' specializes DataFunctions::'*' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '/' specializes DataFunctions::'/' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '**' specializes DataFunctions::'**' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '^' specializes DataFunctions::'^' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '%' specializes DataFunctions::'%' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	
+	abstract function 'not' specializes DataFunctions::'not' { in x: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function 'xor' specializes DataFunctions::'xor' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+
+	abstract function '~' specializes DataFunctions::'~' { in x: ScalarValue[1]; return : ScalarValue[1]; }	
+	abstract function '|' specializes DataFunctions::'|' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function '&' specializes DataFunctions::'&' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	
+	abstract function '<' specializes DataFunctions::'<' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }
+	abstract function '>' specializes DataFunctions::'>' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }
+	abstract function '<=' specializes DataFunctions::'<=' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }
+	abstract function '>=' specializes DataFunctions::'>=' { in x: ScalarValue[1]; in y: ScalarValue[1]; return : Boolean[1]; }
+	
+	abstract function max specializes DataFunctions::max { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	abstract function min specializes DataFunctions::min { in x: ScalarValue[1]; in y: ScalarValue[1]; return : ScalarValue[1]; }
+	
+	abstract function '..' specializes DataFunctions::'..' { in lower: ScalarValue[1]; in upper: ScalarValue[1]; return : ScalarValue[0..*]; }
+}