Нахождение рациональных корней многочлена с рациональными коэффициентами

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Курсовой проект

по дисциплине

«Программирование на языке высокого уровня»

на тему:

«Нахождение рациональных корней многочлена с рациональными коэффициентами»

Введение

Целью данного проекта - является закрепление материала, изложенного в курсе «Программирование на языке высокого уровня» на основе какой-либо обобщающей задачи. В качестве таковой была выбрана задача нахождения рациональных корней уравнения с рациональными коэффициентами, т. к. она в достаточной степени полна, в плане разнообразия подзадач. Для обоснования выбора данной задачи охарактеризую её, в общих чертах.

Многочлены или полиномы от одной переменной - функции

Qn(x)= anxn + an-1xn-1+ ... a1x+ a0,

многочлен полиномиальный уравнение

где аi фиксированные коэффициенты, а x -- переменная. Многочлены составляют один из важнейших классов элементарных функций.

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

Техническая простота вычислений, связанных с многочленами, по сравнению с более сложными классами функций, а также тот факт, что множество многочленов плотно в пространстве непрерывных функций на компактных подмножествах евклидова пространства, способствовали развитию методов разложения в ряды и полиномиальной интерполяции в математическом анализе.

Многочлены также играют ключевую роль в алгебраической геометрии, объектом которой являются множества, определённые как решения систем многочленов. Особые свойства преобразования коэффициентов при умножении многочленов используются в алгебраической геометрии, алгебре, теории узлов и других разделах математики для кодирования, или выражения многочленами свойств различных объектов.

Постановка задачи

Разработать подпрограмму для нахождения рациональных корней многочлена произвольной степени с рациональными коэффициентами.

Создание демонстрационной программы для показа найденного решения.

Коэффициенты могут быть заданы целыми числами, простыми дробями, смешанными числами и конечными и бесконечными десятичными дробями.

Теоретические сведения

В данной работе рассматриваются многочлены вида:

Pn(x) = x n+ x n-1+…+

Для поиска возможных рациональных корней применяется

Теорема о рациональных корнях многочлена

Eсли рациональное число является корнем многочлена с целыми коэффициентами Qn(x)= anxn + an-1xn-1+ ... a1x+ a0, то a0 делится на p и an делится на q.

Это дает возможность по коэффициентам a0 и an данного многочлена найти все рациональные числа, которые могут быть корнями Qn(x). Подставляя затем все эти числа, можно установить, какие из них действительно являются корнями Qn(x).

Для рациональных корней таких многочленов существуют алгоритмы нахождения перебором кандидатов с использованием схемы Горнера.

I. Преобразование коэффициентов

Так как коэффициенты многочлена могут быть представлены не только обыкновенными дробями , но и смешанным числами , бесконечным 0,(45) и конечными десятичными 0,05, то все коэффициенты следует обратить в обыкновенные дроби.

1) Перевод конечной десятичной дроби:

Для перевода достаточно в числителе дроби записать число, стоящее после запятой, а в знаменателе - единицу с нулями, причем нулей должно быть столько, сколько цифр справа от запятой. Например,

2) Перевод периодической дроби:

Для перевода нужно из числа, стоящее до второго периода, вычесть число, стоящее до первого периода, и записать эту разность числителем, а в знаменателе написать цифру 9 столько раз, сколько цифр в периоде, и после девяток дописать столько нулей, сколько цифр между запятой и первым периодом.

3) Перевод смешанного числа

Данная дробь будет неправильной.

Чтобы записать число в виде неправильной дроби, нужно умножить его целую часть на знаменатель дробной части и к произведению прибавить числитель дробной части. Полученная сумма будет числителем дроби, а знаменателем будет знаменатель дробной части.

II. Схема Горнера

Схема Горнера - алгоритм вычисления значения многочлена, записанного в виде суммы мономов, при заданном значении переменной. Метод Горнера позволяет найти корни многочлена.

Qn (x) = anxn + an-1xn-1+ ... +a1x+a0

Пусть требуется вычислить значение данного многочлена при фиксированном значении x = x0. Представим многочлен Qn (x) в следующем виде:

Qn (x) =((…(anx+ an-1) x+…a2)x+a1)x+a0

Определим следующую последовательность:

…

…

Искомое значение Qn(x0) = b0. Покажем, что это так.

В полученную форму записи Qn (x) подставим x = x0 и будем вычислять значение выражения, начиная с внутренних скобок. Для этого будем заменять подвыражения через bi:

Qn (x0)

Схема Горнера также является простым алгоритмом для деления многочлена на бином, вида (x - c),

При делении многочлена anxn + an-1xn-1+ ... +a1x+a0 на (x - c) получается многочлен (x-c)(bn-1xn-1 + bn-1-2xn-2+ ... b1x +b0)+r

Если r=0, то с-корень многочлена

Описание общего алгоритма

Пользователь вводит коэффициенты, которые могут быть представлены

- простыми дробями;

- смешанными числами.

- конечными и бесконечными десятичными дробями;

Преобразовываем коэффициенты в обыкновенные дроби и создаем динамический массив коэффициентов {a}i=0;n

Для нахождения корней многочлена преобразуем его в многочлен вида

Qn(x) = ( xn+xn-1+…+) = (anxn+an-1xn-1+…+a0), (1.2)

где z - НОК (Наименьшее Общее Кратное) для ( kn; kn-1; …; k0).

Для дальнейшего нахождения корней используем Теорему о рациональных корнях многочлена. В массиве Х будут храниться делители а0, в массиве У - делители аn.

Корни будем искать перебором

x1, x2,..., xm x1 x1 x1 x2 x2 x2

y1, y2,.., ym , поочередно y1, y2, …, ym, затем y1, y2,…, ym , и так далее.

Значение каждого кандидата подставляем в многочлен и вычисляем его значение, если оно равно 0, тогда этот кандидат является корнем многочлена, если нет, то выдаем сообщение, о том, что у данного многочлена корней нет.

Затем делим данный многочлена на бином (x-c), где с - найденный корень, по схеме Горнера. Получаем новый многочлен (x-c)

(bn-1xn-1 + bn-1-2xn-2+ ... b1x +b0).

Теперь ищем корень многочлена

(bn-1xn-1 + bn-1-2xn-2+ ... b1x +b0)

этим же способом. Продолжаем это до тех пока, степень многочлена не станет равной 1, у многочлена 1 степени находим корень, но дальнейшего деления не производим.

Описание структур данных

Коэффициенты многочлена хранятся в массиве (t_mas_k), расположенном в динамической памяти (t_p_mas_k). Элемент массива представляет собой запись (t_dr): одно поле - числитель дроби (ch), второе - знаменатель (zn).

Type

t_dr=record

ch,zn:longint;

end;

t_mas_k=array [0..65520 div sizeof(t_dr)] of t_dr;

t_p_mas_k=^t_mas_k;

Описание модулей

Модуль FRACTION для распознавания и работы с рациональными числами.

Модуль POLINOM для создания многочлена с рациональными коэффициентами и преобразование его к многочлену с целыми коэффициентами.

Модуль HORNER для нахождения корней многочлена по схеме Горнера.

Модуль FRACTION

Enter_error

Function Enter_error (str:string):boolean;

Просмотр строки str на наличие непредусмотренных символов. Возвращает значение True, если таковых не найдено и False в противном случае.

Входные параметры: str

Возврат: prov

Sign_drob

Function Sign_drob (str:string; var i:byte):shortint;

Определяет знак коэффициента многочлена sign. И номер позиции i для дальнейшего считывания.

Входные параметры: str

Выходные параметры: i

Возврат: sign

Int

Procedure Int (str:string; var d:t_dr);

Преобразовывает строку str, в которой записано целое число в обыкновенную дробь d.

Входные параметры: str

Выходные параметры: d

Ordinary_fraction

Procedure Ordinary_fraction (str:string; var d:t_dr);

Преобразовывает строку str, в которой записана обыкновенная дробь `7/8' в обыкновенную дробь d.

Входные параметры: str

Выходные параметры: d

Improper_fraction

Procedure Improper_fraction (str:string; var d:t_dr);

Преобразовывает строку str, в которой записана неправильная дробь `3+7/8' в обыкновенную дробь d.

Входные параметры: str

Выходные параметры: d

Decimal_fraction

Procedure Decimal_fraction (str:string; var d:t_dr);

Преобразовывает строку str, в которой записана десятичная дробь `3,78' в обыкновенную дробь d.

Входные параметры: str

Выходные параметры: d

Circulator_fraction

Procedure Circulator_fraction (str:string; var d:t_dr);

Преобразовывает строку str, в которой записана периодическая дробь `3,0(78)' в обыкновенную дробь d.

Входные параметры: str

Выходные параметры: d

Reduction_drob

Procedure Reduction_drob (var d:t_dr);

Сокращает дробь d.

Входные параметры: d

Выходные параметры: d

Mul_drob

Procedure Mul_drob (root,d_0:t_dr; var d:t_dr);

Перемножает две дроби root и d_0 и root, результат в d.

Входные параметры: d_0, root

Выходные параметры: d

Add_drob

Procedure Add_drob (d_0:t_dr; var d:t_dr);

Складывает две дроби d_0 и d, результат в d.

Входные параметры: d_0,d

Выходные параметры: d

NOD

Function NOD (x,y:longint):longint;

Возвращает НОД (Наибольший Общий Делитель) двух целых чисел x и y.

Входные параметры: x, y

Возврат: NOD

NOK

Function NOK (x,y:longint):longint;

Возвращает НОК (Наименьшее Общее Кратное) двух целых чисел x и y.

Входные параметры: x, y

Возврат: NOK

Модуль POLINOM

Create_polinom

Procedure Create_polinom (n:longint; var mas:t_p_mas_k);

Cоздает массив mas из коэффициентов многочлена n-ой степени.

Входные параметры: n

Выходные параметры: mas

Normalization;

Procedure Normalization (n:longint; var mas:t_p_mas_k);

Преобразует элементы массива mas, размером n, умножая их на общий знаменатель.

Входные параметры: n

Выходные параметры: mas

Модуль HORNER

Mas_roots

Procedure Mas_roots (n:longint; mas:t_p_mas_k; var x,y:t_mas; var k_x,k_y:longint);

Создает массив x, размером k_x числителей всех возможных корней многочлена из делителей коэффициента при нулевой степени.

Создает массив у, размером k_y массив знаменателей всех возможных корней многочлена из делителей коэффициента при старшей n степени.

Входные параметры: n, mas

Выходные параметры: x, y, k_x, k_y

Value_mnog

Procedure Value_mnog (n:longint; var mas:t_p_mas_k; var roots_mas:t_mas_dr; var size_r:longint; var flag:boolean);

Для многочлена n-ой степени, хранящегося в массиве mas находит возможные корни и записывает их в массив roots_mas размером size_r и устанавливает в логическую переменную flag значение FALSE, если нет ни одного такого корня.

Входные параметры: n, mas

Выходные параметры: roots_mas, size_r, flag

Decision

Procedure Decision (n:longint; var mas:t_p_mas_k);

Выводит на экран корни многочлена, коэффициенты которого хранятся в массиве mas, размером n.

Входные параметры: n, mas

Выходные параметры: нет

  

Тестовые данные

Заключение

В курсовом проекте было предусмотрено следующее:

· Преобразование целых, десятичных, периодических десятичных чисел и смешанных дробей и обыкновенные дроби;

· Считывание и распознавание введенных пользователем данных.

· Вычисление значения многочлена при помощи схемы Горнера;

· Деление многочлена степени >=2 на бином (x-c), где с - корень многочлена с помощью схемы Горнера.

· Вывод на экран корни искомого многочлена.

Список используемой литературы

1) Брусенцева В.С. Конспект лекций по программированию

2) Фаронов В. С. Учебное пособие Turbo Pascal

3) Гусев В.А., Мордкович А.Г. Математика. Справочные материалы

4) http://ru.wikipedia.org

Листинг

UNIT FRACTION;

INTERFACE

Type

t_dr=record

ch,zn:longint;

end;

Function Enter_error (str:string):boolean;

Function Sign_drob (str:string; var i:byte):shortint;

Procedure Int (str:string; var d:t_dr);

Procedure Ordinary_fraction (str:string; var d:t_dr);

Procedure Improper_fraction (str:string; var d:t_dr);

Procedure Decimal_fraction (str:string; var d:t_dr);

Procedure Circulator_fraction (str:string; var d:t_dr);

Procedure Reduction_drob (var d:t_dr);

Procedure Mul_drob (root,d_0:t_dr; var d:t_dr);

Procedure Add_drob (d_0:t_dr; var d:t_dr);

Function NOD (x,y:longint):longint;

Function NOK (x,y:longint):longint;

IMPLEMENTATION

Function Enter_error;

Type

mnog = set of char;

Const

mn: mnog = ['0'..'9','+','-','/',',','(',')'];

Var

prov:boolean;

len,i:byte;

Begin

len:=Length(str);

prov:=true;

i:=1;

while (i<=len) and prov do

begin

prov:=(str[i] in mn);

inc(i);

end;

Enter_error:=prov;

End;

Function Sign_drob;

Var sign:shortint;

Begin

i:=1;

sign:=1;

if str[i]='-' then

begin

sign:=-1;

inc(i);

end;

Sign_drob:=sign;

End;

{//////////////////////////////////////////////////}

Procedure Int;

Var

len,i:byte;

buf:longint;

sign:shortint;

Begin

len:=Length(str);

sign:=Sign_drob(str,i);

buf:=0;

while (i<=len) do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

end;

d.ch:=buf;

d.zn:=1;

End;

Procedure Ordinary_fraction;

Var

len,i:byte;

ch,zn,buf:longint;

sign:shortint;

Begin

len:=Length(str);

sign:=Sign_drob(str,i);

buf:=0;

while (str[i]<>'/') do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

end;

ch:=buf;

buf:=0;

inc(i);

while (i<=len) do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

end;

zn:=buf;

buf:=0;

d.ch:=ch*sign;

d.zn:=zn;

Reduction_drob(d);

End;

Procedure Improper_fraction;

Var

len,i:byte;

cel,ch,zn,buf:longint;

sign:shortint;

Begin

len:=Length(str);

sign:=Sign_drob(str,i);

buf:=0;

while (str[i]<>'+') do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

end;

cel:=buf;

buf:=0;

inc(i);

while (str[i]<>'/') do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

end;

ch:=buf;

buf:=0;

inc(i);

while (i<=len) do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

end;

zn:=buf;

buf:=0;

d.ch:=(cel*zn+ch)*sign;

d.zn:=zn;

Reduction_drob(d);

End;

Procedure Decimal_fraction;

Var

len,i:byte;

k0,buf:longint;

sign:shortint;

Begin

len:=Length(str);

sign:=sign_drob(str,i);

buf:=0;

while (str[i]<>',') do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

end;

inc(i);

k0:=0;

while (i<=len) do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

inc(k0);

end;

d.ch:=buf*sign;

buf:=1;

for i:=1 to k0 do

buf:=buf*10;

d.zn:=buf;

Reduction_drob(d);

End;

Procedure Circulator_fraction;

Var

len,i:byte;

k0,k9,k,buf:longint;

sign:shortint;

Begin

len:=Length(str);

sign:=Sign_drob(str,i);

buf:=0;

while (str[i]<>',') do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

end;

inc(i);

k0:=0;

while (str[i]<>'(') do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

inc(k0);

end;

k:=buf;

inc(i);

k9:=0;

while (i<len) do

begin

buf:=buf*10+(ord(str[i])-ord('0'));

inc(i);

inc(k9);

end;

d.ch:=(buf-k)*sign;

buf:=0;

for i:=1 to k9 do

buf:=buf*10+9;

for i:=1 to k0 do

buf:=buf*10;

d.zn:=buf;

Reduction_drob(d);

End;

{//////////////////////////////////////////////////}

Procedure Reduction_drob;

Var x:longint;

Begin

x:=NOD(d.ch,d.zn);

d.ch:=d.ch div x;

d.zn:=d.zn div x;

End;

Procedure Mul_drob;

Begin

d.ch:=d_0.ch*root.ch;

d.zn:=d_0.zn*root.zn;

Reduction_drob(d);

End;

Procedure Add_drob;

Var n,m:longint;

Begin

n:=NOK(d_0.zn,d.zn);

m:=(n div d_0.zn)*d_0.ch+(n div d.zn)*d.ch;

d.ch:=m;

d.zn:=n;

Reduction_drob(d);

End;

Function NOD;

Var z:longint;

Begin

z:=x mod y;

While z <> 0 do

begin

x:=y;

y:=z;

z:=x mod y;

end;

NOD:=y;

End;

Function NOK;

Var z:longint;

Begin

z:=NOD(x,y);

NOK:=(x*y) div z;

End;

END.

UNIT POLINOM;

INTERFACE

Uses FRACTION;

Type

t_mas_k=array [0..65520 div sizeof(t_dr)] of t_dr;

t_p_mas_k=^t_mas_k;

Procedure Create_polinom (n:longint; var mas:t_p_mas_k);

Procedure Normalization (n:longint; var mas:t_p_mas_k);

IMPLEMENTATION

Procedure Create_polinom;

Type

mnog = set of char;

Var

size_m:longint;

d:t_dr;

str:string;

mn_str: mnog;

len,i:byte;

j:integer;

prov:boolean;

Begin

size_m:=(n+1)*sizeof(longint);

if size_m<=MaxAvail

then GetMem(mas,size_m)

else

begin

WriteLN ('Net pamjati');

mas:=nil;

end;

for j:=n downto 0 do

begin

mas^[j].ch:=0;

mas^[j].zn:=1;

end;

j:=n;

while (j>=0) do

begin

Writeln (' Vvedite koefficient ', j,' stepeni');

Write (' ');

Readln (str);

if Enter_error(str)

then

begin

prov:=true;

mn_str:=[];

len:=length(str);

For i:=1 to len do

mn_str:=mn_str+[str[i]];

mn_str:=mn_str-['0'..'9','-'];

if mn_str=[] then

begin

Int (str,d);

prov:=false;

end;

if ('/' in mn_str) then

if ('+' in mn_str)

then

begin

Improper_fraction (str,d);

prov:=false;

end

else

begin

Ordinary_fraction (str,d);

prov:=false;

end;

if (',' in mn_str) then

if ('(' in mn_str) and (')' in mn_str)

then

begin

Circulator_fraction (str,d);

prov:=false;

end

else

begin

Decimal_fraction (str,d);

prov:=false;

end;

mas^[j].ch:=d.ch;

mas^[j].zn:=d.zn;

if prov

then WriteLN('EpicFail')

else dec(j);

end

else

Writeln ('Ne dopustimoe znachenie, povtorite vvod');

end;

End;

Procedure Normalization;

Var

i:word;

x,y,domn,domn0:longint;

Begin

i:=0;

domn:=0;

x:=mas^[i].zn;

y:=mas^[i+1].zn;

domn:=NOK(x,y);

mas^[i].ch:=(domn div mas^[i].zn)*mas^[i].ch;

mas^[i].zn:=domn;

mas^[i+1].ch:=(domn div mas^[i+1].zn)*mas^[i+1].ch;

mas^[i+1].zn:=domn;

inc(i);

while i<n do

begin

x:=mas^[i].zn;

y:=mas^[i+1].zn;

domn0:=NOK(x,y);

if domn0>domn then domn:=domn0;

inc(i);

end;

for i:=0 to n do

begin

mas^[i].ch:=(domn div mas^[i].zn)*mas^[i].ch;

mas^[i].zn:=1;

end;

End;

END.

UNIT HORNER;

INTERFACE

Uses FRACTION, POLINOM;

Type

t_mas_dr=array [1..500 div sizeof(t_dr)] of t_dr;

t_mas=array [1..500 div sizeof(longint)] of longint;

Procedure Value_mnog (n:longint; var mas:t_p_mas_k; var roots_mas:t_mas_dr; var size_r:longint; var flag:boolean);

Procedure Decision (n:longint; var mas:t_p_mas_k);

IMPLEMENTATION

Procedure Mas_roots (n:longint; mas:t_p_mas_k; var x,y:t_mas; var k_x,k_y:longint);

Var

x0,y0:longint;

i,j:byte;

Begin

x0:=ABS(mas^[0].ch);

y0:=ABS(mas^[n].ch);

j:=0;

for i:=1 to x0 do

begin

if (x0 mod i = 0) then

begin

inc(j);

x[j]:=i;

end;

end;

k_x:=j;

j:=0;

for i:=1 to y0 do

begin

if (y0 mod i = 0) then

begin

inc(j);

y[j]:=i;

end;

end;

k_y:=j;

End;

Procedure Value_mnog;

Var

i,j,k:byte;

prov:boolean;

s,d,d0:t_dr;

size_m,size_m0,m,k_x,k_y:longint;

mas0:t_p_mas_k;

root:t_dr;

x,y:t_mas;

Begin

Mas_roots (n,mas,x,y,k_x,k_y);

prov:=true;

i:=1;

while (i<=k_x) and prov and (n>=1) do

begin

j:=1;

while (j<=k_y) and prov and (n>=1) do

begin

d.ch:=x[i];

d.zn:=y[j];

d0:=d;

Reduction_drob(d);

root:=d;

s.ch:=0;

s.zn:=1;

for k:=n downto 0 do

begin

Mul_drob (root,s,d);

Add_drob (mas^[k],d);

s:=d;

end;

if (s.ch=0)

then

begin

roots_mas[size_r].ch:=d0.ch;

roots_mas[size_r].zn:=d0.zn;

prov:=false;

flag:=true;

if (n>1) then

begin

size_m0:=n*sizeof(longint);

if size_m0<=MaxAvail

then GetMem(mas0,size_m0)

else mas0:=nil;

mas0^[n-1]:=mas^[n];

m:=n-2;

for i:=m downto 0 do

mas0^[i].zn:=1;

for i:=m downto 0 do

begin

Mul_drob (root,mas0^[i+1],d);

Add_drob (d,mas^[i+1]);

mas0^[i]:=mas^[i+1];

end;

FreeMem (mas, size_m);

mas:=mas0;

inc(size_r);

dec(n);

Value_mnog (n, mas, roots_mas, size_r, flag);

end;

end

else inc(j);

end;

inc(i);

end;

if prov

then

begin

i:=1;

while (i<=k_x) and (n>=1) and prov do

begin

j:=1;

while (j<=k_y) and (n>=1) and prov do

begin

d.ch:=-x[i];

d.zn:=y[j];

d0:=d;

Reduction_drob(d);

root:=d;

s.ch:=0;

s.zn:=1;

for k:=n downto 0 do

begin

Mul_drob (root,s,d);

Add_drob (mas^[k],d);

s:=d;

end;

if (s.ch=0)

then

begin

roots_mas[size_r].ch:=d0.ch;

roots_mas[size_r].zn:=d0.zn;

prov:=false;

flag:=true;

if (n>1) then

begin

size_m0:=n*sizeof(longint);

if size_m0<=MaxAvail

then GetMem(mas0,size_m0)

else mas0:=nil;

prov:=false;

mas0^[n-1]:=mas^[n];

m:=n-2;

for i:=m downto 0 do

mas0^[i].zn:=1;

for i:=m downto 0 do

begin

Mul_drob (root,mas0^[i+1],d);

Add_drob (d,mas^[i+1]);

mas0^[i]:=mas^[i+1];

end;

FreeMem (mas, size_m);

mas:=mas0;

inc(size_r);

dec(n);

Value_mnog (n,mas,roots_mas,size_r, flag);

end;

end

else inc(j);

end;

inc(i);

end;

end;

End;

Procedure Decision;

Var

size_r,i:longint;

roots_mas:t_mas_dr;

prov:boolean;

Begin

for i:=1 to n do

begin

roots_mas[i].ch:=0;

roots_mas[i].zn:=1;

end;

size_r:=1;

prov:=false;

Value_mnog (n,mas,roots_mas,size_r,prov);

if prov

then

begin

if (size_r>1)

then WriteLN ('Korni mnogochlena:')

else WriteLN ('Koren mnogochlena:');

for i:=1 to size_r do

if (roots_mas[i].ch<>0)

then

if (roots_mas[i].zn=1)

then WriteLN (roots_mas[i].ch)

else WriteLN (' ',roots_mas[i].ch, '/', roots_mas[i].zn);

end

else

WriteLN ('U dannogo mnogochlena korney net')

End;

END.

PROGRAM RAT_POL;

Uses FRACTION, POLINOM, HORNER, CRT;

Var

n:longint;

mas:t_p_mas_k;

BEGIN

ClrScr;

WriteLN ('"Nahojdenie racionalnyh korney mnogochlena s racionalnymi koefficientami"':74);

WriteLN;

WriteLN ('Vvedite koefficienty mnogochlena, kotorye mogut byt zadany:');

WriteLN;

WriteLN ('-obyknovennaya drob 7/8');

WriteLN ('-nepravilnaya drob 3+7/8');

WriteLN ('-desyatichnaya drob 3,78');

WriteLN ('-periodicheskaya drob 3,0(78)');

WriteLN;

Write ('Vvedite stepen mnogochlena:');

Readln(n);

Create_polinom(n,mas);

Normalization(n,mas);

Decision(n,mas);

ReadKey;

END.

Размещено на Allbest.ru