implement all numeric operators

trifork · Nov 22, 2009 · 73c061e · 73c061e
1 parent a1c318b
commit 73c061e
Show file tree

Hide file tree

Showing 22 changed files with 1,057 additions and 225 deletions.
diff --git a/src/main/java/erjang/EBig.java b/src/main/java/erjang/EBig.java
@@ -26,12 +26,49 @@
 
 public class EBig extends EInteger {
 
+	private static final BigInteger EBIG32 = BigInteger.valueOf(32);
+	private static final BigInteger EBIG_MAXINT = BigInteger.valueOf(Integer.MAX_VALUE);
+
 	private final BigInteger value;
 
 	public EBig(BigInteger value) {
 		this.value = value;
 	}
 
+
+	/* (non-Javadoc)
+	 * @see java.lang.Object#hashCode()
+	 */
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((value == null) ? 0 : value.hashCode());
+		return result;
+	}
+
+
+	/* (non-Javadoc)
+	 * @see java.lang.Object#equals(java.lang.Object)
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		EBig other = (EBig) obj;
+		if (value == null) {
+			if (other.value != null)
+				return false;
+		} else if (!value.equals(other.value))
+			return false;
+		return true;
+	}
+
+
 	public EBig(long res) {
 		this.value = BigInteger.valueOf(res);
 	}
@@ -67,7 +104,194 @@ public org.objectweb.asm.Type emit_const(MethodVisitor fa) {
 	}
 
 	@Override
-	public EBig asb() {
+	public EBig abs() {
 		return new EBig(value.abs());
 	}
+
+	public ENumber add(EObject other) { return other.add(value); }
+
+	public ENumber add(int lhs) { 
+		return ERT.box(BigInteger.valueOf(lhs).add(value));
+	}
+
+	public ENumber add(double lhs) { 
+		return ERT.box(lhs + value.doubleValue());
+	}
+
+	public ENumber add(BigInteger lhs) { 
+		return ERT.box(lhs.add(value));
+	}
+
+
+
+	public ENumber subtract(EObject other) { return other.r_subtract(value); }
+
+	public ENumber r_subtract(int lhs) { 
+		return ERT.box(BigInteger.valueOf(lhs).subtract(value));
+	}
+
+	public ENumber r_subtract(double lhs) { 
+		return ERT.box(lhs - value.doubleValue());
+	}
+
+	public ENumber r_subtract(BigInteger lhs) { 
+		return ERT.box(lhs.subtract(value));
+	}
+
+
+	public EInteger idiv(EObject other) { return other.r_idiv(value); }
+
+	public EInteger r_idiv(int lhs) { 
+		return ERT.box(BigInteger.valueOf(lhs).divide(value)).asInteger();
+	}
+
+	public EInteger r_idiv(BigInteger lhs) { 
+		return ERT.box(lhs.divide(value)).asInteger();
+	}
+
+
+
+	public EInteger irem(EObject other) { return other.r_irem(value); }
+
+	public EInteger r_irem(int lhs) { 
+		return ERT.box(BigInteger.valueOf(lhs).divide(value));
+	}
+
+	public EInteger r_irem(BigInteger lhs) { 
+		return ERT.box(lhs.remainder(value));
+	}
+
+
+	public EDouble divide(EObject other) { return other.r_divide(value); }
+
+	public EDouble r_divide(int lhs) { 
+		return ERT.box(lhs / value.doubleValue());
+	}
+
+	public EDouble r_divide(double lhs) { 
+		return ERT.box(lhs / value.doubleValue());
+	}
+
+	public EDouble r_divide(BigInteger lhs) { 
+		return ERT.box(lhs.doubleValue() / value.doubleValue());
+	}
+
+
+	public ENumber multiply(EObject other) { return other.multiply(value); }
+
+	public ENumber multiply(int lhs) { 
+		return ERT.box(BigInteger.valueOf(lhs).multiply(value));
+	}
+
+	public ENumber multiply(double lhs) { 
+		return ERT.box(lhs * value.doubleValue());
+	}
+
+	public ENumber multiply(BigInteger lhs) { 
+		return ERT.box(lhs.multiply(value));
+	}
+
+
+
+	public EInteger bsr(EObject other) {
+		return other.r_bsr(value);
+	}
+
+	public EInteger r_bsr(int lhs) { 
+		if (EBIG32.compareTo(value) <= 0) {
+			return new ESmall(0);
+		} else {
+			return ERT.box(lhs >> value.intValue());
+		}
+	}
+
+	public EInteger r_bsr(BigInteger lhs) { 
+		if (EBIG_MAXINT.compareTo(value) < 0) {
+			return new ESmall(0);
+		} else {
+			return ERT.box( lhs.shiftRight(value.intValue()) );
+		}
+	}
+
+	public EInteger bsl(EObject other) {
+		return other.r_bsl(value);
+	}
+
+	public EInteger r_bsl(int lhs) { 
+		if (EBIG32.compareTo(value) <= 0) {
+			return new ESmall(0);
+		} else {
+			return ERT.box(lhs << value.intValue());
+		}
+	}
+
+	public EInteger r_bsl(BigInteger lhs) { 
+		if (EBIG_MAXINT.compareTo(value) < 0) {
+			return new ESmall(0);
+		} else {
+			return ERT.box( lhs.shiftLeft(value.intValue()) );
+		}
+	}
+
+	// binary and
+
+	public EInteger band(EObject other) { return other.band(value); }
+
+	public EInteger band(int lhs) { 
+		return ERT.box(BigInteger.valueOf(lhs).and(value));
+	}
+
+	public EInteger band(BigInteger lhs) { 
+		return ERT.box(lhs.add(value));
+	}
+
+
+	// binary or
+
+	public EInteger bor(EObject other) { return other.bor(value); }
+
+	public EInteger bor(int lhs) { 
+		return ERT.box(BigInteger.valueOf(lhs).or(value));
+	}
+
+	public EInteger bor(BigInteger lhs) { 
+		return ERT.box(lhs.or(value));
+	}
+
+
+	// binary xor
+
+	public EInteger bxor(EObject other) { return other.bxor(value); }
+
+	public EInteger bxor(int lhs) { 
+		return ERT.box(BigInteger.valueOf(lhs).and(value));
+	}
+
+	public EInteger bxor(BigInteger lhs) { 
+		return ERT.box(lhs.xor(value));
+	}
+
+	public EInteger bnot() {
+		return ERT.box(value.not());
+	}
+
+
+/* (non-Javadoc)
+	 * @see erjang.EInteger#bigintValue()
+	 */
+	@Override
+	BigInteger bigintValue() {
+		return value;
+	}
+
+	/* (non-Javadoc)
+	 * @see erjang.ENumber#doubleValue()
+	 */
+	@Override
+	public double doubleValue() {
+		return value.doubleValue();
+	}
+
+
+
 }
diff --git a/src/main/java/erjang/EDouble.java b/src/main/java/erjang/EDouble.java
@@ -19,6 +19,9 @@
 package erjang;
 
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
@@ -47,7 +50,7 @@ public static EObject parseDouble(String string) {
 
 
 	@Override
-	public EDouble asb() {
+	public EDouble abs() {
 		return new EDouble (Math.abs(value));
 	}
 
@@ -56,6 +59,15 @@ public String toString() {
 		return String.valueOf(value);
 	}
 
+	public EInteger asInteger() {
+		if (value >= Integer.MIN_VALUE && value <= Integer.MAX_VALUE) {
+			return new ESmall((int)value);
+		} else {
+			return new EBig(BigDecimal.valueOf(value).toBigInteger());
+		}
+	}
+
+
 
 	@Override
 	public org.objectweb.asm.Type emit_const(MethodVisitor fa) {
@@ -77,5 +89,82 @@ public EString to_list() {
 		return new EString(String.valueOf(value));
 	}
 
+
+	public ENumber add(EObject other) { return other.add(value); }
+
+	public ENumber r_add(int lhs) { 
+		return ERT.box((long)lhs + value);
+	}
+
+	public ENumber add(double lhs) { 
+		return ERT.box(lhs + value);
+	}
+
+	public ENumber add(BigInteger lhs) { 
+		return ERT.box(lhs.doubleValue() + value);
+	}
+
+
+	public ENumber subtract(EObject other) { return other.r_subtract(value); }
+
+	public ENumber r_subtract(int lhs) { 
+		return ERT.box((long)lhs - value);
+	}
+
+	public ENumber r_subtract(double lhs) { 
+		return ERT.box(lhs - value);
+	}
+
+	public ENumber r_subtract(BigInteger lhs) { 
+		return ERT.box(lhs.doubleValue() - value);
+	}
+
+
+
+
+
+	public ENumber multiply(EObject other) { return other.multiply(value); }
+
+	public ENumber multiply(int lhs) { 
+		return ERT.box(lhs * value);
+	}
+
+	public ENumber multiply(double lhs) { 
+		return ERT.box(lhs * value);
+	}
+
+	public ENumber multiply(BigInteger lhs) { 
+		return ERT.box(lhs.doubleValue() * value);
+	}
+
+
+
+
+	public EDouble divide(EObject other) { return other.r_divide(value); }
+
+	public EDouble r_divide(int lhs) { 
+		return ERT.box(lhs / value);
+	}
+
+	public EDouble r_divide(double lhs) { 
+		return ERT.box(lhs / value);
+	}
+
+	public EDouble r_divide(BigInteger lhs) { 
+		return ERT.box(lhs.doubleValue() / value);
+	}
+
+	@Override
+	public double doubleValue() {
+		return value;
+	}
+
+	/* (non-Javadoc)
+	 * @see erjang.ENumber#add(int)
+	 */
+	@Override
+	public ENumber add(int rhs) {
+		return ERT.box(value + rhs);
+	}
 
 }