ATOUTFOX
COMMUNAUTÉ FRANCOPHONE DES PROFESSIONNELS FOXPRO
Visual FoxPro : le développement durable

Forum AtoutFox : Re: Récursivité et stack space   

Sujet

rss Flux RSS des derniers messages

Vous devez vous identifier pour pouvoir poser une question ou répondre.

dim. 31 octobre 2010, 19h50
eddymaue
atoutfox.public.association

Re: Récursivité et stack space

et un peu de lecture suplémentaire sur le sujet

http://web2.uqat.ca/lerene/Webcours/gen-3405/manuel/m17-3405.pdf

ca fait pas de mal

a+ eddy

eddymaue a couché sur son écran :
> Gilles t'as raison
> A part fouiner dans la profondeur des arcades de mes objets et la recherche
> de fichiers sur mes disques c'est rare, voir très rare, que je me serve de la
> récursivité....
>
> humm… quoi que dans les treeviews c'est pas mauvais non plus et toutes
> algorithmes qui doivent fouiller dans un arbre dont on ne connait pas le
> nombre de branches ainsi que la profondeur variable de chacune ... je ne vois
> pas comment autrement faire que de passer par la récursivité…. Il y a aussi
> le fameux algo QuickSort qui est bel exemple de récursivité dans le tri d’une
> liste d’éléments d’un tableau… J’ai pratiqué cet algo pour la première fois
> sur mon Commodore 64 et comme exercice surtout les environnements ou j’ai
> fait du développement.
> Mais enfin pour faire 1+1=3 c’est pas utile… ;)
>
> Bonne soirée
>
>
>
> G.L.S avait énoncé :
>> Bonjour,
>>
>> Merci Greg..
>> en mode itératif dans une même séquence je ne vois pas comment faire...peut
>> être une procédure appelante qui met dans un tableau les répertoires
>> courants, les balaye un par un en appelant une fonction avec comme
>> paramètre le tableau courant passé en référence, l'indice à traiter du
>> tableau courant passé en valeur qui traite les fichiers du répertoire
>> indicé et qui ajoute dans le tableau passé en référence les nouveaux
>> répertoires trouvés. Ce tableau à l'origine possède une dimension
>> supplémentaire pour ne plus à avoir à traiter les répertoires déjà
>> balayés..
>>
>> Maintenant, hormis le cas d'utilisation de Eddy qui jongle avec les objets
>> de VFP, je ne vois pas dans une application le besoin de balayer des
>> répertoires dont on ne connait pas d'avance ni le nom du dossier principal,
>> ni la structure des noms de dossiers et fichiers..D'autant que je me doute
>> qu'une telle opération doit être couteuse en temps machine..
>>
>> Je suis obtus et pragmatique, mais la récursivité couplée a vos
>> explications au demeurant brillantes et compréhensibles, me semble rester
>> un phénomène théorique (dans des applications ou VFP va donner pleinement
>> sa mesure a savoir le traitement des données d'une base de données à des
>> fins de gestions) et ne me laisse entrevoir aucune utilisation utile dans
>> mes programmes..
>>
>> Amicalement
>> G.L.S
>> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
>> news:iagsmk$76c$1@news.niouzes.net...
>>> Tiens, Gilles,
>>>
>>> Je te donne le code pour parcourir des repertoires de maniere recursive.
>>> Il est assez simple
>>>
>>> Petit excersice : donne-moi le code pour le faire - et dans la meme
>>> sequence - en mode iteratif ?
>>>
>>>
>>> ?AdirRecursive('d:\tmp')
>>>
>>> function AdirRecursive(folder)
>>>
>>> local aa[1], i, n, mounted, filename
>>>
>>> n = adir(aa, addbs(m.folder) + '*.*', 'AHRDS', 1)
>>> mounted = !( (m.n >= 2) and (aa[1,1]=='.') and (aa[2,1] == '..') )
>>>
>>> for i = iif(m.mounted, 1, 3) to m.n
>>> filename = addbs(m.folder) + m.aa[m.i, 1]
>>> ?m.filename
>>> if( 'D' $ m.aa[m.i, 5] )
>>> =AdirRecursive(m.filename)
>>> endif
>>> endfor
>>>
>>> endfunc
>>>
>>>
>>>
>>> Gregory
>>> __
>>> "G.L.S" wrote in message news:iagqhb$5qn$1@news.niouzes.net...
>>>
>>> Merci Greg..
>>>
>>> Donc je retiens hormis la brillante démonstration que cela ne sert pas à
>>> grand chose de pratique dans nos applications VFP sauf à améliorer
>>> ponctuellement la lisibilité de quelques cas d'écritures..
>>>
>>> Amicalement
>>> G.L.S.
>>> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
>>> news:iagntr$3vj$1@news.niouzes.net...
>>>> >surtout dans quelles situations concrètes sous VFP ou
>>>> autres langages de dév. on est obligé de s'en servir..
>>>>
>>>>
>>>> On n'est jamais obligé de s'en servir, mais cela a un avantage d'etre
>>>> plus clair
>>>>
>>>> En vfp on est parfois limite du au niveau des 'DO' et dans ce cas il
>>>> faut emploer une methode iterative
>>>>
>>>>
>>>>
>>>> Gregory
>>>> __
>>>> "G.L.S" wrote in message news:iagjgr$120$1@news.niouzes.net...
>>>>
>>>> Bonjour,
>>>>
>>>> Je rebondis sur les dires de Marc..
>>>>
>>>> Perso je ne sais pas ce que c'est que la récursivité (bien que le mot ne
>>>> me
>>>> soit pas étranger) et surtout dans quelles situations concrètes sous VFP
>>>> ou
>>>> autres langages de dév. on est obligé de s'en servir..
>>>>
>>>> Cordialement
>>>> G.L.S
>>>> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
>>>> news:iagieb$9b$1@news.niouzes.net...
>>>>> >le vin aurait été banni au profit de
>>>>> Oui, Marc, mais puisque je m'adressais a un Francais, je me disais que
>>>>> le vin, il comprendrait mieux
>>>>>
>>>>>> J'espère bien de ta part un exposé sur la récursivité dans VFP ...
>>>>> Qu'entends-tu par cela ? Quels points sont obscurs ?
>>>>>
>>>>> Gregory
>>>>> __
>>>>> "Marc Thivolle" wrote in message news:iaf9o5$2fh5$1@news.niouzes.net...
>>>>>
>>>>> A part que je suis d'accord avec tes remarques techniques, je pensais
>>>>> que
>>>>> venant de ta part le vin aurait été banni au profit de le bière et du
>>>>> whisky
>>>>> (ce qu'on peut être méchant à 22h00 !).
>>>>>
>>>>> Tout cela en toute amitié.
>>>>>
>>>>> J'espère bien de ta part un exposé sur la récursivité dans VFP ... car
>>>>> j'avoue que certains comportements de notre langage préféré me semblent
>>>>> bien
>>>>> étranges.
>>>>>
>>>>> Marc de la Bastille
>>>>>
>>>>>
>>>>> "Gregory Adam" a écrit dans le message de groupe de discussion :
>>>>> iaedah$1rv7$1@news.niouzes.net...
>>>>>
>>>>> Luc,
>>>>>
>>>>> Les stack et les queue - c'est comme le vin - il faut apprendre a
>>>>> apprecier
>>>>>
>>>>> Sans doute que ton code recursif peut etre converti en non-recursif -
>>>>> avec
>>>>> ou sans stack/queue
>>>>>
>>>>> Faudrait voir le code pour avoir une idee
>>>>>
>>>>> Mais - duplication du code - j'eviterais
>>>>>
>>>>>
>>>>> Gregory
>>>>> __
>>>>> "luc Gilot" wrote in message news:iaebjt$1qp4$1@news.niouzes.net...
>>>>>
>>>>> Merci Grégory
>>>>>
>>>>> Bon, je connaissais bien stacks et queu, mais je ne voyais pas le
>>>>> rapport.
>>>>> Je ne le vois toujours pas d'ailleurs, mais j'ai fini par contourner le
>>>>> problème en créant une pseudo-récursivité à l'intérieur de la fonction
>>>>> récursive, par duplication du code (10 fois, ce qui me permet de diviser
>>>>> par
>>>>> 10 la profondeur des appels de fonctions). Ce n'est pas très élégant
>>>>> mais ca
>>>>> a l'air de fonctionner...
>>>>>
>>>>> Luc
>>>>>
>>>>> "Gregory Adam" <GregoryAdam@NoWhere.com> a écrit dans le message de
>>>>> news:
>>>>> iae7n8$1nv8$1@news.niouzes.net...
>>>>>> Stack/Queue = pile ou on peut sauver son contexte pour le recharger
>>>>>> apres
>>>>>>
>>>>>> Stack = LIFO http://en.wikipedia.org/wiki/Stack_(data_structure)
>>>>>> Queue = FIFO http://en.wikipedia.org/wiki/Queue_(data_structure)
>>>>>>
>>>>>> Stack: operations:
>>>>>> - Push(xx)
>>>>>> - Pop(@m.xx) or Pop()
>>>>>>
>>>>>> Queue: operations
>>>>>> - Enqueue(item)
>>>>>> - Dequeue(@m.item)
>>>>>>
>>>>>> Une implementation simple des deux
>>>>>>
>>>>>> local stackObj
>>>>>>
>>>>>> stackObj = createObject('Stack')
>>>>>> ?m.stackObj.Push(1)
>>>>>> ?m.stackObj.Push(2)
>>>>>> ?m.stackObj.Push(3)
>>>>>> ?m.stackObj.Push(4)
>>>>>>
>>>>>> local x
>>>>>> ?m.stackObj.Pop(@m.x)
>>>>>> ?x && 4
>>>>>>
>>>>>> ?m.stackObj.Pop(@m.x)
>>>>>> ?x && 3
>>>>>>
>>>>>> ?m.stackObj.Pop(@m.x)
>>>>>> ?x && 2
>>>>>>
>>>>>> ?m.stackObj.Pop(@m.x)
>>>>>> ?x && 1
>>>>>>
>>>>>> meme excersice avec Queue
>>>>>>
>>>>>>
>>>>>> local queueObj
>>>>>> queueObj = createObject('Queue')
>>>>>> ?m.queueObj.Enqueue(1)
>>>>>> ?m.queueObj.Enqueue(2)
>>>>>> ?m.queueObj.Enqueue(3)
>>>>>> ?m.queueObj.Enqueue(4)
>>>>>>
>>>>>> ?m.queueObj.Dequeue(@m.x)
>>>>>> ?x && 1
>>>>>>
>>>>>> ?m.queueObj.Dequeue(@m.x)
>>>>>> ?x && 2
>>>>>>
>>>>>> ?m.queueObj.Dequeue(@m.x)
>>>>>> ?x && 3
>>>>>>
>>>>>> ?m.queueObj.Dequeue(@m.x)
>>>>>> ?x && 4
>>>>>>
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> define class Stack as CollectionBase
>>>>>>
>>>>>> *-------------------------------------------------------------------------------
>>>>>> function Push(v)
>>>>>> =m.this.Add(m.v)
>>>>>> endfunc
>>>>>> *-------------------------------------------------------------------------------
>>>>>> function Pop(v)
>>>>>>
>>>>>> if( empty(m.this.Count) )
>>>>>> return FALSE
>>>>>> endif
>>>>>> v = m.this.Item(m.this.Count)
>>>>>> =m.this.Remove(m.this.Count)
>>>>>>
>>>>>> endfunc
>>>>>> *-------------------------------------------------------------------------------
>>>>>> function Peek(v)
>>>>>>
>>>>>> if( empty(m.this.Count) )
>>>>>> return FALSE
>>>>>> endif
>>>>>> v = m.this.Item(m.this.Count)
>>>>>>
>>>>>> endfunc
>>>>>> *-------------------------------------------------------------------------------
>>>>>> *-------------------------------------------------------------------------------
>>>>>> enddefine
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>>
>>>>>>
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> define class Queue as CollectionBase
>>>>>>
>>>>>> *-------------------------------------------------------------------------------
>>>>>> function EnQueue(v)
>>>>>> =m.this.Add(m.v)
>>>>>> endfunc
>>>>>> *-------------------------------------------------------------------------------
>>>>>> function DeQueue(v)
>>>>>>
>>>>>> if( empty(m.this.Count) )
>>>>>> return FALSE
>>>>>> endif
>>>>>> v = m.this.Item(1)
>>>>>> =m.this.Remove(1)
>>>>>>
>>>>>> endfunc
>>>>>> *-------------------------------------------------------------------------------
>>>>>> function Peek(v)
>>>>>>
>>>>>> if( empty(m.this.Count) )
>>>>>> return FALSE
>>>>>> endif
>>>>>> v = m.this.Item(1)
>>>>>>
>>>>>> endfunc
>>>>>> *-------------------------------------------------------------------------------
>>>>>> enddefine
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>>
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> define class CollectionBase as Collection
>>>>>>
>>>>>> *-------------------------------------------------------------------------------
>>>>>> function Clear()
>>>>>>
>>>>>> =m.this.Remove(-1)
>>>>>>
>>>>>> endfunc
>>>>>> *-------------------------------------------------------------------------------
>>>>>> function Empty()
>>>>>>
>>>>>> return empty(m.this.Count)
>>>>>>
>>>>>> endfunc
>>>>>> *-------------------------------------------------------------------------------
>>>>>> enddefine
>>>>>>
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>> *===============================================================================
>>>>>>
>>>>>> Gregory
>>>>>> __
>>>>>> "luc Gilot" wrote in message news:iae653$1mri$1@news.niouzes.net...
>>>>>>
>>>>>> Merci pour vos réponses.
>>>>>>
>>>>>> * Changer le nb de variables ne change rien (non plus que de diminuer
>>>>>> la
>>>>>> longueur de leurs noms ou de celui de la fonction récursive : il
>>>>>> fallait
>>>>>> quand même essayer...)
>>>>>>
>>>>>> * Grégory qu'est-ce qu'un stack ou queue ?
>>>>>>
>>>>>> Luc
>>>>>>
>>>>>> "luc Gilot" <luc.gilot@limoog.net> a écrit dans le message de news:
>>>>>> iae0jb$1ivi$1@news.niouzes.net...
>>>>>>> Bonjour
>>>>>>>
>>>>>>> Je dois écrire un programme très récursif (environ 2000 niveaux de
>>>>>>> profondeur).
>>>>>>> Un premier réglage de STACKSIZE = ... dans config.fpw m'a permis
>>>>>>> d'éviter le message "Trop de DO imbriqués" à une profondeur de 119.
>>>>>>> J'arrive maintenant à une profondeur de 437 avec un message "Espace
>>>>>>> pile insiffisant"
>>>>>>>
>>>>>>> Comment augmenter la taille de la pile, ou faire en sorte qu'elle se
>>>>>>> remplisse moins vite (à part en ne faisant plus de récursivité!) ?
>>>>>>>
>>>>>>> Luc

Permalink : http://www.atoutfox.org/nntp.asp?ID=0000004305
20 286 messages dans le forum • Liste complète des messages

www.atoutfox.org - Site de la Communauté Francophone des Professionnels FoxPro - v3.4.0 - © 2004-2026.
Cette page est générée par un composant COM+ développé en Visual FoxPro 9.0-SP2-HF3