sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/library/domain/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. */
+	}
+}

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

sysmlpy/library/kernel/Base.kerml

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

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

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

sysmlpy/library/kernel/Clocks.kerml

@@ -0,0 +1,156 @@
+standard library package Clocks {
+	doc
+	/*
+	 * This package models Clocks that provide an advancing numerical reference 
+	 * usable for quantifying the time of an Occurrence.
+	 */
+
+	private import ScalarValues::NumericalValue;
+	private import ScalarValues::Real;
+	private import Occurrences::Occurrence;
+	private import Occurrences::Life;
+	private import ControlFunctions::forAll;
+	
+	private struct UniversalClockLife[1] :> Clock, Life {
+	    doc
+	    /*
+	     * UniversalClockLife is the classifier of the singleton Life of the universalClock.
+	     */
+	}
+	
+	feature universalClock : UniversalClockLife[1] {
+		doc
+		/*
+		 * universalClock is a single Clock that can be used as a default universal
+		 * time reference.
+		 */
+	}
+	
+	abstract struct Clock {
+		doc
+		/*
+		 * A Clock provides a numerical currentTime that advances montonically
+		 * over its lifetime. Clock is an abstract base Structure that can be
+		 * specialized for different kinds of time quantification (e.g., discrete
+		 * time, continuous time, time with units, etc.).
+		 */
+		 
+		private thisClock : Clock :>> self;
+		
+		var feature currentTime : NumericalValue[1] {
+			doc
+			/*
+			 * A scalar time reference that advances over the lifetime of the Clock. 
+			 */
+		}
+						
+		inv timeFlowConstraint {
+			doc
+			/*
+			 * The currentTime of a snapshot of a Clock is equal to
+			 * the TimeOf the snapshot relative to that Clock.
+			 */
+			
+			snapshots->forAll{in s : Clock; 
+				TimeOf(s, thisClock) == s.currentTime
+			}
+		}		
+	}
+	
+	abstract function TimeOf {
+		doc
+		/*
+		 * TimeOf returns a numerical timeInstant for a given Occurrence relative to
+		 * a given Clock. The timeInstant is the time of the start of the Occurrence,
+		 * which is considered to be synchronized with the snapshot of the Clock 
+		 * with a currentTime equal to the returned timeInstant.
+		 */
+		
+		in o : Occurrence[1];
+		in clock : Clock[1] default localClock;
+		return timeInstant : NumericalValue[1];
+		
+		 inv startTimeConstraint {
+		 	doc
+			/*
+			 * The TimeOf an Occurrence is equal to the time of its start snapshot.
+			 */
+			 
+		 	timeInstant == TimeOf(o.startShot, clock)
+		 }	 
+
+		inv timeOrderingConstraint {
+			doc
+			/*
+			 * If one Occurrence happens before another, then the TimeOf the end
+			 * snapshot of the first Occurrence is no greater than the TimeOf the 
+			 * second Occurrence.
+			 */
+			
+			o.predecessors->forAll{in p : Occurrence; 
+				TimeOf(p.endShot, clock) <= timeInstant
+			}
+		}
+				
+		inv timeContinuityConstraint {
+			doc
+			/*
+			 * If one Occurrence happens immediately before another, then the TimeOf 
+			 * the end snapshot of the first Occurrence equals the TimeOf the second
+			 * Occurrence.
+			 */
+		 
+			o.immediatePredecessors->forAll{in p : Occurrence; 
+				TimeOf(p.endShot, clock) == timeInstant
+			}
+		}				
+	}
+	
+	function DurationOf {
+		doc
+		/*
+		 * DurationOf returns the duration of a given Occurrence relative to a
+		 * given Clock, which is equal to the TimeOf the end snapshot of the
+		 * Occurrence minus the TimeOf its start snapshot.
+		 */
+		
+		in o : Occurrence[1]; 
+		in clock : Clock[1] default localClock;
+		return duration : NumericalValue =
+			TimeOf(o.endShot, clock) - TimeOf(o.startShot, clock);
+	}
+	
+	struct BasicClock :> Clock {
+		doc
+		/*
+		 * A BasicClock is a Clock whose currentTime is a Real number.
+		 */
+		
+		var feature :>> currentTime : Real;
+	}
+	
+	function BasicTimeOf :> TimeOf {
+		doc
+		/*
+		 * BasicTimeOf returns the TimeOf an Occurrence as a Real number relative
+		 * to a BasicClock.
+		 */
+
+		in o : Occurrence[1];
+		in clock : BasicClock[1];
+		return : Real[1];
+	}
+	
+	function BasicDurationOf :> DurationOf {
+		doc
+		/*
+		 * BasicDurationOf returns the DurationOf an Occurrence as a Real number relative
+		 * to a BasicClock.
+		 */
+		
+		in o : Occurrence[1];
+		in clock : BasicClock[1];
+		return : Real[1];
+	}
+
+}

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

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