Index: /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/RandomInstanceProvider.cs
===================================================================
--- /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/RandomInstanceProvider.cs	(revision 15417)
+++ /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/RandomInstanceProvider.cs	(revision 15418)
@@ -26,4 +26,5 @@
 using System.IO;
 using System.Linq;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Problems.Instances;
@@ -83,5 +84,9 @@
 
   // class 9 from the paper (all-fill) is not implemented 
+
+
   public abstract class RandomInstanceProvider : ProblemInstanceProvider<BPPData>, IProblemInstanceProvider<BPPData> {
+
+
 
     protected int @class;
@@ -122,5 +127,6 @@
     public override BPPData LoadData(IDataDescriptor dd) {
       var randDd = dd as RandomDataDescriptor;
-      if (randDd == null) throw new NotSupportedException("Cannot load data descriptor " + dd);
+      if (randDd == null)
+        throw new NotSupportedException("Cannot load data descriptor " + dd);
 
       var data = new BPPData() {
@@ -161,31 +167,46 @@
       switch (type) {
         case 1: {
-            minW = 1; maxW = w / 2; // integer division on purpose (see paper)
-            minH = h * 2 / 3; maxH = h;
-            minD = d * 2 / 3; maxD = d;
+            minW = 1;
+            maxW = w / 2; // integer division on purpose (see paper)
+            minH = h * 2 / 3;
+            maxH = h;
+            minD = d * 2 / 3;
+            maxD = d;
             break;
           }
         case 2: {
-            minW = w * 2 / 3; maxW = w;
-            minH = 1; maxH = h / 2;
-            minD = d * 2 / 3; maxD = d;
+            minW = w * 2 / 3;
+            maxW = w;
+            minH = 1;
+            maxH = h / 2;
+            minD = d * 2 / 3;
+            maxD = d;
             break;
           }
         case 3: {
-            minW = w * 2 / 3; maxW = w;
-            minH = h * 2 / 3; maxH = h;
-            minD = 1; maxD = d / 2;
+            minW = w * 2 / 3;
+            maxW = w;
+            minH = h * 2 / 3;
+            maxH = h;
+            minD = 1;
+            maxD = d / 2;
             break;
           }
         case 4: {
-            minW = w / 2; maxW = w;
-            minH = h / 2; maxH = h;
-            minD = d / 2; maxD = d;
+            minW = w / 2;
+            maxW = w;
+            minH = h / 2;
+            maxH = h;
+            minD = d / 2;
+            maxD = d;
             break;
           }
         case 5: {
-            minW = 1; maxW = w / 2;
-            minH = 1; maxH = h / 2;
-            minD = 1; maxD = d / 2;
+            minW = 1;
+            maxW = w / 2;
+            minH = 1;
+            maxH = h / 2;
+            minD = 1;
+            maxD = d / 2;
             break;
           }
Index: /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/RandomInstanceProviderWithSRand.cs
===================================================================
--- /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/RandomInstanceProviderWithSRand.cs	(revision 15418)
+++ /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/RandomInstanceProviderWithSRand.cs	(revision 15418)
@@ -0,0 +1,332 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.IO;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  // make sure that for each class we have a separate entry in the problem instance providers
+  public class RandomInstanceClass1ProviderWithSRand : RandomInstanceProviderWithSRand {
+    public RandomInstanceClass1ProviderWithSRand() : base() { @class = 1; binWidth = binHeight = binDepth = 100; }
+  }
+  public class RandomInstanceClass2ProviderWithSRand : RandomInstanceProviderWithSRand {
+    public RandomInstanceClass2ProviderWithSRand() : base() { @class = 2; binWidth = binHeight = binDepth = 100; }
+  }
+  public class RandomInstanceClass3ProviderWithSRand : RandomInstanceProviderWithSRand {
+    public RandomInstanceClass3ProviderWithSRand() : base() { @class = 3; binWidth = binHeight = binDepth = 100; }
+  }
+  public class RandomInstanceClass4ProviderWithSRand : RandomInstanceProviderWithSRand {
+    public RandomInstanceClass4ProviderWithSRand() : base() { @class = 4; binWidth = binHeight = binDepth = 100; }
+  }
+  public class RandomInstanceClass5ProviderWithSRand : RandomInstanceProviderWithSRand {
+    public RandomInstanceClass5ProviderWithSRand() : base() { @class = 5; binWidth = binHeight = binDepth = 100; }
+  }
+
+  public class RandomInstanceClass6ProviderWithSRand : RandomInstanceProviderWithSRand {
+    public RandomInstanceClass6ProviderWithSRand() : base() {
+      @class = 6;
+      binWidth = binHeight = binDepth = 10;
+    }
+    protected override void SampleItemParameters(IRandom rand, out int w, out int h, out int d) {
+      w = rand.Next(1, 11);
+      h = rand.Next(1, 11);
+      d = rand.Next(1, 11);
+    }
+  }
+  public class RandomInstanceClass7ProviderWithSRand : RandomInstanceProviderWithSRand {
+    public RandomInstanceClass7ProviderWithSRand() : base() {
+      @class = 7;
+      binWidth = binHeight = binDepth = 40;
+    }
+    protected override void SampleItemParameters(IRandom rand, out int w, out int h, out int d) {
+      w = rand.Next(1, 36);
+      h = rand.Next(1, 36);
+      d = rand.Next(1, 36);
+    }
+  }
+  public class RandomInstanceClass8ProviderWithSRand : RandomInstanceProviderWithSRand {
+    public RandomInstanceClass8ProviderWithSRand() : base() {
+      @class = 8;
+      binWidth = binHeight = binDepth = 100;
+    }
+    protected override void SampleItemParameters(IRandom rand, out int w, out int h, out int d) {
+      w = rand.Next(1, 101);
+      h = rand.Next(1, 101);
+      d = rand.Next(1, 101);
+    }
+  }
+
+  // class 9 from the paper (all-fill) is not implemented 
+
+
+  public abstract class RandomInstanceProviderWithSRand : ProblemInstanceProvider<BPPData>, IProblemInstanceProvider<BPPData> {
+    #region Random Generator srand48
+    protected class SRand48 : Item, IRandom {
+      private object locker = new object();
+
+      private bool init = false;
+
+      private uint _h48;
+      private uint _l48;
+
+      public SRand48() {
+        if (!init) {
+          Seed((uint)DateTime.Now.Ticks);
+          init = true;
+        }
+      }
+      public SRand48(uint seed) {
+        if (!init) {
+          Seed(seed);
+          init = true;
+        }
+      }
+
+      public override IDeepCloneable Clone(Cloner cloner) {
+        throw new NotImplementedException();
+      }
+
+      public int Next() {
+        lock (locker) {
+          return (int)LRand48x();
+        }
+      }
+
+      public int Next(int maxVal) {
+        lock (locker) {
+          if (maxVal <= 0)
+            throw new ArgumentException("The interval [0, " + maxVal + ") is empty");
+          return (int)(LRand48x() % maxVal);
+        }
+      }
+
+      public int Next(int minVal, int maxVal) {
+        lock (locker) {
+          if (maxVal <= minVal)
+            throw new ArgumentException("The interval [" + minVal + ", " + maxVal + ") is empty");
+          return Next(maxVal - minVal + 1) + minVal;
+        }
+      }
+
+      public double NextDouble() {
+        lock (locker) {
+          return ((double)Next()) * (1.0 / 4294967296.0);
+        }
+      }
+
+      public void Reset() {
+        lock (locker) {
+          Seed((uint)DateTime.Now.Ticks);
+        }
+      }
+
+      public void Reset(int seed) {
+        lock (locker) {
+          Seed((uint)seed);
+        }
+      }
+
+      private void Seed(uint seed) {
+        _h48 = seed;
+        _l48 = 0x330E;
+      }
+
+      private int LRand48x() {
+        _h48 = (_h48 * 0xDEECE66D) + (_l48 * 0x5DEEC);
+        _l48 = _l48 * 0xE66D + 0xB;
+        _h48 = _h48 + (_l48 >> 16);
+        _l48 = _l48 & 0xFFFF;
+        return (int)(_h48 >> 1);
+      }
+
+    }
+
+    #endregion
+
+    protected int @class;
+    protected int binWidth, binHeight, binDepth;
+
+    public override string Name {
+      get { return string.Format("Martello, Pisinger, Vigo (class={0})", @class); }
+    }
+
+    public override string Description {
+      get { return "Randomly generated 3d bin packing problems as described in Martello, Pisinger, Vigo: 'The Three-Dimensional Bin Packing Problem', Operations Research Vol 48, Issue 2, 2000, pp. 256-267."; }
+    }
+
+    public override Uri WebLink {
+      get { return null; }
+    }
+
+    public override string ReferencePublication {
+      get { return "Martello, Pisinger, Vigo: 'The Three-Dimensional Bin Packing Problem', Operations Research Vol 48, Issue 2, 2000, pp. 256-267."; }
+    }
+
+    public RandomInstanceProviderWithSRand() : base() { }
+
+    public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
+      // 10 classes
+      //var rand = new MersenneTwister(1234); // fixed seed to makes sure that instances are always the same
+      foreach (int numItems in new int[] { 10, 15, 20, 25, 30, 35, 40, 45, 50, 60, 70, 80, 90, 100, 150, 200 }) {
+        // get class parameters
+        // generate 30 different instances for each class
+        foreach (int instance in Enumerable.Range(1, 30)) {
+          var rand = new SRand48((uint)(numItems + instance));
+          string name = string.Format("n={0}-id={1:00} (class={2})", numItems, instance, @class);
+          var dd = new RandomDataDescriptor(name, name, numItems, @class, seed: rand.Next());
+          yield return dd;
+        }
+      }
+    }
+
+    public override BPPData LoadData(IDataDescriptor dd) {
+      var randDd = dd as RandomDataDescriptor;
+      if (randDd == null)
+        throw new NotSupportedException("Cannot load data descriptor " + dd);
+
+      var data = new BPPData() {
+        BinShape = new PackingShape(binWidth, binHeight, binDepth),
+        Items = new PackingItem[randDd.NumItems]
+      };
+      var instanceRand = new SRand48((uint)randDd.Seed);
+      for (int i = 0; i < randDd.NumItems; i++) {
+        int w, h, d;
+        SampleItemParameters(instanceRand, out w, out h, out d);
+        data.Items[i] = new PackingItem(w, h, d, data.BinShape);
+      }
+      return data;
+    }
+
+    // default implementation for class 1 .. 5
+    protected virtual void SampleItemParameters(IRandom rand, out int w, out int h, out int d) {
+      // for classes 1 - 5
+      Contract.Assert(@class >= 1 && @class <= 5);
+      var weights = new double[] { 0.1, 0.1, 0.1, 0.1, 0.1 };
+      weights[@class - 1] = 0.6;
+      var type = Enumerable.Range(1, 5).SampleProportional(rand, 1, weights).First();
+
+      int minW, maxW;
+      int minH, maxH;
+      int minD, maxD;
+      GetItemParameters(type, rand, binWidth, binHeight, binDepth,
+        out minW, out maxW, out minH, out maxH, out minD, out maxD);
+
+      w = rand.Next(minW, maxW + 1);
+      h = rand.Next(minH, maxH + 1);
+      d = rand.Next(minD, maxD + 1);
+    }
+
+    private void GetItemParameters(int type, IRandom rand,
+      int w, int h, int d,
+      out int minW, out int maxW, out int minH, out int maxH, out int minD, out int maxD) {
+      switch (type) {
+        case 1: {
+            minW = 1;
+            maxW = w / 2; // integer division on purpose (see paper)
+            minH = h * 2 / 3;
+            maxH = h;
+            minD = d * 2 / 3;
+            maxD = d;
+            break;
+          }
+        case 2: {
+            minW = w * 2 / 3;
+            maxW = w;
+            minH = 1;
+            maxH = h / 2;
+            minD = d * 2 / 3;
+            maxD = d;
+            break;
+          }
+        case 3: {
+            minW = w * 2 / 3;
+            maxW = w;
+            minH = h * 2 / 3;
+            maxH = h;
+            minD = 1;
+            maxD = d / 2;
+            break;
+          }
+        case 4: {
+            minW = w / 2;
+            maxW = w;
+            minH = h / 2;
+            maxH = h;
+            minD = d / 2;
+            maxD = d;
+            break;
+          }
+        case 5: {
+            minW = 1;
+            maxW = w / 2;
+            minH = 1;
+            maxH = h / 2;
+            minD = 1;
+            maxD = d / 2;
+            break;
+          }
+        default: {
+            throw new InvalidProgramException();
+          }
+      }
+    }
+
+    public override bool CanImportData {
+      get { return false; }
+    }
+    public override BPPData ImportData(string path) {
+      throw new NotSupportedException();
+    }
+
+    public override bool CanExportData {
+      get { return true; }
+    }
+
+    public override void ExportData(BPPData instance, string file) {
+      using (Stream stream = new FileStream(file, FileMode.OpenOrCreate, FileAccess.Write)) {
+        Export(instance, stream);
+      }
+    }
+    public static void Export(BPPData instance, Stream stream) {
+
+      using (var writer = new StreamWriter(stream)) {
+        writer.WriteLine(String.Format("{0,-5} {1,-5} {2,-5}   WBIN,HBIN,DBIN", instance.BinShape.Width, instance.BinShape.Height, instance.BinShape.Depth));
+        for (int i = 0; i < instance.NumItems; i++) {
+          if (i == 0)
+            writer.WriteLine("{0,-5} {1,-5} {2,-5}   W(I),H(I),D(I),I=1,...,N", instance.Items[i].Width, instance.Items[i].Height, instance.Items[i].Depth);
+          else
+            writer.WriteLine("{0,-5} {1,-5} {2,-5}", instance.Items[i].Width, instance.Items[i].Height, instance.Items[i].Depth);
+
+        }
+        writer.Flush();
+      }
+    }
+
+  }
+}
Index: /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj
===================================================================
--- /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 15417)
+++ /branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 15418)
@@ -106,4 +106,5 @@
     <Compile Include="3D\Evaluators\BinUtilizationEvaluator.cs" />
     <Compile Include="3D\Evaluators\PackingRatioEvaluator.cs" />
+    <Compile Include="3D\Instances\RandomInstanceProviderWithSRand.cs" />
     <Compile Include="Algorithms\3D\ExtremePointAlgorithm.cs" />
     <Compile Include="3D\Instances\ThreeDInstanceDescriptor.cs" />
Index: /branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Problems.Bin-Packing-3.3/AlgorithmTest.cs
===================================================================
--- /branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Problems.Bin-Packing-3.3/AlgorithmTest.cs	(revision 15418)
+++ /branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Problems.Bin-Packing-3.3/AlgorithmTest.cs	(revision 15418)
@@ -0,0 +1,199 @@
+﻿using System;
+using System.IO;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Problems.BinPacking3D;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.BinPacking.Tests {
+    [TestClass]
+    public class AlgorithmTest {
+
+        private struct Dimension {
+            public int Id { get; set; }
+            public int Width { get; set; }
+            public int Height { get; set; }
+            public int Depth { get; set; }
+        }
+
+        #region TestRandomInstanceProvider
+
+
+        /// <summary>
+        /// Tests if the generated random instance equals to the references generated by david pisinger 
+        /// http://www.diku.dk/~pisinger/new3dbpp/test3dbpp.c
+        /// </summary>
+        [TestMethod]
+        [TestCategory("Problems.BinPacking")]
+        public void TestRandomInstanceProvider() {
+
+
+            var referenceItemLists = ReadReferenceItemLists();
+
+            TestRandomInstanceProviderByClass(new RandomInstanceClass1Provider(), referenceItemLists);
+            TestRandomInstanceProviderByClass(new RandomInstanceClass2Provider(), referenceItemLists);
+            TestRandomInstanceProviderByClass(new RandomInstanceClass3Provider(), referenceItemLists);
+            TestRandomInstanceProviderByClass(new RandomInstanceClass4Provider(), referenceItemLists);
+            TestRandomInstanceProviderByClass(new RandomInstanceClass5Provider(), referenceItemLists);
+            TestRandomInstanceProviderByClass(new RandomInstanceClass6Provider(), referenceItemLists);
+            TestRandomInstanceProviderByClass(new RandomInstanceClass7Provider(), referenceItemLists);
+            TestRandomInstanceProviderByClass(new RandomInstanceClass8Provider(), referenceItemLists);
+
+        }
+
+        private IDictionary<string, List<Dimension>> ReadReferenceItemLists() {
+            var itemList = new Dictionary<string, List<Dimension>>();
+            string path = @"C:\HEAL\BinPacking\Algorithm\export";//todo which location can be used for storing the reference files? At the moment their location can be found on the local disc
+
+            string[] files = Directory.GetFiles(path);
+            foreach (string filePath in files) {
+                string key = Path.GetFileNameWithoutExtension(filePath);
+
+                using (StreamReader reader = new StreamReader(filePath)) {
+                    int lineNumber = 1;
+                    List<Dimension> dimensionList = new List<Dimension>();
+                    while (!reader.EndOfStream) {
+                        string line = reader.ReadLine();
+                        if (lineNumber > 2) {
+                            string[] lineValues = line.Split('\t');
+                            int id;
+                            int depth;
+                            int width;
+                            int height;
+                            Int32.TryParse(lineValues[0], out id);
+                            Int32.TryParse(lineValues[1], out depth);
+                            Int32.TryParse(lineValues[2], out width);
+                            Int32.TryParse(lineValues[3], out height);
+                            dimensionList.Add(new Dimension() {
+                                Id = id,
+                                Depth = depth,
+                                Width = width,
+                                Height = height
+                            });
+                        }
+                        lineNumber++;
+                    }
+                    itemList.Add(key, dimensionList);
+                }
+            }
+            return itemList;
+        }
+
+        private void TestRandomInstanceProviderByClass(RandomInstanceProvider randomInstanceProvider, IDictionary<string, List<Dimension>> referenceItems) {
+
+            var dataDescriptors = randomInstanceProvider.GetDataDescriptors();
+            foreach (var dataDescriptor in dataDescriptors) {
+                List<Dimension> testItemDimensions = null;
+                if (referenceItems.TryGetValue(dataDescriptor.Name, out testItemDimensions)) {
+                    var packingItems = randomInstanceProvider.LoadData(dataDescriptor).Items;
+                    Assert.IsNotNull(packingItems);
+                    Assert.AreEqual(testItemDimensions.Count, packingItems.Length);
+                    for (int i = 0; i < packingItems.Length; i++) {
+                        Assert.AreEqual(testItemDimensions[i].Width, packingItems[i].Width);
+                        Assert.AreEqual(testItemDimensions[i].Height, packingItems[i].Height);
+                        Assert.AreEqual(testItemDimensions[i].Depth, packingItems[i].Depth);
+                    }
+                }
+            }
+        }
+        #endregion
+
+        #region TestExtremePointAlgorithm
+
+        /// <summary>
+        /// Constants for testing the algorithm
+        /// The test parameter are defined in the paper 
+        /// </summary>
+        private const int NUMBER_OF_TEST_INSTANCES = 10;
+        private static readonly int[] TEST_CLASSES = { 1, 2 };
+        private static readonly int[] NUMBER_OF_TEST_ITEMS = { 50, 100, 150, 200 };
+
+        [TestMethod]
+        [TestCategory("Problems.BinPacking")]
+        public void TestExtremePointAlgorithm() {
+            TestExtremePointAlgorithmByParameters(new RandomInstanceClass1Provider(), 1, SortingMethod.Given, FittingMethod.FirstFit);
+
+
+        }
+
+        private void TestExtremePointAlgorithmByParameters(RandomInstanceProvider randomInstanceProvider, int @class, SortingMethod sortingMethod, FittingMethod fittingMethod) {
+            var dataDescriptors = randomInstanceProvider.GetDataDescriptors();
+            var referenceValues = GetReferenceAlgorithmValues();
+            foreach (var numItems in NUMBER_OF_TEST_ITEMS) {
+                int sumNumberOfBins = 0;
+                for (int instance = 1; instance <= NUMBER_OF_TEST_INSTANCES; instance++) {
+                    string name = string.Format("n={0}-id={1:00} (class={2})", numItems, instance, @class);
+                    var selectedDataDescriptor = dataDescriptors.Where(dataDescriptor => dataDescriptor.Name == name);
+                    Assert.IsNotNull(selectedDataDescriptor?.First());
+                    var packingData = randomInstanceProvider.LoadData(selectedDataDescriptor.First());
+
+                    ExtremePointAlgorithm algorithm = new ExtremePointAlgorithm();
+                    algorithm.SortingMethodParameter.Value.Value = sortingMethod;
+                    algorithm.FittingMethodParameter.Value.Value = fittingMethod;
+                    algorithm.Problem.Load(packingData);
+
+                    algorithm.Start();
+
+                    PackingPlan<BinPacking3D.PackingPosition, PackingShape, PackingItem> bestPackingPlan = null;
+                    foreach (Optimization.IResult result in algorithm.Results) {
+                        if (result.Name == "Best Solution") {
+                            bestPackingPlan = (PackingPlan<BinPacking3D.PackingPosition, PackingShape, PackingItem>)result.Value;
+                            break;
+                        }
+                    }
+
+                    sumNumberOfBins += bestPackingPlan.NrOfBins;
+                }
+
+                double referenceValue = 0.0;
+                if (referenceValues.TryGetValue(new Tuple<int, int, SortingMethod>(@class, numItems, sortingMethod), out referenceValue)) {
+                    Assert.AreEqual(referenceValue, (double)sumNumberOfBins / (double)NUMBER_OF_TEST_INSTANCES, 0.1);
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Returns a dictionary which contains the reference values from table 2 given by the paper https://www.cirrelt.ca/DocumentsTravail/CIRRELT-2007-41.pdf 
+        /// </summary>
+        /// <returns></returns>
+        private Dictionary<Tuple<int, int, SortingMethod>, double> GetReferenceAlgorithmValues() {
+            Dictionary<Tuple<int, int, SortingMethod>, double> referenceValues = new Dictionary<Tuple<int, int, SortingMethod>, double>();
+            
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 50, SortingMethod.Given), 14.6);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 100, SortingMethod.Given), 29.2);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 150, SortingMethod.Given), 40.1);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 200, SortingMethod.Given), 55.9);
+
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 50, SortingMethod.HeightVolume), 15);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 100, SortingMethod.HeightVolume), 29.2);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 150, SortingMethod.HeightVolume), 39.9);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 200, SortingMethod.HeightVolume), 55.6);
+
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 50, SortingMethod.VolumeHeight), 14.4);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 100, SortingMethod.VolumeHeight), 29.5);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 150, SortingMethod.VolumeHeight), 40.3);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 200, SortingMethod.VolumeHeight), 55.7);
+
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 50, SortingMethod.AreaHeight), 14.4);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 100, SortingMethod.AreaHeight), 28.3);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 150, SortingMethod.AreaHeight), 39.2);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 200, SortingMethod.AreaHeight), 53.2);
+
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 50, SortingMethod.HeightArea), 15);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 100, SortingMethod.HeightArea), 29);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 150, SortingMethod.HeightArea), 39.8);
+            referenceValues.Add(new Tuple<int, int, SortingMethod>(1, 200, SortingMethod.HeightArea), 55.1);
+
+
+            var s = referenceValues[new Tuple<int, int, SortingMethod>(1, 200, SortingMethod.HeightArea)];
+
+            return referenceValues;
+        }
+
+
+        #endregion
+    }
+
+}
Index: /branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- /branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15417)
+++ /branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15418)
@@ -583,4 +583,5 @@
     <Compile Include="HeuristicLab.PluginInfraStructure-3.3\InstallationManagerTest.cs" />
     <Compile Include="HeuristicLab.PluginInfraStructure-3.3\TypeExtensionsTest.cs" />
+    <Compile Include="HeuristicLab.Problems.Bin-Packing-3.3\AlgorithmTest.cs" />
     <Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\ThresholdCalculatorsTest.cs" />
     <Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\OnlineCalculatorPerformanceTest.cs" />
