Converter uma equação em float

9 respostas
Arthur_Laender

Bom dia, gostaria de saber como faço para transformar uma equação em um valor float, se alguém puder me ajudar. Fiz assim:

String equacao="(x*x*x)+15"; float x=3; float valor=Transforma(equacao,x);

public float Transforma(String equacao,float x) { equacao=equacao.replaceAll("x",""+x); //até aqui fica tudo blz (3*3*3)+15 return Float.parseFloat(equacao); }

Gostaria de saber como faço para converter o (333)+15 em 42, se coloco um valor float=(333)+15; dá certo, mais ao converter essa String em float já da errado.

Se alguém puder me ajudar, desde já agradeço.

9 Respostas

F

Cara pelo q eu saiba num da para converter do jeito q vc quer porque a função nao converte os caracteres especias (*,+,-, esses ai), ai no caso ela lança uma execeção.

Acho q vc deveria percorrer a string e fazer um contador para resolver esse exe, tipo minha ideia é essa, num sei se é a melhor mas se quise ajuda fala ae.

Flw

Marky.Vasconcelos

Voce nao tem no Java algo igual ao eval do JavaScript. Voce vai ter que dividir essa String na mão e fazer as contas.

Arthur_Laender

Estou meio que perdido no que fazer então agora.

Qualquer ajuda vai ser bem vindo.

rldpv

Acho que o único jeito seria você usar o método charAt() para pegar os caracteres da String separadamente.

Marky.Vasconcelos

É meio complicado.

Amanhã eu posto algo que começei a fazer no trabalho. Mas voce vai ter que terminar o código.

Arthur_Laender

Ok… estou no aguardo.

Obrigado mesmo.

Marky.Vasconcelos

Alias… terminei o código hoje…

O seguinte main faz o que voce queria.

public static void main(String[] args) {
		Expression exp = new Expression("(x+x+x)*5");
		exp.setVariable("x", 3);
		System.out.println(exp.resolve());
	}

E a classe Expression.

package mark.utils.math;

import java.util.LinkedList;
import java.util.List;
import java.util.regex.Pattern;

public class Expression {
	private String expression;
	private List<Double> numbers = new LinkedList<Double>();
	private List<Operator> operators = new LinkedList<Operator>();

	public Expression(String exp) {
		expression = exp;
	}

	public static double resolve(String expression) {
		return new Expression(expression).resolve();
	}

	public void setVariable(String name, Object value) {
		expression = expression.replaceAll(name, value.toString());
	}

	public double resolve() {
		numbers = new LinkedList<Double>();
		operators = new LinkedList<Operator>();
		StringBuilder current = new StringBuilder();
		if (expression.startsWith("-") || expression.startsWith("+"))
			numbers.add(0.0);

		for (int i = 0; i < expression.length(); i++) {
			String s = expression.substring(i, i + 1);
			if (s.equals("(")) {
				int opens = 0;
				String sub = expression.substring(i);
				for (int j = 0; j < sub.length(); j++) {
					String ss = sub.substring(j, j + 1);
					if (ss.equals("("))
						opens++;
					if (ss.equals(")"))
						opens--;
					if (opens == 0) {
						String exp = sub.substring(0, j + 1);
						String expPure = sub.substring(1, j);
						double value = new Expression(expPure).resolve();
						expression = expression.replace(exp, Double
								.toString(value));
						return resolve();
					}
				}
				continue;
			}

			if (s.matches(operator.pattern())) {
				if (s.equals(add.symbol()))
					operators.add(add);
				else if (s.equals(minus.symbol()))
					operators.add(minus);
				else if (s.equals(div.symbol()))
					operators.add(div);
				else
					operators.add(times);
				continue;
			}
			current.append(s);
			String next = "";
			if (expression.length() >= i + 2)
				next = expression.substring(i + 1, i + 2);
			if (!next.matches(digit.pattern())) {
				numbers.add(Double.parseDouble(current.toString()));
				current.delete(0, current.length());
			}
		}
		resolveTimesDivs();

		double result = 0;
		if (numbers.size() == 1)
			result = numbers.get(0);

		else {
			result = operators.get(0).resolve(numbers.get(0), numbers.get(1));
			for (int i = 1; i < operators.size(); i++) {
				Operator op = operators.get(i);
				result = op.resolve(result, numbers.get(i + 1));
			}
		}
		return result;
	}

	private void resolveTimesDivs() {
		for (int i = 0; i < operators.size(); i++) {
			Operator op = operators.get(i);
			boolean resolve = op.symbol().equals(div.symbol())
					|| op.symbol().equals(times.symbol());
			if (resolve) {
				double d1 = numbers.get(i);
				double d2 = numbers.get(i + 1);
				double result = op.resolve(d1, d2);
				numbers.set(i, result);
				numbers.remove(i + 1);
				operators.remove(i);
				resolveTimesDivs();
				break;
			}
		}
	}

	private static final Pattern digit = Pattern.compile("[0-9\.]");
	private static final Pattern operator = Pattern.compile("[+\-/*]");

	private interface Operator {
		public double resolve(double first, double second);

		public String symbol();
	}

	private Operator minus = new Operator() {
		public double resolve(double first, double second) {
			return first - second;
		}
		public String symbol() {
			return "-";
		}
	};
	private Operator add = new Operator() {
		public double resolve(double first, double second) {
			return first + second;
		}
		public String symbol() {
			return "+";
		}
	};
	private Operator div = new Operator() {
		public double resolve(double first, double second) {
			return first / second;
		}
		public String symbol() {
			return "/";
		}
	};
	private Operator times = new Operator() {
		public double resolve(double first, double second) {
			return first * second;
		}
		public String symbol() {
			return "*";
		}
	};
}
Marky.Vasconcelos

Fiz um post sobre isso no meu blog.

Sei que esporadicamente as pessoas procuram esse assunto então decedi deixar lá para estar mais fácil o acesso a informação.

Arthur_Laender

Valeu mesmo cara

ficou muito bom

você está de parabens!!

brigadao

Criado 20 de junho de 2009
Ultima resposta 22 de jun. de 2009
Respostas 9
Participantes 4