void compare_functionals(const Functional &f1, const Functional &f2,
double kT, const Grid &n, double fraccuracy = 1e-15,
double x = 0.001, double fraccuracydoub = 1e-15) {
printf("\n************");
for (unsigned i=0;i<f1.get_name().size();i++) printf("*");
printf("\n* Testing %s *\n", f1.get_name().c_str());
for (unsigned i=0;i<f1.get_name().size();i++) printf("*");
printf("************\n\n");
printf("First energy:\n");
double f1n = f1.integral(kT, n);
print_double("first energy is: ", f1n);
printf("\n");
f1.print_summary("", f1n, f1.get_name().c_str());
printf("Second energy:\n");
double f2n = f2.integral(kT, n);
print_double("second energy is: ", f2n);
printf("\n");
f2.print_summary("", f2n, f2.get_name().c_str());
if (fabs(f1n/f2n - 1) > fraccuracy) {
printf("E1 = %g\n", f1n);
printf("E2 = %g\n", f2n);
printf("FAIL: Error in f(n) is %g\n", f1n/f2n - 1);
errors++;
}
Grid gr1(gd), gr2(gd);
gr1.setZero();
gr2.setZero();
f1.integralgrad(kT, n, &gr1);
f2.integralgrad(kT, n, &gr2);
double err = (gr1-gr2).cwise().abs().maxCoeff();
double mag = gr1.cwise().abs().maxCoeff();
if (err/mag > fraccuracy) {
printf("FAIL: Error in grad %s is %g as a fraction of %g\n", f1.get_name().c_str(), err/mag, mag);
errors++;
}
errors += f1.run_finite_difference_test(f1.get_name().c_str(), kT, n);
double f1x = f1(kT, x);
double f2x = f2(kT, x);
if (1 - fabs(f1x/f2x) > fraccuracydoub) {
printf("FAIL: Error in double %s is %g as a fraction of %g\n", f1.get_name().c_str(),
1 - fabs(f1x/f2x), f2x);
errors++;
}
double f1p = f1.derive(kT, x);
double f2p = f2.derive(kT, x);
if (1 - fabs(f1p/f2p) > fraccuracydoub) {
printf("FAIL: Error in derive double %s is %g as a fraction of %g\n", f1.get_name().c_str(),
1 - fabs(f1p/f2p), f2p);
errors++;
}
//errors += f2.run_finite_difference_test("other version", n);
}
void HeatControl2Delta::main()
{
HeatControl2Delta hc(100, 100, 100);
hc.O.resize(2*hc.L);
hc.O[0] = 0.50;
hc.O[1] = 0.80;
hc.O[2] = 0.70;
hc.O[3] = 0.20;
hc.O[4] = 0.20;
hc.O[5] = 0.30;
hc.initialize();
DoubleVector x(2*hc.L + (hc.M+1)*hc.L);
x[0] = 0.60; x[1] = 0.70; x[2] = 0.65; x[3] = 0.25; x[4] = 0.25; x[5] = 0.35;
for (unsigned int k=0; k<=hc.M; k++)
{
x[2*hc.L + 0*(hc.M+1) + k] = 1.0;//hc.v1(k*hc.ht);
x[2*hc.L + 1*(hc.M+1) + k] = 1.0;//hc.v2(k*hc.ht);
x[2*hc.L + 2*(hc.M+1) + k] = 1.0;//hc.v3(k*hc.ht);
}
/* Minimization */
ConjugateGradient g2;
g2.setFunction(&hc);
g2.setGradient(&hc);
g2.setEpsilon1(0.0001);
g2.setEpsilon2(0.0001);
g2.setEpsilon3(0.0001);
g2.setR1MinimizeEpsilon(1.0, 0.0001);
g2.setPrinter(&hc);
g2.setProjection(&hc);
g2.setNormalize(true);
g2.calculate(x);
DoubleVector gr1(x.length());
IGradient::Gradient(&hc, 0.00001, x, gr1);
gr1.L2Normalize();
DoubleVector gr2(x.length());
hc.gradient(x, gr2);
gr2.L2Normalize();
printf("J[%d]: %.16f\n", 0, hc.fx(x));
printf("eo: [%12.8f, %12.8f] [%12.8f, %12.8f] [%12.8f, %12.8f]\n", hc.O[0], hc.O[1], hc.O[2], hc.O[3], hc.O[4], hc.O[5]);
printf("e1: [%12.8f, %12.8f] [%12.8f, %12.8f] [%12.8f, %12.8f]\n", x[0], x[1], x[2], x[3], x[4], x[5]);
printf("gr1: [%12.8f, %12.8f] [%12.8f, %12.8f] [%12.8f, %12.8f]\n", gr1[0], gr1[1], gr1[2], gr1[3], gr1[4], gr1[5]);
printf("gr2: [%12.8f, %12.8f] [%12.8f, %12.8f] [%12.8f, %12.8f]\n", gr2[0], gr2[1], gr2[2], gr2[3], gr2[4], gr2[5]);
}
void FitSignals(TTree * treeB, TCut cut, Int_t max){
AliSignalProcesor proc;
TF1 * f1 = proc.GetAsymGauss();
TTreeSRedirector cstream("FitSignal.root");
TFile *f = cstream.GetFile();
char lname[100];
sprintf(lname,"Fit%s", cut.GetTitle());
TEventList *list = new TEventList(lname,lname);
sprintf(lname,">>Fit%s", cut.GetTitle());
treeB->Draw(lname,cut);
treeB->SetEventList(list);
Int_t nFits=0;
for (Int_t ievent=0; ievent<list->GetN(); ievent++){
if (nFits>max) break;
if (nFits%50==0) printf("%d\n",nFits);
char ename[100];
sprintf(ename,"Fit%d", ievent);
Double_t nsample = treeB->Draw("Graph.fY-Mean09:Graph.fX","","",1,ievent);
Double_t * signal = treeB->GetV1();
Double_t * time = treeB->GetV2();
Double_t maxpos =0;
Double_t max = 0;
for (Int_t ipos = 0; ipos<nsample; ipos++){
if (signal[ipos]>max){
max = signal[ipos];
maxpos = ipos;
}
}
Int_t first = TMath::Max(maxpos-10,0.);
Int_t last = TMath::Min(maxpos+60, nsample);
//
f->cd();
TH1F his(ename,ename,last-first,first,last);
for (Int_t ipos=0; ipos<last-first; ipos++){
his.SetBinContent(ipos+1,signal[ipos+first]);
}
treeB->Draw("Sector:Row:Pad","","",1,ievent);
Double_t sector = treeB->GetV1()[0];
Double_t row = treeB->GetV2()[0];
Double_t pad = treeB->GetV3()[0];
// TGraph graph(last-first,&time[first],&signal[first]);
f1->SetParameters(0.75*max,maxpos,1.1,0.8,0.25,0.2);
// TH1F * his = (TH1F*)graph.GetHistogram();
his.Fit(f1,"q");
his.Write(ename);
gPad->Clear();
his.Draw();
gPad->Update();
Double_t params[6];
for (Int_t ipar=0; ipar<6; ipar++) params[ipar] = f1->GetParameters()[ipar];
Double_t chi2 = TFitter::GetFitter()->Chisquare(6,params);
TMatrixD cov(6,6);
cov.SetMatrixArray(TFitter::GetFitter()->GetCovarianceMatrix());
//
// tail cancellation
//
Double_t x0[1000];
Double_t x1[1000];
Double_t x2[1000];
for (Int_t ipos=0; ipos<last-first; ipos++){
x0[ipos] = signal[ipos+first];
}
proc.TailCancelationALTRO1(x0,x1,0.85*0.339,0.09,last-first);
proc.TailCancelationALTRO1(x1,x2,0.85,0.789,last-first);
//
sprintf(ename,"Cancel1_%d", ievent);
TH1F his1(ename,ename,last-first,first,last);
for (Int_t ipos=0; ipos<last-first; ipos++){
his1.SetBinContent(ipos+1,x1[ipos]);
}
his1.Write(ename);
sprintf(ename,"Cancel2_%d", ievent);
TH1F his2(ename,ename,last-first,first,last);
for (Int_t ipos=0; ipos<last-first; ipos++){
his2.SetBinContent(ipos+1,x1[ipos]);
}
f1->SetParameters(0.75*max,maxpos,1.1,0.8,0.25,0.2);
his2.Fit(f1,"q");
his2.Write(ename);
Double_t params2[6];
for (Int_t ipar=0; ipar<6; ipar++) params2[ipar] = f1->GetParameters()[ipar];
Double_t chi22 = TFitter::GetFitter()->Chisquare(6,params2);
TMatrixD cov2(6,6);
cov2.SetMatrixArray(TFitter::GetFitter()->GetCovarianceMatrix());
TGraph gr0(last-first, &time[first],x0);
TGraph gr1(last-first, &time[first],x1);
TGraph gr2(last-first, &time[first],x2);
//
cstream<<"Fit"<<
"Sector="<<sector<<
"Row="<<row<<
"Pad="<<pad<<
"First="<<first<<
"Max="<<max<<
"MaxPos="<<maxpos<<
"chi2="<<chi2<<
"chi22="<<chi22<<
"Cov="<<&cov<<
"Cov2="<<&cov2<<
"gr0.="<<&gr0<<
"gr1.="<<&gr1<<
"gr2.="<<&gr2<<
"p0="<<params[0]<<
"p1="<<params[1]<<
"p2="<<params[2]<<
"p3="<<params[3]<<
"p4="<<params[4]<<
"p5="<<params[5]<<
"p02="<<params2[0]<<
"p12="<<params2[1]<<
"p22="<<params2[2]<<
"p32="<<params2[3]<<
"p42="<<params2[4]<<
"p52="<<params2[5]<<
"\n";
// delete his;
nFits++;
}
}
void function_minimizer::shmc_mcmc_routine(int nmcmc,int iseed0,double dscale,
int restart_flag) {
if (nmcmc<=0)
{
cerr << endl << "Error: Negative iterations for MCMC not meaningful" << endl;
ad_exit(1);
}
uostream * pofs_psave=NULL;
if (mcmc2_flag==1)
{
initial_params::restore_start_phase();
}
initial_params::set_inactive_random_effects();
initial_params::set_active_random_effects();
int nvar_re=initial_params::nvarcalc();
int nvar=initial_params::nvarcalc(); // get the number of active parameters
if (mcmc2_flag==0)
{
initial_params::set_inactive_random_effects();
nvar=initial_params::nvarcalc(); // get the number of active parameters
}
initial_params::restore_start_phase();
independent_variables parsave(1,nvar_re);
// dvector x(1,nvar);
// initial_params::xinit(x);
// dvector pen_vector(1,nvar);
// {
// initial_params::reset(dvar_vector(x),pen_vector);
// }
initial_params::mc_phase=1;
int old_Hybrid_bounded_flag=-1;
int on,nopt = 0;
//// ------------------------------ Parse input options
// Step size. If not specified, will be adapted. If specified must be >0
// and will not be adapted.
double eps=0.1;
double _eps=-1.0;
int useDA=1; // whether to adapt step size
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-hyeps",nopt))>-1)
{
if (!nopt) // not specified means to adapt, using function below to find reasonable one
{
cerr << "Warning: No step size given after -hyeps, ignoring" << endl;
useDA=1;
}
else // read in specified value and do not adapt
{
istringstream ist(ad_comm::argv[on+1]);
ist >> _eps;
if (_eps<=0)
{
cerr << "Error: step size (-hyeps argument) needs positive number";
ad_exit(1);
}
else
{
eps=_eps;
useDA=0;
}
}
}
// Chain number -- for console display purposes only
int chain=1;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-chain",nopt))>-1) {
if (nopt) {
int iii=atoi(ad_comm::argv[on+1]);
if (iii <1) {
cerr << "Error: chain must be >= 1" << endl;
ad_exit(1);
} else {
chain=iii;
}
}
}
// Number of leapfrog steps. Defaults to 10.
int L=10;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-hynstep",nopt))>-1)
{
if (nopt)
{
int _L=atoi(ad_comm::argv[on+1]);
if (_L < 1 )
{
cerr << "Error: hynstep argument must be integer > 0 " << endl;
ad_exit(1);
}
else
{
L=_L;
}
}
}
// Number of warmup samples if using adaptation of step size. Defaults to
// half of iterations.
int nwarmup= (int)nmcmc/2;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-nwarmup",nopt))>-1)
{
if (nopt)
{
int iii=atoi(ad_comm::argv[on+1]);
if (iii <=0 || iii > nmcmc)
{
cerr << "Error: nwarmup must be 0 < nwarmup < nmcmc" << endl;
ad_exit(1);
}
else
{
nwarmup=iii;
}
}
}
// Target acceptance rate for step size adaptation. Must be
// 0<adapt_delta<1. Defaults to 0.8.
double adapt_delta=0.8; // target acceptance rate specified by the user
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-adapt_delta",nopt))>-1)
{
if (nopt)
{
istringstream ist(ad_comm::argv[on+1]);
double _adapt_delta;
ist >> _adapt_delta;
if (_adapt_delta < 0 || _adapt_delta > 1 )
{
cerr << "Error: adapt_delta must be between 0 and 1"
" using default of 0.8" << endl;
}
else
{
adapt_delta=_adapt_delta;
}
}
}
// Use diagnoal covariance (identity mass matrix)
int diag_option=0;
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcdiag"))>-1)
{
diag_option=1;
cout << " Setting covariance matrix to diagonal with entries " << dscale
<< endl;
}
// Restart chain from previous run?
int mcrestart_flag=option_match(ad_comm::argc,ad_comm::argv,"-mcr");
if(mcrestart_flag > -1){
cerr << endl << "Error: -mcr option not implemented for HMC" << endl;
ad_exit(1);
}
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcec"))>-1)
{
cerr << endl << "Error: -mcec option not yet implemented with HMC" << endl;
ad_exit(1);
// use_empirical_flag=1;
// read_empirical_covariance_matrix(nvar,S,ad_comm::adprogram_name);
}
// Prepare the mass matrix for use. Depends on many factors below.
dmatrix S(1,nvar,1,nvar);
dvector old_scale(1,nvar);
int old_nvar;
// Need to grab old_scale values still, since it is scaled below
read_covariance_matrix(S,nvar,old_Hybrid_bounded_flag,old_scale);
if (diag_option) // set covariance to be diagonal
{
S.initialize();
for (int i=1;i<=nvar;i++)
{
S(i,i)=dscale;
}
}
// How much to thin, for now fixed at 1.
if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-mcsave"))>-1)
{
cerr << "Option -mcsave does not currently work with HMC -- every iteration is saved" << endl;
ad_exit(1);
}
//// ------------------------------ End of input processing
//// Setup more inputs and outputs
pofs_psave=
new uostream((char*)(ad_comm::adprogram_name + adstring(".psv")));
if (!pofs_psave|| !(*pofs_psave))
{
cerr << "Error trying to open file" <<
ad_comm::adprogram_name + adstring(".psv") << endl;
ad_exit(1);
}
if (mcrestart_flag == -1 )
{
(*pofs_psave) << nvar;
}
// need to rescale the hessian
// get the current scale
dvector x0(1,nvar);
dvector current_scale(1,nvar);
initial_params::xinit(x0);
int mctmp=initial_params::mc_phase;
initial_params::mc_phase=0;
initial_params::stddev_scale(current_scale,x0);
initial_params::mc_phase=mctmp;
// cout << "old scale=" << old_scale << endl;
// cout << "current scale=" << current_scale << endl;
// cout << "S before=" << S << endl;
// I think this is only needed if mcmc2 is used??
// for (int i=1;i<=nvar;i++)
// {
// for (int j=1;j<=nvar;j++)
// {
// S(i,j)*=old_scale(i)*old_scale(j);
// }
// }
if(diag_option){
for (int i=1;i<=nvar;i++)
{
for (int j=1;j<=nvar;j++)
{
S(i,j)*=current_scale(i)*current_scale(j);
}
}
}
// cout << "S after=" << S << endl;
gradient_structure::set_NO_DERIVATIVES();
if (mcmc2_flag==0)
{
initial_params::set_inactive_random_effects();
}
// Setup random number generator, based on seed passed
int iseed=2197;
if (iseed0) iseed=iseed0;
random_number_generator rng(iseed);
gradient_structure::set_YES_DERIVATIVES();
initial_params::xinit(x0);
// Dual averaging components
dvector epsvec(1,nmcmc+1), epsbar(1,nmcmc+1), Hbar(1,nmcmc+1);
epsvec.initialize(); epsbar.initialize(); Hbar.initialize();
double time_warmup=0;
double time_total=0;
std::clock_t start = clock();
time_t now = time(0);
tm* localtm = localtime(&now);
cout << endl << "Starting static HMC for model '" << ad_comm::adprogram_name <<
"' at " << asctime(localtm);
// write sampler parameters
ofstream adaptation("adaptation.csv", ios::trunc);
adaptation << "accept_stat__,stepsize__,int_time__,energy__,lp__" << endl;
// Declare and initialize the variables needed for the algorithm
dmatrix chd = choleski_decomp(S); // cholesky decomp of mass matrix
dvector y(1,nvar); // unbounded parameters
y.initialize();
// transformed params
independent_variables z(1,nvar); z=chd*y;
dvector gr(1,nvar); // gradients in unbounded space
// Need to run this to fill gr with current gradients and initial NLL.
double nllbegin=get_hybrid_monte_carlo_value(nvar,z,gr);
if(std::isnan(nllbegin)){
cerr << "Starting MCMC trajectory at NaN -- something is wrong!" << endl;
ad_exit(1);
}
// initial rotated gradient
dvector gr2(1,nvar); gr2=gr*chd;
dvector p(1,nvar); // momentum vector
p.fill_randn(rng);
// Copy initial value to parsave in case first trajectory rejected
initial_params::copy_all_values(parsave,1.0);
double iaccept=0.0;
// The gradient and params at beginning of trajectory, in case rejected.
dvector gr2begin(1,nvar); gr2begin=gr2;
dvector ybegin(1,nvar); ybegin=y;
double nll=nllbegin;
// if(useDA){
// eps=find_reasonable_stepsize(nvar,y,p,chd);
// epsvec(1)=eps; epsbar(1)=eps; Hbar(1)=0;
// }
double mu=log(10*eps);
// Start of MCMC chain
for (int is=1;is<=nmcmc;is++) {
// Random momentum for next iteration, only affects Ham values
p.fill_randn(rng);
double H0=nll+0.5*norm2(p);
// Generate trajectory
int divergence=0;
for (int i=1;i<=L;i++) {
// leapfrog updates gr, p, y, and gr2 by reference
nll=leapfrog(nvar, gr, chd, eps, p, y, gr2);
// Break trajectory early if a divergence occurs to save computation
if(std::isnan(nll)){
divergence=1; break;
}
} // end of trajectory
// Test whether to accept the proposed state
double Ham=nll+0.5*norm2(p); // Update Hamiltonian for proposed set
double alpha=min(1.0, exp(H0-Ham)); // acceptance ratio
double rr=randu(rng); // Runif(1)
if (rr<alpha && !divergence){ // accept
iaccept++;
// Update for next iteration: params, Hamiltonian and gr2
ybegin=y;
gr2begin=gr2;
nllbegin=nll;
initial_params::copy_all_values(parsave,1.0);
} else {
// Reject and don't update anything to reuse initials for next trajectory
y=ybegin;
gr2=gr2begin;
nll=nllbegin;
}
// Save parameters to psv file, duplicated if rejected
(*pofs_psave) << parsave;
// Adaptation of step size (eps).
if(useDA && is <= nwarmup){
eps=adapt_eps(is, eps, alpha, adapt_delta, mu, epsvec, epsbar, Hbar);
}
adaptation << alpha << "," << eps << "," << eps*L << "," << H0 << "," << -nll << endl;
if(is ==nwarmup) time_warmup = ( std::clock()-start)/(double) CLOCKS_PER_SEC;
print_mcmc_progress(is, nmcmc, nwarmup, chain);
} // end of MCMC chain
// This final ratio should closely match adapt_delta
if(useDA){
cout << "Final acceptance ratio=" << iaccept/nmcmc << " and target is " << adapt_delta<<endl;
cout << "Final step size=" << eps << "; after " << nwarmup << " warmup iterations"<< endl;
} else {
cout << "Final acceptance ratio=" << iaccept/nmcmc << endl;
}
time_total = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;
print_mcmc_timing(time_warmup, time_total);
// I assume this closes the connection to the file??
if (pofs_psave)
{
delete pofs_psave;
pofs_psave=NULL;
}
} // end of HMC function
bool testFloatNbhoodReprBooleanOperations()
{
/* Testovani booleovskych operaci, tj. sjednoceni, pruniku a rozdilu (doplnek je v jinych testech) */
cout << "------------------------- ";
cout << "testFloatNbhoodReprBooleanOperations:" << endl;
vector<string> fileSet;
string file1, file2;
string datafile, spacefile;
/* Kazda sada mnohostenu (kazda sada objahuje mnohosteny se stejnym Space) bude testovana tak, ze
pro kazdou dvojici teto sady spocitame prunik (resp. sjednoceni, rozdil) ve vertex reprezentaci a otestujeme,
zda je tento prunik (resp. sjednoceni, rozdil) stejny jako prunik (resp. sjednoceni, rozdil)
v grid reprezentaci (tu povazujeme za referencni). */
/* Sada pro 2D prostor o rozmerech 4 x 4 */
cout << "test 2D polyhedra" << endl;
fileSet.clear();
fileSet.push_back("06");
fileSet.push_back("07");
fileSet.push_back("08");
fileSet.push_back("09");
fileSet.push_back("10");
fileSet.push_back("11");
fileSet.push_back("12");
for (size_t i = 0; i < fileSet.size(); i ++) {
for (size_t j = 0; j < fileSet.size(); j ++) {
datafile = "src/test/data/uint/grid_repr/" + fileSet[i] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[i] + "_space.txt";
GridRepr gr1(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
datafile = "src/test/data/uint/grid_repr/" + fileSet[j] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[j] + "_space.txt";
GridRepr gr2(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
NbhoodRepr nr1(gr1);
NbhoodRepr nr2(gr2);
NbhoodRepr intersc = nr1.intersection(nr2);
assert(gr1.intersection(gr2) == GridRepr(intersc));
NbhoodRepr unif = nr1.unification(nr2);
assert(gr1.unification(gr2) == GridRepr(unif));
NbhoodRepr diff = nr1.difference(nr2);
assert(gr1.difference(gr2) == GridRepr(diff));
}
}
/* Sada pro 3D prostor o rozmerech 6 x 6 x 6 */
cout << "test 3D polyhedra" << endl;
fileSet.clear();
fileSet.push_back("13");
fileSet.push_back("14");
fileSet.push_back("15");
fileSet.push_back("16");
fileSet.push_back("17");
for (size_t i = 0; i < fileSet.size(); i ++) {
for (size_t j = 0; j < fileSet.size(); j ++) {
datafile = "src/test/data/uint/grid_repr/" + fileSet[i] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[i] + "_space.txt";
GridRepr gr1(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
datafile = "src/test/data/uint/grid_repr/" + fileSet[j] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[j] + "_space.txt";
GridRepr gr2(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
NbhoodRepr nr1(gr1);
NbhoodRepr nr2(gr2);
NbhoodRepr intersc = nr1.intersection(nr2);
assert(gr1.intersection(gr2) == GridRepr(intersc));
NbhoodRepr unif = nr1.unification(nr2);
assert(gr1.unification(gr2) == GridRepr(unif));
NbhoodRepr diff = nr1.difference(nr2);
assert(gr1.difference(gr2) == GridRepr(diff));
}
}
/* Sada pro 1D prostor o rozmerech 20 */
cout << "test 1D polyhedra" << endl;
fileSet.clear();
fileSet.push_back("18");
fileSet.push_back("19");
fileSet.push_back("20");
fileSet.push_back("21");
for (size_t i = 0; i < fileSet.size(); i ++) {
for (size_t j = 0; j < fileSet.size(); j ++) {
datafile = "src/test/data/uint/grid_repr/" + fileSet[i] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[i] + "_space.txt";
GridRepr gr1(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
datafile = "src/test/data/uint/grid_repr/" + fileSet[j] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[j] + "_space.txt";
GridRepr gr2(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
NbhoodRepr nr1(gr1);
NbhoodRepr nr2(gr2);
NbhoodRepr intersc = nr1.intersection(nr2);
assert(gr1.intersection(gr2) == GridRepr(intersc));
NbhoodRepr unif = nr1.unification(nr2);
assert(gr1.unification(gr2) == GridRepr(unif));
NbhoodRepr diff = nr1.difference(nr2);
assert(gr1.difference(gr2) == GridRepr(diff));
}
}
#if 1
/* Sada pro 4D prostor o rozmerech 6 x 6 x 6 x 6 */
cout << "test 4D polyhedra" << endl;
fileSet.clear();
fileSet.push_back("22");
fileSet.push_back("23");
fileSet.push_back("24");
for (size_t i = 0; i < fileSet.size(); i ++) {
for (size_t j = 0; j < fileSet.size(); j ++) {
datafile = "src/test/data/uint/grid_repr/" + fileSet[i] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[i] + "_space.txt";
GridRepr gr1(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
datafile = "src/test/data/uint/grid_repr/" + fileSet[j] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[j] + "_space.txt";
GridRepr gr2(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
NbhoodRepr nr1(gr1);
NbhoodRepr nr2(gr2);
NbhoodRepr intersc = nr1.intersection(nr2);
assert(gr1.intersection(gr2) == GridRepr(intersc));
NbhoodRepr unif = nr1.unification(nr2);
assert(gr1.unification(gr2) == GridRepr(unif));
NbhoodRepr diff = nr1.difference(nr2);
assert(gr1.difference(gr2) == GridRepr(diff));
}
}
#endif
#if 1
/* Sada pro 5D prostor o rozmerech 5 x 5 x 5 x 4 x 3 */
cout << "test 5D polyhedra" << endl;
fileSet.clear();
fileSet.push_back("25");
fileSet.push_back("26");
for (size_t i = 0; i < fileSet.size(); i ++) {
for (size_t j = 0; j < fileSet.size(); j ++) {
datafile = "src/test/data/uint/grid_repr/" + fileSet[i] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[i] + "_space.txt";
GridRepr gr1(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
datafile = "src/test/data/uint/grid_repr/" + fileSet[j] + ".txt";
spacefile = "src/test/data/uint/grid_repr/" + fileSet[j] + "_space.txt";
GridRepr gr2(createSpaceFromSpacefile(spacefile, true), datafile.c_str(), true);
NbhoodRepr nr1(gr1);
NbhoodRepr nr2(gr2);
NbhoodRepr intersc = nr1.intersection(nr2);
assert(gr1.intersection(gr2) == GridRepr(intersc));
NbhoodRepr unif = nr1.unification(nr2);
assert(gr1.unification(gr2) == GridRepr(unif));
NbhoodRepr diff = nr1.difference(nr2);
assert(gr1.difference(gr2) == GridRepr(diff));
}
}
#endif
return true;
}
void ColorRing::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, true);
QRect r = contentsRect();
r.moveTo(-r.width()/2, -r.height()/2);
painter.translate(r.width()/2, r.height()/2);
//painter.fillRect(r, QApplication::palette().window().color());
QConicalGradient gr(0, 0, 360);
for(int i = 0; i< 12; i++) {
gr.setColorAt(float(i)/12, QColor::fromHsvF(float(i)/12, 1.f, 1.f));
}
painter.setBrush(QBrush(gr));
painter.setPen(Qt::NoPen);
painter.drawPie(r, 0, 5760);
painter.scale(RING, RING);
painter.setBrush(QApplication::palette().window().color());
painter.drawPie(r, 0, 5760);
painter.rotate(-col.hueF() * 360);
painter.scale(r.width()*.5f, r.height()*.5f);
painter.setPen(Qt::SolidLine);
painter.setPen(QPen(QColor("white")));
painter.setBrush(QBrush(QColor(0,0,0,0)));
painter.drawEllipse(QPointF(1.12f, .0f), 0.1f, 0.1f);
painter.setPen(Qt::NoPen);
if(triangleMode) {
QConicalGradient gr2(points[2], 270.f);
gr2.setColorAt(.0f, QColor::fromHsvF(col.hueF(), .0f, 1.f));
gr2.setColorAt(1.f/6.f, QColor::fromHsvF(col.hueF(), 1.f, 1.f));
painter.setBrush(QBrush(gr2));
painter.drawPolygon(points, 3);
//painter.setCompositionMode(QPainter::CompositionMode_Multiply);
QLinearGradient gr3(points[2], (points[0]+points[1])*.5f);
gr3.setColorAt(.0f, QColor::fromRgbF(.0f, .0f, .0f, 1.f));
gr3.setColorAt(1.f, QColor::fromRgbF(.0f, .0f, .0f, 0.f));
painter.setBrush(QBrush(gr3));
painter.drawPolygon(points, 3);
//painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
QPointF p1 = points[0] * col.saturationF() + points[1] * (1.f - col.saturationF());
QPointF p2 = p1 * col.valueF() + points[2] * (1.f - col.valueF());
painter.setPen(Qt::SolidLine);
painter.setPen(QPen(QColor("white")));
painter.setBrush(QBrush(QColor(0,0,0,0)));
painter.drawEllipse(p2, 0.1f, 0.1f);
} else { // box mode
QLinearGradient gr2(points2[0], points2[1]);
gr2.setColorAt(.0f, QColor::fromHsvF(col.hueF(), 1.f, 1.f));
gr2.setColorAt(1.f, QColor::fromHsvF(col.hueF(), .0f, 1.f));
painter.setBrush(QBrush(gr2));
painter.drawPolygon(points2, 4);
QLinearGradient gr3(points2[1], points2[2]);
gr3.setColorAt(.0f, QColor::fromRgbF(.0f, .0f, .0f, 1.f));
gr3.setColorAt(1.f, QColor::fromRgbF(.0f, .0f, .0f, 0.f));
painter.setBrush(QBrush(gr3));
painter.drawPolygon(points2, 4);
QPointF p1 = points2[0] * col.saturationF() + points2[1] * (1.f - col.saturationF());
QPointF p2 = p1 + (points2[2] - points2[1]) * col.valueF();
painter.setPen(Qt::SolidLine);
painter.setPen(QPen(QColor("white")));
painter.setBrush(QBrush(QColor(0,0,0,0)));
painter.drawEllipse(p2, 0.1f, 0.1f);
}
}
