sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/library/kernel/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));
+	}	
+}

sysmlpy/library/kernel/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;
+	}
+	
+}

sysmlpy/library/kernel/ControlPerformances.kerml

@@ -0,0 +1,135 @@
+standard library package ControlPerformances {
+	doc
+	/*
+	 * This package defines Behaviors to be used to type Steps that control the sequencing of performance
+	 * of other Steps. 
+	 */
+
+	private import ScalarValues::Boolean;
+	private import SequenceFunctions::size;
+	private import SequenceFunctions::notEmpty;
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensBefore;
+	private import Occurrences::SelfSameLifeLink;
+	private import Performances::Performance;
+	private import Performances::BooleanEvaluation;
+	
+	behavior DecisionPerformance specializes Performance {
+		doc
+		/*
+		 * A DecisionPerformance is a Performance that represents the selection of one of the Successions
+		 * that have the DecisionPerforance behavior as their source. All such Successions must subset the 
+		 * outgoingHBLink feature of the source DecisionPerformance. For each instance of DecisionPerformance, 
+		 * the outgoingHBLink is an instance of exactly one of the Successions, ordering the DecisionPerformance
+		 * as happening before an instance of the target of that Succcession.
+		 */
+		
+		feature outgoingHBLink: HappensBefore[1] {
+			doc
+			/*
+			 * Specializations subset this by all
+			 * successions going out of a decision step.
+			 */
+
+			 end feature redefines earlierOccurrence subsets that;
+		}
+	}
+	
+	behavior MergePerformance specializes Performance {
+		doc
+		/*
+		 * A MergePerformance is a Performance that represents the merging of all Successions that
+		 * target the MergePerforance behavior. All such Successions must subset the incomingHBLink
+		 * feature of the target MergePerformance. For each instance of MergePerformance, the
+		 * incomingHBLink is an instance of exactly one of the Successions, ordering the
+		 * MergePerformance as happening after an instance of the source of that Succession.
+		 */
+
+		feature incomingHBLink: HappensBefore[1] {
+			doc
+			/*
+			 * Specializations subset this by all
+			 * successions coming into a merge step.
+			 */
+
+			 end feature redefines laterOccurrence subsets that;
+		}
+	}
+
+	abstract behavior IfPerformance specializes Performance {
+		doc
+		/*
+		 * An IfPerformance is a Performance that determines whether the ifTest evaluation result is true 
+		 * (by whether ifTrue has a value).
+		 */	
+		 
+		in ifTest : BooleanEvaluation[1];
+	}
+	
+	behavior IfThenPerformance specializes IfPerformance {
+		doc
+		/*
+		 * An IfThenPerformance is an IfPerformance where the thenClause occurs after and only after the 
+		 * ifTest evaluation result is true.
+		 */
+		
+		in redefines ifTest;
+		in thenClause : Occurrence[0..1];
+		succession [1] ifTest then [0..1] thenClause;
+		inv { ifTest() == thenClause->notEmpty() }
+	}
+	
+	behavior IfElsePerformance specializes IfPerformance {
+		doc
+		/*
+		 * An IfElsePerformance is an IfPerformance where the elseClause occurs after and only 
+		 * after the ifTest evaluation result is not true.
+		 */
+
+		in redefines ifTest;
+		in elseClause : Occurrence[0..1];
+		succession [1] ifTest then [0..1] elseClause;
+		inv { not ifTest() == elseClause->notEmpty() }
+	}
+	
+	behavior IfThenElsePerformance specializes IfThenPerformance {
+		doc
+		/*
+		 * An IfThenElsePerformance is an IfThenPerformance with an additional elseClause that
+		 * occurs after and only after the ifTest evaluation is false.
+		 */
+		 
+		in redefines ifTest;
+		in redefines thenClause;
+        in elseClause : Occurrence[0..1];
+        succession [1] ifTest then [0..1] elseClause;
+        inv { not ifTest() == elseClause->notEmpty() }
+	}
+	
+	behavior LoopPerformance specializes Performance {
+		doc
+		/*
+		 * A LoopPerformance is a Performance where the body occurs repeatedly in sequence (iterates) 
+		 * as long as the whileTest evaluation result is true before each iteration (and after the 
+		 * previous one, except the first time) and the untilTest evaluation result is not true after 
+		 * each iteration and before the next one (except the last one).
+		 */
+		 
+		in whileTest : BooleanEvaluation[1..*];
+		in body : Occurrence[0..*];
+        in untilTest : BooleanEvaluation[0..*];
+		
+		step whileDecision : IfThenPerformance[1..*];
+		step untilDecision : IfElsePerformance[0..*];
+		
+		binding [1] whileDecision.ifTest = [1] whileTest;
+		binding [1] whileDecision.thenClause = [1] body;
+		
+		succession body then untilDecision;
+		
+		binding [1] untilDecision.ifTest = [1] untilTest;
+		binding loopBack of [0..1] untilDecision.elseClause = [1] whileDecision;
+		
+		inv { loopBack->size() == whileDecision->size() - 1 }
+	}
+}

sysmlpy/library/kernel/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; }	
+}

sysmlpy/library/kernel/FeatureReferencingPerformances.kerml

@@ -0,0 +1,190 @@
+standard library package FeatureReferencingPerformances {
+	doc
+	/*
+	 * This package defines Behaviors used to read, write and monitor values of a referenced Feature of an 
+	 * Occurrence.
+	 */
+
+	private import Base::Anything;
+	private import Base::things;
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensWhile;
+	private import Occurrences::HappensBefore;
+	private import Occurrences::HappensJustBefore;
+	private import Occurrences::SelfSameLifeLink;
+	private import Performances::Performance;
+	private import Performances::Evaluation;
+	private import ScalarValues::Boolean;
+	private import SequenceFunctions::isEmpty;
+	private import SequenceFunctions::equals;
+
+	abstract behavior FeatureReferencingPerformance specializes Performance {
+		doc
+		/*
+		 * A FeatureReferencingPerformance is the base Performance for specialized behaviors related 
+		 * to values of a referenced Feature of a given Occurrence, as identified in specializations 
+		 * of this Behavior.
+		 */
+		
+		in abstract feature onOccurrence : Occurrence [1] {
+			doc
+			/*
+			 * Occurrence with values for the referenced feature in specializations of this behavior.
+			 */
+		}
+		 
+		inout feature values : Anything [*] nonunique {
+			doc
+			/*
+			 * Values of the referenced feature, as specified in specializations of this behavior.
+			 */
+		}	
+	}
+
+    abstract behavior FeatureAccessPerformance specializes FeatureReferencingPerformance {
+    	doc
+		/*
+		 * A FeatureAccessPerformance is a FeatureReferencingPerformance where the result values
+		 * are all the values of a feature of onOccurrence at the time the Performance ends. The
+		 * feature is specified by restricting accessedFeature in specializations or usages.
+		 */
+     	
+		in abstract feature onOccurrence : Occurrence {
+			abstract feature startingAt : Occurrence [1] subsets timeSlices {
+				abstract feature accessedFeature : Anything [*] nonunique;
+			}
+		}
+
+	  	 connector :HappensWhile from onOccurrence.startingAt.startShot to endShot {
+	  	 	doc
+			/*
+			 * Requires some time slice of onOccurrence to start when this performance
+			 * ends (this connector), with particular feature values (following connector).
+			 * The feature is specified by restricting the onOccurrence::accessedFeature 
+			 * on usages of this behavior.
+			 */
+	  	 }
+	  	 connector :SelfSameLifeLink from onOccurrence.startingAt.accessedFeature to values;
+	}
+
+	abstract function FeatureReadEvaluation specializes FeatureAccessPerformance, Evaluation { 
+		doc
+		/*
+		 * A FeatureReadEvaluation is a FeatureAccessPerformance that is a function providing as
+		 * its result the values of a feature on an occurrence at the time its evaluation ends.
+		 */
+
+		in onOccurrence: Occurrence [1];
+		return resultValues : Anything [*] nonunique redefines result redefines values;
+	}
+
+	abstract behavior FeatureWritePerformance specializes FeatureAccessPerformance {
+		doc
+		/*
+		 * A FeatureWritePerformance is a FeatureAccessPerformance that assigns the values of a 
+		 * feature on an occurrence to the given replacementValues at time its performance ends.
+		 */
+		 
+		in feature onOccurrence : Occurrence[1] redefines onOccurrence;
+		inout feature replacementValues : Anything redefines values [*] nonunique;
+	}
+	
+	abstract behavior FeatureMonitorPerformance specializes FeatureReferencingPerformance {
+		doc
+		/*
+		 * A FeatureMonitorPerformance is a FeatureReferencingPerformance that waits for values
+		 * of monitoredFeature to change on onOccurrence from what they were when the performance 
+		 * started. The values before and after the change are given by beforeValues and afterValues.
+		 */	
+
+		in feature redefines onOccurrence {
+	    	feature monitoredOccurrence : Occurrence [1] subsets timeSlices {
+	      		abstract feature monitoredFeature : Anything[*] nonunique;
+	      		feature beforeTimeSlice : Occurrence [1] subsets timeSlices {
+	        		feature redefines monitoredFeature;
+	        	}
+	      		feature afterSnapshot : Occurrence [1] subsets snapshots {
+	        		feature redefines monitoredFeature;
+	        	}
+	      		connector :HappensJustBefore from beforeTimeSlice to afterSnapshot;
+	        }
+	  	}
+	  	out feature afterValues redefines values;
+	  	out feature beforeValues : Anything[*] nonunique;
+	  	inv { not beforeValues->equals(afterValues) }
+	
+	  	private connector : HappensWhile 
+	  		from [1] onOccurrence.monitoredOccurrence.beforeTimeSlice.startShot to [1] startShot;
+	  	private connector : SelfSameLifeLink 
+	  		from [1] onOccurrence.monitoredOccurrence.beforeTimeSlice.monitoredFeature to [1] beforeValues;
+	  	private connector : SelfSameLifeLink 
+	  		from [1] onOccurrence.monitoredOccurrence.afterSnapshot.monitoredFeature to [1] afterValues;
+	  	protected connector endWhen : HappensBefore 
+	  		from [1] onOccurrence.monitoredOccurrence.afterSnapshot to [1] endShot;
+	}
+		
+	behavior EvaluationResultMonitorPerformance specializes FeatureMonitorPerformance {
+		doc
+		/*
+		 * An EvaluationResultMonitorPerformance is a FeatureMonitorPerformance that waits for changes 
+		 * in the result of an Evaluation identified by onOccurrence. The Predicate being evaluated must 
+		 * be able to produce multiple results over time, for example by only using BindingConnectors 
+		 * between Steps, rather than Successions or Flows, including in its Step behaviors.
+		 */
+		
+		in feature onOccurrence : Evaluation redefines onOccurrence {
+	    	protected expr monitoredOccurrence : Evaluation [1] redefines monitoredOccurrence {
+				return result : Anything[*] redefines result, monitoredFeature; 
+			} 
+		} 
+	}
+	
+	behavior BooleanEvaluationResultMonitorPerformance specializes EvaluationResultMonitorPerformance {
+		doc
+		/*
+		 * A BooleanEvaluationResultMonitorPerformance is a EvaluationResultMonitorPerformance
+		 * that waits for changes in the result of a BooleanEvaluation identified by onOccurrence.
+		 */	
+		
+	  	in bool redefines onOccurrence {
+	    	protected bool redefines monitoredOccurrence[1] {
+	    	    return result : Boolean [1];
+	    	}
+		}
+		out redefines afterValues : Boolean [1]; 
+		out redefines beforeValues : Boolean [1];	 
+	}
+	
+	behavior BooleanEvaluationResultToMonitorPerformance specializes FeatureReferencingPerformance {
+		doc
+		/*
+		 * A BooleanEvaluationResultToMonitorPerformance is a FeatureReferencingPerformance that waits 
+		 * for the result of a BooleanEvaluation (identified by onOccurrence) to change to either true 
+		 * or false, as indicated by isToTrue (defaulting to true). If the result is already true (or false), 
+		 * the performance waits for the result to become false (or true) before waiting again for it to 
+		 * change back.
+		 */	
+		 
+  		in bool redefines onOccurrence;
+  		feature isToTrue : Boolean [1] default true;
+  		out afterValues: Boolean[1] redefines values  = isToTrue;
+  		private feature monitor1 : BooleanEvaluationResultMonitorPerformance [1] {
+    		feature redefines endWhen : HappensJustBefore {
+    		    end feature earlierOccurrence;
+    		    end feature laterOccurrence;
+    		}
+  		}
+  		private feature monitor2 : BooleanEvaluationResultMonitorPerformance [1] {
+    		feature redefines endWhen : HappensJustBefore {
+                end feature earlierOccurrence;
+                end feature laterOccurrence;
+            }
+  		}
+
+  		private connector : HappensJustBefore from [1] monitor1 to [0..1] monitor2;
+  		inv { isEmpty(monitor2) == (monitor1.afterValues == isToTrue) }
+
+  		private binding [1] monitor1.onOccurrence = [1] onOccurrence;
+  		private binding [1] monitor2.onOccurrence = [1] onOccurrence;
+	}
+}

sysmlpy/library/kernel/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);
+	}
+}