hpmath.java

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

    public static short SGN(boolean param) throws HpException
    {
        return param==true ? (short)-1:(short)0;
    }
    
    public static short SGN(HByte byte_param) throws HpException
    {
    short param = byte_param.byteValue();    
    if( param>0 )
        return (short)1;
    else if( param==0 )
        return (short)0;
    else
        return (short)-1;
    }
    
    public static short SGN(short param) throws HpException
    {
    if( param>0 )
        return (short)1;
    else if( param==0 )
        return (short)0;
    else
        return  (short)-1;
    }
    
    public static short SGN(int param) throws HpException
    {
    if( param>0 )
        return (short)1;
    else if( param==0 )
        return (short)0;
    else
        return (short)-1;
    }
    
    public static short SGN(float param) throws HpException
    {
    if( param>0 )
        return (short)1;
    else if( param==0 )
        return (short)0;
    else
        return (short)-1;
    }

    public static short SGN(double param) throws HpException
    {
    short    value=0;
    if( param>0 )
        value = 1;
    else if( param==0 )
        value = 0;
    else
        value = -1;

    return  value ;
    }
    
    public static short SGN(HCurr param) throws HpException
    {
    short    value=0;
    double     d = param.dblValue();
    if( d>0 )
        value = 1;
    else if( d==0 )
        value = 0;
    else
        value = -1;

    return  value ;
    }

    public static short SGN(HDate param) throws HpException
    {
    short    value=0;
    double     d = param.dblValue();
    if( d>0 )
        value = 1;
    else if( d==0 )
        value = 0;
    else
        value = -1;

    return  value ;
    }
    
    public static short SGN(fixedString param) throws HpException
    {
    short    value=0;
    double     d = hpstring.strtodbl(param.strValue());
    if( d>0 )
        value = 1;
    else if( d==0 )
        value = 0;
    else
        value = -1;

    return  value ;
    }

    public static short SGN(String param) throws HpException
    {
    short    value=0;
    double     d = hpstring.strtodbl(param);
    if( d>0 )
        value = 1;
    else if( d==0 )
        value = 0;
    else
        value = -1;

    return  value ;
    }


    /**
	 *Int(number)
	 *Fix(number)
	 *Returns the integer portion of a number.If number contains Null,Null is returned.
	 *Remarks
		Both Int and Fix remove the fractional part of number and return the resulting
		integer value.The difference between Int and Fix is that if number is negative,
		Int returns the first negative integer less than or equal to number, whereas
		Fix returns the first negative integer greater than or equal to number.  For
		example, Int converts -8.4 to -9, and Fix converts -8.4 to -8.
	 */
    public static Variant INT(Variant param) throws HpException
    {
        Variant  v=null;
        double   db=0;

        switch (param.getType())
    	{
            case Variant.V_NULL:
            v = new VNull();
            break;

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

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

        	case Variant.V_EMPTY:
            case Variant.V_BOL:
        	case Variant.V_INT:
        	    short tmpsht = param.intValue();
        	    v = new VInt( tmpsht);
        	break;

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

        	case Variant.V_BYTE:
            v = param;
            break;

        	case Variant.V_LONG:
    	    int  tmplg = param.lngValue();
    	    v = new VLong( tmplg );
    	    break;

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

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

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

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

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

        }

        return v;
    }

    public static short INT(boolean param) throws HpException
    {
        short i = param==true ? (short)-1:(short)0;
        return i;
    }  

    public static HByte INT(HByte param) throws HpException
    {
        return new HByte(param.byteValue());
    }

    public static short INT(short param) throws HpException
    {
        return param;
    }
    
    public static int INT(int param) throws HpException
    {
        return param;
    }

    public static float INT(float param) throws HpException
    {
	    return (float)Math.floor((double)param);
    }
    
    public static double INT(double param) throws HpException
    {
    	return Math.floor(param);
    }

    public static HCurr INT(HCurr param) throws HpException
    {
        double  d = param.dblValue();
        return new HCurr((Math.floor(d)));
    }

    public static HDate INT(HDate param) throws HpException
    {
	    double d = Math.floor( param.dblValue() );
    	return  new HDate(d);
    }

    //case Variant.V_FIX_STR:
    public static double INT(fixedString param) throws HpException
    {
        double d = hpstring.strtodbl( param.strValue() );
	    return Math.floor( d );
    }
    
    public static double INT(String param) throws HpException
    {
    	double db = hpstring.strtodbl( param );
        return  Math.floor( db );
    }
    
    /**
     *fix(number)
	 */
    public static Variant FIX(Variant param) throws HpException
    {
        Variant   v=null;
        double   db=0;
        short    i;        
    	switch (param.getType())
    	{
        	case Variant.V_NULL:
    	    v = new VNull();
    	    break;

            case Variant.V_FIX_STR:
            fixedString    fixstr = ((VString)param).getfixedLenStrValue();
            String str = fixstr.strValue();
            db = hpstring.strtodbl( str );
            if( db>0 )
                v = new VDouble( Math.floor(db) );
            else
                v = new VDouble( Math.ceil(db) );
            break;

        	case Variant.V_STR:
        	String s = param.strValue();
            db = hpstring.strtodbl( s);
            if( db>0 )
                v = new VDouble( Math.floor(db) );
            else
                v = new VDouble( Math.ceil(db) );
        	break;

        	case Variant.V_EMPTY:
        	case Variant.V_INT:
        	case Variant.V_BOL:
    	    i = param.intValue();
    	    v = new VInt(i);
    	    break;

        	case Variant.V_BYTE:
    	    v = param;
    	    break;

        	case Variant.V_LONG:
    	    v = new VLong(param.lngValue());
    	    break;

        	case Variant.V_CURR:
    	    db = param.dblValue();
            if( db>0 )
                v = new VCurr(Math.floor(db));
            else
                v = new VCurr( Math.ceil(db) );
    	    break;

        	case Variant.V_DBL:
    	    db = param.dblValue();
            if( db>0 )
                v = new VDouble( Math.floor(db));
            else
                v = new VDouble( Math.ceil(db));
    	    break;

        	case Variant.V_SINGLE:
            db = param.sglValue() ;
            if( db>0 )
                v = new VSingle( Math.floor(db) );
            else
                v = new VSingle( Math.ceil(db) );
    	    break;

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

        	case Variant.V_DATE:
    	    db = param.dblValue() ;
            v = new VDate( Math.floor(db) );
            break;

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

            }
        return v;
    }
    
    public static short FIX(boolean param) throws HpException
    {
        return param==true ? (short)-1:(short)0;   
    }

    public static HByte FIX(HByte param) throws HpException
    {
        return new HByte(param.byteValue());   
    }

    public static short FIX(short param) throws HpException
    {
        return param;   
    }
        
    public static int FIX(int param) throws HpException
    {
        return param;   
    }

    public static float FIX(float param) throws HpException
    {
        if( param>0 )
            return (float)Math.floor((double)param);
        else
            return (float)Math.ceil((double)param);
    }
    
    public static double FIX(double param) throws HpException
    {
        if( param>0 )
            return  Math.floor(param);
        else
            return Math.ceil(param);
    }
    
    public static HCurr FIX(HCurr param) throws HpException
    {
	    double db = param.dblValue();
        if( db>0 )
            return new HCurr(Math.floor(db) );
        else
            return new HCurr( Math.ceil(db) );
    }

    public static HDate FIX(HDate param) throws HpException
    {
	    double db = param.dblValue();
        if( db>0 )
           return new HDate( Math.floor(db) );
        else
           return new HDate( Math.ceil(db) );
    }

    public static double FIX(fixedString param) throws HpException
    {
        double db = hpstring.strtodbl( param.strValue() );
        if( db>0 )
            return  Math.floor(db);
        else
            return  Math.ceil(db);
    }
    
    public static double FIX(String param) throws HpException
    {
        double db = hpstring.strtodbl( param );
        if( db>0 )
            return  Math.floor(db);
        else
            return  Math.ceil(db);
    }

	/**
	 *Rnd[(number)]
	 *Returns a random number.
	 */
	public static float RND() throws HpException
    {
	float  result = (float)Math.random();
	return   result;