@Override public Tensor toTensor() { return Tensors.simpleTensor(name, indices); }
/** * Generates a new symbol which never used before during current session. * * @return new symbol which never used before during current session */ public SimpleTensor generateNewSymbol() { NameDescriptor nameDescriptor = nameManager.generateNewSymbolDescriptor(); return Tensors.simpleTensor(nameDescriptor.getId(), IndicesFactory.EMPTY_SIMPLE_INDICES); }
@Override public SimpleTensor take() { SimpleTensor st; do { st = Tensors.simpleTensor(prefix + (counter++), IndicesFactory.EMPTY_SIMPLE_INDICES); } while (forbiddenNames.contains(st.getName())); return st; } }
protected Tensor[] createLine(final int length) { Tensor[] gammas = new Tensor[length]; int matrixIndex, u = matrixIndex = setType(matrixType, 0); for (int i = 0; i < length; ++i) gammas[i] = Tensors.simpleTensor(gammaName, createSimple(null, u | 0x80000000, u = ++matrixIndex, setType(metricType, i))); return gammas; }
private Tensor[] createLine(final int length, final IntArrayList g5s) { Tensor[] gammas = new Tensor[length]; int matrixIndex, metricIndex = 0, u = matrixIndex = setType(matrixType, 0); int j = 0; for (int i = 0; i < length; ++i) { if (j < g5s.size() && g5s.get(j) == i) { gammas[i] = Tensors.simpleTensor(gamma5Name, createSimple(null, u | 0x80000000, u = ++matrixIndex)); ++j; } else gammas[i] = Tensors.simpleTensor(gammaName, createSimple(null, u | 0x80000000, u = ++matrixIndex, setType(metricType, metricIndex++))); } return gammas; }
private Tensor simplifyProduct(List<Tensor> gammas) { int upper = gammas.get(0).getIndices().getUpper().get(matrixType, 0), lower = gammas.get(gammas.size() - 1).getIndices().getLower().get(matrixType, 0); int initialSize = gammas.size(); boolean sign = false; int dummy = -1; for (int i = gammas.size() - 1; i >= 0; --i) { if (isGamma5(gammas.get(i))) { sign ^= (gammas.size() - i) % 2 == 0; dummy = del(gammas, i); } } if ((initialSize - gammas.size()) % 2 == 1) { //adding last gamma if (gammas.isEmpty()) gammas.add(simpleTensor(gamma5Name, createSimple(null, upper, lower))); else { Tensor t = gammas.get(gammas.size() - 1); gammas.set(gammas.size() - 1, setLowerMatrixIndex((SimpleTensor) t, dummy)); gammas.add(simpleTensor(gamma5Name, createSimple(null, raise(dummy), t.getIndices().getLower().get(matrixType, 0)))); } } Tensor r = multiply(gammas); if (sign) r = negate(r); return r; } }
public SimpleTensor nextSimpleTensor() { NameDescriptor nd = nextNameDescriptor(); StructureOfIndices structureOfIndices = nd.getStructureOfIndices(); int[] indices = nextIndices(structureOfIndices); return Tensors.simpleTensor(nd.getId(), IndicesFactory.createSimple(nd.getSymmetries(), indices)); }
private Tensor[] createArray(final int[] permutation) { int[] metricIndices = new int[permutation.length]; for (int i = 0; i < permutation.length; ++i) metricIndices[i] = setType(metricType, i); metricIndices = Permutations.permute(metricIndices, Permutations.inverse(permutation)); Tensor[] gammas = new Tensor[permutation.length]; int matrixIndex, u = matrixIndex = setType(matrixType, 0); for (int i = 0; i < permutation.length; ++i) { gammas[i] = Tensors.simpleTensor(gammaName, createSimple(null, u | 0x80000000, u = ++matrixIndex, metricIndices[i])); } return gammas; }
public SimpleTensor nextSimpleTensor(SimpleIndices indices) { NameDescriptor nd = nextNameDescriptor(indices.getStructureOfIndices()); StructureOfIndices structureOfIndices = nd.getStructureOfIndices(); int[] _indices = nextIndices(structureOfIndices); return Tensors.simpleTensor(nd.getId(), IndicesFactory.createSimple(nd.getSymmetries(), _indices)); }
protected static SimpleTensor setMetricIndex(SimpleTensor gamma, int metricIndex) { int[] indices = gamma.getIndices().getAllIndices().copy(); for (int i = indices.length - 1; i >= 0; --i) if (CC.isMetric(getType(indices[i]))) indices[i] = metricIndex; return simpleTensor(gamma.getName(), IndicesFactory.createSimple(null, indices)); }
/** * Returns metric tensor with specified indices. * * @param index1 first index * @param index2 second index * @return metric tensor with specified indices * @throws IllegalArgumentException if indices have different states * @throws IllegalArgumentException if indices have different types * @throws IllegalArgumentException if indices have non metric types */ public SimpleTensor createMetric(int index1, int index2) { byte type; if ((type = IndicesUtils.getType(index1)) != IndicesUtils.getType(index2) || !IndicesUtils.haveEqualStates(index1, index2) || !metricTypesBits.get(type)) throw new IllegalArgumentException("Not metric indices."); SimpleIndices indices = IndicesFactory.createSimple(null, index1, index2); NameDescriptor nd = nameManager.mapNameDescriptor(nameManager.getMetricName(), StructureOfIndices.create(indices)); int name = nd.getId(); return Tensors.simpleTensor(name, indices); }
private static Tensor applyDirectMapping(Tensor t, DirectIndexMapping mapping) { if (t instanceof SimpleTensor) { SimpleTensor st = (SimpleTensor) t; SimpleIndices newIndices = st.getIndices().applyIndexMapping(mapping); if (t instanceof TensorField) return Tensors.field(st.getName(), newIndices, ((TensorField) st).getArgIndices(), ((TensorField) st).getArguments()); else return Tensors.simpleTensor(st.getName(), newIndices); } else { assert t.getIndices().size() == 0; return t; } }
SimpleTensor apply(SimpleTensor t) { SimpleIndices oldIndices = t.getIndices(); int from = -1, to = -1; OUTER: for (int i = 0; i < oldIndices.size(); ++i) for (int j = 0; j < 2; ++j) if ((oldIndices.get(i) ^ indices[j]) == 0x80000000) { from = oldIndices.get(i); to = indices[1 - j]; break OUTER; } IM im = new IM(from, to); SimpleIndices newIndices = oldIndices.applyIndexMapping(im); if (oldIndices == newIndices) return t; if (t.getClass() == SimpleTensor.class) return Tensors.simpleTensor(t.getName(), newIndices); TensorField ff = (TensorField) t; return Tensors.field(ff.getName(), newIndices, ff.getArgIndices(), ff.getArguments()); }
/** * Returns Kronecker tensor with specified upper and lower indices. * * @param index1 first index * @param index2 second index * @return Kronecker tensor with specified upper and lower indices * @throws IllegalArgumentException if indices have same states * @throws IllegalArgumentException if indices have different types */ public SimpleTensor createKronecker(int index1, int index2) { byte type; if ((type = IndicesUtils.getType(index1)) != IndicesUtils.getType(index2) || IndicesUtils.getRawStateInt(index1) == IndicesUtils.getRawStateInt(index2)) throw new IllegalArgumentException("This is not kronecker indices!"); if (!isMetric(type) && IndicesUtils.getState(index2)) { int t = index1; index1 = index2; index2 = t; } SimpleIndices indices = IndicesFactory.createSimple(null, index1, index2); NameDescriptor nd = nameManager.mapNameDescriptor(nameManager.getKroneckerName(), StructureOfIndices.create(indices)); int name = nd.getId(); return Tensors.simpleTensor(name, indices); }
private Expression getTraceSubstitution(int length) { Expression trace = cachedTraces.get(length); if (trace == null) { //product of gamma matrices as array Tensor[] data = new Tensor[length]; int matrixIndex = setType(matrixType, 0) - 1, metricIndex = -1; int firstUpper, u = firstUpper = ++matrixIndex, i; for (i = 0; i < length; ++i) { data[i] = Tensors.simpleTensor(gammaMatrixStringName, createSimple(null, u | 0x80000000, i == length - 1 ? firstUpper : (u = ++matrixIndex), setType(metricType, ++metricIndex))); } Tensor rhs = traceOfArray(data); rhs = expandAndEliminate.transform(rhs); cachedTraces.put(length, trace = expression(multiply(data), rhs)); } return trace; }
protected static SimpleTensor setMatrixIndices(SimpleTensor gamma, int matrixUpper, int matrixLower) { int[] indices = gamma.getIndices().getAllIndices().copy(); for (int i = indices.length - 1; i >= 0; --i) if (!CC.isMetric(getType(indices[i]))) { indices[i] = getState(indices[i]) ? createIndex(matrixUpper, getType(indices[i]), getState(indices[i])) : createIndex(matrixLower, getType(indices[i]), getState(indices[i])); } return simpleTensor(gamma.getName(), IndicesFactory.createSimple(null, indices)); }
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)); }
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)}; }
SimpleTensor symmetric = simpleTensor("@!@#@##_AS@23@@#", dIndices); SimpleIndices allFreeVarIndicesI = IndicesFactory.createSimple(varIndices.getSymmetries(), allFreeVarIndices); Tensor derivative =