[Haxe] Types numériques et Manipulations booléennes

Bonjour !

Habitué à la grande multitude de types numériques dans les langages utilisé jusque maintenant, je me sens un peu perdu en arrivant en Haxe avec des Float et des Int, et rien d'autre.

Dans le cas où je me trouve, je vais avoir besoin de plusieurs tableau pouvant stocker des valeurs allant de 0 à 128, je souhaiterais donc utiliser le plus petit volume mémoire possible pour mes variables.

Le problème étant que, je ne trouve même pas la taille mémoire d'un Int basique, j'ai bien vu qu'il y avait des ByteArray dans la librairie haxe.io, mais je ne trouve quasiment rien sur leur utilisation ...

Pourrait-on m'éclairer un peu ?

Pour aider, dans l'idéal, je dois pouvoir stocker dans une matrice tridimensionnelle des objets contenant des structures de données à taille variable, mais contenant tous au moins un identifiant numérique de type de case, pouvant être unique, double ou triple. Une map devant pouvoir faire au moins 128*64*128, il me faut concevoir une structure suffisamment légère.

Merci par avance.

PS : Si on me répond C++, j'y ai pensé, mais, pas pour ce projet là, désolé.

T'as http://api.haxe.org/haxe/io/Bytes.html mais il gère au plus petit que des Int16.

Ce que je ferais c'est ma propre classe custom qui contiens un array de Int32, et j'utiliserais les opérateurs binaires pour les manipuler byte a byte.
Le seul truc 'complexe' a écrire c'est les méthodes get/set:

Code:

get_byte(pos: Int):Int
{
  var shift = (pos % 4) << 3;
  return (array[ pos/4 ] & (0xFF << shift)) >> shift;
}

set_byte(pos: Int, byte: Int):Int
{
  var shift = (pos % 4) << 3;
  array[ pos/4 ] = (array[ pos/4 ] & ~(0xFF << shift)) | (byte << shift);
}

Bon par contre normalement vaux mieux utiliser un int non signé, je sais pas comment haxe gère les "dépassements", mais si tu limites les valeurs de 0 a 128 devrait pas y avoir de soucis.

Edit:

Tout con en fait: http://api.haxe.org/haxe/io/UInt8Array.html

Je ne vais pas jouer avec les dépassements donc ça devrait aller oui.
Je ne pense pas que le Haxe a une réelle gestion du dépassement, ça doit dépendre du langage d'export surtout.

Je vais essayer de comprendre ton code avant de l'utiliser, mais merci.

Edit : Ah bah ouaip, je l'avais pas vu lui, Mea Culpa. Je vais essayer de chercher des informations dessus. Merci.

onilink_ a écrit:

Code:

get_byte(pos: Int):Int
{
  var shift = (pos % 4) << 3;
  return (array[ pos/4 ] & (0xFF << shift)) >> shift;
}

set_byte(pos: Int, byte: Int):Int
{
  var shift = (pos % 4) << 3;
  array[ pos/4 ] = (array[ pos/4 ] & ~(0xFF << shift)) | (byte << shift);
}

(Recyclage de topic ! \o/ )

Les opérations que tu fais là m’intéresse car pour ainsi dire, les opérateurs >>, <<, |, & et ~ sont des opérateurs booléan, mais je n'ai pas trop compris comment ils fonctionnent. x)

Dans une optique de progression avant tout, j'essaye de manipuler à la manière que j'ai pu te voir faire là, plusieurs taille d'encodage de nombre dans un Int.

Par exemple, je veux faire en sorte que sur une séquence de 4 Octet, taille par défaut d'un Int, j'ai du genre ça comme cases :
[] [][][][][][][][][] [][][][][][][][][] [][][][][][][][][] [][][][]

En bref, je cherche à découper de manière dynamique les bits de mon fichier pour l’interpréter tel que je veux, en gardant parfois le byte seul, donc 0 ou 1, ou en le groupant avec 8 autres bit pur l’interpréter en un nombre de 0 à 511.

Donc première question : Suis-je simplement fou ou un abrutis fini ? 
Seconde question : Pourrait-on m'expliquer un peu le fonctionnement de ses opérateurs ? Enfin, dans le cas présent, car j'ai du mal à le visualiser. 

Ooooh ! Tu avais déjà pensé à tout il y a un moment je vois !  Je regarde ça.

Merci.