/// <summary>
/// Returns a new table that is the union of the input tables.
/// </summary>
/// <param name="parameters">The model's parameters</param>
/// <param name="first">First table</param>
/// <param name="second">Second table</param>
/// <param name="newState">Function to calculate state of merged value combinations</param>
/// <returns>The new table</returns>
public static ParameterInteraction Merge <T>(IList <ParameterBase> parameters, ParameterInteraction first, ParameterInteraction second, Func <ValueCombinationState, ValueCombinationState, ValueCombinationState> newState)
where T : new()
{
List <int> parameterIndices = first.Parameters.Union(second.Parameters).ToList();
parameterIndices.Sort();
var mergedInteraction = new ParameterInteraction(parameterIndices);
var valueTable = ParameterInteractionTable <T> .GenerateValueTable(parameters, mergedInteraction);
foreach (var value in valueTable)
{
mergedInteraction.Combinations.Add(new ValueCombination(value, mergedInteraction));
}
foreach (var combination in mergedInteraction.Combinations)
{
var firstMatch = first.Combinations.First((c) => ParameterInteractionTable <T> .MatchCombination(c, combination));
var secondMatch = second.Combinations.First((c) => ParameterInteractionTable <T> .MatchCombination(c, combination));
combination.State = newState(firstMatch.State, secondMatch.State);
}
return(mergedInteraction);
}
private void GenerateHigherOrderDependentExclusions(Model <T> model, int order, List <int> parameterInteractionCounts, ParameterInteraction completeInteraction, IEnumerable <ValueCombination> allowedCombinations)
{
// generate the combinations for orders between order and completerInteraction.Parameters.Count
foreach (var count in parameterInteractionCounts)
{
IList <int[]> parameterCombinations = GenerateCombinations(completeInteraction.Parameters.Count, count);
foreach (var combinations in parameterCombinations)
{
var interaction = new ParameterInteraction(combinations.Select((i) => completeInteraction.Parameters[i]));
var possibleValues = ParameterInteractionTable <T> .GenerateValueTable(model.Parameters, interaction);
foreach (var value in possibleValues)
{
interaction.Combinations
.Add(new ValueCombination(value, interaction)
{
State = ValueCombinationState.Covered
});
}
// find combinations that should be excluded
var excludedCombinations = new List <ValueCombination>();
foreach (var combination in interaction.Combinations)
{
if (!combination.ParameterToValueMap.Any((p) => !completeInteraction.Parameters.Contains(p.Key)) &&
!allowedCombinations.Any((c) => MatchCombination(combination, c)))
{
excludedCombinations.Add(combination);
}
}
if (excludedCombinations.Count() > 0)
{
foreach (var combination in excludedCombinations)
{
combination.State = ValueCombinationState.Excluded;
}
MergeConstraintInteraction(order, interaction);
}
}
}
}
// helper to implement Constraint.GetExcludeCombinations
internal static ParameterInteraction GetExcludedCombinations <T>(Model model, Constraint constraint, Parameter first, Parameter second, T value, Func <T, T, bool> comparison)
{
Debug.Assert(first != null && model != null && constraint != null && comparison != null);
List <int> parameterIndices = new List <int>();
parameterIndices.Add(model.Parameters.IndexOf(first));
if (second != null)
{
parameterIndices.Add(model.Parameters.IndexOf(second));
}
parameterIndices.Sort();
ParameterInteraction interaction = new ParameterInteraction(parameterIndices);
List <int[]> valueTable = ParameterInteractionTable.GenerateValueTable(model.Parameters, interaction);
foreach (var valueIndices in valueTable)
{
T value1, value2;
value1 = (T)first[valueIndices[0]];
if (second == null)
{
value2 = value;
}
else
{
value2 = (T)second[valueIndices[1]];
}
ValueCombinationState comboState = comparison(value1, value2) ? ValueCombinationState.Covered : ValueCombinationState.Excluded;
interaction.Combinations.Add(new ValueCombination(valueIndices, interaction)
{
State = comboState
});
}
return(interaction);
}
// for the following system:
// if A == 0 then B == 0
// if B == 0 then C == 0
// if C == 0 then A == 1
// all combinations with A == 0 need to be excluded, but this is impossible to determine when looking at individual constraints
// to do this:
// - create groups of constraints where all members have a parameter that overlaps with another constraint
// - create ParameterInteraction for each group of constraints
// - for the existing uncovered combinations, if they excluded in every matching combination in the group interaction, mark excluded
// - higher order combinations that match the order of a constraint's interaction can also need to be exculded
private void GenerateDependentConstraintInteractions(Model model, int order, List <ParameterInteraction> constraintInteractions)
{
// group all the constraint parameter interactions that share parameters
var dependentConstraintSets = new List <List <ParameterInteraction> >();
while (constraintInteractions.Count > 0)
{
var dependentConstraintSet = new List <ParameterInteraction>();
var interactionsToExplore = new List <ParameterInteraction>();
interactionsToExplore.Add(constraintInteractions[0]);
constraintInteractions.RemoveAt(0);
while (interactionsToExplore.Count > 0)
{
ParameterInteraction current = interactionsToExplore[0];
interactionsToExplore.RemoveAt(0);
dependentConstraintSet.Add(current);
var dependentInteractions =
(from constraint in constraintInteractions
where constraint.Parameters.Any((i) => current.Parameters.Contains(i))
select constraint).ToList();
foreach (var dependentInteraction in dependentInteractions)
{
constraintInteractions.Remove(dependentInteraction);
}
interactionsToExplore.AddRange(dependentInteractions);
}
dependentConstraintSets.Add(dependentConstraintSet);
}
// walk over the groups of constraints
foreach (var dependentConstraintSet in dependentConstraintSets)
{
// if there's only one constraint no more processing is necessary
if (dependentConstraintSet.Count <= 1)
{
continue;
}
// merge the interactions of all the constraints
var uniqueParameters = new Dictionary <int, bool>();
var parameterInteractionCounts = new List <int>();
for (int i = 0; i < dependentConstraintSet.Count; i++)
{
foreach (var parameter in dependentConstraintSet[i].Parameters)
{
uniqueParameters[parameter] = true;
}
if (dependentConstraintSet[i].Parameters.Count > order)
{
parameterInteractionCounts.Add(dependentConstraintSet[i].Parameters.Count);
}
}
var sortedParameters = uniqueParameters.Keys.ToList();
sortedParameters.Sort();
ParameterInteraction completeInteraction = new ParameterInteraction(sortedParameters);
var valueTable = ParameterInteractionTable.GenerateValueTable(model.Parameters, completeInteraction);
foreach (var value in valueTable)
{
completeInteraction.Combinations
.Add(new ValueCombination(value, completeInteraction)
{
State = ValueCombinationState.Covered
});
}
// calculate the excluded combinations in the new uber interaction
var completeInteractionExcludedCombinations = new List <ValueCombination>();
// find the combinations from the uber interaction that aren't excluded
// if a combination is a subset of any of these it is not excluded
var allowedCombinations = new List <ValueCombination>();
foreach (var combination in completeInteraction.Combinations)
{
bool exclude = false;
foreach (var constraint in completeConstraints)
{
if (constraint.SatisfiesContraint(model, combination) == ConstraintSatisfaction.Unsatisfied)
{
exclude = true;
break;
}
}
if (exclude)
{
combination.State = ValueCombinationState.Excluded;
completeInteractionExcludedCombinations.Add(combination);
}
else
{
allowedCombinations.Add(combination);
}
}
// find the existing combinations that are never allowed in the uber interaction
var individualInteractionExcludedCombinations =
from interaction in Interactions
from combination in interaction.Combinations
where !combination.ParameterToValueMap.Any((p) => !completeInteraction.Parameters.Contains(p.Key)) &&
!allowedCombinations.Any((c) => MatchCombination(combination, c))
select combination;
// mark the combinations in the table as excluded
foreach (var combination in individualInteractionExcludedCombinations)
{
combination.State = ValueCombinationState.Excluded;
}
GenerateHigherOrderDependentExclusions(model, order, parameterInteractionCounts, completeInteraction, allowedCombinations);
}
}
