Beispiel #1
0
real
claussen( real x )
{
  static int nclpi6 = 0, nclpi2 = 0, ncl5pi6 = 0;
  /*
   * right half (Pi <= x < 2 Pi)
   */
  int rh = 0;
  real f;

  if( !nclpi6 ){
    nclpi6 = inits( clpi6, sizeof clpi6 / sizeof *clpi6, mach[2] / 10 );
    nclpi2 = inits( clpi2, sizeof clpi2 / sizeof *clpi2, mach[2] / 10 );
    ncl5pi6 = inits( cl5pi6, sizeof cl5pi6 / sizeof *cl5pi6, mach[2] / 10 );
  }

  /*
   * get to canonical interval
   */
  if( ( x = fmod( x, 2 * M_PI ) ) < 0 ){
    x += ( real )( 2 * M_PI );
  }
  if( x > ( real )M_PI ){
    rh = 1;
    x = ( real )( 2 * M_PI ) - x;
  }

  if( x == 0 ){
    f = x;
  }else if( x <= ( real )( M_PI / 3 ) ){
    f = csevl( x * ( real )( 6 / M_PI ) - 1, clpi6, nclpi6 ) * x
      - x * log( x );
  }else if( x <= ( real )( 2 * M_PI / 3 ) ){
    f = csevl( x * ( real )( 3 / M_PI ) - 1, clpi2, nclpi2 ) * x
      - x * log( x );
  }else{ /* x <= Pi */
    f = ( ( real )M_LN2 -
         csevl( 5 - x * ( real )( 6 / M_PI ), cl5pi6, ncl5pi6 ) ) *
           ( ( real )M_PI - x );
  }

  return rh ? -f : f;
}
Beispiel #2
0
int main() {
  inits(&empty, 1);
  inits(&mpMale, 3);
  inits(&mpFemale, 3);
  ls_init(&lsMale);
  ls_init(&lsFemale);

  int i;
  pthread_t _man[5];
  pthread_t _woman[6];

  for (i=0;i<5;i++) {
    pthread_create(&_man[i], 0, man, 0);
  }

  for (i=0;i<6;i++) {
    pthread_create(&_woman[i], 0, woman, 0);
  }
  pthread_exit(0);
  
  return 0;
}
Beispiel #3
0
int main(void)
{
	inits();
	sei();
    while(1)
    {
	    seven_seg(counter);   
		if (counter == 100)
		    counter = 0;
		if (counter == 255)
		    counter = 99;
    }
}
Beispiel #4
0
int main(void)
{
	/* Initialize module */
    inits();
    for(;;) {
		fm_horn_handler();
		fm_wipers_handler();
		fm_fans_handler();
		_delay_ms(16); // the longer the wait the slower the wiper will go
		asm("sleep");
	}
	return 0;
}
Beispiel #5
0
int main()
{
	int n;

	inits();
	while(1) {
		scanf("%d", &n);
		if (!n)
			break;
		printf("%d\n", grids[n]);
	}

	return 0;
}
Beispiel #6
0
int Caldist::init(Build_m &b_m,Build_s &b_s)
{
 int i,j;
 initm(b_m);
 inits(b_s);
 maxr=0.0;
 for(i=0;i<vdw_n;i++)
 if(maxr<vdw_r[i])
	maxr=vdw_r[i];
 goodn=new int[b_s.resnum];
 good=new int*[b_s.resnum];
 for(i=0;i<b_s.resnum;i++)
	good[i]=new int[b_s.rtmn[i]];
 
}
void iterativetraverse(tree t){
	node *temp;
	stack st;
	inits(&st);
	temp = t;
	if(!temp)
		return;
	while(1){
		for(; temp; temp = temp->left)
			push(&st, temp);
		temp = pop(&st);
		if(!temp)
			break;
		printf("%d\t",temp->n);
		temp = temp->right;
	}
}
Beispiel #8
0
int main(void)
{
//	char i;
// Serielle initialisieren  
	inits();
	init_ser();
// CR und LF auf das Terminal ausgeben
	putc (0xd);
	putc (0xa);
// ein Zeichen von der seriellen abholen	
//	i=getc();
	putc('a');
// String ausgeben
	puts("Hallo! \n");
	
//	intOutput(0x80000);	
	intOutput(0x80000000); // diese zahl max mit 20 stellen (- zeichen zählt als stelle), falls mehr benötigt, muss im quellcode die größe von "carray" entsprechend geändert werden
	
	return 0;
}
Beispiel #9
0
/* Main ----------------------------------------------------------------------*/
int main(void){

	inits( );

	//while(1){;;}
	while(1){

	 // Runs in 1000Hz.
		if(runRegulator){
			runRegulator = false;
			regulator( );			
		}
		
	 // Reset if line is lost.
 /*		if(stopTimer >= 3000){
			stopTimer = 0;
			isFindingLine = false;
			runState = false;
			drive_total_stop( );
		}*/	

	 // Runs when all ADC are read, to calculate speed.
		if(adcDMA){
			adcDMA = false;
			spokesCounter( );
		}

	 // Runs when data has been received.
		if(handleUsart){
			handleUsart = false;
			usartHandler( );
		}

	 // Runs when data has been requested.	
		if(usartRequested){
			usartRequested = false;
			sendUART( );
		}
	}
}
Beispiel #10
0
// build a single element for the OffsetInfo[] of ClassInfo
static LLConstant* build_offti_entry(ClassDeclaration* cd, VarDeclaration* vd)
{
    std::vector<LLConstant*> inits(2);

    // size_t offset;
    //
    assert(vd->ir.irField);
    // grab the offset from llvm and the formal class type
    size_t offset = gDataLayout->getStructLayout(isaStruct(cd->type->ir.type->get()))->getElementOffset(vd->ir.irField->index);
    // offset nested struct/union fields
    offset += vd->ir.irField->unionOffset;

    // assert that it matches DMD
    Logger::println("offsets: %lu vs %u", offset, vd->offset);
    assert(offset == vd->offset);

    inits[0] = DtoConstSize_t(offset);

    // TypeInfo ti;
    inits[1] = DtoTypeInfoOf(vd->type, true);

    // done
    return llvm::ConstantStruct::get(inits);
}
Beispiel #11
0
CMAParams::CMAParams(eoParser& parser, unsigned dimensionality) {

    string section = "CMA parameters";

    n = parser.createParam(dimensionality, "dimensionality", "Dimensionality (N) of the problem", 'N', section, dimensionality == 0).value();

    maxgen = parser.createParam(
            1000,
            "max-gen",
            "Maximum number of generations that the system will run (needed for damping)",
            'M',
            section).value();


    if (n == 0) {
        return;
    }

    defaults(n, maxgen);

    /* handle lambda */
    lambda = parser.createParam(
            lambda,
            "lambda",
            "Number of offspring",
            'l',
            section).value();

    if (lambda < 2) {
        lambda = 4+(int)(3*log((double) n));
        cerr << "Too small lambda specified, setting it to " << lambda << endl;
    }

    /* handle mu */
    mu = parser.createParam(
            mu,
            "mu",
            "Population size",
            'm',
            section).value();

    if (mu >= lambda) {
        mu = lambda/2;
        cerr << "Mu set larger/equal to lambda, setting it to " << mu << endl;
    }

    /* handle selection weights */

    int weight_type = parser.createParam(
            0,
            "weighting",
            "Weighting scheme (for 'selection'): 0 = logarithmic, 1 = equal, 2 = linear",
            'w',
            section).value();

    switch (weight_type) {
        case 1:
            {
                for (unsigned i = 0; i < weights.size(); ++i) {
                    weights[i] = mu - i;
                }
            }
        case 2:
            {
                weights = 1.;
            }
        default :
            {
                for (unsigned i = 0; i < weights.size(); ++i) {
                    weights[i] = log(mu+1.)-log(i+1.);
                }
            }

    }

    /* Normalize weights and set mu_eff */
    double sumw = weights.sum();
    mueff =  sumw * sumw / (weights * weights).sum();
    weights /= sumw;


    /* most of the rest depends on mu_eff, so needs to be set again */

    /* set the others using Nikolaus logic. If you want to tweak, you can parameterize over these defaults */
    mucov = mueff;
    ccumsig = (mueff + 2.) / (n + mueff + 3.);
    ccumcov = 4. / (n + 4);

    double t1 = 2. / ((n+1.4142)*(n+1.4142));
    double t2 = (2.*mucov-1.) / ((n+2.)*(n+2.)+mucov);
    t2 = (t2 > 1) ? 1 : t2;
    t2 = (1./mucov) * t1 + (1.-1./mucov) * t2;

    ccov = t2;

    damp = 1 + std::max(0.3,(1.-(double)n/(double)maxgen))
              * (1+2*std::max(0.,sqrt((mueff-1.)/(n+1.))-1)) /* limit sigma increase */
                    / ccumsig;

    vector<double> mins(1,0.0);
    mins = parser.createParam(
            mins,
            "min-stdev",
            "Array of minimum stdevs, last one will apply for all remaining axes",
            0,
            section).value();

    if (mins.size() > n) mins.resize(n);

    if (mins.size()) {
        minStdevs = mins.back();
        for (unsigned i = 0; i < mins.size(); ++i) {
            minStdevs[i] = mins[i];
        }
    }

    vector<double> inits(1,0.3);
    inits = parser.createParam(
            inits,
            "init-stdev",
            "Array of initial stdevs, last one will apply for all remaining axes",
            0,
            section).value();

    if (inits.size() > n) inits.resize(n);

    if (inits.size()) {
        initialStdevs = inits.back();
        for (unsigned i = 0; i < inits.size(); ++i) {
            initialStdevs[i] = inits[i];
        }
    }

}
Beispiel #12
0
int main(int argc, char *argv[])
{
    char  c;
    FILE  *inputf;
    int   skiptoend, opencount, closecount, i, usech;
    long  *loopstarts, *loopsts = calloc(LOOP_DEPTH, sizeof(long));
    STACK_TYPE *stack, *stackstart = calloc(MAX, sizeof(STACK_TYPE));
    
    if (argc == 2) {
        i = 1;
    } else if (argc == 3 && !strcmp(argv[1], "-c")) {
        usech = 1;
        i = 2;
    } else if (argc == 3 && !strcmp(argv[1], "-n")) {
        usech = 0;
        i = 2;
    } else {
        fprintf(stderr, "Invalid command\nThe valid command format is ./brainfuck [-c | -n] <filename>\n");
        exit(1);
    }
    inputf = fopen(argv[i], "r");
    if (!inputf) {
        fprintf(stderr, "Cannot open file %s\n", argv[i]);
        exit(1);
    }
    
    // give error if no memory
    if (!stackstart || !loopsts) {
        fprintf(stderr, "Memory allocation error\n");
        exit(1);
    }
    
    inits(stackstart);
    initl(loopsts);
    stack      = stackstart;
    loopstarts = loopsts;
    skiptoend  = opencount = closecount = 0;
    
    // go through each character
    while ((c = fgetc(inputf)) != EOF) {
        
        // skip to first ] that isn't enclosed by an [
        if (skiptoend) {
            if (c == '[')
                opencount++;
            if (c == ']')
                closecount++;
            if (c != ']' || (opencount - closecount))
                continue;
        }
        
        switch (c) {
        case '+':
            ++*stack;
            break;
        case '-':
            --*stack;
            break;
        case '>':
            if (stack < stackstart + MAX - 1) // keep stack position within range
                ++stack;
            break;
        case '<':
            if (stack > stackstart) // keep stack position within range
                --stack;
            break;
        case ',':
            if (usech)
                *stack = getchar();
            else
                scanf("%lld", stack);
            break;
        case '.':
            if (usech)
                putchar((char) *stack);
            else
                printf("%lld\n", (unsigned long long) *stack); 
            break;
        case '[':
            if (!*stack) {
                skiptoend = opencount = 1;
                closecount = 0;
            } else if (!inloop(CURRENTPOS - 1)) { // check if I've already come here
                ++loopstarts; // inc(loopstart, 0);
                *loopstarts = CURRENTPOS - 1; // loopstart is located at the [
            }
            break;
        case ']':
            if (!skiptoend) { // if the loop is continuing
                jumpto(*loopstarts); // go back to the [
            } else {
                *loopstarts = 0;
                --loopstarts; // continue after the ]
                skiptoend = opencount = closecount = 0;
            }
            break;
        }
    }
    
    if (usech)
        putchar('\n');

    fclose(inputf);
    free(loopsts);
    free(stackstart);
    // free(stack);
    
}
Beispiel #13
0
int main(int argc ,char *argv[])
{
	inits();
	close(sock_fd);
	return 0;
}
Beispiel #14
0
int main(int argc,char *argv[])
{
 	// decode arguments
	args(argc,argv);
   inits();
   if(run_type==6)
      to_year=2010;

    // Read in Data // 
    cout<< "Reading Data\n";
    read_data();

    // Set initial Params //
    cout<< "Initiallizing...\n";
    init_state();
    init_t(); 
    calc_state();

   if(fixed_d != 0) //run traf_mat once and only once (for faster prototyping)
   {
      calc_traf();
       /* _vbc_vec<float> Uj(1,n_lakes);
        for(int j=1;j<=n_lakes;j++)
        {
            Uj(j) = 0;
            for(int i=1;i<=n_sources;i++)
            {
                Uj(j) += sources(i).Gij(j) * sources(i).Oi;
            }
            cout << Uj(j) << "\t" <<  1-exp(- pow(0.001 * Uj(j), 1 ) ) << "\n";
        }

      */
      calc_traf_mat();
      calc_pp();
   }

   ofstream ll_("output/ll_test.dat");
   if(FALSE)
   {
      calc_traf();
      calc_traf_mat();
      calc_pp(); //!!
      int tmp_t;
       for(int lake=1;lake<=n_lakes;lake++)
       {
           if(lakes(lake).invaded == 0 && lakes(lake).last_abs == 0 )
           {
               for(int t=from_year;t<=to_year+2;t++)
               {
                   // sample_t();
                   tmp_t=t_vec(lake);
                   t_vec(lake)=t;
                   calc_state();
                   calc_pp();
                   cout << lake << "\t" << t <<endl;
                   ll_ << lake << "\t" << t <<"\t"<<l_hood()<<endl;
               }
               t_vec(lake)=tmp_t;
           }
       }
   }

   if(FALSE) // likelihood profile of d and e //if init_t is random, MLE d=e=0 (no effect of distance or size: CHECK)
   {
       d_par=-1;
       e_par=0;
       for(int i=0;i<=60;i++)
       {
           d_par=d_par+0.1;
           e_par=0;
           for(int j=0;j<=10;j++)
           {
           e_par=e_par + 0.1;
           calc_traf();
           calc_traf_mat();
           calc_pp();
           ll_ << d_par << "\t" << e_par << "\t" << l_hood()<< endl;
           cout <<  d_par <<"\t"<< e_par << "\t" << l_hood()<< endl;
           }
       }
   }
   if(FALSE) //likelihood profile of alpha
   { 
      chem_pars(1)=0;
       for(int i=0;i<=1000;i++)
       {
           chem_pars(1)+=0.0001;
           ll_ << chem_pars(1) << "\t" << l_hood()<< endl;
       }
   }

   //Just sim under the true alpha to see the t_vec distribution
   // to compare with sim_dat.R
   if(FALSE)
   {
       for(int lake_index=1;lake_index<=n_lakes;lake_index++)
       {
           lakes(lake_index).discovered=0;
           lakes(lake_index).last_abs=0;
       }
       for(int i=1;i<=1000;i++)
       {
           sim_spread();
           write_t();
       }
   }



   /// SEEDS ///
//i       d        e           c     B_o       NAUT        KKUT      MGUT
//8394 1.06513 0.531416 0.000125572 -13.713 0.00405104 -0.00475339 0.0038181
//      CAUT     PPUT1  SIO3UR      DOC       COLTR     ALKTI         ALKT
//0.00403173 0.0571088 1.28896 -0.31447 -0.00654376 0.0621327 -0.000480646
//        PH     COND25 SECCHI.DEPTH       NA
//0.00852002 0.00335544    0.0995729 -380.192

//0.407766	1.44137	0.417034	-10.8476	0.708086 -0.0150081	-0.404532	-0.512538	0.689779	0.43177-0.584563	-0.224491	0.786624	1.0269	0.868935	-0.0982729	0.37267

   chem_pars(1)=-10;
   chem_pars(2)=0.7;
   chem_pars(3)=-0.01; //-2:1 MLE ~0
   chem_pars(4)=-0.38; //-1.5:1.5 MLE ~0
   chem_pars(5)=-0.5; //-0.4:0.2 MLE ~0
   chem_pars(6)=0.68; //0:0.1 MLE 0.05    ***
   chem_pars(7)=0.43; //-0.4:0.2 MLE ~1.3  **** 
   chem_pars(8)=-0.58; //-0.7:0.1 MLE ~-0.31 ****
   chem_pars(9)=-0.22; //-0.4:0.2 MLE ~-0.01 **
   chem_pars(10)=0.78; //-0.1:0.1 MLE ~0.06 *
   chem_pars(11)=1.02; //-0.16:0.1 MLE ~0
   chem_pars(12)=0.85; //-0.2:0.2 MLE ~0
   chem_pars(13)=-0.09; //-0.04:0.01 MLE ~0
   chem_pars(14)=0.37; //-0.3:0.3 MLE ~0.1

   int test_ch=14;
   d_par=1.54;
   //float bb = l_hood();

   if(ll)
   {
       float tmplhood;
       for(int i=1;i<=20;i++)
       {
          cerr << i << "\n";
           //chem_pars(test_ch)=chem_pars(test_ch)+0.0013;
           d_par=d_par+0.05;
           calc_traf();
          cerr << "A" << "\n";
           calc_traf_mat();
          cerr << "B" << "\n";

           sim_spread();
          cerr << "C" << "\n";
           //write_t();
           tmplhood = l_hood();
          cerr << "D" << "\n";
           ll_ << chem_pars(test_ch) << "\t" << tmplhood << "\n";
           cout << d_par << "\t" << tmplhood << "\n";

       }
   }

   ll_.close();

cout << "# sampled\t" << n_sampled << "\n";

if(run_type==1)
{
   // FIT ON TRAF_PARS & SPREAD PARS ONLY (NO ENV) //
   // need a likelihood function wrapper to call l_hood() multiple times and average the result
   // to smooth out stochastic surface.
   // BOOTSTRAP RESAMPLING OF DATA (SAMPLED LAKES) TO GENERATE CI //

   float garbage=l_hood();
   int n_reps = 1000;
   ofstream par_file;

   int n_pars; //13 env + intercept + d,c,gamma
   _vbc_vec<float> params1;
   _vbc_vec<float> dat1;
   _vbc_vec<float> MLE_params;
   if(!env)
   {
      if(sim)
        par_file.open("sims/gb_output/pred_pars.tab");
      else
        par_file.open("output/pred_pars.tab");    
      n_pars=4;  // d,c,gamma,alpha
      params1.redim(1,n_pars);
      dat1.redim(1,n_pars);
      MLE_params.redim(1,n_pars);
      params1(1)=1.27;
      params1(2)=1.48;
      params1(3)=0.0000489;
      params1(4)=0.00105;  
   }else{
      if(sim)        
          par_file.open("sims/gb_output/pred_parsENV.tab");
      else
          par_file.open("output/pred_parsENV.tab");
      n_pars=18; //13 env + intercept + d,e,c,gamma
      params1.redim(1,n_pars);
      dat1.redim(1,n_pars);
      MLE_params.redim(1,n_pars);
      params1(1)=1.79;
      params1(2)=2;
      params1(3)=0.69;
      params1(4)=0.0000489;   

      /// SEEDS ///
      params1(5)=-6.2;
      params1(6)=0.014;
      params1(7)=-0.08; //-2:1 MLE ~0
      params1(8)=0.15; //-1.5:1.5 MLE ~0
      params1(9)=0.21; //-0.4:0.2 MLE ~0
      params1(10)=0.03; //0:0.1 MLE 0.05    ***
      params1(11)=-0.13; //-0.4:0.2 MLE ~1.3  **** 
      params1(12)=-0.43; //-0.7:0.1 MLE ~-0.31 ****
      params1(13)=-0.007; //-0.4:0.2 MLE ~-0.01 **
      params1(14)=0.056; //-0.1:0.1 MLE ~0.06 *
      params1(15)=0.0087; //-0.16:0.1 MLE ~0
      params1(16)=0.081; //-0.2:0.2 MLE ~0
      params1(17)=-0.015; //-0.04:0.01 MLE ~0
      params1(18)=0.013; //-0.3:0.3 MLE ~0.1
   }

   _vbc_vec<int> tmp_index_sampled;
   tmp_index_sampled = sampled_index;


   if(boot)
   {
      ofstream boot_file;
      if(sim)
          boot_file.open("sims/gb_output/boot_lakes.tab");
      else
          boot_file.open("output/boot_lakes.tab");    
      for(int i=1;i<=n_reps;i++)
      {
         //Bootstrap resample //
         sampled_index = sample_w_replace(tmp_index_sampled);
         for(int j=1;j<=n_sampled;j++)
            boot_file << sampled_index(j) << "\t";
         boot_file << "\n";
         boot_file.flush();
         // --- //

         simplex::clsSimplex<float> gertzen_rep;
         //gertzen_rep.set_param_small(1e-3);
         gertzen_rep.start(&dat1,&params1, &MLE_l_hood,n_pars, 1e-2);
         gertzen_rep.getParams(&MLE_params);

         cout << "\n\nMLE "<< i << " of " << n_reps << "\n\n";
         for(int p=1;p<=n_pars;p++)
            par_file << MLE_params(p) <<"\t";
         par_file << "\n";
         par_file.flush();
      }
      boot_file.close();
   }else{
      simplex::clsSimplex<float> gertzen_rep;
      //gertzen_rep.set_param_small(1e-3);
      gertzen_rep.start(&dat1,&params1, &MLE_l_hood,n_pars, 1e-2);
      gertzen_rep.getParams(&MLE_params);

      cout << "\n\nMLE\n";
      for(int p=1;p<=n_pars;p++)
         par_file << MLE_params(p) <<"\t";
      par_file << "\n";
      par_file.flush();

      // Print out distribution of alpha values at MLE
      ofstream alphas_file;
      alphas_file.open("output/alphas.tab",std::fstream::app);
      for(int i=1;i<=n_lakes;i++)
      {
        alphas_file << calc_alpha(i) << "\n";
      }
      alphas_file.close();
   }
   par_file.close();

}



if(run_type==2)
{
   //MCMC lib
	string mcmc_file("output/lib.mcmc");
   if(env)
   {
      _vbc_vec<float> params(1,4+n_chem_var);
      _vbc_vec<float> prop_width(1,4+n_chem_var,1,4+n_chem_var);
      prop_width(1)=0.05;
      prop_width(2)=0.05;
      prop_width(3)=0.05;

      params(1)=0.4;
      params(2)=1.4;
      params(3)=0.42;   
      for(int i=1;i<=n_chem_var+1;i++)
      {
         prop_width(i+3)=0.0001;
         params(i+3)=chem_pars(i);
      }
      prop_width(4)=0.1;

      _vbc_vec<float> prop_sigma;
      prop_sigma = diag(prop_width);

      // Print out prop_sigma
      for(int i=1;i<=n_chem_var+4;i++)
      {
         for(int j=1;j<=n_chem_var+4;j++)   
            cout << prop_sigma(i,j) << " | ";
         cout << "\n";
      }
     
      mcmcMD::run_mcmc(params, 
         prop_sigma, 
         &likelihood_wrapperMCMC_MD,
         &prior_MD, 
         &restrict_MCMC_MD, 
         50000, 
         50, 
         1, 
         mcmc_file.c_str(),
         true,
         true,
         true,
         500,
         4);
   }else
   {
   /// No env.
      _vbc_vec<float> params(1,4);
      _vbc_vec<float> prop_width(1,4,1,4);
      prop_width(1)=0.05;
      prop_width(2)=0.05;
      prop_width(3)=0.000001;
      prop_width(4)=0.00001;


      params(1)=1.27;
      params(2)=1.48;
      params(3)=0.0000489;
      params(4)=0.00105;      

      _vbc_vec<float> prop_sigma;
      prop_sigma = diag(prop_width);

      // Print out prop_sigma
      for(int i=1;i<=4;i++)
      {
         for(int j=1;j<=4;j++)   
            cout << prop_sigma(i,j) << " | ";
         cout << "\n";
      }
     
      mcmcMD::run_mcmc(params, 
         prop_sigma, 
         &likelihood_wrapperMCMC_MD,
         &prior_MD, 
         &restrict_MCMC_MD, 
         500000, 
         1, 
         1, 
         mcmc_file.c_str(),
         true,
         true,
         true,
         500,
         5);
   }


/*	mcmcMD::run_mcmc(pms, 
      props, 
      &like, 
      &prior, 
      &restrictions, 
      500000, 
      1, 
      100, 
      file_name.c_str(),
      TRUE,
      TRUE,
      1000);
*/
}


/// Sim from posterior ///
if(run_type==3)
   sim_spread_posterior();

/// Traf tests ////
if(run_type==4)
{
   ofstream traf_ll_file("output/traf_ll.dat");

   d_par=1.54;
   e_par=2;
   c_par=0.8;
   calc_traf();
   calc_traf_mat();
   calc_pp();
   sim_spread();
   cout << l_hood() <<"\n";
   
    /*
    for(int i=1;i<=70;i++)
    {
        e_par=e_par+0.05;
        cout << e_par << "\t";
        calc_traf();
        calc_traf_mat();
        calc_pp();
        sim_spread();
        traf_ll_file << e_par  << "\t" << l_hood()  << "\n"; 
        cout << l_hood() <<"\t";
        sim_spread();
        traf_ll_file << e_par  << "\t" << l_hood()  << "\n"; 
        cout << l_hood() <<"\t";
        sim_spread();
        traf_ll_file << e_par  << "\t" << l_hood()  << "\n"; 
        cout << l_hood() <<"\n";
        traf_ll_file << e_par  << "\t" << l_hood()  << "\n"; 
    }


   for(int i=1;i<=10;i++)
   {
      e_par=e_par+0.2;
      c_par=0.8;
         calc_traf();
         calc_traf_mat();
         calc_pp();
      for(int j = 1;j<=10;j++)
      {
         c_par=c_par+0.2;
         glb_alpha=0; //from MLE
         for(int k=1;k<=500;k++)
         {
            glb_alpha=glb_alpha+0.00001;
            sim_spread();
            sim_spread();
            sim_spread();
            cout << e_par << "\t" << c_par << "\t" << glb_alpha << "\t" << l_hood()  << "\n"; 
            traf_ll_file << e_par << "\t" << c_par << "\t" << glb_alpha << "\t" << l_hood()  << "\n"; 
         }
      }
   } 
    */
   traf_ll_file.close();
   calc_pp();
   write_pp(); 
   write_inv_stat();
}

/// Holdout sets for internal AUC ////
if(run_type==5)
{  
   int n_pars=4;
   _vbc_vec<float>params1(1,n_pars); 

   // Read parameters values from file //
   ifstream pred_pars;
   if(sim)
       pred_pars.open("sims/gb_output/pred_pars.tab");
   else
       pred_pars.open("output/pred_pars.tab");
   for(int j=1;j<=n_pars;j++)
      pred_pars >> params1(j);

   pred_pars.close();
   // -- //

   d_par=params1(1);
   e_par = 1;
   c_par=params1(2);
   gamma_par=params1(3);
   glb_alpha=params1(4);

   calc_traf();
   calc_traf_mat();
   //write_traf_mat();

   //Sub-sample a holdout set from sampled lakes (pre-2010)
   int n_sub_sampled = 100,choose_from=0;
   _vbc_vec<int> index_2006_big(1,n_lakes);
   for(int i = 1; i<=n_lakes;i++)
   {
      if( (lakes(i).last_abs==2006 || lakes(i).discovered == 2006) )
      {
         choose_from += 1;
         index_2006_big(choose_from)=i;
      }
   }
   _vbc_vec<int> index_2006(1,choose_from);
   for(int i = 1; i<=choose_from;i++)
      index_2006(i)=index_2006_big(i);

   
   ofstream prop_holdout_file;
   prop_holdout_file.open("output/holdout_sim_props.csv");
   ofstream holdout_inv_file("output/holdout2006_data_status.csv");

   _vbc_vec<int> holdout_inv_status(1,n_sub_sampled);
   _vbc_vec<int> indicies_holdout(1,n_sub_sampled);
   _vbc_vec<int> tmp_discovered(1,n_sub_sampled);
   _vbc_vec<int> tmp_last_abs(1,n_sub_sampled);

   cout << "Total 2006 lakes to choose from " << choose_from << "\n";
   for(int rep=1;rep<=50;rep++)
   {
      indicies_holdout = sample_wo_replace(index_2006,n_sub_sampled);

      //Record the year_discovered of holdoutset
      for(int i = 1; i<=n_sub_sampled;i++)
      {
         if(lakes(indicies_holdout(i)).discovered == 2006)
            holdout_inv_status(i) = 1;
         else
            holdout_inv_status(i) = 0;

         //write year discovered 
         if(i == n_sub_sampled)
            holdout_inv_file << holdout_inv_status(i) << "\n";
         else
            holdout_inv_file << holdout_inv_status(i) << ",";


         //save last_abs and discoved
         tmp_discovered(i) = lakes(indicies_holdout(i)).discovered;
         tmp_last_abs(i) = lakes(indicies_holdout(i)).last_abs;

         //remove year discovered
         lakes(indicies_holdout(i)).discovered = 0;
         lakes(indicies_holdout(i)).last_abs = 0;
      }   
      
      //SIM SPREAD
      _vbc_vec<float> prop_holdout_invaded(1,n_sub_sampled);
      for(int i=1;i<=n_sub_sampled;i++)
         prop_holdout_invaded(i) = 0;
      int n_sims=1000;
      for(int s=1; s<= n_sims; s++)
      {
         sim_spread();
         for(int i=1;i<=n_sub_sampled;i++)
         {
            if(t_vec(indicies_holdout(i)) <= 2006)
               prop_holdout_invaded(i) += 1;
         }
      }
      //write prop inv
      for(int i=1;i<=n_sub_sampled;i++)
      {
         prop_holdout_invaded(i) = prop_holdout_invaded(i)/n_sims;
         if(i < n_sub_sampled)
            prop_holdout_file << prop_holdout_invaded(i) << ",";
         else
            prop_holdout_file << prop_holdout_invaded(i) << "\n";

         //reset last_abs and discoved
         lakes(indicies_holdout(i)).discovered = tmp_discovered(i);
         lakes(indicies_holdout(i)).last_abs = tmp_last_abs(i);
      }
   }
   holdout_inv_file.close();
   prop_holdout_file.close();
}
Beispiel #15
0
int main()
{
    inits();
    Shader text_shader("text.vs", "text.frag");
    Shader ourShader("coordinate_systems.vs", "coordinate_systems.frag");
    Shader bar_shader("bar.vs", "bar.frag");
    inittext(text_shader);
    initbar(bar_shader);
    
    // Set up our vertex data (and buffer(s)) and attribute pointers
    msg(sizeof(vertices_indexed));
    msg(sizeof(indices));
    msg(sizeof(vertices));

#ifdef use_indexed
    makeglgeom_indexed(VBO_indexed, VAO_indexed, EBO_indexed, vertices_indexed, indices, sizeof(vertices_indexed), sizeof(indices));
#else
    makeglgeom(VBO, VAO, vertices, sizeof(vertices));
#endif
    // Load and create a texture 

    makegltext(texture1, "resources/textures/container.jpg");
    makegltext(texture2, "resources/textures/awesomeface.png");
        GLint modelLoc = glGetUniformLocation(ourShader.Program, "model");
        GLint viewLoc = glGetUniformLocation(ourShader.Program, "view");
        GLint projLoc = glGetUniformLocation(ourShader.Program, "projection");
    // Game loop
    while (!glfwWindowShouldClose(window))
    {
        // Set frame time
        GLfloat currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

#ifdef RAWMOUSE
        acc += updatemouse();
#endif
        //vec2 diff = mouse - acc;
        //log
        //mousepos += acc;
        lag = lag_coeff*acc;
        //lag = lag_coeff*vec2(log(abs(acc.x)), log(abs(acc.y)));
        //if (acc.x < 0)lag.x *= -1.0f;
        //if (acc.y < 0)lag.y *= -1.0f;

        if (abs(lag.x) < 1e-4) lag.x = 0;
        if (abs(lag.y) < 1e-4) lag.y = 0;
        acc -= lag;
        camera.ProcessMouseMovement(lag.x, lag.y);
        show2(mouse);
        show2(lag);
        show2(acc);
        //show2(string(int(0.1f*length(acc)), '='));
        //show2(string(int(10.f*length(lag)), '='));

        // Check and call events #######################################
        glfwPollEvents();
        Do_Movement();

        // Clear the colorbuffer
        glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        // texts #######################
        int line = 0;
        for (auto&a : texts)
        {
            RenderText(text_shader, a.first + " " + a.second,
                25.0f, (line + 1)*25.0f, 0.3f, glm::vec3(1, 1, 1));
            ++line;
        }
        //RenderText(text_shader, "(C) LearnOpenGL.com", 540.0f, 570.0f, 0.5f, glm::vec3(0.3, 0.7f, 0.9f));
        drawbar(bar_shader);

        // Draw our first triangle #######################
        ourShader.Use();

        // Bind Textures using texture units #######################
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texture1);
        glUniform1i(glGetUniformLocation(ourShader.Program, "ourTexture1"), 0);
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, texture2);
        glUniform1i(glGetUniformLocation(ourShader.Program, "ourTexture2"), 1);

        // Create camera transformation #######################
        glm::mat4 view;
        view = camera.GetViewMatrix();
        glm::mat4 projection;
        projection = glm::perspective(glm::radians(camera.Zoom), (float)screenWidth / (float)screenHeight, 0.1f, 1000.0f);
        // Get the uniform locations
        // Pass the matrices to the shader
        glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
#ifdef use_indexed
        glBindVertexArray(VAO_indexed);

#else
        glBindVertexArray(VAO);
#endif
        for (GLuint i = 0; i < 10; i++)
        {
            // Calculate the model matrix for each object and pass it to shader before drawing
            glm::mat4 model;
            model = glm::translate(model, cubePositions[i]);
            GLfloat angle = 20.0f * i;
            model = glm::rotate(model, angle, glm::vec3(1.0f, 0.3f, 0.5f));
            glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
#ifdef use_indexed
            glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0);
#else
            glDrawArrays(GL_TRIANGLES, 0, 36);
#endif
        }
        glBindVertexArray(0);

        // Swap the buffers
        glfwSwapBuffers(window);
    }
    // Properly de-allocate all resources once they've outlived their purpose
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glfwTerminate();
    ManyMouse_Quit();
    return 0;
}
Beispiel #16
0
Particle::Particle(char *l)
{
  parser(l);
  behavior();
  inits();
}
Beispiel #17
0
int main() {
    inits();
    solve(0, 0, 0, 0, 0, 0, 0, -1);
    return 0;
           }
Beispiel #18
0
int main(void)
{
    pump_stop();
    int test1 = 0;
    int test = 50;
    // Serielle initialisieren
    inits();
    init_ser();

    puts("Herzlich willkommen zur Ausschankstation. Bitte Folgen Sie den Anweisungen.\n");

    while(1){
    pump_stop();                            //falls die Pumpe noch läuft
    int fehlertoleranz = 7;
    int voll = 50;                            // Welche Menge soll abgefüllt werden
    puts("Bitte stellen Sie zur Kalibrierung den Becher auf und drücken Sie SW1 \n");
    init_messung();
    while(piobaseB->PIO_PDSR & KEY1){}                              //polling (KEY1)
    int becher = 0;
    becher = MasseMitGenauigkeit();                                 //Bechergewicht messen
    puts("Der Becher hat folgende Masse in Gramm: ");
    intOutput(becher);
    puts("\n");
    puts("Drücken Sie SW2 um den Becher zu befüllen. \n");

    while(piobaseB->PIO_PDSR & KEY2){}                              //polling (KEY2)
        if (MasseMitGenauigkeit() < becher+fehlertoleranz && MasseMitGenauigkeit() > becher -fehlertoleranz){
        // pump_init();
            pump_start();
            int alteMasse = becher;
            int neueMasse = becher;
            int testMasse = becher;
            int ausgabe = 1;
             while ((neueMasse - becher) < voll){         // Solange Masse minus Bechergewicht kleiner als die gewünschte Menge ist, Schleife ausführen
             test1++;
             if(test1%test==0){
             if(testMasse>=neueMasse){
                 pump_stop();
                puts("keine Gewichtszunahme !! \n");
                break;
                }
                 testMasse = neueMasse;
             }
             alteMasse = neueMasse;
             neueMasse = MasseMitGenauigkeit();
             if((neueMasse-becher) >= ausgabe){
             puts(" im Becher sind ");
             intOutput(neueMasse-becher);
             puts(" Gramm \n");
             ausgabe = neueMasse-becher+1;
             }
             if (neueMasse < 1 || (alteMasse+6) < neueMasse || (alteMasse-6) > neueMasse){        // Falls Becher weg genommen wird oder Gewichtsveränderung zu groß ist
             pump_stop();
             puts("Fehler: Gewichtsveränderung zu groß \n");
             break;
             }
            }
            pump_stop();
            puts("Vorgang abgeschlossen \n\n");
        } else{
            pump_stop();
            puts("Fehler: Gewichtsveränderung an Becher zu groß \n");
        }
    }
    return 0;
}
Beispiel #19
0
int main()
{

	inits();

	DHT22 * dhtS = new DHT22(18, "Sisämittari(DIG)");
	DHT22 * dht2S = new DHT22(17, "Ulkomittari(DIG)");
	BMP180 * bmp = new BMP180(0x77, "Painemittari(DIG)");

	char *code = NULL;

	short prog = 1;

	clock_t timer1 = clock();
	clock_t timer2 = clock();

	for(tempSensIT it = tempSensors.begin(); it != tempSensors.end(); ++it) {
		it->second->update();
	}

	//while(lirc_nextcode(&code) != 0) {
	while(1) {

		if(float(clock())/CLOCKS_PER_SEC - float(timer1)/CLOCKS_PER_SEC >= 0.012) {

			// Turn on DHT22's
			digitalWrite(20, HIGH);
			usleep(1000);

			for(tempSensIT it = tempSensors.begin(); it != tempSensors.end(); ++it) {
				it->second->update();
			}

			digitalWrite(20, LOW);

			timer1 = clock();

		}

		if(float(clock())/CLOCKS_PER_SEC - float(timer2)/CLOCKS_PER_SEC >= 0.25) {
			#ifdef HCDEBUG
				logfile << "MySQL connection: " << (mysql_ping(sqlcon) == 0 ? "Up" : "Down") << endl;
			#endif
			for(tempSensIT it = tempSensors.begin(); it != tempSensors.end(); ++it) {
				it->second->saveCurTemp();
			}
			for(humSensIT it = humSens.begin(); it != humSens.end(); ++it) {
				it->second->saveCurHumi();
			}
			for(pressSensIT it = pressSens.begin(); it != pressSens.end(); ++it) {
				it->second->saveCurPress();
			}
			timer2 = clock();
		}

		switch(prog) {
			case 0:
			{
				lcdClear(lcdHandle);
				break;
			}
			case 1:
			{
				lcdPrint1("Temperatures("+string(1, (unsigned char)(int)223)+"C)");

				stringstream ss;
				for(tempSensIT it = tempSensors.begin(); it != tempSensors.end(); ++it) {
					ss << (int)it->second->getTemp() << " ";
				}
				lcdPrint2(ss.str());
				break;
			}
			case 2:
			{
				lcdPrint1("Humidities(%)");
				stringstream ss;
				for(humSensIT it = humSens.begin(); it != humSens.end(); ++it) {
					ss << (int)it->second->getHumi() << " ";
				}
				lcdPrint2(ss.str());
				break;
			}
			case 3:
			{
				lcdPrint1("Pressures(hPa)");
				stringstream ss;
				for(pressSensIT it = pressSens.begin(); it != pressSens.end(); ++it) {
					ss << (int)it->second->getPress() << " ";
				}
				lcdPrint2(ss.str());
				break;
			}
		}

		if(code != NULL) {
			if(parseKey(code) == "KEY_SUSPEND") {
				if(shutdown()) {
					break;
				}
			}
			if(parseKey(code) == "KEY_MODE") {
				calibrateAnalogTempSensors();
			}
			if(parseKey(code) == "KEY_0") {
				prog = 0;
			}
			if(parseKey(code) == "KEY_1") {
				prog = 1;
			}
			if(parseKey(code) == "KEY_2") {
				prog = 2;
			}
			free(code);
		}
	}

	delete diS;
	delete diS2;
	delete dhtS;
	delete dht2S;
	delete bmp;

	deinits();

	return EXIT_SUCCESS;
}
int getConst(double * constante, int * sh ){
   int flag=0,mas=0,menos=0,pto=0,num=0;
    char aux[50];
   int lenght=0;
    inits(aux,lenght); // inciando cadena 

  while(flag==0){



 gets(aux); //obteniendo cadena
 lenght= strlen(aux);

 int x=0;
 while(aux[x]!='\0'){
   
     
 
   if((aux[x]-'0'>=0 &&aux[x]-'0'<=9)||aux[x]=='-'||aux[x]=='.'||aux[x]=='+'){
     flag=1;
if(aux[x]=='.')
pto++;
if(aux[x]=='-')
menos++;
if(aux[x]=='+')
mas++;
if((aux[x]-'0'>=0 &&aux[x]-'0'<=9))
num++;
if((aux[x]=='-'||aux[x]=='+')&&(num>0))
menos=2;
if((aux[x]=='-'||aux[x]=='+')&&(pto>0))
menos=2;


}
else{
flag=0;
x= lenght-1;
}
     
     
   x++;
 }

 if(flag==1){

   *constante=atof(aux);
 if(pto>1||menos>1||mas>1)
printf("Eso no es un número pero pienso que puedo tratar con %f \n\n",*constante);
}

    else{
     printf("Es en serio?, intenta de nuevo... Ingrese el valor requerido:\n");
       *sh=1;
  }
  }
 

 return flag;

}
Beispiel #21
0
Thunder::Thunder(char *l)
{
  parser(l);
  behavior();
  inits();
}