void update_dangling_value(web* w) {
	assert(w != NULL);
	size_t i, j;

	float d = g_damping_factor;
	if (w->dangling_v == -1)
		w->dangling_v = w->pagerank[0] * w->dangling_pages->size / w->size;
	else {
		w->dangling_v = 0;
		for (i = 0; i < w->dangling_pages->size; ++i) {
			int page_id = vec_get(w->dangling_pages, i);
			w->dangling_v += w->pagerank[page_id];
		}
		w->dangling_v = w->dangling_v / w->size;
	}
	for (i = 0; i < w->dangling_pages->size; ++i) {
		float pagerank = 0;
		int page_id = vec_get(w->dangling_pages, i);
		
		for (j = 0; j < w->webnodes[page_id]->in_links->size; ++j) {
			int in_link = vec_get(w->webnodes[page_id]->in_links, j);
			pagerank += w->pagerank[in_link] * d / w->webnodes[in_link]->out_links_num;
		}
		pagerank = pagerank + (1 - d) / w->size;
		pagerank = pagerank + d * w->dangling_v;
		w->pagerank[page_id] = pagerank;
	}
}
Пример #2
0
char*
vec_char (vec_t *vec)
{
  ensure_vec(vec, __func__);

  int count = vec->count;

  push(strf("["));

  for (int i = 0; i < count; i++)
  {
    if (is_vec(vec_get(vec, i)[0]))
      push(strf("vec[]"));
    else
    if (is_map(vec_get(vec, i)[0]))
      push(strf("map[]"));
    else
      push(to_char(vec_get(vec, i)[0]));

    op_concat();
    if (i < count-1)
    {
      push(strf(", "));
      op_concat();
    }
  }

  push(strf("]"));
  op_concat();

  return pop();
}
int test() {
	vector * vec = (vector *) malloc(sizeof(struct vector));
	vec_init(vec, 50);
	int i;

	for (i = 0; i < 14; i++) {
		vec_push(vec, i * 4 + 2);
	}

	vec_set(vec, 0, 1);
	printf("capacity = %zd, %zd\n", vec->capacity, vec->size);
	vec_set(vec, 39, 1);
	printf("capacity = %zd, %zd\n", vec->capacity, vec->size);
	vec_set(vec, 19, 2);
	printf("capacity = %zd, %zd\n", vec->capacity, vec->size);
	vec_set(vec, 45, 2);
	printf("capacity = %zd, %zd\n", vec->capacity, vec->size);

	printf("vec[3] = %d\n", vec_get(vec, 3));
	printf("vec[6] = %d\n", vec_get(vec, 6));
	printf("vec[666] = %d\n", vec_get(vec, 666));

	for (size_t i = 0; i < vec->size; i++) {
		printf("vec[%zd] = %d\n", i, vec->data[i]);
	}

	vec_free(vec);

	return 0;
}
Пример #4
0
Файл: gen.c Проект: 4ker/8cc
static void do_emit_data(Vector *inits, int size, int off, int depth) {
    SAVE;
    for (int i = 0; i < vec_len(inits) && 0 < size; i++) {
        Node *node = vec_get(inits, i);
        Node *v = node->initval;
        emit_padding(node, off);
        if (node->totype->bitsize > 0) {
            assert(node->totype->bitoff == 0);
            long data = eval_intexpr(v, NULL);
            Type *totype = node->totype;
            for (i++ ; i < vec_len(inits); i++) {
                node = vec_get(inits, i);
                if (node->totype->bitsize <= 0) {
                    break;
                }
                v = node->initval;
                totype = node->totype;
                data |= ((((long)1 << totype->bitsize) - 1) & eval_intexpr(v, NULL)) << totype->bitoff;
            }
            emit_data_primtype(totype, &(Node){ AST_LITERAL, totype, .ival = data }, depth);
            off += totype->size;
            size -= totype->size;
            if (i == vec_len(inits))
                break;
        } else {
Пример #5
0
double
efp_quadrupole_quadrupole_energy(const double *quad1, const double *quad2, const vec_t *dr)
{
	double r = vec_len(dr);
	double r2 = r * r;
	double r5 = r2 * r2 * r;
	double r7 = r5 * r2;
	double r9 = r7 * r2;

	double q1dr = quadrupole_sum(quad1, dr);
	double q2dr = quadrupole_sum(quad2, dr);

	double q1q2 = 0.0;
	double q1q2dr = 0.0;

	for (size_t a = 0; a < 3; a++) {
		double t1 = 0.0;
		double t2 = 0.0;

		for (size_t b = 0; b < 3; b++) {
			size_t idx = quad_idx(a, b);

			t1 += quad1[idx] * vec_get(dr, b);
			t2 += quad2[idx] * vec_get(dr, b);

			q1q2 += quad1[idx] * quad2[idx];
		}

		q1q2dr += t1 * t2;
	}

	return (2.0 / r5 * q1q2 - 20.0 / r7 * q1q2dr + 35.0 / r9 * q1dr * q2dr) / 3.0;
}
Пример #6
0
MAT	*m_inverse(const MAT *A, MAT *out)
{
  unsigned int	i;
  char MatrixTempBuffer[ 4000 ];
  VEC	*tmp = VNULL, *tmp2 = VNULL;
  MAT	*A_cp = MNULL;
  PERM	*pivot = PNULL;

  if ( ! A )
    error(E_NULL,"m_inverse");
  if ( A->m != A->n )
    error(E_SQUARE,"m_inverse");
  if ( ! out || out->m < A->m || out->n < A->n )
    out = m_resize(out,A->m,A->n);

  if( SET_MAT_SIZE( A->m, A->n ) < 1000 )
    mat_get( &A_cp, (void *)( MatrixTempBuffer + 2000 ), A->m, A->n );
  else
    A_cp = matrix_get( A->m, A->n  );

  A_cp = m_copy( A, A_cp );
  if( SET_VEC_SIZE( A->m ) < 1000 ) {
    vec_get( &tmp, (void *)MatrixTempBuffer, A->m );
    vec_get( &tmp2, (void *)(MatrixTempBuffer + 1000), A->m );
  } else {
    tmp   = v_get( A->m );
    tmp2  = v_get( A->m );
  }

  if( SET_PERM_SIZE( A->m ) < 1000 ) {
    perm_get( &pivot, (void *)( MatrixTempBuffer + 3000 ), A->m );
  } else {
    pivot   = px_get( A->m );
  }

  LUfactor(A_cp,pivot);
  //tracecatch_matrix(LUfactor(A_cp,pivot),"m_inverse");
  for ( i = 0; i < A->n; i++ ){
    v_zero(tmp);
    tmp->ve[i] = 1.0;
    LUsolve(A_cp,pivot,tmp,tmp2);
    //tracecatch_matrix(LUsolve(A_cp,pivot,tmp,tmp2),"m_inverse");
    set_col(out,i,tmp2);
  }
  if( tmp != (VEC *)(MatrixTempBuffer ) ) // память выделялась, надо освободить
    V_FREE(tmp);
  if( tmp2 != (VEC *)(MatrixTempBuffer + 1000) ) // память выделялась, надо освободить
    V_FREE(tmp2);
  if( A_cp != (MAT *)(MatrixTempBuffer + 2000) ) // память выделялась, надо освободить
    M_FREE(A_cp);
  if( pivot != (PERM *)(MatrixTempBuffer + 3000) ) // память выделялась, надо освободить
    PX_FREE( pivot );
  return out;
}
Пример #7
0
/* these two functions for use by bd_estimate_transitions */
void unpack_params(Vector *params, BDPhyloHmm *bdphmm) {
  int params_idx = 0;
  if (bdphmm->estim_omega)
    bdphmm->mu = 1/vec_get(params, params_idx++);
  if (bdphmm->estim_gamma) {
    double gamma = vec_get(params, params_idx++);
    bdphmm->nu = gamma/(1-gamma) * bdphmm->mu;
  }
  if (bdphmm->estim_phi)
    bdphmm->phi = vec_get(params, params_idx++);
  bd_set_transitions(bdphmm);
}
Пример #8
0
/* Wrapper for likelihood function for use in parameter estimation */
double ff_likelihood_wrapper(Vector *params, void *data) {
    FeatFitData *d = (FeatFitData*)data;

    d->cdata->mod->scale = vec_get(params, 0);
    if (d->cdata->stype == SUBTREE)
        d->cdata->mod->scale_sub = vec_get(params, 1);

    /* reestimate subst models on edges */
    tm_set_subst_matrices(d->cdata->mod);

    return -1 * ff_compute_log_likelihood(d->cdata->mod, d->cdata->msa,
                                          d->feat, d->cdata->fels_scratch[0]);
}
Пример #9
0
/* 実行膜スタックからmemを削除する。外部関数が膜の削除しようとするとき
   に、その膜がスタックに積まれている事がある。そのため、安全な削除を行
   うために、この手続きが必要になる。外部の機能を使わない通常の実行時に
   はこの手続きは必要ない*/
void lmn_memstack_delete(LmnMemStack memstack, LmnMembrane *mem)
{
  unsigned long i, j, n = vec_num(memstack);

  for (i = n-1; i >= 0; i--) {
    if ((LmnMembrane *)vec_get(memstack, i) == mem) {
      /* 空いた分後ろの要素を前にを詰める */
      for (j = i+1; j < n; j++) {
        vec_set(memstack, j-1, vec_get(memstack, j));
      }
      break;
    }
  }
  vec_pop(memstack);
}
Пример #10
0
struct variable *
cp_enqvar(char *word)
{
    struct dvec *d;
    struct variable *vv, *tv;
    struct plot *pl;
    int i;

    if (*word == '&') {

        word++;

        d = vec_get(word);
        if (!d)
            return (NULL);

        if (d->v_length == 1) {
            vv = alloc(struct variable);
            vv->va_next = NULL;
            vv->va_name = copy(word);
            vv->va_type = CP_REAL;
            if (isreal(d))
                vv->va_real = d->v_realdata[0];
            else
                vv->va_real = realpart(d->v_compdata[0]);
        } else {
Пример #11
0
Файл: cpp.c Проект: ctx2002/8cc
void cpp_eval(char *buf) {
    stream_stash(make_file_string(buf));
    Vector *toplevels = read_toplevels();
    for (int i = 0; i < vec_len(toplevels); i++)
        emit_toplevel(vec_get(toplevels, i));
    stream_unstash();
}
Пример #12
0
int exe_sqlite3_exe(sqlite3_vtab_cursor* pCursor, sqlite3_context *ctx) {
    exe_cursor_t *cursor = (exe_cursor_t*) pCursor;
    exe_table_t *table = (exe_table_t*) pCursor->pVtab;
    exe_t* exe = (exe_t*) vec_get(table->content,cursor->row);
    sqlite3_result_text(ctx, exe->exe, exe->exe_len, SQLITE_STATIC);
    return SQLITE_OK;
}
Пример #13
0
struct membuf *get_named_buffer(const char *name)
{
    int pos;
    struct sbe e[1];
    struct sbe *ep;
    struct membuf *mp;

    /* name is already strdup:ped */
    e->name = name;
    pos = vec_find(s_sbe_table, sbe_cmp, e);
    if(pos >= 0)
    {
        /* found */
        ep = vec_get(s_sbe_table, pos);
    }
    else
    {
        membuf_init(e->mb);
        read_file(name, e->mb);
        ep = vec_insert(s_sbe_table, -(pos + 2), e);
    }
    mp = ep->mb;

    return mp;
}
Пример #14
0
int exe_sqlite3_pid(sqlite3_vtab_cursor* pCursor, sqlite3_context *ctx) {
    exe_cursor_t *cursor = (exe_cursor_t*) pCursor;
    exe_table_t *table = (exe_table_t*) pCursor->pVtab;
    exe_t* exe = (exe_t*) vec_get(table->content,cursor->row);
    sqlite3_result_int(ctx, exe->pid);
    return SQLITE_OK;
}
Пример #15
0
static void spoil_mon_info()
{
    int     i;
    vec_ptr v = vec_alloc(NULL);
    doc_ptr doc = doc_alloc(80);

    spoiler_hack = TRUE;

    for (i = 1; i < max_r_idx; i++)
    {
        monster_race *r_ptr = &r_info[i];
        if (!r_ptr->name) continue;
        if (r_ptr->id == MON_MONKEY_CLONE) continue;
        if (r_ptr->id == MON_KAGE) continue;
        vec_add(v, r_ptr);
    }
    vec_sort(v, (vec_cmp_f)_compare_r_level_desc);

    for (i = 0; i < vec_length(v); i++)
    {
        monster_race *r_ptr = vec_get(v, i);
        doc_printf(doc, "<topic:%s><color:r>=====================================================================</color>\n", r_name + r_ptr->name);
        mon_display_doc(r_ptr, doc);
        doc_newline(doc);
    }
    vec_free(v);

    doc_display(doc, "Monster Spoilers", 0);
    doc_free(doc);

    spoiler_hack = FALSE;
}
Пример #16
0
int cmdline_sqlite3_cmdline(sqlite3_vtab_cursor* pCursor, sqlite3_context *ctx) {
  cmdline_cursor_t *cursor = (cmdline_cursor_t*) pCursor;
  cmdline_table_t *table = (cmdline_table_t*) pCursor->pVtab;
  cmdline_t* cmdline = (cmdline_t*) vec_get(table->content,cursor->row);
  sqlite3_result_text(ctx, cmdline->cmdline, cmdline->cmdline_len, SQLITE_STATIC);
  return SQLITE_OK;
}
Пример #17
0
Файл: env.c Проект: berkus/moto
char
moto_isVarGlobal(MotoEnv *env, char *name) {
    MotoVar* var;

    if ((var = (MotoVar *)stab_get(env->frame->symtab, name)) == NULL) {
        int i = env->frameindex;
        while (--i >= 0) {
            MotoFrame *frame = (MotoFrame *)vec_get(env->frames, i);
            SymbolTable *symtab = frame->symtab;
            if ((var = (MotoVar *)stab_get(symtab, name)) != NULL) {
                break;
            }
            if (frame->type == FN_FRAME)
                break;
        }
    }

    /* If we still don't have it, check the globals */

    if(var==NULL) {
        var=stab_get(env->globals, name);
        if(var!=NULL) return '\1';
    }

    return '\0';
}
Пример #18
0
struct pnode *
PP_mkfnode(const char *func, struct pnode *arg)
{
    struct func *f;
    struct pnode *p, *q;
    struct dvec *d;
    char buf[BSIZE_SP];

    (void) strcpy(buf, func);
    strtolower(buf);  /* Make sure the case is ok. */

    for (f = &ft_funcs[0]; f->fu_name; f++)
        if (eq(f->fu_name, buf))
            break;

    if (f->fu_name == NULL) {
        /* Give the user-defined functions a try. */
        q = ft_substdef(func, arg);
        if (q)
            return (q);
    }

    if ((f->fu_name == NULL) && arg->pn_value) {
        /* Kludge -- maybe it is really a variable name. */
        (void) sprintf(buf, "%s(%s)", func, arg->pn_value->v_name);
        free_pnode(arg);
        d = vec_get(buf);
        if (d == NULL) {
            /* Well, too bad. */
            fprintf(cp_err, "Error: no such function as %s.\n",
                    func);
            return (NULL);
        }
        /* (void) strcpy(buf, d->v_name); XXX */
        return (PP_mksnode(buf));
    } else if (f->fu_name == NULL) {
        fprintf(cp_err, "Error: no function as %s with that arity.\n",
                func);
        free_pnode(arg);
        return (NULL);
    }

    if (!f->fu_func && arg->pn_op && arg->pn_op->op_num == PT_OP_COMMA) {
        p = PP_mkbnode(PT_OP_MINUS, PP_mkfnode(func, arg->pn_left),
                    PP_mkfnode(func, arg->pn_right));
        free_pnode(arg);
        return p;
    }

    p = alloc_pnode();

    p->pn_func = f;

    p->pn_left = arg;
    if (p->pn_left)
        p->pn_left->pn_use++;

    return (p);
}
Пример #19
0
void sp_atom_finalize()
{
  int i;

  for (i = 0; i < vec_num(sp_atom_callback_tbl); i++) {
    LMN_FREE(vec_get(sp_atom_callback_tbl, i));
  }
  vec_free(sp_atom_callback_tbl);
}
Пример #20
0
int vec_inserted_index(Vector *v, LmnWord w)
{
  int i;
  for (i = 0; i < vec_num(v); i++){
    if (vec_get(v, i) == w) return i;
  }
  vec_push(v, w);
  return vec_num(v) - 1;
}
Пример #21
0
void vec_debugi(pvec v) {
	int i;
	printf("(%d/%d):", v->size, v->_capacity);
	for(i = 0; i < v->size; i++) {
		int* x = (int*)vec_get(v, i);
	    printf(" %d", *x ); 
	}
	printf("\n");
}
Пример #22
0
Файл: gen.c Проект: 4ker/8cc
static char *get_caller_list() {
    Buffer *b = make_buffer();
    for (int i = 0; i < vec_len(functions); i++) {
        if (i > 0)
            buf_printf(b, " -> ");
        buf_printf(b, "%s", vec_get(functions, i));
    }
    buf_write(b, '\0');
    return buf_body(b);
}
Пример #23
0
Файл: gen.c Проект: 4ker/8cc
static void set_reg_nums(Vector *args) {
    numgp = numfp = 0;
    for (int i = 0; i < vec_len(args); i++) {
        Node *arg = vec_get(args, i);
        if (is_flotype(arg->ty))
            numfp++;
        else
            numgp++;
    }
}
Пример #24
0
Файл: env.c Проект: berkus/moto
void
moto_freeTreeCells(MotoEnv *env) {
    MotoTree *tree = env->tree;
    Vector *cells = tree->cells;
    int size = vec_size(cells);
    int i;
    for (i = 0; i < size; i++) {
        moto_freeCell(env, vec_get(cells, i));
    }
}
Пример #25
0
Файл: gen.c Проект: 4ker/8cc
// Set the register class for parameter passing to RAX.
// 0 is INTEGER, 1 is SSE, 2 is MEMORY.
static void emit_builtin_reg_class(Node *node) {
    Node *arg = vec_get(node->args, 0);
    assert(arg->ty->kind == KIND_PTR);
    Type *ty = arg->ty->ptr;
    if (ty->kind == KIND_STRUCT)
        emit("mov $2, #eax");
    else if (is_flotype(ty))
        emit("mov $1, #eax");
    else
        emit("mov $0, #eax");
}
Пример #26
0
doc_style_ptr doc_current_style(doc_ptr doc)
{
    int           ct = vec_length(doc->style_stack);
    doc_style_ptr style = NULL;

    if (ct > 0)
        style = vec_get(doc->style_stack, ct - 1);

    assert(style);
    return style;
}
Пример #27
0
double
efp_dipole_quadrupole_energy(const vec_t *d1, const double *quad2, const vec_t *dr)
{
	double r = vec_len(dr);
	double r2 = r * r;
	double r5 = r2 * r2 * r;
	double r7 = r5 * r2;

	double d1dr = vec_dot(d1, dr);
	double q2dr = quadrupole_sum(quad2, dr);
	double d1q2dr = 0.0;

	for (size_t a = 0; a < 3; a++)
		for (size_t b = 0; b < 3; b++) {
			size_t idx = quad_idx(a, b);
			d1q2dr += quad2[idx] * vec_get(d1, a) * vec_get(dr, b);
		}

	return 5.0 / r7 * q2dr * d1dr - 2.0 / r5 * d1q2dr;
}
Пример #28
0
void map_clear(hashmap_t* map)
{
	for(size_t i = 0; i < map->active_buckets.length; ++i)
	{
		unsigned long pos = *(unsigned long*)vec_get(&map->active_buckets, i);
		hashmap_node_t* node = map->buckets[pos];
		free_bucket(node);
		map->buckets[pos] = NULL;
	}
	
	vec_clear(&map->active_buckets);
}
Пример #29
0
/**
 * ($start, $end, $g)
 * where
 *  start, end = integer
 *  g = ground
 *
 * Creates a (multi)set $g[$a], $g[$a+1], ..., $g[$b].
 */
void integer_set(LmnReactCxt *rc,
                 LmnMembrane *mem,
                 LmnAtom a0, LmnLinkAttr t0,
                 LmnAtom a1, LmnLinkAttr t1,
                 LmnAtom a2, LmnLinkAttr t2)
{
  Vector *srcvec;
  int i, j, n;
  int start, end;

  start  = (int)a0;
  end    = (int)a1;
  srcvec = vec_make(16);
  vec_push(srcvec, (LmnWord)LinkObj_make(a2, t2));

  for (i = 0, n = start; n <= end; i++, n++) {
    Vector *dstlovec;
    ProcessTbl atommap;
    LinkObj l;

    lmn_mem_copy_ground(mem, srcvec, &dstlovec, &atommap);

    l = (LinkObj)vec_get(dstlovec, 0);
    lmn_mem_newlink(mem, n, LMN_INT_ATTR, 0,
                    l->ap, t2, LMN_ATTR_GET_VALUE(l->pos));
    lmn_mem_push_atom(mem, n, LMN_INT_ATTR);

    for (j = 0; j < vec_num(dstlovec); j++) LMN_FREE(vec_get(dstlovec, j));
    vec_free(dstlovec);
    proc_tbl_free(atommap);
  }

  lmn_mem_delete_atom(mem, a0, t0);
  lmn_mem_delete_atom(mem, a1, t1);

  lmn_mem_delete_ground(mem, srcvec);

  for (i = 0; i < vec_num(srcvec); i++) LMN_FREE(vec_get(srcvec, i));
  vec_free(srcvec);
}
Пример #30
0
void map_traverse(hashmap_t* map, hashmap_traverse_t traverse, void* data)
{
	for(size_t i = 0; i < map->active_buckets.length; ++i)
	{
		unsigned long pos = *(unsigned long*)vec_get(&map->active_buckets, i);
		hashmap_node_t* node = map->buckets[pos];
		while(node)
		{
			traverse(node->key, node->value, data);
			node = node->next;
		}
	}
}