private Var(SimpleTensor simpleTensor) { this.simpleTensor = simpleTensor; this.name = simpleTensor.getName(); }
private static boolean isLeviCivita(Tensor tensor, int leviCivitaName) { return tensor instanceof SimpleTensor && ((SimpleTensor) tensor).getName() == leviCivitaName; }
/** * Returns {@code true} if specified tensor is a metric or a Kronecker tensor * * @param t tensor * @return {@code true} if specified tensor is a metric or a Kronecker tensor */ public boolean isKroneckerOrMetric(SimpleTensor t) { return nameManager.isKroneckerOrMetric(t.getName()); }
public SqrSubs(SimpleTensor st) { if (st.getIndices().size() != 1) throw new IllegalArgumentException(); name = st.getName(); }
private static void addAllDiffSimpleTensors(Tensor tensor, TIntObjectHashMap<SimpleTensor> names) { if (tensor instanceof SimpleTensor) names.put(((SimpleTensor) tensor).getName(), (SimpleTensor) tensor); else for (Tensor t : tensor) addAllDiffSimpleTensors(t, names); }
@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); } };
/** * Adds new insertion rule to this transformer. <p/> <p>After rule is added you can omit indices of specified type * in specified simple tensors, when this transformer is passed to {@link cc.redberry.core.tensor.Tensors#parse(String, * cc.redberry.core.parser.ParseTokenTransformer...)} method or somehow added to default parse nodes * preprocessor.</p> * * @param tensor simple tensor * @param omittedIndexType type of indices that may be omitted */ public void addInsertionRule(SimpleTensor tensor, IndexType omittedIndexType) { addInsertionRule(CC.getNameDescriptor(tensor.getName()), omittedIndexType); }
@Override public SimpleTensor take() { SimpleTensor st; do { st = Tensors.simpleTensor(prefix + (counter++), IndicesFactory.EMPTY_SIMPLE_INDICES); } while (forbiddenNames.contains(st.getName())); return st; } }
private static boolean isUnitaryMatrixOrOne(Tensor tensor, int unitaryMatrix) { if (tensor instanceof SimpleTensor) { int name = ((SimpleTensor) tensor).getName(); return name == unitaryMatrix || CC.getNameManager().isKroneckerOrMetric(name); } return false; }
private static void addSymbolsNames(Tensor tensor, TIntHashSet set) { if (isSymbol(tensor)) { set.add(((SimpleTensor) tensor).getName()); } else for (Tensor t : tensor) addSymbolsNames(t, set); }
private static Tensor applyDirectMapping(Tensor t, DirectIndexMapping mapping) { if (t instanceof SimpleTensor) { SimpleTensor st = (SimpleTensor) t; SimpleIndices newIndices = st.getIndices().applyIndexMapping(mapping); if (t instanceof TensorField) return Tensors.field(st.getName(), newIndices, ((TensorField) st).getArgIndices(), ((TensorField) st).getArguments()); else return Tensors.simpleTensor(st.getName(), newIndices); } else { assert t.getIndices().size() == 0; return t; } }
/** * Returns {@code true} if specified tensor is a metric tensor * * @param t tensor * @return {@code true} if specified tensor is a metric tensor */ public boolean isMetric(SimpleTensor t) { return nameManager.isKroneckerOrMetric(t.getName()) && IndicesUtils.haveEqualStates(t.getIndices().get(0), t.getIndices().get(1)); }
private static TIntHashSet addSimpleTensorsNames(Tensor t, TIntHashSet names) { if (t instanceof TensorField) names.add(((TensorField) t).getNameDescriptor().getParent().getId()); if (t instanceof SimpleTensor) names.add(((SimpleTensor) t).getName()); for (Tensor tt : t) addSimpleTensorsNames(tt, names); return names; }
private static boolean testContainsNames(Tensor t, TIntHashSet names) { if (t instanceof TensorField) { if (names.contains(((TensorField) t).getNameDescriptor().getParent().getId())) return true; } else if (t instanceof SimpleTensor) return names.contains(((SimpleTensor) t).getName()); for (Tensor tt : t) if (testContainsNames(tt, names)) return true; return false; }
/** * Returns {@code true} if specified tensor is a Kronecker tensor * * @param t tensor * @return {@code true} if specified tensor is a Kronecker tensor */ public boolean isKronecker(SimpleTensor t) { return nameManager.isKroneckerOrMetric(t.getName()) && !IndicesUtils.haveEqualStates(t.getIndices().get(0), t.getIndices().get(1)); }
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)); }
protected AbstractTransformationWithGammas(DiracOptions options) { checkNotation(options.gammaMatrix, options.gamma5, options.leviCivita); if (!options.created) options.triggerCreate(); this.gammaName = options.gammaMatrix.getName(); this.gamma5Name = options.gamma5 == null ? Integer.MIN_VALUE : options.gamma5.getName(); final IndexType[] types = TraceUtils.extractTypesFromMatrix(options.gammaMatrix); this.metricType = types[0]; this.matrixType = types[1]; this.tokenTransformer = createTokenTransformer(metricType, matrixType, options.gammaMatrix, options.gamma5, options.leviCivita); this.expandAndEliminate = options.expandAndEliminate; this.traceOfOne = (Expression) tokenTransformer.transform(CC.current().getParseManager().getParser().parse("d^a'_a'=" + options.traceOfOne)).toTensor(); this.deltaTrace = (Expression) tokenTransformer.transform(CC.current().getParseManager().getParser().parse("d^a_a=" + options.dimension)).toTensor(); }
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)); }