sysml-validate 0.11.0 → 0.14.2

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/RationalFunctions.kerml

@@ -1,49 +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));
-	}	
-}
+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/resources/sysml.library/Kernel Libraries/Kernel Function Library/RealFunctions.kerml

@@ -1,56 +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);
-	}	
-}
+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/resources/sysml.library/Kernel Libraries/Kernel Function Library/ScalarFunctions.kerml

@@ -1,33 +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..*]; }
+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..*]; }
 }

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/SequenceFunctions.kerml

@@ -1,111 +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;
-		}
-	}
+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/resources/sysml.library/Kernel Libraries/Kernel Function Library/StringFunctions.kerml

@@ -1,25 +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;
-	}
-}
+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/resources/sysml.library/Kernel Libraries/Kernel Function Library/TrigFunctions.kerml

@@ -1,35 +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]; }
+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]; }
 }