uint8numbertoken.java

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

    }


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

    
    /** 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, short _real, short _imag)
    {
        int n = yx2n(y,x);
        setValue(n, _real, _imag);
    }

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

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

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

            if ((nArg.getSize().length!=2) || 
                (nArg.getSizeX()      !=1) || 
                (nArg.getSizeY()      !=1)    )
                Errors.throwMathLibException("UInt8NumberToken: uint8+double only works if double is scalar");
                
            UInt8NumberToken result = new UInt8NumberToken(sizeA, null, null);
            
            for(int n = 0; n < noElem; n++)
            {
                short realval      = add(getValueRe(n), nArg.getValueRe());
                short imaginaryval = add(getValueIm(n), nArg.getValueIm());
                result.setValue(n, realval, imaginaryval);
            }
            return result;
        }


        
        Errors.throwMathLibException("UInt8NumberToken: add: wrong type");
        return null;
        
    } // and add

    private short add(double a, double b)
    {
        double c= a + b;
        
        if (c>255)
            return 255;
        else if (c<0)
            return 0;
        else
            return (short)c;
    }

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

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

            if ((nArg.getSize().length!=2) || 
                (nArg.getSizeX()      !=1) || 
                (nArg.getSizeY()      !=1)    )
                Errors.throwMathLibException("UInt8NumberToken: uint8-double only works if double is scalar");
                
            UInt8NumberToken result = new UInt8NumberToken(sizeA, null, null);
            
            for(int n = 0; n < noElem; n++)
            {
                short realval      = subtract(getValueRe(n), nArg.getValueRe());
                short imaginaryval = subtract(getValueIm(n), nArg.getValueIm());
                result.setValue(n, realval, imaginaryval);
            }
            return result;
        }


        
        Errors.throwMathLibException("UInt8NumberToken: subtract: wrong type");
        return null;
        
    } // and add

    private short subtract(double a, double b)
    {
        double c= a - b;
        
        if (c>255)
            return 255;
        else if (c<0)
            return 0;
        else
            return (short)c;
    }
    
    /**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(short _values[])
    {
        if (_values==null)
            return "XXXXXX";
        
        short re = _values[REAL];
        short im = _values[IMAG];
        
        StringBuffer result =  new StringBuffer();
        
        if(im != 0)
            result.append("(");

        result.append(re);

        // imaginary part of number
        if(im != 0.0)
        {
            if ((re!=0) && !(im<0))
                result.append("+");
                
            result.append(im);
        
            result.append("i)");
        }
        return  result.toString();
    }

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

} // end Int8NumberToken