/// <summary>
/// Returns a set of random binary partial configurations.
/// </summary>
/// <param name="parameters">Parameters for this random sampling. The following paramters are supported:
/// seed = the seed for the random generator (int required)
/// numConfigs = the number of configurations that have to be selected.
/// To be able ot select a number of configurations equal to the number selected by the OW heuristic or
/// the TWise heuristics, two special values can be given for this paramter. To select a number equal to
/// the OW heuristics use "asOW" as value and to select a number equal to a TWise heuristics with a t of X
/// use "asTWX".
/// </param>
/// <returns>A list of random binary partial configuartions.</returns>
public List <List <BinaryOption> > getRandomConfigs(Dictionary <String, String> parameters)
{
configurations.Clear();
int seed = 0;
int numConfigs = varModel.BinaryOptions.Count;
// parse parameters
if (parameters.ContainsKey("numConfigs"))
{
String numConfigsValue = parameters["numConfigs"];
if (!int.TryParse(numConfigsValue, out numConfigs))
{
// special constants as parameter (numConfigs = asOW or asTWX
if (numConfigsValue.Contains("asOW"))
{
FeatureWise fw = new FeatureWise();
numConfigs = fw.generateFeatureWiseConfigsCSP(varModel).Count;
}
else if (numConfigsValue.Contains("asTW"))
{
numConfigsValue = numConfigsValue.Replace("asTW", "").Trim();
int.TryParse(numConfigsValue, out numConfigs);
TWise tw = new TWise();
numConfigs = tw.generateT_WiseVariants_new(varModel, numConfigs).Count;
}
}
}
if (parameters.ContainsKey("seed"))
{
int.TryParse(parameters["seed"], out seed);
}
// build set of all valid binary partial configurations
VariantGenerator vg = new VariantGenerator();
List <List <BinaryOption> > allConfigs = vg.generateAllVariantsFast(varModel);
//repair wrong parameters
if (numConfigs >= allConfigs.Count)
{
if (numConfigs > allConfigs.Count)
{
GlobalState.logError.logLine("Random Sampling: numConfigs to large for variability model. num set to " + allConfigs.Count);
}
configurations = allConfigs;
return(allConfigs);
}
// select random configurations
Random r = new Random(seed);
for (int i = 0; i < numConfigs; i++)
{
List <BinaryOption> selectedConfig = allConfigs[r.Next(allConfigs.Count + 1)];
if (configurations.Contains(selectedConfig))
{
i -= 1;
}
else
{
configurations.Add(selectedConfig);
}
}
return(configurations);
}
public static List <Configuration> buildConfigs(VariabilityModel vm, List <SamplingStrategies> binaryStrategies,
List <ExperimentalDesign> experimentalDesigns)
{
List <Configuration> result = new List <Configuration>();
VariantGenerator vg = new VariantGenerator();
List <List <BinaryOption> > binaryConfigs = new List <List <BinaryOption> >();
List <Dictionary <NumericOption, Double> > numericConfigs = new List <Dictionary <NumericOption, double> >();
foreach (SamplingStrategies strat in binaryStrategies)
{
switch (strat)
{
//Binary sampling heuristics
case SamplingStrategies.ALLBINARY:
binaryConfigs.AddRange(vg.generateAllVariantsFast(vm));
break;
case SamplingStrategies.BINARY_RANDOM:
RandomBinary rb = new RandomBinary(vm);
foreach (Dictionary <string, string> expDesignParamSet in binaryParams.randomBinaryParameters)
{
binaryConfigs.AddRange(rb.getRandomConfigs(expDesignParamSet));
}
break;
case SamplingStrategies.OPTIONWISE:
{
FeatureWise fw = new FeatureWise();
binaryConfigs.AddRange(fw.generateFeatureWiseConfigurations(GlobalState.varModel));
}
break;
//case SamplingStrategies.MINMAX:
// {
// MinMax mm = new MinMax();
// binaryConfigs.AddRange(mm.generateMinMaxConfigurations(GlobalState.varModel));
// }
// break;
case SamplingStrategies.PAIRWISE:
{
PairWise pw = new PairWise();
binaryConfigs.AddRange(pw.generatePairWiseVariants(GlobalState.varModel));
}
break;
case SamplingStrategies.NEGATIVE_OPTIONWISE:
{
NegFeatureWise neg = new NegFeatureWise(); //2nd option: neg.generateNegativeFWAllCombinations(GlobalState.varModel));
binaryConfigs.AddRange(neg.generateNegativeFW(GlobalState.varModel));
}
break;
case SamplingStrategies.T_WISE:
foreach (Dictionary <string, string> ParamSet in binaryParams.tWiseParameters)
{
TWise tw = new TWise();
int t = 3;
foreach (KeyValuePair <String, String> param in ParamSet)
{
if (param.Key.Equals(TWise.PARAMETER_T_NAME))
{
t = Convert.ToInt16(param.Value);
}
binaryConfigs.AddRange(tw.generateT_WiseVariants_new(vm, t));
}
}
break;
}
}
//Experimental designs for numeric options
if (experimentalDesigns.Count != 0)
{
handleDesigns(experimentalDesigns, numericConfigs, vm);
}
foreach (List <BinaryOption> binConfig in binaryConfigs)
{
if (numericConfigs.Count == 0)
{
Configuration c = new Configuration(binConfig);
result.Add(c);
}
foreach (Dictionary <NumericOption, double> numConf in numericConfigs)
{
Configuration c = new Configuration(binConfig, numConf);
result.Add(c);
}
}
if (vm.MixedConstraints.Count == 0)
{
return(result.Distinct().ToList());
}
else
{
List <Configuration> unfilteredList = result.Distinct().ToList();
List <Configuration> filteredConfiguration = new List <Configuration>();
foreach (Configuration toTest in unfilteredList)
{
bool isValid = true;
foreach (MixedConstraint constr in vm.MixedConstraints)
{
if (!constr.requirementsFulfilled(toTest))
{
isValid = false;
}
}
if (isValid)
{
filteredConfiguration.Add(toTest);
}
}
return(filteredConfiguration);
}
}
