sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/library/kernel/TransitionPerformances.kerml

@@ -0,0 +1,66 @@
+standard library package TransitionPerformances {
+	doc
+	/*
+	 * This package contains a library model of the semantics of conditional transitions between occurrences, 
+	 * including the performance of specified Behaviors when the transition occurs.
+	 */
+
+	private import ScalarValues::Boolean;
+	private import ScalarValues::Natural;
+	private import SequenceFunctions::isEmpty;
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensBefore;
+	private import Performances::Performance;
+	private import Performances::Evaluation;
+	private import Transfers::MessageTransfer;
+	private import Transfers::AcceptPerformance;
+	private import Transfers::acceptPerformances;
+	private import ControlFunctions::allTrue;
+	private import SequenceFunctions::size;
+	
+	abstract behavior TransitionPerformance {
+		in feature transitionLinkSource: Performance[1];
+		
+		feature trigger: MessageTransfer[*];
+		bool guard[*] subsets enclosedPerformances;
+		step effect[*] subsets enclosedPerformances;
+
+		feature triggerTarget : Occurrence [1] default this;
+		feature transitionLink: HappensBefore[0..1];
+		
+		private binding [0..1] transitionLink.earlierOccurrence = [1] transitionLinkSource;
+		private succession [1] transitionLinkSource then [*] effect;
+		private succession [*] effect then [1] transitionLink.laterOccurrence;
+		
+		private connector [0..1] transitionLink to [1..*] trigger;
+		private connector all guardConstraint: TPCGuardConstraint[*] 
+			from [0..1] transitionLink to [*] guard;
+			
+		private succession all [*] trigger then [*] guard;
+		private succession all [*] guard then [*] effect;
+
+		feature accNum: Natural [1] = if isEmpty(trigger) ? 0 else 1;
+		step accept: AcceptPerformance[accNum] subsets timeEnclosedOccurrences, acceptPerformances {
+			feature redefines acceptedTransfer = trigger;
+		}
+        binding accept.receiver = triggerTarget;
+
+		private succession [*] guard then [accNum] accept;
+	}
+	
+	behavior NonStateTransitionPerformance specializes TransitionPerformance {
+		feature isTriggerAfter: Boolean default true;
+		private succession [1] transitionLinkSource then [1] Performance::self;
+		private feature taNum: Natural [1] = if isTriggerAfter ? size(trigger) else 0;
+		private succession triggerAfter [taNum] first [0..1] transitionLinkSource then [*] trigger.endShot;
+				
+		private succession all [*] guard then [0..1] transitionLink.laterOccurrence;
+	}
+	
+	assoc struct TPCGuardConstraint {
+		end guardedLink [0..1] feature constrainedHBLink: HappensBefore;
+		end bool constrainedGuard;
+		
+		private inv { allTrue(constrainedGuard()) }
+	}	
+}

sysmlpy/library/kernel/TrigFunctions.kerml

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

sysmlpy/library/kernel/Triggers.kerml

@@ -0,0 +1,188 @@
+standard library package Triggers {
+	doc
+	/*
+	 * This package contains functions that return ChangeSignals for triggering
+	 * when a Boolean condition changes from false to true, at a specific time
+	 * or after a specific time delay.
+	 */
+
+	private import ScalarValues::Boolean;
+	private import ScalarValues::NumericalValue;
+	private import Occurrences::Occurrence;
+	
+	public import Clocks::*;
+	public import Observation::*;
+	
+	struct TimeSignal :> ChangeSignal {
+		doc
+		/*
+		 * A TimeSignal is a ChangeSignal whose condition is the currentTime
+		 * of a given Clock reaching a specific signalTime.
+		 */
+	
+		feature signalTime : NumericalValue[1] {
+			doc
+			/*
+			 * The time at which the TimeSignal should be sent.
+			 */
+		}
+		
+		feature signalClock : Clock[1] {
+			doc
+			/*
+			 * The Clock whose currentTime is being monitored.
+			 */
+		}
+		
+		private bool :>> signalCondition {
+			doc
+			/*
+			 * The Boolean condition of the currentTime of the signalClock being
+			 * equal to the signalTime.
+			 */
+		
+			signalClock.currentTime == signalTime
+		}
+	}
+	
+	function TriggerWhen {
+		doc
+		/*
+		 * TriggerWhen returns a monitored ChangeSignal for a given condition,
+		 * to be sent to a given receiver when the condition occurs.
+		 */
+	
+		in bool condition[1] {
+			doc
+			/*
+			 * The BooleanExpression to be monitored for changing from 
+			 * false to true.
+		 */
+		}
+		
+		in feature receiver : Occurrence [1] {
+			doc
+			/*
+			 * The Occurrence to which the ChangeSignal is to be sent.
+			 */
+		}
+		
+		in feature monitor : ChangeMonitor[1] default defaultMonitor {
+			doc
+			/*
+			 * The ChangeMonitor to be used to monitor the ChangeSignal condition.
+			 * The default is the Observation::defaultMonitor.
+			 */
+		}
+		
+		return feature changeSignal : ChangeSignal[1] = new ChangeSignal(condition, monitor) {
+			doc
+			/*
+			 * The ChangeSignal for the condition, as monitored by the monitor.
+			 */
+		}
+		
+		step :> monitor.startObservation {
+			in observer = receiver;
+			in signal = changeSignal;
+		}		
+	}
+	
+	function TriggerAt {
+		doc
+		/*
+		 * TriggerAt returns a monitored TimeSignal to be sent to a receiver when
+		 * the currentTime of a given Clock reaches a specific timeInstant. 
+		 */
+	
+		in feature timeInstant : NumericalValue[1] {
+			doc
+			/*
+			 * The time instant, relative to the clock, at which the TimeSignal should be sent. 
+			 */
+		}
+		
+		in feature receiver : Occurrence[1] {
+			doc
+			/*
+			 * The Occurrence to which the TimeSignal is to be sent.
+			 */
+		}
+		
+		in feature clock : Clock[1] default localClock {
+			doc
+			/*
+			 * The Clock to be used as the reference for the timeInstant. The default is
+			 * the localClock, which will be bound when the function is invoked. 
+			 */
+		}
+		
+		in feature monitor : ChangeMonitor[1] default defaultMonitor {
+			doc
+			/*
+			 * The ChangeMonitor to be used to monitor the TimeSignal condition.
+			 * The default is the Observation::defaultMonitor.
+			 */
+		}
+		
+		return feature timeSignal : TimeSignal[1] = new TimeSignal(timeInstant, clock, monitor) {
+			doc
+			/*
+			 * The TimeSignal for the given timeInstant, as monitored by the monitor.
+			 */
+		}
+		
+		step :> monitor.startObservation {
+			in observer = receiver;
+			in signal = timeSignal;
+		}
+	}
+	
+	function TriggerAfter {
+		doc
+		/*
+		 * TriggerAfter returns a monitored TimeSignal to be sent to a receiver after
+		 * a certain time delay relative to a given Clock.
+		 */
+	
+		in feature delay : NumericalValue[1] {
+			doc
+			/*
+			 * The time duration, relative to the clock, after which the TimeSignal is sent.
+			 */
+		}
+		
+		in feature receiver : Occurrence[1] {
+			doc
+			/*
+			 * The Occurrence to which the TimeSignal is to be sent.
+			 */
+		}
+		
+		in feature clock : Clock[1] default localClock {
+			doc
+			/*
+			 * The Clock to be used as the reference for the time delay. The default is
+			 * the localClock, which will be bound when the function is invoked. 
+			 */
+		}
+		
+		in feature monitor : ChangeMonitor[1] default defaultMonitor {
+			doc
+			/*
+			 * The ChangeMonitor to be used to monitor the TimeSignal condition.
+			 * The default is the Observation::defaultMonitor.
+			 */
+		}
+		
+		return signal : TimeSignal[1] = 
+			TriggerAt(clock.currentTime + delay, receiver, clock, monitor) {
+			doc
+			/*
+			 * The TimeSignal for the currentTime of the clock when the function is invoked
+			 * plus the given time delay, as monitored by the monitor.
+			 */
+		}
+	}	
+	
+}

sysmlpy/library/kernel/VectorFunctions.kerml

@@ -0,0 +1,273 @@
+standard library package VectorFunctions {
+	doc
+	/*
+	 * This package defines abstract functions on VectorValues corresponding to the algebraic operations
+	 * provided by a vector space with inner product. It also includes concrete implementations of these
+	 * functions specifically for CartesianVectorValues.
+	 */
+
+	private import ScalarValues::NumericalValue;
+	private import ScalarValues::Positive;
+	private import ScalarValues::Real;
+	private import ScalarValues::Boolean;
+	private import NumericalFunctions::*;
+	private import RealFunctions::sqrt;
+	private import TrigFunctions::arccos;
+	private import SequenceFunctions::size;
+	private import ControlFunctions::*;
+	
+	public import VectorValues::*;
+	
+	/* Generic arithmetic functions for all VectorValues. */
+	
+	abstract function isZeroVector {
+		doc
+		/*
+		 * Return whether a VectorValue is a zero vector.
+		 */
+		 
+		in v: VectorValue[1]; 
+		return : Boolean[1]; 
+	}
+	
+	abstract function '+' specializes DataFunctions::'+' {
+		doc
+		/*
+		 * With two arguments, returns the sum of two VectorValues. With one argument, returns that VectorValue.
+		 */
+		 
+	 	in v: VectorValue[1]; 
+	 	in w: VectorValue[0..1]; 
+		return u: VectorValue[1];
+		inv zeroAddition { w == null or isZeroVector(w) implies u == w }
+		inv commutivity { w != null implies u == w + v }
+	}
+	
+	abstract function '-' specializes DataFunctions::'-' {
+		doc
+		/*
+		 * With two arguments, returns the difference of two VectorValues. With one arguments, returns the inverse
+		 * of the given VectorValue, that is, the VectorValue that, when added to the original VectorValue, results in
+		 * the zeroVector.
+		 */
+	 
+		in v: VectorValue[1]; 
+		in w: VectorValue[0..1]; 
+		return u: VectorValue[1];
+		inv negation { w == null implies isZeroVector(v + u) }
+		inv difference { w != null implies v + u == w }
+	}
+	
+	abstract function sum0 {
+		doc
+		/*
+		 * Return the sum of a collection of VectorValues. If the collection is empty, return a given zero vector.
+		 */
+	 
+		in coll: VectorValue[*] nonunique; 
+		in zero: VectorValue[1]; 
+		inv precondition { isZeroVector(zero) }
+		return s: VectorValue[1] = coll->reduce '+' ?? zero;
+	}
+
+	/* Functions specific to NumericalVectorValues. */
+	
+	function VectorOf {
+		doc
+		/*
+		 * Construct a NumericalVectorValue whose elements are a non-empty list of component NumericalValues.
+		 * The dimension of the NumericalVectorValue is equal to the number of components.
+		 */
+	 
+		in components: NumericalValue[1..*] ordered nonunique; 
+		return : NumericalVectorValue[1] {
+			:>> dimension = size(components);
+			:>> elements = components;
+		}
+	}
+	
+	abstract function scalarVectorMult specializes DataFunctions::'*' {
+		doc
+		/*
+		 * Scalar product of a NumericalValue and a NumericalVectorValue.
+		 */
+	 
+		in x: NumericalValue[1]; 
+		in v: NumericalVectorValue[1];
+		return w: NumericalVectorValue[1];
+		inv scaling { norm(w) == x * norm(v) }
+		inv zeroLength { isZeroVector(w) implies isZero(norm(w))}
+	}
+	alias '*' for scalarVectorMult;
+	
+	abstract function vectorScalarMult specializes DataFunctions::'*' {
+		doc
+		/*
+		 * Scalar product of a NumericalVectorValue and a NumericalValue, which has the same value as the scalar product of the
+		 * NumericalValue and the NumericalVectorValue.
+		 */
+	 
+		in v: NumericalVectorValue[1]; 
+		in x: NumericalValue[1];
+		return w: NumericalVectorValue[1] default scalarVectorMult(x, v);
+	}
+	
+	abstract function vectorScalarDiv specializes DataFunctions::'/' {
+		doc
+		/*
+		 * Scalar quotient of a NumericalVectorValue and a NumericalValue, defined as the scalar product of the inverse of the 
+		 * NumericalValue and the NumericalVectorValue.
+		 */
+	 
+		in v: NumericalVectorValue[1]; 
+		in x: NumericalValue[1];
+		return w: NumericalVectorValue[1] = scalarVectorMult(1.0 / x, v);
+	}
+
+	abstract function inner specializes DataFunctions::'*' {
+		doc
+		/*
+		 * Inner product of two NumericalVectorValues.
+		 */
+	 
+		in v: NumericalVectorValue[1]; 
+		in w: NumericalVectorValue[1];
+		return x: NumericalValue[1];
+		inv commmutivity { x == inner(w, v) }
+		inv zeroInner { isZeroVector(v) or isZeroVector(w) implies isZero(x)}
+	}
+	
+	abstract function norm {
+		doc
+		/*
+		 * The norm (magnitude) of a NumericalVectorValue, as a NumericalValue.
+		 */
+	 
+		in v: NumericalVectorValue[1]; 
+		return l : NumericalValue[1];
+		inv squareNorm { l * l == inner(v,v) }
+		inv lengthZero { isZero(l) == isZeroVector(v) }
+	}
+	
+	abstract function angle {
+		doc
+		/*
+		 * The angle between two NumericalVectorValues, as a NumericalValue.
+		 */
+		 
+	 	in v: NumericalVectorValue[1]; 
+	 	in w: NumericalVectorValue[1]; 
+		return theta: NumericalValue[1];
+		inv commutivity { theta == angle(w, v) }
+		inv lengthInsensitive { theta == angle(w / norm(w), v / norm(v)) }
+	}
+	
+	/* Specialized functions with concrete definitions for CartesianVectorValues. */
+	
+	function CartesianVectorOf {
+		doc
+		/*
+		 * Construct a CartesianVectorValue whose elements are a non-empty list of Real components.
+		 * The dimension of the NumericalVectorValue is equal to the number of components.
+		 */
+	 
+		in components: Real[*] ordered nonunique; 
+		return : CartesianVectorValue[1] {
+			:>> dimension = size(components);
+			:>> elements = components;
+		}
+	}
+	function CartesianThreeVectorOf specializes CartesianVectorOf { 
+		in components: Real[3] ordered nonunique;
+		return : CartesianThreeVectorValue[1] {
+		    feature :>> CartesianVectorOf::result::dimension, CartesianThreeVectorValue::dimension;
+		}
+	}
+	
+	feature cartesianZeroVector: CartesianVectorValue[3] =
+		(
+			CartesianVectorOf(0.0),
+			CartesianVectorOf((0.0, 0.0)),
+			CartesianThreeVectorOf((0.0, 0.0, 0.0))
+		) {
+		doc
+		/*
+		 * Cartesian zero vectors of 1, 2 and 3 dimensions.
+		 */
+	}
+	feature cartesian3DZeroVector: CartesianThreeVectorValue[1] =
+		cartesianZeroVector#(3);
+	
+	function isCartesianZeroVector specializes isZeroVector {
+		doc
+		/*
+		 * A CartesianVectorValue is a zero vector if all its elements are zero.
+		 */
+	 
+		in v: CartesianVectorValue[1]; 
+		return : Boolean[1] = v.elements->forAll{in x; x == 0.0};
+	}
+	
+	function 'cartesian+' specializes '+' { 
+		in v: CartesianVectorValue[1]; 
+		in w: CartesianVectorValue[0..1];
+		inv precondition { w != null implies v.dimension == w.dimension }
+		return u: CartesianVectorValue[1] =
+			if w == null? v
+			else CartesianVectorOf(
+				(1..w.dimension)->collect{in i : Positive; v#(i) + w#(i)}
+			);
+	}
+	
+	function 'cartesian-' specializes '-' { 
+		in v: CartesianVectorValue[1]; 
+		in w: CartesianVectorValue[0..1];
+		inv precondition { w != null implies v.dimension == w.dimension }
+		return u: CartesianVectorValue[1] =
+			CartesianVectorOf(
+				if w == null? CartesianVectorOf(v.elements->collect{in x : Real; -x})
+				else CartesianVectorOf(
+					(1..v.dimension)->collect{in i : Positive; v#(i) - w#(i)}
+				)
+			);
+	}
+	
+	function cartesianScalarVectorMult specializes scalarVectorMult { 
+		in x: Real[1]; 
+		in v: CartesianVectorValue[1];
+		return w: CartesianVectorValue[1] =
+			CartesianVectorOf(
+				v.elements->collect{in y : Real; x * y}
+			);
+	}
+	function cartesianVectorScalarMult specializes vectorScalarMult { 
+		in v: CartesianVectorValue[1]; 
+		in x: Real[1]; 
+		return w: CartesianVectorValue[1] = cartesianScalarVectorMult(x, v);
+	}
+	
+	function cartesianInner specializes inner { 
+		in v: CartesianVectorValue[1]; 
+		in w : CartesianVectorValue[1];
+		inv precondition { v.dimension == w.dimension }
+		return x: Real[1] =
+			(1..v.dimension)->collect{in i : Positive; v#(i) * w#(i)}->reduce RealFunctions::'+';
+	}
+	
+	function cartesianNorm specializes norm { 
+		in v: CartesianVectorValue[1];
+		return l : NumericalValue[1] = sqrt(cartesianInner(v, v));
+	}
+	
+	function cartesianAngle specializes angle { 
+		in v: CartesianVectorValue[1]; in w: CartesianVectorValue[1];
+		inv precondition { v.dimension == w.dimension }
+		return theta: Real[1] = arccos(cartesianInner(v, w) / (norm(v) * norm(w)));
+	}
+	
+	function sum { 
+		in coll: CartesianThreeVectorValue[*];
+		return : CartesianThreeVectorValue[1] = sum0(coll, cartesian3DZeroVector);
+	}
+	
+}

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