auto dag_leaves_impl(TAList al)
{
return list::remove_matching(all_nodes(al), [=](auto zn)
{
return has_start_node(al, zn);
});
}
void BrowserView::update(const Q3PtrList<BrowserView> & lv)
{
Q3Dict<Use> all_nodes(DICT_SIZE);
Q3PtrListIterator<BrowserView> itv(lv);
all_nodes.setAutoDelete(TRUE);
// look at the revision in each view
for (; itv.current(); ++itv) {
Q3DictIterator<BrowserNode> itd(itv.current()->nodes);
for (; itd.current(); ++itd) {
BrowserNode * bn = itd.current();
int rev = bn->get_rev();
Use * use = all_nodes.find(itd.currentKey());
if (use == 0)
all_nodes.insert(itd.currentKey(), new Use(rev));
else {
if (rev < use->rev_min)
use->rev_min = rev;
if (rev > use->rev_max)
use->rev_max = rev;
use->count += 1;
}
}
}
// first solve step
// only the package existing in all the view are solved
int nviews = lv.count();
QStringList deleted_or_new;
Q3DictIterator<Use> itu(all_nodes);
for (; itu.current(); ++itu) {
QString who = itu.currentKey();
Use * use = itu.current();
if (use->count == nviews) {
// exist in all views : solve the state
if (use->rev_min == use->rev_max) {
// up to date in all views
for (itv.toFirst(); itv.current(); ++itv)
itv.current()->nodes.find(who)->set_state(UpToDate);
}
else {
int max = use->rev_max;
for (itv.toFirst(); itv.current(); ++itv) {
BrowserNode * pack = itv.current()->nodes.find(who);
pack->set_state((pack->get_rev() == max) ? Young : Old);
}
}
}
else {
// deleted or new, mark it unknown for this step
deleted_or_new.append(who);
for (itv.toFirst(); itv.current(); ++itv) {
BrowserNode * pack = itv.current()->nodes.find(who);
if (pack != 0)
pack->set_state(Unknown);
}
}
}
all_nodes.clear();
// solve packages marked unknown
// a package is deleted if its parent is never 'Young'
QStringList::Iterator it;
for (it = deleted_or_new.begin(); it != deleted_or_new.end(); ++it) {
QString who = *it;
Q3PtrList<BrowserNode> images;
bool young = FALSE;
// set the state in each view without looking at the others
for (itv.toFirst(); itv.current(); ++itv) {
BrowserNode * pack = itv.current()->nodes.find(who);
if (pack != 0) {
images.append(pack);
if (pack->solve())
young = TRUE;
}
}
// set the final state if young, else all already marked deleted
if (young) {
BrowserNode * pack;
for (pack = images.first(); pack != 0; pack = images.next())
pack->set_state(Young);
}
}
// force update on views
for (itv.toFirst(); itv.current(); ++itv)
itv.current()->update_it();
}
int _tmain(int argc, _TCHAR* argv[])
{
vector<vector<ClassifiedSample*>*> performance_lists(0);
MNIST_Generate_Validation_Performance_Lists_Vector(performance_lists);
vector<vector<ClassifiedSample*>*> test_performance_lists(0);
MNIST_Generate_Test_Performance_Lists_Vector(test_performance_lists);
vector<CascadeNode*> all_nodes(0);
MNIST_Generate_CascadeNodes_Vector(all_nodes);
for(int i=0; i<all_nodes.size(); i++)
{
all_nodes[i]->performance_list= performance_lists[i];
all_nodes[i]->test_performance_list= test_performance_lists[i];
}
vector<CascadeNode*> best_cascade(0);
float best_cascade_theoretical_complexity;
Build_Cascade_ModelBased(
/*vector<CascadeNode*>&*/ all_nodes, //from which we build the best cascade
/*vector<CascadeNode*>&*/ best_cascade,
/*float&*/ best_cascade_theoretical_complexity
);
cout<<endl<<endl<<"Best Cascade:"<<endl;
cout<<"Thresholds: ";
for(int i=0; i<best_cascade.size(); i++)
cout<<best_cascade[i]->ID<<": "<<best_cascade[i]->thresh<<", "<<endl;
cout<<endl<<"Theoretical Complexity: "<<best_cascade_theoretical_complexity<<endl;
ofstream fout("Model_Based_All_Stages_Results.txt");
float complexity(0);
float error(0);
float final_stage_complexity(0);
float final_stage_error(0);
float rej(0);
//Calculating actual complexity and error on validation set
Evaluate_Cascade_Performance_OnValidation(
best_cascade,
complexity,
error,
final_stage_complexity,
final_stage_error,
rej
);
cout<<"On Validation:"<<endl;
cout<<"Error of most complex classifier: "<<final_stage_error<<endl;
cout<<"Complexity of most complex classifier: "<<final_stage_complexity<<endl;
cout<<"Actual Error= "<<error<<endl;
cout<<"Actual Complexity= "<<complexity<<endl;
cout<<endl<<endl;
fout<<"On Validation:"<<endl;
fout<<"Error of most complex classifier: "<<final_stage_error<<endl;
fout<<"Complexity of most complex classifier: "<<final_stage_complexity<<endl;
fout<<"Actual Error= "<<error<<endl;
fout<<"Actual Complexity= "<<complexity<<endl;
fout<<endl<<endl;
//Calculating actual complexity and error on test set
Evaluate_Cascade_Performance_OnTest(
best_cascade,
complexity,
error,
final_stage_complexity,
final_stage_error,
rej
);
cout<<"On Test:"<<endl;
cout<<"Error of most complex classifier: "<<final_stage_error<<endl;
cout<<"Complexity of most complex classifier: "<<final_stage_complexity<<endl;
cout<<"Actual Error= "<<error<<endl;
cout<<"Actual Complexity= "<<complexity<<endl;
cout<<endl<<endl;
fout<<"On Test:"<<endl;
fout<<"Error of most complex classifier: "<<final_stage_error<<endl;
fout<<"Complexity of most complex classifier: "<<final_stage_complexity<<endl;
fout<<"Actual Error= "<<error<<endl;
fout<<"Actual Complexity= "<<complexity<<endl;
fout<<endl<<endl;
cout<<"Done."<<endl;
getch();
return 0;
}
int FMM_Init(MPI_Comm& comm, FMMData *fmm_data){
int myrank, np;
MPI_Comm_rank(comm, &myrank);
MPI_Comm_size(comm,&np);
FMM_Mat_t *fmm_mat=new FMM_Mat_t;
FMM_Tree_t* tree=new FMM_Tree_t(comm);
//Kernel function
const pvfmm::Kernel<double>* kernel;
if(INPUT_DOF==1) kernel=pvfmm::LaplaceKernel<double>::potn_ker;
else if(INPUT_DOF==2) kernel=&pvfmm::ker_helmholtz;
else if(INPUT_DOF==3) kernel=&pvfmm::ker_stokes_vel;
//Setup FMM data structure.
int mult_order=MUL_ORDER;
int cheb_deg=CHEB_DEG;
bool adap=true;
double tol=TOL;
pvfmm::BoundaryType bndry=pvfmm::FreeSpace;
if(PERIODIC==PETSC_TRUE) bndry=pvfmm::Periodic;
typename FMMNode_t::NodeData tree_data;
{ // Tree Construction (eta).
FMM_Tree_t* tree=new FMM_Tree_t(comm);
//Various parameters.
tree_data.dim=COORD_DIM;
tree_data.max_depth=MAXDEPTH;
tree_data.cheb_deg=cheb_deg;
//Set input function pointer
tree_data.input_fn=eta;
tree_data.data_dof=1;
tree_data.tol=tol*fabs(eta_);
std::vector<double> pt_coord;
{ //Set source coordinates.
size_t NN=ceil(pow((double)np,1.0/3.0));
NN=std::max<size_t>(NN,pow(2.0,MINDEPTH));
size_t N_total=NN*NN*NN;
size_t start= myrank *N_total/np;
size_t end =(myrank+1)*N_total/np;
for(size_t i=start;i<end;i++){
pt_coord.push_back(((double)((i/ 1 )%NN)+0.5)/NN);
pt_coord.push_back(((double)((i/ NN )%NN)+0.5)/NN);
pt_coord.push_back(((double)((i/(NN*NN))%NN)+0.5)/NN);
}
tree_data.pt_coord=pt_coord;
}
tree_data.max_pts=1; // Points per octant.
//Create Tree and initialize with input data.
tree->Initialize(&tree_data);
tree->InitFMM_Tree(adap,bndry);
// this is getting the center coordinates of each of the nodes of the octree?
pt_coord.clear();
std::vector<FMMNode_t*> nlist=tree->GetNodeList();
for(size_t i=0;i<nlist.size();i++){
if(nlist[i]->IsLeaf() && !nlist[i]->IsGhost()){
double s=pow(0.5,nlist[i]->Depth()+1);
double* c=nlist[i]->Coord();
pt_coord.push_back(c[0]+s);
pt_coord.push_back(c[1]+s);
pt_coord.push_back(c[2]+s);
}
}
tree_data.pt_coord=pt_coord;
tree->Write2File("results/eta",VTK_ORDER);
FMM_Tree_t* eta_tree = tree;
fmm_data->eta_tree = eta_tree;
//delete tree;
}
//new
// typename FMMNode_t::NodeData tree_data;
//Various parameters.
// tree_data.dim=COORD_DIM;
// tree_data.max_depth=MAXDEPTH;
// tree_data.cheb_deg=cheb_deg;
{ // Tree Construction.
bool adap=true;
// Manually setting the coordinates where we evaluate the function?
std::vector<double> pt_coord;
{ //Set source coordinates.
size_t NN=ceil(pow((double)np,1.0/3.0));
NN=std::max<size_t>(NN,pow(2.0,MINDEPTH));
size_t N_total=NN*NN*NN;
size_t start= myrank *N_total/np;
size_t end =(myrank+1)*N_total/np;
for(size_t i=start;i<end;i++){
pt_coord.push_back(((double)((i/ 1 )%NN)+0.5)/NN);
pt_coord.push_back(((double)((i/ NN )%NN)+0.5)/NN);
pt_coord.push_back(((double)((i/(NN*NN))%NN)+0.5)/NN);
}
tree_data.pt_coord=pt_coord;
}
tree_data.max_pts=1; // Points per octant.
//old
//
//Set input function pointer
tree_data.input_fn=fn_input;
tree_data.data_dof=kernel->ker_dim[0];
tree_data.tol=tol*f_max;
//Create Tree and initialize with input data.
tree->Initialize(&tree_data);
tree->InitFMM_Tree(adap,bndry);
//std::vector<double> pt_coord; Again getting the point coordinates of the centers of the nodes of the octree?
pt_coord.clear();
std::vector<FMMNode_t*> nlist=tree->GetNodeList();
for(size_t i=0;i<nlist.size();i++){
if(nlist[i]->IsLeaf() && !nlist[i]->IsGhost()){
double s=pow(0.5,nlist[i]->Depth()+1);
double* c=nlist[i]->Coord();
pt_coord.push_back(c[0]+s);
pt_coord.push_back(c[1]+s);
pt_coord.push_back(c[2]+s);
}
}
tree_data.pt_coord=pt_coord;
{ //Output max tree depth.
std::vector<size_t> all_nodes(MAXDEPTH+1,0);
std::vector<size_t> leaf_nodes(MAXDEPTH+1,0);
std::vector<FMMNode_t*>& nodes=tree->GetNodeList();
for(size_t i=0;i<nodes.size();i++){
FMMNode_t* n=nodes[i];
if(!n->IsGhost()) all_nodes[n->Depth()]++;
if(!n->IsGhost() && n->IsLeaf()) leaf_nodes[n->Depth()]++;
}
if(!myrank) std::cout<<"All Nodes: ";
for(int i=0;i<MAXDEPTH;i++){
int local_size=all_nodes[i];
int global_size;
MPI_Allreduce(&local_size, &global_size, 1, MPI_INT, MPI_SUM, comm);
if(global_size==0) MAXDEPTH=i;
if(!myrank) std::cout<<global_size<<' ';
}
if(!myrank) std::cout<<'\n';
if(!myrank) std::cout<<"Leaf Nodes: ";
for(int i=0;i<MAXDEPTH;i++){
int local_size=leaf_nodes[i];
int global_size;
MPI_Allreduce(&local_size, &global_size, 1, MPI_INT, MPI_SUM, comm);
if(!myrank) std::cout<<global_size<<' ';
}
if(!myrank) std::cout<<'\n';
}
}
size_t n_coeff3=(cheb_deg+1)*(cheb_deg+2)*(cheb_deg+3)/6;
size_t n_nodes3=(cheb_deg+1)*(cheb_deg+1)*(cheb_deg+1);
PetscInt m=0,n=0,M=0,N=0,l=0,L=0;
{ // Get local and global size
long long loc_size=0, glb_size=0;
long long loc_nodes=0, glb_nodes=0;
std::vector<FMMNode_t*> nlist=tree->GetNodeList();
for(size_t i=0;i<nlist.size();i++){
if(nlist[i]->IsLeaf() && !nlist[i]->IsGhost()){
loc_size+=n_coeff3; //nlist[i]->ChebData().Dim();
loc_nodes+=n_nodes3;
}
}
MPI_Allreduce(&loc_size, &glb_size, 1, MPI_LONG_LONG , MPI_SUM, comm);
MPI_Allreduce(&loc_nodes, &glb_nodes, 1, MPI_LONG_LONG, MPI_SUM, comm);
n=loc_size*kernel->ker_dim[0];
N=glb_size*kernel->ker_dim[0];
m=loc_size*kernel->ker_dim[1];
M=glb_size*kernel->ker_dim[1];
l=loc_nodes*kernel->ker_dim[0];
L=glb_nodes*kernel->ker_dim[0];
std::cout << L << std::endl;
num_oct=glb_size/n_coeff3;
}
if(TREE_ONLY) return 0;
//Initialize FMM_Mat.
fmm_mat->Initialize(mult_order,cheb_deg,comm,kernel);
fmm_data->kernel =kernel ;
fmm_data->fmm_mat=fmm_mat;
fmm_data->tree =tree ;
fmm_data->bndry =bndry ;
fmm_data->m=m;
fmm_data->n=n;
fmm_data->M=M;
fmm_data->N=N;
fmm_data->l=l;
fmm_data->L=L;
return 0;
}
