コード例 #1
0
ファイル: longlongtest.cpp プロジェクト: AaronDP/wxWidgets
void LongLongTestCase::Multiplication()
{
    for ( size_t n = 0; n < ITEMS; n++ )
    {
        wxLongLong a = RAND_LL();
        wxLongLong b = RAND_LL();
        wxLongLong c = a*b;

        wxLongLong a1(a.GetHi(), a.GetLo());
        wxLongLong b1(b.GetHi(), b.GetLo());
        wxLongLong c1 = a1*b1;
        CPPUNIT_ASSERT( c1 == c );

#if wxUSE_LONGLONG_WX
        wxLongLongWx a2(a.GetHi(), a.GetLo());
        wxLongLongWx b2(b.GetHi(), b.GetLo());
        wxLongLongWx c2 = a2*b2;
        CPPUNIT_ASSERT( c2 == c );
#endif

#if wxUSE_LONGLONG_NATIVE
        wxLongLongNative a3(a.GetHi(), a.GetLo());
        wxLongLongNative b3(b.GetHi(), b.GetLo());
        wxLongLongNative c3 = a3*b3;
        CPPUNIT_ASSERT( c3 == c );
#endif
    }
}
コード例 #2
0
int main() {
  
  dump();

  for (int i=0;i<500;i++) {
    {
      flop = !flop;
      blockWipedPool().wipe();
      if (i%10==0)  blockWipedPool().clear();
      BP b1(new A1);
      BP b2(new A2);
      BP b3(new A3);
      dump();
      {
	BP bb1(b1->clone());
	BP bb2(b2->clone());
	BP bb3(b3->clone());
	dump();
      }
      dump("after clone destr");
      
      BP b11(new A1);
      BP b22(new A2);
      BP b23(new A2);
      dump();
      b1.reset();
      b2.reset();
      b3.reset();
      dump("after first destr");
    }
    dump();
    { 
      std::vector<BP> v(233);
      for_each(v.begin(),v.end(),&gen);
      dump("after 233 alloc");
      v.resize(123);
      dump("after 110 distr");
    }
    dump();
    
    for (int i=0;i<3;i++){
      std::vector<BP> v(2432);
      for_each(v.begin(),v.end(),&gen);
      std::vector<BP> v1(3213);
      for_each(v1.begin(),v1.end(),&gen);
      {
	std::vector<BP> d; d.swap(v);
      }
      // alloc disalloc
      std::vector<BP> vs(514);
      for_each(vs.begin(),vs.end(),&gen);
      for_each(vs.begin(),vs.end(),&gen);
    }
    dump("loop end");
  }
  return 0;
}
コード例 #3
0
void convertHFShowerLibrary() {
  TFile *nF=new TFile("david.root","RECREATE","hiThere",1);
  TTree *nT=new TTree("HFSimHits","HF simple tree");
  std::vector<float> *parts=new std::vector<float>();
  std::vector<float> *partsHad=new std::vector<float>();
  nT->Branch("emParticles", &parts);
  nT->GetBranch("emParticles")->SetBasketSize(1);
  nT->Branch("hadParticles", &partsHad);
  nT->GetBranch("hadParticles")->SetBasketSize(1);

  TDirectory *target=gDirectory;
  TFile *oF=TFile::Open("HFShowerLibrary_npmt_noatt_eta4_16en_v3_orig.root");
  TTree *t=(TTree*)oF->Get("HFSimHits");
  TTreeReader fReader(t);
  TTreeReaderArray<Float_t> b1(fReader, "emParticles.position_.fCoordinates.fX");
  TTreeReaderArray<Float_t> b2(fReader, "emParticles.position_.fCoordinates.fY");
  TTreeReaderArray<Float_t> b3(fReader, "emParticles.position_.fCoordinates.fZ");
  TTreeReaderArray<Float_t> b4(fReader, "emParticles.lambda_");
  TTreeReaderArray<Float_t> b5(fReader, "emParticles.time_");

  TTreeReaderArray<Float_t> h1(fReader, "hadParticles.position_.fCoordinates.fX");
  TTreeReaderArray<Float_t> h2(fReader, "hadParticles.position_.fCoordinates.fY");
  TTreeReaderArray<Float_t> h3(fReader, "hadParticles.position_.fCoordinates.fZ");
  TTreeReaderArray<Float_t> h4(fReader, "hadParticles.lambda_");
  TTreeReaderArray<Float_t> h5(fReader, "hadParticles.time_");


  target->cd();
  while ( fReader.Next() ) {
    parts->clear();
    unsigned int s=b1.GetSize();
    parts->resize(5*s);
    for ( unsigned int i=0; i<b1.GetSize(); i++) {
      (*parts)[i]=(b1[i]);
      (*parts)[i+1*s]=(b2[i]);
      (*parts)[i+2*s]=(b3[i]);
      (*parts)[i+3*s]=(b4[i]);
      (*parts)[i+4*s]=(b5[i]);
    }  

    partsHad->clear();
    s=h1.GetSize();
    partsHad->resize(5*s);
    for ( unsigned int i=0; i<h1.GetSize(); i++) {
      (*partsHad)[i]=(h1[i]);
      (*partsHad)[i+1*s]=(h2[i]);
      (*partsHad)[i+2*s]=(h3[i]);
      (*partsHad)[i+3*s]=(h4[i]);
      (*partsHad)[i+4*s]=(h5[i]);
    }  

    nT->Fill();
  }

  nT->Write();
  nF->Close();
}
コード例 #4
0
ファイル: fullscreen.cpp プロジェクト: edeproject/svn
int main(int argc, char **argv) {

  int i=0;
  if (Fl::args(argc,argv,i,arg) < argc)
    Fl::fatal("Options are:\n -2 = 2 windows\n -f = startup fullscreen\n%s",Fl::help);

  Fl_Single_Window window(300,300+30*NUMB); window.end();

  shape_window sw(10,10,window.w()-20,window.h()-30*NUMB-20);
#if HAVE_GL
  sw.mode(FL_RGB);
#endif

  Fl_Window *w;
  if (twowindow) {	// make it's own window
    sw.resizable(&sw);
    w = &sw;
    window.set_modal();	// makes controls stay on top when fullscreen pushed
    argc--;
    sw.show();
  } else {		// otherwise make a subwindow
    window.add(sw);
    window.resizable(&sw);
    w = &window;
  }

  window.begin();

  int y = window.h()-30*NUMB-5;
  Fl_Hor_Slider slider(50,y,window.w()-60,30,"Sides:");
  slider.clear_flag(FL_ALIGN_MASK);
  slider.set_flag(FL_ALIGN_LEFT);
  slider.callback(sides_cb,&sw);
  slider.value(sw.sides);
  slider.step(1);
  slider.range(3,40);
  y+=30;

  Fl_Toggle_Light_Button b1(50,y,window.w()-60,30,"Double Buffered");
  b1.callback(double_cb,&sw);
  y+=30;

  Fl_Toggle_Light_Button b3(50,y,window.w()-60,30,"FullScreen");
  b3.callback(fullscreen_cb,w);
  y+=30;

  Fl_Button eb(50,y,window.w()-60,30,"Exit");
  eb.callback(exit_cb);
  y+=30;

  if (initfull) {b3.set(); b3.do_callback();}

  window.end();
  window.show(argc,argv);

  return Fl::run();
}
コード例 #5
0
/* Public functions */
void VGCRectangleTest::run(){
	VGCRectangle r0;
	VGCAssert(VGCVector(0, 0) == r0.getPosition());
	VGCAssert(0 == r0.getWidth());
	VGCAssert(0 == r0.getHeight());

	r0.setPosition(VGCVector(1, 2));
	VGCAssert(VGCVector(1, 2) == r0.getPosition());
	r0.setWidth(1);
	VGCAssert(1 == r0.getWidth());
	r0.setHeight(2);
	VGCAssert(2 == r0.getHeight());

	VGCRectangle r1(VGCVector(1, 2), 1, 2);
	VGCAssert(VGCVector(1, 2) == r1.getPosition());
	VGCAssert(1 == r1.getWidth());
	VGCAssert(2 == r1.getHeight());

	VGCRectangle r2(r1);
	VGCAssert(VGCVector(1, 2) == r2.getPosition());
	VGCAssert(1 == r2.getWidth());
	VGCAssert(2 == r2.getHeight());

	VGCRectangle r3;
	r3 = r2;
	VGCAssert(VGCVector(1, 2) == r3.getPosition());
	VGCAssert(1 == r3.getWidth());
	VGCAssert(2 == r3.getHeight());

	VGCRectangle r4(VGCVector(1, 2), 2, 3);
	VGCAssert(r4.isInside(VGCVector(1, 2)));
	VGCAssert(r4.isInside(VGCVector(2, 2)));
	VGCAssert(r4.isInside(VGCVector(1, 3)));
	VGCAssert(r4.isInside(VGCVector(2, 3)));
	VGCAssert(r4.isInside(VGCVector(1, 4)));
	VGCAssert(r4.isInside(VGCVector(2, 4)));
	VGCAssert(!r4.isInside(VGCVector(0, 3)));
	VGCAssert(!r4.isInside(VGCVector(2, 5)));


	VGCRectangle a0(VGCVector(0, 0), 0, 0);
	VGCRectangle a1(VGCVector(0, 0), 0, 1);
	VGCRectangle a2(VGCVector(0, 0), 1, 0);
	VGCRectangle a3(VGCVector(0, 1), 0, 0);
	VGCRectangle b0(VGCVector(0, 0), 0, 0);
	VGCRectangle b1(VGCVector(0, 0), 0, 1);
	VGCRectangle b2(VGCVector(0, 0), 1, 0);
	VGCRectangle b3(VGCVector(0, 1), 0, 0);
	VGCAssert(a0 == b0);
	VGCAssert(a1 == b1);
	VGCAssert(a2 == b2);
	VGCAssert(a3 == b3);
	VGCAssert(a0 != a1);
	VGCAssert(a0 != a2);
	VGCAssert(a0 != a3);
}
コード例 #6
0
ファイル: test32.cpp プロジェクト: 8l/rose
void foo()
{
    int val;
    int *p = &val;
    A a1(p);
    A a2, a3;
    a2 = a3 = a1;
    B b1, b2(2), b3(3);
    b1 = b2 + b3;
}
コード例 #7
0
ファイル: TCollisionShapes.cpp プロジェクト: bdbdonp/tubras
    //-----------------------------------------------------------------------
    //                     e x t r a c t T r i a n g l e s
    //-----------------------------------------------------------------------
    btTriangleMesh* TMeshShape::extractTriangles(IMesh* mesh,   
        bool removeDupVertices)
    {
        vector3df p1, p2, p3;

        // 32 bit indices, 3 component vertices - allows for use in decomposition.
        btTriangleMesh* triMesh = new btTriangleMesh(true, false);
        u32 bufCount = mesh->getMeshBufferCount();

        for(u32 i=0;i<bufCount;i++)
        {
            IMeshBuffer* mbuf = mesh->getMeshBuffer(i);
            void* vp = mbuf->getVertices();
            E_VERTEX_TYPE vtype = mbuf->getVertexType();
            S3DVertex           *vstd = (S3DVertex*) vp;
            S3DVertex2TCoords   *v2t = (S3DVertex2TCoords*) vp;
            S3DVertexTangents   *vtan = (S3DVertexTangents*)vp;
            const u16* ip = mbuf->getIndices();
            u32 ic = mbuf->getIndexCount();
            u32 fi = 0;
            while(fi < ic)
            {
                S3DVertex *v1,*v2,*v3;
                switch(vtype)
                {
                case EVT_2TCOORDS:
                    v1 = &v2t[ip[fi++]];
                    v2 = &v2t[ip[fi++]];
                    v3 = &v2t[ip[fi++]];
                    break;
                case EVT_TANGENTS:
                    v1 = &vtan[ip[fi++]];
                    v2 = &vtan[ip[fi++]];
                    v3 = &vtan[ip[fi++]];
                    break;
                default:
                    v1 = &vstd[ip[fi++]];
                    v2 = &vstd[ip[fi++]];
                    v3 = &vstd[ip[fi++]];
                    break;
                }

                p1 = v1->Pos;
                p2 = v2->Pos;
                p3 = v3->Pos;

                btVector3 b1(p1.X, p1.Y, p1.Z);
                btVector3 b2(p2.X, p2.Y, p2.Z);
                btVector3 b3(p3.X, p3.Y, p3.Z);

                triMesh->addTriangle(b1,b2,b3,removeDupVertices);
            }
        }
        return triMesh;
    }
コード例 #8
0
void test_non_contiguous()
{
    BuffAggr b3(6, false);
    uint32_t off = 0;
    for ( uint32_t i=0; i<7; i++) {
        uint8_t *buf = create_buf(i+4);
        b3.set_buf(buf, off, i+4);
        off += i + 4 + 10;
    }
    b3.print();
}
コード例 #9
0
ファイル: Test.cpp プロジェクト: momo462/Project
void test4()
{
	BigData b1("9999999999999999999999999999999");
	BigData b2("9999999999999999999999999999991");
	cout<<b1-b2<<endl;
	BigData b3("33333333333333");
	BigData b4("9999999999999999999999999999999");
	cout<<b3-b4<<endl;
	BigData b5("9999999999999999999999999999991");
	BigData b6("9999999999999999999999999999999");
	cout<<b5-b6<<endl;
}
コード例 #10
0
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    
    GLint viewport[4];
    glGetIntegerv(GL_VIEWPORT, viewport);
    double aspect = (double)viewport[2] / (double)viewport[3];
    gluPerspective(fovy, aspect, clipNear, clipFar);
    
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    
    gluLookAt(0, 0, z, x, y, 0, 0, 1, 0);
    
    if (success) {
        drawFaces();
        
        if (drawAABB) {
            Eigen::Vector3d max = boundingBox.max;
            Eigen::Vector3d min = boundingBox.min;
            Eigen::Vector3d extent = boundingBox.extent;
            
            Eigen::Vector3d b2(min.x() + extent.x(), min.y(), min.z());
            Eigen::Vector3d b3(min.x() + extent.x(), min.y() + extent.y(), min.z());
            Eigen::Vector3d b4(min.x(), min.y() + extent.y(), min.z());
            Eigen::Vector3d b5(max.x() - extent.x(), max.y() - extent.y(), max.z());
            Eigen::Vector3d b6(max.x(), max.y() - extent.y(), max.z());
            Eigen::Vector3d b8(max.x() - extent.x(), max.y(), max.z());
            
            drawBox(min, b2, b3, b4, b5, b6, max, b8);
            
        } else {
            std::vector<Eigen::Vector3d> orientedPoints = boundingBox.orientedPoints;
            
            Eigen::Vector3d b1 = orientedPoints[0] + orientedPoints[2] + orientedPoints[4];
            Eigen::Vector3d b2 = orientedPoints[1] + orientedPoints[2] + orientedPoints[4];
            Eigen::Vector3d b3 = orientedPoints[1] + orientedPoints[2] + orientedPoints[5];
            Eigen::Vector3d b4 = orientedPoints[0] + orientedPoints[2] + orientedPoints[5];
            Eigen::Vector3d b5 = orientedPoints[0] + orientedPoints[3] + orientedPoints[4];
            Eigen::Vector3d b6 = orientedPoints[1] + orientedPoints[3] + orientedPoints[4];
            Eigen::Vector3d b8 = orientedPoints[0] + orientedPoints[3] + orientedPoints[5];
            Eigen::Vector3d b7 = orientedPoints[1] + orientedPoints[3] + orientedPoints[5];
            
            drawBox(b1, b2, b3, b4, b5, b6, b7, b8);
        }
    }
    
    glutSwapBuffers();
}
コード例 #11
0
ファイル: HttpCarrier.cpp プロジェクト: paulfitz/yarp
bool yarp::os::impl::HttpCarrier::write(Protocol& proto, SizedWriter& writer) {
    DummyConnector con;
    con.setTextMode(true);
    for (size_t i=writer.headerLength(); i<writer.length(); i++) {
        con.getWriter().appendBlock(writer.data(i),writer.length(i));
    }
    Bottle b;
    b.read(con.getReader());

    ConstString body = b.find("web").toString();
    if (body.length()!=0) {
        ConstString header;
        header += NetType::toHexString(body.length()).c_str();
        header += "\r\n";

        Bytes b2((char*)header.c_str(),header.length());
        proto.os().write(b2);

        Bytes b3((char*)body.c_str(),body.length());
        proto.os().write(b3);

        proto.os().write('\r');
        proto.os().write('\n');

    } else {
        ConstString txt = b.toString() + "\r\n";
        ConstString header;
        header += NetType::toHexString(txt.length()).c_str();
        header += "\r\n";
        Bytes b2((char*)header.c_str(),header.length());
        proto.os().write(b2);
        Bytes b3((char*)txt.c_str(),txt.length());
        proto.os().write(b3);
        proto.os().write('\r');
        proto.os().write('\n');
    }
    proto.os().flush();
    return proto.os().isOk();
}
コード例 #12
0
ファイル: main.cpp プロジェクト: CCJY/coliru
int main()
{
    std::string s = "bonjour";

    Buffer b1(s);
    Buffer b2(s);
    Buffer b3(std::string("bonjour"));

    std::cout << s << std::endl;
    std::cout << b1.donnees_ << std::endl;
    std::cout << b2.donnees_ << std::endl;
    std::cout << b3.donnees_ << std::endl;
}
コード例 #13
0
void test_single_dest() {

   // push only
   tbb::flow::graph g;
   tbb::flow::source_node<T> src(g, source_body<T>() );
   test_push_receiver<T> dest;
   tbb::flow::make_edge( src, dest );
   g.wait_for_all();
   for (int i = 0; i < N; ++i ) {
       ASSERT( dest.get_count(i) == 1, NULL ); 
   }

   // push only
   tbb::atomic<int> counters3[N];
   tbb::flow::source_node<T> src3(g, source_body<T>() );
   function_body<T> b3( counters3 );
   tbb::flow::function_node<T,bool> dest3(g, tbb::flow::unlimited, b3 );
   tbb::flow::make_edge( src3, dest3 );
   g.wait_for_all();
   for (int i = 0; i < N; ++i ) {
       int v = counters3[i];
       ASSERT( v == 1, NULL ); 
   }

   // push & pull 
   tbb::flow::source_node<T> src2(g, source_body<T>() );
   tbb::atomic<int> counters2[N];
   function_body<T> b2( counters2 );
   tbb::flow::function_node<T,bool> dest2(g, tbb::flow::serial, b2 );
   tbb::flow::make_edge( src2, dest2 );
#if TBB_PREVIEW_FLOW_GRAPH_FEATURES
   ASSERT(src2.successor_count() == 1, NULL);
   typename tbb::flow::source_node<T>::successor_vector_type my_succs;
   src2.copy_successors(my_succs);
   ASSERT(my_succs.size() == 1, NULL);
#endif
   g.wait_for_all();
   for (int i = 0; i < N; ++i ) {
       int v = counters2[i];
       ASSERT( v == 1, NULL ); 
   }

   // test copy constructor
   tbb::flow::source_node<T> src_copy(src);
   test_push_receiver<T> dest_c;
   ASSERT( src_copy.register_successor(dest_c), NULL );
   g.wait_for_all();
   for (int i = 0; i < N; ++i ) {
       ASSERT( dest_c.get_count(i) == 1, NULL ); 
   }
}
コード例 #14
0
ファイル: Arrays11.cpp プロジェクト: Blaze5xD/pipeproject
void level_three()
{
	vector<DPipe> DirectPipes(13);
		vector<DoublePipe> DoublePipes(13);
		vector<CrossPipe> CrossPipes(2);
				DPipe a0(50,SCREEN_HEIGHT-50,100,40);
				DoublePipe b0(150,SCREEN_HEIGHT-50,70,40);
				DPipe a1(150,SCREEN_HEIGHT-150,100,40);
				DoublePipe b1(150,SCREEN_HEIGHT-250,70,40);
				DPipe a2(250,SCREEN_HEIGHT-350,100,40);
				DoublePipe b2(350,SCREEN_HEIGHT-250,70,40);
				DPipe a3(350,SCREEN_HEIGHT-350,100,40);
				DPipe a4(350,SCREEN_HEIGHT-150,100,40);
				DoublePipe b3(250,SCREEN_HEIGHT-450,70,40);
				DoublePipe b4(350,SCREEN_HEIGHT-450,70,40);
				CrossPipe c0(250,SCREEN_HEIGHT-250,100,40);
				DPipe a5(550,SCREEN_HEIGHT-50,100,40);
				DoublePipe b5(250,SCREEN_HEIGHT-150,70,40);
				DoublePipe b6(450,SCREEN_HEIGHT-50,70,40);
				DoublePipe b7(650,SCREEN_HEIGHT-150,70,40);
				DPipe a6(550,SCREEN_HEIGHT-50,100,40);
				DPipe a7(550,SCREEN_HEIGHT-150,100,40);
				DoublePipe b8(750,SCREEN_HEIGHT-50,70,40);
				DPipe a8(550,SCREEN_HEIGHT-250,100,40);
				DoublePipe b9(750,SCREEN_HEIGHT-350,70,40);
				CrossPipe c1(450,SCREEN_HEIGHT-150,100,40);
				DoublePipe b10(350,SCREEN_HEIGHT-450,70,40);
				DPipe a9(750,SCREEN_HEIGHT-150,100,40);
				DPipe a10(750,SCREEN_HEIGHT-250,100,40);
				DoublePipe b11(450,SCREEN_HEIGHT-250,70,40);
				DoublePipe b12(650,SCREEN_HEIGHT-250,70,40);
				DPipe a11(650,SCREEN_HEIGHT-50,100,40);
				DPipe a12(850,SCREEN_HEIGHT-350,100,40);

				DirectPipes[0] = a0; DoublePipes[0] = b0;
				DirectPipes[1] = a1; DoublePipes[1] = b1;
				DirectPipes[2] = a2; DoublePipes[2] = b2;
				DirectPipes[3] = a3; DoublePipes[3] = b3;
				DirectPipes[4] = a4; DoublePipes[4] = b4;
				DirectPipes[5] = a5; DoublePipes[5] = b5;
				DirectPipes[6] = a6; DoublePipes[6] = b6;
				DirectPipes[7] = a7; DoublePipes[7] = b7;
				DirectPipes[8] = a8; DoublePipes[8] = b8;
				DirectPipes[9] = a9; DoublePipes[9] = b9;
				DirectPipes[10] = a10; DoublePipes[10] = b10;
				DirectPipes[11] = a11; DoublePipes[11] = b11;
				DirectPipes[12] = a12; DoublePipes[12] = b12;
				CrossPipes[0] = c0; CrossPipes[1] = c1;
				Water a(20,SCREEN_HEIGHT-50,40,40);
}
コード例 #15
0
void test_rw_aggr_buf()
{
    BuffAggr b3(6, false);
    uint32_t off = 0;
    for ( uint32_t i=1; i<3; i++) {
        uint8_t *buf = create_buf(i+4);
        b3.set_buf(buf, off, i+4);
        off += i+4;
    }
    b3.print();
    uint8_t *buf = create_buf(2);
    b3.set_buf(buf, 2, 2);
    b3.print();
}
コード例 #16
0
ファイル: omnirobot.cpp プロジェクト: Rauf-Kurbanov/omni-ctrl
void OmniRobot::init()
{
    period = 200;
    xw = 75.0; //mm
    yw = 75.0; //mm
    Dw = 50.0; //mm

    vector<float> u1 (2); u1(0) =  c1; u1(1) =  c1;
    vector<float> u2 (2); u2(0) =  c1; u2(1) = -c1;
    vector<float> u3 (2); u3(0) =  c1; u3(1) =  c1;
    vector<float> u4 (2); u4(0) =  c1; u4(1) = -c1;

    vector<float> n1 (2); n1(0) =  c1; n1(1) = -c1;
    vector<float> n2 (2); n2(0) = -c1; n2(1) = -c1;
    vector<float> n3 (2); n3(0) =  c1; n3(1) = -c1;
    vector<float> n4 (2); n4(0) = -c1; n4(1) = -c1;

    vector<float> b1 (2); b1(0) =  xw; b1(1) =  yw;
    vector<float> b2 (2); b2(0) =  xw; b2(1) = -yw;
    vector<float> b3 (2); b3(0) = -xw; b3(1) = -yw;
    vector<float> b4 (2); b4(0) = -xw; b4(1) =  yw;

    Mt(0,0) = n1(0); Mt(0,1) = n1(1); Mt(0,2) = b1(0)*u1(0) + b1(1)*u1(1);
    Mt(1,0) = n2(0); Mt(1,1) = n2(1); Mt(1,2) = b2(0)*u2(0) + b2(1)*u2(1);
    Mt(2,0) = n3(0); Mt(2,1) = n3(1); Mt(2,2) = b3(0)*u3(0) + b3(1)*u3(1);
    Mt(3,0) = n4(0); Mt(3,1) = n3(1); Mt(3,2) = b4(0)*u4(0) + b4(1)*u4(1);

    Mt = -1 * Mt;

    cmd(0) = 0.0; cmd(1) = 0.0; cmd(2) = 0.0;
    pwm(0) = 0.0; pwm(1) = 0.0; pwm(2) = 0.0; pwm(3) = 0.0;

    omniState = INIT_MODE;
    movementMode = ROTATE_MODE;
    power = 20;
    pplus = 1;
}
コード例 #17
0
ファイル: 2fish.c プロジェクト: pktmonky/SLAE
/* the Zero-keyed h function (used by the key setup routine) */
u32 h(u32 X, u32 L[4], int k)
{
    BYTE y0, y1, y2, y3;
    BYTE z0, z1, z2, z3;
    y0 = b0(X);
    y1 = b1(X);
    y2 = b2(X);
    y3 = b3(X);

    switch(k)
    {
	case 4:
	    y0 = Q1[y0] ^ b0(L[3]);
	    y1 = Q0[y1] ^ b1(L[3]);
	    y2 = Q0[y2] ^ b2(L[3]);
	    y3 = Q1[y3] ^ b3(L[3]);
	case 3:
	    y0 = Q1[y0] ^ b0(L[2]);
	    y1 = Q1[y1] ^ b1(L[2]);
	    y2 = Q0[y2] ^ b2(L[2]);
	    y3 = Q0[y3] ^ b3(L[2]);
	case 2:
	    y0 = Q1[  Q0 [ Q0[y0] ^ b0(L[1]) ] ^ b0(L[0]) ];
	    y1 = Q0[  Q0 [ Q1[y1] ^ b1(L[1]) ] ^ b1(L[0]) ];
	    y2 = Q1[  Q1 [ Q0[y2] ^ b2(L[1]) ] ^ b2(L[0]) ];
	    y3 = Q0[  Q1 [ Q1[y3] ^ b3(L[1]) ] ^ b3(L[0]) ];
    }

    /* inline the MDS matrix multiply */
    z0 = multEF[y0] ^ y1 ^         multEF[y2] ^ mult5B[y3]; 
    z1 = multEF[y0] ^ mult5B[y1] ^ y2 ^         multEF[y3]; 
    z2 = mult5B[y0] ^ multEF[y1] ^ multEF[y2] ^ y3; 
    z3 = y0 ^         multEF[y1] ^ mult5B[y2] ^ mult5B[y3]; 

    return BYTES_TO_U32(z0, z1, z2, z3);
}
コード例 #18
0
ファイル: TMV_TestSymDiv_E2.cpp プロジェクト: rmjarvis/tmv
void TestSymDiv_E2(tmv::DivType dt, PosDefCode pdc)
{
    const int N = 10;

    std::vector<tmv::SymMatrixView<T> > s;
    std::vector<tmv::SymMatrixView<std::complex<T> > > cs;
    MakeSymList(s,cs,pdc);

    tmv::Matrix<T> a1(N,N);
    for (int i=0; i<N; ++i) for (int j=0; j<N; ++j) a1(i,j) = T(1-3*i+j);
    a1.diag().addToAll(T(10)*N);
    a1 /= T(10);
    tmv::Matrix<std::complex<T> > ca1 = a1 * std::complex<T>(3,-4);

    tmv::BandMatrix<T> b1(a1,1,3);
    tmv::BandMatrix<std::complex<T> > cb1(ca1,1,3);

    tmv::BandMatrix<T> b1v = b1.view();
    tmv::BandMatrix<std::complex<T> > cb1v = cb1.view();

#if (XTEST & 2)
    tmv::BandMatrix<T> b3(a1.colRange(0,N-2),1,3);
    tmv::BandMatrix<std::complex<T> > cb3(ca1.colRange(0,N-2),1,3);
    tmv::BandMatrix<T> b4(a1.rowRange(0,N-2),1,3);
    tmv::BandMatrix<std::complex<T> > cb4(ca1.rowRange(0,N-2),1,3);

    tmv::BandMatrix<T> b3v = b3.view();
    tmv::BandMatrix<std::complex<T> > cb3v = cb3.view();
    tmv::BandMatrix<T> b4v = b4.view();
    tmv::BandMatrix<std::complex<T> > cb4v = cb4.view();
#endif

    for(size_t i=START;i<s.size();i++) {
        if (showstartdone)
            std::cout<<"Start loop: i = "<<i<<", si = "<<tmv::TMV_Text(s[i])<<
                "  "<<s[i]<<std::endl;
        tmv::SymMatrixView<T> si = s[i];
        tmv::SymMatrixView<std::complex<T> > csi = cs[i];

        TestMatrixDivArith1(dt,b1v,si,cb1v,csi,"Sym/SquareBandMatrix");
        if (dt == tmv::LU) continue;
#if (XTEST & 2)
        TestMatrixDivArith1(dt,b3v,si,cb3v,csi,"Sym/NonSquareBandMatrix");
        TestMatrixDivArith1(dt,b4v,si,cb4v,csi,"Sym/NonSquareBandMatrix");
#endif
    }
}
コード例 #19
0
ファイル: main.cpp プロジェクト: jeremy-prater/OSU
int main()
{
  Book b1("123", "War and Peace", "Tolstoy");
  Book b2("234", "Moby Dick", "Melville");
  Book b3("345", "Phantom Tollbooth", "Juster");
  Patron p1("abc", "Felicity");
  Patron p2("bcd", "Waldo");
  Patron p3("123", "Jeremy");
  Library lib;
  lib.addBook(&b1);
  lib.addBook(&b2);
  lib.addBook(&b3);
  lib.addPatron(&p1);
  lib.addPatron(&p2);
  lib.addPatron(&p3);
  std::cout << lib.checkOutBook("bcd", "234") << std::endl;
  for (int i=0; i<7; i++)
     lib.incrementCurrentDate();
  std::cout << lib.checkOutBook("bcd", "123") << std::endl;
  std::cout << lib.checkOutBook("abc", "345") << std::endl;
  for (int i=0; i<24; i++)
     lib.incrementCurrentDate();
  std::cout << lib.payFine("bcd", 0.4) << std::endl;
  double p1Fine = p1.getFineAmount();
  double p2Fine = p2.getFineAmount();
  std::cout << "p1 fine: " << p1Fine << std::endl;
  std::cout << "p2 fine: " << p2Fine << std::endl;

  std::cout << "request: " << lib.requestBook ("123", "123") << std::endl;
  std::cout << "request: " << lib.requestBook ("12b", "123") << std::endl;
  std::cout << "request: " << lib.requestBook ("abc", "123") << std::endl;

  for (int i=0; i<10; i++)
     lib.incrementCurrentDate();

  std::cout << "return book: " << lib.returnBook ("123") << std::endl;
  std::cout << lib.payFine("bcd", 1.0) << std::endl;
  p1Fine = p1.getFineAmount();
  p2Fine = p2.getFineAmount();
  std::cout << "p1 fine: " << p1Fine << std::endl;
  std::cout << "p2 fine: " << p2Fine << std::endl;

  std::cout << "checkout book: " << lib.checkOutBook("123", "345") << std::endl;
  std::cout << "checkout book: " << lib.checkOutBook("123", "123") << std::endl;
  return 0;
}
コード例 #20
0
ファイル: timecontrols.cpp プロジェクト: biosdaddy/pencil
void TimeControls::initUI()
{
    auto playback = mEditor->playback();
    
    SignalBlocker b( mLoopStartSpinBox );
    mLoopStartSpinBox->setValue( playback->markInFrame() );
    
    SignalBlocker b2( mLoopEndSpinBox );
    mLoopEndSpinBox->setValue( playback->markOutFrame() );
    
    mPlaybackRangeCheckBox->setChecked( false );
    mLoopStartSpinBox->setEnabled( false );
    mLoopEndSpinBox->setEnabled( false );
    
    SignalBlocker b3( mFpsBox );
    mFpsBox->setValue( playback->fps() );
}
コード例 #21
0
ファイル: bubble_test.cpp プロジェクト: Strubbl/bebetuso
TEST(Bubbles, PrintStatus)
{
  bbs::Bubble b1(1, 1, bbs::colors_t::NONE);
  EXPECT_EQ(b1.getPrintableStatus(), "N");

  bbs::Bubble b2(1, 1, bbs::colors_t::RED);
  EXPECT_EQ(b2.getPrintableStatus(), "R");

  bbs::Bubble b3(1, 1, bbs::colors_t::GREEN);
  EXPECT_EQ(b3.getPrintableStatus(), "G");

  bbs::Bubble b4(1, 1, bbs::colors_t::YELLOW);
  EXPECT_EQ(b4.getPrintableStatus(), "Y");

  bbs::Bubble b5(1, 1, bbs::colors_t::BLUE);
  EXPECT_EQ(b5.getPrintableStatus(), "B");
}
コード例 #22
0
ファイル: bubble_test.cpp プロジェクト: Strubbl/bebetuso
TEST(BubbleInitializing, Colors)
{
  bbs::Bubble b1(1, 1, bbs::colors_t::NONE);
  EXPECT_EQ(b1.getStatus(), bbs::colors_t::NONE);

  bbs::Bubble b2(1, 1, bbs::colors_t::RED);
  EXPECT_EQ(b2.getStatus(), bbs::colors_t::RED);

  bbs::Bubble b3(1, 1, bbs::colors_t::GREEN);
  EXPECT_EQ(b3.getStatus(), bbs::colors_t::GREEN);

  bbs::Bubble b4(1, 1, bbs::colors_t::YELLOW);
  EXPECT_EQ(b4.getStatus(), bbs::colors_t::YELLOW);

  bbs::Bubble b5(1, 1, bbs::colors_t::BLUE);
  EXPECT_EQ(b5.getStatus(), bbs::colors_t::BLUE);
}
コード例 #23
0
ファイル: drawdemo.cpp プロジェクト: opieproject/qte-opie
void drawShapes( QPainter *p )
{
    QBrush b1( Qt::blue );
    QBrush b2( Qt::green, Qt::Dense6Pattern );		// green 12% fill
    QBrush b3( Qt::NoBrush );				// void brush
    QBrush b4( Qt::CrossPattern );			// black cross pattern

    p->setPen( Qt::red );
    p->setBrush( b1 );
    p->drawRect( 10, 10, 200, 100 );
    p->setBrush( b2 );
    p->drawRoundRect( 10, 150, 200, 100, 20, 20 );
    p->setBrush( b3 );
    p->drawEllipse( 250, 10, 200, 100 );
    p->setBrush( b4 );
    p->drawPie( 250, 150, 200, 100, 45*16, 90*16 );
}
コード例 #24
0
int main()
{
	Big b0("b0");

	Big b1(b0);
	b1.setName("b1");
	std::cout << std::endl << "现在b1:" << std::endl;
	print(b1);

	Big b2(std::move(makeBig(1, 2, "临时b2") + 4));
	b2.setName("b2");
	std::cout << std::endl << "现在b2:" << std::endl;
	print(b2);

	Big b3("b3");
	b3 = b0;
	b3.setName("变量b3=b0");
	std::cout << std::endl << "现在b3:" << std::endl;
	print(b3);

	Big b4("b4");
	b4 = b0 + 8;
	b4.setName("变量b4=b0+8");
	std::cout << std::endl << "现在b4:" << std::endl;
	print(b4);

	std::cout << "-----------------------" << std::endl;

	std::vector<Big> *v = new std::vector<Big>;
	v->push_back(b0 + 16);
	std::cout << "1st push_back" << std::endl;

	v->push_back(makeBig(32, 64, "临时b5"));
	std::cout << "2nd push_back" << std::endl;

	v->push_back(makeBig(128, 256, "临时b6") + 512);
	std::cout << "3rd push_back" << std::endl;

	std::cout << std::endl << "释放vector<Big>内所有的资源:" << std::endl;
	delete v;

	std::cout << "-----------------------" << std::endl;
	
	std::cout << "程序到达终点,操作系统释放剩余的资源!" << std::endl;
	return 0;
}//main
コード例 #25
0
ファイル: main.cpp プロジェクト: dutow/elte-cpp-examples
int main(int argc, char** argv)
{
    bimap<int, char> bm;

    bm.insertOrKeep(5, 'c');
    bm.insertOrKeep(3, 'b');

    bm.insertOrKeep(5, 'd');
    bm.insertOrReplace(4, 'b');

    std::cout << bm[4] << std::endl;
    std::cout << bm('b') << std::endl;

    try {
        std::cout << bm('f') << std::endl;
    } catch(...) {

    }

    // for(bimap::iterator it = bm.begin(); it != bm.end(); ++it) {
    for(auto const& p: bm)
    {
        std::cout << "<" << p.first << ", " << p.second << ">" << std::endl;
    }

    std::unordered_map<int, char> m;
    m[5] = 'c';
    m[4] = 'b';
    m[2] = 'c';

    bimap<int, char> b2(m.begin(), m.end());

    for(auto const& p: b2)
    {
        std::cout << "<" << p.first << ", " << p.second << ">" << std::endl;
    }

    std::vector<std::pair<int, char>> v;
    v.push_back(std::pair<int,char>(3, 'a'));
    v.push_back(std::pair<int,char>(5, 'c'));
    v.push_back(std::pair<int,char>(9, 'b'));

    bimap<int, char> b3(v.begin(), v.end());

    return 0;
}
コード例 #26
0
void drawShapes( QPainter *p )
{
    QBrush b1( blue );				// solid blue brush
    QBrush b2( green, Dense6Pattern );		// green 12% fill
    QBrush b3( NoBrush );			// void brush
    QBrush b4( CrossPattern );			// black cross pattern

    p->setPen( red );
    p->setBrush( b1 );
    p->drawRect( 10, 10, 200, 100 );		// draw some shapes
    p->setBrush( b2 );
    p->drawRoundRect( 10, 150, 200, 100, 20, 20 );
    p->setBrush( b3 );
    p->drawEllipse( 250, 10, 200, 100 );
    p->setBrush( b4 );
    p->drawPie( 250, 150, 200, 100, 45*16, 90*16 );
}
コード例 #27
0
void test_single_dest() {

   // push only
   tbb::flow::graph g;
   tbb::flow::source_node<T> src(g, source_body<T>() );
   test_push_receiver<T> dest;
   tbb::flow::make_edge( src, dest );
   g.wait_for_all();
   for (int i = 0; i < N; ++i ) {
       ASSERT( dest.get_count(i) == 1, NULL ); 
   }

   // push only
   tbb::atomic<int> counters3[N];
   tbb::flow::source_node<T> src3(g, source_body<T>() );
   function_body<T> b3( counters3 );
   tbb::flow::function_node<T,bool> dest3(g, tbb::flow::unlimited, b3 );
   tbb::flow::make_edge( src3, dest3 );
   g.wait_for_all();
   for (int i = 0; i < N; ++i ) {
       int v = counters3[i];
       ASSERT( v == 1, NULL ); 
   }

   // push & pull 
   tbb::flow::source_node<T> src2(g, source_body<T>() );
   tbb::atomic<int> counters2[N];
   function_body<T> b2( counters2 );
   tbb::flow::function_node<T,bool> dest2(g, tbb::flow::serial, b2 );
   tbb::flow::make_edge( src2, dest2 );
   g.wait_for_all();
   for (int i = 0; i < N; ++i ) {
       int v = counters2[i];
       ASSERT( v == 1, NULL ); 
   }

   // test copy constructor
   tbb::flow::source_node<T> src_copy(src);
   test_push_receiver<T> dest_c;
   ASSERT( src_copy.register_successor(dest_c), NULL );
   g.wait_for_all();
   for (int i = 0; i < N; ++i ) {
       ASSERT( dest_c.get_count(i) == 1, NULL ); 
   }
}
コード例 #28
0
ファイル: box_test.cpp プロジェクト: tdunn19/PolySim
TEST(BoxTest, Construction) {
  Box b1;
  Box b2(2.10, 0.14, 9.6);
  Vector3D v3(0.4, 3.21, 1.5);
  Box b3(v3);

  EXPECT_DOUBLE_EQ(b1.length.y, 0.0);
  EXPECT_DOUBLE_EQ(b2.length.x, 2.10);
  EXPECT_DOUBLE_EQ(b3.length.z, 1.5);

  EXPECT_DOUBLE_EQ(b1.half_length.x, 0.0);
  EXPECT_DOUBLE_EQ(b2.half_length.z, 4.8);
  EXPECT_DOUBLE_EQ(b3.half_length.x, 0.2);

  EXPECT_DOUBLE_EQ(b1.volume, 0.0);
  EXPECT_DOUBLE_EQ(b2.volume, 2.8224);
  EXPECT_DOUBLE_EQ(b3.volume, 1.926);
}
コード例 #29
0
void ClientConnection::RestoreArea(RECT &r)
{
	int x = r.left;
	int y = r.top;
	int w = r.right - r.left;
	int h = r.bottom - r.top;
	HBITMAP m_hTempBitmap=NULL;
	HDC		m_hTempBitmapDC=NULL;

	boost::recursive_mutex::scoped_lock l(m_bitmapdcMutex);

	ObjectSelector b1(m_hBitmapDC, m_hBitmap);
	PaletteSelector ps1(m_hBitmapDC, m_hPalette);
	m_hTempBitmapDC = CreateCompatibleDC(m_hBitmapDC);
	m_hTempBitmap = CreateCompatibleBitmap(m_hBitmapDC, w, h);
	ObjectSelector b3(m_hTempBitmapDC, m_hTempBitmap);
	PaletteSelector ps3(m_hTempBitmapDC, m_hPalette);
	ObjectSelector b2(m_hCacheBitmapDC, m_hCacheBitmap);
	PaletteSelector ps2(m_hCacheBitmapDC, m_hPalette);

	if (!BitBlt(m_hTempBitmapDC, 0, 0, w, h, m_hBitmapDC, x, y, SRCCOPY)) 
	{
		//vnclog.Print(0, _T("Error saving temp bitmap\n"));
		Log.WinError(_ERROR_, "Error saving temp bitmap");
	}

	if (!BitBlt(m_hBitmapDC, x, y, w, h, m_hCacheBitmapDC, x, y, SRCCOPY)) 
	{
		//vnclog.Print(0, _T("Error restoring screen\n"));
		Log.WinError(_ERROR_, "Error restoring screen");
	}

	if (!BitBlt(m_hCacheBitmapDC, x, y, w, h, m_hTempBitmapDC, 0, 0, SRCCOPY)) 
	{
		//vnclog.Print(0, _T("Error restoring screen under cursor\n"));
		Log.WinError(_ERROR_, "Error restoring screen under cursor");
	}

	DeleteDC(m_hTempBitmapDC);
	if (m_hTempBitmap != NULL)
		DeleteObject(m_hTempBitmap);
	if (m_hCacheBitmapDC != NULL)
		DeleteObject(m_hTempBitmapDC);
}
コード例 #30
0
ファイル: b_0_49.cpp プロジェクト: jakexie/micmac
template <class Type> void bench_pack_im(Type *,INT vmax,bool quick)
{

	for (INT x=10; x< (quick ? 300 : 1200); x+= 220)
	{
cout << x << "\n";
		Bench_PackB_IM<Type>  b1(Pt2di(x,x),0);
		Bench_PackB_IM<Type>  b0(Pt2di(x,x),FX%vmax);
		Bench_PackB_IM<Type>  b2(Pt2di(x,x),(FX>FY)*vmax);
		Bench_PackB_IM<Type>  b3(Pt2di(x,x),frandr()<0.1);
		Bench_PackB_IM<Type>  b4(Pt2di(x,x),frandr()<(1/128.0));

                b0.DoNothing();
                b1.DoNothing();
                b2.DoNothing();
                b3.DoNothing();
                b4.DoNothing();
	}
}