/** * Retrieves several sub-tensors from current tensor. This function is * faster than sequential invocations of {@link #get(int)} method. * * @param from index of first sub-tensor to be retrieved (inclusive) * @param to next index after last sub-tensor to be retrieved (exclusive) * @return array with retrieved tensors */ public Tensor[] getRange(int from, final int to) { int size = size(); if (from < 0 || from > to || to > size) throw new IndexOutOfBoundsException(); Tensor[] range = new Tensor[to - from]; for (size = 0; from < to; ++size, ++from) range[size] = get(from); return range; }
/** * Returns true if at least one free index of {@code u} is contracted * with some free index of {@code v}. * * @param u tensor * @param v tensor * @return true if at least one free index of {@code u} is contracted * with some free index of {@code v} */ public static boolean haveIndicesIntersections(Tensor u, Tensor v) { return IndicesUtils.haveIntersections(u.getIndices(), v.getIndices()); }
public SumBijectionPort(Tensor from, Tensor to) { if (from.size() > to.size()) { finished = true; return; int i, j = 0, fromBegin = 0, toBegin, fromSize = from.size(), toSize = to.size(); int mainStretchFromCoord = -1, mainStretchFromPointer = -1, mainStretchFromLength = -1, mainStretchToLength = Integer.MAX_VALUE, maintStretchIndex = -1; int hash = from.get(0).hashCode(); for (i = 1; i <= fromSize; ++i) { if (i == fromSize || from.get(i).hashCode() != hash) { for (; j < toSize; ++j) if (to.get(j).hashCode() >= hash) break; if (j == toSize || to.get(j).hashCode() > hash) { finished = true; break; if (to.get(j).hashCode() != hash) break; mappers.add(new SinglePairMapper(from.get(fromBegin), to.get(toBegin), toBegin)); else mappers.add(new StretchPairMapper(from.getRange(fromBegin, i), to.getRange(toBegin, j), toBegin)); if (j - toBegin < mainStretchToLength) { mainStretchToLength = j - toBegin; hash = from.get(i).hashCode(); source = new SinglePairSource(from.get(mainStretchFromCoord), to.get(mainStretchFromPointer), mainStretchFromPointer);
@Override public IndexMappingProvider create(IndexMappingProvider opu, Tensor from, Tensor to) { if (from.size() != to.size()) return IndexMappingProvider.Util.EMPTY_PROVIDER; for (int i = 0; i < from.size(); ++i) if (from.get(i).hashCode() != to.get(i).hashCode()) return IndexMappingProvider.Util.EMPTY_PROVIDER; return new ProviderSum(opu, from, to); } };
@Override public boolean is(Tensor object) { int toCheck; if (object instanceof SimpleTensor) toCheck = object.hashCode(); else if (object instanceof Power) { if (!(object.get(0) instanceof SimpleTensor)) return false; toCheck = object.get(0).hashCode(); } else return false; return Arrays.binarySearch(names, toCheck) >= 0; } };
private static boolean isSymbolicPoly(Tensor t) { if (t.getIndices().size() != 0 || t instanceof ScalarFunction) return false; if (t instanceof SimpleTensor) return t.size() == 0;//not a field if (t instanceof Power) { if (!isSymbolicPoly(t.get(0))) return false; if (!TensorUtils.isInteger(t.get(1))) return false; Complex e = (Complex) t.get(1); return e.isReal() && !e.isNumeric(); } for (Tensor tt : t) if (!isSymbolicPoly(tt)) return false; return true; }
/** * Returns new tensor instance with i-th sub-tensor replaced by provided * tensor. * * @param i index of sub-tensor to be replaced * @param tensor tensor to replace i-th sub-tensor * @return new instance of tensor */ public Tensor set(int i, Tensor tensor) { int size = size(); if (i >= size || i < 0) throw new IndexOutOfBoundsException(); if (tensor == null) throw new NullPointerException(); TensorBuilder builder = getBuilder(); for (int j = 0; j < size; ++j) if (j == i) builder.put(tensor); else builder.put(get(j)); return builder.build(); }
@Override public String toString(OutputFormat mode) { return "@[" + innerTensor.toString(mode) + "]"; } }
if (tensor instanceof TensorField) { boolean applied = false; TensorBuilder builder = tensor.getBuilder(); Tensor temp, current; for (int i = 0, size = tensor.size(); i < size; ++i) { current = tensor.get(i); temp = transform(current); if (current != temp) int i; boolean applied = false; for (i = tensor.size() - 1; i >= 0; --i) { current = tensor.get(i); if (Tensors.isKroneckerOrMetric(current)) applied = applied | (tempContainer.add(new MetricWrapper(current))); Tensor[] data = new Tensor[tensor.size()]; boolean applied = false; for (int i = tensor.size() - 1; i >= 0; --i) { oldTensor = tensor.get(i); if (i == 0) newTensor = transform(oldTensor, chain); TensorBuilder builder = tensor.getBuilder(); for (Tensor term : data) builder.put(term); return builder.build(); } else {
@Override public int hashCode() { return tensor.hashCode(); } }
static void addVars(Tensor tensor, TIntObjectMap<Var> vars, long power) { if (power < 0) throw new IllegalArgumentException("Negative powers."); if (tensor.getClass() == SimpleTensor.class) { if (tensor.getIndices().size() != 0) throw new IllegalArgumentException(); int name = ((SimpleTensor) tensor).getName(); Var var = vars.get(name); if (var == null) vars.put(name, var = new Var((SimpleTensor) tensor)); var.maxPower = Math.max(power, var.maxPower); return; } else if (tensor.getClass() == Power.class) { if (!TensorUtils.isNaturalNumber(tensor.get(1))) throw new IllegalArgumentException(tensor.toString()); long pow = power * ((Complex) tensor.get(1)).longValue(); addVars(tensor.get(0), vars, pow); return; } else if (tensor instanceof MultiTensor) { for (Tensor t : tensor) addVars(t, vars, power); return; } else if (tensor.getClass() == Complex.class) { if (((Complex) tensor).isNumeric() || !((Complex) tensor).isReal()) throw new IllegalArgumentException("Illegal coefficient: " + tensor); return; } throw new IllegalArgumentException(); }
int i; Tensor tensorCurrent, tempResult; Tensor[] newSumElements = new Tensor[tensor.size()]; boolean needRebuild = false; for (i = tensor.size() - 1; i >= 0; --i) { tensorCurrent = tensor.get(i); tempResult = transform(tensorCurrent); if (tensorCurrent != tempResult) return tensor.getFactory().create(newSumElements); else return tensor; IndicesBuilder ib = new IndicesBuilder(); List<Tensor> newProductElements = new ArrayList<>(); for (i = tensor.size() - 1; i >= 0; --i) { current = tensor.get(i); if (isN(current)) { ib.append(current); if (!(current instanceof Power) || !TensorUtils.isInteger(current.get(1)) || ((Complex) current.get(1)).intValue() != 2) throw new IllegalArgumentException(); Tensor[] bases = {current.get(0), current.get(0)}; bases[1] = ApplyIndexMapping.renameDummy(bases[1], TensorUtils.getAllIndicesNamesT(tensor).toArray()); flag = false; Tensor nBase = transform(tensor.get(0)); if (nBase == tensor.get(0))
private static boolean weakMatch(Tensor t0, Tensor t1) { if (t0.hashCode() != t1.hashCode()) return false; if (t0.getClass() != t1.getClass()) return false; //CHECKSTYLE //This test is highly assotiated with current architecture. //Can fail arter architecture change //BEWARE! if (t0.getIndices().getClass() != t1.getIndices().getClass()) return false; return t0.getIndices().size() == t1.getIndices().size(); }
public static boolean powerUnfoldApplicable(Tensor power, Indicator<Tensor> indicator) { return power instanceof Power && (power.get(0).getIndices().size() != 0 || (power.get(0) instanceof Product && !TensorUtils.isInteger(power.get(1))) ) && powerExpandApplicable1(power, indicator); }
/** * Creates iterator over tensor elements. * * @param tensor tensor */ public BasicTensorIterator(Tensor tensor) { this.tensor = tensor; this.size = tensor.size(); }
public static Expression[] setMandelstam5(Tensor[][] momentums, Tensor s, Tensor t1, Tensor t2, Tensor u1, Tensor u2) { checkMandelstamInput(momentums, 5); if (s.getIndices().getFree().size() != 0 || t1.getIndices().getFree().size() != 0 || t2.getIndices().getFree().size() != 0 || u1.getIndices().getFree().size() != 0 || u2.getIndices().getFree().size() != 0) throw new IllegalArgumentException("Mandelstam variables should be scalar."); parseExpression("s = " + s.toString(Redberry)), parseExpression("t1 = " + t1.toString(Redberry)), parseExpression("t2 = " + t2.toString(Redberry)), parseExpression("u1 = " + u1.toString(Redberry)), parseExpression("u2 = " + u2.toString(Redberry)),
Tensor a = renameIndicesOfFieldsArguments(tensor.get(0), forbidden), b = renameIndicesOfFieldsArguments(tensor.get(1), forbidden); if (a == tensor.get(0) && b == tensor.get(1)) return tensor; return tensor.getFactory().create(a, b); Tensor arg = renameIndicesOfFieldsArguments(tensor.get(0), forbidden); if (arg == tensor.get(0)) return tensor; return tensor.getFactory().create(arg);
TensorBuilder rebuild = result.getBuilder(); List<Tensor[]> list; for (Tensor t : result) { oldCoefficient = sc[0]; list = coefficients.get(oldCoefficient.hashCode()); if (list == null) { list = new ArrayList<>(); coefficients.put(oldCoefficient.hashCode(), list);