/** * Returns the result of summation of several tensors. * * @param tensors collection of summands * @return result of summation * @throws TensorException if tensors have different free indices */ public static Tensor sum(Collection<Tensor> tensors) { return sum(tensors.toArray(new Tensor[tensors.size()])); }
@Override public String toString() { return multiply(factors) + " : " + sum(summands.toArray(new Tensor[summands.size()])); } }
/** * Subtracts {@code b} from {@code a} * * @param a tensor * @param b tensor * @return {@code a} - {@code b} * @throws TensorException if tensors have different free indices */ public static Tensor subtract(Tensor a, Tensor b) { return sum(a, negate(b)); }
Tensor toTensor(Transformation[] transformations) { Tensor sum = Transformation.Util.applySequentially( Tensors.sum(summands.toArray(new Tensor[summands.size()])), transformations); Tensor[] ms = new Tensor[factors.length + 1]; ms[ms.length - 1] = sum; System.arraycopy(factors, 0, ms, 0, factors.length); return Tensors.multiply(ms); }
@Override public Tensor derivative() { return Tensors.pow( Tensors.sum(Complex.ONE, Tensors.pow(argument, Complex.TWO)), Complex.MINUS_ONE); }
@Override public Tensor derivative() { return Tensors.pow(Tensors.sum(Complex.ONE, Tensors.pow(argument, Complex.TWO)), Complex.MINUS_ONE_HALF); }
@Override public Tensor derivative() { return Tensors.multiply(Tensors.pow( Tensors.sum(Complex.ONE, Tensors.pow(argument, Complex.TWO)), Complex.MINUS_ONE), Complex.MINUS_ONE); }
@Override public Tensor derivative() { return Tensors.multiply(Tensors.pow(Tensors.sum(Complex.ONE, Tensors.pow(argument, Complex.TWO)), Complex.MINUS_ONE_HALF), Complex.MINUS_ONE); }
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()])); }
public static Expression[] setMandelstam(Tensor[][] momentums, Tensor s, Tensor t, Tensor u) { checkMandelstamInput(momentums, 4); if (s.getIndices().getFree().size() != 0 || t.getIndices().getFree().size() != 0 || u.getIndices().getFree().size() != 0) throw new IllegalArgumentException("Mandelstam variables should be scalar."); Expression[] result = new Expression[10]; int i; // (k1,k1) = m1^2, (k2,k2) = m2^2, (k3,k3) = m3^2, (k4,k4) = m4^2 for (i = 0; i < 4; ++i) result[i] = expression(square(momentums[i][0]), pow(momentums[i][1], 2)); //2(k1, k2) = s - k1^2 - k2^2 //2(k3, k4) = s - k3^2 - k4^2 result[i++] = expression(multiply(Complex.TWO, contract(momentums[0][0], momentums[1][0])), sum(s, negate(sum(pow(momentums[0][1], 2), pow(momentums[1][1], 2))))); result[i++] = expression(multiply(Complex.TWO, contract(momentums[2][0], momentums[3][0])), sum(s, negate(sum(pow(momentums[2][1], 2), pow(momentums[3][1], 2))))); //-2(k1, k3) = t - k1^2 - k3^2 //-2(k2, k4) = t - k2^2 - k4^2 result[i++] = expression(multiply(Complex.MINUS_TWO, contract(momentums[0][0], momentums[2][0])), sum(t, negate(sum(pow(momentums[0][1], 2), pow(momentums[2][1], 2))))); result[i++] = expression(multiply(Complex.MINUS_TWO, contract(momentums[1][0], momentums[3][0])), sum(t, negate(sum(pow(momentums[1][1], 2), pow(momentums[3][1], 2))))); //-2(k1, k4) = u - k1^2 - k4^2 //-2(k2, k3) = u - k2^2 - k3^2 result[i++] = expression(multiply(Complex.MINUS_TWO, contract(momentums[0][0], momentums[3][0])), sum(u, negate(sum(pow(momentums[0][1], 2), pow(momentums[3][1], 2))))); result[i++] = expression(multiply(Complex.MINUS_TWO, contract(momentums[1][0], momentums[2][0])), sum(u, negate(sum(pow(momentums[1][1], 2), pow(momentums[2][1], 2))))); return result; }
@Override public Tensor set(int i, Tensor tensor) { // return super.set(i, tensor); if (i >= data.length || i < 0) throw new IndexOutOfBoundsException(); Tensor old = data[i]; if (old == tensor) return this; if (TensorUtils.equalsExactly(old, tensor)) return this; if (TensorUtils.isIndeterminate(tensor)) return tensor; if (TensorUtils.isZero(tensor)) return remove(i); Tensor[] newData = data.clone(); newData[i] = tensor; if (TensorUtils.equals(old, tensor)) return new Sum(newData, indices); return Tensors.sum(newData); }
/** * 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); }
private Tensor factorSum1(Tensor sum) { Tensor[] parts = reIm(sum); if (!TensorUtils.isZero(parts[0])) { Tensor im = parts[0]; if (im instanceof Sum) im = FastTensors.multiplySumElementsOnFactor((Sum) im, Complex.IMAGINARY_UNIT); else im = Tensors.multiply(im, Complex.IMAGINARY_UNIT); im = factorizationEngine.transform(im); im = Tensors.multiply(im, Complex.NEGATIVE_IMAGINARY_UNIT); parts[0] = im; } if (!TensorUtils.isZero(parts[1])) parts[1] = factorizationEngine.transform(parts[1]); return Tensors.sum(parts[0], parts[1]); }
private Tensor factorSymbolicTerms(Tensor tensor) { FromParentToChildIterator iterator = new FromParentToChildIterator(tensor); Tensor c; while ((c = iterator.next()) != null) { if (!(c instanceof Sum)) continue; Tensor remainder = c, temp; IntArrayList symbolicPositions = new IntArrayList(); for (int i = c.size() - 1; i >= 0; --i) { temp = c.get(i); if (isSymbolic(temp)) { symbolicPositions.add(i); if (remainder instanceof Sum) remainder = ((Sum) remainder).remove(i); else remainder = Complex.ZERO; } } Tensor symbolicPart = ((Sum) c).select(symbolicPositions.toArray()); symbolicPart = factorSymbolicTerm(symbolicPart); if (remainder instanceof Sum) { SumBuilder sb = new SumBuilder(remainder.size()); for (Tensor tt : remainder) sb.put(factorSymbolicTerms(tt)); remainder = sb.build(); } else remainder = factorSymbolicTerms(remainder); iterator.set(Tensors.sum(symbolicPart, remainder)); } return iterator.result(); }
temp = Tensors.sum(temp, withoutSumsTerm); if (!(temp instanceof Sum))