Question fonction

[(gile)]

Je n'avais pas compris ça, dans ton exemple 'lsbrrecur' ne décrit pas une arborescence.

 

Si tes données sont structurées en arbre (structure récursive), commence par poser le problème en décrivant la structure de façon récursive.

Typequement, un arbre est une branche qui peut soit être vide, soit contenir des feuilles et / ou des branches.

Quand tu as clairement décrit ce qu'est une feuille, tu parcours ton arbre de façon récursive en traitant chaque cas :

- un arbre vide est une condition d'arrêt,

- une feuille peut aussi être une condition d'arrêt ou avoir un traitement particulier dans un appel récursif,

- une branche est traitée récursivement.

 

Petit exemple simple avec un arbre dont les feuilles sont des nombres, les branches sont des listes contenant des nombres et/ou des branches.

 

(setq arbre
      '(
        5
        (9 4)
        (6 (1 1))
        3
       )
)

 

Si je veux faire la somme de tous les nombres (feuilles), j'utilise un algorithme récursif qui colle à la description récursive de la structure.

La somme de toutes les feuilles d'une branche est égale à :

- 0 si la branche est vide

- si le premier élément de la branche est une feuille : la valeur d'une feuille plus la somme de toutes les feuilles du reste de la branche

si le premier élément de la branche est une branche : la somme de toutes les feuilles de cette branche plus la somme de toutes les feuilles du reste de la branche.

 

(defun sum (l)
 (cond
   ((null l) 0)                                  ; la branche est vide (condition d'arrêt)
   ((numberp (car l))                            ; le premier élément est une feuille
    (+ (car l) (sum (cdr l)))                    ; on l'ajoute à la somme du reste de la branche
   )
   (T                                            ; le premier élément est une branche
    (+ (sum (car l)) (sum (cdr l)))              ; on ajoute la somme de cette branche à la somme du reste de la branche
   )
 )
)

 

Si tu trace la fonction sum (trace sum) tu pourras voir dans la fenêtre de suivi comment les appels récursif traitent toutes les branches.

[x_all]

(trace ? je ne connais pas je regarde...

la structure?

lsbrrecur à bien la forme ( (branche 1) (branche 2) ...)

branche ( (nom_du_bloc 1 position 1 handle1) (nom_du_bloc 2 position 2 handle2) ...)

à mon avis il n'y a pas besoin de plus cette liste (lsbrrecu) n'est valable que pour le dessin debit-ventil3.dwg car elle a été générée en amont pour ce test . Ce n'est pas grave pour des test, mais pour générer cette liste, en cas de changement de graphe il faut le programme complet (qui reste hors sujet)

 

pour le calcul des conditions de sortie, j'ai essayer de le détailler, mais il est un peu moins trivial que le fonctionnement que tu décris Les variables sont caché dans les attributs des blocs (dynamiques) . J’aurai effectivement pu dérouler l'itération d'une branche avec une fonction récursive, mais bon, comme on ne parcours la branche qu'une seule foi et que je réinitialise le compteur, il n'y a pas de raison pour que ça marche pas.

Dans le code de (explore il y a un commentaire "par ici la sortie". C'est vrai que je ne l'ai pas signalé à la fin de mon algorithme, mais avec un garçon comme toi, je croyais que ce serai implicite. On sort quand on ne peu plus faire de (cdr dans la liste lsbrrecur car il n'y a plus qu'un n'a plus qu'un seul élément.

[(gile)]

lsbrrecur à bien la forme ( (branche 1) (branche 2) ...)

branche ( (nom_du_bloc 1 position 1 handle1) (nom_du_bloc 2 position 2 handle2) ...)

Toutes ces "branches" sont similaires (une liste de sous-listes de même format) et aucune ne contient de "sous-branche".

C'est comme si tu avais un dossier qui contient n sous-dossiers chacun contenant un certains nombre de fichiers (mais pas de dossiers).

Ce serait un arbre contenant uniquement des branches qui ne contiennent que des feuilles

On ne peut pas vraiment parler d'arborescence, en tout cas pas de structure récursive dans la mesure où au deuxième niveau d'imbrication on tombe toujours sur une feuille du type (nom_du_bloc 1 position 1 handle1), jamais sur une autre branche.

Si l'exemple que tu as donné est représentatif de ta structure, tu n'as pas besoin de récursivité, un foreach te permet de parcourir chaque "branche" et pour chacune, un autre foreach te permet de parcourir chaque feuille.

 

elle a été générée en amont pour ce test

Si tu n'as pas utilisé de fonction récursive pour générer cette liste, tu ne devrais pas avoir besoin de fonction récursive pour la parcourir.

 

Si ta structure est vraiment de type récursif tu dois pouvoir la définir comme une branche contenant potentiellement des feuilles et des branches (cette définition est récursive).

Dans ce cas :

J’aurai effectivement pu dérouler l'itération d'une branche avec une fonction récursive

C'est précisément ça un traitement récursif, un arbre est une branche, donc tu traites l'arbre comme tu traites une branche.

 

pour le calcul des conditions de sortie, j'ai essayer de le détailler, mais il est un peu moins trivial que le fonctionnement que tu décris

Si j'ai chois un exemple trivial pour illustrer mon propos, c'est pour faire ressortir le principe du fonctionnement des appels récursifs, mais en définissant des fonctions séparées pour le calcul de ces conditions (en général des prédicats qui retournent T ou nil) tu devrais pouvoir écrire une fonction 'explore' aussi claire et concise que 'sum'.

[x_all]

oui la fonction (explore doit pouvoir s'écrire

(explore lstbranche
branche (car lstbranche)
(testebranche branche)
 si non valide	passe le 1er élément à la fin et (explore lstbranche)
si valide  (traitebranche branche
 	si on est pas sur le dernier élément
       	lstbranche (cdr lstbranche)
  		(explore lstbranche)
Sortie de (explore)

Je vais faire (testebranche en dehors comme j'ai fait pour (traitebranche car a mon avis c'est là que j'ai un bug de voir la sortie de Sum je me dit que mon test de sortie pour explore est peut être pas top, mais ça se verra au débogage s'il me manque une itération...

Sur le principe j'avais bien compris.

Quand à la structure de la liste de branche à la longueur près toutes les branches sont identique dans la forme. Je comprend mal comment on pourrai faire une liste récursive. Dans tes exemple tu n'a pas besoin d'ordre dans tes calculs et je n'arrive pas à imaginer une structure de liste qui serai "auto ordonnée" pour qu'un simple (cdr me garantisse un calcul hiérarchisée.

Si on s’attaque à ça ça revient à changer le code du programme principal, ce qui n'était pas le but de la question. Et pourquoi se faire suer cet algo devrai marcher...

[(gile)]

si non valide passe le 1er élément à la fin et (explore lstbranche)

Ça sent fort le risque de boucle infinie...

[x_all]

ben non, on va finir par tomber une une branche terminale qui sera calculable (car pas de jonction intermédiaire non calculés)

[(gile)]

ben non, on va finir par tomber une une branche terminale qui sera calculable (car pas de jonction intermédiaire non calculés)

Typiquement le genre phrase incompréhensible pour moi. D'où la difficulté à t'aider concrètement.

 

Dans tous les cas pourquoi on "passe le 1er élément à la fin" si on est absolument sûr de ne pas y revenir ?

[x_all]

.... bizarre que tu n'ai pas compris après 10 messages d'explication

la condition pour qu'une branche soit calculable c'est que toute les sous branches aient été calculées une branche terminale n'a pas de sous branche, elle est donc toujours valide pour un traitement. (le traitement est traçable par Qa sur la branche mère car le bloc "jonction" est commun aux deux branches)

 

la branche mère que je repasse au début de la liste sera re testée et sera valide quand sa (ou ses branches filles) auront été calculées (et donc sorties de la liste) Peu importe l'ordre des branches dans la liste de départ. C'est un peu pour ça que j'ai fait la liste de branche en itératif.

Il se peu que la branche tronc (celle à la racine) passe plusieurs fois par le test mais peu importe quand tous les blocs "jonction" auront fini par être renseignés elle sera logiquement la dernière a sortir à cause de son retour au début à chaque fois quelle échoue au test

je persiste à croire que mon bug est grammatical une variable de type inadéquat, ou un appel mal orthographier un parantèse mal placée......bref rien que je ne sache corriger sans le pas à pas. En simplifiant (explore et en sortant (testebranche) je devrai pouvoir mieux m'en sortir...

 

typiquement un gros réseau c'est 10 ou 15 branches... pas de quoi être pénalisant en temps de calcul (sauf si on le fait à la main)

[DenisHen]

Salut.

.... bizarre que tu n'ai pas compris après 10 messages d'explication

Perso, je suis ce forum depuis le début et je ne panne toujours rien :blink: , mais je ne suis pas (gile)... ;)

 

Par exemple, pourquoi une branche contiendra uniquement des feuilles et pas d'autres branches...

[x_all]

parce que c'est la règle du jeu

La règle pour la construction de cet arbre, c’est que le point 1 de la polyligne est le plus éloigné de la source, 2 types de bloc sont possible sur les vertex soit une Bouche soit un Tè. Chaque branche se termine par un Té.

 

Le bloc T s’il n’est pas le dernier cumule de Q courant de la branche et un Q auxiliaire de la branche fille. Si le T est sur une extrémité, le champ à remplir est le Qa . La condition pour que la branche parent soit calculable c'est que tous les bloc T intermédiaire aient une valeur de Qa non nulle.

voir ici pour rappel

http://cadxp.com/top...post__p__266131

après même sans être des "spécialiste" un réseau de ventil, c'est une source qui aspire dans un réseau ramifié. le débit se cumule de bouche en bouche dans la branche et les branches dans le collecteur.avez vous observé le dessin?

Quand tu parles de feuille c'est moi qui ai du mal car j'ai 2 types de feuilles (non interchangeable) donc ce concept n'est à mon avis pas pertinent.

pour cumuler la valeur qui arrive d'une branche fille, il est indispensable que cette fille ait été déja calculée. Une des règle du jeux, c'est que je réinitialise le Qa avant traitement de la liste des branches donc j'en reviens à

 

si tous les Qa des bloc de la branche (sauf le dernier) sont différent de 0 la branche est calculable.

Mais bon encore une fois, peu importe le pourquoi et le comment j'en arrive là. Ce qui me bloque partant de cette interface de test, c'est de trouver une coquille sans débuguer.En sortant le test j'espère m'en sortir...

 

 

 

 

[(gile)]

Je n'ai pas compris parce que je ne fais aucun effort. C'est pour essayer de te pousser à t'expliquer de la manière la plus symbolique (mathématique) possible, avec recul, sans référence au métier.

Quand tu codes, tu t'adresses à l'interpréteur LISP qui ne sais pas ce qu'est un Té, une Bouche, une Jonction...

 

Quand tu parles de feuille c'est moi qui ai du mal car j'ai 2 types de feuilles (non interchangeable) donc ce concept n'est à mon avis pas pertinent

Si je parle de feuille et de branche, c'est parce que ce sont les termes symbolique couramment utilisés quand on parle de traitement de structures arborescentes.

Que tu aies deux types de feuilles ne change rien à la structure générale de ton "arbre", tu peux dire qu'une "branche" peut potentiellement porter des "feuilles" et des "fruits".

 

Ce qu'il faut que intègres, c'est que si une "branche" ne peut porter que des "feuilles" et des "fruits" mais aucune autre "branche", alors ta structure n'est pas une structure récursive.

 

Structure non récursive :

Un "arbre" est une liste de "branches". Une "branche" est une liste de "feuilles" et de "fruits".

 

Structure récursive :

Un "arbre" est une "branche". Une "branche" est une liste de "feuilles", de "fruits" et de "branches" (qui sont autant de listes de "feuilles", de "fruits" et de "branches"...)

 

Comme dit plus haut, si tu n'as pas eu besoin d'utiliser la récursivité pour construire ton arbre (la liste) je vois mal comment ça pourrait être une structure récursive donc pourquoi tu aurais besoin d'utiliser la récursivité pour le parcourir (à part pour le fun).

[x_all]

Je comprend ou est la nuance. C'est vrai que dans la conception le la création de la liste je n'ai pas choisi cette option. Du reste que j'ai du mal à l'imaginer écrite en lisp. ça donne quoi le (print d'un arbre?) et encore plus à pondre la moulinette pour l’extraire d'un dessin.

Et puis si ma branche ne contient pas de branche, elle contient des jonctions qui sont les départ de branche on retombe sur nos pattes non?

Si j'ai besoin de la branche fille du nœud N je peu aller le chercher en trouvant le point commun avec les autres listes.

 

 

Pour le fun, quand j'en aurai fini avec ça, je veux bien m'y pencher... ça me sera sans doute tip top si je veux faire une numérotation automatique des bouches du réseau ou une notion de profondeur de branche me serai utile.

 

 

Il n'en reste pas moins que en l'espèce comme disent les avocats, une fonction récursive me parait efficace pour sortir de cette impasse. Malgré la structure de ma liste de branche il n'y a pas de raison pour que ça marche pas.

Et comment faire pour obtenir le même résultat sans récursif?

 

A ce jour le réseau n'est pas hiérarchisé. il faudrait commencer par ordonner la liste?

Depuis le début, quand je parle d'arbre, c'est pour décrire à quoi ressemble physiquement un réseau. Dans mon code je ne parle que d'une liste de branche qui est suffisante à résoudre le problème posé mais pas plus.

 

Je me creuse un peu mais sans rire je ne voie pas comment on peu faire sans.

 

 

 

 

 

 

[(gile)]

Et puis si ma branche ne contient pas de branche, elle contient des jonctions qui sont les départ de branche on retombe sur nos pattes non?

Non, si tu ne regardes pas la chose d'un point de vue métier mais d'un point de vue structure de données, une "jonction" est une liste du même type qu'un "Debit".

 

Et comment faire pour obtenir le même résultat sans récursif?

Toujours en essayant de rester générique, et comme déjà dit précédemment :

(defun traiterbranche (branche)
 (foreach feuille branche
   (if (= (car feuille) "Debit")
     (traiterdebit feuille)
     (traiterjonction feuille)
   )
 )
)

(defun traiterarbre (arbre)
 (foreach branche arbre
   (traiterbranche branche)
 )
)

[x_all]

les mots me manques. c'est comment dire ... renversant.

 

un petit aparté "technique" mon collègue ingé psvc me signale de les thermes ne sont pas ceux usuels pour les bouches on parle due Qd pour le diffuseur et du Qa pour axial, le débit à l'avancement.

et pour les T de jonction Qa , Qt transversal pour la branche

 

 

 

Mais une foi de plus tu me savonnes la planche, si je comprend bien a peut près comment je peut accéder au données et même ou je pourrai mettre des test avec un truc comme ça

 

(defun traiterdebit (feuille)
 (princ (strcat "feuille débit Qdiffuseur Qd: " (        (read (Vb-Val-att (handent handle_feuille) "Qd")))))
 (princ (strcat "feuille débit Qaxial Qa  : " (        (read (Vb-Val-att (handent handle_feuille) "Qa")))))
);fd

(defun traiterjonction (feuille)
 (princ (strcat "feuille jonction Qaxial: " (        (read (Vb-Val-att (handent handle_feuille) "Qa")))))
 (print "maj Qtransversal a 100")
 (Vb-Mod-att (handent handle_feuille) "Qt" (rtos 100))
 (princ (strcat "feuille jonction Qtransversal Qt : " (        (read (Vb-Val-att (handent handle_feuille) "Qt")))))

);fd

 

 

j'ai plus de mal à formuler la structure des données en entrée

suis je sur la bonne piste ?

 

setq arbre (liste des branches)

setq branche (liste des points de poly)

setq feuille ( nom point handle )

 

 

Si je lit bien le squelette,j'ai hâte de le faire tourner on a quand même changé de niveau là...

j'en suis presque à dire... et pourtant, ... elle tourne...

car j'ai du mal à comprendre d'ou va émerger la hiérarchie du réseau de cette moulinette.

 

ça reprend complètement le projet, mais ça devrai avancer vite..

[(gile)]

un petit aparté "technique" mon collègue ingé psvc me signale de les thermes ne sint pas ceux usuels pour les bouche on parle due Qd pour le diffuseur et du Qa pour axial, le débit à l'avancement.

et pour les T de jonction Qa , Qt transversal pour la branche

:blink: :blink:

Là on atteint des sommets, même en corrigeant le fautes d'orthographes on est au delà de la poésie surréaliste...

Je crois qu'il est grand temps que tu relèves la tête et que tu prennes un peu de recul (ou de repos).

 

Tant que tu n'arriveras à énoncer clairement pour le commun des mortels ce que tu souhaites faire, tu ne pourras pas concevoir un programme pour un ordinateur qui ne fait qu’obéir à des instructions sans être capable de comprendre tes intentions.

[x_all]

c'était parti un peu vite, mais je croyais avoir le temps d'éditer te supposant couché ;)

[Fraid]

Bonjour,

 

Les calculs de débits de climatisation tel que tu nous les présente, ne sont connus que de quelques ingénieur spécialisé qui eux seul pourront t'aider, si il connaissent l'Autolisp.

 

cela réduit terriblement les chances que quelqu’un puisse t'aider au delà de cela.

 

Débit en m3/h=Vitesse (m/s) x Surface (m) x 3600

 

tu devrait repenser ton problème avec du code générique et non spécialisé.

 

et surtout mettre en place un vrais Algorithme complet, comme te l'a indiqué Gile.

 

La, on ne voit même pas ce que tu cherche à faire....

 

Je te conseil les cours d'algo present sur developpez.com

 

Bonne chance

[x_all]

merci pour les encouragements

 

le dimensionnement d'un réseau, c'est ce que je fait régulièrement. les cours d'algo? je viens d'en prendre un.

du reste si tu as bien suivi, l’algorithme, (gile) vient de le poser clairement

 

la structure des donnes vient de changer complètement ça demande donc a mûrir un peu avant d’être reformulé...

mais j'ai dans l'idée qu'il faut numéroter les feuilles et les branches pour s'en sortir

 

je rappelle que la programmation n'est pas mon métier (et ne devrai pas occuper mes nuits) et que le projet est un peu ambitieux. Il va me faire gagner énormément de temps et en fera gagner à d'autre j'espère.

[DenisHen]

D'après ce que j'en ai compris, il faut calculer les branches en fin d'arborescence, avec leurs feuilles et leurs fruits, puis, à l'aide de ces résultats, calculer les branches précédentes, avec leurs feuilles et leurs fruits... Ainsi de suite jusqu'à la branche principale...

 

C'est marrant, j'ai essayé de faire un truc similaire il y a peu de temps, mais j'ai laissé tomber, pas le niveau... :blink:

[x_all]

je lis à peu près la même chose, reste à générer la liste des branches... avec les feuilles et sous branche.Pour les feuille c'est facile, pour les branches il me faudra un peu de temps

Pas de la tarte.et pas de temps avant qqs jours...

 

 

 

[(gile)]

D'après ce que j'en ai compris, il faut calculer les branches en fin d'arborescence, avec leurs feuilles et leurs fruits, puis, à l'aide de ces résultats, calculer les branches précédentes, avec leurs feuilles et leurs fruits... Ainsi de suite jusqu'à la branche principale...

 

C'est marrant, j'ai essayé de faire un truc similaire il y a peu de temps, mais j'ai laissé tomber, pas le niveau... :blink:

 

C'est exactement ce que fait la fonction récursive donnée en exemple ici.

Si on fait un pas à pas :

;; empilement
(sum '(5 (9 4) (6 (1 1)) 3))
(+ 5 (sum '((9 4) (6 (1 1)) 3)))
(+ 5 (+ (sum '(9 4)) (sum '((6 (1 1)) 3))))       ; (sum '(9 4)) est le calcul d'une branche
(+ 5 (+ (+ 9 (sum '(4))) (sum '((6 (1 1)) 3))))
(+ 5 (+ (+ 9 (+ 4 (sum ()))) (sum '((6 (1 1)) 3))))
(+ 5 (+ (+ 9 (+ 4 0)) (sum '((6 (1 1)) 3))))
(+ 5 (+ (+ 9 (+ 4 0)) (+ (sum '(6 (1 1))) (sum '(3))))) ; (sum '(6 (1 1))) calcul d'une branche
(+ 5 (+ (+ 9 (+ 4 0)) (+ (+ 6 (sum '(1 1))) (sum '(3)))))    ; (sum '(1 1)) calcul d'une branche
(+ 5 (+ (+ 9 (+ 4 0)) (+ (+ 6 (+ 1 (sum '(1)))) (sum '(3)))))
(+ 5 (+ (+ 9 (+ 4 0)) (+ (+ 6 (+ 1 (+ 1 (sum ())))) (sum '(3)))))
(+ 5 (+ (+ 9 (+ 4 0)) (+ (+ 6 (+ 1 (+ 1 0))) (sum '(3)))))
(+ 5 (+ (+ 9 (+ 4 0)) (+ (+ 6 (+ 1 (+ 1 0))) (+ 3 (sum ())))))
;; dépilement
(+ 5 (+ (+ 9 (+ 4 0)) (+ (+ 6 (+ 1 (+ 1 0))) (+ 3 0))))
(+ 5 (+ (+ 9 4) (+ (+ 6 (+ 1 (+ 1 0))) (+ 3 0))))
(+ 5 (+ 13 (+ (+ 6 (+ 1 (+ 1 0))) (+ 3 0))))
(+ 5 (+ 13 (+ (+ 6 (+ 1 1)) (+ 3 0))))
(+ 5 (+ 13 (+ (+ 6 2) (+ 3 0))))
(+ 5 (+ 13 (+ 8 (+ 3 0))))
(+ 5 (+ 13 (+ 8 3)))
(+ 5 (+ 13 (+ 8 3)))                              ; résultats des feuilles et sommes par branche
(+ 5 (+ 13 11))
(+ 5 24)
29

 

Mais cet algorithme un peu naïf qui traite chaque branche élément par élément n'est pas très efficient et servait surtout à illustrer mon propos.

 

Les fonctions d'ordre supérieur permettent de traduire de façon déclarative (quasiment mot pour mot l'algorithme) :

la somme des feuilles d'une branche, c'est la somme de ses feuilles et des sommes des feuilles de ses branches.

(defun sum (l)
 (apply '+
        (mapcar
          '(lambda (x)
             (if (listp x)
               (sum x)
               x
             )
           )
          l
        )
 )
)

Le pas à pas est alors bien plus concis :

(sum '(5 (9 4) (6 (1 1)) 3))
(apply '+ (list 5 (sum '(9 4)) (sum '(6 (1 1))) 3))
(apply '+ (list 5 (apply '+ (list 9 4)) (sum '(6 (1 1))) 3))        ; dépilement de (sum '(9 4))
(apply '+ (list 5 13 (sum '(6 (1 1))) 3))
(apply '+ (list 5 13 (apply '+ (list 6 (sum '(1 1)))) 3))           ; dépilement de (sum '(6 (1 1)))
(apply '+ (list 5 13 (apply '+ (list 6 (apply + (list 1 1)))) 3))   ; dépilement de (sum '(1 1))
(apply '+ (list 5 13 (apply '+ (list 6 2)) 3))
(apply '+ (list 5 13 8 3))
(+ 5 13 8 3)
29

[x_all]

Merci à Patrick pour sa petite aspirine. Son exercice m'a délié (explore... j'ai eu droit à mon "sortie normale de Tex!"

 

 

 

je vais pouvoir passer à la suite. Mais j'attends de tester un peu.

 

Pour la petite l'histoire, c'était bien de bugs à la cons (il y en a un de dyslexique qui m'a donné du mal) Avec l'exercice de patrick, j'ai compris que le pas à pas marche très bien dans les fonctions récursives

juste il faut que la grammaire soit irréprochable. Pour contourner le truc, (car mon orthographe n'est pas catastrophique que sur les forum) j'ai supprimé les appels de (explore a l'exécution, et tester la première branche en remplissant les champs dans le dessin pour passer les tests.

 

je retiens la roulette de fonctions de l'arbre/branches/feuille très pédagogique. Mais si je fait un module de numérotation des blocs, j'aurai besoin d'un vrai parcours d'arbre, j'ai plutôt espoir du coté du challenge 2

 

la suite bientôt ici...

 

merci pour la patience.