making dist

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