Еngee как альтернатива PascalABC

program lab_1_v_10;
 var                //раздел описания переменных
    a1,a2:integer;  //объявление переменных с различными типами данных
    b1,b2:real;
    c1,c2:char;
    d:boolean;
 begin              
 writeln ('Лабораторная работа №1'); //оператор вывода на экран
 writeln ('Ввод-вывод различных типов данных');
 
  writeln ('Ввод переменных целого типа а');
  write ('а1=');
  readln (a1);   //оператор ввода с клавиатуры
  write ('а2=');
  readln (a2);
  
  writeln ('Ввод переменных вещественного типа b');
  write ('b1=');
  readln (b1);
  write ('b2=');
  readln (b2);;
  
  writeln ('Ввод переменных символьного типа c');
  write ('с1=');
  readln (c1);
  write ('с2=');
  readln (c2);
  
      writeln('Вывод переменных целого типа а');
      writeln('а1=',a1:6);  //вывод комментария и переменной
      writeln('а2=',a2:6);  //":6" форматирование целой переменной(количество позиций отводимых под все число) 
      
      writeln('Вывод переменных вещественного типа b');
      writeln('b1=',b1:8:4); //":8:4" форматирование вещественной переменной
      writeln('b2=',b2:8:4); // (":8"-количество позиций отводимых под все число; 
                             //  ":4"-количество позиций отводимых под дробную часть числа)
     
      writeln('Вывод переменных символьного типа c');
      writeln('c1=',c1);  
      writeln('c2=',c2);
      
      writeln('Вывод значения булевской переменной');
      d:=a1>a2;  
      writeln('Верно ли выражение a1>a2');
      writeln(d);
   end.  
_______________________________________________________________________________________________

program lab_2_v10;
var
x,y,z:real; 
 
begin
   writeln ('Лабораторная работа №2. Вариант №10.');
   writeln ('Программирование линейных алгоритмов.');
   writeln ('Вычисление выражений с использованием стандартных функций.');
   writeln;
   x:=3;
   y:=0.5;
   z:=(1+cos(x+y))/(abs(exp(x))-2*y/(1+sqr(x)*sqr(y)))*power(x,3)+arctan(y/sqrt(1-sqr(y)));
   write ('Значение выражения z=',z:6:5);
end.
_____________________________________________________________________________________________

program lab3_v10;

var 
 x,y,k:real;
begin
  writeln('Лабораторная работа №3. Вариант №10.');
  writeln('Оператор условного перехода IF.');
 
 writeln('Введите значения x и y');
 write('х=');
 readln(x);
 write('y=');
 readln(y);
 
 if (x=y) then
   begin
   k:= sqr(x+y);
   writeln('При x=y получаем выражение (x+y)^2=',k:5:4);
   writeln();
   end
     else
      if (x>y) then
      begin
      k:=arctan(abs(x)+y);
      writeln('При x>y получаем выражение arctg(|x|+y)=',k:5:4);
      writeln();
      end
         else  
         begin
         k:=arctan(x+abs(y));
         writeln('При x<y получаем выражение arctg(x+|y|)=',k:5:4);
         writeln();
         end;    
end.
_____________________________________________________________________________________

program lab_4_v2;
label 1;
var
  b:integer;
  a,x,y:real;
begin
  writeln('Лабораторная работа №4. Вариант №2');
  writeln('Программирование развлетвляющихся алгоритмов');
  writeln('Принадлежит ли точка области');
  writeln('при X=[0;-2] и Y=[0,-1]');
  
 1: writeln('Введите значение x');
  write('x=');
  readln(x);
  
  a:=exp(x)-sin(x);
  y:=exp((1/3)*ln(a));
  
if (x<=0)and(x>=-2)and(y<=0)and(y>=-1) then
    begin
      writeln('Значения точки');
      writeln('X=',x:6:4); 
      writeln('Y=',y:6:4);
      writeln ('Точка принадлежит области');
      
    end
       else
  begin
      writeln('Значения точки');
      writeln('X=',x:6:4); 
      writeln('Y=',y:6:4);
      writeln ('Точка не принадлежит области');
      
  end;
   writeln();
   writeln('Для повторения программы нажмите 1.');
   writeln('Для завершения программы нажмите 0.');
   readln(b);
   write(b);
   
   if (b=1) then
   goto 1
   else
  writeln(t); 
  write('Конец программы');

 end. 
_____________________________________________________________________________________
program lab5_v2;
label 1,2;

var
x,y,a1,a2,a3:real;
m:integer;

begin 
writeln('Лабораторная работа №7. Вариант №2.');
 writeln('Оператор выбора CASE.');
 writeln();
 writeln('Введите значения x и y и выберите формулу');
 writeln('для расчета параметра L. ');
 writeln();
 writeln('При m=1 значение L=arctan(2*x+abs(y)-abs(x*y))');
 writeln('При m=2 значение L=arctan(abs(x)+2*y+(x*y))');
 writeln('При m=3 значение L=exp(4*ln(x+y))');
 writeln();
 writeln('Для завершения программы введите m=0');
 writeln();
 writeln('Для иных значений m программа результаты не выдает.');
 writeln();
 writeln('Введите значение x');
 write('x=');
 readln(x);
 writeln('x=',x);
 writeln('Введите значение y');
 write('y=');
 readln(y); 
 writeln('y=',y);
 1:writeln('Введите значение m');
 write('m=');
 readln(m);
 writeln('m=',m);
 
 case m of
 1:begin 
 a1:=arctan(2*x+abs(y)-abs(x*y));
 writeln('При m=1 значение L=arctan(2*x+abs(y)-abs(x*y)=',a1:4:3);
 writeln();
 goto 1;
 end;
 2:begin
 a2:=arctan(abs(x)+2*y+(x*y));
 writeln('При m=2 значение L=arctan(abs(x)+2*y+(x*y))=',a2:4:3);
 writeln();
 goto 1;
 end;
 3:begin
 a3:=exp(4*ln(x+y));
 writeln('При m=3 значение L=exp(4*ln(x+y))=',a3:4:3);
 writeln();
 goto 1;
 end;
 0: goto 2
 else
 begin
  writeln(t,'Проверьте значение m');
  goto 1;
  end
  end;
  
2: writeln('Конец программы'); 

end.
_____________________________________________________________________________________

program lab6_v10;

var
a,s,f:real;
i,n,k:integer;

begin 
writeln('Лабораторная работа №6. Вариант №10.');
 writeln('Циклический алгоритм FOR');
 writeln('Вычисление суммы ряда из n элементов');
 writeln();
write('Введите значение элементов n=');
read(n);

f:=1;

writeln('Полученные данные, где ');
writeln(' n  - шаг изменения');
writeln(' n! - факториал');
writeln(' а  - общий член ряда определяемый по формуле (sqr(n!))/(exp(sqrt(n))))');
writeln(' s  - сумма ряда ');
writeln();
writeln('|     n   |       n!       |             a            |               s        |');
writeln('===============================================================================');

 for i:=1 to n do
 begin 
 k:=k+1;
 f:=f*i;
 a:=(sqr(f))/(exp(sqrt(k)));
 s:=s+a; 
 writeln('|':4,k:3,'|','| ':7,f:9,'|','|':5,a:20:5,'|','|':6,s:20:5,'|' ); 
 end;
 end.
____________________________________________________________________________________________

program lab7_v10;

var
i1,i2,f1,f2:real;
an,an1,T:real;
begin 
writeln('Лабораторная работа №7. Вариант №10.');
 writeln('Программирование циклических алгоритмов с');
 writeln('числом повторений, заданным в неявной форме.');
 writeln('Вычисление суммы ряда с заданной точностью.');
 writeln();

i1:=0;
i2:=0;
f1:=1;
f2:=1;
an:=1;
an1:=1;

writeln('|Значения суммы ряда|');
writeln('=====================');

while abs(an)>=0.00001 do
begin
i1:=i1+1;
i2:=(i2+1)+1;
f1:=f1*i1;
f2:=(f2+1)*i1;
an:=(f1/(3*power(i1,i1)));
an1:=(f2/(3*power(i2,i2)));

T:=an1/an;
an:=an*T;
writeln('':4,an:8:7);

end;
 writeln();
 
i1:=0;
i2:=0;
f1:=1;
f2:=1;

writeln('|Значения суммы ряда|');
writeln('=====================');

repeat 
 
i1:=i1+1;
i2:=(i2+1)+1;
f1:=f1*i1;
f2:=(f2+1)*i1;
an:=(f1/(3*power(i1,i1)));
an1:=(f2/(3*power(i2,i2)));

T:=an1/an;
an:=an*T;
writeln('':4,an:8:7);
until abs(an)<=0.00001;

end.
___________________________________________________________________________

program lab8_v10;

var
t:text;
x,y,a,b,h:real;
m,i:integer;

begin
assign(t,'rez8.dat');
rewrite(t);

writeln('Лабораторная работа №8');
writeln('Построение таблицы значений функций');
writeln();
writeln('Введите число определяющее количество расчетных точек на заданном интервале');
write('m=');
readln(m);
writeln('Находим значения в отрезке 0 до 3П');

a:=0;
b:=3*3.14;
h:=(b-a)/m;
x:=a;

writeln('|    X    |     Y    |');
writeln('======================');
for i:=1 to m do
begin

y:=x+sin(x);
writeln('|':3,x:6:3,'|','|':3,y:6:3,'|');
writeln(t,x,' ',y);
x:=x+h;
end;
close(t);
end.
______________________________________________________________________________________________

program lab9_v10;

type
a1=array[1..7] of integer;
a2=array[1..2,1..6] of real;
const U:a2=((2,-3.5,8.1,7,5.2,-9.7),(-3,2.8,-5.7,1,6.2,4));
var 
mas1:a1;
i,j:integer;

begin
  writeln('Лабораторная работа №9. Вариант №10.');
  writeln('Ввод вывод массивов.');
  writeln();
  writeln('Введите элементы одномерного массива');
  writeln();
for i:=1 to 7 do
mas1[i]:=random(20)-10;
for i:=1 to 7 do
begin
write('mas[',i,']=',mas1[i],' ');
end;
writeln();
writeln();
writeln('Элементы двумерного массива');
writeln();
for i:=1 to 2 do 
begin 
  for j:=1 to 6 do
  begin
  write('  ','a[',i,';',j,']=',U[i,j]:5:2);
  end;
 writeln();
 end;
end.

______________________________________________________________________________________________
program lab10_v10;

type
a1=array[1..6] of integer;
label 1;
var 
mas1:a1;
i,k,b,max:integer;

begin
writeln ('Лабораторная работа №10 Вариант №10');
     writeln ('Преобразование одномерного массива.');
     writeln ('Введите значения массива');
     
for i:=1 to 6 do
begin
write('mas[',i,']=');
read(mas1[i]); 
end;
writeln();
writeln('Введенный массив');
writeln();
for i:=1 to 6 do
begin
write('mas[',i,']=',mas1[i],' ');
end;
writeln();
writeln();

max:=mas1[1];
k:=1;
for i:=2 to 6 do

begin
if mas1[i]>max then
begin
max:=mas1[i];
k:=i;
end;
end;
writeln('Массимальное значение массива');
writeln();
writeln('mas[',k,']=',mas1[k]);

b:=mas1[2];
mas1[2]:=max;
mas1[k]:=b;
writeln();

writeln('Массив в котором максимальное значение массива');
writeln('поменяли со вторым элементом массива');
writeln();
for i:=1 to 6 do
begin
write('mas[',i,']=',mas1[i],' ');
end;
end.
______________________________________________________________________________________________
program lab11_v10;

type
mas=array[1..8] of integer;

var 
a1:mas;
i,j,b:integer;

begin

writeln('Лабораторная работа №11. Вариант №10.');
 writeln('Сортировка вставками.');
 writeln('Введите массив.');
 for i:=1 to 8 do
 begin
 write('a[',i,']=',' ');
 read(a1[i]);
 end;
 writeln();
 writeln('Введенный массив.');
 for i:=1 to 8 do
 begin
write('a[',i,']=',a1[i],' ');
end;
 writeln();
 
for j:=2 to 8 do
  begin
b:=a1[j];
i:=j-1;
   while (i>=1) and (a1[i]<b) do
      begin
       a1[i+1]:=a1[i];
       i:=i-1;
       end;
       a1[i+1]:=b;
   end;
   writeln();
   writeln('Отсортированный массив.');
for i:=1 to 8 do
 begin
 write('a[',i,']=',a1[i],' ');
 end;
end.
______________________________________________________________________________________________

program lab12_v1;
Function fun(x1:real):real;
begin
fun:=x1-sin(x1)
end;
var
x,y,a,b,h:real;
m,i:integer;

begin

writeln('Лабораторная работа №12');
writeln('Программирование с использованием подпрограмм типа функция');
writeln();
writeln('Количество расчетных точек на заданном интервале: m=10');
writeln();
writeln('Находим значения в отрезке 0 до 2*П');
writeln('где а=0-начало отрезка, b=2*П-конец отрезка');

m:=10;
a:=0;
b:=2*3.14;
h:=(b-a)/m;
x:=a;

writeln('Нахождение точек с помощью подпрограммы типа функция');
writeln('|    X    |     Y    |');
writeln('======================');

for i:=1 to m do
begin
y:=fun(x);
writeln('|':3,x:6:3,'|','|':3,y:6:3,'|');
x:=x+h;
end;
writeln();
writeln('Нахождение точек с помощью цикла for');
writeln('|    X    |     Y    |');
writeln('======================');
x:=a;
for i:=1 to m do
begin
y:=x-sin(x);
writeln('|':3,x:6:3,'|','|':3,y:6:3,'|');
x:=x+h;
end;
end.
______________________________________________________________________________________________

program lab13_v1;
type 
mas=array[1..7] of real;

procedure vecD(x,y:mas; var z:mas);
begin
var j:integer;
for j:=1 to 7 do
z[j]:=x[j]*y[j];
end;

var
i:integer;
c,f,d:mas;

begin
writeln('Введите значения вектора с');
for i:=1 to 7 do
read(c[i]);
writeln('Введите значения вектора f');
for i:=1 to 7 do
read(f[i]);
vecD(c,f,d);
writeln('Вывод вектора d');
for i:=1 to 7 do
write(' ',d[i]);
end.
______________________________________________________________________________________________

program lab_trap;
type fun=function (z:real):real;
var

s_toch,s_trap,s_prav,s_lev,s_simp:real;
a,b,s1,s2,s3,s4,h:real;
x1,f_perv,f_podint:real;
n,k:integer;

function podinteg(z1:real):real;
begin
podinteg:= sqr(z1)*sqrt(4-sqr(z1));//подинтегральная 
end;

function perv(z:real):real;
begin
     perv:=2*arctan(((z/2)/sqrt(1-sqr(z/2)))/2)-(1/2)*sin(4*arctan(((z/2)/sqrt(1-sqr(z/2)))/2));// первообразная
end;


procedure toch_znach (a,b:real;perv:fun; var s_toch:real); // точное значение интеграла
begin
s_toch:=perv(b)-perv(a);
end;                                                    // нахождение площади

procedure trap(a,b,h:real;n:integer;podinteg:fun;var s_trap:real); //метод трапеций
var 
c:real;
j:integer;
begin
s_trap:=(podinteg(a)+podinteg(b))/2;
c:=a;
for j:=1 to (n-1) do
begin
c:=c+h;
s_trap:=s_trap+podinteg(c)
end;
s_trap:=s_trap*h;
end;                                                        //метод трапеций

procedure prav (a,b,h:real;n:integer;podinteg:fun;var s_prav:real);    //метод правых прямоугольников
var 
x:real;
i:integer;
begin 
s_prav:=0;
x:=a;
for i:=1 to n do
begin 
x:=x+h;
s_prav:=s_prav+podinteg(x);
end;
s_prav:=s_prav*h;
end;                                              //метод правых прямоугольников

procedure lev (a,b,h:real;n:integer;podinteg:fun;var s_lev:real); //метод левых прямоугольников
var
x:real;
i:integer;
begin 
x:=a;
s_lev :=0;
for i:=0 to (n-1) do
begin
s_lev :=s_lev+podinteg(x);
x:=x+h;
end;
s_lev:=s_lev*h;
end;  //метод левых прямоугольников

procedure simp (a,b:real;n:integer;podinteg:fun;var s_simp:real); //метод Симпсона
var 
x,h:real;
i:integer;
begin
h:=(b-a)/(2*n);
s_simp:=podinteg(a)+podinteg(b);
x:=a;
for i:=1 to (2*n-1) do
begin 
x:=x+h;
if i mod 2 = 0 then 
s_simp:=s_simp+2*podinteg(x)
else
s_simp:=s_simp+4*podinteg(x);
end;
s_simp:=s_simp*h/3;
end;     //метод Симпсона

begin 

writeln('Нахождение определенного интеграла методом трапеций');
write('Введите нижний предел a=');
readln(a);
write('Введите верхний предел b=');
readln(b);
write('Введите количество шагов n=');
readln(n);
 toch_znach (a,b,perv,s_toch);
writeln('Вывод точного значения интеграла');
writeln('s_toch=',s_toch:7:5);
 
 h:=(b-a)/n;
 trap(a,b,h,n,podinteg,s_trap);
 writeln('Вывод результата найденный методом трапеций');
 writeln('Вывод относительной погрешности метода трапеций');
 writeln('s_trap=',s_trap:7:5);
 s1:=(abs(s_toch-s_trap))/s_toch;
 writeln('s1=',s1:7:5);

 prav (a,b,h,n,podinteg,s_prav);
 writeln('Вывод результата найденный методом правых прямоугольников');
 writeln('Вывод относительной погрешности метода правых прямоугольников');
 writeln('s_prav=',s_prav:7:5);
 s2:=(abs(s_toch-s_prav))/s_toch;
 writeln('s2=',s2:7:5);
 
 lev (a,b,h,n,podinteg,s_lev);
 writeln('Вывод результата найденный методом левых прямоугольников');
 writeln('Вывод относительной погрешности метода левых прямоугольников');
 writeln('s_lev=',s_lev :7:5);
 s3:=(abs(s_lev-s_prav))/s_toch;
 writeln('s3=',s3:7:5);
 
 simp (a,b,n,podinteg,s_simp);
 writeln('Вывод результата найденный методом Симпсона');
 writeln('Вывод относительной погрешности метода Симпсона');
 writeln('s_simp=',s_simp:7:5);
 s4:=(abs(s_simp-s_prav))/s_toch;
 writeln('s4=',s4:7:5);
 
 x1:=a;
 for k:=1 to n do
begin
 f_perv:=perv(x1);
 writeln (x1:6:3,f_perv:6:3);
 x1:=x1+h;
 end;
 
  x1:=a;
 for k:=1 to n do
begin
 f_podint:=podinteg(x1);
  writeln (x1:6:3,f_podint:6:3);
 x1:=x1+h;
 end;
 end.
______________________________________________________________________________________________

program lab_nelin_urav;
type fun=function (z:real):real;
var
a,b,y,h,eps,delta,fp,x,x1,x2:real;
b1:boolean;

function f1 (x:real):real;         // функция для метода деления пополам
begin    
f1:=x+sqrt(x)+exp((1/3)*ln(x))-2.5; 
end;                              // функция для метода деления пополам

function f2 (x1:real):real;         // функция для метода итераций
begin    
f2:=(3.8/0.35)-(3/0.35)*sin(sqrt(x1));                                
end;                               

function f5 (x1:real):real;         
begin    
f5:=3*sin(sqrt(x1))+0.35*x1-3.8;   // функция для метода итераций
end;

function f3 (x2:real):real;         // функция для метода Ньютона
begin    
f3:=0.25*power(x2,3)+x2-1.2502; 
end;         
function f4 (x2:real):real;
begin
f4:=0.75*sqr(x2)+1;
end;                                // функция для метода Ньютона                                                                          

 
procedure mdp(a,b,eps,delta:real;f1:fun; var x:real);   // метод деления пополам
begin
repeat
x:=(a+b)/2;
if (f1(a)*f1(x)>0) then
a:=x
else
b:=x;
until (abs(a-b)<eps) or (abs(f1(x))<delta);
end;                                                   // метод деления пополам

procedure mit(a:real;f2:fun;eps:real; var x1:real); // метод итераций
var 
i:integer;
begin
i:=0;
b1:=true;
x1:=a;
while (abs(x1-f2(x1))>eps) do
begin
x1:=f2(x1);
i:=i+1;

end;
end;
                                                              // метод итераций

procedure Newton (a:real;eps,delta:real; f3,f4:fun; var x2:real);  // метод Ньютона
begin
x2:=a;
while (abs(f3(x2))>eps) do
x2:=x2-f3(x2)/f4(x2);
end;                                                               // метод Ньютона

begin

writeln('Лабораторная работа:Решение нелинейных уравнений');
writeln('Метод деления пополам');
writeln('Введите значения интервала a и b');
write('a=');
readln(a);
writeln(a);
write('b=');
readln(b);
writeln(b);
delta:=power(10,(-5));
eps:=power(10,(-5));
if (f1(a)*f1(b)<0) then
begin
mdp (a,b,eps,delta,f1,x);
fp:=f1(x);
writeln('Полученное значение x=',x:6:4,'   f(x)=',f1(x):11:9);
end
else
writeln('Корней нет');

writeln('Метод итераций');
writeln('Введите значения интервала a и b');
write('a=');
readln(a);
writeln(a);
write('b=');
readln(b);
writeln(b);
if (f5(a)*f5(b)<0) then
begin
mit(a,f2,eps,x1);
writeln('Полученное значение x=',x1:6:4,'   f(x)=',f5(x1):11:9);
end
else 
writeln('Корней нет');

writeln('Метод Ньютона');
writeln('Введите значения интервала a и b');
write('a=');
readln(a);
writeln(a);
write('b=');
readln(b);
writeln(b);
if (f3(a)*f3(b)<0) then
begin
Newton(a,eps,delta,f3,f4,x2);
writeln('Полученное значение x=',x2:6:4,'  f(x)=',f3(x2):11:9);
end
else
writeln('Корней нет');

end.