public void SinglePointCrossoverCrossTest() {
   var target = new PrivateObject(typeof(SinglePointCrossover));
   ItemArray<IntegerVector> parents;
   TestRandom random = new TestRandom();
   bool exceptionFired;
   // The following test checks if there is an exception when there are more than 2 parents
   random.Reset();
   parents = new ItemArray<IntegerVector>(new IntegerVector[] { new IntegerVector(5), new IntegerVector(6), new IntegerVector(4) });
   exceptionFired = false;
   try {
     IntegerVector actual;
     actual = (IntegerVector)target.Invoke("Cross", random, parents);
   }
   catch (System.ArgumentException) {
     exceptionFired = true;
   }
   Assert.IsTrue(exceptionFired);
   // The following test checks if there is an exception when there are less than 2 parents
   random.Reset();
   parents = new ItemArray<IntegerVector>(new IntegerVector[] { new IntegerVector(4) });
   exceptionFired = false;
   try {
     IntegerVector actual;
     actual = (IntegerVector)target.Invoke("Cross", random, parents);
   }
   catch (System.ArgumentException) {
     exceptionFired = true;
   }
   Assert.IsTrue(exceptionFired);
 }

    public static LinearLinkage Apply(IRandom random, ItemArray<LinearLinkage> parents) {
      var len = parents[0].Length;

      var child = new LinearLinkage(len);
      var childGroup = new List<HashSet<int>>();
      var currentParent = random.Next(parents.Length);
      var groups = parents.Select(x => x.GetGroups().Select(y => new HashSet<int>(y)).ToList()).ToList();
      bool remaining;
      do {
        var maxGroup = groups[currentParent].Select((v, i) => Tuple.Create(i, v))
          .MaxItems(x => x.Item2.Count)
          .SampleRandom(random).Item1;
        var group = groups[currentParent][maxGroup];
        groups[currentParent].RemoveAt(maxGroup);
        childGroup.Add(group);

        remaining = false;
        for (var p = 0; p < groups.Count; p++) {
          for (var j = 0; j < groups[p].Count; j++) {
            foreach (var elem in group) groups[p][j].Remove(elem);
            if (!remaining && groups[p][j].Count > 0) remaining = true;
          }
        }

        currentParent = (currentParent + 1) % parents.Length;
      } while (remaining);

      child.SetGroups(childGroup);
      return child;
    }

 public void DiscreteCrossoverApplyTest() {
   TestRandom random = new TestRandom();
   RealVector parent1, parent2, expected, actual;
   ItemArray<RealVector> parents;
   bool exceptionFired;
   // The following test is not based on published examples
   random.Reset();
   random.IntNumbers = new int[] { 0, 0, 1, 0, 1 };
   parent1 = new RealVector(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
   parent2 = new RealVector(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
   parents = new ItemArray<RealVector>(new RealVector[] { parent1, parent2 });
   expected = new RealVector(new double[] { 0.2, 0.2, 0.3, 0.5, 0.8 });
   actual = DiscreteCrossover.Apply(random, parents);
   Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
   // The following test is not based on published examples
   random.Reset();
   random.IntNumbers = new int[] { 0, 0, 1, 0, 1, 0 };
   parent1 = new RealVector(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
   parent2 = new RealVector(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
   parents = new ItemArray<RealVector>(new RealVector[] { parent1, parent2 });
   exceptionFired = false;
   try {
     actual = DiscreteCrossover.Apply(random, parents);
   }
   catch (System.ArgumentException) {
     exceptionFired = true;
   }
   Assert.IsTrue(exceptionFired);
 }

 public override IOperation Apply() {
   ItemArray<IntArray> neighbors = new ItemArray<IntArray>(SwarmSize);
   for (int i = 0; i < SwarmSize; i++) {
     neighbors[i] = new IntArray(new[] { (SwarmSize + i - 1) % SwarmSize, (i + 1) % SwarmSize });
   }
   Neighbors = neighbors;
   return base.Apply();
 }

        public IList<Item> GetItems(Critter critter)
        {
            var container = GetContainer (critter, false);
            if (container == null)
                return new List<Item> (0);

            var itemArray = new ItemArray ();
            container.GetItems (0, itemArray);
            return new List<Item> (itemArray);
        }

 private DoubleArray Average(IRandom random, ItemArray<DoubleArray> parents) {
   int length = parents[0].Length;
   var result = new DoubleArray(length);
   for (int i = 0; i < length; i++) {
     for (int p = 0; p < parents.Length; p++) {
       result[i] += parents[p][i];
     }
     result[i] /= parents.Length;
   }
   return result;
 }

        public void PutItems(Critter critter, IList<Item> items)
        {
            var container = GetContainer (critter, true);
            if (container == null)
                return;

            var itemArray = new ItemArray ();
            itemArray.AddRange (items);

            Global.MoveItems (itemArray, container, 0);
        }

    /// <summary>
    /// Performs a discrete crossover operation on multiple parents.
    /// </summary>
    /// <exception cref="ArgumentException">Thrown when the vectors of the parents are of different length.</exception>
    /// <param name="random">A random number generator.</param>
    /// <param name="parents">An array containing the parents that should be crossed.</param>
    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
    public static RealVector Apply(IRandom random, ItemArray<RealVector> parents) {
      int length = parents[0].Length;

      for (int i = 0; i < parents.Length; i++) {
        if (parents[i].Length != length)
          throw new ArgumentException("DiscreteCrossover: The parents' vectors are of different length.", "parents");
      }

      RealVector result = new RealVector(length);
      for (int i = 0; i < length; i++) {
        result[i] = parents[random.Next(parents.Length)][i];
      }

      return result;
    }

    /// <summary>
    /// Performs a discrete crossover operation of any number of given parents.
    /// </summary>
    /// <exception cref="ArgumentException">Thrown when the vectors of the parents are of different length or when there are less than 2 parents.</exception>
    /// <param name="random">A random number generator.</param>
    /// <param name="parents">The list of parents for the crossover operation.</param>
    /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
    public static IntegerVector Apply(IRandom random, ItemArray<IntegerVector> parents) {
      if (parents.Length < 2) throw new ArgumentException("DiscreteCrossover: There are less than two parents to cross.");
      int length = parents[0].Length;

      for (int i = 0; i < parents.Length; i++) {
        if (parents[i].Length != length)
          throw new ArgumentException("DiscreteCrossover: The parents' vectors are of different length.", "parents");
      }

      var result = new IntegerVector(length);
      for (int i = 0; i < length; i++) {
        result[i] = parents[random.Next(parents.Length)][i];
      }

      return result;
    }

 public override IOperation Apply() {
   ItemArray<IntArray> neighbors = new ItemArray<IntArray>(SwarmSize);
   for (int i = 0; i < SwarmSize; i++) {
     var numbers = Enumerable.Range(0, SwarmSize).ToList();
     numbers.RemoveAt(i);
     var selectedNumbers = new List<int>(NrOfConnections);
     for (int j = 0; j < NrOfConnections && numbers.Count > 0; j++) {
       int index = Random.Next(numbers.Count);
       selectedNumbers.Add(numbers[index]);
       numbers.RemoveAt(index);
     }
     neighbors[i] = new IntArray(selectedNumbers.ToArray());
   }
   Neighbors = neighbors;
   return base.Apply();
 }

    public override IOperation InstrumentedApply() {
      ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
      for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
        IVRPEncoding solution = ParentsParameter.ActualValue[i];

        if (!(solution is PrinsEncoding)) {
          parents[i] = PrinsEncoding.ConvertFrom(solution, ProblemInstance);
        } else {
          parents[i] = solution;
        }
      }
      ParentsParameter.ActualValue = parents;

      ChildParameter.ActualValue =
        Crossover(RandomParameter.ActualValue, parents[0] as PrinsEncoding, parents[1] as PrinsEncoding);

      return base.InstrumentedApply();
    }

    public static LinearLinkage Apply(IRandom random, ItemArray<LinearLinkage> parents) {
      var len = parents[0].Length;
      var child = new LinearLinkage(len);
      var remaining = new SortedSet<int>(Enumerable.Range(0, len));
      do {
        var groups = parents.Select(x => x.GetGroupForward(remaining.Min).Where(y => remaining.Contains(y)).ToList()).ToList();
        var max = groups.Select((v, idx) => Tuple.Create(idx, v.Count)).MaxItems(x => x.Item2).SampleRandom(random).Item1;
        var i = groups[max][0];
        for (var k = 1; k < groups[max].Count; k++) {
          child[i] = groups[max][k];
          remaining.Remove(i);
          i = child[i];
        }
        child[i] = i;
        remaining.Remove(i);
      } while (remaining.Count > 0);

      return child;
    }

    /// <summary>
    /// Performs the average crossover (intermediate recombination) on a list of parents.
    /// </summary>
    /// <exception cref="ArgumentException">Thrown when there is just one parent or when the parent vectors are of different length.</exception>
    /// <remarks>
    /// There can be more than two parents.
    /// </remarks>
    /// <param name="random">The random number generator.</param>
    /// <param name="parents">The list of parents.</param>
    /// <returns>The child vector (average) of the parents.</returns>
    public static RealVector Apply(IRandom random, ItemArray<RealVector> parents) {
      int length = parents[0].Length, parentsCount = parents.Length;
      if (parents.Length < 2) throw new ArgumentException("AverageCrossover: The number of parents is less than 2.", "parents");
      RealVector result = new RealVector(length);
      try {
        double avg;
        for (int i = 0; i < length; i++) {
          avg = 0;
          for (int j = 0; j < parentsCount; j++)
            avg += parents[j][i];
          result[i] = avg / (double)parentsCount;
        }
      }
      catch (IndexOutOfRangeException) {
        throw new ArgumentException("AverageCrossover: The parents' vectors are of different length.", "parents");
      }

      return result;
    }

    public static LinearLinkage Apply(IRandom random, ItemArray<LinearLinkage> parents) {
      var len = parents[0].Length;
      var p = random.Next(parents.Length);
      var child = new LinearLinkage(len);
      var remaining = new SortedSet<int>(Enumerable.Range(0, len));
      do {
        var i = remaining.Min;
        foreach (var g in parents[p].GetGroupForward(i)) {
          if (!remaining.Contains(g)) continue;
          child[i] = g;
          i = g;
          remaining.Remove(g);
        }
        child[i] = i;
        remaining.Remove(i);

        p = (p + 1) % parents.Length;
      } while (remaining.Count > 0);

      return child;
    }

 public static string ShowMatrixOnConsole(ItemArray matrix)
 {
     string x = string.Empty;
     for (int row = Globals.Rows - 1; row >= 0; row--)
     {
         for (int column = 0; column < Globals.Columns; column++)
         {
             if (matrix[row, column] != null)
             {
                 x += matrix[row, column].Value + "|";
             }
             else
             {
                 x += "X" + "|";
             }
         }
         x += Environment.NewLine;
     }
     Debug.Log(x);
     return x;
 }

    public void Initialize()
    {
        if (matrix != null)
            for (int row = 0; row < Globals.Rows; row++)
                for (int column = 0; column < Globals.Columns; column++)
                {
                    if (matrix[row, column] != null && matrix[row, column].GO != null)
                        Destroy(matrix[row, column].GO);
                }

        matrix = new ItemArray();



        //InitArrayWithPremadeData();
        CreateNewItem();
        CreateNewItem();

        score = 0;
        UpdateScore(0);

        gameState = GameState.Playing;
    }

    protected override void Analyze(ItemArray<DoubleArray> qualities, ResultCollection results) {
      ItemArray<IntValue> ranks = RankParameter.ActualValue;

      bool populationLevel = RankParameter.Depth == 1;

      int objectives = qualities[0].Length;
      int frontSize = ranks.Count(x => x.Value == 0);
      ItemArray<IScope> paretoArchive = null;
      if (populationLevel) paretoArchive = new ItemArray<IScope>(frontSize);

      DoubleMatrix front = new DoubleMatrix(frontSize, objectives);
      int counter = 0;
      for (int i = 0; i < ranks.Length; i++) {
        if (ranks[i].Value == 0) {
          for (int k = 0; k < objectives; k++)
            front[counter, k] = qualities[i][k];
          if (populationLevel) {
            paretoArchive[counter] = (IScope)ExecutionContext.Scope.SubScopes[i].Clone();
          }
          counter++;
        }
      }

      front.RowNames = GetRowNames(front);
      front.ColumnNames = GetColumnNames(front);

      if (results.ContainsKey("Pareto Front"))
        results["Pareto Front"].Value = front;
      else results.Add(new Result("Pareto Front", front));

      if (populationLevel) {
        if (results.ContainsKey("Pareto Archive"))
          results["Pareto Archive"].Value = paretoArchive;
        else results.Add(new Result("Pareto Archive", paretoArchive));
      }
    }

    /// <summary>
    /// Performs an average crossover of the two given parent integer vectors.
    /// The average is rounded and mapped to the nearest valid value (e.g. if step size is > 1)
    /// </summary>
    /// <param name="random">A random number generator.</param>
    /// <param name="parents">The parents for crossover.</param>
    /// <param name="bounds">The bounds matrix that contains for each dimension one row with minimum (inclusive), maximum (exclusive), and step size columns.
    /// If the number of rows is smaller than the number of dimensions the matrix is cycled.</param>
    /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
    public static IntegerVector Apply(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
      int length = parents[0].Length, parentsCount = parents.Length;
      if (parents.Length < 2) throw new ArgumentException("RoundedAverageCrossover: The number of parents is less than 2.", "parents");
      if (bounds == null || bounds.Rows < 1 || bounds.Columns < 2) throw new ArgumentException("AverageCrossover: Invalid bounds specified.", "bounds");

      var result = new IntegerVector(length);
      try {
        double avg;
        for (int i = 0; i < length; i++) {
          avg = 0;
          for (int j = 0; j < parentsCount; j++)
            avg += parents[j][i];
          avg /= parentsCount;
          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
          max = FloorFeasible(min, max, step, max - 1);
          result[i] = RoundFeasible(min, max, step, avg);
        }
      } catch (IndexOutOfRangeException) {
        throw new ArgumentException("RoundedAverageCrossover: The parents' vectors are of different length.", "parents");
      }

      return result;
    }

 protected abstract IntegerVector Cross(IRandom random, ItemArray<IntegerVector> parents);

 /// <summary>
 /// Performs a random convex crossover operation for two given parent real vectors.
 /// </summary>
 /// <exception cref="ArgumentException">Thrown if there are not exactly two parents.</exception>
 /// <param name="random">A random number generator.</param>
 /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
 /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
 protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
   if (parents.Length != 2) throw new ArgumentException("ERROR in RandomConvexCrossover: The number of parents is not equal to 2");
   return Apply(random, parents[0], parents[1]);
 }