hpmath.java

来自「一个简单的visio程序。」· Java 代码 · 共 1,723 行 · 第 1/4 页

        case Variant.V_OBJ:
        //Wrapper  obj = param.getObject();
        //if( obj==null )
        //    throw new HpException( 91, "Object variable or With block variable not set");
        v = new VInt( Math.round( ((VObject)param).getDefaultProperty().intValue() )) ;
        break;

        case Variant.V_BOL:
        boolean  bool = param.boolValue();
        v = new VBoolean(bool);
        break;

        case Variant.V_INT:
    	short  shvalue = param.intValue();
    	if( shvalue<=-32768 )
    		throw new HpException(6,"Overflow");
        v = new VInt( Math.abs( param.intValue() ));
        break;

        case Variant.V_LONG:
        int  vblng = param.lngValue();
        if ( vblng<= -2147483648 )
            throw new HpException(6, "Overflow");

        v = new VLong( Math.abs(param.lngValue()) );
        break;

        case Variant.V_SINGLE:
        v = new VSingle(Math.abs(param.sglValue()) );
        break;

        case Variant.V_DATE:
        double tempdb = Math.abs( param.dblValue() );
        v = new VDate(tempdb);
        break;

        case Variant.V_CURR:
        v = new VCurr(Math.abs( param.dblValue()) );
        break;

        case Variant.V_DBL:
        v = new VDouble(Math.abs( param.dblValue()) );
        break;

        case Variant.V_VAR:
        v = Variant.newVariant(Variant.V_VAR, Math.abs( param.dblValue() ));
        break;

        case Variant.V_NULL:
        v = new VNull();
        break;

        case Variant.V_FIX_STR:
        fixedString  fixstr = ((VString)param).getfixedLenStrValue();
        String   str = fixstr.strValue();
        double d = hpstring.strtodbl( str);
        v = new VDouble( Math.abs( d));
        break;

        case Variant.V_STR:
        double  db=0;
        String s = param.strValue();
        db = hpstring.strtodbl( s);
        v = new VDouble( Math.abs(db) );
        break;

        default:
            throw new HpException(13,"Type mismatch");
        }
        return v;
    }

    //case V_EMPTY
    public static short ABS( boolean param ) throws HpException
    {
        return param==true ? (short)1:(short)0;
    }

    public static HByte ABS( HByte param ) throws HpException
    {
        return new HByte((short)Math.abs((int)(param.byteValue())));
    }

    public static short ABS( short param ) throws HpException
    {
        return (short)Math.abs((int)param);
    }
    
    public static int ABS(int param ) throws HpException
    {
        return Math.abs((int)param);
    }
    
    public static float ABS( float param ) throws HpException
    {
        return Math.abs(param);
    }
    
    public static double ABS( double param ) throws HpException
    {
        return Math.abs(param);
    }
    
    public static HCurr ABS( HCurr param ) throws HpException
    {
        double d = param.dblValue();
        return new HCurr( Math.abs(d) );
    }
    
    public static HDate ABS( HDate param ) throws HpException
    {
        double d = param.dblValue();
        return new HDate( Math.abs(d) );
    }

    public static double ABS( fixedString param ) throws HpException
    {
        double d = hpstring.strtodbl(param.strValue() );
        return Math.abs(d);
    }

    public static double ABS( String param ) throws HpException
    {
        double  d = hpstring.strtodbl(param);
        return Math.abs(d);
    }


    /**
	 *Sqr(number)
	 *Returns the square root of a number.
	 */
    public static double SQR(Variant param) throws HpException
    {
    double     d = hpstring.get_db(param);
    if(d<0)
        throw new HpException(5, "Invalid procedure call");

    return  Math.sqrt(d) ;
    }

    public static double SQR(boolean param) throws HpException
    {
    if( param==true )
        throw new HpException(5, "Invalid procedure call");
    else
        return  Math.sqrt((double)0) ;
    }

    public static double SQR(HByte byte_param) throws HpException
    {
    short param = byte_param.byteValue();    
    if(param<0)
        throw new HpException(5, "Invalid procedure call");

    return  Math.sqrt(param) ;
    }

    public static double SQR(short param) throws HpException
    {
    if(param<0)
        throw new HpException(5, "Invalid procedure call");

    return  Math.sqrt((double)param) ;
    }

    public static double SQR(int param) throws HpException
    {
    if(param<0)
        throw new HpException(5, "Invalid procedure call");

    return  Math.sqrt((double)param) ;
    }
   
    public static double SQR(float param) throws HpException
    {
    if(param<0)
        throw new HpException(5, "Invalid procedure call");

    return  Math.sqrt((double)param) ;
    }
    
    public static double SQR(double d) throws HpException
    {
    if(d<0)
        throw new HpException(5, "Invalid procedure call");

    return  Math.sqrt(d) ;
    }

    public static double SQR(HCurr param) throws HpException
    {
    double d = param.dblValue();    
    if(d<0)
        throw new HpException(5, "Invalid procedure call");

    return  Math.sqrt(d) ;
    }

    public static double SQR(HDate param) throws HpException
    {
    double     d = param.dblValue();
    if(d<0)
        throw new HpException(5, "Invalid procedure call");
    return  Math.sqrt(d) ;
    }

    public static double SQR(fixedString param) throws HpException
    {
    double     d = hpstring.strtodbl( param.strValue() );
    if(d<0)
        throw new HpException(5, "Invalid procedure call");
    return  Math.sqrt(d) ;
    }
    
    public static double SQR(String param) throws HpException
    {
    double     d = hpstring.strtodbl(param);
    if(d<0)
        throw new HpException(5, "Invalid procedure call");
    return  Math.sqrt(d) ;
    }


    /**
	 *Exp(number)
	 *Returns e (the base of natural logarithms) raised to a power.
	 */
	public static double EXP(Variant param) throws HpException
    {
    double     d = hpstring.get_db(param);
    if (d>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp(d) ;
    }

	public static double EXP(boolean param) throws HpException
    {
        return   Math.exp(param==true ? (double)-1:(double)0 ) ;
    }

	public static double EXP(HByte param) throws HpException
    {
    return   Math.exp((double)(param.byteValue())) ;
    }

	public static double EXP(short param) throws HpException
    {
    if (param>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp((double)param ) ;
    }

	public static double EXP(int param) throws HpException
    {
    if (param>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp((double)param ) ;
    }

	public static double EXP(float param) throws HpException
    {
    if (param>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp(param) ;
    }

	public static double EXP(double d) throws HpException
    {
    if (d>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp(d) ;
    }

	public static double EXP(HCurr param) throws HpException
    {
    double d = param.dblValue();    
    if (d>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp(d) ;
    }
    
	public static double EXP(HDate param) throws HpException
    {
    double     d = param.dblValue();
    if (d>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp(d) ;
    }
    
	public static double EXP(fixedString param) throws HpException
    {
    double d = hpstring.strtodbl( param.strValue());
    if (d>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp(d) ;
    }
    
	public static double EXP(String param) throws HpException
    {
    double d = hpstring.strtodbl( param);
    if (d>=709.782712894)
        throw new HpException(6, "Overflow");

    return   Math.exp(d) ;
    }


    /**
	 *Log(number)
     *Returns the natural logarithm of a number.
     */
    public static double LOG(Variant param) throws HpException
    {
    double     d = hpstring.get_db(param);
    if (d<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log(d);
    }

    public static double LOG(boolean param) throws HpException
    {
        throw new HpException(5, "Invalid procedure call");
    }

    public static double LOG(HByte byte_param) throws HpException
    {
    short param = byte_param.byteValue();    
    if (param<=0)
        throw new HpException(5, "Invalid procedure call");
    return    Math.log((double)param);
    }
    
    public static double LOG(short param) throws HpException
    {
    if (param<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log((double)param);
    }

    public static double LOG(int param) throws HpException
    {
    if (param<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log((double)param );
    }

    public static double LOG(float param) throws HpException
    {
    if (param<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log((double)param);
    }

    public static double LOG(double d) throws HpException
    {
    if (d<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log(d);
    }
    
    public static double LOG(HCurr param) throws HpException
    {
    double d = param.dblValue();
    if (d<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log(d);
    }

    public static double LOG(HDate param) throws HpException
    {
    double     d = param.dblValue();
    if (d<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log(d);
    }

    public static double LOG(fixedString param) throws HpException
    {
    double d = hpstring.strtodbl(param.strValue());
    if (d<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log(d);
    }

    public static double LOG(String  param) throws HpException
    {
    double     d = hpstring.strtodbl(param);
    if (d<=0)
        throw new HpException(5, "Invalid procedure call");

    return    Math.log(d);
    }


	/**
	 *Sgn(number)
	 *Returns an integer indicating the sign of a number.
	 *if number Greater than zero return 1,if number Equal to zero return 0,if
	 *number Less than zero	 return -1
	 */
    public static short SGN(Variant param) throws HpException
    {
    short    value=0;
    double     d = hpstring.get_db(param);
    if( d>0 )
        value = 1;
    else if( d==0 )
        value = 0;
    else
        value = -1;

    return  value ;
    }