making dist

2025.05.02/06Ex/comp.h

@@ -44,7 +44,7 @@ static inline int is_null (const double a)
 
 static inline int is_eps (const double a, const double eps)
 {
-	return (((a < 0) ? -a : a) - eps) < DBL_EPSILON;
+	return ((a < 0) ? -a : a) < eps;
 }
 
 #endif

2025.05.02/06Ex/solve.c

@@ -11,8 +11,6 @@ int t6_solve (
 		double a, double b, 
 		const double eps, const int M, double *res
 ) {
-	double *maximum = d;
-
 	const int len = m + 1;
 	
 	double *y_lst = d;
@@ -20,8 +18,20 @@ int t6_solve (
 	double *t_lst = d + (len << 1);
 
 	int it;
+
+	if (is_eps(y_lst[0], eps)) {
+		*res = a;
+		return 1;
+	} else if (is_eps(y_lst[m], eps)) {
+		*res = b;
+		return 1;
+	}
+
 	for (it = 1; it <= M; ++it)
 	{
+		double maximum = 0;
+		int max_i = 0;
+
 		double x = construct_poly(0, len, y_lst, x_lst);
 		double y = f(x);
 
@@ -42,18 +52,17 @@ int t6_solve (
 			if (is_equal(y, yi))
 				return -1;
 			
-			if ((fabs(yi) - fabs(*maximum)) > DBL_EPSILON)
-				maximum = y_lst + i;
+			if ((yi - maximum) > DBL_EPSILON) {
+				maximum = yi;
+				max_i = i;
+			}
 		}
-
-		*maximum = y;
-		*(maximum + len) = x;
-		*(maximum + (len << 1)) = x;
+		
+		y_lst[max_i] = y;
+		x_lst[max_i] = x;
+		t_lst[max_i] = x;
 	}
 
-	(void)a;
-	(void)b;
-
 	return -1;
 }
 

2025.05.02/10Ex/Makefile

@@ -0,0 +1,42 @@
+WFLAGS = -fstack-protector-all -W -Wall -Wextra -Wunused \
+-Wempty-body -Wlogical-op -Wold-style-declaration -Wmissing-parameter-type \
+-Wignored-qualifiers -Winit-self -Wshadow -Wtype-limits \
+-Wpointer-arith -Wformat-security -Wmissing-format-attribute -Wformat=1 \
+-Wdeclaration-after-statement -Wbad-function-cast -Wnested-externs \
+-Wmissing-prototypes -Wmissing-declarations -Wold-style-definition \
+-Wcast-align -Werror -pedantic -pedantic-errors -Wfloat-equal \
+-Wwrite-strings -Wno-long-long -std=gnu99 -Wstrict-prototypes \
+-Wmissing-field-initializers -Wpointer-sign
+
+LDFLAGS = -std=gnu99 -mfpmath=sse -O3
+LDLIBS = -lm
+
+ifeq ($(OS),Windows_NT)
+	EXE = exe
+	CLEAN = del
+	LDLIBS += -lssp
+else
+	EXE = out
+	CLEAN = rm -f
+endif
+
+TARGET = a10.$(EXE)
+OBJ = main.o solve.o init_f.o
+
+%.o: %.c
+	gcc $(WFLAGS) $(LDFLAGS) -c $< -o $@
+
+$(TARGET): $(OBJ)
+	gcc $^ -o $@ $(LDLIBS)
+
+# Отладочная сборка (gdb)
+gdb: LDFLAGS = -std=gnu99 -mfpmath=sse -g -O0
+gdb: clean $(TARGET)
+
+# Профилировочная сборка (gprof)
+prof: LDFLAGS += -pg
+prof: LDLIBS += -pg
+prof: clean $(TARGET)
+
+clean:
+	$(CLEAN) *.o *$(EXE)

2025.05.02/10Ex/init_f.c

@@ -0,0 +1,61 @@
+#include "init_f.h"
+
+#include <math.h>
+
+
+static int cl = 0;
+
+int get_call_count (void) 
+{
+	return cl;
+}
+
+double f0 (double x)
+{
+	cl++;
+	(void)x;
+
+	return 1;
+}
+
+double f1 (double x)
+{
+	cl++;
+	return (x * 1e-100) - 1.0;
+}
+
+double f2 (double x)
+{
+	cl++;
+	return 4 - x * x;
+}
+
+double f3 (double x)
+{
+	double x_2 = x * x;
+	cl++;
+
+	return x * x_2 + 3 * x_2 + 16;
+}
+
+double f4 (double x)
+{
+	double x_2 = x * x;
+	cl++;
+
+	return 3 - 2 * x_2 - x_2 * x_2;
+}
+
+double f5 (double x)
+{
+	cl++;
+	return sqrt(fabs(x) + 1) - 2;
+}
+
+double f6 (double x)
+{
+	cl++;
+	return sqrt(sqrt(fabs(x) + 1) + 1) - 2;
+}
+
+

2025.05.02/10Ex/init_f.h

@@ -0,0 +1,13 @@
+#ifndef INIT_F_H
+#define INIT_F_H
+
+int get_call_count (void); 
+double f0 (double x);
+double f1 (double x);
+double f2 (double x);
+double f3 (double x);
+double f4 (double x);
+double f5 (double x);
+double f6 (double x);
+
+#endif

2025.05.02/10Ex/main.c

@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <time.h>
+#include <math.h>
+
+#include "init_f.h"
+#include "solve.h"
+
+/* ./a.out a b eps M k */
+int main(int argc, char *argv[])
+{
+	double t, a, b, eps, x = 0;
+	int m, k, cl, it, task = 10;
+	
+	double (*f) (double);
+	double (*f_lst[]) (double) = {f0, f1, f2, f3, f4, f5, f6};
+	int len_f = sizeof(f_lst) / sizeof(f_lst[0]);
+
+	if (
+			!((argc == 6) && 
+			sscanf(argv[1], "%lf", &a) == 1 &&
+			sscanf(argv[2], "%lf", &b) == 1 &&
+			(a <= b) &&
+			(sscanf(argv[3], "%lf", &eps) == 1 && (eps >= 0)) &&
+			((sscanf(argv[4], "%d", &m) == 1) && m > 0) &&
+			((sscanf(argv[5], "%d", &k) == 1) && ((0 <= k) && (k <= len_f))))
+	) {
+		fprintf(stderr, "Usage: %s a b eps M k\n", argv[0]);
+		return -1;
+	}
+
+	f = f_lst[k];
+
+	t = clock();
+	it = t10_solve(f, a, b, eps, m, &x);
+	t = (clock() - t) / CLOCKS_PER_SEC;
+		
+	cl = get_call_count();
+	
+	if (it < 0)
+	{
+		fprintf(stdout, "%s : Task = %d NOT FOUND Count = %d T = %.2f\n", argv[0], task, cl, t);
+		return -2;
+	} else 
+	{
+		printf("%s : Task = %d X = %e Res = %e Its = %d Count = %d T = %.2f\n", argv[0], task, x, f(x), it, cl, t);
+		return 0;
+	}
+}
+

2025.05.02/10Ex/solve.c

@@ -0,0 +1,74 @@
+#include "solve.h"
+
+#include <math.h>
+#include <float.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+int t5_solve (
+		double (*f) (double), 
+		double a, double b, 
+		double eps, int m, double *x
+) {
+	int it;
+	double c = (a + b) * 0.5;
+
+	double y_a = f(a);
+	double y_c = f(c);
+	double y_b = f(b);
+	
+	if (is_null(y_a)) {
+		*x = a;
+		return 1;
+	} else if (is_null(y_b)) {
+		*x = b;
+		return 1;
+	} else if (is_null(y_c)) {
+		*x = c;
+		return 1;
+	}
+
+	if (is_equal(a, b))
+		return -1;
+	else if (is_equal(a, c))
+	       return -1;
+	else if (is_equal(b, c))
+		return -1;
+
+	for (it = 1; it <= m; ++it)
+	{
+		double *temp_pnt = 0, *inner_max_pnt;
+		const double x_new = a - 
+			angle * y_a +
+		       	((((b - c) / (y_b - y_c)) - angle) / (y_b - y_a)) * y_a * y_c;
+		const double y_new = f(x_new);
+
+		if (is_eps(y_new, eps))
+		{
+			*x = x_new;
+			return it;
+		}
+
+		if (
+			is_equal(x_new, a) ||
+			is_equal(x_new, c) ||
+			is_equal(x_new, b)
+		   )
+			return -1;
+
+		inner_max_pnt = fp_abs_max(&c, &b, &y_c, &y_b, &temp_pnt);	
+		*fp_abs_max(&a, inner_max_pnt, &y_a, temp_pnt, &temp_pnt) = x_new;
+		*temp_pnt = y_new;
+	}
+
+	if (it > m)
+		return -2;
+	else
+	{
+		double temp = 0, *temp_x_pnt = fpmax(&c, &b, -y_c, -y_b, &temp);
+		*x = *fpmax(&a, temp_x_pnt, -y_a, temp, &temp);
+		return it;
+	}
+}
+

2025.05.02/10Ex/solve.h

@@ -0,0 +1,56 @@
+#ifndef SOLVE_H
+#define SOLVE_H
+
+#include <math.h>
+#include <float.h>
+
+static inline double * fpmax (double *pa, double *pb, double fa, double fb, double *max_f_p)
+{
+	if ((fa - fb) > DBL_EPSILON) 
+	{
+		*max_f_p = fa;
+		return pa;
+	} else
+	{
+		*max_f_p = fb;
+		return pb;
+	}
+}
+
+static inline double * fp_abs_max (double *pa, double *pb, double *fa, double *fb, double **max_f_p)
+{
+	if ((fabs(*fa) - fabs(*fb)) > DBL_EPSILON) 
+	{
+		*max_f_p = fa;
+		return pa;
+	} else
+	{
+		*max_f_p = fb;
+		return pb;
+	}
+}
+
+static inline int is_equal (const double a, const double b)
+{
+	double diff = a - b;
+	double max_val = (a > b) ? a : b;
+	return ((diff < 0) ? -diff : diff) < (DBL_EPSILON * max_val);
+}
+
+static inline int is_null (const double a)
+{
+	return ((a < 0) ? -a : a) < DBL_EPSILON;
+}
+
+static inline int is_eps (const double a, const double eps)
+{
+	return (((a < 0) ? -a : a) - eps) < DBL_EPSILON;
+}
+
+int t5_solve (
+		double (*f) (double), 
+		double a, double b, 
+		double eps, int m, double *x
+		);
+
+#endif

2025.05.02/dist/Krivoruchenko_SK/a05.c

@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <time.h>
+#include <math.h>
+
+#include "init_f.h"
+#include "solve.h"
+
+/* ./a.out a b eps M k */
+int main(int argc, char *argv[])
+{
+	double t, a, b, eps, x = 0;
+	int m, k, cl, it, task = 5;
+	
+	double (*f) (double);
+	double (*f_lst[]) (double) = {f0, f1, f2, f3, f4, f5, f6}; //TODO: Rem f7
+	int len_f = sizeof(f_lst) / sizeof(f_lst[0]);
+
+	if (
+			!((argc == 6) && 
+			sscanf(argv[1], "%lf", &a) == 1 &&
+			sscanf(argv[2], "%lf", &b) == 1 &&
+			(a <= b) &&
+			(sscanf(argv[3], "%lf", &eps) == 1 && (eps >= 0)) &&
+			((sscanf(argv[4], "%d", &m) == 1) && m > 0) &&
+			((sscanf(argv[5], "%d", &k) == 1) && ((0 <= k) && (k <= len_f))))
+	) {
+		fprintf(stderr, "Usage: %s a b eps M k\n", argv[0]);
+		return -1;
+	}
+
+	f = f_lst[k];
+
+	t = clock();
+	it = t5_solve(f, a, b, eps, m, &x);
+	t = (clock() - t) / CLOCKS_PER_SEC;
+		
+	cl = get_call_count();
+	
+	if (it < 0)
+	{
+		fprintf(stdout, "%s : Task = %d NOT FOUND Count = %d T = %.2f\n", argv[0], task, cl, t);
+		return -2;
+	} else 
+	{
+		printf("%s : Task = %d X = %e Res = %e Its = %d Count = %d T = %.2f\n", argv[0], task, x, f(x), it, cl, t);
+		return 0;
+	}
+}
+

2025.05.02/dist/Krivoruchenko_SK/a06.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+
+#include "init_f.h"
+#include "array_io.h"
+#include "solve.h"
+
+/* ./a.out m a b eps M k */
+int main(int argc, char *argv[])
+{
+	double t = 0, *d, a, b, eps, x = 0;
+	int deg_poly, num_iter, k, cl, it, task = 6;
+	
+	double (*f) (double);
+	double (*f_lst[]) (double) = {f0, f1, f2, f3, f4, f5, f6};
+	int len_f = sizeof(f_lst) / sizeof(f_lst[0]);
+
+	if (
+			!((argc == 7) && 
+			sscanf(argv[1], "%d", &deg_poly) == 1 &&
+			sscanf(argv[2], "%lf", &a) == 1 &&
+			sscanf(argv[3], "%lf", &b) == 1 &&
+			(a <= b) &&
+			(sscanf(argv[4], "%lf", &eps) == 1 && (eps >= 0)) &&
+			((sscanf(argv[5], "%d", &num_iter) == 1) && num_iter > 0) &&
+			((sscanf(argv[6], "%d", &k) == 1) && ((0 <= k) && (k <= len_f))))
+	) {
+		fprintf(stderr, "Usage: %s m a b eps M k\n", argv[0]);
+		return -1;
+	}
+
+	d = (double *)malloc(3 * (deg_poly + 1) * sizeof(double));
+	if (!d)
+	{
+		fprintf(stderr, "Error: Not enough memory!\n");
+		return -2;
+	}
+	
+	f = f_lst[k];
+	
+	it = init_array(f, d, deg_poly, a, b, eps, &x);
+	
+	if (!it)
+	{
+		t = clock();
+		it = t6_solve(f, deg_poly, d, a, b, eps, num_iter, &x);
+		t = (clock() - t) / CLOCKS_PER_SEC;
+	}
+
+	cl = get_call_count();
+	
+	free(d);
+
+	if (it < 0)
+	{
+		fprintf(stdout, "%s : Task = %d NOT FOUND Count = %d T = %.2f\n", argv[0], task, cl, t);
+		return -2;
+	} else 
+	{
+		fprintf(stdout, "%s : Task = %d X = %e Res = %e Its = %d Count = %d T = %.2f\n", argv[0], task, x, f(x), it, cl, t);
+		return 0;
+	}
+}
+

2025.05.02/dist/Krivoruchenko_SK/array_io.c

@@ -0,0 +1,41 @@
+#include "array_io.h"
+#include "comp.h"
+
+int init_array (
+		double (*f) (double), 
+		double *d, int m,
+		double a, double b,
+	       	double eps, double *ret
+) {
+	const double h = (b - a) / m;
+	const int len = m+1;
+
+	double *y_lst = d;
+	double *x_lst = d + len;
+	double *t_lst = d + (len << 1);
+
+	double x = a;
+
+	for (int i = 0; i < len; ++i)
+	{
+		double y = f(x);
+
+		if (is_eps(y, eps))
+		{
+			*ret = x;
+			return 1;
+		}
+
+		for (int j = 0; j < i; ++j)
+			if (is_equal(y, y_lst[j]))
+				return -1;
+
+		y_lst[i] = y;
+		x_lst[i] = x;
+		t_lst[i] = x;
+
+		x += h;
+	}
+
+	return 0;
+}

2025.05.02/dist/Krivoruchenko_SK/array_io.h

@@ -0,0 +1,11 @@
+#ifndef ARRAY_IO_H
+#define ARRAY_IO_H
+
+int init_array (
+		double (*f) (double), 
+		double *d, int m,
+		double a, double b,
+	       	double eps, double *ret
+);
+
+#endif

2025.05.02/dist/Krivoruchenko_SK/comp.h

@@ -0,0 +1,50 @@
+#ifndef COMP_H
+#define COMP_H
+
+#include <float.h>
+#include <math.h>
+
+static inline double * fpmax (double *pa, double *pb, double fa, double fb, double *max_f_p)
+{
+	if ((fa - fb) > DBL_EPSILON) 
+	{
+		*max_f_p = fa;
+		return pa;
+	} else
+	{
+		*max_f_p = fb;
+		return pb;
+	}
+}
+
+static inline double * fp_abs_max (double *pa, double *pb, double *fa, double *fb, double **max_f_p)
+{
+	if ((fabs(*fa) - fabs(*fb)) > DBL_EPSILON) 
+	{
+		*max_f_p = fa;
+		return pa;
+	} else
+	{
+		*max_f_p = fb;
+		return pb;
+	}
+}
+
+static inline int is_equal (const double a, const double b)
+{
+	double diff = a - b;
+	double max_val = (a > b) ? a : b;
+	return ((diff < 0) ? -diff : diff) < (DBL_EPSILON * max_val);
+}
+
+static inline int is_null (const double a)
+{
+	return ((a < 0) ? -a : a) < DBL_EPSILON;
+}
+
+static inline int is_eps (const double a, const double eps)
+{
+	return (((a < 0) ? -a : a) - eps) < DBL_EPSILON;
+}
+
+#endif

2025.05.02/dist/Krivoruchenko_SK/init_f.c

@@ -1,128 +1,66 @@
 #include "init_f.h"
 
 #include <math.h>
-#include <float.h>
 
 
-static int cl_f = 0;
-static int cl_d = 0;
+static int cl = 0;
 
 int get_call_count (void) 
 {
-	return cl_f;
-}
-
-int get_call_function_count (void) 
-{
-	return cl_f;
-}
-
-int get_call_derivative_count (void)
-{
-	return cl_d;
+	return cl;
 }
 
 double f0 (double x)
 {
-	cl_f++;
+	cl++;
 	(void)x;
 
 	return 1;
 }
 
-double d0 (double x)
-{
-	cl_d++;
-	(void)x;
-
-	return 0;
-}
-
 double f1 (double x)
 {
-	cl_f++;
-	return ((x * 1e-100) - 1.0) * 1e100;
-}
-
-double d1 (double x)
-{
-	(void)x;
-	cl_d++;
-	return 1;
+	cl++;
+	return (x * 1e-100) - 1.0;
 }
 
 double f2 (double x)
 {
-	cl_f++;
-	return 4 - x * x;
-}
-
-double d2 (double x)
-{
-	cl_d++;
-	return -2 * x;
+	double x_2 = x * x;
+	cl++;
+	return 4 - x_2;
 }
 
 double f3 (double x)
 {
 	double x_2 = x * x;
-	cl_f++;
+	double x_3 = x * x_2;
+	cl++;
 
-	return x * x_2 + 3 * x_2 + 16;
-}
-
-double d3 (double x)
-{
-	cl_d++;
-
-	return 3 * x * x + 6 * x;
+	return x_3 + 3 * x_2 + 16;
 }
 
 double f4 (double x)
 {
 	double x_2 = x * x;
-	cl_f++;
+	double x_4 = x_2 * x_2;
+	cl++;
 
-	return 3 - 2 * x_2 - x_2 * x_2;
-}
-
-double d4 (double x)
-{
-	cl_d++;
-
-	return -4 * x - 4 * ((x * x) * x);
+	return 3 - 2 * x_2 - x_4;
 }
 
 double f5 (double x)
 {
-	cl_f++;
-	return sqrt(fabs(x) + 1) - 2;
-}
-
-double d5 (double x)
-{
-	cl_d++;
-	if (x < -DBL_EPSILON)
-		return (-1.0 / (sqrt(fabs(x) + 1))) * 0.5;
-	else if (x > DBL_EPSILON)
-		return (1.0 / (sqrt(fabs(x) + 1))) * 0.5;
-	return 0;
+	double sq_x = sqrt(fabs(x) + 1);
+	cl++;
+	return sq_x - 2;
 }
 
 double f6 (double x)
 {
-	cl_f++;
-	return sqrt(sqrt(fabs(x) + 1) + 1) - 2;
+	double sq_x = sqrt(fabs(x) + 1);
+	double sq = sqrt(sq_x + 1);
+	cl++;
+	return sq - 2;
 }
 
-double d6 (double x)
-{
-	double sqrt_x = sqrt(fabs(x) + 1);
-	cl_d++;
-	
-	if (x < -DBL_EPSILON)
-		return (-1.0 / (sqrt(sqrt_x + 1) * sqrt_x)) * 0.25;
-	else if (x > DBL_EPSILON)
-		return (1.0 / (sqrt(sqrt_x + 1) * sqrt_x)) * 0.25;
-	return 0;
-}

2025.05.02/dist/Krivoruchenko_SK/polynom.c

@@ -0,0 +1,43 @@
+#include "polynom.h"
+
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+
+// the Newton interpolation polynomial
+double construct_poly (const double x_0, const int n, const double * restrict X, double * restrict Y)
+{
+	double value, start_value;
+
+	for (int k = 0; k < n-1; ++k)
+	{
+		double last_x; 
+		double last_y = Y[n-1];
+		
+		for (int i = n-2; i >= k; --i)
+		{
+			const double x_i = X[i-k];
+			const double y_i = Y[i];
+			last_x = X[i+1];
+			
+			if (fabs(last_x - x_i) < DBL_EPSILON)
+				return DBL_MAX;
+			
+			Y[i+1] = (last_y - y_i) / (last_x - x_i);
+
+			last_y = y_i;
+		}
+	}
+
+	start_value = 1;
+	value = 0;
+
+	for (int i = 0; i < n; ++i)
+	{
+		value += Y[i] * start_value;
+		start_value *= (x_0 - X[i]);
+	}
+
+	return value;
+}
+

2025.05.02/dist/Krivoruchenko_SK/polynom.h

@@ -0,0 +1,6 @@
+#ifndef POLYNOM_H
+#define POLYNOM_H
+
+double construct_poly (const double x_0, const int n, const double * restrict X, double * restrict Y);
+
+#endif

2025.05.02/tests/6th_test.sh

@@ -1,7 +1,9 @@
 script_name="$(basename "$0")"
+prog="6"
+
 iter="1000"
 poly_deg="10"
-prog="6"
+eps="1e-14"
 
 mkdir -p tests
 
@@ -17,25 +19,35 @@ if [ ! -f a0$prog.out ]; then
 	exit 1
 fi
 
+outlog="$(pwd)/tests/out_a0${prog}_$script_name.log"
+errlog="$(pwd)/tests/err_a0${prog}_$script_name.log"
+
+rm -f $outlog $errlog
+
 echo "Тест запущен..."
 
 for (( k = 3 ; k < 7; k++ )); do 
-	echo "------- K = $k -------"
 	for (( a = -100 ; a < -40 ; a++ )); do 
 		for (( b = -9 ; b < 10 ; b++ )); do
-			echo "./a0$prog.out $poly_deg "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" 1e-16 $iter $k"
-			./a0$prog.out $poly_deg "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" 1e-16 $iter $k
+			x="$(echo "$a / 10" | bc -l)"
+			y="$(echo "$b / 10" | bc -l)"
+			cmd="./a0$prog.out $poly_deg $x $y $eps $iter $k"
+			echo "$cmd"
+			$cmd
 		done
 	done
 	for (( a = -9 ; a < 10 ; a++ )); do 
 		for (( b = 11 ; b < 100 ; b++ )); do
-			echo "./a0$prog.out $poly_deg "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" 1e-16 $iter $k"
-			./a0$prog.out $poly_deg "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" 1e-16 $iter $k
+			x="$(echo "$a / 10" | bc -l)"
+			y="$(echo "$b / 10" | bc -l)"
+			cmd="./a0$prog.out $poly_deg $x $y $eps $iter $k"
+			echo "$cmd"
+			$cmd
 		done
 	done
-done >$(pwd)/tests/out_$script_name.log 2>$(pwd)/tests/err_$script_name.log
+done >$outlog 2>$errlog
 
-echo "Тест записан в ./tests/out_$script_name.log"
-echo "Ошибки записаны в ./tests/err_$script_name.log"
+echo "Тест записан в $outlog"
+echo "Ошибки записаны в $errlog"
 echo "Тест завершен"
 

2025.05.02/tests/main_test.sh

@@ -8,7 +8,7 @@ if [ "$#" -ne 1 ]; then
 	exit 1
 fi
 
-prog=$1
+prog=$(printf "%02d" "$1")
 
 mkdir -p tests
 
@@ -24,10 +24,10 @@ if [ ! -f a0$prog.out ]; then
 	exit 2
 fi
 
-outlog="$(pwd)/tests/out_a0${prog}_$script_name.log"
-errlog="$(pwd)/tests/err_a0${prog}_$script_name.log"
+outlog="$(pwd)/tests/out_a${prog}_$script_name.log"
+errlog="$(pwd)/tests/err_a${prog}_$script_name.log"
 
-rm -f $outlog $errlog
+rm -f "$outlog" "$errlog"
 
 echo "Тест запущен..."
 
@@ -37,14 +37,14 @@ for (( k = 3 ; k < 7; k++ )); do
 	for (( a = -100 ; a < -40 ; a++ )); do 
 		for (( b = -9 ; b < 10 ; b++ )); do
 			echo "./a0$prog.out "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" $eps $iter $k"
-			echo "$i $(./a0$prog.out "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" $eps $iter $k)"
+			echo "$i $(./a$prog.out "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" $eps $iter $k)"
 			((i+=2))
 		done
 	done
 	for (( a = -9 ; a < 10 ; a++ )); do 
 		for (( b = 11 ; b < 100 ; b++ )); do
 			echo "$i ./a0$prog.out "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" $eps $iter $k"
-			echo "$i $(./a0$prog.out "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" $eps $iter $k)"
+			echo "$i $(./a$prog.out "$(echo "$a / 10" | bc -l)" "$(echo "$b / 10" | bc -l)" $eps $iter $k)"
 			((i+=2))
 		done
 	done