BAUDET Jennifer BERCHER Matthieu

Contraintes gomtriques en 2D - Newton-Raphson

Universit de Bourgogne Master MIGS Anne 2008 - 2009

Table des matires

1 2 3 4 5 6 Prsentation du sujet Prsentation du problme Convergence de l'algorithme Reprsentation d'une quation par un DAG Calcul de l'inverse d'une matrice carre Exemples bien contraints 2 2 3 3 4 5

6.1 6.2 6.3 6.4 6.5

Exemple 1 Exemple 2 Exemple 3 Exemple 4 Exemple 5

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

5 6 7 8 8

7.1 Exemple 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 7.2 Exemple 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Bibliographie Annexes 13 13

Exemples non bien contraints

8 9

9.1 Dcomposition LU . . . . . . . . . . . . . . . . . . . . . . . . . . 13 9.2 Solveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Prsentation du sujet

Faire un solveur de contraintes gomtriques en 2 dimensions en utilisant la mthode de Newton-Raphson. Ce projet pourra tre prolong au second semestre avec une interface graphique.
2 Prsentation du problme

Dans ce projet, nous allons chercher trouver un point qui vrie certaines contraintes gomtriques prdnies. Il s'agit donc de rsoudre un systme d'quations polynomiales de la forme :
f (x, y ) = 0 g (x, y ) = 0

On utilisera alors la mthode de Newton-Raphson pour approximer une solution de ce systme. Considrons les dveloppements limits d'ordre 1 des fonctions f et g au point (x0 , y0 ) :
f (x, y ) = f (x0 , y0 ) + g (x, y ) = g (x0 , y0 ) +
f f x (x0 , y0 )(x x0 ) + y (x0 , y0 )(y y0 ) + o(x, y ) g g x (x0 , y0 )(x x0 ) + y (x0 , y0 )(y y0 ) + o(x, y )

Ainsi, si on note J (x, y ) le jacobien du systme, on trouve par approximation :

f (x0 , y0 ) g (x0 , y0 ) = J (x0 , y0 ). x x0 y y0

Si det(J ) = 0 alors on dnie l'itration de la mthode de Newton-Raphson par :

xn+1 yn+1 = xn yn J (xn , yn )1 . f (xn , yn ) g (xn , yn )

Dans le cas gnral, on a la formulation matricielle suivante :

Xn+1 = Xn J 1 (Xn )(F (Xn )) o J = F (X )

Dans le cas o le jacobien n'est pas carr, cas non bien contraint, on utilise la pseudo-inverse ou inverse de Moore-Penrose. La pseudo-inverse de la matrice jacobienne m n est dnie comme suit : Dans le cas o m < n on a : J + = J T (JJ T )
1 1

Dans le cas o m > n on a : J + = (J T J ) J T Dans notre projet, nous tudions les contraintes gomtriques en 2D, le jacobien aura donc au plus deux colonnes. Donc dans le cas non bien contraint, on se trouve dans le cas o il y a plusieurs quations (>2) deux inconnues. On 1 se place donc dans le cas o m > n, la pseudo-inverse vaut : J + = (J T J ) J T . On remplace donc dans l'itration de Newton-Raphson J 1 par J + . 2

Convergence de l'algorithme

Supposons qu'on dispose d'une fonction f pour laquelle on cherche estimer la ou les racine(s). Entre la valeur exacte d'une racine r et son estimation xn l'itration n par la mthode de Newton-Raphson, on a la relation suivante : r = xn + n c'est--dire xn = r n o n est l'erreur d'estimation l'itration n. A l'itration n + 1, on a :
xn+1 = r n+1 (xn ) xn+1 = xn f f (xn+1 ) xn+1 = r n
f ( r n ) f (r n ) f (r n ) f ( r n )

Ainsi :
4

n+1 = n +

Reprsentation d'une quation par un DAG

Les contraintes gomtriques dnissant le problme sont exprimes par des quations qu'il faut alors reprsenter sous une forme utilisable dans un programme Ocaml. On utilise pour cela des DAG (graphes acycliques orients). En eet, on peut par exemple reprsenter le polynme x2 + y 2 9 par le graphe suivant :

Il sut alors de dnir tous les types d'lments pouvant apparatre et toutes les relations pouvant lier ces lments. On a alors sous Ocaml :
type dag = Nb of float |Sum of dag*dag |Prod of dag*dag

|Opp of dag |Var of string;;

Ainsi un lment de type dag peut tre un rel (oat), une variable (string), une somme de dag (Sum), un produit de dag (Prod) ou l'oppos d'un dag (Opp).
5 Calcul de l'inverse d'une matrice carre

Pour calculer l'inverse d'une matrice, on utilisera sa dcomposition LU. Supposons que A est une matrice inversible, alors il existe trois matrices P , L et U telles que P A = LU o U est une matrice triangulaire suprieure, L une matrice triangulaire infrieure et P une matrice de permutation. Si A est une matrice de taille n n, l'algorithme de la dcomposition LU se droule en n 1 tapes. A chaque tape, il faut choisir un pivot parmi les lments de A. A l'tape k, le pivot est l'lment la ligne k et la colonne k de la matrice obtenue l'tape k 1, on le note akk . A partir de ce pivot, on cre n k matrices E1 , E2 , ..., Enk o Ei est la matrice identit dans laquelle on a remplac l'lment la colonne k , ligne k + i par : ak+i,k /akk . Par exemple, si on dispose d'une matrice de taille 3 3, l'tape 1, le pivot sera a11 et on cre 2 matrices E1 et E2 telles que :
E1 = E2 = 1
a21 a11

0 1 0
a31 a11

0 0 1 0 0 1 0 0 1 0 0 1

En faisant la somme des matrices Ei , on obtient la matrice identit dans laquelle on a remplac les zros placs sous le 1 la colonne k par : ak+1,k /akk la ligne k + 1, ak+2,k /akk la ligne k + 2,..., an,k /akk la ligne n. Notons cette somme E , on obtient la nouvelle matrice A est alors dnie par : A = EA. La matrice L est obtenue la dernire tape de l'algorithme en faisant le produit des inverses des matrices Ei calcules chaque tape. La matrice U est obtenue en faisant le produit des matrices Ei avec A. Dans le cas 3 3 :
1 1 1 L = E1 E2 E3 = (E3 E2 E1 )1 U = (E3 E2 E1 )A

On remarque que la dnition des matrices Ei ncessite que le pivot soit non nul, on vrie alors chaque tape si le pivot est nul, s'il l'est, on permute la ligne o se trouve le pivot avec une autre ligne de A an que l'lment sur la diagonale soit non nul. Cette opration engendre une matrice de permutation P que l'on ajoute la dcomposition, on a alors P A = LU et si tous les pivots sont non nuls, on aura A = LU . Aprs cette dcomposition, le calcul du dterminant de A est simpli, en eet :
det(A) = det(P )det(L)det(U )

De plus, det(P ) = 1 et le dterminant d'une matrice triangulaire est gal au produit de ses lments diagonaux. 4

6
6.1

Exemples bien contraints

Exemple 1

Rsoudre le systme suivant :

x2 + y 2 = 1 x3 y = 0

(1)

On peut voir sur la gure 1 les courbes C1 : x2 + y 2 = 1 et C2 : x3 y = 0, on en dduit graphiquement une approximation des solutions.

Fig 1 Sur le graphique, on voit que le systme admet deux solutions, l'algorithme de Newton-Raphson va nous permettre d'approximer l'une d'elles. x 0 On cherche rsoudre l'quation F = avec
y 0 F x y = x2 + y 2 1 x3 y

(2)

La matrice Jacobienne de F est donne par :

JF x y =
f x g x f y g y

2x 3x2

2y 1

(3)

On applique les itrations successives de Newton-Raphson avec comme point de dpart x0 0, 5 = .

y0 0, 5

On obtient en 4 itrations le point : . y 0, 563624163 Si on change le point de dpart, on peut approximer l'autre point d'intersection entre le cercle et la courbe. 5

0, 826031364

6.2

Exemple 2

Rsoudre le systme suivant :

y = x2 (x 1)2 + (y 1)2 = 1

(4)

On peut voir sur la gure 2 les courbes C1 : (x 1)2 +(y 1)2 = 1 et C2 : y = x2 , on en dduit graphiquement une approximation des solutions.

Fig 2 Sur le graphique, on voit que le systme admet deux solutions. x 0 On cherche rsoudre l'quation F = avec
y 0 F x y = x2 y (x 1) + (y 1)2 1
2

(5)

La matrice Jacobienne de F est donne par :

JF x y = 2x 2x 2 1 2y 2

(6)

On applique les itrations successives de Newton-Raphson avec comme point de dpart x0 2 = .

y0 4

On obtient le point : . y 1.92230 En changeant le point de dpart, on peut obtenir l'autre solution.

1.38647

6.3

Exemple 3

Rsoudre le systme suivant :

y=x (x 1)2 + (y 1)2 = 1

(7)

On peut voir sur la gure 3 les courbes C1 : (x 1)2 + (y 1)2 = 1 et C2 : y = x, on en dduit graphiquement une approximation des solutions.

Fig 3 Sur le graphique, on voit que le systme admet deux solutions. x 0 On cherche rsoudre l'quation F = avec
y 0 F x y = yx (x 1)2 + (y 1)2 1

(8)

La matrice Jacobienne de F est donne par :

JF x y = 1 2x 2 1 2y 2

(9)

On applique les itrations successives de Newton-Raphson avec comme point de dpart x0 2 = .

y0 4

On obtient en 5 itrations le point :

0 En prenant, = y0 100 point solution en 19 itrations.

x y

1.70710 1.70710

100

comme point de dpart, on obtient l'autre

6.4

Exemple 4

Rsoudre le systme suivant :

y = x2 y = x 2

(10)

On peut voir sur la gure 4 les courbes C1 : y = x2 et C2 : y = x2 , on en dduit graphiquement une approximation des solutions.

Fig 4 Sur le graphique, on voit que le systme admet une unique solution. x 0 On cherche rsoudre l'quation F = avec
y 0 F x y x y = yx y + x2 2x 2x 1 1
2

(11)

La matrice Jacobienne de F est donne par :

JF =

(12)

On applique les itrations successives de Newton-Raphson avec comme point de dpart x0 1 = .

y0 2

On obtient le point :
6.5 Exemple 5

x y

0.08122 0.04606

Rsoudre le systme suivant :

x2 + y 2 = 1 (y 1)2 x2 =1 3 + 0.5

(13)

On peut voir sur la gure 5 les courbes C1 : x2 + y 2 = 1 et C2 : on en dduit graphiquement une approximation des solutions.

x2 3

1) + (y0 = 1, .5

Fig 5 Sur le graphique, on voit que le systme admet deux solutions. x 0 On cherche rsoudre l'quation F = avec
y 0 F x y = x2 + y 2 1 1)2 + (y0 1 .5

x2 3

(14)

La matrice Jacobienne de F est donne par :

JF x y = 2x 2x/3 2y 4y 4

(15)

On applique les itrations successives de Newton-Raphson avec comme point de dpart x0 1.5 = .
y0 1

On obtient le point :
7

x y

0.91651 0.39999

Exemples non bien contraints

Dans les exemples suivants, on rsout un systme de 3 quations 2 inconnues. Le jacobien est donc non carr. On utilise alors la pseudo-inverse.

7.1

Exemple 6

Fig 6

10

7.2

Exemple 7

Fig 7

11

Conclusion
La mthode de Newton-Raphson convergeant assez rapidement, elle est largement utilise pour rsoudre les quations du type F (X ) = 0. On distingue deux cas pouvant se prsenter, premirement le cas bien contraint o le jacobien du systme est carr, c'est--dire o le nombre d'quations est gal au nombre de variables, deuximement le cas non bien contraint o le jacobien n'est pas une matrice carre. Dans ce cas, on utilise la pseudo-inverse (aussi appele inverse de Moore-Penrose) du jacobien comme nous avons utilis ou sa dcomposition en valeurs singulires (SVD). On peut donc utiliser cette mthode pour rsoudre des systmes de contraintes gomtriques complexes. Cependant, cette mthode converge vers une solution mais pas l'ensemble des solutions. De plus, celle-ci ne converge pas toujours, ce qui peut tre d au choix du point de dpart de l'algorithme. Il peut alors convenir d'avoir recours d'autres mthodes telles que l'homotopie.

12

Bibliographie

1. Numerical recipes in C
9
9.1

Annexes
Dcomposition LU

type lup_decomposition = { mat : float array array; low : float array array; up : float array array; per : int array };; exception Singular ;; module A= Array;; module L= List;; let parity_permutation tab = (* i va en tab.(i) *) let n= A.length tab in let count = ref 0 in for i=0 to n-2 do for j=i+1 to n-1 do if tab.(i) > tab.(j) then count := 1 - !count done; done; !count;; let matrice nlines ncolumns fonc = A.init nlines (function line -> A.init ncolumns (function col -> fonc line col));; let transpose m = matrice (A.length m.(0)) (A.length m) (fun l c -> m.(c).(l));; let copy_matrix m = A.init (A.length m) (function l -> A.copy m.(l));; let lup_decomp m = let n= A.length m in assert (A.length m.(0) = n); let a= A.init n (function lig -> A.copy m.(lig)) in let per = A.init n (function i-> i ) in for k=0 to n-1 do let k'= ref k in for i=k+1 to n-1 do if abs_float a.(i).(k) > abs_float a.(!k').(k) then done; let k' = !k' in

k' := i

13

if a.( k').(k) = 0. then raise Singular; let tmp= per.(k) in per.(k) <- per.( k'); per.(k') <- tmp ; for i=0 to n-1 do let tmp= a.(k).(i) in a.(k).(i) <- a.(k').(i); a.(k').(i) <- tmp done; for i=k+1 to n-1 do a.(i).(k) <- a.(i).(k) /. a.(k).(k); for j=k+1 to n-1 do a.(i).(j) <- a.(i).(j) -. a.(i).(k) *. a.(k).(j) done; done; done; { up= matrice n n (fun l c -> if l<=c then a.(l).(c) else 0.); low= matrice n n (fun l c -> if l>c then a.(l).(c) else if l=c then 1. else 0.); per = per; mat = copy_matrix m; };; (* returns X such that AX=B *) let lup_solve { low=l; up=u; per=p } b = let n= A.length p in assert (A.length b = n); let x= A.make n 0. in let y= A.make n 0. in for i=0 to n-1 do y.(i) <- b.( p.(i)) -. (summation 0 (i-1) (function j-> l.(i).(j) *. y.(j))) done; for i=n-1 downto 0 do x.(i) <- (y.(i) -. (summation (i+1) (n-1) (function j->u.(i).(j) *. x.(j)))) /. u.(i).(i) done; x ;; let lup_inverse ({ low=l; up=u; per=p } as lup) = let n= A.length p in let mat=A.init n (function k -> let b= A.init n (function l -> if l=k then 1. else 0.) in lup_solve lup b ) in transpose mat;; let inverse_mat mat = lup_inverse (lup_decomp mat);; (* AX=I *)

9.2

Solveur

(** File solveur.ml **) (* contraintes geometriques en 2D - Newton-Raphson *) module L=List;; module A=Array;; (* #load"lu_decompose.cmo";; *) module Inv=Lu_decompose;; type dag = Nb of float

14

|Sum of dag*dag |Prod of dag*dag |Opp of dag |Var of string;; let nb x=Nb x;; (* un nbe -> le dag *) let var nom=Var nom;; (* une string -> le dag *) let opp undag=Opp undag;; let (+%) a b=Sum(a,b);; let (-%) a b=Sum(a, opp b);; let ( *% ) a b=Prod(a,b);; (*derivee de exp par rapport a x*) let rec derivee (exp:dag) (x:string)= match exp with |Nb _ -> nb 0. |Sum (a,b) -> (derivee a x) +% (derivee b x) |Prod (a,b) -> (derivee a x) *% b +% a *% (derivee b x) |Opp a -> opp (derivee a x) |Var v -> if v=x then nb 1. else nb 0.;; let rec match |Nb _ |Prod simpl exp= exp with -> exp (a,b) -> let a'=simpl a in let b'=simpl b in if a'=Nb 0. || b'=Nb 0. then Nb 0. else if a'=Nb 1. then b' else if b'=Nb 1. then a' else Prod (a',b') |Sum (a,b) -> let a'=simpl a in let b'=simpl b in if a'=Nb 0. then b' else if b'=Nb 0. then a' else Sum (a',b') |Opp a -> (let a'=simpl a in match a' with |Nb x->Nb (0. -. x) |Opp truc->truc | _ -> Opp a') | _ -> exp;;

let rec valeur env x= match env with

15

|[]->failwith("La variable"^x^"n'a pas de valeur") |(v,nbf)::qenv->if v=x then nbf else valeur qenv x;; let rec eval dag env= match dag with |Nb v->v |Sum (a,b)->(eval a env) +. (eval b env) |Prod (a,b)->(eval a env) *. (eval b env) |Opp a->0. -. (eval a env) |Var a->(match env with |[]->failwith("La variable"^a^"n'a pas de valeur") |(v,valv)::qenv->if v=a then valv else eval dag qenv);; (* type "systeme de contraintes" *) type system = { mutable equations : dag array; (* liste des expressions qui doivent etre nulles *) mutable vars: string array; (* les variables *) };; let matrice nl nc fonc= A.init nl (function l->A.init nc (function c->fonc l c));; let rec sigma i0 i1 fonc= if i0=i1 then fonc i0 else (fonc i0) +. (sigma (i0 + 1) i1 fonc);; let multM a b= assert (A.length a.(0)=A.length b); matrice (A.length a) (A.length b.(0)) (fun l c -> sigma 0 (A.length a.(0) - 1) (function k-> a.(l).(k) *. b.(k).(c)));; let transpose mat= matrice (A.length mat.(0)) (A.length mat) (fun lig col->mat.(col).(lig));; let copy_matrix m = A.init (A.length m) (function l -> A.copy m.(l));; let jacobian sys= let nbeq=A.length sys.equations in let nbvar=A.length sys.vars in matrice nbeq nbvar (fun i j-> simpl (derivee sys.equations.(i) sys.vars.(j)));; (* valeur de la matrice de dag mat les valeurs des variables decrites let eval_mat_dag mat lval= let n=A.length mat in let m=A.length mat.(0) in let mm=matrice n m (fun l c->0.) for i=0 to n-1 do for j=0 to m-1 do mm.(i).(j)<-eval mat.(i).(j) pour dans lval : *)

in lval

16

done; done; mm;; (* valeur du vecteur de dag vec pour les valeurs des variables decrites dans lval : *) let eval_vect_dag vec lval= let n=A.length vec in let v=A.make n 0. in for i=0 to n-1 do v.(i)<-eval vec.(i) lval done; v;; let summation i_min i_max fonc_i = let rec scan accu i = if i> i_max then accu else scan (accu +. (fonc_i i)) (i+1) in scan 0. i_min;; let distance u v = summation 0 (A.length u - 1) (function i -> (u.(i) -. v.(i)) *. (u.(i) -. v.(i)));; let mat_vect m v = let n=A.length v in let nl=A.length m in let nc=A.length m.(0) in assert (n=nc); A.init nl (function l -> summation 0 (n-1) (fun col -> v.(col) *. m.(l).(col)));; let moins_vect u v = assert (A.length u=A.length v); A.init (A.length u) (function col -> u.(col) -. v.(col));; type newton_results = { x : (string*float) list; e : int };; let itere_newton jac = assert (A.length jac>=A.length jac.(0)); (* Cas ou le jacobien est carre : *) if ((A.length jac)=A.length jac.(0)) then copy_matrix (Inv.inverse_mat jac) else (* Cas ou le jacobien n'est pas carre : *) let jac_transpose = transpose jac in let mult_jac_t_jac = multM jac_transpose jac in let inv_m = copy_matrix (Inv.inverse_mat mult_jac_t_jac) in multM inv_m jac_transpose;; (* pseudo inverse = (JTxJ)^(-1) x JT *) let rec boucle x e jac sys epsilon = (* on verifie que le bon nbe de variables a ete entre en parametre : *)

17

assert(L.length x=A.length jac.(0)); let m=L.length x in let tab=A.of_list x in let var=A.init m (function k->fst tab.(k)) in let valx=A.init m (function k->snd tab.(k)) in let fx=eval_vect_dag sys.equations x in let jac_val=eval_mat_dag jac x in let inv_jac=itere_newton jac_val in if e=100 then {x=x; e=e} else let valx'= moins_vect valx (mat_vect inv_jac fx) in let lval=A.to_list valx' in let lvar=A.to_list var in let x'=L.combine lvar lval in if (distance valx valx' <= epsilon *. epsilon) then {x=x'; e=e} else boucle x' (e+1) jac sys epsilon;; let newton xo sys epsilon= let jac=jacobian sys in boucle xo 0 jac sys epsilon;; (*************** Applications *****************) let sys1= let foncf=(var "x") *% (var "x") *% (var "x") -% (var "y") in let foncg=(var "x") *% (var "x") +% (var "y") *% (var "y") -% (nb 1.) in { equations=[|foncf;foncg|];vars=[|"x";"y"|] };; let sys2= let foncf=(var "x") *% (var "x") +% (var "y") *% (var "y") -% (nb 2.) *% (var "x") -% (nb 2.) *% (var "y") +% (nb 1.) in let foncg=(var "x") *% (var "x") -% (var "y") in { equations=[|foncf;foncg|];vars=[|"x";"y"|] };; let sys3= let foncf = (var "y") -% (var "x") in let foncg = (var "x") *% (var "x") +% (var "y") *% (var "y") -% (nb 2.) *% (var "x") -% (nb 2.) *% (var "y") +% (nb 1.) in { equations=[|foncf;foncg|];vars=[|"x";"y"|] };; let sys4= let foncf=(var "x") *% (var "x") +% (var "y") in let foncg=(var "x") *% (var "x") -% (var "y") in { equations=[|foncf;foncg|];vars=[|"x";"y";|] };; let sys5= let foncf=(var "x") *% (var "x") +% (var "y") *% (var "y") -% (nb 1.) in let foncg=(var "x") *% (var "x") +% (nb 6.) *% (var "y") *% (var "y") -% (nb 12.) *% (var "y") +% (nb 3.) in { equations=[|foncf;foncg|];vars=[|"x";"y";|] };;

18

(* Exemples ou le jacobien n'est pas carre : cas non bien contraints *) let sys6= let f=(var "x") *% (var "x") +% (var "y") *% (var "y") -% (nb 2.) *% (var "x") -% (nb 2.) *% (var "y") +% (nb 1.) in let g=(Nb 3.) -% (var "x") -% (var "y") in let h=(var "x") -% (Nb 1.) -% (var "y") in { equations=[|f;g;h|];vars=[|"x";"y"|] };; let sys7= let f=(var "x") *% (var "x") -% (var "y") in (*parabole*) let g=(var "x") *% (var "x") +% (var "y") *% (var "y") -% (nb 4.) *% (var "x") -% (nb 4.) *% (var "y") +% (nb 4.) in (*cercle de centre (2,2) et de rayon 2*) let h=(nb 2.) *% (var "x") -% (var "y") in (*droite passant par le pt (2,4) *) { equations=[|f;g;h|];vars=[|"x";"y"|] };; let epsilon = 0.000001;; (* Exemple 1 : *) let xo=[("x",0.5);("y",0.5)];; newton xo sys1 epsilon;; (* resultat : {x = [("x", 0.82603135765429625); ("y", 0.56362416216121447)]; e = 4} *) (* Exemple 2 : *) let xo=[("x",2.);("y",4.)];; newton xo sys2 epsilon;; (* resultat : [("x", 1.38647091396835132); ("y", 1.92230159528023536)] *) let x1=[("x",-100.);("y",-100.)];; newton x1 sys2 epsilon;; (*resultat : {x = [("x", 0.425786666318444529); ("y", 0.181294285214574413)]; e = 14}*) (*on trouve alors la deuxieme intersection : 2eme solution*) (* Exemple 3 : *) let xo=[("x",2.);("y",4.)];; newton xo sys3 epsilon;; (* resultat : [("x", 1.70710678118654791); ("y", 1.70710678118654791)] *) (* Exemple 4 : *) let xo=[("x",1.);("y",2.)];; newton xo sys4 epsilon;; (* resultat : [("x", 9.5367431640625e-07); ("y", 0.)] *) (* Exemple 5 : *)

19

let xo=[("x",1.5);("y",1.)];; newton xo sys5 epsilon;; (* resultat : [("x", 0.916515138991168); ("y", 0.399999999999999911)] *) (* Exemple 6 : *) let x0=[("x",8.);("y",3.)];; let xf=newton x0 sys6 epsilon;; (*resultat : [x=2;y=1] *) (* Exemple 7 : *) let x0=[("x",3.);("y",6.)];; let xf=newton x0 sys7 epsilon;; (* resultat : {x = [("x", 2.00000000000004752); ("y", 4.00000000000011191)]; e = 4} *)

20