Example #1
0
int main(int argc,const char **argv)
{
	if ( argc < 2 )
	{
		printf("Usage: blockchain (options) <dataDir>\n");
		printf("\n");
		printf("Options:\n");
		printf("\n");
		printf("-max_blocks <n> : Maximum number of blocks in the blockchain to analyze\n");
		printf("-statistics : Whether or not to perform full statistics processing of every single address\n");
		printf("-by_day : Accumulate breakdown of all bitcoin addresses by day\n");
		printf("-by_month : Accumulate breakdown of all bitcoin addresses by month\n");
		printf("-by_year : Accumulate breakdown of all bitcoin addresses by year\n");
		printf("-zombie_days <n> : Number of days to consider a bitcoin address as a zombie, default value is 3 years.\n");
		printf("-find_text <n> : Search for occurrences of ASCII text in the blockchain and output it to the log file. <n> is how many ASCII characters in a row to report text.\n");
	}
	else
	{
		uint32_t zombieDays = 365*3;
		uint32_t maxBlocks = 10000000;
		const char *dataPath = ".";
		int i = 1;
		StatResolution resolution = SR_YEAR;
		bool processTransactions = false;
		uint32_t searchText = 0;

		while ( i < argc )
		{
			const char *option = argv[i];
			if ( *option == '-' )
			{
				if ( strcmp(option,"-max_blocks") == 0 )
				{
					i++;
					if ( i < argc )
					{
						maxBlocks = atoi(argv[i]);
						if ( maxBlocks < 1 )
						{
							printf("Invalid max_blocks value '%s'\n", argv[i] );
							maxBlocks = 1000000;
						}
						else
						{
							printf("Maximum blocks set to %d\r\n", maxBlocks);
						}
					}
					else
					{
						printf("Error parsing option '-max_blocks', missing block number.\n");
					}
				}
				else if ( strcmp(option,"-statistics") == 0 )
				{
					processTransactions = true;
					printf("Enabling statistics processing\r\n");
				}
				else if ( strcmp(option,"-by_day") == 0 )
				{
					resolution = SR_DAY;
					processTransactions = true;
					printf("Gathering statistics by day\n");
				}
				else if ( strcmp(option,"-by_month") == 0 )
				{
					resolution = SR_MONTH;
					processTransactions = true;
					printf("Gathering statistics by month\n");
				}
				else if ( strcmp(option,"-by_year") == 0 )
				{
					resolution = SR_YEAR;
					processTransactions = true;
					printf("Gathering statistics by year\n");
				}
				else if ( strcmp(option,"-find_text") == 0 )
				{
					i++;
					if ( i < argc )
					{
						searchText = atoi(argv[i]);
						printf("Searching for ASCII text in the blockchain using a character limit of %d\n", searchText );
					}
					else
					{
						printf("Error parsing option '-find_text', missing character length.\n");
					}
				}
				else if ( strcmp(option,"-zombie_days") == 0 )
				{
					i++;
					if ( i < argc )
					{
						zombieDays = atoi(argv[i]);
						printf("Zombie Days set to %d\n", zombieDays );
					}
					else
					{
						printf("Error parsing option '-zombie_days', missing day count.\n");
					}
				}
				else
				{
					printf("Unknown option '%s'\n", option );
				}
			}
			else
			{
				if ( (i+1) == argc )
				{
					printf("Using directory: %s to locate bitcoin data blocks.\n", option );
					dataPath = option;
				}
				else
				{
					printf("%s not a valid option.\n", option );
				}
			}
			i++;
		}
		BlockChainCommand bc(dataPath,maxBlocks,processTransactions,resolution,searchText,zombieDays);
		bc.setMaxBlocks(maxBlocks);
		while ( bc.process() );
	}


	return 0;
}
Int_t BToDstPi0Analysis::FitMES(){

  //define cuts
  Float_t mesmin=BCPDGMass-.009;
  Float_t mesmax=BCPDGMass+.009;
    
  if(!OpenReducedNtuple())return 0;
  
  TH1F HmES("HmES","",40,5.20,5.30);
  ReducedNtuple->Draw("bmes>>HmES");


  TH1F HmESN("HmESN","",40,5.20,5.30);
  ReducedNtuple->Draw("bmes>>HmESN","bcharge==-1");
  
  TH1F HmESP("HmESP","",40,5.20,5.30);
  ReducedNtuple->Draw("bmes>>HmESP","bcharge==1");


  filename=_OutputDir+"/MES.ps";
  Canvas.Print(filename+"[");


  Canvas.Clear();  
  HmES.Draw("pe");
  Canvas.Print(filename);
  Canvas.Clear();  
  HmESN.Draw("pe");
  Canvas.Print(filename);
  Canvas.Clear();  
  HmESP.Draw("pe");
  Canvas.Print(filename);

  
  mass.setRange(HmES.GetXaxis()->GetXmin(),HmES.GetXaxis()->GetXmax());
  mass.setBins(HmES.GetXaxis()->GetNbins());

  RooRealVar bm0("bm0","bm0",5.29);
  RooRealVar bc("bc","bc",-100,-10);
  RooRealVar bp("bp","bp",.1,1);
  RooArgusBG Bkg("Bkg","ArgusP",mass,bm0,bc,bp);




  ///-------------------------------Fit The RS
  RooDataHist dataset("dataset","dataset",RooArgList(mass),&HmES,1);  
  RooDataHist datasetn("datasetn","datasetn",RooArgList(mass),&HmESN,1);  
  RooDataHist datasetp("datasetp","datasetp",RooArgList(mass),&HmESP,1);  


  //--------------------------------------------------------------------
  //Fit RS data with Argus function
  //--------------------------------------------------------------------
  Bkg.fitTo(dataset,"m");
  RooPlot*plot=mass.frame();
  dataset.plotOn(plot);
  Bkg.plotOn(plot);
  Canvas.Clear();  
  plot->Draw();
  Canvas.Print(filename);
  delete plot;


  
  //--------------------------------------------------------------------
  //Fit RS data Bkg + CBShape
  //--------------------------------------------------------------------
//   RooHistPdf HBkg("HBkg","HBP",RooArgSet(mass),HB,0);
//   RooRealVar Bsl0("Bsl0","Bsl0",HmES.GetXaxis()->GetXmin());
//   RooRealVar Bsl("Bsl","Bsl",-100,100);
//   RooGenericPdf BslP("BslP","BslP","1+Bsl*(mass-Bsl0)",RooArgList(Bsl0,Bsl,mass));
//   RooProdPdf BkgProd("BkgProd","BkgProd",BslP,HBkg);

  RooRealVar sm0("sm0","sm0",5.2794);
  RooRealVar sigma("sigma","sigma",.003);
  RooRealVar alpha("alpha","alpha",3.);
  RooRealVar n("n","n",1,10);//1);
  //RooCBShape CBP("CBP","CBP",mass,sm0,sigma,alpha,n);
  RooGaussian CBP("CBP","CBP",mass,sm0,sigma);
  RooRealVar SYield("SYield","SYield",.01,.9);

  RooAddPdf FitPdf("FitPdf","FitPdf",RooArgList(CBP,Bkg),RooArgList(SYield));

  mass.SetTitle("m_{ES}");
  mass.setUnit("GeV^{2}/c^{4}");

  ///Fit The Total
  FitPdf.fitTo(dataset,"m");
  plot=mass.frame();  
  dataset.plotOn(plot,MarkerColor(0),LineColor(0));
  FitPdf.plotOn(plot); 
  FitPdf.plotOn(plot,Components(Bkg),LineColor(kRed));
  Canvas.Clear();  
  plot->Draw();
  HmES.SetLineColor(1);HmES.SetStats(0);
  HmES.Draw("same");
  cutline.DrawLine(mesmin,0,mesmin,HmES.GetMaximum());
  cutline.DrawLine(mesmax,0,mesmax,HmES.GetMaximum());
  Canvas.Print(filename);
  delete plot;
//   //Calculate total signal yield
//   Int_t Syieldtot=(int)(SYield.getVal()*HmES.Integral());
//   Int_t Syieldtote=(int)(SYield.getError()*HmES.Integral());
//   Int_t Byieldtot=(int)((1-SYield.getVal())*HmES.Integral());
//   Int_t Byieldtote=(int)((SYield.getError())*HmES.Integral());
  //Calculate signal yield in cut   
  mass.setRange("sigregion",mesmin,mesmax);
  RooArgSet nset(mass);
  RooAbsReal* sintegral=CBP.createIntegral(nset,nset,"sigregion");
  Int_t syieldtot=(int)(HmES.Integral()*sintegral->getVal()*SYield.getVal());
  RooAbsReal* bintegral=Bkg.createIntegral(nset,nset,"sigregion");
  Int_t byieldtot=(int)(HmES.Integral()*bintegral->getVal()*(1-SYield.getVal()));

  cout<<"Yield Results in sig region  TotSig="<<syieldtot<<endl;
  cout<<"Yield Results in sig region  TotBkg="<<byieldtot<<endl;

  /*  
  ///Now fix the shape parameters
  sm0.setConstant(1);
  sigma.setConstant(1);
  alpha.setConstant(1);
  n.setConstant(1);
  

  
  ////Fit the B0
  FitPdf.fitTo(datasetn,"m");
  RooPlot*plotn=mass.frame();  
  datasetn.plotOn(plotn,MarkerColor(0),LineColor(0));
  //FitPdf.plotOn(plotn,LineStyle(1),LineColor(2)); 
  FitPdf.plotOn(plotn,Components(BkgProd),LineColor(kBlack));
  //Calculate total signal yield
  Int_t Syieldn=(int)(SYield.getVal()*HmESN.Integral());
  Int_t Syieldne=(int)(SYield.getError()*HmESN.Integral());
  Int_t Byieldn=(int)((1-SYield.getVal())*HmESN.Integral());
  Int_t Byieldne=(int)((SYield.getError())*HmESN.Integral());
  //Calculate signal yield in cut 
  Int_t syieldn=(int)(HmESN.Integral()*sintegral->getVal()*SYield.getVal());
  Int_t byieldn=(int)(HmESN.Integral()*bintegral->getVal()*(1-SYield.getVal()));
  


  ////Fit the B0bar
  FitPdf.fitTo(datasetp,"m");
  RooPlot*plotp=mass.frame();  
  datasetp.plotOn(plotp,MarkerColor(0),LineColor(0));
  //FitPdf.plotOn(plotp,LineStyle(1),LineColor(3)); 
  FitPdf.plotOn(plotp,Components(BkgProd),LineColor(kBlack));
  //Calculate total signal yield
  //Calculate total signal yield
  Int_t Syieldp=(int)(SYield.getVal()*HmESP.Integral());
  Int_t Syieldpe=(int)(SYield.getError()*HmESP.Integral());
  Int_t Byieldp=(int)((1-SYield.getVal())*HmESP.Integral());
  Int_t Byieldpe=(int)((SYield.getError())*HmESP.Integral());
  //Calculate signal yield in cut 
  Int_t syieldp=(int)(HmESP.Integral()*sintegral->getVal()*SYield.getVal());
  Int_t byieldp=(int)(HmESP.Integral()*bintegral->getVal()*(1-SYield.getVal()));


  Canvas.Clear();  
  plotn->Draw();

  HmESN.SetLineColor(2);HmESN.SetStats(0);
  HmESN.Draw("same");
  plotp->Draw("same");
  HmESP.SetLineColor(3);HmESP.SetStats(0);
  HmESP.Draw("same");
  Canvas.Print(filename);
  delete plotn;
  delete plotp;


  Float_t diff=Syieldn-Syieldp;
  Float_t diffe=sqrt((float)Syieldne*Syieldne+(float)Syieldpe*Syieldpe);
  Float_t asym=diff/Syieldtot;
  Float_t asyme=asym*sqrt(diffe*diffe/((float)diff*diff)+Syieldtote*Syieldtote/((float)Syieldtot*Syieldtot));
  cout<<"Yield Results  TotSig="<<Syieldtot<<"+-"<<Syieldtote
      <<",  SigN="<<Syieldn<<"+-"<<Syieldne
      <<",   SigP="<<Syieldp<<"+-"<<Syieldpe
      <<"    Asym=(SigN-SigP)/(SigN+SigP)="<<asym<<"+-"<<asyme
      <<endl<<endl;
    
  cout<<"Yield Results  TotBkg="<<Byieldtot<<"+-"<<Byieldtote<<",  BkgN="<<Byieldn<<"+-"<<Byieldne<<",   BkgP="<<Byieldp<<"+-"<<Byieldpe<<endl<<endl;


  cout<<"Yield Results in sig region  TotSig="<<syieldtot<<",  SigN="<<syieldn<<",   SigP="<<syieldp<<endl;
  cout<<"Yield Results in sig region  TotBkg="<<byieldtot<<",  BkgN="<<byieldn<<",   BkgP="<<byieldp<<endl;

  ///---------------------------------------------------------------
  


  ////Plot Difference of the histograms:
  TH1F*HDiff=(TH1F*)HmESN.Clone();
  HDiff->SetName("HDiff");HDiff->SetTitle("Difference");
  HDiff->Sumw2();
  HDiff->Add(&HmESP,-1);
  Canvas.Clear(); 
  HDiff->SetStats(1);
  HDiff->SetLineColor(1); 
  SetHistoXYLabels(HDiff,"m_{ES}","(GeV^{2}/c^{4})");
  HDiff->Draw("pe");
  Canvas.Update();
  MoveStatsBox(HDiff,-1,1);
  cutline.DrawLine(HmESN.GetXaxis()->GetXmin(),0,HmESN.GetXaxis()->GetXmax(),0);
  Canvas.Update();
  Canvas.Print(filename);
  cout<<" Asym="<<(float)(HDiff->Integral())/HmES.Integral(28,36)<<endl;
  delete HDiff;


  */

  Canvas.Print(filename+"]");

  return 1;
}
Example #3
0
/*
 * @test @(#)bug4117335.java    1.1 3/5/98
 *
 * @bug 4117335
 */
void
DateFormatMiscTests::test4117335()
{
    //UnicodeString bc = "\u7d00\u5143\u524d";
    UChar bcC [] = {
        0x7D00,
        0x5143,
        0x524D
    };
    UnicodeString bc(bcC, 3, 3);

    //UnicodeString ad = "\u897f\u66a6";
    UChar adC [] = {
        0x897F,
        0x66A6
    };
    UnicodeString ad(adC, 2, 2);
    
    //UnicodeString jstLong = "\u65e5\u672c\u6a19\u6e96\u6642";
    UChar jstLongC [] = {
        0x65e5,
        0x672c,
        0x6a19,
        0x6e96,
        0x6642
    };
    UnicodeString jstLong(jstLongC, 5, 5);

    UnicodeString jstShort = "JST";

    
    UErrorCode status = U_ZERO_ERROR;
    DateFormatSymbols *symbols = new DateFormatSymbols(Locale::getJapan(), status);
    if(U_FAILURE(status)) {
      errln("Failure creating DateFormatSymbols, %s", u_errorName(status));
      delete symbols;
      return;
    }
    failure(status, "new DateFormatSymbols");
    int32_t eraCount = 0;
    const UnicodeString *eras = symbols->getEras(eraCount);
    
    logln(UnicodeString("BC = ") + eras[0]);
    if (eras[0] != bc) {
        errln("*** Should have been " + bc);
        //throw new Exception("Error in BC");
    }

    logln(UnicodeString("AD = ") + eras[1]);
    if (eras[1] != ad) {
        errln("*** Should have been " + ad);
        //throw new Exception("Error in AD");
    }

    int32_t rowCount, colCount;
    const UnicodeString **zones = symbols->getZoneStrings(rowCount, colCount);
    logln(UnicodeString("Long zone name = ") + zones[24][1]);
    if (zones[24][1] != jstLong) {
        errln("*** Should have been " + jstLong);
        //throw new Exception("Error in long TZ name");
    }
    logln(UnicodeString("Short zone name = ") + zones[24][2]);
    if (zones[24][2] != jstShort) {
        errln("*** Should have been " + jstShort);
        //throw new Exception("Error in short TZ name");
    }
    logln(UnicodeString("Long zone name = ") + zones[24][3]);
    if (zones[24][3] != jstLong) {
        errln("*** Should have been " + jstLong);
        //throw new Exception("Error in long TZ name");
    }
    logln(UnicodeString("SHORT zone name = ") + zones[24][4]);
    if (zones[24][4] != jstShort) {
        errln("*** Should have been " + jstShort);
        //throw new Exception("Error in short TZ name");
    }
    delete symbols;

}
Example #4
0
int main(int argc, char* argv[])
{
  // Define problem parameters: (x_loc, y_loc) is the center of the circular wave front, R_ZERO is the distance from the 
  // wave front to the center of the circle, and alpha gives the steepness of the wave front.
  double alpha, x_loc, y_loc, r_zero;
  switch(PARAM) {
  case 0:
    alpha = 20;
    x_loc = -0.05;
    y_loc = -0.05;
    r_zero = 0.7;
    break;
  case 1:
    alpha = 1000;
    x_loc = -0.05;
    y_loc = -0.05;
    r_zero = 0.7;
    break;
  case 2:
    alpha = 1000;
    x_loc = 1.5;
    y_loc = 0.25;
    r_zero = 0.92;
    break;
  case 3:
    alpha = 50;
    x_loc = 0.5;
    y_loc = 0.5;
    r_zero = 0.25;
    break;
  default:   
    // The same as 0.
    alpha = 20;
    x_loc = -0.05;
    y_loc = -0.05;
    r_zero = 0.7;
    break;
  }
  
  // Set adaptivity options according to the command line argument.
  int refinement_mode;
  if (argc != 2)
    refinement_mode = 0;
  else
  {
    refinement_mode = atoi(argv[1]);
    if (refinement_mode < 1 || refinement_mode > 12)
      throw Hermes::Exceptions::Exception("Invalid run case: %d (valid range is [1,12])", refinement_mode);
  }
  
  double threshold = 0.3;                     
  // strategy = 0 ... Refine elements until sqrt(threshold) times total error is processed. 
  //                  If more elements have similar errors, refine all to keep the mesh symmetric.
  int strategy = 0;       
  // strategy = 1 ... Refine all elements whose error is larger than threshold times max. element error.
  // Add also the norm of the residual to the error estimate of each element.
  bool use_residual_estimator = false;        
  // Use energy norm for error estimate normalization and measuring of exact error.
  bool use_energy_norm_normalization = false; 
  
  switch (refinement_mode)
  {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    {
      strategy = 0;
      break;
    }
    
    case 7 :
    case 8 :
    case 9 :
    case 10:
    case 11:
    case 12:
    {
      strategy = 1;
      break;
    }
  }
  
  switch (refinement_mode)
  {
    case 1:
    case 2:
    case 3:
    case 7:
    case 8:
    case 9:
    {
      threshold = 0.3;
      break;
    }
    
    case 4:
    case 5:
    case 6:
    case 10:
    case 11:
    case 12:
    {
      threshold = 0.3*0.3;
      break;
    }
  }
  
  switch (refinement_mode)
  {
    case 2:
    case 3:
    case 5:
    case 6:
    case 8:
    case 9:
    case 11:
    case 12:
    {
      use_residual_estimator = true;
      break;
    }
  }
  
  switch (refinement_mode)
  {
    case 3:
    case 6:
    case 9:
    case 12:
    {
      use_energy_norm_normalization = true;
      break;
    }
  }
  
  double setup_time = 0, assemble_time = 0, solve_time = 0, adapt_time = 0;
  
  // Time measurement.
  Hermes::Mixins::TimeMeasurable wall_clock;
  // Stop counting time for adaptation.
  wall_clock.tick(); 

  // Load the mesh.
  Mesh mesh;
  MeshReaderH2D mloader;
  mloader.load("square_quad.mesh", &mesh);    

  // Perform initial mesh refinement.
  for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
  
  // Stop counting time for adaptation.
  wall_clock.tick(); 
  adapt_time += wall_clock.last();
  
  // Set exact solution.
  CustomExactSolution exact(&mesh, alpha, x_loc, y_loc, r_zero);

  // Define right-hand side.
  CustomRightHandSide rhs(alpha, x_loc, y_loc, r_zero);

  // Initialize the weak formulation.
  CustomWeakForm wf(&rhs);
  // Equivalent, but slower:
  // DefaultWeakFormPoisson<double> wf(Hermes::HERMES_ANY, HERMES_ONE, &rhs);

  // Initialize boundary conditions.
  DefaultEssentialBCNonConst<double> bc("Bdy", &exact);
  EssentialBCs<double> bcs(&bc);

  // Create an H1 space with default shapeset.
  H1Space<double> space(&mesh, &bcs, P_INIT);
  
  // Initialize approximate solution.
  Solution<double> sln;
  
  // Initialize views.
  Views::ScalarView sview("Solution", new Views::WinGeom(800, 0, 400, 400));
  sview.show_mesh(false);
  sview.set_3d_mode();
  sview.set_palette(Views::H2DV_PT_HUESCALE);
  sview.fix_scale_width(50);
  Views::OrderView  oview("Mesh", new Views::WinGeom(0, 0, 800, 800));
  oview.set_palette(Views::H2DV_PT_INVGRAYSCALE);

  // DOF and CPU convergence graphs.
  ConvergenceTable conv_table;
  conv_table.add_column(" cycle ", "%6d ");
  conv_table.add_column("  H1 error ", " %.4e ");
  conv_table.add_column("   ndof  ", " %6d ");
  conv_table.add_column(" total time ", " %8.3f  ");
  conv_table.add_column(" setup time ", "  %8.3f  ");
  conv_table.add_column(" assem time ", "  %8.3f  ");
  conv_table.add_column(" solve time ", "  %8.3f  ");
  conv_table.add_column(" adapt time ", "  %8.3f  ");
  
  wall_clock.tick(Hermes::Mixins::TimeMeasurable::HERMES_SKIP);

  // Adaptivity loop:
  int as = 0; bool done = false;
  do
  {
    // Start counting setup time.
    wall_clock.tick(); 
    
    // Assemble the discrete problem.    
    DiscreteProblem<double> dp(&wf, &space);

    // Actual ndof.
    int ndof = space.get_num_dofs();
    
    NewtonSolver<double> newton(&dp);
    newton.set_verbose_output(false);

    // Setup time continues in NewtonSolver::solve().
    try
    {
      newton.solve();
    }
    catch(Hermes::Exceptions::Exception e)
    {
      e.printMsg();
      throw Hermes::Exceptions::Exception("Newton's iteration failed.");
    };

    setup_time += newton.get_setup_time();
    assemble_time += newton.get_assemble_time();
    solve_time += newton.get_solve_time();
     
    // Start counting time for adaptation.
    wall_clock.tick();  
    Solution<double>::vector_to_solution(newton.get_sln_vector(), &space, &sln);
    
    double err_exact = Global<double>::calc_abs_error(&sln, &exact, HERMES_H1_NORM);
   
    // Report results.
    Hermes::Mixins::Loggable::Static::info(" Cycle %d:", as);
    Hermes::Mixins::Loggable::Static::info("    Number of degrees of freedom: %d", ndof);
    Hermes::Mixins::Loggable::Static::info("    H1 error w.r.t. exact soln.:  %g", err_exact);
    
    // Stop counting time for adaptation.
    wall_clock.tick(); 
    double accum_time = wall_clock.accumulated();
    adapt_time += wall_clock.last();
    
    // View the approximate solution and polynomial orders.
    //sview.show(&sln);
    //oview.show(&space);
    //Views::View::wait(Views::HERMES_WAIT_KEYPRESS);
    
    conv_table.add_value(0, as);
    conv_table.add_value(1, err_exact);
    conv_table.add_value(2, ndof);
    conv_table.add_value(3, accum_time);
    conv_table.add_value(4, setup_time);
    conv_table.add_value(5, assemble_time);
    conv_table.add_value(6, solve_time);
    conv_table.add_value(7, adapt_time);
    
    // Start counting time for adaptation.
    wall_clock.tick(); 
    
    if (err_exact < ERR_STOP) 
      done = true;
    else
    {
      // Calculate element errors and total error estimate.
      Hermes::Hermes2D::BasicKellyAdapt<double> adaptivity(&space);
      
      unsigned int error_flags = HERMES_TOTAL_ERROR_ABS;
      
      if (use_energy_norm_normalization)
      {
        error_flags |= HERMES_ELEMENT_ERROR_REL;
        adaptivity.set_error_form(new EnergyErrorForm(&wf));
      }
      else
        error_flags |= HERMES_ELEMENT_ERROR_ABS;
      
      if (use_residual_estimator) 
        adaptivity.add_error_estimator_vol(new ResidualErrorForm(&rhs));
      
      double err_est_rel = adaptivity.calc_err_est(&sln, error_flags);  
      
      done = adaptivity.adapt(threshold, strategy, MESH_REGULARITY);
      
      // Stop counting time for adaptation.
      wall_clock.tick(); 
      adapt_time += wall_clock.last();
    }
        
    // Increase the counter of performed adaptivity steps.
    if (done == false)  
      as++;
    else
    {
      Hermes::Mixins::Loggable::Static::info("Total running time:  %g s", wall_clock.accumulated());
      Hermes::Mixins::Loggable::Static::info("   Setup:            %g s", setup_time);
      Hermes::Mixins::Loggable::Static::info("   Assemble:         %g s", assemble_time);
      Hermes::Mixins::Loggable::Static::info("   Solve:            %g s", solve_time);
      Hermes::Mixins::Loggable::Static::info("   Adapt:            %g s", adapt_time);
      
      //sview.show(&sln);
      oview.show(&space);
      oview.save_screenshot(("final_mesh-"+itos(refinement_mode)+".bmp").c_str());
      oview.close();
      conv_table.save(("conv_table-"+itos(refinement_mode)+".dat").c_str());
    }
  }
  while (done == false);

  // Wait for all views to be closed.
  //Views::View::wait();
  return 0;
}
Example #5
0
File: sor3d.c Project: valner/svt
INT main(INT argc, CHAR *argv[]) {
/********** MAIN PROGRAM *********************************
 * Solve Laplace equation using Jacobi iteration method  *
        *
 *********************************************************/
      INT m = M_DEFAULT, mp, k, p, below, above;
      long iter=MAXSTEPS;
      REAL TOL=EPS_DEFAULT, del, gdel,start,finish,time;
      CHAR line[80];
      REAL ***v, ***vt, ***vnew;

      MPI_Init(&argc, &argv);                       /* starts MPI */
      
      MPI_Comm_rank(MPI_COMM_WORLD, &k); /* get current process id */
      MPI_Comm_size(MPI_COMM_WORLD, &p); /* get # procs from env or */

      if(k == 0) {
          fprintf(OUTPUT," Number of args in command line, argc :\n");
          
          fprintf(OUTPUT," argc = %d :\n", argc);
          if (argc >= 2) 
              fprintf(OUTPUT," arg[1]= %s :\n", argv[1]);
          if (argc >= 3) 
              fprintf(OUTPUT," arg[2]= %s :\n", argv[2]);
          
          if (argc >1){
              m=atoi(argv[1]);
          }  
          
          if (argc >2 ) {
              TOL= atof(argv[2]);
          }
          
          fprintf(OUTPUT,"Size of interior points, m :\n");
          fprintf(OUTPUT,"m = %d\n",m);
          fprintf(OUTPUT,"Numerical accuracy, eps :\n");
          fprintf(OUTPUT,"eps = %f\n",TOL);

          fprintf(OUTPUT,"Number of processes, p :\n");
          fprintf(OUTPUT,"p = %d\n",p);
          
          start=-MPI_Wtime();
      }
      MPI_Bcast(&m, 1, MPI_INT, 0, MPI_COMM_WORLD);
      MPI_Bcast(&TOL, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
      
      mp = m/p;
      
      v  = allocate_3D(m, m, mp);  /* allocate mem for 2D array */
      vt = allocate_3D(mp, m, m);
      vnew = allocate_3D(mp, m, m);

      gdel = 1.0;
      iter = 0;

      bc(m, m, mp, v, k, p); /* initialize and define B.C. for v */
      transpose(m, m, mp, v, vt);  /* solve for vt */
                                /* driven by need of update_bc_2 */

      replicate(mp, m, vt, vnew);            /* vnew = vt */
      neighbors(k, p, MPI_PROC_NULL, &below, &above);   /* domain borders */
      
      REAL ro = 1.0 - pow (PI / (2 * (m + 1)), 2);
      REAL w = 0;
      while (gdel > TOL) {  /* iterate until error below threshold */
        iter++;             /* increment iteration counter */

        if(iter > MAXSTEPS) {
          fprintf(OUTPUT,"Iteration terminated (exceeds %6d", MAXSTEPS);
          fprintf(OUTPUT," )\n");
          return (0);       /* nonconvergent solution */
        }
/* compute new solution according to the Jacobi scheme */
        update_jacobi(mp, m, vt, vnew, &del);  /* compute new vt */
        /*update_sor(mp, m, vt, vnew, &del, w, 0 );*/
        /*update_bc_2( mp, m, vt, k, below, above); [> update b.c. <]*/

        /*update_sor(mp, m, vt, vnew, &del, w, 1);*/
        /*update_bc_2( mp, m, vt, k, below, above); [> update b.c. <]*/

        /*update_w(&w, ro);*/
        if(iter%INCREMENT == 0) {
            gdel = 0;
          MPI_Allreduce( &del, &gdel, 1, MPI_DOUBLE,
               MPI_SUM, MPI_COMM_WORLD );  /* find global max error */
          if( k == 0) {
            fprintf(OUTPUT,"iter,del,gdel: %6d, %lf %lf\n",iter,del,gdel);
          }
        }
      }
      if (k == 0) {
	  finish=MPI_Wtime();
        time=start+finish;
        fprintf(OUTPUT,"Stopped at iteration %d\n",iter);
        fprintf(OUTPUT,"The maximum error = %f\n",gdel);
        fprintf(OUTPUT,"Time = %f\n",time);

      }
      if (FILE_OUT) {
	  /* write v to file for use in MATLAB plots */
	  transpose(mp, m, m, vt, v);
	  write_file( m, m, mp, v, k, p );
	  
	  MPI_Barrier(MPI_COMM_WORLD);
      }

      free(v); free(vt); free(vnew); /* release allocated arrays  */
      MPI_Finalize();  
      return (0);
}
Example #6
0
 int16_t getInt16() {
     int16_t res = bc()->getInt16(bci_);
     bci_ += sizeof(int16_t);
     return res;
 }
Example #7
0
// Alternative, FGL version: optimistic fine-grain locking.
// Identifies the relevant edges and points, then locks
// them in canonical order, then double-checks to make
// sure nothing has changed.
//
void synchronized_reconsider(edge::Up self, const int seam,
                             simple_queue<edge::Sp> *tentative_edges) {
    self->set_tentative(false, self);
        // Do this first, to avoid window where I turn it off
        // after somebody else has turned it on.
    point* a = self->get_points(0, self);
    point* b = self->get_points(1, self);
    edge::Up ac(self->get_neighbors(0, ccw, self));
    edge::Up bc(self->get_neighbors(1, cw, self));
    int aci = index_of(ac, a);
    int bci = index_of(bc, b);
    if (aci == -1 || bci == -1) {
        // inconsistent; somebody has already been here
        return;
    }
    point* c = ac->get_points(1-aci, ac);
    if (c != bc->get_points(1-bci, bc)) {
        // No triangle on the c side; we're an external edge
        return;
    }
    edge::Up ad(self->get_neighbors(0, cw, self));
    edge::Up bd(self->get_neighbors(1, ccw, self));
    int adi = index_of(ad, a);
    int bdi = index_of(bd, b);
    if (adi == -1 || bdi == -1) {
        // inconsistent; somebody has already been here
        return;
    }
    point* d = ad->get_points(1-adi, ad);
    if (d != bd->get_points(1-bdi, bd)) {
        // No triangle on the d side; we're an external edge
        return;
    }
    {
        point_set S;
        with_locked_points cs(S | a | b | c | d);

        if (!(edges->contains(self)
                && edges->contains(ac) && edges->contains(bc)
                && edges->contains(ad) && edges->contains(bd))) {
            // inconsistent; somebody has already been here
            return;
        }
        if (!(ac == self->get_neighbors(0, ccw, self)
                && bc == self->get_neighbors(1, cw, self)
                && ad == self->get_neighbors(0, cw, self)
                && bd == self->get_neighbors(1, ccw, self))) {
            // inconsistent; somebody has already been here
            return;
        }
        if (!(aci == index_of(ac, a)
                && bci == index_of(bc, b)
                && adi == index_of(ad, a)
                && bdi == index_of(bd, b))) {
            // inconsistent; somebody has already been here
            return;
        }
        if (!(c == ac->get_points(1-aci, ac)
                && c == bc->get_points(1-bci, bc)
                && d == ad->get_points(1-adi, ad)
                && d == bd->get_points(1-bdi, bd))) {
            // inconsistent; somebody has already been here
            return;
        }
        if (encircled(b, c, a, d, ccw) || encircled(a, d, b, c, ccw)) {
            // other diagonal is locally Delaunay; we're not
            destroy(self);      // can't wait for delayed destructor
            edge::Sp dum;
            edge::create(c, d, bc, bd, cw, dum);
            ac->set_tentative(true, ac);  tentative_edges->enqueue(ac, seam);
            ad->set_tentative(true, ad);  tentative_edges->enqueue(ad, seam);
            bc->set_tentative(true, bc);  tentative_edges->enqueue(bc, seam);
            bd->set_tentative(true, bd);  tentative_edges->enqueue(bd, seam);
        }
    }
}
Example #8
0
int main(int argc, char *argv[]) {
	
	struct sched_param scp;

	scp.sched_priority = 60;

	sched_setscheduler(0, SCHED_FIFO, &scp);
	mlockall(MCL_FUTURE);

	allegro_init();
	set_color_depth(24);
	set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 1024, 768, 0, 0);
	install_keyboard();
	install_mouse();

	font = load_font("font.fnt", NULL, NULL);
	
	BITMAP *wsbuffer = create_bitmap(1024, 768);

	Box workspace(0, 0, 1024, 768, COLOR_PLAYER, Box::TYPE_FLAT);

	BarCounter bc(902, 16); 

	workspace.addChild(new Image(0, 0, 32, 768, "left.bmp"));
	workspace.addChild(new Image(992, 0, 32, 768, "right.bmp"));

	workspace.addChild(&bc);
	workspace.addChild(new PeakMeter(907, 50));

	BITMAP *splash = load_bitmap("splash.bmp", 0);
	blit(splash, screen, 0, 0, 0, 0, 1024, 768);
	destroy_bitmap(splash);
	sound->init(162, &bc); // FIXME changing tempo.

	loader = new Loader();

	for(int i = 0; i < NUMBER_PLAYERS; i++){
		workspace.addChild(new Player(96 * i, COLOR_PLAYER));
		sound->update();
	}

	workspace.paint();

	show_mouse(screen);

	bool mbdown = false;
	bool wsneedsredraw = false;

	int dragstart_x = 0;
	int dragstart_y = 0;

	int mickey_x = 0;
	int mickey_y = 0;

	bool taking_screenshot = false;

	while(!(key[KEY_LSHIFT] && key[KEY_LCONTROL] && key[KEY_ESC])){
		sound->update();
	
		bc.paintIfNeeded();
		// Screenshot
		if(key[KEY_F12] && !taking_screenshot){
			taking_screenshot = true;
			save_bitmap("shot.bmp", screen, 0);
		} else if(taking_screenshot){
			taking_screenshot = false;
		}
	

		if(loader->needsDisplay()){
			if(!wsneedsredraw){
				scare_mouse();
				blit(screen, wsbuffer, 0, 0, 0, 0, 1024, 768);
				unscare_mouse();
				loader->paint();
				wsneedsredraw = true;
			}
			if(key[KEY_ESC])
				loader->cancelDisplay();
		} else if(wsneedsredraw) {
			scare_mouse();
			blit(wsbuffer, screen, 0, 0, 0, 0, 1024, 768);
			bc.paint();
			workspace.paintIfNeeded();
			unscare_mouse();
			wsneedsredraw = false;
		} else {
			workspace.paintIfNeeded();
		}
		
		if((mouse_b) && !mbdown) {
			if(loader->needsDisplay()) {
				loader->mouseEvent(mouse_x, mouse_y, mouse_b);
			} else {
				workspace.mouseEvent(mouse_x, mouse_y, mouse_b);
			}
			mbdown = true;
			dragstart_x = mouse_x;
			dragstart_y = mouse_y;
			show_mouse(0);
			get_mouse_mickeys(&mickey_x, &mickey_y);
		} else if (!mouse_b && mbdown) {
			mbdown = false;
			position_mouse(dragstart_x, dragstart_y);
			show_mouse(screen);
		} else if (mbdown) {
			// Trigger drag events
			get_mouse_mickeys(&mickey_x, &mickey_y);
			if(!loader->needsDisplay()){
				if(mickey_x != 0 || mickey_y != 0)
					workspace.dragEvent(dragstart_x, dragstart_y, mickey_x, mickey_y);
			}
		}

		usleep(100);
	}
	// sound->system->release();
	delete logg;
	set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
	return 0;
}
dtStatus dtTileCache::buildNavMeshTile(const dtCompressedTileRef ref, dtNavMesh* navmesh)
{	
	dtAssert(m_talloc);
	dtAssert(m_tcomp);
	
	unsigned int idx = decodeTileIdTile(ref);
	if (idx > (unsigned int)m_params.maxTiles)
		return DT_FAILURE | DT_INVALID_PARAM;
	const dtCompressedTile* tile = &m_tiles[idx];
	unsigned int salt = decodeTileIdSalt(ref);
	if (tile->salt != salt)
		return DT_FAILURE | DT_INVALID_PARAM;
	
	m_talloc->reset();
	
	BuildContext bc(m_talloc);
	const int walkableClimbVx = (int)(m_params.walkableClimb / m_params.ch);
	dtStatus status;
	
	// Decompress tile layer data. 
	status = dtDecompressTileCacheLayer(m_talloc, m_tcomp, tile->data, tile->dataSize, &bc.layer);
	if (dtStatusFailed(status))
		return status;

#if 0
	if (tile->header->tx != 1 || tile->header->ty != 0 || tile->header->tlayer < 1)
		return status;
#endif
	
	// Rasterize obstacles.
	for (int i = 0; i < m_params.maxObstacles; ++i)
	{
		const dtTileCacheObstacle* ob = &m_obstacles[i];
		if (ob->state == DT_OBSTACLE_EMPTY || ob->state == DT_OBSTACLE_REMOVING)
			continue;
		if (contains(ob->touched, ob->ntouched, ref))
		{
			dtMarkCylinderArea(*bc.layer, tile->header->bmin, m_params.cs, m_params.ch,
							   ob->pos, ob->radius, ob->height, 0);
		}
	}
	
	if (m_tmproc)
	{
		m_tmproc->markAreas(bc.layer, tile->header->bmin, m_params.cs, m_params.ch);
	}

	// Build navmesh
	if (m_params.regionPartitioning == DT_REGION_MONOTONE)
	{
		status = dtBuildTileCacheRegionsMonotone(m_talloc, m_params.minRegionArea, m_params.mergeRegionArea, *bc.layer);
	}
	else if (m_params.regionPartitioning == DT_REGION_WATERSHED)
	{
		bc.dfield = dtAllocTileCacheDistanceField(m_talloc);
		if (!bc.dfield)
			return status;

		status = dtBuildTileCacheDistanceField(m_talloc, *bc.layer, *bc.dfield);
		if (dtStatusFailed(status))
			return status;

		status = dtBuildTileCacheRegions(m_talloc, m_params.minRegionArea, m_params.mergeRegionArea, *bc.layer, *bc.dfield);
	}
	else
	{
		status = dtBuildTileCacheRegionsChunky(m_talloc, m_params.minRegionArea, m_params.mergeRegionArea, *bc.layer, m_params.regionChunkSize);
	}
	if (dtStatusFailed(status))
		return status;
	
	bc.lcset = dtAllocTileCacheContourSet(m_talloc);
	bc.lclusters = dtAllocTileCacheClusterSet(m_talloc);
	if (!bc.lcset || !bc.lclusters)
		return status;
	status = dtBuildTileCacheContours(m_talloc, *bc.layer, walkableClimbVx,
									  m_params.maxSimplificationError, m_params.cs, m_params.ch,
									  *bc.lcset, *bc.lclusters);
	if (dtStatusFailed(status))
		return status;
	
	bc.lmesh = dtAllocTileCachePolyMesh(m_talloc);
	if (!bc.lmesh)
		return status;
	status = dtBuildTileCachePolyMesh(m_talloc, 0, *bc.lcset, *bc.lmesh);
	if (dtStatusFailed(status))
		return status;
	
	// Early out if the mesh tile is empty.
	if (!bc.lmesh->npolys)
		return DT_SUCCESS;

	status = dtBuildTileCacheClusters(m_talloc, *bc.lclusters, *bc.lmesh);
	if (dtStatusFailed(status))
		return status;
	
	dtNavMeshCreateParams params;
	memset(&params, 0, sizeof(params));
	params.verts = bc.lmesh->verts;
	params.vertCount = bc.lmesh->nverts;
	params.polys = bc.lmesh->polys;
	params.polyAreas = bc.lmesh->areas;
	params.polyFlags = bc.lmesh->flags;
	params.polyCount = bc.lmesh->npolys;
	params.nvp = DT_VERTS_PER_POLYGON;
	params.walkableHeight = m_params.walkableHeight;
	params.walkableRadius = m_params.walkableRadius;
	params.walkableClimb = m_params.walkableClimb;
	params.tileX = tile->header->tx;
	params.tileY = tile->header->ty;
	params.tileLayer = tile->header->tlayer;
	params.cs = m_params.cs;
	params.ch = m_params.ch;
	params.buildBvTree = false;
	dtVcopy(params.bmin, tile->header->bmin);
	dtVcopy(params.bmax, tile->header->bmax);
	params.polyClusters = bc.lclusters->polyMap;
	params.clusterCount = (unsigned short)bc.lclusters->nclusters;
	
	if (m_tmproc)
	{
		m_tmproc->process(&params, bc.lmesh->areas, bc.lmesh->flags);
	}
	
	unsigned char* navData = 0;
	int navDataSize = 0;
	if (!dtCreateNavMeshData(&params, &navData, &navDataSize))
		return DT_FAILURE;

	// Remove existing tile.
	navmesh->removeTile(navmesh->getTileRefAt(tile->header->tx,tile->header->ty,tile->header->tlayer),0,0);

	// Add new tile, or leave the location empty.
	if (navData)
	{
		// Let the navmesh own the data.
		status = navmesh->addTile(navData,navDataSize,DT_TILE_FREE_DATA,0,0);
		if (dtStatusFailed(status))
		{
			dtFree(navData);
			return status;
		}
	}
	
	return DT_SUCCESS;
}
Example #10
0
/*
 * @test @(#)bug4117335.java    1.1 3/5/98
 *
 * @bug 4117335
 */
void
DateFormatMiscTests::test4117335()
{
    //UnicodeString bc = "\u7d00\u5143\u524d";
    UChar bcC [] = {
        0x7D00,
        0x5143,
        0x524D
    };
    UnicodeString bc(bcC, 3, 3);

    //UnicodeString ad = "\u897f\u66a6";
    UChar adC [] = {
        0x897F,
        0x66A6
    };
    UnicodeString ad(adC, 2, 2);
    
    //UnicodeString jstLong = "\u65e5\u672c\u6a19\u6e96\u6642";
    UChar jstLongC [] = {
        0x65e5,
        0x672c,
        0x6a19,
        0x6e96,
        0x6642
    };
    UChar jdtLongC [] = {0x65E5, 0x672C, 0x590F, 0x6642, 0x9593};

    UnicodeString jstLong(jstLongC, 5, 5);

//    UnicodeString jstShort = "JST";
    
    UnicodeString tzID = "Asia/Tokyo";

    UnicodeString jdtLong(jdtLongC, 5, 5);
 
//    UnicodeString jdtShort = "JDT";
    UErrorCode status = U_ZERO_ERROR;
    DateFormatSymbols *symbols = new DateFormatSymbols(Locale::getJapan(), status);
    if(U_FAILURE(status)) {
      dataerrln("Failure creating DateFormatSymbols, %s", u_errorName(status));
      delete symbols;
      return;
    }
    failure(status, "new DateFormatSymbols");
    int32_t eraCount = 0;
    const UnicodeString *eras = symbols->getEraNames(eraCount);
    
    logln(UnicodeString("BC = ") + eras[0]);
    if (eras[0] != bc) {
        errln("*** Should have been " + bc);
        //throw new Exception("Error in BC");
    }

    logln(UnicodeString("AD = ") + eras[1]);
    if (eras[1] != ad) {
        errln("*** Should have been " + ad);
        //throw new Exception("Error in AD");
    }

    int32_t rowCount, colCount;
    const UnicodeString **zones = symbols->getZoneStrings(rowCount, colCount);
    //don't hard code the index .. compute it.
    int32_t index = -1;
    for (int32_t i = 0; i < rowCount; ++i) {
        if (tzID == (zones[i][0])) {
            index = i;
            break;
        }
    }
    logln(UnicodeString("Long zone name = ") + zones[index][1]);
    if (zones[index][1] != jstLong) {
        errln("*** Should have been " + prettify(jstLong)+ " but it is: " + prettify(zones[index][1]));
        //throw new Exception("Error in long TZ name");
    }
//    logln(UnicodeString("Short zone name = ") + zones[index][2]);
//    if (zones[index][2] != jstShort) {
//        errln("*** Should have been " + prettify(jstShort) + " but it is: " + prettify(zones[index][2]));
//        //throw new Exception("Error in short TZ name");
//    }
    logln(UnicodeString("Long zone name = ") + zones[index][3]);
    if (zones[index][3] != jdtLong) {
        errln("*** Should have been " + prettify(jstLong) + " but it is: " + prettify(zones[index][3]));
        //throw new Exception("Error in long TZ name");
    }
//    logln(UnicodeString("SHORT zone name = ") + zones[index][4]);
//    if (zones[index][4] != jdtShort) {
//        errln("*** Should have been " + prettify(jstShort)+ " but it is: " + prettify(zones[index][4]));
//        //throw new Exception("Error in short TZ name");
//    }
    delete symbols;

}
Example #11
0
// 与えられた変換で曲線のトランスフォームを行いオブジェクトを生成する。
//General transformation of the curve.
MGRSBRep MGRSBRep::operator* (const MGTransf& tr) const{
	MGSPointSeq bc(m_surface.surface_bcoef());
	bc.homogeneous_transform(tr);
	return MGRSBRep(bc,m_surface.knot_vector_u(),m_surface.knot_vector_v());
}
Example #12
0
bool
vc1::parse_sequence_header(const unsigned char *buf,
                           int size,
                           vc1::sequence_header_t &seqhdr) {
  try {
    static const struct { int n, d; } s_aspect_ratios[13] = {
      {   1,  1 },
      {  12, 11 },
      {  10, 11 },
      {  16, 11 },
      {  40, 33 },
      {  24, 11 },
      {  20, 11 },
      {  32, 11 },
      {  80, 33 },
      {  18, 11 },
      {  15, 11 },
      {  64, 33 },
      { 160, 99 }
    };

    static const int s_framerate_nr[5] = { 24, 25, 30, 50, 60 };
    static const int s_framerate_dr[2] = { 1000, 1001 };

    bit_reader_c bc(buf, size);
    vc1::sequence_header_t hdr;

    bc.skip_bits(32);           // Marker
    hdr.profile = bc.get_bits(2);

    if (VC1_PROFILE_ADVANCED != hdr.profile)
      return false;

    hdr.level              = bc.get_bits(3);
    hdr.chroma_format      = bc.get_bits(2);
    hdr.frame_rtq_postproc = bc.get_bits(3);
    hdr.bit_rtq_postproc   = bc.get_bits(5);
    hdr.postproc_flag      = bc.get_bit();
    hdr.pixel_width        = (bc.get_bits(12) + 1) << 1;
    hdr.pixel_height       = (bc.get_bits(12) + 1) << 1;
    hdr.pulldown_flag      = bc.get_bit();
    hdr.interlace_flag     = bc.get_bit();
    hdr.tf_counter_flag    = bc.get_bit();
    hdr.f_inter_p_flag     = bc.get_bit();
    bc.skip_bits(1);            // reserved
    hdr.psf_mode_flag      = bc.get_bit();
    hdr.display_info_flag  = bc.get_bit();

    if (hdr.display_info_flag) {
      hdr.display_width     = bc.get_bits(14) + 1;
      hdr.display_height    = bc.get_bits(14) + 1;
      hdr.aspect_ratio_flag = bc.get_bit();

      if (hdr.aspect_ratio_flag) {
        int aspect_ratio_idx      = bc.get_bits(4);

        if ((0 < aspect_ratio_idx) && (14 > aspect_ratio_idx)) {
          hdr.aspect_ratio_width  = s_aspect_ratios[aspect_ratio_idx - 1].n;
          hdr.aspect_ratio_height = s_aspect_ratios[aspect_ratio_idx - 1].d;

        } else if (15 == aspect_ratio_idx) {
          hdr.aspect_ratio_width  = bc.get_bits(8);
          hdr.aspect_ratio_height = bc.get_bits(8);

          if ((0 == hdr.aspect_ratio_width) || (0 == hdr.aspect_ratio_height))
            hdr.aspect_ratio_flag = false;

        } else
          hdr.aspect_ratio_flag   = false;
      }

      hdr.framerate_flag = bc.get_bit();
      if (hdr.framerate_flag) {
        if (bc.get_bit()) {
          hdr.framerate_num = 32;
          hdr.framerate_den = bc.get_bits(16) + 1;

        } else {
          int nr = bc.get_bits(8);
          int dr = bc.get_bits(4);

          if ((0 != nr) && (8 > nr) && (0 != dr) && (3 > dr)) {
            hdr.framerate_num = s_framerate_dr[dr - 1];
            hdr.framerate_den = s_framerate_nr[nr - 1] * 1000;

          } else
            hdr.framerate_flag = false;
        }
      }

      if (bc.get_bit()) {
        hdr.color_prim    = bc.get_bits(8);
        hdr.transfer_char = bc.get_bits(8);
        hdr.matrix_coef   = bc.get_bits(8);
      }
    }

    hdr.hrd_param_flag = bc.get_bit();
    if (hdr.hrd_param_flag) {
      hdr.hrd_num_leaky_buckets = bc.get_bits(5);
      bc.skip_bits(4 + 4);       // bitrate exponent, buffer size exponent
      bc.skip_bits(hdr.hrd_num_leaky_buckets * (16 + 16)); // hrd_rate, hrd_buffer
    }

    memcpy(&seqhdr, &hdr, sizeof(vc1::sequence_header_t));

    return true;
  } catch (...) {
    return false;
  }
}
Example #13
0
main()
{
    int
    x_a[10]
        = {4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, };
    int
    x_b
        =8888;
    int
    x_e[2]
        = {4444, 4444, };
    int
    x_c[3]
        = {4444, 4444, 4444, };
    for(
        x_b
        =
            1
            ;
        x_b
        <=
        10
        ;
        x_b
        ++)
    {
        x_a[(-1)*1+
            bc("a", 4, 1, 10,
               x_b
              )
           ]
            =
                100
                +
                x_b
                ;
    }
    for(
        x_b
        =
            0
            -
            2
            ;
        x_b
        >=
        0
        -
        4
        ;
        x_b
        --)
    {
        x_c[(-1)*-4+
            bc("c", 8, -4, -2,
               x_b
              )
           ]
            =
                1000
                -
                x_b
                ;
    }
    printf(
        "%s\n",
        "forward x: a"
    );
    {
        int
        x_x
        ;
        int i;
        for(i=1; i<=10; i++) {
            x_x =
                x_a[i-(1)];
            {
                int
                x_a
                    =8888;
                x_a
                    =
                        12
                        ;
                printf(
                    "%d\n",
                    x_x
                );
                printf(
                    "%d\n",
                    x_a
                );
            }
        }
    }
    printf(
        "%s\n",
        "forward x: c"
    );
    {
        int
        x_x
        ;
        int i;
        for(i=-4; i<=-2; i++) {
            x_x =
                x_c[i-(-4)];
            {
                int
                x_c[4]
                    = {4444, 4444, 4444, 4444, };
                printf(
                    "%d\n",
                    x_x
                );
                printf(
                    "%d\n",
                    x_c[(-1)*22+
                        bc("c", 23, 22, 25,
                           24
                          )
                       ]
                );
                {
                    int
                    x_x
                    ;
                    int i;
                    for(i=22; i<=25; i++) {
                        x_x =
                            i;
                        {
                            x_c[(-1)*22+
                                bc("c", 25, 22, 25,
                                   x_x
                                  )
                               ]
                                =
                                    20000
                                    +
                                    x_x
                                    ;
                        }
                    }
                }
                {
                    int
                    x_x
                    ;
                    int i;
                    for(i=22; i<=25; i++) {
                        x_x =
                            x_c[i-(22)];
                        {
                            printf(
                                "%d\n",
                                x_x
                            );
                        }
                    }
                }
                printf(
                    "%d\n",
                    x_x
                );
            }
        }
    }
    printf(
        "%s\n",
        "bottom forward x: c"
    );
    {
        int
        x_x
        ;
        int i;
        for(i=-4; i<=-2; i++) {
            x_x =
                x_c[i-(-4)];
            {
                int
                x_c[4]
                    = {4444, 4444, 4444, 4444, };
                printf(
                    "%d\n",
                    x_x
                );
                printf(
                    "%d\n",
                    x_c[(-1)*22+
                        bc("c", 37, 22, 25,
                           24
                          )
                       ]
                );
                {
                    int
                    x_y
                    ;
                    int i;
                    for(i=22; i<=25; i++) {
                        x_y =
                            i;
                        {
                            x_c[(-1)*22+
                                bc("c", 39, 22, 25,
                                   x_y
                                  )
                               ]
                                =
                                    20000
                                    +
                                    x_y
                                    ;
                        }
                    }
                }
                {
                    int
                    x_y
                    ;
                    int i;
                    for(i=22; i<=25; i++) {
                        x_y =
                            x_c[i-(22)];
                        {
                            printf(
                                "%d\n",
                                x_y
                            );
                            {
                                int
                                x_y
                                ;
                                int i;
                                for(i=84; i<=85; i++) {
                                    x_y =
                                        i;
                                    {
                                        printf(
                                            "%d\n",
                                            x_y
                                        );
                                    }
                                }
                            }
                        }
                    }
                }
                printf(
                    "%d\n",
                    x_x
                );
            }
        }
    }
}
int main(int argc, char **argv)
{
	dest_x=0;
	dest_y=6000;
	v = 200;	
	numberofobjects = 2;
	v1 = 100;
	ra[0][5] = 400;
	ra[1][5] = 400;
	ra[2][5] = 400; 
	ra[3][5] = 400;
	//argv[1]="-rh";
	//argv[2]="10.2.36.7";
	//argc=3;
	BotConnector bc(argc, argv);
	if( bc.connect() )
	{
		printf( "Connected to Robot\n" );
	}
	else
	{
		printf( "Connection attempt to Robot failed, Sorry :(\n" );
		return EXIT_SUCCESS;
	}
	argv[1]="-rrtp";
	argv[2]="8102";
	argc=3;
	BotConnector bc1(argc, argv);
	if( bc1.connect() )
	{
		printf( "Connected to Robot1\n" );
	}
	else
	{
		printf( "Connection attempt to Robot failed, Sorry :(\n" );
		return EXIT_SUCCESS;
	}
//	bc.setRobotVelocity_idle(100,100); // initialising vr and vl
	bc.setRobotVelocity(100,100, 10000);
	bc.getAngles(0);// updating ra[][].
//	omnicx = ra[0][1]+ra[0][5]*cos(ra[0][0]);
//	omnicy = ra[0][2]+ra[0][5]*sin(ra[0][0]);
	//bc1.moveRobot(0,90);
//bc1.setRobotVelocity(100,100, 10000);
bc1.moveRobot(6000,90);
//bc1.setRobotVelocity(100,100, 30000);
bc1.moveRobot(0,180);
	argv[1]="-rrtp";
	argv[2]="8103";	
	argc=3;
	BotConnector bc2(argc, argv);
	if( bc2.connect() )
	{
		printf( "Connected to Robot2\n" );
	}
	else
	{
		printf( "Connection attempt to Robot failed, Sorry :(\n" );
		return EXIT_SUCCESS;
	}
bc2.moveRobot(2000,90);
//bc2.setRobotVelocity(100,100, 20000);
bc2.moveRobot(2000,-45);
//bc2.setRobotVelocity(200,200, 25000);
bc2.moveRobot(0,135);
/*	argv[1]="-rrtp";
  argv[2]="8104";
  argc=3;
  BotConnector bc3(argc, argv);
  if( bc3.connect() )
  {
          printf( "Connected to Robot\n" );
  }
  else
  {
          printf( "Connection attempt to Robot failed, Sorry :(\n" );
          return EXIT_SUCCESS;
  }
//bc.setVelocity1(-100,-100, 10000);
bc3.moveRobot(0,90);
bc3.setRobotVelocity(150,150, 30000);
bc3.moveRobot(0,-125);
bc3.setRobotVelocity(100,100, 20000);
bc3.moveRobot(0,180);*/
/*argv[1]="-rrtp";
  argv[2]="8105";
  argc=3;
  BotConnector bc4(argc, argv);
  if( bc4.connect() )
  {
          printf( "Connected to Robot\n" );
  }
  else
  {
          printf( "Connection attempt to Robot failed, Sorry :(\n" );
          return EXIT_SUCCESS;
  }
//bc.setVelocity1(-100,-100, 10000);
bc4.getAngles(4);
bc4.moveRobot(0,90);
bc4.setRobotVelocity(100,100, 40000);
bc4.moveRobot(0,0);
bc4.setRobotVelocity(200,200, 25000);
bc4.moveRobot(0,180);
argv[1]="-rrtp";
  argv[2]="8106";
  argc=3;
  BotConnector bc5(argc, argv);
  if( bc5.connect() )
  {
          printf( "Connected to Robot\n" );
  }
  else
  {
          printf( "Connection attempt to Robot failed, Sorry :(\n" );
          return EXIT_SUCCESS;
  }
//bc.setVelocity1(-100,-100, 10000);
bc5.getAngles(5);
bc5.moveRobot(0,90);
bc5.setRobotVelocity(200,200, 25000);
bc5.moveRobot(0,-80);
bc5.setRobotVelocity(300,300, 15000);
bc5.moveRobot(0,180);*/
bc.setRobotVelocity(-100,-100, 10000);
bc.moveRobot(0,90);
bc.getAngles(0);
bc1.getAngles(1);
bc2.getAngles(2);
omnicx = ra[0][1];
omnicy = ra[0][2]+300;
//bc3.getAngles(3);
/*bc4.getAngles(4);
bc5.getAngles(5);*/
 ArUtil::sleep(5000);
	
	int f;
	for(f=0;f<200;f++)
	{
			float dest,dest1;
			int j;
			dest = tan_inv((dest_y-omnicy),(dest_x-omnicx));
			j=update(dest);
			right_left();
		//	robot_motion();
 			bc.setRobotVelocity_idle(vright,vleft);
         		 bc1.setRobotVelocity_idle(100,100);
	  		bc2.setRobotVelocity_idle(100,100);
			// bc3.setRobotVelocity_idle(250,250);
          		/*bc4.setRobotVelocity_idle(250,250);
          		bc5.setRobotVelocity_idle(250,250);*/
			 ArUtil::sleep(300);
          		bc.getAngles(0);
          		bc1.getAngles(1);
         		 bc2.getAngles(2);
			//bc3.getAngles(3);
			omnicx = omnicx+ra[0][3]*0.3;
			omnicy = omnicy+ra[0][4]*0.3;
			/*bc.setRobotVelocity_idle(0,0);
         		 bc1.setRobotVelocity_idle(0,0);
	  		bc2.setRobotVelocity_idle(0,0);
			 bc3.setRobotVelocity_idle(0,0);*/
		//	omnicx = ra[0][1]+ra[0][5]*cos(ra[0][0]);
//omnicy = ra[0][2]+ra[0][5]*sin(ra[0][0]);
			printf("omnicx = %f, omnicy = %f\n",omnicx,omnicy);
			printf("x = %d",f);
		/*	bc3.getAngles(3);
			bc4.getAngles(4);
			bc5.getAngles(5);*/
	}
	return bc.disconnect();
}
Example #15
0
 int64_t getInt() {
     int64_t res = bc()->getInt64(bci_);
     bci_ += sizeof(int64_t);
     return res;
 }
Example #16
0
main() 
{
int 
x_a[] = {1, 10, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, };
int 
x_b
=8888;
int 
x_e
=8888;
int 
x_c[] = {-4, 3, 4444, 4444, 4444, 4444, };
for(
x_b
=
1
;
x_b
<=
10
;
x_b
++)
{
printf("%d\n", 
x_b
);
printf("%d\n", 
x_a[bc(x_a, 5, 
x_b
, 'a')]
);
}
for(
x_b
=
0
-
4
;
x_b
<=
0
-
2
;
x_b
++)
{
printf("%d\n", 
x_b
);
printf("%d\n", 
x_c[bc(x_c, 10, 
x_b
, 'c')]
);
}
for(
x_b
=
1
;
x_b
<=
10
;
x_b
++)
{
x_a[bc(x_a, 14, 
x_b
, 'a')]
=
100
-
x_b
;
}
for(
x_b
=
1
;
x_b
<=
10
;
x_b
++)
{
printf("%d\n", 
x_b
);
printf("%d\n", 
x_a[bc(x_a, 19, 
x_b
, 'a')]
);
}
for(
x_b
=
1
;
x_b
<=
9
;
x_b
++)
{
for(
x_e
=
x_b
+
1
;
x_e
<=
11
;
x_e
++)
{
if(
x_a[bc(x_a, 25, 
x_b
, 'a')]
>
x_a[bc(x_a, 25, 
x_e
, 'a')]
)
{
int 
x_t
=8888;
x_t
=
x_a[bc(x_a, 27, 
x_b
, 'a')]
;
x_a[bc(x_a, 28, 
x_b
, 'a')]
=
x_a[bc(x_a, 28, 
x_e
, 'a')]
;
x_a[bc(x_a, 29, 
x_e
, 'a')]
=
x_t
;
}
}
}
for(
x_b
=
1
;
x_b
<=
10
;
x_b
++)
{
printf("%d\n", 
x_b
);
printf("%d\n", 
x_a[bc(x_a, 36, 
x_b
, 'a')]
);
}
}
Example #17
0
 uint16_t getUInt16() {
     uint16_t res = bc()->getUInt16(bci_);
     bci_ += sizeof(uint16_t);
     return res;
 }
Example #18
0
void TriangleMesherInterface :: simplifyPSLG(Triangle_PSLG &coarse, const Triangle_PSLG &pslg, double limit, double minlen)
{
    int segments = pslg.segment_a.giveSize();
    int nodes = pslg.nx.giveSize();

    // Calculate the inverted connection node->element
    std :: set< int > *connectivity = new std :: set< int > [ nodes ];
    for ( int i = 0; i < segments; i++ ) {
        connectivity [ pslg.segment_a[i] - 1 ].insert(i + 1);
        connectivity [ pslg.segment_b[i] - 1 ].insert(i + 1);
    }

    // Some conservative error measure
    IntArray nodeRemoval(nodes);
    IntArray edgeRemoval(segments);
    edgeRemoval.zero();
    IntArray seg_a = pslg.segment_a;
    IntArray seg_b = pslg.segment_b;

    nodeRemoval.zero();
    FloatArray error_x(nodes), error_y(nodes), ab(2), ac(2), bc(2), err_vec(2);
    error_x.zero();
    error_y.zero();

    for ( int j = 0; j < 2; ++j ) {
        double allowed = j * limit / 2;
        for ( int i = 1; i <= nodes; i++ ) {
            std :: set< int > &elems = connectivity [ i - 1 ];
#if 1
            if ( elems.size() < 2 ) {
                // Lone nodes or edges are removed. It is up for discussion whether or not this is a wanted.
                nodeRemoval.at(i) = true;
                if ( elems.size() == 1 ) {
                    int e0 = * elems.begin();
                    edgeRemoval.at(e0) = true;
                    // Find the other node and remove segment e0 from it;
                    int n1 = seg_a.at(e0) == i ? seg_b.at(e0) : seg_a.at(e0);
                    connectivity [ n1 - 1 ].erase(e0);
                    elems.clear();
                    /*printf("Removing edge %d and node = %d\n", e0, n1);
                     * while (connectivity[n1-1].size() < 2) {
                     *  nodeRemoval.at(n1) = true;
                     *  if (connectivity[n1-1].size() == 1) {
                     *      e0 = *connectivity[n1-1].begin();
                     *      edgeRemoval.at(e0) = true;
                     *      connectivity[n1-1].clear();
                     *      n1 = seg_a.at(e0) == i ? seg_b.at(e0) : seg_a.at(e0);
                     *      connectivity[n1-1].erase(e0);
                     *  } else {
                     *      OOFEM_WARNING("HAPPENS ONCE!");
                     *      break;
                     *  }
                     * }*/
                }
            } else
#endif
            if ( elems.size() == 2 ) {
                int e0 = * elems.begin();
                int e1 = * ( ++elems.begin() );
                if ( pslg.segment_marker.at(e0) == pslg.segment_marker.at(e1) ) {
                    double abac, acac;
                    int n0, n1, n2;

                    n0 = seg_a.at(e0) == i ? seg_b.at(e0) : seg_a.at(e0);
                    n1 = i;
                    n2 = seg_a.at(e1) == i ? seg_b.at(e1) : seg_a.at(e1);

                    ab[0] = pslg.nx.at(n1) - pslg.nx.at(n0);
                    ab[1] = pslg.ny.at(n1) - pslg.ny.at(n0);
                    ac[0] = pslg.nx.at(n2) - pslg.nx.at(n0);
                    ac[1] = pslg.ny.at(n2) - pslg.ny.at(n0);

                    abac = ab.dotProduct(ac);
                    acac = ac.computeSquaredNorm();

                    // Find the error (how far the point would be moved to obtain the following line without it).
                    if ( abac <= 0 || acac == 0 ) { // then -ab
                        err_vec[0] = -ab[0];
                        err_vec[1] = -ab[1];
                    } else if ( abac >= acac ) { // then bc
                        err_vec[0] = pslg.nx.at(n2) - pslg.nx.at(n1);
                        err_vec[1] = pslg.ny.at(n2) - pslg.ny.at(n1);
                    } else {
                        err_vec = ac;
                        err_vec.times(abac / acac);
                        err_vec.subtract(ab);
                    }

                    double ev_norm = err_vec.computeNorm();
                    // Max of new or old error;
                    double real_error = 0.0;
                    if ( ev_norm == 0 ) {
                        real_error = 0.0;
                    } else {
                        error_x.at(n1) += err_vec[0];
                        error_y.at(n1) += err_vec[1];
                        real_error = sqrt( error_x.at(n1) * error_x.at(n1) + error_y.at(n1) * error_y.at(n1) );
                    }

                    if ( real_error <= allowed ) {
                        // Mark node for removal, remove second edge, more first edge connection to next node;
                        nodeRemoval.at(i) = true;
                        edgeRemoval.at(e1) = true;
                        connectivity [ n2 - 1 ].erase(e1);
                        connectivity [ n2 - 1 ].insert(e0);
                        if ( seg_a.at(e0) == n1 ) { // Doing the bothersome way to preserve direction of segments.
                            seg_a.at(e0) = n2;
                        } else {
                            seg_b.at(e0) = n2;
                        }
                        elems.clear();
                        // Accumulate the error vector
                        error_x.at(n0) += error_x.at(n1);
                        error_y.at(n0) += error_y.at(n1);
                        error_x.at(n2) += error_x.at(n1);
                        error_y.at(n2) += error_y.at(n1);
                    }
                }
            }
        }
    }

    // Deleting the elements which are too short.
    bool edgeRemoved = true;
    while ( edgeRemoved ) {
        edgeRemoved = false;
        for ( int i = 1; i <= nodes; i++ ) {
            std :: set< int > &elems = connectivity [ i - 1 ];
            if ( elems.size() == 2 ) {
                int e0 = * elems.begin();
                int e1 = * ( ++elems.begin() );
                if ( pslg.segment_marker.at(e0) == pslg.segment_marker.at(e1) ) {
                    int n0, n1, n2;

                    n0 = seg_a.at(e0) == i ? seg_b.at(e0) : seg_a.at(e0);
                    n1 = i;
                    n2 = seg_a.at(e1) == i ? seg_b.at(e1) : seg_a.at(e1);

                    ab[0] = pslg.nx.at(n1) - pslg.nx.at(n0);
                    ab[1] = pslg.ny.at(n1) - pslg.ny.at(n0);
                    bc[0] = pslg.nx.at(n2) - pslg.nx.at(n1);
                    bc[1] = pslg.ny.at(n2) - pslg.ny.at(n1);

                    if ( ab.computeSquaredNorm() < minlen * minlen || bc.computeSquaredNorm() < minlen * minlen ) {
                        // Mark node for removal, remove second edge, more first edge connection to next node;
                        nodeRemoval.at(i) = true;
                        edgeRemoval.at(e1) = true;
                        connectivity [ n2 - 1 ].erase(e1);
                        connectivity [ n2 - 1 ].insert(e0);
                        if ( seg_a.at(e0) == n1 ) { // Doing the bothersome way to preserve direction of segments.
                            seg_a.at(e0) = n2;
                        } else {
                            seg_b.at(e0) = n2;
                        }
                        elems.clear();
                        edgeRemoved = true;
                    }
                }
            }
        }
    }


    // Remove simple double-connections like o<--->o
    for ( int i = 1; i <= nodes; i++ ) {
        std :: set< int > &elems = connectivity [ i - 1 ];
        if ( elems.size() == 2 ) {
            int e0 = * elems.begin();
            int e1 = * ( ++elems.begin() );
            int n0 = seg_a.at(e0) == i ? seg_b.at(e0) : seg_a.at(e0);
            int n1 = i;
            int n2 = seg_a.at(e1) == i ? seg_b.at(e1) : seg_a.at(e1);

            if ( n0 == n2 ) {
                // Then we have a simple double connection. We get rid of this node and the two edges.
                nodeRemoval.at(n1) = true;
                edgeRemoval.at(e0) = true;
                edgeRemoval.at(e1) = true;
                connectivity [ n1 - 1 ].erase(e0);
                connectivity [ n1 - 1 ].erase(e1);
                connectivity [ n2 - 1 ].erase(e0);
                connectivity [ n2 - 1 ].erase(e1);
                if ( connectivity [ n1 - 1 ].size() == 0 ) {
                    nodeRemoval.at(n2) = true;
                }
            }
        }
    }

    delete[] connectivity;

    // Cleanup
    int newNodes = 0;
    IntArray newNumber(nodes);
    newNumber.zero();
    coarse.nx.resize(nodes);
    coarse.ny.resize(nodes);
    for ( int i = 1; i <= nodes; i++ ) {
        if ( !nodeRemoval.at(i) ) {
            newNodes++;
            coarse.nx.at(newNodes) = pslg.nx.at(i);
            coarse.ny.at(newNodes) = pslg.ny.at(i);
            newNumber.at(i) = newNodes;
        }
    }
    coarse.nx.resize(newNodes);
    coarse.ny.resize(newNodes);

    int newSegments = 0;
    coarse.segment_a.resize(segments);
    coarse.segment_b.resize(segments);
    coarse.segment_marker.resize(segments);

    for ( int i = 1; i <= segments; i++ ) {
        if ( !edgeRemoval.at(i) ) {
            newSegments++;
            coarse.segment_a.at(newSegments) = newNumber.at( seg_a.at(i) );
            coarse.segment_b.at(newSegments) = newNumber.at( seg_b.at(i) );
            coarse.segment_marker.at(newSegments) = pslg.segment_marker.at(i);
        }
    }
    coarse.segment_a.resize(newSegments);
    coarse.segment_b.resize(newSegments);
    coarse.segment_marker.resize(newSegments);
}
Example #19
0
 double getDouble() {
     double res = bc()->getDouble(bci_);
     bci_ += sizeof(double);
     return res;
 }
Example #20
0
main() 
{
int 
x_a[] = {1, 10, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, };
int 
x_b[] = {1, 10, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, };
int 
x_k
=8888;
{
int 
x_x
;

int indexx;
for(
indexx=(
x_a
[1]-1);indexx>=0;indexx--)
{
x_x
 = 
indexx+
x_a
[0];
{
x_a[bc(x_a, 4, 
x_x
, 'a')]
=
1000
-
x_x
;
}
	}
}
{
int 
x_x
;

int indexx;
for(
indexx=0;indexx<
x_a
[1];indexx++)
{
x_x
 = 
x_a
[indexx+2];
{
printf("%d\n", 
x_x
);
x_a[bc(x_a, 9, 
5
, 'a')]
=
100
;
}
	}
}
{
int 
x_x
;

int indexx;
for(
indexx=(
x_b
[1]-1);indexx>=0;indexx--)
{
x_x
 = 
indexx+
x_b
[0];
{
x_b[bc(x_b, 13, 
x_x
, 'b')]
=
3000
-
x_x
;
}
	}
}
x_k
=
0
;
{
int 
x_x
;

int indexx;
for(
indexx=0;indexx<
x_b
[1];indexx++)
{
x_x
 = 
x_b
[indexx+2];
{
x_k
=
x_k
+
1
;
x_b[bc(x_b, 20, 
x_k
, 'b')]
=
9000
-
x_k
;
printf("%d\n", 
x_x
);
}
	}
}
{
int 
x_x
;

int indexx;
for(
indexx=0;indexx<
x_b
[1];indexx++)
{
x_x
 = 
x_b
[indexx+2];
{
printf("%d\n", 
x_x
);
}
	}
}
}
Example #21
0
    // can be instantiated with
    // <edge::Rp, edge::Wp> or <edge::Up, edge::Up>.
bool reconsider(edgeWp self, const int seam,
                edge::Sp& e1, edge::Sp& e2, edge::Sp& e3, edge::Sp& e4) {
    e1 = edge::Sp(NULL);  e2 = edge::Sp(NULL);
    e3 = edge::Sp(NULL);  e4 = edge::Sp(NULL);
    self->set_tentative(false, self);
    point* a = self->get_points(0, self);
    assert (txnal<edgeRp>() || closest_seam(a) == seam);
    point* b = self->get_points(1, self);
    assert (txnal<edgeRp>() || closest_seam(b) == seam);
    edgeRp ac(self->get_neighbors(0, ccw, self));
    edgeRp bc(self->get_neighbors(1, cw, self));
    point* c = ac->get_points(1-index_of(ac, a), ac);
    // a and b are assumed to be closest to my seam.
    // I have to check c and d.
    if (!txnal<edgeRp>() && closest_seam(c) != seam) {
        // I can't safely consider this flip in this phase of
        // the algorithm.  Defer to synchronized phase.
        self->set_tentative(true, self);
        return false;
    }
    if (c != bc->get_points(1-index_of(bc, b), bc)) {
        // No triangle on the c side; we're an external edge
        return true;
    }
    edgeRp ad(self->get_neighbors(0, cw, self));
    edgeRp bd(self->get_neighbors(1, ccw, self));
    point* d = ad->get_points(1-index_of(ad, a), ad);
    if (!txnal<edgeRp>() && closest_seam(d) != seam) {
        // I can't safely consider this flip in this phase of
        // the algorithm.  Defer to synchronized phase.
        self->set_tentative(true, self);
        return false;
    }
    if (d != bd->get_points(1-index_of(bd, b), bd)) {
        // No triangle on the d side; we're an external edge
        return true;
    }
    if (encircled(b, c, a, d, ccw) || encircled(a, d, b, c, ccw)) {
        // other diagonal is locally Delaunay; we're not
        destroy(self);      // can't wait for delayed destructor
        edgeWp ac_w(ac);  edgeWp ad_w(ad);
        edgeWp bc_w(bc);  edgeWp bd_w(bd);
        edge::Sp dum;
        edge::create(c, d, bc_w, bd_w, cw, dum);
            // Aliasing problem here: since edge constructor modifies
            // neighbors, I can't safely use ac, bc, ad, or bd after this
            // call.  Must use writable versions instead.
        if (!ac_w->get_tentative(ac_w)) {
            ac_w->set_tentative(true, ac_w);  e1 = ac_w;
        }
        if (!ad_w->get_tentative(ad_w)) {
            ad_w->set_tentative(true, ad_w);  e2 = ad_w;
        }
        if (!bc_w->get_tentative(bc_w)) {
            bc_w->set_tentative(true, bc_w);  e3 = bc_w;
        }
        if (!bd_w->get_tentative(bd_w)) {
            bd_w->set_tentative(true, bd_w);  e4 = bd_w;
        }
    }
    return true;
}
Example #22
0
void BwCtrlWindow::updateBandwidth()
{
	QTreeWidget *peerTreeWidget = bwTreeWidget;

	peerTreeWidget->clear();

	RsConfigDataRates totalRates;
	std::map<RsPeerId, RsConfigDataRates> rateMap;
	std::map<RsPeerId, RsConfigDataRates>::iterator it;

    rsConfig->getTotalBandwidthRates(totalRates);
	rsConfig->getAllBandwidthRates(rateMap);

			/* insert */
	QTreeWidgetItem *item = new QTreeWidgetItem();
	peerTreeWidget->addTopLevelItem(item);
	peerTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
	
	/* do Totals */
	item -> setData(COLUMN_PEERID, Qt::DisplayRole, tr("TOTALS"));
	item -> setData(COLUMN_RSNAME, Qt::DisplayRole, tr("Totals"));

	item -> setData(COLUMN_IN_RATE, Qt::DisplayRole, totalRates.mRateIn);
	item -> setData(COLUMN_IN_MAX, Qt::DisplayRole,totalRates.mRateMaxIn);
	item -> setData(COLUMN_IN_QUEUE, Qt::DisplayRole, totalRates.mQueueIn);
	item -> setData(COLUMN_IN_ALLOC, Qt::DisplayRole, std::numeric_limits<float>::max());
	item -> setData(COLUMN_IN_ALLOC_SENT, Qt::DisplayRole, std::numeric_limits<qint64>::max());

	item -> setData(COLUMN_OUT_RATE, Qt::DisplayRole, totalRates.mRateOut);
	item -> setData(COLUMN_OUT_MAX, Qt::DisplayRole, totalRates.mRateMaxOut);
	item -> setData(COLUMN_OUT_QUEUE, Qt::DisplayRole, totalRates.mQueueOut);
	item -> setData(COLUMN_OUT_ALLOC, Qt::DisplayRole, std::numeric_limits<float>::max());
	item -> setData(COLUMN_OUT_ALLOC_SENT, Qt::DisplayRole, std::numeric_limits<qint64>::max());

	time_t now = time(NULL);
	for(it = rateMap.begin(); it != rateMap.end(); ++it)
	{
		/* find the entry */
		QTreeWidgetItem *peer_item = NULL;
#if 0
		QString qpeerid = QString::fromStdString(*it);
		int itemCount = peerTreeWidget->topLevelItemCount();
		for (int nIndex = 0; nIndex < itemCount; ++nIndex)
		{
			QTreeWidgetItem *tmp_item = peerTreeWidget->topLevelItem(nIndex);
			if (tmp_item->data(COLUMN_PEERID, Qt::DisplayRole).toString() == qpeerid)
			{
				peer_item = tmp_item;
				break;
			}
		}
#endif

		if (!peer_item)
		{
			/* insert */
			peer_item = new QTreeWidgetItem();
			peerTreeWidget->addTopLevelItem(peer_item);
		}

		std::string name = rsPeers->getPeerName(it->first);

		peer_item -> setData(COLUMN_PEERID, Qt::DisplayRole, QString::fromStdString(it->first.toStdString()));
		peer_item -> setData(COLUMN_RSNAME, Qt::DisplayRole, QString::fromStdString(name));

		peer_item -> setData(COLUMN_IN_RATE, Qt::DisplayRole, it->second.mRateIn);
		peer_item -> setData(COLUMN_IN_MAX, Qt::DisplayRole, it->second.mRateMaxIn);
		peer_item -> setData(COLUMN_IN_QUEUE, Qt::DisplayRole, it->second.mQueueIn);
		peer_item -> setData(COLUMN_IN_ALLOC, Qt::DisplayRole, it->second.mAllocIn);
		peer_item -> setData(COLUMN_IN_ALLOC_SENT, Qt::DisplayRole, qint64(now - it->second.mAllocTs));

		peer_item -> setData(COLUMN_OUT_RATE, Qt::DisplayRole, it->second.mRateOut);
		peer_item -> setData(COLUMN_OUT_MAX, Qt::DisplayRole, it->second.mRateMaxOut);
		peer_item -> setData(COLUMN_OUT_QUEUE, Qt::DisplayRole, it->second.mQueueOut);
		if (it->second.mAllowedTs != 0)
		{
			peer_item -> setData(COLUMN_OUT_ALLOC, Qt::DisplayRole, it->second.mAllowedOut);
			peer_item -> setData(COLUMN_OUT_ALLOC_SENT, Qt::DisplayRole,qint64(now - it->second.mAllowedTs));
		}
		else
		{
			peer_item -> setData(COLUMN_OUT_ALLOC, Qt::DisplayRole, std::numeric_limits<float>::max());
			peer_item -> setData(COLUMN_OUT_ALLOC_SENT, Qt::DisplayRole, std::numeric_limits<qint64>::max());
		}


		/* colour the columns */
		if (it->second.mAllowedTs != 0)
		{
			if (it->second.mAllowedOut < it->second.mRateOut)
			{	
				/* RED */
				QColor bc("#ff4444"); // red
				peer_item -> setBackground(COLUMN_OUT_RATE,QBrush(bc));
	
			}
			else if (it->second.mAllowedOut < it->second.mRateMaxOut)
			{
				/* YELLOW */
				QColor bc("#ffff66"); // yellow
				peer_item -> setBackground(COLUMN_OUT_MAX,QBrush(bc));
	
			}
			else
			{
				/* GREEN */
				QColor bc("#44ff44");//bright green
				peer_item -> setBackground(COLUMN_OUT_ALLOC,QBrush(bc));
			}
		}
		else
		{
			/* GRAY */
			QColor bc("#444444");// gray
			peer_item -> setBackground(COLUMN_OUT_ALLOC,QBrush(bc));
			peer_item -> setBackground(COLUMN_OUT_ALLOC_SENT,QBrush(bc));

		}

		/* queueOut */
#define QUEUE_RED	10000
#define QUEUE_ORANGE	2000
#define QUEUE_YELLOW	500

		if (it->second.mQueueOut > QUEUE_RED)
		{	
			/* RED */
			QColor bc("#ff4444"); // red
			peer_item -> setBackground(COLUMN_OUT_QUEUE,QBrush(bc));
	
		}
		else if (it->second.mQueueOut > QUEUE_ORANGE)
		{
			/* ORANGE */
			QColor bc("#ff9900"); //orange
			peer_item -> setBackground(COLUMN_OUT_QUEUE,QBrush(bc));

		}
		else if (it->second.mQueueOut > QUEUE_YELLOW)
		{
			/* YELLOW */
			QColor bc("#ffff66"); // yellow
			peer_item -> setBackground(COLUMN_OUT_QUEUE,QBrush(bc));

		}
		else
		{
			/* GREEN */
			QColor bc("#44ff44");//bright green
			peer_item -> setBackground(COLUMN_OUT_QUEUE,QBrush(bc));
		}
	}
}
Example #23
0
void testInitialzation(const Teuchos::RCP<Teuchos::ParameterList>& ipb,
                       std::vector<panzer::BC>& bcs)
{
    // Physics block
    Teuchos::ParameterList& physics_block = ipb->sublist("test physics");
    {
        Teuchos::ParameterList& p = physics_block.sublist("a");
        p.set("Type","Energy");
        p.set("Prefix","");
        p.set("Model ID","solid");
        p.set("Basis Type","HGrad");
        p.set("Basis Order",2);
    }
    {
        Teuchos::ParameterList& p = physics_block.sublist("b");
        p.set("Type","Energy");
        p.set("Prefix","ION_");
        p.set("Model ID","ion solid");
        p.set("Basis Type","HGrad");
        p.set("Basis Order",1);
    }

    {
        std::size_t bc_id = 0;
        panzer::BCType neumann = BCT_Dirichlet;
        std::string sideset_id = "left";
        std::string element_block_id = "eblock-0_0";
        std::string dof_name = "TEMPERATURE";
        std::string strategy = "Constant";
        double value = 5.0;
        Teuchos::ParameterList p;
        p.set("Value",value);
        panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
                      strategy, p);
        bcs.push_back(bc);
    }
    {
        std::size_t bc_id = 1;
        panzer::BCType neumann = BCT_Dirichlet;
        std::string sideset_id = "right";
        std::string element_block_id = "eblock-1_0";
        std::string dof_name = "TEMPERATURE";
        std::string strategy = "Constant";
        double value = 5.0;
        Teuchos::ParameterList p;
        p.set("Value",value);
        panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
                      strategy, p);
        bcs.push_back(bc);
    }
    {
        std::size_t bc_id = 2;
        panzer::BCType neumann = BCT_Dirichlet;
        std::string sideset_id = "top";
        std::string element_block_id = "eblock-1_0";
        std::string dof_name = "TEMPERATURE";
        std::string strategy = "Constant";
        double value = 5.0;
        Teuchos::ParameterList p;
        p.set("Value",value);
        panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
                      strategy, p);
        bcs.push_back(bc);
    }
}
Example #24
0
main()
{
    int
    x_a[] = {1, 10, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, 4444, };
    int
    x_b
        =8888;
    int
    x_x
        =8888;
    int
    x_c[] = {-4, 3, 4444, 4444, 4444, 4444, };
    x_x
        =
            12
            ;
    for(
        x_b
        =
            1
            ;
        x_b
        <=
        10
        ;
        x_b
        ++)
    {
        x_a[bc(x_a, 6,
               x_b
               , 'a')]
            =
                100
                +
                x_b
                ;
    }
    for(
        x_b
        =
            0
            -
            2
            ;
        x_b
        >=
        0
        -
        4
        ;
        x_b
        --)
    {
        x_c[bc(x_c, 10,
               x_b
               , 'c')]
            =
                1000
                -
                x_b
                ;
    }
    printf(
        "%s\n", "element forward x: a"
    );
    {
        int
        x_x
        ;

        int indexx;
        for(
            indexx=0; indexx<
            x_a
            [1]; indexx++)
        {
            x_x
                =
                    x_a
                    [indexx+2];
            {
                printf("%d\n",
                       x_x
                      );
            }
        }
    }
    printf("%d\n",
           x_x
          );
}
double snlCtrlPointNetSurface::calcFlatness ( int indexU, int indexV, int numPointsU, int numPointsV )
{
    // Calculate flatness of a rectangular section of control points.
    // --------------------------------------------------------------
    // indexU:      U index of starting position in control point net.
    // indexV:      V index of starting position in control point net.
    // numPointsU:  Number of points in U direction, including starting point, to test.
    // numPointsV:  Number of points in V direction, including starting point, to test.
    //
    // Notes:
    //
    //              Rectangle data orientation:
    //
    //                V     B--------D
    //                      |        |
    //                ^     |        |
    //                |     |        |
    //                |     A--------C
    //
    //                      ----->   U

    // Locate rectangular array of points to process.

    int numPoints = numPointsU * numPointsV;

    snlCtrlPoint** ctrlPointPtrs = new snlCtrlPoint* [ numPoints ];

    locatePoints ( indexU, indexV, numPointsU, numPointsV, ctrlPointPtrs );

    // Pre-calculate vectors and normals.

    // 4 Corners.
    
    int indexB = numPointsV - 1;
    int indexC = numPoints - numPointsV;
    int indexD = numPoints - 1;

    snlCtrlPoint ptA = *(ctrlPointPtrs [ 0 ]);
    ptA.normalise();
    snlCtrlPoint ptB = *(ctrlPointPtrs [ numPointsV - 1 ]);
    ptB.normalise();
    snlCtrlPoint ptC = *(ctrlPointPtrs [ numPoints - numPointsV ]);
    ptC.normalise();
    snlCtrlPoint ptD = *(ctrlPointPtrs [ numPoints - 1 ]);
    ptD.normalise();

    // Side Vectors.
    
    snlVector ab ( ptA, ptB );
    ab.unitise();
    
    snlVector ba = ab * -1.0;

    snlVector ac ( ptA, ptC );
    ac.unitise();

    snlVector ca = ac * -1.0;

    snlVector bd ( ptB, ptD );
    bd.unitise();

    snlVector db = bd * -1.0;

    snlVector cd ( ptC, ptD );
    cd.unitise();

    snlVector dc = cd * -1.0;

    // Diagonal Vectors.

    snlVector bc ( ptB, ptC );
    snlVector ad ( ptA, ptD );

    // Normals.

    snlVector normA ( ac, ab );
    snlVector normB ( ba, bd );
    snlVector normC ( cd, ca );
    snlVector normD ( db, dc );

    // Project each point of the rectangle, not on the corners, onto the 4 base triangles.
    // If the projection does not lay on a triangle, it is not considered in any further flatness
    // calculations. If a point does not have any projections that lay on one of the four triangles
    // then the closest distance to one of the 6 vectors defining the 4 triangles is taken
    // as the flatness.

    double maxDistance = 0.0;  // Maximum distance or "flatness".

    for ( int index = 0; index < indexD; index ++ )
    {
        if ( ! index || index == indexB || index == indexC ) continue;  // Don't process the corners.

        bool interiorFound = false;  // True if at least one triangle contains projection.

        snlCtrlPoint t = *(ctrlPointPtrs [ index ]);
        t.normalise();

        // Project point to and compare to triangle rooted at A.

        snlVector toProj ( ptA, t );

        snlVector projVect = toProj.project ( normA );

        snlPoint projPoint = t - projVect;

        double projDist = projVect.length();

        bool isInterior = isInteriorToTriangle ( projPoint, ptA, ab, ac, ptB, ba, bc );

        if ( isInterior ) interiorFound = true;

        if ( isInterior &&  maxDistance < projDist ) maxDistance = projDist;

        // Project point to and compare to triangle rooted at B.

        toProj.calc ( ptB, t );

        projVect = toProj.project ( normB );

        projPoint = t - projVect;

        projDist = projVect.length();

        isInterior = isInteriorToTriangle ( projPoint, ptB, ba, bd, ptA, ab, ad );

        if ( isInterior ) interiorFound = true;

        if ( isInterior &&  maxDistance < projDist ) maxDistance = projDist;
        
        // Project point to and compare to triangle rooted at C.

        toProj.calc ( ptC, t );

        projVect = toProj.project ( normC );

        projPoint = t - projVect;

        projDist = projVect.length();

        isInterior = isInteriorToTriangle ( projPoint, ptC, ca, cd, ptA, ac, ad );

        if ( isInterior ) interiorFound = true;

        if ( isInterior &&  maxDistance < projDist ) maxDistance = projDist;
        
        // Project point to and compare to triangle rooted at D.

        toProj.calc ( ptD, t );

        projVect = toProj.project ( normD );

        projPoint = t - projVect;

        projDist = projVect.length();

        isInterior = isInteriorToTriangle ( projPoint, ptD, db, dc, ptB, bd, bc );

        if ( isInterior ) interiorFound = true;

        if ( isInterior &&  maxDistance < projDist ) maxDistance = projDist;
        
        // If no triangle contains a projection then project to the six triangle outlines and take _smallest_ value

        if ( ! interiorFound )
        {
            toProj.calc ( ptA, t );

            double projMaxDistance = ab.projectDist ( toProj );  // A -> B.

            double projDist = ac.projectDist ( toProj );  // A -> C.

            if ( projDist < projMaxDistance ) projMaxDistance = projDist;

            projDist = ad.projectDist ( toProj );  // A -> D.

            if ( projDist < projMaxDistance ) projMaxDistance = projDist;

            toProj.calc ( ptD, t );

            projDist = db.projectDist ( toProj );  // D -> B.

            if ( projDist < projMaxDistance ) projMaxDistance = projDist;

            projDist = dc.projectDist ( toProj );  // D -> C.

            if ( projDist < projMaxDistance ) projMaxDistance = projDist;

            toProj.calc ( ptB, t );

            projDist = bc.projectDist ( toProj );  // B -> C.

            if ( projDist < projMaxDistance ) projMaxDistance = projDist;

            if ( maxDistance < projMaxDistance ) maxDistance = projMaxDistance;
        }
    }

    return maxDistance;
}
Example #26
0
void Cone::tesselate( int nTheta, int nHeight,
	std::vector< Vector4f >& positions,
	std::vector< Vector3f >& normals )
{
	positions.clear();
	normals.clear();

	positions.reserve( 6 * nTheta * nHeight );
	normals.reserve( 6 * nTheta * nHeight );

	float dt = MathUtils::TWO_PI / nTheta;
	float dh = height / nHeight;

	Vector4f bc( baseCenter, 0 );

	for( int t = 0; t < nTheta; ++t )
	{
		float t0 = t * dt;
		float t1 = t0 + dt;

		for( int h = 0; h < nHeight; ++h )
		{
			float h0 = h * dh;
			float h1 = h0 + dh;

			float r0 = baseRadius * ( 1 - h0 / height );
			float r1 = baseRadius * ( 1 - h1 / height );

			float x00 = r0 * cosf( t0 );
			float y00 = r0 * sinf( t0 );
			float x10 = r0 * cosf( t1 );
			float y10 = r0 * sinf( t1 );
			float x01 = r1 * cosf( t0 );
			float y01 = r1 * sinf( t0 );
			float x11 = r1 * cosf( t1 );
			float y11 = r1 * sinf( t1 );

			Vector4f v00 = bc + Vector4f( x00, y00, h0, 1 );
			Vector3f n00( x00, y00, r0 / sqrtf( r0 * r0 + h0 * h0 ) );
			n00.normalize();

			Vector4f v10 = bc + Vector4f( x10, y10, h0, 1 );
			Vector3f n10( x10, y10, r0 / sqrtf( r0 * r0 + h0 * h0 ) );
			n10.normalize();

			Vector4f v01 = bc + Vector4f( x01, y01, h1, 1 );
			Vector3f n01( x01, y01, r1 / sqrtf( r1 * r1 + h1 * h1 ) );
			n01.normalize();

			Vector4f v11 = bc + Vector4f( x11, y11, h1, 1 );
			Vector3f n11( x11, y11, r1 / sqrtf( r1 * r1 + h1 * h1 ) );
			n11.normalize();

			positions.push_back( v00 );
			normals.push_back( n00 );
			positions.push_back( v10 );
			normals.push_back( n10 );
			positions.push_back( v01 );
			normals.push_back( n01 );

			positions.push_back( v01 );
			normals.push_back( n01 );
			positions.push_back( v10 );
			normals.push_back( n10 );
			positions.push_back( v11 );
			normals.push_back( n11 );
		}
	}
}
Example #27
0
    return e1->eval(a, b, c, d) ^ e2->eval(a, b, c, d);
  }
};

Expr* const ba() { return new A(); }
Expr* const bb() { return new B(); }
Expr* const bc() { return new C(); }
Expr* const bd() { return new D(); }
Expr* bnot(Expr* const e) { return new Not(e); }
Expr* band(Expr* const e1, Expr* const e2) { return new And(e1, e2); }
Expr* bor(Expr* const e1, Expr* const e2) { return new Or(e1, e2); }
Expr* bxor(Expr* const e1, Expr* const e2) { return new Xor(e1, e2); }

Expr* const knownXor4 =
  band(
      bor(bxor(ba(), bb()), bxor(bc(), bd())),
      bxor(bor(ba(), bb()), bor(bc(), bd())));

bool isXor4(Expr* const e) {
  return !e->eval(true, true, true, true)
      && !e->eval(false, true, true, true)
      && !e->eval(true, false, true, true)
      && !e->eval(false, false, true, true)
      && !e->eval(true, true, false, true)
      && !e->eval(false, true, false, true)
      && !e->eval(true, false, false, true)
      && e->eval(false, false, false, true)
      && !e->eval(true, true, true, false)
      && !e->eval(false, true, true, false)
      && !e->eval(true, false, true, false)
      && e->eval(false, false, true, false)
Example #28
0
 Instruction getInstruction() {
     return bc()->getInsn(bci_++);
 }
Example #29
0
File: x86_sor.c Project: valner/svt
INT main(INT argc, CHAR *argv[]) {
/********** MAIN PROGRAM *********************************
 * Solve Laplace equation using Jacobi iteration method  *
        *
 *********************************************************/
      INT m = M_DEFAULT, mp, k, p, below, above;
      long iter=MAXSTEPS;
      REAL TOL=EPS_DEFAULT, del, gdel,start,finish,mytime;
      CHAR line[80];
      REAL **v, **vt, **vnew;

      
      k = 0; 
      p= 1;
      if(k == 0) {
          fprintf(OUTPUT," Number of args in command line, argc :\n");
          
          fprintf(OUTPUT," argc = %d :\n", argc);
          if (argc >= 2) 
              fprintf(OUTPUT," arg[1]= %s :\n", argv[1]);
          if (argc >= 3) 
              fprintf(OUTPUT," arg[2]= %s :\n", argv[2]);
          
          if (argc >1){
              m=atoi(argv[1]);
              m=MAX_M;
          }  
          
          if (argc >2 ) {
              TOL= atof(argv[2]);
              TOL=EPS;
          }
          
          fprintf(OUTPUT,"Size of interior points, m :\n");
          fprintf(OUTPUT,"m = %d\n",m);
          fprintf(OUTPUT,"Numerical accuracy, eps :\n");
          fprintf(OUTPUT,"eps = %f\n",TOL);

          fprintf(OUTPUT,"Number of processes, p :\n");
          fprintf(OUTPUT,"p = %d\n",p);
          
          start=-time(0);
      }
      
      mp = m/p;
      
      v  = allocate_2D(m, mp);  /* allocate mem for 2D array */
      vt = allocate_2D(mp, m);
      vnew = allocate_2D(mp, m);

      gdel = 1.0;
      iter = 0;

      bc(m, mp, v, k, p); /* initialize and define B.C. for v */
      transpose(m, mp, v, vt);  /* solve for vt */
                                /* driven by need of update_bc_2 */

      replicate(mp, m, vt, vnew);            /* vnew = vt */
      
      REAL ro = 1.0 - pow (PI / (2 * (m + 1)), 2);
      REAL w = 0;
      while (gdel > TOL) {  /* iterate until error below threshold */
        iter++;             /* increment iteration counter */

        if(iter > MAXSTEPS) {
          fprintf(OUTPUT,"Iteration terminated (exceeds %6d", MAXSTEPS);
          fprintf(OUTPUT," )\n");
          return (0);       /* nonconvergent solution */
        }
/* compute new solution according to the Jacobi scheme */
        /*update_jacobi(mp, m, vt, vnew, &del);  [> compute new vt <]*/
        update_sor(mp, m, vt, vnew, &del, w);
        update_w(&w, ro);
            if (del > gdel)
                gdel = del;
          if( k == 0) {
            fprintf(OUTPUT,"iter,del,gdel: %6d, %lf %lf\n",iter,del,gdel);
        }
        update_bc_2( mp, m, vt, k, below, above); /* update b.c. */
      }
      if (k == 0) {
	  finish=time(0);
        mytime=start+finish;
        fprintf(OUTPUT,"Stopped at iteration %d\n",iter);
        fprintf(OUTPUT,"The maximum error = %f\n",gdel);
        fprintf(OUTPUT,"Time = %f\n",mytime);

      }
      if (FILE_OUT) {
	  /* write v to file for use in MATLAB plots */
	  transpose(mp, m, vt, v);
	  write_file( m, mp, v, k, p );
	  
      }

      free(v); free(vt); free(vnew); /* release allocated arrays  */
      
      return (0);
}
Example #30
0
void drawTree(FastVoxelView &vv,Pos3D base,float h)
{
  Pos3D p1(0,0,0),p2(0,0,0),p3(0,0,0);
  Color c(0x99,0x69,0);
  Color bc(0,0xAA,0);

  p1=base;
  p2=base+Pos3D(0,1,0)*h*0.25;
  p3=base+Pos3D(0,1,0)*h*0.5;

  cdebug(p1<<p2<<p3);

  Trunk t(p1,p2,p3,7,5);

  std::list<Trunk> tlist,nlist;

  tlist.push_back(t);

  int rw=h/4;

  float angle=M_PI/1.5; // 30 degrees

  int last=5;

  for(int i=0;i<=last;i++)
    {
      std::cout<<"_______________"<<std::endl;
      std::list<Trunk>::iterator k=tlist.begin();

      for(;k!=tlist.end();k++)
	{
	  Pos3D dir=k->p3 - k->p2;

	  int count=4;

	  std::list<Pos3D> l=splitDir(dir,count,angle,M_PI/count/8.0,0);//M_PI/count,angle/3);

	  std::list<Pos3D>::iterator j=l.begin();

	  for(;j!=l.end();j++)
	    {

	      Pos3D r=*j;


	      r=r*rw;

	      int mi=i+1;
	      // c=Color(mi&1,(mi>>1)&1,(mi>>2)&1);

	      /*	      drawBall(vv,k->p1,4,c);
	      drawBall(vv,k->p2,3,c);
	      drawBall(vv,k->p3,2,c);*/

	      	  
	      draw3Line(vv,k->p1,k->p2,k->p3,c,40,k->w1,k->w2);
	      if(i==last)
		draw3Line(vv,k->p1,k->p2,k->p2,bc,4,2,1);


	      
	      float start=0.6;

	      start+=getRandEq()*0.3;

	      Pos3D sp=bezier(start,
			       k->p1,k->p2,k->p3);
	      //	      Pos3D np(k->p3*2-k->p2+Pos3D(rx,ry,rz));
	      Pos3D np(k->p3*2-k->p2+r);
	      




	      Trunk nt(sp,
		       sp*0.5+np*0.5+getRandPos(rw),
		       np,
		       k->w2,k->w2-1);
	      nlist.push_back(nt);


	    }

	}
      rw*=0.9;
      tlist.clear();
      cdebug(nlist.size());
      tlist=nlist;
      nlist.clear();
    }


  // roots
  std::list<Pos3D> l=splitDir(Pos3D(0,-1,0),4,M_PI/4,0,0);
  
  std::list<Pos3D>::iterator j=l.begin();
  for(;j!=l.end();j++)
    {
      Pos3D n=*j * 10 + base;
      draw3Line(vv,base,base*0.5+n*0.5,n,c,40,t.w1,t.w2);
    }
  

}