feat: demo programs with integral calculations

2 files changed, 143 insertions, 14 deletions

diff --git a/controller.c b/controller.c
index 6efcb7e..a95d82b 100644
--- a/controller.c
+++ b/controller.c
@@ -1,19 +1,73 @@
 #include "lib/controller.h"
+#include "lib/common.h"
+
+typedef struct {
+    int id;
+
+    char* task;
+    size_t task_size;
+} task_t;
+
+task_t* tasks;
+
+const size_t TASKS = 100;
+const long double A = -5;
+const long double B = 10;
+const long double EPS = 1e-3;
+
+void divide_and_yield_tasks() {
+    tasks = calloc(TASKS, sizeof(*tasks));
+    long double delta = (B - A) / TASKS;
+    for (size_t i = 0; i < TASKS; i++) {
+        tasks[i].task = calloc(3, sizeof(long double));
+        long double* args = (long double*) tasks[i].task;
+
+        args[0] = A + delta * i;
+        args[1] = A + delta * (i + 1);
+        args[2] = EPS;
+
+        tasks[i].task_size = 3 * sizeof(long double);
+
+        tasks[i].id = controller_yield_task(tasks[i].task, tasks[i].task_size);
+        printf("%d task id\n", tasks[i].id);
+    }
+}
+
+void combine_results_and_print() {
+    long double sum = 0;
+
+    size_t cnt = 0;
+    while (cnt < TASKS) {
+        const char* res;
+        size_t sz;
+        printf("%lu taskid %d\n", cnt, controller_get_result(&res, &sz));
+
+        if (sz == 0) {
+            printf("fuck\n");
+            break;
+        }
+
+        const long double* resp = (const long double*) res;
+        printf("%lu %.10Lf\n", cnt, *resp);
+        sum += *resp;
+        cnt++;
+    }
+
+    printf("%.10Lf\n", sum);
+}
 
 int32_t main() {
     controller_init("127.0.0.1", "33554", 1, 4);
+    configure_timeout(100);
     controller_start();
 
-    printf("%d\n", controller_yield_task("test", 4));
-    printf("%d\n", controller_yield_task("task", 4));
+    divide_and_yield_tasks();
 
     controller_wait();
 
-    const char* c;
-    size_t sz;
-    printf("%d\n", controller_get_result(&c, &sz));
-    printf("%d\n", controller_get_result(&c, &sz));
+    combine_results_and_print();
 
+    printf("expected:\n313064450.892857\n");
     controller_finish();
-    printf("OK\n");
+    return 0;
 }
diff --git a/worker.c b/worker.c
index c6698d9..08be9bd 100644
--- a/worker.c
+++ b/worker.c
@@ -1,16 +1,91 @@
 #include "./lib/worker.h"
+#include "lib/common.h"
+#include "math.h"
 
-void func(const char* task, size_t task_size, char** resp, size_t* resp_size) {
-    printf("HERE %*s\n", (int) task_size, task);
+const long double RUNGE_SIMPSON_CONST = 1.0L / 15;
 
-    task = task;
+typedef long double (*func_value_t)(long double);
+
+typedef struct func_t {
+    func_value_t value;
+    func_value_t derivative;
+    int id;
+} func_t;
+
+long double func_value(long double x) {
+    return x * x * x * x * x * x - 15 * x * x * x * x * x + 134567 * x * x * x - 3486 * x * x + 100;
+}
+
+long double func_der(long double x) { return 6 * x * x * x * x * x - 75 * x * x * x * x + 403701 * x * x - 6972 * x; }
+
+long double func_value_x(long double x) { return x; }
+long double func_der_x(long double x) {
+    x = x;
+    return 1;
+}
+
+func_t func = {func_value, func_der, 1};
+// func_t func = {func_value_x, func_der_x, 1};
+
+long double calculate_integral(func_t f, long double a, long double b, long double eps) {
+    int n = 2;
+    long double delta = (b - a) / n, x = 0;
+
+    // integral value = (sum_by_1 + 2 * sum_by_2 + 4 * sum_by_4) * delta / 3
+    long double sum_by_1 = 0, sum_by_2 = 0, sum_by_4 = 0;
+
+    sum_by_1 += f.value(a);
+    sum_by_1 += f.value(b);
+
+    x = a + delta;
+    for (int i = 1; i < n; i += 2) {
+        sum_by_4 += f.value(x);
+        x += 2 * delta;
+    }
+
+    x = a + 2 * delta;
+    for (int i = 2; i < n; i += 2) {
+        sum_by_2 += f.value(x);
+        x += 2 * delta;
+    }
+
+    long double prev_sum = (sum_by_1 + 2 * sum_by_2 + 4 * sum_by_4) * delta / 3;
+    long double sum = prev_sum;
+
+    do {
+        prev_sum = sum;
+        sum_by_2 += sum_by_4;
+        sum_by_4 = 0;
+
+        n *= 2;
+        delta = (b - a) / n;
+
+        x = a + delta;
+        for (int i = 1; i < n; i += 2) {
+            sum_by_4 += f.value(x);
+            x += 2 * delta;
+        }
+
+        sum = (sum_by_1 + 2 * sum_by_2 + 4 * sum_by_4) * delta / 3;
+    } while ((fabsl(prev_sum - sum) - eps / RUNGE_SIMPSON_CONST) > 0);
+
+    return sum;
+}
+
+void worker_func(const char* task, size_t task_size, char** resp, size_t* resp_size) {
+    long double* args = (long double*) task;
     task_size = task_size;
-    *resp = malloc(10);
-    *resp_size = 10;
-    sleep(1);
+
+    long double res = calculate_integral(func, args[0], args[1], args[2]);
+    printf("task %Lf %Lf -> %Lf\n", args[0], args[1], res);
+
+    *resp = calloc(1, sizeof(long double));
+    *((long double*) *resp) = res;
+    *resp_size = sizeof(long double);
 }
 
 int32_t main() {
-    worker_init("127.0.0.1", "33554", 2, func);
+    worker_init("127.0.0.1", "33554", 2, worker_func);
+    configure_timeout(10);
     worker_exec();
 }