java - 如何解析正弦函数？

Question

我的字符串输入格式为 sin (b(x-c)) + d。我应该使用什么定界符表达式来拆分它，以便我可以使用 Integer.parse 获取 a、b、c 和 d 的数值？

所以，如果字符串输入是

sin 5x                   a=1, b=5, c=d=0
sin 5(x-4)               a=1, b=5, c=4, d=0
2  sin 3(x-2)           a=2, b=3, c=2, d=0
sin 5x + 3               a=1, b=5, c=0, d=3
4  sin 7(x+6) + 2       a=4, b=7, c=-6, d=2
11  sin 2x              a=11, b=2, c=d=0

Answer 1

呸。每当您使用字符串提供抽象上下文(例如数学
函数)时，您应该考虑编写:
一个 TokenScanner，它识别 token ，例如您的情况:
函数名'sin',
运算符 '(', ')', '+'
常量标记 1、2、5。
从字符串中提取 token 后，您可以开始构建 AST(抽象
语法树)。
通过评估这棵树，您可以执行计算。

看，如果您从上面发布的公式中得到数字，您会
进一步采取哪些步骤？运算符、数字甚至函数名称本身都可以位于公式中的
不同位置，否则您将对字符串本身进行非常复杂的分析。
构建 token 扫描器很简单。
构建 AST 似乎更复杂，但在本例中并非如此，因为表达式的语法
并不太复杂。
因此，不是根据您期望的那种表达式来分析整个字符串，
您专注于符号如何相互关联。例如。罪恶(3+(2+4))。
为您提供以下形式的 AST:
function 'sin'
operator '('
const_value 3
operator +
operator '('
const_value 2
operator '+'
const_value 4
operator ')'
operator ')'.
然后，您可以遍历该树以获得最内层的表达式，对它们求值并
重新替换它的结果。您知道每个函数 - 调用都会创建一个新范围
以及每个左圆括号。
因此不难发现哪个是最里面的。 TokenScanner 基本上可以是以下形式:
读取字符串中的第一个字符，与 token 列表进行比较，当匹配时，
构建该 token 类型的对象，读取下一个 token ，构建该 token 的对象，
链接两者 token 例如通过 first 和 next - 指针等。
要获得一个基本概念:

public class TokenScanner {
    public TokenScanner() { }
    public Token scan(String input) {
      Token root = new Token();
      Token prevToken = null;

      for(int i = 0; i < input.length(),i++) {
      Token newToken = null;
      char c = input.getCharAt(i);

      switch(c) {
        case 's': //** s is the start of the word sin, and not used in other contexts in this example, so: **/
        newToken = new FunctionToken();
        break;
        case '(':
          newToken = new Expression();
        case ')':
          newToken = new Expression();
        ....
      }
      if(prevToken == null) { 
        root->next = newToken;
        newToken->prev = root;
      }
      else {
        newToken->prev = prevToken;
        prevToken->next = newToken;
      }

      return root;
      }
    }
}

public class Token() {
    public Token prev;
    public Token next;
    public int TOKEN_TYPE = 0;

    public Token() {
    }
}

public class FunctionToken extends Token {
  static public int TOKEN_TYPE = 1;
}

public class Expression extends Token {
}

public class TokenTreeVisitor {
    public void traverse(Token currentToken) {
    switch(currentToken.TOKEN_TYPE) {
      case 1:
        enter((FunctionToken) currentToken);
    }
    }
}

虽然这里已经有对 token 的解释，所以您应该适本地将表达式更改为 OpenBracketToken 和 tokenScanner 的 ClosingBracketToken。但它显示了如何从标记到表达式以及可以计算的表达式。
这又是一个检查表达式是否包含子表达式的过程。如果有
，则处理该子表达式。如果不是，计算子表达式并用结果替换
该树中的那个表达式。
例如
原始子表达式 (5 + (1 + 7))
表达式 exp 只包含 const_value (1) , operator '+', const_value (7).
通过 Int.parse(1) + INt.parse(7) 评估它，

class ExpressionResult extends Expression {
     public int result;
}

result = new ExpressionResult(); result->result = 8;
exp->prev->next = result; result->prev = exp->prev; result->next =  exp->next;

再次扫描并递归替换。
exp2 现在是 const_value (5) + operator '+' + expression_result(8)

所以你可以 Int.parse(5) + exp2->next->result;

等等。安静琐碎，不是吗？ ;)