Mensajes

LO cierto es que lo solucioné sin necesidad de ayuda puesto que no entendi la respuesta del amigo LEYER.

Una cosa, que ando asustadillo, creeis que podria cursar carrera de informatica? me han dicho que es muy dificil y tal, pero poco a poco voy haciendo cosas para que luego no me cueste tanto.

Saludos

Mejorado, solo queda un ultimo detalle.

Saludos

Lo más recomendable sería usar el concepto de sistema de ecuaciones. Podrías utilizar el método de gauss, hallando un cuadro de números y resolviendo tal... es sólo una idea.

Ok investigare sobre el tema, pero para un sistema de ecuaciones no tiene que haber mas de una ?

Saludos

Hola a todos, ya tengo mi procesador de expresiones algebraico-aritmeticas, resuelve expreiones facilmente, ahora quiero dar el paso y conseguir hacerlo con expresiones de dos miembros, osease, ecuaciones con 1 o mas incognitas.

Tengo por ejemplo esta expresion:

5*49/2*a == 15

La evaluo, proceso y me pide un valor para a se lo doy y si no cumple la expresión, devuelve 0 (false) si la cumple devuelve 1 (true).
Ahora estoy planteando una manera de aislar la incognita en uno de los miembros de la ecuacion, para resolverla, añadirla ala expresion inicial y comprovar que es correcta.
La pregunta es como?

He imaginado 3 maneras posibles:

La primera, es haciendo el bestia, y usando puerza bruta, aunmentando la variable de 0,001 en 0,001 e ir probando pero será muy inexacto y es probable que en muchas ocasiones no lo encuentre, eso sin contar con el uso de memoria que requeriria un bucle de ese nivel.

La segunda es identificando el grado de la ecuacion, aislar las incognitas y aplicar la formula correspondiente.

La tercera es haciendolo literalmente, osea moviendo caracteres por la cadena, y detectando el simbolo que lleva para luego dejar la incognita sola y evaluar la expresión. Esto eliminando posibilidades puede resultar muy tedioso de programar, y quizas, que estoy seguro que habrá metodos mas sencillos que estos.

Un saludo

Estas en tiempo de clases o para que haces este code??

Amm yo hice un Evaluador de Expresiones Aritmeticas hace tiempo, bueno como un año, tiene su analizador lexico y gramatico y despues convertia las operaciones a lenguaje ensamblador.

Y te preguntaba si era un trabajo de la escuela me imagino que es para ayer  pero si es por hacer algo puedes hacer tu propio Analizador Lexico y Gramatical

Aqui el Analizador de Expresiones Aritmeticas que hice sin librerias mas que el substance 

Y de tu code aun no he revisado nada, mas tarde me doy una vuelta

http://laquetegustaati.com.mx/D929/Analizador.rar

Saludos

LO hago por placer si no he cumplido los 16 aun xD
PD:Solucionado, ocurre porque abc lo detecta como una variable y no como 3 factores (menuda empanada mental la mia xD)

Saludos

no entendi,para que pides la variables ? y esto qui lo modifico y no salta error

new String("5*49/2*a");

y cuando pide variables es a,A,B

Un Saludo.

Pido variables para poder completar la expresion.
Lo de las variables aab lo solucione haciendo saltos en el bucle de dos en dos envezde uno en uno.
El problema es que no se porque ese error, no le veo sentido.

Saludos

Gracias, haber si alguien me ayuda con el error.

Saludos

Aprende C++ o java 

Saludos

[<----- Aqui introduzco una nueva variable, que teoricamente tendria que analizar y pedir un valor para esta]

Hola a todos, tengo ya casi acabado el analizador de expresiones numéricas, le introduces una expresion aritmetica con variables inclusive, la analiza y resuelve, pero aun tiene un error que no he conseguido solucionar, os dejo el codigo y el error:

Código (java) [Seleccionar] Expandir


package main;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import net.java.dev.eval.Expression;

public class principal {
//Por cutre que parezca, si he metido el abecedario en una matriz para identificar incognitas...
//xD
public static char[] TokensVariables = {'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F', 'g', 'G', 'h', 'H', 'i', 'I', 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'p', 'P', 'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'u', 'U', 'v', 'V', 'w', 'W', 'x', 'X', 'y', 'Y', 'z', 'Z'};
public static int cuantasVariables = 0;
public static Vector<Character> vectorOperandos = new Vector(10, 5);
public static Vector<Character> vectorVariables = new Vector(10, 5);

public static void main(String args[])
{

   String expresion = new String("2*x+b");
     
   System.out.println("\n"+Procesador(preProcesador(expresion), expresion)); //La recursividad es inutil aqui, o quizas lo soy yo...

}
static int[] preProcesador(String argumento)
{
char[] TokensOperandos = {'+', '-', '*', '/', '^'};

char[] TokensVariables = {'a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F', 'g', 'G', 'h', 'H', 'i', 'I', 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'p', 'P', 'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'u', 'U', 'v', 'V', 'w', 'W', 'x', 'X', 'y', 'Y', 'z', 'Z'};

int countOperandos = 0;
int countVariables = 0;
/*BUCLE SEPARADOR DE OPERANDOS*/

/*-NOTA: ESTE ALGORITMO SE PUEDE MEJORAR, PUES EL BUCLE SOBRECARGA*/
//                                        ^
//                                        |
//La pereza hace cosas muy malas...  -----|
//Bucle que busca operandos y los distribuye en memoria
for(int i = 0; i< argumento.length(); i++)
{
//Bucle para recorrer la matriz con los tokens
for(int j = 0; j < TokensOperandos.length; j++)
{
char chVolatil = TokensOperandos[j]; //Un caprichito de programador idiota :P
if(argumento.charAt(i) == chVolatil)
{
vectorOperandos.add(chVolatil);
countOperandos++;
}
}
}
/*BUCLE PARA SEPARAR VARIABLES                                    */
/*-NOTA: ESTE ALGORITMO SE PUEDE MEJORAR, PUES EL BUCLE SOBRECARGA*/
    //                                        ^
//                                        |
//La pereza hace cosas muy malas...  -----|
for(int i = 0; i < argumento.length(); i++)
{
//Bucle para recorrer la matriz con los tokens
for(int j = 0; j < TokensVariables.length; j++)
{
char varVolatil = TokensVariables[j]; //Un caprichito de programador idiota :P
if(argumento.charAt(i) == varVolatil)
{
vectorVariables.add(varVolatil);
countVariables++;
}
}
}//Que poco me gusta trabajar, y como se nota el copypaste de este fragmento...
//Para que codearlo 2 veces? Es inutil hacerlo :P
System.out.print("Estos son los " + vectorOperandos.size() + " operandos que hay en la expresion:\n" );
System.out.print("[");
for(int i=0; i<vectorOperandos.size(); i++){
if(i == 0)
{
        System.out.print(vectorOperandos.elementAt(i));
}else{
    System.out.print(","+vectorOperandos.elementAt(i));
}
    }
System.out.print("]\n");
    System.out.println("/////////////////////////////////////////////////////////////////////////////// ");
    System.out.println("############################################################################### ");
    System.out.println("/////////////////////////////////////////////////////////////////////////////// ");
System.out.print("Y aqui estan las " + vectorVariables.size() + " variables o incognitas de la expresion:\n");
System.out.print("[");
for(int i=0; i<vectorVariables.size(); i++){
if(i == 0)
{
        System.out.print(vectorVariables.elementAt(i));
}else{
    System.out.print(","+vectorVariables.elementAt(i));
}
    }
System.out.print("]");
int[] salida = {countOperandos, countVariables};
return salida;
}
static BigDecimal Procesador(int[] cuantos, String que)
{

Expression exp = new Expression(que);
InputStreamReader isr = new InputStreamReader(System.in);
     BufferedReader br = new BufferedReader(isr);

Map<String, BigDecimal> variables = new HashMap<String, BigDecimal>();

for(int j = 0; j < cuantos[1]; j++)
{
System.out.print("\nDame un valor para la variable " + vectorVariables.elementAt(j) + " :\n");
try {
String expresionVolatil = br.readLine();
            variables.put(String.valueOf(vectorVariables.elementAt(j)), Procesador(preProcesador(expresionVolatil), expresionVolatil));
} catch (IOException e) {
           e.printStackTrace();
}
}
     BigDecimal result = exp.eval(variables);

return result;
}
}


Y aqui la salida de la ejecucion del programita en cuestion:
OUT:

Ya depurado el programa hace su funcion especial solo tiene un pequeño fallo que no soy capaz de ver:

Estos son los 2 operandos que hay en la expresion:
[*,+]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 2 variables o incognitas de la expresion:
[x,b]
Dame un valor para la variable x :
5*3
Estos son los 3 operandos que hay en la expresion:
[*,+,*]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 2 variables o incognitas de la expresion:
[x,b]
Dame un valor para la variable b :
6*x
Estos son los 4 operandos que hay en la expresion:
[*,+,*,*]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 3 variables o incognitas de la expresion:
[x,b,x]
Dame un valor para la variable x :
15
Estos son los 4 operandos que hay en la expresion:
[*,+,*,*]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 3 variables o incognitas de la expresion:
[x,b,x]
120

Ese seria el desarrollo de la expresión 2*x+b

El problema es que cuando cuando un valor para una variable, si introduzco otra expresion que tenga otra variable y no es una de las que estaban en la principal no funciona, aqui os dejo para que lo veais con vuestros propios ojos:

Estos son los 2 operandos que hay en la expresion:
[*,+]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 2 variables o incognitas de la expresion:
[x,b]
Dame un valor para la variable x :
5*x
Estos son los 3 operandos que hay en la expresion:
[*,+,*]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 3 variables o incognitas de la expresion:
[x,b,x]
Dame un valor para la variable x :
7
Estos son los 3 operandos que hay en la expresion:
[*,+,*]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 3 variables o incognitas de la expresion:
[x,b,x]
Dame un valor para la variable b :
6*d  <----- Aqui introduzco una nueva variable, que teoricamente tendria que analizar y pedir un valor para esta
Estos son los 4 operandos que hay en la expresion:
[*,+,*,*]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 4 variables o incognitas de la expresion:
[x,b,x,d]
Dame un valor para la variable x :   <-------Sin embargo pide para X y no para d que es la que he pedido y como se aprecia abajo no tiene valor para d puesto que no ha pedido para esta, si no para X
1
Exception in thread "main" java.lang.RuntimeException: no value for variable "d"
   at net.java.dev.eval.Operation.evaluateOperand(Operation.java:128)
   at net.java.dev.eval.Operation.eval(Operation.java:107)
   at net.java.dev.eval.Expression.eval(Expression.java:161)
   at main.principal.Procesador(principal.java:123)
   at main.principal.Procesador(principal.java:118)
   at main.principal.main(principal.java:26)
Estos son los 4 operandos que hay en la expresion:
[*,+,*,*]
///////////////////////////////////////////////////////////////////////////////
###############################################################################
///////////////////////////////////////////////////////////////////////////////
Y aqui estan las 4 variables o incognitas de la expresion:
[x,b,x,d]

Haber si me pueden ayudar con este ultimo problema.
Saludos

He encontrado esta libreria que por ahora funciona muy bien:
https://eval.dev.java.net/eval-dist-0.5.zip

Saludos