flipdim inverse l'ordre des (blocs de) lignes, colonnes, pages.. d'un tableau.

## Séquence d'appel

                y = flipdim(x, dim)
                y = flipdim(x, dim, blockSize)

## Paramètres

x, y

  scalaires, vecteurs, matrices, ou hypermatrices de n'importe quel type de données régulier, ou tableau de cells. `y` prend la taille de `x`.

dim

  entier positif : n° de la dimension / direction de `x` selon laquelle l'ordre des éléments de `x` doit être inversé.

blockSize

  entier positif, sous-multiple de `size(x,dim)` : taille des blocs dont l'ordre doit être inversé. Vaut 1 par défaut.

## Description

`flipdim(x, 1)` inverse l'ordre des lignes de `x`.

`flipdim(x, 2)` inverse l'ordre des colonnes de `x`.

`flipdim(x, 3)` inverse l'ordre des pages de `x`. etc.

Le paramètre optionnel `blockSize` permet d'inverser l'ordre des `size(x,1)/blockSize` blocs de `blockSize` lignes de `x` (`dim=1`), ou des `size(x,2)/blockSize` blocs de `blockSize` colonnes (`dim=2`), etc (`dim>2`). À l'intérieur de chaque bloc, l'ordre des éléments (lignes, colonnes, etc) n'est pas modifié.

## Exemples

    // Exemple 1 : selon la première dimension
    x = [1 2 3 4; 5 6 7 8]
    dim = 1
    y = flipdim(x, dim)

    // Exemple 2 : selon la deuxième dimension
    dim = 2
    y = flipdim(x, dim)

    // Exemple 3 : selon la troisième dimension
    x = matrix(1:24, [3 2 4])
    dim = 3
    y = flipdim(x, dim)

    // Exemple 4 : premier exemple, mais avec des complexes
    x = [1+%i 2*%i 3 4; 5 6-%i 7 8*%pi*%i]
    dim = 1
    y = flipdim(x, dim)

    // Entiers :
    x = int16(grand(4, 3, 2, "uin", -9, 9))
    y = flipdim(x, 1)

    // Booléens :
    x = (grand(3, 4, "uin", -9, 9) > 0)
    y = flipdim(x, 2)

    // Textes :
    x = matrix(strsplit("a":"x", 1:23), 4, 6);
    x = x+x
    flipdim(x, 2)

    // Polynômes :
    x = inv_coeff(grand(3, 9, "uin", 0, 3), 2)
    flipdim(x, 1)

    // Rationals :
    n = inv_coeff(grand(3, 9, "uin", 0 ,3), 2);
    d = inv_coeff(grand(3, 9, "uin", 0, 3), 2);
    r = n./d
    flipdim(r, 2)

Exemples utilisant `blockSize` :

    X = [0 1 2 3 4 5 6 7 8 9 10 11];
    flipdim(X, 2, 2) // => [10 11   8 9   6 7   4 5   2 3   0 1] // Taille du bloc = 2.
    flipdim(X, 2, 3) // => [9 10 11   6 7 8   3 4 5   0 1 2]
    flipdim(X, 2, 4) // => [8 9 10 11   4 5 6 7   0 1 2 3]
    flipdim(X, 2, 6) // => [6 7 8 9 10 11   0 1 2 3 4 5]

    // Erreur si la valeur de blockSize n'est pas sous-multiple de la dimension ciblée de x.
    y = flipdim(x, 2, 5); // size(X) = [1 12] et blockSize=5 ne divise pas 12.

Exemple de résultats :

    --> x
     x  =
     -5 -2  0  9
      0 -7 -6  9
     -1 -8 -7  8

    --> flipdim(x, 1)
     ans  =
     -1 -8 -7  8
      0 -7 -6  9
     -5 -2  0  9

    --> flipdim(x, 2)
     ans  =
      9  0 -2 -5
      9 -6 -7  0
      8 -7 -8 -1

    --> x
     x  =
    (:,:,1)
      9  4 -3
     -4 -8 -3

    (:,:,2)
      5  8  9
      4  4  9

    --> flipdim(x, 3)
     ans  =
    (:,:,1)
      5  8  9
      4  4  9

    (:,:,2)
      9  4 -3
     -4 -8 -3

    --> x
     x  =
     -2  3 -5  9 -4 -8
      2  8  4 -9  6 -6
     -9  8  3  4 -3  4

    --> flipdim(x, 2, 2)
     ans  =
     -4 -8 -5  9 -2  3
      6 -6  4 -9  2  8
     -3  4  3  4 -9  8

    --> flipdim(x, 2, 3)
     ans  =
      9 -4 -8 -2  3 -5
     -9  6 -6  2  8  4
      4 -3  4 -9  8  3

## Voir aussi

- circshift
- fftshift
- ifftshift
- colon

## History

5.5.0

- Extension aux matrices et hypermatrices de booléens, entiers encodés, textes, polynômes, fractions rationnelles, identifiants graphiques, etc.
- Nouveau paramètre optionnel `blockSize` pour réordonner `x` par blocs.