protected Tensor[] contentToTensors() { Tensor[] tensors = new Tensor[content.length]; for (int i = 0; i < content.length; ++i) tensors[i] = content[i].toTensor(); return tensors; }
DiracSimplify1(DiracOptions options) { super(options, IDENTITY); ParseToken[] ss = {s1, s2, s3, s4}; this.subs = new Expression[ss.length]; for (int i = 0; i < ss.length; ++i) subs[i] = (Expression) deltaTrace.transform(tokenTransformer.transform(ss[i]).toTensor()); }
UnitarySimplifyTransformation(final Tensor dimension, ChangeIndicesTypesAndTensorNames tokenTransformer) { //simplifications with SU(N) combinations ArrayList<Transformation> unitarySimplifications = new ArrayList<>(); if (dimension instanceof Complex) { Transformation nSub = parseExpression("N = " + dimension); for (ParseToken substitution : unitarySimplificationsTokens) unitarySimplifications.add((Transformation) nSub.transform(tokenTransformer.transform(substitution).toTensor())); } else for (ParseToken substitution : unitarySimplificationsTokens) unitarySimplifications.add((Transformation) tokenTransformer.transform(substitution).toTensor()); //all simplifications ArrayList<Transformation> simplifications = new ArrayList<>(); simplifications.add(EliminateMetricsTransformation.ELIMINATE_METRICS); simplifications.addAll(unitarySimplifications); this.unitarySimplifications = new TransformationCollection(simplifications); }
@Override public Tensor toTensor() { Tensor expression = Tensors.expression(content[0].toTensor(), content[1].toTensor()); if (preprocess) { for (Transformation tr : Context.get().getParseManager().defaultTensorPreprocessors) expression = tr.transform(expression); Context.get().getParseManager().defaultTensorPreprocessors.add((Transformation) expression); } return expression; } }
/** * @param expression string expression * @param tensorPreprocessors transformation * @param nodesPreprocessors AST transformers * @return tensor */ public Tensor parse(String expression, Transformation[] tensorPreprocessors, ParseTokenTransformer[] nodesPreprocessors) { ParseToken node = parser.parse(expression); for (ParseTokenTransformer tr : nodesPreprocessors) node = tr.transform(node); Tensor t = node.toTensor(); for (Transformation tr : tensorPreprocessors) if (tr != t) t = tr.transform(t); return t; }
/** * @param expression string expression * @param tensorPreprocessors transformation * @param nodesPreprocessors AST transformers * @return tensor */ public Tensor parse(String expression, List<Transformation> tensorPreprocessors, List<ParseTokenTransformer> nodesPreprocessors) { ParseToken node = parser.parse(expression); for (ParseTokenTransformer tr : nodesPreprocessors) node = tr.transform(node); Tensor t = node.toTensor(); for (Transformation tr : tensorPreprocessors) if (tr != t) t = tr.transform(t); return t; }
/** * Converts this AST to tensor. * * @return resulting tensor */ public Tensor toTensor() { switch (tokenType) { case Sum: return Tensors.sum(contentToTensors()); case Power: assert content.length == 2; return Tensors.pow(content[0].toTensor(), content[1].toTensor()); case Trace: case Product: return Tensors.multiplyAndRenameConflictingDummies(contentToTensors()); } throw new ParserException("Unknown tensor type: " + tokenType); }
Transformation nSub = parseExpression("N = " + dimension); for (ParseToken substitution : unitarySimplificationsTokens) unitarySimplifications.add((Transformation) nSub.transform(tokenTransformer.transform(substitution).toTensor())); } else for (ParseToken substitution : unitarySimplificationsTokens) unitarySimplifications.add((Transformation) tokenTransformer.transform(substitution).toTensor());
private Tensor traceWith5(Tensor product, int numberOfGammas) { if (traceOf4GammasWith5 == null) { traceOf4GammasWith5 = (Expression) tokenTransformer.transform(traceOf4GammasWith5Token).toTensor(); chiholmKahaneIdentity = (Expression) tokenTransformer.transform(chiholmKahaneToken).toTensor(); chiholmKahaneIdentityReversed = (Expression) tokenTransformer.transform(chiholmKahaneTokenReversed).toTensor(); chiholmKahaneIdentityReversed = (Expression) deltaTrace.transform(chiholmKahaneIdentityReversed); } if (numberOfGammas == 5)//including one gama5 product = traceOf4GammasWith5.transform(product); else { product = chiholmKahaneIdentityReversed.transform(product); //no gamma5 leaved product = getTraceSubstitution(numberOfGammas + 1).transform(product); } product = expandAndEliminate.transform(product); product = deltaTrace.transform(product); product = traceOfOne.transform(product); if (simplifyLeviCivita != null) { product = simplifyLeviCivita.transform(product); product = deltaTrace.transform(product); product = traceOfOne.transform(product); } return product; }
@Override public Tensor toTensor() { if (content.length != 1) throw new IllegalArgumentException("Wrong scalar function node."); Tensor arg = content[0].toTensor(); switch (function.toLowerCase()) { case "sin": return Tensors.sin(arg); case "cos": return Tensors.cos(arg); case "tan": return Tensors.tan(arg); case "cot": return Tensors.cot(arg); case "arcsin": return Tensors.arcsin(arg); case "arccos": return Tensors.arccos(arg); case "arctan": return Tensors.arctan(arg); case "arccot": return Tensors.arccot(arg); case "log": return Tensors.log(arg); case "exp": return Tensors.exp(arg); } throw new IllegalStateException("Unknown scalar function \"" + function + "\"."); }
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(); }
Expression pairProduct = (Expression) tokenTransformer.transform(pairProductToken).toTensor(); if (dimension instanceof Complex) pairProduct = (Expression) parseExpression("N = " + dimension).transform(pairProduct); this.pairProduct = pairProduct; this.singleTrace = (Expression) tokenTransformer.transform(singleTraceToken).toTensor();
public SchoutenIdentities4(SimpleTensor leviCivita) { this.leviCivita = leviCivita; ChangeIndicesTypesAndTensorNames tokenTransformer = new ChangeIndicesTypesAndTensorNames(TypesAndNamesTransformer.Utils.and( TypesAndNamesTransformer.Utils.changeName(new String[]{"e"}, new String[]{leviCivita.getStringName()}), TypesAndNamesTransformer.Utils.changeType(IndexType.LatinLower, IndicesUtils.getTypeEnum(leviCivita.getIndices().get(0))))); this.schouten1 = new Tensor[schoutenCombinations1.length]; for (int i = 0; i < schouten1.length; i++) schouten1[i] = tokenTransformer.transform(CC.current().getParseManager().getParser().parse(schoutenCombinations1[i])).toTensor(); this.schouten2 = new Tensor[schoutenCombinations2.length]; for (int i = 0; i < schouten2.length; i++) schouten2[i] = tokenTransformer.transform(CC.current().getParseManager().getParser().parse(schoutenCombinations2[i])).toTensor(); this.schouten3 = new Tensor[schoutenCombinations3.length]; for (int i = 0; i < schouten3.length; i++) schouten3[i] = tokenTransformer.transform(CC.current().getParseManager().getParser().parse(schoutenCombinations3[i])).toTensor(); allSchouten = new Tensor[][]{schouten1, schouten2, schouten3}; }
@Override public Tensor toTensor() { SimpleTensor[] vars = new SimpleTensor[content.length - 1]; Tensor temp = content[0].toTensor(); TIntHashSet allowedDummies = TensorUtils.getAllIndicesNamesT(temp); IndicesBuilder free = new IndicesBuilder().append(temp.getIndices()); for (int i = 1; i < content.length; ++i) { temp = content[i].toTensor(); free.append(temp.getIndices().getInverted()); allowedDummies.addAll(IndicesUtils.getIndicesNames(temp.getIndices())); if (!(temp instanceof SimpleTensor) && !(temp instanceof TensorField)) throw new IllegalArgumentException("Derivative with respect to non simple argument: " + temp); vars[i - 1] = (SimpleTensor) temp; } allowedDummies.removeAll(IndicesUtils.getIndicesNames(free.getIndices().getFree())); Tensor result = new DifferentiateTransformation( vars, new Transformation[]{ExpandAndEliminateTransformation.EXPAND_AND_ELIMINATE} ).transform(content[0].toTensor()); result = ApplyIndexMapping.optimizeDummies(result); TIntHashSet generated = TensorUtils.getAllDummyIndicesT(result); generated.removeAll(allowedDummies); result = ApplyIndexMapping.renameDummy(result, generated.toArray(), allowedDummies.toArray()); return result; } }
Expression substitution = (Expression) tokenTransformer.transform(substitutionToken).toTensor(); if (minkowskiSpace & numberOfIndices % 2 == 0) substitution = expression(substitution.get(0), negate(substitution.get(1)));