public void ShouldGetItemsByIndex()
{
Vector<int> vector = new ArrayVector<int>(1, 2, 3);
vector[0].ShouldEqual(1);
vector[1].ShouldEqual(2);
vector[2].ShouldEqual(3);
}
public void ShouldProvideItemCount()
{
Vector<int> empty = new ArrayVector<int>();
empty.Count.ShouldEqual(0);
Vector<int> single = new ArrayVector<int>(0);
single.Count.ShouldEqual(1);
}
public void ShouldBeEnumerable()
{
Vector<int> empty = new ArrayVector<int>();
Vector<int> nonempty = new ArrayVector<int>(1, 2, 3);
empty.ShouldBeEmpty();
nonempty.ShouldList(1, 2, 3);
}
public void ShouldAllowTakingAnEmptySliceOfAnEmptySourceVector()
{
//This is a test of the internal SliceVector constructor,
//indirectly since we cannot construct it directly.
Vector<int> empty = new ArrayVector<int>();
empty.Slice(0, 0).ShouldBeEmpty();
}
public void ShouldCreateNewVectorWithNewValueAppended()
{
Vector<int> original = new ArrayVector<int>(1, 2, 3);
original.ShouldList(1, 2, 3);
Vector<int> appended = original.Append(4);
original.ShouldList(1, 2, 3);
appended.ShouldList(1, 2, 3, 4);
}
public void ShouldCreateNewVectorWithAlteredCell()
{
Vector<int> original = new ArrayVector<int>(1, 2, 3);
original.ShouldList(1, 2, 3);
original.With(0, 10).ShouldList(10, 2, 3);
original.With(1, 20).ShouldList(1, 20, 3);
original.With(2, 30).ShouldList(1, 2, 30);
original.ShouldList(1, 2, 3);
}
public void ShouldRemainImmutableEvenWhenSourceArrayIsMutated()
{
var source = new[] {1, 2};
Vector<int> vector = new ArrayVector<int>(source);
vector.ShouldList(1, 2);
source[0] = -1;
source[1] = -2;
vector.ShouldList(1, 2);
}
public void GetRootPowerSumsTest_IntegerFraction()
{
// Representação dos polinómios.
var polynomText = "(x-3)*(x-2)^2*(x+1)^3";
var variableName = "x";
// Estabelece os domínios.
var integerDomain = new IntegerDomain();
// Estabelece o corpo responsável pelas operações sobre as fracções.
var fractionField = new FractionField <int>(integerDomain);
// Estabelece os conversores.
var integerToFractionConversion = new ElementFractionConversion <int>(integerDomain);
// Estabelece os leitores individuais.
var integerParser = new IntegerParser <string>();
// Estabelece o leitor de fracções.
var fractionParser = new ElementFractionParser <int>(integerParser, integerDomain);
// Estabelece os polinómios.
var integerPolynomial = TestsHelper.ReadUnivarPolynomial(
polynomText,
fractionField,
fractionParser,
integerToFractionConversion,
variableName);
var integerFractionExpectedVector = new ArrayVector <Fraction <int> >(6);
integerFractionExpectedVector[0] = new Fraction <int>(4, 1, integerDomain);
integerFractionExpectedVector[1] = new Fraction <int>(20, 1, integerDomain);
integerFractionExpectedVector[2] = new Fraction <int>(40, 1, integerDomain);
integerFractionExpectedVector[3] = new Fraction <int>(116, 1, integerDomain);
integerFractionExpectedVector[4] = new Fraction <int>(304, 1, integerDomain);
integerFractionExpectedVector[5] = new Fraction <int>(860, 1, integerDomain);
var integerFractionActualVector = integerPolynomial.GetRootPowerSums(
fractionField,
new SparseDictionaryMathVectorFactory <Fraction <int> >());
Assert.AreEqual(
integerFractionExpectedVector.Length,
integerFractionActualVector.Length,
"Vector lengths aren't equal.");
for (int i = 0; i < integerFractionActualVector.Length; ++i)
{
Assert.AreEqual(integerFractionExpectedVector[i], integerFractionActualVector[i]);
}
}
public void ShouldThrowExceptionWhenGivenIndexIsOutOfRange()
{
Vector<int> empty = new ArrayVector<int>();
var actions = new Action[]
{
() => empty.With(0, 0),
() => empty.With(-1, -1),
() => { int value = empty[0]; },
() => { int value = empty[-1]; }
};
foreach (var action in actions)
action.ShouldThrow<IndexOutOfRangeException>("Index was outside the bounds of the vector.");
}
public static double stdGetGroup(ICanGetProperty data, double avg, int start, int count, int grouplength)
{
int a = (int)(count / grouplength);
if (a < 1)
{
throw new Exception("子组容量过大");
}
if (grouplength < 1)
{
throw new Exception("子组大小必须大于0");
}
if (grouplength >= StandardConst.D2.Length || grouplength > count)
{
throw new Exception("子组容量过大");
}
ArrayVector std = new ArrayVector(a);
int s = start;
double result = 0;
ArrayVector gavg = new ArrayVector(a);
for (int i = 0; i < a; i++)
{
int j = s;
for (int c = 0; c < grouplength; j++)
{
double?temp = data[j];
if (temp != null)
{
gavg.Data[i] += (double)temp / grouplength;
c++;
}
}
gavg.AVG += gavg.Data[i] / a;
std.Data[i] = STDEV.GetEntirety(data, gavg.Data[i], s, grouplength);
std.AVG += std.Data[i] / a;
s = j;
}
std.AVG = std.AVG / StandardConst.C4[(int)grouplength];
//double rbar = (std.data[1] - std.data[0]) / StandardConst.D2[2];
//double rbar = GetAvgMovingRangeXBar(data, start, count);
//bgstd =Math.Max(0, Math.Pow(Math.Pow(rbar,2) - Math.Pow(std.AVG,2)/a,0.5));
//result = Math.Pow(Math.Pow(bgstd, 2) + Math.Pow(std.AVG, 2), 0.5);
result = std.AVG;
return(result);
}
public IVector <T> Build <T>(IVecConstructionCmd vectorConstruction, IVector <T>[] vectors)
{
if (vectorConstruction.GetType() == typeof(Return))
{
var vcReturn = (Return)vectorConstruction;
return(vectors[vcReturn.VectorLocation]);
}
else if (vectorConstruction.GetType() == typeof(Combine))
{
var combine = (Combine)vectorConstruction;
var data = combine.VecConstructionCmds.Select(vc => (IVector)VectorBuilderInstance.Build(vc, vectors)).ToArray();
var frameData = VectorBuilderInstance.Create(data);
var rowReaders = new object[combine.Size];
for (long i = 0; i < combine.Size; i++)
{
rowReaders[i] = new RowReaderVector <object>(frameData, VectorBuilderInstance, i);
}
var objVec = new ArrayVector <object>(new ArrayVectorData <object>(rowReaders));
//var objectSeq = new ObjectSequence<T>(objVec);
return(Vector.unboxVector <T>(objVec, VectorBuilderInstance));
}
else if (vectorConstruction.GetType() == typeof(GetRange))
{
var cmd = (GetRange)vectorConstruction;
//TODO
var range = (IntervalOf <Int64>)cmd.RangeBoundary;
var newVecData = this.buildArrayVector(cmd.VecConstructionCmd, vectors);
var newData = new T[(range.End - range.Start + 1)];
long idx = 0;
for (long i = range.Start; i <= range.End; i++)
{
newData[idx] = newVecData[i];
idx++;
}
return(new ArrayVector <T>(new ArrayVectorData <T>(newData)));
}
else
{
return(null);
}
}
public void GetRootPowerSumsTest_Integer()
{
// Representação dos polinómios.
var polynomText = "(x-3)*(x-2)^2*(x+1)^3";
var variableName = "x";
// Estabelece os domínios.
var integerDomain = new IntegerDomain();
// Estabelece os conversores.
var integerToIntegerConv = new ElementToElementConversion <int>();
// Estabelece os leitores individuais.
var integerParser = new IntegerParser <string>();
// Estabelece os polinómios.
var integerPolynomial = TestsHelper.ReadUnivarPolynomial(
polynomText,
integerDomain,
integerParser,
integerToIntegerConv,
variableName);
var integerExpectedVector = new ArrayVector <int>(6);
integerExpectedVector[0] = 4;
integerExpectedVector[1] = 20;
integerExpectedVector[2] = 40;
integerExpectedVector[3] = 116;
integerExpectedVector[4] = 304;
integerExpectedVector[5] = 860;
var integerActualVector = integerPolynomial.GetRootPowerSums(integerDomain);
Assert.AreEqual(integerExpectedVector.Length, integerActualVector.Length, "Vector lengths aren't equal.");
for (int i = 0; i < integerActualVector.Length; ++i)
{
Assert.AreEqual(integerExpectedVector[i], integerActualVector[i]);
}
}
private static Vector<int> SliceDigits(int startIndexInclusive, int endIndexExclusive)
{
var digits = new ArrayVector<int>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
return digits.Slice(startIndexInclusive, endIndexExclusive);
}
public void ShouldCreateSlices()
{
Vector<int> slice = new ArrayVector<int>(0, 1, 2, 3, 4, 5, 6).Slice(1, 6);
slice.ShouldList(1, 2, 3, 4, 5);
}
public void GetRootPowerSumsTest()
{
// Representação dos polinómios.
var polynomText = "(x-3)*(x-2)^2*(x+1)^3";
var variableName = "x";
// Estabelece os domínios.
var integerDomain = new IntegerDomain();
// Estabelece o corpo responsável pelas operações sobre as fracções.
var fractionField = new FractionField <int>(integerDomain);
// Estabelece os conversores.
var integerToFractionConversion = new ElementFractionConversion <int>(integerDomain);
// Estabelece os leitores individuais.
var integerParser = new IntegerParser <string>();
// Estabelece o leitor de fracções.
var fractionParser = new ElementFractionParser <int>(integerParser, integerDomain);
// Estabelece os polinómios.
var integerPolynomial = TestsHelper.ReadUnivarPolynomial(
polynomText,
fractionField,
fractionParser,
integerToFractionConversion,
variableName);
var number = 10;
var roots = new int[] { 3, 2, 2, -1, -1, -1 };
var powerRoots = new int[] { 3, 2, 2, -1, -1, -1 };
var integerFractionExpectedVector = new ArrayVector <Fraction <int> >(number);
// Primeiro cálculo
var sum = powerRoots[0];
for (int i = 1; i < powerRoots.Length; ++i)
{
sum += powerRoots[i];
}
integerFractionExpectedVector[0] = new Fraction <int>(sum, 1, integerDomain);
for (int i = 1; i < number; ++i)
{
for (int j = 0; j < roots.Length; ++j)
{
powerRoots[j] *= roots[j];
}
sum = powerRoots[0];
for (int j = 1; j < powerRoots.Length; ++j)
{
sum += powerRoots[j];
}
integerFractionExpectedVector[i] = new Fraction <int>(sum, 1, integerDomain);
}
var integerFractionActualVector = integerPolynomial.GetRootPowerSums(
number,
fractionField,
new SparseDictionaryMathVectorFactory <Fraction <int> >());
Assert.AreEqual(
integerFractionExpectedVector.Length,
integerFractionActualVector.Length,
"Vector lengths aren't equal.");
for (int i = 0; i < integerFractionActualVector.Length; ++i)
{
Assert.AreEqual(integerFractionExpectedVector[i], integerFractionActualVector[i]);
}
}
