sparsenumbertoken.java

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

        result[REAL] =  ( (re*re) - (im*im) ) + 1.0;
        result[IMAGINARY] =  ( (re*im) + (im*re) );

        // result:  _1.Sqrt() ...
        result = sqrt(result);

        // result:  z.Plus(result) ...
        result[REAL] =  re + result[REAL];                                       // !
        result[IMAGINARY] =  im + result[IMAGINARY];                                       // !

        // _1:      result.log() ...
        result = log(result);
                
        return  result;
    }
    
    /**Trigonometric function - calculates the inverse hyperbolic cosine
       @return the result as an OperandToken*/   
    public OperandToken acosh()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = acosh(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the inverse hyperbolic cosine of a complex number
       @param arg = the angle as an array of double
       @return the result as an array of double*/ 
    public double[] acosh(double[] arg)
    {
        double result[] = new double[2];
        //  acosh(z)  =  log(z + Sqrt(z*z - 1))
        double re = arg[REAL];
        double im = arg[IMAGINARY];

        // _1:  z.Times(z).Minus(one) ...
        result[REAL]       =  ( (re*re) - (im*im) ) - 1.0;
        result[IMAGINARY]  =  ( (re*im) + (im*re) ) - 0.0;

        // result:  _1.Sqrt() ...
        result = sqrt(result);

        // result:  z.Plus(result) ...
        result[REAL] =  re + result[REAL];                                       // !
        result[IMAGINARY] =  im + result[IMAGINARY];                                       // !

        // _1:  result.log() ...
        result = log(result);

        // result:  _1 ...
        return  result;
    }

    /**Trigonometric function - calculates the inverse hyperbolic tangent
       @return the result as an OperandToken*/   
    public OperandToken atanh()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = atanh(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the inverse hyperbolic tangent  of a complex number
       @param arg = the angle as an array of double
       @return the result as an array of double*/ 
    public double[] atanh(double[] arg)
    {
        double result[] = new double[2];
        //  atanh(z)  =  1/2 * log( (1+z)/(1-z) )

        // _1:      one.Minus(z) ...
        double[] temp = new double[2];
        temp[REAL]      = 1 - arg[REAL];
        temp[IMAGINARY] = - arg[IMAGINARY];

        // result:  one.Plus(z) ...
        result[REAL] = 1 + arg[REAL];

        // result:  result.Div(_1) ...
        result = divide(result, temp);

        // _1:      result.log() ...
        result = log(result);

        // result:  _1.scale(0.5) ...
        result[REAL]       =  0.5 * result[REAL];
        result[IMAGINARY]  =  0.5 * result[IMAGINARY];
        return result;  
    }

    ///////////////////////////////////////Exponential Functions////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////
    /**Standard functions - calculates the exponent
       @return the result as an OperandToken*/
    public OperandToken exp()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = exp(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the exponent of a complex number
       @param arg = the value as an array of double
       @return the result as an array of double*/ 
    public double[] exp(double[] arg)
    {
        double[] result = new double[2];
        double scalar =  Math.exp(arg[REAL]);                                         // e^ix = cis x
        result[REAL]       = scalar * Math.cos(arg[IMAGINARY]);
        result[IMAGINARY]  = scalar * Math.sin(arg[IMAGINARY]);
        return  result;
    }
    
    /**Standard functions - calculates the natural logarythm
       @return the result as an OperandToken*/
    public OperandToken ln()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = log(values[y][x]);                
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Standard functions - calculates the logarythm
       @return the result as an OperandToken*/
    public OperandToken log()
    {        
        double[][][] results = new double[sizeY][sizeX][2];
        
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = log(values[y][x]);               
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the logarythm of a complex number
       @param arg = the value as an array of double
       @return the result as an array of double*/ 
    public double[] log(double[] arg) 
    {
        double[] result = new double[2];
        double re = arg[REAL];
        double im = arg[IMAGINARY];

        double temp = Math.pow(re, 2) + Math.pow(im, 2);
        temp =  Math.sqrt(temp);
        
        result[REAL]      = Math.log(temp);
        result[IMAGINARY] = Math.atan2(im, re);
        return  result;                      // principal value
    }

    /**Standard functions - calculates the square root    
       @return the result as an OperandToken*/
    public OperandToken sqrt()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = sqrt(values[y][x]);                
            }
        }
        return new DoubleNumberToken(results);   	
    }
    
    /**Calculates the sqrt of a complex number
       @param arg = the value as an array of double
       @return the result as an array of double*/ 
    public double[] sqrt(double[] arg) 
    {
        // with thanks to Jim Shapiro <[e-mail]>
        // adapted from "Numerical Recipies in C" (ISBN 0-521-43108-5)
        // by William H. Press et al

        double[] result = new double[2];
        double re = arg[REAL];
        double im = arg[IMAGINARY];

        double temp = Math.pow(re, 2) + Math.pow(im, 2);
        double mag =  Math.sqrt(temp);

        if (mag > 0.0) 
        {
            if (re > 0.0) 
            {
                temp =  Math.sqrt(0.5 * (mag + re));

                re =  temp;
                im =  0.5 * im / temp;
            } 
            else 
            {
                temp =  Math.sqrt(0.5 * (mag - re));

                if (im < 0.0) 
                {
                    temp =  -temp;
                }//endif

                re =  0.5 * im / temp;
                im =  temp;
            }//endif
        } 
        else 
        {
            re =  0.0;
            im =  0.0;
        }
        result[REAL] = re;
        result[IMAGINARY] = im;
        
        return result;
    }

    ///////////////////////////////////////Standard Math Functions///////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////

    /**Standard functions - absolute value  
    @return the result as an OperandToken*/
    public OperandToken abs()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        if (isReal())
        {
            // real numbers only
	        for (int yy=0; yy<sizeY; yy++)
	        {
	            for (int xx=0; xx<sizeX; xx++)
	            {
	                results[yy][xx][REAL]  = java.lang.Math.abs(values[yy][xx][REAL]);
	            }
	        }
        }
        else
        {
        	// complex absolute value
    	    double real = 0;
            double imag = 0;
            for (int yy=0; yy<sizeY; yy++)
            {
                for (int xx=0; xx<sizeX; xx++)
                {
                    real = 	values[yy][xx][REAL];
                    imag = 	values[yy][xx][IMAGINARY];
                    results[yy][xx][REAL]      = Math.sqrt( real*real + imag*imag );
                    results[yy][xx][IMAGINARY] = 0;
                }
            }
        }

        return new DoubleNumberToken(results);   	
    }

    /**Standard functions - rounds the value down  
       @return the result as an OperandToken*/
    public OperandToken floor()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for (int yy=0; yy<sizeY; yy++)
        {
            for (int xx=0; xx<sizeX; xx++)
            {
                results[yy][xx][REAL]      = java.lang.Math.floor(values[yy][xx][REAL]);
                results[yy][xx][IMAGINARY] = java.lang.Math.floor(values[yy][xx][IMAGINARY]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Standard functions - rounds the value up   
       @return the result as an OperandToken*/
    public OperandToken ceil()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for (int yy=0; yy<sizeY; yy++)
        {
            for (int xx=0; xx<sizeX; xx++)
            {
                results[yy][xx][REAL]      = Math.ceil(values[yy][xx][REAL]);
                results[yy][xx][IMAGINARY] = Math.ceil(values[yy][xx][IMAGINARY]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Standard functions - rounds the value to the nearest integer 
       @return the result as an OperandToken*/
    public OperandToken round()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for (int yy=0; yy<sizeY; yy++)
        {
            for (int xx=0; xx<sizeX; xx++)
            {
                results[yy][xx][REAL]      = java.lang.Math.rint(values[yy][xx][REAL]);
                results[yy][xx][IMAGINARY] = java.lang.Math.rint(values[yy][xx][IMAGINARY]);
            }
        }
        return new DoubleNumberToken(results);   	
    }
    
    /**standard function - returns the negative of the number*/
    public OperandToken negate()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for (int yy=0; yy<sizeY; yy++)
        {
            for (int xx=0; xx<sizeX; xx++)
            {
                results[yy][xx][REAL]      = -values[yy][xx][REAL];
                results[yy][xx][IMAGINARY] = -values[yy][xx][IMAGINARY];
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Standard functions - calculates the minimum of two values
       @return the result as an OperandToken*/
    public OperandToken min(RootObject arg)
    {
		// !!! see matlab documentation for correct implementation		

        double arg2 = ((DoubleNumberToken)arg).getValueRe(0, 0);       
        double result = java.lang.Math.min(values[0][0][REAL], arg2);
        return new DoubleNumberToken(result);   	
    }

    /**Standard functions - calculates the maximum of two values
       @return the result as an OperandToken*/
    public OperandToken max(RootObject arg)
    {
		// !!! see matlab documentation for correct implementation		

        double arg2 = ((DoubleNumberToken)arg).getValueRe(0, 0);       
        double result = java.lang.Math.max(values[0][0][REAL], arg2);
        return new DoubleNumberToken(result);   	
    }

    /**Standard functions - calculates the factorial of the number
       @return the result as an OperandToken*/
    public OperandToken factorial()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for (int yy=0; yy<sizeY; yy++)
        {
            for (int xx=0; xx<sizeX; xx++)
            {
                double amount = java.lang.Math.rint(values[yy][xx][REAL]);
                results[yy][xx][REAL] = factorial(amount);               
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calulates the factorial