feat: Implement subtypes

This should eventually be moved into typed-function itself, but for
  now it can be implemented on top of the existing typed-function.

  Uses subtypes to define (and error-check) gcd and lcm, which are only
  defined for integer arguments.

  Resolves #36.

src/bigint/divide.mjs

@@ -1,20 +1,12 @@
 export * from './Types/bigint.mjs'
 
 export const divide = {
-   'bigint,bigint': ({config, 'sign(bigint)': sgn}) => {
+   'bigint,bigint': ({config, 'quotient(bigint,bigint)': quot}) => {
-      if (config.predictable) {
+      if (config.predictable) return quot
       return (n, d) => {
-            if (sgn(n) === sgn(d)) return n/d
+         const q = n/d
-            const quot = n/d
+         if (q * d == n) return q
-            if (quot * d == n) return quot
-            return quot - 1n
-         }
-      } else {
-         return (n, d) => {
-            const quot = n/d
-            if (quot * d == n) return quot
          return undefined
       }
    }
-   }
 }

src/bigint/isZero.mjs

@@ -0,0 +1,3 @@
+export * from './Types/bigint.mjs'
+
+export const isZero = {bigint: () => b => b === 0n}

src/bigint/multiply.mjs

@@ -1,5 +1,3 @@
 export * from './Types/bigint.mjs'
 
-export const multiply = {
+export const multiply = {'bigint,bigint': () => (a,b) => a*b}
-   '...bigint': () => multiplicands => multiplicands.reduce((x,y) => x*y, 1n)
-}

src/bigint/native.mjs

@@ -1,9 +1,16 @@
+import gcdType from '../generic/gcdType.mjs'
+
 export * from './Types/bigint.mjs'
+
 export {add} from './add.mjs'
 export {divide} from './divide.mjs'
+export const gcd = gcdType('bigint')
+export {isZero} from './isZero.mjs'
 export {multiply} from './multiply.mjs'
 export {negate} from './negate.mjs'
 export {one} from './one.mjs'
 export {sign} from './sign.mjs'
+export {quotient} from './quotient.mjs'
+export {roundquotient} from './roundquotient.mjs'
 export {sqrt} from './sqrt.mjs'
 export {zero} from './zero.mjs'

src/bigint/quotient.mjs

@@ -0,0 +1,13 @@
+export * from './Types/bigint.mjs'
+
+/* Returns the best integer approximation to n/d */
+export const quotient = {
+   'bigint,bigint': ({'sign(bigint)': sgn}) => (n, d) => {
+      const dSgn = sgn(d)
+      if (dSgn === 0n) return 0n
+      if (sgn(n) === dSgn) return n/d
+      const quot = n/d
+      if (quot * d == n) return quot
+      return quot - 1n
+   }
+}

src/bigint/roundquotient.mjs

@@ -0,0 +1,15 @@
+export * from './Types/bigint.mjs'
+
+/* Returns the closest integer approximation to n/d */
+export const roundquotient = {
+   'bigint,bigint': ({'sign(bigint)': sgn}) => (n, d) => {
+      const dSgn = sgn(d)
+      if (dSgn === 0n) return 0n
+      const candidate = n/d
+      const rem = n - d*candidate
+      const absd = d*dSgn
+      if (2n * rem > absd) return candidate + dSgn
+      if (-2n * rem >= absd) return candidate - dSgn
+      return candidate
+   }
+}

src/complex/Types/Complex.mjs

@@ -12,9 +12,19 @@ const Complex = new PocomathInstance('Complex')
 Complex.installType('Complex', {
    test: isComplex,
    from: {
-      number: x => ({re: x, im: 0}),
+      number: x => ({re: x, im: 0})
+   }
+})
+Complex.installType('GaussianInteger', {
+   test: z => typeof z.re == 'bigint' && typeof z.im == 'bigint',
+   refines: 'Complex',
+   from: {
       bigint: x => ({re: x, im: 0n})
    }
 })
 
+Complex.promoteUnary = {
+   Complex: ({self,complex}) => z => complex(self(z.re), self(z.im))
+}
+
 export {Complex}

src/complex/abs.mjs

@@ -1,5 +1,5 @@
 export * from './Types/Complex.mjs'
 
-export const abs = {Complex: ({sqrt, add, multiply}) => z => {
+export const abs = {
-    return sqrt(add(multiply(z.re, z.re), multiply(z.im, z.im)))
+    Complex: ({sqrt, 'absquare(Complex)': absq}) => z => sqrt(absq(z))
-}}
+}

src/complex/absquare.mjs

@@ -0,0 +1,5 @@
+export * from './Types/Complex.mjs'
+
+export const absquare = {
+   Complex: ({add, square}) => z => add(square(z.re), square(z.im))
+}

src/complex/conjugate.mjs

@@ -0,0 +1,6 @@
+export * from './Types/Complex.mjs'
+
+export const conjugate = {
+   Complex: ({negate, complex}) => z => complex(z.re, negate(z.im))
+}
+

src/complex/gcd.mjs

@@ -0,0 +1,17 @@
+import PocomathInstance from '../core/PocomathInstance.mjs'
+import * as Complex from './Types/Complex.mjs'
+import gcdType from '../generic/gcdType.mjs'
+
+const imps = {
+   gcdComplexRaw: gcdType('Complex'),
+   gcd: { // Only return gcds with positive real part
+      'Complex, Complex': ({gcdComplexRaw, sign, one, negate}) => (z,m) => {
+         const raw = gcdComplexRaw(z, m)
+         if (sign(raw.re) === one(raw.re)) return raw
+         return negate(raw)
+      }
+   }
+}
+
+export const gcd = PocomathInstance.merge(Complex, imps)
+

src/complex/isZero.mjs

@@ -0,0 +1,5 @@
+export * from './Types/Complex.mjs'
+
+export const isZero = {
+   Complex: ({self}) => z => self(z.re) && self(z.im)
+}

src/complex/multiply.mjs

@@ -0,0 +1,14 @@
+export * from './Types/Complex.mjs'
+
+export const multiply = {
+   'Complex,Complex': ({
+      'complex(any,any)': cplx,
+      add,
+      subtract,
+      self
+   }) => (w,z) => {
+      return cplx(
+         subtract(self(w.re, z.re), self(w.im, z.im)),
+         add(self(w.re, z.im), self(w.im, z.re)))
+   }
+}

src/complex/native.mjs

@@ -1,8 +1,18 @@
+import gcdType from '../generic/gcdType.mjs'
+
 export * from './Types/Complex.mjs'
 
 export {abs} from './abs.mjs'
+export {absquare} from './absquare.mjs'
 export {add} from './add.mjs'
+export {conjugate} from './conjugate.mjs'
 export {complex} from './complex.mjs'
+export {gcd} from './gcd.mjs'
+export {isZero} from './isZero.mjs'
+export {multiply} from './multiply.mjs'
 export {negate} from './negate.mjs'
+export {quotient} from './quotient.mjs'
+export {roundquotient} from './roundquotient.mjs'
 export {sqrt} from './sqrt.mjs'
+export {zero} from './zero.mjs'
 

src/complex/negate.mjs

@@ -1,5 +1,5 @@
-export * from './Types/Complex.mjs'
+import {Complex} from './Types/Complex.mjs'
 
-export const negate = {
+const negate = Complex.promoteUnary
-   Complex: ({self}) => z => ({re: self(z.re), im: self(z.im)})
+
-}
+export {Complex, negate}

src/complex/quotient.mjs

@@ -0,0 +1,5 @@
+export * from './roundquotient.mjs'
+
+export const quotient = {
+   'Complex,Complex': ({roundquotient}) => (w,z) => roundquotient(w,z)
+}

src/complex/roundquotient.mjs

@@ -0,0 +1,17 @@
+export * from './Types/Complex.mjs'
+
+export const roundquotient = {
+   'Complex,Complex': ({
+      'isZero(Complex)': isZ,
+      conjugate,
+      'multiply(Complex,Complex)': mult,
+      absquare,
+      self,
+      complex
+   }) => (n,d) => {
+      if (isZ(d)) return d
+      const cnum = mult(n, conjugate(d))
+      const dreal = absquare(d)
+      return complex(self(cnum.re, dreal), self(cnum.im, dreal))
+   }
+}

src/complex/zero.mjs

@@ -0,0 +1,5 @@
+import {Complex} from './Types/Complex.mjs'
+
+const zero = Complex.promoteUnary
+
+export {Complex, zero}

src/core/PocomathInstance.mjs

@@ -27,6 +27,7 @@ export default class PocomathInstance {
       this._typed = typed.create()
       this._typed.clear()
       this.Types = {any: anySpec} // dummy entry to track the default 'any' type
+      this._subtypes = {} // For each type, gives all of its (in)direct subtypes
       this._usedTypes = new Set() // all types that have occurred in a signature
       this._doomed = new Set() // for detecting circular reference
       this._config = {predictable: false}
@@ -190,6 +191,9 @@ export default class PocomathInstance {
     *        **to** this type to the corresponding conversion functions
     *    - before: [optional] a list of types this should be added
     *        before, in priority order
+    *    - refines: [optional] the name of a type that this is a subtype
+    *        of. This means the test is the conjunction of the given test and
+    *        the supertype test, and that it must come before the supertype.
     */
    /*
     * Implementation note: unlike _installFunctions below, we can make
@@ -202,29 +206,68 @@ export default class PocomathInstance {
          }
          return
       }
-      let beforeType = 'any'
+      if (spec.refines && !(spec.refines in this.Types)) {
+         throw new SyntaxError(
+            `Cannot install ${type} before its supertype ${spec.refines}`)
+      }
+      let beforeType = spec.refines
+      if (!beforeType) {
+         beforeType = 'any'
          for (const other of spec.before || []) {
             if (other in this.Types) {
                beforeType = other
                break
             }
          }
-      this._typed.addTypes([{name: type, test: spec.test}], beforeType)
+      }
+      let testFn = spec.test
+      if (spec.refines) {
+         const supertypeTest = this.Types[spec.refines].test
+         testFn = entity => supertypeTest(entity) && spec.test(entity)
+      }
+      this._typed.addTypes([{name: type, test: testFn}], beforeType)
+      this.Types[type] = spec
       /* Now add conversions to this type */
       for (const from in (spec.from || {})) {
          if (from in this.Types) {
+            // add conversions from "from" to this one and all its supertypes:
+            let nextSuper = type
+            while (nextSuper) {
                this._typed.addConversion(
-               {from, to: type, convert: spec.from[from]})
+                  {from, to: nextSuper, convert: spec.from[from]})
+               nextSuper = this.Types[nextSuper].refines
+            }
          }
       }
       /* And add conversions from this type */
       for (const to in this.Types) {
          if (type in (this.Types[to].from || {})) {
+            if (spec.refines == to || spec.refines in this._subtypes[to]) {
+               throw new SyntaxError(
+                  `Conversion of ${type} to its supertype ${to} disallowed.`)
+            }
+            let nextSuper = to
+            while (nextSuper) {
+               this._typed.addConversion({
+                  from: type,
+                  to: nextSuper,
+                  convert: this.Types[to].from[type]
+               })
+               nextSuper = this.Types[nextSuper].refines
+            }
+         }
+      }
+      if (spec.refines) {
          this._typed.addConversion(
-               {from: type, to, convert: this.Types[to].from[type]})
+            {from: type, to: spec.refines, convert: x => x})
       }
+      this._subtypes[type] = new Set()
+      // Update all the subtype sets of supertypes up the chain:
+      let nextSuper = spec.refines
+      while (nextSuper) {
+         this._subtypes[nextSuper].add(type)
+         nextSuper = this.Types[nextSuper].refines
       }
-      this.Types[type] = spec
       // rebundle anything that uses the new type:
       this._invalidateDependents(':' + type)
    }

src/generic/arithmetic.mjs

@@ -1,7 +1,10 @@
 export * from './Types/generic.mjs'
 
+export {lcm} from './lcm.mjs'
+export {mod} from './mod.mjs'
 export {multiply} from './multiply.mjs'
 export {divide} from './divide.mjs'
 export {sign} from './sign.mjs'
 export {sqrt} from './sqrt.mjs'
+export {square} from './square.mjs'
 export {subtract} from './subtract.mjs'

src/generic/gcdType.mjs

@@ -0,0 +1,18 @@
+/* Returns a object that defines the gcd for the given type */
+export default function(type) {
+   const producer = refs => {
+      const modder = refs[`mod(${type},${type})`]
+      const zeroTester = refs[`isZero(${type})`]
+      return (a,b) => {
+         while (!zeroTester(b)) {
+            const r = modder(a,b)
+            a = b
+            b = r
+         }
+         return a
+      }
+   }
+   const retval = {}
+   retval[`${type},${type}`] = producer
+   return retval
+}

src/generic/lcm.mjs

@@ -0,0 +1,6 @@
+export const lcm = {
+   'any,any': ({
+      multiply,
+      quotient,
+      gcd}) => (a,b) => multiply(quotient(a, gcd(a,b)), b)
+}

src/generic/mod.mjs

@@ -0,0 +1,6 @@
+export const mod = {
+   'any,any': ({
+      subtract,
+      multiply,
+      quotient}) => (a,m) => subtract(a, multiply(m, quotient(a,m)))
+}

src/generic/multiply.mjs

@@ -4,9 +4,9 @@ export const multiply = {
    'undefined': () => u => u,
    'undefined,...any': () => (u, rest) => u,
    'any,undefined': () => (x, u) => u,
-   'any,undefined,...any': () => (x, u, rest) => u,
+   'any,any,...any': ({self}) => (a,b,rest) => {
-   'any,any,undefined': () => (x, y, u) => u,
+      const later = [b, ...rest]
-   'any,any,undefined,...any': () => (x, y, u, rest) => u
+      return later.reduce((x,y) => self(x,y), a)
-   // Bit of a hack since this should go on indefinitely...
+   }
 }
 

src/generic/square.mjs

@@ -0,0 +1,3 @@
+export const square = {
+   any: ({multiply}) => x => multiply(x,x)
+}

src/number/Types/number.mjs

@@ -5,4 +5,9 @@ Number.installType('number', {
     test: n => typeof n === 'number',
     from: {string: s => +s}
 })
+Number.installType('NumInt', {
+    refines: 'number',
+    test: i => isFinite(i) && i === Math.round(i)
+})
+
 export {Number}

src/number/isZero.mjs

@@ -0,0 +1,3 @@
+export * from './Types/number.mjs'
+
+export const isZero = {number: () => n => n === 0}

src/number/multiply.mjs

@@ -1,5 +1,3 @@
 export * from './Types/number.mjs'
 
-export const multiply = {
+export const multiply = {'number,number': () => (m,n) => m*n}
-   '...number': () => multiplicands => multiplicands.reduce((x,y) => x*y, 1),
-}

src/number/native.mjs

@@ -1,10 +1,16 @@
+import gcdType from '../generic/gcdType.mjs'
+
 export * from './Types/number.mjs'
 
 export {abs} from './abs.mjs'
 export {add} from './add.mjs'
+export const gcd = gcdType('NumInt')
 export {invert} from './invert.mjs'
+export {isZero} from './isZero.mjs'
 export {multiply} from './multiply.mjs'
 export {negate} from './negate.mjs'
 export {one} from './one.mjs'
+export {quotient} from './quotient.mjs'
+export {roundquotient} from './roundquotient.mjs'
 export {sqrt} from './sqrt.mjs'
 export {zero} from './zero.mjs'

src/number/quotient.mjs

@@ -0,0 +1,8 @@
+export * from './Types/number.mjs'
+
+export const quotient = {
+   'number,number': () => (n,d) => {
+      if (d === 0) return d
+      return Math.floor(n/d)
+   }
+}

src/number/roundquotient.mjs

@@ -0,0 +1,8 @@
+export * from './Types/number.mjs'
+
+export const roundquotient = {
+   'number,number': () => (n,d) => {
+      if (d === 0) return d
+      return Math.round(n/d)
+   }
+}

test/bigint/_all.mjs

@@ -52,4 +52,16 @@ describe('bigint', () => {
       assert.deepStrictEqual(bo.sqrt(-3249n), bo.complex(0n, 57n))
    })
 
+   it('computes gcd', () => {
+      assert.strictEqual(math.gcd(105n, 70n), 35n)
+   })
+
+   it('computes lcm', () => {
+      assert.strictEqual(math.lcm(105n, 70n), 210n)
+      assert.strictEqual(math.lcm(15n, 60n), 60n)
+      assert.strictEqual(math.lcm(0n, 17n), 0n)
+      assert.strictEqual(math.lcm(20n, 0n), 0n)
+      assert.strictEqual(math.lcm(0n, 0n), 0n)
+   })
+
 })

test/complex/_all.mjs

@@ -29,4 +29,10 @@ describe('complex', () => {
          math.complex(ms.negate(ms.sqrt(0.5)), ms.sqrt(0.5)))
    })
 
+   it('computes gcd', () => {
+      assert.deepStrictEqual(
+         math.gcd(math.complex(53n, 56n), math.complex(47n, -13n)),
+         math.complex(4n, 5n))
+   })
+
 })

test/custom.mjs

@@ -39,6 +39,7 @@ describe('A custom instance', () => {
       assert.strictEqual(pm.subtract(5, 10), -5)
       pm.install(complexAdd)
       pm.install(complexNegate)
+      pm.install(complexComplex)
       // Should be enough to allow complex subtraction, as subtract is generic:
       assert.deepStrictEqual(
          pm.subtract({re:5, im:0}, {re:10, im:1}), {re:-5, im: -1})

test/number/_all.mjs

@@ -27,4 +27,7 @@ describe('number', () => {
       assert.deepStrictEqual(no.sqrt(-16), no.complex(0,4))
    })
 
+   it('computes gcd', () => {
+      assert.strictEqual(math.gcd(15, 35), 5)
+   })
 })