mathcmds.java

Hecl编程语言是一个高层次的脚本语言的Java实现。其用意是要小

/* Copyright 2006 Wolfgang S. Kechel

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package org.hecl;

import java.util.Enumeration;
import java.util.Hashtable;

/**
 * The <code>MathCmds</code> class implements a variety of math
 * commands, depending on which version of Java Hecl is compiled for.
 *
 * @version 1.0
 */
public class MathCmds extends org.hecl.Operator {
//#if javaversion >= 1.5 || cldc > 1.0
    public static final Thing E = new Thing(new DoubleThing(Math.E));
    public static final Thing PI = new Thing(new DoubleThing(Math.PI));
//#endif

    public static final int CASTINT = 1;
    public static final int CASTLONG = 2;
    public static final int CASTFLOAT = 3;
    public static final int CASTDOUBLE = 4;
    public static final int TODEGREES = 5;
    public static final int TORADIANS = 6;
    public static final int ABS = 7;
    public static final int SQRT = 8;
    public static final int LOG = 9;

    public static final int SIN = 10;
    public static final int COS = 11;
    public static final int TAN = 12;
    public static final int ASIN = 13;
    public static final int ACOS = 14;
    public static final int ATAN = 15;
    public static final int EXP = 16;
    public static final int FLOOR = 17;
    public static final int CEIL = 18;
    public static final int POW = 19;
    public static final int RANDOM = 20;
    public static final int ROUND = 21;
    public static final int MIN = 22;
    public static final int MAX = 23;

    // valid only for java 1.5
    public static final int SIGNUM = 30;
    public static final int CBRT = 31;
    public static final int LOG10 = 32;
    public static final int LOG1P = 33;
    public static final int SINH = 34;
    public static final int COSH = 35;
    public static final int TANH = 36;
    public static final int EXPM1 = 37;
    public static final int HYPOT = 38;
    // end valid for java 1.5

    public static final int INCR = 50;
    public static final int DECR = 51;
    public static final int TRUE = 52;
    public static final int FALSE = 53;

    public static final int NOT = 80;
    public static final int AND = 81;
    public static final int OR = 82;

    public static final int EQ = 90;
    public static final int NEQ = 91;
    public static final int LT = 92;
    public static final int LE = 93;
    public static final int GT = 94;
    public static final int GE = 95;

    public static final int BINADD = 100;
    public static final int BINSUB = 101;
    public static final int BINMUL = 102;
    public static final int BINDIV = 103;
    public static final int MOD = 104;
    public static final int PLUS = 105;
    public static final int MINUS = 106;
    public static final int MUL = 107;

    // Comparison
    public static int compare(Thing a,Thing b) {
	return compare(NumberThing.asNumber(a),NumberThing.asNumber(b));
    }

    public static int compare(NumberThing a,NumberThing b) {
//#if javaversion >= 1.5 || cldc > 1.0
	if(a.isIntegral() && b.isIntegral()) {
//#endif
	    if(((IntegralThing)a).isLong() || ((IntegralThing)b).isLong()) {
		return compare(a.longValue(),b.longValue());
	    }
	    return compare(a.intValue(),b.intValue());
//#if javaversion >= 1.5 || cldc > 1.0
	}
	return compare(a.doubleValue(),b.doubleValue());
//#endif
    }

    public static Thing unary(int cmdcode,Interp ip,NumberThing a)
	throws HeclException {
	switch(cmdcode) {
	  case CASTINT:
	    return IntThing.create(a.intValue());
	  case CASTLONG:
	    return LongThing.create(a.longValue());
//#if javaversion >= 1.5 || cldc > 1.0
	  case CASTFLOAT:
	  case CASTDOUBLE:
	    return DoubleThing.create(a.doubleValue());
	  case TODEGREES:
	    return DoubleThing.create(Math.toDegrees(a.doubleValue()));
	  case TORADIANS:
	    return DoubleThing.create(Math.toRadians(a.doubleValue()));
//#endif
	  case ABS:
//#if javaversion >= 1.5 || cldc > 1.0
	    if(a.isIntegral()) {
//#endif
		IntegralThing i = (IntegralThing)a;
		if(i.isLong())
		    return LongThing.create(Math.abs(i.longValue()));
		return IntThing.create(Math.abs(i.intValue()));
//#if javaversion >= 1.5 || cldc > 1.0
	    }
	    return DoubleThing.create(Math.abs(a.doubleValue()));
//#endif
//#if javaversion >= 1.5 || cldc > 1.0
	  case SIN:
	    return DoubleThing.create(Math.sin(a.doubleValue()));
	  case COS:
	    return DoubleThing.create(Math.cos(a.doubleValue()));
	  case TAN:
	    return DoubleThing.create(Math.tan(a.doubleValue()));
	  case SQRT:
	    return DoubleThing.create(Math.sqrt(a.doubleValue()));
	  case FLOOR:
	    return DoubleThing.create(Math.floor(a.doubleValue()));
	  case CEIL:
	    return DoubleThing.create(Math.ceil(a.doubleValue()));
	  case ROUND:
	    if(a.isIntegral()) {
		return new Thing(a.deepcopy());
	    } else {
		long l = (long)
		//#ifdef j2se
		    Math.round(a.doubleValue())
		//#else
		    Math.floor(.5+a.doubleValue())
		//#endif
		    ;
		if(l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE) {
		    return IntThing.create((int)l);
		}
		return LongThing.create(l);
	    }
//#endif
	  case INCR:
	    return binary(BINADD,ip,a,IntThing.ONE);
	  case DECR:
	    return binary(BINSUB,ip,a,IntThing.ONE);
	  case NOT:
	    return boolres(!(a.intValue() != 0));
//#ifdef j2se
	  case LOG:
	    return DoubleThing.create(Math.log(a.doubleValue()));
	  case ASIN:
	    return DoubleThing.create(Math.asin(a.doubleValue()));
	  case ACOS:
	    return DoubleThing.create(Math.acos(a.doubleValue()));
	  case ATAN:
	    return DoubleThing.create(Math.atan(a.doubleValue()));
	  case EXP:
	    return DoubleThing.create(Math.exp(a.doubleValue()));
//#if javaversion >= 1.5
	  case SIGNUM:
	    return DoubleThing.create(Math.signum(a.doubleValue()));
	  case CBRT:
	    return DoubleThing.create(Math.cbrt(a.doubleValue()));
	  case LOG10:
	    return DoubleThing.create(Math.log10(a.doubleValue()));
	  case LOG1P:
	    return DoubleThing.create(Math.log1p(a.doubleValue()));
	  case SINH:
	    return DoubleThing.create(Math.sinh(a.doubleValue()));
	  case COSH:
	    return DoubleThing.create(Math.cosh(a.doubleValue()));
	  case TANH:
	    return DoubleThing.create(Math.tanh(a.doubleValue()));
	  case EXPM1:
	    return DoubleThing.create(Math.expm1(a.doubleValue()));
//#endif
//#endif
	}
	throw new HeclException("Unknown unary mathcmdcode '"+cmdcode+"'.");
    }


    public static Thing binary(int cmdcode, Interp ip, NumberThing a, NumberThing b)
	throws HeclException {

	switch(cmdcode) {
	  case BINADD:
//#if javaversion >= 1.5 || cldc > 1.0
	    if(a.isIntegral() && b.isIntegral()) {
//#endif
		if(((IntegralThing)a).isLong()
		   || ((IntegralThing)b).isLong()) {
		    return LongThing.create(a.longValue()+b.longValue());
		}
		return IntThing.create(a.intValue()+b.intValue());
//#if javaversion >= 1.5 || cldc > 1.0
	    }
	    return DoubleThing.create(a.doubleValue()+b.doubleValue());
//#endif
	  case BINSUB:
//#if javaversion >= 1.5 || cldc > 1.0
	    if(a.isIntegral() && b.isIntegral()) {
//#endif
		if(((IntegralThing)a).isLong()
		   || ((IntegralThing)b).isLong()) {
		    return LongThing.create(a.longValue()-b.longValue());
		}
		return IntThing.create(a.intValue()-b.intValue());
//#if javaversion >= 1.5 || cldc > 1.0
	    }
	    return DoubleThing.create(a.doubleValue()-b.doubleValue());
//#endif
	  case BINMUL:
//#if javaversion >= 1.5 || cldc > 1.0
	    if(a.isIntegral() && b.isIntegral()) {
//#endif
		if(((IntegralThing)a).isLong()
		   || ((IntegralThing)b).isLong()) {
		    return LongThing.create(a.longValue()*b.longValue());
		}
		return IntThing.create(a.intValue()*b.intValue());
//#if javaversion >= 1.5 || cldc > 1.0
	    }
	    return DoubleThing.create(a.doubleValue()*b.doubleValue());
//#endif
	  case BINDIV:
//#if javaversion >= 1.5 || cldc > 1.0
	    if(a.isIntegral() && b.isIntegral()) {
//#endif
		if(((IntegralThing)a).isLong()
		   || ((IntegralThing)b).isLong()) {
		    return LongThing.create(a.longValue()/b.longValue());
		}
		return IntThing.create(a.intValue()/b.intValue());
//#if javaversion >= 1.5 || cldc > 1.0
	    }
	    return DoubleThing.create(a.doubleValue()/b.doubleValue());
//#endif
	  case MOD:
//#if javaversion >= 1.5 || cldc > 1.0
	    if(a.isIntegral() && b.isIntegral()) {
//#endif
		if(((IntegralThing)a).isLong()
		   || ((IntegralThing)b).isLong()) {
		    return LongThing.create(a.longValue()%b.longValue());
		}