Les types de données

Sous Matlab, les éléments d'une matrice peuvent être de 5 types (classes) différents. Le typage est automatique dans le sens où il n'est pas nécessaire de déclarer les variables avant de les utiliser. Au moment de la création d'une variable, Matlab lui affecte un type par défaut en fonction de la valeur qu'on lui a affecté.

Le type logical

Une variable logique peut prendre deux valeur true (1) ou false 0. Elle est codée sur un octet. En fait, tout ce qui est différent de 0 est considéré comme true.

>> a = true
  a = 1

>> b = false
  b =  0

>> c = 4 > 1
  c =  1

>> d = [20 9 8 30 40 5] > 10
  d =  1     0     0     1     1     0

>> whos
  Name      Size            Bytes  Class      Attributes
  a         1x1                 1  logical             
  b         1x1                 1  logical             
  c         1x1                 1  logical             
  d         1x6                 6  logical

            

Le type char

Chaque caractère est codé par son code Unicode sur 2 octets
>> c = 'A';
>> s = 'ABCD'
>> whos
  Name      Size            Bytes  Class    Attributes
  c         1x1                 2  char              
  s         1x4                 8  char 
            

Les types Numériques

le type cellule

Conversion entre types numériques

int8(n)	Convertir n de son type d'origine vers le type entier 8 bits signé. Ce type ne peut représenter que les nombres compris entre -128 et +127. Si la valeur de n est hors cet intervalle, elle sera tronquée à +127 ou à -128 >> a = int8(50)    a =   50 >> b = int8(200)    b = 127 >> c = int8(-150)    c =  -128 >> d = uint16(2300)    d =  2300 >> e = int8(d)    e =   127 >> whos   Name      Size            Bytes  Class     Attributes   a         1x1                 1  int8                  b         1x1                 1  int8                  c         1x1                 1  int8                  d         1x1                 2  uint16                e         1x1                 1  int8
uint8(n)	Convertir n de son type d'origine vers le type entier 8 bits non signé. Ce type ne peut représenter que les nombres compris entre 0 et 255. Si la valeur de n est hors cet intervalle, elle sera tronquée à 0 ou à 255 >> a = uint8(50)    a =   50 >> b = uint8(300)    b = 255 >> c = uint8(-150)    c =  0
int16(n)	Convertit n en un entier 16 bits signé. Le résultat est compris dans l'intervalle [-32768,  -32768]
uint16(n)	Convertit n en un entier 16 bits non signé. Le résultat est compris dans l'intervalle [0,  65535]
int32(n)	Convertit n en un entier 32 bits signé. Le résultat est compris dans l'intervalle [-2147483648,  2147483647]
uint32(n)	Convertit n en un entier 32 bits non signé. Le résultat est compris dans l'intervalle [0,  4294967295]
int64(n)	Convertit n en un entier 64 bits signé. Le résultat est compris dans l'intervalle [-9223372036854775808, 9223372036854775807]
uint64(n)	Convertit n en un entier 64 bits non signé. Le résultat est compris dans l'intervalle [0, 18446744073709551615]
single(n)	Convertit n en un réel simple précision (32 bits). Le résultat est compris dans l'intervalle [-3.4028e+038, +  3.4028e+038] tous les nombres compris dans l'intervalle ]-1.1755e-038, 1.1755e-038[ sont représentés par 0
double(n)	Convertit n en un réel double précision (64 bits). Le résultat est compris dans l'intervalle [-1.7977e+308,   1.7977e+308] double est le type par défaut.
cast(n,type)	Convertit n vers le type précisé. Cette fonction permet de remplacer n'importe laquelle des fonction ci-dessus. cast(n, 'int8') ≡ int8(n) cast(n, 'uint16') ≡ int16(n)
typecast(n,type)	Convertit n vers le type précisé sans modifier la valeur de la donnée. Si n est plus grand que le nombre max que l'on peut représenter avec le type désiré, il sera tronçonner en plusieurs morceaux. prenons l'exemple du nombre 888666444, si on le représente en binaire, on voit qu'il fait 30 bits. Il faut donc au moins  quatre octets pour le représenter. dec2bin(888666444) ans = 110100111101111111100101001100 On commence par affecter notre valeur à une variable N de type uint32, ce qui ne pose aucun problème >> N = uint32(888666444) N =  888666444 On essaye ensuite d'affecter le contenu de cette variable à une variable M de type uint8 >> M = typecast(N,'uint8') M =   76  249  247   52 On obtient une matrice (vecteur) de quatre nombre de type uint8. C'est normal, notre valeur d'origine est constituée de quatre octet           888666444 =  110100 11110111 11111001 01001100                                =      52             247             249            76 Remarquez que le premier élément du vecteur M est l'octet de plus faible poids de N. C'est la représentation LittleEndian. Pour les inverser, on a deux solution: Après la conversion, on 'retourne' le vecteur M >> M = fliplr(M) M =  52  247  249   76 On retourne le nombre N avant la conversion >> M = typecast(swapbytes(N),'uint8') M =   52  247  249   76

Conversion entre nombres et string

char(N)	Retourne le caractère de code Unicode N. N doit être un entier positif  compris entre 0 et 65535 >> s = char(65)   s = A >> S = char([65 66 67 68])    S = ABCD >> S = char(65 : 65+25)    S = ABCDEFGHIJKLMNOPQRSTUVWXYZ -------------------------------------------------------------------------- Si C est un tableau de cellules de chaînes de caractères. Char(C) retourne une matrice de caractères, les chaînes sont complétées par des espaces pour former une matrice rectangulaire. Utiliser sellstr() pour faire l'opération inverse. >> C = {'ABCD' 'abcdefg'; 'XYZ'  '012'} C =     'ABCD'    'abcdefg'     'XYZ'     '012'    >> SS = char(C) SS = ABCD   XYZ    abcdefg 012
int2str()	Convertit un entier en une chaîne. C'est souvent très utile avec l'interface GUI quand on a des champs d'affichage qui n'accepte que des strings >> s = ['Figure n° '   int2str(125)]    s = figure n° 125
mat2str()	Retourne la chaîne qui a servi à la définition de la matrice. >> A = magic(4) A =     16     2     3    13      5    11    10     8      9     7     6    12      4    14    15     1 >> S = mat2str(A)    S = [16 2 3 13;5 11 10 8;9 7 6 12;4 14 15 1]
num2str()	Convertit un nombre quelconque en une chaîne. C'est souvent très utile quand il faut coller un nombre avec une chaîne. Surtout avec l'interface GUI quand on a des champs d'affichage qui n'acceptent que des strings >> s1 = 'La température du four est égale à '; >> s2 = 'degré'; >> n = 850.5; >> S = [s1 num2str(n) s2]    S = La température du four est égale à 850.5 degrés
str2double()	Convertit une chaîne en un nombre de type double. Ceci est très utile, par exemple, quand on vient de récupérer le contenu d'un champs de saisie comme le contrôle GUI Edit, il est sous forme d'une chaîne >> R = str2double('23.5e3')    R =  23500 >> str2double('123.45e7')    ans = 1.2345e+009
str2num()	Convertit une chaîne en un nombre. A de rares exceptions près, elle produit les mêmes résultats que str2double(). Par défaut, le nombre retoutné est de type double. Si on veut que le résultat soit dans un type autre que double, on peut procéder de trois façons: >> n = str2num('uint16(3500)')    n = 3500 >> m = uint16( str2num('3500'))    m = 3500 >> k = cast(str2num('3500'), 'uint16')    k = 3500 >> whos   Name      Size            Bytes  Class     Attributes   k         1x1                 2  uint16                m         1x1                 2  uint16                n         1x1                 2  uint16
native2unicode()	Reconstitue une chaîne à partir des codes de ces caractères >> N = [65  195  167  195  169   66]    N = 65   195   167   195   169    66 >> s = native2unicode(N, 'utf-8')    s = AçéB On remarque qu'avec le codage utf-8, les caractères ç et é sont codés par deux octet chacun.
unicode2native()	Réalise le codage d'une chaîne conformément à codage standard B = unicode2native('AçéB', 'latin-1')    B =   65  231  233   66 B = unicode2native('AçéB','utf-8') B =   65  195  167  195  169   66 on remarque avec le codage utf-8,  ç est codé par deux octets 195, 167 ainsi que é qui est codé par 195, 169

Conversion entre matrices et cellules

cell2mat()	Convertit une matrice de cellule en une matrice de nombres
cell2struct()	Convertie une matrice de cellule en une structure
cellstr()	Construit une matrice de cellules contenant des chaînes à partir d'une matrice de chaînes
mat2cell()	Convertit une matrice en une matrice de cellule avec potentiellement des cellules de taille différentes
num2cell()	Convertit un tableau en une matrice de cellules
struct2cell()	Convertit une structure en une matrice de cellules

Identifier le type d'une donnée

Voici une liste non exhaustive de fonctions qui permettent de renseigner sur les types des données.

class(x)	Retourne la classe (type) de x
whos	Affiche toutes les variables avec leur taille et leur type
iscell(x)	Vrai si x est une matrice de cellule
iscellstr(x)	Vrai si x est une matrice de cellule contenant des chaînes
ischar(x)	Vrai si x est de type char
isfloat(x)	Vrai si x est de type single ou double
isinteger(x)	Vrai si x est un entier
islogical(x)	Vrai si x est une variable logique
isnumeric(x)	Vrai si x est un nombre
isreal(x)	Vrai si x est un réel pur sans partie imaginaire
isscalar(x)	Vrai si x est un scalaire: valeur unique (matrice  1x1)
isstr(x)	Vrai si x est une chaine
isstruct(x)	Vrai si x est une structure
isvector(x)	Vrai si x est un vecteur; matrice à une seule ligne ou une seule colonne.

Quelques constantes et fonctions utiles

ans	Variable qui reçoit le résultat de la dernière opération s'il n'a pas été affecté à une variable spécifique.
eps	Valeur très faible (2.2204e-016) correspondant à la précision de calcul avec les nombres réel
pi	3.1415926535897...
inf	infini
NaN	Not a Number (0/0,  inf/inf ...)
i, j	unité imaginaire pour les nombre complexes
intmax	Le plus grand entier d'un type entier donné. >> intmax('uint8')   ans =  255 >> intmax('int32')    ans = 2147483647
intmin	Le plus petit entier d'un type entier donné. >> intmin('int32')    ans = -2147483648 >> intmin('uint32')    ans = 0
realmax	Le plus grand réel d'un type float donné. >> realmax('single')    ans = 3.4028e+038 >> realmax('double') ans =  1.7977e+308
realmin	Le plus petit réel d'un type float donné. >> realmin('single')    ans = 1.1755e-038 >> realmin('double')    ans = 2.2251e-308