private Tuple NextInternal()
{
object[] objs = ArrayUtils.Range(0, numEntries + 1)
.Select(i => i == 0 ? minKeyVal as object : new List <object>() as object)
.ToArray();
Tuple retVal = new Tuple(objs);
for (int i = 0; i < numEntries; i++)
{
if (IsEligibleList(i, minKeyVal))
{
((List <object>)retVal.Get(i + 1)).Add(nextList[i].Get().Item1);
DrainKey(retVal, i, minKeyVal);
advanceList[i] = true;
}
else
{
advanceList[i] = false;
((List <object>)retVal.Get(i + 1)).Add(Slot <Tuple <object, R> > .Empty());
}
}
return(retVal);
}
/**
* Calculate the active cells, using the current active columns and dendrite
* segments. Grow and reinforce synapses.
*
* <pre>
* Pseudocode:
* for each column
* if column is active and has active distal dendrite segments
* call activatePredictedColumn
* if column is active and doesn't have active distal dendrite segments
* call burstColumn
* if column is inactive and has matching distal dendrite segments
* call punishPredictedColumn
*
* </pre>
*
* @param conn
* @param activeColumnIndices
* @param learn
*/
public void ActivateCells(Connections conn, ComputeCycle cycle, int[] activeColumnIndices, bool learn)
{
ColumnData columnData = new ColumnData();
HashSet <Cell> prevActiveCells = conn.GetActiveCells();
HashSet <Cell> prevWinnerCells = conn.GetWinnerCells();
List <Column> activeColumns = activeColumnIndices
.OrderBy(i => i)
.Select(i => conn.GetColumn(i))
.ToList();
Func <Column, Column> identity = c => c;
Func <DistalDendrite, Column> segToCol = segment => segment.GetParentCell().GetColumn();
//@SuppressWarnings({ "rawtypes" })
GroupBy2 <Column> grouper = GroupBy2 <Column> .Of(
new Tuple <List <object>, Func <object, Column> >(activeColumns.Cast <object>().ToList(), x => identity((Column)x)),
new Tuple <List <object>, Func <object, Column> >(new List <DistalDendrite>(conn.GetActiveSegments()).Cast <object>().ToList(), x => segToCol((DistalDendrite)x)),
new Tuple <List <object>, Func <object, Column> >(new List <DistalDendrite>(conn.GetMatchingSegments()).Cast <object>().ToList(), x => segToCol((DistalDendrite)x)));
double permanenceIncrement = conn.GetPermanenceIncrement();
double permanenceDecrement = conn.GetPermanenceDecrement();
foreach (Tuple t in grouper)
{
columnData = columnData.Set(t);
if (columnData.IsNotNone(ACTIVE_COLUMNS))
{
if (columnData.ActiveSegments().Any())
{
List <Cell> cellsToAdd = ActivatePredictedColumn(conn, columnData.ActiveSegments(),
columnData.MatchingSegments(), prevActiveCells, prevWinnerCells,
permanenceIncrement, permanenceDecrement, learn);
cycle.ActiveCells().UnionWith(cellsToAdd);
cycle.WinnerCells().UnionWith(cellsToAdd);
}
else
{
Tuple cellsXwinnerCell = BurstColumn(conn, columnData.Column(), columnData.MatchingSegments(),
prevActiveCells, prevWinnerCells, permanenceIncrement, permanenceDecrement, conn.GetRandom(),
learn);
cycle.ActiveCells().UnionWith((IEnumerable <Cell>)cellsXwinnerCell.Get(0));
cycle.WinnerCells().Add((Cell)cellsXwinnerCell.Get(1));
}
}
else
{
if (learn)
{
PunishPredictedColumn(conn, columnData.ActiveSegments(), columnData.MatchingSegments(),
prevActiveCells, prevWinnerCells, conn.GetPredictedSegmentDecrement());
}
}
}
}
public void AddEncoder(string fieldName, string encoderName, IEncoder child)
{
base.AddEncoder(this, fieldName, encoderName, child, width);
foreach (Tuple d in child.GetDescription())
{
Tuple dT = d;
description.Add(new Tuple(dT.Get(0), (int)dT.Get(1) + GetWidth()));
}
width += child.GetWidth();
}
public void TestWeekend()
{
//use of forced is not recommended, used here for readability, see ScalarEncoder
DateEncoder e = (DateEncoder)((DateEncoder.Builder)DateEncoder.GetBuilder()).CustomDays(21, new List <string>
{
"sat",
"sun",
"fri"
}).Forced(true).Build();
DateEncoder mon = (DateEncoder)((DateEncoder.Builder)DateEncoder.GetBuilder()).CustomDays(21, new List <string> {
"Monday"
})
.Forced(true).Build();
DateEncoder e2 = (DateEncoder)((DateEncoder.Builder)DateEncoder.GetBuilder()).Weekend(21, 1).Forced(true).Build();
//DateTime d = new DateTime(1988,5,29,20,0);
DateTime d = new DateTime(1988, 5, 29, 20, 0, 0);
Console.WriteLine("DateEncoderTest.testWeekend(): e.encode(d) = " + Arrays.ToString(e.Encode(d)));
Console.WriteLine("DateEncoderTest.testWeekend(): e2.encode(d) = " + Arrays.ToString(e2.Encode(d)));
Assert.IsTrue(e.Encode(d).SequenceEqual(e2.Encode(d)));
for (int i = 0; i < 300; i++)
{
DateTime curDate = d.AddDays(i + 1);
Assert.IsTrue(e.Encode(curDate).SequenceEqual(e2.Encode(curDate)));
//Make sure
Tuple decoded = mon.Decode(mon.Encode(curDate), null);
Map <String, RangeList> fieldsMap = (Map <String, RangeList>)decoded.Get(0);
List <String> fieldsOrder = (List <String>)decoded.Get(1);
Assert.IsNotNull(fieldsMap);
Assert.IsNotNull(fieldsOrder);
Assert.AreEqual(1, fieldsMap.Count);
RangeList range = fieldsMap["Monday"];
Assert.AreEqual(1, range.Count);
Assert.AreEqual(1, ((List <MinMax>)range.Get(0)).Count);
MinMax minmax = range.GetRange(0);
Console.WriteLine("DateEncoderTest.testWeekend(): minmax.min() = {0} -> {1}", minmax.Min(), curDate.DayOfWeek);
if (minmax.Min() == 1.0)
{
Assert.AreEqual(1, (int)curDate.DayOfWeek);
}
else
{
Assert.AreNotEqual(1, (int)curDate.DayOfWeek);
}
}
}
/**
* {@inheritDoc}
*/
public override void EncodeIntoArray(Tuple inputData, int[] output)
{
List <int[]> neighs = Neighbors((int[])inputData.Get(0), (double)inputData.Get(1));
int[][] neighbors = new int[neighs.Count][];
for (int i = 0; i < neighs.Count; i++)
{
neighbors[i] = neighs[i];
}
int[][] winners = TopWCoordinates(this, neighbors, w);
for (int i = 0; i < winners.Length; i++)
{
int bit = BitForCoordinate(winners[i], n);
output[bit] = 1;
}
}
public void TestDecoding()
{
SetUp();
InitDe();
//TODO Why null is needed?
Tuple decoded = de.Decode(bits, null);
Console.WriteLine(decoded.ToString());
Console.WriteLine(String.Format("decodedToStr=>{0}", de.DecodedToStr(decoded)));
Map <String, RangeList> fieldsMap = (Map <String, RangeList>)decoded.Get(0);
List <String> fieldsOrder = (List <String>)decoded.Get(1);
Assert.IsNotNull(fieldsMap);
Assert.IsNotNull(fieldsOrder);
Assert.AreEqual(4, fieldsMap.Count);
Map <String, Double> expectedMap = new Map <String, Double>();
expectedMap.Add("season", 305.0);
expectedMap.Add("time of day", 14.4);
expectedMap.Add("day of week", 3.0);
expectedMap.Add("weekend", 0.0);
foreach (String key in expectedMap.Keys)
{
double expected = expectedMap[key];
RangeList actual = fieldsMap[key];
Assert.AreEqual(1, actual.Count);
MinMax minmax = actual.GetRange(0);
Assert.AreEqual(expected, minmax.Min(), de.GetResolution());
Assert.AreEqual(expected, minmax.Max(), de.GetResolution());
}
Console.WriteLine(decoded.ToString());
Console.WriteLine(String.Format("decodedToStr=>{0}", de.DecodedToStr(decoded)));
}
/**
* Each input grouper may generate multiple members which match the
* specified "targetVal". This method guarantees that all members
* are added to the list residing at the specified Tuple index.
*
* @param retVal the Tuple being added to
* @param listIdx the index specifying the list within the
* tuple which will have members added to it
* @param targetVal the value to match in order to be an added member
*/
private void DrainKey(Tuple retVal, int listIdx, R targetVal)
{
while (generatorList[listIdx].HasNextInternal())
{
var peeked = generatorList[listIdx].Peek();
if (peeked?.Item2.Equals(targetVal) == true)
{
nextList[listIdx] = Slot <Tuple <object, R> > .Of(generatorList[listIdx].NextInternal());
((IList)retVal.Get(listIdx + 1)).Add(nextList[listIdx].Get().Item1);
}
else
{
nextList[listIdx] = Slot <Tuple <object, R> > .Empty();
break;
}
}
}
/**
* Initializes the {@link DateEncoder.Builder} specified
* @param b the builder on which to set the mapping.
* @param m the map containing the values
* @param key the key to be set.
*/
private static void SetDateFieldBits(DateEncoder.Builder b, Map <string, object> m, string key)
{
Tuple t = (Tuple)m[key];
switch (key)
{
case "season":
{
if (t.Count > 1 && (TypeConverter.Convert <double>(t.Get(1))) > 0.0)
{
b.Season((int)t.Get(0), TypeConverter.Convert <double>(t.Get(1)));
}
else
{
b.Season((int)t.Get(0));
}
break;
}
case "dayOfWeek":
{
if (t.Count > 1 && (TypeConverter.Convert <double>(t.Get(1)) > 0.0))
{
b.DayOfWeek((int)t.Get(0), TypeConverter.Convert <double>(t.Get(1)));
}
else
{
b.DayOfWeek((int)t.Get(0));
}
break;
}
case "weekend":
{
if (t.Count > 1 && (TypeConverter.Convert <double>(t.Get(1))) > 0.0)
{
b.Weekend((int)t.Get(0), TypeConverter.Convert <double>(t.Get(1)));
}
else
{
b.Weekend((int)t.Get(0));
}
break;
}
case "holiday":
{
if (t.Count > 1 && (TypeConverter.Convert <double>(t.Get(1))) > 0.0)
{
b.Holiday((int)t.Get(0), TypeConverter.Convert <double>(t.Get(1)));
}
else
{
b.Holiday((int)t.Get(0));
}
break;
}
case "timeOfDay":
{
if (t.Count > 1 && (TypeConverter.Convert <double>(t.Get(1))) > 0.0)
{
b.TimeOfDay((int)t.Get(0), TypeConverter.Convert <double>(t.Get(1)));
}
else
{
b.TimeOfDay((int)t.Get(0));
}
break;
}
case "customDays":
{
if (t.Count > 1 && (TypeConverter.Convert <double>(t.Get(1))) > 0.0)
{
b.CustomDays((int)t.Get(0), (List <string>)t.Get(1));
}
else
{
b.CustomDays((int)t.Get(0));
}
break;
}
default: break;
}
}
public Column Column()
{
return((Column)t.Get(0));
}
