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;
}
