Como fazer um programa java que reconheça uma função de duas variaveis atribua valores a essa?

Primeiro vou dar um exemplo e depois faço a pergunta.

Ex1.
Temos uma função qualquer, por ex. y= x^2 + 1 ( leia ‘y’ é igual ‘x’ ao quadrado mais um ), uma função do segundo grau.

Para construir o gráfico dessa função atribuimos valores a ‘x’ para encontrar os valores de ‘y’
e assim montar o par ordenado (x,y) que representa um ponto no plano cartesiano.

Atribuindo valores para ‘x’ ´podemos montar um tabela que nos dá os pares ordenados:
Podemos usar quaisquer numeros,mas usarei o intervalo [-3,3]

x | y= x^2 + 1
-3| y=(-3)^2 +1 = 10
-2| y=(-2)^2 +1 = 5
-1| y=(-1)^2 +1 = 2
0| y=(0)^2 +1 = 1
1| y=(1)^2 +1 = 2
2| y=(2)^2 +1 = 5
3| y=(3)^2 +1 = 10

Encontramos então os pares ordenados:
(-3,10) ; (-2,5) ;(-1,2) ; (0,1) ; (1,2) ; (2,5) ;(3,10)

que tabem pode ser representado por um tabela:
x | y
-3| y= 10
-2| y= 5
-1| y= 2
0| y= 1
1| y= 2
2| y= 5
3| y= 10

Agora vou começar a expor a minha duvida.
Veja esse programa:

Ex2

/*

  • To change this template, choose Tools | Templates
  • and open the template in the editor.
    */

package encontrando_o_valor_de_y;

/**
*

  • @author Soldat des Gottes
    */
    import javax.swing.JOptionPane;
    public class Main {

    /**

    • @param args the command line arguments
      */
      public static void main(String[] args) {

    int x,y;
    String x1;

x1= JOptionPane.showInputDialog( "Temos a função y = x + 1 \n " +
“Atribua um valor para ‘x’,”); // recebe um valor para a função y = x + 1

x = Integer.parseInt(x1); // tranforma String em int

y= x + 1; // recebe o valor de ‘x’ e calcula ‘y’

JOptionPane.showMessageDialog( null , "O valor de ‘y’ é: \t\t " + y);
// exibe o valor de ‘y’

System.exit( 0 ) ;

                 }
                 }

 
Vemos que o programa acima recebe um valor para 'x' e o substitui na função contida no programa,                     y = x + 1 , e assim encontra o valor da variavel 'y'. 

 Em :    x1= JOptionPane.showInputDialog( "Temos a função y = x + 1 \n " +
                                              "Atribua um valor para 'x',"); 

 A entrada é um numero e esse numero é atribuido a a função ja existente no programa(y = x + 1).

A pergunta é : seria possivel entrar com uma função?

  Ex : o programa pediria: DIGITE A FUNÇÃO ?

       O USUARIO DIGITARIA UMA FUNÇÃO QUALQUER, TIPO : y = x^2 +1
         
       O programa reconheceria a função e atribuiria valores numericos a essa função como no Ex1, no inicio desse texto.
      E depois de encontrar os valores de x e y os lançaria numa tabela. 

     Seria possivel isso??
     Ao invez de entramos com um numero para que o programa o sustitua numa função ja existente como no Ex2, visto acima, entramos com um função quaquer( tipo: y = x^2 +1 ) para que o programa  atribuisse valores a essa função e após isso criar uma tabela de valores como no Ex1 .

    Espero que tenha ficado mais facil de entender minha duvida agora.
   Agradeço a atenção!
   Deus abençoe!

Não use caixa alta, cara. Seja educado.

Iai cara…

fiz um pequeno metodo aqui…vê se te ajuda… pelo que entendi, era isso…se ficou confuso, posta outra vez. Coloquei os comentários p te ajudar…

abraço.

//inicio é o mesmo que o intervalor ate o numero de repeticoes 
    //inicio = 10 e nRepeticoes = 10
    //intervalo = 10 a 20
    public double [] funcao(int inicio, int nRepeticoes){
    	
    	if ( nRepeticoes < 1 ){//numero de repeticoes deve ser maior que zero
    		
    		System.out.println("Repeticões deve ser > 0");
    		return new double[0]; //interrompemos o metodo e retornamos um vetor vazio
    	}
    	
    	double calc = 0;
    	
    	//guardaremos os dados em um vetor...para saber o tamanho do vetor deveremos calcular
    	//o intervalor que é o ínicio + nRepeticoes, lembrando que o teremos que saber se o inicio é menor que zero
    	double [] tab;
    	
    	if ( inicio < 0 ){//se o inicio for menor que zero, multiplicamos por -1 para somarmos com o n de Repeticoes
    					  //assim, teremos o intervalo q será a quantida de posicoes em nosso vetor
    		 int valPositivo = (inicio * (-1));
    		 tab = new double[ valPositivo + nRepeticoes ];
    		
    	}else {
    			
    			if(inicio == 0){ //se inicio for 0, somamos mais um, para assim termos o numero do intervalo
    				
    				tab = new double [ nRepeticoes + 1 ];
    		    		
    			}else {//senão, simplesmente somamos inicio + nRepeticoes para termos o intervalo e a qtde de posicoes
    		
    					tab = new double[ inicio + nRepeticoes ];
    				}
    		}
    		
    	int count = 0; //vamos usar uma variavel auxiliar p colocarmos os valores no vetor...pois
    				   //se usarmos a var... inicio iremos acessar uma posicao inexistente, se o mesmo for negativo
    				      	
    	
    	while(inicio <= nRepeticoes){//enquanto o inicio for menor que o n de repeticoes, continua calculando
    	
    		calc = 2 * Math.pow(inicio, 2); // equivale a inicio ^ 2
    		tab[count] = calc; //guardamos o valor calculado
    		
    		inicio++; //soma 1 ao inicio
    		
    		System.out.println(tab[count++]);//imprime
    		
    	}
    	
    	return tab; //retornamos o vetor
    }

Olá, bom dia…
Acho melhor, ao invés de editar a pergunta, refazê-la. Do jeito que vc fez, fica mto estranho a resposta anterior.

abraço!

cara, se vc for trabalhar com funções matemáticas diversas tente um parser qq, tipo jep ou xjep. É bem complicado escrever algo que faça isso do zero, por isso a sugestão.

cara, se vc for trabalhar com funções matemáticas diversas tente um parser qq, tipo jep ou xjep. É bem complicado escrever algo que faça isso do zero, por isso a sugestão.[/quote]

Exercicios como esse costumam ser de universidades. Então preferem que você reinvente a roda mesmo :wink:
Porem, caso nao seja, usar jep ou xjep é o recomendado :slight_smile:

Att,

Renan

Rafael, a versão atual do jep - 3.1 - não é mais open source, contudo, é bem fácil encontrar as versões anteriores (2.4.0, que era gpl).

Isso que vc está querendo fazer pode ser feito simplesmente substituindo x (ou qq outra variável) por uma função que reconheça séries.

Vc terá que escrever um wrapper de função de leitura de séries para o jep e então utilizá-la em meio à suas fórmulas.

Por exemplo:

Seu usuário digitou: y = x^2 +1
antes de submeter essa string para o jep vc terá de substituir x pela função que conhece essa série.

Fórmula “traduzida”: y = serie(“x”)^2 +1

depois disso feito vc só precisa fazer o parser e avaliar o node retornado dentro de um loop.

Fiz isso recentemente e funcionou muito bem pra mim.

// ---------------------------------------------------------------------------- //
//                                                                              //
// Copyright (C) 2007, G&C Consultoria e Informática Ltda. All rights reserved. //
//                                                                              //
// This software is the confidential and proprietary product of G&C Consultoria //
// e Informática Ltda, Any unauthorized use, reproduction, or transfer of  this //
// software is strictly prohibited.                                             //
//                                                                              //
// ---------------------------------------------------------------------------- //

package br.com.gec.jep;

import java.util.Stack;

import br.com.gec.parser.AbstractJepSerieFunction;
import br.com.gec.parser.FormulaParseException;
import br.com.gec.parser.ISerie;
import br.com.gec.parser.ISerieReader;

/**
 * <p >
 * Classe de apoio para tradução/avaliação de fórmulas do jep.</p>
 * 
 * contaValor( idContaValor, defasagem )
 * curvaHistorica( idCurvaHistorica, defasagem )
 * 
 * <p >
 * Essa classe deve ser "carregada" em meio à inicialização do parser para que o mesmo
 * considere a função "contaValor" e "curvaHistorica" em suas expressões.</p>
 * 
 * @author  Anaximandro de Godinho.
 * @version $Revision: 1.24 $
 */
public class JepContaValor extends AbstractJepSerieFunction
{
   /**
    * O nome da função, operando como conta valor.
    */
   public static final String P_CONTAVALOR     = I18n.P_contaValor;

   /**
    * O nome da função, operando como curva histórica.
    */
   public static final String P_CURVAHISTORICA = I18n.P_curvaHistorica;

   /**
    * Construtor.
    * 
    * @param reader o reader de séries.
    */
   public JepContaValor( final ISerieReader reader )
   {
      this( reader, P_CONTAVALOR );
   }

   /**
    * Construtor.
    * 
    * @param reader o reader de séries.
    */
   public JepContaValor( final ISerieReader reader, final String internalName )
   {
      super( internalName, reader, 2 );
   }

   /** @see br.com.gec.parser.IJepFunction#run
    */
   public void run( final Stack stack ) throws FormulaParseException
   {
      checkStack( stack );

      // Lê o segunto parâmetro.
      final int defasagem = getIntegerValue( stack, I18n.P_PAR_contaValor_d );

      // Lê o primeiro parâmentro.
      final String idConta = getString( stack, I18n.P_PAR_contaValor_id );

      /* Lê o valor da defasagem inicial em dI,
       * Calcula a defasagem dessa função/iteração em dF,
       * Calcula o tempo dessa função/iteração em tF.
       */
      final int dI = _parse.getVarD();
      final int dF = dI + defasagem;
      final int tF = _parse.getVarT() - dF;

      // Obtêm o valor do tF calculado correspondente.
      final Double valor = getValue( idConta, tF );

      // Empilha o resultado.
      stack.push( valor );

      _logger.debug( //
         _functionName + "[" + idConta + //
            "], dI[" + dI + //
            "], dF[" + dF + //
            "], tF[" + tF + //
            "], v[" + valor + //
            "]." //
         );
   }

   /** @see br.com.gec.parser.IJepSerieFunction#getValue(String, int)
    */
   public Double getValue( final String idSerie, final int t ) throws FormulaParseException
   {
      // Obtêm a série correspondente ao id fornecido.
      ISerie serie = _map.getSerie( idSerie );
      if( serie == null )
      {
         serie = _reader.readSerie( idSerie );
         if( serie == null )
         {
            throw new FormulaParseException( _functionName + I18n.P_ERR_CV_NOTFOUND, idSerie );
         }
         else
         {
            _map.addSerie( idSerie, serie );
         }
      }

      // Retorna o valor do vértice da serie temporal.
      return new Double( serie.getValue( t ) );
   }
}