TEST(BitopsTest, fill0){ std::bitset<64> bitset; bitset.set(); fill0(bitset); EXPECT_TRUE(bitset.none()); bitset.set(); fill0(bitset, 20, 41); for (size_t i = 0; i < bitset.size(); ++i) { if (i >= 20 && i <= 40){ EXPECT_FALSE(bitset.test(i)); } else { EXPECT_TRUE(bitset.test(i)); } } }
//computes the tfce score of a 3D statistic map(dim_x*dim_y*dim_z) float * tfce_score(float * map, int dim_x, int dim_y, int dim_z, float E, float H, float dh){ int n = dim_x * dim_y * dim_z; float minData = 0; float maxData = 0; float rangeData = 0; float * posData; float * negData; float precision, increment; float h; int i,j; int * indexPosData; int * indexNegData; int * indexMatchingData; float * clustered_map; int num_clusters; int numOfElementsMatching; float * toReturn = fill0(n); float minPos = 0; float maxPos = 0; int steps = 0; findMinMax(map, n, &minData, &maxData, &rangeData); precision = rangeData/dh; if (precision > 200) { increment = rangeData/200; } else{ increment = rangeData/precision; } steps = ceil(rangeData / increment); #pragma omp parallel for for (i = 0; i < steps; i++) { computeTfceIteration(minData + i*increment, map, n, dim_x, dim_y, dim_z, E, H, increment, toReturn); } return toReturn; }
void slvsml(double **u, double **rhs) { void fill0(double **u, int n); double h=0.5; fill0(u,3); u[2][2] = -h*h*rhs[2][2]/4.0; }
void slvsml(float ***u, float ***rhs) /* Solution of the model problem on the coarsest grid, where h = 1 2 . The right-hand side is input in rhs[1..3][1..3] and the solution is returned in u[1..3][1..3]. */ { void fill0(float ***u, int n); double h=0.5; double C = alpha/(h*h); fill0(u,3); u[2][2][2] = -rhs[2][2][2]/(6.0*C+1); }
void slvsml(double **u, double **rhs, double c, double dt, double **s) /* Solution of the model problem on the coarsest grid, where h = 1 2 . The right-hand side is input in rhs[1..3][1..3] and the solution is returned in u[1..3][1..3]. */ { void fill0(double **u, int n); double h=0.5; c=c/(h*h); fill0(u,3); u[2][2] = (rhs[2][2]+dt*s[2][2])/(1+4.0*c); }
void slvsml(double **u, double **rhs) /* Solution of the model problem on the coarsest grid, where h = 1 2 . The right-hand side is input in rhs[1..3][1..3] and the solution is returned in u[1..3][1..3]. */ { H(""); float alpha = 1.1234e-4; // diffusivity of copper in m^2/s float dt = 0.00001; // timestep chosen arbitrarily float dx = 0.5; // domain is [0,1]; 2 intervals at this coarseness float C = alpha*dt/(dx*dx); void fill0(double **u, int n); fill0(u,3); u[2][2] = rhs[2][2]/(1+4.0*C); }
void mglin(float ***u, int n, int ncycle){ /* Full Multigrid Algorithm for solution of the steady state heat equation with forcing. On input u[1..n][1..n] contains the right-hand side ρ, while on output it returns the solution. The dimension n must be of the form 2j + 1 for some integer j. (j is actually the number of grid levels used in the solution, called ng below.) ncycle is the number of V-cycles to be used at each level. */ unsigned int j,jcycle,jj,jpost,jpre,nf,ng=0,ngrid,nn; /*** setup multigrid jagged arrays ***/ float ***iu[NGMAX+1]; /* stores solution at each grid level */ float ***irhs[NGMAX+1]; /* stores rhs at each grid level */ float ***ires[NGMAX+1]; /* stores residual at each grid level */ float ***irho[NGMAX+1]; /* stores rhs during intial solution of FMG */ /*** use bitshift to find the number of grid levels, stored in ng ***/ nn=n; while (nn >>= 1) ng++; /*** some simple input checks ***/ if (n != 1+(1L << ng)) nrerror("n-1 must be a power of 2 in mglin."); if (ng > NGMAX) nrerror("increase NGMAX in mglin."); /***restrict solution to next coarsest grid (irho[ng-1])***/ nn=n/2+1; ngrid=ng-1; irho[ngrid]=f3tensor(1,nn,1,nn,1,nn); rstrct(irho[ngrid],u,nn);/* coarsens rhs (u at this point) to irho on mesh size nn */ /***continue setting up coarser grids down to coarsest level***/ while (nn > 3) { nn=nn/2+1; irho[--ngrid]=f3tensor(1,nn,1,nn,1,nn); rstrct(irho[ngrid],irho[ngrid+1],nn); } /***now setup and solve coarsest level iu[1],irhs[1] ***/ nn=3; iu[1]=f3tensor(1,nn,1,nn,1,nn); irhs[1]=f3tensor(1,nn,1,nn,1,nn); slvsml(iu[1],irho[1]); /* solve the small system directly */ free_f3tensor(irho[1],1,nn,1,nn,1,nn); ngrid=ng; /* reset ngrid to original size */ for (j=2;j<=ngrid;j++) { /* loop over coarse to fine, starting at level 2 */ printf("at grid level %d\n",j); nn=2*nn-1; iu[j]=f3tensor(1,nn,1,nn,1,nn); /* setup grids for lhs,rhs, and residual */ irhs[j]=f3tensor(1,nn,1,nn,1,nn); ires[j]=f3tensor(1,nn,1,nn,1,nn); interp(iu[j],iu[j-1],nn); /* irho contains rhs except on fine grid where it is in u */ copy(irhs[j],(j != ngrid ? irho[j] : u),nn); /* v-cycle at current grid level */ for (jcycle=1;jcycle<=ncycle;jcycle++) { /* nf is # points on finest grid for current v-sweep */ nf=nn; for (jj=j;jj>=2;jj--) { for (jpre=1;jpre<=NPRE;jpre++) /* NPRE g-s sweeps on the finest (relatively) scale */ relax(iu[jj],iu[jj-1],irhs[jj],nf); //need iu[jj-1] for jacobi resid(ires[jj],iu[jj],irhs[jj],nf); /* compute res on finest scale, store in ires */ nf=nf/2+1; /* next coarsest scale */ rstrct(irhs[jj-1],ires[jj],nf); /* restrict residuals as rhs of next coarsest scale */ fill0(iu[jj-1],nf); /* set the initial solution guess to zero */ } slvsml(iu[1],irhs[1]); /* solve the small problem exactly */ nf=3; /* fine scale now n=3 */ for (jj=2;jj<=j;jj++) { /* work way back up to current finest grid */ nf=2*nf-1; /* next finest scale */ addint(iu[jj],iu[jj-1],ires[jj],nf); /* inter error and add to previous solution guess */ for (jpost=1;jpost<=NPOST;jpost++) /* do NPOST g-s sweeps */ relax(iu[jj],iu[jj-1],irhs[jj],nf); } } } copy(u,iu[ngrid],n); /* copy solution into input array (implicitly returned) */ /*** clean up memory ***/ for (nn=n,j=ng;j>=2;j--,nn=nn/2+1) { free_f3tensor(ires[j],1,nn,1,nn,1,nn); free_f3tensor(irhs[j],1,nn,1,nn,1,nn); free_f3tensor(iu[j],1,nn,1,nn,1,nn); if (j != ng) free_f3tensor(irho[j],1,nn,1,nn,1,nn); } free_f3tensor(irhs[1],1,3,1,3,1,3); free_f3tensor(iu[1],1,3,1,3,1,3); }
fixed_bit_vector* fixed_bit_vector_manager::allocate0() { fixed_bit_vector* result = allocate(); fill0(*result); return result; }
void mglin(double **u, int n, int ncycle) { void addint(double **uf, double **uc, double **res, int nf); void copy(double **aout, double **ain, int n); void fill0(double **u, int n); void interp(double **uf, double **uc, int nf); void relax(double **u, double **rhs, int n); void resid(double **res, double **u, double **rhs, int n); void rstrct(double **uc, double **uf, int nc); void slvsml(double **u, double **rhs); unsigned int j,jcycle,jj,jpost,jpre,nf,ng=0,ngrid,nn; double **ires[NGMAX+1],**irho[NGMAX+1],**irhs[NGMAX+1],**iu[NGMAX+1]; nn=n; while (nn >>= 1) ng++; if (n != 1+(1L << ng)) nrerror("n-1 must be a power of 2 in mglin."); if (ng > NGMAX) nrerror("increase NGMAX in mglin."); nn=n/2+1; ngrid=ng-1; irho[ngrid]=dmatrix(1,nn,1,nn); rstrct(irho[ngrid],u,nn); while (nn > 3) { nn=nn/2+1; irho[--ngrid]=dmatrix(1,nn,1,nn); rstrct(irho[ngrid],irho[ngrid+1],nn); } nn=3; iu[1]=dmatrix(1,nn,1,nn); irhs[1]=dmatrix(1,nn,1,nn); slvsml(iu[1],irho[1]); free_dmatrix(irho[1],1,nn,1,nn); ngrid=ng; for (j=2;j<=ngrid;j++) { nn=2*nn-1; iu[j]=dmatrix(1,nn,1,nn); irhs[j]=dmatrix(1,nn,1,nn); ires[j]=dmatrix(1,nn,1,nn); interp(iu[j],iu[j-1],nn); copy(irhs[j],(j != ngrid ? irho[j] : u),nn); for (jcycle=1;jcycle<=ncycle;jcycle++) { nf=nn; for (jj=j;jj>=2;jj--) { for (jpre=1;jpre<=NPRE;jpre++) relax(iu[jj],irhs[jj],nf); resid(ires[jj],iu[jj],irhs[jj],nf); nf=nf/2+1; rstrct(irhs[jj-1],ires[jj],nf); fill0(iu[jj-1],nf); } slvsml(iu[1],irhs[1]); nf=3; for (jj=2;jj<=j;jj++) { nf=2*nf-1; addint(iu[jj],iu[jj-1],ires[jj],nf); for (jpost=1;jpost<=NPOST;jpost++) relax(iu[jj],irhs[jj],nf); } } } copy(u,iu[ngrid],n); for (nn=n,j=ng;j>=2;j--,nn=nn/2+1) { free_dmatrix(ires[j],1,nn,1,nn); free_dmatrix(irhs[j],1,nn,1,nn); free_dmatrix(iu[j],1,nn,1,nn); if (j != ng) free_dmatrix(irho[j],1,nn,1,nn); } free_dmatrix(irhs[1],1,3,1,3); free_dmatrix(iu[1],1,3,1,3); }