@Override public ASTNode createFunction(final INodeParserFactory factory, final ASTNode lhs, final ASTNode rhs) { if (fOperatorString.equals("@")) { FunctionNode fn = factory.createAST(lhs); fn.add(rhs); return fn; } FunctionNode fn = factory.createFunction(factory.createSymbol("Apply"), lhs, rhs); if (fOperatorString.equals("@@")) { return fn; } // case "@@@" fn.add(factory.createFunction(factory.createSymbol("List"), factory.createInteger(1))); return fn; } }
@Override public ASTNode createFunction(final INodeParserFactory factory, final ASTNode argument) { return factory.createFunction(factory.createSymbol("Times"), factory.createInteger(-1), argument); } }
public ASTNode createFunction(final INodeParserFactory factory, final ASTNode argument) { return factory.createFunction(factory.createSymbol(getFunctionName()), argument); } }
if (fToken == TT_PRECEDENCE_OPEN) { if (!Config.EXPLICIT_TIMES_OPERATOR) { Operator oper = fFactory.get("Times"); if (Config.DOMINANT_IMPLICIT_TIMES || oper.getPrecedence() >= min_precedence) { return getTimes(temp); temp = fFactory.createPattern(symbol, null); getNextToken(); } else { if (isSymbolIdentifier()) { final ASTNode check = getSymbol(); temp = fFactory.createPattern(symbol, check); } else { temp = fFactory.createPattern(symbol, null); temp = fFactory.createPattern2(symbol, null); getNextToken(); } else { if (isSymbolIdentifier()) { final ASTNode check = getSymbol(); temp = fFactory.createPattern2(symbol, check); } else { temp = fFactory.createPattern2(symbol, null); temp = fFactory.createPattern3(symbol, null); getNextToken(); } else {
public ASTNode createFunction(final INodeParserFactory factory, final ASTNode lhs, final ASTNode rhs) { if (fOperatorString.equals("//")) { // lhs // rhs ==> rhs[lhs] FunctionNode function =factory.createAST(rhs); function.add(lhs); return function; } return factory.createFunction(factory.createSymbol(getFunctionName()), lhs, rhs); } }
if (!Config.EXPLICIT_TIMES_OPERATOR) { oper = fFactory.get("Times"); if (Config.DOMINANT_IMPLICIT_TIMES || oper.getPrecedence() >= min_precedence) { rhs = parseLookaheadOperator(oper.getPrecedence()); lhs = fFactory.createFunction(fFactory.createSymbol(oper.getFunctionName()), lhs, rhs); continue;
/** * Read the current identifier from the expression factories table * * @return * @see */ private SymbolNode getSymbol() throws SyntaxError { String[] identifierContext = getIdentifier(); if (!fFactory.isValidIdentifier(identifierContext[0])) { throwSyntaxError("Invalid identifier: " + identifierContext[0] + " detected."); } final SymbolNode symbol = fFactory.createSymbol(identifierContext[0], identifierContext[1]); getNextToken(); return symbol; }
/** * Method Declaration. * * @return * @see */ private ASTNode getNumber(final boolean negative) throws SyntaxError { ASTNode temp = null; final Object[] result = getNumberString(); String number = (String) result[0]; final int numFormat = ((Integer) result[1]).intValue(); try { if (negative) { number = '-' + number; } if (numFormat < 0) { temp = fFactory.createDouble(number); } else { temp = fFactory.createInteger(number, numFormat); } } catch (final RuntimeException e) { throwSyntaxError("Number format error: " + number, number.length()); } getNextToken(); return temp; }
private ASTNode parseDerivative(ASTNode expr) { int derivativeCounter = 1; getNextToken(); while (fToken == TT_DERIVATIVE) { derivativeCounter++; getNextToken(); } FunctionNode head = fFactory.createFunction(DERIVATIVE, new IntegerNode(derivativeCounter)); FunctionNode deriv = fFactory.createAST(head); deriv.add(expr); expr = parseArguments(deriv); return expr; }
if (!Config.EXPLICIT_TIMES_OPERATOR) { InfixOperator timesOperator = (InfixOperator) fFactory.get("Times"); if (Config.DOMINANT_IMPLICIT_TIMES || timesOperator.getPrecedence() > min_precedence) { rhs = parseExpression(rhs, timesOperator.getPrecedence()); if (infixOperator.isOperator(";")) { if (fPackageMode && fRecursionDepth < 1) { return infixOperator.createFunction(fFactory, rhs, fFactory.createSymbol("Null"));
private ASTNode getTimes(ASTNode temp) throws SyntaxError { FunctionNode func = fFactory.createAST(new SymbolNode("Times")); func.add(temp); do { getNextToken(); temp = parseExpression(); func.add(temp); if (fToken != TT_PRECEDENCE_CLOSE) { throwSyntaxError("\')\' expected."); } getNextToken(); } while (fToken == TT_PRECEDENCE_OPEN); return func; }
private ASTNode parseCompoundExpressionNull(InfixOperator infixOperator, ASTNode rhs) { if (infixOperator.isOperator(";")) { if (fToken == TT_EOF || fToken == TT_ARGUMENTS_CLOSE || fToken == TT_LIST_CLOSE || fToken == TT_PRECEDENCE_CLOSE || fToken == TT_COMMA) { return infixOperator.createFunction(fFactory, rhs, fFactory.createSymbol("Null")); } if (fPackageMode && fRecursionDepth < 1) { return infixOperator.createFunction(fFactory, rhs, fFactory.createSymbol("Null")); } } return null; }
private ASTNode getString() throws SyntaxError { final StringBuilder ident = getStringBuilder(); getNextToken(); return fFactory.createString(ident); }
@Override public ASTNode createFunction(final INodeParserFactory factory, final ASTNode lhs, final ASTNode rhs) { return factory.createFunction(factory.createSymbol("Plus"), lhs, factory.createFunction(factory.createSymbol("Times"), factory.createInteger(-1), rhs)); } }
public ASTNode createFunction(final INodeParserFactory factory, final ASTNode argument) { return factory.createFunction(factory.createSymbol(getFunctionName()), argument); } }
/** * Get a function f[...][...] * */ FunctionNode getFunctionArguments(final ASTNode head) throws SyntaxError { final FunctionNode function = fFactory.createAST(head); fRecursionDepth++; getNextToken(); if (fToken == TT_ARGUMENTS_CLOSE) { fRecursionDepth--; getNextToken(); if (fToken == TT_ARGUMENTS_OPEN) { return getFunctionArguments(function); } return function; } getArguments(function); fRecursionDepth--; if (fToken == TT_ARGUMENTS_CLOSE) { getNextToken(); if (fToken == TT_ARGUMENTS_OPEN) { return getFunctionArguments(function); } return function; } throwSyntaxError("']' expected."); return null; }
private final ASTNode parseInfixOperator(ASTNode lhs, InfixOperator infixOperator) { ASTNode rhs; rhs = parseLookaheadOperator(infixOperator.getPrecedence()); lhs = infixOperator.createFunction(fFactory, lhs, rhs); String infixOperatorString = infixOperator.getOperatorString(); while (fToken == TT_OPERATOR && infixOperator.getGrouping() == InfixOperator.NONE && infixOperatorString.equals(fOperatorString)) { getNextToken(); if (";".equals(infixOperatorString)) { if (fToken == TT_EOF || fToken == TT_ARGUMENTS_CLOSE || fToken == TT_LIST_CLOSE || fToken == TT_PRECEDENCE_CLOSE || fToken == TT_COMMA) { ((FunctionNode) lhs).add(fFactory.createSymbol("Null")); break; } } while (fToken == TT_NEWLINE) { getNextToken(); } rhs = parseLookaheadOperator(infixOperator.getPrecedence()); ((FunctionNode) lhs).add(rhs); } return lhs; }
@Override public ASTNode createFunction(final INodeParserFactory factory, final ASTNode lhs, final ASTNode rhs) { if (rhs instanceof IntegerNode) { if (lhs instanceof IntegerNode) { return new FractionNode((IntegerNode) lhs, (IntegerNode) rhs); } return factory.createFunction(factory.createSymbol("Times"), new FractionNode(IntegerNode.C1, (IntegerNode) rhs), lhs); } if (lhs.equals(IntegerNode.C1)) { return factory.createFunction(factory.createSymbol("Power"), rhs, factory.createInteger(-1)); } return factory.createFunction(factory.createSymbol("Times"), lhs, factory.createFunction(factory.createSymbol("Power"), rhs, factory.createInteger(-1))); } }
@Override public ASTNode createFunction(final INodeParserFactory factory, final ASTNode lhs, final ASTNode rhs) { if (rhs instanceof FunctionNode) { FunctionNode r = (FunctionNode) rhs; if (r.size() == 3) { if (r.get(0).equals(factory.createSymbol("Set"))) { return factory.createFunction(factory.createSymbol("TagSet"), lhs, r.get(1), r.get(2)); } else if (r.get(0).equals(factory.createSymbol("SetDelayed"))) { return factory.createFunction(factory.createSymbol("TagSetDelayed"), lhs, r.get(1), r.get(2)); } } } return factory.createFunction(factory.createSymbol("TagSet"), lhs, rhs); } }
final FunctionNode function = fFactory.createAST(head);