@uor-foundation/operators
Version:
Layer 3: Arithmetic operators - operations as chemical reactions between numbers
145 lines • 5.37 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AdditionOperator = void 0;
const field_substrate_1 = require("@uor-foundation/field-substrate");
/**
* Addition as field merger - creates field superposition
* The fields don't simply combine - they interfere and transform
*/
class AdditionOperator {
constructor(substrate, resonance, topology) {
this.substrate = substrate;
this.resonance = resonance;
this.topology = topology;
}
/**
* Add two numbers - field merger with interference
*/
add(a, b) {
const sum = a + b;
// Get field patterns
const patternA = this.substrate.getFieldPattern(a);
const patternB = this.substrate.getFieldPattern(b);
const patternSum = this.substrate.getFieldPattern(sum);
// Calculate resonances
const resonanceA = this.resonance.calculateResonance(a);
const resonanceB = this.resonance.calculateResonance(b);
const resonanceSum = this.resonance.calculateResonance(sum);
// Get page information
const locationA = this.topology.locateNumber(a);
const locationB = this.topology.locateNumber(b);
const locationSum = this.topology.locateNumber(sum);
// Analyze field merger
const fieldMerger = this.analyzeFieldMerger(patternA, patternB, patternSum);
return {
operation: 'addition',
operands: [a, b],
result: sum,
fieldAnalysis: {
operandPatterns: [patternA, patternB],
resultPattern: patternSum,
fieldTransitions: fieldMerger,
},
resonanceAnalysis: {
operandResonances: [resonanceA, resonanceB],
resultResonance: resonanceSum,
energyRedistribution: resonanceSum - (resonanceA + resonanceB),
},
topologicalAnalysis: {
operandPages: [locationA.page, locationB.page],
resultPage: locationSum.page,
crossedBoundary: locationA.page !== locationSum.page || locationB.page !== locationSum.page,
},
};
}
/**
* Analyze how fields merge during addition
*/
analyzeFieldMerger(patternA, patternB, patternSum) {
const transitions = [];
for (let i = 0; i < field_substrate_1.FIELD_COUNT; i++) {
const activeInA = patternA[i];
const activeInB = patternB[i];
const activeInSum = patternSum[i];
// Determine transition type
let transitionType;
if (activeInA && activeInB && activeInSum) {
transitionType = 'preserved';
}
else if (!activeInA && !activeInB && activeInSum) {
transitionType = 'created';
}
else if ((activeInA || activeInB) && !activeInSum) {
transitionType = 'destroyed';
}
else {
transitionType = 'transformed';
}
transitions.push({
field: i,
beforeA: activeInA,
beforeB: activeInB,
after: activeInSum,
type: transitionType,
});
}
return transitions;
}
/**
* Perform modular addition
*/
addModulo(a, b, modulus) {
const standardResult = this.add(a, b);
const modularSum = (a + b) % modulus;
// Analyze the modular reduction
const patternModular = this.substrate.getFieldPattern(modularSum);
const resonanceModular = this.resonance.calculateResonance(modularSum);
return {
...standardResult,
modulus,
modularResult: modularSum,
modularFieldPattern: patternModular,
modularResonance: resonanceModular,
reductionOccurred: standardResult.result !== modularSum,
};
}
/**
* Chain multiple additions and track field evolution
*/
addChain(numbers) {
if (numbers.length === 0) {
throw new Error('Cannot perform chain addition on empty array');
}
const steps = [];
let accumulator = numbers[0];
for (let i = 1; i < numbers.length; i++) {
const result = this.add(accumulator, numbers[i]);
steps.push(result);
accumulator = result.result;
}
// Analyze overall field evolution
const initialPattern = this.substrate.getFieldPattern(numbers[0]);
const finalPattern = this.substrate.getFieldPattern(accumulator);
return {
operation: 'addition-chain',
operands: numbers,
finalResult: accumulator,
steps,
fieldEvolution: {
initial: initialPattern,
final: finalPattern,
totalTransitions: this.countTransitions(steps),
},
};
}
/**
* Count total field transitions in a chain
*/
countTransitions(steps) {
return steps.reduce((total, step) => {
return (total + step.fieldAnalysis.fieldTransitions.filter((t) => t.type !== 'preserved').length);
}, 0);
}
}
exports.AdditionOperator = AdditionOperator;
//# sourceMappingURL=addition.js.map