Data commit

Task/Arithmetic-Rational/Groovy/arithmetic-rational-1.groovy

@@ -0,0 +1,117 @@
+class Rational extends Number 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)]
+    }
+
+    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.class:              return this
+            case [Boolean, Boolean.TYPE]: return asBoolean()
+            case BigDecimal:              return toBigDecimal()
+            case BigInteger:              return toBigInteger()
+            case [Double, Double.TYPE]:   return toDouble()
+            case [Float, Float.TYPE]:     return toFloat()
+            case [Integer, Integer.TYPE]: return toInteger()
+            case [Long, Long.TYPE]:       return toLong()
+            case String:                  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}"
+    }
+}

Task/Arithmetic-Rational/Groovy/arithmetic-rational-2.groovy

@@ -0,0 +1,14 @@
+import org.codehaus.groovy.runtime.DefaultGroovyMethods
+
+class RationalCategory {
+    static Rational plus (Number a, Rational b) { ([a] as Rational) + b }
+    static Rational minus (Number a, Rational b) { ([a] as Rational) - b }
+    static Rational multiply (Number a, Rational b) { ([a] as Rational) * b }
+    static Rational div (Number a, Rational b) { ([a] as Rational) / b  }
+
+    static <T> T asType (Number a, Class<T> type) {
+        type == Rational \
+            ? [a] as Rational
+                : DefaultGroovyMethods.asType(a, type)
+    }
+}

Task/Arithmetic-Rational/Groovy/arithmetic-rational-3.groovy

@@ -0,0 +1,87 @@
+Number.metaClass.mixin RationalCategory
+
+def x = [5, 20] as Rational
+def y = [9, 12] as Rational
+def z = [0, 10000] as Rational
+
+println x
+println y
+println z
+println (x <=> y)
+println (x.compareTo(y))
+assert x < y
+assert x*3 == y
+assert x*5.5 == 5.5*x
+assert (z + 1) <= y*4
+assert x + 1.3 == 1.3 + x
+assert 24 - y == -(y - 24)
+assert 3 / y == (y / 3).reciprocal()
+assert x != y
+
+println "x + y == ${x} + ${y} == ${x + y}"
+println "x + z == ${x} + ${z} == ${x + z}"
+println "x - y == ${x} - ${y} == ${x - y}"
+println "x - z == ${x} - ${z} == ${x - z}"
+println "x * y == ${x} * ${y} == ${x * y}"
+println "y ** 3 == ${y} ** 3 == ${y ** 3}"
+println "y ** -3 == ${y} ** -3 == ${y ** -3}"
+println "x * z == ${x} * ${z} == ${x * z}"
+println "x / y == ${x} / ${y} == ${x / y}"
+try { print "x / z == ${x} / ${z} == "; println "${x / z}" }
+catch (Throwable t) { println t.message }
+
+println "-x == -${x} == ${-x}"
+println "-y == -${y} == ${-y}"
+println "-z == -${z} == ${-z}"
+
+print "x as int == ${x} as int == "; println x.intValue()
+print "x as double == ${x} as double == "; println x.doubleValue()
+print "1 / x as int == 1 / ${x} as int == "; println x.reciprocal().intValue()
+print "1.0 / x == 1.0 / ${x} == "; println x.reciprocal().doubleValue()
+print "y as int == ${y} as int == "; println y.intValue()
+print "y as double == ${y} as double == "; println y.doubleValue()
+print "1 / y as int == 1 / ${y} as int == "; println y.reciprocal().intValue()
+print "1.0 / y == 1.0 / ${y} == "; println y.reciprocal().doubleValue()
+print "z as int == ${z} as int == "; println z.intValue()
+print "z as double == ${z} as double == "; println z.doubleValue()
+try { print "1 / z as int == 1 / ${z} as int == "; println z.reciprocal().intValue() }
+catch (Throwable t) { println t.message }
+try { print "1.0 / z == 1.0 / ${z} == "; println z.reciprocal().doubleValue() }
+catch (Throwable t) { println t.message }
+
+println "++x == ++ ${x} == ${++x}"
+println "++y == ++ ${y} == ${++y}"
+println "++z == ++ ${z} == ${++z}"
+println "-- --x == -- -- ${x} == ${-- (--x)}"
+println "-- --y == -- -- ${y} == ${-- (--y)}"
+println "-- --z == -- -- ${z} == ${-- (--z)}"
+println x
+println y
+println z
+
+println (x <=> y)
+assert x*3 == y
+assert (z + 1) <= y*4
+assert (x < y)
+
+println 25 as Rational
+println 25.0 as Rational
+println 0.25 as Rational
+
+def ε = 0.000000001  // tolerance (epsilon): acceptable "wrongness" to account for rounding error
+
+def π = Math.PI
+def α = π as Rational
+assert (π - (α as BigDecimal)).abs() < ε
+println π
+println α
+println (α.toBigDecimal())
+println (α as BigDecimal)
+println (α as Double)
+println (α as double)
+println (α as boolean)
+println (z as boolean)
+try { println (α as Date) }
+catch (Throwable t) { println t.message }
+try { println (α as char) }
+catch (Throwable t) { println t.message }

Task/Arithmetic-Rational/Groovy/arithmetic-rational-4.groovy

@@ -0,0 +1,25 @@
+Number.metaClass.mixin RationalCategory
+
+def factorize = { target ->
+    assert target > 0
+    if (target == 1L) { return [1L] }
+    if ([2L, 3L].contains(target)) { return [1L, target] }
+    def targetSqrt = Math.sqrt(target)
+    def lowFactors = (2L..targetSqrt).findAll { (target % it) == 0 }
+
+    if (!lowFactors) { return [1L, target] }
+    def highFactors = lowFactors[-1..0].findResults { target.intdiv(it) } - lowFactors[-1]
+
+    return [1L] + lowFactors + highFactors + [target]
+}
+
+def perfect = {
+    def factors = factorize(it)
+    2 as Rational == factors.sum{ factor -> new Rational(1, factor) } \
+        ? [perfect: it, factors: factors]
+        : null
+}
+
+def trackProgress = { if ((it % (100*1000)) == 0) { println it } else if ((it % 1000) == 0) { print "." } }
+
+(1..(2**19)).findResults { trackProgress(it); perfect(it) }.each { println(); print it }