/** * Parses string expression and returns indices allowing repeated indices with same states (like T_ii): appropriate * raising or lowering will be performed automatically. * * @param expression string representation of indices * @return integer indices * @throws IllegalArgumentException if string does not represent correct indices object. */ public static SimpleIndices parseSimpleIgnoringVariance(String expression) { int[] indices = parse(expression); out: for (int i = 0; i < indices.length - 1; ++i) for (int j = i + 1; j < indices.length; ++j) if (indices[i] == indices[j]) { indices[i] = IndicesUtils.inverseIndexState(indices[i]); continue out; } return IndicesFactory.createSimple(null, indices); }
/** * Returns an array of contracted indices between specified free indices. * * @param freeIndices1 free indices * @param freeIndices2 free indices * @return an array of contracted indices */ public static int[] getIntersections(int[] freeIndices1, int[] freeIndices2) { //micro optimization if (freeIndices1.length > freeIndices2.length) { int[] temp = freeIndices1; freeIndices1 = freeIndices2; freeIndices2 = temp; } IntArrayList contracted = new IntArrayList(); for (int i = 0; i < freeIndices1.length; ++i) for (int j = 0; j < freeIndices2.length; ++j) if (freeIndices2[j] == inverseIndexState(freeIndices1[i])) contracted.add(getNameWithType(freeIndices2[j])); return contracted.toArray(); }
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)}; }
private static void revertIndex(ParseToken token, int index) { if (token instanceof ParseTokenSimpleTensor) { ParseTokenSimpleTensor pToken = (ParseTokenSimpleTensor) token; SimpleIndices indices = pToken.indices; for (int i = 0; i < indices.size(); i++) { if (indices.get(i) == index) { int[] inds = indices.toArray(); inds[i] = IndicesUtils.inverseIndexState(index); pToken.indices = IndicesFactory.createSimple(null, inds); break; } } } else if (token.tokenType == TokenType.Product || token.tokenType == TokenType.Trace || token.tokenType == TokenType.Sum) for (ParseToken c : token.content) revertIndex(c, index); } }
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; }
append(covariantIndicesString); for (k = 0; k < j; ++k) sb.append("*n").append(IndicesUtils.toString(IndicesUtils.inverseIndexState(covariantIndices[k]), OutputFormat.Redberry)); append(matricIndices); for (k = 0; k < i; ++k) sb.append("*n").append(IndicesUtils.toString(IndicesUtils.inverseIndexState(covariantIndices[k]), OutputFormat.Redberry)); temp = Tensors.parse(sb.toString()); temp = inputValues[0].transform(temp);
/** * Returns true if at least one free index of {@code u} is contracted * with some free index of {@code v}. * * @param u indices * @param v indices * @return true if at least one free index of {@code u} is contracted * with some free index of {@code v} */ public static boolean haveIntersections(Indices u, Indices v) { //todo can be improved Indices uFree = u.getFree(), vFree = v.getFree(); //micro optimization if (uFree.size() > vFree.size()) { Indices temp = uFree; uFree = vFree; vFree = temp; } for (int i = 0; i < uFree.size(); ++i) for (int j = 0; j < vFree.size(); ++j) if (vFree.get(j) == inverseIndexState(uFree.get(i))) return true; return false; }
index = IndicesUtils.inverseIndexState(index); component = indexToComponent.remove(index); if (component != null) {
from.add(index); to.add(newIndex); kroneckers.add(Tensors.createKronecker(index, inverseIndexState(newIndex))); } else if (IndicesUtils.getState(index) && dummies.contains(getNameWithType(index))) { newIndex = setRawState(getRawStateInt(index), generator.generate(getType(index))); from.add(index); to.add(newIndex); kroneckers.add(Tensors.createKronecker(index, inverseIndexState(newIndex)));
contract = false; for (a = 0; a < epsIndices.length; ++a) if (indices[b] == inverseIndexState(epsIndices[a])) contract = true; if (!contract)
upper[i] = IndicesUtils.inverseIndexState(numberOfIndices + i);
indicesSpace[b][i] = indexGenerator.generate(b); for (i = 0; i < diff; ++i) indicesSpace[b][i + diff] = IndicesUtils.inverseIndexState(indicesSpace[b][i]); System.arraycopy(freeIndices[b], 0, indicesSpace[b], diff * 2, freeIndices[b].length); shuffle(indicesSpace[b]);
return currentBuffer = null; int toIndex = inverseIndexState(setRawState(bRec.getToRawState(), bRec.getIndexName())); for (int mapTo = 0; mapTo < size; ++mapTo) { if (toIndices.get(mapTo) == toIndex) {
type = getType(varIndices.get(i)); state = getRawStateInt(varIndices.get(i)); allFreeVarIndices[i] = setRawState(indexGenerator.generate(type), inverseIndexState(state)); allFreeArgIndices[i] = setRawState(indexGenerator.generate(type), state);