Free cookie consent management tool by TermsFeed Policy Generator

Changeset 17887 for branches


Ignore:
Timestamp:
03/12/21 14:00:36 (4 years ago)
Author:
gkronber
Message:

#3073: intermediate comment while refactoring the branch

Location:
branches/3073_IA_constraint_splitting_reintegration
Files:
8 added
3 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/IntervalArithmeticGrammar.cs

    r17880 r17887  
    3535      var cos = new Cosine();
    3636      var tan = new Tangent();
     37      var tanh = new HyperbolicTangent();
    3738      var log = new Logarithm();
    38       var pow = new Power();
     39      var exp = new Exponential();
    3940      var square = new Square();
    40       var root = new Root();
    4141      var sqrt = new SquareRoot();
    42       var exp = new Exponential();
    43       var tanh = new HyperbolicTangent();
     42      var cube = new Cube();
     43      var cbrt = new CubeRoot();
     44      var abs = new Absolute();
     45      var aq = new AnalyticQuotient();
    4446      var constant = new Constant();
    45       var aq = new AnalyticQuotient();
    4647      constant.MinValue = -20;
    4748      constant.MaxValue = 20;
    … …  
    5152
    5253      //Special symbols
    53       var offset = new Addition {Name = "Offset"};
    54       var scaling = new Multiplication {Name = "Scaling"};
     54      var offset = new Addition { Name = "Offset" };
     55      var scaling = new Multiplication { Name = "Scaling" };
    5556      //all other symbols
    5657      var allSymbols = new List<Symbol> {
    57         add, sub, mul, div, constant, variableSymbol, sin, cos, tan, log, pow, square, root, sqrt, exp,
    58         tanh, aq
     58        add, sub, mul, div, constant, variableSymbol, sin, cos, tan, log, square, sqrt, cube, cbrt, exp,
     59        tanh, aq, abs
    5960      };
    6061
    61       var arithmeticSymbols = new List<Symbol> {add, sub, mul, div};
    62       var trigonometricSymbols = new List<Symbol> {sin, cos, tan, tanh};
    63       var exponentialAndLogarithmicSymbols = new List<Symbol> {exp, log};
    64       var powerSymbols = new List<Symbol> {square, pow, sqrt, root};
    65       var specialSymbols = new List<Symbol> {aq};
    66       var realValueSymbols = new List<Symbol>
    67         {add, sub, mul, div, sin, cos, tan, tanh, exp, log, variableSymbol, constant, aq};
     62      var bivariateFuncs = new List<Symbol> { add, sub, mul, div, aq };
     63      var univariateFuncs = new List<Symbol> { sin, cos, tan, tanh, exp, log, abs, square, cube, sqrt, cbrt };
     64      var realValueSymbols = new List<Symbol> {
     65         add, sub, mul, div, sin, cos, tan, tanh, exp, log, aq, abs, square, cube, sqrt, cbrt,
     66         variableSymbol, constant,
     67        };
    6868
    6969
    … …  
    7676      #region define subtree count for special symbols
    7777
    78       foreach (var symb in arithmeticSymbols) SetSubtreeCount(symb, 2, 2);
     78      foreach (var symb in bivariateFuncs) SetSubtreeCount(symb, 2, 2);
    7979
    80       foreach (var symb in trigonometricSymbols) SetSubtreeCount(symb, 1, 1);
    81 
    82       foreach (var symb in exponentialAndLogarithmicSymbols) SetSubtreeCount(symb, 1, 1);
     80      foreach (var symb in univariateFuncs) SetSubtreeCount(symb, 1, 1);
    8381
    8482      SetSubtreeCount(offset, 2, 2);
    8583      SetSubtreeCount(scaling, 2, 2);
    86       SetSubtreeCount(pow, 2, 2);
    87       SetSubtreeCount(root, 2, 2);
    88       SetSubtreeCount(square, 1, 1);
    89       SetSubtreeCount(sqrt, 1, 1);
    90       SetSubtreeCount(aq, 2, 2);
    9184
    9285      #endregion
    … …  
    109102      }
    110103
    111       //define childs for power symbols
    112       foreach (var symb in powerSymbols) {
    113         AddAllowedChildSymbol(symb, variableSymbol, 0);
    114         AddAllowedChildSymbol(symb, constant, 1);
    115       }
    116 
    117       //define child for sqrt and square
    118       foreach (var c in realValueSymbols) {
    119         AddAllowedChildSymbol(square, c, 0);
    120         AddAllowedChildSymbol(sqrt, c, 0);
    121       }
    122 
    123       //define child for aq
    124       foreach (var c in realValueSymbols) {
    125         AddAllowedChildSymbol(aq, c, 0);
    126         AddAllowedChildSymbol(aq, c, 1);
    127       }
    128 
    129104      #endregion
    130105
    131       Symbols.First(s => s is Power).Enabled = false;
    132       Symbols.First(s => s is Root).Enabled = false;
    133       Symbols.First(s => s is AnalyticQuotient).Enabled = false;
     106      Symbols.First(s => s is Cube).Enabled = false;
     107      Symbols.First(s => s is CubeRoot).Enabled = false;
     108      Symbols.First(s => s is Absolute).Enabled = false;
    134109    }
    135110  }

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IBoundsEstimator.cs

    r17768 r17887  
    1 using System;
    2 using System.Collections.Generic;
    3 using System.Linq;
    4 using System.Text;
    5 using System.Threading.Tasks;
     1using System.Collections.Generic;
    62using HEAL.Attic;
    73using HeuristicLab.Core;
    84using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    95
    10 namespace HeuristicLab.Problems.DataAnalysis.Symbolic{
     6namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    117  [StorableType("C94A360D-5A9F-48A3-A6D3-CF920C77E50D")]
    128  public interface IBoundsEstimator : INamedItem, IStatefulItem {
    139    Interval GetModelBound(ISymbolicExpressionTree tree, IntervalCollection variableRanges);
    1410
    15     IDictionary<ISymbolicExpressionTreeNode, Interval> GetModelNodesBounds(
     11    IDictionary<ISymbolicExpressionTreeNode, Interval> GetModelNodeBounds(
    1612      ISymbolicExpressionTree tree, IntervalCollection variableRanges);
    1713
     14    // returns the size of the violation which is the distance to one of the bounds
    1815    double CheckConstraint(
    19       ISymbolicExpressionTree tree, IntervalCollection variableRanges, IntervalConstraint constraint);
     16      ISymbolicExpressionTree tree, IntervalCollection variableRanges, ShapeConstraint constraint);
    2017
    2118    bool IsCompatible(ISymbolicExpressionTree tree);
    2219
    2320    int EvaluatedSolutions { get; set; }
    24     }
     21  }
    2522}

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IABoundsEstimator.cs

    r17880 r17887  
    461461    }
    462462
    463     public IDictionary<ISymbolicExpressionTreeNode, Interval> GetModelNodesBounds(
     463    public IDictionary<ISymbolicExpressionTreeNode, Interval> GetModelNodeBounds(
    464464      ISymbolicExpressionTree tree, IntervalCollection variableRanges) {
    465465      throw new NotImplementedException();
    … …  
    467467
    468468    public double CheckConstraint(
    469       ISymbolicExpressionTree tree, IntervalCollection variableRanges, IntervalConstraint constraint) {
     469      ISymbolicExpressionTree tree, IntervalCollection variableRanges, ShapeConstraint constraint) {
    470470      var occuringVariableRanges = GetOccurringVariableRanges(tree, variableRanges);
    471471      var instructions = PrepareInterpreterState(tree, occuringVariableRanges);

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IACompiledExpressionBoundsEstimator.cs

    r17772 r17887  
    104104
    105105
    106     public double CheckConstraint(ISymbolicExpressionTree tree, IntervalCollection variableRanges, IntervalConstraint constraint) {
     106    public double CheckConstraint(ISymbolicExpressionTree tree, IntervalCollection variableRanges, ShapeConstraint constraint) {
    107107      if (!UseIntervalSplitting) {
    108108        var modelBound = GetModelBound(tree, variableRanges);
    … …  
    166166    }
    167167
    168     public IDictionary<ISymbolicExpressionTreeNode, Interval> GetModelNodesBounds(ISymbolicExpressionTree tree, IntervalCollection variableRanges) {
     168    public IDictionary<ISymbolicExpressionTreeNode, Interval> GetModelNodeBounds(ISymbolicExpressionTree tree, IntervalCollection variableRanges) {
    169169      throw new NotSupportedException("Model nodes bounds are not supported.");
    170170    }

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

    r17760 r17887  
    2424using System;
    2525using System.Collections.Generic;
    26 using System.Collections.ObjectModel;
    2726using System.Linq;
    2827using HEAL.Attic;
    … …  
    3837  public sealed class IntervalInterpreter : ParameterizedNamedItem, IStatefulItem {
    3938    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
    40     private const string MinSplittingWidthParameterName = "MinSplittingWidth";
    41     private const string MaxSplittingDepthParameterName = "MaxSplittingDepth";
    42     private const string UseIntervalSplittingParameterName = "UseIntervalSplitting";
    43 
    4439    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter =>
    4540      (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName];
    46 
    47     public IFixedValueParameter<IntValue> MinSplittingWithParameter =>
    48       (IFixedValueParameter<IntValue>)Parameters[MinSplittingWidthParameterName];
    49 
    50     public IFixedValueParameter<IntValue> MaxSplittingDepthParameter =>
    51       (IFixedValueParameter<IntValue>)Parameters[MaxSplittingDepthParameterName];
    52 
    53     public IFixedValueParameter<BoolValue> UseIntervalSplittingParameter =>
    54       (IFixedValueParameter<BoolValue>)Parameters[UseIntervalSplittingParameterName];
    55 
    56     public int MinSplittingWidth {
    57       get => MinSplittingWithParameter.Value.Value;
    58       set => MinSplittingWithParameter.Value.Value = value;
    59     }
    60 
    61     public int MaxSplittingDepth {
    62       get => MaxSplittingDepthParameter.Value.Value;
    63       set => MaxSplittingDepthParameter.Value.Value = value;
    64     }
    65 
    66     public bool UseIntervalSplitting {
    67       get => UseIntervalSplittingParameter.Value.Value;
    68       set => UseIntervalSplittingParameter.Value.Value = value;
    69     }
    7041
    7142    public int EvaluatedSolutions {
    … …  
    8455      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName,
    8556        "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    86       Parameters.Add(new FixedValueParameter<IntValue>(MinSplittingWidthParameterName,
    87         "Minimum interval width until splitting is stopped", new IntValue(0)));
    88       Parameters.Add(new FixedValueParameter<IntValue>(MaxSplittingDepthParameterName,
    89         "Maximum recursion depth of the splitting", new IntValue(5)));
    90       Parameters.Add(new FixedValueParameter<BoolValue>(UseIntervalSplittingParameterName, "", new BoolValue(false)));
    9157    }
    9258
    … …  
    13197      Interval outputInterval;
    13298
    133       if (UseIntervalSplitting) {
    134         outputInterval = GetSymbolicExpressionTreeIntervals(tree, variableRanges,
    135           out var _);
    136       } else {
    137         var instructionCount = 0;
    138         var instructions = PrepareInterpreterState(tree, variableRanges);
    139         outputInterval = Evaluate(instructions, ref instructionCount);
    140       }
     99      var instructionCount = 0;
     100      var instructions = PrepareInterpreterState(tree, variableRanges);
     101      outputInterval = Evaluate(instructions, ref instructionCount);
    141102
    142103      return outputInterval.LowerBound <= outputInterval.UpperBound
    … …  
    159120
    160121      Interval outputInterval;
    161       if (UseIntervalSplitting) {
    162         //var variables = tree.IterateNodesPrefix().OfType<VariableTreeNode>().Select(x => x.VariableName).Distinct()
    163         //                    .ToList();
    164         var containsDependencyProblem = ContainsVariableMultipleTimes(tree, out var variables);
    165 
    166         if (containsDependencyProblem) {
    167           var currIndex = 0;
    168           var currDepth = 0;
    169           IDictionary<string, Interval> writeableVariableRanges =
    170             variableRanges.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
    171           //outputInterval = EvaluateRecursive(instructions, intervals, writeableVariableRanges, variables, MinSplittingWidth, MaxSplittingDepth,
    172           //  ref currIndex, ref currDepth, tree);
    173           outputInterval = EvaluateWithSplitting(instructions, intervals, writeableVariableRanges, variables);
    174         } else {
    175           var instructionCount = 0;
    176           outputInterval = Evaluate(instructions, ref instructionCount, intervals);
    177         }
    178       } else {
    179         var instructionCount = 0;
    180         outputInterval = Evaluate(instructions, ref instructionCount, intervals);
    181       }
     122      var instructionCount = 0;
     123      outputInterval = Evaluate(instructions, ref instructionCount, intervals);
    182124
    183125      nodeIntervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
    … …  
    219161    }
    220162
    221     public static Interval EvaluateWithSplitting(Instruction[] instructions,
    222                                                  IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals,
    223                                                  IDictionary<string, Interval> variableIntervals, List<string> multipleOccurenceVariables) {
    224       var savedIntervals = variableIntervals.ToDictionary(entry => entry.Key, entry => entry.Value);
    225       var min = FindBound(instructions, nodeIntervals, variableIntervals, multipleOccurenceVariables, minimization: true);
    226       var max = FindBound(instructions, nodeIntervals, savedIntervals, multipleOccurenceVariables, minimization: false);
    227 
    228       return new Interval(min, max);
    229     }
    230 
    231 
    232     private static double FindBound(Instruction[] instructions,
    233                                     IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals,
    234                                     IDictionary<string, Interval> variableIntervals, List<string> multipleOccurenceVariables, bool minimization = true) {
    235       SortedSet<BoxBound> prioQ = new SortedSet<BoxBound>();
    236 
    237       var ic = 0;
    238       //Calculate full box
    239       IReadOnlyDictionary<string, Interval> readonlyRanges = variableIntervals.ToDictionary(k => k.Key, k => k.Value);
    240       var interval = Evaluate(instructions, ref ic, nodeIntervals, readonlyRanges);
    241       // the order of keys in a dictionary is guaranteed to be the same order as values in a dictionary
    242       // https://docs.microsoft.com/en-us/dotnet/api/system.collections.idictionary.keys?view=netcore-3.1#remarks
    243       //var box = variableIntervals.Values;
    244       //Box only contains intervals from multiple occurence variables
    245       var box = multipleOccurenceVariables.Select(k => variableIntervals[k]);
    246       if (minimization) {
    247         prioQ.Add(new BoxBound(box, interval.LowerBound));
    248       } else {
    249         prioQ.Add(new BoxBound(box, -interval.UpperBound));
    250       }
    251 
    252       // TODO a fixed limit for depth?!
    253       for (var depth = 0; depth < 200; ++depth) {
    254         var currentBound = prioQ.Min;
    255         prioQ.Remove(currentBound);
    256 
    257         var newBoxes = Split(currentBound.box);
    258 
    259         foreach (var newBox in newBoxes) {
    260           //var intervalEnum = newBox.GetEnumerator();
    261           //var keyEnum = readonlyRanges.Keys.GetEnumerator();
    262           //while (intervalEnum.MoveNext() & keyEnum.MoveNext()) {
    263           //  variableIntervals[keyEnum.Current] = intervalEnum.Current;
    264           //}
    265           //Set the splitted variables
    266           var intervalEnum = newBox.GetEnumerator();
    267           foreach (var key in multipleOccurenceVariables) {
    268             intervalEnum.MoveNext();
    269             variableIntervals[key] = intervalEnum.Current;
    270           }
    271 
    272           ic = 0;
    273           var res = Evaluate(instructions, ref ic, nodeIntervals,
    274             new ReadOnlyDictionary<string, Interval>(variableIntervals));
    275           if (minimization) {
    276             prioQ.Add(new BoxBound(newBox, res.LowerBound));
    277           } else {
    278             prioQ.Add(new BoxBound(newBox, -res.UpperBound));
    279           }
    280         }
    281       }
    282 
    283       return minimization ?
    284         prioQ.First().bound :
    285         -prioQ.First().bound;
    286     }
    287 
    288     private static IEnumerable<IEnumerable<Interval>> Split(List<Interval> box) {
    289       var boxes = box.Select(region => region.Split()).Select(split => new List<Interval> { split.Item1, split.Item2 })
    290                      .ToList();
    291 
    292       return boxes.CartesianProduct();
    293     }
    294 
    295     // a multi-dimensional box with an associated bound
    296     // boxbounds are ordered first by bound (smaller first), then by size of box (larger first) then by distance of bottom left corner to origin
    297     private class BoxBound : IComparable<BoxBound> {
    298       public List<Interval> box;
    299       public double bound;
    300       public BoxBound(IEnumerable<Interval> box, double bound) {
    301         this.box = new List<Interval>(box);
    302         this.bound = bound;
    303       }
    304       public int CompareTo(BoxBound other) {
    305         if (bound != other.bound) return bound.CompareTo(other.bound);
    306 
    307         var thisSize = box.Aggregate(1.0, (current, dimExtent) => current * dimExtent.Width);
    308         var otherSize = other.box.Aggregate(1.0, (current, dimExtent) => current * dimExtent.Width);
    309         if (thisSize != otherSize) return -thisSize.CompareTo(otherSize);
    310 
    311         var thisDist = box.Sum(dimExtent => dimExtent.LowerBound * dimExtent.LowerBound);
    312         var otherDist = other.box.Sum(dimExtent => dimExtent.LowerBound * dimExtent.LowerBound);
    313         if (thisDist != otherDist) return thisDist.CompareTo(otherDist);
    314 
    315         // which is smaller first along the dimensions?
    316         for (int i = 0; i < box.Count; i++) {
    317           if (box[i].LowerBound != other.box[i].LowerBound) return box[i].LowerBound.CompareTo(other.box[i].LowerBound);
    318         }
    319 
    320         return 0;
    321       }
    322     }
    323 
    324     public static Interval EvaluateRecursive(
    325       Instruction[] instructions,
    326       IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals,
    327       IDictionary<string, Interval> variableIntervals, IList<string> variables,
    328       double minWidth, int maxDepth, ref int currIndex, ref int currDepth,
    329       ISymbolicExpressionTree tree) {
    330       Interval evaluate() {
    331         var ic = 0;
    332         IReadOnlyDictionary<string, Interval> readonlyRanges =
    333           new ReadOnlyDictionary<string, Interval>(variableIntervals);
    334         return Evaluate(instructions, ref ic, nodeIntervals, readonlyRanges);
    335       }
    336 
    337       Interval recurse(ref int idx, ref int depth) {
    338         return EvaluateRecursive(instructions, nodeIntervals, variableIntervals, variables, minWidth, maxDepth, ref idx,
    339           ref depth, tree);
    340       }
    341 
    342 
    343       var v = variables[currIndex];
    344       var x = variableIntervals[v];
    345       if (x.Width < minWidth || currDepth == maxDepth || !MultipleTimes(tree, v)) {
    346         if (currIndex + 1 < variables.Count) {
    347           currDepth = 0;
    348           currIndex++;
    349           var z = recurse(ref currIndex, ref currDepth);
    350           currIndex--;
    351           return z;
    352         }
    353 
    354         return evaluate();
    355       }
    356 
    357       var t = x.Split();
    358       var xa = t.Item1;
    359       var xb = t.Item2;
    360       var d = currDepth;
    361       currDepth = d + 1;
    362       variableIntervals[v] = xa;
    363       var ya = recurse(ref currIndex, ref currDepth);
    364       currDepth = d + 1;
    365       variableIntervals[v] = xb;
    366       var yb = recurse(ref currIndex, ref currDepth);
    367       variableIntervals[v] = x; // restore interval
    368       return ya | yb;
    369     }
    370 
     163    // Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
     164    // Update instructionCounter, whenever Evaluate is called
    371165    public static Interval Evaluate(
    372       Instruction[] instructions, ref int instructionCounter,
     166    Instruction[] instructions, ref int instructionCounter,
    373167      IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null,
    374168      IReadOnlyDictionary<string, Interval> variableIntervals = null) {
    375169      var currentInstr = instructions[instructionCounter];
    376       //Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
    377       //Update instructionCounter, whenever Evaluate is called
     170
    378171      instructionCounter++;
    379       Interval result = null;
     172      Interval result;
    380173
    381174      switch (currentInstr.opCode) {
    382         //Variables, Constants, ...
    383175        case OpCodes.Variable: {
    384176            var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
    385177            var weightInterval = new Interval(variableTreeNode.Weight, variableTreeNode.Weight);
    386             //var variableInterval = (Interval)currentInstr.data;
    387178
    388179            Interval variableInterval;
    … …  
    402193        //Elementary arithmetic rules
    403194        case OpCodes.Add: {
    404             //result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    405             result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    406             for (var i = 1; i < currentInstr.nArguments; i++) {
    407               //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
     195            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
     196            for (var i = 1; i < currentInstr.nArguments; i++) {
    408197              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    409198              result = Interval.Add(result, argumentInterval);
    … …  
    413202          }
    414203        case OpCodes.Sub: {
    415             //result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    416204            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    417205            if (currentInstr.nArguments == 1)
    … …  
    419207
    420208            for (var i = 1; i < currentInstr.nArguments; i++) {
    421               //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    422209              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    423210              result = Interval.Subtract(result, argumentInterval);
    … …  
    427214          }
    428215        case OpCodes.Mul: {
    429             //result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    430             result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    431             for (var i = 1; i < currentInstr.nArguments; i++) {
    432               var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    433               //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
     216            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
     217            for (var i = 1; i < currentInstr.nArguments; i++) {
     218              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    434219              result = Interval.Multiply(result, argumentInterval);
    435220            }
    … …  
    438223          }
    439224        case OpCodes.Div: {
    440             //result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    441225            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    442226            if (currentInstr.nArguments == 1)
    … …  
    444228
    445229            for (var i = 1; i < currentInstr.nArguments; i++) {
    446               //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    447230              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    448231              result = Interval.Divide(result, argumentInterval);
    … …  
    451234            break;
    452235          }
    453         //Trigonometric functions
    454236        case OpCodes.Sin: {
    455             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    456237            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    457238            result = Interval.Sine(argumentInterval);
    … …  
    459240          }
    460241        case OpCodes.Cos: {
    461             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    462242            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    463243            result = Interval.Cosine(argumentInterval);
    … …  
    465245          }
    466246        case OpCodes.Tan: {
    467             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    468247            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    469248            result = Interval.Tangens(argumentInterval);
    … …  
    471250          }
    472251        case OpCodes.Tanh: {
    473             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    474252            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    475253            result = Interval.HyperbolicTangent(argumentInterval);
    476254            break;
    477255          }
    478         //Exponential functions
    479256        case OpCodes.Log: {
    480             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    481257            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    482258            result = Interval.Logarithm(argumentInterval);
    … …  
    484260          }
    485261        case OpCodes.Exp: {
    486             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    487262            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    488263            result = Interval.Exponential(argumentInterval);
    … …  
    490265          }
    491266        case OpCodes.Square: {
    492             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    493267            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    494268            result = Interval.Square(argumentInterval);
    … …  
    496270          }
    497271        case OpCodes.SquareRoot: {
    498             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    499272            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    500273            result = Interval.SquareRoot(argumentInterval);
    … …  
    502275          }
    503276        case OpCodes.Cube: {
    504             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    505277            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    506278            result = Interval.Cube(argumentInterval);
    … …  
    508280          }
    509281        case OpCodes.CubeRoot: {
    510             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    511282            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    512283            result = Interval.CubicRoot(argumentInterval);
    … …  
    514285          }
    515286        case OpCodes.Absolute: {
    516             //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    517287            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    518288            result = Interval.Absolute(argumentInterval);
    … …  
    520290          }
    521291        case OpCodes.AnalyticQuotient: {
    522             //result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    523             result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    524             for (var i = 1; i < currentInstr.nArguments; i++) {
    525               //var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
     292            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
     293            for (var i = 1; i < currentInstr.nArguments; i++) {
    526294              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
    527295              result = Interval.AnalyticalQuotient(result, argumentInterval);
    … …  
    538306
    539307      return result;
    540     }
    541 
    542     private static bool MultipleTimes(ISymbolicExpressionTree tree, string variable) {
    543       var varlist = tree.IterateNodesPrefix().OfType<VariableTreeNode>().GroupBy(x => x.VariableName);
    544       var group = varlist.Select(x => x.Key == variable).Count();
    545 
    546       return group > 1;
    547     }
    548 
    549     private static bool ContainsVariableMultipleTimes(ISymbolicExpressionTree tree, out List<String> variables) {
    550       variables = new List<string>();
    551       var varlist = tree.IterateNodesPrefix().OfType<VariableTreeNode>().GroupBy(x => x.VariableName);
    552       foreach (var group in varlist) {
    553         if (group.Count() > 1) {
    554           variables.Add(group.Key);
    555         }
    556       }
    557 
    558       return varlist.Any(group => group.Count() > 1);
    559308    }
    560309

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/IntervalUtil.cs

    r17881 r17887  
    77  public static class IntervalUtil {
    88    public static double IntervalConstraintViolation(
    9       IntervalConstraint constraint, IBoundsEstimator estimator, IntervalCollection intervalCollection,
     9      ShapeConstraint constraint, IBoundsEstimator estimator, IntervalCollection intervalCollection,
    1010      ISymbolicExpressionTree solution) {
    1111      var variableRanges = intervalCollection.GetReadonlyDictionary();
    … …  
    1414        throw new ArgumentException(
    1515          $"The given variable {constraint.Variable} in the constraint does not exist in the model.",
    16           nameof(IntervalConstraintsParser));
     16          nameof(ShapeConstraintsParser));
    1717      }
    1818
    … …  
    4747
    4848    public static IEnumerable<double> IntervalConstraintsViolation(
    49       IEnumerable<IntervalConstraint> constraints, IBoundsEstimator estimator, IntervalCollection intervalCollection,
     49      IEnumerable<ShapeConstraint> constraints, IBoundsEstimator estimator, IntervalCollection intervalCollection,
    5050      ISymbolicExpressionTree solution) {
    5151      return constraints.Select(constraint => IntervalConstraintViolation(constraint, estimator, intervalCollection, solution)).ToList();

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalConstraintView.cs

    r17607 r17887  
    3030namespace HeuristicLab.Problems.DataAnalysis.Views {
    3131  [View("Interval Constraint Detail View")]
    32   [Content(typeof(IntervalConstraint), true)]
     32  [Content(typeof(ShapeConstraint), true)]
    3333  public sealed partial class IntervalConstraintView : ItemView {
    34     public new IntervalConstraint Content {
    35       get => (IntervalConstraint) base.Content;
     34    public new ShapeConstraint Content {
     35      get => (ShapeConstraint) base.Content;
    3636      set => base.Content = value;
    3737    }

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Views/3.4/ProblemDataConstraintView.Designer.cs

    r17607 r17887  
    5858      this.errorOutput = new System.Windows.Forms.Label();
    5959      this.label1 = new System.Windows.Forms.Label();
    60       this.intervalConstraintsView = new CheckedItemListView<IntervalConstraint>();
     60      this.intervalConstraintsView = new CheckedItemListView<ShapeConstraint>();
    6161      ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
    6262      this.splitContainer1.Panel1.SuspendLayout();
    … …  
    183183    private System.Windows.Forms.Button                                     parseBtn;
    184184    private System.Windows.Forms.Label                                      label1;
    185     private HeuristicLab.Core.Views.CheckedItemListView<IntervalConstraint> intervalConstraintsView;
     185    private HeuristicLab.Core.Views.CheckedItemListView<ShapeConstraint> intervalConstraintsView;
    186186    private System.Windows.Forms.TextBox                                    constraintsInput;
    187187    private Label                                                           errorOutput;

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis.Views/3.4/ProblemDataConstraintView.cs

    r17607 r17887  
    3232namespace HeuristicLab.Problems.DataAnalysis.Views {
    3333  [View("ParsedConstraint View")]
    34   [Content(typeof(ProblemDataConstraint), true)]
     34  [Content(typeof(ShapeConstraints), true)]
    3535  public partial class ProblemDataConstraintView : AsynchronousContentView {
    36     private readonly CheckedItemList<IntervalConstraint>
    37       intervalConstraints = new CheckedItemList<IntervalConstraint>();
     36    private readonly CheckedItemList<ShapeConstraint>
     37      intervalConstraints = new CheckedItemList<ShapeConstraint>();
    3838
    39     public new ProblemDataConstraint Content {
    40       get => (ProblemDataConstraint) base.Content;
     39    public new ShapeConstraints Content {
     40      get => (ShapeConstraints) base.Content;
    4141      set => base.Content = value;
    4242    }
    … …  
    7373
    7474
    75     private IEnumerable<IntervalConstraint> ParseConstraints(string input) {
    76       return IntervalConstraintsParser.ParseInput(input, Content.ProblemData.TargetVariable,
     75    private IEnumerable<ShapeConstraint> ParseConstraints(string input) {
     76      return ShapeConstraintsParser.ParseInput(input, Content.ProblemData.TargetVariable,
    7777                                                  Content.ProblemData.AllowedInputVariables);
    7878    }
    … …  
    9090        }
    9191        catch (ArgumentException ex) {
    92           Content.Constraints = new List<IntervalConstraint>();
     92          Content.Constraints = new List<ShapeConstraint>();
    9393          Content.InfoText    = ex.Message.Replace("Parameter name", "@Line");
    9494          Content.InfoColor   = Color.DarkRed;
    … …  
    117117
    118118    private void constraint_Changed(object sender, EventArgs e) {
    119       var constraint = (IntervalConstraint) sender;
     119      var constraint = (ShapeConstraint) sender;
    120120      intervalConstraints.SetItemCheckedState(constraint, constraint.Enabled);
    121121    }
    122122
    123123    private void constraints_Updated(object                                                           sender,
    124                                      CollectionItemsChangedEventArgs<IndexedItem<IntervalConstraint>> e) {
     124                                     CollectionItemsChangedEventArgs<IndexedItem<ShapeConstraint>> e) {
    125125      foreach (var addedItem in e.Items) addedItem.Value.Changed += constraint_Changed;
    126126    }
    127127
    128     private void constraint_removed(object sender, CollectionItemsChangedEventArgs<IndexedItem<IntervalConstraint>> e) {
     128    private void constraint_removed(object sender, CollectionItemsChangedEventArgs<IndexedItem<ShapeConstraint>> e) {
    129129      foreach (var removedItem in e.Items) removedItem.Value.Changed -= constraint_Changed;
    130130    }
    131131
    132132    private void constraint_CheckedItemChanged(object                                                           sender,
    133                                                CollectionItemsChangedEventArgs<IndexedItem<IntervalConstraint>> e) {
    134       ICheckedItemList<IntervalConstraint> checkedItemList           = (ICheckedItemList<IntervalConstraint>) sender;
     133                                               CollectionItemsChangedEventArgs<IndexedItem<ShapeConstraint>> e) {
     134      ICheckedItemList<ShapeConstraint> checkedItemList           = (ICheckedItemList<ShapeConstraint>) sender;
    135135      foreach (var indexedItem in e.Items) indexedItem.Value.Enabled = checkedItemList.ItemChecked(indexedItem.Value);
    136136    }

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj

    r17768 r17887  
    190190    <Compile Include="Implementation\Interval\Interval.cs" />
    191191    <Compile Include="Implementation\Interval\IntervalCollection.cs" />
    192     <Compile Include="Implementation\Interval\IntervalConstraint.cs" />
    193     <Compile Include="Implementation\Interval\IntervalConstraintsParser.cs" />
     192    <Compile Include="Implementation\Interval\ShapeConstraint.cs" />
     193    <Compile Include="Implementation\Interval\ShapeConstraintsParser.cs" />
    194194    <Compile Include="Implementation\Regression\ConfidenceBoundRegressionSolution.cs" />
    195195    <Compile Include="Implementation\Regression\ConstantRegressionModel.cs" />
    196196    <Compile Include="Implementation\Regression\ConstantRegressionSolution.cs" />
     197    <Compile Include="Implementation\Regression\ShapeConstraints.cs" />
    197198    <Compile Include="Implementation\Regression\RegressionEnsembleProblemData.cs" />
    198199    <Compile Include="Implementation\Regression\RegressionEnsembleModel.cs">
    … …  
    306307    <Compile Include="Interfaces\IDataAnalysisModel.cs" />
    307308    <Compile Include="Interfaces\IDataAnalysisProblem.cs" />
    308     <Compile Include="ProblemDataConstraint.cs" />
    309309    <Compile Include="Properties\AssemblyInfo.cs" />
    310310  </ItemGroup>

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs

    r17770 r17887  
    2525using HEAL.Attic;
    2626using HeuristicLab.Common;
     27using HeuristicLab.Core;
    2728
    2829namespace HeuristicLab.Problems.DataAnalysis {
    … …  
    8081 
    8182      return false;
    82     }
    83 
    84     public Tuple<Interval, Interval> Split() {
    85       var midpoint = Width / 2;
    86       var left     = new Interval(LowerBound, LowerBound + midpoint - double.Epsilon);
    87       var right    = new Interval(LowerBound + midpoint, UpperBound);
    88       return Tuple.Create(left, right);
    89     }
    90 
    91     //Interval Intersection
    92     public static Interval operator &(Interval lhs, Interval rhs) {
    93       return new Interval(Math.Max(lhs.LowerBound, rhs.LowerBound), Math.Min(lhs.UpperBound, rhs.UpperBound));
    94     }
    95 
    96     //Interval Union
    97     public static Interval operator |(Interval lhs, Interval rhs) {
    98       return new Interval(Math.Min(lhs.LowerBound, rhs.LowerBound), Math.Max(lhs.UpperBound, rhs.UpperBound));
    9983    }
    10084

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalCollection.cs

    r17631 r17887  
    3434      get => HeuristicLab.Common.Resources.VSImageLibrary.Object;
    3535    }
    36     private IDictionary<string, Interval> intervals { get; } = new Dictionary<string, Interval>();
    3736
    38     [Storable(Name = "StorableIntervalInformation")]
     37    //[Storable]
     38    private IDictionary<string, Interval> intervals { get; set; } = new Dictionary<string, Interval>();
     39
     40    [Storable(OldName = "StorableIntervalInformation")]
    3941    private KeyValuePair<string, double[]>[] StorableIntervalInformation {
     42      set {
     43        foreach (var varInt in value)
     44          intervals.Add(varInt.Key, new Interval(varInt.Value[0], varInt.Value[1]));
     45      }
     46    }
     47
     48    [Storable]
     49    private object[] StorableIntervals {
    4050      get {
    41         var l = new List<KeyValuePair<string, double[]>>();
    42         foreach (var varInt in intervals)
     51        var names = intervals.Keys.ToArray();
     52        var lowerBounds = intervals.Values.Select(i => i.LowerBound).ToArray();
     53        var upperBounds = intervals.Values.Select(i => i.UpperBound).ToArray();
    4354
    44           l.Add(new KeyValuePair<string, double[]>(varInt.Key,
    45             new double[] { varInt.Value.LowerBound, varInt.Value.UpperBound }));
    46         return l.ToArray();
     55        return new object[] { names, lowerBounds, upperBounds };
    4756      }
    4857
    4958      set {
    50         foreach (var varInt in value)
    51           intervals.Add(varInt.Key, new Interval(varInt.Value[0], varInt.Value[1]));
     59        var names = (string[])value[0];
     60        var lowerBounds = (double[])value[1];
     61        var upperBounds = (double[])value[2];
     62
     63        for (int i = 0; i < names.Length; i++) {
     64          intervals.Add(names[i], new Interval(lowerBounds[i], upperBounds[i]));
     65        }
    5266      }
    5367    }
    … …  
    8094    public void SetInterval(string identifier, Interval interval) {
    8195      intervals[identifier] = interval;
     96      RaiseChanged();
    8297    }
    8398
    8499    public void AddInterval(string identifier, Interval interval) {
    85100      intervals.Add(identifier, interval);
     101      RaiseChanged();
    86102    }
    87103
    88104    public void DeleteInterval(string identifier) {
    89105      intervals.Remove(identifier);
     106      RaiseChanged();
    90107    }
    91108
    … …  
    102119        yield return Tuple.Create(variableInterval.Key, variableInterval.Value);
    103120    }
     121
     122    public event EventHandler Changed;
     123    private void RaiseChanged() {
     124      OnChanged();
     125      var handler = Changed;
     126      if (handler != null)
     127        handler(this, EventArgs.Empty);
     128    }
     129
     130    protected virtual void OnChanged() {  }
    104131  }
    105132}

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs

    r17607 r17887  
    9494      problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>()));
    9595      problemData.Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, "", new IntervalCollection()));
    96       problemData.Parameters.Add(new FixedValueParameter<ProblemDataConstraint>(IntervalConstraintsParameterName, "", new ProblemDataConstraint(problemData)));
     96      problemData.Parameters.Add(new FixedValueParameter<ShapeConstraints>(IntervalConstraintsParameterName, "", new ShapeConstraints()));
    9797      emptyProblemData = problemData;
    9898    }
    … …  
    109109    }
    110110
    111     public IFixedValueParameter<ProblemDataConstraint> IntervalConstraintsParameter =>
    112       (IFixedValueParameter<ProblemDataConstraint>) Parameters[IntervalConstraintsParameterName];
    113 
    114     public ProblemDataConstraint IntervalConstraints => IntervalConstraintsParameter.Value;
     111    public IFixedValueParameter<ShapeConstraints> IntervalConstraintsParameter =>
     112      (IFixedValueParameter<ShapeConstraints>) Parameters[IntervalConstraintsParameterName];
     113
     114    public ShapeConstraints IntervalConstraints => IntervalConstraintsParameter.Value;
    115115
    116116
    … …  
    148148
    149149      if (!Parameters.ContainsKey(IntervalConstraintsParameterName)) {
    150         Parameters.Add(new FixedValueParameter<ProblemDataConstraint>(IntervalConstraintsParameterName, new ProblemDataConstraint(this)));
     150        Parameters.Add(new FixedValueParameter<ShapeConstraints>(IntervalConstraintsParameterName, new ShapeConstraints()));
    151151      }
    152152      RegisterParameterEvents();
    … …  
    173173    }
    174174
    175     public RegressionProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
     175    public RegressionProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable,
     176      IEnumerable<ITransformation> transformations = null,
     177      IntervalCollection variableRanges = null,
     178      ShapeConstraints intervalConstraints = null)
    176179      : base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<ITransformation>()) {
    177180      var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
    178181      Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
    179       var intervalCollection = CalculateDatasetIntervals(this.Dataset);
    180       Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
    181       Parameters.Add(new FixedValueParameter<ProblemDataConstraint>(IntervalConstraintsParameterName, new ProblemDataConstraint(this)));
     182      if (variableRanges == null) {
     183        variableRanges = CalculateDatasetIntervals(this.Dataset);
     184      }
     185      Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, variableRanges));
     186      if (intervalConstraints == null) {
     187        intervalConstraints = new ShapeConstraints();
     188      }
     189      Parameters.Add(new FixedValueParameter<ShapeConstraints>(IntervalConstraintsParameterName, intervalConstraints));
    182190      RegisterParameterEvents();
    183191    }
    … …  
    185193    private static IntervalCollection CalculateDatasetIntervals(IDataset dataset) {
    186194      IntervalCollection intervalCollection = new IntervalCollection();
    187       foreach (var variable in dataset.DoubleVariables) {// intervals are only possible for double variables
     195      foreach (var variable in dataset.DoubleVariables) { // intervals are only possible for double variables
    188196        var variableInterval = Interval.GetInterval(dataset.GetDoubleValues(variable));
    189197        intervalCollection.AddInterval(variable, variableInterval);

  • branches/3073_IA_constraint_splitting_reintegration/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs

    r17607 r17887  
    3030    string TargetVariable { get; set; }
    3131
    32     IntervalCollection    VariableRanges      { get; }
    33     ProblemDataConstraint IntervalConstraints { get; }
     32    IntervalCollection VariableRanges { get; }
     33    ShapeConstraints IntervalConstraints { get; }
    3434
    35     IEnumerable<double> TargetVariableValues         { get; }
     35    IEnumerable<double> TargetVariableValues { get; }
    3636    IEnumerable<double> TargetVariableTrainingValues { get; }
    37     IEnumerable<double> TargetVariableTestValues     { get; }
     37    IEnumerable<double> TargetVariableTestValues { get; }
    3838  }
    3939}

  • branches/3073_IA_constraint_splitting_reintegration/IAConstraintsSplitting.sln

    r17591 r17887  
    99EndProject
    1010Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.DataAnalysis.Views-3.4", "HeuristicLab.Problems.DataAnalysis.Views\3.4\HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj", "{3E9E8944-44FF-40BB-A622-3A4A7DD0F198}"
     11EndProject
     12Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests\Tests.csproj", "{74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}"
    1113EndProject
    1214Global
    … …  
    5658    {3E9E8944-44FF-40BB-A622-3A4A7DD0F198}.Release|x86.ActiveCfg = Release|x86
    5759    {3E9E8944-44FF-40BB-A622-3A4A7DD0F198}.Release|x86.Build.0 = Release|x86
     60    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
     61    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Debug|Any CPU.Build.0 = Debug|Any CPU
     62    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Debug|x64.ActiveCfg = Debug|Any CPU
     63    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Debug|x64.Build.0 = Debug|Any CPU
     64    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Debug|x86.ActiveCfg = Debug|Any CPU
     65    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Debug|x86.Build.0 = Debug|Any CPU
     66    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Release|Any CPU.ActiveCfg = Release|Any CPU
     67    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Release|Any CPU.Build.0 = Release|Any CPU
     68    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Release|x64.ActiveCfg = Release|Any CPU
     69    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Release|x64.Build.0 = Release|Any CPU
     70    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Release|x86.ActiveCfg = Release|Any CPU
     71    {74BBCE93-8C04-4652-A6A4-E6EFF2DD8175}.Release|x86.Build.0 = Release|Any CPU
    5872  EndGlobalSection
    5973  GlobalSection(SolutionProperties) = preSolution
Note: See TracChangeset for help on using the changeset viewer.