public void Object_Equality()
{
var pattern1 = Recurrent.Yearly(MonthOfYear.April, dayOfMonth: 02, interval: 2);
var pattern2 = Recurrent.Yearly(MonthOfYear.April, dayOfMonth: 02, interval: 2);
Assert.That(pattern1, Is.EqualTo(pattern2));
}
public void Object_Equality()
{
var pattern1 = Recurrent.Monthly(dayOfMonth: 02, interval: 2);
var pattern2 = Recurrent.Monthly(dayOfMonth: 02, interval: 2);
Assert.That(pattern1, Is.EqualTo(pattern2));
}
public void HashCode_Inequality()
{
var pattern1 = Recurrent.Daily(interval: 1);
var pattern2 = Recurrent.Daily(interval: 2);
Assert.That(pattern1.GetHashCode() != pattern2.GetHashCode());
}
public void Object_Equality()
{
var pattern1 = Recurrent.Weekly(DaysOfTheWeek.Weekend, interval: 2, firstDayOfWeek: DayOfWeek.Monday);
var pattern2 = Recurrent.Weekly(DaysOfTheWeek.Weekend, interval: 2, firstDayOfWeek: DayOfWeek.Monday);
Assert.That(pattern1, Is.EqualTo(pattern2));
}
public void Object_Equality()
{
var pattern1 = Recurrent.Yearly(WeekOfMonth.First, DaysOfTheWeek.Weekend, MonthOfYear.January, interval: 1);
var pattern2 = Recurrent.Yearly(WeekOfMonth.First, DaysOfTheWeek.Weekend, MonthOfYear.January, interval: 1);
Assert.That(pattern1, Is.EqualTo(pattern2));
}
public void HashCode_Equality()
{
var pattern1 = Recurrent.Monthly(WeekOfMonth.First, DaysOfTheWeek.Weekend, interval: 2);
var pattern2 = Recurrent.Monthly(WeekOfMonth.First, DaysOfTheWeek.Weekend, interval: 2);
Assert.That(pattern1.GetHashCode() == pattern2.GetHashCode());
}
public void HashCode_Equality()
{
var pattern1 = Recurrent.Yearly(WeekOfMonth.First, DaysOfTheWeek.Weekend, MonthOfYear.November, interval: 1);
var pattern2 = Recurrent.Yearly(WeekOfMonth.First, DaysOfTheWeek.Weekend, MonthOfYear.November, interval: 1);
Assert.That(pattern1.GetHashCode() == pattern2.GetHashCode());
}
public void HashCode_Equality()
{
var pattern1 = Recurrent.Monthly(dayOfMonth: 02, interval: 2);
var pattern2 = Recurrent.Monthly(dayOfMonth: 02, interval: 2);
Assert.That(pattern1.GetHashCode() == pattern2.GetHashCode());
}
public void Object_Inequality()
{
var pattern1 = Recurrent.Daily(interval: 1);
var pattern2 = Recurrent.Daily(interval: 2);
Assert.That(pattern1, Is.Not.EqualTo(pattern2));
}
public void HashCode_Equality()
{
var pattern1 = Recurrent.Weekly(DaysOfTheWeek.Weekend, interval: 2, firstDayOfWeek: DayOfWeek.Monday);
var pattern2 = Recurrent.Weekly(DaysOfTheWeek.Weekend, interval: 2, firstDayOfWeek: DayOfWeek.Monday);
Assert.That(pattern1.GetHashCode() == pattern2.GetHashCode());
}
public void Object_Inequality()
{
var pattern1 = Recurrent.Yearly(dayOfYear: 123, interval: 1);
var pattern2 = Recurrent.Yearly(dayOfYear: 321, interval: 2);
Assert.That(pattern1, Is.Not.EqualTo(pattern2));
}
public void HashCode_Inequality()
{
var pattern1 = Recurrent.Yearly(dayOfYear: 123, interval: 1);
var pattern2 = Recurrent.Yearly(dayOfYear: 321, interval: 2);
Assert.That(pattern1.GetHashCode() != pattern2.GetHashCode());
}
public void Object_Equality()
{
var pattern1 = Recurrent.Monthly(WeekOfMonth.First, DaysOfTheWeek.Weekend, interval: 2);
var pattern2 = Recurrent.Monthly(WeekOfMonth.First, DaysOfTheWeek.Weekend, interval: 2);
Assert.That(pattern1, Is.EqualTo(pattern2));
}
public void Recurrences_All()
{
var pattern = Recurrent.Daily();
var start = DateTime.SpecifyKind(DateTime.MinValue.AddTicks(123456789), DateTimeKind.Utc);
Assert.That(pattern.GetRecurrencesStartingAt(start).Select(date => date.Kind), Is.All.EqualTo(start.Kind));
Assert.That(pattern.GetRecurrencesStartingAt(start).Select(date => date.TimeOfDay), Is.All.EqualTo(start.TimeOfDay));
}
public void HashCode_Inequality()
{
var pattern1 = Recurrent.Yearly(MonthOfYear.December, dayOfMonth: 01, interval: 1);
var pattern2 = Recurrent.Yearly(MonthOfYear.April, dayOfMonth: 02, interval: 2);
var pattern3 = Recurrent.Yearly(MonthOfYear.April, dayOfMonth: 02, interval: 1);
Assert.That(pattern1.GetHashCode() != pattern2.GetHashCode());
Assert.That(pattern1.GetHashCode() != pattern3.GetHashCode());
Assert.That(pattern2.GetHashCode() != pattern3.GetHashCode());
}
public void Object_Inequality()
{
var pattern1 = Recurrent.Yearly(MonthOfYear.December, dayOfMonth: 01, interval: 1);
var pattern2 = Recurrent.Yearly(MonthOfYear.April, dayOfMonth: 02, interval: 2);
var pattern3 = Recurrent.Yearly(MonthOfYear.April, dayOfMonth: 02, interval: 1);
Assert.That(pattern1, Is.Not.EqualTo(pattern2));
Assert.That(pattern1, Is.Not.EqualTo(pattern3));
Assert.That(pattern2, Is.Not.EqualTo(pattern3));
}
public void Recurrences_All()
{
var pattern = Recurrent.Monthly(WeekOfMonth.Second, DaysOfTheWeek.Wednesday);
var start = DateTime.SpecifyKind(DateTime.MinValue.AddTicks(123456789), DateTimeKind.Utc);
Assert.That(pattern.GetRecurrencesStartingAt(start).Select(date => date.Kind), Is.All.EqualTo(start.Kind));
Assert.That(pattern.GetRecurrencesStartingAt(start).Select(date => date.TimeOfDay), Is.All.EqualTo(start.TimeOfDay));
Assert.That(pattern.GetRecurrencesStartingAt(start).Select(date => date.DayOfWeek), Is.All.EqualTo(DayOfWeek.Wednesday));
Assert.That(pattern.GetRecurrencesStartingAt(start).Select(date => date.DayOfWeekInstance()), Is.All.EqualTo(WeekOfMonth.Second));
}
public void HashCode_Inequality()
{
var pattern1 = Recurrent.Monthly(WeekOfMonth.First, DaysOfTheWeek.Weekend, interval: 1);
var pattern2 = Recurrent.Monthly(WeekOfMonth.First, DaysOfTheWeek.Weekday, interval: 1);
var pattern3 = Recurrent.Monthly(WeekOfMonth.Last, DaysOfTheWeek.Weekend, interval: 1);
var pattern4 = Recurrent.Monthly(WeekOfMonth.Last, DaysOfTheWeek.Weekend, interval: 2);
Assert.That(pattern1.GetHashCode() != pattern2.GetHashCode());
Assert.That(pattern1.GetHashCode() != pattern3.GetHashCode());
Assert.That(pattern1.GetHashCode() != pattern4.GetHashCode());
Assert.That(pattern2.GetHashCode() != pattern3.GetHashCode());
Assert.That(pattern2.GetHashCode() != pattern4.GetHashCode());
Assert.That(pattern3.GetHashCode() != pattern4.GetHashCode());
}
public void Object_Inequality()
{
var pattern1 = Recurrent.Monthly(WeekOfMonth.First, DaysOfTheWeek.Weekend, interval: 1);
var pattern2 = Recurrent.Monthly(WeekOfMonth.First, DaysOfTheWeek.Weekday, interval: 1);
var pattern3 = Recurrent.Monthly(WeekOfMonth.Last, DaysOfTheWeek.Weekend, interval: 1);
var pattern4 = Recurrent.Monthly(WeekOfMonth.Last, DaysOfTheWeek.Weekend, interval: 2);
Assert.That(pattern1, Is.Not.EqualTo(pattern2));
Assert.That(pattern1, Is.Not.EqualTo(pattern3));
Assert.That(pattern1, Is.Not.EqualTo(pattern4));
Assert.That(pattern2, Is.Not.EqualTo(pattern3));
Assert.That(pattern2, Is.Not.EqualTo(pattern4));
Assert.That(pattern3, Is.Not.EqualTo(pattern4));
}
public void HashCode_Inequality()
{
var pattern1 = Recurrent.Weekly(DaysOfTheWeek.Weekend, interval: 1, firstDayOfWeek: DayOfWeek.Monday);
var pattern2 = Recurrent.Weekly(DaysOfTheWeek.Weekend, interval: 2, firstDayOfWeek: DayOfWeek.Monday);
var pattern3 = Recurrent.Weekly(DaysOfTheWeek.Weekday, interval: 2, firstDayOfWeek: DayOfWeek.Monday);
var pattern4 = Recurrent.Weekly(DaysOfTheWeek.Weekday, interval: 2, firstDayOfWeek: DayOfWeek.Sunday);
Assert.That(pattern1.GetHashCode() != pattern2.GetHashCode());
Assert.That(pattern1.GetHashCode() != pattern3.GetHashCode());
Assert.That(pattern1.GetHashCode() != pattern4.GetHashCode());
Assert.That(pattern2.GetHashCode() != pattern3.GetHashCode());
Assert.That(pattern2.GetHashCode() != pattern4.GetHashCode());
Assert.That(pattern3.GetHashCode() != pattern4.GetHashCode());
}
public void Object_Inequality()
{
var pattern1 = Recurrent.Weekly(DaysOfTheWeek.Weekend, interval: 1, firstDayOfWeek: DayOfWeek.Monday);
var pattern2 = Recurrent.Weekly(DaysOfTheWeek.Weekend, interval: 2, firstDayOfWeek: DayOfWeek.Monday);
var pattern3 = Recurrent.Weekly(DaysOfTheWeek.Weekday, interval: 2, firstDayOfWeek: DayOfWeek.Monday);
var pattern4 = Recurrent.Weekly(DaysOfTheWeek.Weekday, interval: 2, firstDayOfWeek: DayOfWeek.Sunday);
Assert.That(pattern1, Is.Not.EqualTo(pattern2));
Assert.That(pattern1, Is.Not.EqualTo(pattern3));
Assert.That(pattern1, Is.Not.EqualTo(pattern4));
Assert.That(pattern2, Is.Not.EqualTo(pattern3));
Assert.That(pattern2, Is.Not.EqualTo(pattern4));
Assert.That(pattern3, Is.Not.EqualTo(pattern4));
}
public void Recurrent_ApplyEffect_ApplyCorrectTimes()
{
Effect oneTimer = new Recurrent(
AllEffects.Create(DamageTarget(1))
);
Member attacker = TestMembers.With(StatType.Attack, 1);
Member target = TestMembers.Create(s => s.With(StatType.MaxHP, 10).With(StatType.Damagability, 1f));
oneTimer.Apply(attacker, new Single(target));
oneTimer.Apply(attacker, new Single(target));
Assert.AreEqual(
9,
target.State[TemporalStatType.HP],
"Effect applied more than the repetition limit."
);
}
public IEnumerable <DateTime> Recurrences(DaysOfTheWeek daysOfWeek, int interval, DayOfWeek firstDayOfWeek, DateTime start, int count)
{
var pattern = Recurrent.Weekly(daysOfWeek, interval, firstDayOfWeek);
return(pattern.GetRecurrencesStartingAt(start).Take(count).ToArray());
}
public bool CreateLayer(int nCount, ELayerType type, ActivationSettings activationSettings)
{
Layer.Utility.Layer layer;
switch (type)
{
case ELayerType.Invalid:
throw new ArgumentException("Invalid \"type\" argument.");
case ELayerType.AveragePooling:
layer = new AveragePooling(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.AverageUnpooling:
layer = new AverageUnpooling(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.Convolutional:
layer = new Convolutional(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.Deconvolutional:
layer = new Deconvolutional(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.Dropout:
layer = new Dropout(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.FullyConnected:
layer = new FullyConnected(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.GatedRecurrent:
layer = new GatedRecurrent(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.LSTM:
layer = new LSTM(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.MaxPooling:
layer = new MaxPooling(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.MaxUnpooling:
layer = new MaxUnpooling(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
case ELayerType.Recurrent:
layer = new Recurrent(nCount, Layers.Count, activationSettings);
Layers.Add(layer);
return(true);
default:
throw new ArgumentException("Invalid \"type\" argument.");
}
}
public IEnumerable <DateTime> Recurrences(WeekOfMonth weekOfMonth, DaysOfTheWeek daysOfWeek, MonthOfYear monthOfYear, int interval, DateTime start, int count)
{
var pattern = Recurrent.Yearly(weekOfMonth, daysOfWeek, monthOfYear, interval);
return(pattern.GetRecurrencesStartingAt(start).Take(count).ToArray());
}
public IEnumerable <DateTime> Recurrences(int dayOfMonth, int interval, DateTime start, int count)
{
var pattern = Recurrent.Monthly(dayOfMonth, interval);
return(pattern.GetRecurrencesStartingAt(start).Take(count).ToArray());
}
