doublenumbertoken.java

JAVA 数学程序库 提供常规的数值计算程序包

        if ((sizeY==0) && (sizeX==0))
            return null;
        
        for(int yy = 0; yy < sizeY; yy++)
        {
            for(int xx = 0; xx < sizeX; xx++)
            {
                int n = yx2n(yy,xx);
                temp[yy][xx] = values[n][REAL];
            }
        }
        return temp;
    }

    /**@return the real values of the number*/
    public double[][] getReValues()
    {
        return getValuesRe();
    }

    /**@return the imaginary values of the number*/
    public double[][] getValuesIm()
    {
        double[][] temp = new double[sizeY][sizeX];

        if ((sizeY==0) && (sizeX==0))
            return null;

        for(int yy = 0; yy < sizeY; yy++)
        {
            for(int xx = 0; xx < sizeX; xx++)
            {
                int n = yx2n(yy,xx);
                temp[yy][xx] = values[n][IMAG];
            }
        }
        return temp;
    }
    

    /**
     * 
     * @param n
     * @return
     */
    public OperandToken getElement(int n)
    {
        return new DoubleNumberToken(values[n][REAL], values[n][IMAG]);
    }


    /**
     * 
     * @param n
     * @param num
     */
    public void setElement(int n, OperandToken num)
    {
        values[n][REAL] = ((DoubleNumberToken)num).getValueRe();
        values[n][IMAG] = ((DoubleNumberToken)num).getValueIm();
    }

    
    /**@return an array of double representing the element at y,x
    @param y = y position in matrix
    @param x = x position in matrix*/
    public double[] getValueComplex(int y, int x)
    {
        int n = yx2n(y,x);
        return getValueComplex(n);
    }
   
    /**
     * 
     * @param n
     * @return
     */
    public double[] getValueComplex(int n)
    {
        return values[n];
    }
    
    /**
     * 
     * @param n
     * @param _value
     */
    public void setValueComplex(int n, double[] _value)
    {
        values[n] = _value;
    }

    /**Set value at position y, x
     * @param y = y position in matrix
     * @param x = x position in matrix
     * @param _value = the value to set it to as an array of doubles  
     */    
    public void setValueComplex(int y, int x, double[] _value)
    {
        int n = yx2n(y,x);
        values[n][REAL] = _value[REAL];
        values[n][IMAG] = _value[IMAG];
    }
    
    /** Set value at position y, x
     * @param y = y position in matrix
     * @param x = x position in matrix
     * @param real = real value
     * @param imag = imaginary value
     */    
    public void setValue(int y, int x, double _real, double _imag)
    {
        int n = yx2n(y,x);
        setValue(n, _real, _imag);
    }

    /**
     * 
     * @param n
     * @param _real
     * @param _imag
     */
    public void setValue(int n, double _real, double _imag)
    {
        values[n][REAL] = _real;
        values[n][IMAG] = _imag;
    }

    /**
     * 
     * @param index  multidimensional index
     * @param _real
     * @param _imag
     */
    public void setValue(int[] index, double _real, double _imag)
    {

        int n = index2n(index);
        
        setValue(n, _real, _imag);
        
    }

    
    /**return the number as a string*/
    public String toString()
    {
        String result = null;
        if((sizeY == 0) && (sizeX == 0))
        {
            // e.g. a=null;
            result = "[]";
        }
        else if((sizeY == 1) && (sizeX == 1) && sizeA.length==2)
        {
            // e.g. a=555;
            result = toString(values[0]);
        }
        else if (sizeA.length ==2)
        {
            result = toString2d(new int[]{sizeY,sizeX});
        }
        else
        {
            // e.g. a=[1,2,3;4,5,6] or multidimensional
            
            int[] dim = new int[sizeA.length];
            dim[0] = sizeY;
            dim[1] = sizeX;
            
            String s = toString(dim, sizeA.length-1);
            
            result = new String(s);
        }           
        return result;
    }
    
    private String toString(int[] dim, int i)
    {
        String ret="";
        
        if (i>=2)
        {
            // e.g. at least 3rd dimension
            // e.g. a(5,3,4,x,3,1)
            for (int n=0; n<sizeA[i]; n++)
            {
                dim[i]=n;
                
                
                // e.g. a(5,3,Y,x,3,1)
                ret += toString(dim, i-1);
                
            }
            
        }
        else
        {
            // e.g. 
            ret += "(:,:";
            for (int k=2; k<dim.length; k++)
            {
                ret += "," + (dim[k]+1);   //NOTE: conversion from internal to external index
            }
            ret += ") = \n";

            ret += toString2d(dim);
            
            ret += "\n";
        }
        return ret;
    }

    private String toString2d(int[] nn)
    {
        StringBuffer buffer = new StringBuffer(20);
        
        for(int yy = 0; yy < sizeA[0]; yy++)
        {
            buffer.append(" [");
            for(int xx = 0; xx < sizeA[1]; xx++)
            {
                nn[0] = yy;
                nn[1] = xx;
                int n = index2n(nn);
                //ErrorLogger.debugLine(" NToken: "+index2n(nn));
                
                buffer.append(toString(values[n]));
                
                if(xx < sizeX - 1)
                    buffer.append(" ,  ");
            }           
            buffer.append("]\n");
        }
        return buffer.toString();
    }
        
    /** create string representation of (complex) double values 
    @param _values[]={REAL,IMAG} real and imaginary part of number*/
    public String toString(double _values[])
    {
        if (_values==null)
            return "XXXXXX";
        
        double re = _values[REAL];
        double im = _values[IMAG];
        
        StringBuffer result =  new StringBuffer();
        
        if((im != 0.0) || Double.isNaN(im))
            result.append("(");

        // real part of number
        // +/- infinity, not a number, number
        if (re == Double.POSITIVE_INFINITY)
            result.append("Inf");
        else if (re == Double.NEGATIVE_INFINITY)    
            result.append("-Inf");
        else if (Double.isNaN(re))    
            result.append("NaN");
        else
            result.append(numFormat.format(re));

        // imaginary part of number
        if((im != 0.0) || Double.isNaN(im))
        {
            if ((re!=0.0) && !(im<0))
                result.append("+");
                
            // +/- infinity, not a number, number
            if (im == Double.POSITIVE_INFINITY)
                result.append("Inf");
            else if (im == Double.NEGATIVE_INFINITY)    
                result.append("-Inf");
            else if (Double.isNaN(im))    
                result.append("NaN");
            else
                result.append(numFormat.format(im));
        
            result.append("i)");
        }
        return  result.toString();
    }

    /**Evaluate the token. This causes it to return itself*/
    //public OperandToken evaluate(Token[] operands)
    //{
    //    return this;    
    //}

    /**Check if two tokens are equal
       @param arg = the object to check against*/
    public boolean equals(Object arg)
    {
        if(arg instanceof DoubleNumberToken)
        {
            DoubleNumberToken nArg = (DoubleNumberToken)arg;
            if(sizeX == nArg.getSizeX() && sizeY == nArg.getSizeY())
            {
                boolean equal = true;
                for (int yy=0; yy<sizeY && equal; yy++)
                {
                        for (int xx=0; xx<sizeX && equal; xx++)
                        {
                            int n = yx2n(yy,xx);
                            if((values[n][REAL] - nArg.getValueRe(n) != 0) ||
                               (values[n][IMAG] - nArg.getValueIm(n) != 0)    )
                                equal = false;
                        }
                }                        
                return equal;
            }
            return false;
        }
        return false;
    }

    /**calculate the arg of the complex number at y, x*/
    public double arg(int y, int x) 
    {
        int n = yx2n(y,x);
        return  Math.atan2(values[n][REAL], values[n][IMAG]);
    }

    ///////////////////////standard operators///////////////////
    ////////////////////////////////////////////////////////////
    
    /**add arg to this object for a number token
    @param = the value to add to it
    @return the result as an OperandToken*/
    public OperandToken add(OperandToken arg)
    {

        if(arg instanceof DoubleNumberToken)
        {

            DoubleNumberToken nArg = ((DoubleNumberToken)arg);
    
            // Check dimensions of matrices 
            if(checkEqualDimensions(sizeA, nArg.sizeA))
            {
                // Add (n*m) + (n*m) or
                //  same dimensions (n,m,r)==(n,m,r)
                ErrorLogger.debugLine("DoubleNumberToken: add (n*m) + (n*m)");
                DoubleNumberToken result = new DoubleNumberToken(sizeA, null, null);
    
                for(int n = 0; n < noElem; n++)
                {
                    double real = getValueRe(n) + nArg.getValueRe(n);
                    double imag = getValueIm(n) + nArg.getValueIm(n);
                    result.setValue(n, real, imag);
                }
                
                //ErrorLogger.debugLine("end DoubleNumberToken: add (n*m) + (n*m)");
                return result;      
            } 
            else if(isScalar())
            {
                // 1 + [3,4,5]       
                ErrorLogger.debugLine("DoubleNumberToken: add (1*1) + (n*m)");
                DoubleNumberToken result = new DoubleNumberToken(nArg.sizeA, null, null);
                
                for(int n = 0; n < nArg.getNumberOfElements(); n++)
                {
                    double realval      = getValueRe() + nArg.getValueRe(n);
                    double imaginaryval = getValueIm() + nArg.getValueIm(n);
                    result.setValue(n, realval, imaginaryval);
                }
                
                //ErrorLogger.debugLine("end DoubleNumberToken: add (n*m) + (n*m)");
                return result;      
            } 
            else if(nArg.isScalar())
            {
                // [3,4,5] +1
                ErrorLogger.debugLine("DoubleNumberToken: add (n,m) + (1,1)");
                DoubleNumberToken result = new DoubleNumberToken(sizeA, null, null);
                
                for(int n = 0; n < noElem; n++)
                {
                    double realval      = getValueRe(n) + nArg.getValueRe();
                    double imaginaryval = getValueIm(n) + nArg.getValueIm();
                    result.setValue(n, realval, imaginaryval);
                }
                
                //ErrorLogger.debugLine("end DoubleNumberToken: add (n*m) + (n*m)");
                return result;      
            } 
            else
            {
                /* Matrices have unequal size: (n*m) != (o*p) */       
                Errors.throwMathLibException("DoubleNumberToken: add matrices of unequal size");
                return null;
            }
        }
        else if(arg instanceof Int8NumberToken)
        {