dot (.) point

## Séquence d'appel

    123.33

                a.*b
                a .*. b

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

                cd ..
                dir ..

## Description

.

  Le point est utilisé dans la notation décimale : 3.25 et 0.001.

.<op>

  Il est aussi utilisé en conjonction avec d'autres opérateurs (`* / \ ^ '`) pour en former de nouveaux. Les opérations multiplicatives "élément par élément" sont obtenues avec `.* , .^ , ./ , .\ ou .'` .Par exemple, `C = A ./ B` est la matrice dont les éléments sont `c(i,j) = a(i,j)/b(i,j)`. Le produit de Kronecker est noté `.*.`.

  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 `2.*x` et `2 .*x` sont évalués comme `(2).*x` et pas comme `2.0*x`.
..

  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).

  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.

  La fonction `foo` suivante :

      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

  est équivalente à :

      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

  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.

  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é.

  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.

      // 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]

  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.

      // 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

  Une erreur est générée si autre chose qu'une commentaire suit la marque de passage à la ligne

      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

## Exemples

    // 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

## Voir aussi

- star
- hat
- slash
- backslash
- whereami
- edit

## Historique

6.0.0

Il est désormais impossible de couper un scalaire.

Pour couper une chaîne de caractères, les opérateurs "+ .." doivent être utilisés.

Dans les appels de fonctions en mode orienté console, `myfun ..` n'attend plus de suite en ligne suivante.