/** * Multiplies each element in specified sum on some factor. * * @param sum sum * @param factor factor * @return resulting sum */ public static Tensor multiplySumElementsOnFactor(Sum sum, Tensor factor) { return multiplySumElementsOnFactor(sum, factor, new Transformation[0]); }
private static Tensor multiplyWithFactory(Sum sum, Tensor factor, Transformation... transformations) { final ArrayList<Tensor> newSumData = new ArrayList<>(sum.size()); Tensor temp; boolean reduced = false; for (int i = sum.size() - 1; i >= 0; --i) { temp = Transformation.Util.applySequentially(multiply(factor, sum.get(i)), transformations); if (!TensorUtils.isZero(temp)) { newSumData.add(temp); if (!reduced && isReduced(sum.get(i), factor, temp)) reduced = true; } } if (newSumData.size() == 0) return Complex.ZERO; if (newSumData.size() == 1) return newSumData.get(0); final Tensor[] data = newSumData.toArray(new Tensor[newSumData.size()]); if (reduced) return SumFactory.FACTORY.create(data); return new Sum(data, IndicesFactory.create(newSumData.get(0).getIndices().getFree())); }
Tensor move(Tensor[] gammas, int index, boolean left) { if (gammas.length == 1) return gammas[0]; if ((index == 0 && left) || (index == gammas.length - 1 && !left)) return multiply(gammas); Tensor gPart, rest; if (left) { gPart = move0(Arrays.copyOfRange(gammas, 0, index + 1), index, left); rest = multiply(Arrays.copyOfRange(gammas, index + 1, gammas.length)); } else { gPart = move0(Arrays.copyOfRange(gammas, index, gammas.length), 0, left); rest = multiply(Arrays.copyOfRange(gammas, 0, index)); } if (gPart instanceof Sum) gPart = FastTensors.multiplySumElementsOnFactorAndResolveDummies((Sum) gPart, rest); else gPart = multiplyAndRenameConflictingDummies(gPart, rest); return eliminate(gPart); }
private 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) || (sum.indices.size() == 0 && factor.getIndices().size() != 0)) return multiplyWithBuilder(sum, factor, transformations); else return multiplyWithFactory(sum, factor, transformations); }
moved = FastTensors.multiplySumElementsOnFactorAndResolveDummies((Sum) moved, spinors); else moved = multiply(moved, spinors); moved = FastTensors.multiplySumElementsOnFactor((Sum) moved, spinors); else moved = multiply(moved, spinors);
Tensor newData = expandProductOfSums1(data, transformations, true); if (newData instanceof Sum) //todo apply transformations? return FastTensors.multiplySumElementsOnFactorAndExpand((Sum) newData, indexless); else //todo apply transformations? return expandIndexlessSubproduct.transform(Tensors.multiply(indexless, newData)); return FastTensors.multiplySumElementsOnFactorAndExpand((Sum) data, indexless); return Tensors.multiply(indexless, data);
term = FastTensors.multiplySumElementsOnFactors((Sum) term); result.put(term);
public static Tensor multiplySumElementsOnFactorAndExpand(Sum sum, Tensor factor, Transformation[] transformations) { if (TensorUtils.isZero(factor)) return Complex.ZERO; if (TensorUtils.isOne(factor)) return sum; if (factor instanceof Sum && factor.getIndices().size() != 0) throw new IllegalArgumentException(); if (TensorUtils.haveIndicesIntersections(sum, factor)) { SumBuilder sb = new SumBuilder(sum.size()); for (Tensor t : sum) sb.put(apply(transformations, ExpandUtils.expandIndexlessSubproduct.transform(multiply(t, factor)))); return sb.build(); } else return apply(transformations, FastTensors.multiplySumElementsOnFactorAndExpand(sum, factor)); }
/** * Multiplies each element in specified sum on some factor. * * @param sum sum * @param factor factor * @return resulting sum */ public static Tensor multiplySumElementsOnFactorAndResolveDummies(Sum sum, Tensor factor) { Tensor[] pair = resolveDummy(sum, factor); int i = pair[0] instanceof Sum ? 0 : 1; return multiplySumElementsOnFactor((Sum) pair[i], pair[1 - i], new Transformation[0]); }
Tensor g5 = pc.get(pg.gPositions.get(pg.g5Positions.first())); if (result instanceof Sum) result = FastTensors.multiplySumElementsOnFactorAndResolveDummies((Sum) result, g5); else result = multiplyAndRenameConflictingDummies(result, g5);
/** * Multiplies each element in specified sum on some factor (not a sum) and expands indexless parts. * * @param sum sum * @param factor factor * @return resulting sum * @throws IllegalArgumentException if factor is sum */ public static Tensor multiplySumElementsOnFactorAndExpand(Sum sum, Tensor factor) { if (factor instanceof Sum && factor.getIndices().size() != 0) throw new IllegalArgumentException(); return multiplySumElementsOnFactor(sum, factor, new Transformation[]{ExpandUtils.expandIndexlessSubproduct}); }
@Override protected Tensor transformLine(ProductOfGammas pg, IntArrayList modifiedElements) { assert pg.g5Positions.size() == 0 || (pg.g5Positions.size() == 1 && pg.g5Positions.first() == pg.length - 1) : "G5s are not simplified"; int length = pg.length; if (pg.g5Positions.size() == 1) --length; if (length <= 1) return null; ProductContent pc = pg.pc; StructureOfContractions st = pc.getStructureOfContractions(); Gamma[] gammas = new Gamma[length]; for (int i = 0; i < length; i++) { Tensor gamma = pc.get(pg.gPositions.get(i)); gammas[i] = new Gamma(gamma, gamma.getIndices().get(metricType, 0), getContraction(pg.gPositions.get(i), pc, st)); } Tensor ordered = orderArray(gammas); if (ordered == null) return null; if (pg.g5Positions.size() == 1) { Tensor g5 = pc.get(pg.gPositions.get(pg.g5Positions.first())); if (ordered instanceof Sum) ordered = multiplySumElementsOnFactorAndResolveDummies((Sum) ordered, g5); else ordered = multiplyAndRenameConflictingDummies(ordered, g5); } return ordered; }
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 order0(Tensor[] gammas) { if (gammas.length == 1) return gammas[0]; else if (gammas.length == 2) return metric(gammas); else { Tensor[] a = gammas.clone(); a[0] = Complex.TWO; a[1] = metric(gammas); Tensor[] b0 = gammas.clone(); swapAdj(b0, 0); Tensor b = order(Arrays.copyOfRange(b0, 1, b0.length)); if (b instanceof Sum) { Tensor[] pair = resolveDummy(b, b0[0]); b = FastTensors.multiplySumElementsOnFactor((Sum) pair[0], pair[1]); } else b = multiplyAndRenameConflictingDummies(b, b0[0]); return expandAndEliminate.transform(subtract(multiply(a), b)); } }
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)); }
Complex frac = new Complex(new Rational(BigInteger.ONE, factor)); if (t instanceof Sum) return FastTensors.multiplySumElementsOnFactor((Sum) t, frac); return Tensors.multiply(frac, t); } else
private Tensor simplify(Element el, IntArrayList gPositions, ProductContent pc) { Tensor[] gammas = new Tensor[el.gIndex2 - el.gIndex1 + 1]; for (int i = el.gIndex1; i <= el.gIndex2; ++i) { gammas[i - el.gIndex1] = pc.get(gPositions.get(i)); if (!isGamma(pc.get(gPositions.get(i)))) return null;//can not simplify } Tensor r = order(gammas); Tensor m = multiply(pc.get(el.tIndex1), pc.get(el.tIndex2)); if (r instanceof Sum) r = FastTensors.multiplySumElementsOnFactor((Sum) r, m); else r = multiply(r, m); r = expandAndEliminate.transform(r); r = traceOfOne.transform(r); r = deltaTrace.transform(r); return r; }
tensor = FastTensors.multiplySumElementsOnFactor((Sum) tensor, Complex.NEGATIVE_IMAGINARY_UNIT);
adj = multiply(cadj); adj = adj instanceof Sum ? multiplySumElementsOnFactor((Sum) adj, metric) : multiply(adj, metric); if (swaps % 2 == 1) adj = negate(adj);
adj = multiply(cadj); adj = adj instanceof Sum ? multiplySumElementsOnFactor((Sum) adj, metric) : multiply(adj, metric); sb.put(adj);