@sschepis/resolang/dist/dsl/math.js

ResoLang - Core quantum resonance computation library for browser and Node.js

// ResoLang Math Utilities - Complex and Quaternion operations
// Complex number operations
export function createComplex(real, imag = 0) {
    return { real, imag };
}
export function complexMagnitude(c) {
    return Math.sqrt(c.real * c.real + c.imag * c.imag);
}
export function complexPhase(c) {
    return Math.atan2(c.imag, c.real);
}
// Quaternion operations
export function createQuaternion(position = [0, 0, 0], amplitude = 1, gaussian = [0, 0], eisenstein = [0, 0]) {
    return {
        position,
        amplitude: typeof amplitude === 'number' ? createComplex(amplitude) : amplitude,
        gaussian,
        eisenstein,
    };
}
// Resonance calculations
export function computeResonance(prime1, prime2, strength = 1.0) {
    const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
    const lcm = (prime1 * prime2) / gcd(prime1, prime2);
    const resonanceStrength = strength * (1 - 1 / Math.log(lcm + 1));
    const phase = (2 * Math.PI * prime1) / prime2;
    return {
        strength: resonanceStrength,
        primes: [prime1, prime2],
        phase,
    };
}
export function computeResonanceVector(state, eigen) {
    const magState = complexMagnitude(state.amplitude);
    const magEigen = complexMagnitude(eigen.amplitude);
    if (magState === 0 || magEigen === 0)
        return 0;
    // Dot product of position vectors
    const dotPos = state.position[0] * eigen.position[0] +
        state.position[1] * eigen.position[1] +
        state.position[2] * eigen.position[2];
    // Cosine similarity of amplitudes (simplified phase alignment)
    const phaseDiff = Math.abs(complexPhase(state.amplitude) - complexPhase(eigen.amplitude));
    const alignment = Math.max(0, Math.cos(phaseDiff));
    return (alignment + Math.abs(dotPos)) / 2;
}
export function computeEntropy(state) {
    const mag = complexMagnitude(state.amplitude);
    const pos = Math.sqrt(state.position[0] ** 2 + state.position[1] ** 2 + state.position[2] ** 2);
    return -Math.log(mag + 0.001) + pos * 0.1;
}
export function measureCoherence(state) {
    const mag = complexMagnitude(state.amplitude);
    const phase = complexPhase(state.amplitude);
    const gaussianMag = Math.sqrt(state.gaussian[0] ** 2 + state.gaussian[1] ** 2);
    return Math.min(1, mag * (1 + Math.cos(phase)) * (1 - gaussianMag * 0.1));
}
export function computeEnergy(state) {
    const mag = complexMagnitude(state.amplitude);
    return mag * mag;
}
//# sourceMappingURL=math.js.map