test ed studio LAB2

LAB2/.vscode/settings.json

@@ -0,0 +1,49 @@
+{
+    "files.associations": {
+        "atomic": "cpp",
+        "*.tcc": "cpp",
+        "deque": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "iterator": "cpp",
+        "memory_resource": "cpp",
+        "optional": "cpp",
+        "string_view": "cpp",
+        "functional": "cpp",
+        "istream": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "array": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "memory": "cpp",
+        "numeric": "cpp",
+        "random": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "limits": "cpp",
+        "numbers": "cpp",
+        "typeinfo": "cpp"
+    }
+}

LAB2/Lezione2/complesso.cc

@@ -0,0 +1,53 @@
+#include "complesso.h"
+#include <cmath>
+#include <iostream>
+
+complesso::complesso(double r, double i) : m_real(r),
+                                           m_imag(i) {}
+
+complesso::complesso(const complesso &orig) : m_real(orig.m_real),
+                                              m_imag(orig.m_imag) {}
+
+complesso::~complesso() {}
+
+double
+complesso::modulo() {
+    return sqrt(m_real * m_real + m_imag * m_imag);
+}
+
+double
+complesso::parte_reale() const {
+    return m_real;
+}
+
+double
+complesso::parte_immaginaria() const {
+    return m_imag;
+}
+
+void complesso::stampami() {
+    std::cout << this->m_real << " + " << this->m_imag << "i" << std::endl;
+    return;
+}
+
+complesso complesso::operator+(const complesso &addendo) {
+    complesso somma(m_real, m_imag);
+    somma.m_real = somma.m_real + addendo.m_real;
+    somma.m_imag = somma.m_imag + addendo.m_imag;
+    return somma;
+}
+
+complesso &
+complesso::operator=(const complesso &orig) {
+    m_real = orig.m_real;
+    m_imag = orig.m_imag;
+    return *this;
+}
+
+complesso operator+(const complesso &uno, const double &due) {
+    double real = uno.parte_reale() + due;
+    double imag = uno.parte_immaginaria();
+    complesso somma(real, imag);
+    
+    return somma;
+}

LAB2/Lezione2/complesso.h

@@ -0,0 +1,20 @@
+#ifndef complesso_h
+#define complesso_h
+
+class Complesso {
+  public:
+    Complesso(const Complesso &orig);
+
+    void stampami();
+
+    Complesso operator+(const Complesso &addendo);
+    Complesso &operator=(const Complesso &orig);
+
+  private:
+    double m_real;
+    double m_imag;
+};
+
+Complesso operator+(const Complesso &uno, const double &due);
+
+#endif

LAB2/Lezione2/main_00.cpp

@@ -0,0 +1,34 @@
+/*
+c++ -o main_00 complesso.cc main_00.cpp
+*/
+
+#include "complesso.h"
+#include <cmath>
+#include <iostream>
+
+int main(int argc, char **argv) {
+    // test del constructor
+    complesso numero_complesso_1(0., 0.);
+    complesso numero_complesso_2(3., 4.);
+
+    std::cout << numero_complesso_1.modulo() << std::endl;
+    std::cout << numero_complesso_2.modulo() << std::endl;
+
+    // test del copy constructor
+    complesso numero_complesso_3(numero_complesso_2);
+
+    // test dell'operator+
+    complesso numero_complesso_4 = numero_complesso_3 + numero_complesso_2;
+    //  complesso numero_complesso_4 = numero_complesso_3.operator+ (numero_complesso_2) ;
+    numero_complesso_4.stampami();
+
+    // test dell'operator=
+    complesso numero_complesso_5 = numero_complesso_4 + 5.;
+    numero_complesso_5.stampami();
+
+    complesso numero_complesso_6 = numero_complesso_5 = numero_complesso_2;
+    numero_complesso_5.stampami();
+    numero_complesso_6.stampami();
+
+    return 0;
+}

LAB2/Lezione2/ref.cpp

@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <string>
+
+// classe test
+class Meow {
+  private:
+    std::string m_NomeGatto;
+    int m_Ripetizione;
+
+  public:
+    Meow(const std::string &NomeGatto,const int &Ripetizioni)
+        : m_NomeGatto(NomeGatto),
+          m_Ripetizione(Ripetizioni) { // Scope Costructor
+        puts("\nClasse inizializzata.");
+
+        puts("##########Costruttore###########");
+        printf("Valore:\t\tm_NomeGatto: %s\n", m_NomeGatto.c_str());
+        printf("Indirizzo:\tm_NomeGatto: %p\n", &m_NomeGatto);
+        printf("Valore:\t\tm_Ripetizioni: %d\n", m_Ripetizione);
+        printf("Indirizzo:\tm_Ripetizioni: %p\n", &m_Ripetizione);
+
+        // riferimento
+        puts("##########Riferimento###########");
+        printf("Valore:\t\tNomeGatto: %s\n", NomeGatto.c_str());
+        printf("Indirizzo:\tNomeGatto: %p\n", &NomeGatto);
+        printf("Valore:\t\tRipetizioni: %d\n", Ripetizioni);
+        printf("Indirizzo:\tRipetizioni: %p\n", &Ripetizioni);
+    }
+    // END costructor
+
+    void stampami() {
+        puts(".STAMPAMI() dentro classe");
+        printf("n_NomeGatto: %s\n", m_NomeGatto.c_str());
+        printf("m_Ripetizione: %d\n", m_Ripetizione);
+    };
+
+    void CAMBIO() {
+        m_NomeGatto = "GATTOMODIFICATO";
+        m_Ripetizione = 21;
+        puts("\nCAMBIO");
+        printf("gatto_Valore: \t%s\n", m_NomeGatto.c_str());
+        printf("gatto_Indiri: \t%p\n", &m_NomeGatto);
+        printf("n_Valore: \t%d\n", m_Ripetizione);
+        printf("n_Indirizzo: \t%p\n", &m_Ripetizione);        
+    }
+};
+
+int main(int argc, char const *argv[]) {
+    std::string gatto = "meow";
+    int n = 3;
+
+    printf("1 Gatto: %s\n", gatto.c_str());
+    printf("Indirizzo gatto: %p\n", &gatto);
+    printf("1 N: %d\n", n);
+    printf("Indirizzo N: %p\n", &n);
+
+    Meow gatto1(gatto, n);
+
+    gatto1.stampami();
+    gatto1.CAMBIO();
+}

LAB2/intro.md

@@ -0,0 +1,47 @@
+# Laboratorio 2 - I Modulo
+
+## Contenuto del corso di calcolo
+
+  * Questo corso ha lo scopo di insegnare alcuni strumenti
+    di *programmazione* e di *calcolo per l’analisi statistica dei dati*
+  * Ogni lezione è dedicata ad un argomento specifico,
+    ed è composta da una parte introduttiva frontale
+    seguita dallo svolgimento di diversi esercizi proposti al termine della prima parte
+  * Utilizzeremo i seguenti strumenti:
+    * Il linguaggio di programmazione [```C++```](http://www.cplusplus.com/) per risolvere i problemi assegnati
+    * Il framework di analisi dati [```ROOT```](https://root.cern.ch/) (sviluppato al CERN per l'analisi dati)
+  * NOTA BENE: Gli strumenti scelti per il corso sono semplicemente un mezzo per
+      * imparare la **logica della programmazione**,
+      * per esercitarsi nella **scrittura di algoritmi**
+      * per svolgere **esercizi di analisi dati**
+  * Gli esercizi svolti a lezione corridspondo al livello di difficoltà medio
+    degli esercizi proposti nelle prove di esame
+
+![linea](immagini/linea.png)
+
+## Lezioni del corso
+
+  * [Prerequisiti](Prerequisiti/README.md): breve riassunto di prerequisiti che non saranno coperti durante il corso
+  * [Ripasso](Ripasso/README.md) : ripasso di ```C```
+  * [Lezione 1](Lezione_01/README.md) : strutturazione di un programma ed introduzione al ```C++```
+  * [Lezione 2](Lezione_02/README.md) : programmazione ad oggetti: le classi
+  * [Lezione 3](Lezione_03/README.md) : visualizzazione dei dati con ROOT
+  * [Lezione 4](Lezione_04/README.md) : la generazione di numeri pseudo-casuali
+  * [Lezione 5](Lezione_05/README.md) : programmazione ```template``` e Standard Template Library
+  * [Lezione 6](Lezione_06/README.md) : zeri ed estremanti di funzioni
+  * [Lezione 7](Lezione_07/README.md) : la distribuzione di Poisson
+  * [Lezione 8](Lezione_08/README.md) : toy experiment ed integrazione con tecniche Montecarlo
+  * [Lezione 9](Lezione_09/README.md) : disegno della funzione di verosimiglianza
+  * [Lezione 10](Lezione_10/README.md) : stime di parametri: il massimo della verosimiglianza
+  * [Lezione 11](Lezione_11/README.md) : stime di parametri: i minimi quadrati
+  * [Lezione 12](Lezione_12/README.md) : stime di parametri: fit di istogrammi
+
+![linea](immagini/linea.png)
+
+## Argomenti di approfondimento
+
+  * [Approfondimento 1](Appendice_01/README.md) : algoritmi predefiniti nelle *Standard Template Library* (STL)
+  * [Approfondimento 2](Appendice_02/README.md) : programmazione ad oggetti: l'ereditarietà ```public```
+  * [Approfondimento 3](Appendice_03/README.md) : approfondimenti sulle ```STL```
+  * [Approfondimento 4](Appendice_04/README.md) : il caso lineare dei minimi quadrati: una soluzione esplicita
+  * [Approfondimento 5](Appendice_04/README.md) : il salvataggio su file di classi di ROOT

LAB2/ref.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <stdio.h>
+
+// classe test
+class Meow {
+  private:
+    double m_real;
+    double m_imag;
+
+  public:
+    Meow(const Meow &orig):
+        {};
+
+    void stampami();
+
+    Meow operator+(const Meow &addendo);
+    Meow &operator=(const Meow &orig);
+};
+
+
+int main(int argc, char const *argv[]) {
+    std::string gatto = "meow";
+
+    printf("1 Gatto: %s\n", gatto );
+
+
+}

LAB2/test1.cpp

@@ -0,0 +1,32 @@
+#include <stdio.h>
+
+int somma(int &a, int &b) {
+    return a + b;
+}
+
+int &somma_ref(int &a, int &b) {
+    return (a > b) ? a : b;
+}
+
+
+
+int main(int argc, char const *argv[]) {
+
+    int pippo = 10;
+    int paperino = 50;
+
+    int &referenza = (*somma_ref);
+
+    referenza(pippo,paperino);
+
+    printf("somma: %d\n", somma(pippo,paperino));
+    printf("somma_ref: %d\n", referenza );
+
+    pippo = 100;
+    printf("somma_ref AAA: %d\n", referenza );
+
+    // 100
+
+
+    return 0;
+}