Discussion :

[piklas]

Bonjour à tous

Débutant en java, je cherche à programmer un système d'entreés sorties via une interface swing, qui est destiné ensuite à gerer les E/S d' une appli externe basée sur le Jini (appel d'une routine fortran )

Pour l'instant je parviens à lire un fichier .in, à executer une fonction gausienne simple et à ecrire le resultat dans un fichier.out. Ce que je voudrais pouvoir faire, c'est simplement changer le contenu de mon .in ( ecraser ce qui existe deja dedans) dynamiquement en fonction du choix de l'utilisateur ( par des zones de texte), pour que ce dernier puisse spécifier la valeur de la variable de la gaussienne.

structure de mon fichier.in:
1. 1. 1. 1.
1. 1. 1. 1.
1. 1. 1. 1.
1. 1. 1. 1.

(par exemple, si l'utilisateur ecrit 2 dans une zone de texte, comment puis je l'écrire dans mon .in ?)

Le code java:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
 
import java.io.*;
//import java.util.*;
 
    public class Lectx5{
        public static void main(String[] args){
            String fichier ="fichier.in";
            String fichierS = "fichier.out";
            double x;double y;double z;double r;
            double sigmax=10.;double sigmay=10.;double sigmaz=10.;
            double x0=10.;double y0=10.;double z0=2.;
            String slignex;String sligney;String slignez;String sligner;
            int N = 4;int i;
            //int[] tab = new int [4];
            //tab[0]=5;tab[1]=1;tab[2]=2;tab[3]=4;
            //fichetxt = new FortranReader(new FileReader(fichetxt));
            try{//lecture
            FortranReader fichetxt = new FortranReader(new FileReader(fichier));
//            //écriture
            FileWriter fw = new FileWriter(fichierS);
            BufferedWriter bw = new BufferedWriter (fw);
            PrintWriter fichierSortie = new PrintWriter (bw);
            // fichierSortie.println ("\n test de lecture et écriture !!");
            //            while((ligne = fichetxt.stringField()) != null){
            //fichetxt.readFields();
            for(i = 0; i < N; i++){
                fichetxt.readFields();
//            while((ligne = fichetxt.stringField(0)) != null){            
            slignex= fichetxt.stringField(0);
            sligney= fichetxt.stringField(1);
            slignez= fichetxt.stringField(2);
            sligner= fichetxt.stringField(3);
            x = Double.parseDouble(slignex);//passage string -> réel
            y = Double.parseDouble(sligney);
            z = Double.parseDouble(slignez);
            r = Double.parseDouble(sligner);
//            System.out.println("fin ligne-----"+ i);
//            _____________________________________
//            Calcul
            r=(1./(2.*Math.PI))*Math.exp(
                    -(Math.pow(x-x0,2)/(2.*Math.pow(sigmax,2))
                    +Math.pow(y-y0,2)/(2.*Math.pow(sigmaz,2))+
                    Math.pow(z-z0,2)/(2.*Math.pow(sigmay,2)))
                            );
//            _____________________________________
            //création ou ajout dans le fichier texte
            //fichierSortie.println(x);//System.out.println(x);
            //fichierSortie.println(y);//System.out.println(y);
            //fichierSortie.println(z);//System.out.println(z);
            //fichierSortie.println(r);//System.out.println(r);
            //fichetxt.readFields();
            slignex = Double.toString(x);
            sligney = Double.toString(y);
            slignez = Double.toString(z);
            sligner = Double.toString(r);
            StringBuffer sb = new StringBuffer(40); // 40 = une estimation de la taille maximale de notre chaîne.
             sb.append(slignex);sb.append(" ");
             sb.append(sligney);sb.append(" ");
             sb.append(slignez);sb.append(" ");
             sb.append(sligner);sb.append(" ");
            fichierSortie.println(sb.toString()); //
            }//Lecture ligne par ligne WHILE
            fichetxt.close(); //cloture fichier
            fichierSortie.close(); //cloture fichier sorties
            //Gestion des pb
            }// FIN lecture
            catch(IOException err){
                System.out.println("Erreur: " +err);            
            }
            catch (Exception e){
                System.out.println(e.toString());
            }
//            _____________________________________
//            Calcul
//            _____________________________________
            //
            System.out.println("fichier de résultat crée");
        } // Fin main
    }// Fin Lectx5{

D'avance merci pour vos réponse et @+

Piklas

[bouye]

Note : si j'ai bien compris il s'agit de JNI ; Jini etant une toute autre technologie Java.

Le FORTRAN est-il compile ? Si ce n'est pas le cas, une maniere consiste a faire de ton fichier de code source FORTRAN un template dans lequel certains champs sont remplaces par des tokens (voir la doc de MessageFormat), de modifier ces tokens avec les valeurs appropriees une fois qu'elles ont ete saisies par l'utilisateur et ensuite de sauvegarder le code FORTRAN ainsi genere dans un nouveau fichier (temporaire?) que tu executeras.

Si le language est compile, idem mais il faut lancer le compilateur (et donc que celui-ci soit present sur le syteme ou tourne l'application) via System.exec ou via JNI.