/// <summary>
/// Register a sequence of actions.
/// </summary>
/// <param name="actions">
/// The actions list, which should be at least of size N.
/// </param>
public void RegisterSequence(IReadOnlyList <T> actions)
{
// Can only register sequence if its size N
if (actions.Count == NValue)
{
// Previous actions
ReadOnlyListSegment <T> prevActions =
new ReadOnlyListSegment <T>(actions, 0, NValue - 1);
// Previous actions in key form
string prevActionsKey = SequenceToString(prevActions);
// Action performed
T actionPerformed = actions[NValue - 1];
// Check if our data contains the key (i.e. sequence of actions)
// If not, create a new record for this sequence of actions
if (!data.ContainsKey(prevActionsKey))
{
data[prevActionsKey] = new ActionFrequency <T>();
}
// Get the data record for this sequence of actions
ActionFrequency <T> actionFrequency = data[prevActionsKey];
// Increment the number of times this action was performed
// after the given sequence of actions
actionFrequency.IncrementFrequency(actionPerformed);
}
}
/// <summary>
/// Register a sequence of actions.
/// </summary>
/// <param name="actions">
/// The actions list, which should be at least of size 1.
/// </param>
public void RegisterSequence(IReadOnlyList <T> actions)
{
// Register the sequence of actions in each Ni-Gram
for (int i = 0; i < NValue; i++)
{
// Are there enough actions for the current Ni-Gram?
if (actions.Count >= i + 1)
{
ReadOnlyListSegment <T> subactions =
new ReadOnlyListSegment <T>(
actions,
actions.Count - i - 1,
i + 1);
// Register the sequence of actions in the current Ni-Gram
predictors[i].RegisterSequence(subactions);
}
}
}
/// <summary>
/// Get the most likely action given a sequence of actions.
/// </summary>
/// <param name="actions">
/// The actions list, which should be at least of size 1.
/// </param>
/// <returns>
/// The most likely action for the given a sequence of actions.
/// </returns>
public T GetMostLikely(IReadOnlyList <T> actions)
{
// Declare variable for best action and set it to its default value
T bestAction = default;
// Go through the various Ni-Grams
for (int i = 0; i < NValue; i++)
{
// Are there enough actions for the current Ni-Gram?
if (actions.Count >= NValue - i - 1)
{
// Get current Ni-Gram
NGram <T> p = predictors[NValue - i - 1];
// Create a view containing only the actions for the
// current Ni-Gram
ReadOnlyListSegment <T> subactions =
new ReadOnlyListSegment <T>(
actions,
actions.Count + i + 1 - NValue,
NValue - i - 1);
// Get frequency of action sequence in the current Ni-Gram
int numActions = p.GetActionsFrequency(subactions);
// Is that frequency larger than the threshold?
if (numActions > threshold)
{
// Then use this action
bestAction = p.GetMostLikely(subactions);
break;
}
}
}
// Return the best action
return(bestAction);
}
public IReadOnlyList <TValue> this[TKey key]
{
get
{
IReadOnlyList <TValue> readOnlyList;
var index = IndexOf(key);
if (index >= 0)
{
var currentGroupIndex = _groups[index];
var nextGroupIndex = index < _groups.Count - 1 ? _groups[index + 1] : _values.Count;
var count = nextGroupIndex - currentGroupIndex;
readOnlyList = new ReadOnlyListSegment <TValue>(_values, currentGroupIndex, count);
}
else
{
readOnlyList = EmptyReadOnlyCollection <TValue> .Value;
}
Assert.IsNotNull(readOnlyList);
return(readOnlyList);
}
}
public bool Equals(ReadOnlyListSegment <T> obj) => obj.List == List && obj.Offset == Offset && obj.Count == Count;
