sysmledgraph 0.7.0

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Requirement Derivation/.project.json

@@ -0,0 +1,19 @@
+{
+  "name": "SysML Requirement Derivation Library",
+  "version": "2.0.0",
+  "description": "Standard requirements derivation domain library for the Systems Modeling Language (SysML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.0.0"
+    }
+  ]
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Requirement Derivation/DerivationConnections.sysml

@@ -0,0 +1,63 @@
+standard library package DerivationConnections {
+	doc
+	/*
+	 * This package provides a library model for derivation connections between requirements.
+	 */
+	 
+	private import SequenceFunctions::excludes;
+	private import ControlFunctions::allTrue;
+	
+	requirement originalRequirements[*] {
+		doc /* originalRequirements are the original requirements in Derivation connections. */
+	}
+	requirement derivedRequirements[*] {
+		doc /* derivedRequirements are the derived requirments in Derivation connections. */
+	}
+	
+	abstract connection def Derivation {
+		doc
+		/*
+		 * A Derivation connection asserts that one or more derivedRequirements are derived from
+		 * a single originalRequirement. This means that any subject that satisfies the
+		 * originalRequirement should, in itself or though other things related to it, satisfy
+		 * each of the derivedRequirements.
+		 * 
+		 * A connection usage typed by Derivation must have requirement usages for all its ends.
+		 * The single end for the originalRequirement should subset originalRequirement, while
+		 * the rest of the ends should subset derivedRequirements.
+		 */
+		
+		// Note: This redefinition causes a distinguishibility problem for binary connections, becuse
+		// participant is already redefined for them to limit the multiplicity to 2.
+		// ref requirement :>> participant {
+		//	doc /* All the participants in a Derivation must be requirements. */
+		// }
+		
+		ref requirement originalRequirement[1] :>> originalRequirements :> participant {
+			doc /* The single original requirement. */
+		}
+		ref requirement :>> derivedRequirements[1..*] :> participant {
+			doc /* The one or more requirements that are derived from the original requirement. */
+		}
+		
+		private assert constraint originalNotDerived {
+			doc /* The original requirement must not be a derived requirement. */
+			
+			derivedRequirements->excludes(originalRequirement)
+		}
+		
+		private assert constraint originalImpliesDerived {
+			doc 
+			/* 
+			 * Whenever the originalRequirement is satisfied, all of the derivedRequirements must also
+			 * be satisfied.
+			 */
+			 
+			originalRequirement.result implies allTrue(derivedRequirements.result)
+		}	
+	}
+	
+	abstract connection derivations : Derivation[*] {
+		doc /* derivations is the base feature for Derivation connection usages. */
+	}
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Domain Libraries/Requirement Derivation/RequirementDerivation.sysml

@@ -0,0 +1,39 @@
+standard library package RequirementDerivation {
+	doc /* This package provides language-extension metadata for modeling requirement derivation. */
+	
+	public import DerivationConnections::*;
+	private import Metaobjects::SemanticMetadata;
+	
+	metadata def <original> OriginalRequirementMetadata :> SemanticMetadata {
+		doc
+		/*
+		 * OriginalRequirementMetadata identifies a usage as an original requirement.
+		 * It is intended to be used to tag the original requirement end of a Derivation.
+		 */
+		 
+		:> annotatedElement : SysML::Usage;
+		:>> baseType = originalRequirements meta SysML::Usage;
+	}
+	
+	metadata def <derive> DerivedRequirementMetadata :> SemanticMetadata {
+		doc
+		/*
+		 * DerivedRequirementMetadata identifies a usage as a derived requirement.
+		 * It is intended to be used to tag the derived requirement ends of a Derivation.
+		 */
+		 
+		:> annotatedElement : SysML::Usage;	
+		:>> baseType = derivedRequirements meta SysML::Usage;
+	}
+	
+	metadata def <derivation> DerivationMetadata :> SemanticMetadata {
+		doc
+		/*
+		 * DerivationMetadata is SemanticMetadata for a Derivation connection.
+		 */
+		 
+		:> annotatedElement : SysML::ConnectionDefinition;
+		:> annotatedElement : SysML::ConnectionUsage;
+		:>> baseType = derivations meta SysML::Usage;
+	}	
+}

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

@@ -0,0 +1,9 @@
+{
+  "index": {
+    "Collections": "Collections.kerml",
+    "ScalarValues": "ScalarValues.kerml",
+    "VectorValues": "VectorValues.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 Data Type Library/.project.json

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

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Data Type Library/Collections.kerml

@@ -0,0 +1,147 @@
+standard library package Collections {
+	doc
+	/*
+	 * This package defines a standard set of Collection data types. Unlike sequences of values 
+	 * defined directly using multiplicity, these data types allow for the possibility of collections 
+	 * as elements of collections.
+	 */
+
+	private import Base::*;
+	private import ScalarValues::*;
+	private import SequenceFunctions::size;
+	private import IntegerFunctions::*;
+	private import ControlFunctions::*;
+
+	abstract datatype Collection {
+		doc
+		/*
+		 * Collection is the top level abstract supertype of all collection types.
+		 * The name elements is used to denote the members or contents of the collection.
+		 */
+		
+		feature elements[0..*] nonunique;
+	}
+
+    abstract datatype OrderedCollection :> Collection {
+    	doc
+		/*
+		 * OrderedCollection is the abstract supertype for all ordered collection types.
+		 */
+    	
+		feature elements[0..*] ordered nonunique :>> Collection::elements;
+    }
+
+    abstract datatype UniqueCollection :> Collection {
+    	doc
+		/*
+		 * UniqueCollection is the abstract supertype for all collection types with unique elements.
+		 */
+		
+		feature elements[0..*] :>> Collection::elements {
+			/* Note: Redefinition of 'elements' is unique by default. */
+		}
+    }
+
+    datatype Array :> OrderedCollection {
+    	doc
+	    /*
+	     * An Array is a fixed size, multi-dimensional Collection of which the elements are nonunique and ordered. 
+	     * Its dimensions specify how many dimensions the array has, and how many elements there are in each dimension. 
+	     * The rank is equal to the number of dimensions. The flattenedSize is equal to the total number of elements 
+	     * in the array.
+	     * 
+	     * Feature elements is a flattened sequence of all elements of an Array and can be accessed by a tuple of indices. 
+	     * The number of indices is equal to rank. The elements are packed according to row-major convention, as in the C programming language.
+	     * 
+	     * The elements of an Array can be assessed by a tuple of indices. The number of indices in such tuple is equal to rank. 
+		 * The packing of the elements, i.e. the flattened representation, follows the row-major convention, 
+		 * as in the C programming language.
+		 * 
+		 * Note 1. Feature dimensions may be empty, which denotes a zero dimensional array, allowing an Array to collapse to a single element. 
+		 * This is useful to allow for specialization of an Array into a type restricted to represent a scalar. 
+		 * The flattenedSize of a zero dimensional array is 1.
+		 * 
+		 * Note 2: An Array can represent the generalized mathematical concept of an infinite matrix of any rank, i.e. not limited to rank two.
+	     */
+	     
+        feature dimensions: Positive[0..*] ordered nonunique {
+        	doc
+       		/* Feature `dimensions` defines the N-dimensional shape of the Array
+             * The alternative name `shape` (as used in many programming languages) is not used as it would interfere with a geometric shape feature.
+ 			 */
+        }
+        feature rank: Natural[1] = size(dimensions);
+        feature flattenedSize: Positive[1] = dimensions->reduce '*' ?? 1;
+        inv { flattenedSize == size(elements) }
+    }
+    
+	datatype Bag :> Collection {
+		doc
+		/*
+		 * Bag is a variable-size, unordered collection of nonunique elements.
+		 */		
+	}
+	
+	datatype Set :> UniqueCollection {
+		doc
+		/*
+		 * Set is a variable-size, unordered collection of unique elements.
+		 */
+	}
+
+	datatype OrderedSet :> OrderedCollection, UniqueCollection 
+		intersects OrderedCollection, UniqueCollection {
+		doc
+		/*
+		 * OrderedSet is a variable-size, ordered collection of unique elements.
+		 */	
+		
+		feature elements[0..*] ordered :>> OrderedCollection::elements, UniqueCollection::elements {
+			/* Note: Redefinition of `elements` is unique by default. */
+		}
+	}
+		
+	datatype List :> OrderedCollection {
+		doc
+		/*
+		 * List is a variable-size, ordered collection of nonunique elements.
+		 */
+	}
+
+    datatype KeyValuePair {
+    	doc
+		/*
+		 * KeyValuePair is a tuple of a key and a value for use in Map collections.
+		 * The key must be immutable.
+		 */
+    	
+        feature key: Anything[0..*] ordered nonunique;
+        feature val: Anything[0..*] ordered nonunique;
+    }
+
+    datatype Map :> Collection {
+    	doc
+		/*
+		 * Map is a variable-size, unordered collection of elements that are key-value pairs.
+		 */
+    	
+		feature elements: KeyValuePair[0..*] :>> Collection::elements {
+			/* Note: Redefinition of `elements` is unique by default. 
+			 * The `key` of any `KeyValuePair` must be unique over the collection of `KeyValuePair`. 
+			 * The `val` does not need to be unique. 
+			 */			
+		}
+    }
+
+    datatype OrderedMap :> Map {
+    	doc
+		/*
+		 * OrderedMap is a variable-size, ordered collection of elements that are key-value pairs. 
+		 */
+
+		feature elements: KeyValuePair[0..*] ordered :>> Map::elements {
+			/* Note: Redefinition of `elements` is unique by default. */
+		}
+    }
+    
+}

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Data Type Library/ScalarValues.kerml

@@ -0,0 +1,23 @@
+standard library package ScalarValues {
+	doc
+	/*
+	 * This package contains a basic set of primitive scalar (non-collection) data types. 
+	 * These include Boolean and String types and a hierarchy of concrete Number types, from 
+	 * the most general type of Complex numbers to the most specific type of Positive integers.</p>
+	 */
+
+	private import Base::DataValue;
+	
+	abstract datatype ScalarValue specializes DataValue;
+	datatype Boolean specializes ScalarValue;
+	datatype String specializes ScalarValue;
+	abstract datatype NumericalValue specializes ScalarValue;
+	
+    abstract datatype Number specializes NumericalValue;
+	datatype Complex specializes Number;
+	datatype Real specializes Complex;	
+	datatype Rational specializes Real;
+	datatype Integer specializes Rational;
+	datatype Natural specializes Integer;
+    datatype Positive specializes Natural;	
+}		

package/lsp/node_modules/sysml-v2-lsp/sysml.library/Kernel Libraries/Kernel Data Type Library/VectorValues.kerml

@@ -0,0 +1,64 @@
+standard library package VectorValues {
+	doc
+	/*
+	 * This package provides a basic model of abstract vectors as well as concrete vectors
+	 * whose components are numerical values. The package VectorFunctions defines the 
+	 * corresponding vector-space functions.
+	 */
+
+	private import ScalarValues::NumericalValue;
+	private import ScalarValues::Real;
+	private import Collections::Array;
+	
+	abstract datatype VectorValue {
+		doc
+		/*
+		 * A VectorValue is an abstract data type whose values may be operated on using
+		 * VectorFunctions.
+		 */
+	}
+	
+	datatype NumericalVectorValue :> VectorValue, Array intersects VectorValue, Array {
+		doc
+		/*
+		 * A NumericalVectorValue is a kind of VectorValue that is specifically represented
+		 * as a one-dimensional array of NumericalValues. The dimension is allowed to be empty,
+		 * permitting a NumericalVectorValue of rank 0, which is essentially isomorphic to a
+		 * scalar NumericalValue.
+		 */
+	
+		feature dimension[0..1] :>> dimensions;
+		feature :>> elements : NumericalValue;
+	}
+	
+	datatype CartesianVectorValue :> NumericalVectorValue {
+		doc
+		/*
+		 * CartesianVectorValue is a specialization Numerical VectorValue for which there are 
+		 * specific implementations in VectorFunctions of the abstract vector-space functions.
+		 * 
+		 * Note: The restriction of the element type to Real is to facilitate
+		 * the complete definition of these functions.
+		 */
+	
+		feature :>> elements : Real;
+	}
+
+	datatype ThreeVectorValue :> NumericalVectorValue {
+		doc
+		/*
+		 * A ThreeVectorValue is a NumericalVectorValue that has dimension 3.
+		 */
+	
+		feature :>> dimension = 3;
+	}
+	
+	datatype CartesianThreeVectorValue :> CartesianVectorValue, ThreeVectorValue 
+		intersects CartesianVectorValue, ThreeVectorValue {
+		doc
+		/*
+		 * A CartesianThreeVectorValue is a NumericalVectorValue that is both Cartesian and
+		 * has dimension 3.
+		 */
+	}	
+}

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

@@ -0,0 +1,23 @@
+{
+  "index": {
+    "BaseFunctions": "BaseFunctions.kerml",
+    "BooleanFunctions": "BooleanFunctions.kerml",
+    "CollectionFunctions": "CollectionFunctions.kerml",
+    "ComplexFunctions": "ComplexFunctions.kerml",
+    "ControlFunctions": "ControlFunctions.kerml",
+    "DataFunctions": "DataFunctions.kerml",
+    "IntegerFunctions": "IntegerFunctions.kerml",
+    "NaturalFunctions": "NaturalFunctions.kerml",
+    "NumericalFunctions": "NumericalFunctions.kerml",
+    "OccurrenceFunctions": "OccurrenceFunctions.kerml",
+    "RationalFunctions": "RationalFunctions.kerml",
+    "RealFunctions": "RealFunctions.kerml",
+    "ScalarFunctions": "ScalarFunctions.kerml",
+    "SequenceFunctions": "SequenceFunctions.kerml",
+    "StringFunctions": "StringFunctions.kerml",
+    "TrigFunctions": "TrigFunctions.kerml",
+    "VectorFunctions": "VectorFunctions.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 Function Library/.project.json

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

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

@@ -0,0 +1,80 @@
+standard library package BaseFunctions {
+	doc
+	/*
+	 * This package defines a basic set of functions defined on all kinds of values. 
+	 * Most correspond to similarly named operators in the KerML expression syntax.
+	 */
+
+	private import Base::Anything;
+	private import Objects::Object;
+	private import Metaobjects::Metaobject;
+	private import KerML::Metaclass;
+	private import ScalarValues::*;
+	
+	abstract function '=='{ in x: Anything[0..1]; in y: Anything[0..1]; 
+		return : Boolean[1];
+	}
+	function '!='{ in x: Anything[0..1]; in y: Anything[0..1]; 
+		return : Boolean[1] = not (x == y);
+	}
+	
+	abstract function '==='{ in x: Anything[0..1]; in y: Anything[0..1]; 
+		return : Boolean[1];
+	}
+	function '!=='{ in x: Anything[0..1]; in y: Anything[0..1]; 
+		return : Boolean[1] = not (x === y);
+	}
+	
+	abstract function ToString{ in x: Anything[0..1]; 
+		return : String;
+	}
+	
+	abstract function '['{ in x: Anything[0..*] nonunique; in y: Anything[0..*] nonunique; 
+		return : Anything[0..*] nonunique;
+	}
+	abstract function '#'{ in seq: Anything[0..*] ordered nonunique; in index: Positive[1..*] ordered nonunique; 
+		return : Anything[0..1];
+	}
+	abstract function ','{ in seq1: Anything[0..*] ordered nonunique; in seq2: Anything[0..*] ordered nonunique; 
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+    abstract function 'all'{
+     	return : Object[0..*];
+    }
+    
+	abstract function 'istype'{ 
+		in seq: Anything[0..*];
+		in 'type': Anything;
+		return : Boolean[1];
+	}
+	
+	abstract function 'hastype'{ 
+		in seq: Anything[0..*];
+		in 'type': Anything;
+		return : Boolean;
+	}
+	
+	abstract function '@'{ 
+		in seq: Anything[0..*];
+		in 'type': Anything;
+		return : Boolean[1];
+	}
+	
+	abstract function '@@'{ 
+		in seq: Metaobject[0..*];
+		in 'type': Metaobject;
+		return : Boolean[1];
+	}
+	
+	abstract function 'as'{ 
+		in seq: Anything[0..*] ordered nonunique; 
+		return : Anything[0..*] ordered nonunique;
+	}
+	
+	abstract function 'meta'{ 
+		in seq: Metaobject[0..*] ordered nonunique; 
+		return : Metaobject[0..*] ordered nonunique;
+	}
+	
+}

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

@@ -0,0 +1,22 @@
+standard library package BooleanFunctions {
+	doc
+	/*
+	 * This package defines functions on Boolean values, including those corresponding to 
+	 * (non-conditional) logical operators in the KerML expression notation.
+	 */
+
+	public import ScalarValues::*;
+	
+	function 'not' specializes ScalarFunctions::'not' { in x: Boolean[1]; return : Boolean[1]; }
+	function 'xor' specializes ScalarFunctions::'xor' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
+	
+	function '|' specializes ScalarFunctions::'|' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
+	function '&' specializes ScalarFunctions::'&' { in x: Boolean[1]; in y: Boolean[1]; return : Boolean[1]; }
+	
+	function '==' specializes DataFunctions::'==' { in x: Boolean[0..1]; in y: Boolean[0..1]; return : Boolean[1]; }
+	
+	function ToString specializes BaseFunctions::ToString { in x: Boolean[1]; return : String[1]; }
+	function ToBoolean { in x: String[1]; return : Boolean[1]; }
+	
+}
+	

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

@@ -0,0 +1,68 @@
+standard library package CollectionFunctions {
+	doc
+	/*
+	 * This package defines functions on Collections (as defined in the Collections package). 
+	 * For functions on general sequences of values, see the SequenceFunctions package.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::*;
+	private import SequenceFunctions::equals;
+	private import SequenceFunctions::includes;
+	private import ControlFunctions::exists;
+	public import Collections::*;
+	
+	function '==' specializes BaseFunctions::'==' { in col1: Collection[0..1]; in col2: Collection[0..1];
+		return : Boolean[1] = col1.elements->equals(col2.elements);
+	}
+	
+	function size { in col: Collection[1];
+		return : Natural[1] = SequenceFunctions::size(col.elements);
+	}
+	
+	function isEmpty { in col: Collection[1]; 
+		return : Boolean[1] = SequenceFunctions::isEmpty(col.elements);
+	}
+	
+	function notEmpty { in col: Collection[1]; 
+		return : Boolean[1] = SequenceFunctions::notEmpty(col.elements);
+	}
+	
+	function contains { in col: Collection[1]; in values: Anything[*];
+		return : Boolean[1] = col.elements->includes(values);
+	}
+	
+	function containsAll { in col1: Collection[1]; in col2: Collection[2]; 
+		return : Boolean[1] = contains(col1, col2.elements);
+	}	
+	
+	function head { in col: OrderedCollection[1]; 
+		return : Anything[0..1] = SequenceFunctions::head(col.elements);
+	}
+	
+	function tail { in col: OrderedCollection[1]; 
+		return : Anything[0..*] ordered nonunique = SequenceFunctions::tail(col.elements);	
+	}
+	
+	function last { in col: OrderedCollection[1]; 
+		return : Anything[0..1] = SequenceFunctions::last(col.elements);
+	}
+	
+	function '#' specializes BaseFunctions::'#' { in col: OrderedCollection[1]; in index: Positive[1];
+		// Cast ensures this function is not called recursively if the elements of col are OrderedCollections.
+		return : Anything[0..1] = (col.elements as Anything)#(index);		
+	}
+	
+	function 'array#' specializes BaseFunctions::'#' { in arr: Array[1]; in indexes: Positive[n] ordered nonunique;		
+		private feature n : Natural[1] = arr.rank;
+		
+		// Assumes row-major ordering for elements.
+		private function index { in arr: Array[1]; in i : Natural; in indexes : Positive[1..*];
+			if i <= 1? indexes#(1) else arr.dimensions#(i) * (index(arr, i-1, indexes) - 1) + indexes#(i)
+		}
+		
+		return : Anything[0..1] =
+			if n == 0 or (1..n)->exists {in i; indexes#(i) > arr.dimensions#(i)}? null 
+			else arr.elements#(index(arr, n, indexes));
+	}	
+}

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

@@ -0,0 +1,47 @@
+standard library package ComplexFunctions {
+	doc
+	/*
+	 * This package defines functions on Complex values, including concrete specializations of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+		
+	feature i: Complex[1] = rect(0.0, 1.0);
+	
+	function rect { in re: Real[1]; in im: Real[1]; return : Complex[1]; }
+	function polar { in abs: Real[1]; in arg: Real[1]; return : Complex[1]; }
+	
+	function re { in x: Complex[1]; return : Real[1]; }
+	function im { in x: Complex[1]; return : Real[1]; }
+	
+	function isZero specializes NumericalFunctions::isZero { in x : Complex[1];
+		return : Boolean[1] = re(x) == 0.0 and im(x) == 0.0;
+	}
+	function isUnit specializes NumericalFunctions::isUnit { in x : Complex[1];
+		return : Boolean[1] = re(x) == 1.0 and im(x) == 0.0;
+	}
+	
+	function abs specializes NumericalFunctions::abs { in x: Complex[1]; return : Real[1]; }
+	function arg { in x: Complex[1]; return : Real[1]; }
+	
+	function '+' specializes NumericalFunctions::'+' { in x: Complex[1]; in y: Complex[0..1]; return : Complex[1]; }
+	function '-' specializes NumericalFunctions::'-' { in x: Complex[1]; in y: Complex[0..1]; return : Complex[1]; }
+	function '*' specializes NumericalFunctions::'*' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
+	function '/' specializes NumericalFunctions::'/' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
+	function '**' specializes NumericalFunctions::'**' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
+	function '^' specializes NumericalFunctions::'^' { in x: Complex[1]; in y: Complex[1]; return : Complex[1]; }
+	
+	function '==' specializes DataFunctions::'==' { in x: Complex[0..1]; in y: Complex[0..1]; return : Boolean[1]; }
+	
+	function ToString specializes BaseFunctions::ToString { in x: Complex[1]; return : String[1]; }
+	function ToComplex { in x: String[1]; return : Complex[1]; }
+	
+	function sum specializes NumericalFunctions::sum { in collection: Complex[0..*];
+		return : Complex[1] default NumericalFunctions::sum0(collection, rect(0.0, 0.0));
+	}
+	
+	function product specializes NumericalFunctions::product { in collection: Complex[0..*];
+		return : Complex[1] default NumericalFunctions::product1(collection, rect(1.0, 0.0));
+	}	
+}