/**

* Copyright (c) Rich Hickey. All rights reserved.

* The use and distribution terms for this software are covered by the

* Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)

* which can be found in the file epl-v10.html at the root of this distribution.

* By using this software in any fashion, you are agreeing to be bound by

* the terms of this license.

* You must not remove this notice, or any other, from this software.

**/

/* rich Mar 31, 2008 */

package clojure.lang;

import java.math.BigInteger;

import java.math.BigDecimal;

import java.math.MathContext;

public class Numbers{

static interface Ops{

Ops combine(Ops y);

Ops opsWith(LongOps x);

Ops opsWith(DoubleOps x);

Ops opsWith(RatioOps x);

Ops opsWith(BigIntOps x);

Ops opsWith(BigDecimalOps x);

public boolean isZero(Number x);

public boolean isPos(Number x);

public boolean isNeg(Number x);

public Number add(Number x, Number y);

public Number addP(Number x, Number y);

public Number unchecked_add(Number x, Number y);

public Number multiply(Number x, Number y);

public Number multiplyP(Number x, Number y);

public Number unchecked_multiply(Number x, Number y);

public Number divide(Number x, Number y);

public Number quotient(Number x, Number y);

public Number remainder(Number x, Number y);

public boolean equiv(Number x, Number y);

public boolean lt(Number x, Number y);

public boolean lte(Number x, Number y);

public boolean gte(Number x, Number y);

public Number negate(Number x);

public Number negateP(Number x);

public Number unchecked_negate(Number x);

public Number inc(Number x);

public Number incP(Number x);

public Number unchecked_inc(Number x);

public Number dec(Number x);

public Number decP(Number x);

public Number unchecked_dec(Number x);

public Number abs(Number x);

}

static abstract class OpsP implements Ops{

public Number addP(Number x, Number y){

return add(x, y);

}

public Number unchecked_add(Number x, Number y){

return add(x, y);

}

public Number multiplyP(Number x, Number y){

return multiply(x, y);

}

public Number unchecked_multiply(Number x, Number y){

return multiply(x, y);

}

public Number negateP(Number x){

return negate(x);

}

public Number unchecked_negate(Number x){

return negate(x);

}

public Number incP(Number x){

return inc(x);

}

public Number unchecked_inc(Number x){

return inc(x);

}

public Number decP(Number x){

return dec(x);

}

public Number unchecked_dec(Number x){

return dec(x);

}

}

static public boolean isZero(Object x){

return ops(x).isZero((Number)x);

}

static public boolean isPos(Object x){

return ops(x).isPos((Number)x);

}

static public boolean isNeg(Object x){

return ops(x).isNeg((Number)x);

}

static public Number minus(Object x){

return ops(x).negate((Number)x);

}

static public Number minusP(Object x){

return ops(x).negateP((Number)x);

}

static public Number inc(Object x){

return ops(x).inc((Number)x);

}

static public Number incP(Object x){

return ops(x).incP((Number)x);

}

static public Number dec(Object x){

return ops(x).dec((Number)x);

}

static public Number decP(Object x){

return ops(x).decP((Number)x);

}

static public Number add(Object x, Object y){

return ops(x).combine(ops(y)).add((Number)x, (Number)y);

}

static public Number addP(Object x, Object y){

return ops(x).combine(ops(y)).addP((Number)x, (Number)y);

}

static public Number minus(Object x, Object y){

Ops yops = ops(y);

return ops(x).combine(yops).add((Number)x, yops.negate((Number)y));

}

static public Number minusP(Object x, Object y){

Ops yops = ops(y);

Number negativeY = yops.negateP((Number) y);

Ops negativeYOps = ops(negativeY);

return ops(x).combine(negativeYOps).addP((Number)x, negativeY);

}

static public Number multiply(Object x, Object y){

return ops(x).combine(ops(y)).multiply((Number)x, (Number)y);

}

static public Number multiplyP(Object x, Object y){

return ops(x).combine(ops(y)).multiplyP((Number)x, (Number)y);

}

static public Number divide(Object x, Object y){

if (isNaN(x)){

return (Number)x;

} else if(isNaN(y)){

return (Number)y;

}

Ops yops = ops(y);

if(yops.isZero((Number)y))

throw new ArithmeticException("Divide by zero");

return ops(x).combine(yops).divide((Number)x, (Number)y);

}

static public Number quotient(Object x, Object y){

Ops yops = ops(y);

if(yops.isZero((Number) y))

throw new ArithmeticException("Divide by zero");

return ops(x).combine(yops).quotient((Number)x, (Number)y);

}

static public Number remainder(Object x, Object y){

Ops yops = ops(y);

if(yops.isZero((Number) y))

throw new ArithmeticException("Divide by zero");

return ops(x).combine(yops).remainder((Number)x, (Number)y);

}

static public double quotient(double n, double d){

if(d == 0)

throw new ArithmeticException("Divide by zero");

double q = n / d;

if(q <= Long.MAX_VALUE && q >= Long.MIN_VALUE)

{

return (double)(long) q;

}

else

{ //bigint quotient

return new BigDecimal(q).toBigInteger().doubleValue();

}

}

static public double remainder(double n, double d){

if(d == 0)

throw new ArithmeticException("Divide by zero");

double q = n / d;

if(q <= Long.MAX_VALUE && q >= Long.MIN_VALUE)

{

return (n - ((long) q) * d);

}

else

{ //bigint quotient

Number bq = new BigDecimal(q).toBigInteger();

return (n - bq.doubleValue() * d);

}

}

static public boolean equiv(Object x, Object y){

return equiv((Number) x, (Number) y);

}

static public boolean equiv(Number x, Number y){

return ops(x).combine(ops(y)).equiv(x, y);

}

static public boolean equal(Number x, Number y){

return category(x) == category(y)

&& ops(x).combine(ops(y)).equiv(x, y);

}

static public boolean lt(Object x, Object y){

return ops(x).combine(ops(y)).lt((Number)x, (Number)y);

}

static public boolean lte(Object x, Object y){

return ops(x).combine(ops(y)).lte((Number)x, (Number)y);

}

static public boolean gt(Object x, Object y){

return ops(x).combine(ops(y)).lt((Number)y, (Number)x);

}

static public boolean gte(Object x, Object y){

return ops(x).combine(ops(y)).gte((Number)x, (Number)y);

}

static public int compare(Number x, Number y){

Ops ops = ops(x).combine(ops(y));

if(ops.lt(x, y))

return -1;

else if(ops.lt(y, x))

return 1;

return 0;

}

@WarnBoxedMath(false)

static BigInt toBigInt(Object x){

if(x instanceof BigInt)

return (BigInt) x;

if(x instanceof BigInteger)

return BigInt.fromBigInteger((BigInteger) x);

else

return BigInt.fromLong(((Number) x).longValue());

}

@WarnBoxedMath(false)

static BigInteger toBigInteger(Object x){

if(x instanceof BigInteger)

return (BigInteger) x;

else if(x instanceof BigInt)

return ((BigInt) x).toBigInteger();

else

return BigInteger.valueOf(((Number) x).longValue());

}

@WarnBoxedMath(false)

static BigDecimal toBigDecimal(Object x){

if(x instanceof BigDecimal)

return (BigDecimal) x;

else if(x instanceof BigInt)

{

BigInt bi = (BigInt) x;

if(bi.bipart == null)

return BigDecimal.valueOf(bi.lpart);

else

return new BigDecimal(bi.bipart);

}

else if(x instanceof BigInteger)

return new BigDecimal((BigInteger) x);

else if(x instanceof Double)

return new BigDecimal(((Number) x).doubleValue());

else if(x instanceof Float)

return new BigDecimal(((Number) x).doubleValue());

else if(x instanceof Ratio)

{

Ratio r = (Ratio)x;

return (BigDecimal)divide(new BigDecimal(r.numerator), r.denominator);

}

else

return BigDecimal.valueOf(((Number) x).longValue());

}

@WarnBoxedMath(false)

static public Ratio toRatio(Object x){

if(x instanceof Ratio)

return (Ratio) x;

else if(x instanceof BigDecimal)

{

BigDecimal bx = (BigDecimal) x;

BigInteger bv = bx.unscaledValue();

int scale = bx.scale();

if(scale < 0)

return new Ratio(bv.multiply(BigInteger.TEN.pow(-scale)), BigInteger.ONE);

else

return new Ratio(bv, BigInteger.TEN.pow(scale));

}

return new Ratio(toBigInteger(x), BigInteger.ONE);

}

@WarnBoxedMath(false)

static public Number rationalize(Number x){

if(x instanceof Float || x instanceof Double)

return rationalize(BigDecimal.valueOf(x.doubleValue()));

else if(x instanceof BigDecimal)

{

BigDecimal bx = (BigDecimal) x;

BigInteger bv = bx.unscaledValue();

int scale = bx.scale();

if(scale < 0)

return BigInt.fromBigInteger(bv.multiply(BigInteger.TEN.pow(-scale)));

else

return divide(bv, BigInteger.TEN.pow(scale));

}

return x;

}

//static Number box(int val){

// return Integer.valueOf(val);

//}

//static Number box(long val){

// return Long.valueOf(val);

//}

//

//static Double box(double val){

// return Double.valueOf(val);

//}

//

//static Double box(float val){

// return Double.valueOf((double) val);

//}

@WarnBoxedMath(false)

static public Number reduceBigInt(BigInt val){

if(val.bipart == null)

return num(val.lpart);

else

return val.bipart;

}

static public Number divide(BigInteger n, BigInteger d){

if(d.equals(BigInteger.ZERO))

throw new ArithmeticException("Divide by zero");

BigInteger gcd = n.gcd(d);

if(gcd.equals(BigInteger.ZERO))

return BigInt.ZERO;

n = n.divide(gcd);

d = d.divide(gcd);

if(d.equals(BigInteger.ONE))

return BigInt.fromBigInteger(n);

else if(d.equals(BigInteger.ONE.negate()))

return BigInt.fromBigInteger(n.negate());

return new Ratio((d.signum() < 0 ? n.negate() : n),

(d.signum() < 0 ? d.negate() : d));

}

static public int shiftLeftInt(int x, int n){

return x << n;

}

static public long shiftLeft(Object x, Object y){

return shiftLeft(bitOpsCast(x),bitOpsCast(y));

}

static public long shiftLeft(Object x, long y){

return shiftLeft(bitOpsCast(x),y);

}

static public long shiftLeft(long x, Object y){

return shiftLeft(x,bitOpsCast(y));

}

static public long shiftLeft(long x, long n){

return x << n;

}

static public int shiftRightInt(int x, int n){

return x >> n;

}

static public long shiftRight(Object x, Object y){

return shiftRight(bitOpsCast(x),bitOpsCast(y));

}

static public long shiftRight(Object x, long y){

return shiftRight(bitOpsCast(x),y);

}

static public long shiftRight(long x, Object y){

return shiftRight(x,bitOpsCast(y));

}

static public long shiftRight(long x, long n){

return x >> n;

}

static public int unsignedShiftRightInt(int x, int n){

return x >>> n;

}

static public long unsignedShiftRight(Object x, Object y){

return unsignedShiftRight(bitOpsCast(x),bitOpsCast(y));

}

static public long unsignedShiftRight(Object x, long y){

return unsignedShiftRight(bitOpsCast(x),y);

}

static public long unsignedShiftRight(long x, Object y){

return unsignedShiftRight(x,bitOpsCast(y));

}

static public long unsignedShiftRight(long x, long n){

return x >>> n;

}

final static class LongOps implements Ops{

public Ops combine(Ops y){

return y.opsWith(this);

}

final public Ops opsWith(LongOps x){

return this;

}

final public Ops opsWith(DoubleOps x){

return DOUBLE_OPS;

}

final public Ops opsWith(RatioOps x){

return RATIO_OPS;

}

final public Ops opsWith(BigIntOps x){

return BIGINT_OPS;

}

final public Ops opsWith(BigDecimalOps x){

return BIGDECIMAL_OPS;

}

public boolean isZero(Number x){

return x.longValue() == 0;

}

public boolean isPos(Number x){

return x.longValue() > 0;

}

public boolean isNeg(Number x){

return x.longValue() < 0;

}

final public Number add(Number x, Number y){

return num(Numbers.add(x.longValue(),y.longValue()));

}

final public Number addP(Number x, Number y){

long lx = x.longValue(), ly = y.longValue();

long ret = lx + ly;

if ((ret ^ lx) < 0 && (ret ^ ly) < 0)

return BIGINT_OPS.add(x, y);

return num(ret);

}

final public Number unchecked_add(Number x, Number y){

return num(Numbers.unchecked_add(x.longValue(), y.longValue()));

}

final public Number multiply(Number x, Number y){

return num(Numbers.multiply(x.longValue(), y.longValue()));

}

final public Number multiplyP(Number x, Number y){

long lx = x.longValue(), ly = y.longValue();

if (lx == Long.MIN_VALUE && ly < 0)

return BIGINT_OPS.multiply(x, y);

long ret = lx * ly;

if (ly != 0 && ret/ly != lx)

return BIGINT_OPS.multiply(x, y);

return num(ret);

}

final public Number unchecked_multiply(Number x, Number y){

return num(Numbers.unchecked_multiply(x.longValue(), y.longValue()));

}

static long gcd(long u, long v){

while(v != 0)

{

long r = u % v;

u = v;

v = r;

}

return u;

}

public Number divide(Number x, Number y){

long n = x.longValue();

long val = y.longValue();

if(n == Long.MIN_VALUE || val == Long.MIN_VALUE)

return BIGINT_OPS.divide(x, y);

long gcd = gcd(n, val);

if(gcd == 0)

return num(0);

n = n / gcd;

long d = val / gcd;

if(d == 1)

return num(n);

if(d < 0)

{

n = -n;

d = -d;

}

return new Ratio(BigInteger.valueOf(n), BigInteger.valueOf(d));

}

public Number quotient(Number x, Number y){

return num(x.longValue() / y.longValue());

}

public Number remainder(Number x, Number y){

return num(x.longValue() % y.longValue());

}

public boolean equiv(Number x, Number y){

return x.longValue() == y.longValue();

}

public boolean lt(Number x, Number y){

return x.longValue() < y.longValue();

}

public boolean lte(Number x, Number y){

return x.longValue() <= y.longValue();

}

public boolean gte(Number x, Number y){

return x.longValue() >= y.longValue();

}

//public Number subtract(Number x, Number y);

final public Number negate(Number x){

long val = x.longValue();

return num(Numbers.minus(val));

}

final public Number negateP(Number x){

long val = x.longValue();

if(val > Long.MIN_VALUE)

return num(-val);

return BigInt.fromBigInteger(BigInteger.valueOf(val).negate());

}

final public Number unchecked_negate(Number x){

long val = x.longValue();

return num(Numbers.unchecked_minus(val));

}

public Number inc(Number x){

long val = x.longValue();

return num(Numbers.inc(val));

}

public Number incP(Number x){

long val = x.longValue();

if(val < Long.MAX_VALUE)

return num(val + 1);

return BIGINT_OPS.inc(x);

}

public Number unchecked_inc(Number x){

long val = x.longValue();

return num(Numbers.unchecked_inc(val));

}

public Number dec(Number x){

long val = x.longValue();

return num(Numbers.dec(val));

}

public Number decP(Number x){

long val = x.longValue();

if(val > Long.MIN_VALUE)

return num(val - 1);

return BIGINT_OPS.dec(x);

}

public Number unchecked_dec(Number x){

long val = x.longValue();

return num(Numbers.unchecked_dec(val));

}

public Number abs(Number x){

return num(Math.abs(x.longValue()));

}

}

final static class DoubleOps extends OpsP{

public Ops combine(Ops y){

return y.opsWith(this);

}

final public Ops opsWith(LongOps x){

return this;

}

final public Ops opsWith(DoubleOps x){

return this;

}

final public Ops opsWith(RatioOps x){

return this;

}

final public Ops opsWith(BigIntOps x){

return this;

}

final public Ops opsWith(BigDecimalOps x){

return this;

}

public boolean isZero(Number x){

return x.doubleValue() == 0;

}

public boolean isPos(Number x){

return x.doubleValue() > 0;

}

public boolean isNeg(Number x){

return x.doubleValue() < 0;

}

final public Number add(Number x, Number y){

return Double.valueOf(x.doubleValue() + y.doubleValue());

}

final public Number multiply(Number x, Number y){

return Double.valueOf(x.doubleValue() * y.doubleValue());

}

public Number divide(Number x, Number y){

return Double.valueOf(x.doubleValue() / y.doubleValue());

}

public Number quotient(Number x, Number y){

return Numbers.quotient(x.doubleValue(), y.doubleValue());

}

public Number remainder(Number x, Number y){

return Numbers.remainder(x.doubleValue(), y.doubleValue());

}

public boolean equiv(Number x, Number y){

return x.doubleValue() == y.doubleValue();

}

public boolean lt(Number x, Number y){

return x.doubleValue() < y.doubleValue();

}

public boolean lte(Number x, Number y){

return x.doubleValue() <= y.doubleValue();

}

public boolean gte(Number x, Number y){

return x.doubleValue() >= y.doubleValue();

}

//public Number subtract(Number x, Number y);

final public Number negate(Number x){

return Double.valueOf(-x.doubleValue());

}

public Number inc(Number x){

return Double.valueOf(x.doubleValue() + 1);

}

public Number dec(Number x){

return Double.valueOf(x.doubleValue() - 1);

}

public Number abs(Number x) {

return num(Math.abs(x.doubleValue()));

}

}

final static class RatioOps extends OpsP{

public Ops combine(Ops y){

return y.opsWith(this);

}

final public Ops opsWith(LongOps x){

return this;

}

final public Ops opsWith(DoubleOps x){

return DOUBLE_OPS;

}

final public Ops opsWith(RatioOps x){

return this;

}

final public Ops opsWith(BigIntOps x){

return this;

}

final public Ops opsWith(BigDecimalOps x){

return BIGDECIMAL_OPS;

}

public boolean isZero(Number x){

Ratio r = (Ratio) x;

return r.numerator.signum() == 0;

}

public boolean isPos(Number x){

Ratio r = (Ratio) x;

return r.numerator.signum() > 0;

}

public boolean isNeg(Number x){

Ratio r = (Ratio) x;

return r.numerator.signum() < 0;

}

static Number normalizeRet(Number ret, Number x, Number y){

// if(ret instanceof BigInteger && !(x instanceof BigInteger || y instanceof BigInteger))

// {

// return reduceBigInt((BigInteger) ret);

// }

return ret;

}

final public Number add(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

Number ret = divide(ry.numerator.multiply(rx.denominator)

.add(rx.numerator.multiply(ry.denominator))

, ry.denominator.multiply(rx.denominator));

return normalizeRet(ret, x, y);

}

final public Number multiply(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

Number ret = Numbers.divide(ry.numerator.multiply(rx.numerator)

, ry.denominator.multiply(rx.denominator));

return normalizeRet(ret, x, y);

}

public Number divide(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

Number ret = Numbers.divide(ry.denominator.multiply(rx.numerator)

, ry.numerator.multiply(rx.denominator));

return normalizeRet(ret, x, y);

}

public Number quotient(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

BigInteger q = rx.numerator.multiply(ry.denominator).divide(

rx.denominator.multiply(ry.numerator));

return normalizeRet(BigInt.fromBigInteger(q), x, y);

}

public Number remainder(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

BigInteger q = rx.numerator.multiply(ry.denominator).divide(

rx.denominator.multiply(ry.numerator));

Number ret = Numbers.minus(x, Numbers.multiply(q, y));

return normalizeRet(ret, x, y);

}

public boolean equiv(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

return rx.numerator.equals(ry.numerator)

&& rx.denominator.equals(ry.denominator);

}

public boolean lt(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

return Numbers.lt(rx.numerator.multiply(ry.denominator), ry.numerator.multiply(rx.denominator));

}

public boolean lte(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

return Numbers.lte(rx.numerator.multiply(ry.denominator), ry.numerator.multiply(rx.denominator));

}

public boolean gte(Number x, Number y){

Ratio rx = toRatio(x);

Ratio ry = toRatio(y);

return Numbers.gte(rx.numerator.multiply(ry.denominator), ry.numerator.multiply(rx.denominator));

}

//public Number subtract(Number x, Number y);

final public Number negate(Number x){

Ratio r = (Ratio) x;

return new Ratio(r.numerator.negate(), r.denominator);

}

public Number inc(Number x){

return Numbers.add(x, 1);

}

public Number dec(Number x){

return Numbers.add(x, -1);

}

public Number abs(Number x) {

Ratio r = (Ratio) x;

return new Ratio(r.numerator.abs(), r.denominator);

}

}

final static class BigIntOps extends OpsP{

public Ops combine(Ops y){

return y.opsWith(this);

}

final public Ops opsWith(LongOps x){

return this;

}

final public Ops opsWith(DoubleOps x){

return DOUBLE_OPS;

}

final public Ops opsWith(RatioOps x){

return RATIO_OPS;

}

final public Ops opsWith(BigIntOps x){

return this;

}

final public Ops opsWith(BigDecimalOps x){

return BIGDECIMAL_OPS;

}

public boolean isZero(Number x){

BigInt bx = toBigInt(x);

if(bx.bipart == null)

return bx.lpart == 0;

return bx.bipart.signum() == 0;

}

public boolean isPos(Number x){

BigInt bx = toBigInt(x);

if(bx.bipart == null)

return bx.lpart > 0;

return bx.bipart.signum() > 0;

}

public boolean isNeg(Number x){

BigInt bx = toBigInt(x);

if(bx.bipart == null)

return bx.lpart < 0;

return bx.bipart.signum() < 0;

}

final public Number add(Number x, Number y){

return toBigInt(x).add(toBigInt(y));

}

final public Number multiply(Number x, Number y){

return toBigInt(x).multiply(toBigInt(y));

}

public Number divide(Number x, Number y){

return Numbers.divide(toBigInteger(x), toBigInteger(y));

}

public Number quotient(Number x, Number y){

return toBigInt(x).quotient(toBigInt(y));

}

public Number remainder(Number x, Number y){

return toBigInt(x).remainder(toBigInt(y));

}

public boolean equiv(Number x, Number y){

return toBigInt(x).equals(toBigInt(y));

}

public boolean lt(Number x, Number y){

return toBigInt(x).lt(toBigInt(y));

}

public boolean lte(Number x, Number y){

return toBigInteger(x).compareTo(toBigInteger(y)) <= 0;

}

public boolean gte(Number x, Number y){

return toBigInteger(x).compareTo(toBigInteger(y)) >= 0;

}

//public Number subtract(Number x, Number y);

final public Number negate(Number x){

return BigInt.fromBigInteger(toBigInteger(x).negate());

}

public Number inc(Number x){

BigInteger bx = toBigInteger(x);

return BigInt.fromBigInteger(bx.add(BigInteger.ONE));

}

public Number dec(Number x){

BigInteger bx = toBigInteger(x);

return BigInt.fromBigInteger(bx.subtract(BigInteger.ONE));

}

public Number abs(Number x) {

return BigInt.fromBigInteger(toBigInteger(x).abs());

}

}

final static class BigDecimalOps extends OpsP{

final static Var MATH_CONTEXT = RT.MATH_CONTEXT;

public Ops combine(Ops y){

return y.opsWith(this);

}

final public Ops opsWith(LongOps x){

return this;

}

final public Ops opsWith(DoubleOps x){

return DOUBLE_OPS;

}

final public Ops opsWith(RatioOps x){

return this;

}

final public Ops opsWith(BigIntOps x){

return this;

}

final public Ops opsWith(BigDecimalOps x){

return this;

}

public boolean isZero(Number x){

BigDecimal bx = (BigDecimal) x;

return bx.signum() == 0;

}

public boolean isPos(Number x){

BigDecimal bx = (BigDecimal) x;

return bx.signum() > 0;

}