Деление полинома на полином

Деление полинома на полином

Добрый вечер! Это программа, которая будет делить полином на полином, но она не совсем правильно работает, а я не могу сообразить, как её исправить. Подскажите, пожалуйста, как её исправить?

В классе два конструктора:

Polynom::Polynom(void){   
 n = 0;   
 a = new float [n+1];  
for(int i=1; i<=n; i++)
 a[i]=0;
 }

Polynom::Polynom(int N){
   if (N>=0){
       n = N;
       a = new float [n+1];
       for(int i=1; i<=n; i++)
          a[i]=0;
   }
}

Оператор деления:

Polynom Polynom::operator/(Polynom t){ //сюда задается полином, который делит исходный
   if(t.n==0){ //делит на число (полином нулевой степени), работает правильно
      Polynom c(n);
      for(int i = 0; i<=n; i++){
          c.a[i] = a[i]/t.a[0];
      }
      return c;
   } else { //делит на полином, правильно выводит только последний элемент.
      if (n>=t.n){
          int k = n-t.n;
          Polynom c(k); //создается новый полином, который и должен быть ответом
          for (int i = k; i>=t.n; i = k-t.n){
                c.a[i] = a[n]/t.a[t.n];
                Polynom h = c*t;
                Polynom r = ReadFile("data1.txt"); //тут из файла считывается исходный полином, который мы делим. (к его полям выше обращались через n и a[i])
                Polynom f = r - h;
}
          return c;
}
}
}

P.S. все операторы сложения, вычитания и умножения полиномов уже написаны в программе и работают правильно.

Попробуй разобраться с этим.

Описание класса и конструкторы-деструкторы:

class Polynom {
private:
    int degree;
    double *coef;
    Polynom(int adegree);
    void reduce(void);
    friend Polynom plus_minus (const Polynom &p1, const Polynom &p2, double op(double, double));
public:
    Polynom(int adegree, double acoef[]);
    Polynom(const Polynom &p);
    ~Polynom();

    string to_s(void) const;

    friend Polynom operator + (const Polynom &p1, const Polynom &p2);
    friend Polynom operator - (const Polynom &p1, const Polynom &p2);
    friend Polynom operator * (const Polynom &p1, const Polynom &p2);
    friend Polynom operator / (const Polynom &p1, const Polynom &p2);
    friend ostream &operator << (ostream &stream, const Polynom &p);
    friend istream &operator >> (istream &stream, Polynom &p);
};

Polynom::Polynom(int adegree) {
    degree = adegree;
    coef = new double[degree];
    for (int i = 0; i < degree; i++) {
        coef[i] = 0.0;
    }
}

Polynom::Polynom(int adegree, double acoef[]) {
    degree = adegree;
    coef = new double[degree];
    for (int i = 0; i < degree; i++) {
        coef[i] = acoef[i];
    }
}

Polynom::Polynom(const Polynom &p) {
    degree = p.degree;
    coef = new double[degree];
    for (int i = 0; i < degree; i++) {
        coef[i] = p.coef[i];
    }
}

Polynom::~Polynom() {
    delete [] coef;
}

void Polynom::reduce(void) {
    int tdeg = degree;
    for (int i = degree - 1; i >= 0; i--) {
        if (coef[i] != 0.0)
            break;
        else
            tdeg--;
    }
    degree = tdeg;
}

А вот функция деления:

Polynom operator / (const Polynom &p1, const Polynom &p2) {
    Polynom temp = p1;
    int rdeg = temp.degree - p2.degree + 1;
    Polynom res(rdeg);
    for (int i = 0; i < rdeg; i++) {
        res.coef[rdeg - i - 1] = temp.coef[temp.degree - i - 1] / p2.coef[p2.degree - 1];
        for (int j = 0; j < p2.degree; j++) {
            temp.coef[temp.degree - j - i - 1] -= p2.coef[p2.degree - j - 1] * res.coef[rdeg - i - 1];
        }
    }
    temp.reduce();
    if (temp.degree != 0) {
        cout << "!!! имеется остаток от деления " << temp << endl;
    }
    return res;
}

Если интересно, могу скинуть программку целиком. Она, правда, достаточно длинная ))

Можешь мне скинуть программу целиком пожайлуста?

Программа целиком

// Polynom.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

double plus(double a, double b) {
    return a + b;
}

double minus(double a, double b) {
    return a - b;
}

class Polynom {
private:
    int degree;
    double *coef;
    Polynom(int adegree);
    void reduce(void);
    friend Polynom plus_minus (const Polynom &p1, const Polynom &p2, double op(double, double));
public:
    Polynom(int adegree, double acoef[]);
    Polynom(const Polynom &p);
    ~Polynom();

    string to_s(void) const;

    friend Polynom operator + (const Polynom &p1, const Polynom &p2);
    friend Polynom operator - (const Polynom &p1, const Polynom &p2);
    friend Polynom operator * (const Polynom &p1, const Polynom &p2);
    friend Polynom operator / (const Polynom &p1, const Polynom &p2);
    friend ostream &operator << (ostream &stream, const Polynom &p);
    friend istream &operator >> (istream &stream, Polynom &p);
};

Polynom::Polynom(int adegree) {
    degree = adegree;
    coef = new double[degree];
    for (int i = 0; i < degree; i++) {
        coef[i] = 0.0;
    }
}

Polynom::Polynom(int adegree, double acoef[]) {
    degree = adegree;
    coef = new double[degree];
    for (int i = 0; i < degree; i++) {
        coef[i] = acoef[i];
    }
}

Polynom::Polynom(const Polynom &p) {
    degree = p.degree;
    coef = new double[degree];
    for (int i = 0; i < degree; i++) {
        coef[i] = p.coef[i];
    }
}

Polynom::~Polynom() {
    delete [] coef;
}

string Polynom::to_s(void) const {
    string str = "";
    str += "[ degree = " + to_string(degree) + " :";
    for (int i = degree - 1; i >= 0; i--) {
        str += " " + to_string(coef[i]);
    }
    str += " ]";
    return str;
}

void Polynom::reduce(void) {
    int tdeg = degree;
    for (int i = degree - 1; i >= 0; i--) {
        if (coef[i] != 0.0)
            break;
        else
            tdeg--;
    }
    degree = tdeg;
}

Polynom plus_minus (const Polynom &p1, const Polynom &p2, double op(double, double)) {
    Polynom *pmax, *pmin;
    if (p1.degree > p2.degree) {
        pmax = (Polynom *)&p1;
        pmin = (Polynom *)&p2;
    }
    else {
        pmax = (Polynom *)&p2;
        pmin = (Polynom *)&p1;
    }
    int min_degree = pmin->degree ;
    int max_degree = pmax->degree;
    Polynom res(max_degree);
    for (int i = 0; i < max_degree; i++)
        if (i < min_degree) {
            res.coef[i] = op(pmax->coef[i], pmin->coef[i]);
        }
        else {
            res.coef[i] = pmax->coef[i];
        }
    return res;
}

Polynom operator + (const Polynom &p1, const Polynom &p2) {
    return plus_minus(p1, p2, plus);
}

Polynom operator - (const Polynom &p1, const Polynom &p2) {
    return plus_minus(p1, p2, minus);
}

Polynom operator * (const Polynom &p1, const Polynom &p2) {
    Polynom res(p1.degree + p2.degree - 1);
    for (int i = 0; i < p1.degree; i++) {
        for (int j = 0; j < p2.degree; j++) {
            res.coef[i+j] += p1.coef[i] * p2.coef[j];
        }
    }
    return res;
}

Polynom operator / (const Polynom &p1, const Polynom &p2) {
    Polynom temp = p1;
    int rdeg = temp.degree - p2.degree + 1;
    Polynom res(rdeg);
    for (int i = 0; i < rdeg; i++) {
        res.coef[rdeg - i - 1] = temp.coef[temp.degree - i - 1] / p2.coef[p2.degree - 1];
        for (int j = 0; j < p2.degree; j++) {
            temp.coef[temp.degree - j - i - 1] -= p2.coef[p2.degree - j - 1] * res.coef[rdeg - i - 1];
        }
    }
    temp.reduce();
    if (temp.degree != 0) {
        cout << "!!! имеется остаток от деления " << temp << endl;
    }
    return res;
}

ostream &operator << (ostream &stream, const Polynom &p) {
    stream << p.to_s();
    return stream;
}

istream &operator >> (istream &stream, Polynom &p) {
    int ndeg = 0;
    stream >> ndeg;
    if (ndeg != p.degree) {
        delete [] p.coef;
        p.degree = ndeg;
        p.coef = new double[ndeg];
        for (int i = 0; i < ndeg; i++)
            p.coef[i] = 0.0;
    }
    for (int i = 0; i < ndeg; i++)
        stream >> p.coef[i];
    return stream;
}


int _tmain(int argc, _TCHAR* argv[])
{
    setlocale(LC_CTYPE, "Russian");

    double c1[] = { 1.0, 2.0, 3.0 };
    double c2[] = { 5.0, 6.0 };
    double c3[] = { 5.0, 2.0 };
    Polynom p1(3, c1), p2(2, c2);

    cout << "Получены полиномы:\n" 
        << p1 << endl
        << p2 << endl;

    Polynom p3 = p1 + p2;

    cout << "p3 = p1 + p2: " << p3 << endl;

    Polynom p4 = p1 - p2;

    cout << "p4 = p1 - p2: " << p4 << endl;

    Polynom p5 = p1 * p2;

    cout << "p5 = p1 * p2: " << p5 << endl;

    Polynom p6 = p5 / p2;

    cout << "p6 = p5 / p2: " << p6 << endl;

    Polynom p7 = p5 / p1;
    cout << "p7 = p5 / p1: " << p7 << endl;

    Polynom p8 = p5 + Polynom(2, c3);
    cout << "p8 = p5 + " << (Polynom(2, c3)) << ": " << p8 << endl;

    Polynom p9 = p8 / p1;
    cout << "p9 = p8 / p1: " << p9 << endl;

    Polynom p12 = p9 * p1;
    cout << "p12 = p9 * p1: " << p12 << endl;

    Polynom p10 = p8 / p2;
    cout << "p10 = p8 / p2: " << p10 << endl;

    Polynom p11 = p10 * p2;
    cout << "p11 = p10 * p2: " << p11 << endl;

    system("pause");
    return 0;
}

деление работает неверно

Голословное утверждение ((

Анита, а что-то из конкретных примеров можно увидеть?

Внимание! Это довольно старый топик, посты в него не попадут в новые, и их никто не увидит. Пишите пост, если хотите просто дополнить топик, а чтобы задать новый вопрос — начните новый.

Ответить

Вы можете использовать разметку markdown для оформления комментариев и постов. Используйте функцию предпросмотра для проверки корректности разметки.

Пожалуйста, оформляйте исходный код в соответствии с правилами разметки. Для того, чтобы вставить код в комментарий, скопируйте его в текстовое поле ниже, после чего выделите то, что скопировали и нажмите кнопку «код» в панели инструментов. Иначе ваш код может принять нечитаемый вид.

Либо производите оформление кода вручную, следующим образом:

``` #include <iostream> using namespace std; int main() { // ... } ```

Предпросмотр сообщения

Ваше сообщение пусто.