Beispiel #1
0
Constraint::Constraint()
: Value(0.0),
  Type(None),
  AlignmentType(Undef),
  Name(""),
  First(GeoUndef),
  FirstPos(none),
  Second(GeoUndef),
  SecondPos(none),
  Third(GeoUndef),
  ThirdPos(none),
  LabelDistance(10.f),
  LabelPosition(0.f),
  isDriving(true),
  InternalAlignmentIndex(-1),
  isInVirtualSpace(false)
{
    // Initialize a random number generator, to avoid Valgrind false positives.
    static boost::mt19937 ran;
    static bool seeded = false;

    if (!seeded) {
        ran.seed(QDateTime::currentMSecsSinceEpoch() & 0xffffffff);
        seeded = true;
    }
    static boost::uuids::basic_random_generator<boost::mt19937> gen(&ran);

    tag = gen();
}
Beispiel #2
0
void UPGMpp::getRandomAssignation(CGraph &graph,
                                  map<size_t,size_t> &assignation,
                                  TInferenceOptions &options )
{
    static boost::mt19937 rng1;
    static bool firstExecution = true;

    if ( firstExecution )
    {
        rng1.seed(std::time(0));
        firstExecution = false;
    }

    vector<CNodePtr> &nodes = graph.getNodes();

    for ( size_t node = 0; node < nodes.size(); node++ )
    {
        // TODO: Check if a node has a fixed value and consider it

        size_t N_classes = nodes[node]->getType()->getNumberOfClasses();

        boost::uniform_int<> generator(0,N_classes-1);
        int state = generator(rng1);

        assignation[nodes[node]->getID()] = state;
    }

    /*map<size_t,size_t>::iterator it;
    for ( it = assignation.begin(); it != assignation.end(); it++ )
        cout << "[" << it->first << "] " << it->second << endl;*/
}
Beispiel #3
0
std::vector<T1> generateRandomSet(const unsigned int size_,
								  const T1 min_,
								  const T1 max_,
								  const bool allowRepetition_)
{
	generator.seed(std::rand());

#if BOOST_MINOR_VERSION <= 46
	NumberType range(min_, max_);
	boost::variate_generator<Generator&, NumberType> dist(generator, range);
#else
	Generator dist(min_, max_);
#endif

	std::vector<T1> numbers;
	numbers.reserve(size_);

	std::map<T1, bool> used;
	while (numbers.size() < size_)
	{
#if BOOST_MINOR_VERSION <= 46
		T1 number = dist();
#else
		T1 number = dist(generator);
#endif

		if (allowRepetition_ || used.find(number) == used.end())
		{
			used[number] = true;
			numbers.push_back(number);
		}
	}

	return numbers;
}
	void readSeed(boost::program_options::variables_map& variableMap, boost::mt19937& randomSource)
	{
		if(variableMap.count("seed") > 0)
		{
			randomSource.seed(variableMap["seed"].as<int>());
		}
	}
	void setUp() {
		randomGen.seed(time(NULL));
		eventLoop = new DummyEventLoop();
		timerFactory = new DummyTimerFactory();
		connection = boost::make_shared<MockeryConnection>(failingPorts, true, eventLoop);
		//connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));
		//stream1 = boost::make_shared<ByteArrayReadBytestream>(createByteArray("abcdefg")));
//		connection->onDataRead.connect(boost::bind(&SOCKS5BytestreamClientSessionTest::handleDataRead, this, _1));
	}
	void setUp() {
		crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());
		destination = "092a44d859d19c9eed676b551ee80025903351c2";
		randomGen.seed(static_cast<unsigned int>(time(NULL)));
		eventLoop = new DummyEventLoop();
		timerFactory = new DummyTimerFactory();
		connection = boost::make_shared<MockeryConnection>(failingPorts, true, eventLoop);
		//connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));
		//stream1 = boost::make_shared<ByteArrayReadBytestream>(createByteArray("abcdefg")));
//		connection->onDataRead.connect(boost::bind(&SOCKS5BytestreamClientSessionTest::handleDataRead, this, _1));
	}
Beispiel #7
0
  void init ()
  {
    std::chrono::high_resolution_clock::time_point now =
      std::chrono::high_resolution_clock::now();

    std::chrono::nanoseconds time =
      std::chrono::duration_cast<std::chrono::nanoseconds>
      (now.time_since_epoch () );

    ran.seed (time.count() );

    pid = getpid();
  }
Beispiel #8
0
int Utils::getRandomNumber(const int min_,
						   const int max_)
{
	generator.seed(std::time(0));

#if BOOST_MINOR_VERSION <= 46
	boost::uniform_int<> range(min_, max_);
	boost::variate_generator<boost::mt19937&, boost::uniform_int<> > dist(generator, range);
	return dist();
#else
	boost::random::uniform_int_distribution<> dist(min_, max_);
	return dist(generator);
#endif
}
Beispiel #9
0
void parse_args(int argc, char* argv[]) {
  uint32_t seed = 0;
  bool has_seed = false;

  struct option long_opts[] = {
    { "help", false, nullptr, 'h' },
    { "seed", true, nullptr, 's' },
    { nullptr, 0, nullptr, 0 }
  };

  while (true) {
    optopt = 1;
    int optchar = getopt_long(argc, argv, "hs:", long_opts, nullptr);
    if (optchar == -1) {
      break;
    }

    switch (optchar) {
      case 's': {
        char *endptr;
        seed = strtol(optarg, &endptr, 0);
        if (endptr == optarg || *endptr != '\0') {
          fprintf(stderr, "invalid seed value \"%s\": must be a positive "
                  "integer\n", optarg);
          exit(1);
        }
        has_seed = true;
        break;
      }
      case 'h':
        print_usage(stdout, argv[0]);
        exit(0);
      case '?':
        exit(1);
      default:
        // Only happens if someone adds another option to the optarg string,
        // but doesn't update the switch statement to handle it.
        fprintf(stderr, "unknown option \"-%c\"\n", optchar);
        exit(1);
    }
  }

  if (!has_seed) {
    seed = time(nullptr);
  }

  printf("seed: %" PRIu32 "\n", seed);
  rng.seed(seed);
}
Beispiel #10
0
boost::unit_test::test_suite* init_unit_test_suite(int argc, char* argv[]) {
  THRIFT_UNUSED_VARIABLE(argc);
  THRIFT_UNUSED_VARIABLE(argv);
  uint32_t seed = static_cast<uint32_t>(time(NULL));
  printf("seed: %" PRIu32 "\n", seed);
  rng.seed(seed);

  boost::unit_test::test_suite* suite = &boost::unit_test::framework::master_test_suite();
  suite->p_name.value = "ZlibTest";

  uint32_t buf_len = 1024 * 32;
  add_tests(suite, gen_uniform_buffer(buf_len, 'a'), buf_len, "uniform");
  add_tests(suite, gen_compressible_buffer(buf_len), buf_len, "compressible");
  add_tests(suite, gen_random_buffer(buf_len), buf_len, "random");

  suite->add(BOOST_TEST_CASE(test_no_write));

  return NULL;
}
Beispiel #11
0
bool init_unit_test_suite() {
  uint32_t seed = static_cast<uint32_t>(time(NULL));
#ifdef HAVE_INTTYPES_H
  printf("seed: %" PRIu32 "\n", seed);
#endif
  rng.seed(seed);

  boost::unit_test::test_suite* suite = &boost::unit_test::framework::master_test_suite();
  suite->p_name.value = "ZlibTest";

  uint32_t buf_len = 1024 * 32;
  add_tests(suite, gen_uniform_buffer(buf_len, 'a'), buf_len, "uniform");
  add_tests(suite, gen_compressible_buffer(buf_len), buf_len, "compressible");
  add_tests(suite, gen_random_buffer(buf_len), buf_len, "random");

  suite->add(BOOST_TEST_CASE(test_no_write));

  return true;
}
Beispiel #12
0
float normalvariate(float mean, float sigma)
{
    static bool seeded = false;

    if (!seeded)
    {
        // seed generator with #seconds since 1970
        rng.seed(static_cast<unsigned> (std::time(0)));
        seeded = true;
    }

    // select desired probability distribution
    boost::normal_distribution<float> norm_dist(mean, sigma);

    // bind random number generator to distribution, forming a function
    boost::variate_generator<boost::mt19937&, boost::normal_distribution<float> >  normal_sampler(rng, norm_dist);

    // sample from the distribution
    return normal_sampler();
}
Beispiel #13
0
int main (int argc, char const *argv[]) {
  // The default maze size is 20x10.  A different size may be specified on
  // the command line.
  std::size_t x = 20;
  std::size_t y = 10;

  if (argc == 3) {
    x = boost::lexical_cast<std::size_t>(argv[1]);
    y = boost::lexical_cast<std::size_t>(argv[2]);
  }

  random_generator.seed(std::time(0));
  maze m(x, y);
  random_maze(m);
  if (m.solve())
    std::cout << "Solved the maze." << std::endl;
  else
    std::cout << "The maze is not solvable." << std::endl;
  std::cout << m << std::endl;
  return 0;
}
Beispiel #14
0
int main() {
    rnd.seed(42);
    vertex_iterator vi,vi_end;
    Graph m_graph;

    auto start = chrono::high_resolution_clock::now();
    generate_random_graph(m_graph, 1000/*00*/, 500/*00*/, rnd); // reduced load for Coliru

    std::cout << "Generated " << num_vertices(m_graph) << " vertices and " << num_edges(m_graph) << " edges in "
        << chrono::duration_cast<chrono::milliseconds>(chrono::high_resolution_clock::now() - start).count() << "ms\n"
        << "The graph has a cycle? " << std::boolalpha << has_cycle(m_graph) << "\n"
        << "starting selective removal...\n";

    start = chrono::high_resolution_clock::now();
    size_t count = 0;
    for (boost::tie(vi, vi_end) = boost::vertices(m_graph); vi!=vi_end;)
    {
        if (m_graph[*vi].guid.part1 == 0) {
            count++;
            clear_vertex(*vi, m_graph);
            //std::cout << "." << std::flush;
#if defined(STABLE_IT)
            auto toremove = vi++;
            boost::remove_vertex(*toremove,m_graph);
#else
            boost::remove_vertex(*vi,m_graph);
            boost::tie(vi, vi_end) = boost::vertices(m_graph);
#endif
        } else 
            ++vi;
    }

    std::cout << "Done in " << chrono::duration_cast<chrono::milliseconds>(
            chrono::high_resolution_clock::now() - start).count() << "ms\n";

    std::cout << "After: " << num_vertices(m_graph) << " vertices and " << num_edges(m_graph) << " edges\n";
}
Beispiel #15
0
int main(int argc, char ** argv)
{
	using namespace std;
	using namespace boost;

	if(argc <= 3) {
		cout << "usage: " << argv[0] << " <grid size> <time> <runs>" << endl;
		return -1;
	}

	int system_random = open("/dev/random", O_RDONLY);
	uint32_t seed;
	read(system_random, &seed, 4);
	close(system_random);

	rng.seed(seed);

	for(int count = 0; count < atoi(argv[3]);) {
		grid_lattice grid(atoi(argv[1]));
		while(true) {
			double dt = grid.next_event();
			grid.time += dt;
			if(grid.time > atof(argv[2])) break;
			grid.flip();
			if(grid.empty()) grid.restart();
		}

		if(!grid.empty()) {
			cout << grid.size() << endl;
//			cout << grid << endl;
			count++;
		}
	}

	return 0;
}
void RandBipartiteGraph::GenerateGraph()
{
    // make n left-vertices
    for(unsigned int i = 0; i < n; i++){
        AddVariable(i);
    }

    vector<Vertex*> availableVertexList;
    availableVertexList.reserve(n);
    gen.seed(time(NULL));

    if (c%d != 0){
    // make c/d n right-vertices
        for(unsigned int i = 0; i < GetRightVerticesNumber(); i++){
            availableVertexList.push_back(static_cast<Vertex*>(AddConstraint(i)));
        }
    }

    for (unsigned int i = 0; i < n; i++){
        for(unsigned int j = 0; j < c; j++){
        	AddEdge(static_cast<Vertex*>(variables[i]), GetRandRightVertex(availableVertexList));
        }
    }
}
Beispiel #17
0
void mexFunction( int nlhs, mxArray *plhs[],
                  int nrhs, const mxArray *prhs[] )
{
//int main(int ac, char* av[]){

  // global objects for the program:
  /*Cogaps_options_class Cogaps_options(ac, av);
  try {
    // Cogaps_options_class Cogaps_options(ac, av); // WS -- change from Sasha's
    if (Cogaps_options.to_help){
      Cogaps_options.help(cout);
      return 0;
    }
    //cout << Cogaps_options; 
  } 
  catch( const exception & e) {
    cerr <<e.what()<<endl;
    return 1;
  }
*/
  // ===========================================================================
  // Initialization of the random number generator.
  // Different seeding methods:
  // --- fixed seed 
  //std::vector<unsigned long> ve(2);
  //ve[0]=198782;ve[1]=89082;
  //boost::random::seed_seq seq(ve);
  //rng.seed(seq);
  // --- seeded with time
  rng.seed(static_cast<boost::uint32_t>(std::time(0)));
  //---------------------

  // ===========================================================================
  // Part 1) Initialization: 
  // In this section, we read in the system parameters from the paremter file
  // parameter.txt, and matrices D and S from datafile.txt. 
  // Then we initialize A and P in both their atomic domains and 
  // matrix forms.
  // ===========================================================================
	
	//Matlab pointers for inputs
    mxArray* DArrayElems;
	mxArray* SArrayElems;
	mxArray* InputColsPtr;
	mxArray* InputRowsPtr;

	//Matlab pointers for config 
	mxArray* nFactorPtr;
	mxArray* simulationIDPtr;
	mxArray* nEquilPtr;
	mxArray* nSamplePtr;
	mxArray* QAtomicPtr;
	mxArray* alphaAPtr;
	mxArray* nIterAPtr;
	mxArray* nMaxAPtr;
	mxArray* maxGibbsAPtr;
	mxArray* lambdaAScalePtr;
	mxArray* alphaPPtr;
	mxArray* nIterPPtr;
	mxArray* nMaxPPtr;
	mxArray* maxGibbsPPtr;
	mxArray* lambdaPScalePtr;
	
	//Transferring inputs from mex gateway to pointers
	DArrayElems = mxGetCell(prhs[0], 0);
	SArrayElems = mxGetCell(prhs[0], 1);
	InputColsPtr = mxGetCell(prhs[0], 2);
	InputRowsPtr = mxGetCell(prhs[0], 3);
	nFactorPtr = mxGetCell(prhs[0], 4);
	simulationIDPtr = mxGetCell(prhs[0], 5);
	nEquilPtr = mxGetCell(prhs[0], 6);
	nSamplePtr = mxGetCell(prhs[0], 7);
	QAtomicPtr = mxGetCell(prhs[0], 8);
	alphaAPtr = mxGetCell(prhs[0], 9);
	nIterAPtr = mxGetCell(prhs[0], 10);
	nMaxAPtr = mxGetCell(prhs[0], 11);
	maxGibbsAPtr = mxGetCell(prhs[0], 12);
	lambdaAScalePtr = mxGetCell(prhs[0], 13);
	alphaPPtr = mxGetCell(prhs[0], 14);
	nIterPPtr = mxGetCell(prhs[0], 15);
	nMaxPPtr = mxGetCell(prhs[0], 16);
	maxGibbsPPtr = mxGetCell(prhs[0], 17);
	lambdaPScalePtr = mxGetCell(prhs[0], 18);
	
	
	//creating native C style data types
	double* DArray;
	double* SArray;
	double* numInputRows;
	double* numInputCols;
	
	//Establish the C types for the Config Information
	double* nFactorC = mxGetPr(nFactorPtr);
	
	int ptrLength; 
	char* simulationIDC;
	ptrLength = mxGetNumberOfElements(simulationIDPtr) + 1;
	simulationIDC = (char *)(mxCalloc(ptrLength, sizeof(char)));
	mxGetString(simulationIDPtr, simulationIDC, ptrLength);
	
	double* nEquilC = mxGetPr(nEquilPtr);
	double* nSampleC = mxGetPr(nSamplePtr);
	double* QAtomicC = mxGetPr(QAtomicPtr);
	double* alphaAC = mxGetPr(alphaAPtr);
	double* nIterAC = mxGetPr(nIterAPtr);
	double* nMaxAC = mxGetPr(nMaxAPtr);
	double* maxGibbsAC = mxGetPr(maxGibbsAPtr);
	double* lambdaAScaleC = mxGetPr(lambdaAScalePtr);
	double*	alphaPC = mxGetPr(alphaPPtr);
	double*	nIterPC = mxGetPr(nIterPPtr);
	double* nMaxPC = mxGetPr(nMaxPPtr);
	double* maxGibbsPC = mxGetPr(maxGibbsPPtr);
	double* lambdaPScaleC = mxGetPr(lambdaPScalePtr);
	
	int nIRows;
	int nICols;
	
	
	
	//converting from pointer to matlab type then to C array
	DArray = mxGetPr(DArrayElems);
	SArray = mxGetPr(SArrayElems);
	numInputCols = mxGetPr(InputRowsPtr);
	numInputRows = mxGetPr(InputColsPtr);
	
	//removing need for arrays for dimensions
	nIRows = numInputRows[0];
	nICols = numInputCols[0];
	
	//Putting C style arrays into C++ vectors to pass to the Gibbs Sampler
	vector< vector<double> > DVector(nIRows, vector<double>(nICols));
	vector< vector<double> > SVector(nIRows, vector<double>(nICols));
	
	for(int i = 0; i < nIRows; i++)
	{
		for(int j = 0; j < nICols; j++)
		{
			DVector[i][j] = DArray[i + (j*nIRows)];
		}
	}
	
	for(int i = 0; i < nIRows; i++)
	{
		for(int j = 0; j < nICols; j++)
		{
			SVector[i][j] = SArray[i + (j*nIRows)];
		}
	}
	
	/*Testing output of matrices
	cout << endl;
	for(int i = 0; i < nIRows; i++)
	{
		for(int j = 0; j < nICols; j++)
		{
			cout << DVector[i][j] << " ";
		}
		cout << endl;
	}
	
	cout << endl;
	for(int i = 0; i < nIRows; i++)
	{
		for(int j = 0; j < nICols; j++)
		{
			cout << SVector[i][j] << " ";
		}
		cout << endl;
	}
	*/
	
  // Parameters or data to be read in:
  unsigned long nEquil = nEquilC[0]; //Cogaps_options.nEquil;    // # outer loop iterations 
                                                   // for equilibration
  unsigned long nSample = nSampleC[0];//Cogaps_options.nSample;  // # outer loop iterations 
                                                   // for sampling
  unsigned int nFactor = nFactorC[0]; //Cogaps_options.nFactor;   // # patterns
  double alphaA = alphaAC[0]; //Cogaps_options.alphaA;
  double alphaP = alphaPC[0]; //Cogaps_options.alphaP;
  double nMaxA = nMaxAC[0];//Cogaps_options.nMaxA;             // max. number of atoms in A
  double nMaxP = nMaxPC[0];//Cogaps_options.nMaxP;             // number of atomic bins for P
  //string datafile = "Data2.txt";//Cogaps_options.datafile;        // File for D
  //string variancefile = "Noise2.txt";//Cogaps_options.variancefile; // File for S
  string simulation_id = simulationIDC;//Cogaps_options.simulation_id; // simulation id
  unsigned long nIterA = nIterAC[0];//Cogaps_options.nIterA;    // initial # of inner-loop iterations for A 
  unsigned long nIterP = nIterPC[0];//Cogaps_options.nIterP;    // initial # of inner-loop iterations for P 
  double max_gibbsmass_paraA = maxGibbsAC[0];//Cogaps_options.max_gibbsmass_paraA; 
                           // maximum gibbs mass parameter for A 
  double max_gibbsmass_paraP = maxGibbsPC[0];//Cogaps_options.max_gibbsmass_paraP; 
                           // maximum gibbs mass parameter for P 
  double lambdaA_scale_factor = lambdaAScaleC[0];//Cogaps_options.lambdaA_scale_factor;
                           // scale factor for lambdaA
  double lambdaP_scale_factor = lambdaPScaleC[0];//Cogaps_options.lambdaP_scale_factor;
                           // scale factor for lambdaP
  bool Q_output_atomic = QAtomicC[0];//Cogaps_options.Q_output_atomic;
                           // whether to output the atomic space info

  // Parameters or structures to be calculated or constructed:
  unsigned int nRow;       // number of items in observation (= # of genes)
  unsigned int nCol;       // number of observation (= # of arrays)
  unsigned int nBinsA;     // number of atomic bins for A
  unsigned int nBinsP;     // number of atomic bins for P
  double lambdaA;
  double lambdaP;
  //unsigned long nIterA;    // number of inner loop iterations for A
  //unsigned long nIterP;    // number of inner loop iterations for P  
  //atomic At, Pt;           // atomic space for A and P respectively
  unsigned long atomicSize; // number of atomic points

  char label_A = 'A';  // label for matrix A
  char label_P = 'P';  // label for matrix P
  char label_D = 'D';  // label for matrix D
  char label_S = 'S';// label for matrix S

  // Output parameters and computing info to files:
  /* Commented out for Matlab and R Versions
  char outputFilename[80];
  strcpy(outputFilename,simulation_id.c_str());
  strcat(outputFilename,"_computing_info.txt");
  
 
  ofstream outputFile;
  outputFile.open(outputFilename,ios::out);  // start by deleting previous content and 
                                             // rewriting the file
  outputFile << "Common parameters and info:" << endl;
  outputFile << "input data file: " << datafile << endl;
  outputFile << "input variance file: " << variancefile << endl;
  outputFile << "simulation id: " << simulation_id << endl;
  outputFile << "nFactor = " << nFactor << endl;
  outputFile << "nEquil = " << nEquil << endl;
  outputFile << "nSample = " << nSample << endl;
  outputFile << "Q_output_atomic (bool) = " << Q_output_atomic << endl << endl;

  outputFile << "Parameters for A:" << endl;
  outputFile << "alphaA = " << alphaA << endl;
  outputFile << "nMaxA = " << nMaxA << endl;
  outputFile << "nIterA = " << nIterA << endl;
  outputFile << "max_gibbsmass_paraA = " << max_gibbsmass_paraA << endl;
  outputFile << "lambdaA_scale_factor = " << lambdaA_scale_factor << endl << endl;

  outputFile << "Parameters for P:" << endl;
  outputFile << "alphaP = " << alphaP << endl;
  outputFile << "nMaxP = " << nMaxP << endl;
  outputFile << "nIterP = " << nIterP << endl;
  outputFile << "max_gibbsmass_paraP = " << max_gibbsmass_paraP << endl;
  outputFile << "lambdaP_scale_factor = " << lambdaP_scale_factor << endl << endl;

  outputFile.close();
  */



  // ---------------------------------------------------------------------------
  // Initialize the GibbsSampler.

  /*Regular Version
  GibbsSampler GibbsSamp(nEquil,nSample,nFactor,   // construct GibbsSampler and 
                         alphaA,alphaP,nMaxA,nMaxP,// Read in D and S matrices
                         nIterA,nIterP,
			 max_gibbsmass_paraA, max_gibbsmass_paraP, 
			 lambdaA_scale_factor, lambdaP_scale_factor,
                         atomicSize,
                         label_A,label_P,label_D,label_S,
			 datafile,variancefile,simulation_id);
	*/
	
	//R and Matlab Version
	GibbsSampler GibbsSamp(nEquil,nSample,nFactor,   // construct GibbsSampler and 
                         alphaA,alphaP,nMaxA,nMaxP,// Read in D and S matrices
                         nIterA,nIterP,
			 max_gibbsmass_paraA, max_gibbsmass_paraP, 
			 lambdaA_scale_factor, lambdaP_scale_factor,
                         atomicSize,
                         label_A,label_P,label_D,label_S,
			 DVector,SVector,simulation_id);

  // ---------------------------------------------------------------------------
  // Based on the information of D, construct and initialize for A and P both 
  // the matrices and atomic spaces.

  GibbsSamp.init_AMatrix_and_PMatrix(); // initialize A and P matrices
  GibbsSamp.init_AAtomicdomain_and_PAtomicdomain(); // intialize atomic spaces
                                                    // A and P
  GibbsSamp.init_sysChi2(); // initialize the system chi2 value

  // ===========================================================================
  // Part 2) Equilibration:
  // In this section, we let the system eqilibrate with nEquil outer loop 
  // iterations. Within each outer loop iteration, A is iterated nIterA times 
  // and P is iterated nIterP times. After equilibration, we update nIterA and 
  // nIterP according to the expected number of atoms in the atomic spaces 
  // of A and P respectively.
  // ===========================================================================
  
      // --------- temp for initializing output to chi2.txt
	  /*
      char outputchi2_Filename[80];
      strcpy(outputchi2_Filename,simulation_id.c_str());
      strcat(outputchi2_Filename,"_chi2.txt");
      ofstream outputchi2_File;
      outputchi2_File.open(outputchi2_Filename,ios::out);
      outputchi2_File << "chi2" << endl;
      outputchi2_File.close();
	  */
      // --------------
      


  double chi2;
  //Matlab control variables 
  double tempChiSq;
  double tempAtomA;
  double tempAtomP;
	int outCount = 0;
	int numOutputs = 100; 
	int totalChiSize = nSample + nEquil;
	
	//Establishing Matlab containers for atoms and chisquare
	double* nAEquil;
	mxArray* nAEMx;
	nAEMx = mxCreateDoubleMatrix(1, nEquil, mxREAL);
	nAEquil = mxGetPr(nAEMx);
	
	double* nASamp;
	mxArray* nASMx;
	nASMx = mxCreateDoubleMatrix(1, nSample, mxREAL);
	nASamp = mxGetPr(nASMx);
	
	double* nPEquil;
	mxArray* nPEMx;
	nPEMx = mxCreateDoubleMatrix(1, nEquil, mxREAL);
	nPEquil = mxGetPr(nPEMx);
	
	double* nPSamp;
	mxArray* nPSMx;
	nPSMx = mxCreateDoubleMatrix(1, nSample, mxREAL);
	nPSamp = mxGetPr(nPSMx);
	
	double* chiVect;
	mxArray* chiMx;
	chiMx = mxCreateDoubleMatrix(1, totalChiSize, mxREAL);
	chiVect = mxGetPr(chiMx);
	

  for (unsigned long ext_iter=1; ext_iter <= nEquil; ++ext_iter){
    GibbsSamp.set_iter(ext_iter);
    GibbsSamp.set_AnnealingTemperature();


    for (unsigned long iterA=1; iterA <= nIterA; ++iterA){
      GibbsSamp.update('A');
	  GibbsSamp.check_atomic_matrix_consistency('A');
      //GibbsSamp.check_atomic_matrix_consistency('A');
      //GibbsSamp.detail_check(outputchi2_Filename);
    }
    

    for (unsigned long iterP=1; iterP <= nIterP; ++iterP){
      GibbsSamp.update('P');
	  GibbsSamp.check_atomic_matrix_consistency('P');

      //GibbsSamp.check_atomic_matrix_consistency('P');
      //GibbsSamp.detail_check(outputchi2_Filename);
    }
	tempChiSq = GibbsSamp.get_sysChi2();
	chiVect[(ext_iter)-1] = tempChiSq;

	tempAtomA = GibbsSamp.getTotNumAtoms('A');
	tempAtomP = GibbsSamp.getTotNumAtoms('P');
	nAEquil[outCount] = tempAtomA;
	nPEquil[outCount] = tempAtomP;
	outCount++;
    // ----------- output computing info ---------
    if ( ext_iter % numOutputs == 0){
      //chi2 = 2.*GibbsSamp.cal_logLikelihood();
      
      cout << "Equil: " << ext_iter << " of " << nEquil << 
              " ,nA: " << tempAtomA <<
	      " ,nP: " << tempAtomP << 
	// " ,chi2 = " << chi2 <<
              " ,System Chi2 = " << tempChiSq << endl;
    }

    // -------------------------------------------
    // re-calculate nIterA and nIterP to the expected number of atoms 
    nIterA = (unsigned long) randgen('P',max((double) GibbsSamp.getTotNumAtoms('A'),10.));
    nIterP = (unsigned long) randgen('P',max((double) GibbsSamp.getTotNumAtoms('P'),10.));
    //nIterA = (unsigned long) randgen('P',(double) GibbsSamp.getTotNumAtoms('A')+10.);
    //nIterP = (unsigned long) randgen('P',(double) GibbsSamp.getTotNumAtoms('P')+10.);
    // --------------------------------------------

  }  // end of for-block for equilibration
 


  // ===========================================================================
  // Part 3) Sampling:
  // After the system equilibriates in Part 2, we sample the systems with an 
  // outer loop of nSample iterations. Within each outer loop iteration, A is 
  // iterated nIterA times and P is iterated nIterP times. After sampling, 
  // we update nIterA and nIterP according to the expected number of atoms in 
  // the atomic spaces of A and P respectively.
  // ===========================================================================
  


  unsigned int statindx = 0;
  outCount = 0;
  for (unsigned long ext_iter=1; ext_iter <= nSample; ++ext_iter){
    for (unsigned long iterA=1; iterA <= nIterA; ++iterA){
      GibbsSamp.update('A');
      //GibbsSamp.check_atomic_matrix_consistency('A');
      //GibbsSamp.detail_check(outputchi2_Filename);
    }
    GibbsSamp.check_atomic_matrix_consistency('A');

    for (unsigned long iterP=1; iterP <= nIterP; ++iterP){ 
      GibbsSamp.update('P');
      //GibbsSamp.check_atomic_matrix_consistency('P');
      //GibbsSamp.detail_check(outputchi2_Filename);
    }
    GibbsSamp.check_atomic_matrix_consistency('P');

    if (Q_output_atomic == true){
       GibbsSamp.output_atomicdomain('A',ext_iter);
       GibbsSamp.output_atomicdomain('P',ext_iter);
    }

     statindx += 1;
     GibbsSamp.compute_statistics_prepare_matrices(statindx);
	 
	tempChiSq = GibbsSamp.get_sysChi2();
	
	chiVect[(nEquil + ext_iter)-1] = tempChiSq;
	
	tempAtomA = GibbsSamp.getTotNumAtoms('A');
	tempAtomP = GibbsSamp.getTotNumAtoms('P');
	nASamp[outCount] = tempAtomA;
	nPSamp[outCount] = tempAtomP;
	outCount++;
    // ----------- output computing info ---------
    if ( ext_iter % numOutputs == 0){
  
      // chi2 = 2.*GibbsSamp.cal_logLikelihood();
      //GibbsSamp.output_atomicdomain('A',(unsigned long) statindx);
      //GibbsSamp.output_atomicdomain('P',(unsigned long) statindx);
		
      cout << "Samp: " << ext_iter << " of " << nSample << 
              " ,nA: " << tempAtomA <<
	      " ,nP: " << tempAtomP << 
	// " ,chi2 = " << chi2 <<
              " , System Chi2 = " << tempChiSq << endl;
		
      if (ext_iter == nSample){
         chi2 = 2.*GibbsSamp.cal_logLikelihood();
	 cout << " *** Check value of final chi2: " << chi2 << " **** " << endl; 
      }



    }

    // -------------------------------------------
    // re-calculate nIterA and nIterP to the expected number of atoms 
    nIterA = (unsigned long) randgen('P',max((double) GibbsSamp.getTotNumAtoms('A'),10.));
    nIterP = (unsigned long) randgen('P',max((double) GibbsSamp.getTotNumAtoms('P'),10.));
    //nIterA = (unsigned long) randgen('P',(double) GibbsSamp.getTotNumAtoms('A')+10.);
    //nIterP = (unsigned long) randgen('P',(double) GibbsSamp.getTotNumAtoms('P')+10.);
    // --------------------------------------------

  }  // end of for-block for Sampling

 

  // ===========================================================================
  // Part 4) Calculate statistics:
  // In this final section, we calculate all statistics pertaining to the final
  // sample and check the results.
  // ===========================================================================

  char outputAmean_Filename[80];
  strcpy(outputAmean_Filename,simulation_id.c_str());
  strcat(outputAmean_Filename,"_Amean.txt");

  char outputAsd_Filename[80];
  strcpy(outputAsd_Filename,simulation_id.c_str());
  strcat(outputAsd_Filename,"_Asd.txt");

  char outputPmean_Filename[80];
  strcpy(outputPmean_Filename,simulation_id.c_str());
  strcat(outputPmean_Filename,"_Pmean.txt");

  char outputPsd_Filename[80];
  strcpy(outputPsd_Filename,simulation_id.c_str());
  strcat(outputPsd_Filename,"_Psd.txt");

  char outputAPmean_Filename[80];
  strcpy(outputAPmean_Filename,simulation_id.c_str());
  strcat(outputAPmean_Filename,"_APmean.txt");



 /* GibbsSamp.compute_statistics(outputFilename,
                               outputAmean_Filename,outputAsd_Filename,
			       outputPmean_Filename,outputPsd_Filename,
			       outputAPmean_Filename,
                               statindx);          // compute statistics like mean and s.d.n */
							   
	vector<vector <double> > AMeanVector;
	vector<vector <double> > AStdVector;
	vector<vector <double> > PMeanVector;
	vector<vector <double> > PStdVector;
	
	GibbsSamp.compute_statistics(statindx,
							   AMeanVector, AStdVector, PMeanVector, PStdVector);   
	
	/*
	cout << endl;
	for(int i = 0; i < AMeanVector.size(); i++)
	{
		for(int j = 0; j < AMeanVector[0].size(); j++)
		{
			cout << AMeanVector[i][j] << " "; 
		}
		cout << endl;
	}
	*/
	
	/*double *x,*y;
	size_t mrows,ncols;
	mrows = mxGetM(prhs[0]);
	ncols = mxGetN(prhs[0]);
	plhs[0] = mxCreateDoubleMatrix((mwSize)mrows, (mwSize)ncols, mxREAL);
	x = mxGetPr(prhs[0]);
	y = mxGetPr(plhs[0]);*/
	
	//Get Dims of Matrices for matlab
	int nrowA, ncolA;
	int nrowP, ncolP;
	ncolA = AMeanVector.size();
	nrowA = AMeanVector[0].size();
	ncolP = PMeanVector.size();
	nrowP = PMeanVector[0].size();
	
	//Declare Matrices for matlab
	double* AMeanMatArray;
	double* AStdMatArray;
	double* PMeanMatArray;
	double* PStdMatArray;
	
	//Convertible Matlab datatypes
	mxArray* AMeanMx;
	mxArray* AStdMx;
	mxArray* PMeanMx;
	mxArray* PStdMx;
	
	//Allocate memory for the Matlab Matrices and establish their data types
	AMeanMx = mxCreateDoubleMatrix(ncolA, nrowA, mxREAL);
	AStdMx = mxCreateDoubleMatrix(ncolA, nrowA, mxREAL);
	PMeanMx = mxCreateDoubleMatrix(ncolP, nrowP, mxREAL);
	PStdMx = mxCreateDoubleMatrix(ncolP, nrowP, mxREAL);
	
	
	//Steps to Create the Cell Array to pass back the data matrices 
	mxArray* TempArry;
	const int* dims;
	TempArry = mxCreateDoubleMatrix(9, 9, mxREAL); //TODO, currently creating the dimensions of a cell Matrix by creating a temp matrix due to lack of understanding of mex datatypes, fix!
	dims = mxGetDimensions(TempArry);
	plhs[0] = mxCreateCellArray(1, dims);
	
	

	 //Fill the matrices individually 
	AMeanMatArray = mxGetPr(AMeanMx);
	double tempVectValue;
	for(int i = 0; i < ncolA; i++)
	{
		for(int j = 0; j < nrowA; j++)
		{
			tempVectValue = AMeanVector[i][j];
			AMeanMatArray[i + (j*ncolA)] = tempVectValue;
		}
	}
	
	AStdMatArray = mxGetPr(AStdMx);
	for(int i = 0; i < ncolA; i++)
	{
		for(int j = 0; j < nrowA; j++)
		{
			tempVectValue = AStdVector[i][j];
			AStdMatArray[i + (j*ncolA)] = tempVectValue;
		}
	}
	
	PMeanMatArray = mxGetPr(PMeanMx);
	for(int i = 0; i < ncolP; i++)
	{
		for(int j = 0; j < nrowP; j++)
		{
			tempVectValue = PMeanVector[i][j];
			PMeanMatArray[i + (j*ncolP)] = tempVectValue;
		}
	}
	
	PStdMatArray = mxGetPr(PStdMx);
	for(int i = 0; i < ncolP; i++)
	{
		for(int j = 0; j < nrowP; j++)
		{
			tempVectValue = PStdVector[i][j];
			PStdMatArray[i + (j*ncolP)] = tempVectValue;
		}
	}
	
	mxSetCell(plhs[0], 0, AMeanMx);
	mxSetCell(plhs[0], 1, AStdMx);
	mxSetCell(plhs[0], 2, PMeanMx);
	mxSetCell(plhs[0], 3, PStdMx);
	mxSetCell(plhs[0], 4, nAEMx);
	mxSetCell(plhs[0], 5, nASMx);
	mxSetCell(plhs[0], 6, nPEMx);
	mxSetCell(plhs[0], 7, nPSMx);
	mxSetCell(plhs[0], 8, chiMx);
	
}
Beispiel #18
0
int
main(int argc, char *argv[])
{
    // Parse and read the command line arguments.
    if (argc != 5)
    {
        cerr << "Usage: " << PNAME
             << " <min-weight> <max-weight> <#vertices> <#tests>\n";
        exit(1);
    }

    long int min_weight = strtol(argv[1], 0, 0);
    long int max_weight = strtol(argv[2], 0, 0);
    long int n_vertices = strtol(argv[3], 0, 0);
    long int n_tests = strtol(argv[4], 0, 0);

    if (errno)
    {
        cerr << "Bad arguments\n";
        exit(1);
    }

    // Check consistency of command line arguments.
    if (n_tests < 0)
    {
        cerr << "the number of tests must be a positive integer\n";
        exit(1);
    }
    
    if (n_vertices > numeric_limits<unsigned>::digits)
    {
        cerr << "Too many vertices\n"
             << "Maximum n.o. vertices is "
             << numeric_limits<unsigned>::digits << "\n";
        exit(1);
    }

    if (n_vertices < 2)
    {
        cerr << "Too few vertices\n"
             << "must be at least two\n";
        exit(1);
    }

    if (min_weight > max_weight)
    {
        cerr << "min weight must be greater than max weight\n";
        exit(1);
    }

    if (abs(max_weight) >= numeric_limits<int>::max() / n_vertices ||
        abs(min_weight) >= numeric_limits<int>::max() / n_vertices)
    {
        cerr << "weights too large\n";
        exit(1);
    }

    // Initialize the random number generator.
    timeval tv;
    gettimeofday(&tv, 0);
    g_generator.seed(tv.tv_sec * 1000000 + tv.tv_usec);
    boost::uniform_int<int> uniform_int_dist(min_weight, max_weight);
    boost::variate_generator<mt19937, uniform_int<int> > rng_i(g_generator, uniform_int_dist);
    
    // Perform the tests.
    enum {MAX_SPAN_0, MAX_SPAN_1, MAX_SPAN_2,
          MAX_NOSPAN_0, MAX_NOSPAN_1, MAX_NOSPAN_2,
          MIN_SPAN_0, MIN_SPAN_1, MIN_SPAN_2,
          MIN_NOSPAN_0, MIN_NOSPAN_1, MIN_NOSPAN_2,
          N_CASES};
    string case_names[] = {
        "MAX_SPAN_0", "MAX_SPAN_1", "MAX_SPAN_2",
        "MAX_NOSPAN_0", "MAX_NOSPAN_1", "MAX_NOSPAN_2",
        "MIN_SPAN_0", "MIN_SPAN_1", "MIN_SPAN_2",
        "MIN_NOSPAN_0", "MIN_NOSPAN_1", "MIN_NOSPAN_2"
    };

    complete_graph      g(n_vertices);
    multi_array<int, 2> weights(extents[n_vertices][n_vertices]);
    vector<Vertex>      parent(n_vertices);
    Vertex              roots[] = {0, 1};

    vector<Edge>        branching;
    vector< vector< Edge > > all_branchings(N_CASES);
    vector<int>         ans(N_CASES);

    while (n_tests--)
    {
        // Clear all the branchings from previous iteration.
        BOOST_FOREACH (vector<Edge> &vec, all_branchings)
        {
            vec.clear();
        }

        // create new weights
        int *end = weights.origin() + n_vertices * n_vertices;
        for (int *ip = weights.origin(); ip != end; ++ip)
        {
            *ip = rng_i();
        }
        
        // run edmonds algorithm for a few cases. The cases will be
        // the cross product of the following properties:
        // optimum-is-maximum x attempt-to-span x num-specified-roots
        // where num-specified roots is either 0, 1, or 2. Also the
        // specified roots are either none, the vertex 0, or the
        // vertices 0 and 1.
        edmonds_optimum_branching<true, true, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 0, back_inserter(all_branchings[MAX_SPAN_0]));
        edmonds_optimum_branching<true, true, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 1, back_inserter(all_branchings[MAX_SPAN_1]));
        edmonds_optimum_branching<true, true, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 2, back_inserter(all_branchings[MAX_SPAN_2]));
        edmonds_optimum_branching<true, false, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 0, back_inserter(all_branchings[MAX_NOSPAN_0]));
        edmonds_optimum_branching<true, false, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 1, back_inserter(all_branchings[MAX_NOSPAN_1]));
        edmonds_optimum_branching<true, false, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 2, back_inserter(all_branchings[MAX_NOSPAN_2]));
        edmonds_optimum_branching<false, true, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 0, back_inserter(all_branchings[MIN_SPAN_0]));
        edmonds_optimum_branching<false, true, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 1, back_inserter(all_branchings[MIN_SPAN_1]));
        edmonds_optimum_branching<false, true, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 2, back_inserter(all_branchings[MIN_SPAN_2]));
        edmonds_optimum_branching<false, false, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 0, back_inserter(all_branchings[MIN_NOSPAN_0]));
        edmonds_optimum_branching<false, false, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 1, back_inserter(all_branchings[MIN_NOSPAN_1]));
        edmonds_optimum_branching<false, false, true>
            (g, identity_property_map(), weights.origin(),
             roots, roots + 2, back_inserter(all_branchings[MIN_NOSPAN_2]));

        for (int i = 0; i < N_CASES; ++i)
        {
            ans[i] = 0;
            BOOST_FOREACH (Edge e, all_branchings[i])
            {
                ans[i] += weights[source(e, g)][target(e, g)];
            }
        }

        // Exhaustively test all branchings and check if the answers
        // from edmonds's algorithm is optimal.
        int bad_case = -1;
        fill(parent.begin(), parent.end(), 0);
        do
        {
            if (is_cyclic(parent))
                continue;
            
            int weight = 0;
            for (int i = 0; i < n_vertices; ++i)
            {
                if (parent[i] == i)
                    continue;
                
                weight += weights[parent[i]][i];
            }

            int num_roots = 0;
            for (int i = 0; i < n_vertices; ++i)
            {
                num_roots += parent[i] == i ? 1 : 0;
            }

            bad_case = MAX_NOSPAN_0;
            if (weight > ans[bad_case])
                break;

            bad_case = MIN_NOSPAN_0;
            if (weight < ans[bad_case])
                break;

            bad_case = MAX_NOSPAN_1;
            if (parent[0] == 0 && weight > ans[bad_case])
                break;

            bad_case = MIN_NOSPAN_1;
            if (parent[0] == 0 && weight < ans[bad_case])
                break;

            bad_case = MAX_NOSPAN_2;
            if (parent[0] == 0 && parent[1] == 1 && weight > ans[bad_case])
                break;

            bad_case = MIN_NOSPAN_2;
            if (parent[0] == 0 && parent[1] == 1 && weight < ans[bad_case])
                break;

            bad_case = MAX_SPAN_0;
            if (num_roots == 1 && weight > ans[bad_case])
                break;

            bad_case = MIN_SPAN_0;
            if (num_roots == 1 && weight < ans[bad_case])
                break;

            bad_case = MAX_SPAN_1;
            if (num_roots == 1 && parent[0] == 0 && weight > ans[bad_case])
                break;

            bad_case = MIN_SPAN_1;
            if (num_roots == 1 && parent[0] == 0 && weight < ans[bad_case])
                break;

            bad_case = MAX_SPAN_2;
            if (num_roots == 1 && parent[0] == 0 && parent[1] == 1 &&
                weight > ans[bad_case])
                break;

            bad_case = MIN_SPAN_2;
            if (num_roots == 1 && parent[0] == 0 && parent[1] == 1 &&
                weight < ans[bad_case])
                break;

            bad_case = -1;
        } while (next_parent(parent));

        // If we broke out of the loop prematurely, then something was
        // wrong.
        if (bad_case > 0)
        {
            cout << "\ntest failed.\n";
            
            cout << "weights:\n";
            for (int i = 0; i < n_vertices; ++i)
            {
                for (int j = 0; j < n_vertices; ++j)
                {
                    cout << weights[i][j] << " ";
                }
                cout << "\n";
            }
            cout << "\n";
            
            int weight = 0;
            for (int i = 0; i < n_vertices; ++i)
            {
                if (parent[i] == i)
                    continue;
                
                weight += weights[parent[i]][i];
            }

            cout << "counter example (weight = " << weight << "):\n";
            for (int i = 0; i < n_vertices; ++i)
            {
                if (parent[i] == i)
                    continue;
                cout << "(" << parent[i] << ", " << i << ")\t";
            }
            cout << "\n";

            weight = 0;
            cout << "case: " << case_names[bad_case] << ":\n";
            BOOST_FOREACH (Edge e, all_branchings[bad_case])
            {
                cout << "(" << source(e, g) << ", " << target(e, g) << ")\t";
                weight += weights[source(e, g)][target(e, g)];
            }
            cout << "\n";
            cout << "weight:\t" << weight << "\n";

            exit(1);
        }
Beispiel #19
0
 servers_chooser()
 {
     boost::random_device dev;
     rng_.seed(dev());
 }
Beispiel #20
0
void initrand(unsigned int seed) {
    rng.seed(seed);
}
Beispiel #21
0
int main (int argc, char* argv[])
{

    cout << endl;
    cout << "      MAP AND MARGINAL INFERENCE EXAMPLE";
    cout << endl << endl;

/*------------------------------------------------------------------------------
 *
 *                         PREPARE TRAINING DATA
 *
 *----------------------------------------------------------------------------*/

    //
    // Generate the types of nodes and edges
    //

    size_t N_classes_type_1        = 11;
    size_t N_nf   = 5;
    size_t N_ef   = 4;

    // OBJECTS

    CNodeTypePtr simpleNodeType1Ptr( new CNodeType(N_classes_type_1,
                                                   N_nf,
                                                   string("Objects") ) );

    CEdgeTypePtr simpleEdgeType1Ptr ( new CEdgeType(N_ef,
                                                    simpleNodeType1Ptr,
                                                    simpleNodeType1Ptr,
                                                    string("Edges between two objects")) );


    trainingDataset.addNodeType( simpleNodeType1Ptr );
    trainingDataset.addEdgeType( simpleEdgeType1Ptr );

    //
    // Create a set of training graphs
    //

    vector<CGraph>                      graphs;
    vector<std::map<size_t,size_t> >    groundTruths;

/*--------------------------------- Graph 1 ----------------------------------*/


    cout << "Graph 1" << endl;

    CGraph graph1;
    std::map<size_t,size_t> groundTruth1;

    Eigen::MatrixXd g1_nf(11,5);

    g1_nf << 1, 0.725256, 0.347833, 2.32114, 1,
             0, 0, 1.46145, 2.86637, 1,
             1, 0.513579, 0.398025, 1.85308, 1,
             0, 0.896507, 0.969337, 1.7035, 1,
             0, 0.748331, 0.585186, 1.47532, 1,
             1, 0.963636, 0.125714, 1, 1,
             1, 0.93444, 0.212592, 1.52702, 1,
             1, 1.05757, 0.236803, 3.22358, 1,
             0, 0.398408, 0.131399, 1, 1,
             0, 0.0300602, 0.129521, 2.03183, 1,
             1, 0.469344, 0.505431, 1.45506, 1;

    Eigen::MatrixXi g1_adj(11,11);

    g1_adj <<   0,  1,  1,  1,  1,  1,  0,  0,  1,  1,  0,
                1,  0,  1,  0,  0,  0,  0,  0,  1,  1,  0,
                1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,
                1,  0,  0,  0,  1,  1,  1,  1,  1,  0,  1,
                1,  0,  0,  1,  0,  1,  1,  1,  1,  1,  1,
                1,  0,  0,  1,  1,  0,  1,  0,  0,  0,  0,
                0,  0,  0,  1,  1,  1,  0,  1,  1,  0,  1,
                0,  0,  0,  1,  1,  0,  1,  0,  0,  0,  1,
                1,  1,  0,  1,  1,  0,  1,  0,  0,  1,  0,
                1,  1,  0,  0,  1,  0,  0,  0,  1,  0,  0,
                0,  0,  0,  1,  1,  0,  1,  1,  0,  0,  0;

    Eigen::MatrixXi isOn_relation(11,11);

    isOn_relation.setZero();
    isOn_relation(3,5) = 1;
    isOn_relation(4,5) = 1;

    Eigen::MatrixXi coplanar_relation(11,11);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g1_relations;

    g1_relations.push_back( isOn_relation );
    g1_relations.push_back( coplanar_relation );

    Eigen::VectorXi g1_groundTruth(11);

    g1_groundTruth << 4, 0, 1, 2, 2, 6, 1, 1, 5, 0, 3;

    fillGraph( graph1, g1_nf, simpleNodeType1Ptr,
                  g1_adj, simpleEdgeType1Ptr, g1_relations,
                  g1_groundTruth, groundTruth1 );

    graphs.push_back( graph1 );
    groundTruths.push_back( groundTruth1 );

    cout << graph1 << endl;

/*--------------------------------- Graph 2 ----------------------------------*/

    cout << "Graph 2" << endl;

    CGraph graph2;
    std::map<size_t,size_t> groundTruth2;

    Eigen::MatrixXd g2_nf(5,5);

    g2_nf << 0, 0.745944,   1.20098,    1.68726,    1,
             1, 0.523566,   0.255477,   1.72744,    1,
             0, 0,          1.49268,    2.54707,    1,
             1, 0.359525,   0.268375,   2.8157,     1,
             0, 0.446692,   0.129895,   1,          1;

    Eigen::MatrixXi g2_adj(5,5);

    g2_adj << 0,  1,  0,  1,  1,
            1,  0,  1,  1,  0,
            0,  1,  0,  1,  1,
            1,  1,  1,  0,  1,
            1,  0,  1,  1,  0;

    isOn_relation.resize(5,5);

    isOn_relation.setZero();

    coplanar_relation.resize(5,5);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g2_relations;

    g2_relations.push_back( isOn_relation );
    g2_relations.push_back( coplanar_relation );

    Eigen::VectorXi g2_groundTruth(5);

    g2_groundTruth << 2, 3, 0, 3, 5;

    fillGraph( graph2, g2_nf, simpleNodeType1Ptr,
               g2_adj, simpleEdgeType1Ptr, g2_relations,
               g2_groundTruth, groundTruth2 );

    graphs.push_back( graph2 );
    groundTruths.push_back( groundTruth2 );


///*--------------------------------- Graph 3 ----------------------------------*/

    cout << "Graph 3" << endl;

    CGraph graph3;
    std::map<size_t,size_t> groundTruth3;

    Eigen::MatrixXd g3_nf(10,5);

    g3_nf << 1, 1.56711,    3.42284,    2.00889, 1,
             1, 1.02852,    0.339804,   1.54119, 1,
             1, 1.02507,    0.317727,   1.77383, 1,
             0, 0.880216,   1.45163,    2.04593, 1,
             1, 1.04219,    0.229974,   1.77708, 1,
             1, 1.66558,    0.171681,   2.3654,  1,
             0, 0.488131,   0.233171,   1.51503, 1,
             1, 0.699061,   0.120062,   1.55154, 1,
             0, 0,          2.84036,    1.99605, 1,
             1, 0.167627,   0.352816,   3.80501, 1;

    Eigen::MatrixXi g3_adj(10,10);

    g3_adj <<   0,  1,  1,  1,  1,  1,  0,  0,  0,  1,
            1,  0,  1,  1,  0,  0,  0,  0,  0,  0,
            1,  1,  0,  1,  1,  1,  1,  1,  0,  1,
            1,  1,  1,  0,  1,  1,  1,  1,  0,  1,
            1,  0,  1,  1,  0,  1,  1,  1,  0,  1,
            1,  0,  1,  1,  1,  0,  0,  0,  0,  0,
            0,  0,  1,  1,  1,  0,  0,  1,  1,  0,
            0,  0,  1,  1,  1,  0,  1,  0,  1,  0,
            0,  0,  0,  0,  0,  0,  1,  1,  0,  1,
            1,  0,  1,  1,  1,  0,  0,  0,  1,  0;

    isOn_relation.resize(10,10);
    isOn_relation.setZero();
    isOn_relation(1,3) = 1;
    isOn_relation(2,3) = 1;
    isOn_relation(3,4) = 1;

    coplanar_relation.resize(10,10);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g3_relations;

    g3_relations.push_back( isOn_relation );
    g3_relations.push_back( coplanar_relation );

    Eigen::VectorXi g3_groundTruth(10);

    g3_groundTruth << 1, 6, 6, 2, 9, 10, 5, 4, 0, 1;

    fillGraph( graph3, g3_nf, simpleNodeType1Ptr,
                  g3_adj, simpleEdgeType1Ptr, g3_relations,
                  g3_groundTruth, groundTruth3 );

    graphs.push_back( graph3 );
    groundTruths.push_back( groundTruth3 );

///*--------------------------------- Graph 4 ----------------------------------*/

    cout << "Graph 4" << endl;

    CGraph graph4;
    std::map<size_t,size_t> groundTruth4;

    Eigen::MatrixXd g4_nf(7,5);

    g4_nf << 1, 1.58673,    2.5301,     1.79962, 1,
             1, 1.01892,    0.198802,   1.46393, 1,
             1, 1.00455,    0.230172,   1.67413, 1,
             0, 0.744138,   0.89911,    1.57856, 1,
             0, 0.477457,   0.187906,   1.87622, 1,
             1, 0.7026,     0.113952,   1.44738, 1,
             0, 0,          2.75497,    1.87592, 1;

    Eigen::MatrixXi g4_adj(7,7);

    g4_adj <<   0,  1,  1,  1,  0,  0,  0,
                1,  0,  1,  1,  1,  1,  0,
                1,  1,  0,  1,  1,  1,  0,
                1,  1,  1,  0,  1,  1,  0,
                0,  1,  1,  1,  0,  1,  1,
                0,  1,  1,  1,  1,  0,  1,
                0,  0,  0,  0,  1,  1,  0;

    isOn_relation.resize(7,7);
    isOn_relation.setZero();
    isOn_relation(1,3) = 1;
    isOn_relation(2,3) = 1;

    coplanar_relation.resize(7,7);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g4_relations;

    g4_relations.push_back( isOn_relation );
    g4_relations.push_back( coplanar_relation );

    Eigen::VectorXi g4_groundTruth(7);

    g4_groundTruth << 1, 6, 9, 2, 5, 4, 0;

    fillGraph( graph4, g4_nf, simpleNodeType1Ptr,
                  g4_adj, simpleEdgeType1Ptr, g4_relations,
                  g4_groundTruth, groundTruth4 );

    graphs.push_back( graph4 );
    groundTruths.push_back( groundTruth4 );

///*--------------------------------- Graph 5 ----------------------------------*/

    cout << "Graph 5" << endl;

    // Desktop 6
    CGraph graph5;
    std::map<size_t,size_t> groundTruth5;

    Eigen::MatrixXd g5_nf(8,5);

    g5_nf << 1, 1.10316,    0.363647,   1.61694,    1,
             1, 1.00384,    0.23474,    2.7587,     1,
             1, 0.988903,   0.118134,   1,          1,
             0, 0.789307,   1.62451,    2.07762,    1,
             1, 0.672498,   1.8316,     1.78692,    1,
             1, 0.976089,   0.244898,   1,          1,
             0, 0.502879,   0.186037,   2.29688,    1,
             0, 0,          2.50486,    1.43262,    1;

    Eigen::MatrixXi g5_adj(8,8);

    g5_adj <<   0,  1,  1,  1,  1,  1,  0,  0,
                1,  0,  1,  1,  1,  0,  0,  0,
                1,  1,  0,  1,  0,  0,  0,  0,
                1,  1,  1,  0,  1,  1,  1,  0,
                1,  1,  0,  1,  0,  1,  1,  1,
                1,  0,  0,  1,  1,  0,  1,  0,
                0,  0,  0,  1,  1,  1,  0,  0,
                0,  0,  0,  0,  1,  0,  0,  0;

    isOn_relation.resize(8,8);
    isOn_relation.setZero();
    isOn_relation(0,3) = 1;
    isOn_relation(2,3) = 1;

    coplanar_relation.resize(8,8);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g5_relations;

    g5_relations.push_back( isOn_relation );
    g5_relations.push_back( coplanar_relation );

    Eigen::VectorXi g5_groundTruth(8);

    g5_groundTruth << 6, 1, 8, 2, 1, 1, 5, 0;

    fillGraph( graph5, g5_nf, simpleNodeType1Ptr,
                  g5_adj, simpleEdgeType1Ptr, g5_relations,
                  g5_groundTruth, groundTruth5 );

    graphs.push_back( graph5 );
    groundTruths.push_back( groundTruth5 );


///*--------------------------------- Graph 6 ----------------------------------*/

    cout << "Graph 6" << endl;

    // Desktop 7
    CGraph graph6;
    std::map<size_t,size_t> groundTruth6;

    Eigen::MatrixXd g6_nf(7,5);

    g6_nf << 1, 0.975437,   1.21382,    2.28555,    1,
             1, 0.951433,   0.270196,   2.29035,    1,
             0, 0.766445,   1.00624,    1.6777,     1,
             0, 0,          1.13219,    1.64994,    1,
             1, 0.985712,   0.208164,   1.67471,    1,
             0, 0.499913,   0.208579,   1.95149,    1,
             1, 0.970966,   0.16066,    1,          1;

    Eigen::MatrixXi g6_adj(7,7);

    g6_adj <<   0,  1,  1,  1,  0,  0,  1,
                1,  0,  1,  0,  1,  1,  1,
                1,  1,  0,  0,  1,  1,  1,
                1,  0,  0,  0,  0,  1,  0,
                0,  1,  1,  0,  0,  1,  0,
                0,  1,  1,  1,  1,  0,  0,
                1,  1,  1,  0,  0,  0,  0;

    isOn_relation.resize(7,7);
    isOn_relation.setZero();
    isOn_relation(2,6) = 1;

    coplanar_relation.resize(7,7);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g6_relations;

    g6_relations.push_back( isOn_relation );
    g6_relations.push_back( coplanar_relation );

    Eigen::VectorXi g6_groundTruth(7);

    g6_groundTruth << 1, 1, 2, 0, 4, 5, 6;

    fillGraph( graph6, g6_nf, simpleNodeType1Ptr,
                  g6_adj, simpleEdgeType1Ptr, g6_relations,
                  g6_groundTruth, groundTruth6 );

    graphs.push_back( graph6 );
    groundTruths.push_back( groundTruth6 );


///*--------------------------------- Graph 7 ----------------------------------*/

    cout << "Graph 7" << endl;

    // Desktop 8
    CGraph graph7;
    std::map<size_t,size_t> groundTruth7;

    Eigen::MatrixXd g7_nf(7,5);

    g7_nf << 1, 1.08949,    0.44,       1.51331,    1,
             1, 1.07257,    0.144868,   1,          1,
             0, 0.802159,   1.19101,    1.78961,    1,
             1, 0.728912,   0.128203,   2.15983,    1,
             0, 0,          3.7626,     2.86856,    1,
             0, 0.0142013,  0.175163,   2.24823,    1,
             0, 0.540925,   0.205526,   1,          1;

    Eigen::MatrixXi g7_adj(7,7);

    g7_adj << 0,  1,  1,  1,  0,  0,  1,
            1,  0,  1,  0,  0,  0,  0,
            1,  1,  0,  1,  0,  0,  1,
            1,  0,  1,  0,  0,  0,  1,
            0,  0,  0,  0,  0,  1,  1,
            0,  0,  0,  0,  1,  0,  1,
            1,  0,  1,  1,  1,  1,  0;

    isOn_relation.resize(7,7);
    isOn_relation.setZero();
    isOn_relation(0,2) = 1;
    isOn_relation(1,2) = 1;

    coplanar_relation.resize(7,7);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g7_relations;

    g7_relations.push_back( isOn_relation );
    g7_relations.push_back( coplanar_relation );

    Eigen::VectorXi g7_groundTruth(7);

    g7_groundTruth << 6, 6, 2, 4, 0, 0, 5;

    fillGraph( graph7, g7_nf, simpleNodeType1Ptr,
                  g7_adj, simpleEdgeType1Ptr, g7_relations,
                  g7_groundTruth, groundTruth7 );

    graphs.push_back( graph7 );
    groundTruths.push_back( groundTruth7 );


///*--------------------------------- Graph 8 ----------------------------------*/


    cout << "Graph 8" << endl;

    // Desktop 9
    CGraph graph8;
    std::map<size_t,size_t> groundTruth8;

    Eigen::MatrixXd g8_nf(5,5);

    g8_nf << 1, 1.0398,     1.45393,    1.85835,    1,
             0, 0.687862,   1.05335,    1.44245,    1,
             0, 0.476001,   0.17945,    1,          1,
             1, 0.150004,   0.163443,   1.72806,    1,
             0, 0,          2.11644,    3.64183,    1;

    Eigen::MatrixXi g8_adj(5,5);

    g8_adj << 0,  1,  0,  0,  0,
            1,  0,  1,  1,  0,
            0,  1,  0,  1,  1,
            0,  1,  1,  0,  1,
            0,  0,  1,  1,  0;

    isOn_relation.resize(5,5);
    isOn_relation.setZero();

    coplanar_relation.resize(5,5);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g8_relations;

    g8_relations.push_back( isOn_relation );
    g8_relations.push_back( coplanar_relation );

    Eigen::VectorXi g8_groundTruth(5);

    g8_groundTruth << 1, 2, 5, 1, 0;

    fillGraph( graph8, g8_nf, simpleNodeType1Ptr,
                  g8_adj, simpleEdgeType1Ptr, g8_relations,
                  g8_groundTruth, groundTruth8 );

    graphs.push_back( graph8 );
    groundTruths.push_back( groundTruth8 );




///*--------------------------------- Graph 9 ----------------------------------*/

    cout << "Graph 9" << endl;

    // Desktop 11
    CGraph graph9;
    std::map<size_t,size_t> groundTruth9;

    Eigen::MatrixXd g9_nf(6,5);

    g9_nf << 1, 1.08032,    0.175311,   1.59692, 1,
             1, 1.04474,    0.153065,   1.75199, 1,
             0, 0.802788,   1.36259,    2.70243, 1,
             1, 0.727563,   0.115821,   1.56757, 1,
             0, 0,          2.24629,    1.73137, 1,
             0, 0.516504,   0.165597,   1,       1;

    Eigen::MatrixXi g9_adj(6,6);

    g9_adj << 0,  1,  1,  1,  0,  0,
             1,  0,  1,  0,  0,  0,
             1,  1,  0,  1,  0,  1,
             1,  0,  1,  0,  1,  1,
             0,  0,  0,  1,  0,  1,
             0,  0,  1,  1,  1,  0;

    isOn_relation.resize(6,6);
    isOn_relation.setZero();
    isOn_relation(0,2) = 1;

    coplanar_relation.resize(6,6);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g9_relations;

    g9_relations.push_back( isOn_relation );
    g9_relations.push_back( coplanar_relation );

    Eigen::VectorXi g9_groundTruth(6);

    g9_groundTruth << 6, 1, 2, 4, 0, 5;

    fillGraph( graph9, g9_nf, simpleNodeType1Ptr,
                  g9_adj, simpleEdgeType1Ptr, g9_relations,
                  g9_groundTruth, groundTruth9 );

    graphs.push_back( graph9 );
    groundTruths.push_back( groundTruth9 );

///*--------------------------------- Graph 10 ----------------------------------*/

    cout << "Graph 10" << endl;

    // Desktop 13
    CGraph graph10;
    std::map<size_t,size_t> groundTruth10;

    Eigen::MatrixXd g10_nf(7,5);

    g10_nf << 1, 1.13981,   0.613381,   1.46317,    1,
              1, 1.01258,   0.167784,   1.47751,    1,
              0, 0.772106,  1.55737,    3.7527,     1,
              1, 1.11485,   0.201305,   2.29086,    1,
              0, 0.487854,  0.161754,   1.53537,    1,
              0, 0,         0.70792,    2.77777,    1,
              0, 0.0221937, 0.310503,   1.72698,    1;

    Eigen::MatrixXi g10_adj(7,7);

    g10_adj << 0,  1,  1,  1,  0,  0,  0,
                1,  0,  1,  1,  0,  0,  0,
                1,  1,  0,  1,  1,  0,  0,
                1,  1,  1,  0,  1,  0,  0,
                0,  0,  1,  1,  0,  1,  1,
                0,  0,  0,  0,  1,  0,  1,
                0,  0,  0,  0,  1,  1,  0;

    isOn_relation.resize(7,7);
    isOn_relation.setZero();
    isOn_relation(1,2) = 1;
    isOn_relation(2,3) = 1;

    coplanar_relation.resize(7,7);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g10_relations;

    g10_relations.push_back( isOn_relation );
    g10_relations.push_back( coplanar_relation );

    Eigen::VectorXi g10_groundTruth(7);

    g10_groundTruth << 1, 6, 2, 8, 5, 0, 0;

    fillGraph( graph10, g10_nf, simpleNodeType1Ptr,
                  g10_adj, simpleEdgeType1Ptr, g10_relations,
                  g10_groundTruth, groundTruth10 );

    graphs.push_back( graph10 );
    groundTruths.push_back( groundTruth10 );


///*--------------------------------- Graph 11 ----------------------------------*/

    cout << "Graph 11" << endl;

    // Desktop 14
    CGraph graph11;
    std::map<size_t,size_t> groundTruth11;

    Eigen::MatrixXd g11_nf(3,5);

    g11_nf << 1, 1.39389,   1.07869,    3.04842, 1,
              0, 0.724976,  0.627546,   3.18692, 1,
              1, 1.02144,   0.168219,   1.53329, 1;

    Eigen::MatrixXi g11_adj(3,3);

    g11_adj << 0,  1,  1,
               1,  0,  1,
               1,  1,  0;

    isOn_relation.resize(3,3);
    isOn_relation.setZero();
    isOn_relation(1,2) = 1;

    coplanar_relation.resize(3,3);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g11_relations;

    g11_relations.push_back( isOn_relation );
    g11_relations.push_back( coplanar_relation );

    Eigen::VectorXi g11_groundTruth(3);

    g11_groundTruth << 1, 2, 6;

    fillGraph( graph11, g11_nf, simpleNodeType1Ptr,
                  g11_adj, simpleEdgeType1Ptr, g11_relations,
                  g11_groundTruth, groundTruth11 );

    graphs.push_back( graph11 );
    groundTruths.push_back( groundTruth11 );


///*--------------------------------- Graph 12 ----------------------------------*/

    cout << "Graph 12" << endl;

    // Desktop 15
    CGraph graph12;
    std::map<size_t,size_t> groundTruth12;

    Eigen::MatrixXd g12_nf(9,5);

    g12_nf << 1, 0.890949,  3.09357,    2.35317, 1,
              0, 0.337975,  0.284948,   1.73898, 1,
              1, 0.722686,  0.397614,   1.45951, 1,
              0, 0.619682,  1.56466,    2.28344, 1,
              1, 0.404655,  0.167949,   1,       1,
              1, 0.726681,  0.198501,   1.52176, 1,
              1, 0.876247,  0.182265,   1.92814, 1,
              1, 0.639947,  0.133658,   2.02595, 1,
              0, 0,         0.36366,    1,       1;

    Eigen::MatrixXi g12_adj(9,9);

    g12_adj << 0,  1,  1,  0,  1,  1,  0,  0,  0,
             1,  0,  1,  1,  1,  0,  0,  0,  0,
             1,  1,  0,  1,  1,  0,  1,  0,  0,
             0,  1,  1,  0,  1,  1,  1,  1,  0,
             1,  1,  1,  1,  0,  0,  1,  0,  0,
             1,  0,  0,  1,  0,  0,  0,  0,  0,
             0,  0,  1,  1,  1,  0,  0,  0,  0,
             0,  0,  0,  1,  0,  0,  0,  0,  1,
             0,  0,  0,  0,  0,  0,  0,  1,  0;

    isOn_relation.resize(9,9);
    isOn_relation.setZero();
    isOn_relation(3,6) = 1;

    coplanar_relation.resize(9,9);

    coplanar_relation.setZero();

    vector<Eigen::MatrixXi> g12_relations;

    g12_relations.push_back( isOn_relation );
    g12_relations.push_back( coplanar_relation );

    Eigen::VectorXi g12_groundTruth(9);

    g12_groundTruth << 1, 5, 4, 2, 3, 1, 6, 4, 0;

    fillGraph( graph12, g12_nf, simpleNodeType1Ptr,
                  g12_adj, simpleEdgeType1Ptr, g12_relations,
                  g12_groundTruth, groundTruth12 );

    graphs.push_back( graph12 );
    groundTruths.push_back( groundTruth12 );


///*--------------------------------- Graph 13 ----------------------------------*/

//    Eigen::MatrixXi g13_adj(11,11);
//, 0,  1,  1,  1,  1,  1,  0,  1,  1,  0
//, 1,  0,  1,  0,  0,  0,  0,  1,  1,  0
//, 1,  1,  0,  0,  0,  0,  0,  0,  0,  0
//, 1,  0,  0,  0,  1,  1,  1,  1,  0,  1
//, 1,  0,  0,  1,  0,  1,  1,  1,  1,  1
//, 1,  0,  0,  1,  1,  0,  1,  0,  0,  0
//, 0,  0,  0,  1,  1,  1,  0,  1,  0,  1
//, 1,  1,  0,  1,  1,  0,  1,  0,  1,  0
//, 1,  1,  0,  0,  1,  0,  0,  1,  0,  0
//, 0,  0,  0,  1,  1,  0,  1,  0,  0,  0

///*--------------------------------- Graph 14 ----------------------------------*/

//    Eigen::MatrixXi g14_adj(11,11);
//, 0,  1,  0,  1,  1,  1
//, 1,  0,  1,  1,  0,  0
//, 0,  1,  0,  1,  1,  0
//, 1,  1,  1,  0,  1,  0
//, 1,  0,  1,  1,  0,  0
//, 1,  0,  0,  0,  0,  0

///*--------------------------------- Graph 15 ----------------------------------*/

//    Eigen::MatrixXi g15_adj(11,11);
//, 0,  1,  1,  1,  0,  0,  0,  1
//, 1,  0,  1,  1,  0,  0,  0,  0
//, 1,  1,  0,  1,  1,  1,  0,  1
//, 1,  1,  1,  0,  1,  1,  0,  1
//, 0,  0,  1,  1,  0,  1,  1,  0
//, 0,  0,  1,  1,  1,  0,  1,  0
//, 0,  0,  0,  0,  1,  1,  0,  1
//, 1,  0,  1,  1,  0,  0,  1,  0

///*--------------------------------- Graph 16 ----------------------------------*/

//    Eigen::MatrixXi g16_adj(11,11);
//, 0,  1,  1,  0,  0,  0
//, 1,  0,  1,  1,  1,  0
//, 1,  1,  0,  1,  1,  0
//, 0,  1,  1,  0,  1,  1
//, 0,  1,  1,  1,  0,  1
//, 0,  0,  0,  1,  1,  0

///*--------------------------------- Graph 17 ----------------------------------*/

//    Eigen::MatrixXi g17_adj(11,11);
//, 0,  1,  1,  1,  1,  0,  0
//, 1,  0,  1,  1,  0,  0,  0
//, 1,  1,  0,  1,  1,  1,  0
//, 1,  1,  1,  0,  1,  1,  1
//, 1,  0,  1,  1,  0,  1,  0
//, 0,  0,  1,  1,  1,  0,  0
//, 0,  0,  0,  1,  0,  0,  0

///*--------------------------------- Graph 18 ----------------------------------*/

//    Eigen::MatrixXi g18_adj(11,11);
//, 0,  1,  1,  1,  0,  0,  1,  1
//, 1,  0,  1,  0,  1,  1,  1,  0
//, 1,  1,  0,  0,  1,  1,  1,  1
//, 1,  0,  0,  0,  0,  1,  0,  0
//, 0,  1,  1,  0,  0,  1,  0,  0
//, 0,  1,  1,  1,  1,  0,  0,  0
//, 1,  1,  1,  0,  0,  0,  0,  0
//, 1,  0,  1,  0,  0,  0,  0,  0

///*--------------------------------- Graph 19 ----------------------------------*/

//    Eigen::MatrixXi g19_adj(11,11);
//, 0,  1,  0,  0,  0,  0
//, 1,  0,  1,  0,  0,  1
//, 0,  1,  0,  0,  0,  1
//, 0,  0,  0,  0,  1,  1
//, 0,  0,  0,  1,  0,  1
//, 0,  1,  1,  1,  1,  0

///*--------------------------------- Graph 20 ----------------------------------*/

//    Eigen::MatrixXi g20_adj(11,11);
//, 0,  1,  0,  0,  0
//, 1,  0,  1,  1,  0
//, 0,  1,  0,  1,  1
//, 0,  1,  1,  0,  1
//, 0,  0,  1,  1,  0

///*--------------------------------- Graph 21 ----------------------------------*/

//    Eigen::MatrixXi g21_adj(11,11);
//, 0,  1,  1,  1,  0,  0,  0
//, 1,  0,  1,  0,  0,  0,  0
//, 1,  1,  0,  1,  0,  1,  1
//, 1,  0,  1,  0,  1,  1,  0
//, 0,  0,  0,  1,  0,  1,  0
//, 0,  0,  1,  1,  1,  0,  0
//, 0,  0,  1,  0,  0,  0,  0

///*--------------------------------- Graph 22 ----------------------------------*/

//    Eigen::MatrixXi g22_adj(11,11);
//, 0,  1,  1,  0,  0
//, 1,  0,  1,  0,  0
//, 1,  1,  0,  1,  0
//, 0,  0,  1,  0,  1
//, 0,  0,  0,  1,  1

///*--------------------------------- Graph 23 ----------------------------------*/

//    Eigen::MatrixXi g23_adj(11,11);
//, 0,  1,  1
//, 1,  0,  1
//, 1,  1,  0

///*--------------------------------- Graph 24 ----------------------------------*/

//    Eigen::MatrixXi g24_adj(11,11);

//    g24_adj <<  0,  1,  1,  0,  1,  1,  0,  0,  0,
//                1,  0,  1,  1,  1,  0,  0,  0,  0,
//                1,  1,  0,  1,  1,  0,  1,  0,  0,
//                0,  1,  1,  0,  1,  1,  1,  1,  0,
//                1,  1,  1,  1,  0,  0,  1,  0,  0,
//                1,  0,  0,  1,  0,  0,  0,  0,  0,
//                0,  0,  1,  1,  1,  0,  0,  0,  0,
//                0,  0,  0,  1,  0,  0,  0,  0,  1,
//                0,  0,  0,  0,  0,  0,  0,  1,  0;

///*--------------------------------- Graph 25 ----------------------------------*/

//    Eigen::MatrixXi g25_adj(11,11);

//    g25_adj <<  0,  1,  1,  0,  0,
//                1,  0,  1,  1,  1,
//                1,  1,  0,  0,  0,
//                0,  1,  0,  0,  1,
//                0,  1,  0,  1,  0;

    static boost::mt19937 rng;
    rng.seed(std::time(0));

    size_t N_graphsForTraining = 9;

    size_t absoluteSuccess_Greedy  = 0;
    size_t absoluteSuccess_ICM     = 0;
    size_t absoluteSuccess_AlphaExpansion = 0;
    size_t absoluteSuccess_AlphaBetaSwap  = 0;
    size_t absoluteSuccess_LBP = 0;
    size_t absoluteSuccess_TRP = 0;
    size_t absoluteSuccess_RBP = 0;
    size_t absoluteNumberOfNodes = 0;

    size_t N_repetitions = 100;

    for ( size_t rep = 0; rep < N_repetitions; rep++ )
    {

    vector<size_t> graphs_to_train;
    size_t N_graphsAdded       = 0;

    while ( N_graphsAdded < N_graphsForTraining )
    {
        boost::uniform_int<> int_generator(0,11);
        int rand = int_generator(rng);

        if ( std::find(graphs_to_train.begin(),graphs_to_train.end(),rand)
             == graphs_to_train.end() )
        {
            graphs_to_train.push_back(rand);
            N_graphsAdded++;
        }
    }

    vector<size_t> graphs_to_test;

    for ( size_t i = 0; i < graphs.size(); i++ )
        if ( std::find(graphs_to_train.begin(),graphs_to_train.end(), i)
             == graphs_to_train.end() )
            graphs_to_test.push_back(i);

    cout << "Graphs to test: ";

    for ( size_t i = 0; i < graphs_to_test.size(); i++)
        cout << graphs_to_test[i] << " ";

    cout << endl;


//    graphs_to_train.push_back(0);
//    graphs_to_train.push_back(1);
//    graphs_to_train.push_back(2);
//    graphs_to_train.push_back(3);
//    graphs_to_train.push_back(4);
//    graphs_to_train.push_back(5);
//    graphs_to_train.push_back(6);
//    graphs_to_train.push_back(7);
//    graphs_to_train.push_back(8);
//    graphs_to_train.push_back(9);
//    graphs_to_train.push_back(10);


//    graphs_to_test.push_back(11);

    for ( size_t i = 0; i < graphs_to_train.size(); i++ )
    {
        trainingDataset.addGraph( graphs[graphs_to_train[i]] );
        trainingDataset.addGraphGroundTruth( groundTruths[graphs_to_train[i]] );
    }


/*------------------------------------------------------------------------------
 *
 *                               TRAINING!
 *
 *----------------------------------------------------------------------------*/

    UPGMpp::TTrainingOptions to;
    to.l2Regularization     = true;
    to.nodeLambda           = 10;
    to.edgeLambda           = 15;
    to.showTrainedWeights   = false;
    to.showTrainingProgress = false;

    cout << "------------------------------------------------------" << endl;
    cout << "                      TRAINING" << endl;
    cout << "------------------------------------------------------" << endl;

    trainingDataset.setTrainingOptions( to );
    int res = trainingDataset.train();

    if (res!=0) continue;


/*------------------------------------------------------------------------------
 *
 *              PREPARE A GRAPH FOR PERFORMING DECODING AND INFERENCE
 *
 *----------------------------------------------------------------------------*/

    cout << "------------------------------------------------------" << endl;
    cout << "                      TESTING" << endl;
    cout << "------------------------------------------------------" << endl;

    for ( size_t i = 0; i < graphs_to_test.size(); i++ )
    {

        graphs[graphs_to_test[i]].computePotentials();

    /*------------------------------------------------------------------------------
     *
     *                               DECODING!
     *
     *----------------------------------------------------------------------------*/

        cout << endl;
        cout << "------------------------------------------------------" << endl;
        cout << "                      DECODING" << endl;
        cout << "------------------------------------------------------" << endl;


        CICMInferenceMAP       decodeICM;
        CICMGreedyInferenceMAP decodeICMGreedy;
        CAlphaExpansionInferenceMAP decodeAlphaExpansion;
        CAlphaBetaSwapInferenceMAP decodeAlphaBetaSawp;
        CLBPInferenceMAP      decodeLBP;
        CTRPBPInferenceMAP    decodeTRPBP;
        CRBPInferenceMAP      decodeRBP;

        double totalSuccess_Greedy  = 0;
        double totalSuccess_ICM     = 0;
        double totalSuccess_AlphaExpansion = 0;
        double totalSuccess_AlphaBetaSwap  = 0;
        double totalSuccess_LBP = 0;
        double totalSuccess_TRP = 0;
        double totalSuccess_RBP = 0;

        TInferenceOptions options;
        options.maxIterations = 100;

        std::map<size_t,size_t> resultsMap;
        std::map<size_t,size_t>::iterator it;

        //std::cout << "           RESULTS ICM " << std::endl;
        //std::cout << "-----------------------------------" << std::endl;

        decodeICM.setOptions( options );
        decodeICM.infer( graphs[graphs_to_test[i]], resultsMap );

        for ( it = resultsMap.begin(); it != resultsMap.end(); it++ )
            if ( it->second == groundTruths[graphs_to_test[i]][ it->first ])
                totalSuccess_ICM++;

        //showResults( resultsMap );

        //std::cout << "-----------------------------------" << std::endl;
        //std::cout << "         RESULTS ICM GREEDY" << std::endl;
        //std::cout << "-----------------------------------" << std::endl;

        decodeICMGreedy.setOptions( options );
        decodeICMGreedy.infer( graphs[graphs_to_test[i]], resultsMap );

        for ( it = resultsMap.begin(); it != resultsMap.end(); it++ )
            if ( it->second == groundTruths[graphs_to_test[i]][ it->first ])
                totalSuccess_Greedy++;

        //showResults( resultsMap );

        //std::cout << "-----------------------------------" << std::endl;
        //std::cout << "      RESULTS ALPHA-EXPANSIONS" << std::endl;
        //std::cout << "-----------------------------------" << std::endl;

        options.maxIterations = 10000;
        decodeAlphaExpansion.setOptions( options );
        decodeAlphaExpansion.infer( graphs[graphs_to_test[i]], resultsMap );

        for ( it = resultsMap.begin(); it != resultsMap.end(); it++ )
            if ( it->second == groundTruths[graphs_to_test[i]][ it->first ])
                totalSuccess_AlphaExpansion++;

        //showResults( resultsMap );

        //std::cout << "-----------------------------------" << std::endl;
        //std::cout << "        RESULTS ALPHA-BETA" << std::endl;
        //std::cout << "-----------------------------------" << std::endl;

        options.maxIterations = 10000;
        decodeAlphaBetaSawp.setOptions( options );
        decodeAlphaBetaSawp.infer( graphs[graphs_to_test[i]], resultsMap );

        for ( it = resultsMap.begin(); it != resultsMap.end(); it++ )
        {
            if ( it->second == groundTruths[graphs_to_test[i]][ it->first ])
                totalSuccess_AlphaBetaSwap++;
        }

        //showResults( resultsMap );

        //std::cout << "-----------------------------------" << std::endl;
        //std::cout << "        RESULTS LBP" << std::endl;
        //std::cout << "-----------------------------------" << std::endl;

        options.maxIterations = 10000;
        decodeLBP.setOptions( options );
        decodeLBP.infer( graphs[graphs_to_test[i]], resultsMap );

        for ( it = resultsMap.begin(); it != resultsMap.end(); it++ )
            if ( it->second == groundTruths[graphs_to_test[i]][ it->first ])
                totalSuccess_LBP++;


        //showResults( resultsMap );

        //std::cout << "-----------------------------------" << std::endl;
        //std::cout << "        RESULTS TRP" << std::endl;
        //std::cout << "-----------------------------------" << std::endl;

        options.maxIterations = 10000;
        decodeTRPBP.setOptions( options );
        decodeTRPBP.infer( graphs[graphs_to_test[i]], resultsMap );

        for ( it = resultsMap.begin(); it != resultsMap.end(); it++ )
            if ( it->second == groundTruths[graphs_to_test[i]][ it->first ])
                totalSuccess_TRP++;

        //showResults( resultsMap );

        //std::cout << "-----------------------------------" << std::endl;
        //std::cout << "         RESULTS RBP" << std::endl;
        //std::cout << "-----------------------------------" << std::endl;

        options.maxIterations = 10000;
        decodeRBP.setOptions( options );
        //decodeRBP.infer( graphs[graphs_to_test[i]], resultsMap );

        for ( it = resultsMap.begin(); it != resultsMap.end(); it++ )
            if ( it->second == groundTruths[graphs_to_test[i]][ it->first ])
                totalSuccess_RBP++;

        //showResults( resultsMap );

        //std::cout << "-----------------------------------" << std::endl;

        double totalNumberOfNodes = graphs[graphs_to_test[i]].getNodes().size();

        //cout << "Total MaxNodePot success: " << 100*(totalSuccess_MaxNodePot / totalNumberOfNodes) << "%" << endl;
        cout << "Total Greedy     success: " << 100*(totalSuccess_Greedy / totalNumberOfNodes) << "%" << endl;
        cout << "Total ICM        success: " << 100*(totalSuccess_ICM / totalNumberOfNodes) << "%" << endl;
        //cout << "Total Exact      success: " << 100*(totalSuccess_Exact / totalNumberOfNodes) << "%" << endl;
        cout << "Total AlphaExpan success: " << 100*(totalSuccess_AlphaExpansion / totalNumberOfNodes) << "%" << endl;
        cout << "Total AlphaBetaS success: " << 100*(totalSuccess_AlphaBetaSwap / totalNumberOfNodes) << "%" << endl;
        cout << "Total LBP        success: " << 100*(totalSuccess_LBP / totalNumberOfNodes) << "%" << endl;
        cout << "Total TRP        success: " << 100*(totalSuccess_TRP / totalNumberOfNodes) << "%" << endl;
        cout << "Total RBP        success: " << 100*(totalSuccess_RBP / totalNumberOfNodes) << "%" << endl;

        absoluteNumberOfNodes           += totalNumberOfNodes;
        absoluteSuccess_Greedy          += totalSuccess_Greedy;
        absoluteSuccess_ICM             += totalSuccess_ICM;
        absoluteSuccess_AlphaExpansion  += totalSuccess_AlphaExpansion;
        absoluteSuccess_AlphaBetaSwap   += totalSuccess_AlphaBetaSwap;
        absoluteSuccess_LBP             += totalSuccess_LBP;
        absoluteSuccess_TRP             += totalSuccess_TRP;
        absoluteSuccess_RBP             += totalSuccess_RBP;

    /*------------------------------------------------------------------------------
     *
     *                               INFERENCE!
     *
     *----------------------------------------------------------------------------*/

        /*cout << endl;
        cout << "------------------------------------------------------" << endl;
        cout << "                      INFERENCE" << endl;
        cout << "------------------------------------------------------" << endl;


        std::cout << "     LOOPY BELIEF PROPAGATION " << std::endl;
        std::cout << "-----------------------------------" << std::endl;

        CLBPInference LBPInference;

        map<size_t,VectorXd> nodeBeliefs;
        map<size_t,MatrixXd> edgeBeliefs;
        double logZ;

        LBPInference.infer( graphs[graphs_to_test[i]], nodeBeliefs, edgeBeliefs, logZ );

        map<size_t,VectorXd>::iterator itNodeBeliefs;
        for ( itNodeBeliefs = nodeBeliefs.begin(); itNodeBeliefs != nodeBeliefs.end(); itNodeBeliefs++ )
        {
            std::cout << "Node id " << itNodeBeliefs->first << " beliefs (marginals): "
                      << endl << itNodeBeliefs->second << std::endl << std::endl;
        }

        map<size_t,MatrixXd>::iterator itEdgeBeliefs;
        for ( itEdgeBeliefs = edgeBeliefs.begin(); itEdgeBeliefs != edgeBeliefs.end(); itEdgeBeliefs++ )
        {
            std::cout << "Edge id " << itEdgeBeliefs->first << " beliefs (marginals): "
                      << endl << itEdgeBeliefs->second << std::endl << std::endl;
        }

        cout << "Log Z : " << logZ << endl;*/
    }

    }

    cout << " FINAL RESULTS: " << endl;

    //cout << "Total MaxNodePot success: " << 100*(totalSuccess_MaxNodePot / totalNumberOfNodes) << "%" << endl;
    cout << "Total Greedy     success: " << 100*((double)absoluteSuccess_Greedy / absoluteNumberOfNodes) << "%" << endl;
    cout << "Total ICM        success: " << 100*((double)absoluteSuccess_ICM / absoluteNumberOfNodes) << "%" << endl;
    //cout << "Total Exact      success: " << 100*(totalSuccess_Exact / totalNumberOfNodes) << "%" << endl;
    cout << "Total AlphaExpan success: " << 100*((double)absoluteSuccess_AlphaExpansion / absoluteNumberOfNodes) << "%" << endl;
    cout << "Total AlphaBetaS success: " << 100*((double)absoluteSuccess_AlphaBetaSwap / absoluteNumberOfNodes) << "%" << endl;
    cout << "Total LBP        success: " << 100*((double)absoluteSuccess_LBP / absoluteNumberOfNodes) << "%" << endl;
    cout << "Total TRP        success: " << 100*((double)absoluteSuccess_TRP / absoluteNumberOfNodes) << "%" << endl;
    cout << "Total RBP        success: " << 100*((double)absoluteSuccess_RBP / absoluteNumberOfNodes) << "%" << endl;

    // We are ready to take a beer :)

    return 0;
}
Beispiel #22
0
int main(int argc, char** argv)
{
	int args = 1;
#ifdef USE_OPENCL
	if (argc < 10) {
#else
	if (argc < 7) {
#endif
		std::cout << "Not enough arguments" << std::endl;
		system("pause");
		return 1;
	}

	DIM = util::toInt(argv[args++]);
	N = util::toInt(argv[args++]);
	K = util::toInt(argv[args++]);
	ITERATIONS = util::toInt(argv[args++]);
	RUNS = util::toInt(argv[args++]);
#ifdef USE_OPENCL
	AM_LWS = util::toInt(argv[args++]);
	RP_LWS = util::toInt(argv[args++]);
	CT_LWS = util::toInt(argv[args++]);

	USE_ALL_DEVICES = util::toInt(argv[args++]);
#else
	device_count = util::toInt(argv[args++]);
#endif


	std::cout << "DIM = " << DIM << std::endl;
	std::cout << "N = " << N << std::endl;
	std::cout << "K = " << K << std::endl;
	std::cout << "ITERATIONS = " << ITERATIONS << std::endl;
	std::cout << "RUNS = " << RUNS << std::endl;
#ifdef USE_OPENCL
	std::cout << "AM_LWS = " << AM_LWS << std::endl;
	std::cout << "RP_LWS = " << RP_LWS << std::endl;
	std::cout << "CT_LWS = " << CT_LWS << std::endl;
	std::cout << "USE_ALL_DEVICES = " << USE_ALL_DEVICES << std::endl << std::endl;
#else
	std::cout << "device_count = " << device_count << std::endl << std::endl;
#endif


#ifdef _WIN32
	rng.seed();
	srand(GetTickCount());
#else
	rng.seed();
	srand(getTimeMs());
#endif

	u = boost::uniform_real<float>(0.0f, 1000000.0f);
	gen = new boost::variate_generator<boost::mt19937&, boost::uniform_real<float> >(rng, u);

#ifdef USE_OPENCL
	cl_int clError = CL_SUCCESS;
	initCL();

	for (int i = 0; i < clDevices.size(); ++i) {

		clInputBuf.push_back(cl::Buffer(clContext, CL_MEM_READ_ONLY, N * DIM * sizeof(float), NULL, &clError));
		if (clError != CL_SUCCESS) std::cout << "OpenCL Error: Could not create buffer" << std::endl;

		clCentroidBuf.push_back(cl::Buffer(clContext, CL_MEM_READ_WRITE, K * DIM * sizeof(float), NULL, &clError));
		if (clError != CL_SUCCESS) std::cout << "OpenCL Error: Could not create buffer" << std::endl;

		clMappingBuf.push_back(cl::Buffer(clContext, CL_MEM_READ_WRITE, N * sizeof(int), NULL, &clError));
		if (clError != CL_SUCCESS) std::cout << "OpenCL Error: Could not create buffer" << std::endl;

		clReductionBuf.push_back(cl::Buffer(clContext, CL_MEM_WRITE_ONLY, N * sizeof(float), NULL, &clError));
		if (clError != CL_SUCCESS) std::cout << "OpenCL Error: Could not create buffer" << std::endl;

		clClusterAssignment[i].setArgs(clInputBuf[i](), clCentroidBuf[i](), clMappingBuf[i]());
		clClusterReposition[i].setArgs(clInputBuf[i](), clMappingBuf[i](), clCentroidBuf[i]());
		clClusterReposition_k[i].setArgs(clInputBuf[i](), clMappingBuf[i](), clCentroidBuf[i]());
		//clClusterReposition_k_c[i].setArgs(clInputBuf[i](), clMappingBuf[i](), clCentroidBuf[i](), clConvergedBuf[i]());
		clComputeCost[i].setArgs(clInputBuf[i](), clCentroidBuf[i](), clMappingBuf[i](), clReductionBuf[i]());

	}

	device_count = clDevices.size();
#endif

	util::Clock clock;
	clock.reset();

	for (int i = 0; i < RUNS; ++i) {
		mapping_list.push_back(NULL);
		centroids_list.push_back(NULL);
		cost_list.push_back(0.0f);
	}

	float* source = new float[N*DIM];
	for (int i = 0; i < N*DIM; ++i)
		source[i] = gen_random_float();

	input_list.push_back(source);

	for (int i = 1; i < device_count; ++i) {
		float* copy = new float[N*DIM];
		memcpy(copy, source, N*DIM*sizeof(float));
		input_list.push_back(copy);
	}

	if (device_count > 1) {
		boost::thread_group threads;

		for (int i = 0; i < device_count; ++i) {
			threads.create_thread(boost::bind(exec, i, true));
		}

		threads.join_all();
	} else {
		exec(0, false);
	}

#ifdef USE_OPENCL
	reduction_group.join_all();
#endif

	int best_result = 0;
	float best_cost = std::numeric_limits<float>::max();
	for (int i = 0; i < RUNS; ++i) {
		if (cost_list[i] < best_cost) {
			best_cost = cost_list[i];
			best_result = i;
		}
	}

	FILE *out_fdesc = fopen("centroids.out", "wb");
	fwrite((void*)centroids_list[best_result], K * DIM * sizeof(float), 1, out_fdesc);
	fclose(out_fdesc);

	out_fdesc = fopen("mapping.out", "wb");
	fwrite((void*)mapping_list[best_result], N * sizeof(int), 1, out_fdesc);
	fclose(out_fdesc);

	std::cout << "Best result is " << best_result << std::endl;

	for (int i = 0; i < device_count; ++i) {
		delete[] input_list[i];
	}

	for (int i = 0; i < RUNS; ++i) {
		delete[] mapping_list[i];
		delete[] centroids_list[i];
	}

	float now = clock.get();
	std::cout << "Total: " << now << std::endl;

	system("pause");

	return 0;
}
Beispiel #23
0
void modify_seed(unsigned thread)
{
	rng.seed(thread);
}
Beispiel #24
0
int scheduler::batch_run(int max_thread)
{
	// every single line of run stat file
	vector<shared_ptr<stringstream> > pvec_stat_line;// dummy file buffer to write,this buffer is to keep the run stat data output FIFO ordered for post-computation analysis convenience
	// using pointer to work around the problem that stringstream is non-copyable
	{
		try 
		{
			// load batch run script file
			batch_conf batch_conf;
			batch_conf.load_conf(m_batch_conf_path);

			vector<shared_ptr<func_base> > vec_ptr_func;// function object base class pointer
			vector<shared_ptr<para_base> > vec_ptr_para;// parameter object base class pointer
			vector<shared_ptr<alg_base> > vec_ptr_alg;// algorithm object base class pointer

			int num_alg;// number of algorithm wait to test
			num_alg=batch_conf.tasks.size();
			vec_ptr_func.resize(num_alg);
			vec_ptr_para.resize(num_alg);
			vec_ptr_alg.resize(num_alg);
			// pool algo_pool(num_alg<max_thread?num_alg:max_thread);// thread pool of algorithms
			pool algo_pool(max_thread); // thread pool of algorithms
			int cur_task_count=0;

			// batch run of specified algorithm
			int alloc_algo_res;
			int algo_type;
			string conf_path;
			bool first_task_run=true;// first time run of batch run
			bool seq_task_first_time=true;// first time run of single sequential value task
			bool different_algo=true;
			int pre_algo_type=0;
			int i,j;

			vec_task::iterator itr=batch_conf.tasks.begin();
			for ( i=0;itr!=batch_conf.tasks.end();++itr,i++ )
			{
				algo_type=(*itr).algo_code;
				conf_path=(*itr).conf_path;
				// allocate specific algorithm object dynamically
				alloc_algo_res=allocate_alg(algo_type,vec_ptr_alg[i],conf_path);
				allocate_para(algo_type,vec_ptr_para[i],conf_path);
				int load_res;
				// load configuration file data
				load_res=vec_ptr_para[i]->read_para(conf_path);
				if ( -1==load_res )
				{
					cout << "read config file ERROR!" 
						<< "\n";
					return -1;
				}

				different_algo=(pre_algo_type!=algo_type);
				if ( different_algo )
					seq_task_first_time=true;
				int func_type=vec_ptr_para[i]->get_obj_func();// test problem type
				int num_dim=vec_ptr_para[i]->get_dim();// dimension of test problem
				int stop_type=vec_ptr_para[i]->get_stop_type();// termination criterion value
				// allocate Objective Function object dynamically
				int alloc_fun_res=allocate_func(func_type,vec_ptr_func[i],num_dim);
				bool max_gen_set=has_max_gen(stop_type);

				// seed random number generator for EACH task
				gen.seed(static_cast<uint32_t>(time(0)));

				// generate output file name generic prefix
				string str_out_prefix_common;
				str_out_prefix_common=gen_out_prefix_common(algo_type,vec_ptr_func[i],vec_ptr_para[i]);
				if ( first_task_run ) 				// print overall batch run stat file title once
				{
					print_algo_stat_title(run_stat_file,max_gen_set);
					print_common_filelist_title(com_filelist);
					first_task_run=false;
				}
				// start sequential parameter valus SPECIFIC processing
				bool has_seq_val=vec_ptr_para[i]->has_seq_value();
				if ( has_seq_val )
				{
					// open sequential parameter value stat file BEFORE all combination is scheduled
					string para_stat_path=gen_para_stat_file_name(str_out_prefix_common);
					// using heap memory and smart pointer to shared the data to sub-threads
					locked_para_stat_os lps_os={shared_ptr<ostream>(new ofstream(para_stat_path.c_str())),shared_ptr<mutex>(new mutex)};
					shared_ptr<ostream> &ppara_stat_file=lps_os.pos; 
					if ( seq_task_first_time )
					{
						print_para_stat_title(*ppara_stat_file,gen_seq_var_name_str(vec_ptr_para[i]),gen_seq_var_num_str(vec_ptr_para[i]),max_gen_set);
						print_file_name(para_stat_filelist,func_type,algo_type,para_stat_path); 
						seq_task_first_time=false;
					}
					// start sequential paramter value processing
					const vector<string>& seq_var_name=vec_ptr_para[i]->get_seq_var_name_vec();
					const int seq_var_size=seq_var_name.size();
					const vector<int>& seq_dim_size=vec_ptr_para[i]->get_seq_dim_size_vec();
					int comb_num=1;
					// calc total combination number
					for ( j=0;j<seq_var_size;j++ )
						comb_num *= seq_dim_size[j];
					// generate all parameter value combination index
					vector<vector<int> > para_comb_idx;
					para_comb_idx.push_back(vector<int>(seq_var_size,0));
					int cur_dim;
					int last_dim=seq_var_size-1;
					// using this method since seq_var_size is NOT constant,
					// hence we can't use for loop to iterate
					for ( j=1;j<comb_num;j++ )
					{
						cur_dim=last_dim;
						vector<int> cur_comb_idx=para_comb_idx.back(); 
						// find approriate dim to increment index
						while ( cur_comb_idx[cur_dim] == seq_dim_size[cur_dim]-1 )
							cur_dim--;
						cur_comb_idx[cur_dim]++;// 'carry propagation'
						if ( cur_dim<last_dim )
						{
							int j;
							for ( j=cur_dim+1;j<seq_var_size;j++ )
								cur_comb_idx[j]=0;
						}
						para_comb_idx.push_back(cur_comb_idx);
					}

					// start combination schedule
					string cur_para;
					int val_idx;
					vector<int> cur_comb_idx(seq_var_size);
					int k;
					// allocate EXTRA algorithm objects andd function objects
					// Parameters object are SHARED between different parameter value combination(const)
					vector<shared_ptr<alg_base> > vec_seq_alg;
					vector<shared_ptr<func_base> > vec_seq_func;
					vector<shared_ptr<para_base> > vec_seq_para;
					vec_seq_alg.resize(comb_num);
					vec_seq_func.resize(comb_num);
					vec_seq_para.resize(comb_num);
					vec_seq_alg[0]=vec_ptr_alg[i];
					vec_seq_func[0]=vec_ptr_func[i];
					vec_seq_para[0]=vec_ptr_para[i];
					for ( k=1;k<comb_num;k++ )
					{
						allocate_alg(algo_type,vec_seq_alg[k],conf_path);
						allocate_func(func_type,vec_seq_func[k],num_dim);
						allocate_para(algo_type,vec_seq_para[k],conf_path);
						(*vec_seq_para[k])=(*vec_ptr_para[i]);// copy parameter values
					}
					for ( k=0;k<comb_num;k++ )
					{
						// alter the sequential parameter value for grouped run
						cur_comb_idx=para_comb_idx[k];
						int j;
						for ( j=0;j<seq_var_size;j++ )
						{
							cur_para=seq_var_name[j];
							val_idx=cur_comb_idx[j];
							vec_seq_para[k]->set_cur_seq_val_idx(cur_para,val_idx);
						}
						// all combination values are set
						// set task description text for output
						string str_out_prefix_para;
						str_out_prefix_para=gen_out_prefix_para(vec_seq_para[k],"_");
						vec_seq_alg[k]->set_para_val_desc(gen_seq_val_str(vec_seq_para[k]));
						string str_para_stat=gen_out_prefix_para(vec_seq_para[k],",");
						// output common stat file path list for post-computation plotting and analysis
						common_path com_out_path;// common stat file output
						gen_common_file_path(com_out_path,str_out_prefix_common,str_out_prefix_para);
						vec_seq_alg[k]->set_com_file_path(com_out_path);
						print_common_filelist(com_filelist,func_type,algo_type,com_out_path);
						print_para_stat_All_Best_Val_Path(para_stat_all_bst_val_filelist,func_type,str_para_stat,com_out_path.all_bst_val_path);// sequential parameters tuning SPECIFIC
						//  set algorithm specific stat file name
						algo_spec_output(func_type,algo_type,vec_seq_alg[k],str_out_prefix_common,str_out_prefix_para);

						// run the algo according to single parameter value combination
						vec_seq_alg[k]->set_eval_func(vec_seq_func[k]);
						vec_seq_alg[k]->load_parameter(vec_seq_para[k]);// Loading algorithm parameters from outer source

						vec_seq_alg[k]->initialize();
						// progress_timer p_t;// timer of specified algorithm
						cur_task_count++;
						output_running_prompt(cur_task_count,vec_seq_para[k]);
						pvec_stat_line.push_back(shared_ptr<stringstream>(new stringstream));// expand size by 1
						shared_ptr<stringstream> pcur_line=pvec_stat_line.back();
						shared_ptr<boost::mutex> pmutex=lps_os.pmut;
						algo_pool.schedule( 
							boost::bind(thread_fun,vec_seq_alg[k],func_type,algo_type,
							max_gen_set,has_seq_val,pcur_line,
							ppara_stat_file,pmutex ) 
							);
					}// for every single value combination
				}
				else
				{
					// NO value combination:no need to schedule
					common_path com_out_path;
					gen_common_file_path(com_out_path,str_out_prefix_common,"");
					vec_ptr_alg[i]->set_com_file_path(com_out_path);
					print_common_filelist(com_filelist,func_type,algo_type,com_out_path);
					algo_spec_output(func_type,algo_type,vec_ptr_alg[i],str_out_prefix_common,"");
					// run the algo according to specified parameter value combination
					vec_ptr_alg[i]->set_eval_func(vec_ptr_func[i]);
					vec_ptr_alg[i]->load_parameter(vec_ptr_para[i]);// Loading algorithm parameters from outer source

					vec_ptr_alg[i]->initialize();

					// progress_timer p_t;// timer of specified algorithm
					cur_task_count++;
					output_running_prompt(cur_task_count,vec_ptr_para[i]);
					pvec_stat_line.push_back(shared_ptr<stringstream>(new stringstream));// expand size by 1,use heap memory to shared the data between main thread and sub-thread 
					shared_ptr<stringstream> pcur_line=pvec_stat_line.back();
					algo_pool.schedule(
							boost::bind(thread_fun, vec_ptr_alg[i], func_type,
									algo_type, max_gen_set, has_seq_val,
									pcur_line, shared_ptr<ostream>(),
									shared_ptr<boost::mutex>()));
				}// if ( has_seq_val )
				pre_algo_type=algo_type;
			}// for every single algorithm task
		}// try
		catch(bad_cast &bc)
		{
			cout<<"bad_cast caught in batch_run:" 
				<< bc.what() << "\n";
			return -1;
		}
		catch(logic_error &le)
		{
			cout<<"logic_error caught in batch_run:" 
				<< le.what() << "\n";
			return -1;
		}
		catch(exception& e) 
		{
			cout<<"exception caught in batch_run:" 
				<<e.what()<< "\n";
			return -1;
		}
	}
	// all task are finished
	print_stat_file(pvec_stat_line);// keep run stat file output data ordered according to FIFO
	return 0;
}// end function batch_run
Beispiel #25
0
void UPGMpp::getSpanningTree( CGraph &graph, std::vector<size_t> &tree)
{
    // TODO: The efficiency of this method can be improved

    // Reset tree
    tree.clear();

    static boost::mt19937 rng;
    static bool firstExecution = true;

    if ( firstExecution )
    {
        rng.seed(time(0));
        firstExecution = false;
    }

    vector<CNodePtr> &v_nodes = graph.getNodes();
    vector<CNodePtr> v_nodesToExplore;
    map<size_t,size_t> nodesToExploreMap;
    size_t N_nodes = v_nodes.size();

    //cout << "Random: ";

    for ( size_t i_node = 0; i_node < N_nodes; i_node++ )
    {        
        boost::uniform_real<> real_generator(0,1);
        real_generator.reset();
        double rand = real_generator(rng);

        //cout << rand << " ";

        if ( rand > 0.25 )
        {
            v_nodesToExplore.push_back( v_nodes[i_node] );
            nodesToExploreMap[ v_nodes[i_node]->getID() ] =  v_nodesToExplore.size()-1;
        }

    }

    //cout << endl;

    //SHOW_VECTOR_NODES_ID("Nodes to explore: ", v_nodesToExplore)

    size_t N_nodesToExplore = v_nodesToExplore.size();

    if ( !N_nodesToExplore )
        return;

    bool nodeAdded = true;
    vector<bool> v_nodesAdded( N_nodesToExplore, false );

    //
    // Randomly select the root node
    //

    boost::uniform_int<> generator(0,N_nodesToExplore-1);
    int rand = generator(rng);

    //cout << "Root:" << rand << endl;

    v_nodesAdded[rand] = true;
    multimap<size_t, CEdgePtr> &edgesF = graph.getEdgesF();

    while ( nodeAdded )
    {
        nodeAdded = false;

        for ( size_t i_node = 0; i_node < N_nodesToExplore; i_node++ )
        {
            //cout << "Node " << i_node << " ID "<< v_nodesToExplore[i_node]->getID() << " Added? " << v_nodesAdded[i_node] << endl;

            // Check that the node has not been added to the tree yet
            if ( !v_nodesAdded[i_node] )
            {
                size_t nodeID = v_nodesToExplore[i_node]->getID();

                NEIGHBORS_IT neighbors = edgesF.equal_range(nodeID);

                for ( multimap<size_t,CEdgePtr>::iterator itNeigbhor = neighbors.first;
                      itNeigbhor != neighbors.second;
                      itNeigbhor++ )
                {

                    CEdgePtr edgePtr = (*itNeigbhor).second;
                    size_t neighborID;

                    if ( !edgePtr->getNodePosition( nodeID ) )
                        neighborID = edgePtr->getSecondNodeID();
                    else
                        neighborID = edgePtr->getFirstNodeID();

                    //cout << "Current node ID: " << nodeID << " neighbor: " << neighborID << endl;

                    if ( v_nodesAdded[nodesToExploreMap[neighborID]] )
                    {
                        v_nodesAdded[i_node] = true;
                        nodeAdded = true;
                    }
                }

            }
        }
    }

    //SHOW_VECTOR("Nodes in tree: ", v_nodesAdded)

    for ( size_t i_node = 0; i_node < v_nodesToExplore.size(); i_node++ )
    {        
        if ( v_nodesAdded[i_node] )
            tree.push_back( v_nodesToExplore[i_node]->getID() );
    }

    //SHOW_VECTOR("Tree: ", tree)
}