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 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 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 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 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 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 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 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 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 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 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 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 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 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 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));
}
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 WeightedMovingAverageNullableLongTest2()
{
var source = LinqTool.Generate(1, 7, X => Generator.GenerateNullableLong(X, -1));
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).Select(S => S.Value).Round(3).Cast <double?>();
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void CumulativeStdevNullableFloatTest1()
{
IEnumerable <Tuple <string, float?> > source = LinqTool.Generate <Tuple <string, float?> >(1, 5,
X =>
Generator.GenerateNullableFloat(X, 10,
2));
IEnumerable <float?> expected = new float?[] { float.NaN, 1.414f, 1.528f, 1.708f };
IEnumerable <float?> actual;
actual = source.CumulativeStDev(X => X.Item2).Select(V => V.Value).Round(3).Cast <float?>();
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void CumulativeMovingAverageIntTest2()
{
var source = LinqTool.Generate(1, 14, X => Generator.GenerateInt(X));
var expected = LinqTool.Generate(1, 14, X => ((double)X + 1) / 2);
var actual = source.CumulativeMovingAverage(X => X.Item2).ToList();
if (IsDebugEnabled)
{
log.Debug(@"expected=[{0}], actual=[{1}]", expected.CollectionToString(), actual.CollectionToString());
}
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void SequenceGeneratorTest4()
{
IEnumerable <int> expected = new int[] { 1, 4, 9, 16, 25, 36, 49, 64, 81 };
IEnumerable <int> actual = LinqTool.Generate(1, 9, (x) => x * x);
Assert.IsTrue(expected.SequenceEqual(actual));
//------------------------------//
expected = new int[] { 10, 11, 13, 16, 20, 25, 31 };
actual = LinqTool.Generate(10, 7, .5, (x, y, z) => (int)(x + y + z * 2));
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void MovingSumDecimalTest3()
{
var source = LinqTool.Generate(1, 13, X => Generator.GenerateNullableDecimal(X, 2));
const int blockSize = 3;
var expected = new decimal?[] { 4, 7, 12, 15, 18, 21, 24, 27, 30, 33, 36 };
var actual = MathTool.MovingSum(source, blockSize, S => S.Item2);
if (IsDebugEnabled)
{
log.Debug("MovingSum: expected=[{0}], actual=[{1}]", expected.CollectionToString(), actual.CollectionToString());
}
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void StandardMovingAverageNullableFloatTest1()
{
IEnumerable <Tuple <string, float?> > source = LinqTool.Generate(1, 13, X => Generator.GenerateNullableFloat(X, 10, 2));
const int blockSize = 3;
var expected = new float?[] { 2, 3.5f, 4, 5, 6, 7, 8, float.NaN, float.NaN, float.NaN, 12 };
var actual = MathTool.StandardMovingAverage(source, blockSize, S => S.Item2);
if (IsDebugEnabled)
{
log.Debug(@"expected=[{0}], actual=[{1}]", expected.CollectionToString(), actual.CollectionToString());
}
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void StandardMovingAverageNullableIntTest1()
{
var source = LinqTool.Generate(1, 13, X => Generator.GenerateNullableInt(X, 2));
const int blockSize = 3;
var expected = new double?[] { 2, 3.5, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
var actual = MathTool.StandardMovingAverage(source, blockSize, S => S.Item2);
if (IsDebugEnabled)
{
log.Debug(@"expected=[{0}], actual=[{1}]", expected.CollectionToString(), actual.CollectionToString());
}
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void SequenceGeneratorTest10()
{
try {
var source = new bool[] { true, true, true, true };
var actual = LinqTool.Generate(false, 3, true).ToArray();
Assert.Fail();
}
catch (InvalidOperationException) {
//Assert.IsTrue(e.Message == "Generate<T> cannot be invoked using 'Boolean' type, only numeric values are valid.");
}
catch (Exception) {
Assert.Fail();
}
}
public void SequenceGeneratorTest9()
{
double angleX = Math.PI * 45 / 180.0;
IEnumerable <double> expected = new double[]
{
Math.Sin(angleX + .000), Math.Sin(angleX + .004), Math.Sin(angleX + .008),
Math.Sin(angleX + .012), Math.Sin(angleX + .016), Math.Sin(angleX + .020),
Math.Sin(angleX + .024), Math.Sin(angleX + .028), Math.Sin(angleX + .032),
Math.Sin(angleX + .036), Math.Sin(angleX + .040), Math.Sin(angleX + .044)
};
IEnumerable <double> actual = LinqTool.Generate <double>(angleX, .004d, 12, (X) => Math.Sin(X));
Assert.IsTrue(expected.SequenceEqual(actual));
}
