/* 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;
}
