117 lines
4.0 KiB
Groovy
117 lines
4.0 KiB
Groovy
class Rational implements Comparable {
|
|
final BigInteger num, denom
|
|
|
|
static final Rational ONE = new Rational(1)
|
|
static final Rational ZERO = new Rational(0)
|
|
|
|
Rational(BigDecimal decimal) {
|
|
this(
|
|
decimal.scale() < 0 ? decimal.unscaledValue()*10**(-decimal.scale()) : decimal.unscaledValue(),
|
|
decimal.scale() < 0 ? 1 : 10**(decimal.scale()))
|
|
}
|
|
|
|
Rational(BigInteger n, BigInteger d = 1) {
|
|
if (!d || n == null) { n/d }
|
|
(num, denom) = reduce(n, d)
|
|
}
|
|
|
|
private List reduce(BigInteger n, BigInteger d) {
|
|
BigInteger sign = ((n < 0) != (d < 0)) ? -1 : 1
|
|
(n, d) = [n.abs(), d.abs()]
|
|
BigInteger commonFactor = gcd(n, d)
|
|
|
|
[n.intdiv(commonFactor) * sign, d.intdiv(commonFactor)]
|
|
}
|
|
|
|
public Rational toLeastTerms() { reduce(num, denom) as Rational }
|
|
|
|
private BigInteger gcd(BigInteger n, BigInteger m) {
|
|
n == 0 ? m : { while(m%n != 0) { (n, m) = [m%n, n] }; n }()
|
|
}
|
|
|
|
Rational plus(Rational r) { [num*r.denom + r.num*denom, denom*r.denom] }
|
|
Rational plus(BigInteger n) { [num + n*denom, denom] }
|
|
Rational plus(Number n) { this + ([n] as Rational) }
|
|
|
|
Rational next() { [num + denom, denom] }
|
|
|
|
Rational minus(Rational r) { [num*r.denom - r.num*denom, denom*r.denom] }
|
|
Rational minus(BigInteger n) { [num - n*denom, denom] }
|
|
Rational minus(Number n) { this - ([n] as Rational) }
|
|
|
|
Rational previous() { [num - denom, denom] }
|
|
|
|
Rational multiply(Rational r) { [num*r.num, denom*r.denom] }
|
|
Rational multiply(BigInteger n) { [num*n, denom] }
|
|
Rational multiply(Number n) { this * ([n] as Rational) }
|
|
|
|
|
|
Rational div(Rational r) { new Rational(num*r.denom, denom*r.num) }
|
|
Rational div(BigInteger n) { new Rational(num, denom*n) }
|
|
Rational div(Number n) { this / ([n] as Rational) }
|
|
|
|
BigInteger intdiv(BigInteger n) { num.intdiv(denom*n) }
|
|
|
|
Rational negative() { [-num, denom] }
|
|
|
|
Rational abs() { [num.abs(), denom] }
|
|
|
|
Rational reciprocal() { new Rational(denom, num) }
|
|
|
|
Rational power(BigInteger n) {
|
|
def (nu, de) = (n < 0 ? [denom, num] : [num, denom])*.power(n.abs())
|
|
new Rational (nu, de)
|
|
}
|
|
|
|
boolean asBoolean() { num != 0 }
|
|
|
|
BigDecimal toBigDecimal() { (num as BigDecimal)/(denom as BigDecimal) }
|
|
|
|
BigInteger toBigInteger() { num.intdiv(denom) }
|
|
|
|
Double toDouble() { toBigDecimal().toDouble() }
|
|
double doubleValue() { toDouble() as double }
|
|
|
|
Float toFloat() { toBigDecimal().toFloat() }
|
|
float floatValue() { toFloat() as float }
|
|
|
|
Integer toInteger() { toBigInteger().toInteger() }
|
|
int intValue() { toInteger() as int }
|
|
|
|
Long toLong() { toBigInteger().toLong() }
|
|
long longValue() { toLong() as long }
|
|
|
|
Object asType(Class type) {
|
|
switch (type) {
|
|
case this.getClass(): return this
|
|
case [Boolean.class,Boolean.TYPE]: return asBoolean()
|
|
case BigDecimal.class: return toBigDecimal()
|
|
case BigInteger.class: return toBigInteger()
|
|
case [Double.class,Double.TYPE]: return toDouble()
|
|
case [Float.class,Float.TYPE]: return toFloat()
|
|
case [Integer.class,Integer.TYPE]: return toInteger()
|
|
case [Long.class,Long.TYPE]: return toLong()
|
|
case String.class: return toString()
|
|
default: throw new ClassCastException("Cannot convert from type Rational to type " + type)
|
|
}
|
|
}
|
|
|
|
boolean equals(o) { compareTo(o) == 0 }
|
|
|
|
int compareTo(o) {
|
|
o instanceof Rational \
|
|
? compareTo(o as Rational) \
|
|
: o instanceof Number \
|
|
? compareTo(o as Number)\
|
|
: (Double.NaN as int)
|
|
}
|
|
int compareTo(Rational r) { num*r.denom <=> denom*r.num }
|
|
int compareTo(Number n) { num <=> denom*(n as BigInteger) }
|
|
|
|
int hashCode() { [num, denom].hashCode() }
|
|
|
|
String toString() {
|
|
"${num}//${denom}"
|
|
}
|
|
}
|