longinteger.java

java开发的大整数计算器,实现基本的运算,还有sin,cos,tan,cot.

public class LongInteger
{

    int number[];
    int length;
    LongInteger(int x[], int y)
    {
        number = x;
        length = y;
    }

    public static int[] add(int x[], int y[])
    {
        if(x.length < y.length)
        {
            int tmp[] = x;
            x = y;
            y = tmp;
        }
        int xIndex = x.length;
        int yIndex = y.length;
        int result[] = new int[Math.max(xIndex, yIndex) + 1];
        int index = result.length;
        while(yIndex > 0) 
        {
            result[--index] = y[--yIndex];
        }
        index = result.length;
        while(xIndex > 0) 
        {
            xIndex--;
            index--;
            if(x[xIndex] + result[index] >= 10)
            {
                result[index] = (x[xIndex] + result[index]) % 10;
                result[index - 1]++;
            } else
            {
                result[index] = x[xIndex] + result[index];
            }
        }
        while(index > 0) 
        {
            if(result[index--] >= 10)
            {
                result[index] = result[index] % 10;
                result[index - 1]++;
            }
        }
        if(result[0] != 0)
        {
            return result;
        } else
        {
            return trustedStripLeadingZeroInts(result);
        }
    }

    private static int[] trustedStripLeadingZeroInts(int val[])
    {
        int keep;
        for(keep = 0; keep < val.length && val[keep] == 0; keep++) { }
        if(keep > 0)
        {
            int result[] = new int[val.length - keep];
            for(int i = 0; i < val.length - keep; i++)
            {
                result[i] = val[keep + i];
            }

            return result;
        } else
        {
            return val;
        }
    }

    public static int[] multiply(int x[], int y[])
    {
        int lenx = x.length;
        int leny = y.length;
        int result[] = new int[lenx + leny];
        for(int j = leny; j > 0; j--)
        {
            int index[] = new int[(lenx + leny) - j];
            int i = y[j - 1];
            for(int z = 0; z < lenx; z++)
            {
                index[z] = x[z];
            }

            while(--i >= 0) 
            {
                result = add(result, index);
            }
        }

        if(result[0] != 0)
        {
            return result;
        } else
        {
            return trustedStripLeadingZeroInts(result);
        }
    }

    public static int[] pow(int x[], int y[])
    {
        String strr = "";
        int wo[] = new int[1];
        int result[] = x;
        int h = y.length;
        if(h ==1&&y[0]==0){
        	wo[0] = 1;
           result = wo;
        }
        else{
        for(int i=0;i<y.length;i++)
          strr += String.valueOf(y[i]);
         int haha = Integer.parseInt(strr);
        
        for(int i = haha; i > 1; i--)
        {
            result = multiply(result, x);
        }
        }
        return result;
    }

    public static int[] subtract(int x[], int y[])
    {
        if(intArrayCmp(x, y) > 0)
        {
            for(int i = y.length - 1; i >= 0; i--)
            {
                y[i] = -y[i];
            }

            int result[] = add(x, y);
            for(int i = result.length - 1; i > 0; i--)
            {
                if(result[i] < 0)
                {
                    result[i] = result[i] + 10;
                    result[i - 1]--;
                }
            }

            return trustedStripLeadingZeroInts(result);
        }
        if(intArrayCmp(x, y) == 0)
        {
            int result[] = new int[1];
            result[0] = 0;
            return result;
        } else
        {
            int result[] = subtract(y, x);
            result[0] = -result[0];
            return result;
        }
    }

    private static int intArrayCmp(int arg1[], int arg2[])
    {
        if(arg1.length < arg2.length)
        {
            return -1;
        }
        if(arg1.length > arg2.length)
        {
            return 1;
        }
        for(int i = 0; i < arg1.length; i++)
        {
            long b1 = (long)arg1[i] & 0xffffffffL;
            long b2 = (long)arg2[i] & 0xffffffffL;
            if(b1 < b2)
            {
                return -1;
            }
            if(b1 > b2)
            {
                return 1;
            }
        }

        return 0;
    }

    public static int[] divide(int x[], int y[])  {        
         if(y.length == 0)
         {
             return x;
         }
        int result[];
        if(x.length < y.length)
        {
            result = new int[1];
            return result;
        }
        result = new int[(x.length - y.length) + 1];
        int index0[] = subIntArray(x, 0, y.length - 1);
        int index1[] = (int[])null;
        int j = index0[0] / (y[0] + 1);
        do
        {
            index1 = new int[1];
            index1[0] = j;
            j++;
        } while(intArrayCmp(subtract(index0, multiply(y, index1)), y) >= 0);
        result[0] = j - 1;
        index0 = subtract(index0, multiply(y, index1));
        for(int i = index0.length - 1; i >= 0; i--)
        {
            x[(y.length - index0.length) + i] = index0[i];
        }

        for(int i = y.length - index0.length - 1; i >= 0; i--)
        {
            x[i] = 0;
        }

        for(int t = 1; t < (x.length - y.length) + 1; t++)
        {
            int index[] = subIntArray(x, t - 1, (t + y.length) - 1);
            j = (index[0] * 10 + index[1]) / (y[0] + 1);
            do
            {
                index1 = new int[1];
                index1[0] = j;
                j++;
            } while(intArrayCmp(subtract(index, multiply(y, index1)), y) >= 0);
            result[t] = j - 1;
            index = subtract(index, multiply(y, index1));
            for(int i = index.length - 1; i >= 0; i--)
            {
                x[(y.length - index.length) + i + t] = index[i];
            }

            for(int i = ((y.length - index.length) + t) - 1; i >= 0; i--)
            {
                x[i] = 0;
            }

        }

        return result;
     
    }

    private static int[] subIntArray(int a[], int b, int c)
    {
        int result[] = new int[(c - b) + 1];
        for(int i = 0; i < (c - b) + 1; i++)
        {
            result[i] = a[b + i];
        }

        return result;
    }

    static int[] stringToIntArray(String s)
    {
        int sLen = s.length();
        int intArr[];
        if(s.charAt(0) == '-')
        {
            intArr = new int[sLen - 1];
            for(int j = 1; j < sLen; j++)
            {
                intArr[j - 1] = Integer.parseInt((new StringBuilder(String.valueOf(s.charAt(j)))).toString());
            }

        } else
        {
            intArr = new int[sLen];
            for(int j = 0; j < sLen; j++)
            {
                intArr[j] = Integer.parseInt((new StringBuilder(String.valueOf(s.charAt(j)))).toString());
            }

        }
        return intArr;
    }
}