Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.80/5: Рейтинг темы: голосов - 5, средняя оценка - 4.80
Gmails
6 / 6 / 2
Регистрация: 08.04.2014
Сообщений: 248
1

Характеристический многочлен матрицы произвольной размерности

03.10.2014, 11:16. Просмотров 924. Ответов 8
Метки нет (Все метки)

не могу придумать как реализовать характеристический многолчен:
дана матрица :http://www.cyberforum.ru/cgi-bin/latex.cgi?\begin{pmatrix}3 &1 \\ 2 &4 \end{pmatrix}
нужно найти ее характеристический многолчен:
http://www.cyberforum.ru/cgi-bin/latex.cgi?\begin{vmatrix}3-L & 1\\  2& 4-L\end{vmatrix}=http://www.cyberforum.ru/cgi-bin/latex.cgi?{L}^{2}+7L+10

Добавлено через 2 минуты
может кто знает,подскажите пожалуйста.читал форумы ничего не нашел.
0
QA
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
03.10.2014, 11:16
Ответы с готовыми решениями:

Рассчитать характеристический многочлен матрицы 3-го порядка
как закодить многочлен матрицы 3-го порядка?в нете ничего не нашел. Добавлено через 2 минуты...

Даны две матрицы произвольной размерности
При выполнении этого задания необходимо написать две функции. Одна из этих функций должна получать...

9. Матрица произвольной размерности, представленная раз* мерностями и динамическим массивом указателей на динамиче* ские массивы - строки матрицы.
Всем привет!помогите пожалуйста с задачей. Матрица произвольной размерности, представленная раз*...

Матрица произвольной размерности
Матрица произвольной размерности, представленная размерностями и линейным динамическим массивом...

Матрица произвольной размерности
Разработать класс, объект которого реализует «пользовательский» тип данных. Обеспечить его...

8
IrineK
Заблокирован
03.10.2014, 11:18 2
Вам именно в символьном виде записать многочлен:
L^2 - 7L + 10

Или найти решение уравнения:
L^2 - 7L + 10 = 0
0
Gmails
6 / 6 / 2
Регистрация: 08.04.2014
Сообщений: 248
03.10.2014, 11:46  [ТС] 3
в символьном виде
0
IrineK
Заблокирован
03.10.2014, 12:45 4
В общем виде для матрицы
http://www.cyberforum.ru/cgi-bin/latex.cgi?\begin{pmatrix}<br />
A & B\\ <br />
C & D<br />
\end{pmatrix}

получаем
http://www.cyberforum.ru/cgi-bin/latex.cgi?<br />
\begin{vmatrix}<br />
A-L & B\\ <br />
C & D-L<br />
\end{vmatrix} = (A-L)(D-L)-BC = AD - L(A+D) + L^2 - BC = L^2 - (A+D)L + (AD-BC)<br />

Т.е., нужно найти (A+D) и (AD-BC) , а затем - собрать соответствующую символьную строку.
1
03.10.2014, 12:45
Gmails
6 / 6 / 2
Регистрация: 08.04.2014
Сообщений: 248
03.10.2014, 17:02  [ТС] 5
а для трехмерной матрицы?как быть с коэффициентами?
0
IrineK
Заблокирован
03.10.2014, 18:47 6
Вам нужно решить задачу для матрицы произвольной размерности?
0
Gmails
6 / 6 / 2
Регистрация: 08.04.2014
Сообщений: 248
03.10.2014, 20:17  [ТС] 7
да...
0
Mr.X
Эксперт С++
3193 / 1720 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
11.10.2014, 11:46 8
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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
/////////////////////////////////////////////////////////////////////////////////////////
//дана матрица произвольной размерности. Нужно найти ее характеристический многолчен
//в символьном виде.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                 T_str;
typedef double                      T_coeff;
typedef std::vector < T_coeff   >   T_polynom_val;
typedef std::vector < T_coeff   >   T_row;
typedef std::vector < T_row     >   T_matr;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_polynom
{
    T_polynom_val  polynom_val_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_polynom( T_coeff  scalar_val = 0 )
    {
        polynom_val_.push_back( scalar_val );
    }
    //-----------------------------------------------------------------------------------
    T_polynom
        (
            T_coeff  coeff_0,
            T_coeff  coeff_1
        )
    {
        polynom_val_.push_back( coeff_0 );
 
        if( coeff_1 )
        {
            polynom_val_.push_back( coeff_1 );
        }
    }
    //-----------------------------------------------------------------------------------
    T_str   to_str_with_var_symb( char  var_symb )                                  const
    {
        static  const   char    MINUS_SYMB  =   '-';
        static  const   char    PLUS_SYMB   =   '+';
        static  const   char    MULT_SYMB   =   '*';
        static  const   char    POW_SYMB    =   '^';
        static  const   char    SPACE_SYMB  =   ' ';
 
        T_str  res_str;
 
        for( int  i = get_degree(); i >= 0; --i )
        {
            auto    const   &   coeff   =   (*this)[i];
 
            bool    to_print_member             =       coeff
                                                    ||  get_degree()    ==  0;
 
            bool    to_print_sign               =       i       !=  get_degree()
                                                    ||  coeff   <   0;
 
            bool    to_print_space_after_sign   =       to_print_sign
                                                    &&  i   !=  get_degree();
 
            bool    to_print_coeff              =       i               ==  0
                                                    ||  abs( coeff )    !=  1.0;
 
            bool    to_print_var_symbol         =   i   >   0;
 
            bool    to_print_mult_symbol        =       to_print_coeff
                                                    &&  to_print_var_symbol;
 
            bool    to_print_pow_symb_and_pow   =       to_print_var_symbol
                                                    &&  i   !=  1;
 
            if( to_print_member )
            {
                std::ostringstream  sout;
 
                if( to_print_sign )
                {
                    sout    <<  (
                                    coeff   <   0
                                        ?   MINUS_SYMB
                                        :   PLUS_SYMB
                                );
                }//if
 
                if( to_print_space_after_sign )
                {
                    sout    <<  SPACE_SYMB;
                }
 
                if( to_print_coeff )
                {
                    sout    <<  abs( coeff );
                }
 
                if( to_print_mult_symbol )
                {
                    sout    <<  MULT_SYMB;
                }
 
                if( to_print_var_symbol )
                {
                    sout    <<  var_symb;
                }
 
                if( to_print_pow_symb_and_pow )
                {
                    sout    <<  POW_SYMB
                            <<  i;
                }
 
                sout    <<  SPACE_SYMB;
 
                res_str     +=  sout.str();
            }//if
        }//for
 
        return  res_str;
    }
    //-----------------------------------------------------------------------------------
    T_polynom   const   &  operator+= ( T_polynom   const   &  polynom )
    {    
        T_polynom   right_polynom( polynom );
 
        to_increase_degree_if_is_less                   (   right_polynom.get_degree    ()  );
        right_polynom.to_increase_degree_if_is_less     (   get_degree                  ()  );
 
        std::transform
            (
                polynom_val_                .begin      (),
                polynom_val_                .end        (),
                right_polynom.polynom_val_  .begin      (),
                polynom_val_                .begin      (),
                std::plus< T_polynom_val::value_type >  ()
            );
 
        return  *this;
    }
    //-----------------------------------------------------------------------------------
    T_polynom   const   &   operator*= ( T_polynom  const   &   polynom )
    {
        T_polynom   res_polynom;
 
        res_polynom.to_increase_degree_if_is_less
            (
                    get_degree          ()
                +   polynom.get_degree  ()
            );
 
        for( size_t  i = 0; i < polynom_val_.size(); ++i )
        {
            for( size_t  j = 0; j < polynom.polynom_val_.size(); ++j )
            {
                    res_polynom.polynom_val_    [i + j]
                +=      polynom_val_            [i]
                    *   polynom.polynom_val_    [j];
            }//for
        }//for
 
        std::swap
            (
                *this,
                res_polynom
            );
 
        return  *this;
    }
    //-----------------------------------------------------------------------------------
    int  get_degree()                                                               const
    {
        return  polynom_val_.size() - 1;
    }
    //-----------------------------------------------------------------------------------
    T_coeff  operator[] ( int  ind )                                                const
    {
        return  polynom_val_[ind];
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  to_increase_degree_if_is_less( int  degree_val )
    {
        if  (
                get_degree() < degree_val
            )
        {
            polynom_val_.resize( degree_val + 1 );
        }
    }
    //-----------------------------------------------------------------------------------
};
0
Mr.X
Эксперт С++
3193 / 1720 / 435
Регистрация: 03.05.2010
Сообщений: 3,867
11.10.2014, 11:48 9
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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
/////////////////////////////////////////////////////////////////////////////////////////
T_polynom   operator*
    (
        T_polynom   const   &   L,
        T_polynom   const   &   R
    )
{
    T_polynom   res     =   L;
    return      res     *=  R;
}
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector < T_polynom         >   T_polynom_row;
typedef std::vector < T_polynom_row     >   T_polynom_matr;
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  TT_container >
void    erase_from_elem_with_ind
    (
        TT_container    &   container,
        int                 ind
    )
{
    auto    it  =   container.begin     ();
    std::advance                        ( it,   ind );
    container.erase                     ( it );
}
/////////////////////////////////////////////////////////////////////////////////////////
T_polynom_matr  get_minor
    (
        T_polynom_matr  const   &   polynom_matr,
        int                         i,
        int                         j
    )
{
    T_polynom_matr  res_matr    =   polynom_matr;
    erase_from_elem_with_ind( res_matr,  i );
 
    std::for_each
        (
            res_matr.begin  (),
            res_matr.end    (),
 
            [=] ( T_polynom_row     &   row )
            {
                erase_from_elem_with_ind( row,   j );
            }
        );
 
    return  res_matr;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_polynom   det( T_polynom_matr  const   &   polynom_matr )
{
    T_polynom   res_polynom;
 
    int     matr_dim    =   polynom_matr.size();
 
    if( matr_dim    ==  1 )
    {
        res_polynom     =   polynom_matr[0][0];
    }
    else
    {
        for( int  j = 0; j < matr_dim; ++j )
        {
            res_polynom     +=      pow( -1.0, 1 + j )
                                *   polynom_matr[1][j]
                                *   det (
                                            get_minor( polynom_matr, 1, j )
                                        );
        }//for
    }//else
 
    return  res_polynom;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_polynom_matr  get_charact_matr( T_matr    const   &   matr )
{
    int             matr_dim    =   matr.size();
 
    T_polynom_matr  res_matr
                        (
                            matr_dim,
                            T_polynom_row( matr_dim )
                        );
 
    for( int  i = 0; i < matr_dim; ++i )
    {
        for( int  j = 0; j < matr_dim; ++j )
        {
            res_matr[i][j]  =   i   ==  j
                                    ?   T_polynom( matr[i][j],   -1  )
                                    :   T_polynom( matr[i][j]        );
        }//for
    }//for
 
    return  res_matr;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_str   get_charact_polynom_str_of_matr_with_var_symb
    (
        T_matr  const   &   matr,
        char                var_symb
    )
{
    return  det (
                    get_charact_matr( matr )
                )
                .to_str_with_var_symb( var_symb );
}
/////////////////////////////////////////////////////////////////////////////////////////
void    print_matr( T_matr  const   &   matr )
{
    std::for_each
        (
            matr.begin  (),
            matr.end    (),
 
            []  ( T_matr::value_type    row )
            {
                std::copy
                    (
                        row.begin                                                   (),
                        row.end                                                     (),
                        std::ostream_iterator< T_matr::value_type::value_type >     ( std::cout, "\t" )
                    );
 
                std::cout   <<  std::endl;
            }
        );
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
 
    const   char    VAR_SYMB    =   'L';
 
    for(;;)
    {
        int     matr_dim    =   rand() % 7  + 1;
 
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "Размерность матрицы: "
                    <<  matr_dim
                    <<  std::endl;
 
        T_matr  matr
                    (
                        matr_dim,
                        T_row( matr_dim )
                    );
 
        for( int  i = 0; i < matr_dim; ++i )
        {
            for( int  j = 0; j < matr_dim; ++j )
            {
                double  matr_elem   =       rand() % 10
                                        *   ( rand() % 2 );
 
                matr_elem   *=  matr_elem
                                    ?   pow( -1.0, rand() % 2 )
                                    :   1;
 
                matr[i][j]  =   matr_elem;
            }//for
        }//for
 
        print_matr( matr );
 
        T_str   charact_polynom_str     =   get_charact_polynom_str_of_matr_with_var_symb
                                                (
                                                    matr,
                                                    VAR_SYMB
                                                );
 
        std::cout   <<  "Характеристический многочлен матрицы:"
                    <<  std::endl
                    <<  charact_polynom_str
                    <<  std::endl;
 
        system("pause");
    }//for
}
0
11.10.2014, 11:48
Answers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
11.10.2014, 11:48

Массив произвольной размерности и работа с ним
Доброго времени суток. Появилась интересная задача: создать функцию для создания массива,...

Разработать класс Vector – геометрический вектор произвольной размерности
Разработать класс Vector – геометрический вектор произвольной размерности (размерность задается в...

Содержимое матрицы размерности n x n повернуть на 90 по часовой стрелке вокруг центра симметрии матрицы. Исходная матрица вводится из файла
Help me plz


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
9
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2019, vBulletin Solutions, Inc.