protected int del(List<Tensor> arr, int i) { Tensor t = arr.remove(i); if (arr.isEmpty()) return t.getIndices().getLower().get(matrixType, 0); if (i == 0) { arr.set(0, setUpperMatrixIndex((SimpleTensor) arr.get(0), t.getIndices().getUpper().get(matrixType, 0))); return t.getIndices().getLower().get(matrixType, 0); } else if (i == arr.size()) { arr.set(arr.size() - 1, setLowerMatrixIndex((SimpleTensor) arr.get(arr.size() - 1), t.getIndices().getLower().get(matrixType, 0))); return t.getIndices().getUpper().get(matrixType, 0); } else { arr.set(i, setUpperMatrixIndex((SimpleTensor) arr.get(i), t.getIndices().getUpper().get(matrixType, 0))); return t.getIndices().getLower().get(matrixType, 0); } }
protected Tensor[] cutAdj(Tensor[] original, int i) { if (original.length < 2) return original; Tensor[] n = new Tensor[original.length - 2]; System.arraycopy(original, 0, n, 0, i); System.arraycopy(original, i + 2, n, i, original.length - i - 2); if (n.length == 0) return n; int u, l; if (i == 0) { i = 1; u = original[0].getIndices().getUpper().get(matrixType, 0); l = n[i - 1].getIndices().getLower().get(matrixType, 0); } else if (i == original.length - 2) { u = n[i - 1].getIndices().getUpper().get(matrixType, 0); l = original[original.length - 1].getIndices().getLower().get(matrixType, 0); } else { u = n[i - 1].getIndices().getUpper().get(matrixType, 0); l = n[i].getIndices().getUpper().get(matrixType, 0); } n[i - 1] = setMatrixIndices((SimpleTensor) n[i - 1], u, l); return n; }
protected static SimpleTensor setMatrixIndices(SimpleTensor gamma, Indices matrixIndices) { return setMatrixIndices(gamma, matrixIndices.getUpper().get(0), matrixIndices.getLower().get(0)); }
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; } }
protected Tensor[] del(Tensor[] arr, int i) { Tensor t = arr[i]; arr = ArraysUtils.remove(arr, i); if (arr.length == 0) return arr; if (i == 0) arr[0] = setUpperMatrixIndex((SimpleTensor) arr[0], t.getIndices().getUpper().get(matrixType, 0)); else if (i == arr.length) arr[arr.length - 1] = setLowerMatrixIndex((SimpleTensor) arr[arr.length - 1], t.getIndices().getLower().get(matrixType, 0)); else arr[i] = setUpperMatrixIndex((SimpleTensor) arr[i], t.getIndices().getUpper().get(matrixType, 0)); return arr; }
private Tensor orderArray(Gamma[] gammas) { final int numberOfGammas = gammas.length; int[] permutation = Permutations.createIdentityArray(numberOfGammas); Tensor fGamma = gammas[0].gamma, lGamma = gammas[gammas.length - 1].gamma; int[] mIndices = new int[numberOfGammas]; for (int i = 0; i < numberOfGammas; ++i) mIndices[i] = gammas[i].index; //use stable sort! //!! gammas is lost now !! ArraysUtils.insertionSort(gammas, permutation); if (Permutations.isIdentity(permutation)) return null;//signals that array is sorted! Cached cached = cache.get(new IntArray(permutation)); if (cached == null) { Tensor[] arr = createArray(permutation); Tensor ordered = eliminate(orderArray0(arr.clone())); cache.put(new IntArray(permutation), cached = new Cached(arr, ordered)); } int[] iFrom = new int[numberOfGammas + 2], iTo = new int[numberOfGammas + 2]; System.arraycopy(cached.getOriginalIndices(metricType), 0, iFrom, 0, numberOfGammas); System.arraycopy(mIndices, 0, iTo, 0, numberOfGammas); iFrom[numberOfGammas] = cached.originalArray[0].getIndices().getUpper().get(matrixType, 0); iTo[numberOfGammas] = fGamma.getIndices().getUpper().get(matrixType, 0); iFrom[numberOfGammas + 1] = cached.originalArray[numberOfGammas - 1].getIndices().getLower().get(matrixType, 0); iTo[numberOfGammas + 1] = lGamma.getIndices().getLower().get(matrixType, 0); return eliminate(ApplyIndexMapping.applyIndexMapping(cached.ordered, new Mapping(iFrom, iTo))); }
leftSubIndices = leftIndices.getOfType(type); leftUpperCount = leftSubIndices.getUpper().size(); leftLowerCount = leftSubIndices.getLower().size(); rightSubIndices = rightIndices.getOfType(type); rightUpperCount = rightSubIndices.getUpper().size(); rightLowerCount = rightSubIndices.getLower().size();
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))); }
private Tensor order(Tensor[] gammas) { int numberOfGammas = gammas.length; Tensor tensor = cache.get(numberOfGammas); if (tensor == null) cache.put(numberOfGammas, tensor = order0(createLine(numberOfGammas))); int[] iFrom = new int[numberOfGammas + 2], iTo = new int[numberOfGammas + 2]; for (int i = 0; i < numberOfGammas; ++i) { iFrom[i] = setType(metricType, i); iTo[i] = gammas[i].getIndices().get(metricType, 0); } iFrom[numberOfGammas] = setType(matrixType, 0) | 0x80000000; iTo[numberOfGammas] = gammas[0].getIndices().getUpper().get(matrixType, 0); iFrom[numberOfGammas + 1] = setType(matrixType, numberOfGammas); iTo[numberOfGammas + 1] = gammas[numberOfGammas - 1].getIndices().getLower().get(matrixType, 0); return eliminate(ApplyIndexMapping.applyIndexMapping(tensor, new Mapping(iFrom, iTo))); }
factorIndices.getUpper().toArray(), factorIndices.getLower().toArray())); SimpleIndices currentFactorIndices; IntArrayList from = new IntArrayList(), to = new IntArrayList();
Tensor move0(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); int numberOfGammas = gammas.length; IntArrayList iFrom = new IntArrayList(numberOfGammas + 2), iTo = new IntArrayList(numberOfGammas + 2), g5s = new IntArrayList(); for (int i = 0; i < numberOfGammas; ++i) { if (isGamma5(gammas[i])) g5s.add(i); else { iFrom.add(setType(metricType, i)); iTo.add(gammas[i].getIndices().get(metricType, 0)); } } iFrom.add(setType(matrixType, 0) | 0x80000000); iTo.add(gammas[0].getIndices().getUpper().get(matrixType, 0)); iFrom.add(setType(matrixType, numberOfGammas)); iTo.add(gammas[numberOfGammas - 1].getIndices().getLower().get(matrixType, 0)); Holder key = new Holder(index, numberOfGammas, g5s, left); Tensor tensor = cache.get(key); if (tensor == null) cache.put(key, tensor = left ? toLeft0(createLine(numberOfGammas, g5s), index) : toRight0(createLine(numberOfGammas, g5s), index)); return eliminate(ApplyIndexMapping.applyIndexMapping(tensor, new Mapping(iFrom.toArray(), iTo.toArray()))); }
int[] indicesArray = indices.getAllIndices().copy(); List<Permutation> symmetries = TensorUtils.getIndicesSymmetriesForIndicesWithSameStates(indicesArray, tensor); int lowerCount = indices.getLower().size(), upperCount = indices.getUpper().size();
Tensor adj; if (cadj.length == 0) adj = createMetricOrKronecker(gammas[j].getIndices().getUpper().get(matrixType, 0), gammas[j + 1].getIndices().getLower().get(matrixType, 0)); else if (cadj.length == 1)
Tensor adj; if (cadj.length == 0) adj = createMetricOrKronecker(gammas[index - 1].getIndices().getUpper().get(matrixType, 0), gammas[index].getIndices().getLower().get(matrixType, 0)); else if (cadj.length == 1)
Tensor adj; if (cadj.length == 0) adj = createMetricOrKronecker(gammas[index].getIndices().getUpper().get(matrixType, 0), gammas[index + 1].getIndices().getLower().get(matrixType, 0)); else if (cadj.length == 1)