diff --git a/LAB2/.vscode/settings.json b/LAB2/.vscode/settings.json new file mode 100644 index 0000000..9c1574a --- /dev/null +++ b/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" + } +} \ No newline at end of file diff --git a/LAB2/Lezione2/complesso.cc b/LAB2/Lezione2/complesso.cc new file mode 100644 index 0000000..74e6780 --- /dev/null +++ b/LAB2/Lezione2/complesso.cc @@ -0,0 +1,53 @@ +#include "complesso.h" +#include +#include + +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; +} diff --git a/LAB2/Lezione2/complesso.h b/LAB2/Lezione2/complesso.h new file mode 100644 index 0000000..2a4ef50 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/LAB2/Lezione2/main_00 b/LAB2/Lezione2/main_00 new file mode 100755 index 0000000..1f01643 Binary files /dev/null and b/LAB2/Lezione2/main_00 differ diff --git a/LAB2/Lezione2/main_00.cpp b/LAB2/Lezione2/main_00.cpp new file mode 100644 index 0000000..1f4dbc1 --- /dev/null +++ b/LAB2/Lezione2/main_00.cpp @@ -0,0 +1,34 @@ +/* +c++ -o main_00 complesso.cc main_00.cpp +*/ + +#include "complesso.h" +#include +#include + +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; +} \ No newline at end of file diff --git a/LAB2/Lezione2/ref b/LAB2/Lezione2/ref new file mode 100755 index 0000000..f00b874 Binary files /dev/null and b/LAB2/Lezione2/ref differ diff --git a/LAB2/Lezione2/ref.cpp b/LAB2/Lezione2/ref.cpp new file mode 100644 index 0000000..78f3b4e --- /dev/null +++ b/LAB2/Lezione2/ref.cpp @@ -0,0 +1,61 @@ +#include +#include + +// 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(); +} diff --git a/LAB2/intro.md b/LAB2/intro.md new file mode 100644 index 0000000..8d7f752 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/LAB2/ref b/LAB2/ref new file mode 100755 index 0000000..9b2c420 Binary files /dev/null and b/LAB2/ref differ diff --git a/LAB2/ref.cpp b/LAB2/ref.cpp new file mode 100644 index 0000000..c9d8ff4 --- /dev/null +++ b/LAB2/ref.cpp @@ -0,0 +1,27 @@ +#include +#include + +// 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 ); + + +} diff --git a/LAB2/test b/LAB2/test new file mode 100755 index 0000000..dbe3642 Binary files /dev/null and b/LAB2/test differ diff --git a/LAB2/test1.cpp b/LAB2/test1.cpp new file mode 100644 index 0000000..c80a3c1 --- /dev/null +++ b/LAB2/test1.cpp @@ -0,0 +1,32 @@ +#include + +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; +}