void reset()
{
tottri = 0;
curface = 0;
offset = 0;
maxsize = 0;
/* initialize tottri */
for (int i = 0; i < input_mesh->totface; i++)
tottri += GET_FACE(input_mesh, i)[3] ? 2 : 1;
veccopy(min, input_mesh->min);
veccopy(max, input_mesh->max);
/* initialize maxsize */
for (int i = 0; i < 3; i++) {
float d = max[i] - min[i];
if (d > maxsize)
maxsize = d;
}
/* redo the bounds */
for (int i = 0; i < 3; i++)
{
min[i] = (max[i] + min[i]) / 2 - maxsize / 2;
max[i] = (max[i] + min[i]) / 2 + maxsize / 2;
}
for (int i = 0; i < 3; i++)
min[i] -= maxsize * (1 / scale - 1) / 2;
maxsize *= 1 / scale;
}
void crf1dc_partial_marginals(crf1d_context_t *ctx, int *mask)
{
int i, j, t;
int *prev_mask, *curr_mask;
const int T = ctx->num_items;
const int L = ctx->num_labels;
/*
Compute the model expectations of states.
p(t,i) = fwd[t][i] * bwd[t][i] / norm
= (1. / C[t]) * fwd'[t][i] * bwd'[t][i]
*/
for (t = 0;t < T;++t) {
curr_mask = &mask[t* L];
floatval_t *fwd = PARTIAL_ALPHA_SCORE(ctx, t);
floatval_t *bwd = PARTIAL_BETA_SCORE(ctx, t);
floatval_t *prob = PARTIAL_STATE_MEXP(ctx, t);
veccopy(prob, fwd, L);
vecmul(prob, bwd, L);
vecscale(prob, 1. / ctx->partial_scale_factor[t], L);
}
/*
Compute the model expectations of transitions.
p(t,i,t+1,j)
= fwd[t][i] * edge[i][j] * state[t+1][j] * bwd[t+1][j] / norm
= (fwd'[t][i] / (C[0] ... C[t])) * edge[i][j] * state[t+1][j] * (bwd'[t+1][j] / (C[t+1] ... C[T-1])) * (C[0] * ... * C[T-1])
= fwd'[t][i] * edge[i][j] * state[t+1][j] * bwd'[t+1][j]
The model expectation of a transition (i -> j) is the sum of the marginal
probabilities p(t,i,t+1,j) over t.
*/
for (t = 0;t < T-1;++t) {
floatval_t *fwd = PARTIAL_ALPHA_SCORE(ctx, t);
floatval_t *state = EXP_STATE_SCORE(ctx, t+1);
floatval_t *bwd = PARTIAL_BETA_SCORE(ctx, t+1);
floatval_t *row = ctx->row;
/* row[j] = state[t+1][j] * bwd'[t+1][j] */
veccopy(row, bwd, L);
vecmul(row, state, L);
prev_mask = &mask[t*L];
curr_mask = &mask[(t+1)*L];
for (i = 0;i < L;++i) {
if (prev_mask[i]) {
floatval_t *edge = EXP_TRANS_SCORE(ctx, i);
floatval_t *prob = PARTIAL_TRANS_MEXP(ctx, i);
for (j = 0;j < L;++j) {
if (curr_mask[j]) {
prob[j] += fwd[i] * edge[j] * row[j];
// fprintf(stderr, "%lf\n", fwd[i] * edge[j] * row[j]);
}
}
}
}
}
}
void crf1dc_marginals(crf1d_context_t* ctx)
{
int i, j, t;
const int T = ctx->num_items;
const int L = ctx->num_labels;
/*
Compute the model expectations of states.
p(t,i) = fwd[t][i] * bwd[t][i] / norm
= (1. / C[t]) * fwd'[t][i] * bwd'[t][i]
*/
for (t = 0;t < T;++t) {
floatval_t *fwd = ALPHA_SCORE(ctx, t);
floatval_t *bwd = BETA_SCORE(ctx, t);
floatval_t *prob = STATE_MEXP(ctx, t);
veccopy(prob, fwd, L);
vecmul(prob, bwd, L);
vecscale(prob, 1. / ctx->scale_factor[t], L);
}
/*
Compute the model expectations of transitions.
p(t,i,t+1,j)
= fwd[t][i] * edge[i][j] * state[t+1][j] * bwd[t+1][j] / norm
= (fwd'[t][i] / (C[0] ... C[t])) * edge[i][j] * state[t+1][j] * (bwd'[t+1][j] / (C[t+1] ... C[T-1])) * (C[0] * ... * C[T-1])
= fwd'[t][i] * edge[i][j] * state[t+1][j] * bwd'[t+1][j]
The model expectation of a transition (i -> j) is the sum of the marginal
probabilities p(t,i,t+1,j) over t.
*/
for (t = 0;t < T-1;++t) {
floatval_t *fwd = ALPHA_SCORE(ctx, t);
floatval_t *state = EXP_STATE_SCORE(ctx, t+1);
floatval_t *bwd = BETA_SCORE(ctx, t+1);
floatval_t *row = ctx->row;
/* row[j] = state[t+1][j] * bwd'[t+1][j] */
veccopy(row, bwd, L);
vecmul(row, state, L);
for (i = 0;i < L;++i) {
floatval_t *edge = EXP_TRANS_SCORE(ctx, i);
floatval_t *prob = TRANS_MEXP(ctx, i);
for (j = 0;j < L;++j) {
prob[j] += fwd[i] * edge[j] * row[j];
}
}
}
}
void crf1dc_exp_transition(crf1d_context_t* ctx)
{
const int L = ctx->num_labels;
veccopy(ctx->exp_trans, ctx->trans, L * L);
vecexp(ctx->exp_trans, L * L);
}
void crf1dc_beta_score(crf1d_context_t* ctx)
{
int i, t;
floatval_t *cur = NULL;
floatval_t *row = ctx->row;
const floatval_t *next = NULL, *state = NULL, *trans = NULL;
const int T = ctx->num_items;
const int L = ctx->num_labels;
const floatval_t *scale = &ctx->scale_factor[T-1];
/* Compute the beta scores at (T-1, *). */
cur = BETA_SCORE(ctx, T-1);
vecset(cur, *scale, L);
--scale;
/* Compute the beta scores at (t, *). */
for (t = T-2;0 <= t;--t) {
cur = BETA_SCORE(ctx, t);
next = BETA_SCORE(ctx, t+1);
state = EXP_STATE_SCORE(ctx, t+1);
veccopy(row, next, L);
vecmul(row, state, L);
/* Compute the beta score at (t, i). */
for (i = 0;i < L;++i) {
trans = EXP_TRANS_SCORE(ctx, i);
cur[i] = vecdot(trans, row, L);
}
vecscale(cur, *scale, L);
--scale;
}
}
void crf1dc_exp_state(crf1d_context_t* ctx)
{
const int T = ctx->num_items;
const int L = ctx->num_labels;
veccopy(ctx->exp_state, ctx->state, L * T);
vecexp(ctx->exp_state, L * T);
}
void crf1dc_partial_beta_score(crf1d_context_t* ctx, int *mask)
{
int i, j, t;
int *curr_mask, *next_mask;
floatval_t *cur = NULL;
floatval_t *row = ctx->row;
const floatval_t *next = NULL, *state = NULL, *trans = NULL;
const int T = ctx->num_items;
const int L = ctx->num_labels;
const floatval_t *scale = &ctx->partial_scale_factor[T-1];
/* Compute the beta scores at (T-1, *). */
cur = PARTIAL_BETA_SCORE(ctx, T-1);
veczero(cur, L);
curr_mask = &mask[(T-1)*L];
for (i = 0; i < L; ++ i) {
if (curr_mask[i]) {
cur[i] = *scale;
}
}
--scale;
/* Compute the beta scores at (t, *). */
for (t = T-2;0 <= t;--t) {
cur = PARTIAL_BETA_SCORE(ctx, t);
next = PARTIAL_BETA_SCORE(ctx, t+1);
state = EXP_STATE_SCORE(ctx, t+1);
curr_mask = &mask[t * L];
next_mask = &mask[(t+1) * L];
veccopy(row, next, L);
veczero(cur, L);
for (i = 0; i < L; ++ i) {
if (next_mask[i]) {
row[i] *= state[i];
}
}
for (j = 0; j < L; ++ j) {
if (curr_mask[j]) {
trans = EXP_TRANS_SCORE(ctx, j);
for (i = 0; i < L; ++ i) {
if (next_mask[i]) {
cur[j] += trans[i] * row[i];
}
}
}
}
vecscale(cur, *scale, L);
--scale;
}
}
static int bnode_merge_nodes(struct sb *sb, struct bnode *into,
struct bnode *from)
{
unsigned into_count = bcount(into), from_count = bcount(from);
if (from_count + into_count > sb->entries_per_node)
return 0;
veccopy(&into->entries[into_count], from->entries, from_count);
into->count = cpu_to_be32(into_count + from_count);
return 1;
}
static tuxkey_t ileaf_split(struct btree *btree, tuxkey_t hint,
void *from, void *into)
{
assert(ileaf_sniff(btree, from));
struct ileaf *leaf = from, *dest = into;
__be16 *dict = ileaf_dict(btree, from);
__be16 *destdict = ileaf_dict(btree, into);
#ifdef SPLIT_AT_INUM
/*
* This is to prevent to have same ibase on both of from and into
* FIXME: we would want to split at better position.
*/
if (hint == ibase(leaf))
hint++;
trace("split at inum 0x%Lx", hint);
unsigned at = min_t(tuxkey_t, hint - ibase(leaf), icount(leaf));
#else
/* binsearch inum starting nearest middle of block */
unsigned at = 1, hi = icount(leaf);
while (at < hi) {
int mid = (at + hi) / 2;
if (*(dict - mid) < (btree->sb->blocksize / 2))
at = mid + 1;
else
hi = mid;
}
#endif
/* should trim leading empty inodes on copy */
unsigned split = atdict(dict, at), free = atdict(dict, icount(leaf));
trace("split at %x of %x", at, icount(leaf));
trace("copy out %x bytes at %x", free - split, split);
assert(free >= split);
memcpy(dest->table, leaf->table + split, free - split);
dest->count = cpu_to_be16(icount(leaf) - at);
veccopy(destdict - icount(dest), dict - icount(leaf), icount(dest));
for (int i = 1; i <= icount(dest); i++)
add_idict(destdict - i, -split);
#ifdef SPLIT_AT_INUM
/* round down to multiple of 64 above ibase */
inum_t round = hint & ~(inum_t)(btree->entries_per_leaf - 1);
dest->ibase = cpu_to_be64(round > ibase(leaf) + icount(leaf) ? round : hint);
#else
dest->ibase = cpu_to_be64(ibase(leaf) + at);
#endif
leaf->count = cpu_to_be16(at);
memset(leaf->table + split, 0, (char *)(dict - icount(leaf)) - (leaf->table + split));
ileaf_trim(btree, leaf);
return ibase(dest);
}
/* userland only */
void ileaf_merge(struct btree *btree, struct ileaf *leaf, struct ileaf *from)
{
if (!icount(from))
return;
be_u16 *dict = (void *)leaf + btree->sb->blocksize;
be_u16 *fromdict = (void *)from + btree->sb->blocksize;
unsigned at = icount(leaf), free = atdict(dict, at), size = atdict(fromdict, icount(from));
printf("copy in %i bytes\n", size);
memcpy(leaf->table + free, from->table, size);
leaf->count = to_be_u16(from_be_u16(leaf->count) + icount(from));
veccopy(dict - icount(leaf), fromdict - icount(from), icount(from));
for (int i = at + 1; at && i <= at + icount(from); i++)
add_idict(dict - i, from_be_u16(*(dict - at)));
}
TREENODE *rinsert(TREENODE *subroot, VECTOR *vp, int level){
if(subroot == NULL){ /* we hit the bottom of the tree */
subroot = talloc();
subroot->pvec = veccopy(vp);
return(subroot);
}
if( (vp->vec)[level] <= ((subroot->pvec)->vec)[level] ){
subroot->left = rinsert(subroot->left, vp, (level+1) % (vp->len) );
}else{
subroot->right = rinsert(subroot->right, vp, (level+1) % (vp->len) );
}
return(subroot); /* although it didn't change */
}
void crf1dc_alpha_score(crf1d_context_t* ctx)
{
int i, t;
floatval_t sum, *cur = NULL;
floatval_t *scale = &ctx->scale_factor[0];
const floatval_t *prev = NULL, *trans = NULL, *state = NULL;
const int T = ctx->num_items;
const int L = ctx->num_labels;
/* Compute the alpha scores on nodes (0, *).
alpha[0][j] = state[0][j]
*/
cur = ALPHA_SCORE(ctx, 0);
state = EXP_STATE_SCORE(ctx, 0);
veccopy(cur, state, L);
sum = vecsum(cur, L);
*scale = (sum != 0.) ? 1. / sum : 1.;
vecscale(cur, *scale, L);
++scale;
/* Compute the alpha scores on nodes (t, *).
alpha[t][j] = state[t][j] * \sum_{i} alpha[t-1][i] * trans[i][j]
*/
for (t = 1;t < T;++t) {
prev = ALPHA_SCORE(ctx, t-1);
cur = ALPHA_SCORE(ctx, t);
state = EXP_STATE_SCORE(ctx, t);
veczero(cur, L);
for (i = 0;i < L;++i) {
trans = EXP_TRANS_SCORE(ctx, i);
vecaadd(cur, prev[i], trans, L);
}
vecmul(cur, state, L);
sum = vecsum(cur, L);
*scale = (sum != 0.) ? 1. / sum : 1.;
vecscale(cur, *scale, L);
++scale;
}
/* Compute the logarithm of the normalization factor here.
norm = 1. / (C[0] * C[1] ... * C[T-1])
log(norm) = - \sum_{t = 0}^{T-1} log(C[t]).
*/
ctx->log_norm = -vecsumlog(ctx->scale_factor, T);
}
static int bnode_merge_nodes(struct sb *sb, struct bnode *into,
struct bnode *from)
{
if(DEBUG_MODE_K==1)
{
printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__);
}
unsigned into_count = bcount(into), from_count = bcount(from);
if (from_count + into_count > sb->entries_per_node)
return 0;
veccopy(&into->entries[into_count], from->entries, from_count);
into->count = cpu_to_be32(into_count + from_count);
return 1;
}
static int ileaf_merge(struct btree *btree, void *vinto, void *vfrom)
{
struct ileaf *into = vinto, *from = vfrom;
unsigned fromcount = icount(from);
/* If "from" is empty, does nothing */
if (!fromcount)
return 1;
assert(ibase(from) > ibase(into));
tuxkey_t fromibase = ibase(from);
unsigned count = icount(into);
int hole = fromibase - ibase(into) + count;
__be16 *dict = ileaf_dict(btree, into);
__be16 *fromdict = ileaf_dict(btree, from);
int need_size = hole * sizeof(*dict) + ileaf_need(btree, from);
if (ileaf_free(btree, into) < need_size)
return 0;
/* Fill hole of dict until from_ibase */
unsigned limit = atdict(dict, count);
__be16 __limit = cpu_to_be16(limit);
while (hole--) {
count++;
*(dict - count) = __limit;
}
/* Copy data from "from" */
unsigned fromlimit = atdict(fromdict, fromcount);
memcpy(into->table + limit, from->table, fromlimit);
/* Adjust copying fromdict */
if (limit) {
int i;
for (i = 1; i <= fromcount; i++)
add_idict(dict - i, limit);
}
veccopy(dict - count - fromcount, fromdict - fromcount, fromcount);
into->count = cpu_to_be16(count + fromcount);
return 1;
}
static tuxkey_t ileaf_split(struct btree *btree, tuxkey_t inum, vleaf *from, vleaf *into)
{
assert(ileaf_sniff(btree, from));
struct ileaf *leaf = from, *dest = into;
be_u16 *dict = from + btree->sb->blocksize, *destdict = into + btree->sb->blocksize;
#ifdef SPLIT_AT_INUM
printf("split at inum 0x%Lx\n", (L)inum);
assert(inum >= ibase(leaf));
unsigned at = inum - ibase(leaf) < icount(leaf) ? inum - ibase(leaf) : icount(leaf);
#else
/* binsearch inum starting nearest middle of block */
unsigned at = 1, hi = icount(leaf);
while (at < hi) {
int mid = (at + hi) / 2;
if (*(dict - mid) < (btree->sb->blocksize / 2))
at = mid + 1;
else
hi = mid;
}
#endif
/* should trim leading empty inodes on copy */
unsigned split = atdict(dict, at), free = from_be_u16(*(dict - icount(leaf)));
printf("split at %x of %x\n", at, icount(leaf));
printf("copy out %x bytes at %x\n", free - split, split);
assert(free >= split);
memcpy(dest->table, leaf->table + split, free - split);
dest->count = to_be_u16(icount(leaf) - at);
veccopy(destdict - icount(dest), dict - icount(leaf), icount(dest));
for (int i = 1; i <= icount(dest); i++)
add_idict(destdict - i, -split);
#ifdef SPLIT_AT_INUM
/* round down to multiple of 64 above ibase */
inum_t round = inum & ~(inum_t)(btree->entries_per_leaf - 1);
dest->ibase = to_be_u64(round > ibase(leaf) + icount(leaf) ? round : inum);
#else
dest->ibase = to_be_u64(ibase(leaf) + at);
#endif
leaf->count = to_be_u16(at);
memset(leaf->table + split, 0, (char *)(dict - icount(leaf)) - (leaf->table + split));
ileaf_trim(btree, leaf);
return ibase(dest);
}
Triangle *getNextTriangle()
{
if (curface == input_mesh->totface)
return 0;
Triangle *t = new Triangle();
unsigned int *f = GET_FACE(input_mesh, curface);
if (offset == 0) {
veccopy(t->vt[0], GET_CO(input_mesh, f[0]));
veccopy(t->vt[1], GET_CO(input_mesh, f[1]));
veccopy(t->vt[2], GET_CO(input_mesh, f[2]));
}
else {
veccopy(t->vt[0], GET_CO(input_mesh, f[2]));
veccopy(t->vt[1], GET_CO(input_mesh, f[3]));
veccopy(t->vt[2], GET_CO(input_mesh, f[0]));
}
if (offset == 0 && f[3])
offset++;
else {
offset = 0;
curface++;
}
/* remove triangle if it contains invalid coords */
for (int i = 0; i < 3; i++) {
const float *co = t->vt[i];
if (isnan(co[0]) || isnan(co[1]) || isnan(co[2])) {
delete t;
return getNextTriangle();
}
}
return t;
}
void matrixput( MATRIX *pmatrix, int pos, VECTOR *pvec){
assert( pos >=0) ;
assert( pos < (pmatrix->count) );
(pmatrix->list)[pos] = veccopy(pvec);
}
static int l2sgd(
encoder_t *gm,
dataset_t *trainset,
dataset_t *testset,
floatval_t *w,
logging_t *lg,
const int N,
const floatval_t t0,
const floatval_t lambda,
const int num_epochs,
int calibration,
int period,
const floatval_t epsilon,
floatval_t *ptr_loss
)
{
int i, epoch, ret = 0;
floatval_t t = 0;
floatval_t loss = 0, sum_loss = 0;
floatval_t best_sum_loss = DBL_MAX;
floatval_t eta, gain, decay = 1.;
floatval_t improvement = 0.;
floatval_t norm2 = 0.;
floatval_t *pf = NULL;
floatval_t *best_w = NULL;
clock_t clk_prev, clk_begin = clock();
const int K = gm->num_features;
if (!calibration) {
pf = (floatval_t*)malloc(sizeof(floatval_t) * period);
best_w = (floatval_t*)calloc(K, sizeof(floatval_t));
if (pf == NULL || best_w == NULL) {
ret = CRFSUITEERR_OUTOFMEMORY;
goto error_exit;
}
}
/* Initialize the feature weights. */
vecset(w, 0, K);
/* Loop for epochs. */
for (epoch = 1;epoch <= num_epochs;++epoch) {
clk_prev = clock();
if (!calibration) {
logging(lg, "***** Epoch #%d *****\n", epoch);
/* Shuffle the training instances. */
dataset_shuffle(trainset);
}
/* Loop for instances. */
sum_loss = 0.;
for (i = 0;i < N;++i) {
const crfsuite_instance_t *inst = dataset_get(trainset, i);
/* Update various factors. */
eta = 1 / (lambda * (t0 + t));
decay *= (1.0 - eta * lambda);
gain = eta / decay;
/* Compute the loss and gradients for the instance. */
gm->set_weights(gm, w, decay);
gm->set_instance(gm, inst);
gm->objective_and_gradients(gm, &loss, w, gain);
sum_loss += loss;
++t;
}
/* Terminate when the loss is abnormal (NaN, -Inf, +Inf). */
if (!isfinite(loss)) {
logging(lg, "ERROR: overflow loss\n");
ret = CRFSUITEERR_OVERFLOW;
sum_loss = loss;
goto error_exit;
}
/* Scale the feature weights. */
vecscale(w, decay, K);
decay = 1.;
/* Include the L2 norm of feature weights to the objective. */
/* The factor N is necessary because lambda = 2 * C / N. */
norm2 = vecdot(w, w, K);
sum_loss += 0.5 * lambda * norm2 * N;
/* One epoch finished. */
if (!calibration) {
/* Check if the current epoch is the best. */
if (sum_loss < best_sum_loss) {
/* Store the feature weights to best_w. */
best_sum_loss = sum_loss;
veccopy(best_w, w, K);
}
/* We don't test the stopping criterion while period < epoch. */
if (period < epoch) {
improvement = (pf[(epoch-1) % period] - sum_loss) / sum_loss;
} else {
improvement = epsilon;
}
/* Store the current value of the objective function. */
pf[(epoch-1) % period] = sum_loss;
logging(lg, "Loss: %f\n", sum_loss);
if (period < epoch) {
logging(lg, "Improvement ratio: %f\n", improvement);
}
logging(lg, "Feature L2-norm: %f\n", sqrt(norm2));
logging(lg, "Learning rate (eta): %f\n", eta);
logging(lg, "Total number of feature updates: %.0f\n", t);
logging(lg, "Seconds required for this iteration: %.3f\n", (clock() - clk_prev) / (double)CLOCKS_PER_SEC);
/* Holdout evaluation if necessary. */
if (testset != NULL) {
holdout_evaluation(gm, testset, w, lg);
}
logging(lg, "\n");
/* Check for the stopping criterion. */
if (improvement < epsilon) {
ret = 0;
break;
}
}
}
/* Output the optimization result. */
if (!calibration) {
if (ret == 0) {
if (epoch < num_epochs) {
logging(lg, "SGD terminated with the stopping criteria\n");
} else {
logging(lg, "SGD terminated with the maximum number of iterations\n");
}
} else {
logging(lg, "SGD terminated with error code (%d)\n", ret);
}
}
/* Restore the best weights. */
if (best_w != NULL) {
sum_loss = best_sum_loss;
veccopy(w, best_w, K);
}
error_exit:
free(best_w);
free(pf);
if (ptr_loss != NULL) {
*ptr_loss = sum_loss;
}
return ret;
}
void crf1dc_marginal_without_beta(crf1d_context_t* ctx)
{
int i, j, t;
floatval_t *prob = NULL;
floatval_t *row = ctx->row;
const floatval_t *fwd = NULL;
const int T = ctx->num_items;
const int L = ctx->num_labels;
/*
Compute marginal probabilities of states at T-1
p(T-1,j) = fwd'[T-1][j]
*/
fwd = ALPHA_SCORE(ctx, T-1);
prob = STATE_MEXP(ctx, T-1);
veccopy(prob, fwd, L);
/*
Repeat the following computation for t = T-1,T-2, ..., 1.
1) Compute p(t-1,i,t,j) using p(t,j)
2) Compute p(t,i) using p(t-1,i,t,j)
*/
for (t = T-1;0 < t;--t) {
fwd = ALPHA_SCORE(ctx, t-1);
prob = STATE_MEXP(ctx, t);
veczero(ctx->adj, L*L);
veczero(row, L);
/*
Compute adj[i][j] and row[j].
adj[i][j] = fwd'[t-1][i] * edge[i][j]
row[j] = \sum_{i} adj[i][j]
*/
for (i = 0;i < L;++i) {
floatval_t *adj = ADJACENCY(ctx, i);
floatval_t *edge = EXP_TRANS_SCORE(ctx, i);
vecaadd(adj, fwd[i], edge, L);
vecadd(row, adj, L);
}
/*
Find z such that z * \sum_{i] adj[i][j] = p(t,j).
Thus, z = p(t,j) / row[j]; we overwrite row with z.
*/
vecinv(row, L);
vecmul(row, prob, L);
/*
Apply the partition factor z (row[j]) to adj[i][j].
*/
for (i = 0;i < L;++i) {
floatval_t *adj = ADJACENCY(ctx, i);
vecmul(adj, row, L);
}
/*
Now that adj[i][j] presents p(t-1,i,t,j),
accumulate model expectations of transitions.
*/
for (i = 0;i < L;++i) {
floatval_t *adj = ADJACENCY(ctx, i);
floatval_t *prob = TRANS_MEXP(ctx, i);
vecadd(prob, adj, L);
}
/*
Compute the marginal probability of states at t-1.
p(t-1,i) = \sum_{j} p(t-1,i,t,j)
*/
prob = STATE_MEXP(ctx, t-1);
for (i = 0;i < L;++i) {
floatval_t *adj = ADJACENCY(ctx, i);
prob[i] = vecsum(adj, L);
}
}
}
float getBoundingBox(float origin[3])
{
veccopy(origin, min);
return maxsize;
}
static void merge_nodes(struct bnode *node, struct bnode *node2)
{
veccopy(&node->entries[bcount(node)], node2->entries, bcount(node2));
node->count = to_be_u32(bcount(node) + bcount(node2));
}
