lcm Plus petit multiple commun (PPCM) de polynômes ou d'entiers

## Séquence d'appel

               pp = lcm(p)
              [pp, fact] = lcm(p)

## Paramètres

p

  matrice de polynômes (type égal à 2) ou d'entiers décimaux ou encodés (types 1 ou 8).

pp

  polynôme ou entier décimal: PPCM positif des éléments de p.

fact

  matrice de polynômes ou d'entiers décimaux, de tailles identiques à celle de `p`, telle que `fact(i)= pp./p(i)`.

## Description

`pp = lcm(p)` calcule le PPCM `pp` des éléments de `p`, au sens des polynômes ou des entiers.

`[pp, fact] = lcm(p)` calcule et produit en outre la matrice `fact` des facteurs tels que `p(i) * fact(i) = pp`

Si `p` sont des entiers,

- s'il s'agit d'entiers encodés, ils sont préalablement convertis en entiers décimaux avant les calculs.
- S'il s'agit d'entiers encodés en int64 ou uint64, les |valeurs| d'entrée > 2^53 seront tronquées par la conversion en décimaux et le résultat `p` sera erroné.
- si un ou plusieurs éléments de `p` sont négatifs, le résultat `pp` sera toujours positif.

Le plus petit commun multiple d'une matrice `p` de réels peut s'obtenir en la convertissant en polynôme avant d'appeler `lcm`, grâce à la commande `p = inv_coeff(p, 0)`.

## Exemples

Avec des polynômes :

    s = %s;
    p = [s , s*(s+1) , s^2-1]
    [pp, fact] = lcm(p)
    p .* fact == pp

    --> p = [s , s*(s+1) , s^2-1]
     p  =
               2       2
       s   s +s   -1 +s

    --> [pp, fact] = lcm(p)
     fact  =
           2
      -1 +s   -1 +s   s

     pp  =
           3
      -s +s

    --> p .* fact == pp
     ans  =
      T T T

Avec des entiers encodés :

    // Nombres premiers : 2  3  5  7  11  13  17  19  23  29  31  37  41  43  47
    V = int16([2*3 3*7 ; 7*5  3*5])
    [pp, fact] = lcm(V)

    --> V = int16([2*3 3*7 ; 7*5  3*5])
     V  =
       6  21
      35  15

    --> [pp, fact] = lcm(V)
     pp  =
       210.

     fact  =
       35.   10.
       6.    14.

Avec des entiers décimaux :

    V = [2*3 3*7 ; 7*5  3*5]
    [pp, fact] = lcm(V)

Avec des grands entiers

    V = [3*2^51 , 3*5]
    [pp, fact] = lcm(V)    // OK

    --> V = [3*2^51 , 3*5]
     V  =
       6.755D+15   15.

    --> [pp, fact] = lcm(V)
     fact  =
       5.   2.252D+15

     pp  =
       3.378D+16

Lorsque les valeurs d'éntrée débordent leur encodage numérique, elles sont tronquées et les résultats deviennent erronés :

    V = [3*2^52 , 3*5]
    [pp, fact] = lcm(V)

    --> V = [3*2^52 , 3*5]
     V  =
       1.351D+16   15.

    --> [pp, fact] = lcm(V)
     fact  =
       15.   1.351D+16

     pp  =
       2.027D+17

## Voir aussi

- gcd
- bezout
- factor

## Historique

6.0.1 Pour un ensemble d'entiers dont certains sont négatifs, lcm() en retourne désormais toujours la valeur absolue du PPCM.
6.0.2

- `p` peut désormais être des entiers int64 ou uint64 encodés sur 64 bits.
- `p` peut désormais être une matrice de format quelconque, non nécessairement un vecteur ligne.
- Lorsque `p` est une matrice d'entiers encodés ou décimaux, `pp` et `fact` sont désormais des entiers décimaux (au lieu d'entiers encodés int32).