(* derivee.ml *)

(** Le type des expressions. *)
type exp =
    N of int
  | Var of char
  | Add of exp * exp
  | Mul of exp * exp
  | Pui of exp * int

(* Des exemples d'expressions. *)
let e1 = N 4 ;;
let e2 = Var 'y' ;;
let e3 = Add (e1, e2) ;;
let e4 = Mul (Var 'a', Var 'x') ;;
let e5 = Pui (Var 'x', 2) ;;
let e6 = Add (e1, Add (e4, Mul (Var 'b', e5))) ;;

(** (string_of_exp e) retourne une chaîne représentant l'expression e en
  notation infixe totalement parethésée. *)
let rec string_of_exp = function
    N n -> string_of_int n
  | Var v -> Char.escaped v
  | Add (e1, e2) -> "(" ^ string_of_exp e1 ^ " + " ^ string_of_exp e2 ^ ")"
  | Mul (e1, e2) -> "(" ^ string_of_exp e1 ^ "*" ^ string_of_exp e2 ^ ")"
  | Pui (e, n) -> "(" ^ string_of_exp e ^ "^" ^ string_of_int n ^ ")" ;;

string_of_exp e1 ;;
string_of_exp e2 ;;
string_of_exp e3 ;;
string_of_exp e4 ;;
string_of_exp e5 ;;
string_of_exp e6 ;;

(** deriv x e) retourne une expression, dérivée de e par rapport à x. *)
let deriv x =
  (** (aux e) retourne une expression, dérivée de e par rapport à x. *)
  let rec aux = function
      N _ -> N 0
    | Var v -> if v = x then N 1 else N 0
    | Add (e1, e2) -> Add (aux e1, aux e2)
    | Mul (e1, e2) -> Add (Mul (e2, aux e1), Mul (e1, aux e2))
    | Pui (e, n) -> Mul (Mul (N n, Pui (e, n-1)), aux e)
  in aux ;;

string_of_exp e1 ;;
deriv 'x' e1 ;;
string_of_exp e2 ;;
deriv 'x' e2 ;;
string_of_exp e3 ;;
deriv 'x' e3 ;;
string_of_exp e4 ;;
deriv 'x' e4 ;;
string_of_exp e5 ;;
deriv 'x' e5 ;;
string_of_exp e6 ;;
deriv 'x' e6 ;;

let e =			(* ax^3 + bx^2 + cx + d *)
  let a = Mul (Var 'a', Pui (Var 'x', 3)) in
  let b = Mul (Var 'b', Pui (Var 'x', 2)) in
  let c = Mul (Var 'c', Var 'x') in
    Add (Add (Add (a, b), c), Var 'd') ;;

string_of_exp e ;;
let d = deriv 'x' e ;;
string_of_exp d ;;