(** Quelques fonctions pathologiques **)




#open "graphics";;

(* Algorithme d'exponentiation rapide *)
let rec puiss_vit x n = 
	if n=0 then 1.
	else let r=n mod 2 in
		if r=0 then puiss_vit (x*.x) (n/2) else x*.(puiss_vit (x*.x) (n/2))
;;

(* La fonction de Bolzano *)
(* Dimension du carré où l'on trace *)
let taille = float_of_int(size_y());;

(* Crée la suite des pentes pour le rang n *)
let calcul_code liste = 
	let rec rcalcul result = function
		|[]	-> result
		|t::q -> rcalcul (2.*.t::-.t::2.*.t::result) q
in rcalcul [] liste
;;

let code n =
	let rec rcode result = function
		|0 -> result
		|n -> rcode (calcul_code result) (n-1)
in rcode [1.] n
;;

(* Tracé de la fonction de rang n *) 
let rec rtrace code (x,y) pas  = match code with
	|[]	-> ()
	|t::q -> let new_x=x+.pas and new_y=y+.t*.pas in
			begin
			moveto (int_of_float x) (int_of_float y);
			lineto (int_of_float new_x) (int_of_float new_y);
			rtrace q (new_x,new_y) pas;
			end
;;

let trace_Bolzano n = let pas=1./.(puiss_vit 3. n)*.taille
in rtrace (code n) (0.,0.) pas;;

(* Tracé de la fonction jusqu'au rang n *)
let trace_Bolzano_to n =
	let rec rtrace_to code = function
		|0 -> ()
		|k -> let pas=1./.(puiss_vit 3. (n-k))*.taille in
				begin
				rtrace code (0.,0.) pas;
				rtrace_to (calcul_code code) (k-1)
				end
in rtrace_to [1.] n
;;

open_graph "";;
trace_Bolzano_to 5;;

(* La fonction de Van der Waerden *)
(* Distance d'un réel à un entier *) 
let d x = let result=abs_float(x-.float_of_int(int_of_float x)) in
	if result<0.5 then result else 1.-.result
;;

(* Définition de la fonction de van der Waerden *) 
let f_VdW n x =
	let rec calcul result = function
		|0 -> (d x)+.result
		|k -> let temp=puiss_vit 4. k in calcul (1./.temp*.d(temp*.x)+.result) (k-1)
in calcul 0. n
;;

(* Tracé de la fonction f dans le carré [low_x,up_x]*[low_y,up_y] en prenant le plus de place sur l'écran *) 
let trace_fct f low_x up_x low_y up_y = 
	let larg_ecr=float_of_int (size_x()) and haut_ecr=float_of_int(size_y())
	and larg_virt=up_x-.low_x and haut_virt=up_y-.low_y in
	let convert_x x = (float_of_int x)/.larg_ecr*.larg_virt+.low_x
	and convert_y y = (int_of_float ((y-.low_y)/.haut_virt*.haut_ecr)) in
		begin
		for t=0 to (size_x()-1) do
			moveto t (convert_y (f(convert_x t)));
			lineto (t+1) (convert_y (f(convert_x (t+1))))
		done;
		end
;;

(* open_graph "";;
trace_fct sin (-.10.) 10. (-.1.) 1.;; *)

(* Tracé de la fonction de rang n et jusqu'au rang n *)
let trace_VdW n= open_graph ""; trace_fct (f_VdW n) 0. 1. 0. 0.65;;
let trace_VdW_to n = 
	open_graph "";
	for t=0 to n do trace_fct (f_VdW t) 0. 1. 0. 0.65 done
;;

trace_VdW_to 4;;