BigBig - [em DESENVOLVIMENTO]

/**
* BigBig - operacao de numeros gigantes com precisao arbitraria
* @author Davidson Francis
* @since 15/08/2013
* @version v.1.0
*/

public class BigBig
{
    private StringBuilder result;
    private int carry;

    BigBig()
    {
        result = null;
        carry  = 0;
    }

    /**
    * <b>Metodo add</b>, realiza adicao de 2 numeros inteiros.
    * @param n1 String do numero 1
    * @param n2 String do numero 2
    */
    public void add(String n1, String n2)
    {
        this.result = new StringBuilder("");
        this.carry  = 0;
        int tamanho = 0;
        char sinal = ' ';

        if( (getSignal(n1) == '+' && getSignal(n2) == '+') || (getSignal(n1) == '-' && getSignal(n2) == '-') )
        {
            if(getSignal(n1) == '-' && getSignal(n2) == '-')
            {
                sinal = '-';
            }
        }
        else
        {
            if( (getSignal(n1) == '+' && getSignal(n2) == '-') || (getSignal(n1) == '-' && getSignal(n2) == '+') )
            {
                //Ajuste do sinal antes de chamar a subtracao
                if(getSignal(n2) == '-')
                {
                    n2 = "+"+n2.substring(1,n2.length());
                }
                else
                {
                    if(getSignal(n2) == '+')
                    {
                        if(n2.charAt(0) == '+')
                        {
                            n2 = "-"+n2.substring(1,n2.length());
                        }
                        else
                        {
                            n2 = "-"+n2;
                        }
                    }
                }
                sub(n1,n2);
                return ;
            }
        }

        n1 = formatNumber(n1);
        n2 = formatNumber(n2);

        //Igualar o tamanho dos operandos
        if(n1.length() > n2.length())
        {
            tamanho = n1.length();
            StringBuilder tmp = new StringBuilder("");

            for(int x=n1.length()-n2.length(); x>0; x--) tmp.append("0");

            tmp.append(n2);
            n2 = ""+tmp;
        }
        else
        {
            if(n2.length() > n1.length())
            {
                tamanho = n2.length();
                StringBuilder tmp = new StringBuilder("");

                for(int x=n2.length()-n1.length(); x>0; x--) tmp.append("0");

                tmp.append(n1);
                n1 = ""+tmp;
            }
            else
            {
                tamanho = n1.length();
            }
        }

        //Soma propriamente dita
        for(int x=tamanho-1; x>=0; x--)
        {
            this.result.append( (char)(( ( (((int)(((char)n1.charAt(x))))-48) + (((int)(((char)n2.charAt(x))))-48) + this.carry ) % 10)+48) );
            this.carry = (int)(( (((int)(((char)n1.charAt(x))))-48) + (((int)(((char)n2.charAt(x))))-48)      + this.carry ) / 10);
        }

        if(this.carry != 0) result.append((char)(this.carry+48));
        if(sinal == '-') result.append('-');
    }

    /**
    * <b>Metodo sub</b>, realiza subtracao de 2 numeros inteiros por meio de complemento de 2.
    * @param n1 String do numero 1
    * @param n2 String do numero 2
    */
    public void sub(String n1, String n2)
    {
        this.result = new StringBuilder("");
        StringBuilder numc2 = new StringBuilder("");
        short maior = 0;
        char sinal = ' ';

        //Aritmetica de sinais, XD
        if(getSignal(n2) == '-')
        {
            n2 = "+"+n2.substring(1,n2.length());
        }
        else
        {
            if(getSignal(n2) == '+')
            {
                if(n2.charAt(0) == '+')
                {
                    n2 = "-"+n2.substring(1,n2.length());
                }
                else
                {
                    n2 = "-"+n2;
                }
            }
        }

        if( (getSignal(n1) == '+' && getSignal(n2) == '+') || (getSignal(n1) == '-' && getSignal(n2) == '-')  )
        {
            add(n1,n2);
            return ;
        }
        else
        {
            maior = getMaior(formatNumber(n1),formatNumber(n2));
            if(maior == 1 || maior == 2)
            {
                if(maior == 1 && n1.charAt(0) == '-' )
                {
                    sinal = '-';
                }
                else
                {
                    if(maior == 2 && n2.charAt(0) == '-' )
                    {
                        sinal = '-';
                    }
                }
            }
        }

        n1 = formatNumber(n1);
        n2 = formatNumber(n2);

        //Igualar tamanhos
        if(n1.length() != n2.length())
        {
            if(n1.length() < n2.length())
            {
                StringBuilder tmp = new StringBuilder("");
                for(int x=n2.length()-n1.length(); x>0; x--) tmp.append("0");
                tmp.append(n1);
                n1 = ""+tmp;
            }
            else
            {
                StringBuilder tmp = new StringBuilder("");
                for(int x=n1.length()-n2.length(); x>0; x--) tmp.append("0");
                tmp.append(n2);
                n2 = ""+tmp;
            }
        }

        //Calcula complemento de 2
        if(maior == 0 || maior == 1)
        {
            for(int x=n2.length()-1; x>=0; x--)
            {
                numc2.append( (char)((9-((int)(n2.charAt(x))-48))+48) );
            }
            add(""+numc2.reverse(),"1");
            numc2 = this.result.reverse();
        }
        else
        {
            for(int x=n1.length()-1; x>=0; x--)
            {
                numc2.append( (char)((9-((int)(n1.charAt(x))-48))+48) );
            }
            add(""+numc2.reverse(),"1");
            numc2 = this.result.reverse();
        }

        //Realiza a soma, e remove a unidade extra, o "overflow"
        if(maior != 2)
        {
            add(n1,""+numc2);
        }
        else
        {
            add(n2,""+numc2);
        }
        this.result = this.result.deleteCharAt(this.result.length()-1);
        if(sinal == '-') this.result.append('-');
    }

    /**
    * <b>Funcao getMaior</b>, compara dois numeros e retorna o maior dentre eles.
    * @param n1,n2 numeros a serem comparados entre si
    * @return - 1 se o maior numero for o 1<br>- 2 se o segundo <br>- 0 se iguais
    */
    public short getMaior(String n1, String n2)
    {
        short maior = 0;

        //Numeros de sinais positivos
        if( (n1.charAt(0) == '+' && n2.charAt(0) == '+') || (n1.charAt(0) >= '0' && n1.charAt(0) <= '9' && n2.charAt(0) >= '0' && n2.charAt(0) <= '9') )
        {
            if(n1.length() == n2.length())
            {
                for(int x=0; x<n1.length(); x++)
                {
                    if(n1.charAt(x) > n2.charAt(x))
                    {
                        maior = 1;
                        x=n1.length();
                    }
                    else if(n2.charAt(x) > n1.charAt(x))
                    {
                        maior = 2;
                        x=n1.length();
                    }
                }
            }
            else
            {
                maior = (n1.length() > n2.length()) ? (short)1 : (short)2;
            }
        }
        //Numeros que possuem sinais negativos
        else
        {
            if( (n1.charAt(0) == '-' && n2.charAt(0) == '-') )
            {
                if(n1.length() == n2.length())
                {
                    for(int x=0; x<n1.length(); x++)
                    {
                        if(n1.charAt(x) < n2.charAt(x))
                        {
                            maior = 1;
                            x=n1.length();
                        }
                        else if(n2.charAt(x) < n1.charAt(x))
                        {
                            maior = 2;
                            x=n1.length();
                        }
                    }
                }
                else
                {
                    maior = (n1.length() < n2.length()) ? (short)1 : (short)2;
                }
            }
            //Numeros que possuem sinais positivos e negativos
            else
            {
                if(n1.charAt(0) == '-')
                {
                    maior = 2;
                }
                else
                {
                    maior = 1;
                }
            }
        }
        return maior;
    }

    /**
    * <b>Funcao formatNumber</b>, formata o numero de entrada para o formato esperado<br>nas funcoes <i>add,sub...</i>
    * @param n1 String do numero a ser formatado
    * @return numero formatado menos o sinal
    */
    private String formatNumber(String n1)
    {
        String retorno = n1;

        if( !(n1.charAt(0) >= '0' && n1.charAt(0) <= '9') )
        {
            retorno = n1.substring(1,n1.length());
        }
        return retorno;
    }

    /**
    * <b>Funcao getSignal</b>, obtem o sinal do numero passado como parametro e o devolve como char.
    * @param n1 String do numero a obter o sinal.
    * @return caractere de sinal do numero
    */
    private char getSignal(String n1)
    {
        char retorno = ' ';

        if(n1.charAt(0) == '+' || n1.charAt(0) == '-')
        {
            retorno = n1.charAt(0);
        }
        else
        {
            retorno = '+';
        }
        return retorno;
    }

    /**
    * <b>Funcao hasSignal</b>, retorna valor booleano correspondente ao sinal dado como parametro.
    * @param n1 String do numero a ser verificado
    * @return - true, se o numero possui um sinal (seja + ou -)<br>- false, se o numero nao possui caractere de sinal
    */
    private boolean hasSignal(String n1)
    {
        return (n1.charAt(0) == '+' || n1.charAt(0) == '-') ? true : false;
    }

    /**
    * <b>Funcao toString</b>, obtem o resultado no formato String de uma operacao realizada.
    * @return retorna em String o valor da operacao realizada (add,sub...)
    */
    public String toString()
    {
        if(this.result != null)
        {
            return ""+this.result.reverse();
        }
        else
        {
            return "0";
        }
    }
}