sparsenumbertoken.java

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

        _im2 =  scalar * Math.sin(-iz_im);

        // _1:      _1.Minus(_2) ...
        _re1 = _re1 - _re2;                                                // !!!
        _im1 = _im1 - _im2;                                                // !!!

        // result:  _1.Div(2*i) ...
        result[REAL] = 0.5*_im1;
        result[IMAGINARY] = -0.5*_re1;
        
        return result;
    }

    /**trigonometric functions - calculate the cosine of this token
    @return the result as an OperandToken*/
    public OperandToken cos()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = cos(values[y][x]);                
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the cosine of a complex number
       @param arg = the angle as an array of double
       @return the result as an array of double*/ 
    public double[] cos(double[] arg)
    {
        double result[] = new double[2];
        double scalar;
        double iz_re, iz_im;
        double _re1, _im1;
        double _re2, _im2;

        // iz:      i.Times(z) ...
        iz_re =  -arg[IMAGINARY];
        iz_im =   arg[REAL];

        // _1:      iz.exp() ...
        scalar =  Math.exp(iz_re);
        _re1 =  scalar * Math.cos(iz_im);
        _im1 =  scalar * Math.sin(iz_im);

        // _2:      iz.neg().exp() ...
        scalar =  Math.exp(-iz_re);
        _re2 =  scalar * Math.cos(-iz_im);
        _im2 =  scalar * Math.sin(-iz_im);

        // _1:      _1.Plus(_2) ...
        _re1 = _re1 + _re2;                                                // !!!
        _im1 = _im1 + _im2;                                                // !!!

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

    /**trigonometric functions - calculate the tangent of this token
    @return the result as an OperandToken*/
    public OperandToken tan()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = tan(values[y][x]);                
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the tangent of a complex number
       @param arg = the angle as an array of double
       @return the result as an array of double*/ 
    public double[] tan(double[] arg)
    {
        double[] temp1 = new double[2];
        temp1[REAL] = arg[REAL];
        temp1[IMAGINARY] = arg[IMAGINARY];
        temp1 = sin(temp1);
        double[] temp2 = cos(arg);
        return divide(temp1, temp2);
    }

    /**trigonometric functions - calculate the arc sine of this token
    @return the result as an OperandToken*/
    public OperandToken asin()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = asin(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the arcsine of a complex number
       @param arg = the value as an array of double
       @return the result as an array of double*/ 
    public double[] asin(double[] arg)
    {
        double result[] = new double[2];
        //  asin(z)  =  -i * log(i*z + Sqrt(1 - z*z))
        double re =  arg[REAL];
        double im =  arg[IMAGINARY];
        
        // _1:      one.Minus(z.Times(z)) ...
        result[REAL]       =  1.0 - ( (re*re) - (im*im) );
        result[IMAGINARY]  =  0.0 - ( (re*im) + (im*re) );

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

        // _1:      z.Times(i) ...
        // result:  _1.Plus(result) ...
        result[REAL]       =   result[REAL] - im;
        result[IMAGINARY]  = result[IMAGINARY] +  re;

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

        double temp     = result[IMAGINARY];
        result[IMAGINARY]  =  -result[REAL];
        result[REAL]       =  temp;

        return result;
    }
    
    /**trigonometric functions - calculate the arc cosine of this token
    @return the result as an OperandToken*/
    public OperandToken acos()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = acos(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the arccosine of a complex number
       @param arg = the value as an array of double
       @return the result as an array of double*/ 
    public double[] acos(double[] arg)
    {
        double result[] = new double[2];
        double _re1, _im1;

        double re =  arg[REAL];
        double im =  arg[IMAGINARY];
               
        // _1:      one - z^2 ...
        result[REAL]       =  1.0 - ( (re*re) - (im*im) );
        result[IMAGINARY]  =  0.0 - ( (re*im) + (im*re) );

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

        // _1:      i * result ...
        _re1 =  - result[IMAGINARY];
        _im1 =  + result[REAL];

        // result:  z +_1  ...
        result[REAL]       =  re + _re1;
        result[IMAGINARY]  =  im + _im1;

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

        // result:  -i * _1 ...
        double temp = result[IMAGINARY];
        result[IMAGINARY] = -result[REAL];
        result[REAL] = temp;
        
        return result;
    }
    
    /**trigonometric functions - calculate the arc tangent of this token
    @return the result as an OperandToken*/
    public OperandToken atan()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = atan(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the arctangent of a complex number
       @param arg = the value as an array of double
       @return the result as an array of double*/ 
    public double[] atan(double[] arg)
    {
        double result[] = new double[2];
        double[] temp = new double[2];
        //  atan(z)  =  -i/2 * log( (i-z)/(i+z) )

        double _re1, _im1;

        // result:  i.Minus(z) ...
        temp[REAL] = -arg[REAL];
        temp[IMAGINARY] = 1 - arg[IMAGINARY];

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

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

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

        // result:  half_i.neg().Times(_2) ...
        double t = -0.5 * result[REAL];
        result[REAL] =   0.5 * result[IMAGINARY];
        result[IMAGINARY] =  t;
        return  result;        
    }
	
    /**Trigonometric function - calculates the hyperbolic sine
       @return the result as an OperandToken*/   
    public OperandToken sinh()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = sinh(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
    }

    /**Calculates the hyperbolic sine of a complex number
       @param arg = the angle as an array of double
       @return the result as an array of double*/ 
    public double[] sinh(double[] arg)
    {
        double result[] = new double[2];
        double scalar;
        double _re1, _im1;
        double _re2, _im2;

        // _1:      z.exp() ...
        scalar =  Math.exp(arg[REAL]);
        _re1 =  scalar * Math.cos(arg[IMAGINARY]);
        _im1 =  scalar * Math.sin(arg[IMAGINARY]);

        // _2:      z.neg().exp() ...
        scalar =  Math.exp(-arg[REAL]);
        _re2 =  scalar * Math.cos(-arg[IMAGINARY]);
        _im2 =  scalar * Math.sin(-arg[IMAGINARY]);

        // _1:      _1.Minus(_2) ...
        _re1 = _re1 - _re2;                        // !!!
        _im1 = _im1 - _im2;                        // !!!

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

        return result;
    }    

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

    /**Calculates the 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[] cosh(double[] arg)
    {
        double result[] = new double[2];
        double scalar;
        double _re1, _im1;
        double _re2, _im2;

        // _1:      z.exp() ...
        scalar =  Math.exp(arg[REAL]);
        _re1 =  scalar * Math.cos(arg[IMAGINARY]);
        _im1 =  scalar * Math.sin(arg[IMAGINARY]);

        // _2:      z.neg().exp() ...
        scalar =  Math.exp(-arg[REAL]);
        _re2 =  scalar * Math.cos(-arg[IMAGINARY]);
        _im2 =  scalar * Math.sin(-arg[IMAGINARY]);

        // _1:  _1.Plus(_2) ...
        _re1 = _re1 + _re2;                    // !!!
        _im1 = _im1 + _im2;                    // !!!

        // result:  _1.scale(0.5) ...
        result[REAL] = 0.5 * _re1;
        result[IMAGINARY] = 0.5 * _im1;
        
        return result;
    }
    
    /**Trigonometric function - calculates the hyperbolic tan
       @return the result as an OperandToken*/   
    public OperandToken tanh()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = tanh(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
	}
		
    /**Calculates the 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[] tanh(double[] arg)
    {
        double[] temp1 = new double[2];
        temp1[REAL] = arg[REAL];
        temp1[IMAGINARY] = arg[IMAGINARY];
        
        temp1 = sinh(temp1);
        double[] temp2 = cosh(arg);
        
        return divide(temp1, temp2);
    }

    /**Trigonometric function - calculates the inverse hyperbolic sine
       @return the result as an OperandToken*/   
    public OperandToken asinh()
    {
        double[][][] results = new double[sizeY][sizeX][2];
        for(int y = 0; y < sizeY; y++)
        {
            for(int x = 0; x < sizeX; x++)
            {
                results[y][x] = asinh(values[y][x]);
            }
        }
        return new DoubleNumberToken(results);   	
    }
	
    /**Calculates the inverse hyperbolic sine of a complex number
       @param arg = the value as an array of double
       @return the result as an array of double*/ 
    public double[] asinh(double[] arg)
    {
        double result[] = new double[2];
        //  asinh(z)  =  log(z + Sqrt(z*z + 1))
        double re = arg[REAL];
        double im = arg[IMAGINARY];
        // _1:      z.Times(z).Plus(one) ...