文字列形式で与えられた数学式を評価するにはどうすればいいですか？
私は次のようなStringの値から単純な数学式を評価するためのJavaルーチンを書いてみます
"5+3""10-40""10*3"
私は多くのif-then-else文を避けたいと思います。これどうやってするの？
JDK 1.6では、組み込みのJavascriptエンジンを使用できます。
import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;
public class Test {
public static void main(String[] args) throws ScriptException {
ScriptEngineManager mgr = new ScriptEngineManager();
ScriptEngine engine = mgr.getEngineByName("JavaScript");
String foo = "40+2";
System.out.println(engine.eval(foo));
}
}
この質問に答えるために、算術式にこのevalメソッドを書きました。加算、減算、乗算、除算、べき乗（^シンボルを使用）、およびsqrtのようないくつかの基本的な関数を行います。 (...)を使用したグループ化をサポートし、演算子 precedence および associativity rules正しいものを取得します。
public static double eval(final String str) {
return new Object() {
int pos = -1, ch;
void nextChar() {
ch = (++pos < str.length()) ? str.charAt(pos) : -1;
}
boolean eat(int charToEat) {
while (ch == ' ') nextChar();
if (ch == charToEat) {
nextChar();
return true;
}
return false;
}
double parse() {
nextChar();
double x = parseExpression();
if (pos < str.length()) throw new RuntimeException("Unexpected: " + (char)ch);
return x;
}
// Grammar:
// expression = term | expression `+` term | expression `-` term
// term = factor | term `*` factor | term `/` factor
// factor = `+` factor | `-` factor | `(` expression `)`
// | number | functionName factor | factor `^` factor
double parseExpression() {
double x = parseTerm();
for (;;) {
if (eat('+')) x += parseTerm(); // addition
else if (eat('-')) x -= parseTerm(); // subtraction
else return x;
}
}
double parseTerm() {
double x = parseFactor();
for (;;) {
if (eat('*')) x *= parseFactor(); // multiplication
else if (eat('/')) x /= parseFactor(); // division
else return x;
}
}
double parseFactor() {
if (eat('+')) return parseFactor(); // unary plus
if (eat('-')) return -parseFactor(); // unary minus
double x;
int startPos = this.pos;
if (eat('(')) { // parentheses
x = parseExpression();
eat(')');
} else if ((ch >= '0' && ch <= '9') || ch == '.') { // numbers
while ((ch >= '0' && ch <= '9') || ch == '.') nextChar();
x = Double.parseDouble(str.substring(startPos, this.pos));
} else if (ch >= 'a' && ch <= 'z') { // functions
while (ch >= 'a' && ch <= 'z') nextChar();
String func = str.substring(startPos, this.pos);
x = parseFactor();
if (func.equals("sqrt")) x = Math.sqrt(x);
else if (func.equals("sin")) x = Math.sin(Math.toRadians(x));
else if (func.equals("cos")) x = Math.cos(Math.toRadians(x));
else if (func.equals("tan")) x = Math.tan(Math.toRadians(x));
else throw new RuntimeException("Unknown function: " + func);
} else {
throw new RuntimeException("Unexpected: " + (char)ch);
}
if (eat('^')) x = Math.pow(x, parseFactor()); // exponentiation
return x;
}
}.parse();
}
例：
System.out.println(eval("((4 - 2^3 + 1) * -sqrt(3*3+4*4)) / 2"));
出力：7.5 （これは正しいです）
パーサーは 再帰降下パーサー です。そのため、文法の各レベルの演算子の優先順位に対して、内部的に別々の解析メソッドを使用します。私はそれを短くしたので修正が簡単ですが、ここであなたがそれを拡張したいと思うかもしれないいくつかのアイデアがあります：
変数：
Map<String,Double> variablesなどのevalメソッドに渡される変数テーブルで名前を調べることで、関数の名前を読み取るパーサーのビットを簡単に変更してカスタム変数も処理できます。コンパイルと評価を分けて：
変数のサポートを追加したときに、毎回解析することなく、変数を変更して同じ式を何百万回も評価したいとしたらどうでしょうか。それが可能だ。まず、プリコンパイルされた式を評価するために使用するインターフェースを定義します。
@FunctionalInterface interface Expression { double eval(); }doublesを返すすべてのメソッドを変更し、代わりにそれらはそのインターフェースのインスタンスを返します。 Java 8のラムダ構文はこれに最適です。変更された方法の1つの例：Expression parseExpression() { Expression x = parseTerm(); for (;;) { if (eat('+')) { // addition Expression a = x, b = parseTerm(); x = (() -> a.eval() + b.eval()); } else if (eat('-')) { // subtraction Expression a = x, b = parseTerm(); x = (() -> a.eval() - b.eval()); } else { return x; } } }これはコンパイルされた式を表す
Expressionオブジェクトの再帰的ツリーを構築します（ abstract syntax tree ）。その後、一度コンパイルして、異なる値で繰り返し評価することができます。public static void main(String[] args) { Map<String,Double> variables = new HashMap<>(); Expression exp = parse("x^2 - x + 2", variables); for (double x = -20; x <= +20; x++) { variables.put("x", x); System.out.println(x + " => " + exp.eval()); } }さまざまなデータ型：
doubleの代わりに、BigDecimal、複素数、または有理数（分数）を実装するクラスのようなより強力なものを使用するようにエバリュエータを変更することができます。実際のプログラミング言語と同じように、Objectを使用して式にデータ型を混在させることもできます。 :)
この回答のすべてのコードは をパブリックドメイン にリリースしました。楽しむ！
HERE はGitHub上のEvalExという名前の別のオープンソースライブラリです。
JavaScriptエンジンとは異なり、このライブラリは数式のみを評価することに焦点を当てています。さらに、このライブラリは拡張可能で、括弧だけでなくブール演算子の使用もサポートしています。
私の大学のプロジェクトでは、基本式とより複雑な方程式（特に反復演算子）の両方をサポートするパーサー/エバリュエーターを探していました。私はmXparserと呼ばれるJavaと.NET用のとても素敵なオープンソースライブラリを見つけました。私はいくつかの例を挙げて構文を理解します。詳細な指示についてはプロジェクトのウェブサイト（特にチュートリアルセクション）をご覧ください。
http://mathparser.org/mxparser-tutorial/
そしていくつかの例
1 - 単純な式
Expression e = new Expression("( 2 + 3/4 + sin(pi) )/2");
double v = e.calculate()
2 - ユーザー定義の引数と定数
Argument x = new Argument("x = 10");
Constant a = new Constant("a = pi^2");
Expression e = new Expression("cos(a*x)", x, a);
double v = e.calculate()
3 - ユーザー定義関数
Function f = new Function("f(x, y, z) = sin(x) + cos(y*z)");
Expression e = new Expression("f(3,2,5)", f);
double v = e.calculate()
4 - 繰り返し
Expression e = new Expression("sum( i, 1, 100, sin(i) )");
double v = e.calculate()
最近見つけました - あなたが構文を試してみたい（そして高度な使用例を見たい）場合は Scalar Calculatorapp that mXparserによって供給されています。
宜しくお願いします
Javaアプリケーションがすでにデータベースにアクセスしている場合は、他のJARを使用せずに式を簡単に評価できます。
データベースによっては、ダミーのテーブル（Oracleの "dual"テーブルなど）を使用する必要があり、他のデータベースでは、どのテーブルからも "選択"せずに式を評価できます。
たとえば、Sql ServerまたはSqliteの場合
select (((12.10 +12.0))/ 233.0) amount
そしてOracleで
select (((12.10 +12.0))/ 233.0) amount from dual;
DBを使用する利点は、同時に多くの式を評価できるということです。また、ほとんどのDBでは、非常に複雑な式を使用でき、必要に応じて呼び出すことができるいくつかの追加機能もあります。
ただし、特にDBがネットワークサーバー上にある場合など、多数の単一表現を個別に評価する必要がある場合は、パフォーマンスが低下する可能性があります。
以下は、Sqliteのインメモリデータベースを使用して、パフォーマンスの問題をある程度解決します。
これがJavaでの完全な実例です。
Class. forName("org.sqlite.JDBC");
Connection conn = DriverManager.getConnection("jdbc:sqlite::memory:");
Statement stat = conn.createStatement();
ResultSet rs = stat.executeQuery( "select (1+10)/20.0 amount");
rs.next();
System.out.println(rs.getBigDecimal(1));
stat.close();
conn.close();
もちろん、上記のコードを拡張して、同時に複数の計算を処理することもできます。
ResultSet rs = stat.executeQuery( "select (1+10)/20.0 amount, (1+100)/20.0 amount2");
BeanShell インタプリタを試すこともできます。
Interpreter interpreter = new Interpreter();
interpreter.eval("result = (7+21*6)/(32-27)");
System.out.println(interpreter.get("result"));
この記事 ではさまざまなアプローチについて説明しています。記事に記載されている2つの主なアプローチは次のとおりです。
ApacheからのJEXL
Javaオブジェクトへの参照を含むスクリプトを許可します。
// Create or retrieve a JexlEngine
JexlEngine jexl = new JexlEngine();
// Create an expression object
String jexlExp = "foo.innerFoo.bar()";
Expression e = jexl.createExpression( jexlExp );
// Create a context and add data
JexlContext jctx = new MapContext();
jctx.set("foo", new Foo() );
// Now evaluate the expression, getting the result
Object o = e.evaluate(jctx);
JDKに組み込まれているJavaScriptエンジンを使用します。
private static void jsEvalWithVariable()
{
List<String> namesList = new ArrayList<String>();
namesList.add("Jill");
namesList.add("Bob");
namesList.add("Laureen");
namesList.add("Ed");
ScriptEngineManager mgr = new ScriptEngineManager();
ScriptEngine jsEngine = mgr.getEngineByName("JavaScript");
jsEngine.put("namesListKey", namesList);
System.out.println("Executing in script environment...");
try
{
jsEngine.eval("var x;" +
"var names = namesListKey.toArray();" +
"for(x in names) {" +
" println(names[x]);" +
"}" +
"namesListKey.add(\"Dana\");");
}
catch (ScriptException ex)
{
ex.printStackTrace();
}
}
もう1つの方法は、Spring Expression LanguageまたはSpELを使用することです。これは、数式の評価といっそう多くのことをします。したがって、やややり過ぎになるかもしれません。スタンドアロンであるため、この式ライブラリを使用するためにSpringフレームワークを使用する必要はありません。 SpELのドキュメントから例をコピーする：
ExpressionParser parser = new SpelExpressionParser();
int two = parser.parseExpression("1 + 1").getValue(Integer.class); // 2
double twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double.class); //24.0
これは別の興味深い代替方法です https://github.com/Shy-Ta/expression-evaluator-demo
使い方はとても簡単で、仕事を終わらせることができます。例えば：
ExpressionsEvaluator evalExpr = ExpressionsFactory.create("2+3*4-6/2");
assertEquals(BigDecimal.valueOf(11), evalExpr.eval());
それを実装しようとしているなら、私たちは以下のアルゴリズムを使うことができます： -
読み込むトークンはまだありますが、
1.1次のトークンを入手する1.2トークンが
1.2.1 Aナンバー：それをバリュースタックにプッシュします。
1.2.2変数：その値を取得し、値スタックにプッシュします。
1.2.3左括弧：演算子スタックに押し込みます。
1.2.4右括弧：
1 While the thing on top of the operator stack is not a left parenthesis, 1 Pop the operator from the operator stack. 2 Pop the value stack twice, getting two operands. 3 Apply the operator to the operands, in the correct order. 4 Push the result onto the value stack. 2 Pop the left parenthesis from the operator stack, and discard it.1.2.5オペレータ（thisOpと呼ぶ）：
1 While the operator stack is not empty, and the top thing on the operator stack has the same or greater precedence as thisOp, 1 Pop the operator from the operator stack. 2 Pop the value stack twice, getting two operands. 3 Apply the operator to the operands, in the correct order. 4 Push the result onto the value stack. 2 Push thisOp onto the operator stack.オペレータスタックが空ではない場合、1オペレータスタックからオペレータをポップします。 2値スタックを2回ポップして、2つのオペランドを取得します。 3正しい順序でオペランドに演算子を適用します。 4結果を値スタックにプッシュします。
この時点で、演算子スタックは空になっているはずであり、値スタックには1つの値しかないはずです。これが最終結果です。
JEP がうまくいくようです
私はあなたがこれをするどんな方法でそれが多くの条件付きステートメントを含むことになるだろうと思うと思います。しかし、あなたの例のような単一の操作のためには、次のようなものを含むif文を4に制限することができます。
String math = "1+4";
if (math.split("+").length == 2) {
//do calculation
} else if (math.split("-").length == 2) {
//do calculation
} ...
「4 + 5 * 6」のように複数の操作を処理したい場合は、かなり複雑になります。
あなたが計算機を作ろうとしているならば、私は計算の各セクションを別々の方法で渡すことをお勧めします。
これは実際に@Boannによって与えられた答えを補完しています。それは "-2 ^ 2"が-4.0の誤った結果を与える原因となるわずかなバグを持っています。そのための問題は、指数が彼の中で評価される点です。指数をparseTerm（）のブロックに移動するだけで、すべて問題ありません。以下を見てください。 @ Boannの答え は少し修正されています。修正はコメントにあります。
public static double eval(final String str) {
return new Object() {
int pos = -1, ch;
void nextChar() {
ch = (++pos < str.length()) ? str.charAt(pos) : -1;
}
boolean eat(int charToEat) {
while (ch == ' ') nextChar();
if (ch == charToEat) {
nextChar();
return true;
}
return false;
}
double parse() {
nextChar();
double x = parseExpression();
if (pos < str.length()) throw new RuntimeException("Unexpected: " + (char)ch);
return x;
}
// Grammar:
// expression = term | expression `+` term | expression `-` term
// term = factor | term `*` factor | term `/` factor
// factor = `+` factor | `-` factor | `(` expression `)`
// | number | functionName factor | factor `^` factor
double parseExpression() {
double x = parseTerm();
for (;;) {
if (eat('+')) x += parseTerm(); // addition
else if (eat('-')) x -= parseTerm(); // subtraction
else return x;
}
}
double parseTerm() {
double x = parseFactor();
for (;;) {
if (eat('*')) x *= parseFactor(); // multiplication
else if (eat('/')) x /= parseFactor(); // division
else if (eat('^')) x = Math.pow(x, parseFactor()); //exponentiation -> Moved in to here. So the problem is fixed
else return x;
}
}
double parseFactor() {
if (eat('+')) return parseFactor(); // unary plus
if (eat('-')) return -parseFactor(); // unary minus
double x;
int startPos = this.pos;
if (eat('(')) { // parentheses
x = parseExpression();
eat(')');
} else if ((ch >= '0' && ch <= '9') || ch == '.') { // numbers
while ((ch >= '0' && ch <= '9') || ch == '.') nextChar();
x = Double.parseDouble(str.substring(startPos, this.pos));
} else if (ch >= 'a' && ch <= 'z') { // functions
while (ch >= 'a' && ch <= 'z') nextChar();
String func = str.substring(startPos, this.pos);
x = parseFactor();
if (func.equals("sqrt")) x = Math.sqrt(x);
else if (func.equals("sin")) x = Math.sin(Math.toRadians(x));
else if (func.equals("cos")) x = Math.cos(Math.toRadians(x));
else if (func.equals("tan")) x = Math.tan(Math.toRadians(x));
else throw new RuntimeException("Unknown function: " + func);
} else {
throw new RuntimeException("Unexpected: " + (char)ch);
}
//if (eat('^')) x = Math.pow(x, parseFactor()); // exponentiation -> This is causing a bit of problem
return x;
}
}.parse();
}
package ExpressionCalculator.expressioncalculator;
import Java.text.DecimalFormat;
import Java.util.Scanner;
public class ExpressionCalculator {
private static String addSpaces(String exp){
//Add space padding to operands.
//https://regex101.com/r/sJ9gM7/73
exp = exp.replaceAll("(?<=[0-9()])[\\/]", " / ");
exp = exp.replaceAll("(?<=[0-9()])[\\^]", " ^ ");
exp = exp.replaceAll("(?<=[0-9()])[\\*]", " * ");
exp = exp.replaceAll("(?<=[0-9()])[+]", " + ");
exp = exp.replaceAll("(?<=[0-9()])[-]", " - ");
//Keep replacing double spaces with single spaces until your string is properly formatted
/*while(exp.indexOf(" ") != -1){
exp = exp.replace(" ", " ");
}*/
exp = exp.replaceAll(" {2,}", " ");
return exp;
}
public static Double evaluate(String expr){
DecimalFormat df = new DecimalFormat("#.####");
//Format the expression properly before performing operations
String expression = addSpaces(expr);
try {
//We will evaluate using rule BDMAS, i.e. brackets, division, power, multiplication, addition and
//subtraction will be processed in following order
int indexClose = expression.indexOf(")");
int indexOpen = -1;
if (indexClose != -1) {
String substring = expression.substring(0, indexClose);
indexOpen = substring.lastIndexOf("(");
substring = substring.substring(indexOpen + 1).trim();
if(indexOpen != -1 && indexClose != -1) {
Double result = evaluate(substring);
expression = expression.substring(0, indexOpen).trim() + " " + result + " " + expression.substring(indexClose + 1).trim();
return evaluate(expression.trim());
}
}
String operation = "";
if(expression.indexOf(" / ") != -1){
operation = "/";
}else if(expression.indexOf(" ^ ") != -1){
operation = "^";
} else if(expression.indexOf(" * ") != -1){
operation = "*";
} else if(expression.indexOf(" + ") != -1){
operation = "+";
} else if(expression.indexOf(" - ") != -1){ //Avoid negative numbers
operation = "-";
} else{
return Double.parseDouble(expression);
}
int index = expression.indexOf(operation);
if(index != -1){
indexOpen = expression.lastIndexOf(" ", index - 2);
indexOpen = (indexOpen == -1)?0:indexOpen;
indexClose = expression.indexOf(" ", index + 2);
indexClose = (indexClose == -1)?expression.length():indexClose;
if(indexOpen != -1 && indexClose != -1) {
Double lhs = Double.parseDouble(expression.substring(indexOpen, index));
Double rhs = Double.parseDouble(expression.substring(index + 2, indexClose));
Double result = null;
switch (operation){
case "/":
//Prevent divide by 0 exception.
if(rhs == 0){
return null;
}
result = lhs / rhs;
break;
case "^":
result = Math.pow(lhs, rhs);
break;
case "*":
result = lhs * rhs;
break;
case "-":
result = lhs - rhs;
break;
case "+":
result = lhs + rhs;
break;
default:
break;
}
if(indexClose == expression.length()){
expression = expression.substring(0, indexOpen) + " " + result + " " + expression.substring(indexClose);
}else{
expression = expression.substring(0, indexOpen) + " " + result + " " + expression.substring(indexClose + 1);
}
return Double.valueOf(df.format(evaluate(expression.trim())));
}
}
}catch(Exception exp){
exp.printStackTrace();
}
return 0.0;
}
public static void main(String args[]){
Scanner scanner = new Scanner(System.in);
System.out.print("Enter an Mathematical Expression to Evaluate: ");
String input = scanner.nextLine();
System.out.println(evaluate(input));
}
}
Symjaフレームワーク を見てください。
ExprEvaluator util = new ExprEvaluator();
IExpr result = util.evaluate("10-40");
System.out.println(result.toString()); // -> "-30"
最終的により複雑な式を評価できることに注意してください。
// D(...) gives the derivative of the function Sin(x)*Cos(x)
IAST function = D(Times(Sin(x), Cos(x)), x);
IExpr result = util.evaluate(function);
// print: Cos(x)^2-Sin(x)^2
JDK 1.6のJavascriptエンジンとコードインジェクション処理を使用して、次のサンプルコードを試してください。
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
public class EvalUtil {
private static ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript");
public static void main(String[] args) {
try {
System.out.println((new EvalUtil()).eval("(((5+5)/2) > 5) || 5 >3 "));
System.out.println((new EvalUtil()).eval("(((5+5)/2) > 5) || true"));
} catch (Exception e) {
e.printStackTrace();
}
}
public Object eval(String input) throws Exception{
try {
if(input.matches(".*[a-zA-Z;~`#$_{}\\[\\]:\\\\;\"',\\.\\?]+.*")) {
throw new Exception("Invalid expression : " + input );
}
return engine.eval(input);
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
}
答えるには遅すぎますが、私はJavaで式を評価するために同じ状況に遭遇しました、それは誰かを助けるかもしれません
MVELは式の実行時評価を行います、これで評価させるためにStringにJavaコードを書くことができます。
String expressionStr = "x+y";
Map<String, Object> vars = new HashMap<String, Object>();
vars.put("x", 10);
vars.put("y", 20);
ExecutableStatement statement = (ExecutableStatement) MVEL.compileExpression(expressionStr);
Object result = MVEL.executeExpression(statement, vars);
このようなものはどうですか。
String st = "10+3";
int result;
for(int i=0;i<st.length();i++)
{
if(st.charAt(i)=='+')
{
result=Integer.parseInt(st.substring(0, i))+Integer.parseInt(st.substring(i+1, st.length()));
System.out.print(result);
}
}
他のすべての数学演算子についても同様にしてください。
RHINOやNASHORNなどの外部ライブラリを使用してJavaScriptを実行できます。そしてjavascriptは文字列を解析することなく簡単な式を評価することができます。コードが適切に記述されていれば、パフォーマンスへの影響もありません。以下はRHINOの例です -
public class RhinoApp {
private String simpleAdd = "(12+13+2-2)*2+(12+13+2-2)*2";
public void runJavaScript() {
Context jsCx = Context.enter();
Context.getCurrentContext().setOptimizationLevel(-1);
ScriptableObject scope = jsCx.initStandardObjects();
Object result = jsCx.evaluateString(scope, simpleAdd , "formula", 0, null);
Context.exit();
System.out.println(result);
}
さらに別の選択肢： https://github.com/stefanhaustein/expressionparser
両方を許可するためのシンプルだが柔軟なオプションを持つためにこれを実装しました。
- 即時処理（ Calculator.Java 、 SetDemo.Java ）
- 解析木の構築と処理（ TreeBuilder.Java ）
上でリンクされたTreeBuilderはシンボリック派生をする CASデモパッケージ の一部です。 BASICインタプリタ の例もあり、私は TypeScriptインタプリタを作り始めました それを使用する。
import Java.util.*;
StringTokenizer st;
int ans;
public class check {
String str="7 + 5";
StringTokenizer st=new StringTokenizer(str);
int v1=Integer.parseInt(st.nextToken());
String op=st.nextToken();
int v2=Integer.parseInt(st.nextToken());
if(op.equals("+")) { ans= v1 + v2; }
if(op.equals("-")) { ans= v1 - v2; }
//.........
}
Djikstraのシャントヤードアルゴリズム を使用して、中置記法の表現文字列を後置記法に変換することができます。アルゴリズムの結果は ポストフィックスアルゴリズム への入力として使用でき、式の結果を返します。
私はここでそれについての記事を書きました 、そしてJavaでの実装
数式を評価できるJavaクラス
package test;
public class Calculator {
public static Double calculate(String expression){
if (expression == null || expression.length() == 0) {
return null;
}
return calc(expression.replace(" ", ""));
}
public static Double calc(String expression) {
if (expression.startsWith("(") && expression.endsWith(")")) {
return calc(expression.substring(1, expression.length() - 1));
}
String[] containerArr = new String[]{expression};
double leftVal = getNextOperand(containerArr);
expression = containerArr[0];
if (expression.length() == 0) {
return leftVal;
}
char operator = expression.charAt(0);
expression = expression.substring(1);
while (operator == '*' || operator == '/') {
containerArr[0] = expression;
double rightVal = getNextOperand(containerArr);
expression = containerArr[0];
if (operator == '*') {
leftVal = leftVal * rightVal;
} else {
leftVal = leftVal / rightVal;
}
if (expression.length() > 0) {
operator = expression.charAt(0);
expression = expression.substring(1);
} else {
return leftVal;
}
}
if (operator == '+') {
return leftVal + calc(expression);
} else {
return leftVal - calc(expression);
}
}
private static double getNextOperand(String[] exp){
double res;
if (exp[0].startsWith("(")) {
int open = 1;
int i = 1;
while (open != 0) {
if (exp[0].charAt(i) == '(') {
open++;
} else if (exp[0].charAt(i) == ')') {
open--;
}
i++;
}
res = calc(exp[0].substring(1, i - 1));
exp[0] = exp[0].substring(i);
} else {
int i = 1;
if (exp[0].charAt(0) == '-') {
i++;
}
while (exp[0].length() > i && isNumber((int) exp[0].charAt(i))) {
i++;
}
res = Double.parseDouble(exp[0].substring(0, i));
exp[0] = exp[0].substring(i);
}
return res;
}
private static boolean isNumber(int c) {
int zero = (int) '0';
int nine = (int) '9';
return (c >= zero && c <= nine) || c =='.';
}
public static void main(String[] args) {
System.out.println(calculate("(((( -6 )))) * 9 * -1"));
System.out.println(calc("(-5.2+-5*-5*((5/4+2)))"));
}
}