void calc_src_coef2(u32 *div_M, u32 *fac_N, u32 freq) { u32 m, n; u64 temp; u32 temp_m = 0; u32 temp_n = 0; u64 cur_val = 0; if(freq > 4200000000UL) { freq = 4200000000UL; __wrn("warning: freq set is over 4200M\n"); } for(n = 12; n < 256; n++) for(m = 0; m < 2; m++) { temp = n; temp = temp * 24000000; temp = temp / (m + 1); if(dif(temp, freq) < dif(cur_val, freq)) { temp_m = m; temp_n = n; cur_val = temp; } } *div_M = temp_m; *fac_N = temp_n; }
void calc_pll8_coef(u32 *div_M, u32 *div_P, u32 *fac_N, u32 freq) { u32 m, p, n; u64 temp; u32 temp_m = 0; u32 temp_p = 0; u32 temp_n = 0; u64 cur_val = 0; if(freq > 4200000000UL) { freq = 4200000000UL; __wrn("warning: freq set is over 4200M\n"); } for(n = 12; n < 256; n++) for(m = 0; m < 2; m++) for(p = 0; p < 3; p++) { temp = n; temp = temp * 24000000; temp = temp / ((m + 1) * pow2(p)); if(dif(temp, freq) < dif(cur_val, freq)) { temp_m = m; temp_p = p; temp_n = n; cur_val = temp; } } *div_M = temp_m; *div_P = temp_p; *fac_N = temp_n; }
static status centerArea(Area a, Point pos) { assign(a, x, dif(pos->x,a->w)); assign(a, y, dif(pos->y,a->h)); succeed; }
void compute( const FUNC& f, const X & x, const o_t & o) { real_t tmptol = tol_; init(o, x); BOOST_AUTO_TPL(dif, nt2::abs(nt2::diff(nt2::rowvect(wpts_)))); real_t tol1= tol_/nt2::globalasum1(dif); size_t l = numel(dif); res_.resize(extent(wpts_)); res_(1) = nt2::Zero<value_t>(); tol_ = tol1*dif(1); res_(2) = compute<true>(f, wpts_(1), wpts_(2)); for(size_t i=2; i < l; ++i) { tol_ = tol1*dif(i); res_(i+1) = res_(i)+compute<false>(f, wpts_(i), wpts_(i+1)); } if (l >= 2) { tol_ = tol1*dif(l); res_(l+1) = res_(l)+compute<true>(f, wpts_(l), wpts_(l+1)); } tol_ = tmptol; if (!o.return_waypoints) { res_(begin_) = res_(end_); res_.resize(nt2::of_size(1, 1)); } }
void calc_src_coef3(u32 *div_M, u32 *fac_K, u32 *fac_N, u32 src_freq, u32 freq) { u32 m, k, n; u64 temp; u32 temp_m = 0; u32 temp_k = 0; u32 temp_n = 0; u64 cur_val = 0; freq = freq > 1440000000 ? 1440000000 : freq; for(n = 0; n < 16; n++) for(k = 0; k < 4; k++) for(m = 0; m < 16; m++) { temp = src_freq; temp = temp * (n + 1) * (k + 1) / (m + 1); if(dif(temp, freq) < dif(cur_val, freq)) { temp_m = m; temp_k = k; temp_n = n; cur_val = temp; } } *div_M = temp_m; *fac_K = temp_k; *fac_N = temp_n; }
void calc_src_coef2(u32 *div_M, u32 *fac_N, u32 freq) { u32 m, n; u64 temp; u32 temp_m = 0; u32 temp_n = 0; u64 cur_val = 0; freq = freq > 1440000000 ? 1440000000 : freq; for(n = 0; n < 128; n++) for(m = 0; m < 16; m++) { temp = 24000000 * (n + 1) / (m + 1); if(dif(temp, freq) < dif(cur_val, freq)) { temp_m = m; temp_n = n; cur_val = temp; } } *div_M = temp_m; *fac_N = temp_n; }
int main() { int L; char h[2000001]; while (scanf("%d ", &L) && L) { gets(h); int ur = INF, ud = INF, dist = INF, dist_a; for (int i = 0; i < L; i++) { if (h[i] == 'Z') { dist = 0; break; } else if (h[i] == 'R') { ur = i; if ((dist_a = dif(ur, ud)) < dist) dist = dist_a; } else if (h[i] == 'D') { ud = i; if ((dist_a = dif(ur, ud)) < dist) dist = dist_a; } } printf("%d\n", dist); } return 0; }
// Distance between 2 points _inline int GetDistance(int xp, int yp, int xp2, int yp2) { // Allow decimal calculation double x = xp; double y = yp; double x2 = xp2; double y2 = yp2; return (int)sqrt((dif (x,x2) * dif (x,x2))+(dif (y,y2) * dif (y,y2))); }
/* * handles the "directive" state after the "ignore" state */ static int direce(lex_t *t) { int i = NELEM(dtab), ign; assert(cond_ignore()); ign = cond_list->f.ignore; NEXTSP(t); /* consumes # */ if (t->id == LEX_ID) { const char *n = LEX_SPELL(t); for (i = 0; i < NELEM(dtab); i++) if (strcmp(n, dtab[i].name) == 0) break; switch(i) { case DINCLUDE: case DDEFINE: case DUNDEF: case DLINE: case DERROR: case DPRAGMA: default: i = NELEM(dtab); break; case DIF: t = dif(t->pos, COND_KIF, 1); break; case DIFDEF: t = dif(t->pos, COND_KIFDEF, 1); break; case DIFNDEF: t = dif(t->pos, COND_KIFNDEF, 1); break; case DELIF: t = delif(t->pos); break; case DELSE: t = delse(t->pos); break; case DENDIF: t = dendif(t->pos); break; } } if (warnxtra[i] && ign != 2) { SKIPSP(t); if (t->id != LEX_NEWLINE) t = xtratok(t); } SKIPNL(t); lst_discard(1); lex_direc = 0; return 0; }
void title::sceneChange() { if (state_ > Blink3) { clear_ ? data::reStart(dif(click_mode_ - Easy)) : data::newGame(dif(click_mode_ - Easy)); data::system.scene_[play::Next] = scene::Politics; } if (click_mode_ == Continue && state_ > Blink2) { data::system.scene_[play::Last] = scene::Title; data::system.scene_[play::Next] = scene::Load; } }
void test(){ std::cout << sum_of_2_numbers(3,5,999) << std::endl; std::cout << sum_of_fib(4000000) << std::endl; factorize(13195); factorize(600851475143); std::cout << findPalindrom() << std::endl; std::cout << dif(10) << std::endl; std::cout.precision(20); std::cout << dif(100) << std::endl; //std::cout << prime10001() << std::endl; std::cout << biggestProduct("/home/paulina/ClionProjects/EulerProb1/Problem8") << std::endl; }
void CGeoSquareProjectile::Draw(void) { inArray=true; unsigned char col[4]; col[0]=(unsigned char) (r*a*255); col[1]=(unsigned char) (g*a*255); col[2]=(unsigned char) (b*a*255); col[3]=(unsigned char) (a*255); float3 dif(p1-camera->pos); dif.Normalize(); float3 dir1(dif.cross(v1)); dir1.Normalize(); float3 dif2(p2-camera->pos); dif2.Normalize(); float3 dir2(dif2.cross(v2)); dir2.Normalize(); if(w2!=0){ va->AddVertexTC(p1-dir1*w1,1.0/16,1.0/8,col); va->AddVertexTC(p1+dir1*w1,1.0/16,0.0/8,col); va->AddVertexTC(p2+dir2*w2,1.0/16,0.0/8,col); va->AddVertexTC(p2-dir2*w2,1.0/16,1.0/8,col); } else { va->AddVertexTC(p1-dir1*w1,1.0/16,1.0/8,col); va->AddVertexTC(p1+dir1*w1,1.0/16,0.0/8,col); va->AddVertexTC(p2+dir2*w2,1.0/16,0.5/8,col); va->AddVertexTC(p2-dir2*w2,1.0/16,1.5/8,col); } }
int trap(int A[], int n) { vector<int> left(n,0),right(n,0); int max=0; for(int i=0;i<n;++i) { left[i] = max; if(max<A[i]) max=A[i]; } max = 0; for(int i=n-1;i>=0;--i) { right[i] = max; if(max<A[i]) max=A[i]; } vector<int> filled(n,0),dif(n,0); int ret = 0; for(int i=0;i<n;++i) { filled[i] = min(left[i],right[i]); dif[i] = filled[i]-A[i]; if(dif[i]>0) ret += dif[i]; } return ret; }
void GUIminimap::MoveView(int xpos, int ypos, int button) { float dist=ground->LineGroundCol(camera->pos,camera->pos+camera->forward*9000); float3 dif(0,0,0); if(dist>0){ dif=camera->forward*dist; } float camHeight=camera->pos.y-ground->GetHeight(camera->pos.x,camera->pos.z); float3 clickPos; float xrel=xpos/(float)w; float yrel=ypos/(float)h; // FIXME: magic number: is this 8 maybe SQUARE_SIZE? clickPos.x=xrel*gs->mapx*8; clickPos.z=yrel*gs->mapy*8; float3 finalPos=clickPos-dif; if(guiGameControl->DirectCommand(clickPos, button)) { downInMinimap=false; return; } if(button!=1) return; mouse->currentCamController->SetPos(clickPos); }
void CExploSpikeProjectile::Draw(void) { inArray=true; float3 dif(pos-camera->pos2); dif.Normalize(); float3 dir2(dif.cross(dir)); dir2.Normalize(); unsigned char col[4]; float a=std::max(0.f,alpha-alphaDecay*gu->timeOffset)*255; col[0]=(unsigned char)(a*color.x); col[1]=(unsigned char)(a*color.y); col[2]=(unsigned char)(a*color.z); col[3]=1; float3 interpos=pos+speed*gu->timeOffset; float3 l=dir*length+lengthGrowth*gu->timeOffset; float3 w=dir2*width; va->AddVertexTC(interpos+l+w, ph->laserendtex.xend, ph->laserendtex.yend, col); va->AddVertexTC(interpos+l-w, ph->laserendtex.xend, ph->laserendtex.ystart, col); va->AddVertexTC(interpos-l-w, ph->laserendtex.xstart, ph->laserendtex.ystart, col); va->AddVertexTC(interpos-l+w, ph->laserendtex.xstart, ph->laserendtex.yend, col); }
void CGeoSquareProjectile::Draw() { inArray = true; unsigned char col[4]; col[0] = (unsigned char) (r * a * 255); col[1] = (unsigned char) (g * a * 255); col[2] = (unsigned char) (b * a * 255); col[3] = (unsigned char) ( a * 255); float3 dif(p1 - camera->GetPos()); dif.ANormalize(); float3 dir1(dif.cross(v1)); dir1.ANormalize(); float3 dif2(p2 - camera->GetPos()); dif2.ANormalize(); float3 dir2(dif2.cross(v2)); dir2.ANormalize(); const float u = (projectileDrawer->geosquaretex->xstart + projectileDrawer->geosquaretex->xend) / 2; const float v0 = projectileDrawer->geosquaretex->ystart; const float v1 = projectileDrawer->geosquaretex->yend; if (w2 != 0) { va->AddVertexTC(p1 - dir1 * w1, u, v1, col); va->AddVertexTC(p1 + dir1 * w1, u, v0, col); va->AddVertexTC(p2 + dir2 * w2, u, v0, col); va->AddVertexTC(p2 - dir2 * w2, u, v1, col); } else { va->AddVertexTC(p1 - dir1 * w1, u, v1, col); va->AddVertexTC(p1 + dir1 * w1, u, v0, col); va->AddVertexTC(p2, u, v0 + (v1 - v0) * 0.5f, col); va->AddVertexTC(p2, u, v0 + (v1 - v0) * 1.5f, col); } }
GMMExpectationMaximization::uint GMMExpectationMaximization::execute(const MatrixX & dataset) { const uint data_count = dataset.rows(); const uint num_gaussians = m_means.size(); const uint dim = dataset.cols(); MatrixX pxi(data_count,num_gaussians); MatrixX pix(data_count,num_gaussians); VectorX pxidatatot(data_count); VectorX weights(num_gaussians); VectorX ex(data_count); MatrixX ts(dim,dim); VectorX dif(dim); Real prev_log_likelyhood = 1.0; uint it_num; for (it_num = 0; it_num < m_max_iterations; it_num++) { for (uint g = 0; g < num_gaussians; g++) weights[g] = m_weights[g]; for (uint d = 0; d < data_count; d++) for (uint g = 0; g < num_gaussians; g++) pxi(d,g) = gauss(m_means[g],m_covs[g],dataset.row(d).transpose()); pxidatatot = pxi * weights; Real log_likelyhood = pxidatatot.array().log().sum() / Real(data_count); if (it_num != 0 && (std::abs(log_likelyhood / prev_log_likelyhood - 1.0) < m_termination_threshold)) break; prev_log_likelyhood = log_likelyhood; for (uint d = 0; d < data_count; d++) pix.row(d) = (pxi.row(d).transpose().array() * weights.array()).transpose() / pxidatatot[d]; ex = pix.colwise().sum(); for(uint g = 0; g < num_gaussians; g++) { m_weights[g] = ex[g] / Real(data_count); m_means[g] = (dataset.transpose() * pix.col(g)) / ex[g]; ts = MatrixX::Zero(dim,dim); for (uint d = 0; d < data_count; d++) { dif = dataset.row(d).transpose() - m_means[g]; ts.noalias() += (dif * dif.transpose()) * pix(d,g); } m_covs[g] = (ts / ex[g]) + MatrixX::Identity(dim,dim) * m_epsilon; } // interruption point here if (m_termination_handler && m_termination_handler->isTerminated()) return it_num; } return it_num; }
void Loader::LoadMaterial(const aiScene *pScene, const char *file_name) { //store material for(int i = 0 ;i<pScene->mNumMaterials;i++) { aiColor3D dif(0.f,0.f,0.f); aiColor3D amb(0.f,0.f,0.f); aiColor3D spec(0.f,0.f,0.f); aiMaterial * the_material = pScene->mMaterials[i]; CMC_Material * material = new CMC_Material(); the_material->Get(AI_MATKEY_COLOR_AMBIENT,amb); the_material->Get(AI_MATKEY_COLOR_DIFFUSE,dif); the_material->Get(AI_MATKEY_COLOR_SPECULAR,spec); material->ambientColor = QVector3D(amb.r,amb.g,amb.b); material->diffuseColor = QVector3D(dif.r,dif.g,dif.b); material->specularColor = QVector3D(spec.r,spec.g,spec.b); aiString normalPath; the_material->GetTexture (aiTextureType_NORMALS,0,&normalPath); //now ,we only use the first diffuse texture, will fix it later aiString diffuse_Path; the_material->GetTexture(aiTextureType_DIFFUSE,0,&diffuse_Path); if(diffuse_Path.length == 0 ) { material->diffuseTexturePath = "INVALID"; }else { material->diffuseTexturePath = diffuse_Path.C_Str (); } m_model->addMaterial (material); } }
void CGenericParticleProjectile::Draw() { inArray = true; if (directional) { float3 dif(pos-camera->GetPos()); dif.ANormalize(); float3 dir1(dif.cross(speed)); dir1.ANormalize(); float3 dir2(dif.cross(dir1)); unsigned char color[4]; colorMap->GetColor(color, life); va->AddVertexTC(drawPos - dir1 * size - dir2 * size, texture->xstart, texture->ystart, color); va->AddVertexTC(drawPos - dir1 * size + dir2 * size, texture->xend, texture->ystart, color); va->AddVertexTC(drawPos + dir1 * size + dir2 * size, texture->xend, texture->yend, color); va->AddVertexTC(drawPos + dir1 * size - dir2 * size, texture->xstart, texture->yend, color); } else { unsigned char color[4]; colorMap->GetColor(color, life); va->AddVertexTC(drawPos - camera->right * size - camera->up * size, texture->xstart, texture->ystart, color); va->AddVertexTC(drawPos + camera->right * size - camera->up * size, texture->xend, texture->ystart, color); va->AddVertexTC(drawPos + camera->right * size + camera->up * size, texture->xend, texture->yend, color); va->AddVertexTC(drawPos - camera->right * size + camera->up * size, texture->xstart, texture->yend, color); } }
void AresInterdictionManager::CleanTargets(void) { Vector v_tmp; v_tmp.EnsureSize(mv_interdiction_targets.Size()/2); CSingleLock lock(&m_lock,TRUE); CTime now=CTime::GetCurrentTime(); CTimeSpan dif(3,0,0,0); for(int i=0;i<(int)mv_interdiction_targets.Size();i++){ InterdictionTarget* it=(InterdictionTarget*)mv_interdiction_targets.Get(i); //if we haven't failed connecting to this target at least twice, then lets keep it for now //the target must be less than 3 days old as well if(it->m_fail_count<2 && it->m_create_time>(now-dif)){ v_tmp.Add(it); } else if(m_index>=i && m_index>0){ if(stricmp(it->GetStrIP().c_str(),"81.3.87.174")==0){ ASSERT(0); } m_index--; //decrememt the index so we don't skip over a large set of clients } } mv_interdiction_targets.Copy(&v_tmp); }
static void enumerate(uint64_t const n, uint64_t const k, edit_a & E, edit_b & BE) { uint64_t z = 1; for ( uint64_t i = 0; i < n; ++i ) z *= k; std::string a(n+3,'a'); for ( uint64_t i = 0; i < a.size(); ++i ) a[i] = 'a' + (libmaus::random::Random::rand8() % k); std::string b(n,' '); for ( uint64_t i = 0; i < z; ++i ) { uint64_t x = i; for ( uint64_t j = 0; j < n; ++j ) { b[j] = 'a' + (x % k); x /= k; } uint64_t const kmin = dif(a.size(),b.size()); testEdit(a,b,kmin,E,BE); testEdit(a,b,kmin+1,E,BE); testEdit(a,b,kmin+2,E,BE); } }
void CTorpedoProjectile::Update(void) { if(pos.y>-3){ //tracking etc only work when we have gotten underwater speed.y+=gs->gravity; if(dir.y>0) dir.y=0; dir=speed; dir.Normalize(); } else { if(pos.y-speed.y>-3){ //level out torpedo a bit when hitting water dir.y*=0.5; dir.Normalize(); } ttl--; if(ttl>0){ if(curSpeed<maxSpeed) curSpeed+=max(0.2,tracking); if(target){ float3 targPos; if((target->midPos-pos).SqLength()<150*150 || !owner) targPos=target->midPos; else targPos=helper->GetUnitErrorPos(target,owner->allyteam); if(targPos.y>0) targPos.y=0; float dist=targPos.distance(pos); float3 dif(targPos + target->speed*(dist/maxSpeed)*0.7 - pos); dif.Normalize(); float3 dif2=dif-dir; if(dif2.Length()<tracking){ dir=dif; } else { dif2-=dir*(dif2.dot(dir)); dif2.Normalize(); dir+=dif2*tracking; dir.Normalize(); } } speed=dir*curSpeed; } else { speed*=0.98; speed.y+=gs->gravity; dir=speed; dir.Normalize(); } } pos+=speed; if(pos.y<-2){ --nextBubble; if(nextBubble==0){ nextBubble=1+gs->randFloat()*1.5; float3 pspeed=gs->randVector()*0.1; pspeed.y+=0.2; new CBubbleProjectile(pos+gs->randVector(),pspeed,40+gs->randFloat()*30,1+gs->randFloat()*2,0.01,owner,0.3+gs->randFloat()*0.3); } } }
void CExploSpikeProjectile::Draw(void) { inArray=true; float3 dif(pos-camera->pos2); dif.Normalize(); float3 dir2(dif.cross(dir)); dir2.Normalize(); unsigned char col[4]; float a=std::max(0.f,alpha-alphaDecay*gu->timeOffset)*255; col[0]=(unsigned char)a; col[1]=(unsigned char)(a*0.8); col[2]=(unsigned char)(a*0.5); col[3]=1; float3 interpos=pos+speed*gu->timeOffset; float3 l=dir*length+lengthGrowth*gu->timeOffset; float3 w=dir2*width; va->AddVertexTC(interpos+l+w, 8/8.0, 1/8.0, col); va->AddVertexTC(interpos+l-w, 8/8.0, 0/8.0, col); va->AddVertexTC(interpos-l-w, 7/8.0, 0/8.0, col); va->AddVertexTC(interpos-l+w, 7/8.0, 1/8.0, col); }
void InMapDraw_QuadDrawer::DrawQuad(int x, int y) { int drawQuadsX = imd->drawQuadsX; CInMapDraw::DrawQuad* dq = &imd->drawQuads[y * drawQuadsX + x]; va->EnlargeArrays(dq->points.size()*12,0,VA_SIZE_TC); //! draw point markers for (std::list<CInMapDraw::MapPoint>::iterator pi = dq->points.begin(); pi != dq->points.end(); ++pi) { if (pi->MaySee(imd)) { float3 pos = pi->pos; float3 dif(pos - camera->pos); dif.ANormalize(); float3 dir1(dif.cross(UpVector)); dir1.ANormalize(); float3 dir2(dif.cross(dir1)); unsigned char col[4]; col[0] = pi->color[0]; col[1] = pi->color[1]; col[2] = pi->color[2]; col[3] = 200; float size = 6; float3 pos1 = pos; pos1.y += 5.0f; float3 pos2 = pos1; pos2.y += 100.0f; va->AddVertexQTC(pos1 - dir1 * size, 0.25f, 0, col); va->AddVertexQTC(pos1 + dir1 * size, 0.25f, 1, col); va->AddVertexQTC(pos1 + dir1 * size + dir2 * size, 0.00f, 1, col); va->AddVertexQTC(pos1 - dir1 * size + dir2 * size, 0.00f, 0, col); va->AddVertexQTC(pos1 - dir1 * size, 0.75f, 0, col); va->AddVertexQTC(pos1 + dir1 * size, 0.75f, 1, col); va->AddVertexQTC(pos2 + dir1 * size, 0.75f, 1, col); va->AddVertexQTC(pos2 - dir1 * size, 0.75f, 0, col); va->AddVertexQTC(pos2 - dir1 * size, 0.25f, 0, col); va->AddVertexQTC(pos2 + dir1 * size, 0.25f, 1, col); va->AddVertexQTC(pos2 + dir1 * size - dir2 * size, 0.00f, 1, col); va->AddVertexQTC(pos2 - dir1 * size - dir2 * size, 0.00f, 0, col); if (pi->label.size() > 0) { font->SetTextColor(pi->color[0]/255.0f, pi->color[1]/255.0f, pi->color[2]/255.0f, 1.0f); //FIXME (overload!) font->glWorldPrint(pos2 + UpVector * 6, 26.0f, pi->label); } } } lineva->EnlargeArrays(dq->lines.size()*2,0,VA_SIZE_C); //! draw line markers for (std::list<CInMapDraw::MapLine>::iterator li = dq->lines.begin(); li != dq->lines.end(); ++li) { if (li->MaySee(imd)) { lineva->AddVertexQC(li->pos - (li->pos - camera->pos).ANormalize() * 26, li->color); lineva->AddVertexQC(li->pos2 - (li->pos2 - camera->pos).ANormalize() * 26, li->color); } } }
bool CCannon::TryTarget(const float3 &pos, bool userTarget, CUnit* unit) { if (!CWeapon::TryTarget(pos, userTarget, unit)) { return false; } if (!weaponDef->waterweapon) { if (unit) { if (unit->isUnderWater) { return false; } } else { if (pos.y < 0) { return false; } } } if (projectileSpeed == 0) { return true; } float3 dif(pos - weaponMuzzlePos); float3 dir(GetWantedDir(dif)); if (dir.SqLength() == 0) { return false; } float3 flatdir(dif.x, 0, dif.z); float flatlength = flatdir.Length(); if (flatlength == 0) { return true; } flatdir /= flatlength; float gc = ground->TrajectoryGroundCol(weaponMuzzlePos, flatdir, flatlength - 10, dir.y , gravity / (projectileSpeed * projectileSpeed) * 0.5f); if (gc > 0) { return false; } const float quadratic = gravity / (projectileSpeed * projectileSpeed) * 0.5f; const float spread = ((accuracy + sprayAngle) * 0.6f) * ((1.0f - owner->limExperience * weaponDef->ownerExpAccWeight) * 0.9f); if (avoidFriendly && helper->TestTrajectoryCone(weaponMuzzlePos, flatdir, flatlength - 30, dir.y, quadratic, spread, 3, owner, CGameHelper::TEST_ALLIED)) { return false; } if (avoidNeutral && helper->TestTrajectoryCone(weaponMuzzlePos, flatdir, flatlength - 30, dir.y, quadratic, spread, 3, owner, CGameHelper::TEST_NEUTRAL)) { return false; } return true; }
int dif(Data at, Data ns) { if(ns.a > at.a || (ns.a == at.a && ns.m > at.m) || (ns.a == at.a && ns.m == at.m && ns.d > at.d)) return -1; ns.a++; return(dif(at, ns) + 1); }
void increaseSize(unsigned int*addr){ unsigned int* s=new unsigned int(sizeof(T)); if (addr>=s){ std::cout << "libm2::increaseSize size is already big enough (orig: " << *addr << " new: " << *s << ") - skipping "<< std::endl; return; } std::cout << "libm2::increaseSize increasing size (orig: " << *addr << " new: " << *s << ")"<< std::endl; dif(addr,s,4); }
int main() { double T(1e-1); double L(1e-6); double N(1e+4); double R(2.5e-9); double D(1e-12); double stirTime(T*0.5); libecs::initialize(); libecs::Model& model(*(new libecs::Model(*libecs::createDefaultModuleMaker()))); model.setup(); libecs::Stepper& stepper(*model.createStepper("SpatiocyteStepper", "SS")); stepper.setProperty("VoxelRadius", libecs::Polymorph(R)); stepper.setProperty("ThreadSize", libecs::Polymorph(libecs::Integer(2))); model.getRootSystem()->setProperty("StepperID", libecs::Polymorph("SS")); createVariable(model, "Variable:/:GEOMETRY", CUBOID); createVariable(model, "Variable:/:LENGTHX", L); createVariable(model, "Variable:/:LENGTHY", L); createVariable(model, "Variable:/:LENGTHZ", L); createVariable(model, "Variable:/:XYPLANE", PERIODIC); createVariable(model, "Variable:/:XZPLANE", PERIODIC); createVariable(model, "Variable:/:YZPLANE", PERIODIC); createVariable(model, "Variable:/:VACANT", 0); createVariable(model, "Variable:/:A", N); createVariable(model, "Variable:/:B", 0); /* libecs::Process& vis(createProcess(model, "VisualizationLogProcess", "Process:/:logger")); vis.registerVariableReference("_", libecs::String("Variable:/Surface:A"), 0); vis.registerVariableReference("_", libecs::String("Variable:/Surface:As"), 0); vis.loadProperty("LogInterval", libecs::Polymorph(0.01)); */ libecs::Process& pop(createProcess(model, "MoleculePopulateProcess", "Process:/:pop")); pop.registerVariableReference("_", libecs::String("Variable:/:A"), 0); libecs::Process& dif(createProcess(model, "DiffusionProcess", "Process:/:diffuseA")); dif.registerVariableReference("_", libecs::String("Variable:/:A"), 0); dif.loadProperty("D", libecs::Polymorph(D)); model.initialize(); run(model, stirTime); boost::posix_time::ptime start( boost::posix_time::microsec_clock::universal_time()); run(model, T); boost::posix_time::ptime end( boost::posix_time::microsec_clock::universal_time()); std::cout << "duration:" << end-start << std::endl; delete &model; libecs::finalize(); }
void InMapDraw_QuadDrawer::DrawQuad (int x,int y) { int drawQuadsX = imd->drawQuadsX; CInMapDraw::DrawQuad* dq=&imd->drawQuads[y*drawQuadsX+x]; for(std::list<CInMapDraw::MapPoint>::iterator pi=dq->points.begin();pi!=dq->points.end();++pi){ float3 pos=pi->pos; float3 dif(pos-camera->pos); float camDist=dif.Length(); dif/=camDist; float3 dir1(dif.cross(UpVector)); dir1.Normalize(); float3 dir2(dif.cross(dir1)); unsigned char col[4]; col[0]=pi->color[0]; col[1]=pi->color[1]; col[2]=pi->color[2]; col[3]=200;//intensity*255; float size=6; float3 pos1=pos; float3 pos2=pos1; pos2.y+=100; va->AddVertexTC(pos1-dir1*size, 0.25f,0,col); va->AddVertexTC(pos1+dir1*size, 0.25f,1,col); va->AddVertexTC(pos1+dir1*size+dir2*size, 0.00f,1,col); va->AddVertexTC(pos1-dir1*size+dir2*size, 0.00f,0,col); va->AddVertexTC(pos1-dir1*size,0.75f,0,col); va->AddVertexTC(pos1+dir1*size,0.75f,1,col); va->AddVertexTC(pos2+dir1*size,0.75f,1,col); va->AddVertexTC(pos2-dir1*size,0.75f,0,col); va->AddVertexTC(pos2-dir1*size, 0.25f,0,col); va->AddVertexTC(pos2+dir1*size, 0.25f,1,col); va->AddVertexTC(pos2+dir1*size-dir2*size, 0.00f,1,col); va->AddVertexTC(pos2-dir1*size-dir2*size, 0.00f,0,col); if(pi->label.size()>0){ glPushMatrix(); glTranslatef3(pi->pos+UpVector*105); glScalef(30,30,30); glColor4ub(pi->color[0],pi->color[1],pi->color[2],250); font->glWorldPrint("%s",pi->label.c_str()); glPopMatrix(); glBindTexture(GL_TEXTURE_2D, texture); } } for(std::list<CInMapDraw::MapLine>::iterator li=dq->lines.begin();li!=dq->lines.end();++li){ lineva->AddVertexC(li->pos-(li->pos - camera->pos).Normalize()*26,li->color); lineva->AddVertexC(li->pos2-(li->pos2 - camera->pos).Normalize()*26,li->color); } }
matrix operator-(const matrix& arg1, const matrix& arg2) { matrix dif(arg1.Rows,arg2.Columns); int Rows=arg1.Rows; int Columns=arg2.Columns; for (int i=0;i<Rows*Columns;i++) dif.TheMatrix[i]=arg1.TheMatrix[i]-arg2.TheMatrix[i]; if (!dif.TheMatrix) exit(1); return dif; }