lcm mínimo múltiplo comum (positivo) de inteiros ou de polinômios

## Seqüência de Chamamento

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

## Parâmetros

p

  matriz de polinômios (tipo 2), ou de inteiros decimais ou codificados (tipos 1 ou 8).

pp

  um polinomial ou um inteiro decimal : Mínimo positivo múltiplo comum de Componentes `p`.

fact

  matriz de polinômios ou de inteiros decimais (tipo 1), com os tamanhos de `p`, tal que `fact(i)=pp./p(i)`.

## Descrição

`pp=lcm(p)` computa o MMC `pp` do matriz de polinômios `p`.

Se `p` são polinômios, `pp` é um polinômio e `fact` também é uma matriz de polinômios.

Se `p` são inteiros,

- inteiros codificados são convertidos em inteiros decimais antes do processamento.
- Qualquer entrada int64 ou uint64 input |inteiros| > 2^53 será truncado e lcm() retornará um resultado errado.
- se algum deles for negativo, o valor de retorno `pp` é sempre positivo.

The least common multiple of an array `p` of real numbers can be obtained by converting it to a polynomial before calling `lcm`, through `p = inv_coeff(p, 0)`.

## Exemplos

Com polinômios :

    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

Com inteiros codificados :

    // Prime numbers: 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.

Com números inteiros decimais :

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

Com grandes inteiros:

    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

Quando a codificação numérica é excedida, truncatura ocorre e os resultados ficam errados :

    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

## Ver Também

- gcd
- bezout
- factor

## Histórico

6.0.1 For input integers possibly negative, the returned LCM is now always positive.
6.0.2

- int64 and uint64 input encoded integers are now supported.
- `p` can now be a matrix of any shape, not necessarily a row.
- When `p` is a matrix of encoded or decimal integers, computations are now performed in floating point instead of int32 format. `pp` and `fact` are now decimal integers (instead of int32 integers).