added Comparable, removed exception declarations

3 files changed, 187 insertions, 123 deletions

diff --git a/src/org/clojure/runtime/DoubleNum.java b/src/org/clojure/runtime/DoubleNum.java
index 3bbdc5bd..4ecbe376 100644
--- a/src/org/clojure/runtime/DoubleNum.java
+++ b/src/org/clojure/runtime/DoubleNum.java
@@ -56,18 +56,22 @@ public class DoubleNum extends FloatNum {
 		return toRational().equivTo(x);
 	}
 
-	public boolean lt(Num rhs) throws Exception {
+	public boolean lt(Num rhs)
+		{
 	    if(rhs instanceof RatioNum)
 	        return toRational().lt(rhs);
 		return val < rhs.doubleValue();
 	}
-	public boolean gt(BigInteger x) throws Exception {
+	public boolean gt(BigInteger x)
+		{
 		return val > x.doubleValue();
 	}
-	public boolean gt(int x) throws Exception {
+	public boolean gt(int x)
+		{
 		return val > x;
 	}
-	public boolean gt(RatioNum x) throws Exception {
+	public boolean gt(RatioNum x)
+		{
 		return toRational().gt(x);
 	}
 
@@ -139,7 +143,7 @@ public class DoubleNum extends FloatNum {
     public Object truncateDivide(ThreadLocalData tld, Num num) {
         return truncate(tld, num.doubleValue(),val);
     }
-	public Num negate() throws Exception{
+	public Num negate(){
 		return Num.from(-val);
 	}
 
diff --git a/src/org/clojure/runtime/Num.java b/src/org/clojure/runtime/Num.java
index 688fb0b4..182955e2 100644
--- a/src/org/clojure/runtime/Num.java
+++ b/src/org/clojure/runtime/Num.java
@@ -14,151 +14,207 @@ package org.clojure.runtime;
 
 import java.math.BigInteger;
 
-public abstract class Num extends Number {
-
-	public final static Num ZERO = from(0);
-	public final static Num ONE = from(1);
-
-	static public Num from(int val){
-		//todo - cache a bunch of small fixnums
-		return new FixNum(val);
+public abstract class Num extends Number implements Comparable{
+
+public final static Num ZERO = from(0);
+public final static Num ONE = from(1);
+
+static public Num from(int val)
+	{
+	//todo - cache a bunch of small fixnums
+	return new FixNum(val);
+	}
+
+static public Num from(double val)
+	{
+	return new DoubleNum(val);
+	}
+
+static public Num from(long val)
+	{
+	if(val <= Integer.MAX_VALUE && val >= Integer.MIN_VALUE)
+		return from((int) val);
+	else
+		return new BigNum(val);
+	}
+
+static public Num from(BigInteger val)
+	{
+	if(val.bitLength() < 32)
+		return from(val.intValue());
+	else
+		return new BigNum(val);
+	}
+
+static public Num from(Object x)
+	{
+	if(x instanceof Num)
+		return (Num) x;
+	else
+		{
+		Class c = x.getClass();
+		if(c == Integer.class)
+			return Num.from(((Integer) x).intValue());
+		else if(c == Double.class || c == Float.class)
+			return Num.from(((Number) x).doubleValue());
+		else if(c == Long.class)
+			return Num.from(((Long) x).longValue());
+		else if(c == BigInteger.class)
+			return Num.from((BigInteger) x);
+		else
+			return Num.from(((Number) x).intValue());
+		}
 	}
 
-	static public Num from(double val){
-		return new DoubleNum(val);
+static public Num add(Object x, Object y)
+	{
+	//if(x instanceof Num && y instanceof Num)
+	//return ((Num)x).add((Num) y);
+	return Num.from(x).add(Num.from(y));
 	}
 
-	static public Num from(long val){
-		if(val <= Integer.MAX_VALUE && val >= Integer.MIN_VALUE)
-			return from((int)val);
-		else
-			return new BigNum(val);
-	}
+abstract public Num add(Num rhs);
 
-	static public Num from(BigInteger val){
-		if(val.bitLength() < 32)
-			return from(val.intValue());
-		else
-			return new BigNum(val);
-	}
-
-	static public Num from(Object x){
-		if(x instanceof Num)
-			return (Num)x;
-		else{
-			Class c = x.getClass();
-			if(c == Integer.class)
-				return Num.from(((Integer)x).intValue());
-			else if(c == Double.class || c == Float.class)
-				return Num.from(((Number)x).doubleValue());
-			else if(c == Long.class)
-				return Num.from(((Long)x).longValue());
-			else if(c == BigInteger.class)
-				return Num.from((BigInteger)x);
-			else
-				return Num.from(((Number)x).intValue());
-		}
-	}
+abstract public Num addTo(int x);
 
-	static public Num add(Object x,Object y){
-		//if(x instanceof Num && y instanceof Num)
-			//return ((Num)x).add((Num) y);
-			return Num.from(x).add(Num.from(y));
-	}
-	abstract public Num add(Num rhs);
-	abstract public Num addTo(int x);
-	abstract public Num addTo(BigInteger x);
-	abstract public Num addTo(RatioNum x);
+abstract public Num addTo(BigInteger x);
+
+abstract public Num addTo(RatioNum x);
 
-	static public Num subtract(Object x,Object y){
-		return Num.from(y).subtractFrom(Num.from(x));
+static public Num subtract(Object x, Object y)
+	{
+	return Num.from(y).subtractFrom(Num.from(x));
 	}
-	//this double-dispatches to addTo(-self)
-	abstract public Num subtractFrom(Num rhs);
 
-	static public Num multiply(Object x,Object y) {
-		return Num.from(x).multiplyBy(Num.from(y));
+//this double-dispatches to addTo(-self)
+abstract public Num subtractFrom(Num rhs);
+
+static public Num multiply(Object x, Object y)
+	{
+	return Num.from(x).multiplyBy(Num.from(y));
 	}
-	abstract public Num multiplyBy(Num rhs);
-	abstract public Num multiply(int x);
-	abstract public Num multiply(BigInteger x);
-	abstract public Num multiply(RatioNum x);
 
-	static public Num divide(Object x,Object y){
-		return Num.from(x).divideBy(Num.from(y));
+abstract public Num multiplyBy(Num rhs);
+
+abstract public Num multiply(int x);
+
+abstract public Num multiply(BigInteger x);
+
+abstract public Num multiply(RatioNum x);
+
+static public Num divide(Object x, Object y)
+	{
+	return Num.from(x).divideBy(Num.from(y));
 	}
 
-	abstract public Num divideBy(Num rhs);
-	abstract public Num divide(int x);
-	abstract public Num divide(BigInteger x);
-	abstract public Num divide(RatioNum x);
+abstract public Num divideBy(Num rhs);
+
+abstract public Num divide(int x);
+
+abstract public Num divide(BigInteger x);
 
-	static public Object truncate(ThreadLocalData tld, Object num, Object div) {
-		return Num.from(div).truncateDivide(tld, Num.from(num));
+abstract public Num divide(RatioNum x);
+
+static public Object truncate(ThreadLocalData tld, Object num, Object div)
+	{
+	return Num.from(div).truncateDivide(tld, Num.from(num));
 	}
 
-	abstract public Object truncateDivide(ThreadLocalData tld, Num rhs) ;
-	abstract public Object truncateBy(ThreadLocalData tld, int x) ;
-	abstract public Object truncateBy(ThreadLocalData tld, BigInteger x) ;
-	abstract public Object truncateBy(ThreadLocalData tld, RatioNum x) ;
+abstract public Object truncateDivide(ThreadLocalData tld, Num rhs);
+
+abstract public Object truncateBy(ThreadLocalData tld, int x);
+
+abstract public Object truncateBy(ThreadLocalData tld, BigInteger x);
 
-	static public Object truncateBigints(ThreadLocalData tld, BigInteger n, BigInteger d){
-	    BigInteger[] result = n.divideAndRemainder(d);
-	    return RT.setValues(tld,Num.from(result[0]),Num.from(result[1]));
+abstract public Object truncateBy(ThreadLocalData tld, RatioNum x);
+
+static public Object truncateBigints(ThreadLocalData tld, BigInteger n, BigInteger d)
+	{
+	BigInteger[] result = n.divideAndRemainder(d);
+	return RT.setValues(tld, Num.from(result[0]), Num.from(result[1]));
 	}
 
-	static public Num divide(BigInteger n,BigInteger d) {
-		BigInteger gcd = n.gcd(d);
-		if(gcd.equals(BigInteger.ZERO))
-			return Num.ZERO;
-		n = n.divide(gcd);
-		d = d.divide(gcd);
-		if(d.equals(BigInteger.ONE))
-			return Num.from(n);
-		return new RatioNum((IntegerNum)Num.from(d.signum() < 0 ? n.negate():n),
-		                    (IntegerNum)Num.from(d.signum() < 0 ? d.negate():d));
+static public Num divide(BigInteger n, BigInteger d)
+	{
+	BigInteger gcd = n.gcd(d);
+	if(gcd.equals(BigInteger.ZERO))
+		return Num.ZERO;
+	n = n.divide(gcd);
+	d = d.divide(gcd);
+	if(d.equals(BigInteger.ONE))
+		return Num.from(n);
+	return new RatioNum((IntegerNum) Num.from(d.signum() < 0 ? n.negate() : n),
+	                    (IntegerNum) Num.from(d.signum() < 0 ? d.negate() : d));
 	}
 
-	static public boolean equiv(Object x,Object y) throws Exception{
-		return Num.from(x).equiv(Num.from(y));
+static public boolean equiv(Object x, Object y)
+	{
+	return Num.from(x).equiv(Num.from(y));
 	}
-	abstract public boolean equiv(Num rhs) ;
-	abstract public boolean equivTo(int x) ;
-	abstract public boolean equivTo(BigInteger x) ;
-	abstract public boolean equivTo(RatioNum x) ;
 
-	static public boolean lt(Object x,Object y) throws Exception{
-		return Num.from(x).lt(Num.from(y));
+abstract public boolean equiv(Num rhs);
+
+abstract public boolean equivTo(int x);
+
+abstract public boolean equivTo(BigInteger x);
+
+abstract public boolean equivTo(RatioNum x);
+
+static public boolean lt(Object x, Object y)
+	{
+	return Num.from(x).lt(Num.from(y));
 	}
-	static public boolean lte(Object x,Object y) throws Exception{
-		Num lx = Num.from(x);
-		Num ly = Num.from(y);
-		return lx.lt(ly) || lx.equiv(ly);
+
+static public boolean lte(Object x, Object y)
+	{
+	Num lx = Num.from(x);
+	Num ly = Num.from(y);
+	return lx.lt(ly) || lx.equiv(ly);
 	}
 
-	static public boolean gt(Object x,Object y) throws Exception{
-		return Num.from(y).lt(Num.from(x));
+static public boolean gt(Object x, Object y)
+	{
+	return Num.from(y).lt(Num.from(x));
 	}
 
-	static public boolean gte(Object x,Object y) throws Exception{
-		Num lx = Num.from(x);
-		Num ly = Num.from(y);
-		return ly.lt(lx) || lx.equiv(ly);
+static public boolean gte(Object x, Object y)
+	{
+	Num lx = Num.from(x);
+	Num ly = Num.from(y);
+	return ly.lt(lx) || lx.equiv(ly);
 	}
 
-	abstract public boolean lt(Num rhs) throws Exception;
-	abstract public boolean gt(int x) throws Exception;
-	abstract public boolean gt(BigInteger x) throws Exception;
-	abstract public boolean gt(RatioNum x) throws Exception;
+abstract public boolean lt(Num rhs);
 
-	static public Num negate(Object x) throws Exception{
-		return Num.from(x).negate();
+abstract public boolean gt(int x);
+
+abstract public boolean gt(BigInteger x);
+
+abstract public boolean gt(RatioNum x);
+
+static public Num negate(Object x)
+	{
+	return Num.from(x).negate();
 	}
-	abstract public Num negate() throws Exception;
 
-	abstract public boolean minusp();
-	abstract public boolean plusp();
-	abstract public Num oneMinus();
-	abstract public Num onePlus();
+abstract public Num negate();
+
+abstract public boolean minusp();
 
+abstract public boolean plusp();
+
+abstract public Num oneMinus();
+
+abstract public Num onePlus();
+
+public int compareTo(Object object)
+	{
+	Num other = Num.from(object);
+	if(this.equiv(other))
+		return 0;
+	else if(this.lt(other))
+		return -1;
+	else
+		return 1;
+	}
 }
diff --git a/src/org/clojure/runtime/RatioNum.java b/src/org/clojure/runtime/RatioNum.java
index d30c9d99..40bdf926 100644
--- a/src/org/clojure/runtime/RatioNum.java
+++ b/src/org/clojure/runtime/RatioNum.java
@@ -64,16 +64,20 @@ public class RatioNum extends Rational {
 		return numerator.equiv(x.numerator) && denominator.equiv(x.denominator);
 	}
 
-	public boolean lt(Num rhs) throws Exception {
+	public boolean lt(Num rhs)
+		{
 		return rhs.gt(this);
 	}
-	public boolean gt(BigInteger x) throws Exception {
+	public boolean gt(BigInteger x)
+		{
 		return denominator.multiply(x).lt(numerator);
 	}
-	public boolean gt(int x) throws Exception {
+	public boolean gt(int x)
+		{
 		return denominator.multiply(x).lt(numerator);
 	}
-	public boolean gt(RatioNum x) throws Exception {
+	public boolean gt(RatioNum x)
+		{
 		return x.numerator.multiplyBy(denominator).lt(numerator.multiplyBy(x.denominator));
 	}
 
@@ -149,7 +153,7 @@ public class RatioNum extends Rational {
 	}
 
 
-	public Num negate() throws Exception{
+	public Num negate(){
 		return Num.divide(numerator.negate(),denominator);
 	}