/* theta_type -- compute type of a theta-exp or theta-select */ PRIVATE type theta_type(tree t, env e, type a, tree cxt) { def d = get_schema((tok) t->x_the_name, t->x_loc); schema s; env e1 = new_env(e); type b; int i; if (d == NULL) return err_type; s = d->d_schema; check_rename(s, (tok) t->x_the_decor, t->x_the_rename, t); for (i = 0; i < s->z_ncomps; i++) { sym x = s->z_comp[i].z_name; sym xp = get_rename(x, (tok) t->x_the_decor, t->x_the_rename); type tt = (a == NULL ? ref_type(xp, nil, e, t) : comp_type(a, xp, cxt, t->x_loc)); add_def(VAR, x, tt, e1); } b = mk_sproduct(mk_schema(e1)); if (! aflag && d->d_abbrev && d->d_nparams == 0 && type_equal(b, arid, mk_sproduct(s), arid)) return mk_abbrev(d, arid); else return b; }
int main(int argc, char* argv[]) { size_t nins; { die_verbose_if(argc < 2, "Usage: " << argv[0] << " #log_ins"); const auto log_nins = foxxll::atoi64(argv[1]); die_verbose_if(log_nins > 31, "This test can't do more than 2^31 operations, you requested 2^" << log_nins); nins = 1ULL << log_nins; } // prepare random unique keys stxxl::vector<key_type> values(nins); std::mt19937_64 randgen; { random_fill_vector(values, randgen); LOG1 << "Sorting the random values"; stxxl::sort(values.begin(), values.end(), comp_type(), 128 * 1024 * 1024); LOG1 << "Deleting duplicate values"; { auto new_end = std::unique(values.begin(), values.end()); values.resize(std::distance(values.begin(), new_end)); } LOG1 << "Randomly permute input values"; stxxl::shuffle(values.begin(), values.end(), randgen, 128 * 1024 * 1024); } btree_type BTree(1024 * 128, 1024 * 128); { LOG1 << "Inserting " << values.size() << " random values into btree"; for (auto it = values.cbegin(); it != values.cend(); ++it) BTree.insert({ *it, static_cast<payload_type>(*it + 1) }); LOG1 << "Number of elements in btree: " << BTree.size(); } { LOG1 << "Searching " << values.size() << " existing elements and erasing them"; for (auto it = values.cbegin(); it != values.cend(); ++it) { auto bIt = BTree.find(*it); die_unless(bIt != BTree.end()); // erasing non-existent element die_unless(BTree.erase((*it) + 1) == 0); // erasing existing element die_unless(BTree.erase(*it) == 1); // checking it is not there die_unless(BTree.find(*it) == BTree.end()); // trying to erase it again die_unless(BTree.erase(*it) == 0); } } die_unless(BTree.empty()); LOG1 << "Test passed."; return 0; }
/** * Prepare histogram data. * * @param x first data * @param wv weight data * @return max. index value or -1, if index empty */ INT32 CGEN_PROTECTED CHistogram::Prepare(CData* x, CData* wv) { INT32 imax = 1, i, n; if (m_hist == NULL) m_hist = data_create("hist"); m_nhist = data_nblock(m_hist); if (data_empty(m_indexlist) != TRUE) { imax = CHistogram_max_index(m_indexlist, 0) + 1; if (imax > m_nhist) m_nhist = imax; } if (data_empty(wv) != TRUE) { imax = data_ndim(wv); if (imax > m_nhist) m_nhist = imax; } if (m_nhist == 0) m_nhist = 1; if (data_empty(m_hist) != TRUE) { data_realloc (m_hist, m_nhist * m_bins); set_data_nrec (m_hist, m_nhist * m_bins); m_hdim = data_dim(m_hist); } else { data_reset(m_hist); n = data_dim(x); m_hdim = 0; for (i = 0; i < n; i++) if (comp_type(x,i) > 256 && i != m_icomp) { comp_def(m_hist, comp_text(x,i),T_DOUBLE); m_hdim++; } data_arr_alloc (m_hist, m_bins * m_nhist); } set_data_descr(m_hist, DESCR1, (FLOAT64)m_hmode); set_data_descr(m_hist, DESCR2, (FLOAT64)m_bins); set_data_nblock(m_hist, m_nhist); return (m_nhist); }
//-------------------------------------------------------------------------- // Function: CommonFG::openCompType ///\brief Opens the named compound datatype at this location. ///\param name - IN: Name of the compound datatype to open ///\return CompType instance ///\exception H5::FileIException or H5::GroupIException // Programmer Binh-Minh Ribler - 2000 //-------------------------------------------------------------------------- CompType CommonFG::openCompType( const char* name ) const { // Call C function H5Topen2 to open the named datatype in this group, // given either the file or group id hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT); // If the datatype's opening failed, throw an exception if( type_id < 0 ) throwException("openCompType", "H5Topen2 failed"); // No failure, create and return the CompType object CompType comp_type(type_id); return(comp_type); }
LOCAL COMP_TYPE *clone_elliptical_comp_type( ELLIPSOID *ellip, COMP_TYPE *ct, Front *front, INIT_PHYSICS *ip) { _ELLIPTICAL *el, *nel; COMP_TYPE *nct; INTERFACE *intfc = front->interf; int i, dim; nct = comp_type(new_component(NEW_COMP)); set_elliptical_comp_type(nct,ip); nel = Elliptical(nct); nel->ellipsoid = ellip; switch (ct->type) { case ELLIPTICAL: dim = intfc->dim; el = Elliptical(ct); nel->rstate = copy_random_state_structure(el->rstate,intfc); ft_assign(nel->state,el->state,front->sizest); ft_assign(nel->wkstate[0],el->wkstate[0],front->sizest); ft_assign(nel->wkstate[1],el->wkstate[1],front->sizest); for (i = 0; i < dim; ++i) nel->weight[i] = el->weight[i]; nel->r0 = el->r0; nel->rw1d = el->rw1d; nel->stratification_type = el->stratification_type; break; case AMBIENT: nel->rstate = NULL; set_state(nel->state,TGAS_STATE,Ambient(ct)); break; default: screen("ERROR in copy_elliptical_comp_type(), " "comp_type %s not supported\n",comp_type_name(ct->type)); clean_up(ERROR); break; } return nct; } /*end clone_elliptical_comp_type*/
int main(int argc, char* argv[]) { if (argc < 2) { STXXL_MSG("Usage: " << argv[0] << " #ins"); return -1; } const unsigned nins = atoi(argv[1]); STXXL_MSG("Data set size : " << nins * sizeof(std::pair<int, my_type>) << " bytes"); STXXL_MSG("Node cache size: " << node_cache_size << " bytes"); STXXL_MSG("Leaf cache size: " << leaf_cache_size << " bytes"); //stxxl::random_number32 rnd; std::vector<std::pair<int, my_type> > Data(nins); for (unsigned int i = 0; i < nins; ++i) { Data[i].first = i; Data[i].second.data = i; checksum += i; } { btree_type BTree1(Data.begin(), Data.end(), comp_type(), node_cache_size, leaf_cache_size, true); btree_type BTree2(Data.begin(), Data.end(), comp_type(), node_cache_size, leaf_cache_size, true); //STXXL_MSG(*stxxl::stats::get_instance()); C(BTree1); //STXXL_MSG(*stxxl::stats::get_instance()); NC(BTree2); //STXXL_MSG(*stxxl::stats::get_instance()); } { btree_type BTree1(Data.begin(), Data.end(), comp_type(), node_cache_size, leaf_cache_size, true); btree_type BTree2(Data.begin(), Data.end(), comp_type(), node_cache_size, leaf_cache_size, true); STXXL_MSG("Disabling prefetching"); BTree1.disable_prefetching(); BTree2.disable_prefetching(); //STXXL_MSG(*stxxl::stats::get_instance()); C(BTree1); //STXXL_MSG(*stxxl::stats::get_instance()); NC(BTree2); //STXXL_MSG(*stxxl::stats::get_instance()); } STXXL_MSG("All tests passed successfully"); return 0; }
/*ARGSUSED*/ EXPORT void set_up_riemann_problem_region( int layer_label, int region_label, int surf_label, int ellip_label, float *coords, float *nor, SIDE ahead_side, Locstate ahead_st, Locstate st, LAYER_SYS *layer_sys, INIT_PHYSICS *ip, INIT_DATA *init) { COMP_TYPE *ct; _RAREFACTION_WAVE_1D *rw1d; LAYER *lyr, *llyr, *ulyr; Front *front = layer_sys->front; INTERFACE *intfc = front->interf; ELLIPSOID *ellip; LAYER_SURF *lsurf; Locstate sl, sr; Locstate left, right; Locstate sml, smr; float vl, vr; float pjump; float pml, pmr, uml, umr, ml, mr; float cl, cr, cml, cmr, Wl, Wr; float W, V; float dt, dh; RIEMANN_SOLVER_WAVE_TYPE l_wave, r_wave; int i, dim = front->rect_grid->dim; int w_type; size_t sizest = front->sizest; debug_print("layer","Entered set_up_riemann_problem_region()\n"); alloc_state(intfc,&left,max(sizeof(VGas),sizest)); alloc_state(intfc,&right,max(sizeof(VGas),sizest)); alloc_state(intfc,&sml,sizest); alloc_state(intfc,&smr,sizest); if (ahead_side == POSITIVE_SIDE) { sl = st; sr = ahead_st; } else { sl = ahead_st; sr = st; } set_state(right,TGAS_STATE,sr); set_state(left,TGAS_STATE,sl); lyr = layer_sys->layer[layer_label]; if (ellip_label > 0) { if (ellip_label <= lyr->num_ellips) ellip = lyr->ellip[ellip_label]; else { screen("ERROR in set_up_riemann_problem_region(), " "invalid ellip_label %d > num_ellips %d\n", ellip_label,lyr->num_ellips); clean_up(ERROR); } lsurf = NULL; } else { ellip = NULL; if (surf_label == layer_label) { lsurf = lyr->upper_surf; llyr = lyr; ulyr = layer_sys->layer[layer_label+1]; } else if (surf_label == layer_label-1) { lsurf = lyr->lower_surf; ulyr = lyr; llyr = layer_sys->layer[layer_label-1]; } else { screen("ERROR in set_up_riemann_problem_region(), " "invalid surf_label %d layer_label %d\n", surf_label,layer_label); clean_up(ERROR); } } if (ellip != NULL) { vr = Vel(right)[0]; vl = Vel(left)[0]; pjump = -ellip->surf_tension/ distance_between_positions(coords,ellip->cen,dim); } else { vr = scalar_product(Vel(right),nor,dim); vl = scalar_product(Vel(left),nor,dim); pjump = 0.0; } zero_state_velocity(right,dim); Vel(right)[0] = vr; zero_state_velocity(left,dim); Vel(right)[0] = vl; set_state_for_find_mid_state(right,right); set_state_for_find_mid_state(left,left); if (find_mid_state(left,right,pjump,&pml,&pmr,¨,&umr,&ml,&mr, &l_wave,&r_wave) != FUNCTION_SUCCEEDED) { screen("ERROR in set_up_riemann_problem_region(), " "find_mid_state() did not converge\n"); verbose_print_state("left",left); verbose_print_state("right",right); (void) printf("pjump = %g\n" "pml = %g, pmr = %g\n" "uml = %g, umr = %g\n" "ml = %g, mr = %g\n", pjump,pml,pmr,uml,umr,ml,mr); (void) printf("l_wave = %s, r_wave = %s\n", rsoln_wave_name(l_wave),rsoln_wave_name(r_wave)); clean_up(ERROR); } w_type = (l_wave == RAREFACTION) ? BACKWARD_SOUND_WAVE_TE : BACKWARD_SHOCK_WAVE; state_behind_sound_wave(left,sml,&cml,&Wl,0.0,ml,uml,pml,TGAS_STATE, w_type,l_wave,LEFT_FAMILY); w_type = (r_wave == RAREFACTION) ? FORWARD_SOUND_WAVE_TE : FORWARD_SHOCK_WAVE; state_behind_sound_wave(right,smr,&cmr,&Wr,0.0,mr,umr,pmr,TGAS_STATE, w_type,r_wave,RIGHT_FAMILY); cl = sound_speed(left); cr = sound_speed(right); W = max(fabs(Wl),fabs(Wr)); V = fabs(vl) + cl; W = max(W,V); V = fabs(vr) + cr; W = max(W,V); V = fabs(uml) + cml; W = max(W,V); V = fabs(umr) + cmr; W = max(W,V); for (dh = HUGE_VAL, i = 0; i < dim; ++i) dh = min(dh,front->rect_grid->h[i]); dt = 0.1*dh/W;/*TOLERANCE*/ layer_sys->dt = min(layer_sys->dt,dt); if (debugging("layer")) { (void) printf("States from Riemann solution\n"); verbose_print_state("left state",left); verbose_print_state("left mid state",sml); verbose_print_state("right mid state",smr); verbose_print_state("right state",right); (void) printf("l_wave = %s, r_wave = %s\n", rsoln_wave_name(l_wave),rsoln_wave_name(r_wave)); (void) printf("Wave speeds\n"); if (l_wave == RAREFACTION) { (void) printf("Left rarefaction leading edge speed = %g\n", vl-cl); (void) printf("Left rarefaction trailing edge speed = %g\n", uml-cml); } else if (l_wave == SHOCK) (void) printf("Left shock speed = %g\n",Wl); (void) printf("Contact speed = %g (uml = %g, umr = %g)\n", 0.5*(uml+umr),uml,umr); if (r_wave == RAREFACTION) { (void) printf("Right rarefaction trailing edge speed = %g\n", umr+cmr); (void) printf("Right rarefaction leading edge speed = %g\n", vr+cr); } else if (r_wave == SHOCK) (void) printf("Right shock speed = %g\n",Wr); } if (ellip == NULL) { LAYER *rlyr, *mlyr; LAYER_SURF *rlyr_le, *rlyr_te, *shock; float *nor = lsurf->nor; float vml, vmr; vml = Vel(sml)[0]; vmr = Vel(smr)[0]; for (i = 0; i < dim; ++i) { Vel(sml)[i] = vel(i,sl) + (vml-vl)*nor[i]; Vel(smr)[i] = vel(i,sr) + (vmr-vr)*nor[i]; } if (l_wave == RAREFACTION) { rlyr = add_new_layer(layer_sys,new_component(NEW_COMP)); rlyr->lower_surf = alloc_layer_surf(); rlyr->upper_surf = alloc_layer_surf(); *rlyr->upper_surf = *lsurf; *rlyr->lower_surf = *lsurf; rlyr->lower_surf->reset_position = YES; rlyr->upper_surf->reset_position = YES; rlyr->lower_surf->surf_ten = 0.0; rlyr->upper_surf->surf_ten = 0.0; ct = comp_type(rlyr->comp); set_rarefaction_wave_1d_comp_type(ct,front); rw1d = Rarefaction_wave_1d(ct); rw1d->l_or_r = LEFT_FAMILY; rw1d->zbar = lsurf->pbar[dim-1]; rw1d->tbar = -HUGE_VAL; /*To be set later */ rw1d->el_lead = rw1d->el_trail = NULL; set_state(rw1d->stl,TGAS_STATE,sl); set_state(rw1d->stt,TGAS_STATE,sml); rw1d->spl = vl-cl; rw1d->spt = vml-cml; mlyr = add_new_layer(layer_sys,new_component(NEW_COMP)); if (nor[dim-1] < 0.0) { rlyr_le = rlyr->upper_surf; rlyr_te = rlyr->lower_surf; mlyr->upper_surf = rlyr_te; mlyr->lower_surf = lsurf; rw1d->zt = rw1d->zmin = -HUGE_VAL;/*To be set later*/ rw1d->stmin = rw1d->stt; rw1d->zl = rw1d->zmax = HUGE_VAL;/*To be set later*/ rw1d->stmax = rw1d->stl; ulyr->lower_surf = rlyr_le; } else { rlyr_le = rlyr->lower_surf; rlyr_te = rlyr->upper_surf; mlyr->lower_surf = rlyr_te; mlyr->upper_surf = lsurf; rw1d->zl = rw1d->zmin = -HUGE_VAL;/*To be set later*/ rw1d->stmin = rw1d->stl; rw1d->zt = rw1d->zmax = HUGE_VAL;/*To be set later*/ rw1d->stmax = rw1d->stt; llyr->upper_surf = rlyr_le; } rw1d->lead = rlyr_le; rw1d->trail = rlyr_te; rlyr_le->l_comp = lsurf->l_comp; rlyr_le->r_comp = rlyr_te->l_comp = rlyr->comp; rlyr_le->wv_type = BACKWARD_SOUND_WAVE_LE; rlyr_te->wv_type = BACKWARD_SOUND_WAVE_TE; rlyr_te->r_comp = lsurf->l_comp = mlyr->comp; for (i = 0; i < dim; ++i) { rlyr_le->velocity[i] = rw1d->spl*nor[i]; rlyr_te->velocity[i] = rw1d->spt*nor[i]; } } else { mlyr = add_new_layer(layer_sys,new_component(NEW_COMP)); shock = alloc_layer_surf(); *shock = *lsurf; if (nor[dim-1] < 0.0) { mlyr->upper_surf = shock; mlyr->lower_surf = lsurf; ulyr->lower_surf = shock; } else { mlyr->lower_surf = shock; mlyr->upper_surf = lsurf; llyr->upper_surf = shock; } shock->l_comp = lsurf->l_comp; shock->wv_type = BACKWARD_SHOCK_WAVE; shock->r_comp = lsurf->l_comp = mlyr->comp; shock->reset_position = YES; for (i = 0; i < dim; ++i) shock->velocity[i] = Wl*nor[i]; } ct = comp_type(mlyr->comp); set_ambient_comp_type(ct,front); set_state(Ambient(ct),GAS_STATE,sml); if (r_wave == RAREFACTION) { rlyr = add_new_layer(layer_sys,new_component(NEW_COMP)); rlyr->lower_surf = alloc_layer_surf(); rlyr->upper_surf = alloc_layer_surf(); *rlyr->upper_surf = *lsurf; *rlyr->lower_surf = *lsurf; rlyr->lower_surf->reset_position = YES; rlyr->upper_surf->reset_position = YES; rlyr->lower_surf->surf_ten = 0.0; rlyr->upper_surf->surf_ten = 0.0; ct = comp_type(rlyr->comp); set_rarefaction_wave_1d_comp_type(ct,front); rw1d = Rarefaction_wave_1d(ct); rw1d->l_or_r = RIGHT_FAMILY; rw1d->zbar = lsurf->pbar[dim-1]; rw1d->tbar = -HUGE_VAL; /*To be set later */ rw1d->el_lead = rw1d->el_trail = NULL; set_state(rw1d->stl,TGAS_STATE,sr); set_state(rw1d->stt,TGAS_STATE,smr); rw1d->spl = vr+cr; rw1d->spt = vmr+cmr; rw1d->lead = rlyr_le; rw1d->trail = rlyr_te; mlyr = add_new_layer(layer_sys,new_component(NEW_COMP)); if (nor[dim-1] < 0.0) { rlyr_le = rlyr->lower_surf; rlyr_te = rlyr->upper_surf; mlyr->lower_surf = rlyr_te; mlyr->upper_surf = lsurf; rw1d->zl = rw1d->zmin = -HUGE_VAL;/*To be set later*/ rw1d->stmin = rw1d->stl; rw1d->zt = rw1d->zmax = HUGE_VAL;/*To be set later*/ rw1d->stmax = rw1d->stt; llyr->upper_surf = rlyr_le; } else { rlyr_le = rlyr->upper_surf; rlyr_te = rlyr->lower_surf; mlyr->upper_surf = rlyr_te; mlyr->lower_surf = lsurf; rw1d->zt = rw1d->zmin = -HUGE_VAL;/*To be set later*/ rw1d->stmin = rw1d->stt; rw1d->zl = rw1d->zmax = HUGE_VAL;/*To be set later*/ rw1d->stmax = rw1d->stl; ulyr->lower_surf = rlyr_le; } rlyr_le->r_comp = lsurf->r_comp; rlyr_le->l_comp = rlyr_te->r_comp = rlyr->comp; rlyr_le->wv_type = FORWARD_SOUND_WAVE_LE; rlyr_te->wv_type = FORWARD_SOUND_WAVE_TE; rlyr_te->l_comp = lsurf->r_comp = mlyr->comp; for (i = 0; i < dim; ++i) { rlyr_le->velocity[i] = rw1d->spl*nor[i]; rlyr_te->velocity[i] = rw1d->spt*nor[i]; } } else { mlyr = add_new_layer(layer_sys,new_component(NEW_COMP)); shock = alloc_layer_surf(); *shock = *lsurf; if (nor[dim-1] < 0.0) { mlyr->lower_surf = shock; mlyr->upper_surf = lsurf; llyr->upper_surf = shock; } else { mlyr->upper_surf = shock; mlyr->lower_surf = lsurf; ulyr->lower_surf = shock; } shock->r_comp = lsurf->r_comp; shock->wv_type = FORWARD_SHOCK_WAVE; shock->l_comp = lsurf->r_comp = mlyr->comp; shock->reset_position = YES; for (i = 0; i < dim; ++i) shock->velocity[i] = Wr*nor[i]; } ct = comp_type(mlyr->comp); set_ambient_comp_type(ct,front); set_state(Ambient(ct),GAS_STATE,smr); lsurf->wv_type = CONTACT; lsurf->reset_position = YES; for (i = 0; i < dim; ++i) lsurf->velocity[i] = 0.5*(vml+vmr)*nor[i]; } else { set_riemann_problem_ellipsoid(front,lyr,ellip,l_wave,r_wave, Wl,Wr,sl,sml,smr,sr,ip); } free_these(4,left,right,sml,smr); debug_print("layer","Left set_up_riemann_problem_region()\n"); } /*end set_up_riemann_problem_region*/
LOCAL void set_riemann_problem_ellipsoid( Front *front, LAYER *lyr, ELLIPSOID *ellip, RIEMANN_SOLVER_WAVE_TYPE l_wave, RIEMANN_SOLVER_WAVE_TYPE r_wave, float Wl, float Wr, Locstate sl, Locstate sml, Locstate smr, Locstate sr, INIT_PHYSICS *ip) { _ELLIPTICAL *rel, *mel, *el; _RAREFACTION_WAVE_1D *rw1d; COMP_TYPE *rct, *mct, *ct; ELLIPSOID *le_ellip, *te_ellip, *shock; INTERFACE *intfc = front->interf; float rmax; int i, dim = intfc->dim; ct = comp_type(ellip->compin); rmax = max_radii(ellip); if (l_wave == RAREFACTION) { le_ellip = clone_ellipsoid(lyr,ellip); le_ellip->wv_type = BACKWARD_SOUND_WAVE_LE; te_ellip = clone_ellipsoid(lyr,ellip); te_ellip->wv_type = BACKWARD_SOUND_WAVE_TE; if (ellip->nor_orient == POSITIVE_ORIENTATION) { mct = clone_elliptical_comp_type(ellip,ct,front,ip); rct = clone_elliptical_comp_type(te_ellip,ct,front,ip); if (ct->type == ELLIPTICAL) { el = Elliptical(ct); el->ellipsoid = le_ellip; } le_ellip->compin = ellip->compin; le_ellip->compout = rct->comp; te_ellip->compin = le_ellip->compout; te_ellip->compout = mct->comp; ellip->compin = te_ellip->compout; inner_ellipsoid(le_ellip) = inner_ellipsoid(ellip); outer_ellipsoid(le_ellip) = te_ellip; inner_ellipsoid(te_ellip) = le_ellip; outer_ellipsoid(te_ellip) = ellip; inner_ellipsoid(ellip) = te_ellip; } else if (ellip->nor_orient == NEGATIVE_ORIENTATION) { rct = clone_elliptical_comp_type(le_ellip,ct,front,ip); mct = clone_elliptical_comp_type(te_ellip,ct,front,ip); le_ellip->compout = ellip->compout; le_ellip->compin = rct->comp; te_ellip->compout = le_ellip->compin; te_ellip->compin = mct->comp; ellip->compout = te_ellip->compin; outer_ellipsoid(le_ellip) = outer_ellipsoid(ellip); inner_ellipsoid(le_ellip) = te_ellip; outer_ellipsoid(te_ellip) = le_ellip; inner_ellipsoid(te_ellip) = ellip; outer_ellipsoid(ellip) = te_ellip; } else { screen("ERROR in set_up_riemann_problem_region(), " "ellip->nor_orient not set\n"); clean_up(ERROR); } rel = Elliptical(rct); rel->rw1d = rw1d = allocate_RAREFACTION_WAVE_1D(front); rw1d->l_or_r = LEFT_FAMILY; rw1d->zbar = rmax; rw1d->tbar = -HUGE_VAL; /*To be set later */ rw1d->el_lead = le_ellip; rw1d->el_trail = te_ellip; rw1d->lead = rw1d->trail = NULL; set_state(rw1d->stl,TGAS_STATE,sl); set_state(rw1d->stt,TGAS_STATE,sml); le_ellip->reset_position = te_ellip->reset_position = YES; rw1d->spl = vel(0,sl) - sound_speed(sl); rw1d->spt = vel(0,sml) - sound_speed(sml); for (i = 0; i < dim; ++i) { le_ellip->vr[i] = rw1d->spl*ellip->rad[i]/rmax; te_ellip->vr[i] = rw1d->spt*ellip->rad[i]/rmax; } if (ellip->nor_orient == POSITIVE_ORIENTATION) { rw1d->zl = rw1d->zmin = -HUGE_VAL; rw1d->zt = rw1d->zmax = HUGE_VAL; rw1d->stmin = rw1d->stl; rw1d->stmax = rw1d->stt; } else { rw1d->zt = rw1d->zmin = -HUGE_VAL; rw1d->zl = rw1d->zmax = HUGE_VAL; rw1d->stmin = rw1d->stt; rw1d->stmax = rw1d->stl; } } else { shock = clone_ellipsoid(lyr,ellip); shock->wv_type = BACKWARD_SHOCK_WAVE; if (ellip->nor_orient == POSITIVE_ORIENTATION) { mct = clone_elliptical_comp_type(ellip,ct,front,ip); if (ct->type == ELLIPTICAL) { el = Elliptical(ct); el->ellipsoid = shock; } shock->compin = ellip->compin; shock->compout = mct->comp; ellip->compin = shock->compout; inner_ellipsoid(shock) = inner_ellipsoid(ellip); outer_ellipsoid(shock) = ellip; inner_ellipsoid(ellip) = shock; } else if (ellip->nor_orient == NEGATIVE_ORIENTATION) { mct = clone_elliptical_comp_type(shock,ct,front,ip); shock->compout = ellip->compout; shock->compin = mct->comp; ellip->compout = shock->compin; outer_ellipsoid(shock) = outer_ellipsoid(ellip); inner_ellipsoid(shock) = ellip; outer_ellipsoid(ellip) = shock; } else { screen("ERROR in set_up_riemann_problem_region(), " "ellip->nor_orient not set\n"); clean_up(ERROR); } shock->reset_position = YES; for (i = 0; i < dim; ++i) shock->vr[i] = Wl*ellip->rad[i]/rmax; } mel = Elliptical(mct); set_state(mel->state,TGAS_STATE,sml); if (r_wave == RAREFACTION) { le_ellip = clone_ellipsoid(lyr,ellip); le_ellip->wv_type = FORWARD_SOUND_WAVE_LE; te_ellip = clone_ellipsoid(lyr,ellip); te_ellip->wv_type = FORWARD_SOUND_WAVE_TE; if (ellip->nor_orient == NEGATIVE_ORIENTATION) { mct = clone_elliptical_comp_type(ellip,ct,front,ip); rct = clone_elliptical_comp_type(te_ellip,ct,front,ip); if (ct->type == ELLIPTICAL) { el = Elliptical(ct); el->ellipsoid = le_ellip; } le_ellip->compin = ellip->compin; le_ellip->compout = rct->comp; te_ellip->compin = le_ellip->compout; te_ellip->compout = mct->comp; ellip->compin = te_ellip->compout; inner_ellipsoid(le_ellip) = inner_ellipsoid(ellip); outer_ellipsoid(le_ellip) = te_ellip; inner_ellipsoid(te_ellip) = le_ellip; outer_ellipsoid(te_ellip) = ellip; inner_ellipsoid(ellip) = te_ellip; } else if (ellip->nor_orient == POSITIVE_ORIENTATION) { rct = clone_elliptical_comp_type(le_ellip,ct,front,ip); mct = clone_elliptical_comp_type(te_ellip,ct,front,ip); le_ellip->compout = ellip->compout; le_ellip->compin = rct->comp; te_ellip->compout = le_ellip->compin; te_ellip->compin = mct->comp; ellip->compout = te_ellip->compin; outer_ellipsoid(le_ellip) = outer_ellipsoid(ellip); inner_ellipsoid(le_ellip) = te_ellip; outer_ellipsoid(te_ellip) = le_ellip; inner_ellipsoid(te_ellip) = ellip; outer_ellipsoid(ellip) = te_ellip; } else { screen("ERROR in set_up_riemann_problem_region(), " "ellip->nor_orient not set\n"); clean_up(ERROR); } rel = Elliptical(rct); rel->rw1d = rw1d = allocate_RAREFACTION_WAVE_1D(front); rw1d->l_or_r = RIGHT_FAMILY; rw1d->zbar = rmax; rw1d->tbar = -HUGE_VAL; /*To be set later */ rw1d->el_lead = le_ellip; rw1d->el_trail = te_ellip; rw1d->lead = rw1d->trail = NULL; set_state(rw1d->stl,TGAS_STATE,sr); set_state(rw1d->stt,TGAS_STATE,smr); le_ellip->reset_position = te_ellip->reset_position = YES; rw1d->spl = vel(0,sr) + sound_speed(sr); rw1d->spt = vel(0,smr) + sound_speed(smr); for (i = 0; i < dim; ++i) { le_ellip->vr[i] = rw1d->spl*ellip->rad[i]/rmax; te_ellip->vr[i] = rw1d->spt*ellip->rad[i]/rmax; } if (ellip->nor_orient == NEGATIVE_ORIENTATION) { rw1d->zl = rw1d->zmin = -HUGE_VAL; rw1d->zt = rw1d->zmax = HUGE_VAL; rw1d->stmin = rw1d->stl; rw1d->stmax = rw1d->stt; } else { rw1d->zt = rw1d->zmin = -HUGE_VAL; rw1d->zl = rw1d->zmax = HUGE_VAL; rw1d->stmin = rw1d->stt; rw1d->stmax = rw1d->stl; } } else { shock = clone_ellipsoid(lyr,ellip); shock->wv_type = FORWARD_SHOCK_WAVE; if (ellip->nor_orient == NEGATIVE_ORIENTATION) { mct = clone_elliptical_comp_type(ellip,ct,front,ip); if (ct->type == ELLIPTICAL) { el = Elliptical(ct); el->ellipsoid = shock; } shock->compin = ellip->compin; shock->compout = mct->comp; ellip->compin = shock->compout; inner_ellipsoid(shock) = inner_ellipsoid(ellip); outer_ellipsoid(shock) = ellip; inner_ellipsoid(ellip) = shock; } else if (ellip->nor_orient == POSITIVE_ORIENTATION) { mct = clone_elliptical_comp_type(shock,ct,front,ip); shock->compout = ellip->compout; shock->compin = mct->comp; ellip->compout = shock->compin; outer_ellipsoid(shock) = outer_ellipsoid(ellip); inner_ellipsoid(shock) = ellip; outer_ellipsoid(ellip) = shock; } else { screen("ERROR in set_up_riemann_problem_region(), " "ellip->nor_orient not set\n"); clean_up(ERROR); } shock->reset_position = YES; for (i = 0; i < dim; ++i) shock->vr[i] = Wr*ellip->rad[i]/rmax; } mel = Elliptical(mct); set_state(mel->state,TGAS_STATE,smr); ellip->wv_type = CONTACT; ellip->reset_position = YES; for (i = 0; i < dim; ++i) ellip->vr[i] = 0.5*(vel(0,sml)+vel(0,smr))*ellip->rad[i]/rmax; } /*end set_riemann_problem_ellipsoid*/
PUBLIC type tc_expr(tree t, env e) #endif { switch (t->x_kind) { case REF: return ref_type((sym) t->x_tag, t->x_params, e, t); case INGEN: return ref_type((sym) t->x_tag, list2(t->x_param1, t->x_param2), e, t); case PREGEN: return ref_type((sym) t->x_tag, list1(t->x_param), e, t); case NUMBER: return nat_type; case SEXPR: { def d; frame params; if (! open_sref(t->x_ref, e, &d, ¶ms)) return err_type; if ((tok) t->x_ref->x_sref_decor != empty) { tc_error(t->x_loc, "Decoration ignored in schema reference"); tc_e_etc("Expression: %z", t); tc_e_end(); } if (t->x_ref->x_sref_renames != nil) { tc_error(t->x_loc, "Renaming ignored in schema reference"); tc_e_etc("Expression: %z", t); tc_e_end(); } if (! aflag && d->d_abbrev) return mk_power(mk_abbrev(d, params)); else return mk_power(seal(mk_sproduct(d->d_schema), params)); } case POWER: { type tt1, tt2; if (! anal_power(tt1 = tc_expr(t->x_arg, e), &tt2, t->x_arg)) { tc_error(t->x_loc, "Argument of \\power must be a set"); tc_e_etc("Expression: %z", t); tc_e_etc("Arg type: %t", tt1); tc_e_end(); } return mk_power(mk_power(tt2)); } case TUPLE : { type a[MAX_ARGS]; int n = 0; tree u; for (u = t->x_elements; u != nil; u = cdr(u)) { if (n >= MAX_ARGS) panic("tc_expr - tuple too big"); a[n++] = tc_expr(car(u), e); } return mk_cproduct(n, a); } case CROSS: { type a[MAX_ARGS]; type tt1, tt2; int n = 0; tree u; for (u = t->x_factors; u != nil; u = cdr(u)) { if (n >= MAX_ARGS) panic("tc_expr - product too big"); tt1 = tc_expr(car(u), e); if (! anal_power(tt1, &tt2, car(u))) { tc_error(t->x_loc, "Argument %d of \\cross must be a set", n+1); tc_e_etc("Expression: %z", t); tc_e_etc("Arg %d type: %t", n+1, tt1); tc_e_end(); } a[n++] = tt2; } return mk_power(mk_cproduct(n, a)); } case EXT: case SEQ: case BAG: { type elem_type; type tt; tree u; if (t->x_elements == nil) elem_type = new_typevar(t); else { elem_type = tc_expr(car(t->x_elements), e); for (u = cdr(t->x_elements); u != nil; u = cdr(u)) { if (unify(elem_type, tt = tc_expr(car(u), e))) elem_type = type_union(elem_type, arid, tt, arid); else { tc_error(t->x_loc, "Type mismatch in %s display", (t->x_kind == EXT ? "set" : t->x_kind == SEQ ? "sequence" : "bag")); tc_e_etc("Expression: %z", car(u)); tc_e_etc("Has type: %t", tt); tc_e_etc("Expected: %t", elem_type); tc_e_end(); } } } switch (t->x_kind) { case EXT: return mk_power(elem_type); case SEQ: return (aflag ? rel_type(num_type, elem_type) : mk_seq(elem_type)); case BAG: return (aflag ? rel_type(elem_type, num_type) : mk_bag(elem_type)); } } case THETA: return theta_type(t, e, (type) NULL, t); case BINDING: { tree u; env e1 = new_env(e); for (u = t->x_elements; u != nil; u = cdr(u)) add_def(VAR, (sym) car(u)->x_lhs, tc_expr(car(u)->x_rhs, e), e1); return mk_sproduct(mk_schema(e1)); } case SELECT: { type a = tc_expr(t->x_arg, e); if (type_kind(a) != SPRODUCT) { tc_error(t->x_loc, "Argument of selection must have schema type"); tc_e_etc("Expression: %z", t); tc_e_etc("Arg type: %t", a); tc_e_end(); mark_error(); return err_type; } switch (t->x_field->x_kind) { case IDENT: return (comp_type(a, (sym) t->x_field, t, t->x_loc)); case THETA: return (theta_type(t->x_field, e, a, t)); default: bad_tag("tc_expr.SELECT", t->x_field->x_kind); return (type) NULL; } } case APPLY: return tc_apply(APPLY, t, t->x_arg1, t->x_arg2, e); case INOP: return tc_apply(INOP, t, simply(t->x_op, t->x_loc), pair(t->x_rand1, t->x_rand2), e); case POSTOP: return tc_apply(POSTOP, t, simply(t->x_op, t->x_loc), t->x_rand, e); case LAMBDA: { env e1 = tc_schema(t->x_bvar, e); type dom = tc_expr(char_tuple(t->x_bvar), e1); type ran = tc_expr(t->x_body, e1); return (aflag ? rel_type(dom, ran) : mk_pfun(dom, ran)); } case COMP: case MU: { env e1 = tc_schema(t->x_bvar, e); type a = tc_expr(exists(t->x_body) ? the(t->x_body) : char_tuple(t->x_bvar), e1); return (t->x_kind == COMP ? mk_power(a) : a); } case LETEXPR: return tc_expr(t->x_body, tc_letdefs(t->x_defs, e)); case IF: { type a, b; tc_pred(t->x_if, e); a = tc_expr(t->x_then, e); b = tc_expr(t->x_else, e); if (unify(a, b)) return type_union(a, arid, b, arid); else { tc_error(t->x_loc, "Type mismatch in conditional expression"); tc_e_etc("Expression: %z", t); tc_e_etc("Then type: %t", a); tc_e_etc("Else type: %t", b); tc_e_end(); return err_type; } } default: bad_tag("tc_expr", t->x_kind); /* dummy */ return (type) NULL; } }
int main(int argc, char* argv[]) { if (argc < 2) { STXXL_MSG("Usage: " << argv[0] << " #ins"); return -1; } btree_type BTree1(node_cache_size, leaf_cache_size); unsigned nins = atoi(argv[1]); if (nins < 100) nins = 100; stxxl::random_number32 rnd; // .begin() .end() test BTree1[10] = 100.; btree_type::iterator begin = BTree1.begin(); btree_type::iterator end = BTree1.end(); STXXL_CHECK(begin == BTree1.begin()); BTree1[5] = 50.; btree_type::iterator nbegin = BTree1.begin(); btree_type::iterator nend = BTree1.end(); STXXL_CHECK(nbegin == BTree1.begin()); STXXL_CHECK(begin != nbegin); STXXL_CHECK(end == nend); STXXL_CHECK(begin != end); STXXL_CHECK(nbegin != end); STXXL_CHECK(begin->first == 10); STXXL_CHECK(begin->second == 100); STXXL_CHECK(nbegin->first == 5); STXXL_CHECK(nbegin->second == 50); BTree1[10] = 200.; STXXL_CHECK(begin->second == 200.); btree_type::iterator it = BTree1.find(5); STXXL_CHECK(it != BTree1.end()); STXXL_CHECK(it->first == 5); STXXL_CHECK(it->second == 50.); it = BTree1.find(6); STXXL_CHECK(it == BTree1.end()); it = BTree1.find(1000); STXXL_CHECK(it == BTree1.end()); stxxl::unsigned_type f = BTree1.erase(5); STXXL_CHECK(f == 1); f = BTree1.erase(6); STXXL_CHECK(f == 0); f = BTree1.erase(5); STXXL_CHECK(f == 0); STXXL_CHECK(BTree1.count(10) == 1); STXXL_CHECK(BTree1.count(5) == 0); it = BTree1.insert(BTree1.begin(), std::pair<int, double>(7, 70.)); STXXL_CHECK(it->second == 70.); STXXL_CHECK(BTree1.size() == 2); it = BTree1.insert(BTree1.begin(), std::pair<int, double>(10, 300.)); STXXL_CHECK(it->second == 200.); STXXL_CHECK(BTree1.size() == 2); // test lower_bound it = BTree1.lower_bound(6); STXXL_CHECK(it != BTree1.end()); STXXL_CHECK(it->first == 7); it = BTree1.lower_bound(7); STXXL_CHECK(it != BTree1.end()); STXXL_CHECK(it->first == 7); it = BTree1.lower_bound(8); STXXL_CHECK(it != BTree1.end()); STXXL_CHECK(it->first == 10); it = BTree1.lower_bound(11); STXXL_CHECK(it == BTree1.end()); // test upper_bound it = BTree1.upper_bound(6); STXXL_CHECK(it != BTree1.end()); STXXL_CHECK(it->first == 7); it = BTree1.upper_bound(7); STXXL_CHECK(it != BTree1.end()); STXXL_CHECK(it->first == 10); it = BTree1.upper_bound(8); STXXL_CHECK(it != BTree1.end()); STXXL_CHECK(it->first == 10); it = BTree1.upper_bound(10); STXXL_CHECK(it == BTree1.end()); it = BTree1.upper_bound(11); STXXL_CHECK(it == BTree1.end()); // test equal_range std::pair<btree_type::iterator, btree_type::iterator> it_pair = BTree1.equal_range(1); STXXL_CHECK(BTree1.find(7) == it_pair.first); STXXL_CHECK(BTree1.find(7) == it_pair.second); it_pair = BTree1.equal_range(7); STXXL_CHECK(BTree1.find(7) == it_pair.first); STXXL_CHECK(BTree1.find(10) == it_pair.second); it_pair = BTree1.equal_range(8); STXXL_CHECK(BTree1.find(10) == it_pair.first); STXXL_CHECK(BTree1.find(10) == it_pair.second); it_pair = BTree1.equal_range(10); STXXL_CHECK(BTree1.find(10) == it_pair.first); STXXL_CHECK(BTree1.end() == it_pair.second); it_pair = BTree1.equal_range(11); STXXL_CHECK(BTree1.end() == it_pair.first); STXXL_CHECK(BTree1.end() == it_pair.second); // it = BTree1.lower_bound(0); BTree1.erase(it); STXXL_CHECK(BTree1.size() == 1); BTree1.clear(); STXXL_CHECK(BTree1.size() == 0); for (unsigned int i = 0; i < nins / 2; ++i) { BTree1[rnd() % nins] = 10.1; } STXXL_MSG("Size of map: " << BTree1.size()); BTree1.clear(); for (unsigned int i = 0; i < nins / 2; ++i) { BTree1[rnd() % nins] = 10.1; } STXXL_MSG("Size of map: " << BTree1.size()); btree_type BTree2(comp_type(), node_cache_size, leaf_cache_size); STXXL_MSG("Construction of BTree3 from BTree1 that has " << BTree1.size() << " elements"); btree_type BTree3(BTree1.begin(), BTree1.end(), comp_type(), node_cache_size, leaf_cache_size); STXXL_CHECK(BTree3 == BTree1); STXXL_MSG("Bulk construction of BTree4 from BTree1 that has " << BTree1.size() << " elements"); btree_type BTree4(BTree1.begin(), BTree1.end(), comp_type(), node_cache_size, leaf_cache_size, true); STXXL_MSG("Size of BTree1: " << BTree1.size()); STXXL_MSG("Size of BTree4: " << BTree4.size()); STXXL_CHECK(BTree4 == BTree1); STXXL_CHECK(BTree3 == BTree4); BTree4.begin()->second = 0; STXXL_CHECK(BTree3 != BTree4); STXXL_CHECK(BTree4 < BTree3); BTree4.begin()->second = 1000; STXXL_CHECK(BTree4 > BTree3); STXXL_CHECK(BTree3 != BTree4); it = BTree4.begin(); ++it; STXXL_MSG("Size of Btree4 before erase: " << BTree4.size()); BTree4.erase(it, BTree4.end()); STXXL_MSG("Size of Btree4 after erase: " << BTree4.size()); STXXL_CHECK(BTree4.size() == 1); STXXL_MSG("Size of Btree1 before erase: " << BTree1.size()); BTree1.erase(BTree1.begin(), BTree1.end()); STXXL_MSG("Size of Btree1 after erase: " << BTree1.size()); STXXL_CHECK(BTree1.empty()); // a copy of BTree3 btree_type BTree5(BTree3.begin(), BTree3.end(), comp_type(), node_cache_size, leaf_cache_size, true); STXXL_CHECK(BTree5 == BTree3); btree_type::iterator b3 = BTree3.begin(); btree_type::iterator b4 = BTree4.begin(); btree_type::iterator e3 = BTree3.end(); btree_type::iterator e4 = BTree4.end(); STXXL_MSG("Testing swapping operation (std::swap)"); std::swap(BTree4, BTree3); STXXL_CHECK(b3 == BTree4.begin()); STXXL_CHECK(b4 == BTree3.begin()); STXXL_CHECK(e3 == BTree4.end()); STXXL_CHECK(e4 == BTree3.end()); STXXL_CHECK(BTree5 == BTree4); STXXL_CHECK(BTree5 != BTree3); btree_type::const_iterator cb = BTree3.begin(); btree_type::const_iterator ce = BTree3.end(); const btree_type& CBTree3 = BTree3; cb = CBTree3.begin(); STXXL_CHECK(!(b3 == cb)); STXXL_CHECK((b3 != cb)); STXXL_CHECK(!(cb == b3)); STXXL_CHECK((cb != b3)); ce = CBTree3.end(); btree_type::const_iterator cit = CBTree3.find(0); cit = CBTree3.lower_bound(0); cit = CBTree3.upper_bound(0); std::pair<btree_type::const_iterator, btree_type::const_iterator> cit_pair = CBTree3.equal_range(1); STXXL_CHECK(CBTree3.max_size() >= CBTree3.size()); CBTree3.key_comp(); CBTree3.value_comp(); double sum = 0.0; STXXL_MSG(*stxxl::stats::get_instance()); stxxl::timer Timer2; Timer2.start(); cit = BTree5.begin(); for ( ; cit != BTree5.end(); ++cit) sum += cit->second; Timer2.stop(); STXXL_MSG("Scanning with const iterator: " << Timer2.mseconds() << " msec"); STXXL_MSG(*stxxl::stats::get_instance()); stxxl::timer Timer1; Timer1.start(); it = BTree5.begin(); for ( ; it != BTree5.end(); ++it) sum += it->second; Timer1.stop(); STXXL_MSG("Scanning with non const iterator: " << Timer1.mseconds() << " msec"); STXXL_MSG(*stxxl::stats::get_instance()); BTree5.disable_prefetching(); BTree5.enable_prefetching(); BTree5.prefetching_enabled(); STXXL_CHECK(BTree5.prefetching_enabled()); STXXL_MSG("All tests passed successfully"); return 0; }