public List <List <BinaryOption> > getSample(Dictionary <string, string> parameter) { int numberConfigs; int optionWeight = 1; string numConfigsValue = null; if (parameter.ContainsKey(NUMBER_SAMPLES)) { numConfigsValue = parameter[NUMBER_SAMPLES]; } else { numConfigsValue = "asOW"; } if (numConfigsValue.Contains("asOW")) { FeatureWise fw = new FeatureWise(); numberConfigs = fw.generateFeatureWiseConfigsCSP(vm).Count; } else if (numConfigsValue.Contains("asTW")) { numConfigsValue.Replace("asTW", ""); numberConfigs = Int32.Parse(numConfigsValue); TWise tw = new TWise(); numberConfigs = tw.generateT_WiseVariants_new(vm, numberConfigs).Count; } else { numberConfigs = Int32.Parse(numConfigsValue); } if (parameter.ContainsKey(OPTION_WEIGHT)) { optionWeight = Int32.Parse(parameter[OPTION_WEIGHT]); } List <BinaryOption> minimalConfiguration = ConfigurationBuilder.vg.MinimizeConfig(new List <BinaryOption>(), vm, true, null); return(ConfigurationBuilder.vg.DistanceMaximization(vm, minimalConfiguration, numberConfigs, optionWeight)); }
/// <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); }