/** * Returns {@code indices.size() == 0}. * * @param indices indices to testing similarity * @return {@code indices.size() == 0} */ @Override public boolean equalsRegardlessOrder(Indices indices) { return indices.size() == 0; }
public static boolean sumContainsIndexed(Tensor t) { if (!(t instanceof Sum)) return false; for (Tensor s : t) if (s.getIndices().size() != 0) return true; return false; }
boolean contracted() { return contraction instanceof SimpleTensor && contraction.getIndices().size() == 1; }
/** * Returns an array of indices names (with types), presented in specified {@code Indices} * object with the same ordering. * * @param indices * @return array of indices names (with types) */ public static int[] getIndicesNames(Indices indices) { int a[] = new int[indices.size()]; for (int i = indices.size() - 1; i >= 0; --i) a[i] = getNameWithType(indices.get(i)); return a; }
public static boolean equalsRegardlessOrder(Indices indices1, int[] indices2) { if (indices1 instanceof EmptyIndices) return indices2.length == 0; if (indices1.size() != indices2.length) return false; int[] temp = indices2.clone(); Arrays.sort(temp); return Arrays.equals(((AbstractIndices) indices1).getSortedData(), temp); }
private static Tensor[] expandSamples(Tensor[] samples) { //select diff samples: HashSet<Wrapper> set = new HashSet<>(); for (Tensor sample : samples) set.add(new Wrapper(sample)); ArrayList<Tensor> r = new ArrayList<>(); for (Wrapper st : set) { r.ensureCapacity(ArithmeticUtils.pow(2, st.tensor.getIndices().getFree().size())); r.addAll(Arrays.asList(TensorGeneratorUtils.allStatesCombinations(st.tensor))); } return r.toArray(new Tensor[r.size()]); }
public static boolean isSymbolic(Tensor t) { if (t.getIndices().size() != 0) return false; for (Tensor c : t) if (!isSymbolic(c)) return false; return true; }
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(); }
private static boolean containsSubIndices(Indices indices, Indices subIndices) { int[] indicesArray = IndicesUtils.getIndicesNames(indices); Arrays.sort(indicesArray); for (int i = 0, size = subIndices.size(); i < size; ++i) if (Arrays.binarySearch(indicesArray, getNameWithType(subIndices.get(i))) < 0) return false; return true; }
private PrimitiveSubgraph[] calculatePartition() { List<PrimitiveSubgraph> subgraphs = new ArrayList<>(); for (int pivot = 0; pivot < size; ++pivot) if (pc.get(pivot).getIndices().size(type) != 0 && !used.get(pivot)) subgraphs.add(calculateComponent(pivot)); return subgraphs.toArray(new PrimitiveSubgraph[subgraphs.size()]); }
private static boolean containsIndicesNames(TIntHashSet set, Indices indices) { for (int i = 0; i < indices.size(); ++i) if (set.contains(getNameWithType(indices.get(i)))) return true; return false; }
private static void getAllIndices1(ParseToken node, Set<Integer> set) { if (node instanceof ParseTokenSimpleTensor) { Indices indices = node.getIndices(); for (int i = indices.size() - 1; i >= 0; --i) set.add(IndicesUtils.getNameWithType(indices.get(i))); } else for (ParseToken pn : node.content) if (!(pn instanceof ParseTokenScalarFunction)) getAllIndices1(pn, set); }
private static Tensor multiplySumElementsOnFactor(Sum sum, Tensor factor, Transformation[] transformations) { if (TensorUtils.isZero(factor)) return Complex.ZERO; if (TensorUtils.isOne(factor)) return sum; if (TensorUtils.haveIndicesIntersections(sum, factor) || (sum.indices.size() == 0 && factor.getIndices().size() != 0)) return multiplyWithBuilder(sum, factor, transformations); else return multiplyWithFactory(sum, factor, transformations); }
private static int hc(Tensor t, int[] inds) { Indices ind = t.getIndices().getFree(); int h = 31; int ii; for (int i = ind.size() - 1; i >= 0; --i) { ii = IndicesUtils.getNameWithType(ind.get(i)); if ((ii = Arrays.binarySearch(inds, ii)) >= 0) h ^= HashFunctions.JenkinWang32shift(ii); } return h; }
@Override public IndexMappingProvider create(IndexMappingProvider opu, Tensor from, Tensor to) { if (((SimpleTensor) from).getName() != ((SimpleTensor) to).getName()) return IndexMappingProvider.Util.EMPTY_PROVIDER; if (from.getIndices().size() == 0) return new DummyIndexMappingProvider(opu); return new ProviderSimpleTensor(opu, (SimpleTensor) from, (SimpleTensor) to); } };
private static void getAllIndicesT1(ParseToken node, TIntSet set) { if (node instanceof ParseTokenSimpleTensor) { Indices indices = node.getIndices(); for (int i = indices.size() - 1; i >= 0; --i) set.add(IndicesUtils.getNameWithType(indices.get(i))); } else for (ParseToken pn : node.content) if (!(pn instanceof ParseTokenScalarFunction)) getAllIndicesT1(pn, set); } }
private int withMomentum(int gamma, ProductContent pc, StructureOfContractions sc) { Indices indices = pc.get(gamma).getIndices(); int j = 0; for (; j < indices.size(); ++j) if (metricType.getType() == getType(indices.get(j))) break; return getToTensorIndex(sc.contractions[gamma][j]); }
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); }
private Element getContraction(int gIndex, int gamma, ProductContent pc, StructureOfContractions sc) { Indices indices = pc.get(gamma).getIndices(); int j = 0; for (; j < indices.size(); ++j) if (metricType.getType() == getType(indices.get(j))) break; int to = getToTensorIndex(sc.contractions[gamma][j]); if (to == -1) return null; return new Element(to, gIndex); }
private Tensor getContraction(int gamma, ProductContent pc, StructureOfContractions sc) { Indices indices = pc.get(gamma).getIndices(); int j = 0; for (; j < indices.size(); ++j) if (metricType.getType() == getType(indices.get(j))) break; int to = getToTensorIndex(sc.contractions[gamma][j]); if (to == -1) return null; return pc.get(to); }