/** * Returns an instance of specified simple tensor with specified indices * * @param tensor simple tensor * @param indices indices * @return instance of specified simple tensor with specified indices */ public static SimpleTensor setIndices(SimpleTensor tensor, int[] indices) { return setIndices(tensor, IndicesFactory.createSimple(null, indices)); }
/** * Parses string expression and returns indices. * * @param expression string representation of indices * @return integer indices * @throws IllegalArgumentException if string does not represent correct indices object. */ public static SimpleIndices parseSimple(String expression) { return IndicesFactory.createSimple(null, parse(expression)); }
public static String toString(int[] indices, OutputFormat mode) { //todo refactor using StringBuilder since InconsistensIndicesException can be thrown return IndicesFactory.createSimple(null, indices).toString(mode); }
private Wrapper(Tensor tensor) { this.tensor = tensor; this.freeIndices = StructureOfIndices.create( IndicesFactory.createSimple(null, tensor.getIndices().getFree())); }
/** * Returns an array of free indices only * * @param indices * @return array of free indices only */ public static int[] getFree(int[] indices) { return IndicesFactory.createSimple(null, indices).getFree().getAllIndices().copy(); }
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; }
public Tensor nextTensorTree(TensorType head, int depth, Parameters parameters, Indices indices) { if (head == null) nextTensorTree(depth, parameters, indices); indices = indices.getFree(); if (depth == 0) return nextSimpleTensor(IndicesFactory.createSimple(null, indices)); if (head == TensorType.Product) return nextProductTree(depth, parameters, indices); if (head == TensorType.Sum) return nextSumTree(depth, parameters, indices); throw new RuntimeException(); }
protected Tensor nextTensorTree(TensorType head, int depth, Parameters parameters) { return nextTensorTree(head, depth, parameters, IndicesFactory.createSimple(null, nextIndices(nextNameDescriptor().getStructureOfIndices()))); }
@Override public void apply(IndexMapper indexMapper, IGWrapper generator, int[] upper, int[] lower) { SimpleIndices oldIndices = node.indices; int[] _newIndices = new int[oldIndices.size() + 2 * upper.length]; int i; for (i = 0; i < oldIndices.size(); ++i) _newIndices[i] = indexMapper.map(oldIndices.get(i)); System.arraycopy(upper, 0, _newIndices, oldIndices.size(), upper.length); System.arraycopy(lower, 0, _newIndices, oldIndices.size() + upper.length, lower.length); for (i = 0; i < upper.length; ++i) _newIndices[i + oldIndices.size()] |= 0x80000000; node.indices = IndicesFactory.createSimple(null, _newIndices); } }
@Override public NameAndStructureOfIndices getIndicesTypeStructureAndName() { StructureOfIndices[] typeStructures = new StructureOfIndices[1 + argumentsIndices.length]; typeStructures[0] = StructureOfIndices.create(indices); for (int i = 0; i < argumentsIndices.length; ++i) { if (argumentsIndices[i] == null) argumentsIndices[i] = IndicesFactory.createSimple(null, content[i].getIndices().getFree()); typeStructures[i + 1] = StructureOfIndices.create(argumentsIndices[i]); } return new NameAndStructureOfIndices(name, typeStructures); }
@Override public void apply(IndexGeneratorImpl generator, int[][] upper, int[][] lower) { SimpleIndices oldIndices = node.indices; int[] result = ArraysUtils.addAll(oldIndices.getAllIndices().copy(), ArraysUtils.addAll(upper), ArraysUtils.addAll(lower)); node.indices = IndicesFactory.createSimple(null, result); } }
public SimpleTensor nextSimpleTensor() { NameDescriptor nd = nextNameDescriptor(); 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)); }
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)); }
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 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 SimpleIndices transformIndices(SimpleIndices old, NameAndStructureOfIndices oldDescriptor) { int[] newIndices = new int[old.size()]; for (int i = old.size() - 1; i >= 0; --i) { newIndices[i] = IndicesUtils.setType(transformer.newType(IndicesUtils.getTypeEnum(old.get(i)), oldDescriptor), old.get(i)); newIndices[i] = transformer.newIndex(newIndices[i], oldDescriptor); } return IndicesFactory.createSimple(null, newIndices); } }
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 SimpleTensor setMatrixIndices0(SimpleTensor tensor, int... indices) { int[] newIndices = new int[tensor.getIndices().size()]; int j = 0; for (int i = 0; i < tensor.getIndices().size(); ++i) if (getType(tensor.getIndices().get(i)) == matrixType.getType()) newIndices[i] = indices[j++]; else newIndices[i] = tensor.getIndices().get(i); return setIndices(tensor, createSimple(null, newIndices)); }
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)); }