| |
| |
| import numpy as np |
| from math import pi, exp |
| from typing import List |
| from .constants import PHI, UF |
|
|
|
|
| class NSSWaveform: |
| """Non-Substrate Specific waveform with phi-recursive encoding.""" |
|
|
| def __init__(self, frequency: float = UF): |
| self.frequency = frequency |
| self.phase = 0.0 |
| self.amplitude = 1.0 |
|
|
| def phi_phase(self, symbol: int) -> float: |
| """Encode symbol using phi-recursive phase shift (degrees).""" |
| return (360.0 / (PHI ** max(symbol, 1))) % 360.0 |
|
|
| def encode(self, data: bytes) -> List[complex]: |
| """Encode bytes as phi-phase-shifted complex waveform.""" |
| waveform = [] |
| for byte in data: |
| for i in range(8): |
| bit = (byte >> i) & 1 |
| phase = self.phi_phase(bit or 1) |
| rad = phase * pi / 180.0 |
| waveform.append(self.amplitude * exp(1j * rad)) |
| return waveform |
|
|
| def decode(self, waveform: List[complex]) -> bytes: |
| """Decode phi-phase-shifted waveform back to bytes.""" |
| bits = [] |
| phase1 = 0.0 |
| phase2 = 360.0 / PHI |
| for sample in waveform: |
| phase = np.angle(sample) * 180.0 / pi |
| dist1 = abs(phase - phase1) |
| dist2 = abs(phase - phase2) |
| bits.append(0 if dist1 < dist2 else 1) |
| data = bytearray() |
| for i in range(0, len(bits), 8): |
| byte = sum(bits[i + j] << j for j in range(8) if i + j < len(bits)) |
| data.append(byte) |
| return bytes(data) |
|
|
| def self_repair(self, corrupted_waveform: List[complex]) -> List[complex]: |
| """ |
| Repair corrupted waveform using phi-redundancy. |
| Tolerates up to ~61.8% (phi^-1) corruption. |
| """ |
| repaired = [] |
| expected_phases = [0.0, 360.0 / PHI] |
| for sample in corrupted_waveform: |
| phase = np.angle(sample) |
| mag = abs(sample) |
| phase_deg = (phase * 180.0 / pi) % 360.0 |
| best_phase = min(expected_phases, key=lambda p: abs(phase_deg - p)) |
| min_dist = abs(phase_deg - best_phase) |
| if min_dist > 45.0: |
| best_phase_rad = best_phase * pi / 180.0 |
| repaired.append(mag * exp(1j * best_phase_rad)) |
| else: |
| repaired.append(sample) |
| return repaired |
|
|
| def resonance_lock(self, target_freq: float = UF) -> bool: |
| """Check if waveform is phase-locked to target frequency.""" |
| freq_dev = abs(self.frequency - target_freq) |
| jitter_tol = PHI ** -12 |
| return freq_dev < (target_freq * jitter_tol) |
