// TO-DO: Remove this ENTIRE queue system. int CSharedMemQueue::PutData(Packet *pkt, int16 uid /*= -1*/) { BYTE BlockMode; int index = 0, count = 0; short size = pkt->size() + 1; if ((DWORD)size > m_wOffset) { TRACE("DataSize Over.. - %d bytes\n", pkt->size()); return SMQ_PKTSIZEOVER; } do { if( m_pHeader->RearMode == W ) { aa(); count++; continue; } m_pHeader->RearMode = W; m_pHeader->WritePid = ::GetCurrentThreadId(); // writing side (game server) is multi thread aa(); // no operation function if( m_pHeader->WritePid != ::GetCurrentThreadId() ) { count++; continue; } LONG pQueue = m_lReference + (m_pHeader->Rear * m_wOffset); BlockMode = GetByte( (char*)pQueue, index ); if( BlockMode == WR && m_pHeader->nCount >= MAX_COUNT-1 ) { m_pHeader->RearMode = WR; return SMQ_FULL; } index = 0; char *queue = ((char *)pQueue); queue[index++] = WR; // Block Mode Set to WR -> Data Exist SetShort(queue, size, index); SetShort(queue, uid, index); queue[index++] = pkt->GetOpcode(); if (pkt->size() > 0) memcpy(queue+index, pkt->contents(), size); m_pHeader->nCount++; m_pHeader->Rear = (m_pHeader->Rear + 1) % MAX_COUNT; m_pHeader->RearMode = WR; break; } while( count < 50 ); if( count >= 50 ) { m_pHeader->RearMode = WR; return SMQ_WRITING; } return 1; }
void mul(Ring_Element& ans,const Ring_Element& a,const Ring_Element& b) { if (a.rep!=b.rep) { throw rep_mismatch(); } if (a.FFTD!=b.FFTD) { throw pr_mismatch(); } ans.partial_assign(a); if (ans.rep==evaluation) { // In evaluation representation, so we can just multiply componentwise for (int i=0; i<(*ans.FFTD).phi_m(); i++) { Mul(ans.element[i],a.element[i],b.element[i],(*a.FFTD).get_prD()); } } else if ((*ans.FFTD).get_twop()!=0) { // This is the case where m is not a power of two // Here we have to do a poly mult followed by a reduction // We could be clever (e.g. use Karatsuba etc), but instead // we do the school book method followed by term re-writing // School book mult vector<modp> aa(2*(*a.FFTD).phi_m()); for (int i=0; i<2*(*a.FFTD).phi_m(); i++) { assignZero(aa[i],(*a.FFTD).get_prD()); } modp temp; for (int i=0; i<(*a.FFTD).phi_m(); i++) { for (int j=0; j<(*a.FFTD).phi_m(); j++) { Mul(temp,a.element[i],b.element[j],(*a.FFTD).get_prD()); int k=i+j; Add(aa[k],aa[k],temp,(*a.FFTD).get_prD()); } } // Now apply reduction, assumes Ring.poly is monic for (int i=2*(*a.FFTD).phi_m()-1; i>=(*a.FFTD).phi_m(); i--) { reduce_step(aa,i,*a.FFTD); assignZero(aa[i],(*a.FFTD).get_prD()); } // Now stick into answer for (int i=0; i<(*ans.FFTD).phi_m(); i++) { ans.element[i]=aa[i]; } } else if ((*ans.FFTD).get_twop()==0) { // m a power of two case Ring_Element aa(*ans.FFTD,ans.rep); modp temp; for (int i=0; i<(*ans.FFTD).phi_m(); i++) { for (int j=0; j<(*ans.FFTD).phi_m(); j++) { Mul(temp,a.element[i],b.element[j],(*a.FFTD).get_prD()); int k=i+j; if (k>=(*ans.FFTD).phi_m()) { k-=(*ans.FFTD).phi_m(); Negate(temp,temp,(*a.FFTD).get_prD()); } Add(aa.element[k],aa.element[k],temp,(*a.FFTD).get_prD()); } } ans=aa; } else { throw not_implemented(); } }
int CSharedMemQueue::PutData(char *pBuf, int size) { char logstr[256]; memset( logstr, 0x00, 256); BYTE BlockMode; int index = 0, count = 0; if( (DWORD)size > m_wOffset ) { sprintf( logstr, "DataSize Over.. - %d bytes\r\n", size ); LogFileWrite( logstr ); return SMQ_PKTSIZEOVER; } do { if( m_pHeader->RearMode == W ) { aa(); count++; continue; } m_pHeader->RearMode = W; m_pHeader->WritePid = ::GetCurrentThreadId(); // writing side (game server) is multi thread aa(); // no operation function if( m_pHeader->WritePid != ::GetCurrentThreadId() ) { count++; continue; } LONG pQueue = m_lReference + (m_pHeader->Rear * m_wOffset); BlockMode = GetByte( (char*)pQueue, index ); if( BlockMode == WR && m_pHeader->nCount >= MAX_COUNT-1 ) { m_pHeader->RearMode = WR; return SMQ_FULL; } index = 0; SetByte( (char*)pQueue, WR, index ); // Block Mode Set to WR -> Data Exist SetShort( (char*)pQueue, size, index ); SetString( (char*)pQueue, pBuf, size, index ); m_pHeader->nCount++; m_pHeader->Rear = (m_pHeader->Rear + 1) % MAX_COUNT; m_pHeader->RearMode = WR; break; } while( count < 50 ); if( count >= 50 ) { m_pHeader->RearMode = WR; return SMQ_WRITING; } return 1; }
void Batched::DrawQuad(Vector2 pos, Vector2 size, float rotation, Texture& tex, int atl) { int i = atl%64; int j = atl/64; Rect aa(i/64.0, (j*32.0)/tex.height, 1/64.0, 32.0/tex.height); innerDraw(pos, size, rotation, tex, aa); }
void TRegularPolygon::get_triangles(const Math::Triangle<2>::put_delegate_t &f, double resolution) const { static const double epsilon = 1e-8; const double rstep = get_radial_step(resolution); const double astep1 = 2.0 * M_PI / (double)_edge_cnt; for (double r = 0 ; r < _radius - epsilon; r += rstep) { for (double a1 = 0; a1 < 2.0 * M_PI - epsilon; a1 += astep1) { Math::Vector2 a(cos(_angle + a1), sin(_angle + a1)); Math::Vector2 aa(a * r); Math::Vector2 ab(a * (r + rstep)); Math::Vector2 b(cos(_angle + a1 + astep1), sin(_angle + a1 + astep1)); Math::Vector2 ba(b * r); Math::Vector2 bb(b * (r + rstep)); f(Math::Triangle<2>(aa, ba, bb)); f(Math::Triangle<2>(bb, ab, aa)); } } }
void KDTreeTestCase::singleSearchExact() { //make sure we can compare points accuratly std::vector<double> a = {1.0,2.0,3.0}; std::vector<double> b = {3.0,2.0,1.0}; //Technically i could do 16 different tests but for now //I'm going to test the two that are important to this //test. If i were to keep going, i would have separate //tests for points Point<3, double, std::string> aa(a, "hello"); Point<3, double, std::string> aa_2(a, "hello"); Point<3, double, std::string> ba(b, "goodbye"); CPPUNIT_ASSERT_MESSAGE("make sure points can be compared with similiar points", aa == aa_2); CPPUNIT_ASSERT_MESSAGE("make sure points can be compared with different points", aa != ba); Point<_N_, double, std::string> pt; search_ptr<_N_, double, std::string> ret; // Grab a bunch of random known point and look for it in the tree for (int test = 0; test < _N_1_SEARCH_TEST_; test++) { pt = points->at(rand() % _N_TEST_POINTS_); ret = tree->search(pt); search_iter<_N_, double, std::string> pos; for( pos = ret->begin(); pos != ret->end(); pos++) { CPPUNIT_ASSERT_MESSAGE("checking if point transferred ok", pos->second == pt); } } }
void generateTF(int trans, Eigen::Quaternionf &R, Eigen::Vector3f &t, Eigen::Matrix3f &mR) { float strengthR=(trans%3)*0.05; trans/=3; float strengthT=(trans%3)*0.05; trans/=3; int temp=trans%8; Eigen::Vector3f axis; axis(0) = temp&1?1:0; axis(1) = temp&2?1:0; axis(2) = temp&4?1:0; trans/=8; Eigen::AngleAxisf aa(strengthR,axis); R = aa.toRotationMatrix(); mR= R.toRotationMatrix(); R = mR; t(0) = temp&1?1:0; if(temp&2) t(0)=-t(0); t(1) = temp&4?1:0; if(temp&8) t(1)=-t(1); t(2) = temp&16?1:0; if(temp&32) t(2)=-t(2); trans/=64; t*=strengthT; }
void *hi(void *ptr) { int a = *(int *)ptr; int b; pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_lock(&mutex1); // printf("into hi function\n"); // klee_make_symbolic(&a, sizeof(a), "input"); /* if(a > 5) printf("nice follow your heart\n"); */ if(b > 100) if(a > 20) printf("int hi00000\n"); else printf("int hi111111\n"); else aa(a); // int a = 10; // if(a > 20) // printf("hfas\n"); /* if(a > 5) printf("hell"); else printf("cry"); */ pthread_mutex_unlock(&mutex1); // printf("out hi function\n"); }
void m2::multABt::calc(matrixn& c, matrixn const& a, matrixn const& b) const { if(&a==&c) { matrixn aa(a); calc(c, aa,b); } if(&b==&c) { matrixn bb(b); calc(c, a,bb); } assert( a.cols()==b.cols() ); c.setSize( a.rows(), b.rows() ); for( int i=0; i<a.rows(); i++ ) for( int j=0; j<b.rows(); j++ ) { c[i][j] = 0; for( int k=0; k<a.cols(); k++ ) c[i][j] += a[i][k] * b[j][k]; } }
int main() { // ======================================================================== std::cout << "Create an amino acid" << std::endl; libaas::aminoAcids::AminoAcid aa('C'); // ======================================================================== std::cout << "Set a stoichiometry configuration" << std::endl; // start creating a custom stoichiometry configuration libaas::StoichiometryConfigImpl::StoichiometryConfigImplKeyType custom_key = "My_Stoichiometry_Configuration 1"; libaas::StoichiometryConfigImpl customConfig(custom_key); // create custom element ... libaas::elements::ElementImpl customElement( libaas::elements::ElementImpl::getNextId(), "C", 6); customElement.addIsotope(13.0034, 1.0); libaas::elements::Element customElementRef(customElement); // ... and add by instance of an element customConfig.insertElement( libaas::elements::Element(customElement.getId())); addStoichiometryConfig(customConfig); aa.setStoichiometryConfig(custom_key); // ======================================================================== std::cout << "Retrieve the stoichiometry" << std::endl; aa.getStoichiometry(); return 0; }
void blah (int code1, int code2) { int i; int n_sets; n_sets = (int) (code1 == 32); if (code2 == 64) goto L2; else goto L3; L2: aa (); L3: if (n_sets > 1) goto L4; else goto L10; L4: aos (); i = 0; goto L24; L10: if (n_sets > 0) goto L25; else goto L8; L25: i = 0; L24: aob (); i = i + 1; if (i < n_sets) goto L24; else goto L8; L8: return; }
void AMSRotMat::YParity(){ number nn[3][3]={{1,0,0},{0,-1,0},{0,0,1}}; AMSRotMat aa(nn); (*this)=(*this)*aa; return; }
bool SerializeAttachment(Grid& grid, TAttachment& attachment, typename geometry_traits<TElem>::iterator iterBegin, typename geometry_traits<TElem>::iterator iterEnd, BinaryBuffer& out) { if(!grid.has_attachment<TElem>(attachment)) return false; // copy data Grid::AttachmentAccessor<TElem, TAttachment> aa(grid, attachment); typedef typename TAttachment::ValueType ValueType; // write a magic number at the beginning and at the end. int magicNumber = 8304548; out.write((char*)&magicNumber, sizeof(int)); //TODO: remove the following test code. // test: write a number-value to check whether it is send correctly /* number tNum = 1247.001234; out.write((char*)&tNum, sizeof(number)); */ for(; iterBegin != iterEnd; ++iterBegin) { out.write((char*)&aa[*iterBegin], sizeof(ValueType)); } out.write((char*)&magicNumber, sizeof(int)); return true; }
int bag(vector< vector< map<int,float> > > & tests, vector<float> & weight){ vector< map<int,float> > aa(USER_NUM); for(int k = 0; k < tests.size(); ++k){ for(int u = 0; u < tests[k].size(); ++u){ if(tests[k][u].empty()) continue; for(map<int,float>::iterator j = tests[k][u].begin(); j != tests[k][u].end(); ++j){ int item = j->first; if(aa[u].find(item) == aa[u].end()) aa[u][item] = 0; aa[u][item] += (float)(j->second) * weight[k]; } } } ofstream out("result-train.txt"); for(int i = 0; i < aa.size(); ++i){ if(aa[i].empty()) continue; vector< pair<int,float> > reco(aa[i].begin(), aa[i].end()); sort(reco.begin(), reco.end(), GreaterSecond<int,float>); //if(reco.size() > 20) reco.erase(reco.begin() + 20, reco.end()); //postProcessByLanguage(i, reco); out << i << ":" << reco[0].first; for(int k = 1; k < reco.size() && k < 20; ++k) out << "," << reco[k].first; out << endl; } out.close(); return score(aa); }
DLLEXPORT void STDCALL FORM_DoPageAAction(FPDF_PAGE page, FPDF_FORMHANDLE hHandle, int aaType) { if (!hHandle) return; CPDFSDK_Document* pSDKDoc = ((CPDFDoc_Environment*)hHandle)->GetSDKDocument(); UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page); CPDF_Page* pPDFPage = CPDFPageFromFPDFPage(page); if (!pPDFPage) return; if (pSDKDoc->GetPageView(pPage, FALSE)) { CPDFDoc_Environment* pEnv = pSDKDoc->GetEnv(); CPDFSDK_ActionHandler* pActionHandler = pEnv->GetActionHander(); CPDF_Dictionary* pPageDict = pPDFPage->m_pFormDict; CPDF_AAction aa(pPageDict->GetDictBy("AA")); if (FPDFPAGE_AACTION_OPEN == aaType) { if (aa.ActionExist(CPDF_AAction::OpenPage)) { CPDF_Action action = aa.GetAction(CPDF_AAction::OpenPage); pActionHandler->DoAction_Page(action, CPDF_AAction::OpenPage, pSDKDoc); } } else { if (aa.ActionExist(CPDF_AAction::ClosePage)) { CPDF_Action action = aa.GetAction(CPDF_AAction::ClosePage); pActionHandler->DoAction_Page(action, CPDF_AAction::ClosePage, pSDKDoc); } } } }
void motion3s(Eigen::Matrix3f &rot, Eigen::Vector3f &tr) { Eigen::Vector3f n=Eigen::Vector3f::Identity(); Eigen::AngleAxisf aa(0.05f,n); rot = aa.toRotationMatrix(); tr.fill(0); }
std::string to_string(big_integer const& a) { std::string res = ""; big_integer aa (a); big_integer bb (0); big_integer cc (0); big_integer dd (0); if (a.flag == 1) { aa.flag = false; } if (a == big_integer(0)) return "0"; while ((aa) > big_integer(0)) { bb = aa / big_integer(1000000000); cc = bb * big_integer(1000000000); dd = aa - cc; aa = bb; for (int i = 0; i < 9; i++) { res += dd.data[0] % 10 + 48; dd.data[0] /= 10; } } while (res[res.size() - 1] == '0') res.pop_back(); if (a.flag == 1) { res+='-'; } for (int i = 0; i < res.size()/2; ++i) { std::swap(res[i], res[res.size()-1-i]); } return res; }
HyperGraphElementAction* VertexSE3DrawAction::operator()(HyperGraph::HyperGraphElement* element, HyperGraphElementAction::Parameters* params_){ if (typeid(*element).name()!=_typeName) return 0; if (! _cacheDrawActions){ _cacheDrawActions = HyperGraphActionLibrary::instance()->actionByName("draw"); } refreshPropertyPtrs(params_); if (! _previousParams) return this; if (_show && !_show->value()) return this; VertexSE3* that = static_cast<VertexSE3*>(element); glColor3f(0.5,0.5,0.8); glPushMatrix(); glTranslatef(that->estimate().translation().x(),that->estimate().translation().y(),that->estimate().translation().z()); AngleAxisd aa(that->estimate().rotation()); glRotatef(RAD2DEG(aa.angle()),aa.axis().x(),aa.axis().y(),aa.axis().z()); if (_triangleX && _triangleY){ drawTriangle(_triangleX->value(), _triangleY->value()); } CacheContainer* caches=that->cacheContainer(); if (caches){ for (CacheContainer::iterator it=caches->begin(); it!=caches->end(); it++){ Cache* c = it->second; (*_cacheDrawActions)(c, params_); } } glPopMatrix(); return this; }
// static bool GLinearProgramming::simplexMethod(GMatrix* pA, const double* pB, int leConstraints, int geConstraints, const double* pC, double* pOutX) { // Set up the matrix in the expected form if((size_t)leConstraints + (size_t)geConstraints > pA->rows()) throw Ex("The number of constraints must be >= leConstraints + geConstraints"); GMatrix aa(pA->rows() + 3, pA->cols() + 2); aa.setAll(0.0); aa[1][1] = 0.0; GVec::copy(aa.row(1).data() + 2, pC, pA->cols()); for(size_t i = 1; i <= pA->rows(); i++) { GVec::copy(aa.row(i + 1).data() + 2, pA->row(i - 1).data(), pA->cols()); GVec::multiply(aa.row(i + 1).data() + 2, -1.0, pA->cols()); aa[i + 1][1] = pB[i - 1]; } // Solve it int icase; GTEMPBUF(int, iposv, aa.rows()); GTEMPBUF(int, izrov, aa.cols()); simplx(aa, (int)pA->rows(), (int)pA->cols(), leConstraints, geConstraints, &icase, izrov, iposv); // Extract the results if(icase) return false; // No solution. (icase gives an error code) GVec::setAll(pOutX, 0.0, pA->cols()); for(size_t i = 1; i <= pA->rows(); i++) { int index = iposv[i]; if(index >= 1 && index <= (int)pA->cols()) pOutX[index - 1] = aa[i + 1][1]; } return true; }
/* this function is called from field renderers for all field nodes */ void Renderer::setNodeGlData(const shared_ptr<Node>& n){ bool scaleRotations=(rotScale!=1.0 && scaleOn); bool scaleDisplacements=(dispScale!=Vector3r::Ones() && scaleOn); const bool isPeriodic=scene->isPeriodic; if(!n->hasData<GlData>()) n->setData<GlData>(make_shared<GlData>()); GlData& gld=n->getData<GlData>(); // inside the cell if periodic, same as pos otherwise Vector3r cellPos=(!isPeriodic ? n->pos : scene->cell->canonicalizePt(n->pos,gld.dCellDist)); bool rendered=!pointClipped(cellPos); // this encodes that the node is clipped if(!rendered){ gld.dGlPos=Vector3r(NaN,NaN,NaN); return; } if(setRefNow || isnan(gld.refPos[0])) gld.refPos=n->pos; if(setRefNow || isnan(gld.refOri.x())) gld.refOri=n->ori; const Vector3r& pos=n->pos; const Vector3r& refPos=gld.refPos; const Quaternionr& ori=n->ori; const Quaternionr& refOri=gld.refOri; // if no scaling and no periodic, return quickly if(!(scaleDisplacements||scaleRotations||isPeriodic)){ gld.dGlPos=Vector3r::Zero(); gld.dGlOri=Quaternionr::Identity(); return; } // apply scaling gld.dGlPos=cellPos-n->pos; // add scaled translation to the point of reference if(scaleDisplacements) gld.dGlPos+=((dispScale-Vector3r::Ones()).array()*Vector3r(pos-refPos).array()).matrix(); if(!scaleRotations) gld.dGlOri=Quaternionr::Identity(); else{ Quaternionr relRot=refOri.conjugate()*ori; AngleAxisr aa(relRot); aa.angle()*=rotScale; gld.dGlOri=Quaternionr(aa); } }
void withReference() { int xx = 4711; Chamaeleon<int&> aa(xx); CPPUNIT_ASSERT_EQUAL( xx, aa.unHide() ); }
void withPointer() { A* aPtr = new A(); Chamaeleon<A*> aa(aPtr); CPPUNIT_ASSERT_EQUAL( 1, aa.unHide()->test() ); }
void OpenGLRenderer::setBodiesDispInfo(){ if(scene->bodies->size()!=bodyDisp.size()) { bodyDisp.resize(scene->bodies->size()); for (unsigned k=0; k<scene->bodies->size(); k++) bodyDisp[k].hidden=0;} bool scaleRotations=(rotScale!=1.0); bool scaleDisplacements=(dispScale!=Vector3r::Ones()); FOREACH(const shared_ptr<Body>& b, *scene->bodies){ if(!b || !b->state) continue; size_t id=b->getId(); const Vector3r& pos=b->state->pos; const Vector3r& refPos=b->state->refPos; const Quaternionr& ori=b->state->ori; const Quaternionr& refOri=b->state->refOri; Vector3r cellPos=(!scene->isPeriodic ? pos : scene->cell->wrapShearedPt(pos)); // inside the cell if periodic, same as pos otherwise bodyDisp[id].isDisplayed=!pointClipped(cellPos); // if no scaling and no periodic, return quickly if(!(scaleDisplacements||scaleRotations||scene->isPeriodic)){ bodyDisp[id].pos=pos; bodyDisp[id].ori=ori; continue; } // apply scaling bodyDisp[id].pos=cellPos; // point of reference (inside the cell for periodic) if(scaleDisplacements) bodyDisp[id].pos+=dispScale.cwiseProduct(Vector3r(pos-refPos)); // add scaled translation to the point of reference if(!scaleRotations) bodyDisp[id].ori=ori; else{ Quaternionr relRot=refOri.conjugate()*ori; AngleAxisr aa(relRot); aa.angle()*=rotScale; bodyDisp[id].ori=refOri*Quaternionr(aa); } } }
//!Precompute relative rotations (and precompute ScGeom3D) void ScGeom6D::precomputeRotations(const State& rbp1, const State& rbp2, bool isNew, bool creep){ if (isNew) { initRotations(rbp1,rbp2); } else { Quaternionr delta((rbp1.ori * (initialOrientation1.conjugate())) * (initialOrientation2 * (rbp2.ori.conjugate()))); delta.normalize(); if (creep) delta = delta * twistCreep; AngleAxisr aa(delta); // axis of rotation - this is the Moment direction UNIT vector; // angle represents the power of resistant ELASTIC moment //Eigen::AngleAxisr(q) returns nan's when q close to identity, next tline fixes the pb. // add -DYADE_SCGEOM_DEBUG to CXXFLAGS to enable this piece or just do // #define YADE_SCGEOM_DEBUG //(but do not commit with that enabled in the code) #ifdef YADE_SCGEOM_DEBUG if (isnan(aa.angle())) { cerr<<"NaN angle found in angleAxisr(q), for quaternion "<<delta<<", after quaternion product"<<endl; cerr<<"rbp1.ori * (initialOrientation1.conjugate())) * (initialOrientation2 * (rbp2.ori.conjugate()) with quaternions :"<<endl; cerr<<rbp1.ori<<" * "<<initialOrientation1<<" * "<<initialOrientation2<<" * "<<rbp2.ori<<endl<<" and sub-products :"<<endl<<rbp1.ori * (initialOrientation1.conjugate())<<" * "<<initialOrientation2 * (rbp2.ori.conjugate())<<endl; cerr <<"q.w (before normalization) "<<delta.w(); delta.normalize(); cerr <<"q.w (after) "<<delta.w()<<endl; AngleAxisr bb(delta); cerr<<delta<<" "<<bb.angle()<<endl; } #else if (isnan(aa.angle())) aa.angle()=0; #endif if (aa.angle() > Mathr::PI) aa.angle() -= Mathr::TWO_PI; // angle is between 0 and 2*pi, but should be between -pi and pi twist = (aa.angle() * aa.axis().dot(normal)); bending = Vector3r(aa.angle()*aa.axis() - twist*normal); } }
bool fmd5app::heartbeat() { int a = 0xA0F980; stringc aa(a, 16); stringc bb = fitoa16(a); stringc tmp = fmd5(bb.c_str(), bb.size()); uint32_t cc32 = fcrc32(bb.c_str(), bb.size()); uint32_t cc32a = fcrc32a(bb.c_str(), bb.size()); FUSE(cc32); FUSE(cc32a); stringc sha1 = fsha1(bb.c_str(), bb.size()); FUSE(sha1); uint8_t src[]="12345678"; uint8_t des[8]; uint8_t ddes[8]; fdes("12345678", src, 8, des); fundes("12345678", des, 8, ddes); stringc des1 = fdes("12345678", "12345678"); stringc src1 = fundes("12345678", des1); FUSE(src1); uint8_t aes_src[]="1234567812345678"; uint8_t aes_des[16]; uint8_t aes_ddes[16]; faes("12345678", aes_src, 16, aes_des); funaes("12345678", aes_des, 16, aes_ddes); stringc aes_des1 = faes("12345678", "1234567812345678"); stringc aes_src1 = funaes("12345678", aes_des1); FUSE(aes_src1); return true; }
int main() { typedef CGAL::Surface_mesh<Point_3> Mesh; Mesh mesh; test_validity(mesh); // triangle quad tetra hexa test<Mesh>("data/triangle.off", true, false, false, false ); test<Mesh>("data/quad.off", false, true, false, false ); test<Mesh>("data/tetrahedron.off", false, false, true, false ); test<Mesh>("data/cube.off", false, false, false, false ); test<Mesh>("data/cube-quads.off", false, false, false, true ); typedef boost::graph_traits<Mesh>::halfedge_descriptor halfedge_descriptor; Point_3 a(0,0,0), b(1,0,0), c(1,1,0), d(0,1,0); Point_3 aa(0,0,1), bb(1,0,1), cc(1,1,1), dd(0,1,1); Mesh m; halfedge_descriptor hd; hd = CGAL::make_triangle(a,b,c,m); assert(CGAL::is_isolated_triangle(hd,m)); assert(CGAL::is_valid_polygon_mesh(m)); m.clear(); hd = CGAL::make_quad(a,b,c,d,m); assert(CGAL::is_isolated_quad(hd,m)); assert(CGAL::is_valid_polygon_mesh(m)); assert(CGAL::is_quad_mesh(m)); m.clear(); hd = CGAL::make_tetrahedron(a,b,c,d,m); assert(CGAL::is_tetrahedron(hd,m)); assert(CGAL::is_triangle_mesh(m)); assert(CGAL::is_valid_polygon_mesh(m)); m.clear(); hd = CGAL::make_hexahedron(a,b,c,d,dd,aa,bb,cc,m); assert(CGAL::is_hexahedron(hd,m)); assert(CGAL::is_quad_mesh(m)); assert(CGAL::is_valid_polygon_mesh(m)); m.clear(); CGAL::make_icosahedron<Mesh, Point_3>(m); assert(num_faces(m) == 20); assert(CGAL::is_triangle_mesh(m)); assert(CGAL::is_valid_polygon_mesh(m)); m.clear(); hd = CGAL::make_pyramid<Mesh, Point_3>(3, m); assert(num_faces(m) == 6); assert(CGAL::is_triangle_mesh(m)); assert(CGAL::is_valid_polygon_mesh(m)); m.clear(); hd = CGAL::make_regular_prism<Mesh, Point_3>(4, m); assert(num_faces(m) == 16); assert(CGAL::is_triangle_mesh(m)); assert(CGAL::is_valid_polygon_mesh(m)); m.clear(); CGAL::make_grid(3,3,m); assert(num_faces(m) == 9); assert(CGAL::is_quad_mesh(m)); assert(CGAL::is_valid_polygon_mesh(m)); std::cerr << "done" << std::endl; return 0; }
/*! * \brief LAArmadillo::det * Calculate the determinant of a * \param result * \param a */ void LAArmadillo::det(double &result, const OiMat &a){ int matSize = a.getRowCount(); arma::mat aa(matSize, matSize); this->oiMat2Arma(aa, a); result = arma::det(aa); }
void gplus(){ Global++; INTERLEV_ACCESS(0,"cs2.gplus","0"); INTERLEV_ACCESS(0,"cs3.gplus","0,1"); INTERLEV_ACCESS(0,"cs4.gplus","0"); INTERLEV_ACCESS(1,"cs1.foo2,cs6.gplus","0,1"); cs7: aa(); }
Math::Vector3<T> getVector (int i) { switch (i) { case 0: return Math::Vector3<T> (aa (), ab (), ac ()); case 1: return Math::Vector3<T> (ab (), bb (), bc ()); case 2: return Math::Vector3<T> (ac (), bc (), cc ()); default: ABORT (); } }
void sfsserver_auth::userauth::finish () { assert (!aborted); auto_auth aa (authuint_create (authno)); authno = 0; sp->authnos.insert (aid, aa); sp->authpending.remove (aid); }