🧙🏼 🧓🏾 👨🏼‍🎤 Kode korektif sistematis. Kode Grup Linier 👨🏻‍⚖️ 👉🏼 🤭

Publikasi ini akan mempertimbangkan kode grup linier sebagai salah satu perwakilan dari kode korektif sistematis dan penerapannya dalam C ++ diusulkan.

Apa itu kode korektif? Kode korektif adalah kode yang bertujuan mendeteksi dan memperbaiki kesalahan. A kode sistematis - Ini adalah kode di mana bit kontrol dan informasi ditempatkan pada sistem tertentu. Salah satu contohnya adalah kode Hamming atau kode grup linear sebenarnya.
Kode grup linear terdiri dari bit informasi dan bit kontrol. Misalnya, untuk kombinasi 4 karakter awal, kode yang dikelompokkan secara linear akan terlihat seperti ini:

|1100|110|

Di mana 4 karakter pertama adalah kombinasi asli kami, dan 3 karakter terakhir adalah bit kontrol.

Panjang total kode grup linier adalah 7 karakter. Jika kami mengetahui jumlah bit dari kombinasi asli, maka untuk menghitung jumlah bit cek, Anda perlu menggunakan rumus:

d = l o g (n + 1 + l o g (n + 1))

$d = log (n + 1 + log (n + 1))$

Di mana n adalah jumlah bit informasi, yaitu, panjang kombinasi asli, dan log adalah basis 2. Dan total panjang N dari kode akan dihitung dengan rumus:

N = n + d

$N = n + d$

Misalkan kombinasi asli adalah 10 bit.

d = l o g (10 + 1 + l o g (10 + 1))

$d = log (10 + 1 + log (10 + 1))$

d = $ 3, 86

$d = $ 3,86$

d selalu dibulatkan ke atas, dan d = 4.

Dan panjang kode lengkap akan menjadi 14 bit.

Setelah mengetahui panjang kode, kita perlu membuat matriks produksi dan verifikasi.

Matriks penghasil, dimensi N oleh n, di mana N adalah panjang kode grup linier, dan n adalah panjang bagian informasi dari kode grup linear. Pada kenyataannya, matriks produksi terdiri dari dua matriks: dimensi satuan m demi m, dan matriks bit kontrol dimensi d oleh n. Jika matriks identitas dikompilasi dengan mengatur unit pada diagonal utama, maka kompilasi bagian "kontrol" dari matriks memiliki beberapa aturan. Lebih mudah dijelaskan dengan contoh. Kami mengambil kombinasi 10 bit informasi yang sudah kami ketahui, tetapi menambahkan redundansi ke kode dan menambahkan bit kontrol 5 ke dalamnya. Matriks akan memiliki dimensi 15 kali 10.

 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 1 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 1 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 1 0 1 1

Bagian "kontrol" dikompilasi sesuai dengan skema untuk mengurangi angka biner dan mengamati jarak kode minimum antara garis: dalam kasus kami adalah 11111, 11110, 11101 ...
Jarak kode minimum untuk kombinasi akan dihitung dengan rumus:

 Wp=r+s

Di mana r adalah peringkat kesalahan yang terdeteksi, dan s adalah peringkat kesalahan yang sedang diperbaiki.
Dalam kasus kami, pangkat kesalahan yang dapat diperbaiki dan terdeteksi adalah 1.
Juga perlu membuat matriks verifikasi. Ia dikompilasi dengan mentransposisi bagian "kontrol" dan setelahnya ditambahkan matriks unit dimensi d oleh d.

 1 1 1 1 1 0 1 1 1 0 1 0 0 0 0 1 1 1 1 0 1 1 1 0 1 0 1 0 0 0 1 1 1 0 1 1 1 0 0 0 0 0 1 0 0 1 1 0 1 1 1 0 0 1 1 0 0 0 1 0 1 0 1 1 1 1 0 1 1 1 0 0 0 0 1

Setelah mengkompilasi matriks, kita sudah dapat menulis kode grup linier dengan menjumlahkan baris matriks penghasil di bawah jumlah bit yang bukan nol dari pesan asli.

Pertimbangkan langkah ini sebagai contoh pesan asli 1001101010.

Kode Grup Linier: 100110101011100

Kami segera mencatat bahwa bit kontrol dalam LGK ditentukan sesuai dengan aturan paritas dari jumlah indeks yang sesuai, dalam kasus kami, jumlah ini adalah: 5,3,3,4,4. Oleh karena itu, bagian kontrol kode terlihat: 11100.

Sebagai hasilnya, kami menyusun kode grup linear. Namun, seperti yang disebutkan sebelumnya, kode grup linear memiliki kemampuan korektif, dalam kasus kami, ia dapat mendeteksi dan memperbaiki satu kesalahan.

Katakanlah kode kami dikirim dengan kesalahan dalam kategori ke-6. Untuk menentukan kesalahan dalam kode, matriks verifikasi yang dikompilasi sebelumnya digunakan.

Untuk menentukan kategori mana kesalahan terjadi, kita perlu tahu "sindrom kesalahan". Sindrom kesalahan dihitung dengan metode pemeriksaan untuk posisi bukan nol dari matriks pemeriksaan paritas. Dalam kasus kami, ada lima cek ini, dan kami mengirim pesan yang kami terima melalui semua cek ini.

S 1 = n 1 + n 2 + n 3 + n 4 + n 5 + n 7 + n 8 + n 9 + n 11

$S1 = n1 + n2 + n3 + n4 + n5 + n7 + n8 + n9 + n11$

S 2 = n 1 + n 2 + n 3 + n 4 + n 6 + n 7 + n 8 + n 10 + n 12

$S2 = n1 + n2 + n3 + n4 + n6 + n7 + n8 + n10 + n12$

S 3 = n 1 + n 2 + n 3 + n 5 + n 6 + n 7 + n 13

$S3 = n1 + n2 + n3 + n5 + n6 + n7 + n13$

S 4 = n 1 + n 2 + n 4 + n 5 + n 6 + n 9 + n 10 + n 14

$S4 = n1 + n2 + n4 + n5 + n6 + n9 + n10 + n14$

S 5 = n 1 + n 3 + n 4 + n 5 + n 6 + n 8 + n 9 + n 10 + n 15

$S5 = n1 + n3 + n4 + n5 + n6 + n8 + n9 + n10 + n15$

Setelah menerima nomor biner, kami membandingkannya dengan kolom matriks verifikasi. Segera setelah kami menemukan "sindrom" yang sesuai, kami menentukan indeksnya, dan melakukan kebalikan dari bit sesuai dengan indeks yang diperoleh.

Dalam kasus kami, sindromnya adalah: 01111, yang sesuai dengan kategori ke-6 dalam LGA. Kami membalikkan bit dan mendapatkan kode grup linier yang benar.

Penguraian kode LGK yang dikoreksi terjadi hanya dengan menghapus bit kontrol. Setelah menghapus bit kontrol LGK, kami mendapatkan kombinasi asli, yang dikirim untuk penyandian.

Kesimpulannya, kita dapat mengatakan bahwa kode koreksi seperti kode grup linier, kode Hamming sudah cukup usang, dan dalam efektivitasnya mereka pasti akan menghasilkan alternatif modern mereka. Namun, mereka cukup mengatasi tugas untuk berkenalan dengan proses pengkodean kode biner dan metode mengoreksi kesalahan sebagai akibat dari pengaruh gangguan pada saluran komunikasi.

Implementasi kerja dengan LGK di C ++:

 #include <iostream> #include <vector> #include <string> #include <cstdlib> #include <ctime> #include <algorithm> #include <iterator> #include <cctype> #include <cmath> using namespace std; int main() { setlocale(LC_ALL, "Russian"); cout<<" :"<<endl; int matr [10][15]={{1,0,0,0,0,0,0,0,0,0,1,1,1,1,1},{0,1,0,0,0,0,0,0,0,0,1,1,1,1,0},{0,0,1,0,0,0,0,0,0,0,1,1,1,0,1},{0,0,0,1,0,0,0,0,0,0,1,1,0,1,1},{0,0,0,0,1,0,0,0,0,0,1,0,1,1,1}, {0,0,0,0,0,1,0,0,0,0,0,1,1,1,1},{0,0,0,0,0,0,1,0,0,0,1,1,1,0,0},{0,0,0,0,0,0,0,1,0,0,1,1,0,0,1},{0,0,0,0,0,0,0,0,1,0,1,0,0,1,1},{0,0,0,0,0,0,0,0,0,1,0,1,0,1,1}}; for(int i=0;i<10;i++) { for(int j=0;j<15;j++) { cout<<matr[i][j]<<' '; } cout<<endl; } cout<<" :"<<endl; int matr_2 [5][15]={{1,1,1,1,1,0,1,1,1,0,1,0,0,0,0},{1,1,1,1,0,1,1,1,0,1,0,1,0,0,0},{1,1,1,0,1,1,1,0,0,0,0,0,1,0,0},{1,1,0,1,1,1,0,0,1,1,0,0,0,1,0},{1,0,1,1,1,1,0,1,1,1,0,0,0,0,1}}; for(int i=0;i<5;i++) { for(int j=0;j<15;j++) { cout<<matr_2[i][j]<<' '; } cout<<endl; } cout<<" : "<<endl; string str; bool flag=false; while(flag!=true) { cin>>str; if(str.size()!=10) { cout<<"  !"<<endl; flag=false; } else flag=true; } vector <int> arr; for(int i=0;i<str.size();i++) { if(str[i]=='1') arr.push_back(1); else if(str[i]=='0') arr.push_back(0); } cout<<" : "; for(int i=0;i<arr.size();i++) cout<<arr[i]; cout<<endl; vector <int> S; vector <vector<int>> R; for(int i=0;i<10;i++) { if(arr[i]==1) { vector <int> T; for(int j=0;j<15;j++) { T.push_back(matr[i][j]); } R.push_back(T); } } cout<<endl; cout<<"     : "<<endl; for(vector <vector<int>>::iterator it=R.begin();it!=R.end();it++) { copy((*it).begin(),(*it).end(),ostream_iterator<int>(cout,"\t")); cout<<"\n"; } cout<<endl; vector <int> P; for(int i=0; i<15;i++) { int PT=0; for(int j=0; j<R.size();j++) { PT+=R[j][i]; } P.push_back(PT); } for(int i=10; i<15;i++) { if(P[i]%2==0) P[i]=0; else if(P[i]%2!=0) P[i]=1; } cout<<endl<<"  : "<<endl; for(int i=0; i<P.size();i++) { cout<<P[i]<<' '; } int rand_i; rand_i=5; cout<<endl<<"   : "; if(P[rand_i]==0) P[rand_i]=1; else if(P[rand_i]==1) P[rand_i]=0; for(int i=0; i<P.size();i++) { cout<<P[i]<<' '; } int S1, S2, S3, S4, S5; //   S1=P[0]+P[1]+P[2]+P[3]+P[4]+P[6]+P[7]+P[8]+P[10]; S2=P[0]+P[1]+P[2]+P[3]+P[5]+P[6]+P[7]+P[9]+P[11]; S3=P[0]+P[1]+P[2]+P[4]+P[5]+P[6]+P[12]; S4=P[0]+P[1]+P[3]+P[4]+P[5]+P[8]+P[9]+P[13]; S5=P[0]+P[2]+P[3]+P[4]+P[5]+P[7]+P[8]+P[9]+P[14]; //  if(S1%2==0) { S1=0; } else if(S1%2!=0) { S1=1; } if(S2%2==0) { S2=0; } else if(S2%2!=0) { S2=1; } if(S3%2==0) { S3=0; } else if(S3%2!=0) { S3=1; } if(S4%2==0) { S4=0; } else if(S4%2!=0) { S4=1; } if(S5%2==0) { S5=0; } else if(S5%2!=0) { S5=1; } cout<<endl<<" : "<<S1<<S2<<S3<<S4<<S5<<endl; int mas_s[5]={S1,S2,S3,S4,S5}; int index_j=0; bool flag_s=false; for(int i=0;i<15;i++) { if((matr_2[0][i]==mas_s[0])&&(matr_2[1][i]==mas_s[1])&&(matr_2[2][i]==mas_s[2])&&(matr_2[3][i]==mas_s[3])&&(matr_2[4][i]==mas_s[4])) { index_j=i; } } cout<<endl<<" : "<<index_j+1<<endl; if(P[index_j]==0) P[index_j]=1; else if(P[index_j]==1) P[index_j]=0; cout<<" : "; for(int i=0; i<P.size();i++) { cout<<P[i]<<' '; } cout<<endl; P.erase(P.begin()+14); P.erase(P.begin()+13); P.erase(P.begin()+12); P.erase(P.begin()+11); P.erase(P.begin()+10); cout<<" : "; for(int i=0; i<P.size();i++) { cout<<P[i]<<' '; } cout<<endl; return 0; }

Sumber:

1. StudFiles - arsip file siswa [Sumber daya elektronik] studfiles.net/preview/4514583/page : 2 /.

2. Zadachnik tentang teori informasi dan pengkodean [Teks] / V.P. Tsymbal. - Ed. bersatu "Sekolah Vishka", 1976. - 276 hal.

3. Tennikov, F.E. Yayasan Teoritis Teknologi Informasi / F.E. Tennikov. - M .: Energi, 1971. - 424 hal.

Kode korektif sistematis. Kode Grup Linier

More articles: