sysml-validate 0.10.18 → 0.14.2

package/resources/sysml.library/Domain Libraries/Analysis/.meta.json

@@ -1,10 +1,10 @@
-{
-  "index": {
-    "AnalysisTooling": "AnalysisTooling.sysml",
-    "SampledFunctions": "SampledFunctions.sysml",
-    "StateSpaceRepresentation": "StateSpaceRepresentation.sysml",
-    "TradeStudies": "TradeStudies.sysml"
-  },
-  "created": "2025-03-13T00:00:00Z",
-  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+{
+  "index": {
+    "AnalysisTooling": "AnalysisTooling.sysml",
+    "SampledFunctions": "SampledFunctions.sysml",
+    "StateSpaceRepresentation": "StateSpaceRepresentation.sysml",
+    "TradeStudies": "TradeStudies.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
 }

package/resources/sysml.library/Domain Libraries/Analysis/.project.json

@@ -1,27 +1,27 @@
-{
-  "name": "SysML Analysis Library",
-  "version": "2.0.0",
-  "description": "Standard analysis domain library for the Systems Modeling Language (SysML)",
-  "usage": [
-    {
-      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
-      "versionConstraint": "1.0.0"
-    },
-    {
-      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
-      "versionConstraint": "1.0.0"
-    },
-    {
-      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
-      "versionConstraint": "1.0.0"
-    },
-    {
-      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
-      "versionConstraint": "2.0.0"
-    },
-    {
-      "resource": "https://www.omg.org/spec/KerML/20250201/Quantities-and-Units-Library.kpar",
-      "versionConstraint": "2.0.0"
-    }
-  ]
+{
+  "name": "SysML Analysis Library",
+  "version": "2.0.0",
+  "description": "Standard analysis domain library for the Systems Modeling Language (SysML)",
+  "usage": [
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Semantic-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Data-Type-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Function-Library.kpar",
+      "versionConstraint": "1.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/SysML/20250201/Systems-Library.kpar",
+      "versionConstraint": "2.0.0"
+    },
+    {
+      "resource": "https://www.omg.org/spec/KerML/20250201/Quantities-and-Units-Library.kpar",
+      "versionConstraint": "2.0.0"
+    }
+  ]
 }

package/resources/sysml.library/Domain Libraries/Analysis/AnalysisTooling.sysml

@@ -1,34 +1,34 @@
-standard library package AnalysisTooling {
-	doc
-	/*
-	 * This package contains definitions for metadata annotations related
-	 * to analysis tool integration.
-	 */
-
-	private import ScalarValues::*;
-	
-	metadata def ToolExecution {
-		doc
-		/*
-		 * ToolExecution metadata identifies an external analysis tool to be
-		 * used to implement the annotated action.
-		 */
-	
-		attribute toolName : String;
-		attribute uri : String;
-	}
-	
-	metadata def ToolVariable {
-		doc
-		/*
-		 * ToolVariable metadata is used in the context of an action that has
-		 * been annotated with ToolExecution metadata. It is used to annotate
-		 * a parameter or other feature of the action with the name of the
-		 * variable in the tool that is to correspond to the annotated
-		 * feature.
-		 */
-	
-		attribute name : String;
-	}
-	
+standard library package AnalysisTooling {
+	doc
+	/*
+	 * This package contains definitions for metadata annotations related
+	 * to analysis tool integration.
+	 */
+
+	private import ScalarValues::*;
+	
+	metadata def ToolExecution {
+		doc
+		/*
+		 * ToolExecution metadata identifies an external analysis tool to be
+		 * used to implement the annotated action.
+		 */
+	
+		attribute toolName : String;
+		attribute uri : String;
+	}
+	
+	metadata def ToolVariable {
+		doc
+		/*
+		 * ToolVariable metadata is used in the context of an action that has
+		 * been annotated with ToolExecution metadata. It is used to annotate
+		 * a parameter or other feature of the action with the name of the
+		 * variable in the tool that is to correspond to the annotated
+		 * feature.
+		 */
+	
+		attribute name : String;
+	}
+	
 }

package/resources/sysml.library/Domain Libraries/Analysis/SampledFunctions.sysml

@@ -1,119 +1,119 @@
-standard library package SampledFunctions {
-	doc
-	/*
-	 * This package provides a library model of discretely sampled mathematical functions.
-	 */
-
-	private import Base::Anything;
-	private import ScalarValues::Positive;
-	private import Collections::KeyValuePair;
-	private import Collections::OrderedMap;
-	private import SequenceFunctions::size;
-	private import ControlFunctions::forAll;
-	private import ControlFunctions::collect;
-	private import ControlFunctions::select;
-	
-    attribute def SamplePair :> KeyValuePair {
-		doc
-		/*
-		 * SamplePair is a key-value pair of a domain-value and a range-value, used as a sample element in SampledFunction.
-		 */
-	
-        attribute domainValue :>> key;
-        attribute rangeValue :>> val;
-    }
-
-	attribute def SampledFunction :> OrderedMap {
-		doc
-		/*
-	     * SampledFunction is a variable-size, ordered collection of 'SamplePair' elements that represents a generic, discretely sampled, 
-	     * uni-variate or multi-variate mathematical function. The function must be montonic, either strictly increasing or strictly
-	     * decreasing.
-	     * 
-	     * It maps discrete domain values to discrete range values.
-	     * The domain of the function is represented by the sequence of 'domainValue' of each 'SamplePair' in 'samples', and 
-	     * the range of the function is represented by the sequence of 'rangeValue' of each 'SamplePair' in 'samples'.
-	     */
-	
-		attribute samples: SamplePair[0..*] ordered :>> elements;
-		
-		assert constraint {
-			// Note: Assumes the functions '<' and '>' are defined for the domain type.
-			(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) < samples.domainValue#(i+1)) } or  // Strictly increasing
-            (1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) > samples.domainValue#(i+1)) }     // Strictly decreasing
-		}
-	}
-	
-	calc def Domain { 
-		doc
-		/* 
-		 * Domain returns the sequence of the domainValues of all samples in a SampledFunction.
-		 */
-		 
-		in fn : SampledFunction; 
-		return : Anything[0..*] = fn.samples.domainValue;
-	}
-	
-	calc def Range { 
-		doc
-		/* 
-		 * Range returns the sequence of the rangeValues of all samples in a SampledFunction.
-		 */
-			
-		in fn : SampledFunction; 
-		return : Anything[0..*] = fn.samples.rangeValue;
-	}
-	
-	calc def Sample {
-		doc
-		/* 
-		 * Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues.
-		 */
-		 
-		in calc calculation { in x; }
-		in attribute domainValues [0..*];
-		return sampling = new SampledFunction (
-			samples = domainValues->collect { in x; new SamplePair(x, calculation(x)) }
-		);
-	}
-	
-	calc def Interpolate {
-		doc
-		/*
-		 * An Interpolate calculation returns an interpolated range value from a given SampledFunction for a given domain value.
-		 * If the input domain value is outside the bounds of the domainValues of the SampleFunction, null is returned.
-		 */
-	
-		in attribute fn : SampledFunction;
-		in attribute value;
-		return attribute result;
-	}
-		
-	calc interpolateLinear : Interpolate {
-		doc
-		/*
-		 * interpolateLinear is an Interpolate calculation assuming a linear functional form between SamplePairs.
-		 */
-	
-		in attribute fn : SampledFunction;
-		in attribute value;
-		
-		private attribute domainValues = Domain(fn);
-		private attribute index : Positive[0..1] =
-			(1..size(domainValues))->select { in i : Positive; domainValues#(i) <= value }#(1);
-			
-		private calc def Linear {
-			in attribute lowerSample : SamplePair;
-			in attribute upperSample : SamplePair;
-			in attribute value;
-			private attribute f = (value - lowerSample.domainValue) / (lowerSample.domainValue - upperSample.domainValue);
-			return result = upperSample.rangeValue + f * (lowerSample.rangeValue - upperSample.rangeValue);				
-		}
-		
-		return result [0..1] =
-			if index == null or index == size(domainValues)? null
-			else if domainValues#(index) < domainValues#(index+1)? Linear(fn.samples#(index), fn.samples#(index+1), value)
-			else Linear(fn.samples#(index+1), fn.samples#(index), value);
-	}
-	
+standard library package SampledFunctions {
+	doc
+	/*
+	 * This package provides a library model of discretely sampled mathematical functions.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::Positive;
+	private import Collections::KeyValuePair;
+	private import Collections::OrderedMap;
+	private import SequenceFunctions::size;
+	private import ControlFunctions::forAll;
+	private import ControlFunctions::collect;
+	private import ControlFunctions::select;
+	
+    attribute def SamplePair :> KeyValuePair {
+		doc
+		/*
+		 * SamplePair is a key-value pair of a domain-value and a range-value, used as a sample element in SampledFunction.
+		 */
+	
+        attribute domainValue :>> key;
+        attribute rangeValue :>> val;
+    }
+
+	attribute def SampledFunction :> OrderedMap {
+		doc
+		/*
+	     * SampledFunction is a variable-size, ordered collection of 'SamplePair' elements that represents a generic, discretely sampled, 
+	     * uni-variate or multi-variate mathematical function. The function must be montonic, either strictly increasing or strictly
+	     * decreasing.
+	     * 
+	     * It maps discrete domain values to discrete range values.
+	     * The domain of the function is represented by the sequence of 'domainValue' of each 'SamplePair' in 'samples', and 
+	     * the range of the function is represented by the sequence of 'rangeValue' of each 'SamplePair' in 'samples'.
+	     */
+	
+		attribute samples: SamplePair[0..*] ordered :>> elements;
+		
+		assert constraint {
+			// Note: Assumes the functions '<' and '>' are defined for the domain type.
+			(1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) < samples.domainValue#(i+1)) } or  // Strictly increasing
+            (1..size(samples)-1)->forAll { in i; (samples.domainValue#(i) > samples.domainValue#(i+1)) }     // Strictly decreasing
+		}
+	}
+	
+	calc def Domain { 
+		doc
+		/* 
+		 * Domain returns the sequence of the domainValues of all samples in a SampledFunction.
+		 */
+		 
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.domainValue;
+	}
+	
+	calc def Range { 
+		doc
+		/* 
+		 * Range returns the sequence of the rangeValues of all samples in a SampledFunction.
+		 */
+			
+		in fn : SampledFunction; 
+		return : Anything[0..*] = fn.samples.rangeValue;
+	}
+	
+	calc def Sample {
+		doc
+		/* 
+		 * Sample returns a SampledFunction that samples a given calculation over a sequence of domainValues.
+		 */
+		 
+		in calc calculation { in x; }
+		in attribute domainValues [0..*];
+		return sampling = new SampledFunction (
+			samples = domainValues->collect { in x; new SamplePair(x, calculation(x)) }
+		);
+	}
+	
+	calc def Interpolate {
+		doc
+		/*
+		 * An Interpolate calculation returns an interpolated range value from a given SampledFunction for a given domain value.
+		 * If the input domain value is outside the bounds of the domainValues of the SampleFunction, null is returned.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		return attribute result;
+	}
+		
+	calc interpolateLinear : Interpolate {
+		doc
+		/*
+		 * interpolateLinear is an Interpolate calculation assuming a linear functional form between SamplePairs.
+		 */
+	
+		in attribute fn : SampledFunction;
+		in attribute value;
+		
+		private attribute domainValues = Domain(fn);
+		private attribute index : Positive[0..1] =
+			(1..size(domainValues))->select { in i : Positive; domainValues#(i) <= value }#(1);
+			
+		private calc def Linear {
+			in attribute lowerSample : SamplePair;
+			in attribute upperSample : SamplePair;
+			in attribute value;
+			private attribute f = (value - lowerSample.domainValue) / (lowerSample.domainValue - upperSample.domainValue);
+			return result = upperSample.rangeValue + f * (lowerSample.rangeValue - upperSample.rangeValue);				
+		}
+		
+		return result [0..1] =
+			if index == null or index == size(domainValues)? null
+			else if domainValues#(index) < domainValues#(index+1)? Linear(fn.samples#(index), fn.samples#(index+1), value)
+			else Linear(fn.samples#(index+1), fn.samples#(index), value);
+	}
+	
 }

package/resources/sysml.library/Domain Libraries/Analysis/StateSpaceRepresentation.sysml

@@ -1,143 +1,143 @@
-standard library package StateSpaceRepresentation {
-	doc
-	/*
-	 * This package provides a model of the foundational state-space system representation, 
-	 * commonly used in control systems.
-	 */
-
-    private import ISQ::DurationValue;
-    private import Quantities::VectorQuantityValue;
-    private import VectorCalculations::*;
-
-    abstract attribute def StateSpace :> VectorQuantityValue;
-    abstract attribute def Input :> VectorQuantityValue;
-    abstract attribute def Output :> VectorQuantityValue;
-
-    abstract calc def GetNextState { 
-    	in input: Input; 
-    	in stateSpace: StateSpace; 
-    	in timeStep: DurationValue; 
-    	return : StateSpace;
-    }
-    abstract calc def GetOutput {
-    	in input: Input; 
-    	in stateSpace: StateSpace;
-    	return : Output;
-	}
-	
-     abstract action def StateSpaceEventDef {
-    	doc
-    	/*
-    	 * Events to be received.
-    	 */
-    }
-    action def ZeroCrossingEventDef :> StateSpaceEventDef;
-
-    item def StateSpaceItem {
-    	doc
-    	/*
-    	 * Item for SSR connection
-    	 */
-    }
-
-    abstract action def StateSpaceDynamics {
-	    doc
-	    /*
-	     * StateSpaceDynamics is the simplest form of State Space Representation,
-	     * and nextState directly computes the stateSpace of the next timestep. 
-	     */
-    
-        in attribute input: Input;
-
-        abstract calc getNextState: GetNextState;
-        abstract calc getOutput: GetOutput;
-        attribute stateSpace: StateSpace;
-
-        out attribute output: Output = getOutput(input, stateSpace);
-    }
-
-    abstract attribute def StateDerivative :> VectorQuantityValue {
-	    doc
-	    /*
-	     * The definition of the time derivative of StateSpace, which means dx/dt, where x is StateSpace
-	     */
-    
-        ref stateSpace: StateSpace;
-        constraint { stateSpace.order == order }
-    }
-
-    abstract calc def GetDerivative {
-	    doc
-	    /*
-	     * Computes the time derivative of stateSpace, which corresponds dx/dt = f(u, x), where u is input and x is stateSpace.
-	     */
-	    
-    	in input: Input;
-    	in stateSpace: StateSpace;
-    	return : StateDerivative;
-	}
-	
-    abstract calc def Integrate {
-	    doc
-	    /*
-	     * Integrates stateSpace to compute the next stateSpace, which corresponds to x + int dx/dt dt.
-	     * Its actual implementation should be given by a solver. 
-	     */
-    
-        in getDerivative: GetDerivative;
-        in input: Input;
-        in initialState: StateSpace;
-        in timeInterval: DurationValue;
-        return result: StateSpace;
-	}
-	
-    abstract action def ContinuousStateSpaceDynamics :> StateSpaceDynamics {
-	    doc
-	    /*
-	     * ContinuousStateSpaceDynamics represents continuous behavior.
-	     * derivative needs to return a time derivative of stateSpace, i.e. dx/dt.
-	     */
-    
-        abstract calc getDerivative: GetDerivative;
-        calc :>> getNextState: GetNextState {
-            /* We compute nextState by Integrate defined above by giving derivative calc. */
-            calc integrate: Integrate {
-                in getDerivative = ContinuousStateSpaceDynamics::getDerivative;
-                in input = GetNextState::input;
-                in initialState = GetNextState::stateSpace;
-                in timeInterval = GetNextState::timeStep;
-           }
-           return result = integrate.result;
-        }
-
-        event occurrence zeroCrossingEvents[0..*] : ZeroCrossingEventDef {
-        	/* ContinuousStateSpaceDynamics may cause zero crossings anomaly. */ 
-        }
-    }
-
-    abstract calc def GetDifference {
-    	doc
-	    /*
-	     * Computes difference of stateSpace by one timestep, that is x(k+1) - x(k),
-	     * where k is the timestep number. 
-	     */
-    
-    	in input: Input;
-    	in stateSpace: StateSpace;
-    	return : StateSpace;
-	}
-	
-    abstract action def DiscreteStateSpaceDynamics :> StateSpaceDynamics {
-	    doc
-	    /*
-	     * DiscreteStateSpaceDynamics represents discrete behavior.
-	     * differences needs to return difference of the stateSpace for each timestep.
-	     */
-    
-        abstract calc getDifference: GetDifference;
-        calc :>> getNextState: GetNextState {
-            attribute diff: StateSpace = getDifference(input, stateSpace);
-            return result = stateSpace + diff;
-        }
-    }
-}
+standard library package StateSpaceRepresentation {
+	doc
+	/*
+	 * This package provides a model of the foundational state-space system representation, 
+	 * commonly used in control systems.
+	 */
+
+    private import ISQ::DurationValue;
+    private import Quantities::VectorQuantityValue;
+    private import VectorCalculations::*;
+
+    abstract attribute def StateSpace :> VectorQuantityValue;
+    abstract attribute def Input :> VectorQuantityValue;
+    abstract attribute def Output :> VectorQuantityValue;
+
+    abstract calc def GetNextState { 
+    	in input: Input; 
+    	in stateSpace: StateSpace; 
+    	in timeStep: DurationValue; 
+    	return : StateSpace;
+    }
+    abstract calc def GetOutput {
+    	in input: Input; 
+    	in stateSpace: StateSpace;
+    	return : Output;
+	}
+	
+     abstract action def StateSpaceEventDef {
+    	doc
+    	/*
+    	 * Events to be received.
+    	 */
+    }
+    action def ZeroCrossingEventDef :> StateSpaceEventDef;
+
+    item def StateSpaceItem {
+    	doc
+    	/*
+    	 * Item for SSR connection
+    	 */
+    }
+
+    abstract action def StateSpaceDynamics {
+	    doc
+	    /*
+	     * StateSpaceDynamics is the simplest form of State Space Representation,
+	     * and nextState directly computes the stateSpace of the next timestep. 
+	     */
+    
+        in attribute input: Input;
+
+        abstract calc getNextState: GetNextState;
+        abstract calc getOutput: GetOutput;
+        attribute stateSpace: StateSpace;
+
+        out attribute output: Output = getOutput(input, stateSpace);
+    }
+
+    abstract attribute def StateDerivative :> VectorQuantityValue {
+	    doc
+	    /*
+	     * The definition of the time derivative of StateSpace, which means dx/dt, where x is StateSpace
+	     */
+    
+        ref stateSpace: StateSpace;
+        constraint { stateSpace.order == order }
+    }
+
+    abstract calc def GetDerivative {
+	    doc
+	    /*
+	     * Computes the time derivative of stateSpace, which corresponds dx/dt = f(u, x), where u is input and x is stateSpace.
+	     */
+	    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateDerivative;
+	}
+	
+    abstract calc def Integrate {
+	    doc
+	    /*
+	     * Integrates stateSpace to compute the next stateSpace, which corresponds to x + int dx/dt dt.
+	     * Its actual implementation should be given by a solver. 
+	     */
+    
+        in getDerivative: GetDerivative;
+        in input: Input;
+        in initialState: StateSpace;
+        in timeInterval: DurationValue;
+        return result: StateSpace;
+	}
+	
+    abstract action def ContinuousStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * ContinuousStateSpaceDynamics represents continuous behavior.
+	     * derivative needs to return a time derivative of stateSpace, i.e. dx/dt.
+	     */
+    
+        abstract calc getDerivative: GetDerivative;
+        calc :>> getNextState: GetNextState {
+            /* We compute nextState by Integrate defined above by giving derivative calc. */
+            calc integrate: Integrate {
+                in getDerivative = ContinuousStateSpaceDynamics::getDerivative;
+                in input = GetNextState::input;
+                in initialState = GetNextState::stateSpace;
+                in timeInterval = GetNextState::timeStep;
+           }
+           return result = integrate.result;
+        }
+
+        event occurrence zeroCrossingEvents[0..*] : ZeroCrossingEventDef {
+        	/* ContinuousStateSpaceDynamics may cause zero crossings anomaly. */ 
+        }
+    }
+
+    abstract calc def GetDifference {
+    	doc
+	    /*
+	     * Computes difference of stateSpace by one timestep, that is x(k+1) - x(k),
+	     * where k is the timestep number. 
+	     */
+    
+    	in input: Input;
+    	in stateSpace: StateSpace;
+    	return : StateSpace;
+	}
+	
+    abstract action def DiscreteStateSpaceDynamics :> StateSpaceDynamics {
+	    doc
+	    /*
+	     * DiscreteStateSpaceDynamics represents discrete behavior.
+	     * differences needs to return difference of the stateSpace for each timestep.
+	     */
+    
+        abstract calc getDifference: GetDifference;
+        calc :>> getNextState: GetNextState {
+            attribute diff: StateSpace = getDifference(input, stateSpace);
+            return result = stateSpace + diff;
+        }
+    }
+}