/** * construct the arguments for an expression * */ private void getArguments(final FunctionNode function) throws SyntaxError { do { function.add(parseExpression()); if (fToken != TT_COMMA) { break; } getNextToken(); if (fToken == TT_PRECEDENCE_CLOSE || fToken == TT_ARGUMENTS_CLOSE) { function.add(new SymbolNode("Null")); break; } } while (true); }
@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; } }
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); } }
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; }
/** * construct the arguments for an expression * */ private void getArguments(final FunctionNode function) throws SyntaxError { do { function.add(parseOperators(parsePrimary(), 0)); if (fToken != TT_COMMA) { break; } getNextToken(); } while (true); }
/** * construct the arguments for an expression. * * @param function the function * @return the arguments * @throws SyntaxError the syntax error */ private void getArguments( final FunctionNode function ) throws SyntaxError { do { function.add( parseOperators( parsePrimary(), 0 ) ); if ( fToken != TT_COMMA ) { break; } getNextToken(); } while ( true ); }
private ASTNode parsePrimary(final int min_precedence) { if (fToken == TT_OPERATOR) { if (";;".equals(fOperatorString)) { FunctionNode function = fFactory.createFunction(fFactory.createSymbol(IConstantOperators.Span)); function.add(fFactory.createInteger(1)); getNextToken(); if (fToken == TT_COMMA || fToken == TT_ARGUMENTS_CLOSE || fToken == TT_PRECEDENCE_CLOSE) { function.add(fFactory.createSymbol(IConstantOperators.All)); return function; } function.add(parsePrimary(0)); if (fToken == TT_OPERATOR && ";;".equals(fOperatorString)) { function.add(fFactory.createSymbol(IConstantOperators.All)); getNextToken(); } return function; } if (".".equals(fOperatorString)) { fCurrentChar = '.'; return getNumber(false); } final PrefixOperator prefixOperator = determinePrefixOperator(); if (prefixOperator != null) { return parsePrefixOperator(prefixOperator); } throwSyntaxError("Operator: " + fOperatorString + " is no prefix operator."); } return getPart(min_precedence); }
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; }
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; }
function.add(parseOperators(parsePrimary(), 0)); } while (fToken == TT_COMMA);
if ( fToken == TT_DIGIT ) { countPercent = getIntegerNumber(); out.add( fFactory.createInteger( countPercent ) ); return out; out.add( fFactory.createInteger( -countPercent ) ); return out; final FunctionNode slot = fFactory.createFunction( fFactory.createSymbol( IConstantOperators.Slot ) ); if ( fToken == TT_DIGIT ) { slot.add( getNumber( false ) ); slot.add( fFactory.createInteger( 1 ) ); final FunctionNode slotSequencce = fFactory.createFunction( fFactory.createSymbol( IConstantOperators.SlotSequence ) ); if ( fToken == TT_DIGIT ) { slotSequencce.add( getNumber( false ) ); slotSequencce.add( fFactory.createInteger( 1 ) );
if (isSymbol(head, "Exp")) { FunctionNode fun = new FunctionNode(fASTFactory.createSymbol("Exp")); fun.add(f.getNode(1)); return getDerivativeResult(arg1Derived, fun); fun.add(new DoubleNode(-1.0)); fun.add(new FunctionNode(fASTFactory.createSymbol("Cos"), f.getNode(1))); return getDerivativeResult(arg1Derived, fun); fun.add(f.getNode(1)); return getDerivativeResult(arg1Derived, fun); ASTNode deriv = derivative(f.getNode(i), var); if (!deriv.equals(new DoubleNode(0.0))) { result.add(deriv); valid = false; } else { timesResult.add(deriv); timesResult.add(f.getNode(j)); plusResult.add(timesResult);
function.add(parseExpression()); } while (fToken == TT_COMMA);
if (fToken == TT_DIGIT) { countPercent = getIntegerNumber(); out.add(fFactory.createInteger(countPercent)); return out; out.add(fFactory.createInteger(-countPercent)); return out; final FunctionNode slot = fFactory.createFunction(fFactory.createSymbol(IConstantOperators.Slot)); if (fToken == TT_DIGIT) { slot.add(getNumber(false)); } else { slot.add(fFactory.createInteger(1)); final FunctionNode slotSequencce = fFactory.createFunction(fFactory.createSymbol(IConstantOperators.SlotSequence)); if (fToken == TT_DIGIT) { slotSequencce.add(getNumber(false)); } else { slotSequencce.add(fFactory.createInteger(1));
ASTNode defaultValue = parseExpression(); final FunctionNode function = fFactory.createAST(fFactory.createSymbol("Optional")); function.add(fFactory.createPattern(symbol, null, false)); function.add(defaultValue); temp = function; } else { function.add(fFactory.createPattern(null, null, false)); function.add(defaultValue); temp = function; if (fToken == TT_DIGIT) { countPercent = getInteger(); out.add(fFactory.createInteger(countPercent)); return out; out.add(fFactory.createInteger(-countPercent)); return parseArguments(out); } else if (fToken == TT_SLOT) { final FunctionNode slot = fFactory.createFunction(fFactory.createSymbol(IConstantOperators.Slot)); if (fToken == TT_DIGIT) { slot.add(fFactory.createInteger(getInteger())); } else { slot.add(fFactory.createInteger(1)); .createFunction(fFactory.createSymbol(IConstantOperators.SlotSequence)); if (fToken == TT_DIGIT) { slotSequencce.add(getNumber(false));