private bool CheckForConflicts(ISensationSnapshot snapshot)
{
foreach (IActionMemory actionMemory in ActionMemoryDictonary.Values)
{
var percentageForDifferenceByActualSnapshot = actionMemory.CheckForDifferencePattern(snapshot);
double posibilityForDifference = Math.Min(actionMemory.NegProcentualNoDifference, percentageForDifferenceByActualSnapshot);
if (posibilityForDifference > 0.0)
{
var positivePartialSnapshotCompression = actionMemory.GetMaxPositivePartialSnapshotCompression(snapshot);
var negativePartialSnapshotCompression = actionMemory.GetMaxNegativePartialSnapshotCompression(snapshot);
if (positivePartialSnapshotCompression != null && negativePartialSnapshotCompression != null)
{
var positivPercentage = actionMemory.GetPositiveFeedbackPercentage(positivePartialSnapshotCompression);
var negativePercentage = actionMemory.GetNegativeFeedbackPercentage(negativePartialSnapshotCompression);
if (positivPercentage + negativePercentage > 1.5)
{
RaiseConflictDetected();
return(true);
}
}
}
}
return(false);
}
public double CheckForNegativeFeedback(ISensationSnapshot snapshot)
{
double result = 0.0;
IEnumerable <FieldOfVisionTypes> fieldOfVisions = NegativeDictPartialSnapshotCompressions.Keys.Select(e => e.FieldOfVision).Distinct();
var dictDirectionToSnapshot = new Dictionary <Tuple <FieldOfVisionTypes, DirectionTypes>, ISensationSnapshot>();
var baseDirection = Action.Direction;
foreach (FieldOfVisionTypes fieldOfVision in fieldOfVisions)
{
var basePartialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, baseDirection);
dictDirectionToSnapshot.Add(new Tuple <FieldOfVisionTypes, DirectionTypes>(fieldOfVision, baseDirection), basePartialSnapshot);
foreach (var childDirection in basePartialSnapshot.SensoryPatterns.Select(p => p.DirectionType))
{
if (childDirection != baseDirection)
{
var childPartialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, childDirection);
dictDirectionToSnapshot.Add(new Tuple <FieldOfVisionTypes, DirectionTypes>(fieldOfVision, childDirection), childPartialSnapshot);
}
}
}
foreach (IPartialSnapshotCompression partialSnapshotCompression in NegativeDictPartialSnapshotCompressions.Keys)
{
if (PartialSnapshotCompression.Contains(dictDirectionToSnapshot, partialSnapshotCompression))
{
result = Math.Max(result, GetNegativeFeedbackPercentage(partialSnapshotCompression));
}
}
return(result);
}
static public List <IPartialSnapshotCompression> NewInstancesOfUnitCountTreeCompression(Dictionary <ISensoryUnit, int> unitCountDictonary, ISensationSnapshot partialSnapshot, ISensationSnapshot snapShot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
var result = new List <IPartialSnapshotCompression>();
// Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry in unitCountDictonary)
{
var patterns = partialSnapshot.SensoryPatterns.Where(p => p.SensoryUnits.Contains(unitCountEntry.Key)).ToList();
foreach (ISensoryPattern pattern in patterns)
{
ISensationSnapshot partialSnapshot2 = SensationSnapshot.ExtractSnapshot(snapShot, fieldOfVision, PuzzleReferee.Addition(direction, pattern.DirectionType));
var unitCountDictonary2 = SensationSnapshot.CountUnits(partialSnapshot2);
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry2 in unitCountDictonary2)
{
if (unitCountEntry2.Key.Equals(unitCountEntry.Key) && unitCountEntry2.Value <= 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
var unitCompression = new PartialSnapshotCompression(CompressionTypes.UnitCountTree, fieldOfVision, DirectionTypes.Undefined);
var node = new PartialSnapshotCompressionNode(unitCountEntry.Key);
for (int i = 0; i < unitCountEntry2.Value; i++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitCountEntry2.Key));
}
unitCompression.ChildNodes.Add(node);
if (!result.Contains(unitCompression))
{
result.Add(unitCompression);
}
}
}
}
return(result);
}
static public List <IPartialSnapshotCompression> NewInstances(ISensationSnapshot snapshot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction, CompressionTypes maximumCompression)
{
var result = new List <IPartialSnapshotCompression>();
ISensationSnapshot partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, direction);
// Single units for fieldOfVision.Single and fieldOfVision.ThreeByThree allows to find 0 and 9
var unitCountDictonary = SensationSnapshot.CountUnits(partialSnapshot);
result.AddRange(NewInstancesOfUnitCompression(unitCountDictonary, fieldOfVision));
if (maximumCompression >= CompressionTypes.UnitSimpleTree)
{
// Find 1 and 8 if a field around is marked as Filled or Empty (two pattern with single unit) --> fieldOfVision.ThreeByThree
result.AddRange(NewInstancesOfUnitSimpleTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction));
}
if (maximumCompression >= CompressionTypes.UnitCountTree)
{
// ToDo: Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree
result.AddRange(NewInstancesOfUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction));
}
if (maximumCompression >= CompressionTypes.MultiUnitCountTree)
{
// ToDo: Find 1-5 fields at the boarder with combination of Empty and Outside --> fieldOfVision.ThreeByThree
result.AddRange(NewInstancesOfMultiUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction));
}
return(result);
}
public SensationResult(ISensationSnapshot before, IPuzzleAction action, ISensationSnapshot after, long feedbackValue, bool saveable = true)
{
Id = -1;
SnapshotBefore = before;
Action = action;
SnapshotAfter = after;
FeedbackValue = feedbackValue;
}
public void Experience(FieldOfVisionTypes fieldOfVisionType, PuzzleBoard partialBoard)
{
Point centerPos = new Point();
switch (fieldOfVisionType)
{
case FieldOfVisionTypes.Single:
centerPos = new Point(0, 0);
break;
case FieldOfVisionTypes.ThreeByThree:
centerPos = new Point(1, 1);
break;
case FieldOfVisionTypes.FiveByFive:
centerPos = new Point(2, 2);
break;
}
List <ISensoryPattern> sensoryPatterns = new List <ISensoryPattern>();
for (int y = 0; y < partialBoard.Rows; y++)
{
for (int x = 0; x < partialBoard.Columns; x++)
{
Point pos = new Point(x, y);
DirectionTypes directionType = PuzzleReferee.ConvertToDirectionType(new Point(pos.X - centerPos.X, pos.Y - centerPos.Y));
PuzzleCellStateTypes state = partialBoard.GetState(pos);
int value = partialBoard.GetValue(pos);
string valueString = value >= 0 ? value.ToString() : " ";
if (state != PuzzleCellStateTypes.Undefined)
{
ISensoryUnit sensoryUnitState = GetOrCreateSensoryUnit(SensoryTypes.FieldState, state.ToString());
ISensoryUnit sensoryUnitValue = GetOrCreateSensoryUnit(SensoryTypes.FieldValue, valueString);
List <ISensoryUnit> sensoryUnits = new List <ISensoryUnit>();
sensoryUnits.Add(sensoryUnitState);
sensoryUnits.Add(sensoryUnitValue);
ISensoryPattern sensoryPattern = new SensoryPattern(directionType, sensoryUnits);
if (_kownSensoryPatterns.Contains(sensoryPattern))
{
sensoryPattern = _kownSensoryPatterns[_kownSensoryPatterns.IndexOf(sensoryPattern)];
}
else
{
_kownSensoryPatterns.Add(sensoryPattern);
_kownSensoryPatterns.Sort();
}
sensoryPatterns.Add(sensoryPattern);
}
}
}
_lastSensationSnapshot = new SensationSnapshot(DirectionTypes.Center, fieldOfVisionType, sensoryPatterns, IS_SAVEABLE_SNAPSHOT);
}
static public List <IPartialSnapshotCompression> NewInstancesOfMultiUnitCountTreeCompression(ISensationSnapshot snapshot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
var result = new List <IPartialSnapshotCompression>();
ISensationSnapshot partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, direction);
var unitCountDictonary = SensationSnapshot.CountUnits(partialSnapshot);
result.AddRange(NewInstancesOfMultiUnitCountTreeCompression(unitCountDictonary, partialSnapshot, snapshot, fieldOfVision, direction));
return(result);
}
public IActionMemoryQuartet FindBestActionMemoryQuartet(Point position)
{
Position = position;
// Look around at special position
RaiseExperienceWanted();
ISensationSnapshot sensationSnapshotBeforeAction = _lastSensationSnapshot;
IActionMemoryQuartet bestActionMemoryQuartet = GetBestActionMemoryQuartet(position, sensationSnapshotBeforeAction);
return(bestActionMemoryQuartet);
}
public IPartialSnapshotCompression GetMaxNegativePartialSnapshotCompression(ISensationSnapshot snapshot)
{
IPartialSnapshotCompression result = null;
double maxPercentage = 0.0;
foreach (KeyValuePair <IPartialSnapshotCompression, IFeedbackCounter> entry in NegativeDictPartialSnapshotCompressions.Where(p => p.Value.PositiveCount > 0))
{
// ToDo: Check in given snapshot if partialSnapshotCompression included.
}
return(result);
}
public void TryToLearn()
{
ActionFeedback = 0;
// Zuerst mal die Lage erkunden
RaiseExperienceWanted();
ISensationSnapshot sensationSnapshotBeforeAction = _lastSensationSnapshot;
if (CheckForConflicts(sensationSnapshotBeforeAction))
{
return;
}
// Nun wird entschieden welche Aktion ausgeführt werden soll
IPuzzleAction action = GetDecisionByMemory(sensationSnapshotBeforeAction);
if (action == null)
{
}
// Nun eine Aktion ausführen und Reaktion erkennen
RaiseActionWanted(action);
int actionFeedback = ActionFeedback;
// Wieder die Lage ermitteln und mit dem Zustand zuvor vergleichen
RaiseExperienceWanted();
ISensationSnapshot sensationSnapshotAfterAction = _lastSensationSnapshot;
var difference = SensationSnapshot.GetDifferencePatterns(sensationSnapshotBeforeAction, sensationSnapshotAfterAction);
IActionMemory actionMemory = ActionMemoryDictonary[action];
bool isDifferent = difference.SensoryPatterns.Any();
actionMemory.RememberDifference(isDifferent, sensationSnapshotBeforeAction);
if (isDifferent)
{
if (actionFeedback != 0)
{
if (actionFeedback < 0)
{
Console.WriteLine("Error occurred!");
}
actionMemory.RememberFeedback(actionFeedback, sensationSnapshotBeforeAction);
actionMemory.RefreshOverallNegativePscList(ActionMemoryDictonary.Values.ToList());
}
_actionFeedbackHistory.Add(actionFeedback);
while (_actionFeedbackHistory.Count > MAX_ACTION_FEEDBACK_HISTORY_COUNT)
{
_actionFeedbackHistory.RemoveAt(0);
}
}
}
static public ISensationSnapshot GetDifferencePatterns(ISensationSnapshot a, ISensationSnapshot b)
{
var result = new SensationSnapshot(a.Direction, a.FieldOfVision, a.SensoryPatterns, false);
foreach (ISensoryPattern sensoryPattern in b.SensoryPatterns)
{
if (a.SensoryPatterns.Contains(sensoryPattern))
{
result.SensoryPatterns.Remove(sensoryPattern);
}
}
result.SensoryPatterns.Sort();
return(result);
}
private IActionMemoryQuartet GetBestActionMemoryQuartet(Point position, ISensationSnapshot snapshot)
{
// ToDo JK: Find all possible actions for that snapshot
Dictionary <IPuzzleAction, IActionMemoryQuartet> rangeOfActions = GetRangeOfActions(snapshot, 0.0);
if (rangeOfActions.Any())
{
// ToDo JK: Use FUZZY to choose the best action???
var orderdByStepSizeActions = rangeOfActions.OrderBy(s => s.Value.StepSize);
KeyValuePair <IPuzzleAction, IActionMemoryQuartet> bestEntry = orderdByStepSizeActions.LastOrDefault();
return(bestEntry.Value);
}
return(null);
}
private List <ISensoryPattern> SplitPattern(ISensationSnapshot snapShot, int unitSize)
{
var result = new List <ISensoryPattern>();
foreach (var pattern in snapShot.SensoryPatterns)
{
foreach (var splittedPattern in SensoryPattern.Split(pattern))
{
if (splittedPattern.SensoryUnits.Count == unitSize && !result.Contains(splittedPattern))
{
result.Add(splittedPattern);
}
}
}
return(result);
}
private List <ISensoryUnit> SplitUnits(ISensationSnapshot snapShot)
{
var result = new List <ISensoryUnit>();
foreach (var pattern in snapShot.SensoryPatterns)
{
foreach (var unit in SplitUnits(pattern))
{
if (!result.Contains(unit))
{
result.Add(unit);
}
}
}
return(result);
}
static public Dictionary <ISensoryUnit, int> CountUnits(ISensationSnapshot snapshot)
{
var result = new Dictionary <ISensoryUnit, int>();
foreach (var pattern in snapshot.SensoryPatterns)
{
foreach (var unit in pattern.SensoryUnits)
{
if (!result.ContainsKey(unit))
{
result.Add(unit, 0);
}
result[unit]++;
}
}
return(result);
}
static public bool Contains(Dictionary <Tuple <FieldOfVisionTypes, DirectionTypes>, ISensationSnapshot> dictDirectionToSnapshot, IPartialSnapshotCompression partialSnapshotCompression)
{
ISensoryUnit baseUnit = partialSnapshotCompression.ChildNodes.FirstOrDefault().Unit;
var baseDirection = DirectionTypes.Center;
FieldOfVisionTypes fieldOfVision = partialSnapshotCompression.FieldOfVision;
ISensationSnapshot basePartialSnapshot = dictDirectionToSnapshot[new Tuple <FieldOfVisionTypes, DirectionTypes>(fieldOfVision, baseDirection)];
switch (partialSnapshotCompression.CompressionType)
{
case CompressionTypes.Unit:
return(basePartialSnapshot.SensoryPatterns.Any(p => p.SensoryUnits.Contains(baseUnit)));
case CompressionTypes.UnitSimpleTree:
case CompressionTypes.UnitCountTree:
case CompressionTypes.MultiUnitCountTree:
IEnumerable <ISensoryPattern> patterns = basePartialSnapshot.SensoryPatterns.Where(p => p.SensoryUnits.Contains(baseUnit));
IEnumerable <ISensoryUnit> childUnits = partialSnapshotCompression.ChildNodes.FirstOrDefault().ChildNodes.Select(p => p.Unit);
foreach (var direction in patterns.Select(p => p.DirectionType))
{
var childPartialSnapshot = dictDirectionToSnapshot[new Tuple <FieldOfVisionTypes, DirectionTypes>(fieldOfVision, direction)];
bool areChildNodesIncluded = false;
foreach (var childUnit in childUnits.Distinct())
{
var minCount = childUnits.Count(u => u.Equals(childUnit));
if (baseUnit.Equals(childUnit))
{
minCount++;
}
areChildNodesIncluded = childPartialSnapshot.SensoryPatterns.Count(p => p.SensoryUnits.Contains(childUnit)) >= minCount;
if (!areChildNodesIncluded)
{
break;
}
}
if (areChildNodesIncluded)
{
return(true);
}
}
break;
default:
throw new NotImplementedException();
}
return(false);
}
static public ISensationSnapshot ExtractSnapshot(ISensationSnapshot sensationSnapshot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
if (fieldOfVision == FieldOfVisionTypes.Single)
{
Point centerPos = PuzzleReferee.ConvertToPoint(direction);
var resultPatterns = new List <ISensoryPattern>();
foreach (ISensoryPattern pattern in sensationSnapshot.SensoryPatterns)
{
if (direction.Equals(pattern.DirectionType))
{
var newPattern = new SensoryPattern(pattern);
Point oldPatternPos = PuzzleReferee.ConvertToPoint(newPattern.DirectionType);
var newPatternPos = new Point(oldPatternPos.X - centerPos.X, oldPatternPos.Y - centerPos.Y);
newPattern.DirectionType = PuzzleReferee.ConvertToDirectionType(newPatternPos);
resultPatterns.Add(newPattern);
}
}
return(new SensationSnapshot(PuzzleReferee.ConvertToDirectionType(centerPos), FieldOfVisionTypes.Single, resultPatterns, false));
}
else if (fieldOfVision == FieldOfVisionTypes.ThreeByThree)
{
Point centerPos = PuzzleReferee.ConvertToPoint(direction);
List <DirectionTypes> fieldOfVisionDirections = new List <DirectionTypes>();
for (int sy = -1; sy < 2; sy++)
{
for (int sx = -1; sx < 2; sx++)
{
fieldOfVisionDirections.Add(PuzzleReferee.ConvertToDirectionType(new Point(sx + centerPos.X, sy + centerPos.Y)));
}
}
var resultPatterns = new List <ISensoryPattern>();
foreach (ISensoryPattern pattern in sensationSnapshot.SensoryPatterns)
{
if (fieldOfVisionDirections.Contains(pattern.DirectionType))
{
var newPattern = new SensoryPattern(pattern);
Point oldPatternPos = PuzzleReferee.ConvertToPoint(newPattern.DirectionType);
var newPatternPos = new Point(oldPatternPos.X - centerPos.X, oldPatternPos.Y - centerPos.Y);
newPattern.DirectionType = PuzzleReferee.ConvertToDirectionType(newPatternPos);
resultPatterns.Add(newPattern);
}
}
return(new SensationSnapshot(PuzzleReferee.ConvertToDirectionType(centerPos), FieldOfVisionTypes.ThreeByThree, resultPatterns, false));
}
throw new NotImplementedException();
}
public double CheckForDifferencePattern(ISensationSnapshot snapshot)
{
List <FieldOfVisionTypes> fieldOfVisions = GetFieldOfVisionsForDifferences();
double result = 1.0;
foreach (var fieldOfVision in fieldOfVisions)
{
var partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, Action.Direction);
foreach (var pattern in SplitPattern(partialSnapshot, 1))
{
if (GetNoDifferencePattern(fieldOfVision).ContainsKey(pattern))
{
double posibilityForDifference = 1.0 - (double)GetNoDifferencePattern(fieldOfVision)[pattern] / MINIMUM_PATTERN_NO_DIFFERENT_COUNT;
result = Math.Min(result, posibilityForDifference);
}
}
}
return(result);
}
private IPuzzleAction GetDecisionByMemory(ISensationSnapshot snapshot)
{
// FUZZY-Logic: Entscheiden welcher Modus aktiv sein sollte
if (_actionFeedbackHistory.Any())
{
var percentagePositive = (double)_actionFeedbackHistory.Count(e => e > 0) / _actionFeedbackHistory.Count;
var percentageNegative = (double)_actionFeedbackHistory.Count(e => e < 0) / _actionFeedbackHistory.Count;
var percentageNeutral = (double)_actionFeedbackHistory.Count(e => e == 0) / _actionFeedbackHistory.Count;
_fillAPixFuzzyLogic.SetValue <FuzzyPositiveHistoryTypes>(percentagePositive);
_fillAPixFuzzyLogic.SetValue <FuzzyErrorHistoryTypes>(percentageNegative);
_fillAPixFuzzyLogic.SetValue <FuzzyNeutralHistoryTypes>(percentageNeutral);
_fillAPixFuzzyLogic.CalculateOutput();
double learningDegree = _fillAPixFuzzyLogic.GetDegree(FuzzyInteractionModeTypes.Learning);
double solvingDegree = _fillAPixFuzzyLogic.GetDegree(FuzzyInteractionModeTypes.Solving);
double hundredPercent = learningDegree + solvingDegree;
if (hundredPercent > 0)
{
PercentageSolving = solvingDegree / hundredPercent * 100;
}
}
double positionInRangeByRandom = _random.NextDouble();
Dictionary <IPuzzleAction, IActionMemoryQuartet> rangeOfActions = GetRangeOfActions(snapshot, RiskFactor);
foreach (var rangeOfAction in rangeOfActions)
{
var stepSize = rangeOfAction.Value.StepSize;
if (stepSize >= positionInRangeByRandom)
{
return(rangeOfAction.Key);
}
positionInRangeByRandom -= stepSize;
}
return(null);
}
private Dictionary <IPuzzleAction, IActionMemoryQuartet> GetRangeOfActions(ISensationSnapshot snapshot, double riskFactor)
{
double sumeOfPosibilityForDifference = 0.0;
double sumeOfPosibilityForPositiveFeedback = 0.0;
double sumeOfPosibilityForNegativeFeedback = 0.0;
Dictionary <IPuzzleAction, double> posibilityForDifferencesByAction = new Dictionary <IPuzzleAction, double>();
Dictionary <IPuzzleAction, double> posibilityForPositiveFeedbackByAction = new Dictionary <IPuzzleAction, double>();
Dictionary <IPuzzleAction, double> posibilityForNegativeFeedbackByAction = new Dictionary <IPuzzleAction, double>();
foreach (IActionMemory actionMemory in ActionMemoryDictonary.Values)
{
var percentageForDifferenceByActualSnapshot = actionMemory.CheckForDifferencePattern(snapshot);
double posibilityForDifference = Math.Min(actionMemory.NegProcentualNoDifference, percentageForDifferenceByActualSnapshot);
sumeOfPosibilityForDifference += posibilityForDifference;
posibilityForDifferencesByAction.Add(actionMemory.Action, posibilityForDifference);
if (posibilityForDifference > 0.0)
{
//var positivePartialSnapshotCompression = actionMemory.GetMaxPositivePartialSnapshotCompression(snapshot);
//var negativePartialSnapshotCompression = actionMemory.GetMaxNegativePartialSnapshotCompression(snapshot);
//if (positivePartialSnapshotCompression != null && negativePartialSnapshotCompression != null)
//{
// var positivPercentage = actionMemory.GetPositiveFeedbackPercentage(positivePartialSnapshotCompression);
// var negativePercentage = actionMemory.GetNegativeFeedbackPercentage(negativePartialSnapshotCompression);
// if (positivPercentage + negativePercentage > 1.5)
// {
// RaiseConflictDetected();
// }
//}
double positiveFeedback = actionMemory.CheckForPositiveFeedback(snapshot);
positiveFeedback = Math.Max(actionMemory.NegProcentualNegativeFeedback, positiveFeedback);
double negativeFeedback = actionMemory.CheckForNegativeFeedback(snapshot);
if (positiveFeedback >= (1.0 - riskFactor) && positiveFeedback > negativeFeedback && negativeFeedback < riskFactor)
{
negativeFeedback = 0.0;
}
else if (negativeFeedback > positiveFeedback && negativeFeedback >= riskFactor)
{
positiveFeedback = 0.0;
}
if (positiveFeedback < 1.0 - riskFactor)
{
positiveFeedback = 0.0;
if (actionMemory.NegativeFeedbackCount > 0)
{
negativeFeedback = Math.Max(1.0 - actionMemory.NegProcentualNegativeFeedback, negativeFeedback);
}
}
if (negativeFeedback > riskFactor)
{
negativeFeedback = 1.0;
}
sumeOfPosibilityForPositiveFeedback += positiveFeedback;
posibilityForPositiveFeedbackByAction.Add(actionMemory.Action, positiveFeedback);
sumeOfPosibilityForNegativeFeedback += negativeFeedback;
posibilityForNegativeFeedbackByAction.Add(actionMemory.Action, negativeFeedback);
}
}
var rangeOfActions = new Dictionary <IPuzzleAction, IActionMemoryQuartet>();
double rangeSize = 0.0;
double positvieMultiplicator = 1.0 + (1.0 - riskFactor) * 100;
foreach (IActionMemory actionMemory in ActionMemoryDictonary.Values)
{
IPuzzleAction action = actionMemory.Action;
IActionMemoryQuartet memoryQuartet = new ActionMemoryQuartet(action);
if (posibilityForDifferencesByAction.ContainsKey(action))
{
memoryQuartet.Difference = posibilityForDifferencesByAction[action];
}
if (posibilityForPositiveFeedbackByAction.ContainsKey(action))
{
memoryQuartet.PositiveFeedback = posibilityForPositiveFeedbackByAction[action];
}
if (posibilityForNegativeFeedbackByAction.ContainsKey(action))
{
memoryQuartet.NegativeFeedback = posibilityForNegativeFeedbackByAction[action];
}
if (memoryQuartet.PositiveFeedback >= 1.0 && memoryQuartet.NegativeFeedback <= 0.0)
{
memoryQuartet.PositiveFeedback *= positvieMultiplicator;
}
var stepSize = memoryQuartet.StepSize;
if (stepSize > 0.0)
{
rangeSize += stepSize;
rangeOfActions.Add(action, memoryQuartet);
}
}
if (!rangeOfActions.Any())
{
rangeSize = sumeOfPosibilityForDifference;
foreach (IActionMemory actionMemory in ActionMemoryDictonary.Values)
{
IActionMemoryQuartet memoryQuartet = new ActionMemoryQuartet(actionMemory.Action);
memoryQuartet.Difference = posibilityForDifferencesByAction[actionMemory.Action];
rangeOfActions.Add(actionMemory.Action, memoryQuartet);
}
}
foreach (var sizeInRange in rangeOfActions)
{
sizeInRange.Value.RangeSize = rangeSize;
}
return(rangeOfActions);
}
static public List <IPartialSnapshotCompression> NewInstancesOfMultiUnitCountTreeCompression(Dictionary <ISensoryUnit, int> unitCountDictonary, ISensationSnapshot partialSnapshot, ISensationSnapshot snapShot, FieldOfVisionTypes fieldOfVision, DirectionTypes direction)
{
var result = new List <IPartialSnapshotCompression>();
// Find 2-7 if 2-7 fields around are marked as Filled or Empty (two pattern with counted units) --> fieldOfVision.ThreeByThree
foreach (KeyValuePair <ISensoryUnit, int> unitCountEntry in unitCountDictonary)
{
var patterns = partialSnapshot.SensoryPatterns.Where(p => p.SensoryUnits.Contains(unitCountEntry.Key)).ToList();
foreach (ISensoryPattern pattern in patterns)
{
ISensationSnapshot partialSnapshot2 = SensationSnapshot.ExtractSnapshot(snapShot, fieldOfVision, PuzzleReferee.Addition(direction, pattern.DirectionType));
var unitCountDictonary2 = SensationSnapshot.CountUnits(partialSnapshot2);
List <ISensoryUnit> sortedUnits = new List <ISensoryUnit>();
sortedUnits.AddRange(unitCountDictonary2.Keys.ToList());
sortedUnits.Sort();
for (int i = 0; i < sortedUnits.Count - 1; i++)
{
var unitKey1 = sortedUnits[i];
int unitValue1 = unitCountDictonary2[unitKey1];
if (unitKey1.Equals(unitCountEntry.Key))
{
unitValue1--;
if (unitValue1 < 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
}
for (int j = i + 1; j < sortedUnits.Count; j++)
{
var unitKey2 = sortedUnits[j];
var unitValue2 = unitCountDictonary2[unitKey2];
if (unitKey2.Equals(unitCountEntry.Key))
{
unitValue2--;
if (unitValue2 < 1)
{
// If the same unit found one time in the field of view, it must be the exact same one.
continue;
}
}
var unitCompression = new PartialSnapshotCompression(CompressionTypes.MultiUnitCountTree, fieldOfVision, DirectionTypes.Undefined);
var node = new PartialSnapshotCompressionNode(unitCountEntry.Key);
for (int q = 0; q < unitValue1; q++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitKey1));
}
for (int q = 0; q < unitValue2; q++)
{
node.ChildNodes.Add(new PartialSnapshotCompressionNode(unitKey2));
}
unitCompression.ChildNodes.Add(node);
if (!result.Contains(unitCompression))
{
result.Add(unitCompression);
}
}
}
}
}
return(result);
}
public void RememberFeedback(int feedbackValue, ISensationSnapshot snapshot)
{
FieldOfVisionTypes fieldOfVision = GetFieldOfVisionsForFeedback().Last();
List <IPartialSnapshotCompression> partialSnapshotCompressions = PartialSnapshotCompression.NewInstances(snapshot, fieldOfVision, Action.Direction, GetMaximumCompression());
if (feedbackValue < 0)
{
NegativeFeedbackCount++;
// ########### PartialSnapshotCompression #############
foreach (IPartialSnapshotCompression pscEntry in partialSnapshotCompressions)
{
if (PositveDictPartialSnapshotCompressions.ContainsKey(pscEntry))
{
PositveDictPartialSnapshotCompressions.Remove(pscEntry);
}
bool containingEntryExists = false;
foreach (IPartialSnapshotCompression negativePsc in NegativeDictPartialSnapshotCompressions.Keys)
{
if (GetNegativeFeedbackPercentage(negativePsc) >= 0.99 && pscEntry.Contains(negativePsc))
{
containingEntryExists = true;
break;
}
}
if (containingEntryExists)
{
continue;
}
if (!NegativeDictPartialSnapshotCompressions.ContainsKey(pscEntry))
{
NegativeDictPartialSnapshotCompressions.Add(pscEntry, new FeedbackCounter(PositiveFeedbackCount, NegativeFeedbackCount));
}
else if (GetNegativeFeedbackPercentage(pscEntry) >= 0.99)
{
var entriesToRemove = new List <IPartialSnapshotCompression>();
foreach (IPartialSnapshotCompression existingPsc in NegativeDictPartialSnapshotCompressions.Keys.Where(p => p.CompressionType != pscEntry.CompressionType))
{
if (existingPsc.Contains(pscEntry))
{
entriesToRemove.Add(existingPsc);
}
}
if (entriesToRemove.Any())
{
foreach (IPartialSnapshotCompression existingPsc in entriesToRemove)
{
NegativeDictPartialSnapshotCompressions.Remove(existingPsc);
}
}
}
else
{
NegativeDictPartialSnapshotCompressions[pscEntry].NegativeLifeCycleStamp = NegativeFeedbackCount;
NegativeDictPartialSnapshotCompressions[pscEntry].NegativeCount++;
}
}
}
else if (feedbackValue > 0)
{
PositiveFeedbackCount++;
// ########### PartialSnapshotCompression #############
foreach (IPartialSnapshotCompression pscEntry in partialSnapshotCompressions)
{
if (NegativeDictPartialSnapshotCompressions.ContainsKey(pscEntry))
{
NegativeDictPartialSnapshotCompressions.Remove(pscEntry);
}
if (OverallNegativePartialSnapshotCompressions.Contains(pscEntry))
{
if (!PositveDictPartialSnapshotCompressions.ContainsKey(pscEntry))
{
PositveDictPartialSnapshotCompressions.Add(pscEntry, new FeedbackCounter(PositiveFeedbackCount, NegativeFeedbackCount));
}
else
{
PositveDictPartialSnapshotCompressions[pscEntry].PositiveLifeCycleStamp = PositiveFeedbackCount;
PositveDictPartialSnapshotCompressions[pscEntry].PositiveCount++;
}
}
}
}
if (feedbackValue != 0)
{
List <IPartialSnapshotCompression> sortedKeys = NegativeDictPartialSnapshotCompressions.Keys.ToList();
sortedKeys.Sort();
var keysToRemove = new List <IPartialSnapshotCompression>();
for (int i = 0; i < sortedKeys.Count - 1; i++)
{
for (int j = i + 1; j < sortedKeys.Count; j++)
{
var a = sortedKeys[i];
var b = sortedKeys[j];
if (a.Contains(b) && NegativeDictPartialSnapshotCompressions[a].NegativeCount < NegativeDictPartialSnapshotCompressions[b].NegativeCount)
{
keysToRemove.Add(a);
}
else if (b.Contains(a) && NegativeDictPartialSnapshotCompressions[b].NegativeCount < NegativeDictPartialSnapshotCompressions[a].NegativeCount)
{
keysToRemove.Add(b);
}
}
}
foreach (var key in keysToRemove)
{
NegativeDictPartialSnapshotCompressions.Remove(key);
}
}
}
public void RememberDifference(bool isDifferent, ISensationSnapshot snapshot)
{
FieldOfVisionTypes fieldOfVision = GetFieldOfVisionsForDifferences().Last();
var partialSnapshot = SensationSnapshot.ExtractSnapshot(snapshot, fieldOfVision, Action.Direction);
// Handles counter and single units
if (isDifferent)
{
DifferenceCount++;
var singleUnits = SplitUnits(partialSnapshot);
foreach (var unit in singleUnits)
{
if (!DifferentUnits.ContainsKey(unit) && NoDifferentUnits.ContainsKey(unit))
{
DifferentUnits.Add(unit, 0);
}
if (DifferentUnits.ContainsKey(unit))
{
DifferentUnits[unit]++;
}
}
List <ISensoryUnit> unitsToRemove = new List <ISensoryUnit>();
foreach (var entry in DifferentUnits)
{
if (!NoDifferentUnits.ContainsKey(entry.Key))
{
unitsToRemove.Add(entry.Key);
}
}
foreach (var unit in unitsToRemove)
{
DifferentUnits.Remove(unit);
}
}
else
{
NoDifferenceCount++;
var singleUnits = SplitUnits(partialSnapshot);
foreach (var unit in singleUnits)
{
if (!NoDifferentUnits.ContainsKey(unit))
{
NoDifferentUnits.Add(unit, 0);
}
NoDifferentUnits[unit]++;
}
}
if (NoDifferenceCount > MINIMUM_CALL_COUNT_FOR_DIFFERENT_PATTERN && DifferenceCount > 0)
{
if (isDifferent)
{
// Look for pattern in No-Difference-Dictionary, which have brought about a change
foreach (var pattern in SplitPattern(partialSnapshot, 1))
{
if (GetNoDifferencePattern(fieldOfVision).ContainsKey(pattern))
{
GetNoDifferencePattern(fieldOfVision).Remove(pattern);
}
}
}
else
{
// Looking for pattern that probably show, that there is no effect by handling this action
foreach (var pattern in SplitPattern(partialSnapshot, 1))
{
bool patternFound = true;
foreach (var unit in pattern.SensoryUnits)
{
if (!NoDifferentUnits.ContainsKey(unit))
{
patternFound = false;
break;
}
}
if (patternFound)
{
if (!GetNoDifferencePattern(fieldOfVision).ContainsKey(pattern))
{
GetNoDifferencePattern(fieldOfVision).Add(pattern, 0);
}
GetNoDifferencePattern(fieldOfVision)[pattern]++;
}
}
}
}
}
