// ============================================================================ // DrawBox::draw() // convert particles from 3D space to 2D screen coordinates // compute blending values for particles and texture void DrawBox::draw( GLBox * glbox, const ParticlesData * part_data, const ParticlesSelectVector * _psv, const GlobalOptions * _store_options, QString shot_name) { const double * mProj = glbox->getProjMatrix(); double * mMod = const_cast<double*> (glbox->getModelMatrix()); // get data pointers viewport = glbox->getViewPort(); store_options = _store_options; psv = _psv; #define MP(row,col) mProj[col*4+row] #define MM(row,col) mMod[col*4+row] // get windows size width = viewport[2]; height= viewport[3]; // set windows size setGeometry(viewport[0],viewport[1],viewport[2],viewport[3]); //QPainter paint(this); //paint.eraseRect(viewport[0],viewport[1],viewport[2],viewport[3]); clearBuffer(); if (psv->size()) { // Zoom is located in ModelView matrix at coordinates MM(2,3) // loop on all object for (int i=0; i< (int ) psv->size(); i++ ) { // loop on all visible object selected particles //std::cerr << "----------\n"; if ((*psv)[i].vps->is_visible ) { for (int j = 0; j < (*psv)[i].vps->ni_index; j ++) { int jndex= (*psv)[i].vps->index_tab[j]; float x=part_data->pos[jndex*3 ], y=part_data->pos[jndex*3+1], z=part_data->pos[jndex*3+2], w=1; // do the product Mmodel X point = mxyzw float myzw0 = MM(0,1)*y + MM(0,2)*z + MM(0,3)*w; float mx = MM(0,0)*x + myzw0; float mx1= mx + store_options->texture_size/2.; // move X from half a texture float myzw1 = MM(1,1)*y + MM(1,2)*z + MM(1,3)*w; float my = MM(1,0)*x + myzw1; float MmzG = MM(2,1)*y + MM(2,2)*z; float Mmz = MM(2,0)*x + MmzG; float mz = Mmz + MM(2,3)*w; float mwG= MM(3,1)*y + MM(3,2)*z + MM(3,3)*w; float mw = MM(3,0)*x + mwG; // do the product Mproj X mxyzw = pxyzw float Ppx = MP(0,0)*mx + MP(0,1)*my + MP(0,3)*mw; float px = Ppx + MP(0,2)*mz; float px1 = MP(0,0)*mx1 + MP(0,1)*my + MP(0,3)*mw + MP(0,2)*mz; float Ppy= MP(1,0)*mx + MP(1,1)*my + MP(1,3)*mw; float py = Ppy + MP(1,2)*mz; float Ppz= MP(2,0)*mx + MP(2,1)*my + MP(2,3)*mw; float pz = Ppz + MP(2,2)*mz; float Ppw= MP(3,0)*mx + MP(3,1)*my + MP(3,3)*mw; float pw = Ppw + MP(3,2)*mz; float pw1 = MP(3,0)*mx1 + MP(3,1)*my + MP(3,3)*mw + MP(3,2)*mz; // normalyze //std::cerr << px << " " << py << " " << pz << "\n"; px /= pw; px1/= pw1; py /= pw; pz /= pw; //std::cerr << px << " " << py << " " << pz << "\n"; // compute screen coordinates float winx =viewport[0] + (1 + px) * viewport[2] / 2; float winx1=viewport[0] + (1 + px1) * viewport[2] / 2; float winy =viewport[1] + (1 + py) * viewport[3] / 2; // paint particles //paint.setPen(red); //paint.drawPoint((int) (winx), viewport[3]-(int) (winy)); #define MMAX(A,B) ((A)>(B)?(A):(B)) #define MMIN(A,B) ((A)<(B)?(A):(B)) //if (winx >= 0. && winy >= 0 && winx < 1024 && winy < 1024) { if (winx >= 0. && winy >= 0 && winx < width && winy < height && pz<1.0) { float size_texture = (int) fabs(winx1-winx); //std::cerr << "x=" << winx << " x1=" << winx1 << " size="<<size_texture<< "\n"; //color_rgba[(int) (winx)][(int) (winy)].blend(psv[i].vps->col,(float) (alpha)/255.); if (store_options->show_part) { //color_rgba[(int) (winx)][viewport[3]-1-(int) (winy)].blend((*psv)[i].vps->col, //(float) (store_options->particles_alpha)/255.); filterPoint( winx,winy,(*psv)[i].vps->col,(float) (store_options->particles_alpha)/255.); } //paint.drawPoint((int) (winx), (int) (winy)); if (store_options->show_poly) { float s4 = size_texture*4.; float ratio_texture = s4 - floor(s4); float ceil_texture = ceil(s4); texture->draw(this,psv,i,winx,winy,(int)(ceil_texture), ratio_texture); } } } } } } paintBuffer(shot_name); }
MP MP::new_ptr( MP model ) { return MP( 0, new Ptr( (qint64)model.m ) ); }
MP MP::operator[]( int index ) const { return MP( c, m and not p.size() ? m->attr( index ) : 0 ); }
MP MP::new_obj( QString type ) { return MP( 0, new ModelWithAttrAndName( type ) ); }
MP MP::new_lst() { return MP( 0, new Lst ); }
// 起点开始搜索 int dfs_large(int id, bool inload[], int cnt, int &best_cost, bool flag = false) { //cout << "dfs(" << id << "," << cnt << ")" << endl; if(id == eid) { best_cost = update_ans(ans_sum,ans); //update_good(ans_sum,ans); return FIND_SOLVE; } if(is_timeout()) { return TIME_OUT; // time out } // start bfs int (&last)[MAX_NODE_NUM] = g_last[cnt]; int (&w)[MAX_NODE_NUM] = g_w[cnt]; int (&dis)[MAX_NODE_NUM] = g_dis[cnt]; for(int i=0;i<node_size;i++) { last[i] = w[i] = dis[i] = -1; } int (&que)[MAX_NODE_NUM] = g_que[cnt]; int front = 0; int rear = 0; int find_cnt = 0; int find_cnt_limit = find_cnt_up; if(cnt == must_node_cnt) find_cnt_limit = 3; if(cnt == 1) find_cnt_limit = node_size*8; w[id] = 0; dis[id] = 0; que[rear++] = id; // 只剩下最后一个节点 , spfa if(cnt == 0) { int que_tag[MAX_NODE_NUM] = {0}; que_tag[id] = true; while(front != rear) { int now_id = que[front++]; if(front == MAX_NODE_NUM) front = 0; for(int i=0; i<node_next[now_id].size(); i++) { int r_node = edge_set[node_next[now_id][i]].r; if(inload[r_node]) continue; if(w[r_node] == -1 || w[now_id] + edge_set[node_next[now_id][i]].cost < w[r_node]) { w[r_node] = w[now_id] + edge_set[node_next[now_id][i]].cost; last[r_node] = now_id; if(!que_tag[r_node]) { que_tag[r_node] = true; que[rear++] = r_node; if(rear==MAX_NODE_NUM) rear = 0; } } } que_tag[now_id] = false; } if(w[eid] == -1) return cnt+1; int t_ans_sum = ans_sum; vector<int> load_nodes; load_nodes.push_back(eid); int tmp_id = eid; while(last[tmp_id] != -1) { tmp_id = last[tmp_id]; load_nodes.push_back(tmp_id); } reverse(load_nodes.begin(),load_nodes.end()); for(int i=0;i<load_nodes.size();i++) { //inload[load_nodes[i]] = true; if(i < load_nodes.size() - 1) { add_edge(load_nodes[i],load_nodes[i+1],ans_sum,ans); } } best_cost = update_ans(ans_sum,ans); //update_good(ans_sum,ans); ans_sum = t_ans_sum; return FIND_SOLVE; } int fin_res = cnt; int t_best_cost = 2000000; while(front < rear && find_cnt < find_cnt_limit) { if(cnt >= must_node_cnt - 5 && front > 0 && w[que[front]] != w[que[front-1]]) { vector<pair<int,int> > pp; for(int i=front;i<rear;i++) pp.push_back(MP(dis[que[i]],que[i])); sort(pp.begin(),pp.end()); for(int i=front;i<rear;i++) que[i] = pp[i-front].second; } int now_id = que[front++]; for(int i=0; i<node_next[now_id].size(); i++) { int r_node = edge_set[node_next[now_id][i]].r; if(inload[r_node] || w[r_node] != -1) continue; if(must_node[r_node] || (cnt == 0 && r_node == eid) ) { int t_ans_sum = ans_sum; //vector<int> load_nodes; vector<int> edge_nodes; //load_nodes.push_back(r_node); //load_nodes.push_back(now_id); edge_nodes.push_back(node_next[now_id][i]); int tmp_id = now_id; while(last[tmp_id] != -1) { tmp_id = last[tmp_id]; //load_nodes.push_back(tmp_id); edge_nodes.push_back(tmp_id); tmp_id = edge_set[tmp_id].l; } reverse(edge_nodes.begin(),edge_nodes.end()); for(int i=0;i<edge_nodes.size();i++) { //inload[load_nodes[i]] = true; inload[edge_set[edge_nodes[i]].r] = true; /* if(i < load_nodes.size() - 1) { add_edge(load_nodes[i],load_nodes[i+1],ans_sum,ans); } */ ans[ans_sum++] = edge_nodes[i]; } find_cnt ++; int t_t_best_cost = 2000000; int res = dfs_large(r_node, inload, cnt - 1, t_t_best_cost, flag); //find_cnt --; t_best_cost = min(t_best_cost,t_t_best_cost); best_cost = min(t_best_cost,best_cost); ans_sum = t_ans_sum; for(int i=0;i<edge_nodes.size();i++) { inload[edge_set[edge_nodes[i]].r] = false; } if(res == END_OUT) return res; fin_res = min(res, fin_res); int min_l = 8; int min_g = 8; if(!flag) { if(good_cost < INF_COST) { min_l = 5; min_g = 13; } if(cnt > min_l && cnt < must_node_cnt - min_g) return fin_res; //else if((cnt > min_l) && cnt < must_node_cnt - min_g + 3 && (fin_res > 0 || t_best_cost - 20 > good_cost)) else if(cnt > min_l - 1 && cnt < must_node_cnt - min_g + 5 && (fin_res > 0 || t_best_cost - 3 > good_cost)) return fin_res; } else { min_l = 6; min_g = 10; if(must_node_cnt > 22) { min_l = 8; min_g = 10; } if(good_cost < INF_COST) { if(node_size >= 300) { min_l = 6; min_g = 12; } else { min_l = 6; min_g = 10; } if(must_node_cnt > 22) { min_l = 8; min_g = 6; } } if(cnt > min_l && cnt < must_node_cnt - min_g )//&& t_best_cost > good_cost) return fin_res; else if(cnt < must_node_cnt - min_g - 2 && (t_best_cost - 3 > good_cost || cnt > 0) ) return fin_res; } } else { w[r_node] = w[now_id] + 1; dis[r_node] = dis[now_id] + edge_set[node_next[now_id][i]].cost; //last[r_node] = now_id; last[r_node] = node_next[now_id][i]; que[rear++] = r_node; } } } return fin_res; }
void addEdge(int u, int v, int id) { //cout << u << "<->" << v << endl; graph[u].PB(MP(v, id)); graph[v].PB(MP(u, id)); }
LL cross(PII a,PII b, PII c){ PII ab = MP(b.first-a.first,b.second-a.second); PII ac = MP(c.first-a.first,c.second-a.second); return ab.first*ac.second - ab.second*ac.first; }
int ProcessShowIml( PINSTALLATION_MODIFICATION_LOGFILE pIml ) { PIML_FILE_RECORD pFile; PIML_FILE_RECORD_CONTENTS pOldFile; PIML_FILE_RECORD_CONTENTS pNewFile; PIML_KEY_RECORD pKey; PIML_VALUE_RECORD pValue; PIML_VALUE_RECORD_CONTENTS pOldValue; PIML_VALUE_RECORD_CONTENTS pNewValue; PIML_INI_RECORD pIni; PIML_INISECTION_RECORD pSection; PIML_INIVARIABLE_RECORD pVariable; BOOLEAN FileNameShown; BOOLEAN SectionNameShown; if (pIml->NumberOfFileRecords > 0) { printf( "File Modifications:\n" ); pFile = MP( PIML_FILE_RECORD, pIml, pIml->FileRecords ); while (pFile != NULL) { pOldFile = MP( PIML_FILE_RECORD_CONTENTS, pIml, pFile->OldFile ); pNewFile = MP( PIML_FILE_RECORD_CONTENTS, pIml, pFile->NewFile ); printf( " %ws - ", MP( PWSTR, pIml, pFile->Name ) ); switch( pFile->Action ) { case CreateNewFile: printf( "created\n" ); break; case ModifyOldFile: printf( "overwritten\n" ); if (pOldFile != NULL) { printf( " Old size is %u bytes\n", pOldFile->FileSize ); } break; case DeleteOldFile: printf( "deleted\n" ); if (pOldFile != NULL) { printf( " Old size is %u bytes\n", pOldFile->FileSize ); } break; case ModifyFileDateTime: printf( "date/time modified\n" ); break; case ModifyFileAttributes: printf( "attributes modified\n" ); break; } pFile = MP( PIML_FILE_RECORD, pIml, pFile->Next ); } printf( "\n" ); } if (pIml->NumberOfKeyRecords > 0) { printf( "Registry Modifications:\n" ); pKey = MP( PIML_KEY_RECORD, pIml, pIml->KeyRecords ); while (pKey != NULL) { printf( " %ws - ", MP( PWSTR, pIml, pKey->Name ) ); switch( pKey->Action ) { case CreateNewKey: printf( "created\n" ); break; case DeleteOldKey: printf( "deleted\n" ); break; case ModifyKeyValues: printf( "modified\n" ); break; } pValue = MP( PIML_VALUE_RECORD, pIml, pKey->Values ); while (pValue != NULL) { pOldValue = MP( PIML_VALUE_RECORD_CONTENTS, pIml, pValue->OldValue ); pNewValue = MP( PIML_VALUE_RECORD_CONTENTS, pIml, pValue->NewValue ); printf( " %ws - ", MP( PWSTR, pIml, pValue->Name ) ); if (pValue->Action != DeleteOldValue) { printf( "%s [%x]", FormatEnumType( 0, ValueDataTypeNames, pNewValue->Type, FALSE ), pNewValue->Length ); if (pNewValue->Type == REG_SZ || pNewValue->Type == REG_EXPAND_SZ ) { printf( " '%ws'", MP( PWSTR, pIml, pNewValue->Data ) ); } else if (pNewValue->Type == REG_DWORD) { printf( " 0x%x", *MP( PULONG, pIml, pNewValue->Data ) ); } } if (pValue->Action == CreateNewValue) { printf( " (created)\n" ); } else { if (pValue->Action == DeleteOldValue) { printf( " (deleted" ); } else { printf( " (modified" ); } printf( " - was %s [%x]", FormatEnumType( 0, ValueDataTypeNames, pOldValue->Type, FALSE ), pOldValue->Length ); if (pOldValue->Type == REG_SZ || pOldValue->Type == REG_EXPAND_SZ ) { printf( " '%ws'", MP( PWSTR, pIml, pOldValue->Data ) ); } else if (pOldValue->Type == REG_DWORD) { printf( " 0x%x", *MP( PULONG, pIml, pOldValue->Data ) ); } printf( " )\n" ); } pValue = MP( PIML_VALUE_RECORD, pIml, pValue->Next ); } pKey = MP( PIML_KEY_RECORD, pIml, pKey->Next ); } printf( "\n" ); } if (pIml->NumberOfIniRecords > 0) { printf( ".INI File modifications:\n" ); pIni = MP( PIML_INI_RECORD, pIml, pIml->IniRecords ); while (pIni != NULL) { FileNameShown = FALSE; pSection = MP( PIML_INISECTION_RECORD, pIml, pIni->Sections ); while (pSection != NULL) { SectionNameShown = FALSE; pVariable = MP( PIML_INIVARIABLE_RECORD, pIml, pSection->Variables ); while (pVariable != NULL) { if (!FileNameShown) { printf( "%ws", MP( PWSTR, pIml, pIni->Name ) ); if (pIni->Action == CreateNewIniFile) { printf( " (created)" ); } printf( "\n" ); FileNameShown = TRUE; } if (!SectionNameShown) { printf( " [%ws]", MP( PWSTR, pIml, pSection->Name ) ); if (pSection->Action == CreateNewSection) { printf( " (created)" ); } else if (pSection->Action == DeleteOldSection) { printf( " (deleted)" ); } printf( "\n" ); SectionNameShown = TRUE; } printf( " %ws = ", MP( PWSTR, pIml, pVariable->Name ) ); if (pVariable->Action == CreateNewVariable) { printf( "'%ws' (created)\n", MP( PWSTR, pIml, pVariable->NewValue ) ); } else if (pVariable->Action == DeleteOldVariable) { printf( " (deleted - was '%ws')\n", MP( PWSTR, pIml, pVariable->OldValue ) ); } else { printf( "'%ws' (modified - was '%ws')\n", MP( PWSTR, pIml, pVariable->NewValue ), MP( PWSTR, pIml, pVariable->OldValue ) ); } pVariable = MP( PIML_INIVARIABLE_RECORD, pIml, pVariable->Next ); } pSection = MP( PIML_INISECTION_RECORD, pIml, pSection->Next ); } if (FileNameShown) { printf( "\n" ); } pIni = MP( PIML_INI_RECORD, pIml, pIni->Next ); } } return 0; }
inline void Trace::commit_memory(Clnum clnum, Address a, uint8_t d) { pair<map<Address, MemoryCell>::iterator, bool> ret = memory_.insert(MP(a, MemoryCell())); ret.first->second[clnum] = d; }
pair<float,float> getCentre(){ return MP(cx,cy); }
void Trace::process() { MUTEX_LOCK(backing_mutex_); EntryNumber entry_count = *((EntryNumber*)backing_); // don't let this change under me MUTEX_UNLOCK(backing_mutex_); if (entries_done_ >= entry_count) return; // handle the > case better remap_backing(sizeof(struct change)*entry_count); // what if this fails? printf("on %u going from %u to %u...", trace_index_, entries_done_, entry_count); fflush(stdout); #ifndef _WIN32 struct timeval tv_start, tv_end; gettimeofday(&tv_start, NULL); #endif // clamping if ((entries_done_ + 1000000) < entry_count) { entry_count = entries_done_ + 1000000; } while (entries_done_ != entry_count) { // no need to lock this here, because this is the only thread that changes it const struct change *c = &backing_[entries_done_]; char type = get_type_from_flags(c->flags); RWLOCK_WRLOCK(db_lock_); // clnum_to_entry_number_, instruction_pages_ if (type == 'I') { if (clnum_to_entry_number_.size() < c->clnum) { // there really shouldn't be holes clnum_to_entry_number_.resize(c->clnum); } clnum_to_entry_number_.push_back(entries_done_); pages_[c->address & PAGE_MASK] |= PAGE_INSTRUCTION; } // addresstype_to_clnums_ // ** this is 75% of the perf, real unordered_map should improve, but c++11 is hard to build pair<unordered_map<pair<Address, char>, set<Clnum> >::iterator, bool> ret = addresstype_to_clnums_.insert(MP(MP(c->address, type), set<Clnum>())); ret.first->second.insert(c->clnum); // registers_ if (type == 'W' && (c->address < (unsigned int)(register_size_ * register_count_))) { registers_[c->address / register_size_][c->clnum] = c->data; } // memory_, data_pages_ if (type == 'L' || type == 'S') { if (type == 'L') { pages_[c->address & PAGE_MASK] |= PAGE_READ; } if (type == 'S') { pages_[c->address & PAGE_MASK] |= PAGE_WRITE; } // no harm in doing the memory commit every time there's a load, right? int byte_count = (c->flags&SIZE_MASK)/8; uint64_t data = c->data; if (is_big_endian_) { for (int i = byte_count-1; i >= 0; --i) { commit_memory(c->clnum, c->address+i, data&0xFF); data >>= 8; } } else { // little endian for (int i = 0; i < byte_count; i++) { commit_memory(c->clnum, c->address+i, data&0xFF); data >>= 8; } } } RWLOCK_WRUNLOCK(db_lock_); // max_clnum_ if (max_clnum_ < c->clnum && c->clnum != INVALID_CLNUM) { max_clnum_ = c->clnum; } if (min_clnum_ == INVALID_CLNUM || c->clnum < min_clnum_) { min_clnum_ = c->clnum; } entries_done_++; }
static int big_bitp(object x, ufixnum p) { return mpz_tstbit(MP(x),p); }
static object integer_log_op2(fixnum op,object x,enum type tx,object y,enum type ty) { object u=big_fixnum1; object ux=tx==t_bignum ? x : (mpz_set_si(MP(big_fixnum2),fix(x)), big_fixnum2); object uy=ty==t_bignum ? y : (mpz_set_si(MP(big_fixnum3),fix(y)), big_fixnum3); switch(op) { case BOOLCLR: mpz_set_si(MP(u),0);break; case BOOLSET: mpz_set_si(MP(u),-1);break; case BOOL1: mpz_set(MP(u),MP(ux));break; case BOOL2: mpz_set(MP(u),MP(uy));break; case BOOLC1: mpz_com(MP(u),MP(ux));break; case BOOLC2: mpz_com(MP(u),MP(uy));break; case BOOLAND: mpz_and(MP(u),MP(ux),MP(uy));break; case BOOLIOR: mpz_ior(MP(u),MP(ux),MP(uy));break; case BOOLXOR: mpz_xor(MP(u),MP(ux),MP(uy));break; case BOOLEQV: mpz_xor(MP(u),MP(ux),MP(uy));mpz_com(MP(u),MP(u));break; case BOOLNAND: mpz_and(MP(u),MP(ux),MP(uy));mpz_com(MP(u),MP(u));break; case BOOLNOR: mpz_ior(MP(u),MP(ux),MP(uy));mpz_com(MP(u),MP(u));break; case BOOLANDC1:mpz_com(MP(u),MP(ux));mpz_and(MP(u),MP(u),MP(uy));break; case BOOLANDC2:mpz_com(MP(u),MP(uy));mpz_and(MP(u),MP(ux),MP(u));break; case BOOLORC1: mpz_com(MP(u),MP(ux));mpz_ior(MP(u),MP(u),MP(uy));break; case BOOLORC2: mpz_com(MP(u),MP(uy));mpz_ior(MP(u),MP(ux),MP(u));break; default:break;/*FIXME error*/ } return u; }
pLL operator * (pLL a,pLL b) {return MP(a.X*b.Y-a.Y*b.X,a.X*b.X+a.Y*b.Y);}
PDD at(PDD & a, PDD & b, double t) { return MP(a.F * t + b.F * (1 - t), a.S * t + b.S * (1 - t)); }
int main(int argc, char * argv[]) { try { libmaus2::util::ArgInfo const arginfo(argc,argv); // free list for alignments libmaus2::util::GrowingFreeList<libmaus2::bambam::BamAlignment> BAFL; // insert size int64_t const insertsize = arginfo.getValue<int64_t>("insertsize",800); // container for bam decoders DecoderContainer deccont; while ( std::cin ) { // eof? if ( std::cin.peek() < 0 ) break; // get next instance line InstanceLine IS(&deccont,std::cin); std::cout << IS << '\n'; uint64_t ilow = 0; while ( ilow != IS.size() ) { uint64_t ihigh = ilow; // get interval for one type of instance while ( ihigh != IS.size() && IS.instances[ihigh].type == IS.instances[ilow].type ) ++ihigh; // if type is split, improper or samestrand if ( IS.instances[ilow].type == Instance::instance_type_split || IS.instances[ilow].type == Instance::instance_type_improper || IS.instances[ilow].type == Instance::instance_type_samestrand ) { // key is maxcnt,num std::map<SubInstKey, std::vector<std::string>, std::greater<SubInstKey> > subinst; for ( uint64_t i = ilow; i < ihigh; ++i ) { std::vector<libmaus2::bambam::BamAlignment *> retlist; // map from read name to vector of alignments std::map<std::string, std::vector<libmaus2::bambam::BamAlignment *> > amap; libmaus2::bambam::BamHeader::unique_ptr_type uheader; // get alignments from A file marked with gene A { libmaus2::bambam::BamAlignmentDecoder & deca = IS.getInstanceDecoderA(i); libmaus2::bambam::BamAlignment & algna = deca.getAlignment(); libmaus2::bambam::BamHeader const & headera = deca.getHeader(); libmaus2::bambam::BamHeader::unique_ptr_type theader(headera.uclone()); uheader = UNIQUE_PTR_MOVE(theader); while ( deca.readAlignment() ) if ( algna.isMapped() && hasGeneComment(&algna,IS.geneA.name) ) { // std::cerr << algna.formatAlignment(headera) << std::endl; libmaus2::bambam::BamAlignment * palgn = BAFL.get(); retlist.push_back(palgn); amap[algna.getName()].push_back(palgn); palgn->swap(algna); } } // get alignments from B file marked with gene B { libmaus2::bambam::BamAlignmentDecoder & decb = IS.getInstanceDecoderB(i); libmaus2::bambam::BamAlignment & algnb = decb.getAlignment(); // libmaus2::bambam::BamHeader const & headerb = decb->getHeader(); while ( decb.readAlignment() ) if ( algnb.isMapped() && hasGeneComment(&algnb,IS.geneB.name) ) { // std::cerr << algna.formatAlignment(headera) << std::endl; libmaus2::bambam::BamAlignment * palgn = BAFL.get(); retlist.push_back(palgn); amap[algnb.getName()].push_back(palgn); palgn->swap(algnb); } } // pair map intervals std::vector<MappedPair> pairs; // count read pairs for gene pair uint64_t cnt = 0; // iterate over names for ( std::map<std::string, std::vector<libmaus2::bambam::BamAlignment *> >::iterator ita = amap.begin(); ita != amap.end(); ++ita ) { // get vector of alignments for name std::vector<libmaus2::bambam::BamAlignment *> & V = ita->second; // sort by (refid,pos,read1) std::sort(V.begin(),V.end(),PosComparator()); // remove multiple copies of same alignment uint64_t o = 0; uint64_t rcnt[2] = {0,0}; for ( uint64_t l = 0; l < V.size(); ) { // skip over multiple copies of same alignment uint64_t h = l; while ( h != V.size() && sameAlignment(V[l],V[h]) ) ++h; // count read 1 if ( V[l]->isRead1() ) rcnt[0]++; // count read 2 if ( V[l]->isRead2() ) rcnt[1]++; // copy alignment pointer if ( V[l]->isRead1() || V[l]->isRead2() ) V[o++] = V[l]; l = h; } V.resize(o); // if we have read1 and read2 if ( V.size() > 1 && rcnt[0] && rcnt[1] ) { // iterate over read 1 for ( uint64_t r1 = 0; r1 < rcnt[0]; ++r1 ) // iterate over read 2 for ( uint64_t r2 = rcnt[0]; r2 < o; ++r2 ) { // get alignment for read 1 libmaus2::bambam::BamAlignment const * algn1 = V[r1]; // get alignment for read 2 libmaus2::bambam::BamAlignment const * algn2 = V[r2]; // if pair is marked with gene pair we are looking for if ( ( hasGeneComment(algn1,IS.geneA.name) && hasGeneComment(algn2,IS.geneB.name) ) || ( hasGeneComment(algn1,IS.geneB.name) && hasGeneComment(algn2,IS.geneA.name) ) ) { #if 0 std::cerr << "\n --- \n"; std::cerr << algn1->formatAlignment(*uheader) << std::endl; std::cerr << algn2->formatAlignment(*uheader) << std::endl; ++cnt; std::cerr << "subcnt=" << V.size() << std::endl; #endif // increment number of read pairs found cnt += 1; // determine smaller and larger alignment (by position) bool const smal1 = PosComparator::compare(algn1,algn2); libmaus2::bambam::BamAlignment const * algnl = smal1 ? algn1 : algn2; libmaus2::bambam::BamAlignment const * algnr = smal1 ? algn2 : algn1; // "left" interval libmaus2::math::IntegerInterval<int64_t> intl( algnl->getPos(), algnl->getAlignmentEnd() ); // "right" interval libmaus2::math::IntegerInterval<int64_t> intr( algnr->getPos(), algnr->getAlignmentEnd() ); // construct mapped pair of aligned intervals MappedPair MP(intl,intr); // see if this interval (modulo insert size) already exists bool existing = false; for ( uint64_t i = 0; (!existing) && i < pairs.size(); ++i ) // already seen? if ( MappedPair::isInsertSizeOverlap(pairs[i],MP,insertsize) ) { // update from for left pairs[i].first.from = std::min( MP.first.from, pairs[i].first.from ); // update to for left pairs[i].first.to = std::max( MP.first.to, pairs[i].first.to ); // update from for right pairs[i].second.from = std::min( MP.second.from, pairs[i].second.from ); // update to for right pairs[i].second.to = std::max( MP.second.to, pairs[i].second.to ); // update number of supporting pair for this "break point" pairs[i].cnt += 1; // note that this break point already existed existing = true; } #if 0 else { std::cerr << "no overlap" << std::endl; std::cerr << MP << std::endl; std::cerr << pairs[i] << std::endl; } #endif // push new pair if break point did not exist yet if ( ! existing ) pairs.push_back(MP); } } } } // std::cerr << IS.instances[i] << " gcnt=" << cnt << ((IS.instances[i].num != cnt) ? "___" : "") << std::endl; std::ostringstream ostr; ostr << "\t" << IS.instances[i]; // sort by number of supporting read pairs std::sort(pairs.begin(),pairs.end(),MappedPairCountComparator()); // maximum count uint64_t const maxcnt = pairs.size() ? pairs.front().cnt : 0; ostr << "\t" << maxcnt; // output break points for ( uint64_t j = 0; j < pairs.size();++j ) ostr << "\t" << pairs[j]; // sub instances map ordered by number of read pairs supporting break point subinst[SubInstKey(maxcnt,IS.instances[i].num)].push_back(ostr.str()); // return alignment to free list for ( uint64_t i = 0; i < retlist.size(); ++i ) BAFL.put(retlist[i]); } // output instance lines for ( std::map<SubInstKey, std::vector<std::string>, std::greater<SubInstKey> >::const_iterator ita = subinst.begin(); ita != subinst.end(); ++ita ) { std::vector<std::string> const & V = ita->second; for ( uint64_t i = 0; i < V.size(); ++i ) std::cout << V[i] << "\n"; } } ilow = ihigh; } } } catch(std::exception const & ex) { std::cerr << ex.what() << std::endl; return EXIT_FAILURE; } }
I rk(I f,A r,A a,A w) { A z=0,*p=0; if(w)ND2 else ND1; { XA; C *pp=0,*ap,*wp; I wt=0,wr=0,wn=0,*wd=0; I n=0,t=0,i,j,k,d[9],rw,ra,ri,ir,iw=0,ia=0,ii=0, e=!w&&f==MP(9),h=QP(f)&&f!=MP(71)&&!e; Q(!QA(r),9); Q(r->t,6); Q(r->n<1||r->n>3,8); ar-=ra=raw(ar,*r->p); if(!w) mv(d,ad,ra),ir=tr(ra,ad),ad+=ra; else { wt=w->t,wr=w->r,wd=w->d; wr-=rw=raw(wr,r->p[r->n>1]),ri=r->n>2?r->p[2]:9; Q(ri<0,9); if(ri>ra)ri=ra; if(ri>rw)ri=rw; mv(d,ad,ra-=ri); ia=tr(ra,ad),mv(d+ra,wd,rw),iw=tr(rw-=ri,wd); Q(cm(ad+=ra,wd+=rw,ri),11); ii=tr(ri,ad),ra+=rw+ri,ir=ia*iw*ii,wn=tr(wr,wd+=ri),ad+=ri; if(h&&ir>iw&&(f==MP(21)||f==MP(25)||f==MP(26)||f==MP(32)||f==MP(33))) h=0; } an=tr(ar,ad); if(h) { g=0; aw_c[0]=a->c; aw_c[1]=w&&w->c; r=(A)fa(f,gC(at,ar,an,ad,a->n?a->p:0),w?gC(wt,wr,wn,wd,w->n?w->p:0):0); aw_c[0]=aw_c[1]=1; if(!r)R 0; r=un(&r); mv(d+ra,r->d,j=r->r); if((j+=ra)>MAXR)R q=13,(I)r; n=r->n;t=r->t; if(ir<2) R mv(r->d,d,r->r=j),r->n*=ir,(I)r; dc(r); if(g==(I (*)())rsh) R rsh(w?w:a,j,d); if(!g){h=0;} else { if(at=atOnExit,w) wt=wtOnExit; if(at!=a->t&&!(a=at?ep_cf(1):ci(1))) R 0; if(w&&wt!=w->t&&!(w=wt?ep_cf(2):ci(2))) R 0; OF(i,ir,n); W(ga(t,j,i,d)); pp=(C*)z->p; } } if(!h) { W(ga(Et,ra,ir,d)); *--Y=zr(z),p=(A*)z->p; } if(!w) { for(ap=(C*)a->p;ir--;ap+=Tt(at,an)) if(h) (*(I(*)(C*,C*,I))g)(pp,ap,an),pp+=Tt(t,n); else a=gc(at,ar,an,ad,(I*)ap),*p++=e?a:(A)fa(f,(I)a,0); } else { for(i=0;i<ia;++i)for(j=0;j<iw;++j) for(k=0;k<ii;++k){ ap=(C*)a->p+Tt(at,(i*ii+k)*an); wp=(C*)w->p+Tt(wt,(j*ii+k)*wn); if(h) { (*(I(*)(C*,C*,C*,I))g)(pp,ap,wp,n),pp+=Tt(t,n); if(q==1)*--Y=(I)z,aplus_err(q,(A)Y[1]),++Y; } else { *p++=(A)fa(f,(I)gc(at,ar,an,ad,(I*)ap),(I)gc(wt,wr,wn,wd,(I*)wp)); } } } if(h)R(I)z; if(!e)z=(A)dis(r=z),dc(r); R ++Y,(I)z; } }
int BlockDACG::reSolve(int numEigen, Epetra_MultiVector &Q, double *lambda, int startingEV) { // Computes the smallest eigenvalues and the corresponding eigenvectors // of the generalized eigenvalue problem // // K X = M X Lambda // // using a Block Deflation Accelerated Conjugate Gradient algorithm. // // Note that if M is not specified, then K X = X Lambda is solved. // // Ref: P. Arbenz & R. Lehoucq, "A comparison of algorithms for modal analysis in the // absence of a sparse direct method", SNL, Technical Report SAND2003-1028J // With the notations of this report, the coefficient beta is defined as // diag( H^T_{k} G_{k} ) / diag( H^T_{k-1} G_{k-1} ) // // Input variables: // // numEigen (integer) = Number of eigenmodes requested // // Q (Epetra_MultiVector) = Converged eigenvectors // The number of columns of Q must be equal to numEigen + blockSize. // The rows of Q are distributed across processors. // At exit, the first numEigen columns contain the eigenvectors requested. // // lambda (array of doubles) = Converged eigenvalues // At input, it must be of size numEigen + blockSize. // At exit, the first numEigen locations contain the eigenvalues requested. // // startingEV (integer) = Number of existing converged eigenmodes // // Return information on status of computation // // info >= 0 >> Number of converged eigenpairs at the end of computation // // // Failure due to input arguments // // info = - 1 >> The stiffness matrix K has not been specified. // info = - 2 >> The maps for the matrix K and the matrix M differ. // info = - 3 >> The maps for the matrix K and the preconditioner P differ. // info = - 4 >> The maps for the vectors and the matrix K differ. // info = - 5 >> Q is too small for the number of eigenvalues requested. // info = - 6 >> Q is too small for the computation parameters. // // info = - 10 >> Failure during the mass orthonormalization // // info = - 20 >> Error in LAPACK during the local eigensolve // // info = - 30 >> MEMORY // // Check the input parameters if (numEigen <= startingEV) { return startingEV; } int info = myVerify.inputArguments(numEigen, K, M, Prec, Q, numEigen + blockSize); if (info < 0) return info; int myPid = MyComm.MyPID(); // Get the weight for approximating the M-inverse norm Epetra_Vector *vectWeight = 0; if (normWeight) { vectWeight = new Epetra_Vector(View, Q.Map(), normWeight); } int knownEV = startingEV; int localVerbose = verbose*(myPid==0); // Define local block vectors // // MX = Working vectors (storing M*X if M is specified, else pointing to X) // KX = Working vectors (storing K*X) // // R = Residuals // // H = Preconditioned residuals // // P = Search directions // MP = Working vectors (storing M*P if M is specified, else pointing to P) // KP = Working vectors (storing K*P) int xr = Q.MyLength(); Epetra_MultiVector X(View, Q, numEigen, blockSize); X.Random(); int tmp; tmp = (M == 0) ? 5*blockSize*xr : 7*blockSize*xr; double *work1 = new (nothrow) double[tmp]; if (work1 == 0) { if (vectWeight) delete vectWeight; info = -30; return info; } memRequested += sizeof(double)*tmp/(1024.0*1024.0); highMem = (highMem > currentSize()) ? highMem : currentSize(); double *tmpD = work1; Epetra_MultiVector KX(View, Q.Map(), tmpD, xr, blockSize); tmpD = tmpD + xr*blockSize; Epetra_MultiVector MX(View, Q.Map(), (M) ? tmpD : X.Values(), xr, blockSize); tmpD = (M) ? tmpD + xr*blockSize : tmpD; Epetra_MultiVector R(View, Q.Map(), tmpD, xr, blockSize); tmpD = tmpD + xr*blockSize; Epetra_MultiVector H(View, Q.Map(), tmpD, xr, blockSize); tmpD = tmpD + xr*blockSize; Epetra_MultiVector P(View, Q.Map(), tmpD, xr, blockSize); tmpD = tmpD + xr*blockSize; Epetra_MultiVector KP(View, Q.Map(), tmpD, xr, blockSize); tmpD = tmpD + xr*blockSize; Epetra_MultiVector MP(View, Q.Map(), (M) ? tmpD : P.Values(), xr, blockSize); // Define arrays // // theta = Store the local eigenvalues (size: 2*blockSize) // normR = Store the norm of residuals (size: blockSize) // // oldHtR = Store the previous H_i^T*R_i (size: blockSize) // currentHtR = Store the current H_i^T*R_i (size: blockSize) // // MM = Local mass matrix (size: 2*blockSize x 2*blockSize) // KK = Local stiffness matrix (size: 2*blockSize x 2*blockSize) // // S = Local eigenvectors (size: 2*blockSize x 2*blockSize) int lwork2; lwork2 = 5*blockSize + 12*blockSize*blockSize; double *work2 = new (nothrow) double[lwork2]; if (work2 == 0) { if (vectWeight) delete vectWeight; delete[] work1; info = -30; return info; } highMem = (highMem > currentSize()) ? highMem : currentSize(); tmpD = work2; double *theta = tmpD; tmpD = tmpD + 2*blockSize; double *normR = tmpD; tmpD = tmpD + blockSize; double *oldHtR = tmpD; tmpD = tmpD + blockSize; double *currentHtR = tmpD; tmpD = tmpD + blockSize; memset(currentHtR, 0, blockSize*sizeof(double)); double *MM = tmpD; tmpD = tmpD + 4*blockSize*blockSize; double *KK = tmpD; tmpD = tmpD + 4*blockSize*blockSize; double *S = tmpD; memRequested += sizeof(double)*lwork2/(1024.0*1024.0); // Define an array to store the residuals history if (localVerbose > 2) { resHistory = new (nothrow) double[maxIterEigenSolve*blockSize]; if (resHistory == 0) { if (vectWeight) delete vectWeight; delete[] work1; delete[] work2; info = -30; return info; } historyCount = 0; } // Miscellaneous definitions bool reStart = false; numRestart = 0; int localSize; int twoBlocks = 2*blockSize; int nFound = blockSize; int i, j; if (localVerbose > 0) { cout << endl; cout << " *|* Problem: "; if (M) cout << "K*Q = M*Q D "; else cout << "K*Q = Q D "; if (Prec) cout << " with preconditioner"; cout << endl; cout << " *|* Algorithm = DACG (block version)" << endl; cout << " *|* Size of blocks = " << blockSize << endl; cout << " *|* Number of requested eigenvalues = " << numEigen << endl; cout.precision(2); cout.setf(ios::scientific, ios::floatfield); cout << " *|* Tolerance for convergence = " << tolEigenSolve << endl; cout << " *|* Norm used for convergence: "; if (normWeight) cout << "weighted L2-norm with user-provided weights" << endl; else cout << "L^2-norm" << endl; if (startingEV > 0) cout << " *|* Input converged eigenvectors = " << startingEV << endl; cout << "\n -- Start iterations -- \n"; } timeOuterLoop -= MyWatch.WallTime(); for (outerIter = 1; outerIter <= maxIterEigenSolve; ++outerIter) { highMem = (highMem > currentSize()) ? highMem : currentSize(); if ((outerIter == 1) || (reStart == true)) { reStart = false; localSize = blockSize; if (nFound > 0) { Epetra_MultiVector X2(View, X, blockSize-nFound, nFound); Epetra_MultiVector MX2(View, MX, blockSize-nFound, nFound); Epetra_MultiVector KX2(View, KX, blockSize-nFound, nFound); // Apply the mass matrix to X timeMassOp -= MyWatch.WallTime(); if (M) M->Apply(X2, MX2); timeMassOp += MyWatch.WallTime(); massOp += nFound; if (knownEV > 0) { // Orthonormalize X against the known eigenvectors with Gram-Schmidt // Note: Use R as a temporary work space Epetra_MultiVector copyQ(View, Q, 0, knownEV); timeOrtho -= MyWatch.WallTime(); info = modalTool.massOrthonormalize(X, MX, M, copyQ, nFound, 0, R.Values()); timeOrtho += MyWatch.WallTime(); // Exit the code if the orthogonalization did not succeed if (info < 0) { info = -10; delete[] work1; delete[] work2; if (vectWeight) delete vectWeight; return info; } } // Apply the stiffness matrix to X timeStifOp -= MyWatch.WallTime(); K->Apply(X2, KX2); timeStifOp += MyWatch.WallTime(); stifOp += nFound; } // if (nFound > 0) } // if ((outerIter == 1) || (reStart == true)) else { // Apply the preconditioner on the residuals if (Prec != 0) { timePrecOp -= MyWatch.WallTime(); Prec->ApplyInverse(R, H); timePrecOp += MyWatch.WallTime(); precOp += blockSize; } else { memcpy(H.Values(), R.Values(), xr*blockSize*sizeof(double)); } // Compute the product H^T*R timeSearchP -= MyWatch.WallTime(); memcpy(oldHtR, currentHtR, blockSize*sizeof(double)); H.Dot(R, currentHtR); // Define the new search directions if (localSize == blockSize) { P.Scale(-1.0, H); localSize = twoBlocks; } // if (localSize == blockSize) else { bool hasZeroDot = false; for (j = 0; j < blockSize; ++j) { if (oldHtR[j] == 0.0) { hasZeroDot = true; break; } callBLAS.SCAL(xr, currentHtR[j]/oldHtR[j], P.Values() + j*xr); } if (hasZeroDot == true) { // Restart the computation when there is a null dot product if (localVerbose > 0) { cout << endl; cout << " !! Null dot product -- Restart the search space !!\n"; cout << endl; } if (blockSize == 1) { X.Random(); nFound = blockSize; } else { Epetra_MultiVector Xinit(View, X, j, blockSize-j); Xinit.Random(); nFound = blockSize - j; } // if (blockSize == 1) reStart = true; numRestart += 1; info = 0; continue; } callBLAS.AXPY(xr*blockSize, -1.0, H.Values(), P.Values()); } // if (localSize == blockSize) timeSearchP += MyWatch.WallTime(); // Apply the mass matrix on P timeMassOp -= MyWatch.WallTime(); if (M) M->Apply(P, MP); timeMassOp += MyWatch.WallTime(); massOp += blockSize; if (knownEV > 0) { // Orthogonalize P against the known eigenvectors // Note: Use R as a temporary work space Epetra_MultiVector copyQ(View, Q, 0, knownEV); timeOrtho -= MyWatch.WallTime(); modalTool.massOrthonormalize(P, MP, M, copyQ, blockSize, 1, R.Values()); timeOrtho += MyWatch.WallTime(); } // Apply the stiffness matrix to P timeStifOp -= MyWatch.WallTime(); K->Apply(P, KP); timeStifOp += MyWatch.WallTime(); stifOp += blockSize; } // if ((outerIter == 1) || (reStart == true)) // Form "local" mass and stiffness matrices // Note: Use S as a temporary workspace timeLocalProj -= MyWatch.WallTime(); modalTool.localProjection(blockSize, blockSize, xr, X.Values(), xr, KX.Values(), xr, KK, localSize, S); modalTool.localProjection(blockSize, blockSize, xr, X.Values(), xr, MX.Values(), xr, MM, localSize, S); if (localSize > blockSize) { modalTool.localProjection(blockSize, blockSize, xr, X.Values(), xr, KP.Values(), xr, KK + blockSize*localSize, localSize, S); modalTool.localProjection(blockSize, blockSize, xr, P.Values(), xr, KP.Values(), xr, KK + blockSize*localSize + blockSize, localSize, S); modalTool.localProjection(blockSize, blockSize, xr, X.Values(), xr, MP.Values(), xr, MM + blockSize*localSize, localSize, S); modalTool.localProjection(blockSize, blockSize, xr, P.Values(), xr, MP.Values(), xr, MM + blockSize*localSize + blockSize, localSize, S); } // if (localSize > blockSize) timeLocalProj += MyWatch.WallTime(); // Perform a spectral decomposition timeLocalSolve -= MyWatch.WallTime(); int nevLocal = localSize; info = modalTool.directSolver(localSize, KK, localSize, MM, localSize, nevLocal, S, localSize, theta, localVerbose, (blockSize == 1) ? 1: 0); timeLocalSolve += MyWatch.WallTime(); if (info < 0) { // Stop when spectral decomposition has a critical failure break; } // Check for restarting if ((theta[0] < 0.0) || (nevLocal < blockSize)) { if (localVerbose > 0) { cout << " Iteration " << outerIter; cout << "- Failure for spectral decomposition - RESTART with new random search\n"; } if (blockSize == 1) { X.Random(); nFound = blockSize; } else { Epetra_MultiVector Xinit(View, X, 1, blockSize-1); Xinit.Random(); nFound = blockSize - 1; } // if (blockSize == 1) reStart = true; numRestart += 1; info = 0; continue; } // if ((theta[0] < 0.0) || (nevLocal < blockSize)) if ((localSize == twoBlocks) && (nevLocal == blockSize)) { for (j = 0; j < nevLocal; ++j) memcpy(S + j*blockSize, S + j*twoBlocks, blockSize*sizeof(double)); localSize = blockSize; } // Check the direction of eigenvectors // Note: This sign check is important for convergence for (j = 0; j < nevLocal; ++j) { double coeff = S[j + j*localSize]; if (coeff < 0.0) callBLAS.SCAL(localSize, -1.0, S + j*localSize); } // Compute the residuals timeResidual -= MyWatch.WallTime(); callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, 1.0, KX.Values(), xr, S, localSize, 0.0, R.Values(), xr); if (localSize == twoBlocks) { callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, 1.0, KP.Values(), xr, S + blockSize, localSize, 1.0, R.Values(), xr); } for (j = 0; j < blockSize; ++j) callBLAS.SCAL(localSize, theta[j], S + j*localSize); callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, -1.0, MX.Values(), xr, S, localSize, 1.0, R.Values(), xr); if (localSize == twoBlocks) { callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, -1.0, MP.Values(), xr, S + blockSize, localSize, 1.0, R.Values(), xr); } for (j = 0; j < blockSize; ++j) callBLAS.SCAL(localSize, 1.0/theta[j], S + j*localSize); timeResidual += MyWatch.WallTime(); // Compute the norms of the residuals timeNorm -= MyWatch.WallTime(); if (vectWeight) R.NormWeighted(*vectWeight, normR); else R.Norm2(normR); // Scale the norms of residuals with the eigenvalues // Count the converged eigenvectors nFound = 0; for (j = 0; j < blockSize; ++j) { normR[j] = (theta[j] == 0.0) ? normR[j] : normR[j]/theta[j]; if (normR[j] < tolEigenSolve) nFound += 1; } timeNorm += MyWatch.WallTime(); // Store the residual history if (localVerbose > 2) { memcpy(resHistory + historyCount*blockSize, normR, blockSize*sizeof(double)); historyCount += 1; } // Print information on current iteration if (localVerbose > 0) { cout << " Iteration " << outerIter << " - Number of converged eigenvectors "; cout << knownEV + nFound << endl; } if (localVerbose > 1) { cout << endl; cout.precision(2); cout.setf(ios::scientific, ios::floatfield); for (i=0; i<blockSize; ++i) { cout << " Iteration " << outerIter << " - Scaled Norm of Residual " << i; cout << " = " << normR[i] << endl; } cout << endl; cout.precision(2); for (i=0; i<blockSize; ++i) { cout << " Iteration " << outerIter << " - Ritz eigenvalue " << i; cout.setf((fabs(theta[i]) < 0.01) ? ios::scientific : ios::fixed, ios::floatfield); cout << " = " << theta[i] << endl; } cout << endl; } if (nFound == 0) { // Update the spaces // Note: Use H as a temporary work space timeLocalUpdate -= MyWatch.WallTime(); memcpy(H.Values(), X.Values(), xr*blockSize*sizeof(double)); callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, 1.0, H.Values(), xr, S, localSize, 0.0, X.Values(), xr); memcpy(H.Values(), KX.Values(), xr*blockSize*sizeof(double)); callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, 1.0, H.Values(), xr, S, localSize, 0.0, KX.Values(), xr); if (M) { memcpy(H.Values(), MX.Values(), xr*blockSize*sizeof(double)); callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, 1.0, H.Values(), xr, S, localSize, 0.0, MX.Values(), xr); } if (localSize == twoBlocks) { callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, 1.0, P.Values(), xr, S + blockSize, localSize, 1.0, X.Values(), xr); callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, 1.0, KP.Values(), xr, S + blockSize, localSize, 1.0, KX.Values(), xr); if (M) { callBLAS.GEMM('N', 'N', xr, blockSize, blockSize, 1.0, MP.Values(), xr, S + blockSize, localSize, 1.0, MX.Values(), xr); } } // if (localSize == twoBlocks) timeLocalUpdate += MyWatch.WallTime(); // When required, monitor some orthogonalities if (verbose > 2) { if (knownEV == 0) { accuracyCheck(&X, &MX, &R, 0, (localSize>blockSize) ? &P : 0); } else { Epetra_MultiVector copyQ(View, Q, 0, knownEV); accuracyCheck(&X, &MX, &R, ©Q, (localSize>blockSize) ? &P : 0); } } // if (verbose > 2) continue; } // if (nFound == 0) // Order the Ritz eigenvectors by putting the converged vectors at the beginning int firstIndex = blockSize; for (j = 0; j < blockSize; ++j) { if (normR[j] >= tolEigenSolve) { firstIndex = j; break; } } // for (j = 0; j < blockSize; ++j) while (firstIndex < nFound) { for (j = firstIndex; j < blockSize; ++j) { if (normR[j] < tolEigenSolve) { // Swap the j-th and firstIndex-th position callFortran.SWAP(localSize, S + j*localSize, 1, S + firstIndex*localSize, 1); callFortran.SWAP(1, theta + j, 1, theta + firstIndex, 1); callFortran.SWAP(1, normR + j, 1, normR + firstIndex, 1); break; } } // for (j = firstIndex; j < blockSize; ++j) for (j = 0; j < blockSize; ++j) { if (normR[j] >= tolEigenSolve) { firstIndex = j; break; } } // for (j = 0; j < blockSize; ++j) } // while (firstIndex < nFound) // Copy the converged eigenvalues memcpy(lambda + knownEV, theta, nFound*sizeof(double)); // Convergence test if (knownEV + nFound >= numEigen) { callBLAS.GEMM('N', 'N', xr, nFound, blockSize, 1.0, X.Values(), xr, S, localSize, 0.0, R.Values(), xr); if (localSize > blockSize) { callBLAS.GEMM('N', 'N', xr, nFound, blockSize, 1.0, P.Values(), xr, S + blockSize, localSize, 1.0, R.Values(), xr); } memcpy(Q.Values() + knownEV*xr, R.Values(), nFound*xr*sizeof(double)); knownEV += nFound; if (localVerbose == 1) { cout << endl; cout.precision(2); cout.setf(ios::scientific, ios::floatfield); for (i=0; i<blockSize; ++i) { cout << " Iteration " << outerIter << " - Scaled Norm of Residual " << i; cout << " = " << normR[i] << endl; } cout << endl; } break; } // Store the converged eigenvalues and eigenvectors callBLAS.GEMM('N', 'N', xr, nFound, blockSize, 1.0, X.Values(), xr, S, localSize, 0.0, Q.Values() + knownEV*xr, xr); if (localSize == twoBlocks) { callBLAS.GEMM('N', 'N', xr, nFound, blockSize, 1.0, P.Values(), xr, S + blockSize, localSize, 1.0, Q.Values() + knownEV*xr, xr); } knownEV += nFound; // Define the restarting vectors timeRestart -= MyWatch.WallTime(); int leftOver = (nevLocal < blockSize + nFound) ? nevLocal - nFound : blockSize; double *Snew = S + nFound*localSize; memcpy(H.Values(), X.Values(), blockSize*xr*sizeof(double)); callBLAS.GEMM('N', 'N', xr, leftOver, blockSize, 1.0, H.Values(), xr, Snew, localSize, 0.0, X.Values(), xr); memcpy(H.Values(), KX.Values(), blockSize*xr*sizeof(double)); callBLAS.GEMM('N', 'N', xr, leftOver, blockSize, 1.0, H.Values(), xr, Snew, localSize, 0.0, KX.Values(), xr); if (M) { memcpy(H.Values(), MX.Values(), blockSize*xr*sizeof(double)); callBLAS.GEMM('N', 'N', xr, leftOver, blockSize, 1.0, H.Values(), xr, Snew, localSize, 0.0, MX.Values(), xr); } if (localSize == twoBlocks) { callBLAS.GEMM('N', 'N', xr, leftOver, blockSize, 1.0, P.Values(), xr, Snew+blockSize, localSize, 1.0, X.Values(), xr); callBLAS.GEMM('N', 'N', xr, leftOver, blockSize, 1.0, KP.Values(), xr, Snew+blockSize, localSize, 1.0, KX.Values(), xr); if (M) { callBLAS.GEMM('N', 'N', xr, leftOver, blockSize, 1.0, MP.Values(), xr, Snew+blockSize, localSize, 1.0, MX.Values(), xr); } } // if (localSize == twoBlocks) if (nevLocal < blockSize + nFound) { // Put new random vectors at the end of the block Epetra_MultiVector Xtmp(View, X, leftOver, blockSize - leftOver); Xtmp.Random(); } else { nFound = 0; } // if (nevLocal < blockSize + nFound) reStart = true; timeRestart += MyWatch.WallTime(); } // for (outerIter = 1; outerIter <= maxIterEigenSolve; ++outerIter) timeOuterLoop += MyWatch.WallTime(); highMem = (highMem > currentSize()) ? highMem : currentSize(); // Clean memory delete[] work1; delete[] work2; if (vectWeight) delete vectWeight; // Sort the eigenpairs timePostProce -= MyWatch.WallTime(); if ((info == 0) && (knownEV > 0)) { mySort.sortScalars_Vectors(knownEV, lambda, Q.Values(), Q.MyLength()); } timePostProce += MyWatch.WallTime(); return (info == 0) ? knownEV : info; }
pii getpos(int x) { return MP(x/len,x%len); }
TEST_F(VirtualTableTests, test_constraints_stacking) { // Add two testing tables to the registry. Registry::add<pTablePlugin>("table", "p"); Registry::add<kTablePlugin>("table", "k"); auto dbc = SQLiteDBManager::get(); { // To simplify the attach, just access the column definition directly. auto p = std::make_shared<pTablePlugin>(); attachTableInternal("p", p->columnDefinition(), dbc->db()); auto k = std::make_shared<kTablePlugin>(); attachTableInternal("k", k->columnDefinition(), dbc->db()); } QueryData results; std::string statement; std::map<std::string, std::string> expected; std::vector<std::pair<std::string, QueryData> > constraint_tests = { MP("select k.x from p, k", makeResult("x", {"1", "2", "1", "2"})), MP("select k.x from (select * from k) k2, p, k where k.x = p.x", makeResult("k.x", {"1", "1", "2", "2"})), MP("select k.x from (select * from k where z = 1) k2, p, k where k.x = " "p.x", makeResult("k.x", {"1", "2"})), MP("select k.x from k k1, (select * from p) p1, k where k.x = p1.x", makeResult("k.x", {"1", "1", "2", "2"})), MP("select k.x from (select * from p) p1, k, (select * from k) k2 where " "k.x = p1.x", makeResult("k.x", {"1", "1", "2", "2"})), MP("select k.x from (select * from p) p1, k, (select * from k where z = " "2) k2 where k.x = p1.x", makeResult("k.x", {"1", "2"})), MP("select k.x from k, (select * from p) p1, k k2, (select * from k " "where z = 1) k3 where k.x = p1.x", makeResult("k.x", {"1", "1", "2", "2"})), MP("select p.x from (select * from k where z = 1) k1, (select * from k " "where z != 1) k2, p where p.x = k2.x", makeResult("p.x", {"1"})), MP("select p.x from (select * from k, (select x as xx from k where x = " "1) k2 where z = 1) k1, (select * from k where z != 1) k2, p, k as k3 " "where p.x = k2.x", makeResult("p.x", {"1", "1"})), }; for (const auto& test : constraint_tests) { QueryData results; queryInternal(test.first, results, dbc->db()); EXPECT_EQ(results, test.second); } std::vector<QueryData> union_results = { makeResult("x", {"1", "2"}), makeResult("k.x", {"1", "2"}), makeResult("k.x", {"1", "2"}), makeResult("k.x", {"1", "2"}), makeResult("k.x", {"1", "2"}), makeResult("k.x", {"1", "2"}), makeResult("k.x", {"1", "2"}), makeResult("p.x", {"1"}), makeResult("p.x", {"1"}), }; size_t index = 0; for (const auto& test : constraint_tests) { QueryData results; queryInternal(test.first + " union " + test.first, results, dbc->db()); EXPECT_EQ(results, union_results[index++]); } }
void set_levels() { loop(i,1,11) loop(j,1,11) level[0].board[i][j]=1; level[0].start = MP(3,3); level[0].des = MP(8,8); loop(i,0,50) loop(j,0,50) level[1].board[i][j]=0; loop(i,0,50) loop(j,0,50) level[2].board[i][j]=0; loop(i,1,4) level[1].board[1][i]=1; loop(i,1,7) level[1].board[2][i]=1; loop(i,1,10) level[1].board[3][i]=1; loop(i,2,11) level[1].board[4][i]=1; loop(i,6,11) level[1].board[5][i]=1; loop(i,7,10) level[1].board[6][i]=1; level[1].start = MP(2,2); level[1].des = MP(5,8); loop(i,7,14) level[2].board[1][i]=1; loop(i,1,5) level[2].board[2][i]=1; loop(i,7,14) level[2].board[2][i]=1; loop(i,1,10) level[2].board[3][i]=1; loop(i,12,16) level[2].board[3][i]=1; loop(i,1,5) level[2].board[4][i]=1; loop(i,12,16) level[2].board[4][i]=1; loop(i,1,5) level[2].board[5][i]=1; loop(i,12,16) level[2].board[5][i]=1; loop(i,13,16) level[2].board[6][i]=1; level[2].start = MP(4,2); level[2].des = MP(4,14); loop(i,2,7) loop(j,1,5) level[3].board[i][j]=1; loop(i,1,7) loop(j,7,11) level[3].board[i][j]=1; loop(i,1,6) loop(j,13,16) level[3].board[i][j]=1; level[3].start = MP(4,2); level[3].des = MP(2,14); level[3].hbridge.pb(MP(3,3)); level[3].vbridge.pb(MP(2,9)); vector< pair<int,int> > temp; temp.pb(MP(5,5)); temp.pb(MP(5,6)); level[3].hbridge_value.pb(temp); temp.clear(); temp.pb(MP(5,11)); temp.pb(MP(5,12)); level[3].vbridge_value.pb(temp); loop(i,1,4) loop(j,12,16) level[4].board[i][j]=1; loop(j,2,6) level[4].board[2][j]=1; loop(j,8,12) level[4].board[2][j]=1; loop(i,3,6) loop(j,2,6) level[4].board[i][j]=1; loop(i,6,7) loop(j,4,14) level[4].board[i][j]=1; loop(i,7,10) loop(j,11,14) level[4].board[i][j]=1; loop(i,7,9) loop(j,14,16) level[4].board[i][j]=1; loop(j,8,12) level[4].board[9][j]=1;loop(j,5,6) level[4].board[9][j]=1; loop(i,8,11) loop(j,1,4) level[4].board[i][j]=1; level[4].board[9][4]=1; level[4].board[10][4]=1; level[4].start = MP(2,14); level[4].des = MP(9,2); level[4].hbridge.pb(MP(2,9)); level[4].hbridge.pb(MP(7,15)); temp.clear(); temp.pb(MP(2,6)); temp.pb(MP(2,7)); level[4].hbridge_value.pb(temp); temp.clear(); temp.pb(MP(9,6)) ; temp.pb(MP(9,7)); level[4].hbridge_value.pb(temp); level[5].start = MP(6,2); level[5].des = MP(8,8); loop(i,3,8) loop(j,1,4) level[5].board[i][j]=1; level[5].board[3][4]=1; level[5].board[3][11]=1; loop(i,3,6) loop(j,12,14) level[5].board[i][j]=1; level[5].board[6][10]=1; level[5].board[7][10]=1; level[5].board_light[6][11]=1; level[5].board_light[7][11]=1; loop(i,6,10) loop(j,7,10) level[5].board[i][j]=1; loop(i,1,3) loop(j,4,12) level[5].board_light[i][j]=1; loop(i,6,10) loop(j,12,16) level[5].board_light[i][j]=1; level[5].board_light[8][14]=0; level[5].board[8][14]=1; }
MP MP::new_lst( QString type ) { return MP( 0, new LstWithType( type ) ); }
int main(int argc, char **argv) { // first build our error handler g3ErrorHandler = new ConsoleErrorHandler(); // // now create a domain and a modelbuilder // and build the model // // Domain *theDomain = new Domain(); MapOfTaggedObjects theStorage; // ArrayOfTaggedObjects theStorage(32); Domain *theDomain = new Domain(theStorage); // create the nodes using constructor: // Node(tag, ndof, crd1, crd2) // and then add them to the domain Node *node1 = new Node(1, 3, 1.0, 1.0, 0.0 ); Node *node2 = new Node(2, 3, 0.0, 1.0, 0.0 ); Node *node3 = new Node(3, 3, 0.0, 0.0, 0.0 ); Node *node4 = new Node(4, 3, 1.0, 0.0, 0.0 ); Node *node5 = new Node(5, 3, 1.0, 1.0, 1.0 ); Node *node6 = new Node(6, 3, 0.0, 1.0, 1.0 ); Node *node7 = new Node(7, 3, 0.0, 0.0, 1.0 ); Node *node8 = new Node(8, 3, 1.0, 0.0, 1.0 ); theDomain->addNode(node1); theDomain->addNode(node2); theDomain->addNode(node3); theDomain->addNode(node4); theDomain->addNode(node5); theDomain->addNode(node6); theDomain->addNode(node7); theDomain->addNode(node8); // create an elastic material using constriuctor: // ElasticMaterialModel(tag, E) //UniaxialMaterial *theMaterial = new ElasticMaterial(1, 3000); double PIo3 = PI/3.0; PIo3 = 0.0; //Drucker-Prager Model DPYieldSurface DP_YS; DPPotentialSurface DP_PS(0.05); //EvolutionLaw_NL_Eeq DP_ELS1; EvolutionLaw_L_Eeq DP_ELS1(10.0); EvolutionLaw_T DP_ELT; double scalars[] = {0.3, 0.0}; //alfa1, k double NOS = 2; //Number of scalar vars double NOT = 1; //Number of tensorial vars stresstensor startstress; straintensor startstrain, otherstrain; startstrain = startstrain.pqtheta2strain( 0.000, 0.0000, 0.0); otherstrain = otherstrain.pqtheta2strain( 0.000, 0.0000, 0.0); stresstensor *tensors = new stresstensor[1]; EPState EPS(3000.0, 3000.0, 0.3, 0.0, startstress, otherstrain, otherstrain, otherstrain, NOS, scalars, NOT, tensors); Template3Dep MP(1, &DP_YS, &DP_PS, &EPS, &DP_ELS1, &DP_ELT); NDMaterial *theMaterial = &MP; //NDMaterial *theMaterial = new ElasticIsotropic3D(1, 3000, 0.3); // create the truss elements using constructor: // Truss(tag, dim, nd1, nd2, Material &,A) // and then add them to the domain //Truss *truss1 = new Truss(1, 2, 1, 4, *theMaterial, 10.0); //Truss *truss2 = new Truss(2, 2, 2, 4, *theMaterial, 5.0); //EPState *eps = 0; EightNodeBrick *brick = new EightNodeBrick(1, 5, 6, 7, 8, 1, 2, 3, 4, theMaterial, "Template3Dep", 0.0, 0.0, 0.0, 1.8, &EPS); //theDomain->addElement(truss1); //theDomain->addElement(truss2); theDomain->addElement( brick ); // create the single-point constraint objects using constructor: // SP_Constraint(tag, nodeTag, dofID, value) // and then add them to the domain SP_Constraint *sp1 = new SP_Constraint(1, 1, 0, 0.0259999); SP_Constraint *sp2 = new SP_Constraint(2, 1, 1, 0.0259999); SP_Constraint *sp3 = new SP_Constraint(3, 1, 2, -0.1213350); SP_Constraint *sp4 = new SP_Constraint(4, 2, 0, -0.0259999); SP_Constraint *sp5 = new SP_Constraint(5, 2, 1, 0.0259999); SP_Constraint *sp6 = new SP_Constraint(6, 2, 2, -0.1213350); SP_Constraint *sp7 = new SP_Constraint(7, 3, 0, -0.0259999); SP_Constraint *sp8 = new SP_Constraint(8, 3, 1, -0.0259999); SP_Constraint *sp9 = new SP_Constraint(9, 3, 2, -0.1213350); SP_Constraint *sp10 = new SP_Constraint(10, 4, 0, 0.0259999); SP_Constraint *sp11 = new SP_Constraint(11, 4, 1, -0.0259999); SP_Constraint *sp12 = new SP_Constraint(12, 4, 2, -0.1213350); SP_Constraint *sp13 = new SP_Constraint(13, 5, 0, 0.0); SP_Constraint *sp14 = new SP_Constraint(14, 5, 1, 0.0); SP_Constraint *sp15 = new SP_Constraint(15, 5, 2, 0.0); SP_Constraint *sp16 = new SP_Constraint(16, 6, 0, 0.0); SP_Constraint *sp17 = new SP_Constraint(17, 6, 1, 0.0); SP_Constraint *sp18 = new SP_Constraint(18, 6, 2, 0.0); SP_Constraint *sp19 = new SP_Constraint(19, 7, 0, 0.0); SP_Constraint *sp20 = new SP_Constraint(20, 7, 1, 0.0); SP_Constraint *sp21 = new SP_Constraint(21, 7, 2, 0.0); SP_Constraint *sp22 = new SP_Constraint(22, 8, 0, 0.0); SP_Constraint *sp23 = new SP_Constraint(23, 8, 1, 0.0); SP_Constraint *sp24 = new SP_Constraint(24, 8, 2, 0.0); //Add penalty constraint theDomain->addSP_Constraint(sp1 ); theDomain->addSP_Constraint(sp2 ); theDomain->addSP_Constraint(sp3 ); theDomain->addSP_Constraint(sp4 ); theDomain->addSP_Constraint(sp5 ); theDomain->addSP_Constraint(sp6 ); theDomain->addSP_Constraint(sp7 ); theDomain->addSP_Constraint(sp8 ); theDomain->addSP_Constraint(sp9 ); theDomain->addSP_Constraint(sp10); theDomain->addSP_Constraint(sp11); theDomain->addSP_Constraint(sp12); theDomain->addSP_Constraint(sp13); theDomain->addSP_Constraint(sp14); theDomain->addSP_Constraint(sp15); theDomain->addSP_Constraint(sp16); theDomain->addSP_Constraint(sp17); theDomain->addSP_Constraint(sp18); theDomain->addSP_Constraint(sp19); theDomain->addSP_Constraint(sp20); theDomain->addSP_Constraint(sp21); theDomain->addSP_Constraint(sp22); theDomain->addSP_Constraint(sp23); theDomain->addSP_Constraint(sp24); // construct a linear time series object using constructor: // LinearSeries() TimeSeries *theSeries = new LinearSeries(); // construct a load pattren using constructor: // LoadPattern(tag) // and then set it's TimeSeries and add it to the domain LoadPattern *theLoadPattern = new LoadPattern(1); theLoadPattern->setTimeSeries(theSeries); theDomain->addLoadPattern(theLoadPattern); // construct a nodal load using constructor: // NodalLoad(tag, nodeID, Vector &) // first construct a Vector of size 2 and set the values NOTE C INDEXING // then construct the load and add it to the domain Vector theLoadValues(3); theLoadValues(0) = 0.0; theLoadValues(1) = 0.0; //theLoadValues(2) = -100.0; theLoadValues(2) = 0.0; NodalLoad *theLoad = new NodalLoad(1, 5, theLoadValues); theDomain->addNodalLoad(theLoad, 1); theLoad = new NodalLoad(2, 6, theLoadValues); theDomain->addNodalLoad(theLoad, 1); theLoad = new NodalLoad(3, 7, theLoadValues); theDomain->addNodalLoad(theLoad, 1); theLoad = new NodalLoad(4, 8, theLoadValues); theDomain->addNodalLoad(theLoad, 1); // create an Analysis object to perform a static analysis of the model // - constructs: // AnalysisModel of type AnalysisModel, // EquiSolnAlgo of type Linear // StaticIntegrator of type LoadControl // ConstraintHandler of type Penalty // DOF_Numberer which uses RCM // LinearSOE of type Band SPD // and then the StaticAnalysis object AnalysisModel *theModel = new AnalysisModel(); EquiSolnAlgo *theSolnAlgo = new Linear(); StaticIntegrator *theIntegrator = new LoadControl(1.0, 1.0, 1.0, 1.0); ConstraintHandler *theHandler = new PenaltyConstraintHandler(1.0e8,1.0e8); RCM *theRCM = new RCM(); DOF_Numberer *theNumberer = new DOF_Numberer(*theRCM); BandSPDLinSolver *theSolver = new BandSPDLinLapackSolver(); LinearSOE *theSOE = new BandSPDLinSOE(*theSolver); StaticAnalysis theAnalysis(*theDomain, *theHandler, *theNumberer, *theModel, *theSolnAlgo, *theSOE, *theIntegrator); // perform the analysis & print out the results for the domain int numSteps = 1; theAnalysis.analyze(numSteps); cerr << *theDomain; //brick->displaySelf(); exit(0); }
MP MP::new_path( QString filename ) { return MP( 0, new Path( filename ) ); }
pii operator -( const pii & a,const pii & b){ return MP(a.X-b.X,a.Y-b.Y); }
MP MP::new_typed_array_qint32() { return MP( 0, new TypedArray<qint32> ); }
pLL operator - (pLL a,pLL b) {return MP(a.X-b.X,a.Y-b.Y);}
TEST(ARRAY, Capacity) { EXPECT_TRUE(kPackedCapCodeThreshold == 0x10000); #define MP(a, b) std::make_pair(a, b) // Update the numbers if we change kPackedCapCodeThreshold #if (LG_SMART_SIZES_PER_DOUBLING == 1) std::pair<uint32_t, uint32_t> caps [] = { MP(3, 0), MP(4, 5), MP(5, 0), MP(6, 7), MP(7, 0), MP(8, 11), MP(12, 15), MP(127, 0), MP(128, 191), MP(0xFFFF, 0), MP(0x10000, 0x17F00), MP(0x10001, 0) }; #elif (LG_SMART_SIZES_PER_DOUBLING == 2) std::pair<uint32_t, uint32_t> caps [] = { MP(3, 0), MP(4, 0), MP(5, 0), MP(6, 0), MP(7, 0), MP(8, 9), MP(12, 13), MP(127, 0), MP(128, 159), MP(0xFFFF, 0), MP(0x10000, 0x13F00), MP(0x10001, 0) }; #else #error Unknown LG_SMART_SIZES_PER_DOUBLING #endif #undef MP for (size_t i = 0; i != sizeof(caps) / sizeof(caps[0]); ++i) { EXPECT_TRUE(PackedArray::getMaxCapInPlaceFast(caps[i].first) == caps[i].second); } }
POINT3D normal=((p[v[i].t[1]]-p[v[i].t[0]])^(p[v[i].t[2]]-p[v[i].t[0]])); LL il=(normal*(p[x]-p[v[i].t[0]])); vis[i]=0; if (il>0) vis[i]=1; else if (il==0){ if ((normal*((p[v[i].t[1]]-p[v[i].t[0]])^(p[x]-p[v[i].t[0]]))>=0 && normal*((p[v[i].t[2]]-p[v[i].t[1]])^(p[x]-p[v[i].t[1]]))>=0 && normal*((p[v[i].t[0]]-p[v[i].t[2]])^(p[x]-p[v[i].t[2]]))>=0)) return; /*ODKOMENTUJ*/ vis[i]=1; } } int ile=SZ(v); REP(i,ile) if (vis[i]) REP(j,3) if (!vis[t[v[i].t[(j+1)%3]][v[i].t[j]]]) pom.PB(MP(v[i].t[j],v[i].t[(j+1)%3])); REP(i,ile) if (vis[i]){ swap(v[i],v.back()); v.pop_back(); REP(j,3) t[v[i].t[j]][v[i].t[(j+1)%3]]=i; vis[i--]=vis[--ile]; } FORE(it,pom){ t[it->X][it->Y]=t[it->Y][x]=t[x][it->X]=SZ(v); v.PB(sciana(it->X,it->Y,x)); } } void CH3D(){ //n>=3, oblicza wektor trojkatnych scian v (mozliwe powtorzenia) int i=2; POINT3D normal; while (i<n && (normal=((p[1]-p[0])^(p[i]-p[0])))==POINT3D(0,0,0)) i++;