private void modeParser(String expression, Mode mode, Parser parser, List<ParseToken> nodes) { if (mode == Mode.Direct) { nodes.add(parser.parse(expression)); return; } if (mode == Mode.Inverse) nodes.add(inverseOperation(parser.parse(expression))); else throw new ParserException("unrepoted operator parser mode"); }
/** * Parse string expression into AST. * * @param expression string expression * @return AST */ public ParseToken parse(String expression) { //replacing comments expression = deleteComments(expression); if (expression.isEmpty()) throw new IllegalArgumentException("Empty expression."); for (TokenParser tokenParser : tokenParsers) { ParseToken node = tokenParser.parseToken(expression.trim(), this); if (node != null) return node; } throw new ParserException("No appropriate parser for expression: \"" + expression + "\""); }
/** * Returns whether repeated indices of the same variance are allowed to be parsed * * @return whether repeated indices of the same variance are allowed to be parsed */ public boolean getParserAllowsSameVariance() { return parseManager.getParser().isAllowSameVariance(); }
/** * Allows to parse expressions with repeated indices of the same variance (like T_aa or T_a*T^a which results in T^a_a * and T^a*T_a respactively) * * @param b allow or not to parse repeated indices with same variance */ public void setParserAllowsSameVariance(boolean b) { parseManager.getParser().setAllowSameVariance(b); }
@Override public ParseToken parseToken(String expression, Parser parser) { if (!expression.contains("=")) return null; if (expression.indexOf('=') != expression.lastIndexOf('=')) throw new ParserException("Several '=' symbols."); String[] parts = expression.split("="); parts[0] = parts[0].trim(); boolean preprocessing = false; if (parts[0].charAt(parts[0].length() - 1) == ':') { preprocessing = true; parts[0] = parts[0].substring(0, parts[0].length() - 1); } ParseToken left = parser.parse(parts[0]); ParseToken right = parser.parse(parts[1]); return new ParseTokenExpression(preprocessing, left, right); }
@Override public final ParseTokenSimpleTensor parseToken(String expression, Parser parser) { expression = expression.replaceAll("\\{[\\s]*\\}", ""); int indicesBegin = expression.indexOf('_'), i = expression.indexOf('^'); if (indicesBegin < 0 && i >= 0) indicesBegin = i; if (indicesBegin >= 0 && i >= 0) indicesBegin = Math.min(indicesBegin, i); if (indicesBegin < 0) indicesBegin = expression.length(); String name = expression.substring(0, indicesBegin); if (name.isEmpty()) throw new ParserException("Simple tensor with empty name."); SimpleIndices indices; if (parser.isAllowSameVariance()) indices = ParserIndices.parseSimpleIgnoringVariance(expression.substring(indicesBegin)); else indices = ParserIndices.parseSimple(expression.substring(indicesBegin)); return new ParseTokenSimpleTensor(indices, name); }
@Override public ParseToken parseToken(String expression, Parser parser) { if (expression.length() <= minLength) return null; if (!(power + '[').equals(expression.substring(0, power.length() + 1)) || expression.charAt(expression.length() - 1) != ']') return null; int level = 0, i, comma = -1; char c; for (i = power.length(); i < expression.length(); ++i) { c = expression.charAt(i); if (c == '[') ++level; if (level < 1) return null; if (c == ']') --level; if (c == ',' && level == 1) { if (comma != -1) throw new ParserException("Power takes only two arguments."); comma = i; } } ParseToken arg = parser.parse(expression.substring(power.length() + 1, comma)); ParseToken power = parser.parse(expression.substring(comma + 1, expression.length() - 1)); return new ParseToken(TokenType.Power, arg, power); } }
@Override public ParseToken parseToken(String expression, Parser parser) { ParseToken node = super.parseToken(expression, parser); if (node == null || !parser.isAllowSameVariance()) return node; TIntHashSet indices = new TIntHashSet(); for (ParseToken c : node.content) { Indices free = c.getIndices().getFree(); for (int i = 0; i < free.size(); i++) { int ind = free.get(i); if (indices.contains(ind)) revertIndex(c, ind); else indices.add(ind); } } return node; }
@Override public ParseToken parseToken(String expression, Parser parser) { if (expression.charAt(0) == '(') if (expression.charAt(expression.length() - 1) != ')') checkWithException(expression); else { int level = 0; for (int i = 0; i < expression.length(); ++i) { char c = expression.charAt(i); if (c == '(') level++; if (level < 1) return null; if (c == ')') level--; } if (level != 0) throw new BracketsError(); return parser.parse(expression.substring(1, expression.length() - 1)); } return null; }
if (!ParseUtils.checkBracketsConsistence(argStr)) return null; ParseToken arg = parser.parse(argStr); if (arg == null) return null; else if (c == ']') --levels[1]; else if (c == ',' && levels[0] == 0 && levels[1] == 0) { tokens.add(parser.parse(buffer.toString())); buffer = new StringBuilder(); } else buffer.append(c); tokens.add(parser.parse(buffer.toString())); return new ParseTokenDerivative(TokenType.Derivative, tokens.toArray(new ParseToken[tokens.size()]));
return new ParseTokenScalarFunction(temp, new ParseToken[]{parser.parse(argument)});
/** * @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; }
/** * @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; }
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(); }
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}; }