/* solve the problem */
int main (int argc, char *argv[]) {
	int p, q, l, r, loop, result;
	int **schedules;
	if (debug_on)
		printf("\nP7 - Chat Online:\n");
	schedules = readArgs(&p, &q, &l, &r, argc, argv);
	if (debug_on)
		printArgs(p,q,l,r,schedules);

	if (p<1 || p>50 || q<1 || q>50 || l<0 || l>1000 || r<0 || r>1000) {
		printf("Invalid schedules. Aborting...\n");
		printf("\n--------------------\n");
		return 1;	
	}
	if (debug_on)
		printf("\nProblem Solution:\n");

	result = 0;
	for (loop=l; loop<=r; loop++) {
		if (momentSuits(loop,p,q,schedules) == true)
			result++;
	}
	printf("%d", result);

	if (debug_on)
		printf("\n--------------------\n");
	return 0;
}
/* solve the problem */
int main (int argc, char *argv[]) {
	int n;
	long wallsToPaint;
	char labyrinth[MAX_SIZE][MAX_SIZE];
	int wasProcessed[MAX_SIZE][MAX_SIZE];
	#ifdef debug_on
		printf("\nP12 - Labyrinth:\n");
	#endif

	n = readArgs(labyrinth, argc, argv);

	#ifdef debug_on
		printArgs(n,labyrinth);
		printf("\nProblem Solution:\n");
	#endif

	/* Solution */
	wallsToPaint = process(0,0,n,labyrinth,wasProcessed);
	if (wasProcessed[n-1][n-1] == 0)
		wallsToPaint += process(n-1,n-1,n,labyrinth,wasProcessed);
	printf("%ld\n", 3*3*wallsToPaint);

	#ifdef debug_on
		printf("\n--------------------\n");
	#endif
	return 0;
}
/**
 * \brief    Main function
 * \details  --
 * \param    int argc
 * \param    char const** argv
 * \return   \e int
 */
int main( int argc, char const** argv )
{
  /*------------------------------------------------*/
  /* 1) read command line arguments                 */
  /*------------------------------------------------*/
  size_t backup_start = 0;
  size_t backup_end   = 0;
  size_t backup_step  = 0;
  readArgs(argc, argv, backup_start, backup_end, backup_step);
  
  /*------------------------------------------------*/
  /* 2) print header                                */
  /*------------------------------------------------*/
  printHeader();
  
  /*------------------------------------------------*/
  /* 3) recover the simulation state at each backup */
  /*------------------------------------------------*/
  std::ofstream file("./statistics/SL_diversity.txt", std::ios::out | std::ios::trunc);
  file << "backup SpA SpB\n";
  size_t current_step = backup_start;
  while (current_step <= backup_end)
  {
    std::cout << "> Working with backup " << current_step << " ...\n";
    
    /*----------------------------------------*/
    /* 3.1) Open the backups                  */
    /*----------------------------------------*/
    Parameters* parameters = new Parameters(current_step);
    Simulation* simulation = new Simulation(parameters, current_step, false);
    simulation->initialize(FROM_BACKUP);
    
    /*----------------------------------------*/
    /* 3.2) Compute SL diversity and write it */
    /*----------------------------------------*/
    double Sp_A  = 0.0;
    double Sp_B  = 0.0;
    double depth = (double)current_step-simulation->get_phylogenetic_tree()->get_common_ancestor_age();
    simulation->get_phylogenetic_tree()->compute_common_ancestor_SL_repartition(Sp_A, Sp_B);
    if (Sp_A != -1.0 && Sp_B != -1.0)
    {
      file << current_step << " " << Sp_A << " " << Sp_B << " " << depth << "\n";
    }
    
    /*----------------------------------------*/
    /* 3.3) Free memory                       */
    /*----------------------------------------*/
    delete simulation;
    simulation = NULL;
    delete parameters;
    parameters = NULL;
    current_step += backup_step;
  }
  file.close();
  return EXIT_SUCCESS;
}
Exemplo n.º 4
0
Arquivo: lzw.c Projeto: g-mainak/LZW
int main(int argc, char **argv)
{
	int* args = readArgs(argc, argv);
	if(args[0])
		decode();
	else
		encode(args);
	free(args);
	return 0;
}
Exemplo n.º 5
0
//
// SourceTokenizerC::expand
//
// Expands a token.
//
void SourceTokenizerC::expand(MacroVec &out, std::set<std::string> &used,
   SourcePosition const &pos, SourceTokenC::Reference tok, SourceStream *in,
   MacroArgs const *altArgs, MacroParm const *altParm)
{
   // Check for function-like macro expansion.
   // That is, a function-like macro name followed by an open parenthesis.
   // And of course, that name must not have been expanded yet.
   if(tok->type == SourceTokenC::TT_PAREN_O &&
      !out.empty() && out.back()->type == SourceTokenC::TT_NAM &&
      hasMacro(out.back()->data) && !used.count(out.back()->data))
   {
      tok = out.back(); out.pop_back();
      MacroData const &mdata = macros[tok->data];
      MacroArgs margs;
      readArgs(margs, in, mdata, pos, altArgs, altParm);

      used.insert(tok->data);
      expand(out, used, pos, mdata, margs);
      used.erase(tok->data);

      return;
   }

   // Check for object-like macro expansion.
   // Like above, but it only needs one token to trigger.
   if(tok->type == SourceTokenC::TT_NAM && hasDefine(tok->data) && !used.count(tok->data))
   {
      used.insert(tok->data);
      expand(out, used, pos, defines[tok->data]);
      used.erase(tok->data);

      return;
   }

   // Then check for __FILE__ specifically.
   if(tok->type == SourceTokenC::TT_NAM && tok->data == "__FILE__")
   {
      out.push_back(SourceTokenC::create(pos, pos.filename, SourceTokenC::TT_STR));

      return;
   }

   // And __LINE__.
   if(tok->type == SourceTokenC::TT_NAM && tok->data == "__LINE__")
   {
      std::ostringstream oss; oss << pos.line;
      out.push_back(SourceTokenC::create(pos, oss.str(), SourceTokenC::TT_INT));

      return;
   }

   // If it actually isn't any of those things, then consider the token expanded.
   out.push_back(tok);
}
Exemplo n.º 6
0
int main (int argc, char* argv[]) {
	int status;
	Ice::CommunicatorPtr ic;

	try {
		ic = Ice::initialize(argc, argv);
		readArgs(&argc, argv);


		// Contact to Encoders
		Ice::ObjectPrx Encoders = ic->propertyToProxy("automata.Encoders.Proxy");
		if (Encoders == 0)
			throw "Could not create proxy with Encoders";
		Encodersprx = jderobot::EncodersPrx::checkedCast(Encoders);
		if (Encodersprx == 0)
			throw "Invalid proxy automata.Encoders.Proxy";
		std::cout << "Encoders connected" << std::endl;

		// Contact to Motors
		Ice::ObjectPrx Motors = ic->propertyToProxy("automata.Motors.Proxy");
		if (Motors == 0)
			throw "Could not create proxy with Motors";
		Motorsprx = jderobot::MotorsPrx::checkedCast(Motors);
		if (Motorsprx == 0)
			throw "Invalid proxy automata.Motors.Proxy";
		std::cout << "Motors connected" << std::endl;

		if (displayGui){
			automatagui = new AutomataGui(argc, argv);
			displayGui = showAutomataGui();
		}

		pthread_create(&thr_sub_1, NULL, &subautomata_1, NULL);
		pthread_create(&thr_sub_2, NULL, &subautomata_2, NULL);
		pthread_create(&thr_sub_3, NULL, &subautomata_3, NULL);

		pthread_join(thr_sub_1, NULL);
		pthread_join(thr_sub_2, NULL);
		pthread_join(thr_sub_3, NULL);
		if (displayGui)
			pthread_join(thr_automatagui, NULL);
	} catch ( const Ice::Exception& ex ) {
		std::cerr << ex << std::endl;
		status = 1;
	} catch ( const char* msg ) {
		std::cerr << msg << std::endl;
		status = 1;
	}

	if (ic)
		ic->destroy();

	return status;
}
Exemplo n.º 7
0
int main(int argc, char *argv[])
{
#ifdef _WIN32
	WSADATA wsaData;
	int result = WSAStartup(MAKEWORD(1, 1), &wsaData);
	if (result != 0) {
		fprintf(stderr, "Your computer was not connected "
			"to the Internet at the time that "
			"this program was launched, or you "
			"do not have a 32-bit "
			"connection to the Internet.");
		exit(1);
	}
#else
	openlog("rinetd", LOG_PID, LOG_DAEMON);
#endif

	readArgs(argc, argv, &options);

#if HAVE_DAEMON && !DEBUG
	if (!options.foreground && daemon(0, 0) != 0) {
		exit(0);
	}
#elif HAVE_FORK && !DEBUG
	if (!options.foreground && fork() != 0) {
		exit(0);
	}
#endif

#if HAVE_SIGACTION
	struct sigaction act;
	act.sa_handler = SIG_IGN;
	sigemptyset(&act.sa_mask);
	act.sa_flags = SA_RESTART;
	sigaction(SIGPIPE, &act, NULL);
	act.sa_handler = &hup;
	sigaction(SIGHUP, &act, NULL);
#elif !_WIN32
	signal(SIGPIPE, plumber);
	signal(SIGHUP, hup);
#endif
	signal(SIGINT, quit);
	signal(SIGTERM, quit);

	readConfiguration();
	registerPID();

	syslog(LOG_INFO, "Starting redirections...");
	while (1) {
		selectPass();
	}

	return 0;
}
Exemplo n.º 8
0
int main (int argc, const char * argv[]) 
{
    int port = DEFAULT_PORT;    
    int bufferSize = DEFAULT_BUFFER_SIZE;
    bool isQuiet = DEFAULT_QUIET;
    bool isDebug = DEFAULT_DEBUG;
    int maxClient = DEFAULT_MAXCLIENT;

    signal(SIGINT, signalHandler);
    signal(SIGTERM, signalHandler);
    
    readArgs(argc,argv,&port,&bufferSize,&isQuiet,&isDebug,&maxClient);

    logger.setQuiet(isQuiet);
    logger.setDebug(isDebug);
    
    if(!isQuiet)
    {
        printInfo(port,bufferSize,isDebug,maxClient);
    }
    
    List<Client*> list;
    sf::Mutex listMutex;

    sf::SocketSelector selector;
    
    Buffer exchangeBuffer;
    setupExchangeBuffer(&exchangeBuffer, bufferSize);

    logger.printLog("Init'ed ...");
    
    ClientsContainer container(&list,&listMutex,&selector);
    
    
    sf::Thread answerThread(&answerToClient,AnswerDataSet(&container,port,maxClient));
    answerThread.launch();


    sf::Thread checkThread(&checkForInputs,CheckDataSet(&container,&exchangeBuffer));
    checkThread.launch();
    
    while(1) //TODO graphic stats
    {
        if(checkStopThreads())
        {
            break;
        }
        sf::sleep(sf::milliseconds(5));
    }
    
    return 0;
}
Exemplo n.º 9
0
CollectionScanner::CollectionScanner( int &argc, char **argv )
        : QCoreApplication( argc, argv )
        , m_batch( false )
        , m_importPlaylists( false )
        , m_batchFolderTime()
        , m_recursively( false )
        , m_incremental( false )
        , m_restart( false )
        , m_amarokCollectionInterface( 0 )
{
    setObjectName( "amarokcollectionscanner" );

    //seed for unique id generation if file lookup fails
    srand( (unsigned)time( 0 ) );
    s_time.start();

    readArgs();

#ifdef TAGLIB_EXTRAS_FOUND
    TagLib::FileRef::addFileTypeResolver(new MP4FileTypeResolver);
    TagLib::FileRef::addFileTypeResolver(new ASFFileTypeResolver);
    TagLib::FileRef::addFileTypeResolver(new RealMediaFileTypeResolver);
    TagLib::FileRef::addFileTypeResolver(new AudibleFileTypeResolver);
    TagLib::FileRef::addFileTypeResolver(new WavFileTypeResolver);
#endif

    m_logfile = ( m_batch ? ( m_incremental ? "amarokcollectionscanner_batchincrementalscan.log" : "amarokcollectionscanner_batchfullscan.log" )
                       : m_saveLocation + "collection_scan.log" );
    
    if( !m_restart )
        QFile::remove( m_logfile );

    if( !m_collectionId.isEmpty() )
    {
        if( m_amarokPid.isEmpty() )
            m_amarokCollectionInterface = new QDBusInterface( "org.kde.amarok", "/SqlCollection/" + m_collectionId );
        else
            m_amarokCollectionInterface = new QDBusInterface( "org.kde.amarok-" + m_amarokPid, "/SqlCollection/" + m_collectionId );
    }

    if( m_batch && m_incremental )
    {
        bool success = readBatchIncrementalFile();
        if( !success )
            return;
    }

    QTimer::singleShot( 0, this, SLOT( doJob() ) );
}
Exemplo n.º 10
0
int main(int argc, char *argv[]) {
    char *inFile;     /* Name of the file with image names one per line */
    char *outFile;    /* Name of the file to which results are written */
    FSU* head = NULL; /* Head pointer to the linked list of subjects */

    if (PRINT_LEVEL > 0)
        printf("\n%s\n%s", OPENNING, VERSION);
    readArgs(argc, argv, &inFile, &outFile);

    if (PRINT_LEVEL > 0)
        printf("\nReading from %s and building subject/replicates linked lists.", inFile);
    head = insertSubjectsFromFile(inFile);

    printSubjectReplicatesFile(head, outFile);
    if (PRINT_LEVEL > 0)
        printf("\nFinished. \n");
    return 0;
}
Exemplo n.º 11
0
//
// SourceTokenizerC::expandMacro
//
void SourceTokenizerC::expandMacro(SourceTokenC *tok)
{
   MacroVec out;
   MacroArgs args;
   MacroData const &data = macros[tok->data];
   std::set<std::string> used;

   // Process the arguments, preserving whitespace in TT_NONEs.
   readArgs(args, inStack.back(), data, tok->pos);

   // Invoke the macro expander, capturing the result in out.
   used.insert(tok->data);
   expand(out, used, tok->pos, data, args);
   used.erase(tok->data);

   // Push out onto the unget stack.
   for(MacroVec::iterator end = out.begin(), itr = out.end(); itr-- != end;)
      ungetStack.push_back(*itr);
}
Exemplo n.º 12
0
CollectionScanner::Scanner::Scanner( int &argc, char **argv )
        : QCoreApplication( argc, argv )
        , m_charset( false )
        , m_newerTime(0)
        , m_incremental( false )
        , m_recursively( false )
        , m_restart( false )
        , m_idlePriority( false )
{
    setObjectName( "amarokcollectionscanner" );

    readArgs();

    if( m_idlePriority )
    {
        if( QThread::currentThread() )
            QThread::currentThread()->setPriority( QThread::IdlePriority );
    }
}
Exemplo n.º 13
0
int main(int argc, char** argv)
{
    Inputs inputs = readArgs(argc, argv);

    auto begin = std::chrono::high_resolution_clock::now();

    Result r;
    switch (inputs.algorithm)
    {
    case Algorithm::GREEDY:
        r = greedyAlgorithm(inputs);
        break;
    case Algorithm::DYNAMIC:
        r = dynamicAlgorithm(inputs);
        break;
    case Algorithm::LOCAL:
        r = localAlgorithm(inputs);
        break;
    default:
        std::cout << "Error, unknown algorithm" << std::endl;
        break;
    }

    auto end = std::chrono::high_resolution_clock::now();
    double elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count() / 1000000000.0;

    if (inputs.benchmark) {
        std::cout << r.revenu << std::endl << elapsed;
    }
    else {
        if (inputs.print) {
            std::cout << "Emplacements : ";
            for (auto loc : r.locations) {
                std::cout << loc.id << " ";
            }
            std::cout << std::endl << "Revenu : " << r.revenu << std::endl;
        }

        std::cout << "Temps : " << elapsed << "s" << std::endl;
    }
}
int main(int argc, char *argv[])
{
	WSADATA wsaData;
	int result = WSAStartup(MAKEWORD(1, 1), &wsaData);
	if (result != 0) {
		fprintf(stderr, "Your computer was not connected "
			"to the Internet at the time that "
			"this program was launched, or you "
			"do not have a 32-bit "
			"connection to the Internet.");
		exit(1);
	}
	readArgs(argc, argv, &options);
#ifndef WIN32
#ifndef DEBUG
	if (!fork()) {
		if (!fork()) {
#endif /* DEBUG */
			signal(SIGPIPE, plumber);
			signal(SIGHUP, hup);
#endif /* WIN32 */
			signal(SIGTERM, term);
			initArrays();
			readConfiguration();
			RegisterPID();
			selectLoop();
#ifndef WIN32
#ifndef DEBUG
		} else {
			exit(0);
		}
	} else {
		exit(0);
	}
#endif /* DEBUG */
#endif /* WIN32 */
	return 0;
}
Exemplo n.º 15
0
int main(int argc, char *argv[]){
  toCargs *pars;
  if(argc<12){
    std::cout << "\t-> Please input -g GENOTYPEFILE -LD {0,1} -back BACK -threshold prune_val -filename OUTPUTDATA -snps KEEPLIST\n";
    return 0;
  }
  //get commandline args
  pars = readArgs(argc,argv);
  pars->doPrune = 1;
  
  //check if fileexists
  if(fexists(pars->data_filename)){
    printf("\t-> outputfile:%s exists, will exit\n",pars->data_filename.c_str());
    return 0;
  }
  if(fexists(pars->usedSnps_filename)){
    printf("\t-> outputfile:%s exists will exit\n",pars->usedSnps_filename.c_str());
    return 0;
  }

  //run prune
  prune object;
  print_functionPars(pars);
  fromCres *fromObject = object.main_run(pars);


  //write results
  write_iMatrix_to_file(pars->data_filename,fromObject->data);
  write_iArray_to_file(pars->usedSnps_filename,fromObject->usedSnps);

  killArray(fromObject->usedSnps);
  killMatrix(fromObject->data);
  killMatrix(pars->data);

  return 0;
}
Exemplo n.º 16
0
Arquivo: shell.c Projeto: Surtr04/misc
int main () {

	signal(SIGINT,killChild);
	signal(SIGSTOP,stop);
	signal(SIGCHLD,children);
	int bg;
	char *in,*out;
	in = out = NULL;

	char *exec = readInput(&bg);
	char *command;

	while(strcmp(exec,"exit") != 0) {
		char **args = readArgs(exec,&in,&out);
		if(strcmp(args[0],"cd") == 0) {
			chdir(args[1]);
		}
		command = exec;
		run(args,bg,command,in,out);
		free(exec);
		exec = readInput(&bg);
	}

}
Exemplo n.º 17
0
void readCommand() {
	/* allocate files used for redirection of stderr, stdin, stdout */
	char  **file = calloc(3, sizeof(char*));
  	if (!file) {
  		memoryError();
  	}

	for (int i = 0; i < 3; i++)
	{
	    file[i] = calloc(MAX_INPUT_LENGTH + 1, sizeof(char));
	    if (!file[i]) {
	      	memoryError();
	    }
	}

	/* initialize status to designate different modes as identified in #defines */
	status parseStatus = 0;
	
	char** args = readArgs(&parseStatus, file); 	
	
	/* determine whether shell should exit after executing command */
	bool terminate = EOF_FOUND & parseStatus;
	//Bit masking is used to use a single value for status.
	switch(parseStatus & (INVALID_SYNTAX | INVALID_ESCAPE)){
		case INVALID_SYNTAX:
			printf("Error: Invalid syntax.\n");
			if (terminate)
				do_exit();			
			return;
		case INVALID_ESCAPE:
			printf("Error: Unrecognized escape sequence.\n");
			if (terminate)
				do_exit();			
			return;
	}

	/* if "exit" is inputted, quit the shell */
	if (args[0]) {
		if (args[1] == NULL && strncmp(args[0], EXIT_COMMAND, strlen(EXIT_COMMAND)) == 0) {
			do_exit();
		}
	}
	
 	int restore_stdout = 0;
	int restore_stdin = 0; 
	int restore_stderr = 0; 
 	int f = -1;
	
	/* check if any redirection was requested and set up proper files */
	if (parseStatus & REDIR_STDOUT)
	{ 
		/*open afile with read and write permissions for the user. */
		/*Create it if needed, and truncate it if opened*/
		f = open(file[STDOUT],O_RDWR|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR); 
		if (f == -1) //-1 indicates that there was a problem with the file
		{
			printf("Error: Invalid syntax.\n");
			if (terminate) {//if it is EOF, terminate
				do_exit();
			}
			return; //otherwise, print another prompt
		}
		/*Open a file with the path "file" and the intention to read and write from it. */
		/*If it does not exist create it and give read and write permissions to the user*/
        	restore_stdout = dup(STDOUT); //keep a copy of STDOUT
        	close(STDOUT); //Close STDOUT
		dup(f); //Copy the same file descriptor but set it to the newly closed STDOUT
		close(f); //Close original file
	}
	if (parseStatus & REDIR_STDERR)
	{
		f = open(file[STDERR],O_RDWR|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR); 
		if (f == -1)
		{
			printf("Error: Invalid syntax.\n");
			if (terminate) {
				do_exit();
			}
			return;
		}
        	restore_stderr = dup(STDERR); //keep a copy of STDOUT
        	close(STDERR); //Close STDOUT
		dup(f); //Copy the same file descriptor but set it to the newly closed STDOUT
		close(f); //Close original file
	}
	if (parseStatus & REDIR_STDIN)//type==(2<<STDIN))
	{ 
		/*Do not create a file, as it would be empty and useless to STDIN*/
		/*Open as read only because it is an input source*/
		f = open(file[STDIN],O_RDONLY); 
		if (f == -1)
		{
			printf("Error: Unable to open redirection file.\n");
			if (terminate) {
				do_exit();
			}
			return;
		}
        	restore_stdin = dup(STDIN); 
        	close(STDIN); 
		dup(f); 
		close(f); 
	}

  /* workaround to allow 'cd' command */
  if(args[0] && strncmp(args[0], "cd", 2) == 0)
  {
     int error = 0; 
     if(args[1])
     	  error = chdir(args[1]);
     else
	error = chdir("/home");
     if(error)
	printf("cd: %s: No such file or directory\n",args[1]);
	
	return;
  }
  
  pid_t parent = fork();
  
  if (parent < 0) {
    printf("Error: process creation failed");  
    do_exit();
  }

  /* if we are in the child process, execute the command */
  else if (!parent) {
    if (execvp(args[0], args)) {
    	if((*args)[0]) {
          printf("Error: ");
          switch(errno) { //based on values in `man errno`
            case 1: printf("Permission denied.\n"); break;
            case 2: printf("Command not found.\n"); break;
	    case 13: printf("Permission denied.\n"); break;
            default: printf("Unkown error.\n"); break;
    	    }
      }
    }
    exit(0);
  } else {
	/* in parent, wait for child if not a background process */
	if (!(parseStatus & BACKGROUND)) {  
    		waitpid(parent, NULL, 0);
	}
    	if (terminate) {
      		do_exit();
   	}
  }

  /* restore any file redirections as necessary */
  if(restore_stdin)
  {
  	close(STDIN);
  	dup(restore_stdin);
  	close(restore_stdin);
  }
  if(restore_stdout)
  {
  	close(STDOUT);
  	dup(restore_stdout);
  	close(restore_stdout);
  }
  if(restore_stderr)
  {
  	close(STDERR);
  	dup(restore_stderr);
  	close(restore_stderr);
  }

  /* free all allocated memory */
  for (int i = 0; i < 3; i++) {
    free(file[i]);
  }
  free(file);
  deleteArgs(args);
  free(args);
}
Exemplo n.º 18
0
int main(int argc, char * const * argv)
{
    ExitStatus      result    = EX_SOFTWARE;
    KcgenArgs       toolArgs;
    Boolean         fatal     = false;

   /*****
    * Find out what the program was invoked as.
    */
    progname = rindex(argv[0], '/');
    if (progname) {
        progname++;   // go past the '/'
    } else {
        progname = (char *)argv[0];
    }

   /* Set the OSKext log callback right away.
    */
    OSKextSetLogOutputFunction(&tool_log);
    
   /* Make the library not sort opened kexts by version for bundle ID lookups.
    */
    _OSKextSetStrictRecordingByLastOpened(TRUE);

   /*****
    * Check if we were spawned by kextd, set up straightaway
    * for service log filtering, and hook up to ASL.
    */
    if (getenv("KEXTD_SPAWNED")) {
        OSKextSetLogFilter(kDefaultServiceLogFilter | kOSKextLogKextOrGlobalMask,
            /* kernel? */ false);
        OSKextSetLogFilter(kDefaultServiceLogFilter | kOSKextLogKextOrGlobalMask,
            /* kernel? */ true);
        tool_openlog("com.apple.kcgen");
    }

   /*****
    * Process args & check for permission to load.
    */
    result = readArgs(&argc, &argv, &toolArgs);
    if (result != EX_OK) {
        if (result == kKcgenExitHelp) {
            result = EX_OK;
        }
        goto finish;
    }

    result = checkArgs(&toolArgs);
    if (result != EX_OK) {
        goto finish;
    }

   /* From here on out the default exit status is ok.
    */
    result = EX_OK;

   /* The whole point of this program is to update caches, so let's not
    * try to read any (we'll briefly turn this back on when checking them).
    */
    OSKextSetUsesCaches(false);

   /* If we're compressing the prelinked kernel, take care of that here
    * and exit.
    */
    if (toolArgs.prelinkedKernelPath && !CFArrayGetCount(toolArgs.argURLs) &&
        (toolArgs.compress || toolArgs.uncompress)) 
    {
        result = compressPrelinkedKernel(toolArgs.prelinkedKernelPath, toolArgs.compress);
        goto finish;
    }

   /*****
    * Read the kexts we'll be working with; first the set of all kexts, then
    * the repository and named kexts for use with mkext-creation flags.
    */
    if (toolArgs.printTestResults) {
        OSKextSetRecordsDiagnostics(kOSKextDiagnosticsFlagAll);
    }
    toolArgs.allKexts = OSKextCreateKextsFromURLs(kCFAllocatorDefault, toolArgs.argURLs);
    if (!toolArgs.allKexts || !CFArrayGetCount(toolArgs.allKexts)) {
        OSKextLog(/* kext */ NULL,
            kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
            "Error - no kernel extensions found.");
        result = EX_SOFTWARE;
        goto finish;
    }

    toolArgs.repositoryKexts = OSKextCreateKextsFromURLs(kCFAllocatorDefault,
        toolArgs.repositoryURLs);
    toolArgs.namedKexts = OSKextCreateKextsFromURLs(kCFAllocatorDefault,
        toolArgs.namedKextURLs);
    if (!toolArgs.repositoryKexts || !toolArgs.namedKexts) {
        OSKextLog(/* kext */ NULL,
            kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
            "Error - failed to read extensions.");
        result = EX_SOFTWARE;
        goto finish;
    }

    if (result != EX_OK) {
        goto finish;
    }

    if (toolArgs.prelinkedKernelPath) {
        result = createPrelinkedKernel(&toolArgs);
        if (result != EX_OK) {
            goto finish;
        }

    }

finish:

   /* We're actually not going to free anything else because we're exiting!
    */
    exit(result);

    SAFE_RELEASE(toolArgs.kextIDs);
    SAFE_RELEASE(toolArgs.argURLs);
    SAFE_RELEASE(toolArgs.repositoryURLs);
    SAFE_RELEASE(toolArgs.namedKextURLs);
    SAFE_RELEASE(toolArgs.allKexts);
    SAFE_RELEASE(toolArgs.repositoryKexts);
    SAFE_RELEASE(toolArgs.namedKexts);
    SAFE_RELEASE(toolArgs.kernelFile);
    SAFE_RELEASE(toolArgs.symbolDirURL);
    SAFE_FREE(toolArgs.prelinkedKernelPath);
    SAFE_FREE(toolArgs.kernelPath);

    return result;
}
ExitStatus main(int argc, char * const * argv)
{
    ExitStatus          result        = EX_OK;
    KextstatArgs        toolArgs;
    CFDictionaryRef   * kextInfoList  = NULL;  // must free
    CFIndex             count, i;

    if (argv[0]) {
        progname = argv[0];
    }

   /* Set the OSKext log callback right away.
    */
    OSKextSetLogOutputFunction(&tool_log);

    result = readArgs(argc, argv, &toolArgs);
    if (result != EX_OK) {
        if (result == kKextstatExitHelp) {
            result = EX_OK;
        }
        goto finish;
    }

    toolArgs.runningKernelArch = OSKextGetRunningKernelArchitecture();
    if (!toolArgs.runningKernelArch) {
        result = EX_OSERR;
        goto finish;
    }

    toolArgs.loadedKextInfo = OSKextCopyLoadedKextInfo(toolArgs.bundleIDs,
        NULL /* all info */);

    if (!toolArgs.loadedKextInfo) {
        OSKextLog(/* kext */ NULL,
            kOSKextLogErrorLevel | kOSKextLogGeneralFlag | kOSKextLogIPCFlag,
            "Couldn't get list of loaded kexts from kernel.");
        result = EX_OSERR;
        goto finish;
    }

    if (!toolArgs.flagListOnly) {
        printf("Index Refs Address    ");
        if (toolArgs.runningKernelArch->cputype & CPU_ARCH_ABI64) {
            printf("        ");
        }
        printf("Size       Wired      ");
        if (toolArgs.flagShowArchitecture) {
            printf("Architecture       ");
        }
        printf("Name (Version) <Linked Against>\n");
    }

    count = CFDictionaryGetCount(toolArgs.loadedKextInfo);
    if (!count) {
        goto finish;
    }

    kextInfoList = (CFDictionaryRef *)malloc(count * sizeof(CFDictionaryRef));
    if (!kextInfoList) {
        OSKextLogMemError();
        result = EX_OSERR;
        goto finish;
    }

    CFDictionaryGetKeysAndValues(toolArgs.loadedKextInfo, /* keys */ NULL,
        (const void **)kextInfoList);
    qsort(kextInfoList, count, sizeof(CFDictionaryRef), &compareKextInfo);
    for (i = 0; i < count; i++) {
        printKextInfo(kextInfoList[i], &toolArgs);
    }

finish:
    exit(result);

    SAFE_FREE(kextInfoList);

    return result;
}
Exemplo n.º 20
0
int main(int argc, char** argv) {
	char SQLq[2048];
	/* exit routine */
	atexit (exitProc);
	/* check arguments */
	if (readArgs(argc, argv) == FALSE) {
		fprintf (stderr, "You have to provide DB-Connection infos and the input directory with the XML-Files.\n");
		return EXIT_FAILURE;
	}
	/* connect to Database, keep connection Idle */
	if (!connectDB())
		return EXIT_FAILURE;

	setlocale (LC_CTYPE,"");

	/* Drop old tables if they exist */
	bzero (SQLq, 2048);
	sprintf (SQLq, db_DROP_TABLE, db_tvtable);
	if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
		fprintf (stderr, "Error while droping Table:%s.\n\t%s", db_tvtable, mysql_error(mysql_conn));
	}
	printD ("Dropped Table:%s\n", db_tvtable);

	bzero (SQLq, 2048);
	sprintf (SQLq, db_CREATE_TVTABLE, db_tvtable);
	if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
		fprintf (stderr, "Error while creating Table:%s.\n\t%s", db_tvtable, mysql_error(mysql_conn));
	}
	printD ("Created Table:%s\n", db_tvtable);

	/****TVEND****/

	bzero (SQLq, 2048);
	sprintf (SQLq, db_DROP_TABLE, db_movietable);
	if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
		fprintf (stderr, "Error while droping Table:%s.\n\t%s", db_tvtable, mysql_error(mysql_conn));
	}

	printD ("Dropped Table:%s\n", db_movietable);
	bzero (SQLq, 2048);
	sprintf (SQLq, db_CREATE_MOVIETABLE, db_movietable);
	if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
		fprintf (stderr, "Error while creating Table:%s.\n\t%s", db_movietable, mysql_error(mysql_conn));
	}
	printD ("Created Table:%s\n", db_movietable);

	/****MOVIEEND****/

	if (db_newstable) {

		bzero (SQLq, 2048);
		sprintf (SQLq, db_DROP_TABLE, db_newstable);
		if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
			fprintf (stderr, "Error while droping Table:%s.\n\t%s", db_newstable, mysql_error(mysql_conn));
		}

		printD ("Dropped Table:%s\n", db_newstable);
		bzero (SQLq, 2048);
		sprintf (SQLq, db_CREATE_NEWS, db_newstable);
		if (mysql_real_query(mysql_conn, SQLq, strlen(SQLq)) != 0) {
			fprintf (stderr, "Error while creating Table:%s.\n\t%s", db_newstable, mysql_error(mysql_conn));
		}
		printD ("Created Table:%s\n", db_newstable);

	}

	/****NEWSEND****/

	/* enter Mainloop and walk thru directory... */
	mainLoop();

	printD ("Mainloop returned gracefully, cleaning up the mess and leaving...\n");

	return EXIT_SUCCESS;
}
Exemplo n.º 21
0
/**
 * main entry point
 */
int main(int argc ,char **argv)
{
	bool result=true;
	if(argc < 5)
	{
		printf("Usage: %s 61.135.250.1 80 61.135.250.2 80\n",
				argv[0]);
		exit(1);
	}
	initLogInfo();
	logInfo(LOG_NOTICE,"%s %s %s %s %s",argv[0],argv[1],
			argv[2],argv[3],argv[4]);
	logInfo(LOG_NOTICE,"tcpcopy version:%s",VERSION);
#if (TCPCOPY_MYSQL_SKIP)
	logInfo(LOG_NOTICE,"TCPCOPY_MYSQL_SKIP mode");
#endif
#if (TCPCOPY_MYSQL_NO_SKIP)
	logInfo(LOG_NOTICE,"TCPCOPY_MYSQL_NO_SKIP mode");
#endif
	
	result=retrieveVirtualIPAddress(argv[1]);
	if(!result)
	{
		printf("it does not support local ip addr or domain name");
		logInfo(LOG_ERR,"it does not support local ip addr or domain name");
	}
	local_port = htons(atoi(argv[2]));
	remote_ip = inet_addr(argv[3]);
	remote_port = htons(atoi(argv[4]));

	if(argc>5)
	{
		if(!readArgs(argc,argv,&options))
		{
#if (TCPCOPY_MYSQL_ADVANCED)  
			logInfo(LOG_ERR,"user password pair is missing:%d",argc);
#endif
		}
	}else
	{
#if (TCPCOPY_MYSQL_ADVANCED)  
		logInfo(LOG_ERR,"user password pair is missing");
		printf("Usage: %s 1.1.1.1 80 1.1.1.2 80 -p user1@psw1:user2@psw2:...\n",
				argv[0]);
		exit(1);
#endif
	}

	if(port_shift_factor||replica_num>1)
	{
		struct timeval tp;
		gettimeofday(&tp,NULL);
		unsigned int seed=tp.tv_usec;
		rand_shift_port=(int)((rand_r(&seed)/(RAND_MAX+1.0))*512);

		if(port_shift_factor)
		{
			logInfo(LOG_NOTICE,"port shift factor:%u",port_shift_factor);
		}else
		{
			logInfo(LOG_NOTICE,"replica num:%d",replica_num);
		}
		logInfo(LOG_NOTICE,"random shift port:%u",rand_shift_port);
	}

	set_signal_handler();
	if(SUCCESS==init_tcp_copy())
	{
		select_server_run();
		return 0;
	}else
	{
		return 1;
	}
}
Exemplo n.º 22
0
int main() {
	int msg_type = 0;
	int msg_len = 0;
	int pipe_fd_one,pipe_fd_two;
	int first_res,second_res;
	char buffer[BUF_SIZE];
	Message send_msg;
	Message recv_msg;

	if(access(FIRST_FIFO_NAME,F_OK) == -1 || access(SECOND_FIFO_NAME,F_OK) == -1) {
		first_res = mkfifo(FIRST_FIFO_NAME,0777);
		if(first_res != 0) {
			fprintf(stderr,"Could not create fifo %s\n",FIRST_FIFO_NAME);
			exit(EXIT_FAILURE);
		}
		second_res = mkfifo(SECOND_FIFO_NAME,0777);
		if(second_res != 0) {
			fprintf(stderr,"Could not create fifo %s\n",SECOND_FIFO_NAME);
			exit(EXIT_FAILURE);
		}
	}
	pid_t child_pid = fork();
	switch(child_pid) {
		case -1 :
			perror("fork failure ");
			exit(EXIT_FAILURE);
					
		case 0 :
			pipe_fd_one = open(FIRST_FIFO_NAME,O_WRONLY);
			pipe_fd_two = open(SECOND_FIFO_NAME,O_RDONLY);
			if(pipe_fd_one != -1 && pipe_fd_two != -1) {
				while(1) {
					read(pipe_fd_two, &recv_msg, sizeof(Message));					
					if(needExit(recv_msg)) {
						printf("\nChild process exit\n");
						exit(CHILD_EXIT);
					}

					printf("\nIn child process:\n");
					printf("receive message form parent\n");
					showMsg(&recv_msg);
					
					readArgs(&msg_type,&msg_len,buffer,"parent");
	
					initMsg(&send_msg,msg_type,msg_len,buffer);

					write(pipe_fd_one, &send_msg, sizeof(Message));
					if(needExit(send_msg)) {
						printf("\nChild process exit\n");
						exit(CHILD_EXIT);
					}
				}
				(void)close(pipe_fd_one);
				(void)close(pipe_fd_two); 
			}else {
				fprintf(stderr,"FIFO open failed in child process\n");
				exit(EXIT_FAILURE);
			}
			break;

		default :
			pipe_fd_one = open(FIRST_FIFO_NAME,O_RDONLY);
			pipe_fd_two = open(SECOND_FIFO_NAME,O_WRONLY);
			if(pipe_fd_one != -1 && pipe_fd_two != -1) {
				while(1) {
					printf("\nIn parent process:\n");
					
					readArgs(&msg_type,&msg_len,buffer,"child");

					initMsg(&send_msg,msg_type,msg_len,buffer);

					write(pipe_fd_two, &send_msg, sizeof(Message));
					if(needExit(send_msg)) {
						parentExit();
					}
					

					read(pipe_fd_one, &recv_msg, sizeof(Message));					
					if(needExit(recv_msg)) {
						parentExit();
					}
					printf("\nIn parent process:\n");
					printf("receive message form child.\n");
					showMsg(&recv_msg);
					printf("\n");
				}
				(void)close(pipe_fd_one);
				(void)close(pipe_fd_two);
			}else {
				fprintf(stderr,"FIFO open failed in parent process\n");
				exit(EXIT_FAILURE);
			}
			break;
	}
}
Exemplo n.º 23
0
int main(int argc, char * const argv[])
{
    ExitStatus           result             = EX_SOFTWARE;
    KctoolArgs           toolArgs;
    int                  kernelcache_fd     = -1;  // must close()
    void               * fat_header         = NULL;  // must unmapFatHeaderPage()
    struct fat_arch    * fat_arch           = NULL;
    CFDataRef            rawKernelcache     = NULL;  // must release
    CFDataRef            kernelcacheImage   = NULL;  // must release

    void               * prelinkInfoSect    = NULL;

    const char         * prelinkInfoBytes   = NULL;
    CFPropertyListRef    prelinkInfoPlist   = NULL;  // must release

    bzero(&toolArgs, sizeof(toolArgs));

   /*****
    * Find out what the program was invoked as.
    */
    progname = rindex(argv[0], '/');
    if (progname) {
        progname++;   // go past the '/'
    } else {
        progname = (char *)argv[0];
    }

   /* Set the OSKext log callback right away.
    */
    OSKextSetLogOutputFunction(&tool_log);

   /*****
    * Process args & check for permission to load.
    */
    result = readArgs(&argc, &argv, &toolArgs);
    if (result != EX_OK) {
        if (result == kKctoolExitHelp) {
            result = EX_OK;
        }
        goto finish;
    }

    kernelcache_fd = open(toolArgs.kernelcachePath, O_RDONLY);
    if (kernelcache_fd == -1) {
        OSKextLog(/* kext */ NULL,
            kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
            "Can't open %s: %s.", toolArgs.kernelcachePath, strerror(errno));
        result = EX_OSERR;
        goto finish;
    }
    fat_header = mapAndSwapFatHeaderPage(kernelcache_fd);
    if (!fat_header) {
        OSKextLog(/* kext */ NULL,
            kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
            "Can't map %s: %s.", toolArgs.kernelcachePath, strerror(errno));
        result = EX_OSERR;
        goto finish;
    }
    
    fat_arch = getFirstFatArch(fat_header);
    if (fat_arch && !toolArgs.archInfo) {
        toolArgs.archInfo = NXGetArchInfoFromCpuType(fat_arch->cputype, fat_arch->cpusubtype);
    }
    
    rawKernelcache = readMachOSliceForArch(toolArgs.kernelcachePath, toolArgs.archInfo,
        /* checkArch */ FALSE);
    if (!rawKernelcache) {
        OSKextLog(/* kext */ NULL,
            kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
            "Can't read arch %s from %s.", toolArgs.archInfo->name, toolArgs.kernelcachePath);
        goto finish;
    }

    if (MAGIC32(CFDataGetBytePtr(rawKernelcache)) == OSSwapHostToBigInt32('comp')) {
        kernelcacheImage = uncompressPrelinkedSlice(rawKernelcache);
        if (!kernelcacheImage) {
            OSKextLog(/* kext */ NULL,
                kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
                "Can't uncompress kernelcache slice.");
            goto finish;
        }
    } else {
        kernelcacheImage = CFRetain(rawKernelcache);
    }

    toolArgs.kernelcacheImageBytes = CFDataGetBytePtr(kernelcacheImage);
    
    if (ISMACHO64(MAGIC32(toolArgs.kernelcacheImageBytes))) {
        prelinkInfoSect = (void *)macho_get_section_by_name_64(
            (struct mach_header_64 *)toolArgs.kernelcacheImageBytes,
            "__PRELINK_INFO", "__info");

    } else {
        prelinkInfoSect = (void *)macho_get_section_by_name(
            (struct mach_header *)toolArgs.kernelcacheImageBytes,
            "__PRELINK_INFO", "__info");
    }

    if (!prelinkInfoSect) {
        OSKextLog(/* kext */ NULL,
            kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
            "Can't find prelink info section.");
        goto finish;
    }

    if (ISMACHO64(MAGIC32(toolArgs.kernelcacheImageBytes))) {
        prelinkInfoBytes = ((char *)toolArgs.kernelcacheImageBytes) +
            ((struct section_64 *)prelinkInfoSect)->offset;
    } else {
        prelinkInfoBytes = ((char *)toolArgs.kernelcacheImageBytes) +
            ((struct section *)prelinkInfoSect)->offset;
    }

    toolArgs.kernelcacheInfoPlist = (CFPropertyListRef)IOCFUnserialize(prelinkInfoBytes,
        kCFAllocatorDefault, /* options */ 0, /* errorString */ NULL);
    if (!toolArgs.kernelcacheInfoPlist) {
        OSKextLog(/* kext */ NULL,
            kOSKextLogErrorLevel | kOSKextLogGeneralFlag,
            "Can't unserialize prelink info.");
        goto finish;
    }

    result = printKextInfo(&toolArgs);
    if (result != EX_OK) {
        goto finish;
    }

    result = EX_OK;

finish:

    SAFE_RELEASE(toolArgs.kernelcacheInfoPlist);
    SAFE_RELEASE(kernelcacheImage);
    SAFE_RELEASE(rawKernelcache);

    if (fat_header) {
        unmapFatHeaderPage(fat_header);
    }

    if (kernelcache_fd != -1) {
        close(kernelcache_fd);
    }
    return result;
}
Exemplo n.º 24
0
int main (int argc, char *argv[])
{
    printf("Start: %s\n", getTime());

    //================================================== 
    // define arguments and usage
    char *optv[MAX_ARGS] = { "-i", "-o", "-s", "-r", "-v", "-l", "-z", "-t", "-f", "-c", "-a" };
    char *optd[MAX_ARGS] = {"efm file  (tab separated like:  0.4\t0\t-0.24)",
                            "output file [default: ltcs.out]",
                            "stoichiometric matrix file [optional, needed to find internal loops]",
                            "reaction file [optional, but necessary if option -a is set]",
                            "reversibility file [optional, but saves memory!]",
                            "loops output [only if stoichiometric matrix is given, default: loops.out]",
                            "zero threshold [default: 1e-10]",
                            "number of threads [default: 1]",
                            "full output [yes/no; default: yes] if set to no only summary is printed and ltcs are not saved",
                            "print ltcs in csv format [yes/no; default: yes] if set to no ltcs output will be e.g. 10011 instead of 1,0,0,1,1",
                            "analysis output file - needs option -r"};
    char *optr[MAX_ARGS];
    char *description = "Calculate largest thermodynamically consistent sets of "
        "EFMs\nbased only on the reversibility of the reactions";
    char *usg = "\n   calcLtcs -i efms.txt -o ltcs.out\n   calcLtcs -i efms.txt -o ltcs.out -s sfile -v rvfile -z 1e-6 -t 8 -a yes -r rfile";
    // end define arguments and usage
    //================================================== 

    //================================================== 
    // read arguments
    readArgs(argc, argv, MAX_ARGS, optv, optr);
    if ( !optr[ARG_INPUT] )
    {
        usage(description, usg, MAX_ARGS, optv, optd);
        quitError("Missing argument\n", ERROR_ARGS);
    }
    char* ltcsout = optr[ARG_LTCS_OUT] ? optr[ARG_LTCS_OUT] : "ltcs.out";
    char* arg_rvfile = optr[ARG_RVFILE] ? optr[ARG_RVFILE] : "not available";
    char* arg_sfile = optr[ARG_SFILE] ? optr[ARG_SFILE] : "not available";
    char* arg_rfile = optr[ARG_RFILE] ? optr[ARG_RFILE] : "not available";
    char* loopout = optr[ARG_SFILE] ? (optr[ARG_LOOPS] ? optr[ARG_LOOPS] : "loops.out") : "not available";
    double threshold = optr[ARG_ZERO] ? atof(optr[ARG_ZERO]) : 1e-10;
    int threads = optr[ARG_THREADS] ? atoi(optr[ARG_THREADS]) : 1;
    int full_out = optr[ARG_FULL_OUT] ? (!strcmp(optr[ARG_FULL_OUT], "no") ? 0 : 1) : 1;
    int csv_out = optr[ARG_CSV_OUT] ? (!strcmp(optr[ARG_CSV_OUT], "no") ? 0 : 1) : 1;
    int arg_analysis = optr[ARG_ANALYSIS] ? (optr[ARG_RFILE] ? 1 : 0) : 0;
    char* arg_analysisfile = optr[ARG_ANALYSIS] ? optr[ARG_ANALYSIS] : "not available";
    // end read arguments
    //================================================== 

    //================================================== 
    // print arguments summary
    printf("\n");
    printf("Input:            %s\n", optr[ARG_INPUT]);
    printf("Output:           %s\n", ltcsout);
    printf("sfile:            %s\n", arg_sfile);
    printf("rvfile:           %s\n", arg_rvfile);
    printf("rfile:            %s\n", arg_rfile);
    printf("Zero threshold:   %.2e\n", threshold);
    printf("Threads:          %d\n", threads);
    printf("Loops output:     %s\n", full_out > 0 ? loopout : "no");
    printf("Full output:      %s\n", full_out > 0 ? "yes" : "no");
    if (full_out > 0)
    {
        printf("csv output:       %s\n", csv_out > 0 ? "yes (1,0,1,1)" : "no (1011)");
    }
    printf("Perform analysis: %s\n", arg_analysis > 0 ? "yes" : "no");
    if (arg_analysis > 0)
    {
        printf("analysis file:    %s\n", arg_analysisfile);
    }
    printf("\n");
    // end print arguments summary
    //================================================== 

    //================================================== 
    // check files
    FILE *file = fopen(optr[ARG_INPUT], "r");
    FILE *fileout = NULL;
    FILE *fileloops = NULL;
    FILE *fileanalysis = NULL;
    if (!file)
    {
        quitError("Error in opening input file\n", ERROR_FILE);
    }
    if (full_out > 0)
    {
        fileout = fopen(ltcsout, "w");
        if (!fileout)
        {
            quitError("Error in opening output file\n", ERROR_FILE);
        }
        if (optr[ARG_SFILE])
        {
            fileloops = fopen(loopout, "w");
            if (!fileloops)
            {
                quitError("Error in opening loop outputfile\n", ERROR_FILE);
            }
        }
    }
    if (arg_analysis > 0)
    {
        fileanalysis = fopen(arg_analysisfile, "w");
        if (!fileanalysis)
        {
            quitError("Error in opening analysis file\n", ERROR_FILE);
        }
    }
    // end check files
    //================================================== 
    
    //================================================== 
    // read number of reactions
    int rx_count = getRxCount(file);
    fclose(file);
    if (rx_count < 1)
    {
        quitError("Error in EFM file format; number of reactions < 1\n",
                ERROR_FILE);
    }
    // end read number of reactions
    //================================================== 

    //================================================== 
    // define exchange reactions
    char* exchange_reaction = NULL;
    int s_cols = 0;
    if (optr[ARG_SFILE])
    {
        defineExchangeReactions(&s_cols, &exchange_reaction, threshold,
                optr[ARG_SFILE]);
        if (s_cols != rx_count)
        {
            quitError("Error in EFM of stoichiometric file format. Number of reactions is not equal\n", ERROR_FILE);
        }
    }
    // end define exchange reactions
    //================================================== 

    //================================================== 
    // define reversible reactions
    unsigned int   rev_rx_count  = 0;
    unsigned long rev_rx_bitsize = getBitsize(rx_count);
    char* reversible_reactions = calloc(1, rev_rx_bitsize);
    int i;
    for (i = 0; i < rx_count; i++) 
    {
        BITSET(reversible_reactions, i);
    }
    if (optr[ARG_RVFILE])
    {
        readReversibleFile(optr[ARG_RVFILE], reversible_reactions, rx_count);
    }
    else
    {
        for (i = 0; i < rx_count; i++) 
        {
            BITSET(reversible_reactions, i);
        }
    }
    // end define reversible reactions
    //================================================== 
    
    //================================================== 
    // read reaction names
    char** reaction_names = NULL;
    if (arg_analysis > 0)
    {
        readReactions(optr[ARG_RFILE], &reaction_names, rx_count);
    }
    //
    //================================================== 

    //================================================== 
    // read efm matrix
    char* loops = NULL;
    char** initial_mat = NULL;
    char** full_mat = NULL;
    unsigned long efm_count = 0;
    int checkLoops = optr[ARG_SFILE] ? 1 : 0;
    readInitialMatrix(rx_count, &efm_count, reversible_reactions,
            &rev_rx_count, &initial_mat, &full_mat, arg_analysis,
            exchange_reaction, &loops, checkLoops, 1e-8, optr[ARG_INPUT]);
    // end read efm matrix
    //================================================== 

    //================================================== 
    // find ltcs
    unsigned long ltcs_count = 0;
    char** ltcs = NULL;
    findLtcs(rev_rx_count, efm_count, initial_mat, loops, &ltcs, &ltcs_count, threads);
    // end find ltcs
    //================================================== 
    
    //================================================== 
    // filter ltcs to remove subsets
    printf("%s filter LTCS to remove subsets\n", getTime());
    char* notAnLtcs = NULL;
    filterLtcs(ltcs, &notAnLtcs, ltcs_count, efm_count);
    // end filter ltcs to remove subsets
    //================================================== 

    //================================================== 
    // print ltcs to file
    if (full_out > 0)
    {
        printf("%s save ltcs\n", getTime());
    }
    unsigned long li;
    unsigned long ul;
    unsigned long result_ltcs_count = 0;
    int makeSep = 0;
    for (li = 0; li < ltcs_count; li++) {
        if (!BITTEST(notAnLtcs, li))
        {
            makeSep = 0;
            result_ltcs_count++;
            if (full_out > 0)
            {
                for (ul = 0; ul < efm_count; ul++) {
                    if (makeSep > 0 && csv_out > 0)
                    {
                        fprintf(fileout, ",");
                    }
                    makeSep = 1;
                    if (BITTEST(ltcs[li],ul))
                    {
                        fprintf(fileout, "1");
                    }
                    else
                    {
                        fprintf(fileout, "0");
                    }
                }
                fprintf(fileout, "\n");
            }
        }
    }
    if (full_out > 0)
    {
        fclose(fileout);
    }
    // end print ltcs to file
    //================================================== 

    //================================================== 
    // perform analysis
    if (arg_analysis > 0)
    {
        printf("%s perform and save analysis of LTCS\n", getTime());
        double** analysis_values = NULL;
        performAnalysis(&analysis_values, ltcs, full_mat, reaction_names,
                ltcs_count, efm_count, rx_count);
        unsigned long lj;
        for (li = 0; li < rx_count; li++) {
            fprintf(fileanalysis, "%s", reaction_names[li]);
            for (lj = 0; lj < ltcs_count; lj++) {
                fprintf(fileanalysis, ",%.2f", analysis_values[li][lj]);
            }
            fprintf(fileanalysis, "\n");
        }
        fclose(fileanalysis);

        for (li = 0; li < rx_count; li++) {
            free(analysis_values[li]);
            free(reaction_names[li]);
        }
        free(analysis_values);
        free(reaction_names);
    }
    // end perform analysis
    //================================================== 
    
    //================================================== 
    // set initial_mat memory free
    for (li=0; li<efm_count; li++)
    {
        if (!BITTEST(loops, li))
        {
            free(initial_mat[li]);
        }
    }
    free(initial_mat);
    initial_mat = NULL;
    if (arg_analysis > 0)
    {
        for (li=0; li<efm_count; li++)
        {
            if (!BITTEST(loops, li))
            {
                free(full_mat[li]);
            }
        }
        free(full_mat);
        full_mat = NULL;
    }
    // end set initial_mat memory free
    //================================================== 

    //================================================== 
    // count and print loops to file
    unsigned long loop_count = 0;
    if (optr[ARG_SFILE])
    {
        if (full_out > 0)
        {
            printf("%s save internal loops\n", getTime());
            for (ul = 0; ul < efm_count; ul++) {
                if (ul > 0 && csv_out > 0)
                {
                    fprintf(fileloops, ",");
                }
                if (BITTEST(loops, ul))
                {
                    fprintf(fileloops, "1");
                    loop_count++;
                }
                else
                {
                    fprintf(fileloops, "0");
                }
            }
            fclose(fileloops);
        }
        else
        {
            for (ul = 0; ul < efm_count; ul++) {
                if (BITTEST(loops, ul))
                {
                    loop_count++;
                }
            }
        }
    }
    // end count and print loops to file
    //================================================== 

    //================================================== 
    // print summary
    printf("\n");
    printf("Nr of EFMS:           %lu\n", efm_count);
    printf("Nr of LTCS:           %lu\n", result_ltcs_count);
    if (optr[ARG_SFILE])
    {
        printf("Nr of internal loops: %lu\n", loop_count);
    }
    printf("\nSizes of LTCS:\n");
    for (li = 0; li < ltcs_count; li++) {
        if (!BITTEST(notAnLtcs, li))
        {
            if (li > 0)
            {
                printf(",");
            }
            printf("%lu", getLtcsCardinality(ltcs[li], efm_count));
        }
    }
    printf("\n\n");
    printf("End: %s\n", getTime());
    // end print summary
    //================================================== 

    //================================================== 
    // set memory free
    free(loops);
    free(exchange_reaction);
    loops = NULL;
    for (li = 0; li < ltcs_count; li++) {
        if (!BITTEST(notAnLtcs, li))
        {
            free(ltcs[li]);
        }
    }
    free(ltcs);
    free(notAnLtcs);
    ltcs = NULL;
    free(reversible_reactions);
    reversible_reactions = NULL;
    // end set memory free
    //================================================== 

    return EXIT_SUCCESS;
}
Exemplo n.º 25
0
int main(int argc, char *argv[]){
  
	Params params;
  
	std::map<std::string, std::string> args;
	readArgs(argc, argv, args);
	if(args.find("algo")!=args.end()){
		params.algo = args["algo"];
	}else{
		params.algo = "qdMCNat";
	}

	if(args.find("inst_file")!=args.end())
		setParamsFromFile(args["inst_file"], args, params);
	else   
		setParams(params.algo, args, params);
  
	createLogDir(params.dir_path);
  
	gen.seed(params.seed);

	// Load the dataset
	MyMatrix X_train, X_valid;
	VectorXd Y_train, Y_valid;
	loadMnist(params.ratio_train, X_train, X_valid, Y_train, Y_valid);
	//loadCIFAR10(params.ratio_train, X_train, X_valid, Y_train, Y_valid);
	//loadLightCIFAR10(params.ratio_train, X_train, X_valid, Y_train, Y_valid);
  
	// ConvNet parameters
	std::vector<ConvLayerParams> conv_params;
	ConvLayerParams conv_params1;
	conv_params1.Hf = 5;
	conv_params1.stride = 1;
	conv_params1.n_filter = 20;
	conv_params1.padding = 0;
	conv_params.push_back(conv_params1);
  
	ConvLayerParams conv_params2;
	conv_params2.Hf = 5;
	conv_params2.stride = 1;
	conv_params2.n_filter = 50;
	conv_params2.padding = 0;
	conv_params.push_back(conv_params2);

	std::vector<PoolLayerParams> pool_params;
	PoolLayerParams pool_params1;
	pool_params1.Hf = 2;
	pool_params1.stride = 2;
	pool_params.push_back(pool_params1);

	PoolLayerParams pool_params2;
	pool_params2.Hf = 2;
	pool_params2.stride = 2;
	pool_params.push_back(pool_params2);
  
	const unsigned n_conv_layer = conv_params.size();
  
	for(unsigned l = 0; l < conv_params.size(); l++){

		if(l==0){
			conv_params[l].filter_size = conv_params[l].Hf * conv_params[l].Hf * params.img_depth;
			conv_params[l].N = (params.img_width - conv_params[l].Hf + 2*conv_params[l].padding)/conv_params[l].stride + 1;
		}
		else{
			conv_params[l].filter_size = conv_params[l].Hf * conv_params[l].Hf * conv_params[l-1].n_filter;
			conv_params[l].N = (pool_params[l-1].N - conv_params[l].Hf + 2*conv_params[l].padding)/conv_params[l].stride + 1;
		}
		pool_params[l].N = (conv_params[l].N - pool_params[l].Hf)/pool_params[l].stride + 1;
	}
  
	// Neural Network parameters
	const unsigned n_training = X_train.rows();
	const unsigned n_valid = X_valid.rows();
	const unsigned n_feature = X_train.cols();
	const unsigned n_label = Y_train.maxCoeff() + 1;
  
	params.nn_arch.insert(params.nn_arch.begin(),conv_params[n_conv_layer-1].n_filter * pool_params[n_conv_layer-1].N * pool_params[n_conv_layer-1].N);
	params.nn_arch.push_back(n_label);
	const unsigned n_layers = params.nn_arch.size();
  
	// Optimization parameter
	const int n_train_batch = ceil(n_training/(float)params.train_minibatch_size);
	const int n_valid_batch = ceil(n_valid/(float)params.valid_minibatch_size);
	double prev_loss = std::numeric_limits<double>::max();
	double eta = params.eta;

	// Create the convolutional layer
	std::vector<MyMatrix> conv_W(n_conv_layer);
	std::vector<MyMatrix> conv_W_T(n_conv_layer);
	std::vector<MyVector> conv_B(n_conv_layer);
  
	// Create the neural network
	MyMatrix W_out(params.nn_arch[n_layers-2],n_label);
	std::vector<MySpMatrix> W(n_layers-2);
	std::vector<MySpMatrix> Wt(n_layers-2);
	std::vector<MyVector> B(n_layers-1);

	double init_sigma = 0.;
	ActivationFunction act_func;
	ActivationFunction eval_act_func;
	if(params.act_func_name=="sigmoid"){
		init_sigma = 4.0;
		act_func = std::bind(logistic,true,_1,_2,_3);
		eval_act_func = std::bind(logistic,false,_1,_2,_3);
	}else if(params.act_func_name=="tanh"){
		init_sigma = 1.0;
		act_func = std::bind(my_tanh,true,_1,_2,_3);
		eval_act_func = std::bind(my_tanh,false,_1,_2,_3);
	}else if(params.act_func_name=="relu"){
		init_sigma = 1.0; // TODO: Find the good value
		act_func = std::bind(relu,true,_1,_2,_3);
		eval_act_func = std::bind(relu,false,_1,_2,_3);
	}else{
		std::cout << "Not implemented yet!" << std::endl;
		assert(false);
	}

	std::cout << "Initializing the network... ";
	params.n_params = initNetwork(params.nn_arch, params.act_func_name, params.sparsity, conv_params, pool_params, W_out, W, Wt, B, conv_W, conv_W_T, conv_B); // TODO: Init the conv bias

	// Deep copy of parameters for the adaptive rule
	std::vector<MyMatrix> mu_dW(n_layers-1);
	std::vector<MyVector> mu_dB(n_layers-1);

	MyMatrix pW_out = W_out;
	std::vector<MySpMatrix> pW = W;
	std::vector<MySpMatrix> pWt = Wt;
	std::vector<MyVector> pB = B;

	MyMatrix ppMii_out, ppM0i_out;
	MyVector ppM00_out;
  
	std::vector<MySpMatrix> ppMii,ppM0i;
	std::vector<MyVector> ppM00;

	MyMatrix pMii_out,pM0i_out;
	MyVector pM00_out;
  
	std::vector<MySpMatrix> pMii,pM0i;
	std::vector<MyVector> pM00;

	std::vector<MyMatrix> conv_ppMii, conv_ppM0i;
	std::vector<MyVector> conv_ppM00;

	std::vector<MyMatrix> conv_pMii, conv_pM0i;
	std::vector<MyVector> conv_pM00;
  
	// Convert the labels to one-hot vector
	MyMatrix one_hot = MyMatrix::Zero(n_training, n_label);
	labels2oneHot(Y_train,one_hot);
  
	// Configure the logger 
	std::ostream* logger;
	if(args.find("verbose")!=args.end()){
		getOutput("",logger);
	}else{
		getOutput(params.file_path,logger);
	}

	double cumul_time = 0.;
  
	printDesc(params, logger);
	printConvDesc(params, conv_params, pool_params, logger);
	std::cout << "Starting the learning phase... " << std::endl;
	*logger << "Epoch Time(s) train_loss train_accuracy valid_loss valid_accuracy eta" << std::endl;
  
	for(unsigned i = 0; i < params.n_epoch; i++){
		for(unsigned j = 0; j < n_train_batch; j++){
      
			// Mini-batch creation
			unsigned curr_batch_size = 0;
			MyMatrix X_batch, one_hot_batch;
			getMiniBatch(j, params.train_minibatch_size, X_train, one_hot, params, conv_params[0], curr_batch_size, X_batch, one_hot_batch);
      
			double prev_time = gettime();

			// Forward propagation for conv layer
			std::vector<std::vector<unsigned>> poolIdxX1(n_conv_layer);
			std::vector<std::vector<unsigned>> poolIdxY1(n_conv_layer);
      
			MyMatrix z0;
			std::vector<MyMatrix> conv_A(conv_W.size());
			std::vector<MyMatrix> conv_Ap(conv_W.size());
			convFprop(curr_batch_size, conv_params, pool_params, act_func, conv_W, conv_B, X_batch, conv_A, conv_Ap, z0, poolIdxX1, poolIdxY1);
            
			// Forward propagation
			std::vector<MyMatrix> Z(n_layers-1);
			std::vector<MyMatrix> A(n_layers-2);
			std::vector<MyMatrix> Ap(n_layers-2);
			fprop(params.dropout_flag, act_func, W, W_out, B, z0, Z, A, Ap);
      
			// Compute the output and the error
			MyMatrix out;
			softmax(Z[n_layers-2], out);
      
			std::vector<MyMatrix> gradB(n_layers-1);
			gradB[n_layers-2] = out - one_hot_batch;

			// Backpropagation
			bprop(Wt, W_out, Ap, gradB);

			// Backpropagation for conv layer
			std::vector<MyMatrix> conv_gradB(conv_W.size());
			MyMatrix layer_gradB = (gradB[0] * W[0].transpose());
			MyMatrix pool_gradB;
			layer2pool(curr_batch_size, pool_params[conv_W.size()-1].N, conv_params[conv_W.size()-1].n_filter, layer_gradB, pool_gradB);
      
			convBprop(curr_batch_size, conv_params, pool_params, conv_W_T, conv_Ap, pool_gradB, conv_gradB, poolIdxX1, poolIdxY1);
      
			if(params.algo == "bprop"){
				update(eta, gradB, A, z0, params.regularizer, params.lambda, W_out, W, Wt, B);
				convUpdate(curr_batch_size, eta, conv_params, conv_gradB, conv_A, X_batch, "", 0., conv_W, conv_W_T, conv_B);
	
			}else{

				// Compute the metric
				std::vector<MyMatrix> metric_gradB(n_layers-1);
				std::vector<MyMatrix> metric_conv_gradB(conv_params.size());

				if(params.algo=="qdMCNat"){

					// Monte-Carlo Approximation of the metric
					std::vector<MyMatrix> mc_gradB(n_layers-1);
					computeMcError(out, mc_gradB[n_layers-2]);

					// Backpropagation
					bprop(Wt, W_out, Ap, mc_gradB);

					for(unsigned k = 0; k < gradB.size(); k++){
						metric_gradB[k] = mc_gradB[k].array().square();
					}

					// Backpropagation for conv layer
					std::vector<MyMatrix> mc_conv_gradB(conv_W.size());
					MyMatrix mc_layer_gradB = (mc_gradB[0] * W[0].transpose());
					MyMatrix mc_pool_gradB;
					layer2pool(curr_batch_size, pool_params[conv_W.size()-1].N, conv_params[conv_W.size()-1].n_filter, mc_layer_gradB, mc_pool_gradB);
	  
					convBprop(curr_batch_size, conv_params, pool_params, conv_W_T, conv_Ap, mc_pool_gradB, mc_conv_gradB, poolIdxX1, poolIdxY1);
	  
					for(unsigned k = 0; k < conv_params.size(); k++){
						metric_conv_gradB[k] = mc_conv_gradB[k].array().square();
					}
				}	
				else if(params.algo=="qdop"){

					for(unsigned k = 0; k < conv_params.size(); k++){
						metric_conv_gradB[k] = conv_gradB[k].array().square();
					}
					for(unsigned k = 0; k < gradB.size(); k++){
						metric_gradB[k] = gradB[k].array().square();
					}
				}
				else if(params.algo=="qdNat"){
	  
					for(unsigned k = 0; k < conv_params.size(); k++){
						metric_conv_gradB[k] = conv_gradB[k].array().square();
					}

					for(unsigned k = 0; k < metric_gradB.size(); k++){
						metric_gradB[k] = MyMatrix::Zero(gradB[k].rows(),gradB[k].cols());
					}

					for(unsigned l = 0; l < n_label; l++){
						MyMatrix fisher_ohbatch = MyMatrix::Zero(curr_batch_size, n_label);
						fisher_ohbatch.col(l).setOnes();

						std::vector<MyMatrix> fgradB(n_layers-1);
						fgradB[n_layers-2] = out - fisher_ohbatch;
						bprop(Wt, W_out, Ap, fgradB);

						// Backpropagation for conv layer
						std::vector<MyMatrix> fisher_conv_gradB(conv_W.size());
						MyMatrix fisher_layer_gradB = (fgradB[0] * W[0].transpose());
						MyMatrix fisher_pool_gradB;
						layer2pool(curr_batch_size, pool_params[conv_W.size()-1].N, conv_params[conv_W.size()-1].n_filter, fisher_layer_gradB, fisher_pool_gradB);
	    
						convBprop(curr_batch_size, conv_params, pool_params, conv_W_T, conv_Ap, fisher_pool_gradB, fisher_conv_gradB, poolIdxX1, poolIdxY1);

						for(unsigned k = 0; k < conv_params.size(); k++){
							MyMatrix fisher_conv_gradB_sq = fisher_conv_gradB[k].array().square();
							for(unsigned m = 0; m < out.rows(); m++){
								for(unsigned f = 0; f < conv_params[k].n_filter; f++){
									for(unsigned n = 0; n < conv_params[k].N * conv_params[k].N; n++){
										fisher_conv_gradB_sq(f,m*conv_params[k].N*conv_params[k].N+n) *= out(m,l);
									}
								}
							}
							metric_conv_gradB[k] += fisher_conv_gradB_sq;
						}
	    
						for(unsigned k = 0; k < W.size(); k++){
							const unsigned rev_k = n_layers - k - 2;
							metric_gradB[rev_k] += (fgradB[rev_k].array().square().array().colwise() * out.array().col(l)).matrix();
						}
					}
				}
	
				bool init_flag = false;
				if(i == 0 && j == 0 && !params.init_metric_id){
					init_flag = true;
				}

				std::vector<MyMatrix> conv_Mii(conv_params.size());
				std::vector<MyMatrix> conv_M0i(conv_params.size());
				std::vector<MyVector> conv_M00(conv_params.size());
	
				buildConvQDMetric(curr_batch_size, metric_conv_gradB, conv_A, X_batch, conv_W, params.matrix_reg, conv_Mii, conv_M0i, conv_M00);

				updateConvMetric(init_flag, params.metric_gamma, conv_pMii, conv_pM0i, conv_pM00, conv_Mii, conv_M0i, conv_M00);

				MyMatrix Mii_out, M0i_out;
				MyVector M00_out;
				std::vector<MySpMatrix> Mii(W.size());
				std::vector<MySpMatrix> M0i(W.size());
				std::vector<MyVector> M00(W.size());

				buildQDMetric(metric_gradB, A, z0, W_out, W, params.matrix_reg, Mii_out, M0i_out, M00_out, Mii, M0i, M00);

				updateMetric(init_flag, params.metric_gamma, Mii_out, M0i_out, M00_out, Mii, M0i, M00, pMii_out, pM0i_out, pM00_out, pMii, pM0i, pM00);
				update(eta, gradB, A, z0, params.regularizer, params.lambda, W_out, W, Wt, B, Mii_out, M0i_out, M00_out, Mii, M0i, M00);
			}
      
			double curr_time = gettime();
			cumul_time += curr_time - prev_time;      
      
			if(params.minilog_flag){
	
				double train_loss = 0.;
				double train_accuracy = 0.;
				double valid_loss = 0.;
				double valid_accuracy = 0.;
				evalModel(eval_act_func, params, n_train_batch, n_training, X_train, Y_train, conv_params, pool_params, conv_W, conv_B, W_out, W, B, train_loss, train_accuracy);
				evalModel(eval_act_func, params, n_valid_batch, n_valid, X_valid, Y_valid, conv_params, pool_params, conv_W, conv_B, W_out, W, B, valid_loss, valid_accuracy);
	
				// Logging
				*logger << i + float(j)/n_train_batch << " " << cumul_time << " " << train_loss <<  " " << train_accuracy << " " << valid_loss <<  " " << valid_accuracy << " " << eta << std::endl;
	
			}
		}
		if(!params.minilog_flag || params.adaptive_flag){
			double train_loss = 0.;
			double train_accuracy = 0.;
			double valid_loss = 0.;
			double valid_accuracy = 0.;
			evalModel(eval_act_func, params, n_train_batch, n_training, X_train, Y_train, conv_params, pool_params, conv_W, conv_B, W_out, W, B, train_loss, train_accuracy);
			evalModel(eval_act_func, params, n_valid_batch, n_valid, X_valid, Y_valid, conv_params, pool_params, conv_W, conv_B, W_out, W, B, valid_loss, valid_accuracy);
      
			// if(params.adaptive_flag)
			// 	adaptiveRule(train_loss, prev_loss, eta, W, B, pMii, pM0i, pM00, pW, pB, ppMii, ppM0i, ppM00);
      
			// Logging
			if(!params.minilog_flag){
				*logger << i  << " " << cumul_time << " " << train_loss <<  " " << train_accuracy << " " << valid_loss <<  " " << valid_accuracy << " " << eta << std::endl;
			}
		}
	}
}
Exemplo n.º 26
0
void SingleServer::newConn()
{
	clientConnection = server->nextPendingConnection();
	connect(clientConnection, SIGNAL(readyRead()), this, SLOT(readArgs()));
	connect(clientConnection, SIGNAL(disconnected()), clientConnection, SLOT(deleteLater()));
}
/**
 * \brief    Main function
 * \details  --
 * \param    int argc
 * \param    char const** argv
 * \return   \e int
 */
int main( int argc, char const** argv )
{
  /*--------------------------------*/
  /* 1) Read command line arguments */
  /*--------------------------------*/
  size_t      rep                      = 0;
  std::string optional_filename        = "";
  std::string optional_population_path = "";
  readArgs(argc, argv, rep, optional_filename, optional_population_path);
  
  /*--------------------------------*/
  /* 2) Load parameters from file   */
  /*--------------------------------*/
  printHeader();
  Parameters* parameters = new Parameters();
  bool load_successful   = false;
  if (strcmp(optional_filename.c_str(), "") != 0)
  {
    load_successful = parameters->load_parameters_from_file(optional_filename);
  }
  else
  {
    load_successful = parameters->load_parameters_from_file(DEFAULT_FILENAME);
  }
  if (!load_successful)
  {
    std::cout << "Error during parameters loading.\n";
    exit(EXIT_FAILURE);
  }
  
  /*--------------------------------*/
  /* 3) Load the evolved population */
  /*--------------------------------*/
  Population* evolved_population = NULL;
  if (strcmp(optional_population_path.c_str(), "") != 0)
  {
    gzFile pop_file    = gzopen(optional_population_path.c_str(), "r");
    evolved_population = new Population(parameters, pop_file);
    gzclose(pop_file);
  }
  else
  {
    gzFile pop_file    = gzopen(DEFAULT_POPULATION_PATH.c_str(), "r");
    evolved_population = new Population(parameters, pop_file);
    gzclose(pop_file);
  }
  
  /*--------------------------------*/
  /* 4) Run the post-treatment      */
  /*--------------------------------*/
  measure_frequency_dependent_fitness(parameters, evolved_population, rep);
  
  /*--------------------------------*/
  /* 5) Free the memory             */
  /*--------------------------------*/
  delete evolved_population;
  evolved_population = NULL;
  delete parameters;
  parameters = NULL;
  
  return EXIT_SUCCESS;
}