Programme spreadsheet Java

J’ai créé différentes classes : Programme (celle qui exécute le
programme), Grid (représente le tableur), Node (la cellule), Value (la
valeur d’une cellule),

J’ai actuellement plusieurs points bloquants :
- Le programme n’accepte pas que l’utilisateur rentre du texte, exemple
des références de cellules, ex : (1,1) et des formules du type
Moy((1,1), (2,3)).
Pour le moment, mon programme n’accepte que des valeur numérique pour le
moment, c’est surement du Í  ma gestion de l’erreur mais je n’arrive pas
Í  trouver comment le résoudre et qu’il accepte du texte :
catch(NumberFormatException e){
System.out.println("e;e;Error: Not a number"e;e;);
}

- Écrire le code pour importer les valeurs d’un fichier dans le tableur.
La méthode loadFile permet d’importer un fichier table.txt dont Chaque
valeur de cellule est séparée par un & et chaque ligne du fichier
correspond Í  une ligne du tableur. Je pense que je vais parser le
fichier ligne par ligne, faire un slip sur le caractère & et enregistrer
les valeurs dans un array list. Puis insérer ces valeurs dans les
cellules du tableur Í  la ligne correspondante. Je pense créer une
méthode assignCells( array list) dans la classe Grid afin de réaliser
ces opérations, est ce que cela vous semble correcte ?

- Calculer le résultat des formules dans les cellules. Exemple, si la
valeur de la cellule (2,2) est (1,1) + 2, il faut calculer le résultat
en remplaçant (1,1) avec sa valeur numérique. Idem pour les autres
opérations arithmétiques : +, -,
*, /, Somme, Moy. Pour le déclenchement des opérations, je pense faire
une loop dans la classe Program qui va parcourir toutes les cellules du
tableur et pour chaque cellule, parser le contenu et détecter s’il y a
s’agit d’un opération avec un opérateur (+, -, *, /, Somme, Moy) et si
c’est le cas, réaliser le calcul. Pour le calcul, je pense créer les
méthodes add, substract, multiply, divide, Sum, Mean dans la classe
Grid. Est ce que cela vous semble judicieux ?

- Représentation graphique de la table. Comment connecter le tableur
avec l’interface graphique UseCalcGUI et CalcGUI afin d’afficher les
valeurs dans le layout de la fenêtre. Je ne suis pas encore très Í 
l’aise avec JFrame et donc j’ai un peu de mal Í  comprendre comment avoir
accès aux parties du Layout. Est ce que vous auriez des idées ?

Le Mon, 14 Jun 2021 04:26:15 -0500, henryd a écrit :
Bonjour
Pour commencer, je dirais que ce projet est sensiblement plus complexe
que le précédent, d'un point de vue algorithmique,
modélisation ou
utilisation de bibliothèques (swing, pour l'interface graphique). Mieux
vaut sans doute être Í  l'aise avec le
précédent avant de se lancer dedans.
Es-tu plutÍ´t débutant en programmation ? Est-ce un projet
qu'on t'a donné
ou bien un projet que tu as choisi de réaliser pour apprendre ?

J’ai créé différentes classes : Programme (celle
qui exécute le
programme), Grid (représente le tableur), Node (la cellule), Value (la
valeur d’une cellule),

Pourquoi ne stockes-tu pas le tableau gridArray dans un attribut de Grid,
au lieu de construire une structure complexe permettant de lier les
cellules les unes aux autres ? Il est plus simple d'accéder aux cellules
par leurs coordonnées.

J’ai actuellement plusieurs points bloquants :
- Le programme n’accepte pas que l’utilisateur rentre du texte,
exemple
des références de cellules, ex : (1,1) et des formules du type
Moy((1,1), (2,3)).
Pour le moment, mon programme n’accepte que des valeur numérique
pour le
moment, c’est surement du Í  ma gestion de l’erreur
mais je n’arrive pas
Í  trouver comment le résoudre et qu’il accepte du
texte :
catch(NumberFormatException e){
System.out.println("e;e;Error: Not a number"e;e;);
}

Comme je l'ai indiqué dans mon message dans l'autre fil de discussion,
laisse courir les exceptions : ne les capture pas comme ça. Le mieux est
de les laisser planter le programme, tu obtiendras une pile d'appels qui
t'indiquera (et nous indiquera, si tu ne sais pas quoi en faire) Í 
quel
endroit précis le programme a planté.

- Écrire le code pour importer les valeurs d’un fichier dans le
tableur.
La méthode loadFile permet d’importer un fichier table.txt dont
Chaque
valeur de cellule est séparée par un & et chaque ligne du
fichier
correspond Í  une ligne du tableur. Je pense que je vais parser le
fichier ligne par ligne, faire un slip sur le caractère & et
enregistrer
les valeurs dans un array list. Puis insérer ces valeurs dans les
cellules du tableur Í  la ligne correspondante. Je pense
créer une
méthode assignCells( array list) dans la classe Grid afin de
réaliser
ces opérations, est ce que cela vous semble correcte ?

Suivant comment ton code est agencé, tu n'as pas forcément besoin
du
tableau (ArrayList) intermédiaire. Sinon oui, ça me
paraͮt correct.

- Calculer le résultat des formules dans les cellules. Exemple, si la
valeur de la cellule (2,2) est (1,1) + 2, il faut calculer le résultat
en remplaçant (1,1) avec sa valeur numérique. Idem pour les
autres
opérations arithmétiques : +, -,
*, /, Somme, Moy. Pour le déclenchement des opérations, je pense
faire
une loop dans la classe Program qui va parcourir toutes les cellules du
tableur et pour chaque cellule, parser le contenu et détecter
s’il y a
s’agit d’un opération avec un opérateur (+, -, *, /,
Somme, Moy) et si
c’est le cas, réaliser le calcul. Pour le calcul, je pense
créer les
méthodes add, substract, multiply, divide, Sum, Mean dans la classe
Grid. Est ce que cela vous semble judicieux ?

Non, a priori.
Mais surtout : si tu débutes en programmation, l'analyse syntaxique des
formules, l'exécution de formules et la modélisation des liens
entre
cellules pour détecter les cycles et les mises Í  jour
Í  réaliser, ça me
paraͮt un peu tendu : il y a pas mal de travail d'algorithmique et
de
modélisation. Et dans tous les cas c'est Í  réaliser
(l'analyse syntaxique
et la modélisation des formules au moins) avant de se demander comment
les calculer. Tu n'as jamais eu aucun cours sur ces sujets ?

- Représentation graphique de la table. Comment connecter le tableur
avec l’interface graphique UseCalcGUI et CalcGUI afin d’afficher
les
valeurs dans le layout de la fenêtre. Je ne suis pas encore très
Í 
l’aise avec JFrame et donc j’ai un peu de mal Í 
comprendre comment avoir
accès aux parties du Layout. Est ce que vous auriez des idées ?

Tu devrais avoir un tableau Í  deux dimensions représentant
les valeurs de
la grille, et tu as un tableau Í  deux dimensions dans ta
fenêtre (nommé
"tft") : quand tu veux mettre Í  jour la cellule (2,1),
tu attrapes le
champ de saisie correspondant dans tft et tu modifies sa valeur. Tu n'as
pas besoin d'accéder aux autres éléments de la
fenêtre pour cette mise Í 
jour.
Yliur

Pour répondre aux différents points dans ton message précédent :
- Pour le tableau gridArray en tant qu’attribut de Grid tu as raison ça
m’a l’air beaucoup plus simple. J’étais partie sur une classe Node afin
de pratiquer les classes mais bon pas forcément judicieux. Je vais
essayer de voir pour faire une modification.

- Pour l’importation du fichier dans le tableur, j’ai parsé le contenu
du fichier et importé les différentes valeurs dans un ArrayList puis je
l’ai envoyé Í  la méthode importFile afin de les transférer dans l’objet
Node. Effectivement, comme tu l’as suggéré, peut-être qu’on pourrait
juste enregistrer cet ArrayList comme attribut de la classe Grid et
aussi remplacer les valeurs de l’ArrayList par l’objet Valeur ayant les
attributs : tag, dval, sval utiles par la suite ?

- Pour l’analyse syntaxique des formules dans les cellules, je pensais
faire une Regex Pattern.compile("+", Pattern.CASE_INSENSITIVE); afin
de détecter les opérations Í  faire dans les cellules. Une fois
l’opération détectée, faire le calcul et stocker le résultat dans
l’attribut dval de la classe Value. Est ce que ça te semble une bonne
solution ?

- Concernant la modélisation des liens entre les cellules, pour gérer
les dépendances, d’après ce qui était conseillé dans le projet, il
faudrait créer en attribut de chaque cellule (ou de la classe Value),
une liste avec les coordonnées des cellules qui dépendent de C. Pour
détecter un cycle, il faut vérifier, Í  chaque fois que l’utilisateur
rentre une valeur, s’il y une référence déjÍ  présente dans la liste des
cellules qui dépendent de C. Si c’est le cas, ne pas autoriser Í  la
renseigner. Idem, pour la mise Í  jour automatique d’une cellule. A
chaque fois qu’une cellule est modifier, il faut mettre Í  jour les
cellules qui sont renseignées dans la liste des cellules qui dépendent
d’elle et ainsi de suite (la valeur du calcul est stockée dans
l’attribut dval de l’objet Value et la valeur texte (formule) dans
l’attribut sval ce qui permet de pouvoir recalculer la formule). Est ce
que cette algorithme te semble judicieux pour modéliser les liaisons
entre les cellules ?

- Dans le point 5 du projet, il est demandé que le programme prenne en
charge les références de cellules relatives avec le signe $. Pour
calculer, la position d'une cellule ayant une référence relative $(1,2)
dans la cellule (2,3) par exemple est la position absolue : (1,1) (1
ligne plus haute et 2 colonnes vers la gauche), est bien cela ? Car je
n’arrive pas Í  comprendre l’exemple qu’ils donnent dans l’explication.

Idem que dans l'affichage du contenu de la cellule référencée de manière
absolue, il faut afficher sa valeur dans la cellule de destination pour
pouvoir faire le calcul, je ferai donc la même technique que celle
utilisée pour les références absolues c’est Í  dire avec le tableau des
références qui dépendent de la cellules

- Je t’invite Í  me dire s’il y a d’autres points importants que je
pourrais améliorer dans mon code ou qu'il pourrait être intéressant
d'approfondir dans le projet :)

Le Tue, 15 Jun 2021 13:25:37 -0500, henryd a écrit :

Pour répondre aux différents points dans ton message
précédent :
- Pour le tableau gridArray en tant qu’attribut de Grid tu as raison
ça
m’a l’air beaucoup plus simple. J’étais partie sur
une classe Node afin
de pratiquer les classes mais bon pas forcément judicieux. Je vais
essayer de voir pour faire une modification.

Tu peux tout Í  fait garder cette classe, simplement il est plus
pratique
d'accéder aux cellules par leurs coordonnées que de suivre des
liens
entre elles. Au lieu d'une méthode traverse qui parcourt les cellules,
tu
aurais une méthode plus simple qui contiendrait
return gridArray[i][j] ;
Par contre tu pourrais peut-être fusionner Node et Value, pour
simplifier. Ce sont bien deux concepts distincts, mais pour chaque
cellule il y a une valeur et réciproquement, donc il est possible de les
fusionner si c'est plus simple.

- Pour l’importation du fichier dans le tableur, j’ai parsé
le contenu
du fichier et importé les différentes valeurs dans un ArrayList
puis je
l’ai envoyé Í  la méthode importFile afin de
les transférer dans l’objet
Node. Effectivement, comme tu l’as suggéré,
peut-être qu’on pourrait
juste enregistrer cet ArrayList comme attribut de la classe Grid et
aussi remplacer les valeurs de l’ArrayList par l’objet Valeur
ayant les
attributs : tag, dval, sval utiles par la suite ?

Je pensais plutÍ´t Í  mettre tout le code de lecture
du fichier dans
importFile et Í  remplir directement gridArray avec des objets
Node/
Value : tu fais déjÍ  les deux boucles sur les lignes et sur
les éléments
de la ligne quand tu lis le fichier, il te suffirait de remplir les cases
au fur et Í  mesure, au lieu de passer par des structures
intermédiaires.

- Pour l’analyse syntaxique des formules dans les cellules, je pensais
faire une Regex Pattern.compile("+", Pattern.CASE_INSENSITIVE);
afin
de détecter les opérations Í  faire dans les
cellules. Une fois
l’opération détectée, faire le calcul et stocker le
résultat dans
l’attribut dval de la classe Value. Est ce que ça te semble une
bonne
solution ?

En relisant la consigne, je m'aperçois que les calculs en question ne
consistent qu'en une seule opération, ça ne peut pas être
complexe. Ça
rend le projet plus abordable que ce que je pensais.
Je ne sais pas très calé en expressions rationnelles. Si tu sais
t'en
servir, c'est bien. Sinon les opérations simples de manipulation des
chaͮnes suffiront.
Il te faut effectivement détecter l'opérateur (opérateur
arithmétique ou
fonction Somme/Moy), extraire les opérandes et réaliser
l'opération
correspondante.

- Concernant la modélisation des liens entre les cellules, pour
gérer
les dépendances, d’après ce qui était
conseillé dans le projet, il
faudrait créer en attribut de chaque cellule (ou de la classe Value),
une liste avec les coordonnées des cellules qui dépendent de C.
Pour
détecter un cycle, il faut vérifier, Í  chaque fois
que l’utilisateur
rentre une valeur, s’il y une référence
déjÍ  présente dans la liste des
cellules qui dépendent de C. Si c’est le cas, ne pas autoriser
Í  la
renseigner. Idem, pour la mise Í  jour automatique d’une
cellule. A
chaque fois qu’une cellule est modifier, il faut mettre Í 
jour les
cellules qui sont renseignées dans la liste des cellules qui
dépendent
d’elle et ainsi de suite (la valeur du calcul est stockée dans
l’attribut dval de l’objet Value et la valeur texte (formule) dans
l’attribut sval ce qui permet de pouvoir recalculer la formule). Est ce
que cette algorithme te semble judicieux pour modéliser les liaisons
entre les cellules ?

Vois-tu comment fonctionne la récursion ? Parce que le cycle peut
impliquer un paquet de cellules, il faut remonter les cellules pour
vérifier qu'il n'y a aucun cycle d'aucune longueur. Sais-tu comment
faire
ça ?

- Dans le point 5 du projet, il est demandé que le programme prenne en
charge les références de cellules relatives avec le signe $.
Pour
calculer, la position d'une cellule ayant une référence relative
$(1,2)
dans la cellule (2,3) par exemple est la position absolue : (1,1) (1
ligne plus haute et 2 colonnes vers la gauche), est bien cela ? Car je
n’arrive pas Í  comprendre l’exemple qu’ils
donnent dans l’explication.

C'est ce que je comprends. C'est bizarre de compter comme ça par contre,
j'aurais plutÍ´t considéré les valeurs positives de
décalage vers le bas
et la droite.

Idem que dans l'affichage du contenu de la cellule
référencée de manière
absolue, il faut afficher sa valeur dans la cellule de destination pour
pouvoir faire le calcul, je ferai donc la même technique que celle
utilisée pour les références absolues c’est
Í  dire avec le tableau des
références qui dépendent de la cellules

Oui.

- Je t’invite Í  me dire s’il y a d’autres
points importants que je
pourrais améliorer dans mon code ou qu'il pourrait être
intéressant
d'approfondir dans le projet :)

Ça me paraÍ®t déjÍ  beaucoup de travail...
:)
Il reste pas mal d'endroits o͹ tu ne laisses pas filer les
exceptions,
c'est dommage en cas de bug.
Note que si tu laisses filer les exceptions le try/catch ou try-finally
n'est pas nécessaire (sauf dans le cas o͹ tu utilises la
try pour gérer
automatiquement la fermeture de flux, comme InputStream).

- 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 ?

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 ?

- 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 ?

- 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])
}