cc.redberry.core.transformations.factor.JasFactor Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of core Show documentation
Show all versions of core Show documentation
Redberry is an open source computer algebra system designed for tensor
manipulation. It implements basic computer algebra system routines as well as
complex tools for real computations in physics.
This is Redberry core, which contains the implementation of the basic
computer algebra routines and general-purpose transformations.
The newest version!
/*
* Redberry: symbolic tensor computations.
*
* Copyright (c) 2010-2015:
* Stanislav Poslavsky
* Bolotin Dmitriy
*
* This file is part of Redberry.
*
* Redberry is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Redberry is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Redberry. If not, see factory =
new GenPolynomialRing<>(BigInteger.ONE, forFactoryNames);
GenPolynomial poly;
java.math.BigInteger gcd, lcm;
if (containsRationals(t)) {
GenPolynomialRing ratFactory =
new GenPolynomialRing<>(BigRational.ONE, forFactoryNames);
GenPolynomial polyRat = tensor2Poly(t, ratFactory, vars, RationalConverter);
Object[] factors = PolyUtil.integerFromRationalCoefficientsFactor(factory, polyRat);
gcd = (java.math.BigInteger) factors[0];
lcm = (java.math.BigInteger) factors[1];
//todo if lcm == 0
poly = (GenPolynomial) factors[2];
} else {
gcd = java.math.BigInteger.ONE;
lcm = java.math.BigInteger.ONE;
poly = tensor2Poly(t, factory, vars, IntegerConverter);
}
if (poly.isZERO())
return Complex.ZERO;
FactorAbstract jasFactor = FactorFactory.getImplementation(BigInteger.ONE);
SortedMap, Long> map = jasFactor.factors(poly);
if (!jasFactor.isFactorization(poly, map))
return t;
List toMultiply = new ArrayList<>(map.size());
for (SortedMap.Entry, Long> entry : map.entrySet())
toMultiply.add(Tensors.pow(poly2Tensor(entry.getKey(), varsArray),
new Complex(entry.getValue())));
if (!gcd.equals(java.math.BigInteger.ONE) || !lcm.equals(java.math.BigInteger.ONE))
toMultiply.add(new Complex(new Rational(gcd, lcm)));
return Tensors.multiply(toMultiply.toArray(new Tensor[toMultiply.size()]));
}
static > GenPolynomial tensor2Poly(Tensor tensor, GenPolynomialRing factory, TIntObjectMap vars, NumberConverter numberConverter) {
if (tensor.getClass() == SimpleTensor.class)
return factory.getONE().
multiply(ExpVector.create(vars.size(), vars.get(((SimpleTensor) tensor).getName()).position, 1L));
else if (tensor.getClass() == Power.class) {
long pow = ((Complex) tensor.get(1)).longValue();
if (tensor.get(0) instanceof SimpleTensor)
return factory.getONE().
multiply(ExpVector.create(vars.size(),
vars.get(((SimpleTensor) tensor.get(0)).getName()).position, pow));
else {
GenPolynomial result = factory.getONE();
GenPolynomial base = tensor2Poly(tensor.get(0), factory, vars, numberConverter);
while (pow > 0) {
if ((pow & 0x1) != 0)
result = result.multiply(base);
base = base.multiply(base);
pow = pow >>> 1;
}
return result;
}
} else if (tensor.getClass() == Sum.class) {
GenPolynomial result = factory.getZERO();
for (Tensor t : tensor)
result = result.sum(tensor2Poly(t, factory, vars, numberConverter));
return result;
} else if (tensor.getClass() == Product.class) {
GenPolynomial result = factory.getONE();
for (Tensor t : tensor)
result = result.multiply(tensor2Poly(t, factory, vars, numberConverter));
return result;
} else if (tensor.getClass() == Complex.class) {
return factory.getONE().multiply(numberConverter.convertComplex(((Complex) tensor)));
}
throw new RuntimeException();
}
private static interface NumberConverter> {
T convertComplex(Complex complex);
}
private static final NumberConverter RationalConverter = new NumberConverter() {
@Override
public BigRational convertComplex(Complex complex) {
Rational rational = (Rational) complex.getReal();
return new BigRational(new BigInteger(rational.getNumerator()),
new BigInteger(rational.getDenominator()));
}
};
private static final NumberConverter IntegerConverter = new NumberConverter() {
@Override
public BigInteger convertComplex(Complex complex) {
return new BigInteger(((Rational) complex.getReal()).getNumerator());
}
};
private static boolean containsRationals(Tensor tensor) {
if (tensor instanceof Complex) {
if (((Complex) tensor).isInteger())
return false;
return true;
}
for (Tensor t : tensor) {
if (containsRationals(t))
return true;
}
return false;
}
static Tensor poly2Tensor(GenPolynomial poly, Var[] varsArray) {
if (poly.length() == 0)
return Complex.ZERO;
List temp = new ArrayList<>(), sum = new ArrayList<>(poly.length());
long lExp;
BigInteger coefficient;
ExpVector exp;
for (Monomial monomial : poly) {
coefficient = monomial.coefficient();
exp = monomial.exponent();
temp.clear();
temp.add(new Complex(new Rational(coefficient.getVal())));
for (int i = 0; i < exp.length(); ++i)
if ((lExp = exp.getVal(i)) != 0)
temp.add(Tensors.pow(varsArray[i].simpleTensor, new Complex(lExp)));
sum.add(Tensors.multiply(temp.toArray(new Tensor[temp.size()])));
}
return Tensors.sum(sum.toArray(new Tensor[sum.size()]));
}
static TIntObjectMap getVars(Tensor... tensors) {
TIntObjectMap vars = new TIntObjectHashMap<>();
for (Tensor t : tensors)
addVars(t, vars, 1);
return vars;
}
static void addVars(Tensor tensor, TIntObjectMap vars, long power) {
if (power < 0)
throw new IllegalArgumentException("Negative powers.");
if (tensor.getClass() == SimpleTensor.class) {
if (tensor.getIndices().size() != 0)
throw new IllegalArgumentException();
int name = ((SimpleTensor) tensor).getName();
Var var = vars.get(name);
if (var == null)
vars.put(name, var = new Var((SimpleTensor) tensor));
var.maxPower = Math.max(power, var.maxPower);
return;
} else if (tensor.getClass() == Power.class) {
if (!TensorUtils.isNaturalNumber(tensor.get(1)))
throw new IllegalArgumentException(tensor.toString());
long pow = power * ((Complex) tensor.get(1)).longValue();
addVars(tensor.get(0), vars, pow);
return;
} else if (tensor instanceof MultiTensor) {
for (Tensor t : tensor)
addVars(t, vars, power);
return;
} else if (tensor.getClass() == Complex.class) {
if (((Complex) tensor).isNumeric() || !((Complex) tensor).isReal())
throw new IllegalArgumentException("Illegal coefficient: " + tensor);
return;
}
throw new IllegalArgumentException();
}
static class Var implements Comparable {
final int name;
String polyName = null;
int position;
long maxPower;
final SimpleTensor simpleTensor;
private Var(SimpleTensor simpleTensor) {
this.simpleTensor = simpleTensor;
this.name = simpleTensor.getName();
}
@Override
public int compareTo(Var o) {
return -Long.compare(o.maxPower, this.maxPower);
}
}
static GenPolynomial tensor2Poly(Tensor t) {
TIntObjectMap vars = getVars(t);
Var[] varsArray = vars.values(new Var[vars.size()]);
Arrays.sort(varsArray);
String[] forFactoryNames = new String[varsArray.length];
for (int i = 0; i < varsArray.length; ++i)
varsArray[i].polyName =
forFactoryNames[varsArray[i].position = i]
= String.valueOf((char) (START_CHAR + i));
GenPolynomialRing factory =
new GenPolynomialRing<>(BigInteger.ONE, forFactoryNames);
GenPolynomial poly;
java.math.BigInteger gcd, lcm;
if (containsRationals(t)) {
GenPolynomialRing ratFactory =
new GenPolynomialRing<>(BigRational.ONE, forFactoryNames);
GenPolynomial polyRat = tensor2Poly(t, ratFactory, vars, RationalConverter);
Object[] factors = PolyUtil.integerFromRationalCoefficientsFactor(factory, polyRat);
poly = (GenPolynomial) factors[2];
} else {
poly = tensor2Poly(t, factory, vars, IntegerConverter);
}
return poly;
}
}