Développeur : OCaml 3.10.0 est sorti

Posté par tuiu pol (Jabber id, ). Modéré le 23 mai 2007.

Le 16 mai est sorti la version 3.10.0 de Objective Caml, implémentation du langage Caml (Categorical Abstract Machine Language) créé par l'INRIA.

Objective Caml est la principale variante du langage Caml. Du point de vue du langage, elle étend le noyau du langage Caml avec une couche orientée objets complète, ainsi qu'un système de modules puissant. Un système de types polymorphe avec inférence automatique des types assure la cohérence de ces traits. Le langage est entièrement développé et maintenu par l'INRIA. Il est distribué sous licence QPL 1.0 tandis que les bibliothèques sont sous licence LGPL 2.

En plus des sources, des binaires sont proposés pour GNU/Linux (format RPM, deb ou Gentoo) et pour Win32. Les binaires Mac OS X ne sont pas encore disponibles.

NdR: Merci à benja pour son journal.

L'annonce sur le site de l'INRIA (698 hits)
La page de téléchargement (213 hits)
La licence (131 hits)
Le changelog complet (178 hits)
Pour creuser : les livres sur le langage (360 hits)
DLFP : le journal d'origine (209 hits)

> Lire la dépêche (88 commentaires, moyenne: 2,6).

Vous avez demandé le commentaire #835173.

Lisibilité et produit de matrices

Posté par judicael () le 25/05/2007 à 06:57. (lien). Évalué à 6.

Pour répondre à quelques objections sur la lisibilité, il me semble que tout langage permet d'écrire des choses illisibles (à partir du moment où il est Turing complet du moins). Un bon langage de programmation à mon sens est un langage qui permet d'écrire lisiblement. Dans pas mal de situations, Caml permet d'écrire lisiblement là où ni C ni Java ne le permettent (et la réciproque est plutôt rare).
Un code caml qui implante le produit de matrice peut être tout à fait lisible en fonctionnel et bien plus lisible que les versions impératives : deux fonctions auxiliaires (sigma et init_matrix) d'une ligne et une ligne pour le produit en lui même. C'est très lisible à partir du moment où on sait que "(fun i j -> expr)" désigne la fonction qui à i et j associe "expr".
Comme je ne suis pas doué, j'ai évidemment fait beaucoup d'erreurs en écrivant le code ci-dessous. Le compilo caml les a toutes corrigées, sauf une dans la fonction sigma qui conduisait à une boucle infinie systématiquement. Correction du bug -> tout baigne. C'est pas en C ni en Java qu'on aurait le même confort.

Cas des matrices de taille n fixée :

(* Fonction d'intérêt général *)
(* Calcule (f i) + (f (i+1) + ... + (f j) *)
let rec sigma i j f = if j < i then 0. else (f i) +. sigma (i+1) j f;;

(* taille des matrices *)
let n = ...

(* Construit la matrice des (f i j) *)
let init_matrix f = Array.init n (fun i -> Array.init n (fun j -> f i j));;

(* somme de matrices, juste pour s'amuser *)
let sum p1 p2 = init_matrix (fun i j -> p1.(i).(j) +. p2.(i).(j));;
;;

let prod p1 p2 =
  init_matrix (fun i j -> sigma 0 (n-1) (fun k -> p1.(i).(k) *. p2.(k).(j)))
;;

Cas des matrices de taille dynamique :

(* Calcule (f i) + (f (i+1) + ... + (f j) *)
let rec sigma i j f = if j < i then 0. else (f i) +. sigma (i+1) j f;;

(* construit la matrice des (f i j), 0<=i<n, 0<=j<m *)
let init_matrix n m f =
  Array.init n (fun i -> Array.init m (fun j -> f i j))
;;

(* dimensions d'une matrice *)
let dim_matrix p =
  let n = Array.length p in
  assert (n<>0);
  let m = Array.length p.(0) in
  (n,m)
;;

(* somme de matrices, juste pour s'amuser *)
let sum p1 p2 =
  let (n1,m1) = dim_matrix p1
  and (n2,m2) = dim_matrix p2 in
  assert (n1 = n2 && m1 = m2);
  init_matrix n1 m1 (fun i j -> p1.(i).(j) +. p2.(i).(j))
;;

let prod p1 p2 =
  let (n1,m1) = dim_matrix p1
  and (n2,m2) = dim_matrix p2 in
  assert (m1 = n2);
  let c i j = sigma 0 (m1-1) (fun k -> p1.(i).(k) *. p2.(k).(j)) in
  init_matrix n1 m2 c
;;

[^]Re: Lisibilité et produit de matrices

Posté par Pierre Tramonson () le 25/05/2007 à 12:43. (lien). Évalué à 2.
Dans pas mal de situations, Caml permet d'écrire lisiblement là où ni C ni Java ne le permettent (et la réciproque est plutôt rare).

Suivi d'un tas de code incompréhensible...

Je ne suis pas sur que la démonstration soit convaincante.
- [^]Re: Lisibilité et produit de matrices
  
  Posté par L (page perso, ) le 25/05/2007 à 12:55. (lien). Évalué à 1.
  Pareil : il faudrait voir l'équivalent en C ou Java ou autre pour comparaison. Pour ma part, je n'ai rien compris à son code.
  - [^]Re: Lisibilité et produit de matrices
    
    Posté par Gniarf () le 25/05/2007 à 13:06. (lien). Évalué à 2.
    ou en Perl
    
    no, wait...
    
    --
    Windows has no users. It has hostages.
    
    [^]Re: Lisibilité et produit de matrices
    
    Posté par fmaz fmaz () le 25/05/2007 à 14:43. (lien). Évalué à 4.
    C'est vraiment question d'habitude.
    
    Il part du principe qu'une matrice, c'est un tableau dont on veut remplir les cases.
    
    Pour cela, il utilise la fonction
    > let init_matrix f = Array.init n (fun i -> Array.init n (fun j -> f i j));;
    
    qui prend en paramètre une fonction f à deux arguments et qui construit la matrice
    f(0,0), f(0,1), f(0,2), f(0,3),...
    f(1,0), f(1,1), f(1,2),...
    f(2,0), f(2,1),...
    f(3,0),...
    
    Une fois qu'on a cette fonction, il suffit de donner en paramètre la fonction qui calcule le coëfficient. Je trouve cette approche très élégante.
    
    Pour l'addition, c'est la fonction
    > fun i j -> p1.(i).(j) +. p2.(i).(j)
    qui me semble vraiment lisible.
    
    Pour la multiplication, c'est la fonction
    > fun i j -> sigma 0 (n-1) (fun k -> p1.(i).(k) *. p2.(k).(j))
    Cette fonction est un poil plus compliquée mais pas trop.
    il a d'abord défini la fonction
    sigma i j f ->
    qui calcule f(i)+. ...+.f(j)
    
    ainsi, sigma 0 (n-1) (fun k -> p1.(i).(k) *. p2.(k).(j))
    calcule p1.(i).(0)*p2.(0).(j)+. ... +. p1.(i).(n-1)*p2.(n-1).(j), ce qui est bien la valeur voulue.
    
    Pour définir la matrice identité, on utilise
    fun i j -> if i=j then 1. else 0.
    
    etc...
    
    Bref, ce n'est pas parce que vous n'avez pas l'habitude de programmer de façon fonctionnelle que son code n'est pas élégant.
    - [^]Re: Lisibilité et produit de matrices
      
      Posté par bluestorm () le 25/05/2007 à 17:19. (lien). Évalué à 2.
      Tout à fait d'accord !
      
      D'ailleurs, je trouve rigolo de constater que ce qui rend son code beaucoup plus lisible que le mien là haut, c'est qu'il colle plus aux méthodes usuelles en mathématique; par exemple, la fonction sigma qui me paraît au premier abord le mélange obscur d'un init et d'un fold_left, est en fait plus naturelle à utiliser dans ce contexte que les init et les fold_left qui vont bien, parce qu'elle reflète l'écriture mathématique.
      
      Ma deuxième erreur a été de ne pas extraire le principe du double init : lui donner un nom (ici init_matrix) aide indéniablement à la compréhension.
[^]Re: Lisibilité et produit de matrices

Posté par Moonz () le 25/05/2007 à 16:27. (lien). Évalué à 2.
> Le compilo caml les a toutes corrigées
Heu...
On va dire que j'ai mal compris, là. Tu peux expliciter ? Parce que un compilo qui corrige tout seul des trucs, moi ça a plutôt tendance à me faire peur...
- [^]Re: Lisibilité et produit de matrices
  
  Posté par MiniMoi () le 25/05/2007 à 18:48. (lien). Évalué à 1.
  Je pense que ce qu'il veut dire, et que tout les programmeurs OCaml ont expérimenté, c'est que le typage strict d'OCaml, associé aux avertissements en cas de filtrage non exhaustifs (ou le programmeur n'a pas envisagé tous les cas) permet au compilateur de lever des erreurs su beaucoup plus de cas.
  
  Donc en fait si ton code compiles, il a beaucoup moins d'erreurs possibles que ton code C qui compile...
  
  Par ailleurs la programmtion en Caml est souvent plus "sûre" car elle permet de coller de près aux concepts mathématiques. En effet de très nombreux algorithmes sont définis par des récursions, ou par "induction", ce qui se traduit littéralement en Caml...

Développeur : OCaml 3.10.0 est sorti

Lisibilité et produit de matrices

[^]Re: Lisibilité et produit de matrices

[^]Re: Lisibilité et produit de matrices

[^]Re: Lisibilité et produit de matrices

[^]Re: Lisibilité et produit de matrices

[^]Re: Lisibilité et produit de matrices

[^]Re: Lisibilité et produit de matrices

[^]Re: Lisibilité et produit de matrices