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

Программа упрощения полиномов - C++

Восстановить пароль Регистрация
 
Рейтинг: Рейтинг темы: голосов - 10, средняя оценка - 5.00
anonymous!
0 / 0 / 0
Регистрация: 12.08.2011
Сообщений: 3
12.08.2011, 18:51     Программа упрощения полиномов #1
Добрый день!
Нуждаюсь в помощи или совете.
Столкнулся со следующей задачей: на вход программы из текстового файла поступает выражение вида:
p^2*(2*p^2+11*p-1)*(3*p+1)-4*p*(p+6)+12*p*(3*p^2-6*p+1)+8
на выходе нужно представить полином в нормальном виде (для данного случая будет):
6*p^5+35*p^4+44*p^3-77*p^2-12*p+8

Пока дошел только до разбиения входной строки на строки вида:
p^2*(2*p^2+11*p-1)*(3*p+1)
-4*p*(p+6)
12*p*(3*p^2-6*p+1)
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
ifstream in_s("s.txt");
    if (!in_s) exit(1);
    in_s>>s;
    in_s.close();
    
    n=i=j=0;
    for ( i; s[i] != '\0' ; i++ ) 
    {
        s1[j][i-n]=s[i];
        s1[j][i-n+1]='\0';
 
        if(s[i] == ')' && s[i+1] == '-')
        {
            n=i+1;
            j++;
        }
 
        if(s[i] == ')' && s[i+1] == '+')
        {
            n=i+2;
            j++; i++;
        }
    }
s[i] - входная строка
s1[i][j] - массив из слагаемых входной строки (в данном случае их 4)

Но как синтаксически проанализировать каждый из этих полиномов и записать, к примеру, коэффициенты каждого из них по степеням в массивы никак не додумаюсь. В данном треде Разбор математических выражений вроде разобрался, но там при вычислении известно p. Помогите, пожалуйста =))

Добавлено через 2 часа 14 минут
Дело даже не в коде, код я напишу. Не могу придумать подходящий алгоритм действий.
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
12.08.2011, 18:51     Программа упрощения полиномов
Посмотрите здесь:

Деление полиномов C++
C++ Реализовать программу умножения полиномов
C++ Сортировка списков (Умножение полиномов)
Умножение полиномов C++
C++ Деление полиномов
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Preveter
 Аватар для Preveter
9 / 9 / 1
Регистрация: 11.08.2011
Сообщений: 66
12.08.2011, 18:55     Программа упрощения полиномов #2
А тут нет ничего сверхъестественного.
Можно воспользоваться рекурсией и последовательно вычленять два очередных перемножающихся полинома (скобка или переменная в степени) и превращать их в один полином. При этом если внутри одного из них встречаются ещё скобки, то рекурсивная функция упрощения такого вида вещей просто вызывает саму себя, но в качестве параметра передаёт только тот полином, внутри которого есть ещё скобки.

Вот примерный алгоритм для функции упрощения части выражения:
0. Функция принимает строку, те есть полином
1. Ищем два перемножающихся полинома
2. Если в первом внутри есть скобки то вызываем ЭТУ ФУНКЦИЮ, но в качестве аргумента выступает первый полином
2. Если во втором внутри есть скобки то вызываем ЭТУ ФУНКЦИЮ, но в качестве аргумента выступает второй полином
3. Заменяем старый вариант первого полинома на новый. Тоже со вторым
4. Перемножаем по обычным правилам. Это не должно составить труда
anonymous!
0 / 0 / 0
Регистрация: 12.08.2011
Сообщений: 3
12.08.2011, 19:27  [ТС]     Программа упрощения полиномов #3
Согласен. Но проблема не в перемножении элементов, т.е. делать-то однозначно через рекурсию, а именно в том как из входной строки грамотно сформировать массивы отдельных полиномов. Кстати, вложенность скобок не предполагается.

Т.е., к примеру полином p^2*(2*p^2+11*p-1)*(3*p+1) представить в виде:
a[1]={ 0 0 1} \
a[2]={-1 11 2} > эти вектора я перемножу и получу упрощенную первую часть
a[3]={ 1 3 0} /

a_new={0 0 -1 8 35 6}

Для полинома -4*p*(p+6):
b[1]={ 0 -4 0}
b[2]={ 6 1 0}

b_new={0 -24 -4}

Для полинома 12*p*(3*p^2-6*p+1)
c[1]={0 12 0}
c[2]={1 -6 3}

c_new={0 12 -72 36}

Для полинома 8
d[1]={8 0 0}

d_new={8 0 0}

Дальше я перемножу между собой все a[1..3], b[1..2], c[1..2] и d[1], а потом уже сложу их между собой по степеням, ну, т.е. а_new+b_new+c_new+d.

Но вот как из строки вычленить отдельные полиномы, записать их коэффициенты по степеням в целочисленные массивы понять не могу.
Preveter
 Аватар для Preveter
9 / 9 / 1
Регистрация: 11.08.2011
Сообщений: 66
12.08.2011, 20:28     Программа упрощения полиномов #4
для начала можно определить максимальную степень (макс число после знака "^"), чтобы потом не париться с динамическими массивами хотя бы здесь.

Потом просматриваем каждую часть из твоего разбиения:
- Когда находим переменную, то смотрим, что стоит перед ней: если "число*" и НЕ "^число*", то коэффициент равен этому числу, а если нет - то коэффициент равен 1.\
- А чтобы определить степень смотрим символ после неё: если "^", то за ним последует степень, т.е. положение элемента в массиве. Если же нет, то степень равна 1.

PS Каковы ограничения у твоего исходного выражения?
anonymous!
0 / 0 / 0
Регистрация: 12.08.2011
Сообщений: 3
13.08.2011, 00:21  [ТС]     Программа упрощения полиномов #5
Условно говоря, ограничения следующие: входная строка вида
<произведение a полиномов>+<произведение b полиномов>+...+<произведение x полиномов>
В тестах количество таких слагаемых не превосходит 4, но может быть и 5, и 7 и т.д.
В тестах максимальная степень отдельно взятого полинома не превосходит двух, но чисто теоритически может быть равна и 3, и 5 и т.д., но в пределах десяти.
Просто изначально задача гораздо глобальнее и сложнее, и потом в качестве коэффициентов будут символьные переменные, которые определяются пользователем в отдельном файле. Поэтому я пытаюсь потренироваться "на кошках" =) Чтобы просто пришло понимание.
Я думаю в этом же направлении, но в таком случае получается множество циклов с множеством условий, я думал, что вдруг есть уже крутой отлаженный алгоритм определения наподобие приводящегося в ссылке Разбор математических выражений , там в комментах предлагается каждому оператору присваивается приоритет, потом с помощью стеков они вычисляют значение выражения, только тут мне p не известно.
Но спасибо, попробую побиться в этом направлении.
Preveter
 Аватар для Preveter
9 / 9 / 1
Регистрация: 11.08.2011
Сообщений: 66
13.08.2011, 09:45     Программа упрощения полиномов #6
Можно сначала посчитать количество "частей" типа (полином*полином*...*полином). Это будет первое измерение трёхмерного массива.
Потом считаем макс. количество полиномов в "частях". Это -- второе измерение.
А макс. степень - третье измерение.

Затем:

Просматривая полином M части N мы записываем коэффициент при степени K в позицию a[n][m][k].

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

Перемножая члены полиномов в соответствии с правилами, заполняем массив b
Просматривая часть N мы записываем коэффициент при степени K в позицию b[n][k]

Затем формируем одномерный массив с с размером, какой был у второго измерения массива b, и просто складываем соответствующие степени.

А потом вывести то что получится не составит проблем
Mr.X
Эксперт С++
 Аватар для Mr.X
2807 / 1583 / 248
Регистрация: 03.05.2010
Сообщений: 3,697
13.08.2011, 17:42     Программа упрощения полиномов #7
Сообщение было отмечено автором темы, экспертом или модератором как ответ
Можно методом рекурсивного спуска сделать:
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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
/////////////////////////////////////////////////////////////////////////////////////////
//  На вход программы из текстового файла поступает выражение вида:
//  p^2*(2*p^2+11*p-1)*(3*p+1)-4*p*(p+6)+12*p*(3*p^2-6*p+1)+8
//  на выходе нужно представить полином в нормальном виде (для данного случая будет):
//  6*p^5+35*p^4+44*p^3-77*p^2-12*p+8
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <functional>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string         T_str;
typedef int                 T_num;
typedef std::vector<T_num>  T_polynom_val;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_polynom
{
    T_polynom_val  polynom_val_;
    //-----------------------------------------------------------------------------------
public:
    T_polynom(T_num  scalar_val = 0)
    {
        set_scalar(scalar_val);
    }
    //-----------------------------------------------------------------------------------
    const  T_polynom&  operator+= (const T_polynom&  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;
    }
    //-----------------------------------------------------------------------------------
    const  T_polynom&  operator*= (const T_polynom&  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];
            }        
        }
        polynom_val_ = res_polynom.polynom_val_;
        return  *this;
    }
    //-----------------------------------------------------------------------------------
    void  set_scalar(T_num  scalar_val)
    {
        polynom_val_ = T_polynom_val(1, scalar_val);
    }
    //-----------------------------------------------------------------------------------
    void  set_x_with_degree(int  degree_val)
    {
        polynom_val_ = T_polynom_val(degree_val + 1);
        polynom_val_[degree_val] = 1;
    }
    //-----------------------------------------------------------------------------------
    const  T_polynom&  operator-= (const T_polynom&  polynom)
    {
        T_polynom  minus_polynom(polynom);
        minus_polynom.operator *=(-1);
        return operator+=(minus_polynom);
    }
    //-----------------------------------------------------------------------------------
    int  get_degree() const
    {
        return  polynom_val_.size() - 1;
    }
    //-----------------------------------------------------------------------------------
    T_num  operator[] (int  ind) const
    {
        return  polynom_val_[ind];
    }
    //-----------------------------------------------------------------------------------
    void  to_increase_degree_if_is_less(int  degree_val)
    {
        if(get_degree() < degree_val)        
        {
            polynom_val_.resize(degree_val + 1);
        }       
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
class T_calculator
{
    enum
    {
        LEFT_PARENTHESIS   = '(',
        RIGHT_PARENTHESIS  = ')',               
        
        PLUS_SIGN          = '+',
        MINUS_SIGN         = '-',        
 
        ASTERISK           = '*',
 
        P_SYMB             = 'p',
        POW_SYMB           = '^',
        FINISH_SYMB        = '$'
    };
public:
    T_calculator();    
private:
    //-----------------------------------------------------------------------------------   
    void  remove_spaces             (T_str&  s);
    bool  calc_expr                 (const T_str&  s_inp, T_str&  s_out, T_polynom&  res); 
    bool  calc_summand              (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_line_of_summand      (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_factor               (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_line_of_factor       (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_add_summand          (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_subtract_summand     (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_mult_to_factor       (const T_str&  s_inp, T_str&  s_out, T_polynom&  res); 
    bool  calc_minus_factor         (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_expr_in_brackets     (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_p_expr               (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);
    bool  calc_scalar               (const T_str&  s_inp, T_str&  s_out, T_polynom&  res);    
    bool  calc_num                  (const T_str&  s_inp, T_str&  s_out, T_num&      res);   
 
    bool  calc_plus                 (const T_str&  s_inp, T_str&  s_out);
    bool  calc_asterisk             (const T_str&  s_inp, T_str&  s_out);
    bool  calc_minus                (const T_str&  s_inp, T_str&  s_out);
    bool  calc_left_parenthesis     (const T_str&  s_inp, T_str&  s_out);
    bool  calc_right_parenthesis    (const T_str&  s_inp, T_str&  s_out);
    bool  calc_p_symb               (const T_str&  s_inp, T_str&  s_out);
    bool  calc_pow_symb           (const T_str&  s_inp, T_str&  s_out);
 
    bool  calc_symb                 (const char c, const T_str&  s_inp, T_str&  s_out);
 
    T_str  get_polynom_str          (const T_polynom&  res);
};
/////////////////////////////////////////////////////////////////////////////////////////
void  T_calculator::remove_spaces(T_str&  s)
{    
    for(;;)
    {
        T_str::size_type  pos = s.find_first_of(" \t");   
        if(pos == T_str::npos)
        {
            break;
        }
        s = s.erase(pos, 1);
    }    
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{    
    return     calc_summand         (s_inp, s_out, res)
            && calc_line_of_summand (s_out, s_out, res);            
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_summand
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{    
    return     calc_factor         (s_inp, s_out, res)
            && calc_line_of_factor (s_out, s_out, res);   
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_line_of_summand
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{   
    switch(s_inp[0])
    {
    case PLUS_SIGN:
        return     calc_add_summand      (s_inp, s_out, res)
                && calc_line_of_summand  (s_out, s_out, res);
    case MINUS_SIGN:
        return     calc_subtract_summand (s_inp, s_out, res)
                && calc_line_of_summand  (s_out, s_out, res);
    default:
        return  true;
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_add_summand
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{    
    T_polynom  res_summand;
    bool       bool_res =     calc_plus    (s_inp, s_out)
                           && calc_summand (s_out, s_out, res_summand);
    res += res_summand;
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_line_of_factor
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{
    switch(s_inp[0])
    {
    case ASTERISK:
        return     calc_mult_to_factor  (s_inp, s_out, res)
                && calc_line_of_factor  (s_out, s_out, res);
    default:
        return  true;
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_mult_to_factor
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{    
    T_polynom  res_factor;
    bool   bool_res =     calc_asterisk (s_inp, s_out)
                       && calc_factor   (s_out, s_out, res_factor);
    res *= res_factor;
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_asterisk(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(ASTERISK, s_inp, s_out);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_symb(const char c, const T_str&  s_inp, T_str&  s_out)
{    
    bool  res = (s_inp[0] == c);
    if(res)
    {        
        s_out = s_inp.substr(1);
    }
    return res;    
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_factor
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{    
    switch(s_inp[0])
    {
    case MINUS_SIGN:
        return  calc_minus_factor           (s_inp, s_out, res);
    case LEFT_PARENTHESIS:
        return  calc_expr_in_brackets       (s_inp, s_out, res);
    case P_SYMB:
        return  calc_p_expr                 (s_inp, s_out, res);
    default:
        return  calc_scalar                 (s_inp, s_out, res);
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_minus_factor
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{    
    bool   bool_res =    calc_minus  (s_inp, s_out)
                      && calc_factor (s_out, s_out, res);
    res *= -1;
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_expr_in_brackets
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{
    return     calc_left_parenthesis  (s_inp, s_out)
            && calc_expr              (s_out, s_out, res)
            && calc_right_parenthesis (s_out, s_out);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_p_expr
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{
    bool  bool_res = calc_p_symb(s_inp, s_out);
    if(bool_res)
    {
        int  p_degree_val = 1;
        if( calc_pow_symb(s_out, s_out) )
        {
            bool_res = calc_num(s_out, s_out, p_degree_val);
            if(bool_res)
            {
                res.set_x_with_degree(p_degree_val);
            }
        }
        else
        {
            res.set_x_with_degree(p_degree_val);            
        }
    }
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_scalar
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{
    T_num  num_val   = 0;
    bool   bool_res  = calc_num(s_inp, s_out, num_val);
    if(bool_res)
    {
        res.set_scalar(num_val);
    }
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_minus(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(MINUS_SIGN, s_inp, s_out);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_left_parenthesis(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(LEFT_PARENTHESIS, s_inp, s_out);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_right_parenthesis(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(RIGHT_PARENTHESIS, s_inp, s_out);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_p_symb(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(P_SYMB, s_inp, s_out);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_pow_symb(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(POW_SYMB, s_inp, s_out);
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_num
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_num&        res
    )
{
    std::istringstream  sin(s_inp);    
    bool  bool_res = ((sin >> res) != 0);
    sin >> s_out;
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_subtract_summand
    (
        const T_str&  s_inp, 
        T_str&        s_out, 
        T_polynom&    res
    )
{    
    T_polynom  res_summand;
    bool   bool_res =     calc_minus   (s_inp, s_out)
                       && calc_summand (s_out, s_out, res_summand);
    res -= res_summand;
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  T_calculator::calc_plus(const T_str&  s_inp, T_str&  s_out)
{
    return  calc_symb(PLUS_SIGN, s_inp, s_out);
}
/////////////////////////////////////////////////////////////////////////////////////////
T_str  T_calculator::get_polynom_str(const T_polynom&  polynom)
{    
    T_str  res_str;
    for(int  i = polynom.get_degree(); i >= 0; --i)
    {
        std::ostringstream  sout;
        if(polynom[i] > 0)
        {
            sout << '+';
        }
 
        if(     polynom[i] == -1
            &&  i > 0           )
        {
            sout << '-';
        }
 
        if(    (   polynom[i]
                || i == 0 && res_str.empty() )
            &&
               (   abs(polynom[i]) != 1
                || i == 0 )
          )
        {
            sout << polynom[i]; 
            if(i > 0)
            {
                sout << '*';
            }
        }
 
        if(   polynom[i]
           && i > 0     )
        {
            sout << 'p';
            if(i != 1)
            {
                sout << '^'
                     << i;
            }
        }   
        res_str += sout.str();    
    }
    if(   !res_str.empty()
       && res_str[0] == '+')
    {
        res_str = res_str.substr(1);    
    }
    return  res_str;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_calculator::T_calculator()
{                      
    std::cout << "-> ";
    T_str  s_inp;
    std::getline(std::cin, s_inp);
    if(s_inp.empty()) exit(0);
    remove_spaces(s_inp);
    T_str      s_out; 
    T_polynom  res;
    if(    calc_expr(s_inp += FINISH_SYMB, s_out, res)
        && s_out == T_str(1, FINISH_SYMB)   )
    {
        std::cout << "Результирующий полином: "
                  << std::endl
                  << get_polynom_str(res);               
    }
    else
    {
        std::cout << "Выражение некорректно.";
    }
 
    std::cout << std::endl
              << std::endl
              << std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{ 
    std::locale::global(std::locale(""));
    for(;;)
    { 
        T_calculator  calculator;        
    }   
}
Mayonez
 Аватар для Mayonez
379 / 271 / 20
Регистрация: 26.12.2009
Сообщений: 875
13.08.2011, 17:52     Программа упрощения полиномов #8
Mr.X, что означает приставка T_ ?
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
13.08.2011, 18:00     Программа упрощения полиномов
Еще ссылки по теме:

C++ Move семантика (класс полиномов)
Создание цикла для упрощения кода C++
Написать программу: умножение полиномов C++

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

Или воспользуйтесь поиском по форуму:
Mr.X
Эксперт С++
 Аватар для Mr.X
2807 / 1583 / 248
Регистрация: 03.05.2010
Сообщений: 3,697
13.08.2011, 18:00     Программа упрощения полиномов #9
Цитата Сообщение от Mayonez Посмотреть сообщение
Mr.X, что означает приставка T_ ?
Да это я так свои типы называю, чтобы сразу в глаза бросались.
Yandex
Объявления
13.08.2011, 18:00     Программа упрощения полиномов
Ответ Создать тему
Опции темы

Текущее время: 13:32. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru