Visualizzazione dei risultati da 1 a 10 su 10
  1. #1

    [java]non ditemi che è impossibile

    Il problema è piuttosto complicato,o forse piuttosto lungo da risolvere:

    Devo scrivere un programma con il quale l'utente inserisce una funzione matematica,quindi puo presentare radici,logaritmi,esponenziali,ecc.
    Il programma deve riuscire ad analizzare questa funzione,e per ogni valore di x,sia esso inserito dall'utente,sia esso generato dal programma,deve calcolarmi il valore corrispondente delle y.

    Il mio problema è:come faccio ad analizzare la funzione,cioè a capire quando c'è una radice,un logaritmo,ecc?
    Inoltre come fa l'utente a inserire questi simboli?
    dovrei crearmi un'applet con vari pulsanti e ad ogni pulsante far corrispondere una funzione Math?


    Sto impazzendo, ,una mano perfavore



  2. #2
    ho provato a fare qualcosa con lo switch,ma riscontro ancora problemi.


  3. #3
    non so se può esserti utile:
    http://utenti.lycos.it/cool01/JMP.html

    Cmq quello che devi fare nn è per niente semplice, devi implementare un parser di espressioni.
    Non ho la + pallida idea di come si faccia ma cmq non si fa con lo switch!!!
    Credo che tu debba costruirti 1 albero dove ogni foglia è 1 pezzo di espressione e da lì partire a fare l'analisi!!!
    tipo:
    y = 4 + x * 2
    che diventa:

    (4,+,*)----> "+" è padre(e radice), "4" è figlio sx, "*" è figlio dx
    (x,*,2)----> "*" è padre (ma figlio dx di "+"), "x" è figlio sx, "2" è figlio dx
    e parti con l'analisi dalle foglie + basse (quindi "x" e "2" che hanno come padre "*").
    Penso si faccio così...

    Vai e divertiti va...

  4. #4
    come presumevo,un vero macello.

    vedrò cosa si può fare.


    grazie 1000

    ciao

  5. #5
    Il consiglio che ti posso dare è studiati materiale su: linguaggi e sistemi formali, automi a stati finiti, linguaggi e traduttori e roba simile.
    se ti fai un giro sui siti delle facolta di ingegneria informatica delle università italiane puoi trovare parecchio materiale.
    ciao

  6. #6
    oggi ho chiesto al mio prof di informatica,e mi ha detto all'incirca le tue stesse cose.
    Dice che si tratta di algoritmi specifici trattati all'università,e dietro c'è paraecchio da studiare.
    Ha parlato pure lui di automi e cose del genere,comunque Lunedì dovrebbe portarmi un libro per vedere come funziona.

    Grazie ancora per i consigli.


  7. #7
    Comincia da qui:
    http://www.dis.uniroma1.it/~lsf/
    vai su materiale didattico e scaricati le dispense.
    Premetto che non ci capirai assolutamente nulla!

  8. #8
    Originariamente inviato da V1RuZ
    Comincia da qui:
    http://www.dis.uniroma1.it/~lsf/
    vai su materiale didattico e scaricati le dispense.
    Premetto che non ci capirai assolutamente nulla!

    grazie per l'incoraggiamento

  9. #9
    questa è una classe che ho scritto tempo fa per analizzare espressioni aritmetiche con i quattro operatori +-*/ e una serie di costanti (cioè stringhe a cui è associato un valore) predefinite.
    Sicuramente un esperto nel campo sorriderebbe a tutte le ingenuità che ho scritto, ma per quello che mi serviva ha sempre funzionato
    Forse ti può essere utile...

    codice:
    /*
     *   Copyright (C) 2003  Lorenzo Blanco
     *
     *   Require JDK 1.3
     *
     *   This program is free software; you can redistribute it and/or modify
     *   it under the terms of the GNU General Public License as published by
     *   the Free Software Foundation; either version 2 of the License, or
     *   (at your option) any later version.
     *
     *   This program is distributed in the hope that it will be useful,
     *   but WITHOUT ANY WARRANTY; without even the implied warranty of
     *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     *   GNU General Public License for more details.
     *
     *   You should have received a copy of the GNU General Public License
     *   along with this program; if not, write to the Free Software
     *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
     *
     *
     *   Send questions or suggestions to webmaster@lorenzoblanco.it
     *
     */
    
    import java.util.*;
    
    /**
     * La classe AnalizzatoreEspressioni permette di calcolare delle
     * espressioni aritmetiche.
     *
     * @version 1.0
     * @author Lorenzo Blanco
     */
    public class AnalizzatoreEspressioni {
        public static double risultEspressione(String espressione) throws EsprException {
            return risultEspressione(espressione,null);
        }
    
        public static double risultEspressione(String espressione, HashMap mappaCostanti) throws EsprException {
    
    //        if (mappaCostanti != null) {
    //
    //            // stampa gli indirizzi IVN con gli indirizzi delle routine di servizio
    //            Set set = mappaCostanti.entrySet();
    //
    //            Iterator i = set.iterator();
    //
    //            while (i.hasNext()) {
    //                Map.Entry la = (Map.Entry) i.next();
    //                System.out.println(la.getKey() + ": " + la.getValue());
    //            }
    //        }
    
            if (!veificaParentesi(espressione)) {
                throw new EsprException("Errore nelle parentesi");
            }
    
            // ad ogni coppia parentesi aperta/chiusa sostituisce il valore
            String daAnalizzare = espressione;
            int indiceAperta = daAnalizzare.indexOf('(');
            int indiceChiusa = daAnalizzare.indexOf(')');
            int indiceUCPDUA = ultimaChiusaPrimaDiUnaAperta(daAnalizzare);
            while (indiceAperta != -1) {
    
                daAnalizzare = daAnalizzare.substring(0,indiceUCPDUA) +
                               String.valueOf(risultEspressioneSenzaPar(
                                                       daAnalizzare.substring(indiceUCPDUA+1,indiceChiusa),
                                                       mappaCostanti)) +
                               daAnalizzare.substring(indiceChiusa+1);
    
                indiceAperta = daAnalizzare.indexOf('(');
                indiceChiusa = daAnalizzare.indexOf(')');
                indiceUCPDUA = ultimaChiusaPrimaDiUnaAperta(daAnalizzare);
    
    //            System.out.println(daAnalizzare);
    
            }
    
            return risultEspressioneSenzaPar(daAnalizzare, mappaCostanti);
        }
    
        private static int ultimaChiusaPrimaDiUnaAperta(String dove) {
            int indiceCercato = -1;
            boolean trovata = false;
            boolean trovataTemp;
            for (int i = 0; !trovata && i < dove.length(); i++) {
    
                // se trova una '(' verifica che prima della prossima ')' non ci siano '('
                if (dove.charAt(i) == '(') {
                    trovataTemp = true;
    
                    for (int j = i+1; trovataTemp && j < dove.indexOf(')'); j++) {
                        if (dove.charAt(j) == '(') {
                            trovataTemp = false;
                        }
    
                    }
    
                    if (trovataTemp) {
                        indiceCercato = i;
                        trovata = true;
                    }
                }
            }
            return indiceCercato;
        }
    
        // metodo che verifica che ci siano un numero uguale di parentesi chiuse e aperte
        private static boolean veificaParentesi(String dove) {
            int daChiudere = 0;;
    
            for (int i = 0; i < dove.length(); i++) {
                if (dove.charAt(i) == '(') {
                    daChiudere++;
                } else if (dove.charAt(i) == ')') {
                    daChiudere--;
                }
    
                if (daChiudere < 0) {
                    return false;
                }
            }
    
            if (daChiudere == 0) {
                return true;
            } else {
                return false;
            }
    
        }
    
        private static double risultEspressioneSenzaPar(String espressione, HashMap mappaCostanti) throws EsprException {
    
    //        System.out.println("\t"+espressione);
    
            if (espressione.length() < 1) {
                throw new EsprException("L'espressione è vuota");
            }
    
            // uso del '-' come cambio di segno
            if (espressione.startsWith("-")) {
                espressione = "0"+espressione;
            }
    
            int primoOperando, secondoOperando;
            int indicePrimoPiuOMeno = trovaPrimoPiuOMeno(espressione);
            int indicePrimoDiviso = trovaPrimoDiviso(espressione);
            int indicePrimoPer = trovaPrimoPer(espressione);
    
    
            // se non ci sono '+' o '-'
            if (indicePrimoPiuOMeno == -1) {
    
                // se non ci sono '*'
                if (indicePrimoPer == -1) {
    
                    // se non ci sono '/'
                    if (indicePrimoDiviso == -1) {
    
                        // è un numero puro, quindi lo restituisce
                        try {
                            // se non è disponibile la mappa delle costanti
                            if (mappaCostanti == null) {
                                return new Double(espressione).doubleValue();
                            } else {
                                if (mappaCostanti.containsKey(espressione)) {
                                    Comando c = (Comando) mappaCostanti.get(espressione);
    
                                    // se è una EQU
                                    if (c.direttiva == 4) {
                                        return  (double) ((Long) c.argDirett.get(1)).longValue();
                                    // altrimenti è una D*
                                    } else {
                                        return  (double) ((Long) c.argDirett.get(2)).longValue();
                                    }
                                } else {
                                    return new Double(espressione).doubleValue();
                                }
                            }
    
    
    
                        } catch (NumberFormatException nfe) {
                            throw new EsprException("La costante "+espressione+" non è valida");
                        }
    
                    // ci sono '/'
                    } else {
    
                        return risultEspressioneSenzaPar(espressione.substring(0,indicePrimoDiviso), mappaCostanti) /
                               risultEspressioneSenzaPar(espressione.substring(indicePrimoDiviso+1), mappaCostanti);
                    }
    
                // ci sono '*'
                } else {
                    return risultEspressioneSenzaPar(espressione.substring(0,indicePrimoPer), mappaCostanti) *
                           risultEspressioneSenzaPar(espressione.substring(indicePrimoPer+1), mappaCostanti);
                }
    
            // c'è almeno un '+' o un '-'
            } else {
                double risultato = risultEspressioneSenzaPar(
                                            espressione.substring(0,trovaPrimoPiuOMeno(espressione)),
                                            mappaCostanti);
                String ancoraDaAnalizzare = espressione;
                int indPrimoPiuOMeno,indSecondoPiuOMeno;
    
                while (trovaPrimoPiuOMeno(ancoraDaAnalizzare) != -1) {
    
                    indPrimoPiuOMeno = trovaPrimoPiuOMeno(ancoraDaAnalizzare);
                    indSecondoPiuOMeno = trovaSecondoPiuOMeno(ancoraDaAnalizzare);
    
                    //System.out.println(ancoraDaAnalizzare + " | " + indicePiuOMeno);
                    if (ancoraDaAnalizzare.charAt(indPrimoPiuOMeno) == '+') {
                        risultato += risultEspressioneSenzaPar(
                                        ancoraDaAnalizzare.substring(indPrimoPiuOMeno+1,indSecondoPiuOMeno),
                                        mappaCostanti);
                    } else if (ancoraDaAnalizzare.charAt(indPrimoPiuOMeno) == '-') {
                        risultato -= risultEspressioneSenzaPar(
                                        ancoraDaAnalizzare.substring(indPrimoPiuOMeno+1,indSecondoPiuOMeno),
                                        mappaCostanti);
                    } else {
                        System.out.println("Questo non dovrebbe essere visualizzato (1)");
                    }
                    ancoraDaAnalizzare = ancoraDaAnalizzare.substring(indPrimoPiuOMeno+1);
    //                System.out.println("\t\tris.int.: "+risultato);
    
                }
    
                return risultato;
            }
        }
    
        private static int trovaPrimoPiuOMeno(String dove) {
            for (int i = 0; i < dove.length(); i++) {
                if (dove.charAt(i) == '+' || dove.charAt(i) == '-') {
                    return i;
                }
            }
    
            return -1;
        }
    
        private static int trovaSecondoPiuOMeno(String dove) {
            boolean trovatoPrimo = false;
            for (int i = 0; i < dove.length(); i++) {
                if (dove.charAt(i) == '+' || dove.charAt(i) == '-') {
                    if (!trovatoPrimo) {
                        trovatoPrimo = true;
                    } else {
                        return i;
                    }
                }
            }
    
            return dove.length();
        }
    
        private static int trovaPrimoDiviso(String dove) {
            for (int i = 0; i < dove.length(); i++) {
                if (dove.charAt(i) == '/') {
                    return i;
                }
            }
    
            return -1;
        }
    
        private static int trovaPrimoPer(String dove) {
            for (int i = 0; i < dove.length(); i++) {
                if (dove.charAt(i) == '*') {
                    return i;
                }
            }
    
            return -1;
        }
    
        public static void main(String[] args) {
            String test = "60/3*2+3+66/2*2";
            test = "(2+30*2/3)*3+((3+2)*3+300/(90+2*7))/2";
            // righe di codice del JPD132 al 28/4/2003
            test = "294+151+51+349+63+2965+391+203+69+138+35+1087+900+151+2604+42+316";
    
            try {
                System.out.println(risultEspressione(test));
            } catch (EsprException ee) {
                System.out.println(ee);
            }
    //        System.out.println(veificaParentesi("( () () ( () () ) )"));
    //        System.out.println(ultimaChiusaPrimaDiUnaAperta("( () () ( () () ) )"));
    
        }
    }
    SO: Debian Sarge kernel 2.6.11
    Lang: Java, C++, C

  10. #10
    ho appena letto la tua risposta,vedrò di analizzarla per capire come funziona il meccanismo e poterne creare uno mio.

    Grazie a tutti

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.