Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > fr.comp.lang.java > #1835

Re: Programme spreadsheet Java

Show all headers | View raw

Bonjour

> - Concernant la mise en place d’une méthode return gridArray[i][j] au
> lieu de la méthode traverse dans la classe Grid effectivement cela
> simplifierait. Est ce qu’il faut aussi que je mette gridArray[i][j] en
> tant qu’attribut de la classe Grid car je ne pense pas que ce soit le
> cas ?

Si : il te faut créer un attribut de type Node[][] dans la classe et le 
remplir dans le constructeur. Sinon tu ne pourras pas y accéder dans les 
autres méthodes. C'est en remplacement de l'attribut head, un moyen plus 
simple d'accéder aux cellules.

Et une méthode qui aurait par exemple cette signature :
    public Node cellule (int ligne, int colonne)
et qui se contenterait d'aller voir dans le tableau ; à la place de 
traverse.


> Pour la fusion de Node et Value,
> je pourrais mettre les attributs de Value (dval, sval, tag) dans Node
> afin d’utiliser uniquement Node. Effectivement pour l’import du fichier,
> je pourrais remplir la liste gridArray avec les Node/ Value directement
> dans la fonction loadFile lorsque je parcours la liste. Est ce que ces
> points te semblent corrects ?

Oui. Il te faudra sans doute un autre constructeur pour Grid, qui prend 
en paramètre un le tableau de type Node[][] au lieu d'en créer un lui-
même comme dans ton constructeur actuel. Les deux constructeurs peuvent 
cohabiter. Ou bien tu remplis les cases d'une grille existante, au choix.


> - J’ai implémenté le code avec les expressions rationnelles pour
> détecter les références, opérandes et les opérations à faire dans une
> cellule et réaliser les calculs. Je sais que ça ne doit pas être très
> optimisé ou lisible mais ça m’a l’air de fonctionner. Peut être faire
> une boucle et une fonction pour éviter de répéter à chaque fois Pattern,
> Matcher ?

Tu pourrais effectivement avoir une fonction pour éviter de répéter le 
code de test de l'expression rationnelle, par contre je ne pense pas 
qu'une boucle t'aide tellement.

Une note sur les performances : ce n'est pas important pour ton projet, 
mais Pattern.compile ça peut coûter quelque chose. Donc dans un vrai 
projet tu préféreras peut-être stocker le résultat quelque part une fois 
au chargement de la classe, avant toutes tes fonctions :
    private static Pattern ... = Pattern.compile (...) ;
Avec des noms précis, pour éviter d'exécuter ce traitement à chaque appel 
de la fonction.


> - Pour réaliser le cycle grâce aux fonctions récursives : remonter les
> cellules pour vérifier qu’il n’y a aucun cycle d’aucune longueur, je ne
> suis pas encore très à l’aise avec les fonctions récursives, est ce que
> tu aurais une idée de comment faire s’il te plait ?
> f([c]) {
>    f([c])
> }

En y repensant, je pense qu'on peut faire sans récursion. Tu vas avoir 
besoin des classes de type Set (des ensembles de données, sans ordre 
particulier et sans doublons en général). Tu peux par exemple utiliser 
HashSet.

Tu as besoin de remonter les cellules dépendant de la cellule, et ainsi 
de suite, en notant toutes celles qui sont passées et en vérifiant que tu 
ne retombes jamais sur celle de départ.

Ça devrait marcher approximativement comme ça :
    - Tu initialises l'ensemble des cellules déjà passées, il est vide.
    - Tu initialises l'ensemble des cellules à traiter en plaçant dedans
      la cellule de départ.
    - Tu commences une boucle qui se termine quand il n'y a plus aucun
      élément dans l'ensemble de cellules à traiter.
    - Dans la boucle, tu prend un élément de l'ensemble des cellules à
      traiter (par exemple avec ensemble.iterator().next(), sans
      parcourir toutes les valeurs de l'ensemble à la suite : tu te
      contentes d'en piocher un).
        - Si cette cellule se trouve dans les cellules déjà passées, tu
          l'ignores.
        - Sinon tu considères les cellules qui dépendent de celle que tu
          viens de piocher, si l'une d'elle est ta cellule de départ
          c'est qu'il y a un cycle, tu peux arrêter tout le processus.
          Sinon tu places ces cellules dans les cellules à traiter.
    - Si à un moment il n'y a plus de cellules dans l'ensemble de celles
      à traiter, c'est qu'il n'y a pas de cycle.

L'idée est de remonter les cellules en vérifiant qu'on ne retombe jamais 
sur celle de départ.

C'est une forme d'algorithme assez classique, ça te resservira sans doute.

Dans ton cas il est même possible de le simplifier un peu : en 
considérant qu'il n'y a pas de cycle dans le reste des cellules 
(puisqu'on vérifie au fur et à mesure), on pourrait se dispenser de noter 
les cellules déjà passées. Un cas conduirait à examiner plus de 
cellules : celui où une cellule est, directement ou indirectement, dans 
les dépendances de deux cellules : si C0 dépend de C1 et C2, C1 et C2 
dépendent chacune de C3 et que C3 dépend de C4, on examinerait deux fois 
le cas de C3 et C4. Ce n'est pas forcément très grave dans ton cas, donc 
tu peux te dispenser de l'ensemble de cellules déjà examinées si tu veux.

Yliur

Back to fr.comp.lang.java | Previous | Next — Previous in thread | Find similar

Thread

Programme spreadsheet Java henryd <nospam_henry.dossot@gmail.com.invalid> - 2021-06-14 04:26 -0500
  Re: Programme spreadsheet Java Yliur <yliur@free.fr> - 2021-06-15 09:49 +0000
    Re: Programme spreadsheet Java henryd <nospam_henry.dossot@gmail.com.invalid> - 2021-06-15 13:25 -0500
      Re: Programme spreadsheet Java Yliur <yliur@free.fr> - 2021-06-15 20:55 +0000
        Re: Programme spreadsheet Java henryd <nospam_henry.dossot@gmail.com.invalid> - 2021-06-17 01:33 -0500
          Re: Programme spreadsheet Java Yliur <yliur@free.fr> - 2021-06-17 08:35 +0000

csiph-web