void test_g0() { int array0[5]; B<int, 5> b0 = g0(array0); const int array1[] = { 1, 2, 3}; B<const int, 3> b1 = g0(array1); B<int, 3> b2 = g0b(array1); }
void bob::ip::base::TanTriggs::computeDoG(double sigma0, double sigma1, size_t size) { // Generates two Gaussians with the given standard deviations // Warning: size should be odd blitz::Array<double,2> g0(size,size); blitz::Array<double,2> g1(size,size); const double inv_sigma0_2 = 0.5 / (sigma0*sigma0); const double inv_sigma1_2 = 0.5 / (sigma1*sigma1); int center = ((int)size) / 2; for(int y=0; y<(int)size; ++y) for(int x=0; x<(int)size; ++x) { int yy = y - center; int xx = x - center; int xx2 = xx*xx; int yy2 = yy*yy; g0(y,x) = exp( - inv_sigma0_2 * (xx2 + yy2) ); g1(y,x) = exp( - inv_sigma1_2 * (xx2 + yy2) ); } // Normalize the kernels such that the sum over the area is equal to 1 // and compute the Difference of Gaussian filter const double inv_sum0 = 1. / blitz::sum(g0); const double inv_sum1 = 1. / blitz::sum(g1); m_kernel.resize( size, size); m_kernel = inv_sum0 * g0 - inv_sum1 * g1; }
int main(int argc, char** argv) { if (argc < 3) { std::cout << "Usage: combustion-vineyard FRAME1 FRAME2" << std::endl; exit(0); } int size0, nc0; int size1, nc1; std::cout << "Reading: " << argv[1] << std::endl; std::ifstream ifs0(argv[1], std::ios::binary); std::cout << "Reading: " << argv[2] << std::endl; std::ifstream ifs1(argv[2], std::ios::binary); if (!ifs0 || !ifs1) { std::cout << "Could not open the frames" << std::endl; exit(0); } read(ifs0, size0); read(ifs0, nc0); read(ifs1, size1); read(ifs1, nc1); assert(size0 == size1); assert(nc0 == nc1); assert(size0 == xsize*ysize); Grid2D g0(xsize, ysize), g1(xsize, ysize); for (int y = 0; y < ysize; ++y) for (int x = 0; x < xsize; ++x) for (int d = 0; d < nc0; ++d) { float val0, val1; read(ifs0, val0); read(ifs1, val1); if (d == var) { g0(x,y) = val0; g1(x,y) = val1; } } std::cout << "Grids read" << std::endl; // Generate filtration and compute pairing Grid2DVineyard v(&g0); std::cout << "Filtration generated, size: " << v.filtration()->size() << std::endl; v.compute_pairing(); std::cout << "Pairing computed" << std::endl; // Compute vineyard v.compute_vineyard(&g1, true); std::cout << "Vineyard computed" << std::endl; v.vineyard()->save_edges("combustion"); }
void generate(int dim, char* filename) { #if (!defined MPI_VERSION || MPI_VERSION<2) && (defined BGQ) std::cerr<<"Error: MPI-2 is required for CCNI."<<std::endl; exit(1); #endif static unsigned long tstart; int rank=0; #ifdef MPI_VERSION rank = MPI::COMM_WORLD.Get_rank(); int np = MPI::COMM_WORLD.Get_size(); #endif #ifdef DEBUG if (rank==0) { if (!isLittleEndian()) std::cout<<"Byte order is big-endian."<<std::endl; } #endif if (dim == 2) { const int edge = 8192; int number_of_fields = 5120000; grid<2,sparse<phi_type> > initGrid(0, 0, edge, 0, edge); if (rank==0) std::cout<<"Grid origin: ("<<g0(initGrid,0)<<','<<g0(initGrid,1)<<")," <<" dimensions: "<<g1(initGrid,0)-g0(initGrid,0)<<" × "<<g1(initGrid,1)-g0(initGrid,1) <<" with "<<number_of_fields<<" seeds"<<std::flush; #ifdef MPI_VERSION number_of_fields /= np; if (rank==0) std::cout<<", "<<number_of_fields<<" per rank"<<std::flush; if (rank==0 && number_of_fields % np != 0) std::cerr<<"\nWarning: Tessellation may hang with uneven distribution of seeds per thread."<<std::endl; #endif if (rank==0) std::cout<<"."<<std::endl; #if (!defined MPI_VERSION) && (defined BGQ) std::cerr<<"Error: Blue Gene requires MPI."<<std::endl; std::exit(-1); #endif tstart = time(NULL); tessellate<2,phi_type>(initGrid, number_of_fields); if (rank==0) std::cout<<"Tessellation complete ("<<time(NULL)-tstart<<" sec)."<<std::endl; #ifdef MPI_VERSION MPI::COMM_WORLD.Barrier(); #endif tstart=time(NULL); output(initGrid, filename); if (rank==0) std::cout<<"Voronoi tessellation written to "<<filename<<" ("<<time(NULL)-tstart<<" sec)."<<std::endl; } }
bool sanity() { GameState g0(5, 7, 7); // Not a valid game state GameState g1(1, 2, 254); // Finish in 1 round GameState g2(2, 3, 254); // ... in 2 rounds GameState g3(3, 4, 254); // ... in 3 rounds GameState g4(4, 5, 254); // GameState g5(4, 9, 254); // These come from a (slower) python implementation GameState g6(8, 11, 254); GameState g7(12, 19, 254); GameState g8(8, 35, 254); GameState g9(1, 4, 6); // From webpage, known to finish in 15 minutes = at round 2 if (explore_game(g0)!=0) return false; // Verify that we get the expected number if (explore_game(g1)!=1) return false; // of rounds for given input states if (explore_game(g2)!=2) return false; // if (explore_game(g3)!=3) return false; // report an error if not if (explore_game(g4)!=4) return false; if (explore_game(g5)!=5) return false; if (explore_game(g6)!=6) return false; if (explore_game(g7)!=7) return false; if (explore_game(g8)!=8) return false; if (explore_game(g9)!=2) return false; return true; }
void object::test<3>() { GeomPtr g0(wktreader.read("LINESTRING(0 0, 10 0)")); GeomPtr g1(wktreader.read("LINESTRING(20 0, 20 0)")); forwDir.clear(); backDir.clear(); SharedPathsOp::sharedPathsOp(*g0, *g1, forwDir, backDir); ensure(forwDir.empty()); ensure(backDir.empty()); }
int main( void ) { g0(); g1(); g2(); g3(); g4(); return 0; }
__complex__ double xcexp (__complex__ double x) { double r; r = g0 (__real__ x); __real__ x = r * g1 (__imag__ x); __imag__ x = r * g2 (__imag__ x); return x; }
int main1(void) { int i; /* Check vec_extract with a non constant element numbering */ for(i=0;i<10;i++) { if (f(a, i) != (i&0x3)) abort (); } /* Check vec_extract with a constant element numbering */ if (f0(a) != 0) abort (); if (f1(a) != 1) abort (); if (f2(a) != 2) abort (); if (f3(a) != 3) abort (); /* Check that vec_extract works with a constant element higher than the number of elements. */ if (f4(a) != 0) abort (); /* Check vec_extract with a non constant element numbering */ for(i=0;i<10;i++) { if (g(b, i) != (i&0x7)) abort (); } /* Check vec_extract with a constant element numbering */ if (g0(b) != 0) abort (); if (g1(b) != 1) abort (); if (g2(b) != 2) abort (); if (g3(b) != 3) abort (); if (g4(b) != 4) abort (); if (g5(b) != 5) abort (); if (g6(b) != 6) abort (); if (g7(b) != 7) abort (); /* Check that vec_extract works with a constant element higher than the number of elements. */ if (g8(b) != 0) abort (); return 0; }
void object::test<9>() { GeomPtr g0(wktreader.read("LINESTRING(-15 0, 15 0)")); GeomPtr g1(wktreader.read("LINESTRING(10 0, -10 0)")); forwDir.clear(); backDir.clear(); SharedPathsOp::sharedPathsOp(*g0, *g1, forwDir, backDir); ensure(forwDir.empty()); ensure_equals(backDir.size(), 1u); ensure_equals(wktwriter.write(backDir[0]), "LINESTRING (-10 0, 10 0)"); SharedPathsOp::clearEdges(backDir); }
void test() { f0(0, 0); g0(0, 0); f1(0, 0); // RUN: %clang_cc1 -std=c89 -fsyntax-only -code-completion-at=%s:6:6 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s // CHECK-CC1: f0(<#float x#>, float y) // RUN: %clang_cc1 -std=c89 -fsyntax-only -code-completion-at=%s:6:9 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s // CHECK-CC2: f0(float x, <#float y#>) // RUN: %clang_cc1 -std=c89 -fsyntax-only -code-completion-at=%s:8:6 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s // CHECK-CC3: f1() }
void object::test<2>() { GeomPtr g0(wktreader.read("POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))")); GeomPtr g1(wktreader.read("LINESTRING(0 0, 10 0)")); bool threw = false; try { SharedPathsOp::sharedPathsOp(*g0, *g1, forwDir, backDir); } catch (const geos::util::IllegalArgumentException& /*ex*/) { threw = true; } ensure(threw); }
void f0(void) { result = 1; bool_mul(bool_id(1)); aggr_mul(aggr_id((AggrTy) { 2, 3, 5})); empty_mul(empty_id((EmptyTy) {})); scalar_mul(scalar_id(7)); complex_mul(complex_id(11 + 13i)); // This call should be eliminated. if (result != 2 * 3 * 5 * 7 * 11 * 13 * 53) g0(); }
/** * Encrypt a single block of data. */ void skipjack_encrypt(byte tab[10][256], byte in[8], byte out[8]) { word32 w1, w2, w3, w4; w1 = (in[0] << 8) + in[1]; w2 = (in[2] << 8) + in[3]; w3 = (in[4] << 8) + in[5]; w4 = (in[6] << 8) + in[7]; /* stepping rule A: */ g0(tab, w1); w4 ^= w1 ^ 1; g1(tab, w4); w3 ^= w4 ^ 2; g2(tab, w3); w2 ^= w3 ^ 3; g3(tab, w2); w1 ^= w2 ^ 4; g4(tab, w1); w4 ^= w1 ^ 5; g0(tab, w4); w3 ^= w4 ^ 6; g1(tab, w3); w2 ^= w3 ^ 7; g2(tab, w2); w1 ^= w2 ^ 8; /* stepping rule B: */ w2 ^= w1 ^ 9; g3(tab, w1); w1 ^= w4 ^ 10; g4(tab, w4); w4 ^= w3 ^ 11; g0(tab, w3); w3 ^= w2 ^ 12; g1(tab, w2); w2 ^= w1 ^ 13; g2(tab, w1); w1 ^= w4 ^ 14; g3(tab, w4); w4 ^= w3 ^ 15; g4(tab, w3); w3 ^= w2 ^ 16; g0(tab, w2); /* stepping rule A: */ g1(tab, w1); w4 ^= w1 ^ 17; g2(tab, w4); w3 ^= w4 ^ 18; g3(tab, w3); w2 ^= w3 ^ 19; g4(tab, w2); w1 ^= w2 ^ 20; g0(tab, w1); w4 ^= w1 ^ 21; g1(tab, w4); w3 ^= w4 ^ 22; g2(tab, w3); w2 ^= w3 ^ 23; g3(tab, w2); w1 ^= w2 ^ 24; /* stepping rule B: */ w2 ^= w1 ^ 25; g4(tab, w1); w1 ^= w4 ^ 26; g0(tab, w4); w4 ^= w3 ^ 27; g1(tab, w3); w3 ^= w2 ^ 28; g2(tab, w2); w2 ^= w1 ^ 29; g3(tab, w1); w1 ^= w4 ^ 30; g4(tab, w4); w4 ^= w3 ^ 31; g0(tab, w3); w3 ^= w2 ^ 32; g1(tab, w2); out[0] = (byte)(w1 >> 8); out[1] = (byte)w1; out[2] = (byte)(w2 >> 8); out[3] = (byte)w2; out[4] = (byte)(w3 >> 8); out[5] = (byte)w3; out[6] = (byte)(w4 >> 8); out[7] = (byte)w4; }
void object::test<15>() { GeomPtr g0(wktreader.read("MULTILINESTRING((-10 0, -5 0),(10 0, 5 0))")); GeomPtr g1(wktreader.read("MULTILINESTRING((6 0, 12 0),(-2 0, -8 0))")); forwDir.clear(); backDir.clear(); SharedPathsOp::sharedPathsOp(*g0, *g1, forwDir, backDir); ensure_equals(backDir.size(), 2u); ensure_equals(wktwriter.write(backDir[0]), "LINESTRING (-8 0, -5 0)"); ensure_equals(wktwriter.write(backDir[1]), "LINESTRING (10 0, 6 0)"); SharedPathsOp::clearEdges(backDir); ensure(forwDir.empty()); }
void SurfaceBasis<EvalT, Traits>::computeDualBaseVectors( const MFC & midplaneCoords, const PHX::MDField<MeshScalarT, Cell, QuadPoint, Dim, Dim> basis, PHX::MDField<MeshScalarT, Cell, QuadPoint, Dim> normal, PHX::MDField<MeshScalarT, Cell, QuadPoint, Dim, Dim> dualBasis) { std::size_t worksetSize = midplaneCoords.dimension(0); Intrepid::Vector<MeshScalarT> g_0(0, 0, 0), g_1(0, 0, 0), g_2(0, 0, 0), g0(0, 0, 0), g1(0, 0, 0), g2(0, 0, 0); for (std::size_t cell(0); cell < worksetSize; ++cell) { for (std::size_t pt(0); pt < numQPs; ++pt) { g_0 = Intrepid::Vector<MeshScalarT>(3, &basis(cell, pt, 0, 0)); g_1 = Intrepid::Vector<MeshScalarT>(3, &basis(cell, pt, 1, 0)); g_2 = Intrepid::Vector<MeshScalarT>(3, &basis(cell, pt, 2, 0)); normal(cell, pt, 0) = g_2(0); normal(cell, pt, 1) = g_2(1); normal(cell, pt, 2) = g_2(2); g0 = cross(g_1, g_2) / dot(g_0, cross(g_1, g_2)); g1 = cross(g_0, g_2) / dot(g_1, cross(g_0, g_2)); g2 = cross(g_0, g_1) / dot(g_2, cross(g_0, g_1)); dualBasis(cell, pt, 0, 0) = g0(0); dualBasis(cell, pt, 0, 1) = g0(1); dualBasis(cell, pt, 0, 2) = g0(2); dualBasis(cell, pt, 1, 0) = g1(0); dualBasis(cell, pt, 1, 1) = g1(1); dualBasis(cell, pt, 1, 2) = g1(2); dualBasis(cell, pt, 2, 0) = g2(0); dualBasis(cell, pt, 2, 1) = g2(1); dualBasis(cell, pt, 2, 2) = g2(2); } } }
geom::Geometry* CascadedPolygonUnion::binaryUnion(GeometryListHolder* geoms, std::size_t start, std::size_t end) { if (end - start <= 1) { return unionSafe(geoms->getGeometry(start), NULL); } else if (end - start == 2) { return unionSafe(geoms->getGeometry(start), geoms->getGeometry(start + 1)); } else { // recurse on both halves of the list std::size_t mid = (end + start) / 2; std::auto_ptr<geom::Geometry> g0 (binaryUnion(geoms, start, mid)); std::auto_ptr<geom::Geometry> g1 (binaryUnion(geoms, mid, end)); return unionSafe(g0.get(), g1.get()); } }
/** * Encrypt a single block of data. */ void SKIPJACK::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const { word w1, w2, w3, w4; Block::Get(inBlock)(w4)(w3)(w2)(w1); /* stepping rule A: */ g0(tab, w1); w4 ^= w1 ^ 1; g1(tab, w4); w3 ^= w4 ^ 2; g2(tab, w3); w2 ^= w3 ^ 3; g3(tab, w2); w1 ^= w2 ^ 4; g4(tab, w1); w4 ^= w1 ^ 5; g0(tab, w4); w3 ^= w4 ^ 6; g1(tab, w3); w2 ^= w3 ^ 7; g2(tab, w2); w1 ^= w2 ^ 8; /* stepping rule B: */ w2 ^= w1 ^ 9; g3(tab, w1); w1 ^= w4 ^ 10; g4(tab, w4); w4 ^= w3 ^ 11; g0(tab, w3); w3 ^= w2 ^ 12; g1(tab, w2); w2 ^= w1 ^ 13; g2(tab, w1); w1 ^= w4 ^ 14; g3(tab, w4); w4 ^= w3 ^ 15; g4(tab, w3); w3 ^= w2 ^ 16; g0(tab, w2); /* stepping rule A: */ g1(tab, w1); w4 ^= w1 ^ 17; g2(tab, w4); w3 ^= w4 ^ 18; g3(tab, w3); w2 ^= w3 ^ 19; g4(tab, w2); w1 ^= w2 ^ 20; g0(tab, w1); w4 ^= w1 ^ 21; g1(tab, w4); w3 ^= w4 ^ 22; g2(tab, w3); w2 ^= w3 ^ 23; g3(tab, w2); w1 ^= w2 ^ 24; /* stepping rule B: */ w2 ^= w1 ^ 25; g4(tab, w1); w1 ^= w4 ^ 26; g0(tab, w4); w4 ^= w3 ^ 27; g1(tab, w3); w3 ^= w2 ^ 28; g2(tab, w2); w2 ^= w1 ^ 29; g3(tab, w1); w1 ^= w4 ^ 30; g4(tab, w4); w4 ^= w3 ^ 31; g0(tab, w3); w3 ^= w2 ^ 32; g1(tab, w2); Block::Put(xorBlock, outBlock)(w4)(w3)(w2)(w1); }
Foam::tmp<Foam::Field<Foam::scalar>> Foam::ParticleStressModels::Lun::tau ( const Field<scalar>& alpha, const Field<scalar>& rho, const Field<scalar>& uSqr ) const { tmp<Field<scalar>> g0 ( 0.6 / max ( 1.0 - pow(alpha/alphaPacked_,1.0/3.0), max(eps_*(1.0 - alpha), small) ) ); tmp<Field<scalar>> gT(uSqr/3.0); return alpha*rho*(1.0 + alpha*(1.0 + e_)*g0)*gT; }
void quadratic_prog(const Vector6d &f, double &lambda, double &miu) { const double a=f[0], b=f[3], c=f[1], d=f[4], e=f[5]; double sum = 0.0; const int N = 2; Matrix<double> G(N, N); G[0][0]=2*a, G[0][1]=b; G[1][0]=b, G[1][1]=2*c; Vector<double> g0(N); g0[0]=d, g0[1]=e; //eq constraints /* Matrix<double> CE(n, m); CE[0][0]=1, CE[1][0]=1; Vector<double> ce0(m); ce0[0]=-3; */ Matrix<double> CE; Vector<double> ce0; //in-eq constraints Matrix<double> CI(N, N); CI[0][0]=1, CI[0][1]=0; CI[1][0]=0, CI[1][1]=1; Vector<double> ci0(N); ci0[0]=0, ci0[1]=-0.001; //=========================== Vector<double> x(N); const double rr = solve_quadprog(G, g0, CE, ce0, CI, ci0, x) + f.z; std::cout << "MinF: " << rr << " x: " << x[0] <<", " <<x[1] << std::endl; lambda = x[0]; miu = x[1]; }
Skeleton_basic::Neighbours::Neighbours( const clipper::Xmap_base &map, const float min_distsq, const float max_distsq ) { /* note that thisd2 is a mesure of distance in real space So here we look around an arbitary current point and take note if the distance between the centre point and points one unit away from it (all directions) is less than a certain cuttoff distance. We are left with a list of ndn neighbouring cells that are sufficicently close to be considered neighbours. Typically, ndn will be 18-20 at then end of this block. Note that body diagonals have length sqrt(3) ~= 1.73, but we passed squared limits. */ clipper::Cell_descr rcd( map.cell().descr() ); clipper::Cell_descr vcd( 1.0,1.0,1.0, rcd.alpha(), rcd.beta(), rcd.gamma() ); clipper::Cell vcell( vcd ); clipper::Coord_grid g0(-1,-1,-1); clipper::Coord_grid g1( 1, 1, 1); clipper::Grid_sampling vgrid( 1, 1, 1 ); clipper::Coord_grid iu, iv, iw; float thisd2; for ( iu = g0; iu.u() <= g1.u(); iu.u()++ ) { for ( iv = iu; iv.v() <= g1.v(); iv.v()++ ) { for ( iw = iv; iw.w() <= g1.w(); iw.w()++ ) { thisd2 = iw.coord_frac( vgrid ).lengthsq( vcell ); if (thisd2 > min_distsq && thisd2 < max_distsq) nlist.push_back( iw ); } } } }
int main(void) { /***************************** Natrual Syntax ********************************/ Base a; Base b; Base c; Derived aa; // test ordinary function functor<void( ) > g0(&test0); g0(); functor<double (double)> g1; g1 = &test1; assert(12.123 == g1(12.123)); // test member function functor<void (int)> g2(&Base::d); functor<int (int)> g3(&Base::static_b); functor<int (int, int, int, int, int, int, int, int, int)> g4(&Base::d9); functor<int (int)> g5(&Base::virtual_c); // operator = functor<int (int, int)> g6; g6 = &Derived::Derived_a2; functor<int (int)> g7(&Derived::virtual_c); // copy constructor functor<int (int)> g7_2; g7_2 = g7; functor<int (int)> g7_3(g7); // reference functor<int (int)> &g7_4 = g7; // pointer functor<int (int)> *g7_5 = &g7; g2(&a, 18); assert(18 == a.getBase()); assert(g3(29) == 29); assert(g4(&b, 1,2,3,4,5,6,7,8,9) == (1+2+3+4+5+6+7+8+9)); assert(g5(&c, 5) == 5); assert(g6(&aa, 5, 6) == 5+6); assert(g7(&aa, 6) == 10+6); assert(g7_2(&aa, 6) == 10+6); assert(g7_3(&aa, 6) == 10+6); assert(g7_4(&aa, 6) == 10+6); assert((*g7_5)(&aa, 6) == 10+6); /************************************* STL *************************************/ int myints[] = {32,71,12,45,26,80,53,33}; std::vector<int> myvector1(myints, myints+8); std::vector<int> myvector2(myints, myints+8); functor<bool (int, int)> functorCmp = &mycmp; std::sort(myvector1.begin(), myvector1.end()); std::sort(myvector2.begin(), myvector2.end(), functorCmp); assert(myvector1.size() == myvector2.size()); for (unsigned int i = 0; i < myvector1.size(); ++i) { assert(myvector1[i] == myvector2[i]); } /***************************** Performance Test ********************************/ // performanceTest (500000000); return 0; }
#define EVAL_EXPR(testno, expr) int test##testno = sizeof(struct{char qq[expr];}); int x; EVAL_EXPR(1, (_Bool)&x) EVAL_EXPR(2, (int)(1.0+(double)4)) EVAL_EXPR(3, (int)(1.0+(float)4.0)) EVAL_EXPR(4, (_Bool)(1 ? (void*)&x : 0)) EVAL_EXPR(5, (_Bool)(int[]){0}) struct y {int x,y;}; EVAL_EXPR(6, (int)(1+(struct y*)0)) EVAL_EXPR(7, (int)&((struct y*)0)->y) EVAL_EXPR(8, (_Bool)"asdf") EVAL_EXPR(9, !!&x) EVAL_EXPR(10, ((void)1, 12)) void g0(void); EVAL_EXPR(11, (g0(), 12)) // FIXME: This should give an error EVAL_EXPR(12, 1.0&&2.0) EVAL_EXPR(13, x || 3.0) unsigned int l_19 = 1; EVAL_EXPR(14, (1 ^ l_19) && 1); // expected-error {{fields must have a constant size}} void f() { int a; EVAL_EXPR(15, (_Bool)&a); // expected-error {{fields must have a constant size}} } // FIXME: Turn into EVAL_EXPR test once we have more folding. _Complex float g16 = (1.0f + 1.0fi);
void f0() { g0(1, 2, 3); // expected-error{{too many arguments to function call}} }
template <int dim> void update(grid<dim, sparse<phi_type> >& oldGrid, int steps) { int rank=0; #ifdef MPI_VERSION rank=MPI::COMM_WORLD.Get_rank(); #endif const phi_type dt = 0.01; const phi_type width = 14.5; const phi_type epsilon = 1.0e-8; const double mu_hi = 1.00; const double mu_lo = 0.01; const double mu_x = 0.6422; const double mu_s = 0.0175; std::ofstream vfile; if (rank==0) vfile.open("v.log",std::ofstream::out | std::ofstream::app); for (int step = 0; step < steps; step++) { if (rank==0) print_progress(step, steps); // newGrid grid must be overwritten each time ghostswap(oldGrid); grid<dim, sparse<phi_type> > newGrid(oldGrid); for (int d=0; d<dim; d++) { if (x0(oldGrid, d) == g0(oldGrid,d)) { b0(oldGrid,d) = Dirichlet; b0(newGrid,d) = Dirichlet; } else if (x1(oldGrid,d) == g1(oldGrid,d)) { b1(oldGrid,d) = Dirichlet; b1(newGrid,d) = Dirichlet; } } for (int i = 0; i < nodes(oldGrid); i++) { vector<int> x = position(oldGrid, i); // determine nonzero fields within // the neighborhood of this node // (2 adjacent voxels along each cardinal direction) sparse<int> s; for (int j = 0; j < dim; j++) for (int k = -1; k <= 1; k++) { x[j] += k; for (int h = 0; h < length(oldGrid(x)); h++) { int pindex = index(oldGrid(x), h); set(s, pindex) = 1; } x[j] -= k; } phi_type S = phi_type(length(s)); // if only one field is nonzero, // then copy this node to newGrid if (S < 2.0) newGrid(i) = oldGrid(i); else { // compute laplacian of each field sparse<phi_type> lap = laplacian(oldGrid, i); // compute variational derivatives sparse<phi_type> dFdp; for (int h = 0; h < length(s); h++) { int hindex = index(s, h); for (int j = h + 1; j < length(s); j++) { int jindex = index(s, j); phi_type gamma = energy(hindex, jindex); phi_type eps = 4.0 / acos(-1.0) * sqrt(0.5 * gamma * width); phi_type w = 4.0 * gamma / width; // Update dFdp_h and dFdp_j, so the inner loop can be over j>h instead of j≠h set(dFdp, hindex) += 0.5 * eps * eps * lap[jindex] + w * oldGrid(i)[jindex]; set(dFdp, jindex) += 0.5 * eps * eps * lap[hindex] + w * oldGrid(i)[hindex]; } } // compute time derivatives sparse<phi_type> dpdt; phi_type mu = mobility(mu_lo, mu_hi, mu_x, mu_s, oldGrid(x).getMagPhi()); for (int h = 0; h < length(s); h++) { int hindex = index(s, h); for (int j = h + 1; j < length(s); j++) { int jindex = index(s, j); set(dpdt, hindex) -= mu * (dFdp[hindex] - dFdp[jindex]); set(dpdt, jindex) -= mu * (dFdp[jindex] - dFdp[hindex]); } } // compute update values phi_type sum = 0.0; for (int h = 0; h < length(s); h++) { int pindex = index(s, h); phi_type value = oldGrid(i)[pindex] + dt * (2.0 / S) * dpdt[pindex]; // Extraneous factor of 2? if (value > 1.0) value = 1.0; if (value < 0.0) value = 0.0; if (value > epsilon) set(newGrid(i), pindex) = value; sum += newGrid(i)[pindex]; } // project onto Gibbs simplex (enforce Σφ=1) phi_type rsum = 0.0; if (fabs(sum) > 0.0) rsum = 1.0 / sum; for (int h = 0; h < length(newGrid(i)); h++) { int pindex = index(newGrid(i), h); set(newGrid(i), pindex) *= rsum; } } } // Loop over nodes(oldGrid) if ((step+1) % 10 == 0) { // Scan along just above the mid-line for the grain boundary. // When found, determine its angle. vector<int> x(dim, 0); const int offset = 2; const phi_type vert_mag = 1.0/std::sqrt(3.0); const phi_type edge_mag = 1.0/std::sqrt(2.0); const phi_type bulk_mag = 1.0; const phi_type edge_contour = edge_mag + 0.125*(bulk_mag - edge_mag); const phi_type vert_contour = vert_mag + 0.125*(edge_mag - vert_mag); x[0] = x0(newGrid,0); x[1] = (g1(newGrid,1) - g0(newGrid,1))/2; while (x[0]<x1(newGrid) && x[1]>=y0(newGrid) && x[1]<y1(newGrid) && newGrid(x).getMagPhi()>vert_contour) x[0]++; if (x[0] == x1(newGrid)) x[0] = g0(newGrid,0); int v0 = x[0]; #ifdef MPI_VERSION MPI::COMM_WORLD.Allreduce(&x[0], &v0, 1, MPI_INT, MPI_MAX); #endif x[1] += offset; while (x[0]>= x0(newGrid) && x[0]<x1(newGrid) && x[1]>=y0(newGrid) && x[1]<y1(newGrid) && newGrid(x).getMagPhi()>edge_contour) x[0]++; if (x[0] == x1(newGrid)) x[0] = g0(newGrid,0); int v1 = x[0]; #ifdef MPI_VERSION MPI::COMM_WORLD.Allreduce(&x[0], &v1, 1, MPI_INT, MPI_MAX); #endif x[1] += offset; while (x[0]>= x0(newGrid) && x[0]<x1(newGrid) && x[1]>=y0(newGrid) && x[1]<y1(newGrid) && newGrid(x).getMagPhi()>edge_contour) x[0]++; if (x[0] == x1(newGrid)) x[0] = g0(newGrid,0); int v2 = x[0]; #ifdef MPI_VERSION MPI::COMM_WORLD.Allreduce(&x[0], &v2, 1, MPI_INT, MPI_MAX); #endif // Second-order right-sided difference to approximate slope double diffX = 3.0*v0 - 4.0*v1 + 1.0*v2; double theta = 180.0/M_PI * std::atan2(2.0*offset*dx(newGrid,1), dx(newGrid,0)*diffX); if (rank==0) vfile << dx(newGrid,0)*v0 << '\t' << dx(newGrid,0)*v1 << '\t' << dx(newGrid,0)*v2 << '\t' << diffX << '\t' << theta << '\n'; } swap(oldGrid, newGrid); } // Loop over steps ghostswap(oldGrid); if (rank==0) vfile.close(); }
void generate(int dim, char* filename) { int rank=0; #ifdef MPI_VERSION rank = MPI::COMM_WORLD.Get_rank(); #endif if (rank==0) { std::ofstream vfile("v.log",std::ofstream::out); vfile.close(); } if (dim == 2) { const int Lx = 768; const int Ly = 128; grid<2,sparse<phi_type> > initGrid(0, 0,Lx, 0,Ly); for (int d=0; d<dim; d++) { if (x0(initGrid, d) == g0(initGrid,d)) b0(initGrid,d) = Dirichlet; else if (x1(initGrid,d) == g1(initGrid,d)) b1(initGrid,d) = Dirichlet; } for (int n=0; n<nodes(initGrid); n++) { vector<int> x = position(initGrid, n); if (x[0]>Ly && x[1]>0.25*Ly && x[1]<0.75*Ly) set(initGrid(n), 0) = 1.0; else if (x[1]<Ly/2) set(initGrid(n), 1) = 1.0; else set(initGrid(n), 2) = 1.0; } output(initGrid, filename); } if (dim == 3) { const int Lx = 512; const int Ly = 256; const int Lz = 64; grid<3,sparse<phi_type> > initGrid(0, 0,Lx, 0,Ly, 0,Lz); for (int d=0; d<dim; d++) { if (x0(initGrid, d) == g0(initGrid,d)) b0(initGrid,d) = Dirichlet; else if (x1(initGrid,d) == g1(initGrid,d)) b1(initGrid,d) = Dirichlet; } for (int n=0; n<nodes(initGrid); n++) { vector<int> x = position(initGrid, n); if (x[0]>Ly && x[1]>0.25*Ly && x[1]<0.75*Ly) set(initGrid(n), 0) = 1.0; else if (x[1]<Ly/2) set(initGrid(n), 1) = 1.0; else set(initGrid(n), 2) = 1.0; } output(initGrid, filename); } }
void skipjack_forwards(u_int8_t *plain, u_int8_t *cipher, u_int8_t **key_tables) { u_int8_t wh1 = plain[0]; u_int8_t wl1 = plain[1]; u_int8_t wh2 = plain[2]; u_int8_t wl2 = plain[3]; u_int8_t wh3 = plain[4]; u_int8_t wl3 = plain[5]; u_int8_t wh4 = plain[6]; u_int8_t wl4 = plain[7]; u_int8_t * k0 = key_tables [0]; u_int8_t * k1 = key_tables [1]; u_int8_t * k2 = key_tables [2]; u_int8_t * k3 = key_tables [3]; u_int8_t * k4 = key_tables [4]; u_int8_t * k5 = key_tables [5]; u_int8_t * k6 = key_tables [6]; u_int8_t * k7 = key_tables [7]; u_int8_t * k8 = key_tables [8]; u_int8_t * k9 = key_tables [9]; /* first 8 rounds */ g0 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 1; wh4 ^= wh1; g4 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 2; wh3 ^= wh4; g8 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 3; wh2 ^= wh3; g2 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 4; wh1 ^= wh2; g6 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 5; wh4 ^= wh1; g0 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 6; wh3 ^= wh4; g4 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 7; wh2 ^= wh3; g8 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 8; wh1 ^= wh2; /* second 8 rounds */ wh2 ^= wh1; wl2 ^= wl1 ^ 9 ; g2 (wh1,wl1, wh1,wl1); wh1 ^= wh4; wl1 ^= wl4 ^ 10; g6 (wh4,wl4, wh4,wl4); wh4 ^= wh3; wl4 ^= wl3 ^ 11; g0 (wh3,wl3, wh3,wl3); wh3 ^= wh2; wl3 ^= wl2 ^ 12; g4 (wh2,wl2, wh2,wl2); wh2 ^= wh1; wl2 ^= wl1 ^ 13; g8 (wh1,wl1, wh1,wl1); wh1 ^= wh4; wl1 ^= wl4 ^ 14; g2 (wh4,wl4, wh4,wl4); wh4 ^= wh3; wl4 ^= wl3 ^ 15; g6 (wh3,wl3, wh3,wl3); wh3 ^= wh2; wl3 ^= wl2 ^ 16; g0 (wh2,wl2, wh2,wl2); /* third 8 rounds */ g4 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 17; wh4 ^= wh1; g8 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 18; wh3 ^= wh4; g2 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 19; wh2 ^= wh3; g6 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 20; wh1 ^= wh2; g0 (wh1,wl1, wh1,wl1); wl4 ^= wl1 ^ 21; wh4 ^= wh1; g4 (wh4,wl4, wh4,wl4); wl3 ^= wl4 ^ 22; wh3 ^= wh4; g8 (wh3,wl3, wh3,wl3); wl2 ^= wl3 ^ 23; wh2 ^= wh3; g2 (wh2,wl2, wh2,wl2); wl1 ^= wl2 ^ 24; wh1 ^= wh2; /* last 8 rounds */ wh2 ^= wh1; wl2 ^= wl1 ^ 25; g6 (wh1,wl1, wh1,wl1); wh1 ^= wh4; wl1 ^= wl4 ^ 26; g0 (wh4,wl4, wh4,wl4); wh4 ^= wh3; wl4 ^= wl3 ^ 27; g4 (wh3,wl3, wh3,wl3); wh3 ^= wh2; wl3 ^= wl2 ^ 28; g8 (wh2,wl2, wh2,wl2); wh2 ^= wh1; wl2 ^= wl1 ^ 29; g2 (wh1,wl1, wh1,wl1); wh1 ^= wh4; wl1 ^= wl4 ^ 30; g6 (wh4,wl4, wh4,wl4); wh4 ^= wh3; wl4 ^= wl3 ^ 31; g0 (wh3,wl3, wh3,wl3); wh3 ^= wh2; wl3 ^= wl2 ^ 32; g4 (wh2,wl2, wh2,wl2); /* pack into byte vector */ cipher [0] = wh1; cipher [1] = wl1; cipher [2] = wh2; cipher [3] = wl2; cipher [4] = wh3; cipher [5] = wl3; cipher [6] = wh4; cipher [7] = wl4; }
#define EVAL_EXPR(testno, expr) int test##testno = sizeof(struct{char qq[expr];}); int x; EVAL_EXPR(1, (_Bool)&x) EVAL_EXPR(2, (int)(1.0+(double)4)) EVAL_EXPR(3, (int)(1.0+(float)4.0)) EVAL_EXPR(4, (_Bool)(1 ? (void*)&x : 0)) EVAL_EXPR(5, (_Bool)(int[]){0}) struct y {int x,y;}; EVAL_EXPR(6, (int)(1+(struct y*)0)) EVAL_EXPR(7, (int)&((struct y*)0)->y) EVAL_EXPR(8, (_Bool)"asdf") EVAL_EXPR(9, !!&x) EVAL_EXPR(10, ((void)1, 12)) void g0(void); EVAL_EXPR(11, (g0(), 12)) // expected-error {{must have a constant size}} EVAL_EXPR(12, 1.0&&2.0) EVAL_EXPR(13, x || 3.0) // expected-error {{must have a constant size}} unsigned int l_19 = 1; EVAL_EXPR(14, (1 ^ l_19) && 1); // expected-error {{fields must have a constant size}} void f() { int a; EVAL_EXPR(15, (_Bool)&a); } // FIXME: Turn into EVAL_EXPR test once we have more folding. _Complex float g16 = (1.0f + 1.0fi);
int main() { // Test dijkstra /* LocalTesting test; test.Test(); return 0; */ srand(time(NULL)); int dimention = 4; cout << "Enter HexBoard side length:"; cin >> dimention; if(dimention<2 || dimention>26) { cout << "\nInvalid dimention, it should be 2<=dimention<=26. Exiting the game" << endl; return -1; } cout << "\nCreating a hexboard of size" << dimention << " X " << dimention << endl; HexBoard hex(dimention); hex.moveNumber = 0; //Create 2 graphs each of size (dimention*dimention)+2 //those last 2 additional vertices are for virtual nodes //Creating 2 separate graphs each for players 0(Blue) and 1(Red) int vertices = (dimention*dimention)+2; Graph g0(vertices); Graph g1(vertices); // Now, connect virtual nodes with corresponding nodes // For g0, WEST virtual vertex is vertex[vertices-2] // EAST virtual vertex is vertex[vertices-1] // For g1, NORTH virtual vertex is vertex[vertices-2] // SOUTH virual vertex is vertex[vertices-1] // Connecting WEST virtual vertex with 1A, 2A, 3A, 4A, .... for(int i=0; i<dimention; i++) { // Undirected graph, so adding it twice g0.add_edge((g0.vertices)-2, (i*dimention)); g0.add_edge((i*dimention), (g0.vertices)-2); // Setting edge_values 1 for all. g0.set_edge_value((g0.vertices)-2, (i*dimention), 1.0); g0.set_edge_value((i*dimention), (g0.vertices)-2, 1.0); } // Connecting EAST virtual vertex with 1G, 2G, 3G, 4G, ....(if it's a 7x7 board) for(int i=0; i<dimention; i++) { // Undirected graph, so adding it twice g0.add_edge((g0.vertices)-1, (i*dimention+(dimention-1))); g0.add_edge((i*dimention+(dimention-1)), (g0.vertices)-1); // Setting edge_values 1 for all. g0.set_edge_value((g0.vertices)-1, (i*dimention+(dimention-1)), 1.0); g0.set_edge_value((i*dimention+(dimention-1)), (g0.vertices)-1, 1.0); } // Connecting NORTH virtual vertex with 1A, 1B, 1C, 1D, ..etc. for(int i=0; i<dimention; i++) { // Undirected graph, so adding it twice g1.add_edge((g1.vertices)-2, (i)); g1.add_edge((i), (g1.vertices)-2); // Setting edge_values 1 for all. g1.set_edge_value((g1.vertices)-2, (i), 1.0); g1.set_edge_value((i), (g1.vertices)-2, 1.0); } // Connecting SOUTH virtual vertex with 7A, 7B, 7C, 7D, ....(if it's a 7x7 board) for(int i=0; i<dimention; i++) { // Undirected graph, so adding it twice g1.add_edge((g1.vertices)-1, (dimention*(dimention-1)+i)); g1.add_edge((dimention*(dimention-1)+i), (g1.vertices)-1); // Setting edge_values 1 for all. g1.set_edge_value((g1.vertices)-1, (dimention*(dimention-1)+i), 1.0); g1.set_edge_value((dimention*(dimention-1)+i), (g1.vertices)-1, 1.0); } cout << "Blue player(Player 0) direction is EAST<->WEST. Occupied position is shown with O" << '\n' << endl; cout << "Red player(Player 1) direction is NORTH<->SOUTH. Occupied position is shown with X" << '\n' << endl; hex.print_board(); cout << '\n' << "Always enter ROW COLUMN(without space and in capital letters)" << endl; cout << "So, row would always be a number and column would be a char" << endl; cout << "Example: 5B is correct, but B5 is wrong" << endl; cout << '\n' << endl; cout << "===================================================================" << endl; cout << "Remember that Blue player always starts the game." << '\n' << endl; cout << "Game is starting now" << '\n' << endl; cout << "===================================================================" << '\n' << endl; //cout << "Helper " << Helper::xy_to_linear(string("4D"), 4) << '\n' << endl; //cout << "Helper " << Helper::linear_to_xy(15, 4) << '\n' << endl; //Main while loop where game is played //while nobody won the game char ch; int isHumanFirst = 1; cout << "Human, do you wanna go first? (Y/N) :"; cin >> ch; cout << '\n' << endl; if(toupper(ch) == 'Y') { isHumanFirst = 1; } else if(toupper(ch) == 'N') { isHumanFirst = 0; } else { cout << "You neither entered Y or N. By default human goes first." << endl; } while((hex.is_win(0, g0)==false) && (hex.is_win(1, g1)==false)) { string player; string color; string move; pair<int, int> p; // Determine which player is playing based on moveNumber. // Player 0 if even moveNumber, Player 1 otherwise. if(hex.moveNumber%2==0) { if(isHumanFirst) { player = "Human"; } else { player = "Computer"; } color.assign("Blue"); } else { if(isHumanFirst) { player = "Computer"; } else { player = "Human"; } color.assign("Red"); } cout << "Player: " << color << "(" << player << ")" << "is playing" << endl; cout << "Move number:" << hex.moveNumber << endl; if(player == "Human") { cout << "Enter move:"; cin >> move; } else {
unsigned long generate(MMSP::grid<dim,MMSP::sparse<float> >*& grid, int seeds, int nthreads) { #if (defined CCNI) && (!defined MPI_VERSION) std::cerr<<"Error: MPI is required for CCNI."<<std::endl; exit(1); #endif int rank=0; #ifdef MPI_VERSION rank = MPI::COMM_WORLD.Get_rank(); int np = MPI::COMM_WORLD.Get_size(); #endif unsigned long timer=0; if (dim == 2) { const int edge = 1024; int number_of_fields(seeds); if (number_of_fields==0) number_of_fields = static_cast<int>(float(edge*edge)/(M_PI*10.*10.)); // average grain is a disk of radius 10 #ifdef MPI_VERSION while (number_of_fields % np) --number_of_fields; #endif grid = new MMSP::grid<dim,MMSP::sparse<float> >(0, 0, edge, 0, edge); #ifndef SILENT if (rank==0) std::cout<<"Grid origin: ("<<g0(*grid,0)<<','<<g0(*grid,1)<<")," <<" dimensions: "<<g1(*grid,0)-g0(*grid,0)<<" × "<<g1(*grid,1)-g0(*grid,1) <<" with "<<number_of_fields<<" grains."<<std::endl; #endif #ifdef MPI_VERSION number_of_fields /= np; #endif #if (!defined MPI_VERSION) && ((defined CCNI) || (defined BGQ)) std::cerr<<"Error: CCNI requires MPI."<<std::endl; std::exit(1); #endif timer = tessellate<dim,float>(*grid, number_of_fields, nthreads); #ifndef SILENT if (rank==0) std::cout<<"Tessellation complete."<<std::endl; #endif #ifdef MPI_VERSION MPI::COMM_WORLD.Barrier(); #endif } else if (dim == 3) { const int edge = 64; int number_of_fields(seeds); if (number_of_fields==0) number_of_fields = static_cast<int>(float(edge*edge*edge)/(4./3*M_PI*10.*10.*10.)); // Average grain is a sphere of radius 10 voxels #ifdef MPI_VERSION while (number_of_fields % np) --number_of_fields; #endif grid = new MMSP::grid<dim,MMSP::sparse<float> >(0,0,edge,0,edge,0,edge); #ifndef SILENT if (rank==0) std::cout<<"Grid origin: ("<<g0(*grid,0)<<','<<g0(*grid,1)<<','<<g0(*grid,2)<<")," <<" dimensions: "<<g1(*grid,0)-g0(*grid,0)<<" × "<<g1(*grid,1)-g0(*grid,1)<<" × "<<g1(*grid,2)-g0(*grid,2) <<" with "<<number_of_fields<<" grains."<<std::endl; #endif #ifdef MPI_VERSION number_of_fields /= np; #endif #if (!defined MPI_VERSION) && ((defined CCNI) || (defined BGQ)) std::cerr<<"Error: CCNI requires MPI."<<std::endl; std::exit(1); #endif timer = tessellate<dim,float>(*grid, number_of_fields, nthreads); #ifdef MPI_VERSION MPI::COMM_WORLD.Barrier(); #endif #ifndef SILENT if (rank==0) std::cout<<"Tessellation complete."<<std::endl; #endif } return timer; }