source: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPEvaluator.cs @ 7970

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 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.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.IntegerVectorEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
  [Item("GQAPEvaluator", "Base class for solution evaluators for the generalized quadratic assignment problem.")]
  [StorableClass]
  public abstract class GQAPEvaluator : SingleSuccessorOperator, IGQAPEvaluator,
  IWeightsAwareGQAPOperator, IDistancesAwareGQAPOperator, IInstallationCostsAwareGQAPOperator,
  IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator, IAssignmentAwareGQAPOperator,
  IExpectedRandomQualityAwareGQAPOperator {

    #region Parameter Descriptions
    public static readonly string QualityDescription = "The quality of the solution.";
    public static readonly string FlowDistanceQualityDescription = "The quality regarding the flow-distance criteria.";
    public static readonly string InstallationQualityDescription = "The quality regarding the installation costs.";
    public static readonly string OverbookedCapacityDescription = "The sum of the overbooked capacities relative to the capacity of each location.";
    #endregion

    public ILookupParameter<BoolValue> MaximizationParameter {
      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
    }
    public ILookupParameter<DoubleValue> QualityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
    }
    public ILookupParameter<DoubleValue> FlowDistanceQualityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
    }
    public ILookupParameter<DoubleValue> InstallationQualityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
    }
    public ILookupParameter<DoubleValue> OverbookedCapacityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
    }
    public IValueLookupParameter<DoubleValue> TransportationCostsParameter {
      get { return (IValueLookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
    }
    public IValueLookupParameter<DoubleValue> ExpectedRandomQualityParameter {
      get { return (IValueLookupParameter<DoubleValue>)Parameters["ExpectedRandomQuality"]; }
    }
    public ILookupParameter<DoubleMatrix> WeightsParameter {
      get { return (ILookupParameter<DoubleMatrix>)Parameters["Weights"]; }
    }
    public ILookupParameter<DoubleMatrix> DistancesParameter {
      get { return (ILookupParameter<DoubleMatrix>)Parameters["Distances"]; }
    }
    public ILookupParameter<DoubleMatrix> InstallationCostsParameter {
      get { return (ILookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
    }
    public ILookupParameter<DoubleArray> DemandsParameter {
      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
    }
    public ILookupParameter<DoubleArray> CapacitiesParameter {
      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
    }
    public ILookupParameter<IntegerVector> AssignmentParameter {
      get { return (ILookupParameter<IntegerVector>)Parameters["Assignment"]; }
    }

    [StorableConstructor]
    protected GQAPEvaluator(bool deserializing) : base(deserializing) { }
    protected GQAPEvaluator(GQAPEvaluator original, Cloner cloner) : base(original, cloner) { }
    public GQAPEvaluator() : base() {
      Parameters.Add(new LookupParameter<BoolValue>("Maximization", GeneralizedQuadraticAssignmentProblem.MaximizationDescription));
      Parameters.Add(new LookupParameter<DoubleValue>("Quality", QualityDescription));
      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", FlowDistanceQualityDescription));
      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", InstallationQualityDescription));
      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", OverbookedCapacityDescription));
      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", GeneralizedQuadraticAssignmentProblem.TransportationCostsDescription));
      Parameters.Add(new ValueLookupParameter<DoubleValue>("ExpectedRandomQuality", GeneralizedQuadraticAssignmentProblem.ExpectedRandomQualityDescription));
      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", GeneralizedQuadraticAssignmentProblem.WeightsDescription));
      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", GeneralizedQuadraticAssignmentProblem.DistancesDescription));
      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", GeneralizedQuadraticAssignmentProblem.InstallationCostsDescription));
      Parameters.Add(new LookupParameter<DoubleArray>("Demands", GeneralizedQuadraticAssignmentProblem.DemandsDescription));
      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
    }

    public virtual double Evaluate(IntegerVector assignment, DoubleMatrix weights,
      DoubleMatrix distances, DoubleMatrix installCosts, DoubleArray demands,
      DoubleArray capacities, double transportationCosts, double expectedRandomQuality) {
      double flowDistanceQuality, installationQuality, overbookedCapacity;
      Evaluate(assignment, weights, distances, installCosts, demands, capacities,
        out flowDistanceQuality, out installationQuality, out overbookedCapacity);
      return GetFitness(flowDistanceQuality, installationQuality, overbookedCapacity,
        transportationCosts, expectedRandomQuality);
    }

    public virtual void Evaluate(IntegerVector assignment, DoubleMatrix weights, DoubleMatrix distances,
      DoubleMatrix installCosts, DoubleArray demands, DoubleArray capacities,
      out double flowDistanceQuality, out double installationQuality,
      out double overbookedCapacity) {
      flowDistanceQuality = 0;
      installationQuality = 0;
      int len = assignment.Length;
      var slack = (DoubleArray)capacities.Clone();
      for (int i = 0; i < len; i++) {
        installationQuality += installCosts[i, assignment[i]];
        for (int j = 0; j < len; j++) {
          flowDistanceQuality += weights[i, j] * distances[assignment[i], assignment[j]];
        }
        slack[assignment[i]] -= demands[i];
      }
      overbookedCapacity = EvaluateOverbooking(slack, capacities);
    }

    public virtual double EvaluateOverbooking(DoubleArray slack, DoubleArray capacities) {
      return slack.Select((v, i) => new { V = v, Index = i }).Where(x => x.V < 0.0).Select(x => -100.0 * x.V / capacities[x.Index]).Sum();
    }

    public abstract double GetFitness(double flowDistanceQuality,
      double installationQuality, double overbookedCapacity,
      double transportationCosts, double expectedRandomQuality);

    public override IOperation Apply() {
      var assignment = AssignmentParameter.ActualValue;
      var weights = WeightsParameter.ActualValue;
      var distances = DistancesParameter.ActualValue;
      var installCosts = InstallationCostsParameter.ActualValue;
      var demands = DemandsParameter.ActualValue;
      var capacities = CapacitiesParameter.ActualValue;
      var transportCosts = TransportationCostsParameter.ActualValue.Value;
      var expectedRandomQuality = ExpectedRandomQualityParameter.ActualValue.Value;

      if (weights.Rows != weights.Columns || distances.Rows != distances.Columns
        || weights.Rows != installCosts.Rows || distances.Rows != installCosts.Columns
        || demands.Length != weights.Rows || capacities.Length != distances.Rows)
        throw new InvalidOperationException("ERROR: The problem configuration is not valid! Check the sizes of the weights (NxN), distances (MxM) and installation costs (NxM) matrices as well as the length of the demand (N) and capacities (M) vectors.");

      double flowDistanceQuality, installationQuality, overbookedCapacity;
      Evaluate(assignment, weights, distances, installCosts, demands, capacities,
        out flowDistanceQuality, out installationQuality, out overbookedCapacity);

      FlowDistanceQualityParameter.ActualValue = new DoubleValue(flowDistanceQuality);
      InstallationQualityParameter.ActualValue = new DoubleValue(installationQuality);
      OverbookedCapacityParameter.ActualValue = new DoubleValue(overbookedCapacity);

      QualityParameter.ActualValue = new DoubleValue(GetFitness(flowDistanceQuality, installationQuality, overbookedCapacity, transportCosts, expectedRandomQuality));
      return base.Apply();
    }
  }
}