nu-lpw-ec 0.0.1__tar.gz

nu_lpw_ec-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: nu_lpw_ec
+Version: 0.0.1
+Summary: Enjoy my codes!
+Author-email: None None <userzeroonetwo091@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7

nu_lpw_ec-0.0.1/nu_lpw_ec/dc.py

@@ -0,0 +1,1177 @@
+def doc():
+    print(r"""
+| Function | Description |
+|:--------:|-------------|
+| p1() | Matched Filter Receiver |
+| p2() | GSO |
+| p3() | BPSK |
+| p4() | QPSK |
+| p5() | BFSK |
+| p6() | DPSK |
+| p7() | MPSK |
+| p8() | Linear Block Code |
+| p9() | Conv Code |
+| p10() | Image and Audio |
+
+""")
+
+def p1():
+    print(r"""
+    -------------------------------------CELL 1-----------------------------------------------
+clc;
+clear;
+close all;
+% Common Parameters
+Tb = 1; % Bit duration
+Fs = 100; % Sampling frequency
+Ns = Fs*Tb; % Samples/bit
+dt = 1/Fs;
+Eb = 1; % Energy per bit
+A = sqrt(Eb/Tb); % Signal amplitude
+t = 0 : dt : Tb-dt;
+% Generation of Binary Antipodal Signal
+bit = 0; % Change to 0 if desired
+if bit==1
+    s = A*ones(1,Ns);
+else
+    s = -A*ones(1,Ns);
+end
+figure;
+plot(t,s,'LineWidth',2);
+xlabel('Time (s)');
+ylabel('Amplitude');
+title('Binary Antipodal Signal');
+grid on;
+% Transmission through AWGN Channel
+EbN0_dB = 6;
+EbN0 = 10^(EbN0_dB/10);
+N0 = Eb/EbN0;
+sigma = sqrt(N0/2);
+noise = sigma*randn(1,Ns);
+r = s + noise;
+figure;
+plot(t,r,'LineWidth',1.5);
+xlabel('Time (s)');
+ylabel('Amplitude');
+title('Received Signal');
+grid on;
+% Correlation Receiver
+Correlation_Output = sum(r.*s)*dt;
+fprintf('\nCorrelation Receiver Output = %f\n',Correlation_Output);
+% Matched Filter Receiver
+h = fliplr(s);
+MF_Output = conv(r,h)*dt;
+time_mf = 0:dt:(length(MF_Output)-1)*dt;
+figure;
+plot(time_mf,MF_Output,'LineWidth',2);
+xlabel('Time (s)');
+ylabel('Amplitude');
+title('Matched Filter Output');
+grid on;
+Sample_Output = MF_Output(Ns);
+fprintf('Matched Filter Output = %f\n',Sample_Output);
+% Verification of Equivalence
+Difference = abs(Correlation_Output-Sample_Output);
+fprintf('\nDifference = %e\n',Difference);
+if Difference<1e-10
+    disp('Matched Filter = Correlation Receiver');
+else
+    disp('Outputs are equal within numerical accuracy.');
+end
+% Optimum Decision Rule
+disp('Decision Device');
+if Sample_Output>0
+    DetectedBit=1;
+else
+    DetectedBit=0;
+end
+fprintf('\nTransmitted Bit = %d\n',bit);
+fprintf('Detected Bit = %d\n',DetectedBit);
+% BER Performance
+disp('BER Simulation');
+Nbits = 100000;
+EbN0_dB = 0:2:10;
+BER = zeros(size(EbN0_dB));
+for k=1:length(EbN0_dB)
+    EbN0 = 10^(EbN0_dB(k)/10);
+    N0 = Eb/EbN0;
+    sigma = sqrt(N0/2);
+    bits = randi([0 1],1,Nbits);
+    symbols = 2*bits-1;
+    noise = sigma*randn(1,Nbits);
+    received = symbols + noise;
+    detected = received>0;
+    BER(k)=sum(bits~=detected)/Nbits;
+end
+Theory = 0.5*erfc(sqrt(10.^(EbN0_dB/10)));
+figure;
+semilogy(EbN0_dB,BER,'o-','LineWidth',2);
+hold on;
+semilogy(EbN0_dB,Theory,'*-','LineWidth',2);
+xlabel('E_b/N_0 (dB)');
+ylabel('Bit Error Rate');
+title('BER Performance');
+legend('Simulation','Theory','Location','southwest');
+grid on;
+
+------------------------------------------CELL 2------------------------------------
+Modify the MATLAB program to transmit a random sequence of 1000 binary bits instead of a single bit.
+clc;
+clear;
+close all;
+%% Common Parameters
+Tb = 1; % Bit duration
+Fs = 100; % Sampling frequency
+Ns = Fs*Tb; % Samples per bit
+dt = 1/Fs;
+Eb = 1;
+A = sqrt(Eb/Tb);
+t = 0:dt:Tb-dt;
+%% Generate Random Binary Sequence
+Nbits = 1000;
+bits = randi([0 1],1,Nbits);
+DetectedBit_MF = zeros(1,Nbits);
+DetectedBit_Corr = zeros(1,Nbits);
+EbN0_dB = 6;
+EbN0 = 10^(EbN0_dB/10);
+N0 = Eb/EbN0;
+sigma = sqrt(N0/2);
+%% Process Each Bit
+for k = 1:Nbits
+    % Binary Antipodal Signal
+    if bits(k)==1
+        s = A*ones(1,Ns);
+    else
+        s = -A*ones(1,Ns);
+    end
+    % AWGN Channel
+    noise = sigma*randn(1,Ns);
+    r = s + noise;
+    % Correlation Receiver
+    Correlation_Output = sum(r.*s)*dt;
+    if Correlation_Output>0
+        DetectedBit_Corr(k)=1;
+    else
+        DetectedBit_Corr(k)=0;
+    end
+    % Matched Filter
+    h = fliplr(s);
+    MF_Output = conv(r,h)*dt;
+    Sample_Output = MF_Output(Ns);
+    if Sample_Output>0
+        DetectedBit_MF(k)=1;
+    else
+        DetectedBit_MF(k)=0;
+    end
+
+    % Verify Equivalence
+    Difference = abs(Correlation_Output-Sample_Output);
+    if Difference>1e-10
+        fprintf('Difference at Bit %d = %e\n',k,Difference);
+    end
+end
+%% BER Calculation
+BER_MF = sum(bits~=DetectedBit_MF)/Nbits;
+BER_Corr = sum(bits~=DetectedBit_Corr)/Nbits;
+%% Display Results
+disp('-----------------------------------------');
+disp('Matched Filter and Correlation Receiver');
+disp('-----------------------------------------');
+fprintf('Number of transmitted bits : %d\n',Nbits);
+fprintf('Eb/N0 : %d dB\n',EbN0_dB);
+fprintf('BER using Matched Filter : %e\n',BER_MF);
+fprintf('BER using Correlator : %e\n',BER_Corr);
+disp('-----------------------------------------');
+%% Plot First Transmitted Signal
+if bits(1)==1
+    s = A*ones(1,Ns);
+else
+    s = -A*ones(1,Ns);
+end
+figure;
+plot(t,s,'LineWidth',2);
+xlabel('Time (s)');
+ylabel('Amplitude');
+title('First Transmitted Binary Antipodal Signal');
+grid on;
+%% Plot First Received Signal
+noise = sigma*randn(1,Ns);
+r = s + noise;
+figure;
+plot(t,r,'LineWidth',2);
+xlabel('Time (s)');
+ylabel('Amplitude');
+title('First Received Signal');
+grid on;
+%% Plot First Matched Filter Output
+h = fliplr(s);
+MF_Output = conv(r,h)*dt;
+tmf = 0:dt:(length(MF_Output)-1)*dt;
+figure;
+plot(tmf,MF_Output,'LineWidth',2);
+xlabel('Time (s)');
+ylabel('Amplitude');
+title('Matched Filter Output');
+grid on;
+    
+""")
+def p2():
+    print(r"""
+p2
+---------------------------------------CELL 1------------------------------
+clear;
+clc;
+close all;
+
+T = 3;
+fs = 5000;
+dt = 1/fs;
+t = 0:dt:T-dt;
+tol = 1e-10;
+
+s1 = double((t >= 0) & (t < T/3));
+s2 = double((t >= 0) & (t < 2*T/3));
+s3 = double((t >= T/3) & (t < T));
+s4 = double((t >= 0) & (t <= T));
+
+g1 = s1;
+E1 = sum(g1.^2)*dt;
+phi1 = g1/sqrt(E1);
+
+S21 = sum(s2.*phi1)*dt;
+g2 = s2 - S21*phi1;
+E2 = sum(g2.^2)*dt;
+phi2 = g2/sqrt(E2);
+
+S31 = sum(s3.*phi1)*dt;
+S32 = sum(s3.*phi2)*dt;
+g3 = s3 - S31*phi1 - S32*phi2;
+E3 = sum(g3.^2)*dt;
+
+if E3 < tol
+    phi3 = zeros(size(t));
+else
+    phi3 = g3/sqrt(E3);
+end
+
+S41 = sum(s4.*phi1)*dt;
+S42 = sum(s4.*phi2)*dt;
+S43 = sum(s4.*phi3)*dt;
+g4 = s4 - S41*phi1 - S42*phi2 - S43*phi3;
+E4 = sum(g4.^2)*dt;
+
+if E4 < tol
+    phi4 = zeros(size(t));
+else
+    phi4 = g4/sqrt(E4);
+end
+
+figure('Position',[100 100 900 700]);
+---------------------------------------CELL 2------------------------------
+subplot(4,2,1);
+plot(t,s1,'LineWidth',2);
+title('s_1(t)');
+grid on;
+
+subplot(4,2,2);
+plot(t,phi1,'LineWidth',2);
+title('phi_1(t)');
+grid on;
+
+subplot(4,2,3);
+plot(t,s2,'LineWidth',2);
+title('s_2(t)');
+grid on;
+
+subplot(4,2,4);
+plot(t,phi2,'LineWidth',2);
+title('phi_2(t)');
+grid on;
+
+subplot(4,2,5);
+plot(t,s3,'LineWidth',2);
+title('s_3(t)');
+grid on;
+
+subplot(4,2,6);
+plot(t,phi3,'LineWidth',2);
+title('phi_3(t)');
+grid on;
+
+subplot(4,2,7);
+plot(t,s4,'LineWidth',2);
+title('s_4(t)');
+grid on;
+
+subplot(4,2,8);
+plot(t,phi4,'LineWidth',2);
+title('phi_4(t)');
+grid on;
+""")
+def p3():
+    print(r"""
+p3
+---------------------------------------BPSK------------------------------
+clc;
+clear all;
+close all;
+N = 5;
+b = randi([0, 1], 1, N); % Binary Message Signal
+A = 5; % Amplitude = 5
+fc = 10;
+fs = 150;
+t = 0:1/fs:1;
+C = A*sin(2*pi*fc*t);
+bpsk_signal = [];           
+full_carrier = [];           
+full_time = [];    
+
+%mod = zeros(1:150);
+for i = 1:N
+    if b(i) == 1
+        mod = C; % Transmit carrier signal for bit 1
+    else
+        mod = -C; % Transmit zero for bit 0
+    end
+    bpsk_signal = [bpsk_signal, mod];
+    full_carrier = [full_carrier, C]; 
+    full_time = [full_time, t + (i-1)];  
+end
+
+figure;
+
+subplot(2,1,1);
+plot(full_time, full_carrier, 'LineWidth', 1.5);
+grid on;
+xlabel('Time (seconds)');
+ylabel('Amplitude');
+title('Reference Carrier Signal (No Phase Shifts)');
+
+subplot(2,1,2);
+plot(full_time, bpsk_signal, 'LineWidth', 1.5);
+grid on;
+xlabel('Time (seconds)');
+ylabel('Amplitude');
+title(['Final BPSK Modulated Signal for Bits: ', num2str(b)]);
+
+-------------------------------------Const Dia--------------------------------
+% Scatter Plot (Constellation) of BPSK
+
+mod1 = zeros(1, N);
+
+for i = 1:N
+    if b(i) == 1
+        mod1(i) = 1;
+    else
+        mod1(i) = -1;
+    end
+end
+
+figure;
+scatterplot(mod1);
+grid on;
+xlabel('(mod1)');
+ylabel('(Q)');
+title(['BPSK Scatter Plot for Bits: ', num2str(b)]);
+
+-------------------------------------BER--------------------------------
+Tb = 1; 
+Fs = 100;  Ns = Fs*Tb; 
+dt = 1/Fs; Eb = 1; 
+A = sqrt(Eb/Tb); 
+t=0:dt:Tb-dt;
+Nbits = 100000;
+EbN0_dB = 0:2:10; BER = zeros(size(EbN0_dB)); 
+for k=1:length(EbN0_dB) 
+    EbN0 = 10^(EbN0_dB(k)/10); 
+    N0 = Eb/EbN0; 
+    sigma = sqrt(N0/2);  
+    bits = randi([0 1],1,Nbits); 
+    symbols = 2*bits-1; 
+    noise = sigma*randn(1,Nbits); 
+    received = symbols + noise; 
+    detected = received>0; 
+    BER(k)=sum(bits~=detected)/Nbits; 
+end
+
+-------------------------------------Compare BER--------------------------------
+Theory = 0.5*erfc(sqrt(10.^(EbN0_dB/10)));
+figure;
+semilogy(EbN0_dB, BER,'o-','LineWidth',2);
+hold on;
+semilogy(EbN0_dB,Theory,'*-','LineWidth',2);
+xlabel('E_b/N_0 (dB)');
+ylabel('Bit Error Rate'); 
+title('BER Performance'); 
+legend('Simulation','Theory','Location','southwest'); 
+grid on;
+""")
+def p4():
+    print(r"""
+p4
+---------------------------------------QPSK------------------------------
+clc;
+clear;
+close all;
+
+A = 5;
+fc = 5;
+fs = 100;
+
+t = 0:1/fs:1;
+
+% Carrier signal
+c = A*cos(2*pi*fc*t);
+
+% Random binary sequence
+b = [0 0 0 1 1 0 1 1];
+
+temp = [];
+full_carrier = [];
+full_time = [];
+
+for i = 2:length(b)
+
+    if(b(i-1) == 0 & b(i) == 0)
+        S = A*cos(2*pi*fc*t + 5*pi/4);
+
+    elseif(b(i-1) == 0 & b(i) == 1)
+        S = A*cos(2*pi*fc*t + 3*pi/4);
+
+    elseif(b(i-1) == 1 & b(i) == 0)
+        S = A*cos(2*pi*fc*t + 3*pi/4);
+
+    elseif(b(i-1) == 1 & b(i) == 1)
+        S = A*cos(2*pi*fc*t + pi/4);
+    end
+
+    temp = [temp S];
+    full_carrier = [full_carrier c];
+    full_time = [full_time t + (i-2)*max(t)];
+end
+
+% Plot carrier wave
+figure;
+plot(full_time, full_carrier);
+xlabel('Time');
+ylabel('Amplitude');
+title('Carrier Wave');
+grid on;
+
+% Plot QPSK signal
+figure;
+plot(full_time, temp);
+xlabel('Time');
+ylabel('Amplitude');
+title('QPSK Signal');
+grid on;
+
+------------------------------------Const Dia---------------------------------
+
+mod1 = zeros(1, length(b)-1);
+
+for i = 2:length(b)
+    
+    if b(i-1) == 0 & b(i) == 0
+        mod1(i-1) = exp(1j*5*pi/4);
+        
+    elseif b(i-1) == 0 & b(i) == 1
+        mod1(i-1) = exp(1j*3*pi/4);
+        
+    elseif b(i-1) == 1 & b(i) == 0
+        mod1(i-1) = exp(1j*pi/4);
+        
+    elseif b(i-1) == 1 & b(i) == 1
+        mod1(i-1) = exp(1j*7*pi/4);
+        
+    end
+    
+end
+
+figure;
+scatterplot(mod1);
+
+grid on;
+xlabel('In-phase (I)');
+ylabel('Quadrature (Q)');
+title('QPSK Constellation Diagram');
+
+------------------------------------BER vs SNR---------------------------------
+
+SNR_dB = 0:1:15;
+
+% Number of bits
+N = 30000;
+
+% Make N even because 2 bits = 1 QPSK symbol
+N = N - mod(N,2);
+
+% Random binary data
+b = randi([0 1], 1, N);
+
+% Group bits into pairs
+bits = reshape(b, 2, []).';
+
+% Number of QPSK symbols
+num_symbols = size(bits,1);
+
+% QPSK symbols
+tx = zeros(1, num_symbols);
+
+% QPSK mapping
+for i = 1:num_symbols
+
+    if bits(i,1) == 0 && bits(i,2) == 0
+        tx(i) = exp(1j*5*pi/4);
+
+    elseif bits(i,1) == 0 && bits(i,2) == 1
+        tx(i) = exp(1j*3*pi/4);
+
+    elseif bits(i,1) == 1 && bits(i,2) == 0
+        tx(i) = exp(1j*pi/4);
+
+    elseif bits(i,1) == 1 && bits(i,2) == 1
+        tx(i) = exp(1j*7*pi/4);
+
+    end
+
+end
+
+BER = zeros(1,length(SNR_dB));
+
+% SNR loop
+for j = 1:length(SNR_dB)
+
+    SNR = 10^(SNR_dB(j)/10);
+
+    % Add AWGN
+    noise = sqrt(1/(2*SNR)) * ...
+        (randn(1,num_symbols) + 1j*randn(1,num_symbols));
+
+    rx = tx + noise;
+
+    % Demodulation
+    rx_bits = zeros(num_symbols,2);
+
+    for i = 1:num_symbols
+
+        % Decision based on I and Q
+        I = real(rx(i));
+        Q = imag(rx(i));
+
+        if I < 0 && Q < 0
+            % 00 -> 5pi/4
+            rx_bits(i,:) = [0 0];
+
+        elseif I < 0 && Q > 0
+            % 01 -> 3pi/4
+            rx_bits(i,:) = [0 1];
+
+        elseif I > 0 && Q > 0
+            % 10 -> pi/4
+            rx_bits(i,:) = [1 0];
+
+        elseif I > 0 && Q < 0
+            % 11 -> 7pi/4
+            rx_bits(i,:) = [1 1];
+
+        end
+
+    end
+
+    % Convert received bits into a single sequence
+    received = reshape(rx_bits.',1,[]);
+
+    % Calculate BER
+    BER(j) = sum(b ~= received)/N;
+
+end
+
+% Plot BER vs SNR
+figure;
+
+semilogy(SNR_dB, BER, 'o-', 'LineWidth', 1.5);
+
+grid on;
+xlabel('SNR (dB)');
+ylabel('Bit Error Rate (BER)');
+title('BER vs SNR for QPSK');
+""")
+def p5():
+    print(r"""
+p5
+---------------------------------------BFSK------------------------------
+clc;
+clear all;
+close all;
+A = 5;         
+f1 = 5;       
+f2 = 10;        
+fs = 150;       
+t = 0:1/fs:1;   
+b = randi([0 1], 1, 8); 
+temp = [];
+full_carrier1 = [];
+full_carrier2 = [];
+full_time = [];
+bit_count = 0; 
+for i = 1:length(b) 
+    bit_count = bit_count + 1;
+    c1 = A*cos(2*pi*f1*t); 
+    c2 = A*cos(2*pi*f2*t); 
+    if b(i) == 0
+        S = c1; 
+    else
+        S = c2;
+    end
+    temp = [temp, S];
+    full_carrier1 = [full_carrier1, c1];
+    full_carrier2 = [full_carrier2, c2];
+    full_time = [full_time, t + (bit_count - 1)]; 
+end
+figure;
+subplot(3,1,1);
+plot(full_time, full_carrier1)
+grid on;
+xlabel('Time(seconds)');
+ylabel('Amplitude');
+title(['Carrier 1 (f1 = ', num2str(f1), ' Hz)']);
+subplot(3,1,2);
+plot(full_time, full_carrier2)
+grid on;
+xlabel('Time(seconds)');
+ylabel('Amplitude');
+title(['Carrier 2(f2 = ', num2str(f2), ' Hz)']);
+subplot(3,1,3);
+plot(full_time, temp)
+grid on;
+xlabel('Time (seconds)');
+ylabel('Amplitude');
+title(['Final Coherent BFSK Modulated Signal(8 bits): ', num2str(b)]);
+
+---------------------------------------Const Dia------------------------------
+A = 5;
+b = [0 0 0 1 1 0 1 1];
+mod2 = zeros(1, length(b));
+for i=1:length(b)
+    if b(i) == 0
+        mod2(i) = A + 1i*0;
+    else if b(i) == 1
+            mod2(i) = 0+1i*A;
+    end
+    end
+end
+    scatterplot(mod2);
+    title("BFSK Constellation Diagram");
+    grid on;
+
+---------------------------------------BER vs SNR------------------------------
+N = 10000;
+b = randi([0 1], 1, N);
+
+SNRdB = 0:10;
+SNR = 10.^(SNRdB/10);
+
+BER = zeros(1, length(SNR));
+theory_BER = zeros(1, length(SNR));
+
+for i = 1:length(SNR)
+
+    A = sqrt(SNR(i)); % Generate amplitude
+
+    s1 = [];
+    s2 = [];
+
+    for k = 1:N
+
+        if b(k) == 0
+            s1 = [s1 A];
+            s2 = [s2 0];
+        else
+            s1 = [s1 0];
+            s2 = [s2 A];
+        end
+
+    end
+
+    d = zeros(1, N);
+
+    for j = 1:N
+
+        n1 = randn();
+        n2 = randn();
+
+        r1 = s1(j) + n1;
+        r2 = s2(j) + n2;
+
+        if r2 >= r1
+            d(j) = 1;
+        else
+            d(j) = 0;
+        end
+
+    end
+
+    error = sum(xor(b,d)); % Calculate Erroneous bits
+    BER(i) = error/N; % BER
+
+    theory_BER(i) = 0.5 * erfc(sqrt(SNR(i)/2)); % theoretical BER
+
+end
+
+figure;
+
+semilogy(SNRdB, BER, 'Y-', 'LineWidth', 1);
+hold on;
+
+semilogy(SNRdB, theory_BER, 'B--', 'LineWidth', 1);
+
+xlabel('SNR (dB)');
+ylabel('BER');
+title('BFSK BER vs SNR');
+
+legend('Simulated BER', 'Theoretical BER');
+grid on;
+""")
+def p6():
+    print(r"""
+p6
+----------------------------Cell 1-------------------------------
+% Parameter
+Nb  = 10;                 
+Tb  = 1;                  
+N   = 100;               
+fs  = N/Tb;               
+fc  = 4/Tb;               
+sigma_demo = 0.3;         
+
+rng(1);
+b = randi([0 1], 1, Nb);  
+
+% Differential encoding: 
+d = zeros(1, Nb+1);
+d(1) = 1;
+for k = 1:Nb
+    d(k+1) = xor(d(k), b(k));
+end
+
+% DPSK modulation 
+sym = 2*d - 1;                         
+t   = 0:1/fs:(Nb+1)*Tb - 1/fs;
+tx  = repelem(sym, N) .* cos(2*pi*fc*t);   
+
+% AWGN channel
+rx = tx + sigma_demo*randn(size(tx));
+
+% Demodulation:
+rx_delay = [zeros(1, N), rx(1:end-N)];
+prod_sig = rx .* rx_delay;                  
+y        = sum(reshape(prod_sig, N, []), 1); 
+y        = y(2:end);                         
+b_hat    = double(y < 0);                    
+
+fprintf('Transmitted bits : %s\n', num2str(b));
+fprintf('Detected bits    : %s\n', num2str(b_hat));
+fprintf('Bit errors : %d\n\n', sum(b ~= b_hat));
+
+figure('Name','DPSK Modulation and Demodulation','Position',[100 100 900 750]);
+subplot(5,1,1);
+stairs(0:Nb-1, b, 'LineWidth', 1.5); ylim([-0.5 1.5]);
+title('Input Binary Data'); ylabel('Amplitude'); grid on;
+
+subplot(5,1,2);
+stairs(0:Nb, d, 'LineWidth', 1.5); ylim([-0.5 1.5]);
+title('Differentially Encoded Data'); ylabel('Amplitude'); grid on;
+
+subplot(5,1,3);
+plot(t, tx, 'LineWidth', 1); 
+title('Modulated DPSK Signal'); ylabel('Amplitude'); grid on;
+
+subplot(5,1,4);
+plot(t, rx); 
+title('Received DPSK Signal'); ylabel('Amplitude'); grid on;
+
+subplot(5,1,5);
+stairs(1:Nb, b_hat, 'LineWidth', 1.5); ylim([-0.5 1.5]);
+title('Demodulated Data'); xlabel('Bit index'); ylabel('Amplitude'); grid on;
+
+
+% Constellation diagram 
+Nsym = 2000;
+bits = randi([0 1], 1, Nsym);
+dd = zeros(1, Nsym+1); dd(1) = 1;
+for k = 1:Nsym
+    dd(k+1) = xor(dd(k), bits(k));
+end
+s = 2*dd - 1;                          
+
+EbN0_const = 10;                      
+N0c = 1/10^(EbN0_const/10);
+nc  = sqrt(N0c/2)*(randn(size(s)) + 1j*randn(size(s)));
+r_c = s + nc;
+
+figure('Name','DPSK Constellation','Position',[150 150 900 400]);
+plot(real(s), imag(s), 'bo', 'MarkerSize', 10, 'LineWidth', 2); hold on;
+plot([-2 2], [0 0], 'k:'); plot([0 0], [-2 2], 'k:');
+axis([-2 2 -2 2]); axis square; grid on;
+xlabel('In-phase'); ylabel('Quadrature');
+title('Constellation Diagram');
+
+
+
+% BER over AWGN 
+EbN0_dB = 0:1:12;
+EbN0    = 10.^(EbN0_dB/10);
+Nbits   = 1e6;                        
+ber_sim = zeros(size(EbN0_dB));
+
+for i = 1:length(EbN0_dB)
+    bi = randi([0 1], 1, Nbits);
+    di = [1, mod(1 + cumsum(bi), 2)];
+    si = 2*di - 1;                    
+    N0 = 1/EbN0(i);
+    n  = sqrt(N0/2)*(randn(size(si)) + 1j*randn(size(si)));
+    ri = si + n;                     
+    z      = real(ri(2:end) .* conj(ri(1:end-1)));
+    bi_hat = double(z < 0);
+
+    ber_sim(i) = sum(bi ~= bi_hat)/Nbits;
+end
+
+% Theoretical BER and comparison 
+ber_dpsk_theory = 0.5*exp(-EbN0);                
+ber_bpsk_theory = 0.5*erfc(sqrt(EbN0));          
+
+figure('Name','BER of DPSK over AWGN');
+semilogy(EbN0_dB, ber_sim, 'ro-', 'LineWidth', 1.5, 'MarkerSize', 7); hold on;
+semilogy(EbN0_dB, ber_dpsk_theory, 'b-', 'LineWidth', 1.8);
+semilogy(EbN0_dB, ber_bpsk_theory, 'k--', 'LineWidth', 1.3);
+grid on; ylim([1e-6 1]);
+xlabel('E_b/N_0 (dB)'); ylabel('Bit Error Rate (BER)');
+title('BER Performance of DPSK over AWGN Channel');
+legend('DPSK Simulated', 'DPSK Theoretical: 0.5e^{-E_b/N_0}', ...
+       'Coherent BPSK Theoretical', 'Location', 'southwest');
+
+""")
+def p7():
+    print(r"""
+p7
+---------------------------Cell 1--------------------------------
+clear all;
+close all;
+clc;
+
+% Parameter
+N = 10000;
+SNR = 0:2:14;
+M = [2 4 8 16];
+
+BER = zeros(length(M),length(SNR));
+
+for m = 1:length(M)
+
+    % Generate random data
+    data = randi([0 M(m)-1],N,1);
+
+    % M-PSK Modulation
+    tx = pskmod(data,M(m),0);
+
+    % Constellation diagram
+    figure;
+    scatterplot(tx);
+    title(['M-PSK Constellation, M = ' num2str(M(m))]);
+    grid on;
+
+    % AWGN channel and BER
+    for k = 1:length(SNR)
+
+        rx = awgn(tx,SNR(k),'measured');
+
+        % M-PSK Demodulation
+        data_rx = pskdemod(rx,M(m),0);
+
+        % Calculate BER
+        [~,BER(m,k)] = biterr(data,data_rx);
+
+    end
+end
+
+% Plot BER
+figure;
+
+for m = 1:length(M)
+    semilogy(SNR,BER(m,:),'-o');
+    hold on;
+end
+
+grid on;
+xlabel('SNR (dB)');
+ylabel('BER');
+title('BER Performance of M-PSK over AWGN Channel');
+
+legend('BPSK (M=2)','QPSK (M=4)', ...
+       '8-PSK (M=8)','16-PSK (M=16)');
+
+
+
+""")
+def p8():
+    print(r"""
+p8
+--------------------Cell 1--------------------------
+clear all ; close all ; clc ;
+
+% Parameter 
+n = 7;
+k = 4; 
+P = [1 1 0; 
+     1 0 1; 
+     0 1 1; 
+     1 1 1]; 
+
+% Systematic Generator Matrix G = [I_k | P]
+G = [eye(k), P]; 
+
+% Parity-Check Matrix H = [P' | I_(n-k)]
+H = [P', eye(n-k)];
+
+disp('Generator Matrix G:'); disp(G);
+disp('Parity-Check Matrix H:'); disp(H);
+
+% Single-Bit Error Correction Demonstration
+msg_demo = [1 0 1 1]; 
+codeword_demo = mod(msg_demo * G, 2); 
+
+% Introduce a single-bit error at a chosen test position
+error_pos = 2; 
+error_vector = zeros(1, n);
+error_vector(error_pos) = 1;
+
+% Received vector with the error
+received_demo = mod(codeword_demo + error_vector, 2);
+
+% Syndrome calculation: S = R * H' (mod 2)
+syndrome_demo = mod(received_demo * H', 2);
+
+% Error Detection and Correction using Syndrome Decoding
+detected_pos = 0;
+if all(syndrome_demo == 0)
+    corrected_demo = received_demo;
+    fprintf('Syndrome is zero: No Error Detected.\n');
+else
+    for i = 1:n
+        if H(:, i)' == syndrome_demo
+            detected_pos = i;
+            break;
+        end
+    end
+    
+    % Correct the error if identified
+    corrected_demo = received_demo;
+    if detected_pos > 0
+        corrected_demo(detected_pos) = mod(corrected_demo(detected_pos) + 1, 2);
+    end
+end
+
+fprintf('\nSingle-Bit Error\n');
+fprintf('Original Message:    [%s]\n', num2str(msg_demo));
+fprintf('Generated Codeword:  [%s]\n', num2str(codeword_demo));
+fprintf('Received Codeword:   [%s] (Error at bit %d)\n', num2str(received_demo), error_pos);
+fprintf('Calculated Syndrome: [%s]\n', num2str(syndrome_demo));
+fprintf('Detected Error at:   Bit %d\n', detected_pos);
+fprintf('Corrected Codeword:  [%s]\n\n', num2str(corrected_demo));
+
+
+%Performance Evaluation over a Binary Symmetric Channel (BSC)
+num_blocks = 10^5;                         
+p_vector = logspace(-4, -1, 10);         
+ber_uncoded = zeros(1, length(p_vector));
+ber_coded = zeros(1, length(p_vector));    
+
+syndrome_table = zeros(2^(n-k), 1);
+for i = 1:n
+    syn_dec = bi2de(H(:, i)', 'left-msb');
+    syndrome_table(syn_dec + 1) = i;
+end
+
+for idx = 1:length(p_vector)
+    p = p_vector(idx);
+    
+    % Generate random source message bits
+    tx_msg = randi([0 1], num_blocks, k);
+    
+    % Encode messages
+    tx_code = mod(tx_msg * G, 2);
+    
+    % Simulate BSC noise (add bit-flips with probability p)
+    noise = rand(num_blocks, n) < p;
+    rx_code = mod(tx_code + noise, 2);
+    
+    % Keep track of raw raw errors for uncoded benchmark line
+    ber_uncoded(idx) = mean(noise(:));
+    
+    % Decode received words block-by-block
+    rx_msg = zeros(num_blocks, k);
+    
+    for b = 1:num_blocks
+        this_rx = rx_code(b, :);
+        syn = mod(this_rx * H', 2);
+        
+        if any(syn)
+            % Check our syndrome table lookup
+            syn_dec = bi2de(syn, 'left-msb');
+            err_bit = syndrome_table(syn_dec + 1);
+            if err_bit > 0
+                this_rx(err_bit) = 1 - this_rx(err_bit); % Flip it back
+            end
+        end
+        % Systematic bits are the first k bits
+        rx_msg(b, :) = this_rx(1:k); 
+    end
+    
+    % Evaluate post-correction performance
+    bit_errors = tx_msg ~= rx_msg;
+    ber_coded(idx) = mean(bit_errors(:));
+end
+
+% Plot Results
+figure;
+loglog(p_vector, ber_uncoded, 'r--o', 'LineWidth', 1.5, 'MarkerSize', 6); hold on;
+loglog(p_vector, ber_coded, 'b-s', 'LineWidth', 1.5, 'MarkerSize', 6);
+grid on;
+xlabel('BSC Crossover Probability (p)');
+ylabel('Bit Error Rate (BER)');
+title('Linear Block Code Evaluation Over BSC');
+legend('Uncoded Performance (Baseline)', 'Coded Performance (with Syndrome Correction)', 'Location', 'SouthEast');
+
+""")
+def p9():
+    print(r"""
+p9
+--------------------------------Cell 1----------------------------
+
+
+%Parameters
+N = 100000;                 % number of message bits
+trellis = poly2trellis(3,[7 5]);  % rate 1/2, constraint length 3
+tbdepth = 15;                     % traceback depth for Viterbi
+rate    = 1/2;                    % code rate
+EbN0_dB = 0:1:8;                  % Eb/N0 range in dB
+
+%Encoder 
+demo_msg   = [1 0 1 1 0 0 1];
+demo_coded = convenc(demo_msg, trellis);
+disp('Message bits :'); disp(demo_msg);
+disp('Encoded bits :'); disp(demo_coded);
+
+%Generate random message and encode
+msg   = randi([0 1], 1, N);
+coded = convenc(msg, trellis);
+
+BER_uncoded = zeros(size(EbN0_dB));
+BER_coded   = zeros(size(EbN0_dB));
+
+for i = 1:length(EbN0_dB)
+    EbN0 = 10^(EbN0_dB(i)/10);
+
+    %Uncoded BPSK over AWGN 
+    tx_u    = 2*msg - 1;
+    sigma_u = sqrt(1/(2*EbN0));
+    rx_u    = tx_u + sigma_u*randn(size(tx_u));
+    dec_u   = rx_u > 0;
+    BER_uncoded(i) = sum(dec_u ~= msg)/N;
+
+    %Convolutional coded BPSK over AWGN 
+    tx_c    = 2*coded - 1;
+    sigma_c = sqrt(1/(2*rate*EbN0));
+    rx_c    = tx_c + sigma_c*randn(size(tx_c));
+    hard    = double(rx_c > 0);
+    dec_c   = vitdec(hard, trellis, tbdepth, 'trunc', 'hard');
+    BER_coded(i) = sum(dec_c ~= msg)/N;
+end
+
+%Plot BER curves
+semilogy(EbN0_dB, BER_uncoded, 'r-o', 'LineWidth', 1.5); hold on;
+semilogy(EbN0_dB, BER_coded,   'b-s', 'LineWidth', 1.5);
+grid on;
+xlabel('E_b/N_0 (dB)'); ylabel('Bit Error Rate (BER)');
+title('BER: Coded vs Uncoded over AWGN Channel');
+legend('Uncoded BPSK', 'Convolutional Coded (Viterbi)');
+
+""")
+def p10():
+    print(r"""
+p10
+------------------------------Cell 1------------------------------------------
+clc; clear; close all;
+
+%Image Transmission
+SNR_dB = [0 5 10];                
+img  = imread('peppers.png');
+gray = uint8(mean(img,3));         % convert to grayscale
+[r,c] = size(gray);
+
+bits = bytes2bits(gray(:));        % image to bit stream
+
+figure('Name','Image Transmission');
+subplot(2,2,1); imshow(gray); title('Original Image');
+
+for k = 1:length(SNR_dB)
+    rx_bits = transmit(bits, SNR_dB(k));          % BPSK + AWGN + detection
+    rx_img  = reshape(bits2bytes(rx_bits), r, c); % bits to image
+
+    BER  = sum(bits ~= rx_bits)/length(bits);
+    mse  = mean((double(gray(:)) - double(rx_img(:))).^2);
+    PSNR = 10*log10(255^2/mse);
+
+    subplot(2,2,k+1); imshow(uint8(rx_img));
+    title(sprintf('SNR=%d dB, BER=%.4f, PSNR=%.1f dB', SNR_dB(k), BER, PSNR));
+    fprintf('Image: SNR = %2d dB  BER = %.5f  PSNR = %.2f dB\n', SNR_dB(k), BER, PSNR);
+end
+
+%Audio Transmission
+load handel;                       % gives y (audio) and Fs (sampling rate)
+y = y(1:20000);                    % use a short segment
+q = round((y + 1)/2 * 255);        % quantize to 8 bits (0 to 255)
+
+abits = bytes2bits(q);             % audio to bit stream
+
+figure('Name','Audio Transmission');
+subplot(2,2,1); plot(y); title('Original Audio'); ylim([-1 1]);
+
+for k = 1:length(SNR_dB)
+    rx_bits = transmit(abits, SNR_dB(k));
+    q_rx    = bits2bytes(rx_bits);
+    y_rx    = q_rx/255*2 - 1;      % bits to audio
+
+    BER = sum(abits ~= rx_bits)/length(abits);
+    snr_out = 10*log10(sum(y.^2)/sum((y - y_rx).^2));
+
+    subplot(2,2,k+1); plot(y_rx); ylim([-1 1]);
+    title(sprintf('SNR=%d dB, BER=%.4f', SNR_dB(k), BER));
+    fprintf('Audio: SNR = %2d dB  BER = %.5f  Output SNR = %.2f dB\n', SNR_dB(k), BER, snr_out);
+
+    % sound(y_rx, Fs); pause(3);  
+end
+% sound(y, Fs);                   
+
+function rx_bits = transmit(bits, snr_dB)
+tx    = 2*bits - 1;                    % BPSK: 0 -> -1, 1 -> +1
+EbN0  = 10^(snr_dB/10);
+sigma = sqrt(1/(2*EbN0));              % noise standard deviation
+rx    = tx + sigma*randn(size(tx));    % AWGN channel
+rx_bits = double(rx > 0);              % hard decision
+end
+
+function bits = bytes2bits(x)
+b = dec2bin(double(x(:)), 8)' - '0';   % 8 bits per sample/pixel
+bits = double(b(:)');
+end
+
+function x = bytes2bits_dummy(~)          
+end
+
+function x = bits2bytes(bits)
+x = reshape(bits, 8, [])' * [128;64;32;16;8;4;2;1];
+end
+""")

nu_lpw_ec-0.0.1/nu_lpw_ec.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: nu_lpw_ec
+Version: 0.0.1
+Summary: Enjoy my codes!
+Author-email: None None <userzeroonetwo091@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7

nu_lpw_ec-0.0.1/nu_lpw_ec.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+pyproject.toml
+nu_lpw_ec/__init__.py
+nu_lpw_ec/dc.py
+nu_lpw_ec.egg-info/PKG-INFO
+nu_lpw_ec.egg-info/SOURCES.txt
+nu_lpw_ec.egg-info/dependency_links.txt
+nu_lpw_ec.egg-info/top_level.txt

nu_lpw_ec-0.0.1/nu_lpw_ec.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nu_lpw_ec-0.0.1/nu_lpw_ec.egg-info/top_level.txt

@@ -0,0 +1 @@
+nu_lpw_ec

nu_lpw_ec-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nu_lpw_ec"
+version = "0.0.1"
+authors = [
+    { name="None None", email="userzeroonetwo091@gmail.com" },
+]
+description = "Enjoy my codes!"
+requires-python = ">=3.7"
+dependencies = [
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.setuptools]
+packages = ["nu_lpw_ec"]

nu_lpw_ec-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+