public void SequenceGeneratorTest7()
{
IEnumerable <decimal> expected = new decimal[] { 1, 3, 5, 7, 9, 11 };
IEnumerable <decimal> actual = LinqTool.Generate(1m, 6, 2);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void SubtractNullableDoubleTest()
{
var leftSequence = new double?[] { 2, 4, 6, 8, 10 };
var rightSequence = new double?[] { 1, 2, 3, 4, 5 };
var expected = new double?[] { 1, 2, 3, 4, 5 };
var actual = LinqTool.Subtract(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
leftSequence = new double?[] { 2, 4, 6, double.NaN, double.PositiveInfinity };
rightSequence = new double?[] { 1, 2, 3, 4, 5 };
expected = new double?[] { 1, 2, 3, double.NaN, double.PositiveInfinity };
actual = LinqTool.Subtract(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
leftSequence = new double?[] { 2, 4, 6, double.NaN, double.PositiveInfinity };
rightSequence = new double?[] { 1, null, 3, 4, 5 };
expected = new double?[] { 1, null, 3, double.NaN, double.PositiveInfinity };
actual = LinqTool.Subtract(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void DivideIntTest()
{
var leftSequence = new int[] { 1, 2, 3, 4, 5 };
var rightSequence = new int[] { 1, 2, 3, 4, 5 };
var expected = new int[] { 1, 1, 1, 1, 1 };
var actual = LinqTool.Divide(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
try {
leftSequence = new int[] { 1, 2, 3, 4, 5 };
rightSequence = new int[] { 1, 0, 3, 4, 5 };
expected = new int[] { 1, 1, 1, 1, 1 };
actual = LinqTool.Divide(leftSequence, rightSequence);
int x = actual.Count();
Assert.Fail();
}
catch (DivideByZeroException) {}
catch (Exception) {
Assert.Fail();
}
}
public void AddNullableFloatTest()
{
var leftSequence = new float?[] { 1, 2, 3, 4, 5 };
var rightSequence = new float?[] { 1, 2, 3, 4, 5 };
var expected = new float?[] { 2, 4, 6, 8, 10 };
var actual = LinqTool.Add(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
leftSequence = new float?[] { 1, 2, 3, float.NaN, float.PositiveInfinity };
rightSequence = new float?[] { 1, 2, 3, 4, 5 };
expected = new float?[] { 2, 4, 6, float.NaN, float.PositiveInfinity };
actual = LinqTool.Add(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
leftSequence = new float?[] { 1, null, 3, float.NaN, float.PositiveInfinity };
rightSequence = new float?[] { 1, 2, 3, 4, 5 };
expected = new float?[] { 2, null, 6, float.NaN, float.PositiveInfinity };
actual = LinqTool.Add(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void SequenceGeneratorTest11()
{
IEnumerable <DateTime> expected = new DateTime[]
{
new DateTime(2011, 1, 1, 0, 0, 0),
new DateTime(2011, 1, 2, 0, 0, 0),
new DateTime(2011, 1, 3, 0, 0, 0),
new DateTime(2011, 1, 4, 0, 0, 0),
new DateTime(2011, 1, 5, 0, 0, 0),
new DateTime(2011, 1, 6, 0, 0, 0)
};
IEnumerable <DateTime> actual = LinqTool.Generate(new DateTime(2011, 1, 1, 0, 0, 0), 6, new TimeSpan(24, 0, 0));
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
try {
DateTime[] actualRes = LinqTool.Generate(new DateTime(2011, 1, 1, 0, 0, 0), 6, TimeSpan.Zero).ToArray();
Assert.IsTrue(expected.SequenceEqual(actual));
}
catch (ArgumentOutOfRangeException) {}
catch (InvalidOperationException) {}
catch (Exception) {
Assert.Fail();
}
}
public void RangeTest2()
{
IEnumerable <double> expected = new double[] { 1.25, 2.5, 3.75, 5, 6.25, 7.5 };
IEnumerable <double> actual = LinqTool.Range(1.25, 7.555, 1.25);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void SequenceGeneratorTest5()
{
IEnumerable <double> expected = new double[] { 1, 3, 5, 7, 9, 11 };
IEnumerable <double> actual = LinqTool.Generate(1d, 6, 2);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void MultiplyNullableFloatTest()
{
var leftSequence = new float?[] { 1, 2, 3, 4, 5 };
var rightSequence = new float?[] { 1, 2, 3, 4, 5 };
var expected = new float?[] { 1, 4, 9, 16, 25 };
var actual = LinqTool.Multiply(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
leftSequence = new float?[] { 1, 2, 3, float.NaN, float.PositiveInfinity };
rightSequence = new float?[] { 1, 2, 3, 4, 5 };
expected = new float?[] { 1, 4, 9, float.NaN, float.PositiveInfinity };
actual = LinqTool.Multiply(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
leftSequence = new float?[] { 1, null, 3, float.NaN, float.PositiveInfinity };
rightSequence = new float?[] { 1, 2, 3, 4, 5 };
expected = new float?[] { 1, null, 9, float.NaN, float.PositiveInfinity };
actual = LinqTool.Multiply(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void RepeatTest()
{
IEnumerable <int> expected = new int[] { 1, 1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3, 1, 1, 2, 3 };
IEnumerable <int> actual = LinqTool.Repeat(new int[] { 1, 1, 2, 3 }, 4);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void DivideFloatTest()
{
var leftSequence = new float[] { 1, 2, 3, 4, 5 };
var rightSequence = new float[] { 1, 2, 3, 4, 5 };
var expected = new float[] { 1, 1, 1, 1, 1 };
var actual = LinqTool.Divide(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
leftSequence = new float[] { 1, 2, 3, float.NaN, float.PositiveInfinity };
rightSequence = new float[] { 1, 2, 3, 4, 5 };
expected = new float[] { 1, 1, 1, float.NaN, float.PositiveInfinity };
actual = LinqTool.Divide(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
leftSequence = new float[] { 1, 2, 3, float.NaN, float.PositiveInfinity };
rightSequence = new float[] { 1, 0, 3, 4, 5 };
expected = new float[] { 1, float.PositiveInfinity, 1, float.NaN, float.PositiveInfinity };
actual = LinqTool.Divide(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void SequenceGeneratorTest8()
{
IEnumerable <long> expected = new long[] { 1, 3, 5, 7, 9, 11 };
IEnumerable <long> actual = LinqTool.Generate(1L, 6, 2);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void SequenceGeneratorTest6()
{
IEnumerable <float> expected = new float[] { 1, 3, 5, 7, 9, 11 };
IEnumerable <float> actual = LinqTool.Generate(1f, 6, 2);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void RangeTest1()
{
IEnumerable <int> expected = new int[] { 1, 3, 5, 7, 9, 11 };
IEnumerable <int> actual = LinqTool.Range(1, 12, 2);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void VarianceWithBlock_Int_Test(double seed, double step, int count)
{
var source = LinqTool.Generate(1, 5, x => Generator.GenerateInt(x));
var expected = new double[] { 2.5 };
var actual = source.Variance(5, x => x.Item2).Round(3);
if (IsDebugEnabled)
{
log.Debug("Variance with Block=[{0}]", actual.CollectionToString());
}
actual.SequenceEqual(expected).Should().Be.True();
//------------------------------------------------------
source = LinqTool.Generate(1, 7, x => Generator.GenerateInt(x));
expected = new double[] { 2.5, 2.5, 2.5 };
actual = source.Variance(5, x => x.Item2).Round(3);
if (IsDebugEnabled)
{
log.Debug("Variance with Block=[{0}]", actual.CollectionToString());
}
actual.SequenceEqual(expected).Should().Be.True();
}
public void SequenceGeneratorTest2()
{
var expected = new decimal[] { .03m, .04m, .05m, .06m, .07m, .08m, .09m };
const decimal factor = .01m;
var actual = LinqTool.Generate(3, 7, (x) => x * factor);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void StandardMovingAverageNullableDoubleTest1()
{
var source = LinqTool.Generate(1, 13, X => Generator.GenerateNullableDouble(X, 10, 2));
const int blockSize = 3;
var expected = new double?[] { 2, 3.5, 4, 5, 6, 7, 8, double.NaN, double.NaN, double.NaN, 12 };
IEnumerable <double?> actual = MathTool.StandardMovingAverage(source, blockSize, S => S.Item2);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void CumulativeStdevNullableIntTest1()
{
IEnumerable <Tuple <string, int?> > source = LinqTool.Generate(1, 5, X => Generator.GenerateNullableInt(X, 20));
IEnumerable <double?> expected = new double?[] { 0.707, 1.000, 1.291, 1.581 };
IEnumerable <double?> actual;
actual = source.CumulativeStDev(X => X.Item2).Select(V => V.Value).Round(3).Cast <double?>();
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void CumulativeStdevFloatTest1()
{
IEnumerable <Tuple <string, float> > source = LinqTool.Generate(1, 5, X => Generator.GenerateFloat(X, 10));
IEnumerable <float> expected = new float[] { .707f, 1, 1.291f, 1.581f };
IEnumerable <float> actual;
actual = source.CumulativeStDev(X => X.Item2).Round(3);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void StdevDoubleTest2()
{
IEnumerable <Tuple <string, double> > source = LinqTool.Generate <Tuple <string, double> >(7, X => Generator.GenerateDouble(X, 10));
double expected = 2.160;
double actual;
actual = Math.Round(source.StDev(X => X.Item2), 3);
Assert.IsTrue(expected.Equals(actual));
}
public void StdevDecimalTest2()
{
IEnumerable <Tuple <string, decimal> > source = LinqTool.Generate <Tuple <string, decimal> >(7, X => Generator.GenerateDecimal(X));
decimal expected = 2.160m;
decimal actual;
actual = (decimal)Math.Round(source.StDev(X => X.Item2), 3);
Assert.IsTrue(expected.Equals(actual));
}
public void StdevFloatTest2()
{
IEnumerable <Tuple <string, float> > source = LinqTool.Generate <Tuple <string, float> >(7, X => Generator.GenerateFloat(X, 10));
float expected = 2.160f;
float actual;
actual = (float)Math.Round(source.StDev(X => X.Item2), 3);
Assert.IsTrue(expected.Equals(actual));
}
public void MovingSumDecimalTest2()
{
var source = LinqTool.Generate(1, 13, X => Generator.GenerateDecimal(X));
const int blockSize = 3;
var expected = new decimal[] { 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36 };
IEnumerable <decimal> actual = MathTool.MovingSum(source, blockSize, S => S.Item2);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void CumulativeStdevNullableDoubleTest1()
{
IEnumerable <Tuple <string, double?> > source = LinqTool.Generate(1, 5, X => Generator.GenerateNullableDouble(X, 10, 2));
IEnumerable <double?> expected = new double?[] { double.NaN, 1.414, 1.528, 1.708 };
IEnumerable <double?> actual;
actual = source.CumulativeStDev(X => X.Item2).Select(V => V.Value).Round(3).Cast <double?>();
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void CumulativeStdevIntTest1()
{
IEnumerable <Tuple <string, int> > source = LinqTool.Generate(1, 5, X => Generator.GenerateInt(X));
IEnumerable <double> expected = new double[] { .707, 1, 1.291, 1.581 };
IEnumerable <double> actual;
actual = source.CumulativeStDev(X => X.Item2).Round(3);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void CumulativeStdevDecimalTest1()
{
IEnumerable <Tuple <string, decimal> > source = LinqTool.Generate(1, 5, X => Generator.GenerateDecimal(X));
IEnumerable <decimal> expected = new decimal[] { .707m, 1, 1.291m, 1.581m };
IEnumerable <decimal> actual;
actual = source.CumulativeStDev(X => X.Item2).Round(3);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void MultiplyIntTest()
{
var leftSequence = new int[] { 1, 2, 3, 4, 5 };
var rightSequence = new int[] { 1, 2, 3, 4, 5 };
var expected = new int[] { 1, 4, 9, 16, 25 };
var actual = LinqTool.Multiply(leftSequence, rightSequence);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void StdevIntLongTest2()
{
IEnumerable <Tuple <string, int?> > source = LinqTool.Generate <Tuple <string, int?> >(7,
X => Generator.GenerateNullableInt(X, 10));
double?expected = 2.160;
double?actual;
actual = (double?)Math.Round(source.StDev(X => X.Item2).Value, 3);
Assert.IsTrue(expected.Equals(actual));
}
public void WeightedMovingAverageDecimalTest2()
{
var source = LinqTool.Generate(1, 7, X => Generator.GenerateDecimal(X));
var expected = new decimal[] { 2.571m, 3.571m, 4.571m, 5.571m, 6.571m };
const int blockSize = 3;
IEnumerable <decimal> actual = source.WeightedMovingAverage(blockSize, DecimalWeightGen, I => I.Item2).Round(3);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void WeightedMovingAverageFloatTest2()
{
var source = LinqTool.Generate(1, 7, X => Generator.GenerateFloat(X, -1));
var expected = new float[] { 2.571f, 3.571f, 4.571f, 5.571f, 6.571f };
const int blockSize = 3;
var actual = source.WeightedMovingAverage(blockSize, FloatWeightGen, I => I.Item2).Round(3);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void WeightedMovingAverageIntTest2()
{
var source = LinqTool.Generate(1, 7, X => Generator.GenerateInt(X));
var expected = new double[] { 2.571, 3.571, 4.571, 5.571, 6.571 };
const int blockSize = 3;
var actual = source.WeightedMovingAverage(blockSize, DoubleWeightGen, I => I.Item2).Round(3);
Assert.IsTrue(expected.SequenceEqual(actual));
}
