lcm наименьшее общее кратное (положительное) целых чисел или полиномов

## Синтаксис

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

## Аргументы

p

  матрица полиномов (тип 2), или десятичных чисел или кодированных целых чисел (тип 1 или 8).

pp

  полином или десятичное целое число: положительное нименьшее общее кратное у составляющих `p`.

fact

  матрица полиномов или десятичных целых чисел (тип 1) с размером, как у `p`, такая, что `fact(i)= pp./p(i)`.

## Описание

`pp=lcm(p)` вычисляет НОК `pp` составляющих `p`.

Если `p` являются полиномами, то `pp` является полиномом и `fact` также является матрицей полиномов.

Если `p` является массивом целых числел, то

- если они являются кодированными целыми числами, то тогда они преобразуются в десятичные целые числи перед обработкой.
- Любые входные целые числа типа int64 или uint64 по модулю больше 2^53 будут усечены и `lcm()` вернёт неверный результат.
- Если некоторые из них отрицательные, то возвращаемое значение `pp` (их НОК) будет всегда положительным.

Намиеньшее общее кратное массива `p` вещественных чисел может быть получено конвертированием его в полином перед вызовом `lcm`, через `p = inv_coeff(p, 0)`.

## Примеры

С полиномами:

    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

С кодированными целыми числами:

    // Простые числа: 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.

С десятичнми целыми числами:

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

С большими целыми числами:

    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

Когда числовое кодирование переполняет разрядную сетку, происходит усечение и результаты возвращаются ошибочные:

    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

## Смотрите также

- gcd
- bezout
- factor

## История

6.0.1 Для входных целых чисел, возможно отрицательных, возвращаемое МОК теперь всегда положительно.
6.0.2

- Теперь поддерживаются входные кодированные целые числа типа int64 и uint64.
- Теперь `p` может быть матрицей любой формы, необязательно строка.
- Когда `p` является матрицей кодированных или десятичных целых чисел, то вычисления теперь выполняются в числах с плавающей запятой вместо формата int32. `pp` и `fact` теперь десятичные целые числа (вместо целых чисел типа int32).