Types de données en Scilab

Types de données en Scilab

Scilab supporte plusieurs types de données fondamentaux : booléens, nombres complexes, entiers (plusieurs précisions), flottants double précision et chaînes de caractères. Comprendre ces types est essentiel pour éviter les erreurs de conversion et choisir la bonne représentation selon le contexte.

1. Booléens

b = %t          // true  (ou %T)
b = %f          // false (ou %F)

// Opérateurs logiques booléens
%t & %f         // ET  → %f
%t | %f         // OU  → %t
~%t             // NON → %f

Exemple n°1 — Booléens et opérations logiques

etat = %t
disp(etat)             // T

etat = %f
disp(etat)             // F

// Comparaisons → booléens
disp(3 > 2)            // T
disp(3 == 2)           // F

// Booléen comme masque sur un vecteur
v = [1 5 3 8 2]
masque = (v > 3)       // [F T F T F]
disp(masque)
disp(v(masque))        // éléments > 3 : [5. 8.]

T
F
T
F
masque = F T F T F
v(masque) = 5.  8.

v = [4 1 7 2 9 3]
nb_sup_5 = sum(v > 5)    // compte les éléments > 5 → 2
disp(nb_sup_5)

2. Nombres complexes

z = a + b * %i      // création d'un complexe

real(z)             // partie réelle
imag(z)             // partie imaginaire
abs(z)              // module |z| = sqrt(a²+b²)
conj(z)             // conjugué ā - b·i
isreal(z)           // %f si z a une partie imaginaire non nulle

Exemple n°2 — Opérations sur les complexes

x = 1 + %i
y = 1 - %i

disp("x         = " + string(x))
disp("isreal(x) = " + string(isreal(x)))  // F

disp("real(y)   = " + string(real(y)))    // 1
disp("imag(y)   = " + string(imag(y)))    // -1
disp("abs(x)    = " + string(abs(x)))     // √2 ≈ 1.4142
disp("x * y     = " + string(x * y))      // (1+i)(1-i) = 1+1 = 2

// Vérification : i² = -1
disp("%i^2 = " + string(%i^2))            // -1

x         = 1 + i
isreal(x) = F
real(y)   = 1.
imag(y)   = -1.
abs(x)    = 1.4142136
x * y     = 2.
%i^2      = -1.

3. Entiers

Fonctions de conversion et inspection

Exemple n°3 — Création et inspection de types entiers

a = int8(3)
b = uint8(3)
c = int32(3)
d = uint32(3)

disp("inttype(a) = " + string(inttype(a)))    // 1  → int8
disp("inttype(b) = " + string(inttype(b)))    // 11 → uint8
disp("inttype(c) = " + string(inttype(c)))    // 4  → int32
disp("inttype(d) = " + string(inttype(d)))    // 14 → uint32

inttype(a) = 1.
inttype(b) = 11.
inttype(c) = 4.
inttype(d) = 14.

x = int8(200)     // ❌ dépasse [−128, 127]
disp(x)           // → 127  (saturation à la valeur max)

y = uint8(-5)     // ❌ négatif sur un type non signé
disp(y)           // → 0   (saturation à la valeur min)

4. Virgules flottantes

// ❌ Comparaison stricte dangereuse
disp(0.1 + 0.2 == 0.3)             // F  (erreur d'arrondi !)

// ✅ Comparaison avec tolérance
disp(abs(0.1 + 0.2 - 0.3) < %eps) // T

5. Chaînes de caractères

s = "bonjour"           // création
s1 + s2                 // concaténation
length(s)               // longueur
string(valeur)          // conversion numérique → chaîne
strsplit(s, sep)        // découpage
strsubst(s, old, new)   // remplacement
part(s, i:j)            // extraction de sous-chaîne

Exemple n°4 — Opérations sur les chaînes

x = "foo"
y = "bar"

// Concaténation
disp(x + y)                          // foobar

// Longueur
disp(length("bonjour"))              // 7

// Conversion nombre → chaîne pour affichage
n = 42
disp("La réponse est : " + string(n))  // La réponse est : 42

// Extraction d'une sous-chaîne (indices 1 à 3)
mot = "Scilab"
disp(part(mot, 1:3))                 // Sci

// Remplacement
disp(strsubst("hello world", "world", "Scilab"))  // hello Scilab

foobar
7
La réponse est : 42
Sci
hello Scilab

a = 3
b = 4
hyp = sqrt(a^2 + b^2)
disp("Hypoténuse de (" + string(a) + ", " + string(b) + ") = " + string(hyp))
// → Hypoténuse de (3, 4) = 5.

Récapitulatif — Types de données