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

#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", "Evaluates solutions to the generalized quadratic assignment problem.")]
  [StorableClass]
  public class GQAPEvaluator : SingleSuccessorOperator, IGQAPEvaluator {

    public ILookupParameter<DoubleValue> QualityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
    }
    public ILookupParameter<DoubleValue> InfeasibilityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["Infeasibility"]; }
    }
    public IValueLookupParameter<DoubleValue> PenaltyParameter {
      get { return (IValueLookupParameter<DoubleValue>)Parameters["Penalty"]; }
    }
    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<DoubleValue> TransportationCostsParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
    }
    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<DoubleValue>("Quality", "The quality a.k.a. fitness of the solution."));
      Parameters.Add(new LookupParameter<DoubleValue>("Infeasibility", "The infeasibility describes the sum of the overbooked capacities."));
      Parameters.Add(new ValueLookupParameter<DoubleValue>("Penalty", "The multiplier for the constraint violation when added to the quality.", new DoubleValue(1000)));
      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", "The weights matrix describes the flows between the equipments."));
      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", "The distances matrix describes the distances between the locations at which the equipment can be installed."));
      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", "The installation costs matrix describes the installation costs of installing equipment i at location j"));
      Parameters.Add(new LookupParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights matrix already."));
      Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands vector describes the space requirements of the equipments."));
      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "The vector that encodes the assignment."));
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new GQAPEvaluator(this, cloner);
    }

    public static DoubleValue Evaluate(IntegerVector assignment, DoubleMatrix weights, DoubleMatrix distances,
      DoubleMatrix installCosts, double transportCosts, DoubleArray demands, DoubleArray capacities,
      out double infeasibility) {
      double quality = 0;
      int len = assignment.Length;
      var slack = (DoubleArray)capacities.Clone();
      for (int i = 0; i < len; i++) {
        quality += installCosts[i, assignment[i]];
        for (int j = 0; j < len; j++) {
          quality += transportCosts * weights[i, j] * distances[assignment[i], assignment[j]];
        }
        slack[assignment[i]] -= demands[i];
      }

      infeasibility = -slack.Where(x => x < 0).Sum();
      return new DoubleValue(quality);
    }

    public override IOperation Apply() {
      IntegerVector assignment = AssignmentParameter.ActualValue;
      DoubleMatrix weights = WeightsParameter.ActualValue;
      DoubleMatrix distances = DistancesParameter.ActualValue;
      DoubleMatrix installCosts = InstallationCostsParameter.ActualValue;
      double transportCosts = TransportationCostsParameter.ActualValue.Value;
      DoubleArray demands = DemandsParameter.ActualValue;
      DoubleArray capacities = (DoubleArray)CapacitiesParameter.ActualValue.Clone();
      double penalty = PenaltyParameter.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 infeasibility;
      var quality = Evaluate(assignment, weights, distances, installCosts, transportCosts, demands, capacities, out infeasibility);

      InfeasibilityParameter.ActualValue = new DoubleValue(infeasibility);
      QualityParameter.ActualValue = new DoubleValue(quality.Value + penalty * infeasibility);
      return base.Apply();
    }
  }
}