Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Please login or create an account
Change language to: English - Português - 日本語 - Русский
Aide de Scilab >> Listes Structures Cells > type

type

Retourne le type d'un objet Scilab

Séquence d'appel

i = type(x)

Paramètres

x

Objet Scilab quelconque : variable, ou expression valide.

i

Code numérique entier identifiant le type de x.

Description

type(x) renvoie le code numérique entier du type de l'objet x, défini comme suit :

1
nombres décimaux ou complexes.
2
polynômes à coefficients réels ou complexes.
4
booléens
5
matrice creuse numérique à valeurs réelles ou complexes.
6
matrice creuse booléenne.
7
matrice creuse au format Matlab
8
entiers encodés sur 1 octet (int8, uint8), 2 octets (int16, uint16), 4 octets (int32, uint32), ou 8 octets (int64, uint64).
9
identifiants d'objets graphiques ("handles").
10
textes
13
Fonction en langage Scilab compilé.
14
Bibliothèque de fonctions compilées en langage Scilab.
15
Liste simple.
16
Liste typée (tlist).
17
Liste typée matricielle (mlist).
128
Identifiant d'un bloc Xcos, d'un résultat de lufact(), etc.
129
Polynôme implicite utilisé pour indexer.
130
Fonction interne Scilab, aussi appellé primitive (Code C, C++ ou Fortran).
0
Elément d'une liste simple non défini. Il peut par exemple s'agir d'un argument d'entrée omis lors de l'appel d'une fonction Scilab tel que foo(a,,b) ; ou omis lors de la création d'une liste à trous telle que list(%pi,,%i,,,%z), etc. Pour tester l'état de ces objets, isdef() répond %T, mais on pourra vérifier que leur type est nul.

Remarques

Certaines données structurées sont stockées dans des listes typées de types 16 (tlist) ou 17 (mlist). C'est le cas pour les fractions rationnelles (rational), les structures (struct), les state-space, les arbres interactifs (uitree), etc, pour lesquelles type(..) répondra 16 ou 17. On utilisera alors typeof pour distinguer leurs types plus précisément.

Conversion de type lors d'opérations mixtes :

Lorsqu'un opérateur binaire -- telle que la multiplication -- ou n-aire i.e. binaire itéré -- telle que la concaténation -- agit sur deux opérandes de types différents mais compatibles, en général le type de l'un d'eux est implicitement converti, et l'autre opérande donne son type au résultat.

Exemples pour la concaténation : [%t, 3.124], [int8(5), 3.124], etc.

Pour la concaténation, l'addition, la soustraction, la multiplication, la division, et la puissance, la hiérarchie des types est la suivante (lire "A < B" : B impose son type à A) :

  • booléen < (nombre décimal, nombre encodé complexe)
  • (nombre décimal, nombre encodé complexe) < entier encodé.
  • polynôme (réel | complexe) < fraction rationnelle (réelle | complexe)

Exemples

// (Sélectionner des lignes, cliquer droit et choisir "Exécuter.." pour les exécuter dans la console)
L = list(%pi,,"abc");
type(L(2))                  // Element non défini dans une liste

type(42)                    // Nombres décimaux
type(%nan)
type(%inf)

type(1+%i)                  // Nombres complexes

s = sparse([1,2;4,5;3,10],[1,2,3]);
type(s)                     // Matrice creuse numérique, à valeurs réelles ou complexes

type(%t)                    // Booléens

type(s>2)                   // Matrice booléenne creuse

g = int8([1 -120 127 312]); // Entiers encodés
type(g)
type(1.23 * int8(4))

type(1-%z+%z^2)             // Polynômes

type(gdf())                 // Identifiants graphiques

type("foo")                 // Textes et caractères

deff('[x] = mymacro(y,z)',['a=3*y+1'; 'x=a*z+y']);
type(mymacro)               // Functions en langage Scilab

type(disp)                  // Fonctions compilées en langage externe

l = list(1,["a" "b"]);      // Lists simples
type(l)

e = tlist(["listtype","field1","field2"], [], []);
type(e)                     // Listes typées

h = mlist(['V','name','value'],['a','b';'c' 'd'],[1 2; 3 4]);
type(h)                     // Listes typées matricielles

clear s, s.r = %pi          // Structures
type(s)

c = {%t %pi %i %z "abc" s}  // cells
type(c)

r = [%z/(1-%z) (1-%z)/%z^2]
type(r)                     // Fractions polynomiales (rationnelles)

Voir aussi

  • typeof — type explicite ou code de surcharge d'un objet Scilab
  • inttype — type des entiers utilisés dans les types entiers de données.
  • isreal — Retourne %F si la matrice est encodée en numération complexe
  • brackets — Concaténation. Récipients d'une affectation. Résultats d'une function
  • overloading — display, functions and operators overloading capabilities
  • poly — définition d'un polynôme
  • rational — Objet Scilab, fraction rationnelle
  • tlist — Objet Scilab. Définition d'une liste typée
  • mlist — Objet Scilab, définition d'une liste typée

Historique

VersionDescription
6.0
  • Le type 11 est supprimé. Il était utilisé pour les fonctions Scilab non compilées.
  • type(:) vaut désormais 129 au lieu de 1.
  • L'affectation d'un objet de type 0 à une variable ne détruit plus celle-ci.
Scilab Enterprises
Copyright (c) 2011-2017 (Scilab Enterprises)
Copyright (c) 1989-2012 (INRIA)
Copyright (c) 1989-2007 (ENPC)
with contributors
Last updated:
Mon Feb 12 19:15:32 CET 2018