test_data/data.c - master - LavrGov/bridge_between_rust_c

test_data/data.c
303 строки10 KB
Lavrentiy
Initial commit
14 июн 2025, 09:52
14 июн 2025, 09:52da79c4c
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "vect.h"

#define TEST_VECTOR_T

typedef double (*ffi_func)(double *y, double t);	
int rk_4(
    vector_t *y1,
     vector_t *y2,
	 vector_t y,
     ffi_func p[]
);

double F11Rang4(double *y, double t)
{
	double y1 = *(y);
	double y2 = *(y+1);
	return sin(t+y1*y2);
	//return 2.0 * (y[0] - y[0] * y[1]);
}

double F21Rang4(double *y, double t)
{
	
	double y1 = *y;
	double y2 = *(y+1);
	return cos(pow(t-y1+y2, 2));
	//return -(y[1] - y[0] * y[1]);
}


#ifdef TEST_VECTOR_T
int main() {
    vector_t int_v = new_vec(sizeof(int));
    int new_item = 34;
    int new_item2 = 345;
    push_back(&int_v, &new_item, sizeof(int));
    push_back(&int_v, &new_item2, sizeof(int));
    printf("%d, %d\n", get_data_m(&int_v, 0, int),  get_data_m(&int_v, 1, int));
    get_data_m(&int_v, 0, int) = 4567;
    printf("%d, %d\n", get_data_m(&int_v, 0, int),  get_data_m(&int_v, 1, int));
    get_data_m(&int_v, 1, int) += 1234;
    printf("%d, %d\n", get_data_m(&int_v, 0, int),  get_data_m(&int_v, 1, int));
    free_vec(&int_v);
    double new_item11 = 34;
    double new_item22 = 345;
    vector_t start_pointers = new_pre_alloc(1, sizeof(vector_t));
    push_back(&get_data_m(&start_pointers, 0, vector_t),&new_item11, sizeof(double));
    push_back(&get_data_m(&start_pointers, 0, vector_t),&new_item22, sizeof(double));
    vector_t get_v = get_data_m(&start_pointers, 0, vector_t);
    printf("%lf, %lf\n", get_data_m(&get_v, 0, double),  get_data_m(&get_v, 1, double));
    free_for_struct(&start_pointers);
}
#endif

#ifdef YMAIN
int main() {
    vector_t y1 = new_vec(sizeof(vector_t));
    vector_t y2 = new_vec(sizeof(vector_t));
    ffi_func p[] = {F11Rang4, F21Rang4};
    vector_t y = new_vec(sizeof(double));
    double f1 = 2;
    double f2 = 1;
    push_back(&y, &f1, sizeof(double));
    push_back(&y, &f2, sizeof(double));
    rk_4(&y1, &y2, y, p);
    print_for_vect_vect_double(&y1);
    print_for_vect_vect_double(&y2);
    free_for_struct(&y1);
    free_for_struct(&y2);
    free_vec(&y);
    printf("Hello, World\n");
}
#endif 

#define NOW_CALLOC


	int extern_rk_2(
		double ***y1,
		double ***y2, 
		double *y,
        int *size_data,
		ffi_func *func
    ) {
        #ifdef NOW_CALLOC

       // *size_data = 11;

		//std::vector<std::vector<double>> y1_vec = {};
		//std::vector<std::vector<double>> y2_vec = {};
        //FILE *new_file = fopen("data.txt", "w+");
        //fprintf(new_file, "%s\n", "start");
        //printf("Start\n");
        vector_t y1_vec =  new_vec(sizeof(vector_t));
        vector_t y2_vec = new_vec(sizeof(vector_t));
		/*
		for (double *start_y1 = y1, *start_y2 = y2; start_y1 != y1 + 2; ++start_y1, ++start_y2) {
			y1_vec.push_back(*start_y1);
			y2_vec.push_back(*start_y2);
		}
			*/
		vector_t y_start = new_vec(sizeof(double));
        push_back(& y_start, y, sizeof(double));
        push_back(& y_start, y + 1, sizeof(double));
        printf("%lf\n", get_data_m(&y_start, 0, double));
        printf("%lf\n", get_data_m(&y_start, 1, double));
		//std::vector<double> y_start = {*y, *(y+1)};
        /*
		std::vector<
		std::function<double(std::vector<double> &y, double t)>
		> p ;
        */
       ffi_func p[2] = {*func, *(func + 1)};
       /*
		for (ffi_func *start_func = func; start_func != func+2; ++start_func) {
			auto get_new_func = [func](std::vector<double> &y, double t) {
				double *y_ptr = &(*y.begin());
				return (*func)(y_ptr, t);
			};
			p.push_back(get_new_func);
		}
            */
        printf("RK_4 start\n");
		rk_4(&y1_vec, &y2_vec, y_start, p);
		*y1 = (double **) calloc(get_size(&y1_vec), sizeof(double *)) ;
        *y2 = (double **) calloc(get_size(&y1_vec), sizeof(double *));
		//*y2 = new double * [y1_vec.size()];
		//std::vector<std::vector<double>>::iterator y1_i = y1_vec.begin();
		///std::vector<std::vector<double>>::iterator y2_i = y2_vec.begin();
        vector_t *y1_i = y1_vec.data; 
        vector_t *y2_i = y2_vec.data;
		double **start_1 = *y1;
		double **start_y2 = *y2;
        
		for (; y1_i != (vector_t *)  y1_vec.data  + y1_vec.count; ++start_1, ++start_y2, ++y1_i, ++y2_i) {
			*start_1 = (double *) calloc(2, sizeof(double));
			*start_y2 = (double *) calloc(2, sizeof(double));
			memcpy(*start_1, y1_i->data, sizeof(double) * 2);
			memcpy(*start_y2, y2_i->data, sizeof(double) * 2);
		}
        int size = get_size(&y1_vec);
        free_for_struct(&y1_vec);
        free_for_struct(&y2_vec);
        free_vec(&y_start);
        
        #endif
        *size_data = size;
		return 12;
	}




    
int rk_4(
    vector_t *y1,
     vector_t *y2,
	 vector_t y,
     ffi_func p[]
    ){
   
	//double y[n] = {2,1}; // начальные значения
	//double yy[n] = {0.0};
    printf("Start in dll\n");
	size_t n = get_size(&y);
	size_t m = 4;
    /*
	auto func = [&p](std::vector<double> &y, double t, size_t i) {
		return p[i](y, t);
	};
    */
	//std::vector<double> yy (n);
    vector_t yy = new_pre_alloc(n, sizeof(double));
	// массив коэфициентов
	//double R[m][n] = {0.0} ;
	//std::vector<std::vector<double>>R (m);
    vector_t R = new_pre_alloc(m, sizeof(vector_t));
	//std::vector<std::vector<double>>::iterator iter = R.begin();
    vector_t *iter = R.data;
    printf("First\n");
	for (; iter != (vector_t *) R.data + R.count; iter++) {
		for (size_t index = 0; index != n ;index++) {
            double new_value = 0;
            push_back(iter, &new_value, sizeof(double));
            //(*iter).push_back(0.0);
        }
		//R.push_back(std::vector<dou)
	}
	double tstart = 0.0;
	double time = 0;
	double tmax = 10;
	double tau = 0.001;
	// 4
	//double tn = omp_get_wtime();
	// основной цикл. Организуем основной вычислительный цикл по аргументу
	// от tstart до tmax с шагом tau. на каждой иетрации цикла будем выполнять следующее
	do {
        printf("Second\n");
        for (int i = 0; i <n; i++) {
            printf("%p\n", y.data);
            double new_value = tau *p[i]((double *)y.data, time);
            printf("s1\n");
            vector_t vectr_form_r = get_data_m(&R,0, vector_t);
            * (double *) get_data(&vectr_form_r, i) = new_value;
            //*(double *)get_data( get_data_m(&R,0, vector_t).data, i) = new_value;
            //R[0][i] = tau *p[i](y, time);
        }
		// организуем цикл по числу параметров и вычислим коэф. первого приближения
        printf("3\n");
		// Организуем цикл по числу парраметров и вычислим значение параметров в 
		// смещенных точках
		for (int i = 0; i <n; i++) {
            vector_t temp_vect = get_data_m(&R, 0, vector_t);
            double new_value = get_data_m(&y, i, double)+0.5*get_data_m(&temp_vect, 0, double);
            get_data_m(&yy, i, double) = new_value;
            //yy.data[i] =new_value;
        }
        printf("4\n");
        
		// организуем цикл по числу параметров и вычислим коэфициенты второго     приближения 
        for ( int i = 0; i < n; i++) {
            vector_t temp_vect = get_data_m(&R, 1, vector_t);
		    get_data_m(& temp_vect, i, double) = tau*p[i](yy.data, time +0.5*tau);
        }
        printf("5\n");

		// Органзиуем цикл по числу параметро в смещенный точках
        for (int i = 0; i < n;i++) {
            vector_t temp_vect = get_data_m(&R, 1, vector_t);
		    get_data_m(&yy, i, double) = get_data_m(&y, i, double) + 0.5*get_data_m(&temp_vect, i, double);
        }
        printf("6\n");
		// организуем цикл по числу параметров c шагом 1 и вычислим коэфициенты третьего   приближения
        for (int i = 0; i < n; i++) {
            vector_t temp_vect = get_data_m(&R, 2, vector_t);
		   get_data_m(&temp_vect, i, double) = tau*p[i](yy.data, time+0.5*tau);
        }
        printf("7\n");
        for (int i = 0; i < n; i++) {
            vector_t temp_vect = get_data_m(&R, 2, vector_t);
			get_data_m(&yy, i, double) = get_data_m(&y, i, double)+get_data_m(&temp_vect, i, double);
        }
        printf("8\n");
		// вычислим значение параметров в смещенных точках
		// организуем цикл по числу параметро с шагом 1 и вычислия коэфициенты 4 приближени
        for (int i = 0; i < n; i++) {
            vector_t temp_vect = get_data_m(&R, 3, vector_t);
		    get_data_m(&temp_vect, i, double) = tau*p[i]((double *)yy.data, time+tau);
        }
        printf("9\n");
		// организуем цикл по числу параметров с шагом 1
        for (int i = 0; i < n; i++) { 
            
            double r1 = get_data_m(get_data_m_ptr(&R, 0, vector_t), i, double);
            double r2 = get_data_m(get_data_m_ptr(&R, 1, vector_t), i, double);
            double r3 = get_data_m(get_data_m_ptr(&R, 2, vector_t), i, double);
            double r4 = get_data_m(get_data_m_ptr(&R, 3, vector_t), i, double);

		    get_data_m(&y, i, double) += (r1 + 2.0*r2+2.0*r3+r4) / 6.0;
        }
        //printf("10_0\n");
		time += tau;
        vector_t t1Ans = new_vec(sizeof(double));
        vector_t y2Ans = new_vec(sizeof(double));
        push_back(&t1Ans, &time, sizeof(double));
        printf("10_1\n");
        push_back(&t1Ans, get_data_m_ptr(&y, 0, double), sizeof(double));
        printf("10_2\n");
        push_back(&y2Ans, &time, sizeof(double));
        printf("10_3\n");
        push_back(&y2Ans, get_data_m_ptr(&y, 1, double), sizeof(double));
        printf("10_4\n");
        printf("push_y_1_bloc\n");
        //std::vector<double> y2Ans {time, *(y.begin()+1)};
        push_back(y1, &t1Ans, sizeof(vector_t));
        push_back(y2, &y2Ans, sizeof(vector_t));
        //printf("y1: %lf, y2: %lf\n", *(double *)y.data, *((double *)y.data + 1));
        //y1.push_back(t1Ans);
        //y2.push_back(y2Ans);
	} while (time <= tmax);
    printf("End DLL\n");

    free_for_struct(&R);
    free_vec(&yy);

	//double tk = omp_get_wtime();
	// печать delta=tk-tstart;
	//printData1(y, n);
    return 0;
} 


void sum_t(int *d1, int *d2) {
    //*d1 = *d1 + *d2;
}


// Вывод значений, которы были получены при решении
// Системы диф-уравнений в файл