linspace suite de nombres équidistants entre 2 bornes atteintes

## Syntaxe

                row = linspace(x1, x2)
                row = linspace(x1, x2, n)
                Matrix = linspace(Col1, Col2)
                Matrix = linspace(Col1, Col2, n)

## Arguments

x1, x2

  Nombres réels ou complexes ou entiers encodés scalaires : bornes entre lesquelles les valeurs doivent être générées.

Col1, Col2

  Vecteurs colonne de nombres réels ou complexes ou entiers encodés, de mêmes tailles.

n

  Nombre entier positif. Il précise le nombre de valeurs ou de colonnes à générer entre les deux extrémités (extrémités comprises). 100 par défaut.

row

  Vecteur ligne de `n` nombres.

Matrix

  Matrice à `n` colonnes de nombres.

## Description

`linspace(x1, x2)` génère un vecteur ligne de `n` valeurs allant exactement de `x1` à `x2` à pas constant.

La syntaxe `y1:y2` ou `y1:step:y2` comme `1:0.1:%pi` produit une suite similaire, mais fixe la valeur de départ `y1` et le pas/incrément. `y2` sert de valeur d'arrêt à ne pas dépasser. La dernière valeur générée peut elle être inférieure, `y2` ne figurant alors pas parmi les valeurs générées.

Au lieu de fixer le pas/incrément, `linspace` fixe la seconde borne `x2` à exactement atteindre, et calcule le pas en conséquence.

Si `x1` ou `x2` sont des nombres complexes, `linspace(x1,x2)` interpole alors séparément la partie réelle de `x1` et `x2`, et d'autre part leur partie imaginaire.

Si des vecteurs colonnes `Col1` et `Col2` sont fournis, `linspace` est alors appliquée ligne par ligne : La `Matrix` résultante à le même nombre de lignes, et `n` colonnes, avec `Matrix(i,:) = linspace(Col1(i), Col2(i), n)`.

Lorsque les bornes fournies sont des entiers encodés, le pas effectif observable peut varier d'une unité le long de la série générée. Voir l'exemple ci-dessous.

## Exemples

    linspace(1, %pi, 0)         // n = 0
    linspace(1, 2, 10)          // x2 > x1 : suite croissante
    linspace(2, 1, 10)          // x2 < x1 : suite décroissante
    linspace(1+%i, 2-2*%i, 5)      // avec des nombres complexes
    linspace([1:4]', [5:8]', 10)   // avec des colonnes de bornes

    --> linspace(1, %pi, 0)    // n = 0
     ans  =
        []

    --> linspace(1, 2, 10)    // x2 > x1 : suite croissante
     ans  =
       1.   1.111   1.222   1.333   1.444   1.556   1.667   1.778   1.889   2.

    --> linspace(2, 1, 10)    // x2 &lt; x1 : suite décroissante
     ans  =
       2.   1.889   1.778   1.667   1.556   1.444   1.333   1.222   1.111   1.

    --> linspace(1+%i, 2-2*%i, 5)      // avec des nombres complexes
     ans  =
       1. +i     1.25 +0.25i   1.5 -0.5i   1.75 -1.25i   2. -2.i

    --> linspace([1:4]', [5:8]', 10)   // avec des colonnes de bornes
     ans  =
       1.   1.444   1.889   2.333   2.778   3.222   3.667   4.111   4.556   5.
       2.   2.444   2.889   3.333   3.778   4.222   4.667   5.111   5.556   6.
       3.   3.444   3.889   4.333   4.778   5.222   5.667   6.111   6.556   7.
       4.   4.444   4.889   5.333   5.778   6.222   6.667   7.111   7.556   8.

Avec des entiers encodés : le pas peut varier d'au plus une unité en cours de série, afin d'assurer que la borne supérieure est toujours atteinte :

    x = linspace(int8([5;127]), int8([127;5]), 10)
    x(:,1:$-1) - x(:,2:$)

    --> x = linspace(int8([5;127]), int8([127;5]), 10)
     ans  =
        5   18   32  45  59  72  86  99  113  127
      127  114  100  87  73  60  46  33   19    5

    --> x(:,1:$-1) - x(:,2:$)
     ans  =
     -13 -14 -13 -14 -13 -14 -13 -14 -14
      13  14  13  14  13  14  13  14  14

## Voir aussi

- colon
- logspace
- grand

## Historique

5.4.0

- Des vecteurs colonne de bornes peuvent être utilisées.
- Le nombre de colonnes générées doit être obligatoirement un entier.

6.0

- linspace(a, b, n<=0) produit [] au lieu de b.
- Toute borne %inf ou %nan est détectée et rejetée.

6.0.2 linspace() génère désormais de manière fiable les séries d'entiers encodés.