public void RunTest()
{
var inputMatrix = "[[1,2,1],[2,-1,-1],[1,-1,3]]";
var inputVector = "[[1,2,3]]";
var expectedText = "[[21/19,-6/19,10/19]]";
var integerDomain = new BigIntegerDomain();
var integerParser = new BigIntegerParser <string>();
var fractionField = new FractionField <BigInteger>(integerDomain);
var fractionFieldParser = new FieldDrivenExpressionParser <Fraction <BigInteger> >(
new SimpleElementFractionParser <BigInteger>(integerParser, integerDomain),
fractionField);
var matrixFactory = new ArrayMathMatrixFactory <Fraction <BigInteger> >();
// Leitura da matriz que representa o sistema de equações.
var coeffsMatrix = TestsHelper.ReadMatrix <Fraction <BigInteger> >(
3,
3,
inputMatrix,
(i, j) => new ArrayMathMatrix <Fraction <BigInteger> >(i, j),
fractionFieldParser);
// Leitura do vector de termos independente.
var vectorMatrix = TestsHelper.ReadMatrix <Fraction <BigInteger> >(
3,
1,
inputVector,
(i, j) => new ArrayMathMatrix <Fraction <BigInteger> >(i, j),
fractionFieldParser);
var expectedMatrix = TestsHelper.ReadMatrix <Fraction <BigInteger> >(
3,
1,
expectedText,
(i, j) => new ArrayMathMatrix <Fraction <BigInteger> >(i, j),
fractionFieldParser);
var systemSolver = new SequentialLanczosAlgorithm <Fraction <BigInteger>, FractionField <BigInteger> >(
matrixFactory,
fractionField);
var squareMatrix = (coeffsMatrix as ArrayMathMatrix <Fraction <BigInteger> >).AsSquare();
var actual = systemSolver.Run(squareMatrix, vectorMatrix);
for (int i = 0; i < 3; ++i)
{
Assert.AreEqual(expectedMatrix[i, 0], actual[i, 0]);
}
}
public void RunTest()
{
var coefficientsMatrixText = "[[1,0,0],[0,0,0],[0,3,3],[2,0,1]]";
var independentVectorText = "[[1,3,3]]";
var expectedText = "[[1,0,1,0]]";
var integerDomain = new IntegerDomain();
var integerParser = new IntegerParser <string>();
var fractionField = new FractionField <int>(integerDomain);
var fractionFieldParser = new FieldDrivenExpressionParser <Fraction <int> >(
new SimpleElementFractionParser <int>(integerParser, integerDomain),
fractionField);
var matrixFactory = new ArrayMatrixFactory <Fraction <int> >();
// Leitura da matriz que representa o sistema de equações.
var coeffsMatrix = TestsHelper.ReadMatrix <Fraction <int> >(
3,
4,
coefficientsMatrixText,
matrixFactory,
fractionFieldParser);
// Leitura do vector de termos independente.
var vectorMatrix = TestsHelper.ReadMatrix <Fraction <int> >(
3,
1,
independentVectorText,
new ArrayMatrixFactory <Fraction <int> >(),
fractionFieldParser);
var expectedMatrixVector = TestsHelper.ReadMatrix <Fraction <int> >(
4,
1,
expectedText,
matrixFactory,
fractionFieldParser);
var algorithm = new DenseCondensationLinSysAlgorithm <Fraction <int> >(fractionField);
var actual = algorithm.Run(coeffsMatrix, vectorMatrix);
Assert.AreEqual(expectedMatrixVector.GetLength(0), actual.Vector.Length);
for (int i = 0; i < actual.Vector.Length; ++i)
{
Assert.AreEqual(expectedMatrixVector[i, 0], actual.Vector[i]);
}
}
public void RunTest()
{
var mainPolText = "x^3+10*x^2-432*x+5040";
var firstFactorText = "x";
var secondFactorText = "x^2-2";
var variableName = "x";
var prime = 5;
var integerDomain = new IntegerDomain();
var integerParser = new IntegerParser <string>();
var integerConversion = new ElementToElementConversion <int>();
var mainPol = TestsHelper.ReadUnivarPolynomial(
mainPolText,
integerDomain,
integerParser,
integerConversion,
variableName);
var firstFactor = TestsHelper.ReadUnivarPolynomial(
firstFactorText,
integerDomain,
integerParser,
integerConversion,
variableName);
var secondFactor = TestsHelper.ReadUnivarPolynomial(
secondFactorText,
integerDomain,
integerParser,
integerConversion,
variableName);
// Testa o levantamento linear.
var linearLift = new LinearLiftAlgorithm <int>(
new ModularSymmetricIntFieldFactory(),
new UnivarPolEuclideanDomainFactory <int>(),
integerDomain);
var liftingStatus = new LinearLiftingStatus <int>(mainPol, firstFactor, secondFactor, prime);
var result = linearLift.Run(liftingStatus, 3);
Assert.AreEqual(625, liftingStatus.LiftedFactorizationModule);
var expected = liftingStatus.UFactor.Multiply(liftingStatus.WFactor, new ModularIntegerField(625));
var actual = mainPol.ApplyFunction(coeff => this.GetSymmetricRemainder(coeff, 625), integerDomain);
Assert.AreEqual(expected, actual);
}
public void RunTest_TestFactors2()
{
var polText = "x^3+2";
var variableName = "x";
var prime = 5;
var integerDomain = new IntegerDomain();
var integerParser = new IntegerParser <string>();
var integerConversion = new ElementToElementConversion <int>();
// Faz a leitura do polinómio.
var pol = TestsHelper.ReadUnivarPolynomial(
polText,
integerDomain,
integerParser,
integerConversion,
variableName);
// Testa os factores.
var integerModule = new ModularIntegerField(prime);
var finiteFieldPolAlg = new FiniteFieldPolFactorizationAlgorithm <int>(
new DenseCondensationLinSysAlgorithm <int>(integerModule),
integerDomain);
var result = finiteFieldPolAlg.Run(pol, integerModule);
var factorsEnumerator = result.Factors.GetEnumerator();
if (factorsEnumerator.MoveNext())
{
var expected = factorsEnumerator.Current;
while (factorsEnumerator.MoveNext())
{
expected = expected.Multiply(factorsEnumerator.Current, integerModule);
}
expected = expected.Multiply(result.IndependentCoeff, integerModule);
Assert.AreEqual(expected, pol.ApplyFunction(coeff => this.GetSymmetricRemainder(coeff, prime), integerModule));
}
else
{
Assert.Fail("At least the main polynomial may be regarded as a factor.");
}
}
public void RunTest_BigIntegerMatrix()
{
// A leitura é realizada por colunas.
var matrixText = "[[100000,1001,20005], [32534,4245341,56134513451], [21346136,1134613,1136135613]]";
var integerDomain = new BigIntegerDomain();
var variableName = "x";
var integerParser = new BigIntegerParser <string>();
var conversion = new BigIntegerToIntegerConversion();
var matrix = TestsHelper.ReadMatrix <BigInteger>(
3,
3,
matrixText,
(i, j) => new ArraySquareMathMatrix <BigInteger>(i),
integerParser);
var fastDivFreeCharacPolAlg = new FastDivisionFreeCharPolynomCalculator <BigInteger>(variableName, integerDomain);
var expected = TestsHelper.ReadUnivarPolynomial("1*x^3+-1140480954*x^2-58754054577367644*x+4689162494877443109176", integerDomain, integerParser, conversion, variableName);
var actual = fastDivFreeCharacPolAlg.Run(matrix as ISquareMathMatrix <BigInteger>);
Assert.AreEqual(expected, actual);
}
public void RunTest_IntegerMatrix()
{
// A leitura é realizada por colunas.
var matrixText = "[[1,-1,2], [3,4,5], [2,1,1]]";
var integerDomain = new IntegerDomain();
var variableName = "x";
var integerParser = new IntegerParser <string>();
var conversion = new ElementToElementConversion <int>();
var matrix = TestsHelper.ReadMatrix <int>(
3,
3,
matrixText,
(i, j) => new ArraySquareMathMatrix <int>(i),
integerParser,
true);
var fastDivFreeCharacPolAlg = new FastDivisionFreeCharPolynomCalculator <int>(variableName, integerDomain);
var expected = TestsHelper.ReadUnivarPolynomial("x^3-6*x^2+3*x+18", integerDomain, integerParser, conversion, variableName);
var actual = fastDivFreeCharacPolAlg.Run(matrix as ISquareMathMatrix <int>);
Assert.AreEqual(expected, actual);
}
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]);
}
}
public void GetElementarySymmetricRepresentationTest()
{
var domain = new IntegerDomain();
var coeffsParser = new IntegerParser <string>();
var conversion = new ElementToElementConversion <int>();
var dictionary = new Dictionary <int, int>();
dictionary.Add(5, 2);
dictionary.Add(0, 2);
var varDictionary = new Dictionary <int, Tuple <bool, string, int> >();
varDictionary.Add(1, Tuple.Create(true, "s[1]", 0));
var symmetric = new SymmetricPolynomial <int>(
new List <string>()
{
"x", "y", "z", "w"
},
dictionary,
1,
domain);
var rep = symmetric.GetElementarySymmetricRepresentation(varDictionary, new IntegerDomain());
var expanded = rep.GetExpanded(domain);
var expectedPolText = "5*s4^2*s2+-5*s4*s2^3+5*s4*s3^2+5*s2^2*s3^2+1*s2^5";
var expected = TestsHelper.ReadPolynomial(
expectedPolText,
domain,
conversion,
coeffsParser);
Assert.AreEqual(expected, expanded);
}
public void FeedFrowardNeuralNetwork_InternalComputeOutputs()
{
var target = new FeedForwardNeuralNetwork <double>(
new[] { 2L, 3L, 2L });
var parser = new DoubleParser <string>();
var matrix = TestsHelper.ReadMatrix(
5,
5,
"[[-1.0, 1.0, 0.5, 0, 0], [1.0, -1.0, 0.5, 0, 0], [0, 0, 0, -1.0, 2.0], [0, 0, 0, 0.5, -1.5], [0, 0, 0, 1.0, -0.5]]",
(i, j) => new SparseDictionaryMatrix <double>(i, j, 0),
parser,
true);
var vector = TestsHelper.ReadVector(
5,
"[0.5, 0.5, 0.5, 0.5, 0.5]",
new SparseDictionaryMathVectorFactory <double>(),
parser,
true);
var model = new NeuralNetworkModel <double, SparseDictionaryMatrix <double>, IMathVector <double> >(
matrix,
vector);
target.LoadModel(model);
var outputMatrix = target.InternalReserveOutput();
target.InternalComputeLayerOutputs(
new ArrayMathVector <double>(new[] { 1.0, -1.0 }),
outputMatrix,
(d1, d2) =>
{
if (d2 > d1)
{
return(1.0);
}
else
{
return(0.0);
}
},
(u, v, l) =>
{
var result = 0.0;
for (var i = 0L; i < l; ++i)
{
result += u[i] * v[i];
}
return(result);
});
Assert.AreEqual(target.Schema.LongCount() - 1L, outputMatrix.LongLength);
var currOut = outputMatrix[0];
Assert.AreEqual(0.0, currOut[0]);
Assert.AreEqual(1.0, currOut[1]);
Assert.AreEqual(0.0, currOut[2]);
currOut = outputMatrix[1];
Assert.AreEqual(0.0, currOut[0]);
Assert.AreEqual(0.0, currOut[1]);
}
public void FeedFrowardNeuralNetwork_RunSimpleMatrixTest()
{
var target = new FeedForwardNeuralNetwork <double>(
new[] { 2L, 3L, 2L });
var parser = new DoubleParser <string>();
var matrix = TestsHelper.ReadMatrix(
5,
5,
"[[-1.0, 1.0, 0.5, 0, 0], [1.0, -1.0, 0.5, 0, 0], [0, 0, 0, -1.0, 2.0], [0, 0, 0, 0.5, -1.5], [0, 0, 0, 1.0, -0.5]]",
(i, j) => new SparseDictionaryMatrix <double>(i, j, 0),
parser,
true);
var vector = TestsHelper.ReadVector(
5,
"[0.5, 0.5, 0.5, 0.5, 0.5]",
new SparseDictionaryMathVectorFactory <double>(),
parser,
true);
var model = new NeuralNetworkModel <double, SparseDictionaryMatrix <double>, IMathVector <double> >(
matrix,
vector);
target.LoadModel(model);
var actual = target.Run(
new[] { 1.0, 0.0 },
(u, v, l) =>
{
var result = 0.0;
for (var i = 0L; i < l; ++i)
{
result += u[i] * v[i];
}
return(result);
},
(d1, d2) =>
{
if (d2 > d1)
{
return(1.0);
}
else
{
return(0.0);
}
});
var expected = new[] { 0.0, 0.0 };
CollectionAssert.AreEqual(expected, actual);
actual = target.Run(
new[] { 0.0, 1.0 },
(u, v, l) =>
{
var result = 0.0;
for (var i = 0L; i < l; ++i)
{
result += u[i] * v[i];
}
return(result);
},
(d1, d2) =>
{
if (d2 > d1)
{
return(1.0);
}
else
{
return(0.0);
}
});
expected = new[] { 0.0, 1.0 };
CollectionAssert.AreEqual(expected, actual);
actual = target.Run(
new[] { 1.0, -1.0 },
(u, v, l) =>
{
var result = 0.0;
for (var i = 0L; i < l; ++i)
{
result += u[i] * v[i];
}
return(result);
},
(d1, d2) =>
{
if (d2 > d1)
{
return(1.0);
}
else
{
return(0.0);
}
});
expected = new[] { 0.0, 0.0 };
CollectionAssert.AreEqual(expected, actual);
}
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]);
}
}
public void PowerTest_FractionPolynomial()
{
var integerDomain = new IntegerDomain();
var longDomain = new LongDomain();
var bigIntegerDomain = new BigIntegerDomain();
var variableName = "x";
var integerPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <int> >(
variableName,
new FractionField <int>(integerDomain));
var longPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <long> >(
variableName,
new FractionField <long>(longDomain));
var bigIntegerPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <BigInteger> >(
variableName,
new FractionField <BigInteger>(bigIntegerDomain));
// Leitores
var integerParser = new IntegerParser <string>();
var longParser = new LongParser <string>();
var bigIntegerParser = new BigIntegerParser <string>();
var integerConversion = new OuterElementFractionConversion <int, int>(new ElementToElementConversion <int>(), integerDomain);
var longToIntegerConversion = new OuterElementFractionConversion <int, long>(new LongToIntegerConversion(), longDomain);
var bigIntegerToIntegerConversion = new OuterElementFractionConversion <int, BigInteger>(new BigIntegerToIntegerConversion(), bigIntegerDomain);
var intPowers = new int[3] {
2, 3, 4
};
var longPowers = new long[3] {
2, 3, 4
};
var bigIntPowers = new BigInteger[3] {
2, 3, 4
};
var polynomialsTexts = new string[3] {
"1/3*x^3-2/3*x^2+3/2*x-1/2", "2*x^2+4/3*x+4/9", "7/5*x+1"
};
var expectedPolinomialsTexts = new string[3] {
"1/9*x^6-4/9*x^5+13/9*x^4-7/3*x^3+35/12*x^2-3/2*x+1/4",
"8*x^6+16*x^5+16*x^4+256/27*x^3+32/9*x^2+64/81*x+64/729",
"2401/625*x^4+1372/125*x^3+294/25*x^2+28/5*x+1"
};
// Coeficientes inteiros.
for (int i = 0; i < 3; ++i)
{
var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol(
polynomialsTexts[i],
integerDomain,
integerParser,
integerConversion,
variableName);
var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol(
expectedPolinomialsTexts[i],
integerDomain,
integerParser,
integerConversion,
variableName);
var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], integerPolynomialField);
Assert.AreEqual(expectedPolynomial, actualPolynomial);
}
// Coeficientes longos.
for (int i = 0; i < 3; ++i)
{
var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol(
polynomialsTexts[i],
longDomain,
longParser,
longToIntegerConversion,
variableName);
var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol(
expectedPolinomialsTexts[i],
longDomain,
longParser,
longToIntegerConversion,
variableName);
var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], longPolynomialField);
Assert.AreEqual(expectedPolynomial, actualPolynomial);
}
// Coeficientes correspondentes a inteiros de precisão arbitrária.
for (int i = 0; i < 3; ++i)
{
var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol(
polynomialsTexts[i],
bigIntegerDomain,
bigIntegerParser,
bigIntegerToIntegerConversion,
variableName);
var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol(
expectedPolinomialsTexts[i],
bigIntegerDomain,
bigIntegerParser,
bigIntegerToIntegerConversion,
variableName);
var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], bigIntegerPolynomialField);
Assert.AreEqual(expectedPolynomial, actualPolynomial);
}
}
public void GetPolynomialDerivativeTest_SimpleInteger()
{
// Representação dos polinómios.
var polynomText = "x^1000-2*x^550+1000*x^10+50";
var polDerivativeText = "1000*x^999-1100*x^549+10000*x^9";
var variableName = "x";
// Estabelece os domínios.
var integerDomain = new IntegerDomain();
var longDomain = new LongDomain();
var bigIntegerDomain = new BigIntegerDomain();
// Estabelece os conversores.
var integerToIntegerConv = new ElementToElementConversion <int>();
var integerToLongConv = new LongToIntegerConversion();
var integerToBigIntegerConvsersion = new BigIntegerToIntegerConversion();
// Estabelece os leitores individuais.
var integerParser = new IntegerParser <string>();
var longParser = new LongParser <string>();
var bigIntegerParser = new BigIntegerParser <string>();
// Estabelece os polinómios.
var integerPolynomial = TestsHelper.ReadUnivarPolynomial(
polynomText,
integerDomain,
integerParser,
integerToIntegerConv,
variableName);
var integerExpectedPolynomial = TestsHelper.ReadUnivarPolynomial(
polDerivativeText,
integerDomain,
integerParser,
integerToIntegerConv,
variableName);
var integerActualDerivative = integerPolynomial.GetPolynomialDerivative(integerDomain);
// Verifica se os polinómios são válidos.
Assert.AreEqual(integerExpectedPolynomial, integerActualDerivative);
// Estabelece os polinómios.
var longPolynomial = TestsHelper.ReadUnivarPolynomial(
polynomText,
longDomain,
longParser,
integerToLongConv,
variableName);
var longExpectedPolynomial = TestsHelper.ReadUnivarPolynomial(
polDerivativeText,
longDomain,
longParser,
integerToLongConv,
variableName);
var longActualDerivative = longPolynomial.GetPolynomialDerivative(longDomain);
// Verifica se os polinómios são válidos.
Assert.AreEqual(longExpectedPolynomial, longActualDerivative);
// Estabelece os polinómios.
var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial(
polynomText,
bigIntegerDomain,
bigIntegerParser,
integerToBigIntegerConvsersion,
variableName);
var bigIntegerExpectedPolynomial = TestsHelper.ReadUnivarPolynomial(
polDerivativeText,
bigIntegerDomain,
bigIntegerParser,
integerToBigIntegerConvsersion,
variableName);
var bigIntegerActualDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerDomain);
// Verifica se os polinómios são válidos.
Assert.AreEqual(bigIntegerExpectedPolynomial, bigIntegerActualDerivative);
}
public void GetPolynomialDerivativeTest_IntegerMatrix()
{
// Os valores a serem lidos
var polynomialText = "[[1,2],[3,4]]*x^2-[[1,0],[0,1]]*x+[[7,6],[9,8]]";
var polynomialDerivativeText = "[[2,4],[6,8]]*x+[[-1,0],[0,-1]]";
var variableName = "x";
var arrayDelimiters = new Dictionary <string, string>();
arrayDelimiters.Add("left_bracket", "right_bracket");
// Os domínios responsáveis sobre as operações sobre os inteiros.
var integerDomain = new IntegerDomain();
var longDomain = new LongDomain();
var bigIntegerDomain = new BigIntegerDomain();
// Os leitore sde inteiros
var integerParser = new IntegerParser <string>();
var longParser = new LongParser <string>();
var bigIntegerParser = new BigIntegerParser <string>();
// As fábricas responsáveis pela instanciação de matrizes
var integerSquareArrayMatrixfactory = new ArraySquareMatrixFactory <int>();
var longSquareArrayMatrixFactory = new ArraySquareMatrixFactory <long>();
var bigIntegerSquareArrayMatrixfactory = new ArraySquareMatrixFactory <BigInteger>();
// Os anéis de matrizes
var integerGenericMatrixRing = new GeneralMatrixRing <int>(
2,
integerSquareArrayMatrixfactory,
integerDomain);
var longGenericMatrixRing = new GeneralMatrixRing <long>(
2,
longSquareArrayMatrixFactory,
longDomain);
var bigIntegerGenericMatrixRing = new GeneralMatrixRing <BigInteger>(
2,
bigIntegerSquareArrayMatrixfactory,
bigIntegerDomain);
// Os objectos responsáveis pela conversão entre os coeficientes e o grau (inteiro)
var integerMatrixConversion = new CantConvertConversion <int, IMatrix <int> >();
var longMatrixConversion = new CantConvertConversion <int, IMatrix <long> >();
var bigIntegerMatrixConversion = new CantConvertConversion <int, IMatrix <BigInteger> >();
var integerMatrixConfigParser = new ConfigMatrixParser <int, IMatrix <int> >(
integerParser,
2,
2,
(i, j) => integerSquareArrayMatrixfactory.CreateMatrix(i, j));
integerMatrixConfigParser.SeparatorSymbType = "comma";
integerMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket");
integerMatrixConfigParser.AddBlanckSymbolType("blancks");
var longMatrixConfigParser = new ConfigMatrixParser <long, IMatrix <long> >(
longParser,
2,
2,
(i, j) => longSquareArrayMatrixFactory.CreateMatrix(i, j));
longMatrixConfigParser.SeparatorSymbType = "comma";
longMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket");
longMatrixConfigParser.AddBlanckSymbolType("blancks");
var bigIntegerMatrixConfigParser = new ConfigMatrixParser <BigInteger, IMatrix <BigInteger> >(
bigIntegerParser,
2,
2,
(i, j) => bigIntegerSquareArrayMatrixfactory.CreateMatrix(i, j));
bigIntegerMatrixConfigParser.SeparatorSymbType = "comma";
bigIntegerMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket");
bigIntegerMatrixConfigParser.AddBlanckSymbolType("blancks");
// Leitura dos polinómios e subsequente teste.
var integerPolynomial = TestsHelper.ReadUnivarPolynomial <IMatrix <int> >(
polynomialText,
integerGenericMatrixRing,
integerMatrixConfigParser,
integerMatrixConversion,
variableName,
arrayDelimiters);
var integerExpectedDerivative = TestsHelper.ReadUnivarPolynomial(
polynomialDerivativeText,
integerGenericMatrixRing,
integerMatrixConfigParser,
integerMatrixConversion,
variableName,
arrayDelimiters,
true);
var integerActualDerivative = integerPolynomial.GetPolynomialDerivative(integerGenericMatrixRing);
Assert.IsTrue(
new UnivarPolynomNormalFormEqualityComparer <IMatrix <int> >(integerGenericMatrixRing).Equals(integerExpectedDerivative, integerActualDerivative),
string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative));
var longPolynomial = TestsHelper.ReadUnivarPolynomial(
polynomialText,
longGenericMatrixRing,
longMatrixConfigParser,
longMatrixConversion,
variableName,
arrayDelimiters);
var longExpectedDerivative = TestsHelper.ReadUnivarPolynomial(
polynomialDerivativeText,
longGenericMatrixRing,
longMatrixConfigParser,
longMatrixConversion,
variableName,
arrayDelimiters,
true);
var longActualDerivative = longPolynomial.GetPolynomialDerivative(longGenericMatrixRing);
Assert.IsTrue(
new UnivarPolynomNormalFormEqualityComparer <IMatrix <long> >(longGenericMatrixRing).Equals(longExpectedDerivative, longActualDerivative),
string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative));
var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial(
polynomialText,
bigIntegerGenericMatrixRing,
bigIntegerMatrixConfigParser,
bigIntegerMatrixConversion,
variableName,
arrayDelimiters);
var bigIntegerExpectedDerivative = TestsHelper.ReadUnivarPolynomial(
polynomialDerivativeText,
bigIntegerGenericMatrixRing,
bigIntegerMatrixConfigParser,
bigIntegerMatrixConversion,
variableName,
arrayDelimiters,
true);
var bigIntegerActualDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerGenericMatrixRing);
Assert.IsTrue(
new UnivarPolynomNormalFormEqualityComparer <IMatrix <BigInteger> >(
bigIntegerGenericMatrixRing).Equals(bigIntegerExpectedDerivative,
bigIntegerActualDerivative),
string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative));
}
public void GetPolynomialDerivativeTest_IntegerFraction()
{
var polynomialText = "1/2*x^5+3/4*x^4-2/7*x^3+5/3*x^2+1/5*x+9";
var polynomialDerivativeText = "5/2*x^4+3*x^3-6/7*x^2+10/3*x+1/5";
var variableName = "x";
var integerDomain = new IntegerDomain();
var longDomain = new LongDomain();
var bigIntegerDomain = new BigIntegerDomain();
var integerParser = new IntegerParser <string>();
var longParser = new LongParser <string>();
var bigIntegerParser = new BigIntegerParser <string>();
var longConversion = new LongToIntegerConversion();
var bigIntegerConversion = new BigIntegerToIntegerConversion();
var integerFractionConversion = new ElementFractionConversion <int>(integerDomain);
var longfractionConversion = new OuterElementFractionConversion <int, long>(longConversion, longDomain);
var bigIntegerfractionConversion = new OuterElementFractionConversion <int, BigInteger>(bigIntegerConversion, bigIntegerDomain);
var integerFractionField = new FractionField <int>(integerDomain);
var longFractionField = new FractionField <long>(longDomain);
var bigIntegerFractionField = new FractionField <BigInteger>(bigIntegerDomain);
// Coeficientes inteiros
var integerPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>(
polynomialText,
integerDomain,
integerParser,
integerFractionConversion,
variableName);
var integerPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>(
polynomialDerivativeText,
integerDomain,
integerParser,
integerFractionConversion,
variableName);
var integerActualPolDerivative = integerPolynomial.GetPolynomialDerivative(integerFractionField);
Assert.AreEqual(integerPolynomialDerivative, integerActualPolDerivative);
// Coeficientes longos
var longPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <long, LongDomain>(
polynomialText,
longDomain,
longParser,
longfractionConversion,
variableName);
var longPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <long, LongDomain>(
polynomialDerivativeText,
longDomain,
longParser,
longfractionConversion,
variableName);
var longActualPolDerivative = longPolynomial.GetPolynomialDerivative(longFractionField);
Assert.AreEqual(longPolynomialDerivative, longActualPolDerivative);
var bigIntegerPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <BigInteger, BigIntegerDomain>(
polynomialText,
bigIntegerDomain,
bigIntegerParser,
bigIntegerfractionConversion,
variableName);
var bigIntegerPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <BigInteger, BigIntegerDomain>(
polynomialDerivativeText,
bigIntegerDomain,
bigIntegerParser,
bigIntegerfractionConversion,
variableName);
var bigIntegerActualPolDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerFractionField);
Assert.AreEqual(bigIntegerPolynomialDerivative, bigIntegerActualPolDerivative);
}
public void RunTest_OnlyInequalitiesDouble()
{
var inputConstraintsMatrixText = "[[1,0,3],[0,2,2]]";
var inputConstraintsVectorText = "[4,12,18]";
var inputObjectiveFuncText = "[-3,-5]";
var inverseMatrixText = "[[1,0,0],[0,1,0],[0,0,1]]";
var cost = 0.0;
var nonBasicVariables = new[] { 0, 1 };
var basicVariables = new[] { 2, 3, 4 };
// Leitura da matriz das retrições.
var doubleElementsParser = new DoubleParser <string>();
var inputConstraintsMatrix = TestsHelper.ReadMatrix <double>(
3,
2,
inputConstraintsMatrixText,
(i, j) => new ArrayMathMatrix <double>(i, j),
doubleElementsParser,
true);
// Leitura da matriz inversa.
var inverseMatrix = TestsHelper.ReadMatrix <double>(
3,
3,
inverseMatrixText,
(i, j) => new ArraySquareMathMatrix <double>(i),
doubleElementsParser,
true) as ISquareMathMatrix <double>;
// Leitura do vector de restrições.
var vectorFactory = new ArrayVectorFactory <double>();
var inputConstraintsVector = TestsHelper.ReadVector <double>(
3,
inputConstraintsVectorText,
vectorFactory,
doubleElementsParser,
true);
// Leitura da função objectivo.
var inputObjectiveFunction = TestsHelper.ReadVector <double>(
2,
inputObjectiveFuncText,
vectorFactory,
doubleElementsParser,
true);
// Objecto de entrada para o algoritmo do simplex.
var simplexInput = new RevisedSimplexInput <double, double>(
basicVariables,
nonBasicVariables,
inputObjectiveFunction,
cost,
inputConstraintsMatrix,
inputConstraintsVector,
inverseMatrix);
// Executa o algoritmo do simplex.
var doubleField = new DoubleField();
var target = new RevisedSimplexAlgorithm <double>(Comparer <double> .Default, doubleField);
var actual = target.Run(simplexInput);
// Verifica o custo
Assert.AreEqual(36, actual.Cost);
// Verifica a solução
Assert.AreEqual(2, actual.Solution[0]);
Assert.AreEqual(6, actual.Solution[1]);
}
public void GetPolynomialDerivativeTest_IntegerPolynomialAsCoefficients()
{
var polynomialText = "(y^2+y+1)*x^3-2*x^2*y+x*(y^5-3)+4";
var polynomialDerivativeText = "3*(y^2+y+1)*x^2-4*y*x+y^5-3";
var variableName = "x";
var coeffsVariableName = "y";
// Os domínios responsáveis pelas operações sobre os inteiros.
var integerDomain = new IntegerDomain();
var longDomain = new LongDomain();
var bigIntegerDomain = new BigIntegerDomain();
// Os leitore sde inteiros
var integerParser = new IntegerParser <string>();
var longParser = new LongParser <string>();
var bigIntegerParser = new BigIntegerParser <string>();
// Definição das conversões.
var integerConversion = new ElementToElementConversion <int>();
var longConversion = new LongToIntegerConversion();
var bigIntegerConversion = new BigIntegerToIntegerConversion();
var integerPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <int>(
coeffsVariableName,
integerConversion,
integerDomain);
var longPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <long>(
coeffsVariableName,
longConversion,
longDomain);
var bigIntegerPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <BigInteger>(
coeffsVariableName,
bigIntegerConversion,
bigIntegerDomain);
// Definição dos anéis polinomiais.
var integerPolynomialRing = new UnivarPolynomRing <int>(coeffsVariableName, integerDomain);
var longPolynomialRing = new UnivarPolynomRing <long>(coeffsVariableName, longDomain);
var bigIntegerPolynomialRing = new UnivarPolynomRing <BigInteger>(coeffsVariableName, bigIntegerDomain);
// Definição dos leitores polinomiais.
var integerPolynomialParser = new UnivarPolNormalFormParser <int>(
coeffsVariableName,
integerConversion,
integerParser,
integerDomain);
var longPolynomialParser = new UnivarPolNormalFormParser <long>(
coeffsVariableName,
longConversion,
longParser,
longDomain);
var bigIntegerPolynomialParser = new UnivarPolNormalFormParser <BigInteger>(
coeffsVariableName,
bigIntegerConversion,
bigIntegerParser,
bigIntegerDomain);
// Definição dos testes.
var integerPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <int> >(
polynomialText,
integerPolynomialRing,
integerPolynomialParser,
integerPolConvertion,
variableName);
var integerExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <int> >(
polynomialDerivativeText,
integerPolynomialRing,
integerPolynomialParser,
integerPolConvertion,
variableName);
var integerActualPlynomial = integerPolynomial.GetPolynomialDerivative(integerPolynomialRing);
Assert.AreEqual(integerExpectedPol, integerActualPlynomial);
var longPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <long> >(
polynomialText,
longPolynomialRing,
longPolynomialParser,
longPolConvertion,
variableName);
var longExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <long> >(
polynomialDerivativeText,
longPolynomialRing,
longPolynomialParser,
longPolConvertion,
variableName);
var longActualPlynomial = longPolynomial.GetPolynomialDerivative(longPolynomialRing);
Assert.AreEqual(longExpectedPol, longActualPlynomial);
var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <BigInteger> >(
polynomialText,
bigIntegerPolynomialRing,
bigIntegerPolynomialParser,
bigIntegerPolConvertion,
variableName);
var bigIntegerExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <BigInteger> >(
polynomialDerivativeText,
bigIntegerPolynomialRing,
bigIntegerPolynomialParser,
bigIntegerPolConvertion,
variableName);
var bigIntegerActualPlynomial = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerPolynomialRing);
Assert.AreEqual(bigIntegerExpectedPol, bigIntegerExpectedPol);
}
public void PowerTest_IntegerPolynomial()
{
var integerDomain = new IntegerDomain();
var longDomain = new LongDomain();
var bigIntegerDomain = new BigIntegerDomain();
var variableName = "x";
var intPolDomain = new UnivarPolynomRing <int>(variableName, integerDomain);
var longPolDomain = new UnivarPolynomRing <long>(variableName, longDomain);
var bigIntegerPolDomain = new UnivarPolynomRing <BigInteger>(variableName, bigIntegerDomain);
// Leitores
var integerParser = new IntegerParser <string>();
var longParser = new LongParser <string>();
var bigIntegerParser = new BigIntegerParser <string>();
var integerConversion = new ElementToElementConversion <int>();
var longToIntegerConversion = new LongToIntegerConversion();
var bigIntegerToIntegerConversion = new BigIntegerToIntegerConversion();
var intPowers = new int[3] {
2, 3, 4
};
var longPowers = new long[3] {
2, 3, 4
};
var bigIntPowers = new BigInteger[3] {
2, 3, 4
};
var polynomialsTexts = new string[3] {
"x^3-2*x^2+3*x-1", "2*x^2+4*x+4", "x+1"
};
var expectedPolinomialsTexts = new string[3] {
"x^6-4*x^5+10*x^4-14*x^3+13*x^2-6*x+1",
"8*x^6+48*x^5+144*x^4+256*x^3+288*x^2+192*x+64",
"x^4+4*x^3+6*x^2+4*x+1"
};
// Coeficientes inteiros.
for (int i = 0; i < 3; ++i)
{
var polynomialValue = TestsHelper.ReadUnivarPolynomial(
polynomialsTexts[i],
integerDomain,
integerParser,
integerConversion,
variableName);
var expectedPolynomial = TestsHelper.ReadUnivarPolynomial(
expectedPolinomialsTexts[i],
integerDomain,
integerParser,
integerConversion,
variableName);
var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], intPolDomain);
Assert.AreEqual(expectedPolynomial, actualPolynomial);
}
// Coeficientes longos.
for (int i = 0; i < 3; ++i)
{
var polynomialValue = TestsHelper.ReadUnivarPolynomial(
polynomialsTexts[i],
longDomain,
longParser,
longToIntegerConversion,
variableName);
var expectedPolynomial = TestsHelper.ReadUnivarPolynomial(
expectedPolinomialsTexts[i],
longDomain,
longParser,
longToIntegerConversion,
variableName);
var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], longPolDomain);
Assert.AreEqual(expectedPolynomial, actualPolynomial);
}
// Coeficientes correspondentes a inteiros de precisão arbitrária.
for (int i = 0; i < 3; ++i)
{
var polynomialValue = TestsHelper.ReadUnivarPolynomial(
polynomialsTexts[i],
bigIntegerDomain,
bigIntegerParser,
bigIntegerToIntegerConversion,
variableName);
var expectedPolynomial = TestsHelper.ReadUnivarPolynomial(
expectedPolinomialsTexts[i],
bigIntegerDomain,
bigIntegerParser,
bigIntegerToIntegerConversion,
variableName);
var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], bigIntegerPolDomain);
Assert.AreEqual(expectedPolynomial, actualPolynomial);
}
}
