Developing.ru

Код: Выделить всё

Polynom & Polynom: :o perator*=(Polynom & no) 
{
	if (&no != this)
	{
		size_t i,k,j,m_B,m_M;

		if (m_Dim > no.m_Dim)
		{
			m_B = m_Dim;
			m_M=no.m_Dim;
		}
		else 
		{
			m_B = no.m_Dim;
			m_M = m_Dim;
		}

		Polynom tmp(m_B+m_M-1),
			sum(0);


		for(i=0;i<m_M;++i)
		{
			for(k=0;k<m_B+m_M-1;++k)
				tmp[k]=0;

			k=i;
			for(j=0;j<m_B;++j)
			{
				tmp[k] =   
					no.m_Pol[i]*m_Pol[j];
				k++;
			}
			sum+=tmp;
		}

	}
	
	return *this;

Код: Выделить всё

Polynom & Polynom: :o perator*=(Polynom & no) 
{
    if (&no != this)
    {
        size_t i,k,j,m_B,m_M;

        if (m_Dim > no.m_Dim)
        {
            m_B = m_Dim;
            m_M = no.m_Dim;
        }
        else 
        {
            m_B = no.m_Dim;
            m_M = m_Dim;
        }
		
		 Polynom new_Pol(m_B+m_M-1),
					 sum(new_Pol);

		
        for(i=0;i<m_M;++i)
        {
            for(k=0;k <= m_B+m_M-1;++k)
                new_Pol[k]=0;

					*this = new_Pol;

        k=i;
            for(j=0;j<m_B;++j)
            {
                new_Pol[k] =   
                    no.m_Pol[i]*m_Pol[j];
                k++;
            }
            sum+=new_Pol;
		}
*this = sum;
	}
        return *this;
}

Код: Выделить всё

#include <iostream>
#include <stdexcept>
#include <string>
#include "math.h"

using namespace std;

class polynomial {
public:
	polynomial();
	polynomial(unsigned int);
	polynomial(const double *, unsigned int);
	polynomial(const polynomial &);
	~polynomial();

	polynomial &operator+=(const polynomial &);
	polynomial &operator*=(const polynomial &);
	double operator()(const double) const;
	double &operator[](const unsigned int) const;

	friend ostream &operator<<(ostream &, const polynomial &);

private:
	double *coeffs;
	unsigned int dimension;

	void reset() { delete[] coeffs; }
};

polynomial: :p olynomial()
{
	coeffs = new double[1];
	coeffs[0] = 0;
	
	dimension = 0;
}

polynomial: :p olynomial(unsigned int dim)
{
	coeffs = new double[dim+1];
	
	for(unsigned int i = 0; i <= dim; ++i)
		coeffs[i] = 0;

	dimension = dim;
}

polynomial: :p olynomial(const double *_coeffs, unsigned int dim)
{
	coeffs = new double[dim+1];
	
	/* the first element in array <_coeffs> is the coefficient of the highest power */
	for(unsigned int i = 0; i <= dim; ++i)
		coeffs[i] = _coeffs[dim-i];

	dimension = dim;
}

polynomial: :p olynomial(const polynomial &poly)
{
	dimension = poly.dimension;

	coeffs = new double[dimension+1];
	
	for(unsigned int i = 0; i <= dimension; ++i)
		coeffs[i] = poly.coeffs[i];
}

polynomial::~polynomial()
{
	reset();
}

double polynomial: :o perator ()(const double x) const
{
	double value = coeffs[0];
	
	for(unsigned int i = 1; i <= dimension; ++i)
		value += coeffs[i] * pow(x, (int)i);

	return value;
}

polynomial &polynomial: :o perator+=(const polynomial &poly)
{
	if(this == &poly)
		return *this;
		
	const double min_dimension = (dimension >= poly.dimension)?poly.dimension:dimension;

	for(unsigned int i = 0; i <= min_dimension; ++i)
		coeffs[i] += poly.coeffs[i];
	
	/* if <*this> has higher dimension, then no need to increase <coeffs> */
	if(min_dimension == poly.dimension)
		return *this;

	double *new_coeffs = new double[poly.dimension+1];

	/* assign coeffs, already added together */
	for(unsigned int i = 0; i <= dimension; ++i)
		new_coeffs[i] = coeffs[i];
		
	/* assign coeffs of powers of x, missing from <*this> */
	for(unsigned int i = dimension + 1; i <= poly.dimension; ++i)
		new_coeffs[i] = poly.coeffs[i];

	reset();
	
	dimension = poly.dimension;
	coeffs = new_coeffs;
	
	return *this;
}

polynomial &polynomial: :o perator*=(const polynomial &poly)
{
	const unsigned int new_dimension = dimension + poly.dimension;
	double *new_coeffs = new double[new_dimension+1];
	
	/* zero new coeffs for <*this> */
	for(unsigned int i = 0; i <= new_dimension; ++i)
		new_coeffs[i] = 0;
	
	/* calc new coeffs */
	for(unsigned int i = 0; i <= dimension; ++i)
		for(unsigned int j = 0; j <= poly.dimension; ++j)
			new_coeffs[i+j] += coeffs[i] * poly.coeffs[j];
	
	reset();
	
	dimension = new_dimension;
	coeffs = new_coeffs;
	
	return *this;
}

/* return a reference of a coeff by power <index> of x */
double &polynomial: :o perator[](const unsigned int index) const
{
	if(index <= dimension)
		return coeffs[index];
	else
		throw logic_error("out of bounds");
}

ostream &operator<<(ostream &os, const polynomial &poly)
{
	for(unsigned int i = poly.dimension; i > 0; --i)
		os << poly.coeffs[i] << "*x^" << i << " + ";

	os << poly.coeffs[0] << endl;

	return os;
}

int main()
{
	double coeffs[] = { 4, -7, 2, 1 };
	
	/* create a polynomial using references */
	polynomial poly(2);
	/* create a polynomial using double array */
	polynomial _poly(coeffs, 3);
	
	poly[0] = 3;
	poly[1] = -2;
	poly[2] = 1;
	
	cout << poly << endl;
	cout << _poly << endl;
	
	//cout << endl << (poly += _poly) << endl;
	cout << endl << (_poly *= poly) << endl;
	
	cout << _poly(0.3) << endl;
	
	getchar();
	return 0;
}

Код: Выделить всё

class Polynom 
{
private:
	size_t m_Dim;	//размер
	double * m_Pol; 
public:
	Polynom derivative() const;
};
..//
Polynom Polynom::derivative() const
{
	if (m_Dim > 1)
	{
		Polynom tmp(*this);
			
		for (int i = 0; i < m_Dim; ++i)
			tmp.m_Pol[i-1] = m_Pol[i]*i;

		return tmp;
	}
	else
	{
	Polynom tmp(1);
	tmp.m_Pol[0] = 0.0;
		return tmp;
	}
}

//...

void main()
{	
double v[]={1,2,3};
Polynom p1(2,v);
p1.derivative();
p1.Show();
}

Код: Выделить всё

p2 = p1.derivative();
p2.Show();

Код: Выделить всё

          
        for (int i = 0; i < m_Dim; ++i)
            tmp.m_Pol[i-1] = m_Pol[i]*i;

Код: Выделить всё

class polynomial {
	explicit polynomial(const double);
[...]
polynomial: :p olynomial(const double value)
{
    coeffs = new double[1];
	dimension = 0;

	coeffs[0] = value;
}
[...]
polynomial polynomial::derivative() const
{
	if(dimension) {
		double *new_coeffs = new double[dimension];
		
		/* coeffs to the constructor must be passed in inverted order */
		for(unsigned int i = 1; i <= dimension; ++i)
			new_coeffs[dimension-i] = i * coeffs[i];
		
		polynomial poly(new_coeffs, dimension - 1);
	
		delete new_coeffs;
		
		return poly;
		
	} else
		return polynomial(0.0);
}

Код: Выделить всё

class Polynom 
{
private:
	size_t m_Dim;	//размер
	double * m_Pol; 
public:
	Polynom();								// к-ор по умолчанию		
	Polynom(const size_t);					// к-ор с 1 аргументом
	Polynom(const size_t,const double* );	//конструктор с 2 аргументами
	Polynom(const Polynom&);				// Конструктор копирования
	~Polynom();								// Деструктор
	size_t GetDim() const {return m_Dim;}	// Получение степени
	double GetKof(const size_t i); //Получение i-ого коэффициента.
	void SetKof(const size_t i,const double x ); // Изменение i-ого коэффициента.
	void Show() const;

	friend Vector Vec2Poly(const Polynom &);
	friend Polynom Poly2Vec(const Vector &);

	Polynom operator+() {return *this;} //перегрузка унарного оператора "+"
	Polynom operator-(); //перегрузка унарного оператора "-"

	operator double* () const;
	double &operator[](const size_t i) const;

	Polynom & operator=(const Polynom &ob); 
	Polynom & operator=(double op); 
	Polynom & operator+=(const Polynom &ob); 
	Polynom & operator+=(double op); 
	Polynom & operator-=(const Polynom &ob); 
	Polynom & operator-=(double op); 
	Polynom & operator*=(const Polynom &poly);
	Polynom & operator*=(double op);
	Polynom & operator/=(double op);
	Polynom & operator^=(int op);

	friend	Polynom operator+(const Polynom &ob1, const Polynom &ob2);
	friend  Polynom operator+(const Polynom &ob1, double op2);
	friend  Polynom operator+(double op1,const Polynom &ob2);
	friend  Polynom operator-(const Polynom &ob1, const Polynom &ob2);
	friend  Polynom operator-(const Polynom &ob1, double op2);
	friend  Polynom operator-(double op1, const Polynom &ob2);
	friend	Polynom operator*(const Polynom &ob1,const Polynom &ob2);
	friend	Polynom operator*(const Polynom &ob1, double op2);
	friend	Polynom operator*(double op1, const  Polynom &ob2);
	friend	Polynom operator/(const Polynom &ob1, double op2);
	friend  Polynom operator^(const Polynom &ob1, double op2);
	friend	bool operator==(const Polynom &ob1, const Polynom &ob2);
	friend	bool operator==(const Polynom &ob1, double op1);
	friend  bool operator!=(const Polynom &ob1,const Polynom &ob2);
	friend	bool operator!=(const Polynom &ob1, double op1);
	friend  ostream& operator<<(ostream&, const Polynom &);
	friend	istream& operator>>(istream&, Polynom &);

	Polynom derivative() const; //dx
	double evaluate(double x) const; // sum
};