CORRIGE TP 1 Exercice 1.

CORRIGE TP 1
Exercice 1.
# let x=5;;
val x : int = 5
# let x=6 in x*x ;;
- : int = 36
# x ;;
- : int = 5
# x = 4 ;;
- : bool = false
# let y= (let x = 4 in x+3) ;;
val y : int = 7
# let f = function x -> x+2 ;;
val f : int -> int =
# f 5 ;;
- : int = 7
# f (5) ;;
- : int = 7
# (f 5) ;;
- : int = 7
# let f x = x+2 ;;
val f : int -> int =
# f (3 * 7) ;;
- : int = 23
# (* attention *) f 3 * 7 ;;
- : int = 35
# let val_abs x = if x int =
# let f2 x y =
let z = x-y in
if z>0 then z else x;;
val f2 : int -> int -> int =
# f2 3 8 ;;
- : int = 3
# f2 9 2 ;;
- : int = 7
# let f3 x y =
let z = x*x in
let w = z-y in
if w>0 then w else z ;;
val f3 : int -> int -> int =
# f3 5 2 ;;
- : int = 23
# f3 2 13 ;;
- : int = 4
# let f4 = f3 5 ;;
val f4 : int -> int =

# f4 2 ;;
- : int = 23
# let f5 x = f3 x 13 ;;
val f5 : int -> int =
# f5 2 ;;
- : int = 4
# (* la meme, version non curryfiee *)
let f3 = function (x,y) ->
let z = x*x in
let w = z-y in
if w>0 then w else z ;;
val f3 : int * int -> int =
# f3 (5,2);;
- : int = 23
# let f4 = function y -> f3 (5,y) ;;
val f4 : int -> int =
# f4 2 ;;
- : int = 23
# let f5 x = f3 (x,13) ;;
val f5 : int -> int =
# f5 2;;
- : int = 4
# let ident = function x -> x ;;
val ident : 'a -> 'a =
# ident 7 ;;
- : int = 7
# ident "salut" ;;
- : string = "salut"
# let polynome a b c x =
(float_of_int a) *. x *. x +. (float_of_int b) *. x
+. float_of_int c ;;
val polynome : int -> int -> int -> float -> float =
# let poly1 = polynome 3 (-2) 2 ;;
val poly1 : float -> float =
# poly1 8.5 ;;
- : float = 201.75
Exercice 2.
# let subfg f g x = f(x) - g(x) ;;
val subfg : ('a -> int) -> ('a -> int) -> 'a -> int =
# let g1 x = x * x ;;
val g1 : int -> int =
# let g2 x = x - 1 ;;
val g2 : int -> int =
# let a = 4 ;;
val a : int = 4
# subfg g1 g2 (a + 2) ;;
- : int = 31
# let compose f g x = f (g x) ;;
val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b =
# let g3 = compose g1 g2 ;;
val g3 : int -> int =

# g3 (a + 2) ;;
- : int = 25
# let curryfie f a b = f(a,b) ;;
val curryfie : ('a * 'b -> 'c) -> 'a -> 'b -> 'c =
# let multip (x, y) = x * y ;;
val multip : int * int -> int =
# multip (7, 3) ;;
- : int = 21
# let multipcurr = curryfie multip ;;
val multipcurr : int -> int -> int =
# multipcurr 7 3 ;;
- : int = 21
# let uncurryfie f (a, b) = f a b ;;
val uncurryfie : ('a -> 'b -> 'c) -> 'a * 'b -> 'c =
# let add x y = x + y ;;
val add : int -> int -> int =
# add 4 31 ;;
- : int = 35
# let adduncurr = uncurryfie add ;;
val adduncurr : int * int -> int =
# adduncurr (27, 9) ;;
- : int = 36
# let uncurryfie2 f x = f (fst x) (snd x) ;;
val uncurryfie2 : ('a -> 'b -> 'c) -> 'a * 'b -> 'c =
# let adduncurr2 = uncurryfie2 add ;;
val adduncurr2 : int * int -> int =
# adduncurr2 (4, 8) ;;
- : int = 12
Exercice 3.
# let rec multegypt x y =
if x = 0 then 0
else if (x mod 2)=0 then multegypt (x/2) (y*2)
else y + multegypt (x-1) y ;;
val multegypt : int -> int -> int =
# multegypt 5 8 ;;
- : int = 40
# multegypt 13 6 ;;
- : int = 78
# let rec sommelst l =
if l = [] then 0
else (List.hd l) + sommelst (List.tl l) ;;
val sommelst : int list -> int =
# sommelst [ 6 ; 2 ; 10 ; 1 ; 3 ] ;;
- : int = 22

# let rec concat l1 l2 =
if l1 = [] then l2
else (List.hd l1)::(concat (List.tl l1) l2) ;;
val concat : 'a list -> 'a list -> 'a list =
# concat [ 6 ; 2 ; 10 ; 1 ; 3 ] [ 7 ; 12 ; 8 ] ;;
- : int list = [6; 2; 10; 1; 3; 7; 12; 8]
# let rec monmap f l =
if l = [] then []
else f(List.hd l)::(monmap f (List.tl l)) ;;
val monmap : ('a -> 'b) -> 'a list -> 'b list =
# let succ x = x + 1 ;;
val succ : int -> int =
# monmap succ [ 34 ; 5 ; 91 ; 17 ; 2 ] ;;
- : int list = [35; 6; 92; 18; 3]
# let sommefct f a b =
let rec somme f x y =
if x = y then f(x) else f(x)+(somme f (x+1) y) in
if a int) -> int -> int -> int =
# let carre x = x * x ;;
val carre : int -> int =
# sommefct carre 7 7 ;;
- : int = 49
# sommefct carre 7 3 ;;
- : int = 0
# sommefct carre 2 5 ;;
- : int = 54