From 2d7717990410d4dbd210ad71972eacfe9aebc418 Mon Sep 17 00:00:00 2001 From: AZEN-SGG Date: Tue, 25 Mar 2025 23:35:44 +0300 Subject: [PATCH] chore(cleanup): replace legacy Matvei project with updated Linux-based version MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Removed obsolete Matvei source files (tasks 01–04, array/matrix/io_status modules, Makefile) - Introduced new Linux-compatible structure in Linux/Matvei - Updated build logic via new Makefile - Adjusted .gitignore to exclude new artifacts --- .gitignore | 2 - 2025.03.21/dist/Linux/Makefile | 15 ++ 2025.03.21/dist/Linux/a01.c | 67 +++++ 2025.03.21/dist/Linux/a02.c | 67 +++++ 2025.03.21/dist/Linux/a03.c | 67 +++++ 2025.03.21/dist/Linux/a04.c | 67 +++++ 2025.03.21/dist/Linux/a05.c | 67 +++++ 2025.03.21/dist/Linux/a06.c | 67 +++++ 2025.03.21/dist/Linux/a07.c | 67 +++++ 2025.03.21/dist/Linux/a08.c | 67 +++++ 2025.03.21/dist/Linux/a09.c | 67 +++++ 2025.03.21/dist/Linux/a10.c | 67 +++++ 2025.03.21/dist/Linux/array_io.c | 40 +++ 2025.03.21/dist/Linux/array_io.h | 11 + 2025.03.21/dist/Linux/init_f.c | 30 +++ 2025.03.21/dist/Linux/init_f.h | 9 + 2025.03.21/dist/Linux/io_status.h | 13 + 2025.03.21/dist/Linux/solve.c | 402 ++++++++++++++++++++++++++++ 2025.03.21/dist/Linux/solve.h | 15 ++ 2025.03.21/dist/Matvei/Makefile | 14 + 2025.03.21/dist/Matvei/a01.c | 98 +++++++ 2025.03.21/dist/Matvei/a02.c | 99 +++++++ 2025.03.21/dist/Matvei/a03.c | 97 +++++++ 2025.03.21/dist/Matvei/a04.c | 110 ++++++++ 2025.03.21/dist/Matvei/a05.c | 98 +++++++ 2025.03.21/dist/Matvei/a06.c | 99 +++++++ 2025.03.21/dist/Matvei/a07.c | 110 ++++++++ 2025.03.21/dist/Matvei/a08.c | 105 ++++++++ 2025.03.21/dist/Matvei/a09.c | 110 ++++++++ 2025.03.21/dist/Matvei/a10.c | 137 ++++++++++ 2025.03.21/dist/Matvei/array.c | 62 +++++ 2025.03.21/dist/Matvei/array.h | 4 + 2025.03.21/dist/Matvei/comparison.c | 8 + 2025.03.21/dist/Matvei/comparison.h | 3 + 2025.03.21/dist/Matvei/input1.txt | 56 ++++ 2025.03.21/dist/Matvei/io_status.h | 6 + 2025.03.21/dist/Matvei/t.txt | 3 + 2025.03.21/dist/Windows/Makefile | 15 ++ 2025.03.21/dist/Windows/a.txt | 56 ++++ 2025.03.21/dist/Windows/a01.c | 67 +++++ 2025.03.21/dist/Windows/a02.c | 67 +++++ 2025.03.21/dist/Windows/a03.c | 67 +++++ 2025.03.21/dist/Windows/a04.c | 67 +++++ 2025.03.21/dist/Windows/a05.c | 67 +++++ 2025.03.21/dist/Windows/a06.c | 67 +++++ 2025.03.21/dist/Windows/a07.c | 67 +++++ 2025.03.21/dist/Windows/a08.c | 67 +++++ 2025.03.21/dist/Windows/a09.c | 67 +++++ 2025.03.21/dist/Windows/a10.c | 67 +++++ 2025.03.21/dist/Windows/array_io.c | 40 +++ 2025.03.21/dist/Windows/array_io.h | 11 + 2025.03.21/dist/Windows/init_f.c | 30 +++ 2025.03.21/dist/Windows/init_f.h | 9 + 2025.03.21/dist/Windows/io_status.h | 13 + 2025.03.21/dist/Windows/solve.c | 402 ++++++++++++++++++++++++++++ 2025.03.21/dist/Windows/solve.h | 15 ++ 2025.03.21/dist/Windows/tests.txt | 5 + 2025.03.28/dist/Ulyanov/Makefile | 20 ++ 2025.03.28/dist/Ulyanov/array.c | 74 +++++ 2025.03.28/dist/Ulyanov/array.h | 5 + 2025.03.28/dist/Ulyanov/io_status.h | 6 + 2025.03.28/dist/Ulyanov/matrix.c | 99 +++++++ 2025.03.28/dist/Ulyanov/matrix.h | 12 + 2025.03.28/dist/Ulyanov/task01.c | 152 +++++++++++ 2025.03.28/dist/Ulyanov/task02.c | 163 +++++++++++ 2025.03.28/dist/Ulyanov/task03.c | 180 +++++++++++++ 2025.03.28/dist/Ulyanov/task04.c | 180 +++++++++++++ 67 files changed, 4581 insertions(+), 2 deletions(-) create mode 100644 2025.03.21/dist/Linux/Makefile create mode 100644 2025.03.21/dist/Linux/a01.c create mode 100644 2025.03.21/dist/Linux/a02.c create mode 100644 2025.03.21/dist/Linux/a03.c create mode 100644 2025.03.21/dist/Linux/a04.c create mode 100644 2025.03.21/dist/Linux/a05.c create mode 100644 2025.03.21/dist/Linux/a06.c create mode 100644 2025.03.21/dist/Linux/a07.c create mode 100644 2025.03.21/dist/Linux/a08.c create mode 100644 2025.03.21/dist/Linux/a09.c create mode 100644 2025.03.21/dist/Linux/a10.c create mode 100644 2025.03.21/dist/Linux/array_io.c create mode 100644 2025.03.21/dist/Linux/array_io.h create mode 100644 2025.03.21/dist/Linux/init_f.c create mode 100644 2025.03.21/dist/Linux/init_f.h create mode 100644 2025.03.21/dist/Linux/io_status.h create mode 100644 2025.03.21/dist/Linux/solve.c create mode 100644 2025.03.21/dist/Linux/solve.h create mode 100644 2025.03.21/dist/Matvei/Makefile create mode 100644 2025.03.21/dist/Matvei/a01.c create mode 100644 2025.03.21/dist/Matvei/a02.c create mode 100644 2025.03.21/dist/Matvei/a03.c create mode 100644 2025.03.21/dist/Matvei/a04.c create mode 100644 2025.03.21/dist/Matvei/a05.c create mode 100644 2025.03.21/dist/Matvei/a06.c create mode 100644 2025.03.21/dist/Matvei/a07.c create mode 100644 2025.03.21/dist/Matvei/a08.c create mode 100644 2025.03.21/dist/Matvei/a09.c create mode 100644 2025.03.21/dist/Matvei/a10.c create mode 100644 2025.03.21/dist/Matvei/array.c create mode 100644 2025.03.21/dist/Matvei/array.h create mode 100644 2025.03.21/dist/Matvei/comparison.c create mode 100644 2025.03.21/dist/Matvei/comparison.h create mode 100644 2025.03.21/dist/Matvei/input1.txt create mode 100644 2025.03.21/dist/Matvei/io_status.h create mode 100644 2025.03.21/dist/Matvei/t.txt create mode 100644 2025.03.21/dist/Windows/Makefile create mode 100644 2025.03.21/dist/Windows/a.txt create mode 100644 2025.03.21/dist/Windows/a01.c create mode 100644 2025.03.21/dist/Windows/a02.c create mode 100644 2025.03.21/dist/Windows/a03.c create mode 100644 2025.03.21/dist/Windows/a04.c create mode 100644 2025.03.21/dist/Windows/a05.c create mode 100644 2025.03.21/dist/Windows/a06.c create mode 100644 2025.03.21/dist/Windows/a07.c create mode 100644 2025.03.21/dist/Windows/a08.c create mode 100644 2025.03.21/dist/Windows/a09.c create mode 100644 2025.03.21/dist/Windows/a10.c create mode 100644 2025.03.21/dist/Windows/array_io.c create mode 100644 2025.03.21/dist/Windows/array_io.h create mode 100644 2025.03.21/dist/Windows/init_f.c create mode 100644 2025.03.21/dist/Windows/init_f.h create mode 100644 2025.03.21/dist/Windows/io_status.h create mode 100644 2025.03.21/dist/Windows/solve.c create mode 100644 2025.03.21/dist/Windows/solve.h create mode 100644 2025.03.21/dist/Windows/tests.txt create mode 100644 2025.03.28/dist/Ulyanov/Makefile create mode 100644 2025.03.28/dist/Ulyanov/array.c create mode 100644 2025.03.28/dist/Ulyanov/array.h create mode 100644 2025.03.28/dist/Ulyanov/io_status.h create mode 100644 2025.03.28/dist/Ulyanov/matrix.c create mode 100644 2025.03.28/dist/Ulyanov/matrix.h create mode 100644 2025.03.28/dist/Ulyanov/task01.c create mode 100644 2025.03.28/dist/Ulyanov/task02.c create mode 100644 2025.03.28/dist/Ulyanov/task03.c create mode 100644 2025.03.28/dist/Ulyanov/task04.c diff --git a/.gitignore b/.gitignore index 8780d97..672039c 100644 --- a/.gitignore +++ b/.gitignore @@ -40,7 +40,6 @@ CMakeLists.txt CMakeCache.txt CMakeFiles/ build/ -dist/ *.cmake # Python files @@ -68,7 +67,6 @@ yarn-error.log *.log *.lock *.cache/ -dist/ out/ coverage/ diff --git a/2025.03.21/dist/Linux/Makefile b/2025.03.21/dist/Linux/Makefile new file mode 100644 index 0000000..d4c94a5 --- /dev/null +++ b/2025.03.21/dist/Linux/Makefile @@ -0,0 +1,15 @@ +FLAGS = -fstack-protector-all -W -Wall -Wextra -Wunused -Wcast-align -Werror -pedantic -pedantic-errors -Wfloat-equal -Wpointer-arith -Wformat-security -Wmissing-format-attribute -Wformat=1 -Wwrite-strings -Wcast-align -Wno-long-long -std=gnu99 -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wold-style-definition -Wdeclaration-after-statement -Wbad-function-cast -Wnested-externs -O3 + +%.out: %.o solve.o array_io.o init_f.o + gcc $(FLAGS) $^ -o $@ -lm +%.o: %.c + gcc -c $(FLAGS) $< + +all: a01.out a02.out a03.out a04.out a05.out a06.out a07.out a08.out a09.out a10.out + +solve.o: solve.c solve.h +array_io.o: array_io.c array_io.h +init_f.o: init_f.c init_f.h + +clean: + rm -f *.o *.out diff --git a/2025.03.21/dist/Linux/a01.c b/2025.03.21/dist/Linux/a01.c new file mode 100644 index 0000000..1b5c068 --- /dev/null +++ b/2025.03.21/dist/Linux/a01.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 1; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t1_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a02.c b/2025.03.21/dist/Linux/a02.c new file mode 100644 index 0000000..51d1c6d --- /dev/null +++ b/2025.03.21/dist/Linux/a02.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 2; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t2_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a03.c b/2025.03.21/dist/Linux/a03.c new file mode 100644 index 0000000..ab7dcb7 --- /dev/null +++ b/2025.03.21/dist/Linux/a03.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 3; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t3_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a04.c b/2025.03.21/dist/Linux/a04.c new file mode 100644 index 0000000..3049b78 --- /dev/null +++ b/2025.03.21/dist/Linux/a04.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 4; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t4_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a05.c b/2025.03.21/dist/Linux/a05.c new file mode 100644 index 0000000..585b48a --- /dev/null +++ b/2025.03.21/dist/Linux/a05.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 5; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t5_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a06.c b/2025.03.21/dist/Linux/a06.c new file mode 100644 index 0000000..79e7a8c --- /dev/null +++ b/2025.03.21/dist/Linux/a06.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 6; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t6_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a07.c b/2025.03.21/dist/Linux/a07.c new file mode 100644 index 0000000..1a00e96 --- /dev/null +++ b/2025.03.21/dist/Linux/a07.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 7; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t7_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a08.c b/2025.03.21/dist/Linux/a08.c new file mode 100644 index 0000000..a68a173 --- /dev/null +++ b/2025.03.21/dist/Linux/a08.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 8; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t8_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a09.c b/2025.03.21/dist/Linux/a09.c new file mode 100644 index 0000000..962b852 --- /dev/null +++ b/2025.03.21/dist/Linux/a09.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 9; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t9_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/a10.c b/2025.03.21/dist/Linux/a10.c new file mode 100644 index 0000000..81637d7 --- /dev/null +++ b/2025.03.21/dist/Linux/a10.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 10; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t10_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Linux/array_io.c b/2025.03.21/dist/Linux/array_io.c new file mode 100644 index 0000000..6e56ecf --- /dev/null +++ b/2025.03.21/dist/Linux/array_io.c @@ -0,0 +1,40 @@ +#include +#include "array_io.h" + +io_status read_matrix(double *a, int n, int m, const char *name) +{ + int i, j; + FILE *fp; + if (!(fp = fopen(name, "r"))) return ERROR_OPEN; + for (i = 0; i < n; i++) + for (j = 0; j < m; j++) + if (fscanf(fp, "%lf", a + i * m + j) != 1) + {fclose(fp); return ERROR_READ;} + fclose(fp); + return SUCCESS; +} + +void print_matrix(const double *a, int n, int m, int p) +{ + int np = (n > p ? p : n); + int mp = (m > p ? p : m); + int i, j; + + for (i = 0; i < np; i++) + { + for (j = 0; j < mp; j++) + printf(" %10.3e", a[i * m + j]); + printf("\n"); + } +} + +void init_matrix(double *a, int n, int m, int k) +{ + double (*q)(int, int, int, int); + double (*f[])(int, int, int, int) = {f1, f2, f3, f4}; + int i, j; + q = f[k-1]; + for (i = 0; i < n; i++) + for (j = 0; j < m; j++) + a[i * m + j] = q(n, m, i+1, j+1); +} diff --git a/2025.03.21/dist/Linux/array_io.h b/2025.03.21/dist/Linux/array_io.h new file mode 100644 index 0000000..e312a84 --- /dev/null +++ b/2025.03.21/dist/Linux/array_io.h @@ -0,0 +1,11 @@ +#ifndef ARRAY_IO_H +#define ARRAY_IO_H + +#include "io_status.h" +#include "init_f.h" + +io_status read_matrix(double *a, int n, int m, const char *name); +void print_matrix(const double *a, int n, int m, int p); +void init_matrix(double *a, int n, int m, int k); + +#endif diff --git a/2025.03.21/dist/Linux/init_f.c b/2025.03.21/dist/Linux/init_f.c new file mode 100644 index 0000000..925afb5 --- /dev/null +++ b/2025.03.21/dist/Linux/init_f.c @@ -0,0 +1,30 @@ +#include "init_f.h" +#include + +#define MAX(n, m) (n < m ? m : n) + +double f1(int n, int m, int i, int j) +{ + return MAX(n, m) - MAX(i, j) + 1; +} + +double f2(int n, int m, int i, int j) +{ + (void)n; + (void)m; + return MAX(i, j); +} + +double f3(int n, int m, int i, int j) +{ + (void)n; + (void)m; + return abs(i - j); +} + +double f4(int n, int m, int i, int j) +{ + (void)n; + (void)m; + return 1./(i+j-1); +} diff --git a/2025.03.21/dist/Linux/init_f.h b/2025.03.21/dist/Linux/init_f.h new file mode 100644 index 0000000..691aace --- /dev/null +++ b/2025.03.21/dist/Linux/init_f.h @@ -0,0 +1,9 @@ +#ifndef INIT_F_H +#define INIT_F_H + +double f1(int n, int m, int i, int j); +double f2(int n, int m, int i, int j); +double f3(int n, int m, int i, int j); +double f4(int n, int m, int i, int j); + +#endif diff --git a/2025.03.21/dist/Linux/io_status.h b/2025.03.21/dist/Linux/io_status.h new file mode 100644 index 0000000..420a981 --- /dev/null +++ b/2025.03.21/dist/Linux/io_status.h @@ -0,0 +1,13 @@ +#ifndef IO_STATUS_H +#define IO_STATUS_H + +#define LEN 1234 + +typedef enum _io_status +{ + SUCCESS, + ERROR_OPEN, + ERROR_READ +} io_status; + +#endif diff --git a/2025.03.21/dist/Linux/solve.c b/2025.03.21/dist/Linux/solve.c new file mode 100644 index 0000000..d87aa05 --- /dev/null +++ b/2025.03.21/dist/Linux/solve.c @@ -0,0 +1,402 @@ +#include "solve.h" +#include +#include +#include + +#define eps 1e-17 + +int t1_solve(double *a, int m, int n) +{ + int l, min_j = 0, del_j; + double minimum = (m * n > 0) ? DBL_MAX : 0; + + for (int i = 0; i < m; i++) + for (int j = 0; j < n; j++) + { + double temp = fabs(a[i*n + j]); + if (temp < minimum) + { + minimum = temp; + min_j = j; + } + } + + for (l = min_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return min_j + 1; +} + +int t2_solve(double *a, int m, int n) +{ + int min_i = 0, min_j = 0; + double minimum = (m * n > 0) ? fabs(a[0]) : 0; + + for (int i = 0; i < m; i++) + for (int j = 0; j < n; j++) + if ((minimum - fabs(a[i*n + j])) > eps) { minimum = fabs(a[i*n + j]); min_i = i; min_j = j; } + + for (int l = min_j+1, del_j = 1; l < min_i*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (min_i+1)*n, del_j = min_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + min_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return min_i * n + min_j; +} + +int t3_solve(double *a, int m, int n) +{ + int min_j = 0; + double minimum = -1; + + for (int j = 0; j < n; j++) + { + double cur = 0; + for (int i = 0; i < m; i++) + cur += fabs(a[i*n + j]); + if ((minimum - cur) > eps || j == 0) { minimum = cur; min_j = j; } + } + + for (int l = min_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return min_j + 1; +} + +int t4_solve(double *a, int m, int n) +{ + int min_i = 0, min_j = 0; + double minimum = -1; + + for (int i = 0; i < m; i++) + { + double sum = 0; + for (int j = 0; j < n; j++) + sum += fabs(a[i*n + j]); + + if ((minimum - sum) > eps || i == 0) { minimum = sum; min_i = i; } + } + + for (int j = 0; j < n; j++) + { + double sum = 0; + for (int i = 0; i < m; i++) + sum += fabs(a[i*n + j]); + + if ((minimum - sum) > eps || j == 0) { minimum = sum; min_j = j; } + } + + for (int l = min_j+1, del_j = 1; l < min_i*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (min_i+1)*n, del_j = min_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + min_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return min_i * n + min_j; +} + +int t5_solve(double *a, int m, int n) +{ + int max_j = 0; + double maximum = 0; + + for (int j = 0; j < n; j++) + { + double sum = 0; + for (int i = 0; i < m; i++) + if (i != j) + sum += fabs(a[i*n + j]); + + if ((sum - maximum) > DBL_EPSILON * fmax(fabs(maximum), fabs(sum))) { maximum = sum; max_j = j; } + } + + for (int l = max_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + max_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return max_j + 1; +} + +int t6_solve(double *a, int m, int n) +{ + int max_j = 0, mn = (n < m) ? n : m; + double maximum = 0; + + for (int j = 0; j < mn; j++) + { + double sum = 0; + for (int i = 0; i < m; i++) + if (i != j) + sum += fabs(a[i*n + j] - a[j*n + j]); + + if ((sum - maximum) > eps) { maximum = sum; max_j = j; } + } + + for (int l = max_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + max_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return max_j + 1; +} + +int t7_solve(double *a, int m, int n) +{ + int min_j = 0; + double minimum = 0; + double inm = 1./m; + + for (int j = 0; j < n; j++) + { + double sum = 0; + double avg = 0; + for (int k = 0; k < m; k++) avg += a[k*n + j]; + avg *= inm; + + for (int i = 0; i < m; i++) + { + double temp = (a[i*n + j] - avg); + sum += temp * temp; + } + + if ((minimum - sum) > eps || j == 0) { minimum = sum; min_j = j; } + } + + for (int l = min_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return min_j + 1; +} + +int t8_solve(double *a, int m, int n) +{ + const int BS = 30; + int max_i = 0, max_j = 0; + double maximum = 0; + + for (int jj = 0; jj < n; jj += BS) + for (int j = jj; j < jj + BS && j < n; j++) + { + double sum_j = 0; + for (int ii = 0; ii < m; ii += BS) + for (int k = ii; k < ii + BS && k < m; k++) + sum_j += fabs(a[k*n + j]); + + for (int ii = 0; ii < m; ii += BS) + for (int i = ii; i < ii + BS && i < m; i++) + { + double sum_i = 0; + double aij = fabs(a[i*n + j]); + sum_j -= aij; + + if (j == 0) + { + double num = a[i*n]; + for (int kk = 1; kk < n; kk += BS) + for (int k = kk; k < kk + BS && k < n; k++) + sum_i += fabs(a[i*n + k]); + + a[i*n] = copysign(fabs(num) + sum_i, num); + } + else + sum_i = fabs(a[i*n]) - fabs(a[i*n + j]); + + if (((sum_j + sum_i) - maximum) > eps) + maximum = (sum_j + sum_i), max_i = i, max_j = j; + + sum_j += aij; + } + } + + if (max_j != 0) + for (int ii = 0; ii < m; ii += BS) + for (int i = ii; i < ii + BS && i < m; i++) + { + double orig = a[i*n]; + double num = fabs(orig); + + for (int jj = 1; jj < n; jj += BS) + for (int j = jj; j < jj + BS && j < n; j++) + num -= fabs(a[i*n + j]); + + a[i*n] = copysign(num, orig); + } + + for (int l = max_j+1, del_j = 1; l < max_i*n; l++) + { + if (l == ((n * del_j) + max_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (max_i+1)*n, del_j = max_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + max_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return max_i * n + max_j; +} + +int t9_solve(double *a, int m, int n) +{ + const int BS = 32; + int max_i = 0, max_j = 0; + double maximum = 0; + + for (int jj = 0; jj < n; jj += BS) + for (int ii = 0; ii < m; ii += BS) + for (int j = jj; j < jj + BS && j < n; j++) + for (int i = ii; i < ii + BS && i < m; i++) + { + double sum_i = 0; + double sum_j = 0; + double aij = a[i*n + j]; + + for (int kk = 0; kk < n; kk += BS) + for (int k = kk; k < kk + BS && k < n; k++) if (k != j) + sum_i += fabs(a[i*n + k] - aij); + + for (int kk = 0; kk < m; kk += BS) + for (int k = kk; k < kk + BS && k < m; k++) if (i != k) + sum_j += fabs(a[k*n + j] - aij); + + if (((sum_j + sum_i) - maximum) > eps) + maximum = (sum_j + sum_i), max_i = i, max_j = j; + } + + for (int l = max_j+1, del_j = 1; l < max_i*n; l++) + { + if (l == ((n * del_j) + max_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (max_i+1)*n, del_j = max_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + max_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return max_i * n + max_j; +} + +int t10_solve(double *a, int m, int n) +{ + const int BS = 30; + int min_i = 0, min_j = 0; + double minimum = (m*n > 0) ? DBL_MAX : 0; + double inn = 1./n, inm = 1./m; + + for (int ii = 0; ii < m; ii += BS) + for (int i = ii; i < ii + BS && i < m; i++) + { + double cur = 0; + double sum = 0; + double sq_sum = 0; + for (int jj = 0; jj < n; jj += BS) + for (int j = jj; j < jj + BS && j < n; j++) + { + double temp = a[i*n + j]; + sum += temp; + sq_sum += temp * temp; + } + + cur = sq_sum - (sum * sum) * inn; + if ((minimum - cur) > DBL_EPSILON * fmax(fabs(minimum), fabs(cur))) { + minimum = cur; + min_i = i; + } + } + + minimum = (m*n > 0) ? DBL_MAX : 0; + + for (int jj = 0; jj < n; jj += BS) + for (int j = jj; j < jj + BS && j < n; j++) + { + double cur = 0; + double sum = 0; + double sq_sum = 0; + + for (int ii = 0; ii < m; ii += BS) + for (int i = ii; i < ii + BS && i < m; i++) + { + double temp = a[i*n + j]; + sum += temp; + sq_sum += temp * temp; + } + + cur = sq_sum - (sum * sum) * inm; + if ((minimum - cur) > DBL_EPSILON * fmax(fabs(minimum), fabs(cur))) { + minimum = cur; + min_j = j; + } + } + + for (int l = min_j+1, del_j = 1; l < min_i*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (min_i+1)*n, del_j = min_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + min_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return min_i * n + min_j; +} diff --git a/2025.03.21/dist/Linux/solve.h b/2025.03.21/dist/Linux/solve.h new file mode 100644 index 0000000..91d3f0a --- /dev/null +++ b/2025.03.21/dist/Linux/solve.h @@ -0,0 +1,15 @@ +#ifndef SOLVE_H +#define SOLVE_H + +int t1_solve(double *a, int m, int n); +int t2_solve(double *a, int m, int n); +int t3_solve(double *a, int m, int n); +int t4_solve(double *a, int m, int n); +int t5_solve(double *a, int m, int n); +int t6_solve(double *a, int m, int n); +int t7_solve(double *a, int m, int n); +int t8_solve(double *a, int m, int n); +int t9_solve(double *a, int m, int n); +int t10_solve(double *a, int m, int n); + +#endif diff --git a/2025.03.21/dist/Matvei/Makefile b/2025.03.21/dist/Matvei/Makefile new file mode 100644 index 0000000..8204905 --- /dev/null +++ b/2025.03.21/dist/Matvei/Makefile @@ -0,0 +1,14 @@ +FLAGS = -fstack-protector-all -W -Wall -Wextra -Wunused -Wcast-align -Werror -pedantic -pedantic-errors -Wfloat-equal -Wpointer-arith -Wformat-security -Wmissing-format-attribute -Wformat=1 -Wwrite-strings -Wcast-align -Wno-long-long -std=gnu99 -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wold-style-definition -Wdeclaration-after-statement -Wbad-function-cast -Wnested-externs -O3 + +%.exe: %.o array.o comparison.o + gcc $(FLAGS) $^ -o $@ -lm +%.o: %.c + gcc -c $(FLAGS) $< + +all: a01.exe a02.exe a03.exe a04.exe a05.exe a06.exe a07.exe a08.exe a09.exe a10.exe + +array.o: array.c array.h +comparison.o: comparison.c comparison.h + +clean: + del *.o *.exe diff --git a/2025.03.21/dist/Matvei/a01.c b/2025.03.21/dist/Matvei/a01.c new file mode 100644 index 0000000..85542d4 --- /dev/null +++ b/2025.03.21/dist/Matvei/a01.c @@ -0,0 +1,98 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve1(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 1; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve1(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve1(double* a, int m, int n) + { + int i, j, ind_min_j = 0; + double modul, min; + int l = 0; + if ((m == 0) || (n == 0)) return 0; + min = fabs(a[0]); + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + modul = fabs(a[i * n + j]); + if (modul < min) + { + min = modul; + ind_min_j = j; + } + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if (j != ind_min_j) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_min_j + 1; + } diff --git a/2025.03.21/dist/Matvei/a02.c b/2025.03.21/dist/Matvei/a02.c new file mode 100644 index 0000000..4d2b23f --- /dev/null +++ b/2025.03.21/dist/Matvei/a02.c @@ -0,0 +1,99 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve2(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 2; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve2(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve2(double* a, int m, int n) + { + int i, j, ind_min_i = 0, ind_min_j = 0; + double modul, min; + int l = 0; + if ((m == 0) || (n == 0)) return 0; + min = fabs(a[0]); + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + modul = fabs(a[i * n + j]); + if (modul < min) + { + min = modul; + ind_min_i = i; + ind_min_j = j; + } + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if ((j != ind_min_j) && (i != ind_min_i)) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_min_i * n + ind_min_j; + } diff --git a/2025.03.21/dist/Matvei/a03.c b/2025.03.21/dist/Matvei/a03.c new file mode 100644 index 0000000..7069eea --- /dev/null +++ b/2025.03.21/dist/Matvei/a03.c @@ -0,0 +1,97 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve3(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 3; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve3(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve3(double* a, int m, int n) + { + int i, j, ind_min_j = 0; + double min, sum = 0; + int l = 0; + if ((m == 0) && (n == 0)) return 0; + for (i = 0; i < m; i++) sum += fabs(a[i * n + 0]); + min = sum; + for (j = 1; j < n; j++) + { + sum = 0; + for (i = 0; i < m; i++) sum += fabs(a[i * n + j]); + if (sum < min) + { + min = sum; + ind_min_j = j; + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if (j != ind_min_j) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_min_j + 1; + } diff --git a/2025.03.21/dist/Matvei/a04.c b/2025.03.21/dist/Matvei/a04.c new file mode 100644 index 0000000..c8124f9 --- /dev/null +++ b/2025.03.21/dist/Matvei/a04.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve4(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 4; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve4(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve4(double* a, int m, int n) + { + int i, j, ind_min_i = 0, ind_min_j = 0; + double sum = 0, minstr, minstl; + int l = 0; + if ((m == 0) || (n == 0)) return 0; + for (i = 0; i < m; i++) sum += fabs(a[i * n + 0]); + minstl = sum; + for (j = 1; j < n; j++) + { + sum = 0; + for (i = 0; i < m; i++) sum += fabs(a[i * n + j]); + if (sum < minstl) + { + minstl = sum; + ind_min_j = j; + } + } + sum = 0; + for (j = 0; j < n; j++) sum += fabs(a[0 * n + j]); + minstr = sum; + for (i = 1; i < m; i++) + { + sum = 0; + for (j = 0; j < n; j++) sum += fabs(a[i * n + j]); + if (sum < minstr) + { + minstr = sum; + ind_min_i = i; + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if ((j != ind_min_j) && (i != ind_min_i)) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_min_i * n + ind_min_j; + } diff --git a/2025.03.21/dist/Matvei/a05.c b/2025.03.21/dist/Matvei/a05.c new file mode 100644 index 0000000..745404c --- /dev/null +++ b/2025.03.21/dist/Matvei/a05.c @@ -0,0 +1,98 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve5(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 5; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve5(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve5(double* a, int m, int n) + { + int i, j, ind_max_j = 0; + double max = 0, sum = 0; + int l = 0; + if ((m == 0) && (n == 0)) return 0; + for (j = 0; j < n; j++) + { + sum = 0; + for (i = 0; i < m; i++) + { + if (i != j) sum += fabs(a[i * n + j]); + } + if (sum > max) + { + max = sum; + ind_max_j = j; + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if (j != ind_max_j) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_max_j + 1; + } diff --git a/2025.03.21/dist/Matvei/a06.c b/2025.03.21/dist/Matvei/a06.c new file mode 100644 index 0000000..339039e --- /dev/null +++ b/2025.03.21/dist/Matvei/a06.c @@ -0,0 +1,99 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve6(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 6; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve6(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve6(double* a, int m, int n) + { + int i, j, ind_max_j = 0, min_mn = (m < n ? m : n); + double diag, max = 0, sum = 0; + int l = 0; + if ((m == 0) && (n == 0)) return 0; + for (j = 0; j < min_mn; j++) + { + diag = a[j * n + j]; + sum = 0; + for (i = 0; i < m; i++) + { + if (i != j) sum += fabs(a[i * n + j] - diag); + } + if (sum > max) + { + max = sum; + ind_max_j = j; + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if (j != ind_max_j) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_max_j + 1; + } diff --git a/2025.03.21/dist/Matvei/a07.c b/2025.03.21/dist/Matvei/a07.c new file mode 100644 index 0000000..b554a60 --- /dev/null +++ b/2025.03.21/dist/Matvei/a07.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve7(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 7; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve7(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve7(double* a, int m, int n) + { + int i, j, ind_min_j = 0; + double slag, min, sum = 0, sr_sum = 0; + int l = 0; + if ((m == 0) && (n == 0)) return 0; + for (i = 0; i < m; i++) sr_sum += a[i * n + 0]; + sr_sum /= m; + for (i = 0; i < m; i++) + { + slag = a[i * n + 0]; + sum += (slag - sr_sum) * (slag - sr_sum); + } + min = sum; + for (j = 1; j < n; j++) + { + sr_sum = 0; + sum = 0; + for (i = 0; i < m; i++) sr_sum += a[i * n + j]; + sr_sum /= m; + for (i = 0; i < m; i++) + { + slag = a[i * n + j]; + sum += (slag - sr_sum) * (slag - sr_sum); + } + if (sum < min) + { + min = sum; + ind_min_j = j; + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if (j != ind_min_j) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_min_j + 1; + } diff --git a/2025.03.21/dist/Matvei/a08.c b/2025.03.21/dist/Matvei/a08.c new file mode 100644 index 0000000..4f32f09 --- /dev/null +++ b/2025.03.21/dist/Matvei/a08.c @@ -0,0 +1,105 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve8(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 8; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve8(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve8(double* a, int m, int n) + { + int i, j, k, ind_max_i = 0, ind_max_j = 0; + double sumstr = 0, sum, max = 0; + int l = 0; + if ((m == 0) || (n == 0)) return 0; + for (i = 0; i < m; i++) + { + sumstr = 0; + for (j = 0; j < n; j++) sumstr += fabs(a[i * n + j]); + for (j = 0; j < n; j++) + { + sum = sumstr; + for (k = 0; k < m; k++) + { + if (k == i) sum -= fabs(a[k * n + j]); + else sum += fabs(a[k * n + j]); + } + if (sum > max) + { + max = sum; + ind_max_i = i; + ind_max_j = j; + } + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if ((j != ind_max_j) && (i != ind_max_i)) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_max_i * n + ind_max_j; + } diff --git a/2025.03.21/dist/Matvei/a09.c b/2025.03.21/dist/Matvei/a09.c new file mode 100644 index 0000000..fb2b0d5 --- /dev/null +++ b/2025.03.21/dist/Matvei/a09.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve9(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 9; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve9(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve9(double* a, int m, int n) + { + int i, j, k, ind_max_i = 0, ind_max_j = 0; + double el, sumstl, sumstr, sum, max = 0; + int l = 0; + if ((m == 0) || (n == 0)) return 0; + for (i = 0; i < m; i++) + { + sumstr = 0; + for (j = 0; j < n; j++) + { + sumstl = 0; + sumstr = 0; + el = a[i * n + j]; + for (k = 0; k < n; k++) + { + if (k != j) sumstr += fabs(a[i * n + k] - el); + } + for (k = 0; k < m; k++) + { + if (k != i) sumstl += fabs(a[k * n + j] - el); + } + sum = sumstl + sumstr; + if (sum > max) + { + max = sum; + ind_max_i = i; + ind_max_j = j; + } + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if ((j != ind_max_j) && (i != ind_max_i)) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_max_i * n + ind_max_j; + } diff --git a/2025.03.21/dist/Matvei/a10.c b/2025.03.21/dist/Matvei/a10.c new file mode 100644 index 0000000..3cc87d0 --- /dev/null +++ b/2025.03.21/dist/Matvei/a10.c @@ -0,0 +1,137 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +int solve10(double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 10; + double* a; + int n, m, p, k; + char* name = 0; + int res; + double t; + if (!((argc == 5 || argc == 6) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k) == 1 && k >= 0 && k <= 4)) + { + printf("Usage: %s m n p k [name]\n", argv[0]); + return 1; + } + if (k == 0) + name = argv[5]; + a = (double*) malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name) + { + io_status ret; + ret = read_matrix(a, m, n, name); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name); + break; + case ERROR_READ: + printf("Can not read file %s\n", name); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, m, n, k); + printf("Matrix:\n"); + print_matrix(a, m, n, p); + t = clock(); + res = solve10(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + free(a); + return 0; + } + +int solve10(double* a, int m, int n) + { + int i, j, ind_min_i = 0, ind_min_j = 0; + double slag, sum = 0, sr_sum = 0, min = 0; + int l = 0; + if ((m == 0) || (n == 0)) return 0; + for (i = 0; i < m; i++) sr_sum += a[i * n + 0]; + sr_sum /= m; + for (i = 0; i < m; i++) + { + slag = a[i * n + 0]; + sum += (slag - sr_sum) * (slag - sr_sum); + } + min = sum; + for (j = 1; j < n; j++) + { + sr_sum = 0; + sum = 0; + for (i = 0; i < m; i++) sr_sum += a[i * n + j]; + sr_sum /= m; + for (i = 0; i < m; i++) + { + slag = a[i * n + j]; + sum += (slag - sr_sum) * (slag - sr_sum); + } + if (sum < min) + { + min = sum; + ind_min_j = j; + } + } + sr_sum = 0; + sum = 0; + for (j = 0; j < n; j++) sr_sum += a[0 * n + j]; + sr_sum /= n; + for (j = 0; j < n; j++) + { + slag = a[0 * n + j]; + sum += (slag - sr_sum) * (slag - sr_sum); + } + min = sum; + for (i = 1; i < m; i++) + { + sr_sum = 0; + sum = 0; + for (j = 0; j < n; j++) sr_sum += a[i * n + j]; + sr_sum /= n; + for (j = 0; j < n; j++) + { + slag = a[i * n + j]; + sum += (slag - sr_sum) * (slag - sr_sum); + } + if (sum < min) + { + min = sum; + ind_min_i = i; + } + } + for (i = 0; i < m; i++) + { + for (j = 0; j < n; j++) + { + if ((j != ind_min_j) && (i != ind_min_i)) + { + a[l] = a[i * n + j]; + l++; + } + } + } + return ind_min_i * n + ind_min_j; + } diff --git a/2025.03.21/dist/Matvei/array.c b/2025.03.21/dist/Matvei/array.c new file mode 100644 index 0000000..b8f4578 --- /dev/null +++ b/2025.03.21/dist/Matvei/array.c @@ -0,0 +1,62 @@ +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "comparison.h" + +io_status read_matrix(double* a, int n, int m, const char* name) + { + int i, j; + FILE* fp; + if (!(fp = fopen(name, "r"))) + return ERROR_OPEN; + for (i = 0; i < n; i++) + { + for (j = 0; j < m; j++) + { + if (fscanf(fp, "%lf", a + i * m + j) != 1) + { + fclose(fp); + return ERROR_READ; + } + } + } + fclose(fp); + return SUCCESS; + } + +void print_matrix(const double* a, int n, int m, int p) + { + int np = (n > p ? p : n); + int mp = (m > p ? p : m); + int i, j; + for (i = 0; i < np; i++) + { + for (j = 0; j < mp; j++) + printf(" %10.3e", a[i * m + j]); + printf("\n"); + } + } + +void init_matrix(double* a, int n, int m, int k) + { + int i, j; + for (i = 0; i < n; i++) + { + for (j = 0; j < m; j++) + a[i * m + j] = f(k, n, m, i+1, j+1); + } + } + +double f(int k, int n, int m, int i, int j) + { + switch (k) + { + case 1: return (n >= m ? n : m) - (i >= j ? i : j) + 1; + case 2: return (i >= j ? i : j); + case 3: return (i - j >= 0 ? i - j : j - i); + case 4: return 1./(i + j - 1); + } + return -1e308; + } diff --git a/2025.03.21/dist/Matvei/array.h b/2025.03.21/dist/Matvei/array.h new file mode 100644 index 0000000..4c2daec --- /dev/null +++ b/2025.03.21/dist/Matvei/array.h @@ -0,0 +1,4 @@ +io_status read_matrix(double*, int, int, const char*); +void print_matrix(const double*, int, int, int); +void init_matrix(double*, int, int, int); +double f(int, int, int, int, int); diff --git a/2025.03.21/dist/Matvei/comparison.c b/2025.03.21/dist/Matvei/comparison.c new file mode 100644 index 0000000..a1ba965 --- /dev/null +++ b/2025.03.21/dist/Matvei/comparison.c @@ -0,0 +1,8 @@ +#include +#include "comparison.h" + +int equal(double a, double b) + { + if (fabs(a - b) <= EPS * fmax(fabs(a), fabs(b))) return 1; + return 0; + } diff --git a/2025.03.21/dist/Matvei/comparison.h b/2025.03.21/dist/Matvei/comparison.h new file mode 100644 index 0000000..fa1f668 --- /dev/null +++ b/2025.03.21/dist/Matvei/comparison.h @@ -0,0 +1,3 @@ +#define EPS (1e-9) + +int equal(double, double); diff --git a/2025.03.21/dist/Matvei/input1.txt b/2025.03.21/dist/Matvei/input1.txt new file mode 100644 index 0000000..b3de1a9 --- /dev/null +++ b/2025.03.21/dist/Matvei/input1.txt @@ -0,0 +1,56 @@ +-6 +5 +-23 +-3 +35 +2 +35 +5 +52 +-5 +34 +4 +-63 +6 +54 +63 +3 +-63 +6 +34 +35 +64 +3 +3 +46 +3 +6 +33 +43 +-6 +4 +2 +5 +22 +-25 +22 +5 +6 +-25 +2 +5 +23 +-5 +-2 +35 +23 +42 +-34 +-2 +52 +54 +-34 +56 +75 +-57 +7 diff --git a/2025.03.21/dist/Matvei/io_status.h b/2025.03.21/dist/Matvei/io_status.h new file mode 100644 index 0000000..4234d9c --- /dev/null +++ b/2025.03.21/dist/Matvei/io_status.h @@ -0,0 +1,6 @@ +typedef enum io_status_ + { + SUCCESS, + ERROR_OPEN, + ERROR_READ, + } io_status; diff --git a/2025.03.21/dist/Matvei/t.txt b/2025.03.21/dist/Matvei/t.txt new file mode 100644 index 0000000..ddb384c --- /dev/null +++ b/2025.03.21/dist/Matvei/t.txt @@ -0,0 +1,3 @@ +1 5 9 +2 6 3 +7 4 8 diff --git a/2025.03.21/dist/Windows/Makefile b/2025.03.21/dist/Windows/Makefile new file mode 100644 index 0000000..84fcdfc --- /dev/null +++ b/2025.03.21/dist/Windows/Makefile @@ -0,0 +1,15 @@ +FLAGS = -fstack-protector-all -W -Wall -Wextra -Wunused -Wcast-align -Werror -pedantic -pedantic-errors -Wfloat-equal -Wpointer-arith -Wformat-security -Wmissing-format-attribute -Wformat=1 -Wwrite-strings -Wcast-align -Wno-long-long -std=gnu99 -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wold-style-definition -Wdeclaration-after-statement -Wbad-function-cast -Wnested-externs -O3 + +%.exe: %.o solve.o array_io.o init_f.o + gcc $(FLAGS) $^ -o $@ -lm +%.o: %.c + gcc -c $(FLAGS) $< + +all: a01.exe a02.exe a03.exe a04.exe a05.exe a06.exe a07.exe a08.exe a09.exe a10.exe + +solve.o: solve.c solve.h +array_io.o: array_io.c array_io.h +init_f.o: init_f.c init_f.h + +clean: + del *.o *.exe diff --git a/2025.03.21/dist/Windows/a.txt b/2025.03.21/dist/Windows/a.txt new file mode 100644 index 0000000..b3de1a9 --- /dev/null +++ b/2025.03.21/dist/Windows/a.txt @@ -0,0 +1,56 @@ +-6 +5 +-23 +-3 +35 +2 +35 +5 +52 +-5 +34 +4 +-63 +6 +54 +63 +3 +-63 +6 +34 +35 +64 +3 +3 +46 +3 +6 +33 +43 +-6 +4 +2 +5 +22 +-25 +22 +5 +6 +-25 +2 +5 +23 +-5 +-2 +35 +23 +42 +-34 +-2 +52 +54 +-34 +56 +75 +-57 +7 diff --git a/2025.03.21/dist/Windows/a01.c b/2025.03.21/dist/Windows/a01.c new file mode 100644 index 0000000..1b5c068 --- /dev/null +++ b/2025.03.21/dist/Windows/a01.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 1; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t1_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a02.c b/2025.03.21/dist/Windows/a02.c new file mode 100644 index 0000000..51d1c6d --- /dev/null +++ b/2025.03.21/dist/Windows/a02.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 2; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t2_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a03.c b/2025.03.21/dist/Windows/a03.c new file mode 100644 index 0000000..ab7dcb7 --- /dev/null +++ b/2025.03.21/dist/Windows/a03.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 3; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t3_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a04.c b/2025.03.21/dist/Windows/a04.c new file mode 100644 index 0000000..3049b78 --- /dev/null +++ b/2025.03.21/dist/Windows/a04.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 4; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t4_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a05.c b/2025.03.21/dist/Windows/a05.c new file mode 100644 index 0000000..585b48a --- /dev/null +++ b/2025.03.21/dist/Windows/a05.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 5; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t5_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a06.c b/2025.03.21/dist/Windows/a06.c new file mode 100644 index 0000000..79e7a8c --- /dev/null +++ b/2025.03.21/dist/Windows/a06.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 6; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t6_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a07.c b/2025.03.21/dist/Windows/a07.c new file mode 100644 index 0000000..1a00e96 --- /dev/null +++ b/2025.03.21/dist/Windows/a07.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 7; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t7_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a08.c b/2025.03.21/dist/Windows/a08.c new file mode 100644 index 0000000..a68a173 --- /dev/null +++ b/2025.03.21/dist/Windows/a08.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 8; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t8_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a09.c b/2025.03.21/dist/Windows/a09.c new file mode 100644 index 0000000..962b852 --- /dev/null +++ b/2025.03.21/dist/Windows/a09.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 9; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t9_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/a10.c b/2025.03.21/dist/Windows/a10.c new file mode 100644 index 0000000..81637d7 --- /dev/null +++ b/2025.03.21/dist/Windows/a10.c @@ -0,0 +1,67 @@ +#include +#include +#include +#include "array_io.h" +#include "io_status.h" +#include "solve.h" + +/* ./a.out m n p k [filename] */ +int main(int argc, char *argv[]) +{ + double t, *a; + int m, n, p, k, res, task = 10; + char *name = 0; + + if (!((argc == 5 || argc == 6) && + sscanf(argv[1], "%d", &m) == 1 && + sscanf(argv[2], "%d", &n) == 1 && + sscanf(argv[3], "%d", &p) == 1 && + sscanf(argv[4], "%d", &k) == 1 && + k >= 0 && k <= 4 && (!(k == 0 && argc != 6)))) + { + printf("Usage: %s m n p k [filename]\n", argv[0]); + return 1; + } + if (argc == 6) name = argv[5]; + + a = (double *)malloc(m * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + + if (name) + { /* из файла */ + io_status ret; + ret = read_matrix(a, m, n, name); + do { + switch (ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Cannot open %s\n", name); + break; + case ERROR_READ: + printf("Cannot read %s\n", name); + } + free(a); + return 3; + } while (0); + } else init_matrix(a, m, n, k); + + printf("Matrix:\n"); + print_matrix(a, m, n, p); + + t = clock(); + res = t10_solve(a, m, n); + t = (clock() - t) / CLOCKS_PER_SEC; + + printf("New matrix:\n"); + print_matrix(a, m - 1, n - 1, p); + printf ("%s : Task = %d Result = %d Elapsed = %.2f\n", argv[0], task, res, t); + + free(a); + return 0; +} diff --git a/2025.03.21/dist/Windows/array_io.c b/2025.03.21/dist/Windows/array_io.c new file mode 100644 index 0000000..6e56ecf --- /dev/null +++ b/2025.03.21/dist/Windows/array_io.c @@ -0,0 +1,40 @@ +#include +#include "array_io.h" + +io_status read_matrix(double *a, int n, int m, const char *name) +{ + int i, j; + FILE *fp; + if (!(fp = fopen(name, "r"))) return ERROR_OPEN; + for (i = 0; i < n; i++) + for (j = 0; j < m; j++) + if (fscanf(fp, "%lf", a + i * m + j) != 1) + {fclose(fp); return ERROR_READ;} + fclose(fp); + return SUCCESS; +} + +void print_matrix(const double *a, int n, int m, int p) +{ + int np = (n > p ? p : n); + int mp = (m > p ? p : m); + int i, j; + + for (i = 0; i < np; i++) + { + for (j = 0; j < mp; j++) + printf(" %10.3e", a[i * m + j]); + printf("\n"); + } +} + +void init_matrix(double *a, int n, int m, int k) +{ + double (*q)(int, int, int, int); + double (*f[])(int, int, int, int) = {f1, f2, f3, f4}; + int i, j; + q = f[k-1]; + for (i = 0; i < n; i++) + for (j = 0; j < m; j++) + a[i * m + j] = q(n, m, i+1, j+1); +} diff --git a/2025.03.21/dist/Windows/array_io.h b/2025.03.21/dist/Windows/array_io.h new file mode 100644 index 0000000..e312a84 --- /dev/null +++ b/2025.03.21/dist/Windows/array_io.h @@ -0,0 +1,11 @@ +#ifndef ARRAY_IO_H +#define ARRAY_IO_H + +#include "io_status.h" +#include "init_f.h" + +io_status read_matrix(double *a, int n, int m, const char *name); +void print_matrix(const double *a, int n, int m, int p); +void init_matrix(double *a, int n, int m, int k); + +#endif diff --git a/2025.03.21/dist/Windows/init_f.c b/2025.03.21/dist/Windows/init_f.c new file mode 100644 index 0000000..925afb5 --- /dev/null +++ b/2025.03.21/dist/Windows/init_f.c @@ -0,0 +1,30 @@ +#include "init_f.h" +#include + +#define MAX(n, m) (n < m ? m : n) + +double f1(int n, int m, int i, int j) +{ + return MAX(n, m) - MAX(i, j) + 1; +} + +double f2(int n, int m, int i, int j) +{ + (void)n; + (void)m; + return MAX(i, j); +} + +double f3(int n, int m, int i, int j) +{ + (void)n; + (void)m; + return abs(i - j); +} + +double f4(int n, int m, int i, int j) +{ + (void)n; + (void)m; + return 1./(i+j-1); +} diff --git a/2025.03.21/dist/Windows/init_f.h b/2025.03.21/dist/Windows/init_f.h new file mode 100644 index 0000000..691aace --- /dev/null +++ b/2025.03.21/dist/Windows/init_f.h @@ -0,0 +1,9 @@ +#ifndef INIT_F_H +#define INIT_F_H + +double f1(int n, int m, int i, int j); +double f2(int n, int m, int i, int j); +double f3(int n, int m, int i, int j); +double f4(int n, int m, int i, int j); + +#endif diff --git a/2025.03.21/dist/Windows/io_status.h b/2025.03.21/dist/Windows/io_status.h new file mode 100644 index 0000000..420a981 --- /dev/null +++ b/2025.03.21/dist/Windows/io_status.h @@ -0,0 +1,13 @@ +#ifndef IO_STATUS_H +#define IO_STATUS_H + +#define LEN 1234 + +typedef enum _io_status +{ + SUCCESS, + ERROR_OPEN, + ERROR_READ +} io_status; + +#endif diff --git a/2025.03.21/dist/Windows/solve.c b/2025.03.21/dist/Windows/solve.c new file mode 100644 index 0000000..d87aa05 --- /dev/null +++ b/2025.03.21/dist/Windows/solve.c @@ -0,0 +1,402 @@ +#include "solve.h" +#include +#include +#include + +#define eps 1e-17 + +int t1_solve(double *a, int m, int n) +{ + int l, min_j = 0, del_j; + double minimum = (m * n > 0) ? DBL_MAX : 0; + + for (int i = 0; i < m; i++) + for (int j = 0; j < n; j++) + { + double temp = fabs(a[i*n + j]); + if (temp < minimum) + { + minimum = temp; + min_j = j; + } + } + + for (l = min_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return min_j + 1; +} + +int t2_solve(double *a, int m, int n) +{ + int min_i = 0, min_j = 0; + double minimum = (m * n > 0) ? fabs(a[0]) : 0; + + for (int i = 0; i < m; i++) + for (int j = 0; j < n; j++) + if ((minimum - fabs(a[i*n + j])) > eps) { minimum = fabs(a[i*n + j]); min_i = i; min_j = j; } + + for (int l = min_j+1, del_j = 1; l < min_i*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (min_i+1)*n, del_j = min_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + min_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return min_i * n + min_j; +} + +int t3_solve(double *a, int m, int n) +{ + int min_j = 0; + double minimum = -1; + + for (int j = 0; j < n; j++) + { + double cur = 0; + for (int i = 0; i < m; i++) + cur += fabs(a[i*n + j]); + if ((minimum - cur) > eps || j == 0) { minimum = cur; min_j = j; } + } + + for (int l = min_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return min_j + 1; +} + +int t4_solve(double *a, int m, int n) +{ + int min_i = 0, min_j = 0; + double minimum = -1; + + for (int i = 0; i < m; i++) + { + double sum = 0; + for (int j = 0; j < n; j++) + sum += fabs(a[i*n + j]); + + if ((minimum - sum) > eps || i == 0) { minimum = sum; min_i = i; } + } + + for (int j = 0; j < n; j++) + { + double sum = 0; + for (int i = 0; i < m; i++) + sum += fabs(a[i*n + j]); + + if ((minimum - sum) > eps || j == 0) { minimum = sum; min_j = j; } + } + + for (int l = min_j+1, del_j = 1; l < min_i*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (min_i+1)*n, del_j = min_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + min_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return min_i * n + min_j; +} + +int t5_solve(double *a, int m, int n) +{ + int max_j = 0; + double maximum = 0; + + for (int j = 0; j < n; j++) + { + double sum = 0; + for (int i = 0; i < m; i++) + if (i != j) + sum += fabs(a[i*n + j]); + + if ((sum - maximum) > DBL_EPSILON * fmax(fabs(maximum), fabs(sum))) { maximum = sum; max_j = j; } + } + + for (int l = max_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + max_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return max_j + 1; +} + +int t6_solve(double *a, int m, int n) +{ + int max_j = 0, mn = (n < m) ? n : m; + double maximum = 0; + + for (int j = 0; j < mn; j++) + { + double sum = 0; + for (int i = 0; i < m; i++) + if (i != j) + sum += fabs(a[i*n + j] - a[j*n + j]); + + if ((sum - maximum) > eps) { maximum = sum; max_j = j; } + } + + for (int l = max_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + max_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return max_j + 1; +} + +int t7_solve(double *a, int m, int n) +{ + int min_j = 0; + double minimum = 0; + double inm = 1./m; + + for (int j = 0; j < n; j++) + { + double sum = 0; + double avg = 0; + for (int k = 0; k < m; k++) avg += a[k*n + j]; + avg *= inm; + + for (int i = 0; i < m; i++) + { + double temp = (a[i*n + j] - avg); + sum += temp * temp; + } + + if ((minimum - sum) > eps || j == 0) { minimum = sum; min_j = j; } + } + + for (int l = min_j+1, del_j = 1; l < m*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + return min_j + 1; +} + +int t8_solve(double *a, int m, int n) +{ + const int BS = 30; + int max_i = 0, max_j = 0; + double maximum = 0; + + for (int jj = 0; jj < n; jj += BS) + for (int j = jj; j < jj + BS && j < n; j++) + { + double sum_j = 0; + for (int ii = 0; ii < m; ii += BS) + for (int k = ii; k < ii + BS && k < m; k++) + sum_j += fabs(a[k*n + j]); + + for (int ii = 0; ii < m; ii += BS) + for (int i = ii; i < ii + BS && i < m; i++) + { + double sum_i = 0; + double aij = fabs(a[i*n + j]); + sum_j -= aij; + + if (j == 0) + { + double num = a[i*n]; + for (int kk = 1; kk < n; kk += BS) + for (int k = kk; k < kk + BS && k < n; k++) + sum_i += fabs(a[i*n + k]); + + a[i*n] = copysign(fabs(num) + sum_i, num); + } + else + sum_i = fabs(a[i*n]) - fabs(a[i*n + j]); + + if (((sum_j + sum_i) - maximum) > eps) + maximum = (sum_j + sum_i), max_i = i, max_j = j; + + sum_j += aij; + } + } + + if (max_j != 0) + for (int ii = 0; ii < m; ii += BS) + for (int i = ii; i < ii + BS && i < m; i++) + { + double orig = a[i*n]; + double num = fabs(orig); + + for (int jj = 1; jj < n; jj += BS) + for (int j = jj; j < jj + BS && j < n; j++) + num -= fabs(a[i*n + j]); + + a[i*n] = copysign(num, orig); + } + + for (int l = max_j+1, del_j = 1; l < max_i*n; l++) + { + if (l == ((n * del_j) + max_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (max_i+1)*n, del_j = max_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + max_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return max_i * n + max_j; +} + +int t9_solve(double *a, int m, int n) +{ + const int BS = 32; + int max_i = 0, max_j = 0; + double maximum = 0; + + for (int jj = 0; jj < n; jj += BS) + for (int ii = 0; ii < m; ii += BS) + for (int j = jj; j < jj + BS && j < n; j++) + for (int i = ii; i < ii + BS && i < m; i++) + { + double sum_i = 0; + double sum_j = 0; + double aij = a[i*n + j]; + + for (int kk = 0; kk < n; kk += BS) + for (int k = kk; k < kk + BS && k < n; k++) if (k != j) + sum_i += fabs(a[i*n + k] - aij); + + for (int kk = 0; kk < m; kk += BS) + for (int k = kk; k < kk + BS && k < m; k++) if (i != k) + sum_j += fabs(a[k*n + j] - aij); + + if (((sum_j + sum_i) - maximum) > eps) + maximum = (sum_j + sum_i), max_i = i, max_j = j; + } + + for (int l = max_j+1, del_j = 1; l < max_i*n; l++) + { + if (l == ((n * del_j) + max_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (max_i+1)*n, del_j = max_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + max_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return max_i * n + max_j; +} + +int t10_solve(double *a, int m, int n) +{ + const int BS = 30; + int min_i = 0, min_j = 0; + double minimum = (m*n > 0) ? DBL_MAX : 0; + double inn = 1./n, inm = 1./m; + + for (int ii = 0; ii < m; ii += BS) + for (int i = ii; i < ii + BS && i < m; i++) + { + double cur = 0; + double sum = 0; + double sq_sum = 0; + for (int jj = 0; jj < n; jj += BS) + for (int j = jj; j < jj + BS && j < n; j++) + { + double temp = a[i*n + j]; + sum += temp; + sq_sum += temp * temp; + } + + cur = sq_sum - (sum * sum) * inn; + if ((minimum - cur) > DBL_EPSILON * fmax(fabs(minimum), fabs(cur))) { + minimum = cur; + min_i = i; + } + } + + minimum = (m*n > 0) ? DBL_MAX : 0; + + for (int jj = 0; jj < n; jj += BS) + for (int j = jj; j < jj + BS && j < n; j++) + { + double cur = 0; + double sum = 0; + double sq_sum = 0; + + for (int ii = 0; ii < m; ii += BS) + for (int i = ii; i < ii + BS && i < m; i++) + { + double temp = a[i*n + j]; + sum += temp; + sq_sum += temp * temp; + } + + cur = sq_sum - (sum * sum) * inm; + if ((minimum - cur) > DBL_EPSILON * fmax(fabs(minimum), fabs(cur))) { + minimum = cur; + min_j = j; + } + } + + for (int l = min_j+1, del_j = 1; l < min_i*n; l++) + { + if (l == ((n * del_j) + min_j)) + del_j++; + else + a[l - del_j] = a[l]; + } + + for (int l = (min_i+1)*n, del_j = min_i; l < m*n; l++) + { + if (l == ((n * (del_j + 1)) + min_j)) + del_j++; + else + a[l - del_j - n] = a[l]; + } + + return min_i * n + min_j; +} diff --git a/2025.03.21/dist/Windows/solve.h b/2025.03.21/dist/Windows/solve.h new file mode 100644 index 0000000..91d3f0a --- /dev/null +++ b/2025.03.21/dist/Windows/solve.h @@ -0,0 +1,15 @@ +#ifndef SOLVE_H +#define SOLVE_H + +int t1_solve(double *a, int m, int n); +int t2_solve(double *a, int m, int n); +int t3_solve(double *a, int m, int n); +int t4_solve(double *a, int m, int n); +int t5_solve(double *a, int m, int n); +int t6_solve(double *a, int m, int n); +int t7_solve(double *a, int m, int n); +int t8_solve(double *a, int m, int n); +int t9_solve(double *a, int m, int n); +int t10_solve(double *a, int m, int n); + +#endif diff --git a/2025.03.21/dist/Windows/tests.txt b/2025.03.21/dist/Windows/tests.txt new file mode 100644 index 0000000..db9da9f --- /dev/null +++ b/2025.03.21/dist/Windows/tests.txt @@ -0,0 +1,5 @@ +-6 5 -23 -3 + 35 2 35 5 + 52 -5 34 4 + -63 6 54 63 + 3 -63 6 34 diff --git a/2025.03.28/dist/Ulyanov/Makefile b/2025.03.28/dist/Ulyanov/Makefile new file mode 100644 index 0000000..a6677ef --- /dev/null +++ b/2025.03.28/dist/Ulyanov/Makefile @@ -0,0 +1,20 @@ +FLAGS = -mfpmath=sse -fstack-protector-all -W -Wall -Wextra -Wunused -Wcast-align -Werror -pedantic -pedantic-errors -Wfloat-equal -Wpointer-arith -Wformat-security -Wmissing-format-attribute -Wformat=1 -Wwrite-strings -Wcast-align -Wno-long-long -std=gnu99 -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wold-style-definition -Wdeclaration-after-statement -Wbad-function-cast -Wnested-externs -Wmaybe-uninitialized -O3 +all: a01.out a02.out a03.out +a01.out: a01.o array.o matrix.o + gcc a01.o array.o matrix.o -lm -o a01.out +a02.out: a02.o array.o matrix.o + gcc a02.o array.o matrix.o -lm -o a02.out +a03.out: a03.o array.o matrix.o + gcc a03.o array.o matrix.o -lm -o a03.out +array.o: + gcc -c $(FLAGS) -o array.o array.c +matrix.o: + gcc -c $(FLAGS) -o matrix.o matrix.c +a01.o: + gcc -c $(FLAGS) -o a01.o task01.c +a02.o: + gcc -c $(FLAGS) -o a02.o task02.c +a03.o: + gcc -c $(FLAGS) -o a03.o task03.c +clean: + rm -f *.o *.out diff --git a/2025.03.28/dist/Ulyanov/array.c b/2025.03.28/dist/Ulyanov/array.c new file mode 100644 index 0000000..e468ec3 --- /dev/null +++ b/2025.03.28/dist/Ulyanov/array.c @@ -0,0 +1,74 @@ +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "matrix.h" + +io_status read_matrix(double* a, int n, int m, const char* name) + { + int i, j; + FILE* fp; + if (!(fp = fopen(name, "r"))) + return ERROR_OPEN; + for (i = 0; i < n; i++) + { + for (j = 0; j < m; j++) + { + if (fscanf(fp, "%lf", a + i * m + j) != 1) + { + fclose(fp); + return ERROR_READ; + } + } + } + fclose(fp); + return SUCCESS; + } + +void print_matrix(const double* a, int n, int m, int p) + { + int np = (n > p ? p : n); + int mp = (m > p ? p : m); + int i, j; + for (i = 0; i < np; i++) + { + for (j = 0; j < mp; j++) + printf(" %10.3e", a[i * m + j]); + printf("\n"); + } + } + +void init_matrix(double* a, int n, int m, int k) + { + int i, j; + for (i = 0; i < n; i++) + { + for (j = 0; j < m; j++) + a[i * m + j] = f(k, n, m, i+1, j+1); + } + } + +double f(int k, int n, int m, int i, int j) + { + switch (k) + { + case 1: return (n >= m ? n : m) - (i >= j ? i : j) + 1; + case 2: return (i >= j ? i : j); + case 3: return (i - j >= 0 ? i - j : j - i); + case 4: return 1./(i + j - 1); + } + return -1e308; + } + +void init_vector(double* b, double* a, int n) + { + int i, k; + double sum; + for (i = 0; i < n; i++) + { + sum = 0; + for (k = 1; k < n; k += 2) sum += a[i * n + k]; + b[i] = sum; + } + } diff --git a/2025.03.28/dist/Ulyanov/array.h b/2025.03.28/dist/Ulyanov/array.h new file mode 100644 index 0000000..e626337 --- /dev/null +++ b/2025.03.28/dist/Ulyanov/array.h @@ -0,0 +1,5 @@ +io_status read_matrix(double*, int, int, const char*); +void print_matrix(const double*, int, int, int); +void init_matrix(double*, int, int, int); +double f(int, int, int, int, int); +void init_vector(double*, double*, int); diff --git a/2025.03.28/dist/Ulyanov/io_status.h b/2025.03.28/dist/Ulyanov/io_status.h new file mode 100644 index 0000000..4234d9c --- /dev/null +++ b/2025.03.28/dist/Ulyanov/io_status.h @@ -0,0 +1,6 @@ +typedef enum io_status_ + { + SUCCESS, + ERROR_OPEN, + ERROR_READ, + } io_status; diff --git a/2025.03.28/dist/Ulyanov/matrix.c b/2025.03.28/dist/Ulyanov/matrix.c new file mode 100644 index 0000000..5e22a00 --- /dev/null +++ b/2025.03.28/dist/Ulyanov/matrix.c @@ -0,0 +1,99 @@ +#include +#include +#include +#include "matrix.h" + +void multmatvec(double* a, double* x1, double* x2, int n) + { + int i, j; + double sum; + for (i = 0; i < n; i++) + { + sum = 0; + for (j = 0; j < n; j++) + sum += a[i * n+ j] * x1[j]; + x2[i] = sum; + } + } + +double scalp(double* a, double* b, int n) + { + int i; + double mult = 0; + for (i = 0; i < n; i++) mult += a[i] * b[i]; + return mult; + } + +double count_task1(double* a, double* x, double r1, int n) + { + int i, j; + double mltd_el_x, sum, modsum1 = 0, modsum2 = 0; + for (i = 0; i < n; i++) + { + sum = 0; + for (j = 0; j < n; j++) sum += a[i * n + j] * x[j]; + mltd_el_x = r1 * x[i]; + modsum1 += fabs(sum - mltd_el_x); + modsum2 += fabs(mltd_el_x); + } + return modsum1 / modsum2; + } + +double count_r1(double* a, double* b, double* x, int n) + { + int i, j; + double el_b, sum, modsum1 = 0, modsum2 = 0; + for (i = 0; i < n; i++) + { + sum = 0; + for (j = 0; j < n; j++) sum += a[i * n + j] * x[j]; + el_b = b[i]; + modsum1 = fabs(sum - el_b); + modsum2 = fabs(el_b); + } + return modsum1 / modsum2; + } + +double count_r2(double* x, int n) + { + int i; + double modsum = 0; + int ost, sum = 0; + for (i = 0; i < n; i++) + { + ost = (i + 1) % 2; + modsum += fabs(x[i] - ost); + sum += ost; + } + return modsum / sum; + } + +void vecdiff(double* a, double* b, int n) + { + int i; + for (i = 0; i < n; i++) a[i] -= b[i]; + } + +void vecmult(double* a, double lambda, int n) + { + int i; + for (i = 0; i < n; i++) a[i] = lambda * a[i]; + } + +void veccpy(double* a, double* b, int n) + { + int i; + for (i = 0; i < n; i++) a[i] = b[i]; + } + +void veccomb(double lambda, double* a, double myu, double* b, int n) + { + int i; + for (i = 0; i < n; i++) a[i] = lambda * a[i] + myu * b[i]; + } + +int equal(double a, double b) + { + if (fabs(a - b) <= EPS * fmax(fabs(a), fabs(b))) return 1; + return 0; + } diff --git a/2025.03.28/dist/Ulyanov/matrix.h b/2025.03.28/dist/Ulyanov/matrix.h new file mode 100644 index 0000000..bc71ea1 --- /dev/null +++ b/2025.03.28/dist/Ulyanov/matrix.h @@ -0,0 +1,12 @@ +#define EPS (1e-9) + +void multmatvec(double*, double*, double*, int); +double scalp(double*, double*, int); +void vecdiff(double*, double*, int); +void vecmult(double*, double, int); +void veccpy(double*, double*, int); +void veccomb(double, double*, double, double*, int); +double count_task1(double*, double*, double, int); +double count_r1(double*, double*, double*, int); +double count_r2(double*, int); +int equal(double, double); diff --git a/2025.03.28/dist/Ulyanov/task01.c b/2025.03.28/dist/Ulyanov/task01.c new file mode 100644 index 0000000..3aa68d8 --- /dev/null +++ b/2025.03.28/dist/Ulyanov/task01.c @@ -0,0 +1,152 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "matrix.h" + +double solve1(double*, double*, double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 1; + double* a; + double* x0; + double* x; + int n, m, p, k1, k2; + char* name1 = 0; + char* name2 = 0; + double r1, r2; + double t; + if (!((argc == 6 || argc == 7 || argc == 8) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k1) == 1 && k1 >= 0 && k1 <= 4)) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + if (k1 == 0) + { + if (!(sscanf(argv[6], "%d", &k2) == 1) && k2 >= 0 && k2 <= 4) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + name1 = argv[5]; + } + else + { + if (!(sscanf(argv[5], "%d", &k2) == 1) && k2 >= 0 && k2 <= 4) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + } + if (k2 == 0) + { + if (k1 == 0) name2 = argv[7]; + else name2 = argv[6]; + } + a = (double*) malloc(n * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name1) + { + io_status ret; + ret = read_matrix(a, n, n, name1); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name1); + break; + case ERROR_READ: + printf("Can not read file %s\n", name1); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, n, n, k1); + x0 = (double*) malloc(n * sizeof(double)); + if (!x0) + { + printf("Not enough memory\n"); + free(a); + return 2; + } + x = (double*) malloc(n * sizeof(double)); + if (!x) + { + printf("Not enough memory\n"); + free(a); + free(x0); + return 2; + } + if (name2) + { + io_status ret; + ret = read_matrix(x0, n, 1, name2); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name2); + break; + case ERROR_READ: + printf("Can not read file %s\n", name2); + break; + } + free(a); + free(x0); + free(x); + return 3; + } while (0); + } + else + init_matrix(x0, n, 1, k2); + printf("Matrix:\n"); + print_matrix(a, n, n, p); + printf("Vector:\n"); + print_matrix(x0, n, 1, p); + t = clock(); + r1 = solve1(a, x0, x, n, m); + t = (clock() - t) / CLOCKS_PER_SEC; + r2 = count_task1(a, x, r1, n); + + printf("Vector x:\n"); + if (m % 2) + print_matrix(x, 1, n, p); + else + print_matrix(x0, 1, n, p); + printf ("%s : Task = %d Res1 = %e Res2 = %e Elapsed = %.2f\n", argv[0], task, r1, r2, t); + free(a); + free(x0); + free(x); + return 0; + } + +double solve1(double* a, double* x0, double* x, int n, int m) + { + int k; + double lambda; + if (m <= 0) return 0; + for (k = 0; k <= m; k++) + { + if (k % 2) multmatvec(a, x, x0, n); + else multmatvec(a, x0, x, n); + } + if (m % 2) lambda = scalp(x0, x, n) / scalp(x, x, n); + else lambda = scalp(x, x0, n) / scalp(x0, x0, n); + return lambda; + } diff --git a/2025.03.28/dist/Ulyanov/task02.c b/2025.03.28/dist/Ulyanov/task02.c new file mode 100644 index 0000000..00364cd --- /dev/null +++ b/2025.03.28/dist/Ulyanov/task02.c @@ -0,0 +1,163 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "matrix.h" + +void solve2(double*, double*, double*, double*, int, int, double); + +int main(int argc, char* argv[]) + { + int task = 2; + double* a; + double* x0; + double* x; + double* b; + int n, m, p, k1, k2; + char* name1 = 0; + char* name2 = 0; + double tau; + double r1, r2; + double t; + if (!((argc == 7 || argc == 8 || argc == 9) && sscanf(argv[1], "%lf", &tau) == 1 && sscanf(argv[2], "%d", &m) == 1 && sscanf(argv[3], "%d", &n) == 1 && sscanf(argv[4], "%d", &p) == 1 && sscanf(argv[5], "%d", &k1) == 1 && k1 >= 0 && k1 <= 4)) + { + printf("Usage: %s tau n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + if (k1 == 0) + { + if (!(sscanf(argv[7], "%d", &k2) == 1) && k2 >= 0 && k2 <= 4) + { + printf("Usage: %s tau n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + name1 = argv[6]; + } + else + { + if (!(sscanf(argv[6], "%d", &k2) == 1) && k2 >= 0 && k2 <= 4) + { + printf("Usage: %s tau n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + } + if (k2 == 0) + { + if (k1 == 0) name2 = argv[8]; + else name2 = argv[7]; + } + a = (double*) malloc(n * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name1) + { + io_status ret; + ret = read_matrix(a, n, n, name1); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name1); + break; + case ERROR_READ: + printf("Can not read file %s\n", name1); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, n, n, k1); + x0 = (double*) malloc(n * sizeof(double)); + if (!x0) + { + printf("Not enough memory\n"); + free(a); + return 2; + } + x = (double*) malloc(n * sizeof(double)); + if (!x) + { + printf("Not enough memory\n"); + free(a); + free(x0); + return 2; + } + b = (double*) malloc(n * sizeof(double)); + if (!b) + { + printf("Not enough memory\n"); + free(a); + free(x0); + free(x); + return 2; + } + if (name2) + { + io_status ret; + ret = read_matrix(x0, n, 1, name2); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name2); + break; + case ERROR_READ: + printf("Can not read file %s\n", name2); + break; + } + free(a); + free(x0); + free(x); + free(b); + return 3; + } while (0); + } + else + init_matrix(x0, n, 1, k2); + init_vector(b, a, n); + printf("Matrix:\n"); + print_matrix(a, n, n, p); + printf("Vector:\n"); + print_matrix(x0, 1, n, p); + printf("Vector b:\n"); + print_matrix(b, 1, n, p); + t = clock(); + solve2(a, x0, x, b, n, m, tau); + t = (clock() - t) / CLOCKS_PER_SEC; + r1 = count_r1(a, b, x, n); + r2 = count_r2(x, n); + printf("New vector:\n"); + print_matrix(x, n, 1, p); + printf ("%s : Task = %d Res1 = %e Res2 = %e Elapsed = %.2f\n", argv[0], task, r1, r2, t); + free(a); + free(x0); + free(x); + free(b); + return 0; + } + +void solve2(double* a, double* x0, double* x, double* b, int n, int m, double tau) + { + int k; + veccpy(x, x0, n); + for (k = 1; k <= m; k++) + { + multmatvec(a, x, x0, n); + vecdiff(x0, b, n); + vecmult(x0, tau, n); + vecdiff(x, x0, n); + } + } diff --git a/2025.03.28/dist/Ulyanov/task03.c b/2025.03.28/dist/Ulyanov/task03.c new file mode 100644 index 0000000..75dd7ef --- /dev/null +++ b/2025.03.28/dist/Ulyanov/task03.c @@ -0,0 +1,180 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "matrix.h" + +void solve3(double*, double*, double*, double*, double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 3; + double* a; + double* x0; + double* x; + double* b; + double* r; + int n, m, p, k1, k2; + char* name1 = 0; + char* name2 = 0; + double r1, r2; + double t; + if (!((argc == 6 || argc == 7 || argc == 8) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k1) == 1 && k1 >= 0 && k1 <= 4)) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + if (k1 == 0) + { + if (!(sscanf(argv[6], "%d", &k2) == 1) && k2 >= 0 && k2 <= 4) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + name1 = argv[5]; + } + else + { + if (!(sscanf(argv[5], "%d", &k2) == 1) && k2 >= 0 && k2 <= 4) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + } + if (k2 == 0) + { + if (k1 == 0) name2 = argv[7]; + else name2 = argv[6]; + } + a = (double*) malloc(n * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name1) + { + io_status ret; + ret = read_matrix(a, n, n, name1); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name1); + break; + case ERROR_READ: + printf("Can not read file %s\n", name1); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, n, n, k1); + x0 = (double*) malloc(n * sizeof(double)); + if (!x0) + { + printf("Not enough memory\n"); + free(a); + return 2; + } + x = (double*) malloc(n * sizeof(double)); + if (!x) + { + printf("Not enough memory\n"); + free(a); + free(x0); + return 2; + } + b = (double*) malloc(n * sizeof(double)); + if (!b) + { + printf("Not enough memory\n"); + free(a); + free(x0); + free(x); + return 2; + } + r = (double*) malloc(n * sizeof(double)); + if (!r) + { + printf("Not enough memory\n"); + free(a); + free(x0); + free(x); + free(b); + return 2; + } + if (name2) + { + io_status ret; + ret = read_matrix(x0, n, 1, name2); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name2); + break; + case ERROR_READ: + printf("Can not read file %s\n", name2); + break; + } + free(a); + free(x0); + free(x); + free(b); + free(r); + return 3; + } while (0); + } + else + init_matrix(x0, n, 1, k2); + init_vector(b, a, n); + printf("Matrix:\n"); + print_matrix(a, n, n, p); + printf("Vector:\n"); + print_matrix(x0, n, 1, p); + printf("Vector b:\n"); + print_matrix(b, n, 1, p); + t = clock(); + solve3(a, x0, x, b, r, n, m); + t = (clock() - t) / CLOCKS_PER_SEC; + r1 = count_r1(a, b, x, n); + r2 = count_r2(x, n); + printf("New vector:\n"); + print_matrix(x, n, 1, p); + printf("%s : Task = %d Res1 = %e Res2 = %e Elapsed = %.2f\n", argv[0], task, r1, r2, t); + free(a); + free(x0); + free(x); + free(b); + free(r); + return 0; + } + +void solve3(double* a, double* x0, double* x, double* b, double* r, int n, int m) + { + int k; + double tau, scalp2; + veccpy(x, x0, n); + multmatvec(a, x, r, n); + vecdiff(r, b, n); + for (k = 1; k <= m; k++) + { + multmatvec(a, r, x0, n); + scalp2 = scalp(x0, r, n); + if (!equal(scalp2, 0)) tau = scalp(r, r, n) / scalp2; + else break; + veccomb(1, x, -tau, r, n); + veccomb(1, r, -tau, x0, n); + } + } diff --git a/2025.03.28/dist/Ulyanov/task04.c b/2025.03.28/dist/Ulyanov/task04.c new file mode 100644 index 0000000..7344dde --- /dev/null +++ b/2025.03.28/dist/Ulyanov/task04.c @@ -0,0 +1,180 @@ +#include +#include +#include +#include +#include "io_status.h" +#include "array.h" +#include "matrix.h" + +void solve4(double*, double*, double*, double*, double*, int, int); + +int main(int argc, char* argv[]) + { + int task = 4; + double* a; + double* x0; + double* x; + double* b; + double* r; + int n, m, p, k1, k2; + char* name1 = 0; + char* name2 = 0; + double r1, r2; + double t; + if (!((argc == 6 || argc == 7 || argc == 8) && sscanf(argv[1], "%d", &m) == 1 && sscanf(argv[2], "%d", &n) == 1 && sscanf(argv[3], "%d", &p) == 1 && sscanf(argv[4], "%d", &k1) == 1 && k1 >= 0 && k1 <= 4)) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + if (k1 == 0) + { + if (!(sscanf(argv[6], "%d", &k2) == 1) && k2 >= 0 && k2 <= 4) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + name1 = argv[5]; + } + else + { + if (!(sscanf(argv[5], "%d", &k2) == 1) && k2 >= 0 && k2 <= 4) + { + printf("Usage: %s n m p k1 [file1] k2 [file2]\n", argv[0]); + return 1; + } + } + if (k2 == 0) + { + if (k1 == 0) name2 = argv[7]; + else name2 = argv[6]; + } + a = (double*) malloc(n * n * sizeof(double)); + if (!a) + { + printf("Not enough memory\n"); + return 2; + } + if (name1) + { + io_status ret; + ret = read_matrix(a, n, n, name1); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name1); + break; + case ERROR_READ: + printf("Can not read file %s\n", name1); + break; + } + free(a); + return 3; + } while (0); + } + else + init_matrix(a, n, n, k1); + x0 = (double*) malloc(n * sizeof(double)); + if (!x0) + { + printf("Not enough memory\n"); + free(a); + return 2; + } + x = (double*) malloc(n * sizeof(double)); + if (!x) + { + printf("Not enough memory\n"); + free(a); + free(x0); + return 2; + } + b = (double*) malloc(n * sizeof(double)); + if (!b) + { + printf("Not enough memory\n"); + free(a); + free(x0); + free(x); + return 2; + } + r = (double*) malloc(n * sizeof(double)); + if (!r) + { + printf("Not enough memory\n"); + free(a); + free(x0); + free(x); + free(b); + return 2; + } + if (name2) + { + io_status ret; + ret = read_matrix(x0, n, 1, name2); + do + { + switch(ret) + { + case SUCCESS: + continue; + case ERROR_OPEN: + printf("Can not open file %s\n", name2); + break; + case ERROR_READ: + printf("Can not read file %s\n", name2); + break; + } + free(a); + free(x0); + free(x); + free(b); + free(r); + return 3; + } while (0); + } + else + init_matrix(x0, n, 1, k2); + init_vector(b, a, n); + printf("Matrix:\n"); + print_matrix(a, n, n, p); + printf("Vector:\n"); + print_matrix(x0, n, 1, p); + printf("Vector b:\n"); + print_matrix(b, n, 1, p); + t = clock(); + solve4(a, x0, x, b, r, n, m); + t = (clock() - t) / CLOCKS_PER_SEC; + r1 = count_r1(a, b, x, n); + r2 = count_r2(x, n); + printf("New vector:\n"); + print_matrix(x, n, 1, p); + printf("%s : Task = %d Res1 = %e Res2 = %e Elapsed = %.2f\n", argv[0], task, r1, r2, t); + free(a); + free(x0); + free(x); + free(b); + free(r); + return 0; + } + +void solve4(double* a, double* x0, double* x, double* b, double* r, int n, int m) + { + int k; + double tau, scalp2; + veccpy(x, x0, n); + multmatvec(a, x, r, n); + vecdiff(r, b, n); + for (k = 1; k <= m; k++) + { + multmatvec(a, r, x0, n); + scalp2 = scalp(x0, r, n); + if (!equal(scalp2, 0)) tau = scalp(r, r, n) / scalp2; + else break; + veccomb(1, x, -tau, r, n); + veccomb(1, r, -tau, x0, n); + } + }