Форум программистов, компьютерный форум 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
08.11.2012, 02:44  [ТС]     Многочлены над GF(2^m)
Т.е. Объявлен и Не реализован.
Я думал, что если его объявить и не реализовать, то он реализуется сам по себе. А что в нём написать? Или лучше его пустым оставить?
Поправил первые два файлика, вроди всё работает. Гляньте ещё разок, на всякий.
Кликните здесь для просмотра всего текста
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
/* * * * * * * * * * * * * * * * * * * * * * *
                    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; // умножение
 
    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 ();
}
 
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;
}
 
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
/* * * * * * * * * * * * * * * * * * * * * * *
                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& right_hand_side) const; // остаток от деления
 
    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.resize (GF_polynom_element.polynom.size());
    polynom = GF_polynom_element.polynom;
}
 
GF_polynom::GF_polynom (const std::vector<GF>& coefficients)
{
    polynom.resize (coefficients.size ());
    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.resize (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& right_hand_side) const
{
 
}
 
std::vector<GF> GF_polynom::return_coefficients () const
{
    return polynom;
}
 
Текущее время: 18:29. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru