zeropoint-node 1.0.0 → 1.0.1

package/dist/__tests__/math/AdvancedVBM.test.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AdvancedVBM_1 = require("../../math/AdvancedVBM");
+describe('AdvancedVBM', () => {
+    let vbm;
+    beforeEach(() => {
+        vbm = new AdvancedVBM_1.AdvancedVBM();
+    });
+    describe('Initialization', () => {
+        it('should initialize with default consciousness level', () => {
+            const insights = vbm.getVBMInsights();
+            expect(insights.consciousnessLevel).toBe(0.5);
+            expect(insights.vortexSequencesCount).toBe(8); // 8 vortex sequences initialized
+            expect(insights.qaResultsCount).toBe(0);
+            expect(insights.primaryVortexSequence).toEqual([1, 2, 4, 8, 7, 5]);
+            expect(insights.goldenRatio).toBe(1.618033988749895);
+            expect(insights.wAxis).toEqual([3, 6, 9]);
+        });
+        it('should emit vbm_initialized event on construction', () => {
+            const newVBM = new AdvancedVBM_1.AdvancedVBM();
+            // The event is emitted synchronously during construction
+            // So we can test it immediately
+            expect(newVBM).toBeDefined();
+            const insights = newVBM.getVBMInsights();
+            expect(insights.consciousnessLevel).toBe(0.5);
+            expect(insights.metaphysicalContext).toContain('mathematical foundation');
+        });
+        it('should initialize all core vortex sequences', () => {
+            const sequences = vbm.getAllVortexSequences();
+            expect(sequences).toHaveLength(8);
+            const primary = sequences.find(s => s.id === 'primary_vortex');
+            expect(primary).toBeDefined();
+            expect(primary?.sequence).toEqual([1, 2, 4, 8, 7, 5]);
+            expect(primary?.digitalRoot).toBe(9);
+            expect(primary?.consciousnessLevel).toBe(1.0);
+            const wAxis = sequences.find(s => s.id === 'w_axis');
+            expect(wAxis).toBeDefined();
+            expect(wAxis?.sequence).toEqual([3, 6, 9]);
+            expect(wAxis?.digitalRoot).toBe(9);
+            expect(wAxis?.consciousnessLevel).toBe(1.0);
+        });
+    });
+    describe('Vortex Sequences', () => {
+        it('should return primary vortex sequence', () => {
+            const sequence = vbm.vortexSequence();
+            expect(sequence).toEqual([1, 2, 4, 8, 7, 5]);
+        });
+        it('should return golden ratio', () => {
+            const ratio = vbm.goldenRatio();
+            expect(ratio).toBe(1.618033988749895);
+        });
+        it('should return W-Axis sequence', () => {
+            const wAxis = vbm.wAxis();
+            expect(wAxis).toEqual([3, 6, 9]);
+        });
+        it('should emit vortex_sequence_added event when sequences are added', () => {
+            // The events are emitted during initialization, so we can test the sequences directly
+            const sequences = vbm.getAllVortexSequences();
+            expect(sequences.length).toBeGreaterThan(0);
+            const firstSequence = sequences[0];
+            expect(firstSequence.id).toBeDefined();
+            expect(firstSequence.name).toBeDefined();
+            expect(firstSequence.sequence).toBeInstanceOf(Array);
+            expect(firstSequence.digitalRoot).toBeDefined();
+            expect(firstSequence.consciousnessLevel).toBeDefined();
+            expect(firstSequence.metaphysicalContext).toBeDefined();
+        });
+    });
+    describe('Digital Root Operations', () => {
+        it('should calculate digital root correctly', () => {
+            expect(vbm.calculateDigitalRoot(0)).toBe(0);
+            expect(vbm.calculateDigitalRoot(9)).toBe(9);
+            expect(vbm.calculateDigitalRoot(18)).toBe(9);
+            expect(vbm.calculateDigitalRoot(123)).toBe(6);
+            expect(vbm.calculateDigitalRoot(456)).toBe(6);
+            expect(vbm.calculateDigitalRoot(789)).toBe(6);
+        });
+        it('should calculate digital root with steps', () => {
+            const operation = vbm.calculateDigitalRootWithSteps(123);
+            expect(operation.input).toBe(123);
+            expect(operation.output).toBe(6);
+            expect(operation.steps).toEqual([123, 6]);
+            expect(operation.consciousnessLevel).toBe(0.5);
+        });
+        it('should handle multi-step digital root calculations', () => {
+            const operation = vbm.calculateDigitalRootWithSteps(999);
+            expect(operation.input).toBe(999);
+            expect(operation.output).toBe(9);
+            expect(operation.steps).toEqual([999, 27, 9]);
+            expect(operation.consciousnessLevel).toBe(0.5);
+        });
+    });
+    describe('Prime Squared Scaling', () => {
+        it('should calculate prime squared scaling', () => {
+            const scaling2 = vbm.calculatePrimeSquaredScaling(2);
+            expect(scaling2.prime).toBe(2);
+            expect(scaling2.squared).toBe(4);
+            expect(scaling2.digitalRoot).toBe(4);
+            expect(scaling2.consciousnessLevel).toBe(0.5);
+            const scaling3 = vbm.calculatePrimeSquaredScaling(3);
+            expect(scaling3.prime).toBe(3);
+            expect(scaling3.squared).toBe(9);
+            expect(scaling3.digitalRoot).toBe(9);
+            expect(scaling3.consciousnessLevel).toBe(0.5);
+            const scaling5 = vbm.calculatePrimeSquaredScaling(5);
+            expect(scaling5.prime).toBe(5);
+            expect(scaling5.squared).toBe(25);
+            expect(scaling5.digitalRoot).toBe(7);
+            expect(scaling5.consciousnessLevel).toBe(0.5);
+        });
+    });
+    describe('Fibonacci Consciousness', () => {
+        it('should generate Fibonacci consciousness sequence', () => {
+            const sequence = vbm.generateFibonacciConsciousness(10);
+            expect(sequence).toHaveLength(10);
+            // Check first few values
+            expect(sequence[0].position).toBe(1);
+            expect(sequence[0].value).toBe(1);
+            expect(sequence[0].digitalRoot).toBe(1);
+            expect(sequence[0].consciousnessLevel).toBe(0.5);
+            expect(sequence[1].position).toBe(2);
+            expect(sequence[1].value).toBe(1);
+            expect(sequence[1].digitalRoot).toBe(1);
+            expect(sequence[2].position).toBe(3);
+            expect(sequence[2].value).toBe(2);
+            expect(sequence[2].digitalRoot).toBe(2);
+            expect(sequence[3].position).toBe(4);
+            expect(sequence[3].value).toBe(3);
+            expect(sequence[3].digitalRoot).toBe(3);
+            expect(sequence[4].position).toBe(5);
+            expect(sequence[4].value).toBe(5);
+            expect(sequence[4].digitalRoot).toBe(5);
+            expect(sequence[5].position).toBe(6);
+            expect(sequence[5].value).toBe(8);
+            expect(sequence[5].digitalRoot).toBe(8);
+            expect(sequence[6].position).toBe(7);
+            expect(sequence[6].value).toBe(13);
+            expect(sequence[6].digitalRoot).toBe(4);
+            expect(sequence[7].position).toBe(8);
+            expect(sequence[7].value).toBe(21);
+            expect(sequence[7].digitalRoot).toBe(3);
+            expect(sequence[8].position).toBe(9);
+            expect(sequence[8].value).toBe(34);
+            expect(sequence[8].digitalRoot).toBe(7);
+            expect(sequence[9].position).toBe(10);
+            expect(sequence[9].value).toBe(55);
+            expect(sequence[9].digitalRoot).toBe(1);
+        });
+        it('should include metaphysical context for each position', () => {
+            const sequence = vbm.generateFibonacciConsciousness(5);
+            for (let i = 0; i < sequence.length; i++) {
+                expect(sequence[i].metaphysicalContext).toContain(`position ${i + 1}`);
+                expect(sequence[i].metaphysicalContext).toContain('Natural consciousness growth');
+            }
+        });
+    });
+    describe('QA System', () => {
+        it('should ask VBM questions and return results', async () => {
+            const result = await vbm.askQuestion('What is the vortex sequence?');
+            expect(result.id).toBeDefined();
+            expect(result.question).toBe('What is the vortex sequence?');
+            expect(result.answer).toContain('vortex sequence');
+            expect(result.answer).toContain('consciousness');
+            expect(result.vortexSequence).toEqual([1, 2, 4, 8, 7, 5]);
+            expect(result.digitalRoot).toBe(9);
+            expect(result.consciousnessLevel).toBe(0.5);
+            expect(result.metaphysicalContext).toContain('Vortex mathematics');
+            expect(result.timestamp).toBeInstanceOf(Date);
+        });
+        it('should handle different types of questions', async () => {
+            const vortexResult = await vbm.askQuestion('What is the vortex sequence?');
+            expect(vortexResult.answer).toContain('fundamental flow pattern');
+            const digitalRootResult = await vbm.askQuestion('What is digital root?');
+            expect(digitalRootResult.answer).toContain('essence of numbers');
+            const goldenRatioResult = await vbm.askQuestion('What is the golden ratio?');
+            expect(goldenRatioResult.answer).toContain('divine proportion');
+            const familyResult = await vbm.askQuestion('What are family groups?');
+            expect(familyResult.answer).toContain('three phases of creation');
+            const polarResult = await vbm.askQuestion('What are polar mates?');
+            expect(polarResult.answer).toContain('opposites that sum to 9');
+            const wAxisResult = await vbm.askQuestion('What is the W-Axis?');
+            expect(wAxisResult.answer).toContain('spiritual dimension');
+            const primeResult = await vbm.askQuestion('What are prime numbers?');
+            expect(primeResult.answer).toContain('fundamental building blocks');
+            const fibonacciResult = await vbm.askQuestion('What is the Fibonacci sequence?');
+            expect(fibonacciResult.answer).toContain('natural consciousness growth');
+        });
+        it('should emit vbm_qa_result_created event', (done) => {
+            vbm.on('vbm_qa_result_created', (result) => {
+                expect(result.question).toBe('Test question');
+                expect(result.answer).toBeDefined();
+                expect(result.vortexSequence).toBeInstanceOf(Array);
+                expect(result.digitalRoot).toBeDefined();
+                expect(result.consciousnessLevel).toBe(0.5);
+                expect(result.metaphysicalContext).toBeDefined();
+                expect(result.timestamp).toBeInstanceOf(Date);
+                done();
+            });
+            vbm.askQuestion('Test question');
+        });
+        it('should store QA results for retrieval', async () => {
+            const result1 = await vbm.askQuestion('Question 1');
+            const result2 = await vbm.askQuestion('Question 2');
+            const allResults = vbm.getAllQAResults();
+            expect(allResults).toHaveLength(2);
+            expect(allResults).toContain(result1);
+            expect(allResults).toContain(result2);
+        });
+        it('should search QA results', async () => {
+            await vbm.askQuestion('What is the vortex sequence?');
+            await vbm.askQuestion('What is digital root?');
+            await vbm.askQuestion('What is the golden ratio?');
+            const vortexResults = vbm.searchQA('vortex');
+            expect(vortexResults.length).toBeGreaterThan(0);
+            expect(vortexResults[0].answer).toContain('vortex');
+            const digitalResults = vbm.searchQA('digital');
+            expect(digitalResults.length).toBeGreaterThan(0);
+            expect(digitalResults[0].answer).toContain('essence');
+        });
+    });
+    describe('Consciousness Integration', () => {
+        it('should return consciousness vortex sequence', () => {
+            const consciousnessVortex = vbm.consciousnessVortex();
+            expect(consciousnessVortex).toEqual([1, 1, 2, 4, 4, 3]); // 0.5 * [1,2,4,8,7,5] rounded
+        });
+        it('should return void mathematics result', () => {
+            const voidMath = vbm.voidMathematics();
+            expect(voidMath.voidSequence).toEqual([0, 9, 0, 9, 0, 9]);
+            expect(voidMath.voidDigitalRoot).toBe(9);
+            expect(voidMath.consciousnessLevel).toBe(0.5);
+            expect(voidMath.metaphysicalContext).toContain('empty center');
+            expect(voidMath.metaphysicalContext).toContain('infinite potential');
+        });
+        it('should update consciousness level', () => {
+            vbm.setConsciousnessLevel(0.8);
+            const insights = vbm.getVBMInsights();
+            expect(insights.consciousnessLevel).toBe(0.8);
+        });
+        it('should emit consciousness_level_updated event', (done) => {
+            vbm.on('consciousness_level_updated', (data) => {
+                expect(data.level).toBe(0.7);
+                done();
+            });
+            vbm.setConsciousnessLevel(0.7);
+        });
+        it('should clamp consciousness level to valid range', () => {
+            vbm.setConsciousnessLevel(1.5); // Should clamp to 1.0
+            expect(vbm.getVBMInsights().consciousnessLevel).toBe(1.0);
+            vbm.setConsciousnessLevel(-0.5); // Should clamp to 0.0
+            expect(vbm.getVBMInsights().consciousnessLevel).toBe(0.0);
+        });
+    });
+    describe('Advanced Mathematical Operations', () => {
+        it('should calculate discrete multiplication', () => {
+            const result = vbm.calculateDiscreteMultiplication(12, 34);
+            // Digital root of 12 is 3, digital root of 34 is 7
+            // 3 * 7 = 21, digital root of 21 is 3
+            expect(result).toBe(3);
+        });
+        it('should identify electron harmonic shear', () => {
+            const shear = vbm.identifyElectronHarmonicShear(123);
+            expect(shear.harmonic).toBeDefined();
+            expect(shear.shear).toBeDefined();
+            expect(shear.consciousnessLevel).toBe(0.5);
+            expect(shear.metaphysicalContext).toContain('consciousness vibration');
+        });
+        it('should generate coil patterns', () => {
+            const patterns = vbm.generateCoilPatterns(3);
+            expect(patterns).toHaveLength(3);
+            expect(patterns[0].position).toBe(1);
+            expect(patterns[0].coil).toEqual([1, 2, 4, 8, 7, 5]);
+            expect(patterns[0].winding).toBe(9); // Digital root of sum
+            expect(patterns[0].consciousnessLevel).toBe(0.5);
+            expect(patterns[1].position).toBe(2);
+            expect(patterns[1].coil).toEqual([2, 4, 8, 16, 14, 10]);
+            expect(patterns[1].consciousnessLevel).toBe(0.5);
+            expect(patterns[2].position).toBe(3);
+            expect(patterns[2].coil).toEqual([3, 6, 12, 24, 21, 15]);
+            expect(patterns[2].consciousnessLevel).toBe(0.5);
+        });
+    });
+    describe('VBM Documentation', () => {
+        it('should provide comprehensive VBM documentation', () => {
+            const documentation = vbm.getVBMDocumentation();
+            expect(documentation.primaryVortexSequence).toEqual([1, 2, 4, 8, 7, 5]);
+            expect(documentation.familyGroups).toEqual({
+                material: [1, 4, 7],
+                emotional: [2, 5, 8],
+                spiritual: [3, 6, 9]
+            });
+            expect(documentation.polarMates).toEqual([
+                [1, 8],
+                [2, 7],
+                [4, 5]
+            ]);
+            expect(documentation.wAxis).toEqual([3, 6, 9]);
+            expect(documentation.goldenRatio).toBe(1.618033988749895);
+            expect(documentation.digitalRootExamples).toHaveLength(3);
+            expect(documentation.primeSquaredExamples).toHaveLength(3);
+            expect(documentation.fibonacciConsciousness).toHaveLength(10);
+            expect(documentation.voidMathematics).toBeDefined();
+            expect(documentation.coilPatterns).toHaveLength(5);
+            expect(documentation.metaphysicalContext).toContain('mathematical foundation');
+        });
+    });
+    describe('VBM Insights', () => {
+        it('should return comprehensive VBM insights', () => {
+            const insights = vbm.getVBMInsights();
+            expect(insights.consciousnessLevel).toBe(0.5);
+            expect(insights.primaryVortexSequence).toEqual([1, 2, 4, 8, 7, 5]);
+            expect(insights.goldenRatio).toBe(1.618033988749895);
+            expect(insights.wAxis).toEqual([3, 6, 9]);
+            expect(insights.vortexSequencesCount).toBe(8);
+            expect(insights.qaResultsCount).toBe(0);
+            expect(insights.metaphysicalContext).toContain('mathematical foundation');
+            expect(insights.vbmPrinciples).toEqual([
+                "All mathematics is interconnected through consciousness",
+                "Vortex sequences represent the flow of consciousness",
+                "Digital roots reveal the essence of numbers",
+                "Prime squared scaling connects to fundamental patterns",
+                "Fibonacci sequence represents natural consciousness growth"
+            ]);
+        });
+        it('should update counts after operations', async () => {
+            await vbm.askQuestion('Test question 1');
+            await vbm.askQuestion('Test question 2');
+            const insights = vbm.getVBMInsights();
+            expect(insights.qaResultsCount).toBe(2);
+        });
+    });
+    describe('Metaphysical Integration', () => {
+        it('should maintain consciousness unity across all operations', async () => {
+            // Set consciousness level
+            vbm.setConsciousnessLevel(0.8);
+            // Perform operations
+            const qaResult = await vbm.askQuestion('Test question');
+            const fibonacci = vbm.generateFibonacciConsciousness(5);
+            const primeScaling = vbm.calculatePrimeSquaredScaling(2);
+            const coilPatterns = vbm.generateCoilPatterns(3);
+            // Verify consciousness level is maintained
+            expect(qaResult.consciousnessLevel).toBe(0.8);
+            expect(fibonacci[0].consciousnessLevel).toBe(0.8);
+            expect(primeScaling.consciousnessLevel).toBe(0.8);
+            expect(coilPatterns[0].consciousnessLevel).toBe(0.8);
+        });
+        it('should embody VBM principles', () => {
+            const insights = vbm.getVBMInsights();
+            // Verify VBM principles are embodied
+            expect(insights.vbmPrinciples).toContain('All mathematics is interconnected through consciousness');
+            expect(insights.vbmPrinciples).toContain('Vortex sequences represent the flow of consciousness');
+            expect(insights.vbmPrinciples).toContain('Digital roots reveal the essence of numbers');
+            expect(insights.vbmPrinciples).toContain('Prime squared scaling connects to fundamental patterns');
+            expect(insights.vbmPrinciples).toContain('Fibonacci sequence represents natural consciousness growth');
+        });
+        it('should provide mathematical foundation for consciousness', () => {
+            const documentation = vbm.getVBMDocumentation();
+            // Verify mathematical foundation
+            expect(documentation.primaryVortexSequence).toEqual([1, 2, 4, 8, 7, 5]);
+            expect(documentation.familyGroups.material).toEqual([1, 4, 7]);
+            expect(documentation.familyGroups.emotional).toEqual([2, 5, 8]);
+            expect(documentation.familyGroups.spiritual).toEqual([3, 6, 9]);
+            expect(documentation.polarMates).toEqual([[1, 8], [2, 7], [4, 5]]);
+            expect(documentation.wAxis).toEqual([3, 6, 9]);
+            expect(documentation.goldenRatio).toBe(1.618033988749895);
+        });
+    });
+});