КУРСОВАЯ РАБОТА по дисциплине: «Программирование» на тему: «Многочлены». Курсовая программирование. Многочлены

• Название: Многочлены
• Анкор: КУРСОВАЯ РАБОТА по дисциплине: «Программирование» на тему: «Многочлены
• Дата: 05.04.2023
• Размер: 295 Kb.
• Имя файла: Курсовая программирование.doc
• Тип: Курсовая; #1038801
• страница: 2 из 8

2. Основная часть

2.1 Возможные исходные данные

• 
  Многочлены(коэффициенты при переменных, степени переменных), алгоритмы решения задач.
  
• 
  Операции над многочленами: сложение, умножение, вычитание, деление с остатком, возведение степень, операции отношения (равно, не равно), возведение в натуральную степень, вычисление производной от многочлена, вычисление значения в точке x₀.
  

2.2 Неформальное изложение алгоритма

Алгоритм создания многочлена

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

void mnogochlen::sozdanie()

{ int i;
cout<<"Введите степень многочлена "<
cin>>stepen;

cout<<"Введите свободный элемент"<
cin>>koof[0];

for(i=1;i<=stepen;i++)

{ cout<<"Введите x в степени "<
cin>>koof[i];
}

}

Алгоритм вывода многочлена

• 
  Выводим на экран “y=”;
  
• 
  Выводим на экран элемент многочлена с наибольшей степенью;
  
• 
  Выводим поочередно все элементы многочлена, начиная с большей степени до единицы включительно;
  
• 
  Если коэффициент при x равен нулю не выводим этот элемент;
  
• 
  Выводим свободный элемент.
  

void mnogochlen::vivod()

{int j,i;
cout<<"y=";

if(stepen==0){cout<
if(koof[stepen]>0)

{

cout<
}

else

{

if(koof[stepen]<0) {cout<
else{cout<<"";}

}

j=stepen-1;

for(i=j;i>=1;i--)

{ if(koof[i]>0)

{ cout<<"+"<
else

{ if(koof[i]<0) {cout<
else{cout<<"";}}

}

if(koof[0]>0)

{ cout<<"+"<
else

{ if(koof[0]<0) {cout<
else{cout<
}

}

}

Алгоритм сложения двух многочленов

• 
  Определяем больший из введенных многочленов них по степени;
  
• 
  Обнуляем в меньшем многочлене коэффициенты при x;
  
• 
  В новом массиве, который предназначен для сохранения результата, коэффициенты делаем равными нулю;
  
• 
  При помощи цикла складываем коэффициенты, при одинаковых степенях x;
  
• 
  Присваиваем полученному многочлену степень, большего из вычитаемых;
  
• 
  Возвращаем полученный многочлен.
  

Алгоритм вычитания двух многочленов

• 
  Определяем больший из введенных многочленов них по степени;
  
• 
  Обнуляем в меньшем многочлене коэффициенты при x;
  
• 
  В новом массиве, который предназначен для сохранения результата, коэффициенты делаем равными нулю;
  
• 
  При помощи цикла вычитаем коэффициенты, при одинаковых степенях x;
  
• 
  Присваиваем полученному многочлену степень, большего из вычитаемых;
  
• 
  Возвращаем полученный многочлен.
  

Алгоритм умножения двух многочленов

• 
  Присваиваем многочлену, предназначенному для сохранения результата степень равную сумме степеней умножаемых многочленов;
  
• 
  В новом массиве, который предназначен для сохранения результата, коэффициенты делаем равными нулю;
  
• 
  В двойном цикле поочередно умножаем все коэффициенты по правилам приведенным выше;
  
• 
  Приводим подобные;
  
• 
  Возвращаем полученный результат.
  

mnogochlen mnogochlen :: operator *(mnogochlen m)
{mnogochlen d;

int i,j,k;

k=stepen+m.stepen;
for (i=0;i<=k;i++)

{ d.koof[i]=0; }

for (i=0;i<=stepen;i++)

{ for(j=0;j<=m.stepen;j++) {

d.koof[i+j]+=koof[i]*m.koof[j]; } }

d.stepen=m.stepen+stepen;

return d ; }
Алгоритм проверки на равенство двух многочленов

• 
  Сравниваем степени двух многочленов, если они не равны, то, следовательно, не равны и многочлены. Это означает, что дальнейшие действия можно не выполнять. Иначе продолжаем выполнение;
  
• 
  В цикле сравниваем коэффициенты при x;
  
• 
  Если коэффициенты, при каком либо x не совпадают, прерываем сравнение. Многочлены не равны. Иначе продолжаем его выполнение.
  
• 
  Выводим значение булевой переменной, которая и будет указывать: равны ли многочлены или нет.
  

bool mnogochlen :: operator ==(mnogochlen m)

{ bool priznak;

int i;

if(stepen!=m.stepen){priznak=0;}

else {for(i=0;i<=stepen;i++)

{

if(koof[i]!=m.koof[i]) {priznak=0;break;}

else {priznak=1;}

} }

return priznak;
}

Алгоритм проверки на неравенство двух многочленов

• 
  Сравниваем степени двух многочленов, если они не равны, то, следовательно, не равны и многочлены. Это означает, что дальнейшие действия можно не выполнять. Иначе продолжаем выполнение;
  
• 
  В цикле сравниваем коэффициенты при x;
  
• 
  Если коэффициенты, при каком либо x не совпадают, прерываем сравнение. Многочлены не равны. Иначе продолжаем его выполнение.
  
• 
  Возвращаем значение булевой переменной, которая и будет указывать: равны ли многочлены или нет.
  

bool mnogochlen :: operator !=(mnogochlen m)

{ bool priznak;

int i;

if(stepen!=m.stepen){priznak=0;}

else {for(i=0;i<=stepen;i++)

{

if(koof[i]!=m.koof[i]) {priznak=1;break;}

else {priznak=0;}

} }

return priznak;

}

Алгоритм возведения в натуральную степень многочлена

• 
  Вводим натуральную степень, в которую следует возвести данный многочлен;
  
• 
  Создаем многочлен, равный многочлену, который следует возвести в степень;
  
• 
  Создаем вспомогательный многочлен, степень которого равна 0, а свободный член равен 1;
  
• 
  При помощи цикла и операции умножения многочленов выполняем поочередное умножение многочленов, сколько того требует степень;
  

mnogochlen mnogochlen ::stepeny(int k)

{int i;

mnogochlen d,c;

c.stepen=stepen;

for(i=0;i<=stepen;i++)

{c.koof[i]=koof[i];}

d.stepen=0;

d.koof[0]=1;

for(i=1;i<=k;i++)

{d=d*c;

}

return d;

}

Алгоритм вычисления производной от многочлена

• 
  Создаем цикл;
  
• 
  Умножаем степень при x на коэффициент при нем;
  
• 
  Уменьшаем степень при x на единицу;
  
• 
  По завершении цикла уменьшаем степень многочлена на 1.
  

mnogochlen mnogochlen::proizvodnaa()

{mnogochlen c; int i, j;

c.stepen=stepen;

for(i=1;i<=stepen;i++)

{c.koof[i-1]=koof[i]*i;}c.stepen--;

return c; }


Алгоритм вычисления значения в точке x₀

• 
  Вводим значение x, которое необходимо для подсчета;
  
• 
  Присваиваем переменной, в которой сохраняется результат, значение свободной переменной многочлена;
  
• 
  Создаем цикл, в котором к этой переменной будет прибавляться значение коэффициента при x умноженного на x в соответствующей степени;
  
• 
  Выводим полученное значение.
  

double mnogochlen::znachenie(double x)

{double y;

int i;

// ввод х в основную программу

y=koof[0];

for(i=1;i<=stepen;i++)

{y+=pow(x,i)*koof[i];}

return y;}

Алгоритм деления многочленов

• 
  Вычисляем степень многочлена, который будет результатом деления многочленов, вычитая из степени делимого степень делителя;
  
• 
  Обнуляем коэффициенты будущего многочлена, который будет результатом деления;
  
• 
  Определяем степень очередного элемента многочлена, вычитая из степени делимого степень делителя;
  
• 
  Вычисляем его коэффициент, разделив коэффициент делимого на коэффициент делителя;
  
• 
  Умножаем делитель на этот элемент многочлена, чтобы получить многочлен, который будет промежуточным;
  
• 
  Вычитаем из делимого этот многочлен и заносим новый результат в делимое;
  
• 
  Выполняем последние четыре действия до тех пор, пока степень делимого не будет меньше и ли равной степени делителя;
  
• 
  Присваиваем полученному многочлену степень, которую запоминали вначале;
  
• 
  Возвращаем результат.
  

mnogochlen mnogochlen :: operator /(mnogochlen m)

{ mnogochlen c,d,g;

int i,l,k;

l=stepen-m.stepen;

for(i=0;i<100;i++)

{c.koof[i]=0; d.koof[i]=0;}

while (stepen>=m.stepen)

{ c.stepen=stepen-m.stepen;

c.koof[c.stepen]=koof[stepen]/m.koof[m.stepen];

d=m*c;

*this=*this-d; }

c.stepen=l;return c;}

Алгоритм нахождения остатка от деления

• 
  Обнуляем коэффициенты будущего многочлена, который будет результатом деления;
  
• 
  Определяем степень очередного элемента многочлена, вычитая из степени делимого степень делителя;
  
• 
  Вычисляем его коэффициент, разделив коэффициент делимого на коэффициент делителя;
  
• 
  Умножаем делитель на этот элемент многочлена, чтобы получить многочлен, который будет промежуточным;
  
• 
  Вычитаем из делимого этот многочлен и заносим новый результат в делимое;
  
• 
  Выполняем последние четыре действия до тех пор, пока степень делимого не будет меньше и ли равной степени делителя;
  
• 
  Возвращаем остаток от деления многочленов;
  

mnogochlen mnogochlen :: operator %(mnogochlen m)

{ mnogochlen c,d,g; bool a;

int i,l,k;

l=stepen-m.stepen;

for(i=0;i<100;i++)

{c.koof[i]=0; d.koof[i]=0;}

while(stepen>=m.stepen)

{ c.stepen=stepen-m.stepen;

c.koof[c.stepen]=koof[stepen]/m.koof[m.stepen];

d=m*c;

*this=*this-d; }

c.stepen=l;

return *this;