feat: more Complex methods

* Adds associate, conj, multiply, negate, subtract, indistinguishable
  * As a result equal is now supported
  * Adds a check for recursive loops in resolve (a key/signature method
    depending on itself

src/complex/type.js

@@ -1,6 +1,7 @@
 import {Complex} from './Complex.js'
 import {Returns} from "#core/Type.js"
 import {Any, match} from "#core/TypePatterns.js"
+import {BooleanT} from '#boolean/BooleanT.js'
 import {NumberT} from '#number/NumberT.js'
 
 export const complex = [
@@ -28,3 +29,24 @@ export const complex = [
 
 export const arg = match(
     Complex(NumberT), Returns(NumberT, z => Math.atan2(z.im, z.re)))
+
+/* Returns true if w is z multiplied by a complex unit */
+export const associate = match([Complex, Complex], (math, [W, Z]) => {
+    if (Z.Component.complex) {
+        throw new Error(
+            `The group of units of type ${Z} is not yet implemented`)
+    }
+    const eq = math.equal.resolve([W, Z])
+    const neg = math.negate.resolve(Z)
+    const eqN = math.equal.resolve([W, neg.returns])
+    const mult = math.multiply.resolve([Z, Z])
+    const eqM = math.equal.resolve([W, mult.returns])
+    const negM = math.negate.resolve(mult.returns)
+    const eqNM = math.equal.resolve([W, negM.returns])
+    const iZ = math.complex(math.zero(Z.Component), math.one(Z.Component))
+    return Returns(BooleanT, (w, z) => {
+        if (eq(w, z) || eqN(w, neg(z))) return true
+        const iz = mult(iZ, z)
+        return eqM(w, iz) || eqNM(w, negM(iz))
+    })
+})