///figure out set of funcs/services to remove when transitioning from set a to set b static uint16_t get_funcs_to_remove (uint16_t ** f_rmv_ret, uint16_t ** p_rmv_ret, uint16_t * funcs_a, uint16_t * pnrs_a, uint16_t n_funcs_a, uint16_t * funcs_b, uint16_t * pnrs_b, uint16_t n_funcs_b) { uint16_t n_rmv = 0; uint16_t *f_rmv = NULL; uint16_t *p_rmv = NULL; unsigned i; /* those pnrs that disappear completely, get removed with those func bits set in the a set(not necesarily all) those pnrs that stay but change func bits get removed when bits set in a set and cleared in b set. func[i]=funcs_a&(~funcs_b); perhaps flatten the whole function list, so it's easier to do? __________ |pnr|func| ---------- instead of func bitfield, func idx combined with pnr in 1 word... so each element in array corresponds to exactly 1 func? the pnr is a full 16 bits, so would have up word size. would it break stuff somewhere else? would not be able to use pidbuf funcs... naaahhh */ //start out with complete removals p_rmv = pidbufDifference (pnrs_a, n_funcs_a, pnrs_b, n_funcs_b, &n_rmv); //got the pnrs, now find the funcs they had.. f_rmv = utlCalloc (n_rmv, sizeof (uint16_t)); for (i = 0; i < n_rmv; i++) { int j = get_idx (pnrs_a, n_funcs_a, p_rmv[i]); //lookup pnrs index in a array f_rmv[i] = funcs_a[j]; //copy func bits (they all get removed) } //now those pnrs that are in both arrays for (i = 0; i < n_funcs_a; i++) { //iterate over a array and see if it's in b, too if (pidbufContains (pnrs_a[i], pnrs_b, n_funcs_b)) { //yes it is int j = get_idx (pnrs_b, n_funcs_b, pnrs_a[i]); uint16_t tmp; if ((tmp = (funcs_a[i] & (~funcs_b[j])))) { //function bits got unset pidbufAddPid (pnrs_a[i], &p_rmv, &n_rmv); n_rmv--; //'cause it got incremented above.. needs to get less ugly... pidbufAddPid (tmp, &f_rmv, &n_rmv); } //otherwise something got added } } *f_rmv_ret = f_rmv; *p_rmv_ret = p_rmv; return n_rmv; }
void setparams() { input = getparam("in"); otimes = getparam("times"); if (strcmp(otimes,"all")==0) { trange[0] = -HUGE; trange[1] = HUGE; } else setrange(trange, otimes); nplot=getiparam("nplot"); xvar = getparam("xvar"); xvar_idx = get_idx(xvar); if (hasvalue("xlabel")) xlabel = getparam("xlabel"); else xlabel = xvar; setrange(xrange, getparam("xrange")); yvar = getparam("yvar"); yvar_idx = get_idx(yvar); if (hasvalue("ylabel")) ylabel = getparam("ylabel"); else ylabel = yvar; setrange(yrange, getparam("yrange")); visib = getparam("visib"); psize = getparam("psize"); #ifdef COLOR color = getparam("color"); #endif maxsteps = getiparam("maxsteps"); }
void goal::elim_redundancies() { if (inconsistent()) return; expr_ref_fast_mark1 neg_lits(m()); expr_ref_fast_mark2 pos_lits(m()); unsigned sz = size(); unsigned j = 0; for (unsigned i = 0; i < sz; i++) { expr * f = form(i); if (m().is_true(f)) continue; if (m().is_not(f)) { expr * atom = to_app(f)->get_arg(0); if (neg_lits.is_marked(atom)) continue; if (pos_lits.is_marked(atom)) { proof * p = 0; if (proofs_enabled()) { proof * prs[2] = { pr(get_idx(atom)), pr(i) }; p = m().mk_unit_resolution(2, prs); } expr_dependency_ref d(m()); if (unsat_core_enabled()) d = m().mk_join(dep(get_idx(atom)), dep(i)); push_back(m().mk_false(), p, d); return; } neg_lits.mark(atom); } else { if (pos_lits.is_marked(f)) continue; if (neg_lits.is_marked(f)) { proof * p = 0; if (proofs_enabled()) { proof * prs[2] = { pr(get_not_idx(f)), pr(i) }; p = m().mk_unit_resolution(2, prs); } expr_dependency_ref d(m()); if (unsat_core_enabled()) d = m().mk_join(dep(get_not_idx(f)), dep(i)); push_back(m().mk_false(), p, d); return; } pos_lits.mark(f); } if (i == j) { j++; continue; } m().set(m_forms, j, f); if (proofs_enabled()) m().set(m_proofs, j, pr(i)); if (unsat_core_enabled()) m().set(m_dependencies, j, dep(i)); j++; } shrink(j); }
void process_event_record(uint8_t *event_data, size_t bytes) { struct record *rec = (struct record *)event_data; printf("\n\n%s", sts_str[get_idx(hab_statuses, rec->contents[0])]); printf("%s", rsn_str[get_idx(hab_reasons, rec->contents[1])]); printf("%s", ctx_str[get_idx(hab_contexts, rec->contents[2])]); printf("%s", eng_str[get_idx(hab_engines, rec->contents[3])]); }
// first monte carlo solver, mildly constraint void oku_mcsol(oku_sod* sod, double temp){ int i,j,num,size = sod->size; int cnt[size+1]; int fit1, fit2, idx1, idx2,tmp,tmp2; //refresh list of unknowns in sod unk_find(sod); //fill sudoku with missing symbols for(i=1;i<size+1;i++) cnt[i] = size; for(i=0;i<size*size;i++) cnt[get_idx(sod,i)]--; j=1; for(i=0;i<get_numunk(sod);i++){ while(cnt[j] < 1 && j <= size+1) j++; cnt[j]--; set_idx(sod,get_unkidx(sod,i),j); } fit1 = fitness(sod); num=0; while(fit1 && num < 200000){ //choose 2 indices idx1 = get_unkidx(sod,rndi() % get_numunk(sod)); idx2 = get_unkidx(sod,rndi() % get_numunk(sod)); //swap tmp = get_idx(sod,idx1); if(tmp == (tmp2 = get_idx(sod,idx2))) continue; set_idx(sod,idx1,tmp2); set_idx(sod,idx2,tmp); fit2 = fitness(sod); if(fit2 > fit1 && exp((fit1 - fit2)/temp) < rndf()){ //swap back tmp = get_idx(sod,idx1); set_idx(sod,idx1,get_idx(sod,idx2)); set_idx(sod,idx2,tmp); } else fit1 = fit2; num++; } printf("Solution found after %d MC Steps\n",num); };
int match_kmp(circular_buffer *text, const char *target) { int m = strlen(target); int *jumps = kmp_jump_table(target, m); int target_idx = 0; int text_idx = 0; char text_char = 0; while ((text_char = buf_get(text, text_idx)) != -1) { if (target_idx >= m) /* match condition */ { return 1; } if (!is_legal(text_char)) { target_idx = 0; } else { target_idx = jumps[get_idx(target_idx, text_char)]; } text_idx++; } free(jumps); return target_idx >= m; }
static struct image_extent get_test_extent(const struct image_target_info *target, unsigned d) { const struct image_extent ls = image_target_limits(target); const unsigned high = ~0, low = 8; struct image_extent ext; int i; for (i = 0; i < 4; ++i) set_idx(ext, i, MIN2(get_idx(ls, i), (i == d ? high : low))); if (target->target == GL_TEXTURE_CUBE_MAP || target->target == GL_TEXTURE_CUBE_MAP_ARRAY) { /* Cube maps have to be square and the number of faces * should be a multiple of six. */ ext.y = ext.x; ext.z = 6 * MAX2(ext.z / 6, 1); } else if (image_target_samples(target) > 1) { /* Use the maximum number of samples to keep things * interesting. */ ext.x = image_target_samples(target); } return ext; }
int main() { int n; scanf("%d", &n); list mylist; init_list(&mylist); while(n--) { char command[10]; scanf("%s", command); // push, get, size, count, clear if(command[0] == 'p') { int value; scanf("%d", &value); push_back(&mylist, value); } else if(command[0] == 'g') { int idx; scanf("%d", &idx); printf("%d\n", get_idx(&mylist, idx)); } else if(command[0] == 's') { printf("%d\n", mylist.size); } else if(command[1] == 'o') { int target; scanf("%d", &target); printf("%d\n", count_target(&mylist, target)); } else { clear_list(&mylist); } } return 0; }
//gets the posth element of the blkth block int get_blk(oku_sod* sod, int blk, int pos){ if(blk < sod->size && pos < sod->size){ return get_idx(sod,sod->blkidx[blk][pos]); } else printf("Error! Invalid Input in get_blk. blk=%d, pos=%d\n",blk,pos); return 0; }
static void DOCX_Circle(double x, double y, double r, const pGEcontext gc, pDevDesc dev) { DOCDesc *pd = (DOCDesc *) dev->deviceSpecific; int idx = get_idx(dev); fprintf(pd->dmlFilePointer, docx_elt_tag_start); if( pd->editable > 0 ) fprintf(pd->dmlFilePointer, "<wps:cNvPr id=\"%d\" name=\"Point %d\" />%s", idx, idx, docx_unlock_properties); else fprintf(pd->dmlFilePointer, "<wps:cNvPr id=\"%d\" name=\"Point %d\" />%s", idx, idx, docx_lock_properties); fprintf(pd->dmlFilePointer, "<wps:spPr>"); fprintf(pd->dmlFilePointer, "<a:xfrm>"); fprintf(pd->dmlFilePointer, "<a:off x=\"%.0f\" y=\"%.0f\"/>", p2e_(pd->offx + x - r), p2e_(pd->offy + y - r)); fprintf(pd->dmlFilePointer, "<a:ext cx=\"%.0f\" cy=\"%.0f\"/>", p2e_(r * 2), p2e_(r * 2)); fprintf(pd->dmlFilePointer, "</a:xfrm>"); fprintf(pd->dmlFilePointer, "<a:prstGeom prst=\"ellipse\"><a:avLst /></a:prstGeom>"); SetFillColor(dev, gc); SetLineSpec(dev, gc); fprintf(pd->dmlFilePointer, "</wps:spPr>"); fprintf(pd->dmlFilePointer, "<wps:bodyPr />"); fprintf(pd->dmlFilePointer, docx_elt_tag_end); fprintf(pd->dmlFilePointer, "\n"); fflush(pd->dmlFilePointer); }
int main(int argc,char** argv) { char* ifo_name="../dict/stardict-langdao-ec-gb-2.4.2/langdao-ec-gb.ifo"; char* idx_name="../dict/stardict-langdao-ec-gb-2.4.2/langdao-ec-gb.idx"; char* dict_name="../dict/stardict-langdao-ec-gb-2.4.2/langdao-ec-gb.dict"; DICT_INFO* dict_info; dict_info=get_dict_info(ifo_name); WORD_IDX* idx=(WORD_IDX*)malloc(sizeof(WORD_IDX)*dict_info->word_count); get_words(idx_name,dict_info,idx); WORD_IDX* word=get_idx(argv[1],idx,dict_info); if(word==NULL){ printf("<NULL>\n"); exit(0); } printf("%s,%d,%d\n",word->word,word->offset,word->length); FILE* dict=fopen(dict_name,"r"); if(NULL==dict) { printf("dict error!\n"); return EXIT_FAILURE; } if(0!=fseek(dict,word->offset,SEEK_SET)) { printf("seek error\n"); return EXIT_FAILURE; } char explain[word->length+1]; memset(explain,'\0',word->length+1); fread(explain,word->length,1,dict); printf("%s\n",explain); free(idx); return EXIT_SUCCESS; }
int *kmp_jump_table(const char *target, int m) { /** * precompute kmp jump table. This is a map saying "if I'm at index i of * target and reading character c from text, what is the next index of * target I look at?" * * more precisely for each substr_len prefix of target, does a prefix of * length prefix_len - 1 match a suffix of (prefix_len - 1)? If so, compute * the next index of target to compare * * jumps[current index of substr (substr_len)] * [next character (target[prefix_len]] = * next index to examine (prefix_len + 1) * * Return: user-free (strlen(target) * PRINT_RANGE * sizeof(int)) * containing jump table */ /* we use calloc to zero the memory */ int *jumps = (int *) calloc(m * PRINT_RANGE, sizeof(int)); int substr_len, prefix_len, i; for (substr_len = 0; substr_len < m; substr_len++) { for (prefix_len = 1; prefix_len < substr_len; prefix_len++) { /* compare prefix_len - 1 prefix and suffix of substr_len */ for (i = 0; i < prefix_len; i++) { if (*(target + i) != *(target + substr_len - (prefix_len - 1) + i)) { break; } } if (i == prefix_len - 1) { /* match */ jumps[get_idx(substr_len, target[prefix_len])] = prefix_len + 1; } } /* special case since we don't need string comparison here */ jumps[get_idx(substr_len, target[substr_len])] = substr_len + 1; } return jumps; }
void unk_find(oku_sod* sod){ int i,size = sod->size; sod->numunk = 0; for(i=0;i<size*size;i++) if(get_idx(sod,i) == 0) sod->unkidx[sod->numunk++] = i; }
//deepcopy of sod void oku_sod_copy(oku_sod* dst,oku_sod* src){ int i,size = src->size; if(dst->size != src->size){ oku_sod_destroy(dst); oku_sod_init(&dst,src->size); } //sudoku dimendion is size*size for(i=0;i<size*size;i++) set_idx(dst,i,get_idx(src,i)); };
struct list * search(py_tree *tree, const char *s) { for (int i = 0, len = strlen(s); i < len; i++) { if (tree == NULL) return NULL; tree = tree->next[get_idx(s[i])]; } struct list *ret; return NULL; }
static bool should_test_dimension(const struct image_target_info *target, int d) { const struct image_extent ls = image_target_limits(target); return get_idx(ls, d) > 1 && /* Skip second cube map dimension as faces have to be * square. */ !(target->target == GL_TEXTURE_CUBE_MAP && d >= 1) && !(target->target == GL_TEXTURE_CUBE_MAP_ARRAY && d == 1) && /* Skip sample dimension. */ !(image_target_samples(target) > 1 && d == 0); }
char *query(const char *word) { idx *x; char *info; x = get_idx(word); if(x == NULL) return NULL; //printf("%s offset=%d, len=%d\n", x->word, x->offset, x->length); info = get_info(x); return info; }
///figure out set of funcs/services to add when transitioning from set a to set b static uint16_t get_funcs_to_add (uint16_t ** f_add_ret, uint16_t ** p_add_ret, uint16_t * funcs_a, uint16_t * pnrs_a, uint16_t n_funcs_a, uint16_t * funcs_b, uint16_t * pnrs_b, uint16_t n_funcs_b) { uint16_t n_add = 0; uint16_t *f_add = NULL; uint16_t *p_add = NULL; unsigned i; //start out with newly added pnrs p_add = pidbufDifference (pnrs_b, n_funcs_b, pnrs_a, n_funcs_a, &n_add); //got the pnrs, now find the funcs they will have.. f_add = utlCalloc (n_add, sizeof (uint16_t)); for (i = 0; i < n_add; i++) { int j = get_idx (pnrs_b, n_funcs_b, p_add[i]); //lookup pnrs index in b array f_add[i] = funcs_b[j]; //copy func bits (they all get added) } //now those pnrs that are in both arrays for (i = 0; i < n_funcs_a; i++) { //iterate over a array and see if it's in b, too if (pidbufContains (pnrs_a[i], pnrs_b, n_funcs_b)) { //yes it is int j = get_idx (pnrs_b, n_funcs_b, pnrs_a[i]); uint16_t tmp; if ((tmp = ((~funcs_a[i]) & funcs_b[j]))) { //function bits got set pidbufAddPid (pnrs_a[i], &p_add, &n_add); n_add--; //'cause it got incremented above.. needs to get less ugly... pidbufAddPid (tmp, &f_add, &n_add); } } } *f_add_ret = f_add; *p_add_ret = p_add; return n_add; }
int main() { bool first = true; while (true) { if (scanf("%d", &n) != 1) break; for (int i = 0; i < n; ++i) scanf("%s", names[i]); Zero(gifts); for (int i = 0; i < n; ++i) { scanf("%s", name); int idx = get_idx(name); int friends; scanf("%d%d", &money[idx], &friends); if (friends == 0) continue; int spend = money[idx] / friends; for (int j = 0; j < friends; ++j) { scanf("%s", name); int f = get_idx(name); gifts[idx] -= spend; gifts[f] += spend; } } if (first) first = false; else putchar('\n'); for (int i = 0; i < n; ++i) printf("%s %d\n", names[i], gifts[i]); } return 0; }
PIGLIT_GL_TEST_CONFIG_END static bool init_image_pixels(const struct image_info img, unsigned unit, uint32_t *r_pixels) { const unsigned m = image_num_components(img.format); const struct image_datum s = image_format_scale(img.format); unsigned i; for (i = 0; i < m * N; ++i) r_pixels[i] = (unit == 1 ? 0 : encode(img.format, get_idx(s, i % m) * i / (m * N))); return true; }
static void DOCX_Rect(double x0, double y0, double x1, double y1, const pGEcontext gc, pDevDesc dev) { double tmp; DOCDesc *pd = (DOCDesc *) dev->deviceSpecific; int idx = get_idx(dev); if (x0 >= x1) { tmp = x0; x0 = x1; x1 = tmp; } if (y0 >= y1) { tmp = y0; y0 = y1; y1 = tmp; } // fprintf(pd->dmlFilePointer, docx_elt_tag_start); if( pd->editable < 1 ) fprintf(pd->dmlFilePointer, "<wps:cNvPr id=\"%d\" name=\"Rectangle %d\" />%s", idx, idx, docx_lock_properties); else fprintf(pd->dmlFilePointer, "<wps:cNvPr id=\"%d\" name=\"Rectangle %d\" />%s", idx, idx, docx_unlock_properties); fprintf(pd->dmlFilePointer, "<wps:spPr>"); fprintf(pd->dmlFilePointer, "<a:xfrm>"); fprintf(pd->dmlFilePointer, "<a:off x=\"%.0f\" y=\"%.0f\"/>", p2e_(pd->offx + x0), p2e_(pd->offy + y0)); fprintf(pd->dmlFilePointer, "<a:ext cx=\"%.0f\" cy=\"%.0f\"/>", p2e_(x1 - x0), p2e_(y1 - y0)); fprintf(pd->dmlFilePointer, "</a:xfrm>"); fprintf(pd->dmlFilePointer, "<a:prstGeom prst=\"rect\"><a:avLst /></a:prstGeom>"); SetFillColor(dev, gc); SetLineSpec(dev, gc); fprintf(pd->dmlFilePointer, "</wps:spPr>"); fprintf(pd->dmlFilePointer, "<wps:bodyPr />"); fprintf(pd->dmlFilePointer, docx_elt_tag_end); fprintf(pd->dmlFilePointer, "\n"); fflush(pd->dmlFilePointer); //return; }
/** * qhasharr->remove_by_obj(): Remove an object from this table by key object * * @param tbl qhasharr_t container pointer. * @param name key data * @param namesize size of key * * @return true if successful, otherwise(not found) returns false * @retval errno will be set in error condition. * - ENOENT : No such key found. * - EINVAL : Invald argument. * - EFAULT : Unexpected error. Data structure is not constant. */ bool qhasharr_remove_by_obj(qhasharr_t *tbl, const void *name, size_t namesize) { if (tbl == NULL || name == NULL || namesize == 0) { errno = EINVAL; return false; } qhasharr_data_t *tbldata = tbl->data; // get hash integer uint32_t hash = qhashmurmur3_32(name, namesize) % tbldata->maxslots; int idx = get_idx(tbl, name, namesize, hash); if (idx < 0) { errno = ENOENT; return false; } return qhasharr_remove_by_idx(tbl, idx); }
void init_table_aux(int table[MAX_SKILLS][2], int *idx, int father, int lev, bool full) { int j, i; for (j = 1; j < max_s_idx; j++) { i = get_idx(j); if (s_info[i].father != father) continue; if (s_info[i].hidden) continue; if (!is_known(i)) continue; table[*idx][0] = i; table[*idx][1] = lev; (*idx)++; if (s_info[i].dev || full) init_table_aux(table, idx, i, lev + 1, full); } }
void init_table_aux(s32b **table, s32b *idx, s32b father, s32b lev, bool full) { s32b j, i; for (j = 1; j < max_s_idx; j++) { i = get_idx(j); if (s_info[i].father != father) continue; if (s_info[i].hidden) continue; if (!is_known(i)) continue; table[*idx][0] = i; table[*idx][1] = lev; (*idx)++; if (s_info[i].dev || full) init_table_aux(table, idx, i, lev + 1, full); } }
void set_ts_info(uint8_t *p, struct nit *nit) { int i, j, idx; uint8_t *q; uint8_t ttype_info, ttype_num_service; uint16_t service_id; nit->ts_info[0].rc_key_id = p[2]; nit->ts_info[0].name_len = (p[3] & 0xfc) >> 2; nit->ts_info[0].num_ttype = p[3] & 0x03; q = p + 4 + nit->ts_info[0].name_len; if (nit->ts_info[0].name_len > MAX_TS_NAME) nit->ts_info[0].name_len = MAX_TS_NAME; memcpy(nit->ts_info[0].name, p+4, nit->ts_info[0].name_len); dprintf(" ts_info name:%.*s\n", nit->ts_info[0].name_len, nit->ts_info[0].name); for (i=0; i<nit->ts_info[0].num_ttype; i++) { ttype_info = q[0]; ttype_num_service = q[1]; dprintf(" ttype:%02hhx(%hhu servs) ", ttype_info, ttype_num_service); q += 2; for(j=0; j<ttype_num_service; j++) { service_id = q[0] << 8 | q[1]; dprintf("[%04hx] ", service_id); idx = get_idx(service_id, nit); if (idx < 0) { continue; } nit->ts_info[0].services[idx].ttype = ttype_info; if (!j) nit->ts_info[0].services[idx].primary = 1; q += 2; } } }
void set_partial_recv(uint8_t *p, struct nit *nit) { uint8_t *q; int i, idx; uint16_t service_id; uint8_t service_type; q = p + 2; dprintf(" partial_recv_list "); for (i=0; i<p[1]; i+=3) { service_id = q[0] << 8 | q[1]; idx = get_idx(service_id, nit); if (idx < 0) { dprintf("overflow! "); continue; } nit->ts_info[0].services[idx].partial = 1; q += 2; dprintf("[%04hx] ", service_id); } dprintf("\n"); }
static bool check_pixels_vs(const struct image_info img, unsigned stride, const uint32_t *pixels, const uint32_t *expect) { const unsigned m = image_num_components(img.format); unsigned i, j; for (i = 0; i < product(img.size); ++i) { const uint32_t *v = &pixels[m * i]; const uint32_t *u = &expect[stride * m * i]; for (j = 0; j < m; ++j) { if ((fabs(decode(img.format, v[j]) - decode(img.format, u[j])) > get_idx(img.epsilon, j)) && isfinite(decode(img.format, u[j]))) { printf("Probe value at (%u, %u, %u, %u)\n", i % img.size.x, i / img.size.x % img.size.y, i / img.size.x / img.size.y % img.size.z, i / img.size.x / img.size.y / img.size.z); printf(" Expected:"); for (j = 0; j < m; ++j) printf(" %f", decode(img.format, u[j])); printf("\n Observed:"); for (j = 0; j < m; ++j) printf(" %f", decode(img.format, v[j])); printf("\n"); return false; } } } return true; }
void push2tree(char *py, char *id) { if (strlen(id) != 24) { err_ret("bad id"); return; } py_tree *itree, *node; int py_len = strlen(py); for (int i = py_len - 1; i >= 0; i--) { itree = tree; for (int j = i; j < py_len; j++) { int idx = get_idx(py[j]); node = itree; itree = itree->next[idx]; if (itree == NULL) itree = node->next[idx] = make_node(); } itree->ids = add2list(itree->ids, id); } }
void set_service_list(uint8_t *p, struct nit *nit) { uint8_t *q; int i, idx; uint16_t service_id; uint8_t service_type; q = p + 2; dprintf(" service_list "); for (i=0; i<p[1]; i+=3) { service_id = q[0] << 8 | q[1]; service_type = q[2]; idx = get_idx(service_id, nit); if (idx < 0) { dprintf("overflow! "); continue; } nit->ts_info[0].services[idx].service_type = service_type; q += 3; dprintf("[%04hx](typ:%02hhx) ", service_id, service_type); } dprintf("\n"); }
inline void init_var_locality(void *data,size_t len,size_t offset,size_t *shape,size_t *dshapes,int dims_size,double shift,TYPE type){ size_t i,j; int size=get_type_size(type); size_t idx[dims_size]; double min,max; size_t pos; double center=1; for(i=0;i<len;i++){ get_idx(idx,i,dshapes,dims_size); idx[0]+=offset; center=1; for(j=0;j<dims_size;j++){ center*=1.0*(idx[j]+1)/shape[j]; } /* min=1.0*(pow(center,1.0/3)-shift);*/ /* max=1.0*(pow(center,1.0/3)+shift);*/ /* pos=0;*/ /* for(j=0;j<dims_size;j++){*/ /* pos+=idx[j]+1;*/ /* }*/ /* min=1.0*(pos-max_pos*shift)/max_pos;*/ /* max=1.0*(pos+max_pos*shift)/max_pos;*/ /* printf("%lf %lf %d\n",min,max,max_pos);*/ /* if(min<0){*/ /* min=0;*/ /* }*/ /* if(max>1){*/ /* max=1;*/ /* }*/ /* random(((char *)data+i*size),min,max,type);*/ double val=pow(center,1.0/3); /* double val=center;*/ setval(((char *)data+i*size),val,type); /* getval(((char *)data+i*size),i+offset,type);*/ /* *(double *)data=i;*/ } }