/** * Returns reciprocal of the specified tensor, i.e. one divided by it. * * @param tensor tensor * @return reciprocal of the specified tensor * @throws IllegalArgumentException if specified tensor is not scalar */ public static Tensor reciprocal(Tensor tensor) { return pow(tensor, Complex.MINUS_ONE); }
@Override public Tensor derivative() { return Tensors.pow(argument, Complex.MINUS_ONE); }
/** * Power function. Returns tensor raised to specified integer power. * * @param argument base * @param power power * @return result of argument exponentiation * @throws IllegalArgumentException if argument is not scalar */ public static Tensor pow(Tensor argument, java.math.BigInteger power) { return pow(argument, new Complex(power)); }
/** * Power function. Returns tensor raised to specified integer power. * * @param argument base * @param power power * @return result of argument exponentiation * @throws IllegalArgumentException if argument is not scalar */ public static Tensor pow(Tensor argument, int power) { return pow(argument, new Complex(power)); }
Tensor build() { if (exponent == null) return base; return Tensors.pow(base, exponent.build()); }
@Override public Tensor derivative() { return Tensors.pow(new Cos(argument), Complex.MINUS_TWO); }
@Override public Tensor derivative() { return Tensors.pow(new Sin(argument), Complex.MINUS_TWO); }
Tensor toTensor() { BigInteger exponent = this.exponent; if (minExponent != null && minExponent.value != null) { exponent = exponent.subtract(minExponent.value); if (diffSigns && minExponent.value.testBit(0)) return Tensors.negate(Tensors.pow(tensor, new Complex(exponent))); } return Tensors.pow(tensor, new Complex(exponent)); }
static Tensor[] powerExpandToArray1(Tensor power, Indicator<Tensor> indicator) { final Tensor[] scalars = ((Product) power.get(0)).getAllScalars(); ArrayList<Tensor> factorOut = new ArrayList<>(scalars.length), leave = new ArrayList<>(scalars.length); Tensor exponent = power.get(1); for (int i = 0; i < scalars.length; ++i) { if (indicator.is(scalars[i])) factorOut.add(Tensors.pow(scalars[i], exponent)); else leave.add(scalars[i]); } if (!leave.isEmpty()) factorOut.add(Tensors.pow( Tensors.multiply(leave.toArray(new Tensor[leave.size()])), exponent)); return factorOut.toArray(new Tensor[factorOut.size()]); }
private static List<Tensor> expandPower(Tensor power) { List<Tensor> powers = new ArrayList<>(power.get(1).size()); for (Tensor exponent : power.get(1)) powers.add(Tensors.pow(power.get(0), exponent)); return powers; }
public static Tensor expandSymbolicPower(Sum argument, int power, Transformation[] transformations) { //TODO improve algorithm using Newton formula!!! int i; Tensor temp = argument; for (i = power - 1; i >= 1; --i) { temp = expandPairOfSums((Sum) temp, argument, transformations); if (!(temp instanceof Sum)) { temp = multiply(temp, apply(transformations, pow(argument, i - 1))); break; } } return temp; }
static Tensor poly2Tensor(GenPolynomial<BigInteger> poly, Var[] varsArray) { if (poly.length() == 0) return Complex.ZERO; List<Tensor> temp = new ArrayList<>(), sum = new ArrayList<>(poly.length()); long lExp; BigInteger coefficient; ExpVector exp; for (Monomial<BigInteger> 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()])); }
private Expression createP2Subs() { return expression(multiply(momentum, setIndices(momentum, momentum.getIndices().getInverted())), pow(mass, 2)); }
/** * Converts this AST to tensor. * * @return resulting tensor */ public Tensor toTensor() { switch (tokenType) { case Sum: return Tensors.sum(contentToTensors()); case Power: assert content.length == 2; return Tensors.pow(content[0].toTensor(), content[1].toTensor()); case Trace: case Product: return Tensors.multiplyAndRenameConflictingDummies(contentToTensors()); } throw new ParserException("Unknown tensor type: " + tokenType); }
public static Tensor expandPower(Sum argument, int power, int[] forbiddenIndices, Transformation[] transformations) { //TODO improve algorithm using Newton formula!!! int i; Tensor temp = argument; TIntHashSet forbidden = new TIntHashSet(forbiddenIndices); TIntHashSet argIndices = TensorUtils.getAllIndicesNamesT(argument); forbidden.ensureCapacity(argIndices.size() * power); forbidden.addAll(argIndices); for (i = power - 1; i >= 1; --i) { temp = expandPairOfSums((Sum) temp, (Sum) ApplyIndexMapping.renameDummy(argument, forbidden.toArray(), forbidden), transformations); if (!(temp instanceof Sum)) { temp = multiply(temp, apply(transformations, pow(argument, i - 1))); break; } } return temp; }