<?xml version="1.0" encoding="UTF-8"?>
<!--
 * Scilab ( https://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) INRIA
 * Copyright (C) 2017 - Samuel GOUGEON
 *
 * Copyright (C) 2012 - 2016 - Scilab Enterprises
 *
 * This file is hereby licensed under the terms of the GNU GPL v2.0,
 * pursuant to article 5.3.4 of the CeCILL v.2.1.
 * This file was originally licensed under the terms of the CeCILL v2.1,
 * and continues to be available under such terms.
 * For more information, see the COPYING file which you should have received
 * along with this program.
 *
 -->
<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML"
    xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
    xml:lang="fr" xml:id="type">
    <refnamediv>
        <refname>type</refname>
        <refpurpose>Retourne le type d'un objet Scilab</refpurpose>
    </refnamediv>
    <refsynopsisdiv>
        <title>Séquence d'appel</title>
        <synopsis>i = type(x)</synopsis>
    </refsynopsisdiv>
    <refsection>
        <title>Paramètres</title>
        <variablelist>
            <varlistentry>
                <term>x</term>
                <listitem>
                    <para>
                        Objet Scilab quelconque : variable, ou expression valide.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>i</term>
                <listitem>
                    <para>Code numérique entier identifiant le type de <varname>x</varname>.
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Description</title>
        <para>
            <literal>type(x)</literal> renvoie le code numérique entier du type de l'objet
            <literal>x</literal>, défini comme suit :
        </para>
        <variablelist>
            <varlistentry>
                <term>1</term>
                <listitem>
                    nombres décimaux ou complexes.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>2</term>
                <listitem>
                    <link linkend="poly">polynômes</link> à coefficients réels ou complexes.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>4</term>
                <listitem>
                    booléens
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>5</term>
                <listitem>
                    <link linkend="sparse">matrice creuse numérique à valeurs réelles ou complexes</link>.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>6</term>
                <listitem>
                    <link linkend="sparse">matrice creuse booléenne</link>.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>7</term>
                <listitem>
                    matrice creuse au format Matlab
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>8</term>
                <listitem>
                    <link linkend="int8">entiers</link> encodés
                    sur 1 octet (int8, uint8), 2 octets (int16, uint16), 4 octets (int32, uint32),
                    ou 8 octets (int64, uint64).
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>9</term>
                <listitem>
                    <link linkend="graphics_entities">identifiants d'objets graphiques</link>
                    ("handles").
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>10</term>
                <listitem>
                    <link linkend="strings">textes</link>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>13</term>
                <listitem>
                    <link linkend="function">Fonction</link> en langage Scilab compilé.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>14</term>
                <listitem>
                    Bibliothèque de fonctions compilées en langage Scilab.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>15</term>
                <listitem>
                    <link linkend="list">Liste</link> simple.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>16</term>
                <listitem>
                    Liste typée (<link linkend="tlist">tlist</link>).
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>17</term>
                <listitem>
                    Liste typée matricielle (<link linkend="mlist">mlist</link>).
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>128</term>
                <listitem>
                    Identifiant d'un bloc Xcos, d'un résultat de
                  <link linkend="lufact">lufact</link>(), etc.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>129</term>
                <listitem>
                    Polynôme implicite utilisé pour indexer.
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>130</term>
                <listitem>
                    Fonction interne Scilab, aussi appellé <emphasis role="italic">primitive</emphasis> (Code C, C++ ou Fortran).
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>0</term>
                <listitem>
                    Elément non défini d'une liste (de typeof <literal>void</literal>, tel que
                    dans l'appel de fonction <literal>foo(a,,b)</literal>, ou dans
                    <literal>list(%pi,,%i,,,%z)</literal>),
                    ou objet nul produit par <literal>null()</literal> (de typeof
                    <literal>listdelete</literal>).
                </listitem>
            </varlistentry>
        </variablelist>
        <refsect2>
        <title>Remarques</title>
            <para>
                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
                (<emphasis role="italic">rational</emphasis>), les structures
                (<emphasis role="italic">struct</emphasis>),
                les <emphasis role="italic">state-space</emphasis>, les arbres interactifs
                (<emphasis role="italic">uitree</emphasis>), etc, pour lesquelles
                <literal>type(..)</literal> répondra 16 ou 17. On utilisera alors
                <link linkend="typeof">typeof</link> pour distinguer leurs types plus précisément.
            </para>
            <para>
                <emphasis role="bold">Conversion de type lors d'opérations mixtes</emphasis> :
            </para>
            <para>
                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.
                <para>
                    Exemples pour la  <link linkend="brackets">concaténation</link> :
                    <literal>[%t, 3.124]</literal>, <literal>[int8(5), 3.124]</literal>, etc.
                </para>
                <para>
                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 &lt; B" :
                B impose son type à A) :
                <simplelist>
                    <member>
                        booléen &lt; (nombre décimal, nombre encodé complexe)
                    </member>
                    <member>
                        <warning>
                            (nombre décimal, nombre encodé complexe) &lt; entier encodé.
                        </warning>
                    </member>
                    <member>
                        polynôme (réel | complexe) &lt; fraction rationnelle (réelle | complexe)
                    </member>
                </simplelist>
                </para>
            </para>
        </refsect2>
    </refsection>
    <refsection>
        <title>Exemples</title>
        <programlisting role="example"><![CDATA[
// (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)
]]></programlisting>
    </refsection>
    <refsection role="see also">
        <title>Voir aussi</title>
        <simplelist type="inline">
            <member>
                <link linkend="typeof">typeof</link>
            </member>
            <member>
                <link linkend="inttype">inttype</link>
            </member>
            <member>
                <link linkend="isreal">isreal</link>
            </member>
            <member>
                <link linkend="brackets">brackets</link>
            </member>
            <member>
                <link linkend="overloading">overloading</link>
            </member>
            <member>
                <link linkend="poly">poly</link>
            </member>
            <member>
                <link linkend="rational">rational</link>
            </member>
            <member>
                <link linkend="tlist">tlist</link>
            </member>
            <member>
                <link linkend="mlist">mlist</link>
            </member>
            <member>
                <link linkend="null">null</link>
            </member>
        </simplelist>
    </refsection>
    <refsection role="history">
        <title>Historique</title>
        <revhistory>
            <revision>
                <revnumber>6.0</revnumber>
                <revdescription>
                  Le type 11 est supprimé. Il était utilisé pour les fonctions Scilab non compilées.
                </revdescription>
            </revision>
        </revhistory>
    </refsection>
</refentry>
