source: branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/Knapsack/KnapsackImprovementOperator.cs @ 7759

#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.BinaryVectorEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Problems.Knapsack;

namespace HeuristicLab.Algorithms.ScatterSearch.Knapsack {
  /// <summary>
  /// An operator that improves knapsack solutions.
  /// </summary>
  [Item("KnapsackImprovementOperator", "An operator that improves knapsack solutions.")]
  [StorableClass]
  public sealed class KnapsackImprovementOperator : SingleSuccessorOperator, ILocalImprovementOperator, IScatterSearchTargetProcessor {
    #region Problem properties
    public Type ProblemType {
      get { return typeof(KnapsackProblem); }
    }
    [Storable]
    private KnapsackProblem problem;
    public IProblem Problem {
      get { return problem; }
      set { problem = (KnapsackProblem)value; }
    }
    #endregion

    #region Parameter properties
    public ScopeParameter CurrentScopeParameter {
      get { return (ScopeParameter)Parameters["CurrentScope"]; }
    }
    public IValueLookupParameter<IntArray> ValuesParameter {
      get { return (IValueLookupParameter<IntArray>)Parameters["Values"]; }
    }
    public IValueLookupParameter<IntArray> WeightsParameter {
      get { return (IValueLookupParameter<IntArray>)Parameters["Weights"]; }
    }
    public IValueLookupParameter<IntValue> KnapsackCapacityParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["KnapsackCapacity"]; }
    }
    public IValueLookupParameter<IItem> TargetParameter {
      get { return (IValueLookupParameter<IItem>)Parameters["Target"]; }
    }
    #region ILocalImprovementOperator Parameters
    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
    }
    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
    }
    public ILookupParameter<ResultCollection> ResultsParameter {
      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
    }
    #endregion
    #endregion

    #region Properties
    private IScope CurrentScope {
      get { return CurrentScopeParameter.ActualValue; }
    }
    private IntArray Values {
      get { return ValuesParameter.ActualValue; }
      set { ValuesParameter.ActualValue = value; }
    }
    private IntArray Weights {
      get { return WeightsParameter.ActualValue; }
      set { WeightsParameter.ActualValue = value; }
    }
    private IntValue KnapsackCapacity {
      get { return KnapsackCapacityParameter.ActualValue; }
      set { KnapsackCapacityParameter.ActualValue = value; }
    }
    private IItem Target {
      get { return TargetParameter.ActualValue; }
    }
    #endregion

    [StorableConstructor]
    private KnapsackImprovementOperator(bool deserializing) : base(deserializing) { }
    private KnapsackImprovementOperator(KnapsackImprovementOperator original, Cloner cloner)
      : base(original, cloner) {
      this.problem = cloner.Clone(original.problem);
    }
    public KnapsackImprovementOperator()
      : base() {
      #region Create parameters
      Parameters.Add(new ScopeParameter("CurrentScope"));
      Parameters.Add(new ValueLookupParameter<IntArray>("Values"));
      Parameters.Add(new ValueLookupParameter<IntArray>("Weights"));
      Parameters.Add(new ValueLookupParameter<IntValue>("KnapsackCapacity"));
      Parameters.Add(new ValueLookupParameter<IItem>("Target"));
      #endregion
      TargetParameter.ActualName = "KnapsackSolution"; // temporary solution for the knapsack problem
    }

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

    public override IOperation Apply() {
      var sol = CurrentScope.Variables[TargetParameter.ActualName].Value as BinaryVector;

      // calculate value-to-weight ratio
      double[] ratio = new double[Values.Length];
      for (int i = 0; i < ratio.Length; i++) {
        ratio[i] = (double)Values[i] / (double)Weights[i];
      }

      // calculate order for ratio
      int[] order = new int[ratio.Length];
      ratio.Select((x, index) => new { Value = x, ValueIndex = index })
           .OrderBy(x => x.Value)
           .Select((x, index) => new { ValueIndex = x.ValueIndex, ItemIndex = index }).ToList()
           .ForEach(x => order[x.ItemIndex] = x.ValueIndex);

      int j = sol.Length - 1;
      while (KnapsackEvaluator.Apply(sol, KnapsackCapacity, new DoubleValue(1.0), Weights, Values).SumWeights.Value > KnapsackCapacity.Value && j >= 0) {
        sol[order[j--]] = false;
      }

      // calculate weight
      int lhs = 0;
      for (int i = 0; i < sol.Length; i++) {
        if (sol[i]) lhs += Weights[i];
      }

      // improve solution
      bool feasible = true; j = 0;
      while (feasible && j < sol.Length) {
        while (sol[order[j]]) j++;
        if (lhs + Weights[order[j]] <= KnapsackCapacity.Value) {
          sol[order[j]] = true;
          lhs += Weights[order[j]];
        } else {
          feasible = false;
        }
      }

      CurrentScope.Variables[TargetParameter.ActualName].Value = sol;

      return base.Apply();
    }

    private bool IsFeasiblse(BinaryVector sol) {
      int sum = 0;
      for (int i = 0; i < sol.Length; i++)
        if (sol[i]) sum += Weights[i];
      return sum <= KnapsackCapacity.Value;
    }
  }
}