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

Создание класса, представляющего многочлен - C++

Восстановить пароль Регистрация
 
Domen0
Сообщений: n/a
06.08.2010, 11:10     Создание класса, представляющего многочлен #1
Доброго времени суток, Профессионалы!
Имеется задание:
Создать класс Polynom ( многочлен ) с операциями +, +=, -, -=, =, ==, !=, >, <, >=, <=, *, *=
Для выполнения операций >, <, >=, <=, надо подставить некоторое число вместо X?
И , что делать с ==, != ?
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
06.08.2010, 11:10     Создание класса, представляющего многочлен
Посмотрите здесь:

Возможно ли создание объекта шаблонного класса в функции этого класса? C++
Создание экземпляр класса из другого класса C++
Даны действительное число а, многочлен степени n. Получить многочлен (x^2+2ax+3)*P(x) C++
Явное создание экземпляра класса и явная специализация шаблона класса C++
C++ Пример класса с конструктором и деструктором, создание экземпляра класса через конструктор с параметрами
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Евгений М.
1033 / 974 / 53
Регистрация: 28.02.2010
Сообщений: 2,817
Завершенные тесты: 2
06.08.2010, 11:17     Создание класса, представляющего многочлен #2
Скорее всего надо сравнивать степени многочлена.

Цитата Сообщение от Domen0 Посмотреть сообщение
надо подставить некоторое число вместо X?
Это как?
Nameless One
Эксперт С++
 Аватар для Nameless One
5755 / 3404 / 255
Регистрация: 08.02.2010
Сообщений: 7,393
06.08.2010, 11:53     Создание класса, представляющего многочлен #3
Цитата Сообщение от Domen0 Посмотреть сообщение
И , что делать с ==, != ?
Ну очевидно же, что два многочлена равны, если их коэффициенты при соответствующих степенях x равны между собой.
А вот что делать с остальными операторами сравнения, и вправду непонятно...
Johnny_D
Padawan
 Аватар для Johnny_D
472 / 322 / 9
Регистрация: 30.01.2010
Сообщений: 1,841
06.08.2010, 11:59     Создание класса, представляющего многочлен #4
Проверять коэффициенты старших степеней, потом более младших, если число >1 и положительно, >1 и отрицательно, <1 и положитель, и <1 и отрицательно. Приблизительный ответ можно дать сразу.
Nameless One
Эксперт С++
 Аватар для Nameless One
5755 / 3404 / 255
Регистрация: 08.02.2010
Сообщений: 7,393
06.08.2010, 14:21     Создание класса, представляющего многочлен #5
Johny_D, чего-то я не понял. Объясни, пожалуйста, на примере, как сравнить два следующих многочлена: http://www.cyberforum.ru/cgi-bin/latex.cgi?2.5 + 3{x} - 5{x}^{2} + 18{x}^{3} и http://www.cyberforum.ru/cgi-bin/latex.cgi?-2 + 9.6{x} - 200{x}^{2} + 10{x}^{3}?

Добавлено через 38 минут
Кстати, можно будет определить методы, возвращающие производную и первообразную...

Добавлено через 1 час 26 минут
Вот моя реализация:
Как должны работать операторы >=, <=, >, <, я так и не додумался.
Тестил, вроде все работает правильно:
polynom.h
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
#ifndef POLYNOM_H
#define POLYNOM_H
 
#include <iostream>
#include <iomanip>
 
namespace my
{
    class polynom
    {
    public:
        polynom(char letter = DEFAULT_LETTER);
        polynom(size_t size, const double* coeffs, char letter = DEFAULT_LETTER);
        polynom(const polynom& rhs);
        ~polynom();
 
        double operator () (double X) const; // Возвращает значение полинома для x=X
        polynom& operator = (const polynom& rhs);
        polynom operator - () const;
        bool operator == (const polynom& rhs) const;
        bool operator != (const polynom& rhs) const;
        polynom operator + (const polynom& rhs) const;
        polynom& operator += (const polynom& rhs);
        polynom operator - (const polynom& rhs) const;
        polynom& operator -= (const polynom& rhs);
        polynom operator * (const polynom& rhs) const;
        polynom& operator *= (const polynom& rhs);
 
        polynom derivative() const; // Возвращает производную
        polynom antiderivative() const; // Возвращает первообразную
 
        friend std::ostream& operator << (std::ostream& os, const polynom& rhs);
 
    private:
        // Массив, в котором хранятся коэффициенты полинома:
        // i-тый коэффициент при i-той степени
        double*     m_pCoeffs;
        size_t      m_nSize; // Размер полинома
        char        m_cLetter; //Символ для вывода (только латинские буквы любого регистра)
 
        static const char DEFAULT_LETTER = 'x';
    };
};
 
#endif

polinom.cpp
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
#include "polynom.h"
 
#include <algorithm>
#include <map>
#include <stdexcept>
 
namespace my
{
    polynom::polynom(char letter)
        : m_nSize(0), m_pCoeffs(NULL)
    {
        char lower = tolower(letter);
        if((letter < 'a') || (letter > 'z'))
            throw(std::invalid_argument("Invalid letter"));
        m_cLetter = letter;
    }
 
 
    polynom::polynom(size_t size, const double* coeffs, char letter)
        : m_nSize(size)
    {
        char lower = tolower(letter);
        if((letter < 'a') || (letter > 'z'))
            throw(std::invalid_argument("Invalid letter"));
        m_cLetter = letter;
        m_pCoeffs = new double [m_nSize];
        std::copy(coeffs, coeffs + m_nSize, m_pCoeffs);
    }
 
 
    polynom::polynom(const polynom& rhs)
        : m_nSize(rhs.m_nSize), m_cLetter(rhs.m_cLetter)
    {
        m_pCoeffs = new double [m_nSize];
        std::copy(rhs.m_pCoeffs, rhs.m_pCoeffs + m_nSize, m_pCoeffs);
    }
 
    polynom::~polynom()
    {
        delete[] m_pCoeffs;
        m_nSize = 0;
    }
 
 
    double polynom::operator () (double X) const
    {
        double returnValue = 0;
        double pow = 1;
        for(size_t i = 0; i < m_nSize; ++i, pow *= X)
            returnValue += m_pCoeffs[i] * pow;
        return returnValue;
    }
 
 
    polynom& polynom::operator = (const polynom& rhs)
    {
        m_nSize = rhs.m_nSize;
        m_pCoeffs = new double [m_nSize];
        m_cLetter = rhs.m_cLetter;
        std::copy(rhs.m_pCoeffs, rhs.m_pCoeffs + m_nSize, m_pCoeffs);
        return *this;
    }
 
 
    polynom polynom::operator - () const
    {
        polynom temp(*this);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pCoeffs[i] *= -1;
        return temp;
    }
 
 
    bool polynom::operator == (const polynom& rhs) const
    {
        if(rhs.m_nSize != m_nSize)
            return false;
        for(size_t i = 0; i < m_nSize; ++i)
            if(m_pCoeffs[i] != rhs.m_pCoeffs[i])
                return false;
        return true;
    }
 
 
    bool polynom::operator != (const polynom& rhs) const
    {
        return !(*this == rhs);
    }
 
 
    polynom polynom::operator + (const polynom& rhs) const
    {
        double* ptrMax, * ptrMin;
        size_t max, min;
        if(rhs.m_nSize >= m_nSize)
        {
            max = rhs.m_nSize;
            min = m_nSize;
            ptrMax = rhs.m_pCoeffs;
            ptrMin = m_pCoeffs;
        }
        else
        {
            max = m_nSize;
            min = rhs.m_nSize;
            ptrMax = m_pCoeffs;
            ptrMin = rhs.m_pCoeffs;
        }
        double* temp = new double[max] ();
        std::copy(ptrMax, ptrMax + max, temp);
        for(size_t i = 0; i < min; ++i)
            temp[i] += ptrMin[i];
        polynom ret(max, temp, m_cLetter);
        delete[] temp;
        return ret;
    }
 
 
    polynom& polynom::operator += (const polynom& rhs)
    {
        return (*this = *this + rhs);
    }
 
 
    polynom polynom::operator - (const polynom& rhs) const
    {
        return (*this + (-rhs));
    }
 
 
    polynom& polynom::operator -= (const polynom& rhs)
    {
        return (*this = *this - rhs);
    }
 
 
    polynom polynom::operator * (const polynom& rhs) const
    {
        std::map<int, double> coeffs;
        for(size_t i = 0; i < m_nSize; ++i)
            for(size_t j = 0; j < rhs.m_nSize; ++j)
                coeffs[i + j] += m_pCoeffs[i] * rhs.m_pCoeffs[j];
        size_t size = coeffs.size();
        double* temp = new double[size] ();
        for(std::map<int, double>::const_iterator it = coeffs.begin();
            it != coeffs.end();
            ++it)
            temp[it->first] = it->second;
        polynom ret(size, temp, m_cLetter);
        delete[] temp;
        return ret;
    }
 
 
    polynom& polynom::operator *= (const polynom& rhs)
    {
        return (*this = *this * rhs);
    }
 
 
    polynom polynom::derivative() const
    {
        size_t size = m_nSize - 1;
        double* temp = new double[size] ();
        for(size_t i = 0; i < size; ++i)
            temp[i] = m_pCoeffs[i + 1] * (i + 1);
        polynom ret(size, temp, m_cLetter);
        delete[] temp;
        return ret;
    }
 
 
    polynom polynom::antiderivative() const
    {
        size_t size = m_nSize + 1;
        double* temp = new double[size] ();
        for(size_t i = 0; i < m_nSize; ++i)
            if(m_pCoeffs[i])
                temp[i + 1] = m_pCoeffs[i] / (static_cast<double>(i + 1));
        polynom ret(size, temp, m_cLetter);
        delete[] temp;
        return ret;
    }
 
    std::ostream& operator << (std::ostream& os, const polynom& rhs)
    {
        for(size_t i = 0; i < rhs.m_nSize; ++i)
            if(rhs.m_pCoeffs[i])
                std::cout << std::setprecision(4)
                << (rhs.m_pCoeffs[i] > 0 ? "+" : "-") << std::abs(rhs.m_pCoeffs[i])
                << rhs.m_cLetter << '^' << i;
        return os;
    }
};

main.cpp
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
#include <iostream>
#include <algorithm>
#include <ctime>
 
#include "polynom.h"
 
#define dbg(EXP) std::cout << std::boolalpha << #EXP ": " << (EXP) << std::endl
 
int main()
{
    try
    {
        srand(static_cast<size_t>(time(NULL)));
        const size_t M = 2;
        const size_t K = 3;
        const int uB = 100;
        const int lB = -100;
        double arrayM[M];
        double arrayK[K];
        std::generate(arrayM, arrayM + M, [lB, uB]() { return (lB + rand() % (lB - uB + 1)) / 10.0; });
        std::generate(arrayK, arrayK + K, [lB, uB]() { return (lB + rand() % (lB - uB + 1)) / 10.0; });
        my::polynom mPol(M, arrayM, 'm');
        my::polynom kPol(K, arrayK, 'k');
        dbg(mPol);
        dbg(kPol);
        dbg(-kPol);
        dbg(kPol.derivative());
        dbg(kPol.antiderivative());
        dbg(kPol + mPol);
        dbg(kPol - mPol);
        dbg(kPol * mPol);
        dbg(kPol == mPol);
        my::polynom kCopy(kPol);
        dbg(kCopy == kPol);
        dbg(mPol(5));
    }
    catch(std::exception& e)
    {
        std::cout << e.what() << std::endl;
    }
    system("pause");
    return EXIT_SUCCESS;
}


Добавлено через 10 минут
PS. Можно еще перегрузить оператор [], чтобы возвращать коэффициент при i-том члене многочлена. Ну и функцию size() написать.
Shaper
22 / 22 / 2
Регистрация: 05.05.2010
Сообщений: 82
06.08.2010, 17:09     Создание класса, представляющего многочлен #6
Сообщение было отмечено автором темы, экспертом или модератором как ответ
Цитата Сообщение от Domen0 Посмотреть сообщение
Доброго времени суток, Профессионалы!
Имеется задание:
Создать класс Polynom ( многочлен ) с операциями +, +=, -, -=, =, ==, !=, >, <, >=, <=, *, *=
Для выполнения операций >, <, >=, <=, надо подставить некоторое число вместо X?
И , что делать с ==, != ?
Класс должен представлять из себя несколько функций, выполняющих действия, и массива офигительной длины, который хранит коэффициенты при x. Так как степень многочлена не задана, она может быть какой угодно.

+ и - - это просто складываются или вычитаются соответствующие коэффициенты. Если у нас есть (ax2+bx+c) и (dx2+ex+f), то их сумма будет равна (a+d)x2+(b+e)x+(c+f);

< и > - это тоже просто. Нужно определить с какой скоростью многочлены уходят в бесконечность. Кто с большей скоростью уходит, тот и больше. Для этого сначала сравниваются коэффициенты при наибольшей степени, а если они равны, то уходим на низшую степень и сравниваем там и так далее, до тех пор, пока не встретятся разные коэффициенты.

== - это тоже просто. Если все коэффициенты равны, то полиномы равны. Иначе не равны.

* - это посложнее. Это каждый член нужно умножать на каждый. При этом степень полинома увеличивается. Новая степень будет суммой степеней умножаемых полиномов.

(ax2+bx+c) * (dx2+ex+f) =
= adx4+aex3+afx2 + bdx3+bex2+bfx + cdx2+cex+cf =
= adx4+(ae+bd)x3+(af+be+cd)x2+(bf+ce)x+cf

Проблема тут только в том, чтобы сделать умножение полиномов для общего случая, и чтобы программа могла переваривать полиномы 100-й степени без проблем. При умножении 2-х полиномов 100-й степени будет полином 200-й степени. Так что, тут еще и с выделяемой памятью нужно вопрос решить.
Yandex
Объявления
06.08.2010, 17:09     Создание класса, представляющего многочлен
Ответ Создать тему
Опции темы

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