glen/pocomath
2
1
Fork 0
Code Issues 3 Pull Requests Projects Releases Wiki Activity

feat(return types): Add more return types for complex functions

Browse Source 
These changes greatly increased the need for precision in generating
  implementations for signatures of operations whenever possible. So this
  commit also includes a refactor that basically caches all of the
  conversions of Pocomath implementations to typed-function implementatios so
  that they are more often externally available (i.e., not disrupted so much
  after invalidation).
This commit is contained in:
Glen Whitney 2022-08-26 23:54:32 -04:00
parent bc434c7163
commit a2f76a55b8
13 changed files with 273 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bigint/divide.mjs
View File

@ -3,7 +3,7 @@ export * from './Types/bigint.mjs'
export const divide = {
'bigint,bigint': ({config, 'quotient(bigint,bigint)': quot}) => {
if (config.predictable) return quot
if (config.predictable) return Returns('bigint', (n,d) => quot(n,d))
return Returns('bigint|undefined', (n, d) => {
const q = n/d
if (q * d == n) return q

2
src/complex/Types/Complex.mjs
View File

@ -6,7 +6,7 @@ const Complex = new PocomathInstance('Complex')
Complex.installType('Complex', {
test: z => z && typeof z === 'object' && 're' in z && 'im' in z
})
// Now the template type: Complex numbers are actually always homeogeneous
// Now the template type: Complex numbers are actually always homogeneous
// in their component types.
Complex.installType('Complex<T>', {
infer: ({typeOf, joinTypes}) => z => joinTypes([typeOf(z.re), typeOf(z.im)]),

23
src/complex/abs.mjs
View File

@ -1,10 +1,25 @@
import {Returns, returnTypeOf} from '../core/Returns.mjs'
export * from './Types/Complex.mjs'
export const abs = {
'Complex<T>': ({
sqrt, // Calculation of the type needed in the square root (the
// underlying numeric type of T, whatever T is, is beyond Pocomath's
// (current) template abilities, so punt and just do full resolution
sqrt, // Unfortunately no notation yet for the needed signature
'absquare(T)': baseabsq,
'absquare(Complex<T>)': absq
}) => z => sqrt(absq(z))
}) => {
const pm = sqrt.fromInstance
if (typeof pm === 'undefined') {
// Just checking for the dependencies, return value is irrelevant
return undefined
}
const midType = returnTypeOf(baseabsq)
const sqrtImp = pm.resolve('sqrt', midType, sqrt)
let retType = returnTypeOf(sqrtImp)
if (retType.includes('|')) {
// This is a bit of a hack, as it relies on all implementations of
// sqrt returning the "typical" return type as the first option
retType = retType.split('|',1)[0]
}
return Returns(retType, z => sqrtImp(absq(z)))
}
}

28
src/complex/absquare.mjs
View File

@ -1,9 +1,31 @@
import {Returns, returnTypeOf} from '../core/Returns.mjs'
export * from './Types/Complex.mjs'
export const absquare = {
'Complex<T>': ({
add, // Calculation of exact type needed in add (underlying numeric of T)
// is (currently) too involved for Pocomath
add, // no easy way to write the needed signature; if T is number
// it is number,number; but if T is Complex<bigint>, it is just
// bigint,bigint. So unfortunately we depend on all of add, and
// we extract the needed implementation below.
'self(T)': absq
}) => z => add(absq(z.re), absq(z.im))
}) => {
const pm = add.fromInstance
if (typeof pm === 'undefined') {
// Just checking the dependencies, return value irrelevant
return undefined
}
const midType = returnTypeOf(absq)
const addImp = pm.resolve('add', `${midType},${midType}`, add)
return Returns(
returnTypeOf(addImp), z => addImp(absq(z.re), absq(z.im)))
}
}
/* We could imagine notations that Pocomath could support that would simplify
* the above, maybe something like
* 'Complex<T>': ({
* 'self(T): U': absq,
* 'add(U,U):V': plus,
* V
* }) => Returns(V, z => plus(absq(z.re), absq(z.im)))
*/

9
src/complex/multiply.mjs
View File

@ -1,15 +1,18 @@
import Returns from '../core/Returns.mjs'
export * from './Types/Complex.mjs'
export const multiply = {
'Complex<T>,Complex<T>': ({
T,
'complex(T,T)': cplx,
'add(T,T)': plus,
'subtract(T,T)': sub,
'self(T,T)': me,
'conjugate(T)': conj // makes quaternion multiplication work
}) => (w,z) => {
return cplx(
}) => Returns(
`Complex<${T}>`,
(w,z) => cplx(
sub(me(w.re, z.re), me(conj(w.im), z.im)),
plus(me(conj(w.re), z.im), me(w.im, z.re)))
}
)
}

43
src/complex/sqrt.mjs
View File

@ -1,3 +1,4 @@
import {Returns, returnTypeOf} from '../core/Returns.mjs'
export * from './Types/Complex.mjs'
export const sqrt = {
@ -12,29 +13,41 @@ export const sqrt = {
'multiply(T,T)': mult,
'self(T)': me,
'divide(T,T)': div,
'abs(Complex<T>)': absC,
'absquare(Complex<T>)': absqC,
'subtract(T,T)': sub
}) => {
let baseReturns = returnTypeOf(me)
if (baseReturns.includes('|')) {
// Bit of a hack, because it is relying on other implementations
// to list the "typical" value of sqrt first
baseReturns = baseReturns.split('|', 1)[0]
}
if (config.predictable) {
return z => {
return Returns(`Complex<${baseReturns}>`, z => {
const reOne = uno(z.re)
if (isZ(z.im) && sgn(z.re) === reOne) return cplxU(me(z.re))
const reTwo = plus(reOne, reOne)
const myabs = me(absqC(z))
return cplxB(
mult(sgn(z.im), me(div(plus(absC(z),z.re), reTwo))),
me(div(sub(absC(z),z.re), reTwo))
mult(sgn(z.im), me(div(plus(myabs, z.re), reTwo))),
me(div(sub(myabs, z.re), reTwo))
)
})
}
return Returns(
`Complex<${baseReturns}>|${baseReturns}|undefined`,
z => {
const reOne = uno(z.re)
if (isZ(z.im) && sgn(z.re) === reOne) return me(z.re)
const reTwo = plus(reOne, reOne)
const myabs = me(absqC(z))
const reSqrt = me(div(plus(myabs, z.re), reTwo))
const imSqrt = me(div(sub(myabs, z.re), reTwo))
if (reSqrt === undefined || imSqrt === undefined) return undefined
return cplxB(mult(sgn(z.im), reSqrt), imSqrt)
}
}
return z => {
const reOne = uno(z.re)
if (isZ(z.im) && sgn(z.re) === reOne) return me(z.re)
const reTwo = plus(reOne, reOne)
const reSqrt = me(div(plus(absC(z),z.re), reTwo))
const imSqrt = me(div(sub(absC(z),z.re), reTwo))
if (reSqrt === undefined || imSqrt === undefined) return undefined
return cplxB(mult(sgn(z.im), reSqrt), imSqrt)
}
)
}
}

229
src/core/PocomathInstance.mjs
View File

@ -38,6 +38,7 @@ export default class PocomathInstance {
'joinTypes',
'name',
'returnTypeOf',
'resolve',
'self',
'subtypesOf',
'supertypesOf',
@ -49,7 +50,8 @@ export default class PocomathInstance {
constructor(name) {
this.name = name
this._imps = {}
this._imps = {} // Pocomath implementations, with dependencies
this._TFimps = {} // typed-function implementations, dependencies resolved
this._affects = {}
this._typed = typed.create()
this._typed.clear()
@ -220,7 +222,6 @@ export default class PocomathInstance {
if (details) {
return returnTypeOf(details.fn, signature, this)
}
console.log('Checking return type of', operation)
return returnTypeOf(this[operation], signature, this)
})
@ -564,8 +565,28 @@ export default class PocomathInstance {
`Conflicting definitions of ${signature} for ${name}`)
}
} else {
// Must avoid aliasing into another instance:
opImps[signature] = {uses: behavior.uses, does: behavior.does}
/* Check if it's an ordinary non-template signature */
let explicit = true
for (const type of typesOfSignature(signature)) {
for (const word of type.split(/[<>:\s]/)) {
if (this._templateParam(word)) {
explicit = false
break
}
}
if (!explicit) break
}
opImps[signature] = {
explicit,
uses: behavior.uses,
does: behavior.does
}
if (explicit) {
opImps[signature].resolved = false
} else {
opImps[signature].hasInstantiations = {}
opImps[signature].needsInstantiations = new Set()
}
for (const dep of behavior.uses) {
const depname = dep.split('(', 1)[0]
if (depname === 'self' || this._templateParam(depname)) {
@ -604,11 +625,40 @@ export default class PocomathInstance {
* Reset an operation to require creation of typed-function,
* and if it has no implementations so far, set them up.
*/
_invalidate(name) {
if (this._invalid.has(name)) return
_invalidate(name, reason) {
if (!(name in this._imps)) {
this._imps[name] = {}
}
if (reason) {
// Make sure no TF imps that depend on reason remain:
for (const [signature, behavior] of Object.entries(this._imps[name])) {
let invalidated = false
if (reason.charAt(0) === ':') {
const badType = reason.slice(1)
if (signature.includes(badType)) invalidated = true
} else {
for (const dep of behavior.uses) {
if (dep.includes(reason)) {
invalidated = true
break
}
}
}
if (invalidated) {
if (behavior.explicit) {
if (behavior.resolved) delete this._TFimps[signature]
behavior.resolved = false
} else {
for (const fullSig
of Object.values(behavior.hasInstantiations)) {
delete this._TFimps[fullSig]
}
behavior.hasInstantiations = {}
}
}
}
}
if (this._invalid.has(name)) return
this._invalid.add(name)
this._invalidateDependents(name)
const self = this
@ -628,7 +678,7 @@ export default class PocomathInstance {
_invalidateDependents(name) {
if (name in this._affects) {
for (const ancestor of this._affects[name]) {
this._invalidate(ancestor)
this._invalidate(ancestor, name)
}
}
}
@ -642,6 +692,10 @@ export default class PocomathInstance {
if (!imps) {
throw new SyntaxError(`No implementations for ${name}`)
}
if (!(this._TFimps[name])) {
this._TFimps[name] = {}
}
const tf_imps = this._TFimps[name]
/* Collect the entries we know the types for */
const usableEntries = []
for (const entry of Object.entries(imps)) {
@ -664,20 +718,13 @@ export default class PocomathInstance {
* in the midst of being reassembled
*/
Object.defineProperty(this, name, {configurable: true, value: 'limbo'})
const tf_imps = {}
for (const [rawSignature, behavior] of usableEntries) {
/* Check if it's an ordinary non-template signature */
let explicit = true
for (const type of typesOfSignature(rawSignature)) {
for (const word of type.split(/[<>:\s]/)) {
if (this._templateParam(word)) {
explicit = false
break
}
if (behavior.explicit) {
if (!(behavior.resolved)) {
this._addTFimplementation(tf_imps, rawSignature, behavior)
tf_imps[rawSignature]._pocoSignature = rawSignature
behavior.resolved = true
}
}
if (explicit) {
this._addTFimplementation(tf_imps, rawSignature, behavior)
continue
}
/* It's a template, have to instantiate */
@ -693,12 +740,9 @@ export default class PocomathInstance {
}
}
/* First, add the known instantiations, gathering all types needed */
if (!('instantiations' in behavior)) {
behavior.instantiations = new Set()
if (ubType) behavior.instantiations.add(ubType)
}
if (ubType) behavior.needsInstantiations.add(ubType)
let instantiationSet = new Set()
for (const instType of behavior.instantiations) {
for (const instType of behavior.needsInstantiations) {
instantiationSet.add(instType)
const otherTypes =
ubType ? this.subtypesOf(instType) : this._priorTypes[instType]
@ -710,6 +754,7 @@ export default class PocomathInstance {
for (const instType of instantiationSet) {
if (!(instType in this.Types)) continue
if (this.Types[instType] === anySpec) continue
if (instType in behavior.hasInstantiations) continue
const signature =
substituteInSignature(rawSignature, theTemplateParam, instType)
/* Don't override an explicit implementation: */
@ -742,10 +787,14 @@ export default class PocomathInstance {
}
this._addTFimplementation(
tf_imps, signature, {uses, does: patch})
tf_imps[signature]._pocoSignature = rawSignature
tf_imps[signature]._pocoInstance = instType
behavior.hasInstantiations[instType] = signature
}
/* Now add the catchall signature */
/* (Not needed if if it's a bounded template) */
if (ubType) continue
if ('_catchall_' in behavior.hasInstantiations) continue
let templateCall = `<${theTemplateParam}>`
/* Relying here that the base of 'Foo<T>' is 'Foo': */
let baseSignature = rawSignature.replaceAll(templateCall, '')
@ -886,11 +935,11 @@ export default class PocomathInstance {
/* Arrange that the desired instantiation will be there next
* time so we don't have to go through that again for this type
*/
refs[theTemplateParam] = instantiateFor
behavior.instantiations.add(instantiateFor)
behavior.needsInstantiations.add(instantiateFor)
self._invalidate(name)
// And update refs because we now know the type we're instantiating
// for:
refs[theTemplateParam] = instantiateFor
const innerRefs = {}
for (const dep in simplifiedUses) {
const simplifiedDep = simplifiedUses[dep]
@ -903,7 +952,7 @@ export default class PocomathInstance {
needsig, theTemplateParam, instantiateFor)
let resname = simplifiedDep
if (resname == 'self') resname = name
innerRefs[dep] = self._pocoresolve(
innerRefs[dep] = self.resolve(
resname, subsig, refs[simplifiedDep])
} else {
innerRefs[dep] = refs[simplifiedDep]
@ -913,13 +962,15 @@ export default class PocomathInstance {
// Finally ready to make the call.
const implementation = behavior.does(innerRefs)
// We can access return type information here
// And in particular, if it's a template, we should try to
// And in particular, if it might be a template, we should try to
// instantiate it:
const returnType = returnTypeOf(implementation, wantSig, self)
const instantiated = self._maybeInstantiate(returnType)
if (instantiated) {
const tempBase = instantiated.split('<',1)[0]
self._invalidateDependents(':' + tempBase)
for (const possibility of returnType.split('|')) {
const instantiated = self._maybeInstantiate(possibility)
if (instantiated) {
const tempBase = instantiated.split('<',1)[0]
self._invalidateDependents(':' + tempBase)
}
}
return implementation(...args)
}
@ -932,6 +983,7 @@ export default class PocomathInstance {
const outerUses = new Set(Object.values(simplifiedUses))
this._addTFimplementation(
tf_imps, signature, {uses: outerUses, does: patch})
behavior.hasInstantiations._catchall_ = rawSignature
}
this._correctPartialSelfRefs(name, tf_imps)
// Make sure we have all of the needed (template) types; and if they
@ -946,9 +998,17 @@ export default class PocomathInstance {
}
}
for (const badSig of badSigs) {
const imp = tf_imps[badSig]
delete tf_imps[badSig]
const fromBehavior = this._imps[name][imp._pocoSignature]
if (fromBehavior.explicit) {
fromBehavior.resolved = false
} else {
delete fromBehavior.hasInstantiations[imp._pocoInstance]
}
}
const tf = this._typed(name, tf_imps)
Object.defineProperty(tf, 'fromInstance', {value: this})
Object.defineProperty(this, name, {configurable: true, value: tf})
return tf
}
@ -1006,13 +1066,20 @@ export default class PocomathInstance {
}
if (func === 'self') {
if (needsig) {
if (full_self_referential) {
throw new SyntaxError(
'typed-function does not support mixed full and '
+ 'partial self-reference')
}
if (subsetOfKeys(typesOfSignature(needsig), this.Types)) {
part_self_references.push(needsig)
/* Maybe we can resolve the self reference without troubling
* typed-function:
*/
if (needsig in imps && typeof imps[needsig] == 'function') {
refs[dep] = imps[needsig]
} else {
if (full_self_referential) {
throw new SyntaxError(
'typed-function does not support mixed full and '
+ 'partial self-reference')
}
if (subsetOfKeys(typesOfSignature(needsig), this.Types)) {
part_self_references.push(needsig)
}
}
} else {
if (part_self_references.length) {
@ -1024,19 +1091,41 @@ export default class PocomathInstance {
}
} else {
if (this[func] === 'limbo') {
/* We are in the midst of bundling func, so have to use
* an indirect reference to func. And given that, there's
* really no helpful way to extract a specific signature
/* We are in the midst of bundling func */
let fallback = true
/* So the first thing we can do is try the tf_imps we are
* accumulating:
*/
const self = this
refs[dep] = function () { // is this the most efficient?
return self[func].apply(this, arguments)
if (needsig) {
const tempTF = this._typed('dummy_' + func, this._TFimps[func])
let result = undefined
try {
result = this._typed.find(tempTF, needsig, {exact: true})
} catch {}
if (result) {
refs[dep] = result
fallback = false
}
}
if (fallback) {
/* Either we need the whole function or the signature
* we need is not available yet, so we have to use
* an indirect reference to func. And given that, there's
* really no helpful way to extract a specific signature
*/
const self = this
const redirect = function () { // is this the most efficient?
return self[func].apply(this, arguments)
}
Object.defineProperty(redirect, 'name', {value: func})
Object.defineProperty(redirect, 'fromInstance', {value: this})
refs[dep] = redirect
}
} else {
// can bundle up func, and grab its signature if need be
let destination = this[func]
if (destination && needsig) {
destination = this._pocoresolve(func, needsig)
destination = this.resolve(func, needsig)
}
refs[dep] = destination
}
@ -1076,7 +1165,8 @@ export default class PocomathInstance {
_correctPartialSelfRefs(name, imps) {
for (const aSignature in imps) {
if (!(imps[aSignature].deferred)) continue
const part_self_references = imps[aSignature].psr
const deferral = imps[aSignature]
const part_self_references = deferral.psr
const corrected_self_references = []
for (const neededSig of part_self_references) {
// Have to find a match for neededSig among the other signatures
@ -1098,8 +1188,8 @@ export default class PocomathInstance {
+ `${name}(${neededSig})`)
}
}
const refs = imps[aSignature].builtRefs
const does = imps[aSignature].sigDoes
const refs = deferral.builtRefs
const does = deferral.sigDoes
imps[aSignature] = this._typed.referTo(
...corrected_self_references, (...impls) => {
for (let i = 0; i < part_self_references.length; ++i) {
@ -1110,6 +1200,8 @@ export default class PocomathInstance {
return implementation
}
)
imps[aSignature]._pocoSignature = deferral._pocoSignature
imps[aSignature]._pocoInstance = deferral._pocoInstance
}
}
@ -1282,16 +1374,30 @@ export default class PocomathInstance {
typedFunction = this[name]
}
let result = undefined
if (!this._typed.isTypedFunction(typedFunction)) {
return result
const haveTF = this._typed.isTypedFunction(typedFunction)
if (haveTF) {
try {
result = this._typed.findSignature(typedFunction, sig, {exact: true})
} catch {
}
}
try {
result = this._typed.findSignature(typedFunction, sig, {exact: true})
} catch {
}
if (result) return result
if (result || !(this._imps[name])) return result
const foundsig = this._findSubtypeImpl(name, this._imps[name], sig)
if (foundsig) return this._typed.findSignature(typedFunction, foundsig)
if (foundsig) {
if (haveTF) {
return this._typed.findSignature(typedFunction, foundsig)
}
// We have an implementation but not a typed function. Do the best
// we can:
const foundImpl = this._imps[name][foundsig]
const needs = {}
for (const dep of foundImpl.uses) {
const [base, sig] = dep.split('()')
needs[dep] = this.resolve(base, sig)
}
const pseudoImpl = foundImpl.does(needs)
return {fn: pseudoImpl, implementation: pseudoImpl}
}
const wantTypes = typeListOfSignature(sig)
for (const [implSig, details]
of typedFunction._typedFunctionData.signatureMap) {
@ -1314,7 +1420,12 @@ export default class PocomathInstance {
return result
}
_pocoresolve(name, sig, typedFunction) {
/* Returns a function that implements the operation with the given name
* when called with the given signature. The optional third argument is
* the typed function that provides the operation name, which can be
* passed in for efficiency if it is already available.
*/
resolve = Returns('function', function (name, sig, typedFunction) {
if (!this._typed.isTypedFunction(typedFunction)) {
typedFunction = this[name]
}
@ -1323,6 +1434,6 @@ export default class PocomathInstance {
// total punt, revert to typed-function resolution on every call;
// hopefully this happens rarely:
return typedFunction
}
})
}

5
src/generic/absquare.mjs
View File

@ -1,6 +1,9 @@
import Returns from '../core/Returns.mjs'
export const absquare = {
T: ({
T,
'square(T)': sq,
'abs(T)': abval
}) => t => sq(abval(t))
}) => Returns(T, t => sq(abval(t)))
}

5
src/generic/square.mjs
View File

@ -1,3 +1,6 @@
import {Returns, returnTypeOf} from '../core/Returns.mjs'
export const square = {
T: ({'multiply(T,T)': multT}) => x => multT(x,x)
T: ({'multiply(T,T)': multT}) => Returns(
returnTypeOf(multT), x => multT(x,x))
}

3
src/number/absquare.mjs
View File

@ -1,6 +1,7 @@
import Returns from '../core/Returns.mjs'
export * from './Types/number.mjs'
/* Absolute value squared */
export const absquare = {
number: ({'square(number)': sqn}) => n => sqn(n)
'T:number': ({T, 'square(T)': sqn}) => Returns(T, n => sqn(n))
}

4
src/number/multiply.mjs
View File

@ -1,3 +1,5 @@
import Returns from '../core/Returns.mjs'
export * from './Types/number.mjs'
export const multiply = {'number,number': () => (m,n) => m*n}
export const multiply = {'T:number,T': ({T}) => Returns(T, (m,n) => m*n)}

17
src/number/sqrt.mjs
View File

@ -1,3 +1,4 @@
import Returns from '../core/Returns.mjs'
export * from './Types/number.mjs'
export const sqrt = {
@ -5,13 +6,13 @@ export const sqrt = {
config,
'complex(number,number)': cplx,
'negate(number)': neg}) => {
if (config.predictable || !cplx) {
return n => isNaN(n) ? NaN : Math.sqrt(n)
if (config.predictable || !cplx) {
return Returns('number', n => isNaN(n) ? NaN : Math.sqrt(n))
}
return Returns('number|Complex<number>', n => {
if (isNaN(n)) return NaN
if (n >= 0) return Math.sqrt(n)
return cplx(0, Math.sqrt(neg(n)))
})
}
return n => {
if (isNaN(n)) return NaN
if (n >= 0) return Math.sqrt(n)
return cplx(0, Math.sqrt(neg(n)))
}
}
}

1
test/complex/_all.mjs
View File

@ -83,6 +83,7 @@ describe('complex', () => {
assert.deepStrictEqual(
math.multiply(q0, math.quaternion(2, 1, 0.1, 0.1)),
math.quaternion(1.9, 1.1, 2.1, -0.9))
math.absquare(math.complex(1.25, 2.5)) //HACK: need absquare(Complex<number>)
assert.strictEqual(math.abs(q0), Math.sqrt(2))
assert.strictEqual(math.abs(q1), Math.sqrt(33)/4)
})