Je dois écrire en Caml la fonction algoRec qui prend les 4 paramètres suivants :
 
a)une fonction scinder : P -> pa(P) qui scinde un problème en une liste de sous problèmes,
b)une fonction estTrivial : P -> B qui retourne true si un problème est trivial ou false sinon,
c)une fonction solutionTrivial : P -> S qui retourne la solution à un problème trivial et
d)une fonction elaborerSolution : P x pa(S) -> S qui retourne la solution d'un problème en fonction de ce problème et des solutions de ses sous problèmes.
 
SACHANT QUE :  
 
- N l'ensemble des entiers naturels,
- B l'ensemble des booléens (true ou false),
- E -> F l'ensemble des applications de E dans F,
- pa(E) l'ensemble des parties d'un ensemble E,
- P l'ensemble des problèmes que l'on veut résoudre et
- S l'ensemble des solutions à ces problèmes.
 
 
Cette fonction algoRec retourne un élément de P -> S qui est une fonction récursive pour résoudre tout problème de P.
 
 
j'ai démarrer comme ca( si vous pouvez m'aider):
 
let algorec scinder estTrivial solutionTrivial elaborerSolution = if stTrivial = true then solutionTrivial else elaborerSolution;;

up  

Ben décompose ta fonction algoRec :

• 1 - scinder le problème si il n'est pas trivial
• 2 - traiter chaque sous-problème (récursif)
• 3 - élaborer la solution du prolème à partir de la solution des sous-problèmes

Voila, vas-y par étape.

il est claire que je dois ecrire les fonctions qui corresponde aux parametres en fonction de mon probleme.
 
Mais c'est la fonction aloRec que j'ai du mal a ecrire.

yo chui en 4A et g le projet Caml a rattraper moi aussi. eske tu a avancé depuis ce post. moi j'y comprends rien et si g pas cette matiere je redouble. tu imagines mon desarroi. si tu peut m'aider contact moi . manu_skp2@hotmail.com

let rec algorec scinder estTrivial solutionTrivial elaborerSolution P =  
  let rec auxRec = fun
    |[]->[]
    |(t::q) -> (algorec t):auxRec q)
  in
    if (estTrivial P)then (solutionTrivial P)
    else
     elaborerSolution P (auxRec (scinder P));;
 
Voila je n'ai pas caml d'installé sur ma machine de boulot, mais une solution comme celle-ci devrais marcher à peu près aux erreurs de syntaxe près.
Il ya besoin d'une fonction auxilliaires pour traiter la liste des sous problèmes qui apparait sous forme de liste.

est en fait : (

Il faudrait que je t'envoie mon pote, il est super-pédagogue niveau caml, moi je peux que faire la solution, ce qui sert à rien.

moi aussi j'ai une question a popos de caml. Pourkoi ce code ne marche pas ?
let procedurep1 = function
 |(1,x,y,z,t) -> moveto x y ;
          lineto z t;
 |(n,x,t,z,t) -> let U = ( x + z +t - z) / 2;
   let V = ( y + t - z + x) / 2;
   procedurep1(n-1,x,y,U,V);;
 
il me souligne les derniers ";;" n me disant qe c pas bon . Sa fait deux ans que je n'ai pas fait d'ocaml et la c dur dur !! merci

Alors déjà il faut faire un bloc quand il y a plusieurs instructions qui se suivent. Tu peux utiliser begin...end ou des parenthèses pour cela.
Ensuite il faut préciser que la fonction est récursive en utilisant le mot clé rec.
Les variables locales se déclarent en utilisant let ... in.
Les majuscules sont réservés aux constructeurs et aux noms de modules.
Et tu utilises deux fois t dans ton deuxième filtre.

(j'espère n'avoir rien oublié)
 
edit:l'expression de u et de v est probablement fausse (+z-z )

Merci beaucoup je ne comprenait plus rien lol. Apres deux ans on en oublie des choses et ce n'est pas chose facile de s'y remettre après tout ce temps en tout cas merci bcp !!!

j'ai une autre question , y a t'il un moyen de tracer un programme caml ? (debugger en gros)

j'ai voulu faire de la récursivité croisé (une fonction recursive f1 qui apelle une autre fonct rec f2 qui lui meme rapelle f1 ) et voila le resultat  
 
let rec procedurep1 = function
       
 |(1,x,y,z,t) ->
          begin
            moveto x y;
            lineto z t
          end
       |(n,x,y,z,t) ->
          (
            let u = ( x + z +t - y) / 2 in
            let v = ( y + t - z + x) / 2 in
             ( procedurep1((n-1),x,y,u,v)
        procedurep2((n-1),x,y,u,v)  
       )
         )
 
      and procedurep2 = function
        |(1,x,y,z,t) ->
          begin
             moveto x y;
              lineto z t
           end
        |(n,x,y,z,t) ->
           (
              let u = ( x + z -t + y) / 2 in
              let v = ( y + t + z - x) / 2 in
             ( procedurep1(n-1,x,y,u,v)
       procedurep2((n-1),u,v,z,t) )
         );;
 
Le seul probleme c'est que sa marche pas !!
Toplevel input:
>...........................function
>        
> |(1,x,y,z,t) ->
>          begin
>..........
>             ( procedurep1((n-1),x,y,u,v)
>        procedurep2((n-1),x,y,u,v)  
>       )
>         )
This expression has type int * int * int * int * int -> unit,
but is used with type int * int * int * int * int -> 'a -> int * int * int * int * int -> unit.
#
 
Un peu d'aide ???
 
Merci bcp

Oui il y a un debugger non graphique (ligne de commande, sauf p-ê avec le GUI cameleon), mais qui permet de revenir en arrière. Mais il n'est pas disponible sur toutes les versions.

 
Mettre des print partout ?

Tu as oublié un point virgule entre les appels à procedurep1 et à procedurep2.

La directive trace est parfois utile aussi, bien que limitée (et elle marche sur toutes les plateformes).

Franchement merci, vous m'etes d'une grande aide !!!!!