// Reserva memoria para la matriz de la imagen void buildmatrix() { int i; // Límite superior - límite inferior dimx = _div(par.c - par.a, par.s) +1; dimy = _div(par.d - par.b, par.s) +1; // printf("Construyendo matriz de puntos [%d, %d] ... ", dimx, dimy); // Creacion de la memoria compartida shm_fd = shm_open("/matrix", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); if(shm_matrix == -1) { printf("\n* Error fatal al intentar crear la memoria compartida\n"); exit(1); } if (ftruncate(shm_fd, sizeof(double) * dimx * dimy) != 0) { printf("\n* Error fatal al intentar truncar la memoria compartida\n"); exit(1); } // Mappeo de la memoria compartida para darle el tamaño matrix = (double *) mmap(NULL, sizeof(double) * dimx * dimy, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0); if(matrix == MAP_FAILED) { printf("\n* Error fatal al mapear la memoria compartida\n"); exit(1); } // printf("OK\n"); }
/* Printf an integer */ int printi(char** dst, int i, int b, int sg, int width, int pad, int letbase) { char print_buf[PRINT_BUF_LEN]; char *s; int t, neg = 0, pc = 0; unsigned int u = i; if (i == 0) { print_buf[0] = '0'; print_buf[1] = '\0'; return prints (dst, print_buf, width, pad); } if (sg && b == 10 && i < 0) { neg = 1; u = -i; } s = print_buf + PRINT_BUF_LEN-1; *s = '\0'; while (u) { if ( b == 16 ) t = u & 0xf; /* hex modulous */ else t = u - ( _div (u, b) * b ); /* Modulous */ if( t >= 10 ) t += letbase - '0' - 10; *--s = t + '0'; /* u /= b; */ if ( b == 16) u = u >> 4; /* divide by 16 */ else u = _div(u, b); }
static CRATIONAL *_divf(CRATIONAL *a, double f, bool invert) { my_mpq_set_d(_tmp.n, f); if (invert) return _div(&_tmp, a, FALSE); else return _div(a, &_tmp, FALSE); }
static CRATIONAL *_divo(CRATIONAL *a, void *o, bool invert) { if (GB.Is(o, CLASS_BigInt)) { mpq_set_z(_tmp.n, ((CBIGINT *)o)->n); if (invert) return _div(&_tmp, a, FALSE); else return _div(a, &_tmp, FALSE); } else return NULL; }
static Value * eval(const Ast *expr) { switch(expr->class) { case N_CALL: return call(expr); case N_ASSIGNMENT: return assignment(expr); case N_IDENTIFIER: return identifier(expr); case N_NEG: return _neg(expr); case N_NOT: return _not(expr); case N_EQ: return _eq(expr); case N_NEQ: return _neq(expr); case N_AND: return _and(expr); case N_IOR: return _ior(expr); case N_XOR: return _neq(expr); // alias case N_LT: return _lt(expr); case N_LE: return _le(expr); case N_GE: return _ge(expr); case N_GT: return _gt(expr); case N_ADD: return _add(expr); case N_SUB: return _sub(expr); case N_MUL: return _mul(expr); case N_DIV: return _div(expr); case N_POW: return _pow(expr); case N_MOD: return _mod(expr); case N_BOOLEAN: return _bool(expr); case N_INTEGER: return _int(expr); case N_FLOAT: return _float(expr); case N_STRING: return _string(expr); case N_SET: return _set(expr); case N_R: return _relation(expr); } printf("EVALFAIL %d ", expr->class); pn(expr); assert(false && "should not be reached"); }
static CBIGINT *_divf(CBIGINT *a, double f, bool invert) { if (invert) { CBIGINT *b; mpz_t n; mpz_init_set_d(n, f); b = BIGINT_create(n); return _div(b, a, FALSE); } else { if (f > 0) { return BIGINT_make_int(a, f, mpz_tdiv_q_ui); } else if (f < 0) { a = BIGINT_make_int(a, (-f), mpz_tdiv_q_ui); mpz_neg(a->n, a->n); return a; } else { GB.Error(GB_ERR_ZERO); return NULL; } } }
void tast02() { int a, b; char op; do { printf("Type qeuation: "); scanf("%d%c%d", &a, &op, &b); switch (op) { case '+': printf("res: %d\n", sum(a, b)); break; case '-': printf("res: %d\n", sub(a, b)); break; case '*': printf("res: %d\n", mult(a, b)); break; case '/': printf("res: %f\n", _div(a, b)); break; case 'q': printf("Exit\n"); break; default: printf("I didn't understend operator %c\n", op); } } while (op != 'q'); }
template <class _Tp2> __device__ _Self& operator/= (const complex<_Tp2>& __z) { value_type __r; value_type __i; _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i); _M_re = __r; _M_im = __i; return *this; }
__device__ _Self& operator/= (const _Self& __z) { value_type __r; value_type __i; _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i); _M_re = __r; _M_im = __i; return *this; }
__device__ complex<double>& operator/= (const complex<_Tp2>& __z) { double __r; double __i; _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i); _M_re = __r; _M_im = __i; return *this; }
__device__ complex<float>& operator/= (const complex<_Tp2>& __z) { float __r; float __i; _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i); _M_re = __r; _M_im = __i; return *this; }
/* * Executes a given instruction, or errors out * ins - instruction to run */ void execute (unsigned short int ins) { /* seperate instruction into parts */ short int a0 = (ins >> 12) % 16; short int a1 = (ins >> 8) % 16; short int a2 = (ins >> 4) % 16; short int a3 = (ins >> 0) % 16; /* Run associated instruction */ switch(a0) { case 0x0: _add (a1, a2, a3); break; case 0x1: _sub (a1, a2, a3); break; case 0x2: _mul (a1, a2, a3); break; case 0x3: _div (a1, a2, a3); break; case 0x6: _beq (a1, a2, a3); break; case 0x7: _bgt (a1, a2, a3); break; case 0x8: _ld (a1, a2, a3); break; case 0x9: _st (a1, a2, a3); break; case 0xa: _lc (a1, a3); break; case 0xb: _jmp (a1, a3); break; case 0xc: _inc (a1, a3); break; case 0xf: _sys (a1, a3); break; default: printf ("Error: invalid opcode %#x.\n", a0); sys_dump (0x0); sys_halt (0x0); } }
/* * Compute the largest value no greater than y which is on a * grid row */ xFixed RenderSampleFloorY (xFixed y, int n) { xFixed f = xFixedFrac(y); xFixed i = xFixedFloor (y); f = _div(f - Y_FRAC_FIRST(n), STEP_Y_SMALL(n)) * STEP_Y_SMALL(n) + Y_FRAC_FIRST(n); if (f < Y_FRAC_FIRST(n)) { f = Y_FRAC_LAST(n); i -= xFixed1; } return (i | f); }
ISTBOOL GetParams(struct sphere_model *model, ISTFLOAT rad) { ISTSHORT i, j; ISTFLOAT min[3] = {0}; ISTFLOAT max[3] = {0}; ISTFLOAT mean[3] = {0}; ISTFLOAT var[3] = {0}; ISTFLOAT tmpf; ISTFLOAT two = _float(2); for (j = 0; j < 3; j++) { min[j] = model->offsets[0][j]; max[j] = model->offsets[0][j]; for (i = 1; i < IST_SPHERE_OFFSET_NUM; i++) { if (_lt(model->offsets[i][j], min[j])) { min[j] = model->offsets[i][j]; } if (_gt(model->offsets[i][j], max[j])) { max[j] = model->offsets[i][j]; } } mean[j] = _div(_add(max[j], min[j]), two); var[j] = _sub(max[j], min[j]); } tmpf = _mul(rad, model->ratio); if (_ge(var[0], tmpf) || _ge(var[1], tmpf) || _ge(var[2], tmpf)) { goto EXIT; } for (j = 0; j < 3; ++j) { model->mean[j] = mean[j]; model->var[j] = var[j]; } model->rad = rad; return ISTTRUE; EXIT: return ISTFALSE; }
int main () { int i1 = 20, i2 = 4, i3; float f1 = 1.5,f2 = 0.3,f3; i3 = _add(i1, i2); printf("add(%d, %d)=%d\n", i1, i2, i3); i3 = _sub(i1, i2); printf("sub(%d, %d)=%d\n", i1, i2, i3); i3 = _mul(i1, i2); printf("mul(%d, %d)=%d\n", i1, i2, i3); i3 = _div(i1, i2); printf("div(%d, %d)=%d\n", i1, i2, i3); f3 = _fadd(f1, f2); printf("fadd(%f, %f)=%f\n", f1, f2, f3); f3 = _fsub(f1, f2); printf("fsub(%f, %f)=%f\n", f1, f2, f3); f3 = _fmul(f1, f2); printf("fmul(%f, %f)=%f\n", f1, f2, f3); f3 = _fdiv(f1, f2); printf("fdiv(%f, %f)=%f\n", f1, f2, f3); return 0; }
/* * TKGetNextToken returns the next token from the token stream as a * character string. Space for the returned token should be dynamically * allocated. The caller is responsible for freeing the space once it is * no longer needed. * * If the function succeeds, it returns a C string (delimited by '\0') * containing the token. Else it returns 0. * * You need to fill in this function as part of your implementation. */ TokenT *TKGetNextToken(TokenizerT *tk) { clearBuffer(tk); char curr = tk->inputIter[0]; // skip all whitespace before next token while(isspace(curr)) { nextChar(tk); clearBuffer(tk); curr = tk->inputIter[0]; } if(curr == '\0') { return NULL; } else if(isalpha(curr) || curr == '_') { return _word(tk); } else if(curr == '0') { return _zero(tk); } else if(isdigit(curr)) { return _decimal(tk); } else if(curr == '!') { // neq return _neq(tk); } else if(curr == '"') { // double_quote return _double_quote(tk); } else if(curr == '#') { return _pound(tk); } else if(curr == '$') { // INVALID return _invalid(tk); } else if(curr == '%') { // mod, mod_eq return _mod(tk); } else if(curr == '&') { // bit_and, log_and, address (?) return _bit_and(tk); } else if(curr == '\'') { // single_quote return _single_quote(tk); } else if(curr == '(') { // open_paren return _open_paren(tk); } else if(curr == ')') { // close_paren return _close_paren(tk); } else if(curr == '*') { // mult, mult_eq, pointer (?) return _mult(tk); } else if(curr == '+') { // plus, plus_eq, inc return _plus(tk); } else if(curr == ',') { // comma return _comma(tk); } else if(curr == '-') { // minus, minus_eq, dec, struct_pointer return _minus(tk); } else if(curr == '.') { // dot return _dot(tk); } else if(curr == '/') { // div, div_eq return _div(tk); } else if(curr == ':') { // ternary_colon return _ternary_colon(tk); } else if(curr == ';') { // semicolon return _semicolon(tk); } else if(curr == '<') { // lt, lshift, lt_eq return _lt(tk); } else if(curr == '=') { // eq, assign return _eq(tk); } else if(curr == '>') { // gt, rshift, gt_eq return _gt(tk); } else if(curr == '?') { // ternary_qmark return _ternary_qmark(tk); } else if(curr == '@') { // INVALID return _invalid(tk); } else if(curr == '[') { // open_bracket return _open_bracket(tk); } else if(curr == '\\') { // backslash (?) return _invalid(tk); } else if(curr == ']') { // close_bracket return _close_bracket(tk); } else if(curr == '^') { // bit_xor return _bit_xor(tk); } else if(curr == '`') { // INVALID return _invalid(tk); } else if(curr == '{') { // open_brace return _open_brace(tk); } else if(curr == '|') { // bit_or, log_or return _bit_or(tk); } else if(curr == '}') { // close_brace return _close_brace(tk); } else if(curr == '~') { // bit_not return _bit_not(tk); } else { return _invalid(tk); } }
void VMDriver::execute(){ if( this->m_state == STATE_IDLE ){ printf( "Error: state is idle. \n"); return; } assert( this->currentAssembly() ); while( this->isActive() ){ if( this->isBreak() ){ break; } unsigned char content = this->getByte( m_funcAddr , m_pc ); m_pc++; switch( content ){ case EMnemonic::MovPtr : _mov_ptr(); break; case EMnemonic::Mov : _mov(); break; case EMnemonic::Add : _add(); break; case EMnemonic::Sub : _sub(); break; case EMnemonic::Mul : _mul(); break; case EMnemonic::Div : _div(); break; case EMnemonic::Rem : _rem(); break; case EMnemonic::Inc : _inc(); break; case EMnemonic::Dec : _dec(); break; case EMnemonic::Push : _push(); break; case EMnemonic::PushPtr : _push_ptr(); break; case EMnemonic::Pop : _pop(); break; case EMnemonic::Call : _call(); break; case EMnemonic::ST : _st(); break; case EMnemonic::LD : _ld(); break; case EMnemonic::EndFunc : _endFunc(); break; case EMnemonic::CmpGeq : case EMnemonic::CmpG : case EMnemonic::CmpLeq : case EMnemonic::CmpL : case EMnemonic::CmpEq : case EMnemonic::CmpNEq : _cmp( content ); break; case EMnemonic::Not : _not(); break; case EMnemonic::Minus : _minus(); break; case EMnemonic::LogOr : case EMnemonic::LogAnd : _log( content ); break; case EMnemonic::Jmp : _jmp(); break; case EMnemonic::JumpZero : _jumpzero(); break; case EMnemonic::JumpNotZero : _jumpnotzero(); break; case EMnemonic::RET : _ret(); break; } } }
inline int divmod(T &num, const T &den) { T ret = _div(num,den); num = _mod(num,den); return ret; }
// Complex to matrix (Número complejo a posición de la matriz) int * ctom(double x, double y) { int * res = (int *) malloc(sizeof(int) * 2); res[0] = _div(x - par.a, par.s); res[1] = _div(y - par.b, par.s); return res; }
ISTBOOL GetSphereFrom4Points(struct sphere_model *model) { ISTFLOAT a[4][4] = {{0}}; ISTFLOAT ho[3] = {0}; ISTFLOAT norm = 0; ISTFLOAT rad = 0; ISTFLOAT tmpf = 0; ISTFLOAT two = _float(2); ISTFLOAT m11, m12, m13, m14, m15; ISTINT i, j; // Get sphere from 4 points for (i = 0; i < 4; i++) { /* find minor 11 */ a[i][0] = model->p4s[i][0]; a[i][1] = model->p4s[i][1]; a[i][2] = model->p4s[i][2]; a[i][3] = _one; } m11 = GetDet(a, 4); for (i = 0; i < 4; i++) { /* find minor 12 */ a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]), _mul(model->p4s[i][1], model->p4s[i][1])), _mul(model->p4s[i][2], model->p4s[i][2])); a[i][1] = model->p4s[i][1]; a[i][2] = model->p4s[i][2]; a[i][3] = _one; } m12 = GetDet(a, 4); for (i = 0; i < 4; i++) { /* find minor 13 */ a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]), _mul(model->p4s[i][1], model->p4s[i][1])), _mul(model->p4s[i][2], model->p4s[i][2])); a[i][1] = model->p4s[i][0]; a[i][2] = model->p4s[i][2]; a[i][3] = _one; } m13 = GetDet(a, 4); for (i = 0; i < 4; i++) { /* find minor 14 */ a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]), _mul(model->p4s[i][1], model->p4s[i][1])), _mul(model->p4s[i][2], model->p4s[i][2])); a[i][1] = model->p4s[i][0]; a[i][2] = model->p4s[i][1]; a[i][3] = _one; } m14 = GetDet(a, 4); for (i = 0; i < 4; i++) { /* find minor 15 */ a[i][0] = _add(_add(_mul(model->p4s[i][0], model->p4s[i][0]), _mul(model->p4s[i][1], model->p4s[i][1])), _mul(model->p4s[i][2], model->p4s[i][2])); a[i][1] = model->p4s[i][0]; a[i][2] = model->p4s[i][1]; a[i][3] = model->p4s[i][2]; } m15 = GetDet(a, 4); if (_eq(m11, 0)) { rad = 0; } else { /* center of sphere */ ho[0] = _div(_div(m12, m11), two); ho[1] = _neg(_div(_div(m13, m11), two)); ho[2] = _div(_div(m14, m11), two); norm = _sub(_add(_add(_mul(ho[0], ho[0]), _mul(ho[1], ho[1])), _mul(ho[2], ho[2])), _div(m15, m11)); if (_ge(norm, 0)) { rad = _sqrt(norm); } } if (_le(rad, 0)) { goto EXIT; } // Check distance for (i = 0; i < 4; i++) { for (j = (i + 1); j < 4; j++) { tmpf = GetDistance(model->p4s[i], model->p4s[j]); if (_lt(tmpf, rad) || _lt(tmpf, model->rad_min)) { goto EXIT; } } } // Update offset for (i = 1; i < IST_SPHERE_OFFSET_NUM; i++) { for (j = 0; j < 3; ++j) { model->offsets[IST_SPHERE_OFFSET_NUM - i][j] = model->offsets[IST_SPHERE_OFFSET_NUM - i - 1][j]; } } for (j = 0; j < 3; ++j) { model->offsets[0][j] = ho[j]; } for (i = (IST_SPHERE_DATAMAX >> 1); i < IST_SPHERE_DATAMAX; i++) { for (j = 0; j < 3; ++j) { model->data[i][j] = _max; } } // Check offset buffer full if (IsInitedVector(model->offsets[IST_SPHERE_OFFSET_NUM - 1])) { goto EXIT; } // Calculate mean bias and radius if (!GetParams(model, rad)) { goto EXIT; } return ISTTRUE; EXIT: return ISTFALSE; }