public static String decToBase(String num, int base)
    {
        /**
         * Oltre 9999999999999990 il double non riesce a gestire con precisione tutti i decimali
         */
        String valore = ERRORE;
        try
        {
            if (numeroValido_privato(num, 10)) //Assicuriamoci che il numero inserito sia in base 10
            {
                valore = "";
                Long intero = new Long(num); // Istruzione con pericolo di overflow
                if (intero > MAX_DEC)
                {
                    valore = ERRORE + ": num deve essere < " + MAX_DEC;
                }
                else
                {
                    if (base==1) // Calcola per la base più inutile e pericolosa in assoluto
                    {
                        /**
                         * Con il massimo valore possibile 9'999'999'999'999'990 si consuma una quatara di RAM.
                         * Ogni carattere della stringa è rappresentato da 16 bit,
                         * quindi il consumo massimo sarebbe di (9'999'999'999'999'990+1)*2 byte
                         * che sarebbero 19'999'999'999'999'982 byte
                         * che sarebbero 19'073'486'328,1 MB
                         * che sarebbero 18'626'451,4923 GB
                         * che sarebbero cazzi amari espressi in potenze di 2
                         * E allora perché non ho messo un controllo per limitare lo spreco di memoria?
                         * 1) Per vedere chi è tanto http://lmgtfy.com/?q=persona+poco+avveduta+che+non+prevede+le+conseguenze+dei+propri+atti+per+insufficiente+intelligenza&l=1
                         * 2) Me lo ha chiesto Fabio (no, non è quello di Striscia)
                         */
                        /*for (int i=0; i<=intero; i++) // Per il ciclo alta tensione...
                        {
                            valore += "0";
                        }*/
                        valore = ERRORE;    // DEBUG: Questo metodo non è sicuro per compiere questa conversione
                    }
                    else // Calcola per tutte le altre basi
                    {
                        Long risultato;
                        Double decimale;
                        while(intero>0)
                        {
                            decimale = intero.doubleValue()/base;                  // In realtà la vera trappola non è l'overflow del Long, ma la notazione del double che perde precisione oltre un certo valore (definito in MAX_DEC)
                            intero = decimale.longValue();                         // Prendo la parte intera del numero
                            decimale = decimale - intero.doubleValue();           // Prendo la parte decimale del numero
                            risultato = Math.round(new Double(base*decimale));                             // Prendo il risultato
                            valore = valoreCifra(risultato.byteValue()) + valore;   // Aggiorno il risultato
                        }
                    }
                }
                
            }
            else
            {
                valore = ERRORE;
            }
        }
        catch(Exception e)
        {
            valore = ERRORE;
        }
        return valore;
    }