<br />
<b>Warning</b>:  session_start(): open(/var/lib/php/sessions/sess_olbkcmp2l6rl3u1ps2d305qq0q, O_RDWR) failed: No space left on device (28) in <b>/var/www/tb-usercake/models/config.php</b> on line <b>51</b><br />
<br />
<b>Warning</b>:  session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in <b>/var/www/tb-usercake/models/config.php</b> on line <b>51</b><br />
// Sc = type of scores (e.g. Double)
// Sc can also be the actual instance created (e.g. a strategy)
// If Sc is not Comparable, you can supply an additional
// comparisonFunction.
sclass TunableParameters<Sc> {
  replace Scrd with GenericallyScored<MapSO, Sc>.
  
  settable IF1<MapSO, Sc> scoreFunction;
  settable IF2_OOInt<Sc> comparisonFunction;
  gettable Scrd best;
  new LinkedHashMap<S, Parameter> parameters;
  new L<Parameter> parameterList;
  gettable volatile long instancesTested;
  
  event newBest(Scrd instance);
  event fireInstanceScored(Scrd scored);
  
  abstract class Parameter<A> {
    settable S name;
    settable A defaultValue;
    
    abstract A randomValue();
    
    A get(MapSO instance) {
      ret (A) instance.get(name);
    }
  }
  
  class IntRangeParameter extends Parameter<Int> {
    settable IntRange range;
    settable int step = 1;
    
    Int randomValue() { ret random(range); }
  }
  
  class DoubleRangeParameter extends Parameter<Double> {
    settable DoubleRange range;
    settable double step = .1;
    
    Double randomValue() { ret random(range); }
  }
  
  <A extends Parameter> A add(A p) {
    parameters.put(p.name(), p);
    parameterList.add(p);
    ret p;
  }
  
  MapSO randomInstance() {
    MapSO map = new LinkedHashMap;
    for (param : parameterList)
      map.put(param.name(), param.randomValue());
    ret map;
  }
  
  MapSO defaultInstance() {
    MapSO map = new LinkedHashMap;
    for (param : parameterList)
      map.put(param.name(), param.defaultValue());
    ret map;
  }
  
  Scrd tryARandomCombination() {
    ret tryInstance(randomInstance());
  }
  
  Scrd tryDefaultValues() {
    ret tryInstance(defaultInstance());
  }
  
  // replaces the parameter with a random value
  L<Scrd> varyEachParameterOnce(MapSO instance) {
    if (instance == null) null;
    new L<Scrd> out;
    for (param : parameterList) {
      O value = param.randomValue();
      if (eq(param.get(instance), value))
        continue;
      MapSO instance2 = cloneMap(instance);
      instance2.put(param.name(), value);
      out.add(tryInstance(instance2));
    }
    ret out;
  }
  
  Sc score(MapSO instance) {
    ++instancesTested;
    ret scoreFunction.get(instance);
  }
  
  Scrd scored(MapSO instance) {
    Scrd scored = new GenericallyScored<>(instance, score(instance));
    fireInstanceScored(scored);
    ret scored;
  }
  
  Scrd tryInstance(MapSO instance) {
    Scrd scored = scored(instance);
    tryInstance(scored);
    ret scored;
  }
    
  void tryInstance(Scrd scored) {
    if (scored == null) ret;
    if (best == null || compareScrd(scored, best) > 0) {
      best = scored;
      newBest(scored);
    }
  }
  
  int compareScrd(Scrd a, Scrd b) {
    Sc scoreA = a.score();
    Sc scoreB = b.score();
    ret comparisonFunction == null ? cmp(scoreA, scoreB) : comparisonFunction.get(scoreA, scoreB);
  }
  
  toString {
    ret "Best: " + best + " (parameters: " + keys(parameters) + ")";
  }
}