<?xml version="1.0" encoding="UTF-8"?>
<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns3="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="dot" xml:lang="fr">
    <refnamediv>
        <refname>dot (.)</refname>
        <refpurpose>point</refpurpose>
    </refnamediv>
    <refsynopsisdiv>
        <title>Séquence d'appel</title>
        <synopsis>123.33

            a.*b
            a .*. b

            %pi * (%e + ..
            %i)

            cd ..
            dir ..
        </synopsis>
    </refsynopsisdiv>
    <refsection>
        <title>Description</title>
        <variablelist>
            <varlistentry>
                <term>.</term>
                <listitem>
                    <para>Le point est utilisé dans la notation décimale : 3.25 et 0.001.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>.&lt;op&gt;</term>
                <listitem>
                    <para>Il est aussi utilisé en conjonction avec d'autres opérateurs
                        (<literal>* / \ ^ '</literal>) pour en former de nouveaux. Les opérations
                        multiplicatives "élément par élément" sont obtenues avec <literal>.* , .^ ,
                            ./ , .\ ou .'
                        </literal>
                        .Par exemple, <literal>C = A ./ B</literal> est la matrice dont les
                        éléments sont <literal>c(i,j) = a(i,j)/b(i,j)</literal>. Le produit de Kronecker est
                        noté <literal>.*.</literal>.
                    </para>
                    <para>
                        <note>
                            Notez que lorsqu'un point est utilisé pour un opérateur, il n'est pas
                            considéré comme faisant partie d'un nombre précédant ce point. Ainsi <literal>2.*x</literal> et <literal>2 .*x</literal> sont évalués comme <literal>(2).*x</literal> et pas comme <literal>2.0*x</literal>.
                        </note>
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>..</term>
                <listitem>
                    <para>Passage à la ligne. Deux points ou plus à la fin d'une ligne font en
                        sorte que la ligne suivante est considérée comme en étant la suite
                        (le retour chariot n'est pas pris en compte).
                    </para>
                    <para>Les lignes de suite sont traitées par un préprocesseur dont
                        l'objet est de construire une ligne logique à partir d'une suite de
                        lignes physiques. Les points de suite peuvent ainsi être utilisés
                        pour couper une ligne logique à n'importe quel endroit.
                    </para>
                    <para>
                        La fonction <literal>foo</literal> suivante :
                    </para>
                    <programlisting role=""><![CDATA[
function foo()
    plot2d()
    xtitle(["Titre général"; "Peut être sur plusieurs lignes, donc assez long"], ..
            "Ceci est le titre de l''axe des X", "titre de l''axe Y")
endfunction
 ]]></programlisting>
                    <para>est équivalente à :</para>
                    <programlisting role=""><![CDATA[
function foo()
    plot2d()

    xtitle(["Titre général"; "Peut être sur plusieurs lignes, donc assez long"], "Ceci est le titre de l''axe des X", "titre de l''axe Y")
endfunction
 ]]></programlisting>
                    <para>La ligne logique formée par les lignes physiques 3 et 4 est
                        construite comme si elle était entièrement écrite sur la ligne
                        physique 4 alors que la ligne physique 3 serait vide. Cette manière
                        de faire est nécessaire car les points de suite peuvent apparaître
                        n'importe où dans la ligne logique, même à l'intérieur d'une
                        expression.
                        <note>La différence entre lignes logiques et lignes physiques
                            a son importance lors de l'édition (scinotes, edit) et dans les messages d'erreurs (whereami),
                            lorsque le numéro de ligne est fourni ou affiché.
                        </note>
                    </para>
                    <para>
                        Il y a des exception à cette règle dans un environnement matriciel afin
                        de faciliter la lecture des scripts scilab. L'exemple suivant met à jour quelques
                        différences entre l'environnement matriciel et non matriciel pour la marque de passage
                        à la ligne.
                    </para>
                    <programlisting role=""><![CDATA[
// Dans un environnement matriciel .. est la marque de passage à la ligne
// sauf dans quelques cas où la lisibilité du script est importante

// ma_matrice == [1 2 3 -4 5 6]
ma_matrice = [ 1 2 3 -4 5 6] // le signe moins ici est unaire

// ma_matrice == [1 2 -1 5 6]
ma_matrice = [ 1 2 3 -... // le signe moins séparé par .. est toujours considéré comme une opération binaire
4 5 6]
                     ]]></programlisting>

                    <para>
                        Une erreur est générée si la marque de passage à la ligne est insérée dans un mot-clé, un nom de variable ou un mot reservé du langage.
                    </para>
                    <programlisting role=""><![CDATA[
// ceci est possible en scilab
for a_word = 1:10
    disp("test " + string(a_word))
end


// cela génère une erreur
for a_...
word = 1:10
    disp("test " + string(a_word))
end
// Scilab ne peut analyser correctement a_...word
                    ]]></programlisting>
                    <para>
                        Une erreur est générée si autre chose qu'une commentaire suit la marque de passage à la ligne
                    </para>

                    <programlisting role=""><![CDATA[
this_wont_work = 3 + ... 4 // Scilab ne sait pas analyser cette ligne

this_wont_work_either = 3 + ... /* un commentaire
sur plusieurs lignes suivi de texte */ 4

this_works = 3 + ... /* un commentaire
sur plusieurs lignes puis retour à la ligne */
4
                     ]]></programlisting>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Exemples</title>
        <programlisting role="example"><![CDATA[
// Point decimal
1.345
x = [1 2 3];
x.^2 .*x // il faut absolument mettre un espace entre le 2 et le point

// Dans le symbole de certains operateurs
x = [1 2 3];
x .^ 2 .*x  // L'espace entre 2 et .* n'est pas nécessaire

// Lorsqu'une matrice est écrite ligne par ligne, ".." peut être utilisé mais n'est pas obligatoire.
N_ligne = [   ..
    63.    89.    3.   ..
    91.    56.    22.  ..
    15.    64.    40.  ..
    ]
// Sans la marque de passage à la ligne la matrix est lue ligne par ligne
N_carree = [
    63.    89.    3.
    91.    56.    22.
    15.    64.    40.
    ]

// Dans les instructions très longues telles que les uicontrol() où l'indication de nombreuses
//  propriétés est souvent requise, la marque .. de continuation est quasi incontournable. Elle
//  permet d'écrire une propriété par ligne, ce qui rend le code lisible et compatible avec
//  les règles de style de code de Scilab :
fig = figure("figure_name", "FIGURE", ..
             "dockable",    "off", ..
             "axes_size",   [990,670], ..
             "infobar_visible", "off", ..
             "toolbar",     "none", ..
             "menubar_visible", "on", ..
             "menubar",     "none", ..
             "default_axes","off", ..
             "layout",      "border", ..
             "background",  color(244,244,244), ..
             "tag",         "figure_1", ..
             "visible",     "on");

// Appels de fonctions orientés console (sans les () ) avec un paramètre ".." :
d = pwd(); cd SCI/contrib
cd ..   // équivaut à cd("..") et n'attend rien en ligne suivante
cd(d)   // (retour à votre dossier initial)

// Cette expression ne fonctionne plus dans Scilab 6
a = "Je commence à écrire une très longue chaîne de caractères...
     - et je continue ici"
// L'expression suivante est celle à utiliser
a = "Je commence à écrire une très longue chaîne de caractères"+...
    "    - et je continue ici"
// Cette expression n'est plus autorisée dans Scilab 6: Les singletons doivent être écrits sur une ligne
y = 12..
45
 ]]></programlisting>
    </refsection>
    <refsection role="see also">
        <title>Voir aussi</title>
        <simplelist type="inline">
            <member>
                <link linkend="star">star</link>
            </member>
            <member>
                <link linkend="hat">hat</link>
            </member>
            <member>
                <link linkend="slash">slash</link>
            </member>
            <member>
                <link linkend="backslash">backslash</link>
            </member>
            <member>
                <link linkend="whereami">whereami</link>
            </member>
            <member>
                <link linkend="edit">edit</link>
            </member>
        </simplelist>
    </refsection>
    <refsection>
        <title>Historique</title>
        <revhistory>
            <revision>
                <revnumber>6.0.0</revnumber>
                <revremark>
                    <para>
                        Il est désormais impossible de couper un scalaire.
                    </para>
                    <para>
                        Pour couper une chaîne de caractères, les opérateurs "+ .." doivent être utilisés.
                    </para>
                    <para>Dans les appels de fonctions en mode orienté console,
                        <literal>myfun ..</literal> n'attend plus de suite en ligne suivante.
                    </para>
                </revremark>
            </revision>
        </revhistory>
    </refsection>
</refentry>
