Document lu mais pas compilé par caml

Bonjour,

Je suis en train de réaliser un exposé. Dans celui-ci, je souhaite réaliser un programme en caml light, seulement je rencontre un problème. J'ai créé un fichier catalogue.ml dans lequel j'ai mis beaucoup de vecteurs avec des types abréviation de float ou int.
Je fais appel à ce document par des include dans mon programme principale.
Mon problème est le suivant : le document est tellement gros que caml bug une fois sur deux à la compilation (pour un ordre d'idée, mes vecteurs ont des tailles allant de 4 à 2000 valeurs)
Est-il possible que mon programme ne fasse que aller chercher les info dans catalogue mais ne compile pas le catalogue?
J'ai vu une fonction compile mais je ne comprend pas comment elle fonctionne et je ne sais pas trop non plus si cette fonction fais ce que je veux.

Merci

Plutôt que d'entrer les données de ton programme sous forme de code OCaml, tu devrais les entrer dans un fichier texte. Mets les dans un format de ton choix, et écris un petit programme caml qui aille lire ce fichier et construire, au moment de l'exécution de ton programme, la structure de donnée correspondante.

C'est un peu plus chiant parce que tu dois écrire le "parser" (le programme qui passe de la représentation textuelle aux données structurées) toi-même au lieu d'utiliser le compilateur caml pour cela, mais sur de grosses données ça marche beaucoup mieux.

Une fois que tu auras choisi un format facile à parser (si tu veux, on peut te donner des conseils, mais il faut donner plus de détails sur tes données), tu n'as pas besoin de tout ré-écrire à la main dans ton fichier : tu peux écrire un code qui prend les données compilées par Caml (comme tu fais actuellement) et qui génère le fichier texte correspondant.

Bonjour,

Merci pour la réponse.

Juste pour être sur : que l'on travail en Ocaml ou en caml light c'est pareil? Parce que je ne connaît que caml light.

Par ailleurs, j'ai vu dans un livre quelque chose sur parse, camllex et camllyacc. Ce livre n'est pas franchement génial pour la clarté des explications sur le fonctionnement de caml light. Est-ce bien de ce parse dont il est question, car je n'ai pas du tout compris comment il fonctionne.

Pour la présentation actuelle de mon catalogue, cela donne ça :

type de == float;;
type mg == int;;

et en suite il y a une vingtaine de tableaux du style de ceux ci-desous :

let (A : de vect) = [|6.98298;14.65140;39.705945;33.242451;357.266|];;

let (B : de vect) = [|6.82136;14.65451;9.705945;353.242451;357.2366|];;

(Certains tableaux contiennent 2000 valeurs)

Le fichier catalogue est inclue par des include dans le fichier principale où se trouvent des fonctions qui vont chercher seulement certains tableaux et s'applique sur ces tableaux sélectionnés par une boucle à tout le tableau.
Le type mg peut être retiré si besoin, car il ne sert pas dans le catalogue même, mais dans la suite du programme.

Merci

Oui, je parle d'une méthode générale pour ce type de problèmes, ça marche aussi bien sous Ocaml que Caml Light (la seule différence c'est que le compilateur OCaml ne plante pas, donc tu peux utiliser ta méthode actuelle même sur de gros fichiers).

L'idée du "parser" est sans doute la même que dans ton livre, mais ce n'est pas forcément la même mise en place. Ce que je propose est très simple :
- au lieu de mettre tous tes nombres dans des tableaux caml, tu les mets dans un fichier texte normal, avec par exemple un nombre par ligne
- quand tu exécutes ton programme Caml, tu lui demandes d'aller lire ce fichier texte (fonctions d'entrée/sortie simples à utiliser), et d'y récupérer les valeurs

Ainsi, si ton programme met ces valeurs dans un tableau par exemple, tu te retrouveras avec exactement le contenu de tes tableaux A, B, .., mais au lieu d'avoir été compilés, ces tableaux sont recréés dynamiquement, à chaque lancement du programme, à partir du contenu du fichier texte.


La difficulté principale de la méthode que je propose, c'est l'écriture de la fonction qui va lire le fichier texte et te donne les tableaux. Plus les données que tu veux stocker dans ce fichier sont complexes (structures imbriquées, types de données différents, etc.), plus cette fonction sera compliquée. Dans ton cas, tu as des structures très simples, donc ça devrait être facile à faire.

Voilà l'organisation que je te propose : ton fichier texte contient un nombre par ligne, à savoir :
- dans la première ligne, le nombre de tableaux stockés dans le fichier
- pour chaque tableau (donc une fois par tableau) :
--- une ligne qui indique le nombre d'éléments du tableau
--- pour chaque élément, une ligne qui contient cet élément

Par exemple, les données que tu donnes seraient stockées sous la forme suivante :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

2 5 6.98298 14.65140 39.705945 33.242451 357.266 5 6.82136 14.65451 9.705945 353.242451 357.2366

---

Bien sûr, si tu connais à l'avance le nombre de tableaux et leur taille, tu n'es pas obligé de le préciser, mais ça peut te donner un peu de flexibilité si tu veux changer ton jeu de données par la suite.

Si tu as un fichier sous cette organisation, il te suffit d'écrire une fonction qui lit le contenu de ce fichier ligne par ligne (avec les fonctions "read_int" et "read_float"), et qui construit un tableau de tableaux. Dans ton cas, il construirait un tableau contenant ton tableau A en position 0, et ton tableau B en position 1.

Je ne comprend pas très bien en quoi la manip qu'il faut faire ne fait pas de compilation, mais seulement de la lecture.

Je viens d'essayer de faire la fonction de lecture du fichier, et cela donne cela :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

let lect () = let a = input_value (open_in "catalogue.txt") in let taille = read_int a in let catalog = make_vect taille [|0.|] in for i = 0 to (taille-1) do let tailleTableau = read_int a in let tableau = make_vect tailleTableau 0. in for j = 0 to (tailleTableau-1) do tableau.(j) <- read_float a done; catalog.(i) <- tableau done; catalog;; lect ();;

---

Le terminal me renvoie :
lect : unit -> float vect vect = <fun>
Exception non rattrapée: Failure "intern: bad object"

Je ne comprend pas pourquoi.
Je ne suis pas sur de ma fonction, car je n'ai jamais utilisé les canaux, les open_ in, input_value etc. J'ai essayer de faire ce que je pouvais avec le livre que j'ai, mais ces fonctions ne sont pas très claires.

Salut !

Citation:

---

Envoyé par Cramer

Je ne comprends pas très bien en quoi la manip qu'il faut faire ne fait pas de compilation, mais seulement de la lecture.

---

Bah un fichier texte auxiliaire n'est pas compilé. Il peut donc contenir toutes les données que tu veux sans faire planter Caml Light.

Citation:

---

Envoyé par Cramer

Je viens d'essayer de faire la fonction de lecture du fichier

---

Ce code contient des maladresses, mais cela se comprend vu que tu n'as pas utilisé les canaux auparavant. La règle veut que tout canal ouvert soit fermé à un moment ou à un autre. En d'autres termes, un code qui contient un appel à open_in sans un appel ultérieur à close_in est maladroit. Ensuite, le code dans son ensemble est trop dans le style impératif pour être du caml authentique. Regarde la documentation de Caml Light : tu as a ta disposition des fonctions comme init_vect qui peuvent t'être très utiles :

Code:

---

1 2 3 4 5 6 7 8 9 10

let read file = let ich = open_in file in let len = int_of_string (input_line ich) in let t = init_vect len (fun _ -> let len = int_of_string (input_line ich) in init_vect len (fun _ -> float_of_string (input_line ich)) ) in close_in ich; t

---

Attention : ce code a été testé avec OCaml. J'ai juste fait des remplacements en regardant la documentation pour avoir le code Caml Light correspondant. Je ne garantis donc pas qu'il fonctionne tel quel...

Remarque 1 : il y a plein de fonctions de conversion des chaînes vers les entiers et les flottants, ainsi que des appels à input_line. Par précaution, il vaut sans doute mieux tout regrouper dans try with et se préparer à une levée d'exception. Ce ne sont pas les occasions qui manque.

Remarque 2 : Tu peux essayer de factoriser encore un peu ce code.

<mode troll=on>De toutes façons, Caml Light c'est le mal<mode troll=off> ;)

Cordialement,
Cacophrène

Bonsoir,

Merci à tous, c'est super, ça marche impeccable. J'ai pas le temps de faire load que le programme a fini de s'exécuter. Alors qu'avant, quand ça bugait pas, il fallait attendre longtemps.

Le code de Cacophrene marche. J'ai dû le réadapter, car je ne connaissais pas toutes les fonctions utilisées même si je comprenais l'idée.

Merci encore.

Citation:

---

et en suite il y a une vingtaine de tableaux du style de ceux ci-desous :

let (A : de vect) = [|6.98298;14.65140;39.705945;33.242451;357.266|];;

let (B : de vect) = [|6.82136;14.65451;9.705945;353.242451;357.2366|];;

(Certains tableaux contiennent 2000 valeurs)

---

Il n'est pas recommandé d'écrire de longues séquences (plusieurs milliers d'entrées) dans les sources Caml.
Caml-Light peut planter et OCaml peut ralentir considérablement au point qu'on se demande s'il a planté ou non.
Je ne sais pas si ce problème de performance vient de l'analyse syntaxique ou de la synthèse de types.

Certains exemples comme :

Code:

---

1 2 3 4 5

type product_id = | MyProduct_1 | MyProduct_2 ... | MyProduct_2000

---

me font penser que le coupable c'est la méthode automatique qu'utilise Caml pour son analyse syntaxique et dont la performance pourrait dégénérer dans les cas de sources atypiques.