void evolvewrap(double *G,double *h,double *bed,double *h0,double *h1,double *u0,double *u1,double *b0,double *b1, double g,double dx,double dt, int n, int nBC,double theta)
{
//UNFINISHED~~~
double *hp = malloc(n*sizeof(double));
double *Gp = malloc(n*sizeof(double));
double *hpp = malloc(n*sizeof(double));
double *Gpp = malloc(n*sizeof(double));
//update h' and G'
evolve(h,G, hp,Gp, bed,g,u0,u1,h0,h1,b0,b1,theta,n,nBC,dx,dt);
//update h'' and G''
evolve(hp,Gp, hpp,Gpp, bed,g,u0,u1,h0,h1,b0,b1,theta,n,nBC,dx,dt);
int i;
for(i=0;i<n;i++)
{
//printf("Before G[%d] : %f || h[%d] : %f \n",i, G[i],i, h[i]);
//printf("Before Gp[%d] : %f || hp[%d] : %f \n",i, Gp[i],i, hp[i]);
//printf("Before Gpp[%d] : %f || hpp[%d] : %f \n",i, Gpp[i],i, hpp[i]);
G[i] = 0.5*(G[i] + Gpp[i]);
h[i] = 0.5*(h[i] + hpp[i]);
//printf("After G[%d] : %f || h[%d] : %f \n",i, G[i],i, h[i]);
}
free(hp);
free(Gp);
free(Gpp);
free(hpp);
}
vector<vector<double>>
mcPathGenWithAnti::genTermSample(const vector<double>& s0, const shared_ptr<func>& phi) {
vector<vector<double>> tmp, res;
//might become a problem if objects are too big
for (int i = 0; i < m_mcpath; i++) {
vector<double> s(s0);
tmp.push_back(s);
tmp.push_back(s);
}
//generating paths
for (vector<double>::const_iterator dt = m_tGrid->dx().begin(); dt != m_tGrid->dx().end(); dt++) {
vector<double> norms = m_norm.generate(m_mcpath);
for (int i = 0; i < m_mcpath; i++) {
evolve(tmp[2 * i], *dt, -norms[i]);
evolve(tmp[2 * i + 1], *dt, norms[i]);
}
}
//antithetic computation
int ssize = s0.size();
for (int i = 0; i < m_mcpath; i++) {
vector<double> sample(ssize, 0.);
for (int j = 0; j < ssize; j++)
sample[j] = (phi->value(tmp[2 * i][j]) + phi->value(tmp[2 * i + 1][j])) / 2.;
res.push_back(sample);
}
return res;
}
void evolvewrap(double *G, double *h, double *h0, double *h1, double *u0, double *u1, double g, double dx, double dt, int nBC, int n, int nBCs, double theta)
{
//first allocate memory for BC variables
double *Gbc = malloc((n + 2*nBC)*sizeof(double));
double *hbc = malloc((n + 2*nBC)*sizeof(double));
double *ubc = malloc((n + 2*nBC)*sizeof(double));
double *Gp = malloc(n*sizeof(double));
double *hp = malloc(n*sizeof(double));
evolveBC(G,h,h0,h1,u0,u1,g,dx,dt,nBC,n,nBCs,Gbc,hbc,ubc);
evolve(Gbc,hbc,ubc,g,dx,dt,nBC,n,Gp,hp,theta);
evolveBC(Gp,hp,h0,h1,u0,u1,g,dx,dt,nBC,n,nBCs,Gbc,hbc,ubc);
evolve(Gbc,hbc,ubc,g,dx,dt,nBC,n,Gp,hp,theta);
int i;
for(i=0;i<n;i++)
{
G[i] = 0.5*(G[i] + Gp[i]);
h[i] = 0.5*(h[i] + hp[i]);
}
free(Gbc);
free(hbc);
free(ubc);
free(Gp);
free(hp);
}
v1::scheduler::Event evolve(const ExitedExecutorMessage& message)
{
v1::scheduler::Event event;
event.set_type(v1::scheduler::Event::FAILURE);
v1::scheduler::Event::Failure* failure = event.mutable_failure();
failure->mutable_agent_id()->CopyFrom(evolve(message.slave_id()));
failure->mutable_executor_id()->CopyFrom(evolve(message.executor_id()));
failure->set_status(message.status());
return event;
}
v1::scheduler::Event evolve(const ExecutorToFrameworkMessage& message)
{
v1::scheduler::Event event;
event.set_type(v1::scheduler::Event::MESSAGE);
v1::scheduler::Event::Message* message_ = event.mutable_message();
message_->mutable_agent_id()->CopyFrom(evolve(message.slave_id()));
message_->mutable_executor_id()->CopyFrom(evolve(message.executor_id()));
message_->set_data(message.data());
return event;
}
int main(int argc, char *argv[]){
//check argc
if(argc!=4){
printf("Please enter the name of the input data file, the total time, and delta t in s\n");
}
double totalTime = atof(argv[2]);
double deltaT = atof(argv[3]);
body gravity[MAX_ENTRIES];
int i=0, count=0, k=0;
double cmx=0., cmy=0., cmz=0., j=0;
FILE *outp;
outp = fopen("location.dat", "w");
count=readData(argv[1], gravity);
centerOfMass(gravity, count, &cmx, &cmy, &cmz);
printf("The center of mass of all of the objects is: (%lf, %lf, %lf)\n", cmx, cmy, cmz);
gravForce(gravity, count);
for(i=0; i<count; i++){
printf("Body %3d Force = (%8.2lg, %8.2lg, %8.2lg)\n", i+1, gravity[i].f_vec[0],
gravity[i].f_vec[1], gravity[i].f_vec[2]);
}
for(j=0; j<totalTime; j+=deltaT){
gravForce(gravity, count);
evolve(gravity, count, deltaT);
for(k=0; k<count; k++){
fprintf(outp, "%lg %lg %lg\n", gravity[k].s_vec[0],
gravity[k].s_vec[1], gravity[k].s_vec[2]);
}
fprintf(outp, "\n\n");
}
fclose(outp);
return 0;
}
unsigned int gol(unsigned char *grid, unsigned int dim_x, unsigned int dim_y, unsigned int time_steps)
{
unsigned char *grid_in, *grid_out, *grid_tmp;
size_t size = sizeof(unsigned char) * dim_x * dim_y;
grid_tmp = calloc(sizeof(unsigned char), dim_y * dim_x);
if (grid_tmp == NULL)
exit(EXIT_FAILURE);
grid_in = grid;
grid_out = grid_tmp;
for (int t = 0; t < time_steps; ++t)
{
for (int y = 0; y < dim_y; ++y)
{
for (int x = 0; x < dim_x; ++x)
{
evolve(grid_in, grid_out, dim_x, dim_y, x, y);
}
}
swap((void**)&grid_in, (void**)&grid_out);
}
if (grid != grid_in)
memcpy(grid, grid_in, size);
free(grid_tmp);
return cells_alive(grid, dim_x, dim_y);
}
vector<vector<double>>
mcPathGen::genTermSample(const vector<double>& s0, const shared_ptr<func>& phi) {
vector<vector<double>> res;
//init paths
for (int i = 0; i < m_mcpath; i++) {
vector<double> s(s0);
res.push_back(s);
}
//generating paths
for (vector<double>::const_iterator dt = m_tGrid->dx().begin(); dt != m_tGrid->dx().end(); dt++) {
vector<double> norms = m_norm.generate(m_mcpath);
for (int i = 0; i < m_mcpath; i++)
evolve(res[i], *dt, norms[i]);
}
//computing terminal sample phi(s1)
int ssize = s0.size();
for (int i = 0; i < m_mcpath; i++)
for (int j = 0; j < ssize; j++)
res[i][j] = phi->value(res[i][j]);
return res;
}
int main()
{
uint64_t length = 1;
char *axiom = malloc(sizeof(char) * length);
*axiom = 'A';
char **state = &axiom;
uint64_t move;
for (move = 0; move < 7; move++)
{
#if DESCRIBE==1
printf("%d. %.*s\n", (int) move, (int) length, *state);
#endif
#ifdef LOGO_MOVE
uint64_t i;
for (i = 0; i < length && move == LOGO_MOVE; i++) {
if ((*state)[i] == '-') {
printf("LT 60\n");
}
if ((*state)[i] == '+') {
printf("RT 60\n");
}
if ((*state)[i] == 'A' || (*state)[i] == 'B') {
printf("FD 4\n");
}
}
#endif
printf("\n");
length = evolve(state, length);
}
return 0;
}
ReturnFlag CPSOH::run_()
{
ReturnFlag rf=Return_Normal;
#ifdef OFEC_CONSOLE
if(Global::msp_global->m_runId==0){
mSingleObj::getSingleObj()->setProgrOutputFlag(true);
if(mMultiModal::getPopInfor())
mMultiModal::getPopInfor()->setOutProgFlag(true);
}
#endif // OFEC_CONSOLE
while(!ifTerminating())
{
//cout<<"Run: "<<Global::msp_global->m_runId<<" "<<Global::msp_global->mp_problem->getEvaluations()<<endl;
rf=evolve();
#ifdef OFEC_CONSOLE
if(mMultiModal::getPopInfor()){
int peaksf;
peaksf=CAST_PROBLEM_CONT->getGOpt().getNumGOptFound();
mMultiModal::getPopInfor()->input(Global::msp_global.get(), Global::msp_global->mp_problem->getEvaluations(),\
Global::msp_global->m_totalNumIndis,1,peaksf,\
CAST_PROBLEM_CONT->getGOpt().getNumOpt(),0,0,0,0,\
0,0,CAST_PROBLEM_CONT->getGOpt().isAllFound());
}
#endif
if(rf==Return_Terminate) return rf;
}
return rf;
}
void FdmVPPStepCondition::applyTo(Array& a, Time t) const {
boost::shared_ptr<FdmLinearOpLayout> layout = mesher_->layout();
const Size nStates = layout->dim()[stateDirection_];
const FdmLinearOpIterator endIter = layout->end();
for (FdmLinearOpIterator iter=layout->begin();iter != endIter; ++iter) {
a[iter.index()] += evolve(iter, t);
}
for (FdmLinearOpIterator iter=layout->begin();iter != endIter; ++iter) {
if (!iter.coordinates()[stateDirection_]) {
Array x(nStates);
for (Size i=0; i < nStates; ++i) {
x[i] = a[layout->neighbourhood(iter, stateDirection_, i)];
}
const Real gasPrice = gasPrice_->innerValue(iter, t);
x = changeState(gasPrice, x, t);
for (Size i=0; i < nStates; ++i) {
a[layout->neighbourhood(iter, stateDirection_, i)] = x[i];
}
}
}
}
void EvolutionaryMonteCarlo::sample(int nCycles)
{
// Initialize ensemble of walkers from VMC best guess
MetropolisHastingsMonteCarlo *initialMonteCarlo = new MetropolisHastingsMonteCarlo(config);
initialMonteCarlo->setRecordMoves(true, nPopulations * nIndividuals * nParticles * nWalkers, "evo-positions.dat");
initialMonteCarlo->setThermalizationEnabled(true);
initialMonteCarlo->sample(nWalkers * nIndividuals * nPopulations * correlationStep);
trialEnergy = initialMonteCarlo->energy();
std::cout << "Initial trial energy was " << trialEnergy << std::endl;
vec2 **moves = initialMonteCarlo->moves();
// Initialize genes with good guesses
for(int i = 0; i < nPopulations; i++) {
for(int j = 0; j < nIndividuals; j++) {
for(int k = 0; k < nGenes; k++) {
int walkerIndex = k / (nParticles * nDimensions);
int kMarked = (k - walkerIndex * (nDimensions * nParticles)); // kMarked is now between 0 and nDimensions * nParticles
int particleIndex = kMarked / nDimensions;
int positionIndex = k % nDimensions;
int moveIndex = walkerIndex + nWalkers * j;
populations[i][j][k] = moves[moveIndex][particleIndex][positionIndex];
// populations[i][j][k] = ran3(idum) * 8;
}
}
}
// trialEnergy = 2;
double totalSum = 0;
int totalSamples = 0;
for(int cycle = 0; cycle < nCycles; cycle++) {
allBestValue = INFINITY;
evolve(1000, 100);
energySum = 0;
nEnergyUpdates = 0;
std::cout << "All best value was " << allBestValue << " found in " << meanEnergies[allBestPopulationIndex][allBestIndex] << std::endl;
// if(allBestValue < 1e-3 || cycle < 5) {
for(int i = 0; i < nPopulations; i++) {
// Avoid the random newcomers by selecting the first three quarters (the best and their children)
for(uint j = 0; j < bestIndices[i].size() * 3. / 4.; j++) {
int index = bestIndices[i][j];
// int index = j;
double meanEnergy = meanEnergies[i][index] /*/ meanEnergyCycles[i][index]*/;
// std::cout << "Mean energies: " << index << "\t" << meanEnergy << "\tdiff: " << values[i][index] << std::endl;
energySum += meanEnergy;
nEnergyUpdates++;
totalSum += meanEnergy;
totalSamples++;
meanEnergies[i][index] = 0;
meanEnergyCycles[i][index] = 0;
}
}
trialEnergy = energySum / nEnergyUpdates;
// trialEnergy = lowestEnergy;
std::cout << "New trial energy " << trialEnergy << std::endl;
std::cout << "Total average " << totalSum / totalSamples << std::endl;
// }
}
m_energy = trialEnergy;
}
inline void LifeGamev2::evolve() {
for (unsigned y = 0; y < ROW; ++y)
for (unsigned x = 0; x < COL; ++x) {
evolve(x, y);
}
swap(puniverse, p_universe);
}
int main()
{
char c[] = "_###_##_#_#_#_#__#__\n",
b[] = "____________________\n";
do { printf(c + 1); } while (evolve(c + 1, b + 1, sizeof(c) - 3));
return 0;
}
LightMap LightMap::corner_evolve() {
auto result = evolve();
result.turn_on(0,0);
result.turn_on(max_x-1,0);
result.turn_on(max_x-1,max_y-1);
result.turn_on(0,max_y-1);
return result;
}
google::protobuf::RepeatedPtrField<T1> evolve(
google::protobuf::RepeatedPtrField<T2> t2s)
{
google::protobuf::RepeatedPtrField<T1> t1s;
foreach (const T2& t2, t2s) {
t1s.Add()->CopyFrom(evolve(t2));
}
int cpuSim(int iterations, byte* ptr1, byte* ptr2, int fieldSizeX, int fieldSizeY)
{
for (int i=0; i<iterations; i++)
{
evolve(ptr1,ptr2,fieldSizeX+2,fieldSizeY+2);
byte* tmp = ptr1; ptr1 = ptr2; ptr2 = tmp;
}
return 0;
}
v1::scheduler::Event evolve(const LostSlaveMessage& message)
{
v1::scheduler::Event event;
event.set_type(v1::scheduler::Event::FAILURE);
v1::scheduler::Event::Failure* failure = event.mutable_failure();
failure->mutable_agent_id()->CopyFrom(evolve(message.slave_id()));
return event;
}
v1::scheduler::Event evolve(const RescindResourceOfferMessage& message)
{
v1::scheduler::Event event;
event.set_type(v1::scheduler::Event::RESCIND);
v1::scheduler::Event::Rescind* rescind = event.mutable_rescind();
rescind->mutable_offer_id()->CopyFrom(evolve(message.offer_id()));
return event;
}
v1::scheduler::Event evolve(const FrameworkReregisteredMessage& message)
{
v1::scheduler::Event event;
event.set_type(v1::scheduler::Event::SUBSCRIBED);
v1::scheduler::Event::Subscribed* subscribed = event.mutable_subscribed();
subscribed->mutable_framework_id()->CopyFrom(evolve(message.framework_id()));
return event;
}
void SpikingGroup::conditional_evolve()
{
spikes = get_spikes_immediate();
spikes->clear();
attribs = get_attributes_immediate();
attribs->clear();
if ( evolve_locally() ) {
evolve();
}
}
inline Disposable<Array> StochasticProcess1D::evolve(
Time t0, const Array& x0,
Time dt, const Array& dw) const {
#if defined(QL_EXTRA_SAFETY_CHECKS)
QL_REQUIRE(x0.size() == 1, "1-D array required");
QL_REQUIRE(dw.size() == 1, "1-D array required");
#endif
Array a(1, evolve(t0,x0[0],dt,dw[0]));
return a;
}
int main()
{
srand(time(NULL));
Population population;
for (int i = 0; i < POPULATION_COUNT; ++i) {
Individual ind;
Chromosome chromosome(targetString.size());
chromosome.randomize();
float fitness = evaluate(chromosome);
ind.setChromosome(chromosome);
ind.setFitness(fitness);
population.addIndividual(ind);
}
population.sortPopulation();
std::string solution = "";
Individual bestInd;
int generationCount = 0;
int nth = 64;
for (int i = 0; i < GENERATION_COUNT; ++i) {
generationCount++;
evolve(population);
population.sortPopulation();
if (bestInd < population[0]) {
bestInd = population[0];
}
if (i % nth == 0) {
std::cout << "Generation: " << generationCount << std::endl;
std::cout << "Best individual: " << bestInd << std::endl;
}
if (bestInd.getFitness() >= 1){
break;
}
}
std::cout << std::endl;
std::cout << "Solved on generation " << generationCount << '!' << std::endl;
std::cout << bestInd << std::endl << std::endl;
std::cout << "Press enter to exit";
std::cin.get();
return 0;
}
void Events::execute()
{
evolve();
newChoose:;
double chooseEvent = _random() * rates.total;
if (chooseEvent < rates.totalAds) {
int index = static_cast<int> (floor(chooseEvent / rates.ads));
adsorption(index, atomType::metal);
}
else if (chooseEvent < rates.totalAds + rates.totalDes) {
chooseEvent -= rates.totalAds;
double cumulateRates = 0;
unsigned ei = 0, ej = 0;
while (cumulateRates + rates.sumsofDes[ei] < chooseEvent) {
if (ei >= c::nDesTypes) {
goto newChoose;
}
cumulateRates += rates.sumsofDes[ei++];
}
ej = static_cast<int> (floor((chooseEvent - cumulateRates) / rates.des[ei]));
if (ej >= eventLists._desEvents[ei].size()) {
goto newChoose;
}/*
if (ei % c::nNeighCount == 0)
_nFreeDes++;
_nDesorbNeigh[ei % c::nNeighCount]++;*/
desorption(eventLists._desEvents[ei][ej]);
}
else {
chooseEvent -= rates.totalAds + rates.totalDes;
double cumulateRates = 0;
unsigned ei = 0, ej = 0;
while (cumulateRates + rates.sumsofDiff[ei] < chooseEvent) {
if (ei >= c::nDiffTypes) {
goto newChoose;
}
cumulateRates += rates.sumsofDiff[ei++];
}
ej = static_cast<int> (floor((chooseEvent - cumulateRates) / rates.diff[ei]));
if (ej >= eventLists._diffEvents[ei].size()) {
goto newChoose;
}
checkDiff(ei, eventLists._diffEvents[ei][ej]);
diffusion(eventLists._diffEvents[ei][ej]);
}
_nEvents++;
}
int main()
{
int fd = open ("shelf" , O_RDWR | O_CREAT );
void * game = init(fd);
while(1){
evolve(game);
poll(NULL , 0 , 1000);
}
munmap (game, sizeof(game));
close(fd);
}
void LifeGamev2::play() {
for (; is_run(); delay_fps(SPEED)) {
if (kbhit()) {
changeSetting(getch());
}
//原始宇宙为universe,进化后为_universe
evolve();
cleardevice();
render();
}
}
v1::scheduler::Event evolve(const StatusUpdateMessage& message)
{
v1::scheduler::Event event;
event.set_type(v1::scheduler::Event::UPDATE);
v1::scheduler::Event::Update* update = event.mutable_update();
update->mutable_status()->CopyFrom(evolve(message.update().status()));
if (message.update().has_slave_id()) {
update->mutable_status()->mutable_agent_id()->CopyFrom(
evolve(message.update().slave_id()));
}
if (message.update().has_executor_id()) {
update->mutable_status()->mutable_executor_id()->CopyFrom(
evolve(message.update().executor_id()));
}
update->mutable_status()->set_timestamp(message.update().timestamp());
// If the update does not have a 'uuid', it does not need
// acknowledging. However, prior to 0.23.0, the update uuid
// was required and always set. In 0.24.0, we can rely on the
// update uuid check here, until then we must still check for
// this being sent from the driver (from == UPID()) or from
// the master (pid == UPID()).
// TODO(vinod): Get rid of this logic in 0.25.0 because master
// and slave correctly set task status in 0.24.0.
if (!message.update().has_uuid() || message.update().uuid() == "") {
update->mutable_status()->clear_uuid();
} else if (UPID(message.pid()) == UPID()) {
update->mutable_status()->clear_uuid();
} else {
update->mutable_status()->set_uuid(message.update().uuid());
}
return event;
}
Real GemanRoncoroniProcess::evolve(Time t0, Real x0,
Time dt, Real dw) const {
// random number generator for the jump part
if (!urng_) {
typedef PseudoRandom::urng_type urng_type;
urng_ = boost::shared_ptr<urng_type>(
new urng_type((unsigned long)(1234ul*dw+56789ul)));
}
Array du(3);
du[0] = urng_->next().value;
du[1] = urng_->next().value;
return evolve(t0, x0, dt, dw, du);
}
void Simulation::evolveAllAircarft() {
vector<Aircraft>::iterator iterator = aircrafts.begin();
while (iterator != aircrafts.end()) {
Aircraft aircraft = *iterator;
UnitTime deltaTime = getTime() - startedTime;
if (!aircraft.isFlying(deltaTime)) {
aircrafts.erase(iterator);
} else {
evolve(aircraft, deltaTime);
}
iterator++;
}
}
void simulate_generation(){
MPI_Startall(vertical_req_index, vertical_reqs);
int i, loc = n+1;
for(i = 0; i < m * n; i++){
if(i % n == 0){
loc += 2;
}
/*next_generation_grid[loc] = (current_generation_grid[loc] % 1000)
+ ((current_generation + 1) * 1000);*/
next_generation_grid[loc] = evolve(loc++);
//eventually, need to exclude a 2 layer border
}
MPI_Waitall(vertical_req_index, vertical_reqs, MPI_STATUSES_IGNORE);
MPI_Startall(horizontal_req_index, horizontal_reqs);
MPI_Waitall(horizontal_req_index, horizontal_reqs, MPI_STATUSES_IGNORE);
for(i = 0; i <(m+2); i++){
current_generation_grid[i * (n+2)] = recv_right_buffer[i];
current_generation_grid[(n+1) + i * (n+2)] = recv_left_buffer[i];
}
//now have neighbor dependencies, can calculate remaining cells
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
if(world_rank == 0) printf("ROUND %d:\n", zi);
for(i=0; i<world_size; i++){
if(world_rank == i){
int j;
for(j=0; j < (m+2) * (n+2); j++){
if(j%(n+2) == 0) printf("\n");
printf("%4d ", current_generation_grid[j]);
}
printf("\n\n");
}
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);MPI_Barrier(grid_comm);
}
memcpy(current_generation_grid, next_generation_grid, (m+2) * (n+2) * sizeof(int));
}