reformat

2 files changed, 333 insertions, 218 deletions

diff --git a/src/org/clojure/runtime/DoubleNum.java b/src/org/clojure/runtime/DoubleNum.java
index 4ecbe376..00ec7c7a 100644
--- a/src/org/clojure/runtime/DoubleNum.java
+++ b/src/org/clojure/runtime/DoubleNum.java
@@ -15,166 +15,230 @@ package org.clojure.runtime;
 import java.math.BigInteger;
 import java.math.BigDecimal;
 
-public class DoubleNum extends FloatNum {
-	double val;
-	public DoubleNum(double val){
-		this.val = val;
+public class DoubleNum extends FloatNum{
+double val;
+
+public DoubleNum(double val)
+	{
+	this.val = val;
 	}
 
-	public double doubleValue() {
-		return val;
+public double doubleValue()
+	{
+	return val;
 	}
-	public float floatValue() {
-		return (float)val;
+
+public float floatValue()
+	{
+	return (float) val;
 	}
-	public int intValue() {
-		return (int)val;
+
+public int intValue()
+	{
+	return (int) val;
 	}
-	public long longValue() {
-		return (long)val;
+
+public long longValue()
+	{
+	return (long) val;
 	}
 
-	final static BigInteger BIGTEN = BigInteger.valueOf(10);
+final static BigInteger BIGTEN = BigInteger.valueOf(10);
 
-	public Num toRational(){
-	    BigDecimal d = new BigDecimal(val);
-	    return Num.divide(d.unscaledValue(),BIGTEN.pow(d.scale()));
+public Num toRational()
+	{
+	BigDecimal d = new BigDecimal(val);
+	return Num.divide(d.unscaledValue(), BIGTEN.pow(d.scale()));
 	}
 
-	public boolean equiv(Num rhs) {
-	    if(rhs instanceof RatioNum)
-	        return equivTo((RatioNum)rhs);
-		return val == rhs.doubleValue();
+public boolean equiv(Num rhs)
+	{
+	if(rhs instanceof RatioNum)
+		return equivTo((RatioNum) rhs);
+	return val == rhs.doubleValue();
 	}
-	public boolean equivTo(BigInteger x) {
-		return val == x.doubleValue();
+
+public boolean equivTo(BigInteger x)
+	{
+	return val == x.doubleValue();
 	}
-	public boolean equivTo(int x) {
-		return x == val;
+
+public boolean equivTo(int x)
+	{
+	return x == val;
 	}
-	public boolean equivTo(RatioNum x) {
-		return toRational().equivTo(x);
+
+public boolean equivTo(RatioNum x)
+	{
+	return toRational().equivTo(x);
 	}
 
-	public boolean lt(Num rhs)
-		{
-	    if(rhs instanceof RatioNum)
-	        return toRational().lt(rhs);
-		return val < rhs.doubleValue();
+public boolean lt(Num rhs)
+	{
+	if(rhs instanceof RatioNum)
+		return toRational().lt(rhs);
+	return val < rhs.doubleValue();
 	}
-	public boolean gt(BigInteger x)
-		{
-		return val > x.doubleValue();
+
+public boolean gt(BigInteger x)
+	{
+	return val > x.doubleValue();
 	}
-	public boolean gt(int x)
-		{
-		return val > x;
+
+public boolean gt(int x)
+	{
+	return val > x;
 	}
-	public boolean gt(RatioNum x)
-		{
-		return toRational().gt(x);
+
+public boolean gt(RatioNum x)
+	{
+	return toRational().gt(x);
 	}
 
-	public Num add(Num rhs){
-		return Num.from(val + rhs.doubleValue());
+public Num add(Num rhs)
+	{
+	return Num.from(val + rhs.doubleValue());
 	}
-	public Num addTo(int x){
-		return Num.from(val + x);
+
+public Num addTo(int x)
+	{
+	return Num.from(val + x);
 	}
-	public Num addTo(BigInteger x){
-		return Num.from(val + x.doubleValue());
+
+public Num addTo(BigInteger x)
+	{
+	return Num.from(val + x.doubleValue());
 	}
-	public Num addTo(RatioNum x){
-		return Num.from(val + x.doubleValue());
+
+public Num addTo(RatioNum x)
+	{
+	return Num.from(val + x.doubleValue());
 	}
 
-	public Num subtractFrom(Num x){
-		return Num.from(x.doubleValue() - val);
+public Num subtractFrom(Num x)
+	{
+	return Num.from(x.doubleValue() - val);
 	}
 
-	public Num multiplyBy(Num rhs){
-		return Num.from(val * rhs.doubleValue());
+public Num multiplyBy(Num rhs)
+	{
+	return Num.from(val * rhs.doubleValue());
 	}
-	public Num multiply(int x){
-		return Num.from(val * x);
+
+public Num multiply(int x)
+	{
+	return Num.from(val * x);
 	}
-	public Num multiply(BigInteger x){
-		return Num.from(val * x.doubleValue());
+
+public Num multiply(BigInteger x)
+	{
+	return Num.from(val * x.doubleValue());
 	}
-	public Num multiply(RatioNum x){
-		return Num.from(val * x.doubleValue());
+
+public Num multiply(RatioNum x)
+	{
+	return Num.from(val * x.doubleValue());
 	}
 
-	public Num divideBy(Num rhs){
-		return Num.from(val / rhs.doubleValue());
+public Num divideBy(Num rhs)
+	{
+	return Num.from(val / rhs.doubleValue());
 	}
-	public Num divide(int x){
-		return Num.from(x/val);
+
+public Num divide(int x)
+	{
+	return Num.from(x / val);
 	}
-	public Num divide(BigInteger x){
-		return Num.from(x.doubleValue()/val);
+
+public Num divide(BigInteger x)
+	{
+	return Num.from(x.doubleValue() / val);
 	}
-	public Num divide(RatioNum x){
-		return Num.from(x.doubleValue()/val);
+
+public Num divide(RatioNum x)
+	{
+	return Num.from(x.doubleValue() / val);
 	}
 
-	static Object truncate(ThreadLocalData tld, double n, double d){
-	    double q = n/d;
-		if(q <= Integer.MAX_VALUE && q >= Integer.MIN_VALUE){
-		    return RT.setValues(tld,Num.from((int)q),
-		                      Num.from(n - ((int)q)*d));
+static Object truncate(ThreadLocalData tld, double n, double d)
+	{
+	double q = n / d;
+	if(q <= Integer.MAX_VALUE && q >= Integer.MIN_VALUE)
+		{
+		return RT.setValues(tld, Num.from((int) q),
+		                    Num.from(n - ((int) q) * d));
 		}
-		else{ //bigint quotient
-		    Num bq = Num.from(new BigDecimal(q).toBigInteger());
-		    return RT.setValues(tld,bq,
-		                      Num.from(n - bq.doubleValue()*d));
+	else
+		{ //bigint quotient
+		Num bq = Num.from(new BigDecimal(q).toBigInteger());
+		return RT.setValues(tld, bq,
+		                    Num.from(n - bq.doubleValue() * d));
 		}
 	}
 
-    public Object truncateBy(ThreadLocalData tld, BigInteger x) {
-        return truncate(tld, val,x.doubleValue());
-    }
-    public Object truncateBy(ThreadLocalData tld, int x) {
-        return truncate(tld, val,x);
-    }
-    public Object truncateBy(ThreadLocalData tld, RatioNum x) {
-        return truncate(tld, val,x.doubleValue());
-    }
-    public Object truncateDivide(ThreadLocalData tld, Num num) {
-        return truncate(tld, num.doubleValue(),val);
-    }
-	public Num negate(){
-		return Num.from(-val);
-	}
-
-	public boolean equals(Object arg0) {
-		return arg0 != null
-		       && arg0 instanceof DoubleNum
-		       && Double.doubleToLongBits(((DoubleNum)arg0).val) ==
-		          Double.doubleToLongBits(val);
-	}
-	public int hashCode() {
-		 long v = Double.doubleToLongBits(val);
-		 return (int)(v^(v>>>32));
-	}
-
-	public String toString() {
-		return Double.toString(val);
-	}
-    public boolean minusp() {
-        return val < 0;
-    }
-    public boolean plusp() {
-        return val > 0;
-    }
-
-    public Num oneMinus() {
-        return Num.from(val - 1);
-    }
-
-    public Num onePlus() {
-        return Num.from(val + 1);
-    }
+public Object truncateBy(ThreadLocalData tld, BigInteger x)
+	{
+	return truncate(tld, val, x.doubleValue());
+	}
+
+public Object truncateBy(ThreadLocalData tld, int x)
+	{
+	return truncate(tld, val, x);
+	}
+
+public Object truncateBy(ThreadLocalData tld, RatioNum x)
+	{
+	return truncate(tld, val, x.doubleValue());
+	}
+
+public Object truncateDivide(ThreadLocalData tld, Num num)
+	{
+	return truncate(tld, num.doubleValue(), val);
+	}
+
+public Num negate()
+	{
+	return Num.from(-val);
+	}
+
+public boolean equals(Object arg0)
+	{
+	return arg0 != null
+	       && arg0 instanceof DoubleNum
+	       && Double.doubleToLongBits(((DoubleNum) arg0).val) ==
+	          Double.doubleToLongBits(val);
+	}
+
+public int hashCode()
+	{
+	long v = Double.doubleToLongBits(val);
+	return (int) (v ^ (v >>> 32));
+	}
+
+public String toString()
+	{
+	return Double.toString(val);
+	}
+
+public boolean minusp()
+	{
+	return val < 0;
+	}
+
+public boolean plusp()
+	{
+	return val > 0;
+	}
+
+public Num oneMinus()
+	{
+	return Num.from(val - 1);
+	}
+
+public Num onePlus()
+	{
+	return Num.from(val + 1);
+	}
 
 }
 
diff --git a/src/org/clojure/runtime/RatioNum.java b/src/org/clojure/runtime/RatioNum.java
index 40bdf926..32e8d2a6 100644
--- a/src/org/clojure/runtime/RatioNum.java
+++ b/src/org/clojure/runtime/RatioNum.java
@@ -14,162 +14,213 @@ package org.clojure.runtime;
 
 import java.math.BigInteger;
 
-public class RatioNum extends Rational {
-	public boolean equals(Object arg0) {
-		return arg0 != null
-		       && arg0 instanceof RatioNum
-		       && ((RatioNum)arg0).numerator.equals(numerator)
-		       && ((RatioNum)arg0).denominator.equals(denominator);
+public class RatioNum extends Rational{
+public boolean equals(Object arg0)
+	{
+	return arg0 != null
+	       && arg0 instanceof RatioNum
+	       && ((RatioNum) arg0).numerator.equals(numerator)
+	       && ((RatioNum) arg0).denominator.equals(denominator);
 	}
 
-	public int hashCode() {
-		return numerator.hashCode() ^ denominator.hashCode();
+public int hashCode()
+	{
+	return numerator.hashCode() ^ denominator.hashCode();
 	}
 
-	public String toString() {
-		return numerator.toString() + "/" + denominator.toString();
+public String toString()
+	{
+	return numerator.toString() + "/" + denominator.toString();
 	}
 
-	public IntegerNum numerator;
-	public IntegerNum denominator;
+public IntegerNum numerator;
+public IntegerNum denominator;
 
-	public RatioNum(IntegerNum n,IntegerNum d){
-		this.numerator = n;
-		this.denominator = d;
+public RatioNum(IntegerNum n, IntegerNum d)
+	{
+	this.numerator = n;
+	this.denominator = d;
 	}
 
-	public double doubleValue() {
-		return numerator.doubleValue()/denominator.doubleValue();
+public double doubleValue()
+	{
+	return numerator.doubleValue() / denominator.doubleValue();
 	}
-	public float floatValue() {
-		return (float)doubleValue();
+
+public float floatValue()
+	{
+	return (float) doubleValue();
 	}
-	public int intValue() {
-		return (int)doubleValue();
+
+public int intValue()
+	{
+	return (int) doubleValue();
 	}
-	public long longValue() {
-		return (long)doubleValue();
+
+public long longValue()
+	{
+	return (long) doubleValue();
 	}
 
-	public boolean equiv(Num rhs)  {
-		return rhs.equivTo(this);
+public boolean equiv(Num rhs)
+	{
+	return rhs.equivTo(this);
 	}
-	public boolean equivTo(BigInteger x)  {
-		return false;
+
+public boolean equivTo(BigInteger x)
+	{
+	return false;
 	}
-	public boolean equivTo(int x)  {
-		return false;
+
+public boolean equivTo(int x)
+	{
+	return false;
 	}
-	public boolean equivTo(RatioNum x) {
-		return numerator.equiv(x.numerator) && denominator.equiv(x.denominator);
+
+public boolean equivTo(RatioNum x)
+	{
+	return numerator.equiv(x.numerator) && denominator.equiv(x.denominator);
 	}
 
-	public boolean lt(Num rhs)
-		{
-		return rhs.gt(this);
+public boolean lt(Num rhs)
+	{
+	return rhs.gt(this);
 	}
-	public boolean gt(BigInteger x)
-		{
-		return denominator.multiply(x).lt(numerator);
+
+public boolean gt(BigInteger x)
+	{
+	return denominator.multiply(x).lt(numerator);
 	}
-	public boolean gt(int x)
-		{
-		return denominator.multiply(x).lt(numerator);
+
+public boolean gt(int x)
+	{
+	return denominator.multiply(x).lt(numerator);
 	}
-	public boolean gt(RatioNum x)
-		{
-		return x.numerator.multiplyBy(denominator).lt(numerator.multiplyBy(x.denominator));
+
+public boolean gt(RatioNum x)
+	{
+	return x.numerator.multiplyBy(denominator).lt(numerator.multiplyBy(x.denominator));
 	}
 
-	public Num add(Num rhs) {
-		return rhs.addTo(this);
+public Num add(Num rhs)
+	{
+	return rhs.addTo(this);
 	}
 
-	public Num addTo(BigInteger x) {
-		return Num.divide(numerator.add(denominator.multiply(x)),denominator);
+public Num addTo(BigInteger x)
+	{
+	return Num.divide(numerator.add(denominator.multiply(x)), denominator);
 	}
-	public Num addTo(int x) {
-		return Num.divide(numerator.add(denominator.multiply(x)),denominator);
+
+public Num addTo(int x)
+	{
+	return Num.divide(numerator.add(denominator.multiply(x)), denominator);
 	}
-	public Num addTo(RatioNum x) {
-		return Num.divide(numerator.multiplyBy(x.denominator)
-									.add(x.numerator.multiplyBy(denominator))
-				,denominator.multiplyBy(x.denominator));
+
+public Num addTo(RatioNum x)
+	{
+	return Num.divide(numerator.multiplyBy(x.denominator)
+			.add(x.numerator.multiplyBy(denominator))
+			, denominator.multiplyBy(x.denominator));
 	}
 
-	public Num subtractFrom(Num x) {
-		return x.add(this.multiply(-1));
+public Num subtractFrom(Num x)
+	{
+	return x.add(this.multiply(-1));
 	}
 
-	public Num multiplyBy(Num rhs) {
-		return rhs.multiply(this);
+public Num multiplyBy(Num rhs)
+	{
+	return rhs.multiply(this);
 	}
 
-	public Num multiply(BigInteger x) {
-		return Num.divide(numerator.multiply(x),denominator);
+public Num multiply(BigInteger x)
+	{
+	return Num.divide(numerator.multiply(x), denominator);
 	}
-	public Num multiply(int x) {
-		return Num.divide(numerator.multiply(x),denominator);
+
+public Num multiply(int x)
+	{
+	return Num.divide(numerator.multiply(x), denominator);
 	}
-	public Num multiply(RatioNum x) {
-		return Num.divide(numerator.multiplyBy(x.numerator)
-				,denominator.multiplyBy(x.denominator));
+
+public Num multiply(RatioNum x)
+	{
+	return Num.divide(numerator.multiplyBy(x.numerator)
+			, denominator.multiplyBy(x.denominator));
 	}
 
-	public Num divideBy(Num rhs) {
-		return rhs.divide(this);
+public Num divideBy(Num rhs)
+	{
+	return rhs.divide(this);
 	}
 
-	public Num divide(BigInteger n) {
-		return Num.divide(denominator.multiply(n),numerator);
+public Num divide(BigInteger n)
+	{
+	return Num.divide(denominator.multiply(n), numerator);
 	}
-	public Num divide(int n) {
-		return Num.divide(denominator.multiply(n),numerator);
+
+public Num divide(int n)
+	{
+	return Num.divide(denominator.multiply(n), numerator);
 	}
-	public Num divide(RatioNum n) {
-		return Num.divide(denominator.multiplyBy(n.numerator)
-				,numerator.multiplyBy(n.denominator));
+
+public Num divide(RatioNum n)
+	{
+	return Num.divide(denominator.multiplyBy(n.numerator)
+			, numerator.multiplyBy(n.denominator));
 	}
 
 
-	public Object truncateDivide(ThreadLocalData tld, Num num) {
-		return num.truncateBy(tld, this);
+public Object truncateDivide(ThreadLocalData tld, Num num)
+	{
+	return num.truncateBy(tld, this);
+	}
+
+public Object truncateBy(ThreadLocalData tld, int div)
+	{
+	Num q = (Num) Num.truncate(tld, numerator, denominator.multiply(div));
+	return RT.setValues(tld, q, q.multiply(div).subtractFrom(this));
 	}
 
-	public Object truncateBy(ThreadLocalData tld, int div) {
-	    Num q =  (Num)Num.truncate(tld, numerator,denominator.multiply(div));
-	    return RT.setValues(tld,q,q.multiply(div).subtractFrom(this));
+public Object truncateBy(ThreadLocalData tld, BigInteger div)
+	{
+	Num q = (Num) Num.truncate(tld, numerator, denominator.multiply(div));
+	return RT.setValues(tld, q, q.multiply(div).subtractFrom(this));
 	}
 
-	public Object truncateBy(ThreadLocalData tld, BigInteger div) {
-	    Num q =  (Num)Num.truncate(tld, numerator,denominator.multiply(div));
-	    return RT.setValues(tld,q,q.multiply(div).subtractFrom(this));
+public Object truncateBy(ThreadLocalData tld, RatioNum div)
+	{
+	Num q = (Num) Num.truncate(tld, numerator.multiplyBy(div.denominator),
+	                           denominator.multiplyBy(div.numerator));
+	return RT.setValues(tld, q, q.multiplyBy(div).subtractFrom(this));
 	}
 
-	public Object truncateBy(ThreadLocalData tld, RatioNum div) {
-	    Num q =  (Num)Num.truncate(tld, numerator.multiplyBy(div.denominator),
-	                                                    denominator.multiplyBy(div.numerator));
-	    return RT.setValues(tld,q,q.multiplyBy(div).subtractFrom(this));
+
+public Num negate()
+	{
+	return Num.divide(numerator.negate(), denominator);
 	}
 
+public boolean minusp()
+	{
+	return numerator.minusp();
+	}
 
-	public Num negate(){
-		return Num.divide(numerator.negate(),denominator);
+public boolean plusp()
+	{
+	return numerator.plusp();
 	}
 
-    public boolean minusp() {
-        return numerator.minusp();
-    }
-    public boolean plusp() {
-        return numerator.plusp();
-    }
+public Num oneMinus()
+	{
+	return addTo(-1);
+	}
 
-    public Num oneMinus() {
-        return addTo(-1);
-    }
-    public Num onePlus() {
-        return addTo(1);
-    }
+public Num onePlus()
+	{
+	return addTo(1);
+	}
 
 }