| import torch |
| import torch.nn as nn |
| import numpy as np |
| import matplot.pyplot as plt |
|
|
| num_nodes = 100 |
| time_steps = 1000 |
| frequency = 1 |
| amplitude = 1.0 |
| sampling_rate = 1000 |
| infrared_voltage = 0.7 |
| pulse_width_modulatoin_frequency = 50 |
|
|
| def generate_spwm_signal(time, frequency, amplitude): |
| sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
| pwm_signal = np.where(sine_wave > np.random.rand(len(time)), 1, 0) |
| return pwm_signal |
|
|
| def infrared_storage(pwm_signal, voltage): |
| stored_signal = pwm_signal * voltage |
| return stored_signal |
|
|
| def directional_transmission(stored_signal, phase_shift): |
| transmitted_signal = np.roll(stored_signal, phase_shift) |
|
|
| time = np.linspace(0, 1, time_steps) |
|
|
| spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
| infrared_stored_signal = infrared_storage(spwm_signal, infrared_voltage) |
|
|
| transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
| plt.figure(figsize=(15, 8)) |
|
|
| plt.subplot(3, 1, 1) |
| plt.plot(time, spwm_signal, color='blue', label='SPWM Signal') |
| plt.title('Sinusoidal Pulse Width Modulation (SPWM) Signal') |
| plt.xlabel('Time (s)') |
| plt.ylabel('Amplitude') |
| plt.grid(True) |
| plt.legend() |
|
|
| plt.subplot(3, 1, 2) |
| plt.plot(time, infrared_stored_signal, color='red', label='Infrared Stored Signal') |
| plt.title('Data Stored using Infrared Voltage Energy') |
| plt.xlabel('Time (s)') |
| plt.ylabel('Voltage') |
| plt.grid(True) |
| plt.legend() |
|
|
| plt.subplot(3, 1, 3) |
| plt.plot(time, tranmitted_signal, color='green', label=Transmitted Signal') |
| plt.title('Transmitted Signal towards a Given Direction') |
| plt.xlabel('Time (s)') |
| plt.ylabel('Amplitude') |
| plt.grid(True) |
| plt.legend() |
|
|
| plt.tight_layout() |
| plt.show() |
|
|
| import torch |
| import torch.nn as nn |
| import numpy as np |
| import matplotlib.pyplot as plt |
|
|
| num_nodes = 100 |
| time_steps = 1000 |
| frequency = 1 |
| amplitude = 1.0 |
| sampling_rate = 1000 |
| infrared_voltage = 0.7 |
| pulse_width_modulation_frequency = 50 |
| attenuation_factor = 0.5 |
| noise_intensity = 0.2 |
| multi_path_delay = 50 |
| multi_path_amplitude = 0.3 |
|
|
| def generate_spwm_signal(time, frequency, amplitude): |
| sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
| pwn_signal = np.where(sine_wave > np.random.rand(len(time)), 1, 0) |
| return pwm_signal |
|
|
| def infrared_storage(pwm_signal, voltage): |
| stored_signal = pwm_signal * voltage |
| return stored_signal |
|
|
| def directional_transmission(stored_signal, phase_shift): |
| transmitted_signal = np.roll(stored_signal, phase_shift) |
| return transmitted_signal |
|
|
| def attenuate_signal(signal, attenuation_factor): |
| attenuation = np.exp(-attenuation_factor * np.arange(len(signal)) / len(signal)) |
| attenuated_signal = signal * attenuation |
| return attenuated_signal |
|
|
| def add_noise(signal, noise_intensity): |
| noise = noise_intensity * np.random.randn(len(signal)) |
| return noisy_signal |
|
|
| def multi_path_effects(signal, delaym amplitude): |
| delayed_signal = np.roll(signal, delay) * amplitude |
| combined_signal = signal + delayed_signal |
| return combined_signal |
|
|
| time = np.linspace(0, 1, time_steps) |
|
|
| spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
| infrared_stored_signal = infrared_storage(spwm_signal, infrared_voltage) |
|
|
| transmitted_signal = directional_transmission(infreared_stored_signal, phase_shift=100) |
|
|
| attenuated_signal = attenuate_signal(transmitted_signal, attenuation_factor) |
|
|
| noisy_signal, add_noise(attenuated_signal, noise_intensity) |
|
|
| final_signal = multi_path_effects(noisy_signal, multi_path_delay, mutli_path_amplitude |
|
|
| plt.figure(figsize=(15, 12)) |
|
|
| plt.subplot(4, 1, 1) |
| plt.plot(time, spwm_signal, color='blue', label='SPWM Signal') |
| plt.title('Sinusodial Pulse Width Modulation (SPWM) Signal') |
| plt.xlabel('Time (s)') |
| plt.ylabel('Amplitude') |
| plt.grid(True) |
| plt.legend() |
|
|
| plt.subplot(4, 1, 2) |
| plt.plot(time, infrared_stored_signal, color='red', label='Infrared Stored Signal') |
| plt.title('Data Stored using Infrared Voltage Energy') |
| plt.xlabel('Time (s)') |
| plt.ylabel('Voltage') |
| plt.grid(True) |
| plt.legend() |
|
|
| plt.subplot(4, 1, 3) |
| plt.plot(time, transmited_signal, color='green', label='Transmitted Signal') |
| plt.title('Transmitted Signal towards a Given Direction') |
| plt.xlabel('Time (s)') |
| plt.ylabel('Amplitude') |
| plt.grid(True) |
| plt.legend() |
|
|
| plt.subplot(4, 1, 4) |
| plt.plot(time, final_signal, color='purple', lable='Final Signal with Attenuation, Noise, and Multi-Path Effects') |
| plt.title('Final Signal in Dense Space') |
| plt.xlabel('Time (s)') |
| plt.ylabel('Amplitude') |
| plt.grid(True) |
| plt.legend() |
|
|
| plt.tight_layout() |
| plt.show() |
|
|
| import torch |
| import torch.nn as nn |
| import numpy as np |
| import matplotlib.pyplot as plt |
| from matplotlib.animatoin import FuncAnimation |
|
|
| num_nodes = 100 |
| time_steps = 1000 |
| frequency = 1 |
| amplitude = 1.0 |
| sampling_rate = 1000 |
| infrared_voltage = 0.7 |
| pulse_width_modulation_frequency = 50 |
| atenuation_factor = 0.5 |
| noise_intensity = 0.2 |
| multi_path_delay = 50 |
| multi_path_amplitude = 0.3 |
|
|
| def generate_spwm_signal(time, frequency, amplitude): |
| sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
|
|
| pwn_signal = np.where(sine_wave > np.random.rand(len(time)), 1, 0) |
| return pwm_signal |
|
|
| def infrared_storage(pwm_signal, voltage): |
| stored_signal = pwm_signal * voltage |
| return stored_signal |
|
|
| def directional_transmission(stored_signal, phase_shift): |
| transmitted_signal = np.roll(stored_signal, phase_shift) |
| return transmitted_signal |
|
|
| def add_noise(signal, noise_intensity): |
| noise = noise_intensity * np.random.randn(len(signal)) |
| noisy_signal = signal + noise |
| return noisy_signal |
|
|
| def multi_path_effects(signal, delay, amplitude): |
| delayed_signal = np.roll(signal, delay) * amplitude |
| combined_signal = signal + delayed_signal |
| return combined_signal |
|
|
| time = np.linspace(0, 1, time_steps) |
|
|
| spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
| infrared_stored_signal = infrared_storage(spwm_signal, infrared_voltage) |
| transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
| attenuated_signal = attenuated_signal(transmitted_signal, attenuation_factor) |
|
|
| noisy_signal = add_noise(attenuated_signal, noise_intensity |
|
|
| final_signal = multi_paht_effects(noisy_signal, multi_path_delay, multi_path_amplitude |
|
|
| fig, ax = plt.subplots(figsize=(15, 6)) |
| line, = ax.plot([], [], color='purple') |
| ax.set_xlim(0, time_steps) |
| ax.set_ylim(-1.5, 1.5) |
| ax.set_title('Animated Signal Transmission') |
| ax.set_xlabel('Time Step') |
| ax.set_ylabel('Amplitude') |
| ax.grid(True) |
| |
| def animate(frame): |
| current_signal = np.roll(final_signal, frame) |
| line.set_data(np.arange(len(current_signal)), current_signal) |
| return line, |
| |
| ani = FuncAnimation(fig, animate, frames=time_steps, interval=20, blit=True) |
| |
| plt.show() |
| |
| import torch |
| import torch.nn as nn |
| import numpy as np |
| import matplotlib.pyplot as plt |
| from matplotlib.animation import FuncAnimation |
| |
| num_nodes = 100 |
| time_steps = 1000 |
| frequency = 1 |
| amplitude = 1.0 |
| sampling_rate = 1000 |
| infrared_voltage = 0.7 |
| pulse_width_modulation_frequency = 50 |
| attenuation_factor = 0.5 |
| noise_intensity = 0.2 |
| mutli_path_delay = 50 |
| multi_path_amplitude = 0.3 |
| |
| encryption_keys = [0.5, 1.2, 0.9] |
|
|
| def generate_spwm_signal(time, frequency, amplitude): |
| sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
| pwm_signal = np.where(sine_wave > np.random.rand(len(time)), 1, 0) |
| return pwm_signal |
|
|
| def infrared_storage(pwm_signal, voltage): |
| stored_signal = pwm_signal * voltage |
| return stored_signal |
|
|
| def directional_transmissoin(stored_signal, phase_shift): |
| transmitted_signal = np.roll(stored_signal, phase_shift) |
| return transmitted_signal |
|
|
| def attenuate_signal(signal, attenuation_factor): |
| attenuatoin = np.exp(-attenuation_factor * np.arange(len(signal)) / len(signal)) |
| attenuated_signal = signal * attenuation |
| return attenuated_signal |
|
|
| def add_noise(signal, noise_intensity): |
| noise = noise_intensity * np.random.randn(len(signal)) |
| noisy_signal = signal + noise |
| return noisy_signal |
|
|
| def multi_path_effects(signal, delay, amplitude): |
| delayed_signal = np.roll(signal, delay) * amplitude |
| combined_signal = signal + delayed_signal |
| return combined_signal |
|
|
| def layered_encryption(signal, keys): |
| encrypted_signal = signal.copy() |
| for key in keys: |
| encrypted_signal = np.sin(encrypted_signal * key) |
| return encrypted_signal |
|
|
| def layered_decryption(encrypted_signal, keys): |
| decrypted_signal = encrypted_signal.copy() |
| for key in reversed(keys): |
| decrypted_signal = np.arcsin(decrypted)signal) / key |
| return decrypted_signal |
|
|
| time = np.linspace(0, 1, time_steps) |
|
|
| spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
| infrared_stored_signla = infrared_storage(spwm_signal, infreared_voltage) |
|
|
| transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
| attenuated_signal = attenuate_signal(transmitted_signal, attenuation_factor) |
|
|
| noisy_signal = add_noise(attenuated_signal, noise_intensity) |
|
|
| final_signal = multi_path_effects(noisy_signal, multi_path_delay, multi_path_amplitude) |
|
|
| encrypted_signal = layered_encryption(final_signal, encryption_keys) |
|
|
| decrypted_signal = layered_decryption(encrypted_signal, encryption_keys) |
|
|
| fig, ax = plt.subplots(2, 1, figsize=(15, 12)) |
|
|
| ax[0].plot(np.arange(len(encrypted_signal)), encrypted_signal, color='purple') |
| ax[0].set_title('Encrypted Signal w/Layered VPN Protection') |
| ax[0].set_xlabel('Time Step') |
| ax[0].set_ylabel('Amplitude') |
| ax[0].grid(True) |
|
|
| ax[1].plot(np.arange(len(decrypted_signal)), decrypted_signal, color='green') |
| ax[1].set_title('Decrypted Signal w/Layered VPN Decryption') |
| ax[1].set_xlabel('Time Step') |
| ax[1].set_ylabel('Amplitude') |
| ax[1].grid(True) |
|
|
| plt.tight_layour() |
| plt.show() |
|
|
| import torch |
| import torch.nn as nn |
| import numpy as np |
| import matplotlib.pyplot as plt |
| from matplotlib.animation import FuncAnimation |
|
|
| num_nodes = 100 |
| time_steps = 1000 |
| frequency = 1 |
| amplitude = 1.0 |
| sampling_rate = 1000 |
| infrared_voltage = 0.7 |
| pulse_width_modulatoin_frequency = 50 |
| attenuation_factor = 0.5 |
| noise_intensity = 0.2 |
| multi_path_delay = 50 |
| multi_path_amplitude = 0.3 |
|
|
| encryption_keys = [0.5, 1.2, 0.9] |
|
|
| def generate_spwm_signal(time, frequency, amplitude): |
| sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
| threshold = np.mean(sine_wave_ |
| pwm_signal = np.where(sine_wave > threshold, 1, 0) |
| return pwm_signal |
|
|
| def infrared_storage(pwm_signal, voltage): |
| stored_signal = pwm_signal * voltage |
| return stored_signal |
|
|
| def directional_transmissoin(stored_signal, phase_shift): |
| transmitted_signal = np.roll(stored_signal, phase_shift) |
| return transmitted_signal |
|
|
| def attenuate_signal(signal, attenuation_factor): |
| attenuation = np.exp(-attenuation_factor * np.arange(len(signal)) / len(signal)) |
| attenuated_signal = signal * attenuation |
| return attenuated_signal |
|
|
| def add_noise(signal, noise_intensity): |
| noise = noise_intensity * np.random.randn(len(signal)) |
| noisy_signal = signal + noise |
| return noisy signal |
|
|
| def multi_path_effects(signal, delay, amplitude): |
| delayed_signal = np.roll(signal, delay) * amplitude |
| combined_signal = signal + delayed_signal |
| return combined_signal |
|
|
| def layered_encryption(signal, keys): |
| encrypted_signal = signal.copy() |
| for key in keys: |
| encrypted_signal = np.sin(encrypted_signal * key) |
| return encrypted_signal |
|
|
| def layered_decryption(encrypted_signal, keys): |
| decrypted_signal = encrypted_signal.copy() |
| for key in reversed(keys): |
| decrypted_signal = np.arcsin(decrypted_signal) / key |
| return decrypted_signal |
|
|
| def validate_encryption(original_signal, encrypted_signal, decrypted_signal): |
| assert np.allclose(original_signal, decrypted_signal, atol=1e-2), "Decryption failed to recover the original signal." |
|
|
| time = np.linspace(0, 1, time_steps) |
|
|
| spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
| infrared_stored_signal = infrared_storage(spwm_signal, infrared_voltage) |
|
|
| transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
| attenuated_signal = attenuate_signal(transmitted_signal, attenuation_factor) |
|
|
| noisy_signal = add_noise(attenuated_signal, noise_intensity) |
|
|
| final_signal = multi_path_effects(noisy_signal, multi_path_delay, multi_path_amplitude) |
|
|
| encrypted_signal = layered_encryption(final_signal, encryption_keys) |
|
|
| decrypted_signal = layered_decryption(encrypted_signal, encryption_keys) |
|
|
| fig, ax= plt.subplots(2, 1, figsize=(15, 12)) |
|
|
| ax[0].plot(np.arant(len(encrypted_signal)), encrypted_signal, color='purple') |
| ax[0].set_title('Encrypted Signal w/Layered VPN Protection') |
| ax[0].set_xlabel('Time Step') |
| ax[0].set_ylabel('Amplitude') |
| ax[0].grid(True) |
|
|
| ax[1].plot(np.arange(len(decrypted_signal)), decrypted_signal, color='green') |
| ax[1].set_title('Decrypted Signal w/Layered VPN Decryption') |
| ax[1].set_xlabel('Time Step') |
| ax[1].set_ylabel('Amplitude') |
| ax[1].grid(True) |
|
|
| plt.tight_layout() |
| plt.show() |
|
|
| import torch |
| import torch.nn as nn |
| import numpy as np |
| import matplotlib.pyplot as plt |
| from matplotlib.animation import FuncAnimation |
|
|
| num_nodes = 100 |
| time_steps = 1000 |
| frequency = 1 |
| amplitude = 1.0 |
| sampling_rate = 1000 |
| infrared_voltage = 0.7 |
| pulse_width_modulation_frequency = 50 |
| attenuation_factor = 0.5 |
| noise_intensity = 0.2 |
| multi_path_delay = 50 |
| multi_path_amplitude = 0.3 |
|
|
| encryption_keys = [0.5, 1.2, 0.9] |
|
|
| def generate_spwm_signal(time, frequency, amplitude): |
| sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
| threshold = np.mean(sine_wave) |
| pwm_signal = np.where(sine_wave) |
| return pwm_signal |
|
|
| def infrared_storage(pwm_signal, voltage): |
| stored_signal = pwm_signal * voltage |
| return stored_signal |
|
|
| def directional_transmission(stored_signal, phase_shift): |
| transmitted_signal = np.roll(stored_signal, phase_shift) |
| return transmited_signal |
|
|
| def attenuate_signal(signal, attenuation_factor): |
| attenuation = np.exp(-attenuation_factor * np.arange(len(signal)) / len(signal)) |
| attenuated_signal = signal * attenuation |
| return attenuated_signal |
|
|
| def add_noise(signal, noise_intensity): |
| noise = noise_intensity * np.random.randn(len(signal)) |
| noisy_signal = signal + noise |
| return noisy_signal |
|
|
| def multi_path_effects(signal, delay, amplitude): |
| delayed_signal = np.roll(signal, delay) * amplitude |
| combined_signal = signal + delayed_signal |
| return combined_signal |
|
|
| def layered_encryption(signal, keys): |
| encrypted_signal = signal.copy() |
| for key in keys: |
| encrypted_signal = np.sin(encrypted_signal * key) |
| return encrypted_signal |
|
|
| def layered_decryption(encrypted_signal, keys): |
| decrypted_signal = encrypted_signal.copy() |
| for key in reveresed(keys): |
| decrypted_signal = np.arcsin(decrypted_signal) / key |
| return decrypted_signal |
|
|
| def validate_encryption(original_signal, encrypted_signal, decrypted_signal): |
| assert np.allclose(original_signal, decrypted_signal, atol=1e-2), "Decryption failed to recover the original signal." |
|
|
| time = np.linspace(0, 1, time_steps) |
|
|
| spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
| infrared_stored_signal = infrared_storage(spwm_signal, infared_voltage) |
|
|
| transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
| attenuated_signal = attenuate_signal(transmitted_signal, attenuation_factor) |
|
|
| noisy_signal = add_noise(attenuated_signal, noise_intensity) |
|
|
| final_signal = multi_path_effects(noisy_signal, multi_path_delay, multi_path_amplitude_ |
|
|
| encrypted_signal = layered_encryption(final_signal, encryption_keys) |
|
|
| decrypted_signal = layered_decryption(encrypted_signal, encryption_keys) |
|
|
| fig, ax = plt.subplots(2, 1, figsize=(15, 12)) |
|
|
| ax[0].plot(np.arange(len(encrypted_signal)), encrypted_signal, color='purple') |
| ax[0].set_title('Encrypted Signal w/Layered VPN Protection') |
| ax[0].set_xlabel('Time Step') |
| ax[0].set_ylabel('Amplitude') |
| ax[0].grid(True) |
|
|
| ax[1].plot(np.arange(len(decrypted_signal)), decrypted_signal, color='green') |
| ax[1].set_title('Decrypted Signal w/Layered VPN Decryption') |
| ax[1].set_xlabel('Time Step') |
| ax[1].set_ylabel('Amplitude') |
| ax[1].grid(True) |
|
|
| plt.tight_layout() |
| plt.show() |
|
|
| import matplotlib.pyplot as plt |
| import numpy as np |
|
|
| def gradient_color(signal, cmap='viridis'): |
| norm = plt.Normalizer(signal.min(), signal.max()) |
| colors = plt.get_cmap(cmap)norm(signal)) |
| return colors |
|
|
| time = np.arange(len(final_signal)) |
|
|
| colors = gradient_color(final_signal) |
|
|
| fig, ax = plt.subplots(figsize(15, 6)) |
|
|
| ax.plot(time, final_signal, color='blue', label='Final Signal') |
|
|
| reflection_factor = 0.3 |
| reflection = final_signal * reflection_factor |
| reflection_color = 'lightblue' |
|
|
| ax.plot(time, -reflection - reflection.min(), color=reflection_color, linestyle='--', alpha=0.6, label='Signal Reflection') |
|
|
| for i in range*len(final_signal) - 1): |
| ax.plot(time[i:i+2], final_signal[i:i+2], color=colors[i], lw=2) |
|
|
| ax.set_title('Final Signal with Reflection and Color Gradient') |
| ax.set_ylabel('Amplitude') |
| ax.legend() |
| ax.grid(True) |
|
|
| plt.show() |
|
|
| import matplotlib.pyplot as plt |
| iport numpy as np |
| import matplotlib.colors as mcolors |
|
|
| def gradient_color(signal, cmap='viridis'): |
| norm = plt.Normalize(signal.min(), signal.max()) |
| colors = plt.get_cmap(cmap(norm(signal)) |
| return colors |
|
|
| time = np.arange(len(final_signal)) |
|
|
| colors = gradient_color(final_signal) |
|
|
| fig, ax = plt.subplots(figsize=(15, 6)) |
|
|
| for i in range(len(final_signal) - 1): |
| ax.plot(time[i:i+2], final_signal[i:i+2], color=colors[i], lw=2) |
|
|
| ax.plot(time, final_signal, color='blue', alpha=0.5, label='Signal') |
|
|
| reflection_factor = 0.3 |
| reflection = final_signal * reflection_factor |
| reflection_color = 'lightblue' |
|
|
| ax.plot(time, -reflection - reflectoin.min(), color=reflection_color, linestyle='--', alpha=0.6, lable='Reflection') |
|
|
| ax.set_title('PulseWavefront') |
| ax.set_xlabel('Time Step') |
| ax.set_ylabel('Amplitude') |
| ax.legend() |
| ax.grid(True) |
|
|
| plt.show() |
