How to use

ASTNodeFactory

in

org.matheclipse.parser.client.operator

public LessEqual() {
  // ≤ ࣘ
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("LessEqual").getPrecedence(),
      "\\leq ");
}

@Override
public SymbolNode createSymbol(final String symbolName) {
  return createSymbol(symbolName, "");
}

@Override
public SymbolNode createSymbol(final String symbolName, final String context) {
  String name = symbolName;
  if (fIgnoreCase) {
    name = symbolName.toLowerCase();
  }
  if (Config.RUBI_CONVERT_SYMBOLS) {
    name = toRubiString(name);
  }
  // if (fIgnoreCase) {
  // return new SymbolNode(symbolName.toLowerCase());
  // }
  return new SymbolNode(name);
}

      grouping = InfixOperator.RIGHT_ASSOCIATIVE;
    oper = ASTNodeFactory.createInfixOperator(operatorStr, headStr, precedence, grouping);
  } catch (final NoSuchElementException nsee) {
    oper = new InfixOperator(operatorStr, headStr, precedence, InfixOperator.NONE);
  oper = ASTNodeFactory.createPrefixOperator(operatorStr, headStr, precedence);
} else if (typeStr.equalsIgnoreCase("post")) {
  oper = ASTNodeFactory.createPostfixOperator(operatorStr, headStr, precedence);
} else {
  throw new ParseException("Wrong operator type: " + typeStr, 0);
ASTNodeFactory.addOperator(operatorMap, operatorTokenStartSet, operatorStr, headStr, oper);

ASTNode arg1Derived = derivative(f.getNode(1), var);
if (isSymbol(head, "Exp")) {
  FunctionNode fun = new FunctionNode(fASTFactory.createSymbol("Exp"));
  fun.add(f.getNode(1));
  return getDerivativeResult(arg1Derived, fun);
  FunctionNode fun = new FunctionNode(fASTFactory.createSymbol("Times"));
  fun.add(new DoubleNode(-1.0));
  fun.add(new FunctionNode(fASTFactory.createSymbol("Cos"), f.getNode(1)));
  return getDerivativeResult(arg1Derived, fun);
  FunctionNode fun = new FunctionNode(fASTFactory.createSymbol("Cos"));
  fun.add(f.getNode(1));
  return getDerivativeResult(arg1Derived, fun);
  FunctionNode exponent = fASTFactory.createFunction(fASTFactory.createSymbol("Plus"),
      new DoubleNode(-1.0), f.get(2));
  FunctionNode fun = fASTFactory.createFunction(fASTFactory.createSymbol("Times"), f.get(2),
      fASTFactory.createFunction(fASTFactory.createSymbol("Power"), f.get(1), exponent));
  return getDerivativeResult(arg1Derived, fun);
  FunctionNode fun = fASTFactory.createFunction(fASTFactory.createSymbol("Times"),
      fASTFactory.createFunction(fASTFactory.createSymbol("Log"), f.get(1)), f);
  return getDerivativeResult(arg2Derived, fun);
  FunctionNode plusResult = new FunctionNode(fASTFactory.createSymbol("Plus"));
  for (int i = 1; i < f.size(); i++) {
    FunctionNode timesResult = new FunctionNode(f.getNode(0));

public DoubleEvaluator(ASTNode node, boolean relaxedSyntax) {
  fASTFactory = new ASTNodeFactory(relaxedSyntax);
  fVariableMap = new HashMap<String, IDoubleValue>();
  fBooleanVariables = new HashMap<String, BooleanVariable>();
  fNode = node;
  fRelaxedSyntax = relaxedSyntax;
  if (fRelaxedSyntax) {
    if (SYMBOL_DOUBLE_MAP.get("pi") == null) {
      // init tables for relaxed mode
      for (String key : SYMBOL_DOUBLE_MAP.keySet()) {
        SYMBOL_DOUBLE_MAP.put(key.toLowerCase(), SYMBOL_DOUBLE_MAP.get(key));
      }
      for (String key : SYMBOL_BOOLEAN_MAP.keySet()) {
        SYMBOL_BOOLEAN_MAP.put(key.toLowerCase(), SYMBOL_BOOLEAN_MAP.get(key));
      }
      for (String key : FUNCTION_DOUBLE_MAP.keySet()) {
        FUNCTION_DOUBLE_MAP.put(key.toLowerCase(), FUNCTION_DOUBLE_MAP.get(key));
      }
      for (String key : FUNCTION_BOOLEAN_MAP.keySet()) {
        FUNCTION_BOOLEAN_MAP.put(key.toLowerCase(), FUNCTION_BOOLEAN_MAP.get(key));
      }
    }
  }
}

      grouping = InfixOperator.RIGHT_ASSOCIATIVE;
    oper = ASTNodeFactory.createInfixOperator( operatorStr, headStr, precedence, grouping );
  oper = ASTNodeFactory.createPrefixOperator( operatorStr, headStr, precedence );
  oper = ASTNodeFactory.createPostfixOperator( operatorStr, headStr, precedence );
ASTNodeFactory.addOperator( operatorMap, operatorTokenStartSet, operatorStr, headStr, oper );

public RuleDelayed() {
  // ⧴ ⧴
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("RuleDelayed").getPrecedence(),
      " := ");
}

/**
 * 
 * @param node
 * @param var
 * @return
 */
public ASTNode derivative(final ASTNode node, String var) {
  SymbolNode sym = fASTFactory.createSymbol(var);
  return derivative(node, sym);
}

public LessEqual() {
  // ≤ ࣘ
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("LessEqual").getPrecedence(),
      "≤");
}

private ASTNode getDerivativeResult(ASTNode arg1Derived, FunctionNode fun) {
  if (!arg1Derived.equals(new DoubleNode(1.0))) {
    FunctionNode res = new FunctionNode(fASTFactory.createSymbol("Times"));
    res.add(arg1Derived);
    res.add(fun);
    return res;
  }
  return fun;
}

public RuleDelayed() {
  // ⧴ ⧴
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("RuleDelayed").getPrecedence(),
      "⧴");
}

public static Operator getOperator(ISymbol head) {
  String headerStr = head.getSymbolName();
  if (Config.PARSER_USE_LOWERCASE_SYMBOLS) {
    String str = AST2Expr.PREDEFINED_SYMBOLS_MAP.get(headerStr);
    if (str != null) {
      headerStr = str;
    }
  }
  final Operator operator = ASTNodeFactory.MMA_STYLE_FACTORY.get(headerStr);
  return operator;
}

public Times() {
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("Times").getPrecedence(), "mrow", "·");// centerdot instead
                                              // of
                                              // invisibletimes:
                                              // "⁢");
}

public Plus() {
 super(ASTNodeFactory.MMA_STYLE_FACTORY.get("Plus").getPrecedence(), "mrow",
   "+");
}

public GreaterEqual() {
  // ≥ ࣙ
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("GreaterEqual").getPrecedence(), "≥");
}

public And() {
  // and 2227
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("And").getPrecedence(), " \\land ");
}

public SetDelayed() {
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("SetDelayed").getPrecedence(),
      ":=");
}

public Power() {
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("Power").getPrecedence(), "msup",
      "");
}

public Times() {
  super(ASTNodeFactory.MMA_STYLE_FACTORY.get("Times").getPrecedence(),
      "\\,");
}