public static FindMethod ReadSolutionResourceOrFindSolutionEnd(string line, KnapsackProblemDataParser data)
        {
            if (string.IsNullOrWhiteSpace(line))
            {
                return(null);
            }

            var parts            = line.Split('\t').Where(s => !string.IsNullOrWhiteSpace(s)).Select(p => p).ToArray();
            var resourceIndex    = int.Parse(parts[0]) - 1;
            var resourceQuantity = int.Parse(parts[1]);
            var item             = new ItemQuantity(data.Resources[resourceIndex], resourceQuantity);

            data.Solution.Add(item);
            return(ReadSolutionResourceOrFindSolutionEnd);
        }
Пример #2
0
        public void LoadDataTest()
        {
            var problemInfo = KnapsackProblemDataParser.LoadData(@"..\..\Data\exnsd16.ukp");

            Assert.AreEqual(889304, problemInfo.MaxWeight);
            Assert.AreEqual(2000, problemInfo.Resources.Length);
            Assert.AreEqual(2, problemInfo.Solution.Length);

            // nb    idx   w        p
            // 156 x R288, 5687, 0, 6585
            //   1 x R987, 2131, 0, 2420

            var iq1 = new ItemQuantity(problemInfo.Resources[288 - 1], 156);
            var iq2 = new ItemQuantity(problemInfo.Resources[987 - 1], 1);

            CollectionAssert.AreEquivalent(new[] { iq1, iq2 }, problemInfo.Solution);
        }
        private static void Mutate(IList <ItemQuantity> genes, IList <Resource> items, double maxWeight, double maxVolume,
                                   Window window)
        {
            window.Slide();
            var fitness         = GetFitness(genes);
            var remainingWeight = maxWeight - fitness.TotalWeight;
            var remainingVolume = maxVolume - fitness.TotalVolume;

            var removing = genes.Count > 1 && Rand.PercentChance(10);

            if (removing)
            {
                var index1 = Rand.Random.Next(genes.Count);
                var iq1    = genes[index1];
                var item1  = iq1.Item;
                remainingWeight += item1.Weight * iq1.Quantity;
                remainingVolume += item1.Volume * iq1.Quantity;
                genes.RemoveAt(index1);
            }

            var adding = (remainingWeight > 0 || remainingVolume > 0) &&
                         (genes.Count == 0 || (genes.Count < items.Count && Rand.PercentChance(1)));

            if (adding)
            {
                var newGene = Add(genes, items, remainingWeight, remainingVolume);
                if (newGene != null)
                {
                    genes.Add(newGene);
                    return;
                }
            }

            var index = Rand.Random.Next(genes.Count);
            var iq    = genes[index];
            var item  = iq.Item;

            remainingWeight += item.Weight * iq.Quantity;
            remainingVolume += item.Volume * iq.Quantity;

            var changeItem = genes.Count < items.Count && Rand.PercentChance(25);

            if (changeItem)
            {
                var itemIndex = items.IndexOf(iq.Item);
                var start     = Math.Max(1, itemIndex - window.Size);
                var stop      = Math.Min(items.Count - 1, itemIndex + window.Size);
                item = items[Rand.Random.Next(start, stop)];
            }

            var maxQuantity = MaxQuantity(item, remainingWeight, remainingVolume);

            if (maxQuantity > 0)
            {
                var newGene = new ItemQuantity(item, window.Size > 1 ? maxQuantity : Rand.Random.Next(1, maxQuantity));
                genes[index] = newGene;
            }
            else
            {
                genes.RemoveAt(index);
            }
        }