Discussion :

[Splash_]

Bonjour, me revoila avec un petit problème :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
        Objective Caml version 3.10.0

# type expression= 
    Const of float
  | Exp of expression
;;
let rec evaluer exp = match exp with
      Const c-> c
    | Exp f -> exp(evaluer f)
  ;;
This expression is not a function, it cannot be applied

C'est bizarre cette erreur surtout que je peux faire exp(3.);; .
C'est du à la version d'ocaml que j'ai ?
(j'ai réduit la fonction et le type pour clarifier)

[Jedai]

Ca s'appelle du shadowing, littéralement tu mets la variable originale dans l'ombre, ici ton paramètre s'appelle "exp" donc il masque la fonction exp() pour la portée de ta fonction, autrement dit ton code est équivalent à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
let rec evaluer truc = match truc with
      Const c-> c
    | Exp f -> truc(evaluer f)

Généralement on utilise e ou expr pour "expression", jamais "exp".

--
Jedaï

[Cacophrene]

Salut !

J'ajoute au propos de Jedai que si, pour une raison quelconque, tu veux garder exp pour expression, il faut être plus explicite pour la fonction exponentielle et utiliser Pervasives.exp. Ton code devient alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
type expression = Const of float | Exp of expression
 
let rec evaluer exp = match exp with
  | Const c -> c
  | Exp f -> Pervasives.exp (evaluer f)

Ceci étant, on peut remplacer let rec evaluer exp = match exp with par let rec evaluer = function, ce qui évite de nommer l'argument. D'ailleurs tu n'en as pas besoin puisque exp est filtré et jamais réutilisé tel quel.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
type expression = Const of float | Exp of expression
let rec evaluer = function Const c -> c | Exp f -> exp (evaluer f)

Cordialement,
Cacophrène

[Splash_]

Ok c'est vrai que ça paraît evident maintenant. Merci pour le complement d'info.

[Splash_]

Et je voudrais savoir si c'était possible de faire quelque chose comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
let opp  fonction= fun x -> let res = fonction x in -.res;; 
 
let derive = fun 
  sin -> cos 
 |exp -> exp
 |cos -> opp sin
 ;;
   |exp -> exp
   ^
Syntax error

qui serait de type (float -> float) -> (float -> float) qui à une fonction retournerait une autre fonction. Un peu à la manière de opp.

[Jedai]

Non, ce n'est pas possible parce que ça impliquerait de comparer des fonctions, chose qu'on ne sait pas faire. Si tu veux faire des trucs comme ça, une solution serait de créer ton propre mini-langage intégré à OCaml pour faire du calcul symbolique (on appelle ça un DSL), ou de te reporter vers Haskell qui, bien qu'il ne te permette pas de comparer des fonctions, utilise un mécanisme de classes de type qui peut être utilisé pour faire des choses proches de ce que tu demandes (avec une méthode dite de dérivation automatique).

--
Jedaï

[gasche]

Lala, c'est gore mais c'est pour le fun.

Code ocaml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
# let sin, cos, exp = sin, cos, exp;;
 
# let derive (f, signe) =
  let signe = signe = signe in
  if f == exp then (f, signe)
  else if f == sin then (cos, signe)
  else if f == cos then (sin, not signe)
  else invalid_arg "derive";;
val derive : (float -> float) * 'a -> (float -> float) * bool = <fun>
 
# applique (derive (fonction cos)) (2. *. atan 1.);;
- : float = -1.

[Jedai]

Tu compares les adresses des fonctions, pas vraiment les fonctions elle-même, en plus c'est extrêmement limité, par exemple avec ton code tu ne peux dériver (fun x -> x^2 + 2)...

Alors qu'avec la technique de différentiation automatique, ce genre de fonction ou plus complexe peut-être dérivée sans problème :

Code Haskell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Prelude> import Data.Number.Dif
Prelude Data.Number.Dif> let double = deriv (\x -> x^2)
Prelude Data.Number.Dif> double 5
10
Prelude Data.Number.Dif> let f x = x^2 + 25
Prelude Data.Number.Dif> f 3
34
Prelude Data.Number.Dif> deriv f 5
10

(Data.Number.Dif est un module relativement simple qui implémente les bases de la différentiation automatique)

Tu peux même dériver des fonctions discontinues (avec des if dans l'expression), bien que la dérivée soit inexacte au point de discontinuité.

--
Jedaï

[SpiceGuid]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
let derive = fun 
  sin -> cos 
 |exp -> exp
 |cos -> opp sin
 ;;

qui serait de type (float -> float) -> (float -> float) qui à une fonction retournerait une autre fonction.

Ta fonction serait du type (sin | cos | exp | opp) → (sin | cos | exp | opp),
pas du type (float → float) → (float → float).

Autrement dit il y a un type somme (le type des fonctions dérivables) que tu n'as pas explicité.
Commence par prouver que tes fonctions sont bien dérivables.
Les fonctions float → float ne sont pas dérivables, elles sont justes applicables.

• types sommes et types algébriques (cours/tutoriel)
• dérivation formelle (code exemple)