repo_name stringlengths 5 122 | path stringlengths 3 232 | text stringlengths 6 1.05M |
|---|---|---|
kipiberbatov/idec | src/mesh/mesh_qc_hodge.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include <stdlib.h>
#include "mesh_qc_private.h"
matrix_sparse * mesh_qc_hodge_p(
const mesh_qc * m, matrix_sparse ** m_bd, int p,
const double * m_inner_q, const double * m_coeff_q)
{
int m_hodge_p_nonzero_max, q;
matrix_sparse * m_hodge_p;
q = m->dim - p;
... |
kipiberbatov/idec | src/array/double_sscan.c | #include <errno.h>
#include <stdlib.h>
#include "double.h"
double double_sscan(const char * s)
{
int correct;
double a;
correct = sscanf(s, "%lf", &a);
if (correct <= 0)
{
errno = EINVAL;
if (correct == 0)
fputs("double_sscan - not a valid floating point number\n", stderr);
else
fp... |
kipiberbatov/idec | main/mesh/main_mesh_qc_laplacian.c | #include <errno.h>
#include <string.h>
#include "mesh.h"
int main()
{
mesh * m;
matrix_sparse ** m_bd, ** m_cbd, ** m_cbd_star;
FILE * in, * out;
out = stdout;
in = stdin;
m = mesh_fscan(in, "--raw");
if (errno)
{
fprintf(stderr, "main - cannot scan m\n");
goto end;
}
m_bd = mesh_f... |
kipiberbatov/idec | src/array/jagged1_fprint.c | #include <errno.h>
#include <string.h>
#include "jagged_private.h"
void jagged1_fprint(FILE * out, const jagged1 * arr, const char * format)
{
int i;
for (i = 0; i < JAGGED1_FPRINT_FORMAT_TOTAL; ++i)
if (!strcmp(format, jagged1_fprint_format[i]))
{
jagged1_fprint_function[i](out, arr);
if (e... |
kipiberbatov/idec | main/region/main_simplex.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include "double.h"
#include "simplex.h"
static void simplex_measure_fprint(FILE * out, const simplex * r)
{
double r_area;
r_area = simplex_measure(r);
fprintf(out, "area : %g\n", r_area);
}
static void simplex_centroid_fprint(FILE * out, const simplex * r)
{
d... |
kipiberbatov/idec | src/algebra/matrix_sparse_fprint_annotated.c | #include <errno.h>
#include "matrix_sparse_private.h"
void matrix_sparse_fprint_annotated(FILE * out, const matrix_sparse * a)
{
int ind, j, m, n;
int * a_cols_total, * a_row_indices;
double * a_values;
m = a->rows;
n = a->cols;
a_cols_total = a->cols_total;
a_row_indices = a->row_indices;
a_values ... |
kipiberbatov/idec | src/array/int_sscan.c | <reponame>kipiberbatov/idec<filename>src/array/int_sscan.c
#include <errno.h>
#include <stdlib.h>
#include "int.h"
int int_sscan(const char * s)
{
int a, correct;
correct = sscanf(s, "%d", &a);
if (correct <= 0)
{
errno = EINVAL;
if (correct == 0)
fputs("int_sscan - not a valid integer\n", std... |
kipiberbatov/idec | src/mesh/forman_cell_to_faces.c | <reponame>kipiberbatov/idec<filename>src/mesh/forman_cell_to_faces.c
#include <errno.h>
#include <stdlib.h>
#include "forman_private.h"
#include "int.h"
void forman_cell_to_faces(
int * m_forman_cell_to_faces, const mesh * m, const jagged3 * m_forman_cbi,
const jagged2 * m_forman_fi, const jagged3 * m_forman_si,
... |
kipiberbatov/idec | src/mesh/mesh_qc_cup_product_sign.c | #include "mesh_qc_private.h"
/* r = p + q,
* cc[r, k] = sign * 2^r * (polytope_sum(cc[p, i], cc[q, j])).
* cup_product(cc[p, i], cc[q, j]) = (sign / 2^r) * cc[r, k].
*/
double mesh_qc_cup_product_sign(
matrix_sparse ** m_bd, int node, int p, int i, int q, int j, int r, int k)
{
if (p == 1)
return matrix_spa... |
kipiberbatov/idec | src/algebra/matrix_sparse_part.c | <reponame>kipiberbatov/idec
#include "matrix_sparse.h"
double matrix_sparse_part(const matrix_sparse * a, int i, int j)
{
int i_loc;
int * a_cols_total, * a_row_indices;
double * a_values;
a_cols_total = a->cols_total;
a_row_indices = a->row_indices;
a_values = a->values;
for (i_loc = a_cols_total[j];... |
kipiberbatov/idec | src/algebra/matrix_sparse_linear_solve_cholesky.c | #include <errno.h>
#include <string.h>
#include "matrix_sparse_private.h"
void matrix_sparse_linear_solve_cholesky(const matrix_sparse * a, double * b)
{
int correct;
cs a0;
matrix_sparse_to_cs(&a0, a);
correct = cs_cholsol(1, &a0, b);
if (!correct)
{
errno = EINVAL;
fputs("matrix_sparse_linear_... |
kipiberbatov/idec | src/algebra/matrix_sparse_laplacian.c | #include <errno.h>
#include <stdlib.h>
#include "matrix_sparse.h"
matrix_sparse * matrix_sparse_laplacian_0(
const matrix_sparse * a_0, const matrix_sparse * b_1)
{
matrix_sparse * delta_0;
delta_0 = matrix_sparse_product(b_1, a_0);
if (errno)
{
perror("Cannot product matrices");
matrix_sparse_fre... |
kipiberbatov/idec | src/mesh/mesh_fcn_part.c | <gh_stars>0
#include "mesh.h"
/* it is assumed that (p != q) */
void mesh_fcn_part2(jagged1 * m_fcn_q_p, const mesh * m, int q, int p)
{
jagged3 m_fcn;
m_fcn.a0 = m->fc->a0;
m_fcn.a1 = m->fc->a1;
m_fcn.a2 = m->fc->a2;
m_fcn.a3 = m->fc->a3;
jagged3_part2(m_fcn_q_p, &m_fcn, q, p - q - 1);
}
int mesh_fcn_... |
kipiberbatov/idec | src/mesh/mesh_fscan_bd.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double.h"
#include "mesh.h"
static void mesh_bd_p_cols_total(
int * m_bd_p_cols_total, int m_bd_p_cols, const int * m_cfn_p_q_a1)
{
int i;
m_bd_p_cols_total[0] = 0;
for (i = 0; i < m_bd_p_cols; ++i)
m_bd_p_cols_total[i + 1] = m_bd_p_co... |
kipiberbatov/idec | src/algebra/matrix_sparse_diffusion.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "int.h"
#include "double.h"
#include "matrix_sparse.h"
static matrix_sparse * matrix_sparse_laplacian_dynamic(
const matrix_sparse * laplacian_0, double tau)
{
matrix_sparse * id, * l;
id = matrix_sparse_identity(laplacian_0->cols);
if (err... |
kipiberbatov/idec | src/array/jagged2_part.c | #include "int.h"
#include "jagged.h"
void jagged2_part1(jagged1 * res, const jagged2 * arr, int i1)
{
int p2;
/* if (i1 < 0 || i1 >= arr->a0) error_handle(); */
res->a0 = arr->a1[i1];
p2 = int_array_total_sum(i1, arr->a1);
res->a1 = arr->a2 + p2;
}
int jagged2_part2(const jagged2 * arr, int i1, int i2)
{... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_remove_symmetric.c | #include <errno.h>
#include "jagged.h"
#include "matrix_sparse.h"
int main(int argc, char * argv[])
{
char * a_format, * a_name, * rows_format, * rows_name, * out_format;
FILE * rows_file;
matrix_sparse * a, * b;
jagged1 * rows;
if (argc != 6)
{
errno = EINVAL;
fputs("main - the number of comman... |
kipiberbatov/idec | src/mesh/mesh_qc_bd_layer.c | <gh_stars>0
#include <stdlib.h>
#include "mesh_qc.h"
jagged1 * mesh_qc_bd_layer_0_hyperfaces(const mesh * m)
{
int ind, j, m_dim, m_bd_layer_0_hyperfaces_a0;
int * m_bd_layer_0_hyperfaces_a1;
jagged1 m_hyperfaces_to_cells_sizes;
jagged1 * m_bd_layer_0_hyperfaces;
m_dim = m->dim;
mesh_fcn_part2(&m_hyperf... |
kipiberbatov/idec | main/array/main_int_array_combination.c | <filename>main/array/main_int_array_combination.c
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include "int.h"
static void int_array_combination_fprint(FILE * out, int m, int n)
{
int prod, i;
int * a;
prod = int_binomial(m, n);
a = (int *) malloc(n * sizeof(int));
if (errno)
{
perror(... |
kipiberbatov/idec | main/mesh/main_mesh_qc_metric_corrected.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "mesh_qc.h"
static void mesh_qc_metric_corrected_fprint_only_values(
FILE * out, const mesh_qc * m, double ** m_vol, double * node_curvatures)
{
int m_dim, p;
int * m_cn;
vector_sparse ** m_metric_p;
m_dim = m->dim;
m_cn = m... |
kipiberbatov/idec | src/array/array_indexed_merge_sort.c | #include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "array_indexed.h"
static void update(array_indexed * b, int * i, int * k, const array_indexed * a)
{
b->positions[*k] = a->positions[*i];
b->values[*k] = a->values[*i];
++*i;
++*k;
}
static void array_indexed_merge_sort_ord... |
kipiberbatov/idec | src/region/triangle.c | #include <stdlib.h>
#include <string.h>
#include <math.h>
#include "triangle.h"
triangle * triangle_new(double * p_x0, double * p_x1, double * p_x2)
{
triangle * p;
p = (triangle *) malloc(sizeof(triangle));
/* NULL pointer check */
memcpy(p->x0, p_x0, sizeof(double) * 2);
memcpy(p->x1, p_x1, sizeof(doubl... |
kipiberbatov/idec | src/array/double_array_fscan_raw.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double_private.h"
double * double_array_fscan_raw(FILE * in, int n)
{
int i;
double * a;
a = (double *) malloc(sizeof(double) * n);
if (errno)
{
perror("double_array_fscan_raw - cannot allocate memory for array");
ret... |
kipiberbatov/idec | src/algebra/matrix_sparse_heat_conduction_solve_non_grid.c | #include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "int.h"
#include "matrix_sparse_private.h"
static int int_array_position(int n, const int * a, int element)
{
int i;
for (i = 0; i < n; ++i)
if (element == a[i])
return i;
return -1;
}
static void lhs_restricted_matrix_modify(
ma... |
kipiberbatov/idec | src/array/double_array_fscan_by_name.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double.h"
double * double_array_fscan_by_name(
const char * name, int n, const char * format)
{
FILE * in;
double * a = NULL;
in = fopen(name, "r");
if (errno)
{
fprintf(stderr, "double_array_fscan_by_name - cannot open file %s: %s\n... |
kipiberbatov/idec | src/region/simplex_free.c | #include <stdlib.h>
#include "simplex.h"
void simplex_free(simplex * s)
{
free(s->coord);
free(s);
}
|
kipiberbatov/idec | src/algebra/vector_sparse_free.c | #include <stdlib.h>
#include "vector_sparse.h"
void vector_sparse_free(vector_sparse * a)
{
free(a->values);
free(a->positions);
free(a);
}
|
kipiberbatov/idec | src/mesh/mesh_qc_hodge_p_row_indices.c | <reponame>kipiberbatov/idec
#include <string.h>
#include "mesh_qc_private.h"
static void mesh_qc_hodge_p_row_indices_d(
int * m_hodge_p_row_indices, const mesh * m)
{
int d_exp, i, ind, m_cn_d;
jagged1 m_cf_d_0_i;
jagged2 m_cf_d_0;
m_cn_d = m->cn[m->dim];
d_exp = 1 << m->dim;
mesh_cf_part2(&m_cf_d_0, ... |
kipiberbatov/idec | src/algebra/vector_sparse_rearange.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "array_indexed.h"
#include "double.h"
#include "int.h"
#include "vector_sparse.h"
void vector_sparse_rearange(vector_sparse * b)
{
double * b_values_new;
array_indexed a;
a.positions = (int *) malloc(sizeof(int) * b->nonzero_max);... |
kipiberbatov/idec | main/mesh/main_mesh_qc_bd_layer.c | #include "mesh_qc.h"
void mesh_qc_bd_layer_0_1_nodes_fprint_raw(FILE * out, const mesh * m)
{
jagged1 * m_bd_layer_0_hyperfaces;
jagged1 * m_bd_layer_0_cells;
jagged1 * m_bd_layer_0_1_nodes;
m_bd_layer_0_hyperfaces = mesh_qc_bd_layer_0_hyperfaces(m);
/* NULL pointer check */
// jagged1_fprint_raw(out, m... |
kipiberbatov/idec | main/mesh/main_mesh_bd_nodes.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "mesh.h"
int main(int argc, char * argv[])
{
char * m_format, * m_name, * out_format;
FILE * m_file;
mesh * m;
jagged1 * m_bd_nodes;
if (argc != 4)
{
errno = EINVAL;
fputs("main - the number of command-line arguments must be 4\n... |
kipiberbatov/idec | src/algebra/vector_sparse_fprint_curly.c | <reponame>kipiberbatov/idec<gh_stars>0
#include <errno.h>
#include "vector_sparse_private.h"
void vector_sparse_fprint_curly(FILE * out, const vector_sparse * a)
{
int a_length, i;
a_length = a->length;
fputc('{', out);
for (i = 0; i < a_length - 1; ++i)
{
fprintf(out, "%g,", vector_sparse_part(a, i))... |
kipiberbatov/idec | include/algebra/matrix_sparse.h | <gh_stars>0
#ifndef MATRIX_SPARSE_H
#define MATRIX_SPARSE_H
#include <stdio.h>
#include "jagged.h"
typedef struct matrix_sparse
{
int rows;
int cols;
int * cols_total;
int * row_indices;
double * values;
} matrix_sparse;
double matrix_sparse_part(const matrix_sparse * a, int i, int j);
/******************... |
kipiberbatov/idec | src/region/point.c | #include <stdlib.h>
#include <string.h>
#include "point.h"
point * point_new(double * p_x)
{
point * p;
p = (point *) malloc(sizeof(point));
/* NULL pointer check */
memcpy(p->x, p_x, sizeof(double) * 2);
return p;
}
void point_free(point * p)
{
free(p->x);
free(p);
}
double point_measure(point * p)... |
kipiberbatov/idec | src/region/quasi_cube_centroid.c | #include "double.h"
#include "int.h"
#include "quasi_cube_private.h"
#include "simplex.h"
/* assumes the ordering from mesh_brick() or forman() */
static void quasi_cube_triangulation_simplex_centroid(
double * s_centroid, const quasi_cube * r, const int * r_nodes)
{
simplex s;
double s_coord[24];
s.dim_em... |
kipiberbatov/idec | main/mesh/main_mesh_measure.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "mesh.h"
// static void mesh_measure_fprint_raw(FILE * out, const mesh * 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 =... |
kipiberbatov/idec | main/region/main_region.c | #include "region.h"
int main()
{
return 0;
}
|
kipiberbatov/idec | src/array/double_fscan.c | #include <errno.h>
#include <stdlib.h>
#include "double.h"
double double_fscan(FILE * in)
{
int correct;
double a;
correct = fscanf(in, "%lf", &a);
if (correct <= 0)
{
errno = EINVAL;
if (correct == 0)
perror("double_fscan - not a valid floating point number");
else
perror("double_... |
kipiberbatov/idec | include/array/int.h | #ifndef INT_H
#define INT_H
#include <stdio.h>
/************************************ int *************************************/
int int_fscan(FILE * in);
int int_sscan(const char * s);
int int_power(int a, int n);
int int_factorial(int n);
int int_binomial(int n, int k);
void int_swap(int * a, int * b);
/******... |
kipiberbatov/idec | src/array/jagged4_part.c | <filename>src/array/jagged4_part.c<gh_stars>0
#include "int.h"
#include "jagged.h"
void jagged4_part1(jagged3 * res, const jagged4 * arr, int i1)
{
int p2, p3, p4;
/* if (i1 < 0 || i1 >= arr->a0) error_handle(); */
res->a0 = arr->a1[i1];
p2 = int_array_total_sum(i1, arr->a1);
res->a1 = arr->a2 + p2;
p3 ... |
kipiberbatov/idec | src/array/int_array_fscan_raw.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "int_private.h"
int * int_array_fscan_raw(FILE * in, int n)
{
int i;
int * a;
a = (int *) malloc(sizeof(int) * n);
if (errno)
{
perror("int_array_fscan_raw - cannot allocate memory for array");
return NULL;
}
for (i = 0; i < n... |
kipiberbatov/idec | src/mesh/forman_coord.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "forman.h"
#include "mesh_private.h"
#include "simplex.h"
#include "quasi_cube.h"
/* finds the centroids of a simplicial mesh or of a quasi-cubical mesh */
/* m_forman_coord is set to zero initially */
void forman_coord(double * m_forman_coord, const ... |
kipiberbatov/idec | src/algebra/matrix_sparse_fprint.c | <reponame>kipiberbatov/idec<filename>src/algebra/matrix_sparse_fprint.c<gh_stars>0
#include <errno.h>
#include <string.h>
#include "matrix_sparse_private.h"
void matrix_sparse_fprint(
FILE * out, const matrix_sparse * a, const char * format)
{
int i;
for (i = 0; i < MATRIX_SPARSE_FPRINT_FORMAT_TOTAL; ++i)
... |
kipiberbatov/idec | src/array/jagged1_free.c | #include <stdlib.h>
#include "jagged.h"
void jagged1_free(jagged1 * arr)
{
free(arr->a1);
free(arr);
}
|
kipiberbatov/idec | src/array/jagged1_part.c | <gh_stars>0
#include "jagged.h"
int jagged1_part1(const jagged1 * arr, int i1)
{
/* if (i1 < 0 || i1 >= arr->a0) error_handle(); */
return arr->a1[i1];
}
|
kipiberbatov/idec | src/algebra/matrix_sparse_fprint_raw.c | #include <errno.h>
#include "double.h"
#include "int.h"
#include "matrix_sparse_private.h"
void matrix_sparse_fprint_raw(FILE * out, const matrix_sparse * a)
{
int n, nonzero_max;
n = a->cols;
nonzero_max = a->cols_total[n];
fprintf(out, "%d\n", a->rows);
fprintf(out, "%d\n", n);
int_array_fprint(out, (... |
kipiberbatov/idec | src/mesh/mesh_brick_cf_a3.c | #include "int.h"
#include "mesh_brick_private.h"
void mesh_brick_cf_a3(int * m_cf_a3, int m_dim, const int * m_cn)
{
int i, ind, m_cn_p, m_cfn_p_q, p, q, r;
ind = 0;
for (p = 1; p <= m_dim; ++p)
{
m_cn_p = m_cn[p];
for (q = 0; q < p; ++q)
{
r = p - q;
m_cfn_p_q = (1 << r) * int_binom... |
kipiberbatov/idec | src/array/jagged4_free.c | <filename>src/array/jagged4_free.c
#include <stdlib.h>
#include "jagged.h"
void jagged4_free(jagged4 * arr)
{
free(arr->a4);
free(arr->a3);
free(arr->a2);
free(arr->a1);
free(arr);
}
|
kipiberbatov/idec | src/algebra/vector_sparse_array2_fscan_by_name.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "vector_sparse.h"
vector_sparse *** vector_sparse_array2_fscan_by_name(
const char * name, int a0, const int * a1, const char * format)
{
int i;
vector_sparse *** a;
a = (vector_sparse ***) malloc(sizeof(vector_sparse **) * a0);
if (errno... |
kipiberbatov/idec | src/algebra/matrix_sparse_fprint_mathematica_sparse.c | #include <errno.h>
#include "matrix_sparse_private.h"
void matrix_sparse_fprint_mathematica_sparse(
FILE * out, const matrix_sparse * a)
{
int i, i_loc, j, m, n;
int * a_cols_total, * a_row_indices;
double x;
double * a_values;
m = a->rows;
n = a->cols;
a_cols_total = a->cols_total;
a_row_indices ... |
kipiberbatov/idec | main/mesh/main_mesh_qc_metric.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double.h"
#include "mesh_qc.h"
static void mesh_qc_metric_fprint_only_values(
FILE * out, const mesh_qc * m, double ** m_vol)
{
int m_dim, p;
int * m_cn;
vector_sparse ** m_metric_p;
m_dim = m->dim;
m_cn = m->cn;
for (... |
kipiberbatov/idec | src/algebra/matrix_sparse_fscan_raw.c | #include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "int.h"
#include "matrix_sparse_private.h"
static int matrix_sparse_cols_total_possible(
int m, int n, const int * a_cols_total)
{
int i;
if (a_cols_total[0] != 0)
return 0;
if (a_cols_total[n] > m * n)
return 0;
for (i = 0; i < n... |
kipiberbatov/idec | src/mesh/mesh_fprint.c | #include <errno.h>
#include <string.h>
#include "mesh_private.h"
void mesh_fprint(FILE * out, const mesh * m, const char * format)
{
int i;
for (i = 0; i < MESH_FPRINT_FORMAT_TOTAL; ++i)
if (!strcmp(format, mesh_fprint_format[i]))
{
mesh_fprint_function[i](out, m);
if (errno)
{
... |
kipiberbatov/idec | src/array/jagged_private.h | <reponame>kipiberbatov/idec<filename>src/array/jagged_private.h
#ifndef JAGGED_PRIVATE_H
#define JAGGED_PRIVATE_H
#include "jagged.h"
/******************************************************************************/
/* jagged1 */
/*********************... |
kipiberbatov/idec | src/mesh/mesh_qc_vol.c | <filename>src/mesh/mesh_qc_vol.c
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "mesh_private.h"
#include "mesh_qc.h"
static double mesh_qc_vol_p_i(const jagged2 * m_cf_p_0, int m_dim_embedded,
double * m_coord, int p, int i)
{
double s_coord[24]; /* m_dim_embeddded... |
kipiberbatov/idec | src/array/int_array2_free.c | <reponame>kipiberbatov/idec<filename>src/array/int_array2_free.c<gh_stars>0
#include <stdlib.h>
#include "int.h"
void int_array2_free(int ** arr, int a0)
{
int p;
for (p = a0 - 1; p >= 0; --p)
free(arr[p]);
free(arr);
}
|
kipiberbatov/idec | src/mesh/mesh_fscan.c | #include <errno.h>
#include <string.h>
#include "mesh_private.h"
mesh * mesh_fscan(FILE * in, const char * format)
{
int i;
mesh * m;
for (i = 0; i < MESH_FSCAN_FORMAT_TOTAL; ++i)
if (!strcmp(format, mesh_fscan_format[i]))
{
m = mesh_fscan_function[i](in);
if (errno)
{
fputs(... |
kipiberbatov/idec | include/mesh/mesh_qc.h | <reponame>kipiberbatov/idec
#ifndef MESH_QC_H
#define MESH_QC_H
#include "mesh.h"
#include "quasi_cube.h"
typedef mesh mesh_qc;
/******************************** mesh_qc_vol *********************************/
double * mesh_qc_vol_p(const mesh_qc * m, int p);
double ** mesh_qc_vol(const mesh_qc * m);
/**************... |
kipiberbatov/idec | src/mesh/mesh_qc_hodge_codifferential.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "mesh.h"
matrix_sparse * mesh_qc_hodge_codifferential_p(
int m_dim, int p, const matrix_sparse * m_cbd_m_dim_minus_p,
matrix_sparse ** m_hodge)
{
matrix_sparse * tmp, * m_hodge_codifferential_p;
tmp = matrix_sparse_product(m_cbd_m_dim_minus_p, m_ho... |
kipiberbatov/idec | src/mesh/mesh_free.c | #include <stdlib.h>
#include "mesh.h"
void mesh_free(mesh * m)
{
if (m->coord)
free(m->coord);
if (m->fc)
jagged4_free(m->fc);
if (m->cf)
jagged4_free(m->cf);
if (m->c)
free(m->c);
if (m->cn)
free(m->cn);
if (m)
free(m);
}
|
kipiberbatov/idec | src/mesh/forman_si.c | <filename>src/mesh/forman_si.c<gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "forman_private.h"
#include "int.h"
static void forman_si_a1(int * m_forman_si_a1, int m_dim)
{
int r;
for (r = 0; r <= m_dim; ++r)
m_forman_si_a1[r] = r + 1;
}
static void forman_si_a2(
int * m_forman_si_a2, int m_... |
kipiberbatov/idec | src/array/int_fscan.c | #include <errno.h>
#include <stdlib.h>
#include "int.h"
int int_fscan(FILE * in)
{
int a, correct;
correct = fscanf(in, "%d", &a);
if (correct <= 0)
{
errno = EINVAL;
if (correct == 0)
fputs("int_fscan - not a valid integer\n", stderr);
else
fputs("int_fscan - there is no number to s... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_transpose.c | #include <errno.h>
#include <stdlib.h>
#include "matrix_sparse.h"
static void matrix_sparse_transpose_fprint(
FILE * out, const char * a_name, const char * a_format,
const char * out_format)
{
matrix_sparse * a, * b;
a = matrix_sparse_fscan_by_name(a_name, a_format);
if (errno)
{
perror("Cannot scan t... |
kipiberbatov/idec | src/array/jagged4_fprint_curly.c | <reponame>kipiberbatov/idec<gh_stars>0
#include "array_fprint.h"
#include "jagged_private.h"
void jagged4_fprint_curly(FILE * out, const jagged4 * arr)
{
array_fprint4(out, arr->a0, arr->a1, arr->a2, arr->a3, arr->a4);
fputc('\n', out);
}
|
kipiberbatov/idec | src/array/double_array2_free.c | #include <stdlib.h>
#include "double.h"
void double_array2_free(double ** arr, int n)
{
int p;
for (p = n - 1; p >= 0; --p)
free(arr[p]);
free(arr);
}
|
kipiberbatov/idec | src/array/double_matrix_fscan_raw.c | <filename>src/array/double_matrix_fscan_raw.c
#include <errno.h>
#include <stdlib.h>
#include "double_private.h"
double * double_matrix_fscan_raw(FILE * in, int m, int n)
{
double * a;
a = double_array_fscan(in, m * n, "--raw");
if (errno)
{
perror("double_matrix_fscan_raw - cannot scan a");
return... |
kipiberbatov/idec | src/region/simplex_fscan.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "int.h"
#include "simplex.h"
simplex * simplex_fscan(FILE * in)
{
simplex * s;
s = (simplex *) malloc(sizeof(simplex));
if (errno)
{
fputs("simplex_fscan - cannot allocate memory for s\n", stderr);
goto end;
}
s->... |
kipiberbatov/idec | src/algebra/vector_sparse_fscan_raw.c | <filename>src/algebra/vector_sparse_fscan_raw.c
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "int.h"
#include "vector_sparse_private.h"
static int all_values_in_range(
int a_length, int a_nonzero_max, const int * a_positions)
{
int i;
for (i = 0; i < a_nonzero_max; ++i)
if (a_positi... |
kipiberbatov/idec | src/region/quasi_cube_private.h | #ifndef QUASI_CUBE_PRIVATE_H
#define QUASI_CUBE_PRIVATE_H
#include "quasi_cube.h"
static const int r_triangulation_nodes_0[1] = {0};
static const int r_triangulation_nodes_1[2] = {0, 1};
static const int r_triangulation_nodes_2[6] =
{0, 1, 3,
0, 2, 3};
static const int r_triangulation_nodes_3[24] =
{0, 1,... |
kipiberbatov/idec | src/mesh/forman_bd.c | <filename>src/mesh/forman_bd.c
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include "forman_private.h"
#include "int.h"
static double * forman_bd_x(
const mesh * m_forman, matrix_sparse ** m_bd,
int m_forman_bd_p_f_nzmax, const jagged3 * m_forman_cbi, int p_f)
{
int i, i_f, ind, j, j_f, j_f_loc, k,... |
kipiberbatov/idec | src/algebra/vector_sparse_private.h | <reponame>kipiberbatov/idec
#ifndef VECTOR_SPARSE_PRIVATE_H
#define VECTOR_SPARSE_PRIVATE_H
#include "vector_sparse.h"
#include "cs.h"
/**************************** vector_sparse_wrapper ***************************/
void vector_sparse_to_cs(cs * a0, const vector_sparse * a);
void vector_sparse_from_cs(vector_sparse *... |
kipiberbatov/idec | src/mesh/mesh_brick.c | #include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "mesh_brick_private.h"
#include "mesh_private.h"
mesh * mesh_brick(int d, const double * brick_lengths, const int * n)
{
int m_c_size;
mesh * m;
if (d > MAX_DIM)
{
errno = EINVAL;
fputs("mesh_brick - dimension is too big\n", stderr);
... |
kipiberbatov/idec | main/algebra/main_matrix_sparse_linear_solve.c | #include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "matrix_sparse.h"
static void matrix_sparse_linear_solve_fprint(
FILE * out, const char * a_name, const char * a_format, const char * b_name,
const char * method)
{
matrix_sparse * a;
double * b;
FILE * b_in;
a = matrix_sparse_fscan_by_na... |
kipiberbatov/idec | src/algebra/matrix_sparse_remove.c | #include <errno.h>
#include <stdlib.h>
#include "matrix_sparse.h"
// static int jagged1_sorted_intersection_length(
// const jagged1 * arr1, const jagged1 * arr2)
// {
// int i, j, res;
//
// i = 0; j = 0; res = 0;
// while (i < arr1->a0 && j < arr2->a0)
// {
// if (arr1->a1[i] < arr2->a1[j])
// ++... |
kipiberbatov/idec | src/algebra/matrix_sparse_laplace_equation_solve.c | #include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "matrix_sparse_private.h"
static void dirichlet_bc_apply(
double * b_bd, int m_dim_embedded, const double * m_coord,
const jagged1 * m_nodes_bd, scalar_field g_d)
{
int j, j_loc, m_nodes_bd_a0;
int * m_nodes_bd_a1;
m_nodes_bd_a0 = m_nodes... |
kipiberbatov/idec | src/mesh/mesh_cell_coord.c | #include <string.h>
#include "mesh_private.h"
void mesh_cell_coord(
double * s_coord, const jagged1 * m_cf_p_0_i,
int m_dim_embedded, const double * m_coord)
{
int m_cf_p_0_i_a0, j_loc, tmp1, tmp2;
int * m_cf_p_0_i_a1;
m_cf_p_0_i_a0 = m_cf_p_0_i->a0;
m_cf_p_0_i_a1 = m_cf_p_0_i->a1;
for (j_loc = 0; j_lo... |
kipiberbatov/idec | src/algebra/vector_sparse_part.c | #include "vector_sparse.h"
double vector_sparse_part(const vector_sparse * a, int i)
{
int a_nonzero_max, i_loc;
int * a_positions;
double * a_values;
a_nonzero_max = a->nonzero_max;
a_positions = a->positions;
a_values = a->values;
for (i_loc = 0; i_loc < a_nonzero_max; ++i_loc)
if (a_positions[i... |
kipiberbatov/idec | src/array/double_array_fprint_curly.c | #include "double_private.h"
void double_array_fprint_curly(FILE * out, int n, const double * a)
{
int i;
fputc('{', out);
for (i = 0; i < n - 1; ++i)
fprintf(out, "%g,", a[i]);
if (n)
fprintf(out, "%g", a[i]);
fputc('}', out);
}
|
kipiberbatov/idec | src/mesh/mesh_fscan_by_name.c | <filename>src/mesh/mesh_fscan_by_name.c
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "mesh.h"
mesh * mesh_fscan_by_name(const char * name, const char * format)
{
FILE * in;
mesh * a = NULL;
in = fopen(name, "r");
if (errno)
{
fprintf(stderr, "mesh_fscan_by_name - cannot open file ... |
kipiberbatov/idec | src/algebra/vector_sparse_fprint_annotated.c | #include "double.h"
#include "int.h"
#include "vector_sparse_private.h"
void vector_sparse_fprint_annotated(FILE * out, const vector_sparse * a)
{
int a_nonzero_max, i;
int * a_positions;
double * a_values;
a_nonzero_max = a->nonzero_max;
a_positions = a->positions;
a_values = a->values;
for (i = 0; i... |
kipiberbatov/idec | src/region/quasi_cube_set.c | #include "quasi_cube.h"
void quasi_cube_set(
quasi_cube * 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 | src/array/double_array.c | <reponame>kipiberbatov/idec<filename>src/array/double_array.c
#include <math.h>
#include "double.h"
void double_array_assign_identity(double * a, int n)
{
int i;
for (i = 0; i < n; ++i)
a[i] = i;
}
void double_array_assign_constant(double * a, int n, double c)
{
int i;
for (i = 0; i < n; ++i)
a[... |
kipiberbatov/idec | main/mesh/main_mesh_qc_integrate.c | #include "mesh_qc.h"
int main()
{
//mesh_qc_integrate_fprint_fscan(stdout, stdin);
return 0;
}
|
kipiberbatov/idec | src/mesh/mesh_brick_regular.c | <gh_stars>0
#include <errno.h>
#include "double.h"
#include "int.h"
#include "mesh_brick.h"
mesh * mesh_brick_regular(int d, int n)
{
int n_list[MAX_DIM];
double brick_lengths[MAX_DIM];
mesh * m;
int_array_assign_constant(n_list, d, n);
double_array_assign_constant(brick_lengths, d, 1.);
m = mesh_brick(... |
kipiberbatov/idec | main/mesh/main_mesh_qc_hodge.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "mesh_qc.h"
static void mesh_qc_hodge_fprint_raw(
FILE * out, const mesh_qc * m, matrix_sparse ** m_bd,
double ** m_inner, double ** m_coeff)
{
int m_dim, p, q;
matrix_sparse * m_hodge_p;
m_dim = m->dim;
for ... |
kipiberbatov/idec | src/array/double_array_fprint.c | <gh_stars>0
#include <errno.h>
#include <string.h>
#include "double_private.h"
void double_array_fprint(
FILE * out, int n, const double * a, const char * format)
{
int i;
for (i = 0; i < DOUBLE_ARRAY_FPRINT_FORMAT_TOTAL; ++i)
if (!strcmp(format, double_array_fprint_format[i]))
{
double_array_fp... |
kipiberbatov/idec | src/algebra/matrix_sparse_constrained_solve_cholesky.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double.h"
#include "int.h"
#include "matrix_sparse.h"
// static double * double_array_restrict(
// int m, const double * b, const jagged1 * rows_complement)
// {
// double * b_restrict;
// int i, i_loc;
//
// b_restrict = (double *) malloc(si... |
kipiberbatov/idec | src/array/jagged2_free.c | #include <stdlib.h>
#include "jagged.h"
void jagged2_free(jagged2 * arr)
{
free(arr->a2);
free(arr->a1);
free(arr);
}
|
kipiberbatov/idec | main/algebra/main_matrix_sparse_laplacian_symmetric.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double.h"
#include "int.h"
#include "matrix_sparse.h"
int main(int argc, char * argv[])
{
char * m_inner_format, * m_inner_name, * m_laplacian_format,
* m_laplacian_name, * out_format;
int d, p;
int * m_cn;
double ** m_inner;
matrix_... |
kipiberbatov/idec | src/array/double_matrix_fprint_raw.c | <filename>src/array/double_matrix_fprint_raw.c<gh_stars>0
#include "double_private.h"
void double_matrix_fprint_raw(FILE * out, int m, int n, const double * a)
{
int i, ind;
ind = 0;
for (i = 0; i < m; ++i)
{
double_array_fprint(out, n, a + ind, "--raw");
ind += n;
}
}
|
kipiberbatov/idec | main/mesh/main_mesh_qc_hodge_codifferential.c | <gh_stars>0
#include <errno.h>
#include "double.h"
#include "mesh_qc.h"
/* if only one hodge star is needed */
// static void mesh_qc_hodge_codifferential_p_fprint(
// FILE * out, int m_dim, int p, const matrix_sparse * m_cbd_m_dim_minus_p, matrix_sparse ** m_hodge)
// {
// matrix_sparse * m_hodge_codifferential_... |
kipiberbatov/idec | src/algebra/vector_sparse_fprint_only_values.c | <filename>src/algebra/vector_sparse_fprint_only_values.c
#include "double.h"
#include "int.h"
#include "vector_sparse_private.h"
void vector_sparse_fprint_only_values(FILE * out, const vector_sparse * a)
{
double_array_fprint(out, a->nonzero_max, a->values, "--raw");
}
|
kipiberbatov/idec | main/mesh/main_mesh_brick.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "mesh_brick.h"
static void mesh_brick_fprint_raw(
FILE * out, int d, const double * brick_lengths, const int * n)
{
int p;
int m_bd_sizes[MAX_DIM];
mesh * m;
int ** m_bd;
m = mesh_brick(d, brick_lengths, n);
if (errno)
{
... |
kipiberbatov/idec | main/mesh/main_mesh_qc_inner.c | #include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "mesh_qc.h"
#include "vector_sparse.h"
static void mesh_qc_inner_fprint_raw(
FILE * out, const mesh_qc * m,
const double * m_vol_d, vector_sparse *** m_metric)
{
int m_dim, p;
int * m_cn;
double * m_inner_p;
m_dim = m->dim;
m_cn = m->... |
kipiberbatov/idec | main/mesh/main_mesh_node_curvature.c | <reponame>kipiberbatov/idec
#include <stdlib.h>
#include "double.h"
#include "mesh.h"
static void mesh_node_curvature_fprint_raw(FILE * out, const mesh * m)
{
double * res;
res = mesh_node_curvature(m);
/* NULL pointer check */
double_array_fprint(out, m->cn[0], res, "--raw");
/* NULL pointer check */
fre... |
kipiberbatov/idec | src/array/double_array2_fscan_raw.c | #include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "double_private.h"
double ** double_array2_fscan_raw(FILE * in, int a0, const int * a1)
{
int i;
double ** a;
a = (double **) malloc(sizeof(double *) * a0);
if (errno)
{
perror("double_array2_fscan_raw - cannot allocate memory for a"... |
kipiberbatov/idec | src/region/quasi_cube_private.c | <reponame>kipiberbatov/idec
#include "int.h"
#include "simplex.h"
#include "quasi_cube_private.h"
/* assumes the ordering from mesh_brick() or forman() */
void quasi_cube_triangulation_node_set(
double * s_coord, const quasi_cube * r, int s_node, int r_node)
{
int r_dim_embedded, r_ind, s_ind, t;
double * r_coor... |
kipiberbatov/idec | src/array/jagged2_fprint_raw.c | <filename>src/array/jagged2_fprint_raw.c
#include "int.h"
#include "jagged_private.h"
void jagged2_fprint_raw(FILE * out, const jagged2 * arr)
{
int arr_a2_size;
fprintf(out, "%d\n", arr->a0);
int_array_fprint(out, arr->a0, arr->a1, "--raw");
arr_a2_size = int_array_total_sum(arr->a0, arr->a1);
int_array_... |
kipiberbatov/idec | src/mesh/mesh_brick_coord.c | <reponame>kipiberbatov/idec
#include <errno.h>
#include <stdlib.h>
#include "int.h"
#include "mesh_brick_private.h"
void mesh_brick_coord(double * m_coord, int m_dim,
const double * brick_lengths, const int * n)
{
int cells_ind, cells_total, ind, p;
int cells[MAX_DIM], n_bar[MAX_DIM];
doub... |
kipiberbatov/idec | src/mesh/mesh_qc_inner.c | <gh_stars>0
#include <errno.h>
#include <stdlib.h>
#include "double.h"
#include "mesh_qc.h"
#include "vector_sparse.h"
double * mesh_qc_inner_p(const mesh_qc * m, const double * m_vol_d,
int p, vector_sparse ** m_metric_p)
{
int i, m_cn_p;
double * m_inner_p;
m_cn_p = m->cn[p];
m... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.