1 files changed, 92 insertions, 127 deletions

diff --git a/src/jvm/clojure/lang/BigNum.java b/src/jvm/clojure/lang/BigNum.java
index 52fa5151..aaa862d1 100644
--- a/src/jvm/clojure/lang/BigNum.java
+++ b/src/jvm/clojure/lang/BigNum.java
@@ -17,204 +17,169 @@ import java.math.BigInteger;
 public class BigNum extends IntegerNum{
 public BigInteger val;
 
-public boolean equals(Object arg0)
-	{
+public boolean equals(Object arg0){
 	return arg0 != null
 	       && arg0 instanceof BigNum
 	       && ((BigNum) arg0).val == val;
-	}
+}
 
-public int hashCode()
-	{
+public int hashCode(){
 	return val.hashCode();
-	}
+}
 
-public String toString()
-	{
+public String toString(){
 	return val.toString();
-	}
+}
 
-public BigNum(long val)
-	{
+public BigNum(long val){
 	this.val = BigInteger.valueOf(val);
-	}
+}
 
-public BigNum(BigInteger val)
-	{
+public BigNum(BigInteger val){
 	this.val = val;
-	}
+}
 
-public double doubleValue()
-	{
+public double doubleValue(){
 	return val.doubleValue();
-	}
+}
 
-public float floatValue()
-	{
+public float floatValue(){
 	return val.floatValue();
-	}
+}
 
-public int intValue()
-	{
+public int intValue(){
 	return val.intValue();
-	}
+}
 
-public long longValue()
-	{
+public long longValue(){
 	return val.longValue();
-	}
+}
 
-public boolean equiv(Num rhs)
-	{
+public boolean equiv(Num rhs){
 	return rhs.equivTo(val);
-	}
+}
 
-public boolean equivTo(BigInteger x)
-	{
+public boolean equivTo(BigInteger x){
 	return x.equals(val);
-	}
+}
 
-public boolean equivTo(int x)
-	{
+public boolean equivTo(int x){
 	//must be outside of range of int or would be one itself
 	return false;
-	}
+}
 
-public boolean equivTo(RatioNum x)
-	{
+public boolean equivTo(RatioNum x){
 	//wouldn't still be a RatioNum if it was an integer
 	return false;
-	}
+}
 
-public boolean lt(Num rhs)
-	{
+public boolean lt(Num rhs){
 	return rhs.gt(val);
-	}
+}
 
-public boolean gt(BigInteger x)
-	{
+public boolean gt(BigInteger x){
 	return x.compareTo(val) < 0;
-	}
+}
 
-public boolean gt(int x)
-	{
+public boolean gt(int x){
 	return BigInteger.valueOf(x).compareTo(val) < 0;
-	}
+}
 
-public boolean gt(RatioNum x)
-	{
+public boolean gt(RatioNum x){
 	return x.numerator.lt(x.denominator.multiply(val));
-	}
+}
 
-public Num add(Num rhs)
-	{
+public Num add(Num rhs){
 	return rhs.addTo(val);
-	}
+}
 
-public Num addTo(BigInteger x)
-	{
+public Num addTo(BigInteger x){
 	return Num.from(x.add(val));
-	}
+}
 
-public Num addTo(int x)
-	{
+public Num addTo(int x){
 	return Num.from(val.add(BigInteger.valueOf(x)));
-	}
+}
 
-public Num addTo(RatioNum x)
-	{
+public Num addTo(RatioNum x){
 	return x.addTo(val);
-	}
+}
 
-public Num subtractFrom(Num x)
-	{
+public Num subtractFrom(Num x){
 	return x.addTo(val.negate());
-	}
+}
 
-public Num multiplyBy(Num rhs)
-	{
+public Num multiplyBy(Num rhs){
 	return rhs.multiply(val);
-	}
+}
 
-public Num multiply(BigInteger x)
-	{
+public Num multiply(BigInteger x){
 	return Num.from(x.multiply(val));
-	}
+}
 
-public Num multiply(int x)
-	{
+public Num multiply(int x){
 	return Num.from(val.multiply(BigInteger.valueOf(x)));
-	}
+}
 
-public Num multiply(RatioNum x)
-	{
+public Num multiply(RatioNum x){
 	return x.multiply(val);
-	}
+}
 
-public Num divideBy(Num rhs)
-	{
+public Num divideBy(Num rhs){
 	return rhs.divide(val);
-	}
+}
 
-public Num divide(BigInteger n)
-	{
+public Num divide(BigInteger n){
 	return Num.divide(n, val);
-	}
+}
 
-public Num divide(int n)
-	{
+public Num divide(int n){
 	return Num.divide(BigInteger.valueOf(n), val);
-	}
+}
 
-public Num divide(RatioNum x)
-	{
+public Num divide(RatioNum x){
 	return Num.divide(x.numerator, x.denominator.multiply(val));
-	}
-
-public Object truncateDivide( Num num)
-	{
-	return num.truncateBy( val);
-	}
-
-public Object truncateBy( int div)
-	{
-	return Num.truncateBigints( val, BigInteger.valueOf(div));
-	}
-
-public Object truncateBy( BigInteger div)
-	{
-	return Num.truncateBigints( val, div);
-	}
-
-public Object truncateBy( RatioNum div)
-	{
-	Num q = (Num) Num.truncate( div.denominator.multiply(val), div.numerator);
-	return RT.setValues( q, q.multiplyBy(div).subtractFrom(this));
-	}
-
-public Num negate()
-	{
+}
+
+public Object truncateDivide(Num num){
+	return num.truncateBy(val);
+}
+
+public Object truncateBy(int div){
+	return Num.truncateBigints(val, BigInteger.valueOf(div));
+}
+
+public Object truncateBy(BigInteger div){
+	return Num.truncateBigints(val, div);
+}
+
+public Object truncateBy(RatioNum div){
+	Num q = (Num) Num.truncate(div.denominator.multiply(val), div.numerator);
+	return RT.setValues(q, q.multiplyBy(div).subtractFrom(this));
+}
+
+public Num negate(){
 	return Num.from(val.negate());
-	}
+}
 
-public boolean minusp()
-	{
+public boolean minusp(){
 	return val.signum() < 0;
-	}
+}
 
-public boolean plusp()
-	{
+public boolean plusp(){
 	return val.signum() > 0;
-	}
+}
+
+public boolean zerop(){
+	return val.compareTo(BigInteger.ZERO) == 0;
+}
 
-public Num oneMinus()
-	{
+public Num oneMinus(){
 	return Num.from(val.subtract(BigInteger.ONE));
-	}
+}
 
-public Num onePlus()
-	{
+public Num onePlus(){
 	return Num.from(val.add(BigInteger.ONE));
-	}
+}
 }