(****** EAP ******)

open List;;

(* Evaluation d'expressions algébriques postfixées numériques *)
type 'a eap_elt =
	|Nb of 'a
	|Op of ('a -> 'a -> 'a)
	|Fct of ('a -> 'a)
;;

let evalue_eap a =
	let accu = ref [] in
		let push x= accu:=x::!accu
		and pop () = match !accu with
					|[]->failwith "Erreur de syntaxe : trop d'opérateurs"
					|t::q->accu:=q; t
in	let rec eval b = 
		match b with
			|[]->()
			|(Nb x)::r -> push x; eval r;
			|(Fct f)::r -> let x=pop() in	(push(f x);	eval r)
			|(Op c)::r -> let y=pop() in let x=pop() in (push(c x y);eval r)
in	eval a;
	match !accu with
		|[]->failwith "Erreur de syntaxe : trop d'opérateurs"
		|[r]->r
		|_->failwith "Erreur de syntaxe : trop de nombres"
;;

let plus a b = a +. b;;
let moins a b = a -.b;;
let fois a b = a *. b;;
let divi a b= a /. b;;

evalue_eap [Nb 2.;Nb 4.;Nb 5.;Op plus;Op moins];; 		(* 2-4+5 = -7 *) 
evalue_eap [Nb 2.;Nb 3.;Fct sin;Op plus;Op fois];;		(* sin(3) + 2 * .... *)
evalue_eap [Nb 2.;Nb 3.14;Fct sin;Op plus];;			(* sin(5) + 3.14 = 2.00159265292 *) 

evalue_eap [Nb 2.;Nb 7.;Nb 4.;Op moins;Op fois];;		(* 2*(7-4) = 6 *) 
evalue_eap [Nb 1.;Nb 3.;Fct sin;Nb 7.;Op plus;Nb 5.;Nb 4.;Nb 2.;Fct cos;Op plus;Op divi;Op fois;Op plus];;
(* = 10.9629081918 *) 
evalue_eap [Nb 2.;Nb 3.;Nb 5.;Fct sin;Op fois;Nb 4.;Op plus;Nb 6.;Nb 3.;Fct cos;Op fois;Op divi;Op plus];;
(* = 1.81090308262 *) 

(* Evaluateur d'expressions algébriques postfixées ensemblistes *) 
type 'b ensemble = Ens of 'b list;;
type 'b eap_ens_elt = 
	| Set of 'b ensemble
	| Op of ('b ensemble -> 'b ensemble -> 'b ensemble)
	| Fct of ('b ensemble -> 'b ensemble)
;;
	
let evalue_eap_elt a =
	let accu = ref [] in
		let push x= accu:=x::!accu
		and pop () = match !accu with
					|[]->failwith "Erreur de syntaxe : trop d'opérateurs"
					|t::q->accu:=q; t
in	let rec eval b = 
		match b with
			|[]->()
			|(Set x)::r -> (push x; eval r)
			|(Fct f)::r -> let x=pop() in (push(f x); eval r)
			|(Op c)::r -> let y=pop() in let x=pop() in (push(c x y);eval r)
in	eval a;
	match !accu with
		|[]->failwith "Erreur de syntaxe : trop d'opérateurs"
		|[r]->r
		|_->failwith "Erreur de syntaxe : trop d'ensembles"
;;

(* Transformation d'une liste en ensemble (sans répétition) *) 
let ens_of_list liste =
	let rec sol l1 l2 = match l1 with
		|[]->l2
		|t::q-> if (mem t q) then sol q l2
					   else sol q (t::l2)
	in Ens (sol liste [])
;;

(* Union d'ensembles *)
let union (Ens l1) (Ens l2) = ens_of_list (l1 @ l2);;

(* Intersection d'ensembles *) 
let inter (Ens l1) (Ens l2) =
	let rec toto liste comparaison = match liste with
			|[]->[]
			|t::q-> if (mem t comparaison) then t::(toto q comparaison)
								 else toto q comparaison
in	ens_of_list (toto l1 l2);;

(* Différence d'ensembles *) 
let diff (Ens l1) (Ens l2) =
	let rec titi liste comparaison = match liste with
			|[]->[]
			|t::q-> if (mem t comparaison) then titi q comparaison
								 else t::(titi q comparaison)
in	ens_of_list (titi l1 l2);;

(* Différence symétrique d'ensembles *) 
let diff_sym ens1 ens2 = diff (union ens1 ens2) (inter ens1 ens2);;

(* Complémentaire (pour les ensembles d'entiers uniquement) *)
let max_int=9999;;
let range n =
	let rec tata n p = match n with
					|0->[]
					|n->p::(tata (n-1) (p+1))
in	tata n 0;;
let ens_entier = Ens(range max_int);;

let compl set = diff ens_entier set;;