/** * Multiplies specified tensor by minus one. * * @param tensor tensor to be negotiated * @return tensor negate to specified one */ public static Tensor negate(Tensor tensor) { if (tensor instanceof Complex) return ((Complex) tensor).negate(); return multiply(Complex.MINUS_ONE, tensor); }
private static Tensor nodesToProduct(FactorNode[] nodes) { Tensor[] tensors = new Tensor[nodes.length]; for (int i = nodes.length - 1; i >= 0; --i) tensors[i] = nodes[i].toTensor(); return Tensors.multiply(tensors); }
/** * Returns {@code a} divided by {@code b}. * * @param a tensor * @param b scalar tensor * @return {@code a} divided by {@code b}. * @throws IllegalArgumentException if b is not scalar */ public static Tensor divide(Tensor a, Tensor b) { return multiply(a, reciprocal(b)); }
@Override public String toString() { return multiply(factors) + " : " + sum(summands.toArray(new Tensor[summands.size()])); } }
@Override public Tensor derivative() { return Tensors.multiply(Complex.MINUS_ONE, new Sin(argument)); }
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 protected Tensor expandProduct(Tensor product) { NumeratorDenominator numDen = NumeratorDenominator.getNumeratorAndDenominator(product, NumeratorDenominator.integerDenominatorIndicator); Tensor numerator = ExpandTransformation.expand(numDen.numerator, transformations); if (numDen.numerator == numerator) return product; return Tensors.multiply(numerator, Tensors.reciprocal(numDen.denominator)); }
@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 protected Tensor expandProduct(Tensor product) { NumeratorDenominator numDen = NumeratorDenominator.getNumeratorAndDenominator(product, NumeratorDenominator.integerDenominatorIndicator); Tensor denominator = ExpandTransformation.expand(numDen.denominator, transformations); if (numDen.denominator == denominator) return product; return Tensors.multiply(numDen.numerator, Tensors.reciprocal(denominator)); }
@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); }
private Expression createBarSubs(SimpleTensor spinor, boolean negate) { if (spinor == null) return null; int dummy = spinor.getIndices().get(matrixType, 0), free = dummy + 1; SimpleTensor gamma = simpleTensor(gammaName, createSimple(null, setState(true, dummy), free, setType(metricType, 0))); SimpleTensor mom = setIndices(momentum, createSimple(null, setState(true, setType(metricType, 0)))); SimpleTensor rhs = setMatrixIndices0(spinor, free); return expression(multiply(spinor, gamma, mom), negate ? negate(multiply(mass, rhs)) : multiply(mass, rhs)); }
private Expression createSubs(SimpleTensor spinor, boolean negate) { if (spinor == null) return null; int dummy = setState(false, spinor.getIndices().get(matrixType, 0)), free = setState(true, dummy + 1); SimpleTensor gamma = simpleTensor(gammaName, createSimple(null, free, dummy, setType(metricType, 0))); SimpleTensor mom = setIndices(momentum, createSimple(null, setState(true, setType(metricType, 0)))); SimpleTensor rhs = setMatrixIndices0(spinor, free); return expression(multiply(spinor, gamma, mom), negate ? negate(multiply(mass, rhs)) : multiply(mass, rhs)); }
/** * @deprecated very unsafe method without checks */ @Deprecated public static Tensor multiplySumElementsOnFactors(Sum sum) { final Tensor[] newSumData = new Tensor[sum.size()]; for (int i = newSumData.length - 1; i >= 0; --i) newSumData[i] = multiply(CC.generateNewSymbol(), sum.get(i)); return new Sum(newSumData, IndicesFactory.create(newSumData[0].getIndices().getFree())); }
private static Tensor multiplyWithBuilder(Sum sum, Tensor factor, Transformation... transformations) { SumBuilder sb = new SumBuilder(sum.size()); for (Tensor t : sum) sb.put(Transformation.Util.applySequentially(multiply(t, factor), transformations)); return sb.build(); }
@Override public Tensor transform(Tensor t) { FromChildToParentIterator iterator = new FromChildToParentIterator(t); Tensor c; while ((c = iterator.next()) != null) if (powerExpandApplicable(c, toExpandIndicator)) iterator.set(Tensors.multiply(powerExpandToArray1(c, toExpandIndicator))); return iterator.result(); }
@Override public Tensor transform(Tensor t) { SubstitutionIterator iterator = new SubstitutionIterator(t); Tensor c; while ((c = iterator.next()) != null) if (powerUnfoldApplicable(c, toExpandIndicator)) iterator.set(Tensors.multiply(powerExpandIntoChainToArray1(c, iterator.getForbidden(), toExpandIndicator))); return iterator.result(); }
Expression createSubstitution(int length) { if (length <= 2) return subs[length - 2]; Expression expr = substitutions.get(length); if (expr == null) { Tensor[] line = createLine(length); line[length - 1] = setMetricIndex((SimpleTensor) line[length - 1], IndicesUtils.inverseIndexState(line[0].getIndices().get(metricType, 0))); substitutions.put(length, expr = expression(multiply(line), createSubstitution0(line))); } return expr; }
private Expression[] createOrtIdentities(SimpleTensor bar, SimpleTensor spinor) { if (bar == null || spinor == null) return null; int dummy = setState(false, bar.getIndices().get(matrixType, 0)); Tensor lhs0 = multiply(setMatrixIndices0(bar, dummy), setMatrixIndices0(spinor, inverseIndexState(dummy))); Tensor lhs1 = multiply( setMatrixIndices0(bar, dummy), simpleTensor(gammaName, createSimple(null, inverseIndexState(dummy), dummy + 1, setType(metricType, 0))), setIndices(momentum, createSimple(null, setState(true, setType(metricType, 0)))), setMatrixIndices0(spinor, inverseIndexState(dummy + 1))); return new Expression[]{expression(lhs0, Complex.ZERO), expression(lhs1, Complex.ZERO)}; }
public static Tensor multiplySumElementsOnFactor(Sum sum, Tensor factor, Transformation[] transformations) { if (TensorUtils.isZero(factor)) return Complex.ZERO; if (TensorUtils.isOne(factor)) return sum; if (TensorUtils.haveIndicesIntersections(sum, factor)) { SumBuilder sb = new SumBuilder(sum.size()); for (Tensor t : sum) sb.put(apply(transformations, multiply(t, factor))); return sb.build(); } else return apply(transformations, FastTensors.multiplySumElementsOnFactor(sum, factor)); }
private Tensor metric(Tensor[] gammas) { return multiply( //metric createMetricOrKronecker(gammas[0].getIndices().get(metricType, 0), gammas[1].getIndices().get(metricType, 0)), //matrix createMetricOrKronecker(gammas[0].getIndices().getUpper().get(matrixType, 0), gammas[1].getIndices().getLower().get(matrixType, 0))); }