(* /!\ Code écrit par Lilian BESSON - LSV & CMLA & ENS de Cachan. Par respect des droits de propriétés intellectuelles, conservez ce bordereau si vous utilisez tout ou une partie de ce fichier. *) (* *) (* Plot : MOcaml *) (* *) (** {7 Plot : code ml pour ocamlc} *) (** *) (** Plot : Projet MOcaml *)(** ENS de Cachan - 2012 L3 Informatique Projet MOcaml v1.0.4 *)(** Besson Lilian. Inspiré de 'meta_plot.c' et 'script_metaplot.sh' écrits par Lilian Besson en Février 2012. (c) Naereen Corp. *) (* * Ce module fait partis du projet MOcaml, et utilise les modules ANSITerminal, et . * Pour plus de détails, voir la documentation du projet MOcaml, en ligne ou dans les README. *) (* ******************************************************************************************************************************************* *) (** Utilise le module ANSITerminal. *) module Top : sig type color = ANSITerminal.color = Black | Red | Green | Yellow | Blue | Magenta | Cyan | White | Default type style = ANSITerminal.style = Reset | Bold | Underlined | Blink | Inverse | Hidden | Foreground of color | Background of color val black : style val red : style val green : style val yellow : style val blue : style val magenta : style val cyan : style val white : style val default : style val on_black : style val on_red : style val on_green : style val on_yellow : style val on_blue : style val on_magenta : style val on_cyan : style val on_white : style val on_default : style val set_autoreset : bool -> unit val print_string : style list -> string -> unit val prerr_string : style list -> string -> unit val printf : style list -> ('a, unit, string, unit) format4 -> 'a type loc = ANSITerminal.loc = Eol | Above | Below | Screen val erase : loc -> unit val set_cursor : int -> int -> unit val move_cursor : int -> int -> unit val move_bol : unit -> unit val pos_cursor : unit -> int * int val save_cursor : unit -> unit val restore_cursor : unit -> unit val resize : int -> int -> unit val size : unit -> int * int val scroll : int -> unit end val line : unit -> int val column : unit -> int (** Récupère la taille de la fenètre ANSI. Ne fonctionne pas lors de l'utilisation d'un wrapper comme "ledit" ou "rlwrap". Par défaut, line = 36; column = 135, résolution de mon terminal en plein écran. L'amélioration du module ANSITerminal est en cours pour régler ça. C'est pas facile ! *) val arrayfloat_of_arrayint : int array -> float array (** Change un tableau d'entiers en tableau de flottants. *) val bool_of_int : int -> bool val int_of_bool : bool -> int (** Conversions entiers et booléens. *) val bool_of_float : float -> bool val float_of_bool : bool -> float (** Conversions entiers et flottants. *) val maxof_array : 'a array -> 'a (** Calcul du max. *) val minof_array : 'a array -> 'a (** Calcul du min. *) exception Mauvaise_valeur_gauche (** Si le programme cherche à évaluer une valeur trop a gauche (bug). *) exception Mauvaise_valeur_droite (** Si le programme cherche à évaluer une valeur trop a droite (bug). *) exception Dessin_impossible (** Si les paramètres du tracé font qu'il est impossible a réaliser. Par exemple si [maxx] < [minx] ou [maxy] < [miny]. *) val getchar : unit -> char (** Comme le getchar du C. *) val plot_array : vect:float array -> ?title:string -> ?param:bool -> ?mon_out:out_channel -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?full_ascii:bool -> unit -> unit (** Affiche les valeurs d'un tableau. @param vect Le tableau a afficher, @param title Le titre du graphique produit, @param param Paramêtre de contrôle, @param mon_out Out_channel ou écrire le graphique, valant par défaut le channel de sortie [stdout], @param minx A faire, @param maxx A faire, @param miny A faire, @param maxy A faire. @param full_ascii Renseigne si tout les caractères baroques peuvent être affichés. Dans certain terminaux, non. Si vous voyez qu'un dessin ne se fait pas avec les flèches normales, continuez avec ~full_ascii:false. *) val plot_list : liste:float list -> ?title:string -> ?param:bool -> ?mon_out:out_channel -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?full_ascii:bool -> unit -> unit (** Idem, mais avec une liste. *) val plot_array_int : vect:int array -> ?title:string -> ?param:bool -> ?mon_out:out_channel -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?full_ascii:bool -> unit -> unit (** Idem, mais avec un tableau d'entiers. *) val plot_list_int : liste:int list -> ?title:string -> ?param:bool -> ?mon_out:out_channel -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?full_ascii:bool -> unit -> unit (** Idem, mais avec une liste d'entiers. *) (** {6 Avec support de la couleur du module ANSITerminal.} *) val plotC_array : vect:float array -> ?title:string -> ?param:bool -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?full_ascii:bool -> unit -> unit (** Affiche les valeurs d'un tableau. @param vect Le tableau a afficher, @param title Le titre du graphique produit, @param param Paramêtre de contrôle, @param mon_out Out_channel ou écrire le graphique, valant par défaut le channel de sortie [stdout], @param minx A faire, @param maxx A faire, @param miny A faire, @param maxy A faire. Supporte les couleurs ANSI pour faire un graphe plus joli. *) (** {6 Pour afficher des fonctions.} *) val array_of_fun : ?minx:float -> ?maxx:float -> ?nb:int -> f:(float -> 'a) -> 'a array (** Donne un tableau de valeurs pour une fonction float -> float. *) val array_int_of_fun : ?minx:float -> ?maxx:float -> ?nb:int -> f:(int -> 'a) -> 'a array (** Donne un tableau de valeurs pour une fonction int -> int. *) val plot_fun : ?title:string -> ?param:bool -> ?mon_out:out_channel -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?nb:int -> ?full_ascii:bool -> f:(float -> float) -> unit -> unit (** Dessine le graphique d'une fonction float -> float. *) val plotC_fun : ?title:string -> ?param:bool -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?nb:int -> ?full_ascii:bool -> f:(float -> float) -> unit -> unit (** Dessine le graphique d'une fonction float -> float, avec couleurs ANSI. *) val plot_fun_int : ?title:string -> ?param:bool -> ?mon_out:out_channel -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?nb:int -> ?full_ascii:bool -> f:(int -> float) -> unit -> unit (** Dessine le graphique d'une fonction float -> float. *) val plotC_fun_int : ?title:string -> ?param:bool -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?nb:int -> ?full_ascii:bool -> f:(int -> float) -> unit -> unit (** Dessine le graphique d'une fonction float -> float, avec couleurs ANSI. *) (** {6 Avec un support de la couleur customisable.} *) val plotCc_array : vect:float array -> ?style_fond:ANSITerminal.style list -> ?style_axe:ANSITerminal.style list -> ?style_pt:ANSITerminal.style list -> ?full_ascii:bool -> ?title:string -> ?param:bool -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> unit -> unit (** Affiche les valeurs d'un tableau. @param vect Le tableau a afficher, @param title Le titre du graphique produit, @param param Paramêtre de contrôle, @param mon_out Out_channel ou écrire le graphique, valant par défaut le channel de sortie [stdout], @param minx A faire, @param maxx A faire, @param miny A faire, @param maxy A faire. Supporte les couleurs ANSI pour faire un graphe plus joli, et ces paramètres de mises en formes ANSI sont customisables : @param style_axe Définit le style des axes, @param style_fond Définit le style du fond, @param style_pt Définit le style des points. Pour plus de détails sur le type ANSITerminal.style, voir la documentation incluse dans le Readme. *) (** {6 Styles ANSI} *) (** Voici un rappel des styles disponibles dans le module ANSITerminal : type color = ANSITerminal.color = Black | Red | Green | Yellow | Blue | Magenta | Cyan | White | Default type style = ANSITerminal.style = Reset | Bold | Underlined | Blink | Inverse | Hidden | Foreground of color | Background of color *) val plotCc_fun : f:(float -> float) -> ?style_fond:ANSITerminal.style list -> ?style_axe:ANSITerminal.style list -> ?style_pt:ANSITerminal.style list -> ?full_ascii:bool -> ?title:string -> ?param:bool -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?nb:int -> unit -> unit (** Dessine le graphique d'une fonction float -> float, avec couleurs ANSI customisables. *) val plotCc_fun_int : f:(int -> float) -> ?style_fond:ANSITerminal.style list -> ?style_axe:ANSITerminal.style list -> ?style_pt:ANSITerminal.style list -> ?full_ascii:bool -> ?title:string -> ?param:bool -> ?minx:float -> ?maxx:float -> ?miny:float -> ?maxy:float -> ?nb:int -> unit -> unit (** Dessine le graphique d'une fonction float -> float, avec couleurs ANSI customisables. *) (** {6 Un essai d'extension de syntaxe} *) (** Afin de se rapprocher de la syntaxe de plot en Maple par exemple. *) val ( -- ) : 'a -> 'b -> 'a * 'b (** Pour créer un interval. *) val plot : ?full_ascii:bool -> (float -> float) * ('a * 'b) -> unit (** Syntaxe améliorée. Essayez : [plot(cos,0--7);;] *) (** {5 Un eval style Maple : très très salement codé en ocaml...} *) val evals : ?p:int -> ?nomv:string -> ?x:'a -> string -> float (** Permet d'évaluer le contenu d'une string ocaml. @param p Renseigne sur la précision maximum du calcul effectuée. En béta. @param nomv Chaine de caractère renseignant sur le nom de la variable libre de l'expression calculée. Par défaut = "x". @param x Valeur de la variable libre. Ces trois paramètres sont optionnels, et par défaut x = 0.0. @param chaine_f Chaine qu'on cherche à évaluer. *) val eval : ?nomv:string -> ?x:'a -> 'b -> float (** Et cette fonction permet d'évaluer un élément ocaml. Si le type de l'élément n'est pas simple, 0.0 est renvoyé. @param nomv Nom de l'éventuelle variable libre de l'expression. @param x Valeur de cette variable libre. @param xpoly Elément a évaluer. Fonctionne si est un entier, un flottant, un booléen, ou une chaine. Les résultats pour les autres types sont aléatoires. *) val pplot : ?nomv:string -> ?full_ascii:bool -> 'a -> 'b * 'c -> unit (** On utilise donc tout ca pour proposer une méthode de dessin de graphe, fortement polymorphique, mais très très salement codée (Si vous pensez que j'exagère ou si vous pensez le contraire, jetez un oeil attentif a ce qui est fait dans ce programme et dans le module Surcharge : c'est sale !) @param xpoly Peut être une constante, entière ou flottante, ou une chaine. Ce second cas n'a d'intéret que si la chaine dépend d'une variable libre, @param nomv Et ce second paramètre est justement le nom de cette variable libre. Par défaut, "x". *) (** Pour le moment, sans vraiment de raison, c'est très lent. En béta ! *) val polyPlot : ?nomv:string -> ?range:'a * 'b -> ?full_ascii:bool -> 'c -> unit (** Le mieux que j'ai pu faire. On a ici une fonction qui peut afficher : des constantes entières ou flottantes, des tableaux ou des listes d'entiers ou de flottants, et des chaines de caractères représentant des expressions ayant une variable libre. Ca marche très bien ! Mais qu'est-ce que c'est sale... Et c'est lent pour les chaines de caractères. Essayez : polyPlot ~range:(0--1) "acos(x)";; polyPlot ~range:(-7,7) "cos(2*x)";; let a = Array.create 500 0 in for i=0 to 499 do a.(i) <- 7*i+9*i*i+3; done polyPlot a;;*) (* Merci a Romain Vernoux pour l'idée sur la surcharge. *) (* /!\ Code écrit par Lilian BESSON - LSV & CMLA & ENS de Cachan. Par respect des droits de propriétés intellectuelles, conservez ce bordereau si vous utilisez tout ou une partie de ce fichier. *)