protected override bool IsNewMaximum(DefinitionDto definition, long[,] stateSpace, PositionDto maxPrize, int indexPrice, int indexItem)
{
return(indexPrice > maxPrize.X &&
indexItem == definition.Items.Count - 1 &&
stateSpace[indexPrice, indexItem] > 0 &&
stateSpace[indexPrice, indexItem] <= definition.Capacity);
}
public IEnumerable <BitArray> CorrectGeneration(DefinitionDto definition, List <BitArray> generation)
{
foreach (var fenotyp in generation)
{
while (definition.Capacity < definition.Items.Select((item, itemIndex) => fenotyp[itemIndex] ? item.Weight : 0).Sum())
{
var newMin = new { Index = -1, Value = double.MaxValue };
for (var indexGen = 0; indexGen < definition.Items.Count; indexGen++)
{
var item = definition.Items[indexGen];
var ratio = (double)item.Price / item.Weight;
if (fenotyp[indexGen] && ratio < newMin.Value)
{
newMin = new { Index = indexGen, Value = ratio };
}
}
if (newMin.Index != -1)
{
fenotyp[newMin.Index] = false;
}
}
yield return(fenotyp);
}
}
protected override IEnumerable <BitArray> SelectByCriteria(DefinitionDto definition, Random random, List <BitArray> generation)
{
for (int index = StartCount; index < generation.Count; index++)
{
var tournament = GenerateTournament(random, generation)
.Select((fenotyp, tournamentInde) => new
{
Index = tournamentInde,
Fenotyp = fenotyp,
Score = GetScoreItem(fenotyp, definition)
})
.Where(tuple => tuple.Score.Weight <= definition.Capacity)
.ToList();
if (!tournament.Any())
{
yield return(generation[random.Next(0, generation.Count)]);
continue;
}
var max = tournament.Max(item => item.Score.Price);
if (max != 0)
{
yield return(tournament.First(item => item.Score.Price == max).Fenotyp);
}
}
}
public override (ResultDto, long) Compute(DefinitionDto definition)
{
var random = new Random();
var generation = InitializeGeneration(definition, random);
for (var generationIndex = 0; generationIndex < Generations; generationIndex++)
{
var generationSelection = SelectionStrategy.Select(definition, random, generation).ToList();
var generationNew = CrossStrategy.Cross(definition.Items.Count, random, generationSelection, PopulationSize, CrossoverProbability).ToList();
Mutation(random, generationNew);
generation = generationNew;
//var currentResult = GetResult(definition, generation);
//Debug.WriteLine($"{generationIndex}\t{currentResult.Item1.Price}\t{currentResult.Item1.Weight}");
}
var result = GetResult(definition, generation);
var resultBools = new List <bool>();
for (int index = 0; index < result.Item2.Count; index++)
{
resultBools.Add(result.Item2[index]);
}
return(new ResultDto(definition.Id, result.Item1.Price, resultBools), 0L);
}
private long GetMax(DefinitionDto definition, long[,] stateSpace, int indexValue, int indexItem)
{
var without = GetWithoutSum(stateSpace, indexValue, indexItem);
var with = GetWithSum(stateSpace, indexValue, indexItem, definition.Items[indexItem]);
return(GetTableValue(without, with));
}
public override (ResultDto, long) Compute(DefinitionDto definition)
{
var searchSpace = new RemainderDto[definition.Capacity + 1, definition.Items.Count + 1];
var counter = 0L;
return(ComputeResultRecursively(definition, new List <bool>(), 0, 0, searchSpace, ref counter), counter);
}
public override (ResultDto, long) Compute(DefinitionDto definition)
{
var counter = 0L;
var result = ComputeResultRecursively(definition, new List <bool>(), 0, ref counter);
return(result, counter);
}
private ResultDto ComputeResultRecursively(DefinitionDto definition, List <bool> result, long weight, long price,
RemainderDto[,] searchSpace, ref long counter)
{
if (weight > definition.Capacity)
{
return(null);
}
if (result.Count == definition.Items.Count)
{
counter++;
return(new ResultDto(definition.Id, GetSum(result, definition.Items).Price, result));
}
var cachedResult = searchSpace[weight, result.Count];
if (cachedResult != null)
{
return(new ResultDto(definition.Id,
GetSum(result, definition.Items).Price + cachedResult.Price,
result.Concat(cachedResult.Result).ToList()));
}
var newResult = GetNewResult(definition, result, weight, price, searchSpace, ref counter);
if (newResult != null)
{
CacheRemainder(result, weight, price, searchSpace, newResult);
}
return(newResult);
}
public override (ResultDto, long) Compute(DefinitionDto definition)
{
var ratioItems = definition.Items.Select((item, index) => (index, new RatioItemDto(item.Weight, item.Price))).OrderByDescending(item => item.Item2.Ratio).ToList();
var list = Enumerable.Repeat(false, ratioItems.Count).ToList();
var weightSum = 0L;
var priceSum = 0L;
foreach (var ratioItem in ratioItems)
{
if (weightSum + ratioItem.Item2.Weight <= definition.Capacity)
{
weightSum += ratioItem.Item2.Weight;
priceSum += ratioItem.Item2.Price;
list[ratioItem.Item1] = true;
}
else
{
list[ratioItem.Item1] = false;
}
}
var suitaibleWeight = definition.Items
.Select((item, index) => (index, new RatioItemDto(item.Weight, item.Price)))
.Where(item => item.Item2.Weight <= definition.Capacity).ToList();
var newMax = suitaibleWeight.Max(item => item.Item2.Price);
var mostPrecious = suitaibleWeight.First(item => item.Item2.Price == newMax);
if (mostPrecious.Item2.Price > priceSum)
{
list = Enumerable.Repeat(false, ratioItems.Count).ToList();
list[mostPrecious.Item1] = true;
priceSum = mostPrecious.Item2.Price;
}
return(new ResultDto(definition.Id, priceSum, list), 1);
}
private IEnumerable <long> GetScore(DefinitionDto definition, List <BitArray> generation)
{
foreach (var item in generation.Select(fenotyp => GetScoreItem(fenotyp, definition)))
{
yield return(item.Weight > definition.Capacity
? 0
: item.Price);
}
}
public IEnumerable <BitArray> Select(DefinitionDto definition, Random random, List <BitArray> generation)
{
var correctedGeneration = CorrectionStrategy.CorrectGeneration(definition, generation).ToList();
var elites = SelectElites(definition, correctedGeneration).ToList();
var childrenByScore = SelectByCriteria(definition, random, generation.ToList());
var result = RemoveWeakests(definition, elites.Concat(childrenByScore).ToList());
return(result);
}
private IEnumerable <BitArray> RemoveWeakests(DefinitionDto definition, List <BitArray> generation)
{
return(generation
.Select(fenotyp => new { Fenotyp = fenotyp, Score = GetScoreItem(fenotyp, definition) })
.OrderBy(tuple => tuple.Score.Price)
.Skip(WeakestsCount)
.Select(item => item.Fenotyp)
.ToArray());
}
public static int InsertCategory(string categoryName)
{
DefinitionDto dto = new DefinitionDto();
dto.DefinitionType = CONST.DEFINITION.DEFINITION_TYPE_CATEGORY;
dto.Value1 = categoryName;
int id = DefinitionDao.Insert(dto);
dto.DefinitionId = id;
ListCategories.Add(dto);
return id;
}
public override (ResultDto, long) Compute(DefinitionDto definition)
{
var searchSpaceSize = GetSearchSpaceSize(definition);
var searchSpace = new long[searchSpaceSize, definition.Items.Count];
var referencePoint = GetMaxPricePoint(definition, searchSpaceSize, searchSpace);
var result = ReconstructItems(searchSpace, referencePoint.X, referencePoint.Y, definition);
return(new ResultDto(definition.Id, GetResultValue(result, definition), result), definition.Items.Count *searchSpaceSize);
}
public void ReturnMostValuableItem()
{
var items = new List <ItemDto>
{
new ItemDto(51, 52),
new ItemDto(90, 60),
};
var definition = new DefinitionDto(1, 100, items);
var result = Strategy.Compute(definition);
Assert.AreEqual(items[1].Price, result.Item1.Price);
}
private IEnumerable <BitArray> SelectElites(DefinitionDto definition, List <BitArray> generation)
{
var elites = generation
.Select(fenotyp => new { Fenotyp = fenotyp, Score = GetScoreItem(fenotyp, definition) })
.Where(tuple => tuple.Score.Weight <= definition.Capacity)
.OrderByDescending(tuple => tuple.Score.Price)
.Take(ElitesCount).ToArray();
StartCount = elites.Length - WeakestsCount;
return(elites.Select(item => item.Fenotyp));
}
public static bool UpdateAuthorization(DefinitionDto dto, String name, List<String> FeaturesName)
{
var featureMap = FeatureAttributeService.GetFeaturePropertiesNameMap();
List<int> values = FeaturesName.Select(n => featureMap.GetValue(n)).Where(n => n != 0).ToList();
var authorizationMap = FeatureAttributeService.GetAuthorizationMap();
FeatureAttributeService.UpdateAuthorizationNameMap(name, values);
authorizationMap.Remove(dto.Value1);
authorizationMap[name] = values;
dto.Value1 = name;
dto.Value2 = String.Join(",", values);
return DefinitionDao.Update(dto);
}
public static bool UpdateCategory(DefinitionDto dto)
{
DefinitionDto oldDto = ListCategories.FirstOrDefault(n => n.DefinitionId == dto.DefinitionId);
bool result = DefinitionDao.Update(dto);
if (result)
{
if (oldDto != null)
ListCategories.Remove(oldDto);
ListCategories.Add(dto);
ListCategories.OrderBy(n => n.DefinitionId);
}
return result;
}
public void ReturnSumOfSmallItems()
{
var items = new List <ItemDto>
{
new ItemDto(51, 52),
new ItemDto(50, 50),
new ItemDto(30, 30),
new ItemDto(20, 19),
};
var definition = new DefinitionDto(1, 100, items);
var result = Strategy.Compute(definition);
Assert.AreEqual(items[0].Price + items[2].Price, result.Item1.Price);
}
private IEnumerable <bool> GetPath(long[,] stateSpace, int x, int y, DefinitionDto definition)
{
for (int index = 0; index <= y; index++)
{
var without = GetWithoutSum(stateSpace, x, y - index);
var isWithSum = without != stateSpace[x, y - index];
if (isWithSum)
{
x = x - (int)GetCompositionValue(definition.Items[y - index]);
}
yield return(isWithSum);
}
}
public override (ResultDto, long) Compute(DefinitionDto definition)
{
var sum = 0L;
var maxPrices = Enumerable.Reverse(definition.Items).Select(item =>
{
sum += item.Price;
return(sum);
}).Reverse().ToList();
long max = -1;
int counter = 0;
var result = ComputeResultRecursively(definition, new List <bool>(), maxPrices, ref max, 0, 0, ref counter);
return(result, counter);
}
private List <BitArray> InitializeGeneration(DefinitionDto definition, Random random)
{
var generation = new List <BitArray>();
for (int generationIndex = 0; generationIndex < PopulationSize; generationIndex++)
{
generation.Add(new BitArray(definition.Items.Count));
for (int itemIndex = 0; itemIndex < definition.Items.Count; itemIndex++)
{
generation.Last().Set(itemIndex, random.Next(0, 100) > 50);
}
}
return(generation);
}
private ItemDto GetScoreItem(BitArray fenotyp, DefinitionDto definition)
{
var price = 0L;
var weight = 0L;
for (int index = 0; index < fenotyp.Count; index++)
{
if (fenotyp[index])
{
price += definition.Items[index].Price;
weight += definition.Items[index].Weight;
}
}
return(new ItemDto(weight, price));
}
private ResultDto GetWithResult(DefinitionDto definition, List <bool> result, long weight, long price, RemainderDto[,] searchSpace, ref long counter)
{
var item = definition.Items[result.Count];
var sumWeight = weight + item.Weight;
ResultDto resultWith = null;
if (sumWeight <= definition.Capacity)
{
resultWith = ComputeResultRecursively(definition, new List <bool>(result)
{
true
}, sumWeight, price + item.Price, searchSpace, ref counter);
}
return(resultWith);
}
private ResultDto GetNewResult(DefinitionDto definition, List <bool> result, long weight, long price, RemainderDto[,] searchSpace, ref long counter)
{
var resultWith = GetWithResult(definition, result, weight, price, searchSpace, ref counter);
var resultWithout = ComputeResultRecursively(definition, new List <bool>(result)
{
false
}, weight, price, searchSpace, ref counter);
var returnValue = resultWithout;
if (IsWithBetter(resultWith, resultWithout))
{
returnValue = resultWith;
}
return(returnValue);
}
private (ItemDto, BitArray) GetResult(DefinitionDto definition, List <BitArray> generation)
{
var candidates = generation
.Select(generationItem => (GetScoreItem(generationItem, definition), generationItem))
.Where(item => item.Item1.Weight <= definition.Capacity)
.ToList();
if (!candidates.Any())
{
return(new ItemDto(0, 0), new BitArray(definition.Items.Count));
}
var maxPrice = candidates.Max(item => item.Item1.Price);
var result = candidates.First(item => item.Item1.Price == maxPrice);
return(result);
}
public static DefinitionDto InsertAuthorization(String name, List<String> FeaturesName)
{
var featureMap = FeatureAttributeService.GetFeaturePropertiesNameMap();
List<int> values = FeaturesName.Select(n => featureMap.GetValue(n)).Where(n => n != 0).ToList();
DefinitionDto dto = new DefinitionDto();
dto.DefinitionType = CONST.DEFINITION.DEFINITION_TYPE_AUTHORIZATION;
dto.Value1 = name;
dto.Value2 = String.Join(",", values);
int id = DefinitionDao.Insert(dto);
dto.DefinitionId = id;
var authorizationMap = FeatureAttributeService.GetAuthorizationMap();
authorizationMap[name] = values;
FeatureAttributeService.UpdateAuthorizationNameMap(name, values);
return dto;
}
protected PositionDto GetMaxPricePoint(DefinitionDto definition, long searchSpaceSiz, long[,] stateSpace)
{
var referencePoint = new PositionDto(0, 0, 0);
for (var indexValue = 0; indexValue < searchSpaceSiz; indexValue++)
{
for (var indexItem = 0; indexItem < definition.Items.Count; indexItem++)
{
stateSpace[indexValue, indexItem] = GetMax(definition, stateSpace, indexValue, indexItem);
if (IsNewMaximum(definition, stateSpace, referencePoint, indexValue, indexItem))
{
referencePoint = new PositionDto(indexValue, indexItem, stateSpace[indexValue, indexItem]);
}
}
}
return(referencePoint);
}
protected override IEnumerable <BitArray> SelectByCriteria(DefinitionDto definition, Random random, List <BitArray> generation)
{
var score = GetScore(definition, generation).ToList();
var sumScore = score.Sum();
for (var newGenerationIndex = StartCount; newGenerationIndex < generation.Count; newGenerationIndex++)
{
var randomValue = random.Next(0, (int)sumScore);
var sumValue = 0L;
var counter = -1;
do
{
counter++;
sumValue += score[counter];
} while (sumValue <= randomValue);
yield return(generation[counter]);
}
}
public override (ResultDto, long) Compute(DefinitionDto definition)
{
var maxValue = Math.Pow(2, definition.Items.Count);
var maxPrice = 0L;
var bestSeed = 0L;
for (long index = 0; index < maxValue; index++)
{
var sumItem = GetSum(index, definition.Items);
if (sumItem[0] <= definition.Capacity && sumItem[1] > maxPrice)
{
maxPrice = sumItem[1];
bestSeed = index;
}
}
return(new ResultDto(definition.Id, maxPrice, GetItems(bestSeed, definition.Items.Count)), (long)maxValue);
}
