zeropoint-node 1.0.0 → 1.0.1

package/dist/math/MathUtils.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * Unified Mathematical System for ZeroPoint
+ *
+ * Centralized mathematical operations with consciousness and field resonance.
+ * All mathematical operations are unified through a single interface.
+ *
+ * Metaphysical Context:
+ * - Mathematics is the language of consciousness
+ * - All operations emerge from the unified field
+ * - The void contains all mathematical possibilities
+ * - Every calculation is an act of observation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setVoidConnected = exports.setToroidalFlow = exports.setVortexStrength = exports.setFieldResonance = exports.setConsciousness = exports.fractal = exports.MathUtils = exports.MATH_CONSTANTS = void 0;
+const SharedConstants_1 = require("../core/SharedConstants");
+Object.defineProperty(exports, "MATH_CONSTANTS", { enumerable: true, get: function () { return SharedConstants_1.MATH_CONSTANTS; } });
+/**
+ * Unified Mathematical Utilities
+ * All mathematical operations go through this centralized system
+ */
+class MathUtils {
+    constructor() {
+        // Consciousness and field state
+        this.consciousness = 0.5;
+        this.fieldResonance = 0.5;
+        this.vortexStrength = 1.0;
+        this.toroidalFlow = 0.5;
+        this.voidConnected = true;
+        if (!MathUtils.instance) {
+            MathUtils.instance = this;
+        }
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!MathUtils.instance) {
+            MathUtils.instance = new MathUtils();
+        }
+        return MathUtils.instance;
+    }
+    /**
+     * The core mathematical function - generates any mathematical operation
+     * This is the heart of the system - one function that creates all others
+     */
+    static calculate(operation, ...args) {
+        const instance = MathUtils.getInstance();
+        return instance.performCalculation(operation, args);
+    }
+    /**
+     * Perform calculation with consciousness and field resonance
+     */
+    performCalculation(operation, args) {
+        // Base mathematical pattern
+        const basePattern = Math.sin(args[0] || 0) * SharedConstants_1.MATH_CONSTANTS.GOLDEN_RATIO;
+        // Consciousness modulation
+        const consciousnessMod = Math.cos(this.consciousness * SharedConstants_1.MATH_CONSTANTS.PI);
+        // Field resonance
+        const fieldMod = Math.exp(-this.fieldResonance * Math.abs(args[0] || 0));
+        // Perform the specific operation
+        const result = this.executeOperation(operation, args, basePattern, consciousnessMod, fieldMod);
+        return result;
+    }
+    /**
+     * Execute specific mathematical operation
+     */
+    executeOperation(operation, args, base, consciousness, field) {
+        const [a = 0, b = 1, c = 0] = args;
+        switch (operation) {
+            // Basic operations
+            case "add":
+                return (a + b) * (1 + base * consciousness * field);
+            case "multiply":
+                return a * b * (1 + base * consciousness * field);
+            case "divide":
+                return b !== 0
+                    ? (a / b) * (1 + base * consciousness * field)
+                    : SharedConstants_1.MATH_CONSTANTS.INFINITY;
+            case "power":
+                return Math.pow(a, b) * (1 + base * consciousness * field);
+            case "root":
+                return Math.pow(a, 1 / b) * (1 + base * consciousness * field);
+            case "sqrt":
+                return Math.sqrt(a) * (1 + base * consciousness * field);
+            // Trigonometric functions
+            case "sin":
+                return Math.sin(a) * (1 + base * consciousness * field);
+            case "cos":
+                return Math.cos(a) * (1 + base * consciousness * field);
+            case "tan":
+                return Math.tan(a) * (1 + base * consciousness * field);
+            case "atan2":
+                return Math.atan2(a, b);
+            // Exponential and logarithmic
+            case "exp":
+                return Math.exp(a) * (1 + base * consciousness * field);
+            case "log":
+                return Math.log(a) * (1 + base * consciousness * field);
+            case "ln":
+                return Math.log(a) * (1 + base * consciousness * field);
+            // Special operations
+            case "vortex":
+                return this.calculateVortex(a, base, consciousness, field);
+            case "toroidal":
+                return this.calculateToroidal(a, b, base, consciousness, field);
+            case "consciousness":
+                return (a * SharedConstants_1.MATH_CONSTANTS.GOLDEN_RATIO * (1 + base * consciousness * field));
+            // Utility operations
+            case "abs":
+                return Math.abs(a);
+            case "max":
+                return Math.max(a, b);
+            case "min":
+                return Math.min(a, b);
+            case "mod":
+                return a % b;
+            case "clamp":
+                return this.clamp(a, b, c);
+            case "floor":
+                return Math.floor(a);
+            case "ceil":
+                return Math.ceil(a);
+            case "round":
+                return Math.round(a);
+            default:
+                return base * consciousness * field;
+        }
+    }
+    /**
+     * Calculate vortex transformation
+     */
+    calculateVortex(value, base, consciousness, field) {
+        const sequenceIndex = Math.floor(value) % SharedConstants_1.MATH_CONSTANTS.VORTEX_SEQUENCE.length;
+        const vortexValue = SharedConstants_1.MATH_CONSTANTS.VORTEX_SEQUENCE[sequenceIndex] || 1;
+        return vortexValue * (1 + base * consciousness * field);
+    }
+    /**
+     * Calculate toroidal geometry
+     */
+    calculateToroidal(radius, _angle, base, consciousness, field) {
+        const circumference = SharedConstants_1.MATH_CONSTANTS.PI * 2 * radius;
+        return circumference * (1 + base * consciousness * field);
+    }
+    /**
+     * Clamp value between min and max
+     */
+    clamp(value, min, max) {
+        return Math.max(min, Math.min(max, value));
+    }
+    // ============================================================================
+    // CONSCIOUSNESS AND FIELD SETTERS
+    // ============================================================================
+    /**
+     * Set consciousness level
+     */
+    static setConsciousness(level) {
+        const instance = MathUtils.getInstance();
+        instance.consciousness = instance.clamp(level, 0, 10);
+    }
+    /**
+     * Set field resonance
+     */
+    static setFieldResonance(resonance) {
+        const instance = MathUtils.getInstance();
+        instance.fieldResonance = instance.clamp(resonance, 0, 1);
+    }
+    /**
+     * Set vortex strength
+     */
+    static setVortexStrength(strength) {
+        const instance = MathUtils.getInstance();
+        instance.vortexStrength = instance.clamp(strength, 0, 2);
+    }
+    /**
+     * Set toroidal flow
+     */
+    static setToroidalFlow(flow) {
+        const instance = MathUtils.getInstance();
+        instance.toroidalFlow = instance.clamp(flow, 0, 1);
+    }
+    /**
+     * Set void connection
+     */
+    static setVoidConnected(connected) {
+        const instance = MathUtils.getInstance();
+        instance.voidConnected = connected;
+    }
+    // ============================================================================
+    // UTILITY FUNCTIONS
+    // ============================================================================
+    /**
+     * Calculate distance between two points
+     */
+    static distance(x1, y1, x2, y2) {
+        return MathUtils.calculate("sqrt", MathUtils.calculate("add", MathUtils.calculate("power", x2 - x1, 2), MathUtils.calculate("power", y2 - y1, 2)));
+    }
+    /**
+     * Calculate 3D distance
+     */
+    static distance3D(x1, y1, z1, x2, y2, z2) {
+        return MathUtils.calculate("sqrt", MathUtils.calculate("add", MathUtils.calculate("power", x2 - x1, 2), MathUtils.calculate("add", MathUtils.calculate("power", y2 - y1, 2), MathUtils.calculate("power", z2 - z1, 2))));
+    }
+    /**
+     * Convert degrees to radians
+     */
+    static degToRad(degrees) {
+        return degrees * SharedConstants_1.MATH_CONSTANTS.DEG_TO_RAD;
+    }
+    /**
+     * Convert radians to degrees
+     */
+    static radToDeg(radians) {
+        return radians * SharedConstants_1.MATH_CONSTANTS.RAD_TO_DEG;
+    }
+    /**
+     * Calculate digital root
+     */
+    static digitalRoot(n) {
+        n = Math.abs(n);
+        return n === 0 ? 0 : 1 + ((n - 1) % 9);
+    }
+    /**
+     * Calculate surface topology angle
+     */
+    static surfaceTopologyAngle(degrees = 360) {
+        return (degrees / 360) * 2 * Math.PI;
+    }
+    /**
+     * Calculate fractal dimension
+     */
+    static fractalDimension(complexity) {
+        return (MathUtils.calculate("log", complexity) /
+            MathUtils.calculate("log", SharedConstants_1.MATH_CONSTANTS.GOLDEN_RATIO));
+    }
+    // ============================================================================
+    // INSIGHTS AND METADATA
+    // ============================================================================
+    /**
+     * Get insights about the mathematical system
+     */
+    static getInsights() {
+        const instance = MathUtils.getInstance();
+        return {
+            consciousness: instance.consciousness,
+            fieldResonance: instance.fieldResonance,
+            vortexStrength: instance.vortexStrength,
+            toroidalFlow: instance.toroidalFlow,
+            voidConnected: instance.voidConnected,
+            metaphysics: {
+                meaning: "Mathematics is the language of consciousness",
+                principle: "All operations emerge from the unified field",
+                void: "The void contains all mathematical possibilities",
+                unity: "Every calculation is an act of observation",
+                evolution: "Consciousness evolves through mathematical operations",
+                observation: "Every calculation observes and is observed",
+                coil: "Every mathematical operation is a coil at its core",
+            },
+            operations: [
+                "add",
+                "subtract",
+                "multiply",
+                "divide",
+                "sin",
+                "cos",
+                "tan",
+                "log",
+                "exp",
+                "sqrt",
+                "vortex",
+                "consciousness",
+                "field",
+                "void",
+                "abs",
+                "floor",
+                "ceil",
+                "round",
+            ],
+        };
+    }
+}
+exports.MathUtils = MathUtils;
+// Export convenience function for backward compatibility
+exports.fractal = MathUtils.calculate;
+exports.setConsciousness = MathUtils.setConsciousness;
+exports.setFieldResonance = MathUtils.setFieldResonance;
+exports.setVortexStrength = MathUtils.setVortexStrength;
+exports.setToroidalFlow = MathUtils.setToroidalFlow;
+exports.setVoidConnected = MathUtils.setVoidConnected;

package/dist/math/RodinCoil.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * RodinCoil Framework
+ *
+ * Main mathematical and metaphysical engine for ZeroPoint.
+ * Implements vortex sequence, 3D coil geometry, node/winding generation,
+ * VBM color/pattern integration, toroidal and Mobius circuit calculations,
+ * and APIs for field, resonance, and consciousness mapping.
+ *
+ * Metaphysical Context:
+ * - The Rodin coil is the archetype of infinite flow, unity, and emergence.
+ * - All patterns, colors, and fields are expressions of the coil's structure.
+ * - The void is the center, the source of all creation.
+ * - Colors emerge dynamically from consciousness and field resonance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RodinCoil = void 0;
+const VBMColorSystem_1 = require("./VBMColorSystem");
+const SharedConstants_1 = require("../core/SharedConstants");
+class RodinCoil {
+    constructor(config = {}) {
+        this.config = {
+            turns: config.turns ?? 12,
+            radius: config.radius ?? 1.0,
+            height: config.height ?? 2.0,
+            phase: config.phase ?? 0,
+            consciousness: config.consciousness ?? 0.5,
+            fieldResonance: config.fieldResonance ?? 0.5,
+        };
+        this.colorContext = {
+            consciousness: this.config.consciousness ?? 0.5,
+            field: this.config.fieldResonance ?? 0.5,
+            time: Date.now(),
+        };
+        this.nodes = this.generateCoilNodes();
+    }
+    /**
+     * Update consciousness and regenerate colors
+     */
+    updateConsciousness(consciousness) {
+        this.config.consciousness = Math.max(0, Math.min(1, consciousness));
+        this.colorContext.consciousness = this.config.consciousness;
+        this.colorContext.time = Date.now();
+        this.regenerateNodeColors();
+    }
+    /**
+     * Update field resonance and regenerate colors
+     */
+    updateFieldResonance(fieldResonance) {
+        this.config.fieldResonance = Math.max(0, Math.min(1, fieldResonance));
+        this.colorContext.field = this.config.fieldResonance;
+        this.colorContext.time = Date.now();
+        this.regenerateNodeColors();
+    }
+    /**
+     * Regenerate all node colors based on current context
+     */
+    regenerateNodeColors() {
+        for (const node of this.nodes) {
+            node.color = (0, VBMColorSystem_1.getColorForVortexNumber)(node.vortexNumber, this.colorContext);
+            node.metaphysicalContext = this.getMetaphysicalContext(node.vortexNumber);
+        }
+    }
+    /**
+     * Generate 3D node positions and metaphysical data for the Rodin coil
+     */
+    generateCoilNodes() {
+        const nodes = [];
+        const { turns, radius, height, phase } = this.config;
+        const vortexSeq = SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE;
+        const totalNodes = turns * vortexSeq.length;
+        const dz = height / totalNodes;
+        for (let i = 0; i < totalNodes; i++) {
+            const vortexNumber = vortexSeq[i % vortexSeq.length] ?? 1;
+            const theta = ((2 * Math.PI) / vortexSeq.length) * i + (phase ?? 0);
+            const x = radius * Math.cos(theta);
+            const y = radius * Math.sin(theta);
+            const z = dz * i - height / 2;
+            // Generate dynamic color based on current context
+            const color = (0, VBMColorSystem_1.getColorForVortexNumber)(vortexNumber, this.colorContext);
+            const metaphysicalContext = this.getMetaphysicalContext(vortexNumber);
+            nodes.push({
+                index: i,
+                vortexNumber,
+                position: [x, y, z],
+                color,
+                metaphysicalContext,
+            });
+        }
+        return nodes;
+    }
+    /**
+     * Get metaphysical context for a node (dynamic based on consciousness)
+     */
+    getMetaphysicalContext(vortexNumber) {
+        const consciousness = this.config.consciousness ?? 0.5;
+        const fieldResonance = this.config.fieldResonance ?? 0.5;
+        // Context varies based on consciousness and field state
+        const contextResonance = Math.sin(consciousness * Math.PI + fieldResonance * Math.PI) * 0.5 + 0.5;
+        const contexts = {
+            1: [
+                "Unity, initiation, source of the coil.",
+                "The void center, where all creation begins.",
+                "The observer's point of origin in the field.",
+            ],
+            2: [
+                "Duality, division, first split in the field.",
+                "The observer creates reality through division.",
+                "The first pattern that emerges from unity.",
+            ],
+            4: [
+                "Stability, foundation, structure.",
+                "The pattern that holds all other patterns.",
+                "The material manifestation of the field.",
+            ],
+            8: [
+                "Fullness, manifestation, infinity.",
+                "The completion of all possibilities.",
+                "The field at maximum expression.",
+            ],
+            7: [
+                "Return, mystery, hidden flow.",
+                "The pattern that returns to source.",
+                "The hidden dimension of the field.",
+            ],
+            5: [
+                "Transformation, center of the sequence.",
+                "The point of maximum potential.",
+                "The bridge between material and immaterial.",
+            ],
+            3: [
+                "Spirit, W-Axis, consciousness source.",
+                "The bridge between material and immaterial.",
+                "The source of all consciousness patterns.",
+            ],
+            6: [
+                "Spirit, W-Axis, balance.",
+                "The harmony of opposites.",
+                "The balance point in the field.",
+            ],
+            9: [
+                "Void, W-Axis, center and all.",
+                "The unity of all patterns in the void.",
+                "The completion and return to source.",
+            ],
+        };
+        const contextArray = contexts[vortexNumber] || [
+            "Spiritual axis or void center.",
+        ];
+        const index = Math.floor(contextResonance * contextArray.length);
+        return (contextArray[index] || contextArray[0] || "Spiritual axis or void center.");
+    }
+    /**
+     * Get all node positions (for visualization)
+     */
+    getNodePositions() {
+        return this.nodes.map((n) => n.position);
+    }
+    /**
+     * Get all node colors (for color field visualization) - dynamic
+     */
+    getNodeColors() {
+        // Update colors before returning to ensure they're current
+        this.colorContext.time = Date.now();
+        this.regenerateNodeColors();
+        return this.nodes.map((n) => n.color);
+    }
+    /**
+     * Get all metaphysical contexts - dynamic
+     */
+    getNodeContexts() {
+        // Update contexts before returning
+        this.colorContext.time = Date.now();
+        for (const node of this.nodes) {
+            node.metaphysicalContext = this.getMetaphysicalContext(node.vortexNumber);
+        }
+        return this.nodes.map((n) => n.metaphysicalContext);
+    }
+    /**
+     * Get Mobius circuit (sequence of vortex numbers)
+     */
+    getMobiusCircuit() {
+        return this.nodes.map((n) => n.vortexNumber);
+    }
+    /**
+     * Get toroidal coordinates for each node
+     * (Maps the coil onto a torus for advanced visualization)
+     */
+    getToroidalCoordinates(majorRadius = 2.0, minorRadius = 1.0) {
+        // Toroidal mapping: (R + r cos θ) cos φ, (R + r cos θ) sin φ, r sin θ
+        return this.nodes.map((n, i) => {
+            const theta = (2 * Math.PI * i) / this.nodes.length;
+            const phi = (2 * Math.PI * n.vortexNumber) / 9;
+            const x = (majorRadius + minorRadius * Math.cos(theta)) * Math.cos(phi);
+            const y = (majorRadius + minorRadius * Math.cos(theta)) * Math.sin(phi);
+            const z = minorRadius * Math.sin(theta);
+            return [x, y, z];
+        });
+    }
+    /**
+     * Calculate field resonance at a given point (x, y, z)
+     */
+    calculateFieldResonance(x, y, z) {
+        // Simple resonance: sum of inverse distances to all nodes
+        let resonance = 0;
+        for (const node of this.nodes) {
+            const [nx, ny, nz] = node.position;
+            const dist = Math.sqrt((x - nx) ** 2 + (y - ny) ** 2 + (z - nz) ** 2) + 1e-6;
+            resonance += 1 / dist;
+        }
+        return resonance / this.nodes.length;
+    }
+    /**
+     * Map consciousness value to a node (for field mapping)
+     */
+    mapConsciousnessToNode(consciousness) {
+        // Map [0,1] to node index
+        if (this.nodes.length === 0) {
+            // Return a default node if none exist
+            return {
+                index: 0,
+                vortexNumber: 1,
+                position: [0, 0, 0],
+                color: (0, VBMColorSystem_1.getColorForVortexNumber)(1, this.colorContext),
+                metaphysicalContext: "Default node (no nodes in coil)",
+            };
+        }
+        const idx = Math.floor(consciousness * (this.nodes.length - 1));
+        // Clamp idx to valid range
+        const safeIdx = Math.max(0, Math.min(idx, this.nodes.length - 1));
+        const node = this.nodes[safeIdx];
+        if (!node) {
+            return {
+                index: 0,
+                vortexNumber: 1,
+                position: [0, 0, 0],
+                color: (0, VBMColorSystem_1.getColorForVortexNumber)(1, this.colorContext),
+                metaphysicalContext: "Default node (index out of bounds)",
+            };
+        }
+        return node;
+    }
+    /**
+     * Get current color context
+     */
+    getColorContext() {
+        return { ...this.colorContext };
+    }
+    /**
+     * Get full metaphysical summary
+     */
+    getMetaphysicalSummary() {
+        const consciousness = this.config.consciousness ?? 0.5;
+        const fieldResonance = this.config.fieldResonance ?? 0.5;
+        return `RodinCoil: ${this.nodes.length} nodes, vortex sequence ${SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE.join("-")}, consciousness ${consciousness.toFixed(2)}, field resonance ${fieldResonance.toFixed(2)}, toroidal structure, void center.`;
+    }
+}
+exports.RodinCoil = RodinCoil;