repo_name stringlengths 5 122 | path stringlengths 3 232 | text stringlengths 6 1.05M |
|---|---|---|
kipiberbatov/idec | src/array/jagged3_fscan.c | <filename>src/array/jagged3_fscan.c
#include <errno.h>
#include <string.h>
#include "jagged_private.h"
jagged3 * jagged3_fscan(FILE * in, const char * format)
{
int i;
jagged3 * arr;
for (i = 0; i < JAGGED3_FSCAN_FORMAT_TOTAL; ++i)
if (!strcmp(format, jagged3_fscan_format[i]))
{
arr = jagged3_fs... |
kipiberbatov/idec | main/mesh/main_forman_bd.c | <filename>main/mesh/main_forman_bd.c<gh_stars>0
#include <errno.h>
#include "double.h"
#include "forman.h"
static void mesh_bd_fprint_raw(FILE * out, int m_dim, matrix_sparse ** m_bd)
{
int m_bd_p_nonzero_max, p;
const matrix_sparse * m_bd_p;
for (p = 1; p <= m_dim; ++p)
{
m_bd_p = m_bd[p - 1];
m_bd_p... |
kipiberbatov/idec | src/mesh/mesh_bd_hyperfaces.c | #include <stdlib.h>
#include "mesh.h"
#if 0
int mesh_bd_hyperfaces_size(const mesh * m)
{
int i, j, m_bd_hyperfaces_size, m_dim, m_fc;
int * m_cn;
jagged1 m_hyperfaces_to_cells_sizes;
m_dim = m->dim;
m_cn = m->cn;
mesh_fcn_part2(&m_hyperfaces_to_cells_sizes, m, m_dim - 1, m_dim);
m_bd_hyperfaces_size... |
kipiberbatov/idec | include/algebra/vector_sparse.h | <reponame>kipiberbatov/idec
#ifndef VEC_SPARSE_H
#define VEC_SPARSE_H
#include <stdio.h>
//#include "cs.h"
// typedef struct vector_sparse
// {
// int nzmax;
// int n;
// int * p;
// double * x;
// } vector_sparse;
typedef struct vector_sparse
{
int length;
int nonzero_max;
int * positions;
double * ... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_linear_combination.c | #include <errno.h>
#include <stdlib.h>
#include "matrix_sparse.h"
static void matrix_sparse_linear_combination_fprint(
FILE * out, const char * a_name, const char * a_format, const char * b_name,
const char * b_format, double alpha, double beta, const char * out_format)
{
matrix_sparse * a, * b, * c;
a = matr... |
kipiberbatov/idec | src/mesh/mesh_measure.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "int.h"
#include "mesh_private.h"
#include "quasi_cube.h"
#include "simplex.h"
/* finds the volumes of a simplicial mesh or of a quasi-cubical mesh */
double * mesh_measure(const mesh * m)
{
int i, ind, m_dim_embedded, m_dim, m_cn_p, m_v... |
kipiberbatov/idec | src/mesh/mesh_displacement.c | <gh_stars>0
#include <stdlib.h>
#include "mesh.h"
static void point_difference(
double * res, int d, const double * a, const double * b)
{
int i;
for (i = 0; i < d; ++i)
res[i] = b[i] - a[i];
}
static void vector_scalar_multiply_by(double * a, int d, double lambda)
{
int i;
for (i = 0; i < d; ++i)... |
kipiberbatov/idec | src/mesh/forman.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include <stdlib.h>
#include "forman_private.h"
#include "int.h"
#include "mesh_private.h"
mesh * forman(const mesh * m)
{
int m_forman_c_size, m_forman_coord_size;
mesh * m_forman;
m_forman = (mesh *) malloc(sizeof(mesh));
if (errno)
{
fputs("forman - cann... |
kipiberbatov/idec | src/algebra/matrix_sparse_array_fprint.c | #include <errno.h>
#include <string.h>
#include "matrix_sparse.h"
void matrix_sparse_array_fprint(
FILE * out, int n, matrix_sparse ** a, const char * format)
{
int i;
for (i = 0; i < n; ++i)
{
matrix_sparse_fprint(out, a[i], format);
if (errno)
{
fprintf(stderr,
"matrix_sparse... |
kipiberbatov/idec | src/mesh/mesh_qc_integrate.c | #include "mesh_qc.h"
double mesh_qc_integrate(const mesh_qc * m, const double * m_vol_d,
const vector_sparse * a)
{
int a_nonzero_max, i, i_loc, j, t;
int * a_positions;
double sum, sum_loc;
double * a_values;
jagged1 m_cf_0_d_j;
jagged2 m_cf_0_d;
a_nonzero_max = a->nonzero_ma... |
kipiberbatov/idec | src/mesh/mesh_qc_elasticity_cbd_star.c | #include <stdlib.h>
#include "mesh_qc.h"
// static double * mesh_qc_cbd_star_physical_single_x(
// const mesh_qc * m, int p, const matrix_sparse * m_bd_p,
// const double * m_inner_p, const double * m_inner_p_minus_1,
// const double * c_p_minus_1)
// {
// int i, ind, j, j_loc, m_cn_p;
// double sign, m_inne... |
kipiberbatov/idec | src/array/jagged2_fscan_raw.c | #include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "jagged_private.h"
jagged2 * jagged2_fscan_raw(FILE * in)
{
int arr_a2_size;
jagged2 * arr;
arr = (jagged2 *) malloc(sizeof(jagged2));
if (errno)
{
perror("jagged2_fscan_raw - cannot allocate memory for arr");
goto end;
}
arr->a0... |
kipiberbatov/idec | src/mesh/mesh_fc_part.c | <filename>src/mesh/mesh_fc_part.c
#include <stdlib.h>
#include "int.h"
#include "mesh.h"
/* it is assumed that (p > q) */
void mesh_fc_part2(jagged2 * m_fc_q_p, const mesh * m, int q, int p)
{
jagged4_part2(m_fc_q_p, m->fc, q, p - q - 1);
}
void mesh_fc_part3(jagged1 * m_fc_q_p_j, const mesh * m, int q, int p, int ... |
kipiberbatov/idec | include/mesh/mesh_brick.h | #ifndef MESH_BRICK_H
#define MESH_BRICK_H
#include "mesh.h"
int ** mesh_brick_bd(int d, const int * n, const int * m_bd_sizes);
mesh * mesh_brick(int d, const double * brick_lengths, const int * n);
mesh * mesh_brick_regular(int d, int n);
#endif /* MESH_BRICK_H */
|
kipiberbatov/idec | include/region/line.h | #ifndef LINE_H
#define LINE_H
typedef struct line
{
double x0[2];
double x1[2];
} line;
/***************************** memory_management ******************************/
line * line_new(double * p_x0, double * p_x1);
void line_free(line * p);
/********************************* geometry **************************... |
kipiberbatov/idec | main/mesh/main_mesh_bd.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include "mesh.h"
int main(int argc, char * argv[])
{
mesh * m;
matrix_sparse ** m_bd;
FILE * in, * out;
char * format;
out = stdout;
in = stdin;
m = mesh_fscan(in, "--raw");
if (errno)
{
fputs("main - cannot scan m\n", stderr);
return errn... |
kipiberbatov/idec | main/array/main_int_array_cartesian_product.c | <reponame>kipiberbatov/idec<gh_stars>0
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include "int.h"
static void int_array_cartesian_product_fprint(FILE * out, int d, const int * n)
{
int prod, i;
int * a;
prod = int_array_total_product(d, n);
a = (int *) calloc(d, sizeof(int));
if (errno)
... |
kipiberbatov/idec | src/mesh/mesh_node_curvature.c | <filename>src/mesh/mesh_node_curvature.c
#include <errno.h>
#include <math.h>
#include <stdlib.h>
#include "double.h"
#include "mesh.h"
#define PI 3.14159265
/* finds the full unit angle in d dimensions (d = 0,1,2,3), i.e.,
* the surface area of the unit (d - 1)-sphere (the boundary of the unit d-ball)
*/
static do... |
kipiberbatov/idec | src/mesh/forman_cbi.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "forman_private.h"
#include "int.h"
static void forman_cbi_a3(int * m_forman_cbi_a3, const mesh * m)
{
int i, ind, j, j_loc, m_dim, p, q, r;
int * m_cn;
jagged1 m_cf_p_r_i, m_cfn_p_r;
jagged2 m_cf_p_r;
m_dim = m->dim;
m_cn = m->cn;
... |
kipiberbatov/idec | src/algebra/vector_sparse_array2_free.c | <gh_stars>0
#include <stdlib.h>
#include "vector_sparse.h"
void vector_sparse_array2_free(vector_sparse *** arr, int a0, const int * a1)
{
int i;
for (i = a0 - 1; i >= 0; --i)
vector_sparse_array_free(arr[i], a1[i]);
free(arr);
}
|
kipiberbatov/idec | src/mesh/mesh_qc_private.h | <filename>src/mesh/mesh_qc_private.h<gh_stars>0
#ifndef MESH_QC_PRIVATE_H
#define MESH_QC_PRIVATE_H
#include "mesh_qc.h"
double mesh_qc_cup_product_sign(
matrix_sparse ** m_bd, int node, int p, int i, int q, int j, int r, int k);
void mesh_qc_perpendicular(
int * nodes, int * perp, const jagged2 * m_cf_d_q, cons... |
kipiberbatov/idec | main/mesh/main_mesh_fc.c | #include "mesh.h"
int main()
{
mesh * m;
FILE * out, * in;
out = stdout;
in = stdin;
m = mesh_fscan(in, "--raw");
/* NULL pointer check */
m->fc = mesh_fc(m);
/* NULL pointer check */
jagged4_fprint(out, m->fc, "--raw");
mesh_free(m);
return 0;
}
|
kipiberbatov/idec | src/mesh/forman_cf_a3.c | #include "forman_private.h"
#include "int.h"
void forman_cf_a3(int * m_forman_cf_a3, int m_dim, const int * m_forman_cn)
{
int ind, m_forman_cn_p_f, p_f, q_f, r_f, vertices_number;
ind = 0;
for (p_f = 1; p_f <= m_dim; ++p_f)
{
m_forman_cn_p_f = m_forman_cn[p_f];
for (q_f = 0; q_f < p_f; ++q_f)
{
... |
kipiberbatov/idec | include/region/region.h | <filename>include/region/region.h
#ifndef REGION_H
#define REGION_H
#include "point.h"
#include "line.h"
#include "triangle.h"
typedef enum region_names_list
{
/* 0D */
POINT,
/* 1D */
LINE,
/* 2D */
TRIANGLE
// QUAD,
// SQUARE,
// RECTANGLE,
// RHOMBUS,
// PARALLELOGRAM,
// PENTAGON,
// HEX... |
kipiberbatov/idec | src/array/jagged1_fscan.c | <filename>src/array/jagged1_fscan.c
#include <errno.h>
#include <string.h>
#include "jagged_private.h"
jagged1 * jagged1_fscan(FILE * in, const char * format)
{
int i;
jagged1 * arr;
for (i = 0; i < JAGGED1_FSCAN_FORMAT_TOTAL; ++i)
if (!strcmp(format, jagged1_fscan_format[i]))
{
arr = jagged1_fs... |
kipiberbatov/idec | src/array/jagged3_free.c | <filename>src/array/jagged3_free.c
#include <stdlib.h>
#include "jagged.h"
void jagged3_free(jagged3 * arr)
{
free(arr->a3);
free(arr->a2);
free(arr->a1);
free(arr);
}
|
kipiberbatov/idec | main/mesh/main_mesh_qc_elasticity_cbd_star_1.c | #include <stdlib.h>
#include <string.h>
#include "double.h"
#include "mesh_qc.h"
static void mesh_qc_elasticity_cbd_star_1_fprint_raw(
FILE * out, const mesh_qc * m, const matrix_sparse * m_bd_1,
const double * m_inner_1, const double * m_inner_0, double lambda, double mu)
{
int m_elasticity_cbd_star_1_nonzero_m... |
kipiberbatov/idec | main/mesh/main_mesh_displacement.c | #include <stdlib.h>
#include "double.h"
#include "mesh_qc.h"
static void mesh_displacement_fprint_raw(
FILE * out, const mesh * m, const matrix_sparse * m_bd_0, const double * u)
{
int i, m_dim_embedded;
double * m_displacement_i;
double ** m_displacement;
m_dim_embedded = m->dim_embedded;
m_displacemen... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_fprint.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "matrix_sparse.h"
static void matrix_sparse_fprint_fscan(FILE * out, FILE * in, char * format)
{
matrix_sparse * a;
a = matrix_sparse_fscan(in, "--raw");
if (errno)
{
perror("Unsuccessful matrix scanning during matrix printing calculati... |
kipiberbatov/idec | src/mesh/mesh_fscan_raw.c | #include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "int.h"
#include "mesh_private.h"
mesh * mesh_fscan_raw(FILE * in)
{
int m_c_size;
mesh * m;
m = (mesh *) malloc(sizeof(mesh));
if (errno)
{
perror("mesh_fscan_raw - cannot allocate memory for m");
goto end;
}
m->dim_embedd... |
kipiberbatov/idec | src/algebra/matrix_sparse_array_free.c | <gh_stars>0
#include <stdlib.h>
#include "matrix_sparse.h"
void matrix_sparse_array_free(matrix_sparse ** a, int n)
{
int i;
for (i = n - 1; i >= 0; --i)
matrix_sparse_free(a[i]);
free(a);
}
void matrix_sparse_array_free_shared(matrix_sparse ** a, int n)
{
int i;
for (i = n - 1; i >= 0; --i)
m... |
kipiberbatov/idec | include/array/double.h | #ifndef DOUBLE_H
#define DOUBLE_H
#include <stdio.h>
/*********************************** double ***********************************/
double double_fscan(FILE * in);
double double_sscan(const char * s);
/******************************** double_array ********************************/
double * double_array_fscan(FILE... |
kipiberbatov/idec | src/mesh/mesh_cf_part.c | <reponame>kipiberbatov/idec<filename>src/mesh/mesh_cf_part.c
#include <stdlib.h>
#include "int.h"
#include "mesh.h"
// void mesh_cf_part2(jagged2 * m_cf_p_q, const mesh * m, int p, int q)
// {
// if (p == q)
// {
// m_cf_p_q->a0 = m->cn[p];
//
// m_cf_p_q->a1 = (int *) malloc(m_cf_p_q->a0 * sizeof(int));
/... |
kipiberbatov/idec | src/mesh/mesh_qc_metric.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include <string.h>
// #include "array_indexed.h"
#include "double.h"
#include "int.h"
#include "mesh_qc.h"
static vector_sparse * mesh_qc_metric_p_i(
int m_cn_0, const jagged1 * m_cf_p_0_i, int p, int i, double m_vol_p_i)
{
double denominator_p_i;
vector_sparse... |
kipiberbatov/idec | main/mesh/main_mesh_brick_regular.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "mesh_brick.h"
static void mesh_brick_regular_fprint_raw(FILE * out, int d, int n)
{
int p;
int m_bd_sizes[MAX_DIM], n_list[MAX_DIM];
mesh * m;
int ** m_bd;
m = mesh_brick_regular(d, n);
if (errno)
{
fputs("mesh_brick_reg... |
kipiberbatov/idec | src/mesh/mesh_bd.c | #include <stdlib.h>
// #include "array_indexed.h"
#include "int.h"
#include "mesh.h"
int mesh_bd_nzmax(const mesh * m, int p)
{
int i, m_cn_p;
int * hyperfaces_a1;
int m_bd_nzmax;
jagged1 hyperfaces;
jagged3 m_cfn;
//jagged4 * m_cf;
m_cn_p = m->cn[p];
m_cfn.a0 = m->cf->a0;
m_cfn.a1 = m->cf->a1;
... |
kipiberbatov/idec | src/region/quasi_cube_measure.c | #include "quasi_cube_private.h"
double quasi_cube_measure(const quasi_cube * r)
{
int r_dim;
r_dim = r->dim;
switch (r_dim)
{
case 0:
return 1;
case 1:
return quasi_cube_measure_from_triangulation(r, r_triangulation_nodes_1);
case 2:
return quasi_cube_measure_from_triangulation(r, r_triang... |
kipiberbatov/idec | src/algebra/matrix_sparse_fprint_only_values.c | <gh_stars>0
#include <errno.h>
#include "double.h"
#include "matrix_sparse_private.h"
void matrix_sparse_fprint_only_values(FILE * out, const matrix_sparse * a)
{
fprintf(out, "%d\n%d\n", a->rows, a->cols);
double_array_fprint(out, a->cols_total[a->cols], a->values, "--raw");
}
|
kipiberbatov/idec | main/region/main_quasi_cube.c | #include <errno.h>
#include "double.h"
#include "quasi_cube.h"
static void quasi_cube_measure_fprint(FILE * out, const quasi_cube * r)
{
double r_area;
r_area = quasi_cube_measure(r);
fprintf(out, "area : %g\n", r_area);
}
static void quasi_cube_centroid_fprint(FILE * out, const quasi_cube * r)
{
double r_ce... |
kipiberbatov/idec | src/array/int_array.c | <filename>src/array/int_array.c
#include "int.h"
void int_array_assign_identity(int * a, int n)
{
int i;
for (i = 0; i < n; ++i)
a[i] = i;
}
void int_array_assign_constant(int * a, int n, int c)
{
int i;
for (i = 0; i < n; ++i)
a[i] = c;
}
void int_array_substitute(int * b, int n, const int * a... |
kipiberbatov/idec | include/region/triangle.h | <reponame>kipiberbatov/idec
#ifndef TRIANGLE_H
#define TRIANGLE_H
typedef struct triangle
{
double x0[2];
double x1[2];
double x2[2];
} triangle;
/***************************** memory_management ******************************/
triangle * triangle_new(double * p_x0, double * p_x1, double * p_x2);
void triangle_... |
kipiberbatov/idec | src/array/jagged2_fprint_curly.c | #include "array_fprint.h"
#include "jagged_private.h"
void jagged2_fprint_curly(FILE * out, const jagged2 * arr)
{
array_fprint2(out, arr->a0, arr->a1, arr->a2);
fputc('\n', out);
}
|
kipiberbatov/idec | src/array/double_array2_fscan_by_name.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double.h"
double ** double_array2_fscan_by_name(
const char * name, int a0, const int * a1, const char * format)
{
int i;
double ** a;
a = (double **) malloc(sizeof(double *) * a0);
if (errno)
{
fputs("double_array2_fsc... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_remove.c | <gh_stars>0
#include <errno.h>
#include "jagged.h"
#include "matrix_sparse.h"
static void matrix_sparse_remove_fprint(
FILE * out, const matrix_sparse * a, const jagged1 * rows,
const jagged1 * cols)
{
matrix_sparse * b;
b = matrix_sparse_remove(a, rows, cols);
if (errno)
{
perror("Problem in matrix... |
kipiberbatov/idec | src/mesh/mesh_brick_bd.c | #include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "mesh_brick_private.h"
static void mesh_brick_bd_p(int * m_bd_p, int d, const int * n, int p)
{
int bin_d_p, ind, sign_p, sign_v, u, v, y_ind, y_size;
int a[MAX_DIM], n_bar_p[MAX_DIM];
bin_d_p = int_binomial(d, p);
sign_p = (p % 2 == 1) ? 1 : ... |
kipiberbatov/idec | src/algebra/vector_sparse_fprint_raw.c | #include "double.h"
#include "int.h"
#include "vector_sparse_private.h"
void vector_sparse_fprint_raw(FILE * out, const vector_sparse * a)
{
fprintf(out, "%d\n", a->length);
fprintf(out, "%d\n", a->nonzero_max);
int_array_fprint(out, a->nonzero_max, a->positions, "--raw");
double_array_fprint(out, a->nonzero_m... |
kipiberbatov/idec | src/array/int_array_fprint.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include <string.h>
#include "int_private.h"
void int_array_fprint(FILE * out, int n, const int * a, const char * format)
{
int i;
for (i = 0; i < INT_ARRAY_FPRINT_FORMAT_TOTAL; ++i)
if (!strcmp(format, int_array_fprint_format[i]))
{
int_array_fprint_... |
kipiberbatov/idec | src/algebra/matrix_sparse_fscan.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "matrix_sparse_private.h"
matrix_sparse * matrix_sparse_fscan(FILE * in, const char * format)
{
int i;
matrix_sparse * a;
for (i = 0; i < MATRIX_SPARSE_FSCAN_FORMAT_TOTAL; ++i)
if (!strcmp(format, matrix_sparse_fscan_format[i]))
{
... |
kipiberbatov/idec | src/array/int_array_4_values.c | #include "int.h"
void int_array_4_values_get(
const int * a, int * x0, int * x1, int * x2, int * x3)
{
*x0 = a[0];
*x1 = a[1];
*x2 = a[2];
*x3 = a[3];
}
void int_array_4_values_set(int * a, int x0, int x1, int x2, int x3)
{
a[0] = x0;
a[1] = x1;
a[2] = x2;
a[3] = x3;
}
|
kipiberbatov/idec | src/array/jagged1_fprint_raw.c | <gh_stars>0
#include "int.h"
#include "jagged_private.h"
void jagged1_fprint_raw(FILE * out, const jagged1 * arr)
{
fprintf(out, "%d\n", arr->a0);
int_array_fprint(out, arr->a0, arr->a1, "--raw");
}
|
kipiberbatov/idec | src/mesh/mesh_private.h | #ifndef MESH_PRIVATE_H
#define MESH_PRIVATE_H
#include "mesh.h"
/*********************************** mesh_c ***********************************/
void mesh_c(int * m_c, int m_dim, const int * m_cn);
/********************************** mesh_cf ***********************************/
void mesh_cf_a1(int * m_cf_a1, int m_d... |
kipiberbatov/idec | src/algebra/matrix_sparse_transpose.c | <gh_stars>0
#include <errno.h>
#include "matrix_sparse_private.h"
matrix_sparse * matrix_sparse_transpose(const matrix_sparse * a)
{
cs a0;
cs * b0;
matrix_sparse * b = NULL;
matrix_sparse_to_cs(&a0, a);
b0 = cs_transpose(&a0, 1);
if (errno)
{
perror("Cannot find transpose via cs_transpose");
... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_diffusion.c | <reponame>kipiberbatov/idec<gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "int.h"
#include "matrix_sparse.h"
int main(int argc, char * argv[])
{
int N;
double tau;
double * lhs, * u_0, * x;
matrix_sparse * laplacian_0;
char * laplacian_0_format, * laplacian_0_name, * lhs_form... |
kipiberbatov/idec | src/algebra/matrix_sparse_identity.c | #include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "double.h"
#include "matrix_sparse.h"
matrix_sparse * matrix_sparse_identity(int n)
{
matrix_sparse * a;
a = (matrix_sparse *) malloc(sizeof(matrix_sparse));
if (errno)
{
fputs("matrix_sparse_identity - cannot allocate memory for a\n", std... |
kipiberbatov/idec | src/algebra/matrix_sparse_wrapper.c | #include "matrix_sparse_private.h"
void matrix_sparse_to_cs(cs * a0, const matrix_sparse * a)
{
a0->nzmax = a->cols_total[a->cols];
a0->m = a->rows;
a0->n = a->cols;
a0->p = a->cols_total;
a0->i = a->row_indices;
a0->x = a->values;
a0->nz = -1;
}
void matrix_sparse_from_cs(matrix_sparse * a, const cs * ... |
kipiberbatov/idec | src/mesh/mesh_cf_fscan.c | #include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "mesh_private.h"
jagged4 * mesh_cf_fscan(FILE * in, int m_dim, const int * m_cn)
{
int m_cf_a2_size, m_cf_a3_size, m_cf_a4_size;
jagged4 * m_cf;
m_cf = (jagged4 *) malloc(sizeof(jagged4));
if (errno)
{
perror("mesh_fscan_cf - cannot allo... |
kipiberbatov/idec | src/array/jagged3_fprint.c | <reponame>kipiberbatov/idec<filename>src/array/jagged3_fprint.c
#include <errno.h>
#include <string.h>
#include "jagged_private.h"
void jagged3_fprint(FILE * out, const jagged3 * arr, const char * format)
{
int i;
for (i = 0; i < JAGGED3_FPRINT_FORMAT_TOTAL; ++i)
if (!strcmp(format, jagged3_fprint_format[i]... |
kipiberbatov/idec | src/region/simplex_set.c | <gh_stars>0
#include "simplex.h"
void simplex_set(
simplex * s, int s_dim_embedded, int s_dim, double * s_coord)
{
s->dim_embedded = s_dim_embedded;
s->dim = s_dim;
s->coord = s_coord;
}
|
kipiberbatov/idec | include/mesh/mesh.h | <gh_stars>0
#ifndef MESH_H
#define MESH_H
#include "matrix_sparse.h"
#include "jagged.h"
#include "vector_sparse.h"
#define MAX_DIM 10
typedef struct mesh
{
int dim_embedded; /* embedding dimension */
int dim; /* geometric dimension */
int * cn; /* cells numbers *... |
kipiberbatov/idec | main/mesh/main_forman.c | #include <errno.h>
#include "forman.h"
static mesh * forman_mesh_fscan(FILE * in, const char * format)
{
mesh * m, * m_forman = NULL;
m = mesh_fscan(in, format);
if (errno)
{
fputs("forman_mesh_fscan - cannot scan m\n", stderr);
goto end;
}
m->fc = mesh_fc(m);
if (errno)
{
fputs("form... |
kipiberbatov/idec | main/mesh/main_mesh_qc_elasticity_cbd_star_2.c | <gh_stars>0
#include <stdlib.h>
#include <string.h>
#include "double.h"
#include "mesh_qc.h"
static void mesh_qc_elasticity_cbd_star_2_fprint_raw(
FILE * out, const mesh_qc * m, const matrix_sparse * m_bd_2,
const double * m_inner_2, const double * m_inner_1, double mu)
{
int m_elasticity_cbd_star_2_nonzero_max;... |
kipiberbatov/idec | main/array/main_array_indexed_merge_sort.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "array_indexed.h"
#include "int.h"
#include "jagged.h"
int main()
{
int n;
jagged1 * arr = NULL;
array_indexed a;
FILE * in, * out;
out = stdout;
in = stdin;
arr = jagged1_fscan(in, "--raw");
if (errno)
{
fputs("main - cann... |
kipiberbatov/idec | src/algebra/vector_sparse_array_free.c | <gh_stars>0
#include <stdlib.h>
#include "vector_sparse.h"
void vector_sparse_array_free(vector_sparse ** arr, int a0)
{
int i;
for (i = a0 - 1; i >= 0; --i)
vector_sparse_free(arr[i]);
free(arr);
}
|
kipiberbatov/idec | src/region/simplex_centroid.c | <filename>src/region/simplex_centroid.c
#include "simplex.h"
void simplex_centroid(double * s_centroid, const simplex * s)
{
int node, nodes_number, s_dim_embedded, t, tmp;
double * s_coord;
nodes_number = s->dim + 1;
s_dim_embedded = s->dim_embedded;
s_coord = s->coord;
for (node = 0; node < nodes_numb... |
kipiberbatov/idec | src/mesh/forman_private.h | <reponame>kipiberbatov/idec
#ifndef FORMAN_PRIVATE_H
#define FORMAN_PRIVATE_H
#include "forman.h"
/********************************* forman_cn **********************************/
void forman_cn(int * m_forman_cn, const mesh * m);
/********************************* forman_cf **********************************/
/* Bor... |
kipiberbatov/idec | src/mesh/mesh_cf.c | #include "int.h"
#include "mesh_private.h"
void mesh_cf_a1(int * m_cf_a1, int m_dim)
{
int i;
for (i = 0; i < m_dim; ++i)
m_cf_a1[i] = i + 1;
}
void mesh_cf_a2(int * m_cf_a2, int m_dim, const int * m_cn)
{
int ind, p;
ind = 0;
for (p = 1; p <= m_dim; ++p)
{
int_array_assign_constant(m_cf_a2 ... |
kipiberbatov/idec | src/array/int.c | <filename>src/array/int.c
#include "int.h"
void int_swap(int * a, int * b)
{
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}
int int_power(int a, int n)
{
int i, res;
res = 1;
for (i = 0; i < n; ++ i)
res *= a;
return res;
}
int int_binomial(int n, int k)
{
int i, k1, res;
k1 = (n >= 2 * k ? k... |
kipiberbatov/idec | src/mesh/mesh_brick_private.h | #ifndef MESH_BRICK_PRIVATE_H
#define MESH_BRICK_PRIVATE_H
#include "mesh_brick.h"
void mesh_brick_cn(int * m_cn, int m_dim, const int * n);
void mesh_brick_assign_n_bar(
int * n_bar, int d, const int * n, int p, const int * a);
void mesh_brick_cf_a3(int * m_cf_a3, int m_dim, const int * m_cn);
void mesh_brick_cf... |
kipiberbatov/idec | src/mesh/mesh_fprint_raw.c | #include "double.h"
#include "int.h"
#include "mesh_private.h"
void mesh_fprint_raw(FILE * out, const mesh * m)
{
int /*m_c_size,*/ m_cf_a2_size, m_cf_a3_size, m_cf_a4_size;
fprintf(out, "%d\n", m->dim_embedded);
fprintf(out, "%d\n", m->dim);
int_array_fprint(out, m->dim + 1, m->cn, "--raw");
// ... |
kipiberbatov/idec | main/array/main_jagged1.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include "jagged.h"
int main()
{
jagged1 * arr;
FILE * in, * out;
out = stdout;
in = stdin;
arr = jagged1_fscan(in, "--raw");
if (errno)
{
fputs("main - cannot scan arr\n", stderr);
return errno;
}
jagged1_fprint(out, arr, "--curly");
... |
kipiberbatov/idec | src/mesh/mesh_cfn_part.c | <gh_stars>0
#include "mesh.h"
// void mesh_cfn_part2(jagged1 * m_cfn_p_q, const mesh * m, int p, int q)
// {
// jagged3 m_cfn;
//
// if (p == q)
// {
// m_cfn_p_q->a0 = 1;
// m_cfn_p_q->a1 = (int *) malloc(sizeof(int));
// m_cfn_p_q->a1[0] = 1;
// }
// else
// {
// m_cfn.a0 = m->cf->a0;
// ... |
kipiberbatov/idec | src/region/region.c | #include <stdlib.h>
#include "region.h"
region * region_new(region_names_list r_name, void * r_object)
{
region * r;
r = (region *) malloc(sizeof(region));
/* NULL pointer check */
r->name = r_name;
r->object = r_object;
return r;
}
void region_free(region * r)
{
switch (r->name)
{
case POINT:
p... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_part.c | #include <errno.h>
#include "matrix_sparse.h"
static void matrix_sparse_part_fprint(FILE * out, const matrix_sparse * a)
{
int i, j;
double k;
for (i = 0; i < a->rows; ++i)
{
for (j = 0; j < a->cols - 1; ++j)
{
k = matrix_sparse_part(a, i, j);
fprintf(out, "%g ", k);
}
k = matrix... |
kipiberbatov/idec | src/array/int_private.h | <filename>src/array/int_private.h
#ifndef INT_PRIVATE_H
#define INT_PRIVATE_H
#include "int.h"
/****************************** int_array_fscan *******************************/
int * int_array_fscan_raw(FILE * in, int n);
#define INT_ARRAY_FSCAN_FORMAT_TOTAL 1
static const char * int_array_fscan_format[INT_ARRAY_FSC... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_product.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include "matrix_sparse.h"
int main(int argc, char * argv[])
{
char * a_format, * a_name, * b_format, * b_name, * out_format;
matrix_sparse * a, * b, * c;
if (argc != 6)
{
errno = EIO;
fputs("main - command-line arguments should be 6 in total", stderr);... |
kipiberbatov/idec | main/mesh/main_mesh_qc_vol.c | #include <stdlib.h>
#include "double.h"
#include "mesh_qc.h"
static void mesh_qc_vol_fprint_raw(FILE * out, const mesh_qc * m)
{
int m_dim, p;
int * m_cn;
double * m_vol_p;
m_dim = m->dim;
m_cn = m->cn;
for(p = 0; p <= m_dim; ++p)
{
m_vol_p = mesh_qc_vol_p(m, p);
/* NULL pointer check */
d... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_laplacian.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "matrix_sparse.h"
int main(int argc, char * argv[])
{
int d;
char * format, * list;
matrix_sparse ** a, ** b;
FILE * in, * out;
out = stdout;
in = stdin;
format = argv[1];
list = argv[2];
d = atoi(argv[3]);
a = ma... |
kipiberbatov/idec | src/algebra/matrix_sparse_free.c | <reponame>kipiberbatov/idec<gh_stars>0
#include <stdlib.h>
#include "matrix_sparse.h"
void matrix_sparse_free(matrix_sparse * a)
{
free(a->values);
free(a->row_indices);
free(a->cols_total);
free(a);
}
void matrix_sparse_free_shared(matrix_sparse * a)
{
free(a->values);
free(a);
}
|
kipiberbatov/idec | src/region/quasi_cube_free.c | <filename>src/region/quasi_cube_free.c
#include <stdlib.h>
#include "quasi_cube.h"
void quasi_cube_free(quasi_cube * s)
{
free(s->coord);
free(s);
}
|
kipiberbatov/idec | src/algebra/matrix_sparse_fprint_matrix_form_raw.c | <gh_stars>0
#include <errno.h>
#include "matrix_sparse_private.h"
void matrix_sparse_fprint_matrix_form_raw(FILE * out, const matrix_sparse * a)
{
int i, j, m, n;
m = a->rows;
n = a->cols;
for (i = 0; i < m; ++i)
{
for(j = 0; j < n - 1; ++ j)
fprintf(out, "%g ", matrix_sparse_part(a, i, j));
... |
kipiberbatov/idec | src/mesh/mesh_brick_cf_a4.c | <reponame>kipiberbatov/idec
#include <string.h>
#include "int.h"
#include "mesh_brick_private.h"
void mesh_brick_cf_a4(int * m_cf_a4, int d, const int * n)
{
int bin_d_p, bin_p_q, h, ind, ind_b, comb_ind, comb_passed,
p, q, u, v, w_ind, w_size, y_ind, y_size;
int a[MAX_DIM], b[MAX_DIM], b_bar[MAX_DIM], b_cop... |
kipiberbatov/idec | include/region/point.h | #ifndef POINT_H
#define POINT_H
typedef struct point
{
double x[2];
} point;
/***************************** memory_management ******************************/
point * point_new(double * p_x);
void point_free(point * p);
/********************************* geometry ***********************************/
double point_m... |
kipiberbatov/idec | src/mesh/mesh_bd_nodes.c | #include <errno.h>
#include <math.h>
#include <stdlib.h>
#include "double.h"
#include "mesh.h"
#define EPSILON 0.00001
static int mesh_bd_nodes_a0(const mesh * m, const double * m_node_curvature)
{
int m_bd_nodes_a0, i, m_cn_0;
m_cn_0 = m->cn[0];
m_bd_nodes_a0 = 0;
for (i = 0; i < m_cn_0; ++i)
if (fabs... |
kipiberbatov/idec | src/algebra/vector_sparse_array_fprint.c | #include "vector_sparse.h"
void vector_sparse_array_fprint(
FILE * out, int a0, vector_sparse ** arr, const char * format)
{
int i;
for (i = 0; i < a0; ++i)
vector_sparse_fprint(out, arr[i], format);
}
|
kipiberbatov/idec | src/mesh/forman_v.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "forman_private.h"
#include "int.h"
static void forman_v_a2(
int * m_forman_v_a2, const mesh * m, int p_f, int q_f, int q, int j,
const jagged2 * m_forman_u, const int * m_forman_v_a1)
{
int ind, k, k_loc, r, r_f, s;
jagged1 m_cf_p... |
kipiberbatov/idec | src/array/jagged1_fprint_curly.c | #include "array_fprint.h"
#include "jagged_private.h"
void jagged1_fprint_curly(FILE * out, const jagged1 * arr)
{
array_fprint1(out, arr->a0, arr->a1);
fputc('\n', out);
}
|
kipiberbatov/idec | src/array/double_matrix_fscan.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double_private.h"
double * double_matrix_fscan(FILE * in, int m, int n, const char * format)
{
int i;
double * a;
for (i = 0; i < DOUBLE_MATRIX_FSCAN_FORMAT_TOTAL; ++i)
if (!strcmp(format, double_matrix_fscan_format[i]))
{
a = ... |
kipiberbatov/idec | src/algebra/matrix_sparse_linear_combination.c | #include <errno.h>
#include "matrix_sparse_private.h"
matrix_sparse * matrix_sparse_linear_combination(
const matrix_sparse * a, const matrix_sparse * b, double alpha, double beta)
{
cs a0, b0;
cs * res0;
matrix_sparse * res = NULL;
matrix_sparse_to_cs(&a0, a);
matrix_sparse_to_cs(&b0, b);
res0 = cs_a... |
kipiberbatov/idec | src/mesh/mesh_qc_cbd_star.c | #include <math.h>
#include <stdlib.h>
#include "mesh_qc.h"
/* q = p - 1 */
static double * mesh_qc_cbd_star_p_x(
const mesh_qc * m, int p, const matrix_sparse * m_bd_p,
const double * m_inner_p, const double * m_inner_q)
{
int i, ind, j, j_loc, m_bd_p_nonzero_max, m_cn_p;
double sign, m_inner_p_i;
double * m... |
kipiberbatov/idec | main/mesh/main_mesh_qc_elasticity_laplacian.c | #include <string.h>
#include "double.h"
#include "mesh_qc.h"
static void mesh_qc_elasticity_laplacian_fprint_raw(
FILE * out, matrix_sparse * m_cbd_0, matrix_sparse * m_cbd_1, matrix_sparse * m_cbd_star_elasticity_1,
matrix_sparse * m_cbd_star_elasticity_2)
{
matrix_sparse * m_laplacian_elasticity_1;
m_lapl... |
kipiberbatov/idec | src/mesh/forman_u.c | <filename>src/mesh/forman_u.c
#include <errno.h>
#include <stdlib.h>
#include "forman_private.h"
#include "int.h"
static void forman_u_a1(int * m_forman_u_a1, const mesh * m,
int p_f, int q_f, int p, int i, int q, int j)
{
int r, r_f;
jagged1 m_cf_part;
jagged1 m_fc_part;
for (r_f = 0;... |
kipiberbatov/idec | src/mesh/mesh_c.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "mesh_private.h"
void mesh_c(int * m_c, int m_dim, const int * m_cn)
{
int i, ind, p;
ind = 0;
for (p = 0; p <= m_dim; ++p)
for (i = 0; i < m_cn[p]; ++i)
{
m_c[ind] = i;
++ind;
}
}
|
kipiberbatov/idec | src/mesh/mesh_qc_metric_corrected.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
// #include "array_indexed.h"
#include "double.h"
#include "int.h"
#include "mesh_qc.h"
static vector_sparse * mesh_qc_metric_corrected_p_i(
int m_cn_0, const jagged1 * m_c_p_i_nodes, int p, int i, double m_vol_p_i,
const double * node_curvatures, const ja... |
kipiberbatov/idec | main/mesh/main_mesh_cbd.c | #include <errno.h>
#include <stdlib.h>
#include "mesh.h"
static void mesh_cbd_fprint(
FILE * out, int m_dim, matrix_sparse ** m_bd, char * format)
{
int p;
matrix_sparse * m_bd_p_plus_1, * m_cbd_p;
for (p = 0; p < m_dim; ++p)
{
m_bd_p_plus_1 = m_bd[p];
m_cbd_p = matrix_sparse_transpose(m_bd_p_plus... |
kipiberbatov/idec | src/algebra/matrix_sparse_laplace_equation_rhs_vector_modify.c | <reponame>kipiberbatov/idec
#include "matrix_sparse.h"
void matrix_sparse_laplace_equation_rhs_vector_modify(
double * b_in, const matrix_sparse * m_laplacian, const jagged1 * m_nodes_in,
const jagged1 * m_nodes_bd, const double * b_bd)
{
int i, i_loc, j, j_loc, m_nodes_bd_a0, nonzeroes_j, position;
int * m_la... |
kipiberbatov/idec | main/mesh/main_mesh_qc_laplace_equation_solve.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double.h"
#include "matrix_sparse.h"
#include "mesh_qc.h"
static double f(const double * x)
{
return - 4;
}
static double g_d(const double * x)
{
return x[0] * x[0] + x[1] * x[1];
}
int main(int argc, char * argv[])
{
char * m_for... |
kipiberbatov/idec | src/algebra/vector_sparse_array_fscan_by_name.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "vector_sparse.h"
vector_sparse ** vector_sparse_array_fscan_by_name(
const char * name, int a0, const char * format)
{
int i;
vector_sparse ** a;
a = (vector_sparse **) malloc(sizeof(vector_sparse *) * a0);
if (errno)
{
perror("vec... |
kipiberbatov/idec | src/algebra/vector_sparse_array_fscan.c | <gh_stars>0
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include "vector_sparse.h"
vector_sparse ** vector_sparse_array_fscan(
FILE * in, int a0, const char * format)
{
int i;
vector_sparse ** arr;
arr = (vector_sparse **) malloc(sizeof(vector_sparse *) * a0);
if (errno)
{
perror("vec... |
kipiberbatov/idec | src/algebra/vector_sparse_fprint_mathematica_sparse.c | <filename>src/algebra/vector_sparse_fprint_mathematica_sparse.c
#include <errno.h>
#include "vector_sparse_private.h"
void vector_sparse_fprint_mathematica_sparse(
FILE * out, const vector_sparse * a)
{
int a_nonzero_max, i, i_loc;
int * a_positions;
double x;
double * a_values;
a_nonzero_max = a->nonze... |
kipiberbatov/idec | src/mesh/forman_cn.c | #include <errno.h>
#include <stdlib.h>
#include "forman_private.h"
#include "int.h"
void forman_cn(int * m_forman_cn, const mesh * m)
{
int m_dim, p_f, q_f;
int * m_cn;
jagged1 m_cfn_p_f_r_f; /* r_f = p_f - q_f */
m_dim = m->dim;
m_cn = m->cn;
/* q_f = 0 */
m_forman_cn[0] = int_array_total_sum(m_di... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.