Passer d'une matrice à une chaine de caractères... - Page 1

...et inversement.

J'aimerais savoir si on peut optimiser ca :

Func
Local i,j,d,strf,mf
If getType(m)="MAT" Then
 dim(m)->d
 char(d[2])->strf
 For i,1,d[1]
  For j,1,d[2]
   strf&char(m[i,j]+14)->strf
  EndFor
 EndFor
 Return strf
EndIf

If getType(m)="STR" Then
 dim(m)-1->d
 ord(left(m,1))->strf
 right(m,d)->m
 list>mat(ord(seq(mid(m,x,1),x,1,d))-14,strf)->mf
 Return mf
EndIf
EndFunc

Le nombre 14 est pour éviter les caractères interdits.

string(m) ne convient pas ?

Non.

String([[1,2,3][4,5,6][7,8,9]]) renvoie "[[1,2,3][4,5,6][7,8,9]]"
Et ma fonction renvoie une chaine de 10 caractères (contre 23 au dessus)

et il se passe quoi si les valeurs de la matrices ne sont pas dans la plage (0 - 241) ?

Bah ca plante, mais je n'ai pas besoin de plus.

Par contre, dès que la matrice grossit un petit peu, la fonction devient très lente
Alors, peut-on mieux faire ? (à part en C ou ASM)

je pense :
faire string(m) et traiter la chaîne de caractère. Tu perds en taille mais tu vas gagner en rapidité.
De la même façon, tu convertis ta string en une nouvelle string sur laquelle tu fais expr(m) pour avoir la matrice. Ca devrait êter plus rapide

J'ai essayé, mais en basic, la gestion des strings est catastrophique (on atteint rapidement 3 min pour la conversion )

Je pense qu'il y a moyen de se débrouiller avec vertel, mais je ne vois pas comment.

Hmm nan, Vertel peut sortir une liste à partir de ta matrice, mais je ne vois pas comment s'en tirer.

If getType(m)="MAT" Then
vertel("load","#m","","retr","list")
char(list)->str
...
endif

Mais là tu vas te retrouver avec une liste de la forme {"H","e","l","l","o"," ","w","o","r","l","d"}, il faut encore la transformer en chaine et je ne vois pas de solution simple.

Hmm... Sachant que tous les élements sont supposés faire 4 octets, y'a moyen de faire un vertel("read") avec un seq qui choppe tous les octets multiples de 4 + une constante, puis qui les réinjecte dans une variable de type STR. Tu peux essayer ça, mais il y a pê des meilleures solutions

La liste est composée d'elements de la forme {0,'a',0,STR_TAG}

=> donc logiquement en faisant (SizeVar-4)/4 on a le nombre d'elements (-4 parceque 2 octets de taille, un LIST_TAG et un END_TAG) qu'elle contient, et avec vertel("read","var",seq(i*4+4,i,0,(SizeVar-4)/4-1),1) on les lit tous (+4 parceque 2 octets de taille, un END_TAG et le 0 qu'il faut sauter).

Pour le ralentissement avec les grosse matrices, tu dois pouvoir te débrouiller en extrayant chaque ligne de la matrice... Asymptotiquement, ce sera en O(n^2) au lieu de O(n^3) ^^

Ben oui, sur Casio, les matrices sont des floats (donc des éléments de taille fixe), donc le lookup se fait en temps constant. Sur TI, la taille est variable et c'est implémenté avec les pieds, donc le lookup prend un temps proportionnel au nb d'éléments de la matrice...

Bah c'est tout simplement que comme une matrice peut contenir à peu près n'importe quoi (entiers dans la limite de la Ti, cad beaucoup, chaines de longueurs quelconques, flottants, etc...), y'a évidement pas d'accès direct. Il aurait fallu faire une table de saut en début de matrice, mais bon à part ça je serais curieux de savoir quelle méthode il auraient du utiliser pour implémenter ça autrement que "avec les pieds" ?

Sur casio les matrices sont bien moins polyvalentes. Bon par contre c'est vrai qu'un type correspondant à une matrice d'entiers de taille fixe ça aurait pu être bien utile pour les jeux

Le BASIC n'est pas fait pour les jeux et n'est pas un langage approprié pour un jeu!

au quart de tour

Y'a jeu et jeu... Et puis c'est pas qqun qui conseillait ExtGraph 1 pour faire des jeux qui peut donner son avis là dessus
Pour des jeux de société par exemple, où n'importe quoi tant qu'il n'y a pas de graphismes trop changeants, le basic peut largement suffire.

Mais en fait ton post est stupide, de toutes façons le problème c'est que les matrices sont lentes, je vois pas ce que ça change que ça soit pour des jeux ou nons

Au fait pour répondre à la question originale, si tu as p valeurs :

seq(p^i,i,0,n-1)->coefbase
{coefbase}^T*{coefbase^n}->coeff
sum(mat.*coeff)->number

Ca doit demander p-ê qq modifs (je sais pas si "sum" fonctionne pour une matrice), mais en tout cas ça devrait marcher et te sortir un nombre qui prend une place minimale (encore moins que ce qui est nécessaire avec une chaîne).

Tu sais lire les posts ?

Vertyos :
[...] qui conseillait ExtGraph 1 [...]

Elle a rien à voir... J'ai parlé de extgraph 1 (qui est ultra lente et qui n'a pas de clipping) pas de la 2 qui est incomparablement mieux. Bon stop le hs...