sysml-validate 0.11.0 → 0.14.2

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

@@ -1,171 +1,171 @@
-standard library package TradeStudies {
-	doc
-	/*
-	 * This package provides a simple framework for defining trade-off study analysis cases.
-	 */
-
-	private import Base::Anything;
-	private import ScalarValues::*;
-	private import ScalarFunctions::*;
-	private import ControlFunctions::*;
-	
-	abstract calc def EvaluationFunction {
-		doc
-		/*
-		 * An EvaluationFunction is a calculation that evaluates a TradeStudy alternative,
-		 * producing a ScalarValue that can be comparted with the evaluation of other
-		 * alternatives.
-		 */
-	
-		in ref alternative : Anything {
-			doc
-			/*
-			 * The alternative to be evaluated.
-			 */
-		} 
-		
-		return attribute result : ScalarValue[1] {
-			doc
-			/*
-			 * A ScalarValue representing the evaluation of the given alternative.
-			 */
-		} 
-	}
-	
-	abstract requirement def TradeStudyObjective {
-		doc
-		/*
-		 * A TradeStudyObjective is the base definition for the objective of a TradeStudy.
-		 * The requirement is to choose from a given set of alternatives the selectedAlternative
-		 * for that has the best evaluation according to a given EvaluationFunction. What
-		 * value is considered "best" is not defined in the abstract base definition but must be
-		 * computed in any concrete specialization.
-		 */
-	
-		subject selectedAlternative : Anything {
-			doc
-			/*
-			 * The alternative that should be selected, as evaluated using the given 
-			 * ObjectiveFunction.
-			 */
-		}
-		
-		in ref alternatives : Anything[1..*] {
-			doc
-			/*
-			 * The alternatives being considered in the TradeStudy for which this TradeStudyObjective 
-			 * is the objective.
-			 */
-		}
-		
-		in calc eval : EvaluationFunction {
-			doc
-			/*
-			 * The EvaluationFunction to be used in evaluating the given alternatives.
-			 */
-		}
-		
-		attribute best : ScalarValue {
-			doc
-			/*
-			 * Out of the evaluation results of all the given alternatives, the one that is considered 
-			 * "best", in the sense that it is the value the selectedAlternative should have. This 
-			 * value must be computed in any concrete specialization of TradeStudyObjective.
-			 */
-		}
-				
-		require constraint { eval(selectedAlternative) == best }
-	}
-	
-	requirement def MinimizeObjective :> TradeStudyObjective {
-		doc
-		/*
-		 * A MinimizeObjective is a TradeStudyObjective that requires that the 
-		 * selectedAlternative have the minimum ObjectiveFunction value of all the
-		 * given alternatives.
-		 */
-		 
-		attribute :>> best = alternatives->minimize {
-			doc
-			/*
-			 * For a MinimizeObjective, the best value is the minimum one.
-			 */
-		
-			in x; eval(x)
-		};
-	}
-	
-	requirement def MaximizeObjective :> TradeStudyObjective {
-		doc
-		/*
-		 * A MaximizeObjective is a TradeStudyObjective that requires that the 
-		 * selectedAlternative have the maximum ObjectiveFunction value of all the
-		 * given alternatives.
-		 */
-	
-		attribute :>> best = alternatives->maximize {
-			doc
-			/*
-			 * For a MinimizeObjective, the best value is the maximum one.
-			 */
-		
-			in x; eval(x)
-		};
-	}
-	
-	abstract analysis def TradeStudy {
-		doc
-		/*
-		 * A TradeStudy is an analysis case whose subject is a set of alternatives
-		 * (at least one) and whose result is a selection of one of those alternatives.
-		 * The alternatives are evaluated based on a given ObjectiveFunction and the
-		 * selection is made such that it satisfies the objective of the TradeStudy
-		 * (which must be a TradeStudyObjective).
-		 */
-	
-		subject studyAlternatives : Anything[1..*] {
-			doc
-			/*
-			 * The set of alternatives being considered in this TradeStudy. 
-			 * 
-			 * In a TradeStudy usage, bind this feature to the actual collection of
-			 * alternatives to be considered.
-			 */
-		}
-		
-		abstract calc evaluationFunction : EvaluationFunction {
-			doc
-			/*
-			 * The EvaluationFunction to be used to evaluate the alternatives.
-			 * 
-			 * In a TradeStudy usage, redefine this feature to provide the desired
-			 * calculation (or bind it to a calculation usage that does so).
-			 */
-		}
-		
-		objective tradeStudyObjective : TradeStudyObjective {
-			doc
-			/*
-			 * The objective of this TradeStudy.
-			 * 
-			 * Redefine this feature to give it a definition that is a concrete
-			 * specialization of TradeStudyObjective. That can either be one of the
-			 * specializations provided in this package, or a more specific user-
-			 * defined one.
-			 */
-		
-            subject :>> selectedAlternative;
-			in ref :>> alternatives = studyAlternatives;
-			in calc :>> eval = evaluationFunction;
-		}
-		
-		return selectedAlternative : Anything = studyAlternatives->selectOne {in ref a {
-			doc
-			/*
-			 * The alternative selected by this TradeStudy, which is the one that meets the
-			 * requirement of the tradeStudyObjective.
-			 */
-		} tradeStudyObjective(selectedAlternative = a)};
-	}
-	
+standard library package TradeStudies {
+	doc
+	/*
+	 * This package provides a simple framework for defining trade-off study analysis cases.
+	 */
+
+	private import Base::Anything;
+	private import ScalarValues::*;
+	private import ScalarFunctions::*;
+	private import ControlFunctions::*;
+	
+	abstract calc def EvaluationFunction {
+		doc
+		/*
+		 * An EvaluationFunction is a calculation that evaluates a TradeStudy alternative,
+		 * producing a ScalarValue that can be comparted with the evaluation of other
+		 * alternatives.
+		 */
+	
+		in ref alternative : Anything {
+			doc
+			/*
+			 * The alternative to be evaluated.
+			 */
+		} 
+		
+		return attribute result : ScalarValue[1] {
+			doc
+			/*
+			 * A ScalarValue representing the evaluation of the given alternative.
+			 */
+		} 
+	}
+	
+	abstract requirement def TradeStudyObjective {
+		doc
+		/*
+		 * A TradeStudyObjective is the base definition for the objective of a TradeStudy.
+		 * The requirement is to choose from a given set of alternatives the selectedAlternative
+		 * for that has the best evaluation according to a given EvaluationFunction. What
+		 * value is considered "best" is not defined in the abstract base definition but must be
+		 * computed in any concrete specialization.
+		 */
+	
+		subject selectedAlternative : Anything {
+			doc
+			/*
+			 * The alternative that should be selected, as evaluated using the given 
+			 * ObjectiveFunction.
+			 */
+		}
+		
+		in ref alternatives : Anything[1..*] {
+			doc
+			/*
+			 * The alternatives being considered in the TradeStudy for which this TradeStudyObjective 
+			 * is the objective.
+			 */
+		}
+		
+		in calc eval : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used in evaluating the given alternatives.
+			 */
+		}
+		
+		attribute best : ScalarValue {
+			doc
+			/*
+			 * Out of the evaluation results of all the given alternatives, the one that is considered 
+			 * "best", in the sense that it is the value the selectedAlternative should have. This 
+			 * value must be computed in any concrete specialization of TradeStudyObjective.
+			 */
+		}
+				
+		require constraint { eval(selectedAlternative) == best }
+	}
+	
+	requirement def MinimizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MinimizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the minimum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+		 
+		attribute :>> best = alternatives->minimize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the minimum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	requirement def MaximizeObjective :> TradeStudyObjective {
+		doc
+		/*
+		 * A MaximizeObjective is a TradeStudyObjective that requires that the 
+		 * selectedAlternative have the maximum ObjectiveFunction value of all the
+		 * given alternatives.
+		 */
+	
+		attribute :>> best = alternatives->maximize {
+			doc
+			/*
+			 * For a MinimizeObjective, the best value is the maximum one.
+			 */
+		
+			in x; eval(x)
+		};
+	}
+	
+	abstract analysis def TradeStudy {
+		doc
+		/*
+		 * A TradeStudy is an analysis case whose subject is a set of alternatives
+		 * (at least one) and whose result is a selection of one of those alternatives.
+		 * The alternatives are evaluated based on a given ObjectiveFunction and the
+		 * selection is made such that it satisfies the objective of the TradeStudy
+		 * (which must be a TradeStudyObjective).
+		 */
+	
+		subject studyAlternatives : Anything[1..*] {
+			doc
+			/*
+			 * The set of alternatives being considered in this TradeStudy. 
+			 * 
+			 * In a TradeStudy usage, bind this feature to the actual collection of
+			 * alternatives to be considered.
+			 */
+		}
+		
+		abstract calc evaluationFunction : EvaluationFunction {
+			doc
+			/*
+			 * The EvaluationFunction to be used to evaluate the alternatives.
+			 * 
+			 * In a TradeStudy usage, redefine this feature to provide the desired
+			 * calculation (or bind it to a calculation usage that does so).
+			 */
+		}
+		
+		objective tradeStudyObjective : TradeStudyObjective {
+			doc
+			/*
+			 * The objective of this TradeStudy.
+			 * 
+			 * Redefine this feature to give it a definition that is a concrete
+			 * specialization of TradeStudyObjective. That can either be one of the
+			 * specializations provided in this package, or a more specific user-
+			 * defined one.
+			 */
+		
+            subject :>> selectedAlternative;
+			in ref :>> alternatives = studyAlternatives;
+			in calc :>> eval = evaluationFunction;
+		}
+		
+		return selectedAlternative : Anything = studyAlternatives->selectOne {in ref a {
+			doc
+			/*
+			 * The alternative selected by this TradeStudy, which is the one that meets the
+			 * requirement of the tradeStudyObjective.
+			 */
+		} tradeStudyObjective(selectedAlternative = a)};
+	}
+	
 }

package/resources/sysml.library/Domain Libraries/Cause and Effect/.meta.json

@@ -1,8 +1,8 @@
-{
-  "index": {
-    "CausationConnections": "CausationConnections.sysml",
-    "CauseAndEffect": "CauseAndEffect.sysml"
-  },
-  "created": "2025-03-13T00:00:00Z",
-  "metamodel": "https://www.omg.org/spec/SysML/20250201"
+{
+  "index": {
+    "CausationConnections": "CausationConnections.sysml",
+    "CauseAndEffect": "CauseAndEffect.sysml"
+  },
+  "created": "2025-03-13T00:00:00Z",
+  "metamodel": "https://www.omg.org/spec/SysML/20250201"
 }

package/resources/sysml.library/Domain Libraries/Cause and Effect/.project.json

@@ -1,23 +1,23 @@
-{
-  "name": "SysML Cause and Effect Library",
-  "version": "2.0.0",
-  "description": "Standard cause-and-effect 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"
-    }
-  ]
+{
+  "name": "SysML Cause and Effect Library",
+  "version": "2.0.0",
+  "description": "Standard cause-and-effect 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"
+    }
+  ]
 }

package/resources/sysml.library/Domain Libraries/Cause and Effect/CausationConnections.sysml

@@ -1,83 +1,83 @@
-standard library package CausationConnections {	
-	doc 
-	/* 
-	 * This package provides a library model modeling causes, effects, and causation connections 
-	 * between them.
-	 */
-
-	private import SequenceFunctions::isEmpty;
-	private import SequenceFunctions::size;
-	private import SequenceFunctions::intersection;
-		 
-	abstract occurrence causes[*] {
-		doc /* Occurrences that are causes. */
-	}
-	
-	abstract occurrence effects[*]  {
-		doc /* Occurrences that are effects. */
-	}
-	
-	abstract connection def Multicausation {
-		doc
-		/*
-		 * A Multicausation connection models the situation in which one set of
-		 * occurrences causes another.
-		 * 
-		 * To create a Multicausation connection, specialize this connection definition
-		 * adding specific end features of the relavent types. Ends representing causes
-		 * should subset 'causes', while ends representing effects should subset 'effects'.
-		 * There must be at least one cause and at least one effect.
-		 */
-		 
-		abstract constant ref occurrence causes[1..*] :>> causes :> participant {
-			doc 
-			/* 
-			 * The causing occurrences. (Constant for each Multicausation instance.)
-			 */
-		}
-		abstract constant ref occurrence effects[1..*] :>> effects :> participant {
-			doc 
-			/* 
-			 * The effect occurrences caused by the causing occurrences. 
-			 * (Constant for each Multicausation instance.)
-			 */
-		}
-		
-		private assert constraint disjointCauseEffect {
-			doc /* causes must be disjoint from effects. */
-			isEmpty(intersection(causes, effects))
-		}
-		
-		private succession causalOrdering first [nCauses] causes.startShot then [nEffects] effects {
-			doc /* All causes must exist before all effects. */
-			attribute nCauses = size(causes);
-			attribute nEffects = size(effects);
-		}
-	}
-	
-	abstract connection multicausations : Multicausation[*] {
-		doc /* multicausations is the base feature for Multicausation ConnectionUsages. */
-	}
-	
-	connection def Causation :> Multicausation {
-		doc
-		/*
-		 * A Causation is a binary Multicausation in which a single cause occurrence
-		 * causes a single effect occurrence. (However, a single cause can separately
-		 * have multiple effects, and a single effect can have separate Causation
-		 * connections with multiple causes.)
-		 */
-		
-		end theCauses [*] occurrence theCause :> causes :>> source {
-		    doc /* The single causing occurrence. */
-		}
-		
-		end theEffects [*] occurrence theEffect :> effects :>> target {
-			doc /* The single effect occurrence resulting from the cause. */
-		}
-	}
-	
-	abstract connection causations : Causation[*] :> multicausations {
-		doc /* causations is the base feature for Causation ConnectionUsages. */
-	}
+standard library package CausationConnections {	
+	doc 
+	/* 
+	 * This package provides a library model modeling causes, effects, and causation connections 
+	 * between them.
+	 */
+
+	private import SequenceFunctions::isEmpty;
+	private import SequenceFunctions::size;
+	private import SequenceFunctions::intersection;
+		 
+	abstract occurrence causes[*] {
+		doc /* Occurrences that are causes. */
+	}
+	
+	abstract occurrence effects[*]  {
+		doc /* Occurrences that are effects. */
+	}
+	
+	abstract connection def Multicausation {
+		doc
+		/*
+		 * A Multicausation connection models the situation in which one set of
+		 * occurrences causes another.
+		 * 
+		 * To create a Multicausation connection, specialize this connection definition
+		 * adding specific end features of the relavent types. Ends representing causes
+		 * should subset 'causes', while ends representing effects should subset 'effects'.
+		 * There must be at least one cause and at least one effect.
+		 */
+		 
+		abstract constant ref occurrence causes[1..*] :>> causes :> participant {
+			doc 
+			/* 
+			 * The causing occurrences. (Constant for each Multicausation instance.)
+			 */
+		}
+		abstract constant ref occurrence effects[1..*] :>> effects :> participant {
+			doc 
+			/* 
+			 * The effect occurrences caused by the causing occurrences. 
+			 * (Constant for each Multicausation instance.)
+			 */
+		}
+		
+		private assert constraint disjointCauseEffect {
+			doc /* causes must be disjoint from effects. */
+			isEmpty(intersection(causes, effects))
+		}
+		
+		private succession causalOrdering first [nCauses] causes.startShot then [nEffects] effects {
+			doc /* All causes must exist before all effects. */
+			attribute nCauses = size(causes);
+			attribute nEffects = size(effects);
+		}
+	}
+	
+	abstract connection multicausations : Multicausation[*] {
+		doc /* multicausations is the base feature for Multicausation ConnectionUsages. */
+	}
+	
+	connection def Causation :> Multicausation {
+		doc
+		/*
+		 * A Causation is a binary Multicausation in which a single cause occurrence
+		 * causes a single effect occurrence. (However, a single cause can separately
+		 * have multiple effects, and a single effect can have separate Causation
+		 * connections with multiple causes.)
+		 */
+		
+		end theCauses [*] occurrence theCause :> causes :>> source {
+		    doc /* The single causing occurrence. */
+		}
+		
+		end theEffects [*] occurrence theEffect :> effects :>> target {
+			doc /* The single effect occurrence resulting from the cause. */
+		}
+	}
+	
+	abstract connection causations : Causation[*] :> multicausations {
+		doc /* causations is the base feature for Causation ConnectionUsages. */
+	}
 }