private void addBinarySamplingDomain(SamplingStrategies strat, List <BinaryOption> optionsToConsider)
{
if (optionsToConsider.Count > 0)
{
this.optionsToConsider.Add(strat, optionsToConsider);
}
}
public static bool TestBinaryNoParam(int expected, string solver, SamplingStrategies strategy, string reference)
{
string loc = resolvePath(solver, reference);
List <Configuration> result = testBinary(strategy);
List <Configuration> expectedSample = ConfigurationReader.readConfigurations_Header_CSV(loc, GlobalState.varModel);
return(containsAllMeasurements(result, expectedSample) && result.Count == expected);
}
private static List <Configuration> testBinary(SamplingStrategies strategy)
{
ConfigurationBuilder configBuilder = new ConfigurationBuilder();
configBuilder.binaryStrategies.Add(strategy);
configBuilder.numericStrategies.Add(new CentralCompositeInscribedDesign());
List <Configuration> result = configBuilder.buildConfigs(model);
return(result);
}
private void addBinSamplingNoParams(SamplingStrategies strategy, string name, bool isValidation)
{
if (isValidation)
{
this.binaryStrategiesValidation.Add(strategy);
}
else
{
this.binaryStrategies.Add(strategy);
}
}
private void testBinary(SamplingStrategies strategy, int expected)
{
List <SamplingStrategies> binaryStrat = new List <SamplingStrategies>();
binaryStrat.Add(strategy);
List <ExperimentalDesign> numericStrat = new List <ExperimentalDesign>();
numericStrat.Add(new CentralCompositeInscribedDesign());
List <Configuration> result = ConfigurationBuilder.buildConfigs(model, binaryStrat, numericStrat);
Assert.AreEqual(expected, result.Count);
}
private static List <Configuration> testBinary(SamplingStrategies strategy)
{
List <SamplingStrategies> binaryStrat = new List <SamplingStrategies>();
binaryStrat.Add(strategy);
List <ExperimentalDesign> numericStrat = new List <ExperimentalDesign>();
numericStrat.Add(new CentralCompositeInscribedDesign());
List <HybridStrategy> hybridStrat = new List <HybridStrategy>();
List <Configuration> result = ConfigurationBuilder.buildConfigs(model, binaryStrat, numericStrat, hybridStrat);
return(result);
}
private static void handleDesigns(List <ExperimentalDesign> samplingDesigns, List <Dictionary <NumericOption, Double> > numericOptions,
VariabilityModel vm)
{
foreach (ExperimentalDesign samplingDesign in samplingDesigns)
{
SamplingStrategies currentSamplingStrategy = (SamplingStrategies)System.Enum.Parse(typeof(SamplingStrategies), samplingDesign.getName());
if (optionsToConsider.ContainsKey(currentSamplingStrategy))
{
samplingDesign.setSamplingDomain(optionsToConsider[currentSamplingStrategy]);
}
else
{
samplingDesign.setSamplingDomain(vm.getNonBlacklistedNumericOptions(blacklisted));
}
samplingDesign.computeDesign();
numericOptions.AddRange(samplingDesign.SelectedConfigurations);
}
}
private void addBinSamplingParams(SamplingStrategies strategy, string name,
Dictionary <string, string> parameter, bool isValidation)
{
addBinSamplingNoParams(strategy, name, isValidation);
switch (strategy)
{
case SamplingStrategies.BINARY_RANDOM:
binaryParams.randomBinaryParameters.Add(parameter);
break;
case SamplingStrategies.T_WISE:
binaryParams.tWiseParameters.Add(parameter);
break;
case SamplingStrategies.SAT:
binaryParams.satParameters.Add(parameter);
break;
case SamplingStrategies.DISTANCE_BASED:
binaryParams.distanceMaxParameters.Add(parameter);
break;
}
}
