Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
10/05/11 21:55:55 (13 years ago)
Author:
abeham
Message:

#1614

  • updated branch from trunk
Location:
branches/GeneralizedQAP
Files:
4 deleted
9 edited
4 copied

Legend:

Unmodified
Added
Removed

  • branches/GeneralizedQAP

  • branches/GeneralizedQAP/HeuristicLab.Optimization/3.3

    • Property svn:ignore

      •  

        old new  
        44*.user
        55*.vs10x
         6Plugin.cs

  • branches/GeneralizedQAP/HeuristicLab.Optimization/3.3/BatchRun.cs

    r6534 r6878  
    147147    }
    148148
    149     private bool stopPending;
     149    private bool batchRunStarted = false;
     150    private bool batchRunPaused = false;
     151    private bool batchRunStopped = false;
    150152
    151153    public BatchRun()
    … …  
    158160      repetitionsCounter = 0;
    159161      Runs = new RunCollection();
    160       stopPending = false;
    161162    }
    162163    public BatchRun(string name)
    … …  
    168169      repetitionsCounter = 0;
    169170      Runs = new RunCollection();
    170       stopPending = false;
    171171    }
    172172    public BatchRun(string name, string description)
    … …  
    177177      repetitionsCounter = 0;
    178178      Runs = new RunCollection();
    179       stopPending = false;
    180179    }
    181180    [StorableConstructor]
    182     private BatchRun(bool deserializing)
    183       : base(deserializing) {
    184       stopPending = false;
    185     }
     181    private BatchRun(bool deserializing) : base(deserializing) { }
    186182    [StorableHook(HookType.AfterDeserialization)]
    187183    private void AfterDeserialization() {
    … …  
    197193      repetitionsCounter = original.repetitionsCounter;
    198194      runs = cloner.Clone(original.runs);
    199       stopPending = original.stopPending;
     195      batchRunStarted = original.batchRunStarted;
     196      batchRunPaused = original.batchRunPaused;
     197      batchRunStopped = original.batchRunStopped;
    200198      Initialize();
    201199    }
    … …  
    227225      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
    228226        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
    229       if (Optimizer != null) Optimizer.Start();
     227      if (Optimizer == null) return;
     228
     229      batchRunStarted = true;
     230      batchRunPaused = false;
     231      batchRunStopped = false;
     232      if (Optimizer.ExecutionState == ExecutionState.Stopped) Optimizer.Prepare();
     233      Optimizer.Start();
    230234    }
    231235    public void Pause() {
    232236      if (ExecutionState != ExecutionState.Started)
    233237        throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
    234       if ((Optimizer != null) && (Optimizer.ExecutionState == ExecutionState.Started))
    235         Optimizer.Pause();
     238      if (Optimizer == null) return;
     239      if (Optimizer.ExecutionState != ExecutionState.Started) return;
     240
     241      batchRunStarted = false;
     242      batchRunPaused = true;
     243      batchRunStopped = false;
     244      Optimizer.Pause();
    236245    }
    237246    public void Stop() {
    238247      if ((ExecutionState != ExecutionState.Started) && (ExecutionState != ExecutionState.Paused))
    239248        throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".", ExecutionState));
    240       stopPending = true;
    241       if ((Optimizer != null) &&
    242           ((Optimizer.ExecutionState == ExecutionState.Started) || (Optimizer.ExecutionState == ExecutionState.Paused)))
    243         Optimizer.Stop();
     249      if (Optimizer == null) return;
     250      if (Optimizer.ExecutionState != ExecutionState.Started && Optimizer.ExecutionState != ExecutionState.Paused) return;
     251      batchRunStarted = false;
     252      batchRunPaused = false;
     253      batchRunStopped = true;
     254      Optimizer.Stop();
    244255    }
    245256
    … …  
    324335    }
    325336    private void Optimizer_Paused(object sender, EventArgs e) {
    326       OnPaused();
     337      if (ExecutionState == ExecutionState.Started) {
     338        batchRunStarted = false;
     339        batchRunPaused = true;
     340        batchRunStopped = false;
     341        OnPaused();
     342      }
    327343    }
    328344    private void Optimizer_Prepared(object sender, EventArgs e) {
    329       if ((ExecutionState == ExecutionState.Paused) || (ExecutionState == ExecutionState.Stopped))
     345      if (ExecutionState == ExecutionState.Stopped || !batchRunStarted) {
    330346        OnPrepared();
     347      }
    331348    }
    332349    private void Optimizer_Started(object sender, EventArgs e) {
    333       stopPending = false;
    334350      if (ExecutionState != ExecutionState.Started)
    335351        OnStarted();
    … …  
    338354      repetitionsCounter++;
    339355
    340       if (!stopPending && (repetitionsCounter < repetitions)) {
     356      if (batchRunStopped) OnStopped();
     357      else if (repetitionsCounter >= repetitions) OnStopped();
     358      else if (batchRunPaused) OnPaused();
     359      else if (batchRunStarted) {
    341360        Optimizer.Prepare();
    342361        Optimizer.Start();
    343       } else {
    344         OnStopped();
    345       }
     362      } else OnStopped();
    346363    }
    347364    private void Optimizer_Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs<IRun> e) {

  • branches/GeneralizedQAP/HeuristicLab.Optimization/3.3/Calculator.cs

    r6685 r6878  
    2222using System;
    2323using System.Collections.Generic;
    24 using System.Globalization;
    2524using System.Linq;
    2625using System.Text.RegularExpressions;
    … …  
    2928using HeuristicLab.Data;
    3029using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     30using System.Globalization;
    3131
    3232namespace HeuristicLab.Optimization {
    … …  
    4545    }
    4646
    47     private static readonly Regex TokenRegex = new Regex(@"[a-zA-Z0-9._]+|""([^""]|\"")+""|[-+*/^]|log");
     47    private static readonly Regex TokenRegex =
     48      new Regex(@"[a-zA-Z0-9._]+|""([^""]|\\"")*""|'([^']|\\')*'|[-+*/<>^]|dup|swap|drop|log|true|false|if|==|not|isnull|null|ismatch|rename");
    4849
    4950    #endregion
    … …  
    5455    protected Calculator(bool deserializing) { }
    5556    public Calculator() { }
    56     public Calculator(Calculator original, Cloner cloner) {
    57       if (original.tokens != null)
    58         this.tokens = original.tokens.ToList();
     57    protected Calculator(Calculator original, Cloner cloner) {
     58      cloner.RegisterClonedObject(original, this);
     59      tokens = original.tokens.ToList();
    5960    }
    6061    public IDeepCloneable Clone(Cloner cloner) {
    … …  
    6667    #endregion
    6768
    68     public IEnumerable<string> Tokenize(string s) {
     69    private static IEnumerable<string> Tokenize(string s) {
    6970      return TokenRegex.Matches(s).Cast<Match>().Select(m => m.Value);
    7071    }
    7172
    72     private double GetVariableValue(IDictionary<string, IItem> variables, string name) {
    73       if (variables.ContainsKey(name)) {
    74         var item = variables[name];
    75         var intValue = item as IntValue;
    76         if (intValue != null) {
    77           return intValue.Value;
    78         } else {
    79           var doubleValue = item as DoubleValue;
    80           if (doubleValue != null)
    81             return doubleValue.Value;
    82           else
    83             throw new InvalidOperationException("Non numerical argument");
    84         }
    85       } else {
    86         throw new InvalidOperationException(string.Format("variable \"{0}\" not found", name));
    87       }
    88     }
    89 
    9073    public IItem GetValue(IDictionary<string, IItem> variables) {
    91       var stack = new Stack<double>();
    92       Action<Func<double, double, double>> binf = op => {
    93         var b = stack.Pop();
    94         stack.Push(op(stack.Pop(), b));
    95       };
    96       try {
    97         foreach (var token in tokens) {
     74      var stack = new Stack<object>();
     75      int i = 0;
     76      try {
     77        for (; i<tokens.Count; i++) {
     78          var token = tokens[i];
    9879          double d;
    99           if (double.TryParse(token,
    100                 NumberStyles.AllowDecimalPoint |
    101               NumberStyles.AllowExponent |
    102               NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out d)) {
     80          if (TryParse(token, out d)) {
    10381            stack.Push(d);
    10482          } else if (token.StartsWith("\"")) {
    10583            stack.Push(GetVariableValue(variables, token.Substring(1, token.Length - 2).Replace(@"\""", @"""")));
     84          } else if (token.StartsWith("'")) {
     85            stack.Push(token.Substring(1, token.Length-2).Replace("\'", "'"));
    10686          } else {
    107             switch (token) {
    108               case "log": stack.Push(Math.Log(stack.Pop())); break;
    109               case "+": binf((x, y) => x + y); break;
    110               case "-": binf((x, y) => x - y); break;
    111               case "*": binf((x, y) => x * y); break;
    112               case "/": binf((x, y) => x / y); break;
    113               case "^": binf(Math.Pow); break;
    114               default: stack.Push(GetVariableValue(variables, token)); break;
    115             }
     87            Apply(token, stack, variables);
    11688          }
    11789        }
    118       } catch (InvalidOperationException x) {
    119         return new StringValue(string.Format("Calculation Failed: {0}", x.Message));
    120       }
    121       if (stack.Count != 1)
    122         return new StringValue("Invalid final evaluation stack size != 1");
    123       return new DoubleValue(stack.Pop());
    124     }
     90      } catch (Exception x) {
     91        throw new Exception(string.Format(
     92          "Calculation Failed at token #{1}: '{2}' {0}current stack is: {0}{3}", Environment.NewLine,
     93          i, tokens[i], string.Join(Environment.NewLine, stack.Select(AsString))),
     94          x);
     95      }
     96      if (stack.Count != 1) throw new Exception(string.Format("Invalid final evaluation stack size {0} (should be 1)", stack.Count));
     97      var result = stack.Pop();
     98      if (result is string) return new StringValue((string)result);
     99      if (result is double) return new DoubleValue((double)result);
     100      if (result is bool) return new BoolValue((bool)result);
     101      return null;
     102    }
     103
     104    private static void Apply(string token, Stack<object> stack, IDictionary<string, IItem> variables) {
     105      switch (token) {
     106        case "null":  stack.Push(null); break;
     107        case "true":  stack.Push(true); break;
     108        case "false": stack.Push(false); break;
     109
     110        case "drop": stack.Pop(); break;
     111        case "dup": stack.Push(stack.Peek()); break;
     112        case "swap":
     113          var top = stack.Pop();
     114          var next = stack.Pop();
     115          stack.Push(top);
     116          stack.Push(next);
     117          break;
     118
     119        case "log": Apply(stack, x => Math.Log((double)x)); break;
     120        case "+": Apply(stack, (x, y) => (double)x + (double)y); break;
     121        case "-": Apply(stack, (x, y) => (double)x - (double)y); break;
     122        case "*": Apply(stack, (x, y) => (double)x * (double)y); break;
     123        case "/": Apply(stack, (x, y) => (double)x / (double)y); break;
     124        case "^": Apply(stack, (x, y) => Math.Pow((double)x, (double)y)); break;
     125        case "<": Apply(stack, (x, y) => (double)x < (double)y); break;
     126        case ">": Apply(stack, (x, y) => (double)x > (double)y); break;
     127
     128        case "==": Apply(stack, (x, y) => Equal(x, y)); break;
     129        case "not": Apply(stack, x => !(bool)x); break;
     130        case "isnull": Apply(stack, x => x == null); break;
     131        case "if": Apply(stack, (then, else_, cond) => (bool)cond ? then : else_); break;
     132
     133        case "ismatch": Apply(stack, (s, p) => new Regex((string)p).IsMatch((string)s)); break;
     134        case "rename": Apply(stack, (s, p, r) => new Regex((string)p).Replace((string)s, (string)r)); break;
     135
     136        default: stack.Push(GetVariableValue(variables, token)); break;
     137      }
     138    }
     139
     140    #region Auxiliary Functions
     141
     142    #region IItem value conversion
     143    private static object GetIntValue(IItem value) {
     144      var v = value as IntValue;
     145      if (v != null) return (double)v.Value;
     146      return null;
     147    }
     148
     149    private static object GetDoubleValue(IItem value) {
     150      var v = value as DoubleValue;
     151      if (v != null) return v.Value;
     152      return null;
     153    }
     154
     155    private static object GetBoolValue(IItem value) {
     156      var v = value as BoolValue;
     157      if (v != null) return v.Value;
     158      return null;
     159    }
     160
     161    private static object GetVariableValue(IDictionary<string, IItem> variables, string name) {
     162      if (variables.ContainsKey(name)) {
     163        var item = variables[name];
     164        return
     165          GetIntValue(item) ??
     166          GetDoubleValue(item) ??
     167          GetBoolValue(item) ??
     168          item.ToString();
     169      }
     170      return null;
     171    }
     172    #endregion
     173
     174    #region variadic equality
     175    private static bool Equal(object a, object b) { return EqualNumber(a, b) || EqualBool(a, b) || EqualString(a, b) || a == b; }
     176    private static bool EqualNumber(object a, object b) { return a is double && b is double && (double)a == (double)b; }
     177    private static bool EqualBool(object a, object b) { return a is bool && b is bool && (bool)a == (bool)b; }
     178    private static bool EqualString(object a, object b) { return a is string && b is string && ((string)a).Equals((string)b); }
     179    #endregion
     180
     181    #region stack calculation
     182    private static void Apply(Stack<object> stack, Func<object, object> func) {
     183      if (stack.Count < 1)
     184        throw new InvalidOperationException("Stack is empty");
     185      var a = stack.Pop();
     186      try {
     187        stack.Push(func(a));
     188      } catch (Exception) {
     189        stack.Push(a);
     190        throw;
     191      }
     192    }
     193
     194    private static void Apply(Stack<object> stack, Func<object, object, object> func) {
     195      if (stack.Count < 2)
     196        throw new InvalidOperationException("Stack contains less than two elements");
     197      var b = stack.Pop();
     198      var a = stack.Pop();
     199      try {
     200        stack.Push(func(a, b));
     201      } catch (Exception) {
     202        stack.Push(b);
     203        stack.Push(a);
     204        throw;
     205      }
     206    }
     207
     208    private static void Apply(Stack<object> stack, Func<object, object, object, object> func) {
     209      if (stack.Count < 3)
     210        throw new InvalidOperationException("Stack contains less than three elements");
     211      var c = stack.Pop();
     212      var b = stack.Pop();
     213      var a = stack.Pop();
     214      try {
     215        stack.Push(func(a, b, c));
     216      } catch (Exception) {
     217        stack.Push(a);
     218        stack.Push(b);
     219        stack.Push(c);
     220        throw;
     221      }
     222    }
     223    #endregion
     224
     225    private static bool TryParse(string token, out double d) {
     226      return double.TryParse(token,
     227                             NumberStyles.AllowDecimalPoint |
     228                             NumberStyles.AllowExponent |
     229                             NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out d);
     230    }
     231
     232    private static string AsString(object o) {
     233      if (o == null) return "null";
     234      if (o is string) return string.Format("'{0}'", o);
     235      return o.ToString();
     236    }
     237
     238    #endregion
    125239  }
    126240}

  • branches/GeneralizedQAP/HeuristicLab.Optimization/3.3/Experiment.cs

    r6534 r6878  
    104104    }
    105105
    106     private bool stopPending;
     106    private bool experimentStarted = false;
     107    private bool experimentStopped = false;
    107108
    108109    public Experiment()
    … …  
    114115      optimizers = new OptimizerList();
    115116      Runs = new RunCollection();
    116       stopPending = false;
    117117      Initialize();
    118118    }
    … …  
    124124      optimizers = new OptimizerList();
    125125      Runs = new RunCollection();
    126       stopPending = false;
    127126      Initialize();
    128127    }
    … …  
    133132      optimizers = new OptimizerList();
    134133      Runs = new RunCollection();
    135       stopPending = false;
    136134      Initialize();
    137135    }
    138136    [StorableConstructor]
    139     private Experiment(bool deserializing)
    140       : base(deserializing) {
    141       stopPending = false;
    142     }
     137    private Experiment(bool deserializing) : base(deserializing) { }
    143138    [StorableHook(HookType.AfterDeserialization)]
    144139    private void AfterDeserialization() {
    … …  
    151146      optimizers = cloner.Clone(original.optimizers);
    152147      runs = cloner.Clone(original.runs);
    153       stopPending = original.stopPending;
     148
     149      experimentStarted = original.experimentStarted;
     150      experimentStopped = original.experimentStopped;
    154151      Initialize();
    155152    }
    … …  
    172169      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
    173170        throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
    174       if (Optimizers.Count > 0) {
    175         if (clearRuns) runs.Clear();
    176         foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState != ExecutionState.Started))
     171      if (Optimizers.Count == 0) return;
     172
     173      if (clearRuns) runs.Clear();
     174      foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState != ExecutionState.Started))
     175        if (clearRuns || optimizer.ExecutionState != ExecutionState.Prepared)
    177176          optimizer.Prepare(clearRuns);
    178       }
    179177    }
    180178    public void Start() {
    181179      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
    182180        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
    183       stopPending = false;
    184       if (Optimizers.Count > 0) {
    185         IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused));
    186         if (optimizer != null) optimizer.Start();
    187       }
     181      if (Optimizers.Count == 0) return;
     182
     183      experimentStarted = true;
     184      experimentStopped = false;
     185      IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused));
     186      if (optimizer != null) optimizer.Start();
    188187    }
    189188    public void Pause() {
    190189      if (ExecutionState != ExecutionState.Started)
    191190        throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
    192       if (Optimizers.Count > 0) {
    193         foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState == ExecutionState.Started))
    194           optimizer.Pause();
    195       }
     191      if (Optimizers.Count == 0) return;
     192
     193      experimentStarted = false;
     194      experimentStopped = false;
     195      foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState == ExecutionState.Started))
     196        optimizer.Pause();
    196197    }
    197198    public void Stop() {
    198199      if ((ExecutionState != ExecutionState.Started) && (ExecutionState != ExecutionState.Paused))
    199200        throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".", ExecutionState));
    200       stopPending = true;
    201       if (Optimizers.Count > 0) {
    202         foreach (IOptimizer optimizer in Optimizers.Where(x => (x.ExecutionState == ExecutionState.Started) || (x.ExecutionState == ExecutionState.Paused)))
    203           optimizer.Stop();
    204       }
     201      if (Optimizers.Count == 0) return;
     202
     203      experimentStarted = false;
     204      experimentStopped = true;
     205      foreach (IOptimizer optimizer in Optimizers.Where(x => (x.ExecutionState == ExecutionState.Started) || (x.ExecutionState == ExecutionState.Paused)))
     206        optimizer.Stop();
    205207    }
    206208
    … …  
    333335    }
    334336    private void optimizer_Stopped(object sender, EventArgs e) {
    335       if (!stopPending && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) {
     337      if (experimentStopped && Optimizers.All(o => o.ExecutionState == ExecutionState.Stopped || o.ExecutionState == ExecutionState.Prepared)) OnStopped();
     338      else if (Optimizers.All(o => o.ExecutionState == ExecutionState.Stopped)) OnStopped();
     339      else if (Optimizers.Any(o => o.ExecutionState == ExecutionState.Paused) && Optimizers.All(o => o.ExecutionState != ExecutionState.Started)) OnPaused();
     340      else if (experimentStarted && !experimentStopped && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) {
    336341        Optimizers.First(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)).Start();
    337       } else {
    338         if (Optimizers.All(x => (x.ExecutionState != ExecutionState.Started) && (x.ExecutionState != ExecutionState.Paused))) {
    339           stopPending = false;
    340           OnStopped();
    341         }
    342342      }
    343343    }

  • branches/GeneralizedQAP/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj

    r6685 r6878  
    4141    <DebugType>full</DebugType>
    4242    <Optimize>false</Optimize>
    43     <OutputPath>bin\Debug\</OutputPath>
     43    <OutputPath>$(SolutionDir)\bin\</OutputPath>
    4444    <DefineConstants>DEBUG;TRACE</DefineConstants>
    4545    <ErrorReport>prompt</ErrorReport>
    … …  
    5050    <DebugType>pdbonly</DebugType>
    5151    <Optimize>true</Optimize>
    52     <OutputPath>bin\Release\</OutputPath>
     52    <OutputPath>$(SolutionDir)\bin\</OutputPath>
    5353    <DefineConstants>TRACE</DefineConstants>
    5454    <ErrorReport>prompt</ErrorReport>
    5555    <WarningLevel>4</WarningLevel>
    56     <DocumentationFile>bin\Release\HeuristicLab.Optimization-3.3.XML</DocumentationFile>
     56    <DocumentationFile>
     57    </DocumentationFile>
    5758    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
    5859  </PropertyGroup>
    5960  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    6061    <DebugSymbols>true</DebugSymbols>
    61     <OutputPath>bin\x86\Debug\</OutputPath>
     62    <OutputPath>$(SolutionDir)\bin\</OutputPath>
    6263    <DefineConstants>DEBUG;TRACE</DefineConstants>
    6364    <DebugType>full</DebugType>
    … …  
    6768  </PropertyGroup>
    6869  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    69     <OutputPath>bin\x86\Release\</OutputPath>
     70    <OutputPath>$(SolutionDir)\bin\</OutputPath>
    7071    <DefineConstants>TRACE</DefineConstants>
    71     <DocumentationFile>bin\x86\Release\HeuristicLab.Optimization-3.3.XML</DocumentationFile>
     72    <DocumentationFile>
     73    </DocumentationFile>
    7274    <Optimize>true</Optimize>
    7375    <DebugType>pdbonly</DebugType>
    … …  
    7880  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
    7981    <DebugSymbols>true</DebugSymbols>
    80     <OutputPath>bin\x64\Debug\</OutputPath>
     82    <OutputPath>$(SolutionDir)\bin\</OutputPath>
    8183    <DefineConstants>DEBUG;TRACE</DefineConstants>
    8284    <DebugType>full</DebugType>
    … …  
    8688  </PropertyGroup>
    8789  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
    88     <OutputPath>bin\x64\Release\</OutputPath>
     90    <OutputPath>$(SolutionDir)\bin\</OutputPath>
    8991    <DefineConstants>TRACE</DefineConstants>
    90     <DocumentationFile>bin\x64\Release\HeuristicLab.Optimization-3.3.XML</DocumentationFile>
     92    <DocumentationFile>
     93    </DocumentationFile>
    9194    <Optimize>true</Optimize>
    9295    <DebugType>pdbonly</DebugType>
    … …  
    111114  </ItemGroup>
    112115  <ItemGroup>
     116    <Compile Include="Plugin.cs" />
     117    <Compile Include="RunCollectionDiscretizer.cs" />
     118    <Compile Include="RunCollectionGroupCreater.cs" />
    113119    <Compile Include="RunCollectionSorter.cs" />
    114120    <Compile Include="RunCollectionValueRemover.cs" />
    115121    <Compile Include="IRunCollectionModifier.cs" />
    116     <None Include="HeuristicLabOptimizationPlugin.cs.frame" />
     122    <None Include="Plugin.cs.frame" />
    117123    <Compile Include="Algorithms\Algorithm.cs" />
    118124    <Compile Include="BatchRun.cs" />
    … …  
    141147    <Compile Include="Problems\Problem.cs" />
    142148    <Compile Include="RunCollectionFormulaModifer.cs" />
    143     <Compile Include="RunCollectionFuzzifier.cs" />
    144     <Compile Include="RunCollectionModificationEvaluator.cs" />
    145149    <Compile Include="RunCollectionConstraints\RunCollectionComparisonConstraint.cs" />
    146150    <Compile Include="RunCollectionConstraints\RunCollectionConstraintCollection.cs" />
    … …  
    192196    <Compile Include="Algorithms\UserDefinedAlgorithm.cs" />
    193197    <Compile Include="Algorithms\EngineAlgorithm.cs" />
    194     <Compile Include="HeuristicLabOptimizationPlugin.cs" />
    195198    <Compile Include="Properties\AssemblyInfo.cs" />
    196199    <Compile Include="ResultCollection.cs" />
    … …  
    199202  <ItemGroup>
    200203    <None Include="HeuristicLab.snk" />
    201     <None Include="Properties\AssemblyInfo.frame" />
     204    <None Include="Properties\AssemblyInfo.cs.frame" />
    202205  </ItemGroup>
    203206  <ItemGroup>
    … …  
    205208      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
    206209      <Name>HeuristicLab.Collections-3.3</Name>
     210      <Private>False</Private>
    207211    </ProjectReference>
    208212    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
    209213      <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
    210214      <Name>HeuristicLab.Common.Resources-3.3</Name>
     215      <Private>False</Private>
    211216    </ProjectReference>
    212217    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
    213218      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
    214219      <Name>HeuristicLab.Common-3.3</Name>
     220      <Private>False</Private>
    215221    </ProjectReference>
    216222    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
    217223      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
    218224      <Name>HeuristicLab.Core-3.3</Name>
     225      <Private>False</Private>
    219226    </ProjectReference>
    220227    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
    221228      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
    222229      <Name>HeuristicLab.Data-3.3</Name>
     230      <Private>False</Private>
    223231    </ProjectReference>
    224232    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
    225233      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
    226234      <Name>HeuristicLab.Parameters-3.3</Name>
     235      <Private>False</Private>
    227236    </ProjectReference>
    228237    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
    229238      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
    230239      <Name>HeuristicLab.Persistence-3.3</Name>
     240      <Private>False</Private>
    231241    </ProjectReference>
    232242    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
    233243      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
    234244      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
     245      <Private>False</Private>
    235246    </ProjectReference>
    236247  </ItemGroup>
    … …  
    268279
    269280call PreBuildEvent.cmd
    270 SubWCRev "%25ProjectDir%25\" "%25ProjectDir%25\HeuristicLabOptimizationPlugin.cs.frame" "%25ProjectDir%25\HeuristicLabOptimizationPlugin.cs"</PreBuildEvent>
     281</PreBuildEvent>
    271282  </PropertyGroup>
    272283</Project>

  • branches/GeneralizedQAP/HeuristicLab.Optimization/3.3/Problems/SingleObjectiveHeuristicOptimizationProblem.cs

  • branches/GeneralizedQAP/HeuristicLab.Optimization/3.3/RunCollection.cs

    r5445 r6878  
    5151
    5252      constraints = new RunCollectionConstraintCollection(original.constraints.Select(x => cloner.Clone(x)));
     53      modifiers = new CheckedItemList<IRunCollectionModifier>(original.modifiers.Select(cloner.Clone));
    5354      foreach (IRunCollectionConstraint constraint in constraints)
    5455        constraint.ConstrainedValue = this;
    … …  
    6768      dataTypes = new Dictionary<string, HashSet<Type>>();
    6869      constraints = new RunCollectionConstraintCollection();
     70      modifiers = new CheckedItemList<IRunCollectionModifier>();
    6971      RegisterConstraintsEvents();
    7072    }
    … …  
    8385      get { return constraints; }
    8486    }
     87
     88    [Storable]
     89    private CheckedItemList<IRunCollectionModifier> modifiers;
     90    public CheckedItemList<IRunCollectionModifier> Modifiers {
     91      get { return modifiers; }
     92    }
     93
    8594
    8695    private bool updateOfRunsInProgress;
    … …  
    98107    private void AfterDeserialization() {
    99108      if (constraints == null) constraints = new RunCollectionConstraintCollection();
     109      if (modifiers == null) modifiers = new CheckedItemList<IRunCollectionModifier>();
    100110      RegisterConstraintsEvents();
    101111      RegisterConstraintEvents(constraints);
    … …  
    393403    }
    394404    #endregion
     405
     406    #region Modification
     407    public void Modify() {
     408      UpdateOfRunsInProgress = true;
     409      var runs = this.ToList();
     410      var selectedRuns = runs.Where(r => r.Visible).ToList();
     411      int nSelected = selectedRuns.Count;
     412      if (nSelected > 0) {
     413        foreach (var modifier in Modifiers.CheckedItems)
     414          modifier.Value.Modify(selectedRuns);
     415        if (nSelected != selectedRuns.Count || HaveDifferentOrder(selectedRuns, runs.Where(r => r.Visible))) {
     416          Clear();
     417          AddRange(ReplaceVisibleRuns(runs, selectedRuns));
     418        } else if (runs.Count > 0) {
     419          OnCollectionReset(this, runs);
     420        }
     421      }
     422      UpdateOfRunsInProgress = false;
     423    }
     424
     425    private static IEnumerable<IRun> ReplaceVisibleRuns(IEnumerable<IRun> runs, IEnumerable<IRun> visibleRuns) {
     426      var newRuns = new List<IRun>();
     427      var runIt = runs.GetEnumerator();
     428      var visibleRunIt = visibleRuns.GetEnumerator();
     429      while (runIt.MoveNext()) {
     430        if (runIt.Current != null && !runIt.Current.Visible)
     431          newRuns.Add(runIt.Current);
     432        else if (visibleRunIt.MoveNext())
     433          newRuns.Add(visibleRunIt.Current);
     434      }
     435      while (visibleRunIt.MoveNext())
     436        newRuns.Add(visibleRunIt.Current);
     437      return newRuns;
     438    }
     439
     440    private static bool HaveDifferentOrder(IEnumerable<IRun> l1, IEnumerable<IRun> l2) {
     441      return l1.Zip(l2, (r1, r2) => r1 != r2).Any();
     442    }
     443    #endregion
    395444  }
    396445}

  • branches/GeneralizedQAP/HeuristicLab.Optimization/3.3/RunCollectionFormulaModifer.cs

    r6685 r6878  
    2020    public ValueParameter<StringValue> ResultNameParameter {
    2121      get { return (ValueParameter<StringValue>)Parameters["ResultName"]; }
    22     }   
    23    
     22    }
     23
    2424    public ValueParameter<StringValue> FormulaParameter {
    2525      get { return (ValueParameter<StringValue>)Parameters["Formula"]; }
    26     }   
     26    }
    2727
    28     #region Construction & Cloning   
     28    private string ResultName { get { return ResultNameParameter.Value.Value; } }
     29    private string Formula { get { return FormulaParameter.Value.Value; } }
     30
     31    #region Construction & Cloning
    2932    [StorableConstructor]
    3033    protected RunCollectionFormulaModifer(bool deserializing) : base(deserializing) { }
    … …  
    3538    public RunCollectionFormulaModifer() {
    3639      Parameters.Add(new ValueParameter<StringValue>("ResultName", "The name of the result to be generated by this formula.", new StringValue("Calc.Value")));
    37       Parameters.Add(new ValueParameter<StringValue>("Formula", "RPN formula for new value. This can contain existing run parameters or results (optionally in quotes if they contain whitespace), numbers and arithmetic operators in postfix notation.", new StringValue("1 1 +")));
     40      Parameters.Add(new ValueParameter<StringValue>("Formula",
     41@"RPN formula for new value in postfix notation.
     42
     43This can contain the following elements:
     44
     45literals:
     46  numbers, true, false, null and strings in single quotes
     47variables (run parameters or results):
     48  unquoted or in double quotes if they contain special characters or whitespace
     49mathematical functions:
     50  +, -, /, ^ (power), log
     51predicates:
     52  ==, <, >, isnull, not
     53stack manipulation:
     54  drop swap dup
     55string matching:
     56  <string> <pattern> ismatch
     57string replacing:
     58  <string> <pattern> <replacement> rename
     59conditionals:
     60  <then> <else> <condition> if
     61
     62If the final value is null, the result variable is removed if it exists.",
     63        new StringValue("1 1 +")));
    3864      UpdateName();
    3965      RegisterEvents();
    … …  
    5884
    5985    private void UpdateName() {
    60       name = string.Format("{0} := {1}", ResultNameParameter.Value.Value, FormulaParameter.Value.Value);
     86      name = string.Format("{0} := {1}", ResultName, Formula);
    6187      OnNameChanged();
    6288    }
    6389
    6490    public void Modify(List<IRun> runs) {
    65       var calc = new Calculator {Formula = FormulaParameter.Value.Value};     
     91      var calc = new Calculator { Formula = Formula };
    6692      foreach (var run in runs) {
    6793        var variables = new Dictionary<string, IItem>();
    … …  
    7096        foreach (var result in run.Results)
    7197          variables[result.Key] = result.Value;
    72         run.Results[ResultNameParameter.Value.Value] = calc.GetValue(variables);       
    73       }     
     98        var value = calc.GetValue(variables);
     99        if (value != null)
     100          run.Results[ResultName] = value;
     101        else
     102          run.Results.Remove(ResultName);
     103      }
    74104    }
    75    
     105
    76106  }
    77107}
Note: See TracChangeset for help on using the changeset viewer.