Programmation Maple

[mathieuH]

Oui, ca marche pas trop mal, il y a juste un truc qui me gêne:
on peut faire f(x) mais pas jf(x). On est obligé de lui donner un vecteur...

[leon1789]

Oui, ca marche pas trop mal, il y a juste un truc qui me gêne:
on peut faire f(x) mais pas jf(x). On est obligé de lui donner un vecteur...

Et là, tu ne donnais pas un vecteur (une liste en réalité !) ?

> fun_der([3,2]);

Alors, encore une fois, quels sont les types que tu veux utiliser ?? :marteau:

[leon1789]

Oui, ca marche pas trop mal, il y a juste un truc qui me gêne:
on peut faire f(x) mais pas jf(x). On est obligé de lui donner un vecteur...

Maintenant, tu fais le difficile en voulant utiliser ça avec plusieurs types de données : ok ok ! :zen: bon, petite modif de la dernière ligne, et voilà... (ça devient un peu cacafouillage, il faudrait reprendre ça à tête reposée, mais comme je te l'ai dit, maple et les matrix ... :hum: )

Code: Tout sélectionner

with(linalg) :
 
jacobian2 := proc(f,n) local p,L,fp,s;
   fp := f(p) ;
   L := [seq([seq( diff(fp[i,1], p[j]), j=1..n)], i=1..rowdim(fp))];
   s := seq(p[i], i=1..n) ;
   RETURN( matrix@unapply(L, s)@op@unapply([s], p) );
end :

et une petite session :

Code: Tout sélectionner

> f := p -> matrix(2,1,[p[1]*p[2]+p[3]^4,p[2]^2*p[3]]);
                                               4      2
       f := p -> matrix(2, 1, [p[1] p[2] + p[3] , p[2]  p[3]])

> jf := jacobian2(f,6) :

> jf(r) ;

           [                             3               ]
           [r[2]       r[1]        4 r[3]     0    0    0]
           [                                             ]
           [                            2                ]
           [ 0      2 r[2] r[3]     r[2]      0    0    0]

> jf([a,b,c,d,2,2]);

                 [                 3               ]
                 [b      a      4 c     0    0    0]
                 [                                 ]
                 [                2                ]
                 [0    2 b c     b      0    0    0]


[leon1789]

Version plus soignée (sauf la dernière ligne qui ne s'améliore pas...) :

Code: Tout sélectionner

jacobian2 := proc(f,n) local p,L,fp,fpi,s;
    fp := f(p) ;
    s := seq(p[i], i=1..n) ;
    L := entries(map(i -> seq( diff(i, j), j=[s]), fp));
    RETURN( matrix@unapply([L], s)@op@unapply([s], p) );
end :

[leon1789]

Version plus soignée (sauf la dernière ligne...) :

Code: Tout sélectionner

jacobian2 := proc(f,n) local p,L,fp,s;
    fp := convert( col(f(p),1), list) ;
    s := seq(p[i], i=1..n) ;
    L := [seq([seq( diff(i, j), j=[s])], i=fp)];
    RETURN( matrix@unapply(L, s)@op@unapply([s], p) );
end :


[mathieuH]

BRAVO...

et merci.

[mathieuH]

effectivement, ca a l'air d'etre chiant les matrices...

quand je fais
f:=unappy(matrix(...),p);

il me retourne
f:=p->array(...);

du coup je ne peux pas utiliser la fonction jacobian2.
il me dit impossible d'executer seq.

peut on faire qu'avec des array.

[leon1789]

Version plus soignée (sauf la dernière ligne...) :

Code: Tout sélectionner

jacobian2 := proc(f,n) local p,L,fp,s;
   fp := convert(f(p), listlist) ;
   s := seq(p[i], i=1..n) ;
   L := [seq([seq(diff(i[1],j), j=[s])], i=fp)];
   RETURN( matrix@unapply(L, s)@op@unapply([s], p) );
end :


[leon1789]

peut on faire qu'avec des array.

des unapply avec des matrices (et/ou des arrays), je crains le pire... :triste:

[leon1789]

effectivement, ca a l'air d'etre chiant les matrices...

quand je fais
f:=unappy(matrix(...),p);

il me retourne
f:=p->array(...);

Fais voir ce que tu veux faire.

[mathieuH]

ben en fait mon probleme est que j'essaye d'étendre la fonction jacobian2 pour pouvoir avoir des fonctions du type f(x,p) et de faire la jacobienne que par rapport aux variables p..

et je n'y arrive pas..

[leon1789]

ben en fait mon probleme est que j'essaye d'étendre la fonction jacobian2 pour pouvoir avoir des fonctions du type f(x,p) et de faire la jacobienne que par rapport aux variables p..

en fait, tu veux pouvoir préciser les variables par rapport auxquelles tu dérives ?

[mathieuH]

exactement

[leon1789]

Si tu mets les variables "de dérivation" en premier, ça ne pose pas de problème...

Exemple où on demande de dériver f(p[1],p[2],...,p[6]) avec uniquement ses 2 premières variables : tu remarqueras le 2 de jacobian2(f,2).

Code: Tout sélectionner

f := p -> matrix(3,1,[p[1]*p[2]+p[3]^4,p[2]^2*p[3], p[6]^2]);

                                            4      2           2
    f := p -> matrix(3, 1, [p[1] p[2] + p[3] , p[2]  p[3], p[6] ])

jf := jacobian2(f,2) :
jf(x) ;

                        [x[2]       x[1]    ]
                        [                   ]
                        [ 0      2 x[2] p[3]]
                        [                   ]
                        [ 0           0     ]


En modifiant jocobian2, on doit arriver à indiquer les indices des "variables de dérivation". Donne moi la syntaxe que tu désires.

[mathieuH]

oui, je me suis mal exprimé...
voila le type de fonction à dériver selon les variables p:

fun:=(x,p)-> matrix(2,1,[p[1]*x[3]*p[2],x[1]^2]);

jacobian3(fun,p,2); doit dériver selon la variable p (p ayant 2 composantes)
jacobian3(fun,x,3); doit dériver selon la variable x (x ayant 3 composantes)

j'imagine qu'on peut remplacer le choix de x ou de p par 1 ou 2 (ordre d'apparition de la variable)

[leon1789]

Il suffit juste de passer (dans une liste) les variables de f dans les paramètres de jacobian3, et de préciser par rapport auxquelles on veut dériver.

Code: Tout sélectionner

with(linalg) :

jacobian3 := proc(f,xp,p,n) local L,fp,s;
   fp := convert(f(op(xp)), listlist) ;
   s := seq(p[i], i=1..n) ;
   L := [seq([seq(diff(i[1],j), j=[s])], i=fp)];
   RETURN( matrix@unapply(L, s)@op@unapply([s], p) );
end :

petite session

Code: Tout sélectionner

fun := (x,p) -> matrix(2,1,[p[1]*x[3]*p[2],x[1]^2]) : fun(x,p);

                           [p[1] x[3] p[2]]
                           [              ]
                           [        2     ]
                           [    x[1]      ]

jf := jacobian3(fun,[x,p],p,2) : jf(p) ;

                       [x[3] p[2]    p[1] x[3]]
                       [                      ]
                       [    0            0    ]

jf := jacobian3(fun,[x,p],x,3) : jf(x) ;

                      [  0       0    p[1] p[2]]
                      [                        ]
                      [2 x[1]    0        0    ]



[mathieuH]

oui, mais jf est devenu une fonction de 1 seule variable. elle a perdu la dépendance en (p,x)...

[leon1789]

Bon, voilà un truc qui vaut ce qu'il vaut...

Code: Tout sélectionner

with(linalg) :
 
jacobian3 := proc(f,xp,n,q) local x,p,nx,np,L,fp,sp,sx,s;
    x,p,nx,np := op(xp),op(n) ;
    sp := seq(p[i], i=1..np) ;
    sx := seq(x[i], i=1..nx) ;
    s := `if`(q=x, sx, sp) ;
    fp := convert(f(x,p), listlist) ;
    L := [seq([seq(diff(i[1],j), j=[s])], i=fp)] ;
    RETURN( matrix@unapply(L, sx, sp)@op@unapply([sx,sp], x, p) );
end :

Code: Tout sélectionner

fun := (x,p) -> matrix(2,1,[p[1]*x[3]*p[2],x[1]^2]) : fun(x,p);

                           [p[1] x[3] p[2]]
                           [              ]
                           [        2     ]
                           [    x[1]      ]

jf := jacobian3(fun,[x,p],[3,2],p) : jf(x,p) ;

                       [x[3] p[2]    p[1] x[3]]
                       [                      ]
                       [    0            0    ]

jf := jacobian3(fun,[x,p],[3,2],x) : jf(x,p) ;

                      [  0       0    p[1] p[2]]
                      [                        ]
                      [2 x[1]    0        0    ]


[leon1789]

Bon, voilà un truc qui vaut ce qu'il vaut :
3,2 indique la longueur de x et p ,
puis d1 ou d2 indique les variables à dériver...

Code: Tout sélectionner

with(linalg) :
 
jacobian3 := proc(f,nx,np,q) local x,p,L,fp,sp,sx,s;
    sp := seq(p[i], i=1..np) ;
    sx := seq(x[i], i=1..nx) ;
    s := `if`(q=d1, sx, sp) ;
    fp := convert(f(x,p), listlist) ;
    L := [seq([seq(diff(i[1],j), j=[s])], i=fp)] ;
    RETURN( matrix@unapply(L, sx, sp)@op@unapply([sx,sp], x, p) );
end :

Code: Tout sélectionner

fun := (x,p) -> matrix(2,1,[p[1]*x[3]*p[2],x[1]^2]) : fun(a,b);
                           [b[1] a[3] b[2]]
                           [              ]
                           [        2     ]
                           [    a[1]      ]

jf := jacobian3(fun,3,2,d1) : jf(a,b) ;

                      [  0       0    b[1] b[2]]
                      [                        ]
                      [2 a[1]    0        0    ]

jf := jacobian3(fun,3,2,d2) : jf(a,b) ;

                       [a[3] b[2]    b[1] a[3]]
                       [                      ]
                       [    0            0    ]


[mathieuH]

bon je me réveille,

je n'avais pas pu continué à travailler sur ce sujet depuis qq temps.

C'est exactement ce que je voulais. Merci à tous ceux qui m'ont aidé et notamment à leon1789.

mathieu.