Pour papydall

Bonjour ! Je te signale que je me suis permis de visiter ton Webdav sur lequel j'ai copié quelques uns de tes bons programmes de trigonométrie avec un motif bien évident: mon intérêt pour les figures et effets obtenus en Panoramic. J'espère que tu ne m'en tiendras pas rigueur, ni ne donneras la fessée à un vilain que je suis.

D'autre part, je t'invite à regarder dans "Google images" par Internet les nombreuses et magnifiques figures géométriques en couleurs du sud-coréen: GHEE BEOM KIM. J'espère par là que tu y puiseras de quoi t'inspirer dans tes programmes.

Enfin, une dernière chose. Parmi tes programmes Basic dans Webdav, il y en a un qui a retenu toute mon attention: il s'agit de "Insectes amoureux". Eh bien, figures toi que j'ai fait un autre en GFA Basic sous le nom de "Rotation Algorithm" donnant ta figure parmi plusieurs que j'ai obtenues. Pour traduire mon programme en Panoramic, je me heurte à une difficulté d'interprétation en ce qui concerne les instructions GFA Basic "ParamArray et Ubound". ParamArray est un Array spécial qui insère vite fait et sans read une série de données dans une table. Ubound prend en compte la donnée la plus élevée d'une table. Mon programme permet d'afficher 9 figures différentes à l'aide de fonctions spéciales comme "POLY, MID, ROTATE et JOIN". Voilà cher papydall et merci de me dire ce que tu penses de tout ça.

Signé: parpaiun lol!

Salut Parpaiun.

Parpaiun a écrit:: Bonjour ! Je te signale que je me suis permis de visiter ton Webdav sur lequel j'ai copié quelques uns de tes bons programmes de trigonométrie avec un motif bien évident: mon intérêt pour les figures et effets obtenus en Panoramic. J'espère que tu ne m'en tiendras pas rigueur, ni ne donneras la fessée à un vilain que je suis.

Sache que mon webdav (et aussi les webdavs des autres membres) est (sont) crée(s) pour permettre aux membres de la communauté panoramicienne d’échanger nos fichiers.
Puisqu’on indique (dans nos signatures) clairement nos paramètres d’accès à nos webdavs, tu n’as pas à demander l’autorisation pour y aller puiser ce qui te plaira.
Tout ce qui se trouve sur les webdavs et sur ce forum est libre : tu peux en faire ce que tu veux sauf mention contraire.

parpaiun a écrit:: Pour traduire mon programme en Panoramic, je me heurte à une difficulté d'interprétation en ce qui concerne les instructions GFA Basic "ParamArray et Ubound". ParamArray est un Array spécial qui insère vite fait et sans read une série de données dans une table. Ubound prend en compte la donnée la plus élevée d'une table. Mon programme permet d'afficher 9 figures différentes à l'aide de fonctions spéciales comme "POLY, MID, ROTATE et JOIN".

Tu peux poster ton essai en Panoramic (même un bout de code) et le programme initial en GFA : on pourra peut-être trouver ensemble une solution.
On avancera mieux si on est plusieurs.

A+

Merci papydall!

Pour mon info n°2 (les figures de GHEE BEOM KIM) j'aimerais savoir s'il te plaît comment tu les trouve et ce que tu comptes faire avec .

Pour mon programme, je te remercie pour ton aide mais, comme je suis un peu égoïste et jaloux en plus, je préfère traduire mon programme GFA Basic et chercher moi-même une solution de remplacement pour les deux fonctions (ParamArray et UBound) avec lesquels je suis plus proche que toi. Désolé !

Alors, ne t'en fais pas pour moi ! Bonne journée ! sunny

Parpaiun a écrit:: Pour mon info n°2 (les figures de GHEE BEOM KIM) j'aimerais savoir s'il te plaît comment tu les trouve et ce que tu comptes faire avec .

C’est très beau !
Je rêve de faire pareil.

Parpaiun a écrit:: Pour mon programme, je te remercie pour ton aide mais, comme je suis un peu égoïste et jaloux en plus, je préfère traduire mon programme GFA Basic et chercher moi-même une solution de remplacement pour les deux fonctions (ParamArray et UBound) avec lesquels je suis plus proche que toi. Désolé !

Comme tu veux. Je comprends parfaitement.

Le GFA basic c’est très très loin pour moi.

Code en GFA (mais je n'en suis pas à 100% sûr!)

Code:: Politesse("Albert")
Politesse("Sophie", "Madame")
Politesse("Chantal", "Mademoiselle")
End

Proc Politesse(nom As String, ParamArray t())
Local String titre = Iif(UBound(t) < 0, "Monsieur", t(0))
Print "Veuillez agréer, "; titre; " "; nom; ", mes salutations distinguées."
EndProc

Ça donne ceci en Panoramic

Code:: rem ============================================================================
Politesse("Albert")
Politesse("Fabian","")
Politesse("Sophie", "Madame")
Politesse("Chantal", "Mademoiselle")
end
rem ============================================================================
SUB Politesse(nom$,genre$)
   dim_local titre$
   if (genre$ = "") or (genre$ = nom$)
   titre$ = "Monsieur"
   else
   titre$ = genre$
   end_if
   print "Veuillez agréer, " + titre$ + " " + nom$ + ", mes salutations distinguées."
END_SUB
rem ============================================================================

Papydall, je suis en train de traduire mon programme "Rotation Algorithm" de GFA Basic en Panoramic. J'ai bien avancé jusqu'à me trouver devant un mur en béton
pré-contraint (mon immeuble est construit comme ça !).

Je t'éclaire un peu plus sur les suivants:
Première chose: Les fonctions PARAMARRAY et UBOUND sont définies et expliquées dans les manuels "Visual Basic".
Je crois avoir trouvé une solution de remplacement pour la fonction
PARAMARRAY c(()). C'est une fonction extensible qui fonctionne comme DIM et accepte n'importe quelle quantité de données ! Elle répartit les données à l'intérieur d'une seule table (en réalité invisible) tout comme DIM c(1,2,3,4,5,6,7,8,9). Mais comme cette forme me parait impossible à réaliser en Panoramic, alors je fais tout bonnement DIM c(9) puis
Data 1,2,3,4,5,6,7,8,9 suivi de for i=1 to 9: read c(i): next

Et voilà que surgit l'autre problème, à savoir UBOUND. Cette fonction sort une donnée référencée par son numéro d'ordre parmi toutes celles contenues dans une table unique par exemple: print UBound (c(),3) 3 étant la troisième donnée d'une série contenue dans la table.
Comme la fonction UBOUND n'a pas d'équivalent en Panoramic , alors je me rabats sur le DIM. Oui, mais voilà, j'avais dit que le DIM doit être extensible, c'est à dire que si j'ai défini DIM c(9), alors je n'ai pas trouvé comment redéfinir un DIM en Panoramic comme REDIM c(5) qui existe en GFA Basic.

Vois-tu, je m'arrache les cheveux (je ne suis pas encore chauve!) à force de chercher quelle fonction Panoramic peut bien me sortir de ce pétrin !!

Alors, j'appelle papydall au secours et j'espère recevoir à temps une bouée de sauvetage de sa part (chez moi, la mer n'est pas loin, à 5 kilomètres).
Merci au nom de tous les panoramiciens ! affraid

Pour contourner REDIM, prévoir dès le départ un tableau suffisamment grand.
Par exemple

Code:: DIM Maxi : Maxi = 99 : ' dimension maximale
DIM Mon_Tablo(Maxi) : ' un tableau de Maxi +1 éléments

Le 1er élément du tableau c’est l’élément d’indice 0 (zéro) : ça correspond à Lbound
Le dernier élément du tableau c’est l’élément d’indice la valeur de la variable Maxi (99 dans notre exemple) : ça correspond à Ubound

UBOUND : Upper Bound (borne supérieure ou borne maximale ) désigne le dernier élément d'un ensemble.
LBOUND : Lower Bound (borne inférieure ou borne minimale ) désigne le premier élément d'un ensemble.

Exemple en Panoramic

Code:: rem ============================================================================
dim i% : ' variable compteur
dim NbElement% : NbElement% = 10
dim Tableau_Entier%(NbElement%) : ' déclaration d'un tableau de NdElement + 1

' On initialise notre tableau
for i% = 0 to NbElement%
Tableau_Entier%(i%) = int(rnd(100))
next i%
' Afficher un élément quelconque du tableau, le 4ème élément par exemple
' Le 4ème élément correspond à l'indice 3 puisque les élément comment à partir de 0
print "4ème élément : ";Tableau_Entier%(3) : print
' Afficher tous les éléments du tableau
for i% = 0 to NbElement% : print Tableau_Entier%(i%); " " ; : next i% : print : print
' Simulation de UBOUND et LBOUND de GFA BASIC
' UBOUND : Upper Bound (borne supérieure ou borne maximale ) désigne le dernier élément d'un ensemble.
' LBOUND : Lower Bound (borne inférieure ou borne minimale ) désigne le premier élément d'un ensemble.
print "UBOUND : " ;Tableau_Entier%(NbElement%) : ' print UBOUND (Tableau_Entier%()
print "LBOUND : " ;Tableau_Entier%(0) : ' print LBOUND (Tableau_Entier%()
rem ============================================================================

Ici s'arrête ma science ! Embarassed

Invité

Je suis désollé, je ne suis pas Papydall, mais bon!

Dans ce cas précis, ne serait-il pas mieux de se servir d'un dlist ? Celui-ci se rempli au fur et à mesure.

On lit le premier (pour Parpaiun évidemment) avec item_read$(X,1). X étant le n° d'objet dlist, et le dernier par item_read$(X,count(x)).
On efface l'objet par clear X. De plus on peut contrôler le contenu en remplaçant le dlist par List pour la mise au point.

Si il y a problème, je sais que Papydall est près à t'aider. Je retourne à mes problèmes.

Excuses-moi Papydall, si tu as été très rapide, j'avais écorché ton pseudo (Papidall).

Tu as raison, Cosmos70 ! et UBOUND() serait COUNT() en Panoramic !

@Parpaiun
Comme Cosmos70 parlait de LIST, voici un exemple qui montre comment utiliser cet objet système.
L’exemple en lui-même n’est qu’un prétexte pour montrer aussi comment on utilise une procédure SUB et récupérer son résultat de calcul comme s’il s’agissait d’une fonction.

Code:: rem ============================================================================
rem Je compte in english
rem ============================================================================
dim w$,z$,i
height 0,600
' déclaration de 3 LIST
for i = 1 to 3
   list i : top i, 50 : left i,050+150*(i-1) : height i,450 : font_bold i
next i
' Un ALPHA pour le titre
alpha 4 : top 4, 10 : left 4, 150 : font_bold 4 : font_size 4,18
color 4,255,0,0 : font_color 4,255,255,0 : caption 4, " Je compte in english "
' Remplir les 3 LIST par les résultats d'un traitement
' En fait, on va apprendre à compter de 1 à 99 en Anglais
for i = 1 to 99
   if i < 10 then z$ = "0" : else : z$= ""
   WordNumber(i) : ' Appel de la procédure SUB de traduction
   if i < 34
   item_add 1, z$+str$(i) + " " +w$ : ' On ajoute des éléments à LIST 1
   else
   if i < 67
   item_add 2,str$(i) + " " +w$ : ' On ajoute des éléments à LIST 2
   else
   item_add 3,str$(i) + " " +w$ : ' On ajoute des éléments à LIST 3
   end_if
   end_if
next i
' La fonction COUNT(N) retourne le nombre de lignes (articles) de l'objet
' système désigné par son numéro N.Dans cet exemple, il s'agit de LIST
print_locate 50,500 : print "Nombre de lignes (list 1)= " + str$(count(1))
print_locate 50,520 : print "Nombre de lignes (list 2)= " + str$(count(2))
print_locate 50,540 : print "Nombre de lignes (list 3)= " + str$(count(3))
end
rem ============================================================================
' Une procédure dont on exploite (comme retour) le résultat du calcul dans
' la variable globale w$
SUB WordNumber(i)
   If i < 11
   select i
   case 0 : w$ = ""
   case 1 : w$ = "One"
   case 2 : w$ = "Two"
   case 3 : w$ = "Three"
   case 4 : w$ = "Four"
   case 5 : w$ = "Five"
   case 6 : w$ = "Six"
   case 7 : w$ = "Seven"
   case 8 : w$ = "Eight"
   case 9 : w$ = "Nine"
   case 10 : w$ = "Ten"
   end_select
   else
   if i < 20
   select i
   case 11 : w$ = "Eleven"
   case 12 : w$ = "Twelve"
   case 13 : w$ = "Thirteen"
   case 14 : w$ = "Fourteen"
   case 15 : w$ = "Fifteen"
   case 16 : w$ = "Sixteen"
   case 17 : w$ = "Seventeen"
   case 18 : w$ = "Eighteen"
   case 19 : w$ = "Nineteen"
   end_select
   else
   Suite(i)
   end_if
   end_if
END_SUB
rem ============================================================================
SUB Suite(i)
   dim_local w1$
   select int(i/10)
   case 2 : WordNumber(mod(i,10)) : w1$ = "Twenty " + w$
   case 3 : WordNumber(mod(i,10)) : w1$ = "Thirty " + w$
   case 4 : WordNumber(mod(i,10)) : w1$ = "Forty " + w$
   case 5 : WordNumber(mod(i,10)) : w1$ = "Fifty " + w$
   case 6 : WordNumber(mod(i,10)) : w1$ = "Sixty " + w$
   case 7 : WordNumber(mod(i,10)) : w1$ = "Seventy " + w$
   case 8 : WordNumber(mod(i,10)) : w1$ = "Eighty " + w$
   case 9 : WordNumber(mod(i,10)) : w1$ = "Ninety " + w$
   end_select
   w$ = w1$
END_SUB
rem ============================================================================

Bonjour à tous, Smile

Parpaiun a écrit:

Citation :: alors je n'ai pas trouvé comment redéfinir un DIM en Panoramic comme REDIM c(5)

Il me semble qu'à une certaine époque, il y avait eu un débat là-dessus et que Jack avait codé la commande free pour libérer une variable et ainsi pouvoir la réutiliser.
Je ne sais pas si ça répond à ta question Parpaiun

Code:: dim a(10),i
for i=1 to 10
   a(i)=i
   print "a("+str$(i)+")=";a(i)
next i

free a(10)
print:print

dim a(10)
for i=1 to 10
   print "a("+str$(i)+")=";a(i)
next i

Excusez ma discrétion en ce moment, mais je suis à nouveau malade, mais je suis régulièrement le forum.
A+ Wink

Merci à Papydall, cosmos70, Klaus et Bignono pour leurs réponses variées mais un peu quelconques à mon avis.

A papydall, ses deux programmes de simulation des fonctions UBound et LBound sont plus ou moins proches de ceux souhaités. Je les ai donc notés et on verra après.

A Klaus, son évocation de la fonction COUNT que je connais bien me parait un peu hors sujet.

A cosmos70, son explication suivante:

On lit le premier (pour Parpaiun évidemment) avec item_read$(X,1). X étant le n° d'objet dlist, et le dernier par item_read$(X,count(x)). On efface l'objet par clear X. De plus on peut contrôler le contenu en remplaçant le dlist par List pour la mise au point.:

me semble pas claire faute d'un petit programme d'exemple.

A Bignono à qui je souhaite un prompt rétablissement, ta réponse n'est pas satisfaisante. Désolé !

A + ! lol!

Regarde bien ce code suivant:

Code:: ' variables techniques
dim i%, x%
' créer un objet dlist pour la démo
x% = 123
dlist x%
' simuler un dim x%(5)
for i%=0 to 5
item_add x%,str$(i%)
next i%
' afficher la valeur de ubound(x%)
message "ubound(x%)="+str$(count(x%)-1)

' redimensionner x% de x%(5) à x%(8)
' ==> rien à faire au niveau de DIM, juste à ajouter les données
for i%=1 to 3
item_add x%,100+i%
next i%
' afficher le nouveau ubound(x%)
message "ubound(x%)="+str$(count(x%)-1)

' conclusion:
' si l'on simule un tableau de dimensions variables par un objet dlist,
' la valeur de count(x%)-1 est la valeur de l'indice le plus élevé,
' donc la valeur de ubound(x%)

' est-ce vraiment hors sujet ?

Je suis ouvert à d'autres contributions...

@Parpaiun
Je pense que Klaus est dans le cœur-même du sujet.
Mais à chacun sa propre vision.
Bon, tu as demandé un petit exemple à cosmos concernant item_read$

Ajoute cette ligne à la fin du code posté par Klaus, ça t’éclairciras les choses, peut-être

Code:: for i% = 1 to count(x%) : print item_read$(x%,i%) : next i%

@Bignono

Je te souhaite un prompt rétablissement.

Invité

Bon je vais répondre. J'ai vu ton message ce soir, et préféré attendre pour me calmer.

Peut-être un peu de recherche sur les mots clés te renseignerais mieux. On est tous passé parlà. De plus il y a des tutoriels divers, sur le forum, sur le mag, et j'en passe.

Klaus et Papydall ont des connaissances que moi je n'ai pas. Je crois même que Klaus a été prof à l'université, et quant il te répond, c'est pas n'importe quoi, comme Papydall d'ailleurs. Moi, c'est pas important.

Comparaison entre un DLIST et un tableau dim:
exemple: DIM a(100)
DLIST 10
pour un list comme a(100):
on met a(1)=10 : a(2) = 20 : a(3) = 30
Pour lire ce tableau, on peut (c'est juste pour la comparaison: b= a(2), et tagada -tsoin-tsoin.

Pour un DLIST: Déjà un dlist peut remplir n'importe quel type de donnée, comme1 "aller se coucher", etc. Il faut seulement savoir quel type de donnée on a rentré à tel endroit (ou item).

On rempli par:
item_add 10,10 : item_add 10,20 : item_add 10,30, ce qui donne dans le dlist:
10
20
30
on peut aussi mettre à la suite: "se dorer la pilule", ce qui donne:
10
20
30
se dorer la pilule

Pour lire un emplacement, dans l'exemple le dlist a le n° 10, donc
avec dim a,a$
a= item_read$(10,1) : print a : ' le résultat sera 10
a = item_read$(10,2): print a: ' le résultat sera 20
a$=item_read$(10,4): print a$:' le résultat sera: se dorer la pilule

On peut modifier un dlist: si je veux modifier le 3ème élément en pensant y mettre 38.5
on supprime le 3ème avec : item_delete 10,3
et on insère avec item_insert 10,3,38.5

On peut tout effacer avec CLEAR 10
On peut lire le premier qui correspond à Lbound ,e crois: par a=item_read(10,1)
On peut lire le dernier qui doit corespondre à Ubound (j'ai pas vérifié les mots que tu donnes), par : a$ = item_read$(10,count10)), et tu aura le dernier de la liste. Si tu trouve trop compliqué pour ce dernier, tu fais une sub:

SUB Ubound(x)
' il n'y a pas de retour, donc il faut dédier une variable pour récupérer avec par exemple: dim retour$ au début.
retour$ = item_read(10,count(x))
END_SUB

et l'appel: avec dlist 10:
Ubound(10): if numeric(retour$) = 1 then a = val(retour$).

Ce qu'il y a de bien avec dlist, est que les données sont dynamiques. On peut en rajouter sans avoir à redéfinir le nombre. Ensuite pour la mise au point, lorsqu'on veut vérifier le contenu de celui-ci, il suffit de remplacer DLIST 10 par LIST 10, et là on a la vue sur les items et les possibilités de celui-ci, comme la sélection. Il y a forcément une différence de temps d'exécution, vu qu'il y a l'écriture sur l'écran. Ensuite lorsque le programme est au point, on le remplace par DLIST 10.

Bonne nuit! Sleep

Sincèrement bravo Cosmos70 pour la peine que tu as prise pour cette explication.

@Cosmos70:
Cool

INCONTOURNABLE Klaus, je te salue! king

Merci cosmos70 pour ta longue explication ! Seulement voilà, tout ça complique sérieusement ce que je voulais entreprendre conformément à mon programme !
Je préfère m'occuper calmement de mon problème sur lequel je ne suis pas loin de trouver la solution. Dès que j'en aurai fini avec ça, tu comprendras en visionnant mon programme qu'il y a une différence importante de fonctionnement. Désolé ! Embarassed

On voulait simplement apporter notre aide, chacun de son côté.
Mais comme tu es sur la bonne voie pour trouver solution à ton problème, c’est tant mieux.
Bonne programmation !

cosmos70 a écrit:: il suffit de remplacer DLIST 10 par LIST 10

Comment les DLIST sont-ils implémentés ? Je pensais que c'était des listes chaînées, un peu comme les StringList de Delphi.

Mais la remarque de Cosmos me fait plutôt penser que le DLIST serait en fait un objet LIST invisible !

Qu'en est-il exactement ?

Une DLIST est techniquement une TStringList en Delphi. On le voit en passant object_internal(numero_de_dlist) en paramètre à une fonction DLL en Delphi. Dans la fonction DLL, on déclare le paramètre con TObject et on affiche la propriété ClassName.

Honnêtement, Parpaiun, j'avoue que je me précipite pas pour t'aider car tu es très acerbe (que ce soit volontaire ou non) dans tes réponses et commentaires par rapport aux gens qui t'aident. Je fais court et je ne m'étend pas plus sur le sujet. J'espère me tromper et que tu continueras d'avoir des réponses à tes questions, mais d'après les réponses que je lit, il est possible aussi que d'autres se découragent aussi de répondre et de chercher à t'aider s'ils reçoivent comme forme de récompense que des "assez médiocre" ou c'est bien mais ce n'est pas du tout ça...

Klaus a écrit:: Une DLIST est techniquement une TStringList en Delphi. On le voit en passant object_internal(numero_de_dlist) en paramètre à une fonction DLL en Delphi. Dans la fonction DLL, on déclare le paramètre con TObject et on affiche la propriété ClassName.

Donc, l'objet DLIST est différent de l'objet LIST et doit être utilisé indépendamment.

En fait, la suggestion de Cosmos ne marche pas. Dans le programme suivant :

Code:: dlist 1

item_add 1, "a"
item_add 1, "b"
item_add 1, "c"

list 1

end

on obtient un message d'erreur : "Object already defined" quand on fait "list 1"

Pour afficher les données du DLIST, il faut faire un LIST supplémentaire et y transférer les données :

Code:: dlist 1

item_add 1, "a"
item_add 1, "b"
item_add 1, "c"

list 2

dim i%

for i% = 1 to 3
item_add 2, item_read$(1, i%)
next i%

end

Ce que Cosmos70 voulait dire, c'est que pour visualiser le contenu de la liste en phase de mise au point, tu remplaces la commande DLIST par la commande LIST. Et le programme fonctionnera de la même manière, sauf que tu vois le contenu de la liste à l'écran. C'est juste pour la mise au point.

Exact ! J'avais mal interprété la suggestion de Cosmos. Toutes mes excuses !

» Welcome Papydall
» Bienvenue à PRO Positif Plus !
» Pour PAPYDALL
» Petit test pour Papydall
» @ Papydall, (Joke)