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 non défini d'une liste (de typeof `void`, tel que dans l'appel de fonction `foo(a,,b)`, ou dans `list(%pi,,%i,,,%z)`), ou objet nul produit par `null()` (de typeof `listdelete`).

### 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
- inttype
- isreal
- brackets
- overloading
- poly
- rational
- tlist
- mlist
- null

## Historique

6.0 Le type 11 est supprimé. Il était utilisé pour les fonctions Scilab non compilées.