Décortiquer un Quad en octets

[SPH]

Je vois qu'il y a une foultitude de solutions (vive PB)

[crisot]

Il y a beaucoup de solutions mais peu de bonnes solutions.

J'ai benché, la plus simple et la plus rapide est la deuxième de g-rom.

Code : Tout sélectionner

quad.q=10011254555
Dim oct.a(7)
CopyMemory(@quad, @oct(0),8)

Une seule instruction pour créer le tableau d'octets, difficile de faire mieux.

[Zorro]

sauf que ton code renvoi des octets de 0 a 255 .....
voici comment avoir les deux types

ps: rappel , une chaine c'est aussi un tableau a une dimension

Code : Tout sélectionner

quad.q=10011254555
For i=0 to 7
		a$=a$+str(peeka(@quad.q+i))+";" ; renvoi ;27;159;183;84;2;0;0;0
		b$=b$+str(peekb(@quad.q+i))+";" ; renvoi ;27;-97;-73;84;2;0;0;0
Next i
debug "en octet non signé ="+a$
debug "en octet signé        ="+b$

[crisot]

C'est un peu le problème: Ca n'a pas de sens de récupérer un signe dans chaque octet d'un quad, vu que le signe du quad se situe dans sa moitié forte. Ca n'a pas de sens d'avoir un octet négatif faisant parti d'un quad positif ou l'inverse.

Pour ça il me semble plus logique de récupérer des octets non signés, et si par chance SPH n'a besoin que de bosser avec des quad positif, c'est plus simple.

Après le contenu bit à bit des octets reste de toute façon le même.

[Ollivier]

Par contre, $0102030405060708 donne :
8
7
6
5
4
3
2
1

C'est stocké complètement en verlan.

[Zorro]

C'est un peu le problème: Ca n'a pas de sens de récupérer un signe dans chaque octet d'un quad, vu que le signe du quad se situe dans sa moitié forte. Ca n'a pas de sens d'avoir un octet négatif faisant parti d'un quad positif ou l'inverse.*.

oui c'est vrais

[Ollivier]

En opposant chaque bit d'index de 0 à 7, on obtient un compte de 7 à 0, et on retrouve les octets du quad dans l'ordre de lecture.

Code : Tout sélectionner

Structure MeliMelo
   StructureUnion
      A.A[8]
      Q.Q
   EndStructureUnion
EndStructure

Define Exemple.Q = $0102030405060708

Define *x.MeliMelo = @Exemple

For I = 0 To 7 ; chaque octet de 7 à 0
   Debug *X\A[I ! 7]
Next

Affichera 1, 2, 3, 4, 5, 6, 7 puis 8...

[Ar-S]

Code : Tout sélectionner

è
For I = 0 To 7 ; chaque octet de 7 à 0
   Debug *X\A[I ! 7]
Next

Affichera 1, 2, 3, 4, 5, 6, 7 puis 8...

ou

Code : Tout sélectionner

For I = 7 To 0 Step -1 ; chaque octet de 7 à 0
   Debug *X\A[I]
Next

[crisot]

Par contre, $0102030405060708 donne :
8
7
6
5
4
3
2
1

C'est stocké complètement en verlan.

La ram se lit de gauche à droite mais un byte/word/long/etc se lit de droite à gauche donc dans l'exemple que tu donnes c'est bien $08 la première valeur qui nous intéresse.

[Ollivier]

Comme repère plus simple, quand je veux faire le calcul élémentaire de deux grands nombres sur papier, je commence par la droite. Et je termine à gauche.

Je peux commencer par la gauche. Par exemple :

Code : Tout sélectionner

  543
+ 982
_____=?

Je peux commencer par 5+9. Ça peut même être plus rapide : le cerveau peut calculer, avec un peu d'habitude, à la fois 5+9, à gauche, et 3+2, à droite. Il y a même des personnes qui ont le résultat de l'addition, mais qui n'ont pas encore terminé de vérifier ce qu'ils ont additionné.

Alors, 5 + 9, ça fait 14. Mais on n'est pas sûr que 14 soit le résultat : ça peut être 15... Pour le savoir, il faut calculer le reste qui se trouve, en l'occurence, à droite de la colonne qui nous concerne.

Le cerveau a cela de faisable d'être naturellement en capacité de résoudre des situations quantiques simples : on imagine, et on précise son imagination.

Pour une addition, il faut s'imaginer les retenues. Si l'on part de gauche à droite, la notion de retenue n'est plus éphémère : il s'agit d'un nombre à part entière, aussi grand que le plus grand des deux nombres à additionner. Et l'on peut s'entrainer à calculer des nombres assez grands et l'on peut s'exercer à additionner le nombre des retenues. Cependant, cet exercice a tendance à contraindre à être con, sauf si on programme un processeur quantique : ce dernier aura le résultat, qu'il démarre à gauche ou à droite, l'addition sera calculée.

Voilà, alors, nous, on n'est pas quantique, matériellement, donc on commence de droite à gauche. Et l'électronique, nous suit : elle calcule de droite à gauche. Comme ça, le nombre n'est calculé qu'à 2% de son temps total alloué à l'addition, que ce résultat, pas encore connu est déjà en train de subir un autre calcul qui lui démarre sur la tronche.

Naturellement, ça signifie qu'un nombre de 64 bits peut être additionné 65 fois dans un temps théorique où seulement deux additions synchrones sont possibles.

Et que si SPH veut voir un de ces nombres, le processeur ne va pas perdre un temps plus important que 2% du temps de calcul pour lui extraire la valeur. C'est une notion de relativité restreinte : les bits sont, à la fois liés et indépendants.

Dans la foulée, SPH se voit avec un nombre à l'envers : de droite à gauche. SPH a donc une contrainte de retournement à subir pour obtenir ses fins.

Et c'est un bon exemple d'ArS avec son exemple de boucle à rebours.

[case]

Code : Tout sélectionner

quad.q=$0102030405060708
Dim oct(7)
For a=0 To 7
  oct(a)=PeekB(@quad+7-a)&$ff
  Debug oct(a)
Next

;

Code : Tout sélectionner

quad.q=$0102030405060708
Dim oct.b(7)
CopyMemory(@quad,@oct(0),8)
For a=7 To 0 Step -1
  Debug oct(a)
Next

; oups deja donnee par crisot

[Ollivier]

Pour la notion de pointeurs, les choix sont restreints.

Code : Tout sélectionner

Define.I Source = 12345 ; 1 variable...
Define.I Dest = 3210 ; 1 seconde variable...

Define *pointeur.Integer

*pointeur = @Source        ; choix n°1
Debug "Source = " +Str(*pointeur\I)

*pointeur = @Dest            ; choix n°2
Debug "Dest = " + Str(*pointeur\I)

Il n'y a de choix possible que ce que l'on définit...
Ici, 2 variables, donc 2 choix de pointage.

S'il y a peu de choix, alors ça facilite l'idée d'utiliser les pointeurs. On peut bien sûr faire exploser le nombre de choix. Mais ça reste méthodique.

Code : Tout sélectionner

Dim a.a(127)
Debug "Début "+Str(@a(0) )
Debug "Fin "+Str(@a(127) )

Ici, s'il fallait attribuer un pointeur par cellule de tableau, ça ferait plus d'une centaine de pointeurs en plus. La réalité, c'est qu'on a besoin d'un seul pointeur mais qui ne s'évade pas hors des limites "Début" et "Fin".

Ce qui se fait avec les pointeurs pour un tableau peut aussi s'appliquer pour un buffer.

Code : Tout sélectionner

Define *Debut = AllocateMemory(50)
*Fin = *Debut + 49

Une difficulté possible de compréhension :

Code : Tout sélectionner

Structure Gabarit
 *p[50000]
EndStructure

Define *p.Gabarit

Ici, la structure Gabarit n'alloue pas 50 000 pointeurs. C'est le buffer pointé par *p qui sera accessible par 50 000 entrées si la taille du buffer le permet. Si le buffer est moins grand que les 50 000 entrées, il y a des pointeurs qui provoqueront une erreur IMA (Invalid memory access) car ils pointeront tout autre chose que la mémoire gérée par notre tâche.

C'est un peu comme avoir une règle graduée transparente dans les mains et mesurer une boîte de sardines : il y a des centimètres sur la règle qui seront dans le vide, et qui ne serviront à rien dans la tâche de mesure. C'est pareil avec les pointeurs.