int main()
{
std::array<double, 40> values = { 1, 2, 3, 4, 5, 6, 7, 8, 9,10,
11,12,13,14,15,16,17,18,19,20,
21,22,23,24,25,26,27,28,29,30,
31,32,33,34,35,36,37,38,39,40};
std::cout << "Sum of squaresof 1,2, ...,40 is " << sum_of_squares(values) << std::endl;
std::array<double, 10000> more_values;
srand(static_cast<unsigned int>(time(0)));
std::generate(more_values.begin(), more_values.end(), []{return static_cast<double>(rand());});
std::cout << "Sum of squares of " << more_values.size() << " random number is "
<< sum_of_squares(more_values) << std::endl;
return 0;
}
int main() {
const int VALUE = 100;
std::cout << "Result: " << square_of_sum(VALUE) - sum_of_squares(VALUE) << std::endl;
}
// correlate binaryish with vector
Eigen::MatrixXf multi_correlate(std::vector<float> & y_data, float * x_data, int x_vector_size, int size, int stride, int offset){
std::vector<float> sum(x_vector_size + 1);
std::vector<float> sum_of_squares(x_vector_size + 1);
int skipped = sum_calc(x_data, x_vector_size, size, sum.data(), sum_of_squares.data(), stride, offset);
skipped += sum_calc(y_data.data(), 1, size, &sum[x_vector_size], &sum_of_squares[x_vector_size]);
//qDebug() << "skipped: " << skipped << "size: " << size;
Eigen::MatrixXf sum_productmat(x_vector_size + 1, x_vector_size + 1);
sum_productmat_calc(y_data.data(), x_data, x_vector_size, size, sum_productmat, stride, offset);
Eigen::MatrixXf correlation_mat(x_vector_size + 1, x_vector_size + 1);
correlation_mat.setIdentity();
for(int r = 0; r < x_vector_size + 1; r++){
for(int c = r+1; c < x_vector_size + 1; c++){
// qDebug() << r << c << ": " << sum[c] << sum_of_squares[c] << sum[r] << sum_of_squares[r] << sum_productmat(r, c);
correlation_mat(r, c) = correlate(sum[c], sum_of_squares[c], sum[r], sum_of_squares[r], sum_productmat(r, c), size-skipped);
correlation_mat(c, r) = correlation_mat(r, c);
}
}
return correlation_mat;
}
/***********************************************************************
* Compute the Pearson correlation coefficient of two vectors.
*
* r(X,Y) = \frac{\sum X_i Y_i - \frac{\sum X_i \sum Y_i}{n}}
* {\sqrt{\left( \sum X_i^2 - \frac{(\sum X_i)^2}{n} \right)
* \left( \sum Y_i^2 - \frac{(\sum Y_i)^2}{n}\right)}}
***********************************************************************/
ATYPE correlation
(ARRAY_T* array1,
ARRAY_T* array2)
{
ATYPE length;
ATYPE sum1;
ATYPE sum2;
ATYPE dotproduct;
ATYPE numerator;
ATYPE variance1;
ATYPE variance2;
ATYPE denominator;
ATYPE return_value;
length = (ATYPE)get_array_length(array1);
if (length != (ATYPE)get_array_length(array2)) {
die("Computing correlation of vectors of different lengths.");
}
sum1 = array_total(array1);
sum2 = array_total(array2);
dotproduct = dot_product(array1, array2);
numerator = dotproduct - ((sum1 * sum2) / length);
variance1 = sum_of_squares(array1) - ((sum1 * sum1) / length);
variance2 = sum_of_squares(array2) - ((sum2 * sum2) / length);
denominator = sqrt(variance1 * variance2);
return_value = numerator / denominator;
/*fprintf(stderr, "return_value=%g\n", return_value);*/
assert(return_value <= 1.0);
assert(return_value >= -1.0);
return(return_value);
}
static void
check_bitwise_copy(void)
{
unsigned int n_loops;
int src_ofs;
int dst_ofs;
int n_bits;
n_loops = 0;
for (n_bits = 0; n_bits <= 64; n_bits++) {
for (src_ofs = 0; src_ofs < 64 - n_bits; src_ofs++) {
for (dst_ofs = 0; dst_ofs < 64 - n_bits; dst_ofs++) {
ovs_be64 src = htonll(random_uint64());
ovs_be64 dst = htonll(random_uint64());
ovs_be64 orig_dst = dst;
ovs_be64 expect;
if (n_bits == 64) {
expect = dst;
} else {
uint64_t mask = (UINT64_C(1) << n_bits) - 1;
expect = orig_dst & ~htonll(mask << dst_ofs);
expect |= htonll(((ntohll(src) >> src_ofs) & mask)
<< dst_ofs);
}
bitwise_copy(&src, sizeof src, src_ofs,
&dst, sizeof dst, dst_ofs,
n_bits);
if (expect != dst) {
fprintf(stderr,"copy_bits(0x%016"PRIx64",8,%d, "
"0x%016"PRIx64",8,%d, %d) yielded 0x%016"PRIx64" "
"instead of the expected 0x%016"PRIx64"\n",
ntohll(src), src_ofs,
ntohll(orig_dst), dst_ofs,
n_bits,
ntohll(dst), ntohll(expect));
abort();
}
n_loops++;
}
}
}
if (n_loops != sum_of_squares(64)) {
abort();
}
}
float* kernel_matrix(float sigma, int radius){
int diameter = radius * 2 + 1;
float *k_matrix = malloc(sizeof(float) * diameter * diameter);
int i, j, k_index;
float square_sigma_mult_by_2 = pow(sigma, 2) * 2;
float base_calculation = 1 / (M_PI * square_sigma_mult_by_2);
float result = 0;
for(i = 0; i < diameter; i++){
for(j = 0; j < diameter; j++){
k_index = i * diameter + j;
result = base_calculation * pow(M_E, -1 * (sum_of_squares(i - radius, j - radius) / square_sigma_mult_by_2));
k_matrix[k_index] = result;
//printf("%1.4f ", result);
}
//printf("\n");
}
return k_matrix;
}
long squares::difference(int a)
{
return square_of_sums(a) - sum_of_squares(a);
}
int is_right(int a, int b, int c)
{
return (sum_of_squares(a, b) == c * c ? 1 : 0 );
}
void view_individual_events() {
/***
Displays an 3D occupancy plot for each SM Event (stop mode event). The h5_file_num chosen must have working Hits and EventsCR files (_Hits.root and _EventsCR.root files).
Can choose which SM event to start at. (find "CHOOSE THIS" in this script)
***/
gROOT->Reset();
// Setting up files, treereaders, histograms
string file_kind = "aggr"; // string that is either "aggr" or "non_aggr" to indicate whether or not its an aggregate file pair or not.
int file_num_input = 19;
string view_option = "1"; // choose what to view:
// "1" or "3d": view the events with their 3d reconstruction and line fit
// "2" or "SM_rel_BCID": numHits per SMRelBCID with the 3d reconstruction
TFile *fileHits;
TFile *fileEventsCR;
if (file_kind.compare("non_aggr") == 0) {
fileHits = new TFile(("/home/pixel/pybar/tags/2.0.2_new/pyBAR-master/pybar/module_202_new/" + to_string(file_num_input) + "_module_202_new_stop_mode_ext_trigger_scan_interpreted_Hits.root").c_str());
fileEventsCR = new TFile(("/home/pixel/pybar/tags/2.0.2_new/pyBAR-master/pybar/module_202_new/" + to_string(file_num_input) + "_module_202_new_stop_mode_ext_trigger_scan_interpreted_EventsCR.root").c_str());
} else if (file_kind.compare("aggr") == 0) {
// fileHits = new TFile("/home/pixel/pybar/tags/2.0.2_new/pyBAR-master/pybar/homemade_scripts/aggregate_data/1_module_202_new_AggrHits.root");
fileHits = new TFile(("/home/pixel/pybar/tags/2.0.2_new/pyBAR-master/pybar/homemade_scripts/aggregate_data/" + to_string(file_num_input) + "_module_202_new_AggrHits.root").c_str());
// fileEventsCR = new TFile("/home/pixel/pybar/tags/2.0.2_new/pyBAR-master/pybar/homemade_scripts/aggregate_data/1_module_202_new_AggrEventsCR.root");
fileEventsCR = new TFile(("/home/pixel/pybar/tags/2.0.2_new/pyBAR-master/pybar/homemade_scripts/aggregate_data/" + to_string(file_num_input) + "_module_202_new_AggrEventsCR.root").c_str());
} else {
cout << "Error: Input file_kind is not valid.";
}
TTreeReader *readerHits = new TTreeReader("Table", fileHits);
TTreeReaderValue<UInt_t> h5_file_num_Hits(*readerHits, "h5_file_num");
TTreeReaderValue<Long64_t> event_number(*readerHits, "event_number");
TTreeReaderValue<UChar_t> tot(*readerHits, "tot");
TTreeReaderValue<UChar_t> relative_BCID(*readerHits, "relative_BCID");
TTreeReaderValue<Long64_t> SM_event_num_Hits(*readerHits, "SM_event_num");
TTreeReaderValue<UInt_t> SM_rel_BCID(*readerHits, "SM_rel_BCID");
TTreeReaderValue<Double_t> x(*readerHits, "x");
TTreeReaderValue<Double_t> y(*readerHits, "y");
TTreeReaderValue<Double_t> z(*readerHits, "z");
TTreeReaderValue<Double_t> s(*readerHits, "s");
TTreeReader *readerEventsCR = new TTreeReader("Table", fileEventsCR);
TTreeReaderValue<UInt_t> h5_file_num_EventsCR(*readerEventsCR, "h5_file_num");
TTreeReaderValue<Long64_t> SM_event_num_EventsCR(*readerEventsCR, "SM_event_num");
TTreeReaderValue<UInt_t> num_hits(*readerEventsCR, "num_hits");
TTreeReaderValue<UInt_t> sum_tots(*readerEventsCR, "sum_tots");
TTreeReaderValue<Double_t> mean_x(*readerEventsCR, "mean_x");
TTreeReaderValue<Double_t> mean_y(*readerEventsCR, "mean_y");
TTreeReaderValue<Double_t> mean_z(*readerEventsCR, "mean_z");
TTreeReaderValue<Double_t> line_fit_param0(*readerEventsCR, "line_fit_param0");
TTreeReaderValue<Double_t> line_fit_param1(*readerEventsCR, "line_fit_param1");
TTreeReaderValue<Double_t> line_fit_param2(*readerEventsCR, "line_fit_param2");
TTreeReaderValue<Double_t> line_fit_param3(*readerEventsCR, "line_fit_param3");
TTreeReaderValue<Double_t> sum_of_squares(*readerEventsCR, "sum_of_squares");
TTreeReaderValue<UInt_t> event_status(*readerEventsCR, "event_status");
TTreeReaderValue<Double_t> fraction_inside_sphere(*readerEventsCR, "fraction_inside_sphere");
TTreeReaderValue<Double_t> length_track(*readerEventsCR, "length_track");
TTreeReaderValue<Double_t> sum_tots_div_by_length_track(*readerEventsCR, "sum_tots_div_by_length_track");
TTreeReaderValue<Double_t> sum_squares_div_by_DoF(*readerEventsCR, "sum_squares_div_by_DoF");
TTreeReaderValue<Double_t> zenith_angle(*readerEventsCR, "zenith_angle");
TTreeReaderValue<UInt_t> duration(*readerEventsCR, "duration");
// Initialize the canvas and graph_3d
TCanvas *c1 = new TCanvas("c1","3D Occupancy for Specified SM Event", 1000, 10, 900, 1000);
// c1->SetRightMargin(0.25);
TPad *pad1 = new TPad("pad1", "pad1", 0, 0.5, 1, 1.0); // upper pad
pad1->SetRightMargin(0.25);
TPad *pad2 = new TPad("pad2", "pad2", 0, 0, 1, 0.5); // lower pad
// pad2->SetRightMargin(0.35);
c1->cd();
TH2F *h_2d_occupancy = new TH2F("h_2d_occupancy", "2D Occupancy", 80, 0, 20, 336, -16.8, 0);
h_2d_occupancy->GetXaxis()->SetTitle("x (mm)");
h_2d_occupancy->GetYaxis()->SetTitle("y (mm)");
h_2d_occupancy->GetZaxis()->SetTitle("SM Relative BCID (BCIDs)");
TH1F *h_SM_rel_BCID = new TH1F("h_SM_rel_BCID", "Num Hits per SMRelBCID", 256, 0, 256);
h_SM_rel_BCID->GetXaxis()->SetTitle("Stop Mode Relative BCID (BCIDs)");
h_SM_rel_BCID->GetYaxis()->SetTitle("Count (hits)");
bool quit = false; // if pressed q
// Main Loop (loops for every entry in readerEventsCR)
while (readerEventsCR->Next() && !quit) {
if (readerEventsCR->GetCurrentEntry() == 0 && file_kind.compare("non_aggr") == 0) {
continue; // skip the entry num 0, because it probably contains no data
}
// Get startEntryNum_Hits and endEntryNum_Hits (for readerHits)
vector<int> entryNumRange_include(2);
entryNumRange_include = getEntryNumRangeWithH5FileNumAndSMEventNum(readerHits, *h5_file_num_EventsCR, *SM_event_num_EventsCR);
if (entryNumRange_include[0] == -1) {
cout << "Error: h5_file_num and SM_event_num should be able to be found in the Hits file.\n";
}
// If statement for choosing which graph_3d/h_2d_occupancy to view
TGraph2D *graph_3d = new TGraph2D(); // create a new TGraph to refresh; the graph_3d is the 3d plot, the h_2d_occupancy is the 2d plot.
h_2d_occupancy->Reset(); // must do reset for histograms, cannot create a new hist to refresh it
h_SM_rel_BCID->Reset();
// Fill graph_3d and h_2d_occupancy with points and set title and axes
readerHits->SetEntry(entryNumRange_include[0]);
for (int i = 0; i < entryNumRange_include[1] - entryNumRange_include[0] + 1; i++) {
graph_3d->SetPoint(i, (*x - 0.001), (*y + 0.001), (*z - 0.001));
h_2d_occupancy->Fill(*x, *y, *SM_rel_BCID);
h_SM_rel_BCID->Fill(*SM_rel_BCID);
readerHits->Next();
}
string graphTitle = "3D Reconstruction and Line Fit for h5FileNum " + to_string(*h5_file_num_EventsCR) + ", SMEventNum " + to_string(*SM_event_num_EventsCR);
// graphTitle.append(to_string(*SM_event_num_EventsCR));
graph_3d->SetTitle(graphTitle.c_str());
graph_3d->GetXaxis()->SetTitle("x (mm)");
graph_3d->GetYaxis()->SetTitle("y (mm)");
graph_3d->GetZaxis()->SetTitle("z (mm)");
graph_3d->GetXaxis()->SetLimits(0, 20); // ROOT is buggy, x and y use setlimits()
graph_3d->GetYaxis()->SetLimits(-16.8, 0); // but z uses setrangeuser()
graph_3d->GetZaxis()->SetRangeUser(0, 40.96);
c1->SetTitle(graphTitle.c_str());
// Draw the graph_3d on pad1 (upper pad)
c1->cd();
pad1->Draw();
pad1->cd();
graph_3d->SetMarkerStyle(8);
graph_3d->SetMarkerSize(0.5);
graph_3d->Draw("pcol");
// Draw other histogram on pad2
c1->cd();
pad2->Draw();
pad2->cd();
if (view_option.compare("3d") == 0 || view_option.compare("1") == 0) {
pad2->SetRightMargin(0.35);
h_2d_occupancy->Draw("COLZ");
} else if (view_option.compare("SM_rel_BCID") == 0 || view_option.compare("2") == 0) {
pad2->SetRightMargin(0.25);
h_SM_rel_BCID->Draw("COLZ");
} else {
cout << "Error: Input view_option is not valid.\n";
}
pad1->cd();
// Display results, draw graph_3d and line fit
if (file_kind.compare("aggr") == 0) {
cout << "Aggr EventsCR Entry Num: " << readerEventsCR->GetCurrentEntry();
}
cout << " h5 Event Num: " << *h5_file_num_EventsCR << " SM Event Num: " << *SM_event_num_EventsCR << "\n";
// cout << " Number of hits: " << *num_hits << "\n";
// Draw the fitted line only if fit did not fail.
if (*event_status != 1) {
double fitParams[4];
fitParams[0] = *line_fit_param0;
fitParams[1] = *line_fit_param1;
fitParams[2] = *line_fit_param2;
fitParams[3] = *line_fit_param3;
int n = 1000;
double t0 = 0; // t is the z coordinate
double dt = 40.96;
TPolyLine3D *l = new TPolyLine3D(n);
for (int i = 0; i <n;++i) {
double t = t0+ dt*i/n;
double x,y,z;
line(t,fitParams,x,y,z);
l->SetPoint(i,x,y,z);
}
l->SetLineColor(kRed);
l->Draw("same");
cout << "Sum of squares div by DoF: " << *sum_squares_div_by_DoF;
} else {
cout << "Sum of squares div by DoF: FIT FAILED";
}
cout << " Zenith angle: " << *zenith_angle << "\n";
cout << "Duration: " << *duration << "\n";
// cout << "Fraction inside sphere (1 mm radius): " << *fraction_inside_sphere << "\n";
cout << "Length of track: " << *length_track << "\n";
cout << "SumTots/Length: " << *sum_tots_div_by_length_track << "\n";
// if (view_option.compare("3d") == 0 || view_option.compare("1") == 0) {
// } else if (view_option.compare("SM_rel_BCID") == 0 || view_option.compare("2") == 0) {
// // // Reset histogram
// // h_SM_rel_BCID->Reset();
// // // For every hit, fill in the histogram with the SM_rel_BCID
// // readerHits->SetEntry(entryNumRange_include[0]);
// // for (int i = 0; i < entryNumRange_include[1] - entryNumRange_include[0] + 1; i++) {
// // h_SM_rel_BCID->Fill(*SM_rel_BCID);
// // readerHits->Next();
// // }
// // // Draw the hist
// // c1->cd();
// // pad1->Draw();
// // pad1->cd();
// // h_SM_rel_BCID->Draw();
// // // Print info lines
// // if (file_kind.compare("aggr") == 0) {
// // cout << "Aggr EventsCR Entry Num: " << readerEventsCR->GetCurrentEntry();
// // }
// // cout << " h5 Event Num: " << *h5_file_num_EventsCR << " SM Event Num: " << *SM_event_num_EventsCR << "\n";
// } else {
// cout << "Error: Input view_option is not valid.\n";
// }
// Ask for input
if (true) { // won't show drawings or ask for input unless its a good event // CHOOSE THIS to show all events or only good events
c1->Update(); // show all the drawings
// handle input
string inString = "";
bool inStringValid = false;
do {
cout << "<Enter>: next; 'b': previous; [number]: the nth SMEvent in the EventsCR file; 'q': quit.\n"; // b is for back
getline(cin, inString);
// Handles behavior according to input
if (inString.empty()) { // <Enter>
// leave things be
inStringValid = true;
} else if (inString.compare("b") == 0) {
readerEventsCR->SetEntry(readerEventsCR->GetCurrentEntry() - 2);
// smEventNum -= 2; // because it gets incremented once at the end of this do while loop
inStringValid = true;
} else if (inString.compare("q") == 0 || inString.compare(".q") == 0) {
quit = true;
inStringValid = true;
} else if (canConvertStringToPosInt(inString)) {
readerEventsCR->SetEntry(convertStringToPosInt(inString) - 1);
// smEventNum = convertStringToPosInt(inString) - 1; // -1 because it gets incremented once at the end of this do while loop
inStringValid = true;
} // else, leave inStringValid as false, so that it asks for input again
} while (!inStringValid);
} else {
cout << "\n";
}
}
cout << "Exiting program.\n";
}
int squares::difference(int n)
{
return square_of_sums(n) - sum_of_squares(n);
}
int main () {
const uint64_t n = 100;
uint64_t d_ss2 = square_of_sums (n) - sum_of_squares (n);
printf ("%lu\n", d_ss2);
return 0;
}
bool is_right(int a, int b, int c)
{
return sum_of_squares(a, b) == c*c;
}
int main(void)
{
printf("The result is %d\n", square_of_sum() - sum_of_squares());
return 0;
}
int ex6()
{
return square_of_sum(101) - sum_of_squares(101);
}
int main() {
printf("%d\n", square_of_sum(100) - sum_of_squares(100));
return 0;
}
