Пример #1
1
static void init_rand_gen()
{
	int fd = open("/dev/urandom", O_RDONLY);
	if (fd != -1) {
		uint32_t seed;
		read(fd, &seed, sizeof(uint32_t));
		g_mt_rand.seed(seed);
		close(fd);
	}
	else {
		g_mt_rand.seed(time(NULL));
	}
}
Пример #2
0
int main() {

	gen.seed(static_cast<unsigned int>(std::time(0)));

	const int beam_size = 3;
	const int vocab_size = 10;
	const int start_symbol = 0;
	const int end_symbol = 1;
	const int max_decoding_length = 30;
	const int min_decoding_length = 10;
	const int source_length = 10;
	const precision penalty = 3;

	decoder<precision> d(beam_size,vocab_size,start_symbol,end_symbol,
		max_decoding_length,min_decoding_length,penalty,"");

	Eigen::Matrix<precision,Eigen::Dynamic, Eigen::Dynamic> outputDist;
	Eigen::Matrix<precision, 1, Eigen::Dynamic> normalization;
	outputDist.resize(vocab_size,beam_size);
	normalization.resize(1,beam_size);

	init_output_dist(outputDist,normalization);

	d.init_decoder();

	for(int i=0; i<20; i++) {
		init_output_dist(outputDist,normalization);
		d.expand_hypothesis(outputDist);
		d.print_current_hypotheses();
	}
	d.finish_current_hypotheses(outputDist);
	d.print_current_hypotheses();
}
Пример #3
0
void UnsyncedRNG::Seed(unsigned seed)
{
#ifdef USE_BOOST_RNG
	rng.seed(seed);
#else
	randSeed = seed;
#endif
}
int main(int argc, char** argv) {

    ptime begin = microsec_clock::local_time();

    random::mt19937 rng;
    random::uniform_real_distribution<> uni(-1, 1);

    int seed = lexical_cast<int>(argv[1]);

    double Wi = lexical_cast<double>(argv[2]);
    double Wf = lexical_cast<double>(argv[3]);

    double mu = lexical_cast<double>(argv[4]);

    double Ui = UWi(Wi);

    double D = lexical_cast<double>(argv[5]);

    double taui = lexical_cast<double>(argv[6]);
    double tauf = lexical_cast<double>(argv[7]);
    int ntaus = lexical_cast<int>(argv[8]);
    //    double tf = 2*tau;
    //    int nsteps = lexical_cast<int>(argv[9]);

    double dt = lexical_cast<double>(argv[9]);
    //    int dnsav = lexical_cast<int>(argv[8]);

    //    int nsteps = (int) ceil(2 * tau / dt);
    //    double h = 2 * tau / nsteps;


    int numthreads = lexical_cast<int>(argv[10]);

    int resi = lexical_cast<int>(argv[11]);
    //    int resi = 0;
    //    if (argc > 9) {
    //        resi = lexical_cast<int>(argv[9]);
    //    }

    int subresi = -1;
    int seed2 = 0;
    if (argc > 12) {
        //        subresi = lexical_cast<int>(argv[12]);
        seed2 = lexical_cast<int>(argv[12]);
    }

#ifdef AMAZON
    //    path resdir("/home/ubuntu/Results/Canonical Transformation Dynamical Gutzwiller");
    path resdir("/home/ubuntu/Dropbox/Amazon EC2/Simulation Results/Canonical Transformation Dynamical Gutzwiller 2");
#else
    path resdir("/Users/Abuenameh/Documents/Simulation Results/Canonical Transformation Dynamical Gutzwiller 2");
    //        path resdir("/Users/Abuenameh/Documents/Simulation Results/Dynamical Gutzwiller Hartmann Comparison");
#endif
    if (!exists(resdir)) {
        cerr << "Results directory " << resdir << " does not exist!" << endl;
        exit(1);
    }
    ostringstream oss;
    if (subresi == -1) {
        oss << "res." << resi << ".txt";
    }
    else {
        oss << "res." << resi << "." << subresi << ".txt";
    }
    path resfile = resdir / oss.str();
    //#ifndef AMAZON
    while (exists(resfile)) {
        resi++;
        oss.str("");
        if (subresi == -1) {
            oss << "res." << resi << ".txt";
        }
        else {
            oss << "res." << resi << "." << subresi << ".txt";
        }
        resfile = resdir / oss.str();
    }
    //#endif
    //        if (seed == -1) {
    //            resi = -1;
    if (seed < 0) {
        resi = seed;
        oss.str("");
        oss << "res." << resi << ".txt";
        resfile = resdir / oss.str();
    }
    vector<double> xi(L, 1);
    rng.seed(seed);
    if (seed > -1) {
        for (int j = 0; j < L; j++) {
            xi[j] = (1 + D * uni(rng));
        }
    }

    //        double Ui = UWi(Wi);
    double mui = mu * Ui;

    filesystem::ofstream os(resfile);
    printMath(os, "seed", resi, seed);
    printMath(os, "Delta", resi, D);
    //    printMath(os, "Wres", resi, Wi);
    printMath(os, "mures", resi, mui);
    printMath(os, "Ures", resi, Ui);
    printMath(os, "xires", resi, xi);
    os << flush;

    printMath(os, "dtres", resi, dt);
    //    printMath(os, "tauires", resi, taui);
    //    printMath(os, "taufres", resi, tauf);
    //    printMath(os, "ntausres", resi, ntaus);

    os << flush;

    //        printMath(os, "Wires", resi, Wi);
    //        printMath(os, "Wfres", resi, Wf);
    os << flush;

    cout << "Res: " << resi << endl;

    queue<input> inputs;
    if (ntaus == 1) {
        input in;
        in.tau = taui;
        inputs.push(in);
    }
    else {
        for (int i = 0; i < ntaus; i++) {
            input in;
            double tau = taui + i * (tauf - taui) / (ntaus - 1);
            in.tau = tau;
            inputs.push(in);
        }
    }

    vector<results> res;

    vector<double> f0(2 * L*dim, 1);
    rng.seed(seed2);
    for (int i = 0; i < 2 * L * dim; i++) {
        f0[i] = uni(rng);
    }

    DynamicsProblem::setup(Wi, mui, xi);

    //    DynamicsProblem::setup(Wi, Wf, mui, xi, f0, dt);
    //    return 0;

    progress_display progress(inputs.size());

    barrier bar(numthreads);

    thread_group threads;
    for (int i = 0; i < numthreads; i++) {
        threads.create_thread(bind(&threadfunc, Wi, Wf, mui, xi, tauf, boost::ref(inputs), boost::ref(res), boost::ref(progress), boost::ref(bar), i));
    }
    threads.join_all();

    vector<double> taures;
    vector<double> Eires;
    vector<double> Efres;
    vector<double> Qres;
    vector<double> pres;
    vector<double> U0res;
    vector<vector<double>> J0res;
    vector<vector<complex<double>>> b0res;
    vector<vector<complex<double>>> bfres;
    vector<vector < vector<complex<double>>>> f0res;
    vector<vector < vector<complex<double>>>> ffres;
    //    vector<vector<vector<double>>> bsres;
    vector<string> runtimeres;

    for (results ires : res) {
        taures.push_back(ires.tau);
        Eires.push_back(ires.Ei);
        Efres.push_back(ires.Ef);
        Qres.push_back(ires.Q);
        pres.push_back(ires.p);
        U0res.push_back(ires.U0);
        J0res.push_back(ires.J0);
        b0res.push_back(ires.b0);
        bfres.push_back(ires.bf);
        f0res.push_back(ires.f0);
        ffres.push_back(ires.ff);
        //        bsres.push_back(ires.bs);
        runtimeres.push_back(ires.runtime);
    }

    printMath(os, "taures", resi, subresi, taures);
    printMath(os, "Eires", resi, subresi, Eires);
    printMath(os, "Efres", resi, subresi, Efres);
    printMath(os, "Qres", resi, subresi, Qres);
    printMath(os, "pres", resi, subresi, pres);
    printMath(os, "U0res", resi, subresi, U0res);
    printMath(os, "J0res", resi, subresi, J0res);
    printMath(os, "b0res", resi, subresi, b0res);
    printMath(os, "bfres", resi, subresi, bfres);
    //    printMath(os, "f0res", resi, subresi, f0res);
    //    printMath(os, "ffres", resi, subresi, ffres);
    //    printMath(os, "bsres", resi, bsres);
    printMath(os, "runtime", resi, subresi, runtimeres);

    ptime end = microsec_clock::local_time();
    time_period period(begin, end);
    cout << endl << period.length() << endl << endl;

    if (subresi == -1) {
        os << "totalruntime[" << resi << "]=\"" << period.length() << "\";" << endl;
    }
    else {
        os << "subtotalruntime[" << resi << "," << subresi << "]=\"" << period.length() << "\";" << endl;
    }

    return 0;

    //        cout << setprecision(10);
    //
    //    double Wi = 2e11;
    //    double Wf = 1e11;
    //    double tau = 1e-6;
    //    double mu = 0.5;
    //    vector<double> xi(L, 1);
    //
    //    int ndim = 2 * L*dim;
    //
    //    vector<double> f0(ndim, 1);
    //
    //    vector<double> Eiv, Efv, Qv, pv;
    //    vector<vector<double>> bv;
    //
    //    DynamicsProblem prob;
    //
    //    for (int i = 0; i < 10; i++) {
    //        prob.setParameters(Wi, Wf, tau + i * 0.1e-6, xi, mu);
    //        prob.setInitial(f0);
    //        prob.solve();
    //        prob.evolve();
    //
    //        Eiv.push_back(prob.getEi());
    //        Efv.push_back(prob.getEf());
    //        Qv.push_back(prob.getQ());
    //        pv.push_back(prob.getRho());
    //        bv.push_back(prob.getBs());
    //    }
    //    
    //    cout << math(bv) << endl;
    //    cout << math(Eiv) << endl;
    //    cout << math(Efv) << endl;
    //    cout << math(Qv) << endl;
    //    cout << math(pv) << endl;

    //    cout << prob.getGSRuntime() << endl;
    //    cout << prob.getRuntime() << endl;

    return 0;


    return 0;
}
Пример #5
0
int Helper::getRandomNumber(const int _min, const int _max)
{
	randomGenerator.seed(std::time(0));
	boost::random::uniform_int_distribution<> dist(_min, _max);
	return dist(randomGenerator);
}
Пример #6
0
// Initialize the seed of the random number generator
void random_initialize(unsigned int seed) {
    random_gen.seed(seed);
}
int main() {
	string x, y, opcode;
	string cmd;

    boost::random::uniform_int_distribution<> dist32bit(0, 2147483647);
	boost::random::uniform_int_distribution<> dist3bit(0, 4);
	
	vector<pair<string,string> > db;
	
	for(int i = 0; i < 5000; i++) {
		gen.seed(static_cast<unsigned int>(time(0) + getpid()) + i);
		
		int r0 = dist32bit(gen);
		int r1 = dist32bit(gen); 
		int r2 = dist3bit(gen);
		
		//cout << r0 << " " << r1 << " " << r2 << endl;
		
		bitset<32> t0(r0);
		bitset<32> t1(r1);
		bitset<3> t2(r2);
		x = t0.to_string();
		y = t1.to_string();
		opcode = t2.to_string();
		
		//cout << x << " " << y << " " << opcode << endl;
		
		cmd = "vvp a.out +x=" + x + " +y=" + y + " +opcode=" + opcode;	// Program to run or "wrap"
		string out = exec(cmd);
		
		//cout << out;
		
		int index;
		string delay;
		const char* process = out.c_str();
		
		for(int i = strlen(process) - 1; i >= 0; i--) {
			if(process[i] == ' ') { index = i; break; }
		}
		
		for(int i = index + 1; i < strlen(process); i++) {
			delay = delay + process[i];
		}
		
		add(delay, opcode, db);
		
		cout << i << endl;
	}
	
	int j;
	ofstream f("5krandominputs.txt");	// Output file
	for(vector<pair<string,string> >::const_iterator i = db.begin(); i != db.end(); ++i) {
		string first = (*i).first;
		string second = (*i).second;
		trim(first);
		trim(second);
		string w = first + " " + second + '\n';
		f << w;
		int j;
		cout << "writing..." << j++ << endl;
	}
}
Пример #8
0
namespace sfs
{
	boost::random::mt19937 randfast;
	boost::random::mt19937_64 randfast64;

	boost::random::random_device randomizer;

	void seedrand()
	{
		randfast.seed(time(0));
		randfast64.seed(time(0));
	}

	double random(double min, double max, bool slow)
	{
		boost::random::uniform_real_distribution<double> d(min, max);
		if(slow)
		{
			return d(randomizer);
		}
		return d(randfast64);
	}

	float random(float min, float max, bool slow)
	{
		boost::random::uniform_real_distribution<float> d(min, max);
		if(slow)
		{
			return d(randomizer);
		}
		return d(randfast);
	}

	template<typename T>
	T random(T min, T max, bool slow)
	{
		boost::random::uniform_int_distribution<T> d(min, max);
		if(slow)
		{
			return d(randomizer);
		}
		if(sizeof(T) >= 8)
		{
			// If we want 64-bit, use 64-bit generator.
			return d(randfast64);
		}
		return d(randfast);
	}

	rgba random(rgba min, rgba max, bool slow)
	{
		rgba result;
		result.r = random(min.r, max.r, slow);
		result.g = random(min.g, max.g, slow);
		result.b = random(min.b, max.b, slow);
		result.a = random(min.a, max.a, slow);
		return result;
	}

	vec3 random(vec3 min, vec3 max, bool slow)
	{
		vec3 result;
		result.x = random(min.x, max.x, slow);
		result.y = random(min.y, max.y, slow);
		result.z = random(min.z, max.z, slow);
		return result;
	}
}
Пример #9
0
	void seed(int seed)
	{
		gen.seed(seed);
	}
Пример #10
0
	RandomInt(int min, int max, int seed)
		: dist(min, max)
	{
		gen.seed(seed);
	}
Пример #11
0
namespace robogen {
void init(unsigned int seed, std::string outputDirectory,
		std::string confFileName, bool overwrite, bool saveAll);

void printUsage(char *argv[]) {
	std::cout << std::endl << "USAGE: " << std::endl << "      "
			<< std::string(argv[0])
			<< " <SEED, INTEGER> <OUTPUT_DIRECTORY, STRING> "
			<< "<CONFIGURATION_FILE, STRING> [<OPTIONS>]" << std::endl
			<< std::endl << "WHERE: " << std::endl
			<< "      <SEED> is a number to seed "
			<< "the pseudorandom number generator." << std::endl << std::endl
			<< "      <OUTPUT_DIRECTORY> is the directory to write output "
			<< "files to." << std::endl << std::endl
			<< "      <CONFIGURATION_FILE> is the evolution"
			<< " configuration file to use." << std::endl << std::endl
			<< "OPTIONS: " << std::endl << "      --help" << std::endl
			<< "          Print all configuration options and exit."
			<< std::endl << std::endl << "      --overwrite" << std::endl
			<< "          Overwrite existing output file directory if it "
			<< "exists." << std::endl
			<< "          (Default is to keep creating new output "
			<< "directories with incrementing suffixes)." << std::endl
			<< std::endl << "      --save-all" << std::endl
			<< "          Save all individuals instead of just the generation"
			<< "best." << std::endl << std::endl;

}

void printHelp() {
	boost::shared_ptr<EvolverConfiguration> conf = boost::shared_ptr<
			EvolverConfiguration>(new EvolverConfiguration());
	conf->init("help");
	std::cout << std::endl;
	boost::shared_ptr<RobogenConfig> robotConf =
			ConfigurationReader::parseConfigurationFile("help");
}

boost::shared_ptr<Population> population;
IndividualContainer children;
boost::shared_ptr<NeatContainer> neatContainer;
boost::shared_ptr<RobogenConfig> robotConf;
boost::shared_ptr<EvolverConfiguration> conf;
boost::shared_ptr<EvolverLog> log;
bool neat;
boost::shared_ptr<Selector> selector;
boost::shared_ptr<Mutator> mutator;
unsigned int generation;
boost::random::mt19937 rng;

std::vector<Socket*> sockets;

void parseArgsThenInit(int argc, char* argv[]) {

	startRobogen();

	// ---------------------------------------
	// verify usage and load configuration
	// ---------------------------------------
	if (argc > 1 && std::string(argv[1]) == "--help") {
		printUsage(argv);
		printHelp();
		exitRobogen(EXIT_SUCCESS);
	}

	if ((argc < 4)) {
		printUsage(argv);
		std::cout << "RUN: " << std::endl << std::endl
				<< "      " << std::string(argv[0])
				<< " --help to see all configuration options."
				<< std::endl << std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	unsigned int seed = atoi(argv[1]);

	std::string outputDirectory = std::string(argv[2]);
	std::string confFileName = std::string(argv[3]);

	bool overwrite = false;
	bool saveAll = false;
	int currentArg = 4;
	for (; currentArg < argc; currentArg++) {
		if (std::string("--help").compare(argv[currentArg]) == 0) {
			printUsage(argv);
			printHelp();
			exitRobogen(EXIT_SUCCESS);
		} else if (std::string("--overwrite").compare(argv[currentArg]) == 0) {
			overwrite = true;
		} else if (std::string("--save-all").compare(argv[currentArg]) == 0) {
			saveAll = true;
		} else {
			std::cerr << std::endl << "Invalid option: " << argv[currentArg]
							 << std::endl << std::endl;
			printUsage(argv);
			exitRobogen(EXIT_FAILURE);
		}

	}

	init(seed, outputDirectory, confFileName, overwrite, saveAll);

}

void init(unsigned int seed, std::string outputDirectory,
		std::string confFileName, bool overwrite, bool saveAll) {

	// Seed random number generator

	rng.seed(seed);

	conf.reset(new EvolverConfiguration());
	if (!conf->init(confFileName)) {
		std::cerr << "Problems parsing the evolution configuration file. Quit."
				<< std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	robotConf = ConfigurationReader::parseConfigurationFile(
			conf->simulatorConfFile);
	if (robotConf == NULL) {
		std::cerr << "Problems parsing the robot configuration file. Quit."
				<< std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	// ---------------------------------------
	// Set up evolution
	// ---------------------------------------

	if (conf->selection == conf->DETERMINISTIC_TOURNAMENT) {
		selector.reset(new DeterministicTournament(conf->tournamentSize, rng));
	} else {
		std::cerr << "Selection type id " << conf->selection << " unknown."
				<< std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	mutator.reset(new Mutator(conf, rng));
	log.reset(new EvolverLog());
	try {
		if (!log->init(conf, robotConf, outputDirectory, overwrite, saveAll)) {
			std::cerr << "Error creating evolver log. Aborting." << std::endl;
			exitRobogen(EXIT_FAILURE);
		}
	} catch (std::exception& e) {
		std::cerr << e.what() << std::endl;
		exitRobogen(EXIT_FAILURE);
	} catch (...) {
		std::cerr << "non standard exception " << std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	// ---------------------------------------
	// parse robot from file & initialize population
	// ---------------------------------------

	boost::shared_ptr<RobotRepresentation> referenceBot(
			new RobotRepresentation());
	bool growBodies = false;
	if (conf->evolutionMode == EvolverConfiguration::BRAIN_EVOLVER
			&& conf->referenceRobotFile.compare("") == 0) {
		std::cerr << "Trying to evolve brain, but no robot file provided."
				<< std::endl;
		exitRobogen(EXIT_FAILURE);
	} else if (conf->referenceRobotFile.compare("") != 0) {
		if (!referenceBot->init(conf->referenceRobotFile)) {
			std::cerr << "Failed interpreting robot from text file"
					<< std::endl;
			exitRobogen(EXIT_FAILURE);
		}
	} else { //doing body evolution and don't have a reference robot
		if (referenceBot->init()) {
			growBodies = true;
		} else {
			std::cerr << "Failed creating base robot for body evolution"
					<< std::endl;
			exitRobogen(EXIT_FAILURE);
		}
	}

	neat = (conf->evolutionaryAlgorithm == EvolverConfiguration::HYPER_NEAT);
	population.reset(new Population());
	if (!population->init(referenceBot, conf->mu, mutator, growBodies,
			(!(conf->useBrainSeed || neat)) ) ) {
		std::cerr << "Error when initializing population!" << std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	if (neat) {
		neatContainer.reset(new NeatContainer(conf, population, seed, rng));
	}

	// ---------------------------------------
	// open sockets for communication with simulator processes
	// ---------------------------------------
#ifndef EMSCRIPTEN
	sockets.resize(conf->sockets.size());
	for (unsigned int i = 0; i < conf->sockets.size(); i++) {
		sockets[i] = new TcpSocket;
#ifndef FAKEROBOTREPRESENTATION_H // do not bother with sockets when using
		// benchmark
		if (!sockets[i]->open(conf->sockets[i].first,
				conf->sockets[i].second)) {
			std::cerr << "Could not open connection to simulator" << std::endl;
			exitRobogen(EXIT_FAILURE);
		}
#endif
	}
#endif

	// ---------------------------------------
	// run evolution TODO stopping criterion
	// ---------------------------------------

	if(neat) {
		if(!neatContainer->fillPopulationWeights(population)) {
			std::cerr << "Filling weights from NEAT failed." << std::endl;
			exitRobogen(EXIT_FAILURE);
		}
	}

	generation = 1;
	population->evaluate(robotConf, sockets);
}

void mainEvolutionLoop();

void postEvaluateNEAT() {
	population->sort(true);
	mainEvolutionLoop();
}

void postEvaluateStd() {

	// comma or plus?
	if (conf->replacement == conf->PLUS_REPLACEMENT) {
		children += *population.get();
	}

	// replace
	population.reset(new Population());
	if (!population->init(children, conf->mu)) {
		std::cout << "Error when initializing population!" << std::endl;
		exitRobogen(EXIT_FAILURE);
	}
	mainEvolutionLoop();
}

void triggerPostEvaluate() {
	if (generation == 1) {
		mainEvolutionLoop();
	} else {
		if (neat) {
			postEvaluateNEAT();
		} else {
			postEvaluateStd();
		}
	}
}

void mainEvolutionLoop() {
#ifdef EMSCRIPTEN
	std::stringstream ss;
	double best, average, stddev;
	population->getStat(best, average, stddev);
	ss << "{best : " << best << ", average : " << average << ", stddev : "
			<< stddev << ", generation : " << generation << "}";
	sendJSEvent("stats", ss.str());
#endif

	std::cout << "mainEvolutionLoop" << std::endl;
	if (!log->logGeneration(generation, *population.get())) {
		exitRobogen(EXIT_FAILURE);
	}

	generation++;


	if (generation <= conf->numGenerations) {
		std::cout << "Generation " << generation << std::endl;
		children.clear();

		// create children
		if (neat) {
			//neatPopulation->Epoch();
			if(!neatContainer->produceNextGeneration(population)) {
				std::cerr << "Producing next generation from NEAT failed."
						<< std::endl;
				exitRobogen(EXIT_FAILURE);
			}
			population->evaluate(robotConf, sockets);

		} else {
			selector->initPopulation(population);
			unsigned int numOffspring = 0;
			while (numOffspring < conf->lambda) {

				std::pair<boost::shared_ptr<RobotRepresentation>,
						boost::shared_ptr<RobotRepresentation> > selection;
				if (!selector->select(selection.first)) {
					std::cerr << "Selector::select() failed." << std::endl;
					exitRobogen(EXIT_FAILURE);
				}
				unsigned int tries = 0;
				do {
					if (tries > 10000) {
						std::cerr << "Selecting second parent failed after "
								"10000 tries, giving up.";
						exitRobogen(EXIT_FAILURE);
					}
					if (!selector->select(selection.second)) {
						std::cerr << "Selector::select() failed." << std::endl;
						exitRobogen(EXIT_FAILURE);
					}
					tries++;
				} while (selection.first == selection.second);

				std::vector<boost::shared_ptr<RobotRepresentation> > offspring
					= mutator->createOffspring(selection.first,
											   selection.second);

				// no crossover, or can fit both new individuals
				if ( (numOffspring + offspring.size()) <= conf->lambda ) {
					children.insert(children.end(), offspring.begin(),
													offspring.end() );
					numOffspring += offspring.size();
				} else { // crossover, but can only fit one
					children.push_back(offspring[0]);
					numOffspring++;
				}
			}
			children.evaluate(robotConf, sockets);
		}
#ifndef EMSCRIPTEN
		triggerPostEvaluate();
#endif
	} else {
#ifdef EMSCRIPTEN
		sendJSEvent("evolutionTerminated", "{}");
#endif

	}
}

#ifdef EMSCRIPTEN
void EMSCRIPTEN_KEEPALIVE evaluationResultAvailable(int ptr, double fitness) {
	RobotRepresentation* robot = (RobotRepresentation*) ptr;
	robot->asyncEvaluateResult(fitness);
}

void EMSCRIPTEN_KEEPALIVE evaluationIsDone() {
	triggerPostEvaluate();
}
#endif

}
Пример #12
0
void init(unsigned int seed, std::string outputDirectory,
		std::string confFileName, bool overwrite, bool saveAll) {

	// Seed random number generator

	rng.seed(seed);

	conf.reset(new EvolverConfiguration());
	if (!conf->init(confFileName)) {
		std::cerr << "Problems parsing the evolution configuration file. Quit."
				<< std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	robotConf = ConfigurationReader::parseConfigurationFile(
			conf->simulatorConfFile);
	if (robotConf == NULL) {
		std::cerr << "Problems parsing the robot configuration file. Quit."
				<< std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	// ---------------------------------------
	// Set up evolution
	// ---------------------------------------

	if (conf->selection == conf->DETERMINISTIC_TOURNAMENT) {
		selector.reset(new DeterministicTournament(conf->tournamentSize, rng));
	} else {
		std::cerr << "Selection type id " << conf->selection << " unknown."
				<< std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	mutator.reset(new Mutator(conf, rng));
	log.reset(new EvolverLog());
	try {
		if (!log->init(conf, robotConf, outputDirectory, overwrite, saveAll)) {
			std::cerr << "Error creating evolver log. Aborting." << std::endl;
			exitRobogen(EXIT_FAILURE);
		}
	} catch (std::exception& e) {
		std::cerr << e.what() << std::endl;
		exitRobogen(EXIT_FAILURE);
	} catch (...) {
		std::cerr << "non standard exception " << std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	// ---------------------------------------
	// parse robot from file & initialize population
	// ---------------------------------------

	boost::shared_ptr<RobotRepresentation> referenceBot(
			new RobotRepresentation());
	bool growBodies = false;
	if (conf->evolutionMode == EvolverConfiguration::BRAIN_EVOLVER
			&& conf->referenceRobotFile.compare("") == 0) {
		std::cerr << "Trying to evolve brain, but no robot file provided."
				<< std::endl;
		exitRobogen(EXIT_FAILURE);
	} else if (conf->referenceRobotFile.compare("") != 0) {
		if (!referenceBot->init(conf->referenceRobotFile)) {
			std::cerr << "Failed interpreting robot from text file"
					<< std::endl;
			exitRobogen(EXIT_FAILURE);
		}
	} else { //doing body evolution and don't have a reference robot
		if (referenceBot->init()) {
			growBodies = true;
		} else {
			std::cerr << "Failed creating base robot for body evolution"
					<< std::endl;
			exitRobogen(EXIT_FAILURE);
		}
	}

	neat = (conf->evolutionaryAlgorithm == EvolverConfiguration::HYPER_NEAT);
	population.reset(new Population());
	if (!population->init(referenceBot, conf->mu, mutator, growBodies,
			(!(conf->useBrainSeed || neat)) ) ) {
		std::cerr << "Error when initializing population!" << std::endl;
		exitRobogen(EXIT_FAILURE);
	}

	if (neat) {
		neatContainer.reset(new NeatContainer(conf, population, seed, rng));
	}

	// ---------------------------------------
	// open sockets for communication with simulator processes
	// ---------------------------------------
#ifndef EMSCRIPTEN
	sockets.resize(conf->sockets.size());
	for (unsigned int i = 0; i < conf->sockets.size(); i++) {
		sockets[i] = new TcpSocket;
#ifndef FAKEROBOTREPRESENTATION_H // do not bother with sockets when using
		// benchmark
		if (!sockets[i]->open(conf->sockets[i].first,
				conf->sockets[i].second)) {
			std::cerr << "Could not open connection to simulator" << std::endl;
			exitRobogen(EXIT_FAILURE);
		}
#endif
	}
#endif

	// ---------------------------------------
	// run evolution TODO stopping criterion
	// ---------------------------------------

	if(neat) {
		if(!neatContainer->fillPopulationWeights(population)) {
			std::cerr << "Filling weights from NEAT failed." << std::endl;
			exitRobogen(EXIT_FAILURE);
		}
	}

	generation = 1;
	population->evaluate(robotConf, sockets);
}
Пример #13
0
/**
 * Set the random seed used by the random functions (Random() and RandInt()).
 * The seed is casted to a 32-bit integer before being given to the random
 * number generator, but a size_t is taken as a parameter for API consistency.
 *
 * @param seed Seed for the random number generator.
 */
inline void RandomSeed(const size_t seed)
{
  randGen.seed((uint32_t) seed);
  srand((unsigned int) seed);
}
Пример #14
0
namespace math /** Miscellaneous math routines. */ {

// Annoying Boost versioning issues.
#include <boost/version.hpp>

#if BOOST_VERSION >= 104700
  // Global random object.
  extern boost::random::mt19937 randGen;
  // Global uniform distribution.
  extern boost::random::uniform_01<> randUniformDist;
  // Global normal distribution.
  extern boost::random::normal_distribution<> randNormalDist;
#else
  // Global random object.
  extern boost::mt19937 randGen;

  #if BOOST_VERSION >= 103900
    // Global uniform distribution.
    extern boost::uniform_01<> randUniformDist;
  #else
    // Pre-1.39 Boost.Random did not give default template parameter values.
    extern boost::uniform_01<boost::mt19937, double> randUniformDist;
  #endif

  // Global normal distribution.
  extern boost::normal_distribution<> randNormalDist;
#endif

/**
 * Set the random seed used by the random functions (Random() and RandInt()).
 * The seed is casted to a 32-bit integer before being given to the random
 * number generator, but a size_t is taken as a parameter for API consistency.
 *
 * @param seed Seed for the random number generator.
 */
inline void RandomSeed(const size_t seed)
{
  randGen.seed((uint32_t) seed);
  srand((unsigned int) seed);
}

/**
 * Generates a uniform random number between 0 and 1.
 */
inline double Random()
{
#if BOOST_VERSION >= 103900
  return randUniformDist(randGen);
#else
  // Before Boost 1.39, we did not give the random object when we wanted a
  // random number; that gets given at construction time.
  return randUniformDist();
#endif
}

/**
 * Generates a uniform random number in the specified range.
 */
inline double Random(const double lo, const double hi)
{
#if BOOST_VERSION >= 103900
  return lo + (hi - lo) * randUniformDist(randGen);
#else
  // Before Boost 1.39, we did not give the random object when we wanted a
  // random number; that gets given at construction time.
  return lo + (hi - lo) * randUniformDist();
#endif
}

/**
 * Generates a uniform random integer.
 */
inline int RandInt(const int hiExclusive)
{
#if BOOST_VERSION >= 103900
  return (int) std::floor((double) hiExclusive * randUniformDist(randGen));
#else
  // Before Boost 1.39, we did not give the random object when we wanted a
  // random number; that gets given at construction time.
  return (int) std::floor((double) hiExclusive * randUniformDist());
#endif
}

/**
 * Generates a uniform random integer.
 */
inline int RandInt(const int lo, const int hiExclusive)
{
#if BOOST_VERSION >= 103900
  return lo + (int) std::floor((double) (hiExclusive - lo)
                               * randUniformDist(randGen));
#else
  // Before Boost 1.39, we did not give the random object when we wanted a
  // random number; that gets given at construction time.
  return lo + (int) std::floor((double) (hiExclusive - lo)
                               * randUniformDist());
#endif

}

/**
 * Generates a normally distributed random number with mean 0 and variance 1.
 */
inline double RandNormal()
{
  return randNormalDist(randGen);
}

/**
 * Generates a normally distributed random number with specified mean and
 * variance.
 *
 * @param mean Mean of distribution.
 * @param variance Variance of distribution.
 */
inline double RandNormal(const double mean, const double variance)
{
  return variance * randNormalDist(randGen) + mean;
}

}; // namespace math
Пример #15
0
worker_input* initialize(double Wi, double Wf, double mu, vector<double>& xi, managed_shared_memory& segment) {

    SX f = SX::sym("f", 2 * L * dim);
    SX dU = SX::sym("dU", L);
    SX J = SX::sym("J", L);
    SX U0 = SX::sym("U0");

    U0 = UW(Wi);
    for (int i = 0; i < L; i++) {
        J[i] = JWij(Wi * xi[i], Wi * xi[mod(i + 1)]);
        dU[i] = UW(Wi * xi[i]) - U0;
    }

    SX E = energy(f, J, U0, dU, mu).real();

    SX g = SX::sym("g", L);
    for (int i = 0; i < L; i++) {
        g[i] = 0;
        for (int n = 0; n < dim; n++) {
            g[i] += f[2 * (i * dim + n)] * f[2 * (i * dim + n)] + f[2 * (i * dim + n) + 1] * f[2 * (i * dim + n) + 1];
        }
    }

    SXFunction nlp("nlp", nlpIn("x", f), nlpOut("f", E, "g", g));
    NlpSolver solver("solver", "ipopt", nlp, make_dict("hessian_approximation", "limited-memory", "linear_solver", "ma86", "print_level", 0, "print_time", false, "obj_scaling_factor", 1));

    boost::random::mt19937 rng;
    boost::random::uniform_real_distribution<> uni(-1, 1);

    vector<double> xrand(2 * L*dim, 1);
    rng.seed();
    for (int i = 0; i < 2 * L * dim; i++) {
        xrand[i] = uni(rng);
    }

    map<string, DMatrix> arg;
    arg["lbx"] = -1;
    arg["ubx"] = 1;
    arg["x0"] = xrand;
    arg["lbg"] = 1;
    arg["ubg"] = 1;

    map<string, DMatrix> res = solver(arg);
    vector<double> x0 = res["x"].nonzeros();
    //        vector<double> x0 = xrand;
    //    cout << "x0 = " << ::math(x0) << endl;
    //    cout << "E0 = " << ::math(res["f"].toScalar()) << endl;

    vector<complex<double>> x0i(dim);
    for (int i = 0; i < L; i++) {
        for (int n = 0; n <= nmax; n++) {
            x0i[n] = complex<double>(x0[2 * (i * dim + n)], x0[2 * (i * dim + n) + 1]);
        }
        double nrm = sqrt(abs(dot(x0i, x0i)));
        for (int n = 0; n <= nmax; n++) {
            x0[2 * (i * dim + n)] /= nrm;
            x0[2 * (i * dim + n) + 1] /= nrm;
        }
    }
    //    cout << "nlp: " << ::math(nlp(vector<DMatrix>{x0, vector<double>()})[0].toScalar()) << endl;

    void_allocator void_alloc(segment.get_segment_manager());
    worker_input* input = segment.construct<worker_input>("input")(void_alloc);
    input->U0 = UW(Wi);
    for (int i = 0; i < L; i++) {
        input->J0.push_back(JWij(Wi * xi[i], Wi * xi[mod(i + 1)]));
    }
    for (int i = 0; i < 2 * L * dim; i++) {
        input->x0.push_back(x0[i]);
    }
    for (int i = 0; i < L; i++) {
        complex_vector f0i(dim, void_alloc);
        for (int n = 0; n <= nmax; n++) {
            f0i[n] = complex<double>(x0[2 * (i * dim + n)], x0[2 * (i * dim + n) + 1]);
        }
        input->f0.push_back(f0i);
    }
    input->Wi = Wi;
    input->Wf = Wf;
    input->mu = mu;
    for (int i = 0; i < L; i++) {
        input->xi.push_back(xi[i]);
    }

    return input;
}
Пример #16
0
int main(int argc, char** argv) {

    build_odes();
    return 0;

    //    build_odes();
    //    return 0;

    ptime begin = microsec_clock::local_time();

    random::mt19937 rng;
    random::uniform_real_distribution<> uni(-1, 1);

    int seed = lexical_cast<int>(argv[1]);

    if (seed != -1) {

        double Wi = lexical_cast<double>(argv[2]);
        double Wf = lexical_cast<double>(argv[3]);

        double mu = lexical_cast<double>(argv[4]);

        double Ui = UWi(Wi);

        double D = lexical_cast<double>(argv[5]);

        double taui = lexical_cast<double>(argv[6]);
        double tauf = lexical_cast<double>(argv[7]);
        int ntaus = lexical_cast<int>(argv[8]);

        int numthreads = lexical_cast<int>(argv[9]);

        int resi = lexical_cast<int>(argv[10]);

        //        int integrator = lexical_cast<int>(argv[11]);
        std::string intg = argv[11];
        double dt = lexical_cast<double>(argv[12]);

#ifdef AMAZON
        //    path resdir("/home/ubuntu/Results/Canonical Transformation Dynamical Gutzwiller");
        path resdir("/home/ubuntu/Dropbox/Amazon EC2/Simulation Results/CTDG");
#else
        path resdir("/Users/Abuenameh/Documents/Simulation Results/Canonical Transformation Dynamical Gutzwiller 2");
        //        path resdir("/Users/Abuenameh/Documents/Simulation Results/Dynamical Gutzwiller Hartmann Comparison");
#endif
        if (!exists(resdir)) {
            cerr << "Results directory " << resdir << " does not exist!" << endl;
            exit(1);
        }
        ostringstream oss;
        oss << "res." << resi << ".txt";
        path resfile = resdir / oss.str();
        //#ifndef AMAZON
        while (exists(resfile)) {
            resi++;
            oss.str("");
            oss << "res." << resi << ".txt";
            resfile = resdir / oss.str();
        }
        //#endif
        if (seed < 0) {
            resi = seed;
            oss.str("");
            oss << "res." << resi << ".txt";
            resfile = resdir / oss.str();
        }
        vector<double> xi(L, 1);
        rng.seed(seed);
        if (seed > -1) {
            for (int j = 0; j < L; j++) {
                xi[j] = (1 + D * uni(rng));
            }
        }

        //        double Ui = UWi(Wi);
        double mui = mu * Ui;

        filesystem::ofstream os(resfile);
        printMath(os, "int", resi, intg);
        printMath(os, "seed", resi, seed);
        printMath(os, "Delta", resi, D);
        printMath(os, "dt", resi, dt);
        printMath(os, "mures", resi, mui);
        printMath(os, "Ures", resi, Ui);
        printMath(os, "xires", resi, xi);
        os << flush;

        printMath(os, "Wires", resi, Wi);
        printMath(os, "Wfres", resi, Wf);
        os << flush;

        cout << "Res: " << resi << endl;

        struct shm_remove {

            shm_remove() {
                shared_memory_object::remove("SharedMemory");
            }

            ~shm_remove() {
                shared_memory_object::remove("SharedMemory");
            }
        } remover;

        int size = 1000 * (sizeof (worker_input) + numthreads * (sizeof (worker_tau) + sizeof (worker_output))); //2 * (((2 * L * dim + L + 1) + numthreads * (4 * L * dim + 5 * L + 6)) * sizeof (double) +numthreads * 2 * sizeof (ptime)/*sizeof(time_period)*/);

        managed_shared_memory segment(create_only, "SharedMemory", size);

        worker_input* w_input = initialize(Wi, Wf, mui, xi, segment);
        //        return 0;

        void_allocator void_alloc(segment.get_segment_manager());
        char_string integrator(intg.begin(), intg.end(), void_alloc);
        w_input->integrator = integrator;
        w_input->dt = dt;

        queue<input> inputs;
        if (ntaus == 1) {
            input in;
            in.tau = taui;
            inputs.push(in);
        }
        else {
            for (int i = 0; i < ntaus; i++) {
                input in;
                double tau = taui + i * (tauf - taui) / (ntaus - 1);
                in.tau = tau;
                inputs.push(in);
            }
        }

        vector<results> res;

        progress_display progress(inputs.size());

        thread_group threads;
        for (int i = 0; i < numthreads; i++) {
            threads.create_thread(bind(&threadfunc, argv[0], tauf, boost::ref(inputs), boost::ref(res), boost::ref(progress), i, boost::ref(segment)));
        }
        threads.join_all();

        vector<double> taures;
        vector<double> Eires;
        vector<double> Efres;
        vector<double> Qres;
        vector<double> pres;
        vector<vector<double>> Esres;
        vector<vector<complex<double>>> b0res;
        vector<vector<complex<double>>> bfres;
        //        vector<complex_vector_vector> f0res;
        vector<vector < vector<complex<double>>>> ffres;
        vector<std::string> runtimeres;

        for (results& ires : res) {
            taures.push_back(ires.tau);
            Eires.push_back(ires.Ei);
            Efres.push_back(ires.Ef);
            Qres.push_back(ires.Q);
            pres.push_back(ires.p);
//            Esres.push_back(ires.Es);
            b0res.push_back(ires.b0);
            bfres.push_back(ires.bf);
            runtimeres.push_back(replace_all_copy(ires.runtime, "\"", "\\\""));
            //            vector<double> Es(ires.Es.begin(), ires.Es.end());
            //            Esres.push_back(Es);
            //            vector<complex<double>> b0(ires.b0.begin(), ires.b0.end());
            //            vector<complex<double>> bf(ires.bf.begin(), ires.bf.end());
            //            b0res.push_back(b0);
            //            bfres.push_back(bf);
            //            f0res.push_back(ires.f0);
            ffres.push_back(ires.ff);
            //            std::string runtime(ires.runtime.begin(), ires.runtime.end());
            //            runtimeres.push_back(replace_all_copy(runtime, "\"", "\\\""));
        }

        printMath(os, "taures", resi, taures);
        printMath(os, "Eires", resi, Eires);
        printMath(os, "Efres", resi, Efres);
        printMath(os, "Qres", resi, Qres);
        printMath(os, "pres", resi, pres);
        printMath(os, "U0res", resi, w_input->U0);
        printMath(os, "J0res", resi, w_input->J0);
        printMath(os, "Esres", resi, Esres);
        printMath(os, "b0res", resi, b0res);
        printMath(os, "bfres", resi, bfres);
        printMath(os, "f0res", resi, w_input->f0);
        //            printMath(os, "f0res", resi, f0res);
        printMath(os, "ffres", resi, ffres);
        printMath(os, "runtime", resi, runtimeres);

        ptime end = microsec_clock::local_time();
        time_period period(begin, end);
        cout << endl << period.length() << endl << endl;

        os << "totalruntime[" << resi << "]=\"" << period.length() << "\";" << endl;

        segment.destroy<worker_input>("input");

    }
    else {
        managed_shared_memory segment(open_only, "SharedMemory");

        worker_input* input = segment.find<worker_input>("input").first;
        worker_tau* tau = segment.find<worker_tau>(argv[2]).first;
        worker_output* output = segment.find<worker_output>(argv[3]).first;

        worker(input, tau, output, segment);

    }

    return 0;

}
Пример #17
0
	void reset(int min, int max, int seed)
	{
		dist = boost::random::uniform_int_distribution<>(min, max);
		gen.seed(seed);
	}
Пример #18
0
	void seedrand()
	{
		randfast.seed(time(0));
		randfast64.seed(time(0));
	}
Пример #19
0
int
main(int argc, char **argv)
{
    time_t tim;
    time(&tim);
    RAND.seed(tim);
    TCODConsole::initRoot(SCREEN_W,SCREEN_H,"libtcod",false);

    int messagesWinHeight = 8;
    int messagesWinWidth    = SCREEN_W;
    int statusWinHeight   = SCREEN_H - messagesWinHeight;
    int statusWinWidth    = 21;
    DUNGEON_WIN_H = statusWinHeight;
    DUNGEON_WIN_W = SCREEN_W - statusWinWidth;

    Level level(DUNGEON_WIN_W,DUNGEON_WIN_H,statusWinWidth,statusWinHeight
            ,messagesWinWidth,messagesWinHeight);
    level.generate();
    level.m_player->customize();


    level.update();

    while ( !TCODConsole::isWindowClosed() ) {
        TCODConsole::root->clear();
        level.render();
        TCODConsole::flush();
        if(level.m_player->m_running){
            level.m_player->run();
            level.update();
        }
        else{
            TCOD_key_t key = TCODConsole::waitForKeypress(true);
            if(key.pressed){
                if(!level.m_playerAlive){
                    return 0;
                }
                else{
                    switch(key.c) {
                        case 'S' :
                            return 0;
                        case 'q' :
                            level.m_player->doQuaff();break;
                        case 'h' :
                            level.m_player->walk(-1,0); break;
                        case 'j' :
                            level.m_player->walk(0,1); break;
                        case 'k' :
                            level.m_player->walk(0,-1); break;
                        case 'l' :
                            level.m_player->walk(1,0); break;
                        case 'y' :
                            level.m_player->walk(-1,-1); break;
                        case 'u' :
                            level.m_player->walk(1,-1); break;
                        case 'b' :
                            level.m_player->walk(-1,1); break;
                        case 'n' :
                            level.m_player->walk(1,1); break;
                        case 'H' :
                            level.m_player->startRun(-1,0); break;
                        case 'J' :
                            level.m_player->startRun(0,1); break;
                        case 'K' :
                            level.m_player->startRun(0,-1); break;
                        case 'L' :
                            level.m_player->startRun(1,0); break;
                        case 'Y' :
                            level.m_player->startRun(-1,-1); break;
                        case 'U' :
                            level.m_player->startRun(1,-1); break;
                        case 'B' :
                            level.m_player->startRun(-1,1); break;
                        case 'N' :
                            level.m_player->startRun(1,1); break;
                        case 'i':
                            level.m_player->showInventory();
                            break;
                        case '.':
                            level.m_player->act();
                            break;
                        case 'g':
                            level.m_player->doPickUp();
                            break;
                        case 'f':
                            level.m_player->doFire();
                            break;
                        case 'o':
                            level.m_player->doOpen();
                            break;
                        case 'Q':
                            level.m_player->doQuiver();
                            break;
                        case 'w':
                            level.m_player->doWield();
                            break;
                        case 'd':
                            level.m_player->doDrop();
                            break;
                        case '1':
                            level.m_player->invokeAbility(0);
                            break;
                        case '2':
                            level.m_player->invokeAbility(1);
                            break;
                        case '3':
                            level.m_player->invokeAbility(2);
                            break;
                        case '>':
                            level.m_player->goDown();
                            break;
                        case '<':
                            level.m_player->goUp();
                            break;
                        /*case 'D':
                            DEBUG = !DEBUG;
                            if(DEBUG)
                                level.m_messages->showMessage("DEBUG MODE ON",MESSAGE_WARNING);
                            else
                                level.m_messages->showMessage("DEBUG MODE OFF",MESSAGE_WARNING);
                            break;
                        case '-' :
                            level.m_player->m_hp--; break;
                        case '+' :
                            level.m_player->m_hp++; break;
                        case 'z' :
                            level.m_player->gainExp(300); break;
                        case 'r':
                            level.generate();
                            break;
                            */
                        default:
                            break;
                    }
                    if(level.m_playerWon){
                        return 0;
                    }
                    if(level.m_player->m_time > 0.0f){
                        level.update();
                    }
                }
            }
        }
    }
}