Forum TI-Planet.org

Bonjour,

J'ai réalisé un petit programme d'étude de jeux à 3 stratégies.
Il calcule plein de choses utiles quand on fait de la théorie des jeux. Il prend en entrée la matrice des gains du jeu.
En soi, il n'intéressera pas grand monde, mais j'ai plusieurs petites questions sur ce qui peut se faire en Basic Nspire CAS:

Show/Hide spoilerAfficher/Masquer le spoiler

Code: Select all

Define study_game(a)=
Prgm
DelVar x,y,z
vars:=[[x][y][z]]
dxyz:=a*vars
dx:=dxyz[1,1]
dy:=dxyz[2,1]
dz:=dxyz[3,1]
Disp "Gains moyens:"
Disp "∆x:   ",dx
Disp "∆y:   ",dy
Disp "∆z:   ",dz
d:=dx*x+dy*y+dz*z
Disp "∆:     ",d
Disp "Equations du réplicateur:"
Disp "x' = x(",expand(dx-d),")"
Disp "y' = y(",expand(dy-d),")"
Disp "z' = y(",expand(dz-d),")"
sys:=system(x+y+z=1,x*(dx-d)=0,y*(dy-d)=0)
equs:=solve(sys,x,y)
ms:=exp▶list(equs,{x,y,z})
n:=dim(ms)[1]
Disp n," points d'équilibre:   ",ms
vars2:=[[x][y][1-x-y]]
dxyz2:=a*vars2
dx2:=dxyz2[1,1]
dy2:=dxyz2[2,1]
dz2:=dxyz2[3,1]
d2:=dx2*x+dy2*y+dz2*(1-x-y)
j:=[[(x*(dx2-d2),x),(x*(dx2-d2),y)][(y*(dy2-d2),x),(y*(dy2-d2),y)]]
Disp "Matrice Jacobienne en 2D:   "
Disp j
Disp "Stabilité des points d'équilibre:"
For a,1,n
x:=ms[a,1]
y:=ms[a,2]
z:=ms[a,3]
de:=det(j)
tr:=trace(j)
delta:=tr^(2)-4*de
If de>0 and tr>0 Then
If delta>0
isp:="==> C'est un noeud instable !"
If delta<0
isp:="==> C'est un foyer instable !"
If delta=0
isp:="==> C'est un noeud dégénéré ou étoile instable !"
EndIf
If de>0 and tr<0 Then
If delta>0
isp:="==> C'est un noeud asymptotiquement stable !"
If delta<0
isp:="==> C'est un foyer asymptotiquement stable !"
If delta=0
isp:="==> C'est un noeud dégénéré ou étoile asymptotiquement stable !"
EndIf
If de<0
isp:="==> C'est un point selle !"
If de=0 Then
If tr=0 Then
isp:="Mouvement continu"
Else
isp:="==> C'est un point non hyperbolique !"
EndIf
EndIf
If tr=0 and de>0
isp:="==> La linéarisation prévoit des centres."
Disp "En (",x,",",y,",",z,"),     J=",j,"   det(J) =",de,"   tr(J) =",tr,"   ∆=",delta,isp
EndFor
EndPrgm


J'aimerais faire deux choses:
- Etendre à la dimension n, pour des jeux à n stratégies,
- Afficher des trajectoires en 2 ou 3D

Mes deux problèmes principaux sont donc:

• Est-ce qu'il est possible de dire explicitement à la commande solve() le domaine dans lequel on attend les solutions ? Par exemple ici, je veux x, y et z entre 0 et 1, et je ne sais pas comment le lui dire.
• Est-il possible de créer un vecteur de variables inconnues de taille sur demande ? Ici, j'ai posé vars := [ [x],[y],[z] ], si je veux avoir un vecteur de n inconnues, n dépendant de la dimension de la matrice passée en entrée, comment faire ?
• Est-il possible de dessiner (graphiquement) le triangle des solutions de x+y+z=1 facilement à partir du programme ? Si c'est trop compliqué, tant pis, ce n'est pas essentiel.

Question subsidiaire: vu qu'il a rejoint les archives TI-Planet ce matin, y'a-t-il une façon d'indiquer que le classeur est réservé aux machines CAS ?
archives_voir.php?id=869145

Merci !

- Tu peux modifier ton solve et en faire un système, en imposant x, y et z entre 0 et 1.
- Un truc genre newmat(n,1), ça fait pas ce que tu veux ?
- En Lua c'est faisable... en TiBasic... je crois pas

Clifward wrote:- Tu peux modifier ton solve et en faire un système, en imposant x, y et z entre 0 et 1.

Tu veux dire un système hybride d'équations et d'inéquations ?

Le newmat n'est pas ce que je cherche, ça crée une matrice nulle.
Je voudrais une matrice de variables "formelles", utilisables par le CAS, de taille sur demande... Si c'est possible

EDIT: solution donnée par Hamza sur le chat:
utiliser subMat([a,b,c,d,e,f,g,h,i,j],1,1,1,n)

Il y a plein d'optimisations faciles à réaliser dans ton programme.

1. tu peux utiliser des listes à la place de matrices à une seule ligne ou une seule colonne.
2. avec une liste, c'est encore plus simple de ne prendre qu'une partie de la liste, par exemple avec left(ta_liste, nombre_de_termes)
3. tu peux créer un nombre infini de variables grâce à l'indirection #"x"&string(i)
4. tu peux utiliser des produits scalaires pour certains calculs, par exemple d:=dotp(dxyz,vars)
5. tu peux utiliser la fonction seq pour créer des listes... et donc si tu fais seq(seq(...)) tu peux créer des matrices comme par exemple ta jacobienne.
6. tu peux remplacer z par 1-x-y dans les calculs pour ne pas avoir à tout refaire... Il suffit de mettre calcul|z=1-x-y
7. pour préciser que tu veux résoudre avec certaines contraintes... il suffit de les préciser solve(equation, variables)|contraintes

Merci Bisam !

J'essaie d'intégrer tout ça.
Cependant, si j'utilise une liste pour les variables, il refuse le produit avec la matrice au tout début. (type de données incorrect).
Je n'ai pas compris comment construire la jacobienne avec seq, même si l'idée me semble intelligente, je ne sais pas faire.

Merci pour le coup des contraintes, ça peut être super utile aussi.
Je posterai une nouvelle version dès que ça marchera, ce qui n'est pas le cas pour l'instant...

tu peux transformer une liste en matrice avant de faire les calculs matriciels

À la place de :

Code: Select all

vars:=[[x][y][z]]
dxyz:=a*vars
dx:=dxyz[1,1]
dy:=dxyz[2,1]
dz:=dxyz[3,1]
...
Disp "∆x:   ",dx
Disp "∆y:   ",dy
Disp "∆z:   ",dz
...
d:=dx*x+dy*y+dz*z
...
vars2:=[[x][y][1-x-y]]
dxyz2:=a*vars2
dx2:=dxyz2[1,1]
dy2:=dxyz2[2,1]
dz2:=dxyz2[3,1]
d2:=dx2*x+dy2*y+dz2*(1-x-y)
j:=[[(x*(dx2-d2),x),(x*(dx2-d2),y)][(y*(dy2-d2),x),(y*(dy2-d2),y)]]

Tu peux écrire :

Code: Select all

n:=coldim(a)
vars:=list►mat(left(augment({x,y,z},when(n>3,seq(#"x"&string(i),i,1,n-3),{}),n),1)
dxyz:=mat►list(a*vars)
For i,1,n
  Disp "∆"&string(vars[i]),dxyz[i]
EndFor
...
d:=dotp(vars,dxyz)
...
j:=seq(seq(derivative(vars[i]*(dxyz[i]-d)|z=1-x-y,vars[j]),j,1,2),i,1,2)

Waaaa ! Servi sur un plateau !

Mais la ligne vars:=list►mat(left(augment({x,y,z},when(n>3,seq(#"x"&string(i),i,1,n-3),{}),n),1) me renvoie une erreur (trop d'arguments).
En zoomant sur la ligne, et en prenant soin d'avoir n>3, le problème vient de seq(#"x"&string(i),i,1,n-3), "type de données incorrect"...

EDIT: Résolu tout seul: il faut mettre des parenthèses: seq(#("x"&string(i)),i,1,n-3).
L'erreur trop d'arguments vient du fait qu'il manque une parenthèse à la fin du augment.

pour seq(#"x"&string(i),i,1,n-3) il a oublié les parenthèses.
normalement c'est seq(#("x"&string(i)),i,1,n-3)

Merci J'avais trouvé entre temps du coup.


Problème suivant:

Code: Select all

"fonctionne:
exp▶list(equs,{x,y,z})

"ne fonctionne pas:
varlist := {x,y,z}
exp▶list(equs,varlist)


Et aussi, comment transformer une liste de conditions en expression reliées par des and ?


J'ai {x>0, y>0, z>0} et je veux obtenir x>0 and y>0 and z>0

Des idées ?