net.segoia.util.calculator.Calculator Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons Show documentation
Various Java Utils
The newest version!
/**
 * commons - Various Java Utils
 * Copyright (C) 2009  Adrian Cristian Ionescu - https://github.com/acionescu
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.segoia.util.calculator;

import java.util.HashMap;
import java.util.Map;

import net.segoia.util.calculator.event.MathExpressionParserEventHandler;
import net.segoia.util.calculator.operators.AddOperator;
import net.segoia.util.calculator.operators.ConstantOperator;
import net.segoia.util.calculator.operators.DecimalLogarithmOperator;
import net.segoia.util.calculator.operators.DivideOperator;
import net.segoia.util.calculator.operators.MultiplyOperator;
import net.segoia.util.calculator.operators.NaturalLogarithmOperator;
import net.segoia.util.calculator.operators.Operator;
import net.segoia.util.calculator.operators.PowerOperator;
import net.segoia.util.calculator.operators.SqrtOperator;
import net.segoia.util.calculator.operators.SubtractOperator;
import net.segoia.util.parser.Parser;
import net.segoia.util.parser.ParserException;
import net.segoia.util.parser.ParserHandlerFactory;
import net.segoia.util.parser.SymbolType;

public class Calculator {
    private static Map operators;
    private static Parser parser;

    static {
	operators = new HashMap();
	operators.put("+", new AddOperator());
	operators.put("-", new SubtractOperator());
	operators.put("/", new DivideOperator());
	operators.put("*", new MultiplyOperator());
	operators.put("sqrt", new SqrtOperator());
	operators.put("^", new PowerOperator());
	operators.put("ln", new NaturalLogarithmOperator());
	operators.put("lg", new DecimalLogarithmOperator());
	operators.put("const", new ConstantOperator());

	parser = new Parser();
	parser.setHandlerFactory(new ParserHandlerFactory(new MathExpressionParserEventHandler()));
	parser.addSymbol("+", SymbolType.ASSOCIATE, 5);
	parser.addSymbol("-", SymbolType.ASSOCIATE, 5);
	parser.addSymbol("*", SymbolType.ASSOCIATE, 3);
	parser.addSymbol("/", SymbolType.ASSOCIATE, 3);
	parser.addSymbol("sqrt", SymbolType.ASSOCIATE, 2);
	parser.addSymbol("^", SymbolType.ASSOCIATE, 2);
	parser.addSymbol("ln", SymbolType.ASSOCIATE, 2);
	parser.addSymbol("lg", SymbolType.ASSOCIATE, 2);
	parser.addSymbol("const", SymbolType.ASSOCIATE, 2);
	parser.addSymbol("(", SymbolType.GROUP_START, 0);
	parser.addSymbol(")", SymbolType.GROUP_END, 0);
    }

    public Calculator() {
    }

    public Number calculate(Expression expression, Map values) {
	return expression.calculate(operators, values).getNumber();
    }

    public Number evaluate(String string, Map values) throws ParserException {
	Expression expression = parseExpression(string);
	return calculate(expression, values);
    }

    public static Expression buildExpression(String operatorString, Expression exp1, Expression exp2) {
	Operator operator = operators.get(operatorString);
	if (operator.getArgumentsCount() == 2) {
	    return new DoubleOperandExpression(exp1, exp2, operatorString);
	} else if (operator.getArgumentsCount() == 1) {
	    return new SingleOperandExpression(operatorString, exp2);
	}
	return null;
    }

    public static Expression parseExpression(String string) throws ParserException {
	return (Expression) parser.parse(string).getObjects().pop();
    }

    public static void main(String[] args) throws ParserException {
	Calculator calc = new Calculator();
	// Map vals = new HashMap();
	// vals.put("a", 5);
	// Expression exp = new DoubleOperandExpression(new ConstantExpression("a"), new ConstantExpression("3"), "/");
	// System.out.println(calc.calculate(exp, vals));
	Map values = new HashMap();
//	values.put("e", 2);
//	System.out.println(calc.evaluate("(((2+8)*(3-2))+10)/a", values));
	System.out.println(calc.evaluate("const(e)+e", values));
    }

}