static void to_xml(xml::element& e, FundInfo const& t) { set_element(e, "scalar_imf", t.ScalarIMF()); set_element(e, "short_name", t.ShortName()); set_element(e, "long_name" , t.LongName ()); set_element(e, "gloss" , t.gloss ()); }
dvl::pid_table::pid_table() { //register internal ids set_group(pid().set_group(GROUP_INTERNAL), L"INTERNAL"); set_element(EMPTY, L"EMPTY"); set_element(PARSER, L"PARSER"); //register diagnostic routines set_group(pid().set_group(GROUP_DIAGNOSTIC), L"DIAGNOSTIC"); set_element(ECHO, L"ECHO"); }
void MeshImplData::set_element( size_t index, const std::vector<long>& vertices, EntityTopology topology, MsqError& err ) { if (sizeof(long) == sizeof(size_t)) set_element( index, *reinterpret_cast<const std::vector<size_t>*>(&vertices), topology, err ); else { std::vector<size_t> conn(vertices.size()); std::copy( vertices.begin(), vertices.end(), conn.begin() ); set_element( index, conn, topology, err ); } }
void _switch_rows(struct matrix M, int first_row, int second_row){ set_error(NONE); if(first_row <= M.rows && second_row <= M.rows){ struct rational temp; int col; for(col=1; col<=M.columns; col++){ temp = get_element(M,first_row,col); set_element(M,first_row,col,get_element(M,second_row,col)); set_element(M,second_row,col,temp); } } else set_error(INCOMPATIBLE_MATRIX); }
void MeshImplData::reset_element( size_t index, const std::vector<size_t>& vertices, EntityTopology topology, MsqError& err ) { clear_element( index, err ); MSQ_ERRRTN(err); set_element( index, vertices, topology, err ); MSQ_ERRRTN(err); }
void Atom::set_atom_type(AtomType t) { get_particle()->set_value(get_atom_type_key(), t.get_index()); Element e= get_element_for_atom_type(t); if (e != UNKNOWN_ELEMENT) { set_element(e); } }
struct matrix transpose(struct matrix M) { struct matrix transpose = new_matrix(M.columns, M.rows); for (int i=1; i<=M.columns; i++) { for (int j=1; j<=M.rows; j++) { set_element(transpose,i,j, get_element(M,j,i)); } } return transpose; }
struct matrix scalar_multiply(struct rational a, struct matrix B){ //a * B struct matrix C = new_matrix(B.rows, B.columns); int i,j; for (i=1; i<=C.rows; i++) { for (j=1; j<=C.columns; j++) { set_element(C, i, j, r_multiply(a, get_element(B,i,j))); } } return C; }
void _multiply_row(struct matrix M, struct rational factor, int row){ set_error(NONE); if(row >0 && row<=M.rows){ int col; for(col=1; col<=M.columns; col++){ set_element(M,row,col,r_multiply(factor,get_element(M,row,col))); } } else set_error(INCOMPATIBLE_MATRIX); }
struct matrix copy_of_matrix (struct matrix M) { struct matrix copy; copy = new_matrix (M.rows,M.columns); int i,j; for (i=1; i<=M.rows; i++) { for (j=1; j<=M.columns; j++) { set_element(copy,i,j,get_element(M,i,j)); } } return copy; }
void _add_multiple(struct matrix M, struct rational factor, int input_row, int modified_row){ set_error(NONE); if(input_row > 0 && modified_row > 0 && input_row <= M.rows && modified_row <= M.rows){ struct rational temp; int col; for(col=1; col<=M.columns; col++){ temp = r_multiply(factor, get_element(M,input_row,col)); temp = r_add(temp, get_element(M,modified_row,col)); set_element(M,modified_row,col,temp); } } else set_error(INCOMPATIBLE_MATRIX); }
void RStarTreeNode::remove_element(const Uint32 index) { Uint32 end; assert(check_index(index)); end = get_count() - 1; if ((index != (get_count() - 1)) && (get_count() > 1)) { set_element(get_element(end), index); } m_count--; }
void linmin(pT& p,pT& xi,rT& fret,func_obj<rT,pT>& func) { // assert(p.size()==10); //assert(xi.size()==10); func_adaptor<rT,pT> fadpt(p,xi,func); int j=0; const rT TOL=std::sqrt(std::numeric_limits<rT>::epsilon()); rT xx=0,xmin=0,fx=0,fb=0,fa=0,bx=0,ax=0; int n=(int)get_size(p); ax=0.; xx=1.; mnbrak(ax,xx,bx,fa,fx,fb,fadpt); //cout<<xx<<endl; fret=brent(ax,xx,bx,fadpt,TOL,xmin); //cout<<xmin<<endl; #ifdef _OPENMP #pragma omp parallel for #endif for(j=0;j<n;++j) { //get_element(xi,j)*=xmin; set_element(xi,j, get_element(xi,j)*xmin); //get_element(p,j)+=get_element(xi,j); set_element(p,j, get_element(p,j)+get_element(xi,j)); } // delete xicom_p; //delete pcom_p; }
struct matrix subtract(struct matrix A, struct matrix B) { set_error(NONE); struct matrix C; int i,j; if (A.rows == B.rows && A.columns == B.columns){ C = new_matrix(A.rows, B.columns); for (i=1; i<=C.rows; i++) { for (j=1; j<=C.columns; j++) { set_element(C, i, j, r_subtract(get_element(A,i,j), get_element(B,i,j))); } } } else { C = new_matrix(0,0); set_error(INCOMPATIBLE_MATRIX); } return C; }
struct matrix multiply(struct matrix A, struct matrix B){ //A * B set_error(NONE); struct matrix C; int i,j; if (A.columns == B.rows){ C = new_matrix(A.rows, B.columns); for (i=1; i<=C.rows; i++) { for (j=1; j<=C.columns; j++) { set_element(C, i, j, row_times_column(A,i,B,j)); } } } else { C = new_matrix(0,0); set_error(INCOMPATIBLE_MATRIX); } return C; }
size_t MeshImplData::add_element( const std::vector<size_t>& vertices, EntityTopology topology, MsqError& err ) { size_t index; if (!deletedElementList.empty()) { index = deletedElementList[deletedElementList.size()-1]; deletedElementList.pop_back(); } else { index = elementList.size(); elementList.resize( elementList.size() + 1 ); } set_element( index, vertices, topology, err ); MSQ_ERRZERO(err); return index; }
rT do_eval(const rT& x) { //assert(p1.size()==xi1.size()); pT xt; opt_eq(xt,p1); #ifdef _OPENMP #pragma omp parallel for #endif for(size_t i=0;i<get_size(xt);++i) { //get_element(xt,i)+=x*get_element((pT)xi1,i); set_element(xt,i, get_element(xt,i)+x*get_element((pT)xi1,i)); //get_element((pT)xi1,i); } return const_cast<func_obj<rT,pT>&>(*pfoo).eval(xt); //return x; }
int search(char *matrix, int rows, int columns, int row, int column) { char *left, *right, *top, *bottom; int num_elements = ceil(1.0 * rows * columns / (sizeof(char) * 4)); if (row < 0 || row >= rows || column < 0 || column >= columns) { return 0; } print_matrix(matrix, rows, columns); char element = get_element(matrix, rows, columns, row, column); if (element == 2) { set_element(matrix, rows, columns, row, column, 3); return verified(matrix, rows, columns); } if (element == 3) { printf("--- FAIL ----\n"); return 0; } set_element(matrix, rows, columns, row, column, 3); left = create_matrix(rows, columns); memcpy(left, matrix, num_elements); right = create_matrix(rows, columns); memcpy(right, matrix, num_elements); bottom = create_matrix(rows, columns); memcpy(bottom, matrix, num_elements); top = create_matrix(rows, columns); memcpy(top, matrix, num_elements); set_element(right, rows, columns, row + 1, column, 1); set_element(left, rows, columns, row - 1, column, 1); set_element(bottom, rows, columns, row, column + 1, 1); set_element(top, rows, columns, row, column - 1, 1); int total = search(left, rows, columns, row - 1, column) + search(right, rows, columns, row + 1, column) + search(top, rows, columns, row, column - 1) + search(bottom, rows, columns, row, column + 1); free(left); free(right); free(top); free(bottom); return total; }
struct matrix submatrix (struct matrix M, int row, int column){ if (row >= 0 && row <= M.rows && column >= 0 && column <= M.columns){ struct matrix subM; if (row !=0 && column != 0) { subM = new_matrix(M.rows-1, M.columns-1); } else if ( row == 0 && column != 0) { subM = new_matrix(M.rows, M.columns-1); } else if ( row != 0 && column == 0) { subM = new_matrix(M.rows-1, M.columns); } int sub_row, sub_col; int orig_row, orig_col; int m_rows = M.rows; int m_columns = M.columns; if(row == m_rows) { m_rows--; } if(column == m_columns) { m_columns--; } for (sub_row =1, orig_row=1; orig_row<=m_rows; sub_row++, orig_row++) { if (orig_row == row) { orig_row++; } for (sub_col=1, orig_col=1; orig_col<=m_columns; sub_col++, orig_col++) { if (orig_col == column) { orig_col++; } set_element(subM,sub_row,sub_col,get_element(M,orig_row,orig_col)); } } return subM; } else { return M; } }
bool RStarTreeNode::add_element(const BoundedObjectPtr element) { Uint32 index; assert(element); if (get_count() < get_max_count()) { index = get_count(); m_count++; assert(get_count() <= get_max_count()); set_element(element, index); return true; } else { return false; } }
/** * Sets the group- and element-name of the given name to the values given by * arr, where arr[0] is the group- and arr[1] the element-name of the id. * * @param _id the id for which the names will be set * @param arr the array of names * * @see set_group * @see set_element */ void set(pid _id, std::array<std::wstring, 2>& arr) { set_group(_id, arr[0]); set_element(_id, arr[1]); }
void swap(T_container& arr,size_t i1,size_t i2) { auto temp=clone<typename element_type_trait<T_container>::element_type>(get_element(arr,i1)); set_element(arr,i1,get_element(arr,i2)); set_element(arr,i2,temp); }
T_ensemble_list ptsample(T_logprob&& logprob, const T_ensemble_list& ensemble_list, T_rng&& rng, const T_beta_list& beta_list, bool perform_swap, size_t nthread_allowed=1, typename std::result_of<T_logprob(typename element_type_trait<typename element_type_trait<T_ensemble_list>::element_type>::element_type)>::type a=2) { using T=typename std::result_of<T_logprob(typename element_type_trait<typename element_type_trait<T_ensemble_list>::element_type>::element_type)>::type; using T_var=typename element_type_trait<typename element_type_trait<T_ensemble_list>::element_type>::element_type; auto new_ensemble_list=clone(ensemble_list); size_t ntemp=get_size(ensemble_list); size_t nwalker=get_size(get_element(ensemble_list,0)); if(perform_swap) { /* for(size_t i=0;i<ntemp;++i) { shuffle(get_element(new_ensemble_list,i),rng); } */ for(size_t i=0;i<ntemp-1;++i) { T beta1=beta_list[i]; T beta2=beta_list[i+1]; if(beta1==beta2) { mcmc_exception e("beta list should not contain duplicated elements"); throw e; } for(size_t j=0;j<nwalker;++j) { auto var1=as<T_var>(get_element(get_element(new_ensemble_list,i),j)); auto var2=as<T_var>(get_element(get_element(new_ensemble_list,i+1),j)); T ep=exchange_prob(logprob,var1,var2,beta1,beta2); if(urng<T>(rng)<ep) { auto temp=clone<T_var>(get_element(get_element(new_ensemble_list,i),j)); set_element(get_element(new_ensemble_list,i),j, get_element(get_element(new_ensemble_list,i+1),j)); set_element(get_element(new_ensemble_list,i+1),j,temp); } } } } for(size_t i=0;i<ntemp;++i) { T beta=get_element(beta_list,i); set_element(new_ensemble_list,i,ensemble_sample([&logprob,beta](const T_var& x){ T lp=logprob(x); if(std::isinf(lp)) { return lp; } return lp*beta; },get_element(new_ensemble_list,i),rng,nthread_allowed,a)); } return new_ensemble_list; }
int get_range(bitstr_t *bits, int low, int high, const char **names, const char **pp) { /* range = number | number "-" number [ "/" number ] */ int i; int num1, num2, num3; if(**pp == '*') { /* '*' means "first-last" but can still be modified by /step */ num1 = low; num2 = high; ++(*pp); } else { if(get_number(&num1, low, names, pp) == ERR) return ERR; if (**pp != '-') { /* not a range, it's a single number. */ if(set_element(bits, low, high, num1) == ERR) return ERR; return OK; } else { /* eat the dash */ ++(*pp); /* get the number following the dash */ if(get_number(&num2, low, names, pp) == ERR) return ERR; } } /* check for step size */ if(**pp == '/') { /* eat the slash */ ++(*pp); /* get the step size */ if(get_number(&num3, low, names, pp) == ERR) return ERR; } else { /* no step. default==1. */ num3 = 1; } /* range. set all elements from num1 to num2, stepping * by num3. (the step is a downward-compatible extension * proposed conceptually by bob@acornrc, syntactically * designed then implmented by paul vixie). */ for(i = num1; i <= num2; i += num3) if(set_element(bits, low, high, i) == ERR) return ERR; return OK; }
static int get_range(bitstr_t *bits, int low, int high, const char * const names[], int ch, FILE *file) { /* range = number | number "-" number [ "/" number ] */ int i, num1, num2, num3; int qmark, star; qmark = star = FALSE; Debug(DPARS|DEXT, ("get_range()...entering, exit won't show\n")); if (ch == '*') { /* '*' means "first-last" but can still be modified by /step */ star = TRUE; num1 = low; num2 = high; ch = get_char(file); if (ch == EOF) return (EOF); } else if (ch == '?') { qmark = TRUE; ch = get_char(file); if (ch == EOF) return EOF; if (!isdigit(ch)) { num1 = random_with_range(low, high); if (EOF == set_element(bits, low, high, num1)) return EOF; return ch; } } if (!star) { ch = get_number(&num1, low, names, ch, file, ",- \t\n"); if (ch == EOF) return (EOF); if (ch != '-') { /* not a range, it's a single number. * a single number after '?' is bogus. */ if (qmark) return EOF; if (EOF == set_element(bits, low, high, num1)) { unget_char(ch, file); return (EOF); } return (ch); } else { /* eat the dash */ ch = get_char(file); if (ch == EOF) return (EOF); /* get the number following the dash */ ch = get_number(&num2, low, names, ch, file, "/, \t\n"); if (ch == EOF || num1 > num2) return (EOF); /* if we have a random range, it is really * like having a single number. */ if (qmark) { if (num1 > num2) return EOF; num1 = random_with_range(num1, num2); if (EOF == set_element(bits, low, high, num1)) return EOF; return ch; } } } /* check for step size */ if (ch == '/') { /* '?' is incompatible with '/' */ if (qmark) return EOF; /* eat the slash */ ch = get_char(file); if (ch == EOF) return (EOF); /* get the step size -- note: we don't pass the * names here, because the number is not an * element id, it's a step size. 'low' is * sent as a 0 since there is no offset either. */ ch = get_number(&num3, 0, PPC_NULL, ch, file, ", \t\n"); if (ch == EOF || num3 == 0) return (EOF); } else { /* no step. default==1. */ num3 = 1; } /* range. set all elements from num1 to num2, stepping * by num3. (the step is a downward-compatible extension * proposed conceptually by bob@acornrc, syntactically * designed then implemented by paul vixie). */ for (i = num1; i <= num2; i += num3) if (EOF == set_element(bits, low, high, i)) { unget_char(ch, file); return (EOF); } return (ch); }
int main(int argc, char *argv[]) { int rows = 8; int columns = 7; //4; char *matrix = create_matrix(rows, columns); /* set_element(matrix, rows, columns, 0, 0, 1); set_element(matrix, rows, columns, 0, 1, 0); set_element(matrix, rows, columns, 0, 2, 0); set_element(matrix, rows, columns, 0, 3, 0); set_element(matrix, rows, columns, 1, 0, 0); set_element(matrix, rows, columns, 1, 1, 0); set_element(matrix, rows, columns, 1, 2, 0); set_element(matrix, rows, columns, 1, 3, 0); set_element(matrix, rows, columns, 2, 0, 0); set_element(matrix, rows, columns, 2, 1, 0); set_element(matrix, rows, columns, 2, 2, 2); set_element(matrix, rows, columns, 2, 3, 3); */ set_element(matrix, rows, columns, 0, 0, 1); set_element(matrix, rows, columns, 0, 1, 0); set_element(matrix, rows, columns, 0, 2, 0); set_element(matrix, rows, columns, 0, 3, 0); set_element(matrix, rows, columns, 0, 4, 0); set_element(matrix, rows, columns, 0, 5, 0); set_element(matrix, rows, columns, 0, 6, 0); set_element(matrix, rows, columns, 1, 0, 0); set_element(matrix, rows, columns, 1, 1, 0); set_element(matrix, rows, columns, 1, 2, 0); set_element(matrix, rows, columns, 1, 3, 0); set_element(matrix, rows, columns, 1, 4, 0); set_element(matrix, rows, columns, 1, 5, 0); set_element(matrix, rows, columns, 1, 6, 0); set_element(matrix, rows, columns, 2, 0, 0); set_element(matrix, rows, columns, 2, 1, 0); set_element(matrix, rows, columns, 2, 2, 0); set_element(matrix, rows, columns, 2, 3, 0); set_element(matrix, rows, columns, 2, 4, 0); set_element(matrix, rows, columns, 2, 5, 0); set_element(matrix, rows, columns, 2, 6, 0); set_element(matrix, rows, columns, 3, 0, 0); set_element(matrix, rows, columns, 3, 1, 0); set_element(matrix, rows, columns, 3, 2, 0); set_element(matrix, rows, columns, 3, 3, 0); set_element(matrix, rows, columns, 3, 4, 0); set_element(matrix, rows, columns, 3, 5, 0); set_element(matrix, rows, columns, 3, 6, 0); set_element(matrix, rows, columns, 4, 0, 0); set_element(matrix, rows, columns, 4, 1, 0); set_element(matrix, rows, columns, 4, 2, 0); set_element(matrix, rows, columns, 4, 3, 0); set_element(matrix, rows, columns, 4, 4, 0); set_element(matrix, rows, columns, 4, 5, 0); set_element(matrix, rows, columns, 4, 6, 0); set_element(matrix, rows, columns, 5, 0, 0); set_element(matrix, rows, columns, 5, 1, 0); set_element(matrix, rows, columns, 5, 2, 0); set_element(matrix, rows, columns, 5, 3, 0); set_element(matrix, rows, columns, 5, 4, 0); set_element(matrix, rows, columns, 5, 5, 0); set_element(matrix, rows, columns, 5, 6, 0); set_element(matrix, rows, columns, 6, 0, 0); set_element(matrix, rows, columns, 6, 1, 0); set_element(matrix, rows, columns, 6, 2, 0); set_element(matrix, rows, columns, 6, 3, 0); set_element(matrix, rows, columns, 6, 4, 0); set_element(matrix, rows, columns, 6, 5, 0); set_element(matrix, rows, columns, 6, 6, 0); set_element(matrix, rows, columns, 7, 0, 2); set_element(matrix, rows, columns, 7, 1, 0); set_element(matrix, rows, columns, 7, 2, 0); set_element(matrix, rows, columns, 7, 3, 0); set_element(matrix, rows, columns, 7, 4, 0); set_element(matrix, rows, columns, 7, 5, 3); set_element(matrix, rows, columns, 7, 6, 3); print_matrix(matrix, rows, columns); printf("%d\n", search(matrix, rows, columns, 0, 0)); return 0; }
void Snake::tick() { direction mov_dir; byte x; byte y; byte new_sid; if (_game_over) return; if (_food_timer == 0) // time to spawn food { _food_x = random(_max_x-2)+1; // don't spawn on border _food_y = random(_max_y-2)+1; } // move head next_pos(_dir, &_head_x, &_head_y); // Test for hitting edge if ( (_head_x == 0) || (_head_x == _max_x-1) || (_head_y == 0) || (_head_y == _max_y-1) ) { _game_over = true; return; } // Test for eating food if (_food_x != 0) { if ((_head_x == _food_x) && (_head_y == _food_y)) { if (_food_timer == 0) { // food spawned on the new location of the head... try spawning again next tick _food_x = 0; _food_y = 0; } else { // Food eaten! _food_timer = 0; _food_x = 0; _food_y = 0; if (_snake_len < (SNAKE_ARRAY_SIZE*8)) _snake_len++; } } } x = _head_x; y = _head_y; // Move tail. Well, recalc how each element links to the next mov_dir = _dir; for (int i=0; i < _snake_len; i++) { next_pos(mov_dir, &x, &y); // Lookout for heading touching tail if ((x==_head_x) && (y==_head_y) && (i < _snake_len - 1)) _game_over = true; // Check food just spawned isn't on the snake if (x==_food_x && y==_food_y && _food_x > 0 && _food_y > 0 && _food_timer == 0) { _food_x = 0; _food_y = 0; _food_timer = 0; } mov(mov_dir, get_element(i), &mov_dir, &new_sid); set_element(i, new_sid); } if (_food_x!=0) _food_timer = 1; }