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

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

Восстановить пароль Регистрация
Другие темы раздела
C++ Вывод кавычек при использовании printf http://www.cyberforum.ru/cpp-beginners/thread157712.html
как с помощью printf напечатать строку в которой неоднократно содержаться двойные кавычки ?
C++ Шифратор пароля. Покритикуйте пожалуйста. Это моя первая программка на С++, если кому не лень, натычте меня носом в ляпы. Чтобы не топтаться по граблям. :) #include <iostream> #include <string> #include <ctime> #include <fstream> using namespace std; http://www.cyberforum.ru/cpp-beginners/thread157699.html
C++ Если в C++ аналог оператора with в Pascal?
Если в C++ аналог оператора with в Pascal?
С++ устаревает?? C++
С++ устаревает?? Или ещё нет?
C++ Как запустить system ("cls")? http://www.cyberforum.ru/cpp-beginners/thread157671.html
Собственно, подскажите, что нужно прописать, чтобы функция system("cls") заработала.
C++ Загрузка файла с интернет-сайта Здраствуйте, я новечок в разработке и мне очень нужна помощь. Дали задание подать запрос к сайту ( http://www.namesite.com/tmansfen/News//1/0/1/0) и стянуть с него новости (XML-файл) при этом сгенерировать MD5 и тоже прикрепить для проверки .... Есть ли встроенные функции которые отправляют запрос и получают ответ от сайта и как примерно это организовывается.. если можно подробнее.. заранее... подробнее

Показать сообщение отдельно
Nameless One
Эксперт С++
 Аватар для Nameless One
5759 / 3408 / 255
Регистрация: 08.02.2010
Сообщений: 7,393
06.08.2010, 14:21     Создание класса, представляющего многочлен
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() написать.
 
Текущее время: 04:50. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru