Condicion para evitar "overflows"
=================================

  En la subrutina Multiplicar de la version en Fortran, la operacion

    lc(ic)=kp+i*lc(ic)

  donde el arrastre kp se ha obtenido en la iteracion anterior como

    lc(ic-1)=kp+i*lc(ic-1)
    kp=lc(ic-1)/NBASE
    lc(ic-1)=lc(ic-1)-kp*NBASE

  puede dar lugar a un "overflow" si kp, i y lc(ic) tienen valores suficientemente grandes.

  El "overflow" se producira cuando

    kp+i*lc(ic) > INT_MAX

  El caso mas desfavorable se produce cuando

    kp     = INT_MAX/NBASE (en la iteracion anterior)
    i      = n             (valor mas alto de i)
    lc(ic) = NBASE-1       (cifra de valor mas alto en base nbase)

  Por tanto el "overflow" es posible cuando

    INT_MAX/NBASE + n*(NBASE-1) > INT_MAX

  lo que equivale a

    n*(NBASE-1) > INT_MAX*(1-1/NBASE) = INT_MAX*(NBASE-1)/NBASE

  o, lo que es lo mismo,

    n*NBASE > INT_MAX.

  Luego la condicion para que no se produzcan overflows se puede escribir en la forma

    n*NBASE < INT_MAX+1 = 2^31




Condicion para que se pueda almacenar el resultado
==================================================

  El numero más grande que se puede representar con NC cifras en base NBASE es

     lc(NC)    lc(NC-1)       lc(2)     lc(1)
    (NBASE-1) (NBASE-1) ... (NBASE-1) (NBASE-1)

  cuyo valor es

    SUMA  [ (NBASE-1) * NBASE^(ic-1) ] = (NBASE-1) * (1-NBASE^(NC-1)*NBASE) / (1-NBASE)
   ic=1,NC

                                       = NBASE^NC - 1

  Luego la condicion para que se pueda almacenar el resultado se puede escribir en la forma

    n! < NBASE^NC