public IClientChannel <T> RegisterPercentageFilter(T publishAfterPercentageChange)
{
// Check to see if T is numeric so can have some sort of a percentage change
if (this.publishedValueDelta is double || this.publishedValueDelta is int || this.publishedValueDelta is short || this.publishedValueDelta is float)
{
return(this.RegisterFilter((newValue, oldValue) =>
{
// Using pure generic math here
this.publishedValueDelta = Operator.Add(this.publishedValueDelta, Operator.Subtract(newValue, oldValue));
var change = Operator.Divide(Operator.MultiplyAlternative(this.publishedValueDelta, 100), oldValue);
if (Operator.GreaterThanOrEqual(change, publishAfterPercentageChange) || Operator.LessThanOrEqual(change, Operator.Negate(publishAfterPercentageChange)))
{
this.publishedValueDelta = default(T);
return true;
}
else
{
return false;
}
}));
}
else
{
return(this);
}
}
/// <summary>
/// Converts a 3 dimensional dataSet to a 2 dimensional dataSet
/// </summary>
/// <param name="dataSet">The dataSet to fold</param>
/// <param name="day">The day to focus</param>
/// <param name="hour">The hour to focus</param>
/// <returns></returns>
public T[,] ConvertTo2D(T[, ,] dataSet, DayOfWeek day, int hour)
{
if (hour < 0)
{
throw new ArgumentOutOfRangeException("hour", "Cannot be less than 0");
}
if (hour > 24)
{
throw new ArgumentOutOfRangeException("hour", "Cannot be greater than 24");
}
//A 2d matrix of only days and hours
T[,] dMatrix = new T[1, 1];
T HoursTotal = default(T);
for (int Minute = 0; Minute < 60; Minute++)
{
//HoursTotal += dataSet[0, hour, Minute];// / DateUtility.OccurancesOfDayInMonth(day, monthInReview, yearInReview);
HoursTotal = Operator.Add(HoursTotal, dataSet[0, hour, Minute]);
}//Minutes
if (!Operator.IsDefault(HoursTotal))
{
HoursTotal = Operator.DivideInt32(HoursTotal, 60); //minuts in a hour
}
dMatrix[0, 0] = HoursTotal;
return(dMatrix);
}
// Multipication C = A*B
public static T[,] Multiplication(T[,] A, T[,] B)
{
int rows = A.GetLength(0); //A.rows
int cols = B.GetLength(1); //B.cols
T zero = Operator.Subtract(A[0, 0], A[0, 0]);
T[,] C = new T[rows, cols];
if (A.GetLength(1) != B.GetLength(0))
{
throw new ArgumentException("Invalid matrix sizes.");
}
for (int i = 0; i < A.GetLength(0); i++) //A.rows
{
for (int j = 0; j < B.GetLength(1); j++) //B.cols
{
C[i, j] = zero;
for (int k = 0; k < A.GetLength(1); k++) //A.cols= B.rows
{
C[i, j] = Operator.Add(C[i, j], Operator.Multiply(A[i, k], B[k, j]));
}
}
}
return(C);
}
//protected void FindAllViews()
//{
// _gestureClassLabel = FindViewById<TextView>(Resource.Id.melee_gc_label);
// _qualityThis = FindViewById<TextView>(Resource.Id.melee_qual_this);
// _qualityAvg = FindViewById<TextView>(Resource.Id.melee_qual_avg);
// _qualityRatio = FindViewById<TextView>(Resource.Id.melee_qual_ratio);
// _delayThis = FindViewById<TextView>(Resource.Id.melee_delay_this);
// _delayAvg = FindViewById<TextView>(Resource.Id.melee_delay_avg);
// _delayRatio = FindViewById<TextView>(Resource.Id.melee_delay_ratio);
// _durationThis = FindViewById<TextView>(Resource.Id.melee_dur_this);
// _durationAvg = FindViewById<TextView>(Resource.Id.melee_dur_avg);
// _durationRatio = FindViewById<TextView>(Resource.Id.melee_dur_ratio);
// _numptsThis = FindViewById<TextView>(Resource.Id.melee_numpts_this);
// _numptsAvg = FindViewById<TextView>(Resource.Id.melee_numpts_avg);
// _numptsRatio = FindViewById<TextView>(Resource.Id.melee_numpts_ratio);
// _pkaccelThis = FindViewById<TextView>(Resource.Id.melee_pkaccel_this);
// _pkaccelAvg = FindViewById<TextView>(Resource.Id.melee_pkaccel_avg);
// _pkaccelRatio = FindViewById<TextView>(Resource.Id.melee_pkaccel_ratio);
// _userTrainingBtn = FindViewById<Button>(Resource.Id.melee_user_training_btn);
// _cuedSingleBtn = FindViewById<Button>(Resource.Id.melee_cued_single_btn);
// _cuedSeriesBtn = FindViewById<Button>(Resource.Id.melee_cued_series_btn);
//}
#endregion
#region Activity Lifecycle Methods
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.SimpleListPage);
//FindAllViews();
//GestureClassList = FragmentManager.FindFragmentById<GestureClassListFragment>(Resource.Id.mlrn_gestureclass_list_fragment);
//LatestSample = FragmentManager.FindFragmentById<LatestSampleFragment>(Resource.Id.mlrn_latest_sample_display);
Dataset = new DataSet <DKS>();
Classifier = new Classifier(); // Just in case; it's not actually going to get used in this version.
//SetUpButtonClicks();
// Debugging
var q1 = Quaternion.CreateFromAxisAngle(Vector3.One, 0.25f);
var q2 = Quaternion.Identity;
Log.Debug(_tag, $"First test: quat {q1} + quat {q2} = quat {q1 + q2}.");
Log.Debug(_tag, $"Second test: Operator.Add(q1, q2) = {Operator.Add(q1, q2)}");
var dks1 = new DKS();
dks1.Values.Value4 = q1;
var dks2 = new DKS();
dks2.Values.Value4 = q2;
var dksSum = dks1 + dks2;
Log.Debug(_tag, $"Third test: dks1 + dks2 = dks3 w/ orientation {dksSum.Orientation}");
var dksSum2 = Operator.Add(dks1, dks2);
Log.Debug(_tag, $"Fourth test: Operator.Add(dks1, dks2) = dks3 w/ orientation {dksSum2.Orientation}");
}
public void CanAddTwoVectors(TestVector testVectorA, TestVector testVectorB)
{
Vector <T> a = Get(testVectorA);
Vector <T> b = Get(testVectorB);
Assume.That(a.Count, Is.EqualTo(b.Count));
var hasha = a.GetHashCode();
var hashb = b.GetHashCode();
var result1 = a + b;
var result2 = a.Add(b);
var result3 = a.Clone();
result3.Add(b, result3);
Assert.That(a.GetHashCode(), Is.EqualTo(hasha));
Assert.That(b.GetHashCode(), Is.EqualTo(hashb));
Assert.That(result1, Is.Not.SameAs(a));
Assert.That(result1, Is.Not.SameAs(b));
Assert.That(result2, Is.Not.SameAs(a));
Assert.That(result2, Is.Not.SameAs(b));
Assert.That(result3, Is.Not.SameAs(a));
Assert.That(result3, Is.Not.SameAs(b));
Assert.That(result1.Equals(result2));
Assert.That(result1.Equals(result3));
for (var i = 0; i < Math.Min(a.Count, 20); i++)
{
Assert.That(result1[i], Is.EqualTo(Operator.Add(a[i], b[i])));
Assert.That(result2[i], Is.EqualTo(Operator.Add(a[i], b[i])));
Assert.That(result3[i], Is.EqualTo(Operator.Add(a[i], b[i])));
}
}
/// <summary>
/// Converts a 4 dimensional dataSet to a 3 dimensional dataSet
/// </summary>
/// <param name="dataSet">The dataSet to fold</param>
/// <param name="day">The day to focus</param>
/// <returns></returns>
public T[, ,] ConvertTo3D(T[, , ,] dataSet, DayOfWeek day)
{
DateTime refrencePoint = DateTime.MinValue;
int ZeroData = 0;
//A 3d matrix of only days and hours and minutes
T[, ,] dMatrix = new T[1, 24, 60];
T MinuteTotal = default(T);
int dayBound = dataSet.GetUpperBound(0) + 1;
for (int Day = 0; Day < dayBound; Day++)
{
try
{
refrencePoint = new DateTime(yearInReview, monthInReview, Day + 1);
}
catch //if this is invalid date
{
break; //stop the loop
}
if (refrencePoint.DayOfWeek != day)
{
continue;
}
for (int Hour = 0; Hour < 24; Hour++)
{
for (int Minute = 0; Minute < 60; Minute++)
{
ZeroData = 0;
MinuteTotal = default(T);
for (int Second = 0; Second < 60; Second++)
{
if (Operator.IsDefault(dataSet[Day, Hour, Minute, Second]))
{
ZeroData++;
}
MinuteTotal = Operator.Add(MinuteTotal, dataSet[Day, Hour, Minute, Second]);
}
int Correction = 60 - ZeroData;
int DayOccurs = DateUtility.OccurancesOfDayInMonth(day, monthInReview, yearInReview);
if (!Operator.IsDefault(MinuteTotal))
{
MinuteTotal = Operator.DivideInt32(MinuteTotal, 60);
}
if (Correction < DayOccurs * 2 && Correction != 0)
{
//dMatrix[0, Hour, Minute] = GenericMath.AddChecked(MinuteTotal, GenericMath.Multiply(GenericMath.Divide(MinuteTotal, Correction), GenericMath.SubtractChecked(GenericMath.Multiply(DayOccurs, 2), Correction)));
dMatrix[0, Hour, Minute] = Operator.Add(MinuteTotal, Operator.MultiplyInt32(Operator.DivideInt32(MinuteTotal, Correction), Operator.Subtract(Operator.MultiplyInt32(DayOccurs, 2), Correction)));
}
else
{
dMatrix[0, Hour, Minute] = MinuteTotal;
}
} //Minutes
} //Hours
}
return(dMatrix);
}
public static T Median <T>(T[] data) where T : IComparable
{
if (data.Length == 0)
{
return(Operator <T> .Zero);
}
Array.Sort(data);
if (data.Length == 0)
{
return(Operator <T> .Zero);
throw new InvalidOperationException("Empty collection");
}
else if (data.Length % 2 == 0)
{
// count is even, average two middle elements
T sum = Operator.Add(data[data.Length / 2 - 1], data[data.Length / 2]);
return(Operator.DivideInt32(sum, 2));
}
else
{
// count is odd, return the middle element
return(data[data.Length / 2]);
}
}
/// <summary>
/// Converts a 4 dimensional dataSet to a 3 dimensional dataSet
/// </summary>
/// <param name="dataSet">The dataSet to fold</param>
/// <param name="day">The day to focus</param>
/// <returns></returns>
public T[, ,] ConvertTo3D(T[, , ,] dataSet, int dayofmonth)
{
if (dayofmonth < 0 || dayofmonth > DateUtility.DaysInMonth(monthInReview, yearInReview))
{
throw new ArgumentOutOfRangeException("dayofmonth", "Cannot be less than 0 or greater than " + DateUtility.DaysInMonth(monthInReview, yearInReview));
}
if (dayofmonth > 0)
{
dayofmonth--;
}
//A 3d matrix of only days and hours and minutes
T[, ,] dMatrix = new T[1, 24, 60];
T MinuteTotal;
for (int Hour = 0; Hour < 24; Hour++)
{
for (int Minute = 0; Minute < 60; Minute++)
{
MinuteTotal = default(T);
for (int Second = 0; Second < 60; Second++)
{
MinuteTotal = Operator.Add(MinuteTotal, dataSet[dayofmonth, Hour, Minute, Second]);
}
dMatrix[0, Hour, Minute] = Operator.DivideInt32(MinuteTotal, 60);//seconds in a minute
}//Minutes
}//Hours
return(dMatrix);
}
/// <summary>
/// Moves all intervals that lie within the given interval.
/// </summary>
/// <param name = "interval">The interval which specifies which elements will be moved.</param>
/// <param name = "offset">The offset where to move the values in the interval.</param>
public void MoveInterval(Interval <TMath> interval, TMath offset)
{
// Keep track of the intervals that need to be moved.
var movedIntervals = new List <IntervalValues>();
foreach (var intersectingRange in FindIntersections(interval))
{
Interval <TMath> intersection = intersectingRange.Interval.Intersection(interval);
// Remove part of the interval which will be moved, static parts can stay.
SplitRemoveIntersection(intersectingRange, intersection);
// Add moved remainder to list to be added again.
var movedInterval = new Interval <TMath>(
Operator <TMath> .Add(intersection.Start, offset),
intersection.IsStartIncluded,
Operator <TMath> .Add(intersection.End, offset),
intersection.IsEndIncluded);
movedIntervals.Add(new IntervalValues(intersectingRange.Values, movedInterval));
}
// Add moved intervals again.
foreach (var newRange in movedIntervals)
{
Add(newRange.Interval, newRange.Values);
}
}
public override void Add(TValue value)
{
// Get position for the new point.
TMath position = default(TMath);
if (_data.Count > 0)
{
// Add the new key point, with the accumulated distance since the last key point.
KeyPoint last = _data[_data.Count - 1];
TMath distance = DistanceBetween(last.Value, value);
position = Operator <TMath> .Add(last.Position, distance);
}
// Create new key point.
var newKeyPoint = new KeyPoint
{
Position = position,
Value = value
};
// Update data range.
if (_dataRange == null)
{
// First object has zero distance.
_dataRange = new Interval <TMath>(_zero, _zero);
}
else
{
_dataRange = _dataRange.ExpandTo(position);
}
_data.Add(newKeyPoint);
}
public static T[] ConsecutiveWithSum <T>(this T[] array, T sum) where T : IComparable
{
int indexStart = 0, indexEnd = 0;
bool success = false;;
for (int i = 0, j = 0; i < array.Length; i++, j = i)
{
if (success)
{
break;
}
T currentSum = default(T);
for (; j < array.Length; j++)
{
currentSum = Operator.Add(currentSum, array[j]);
if (currentSum.CompareTo(sum) == 0)
{
indexStart = i;
indexEnd = j;
success = true;
break;
}
}
}
if (!success)
{
return(new T[0]);
}
T[] series = new T[indexEnd - indexStart + 1];
for (int i = 0, j = indexStart; j <= indexEnd; i++, j++)
{
series[i] = array[j];
}
return(series);;
}
protected static T _defaultGetAverageFunc(RollingAverage <T> self)
{
return((self.isValidYet)
? self.currentAverage
: Operator <T> .Add(Operator.MultiplyAlternative(self.currentAverage, self.readyPart),
Operator.MultiplyAlternative(self.defaultAverage, self.unreadyPart)));
}
public virtual void Update(T newValue)
{
if (float.IsNaN(MagnitudeOf(newValue)))
{
// It's conceivable that a single NaN might get passed here during startup / stopping, so tolerate that (but warn)
if (!WarningIssued)
{
WarningIssued = true;
Android.Util.Log.Warn("Atropos|SimpleAverage<T>", $"SimpleAverage<{typeof(T).Name}> passed {newValue}, whose Magnitude is NaN. Problem?");
return;
}
else
{
throw new ArgumentException($"SimpleAverage<{typeof(T).Name}> passed {newValue}, whose Magnitude is NaN, more than once. Time to investigate.");
}
}
count++;
lastAverage = currentAverage;
lastValue = currentValue;
currentValue = newValue;
var delta = Operator.Subtract(newValue, lastAverage);
//currentAverage = Operator.Add(lastAverage, Operator.MultiplyAlternative(delta, Alpha));
var v1 = Operator.MultiplyAlternative(delta, Alpha);
var v2 = Operator.Add(lastAverage, v1);
currentAverage = v2;
}
T Fold <T>(ArithmeticBinaryExpression n) where T : struct
{
var vleft = n.left.Value.Val <T>();
var vright = n.right.Value.Val <T>();
switch (n.op)
{
case ArithmeticBinaryOp.ADD: return(Operator.Add(vleft, vright));
case ArithmeticBinaryOp.SUB: return(Operator.Subtract(vleft, vright));
case ArithmeticBinaryOp.MUL: return(Operator.Multiply(vleft, vright));
case ArithmeticBinaryOp.QUOT: return(Operator.Add(vleft, vright));
case ArithmeticBinaryOp.DIV: return(Operator.Divide(vleft, vright));
case ArithmeticBinaryOp.MOD: return(Operator.DivideInt32(vleft, n.right.Value.Val <int>()));
// TODO
// case ArithmeticBinaryOp.SHL: return Operator
// case ArithmeticBinaryOp.SHR: return Operator
default: throw new SemanticException("Constant folding of operator not yet supported");
}
}
public T Update(T mostRecentValue)
{
if (history.Count < history.Capacity)
{
history.Add(mostRecentValue);
nextUpdateSlot++;
}
else
{
history[nextUpdateSlot++] = mostRecentValue;
}
if (nextUpdateSlot >= history.Capacity)
{
nextUpdateSlot = 0;
}
var sum = Operator <T> .Zero;
foreach (var value in history)
{
sum = Operator.Add(sum, value);
}
if (Operator.NotEqual(sum, Operator <T> .Zero))
{
return(Operator.DivideAlternative(sum, (float)history.Count));
}
else
{
return(sum);
}
}
/// <summary>
/// Converts a 3 dimensional dataSet to a 2 dimensional dataSet
/// </summary>
/// <param name="dataSet">The dataSet to fold</param>
/// <returns></returns>
public T[,] ConvertTo2D(T[, ,] dataSet)
{
//A 2d matrix of only days and hours
int dayEnd = dataSet.GetUpperBound(0) + 1;
int hourEnd = dataSet.GetUpperBound(1) + 1;
T[,] dMatrix = new T[dayEnd, hourEnd];
T HoursTotal;
for (int Day = 0; Day < dayEnd; Day++)
{
for (int Hour = 0; Hour < hourEnd; Hour++)
{
HoursTotal = default(T);
for (int Minute = 0, minuteEnd = dataSet.GetUpperBound(2) + 1; Minute < minuteEnd; Minute++)
{
HoursTotal = Operator.Add(HoursTotal, dataSet[Day, Hour, Minute]);
}//Minutes
if (!Operator.IsDefault(HoursTotal))
{
HoursTotal = Operator.DivideInt32(HoursTotal, 60);//minutes in a hour
}
dMatrix[Day, Hour] = HoursTotal;
} //Hours
} //Days
return(dMatrix);
}
private static T GetAverage <T>(IEnumerable <T> numbers)
{
T sum = Operator <T> .Zero;
int count = 0;
foreach (var value in numbers)
{
// null values are not counted for the average result,
// The compiler will skip this check for non nullable types like Int32
if (value != null)
{
sum = Operator.Add(sum, value);
count++;
}
}
if (count == 0)
{
sum = default(T);
if (sum != null)
{
throw new InvalidOperationException();
}
return(sum);
}
else
{
return(Operator.DivideInt32(sum, count));
}
}
public void AddTestComplex()
{
Complex a = new Complex(12, 3);
Complex b = new Complex(2, 5);
Assert.AreEqual(a + b, Operator.Add(a, b));
}
//Select Method
public void SelectFromDB(string query, bool State)
{
try
{
cmd = new SqlCommand(query, sc);
Da = new SqlDataAdapter(cmd);
if (dt != null)
{
dt.Clear();
}
Da.Fill(dt);
if (dt != null && State == true)
{
foreach (DataRow row in dt.Rows)
{
type.Add(row["Type"].ToString());
Operator.Add(row["Operator"].ToString());
}
//remove duplicate items
type = type.Distinct().ToList();
Operator = Operator.Distinct().ToList();
}
}
catch (SqlException ex)
{
MessageBox.Show("Some errors affected ! " + ex.Message);
}
finally
{
sc.Close();
}
}
/// <summary>
/// Converts a 4 dimensional dataSet to a 3 dimensional dataSet
/// </summary>
/// <param name="dataSet">The dataSet to fold</param>
/// <returns></returns>
public T[, ,] ConvertTo3D(T[, , ,] dataSet)
{
//A 3d matrix of only days and hours and minutes
T[, ,] dMatrix = new T[7, 24, 60];
T MinuteTotal = default(T);
for (int Day = 0, dayEnd = dataSet.GetUpperBound(0) + 1, dayInMonth = DateUtility.DaysInMonth(monthInReview, yearInReview); (Day < dayEnd && Day < dayInMonth); Day++)
{
for (int Hour = 0, hourEnd = dataSet.GetUpperBound(1) + 1; Hour < hourEnd; Hour++)
{
for (int Minute = 0, minuteEnd = dataSet.GetUpperBound(2) + 1; Minute < minuteEnd; Minute++)
{
MinuteTotal = default(T);
for (int Second = 0, secondEnd = dataSet.GetUpperBound(3) + 1; Second < secondEnd; Second++)
{
MinuteTotal = Operator.Add(MinuteTotal, dataSet[Day, Hour, Minute, Second]);
}
DateTime checker = new DateTime(yearInReview, monthInReview, Day + 1, Hour, Minute, 0);
dMatrix[(int)checker.DayOfWeek, Hour, Minute] = MinuteTotal;
} //Minutes
} //Hours
} //Days
return(dMatrix);
}
public static Box <T> operator +(Box <T> x, Box <T> y)
{
if (x == null || y == null)
{
return(null);
}
return(new Box <T>(Operator.Add(x.Value, y.Value)));
}
public T Absolute(T obj)
{
T zero = Operator.Subtract(obj, obj);
if (Operator.LessThan(obj, zero))
{
obj = Operator.Subtract(obj, Operator.Add(obj, obj));
}
return(obj);
}
public void Multiplication()
{
for (int y = 0; y < Dimensions; y++)
{
for (int x = 0; x < Dimensions; x++)
{
VectorB[y] = Operator.Add(VectorB[y], Operator.Multiply(MatrixA[x, y], VectorX[x]));
}
}
}
public bool AddIfNotNull(ref T accumulator, T value)
{
if (value != null)
{
accumulator = accumulator == null ? value : Operator <T> .Add(accumulator, value);
return(true);
}
return(false);
}
// Note that I suspect none of these are necessary due to the implicit conversions to and from T... but for symmetry with Datapoint<T1,T2> it was easy to just add them explicitly to save on casts.
public static Datapoint <T> operator +(Datapoint <T> first, Datapoint <T> second)
{
if (typeof(T) == typeof(Quaternion)) // For some reason the simple Operator.Add<Quaternion, Quaternion> fails IN RELEASE MODE ONLY. WTF?!?!?
{
Quaternion fst = Operator.Convert <T, Quaternion>(first.Value);
Quaternion scnd = Operator.Convert <T, Quaternion>(second.Value);
return((Datapoint <T>)Datapoint.From <T>(Operator.Convert <Quaternion, T>(fst + scnd)));
}
return((Datapoint <T>)Operator.Add(first.Value, second.Value));
}
public bool AddIfNotNull(ref T?accumulator, T?value)
{
if (value.HasValue)
{
accumulator = accumulator.HasValue ? Operator <T> .Add(accumulator.GetValueOrDefault(), value.GetValueOrDefault()) : value;
return(true);
}
return(false);
}
public void Multiplication()
{
for (int y = 0; y < dimensions; y++)
{
for (int x = 0; x < dimensions; x++)
{
vectorB[y] = Operator.Add(vectorB[y], Operator.Multiply(matrixA[x, y], vectorX[x]));
}
}
}
// multiplication matrix A and vector X to get vector B
public void ComputeVectorB()
{
for (int y = 0; y < dimensions; y++)
{
for (int x = 0; x < dimensions; x++)
{
B[y] = Operator.Add(B[y], Operator.Multiply(A[x, y], X[x]));
}
}
}
private static T MultiplyRowColumn(int rowIndex, int columnIndex, T[,] firstMatrix, T[,] secondMatrix)
{
T temp = Operator <T> .Zero;
for (var cellIndex = 0; cellIndex < firstMatrix.GetLength(1); cellIndex++)
{
temp = Operator.Add <T>(temp, Operator.Multiply <T>(firstMatrix[rowIndex, cellIndex], secondMatrix[cellIndex, columnIndex]));
}
return(temp);
}
public T CalculateDiff()
{
T sum = Operator.Subtract(VectorX[0], VectorX[0]);
for (int y = 0; y < Dimensions; y++)
{
T diff = Absolute(Operator.Subtract(VectorX[y], VectorB[y]));
sum = Operator.Add(sum, diff);
}
return(sum);
}
