closer and closer

Author: ZocoLini

modules/cuqdyn-c/include/config.h

@@ -5,12 +5,12 @@
 
 typedef struct
 {
-    sunsunrealtype rtol;
+    sunrealtype rtol;
     N_Vector atol;
 
 } Tolerances;
 
-Tolerances create_tolerances(sunsunrealtype rtol, N_Vector atol);
+Tolerances create_tolerances(sunrealtype rtol, N_Vector atol);
 void destroy_tolerances(Tolerances);
 
 typedef struct

modules/cuqdyn-c/include/functions.h

@@ -7,7 +7,7 @@
 
 void mexpreval_init_wrapper(OdeExpr ode_expr);
 /// Function used to solve the ODE using cvodes
-int ode_model_fun(sunsunrealtype t, N_Vector y, N_Vector ydot, void *data);
+int ode_model_fun(sunrealtype t, N_Vector y, N_Vector ydot, void *data);
 /// Objetive function for the lotka_volterra problem used by the sacess library
 void* ode_model_obj_func(double *x, void *data);
 

modules/cuqdyn-c/include/matlab.h

@@ -53,5 +53,5 @@ SUNMatrix subtract_two_matrices(SUNMatrix a, SUNMatrix b);
  * For the quantiles corresponding to the probabilities outside that range,
  * quantile assigns the minimum or maximum values of the elements in A.
  */
-sunsunrealtype quantile(N_Vector, sunsunrealtype);
+sunrealtype quantile(N_Vector, sunrealtype);
 #endif //MATLAB_H

modules/cuqdyn-c/include/ode_solver.h

@@ -14,6 +14,6 @@
  *   - Columns 1-n: Solution components (y1, y2, ..., yn)
  *
  */
-SUNMatrix solve_ode(N_Vector parameters, N_Vector initial_values, sunsunrealtype t0, N_Vector times);
+SUNMatrix solve_ode(N_Vector parameters, N_Vector initial_values, sunrealtype t0, N_Vector times);
 
 #endif //EDO_SOLVER_H

modules/cuqdyn-c/src/config.c

@@ -69,7 +69,7 @@ int parse_cuqdyn_conf(const char *filename, CuqdynConf *config)
     xmlNodePtr root = xmlDocGetRootElement(doc);
     xmlNodePtr cur = root->children;
 
-    sunsunrealtype rtol = 1e-6;
+    sunrealtype rtol = 1e-6;
     N_Vector atol = NULL;
     int y_count = 0;
     char **odes = NULL;
@@ -213,7 +213,7 @@ CuqdynConf *get_cuqdyn_conf()
     return config;
 }
 
-Tolerances create_tolerances(sunsunrealtype scalar_rtol, N_Vector atol)
+Tolerances create_tolerances(sunrealtype scalar_rtol, N_Vector atol)
 {
     Tolerances tolerances;
     tolerances.rtol = scalar_rtol;

modules/cuqdyn-c/src/cuqdyn.c

@@ -63,7 +63,7 @@ CuqdynResult *cuqdyn_algo(const char *data_file, const char *sacess_conf_file,
         exit(1);
     }
 
-    const sunsunrealtype t0 = NV_Ith_S(times, 0);
+    const sunrealtype t0 = NV_Ith_S(times, 0);
     N_Vector initial_values = copy_matrix_row(observed_data, 0, 0, SM_COLUMNS_D(observed_data));
 
     const long m = SM_ROWS_D(observed_data);
@@ -126,7 +126,7 @@ CuqdynResult *cuqdyn_algo(const char *data_file, const char *sacess_conf_file,
 
         N_Vector init_vals = New_Serial(NV_LENGTH_S(initial_values));
         memcpy(NV_DATA_S(init_vals), NV_DATA_S(initial_values),
-               NV_LENGTH_S(initial_values) * sizeof(sunsunrealtype));
+               NV_LENGTH_S(initial_values) * sizeof(sunrealtype));
 
         N_Vector predicted_params =
                 execute_ess_solver(sacess_conf_file, output_file, texp, yexp, init_vals, rank, nproc);
@@ -138,8 +138,8 @@ CuqdynResult *cuqdyn_algo(const char *data_file, const char *sacess_conf_file,
 
         for (int j = 0; j < n; ++j)
         {
-            sunsunrealtype observed = SM_ELEMENT_D(observed_data, i, j);
-            sunsunrealtype predicted = SM_ELEMENT_D(predicted_data, i, j);
+            sunrealtype observed = SM_ELEMENT_D(observed_data, i, j);
+            sunrealtype predicted = SM_ELEMENT_D(predicted_data, i, j);
 
             NV_Ith_S(residuals, j) = fabs(observed - predicted);
         }
@@ -343,13 +343,13 @@ void matrix_array_set_index(MatrixArray array, long i, SUNMatrix matrix)
 
     array.data[i] = NewDenseMatrix(rows, cols);
 
-    memcpy(SM_DATA_D(array.data[i]), SM_DATA_D(matrix), rows * cols * sizeof(sunsunrealtype));
+    memcpy(SM_DATA_D(array.data[i]), SM_DATA_D(matrix), rows * cols * sizeof(sunrealtype));
 }
 
-int compare_sunsunrealtype(const void *a, const void *b)
+int compare_sunrealtype(const void *a, const void *b)
 {
-    double x = *(sunsunrealtype *) a;
-    double y = *(sunsunrealtype *) b;
+    double x = *(sunrealtype *) a;
+    double y = *(sunrealtype *) b;
 
     if (x < y)
         return -1;
@@ -367,9 +367,9 @@ SUNMatrix matrix_array_get_median(MatrixArray matrix_array)
     long max_z = matrix_array.len;
 
     SUNMatrix medians_matrix = NewDenseMatrix(rows, cols);
-    sunsunrealtype *medians = SM_DATA_D(medians_matrix);
+    sunrealtype *medians = SM_DATA_D(medians_matrix);
 
-    sunsunrealtype values[max_z];
+    sunrealtype values[max_z];
 
     for (int i = 0; i < rows; ++i)
     {
@@ -382,7 +382,7 @@ SUNMatrix matrix_array_get_median(MatrixArray matrix_array)
             }
 
             // Sorting the vector to obtain the median easily
-            qsort(values, max_z, sizeof(values[0]), compare_sunsunrealtype);
+            qsort(values, max_z, sizeof(values[0]), compare_sunrealtype);
 
             SM_ELEMENT_D(medians_matrix, i, j) =
                     max_z & 0b1 ? values[(max_z - 1) / 2] : (values[max_z / 2 - 1] + values[max_z / 2]) / 2;
@@ -410,9 +410,9 @@ N_Vector get_matrix_cols_median(SUNMatrix matrix)
     long cols = SM_COLUMNS_D(matrix);
 
     N_Vector medians_vector = New_Serial(cols);
-    sunsunrealtype *medians = NV_DATA_S(medians_vector);
+    sunrealtype *medians = NV_DATA_S(medians_vector);
 
-    sunsunrealtype copied_col[rows];
+    sunrealtype copied_col[rows];
 
     for (int j = 0; j < cols; ++j)
     {
@@ -422,7 +422,7 @@ N_Vector get_matrix_cols_median(SUNMatrix matrix)
         }
 
         // Sorting the vector to obtain the median easily
-        qsort(copied_col, rows, sizeof(copied_col[0]), compare_sunsunrealtype);
+        qsort(copied_col, rows, sizeof(copied_col[0]), compare_sunrealtype);
 
         medians[j] = rows & 0b1 ? copied_col[(rows - 1) / 2] : (copied_col[rows / 2 - 1] + copied_col[rows / 2]) / 2;
     }

modules/cuqdyn-c/src/data_reader.c

@@ -45,10 +45,10 @@ int read_txt_data_file(const char *data_file, N_Vector *t, SUNMatrix *y)
     fscanf(f, "%ld", &cols);
 
     *t = New_Serial(rows);
-    sunsunrealtype *data_t = N_VGetArrayPointer(*t);
+    sunrealtype *data_t = N_VGetArrayPointer(*t);
 
     *y = NewDenseMatrix(rows, cols - 1);
-    sunsunrealtype *data_y = ((SUNMatrixContent_Dense)(*y)->content)->data;
+    sunrealtype *data_y = ((SUNMatrixContent_Dense)(*y)->content)->data;
 
     double tmp;
 
@@ -107,10 +107,10 @@ int read_mat_data_file(const char *data_file, N_Vector *t, SUNMatrix *y)
     // The first row of the matrix are the initial values [t0 y10 y20 ...]
 
     *t = New_Serial((long) rows);
-    sunsunrealtype *data_t = N_VGetArrayPointer(*t);
+    sunrealtype *data_t = N_VGetArrayPointer(*t);
 
     *y = NewDenseMatrix((long) rows, (long) cols - 1);
-    sunsunrealtype *data_y = ((SUNMatrixContent_Dense)(*y)->content)->data;
+    sunrealtype *data_y = ((SUNMatrixContent_Dense)(*y)->content)->data;
 
     const double *file_data = matvar->data;
 

modules/cuqdyn-c/src/ess_solver.c

@@ -8,6 +8,8 @@
 #include "ess_solver.h"
 
 #include <../include/functions.h>
+
+#include "cuqdyn.h"
 #if defined(MPI2) && !defined(MPI)
 #include <mpi.h>
 #endif
@@ -78,7 +80,7 @@ N_Vector execute_ess_solver(const char *file, const char *path, N_Vector texp, S
 
     destroyexp(exptotal);
 
-    N_Vector predicted_params = N_VNew_Serial(exptotal->test.bench.dim);
+    N_Vector predicted_params = New_Serial(exptotal->test.bench.dim);
     N_VSetArrayPointer(result.bestx_value, predicted_params);
     return predicted_params;
 }

modules/cuqdyn-c/src/functions.c

@@ -2,13 +2,10 @@
 #include <method_module/structure_paralleltestbed.h>
 #include <nvector/nvector_serial.h>
 #include <string.h>
-#include <sundials_old/sundials_direct.h>
-#include <sundials_old/sundials_nvector.h>
 #include <sunmatrix/sunmatrix_dense.h>
 
 #include "config.h"
 #include "cuqdyn.h"
-#include "sundials_old/sundials_types.h"
 
 extern void mexpreval_init(OdeExpr ode_expr);
 
@@ -17,14 +14,14 @@ void mexpreval_init_wrapper(OdeExpr ode_expr)
     mexpreval_init(ode_expr);
 }
 
-extern void eval_f_exprs(sunsunrealtype t, sunsunrealtype *y, sunsunrealtype *ydot, sunsunrealtype *params);
+extern void eval_f_exprs(sunrealtype t, sunrealtype *y, sunrealtype *ydot, sunrealtype *params);
 
-int ode_model_fun(sunsunrealtype t, N_Vector y, N_Vector ydot, void *user_data)
+int ode_model_fun(sunrealtype t, N_Vector y, N_Vector ydot, void *user_data)
 {
     N_Vector params_vec = user_data;
-    sunsunrealtype *params = NV_DATA_S(params_vec);
-    sunsunrealtype *ydot_pointer = NV_DATA_S(ydot);
-    sunsunrealtype *y_pointer = NV_DATA_S(y);
+    sunrealtype *params = NV_DATA_S(params_vec);
+    sunrealtype *ydot_pointer = NV_DATA_S(ydot);
+    sunrealtype *y_pointer = NV_DATA_S(y);
 
     eval_f_exprs(t, y_pointer, ydot_pointer, params);
 
@@ -48,21 +45,21 @@ void *ode_model_obj_func(double *x, void *data)
     output_function *res = calloc(1, sizeof(output_function));
 
     N_Vector parameters = New_Serial(conf->ode_expr.p_count);
-    memcpy(NV_DATA_S(parameters), x, NV_LENGTH_S(parameters) * sizeof(sunsunrealtype));
+    memcpy(NV_DATA_S(parameters), x, NV_LENGTH_S(parameters) * sizeof(sunrealtype));
 
     N_Vector texp = New_Serial(NV_LENGTH_S(exptotal->texp));
-    memcpy(NV_DATA_S(texp), NV_DATA_S(exptotal->texp), NV_LENGTH_S(exptotal->texp) * sizeof(sunsunrealtype));
+    memcpy(NV_DATA_S(texp), NV_DATA_S(exptotal->texp), NV_LENGTH_S(exptotal->texp) * sizeof(sunrealtype));
 
-    const sunsunrealtype t0 = NV_Ith_S(texp, 0);
+    const sunrealtype t0 = NV_Ith_S(texp, 0);
 
     SUNMatrix result = solve_ode(parameters, exptotal->initial_values, t0, texp);
 
     // Objective function code:
     const int rows = SM_ROWS_D(result);
     const int cols = SM_COLUMNS_D(result);
 
-    // sunsunrealtype R[(cols - 1) * rows];
-    sunsunrealtype J = 0.0;
+    // sunrealtype R[(cols - 1) * rows];
+    sunrealtype J = 0.0;
 
     long index = 0;
 
@@ -71,7 +68,7 @@ void *ode_model_obj_func(double *x, void *data)
         // Note that the first col of the result matrix is t
         for (long j = 1; j < cols; ++j)
         {
-            const sunsunrealtype diff = SM_ELEMENT_D(result, i, j) - SM_ELEMENT_D(exptotal->yexp, i, j - 1);
+            const sunrealtype diff = SM_ELEMENT_D(result, i, j) - SM_ELEMENT_D(exptotal->yexp, i, j - 1);
             J += diff * diff;
             // R[index++] = SM_ELEMENT_D(result, i, j) - SM_ELEMENT_D(exptotal->yexp, i, j - 1);
         }

modules/cuqdyn-c/src/matlab.c

@@ -8,12 +8,12 @@
 
 N_Vector copy_vector_remove_indices(N_Vector original, LongArray indices)
 {
-    sunsunrealtype *original_data = N_VGetArrayPointer(original);
+    sunrealtype *original_data = N_VGetArrayPointer(original);
     long N = NV_LENGTH_S(original);
 
     N_Vector new_vector = New_Serial(N - indices.len);
 
-    sunsunrealtype *new_data = N_VGetArrayPointer(new_vector);
+    sunrealtype *new_data = N_VGetArrayPointer(new_vector);
 
     long new_index = 0; // Index to track the current index in the new vector
     long skip_index = 0; // Index to track the current index in the indices array
@@ -40,8 +40,8 @@ SUNMatrix copy_matrix_remove_rows_and_columns(SUNMatrix matrix, LongArray row_in
 
     SUNMatrix copy = NewDenseMatrix(rows - row_indices.len, cols - col_indices.len);
 
-    sunsunrealtype *original_data = SM_DATA_D(matrix);
-    sunsunrealtype *copy_data = SM_DATA_D(copy);
+    sunrealtype *original_data = SM_DATA_D(matrix);
+    sunrealtype *copy_data = SM_DATA_D(copy);
 
     // copy_index: Index to track the current index in the copy matrix
     // row_skip_index: Index to track the current index in the row_indices array
@@ -179,10 +179,10 @@ SUNMatrix subtract_two_matrices(SUNMatrix a, SUNMatrix b)
     return result;
 }
 
-int cmp_sunsunrealtype(const void *a, const void *b)
+int cmp_sunrealtype(const void *a, const void *b)
 {
-    double x = *(sunsunrealtype *) a;
-    double y = *(sunsunrealtype *) b;
+    double x = *(sunrealtype *) a;
+    double y = *(sunrealtype *) b;
 
     if (x < y)
         return -1;
@@ -191,17 +191,17 @@ int cmp_sunsunrealtype(const void *a, const void *b)
     return 0;
 }
 
-sunsunrealtype quantile(N_Vector vec, sunsunrealtype q)
+sunrealtype quantile(N_Vector vec, sunrealtype q)
 {
     const long n = NV_LENGTH_S(vec);
-    sunsunrealtype *data = malloc(n * sizeof(sunsunrealtype));
+    sunrealtype *data = malloc(n * sizeof(sunrealtype));
 
-    memcpy(data, NV_DATA_S(vec), n * sizeof(sunsunrealtype));
+    memcpy(data, NV_DATA_S(vec), n * sizeof(sunrealtype));
 
-    qsort(data, n, sizeof(sunsunrealtype), cmp_sunsunrealtype);
+    qsort(data, n, sizeof(sunrealtype), cmp_sunrealtype);
 
-    const double min_q = 0.5 / (sunsunrealtype) n;
-    const double max_q = ((sunsunrealtype) n - 0.5) / (sunsunrealtype) n;
+    const double min_q = 0.5 / (sunrealtype) n;
+    const double max_q = ((sunrealtype) n - 0.5) / (sunrealtype) n;
 
     if (q <= min_q) {
         const double val = data[0];
@@ -215,7 +215,7 @@ sunsunrealtype quantile(N_Vector vec, sunsunrealtype q)
         return val;
     }
 
-    const double pos = q * (sunsunrealtype) n - 0.5;
+    const double pos = q * (sunrealtype) n - 0.5;
     const int i = (int) pos;
     const double delta = pos - i;