Pour fabriquer une séquence ou une liste : seq $

### 6.39.5 Pour fabriquer une séquence ou une liste : `seq $`

`seq` peut renvoyer une séquence (avec la même syntaxe que `Maple`) ou une liste (avec la même syntaxe que `TI`) selon la forme de ses arguments qui sont : une expression dépendant d’un paramètre (par exemple j) et des paramètres décrivant la variation de j.
`$` renvoie une séquence et c’est la version infixée de `seq` lorsque `seq` a deux arguments : une expression dépendant d’un paramètre (par exemple j) et (j=a..b) où a et b sont des nombres réels (par exemple `j```^```2$ (j=-1..3)`), ou une expression constante et un nombre n (par exemple `4$3`).
`seq` a deux, trois, quatre ou cinq arguments car on peut exprimer la variation de j de a à b à l’aide d’un argument (j=a..b) ou de deux arguments (j,a..b) (syntaxe `Maple` où il n’y a pas la possibilité de mettre un paramètre de saut) ou encore à l’aide de trois arguments (j,a,b) ou de quatre arguments (j,a,b,p) (syntaxe `TI` avec la possibilité de mettre p comme paramètre de saut).

- Syntaxe simplifiée `Xcas`
  `seq` a deux arguments un intervalle de réels a..b et un réel p (le pas) `seq` renvie la séquence des réels entre a et b par pas de p.
  `$` a les même arguments mais est une fonction infixée et il faut parenthéser les arguments.
  On tape :
  `seq(1..3,0.2)`
  Ou on tape :
  `(1..3)$0.2`
  On obtient :
  `(1,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.6,2.8,3.0)`
  On tape :
  `seq(1..3,2/10)`
  Ou on tape :
  `(1..3)$(2/10)`
  On obtient :
  `(1,6/5,7/5,8/5,9/5,2,11/5,12/5,13/5,14/5,3)`
  Pour avoir une liste il suffit de rajouter des crochets :
  On tape :
  `[seq(1..3,0.2)`]
  Ou on tape :
  `[(1..3)$0.2]`
  On obtient :
  `[1,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.6,2.8,3.0]`
- Syntaxe compatible `Maple`
  `seq` a deux arguments une expression dépendant d’un paramètre (par exemple j) et j=a..b où a et b sont des nombres réels (ou une expression constante et un nombre n). On peut ajouter pour `seq` un troisième argument, le pas (1 par défaut).
  `$` a les même arguments mais est une fonction infixée et il faut parenthéser les arguments et le pas vaut toujours 1.
  `seq` (ou `$`) définit la séquence obtenue en remplacant dans l’expression j par a, a+1..b si b>a et par a, a−1..b si b<a (ou `seq` renvoie la séquence formée par n fois la constante).
  -`seq` a trois arguments une expression dépendant d’un paramètre (par exemple j), le nom du paramètre (par exemple j) et a..b où a et b sont des nombres réels, ou
  `seq` définit la séquence obtenue en remplacant dans l’expression j par a, a+1..b si b>a et par a, a−1..b si b<a le pas est donc soit égal à 1, soit égal à -1.
  On tape :
  `seq(0.4,5)`
  Ou on tape :
  `0.4$5`
  On obtient :
  `0.4,0.4,0.4,0.4,0.4)`
  On tape :
  `seq(2*k+1,k=1..5)`
  Ou on tape :
  `(2*k+1)$(k=1..5)`
  On obtient :
  `(3,5,7,9,11)`
  On tape :
  `seq(2*k+1,k=1..10,2)`
  Ou on tape :
  `(2*k+1)$(k=(1..10$2))`
  On obtient :
  `(3,7,11,15,19)`
  Pour avoir une liste il suffit de rajouter des crochets :
  On tape :
  `[seq(2*k+1,k=1..5)]`]
  Ou on tape :
  `[(2*k+1)$(k=1..5)]`
  On obtient :
  `[3,5,7,9,11]`
- Syntaxe compatible `TI`
  -`seq` a quatre arguments une expression dépendant d’un paramètre (par exemple j), le nom du paramètre (par exemple j), puis a et b où a et b sont des nombres réels. `seq` définit la liste obtenue en remplaçant dans l’expression j par a, a+1..b si b>a ou par a, a−1..b si b<a).
  -`seq` a cinq arguments une expression dépendant d’un paramètre (par exemple j), le nom du paramètre (par exemple j), puis a et b (où a et b sont des nombres réels) et p le pas (où p est un nombre réel positif ou négatif).
  `seq` définit la liste obtenue en remplaçant dans l’expression j par a, a+p..a+k*p (a+k*p ≤ b <a+(k+1)*p ou a+k*p ≥ b> a+(k+1)*p). Par défaut, on a p=1 si b>a et p=-1 si b<a. Si p n’a pas le bon signe, ce signe est rectifié par le logiciel!

Remarque :
Dans la syntaxe `Maple`, `seq` renvoie une séquence et il n’y a pas la possibilité de mettre un paramètre de saut, contrairement à la syntaxe `TI` où `seq` renvoie une liste avec la possibilité de mettre un paramètre de saut.
On tape pour avoir une séquence d’éléments identiques :

`seq(t,4)`

Ou on tape

`seq(t,k=1..4)`

Ou on tape

`t$4`

On obtient :

`(t,t,t,t)`

On tape pour avoir une séquence :

`seq(j```^```3,j=1..4)`

Ou on tape

`(j```^```3)$(j=1..4)`

Ou on tape :

`seq(j```^```3,j,1..4)`

On obtient :

`(1,4,9,16)`

Ou on tape pour avoir une liste :

`seq(j```^```3,j,1,4)`

On obtient :

`[1,4,9,16]`

On tape :

`seq(j```^```3,j,0,5,2)`

On obtient :

`[0,8,64]`

On tape :

`seq(j```^```3,j,5,0,-2)`

ou

`seq(j```^```3,j,5,0,2)`

On obtient :

`[125,27,1]`

On tape :

`seq(j```^```3,j,1,3,0.5)`

On obtient :

`[1,3.375,8,15.625,27]`

On tape :

`seq(j```^```3,j,1,3,1/2)`

On obtient :

`[1,27/8,8,125/8,27]`

Exemples d’utilisation

- On tape pour avoir la dérivée troisième de ln(t) :
  `diff(log(t),t$3)`
  On obtient :
  `-((-(2*t))/t```^```4)`
  On tape :
  `l:=[[2,3],[5,1],[7,2]]`
  `seq((l[k][0])$(l[k][1]),k=0 .. size(l)-1)`
  On obtient :
  `2,2,2,seq[5],7,7`
  `2,2,2,5,7,7`
- On tape pour transformer une chaîne en la liste de ces caractères :
  `f(chn):={ local l; l:=size(chn); return seq(chn[j],j,0,l-1); }`
  puis,
  `f("abracadabra")`
  On obtient :
  `["a","b","r","a","c","a","d","a","b","r","a"]`
- On tape pour transformer une chaîne en la séquence de ces caractères :
  `f(chn):={ local l; l:=size(chn); return seq(chn[j],j,0..l-1); }`
  puis,
  `f("abracadabra")`
  On obtient :
  `("a","b","r","a","c","a","d","a","b","r","a"]))`