private void DefConstraintTypes(Workspace cdaStarTms, IDomain metricDomain, IDomain boolDomain, int numberOfElements, out IConstraintType ctNotEquals, out IConstraintType ctGreaterThan) { var ctSignature = constraintSignature(metricDomain, boolDomain); ctNotEquals = DefNotEquals(cdaStarTms, ctSignature, numberOfElements); ctGreaterThan = DefGreaterThan(cdaStarTms, ctSignature, numberOfElements); }
public static bool SatisfyConstraint(this IConstraintType constraint, IExprValue value) { return (value.Match( constStringValue: strVal => constraint.Match( constant: strConst => strVal == strConst, sequence: _ => false, range: _ => false ), integerValue: intVal => constraint.Match( constant: _ => false, sequence: sequence => InSequence(sequence, intVal), range: range => InRange(range, intVal) ) )); }
public void ClearWorkspaceTest2() { ICDAStar cdaStarTms = new Workspace(); // Domains String[] boolDomainValues = new string[] { "T", "F" }; String[] metricDomainValues = new string[] { "1", "2", "3" }; IDomain boolDomain = cdaStarTms.DefDomain("Boolean", boolDomainValues);; IDomain metricDomain = cdaStarTms.DefDomain("Metric", metricDomainValues); // Constraint types IConstraintType ctOnly1Allowed = cdaStarTms.DefConstraintType( "Only_1_Allowed", new IDomain[1] { metricDomain }, new string[][] { new string[] { "1" } } ); IConstraintType ctOnlyTrueAllowed = cdaStarTms.DefConstraintType( "Only_True_Allowed", new IDomain[1] { boolDomain }, new string[][] { new string[] { "T" } } ); IConstraintType ctF = cdaStarTms.DefConstraintType( "Only_False_Allowed", new IDomain[1] { boolDomain }, new string[][] { new string[] { "F" } } ); IConstraintType ctNotEquals; IConstraintType ctLE; // --------------------------------------------------------------------------// // Creating additional constraint types // Creating the not equals constraint type, i.e. A != B // If a tuple <A, B> satisfies the condition then the third part of the relation is True, otherwise False - this allows using soft constraints and is used for the utility function var ctSignature = new IDomain[3] { metricDomain, metricDomain, boolDomain }; var ctTuples = new string[3 * 3][]; var tupleCounter = 0; for (int i = 1; i < 4; i++) { for (int j = 1; j < 4; j++) { string satisfied = i != j ? "T" : "F"; ctTuples[tupleCounter] = new string[] { i.ToString(), j.ToString(), satisfied }; tupleCounter++; } } ctNotEquals = cdaStarTms.DefConstraintType("Not_Equals", ctSignature, ctTuples); // Creating the less or equals constraint type, i.e. A <= B // If a tuple <A, B> satisfies the condition then the third part of the relation is True, otherwise False - this allows using soft constraints and is used for the utility function ctSignature = new IDomain[3] { metricDomain, metricDomain, boolDomain }; ctTuples = new string[3 * 3][]; tupleCounter = 0; for (int i = 1; i < 4; i++) { for (int j = 1; j < 4; j++) { string satisfied = i <= j ? "T" : "F"; ctTuples[tupleCounter] = new string[] { i.ToString(), j.ToString(), satisfied }; tupleCounter++; } } ctLE = cdaStarTms.DefConstraintType("Less_Or_Equals", ctSignature, ctTuples); // --------------------------------------------------------------------------// // Setting the utility function cdaStarTms.DefAggregateUtility((double[] utilities) => { return(utilities.Sum() / 2); }); // Variables IVariable positionA = cdaStarTms.DefVariable("position_A", metricDomain); IVariable positionB = cdaStarTms.DefVariable("position_B", metricDomain); IVariable metricVal1 = cdaStarTms.DefVariable("metric_val-1", metricDomain); // Satisfiability variables used for utility IVariable ANotEqBSatisfied = cdaStarTms.DefVariable("position_A-NotEquals-position_B", boolDomain); IVariable ALessOrEquals1Satisfied = cdaStarTms.DefVariable("position_A-LessOrEquals-1", boolDomain); IVariable BLessOrEquals1Satisfied = cdaStarTms.DefVariable("position_B-LessOrEquals-1", boolDomain); //// --------------------------------------------------------------------------// //// Attributes and utilities //// Setting the non-utility variables as attributes //// These variables do not take part in the utility function, //// but there assignment is the actual solution which is sought cdaStarTms.DefAttribute(positionA.Name); cdaStarTms.DefAttribute(positionB.Name); cdaStarTms.DefAttribute(metricVal1.Name); // Each constraint in the problem has a satisfaction variable with boolean domain. // If a constraint is satisfied, its satisfaction variable is True, otherwise - False. // If the value is True (i.e. the constraint is satisfied) it has utility - 1, otherwise - 0 cdaStarTms.DefAttribute(ANotEqBSatisfied.Name); cdaStarTms.set_Utility(ANotEqBSatisfied.Name, 0, 3); cdaStarTms.set_Utility(ANotEqBSatisfied.Name, 1, 0); cdaStarTms.DefAttribute(ALessOrEquals1Satisfied.Name); cdaStarTms.set_Utility(ALessOrEquals1Satisfied.Name, 0, 2); cdaStarTms.set_Utility(ALessOrEquals1Satisfied.Name, 1, 0); cdaStarTms.DefAttribute(BLessOrEquals1Satisfied.Name); cdaStarTms.set_Utility(BLessOrEquals1Satisfied.Name, 0, 2); cdaStarTms.set_Utility(BLessOrEquals1Satisfied.Name, 1, 0); ////// --------------------------------------------------------------------------// // --------------------------------------------------------------------------// // Constraints // A should not have the same position as B cdaStarTms.DefConstraint(ctNotEquals, new IVariable[] { positionA, positionB, ANotEqBSatisfied }); // The positions of A and B should be LE 1 cdaStarTms.DefConstraint(ctLE, new IVariable[] { positionA, metricVal1, ALessOrEquals1Satisfied }); cdaStarTms.DefConstraint(ctLE, new IVariable[] { positionB, metricVal1, BLessOrEquals1Satisfied }); // The metric variable should have value 1 cdaStarTms.DefConstraint(ctOnly1Allowed, new IVariable[] { metricVal1 }); // Specifying that the constraints: position A <= 1 // position B <= 1 // cannot be violated, i.e. their satisfaction variable should be always set to True // This is achieved by using the ctOnlyTrueAllowed constraint for these variables cdaStarTms.DefConstraint(ctOnlyTrueAllowed, new IVariable[] { ALessOrEquals1Satisfied }); cdaStarTms.DefConstraint(ctOnlyTrueAllowed, new IVariable[] { BLessOrEquals1Satisfied }); // --------------------------------------------------------------------------// // --------------------------------------------------------------------------// // Solving ISolutionsIterator solutionIterator; ISolution solution; solutionIterator = cdaStarTms.Solutions(); solution = solutionIterator.FirstSolution(); while (solution != null) { Debug.WriteLine("Utility: " + solution.Utility()); Debug.WriteLine("A NotEq B Satisfied: " + boolDomainValues[solution.Value(ANotEqBSatisfied.Name)]); Debug.WriteLine("A LessOrEquals 1 Satisfied: " + boolDomainValues[solution.Value(ALessOrEquals1Satisfied.Name)]); Debug.WriteLine("B LessOrEquals 1 Satisfied: " + boolDomainValues[solution.Value(BLessOrEquals1Satisfied.Name)]); Debug.WriteLine("Position A: " + metricDomainValues[solution.Value(positionA.Name)]); Debug.WriteLine("Position B: " + metricDomainValues[solution.Value(positionB.Name)]); Debug.WriteLine("Metric Val 1: " + metricDomainValues[solution.Value(metricVal1.Name)]); Debug.WriteLine("AsString: " + solution.AsString()); Debug.WriteLine(""); solution = solutionIterator.NextSolution(); } // --------------------------------------------------------------------------// // PROBLEM 2 - works only if the first problem has no CDA* attributes defined cdaStarTms.Clear(); IVariable testVar = cdaStarTms.DefVariable("test", boolDomain); IVariable softVar = cdaStarTms.DefVariable("soft", boolDomain); // Trying clearing IConstraint constraint = cdaStarTms.DefConstraint(ctOnlyTrueAllowed, new IVariable[] { testVar }); //IConstraint constraintContradicting = cdaStarTms.DefConstraint(ctF, new IVariable[] { testVar }); // The function simply returns the sum of utilities cdaStarTms.DefAggregateUtility((double[] utilities) => { return(utilities.Sum() * 10); }); // Adding the two variables as attributes cdaStarTms.DefAttribute(softVar.Name); cdaStarTms.set_Utility(softVar.Name, 0, 0); cdaStarTms.set_Utility(softVar.Name, 1, 1); // testVar is not relevant to the utility function cdaStarTms.DefAttribute(testVar.Name); //cdaStarTms.set_Utility(testVar.Name, 0, 0); //cdaStarTms.set_Utility(testVar.Name, 1, 0); solutionIterator = cdaStarTms.Solutions(); try { // The exception is currently thrown here solution = solutionIterator.FirstSolution(); while (solution != null) { Debug.WriteLine("Utility: " + solution.Utility()); Debug.WriteLine("Test var: " + boolDomainValues[solution.Value(testVar.Name)]); Debug.WriteLine("Soft var: " + boolDomainValues[solution.Value(softVar.Name)]); Debug.WriteLine("AsString: " + solution.AsString()); Debug.WriteLine(""); solution = solutionIterator.NextSolution(); } } catch (Exception ex) { Assert.Fail("Expected no exception, but got: " + ex.Message); } }
public void ClearWorkspaceTest1() { ICDAStar cdaStarTms = new Workspace(); String[] boolDomainValues = new string[] { "T", "F" }; IDomain boolDomain = cdaStarTms.DefDomain("Boolean", boolDomainValues); IConstraintType ctT = cdaStarTms.DefConstraintType( "Only_True_Allowed", new IDomain[1] { boolDomain }, new string[][] { new string[] { "T" } } ); cdaStarTms.DefAggregateUtility((double[] utilities) => { return(utilities.Sum() / 2); }); IVariable valA = cdaStarTms.DefVariable("val_A", boolDomain); IVariable valB = cdaStarTms.DefVariable("val_B", boolDomain); cdaStarTms.DefConstraint(ctT, new IVariable[] { valA }); cdaStarTms.DefConstraint(ctT, new IVariable[] { valA }); cdaStarTms.DefAttribute(valA.Name); cdaStarTms.set_Utility(valA.Name, 0, 2); cdaStarTms.set_Utility(valA.Name, 1, 0); cdaStarTms.DefAttribute(valB.Name); cdaStarTms.set_Utility(valB.Name, 0, 2); cdaStarTms.set_Utility(valB.Name, 1, 0); ISolutionsIterator solutionIterator = cdaStarTms.Solutions(); ISolution solution = solutionIterator.FirstSolution(); while (solution != null) { Debug.WriteLine("Utility: " + solution.Utility()); Debug.WriteLine("AsString: " + solution.AsString()); Debug.WriteLine(""); solution = solutionIterator.NextSolution(); } // --------------------------------------------------------------------------// cdaStarTms.Clear(); IVariable testVar = cdaStarTms.DefVariable("test", boolDomain); IVariable softVar = cdaStarTms.DefVariable("soft", boolDomain); cdaStarTms.DefConstraint(ctT, new IVariable[] { testVar }); cdaStarTms.DefAggregateUtility((double[] utilities) => { return(utilities.Sum() * 10); }); cdaStarTms.DefAttribute(softVar.Name); cdaStarTms.set_Utility(softVar.Name, 0, 0); cdaStarTms.set_Utility(softVar.Name, 1, 1); cdaStarTms.DefAttribute(testVar.Name); solutionIterator = cdaStarTms.Solutions(); solution = solutionIterator.FirstSolution(); while (solution != null) { Debug.WriteLine("Utility: " + solution.Utility()); Debug.WriteLine("AsString: " + solution.AsString()); Debug.WriteLine(""); // For some reasone the solution only returns F and enters an infinite loop, // so it loops through the while indefinite number of times Assert.IsFalse(solution.AsString() == "F"); solution = solutionIterator.NextSolution(); } }
public void TestTmsUtilityFunction() { ICDAStar cdaStarTms = new Workspace(); ISolutionsIterator solutionIterator; ISolution solution; var boolDomainArr = new string[] { "T", "F" }; IDomain boolDomain = cdaStarTms.DefDomain("Boolean", boolDomainArr); IVariable testVar = cdaStarTms.DefVariable("test", boolDomain); IVariable softVar = cdaStarTms.DefVariable("soft", boolDomain); ICDAStar.AggregateUtility utilityFunction = (double[] utilities) => { return(utilities.Sum()); }; //only value T to be chosen IConstraintType ctT = cdaStarTms.DefConstraintType( "Only_True_Allowed", new IDomain[1] { boolDomain }, new string[][] { new string[] { "T" } } ); //only value F to be chosen IConstraintType ctF = cdaStarTms.DefConstraintType( "Only_False_Allowed", new IDomain[1] { boolDomain }, new string[][] { new string[] { "F" } } ); // IConstraint constraint = cdaStarTms.DefConstraint(ctT, new IVariable[] { testVar }); //IConstraint constraintContradicting = cdaStarTms.DefConstraint(ctF, new IVariable[] { testVar }); // The function simply returns the sum of utilities cdaStarTms.DefAggregateUtility(utilityFunction); // Adding the two variables as attributes cdaStarTms.DefAttribute(softVar.Name); cdaStarTms.set_Utility(softVar.Name, 0, 0); cdaStarTms.set_Utility(softVar.Name, 1, 1); // testVar is not relevant to the utility function cdaStarTms.DefAttribute(testVar.Name); //cdaStarTms.set_Utility(testVar.Name, 0, 0); //cdaStarTms.set_Utility(testVar.Name, 1, 0); solutionIterator = cdaStarTms.Solutions(); solution = solutionIterator.FirstSolution(); while (solution != null) { Debug.WriteLine("Utility: " + solution.Utility()); Debug.WriteLine("Test var: " + boolDomainArr[solution.Value(testVar.Name)]); Debug.WriteLine("Soft var: " + boolDomainArr[solution.Value(softVar.Name)]); Debug.WriteLine("AsString: " + solution.AsString()); Debug.WriteLine(""); solution = solutionIterator.NextSolution(); } }
///<summary>Initializes a new constraint with a type and an optional name.</summary> ///<param name="type">The type of the constraint.</param> ///<param name="name">The name of the constraint(optional).</param> public Constraint(IConstraintType type, string name = null) => (this.type, Name) = (type, name);
public Parameter(string name, IConstraintType constraint) { this.name = name; this.constraint = constraint; }
private void DefProblem(Workspace cdaStarTms, int numberOfElements, bool detailedLog, IConstraintType ctNotEquals, IDomain metricDomain, IDomain boolDomain, out int constraintsCount) { // Variables and attributes var variables = new List <IVariable>(); var utilities = new List <double>(); //System.Array utilities = Array.CreateInstance(typeof(double), numberOfElements); for (int i = 0; i < numberOfElements; i++) { variables.Add(cdaStarTms.DefVariable("position_component_" + (i + 1), metricDomain)); utilities.Add(i + 1); } variables.ForEach(v => cdaStarTms.DefAttribute(v.Name, utilities.ToArray())); // Conditions and utility variables/attributes constraintsCount = 0; // Different positions for (int i = 1; i < variables.Count; i++) { for (int j = 0; j < i; j++) { // For each constraint add new variable to check whether it is satisfied or not var softVar = cdaStarTms.DefVariable("posOf_" + (j + 1) + "_notSameAs_posOf" + (i + 1), boolDomain); // softVars.Add(softVar); // Defining the variable utility // cdaStarTms.DefAttribute(softVar.Name, 1, 0); // The constraint itself cdaStarTms.DefConstraint(ctNotEquals, new IVariable[] { variables[j], variables[i], softVar }); constraintsCount++; } } }