sd_hist *
sd_hist_new_default(uint32_t nd, uint32_t *vi, double *vd, double t0, double dt)
{
sd_hist *hist;
hist_data *h = NULL, zh = { 0 };
if ((hist = sd_malloc(sizeof(sd_hist))) == NULL
|| (h = hist->ptr = sd_malloc(sizeof(hist_data))) == NULL
|| (*h = zh, (h->nd = nd) < 1)
|| sd_util_uniqi(nd, vi, &(h->nu), &(h->uvi)) != SD_OK
|| (h->del = sd_malloc(sizeof(double) * nd)) == NULL
|| (h->vi = sd_malloc(sizeof(uint32_t) * nd)) == NULL
|| (memcpy(h->del, vd, nd * sizeof(double)),
memcpy(h->vi, vi, nd * sizeof(uint32_t)),
0)
|| setup_buffer_structure(h, dt) != SD_OK
|| (h->buf = sd_malloc(sizeof(double) * h->lim[h->nu])) == NULL
)
{
if (hist != NULL) sd_free(hist);
if (h != NULL)
{
if (h->buf!=NULL) sd_free(h->buf);
if (h->uvi!=NULL) sd_free(h->uvi);
if (h->del!=NULL) sd_free(h->del);
if (h->vi!=NULL) sd_free(h->vi);
}
sd_err("number of delays < 1 or memory alloc failed.");
return NULL;
}
h->dt = dt;
h->t = t0;
*hist = sd_hist_defaults;
hist->ptr = h;
return hist;
}
struct sd_sch *
sd_sch_new_emc(double time, double dt, double lam,
struct sd_sys *sys, struct sd_hist *hist, struct sd_rng *rng)
{
struct data *d, z={0};
uint32_t n_dim = sys->get_n_dim(sys)
, n_in = sys->get_n_in(sys)
, n_out = sys->get_n_out(sys)
;
if ((d = sd_malloc(sizeof(struct data))) == NULL
|| (*d=z, 0)
|| (d->f=sd_malloc(sizeof(double)*n_dim))==NULL
|| (d->g=sd_malloc(sizeof(double)*n_dim))==NULL
|| (d->z=sd_malloc(sizeof(double)*n_dim))==NULL
|| (d->eps=sd_malloc(sizeof(double)*n_dim))==NULL
|| sch_base_init(&d->base,
time, dt,
n_dim, n_in, n_out,
sys, hist, rng,
emc_n_byte, emc_free, emc_copy, emc_apply, &sample) != SD_OK
)
{
if (d->f!=NULL) sd_free(d->f);
if (d->g!=NULL) sd_free(d->g);
if (d->z!=NULL) sd_free(d->z);
if (d->eps!=NULL) sd_free(d->eps);
if (d != NULL) sd_free(d);
sd_err("alloc for emc scheme failed.");
return NULL;
}
d->first_call = true;
d->lam = lam;
d->base.sch.data = d;
return &(d->base.sch);
}
static sd_stat fill(sd_hist *hist, sd_hfill *hf)
{
uint32_t i, j, ui, o, n, *vi;
double *t;
char *errmsg;
hist_data *h = hist->ptr;
errmsg = NULL;
t = NULL;
vi = NULL;
n = h->lim[h->nu];
if ((t = sd_malloc (sizeof(double) * n))==NULL ||
(vi = sd_malloc (sizeof(uint32_t) * n))==NULL) {
errmsg = "failed to allocate memory for evaluating hist fill.";
goto end;
}
/* expand indices per buffer element */
for (i=0; i<h->nu; i++)
{
ui = h->uvi[i];
for (j=h->lim[i]; j<h->lim[i+1]; j++)
vi[j] = ui;
}
/* evaluate time per buffer element */
for (i=0; i<h->nu; i++)
{
for (j=0; j<(h->len[i]-1); j++)
{
o = h->pos[i]; /* current position in buffer */
o += j; /* time step through buffer */
o %= h->len[i]; /* wrap around on section length */
o += h->lim[i]; /* offset to start of section */
t[o] = h->t - j * h->dt;
}
j = h->len[i] - 1;
o = h->pos[i]; /* current position in buffer */
o += j; /* time step through buffer */
o %= h->len[i]; /* wrap around on section length */
o += h->lim[i]; /* offset to start of section */
t[o] = h->t + h->dt; /* last point is next grid point */
}
if (hf->apply(hf, n, t, vi, h->buf) != SD_OK)
errmsg = "history fill function failed.";
end:
if (t!=NULL) sd_free(t);
if (vi!=NULL) sd_free(vi);
return errmsg == NULL ? SD_OK : SD_ERR;
}
static sd_stat setup_buffer_structure(hist_data *h, double dt)
{
uint32_t i, j, ui;
double maxd;
char *errmsg;
/* alloc */
if (
(h->maxd = sd_malloc (sizeof(double) * h->nu))==NULL ||
(h->lim = sd_malloc (sizeof(double) * (h->nu + 1)))==NULL ||
(h->len = sd_malloc (sizeof(double) * h->nu))==NULL ||
(h->pos = sd_malloc (sizeof(double) * h->nu))==NULL
) {
errmsg = "failed to alloc internal storage.";
goto fail;
}
/* vi2i requires max(uvi) then filling in vi2i[ui]=i */
h->maxvi = 0;
for (i=0; i<h->nu; i++)
if (h->uvi[i] > h->maxvi)
h->maxvi = h->uvi[i];
/* alloc */
if ((h->vi2i = sd_malloc (sizeof(uint32_t) * (h->maxvi + 1)))==NULL) {
errmsg = "failed to alloc internal storage.";
goto fail;
}
/* set up vi2i, maxd len pos lim */
for (i=0; i<h->nu; i++)
{
ui = h->uvi[i];
h->vi2i[ui] = i;
maxd = 0.0;
for (j=0; j<h->nd; j++)
if (h->vi[j]==ui && h->del[j]>maxd)
maxd = h->del[j];
h->maxd[i] = maxd;
h->len[i] = (uint32_t) ceil(maxd / dt) + 2;
h->pos[i] = 0;
if (i==0)
h->lim[i] = 0;
else
h->lim[i] = h->lim[i-1] + h->len[i-1];
}
h->lim[h->nu] = h->lim[h->nu-1] + h->len[h->nu-1];
return SD_OK;
fail:
if (h->maxd!=NULL) sd_free(h->maxd);
if (h->lim!=NULL) sd_free(h->lim);
if (h->len!=NULL) sd_free(h->len);
if (h->pos!=NULL) sd_free(h->pos);
if (h->vi2i!=NULL) sd_free(h->vi2i);
sd_err(errmsg);
return SD_ERR;
}
static char *cpstr(char *str)
{
uint32_t nc = strlen(str) + 1;
char *out = sd_malloc(sizeof(char) * nc);
memcpy(out, str, sizeof(char) * nc);
return out;
}
struct sd_sch *
sd_sch_new_cb(
double time, double dt,
struct sd_sys *sys,
struct sd_hist *hist,
struct sd_rng *rng,
void *user_data,
enum sd_stat(*user_apply)(void *))
{
struct data *data;
if ((data = sd_malloc(sizeof(struct data))) == NULL)
{
sd_err("alloc sch cb failed.");
return NULL;
}
sch_base_init(&data->base,
time, dt,
sys->get_n_dim(sys),
sys->get_n_in(sys),
sys->get_n_out(sys),
sys, hist, rng,
&n_byte, &cb_free, ©, &apply);
data->base.sch.data = data;
data->user_data = user_data;
data->user_apply = user_apply;
return &data->base.sch;
}
static struct data *
data_copy(struct data *data)
{
struct data *copy = sd_malloc(sizeof(struct data));
if (copy == NULL)
sd_err("copy rww failed.");
*copy = *data;
return copy;
}
static struct data *data_copy(struct data *data)
{
struct data *copy = sd_malloc(sizeof(struct data));
if (copy == NULL)
{
sd_err("alloc rng copy failed.");
return NULL;
}
memcpy(copy, data, sizeof(struct data));
return copy;
}
int main()
{
int i, j, n, m;
double *g, *z;
time_t tic, toc;
sd_rng *rng = sd_rng_new_default();
n = 10000;
m = 10;
rng->seed(rng, 42);
g = sd_malloc (sizeof(double) * n);
z = sd_malloc (sizeof(double) * n);
for (i=1; i<n; i+=100)
{
for (j=0; j<n; j++) g[i] = 0.0;
/* put i nnz into g */
for (j=0; j<i; j++) g[i] = 1.0;
tic = clock();
for (j=0; j<n; j++)
if (g[j]!=0.0)
g[j] *= rng->norm(rng);
toc = clock();
printf("i=%03d %.3fs\n", i, (double) (toc - tic) / CLOCKS_PER_SEC);
}
tic = clock();
rng->fill_norm(rng, n, z);
for (j=0; j<n; j++)
g[j] *= z[j];
toc = clock();
printf("fill & mult %.3fs\n", (double) (toc - tic) / CLOCKS_PER_SEC);
return 0;
}
struct sd_conn * sd_conn_new_sparse(
uint32_t n_rows,
uint32_t n_cols,
uint32_t n_nonzero,
uint32_t *row_offsets,
uint32_t *col_indices,
double *weights,
double *delays
)
{
struct conn *conn, zero={0};
if ((conn = sd_malloc(sizeof(struct conn))) == NULL
|| (*conn = zero, 0)
|| (conn->row_offsets = sd_malloc(sizeof(uint32_t)*(n_rows + 1))) == NULL
|| (conn->col_indices = sd_malloc(sizeof(uint32_t)*n_nonzero)) == NULL
|| (conn->weights = sd_malloc(sizeof(double)*n_nonzero)) == NULL
|| (conn->delays = sd_malloc(sizeof(double)*n_nonzero)) == NULL
)
{
if (conn->row_offsets!=NULL) sd_free(conn->row_offsets);
if (conn->col_indices!=NULL) sd_free(conn->col_indices);
if (conn->weights!=NULL) sd_free(conn->weights);
if (conn!=NULL) sd_free(conn);
sd_err("alloc conn data failed.");
return NULL;
}
conn->n_row = n_rows;
conn->n_col = n_cols;
conn->nnz = n_nonzero;
memcpy(conn->row_offsets, row_offsets, sizeof(uint32_t) * n_nonzero);
memcpy(conn->col_indices, col_indices, sizeof(uint32_t) * n_nonzero);
memcpy(conn->weights, weights, sizeof(double) * n_nonzero);
memcpy(conn->delays, delays, sizeof(double) * n_nonzero);
conn->delay_scale = 1.0;
conn->sd_conn = sd_conn_defaults;
conn->sd_conn.data = conn;
return &(conn->sd_conn);
}
struct sd_sys_rww *sd_sys_rww_new()
{
struct data *data;
if ((data = sd_malloc(sizeof(struct data)))==NULL)
{
sd_err("alloc sys rww failed.");
return NULL;
}
data->pars = pars_defaults;
data->sd_sys = sd_sys_defaults;
data->sd_sys_rww = sd_sys_rww_defaults;
data->sd_sys.data = data->sd_sys_rww.data = data;
return &data->sd_sys_rww;
}
SD_API struct sd_out *
sd_out_new_until(double time)
{
struct data *data, zero = {0};
if ((data = sd_malloc(sizeof(struct data))) == NULL)
{
sd_err("alloc out until failed.");
return NULL;
}
data->time = time;
data->sd_out = sd_out_defaults;
data->sd_out.data = data;
return &(data->sd_out);
}
struct sd_rng *
sd_rng_new_mt(uint32_t seed)
{
struct data *data;
if ((data = sd_malloc(sizeof(struct data))) == NULL)
{
sd_err("alloc rng failed.");
return NULL;
}
data->seed = seed;
data->sd_rng = sd_rng_defaults;
data->sd_rng.data = data;
sd_rng_mt_seed(seed, &data->rks);
return &data->sd_rng;
}
struct sd_sol *
sd_sol_new_default(double init_time, double *init_state,
struct sd_sch *sch, struct sd_out *out)
{
struct data *data;
if ((data = sd_malloc(sizeof(struct data))) == NULL)
{
sd_err("failed to alloc solver");
return NULL;
}
data->cont = SD_CONT;
data->out = out;
data->sch = sch;
data->sol = sd_sol_defaults;
data->sol.data = data;
return &data->sol;
}
