Форум программистов, компьютерный форум CyberForum.ru

Многочлены над GF(2^m) - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Цикл вычисления бесконечной суммы http://www.cyberforum.ru/cpp-beginners/thread689595.html
#include<iostream> #include<math.h> using namespace std; int main () {double k=0; double a=0; double e=0.001; while(a>=e)
C++ Проверьте пожалуйста код на правильность ! ! ! 2. Дан массив размера 5 x 6 с элементами целого типа. Написать программу для вычисления числа элементов массива кратных 3. За ранее спасибо ! #include "stdafx.h" #include <conio.h> #include <stdio.h> #include <math.h> void main () { int M; http://www.cyberforum.ru/cpp-beginners/thread689590.html
C++ Подключение файлов в проект
Здравствуйте. Запутался немного с подключением файлов, подскажите как лучше организовать. Собственно прикладываю картинку со схемой подключений и сам проект(сильно упрощенный, но нужные связи есть).
C++ в php var_Dump , в c++ есть подобное?
в php var_dump , в c++ есть подобное?
C++ рекурсивный ввод элементов http://www.cyberforum.ru/cpp-beginners/thread689564.html
И еще одна задача по рекурсии:( не пиайте сильно, но теперь совсем простая. Задача написать функцию, по рекурсивному вводу элементов матрицы. Опять же, можно только идею:(.
C++ что не так? /*задано масcив цеых чисел,создать новый массив который состоит с елементов первого массива и встречаеться всего один раз . получить сумму нового массива, середнее арифметическое , максимальный и минимальный елемент*/ #include<iostream.h> #include<conio.h> int main() { int A; int max,min,sz,n,i,j,s; cout<<"n="; cin>>n; подробнее

Показать сообщение отдельно
vlad_light
4 / 4 / 0
Регистрация: 24.09.2012
Сообщений: 178
09.11.2012, 02:15  [ТС]     Многочлены над GF(2^m)
Отлично! Тогда я сейчас попробую реализовать столбиком (даже скорее не сейчас, а ближе к вечеру, поскольку сейчас есть ещё дела) и выложу здесь, а Вы посмотрите. Спасибо!
И ещё вопрос: а разве Вам проще разбираться в моём коде, чем написать собственный? Если да, то как научиться в нём разбираться, поскольку я в чужом коде вообще ничего понять не могу

Добавлено через 4 часа 35 минут
Алгоритм деления столбиком.
Имеем два многочлена http://www.cyberforum.ru/cgi-bin/latex.cgi?a(x)\in P_n и http://www.cyberforum.ru/cgi-bin/latex.cgi?div(x)\in P_m с коэффициентами из http://www.cyberforum.ru/cgi-bin/latex.cgi?GF(2^k). Не нарушая общности, положим http://www.cyberforum.ru/cgi-bin/latex.cgi?n>m. Представим каждый многочлен в виде вектора из его коэффициентов
http://www.cyberforum.ru/cgi-bin/latex.cgi?a(x)\leftrightarrow a = (a_0, a_1,...,a_n)\in (GF(2^k))^{n+1};div(x)\leftrightarrow b = (div_0, div_1,...,div_m)\in (GF(2^k))^{m+1}.
Создаём две дополнительных переменных:
http://www.cyberforum.ru/cgi-bin/latex.cgi?rem(x)\in P_v, v = n, n-1, n-2,...; rem(x)\leftrightarrow rem = (rem_1, rem_2,...,rem_v),
которая будет отображать текущий остаток от деления http://www.cyberforum.ru/cgi-bin/latex.cgi?a(x) на http://www.cyberforum.ru/cgi-bin/latex.cgi?div(x), и http://www.cyberforum.ru/cgi-bin/latex.cgi?mult(x)\in P_{v-m}, который имеет вид
http://www.cyberforum.ru/cgi-bin/latex.cgi?mult(x)=\frac{rem_v}{div_m}x^{v-m}\leftrightarrow mult = (0,0,...,0,\frac{rem_v}{div_m}).
Теперь на первом шаге умножаем http://www.cyberforum.ru/cgi-bin/latex.cgi?mult(x) на http://www.cyberforum.ru/cgi-bin/latex.cgi?div(x) и прибавляем к http://www.cyberforum.ru/cgi-bin/latex.cgi?rem, получаем
http://www.cyberforum.ru/cgi-bin/latex.cgi?mult(x)\times div(x)\leftrightarrow (0,0,...,0,\frac{rem_v}{div_m}div_0,\frac{rem_v}{div_m}div_1,...,\frac{rem_v}{div_m}div_m).
Поскольку последний коэф. равен http://www.cyberforum.ru/cgi-bin/latex.cgi?rem_v (такой же,как и у http://www.cyberforum.ru/cgi-bin/latex.cgi?rem), то при суммировании (что равно вычитанию) он сократиться. После этого мы убираем последний элемент из http://www.cyberforum.ru/cgi-bin/latex.cgi?rem(x), поскольку он равен нулю, и из http://www.cyberforum.ru/cgi-bin/latex.cgi?mult(x), поскольку он нам больше не нужен. проделываем операцию до тех пор, пока степень текущего остатка не станет меньше степени делителя.

Не по теме:

Хотел написать красиво, но с таким редактором ТеХ'а оно выглядит ужасно. Надеюсь, хоть что-то понятно...


Вот, что я пока написал, но не проверял. Гляньте, пожалуйста, уверен, там можно его переписать в лучшем виде.
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/* * * * * * * * * * * * * * * * * * * * * * *
                GF_polynom.cpp
* * * * * * * * * * * * * * * * * * * * * * */
 
#include "GF_polynom.h"
 
GF_polynom::GF_polynom ()
{
 
}
 
GF_polynom::GF_polynom (const GF_polynom& GF_polynom_element):
polynom (GF_polynom_element.polynom)
{
 
}
 
GF_polynom::GF_polynom (const std::vector<GF>& coefficients):
polynom (coefficients)
{
 
}
 
GF_polynom::~GF_polynom ()
{
 
}
 
GF_polynom& GF_polynom::operator= (const GF_polynom& right_hand_side)
{
    polynom.resize (right_hand_side.polynom.size());
    polynom = right_hand_side.polynom;
 
    return *this;
}
 
GF_polynom GF_polynom::operator+ (const GF_polynom& right_hand_side) const
{
    GF_polynom sum;
    sum.polynom.reserve (std::max(polynom.size(), right_hand_side.polynom.size()));
 
    for (int i = 0; i < std::min(polynom.size(), right_hand_side.polynom.size()); ++i)
        sum.polynom.push_back (polynom.at(i) + right_hand_side.polynom.at(i));
 
    if (polynom.size() < right_hand_side.polynom.size())
        for (int i = polynom.size(); i < right_hand_side.polynom.size(); ++i)
            sum.polynom.push_back (right_hand_side.polynom.at(i));
    else
        for (int i = right_hand_side.polynom.size(); i < polynom.size(); ++i)
            sum.polynom.push_back (polynom.at(i));
    
    return sum;
}
 
GF_polynom GF_polynom::operator* (const GF_polynom& right_hand_side) const
{
    GF_polynom prod;
    prod.polynom.resize (polynom.size() + right_hand_side.polynom.size());
 
    for (int i = 0; i < prod.polynom.size(); ++i)
    {
        GF sum (null_vector);
 
        for (int j = 0; j < i + 1; ++j)
            if ((j < polynom.size()) && (i - j < right_hand_side.polynom.size()))
                sum = sum + (polynom.at(j) * right_hand_side.polynom.at(i - j));
        
        prod.polynom.push_back (sum);
    }
 
    return prod;
}
 
GF_polynom GF_polynom::operator% (const GF_polynom& divisor) const
{
    GF_polynom reminder (*this); // остаток
    GF_polynom multiplier; // множитель, на который умножаем делитель
                           // (имеет вид a * x^n )
    multiplier.polynom.resize (reminder.polynom.size() - divisor.polynom.size() + 1);
 
    for (int i = 0; i < reminder.polynom.size() - divisor.polynom.size(); ++i) 
        multiplier.polynom.at(i) = null_vector; // заполняем нулями все, кроме последнего   
    
    while (reminder.polynom.size() > divisor.polynom.size()) // пока степень остачи больше степени делителя
    {
        multiplier.polynom.at(reminder.polynom.size() - divisor.polynom.size()) = //коэффициент при x^(n-m)
            reminder.polynom.at(reminder.polynom.size() - 1) /                    // n - степень текущего остатка
            divisor.polynom.at(divisor.polynom.size() - 1);                       // m - степень делителя
 
        reminder = reminder + (divisor * multiplier); // обнуляем коэффициент
                                                      // при старшей степени
        multiplier.polynom.pop_back(); // убираем старший коэф., остаются одни нули
        reminder.polynom.pop_back(); // убираем старштй коэф., поскольку он нулевой
    }
 
    return reminder; // возвращаем остаток
}
 
std::vector<GF> GF_polynom::return_coefficients () const
{
    return polynom;
}


Добавлено через 3 часа 59 минут
Урааа!!! Наконец-то дописал весь код, осталось его исправить и протестировать. Вообщем, выкладываю "пре-альфа" версию
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
/* * * * * * * * * * * * * * * * * * * * * * *
                    GF_table.h
* * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef GF_table_h
#define GF_table_h
 
#include <vector>
 
extern const int GROUP_DEGREE; 
 
const std::vector<int> init_primitive_polynomial (const int degree); 
 
struct GF_table
{
    GF_table ();
    GF_table (const GF_table& GF_element);
    ~GF_table ();
 
    GF_table& operator= (const GF_table& right_hand_side);
 
    int power;
    std::vector<int> vector;    
};
 
std::vector<GF_table> init_GF_table (const std::vector<int>& primitive_polynomial);
 
extern const std::vector<GF_table> table;
 
extern const std::vector<int> null_vector;
extern const std::vector<int> unit_vector;
 
#endif
 
/* * * * * * * * * * * * * * * * * * * * * * *
                    GF_table.cpp
* * * * * * * * * * * * * * * * * * * * * * */
 
#include "GF_table.h"
 
const int GROUP_DEGREE = 3;
 
const std::vector<int> init_primitive_polynomial (const int degree = GROUP_DEGREE)
{
    std::vector<int> polynom (degree, 0);
    polynom.resize (degree);
 
    switch (degree)
    {
    case 2:
        for (int i = 0; i < 2; ++i)
            polynom.at(i) = 1;
 
        return polynom;
 
    case 3:
        for (int i = 0; i < 3; ++i)
            polynom.at(i) = 1;
 
        polynom.at(2) = 0;
        return polynom;
 
    case 4:
        for (int i = 0; i < 4; ++i)
            polynom.at(i) = 1;
 
        polynom.at(2) = 0;
        polynom.at(3) = 0;
        return polynom;
 
    /* case 5, 6,...*/
    }
}
 
GF_table::GF_table ()
{
    power = 0;
    vector.resize (GROUP_DEGREE);
}
 
GF_table::GF_table (const GF_table& GF_element)
{
    power = GF_element.power;
    vector = GF_element.vector;
}
 
GF_table::~GF_table ()
{
 
}
 
GF_table& GF_table::operator= (const GF_table& right_hand_side)
{
    power = right_hand_side.power;
    vector = right_hand_side.vector;
 
    return *this;
}
 
std::vector<GF_table> init_GF_table (const std::vector<int>& primitive_polynomial = init_primitive_polynomial ())
{
    std::vector<GF_table> table;
    table.resize ((1 << GROUP_DEGREE) - 1);
 
    std::vector<int> temp_vec (GROUP_DEGREE, 0);
 
    temp_vec.at(0) = 1;
    table.at(0).vector = temp_vec;
 
    for (int i = 1; i < (1 << GROUP_DEGREE) - 1; ++i)
    {
        table.at(i).vector.at(0) = 0;
 
        for (int j = 1; j < GROUP_DEGREE; ++j)
            table.at(i).vector.at(j) = table.at(i - 1).vector.at(j - 1);
 
        if (table.at(i - 1).vector.at(GROUP_DEGREE - 1) == 1)
            for (int j = 0; j < GROUP_DEGREE; ++j)
                table.at(i).vector.at(j) = (table.at(i).vector.at(j) + primitive_polynomial.at(j)) % 2;
    }
 
    return table;
}
 
const std::vector<GF_table> table (init_GF_table ());
 
const std::vector<int> null_vector (GROUP_DEGREE, 0);
const std::vector<int> unit_vector (table.at(0).vector);

Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
/* * * * * * * * * * * * * * * * * * * * * * *
                    GF.h
* * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef GF_h
#define GF_h
 
#include "GF_table.h"
 
class GF 
{
private:
    int alpha_power; // представление в виде степени альфа
    std::vector<int> alpha_vector; // представление в виде вектора
    int null; // индикатор того, что вектор нулевой
 
    void power_to_vector (); // используем 
    void vector_to_power (); // GF_table
 
public:
    GF ();
    GF (const GF& GF_element);
    GF (const int power);
    GF (const std::vector<int> vector);
    ~GF ();
    
    GF& operator= (const GF& right_hand_side);
 
    GF operator+ (const GF& right_hand_side) const; // сложение
    GF operator* (const GF& right_hand_side) const; // умножение
    GF operator/ (const GF& right_hand_side) const;
 
    int return_power () const;
    std::vector<int> return_alpha_vector () const; // возврат элемента в виде вектора
};
 
#endif
 
/* * * * * * * * * * * * * * * * * * * * * * *
                    GF.cpp
* * * * * * * * * * * * * * * * * * * * * * */
 
#include "GF.h"
 
GF::GF ()
{
    alpha_power = 0;
    alpha_vector.resize (GROUP_DEGREE);
    null = 1;
}
 
GF::GF (const GF& GF_element)
{
    alpha_power = GF_element.alpha_power;
    alpha_vector = GF_element.alpha_vector;
    null = GF_element.null;
}
 
GF::GF (const int power)
{
    alpha_power = power;
    power_to_vector ();
    null = 0;
}
 
GF::GF (const std::vector<int> vector)
{
    alpha_vector = vector;
    vector_to_power ();
}
 
GF::~GF ()
{
 
}
 
GF& GF::operator= (const GF& right_hand_side)
{
    alpha_power = right_hand_side.alpha_power;
    alpha_vector = right_hand_side.alpha_vector;
    null = right_hand_side.null;
 
    return *this;
}
 
void GF::power_to_vector ()
{
    alpha_vector = table.at(alpha_power).vector;
}
 
void GF::vector_to_power ()
{
    if (alpha_vector != null_vector)
    {
        int i = 0;
        while (table.at(i).vector != alpha_vector)
            ++i;
 
        alpha_power = i;
        null = 0;
    }
    else
        null = 1;   
}
 
GF GF::operator+ (const GF& right_hand_side) const
{
    if (null == 1) 
        return right_hand_side;
    if (right_hand_side.null == 1)
        return *this;
 
    GF sum;
 
    for (int i = 0; i < GROUP_DEGREE; ++i)
        sum.alpha_vector.at(i) = (alpha_vector.at (i) + right_hand_side.alpha_vector.at (i)) % 2;
    
    if (sum.alpha_vector == null_vector)
    {
        sum.null = 1;
        return sum;
    }
 
    sum.vector_to_power ();
 
    return sum;
}
 
GF GF::operator* (const GF& right_hand_side) const
{
    if (null == 1)
        return *this;
    if (right_hand_side.null == 1)
        return right_hand_side;
 
    GF prod;
 
    prod.alpha_power = (alpha_power + right_hand_side.alpha_power) % ((1 << GROUP_DEGREE) - 1);
    
    prod.power_to_vector ();
    
    return prod;
}
 
GF GF::operator/ (const GF& right_hand_side) const
{   
    if (alpha_power - right_hand_side.alpha_power < 0)
    {
        GF div ((alpha_power - right_hand_side.alpha_power) % 
            ((1 << GROUP_DEGREE) - 1) + ((1 << GROUP_DEGREE) - 1));
        return div;
    }
    else
    {
        GF div ((alpha_power - right_hand_side.alpha_power) % ((1 << GROUP_DEGREE) - 1));
        return div;
    }
}
 
int GF::return_power () const
{
    return alpha_power;
}
 
std::vector<int> GF::return_alpha_vector () const
{
    return alpha_vector;
}

Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/* * * * * * * * * * * * * * * * * * * * * * *
                GF_polynom.h
* * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef GF_polynom_h
#define GF_polynom_h
 
#include "GF.h"
 
class GF_polynom
{
private:
    std::vector<GF> polynom; // вектор из коэфициентов полинома,
                             // которые принадлежат GF(2^m)
public:
    GF_polynom ();
    GF_polynom (const GF_polynom& GF_polynom_element);
    GF_polynom (const std::vector<GF>& coefficients);
    ~GF_polynom ();
 
    GF_polynom& operator= (const GF_polynom& right_hand_side);
 
    GF_polynom operator+ (const GF_polynom& right_hand_side) const; // сложение 
    GF_polynom operator* (const GF_polynom& right_hand_side) const; // умножение
    GF_polynom operator% (const GF_polynom& divisor) const; // остаток от деления
 
    void shift (const int shift_value);
 
    std::vector<GF> return_coefficients () const; // возвращает коэффициенты многочлена
};
 
#endif
 
/* * * * * * * * * * * * * * * * * * * * * * *
                GF_polynom.cpp
* * * * * * * * * * * * * * * * * * * * * * */
 
#include "GF_polynom.h"
 
GF_polynom::GF_polynom ()
{
 
}
 
GF_polynom::GF_polynom (const GF_polynom& GF_polynom_element):
polynom (GF_polynom_element.polynom)
{
 
}
 
GF_polynom::GF_polynom (const std::vector<GF>& coefficients):
polynom (coefficients)
{
 
}
 
GF_polynom::~GF_polynom ()
{
 
}
 
GF_polynom& GF_polynom::operator= (const GF_polynom& right_hand_side)
{
    polynom.resize (right_hand_side.polynom.size());
    polynom = right_hand_side.polynom;
 
    return *this;
}
 
GF_polynom GF_polynom::operator+ (const GF_polynom& right_hand_side) const
{
    GF_polynom sum;
    sum.polynom.reserve (std::max(polynom.size(), right_hand_side.polynom.size()));
 
    for (int i = 0; i < std::min(polynom.size(), right_hand_side.polynom.size()); ++i)
        sum.polynom.push_back (polynom.at(i) + right_hand_side.polynom.at(i));
 
    if (polynom.size() < right_hand_side.polynom.size())
        for (int i = polynom.size(); i < right_hand_side.polynom.size(); ++i)
            sum.polynom.push_back (right_hand_side.polynom.at(i));
    else
        for (int i = right_hand_side.polynom.size(); i < polynom.size(); ++i)
            sum.polynom.push_back (polynom.at(i));
    
    return sum;
}
 
GF_polynom GF_polynom::operator* (const GF_polynom& right_hand_side) const
{
    GF_polynom prod;
    prod.polynom.resize (polynom.size() + right_hand_side.polynom.size());
 
    for (int i = 0; i < prod.polynom.size(); ++i)
    {
        GF sum (null_vector);
 
        for (int j = 0; j < i + 1; ++j)
            if ((j < polynom.size()) && (i - j < right_hand_side.polynom.size()))
                sum = sum + (polynom.at(j) * right_hand_side.polynom.at(i - j));
        
        prod.polynom.push_back (sum);
    }
 
    return prod;
}
 
GF_polynom GF_polynom::operator% (const GF_polynom& divisor) const
{
    GF_polynom reminder (*this); // остаток
    GF_polynom multiplier; // множитель, на который умножаем делитель
                           // (имеет вид a * x^n )
    multiplier.polynom.resize (reminder.polynom.size() - divisor.polynom.size() + 1);
 
    multiplier.shift (reminder.polynom.size() - divisor.polynom.size());// заполняем нулями все, кроме последнего
    
    while (reminder.polynom.size() > divisor.polynom.size()) // пока степень остачи больше степени делителя
    {
        multiplier.polynom.at(reminder.polynom.size() - divisor.polynom.size()) = //коэффициент при x^(n-m)
            reminder.polynom.at(reminder.polynom.size() - 1) / divisor.polynom.at(divisor.polynom.size() - 1);                        // m - степень делителя
 
        reminder = reminder + (divisor * multiplier); // обнуляем коэффициент
                                                      // при старшей степени
        multiplier.polynom.pop_back(); // убираем старший коэф., остаются одни нули
        reminder.polynom.pop_back(); // убираем старштй коэф., поскольку он нулевой
    }
 
    return reminder; // возвращаем остаток
}
 
void GF_polynom::shift (const int shift_value)
{
    polynom.reserve (polynom.size() + shift_value);
 
    for (int i = 0; i < shift_value; ++i)
        polynom.push_back (null_vector);
}
 
std::vector<GF> GF_polynom::return_coefficients () const
{
    return polynom;
}

Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
/* * * * * * * * * * * * * * * * * * * * * * *
                RS_encoder.h
* * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef RS_encoder_h
#define RS_encoder_h
 
#include "GF_polynom.h"
#include <string>
 
extern const int CODE_LENGTH; // длина кода
extern const int MAX_ERRORS; // количество исправляемых ошибок
extern const int MESSAGE_LENGTH; // длина сообщения
 
const GF_polynom init_GF_primitive_polynomial (const std::vector<int>& primitive_polynomial);
 
std::vector<int> str_to_int (const std::string& str_message); // строку в вектор
std::vector<GF> message_to_GF_message (const std::vector<int>& message); // вектор из 0 и 1 в 
                                                                         // вектор из элементов GF(2^m)
GF_polynom encode (const std::vector<GF>& GF_message); // кодирование сообщения
std::vector<int> GF_code_to_vector (const std::vector<GF>& code);
 
#endif
 
/* * * * * * * * * * * * * * * * * * * * * * *
                RS_encoder.cpp
* * * * * * * * * * * * * * * * * * * * * * */
 
#include "RS_encoder.h"
 
const int MAX_ERRORS = 0;
const int CODE_LENGTH = 1 << GROUP_DEGREE - 1;
const int MESSAGE_LENGTH = 1 << GROUP_DEGREE - 1 - 2 * MAX_ERRORS;
 
const GF_polynom init_GF_primitive_polynomial (const std::vector<int>& primitive_polynomial = 
                                                init_primitive_polynomial(GROUP_DEGREE))
{
    std::vector<GF> GF_primitive_polynomial;
 
    for (auto iter = primitive_polynomial.begin(); iter != primitive_polynomial.end(); ++iter)
    {
        if (*iter == 0)
            GF_primitive_polynomial.push_back (null_vector);
        else
            GF_primitive_polynomial.push_back (unit_vector);
    }
 
    GF_primitive_polynomial.push_back (unit_vector);
 
    GF_polynom polynom (GF_primitive_polynomial);
    return polynom;
}
 
std::vector<int> str_to_int (const std::string& str_message)
{
    std::vector<int> int_message;
 
    for (auto iter = str_message.begin(); iter != str_message.end(); ++iter)
        int_message.push_back (*iter - '0');
 
    return int_message;
}
 
std::vector<GF> message_to_GF_message (const std::vector<int>& int_message)
{
    std::vector<int> message (int_message);
    message.reserve (GROUP_DEGREE * MESSAGE_LENGTH);
 
    for (int i = message.size(); i < GROUP_DEGREE * MESSAGE_LENGTH; ++i)
        message.push_back (0);
 
    std::vector<GF> GF_message;
 
    for (int i = 0; i < MESSAGE_LENGTH; ++i)
    {
        std::vector<int> one_symbol;
 
        for (int j = i * GROUP_DEGREE; j < (i + 1) * GROUP_DEGREE; ++j)
            one_symbol.push_back (message.at(j));
 
        GF_message.push_back (one_symbol);
    }
 
    return GF_message;  
}
 
GF_polynom encode (const std::vector<GF>& GF_message)
{
    GF_polynom u(GF_message);
    GF_polynom g(init_GF_primitive_polynomial());
    GF_polynom v;
 
    u.shift (2 * MAX_ERRORS);
 
    v = u + (u % g);
 
    return v;
}
 
std::vector<int> GF_polynom_to_vector (const GF_polynom& code)
{
    std::vector<GF> GF_messge (code.return_coefficients());
 
    std::vector<int> message;
 
    for (auto gf_iter = GF_messge.begin(); gf_iter != GF_messge.end(); ++gf_iter)
    {
        std::vector<int> temp (gf_iter->return_alpha_vector());
 
        for (auto iter = temp.begin(); iter != temp.end(); ++iter)
            message.push_back (*iter);
    }
 
    return message;
}

Чтобы вам не разбираться в тонкостях кода -- задавайте вопросы по каждому участку, а я постараюсь на них как можно более полно ответить.
Моя конечная цель была найти http://www.cyberforum.ru/cgi-bin/latex.cgi?v(x) = x^{n-k}u(x) + (x^{n-k}u(x) \mathrm {mod} g(x)).
 
Текущее время: 13:19. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru