perms

Arguments

x

Vecteur ligne ou colonne de tout type de données pour lesquelles les opérateurs size(), ==, et [] sont définis, incluant le type cell.

"unique"

indicateur texte optionnel, pour calculer et produire uniquement les permutations uniques, sans aucun doublon. Cette option est utilisable uniquement si x est ordonnable : booléen, entier, réel, ou texte.

y

Tableau du type de x, avec n=size(x,"*") colonnes. Chaque ligne contient une permutation. Sans utiliser l'option "unique", y comprend n! lignes. Sinon, le nombre de lignes size(y,1) ≤ n! dépend de la multiplicité des valeurs dédoublonnées de x.

Description

Etant donné un vecteur x de n éléments, perms(..) calcule le nombre attendu de permutations attendues, et vérifie qu'il y a suffisamment de mémoire vive disponible pour les calculer et les stocker en résultat.

S'il n'y a pas suffisamment de mémoire vive, aucun calcul effectif n'est effectué, et une erreur est générée.

Sinon, les permutations sont calculées et retournées en résultat.

Lorsque "unique" est utilisé, si aucun doublon n'est détecté dans x, l'algorithme sans "unique" est automatiquement utilisé pour effectuer les calculs plus rapidement. x est préalablement trié en ordre croissant, et y est construite en ordre lexicographique croissant. Sinon : l'ordre initial des éléments de x est conservé, et l'ordre des permutations dans y en tient compte. Ainsi x pourra si besoin être trié selon l'ordre choisi par l'utilisateur, avant d'appeler perms().

Pour mémoire, le poids n*n!*8 de y en octets est listé ci-dessous en fonction du nombre n d'éléments de x, pour x nombres décimaux, et sans l'option "unique" :

Exemples

x = [4, 7, 10];
y = perms(x)

x = ["a" "b" "c" "d"];
y = perms(x)'

c = {"bonjour", %pi, %t};
perms(c)

--> x = [4, 7, 10];
--> y = perms(x)
 y  =
   10.   7.    4.
   10.   4.    7.
   7.    10.   4.
   7.    4.    10.
   4.    10.   7.
   4.    7.    10.

--> x = ["a" "b" "c" "d"];
--> perms(x)'
 ans  =
!d  d  d  d  d  d  c  c  c  c  c  c  b  b  b  b  b  b  a  a  a  a  a  a  !
!c  c  b  b  a  a  d  d  b  b  a  a  d  d  c  c  a  a  d  d  c  c  b  b  !
!b  a  c  a  c  b  b  a  d  a  d  b  c  a  d  a  d  c  c  b  d  b  d  c  !
!a  b  a  c  b  c  a  b  a  d  b  d  a  c  a  d  c  d  b  c  b  d  c  d  !

--> c = {"bonjour", %pi, %t};
--> perms(c)
 ans  =
  [1x1 boolean ]  [1x1 constant]  [1x1 string  ]
  [1x1 boolean ]  [1x1 string  ]  [1x1 constant]
  [1x1 constant]  [1x1 boolean ]  [1x1 string  ]
  [1x1 constant]  [1x1 string  ]  [1x1 boolean ]
  [1x1 string  ]  [1x1 boolean ]  [1x1 constant]
  [1x1 string  ]  [1x1 constant]  [1x1 boolean ]

Avec des éléments de multiplicité > 1 (doublons ou plus) :

perms([1 0 0])
perms([1 0 0], "unique")
perms([0 1 2 0], "unique")'
p = perms([0 0 0 0 1 1 1 2 2 3], "unique");
size(p)

--> perms([1 0 0])
 ans  =
   0.   0.   1.
   0.   1.   0.
   0.   0.   1.
   0.   1.   0.
   1.   0.   0.
   1.   0.   0.

--> perms([1 0 0], "unique")
 ans  =
   0.   0.   1.
   0.   1.   0.
   1.   0.   0.

--> perms([0 1 2 0], "unique")'
 ans  =
   0.   0.   0.   0.   0.   0.   1.   1.   1.   2.   2.   2.
   0.   0.   1.   1.   2.   2.   0.   0.   2.   0.   0.   1.
   1.   2.   0.   2.   0.   1.   0.   2.   0.   0.   1.   0.
   2.   1.   2.   0.   1.   0.   2.   0.   0.   1.   0.   0.

--> p = perms([0 0 0 0 1 1 1 2 2 3], "unique");
--> size(p)
 ans  =
   12600.   10.  // au lieu de 10! = 3628800 lignes

Voir aussi

• grand(n,'prm',x) — Générateur de nombres pseudo-aléatoires
• factorial — factorial function : product of the n first positive integers
• unique — extrait (et trie) les éléments distincts d'un vecteur, matrice, hypermatrice
• gsort — sorting by quick sort algorithm
• try — mot clé de début du bloc try dans une instruction de contrôle try-catch

Historique