Changeset 7548 for branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3

Timestamp:

03/05/12 16:30:27 (13 years ago)

Author:

abeham

Message:

#1614: changed according to architects review

File:

• branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs (modified) (5 diffs)

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs

@@ -39 +39 @@
   [StorableClass]
   public sealed class GeneralizedQuadraticAssignmentProblem : SingleObjectiveHeuristicOptimizationProblem<IGQAPEvaluator, IGQAPSolutionCreator>, IStorableContent,
-    IConsumable<QAPInstance>,
-    IConsumable<CTAPInstance>,
-    IConsumable<TSPInstance>,
-    IConsumable<ATSPInstance>,
-    IConsumable<GQAPInstance> {
+    IProblemInstanceConsumer<QAPData>,
+    IProblemInstanceConsumer<CTAPData>,
+    IProblemInstanceConsumer<TSPData>,
+    IProblemInstanceConsumer<ATSPData>,
+    IProblemInstanceConsumer<GQAPData> {
 
     public override Image ItemImage {
@@ -169 +169 @@
       Parameters.Add(new ValueParameter<DoubleMatrix>("InstallationCosts", InstallationCostsDescription, new DoubleMatrix(), false));
       Parameters.Add(new FixedValueParameter<DoubleValue>("TransportationCosts", TransportationCostsDescription, new DoubleValue(1)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("OverbookedCapacityPenalty", OverbookedCapacityPenaltyDescription, new DoubleValue(1000)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("OverbookedCapacityPenalty", OverbookedCapacityPenaltyDescription, new DoubleValue(100000)));
       Parameters.Add(new ValueParameter<DoubleArray>("Demands", DemandsDescription, new DoubleArray(), false));
       Parameters.Add(new ValueParameter<DoubleArray>("Capacities", CapacitiesDescription, new DoubleArray(), false));
@@ -213 +213 @@
     }
 
-    #region Problem Instance Consumptions
-    public bool LoadFrom(QAPInstance instance) {
-      try {
-        Name = instance.Name;
-        Description = instance.Description;
-
-        Weights = new DoubleMatrix(instance.Weights);
-        Distances = new DoubleMatrix(instance.Distances);
-        InstallationCosts = new DoubleMatrix(Weights.Rows, Distances.Columns); // all zero
-        Capacities = new DoubleArray(Enumerable.Range(0, Distances.Rows).Select(x => 1.0).ToArray());
-        Demands = new DoubleArray(Enumerable.Range(0, Weights.Rows).Select(x => 1.0).ToArray());
-
-        TransportationCosts.Value = 1;
-
-        if (instance.BestKnownAssignment != null) {
-          EvaluateAndLoadAssignment(instance.BestKnownAssignment);
-        } else {
-          BestKnownQuality = null;
-          BestKnownSolution = null;
-          BestKnownSolutions = null;
+    #region Problem Instance Loading
+    public void Load(QAPData data) {
+      Name = data.Name;
+      Description = data.Description;
+
+      var weights = new DoubleMatrix(data.Weights);
+      var distances = new DoubleMatrix(data.Distances);
+      var installationCosts = new DoubleMatrix(weights.Rows, distances.Columns); // all zero
+      var capacities = new DoubleArray(Enumerable.Range(0, distances.Rows).Select(x => 1.0).ToArray());
+      var demands = new DoubleArray(Enumerable.Range(0, weights.Rows).Select(x => 1.0).ToArray());
+
+      Load(demands, capacities, weights, distances, installationCosts, new DoubleValue(1));
+      EvaluateAndLoadAssignment(data.BestKnownAssignment);
+    }
+
+    public void Load(CTAPData data) {
+      Name = data.Name;
+      Description = data.Description;
+
+      var capacities = new DoubleArray(data.MemoryCapacities);
+      var demands = new DoubleArray(data.MemoryRequirements);
+      var weights = new DoubleMatrix(data.CommunicationCosts);
+      var installationCosts = new DoubleMatrix(data.ExecutionCosts.Transpose());
+      var distances = new DoubleMatrix(capacities.Length, capacities.Length);
+      for (int i = 0; i < capacities.Length - 1; i++)
+        for (int j = i + 1; j < capacities.Length; j++) {
+          distances[i, j] = 1;
         }
-      } catch {
-        return false;
-      }
-      return true;
-    }
-
-    public bool LoadFrom(CTAPInstance instance) {
-      try {
-        Name = instance.Name;
-        Description = instance.Description;
-
-        Capacities = new DoubleArray(instance.MemoryCapacities);
-        Demands = new DoubleArray(instance.MemoryRequirements);
-        Weights = new DoubleMatrix(instance.CommunicationCosts);
-        InstallationCosts = new DoubleMatrix(instance.ExecutionCosts.Transpose());
-        Distances = new DoubleMatrix(Capacities.Length, Capacities.Length);
-        for (int i = 0; i < Capacities.Length - 1; i++)
-          for (int j = i + 1; j < Capacities.Length; j++) {
-            Distances[i, j] = 1;
-          }
-
-        TransportationCosts.Value = 1;
-
-        if (instance.BestKnownAssignment != null) {
-          EvaluateAndLoadAssignment(instance.BestKnownAssignment);
-        } else {
-          BestKnownQuality = null;
-          BestKnownSolution = null;
-          BestKnownSolutions = null;
-        }
-      } catch {
-        return false;
-      }
-      return true;
-    }
-
-    public bool LoadFrom(TSPInstance instance) {
-      try {
-        if (instance.Dimension > 1000) return false;
-
-        Name = instance.Name;
-        Description = instance.Description;
-
-        Capacities = new DoubleArray(instance.Dimension);
-        Demands = new DoubleArray(instance.Dimension);
-        for (int i = 0; i < instance.Dimension; i++) {
-          Capacities[i] = 1;
-          Demands[i] = 1;
-        }
-        InstallationCosts = new DoubleMatrix(instance.Dimension, instance.Dimension);
-        Weights = new DoubleMatrix(instance.Dimension, instance.Dimension);
-        for (int i = 0; i < instance.Dimension; i++)
-          Weights[i, (i + 1) % instance.Dimension] = 1;
-        Distances = new DoubleMatrix(instance.GetDistanceMatrix());
-
-        TransportationCosts.Value = 1;
-
-        if (instance.BestKnownTour != null) {
-          EvaluateAndLoadAssignment(instance.BestKnownTour);
-        } else {
-          BestKnownQuality = null;
-          BestKnownSolution = null;
-          BestKnownSolutions = null;
-        }
-      } catch {
-        return false;
-      }
-      return true;
-    }
-
-    public bool LoadFrom(ATSPInstance instance) {
-      try {
-        Name = instance.Name;
-        Description = instance.Description;
-
-        Capacities = new DoubleArray(instance.Dimension);
-        Demands = new DoubleArray(instance.Dimension);
-        for (int i = 0; i < instance.Dimension; i++) {
-          Capacities[i] = 1;
-          Demands[i] = 1;
-        }
-        InstallationCosts = new DoubleMatrix(instance.Dimension, instance.Dimension);
-        Weights = new DoubleMatrix(instance.Dimension, instance.Dimension);
-        for (int i = 0; i < instance.Dimension; i++)
-          Weights[i, (i + 1) % instance.Dimension] = 1;
-        Distances = new DoubleMatrix(instance.Distances);
-
-        TransportationCosts.Value = 1;
-
-        if (instance.BestKnownTour != null) {
-          EvaluateAndLoadAssignment(instance.BestKnownTour);
-        } else {
-          BestKnownQuality = null;
-          BestKnownSolution = null;
-          BestKnownSolutions = null;
-        }
-      } catch {
-        return false;
-      }
-      return true;
-    }
-
-    public bool LoadFrom(GQAPInstance instance) {
-      try {
-        Name = instance.Name;
-        Description = instance.Description;
-
-        Capacities = new DoubleArray(instance.Capacities);
-        Demands = new DoubleArray(instance.Demands);
-        InstallationCosts = new DoubleMatrix(instance.InstallationCosts);
-        Weights = new DoubleMatrix(instance.Weights);
-        Distances = new DoubleMatrix(instance.Distances);
-        TransportationCosts.Value = instance.TransportationCosts;
-
-        if (instance.BestKnownAssignment != null) {
-          EvaluateAndLoadAssignment(instance.BestKnownAssignment);
-        } else if (instance.BestKnownQuality.HasValue) {
-          BestKnownQuality = new DoubleValue(instance.BestKnownQuality.Value);
-          BestKnownSolution = null;
-          BestKnownSolutions = null;
-        } else {
-          BestKnownQuality = null;
-          BestKnownSolution = null;
-          BestKnownSolutions = null;
-        }
-      } catch {
-        return false;
-      }
-      return true;
-    }
-    #endregion
+
+      Load(demands, capacities, weights, distances, installationCosts, new DoubleValue(1));
+      EvaluateAndLoadAssignment(data.BestKnownAssignment);
+    }
+
+    public void Load(TSPData data) {
+      if (data.Dimension > 1000)
+        throw new System.IO.InvalidDataException("Instances with more than 1000 cities are not supported.");
+
+      Name = data.Name;
+      Description = data.Description;
+
+      var capacities = new DoubleArray(data.Dimension);
+      var demands = new DoubleArray(data.Dimension);
+      for (int i = 0; i < data.Dimension; i++) {
+        capacities[i] = 1;
+        demands[i] = 1;
+      }
+      var installationCosts = new DoubleMatrix(data.Dimension, data.Dimension);
+      var weights = new DoubleMatrix(data.Dimension, data.Dimension);
+      for (int i = 0; i < data.Dimension; i++)
+        weights[i, (i + 1) % data.Dimension] = 1;
+      var distances = new DoubleMatrix(data.GetDistanceMatrix());
+
+      Load(demands, capacities, weights, distances, installationCosts, new DoubleValue(1));
+      EvaluateAndLoadAssignment(data.BestKnownTour);
+    }
+
+    public void Load(ATSPData data) {
+      Name = data.Name;
+      Description = data.Description;
+
+      var capacities = new DoubleArray(data.Dimension);
+      var demands = new DoubleArray(data.Dimension);
+      for (int i = 0; i < data.Dimension; i++) {
+        capacities[i] = 1;
+        demands[i] = 1;
+      }
+      var installationCosts = new DoubleMatrix(data.Dimension, data.Dimension);
+      var weights = new DoubleMatrix(data.Dimension, data.Dimension);
+      for (int i = 0; i < data.Dimension; i++)
+        weights[i, (i + 1) % data.Dimension] = 1;
+      var distances = new DoubleMatrix(data.Distances);
+
+      Load(demands, capacities, weights, distances, installationCosts, new DoubleValue(1));
+      EvaluateAndLoadAssignment(data.BestKnownTour);
+    }
+
+    public void Load(GQAPData data) {
+      Name = data.Name;
+      Description = data.Description;
+
+      var capacities = new DoubleArray(data.Capacities);
+      var demands = new DoubleArray(data.Demands);
+      var installationCosts = new DoubleMatrix(data.InstallationCosts);
+      var weights = new DoubleMatrix(data.Weights);
+      var distances = new DoubleMatrix(data.Distances);
+      var transportationCosts = new DoubleValue(data.TransportationCosts);
+
+      Load(demands, capacities, weights, distances, installationCosts, transportationCosts);
+      EvaluateAndLoadAssignment(data.BestKnownAssignment);
+
+      if (data.BestKnownAssignment == null && data.BestKnownQuality.HasValue) {
+        BestKnownQuality = new DoubleValue(data.BestKnownQuality.Value);
+      }
+    }
+
+    public void Load(DoubleArray demands, DoubleArray capacities,
+      DoubleMatrix weights, DoubleMatrix distances, DoubleMatrix installationCosts,
+      DoubleValue transportationCosts, DoubleValue overbookedCapacityPenalty = null) {
+      if (weights == null || weights.Rows == 0)
+        throw new System.IO.InvalidDataException(
+@"The given instance does not contain weights!");
+      if (weights.Rows != weights.Columns)
+        throw new System.IO.InvalidDataException(
+@"The weights matrix of the given instance contains an unequal number of rows
+and columns.");
+      Weights = weights;
+
+      if (distances == null || distances.Rows == 0)
+        throw new System.IO.InvalidDataException(
+@"The given instance does not contain distances!");
+      if (distances.Rows != distances.Columns)
+        throw new System.IO.InvalidDataException(
+@"The distances matrix of the given instance contains an unequal number of rows
+and columns.");
+      Distances = distances;
+
+      if (installationCosts == null || installationCosts.Rows == 0)
+        throw new System.IO.InvalidDataException(
+@"The given instance does not contain installation costs!");
+      if (installationCosts.Rows != weights.Rows
+        || installationCosts.Columns != distances.Columns)
+        throw new System.IO.InvalidDataException(
+@"The installation costs matrix of the given instance contains different number
+of rows than given in the weights matrix and a different number of columns than
+given in the distances matrix.");
+      InstallationCosts = installationCosts;
+
+      if (capacities == null || capacities.Length == 0)
+        throw new System.IO.InvalidDataException(
+@"The given instance does not contain capacities!");
+      if (capacities.Length != distances.Rows)
+        throw new System.IO.InvalidDataException(
+@"The given instance contains a different number of capacities than rows given in
+the distances matrix.");
+      Capacities = capacities;
+
+      if (demands == null || demands.Length == 0)
+        throw new System.IO.InvalidDataException(
+@"The given instance does not contain demands!");
+      if (demands.Length != weights.Rows)
+        throw new System.IO.InvalidDataException(
+@"The given instance contains a different number of demands than rows given in
+the weights matrix.");
+      Demands = demands;
+
+      if (transportationCosts == null)
+        throw new System.IO.InvalidDataException(
+@"The given instance does not contain transportation costs.");
+      TransportationCosts.Value = transportationCosts.Value;
+
+      if (overbookedCapacityPenalty != null)
+        OverbookedCapacityPenalty.Value = overbookedCapacityPenalty.Value;
+
+      BestKnownQuality = null;
+      BestKnownSolution = null;
+      BestKnownSolutions = null;
+    }
 
     private void EvaluateAndLoadAssignment(int[] vector) {
+      if (vector == null || vector.Length == 0) return;
       EvaluateAndLoadAssignment(new IntegerVector(vector));
     }
-    private void EvaluateAndLoadAssignment(IntegerVector assignment) {
+    public void EvaluateAndLoadAssignment(IntegerVector assignment) {
       if (!IsConfigurationValid()) {
         BestKnownQuality = null;
@@ -387 +393 @@
       BestKnownSolutions.Solutions.Add(new GQAPSolution((IntegerVector)assignment.Clone(), new DoubleValue(quality), new DoubleValue(flowDistanceQuality), new DoubleValue(installationQuality), new DoubleValue(overbookedCapacity)));
     }
+    #endregion
 
     #region Events
@@ -525 +532 @@
     #endregion
 
-    private bool IsConfigurationValid() {
+    public bool IsConfigurationValid() {
       return Weights != null && Distances != null && Demands != null && Capacities != null && InstallationCosts != null
         && Weights.Rows == Weights.Columns && Weights.Rows == InstallationCosts.Rows