├── Computabilita ├── riassunto │ ├── Riassunto.md │ ├── Riassunto.pdf │ ├── build.sh │ ├── 99-CoseSulLab.md │ ├── 25-NFA.md │ ├── 30-GrammaticheRegolari.md │ └── 20-DFA.md ├── lab │ ├── lab01 │ │ ├── 806830.txt │ │ ├── 806830BaldiCristian.zip │ │ └── films.dtd │ ├── lab02 │ │ ├── 806830.txt │ │ └── films.dtd │ └── lab03 │ │ ├── films.xml │ │ ├── Makefile │ │ ├── films.dtd │ │ ├── ParserVal.java │ │ └── films.y ├── multiplodi5inbinario.md └── multiplodi5inbinario.jff ├── RetiSistemiOperativi ├── 2016-12-06.md ├── .2016-11-29.md.swp ├── eserciziPageTable.md ├── ripassoConGalimbo.md ├── esercizioCollisione.md ├── 2016-10-04.md ├── 2016-10-11.md ├── 2016-11-22.md ├── 2016-10-28.md ├── routing.md └── 2016-10-25.md ├── .gitignore ├── SistemiDistribuiti ├── 2017-03-23.md ├── teoria │ ├── Riassunto.pdf │ ├── 11-RDF-Sparql.md │ └── 03-RPC.md ├── esercizi.md ├── 2017-03-21.md ├── 2017-03-28.md ├── 2017-03-14-esercitazione.md ├── 2017-04-27.md ├── 2017-05-02.md └── 2017-02-28.md ├── Architettura ├── 2016-03-22-esercitazione.md ├── text9696-5-1.png ├── I-type-datapath.png ├── MULTICYCLE.svg.png ├── R-type-datapath.png ├── 2016-04-01.md ├── 2016-04-19-esercitazione.md ├── mips │ ├── Add5Nums.asm │ ├── mips1.asm │ ├── Es1.asm │ ├── Add10-FindMax-CalculateAvg.asm │ └── functioncalls.asm ├── 2016-05-26.md ├── 2016-04-07.md ├── 2016-05-13.md ├── 2016-05-10.md ├── 2016-03-31.md ├── 2016-05-31.md ├── 2016-05-05.md ├── 2016-0-5-24-esercitazione.md ├── 2016-04-05-esercitazione.md ├── approfondimento │ ├── DatapathPipeline.mdown │ ├── PrioritaInterrupt.mdown │ ├── IEEE754.md │ └── esercizi.md └── 2016-05-12.md ├── LinguaggiDiProgrammazione ├── c │ ├── hello.c │ ├── a.out │ ├── altra.c │ ├── finale │ ├── separata.h │ ├── pointers.o │ ├── separata.o │ ├── altra.h │ ├── cpolisimple.zip │ ├── cpolisimple │ │ ├── a.out │ │ ├── Potenza.h │ │ ├── Monomio.h │ │ ├── Polinomio.h │ │ ├── Potenza.c │ │ ├── Monomio.c │ │ ├── Polinomio.c │ │ └── main.c │ ├── separata.c │ └── pointers.c ├── lisp │ ├── primi-test.fasl │ ├── lab-2016-12-02.fasl │ ├── primi-test.lisp │ ├── lab-2016-12-16.lisp │ ├── esercizi-vari.lisp │ ├── #esercizi-vari.lisp# │ └── lab-2016-12-02.lisp ├── prolog │ ├── sum.pl │ ├── recursion.pro │ ├── lab-2016-10-28.pro │ ├── lab-2016-11-11.pro │ └── lists.pl └── c-teoria-esame.md ├── Fondamenti ├── bigliettone.pdf ├── Riassunto │ ├── Riassunto.pdf │ ├── build.sh │ ├── 30_Induzione.md │ ├── 26_Reticoli.md │ ├── 15_Proprieta_Relazioni.md │ ├── 21_Strutture_Relazionali.md │ └── 40_Algebra_Booleana.md └── 2015-10-06 ├── APSoftware ├── teoria │ ├── Ripasso.pdf │ ├── 05_Modelli-Dominio.md │ ├── 06_SSD.md │ ├── 09-Architettura-Logica.md │ ├── 03-Casi-Uso.md │ ├── 13-Testing.md │ └── 10-GRASP.md ├── Diagramma-Attività.png ├── diagrammaStatiRadio.jpg ├── EsercizioVotoDiagAttività.png ├── comeLeggereCasiUso.md ├── laboratorio │ ├── lab5 │ │ └── lab5.txt │ ├── lab6.mdown │ ├── Prova.java │ └── casi-uso │ │ └── biglietteria.md ├── 2017-03-23.md ├── 2017-03-31.md ├── 2017-03-10-esercitazione.md ├── 2017-03-17.md ├── 2017-03-30.md └── 2017-02-23.md ├── Complementi ├── img │ └── diff_partial.png ├── riassunto │ ├── RipassoTotale.pdf │ ├── images │ │ ├── piano.png │ │ ├── diff_partial.png │ │ ├── prop-limiti.png │ │ ├── prodotto-misto.png │ │ ├── equazione-retta.png │ │ ├── angolo-retta-piano7.png │ │ ├── parallelismo-piano-retta.png │ │ ├── parallelogramma-vettoriale.png │ │ └── perpendicolarita-piano-retta.png │ └── RipassoTotale.tex ├── EserciziSecondo.tex └── CoseSuMatrici.md ├── Statistica ├── teoria │ ├── images │ │ ├── 6-01.png │ │ ├── 6-02.png │ │ ├── 6-03.png │ │ ├── 6-04.png │ │ ├── 6-05.png │ │ ├── 6-06.png │ │ ├── 6-07.png │ │ ├── 7-01.png │ │ ├── 7-02.png │ │ ├── 7-03.png │ │ ├── 7-04.png │ │ ├── 8-01.png │ │ └── 8-02.png │ └── dataset │ │ └── etaAltezza.csv ├── laboratorio │ ├── images │ │ ├── 01.png │ │ ├── 02.png │ │ ├── 03.png │ │ └── 04.png │ ├── .ipynb_checkpoints │ │ ├── Capitolo 5-checkpoint.ipynb │ │ └── Capitolo 6-checkpoint.ipynb │ └── dati │ │ ├── esempio1.12.csv │ │ ├── esempio1.1.csv │ │ └── esempio1.2.csv └── esercizi │ ├── .ipynb_checkpoints │ └── Approfondimento2-checkpoint.ipynb │ └── Approfondimento2.ipynb ├── Analisi └── Riassunto │ ├── RipassoAnalisi.pdf │ └── main.tex ├── Programmazione ├── Laboratorio │ ├── 1 │ │ ├── Es4.java │ │ ├── Es1.java │ │ ├── Es2.java │ │ ├── Es5.java │ │ ├── Es3.java │ │ ├── Es6.java │ │ └── Es7.java │ ├── 2 │ │ ├── Es1.java │ │ ├── Es2.java │ │ ├── Es6.java │ │ ├── Es3.java │ │ ├── Es4.java │ │ └── Es5.java │ ├── 3 │ │ ├── Es1.java │ │ ├── Es3.java │ │ └── Es2.java │ └── 4 │ │ ├── Es1.java │ │ ├── Es6.java │ │ ├── Es5.java │ │ └── Es2.java ├── letitsnow.py └── mergeSort.py ├── README.md ├── Algoritmi ├── SomamDiProdotti.py ├── IT-SubStr.py ├── DI-CountTrueCouples.py ├── Cerca3.py ├── DI-SumOfProds.py ├── Compitino2012-06-20.py ├── ContaSottoArray.py ├── merge.py ├── Laboratorio │ ├── MaxArray.java │ ├── AvgArray.java │ └── BinarySearch.java ├── 2016-04-22.md ├── Liste │ ├── List.py │ └── TestList.py └── 2016-03-18.md └── BasiDiDati ├── 2017-03-15.md ├── 2017-02-21.md ├── 2017-02-22.md └── video ├── 04-Progettazione-Concettuale.md └── 02-Modello-ER.md /Computabilita/riassunto/Riassunto.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /RetiSistemiOperativi/2016-12-06.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | Dispense 2 | *.class 3 | *.md~ 4 | -------------------------------------------------------------------------------- /Computabilita/lab/lab01/806830.txt: -------------------------------------------------------------------------------- 1 | 806830 Baldi Cristian -------------------------------------------------------------------------------- /Computabilita/lab/lab02/806830.txt: -------------------------------------------------------------------------------- 1 | 806830 Baldi Cristian -------------------------------------------------------------------------------- /SistemiDistribuiti/2017-03-23.md: -------------------------------------------------------------------------------- 1 | # Ajax revealed 2 | 3 | 4 | -------------------------------------------------------------------------------- /Architettura/2016-03-22-esercitazione.md: -------------------------------------------------------------------------------- 1 | Esercizio 1 2 | !(!A+B)*C 3 | 4 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/hello.c: -------------------------------------------------------------------------------- 1 | int main(){ 2 | int a = 42; 3 | int b = 76; 4 | return a+b; 5 | } 6 | -------------------------------------------------------------------------------- /Fondamenti/bigliettone.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Fondamenti/bigliettone.pdf -------------------------------------------------------------------------------- /APSoftware/teoria/Ripasso.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/APSoftware/teoria/Ripasso.pdf -------------------------------------------------------------------------------- /Architettura/text9696-5-1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Architettura/text9696-5-1.png -------------------------------------------------------------------------------- /Architettura/I-type-datapath.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Architettura/I-type-datapath.png -------------------------------------------------------------------------------- /Architettura/MULTICYCLE.svg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Architettura/MULTICYCLE.svg.png -------------------------------------------------------------------------------- /Architettura/R-type-datapath.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Architettura/R-type-datapath.png -------------------------------------------------------------------------------- /Complementi/img/diff_partial.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/img/diff_partial.png -------------------------------------------------------------------------------- /APSoftware/Diagramma-Attività.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/APSoftware/Diagramma-Attività.png -------------------------------------------------------------------------------- /APSoftware/diagrammaStatiRadio.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/APSoftware/diagrammaStatiRadio.jpg -------------------------------------------------------------------------------- /Fondamenti/Riassunto/Riassunto.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Fondamenti/Riassunto/Riassunto.pdf -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/LinguaggiDiProgrammazione/c/a.out -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/altra.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "altra.h" 4 | 5 | void altra(){ 6 | separata(); 7 | } -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/finale: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/LinguaggiDiProgrammazione/c/finale -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/separata.h: -------------------------------------------------------------------------------- 1 | #ifndef _SEPARATA 2 | #define _SEPARATA 3 | 4 | extern void separata(); 5 | 6 | #endif -------------------------------------------------------------------------------- /Statistica/teoria/images/6-01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/6-01.png -------------------------------------------------------------------------------- /Statistica/teoria/images/6-02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/6-02.png -------------------------------------------------------------------------------- /Statistica/teoria/images/6-03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/6-03.png -------------------------------------------------------------------------------- /Statistica/teoria/images/6-04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/6-04.png -------------------------------------------------------------------------------- /Statistica/teoria/images/6-05.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/6-05.png -------------------------------------------------------------------------------- /Statistica/teoria/images/6-06.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/6-06.png -------------------------------------------------------------------------------- /Statistica/teoria/images/6-07.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/6-07.png -------------------------------------------------------------------------------- /Statistica/teoria/images/7-01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/7-01.png -------------------------------------------------------------------------------- /Statistica/teoria/images/7-02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/7-02.png -------------------------------------------------------------------------------- /Statistica/teoria/images/7-03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/7-03.png -------------------------------------------------------------------------------- /Statistica/teoria/images/7-04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/7-04.png -------------------------------------------------------------------------------- /Statistica/teoria/images/8-01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/8-01.png -------------------------------------------------------------------------------- /Statistica/teoria/images/8-02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/teoria/images/8-02.png -------------------------------------------------------------------------------- /Analisi/Riassunto/RipassoAnalisi.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Analisi/Riassunto/RipassoAnalisi.pdf -------------------------------------------------------------------------------- /Computabilita/riassunto/Riassunto.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Computabilita/riassunto/Riassunto.pdf -------------------------------------------------------------------------------- /Statistica/laboratorio/images/01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/laboratorio/images/01.png -------------------------------------------------------------------------------- /Statistica/laboratorio/images/02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/laboratorio/images/02.png -------------------------------------------------------------------------------- /Statistica/laboratorio/images/03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/laboratorio/images/03.png -------------------------------------------------------------------------------- /Statistica/laboratorio/images/04.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Statistica/laboratorio/images/04.png -------------------------------------------------------------------------------- /APSoftware/EsercizioVotoDiagAttività.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/APSoftware/EsercizioVotoDiagAttività.png -------------------------------------------------------------------------------- /Complementi/riassunto/RipassoTotale.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/RipassoTotale.pdf -------------------------------------------------------------------------------- /Complementi/riassunto/images/piano.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/piano.png -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/pointers.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/LinguaggiDiProgrammazione/c/pointers.o -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/separata.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/LinguaggiDiProgrammazione/c/separata.o -------------------------------------------------------------------------------- /RetiSistemiOperativi/.2016-11-29.md.swp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/RetiSistemiOperativi/.2016-11-29.md.swp -------------------------------------------------------------------------------- /SistemiDistribuiti/teoria/Riassunto.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/SistemiDistribuiti/teoria/Riassunto.pdf -------------------------------------------------------------------------------- /Complementi/riassunto/images/diff_partial.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/diff_partial.png -------------------------------------------------------------------------------- /Complementi/riassunto/images/prop-limiti.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/prop-limiti.png -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/altra.h: -------------------------------------------------------------------------------- 1 | #ifndef _ALTRA 2 | #define _ALTRA 3 | 4 | #include "separata.h" 5 | 6 | extern void altra(); 7 | 8 | #endif -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/cpolisimple.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/LinguaggiDiProgrammazione/c/cpolisimple.zip -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/cpolisimple/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/LinguaggiDiProgrammazione/c/cpolisimple/a.out -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/separata.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "separata.h" 3 | 4 | void separata(){ 5 | printf("WE SONO QUI\n"); 6 | } -------------------------------------------------------------------------------- /Complementi/riassunto/images/prodotto-misto.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/prodotto-misto.png -------------------------------------------------------------------------------- /Computabilita/lab/lab01/806830BaldiCristian.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Computabilita/lab/lab01/806830BaldiCristian.zip -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/lisp/primi-test.fasl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/LinguaggiDiProgrammazione/lisp/primi-test.fasl -------------------------------------------------------------------------------- /Complementi/riassunto/images/equazione-retta.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/equazione-retta.png -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/lisp/lab-2016-12-02.fasl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/LinguaggiDiProgrammazione/lisp/lab-2016-12-02.fasl -------------------------------------------------------------------------------- /Complementi/riassunto/images/angolo-retta-piano7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/angolo-retta-piano7.png -------------------------------------------------------------------------------- /Statistica/esercizi/.ipynb_checkpoints/Approfondimento2-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 2 6 | } 7 | -------------------------------------------------------------------------------- /Statistica/laboratorio/.ipynb_checkpoints/Capitolo 5-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 2 6 | } 7 | -------------------------------------------------------------------------------- /Statistica/laboratorio/.ipynb_checkpoints/Capitolo 6-checkpoint.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [], 3 | "metadata": {}, 4 | "nbformat": 4, 5 | "nbformat_minor": 2 6 | } 7 | -------------------------------------------------------------------------------- /Statistica/teoria/dataset/etaAltezza.csv: -------------------------------------------------------------------------------- 1 | Età;Altezza 2 | 20;175 3 | 20;185 4 | 21;165 5 | 19;173 6 | 22;173 7 | 18;171 8 | 18;175 9 | 20;175 10 | 19;173 11 | -------------------------------------------------------------------------------- /Complementi/riassunto/images/parallelismo-piano-retta.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/parallelismo-piano-retta.png -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/lisp/primi-test.lisp: -------------------------------------------------------------------------------- 1 | (defun somma(primo secondo) 2 | (+ primo secondo)) 3 | 4 | (defun prodotto(primo secondo) 5 | (* primo secondo)) 6 | 7 | -------------------------------------------------------------------------------- /Complementi/riassunto/images/parallelogramma-vettoriale.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/parallelogramma-vettoriale.png -------------------------------------------------------------------------------- /Complementi/riassunto/images/perpendicolarita-piano-retta.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/crisbal/Appunti-Unimib/HEAD/Complementi/riassunto/images/perpendicolarita-piano-retta.png -------------------------------------------------------------------------------- /Computabilita/lab/lab03/films.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Computabilita/riassunto/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | pandoc *.md -o Riassunto.pdf --template=template.tex --latex-engine=xelatex -V documentclass:report -V fontsize=12pt -V linestretch=1.1 -N 3 | -------------------------------------------------------------------------------- /Programmazione/Laboratorio/1/Es4.java: -------------------------------------------------------------------------------- 1 | public class Es4{ 2 | 3 | public static void main(String[] args){ 4 | char x = 'a',y = 'b'; 5 | 6 | System.out.println(x+""+y); //ab 7 | } 8 | } -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/prolog/sum.pl: -------------------------------------------------------------------------------- 1 | sum(0, Y, Y). 2 | sum(s(X), Y, s(Z)) :- sum(X,Y,Z). 3 | 4 | product(X, s(0), X) :- !. 5 | product(X, s(Y), Z) :- product(X, Y, R), sum(X, R, Z). 6 | 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Appunti-Unimib 2 | I miei appunti per il corso di Laurea in Informatica all'Università di Milano Bicocca 3 | 4 | ## Licenza 5 | 6 | https://creativecommons.org/licenses/by-nc/3.0/ 7 | -------------------------------------------------------------------------------- /Statistica/laboratorio/dati/esempio1.12.csv: -------------------------------------------------------------------------------- 1 | Stanze;Occupanti 4;3 2;2 6;4 4;4 3;2 4;5 5;2 4;5 3;4 3;2 2;2 3;3 3;2 6;4 4;3 5;3 4;3 4;4 4;3 2;3 6;7 3;3 4;4 4;2 4;3 5;3 5;3 2;2 5;4 3;2 5;7 5;4 4;4 3;4 3;2 -------------------------------------------------------------------------------- /Fondamenti/Riassunto/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | pandoc *.md -o Riassunto.pdf --template=template.tex --latex-engine=xelatex -V documentclass:report -V fontsize=12pt -V papersize=a4paperV -V linestretch=1.1 -N 3 | -------------------------------------------------------------------------------- /Programmazione/Laboratorio/1/Es1.java: -------------------------------------------------------------------------------- 1 | public class Es1{ 2 | 3 | public static void main(String[] args){ 4 | int x,y; 5 | x=3; 6 | y=5; 7 | 8 | System.out.println("x: " + x + " y: " + y); 9 | } 10 | } -------------------------------------------------------------------------------- /Statistica/laboratorio/dati/esempio1.1.csv: -------------------------------------------------------------------------------- 1 | 3;4;2;6;5;2;4;4 2 | 2;5;4;4;5;7;5;4 3 | 5;7;8;4;3;6;2;3 4 | 5;2;7;2;4;8;4;2 5 | 6;5;4;4;6;5;3;3 6 | 8;5;2;5;6;5;5;4 7 | 2;6;4;5;5;7;3;4 8 | 3;3;3;4;4;3;4;6 9 | 4;3;7;4;4;6;4;2 10 | 4;4;6;3;2;3;5;4 11 | -------------------------------------------------------------------------------- /APSoftware/comeLeggereCasiUso.md: -------------------------------------------------------------------------------- 1 | A <--- <> ---- B 2 | 3 | B estende A, cioè fare B implica che hai fatto A, mentre facendo A puoi fare, ma anche no, B 4 | 5 | A <--- <> --- B 6 | 7 | B include A, B tra le sue operazioni include/richiede TUTTE quelle di A. A può essere eseguito senza B. -------------------------------------------------------------------------------- /Programmazione/Laboratorio/1/Es2.java: -------------------------------------------------------------------------------- 1 | public class Es2{ 2 | 3 | public static void main(String[] args){ 4 | double x,y; 5 | x=125.0; 6 | y=85.3; 7 | 8 | System.out.println("x: " + x + " y: " + y); 9 | System.out.println("x*y: " + x*y); 10 | System.out.println("x/y: " + x/y); 11 | } 12 | } -------------------------------------------------------------------------------- /Programmazione/Laboratorio/1/Es5.java: -------------------------------------------------------------------------------- 1 | public class Es5{ 2 | 3 | public static void main(String[] args){ 4 | int x = 5, y = 2; 5 | int area = x*y; 6 | 7 | System.out.println("Lato1 = " + x); 8 | System.out.println("Lato2 = " + y); 9 | System.out.println("Area = " + area); 10 | 11 | } 12 | } -------------------------------------------------------------------------------- /Programmazione/Laboratorio/1/Es3.java: -------------------------------------------------------------------------------- 1 | public class Es3{ 2 | 3 | public static void main(String[] args){ 4 | int x = 7,y = 2; 5 | double a = 7.0, b = 2.0; 6 | 7 | System.out.println("x/y: " + x/y); //3 8 | System.out.println("x%y: " + x%y); //1 9 | 10 | System.out.println("a/b: " + a/b); //4.5 11 | } 12 | } -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/prolog/recursion.pro: -------------------------------------------------------------------------------- 1 | c(a,b). 2 | c(b,c). 3 | c(d,e). 4 | c(e,f). 5 | 6 | canGo(From,To) :- c(From, To), !. 7 | canGo(From,To) :- c(From, Middle), canGo(Middle, To). 8 | 9 | sum(0,X,X). 10 | sum(s(X),Y,Z) :- sum(X,s(Y),Z). %sposto da X sopra Y, quindi alla fine arrivo ad avere 0 e tanti S(Y). 11 | 12 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/cpolisimple/Potenza.h: -------------------------------------------------------------------------------- 1 | #ifndef _POTENZA_H 2 | #define _POTENZA_H 3 | 4 | struct potenza 5 | { 6 | char simbolo; 7 | int esponente; 8 | }; 9 | typedef struct potenza Potenza; 10 | 11 | Potenza* potenza_crea(char simbolo, int esponente); 12 | void potenza_stampa(Potenza* potenza); 13 | 14 | 15 | #endif -------------------------------------------------------------------------------- /Algoritmi/SomamDiProdotti.py: -------------------------------------------------------------------------------- 1 | def sommaProdotti(a, i, f): 2 | if i==f: 3 | return 0 4 | 5 | if f-i == 1: 6 | return a[i]*a[f] 7 | 8 | m = (i+f)//2 9 | 10 | return sommaProdotti(a, i, m) + sommaProdotti(a, m, f) 11 | 12 | 13 | #main 14 | a = [1,2,3,4,5] 15 | ris = sommaProdotti(a, 0, len(a)-1) 16 | print(ris) 17 | -------------------------------------------------------------------------------- /Programmazione/Laboratorio/1/Es6.java: -------------------------------------------------------------------------------- 1 | public class Es6{ 2 | 3 | public static void main(String[] args){ 4 | int x = 5, y = 2, h = 6; 5 | double area = ((x+y)*h)/2; 6 | 7 | System.out.println("Base1 = " + x); 8 | System.out.println("Base2 = " + y); 9 | System.out.println("Altezza = " + h); 10 | System.out.println("Area = " + area); 11 | } 12 | } -------------------------------------------------------------------------------- /Algoritmi/IT-SubStr.py: -------------------------------------------------------------------------------- 1 | def subStr(stringa,query): 2 | c = 0 3 | for i in range(0,len(stringa)): 4 | j = 0 5 | 6 | while (i+j)= RTT/(L/R) + 1 6 | Nel tempo del RTT quanti pacchetti (L/R) posso inviare? 7 | Il più 1 è per approssimare per eccesso e farci stare un pacchettoin più 8 | 9 | Utilizzo = N * L/R = numero che se è 1 è al massimo 10 | ------- 11 | RTT+L/R 12 | 13 | Latenza = Connessione + Invio + RTT = RTT + L/R + RTT 14 | 15 | 16 | -------------------------------------------------------------------------------- /Programmazione/Laboratorio/1/Es7.java: -------------------------------------------------------------------------------- 1 | public class Es7{ 2 | 3 | public static void main(String[] args){ 4 | 5 | System.out.println( (13+9+6-7)*2 ); 6 | System.out.println( (2+3)*5 + (2/3+5)*4 + 3*(7+5-13) ); 7 | System.out.println( ((3.4+5-6.3)*4.3 + (3.5*-4))*6 ); 8 | 9 | int x = 3, y = 5; 10 | 11 | System.out.println( (x+y)*(x-y) ); 12 | System.out.println( (x*x+y*y) ); 13 | System.out.println( ((x+y)*(x-y)) / ((2*x+y)*(2*x+y)) ); 14 | } 15 | } -------------------------------------------------------------------------------- /Programmazione/Laboratorio/4/Es6.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Es6{ 4 | 5 | public static void main(String[] args){ 6 | 7 | Scanner t = new Scanner(System.in); 8 | 9 | String str = t.nextLine(); 10 | 11 | for(int i=0;i 4 | #include 5 | 6 | 7 | Potenza* potenza_crea(char simbolo, int esponente) 8 | { 9 | Potenza* potenza = (Potenza*) malloc(sizeof(Potenza)); // alloca memoria per tenere dentro potenza e dammi il puntatore 10 | potenza->simbolo = simbolo; 11 | potenza->esponente = esponente; 12 | 13 | return potenza; 14 | } 15 | 16 | void potenza_stampa(Potenza* potenza){ 17 | printf("%c^%d", potenza->simbolo, potenza->esponente); 18 | } -------------------------------------------------------------------------------- /Programmazione/Laboratorio/2/Es6.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Es6{ 4 | 5 | public static void main(String[] arghs) 6 | { 7 | Scanner t = new Scanner(System.in); 8 | 9 | System.out.println("Inserisci Saldo: "); 10 | 11 | float saldo = t.nextFloat(); 12 | 13 | System.out.println("Saldo originale: "+ saldo); 14 | 15 | if(saldo<0) 16 | { 17 | saldo = saldo - 8; 18 | } 19 | else 20 | { 21 | saldo = saldo + (saldo*2/100); 22 | } 23 | 24 | System.out.println("Saldo finale: "+ saldo); 25 | 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Algoritmi/Compitino2012-06-20.py: -------------------------------------------------------------------------------- 1 | p1 = [20,11,24,36,43,12,11,43,20,33,42,34] 2 | 3 | p2 = [21,1,15,10,89,24,31,63,64,65,78,5] 4 | 5 | p3 = [] 6 | 7 | i = 0 8 | while len(p2) != 0: 9 | if i%2 == 0: 10 | n = p1.pop() 11 | else: 12 | n = p2.pop() 13 | 14 | if n%2 != 0: 15 | p3.append(n) 16 | 17 | i+=1 18 | 19 | print(p3) 20 | 21 | #Caso migliore 22 | #Non ci sono mai elementi dispari. 23 | #Faccio comunque tutte le pop 24 | #Spendo comunque r(n) 25 | 26 | #Caso peggiore 27 | #Ci sono solo elementi dispari. 28 | #E' comunque O(n) -------------------------------------------------------------------------------- /Architettura/2016-04-01.md: -------------------------------------------------------------------------------- 1 | Istruzione immediata 2 | Senza passare dai registri, a differenza d R-type (register) 3 | 4 | add $r3, $r1, $r2 5 | addi $r3, $r1, 1312 6 | 7 | Si posso indirizzare 2^32 celle da 1 byte 8 | byte = unità minima che posso prendere con le istruzioni di load/read 9 | 10 | 11 | Problema istruzione load 12 | Opcode 13 | Destinazione 14 | Indirizzo 15 | 16 | Ma solo l'indirizzo sono 32bit, come faccio? 17 | 18 | Soluzione: 19 | Opcode 20 | Destinazione 21 | RegistroCheContiene indirizzo base 22 | Offset (come facevamo in ASM) 23 | 24 | 25 | -------------------------------------------------------------------------------- /Computabilita/lab/lab03/Makefile: -------------------------------------------------------------------------------- 1 | # only works with the Java extension of yacc: 2 | # byacc/j from http://troi.lincom-asg.com/~rjamison/byacc/ 3 | 4 | JFLEX = jflex 5 | BYACCJ = byaccj -J 6 | JAVAC = javac 7 | 8 | # targets: 9 | 10 | all: Parser.class 11 | 12 | run: Parser.class 13 | java Parser 14 | 15 | build: clean Parser.class 16 | 17 | clean: 18 | rm -f *~ *.class *.java 19 | 20 | Parser.class: Yylex.java Parser.java 21 | $(JAVAC) Parser.java 22 | 23 | Yylex.java: films.flex 24 | $(JFLEX) films.flex 25 | 26 | Parser.java: films.y 27 | $(BYACCJ) films.y 28 | -------------------------------------------------------------------------------- /Algoritmi/ContaSottoArray.py: -------------------------------------------------------------------------------- 1 | def contaSottostringa(a,b): 2 | contaTrovato = 0 3 | i = 0 4 | 5 | for i in range(0, len(a)): #for i=0 to len(a)-1 6 | j = 0 7 | while i+j 2 | 3 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /Computabilita/lab/lab02/films.dtd: -------------------------------------------------------------------------------- 1 | 2 | 3 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /Computabilita/lab/lab03/films.dtd: -------------------------------------------------------------------------------- 1 | 2 | 3 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /Computabilita/multiplodi5inbinario.md: -------------------------------------------------------------------------------- 1 | 10 = 2 2 | 100 = 4 3 | 1000 = 8 4 | 5 | 100 = 4 6 | 1001 = 4*2+1 7 | 8 | Non ci serve sapere tutto il numero ma solo il suo resto quando diviso per 5. 9 | 10 | Tutti i numeri li possiamo rappresentare con 5a+b 11 | 12 | b varia tra 0 e 4 13 | 14 | Se arriva un altro 0 15 | Il numero corrente diventa 16 | 2(5a+b) = 10a+2b 17 | 18 | 10a+2b%5=2b%5 19 | 20 | Visto che b varia tra 0 e 4 si puo' fare facilmente 21 | 22 | 1 = 1b = 5*0+1 q1 23 | 2 = 10b = 5*0+2 q2 24 | 3 = 11b = 5*0+3 q3 25 | 4 = 100b = 5*0+4 q4 26 | 5 = 101b 5*1 q0 27 | 6 = 110b = 5*1+1 q1 28 | 7 = 5*1+2 q2 29 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/cpolisimple/Monomio.c: -------------------------------------------------------------------------------- 1 | #include "Monomio.h" 2 | 3 | #include 4 | #include 5 | 6 | #include "Potenza.h" 7 | 8 | Monomio* monomio_crea(int coefficiente, Potenza* potenza) 9 | { 10 | Monomio* monomio = (Monomio*) malloc(sizeof(Monomio)); // alloca memoria per tenere un monomio e dammi il puntatore a quella area di memoria 11 | monomio->coefficiente = coefficiente; 12 | monomio->potenza = potenza; 13 | 14 | return monomio; 15 | } 16 | 17 | void monomio_stampa(Monomio* monomio) 18 | { 19 | printf("%d*", monomio->coefficiente); 20 | potenza_stampa(monomio->potenza); 21 | } -------------------------------------------------------------------------------- /Architettura/2016-04-19-esercitazione.md: -------------------------------------------------------------------------------- 1 | 10bit di memoria 2 | indirizzo di memoria da 3 bit 3 | quanti bit è una parola di memoria? 4 | 5 | 2^3 indirizzo = 8 indirizzi 6 | 7 | Abbiamo un rettangolo di area 10bit, abbiamo l'altezza 8 | 9 | 10/8 = 1.spicci = 1.25 10 | 11 | Secondo loro meglio usare parole da 2 bit, così uso meglio la memoria. 12 | 13 | 14 | a = Math.pow(2,30)*64 15 | > a = a/8 16 | 8589934592 17 | > a = a/1024 18 | 8388608 19 | > a = a/1024 20 | 8192 21 | 22 | 23 | 2^30*2^6 = 2^36 bit 24 | 25 | 2^33 byte 26 | 2^23 kbyte 27 | 2^13 mbyte 28 | 29 | 30 | Esercizio 6 31 | Occhio che siamo in HEX! Quindi non si fa 80-100 ma 80 A0 32 | -------------------------------------------------------------------------------- /Architettura/mips/Add5Nums.asm: -------------------------------------------------------------------------------- 1 | # add 5 numbers 2 | # 3 | 4 | .data ## Data declaration section 5 | 6 | values: .word 111, 4, 5, 10, 12, 5, 12, 433, 0 7 | 8 | result: .word 0 9 | 10 | .text 11 | .globl main 12 | 13 | main: 14 | move $t1, $zero 15 | move $a0, $zero #sum 16 | 17 | la $s1, values #load into $s1 the label address 18 | 19 | loop: 20 | lw $a1, 0($s1) 21 | 22 | beq $a1, 0, exit #if zero exit 23 | 24 | add $a0, $a0, $a1 25 | addi $s1, $s1, 4 26 | addi $t1, $t1, 1 27 | 28 | j loop 29 | 30 | exit: 31 | la $s1, result 32 | sw $a0, 0($s1) 33 | 34 | li $v0, 10 # terminate program 35 | syscall -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/cpolisimple/Polinomio.c: -------------------------------------------------------------------------------- 1 | #include "Polinomio.h" 2 | 3 | #include 4 | #include 5 | 6 | #include "Monomio.h" 7 | 8 | Polinomio* polinomio_crea(int numeroMonomi) 9 | { 10 | Polinomio* polinomio = (Polinomio*) malloc(sizeof(Polinomio)); 11 | polinomio->numeroMonomi = numeroMonomi; 12 | polinomio->monomi = (Monomio**) malloc(sizeof(Monomio) * numeroMonomi); 13 | return polinomio; 14 | } 15 | 16 | void polinomio_stampa(Polinomio* polinomio){ 17 | for (int i = 0; i < polinomio->numeroMonomi; i++) 18 | { 19 | printf(" + "); 20 | monomio_stampa(polinomio->monomi[i]); 21 | } 22 | } -------------------------------------------------------------------------------- /Architettura/2016-05-26.md: -------------------------------------------------------------------------------- 1 | 2 | qui: 3 | sum 0xarray 2: 4 | // ra = qui 5 | sp = -8 6 | t0 = size-1 = 1 7 | 8 | sum 0xarray 1: 9 | SP -= 8 //-16 10 | t0 = size-1 = 0 11 | 12 | v0 = 0 13 | sp += 8 //torna su 14 | <-- jr ra 15 | elemento = punto l'elemento() 16 | 17 | $v0 = $v0 + elemento 18 | ra = sum 0xarray 2 19 | sp += 8 //torno su di nuovo 20 | jr ra //done! 21 | 22 | sp //torna su di nuovo 23 | # sum 0xarray 2 24 | # size-1 = 1 <--- //torna su 25 | # sum 0xarray 1 26 | # size-1 = 0 <--- 27 | # 28 | # 29 | # 30 | # -------------------------------------------------------------------------------- /Architettura/2016-04-07.md: -------------------------------------------------------------------------------- 1 | Istruzioni Itype e Rtype 2 | Solite cose 3 | 4 | Istruzione JType 5 | Non possiamo indicizzare 32bit di istruzioni! 6 | Ricordamo ad un hack che ci lascia usare non proprio 32bit ma un po' meno 7 | 8 | Con 26bit ne indirizzo 2^28, vengono aggiunti due zeri alla fine (in modo che finisco sempre con multipli di 4) 9 | 10 | Jtype branch 11 | 16bit per indicare dove saltare, offset a partire da un registro base (program counter in questo caso), non posso saltare dove voglio, ma più che sufficiente per l'uso base 12 | 13 | shift left 14 | shifta di 4 bit 15 | 16 | 17 | Catena di programmazione 18 | Sorgente -> Assembler -> Oggetto -> Linker -> Eseguibile 19 | 20 | -------------------------------------------------------------------------------- /SistemiDistribuiti/2017-03-28.md: -------------------------------------------------------------------------------- 1 | # Web Service 2 | 3 | ## What is a web service? 4 | 5 | A WS is a SW defined by a URI whose interface and bindings are capable of being defined, described and discovered by XML artifacts... 6 | 7 | ## Service Oriented Architecture 8 | 9 | Roles: 10 | 11 | * Providers 12 | * Brokers 13 | * Requestors 14 | 15 | Operations: Publish, Find, Interact 16 | 17 | Indipendenza tra chi costruisce il servizio e chi lo costruisce. Il trend è verso sistemi che non sono applicazioni complesse ma verso un'architettura ad N fornitori ed N gestori. 18 | 19 | 20 | ## BUsiness process 21 | 22 | Un set di attività correlate che permettono di arrivare ad un determinato outcome 23 | 24 | -------------------------------------------------------------------------------- /Algoritmi/merge.py: -------------------------------------------------------------------------------- 1 | a = [9,3,12,6,11] 2 | 3 | def QuickSort(i,f,j): 4 | if(ip: 22 | dx-=1 23 | 24 | 25 | if sxend) 21 | return -1; 22 | 23 | if(toFind 2 | #include "altra.h" 3 | 4 | 5 | struct Test 6 | { 7 | int i; 8 | } dummy = { 69 }; 9 | 10 | void foo(int* array, int* numero); 11 | void bar(struct Test* p); 12 | 13 | void separata(); 14 | 15 | 16 | int main(int argc, char const *argv[]) 17 | { 18 | int a = 42; 19 | int* b = &a; 20 | int z = *b; 21 | printf("%d\n", z); 22 | 23 | int numeri[10]; 24 | for (int i = 0; i < 10; ++i) 25 | { 26 | numeri[i] = i; 27 | } 28 | for (int i = 0; i < 10;) 29 | { 30 | foo(numeri, &i); 31 | } 32 | 33 | bar(&dummy); 34 | 35 | int* parray = numeri; 36 | parray += 2; 37 | printf("%d\n", *parray); 38 | 39 | separata(); 40 | altra(); 41 | 42 | return 0; 43 | } 44 | 45 | void foo(int* array, int* numero) 46 | { 47 | printf("We %d\n", array[*numero] ); 48 | *numero = *numero + 1; 49 | } 50 | 51 | void bar(struct Test* p) 52 | { 53 | printf("%d == %d\n", (*p).i, p->i); 54 | } 55 | -------------------------------------------------------------------------------- /Architettura/mips/Es1.asm: -------------------------------------------------------------------------------- 1 | # sum se a>0 2 | # multiply a<0 3 | # bitwise and b&c a==0 4 | # 5 | 6 | .data ## Data declaration section 7 | 8 | values: .word 0,111,4 #a,b,c 9 | 10 | result: .word 0 11 | 12 | .text 13 | .globl main 14 | 15 | main: 16 | la $s1, values #load into $s1 the label address 17 | 18 | lw $t0, 0($s1) #load into $t0 0+s1 19 | lw $t1, 4($s1) #load into $t1 4+s1 (next word) 20 | lw $t2, 8($s1) #load into $t1 8+s1 (next next word) 21 | 22 | blt $t0, 0, t0lesszero #branch-less-than t0<0: go to lessthan0 23 | beq $t0, 0, t0iszero 24 | 25 | #if i'm here $t0 is >=0 26 | #sum numbers: 27 | add $s0, $t0, $t1 28 | add $s0, $s0, $t2 29 | j exit 30 | 31 | t0lesszero: 32 | #multiply numbers 33 | mul $s0, $t0, $t1 34 | mul $s0, $s0, $t2 35 | j exit 36 | 37 | t0iszero: 38 | and $s0, $t1, $t2 39 | j exit #just for fun 40 | 41 | exit: 42 | la $s1, result 43 | sw $s0, 0($s1) 44 | 45 | li $v0, 10 # terminate program 46 | syscall -------------------------------------------------------------------------------- /APSoftware/laboratorio/lab6.mdown: -------------------------------------------------------------------------------- 1 | Operazione: creaPianta(nome: String) 2 | Riferimenti: caso d'uso Gestione Libreria - Gestione Pianta 3 | Pre-Condizioni: E' in corso la gestione della libreria delle piante 4 | Post-Condizioni: E' stata creata una istanza di Pianta, ed è stata associata con la Libreria. L'attributo nome della pianta è stato inizializzato al parametro nome del costruttore. Sono stati inizializzate le varie caratteristiche vitali della pianta. 5 | 6 | Operazione: setAltezzaPianta(Pianta p, altezza: float) 7 | Riferimenti: caso d'uso Gestione Libreria - Gestione Pianta 8 | Pre-Condizioni: E' in corso la modifica di una pianta 9 | Post-Condizioni: L'attributo altezza della pianta p viene settato al valore passato come parametro. 10 | 11 | Operazione: deletePianta(Pianta: p) 12 | Riferimenti: caso d'uso Gestione Libreria - Gestione Pianta 13 | Pre-Condizioni: E' in corso la modifica di una pianta 14 | Post-Condizioni: Viene eliminata la Pianta p dalla Libreria 15 | 16 | Diagramma classi: 17 | 18 | Libreria 19 | Pianta -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/prolog/lab-2016-10-28.pro: -------------------------------------------------------------------------------- 1 | %natural numbers 2 | natural(0). 3 | natural(s(X)) :- 4 | natural(X). 5 | 6 | %sum of two numbers 7 | sum(0, X, X). 8 | sum(s(X), Y, Z) :- 9 | sum(X, s(Y), Z). 10 | 11 | 12 | %product 13 | times(0, X, 0). 14 | times(s(X), Y, Z) :- 15 | times(X, Y, P), 16 | plus(P, Y, Z). %Z è accumulatore 17 | 18 | % times(s(0), s(s(0)), R) 19 | % -> chiamo times(0, s(s(0)), P). 20 | % -> CASO BASE P=0 21 | % -> chiamo plus(0, s(s(0)), T) 22 | % s(s(0)) 23 | % in sostanza times lo chiamo solo per far chiamare le somme che poi mi porto dietro tramite Z 24 | 25 | %double a list 26 | doublelist([], []). 27 | doublelist([E|R], [E, E | Y]) :- doublelist(R, Y). 28 | 29 | %check if element in list 30 | inlist(X, [X|R]) :- !. 31 | inlist(X, [H|R]) :- 32 | inlist(X, R). 33 | 34 | %join 35 | join([], L, L). 36 | join([A|X], Y, [A|Z]) :- join(X, Y, Z). 37 | 38 | %same length 39 | sameLen([], []). 40 | sameLen([H1|R1], [H2|R2]) :- sameLen(R1,R2). 41 | -------------------------------------------------------------------------------- /Programmazione/letitsnow.py: -------------------------------------------------------------------------------- 1 | import random 2 | import time 3 | import os 4 | 5 | def printMx(mx): 6 | for i in range(len(mx)): 7 | for j in range(len(mx[i])): 8 | print(mx[i][j], end="") #stampa la cella 9 | print() #vai a capo 10 | 11 | 12 | def updateMx(mx): 13 | for i in range(len(mx)): 14 | for j in range(len(mx[i])): 15 | if mx[i][j] == '*': 16 | mx[i][j] = '#' #deve ancora cedere 17 | 18 | for i in range(0, len(mx)): 19 | i = len(mx)-1-i 20 | for j in range(0, len(mx[i])): 21 | if mx[i][j] == '#' and i!=len(mx)-1: 22 | #potrebbe cadere 23 | #controllo sotto 24 | if mx[i+1][j] != '*' and mx[i+1][j] != '#': 25 | mx[i+1][j] = '*' 26 | mx[i][j] = ' ' 27 | return mx 28 | 29 | mx = [[' ' for i in range(20)] for j in range(10)] #creo matrice 20 colonne 10 righe 30 | 31 | while True: 32 | print("\033c"); #pulisce lo schermo 33 | col = random.randrange(0,len(mx[0])) #indice random 34 | mx[0][col] = '*' #metti la neve all'indice random 35 | printMx(mx) #stampa la matrice 36 | mx = updateMx(mx) #aggiorna la matrice 37 | 38 | 39 | -------------------------------------------------------------------------------- /Programmazione/mergeSort.py: -------------------------------------------------------------------------------- 1 | def mergeSort(alist): 2 | print("Splitting ",alist) 3 | if len(alist)>1: 4 | mid = len(alist)//2 5 | lefthalf = alist[:mid] 6 | righthalf = alist[mid:] 7 | 8 | mergeSort(lefthalf) 9 | mergeSort(righthalf) 10 | 11 | i=0 12 | j=0 13 | k=0 14 | 15 | while i < len(lefthalf) and j < len(righthalf): 16 | if lefthalf[i] < righthalf[j]: 17 | alist[k]=lefthalf[i] 18 | i=i+1 19 | else: 20 | alist[k]=righthalf[j] 21 | j=j+1 22 | k=k+1 23 | 24 | while i < len(lefthalf): 25 | alist[k]=lefthalf[i] 26 | i=i+1 27 | k=k+1 28 | 29 | while j < len(righthalf): 30 | alist[k]=righthalf[j] 31 | j=j+1 32 | k=k+1 33 | print("Merging ",alist) 34 | 35 | import random 36 | alist = [] 37 | for i in range(0, 1000000): 38 | alist.append(random.randint(1, 1000000000000000000)) 39 | mergeSort(alist) 40 | print(alist) 41 | -------------------------------------------------------------------------------- /Architettura/2016-03-31.md: -------------------------------------------------------------------------------- 1 | # La macchina programmata 2 | Instruction Set Architecture = ISA 3 | 4 | MIPS 5 | 6 | Registri = piccoli contenitori per fare operazioni 7 | ALU = manipolare dati 8 | Registro CI per la Current Instruction 9 | 10 | Esecuzione dell'istruzione richiede alcuni colpti di clock, più o meno dividere per 10 i ghz del clock per capire quante istruzioni al secondo 11 | 12 | Le istruzioni vengono dalla memoria, array di celle 13 | 14 | ciclo di fetch, poi la guarda e la interpreta 15 | nel frattempo il PC si incrementa 16 | 17 | Registri 18 | colpi di clock 19 | 20 | RAM 21 | qualche ciclo di clock 22 | 23 | Di massa 24 | millisecondi 25 | 26 | 27 | RISC 28 | Reduced instruction set 29 | 30 | 31 | 32 registri a 32 bit l'uno 32 | Istruzioni da 32 bit 33 | 34 | R-type 35 | tra le altre cose "Shift"=per fare lo shift del risultato 36 | op è tipo di istruzione (aka matematica, logica etc) funct l'istruzione della categoria "op" 37 | 38 | OCCHIO CHE LA CODIFICA BINARIA E' SORGENTE E DESTINAZIONE 39 | MENTRE ASM E' DESTINAZIONE E POI SORGENTE !!!! 40 | -------------------------------------------------------------------------------- /APSoftware/2017-03-23.md: -------------------------------------------------------------------------------- 1 | # Diagramma di sequenza 2 | 3 | ## Frame 4 | 5 | CI sono i frame che indicano delle particolari "parti" del nostro diagramma di interazione, che vengono eseguite/trattate a seconda del tipo del frame. 6 | 7 | ## Chiamate Asincrone 8 | 9 | 10 | ## Diagrammi di comunicazione 11 | 12 | Abbiamo oggetti non classi. 13 | 14 | I numeri si mettono in ordine temporale. Non fa differenza tra 1 1.1 2 e 1 2 3. 15 | 16 | # Casi d'uso 17 | 18 | ## Test casi d'uso 19 | 20 | * Test del capo 21 | * Cosa hai fatto tutto il giorno? Nome caso d'uso 22 | * Test del valore aggiunto 23 | * Questa attività aggiunge valore al business? 24 | * Test di dimensione 25 | * Formato dettagliato tra le 3 e 10 pagine 26 | * ENtità descritta è coerente autonoma significativa 27 | 28 | # Contratti 29 | 30 | E' quello che ci si aspetta: parte dei casi d'uso. 31 | 32 | Insieme di precondizioni per cui il contratto è reso valido. 33 | Ma è anche un insieme di post condizioni! 34 | 35 | Non mi curo di come è fatto il sistema, ma delle funzioni che deve fare. 36 | 37 | Operazione di sistema 38 | -------------------------------------------------------------------------------- /Fondamenti/Riassunto/30_Induzione.md: -------------------------------------------------------------------------------- 1 | #Induzione 2 | 3 | L'induzione è un metodo di ragionamento che è utile per: 4 | 5 | * Verificare proprietà di strutture di dati 6 | * Definire strutture dati 7 | * Definire procedimenti di calcolo su strutture dati attraverso la ricorsione 8 | 9 | ## Definizione 10 | 11 | ### Principio di Induzione Matematica 12 | 13 | Sia $A(n)$ una asserzione (proprietà da verificare) per ogni elemento dell'insieme dei numeri naturali $N$. Supponendo che: 14 | 15 | * $A(n)$ è vera 16 | * per ogni $k \in N$, se A(k) è vera, allora è vera anche $A(k+1)$ 17 | 18 | Allora per ogni $n \in N$, $A(n)$ è vera. 19 | 20 | ### Principio di Induzione Matematica Completo 21 | 22 | Sia $A(n)$ una asserzione (proprietà da verificare) per ogni elemento dell'insieme dei numeri naturali $N$. Supponendo che: 23 | 24 | * $A(n)$ è vera 25 | * per ogni $m \in N$, se $A(k)$ è vera per ogni $k$, con $00$, $A(n)$ è vera. 28 | 29 | 30 | ## Esempi di Dimostrazione per Induzione 31 | 32 | 33 | ## Dichiarazione di insiemi tramite l'induzione 34 | -------------------------------------------------------------------------------- /Algoritmi/2016-04-22.md: -------------------------------------------------------------------------------- 1 | Noi abbiamo array per gli head, per i next per le key. Non ha troppo senso pratico ma ok. 2 | 3 | List_Search(L,k) 4 | P = L.head 5 | 6 | while p.key != k and p!=null: 7 | p = p.next 8 | 9 | return p 10 | 11 | 12 | 13 | caso migliore = 3c = Omega(1) 14 | caso peggiore = O(n) 15 | 16 | Non posso fare la ricerca binaria su una lista ordinata, non posso sapere l'indirizzo delle "celle" a priori 17 | 18 | 19 | List Insert(L,x): //x è un puntatore ad una casella con tutte le informazioni già dentro 20 | l.next = l.head 21 | x.prev = null //extra solo per lista doppia 22 | l.head.prev = X //solo per lista doppia 23 | l.head = x 24 | 25 | ListDelete(L,x) 26 | If x.prev != null 27 | x.prev.next = x.next 28 | else 29 | l.head = x.next 30 | 31 | if x.next != null 32 | next.prev = x.prev 33 | 34 | //free 35 | 36 | 37 | List_min(L) 38 | pmin = l.head 39 | patt = l.head 40 | 41 | while patt != null: 42 | if patt.key < p_min.key: 43 | p_min = p_att 44 | 45 | p_att = patt.next 46 | 47 | return p_min -------------------------------------------------------------------------------- /Programmazione/Laboratorio/4/Es2.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Es2{ 4 | 5 | public static void main(String[] args){ 6 | 7 | Scanner t = new Scanner(System.in); 8 | 9 | System.out.println("Inserisci una frase: "); 10 | String str = t.nextLine(); 11 | 12 | while(str.charAt(0) == ' ' || str.charAt(0) == '\t'){ 13 | str = str.substring(1); 14 | } 15 | 16 | while(str.charAt(str.length()-1) == ' ' || str.charAt(str.length()-1) == '\t'){ 17 | str = str.substring(0,str.length()-2); 18 | } 19 | 20 | System.out.println("é" + str + "è"); 21 | if(str.length() == 0) 22 | { 23 | System.out.println("Non ci sono parole nella frase"); 24 | }else if (str.indexOf(" ") == -1){ 25 | System.out.println("C'è una sola parola!"); 26 | System.out.println("Lunghezza parola: " + str.length()); 27 | }else{ //piu parole 28 | System.out.println("La frase contiene piu' parole"); 29 | 30 | int spazio = str.indexOf(" "); 31 | String primaParola = str.substring(0,spazio); 32 | 33 | System.out.println(primaParola); 34 | 35 | System.out.println(str.substring(str.lastIndexOf(" ")+1)); 36 | } 37 | 38 | } 39 | } -------------------------------------------------------------------------------- /Architettura/mips/Add10-FindMax-CalculateAvg.asm: -------------------------------------------------------------------------------- 1 | #sum of 10 numbers, find max and avg 2 | # $a0 = sum of n numbers 3 | # $a1 = max 4 | # $a2 = avg 5 | 6 | .data 7 | 8 | array: .word 1,2,3,4,5,6,7,8,9,10 9 | 10 | .text 11 | .globl main 12 | 13 | main: 14 | 15 | la $t7, array #$t7 keeps the label of "array" 16 | 17 | move $a0, $0 #$a0 keeps the sum 18 | lb $a1, 0($t7) #$a1 keeps the max (set it to the first number of the array) 19 | 20 | move $t0, $0 #here we keep the number of loops / array offset //for(i=0 21 | 22 | jump: 23 | lb $t1, 0($t7) #load in $t1 the current value pointed by $t7 24 | 25 | add $a0, $a0, $t1 # calcualte sum 26 | 27 | ble $t1, $a1, _noMax #is current value less or eq than max? if so goto noMAx 28 | 29 | setMax: #if we are here we have a max, label added for clarification 30 | move $a1, $t1 #set $a1 equal to $t1: $a1 holds the max 31 | 32 | _noMax: 33 | addi $t0, $t0, 1 #increment number of checked values 34 | addi $t7, $t7, 4 #increment pointer //i++ 35 | 36 | blt $t0, 10, jump #if we have not checked 10 values jump up //i99) 13 | { 14 | System.out.println("Massimo 99 centesimi!!!"); 15 | System.exit(42); 16 | } 17 | 18 | System.out.println("Devo restituire" + resto + "centesimi"); 19 | 20 | int c50 = resto/50; 21 | resto = resto%50; 22 | 23 | int c20 = resto/20; 24 | resto = resto%20; 25 | 26 | int c10 = resto/10; 27 | resto = resto%10; 28 | 29 | int c5 = resto/5; 30 | resto = resto%5; 31 | 32 | int c2 = resto/2; 33 | resto = resto%2; 34 | 35 | int c1 = resto/1; 36 | resto = resto%1; 37 | 38 | System.out.println(c50 + " monete da 50 centesimi"); 39 | System.out.println(c20 + " monete da 20 centesimi"); 40 | System.out.println(c10 + " monete da 10 centesimi"); 41 | System.out.println(c5 + " monete da 5 centesimi"); 42 | System.out.println(c2 + " monete da 2 centesimi"); 43 | System.out.println(c1 + " monete da 1 centesimi"); 44 | 45 | } 46 | } -------------------------------------------------------------------------------- /BasiDiDati/2017-03-15.md: -------------------------------------------------------------------------------- 1 | # Esame 2 | 3 | Modello ER 4 | Modello Relazionale 5 | 6 | Una domanda d'esame è "definire almeno un vincolo di dominio" 7 | 8 | ## Vincoli di dominio 9 | 10 | Definito su un attributo 11 | 12 | Dom(Voto) [0..30] 13 | Dom(Lode) = [No,Si] 14 | 15 | ## Vincoli di tupla 16 | 17 | A tuple constaint over a relation R expresses is a property that must be true for all tuples in R 18 | 19 | Da scrivere in linguaggio naturale. 20 | 21 | Ad esempio: il valore di Lode=Si se il valore di Voto=30 cioè Lode=Si -> Voto=30 22 | 23 | ## Dipendenza funzionale 24 | 25 | Dato uno schema relazione R definito sugli attributi A1, A2, An. 26 | Date B e C due sottoinsiemi disgiunti di attributi, diciamo che c'è una dipendenza funzionale tra B e C e indichiamo con B->C qundo per qualche istanza i R, per ogni insieme di valori di B, un set unico di valori di C corrisponde. 27 | 28 | # Chiave 29 | 30 | Dato R ed un insieme di attributi A1,A2,Ak quando vale la proprietà A1,A2,Ak -> tutti gli attributi di R, diciamo che A1,A2,Ak è una superchiave 31 | 32 | Quando nessun sottoinsieme A1,Ak gode della stessa proprietà allora A1,Ak è una chiave = superchiave minimale. 33 | 34 | -------------------------------------------------------------------------------- /Programmazione/Laboratorio/3/Es1.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Es1{ 4 | 5 | public static void main(String[] args){ 6 | 7 | Scanner t = new Scanner(System.in); 8 | 9 | int vTeoria,vPratico; 10 | 11 | do{ 12 | System.out.print("Inserisci il voto dello scritto (tra -8 e 8): "); 13 | vTeoria = t.nextInt(); 14 | }while(vTeoria < -8 || vTeoria > 8); 15 | 16 | do{ 17 | System.out.print("Inserisci il voto del pratico (tra 0 e 24): "); 18 | vPratico = t.nextInt(); 19 | }while(vPratico < 0 || vPratico > 24); 20 | 21 | System.out.println(vTeoria + vPratico); 22 | 23 | if(vTeoria < 1 && (vTeoria + vPratico) >= 18) { 24 | System.out.println("Sei bocciato! Controllo smanettone! Devi studiare di piu' la teoria!"); 25 | } 26 | else if(vTeoria <= 0 && vPratico < 18) { 27 | System.out.println("Sei bocciato! Devi studiare di piu' la teoria e fare esercizi!"); 28 | } 29 | else if(vTeoria > 0 && (vTeoria + vPratico) < 18) { 30 | System.out.println("Sei bocciato! Devi fare esercizi!"); 31 | } 32 | else if((vTeoria + vPratico) > 30) { 33 | System.out.println("30 e lode!"); 34 | } else { 35 | System.out.println("Il tuo voto è " + (vTeoria+vPratico)); 36 | } 37 | } 38 | } -------------------------------------------------------------------------------- /SistemiDistribuiti/2017-03-14-esercitazione.md: -------------------------------------------------------------------------------- 1 | # Linguagg di markup 2 | 3 | Annoto un documento in modo che l'annotazione sia sintatticamente distinguibile dal testo. 4 | 5 | Le annotazioni possono avere diverse finalità: 6 | 7 | * presentazione 8 | * procedurali (istruzioni per programmi che elaborino il testo) 9 | * descrittive (etichettano semplicemente parti del testo, disaccopiando la struttua della presentazione dal testo stesso) 10 | 11 | # HTML 12 | 13 | HyperText Markup Language, specifica del W3C. 14 | 15 | # DOM 16 | 17 | E' una interfaccia neutrale rispetto al linguaggio di programmazione e alla piattaforma utilizzata per consentire l'accesso e la modifica dinamiba di contenuto, struttura e stile di un documento. 18 | 19 | DOM è un API definita da W3C. 20 | 21 | # Media Queries 22 | 23 | # Cascanding in CSS 24 | 25 | Le regole possono essere sovrascritte da altre. In cascata si applcano prima gli stili più importanti e via via quelli meno. 26 | 27 | + Prima si guardano gli !important ...... 28 | + Poi gli stili in linea 29 | + Poi si guardano gli id, poi le classie e poi i tag 30 | + A parità si guarda l'ultimo dichiarato nel documento 31 | 32 | # Separation of concernes 33 | 34 | Si separa la visualizzazione dalla rappresentazione 35 | -------------------------------------------------------------------------------- /Fondamenti/2015-10-06: -------------------------------------------------------------------------------- 1 | # Fondamenti di Informatica 2 | 3 | 4 | Matematica Discreta 5 | Basata su elementi distinguibili tra di loro, cioè su un numero finito di elementi. 6 | Matematica del discontinuo e del numerabile 7 | 8 | Qualitativo e Quantitativo 9 | Qualitativo = "Bello" "Brutto" 10 | Quantitativo = 15, 20, 3.14 11 | Discreto = Numeri interi 12 | Continuo = Incommensurabile: se ne occupa la fisica e l'analisi matematica 13 | 14 | I fenomeni reali sono generalmente discreti, tranne in rari casi. Allo stesso modo i sistemi informatici sono discreti, non si potrebbe fare altro. Ad esempio una curva (fenomeno continuo) viene tradotta in un insieme di N punti (quantificabili) 15 | 16 | Metodo matematica discreta 17 | Operazioni di classificazione 18 | Raggruppare oggetti/fenomeni in base a caratteristiche comuni 19 | 20 | Operazione di enumerazione 21 | Contare e dare un numero agli oggeti/fenomeni, a seconda di un indice 22 | 23 | Operazione di combinazione 24 | Permutare e cambiare gli oggetti/fenomeni (matrici, grafi) 25 | 26 | 27 | Logica 28 | Da logos, parola/pensiero 29 | Studio del ragionamento -> capire se le cose filano bene e se i ragionamenti sono validi 30 | 31 | Algebra Astratta 32 | Che studia le strutture algebrice 33 | Basata su gruppi, anelli, campi, spazi vettoriali 34 | -------------------------------------------------------------------------------- /APSoftware/laboratorio/Prova.java: -------------------------------------------------------------------------------- 1 | class Pianta { 2 | 3 | private String nome; 4 | private float altezza; 5 | 6 | public Pianta(String nome) { 7 | this.nome = nome; 8 | this.altezza = 0; 9 | } 10 | 11 | public void setAltezza(float a) { 12 | this.altezza = a; 13 | } 14 | } 15 | 16 | class Libreria { 17 | 18 | private ArrayList piante; 19 | 20 | public Libreria(){ 21 | piante = new ArrayList<>(); 22 | } 23 | 24 | public void aggiungiPianta(Pianta p) { 25 | piante.add(p); 26 | } 27 | 28 | public void rimuoviPianta(String n) { 29 | for(int i=0; i [3,1,2], elimina man mano la prima occorrenza, metodo meh ma gli va bene 25 | eliminaDuplicati([],[]). 26 | eliminaDuplicati([X|Resto], Ris) :- 27 | mymember(Resto, X), 28 | eliminaDuplicati(Resto, Ris), !. 29 | eliminaDuplicati([X|Resto], [X|Ris]) :- 30 | eliminaDuplicati(Resto, Ris). 31 | 32 | %valore assoluto 33 | abs(X, Y) :- X<0, !, Y is X*(-1). 34 | abs(X, X). 35 | 36 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/lisp/lab-2016-12-16.lisp: -------------------------------------------------------------------------------- 1 | (defun concat-lists(l1 l2) 2 | "Concat L1 to L2" 3 | (cond ((null l1) l2) 4 | (T (cons (first l1) (concat-lists (rest l1) l2))))) 5 | 6 | (defun insert-in-right-place(anumber mylist) 7 | "Insert a number in the right place in a sorted list" 8 | (cond ((null mylist) (list anumber)) 9 | ((< anumber (first mylist)) (cons anumber mylist)) 10 | (T (cons (first mylist) (insert-in-right-place anumber (rest mylist)))))) 11 | 12 | (defun join-lists(l1 l2) 13 | "Join L1 and L2 (no duplicates)" 14 | (cond ((null l1) l2) 15 | ((member (first l1) l2) (join-lists (rest l1) l2)) 16 | (T (cons (first l1) (join-lists (rest l1) l2))))) 17 | 18 | (defun censura-all-levels(mylist word) 19 | (cond ((null mylist) nil) 20 | ((atom mylist) (if (equal mylist word) 21 | 'xxx 22 | mylist)) 23 | (T (cons (censura-all-levels (first mylist) word) (censura-all-levels (rest mylist) word))))) 24 | 25 | (defun only-even-position(mylist) 26 | (cond ((null mylist) nil) 27 | ((null (rest mylist)) nil) 28 | (T (cons (second mylist) (only-even-position (rest (rest mylist))))))) 29 | 30 | (defun mymapcar(thefunction mylist) 31 | (if (null mylist) 32 | nil 33 | (cons (funcall thefunction (first mylist)) (mymapcar thefunction (rest mylist))))) 34 | 35 | -------------------------------------------------------------------------------- /Fondamenti/Riassunto/26_Reticoli.md: -------------------------------------------------------------------------------- 1 | # Reticoli 2 | 3 | ## Definizione 4 | I reticoli sono poset in cui per ogni coppia di $\pangle{x,y} \in S$ esistono un mimino maggiorante (che chiamiamo *join* e che indichiamo con il simbolo $\sqcup$) e un massimo minorante (che chiamiamo *meet* e che indichiamo con il simbolo $\sqcap$). 5 | 6 | ## Proprietà e proposizioni dei reticoli 7 | 8 | ### Complemento di un elemento 9 | 10 | Preso un reticolo $L$, un elemento $a'\in L$ è detto complemento di $a\in L$ se $a$ e $a'$ hanno lo stesso meet e join. (Il libro dice se hanno lo stesso minimo minorante e massimo maggiorante) 11 | 12 | ## Reticoli particolari 13 | 14 | ### Reticolo Completo 15 | 16 | Si chiama reticolo completo un reticolo $L$ in cui ogni sottoinsieme $A$ di $L$ ha un minimo maggiorante (non vuoto) e un massimo minorante (non vuoto). 17 | 18 | ### Reticolo Limitato 19 | 20 | Si chiama reticolo limitato un reticolo $L$ in cui esiste un elemento massimo ed uno minimo. 21 | 22 | ### Reticolo distributivo 23 | 24 | Si chiama reticolo distributivo un reticolo $L$ in cui per ogni terna di elementi ${x,y,z} \in L$ valgono le seguenti proprietà, che chiamiamo distributive: 25 | 26 | * $x \sqcap (y \sqcup z) = (x \sqcap y) \sqcup (x \sqcap z)$ 27 | * $x \sqcup (y \sqcap z) = (x \sqcup y) \sqcap (x \sqcup z)$ 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /Programmazione/Laboratorio/2/Es4.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Es4{ 4 | 5 | public static void main(String[] args){ 6 | 7 | Scanner t = new Scanner(System.in); 8 | 9 | System.out.println("Inserisci il resto da dare in centesimi (max 99): "); 10 | int resto = t.nextInt(); 11 | 12 | if(resto>99) 13 | { 14 | System.out.println("Massimo 99 centesimi!!!"); 15 | System.exit(42); 16 | } 17 | 18 | System.out.println("Devo restituire " + resto + " centesimi"); 19 | 20 | int c50 = resto/50; 21 | resto = resto%50; 22 | 23 | int c20 = resto/20; 24 | resto = resto%20; 25 | 26 | int c10 = resto/10; 27 | resto = resto%10; 28 | 29 | int c5 = resto/5; 30 | resto = resto%5; 31 | 32 | int c2 = resto/2; 33 | resto = resto%2; 34 | 35 | int c1 = resto/1; 36 | resto = resto%1; 37 | 38 | if(c50!=0) 39 | System.out.println(c50 + " monete da 50 centesimi"); 40 | 41 | if(c20!=0) 42 | System.out.println(c20 + " monete da 20 centesimi"); 43 | 44 | if(c10!=0) 45 | System.out.println(c10 + " monete da 10 centesimi"); 46 | 47 | if(c5!=0) 48 | System.out.println(c5 + " monete da 5 centesimi"); 49 | 50 | if(c2!=0) 51 | System.out.println(c2 + " monete da 2 centesimi"); 52 | 53 | if(c1!=0) 54 | System.out.println(c1 + " monete da 1 centesimi"); 55 | 56 | } 57 | } -------------------------------------------------------------------------------- /Architettura/2016-05-31.md: -------------------------------------------------------------------------------- 1 | Capire se è un interrupt 2 | 3 | 4 | mfc0 $k0, $13 5 | srl $k0, $k0, 2 //shift right logical 6 | andi $k0, $k0, 0x1f //faccio la mask per ottenere i bit dell'eccezione 7 | 8 | 9 | //vedo se $k0 è 0. 10 | 11 | * Abbiamo una CPU MIPS32, 1 istruzione ogni ciclo di clock 12 | * Clock a 500Mhz 13 | * Un device che emette 1000B/s 14 | * Impostare il DMA occupa 10 cicli di clock 15 | * Si vuole trasmettere n testo di 2*10^6 Byte 16 | 17 | Quanto ci mette in secondi la CPU con il DMA e con il polling? 18 | 19 | FARE A CASA 20 | 21 | 22 | Procedura che stampa il carattere alla posizione X della stringa S 23 | 24 | stampaChar: 25 | #$a0 = indirizzo di memoria 26 | add $t0, $a0, $a1 #indirizzo+spiazzamento 27 | 28 | lb $a0, 0($t0) 29 | li $v0, 11 30 | syscall 31 | 32 | jr $ra 33 | 34 | 35 | stampaCharControllato: 36 | blz $a1, esci #se minore di 0 37 | 38 | li $t0, 0 39 | loop: 40 | lw $t1, 0($a0) 41 | 42 | beq $t1, '\0', esci 43 | 44 | beq $t0, $a1, stampa 45 | 46 | addi $t0, $t0, 1 47 | addi $a0, $a0, 1 48 | 49 | j loop 50 | 51 | stampa: 52 | lb $a0, 0($a0) 53 | li $v0, 11 54 | syscall 55 | j esci 56 | 57 | esciMessaggio: 58 | la $a0, messaggio 59 | li $v0, 4 60 | syscall 61 | 62 | esci: 63 | jr $ra 64 | -------------------------------------------------------------------------------- /Architettura/mips/functioncalls.asm: -------------------------------------------------------------------------------- 1 | .data 2 | 3 | notes: 67, 67, 67, 63, 70, 67, 63, 70, 67, 4 | 74, 74, 74, 75, 70, 66, 63, 70, 67, 5 | 79, 67, 67, 79, 78, 77, 76, 75, 75, 6 | 0, 68, 73, 72, 71, 70, 69, 70 , 0, 7 | 64, 66, 64, 67, 70, 67, 70, 74, 8 | 79, 67, 67, 79, 78, 77, 76, 75, 75, 9 | 0, 68, 73, 72, 71, 70, 69, 70 , 0, 10 | 64, 66, 64, 67, 70, 67, 70, 67, -1 11 | 12 | times: 500, 500, 500, 333, 125, 500, 333, 125, 1000, 13 | 500, 500, 500, 333, 125, 500, 333, 125, 1000, 14 | 500, 333, 125, 500, 333, 125, 125, 125, 250 15 | 125, 125, 500, 333, 125, 125, 125, 250, 125, 16 | 125, 500, 333, 125, 500, 333, 125, 1000, 17 | 500, 333, 125, 500, 333, 125, 125, 125, 250 18 | 125, 125, 500, 333, 125, 125, 125, 250, 125, 19 | 125, 500, 333, 125, 500, 333, 125, 1000 20 | .text 21 | .globl main 22 | 23 | main: 24 | 25 | la $t6, notes 26 | la $t7, times 27 | li $t1, 0 28 | 29 | loop: 30 | li $v0, 33 #suona 31 | 32 | lw $t2, 0($t6) 33 | move $a0, $t2 #nota 34 | 35 | lw $t3, 0($t7) 36 | move $a1, $t3 #durata 37 | 38 | li $a2, 22 #strumento 39 | li $a3, 127 #volumea3 40 | syscall 41 | 42 | 43 | addi $t6, $t6, 4 44 | addi $t7, $t7, 4 45 | addi $t1, $t1, 1 46 | bne $a0, -1, loop 47 | 48 | li $v0, 17 49 | syscall 50 | -------------------------------------------------------------------------------- /APSoftware/teoria/06_SSD.md: -------------------------------------------------------------------------------- 1 | # Diagrammi di Sequenza e Contratti 2 | 3 | Fanno parte dei diagrammi di interazione. 4 | 5 | Un diagramma di sequenza di sistema è un elaborato che illustra eventi di input ed output relativi ai sistemi in discussione. 6 | 7 | Un diagramma di sequenza di sistema è una figura che mostra, per un particolare scenario di un caso d'uso, gli eventi generati da attori esterni, il loro ordine e gli eventi tra i vari sistemi. 8 | 9 | ## Contratti 10 | 11 | I contratti delle operazioni usano pre-condizioni e post-condizione per descrivere i cambiamenti agli oggetti in un modello di dominio. 12 | 13 | ### Esempio di Contratto 14 | 15 | Operazione: enterItem(itemId: ItemID, quantity: Integer) 16 | Riferimenti: caso d'uso Process Sale 17 | Pre-Condizioni: E' in corso una vendita 18 | Post-Condizioni: E' stata creata una istanza di SalesItem, associata con la Sale corrente. SalesItem.quantity è diventata quantity, SalesItem è stata associata con una ProductDescription, in base alla corrispondenza con itemID 19 | 20 | ### Sezioni del contratto 21 | 22 | * Operazioni: nome e parametri dell'operazione 23 | * Riferimenti: casi d'uso in cui può verificarsi questa operazione 24 | * Pre-condizioni: ipotesi significati sullo stato del sistema 25 | * Post-condizioni: lo stato degli oggetti dopo il completamente dell'operazione (istanze, associazioni, modifica attributi) 26 | 27 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/lisp/esercizi-vari.lisp: -------------------------------------------------------------------------------- 1 | (defun nopred(predname something) 2 | (cond ((null something) '()) 3 | ((atom something) 4 | (if (funcall predname something) something)) 5 | ((listp something) 6 | (let ((thevalue (nopred predname (first something)))) 7 | (if (null thevalue) 8 | (nopred predname (rest something)) 9 | (cons thevalue (nopred predname (rest something)))))))) 10 | 11 | (defun my-reduce(func elements) 12 | (cond ((null (rest elements)) (first elements)) 13 | (T (my-reduce func 14 | (cons (funcall func (first elements) (second elements)) 15 | (rest (rest elements))))))) 16 | 17 | (defun nopred2 (predname list) 18 | (if (null list) nil 19 | (let ((head (first list)) 20 | (tail (rest list))) 21 | (cond ((null head) (cons '() (nopred2 predname tail))) 22 | ((atom head) 23 | (if (funcall predname head) 24 | (nopred2 predname tail) 25 | (cons head (nopred2 predname tail)))) 26 | ((listp head) 27 | (cons (nopred predname head) (nopred2 predname tail))))))) 28 | 29 | 30 | (defun remove-at(list place) 31 | (cond ((null list) nil) 32 | ((< place 0) list) 33 | ((= place 0) (rest list)) 34 | (T (cons (first list) (remove-at (rest list) (+ place -1)))))) 35 | 36 | (defun reverse*(list) 37 | (cond ((null list) nil) 38 | (T (cons (reverse* (rest list)) (first list))))) 39 | -------------------------------------------------------------------------------- /Computabilita/riassunto/99-CoseSulLab.md: -------------------------------------------------------------------------------- 1 | # Laboratorio 2 | 3 | ### Input Analizzatore Lessicale 4 | Sequenza di stringhe di simboli unicode che vengono trasformati in token 5 | 6 | ### Input Analizzatore sintattico 7 | Sequenza di token lessicalmente corretti 8 | 9 | ### Dfferenza tra grammatica lessicale e grammatica sintattica 10 | L'analisi lessicale raggruppa e controlla i simboli in token che verranno analizzati sintatticamente dal parser che controlla la loro composizione alla base della sintassi del linguaggio. 11 | 12 | ### Compilatore 13 | 14 | * Line Recontructor - prepara l'input per il lexer 15 | * Lexer + Parser - riconosce Token e crea la struttura sintattica del codice 16 | * Semantic Checker - crea il parse tree 17 | * Code Generator - analisi ed ottimizzazione del parse tree 18 | 19 | ### Parse Tree 20 | E' l'output di un parser e rappresenta la struttura sintattica di un programma 21 | 22 | ### Parse Stack 23 | Contiene i vari token letti dall'inputi attraverso l'operazione di shift. 24 | 25 | ### Bottom-up parser 26 | Si parte dalla stringa prodotta e si costruisce il parse tree dalle fogli verso i vari padri fino alla root (start symbol). 27 | 28 | ### Left-right parser 29 | Legge la stringa da sinistra a destra 30 | E cerca nell'input elaborato le sottostringhe che corrispondono al corpo di una produzione partedo da destra e applica quella produzione al contrario. 31 | 32 | 33 | -------------------------------------------------------------------------------- /Programmazione/Laboratorio/2/Es5.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Es5{ 4 | 5 | public static void main(String[] args){ 6 | 7 | Scanner t = new Scanner(System.in); 8 | 9 | System.out.println("Inserisci il resto da dare in centesimi (max 99): "); 10 | int resto = t.nextInt(); 11 | 12 | if(resto>99) 13 | { 14 | System.out.println("Massimo 99 centesimi!!!"); 15 | System.exit(42); 16 | } 17 | 18 | System.out.println("Devo restituire " + resto + " centesimi"); 19 | 20 | int c50 = resto/50; 21 | resto = resto%50; 22 | 23 | int c20 = resto/20; 24 | resto = resto%20; 25 | 26 | int c10 = resto/10; 27 | resto = resto%10; 28 | 29 | int c5 = resto/5; 30 | resto = resto%5; 31 | 32 | int c2 = resto/2; 33 | resto = resto%2; 34 | 35 | int c1 = resto/1; 36 | resto = resto%1; 37 | System.out.println(c50 + " " + (c50 > 1 || c50 == 0 ? "monete" : "moneta") + " da 50 centesimi"); 38 | System.out.println(c20 + " " + (c20 > 1 || c20 == 0 ? "monete" : "moneta") + " da 20 centesimi"); 39 | System.out.println(c10 + " " + (c10 > 1 || c10 == 0 ? "monete" : "moneta") + " da 10 centesimi"); 40 | System.out.println(c5 + " " + (c5 > 1 || c5 == 0 ? "monete" : "moneta") + " da 5 centesimi"); 41 | System.out.println(c2 + " " + (c2 > 1 || c2 == 0 ? "monete" : "moneta") + " da 2 centesimi"); 42 | System.out.println(c1 + " " + (c1 > 1 || c1 == 0 ? "monete" : "moneta") + " da 1 centesimi"); 43 | 44 | } 45 | } -------------------------------------------------------------------------------- /RetiSistemiOperativi/esercizioCollisione.md: -------------------------------------------------------------------------------- 1 | Assumiamo che ci siano due host A e B attaccati alle opposte estremità di un segmento ethernet alla distanza di 900 m. 2 | 3 | I due host devono inviare l'uno all'altro frame da 1.000 bit ciascuno. 4 | 5 | Supponiamo che la velocità del segnale sia di 200 milioni di metri al secondo, che l'ampiezza di banda sia di 10 Mbps e che ci siano quattro ripetitori tra i due host che introducono un ritardo di 25 bit ciascuno sulla trasmissione. 6 | 7 | Entrambi gli host iniziano a trasmettere a t=0. 8 | 9 | Dopo la collisione A estrae K=0 e B K=1. 10 | 11 | Dopo quanto tempo il frame di B è completamente consegnato ad A, assumendo che B inizi a trasmettere senza problemi subito dopo che ha ricevuto il frame da A? 12 | 13 | 14 | 25bit = 25/10000000 = 0.0000025 = 2.5microsec 15 | 16 | Dopo Rprop + 2.5ms * 4 rilevo la collisione -> 14.5microsec = 145bit 17 | 18 | JAM = 48bit = 4.8microsec = 48bit 19 | 20 | RProp = D/V= 4.5/1000000 = 21 | 22 | Ttrams = 1/10000 = 1000bit 23 | 24 | 0 = inizio trasmissione 25 | 145bit = primo bit contemporaneo, entrambi smettono di trasmettere 26 | 145+145 = arriva la coda di bit 27 | 290+48 = fine segnale di jam 28 | 29 | 338+96 = A inzia a trasmettere 30 | 434+145 = Arriva a B il primo bit del messaggio 31 | 579+1000 = arriva a B l'ultimo bit del messaggio 32 | 33 | 1579+96 = B inzia a trasmettere 34 | ^ + 145 = arriva il primo bit ad A 35 | ^ + 1000 = Arriva l'ultimo bit ad A 36 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/lisp/#esercizi-vari.lisp#: -------------------------------------------------------------------------------- 1 | (defun nopred(predname something) 2 | (cond ((null something) '()) 3 | ((atom something) 4 | (if (funcall predname something) something)) 5 | ((listp something) 6 | (let ((thevalue (nopred predname (first something)))) 7 | (if (null thevalue) 8 | (nopred predname (rest something)) 9 | (cons thevalue (nopred predname (rest something)))))))) 10 | 11 | (defun my-reduce(func elements) 12 | (cond ((null (rest elements)) (first elements)) 13 | (T (my-reduce func 14 | (cons (funcall func (first elements) (second elements)) 15 | (rest (rest elements))))))) 16 | 17 | (defun nopred2 (predname list) 18 | (if (null list) nil 19 | (let ((head (first list)) 20 | (tail (rest list))) 21 | (cond ((null head) (cons '() (nopred2 predname tail))) 22 | ((atom head) 23 | (if (funcall predname head) 24 | (nopred2 predname tail) 25 | (cons head (nopred2 predname tail)))) 26 | ((listp head) 27 | (cons (nopred predname head) (nopred2 predname tail))))))) 28 | 29 | 30 | (defun remove-at(list place) 31 | (cond ((null list) nil) 32 | ((< place 0) list) 33 | ((= place 0) (rest list)) 34 | (T (cons (first list) (remove-at (rest list) (+ place -1)))))) 35 | 36 | (defun reverse*(list) 37 | (cond ((null list) nil) 38 | (T (cons (reverse* (rest list)) (first list))))) 39 | 40 | 41 | (defun average(list) 42 | (/ (reduce #'+ list) 43 | (length list))) -------------------------------------------------------------------------------- /Complementi/EserciziSecondo.tex: -------------------------------------------------------------------------------- 1 | 2 | \begin{domanda} 3 | Sia $p$ un punto in cui l'hessiano della funzione $f$ a due variabili è definito positivo. 4 | 5 | Quale tra le seguenti è corretta: 6 | \begin{itemize} 7 | \item se $f$ ha differenziale non nullo in $p$, allora $p$ può essere un minimo locale: ha senso, il differenziale/gradiente non è nullo e quindi posso fare la derivata seconda che mi permette di definire il segno 8 | \end{itemize} 9 | 10 | \end{domanda} 11 | 12 | \begin{domanda} 13 | Una funzione $f$ in due variabili $x,y$ ammette derivate parziali in un dominio $D$ del piano se: 14 | 15 | \item se è integrabile su $D$: ??? 16 | \item se è continua su $D$: la continuità non implica nulla in $R^2$ 17 | \item se è quoziente di due polinomi, uno strettamente positivo e uno strettamente negativo su $D$: si ottiene una funzione continua e come abbiamo detto la continuità non implica nulla. 18 | \item ammette almeno due derivate direzionali in direzioni distinte in ogni punto di $D$: ??? 19 | \end{domanda} 20 | 21 | \begin{domanda} 22 | Si consideri la funzione $f(x,y)=2x^3y^2-x^2y$. Supponiamo di essere in posizione $P=(1,1,1)$ sul grafico di $f$. Quale angolo (rispetto al semiasse positivo $x$) il mio vettore spostamento deve seguire perchè io non scenda, immediatamente dopo la partenza? 23 | 24 | E' il problema fatto in classe dell'omino che scappa dal fuoco. 25 | 26 | Per prima cosa individuiamo il gradiente nel punto. 27 | 28 | $\nabla f = (6x^2y^2-2xy,4yx^3-x^2)$ 29 | $\nabla f(1,1) = (4,3)$ 30 | 31 | 32 | \end{domanda} -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/prolog/lists.pl: -------------------------------------------------------------------------------- 1 | %List stuff 2 | 3 | doubleLen([],[]). 4 | doubleLen([_,_|R],[_|R2]) :- doubleLen(R,R2). 5 | 6 | reverse(S,R) :- reverse(S, [], R). 7 | reverse([], Acc, Acc). 8 | reverse([H|Tail], Acc, Ret) - reverse(Tail, [H|Acc], Ret). 9 | 10 | compress([],[]) :- !. 11 | compress([X],[X]) :- !. 12 | compress([X,X|R], R2) :- compress([X|R], R2), !. 13 | compress([X,Y|R], [X|R2]) :- !, X\=Y, compress([Y|R], R2). 14 | 15 | duplicate([],[]) :- !. 16 | duplicate([X], [X,X]) :- !. 17 | duplicate([X|R], [X,X|R2]) :- duplicate(R,R2). 18 | 19 | project([],[]) :- !. 20 | project([F|R],[E|R2]) :- functor(F,_,N), N>=2, arg(2, F, E), project(R,R2). 21 | 22 | 23 | horn(and(ListOfOrs)):- 24 | loopAnd(ListOfOrs). 25 | 26 | loopAnd([]) :- !. %gestisci caso base / secondo input 27 | loopAnd([or(List)|Rest]) :- 28 | loopOr(List,N), 29 | N=<1, %se un or mi ritorna un numero di non-not <=1 allora va tutto bene 30 | loopAnd(Rest). 31 | 32 | loopOr(P, 0) :- atomic(P), !. %gestisci primo input 33 | loopOr([], N) :- !. %caso base 34 | loopOr([Pred|Rest], N) :- 35 | functor(Pred, Name, _), 36 | Name\=not, %una cosa diversa dal not 37 | !, %per forza qui devo proseguire 38 | loopOr(Rest, N2), %conto il resto 39 | N is N2+1. %aggiorno il contatore 40 | loopOr([_Pred|Rest], N):- %trovo un not 41 | loopOr(Rest, N). %proseguo 42 | 43 | 44 | replace([], X, Y, []). 45 | replace([X|Resto], X, Y, [Y|Altro]) :- !, replace(Resto, X, Y, Altro). 46 | replace([O|Resto], X, Y, [O|Altro]) :- replace(Resto, X, Y, Altro). 47 | -------------------------------------------------------------------------------- /Computabilita/lab/lab03/ParserVal.java: -------------------------------------------------------------------------------- 1 | //############################################# 2 | //## file: Parser.java 3 | //## Generated by Byacc/j 4 | //############################################# 5 | /** 6 | * BYACC/J Semantic Value for parser: Parser 7 | * This class provides some of the functionality 8 | * of the yacc/C 'union' directive 9 | */ 10 | public class ParserVal 11 | { 12 | /** 13 | * integer value of this 'union' 14 | */ 15 | public int ival; 16 | 17 | /** 18 | * double value of this 'union' 19 | */ 20 | public double dval; 21 | 22 | /** 23 | * string value of this 'union' 24 | */ 25 | public String sval; 26 | 27 | /** 28 | * object value of this 'union' 29 | */ 30 | public Object obj; 31 | 32 | //############################################# 33 | //## C O N S T R U C T O R S 34 | //############################################# 35 | /** 36 | * Initialize me without a value 37 | */ 38 | public ParserVal() 39 | { 40 | } 41 | /** 42 | * Initialize me as an int 43 | */ 44 | public ParserVal(int val) 45 | { 46 | ival=val; 47 | } 48 | 49 | /** 50 | * Initialize me as a double 51 | */ 52 | public ParserVal(double val) 53 | { 54 | dval=val; 55 | } 56 | 57 | /** 58 | * Initialize me as a string 59 | */ 60 | public ParserVal(String val) 61 | { 62 | sval=val; 63 | } 64 | 65 | /** 66 | * Initialize me as an Object 67 | */ 68 | public ParserVal(Object val) 69 | { 70 | obj=val; 71 | } 72 | }//end class 73 | 74 | //############################################# 75 | //## E N D O F F I L E 76 | //############################################# 77 | -------------------------------------------------------------------------------- /APSoftware/2017-03-31.md: -------------------------------------------------------------------------------- 1 | # Pattern Grasp 2 | 3 | General Responsibility Assignment Patterns 4 | 5 | ## Responsibility Drived Development 6 | 7 | Progettazione ad oggetti basata su: 8 | 9 | * Responsabilità 10 | * Chi è responsabile di cosa nel mio sistema 11 | * Astrazione di cioè che si deve saper fare 12 | * Ruoli 13 | * Partecipazione ad una relazione con un altro oggetto 14 | * Collaborazioni 15 | * Oggetti collaborano per un obiettivo 16 | 17 | ### Tipi di responsabilitàà 18 | 19 | * Responsabilità di fare 20 | * Fare qualcosa 21 | * Eseguire un calcolo 22 | * Creare o modificare oggetti di tipo omogeneo 23 | * Dare inizio ad una azione 24 | * Controllare e coordinare oggetti 25 | * Responsabilità di conoscere 26 | * Conoscere dati privati 27 | * Conoscere .... 28 | 29 | * Granularità fine: 30 | * Granularità grossa: 31 | 32 | ## Assegnare le responsabilità 33 | 34 | Le posso assegnare o durante la progettazione o durante la codifica 35 | 36 | ## Principi di progettazione 37 | 38 | * Information expert 39 | * Assegno in base all'elemento che ha la conoscenza per fare una operazione 40 | * Creazione 41 | * chi è responsabile di creare una nuova istanza di classe 42 | * Coupling 43 | * Low Coupling 44 | * Accoppiamento e dipendenza bassa, impatto dei cambiamenti basso e riuso maggiore. Un oggetto è in relazione con pochi ed in modo "semplice" 45 | * Non è parte intrinseca del problema, ma intrinseca della qualità della soluzione 46 | * High Coupling 47 | * L'oggetto è in relazione con molte classi e in più modi 48 | * Controller 49 | * Separa visualizzazione dai dati -------------------------------------------------------------------------------- /Architettura/2016-05-05.md: -------------------------------------------------------------------------------- 1 | # Procedure 2 | 3 | Flusso di controllo 4 | 5 | La chiamata di una procedura è un salto alla label che punta al pezzo di codice della procedura, non esiste nulla come la chiamata di una funzione(). 6 | 7 | Quando si fa return si salta indietro al "main". 8 | 9 | 10 | La chiamata della procedura si fa con la "jal", jump and link. Salvando nel registro $ra, return address, l'indirizo a cui deve tornare dopo l'esecuzione della procedura. $ra = indirizzo jr+4. 11 | 12 | Passaggio parametri 13 | $a0-$a3 Arguments 14 | $v0-$v1 return Values 15 | 16 | Far girare gli esempi 17 | 18 | Cosa succede se una procedura chiama un'altra? 19 | Si usa lo stack. 20 | 21 | Dove stanno le variabili locali della procedura? 22 | 23 | 24 | Syscall 25 | Impostare il codice della chiamata in $v0 26 | Impostare parametro in $a0-$a3 27 | Syscall 28 | Codice 17, termina programma 29 | 30 | Esempio di stampa da guardare 31 | 32 | 33 | I registri $s sono salvati dalla procedura 34 | Puo' essere che fa push nello stack 35 | E poi pop 36 | I registri $t non sono salvati dalla procedura 37 | 38 | Procedura foglia 39 | Non chiama procedure 40 | 41 | Non foglia 42 | Chiama Procedure 43 | 44 | Se c'è una procedura foglia deve anche salvare $ra nello stack 45 | 46 | 47 | Convenzioni di uso della memoria 48 | Sia da parte del linker/compiatore ma anche dai programmatori 49 | 50 | Figura 5.1 dell'appendice A 51 | 52 | C'è una parte per lo stack (stack segment) 53 | Spazio per dati dinamici 54 | Dati Statici 55 | Programma 56 | Reserved 57 | 58 | Alla crescita dello stack, cresce lo stack pointer $sp 59 | -------------------------------------------------------------------------------- /APSoftware/2017-03-10-esercitazione.md: -------------------------------------------------------------------------------- 1 | Ogni iterazione produce un mini progetto ceh include: 2 | * pianificazione 3 | * analisi e progettazione 4 | * costruzione 5 | * integrazione e test 6 | * rilascio 7 | 8 | RUP sprcifica: 9 | 10 | + requisiti 11 | + analisi 12 | + progettazione 13 | + implementazione 14 | + test 15 | 16 | Baseline: insieme di documenti prodotti in ogni fase 17 | 18 | ## Analisi dei requisiti 19 | 20 | Alto livello di specifiche, costruito intervistando gli stakeholder (cliente e utente finale) 21 | 22 | Come si fa: 23 | 24 | + individuo gli attori e i casi d'uso 25 | + assegno priorità ai casi d'uso 26 | + descrivo i casi d'uso 27 | + progetto un'interfaccia utente 28 | 29 | ma c'è un problema? come rappresento le cose non funzionali? uso un estensione del modello precedente. 30 | 31 | + Individuo i requisiti funzionali 32 | + Individuo i requisiti non funzionali 33 | 34 | ### Come formulare i requisiti 35 | 36 | Il dovrà 37 | 38 | In UML però non c'è uno standard. Puoi fare come vuoi. Noi usiamo quello sopra. 39 | 40 | 41 | ### Come organizzare i requisiti 42 | 43 | Funzionali: in base all'aspetto che toccano 44 | 45 | * Clienti 46 | * Prodotti 47 | * Ordini 48 | * Pagamenti 49 | 50 | Non funzionali: 51 | 52 | * prestzioni 53 | * capacità 54 | * disponibilità 55 | * conformità agli standard 56 | * sicurezza 57 | 58 | ### Priorità dei requisiti 59 | 60 | * must have 61 | * should have, è importante ma può essere omesso 62 | * could have, se c'è tempo 63 | * want to have, in versioni successive 64 | 65 | Il modello MoSCoW 66 | 67 | # Esercizio 68 | 69 | 70 | -------------------------------------------------------------------------------- /SistemiDistribuiti/teoria/11-RDF-Sparql.md: -------------------------------------------------------------------------------- 1 | # RDF 2 | 3 | RDF sta per Resource Description Framework. 4 | 5 | Modello per la rappresentazione dei dati sul Web. 6 | 7 | ## Unità di base 8 | 9 | * triple: unità base di organizzazione delle informazioni 10 | * grafi orientati: insiemi di triple 11 | * URI: identificazione univoca sul web degli oggetti rappresentati 12 | * devo avere una radice comune a tutte le risorse: un sito in cui posso mettere le risorse 13 | * possono esssere abbreviati con i namespace 14 | 15 | ## Caratteristiche 16 | 17 | * Indipendenza: ognuno può inventare i predicati 18 | * Interscambiabilità: posso convertire RDF in XML 19 | * Scalabilità: semplici da replicare e da parsare 20 | * Le proprietà sono risorse: anche esse hanno un URI 21 | 22 | 23 | ## Triple 24 | 25 | Le triple sono nel formato 26 | 27 | `soggetto predicao oggetto` 28 | 29 | Un oggetto può essere un altra risorsa RDF oppure un literal. 30 | 31 | Esistono plain literals (stringhe) e typed literals (stringhe contestualizzate) 32 | 33 | `"2006"^^xsd:integer` 34 | 35 | ## RDF Schema 36 | 37 | ## RDFS 38 | 39 | RDF Schema, serve a dare più espressività e a vincolare domini e codomini di certe proprietà 40 | 41 | E' un estensione di RDF che permette di esprimere concetti sopra i limiti e i vincoli di RDF. In particolare ci permette di definire il concetto di classe, proprietà, risorsa, letterale, gerarchia di classi, domini. 42 | 43 | **Definisce classi e proprietà che possono essere usate per descrivere classi e proprietà e risorse** 44 | 45 | ## OWL 46 | 47 | Un estensione di RDF che mi permette che mi permette di fare i check dei vincoli e stabilire relazioni simil prolog. 48 | -------------------------------------------------------------------------------- /Architettura/2016-0-5-24-esercitazione.md: -------------------------------------------------------------------------------- 1 | Eccezioni = variazioni delle condizioni normali 2 | Consegenze -> Cambiamento nel flusso normale 3 | Chi crea l'eccezione? Errore del programma, richiesta del programma, evento esterno 4 | 5 | Sincrone "involontario": impreviste, causate da elaborazioni con valori non ammissibili 6 | Sincrono "volontarie": syscall/break 7 | Asincrone: interrupt delle periferiche 8 | 9 | Coprocessore 1: fa operazioni aritmetiche sul floating point 10 | Coprocessore 0: si occupa delle eccezioni 11 | 12 | Il Coprocessore0 ha: 13 | 14 | * Status (???) 15 | * Cause, tipo di eccezione 16 | * EPC Indirizzo istruzione dove si è verificato il problema 17 | * BadVAddr (eventuale indirizzo da/verso cui si è provato scrivere/leggere) 18 | 19 | Ci sono istruzioni specifiche 20 | * mtc0 move to c0 21 | * mfc0 move from c0 22 | 23 | 24 | Registro Cause 25 | * Contiene gli interrupt "pending" e il tipo di errore 26 | 27 | Registro Status 28 | * Interrupt enable: se 0 nessuna interruzione abilitata 29 | * Exception level: 1 se c'è stata eccezione 30 | * User mode: se il processore è in user o kernel mode 31 | * Interrupt mask: gli interrupt abilitati 32 | 33 | Break 34 | Per il debugging 35 | E' veramente un breakpoint 36 | 37 | 38 | # Implementare un gestore delle eccezioni 39 | 40 | Potrebbe essere che dopo l'eccezione posso riprendere l'esecuzione, torno quindi a EPC+4 41 | 42 | Per le eccezioni incremento EPC per le interruzioni no! 43 | 44 | ``` 45 | .kdata 46 | 47 | save0: word 0 48 | save1: word 1 49 | 50 | .ktext 0x80000180 51 | move $k1, $at #cosa da fare sempre, $at viene usato per le pseudoistruzioni 52 | 53 | sw $v0, save0 54 | sw $a0, save1 55 | ``` 56 | 57 | Come capire il tipo di eccezione: 58 | 59 | -------------------------------------------------------------------------------- /Algoritmi/Liste/List.py: -------------------------------------------------------------------------------- 1 | class List(): 2 | def __init__(self): 3 | self.head = None 4 | 5 | def add(self, node): 6 | if self.head is None: 7 | self.head = node 8 | else: 9 | tmp = self.head 10 | self.head = node 11 | self.head.next = tmp 12 | 13 | def delete(self, node): 14 | """Delete first instance of node and return it""" 15 | if self.head is None: 16 | return None 17 | 18 | if self.head.equals(node): 19 | tmp = self.head 20 | self.head = self.head.next 21 | return tmp 22 | 23 | tNode = self.head 24 | while tNode.next is not None and not tNode.next.equals(node): 25 | tNode = tNode.next 26 | 27 | if tNode.next is not None: 28 | tmp = tNode.next 29 | tNode.next = tNode.next.next 30 | return tmp 31 | 32 | def add_tail(self, node): 33 | if self.head is None: 34 | self.head = node 35 | else: 36 | tNode = self.head 37 | while tNode.next is not None: 38 | tNode = tNode.next 39 | 40 | tNode.next = node 41 | 42 | def to_string(self): 43 | return str(self.to_list()) 44 | 45 | def to_list(self): 46 | list = [] 47 | 48 | tNode = self.head 49 | 50 | while tNode is not None: 51 | list.append(tNode.value) 52 | tNode = tNode.next 53 | 54 | return list 55 | 56 | def length(self): 57 | c = 0 58 | tNode = self.head 59 | 60 | while tNode is not None: 61 | c += 1 62 | tNode = tNode.next 63 | 64 | return c 65 | 66 | class Node(): 67 | def __init__(self, value): 68 | self.value = value 69 | self.next = None 70 | 71 | def equals(self, othernode): 72 | if self.value == othernode.value: 73 | return True 74 | 75 | return False -------------------------------------------------------------------------------- /Programmazione/Laboratorio/3/Es3.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Es3{ 4 | 5 | public static void main(String[] args){ 6 | 7 | Scanner t = new Scanner(System.in); 8 | 9 | String player1, player2; 10 | 11 | do{ 12 | System.out.print("Giocatore 1, inserisci il tuo nome: "); 13 | player1 = t.nextLine(); 14 | }while(player1.equals("")); 15 | 16 | player2 = "Computer"; 17 | 18 | String mossa1, mossaCPU = ""; 19 | 20 | do{ 21 | System.out.print(player1 + ", inserisci la tua mossa (carta, sasso, forbice): "); 22 | mossa1 = new String(System.console().readPassword()); 23 | }while(!mossa1.equals("carta") && !mossa1.equals("sasso") && !mossa1.equals("forbice")); 24 | 25 | int random = (int) (Math.random()*3); 26 | 27 | switch (random) 28 | { 29 | case 0: 30 | mossaCPU = "forbice"; 31 | break; 32 | case 1: 33 | mossaCPU = "carta"; 34 | break; 35 | case 2: 36 | mossaCPU = "sasso"; 37 | break; 38 | } 39 | System.out.println("Il Computer ha scelto " + mossaCPU); 40 | 41 | if(mossa1.equals(mossaCPU)) 42 | System.out.println("Pareggio!"); 43 | else if(mossa1.equals("carta")){ 44 | if(mossaCPU.equals("sasso")) 45 | { 46 | System.out.println(player1 + " vince"); 47 | } else { 48 | System.out.println(player2 + " vince"); 49 | } 50 | } 51 | else if(mossa1.equals("sasso")){ 52 | if(mossaCPU.equals("forbice")) 53 | { 54 | System.out.println(player1 + " vince"); 55 | } else { 56 | System.out.println(player2 + " vince"); 57 | } 58 | } else if(mossa1.equals("forbice")){ 59 | if(mossaCPU.equals("carta")) 60 | { 61 | System.out.println(player1 + " vince"); 62 | } else { 63 | System.out.println(player2 + " vince"); 64 | } 65 | } 66 | } 67 | 68 | 69 | } -------------------------------------------------------------------------------- /BasiDiDati/2017-02-21.md: -------------------------------------------------------------------------------- 1 | # Esercizio 2 | 3 | * Tabella Corsi 4 | ``` 5 | ID 6 | Prof_ID 7 | Prof_Cognome 8 | Stipendio_LivelloAnzianita 9 | ``` 10 | 11 | * Tabella Stipendi 12 | ``` 13 | LivelloAnzianita 14 | Stipendio 15 | ``` 16 | 17 | # Vaneggiamenti 18 | 19 | I dati di un organizzazione vengono trattati da dei processi che dipendono da inormaziono e human resources, queste utilizzano tecnologie informative. 20 | 21 | Tecnologie informative: 22 | * Hardware 23 | * Software 24 | * TLC 25 | 26 | E tutte le tecnologie informative sono collegate e comunicano con una o più DB. 27 | 28 | # Dato e Informazione 29 | 30 | Dato: una cosa grezza, non inserita in un contesto (ad esempio il numero 38.4) 31 | Informazione: inserita in un contensto e in un dominio (cioè si associa il 38.4 alla temparatura corporea e ai gradi centigradi) 32 | 33 | Conclusione: a partire da più informazioni posso fare delle asserzioni, ad esempio se confronto 38.4 con altre temperature capisco che è un valore anormale. 34 | 35 | # Base di dati 36 | 37 | Collezione di dati (o di tabelle) 38 | 1) utilizzata per rappresentare informazioni di interesse di diversi settori della organizzazione 39 | 2) Condivisa tra diversi processi e applicazioni software 40 | 3) in cui un informazione di interesse è rappresentata per una volta sola 41 | 42 | 43 | Mondo reale -> progettazione -> produzione di uno schema relazionale -> generazione dei dati -> dati -> interrogazione 44 | 45 | 46 | # Note organizzative 47 | 48 | ## Programma 49 | 50 | 1) Modello ER 51 | 2) Modello Relazionale 52 | 3) Metodologie progettazione concettuale 53 | +) Primo compitino 54 | 5) Algebra relazionale 55 | 6) Linguaggio SQL 56 | 7) Progettazione logica 57 | +) Secondo compitino 58 | 59 | ## Laboratorio 60 | 61 | Produrre basi di dati, compilarla, riempirla per punti extra 62 | -------------------------------------------------------------------------------- /APSoftware/teoria/09-Architettura-Logica.md: -------------------------------------------------------------------------------- 1 | # Architettura Logica 2 | 3 | ## Architettura software 4 | 5 | L' insieme delle decisioni significative sull' organizzazione di un sistema software. 6 | 7 | Insieme degli elementi strutturali e delle interfacce e collaborazioni tra essi. 8 | 9 | ## Architettura logica 10 | 11 | L'organizzazione su larga scala delle classi software in package, sottosistemi e strati 12 | 13 | Non si prendono decisioni sulla disposizione fisica dei componenti (sta alla architettura di deployment) 14 | 15 | ## Strati 16 | 17 | Uno strato e' un gruppo a grana molto grossa di classi, package che ha delle responsabilita' coese rispetto ad un determinato aspetto del sistema. 18 | 19 | In genere strati piu' alti utilizzano i servizi degli strati piu' bassi ma non viceversa. 20 | 21 | A strati stretta: uno strato puo' solo richiamare i servizi dello strato piu' basso 22 | 23 | A strati risdlassata: uno strato puo' richiamare i servizi di uno qualsiasi degli strati piu' in basso 24 | 25 | Piu si scende piu' gli strati diventano generici 26 | 27 | ## Problemi nelle architetture software 28 | 29 | * Alto accoppiamento dei componenti (coupling): cambiamenti in uno generano conseguenti modifiche in molti altri 30 | * La logica applicativa può essere condivisa con le GUI 31 | * Servizi tecnici collegati direttamente la logica applicativa, sfavorendone il riuso 32 | * L’evoluzione del sistema è resa difficoltosa dall’alto accoppiamentp e dalla commistione di funzionalita' distinte 33 | 34 | Alcune di queste problematiche possono essere risolte con il pattern Layers. 35 | 36 | Esso organizza l'architettura logica di un sistema in piu' livelli discreti comprendenti ciascuno funzionalita' distinte ma correlate in modo da permettere una una separazione delle responsabilita' che aumenti la coesione del sistema stesso. 37 | -------------------------------------------------------------------------------- /APSoftware/laboratorio/casi-uso/biglietteria.md: -------------------------------------------------------------------------------- 1 | # Casi d'uso 2 | 3 | ## Acquisto (generico) 4 | 5 | Attori: spettatore, biglietteria 6 | 7 | Descrizione: lo spettatore seleziona la tipologia di biglietto che vuole acquistare. la biglietteria contatta il sistema centrale per ottenere i prezzi. La biglietteria provvede a verificare l'identità dello spettatore. Lo spettatore effettua il pagamento. La biglietteria stampa il biglietto. La biglietteria provvede ad aggiornare i record del sistema centrale. 8 | 9 | ## Biglietto per evento singolo 10 | 11 | Attori: spettatore, biglietteria 12 | 13 | Descrizione: lo spettatore seleziona di acquistare un biglietto per un evento singolo. La biglietteria si collega al sistema centrale e prende la lista di eventi, con i rispettivi prezzi. Lo spettatore sceglie l'evento a cui è interessato e procede con l'acquisto. 14 | 15 | ## Biglietto per abbonamento 16 | 17 | Attori: spettatore, biglietteria 18 | 19 | Descrizione: lo spettatore seleziona di acquistare un abbonamento. Lo spettatore sceglie la tipologia (settimanale o stagionale) ed il periodo. La biglietteria contatta il sistema centrale per il prezzo dell'abbonamento. Lo spettatore procede con l'acquisto. 20 | 21 | ## Aggiornamento dei prezzi 22 | 23 | Attori: gestore, sistema centrale 24 | 25 | Il gestore si collega al sistema centrale. Il gestore seleziona un evento. Il gestore cambia il prezzo per l'evento selezionato. Il gestore conferma la modifica. Il gestore si scollega. 26 | 27 | 28 | ### Dettagliato: Biglietto per evento singolo 29 | 30 | Nome: Acquisto biglietto per evento singolo 31 | Portata: interazione biglietteria 32 | Livello: obbiettivo utente 33 | Attore primario: spettatore 34 | Parti interessate: 35 | Pre-condizioni: 36 | Garanzie di successo: 37 | Estensioni: 38 | Requisiti speciali: 39 | Frequenza di ripetizione: 40 | Variabili: 41 | -------------------------------------------------------------------------------- /Programmazione/Laboratorio/3/Es2.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Es2{ 4 | 5 | public static void main(String[] args){ 6 | 7 | Scanner t = new Scanner(System.in); 8 | 9 | String player1, player2; 10 | 11 | do{ 12 | System.out.print("Giocatore 1, inserisci il tuo nome: "); 13 | player1 = new String(System.console().readPassword()); 14 | }while(player1.equals("")); 15 | 16 | do{ 17 | System.out.print("Giocatore 2, inserisci il tuo nome: "); 18 | player2 = new String(System.console().readPassword()); 19 | }while(player2.equals("")); 20 | 21 | String mossa1, mossa2; 22 | 23 | do{ 24 | System.out.print(player1 + ", inserisci la tua mossa (carta, sasso, forbice): "); 25 | mossa1 = new String(System.console().readPassword()); 26 | }while(!mossa1.equals("carta") && !mossa1.equals("sasso") && !mossa1.equals("forbice")); 27 | 28 | do{ 29 | System.out.print(player2 + ", inserisci la tua mossa (carta, sasso, forbice): "); 30 | mossa2 = new String(System.console().readPassword()); 31 | }while(!mossa2.equals("carta") && !mossa2.equals("sasso") && !mossa2.equals("forbice")); 32 | 33 | if(mossa1.equals(mossa2)) 34 | System.out.println("Pareggio!"); 35 | else if(mossa1.equals("carta")){ 36 | if(mossa2.equals("sasso")) 37 | { 38 | System.out.println(player1 + " vince"); 39 | } else { 40 | System.out.println(player2 + " vince"); 41 | } 42 | } 43 | else if(mossa1.equals("sasso")){ 44 | if(mossa2.equals("forbice")) 45 | { 46 | System.out.println(player1 + " vince"); 47 | } else { 48 | System.out.println(player2 + " vince"); 49 | } 50 | } else if(mossa1.equals("forbice")){ 51 | if(mossa2.equals("carta")) 52 | { 53 | System.out.println(player1 + " vince"); 54 | } else { 55 | System.out.println(player2 + " vince"); 56 | } 57 | } 58 | } 59 | 60 | 61 | } -------------------------------------------------------------------------------- /Computabilita/multiplodi5inbinario.jff: -------------------------------------------------------------------------------- 1 | 2 | fa 3 | 4 | 5 | 6 | 104.0 7 | -13.0 8 | 9 | 10 | 11 | 316.0 12 | -49.0 13 | 14 | 15 | 223.0 16 | 118.0 17 | 18 | 19 | 20 | 351.0 21 | 299.0 22 | 23 | 24 | 25 | 181.0 26 | 344.0 27 | 28 | 29 | 30 | 0 31 | 0 32 | 0 33 | 34 | 35 | 0 36 | 1 37 | 1 38 | 39 | 40 | 2 41 | 4 42 | 0 43 | 44 | 45 | 1 46 | 2 47 | 0 48 | 49 | 50 | 2 51 | 0 52 | 1 53 | 54 | 55 | 4 56 | 4 57 | 1 58 | 59 | 60 | 1 61 | 3 62 | 491 63 | 111 64 | 1 65 | 66 | 67 | 4 68 | 3 69 | 0 70 | 71 | 72 | 3 73 | 1 74 | 0 75 | 76 | 77 | 3 78 | 2 79 | 1 80 | 81 | 82 | -------------------------------------------------------------------------------- /Architettura/2016-04-05-esercitazione.md: -------------------------------------------------------------------------------- 1 | Tradurre in istruzione mips 2 | 3 | 0010 0010 1110 1011 0000 0000 0110 0000 4 | 5 | I primi 6 bit indicano il tipo di operazione che voglio fare (opcode) 6 | 001000_2 = 8_{10} 7 | 8 | Guardo sulla tabella e vedo che 8_{10 9 | = \text{ADDI = Add Immediate} 10 | 11 | In particolare ADDI è cosi' organizzata 12 | 13 | Opcode(6) Source(5) Dest(5) Value(16) = 32bit 14 | 15 | Quindi vedo che il nostro binario viene diviso così 16 | 17 | 001000 10111 01011 0000000001100000 18 | 19 | Convertiamo tutto e ricordiamoci che nel binario prima c'è Source mentre nell'ASM prima c'è Dest 20 | 21 | Quindi esce sta cosa 22 | 23 | addi $11, $23, 96 24 | 25 | 26 | # Da hex a istruzione 27 | 28 | 0x0232502A 29 | 30 | Converto simbolo per simbolo 31 | 32 | 0x0232502A = 0000 0010 0011 0010 0101 0000 0010 1010 33 | 34 | I primi 6 bit indicano il tipo di operazione che voglio fare (opcode) 35 | 000000_2 = 0_{10} 36 | 37 | Questo vuol dire che è un operazione R-type, devo guardare gli ultimi 6 bit dell'istruzione 38 | 39 | 101010_2 = 42_{10} 40 | 41 | Seguendo la mappa vedo che 42 = \text{slt} (set less than), vediamo come è fatta. 42 | 43 | Set register rd to 1 if register rs is less than rt , and to 0 otherwise. 44 | 45 | ## Esercizio 3 46 | 47 | Si chiede di realizzare il programma MIPS che effettua la differenza tra i numeri 11 e 10 e posita il risultato nel registro $2, si suppone che 11 e 10 siano memorizzati in $3 e $4. 48 | 49 | Vado a prendere la tabella, vedo come è fatto "sub" r-type 50 | 51 | sub $2, $3, $4 52 | 53 | Convertire poi in binario, guardando la mappa degli opcode 54 | 55 | ## Esercizio 4 56 | 57 | Programma che fa la somma di 4+100, e lo mette in $5, 4 è in $6 58 | 59 | Basta usare la ADDimmediate -------------------------------------------------------------------------------- /SistemiDistribuiti/2017-04-27.md: -------------------------------------------------------------------------------- 1 | # Tecnologie semantiche 2 | 3 | Si scrive in un determinato modo non per il programmatore ma per il software. 4 | 5 | RDF: recupera un po' le idee di Tim Berners Lee (che non aveva implementato per questioni tecniche) 6 | 7 | ## RDF 8 | 9 | Modello per la rappresentazione dei dati sul Web. 10 | 11 | Unità di base: 12 | 13 | * triple: unità base di organizzazione delle informazioni 14 | * grafi orientati: insiemi di triple 15 | * URI: identificazione univoca sul web degli oggetti rappresentati 16 | * devo avere una radice comune a tutte le risorse: un sito in cui posso mettere le risorse 17 | * possono essere abbreviati passando in namespace 18 | 19 | 20 | Esistono dei tipi di dato "base" (stringhe o numeri) e dei valori "complessi" che a loro volta possono puntare ad altri valori semplici o complessi. 21 | 22 | Ogni tripla è fatta da Soggetto Predicato Oggetto 23 | 24 | Ad esempio: San_Lorenzo nome "Basilica di San Lorenzo". San_Lorenzo category Basilica. San_Lorenzo contiene >Sant'Aquilino 25 | 26 | Il linguaggio RDF mette a disposizione dei "predicati" di base, accessibili al namespace rdf: 27 | 28 | Il concetto di tipo è incluso nel linguaggio base, come rdf:type 29 | 30 | ## URI 31 | 32 | URI = Uniform Resource Identifier = Posso avere gli URL ma anche altre cose tipo gli ISBN (tel:+39...) 33 | 34 | URL = UR Locator = Localizzatore di risorse internet (riferimenti http o ftp o mailto) 35 | 36 | ## Caratteristiche RDF 37 | 38 | * scalabilità 39 | * posso aggiungere incrementalmente della conoscenza nuova alla conoscenza già esistente 40 | * indipendenza 41 | * i predicati sono risorse 42 | .... 43 | 44 | 45 | ## Dettagli RDF 46 | 47 | Uno statement deve essere 48 | 49 | soggetto (URI) predicato (URI) oggetto(URI o tipo di dato base) 50 | 51 | Ogni cosa può essere una risorsa: un'informazione, un documento, un concetto di un'ontologia... 52 | 53 | 54 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c-teoria-esame.md: -------------------------------------------------------------------------------- 1 | # Puntatore a carattere costante e puntatore costante a carattere 2 | 3 | [Più info](http://stackoverflow.com/questions/890535/what-is-the-difference-between-char-const-and-const-char) 4 | 5 | ``` 6 | const char* carattere; // puntatore a un carattere costante 7 | char* const carattere; // puntatore costante a carattere 8 | const char * const carattere; // puntatore costante a carattere costante 9 | 10 | int * mutable_pointer_to_mutable_int; 11 | int const * mutable_pointer_to_constant_int; 12 | int *const constant_pointer_to_mutable_int; 13 | int const *const constant_pointer_to_constant_int; 14 | ``` 15 | 16 | # Puntatori 17 | 18 | ``` 19 | int x = 42; 20 | int *p; // puntatore ad un intero 21 | p = &x; // associo a p l'indirizzo di x 22 | int n = *p; //associo a n il valore puntato da p, cioè 42 23 | ``` 24 | 25 | ``` 26 | /* 27 | Somma riceve come input due puntatori ad interi, e ritorna la somma del valore associato ai puntatori 28 | */ 29 | int somma(int* a, int* b) 30 | { 31 | return *a + *b; 32 | } 33 | ``` 34 | 35 | # Quale è la differenza tra il modificatore extern e quello static? 36 | 37 | ``` 38 | extern conts int NUMERO; 39 | extern int somma(int, int); 40 | ``` 41 | 42 | ``` 43 | static int somma(int x, int y) 44 | ``` 45 | 46 | `extern`: 47 | la dichiarazione seguente ha una definizione non locale, ovvero la definizione dell’oggetto dichiarato si trova più in là nel file od in un altro file 48 | 49 | `static`: 50 | la dichiarazione o definizione seguente viene “fissata” nello spazio 51 | di memoria globale e non è visibile al di fuori del file in cui essa 52 | appare 53 | 54 | Extern si usa essenzialmente per dichiarazioni da mettere in file di interfaccia, mentre static si usa soprattutto per definizioni globali in un file 55 | 56 | Inoltre le variabili static mantengono il loro valore tra una chiamata di funzione e la successiva; 57 | 58 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/c/cpolisimple/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include "Potenza.h" 6 | #include "Monomio.h" 7 | #include "Polinomio.h" 8 | 9 | #define PI ciao 10 | 11 | struct esempio { 12 | int a; 13 | float b; 14 | }; 15 | 16 | int raddoppia(int x){ 17 | return x*2; 18 | } 19 | int triplica(int x){ 20 | return x*3; 21 | } 22 | 23 | int mapcar(int* array, int (*lafunz)(int)){ 24 | for (int i = 0; i < 3; ++i) 25 | { 26 | array[i] = (*lafunz)(array[i]); 27 | } 28 | } 29 | 30 | int main() 31 | { 32 | 33 | printf("SONO QUI\n" ); 34 | int test[] = {1,2,3}; 35 | mapcar(test, &raddoppia); 36 | printf("SONO QUI\n" ); 37 | 38 | for (int i = 0; i < 3; ++i) 39 | { 40 | printf("%d", test[i]); 41 | } 42 | printf("SONO QUI\n" ); 43 | 44 | mapcar(test, &triplica); 45 | for (int i = 0; i < 3; ++i) 46 | { 47 | printf("%d", test[i]); 48 | } 49 | printf("SONO QUI\n" ); 50 | 51 | int array[12]; 52 | int* array2; 53 | array2 = (int*) malloc(sizeof(int) * 5); 54 | 55 | int array3[] = {1, 2, 3}; 56 | printf("%d\n", *(array3+1)); 57 | printf("%d\n", array3[1]); 58 | 59 | int *a = (int*) malloc(sizeof(int)); 60 | *a = 12; 61 | printf("%d\n", a[0]); 62 | 63 | Potenza* potenza = potenza_crea('x', 2); 64 | potenza_stampa(potenza); 65 | 66 | int len; 67 | scanf("%d", &len); 68 | int ciao[len]; 69 | 70 | printf("\n"); 71 | 72 | Monomio* monomio = monomio_crea(42, potenza); 73 | monomio_stampa(monomio); 74 | printf("\n"); 75 | 76 | Monomio* monomio2 = monomio_crea(69, potenza_crea('y', 3)); 77 | monomio_stampa(monomio2); 78 | printf("\n"); 79 | 80 | Polinomio* poli = polinomio_crea(2); 81 | poli->monomi[0] = monomio; 82 | poli->monomi[1] = monomio2; 83 | polinomio_stampa(poli); 84 | 85 | return 0; 86 | } -------------------------------------------------------------------------------- /Algoritmi/Liste/TestList.py: -------------------------------------------------------------------------------- 1 | import unittest 2 | from List import List, Node 3 | 4 | class TestList(unittest.TestCase): 5 | 6 | def setUp(self): 7 | self.l = List() 8 | 9 | def test_to_string(self): 10 | self.assertEqual(self.l.to_string(),"[]") 11 | 12 | self.l.add(Node(1)) 13 | self.assertEqual(self.l.to_string(),"[1]") 14 | 15 | self.l.add(Node(2)) 16 | self.l.add(Node(3)) 17 | self.assertEqual(self.l.to_string(),"[3, 2, 1]") 18 | 19 | def test_to_list(self): 20 | self.assertEqual(self.l.to_list(),[]) 21 | 22 | self.l.add(Node(1)) 23 | self.assertEqual(self.l.to_list(),[1]) 24 | 25 | self.l.add(Node(2)) 26 | self.l.add(Node(3)) 27 | self.assertEqual(self.l.to_list(),[3, 2, 1]) 28 | 29 | def test_add(self): 30 | self.l.add(Node(1)) 31 | self.l.add(Node(2)) 32 | self.l.add(Node(3)) 33 | self.assertEqual(self.l.to_list(),[3, 2, 1]) 34 | 35 | def test_add_tail(self): 36 | self.l.add_tail(Node(1)) 37 | self.l.add_tail(Node(2)) 38 | self.l.add_tail(Node(3)) 39 | self.assertEqual(self.l.to_list(),[1, 2, 3]) 40 | 41 | def test_add_mixed(self): 42 | self.l.add(Node(1)) 43 | self.l.add_tail(Node(2)) 44 | self.l.add_tail(Node(3)) 45 | self.l.add(Node(4)) 46 | self.l.add(Node(5)) 47 | self.l.add_tail(Node(6)) 48 | 49 | self.assertEqual(self.l.to_list(),[5, 4, 1, 2, 3, 6]) 50 | 51 | def test_length(self): 52 | self.assertEqual(self.l.length(), 0) 53 | 54 | self.l.add(Node(1)) 55 | self.l.add(Node(2)) 56 | self.l.add(Node(3)) 57 | 58 | self.assertEqual(self.l.length(), 3) 59 | 60 | def test_delete(self): 61 | self.l.add(Node(1)) 62 | self.l.add(Node(2)) 63 | self.l.add(Node(3)) 64 | 65 | self.assertTrue(self.l.delete(Node(2)).equals(Node(2))) 66 | self.assertIsNone(self.l.delete(Node(12))) 67 | 68 | 69 | """class TestNode(unittest.TestCase): 70 | 71 | def setUp(self): 72 | self.node = Node(42)""" 73 | 74 | if __name__ == '__main__': 75 | unittest.main() 76 | -------------------------------------------------------------------------------- /SistemiDistribuiti/2017-05-02.md: -------------------------------------------------------------------------------- 1 | # Tecnologie Semantiche 2 | 3 | ## RDFS 4 | 5 | RDF Schema, serve a dare più espressività e a vincolare domini e codomini di certe proprietà 6 | 7 | E' un estensione di RDF che permette di esprimere concetti sopra i limiti e i vincoli di RDF. In particolare ci permette di definire il concetto di classe, proprietà, risorsa, letterale. 8 | 9 | Ad esempio mi permette di discriminare le proprietà ("essere un luogo" è una proprietà) 10 | 11 | Ad esempio San Lorenzo ha un nome che è di tipo Letterale. San Lorenzo appartiene alla categoria Basiliche e Basiliche è una classe. 12 | 13 | **Definisce classi e proprietà che possono essere usate per descrivere classi e proprietà e risorse** 14 | 15 | 16 | ## Ontology and Ontologies 17 | 18 | Dare una specifica descrizione di un significato intesto di un vocabolario 19 | 20 | ### Sinonimi e ontologie 21 | 22 | ## OWL 23 | 24 | Un linguaggio che mi permette di fare operazioni su dati RDF, che mi permette di fare i check dei vincoli e stabilire relazioni simil prolog. 25 | 26 | ## Tassonomie in RDF 27 | 28 | Il Luogo è una rdfs:class 29 | Luogo di Interesse culturale è una rdfs:class 30 | Luogo di Interesse culturale è una rdfs:subClassOf 31 | 32 | Ogni istanza di LIC è anche istanza di Luogo 33 | 34 | Nazione contiene Città. 35 | Città è una rdf:property di Nazione. 36 | 37 | Esiste anche il concetto di sottoproprietà 38 | rdfs:subPropertyOf 39 | 40 | Nazione contiene Città che contiene Capitale 41 | Capitale ???? 42 | 43 | Posso dare dei rdfs:domain (Dominio) e dei rdfs:range (Codominio), in modo da forzare l'uso e i valori delle proprietà 44 | 45 | Avere capitale è sottoproprietà di avere città. Quindi eredità lo stesso dominio e codominio. 46 | 47 | # Query con SparQL 48 | 49 | Chi fa SparQL? Un Query Engine costruito sopra un Triple Store. 50 | 51 | Come se fosse un DBMS costruito sopra i dati. 52 | 53 | 54 | SparQL è READ ONLY. E' simile a SQL. 55 | 56 | ``` 57 | SELECT ?cosa 58 | WHERE( 59 | ?classe foaf:name valore 60 | ) 61 | ``` 62 | 63 | Il grafo è in RDF 64 | La query è in RDF 65 | Il risultato è una tabella 66 | -------------------------------------------------------------------------------- /Architettura/approfondimento/DatapathPipeline.mdown: -------------------------------------------------------------------------------- 1 | # Pipelined Datapath 2 | 3 | Visto che si deve riutilizzare uno stesso componente per il processing di più istruzioni è necessario introdurre nel datapath (in seguito ad ogni step) dei registri aggiuntivi, utile a tenere e condividere lo stato del pipelining tra le varie fasi. I registri prendono il nome delle due fasi tra cui si frappongono. Ad esempio il registro che sta tra la fase IF e quella ID si chiama IF/ID. 4 | 5 | ## Cosa viene passato 6 | 7 | * Tra IF e ID 8 | ** PC+4, necessario se l'istruzione è una Branch 9 | ** Instruction Memory, necessaria per il decode 10 | * Tra ID e EX 11 | ** PC+4, necessario se l'istruzione è una Branch 12 | ** Registri A,B, necessari se l'istruzione è un R-Type 13 | ** Bits `immediate`, già sign-extended, o per Branch o per SW/LW 14 | * Tra EX e MEM 15 | ** Indirizzo di Branch calcolato, utile solo se l'istruzione è una branch 16 | ** Bit di zero, utile solo se l'istruzione è una branch 17 | ** Risultato ALU, per operazioni aritmetiche logiche e SW/LW o JR 18 | ** Registro ReadData2, utile per SW 19 | * Tra MEM e WB 20 | ** Dato letto, utile solo se l'operazione è una LW 21 | ** Risultato ALU, utile se l'operazione è una R-Type 22 | 23 | 24 | ## Istruzioni 25 | 26 | ### R-Type 27 | 28 | * IF 29 | ** Incremento il PC di 4 30 | ** Fetch istruzione 31 | ** Passo PC+4, Istr 32 | * ID 33 | ** Uso Istr per leggere registro A e B 34 | ** Passo PC+4, A, B, $rdest 35 | * EX 36 | ** Faccio operazione aritmetico-logica 37 | ** Passo AluResult, $rdest 38 | * MEM 39 | ** Non devo fare nulla 40 | ** Passo AluResult, $rdest 41 | * WB 42 | ** Mando AluResult a WriteData 43 | ** Mando $rdest a WriteReg 44 | 45 | ## Controlllo della pipeline 46 | 47 | * IF: nulla di speciale, lo devono fare tutti 48 | * ID: nulla di speciale, lo devono fare tutti 49 | * EX: settare RegDst, ALUOp (a seconda di quello che si deve fare) e ALUSrc (B oppure immediato16To32 LW/SW) 50 | * MEM: settare Branch a 1 se è una branch (che poi permetterà di scegliere PC Source a seconda di Zero), settare MemRead o MemWrite se è LW o SW. 51 | * WB: settare MemToReg (mandi risultato ALU o LW?). -------------------------------------------------------------------------------- /Analisi/Riassunto/main.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,12pt,oneside]{book} 2 | 3 | \usepackage{fullpage} 4 | \usepackage[italian]{babel} 5 | \usepackage[utf8]{inputenc} 6 | \usepackage{amssymb} 7 | \usepackage{amsthm} 8 | \usepackage{graphics} 9 | \usepackage{amsmath} 10 | \usepackage{amstext} 11 | \usepackage{engrec} 12 | \usepackage{rotating} 13 | \usepackage[safe,extra]{tipa} 14 | \usepackage{showkeys} 15 | \usepackage{multirow} 16 | \usepackage{hyperref} 17 | \usepackage{microtype} 18 | \usepackage{enumerate} 19 | \usepackage{braket} 20 | \usepackage{marginnote} 21 | \usepackage{pgfplots} 22 | \usepackage{cancel} 23 | \usepackage{polynom} 24 | 25 | 26 | \usetikzlibrary{decorations.markings, intersections} 27 | \usetikzlibrary{snakes} 28 | \usetikzlibrary{arrows} 29 | 30 | \setlength{\parindent}{0pt} 31 | \renewcommand{\baselinestretch}{1.25} 32 | \pagestyle{plain} 33 | 34 | % This is to suppress the 'Chapter N' title at the beginning of every 35 | % chapter while keeping chapter numbers. 36 | \usepackage[pagestyles]{titlesec} 37 | \titleformat{\chapter}[display]{\normalfont\bfseries}{}{0pt}{\Huge} 38 | 39 | \title{Riassunto Analisi Matematica} 40 | \author{Cristian Baldi} 41 | 42 | \usepackage{fontspec} 43 | \newfontfamily\DejaSans{DejaVu Sans} 44 | \usepackage[linewidth=1pt,linecolor=black]{mdframed} 45 | \newenvironment{tip} 46 | { \begin{mdframed} {\DejaSans ☺} } 47 | { \end{mdframed} } 48 | 49 | \newcommand{\serie}[2]{ 50 | \sum\limits_{#1}^{#2} 51 | } 52 | \newcommand{\comment}[1]{} 53 | 54 | \begin{document} 55 | 56 | \maketitle 57 | 58 | \tableofcontents 59 | 60 | \chapter{Prima di iniziare} 61 | 62 | Un paio di cose prima di iniziare. 63 | 64 | Questo riassunto è in preparazione per l'esame orale di Analisi Matematica Unimib Corso Informatica. 65 | 66 | Fonte dei contenuti: 67 | \begin{itemize} 68 | \item Analisi Matematica, Paolo Maurizio Soardi 69 | \item Appunti di Matematica, Luca Chiodini 70 | \item WikiToLearn, Analisi 1 71 | \end{itemize} 72 | 73 | 74 | \input 2_Successioni.tex 75 | \input 3_Serie_Numeriche.tex 76 | \input 4_Funzioni.tex 77 | \input 5_Derivate.tex 78 | \input 6_Primitive.tex 79 | 80 | \end{document} 81 | -------------------------------------------------------------------------------- /Architettura/approfondimento/PrioritaInterrupt.mdown: -------------------------------------------------------------------------------- 1 | # Gestione delle Priorità nelle Interruzioni 2 | 3 | Ci potrebbe essere la necessità di stabilire un grado di importanza per gli interrupt che si manifestano, in modo da far gestire alla CPU quello più prioritario. 4 | 5 | Ogni sistema che si rispetti ha gli interrupt prioritarizzati. Generalmente gli interrupt di I/O hanno meno priorità degli interrupt di eccezione. E anche tra gli interrupt I/O c'è una distinzione, le periferiche più veloci hanno priorità più alta (ovviamente è necessario gestirle per prima visto che più tempo passa più lavoro perdono). 6 | 7 | ## Registro Status 8 | 9 | Inanzitutto nel MIPS abbiamo lo Status register, esso stabilisce chi può interrompere il processore. Il primo filtro che attua questo registro è attraverso il bit di enable, se è 0 il processore non verrà mai interrotto. 10 | 11 | Inoltre una sezione di questo registro è utilizzata per definire quali interrupt precisi possono verificarsi, 8 bit (dal 15 all' 8). Se voglio rendere triggerabile un interrupt mi basterà mettere i bit corrispondenti a 1. 12 | 13 | ## Registro Cause 14 | 15 | Quando si verifica un'eccezione o un interrupt è nel registro Cause che troviamo tutte le informazioni necessarie per gestirla. Ad esempio nei bit da 6 a 2 troviamo l'exception code e dal 15 all'8 i pending interrupts. 16 | 17 | ## Gestione dell'interrupt 18 | 19 | + Fare l'AND logico tra la interrupt mask del registro status e i pending interrupt del registro cause. In questo modo avremmo tutti gli interrupt che si sono manifestati e che sono abilitati ad essere gestiti. 20 | + Selezionare l'interrupt con la priorità più alta, generalmente quello più a sinistra. 21 | + Salvare la maschera degli interrupt 22 | + Cambiare la maschera degli interrupt disabilitando gli interrupt con priorità minore o uguale a quella che si sta gestendo 23 | + Salvare lo stato del processore 24 | + Settare Interrupt Enable dello Status Register a 1 25 | + Chiamare la routine di gestione dell'interrupt 26 | + Prima di restorare lo stato, settare il bit di interrupt enable del registro Cause a 0. Per fare il restore della maschera di interrupt. 27 | -------------------------------------------------------------------------------- /SistemiDistribuiti/teoria/03-RPC.md: -------------------------------------------------------------------------------- 1 | # RPC 2 | 3 | Estensione distribuita alla normale chiamata di una procedura. 4 | 5 | ## Vantaggi 6 | 7 | * Sono semanticamente chiamate di procedura 8 | * Facilmente implementabili 9 | 10 | ## Svantaggi 11 | 12 | * Esplicitamente realizzate dal programmatore 13 | * Statiche: scritte nel codice 14 | * Generalmente bloccanti 15 | 16 | ## Tipologia di chiamate 17 | 18 | ### Chiamata Sincrona 19 | 20 | Al pari di una richiesta HTTP sincrona ad un server, faccio la richiesta, aspetto (bloccandomi) la risposta, riprendo la mia esecuzione. 21 | 22 | ### Chiamata asincrona 23 | 24 | Invio la richiestra, aspetto un ACK, riprendo l'esecuzione. Prima o poi arriverà la risposta. 25 | 26 | ## Architettura 27 | 28 | Il client ha metodi stub (circa placeholder) che al posto che eseguire la procedura mandano la richiesta al server, il server ha metodi stub che ricevono la richiesta e che in seguito eseguono la procedura. 29 | 30 | ## Passaggio di parametri 31 | 32 | Alla chiamata del metodo stub i parametri vengono pacchettizzati/serializzati e inviati al server (marshalling). Il server deserializza/spacchetta i parametri ed esegue le procedure. 33 | 34 | Il passaggio di parametri è puramente per valore. 35 | 36 | # RMI 37 | 38 | RMI = remote method invocation 39 | 40 | ## Caratteristiche 41 | 42 | * Ad oggetti 43 | * Agli oggetti ci si riferisce con indirizzo + porta + id/nome oggetto 44 | 45 | ## RMI 46 | 47 | E' un middleware che: 48 | 49 | * fornisce servizi avanzati 50 | * garbage collection 51 | * gestione oggetti replicati e persistenti 52 | * multithreading 53 | * supporta l'invocazione tra oggetti in JVM distinte 54 | * si passano oggetti Java 55 | * le classi sono caricate dinamicamente 56 | * si basa sulla portabilità del bytecode 57 | * faccio OOP su un sistema distribuito 58 | * supporta invocazioni statiche e dinamiche 59 | 60 | 61 | ## Implementazione 62 | 63 | Il client chiama il metodo di un oggetto interfaccia. La chiamata passa attraverso un proxy che la invia al server dove uno skeleton (l'opposto del proxy) riceve la richiesta. Lo skeleton attraverso un oggetto interfaccia effettua la chiamata dei metodi. 64 | 65 | -------------------------------------------------------------------------------- /BasiDiDati/2017-02-22.md: -------------------------------------------------------------------------------- 1 | # Seconda lezione 2 | 3 | Una BD di dati rappresenta i dati di interesse una sola volta. 4 | 5 | Più unità organizzative accedono a una o più basi di dati condivise. 6 | Diventa difficile condividere i dati tra le UO. I dati sono potere, serve la sicurezza di accesso! 7 | E' necessario instaurare all'interno del DB delle forme di autorizzazione di accesso sia in lettua che in scrittura. 8 | 9 | C'è anche da tenere in considerazione la concorrenza: ad un DB in un momento ci possono essere aperte più connessioni, non possiamo rendere l'accesso ad un DB completamente esclusivo e per questo motivo c'è da garantire la mutua esclusione su determinate transazioni di aggiornamento. 10 | 11 | Per poter cambiare un'informazione nel DB devo mandare dal disco alla RAM, cambiare l'info, scrivere dalla RAM al disco. Il write back è necessario, si deve scrivere nel disco permanentemente i dati. Serve la PERSISTENZA. 12 | 13 | Purtroppo accedere al disco costa molto tempo. E' necessario essere efficienti nell'esecuzioni di transizioni ed interrogazioni. 14 | 15 | A database managment system is a software system able to manage requests of users and software applications in terms of queries and transactions, to access databases, namely collections of data that are: 16 | 17 | * Large 18 | * Shared 19 | * Persistent 20 | * Secure 21 | 22 | # Modello relazionale 23 | 24 | Ci sono tabelle con colonne che sono gli attributi. 25 | 26 | La base di dati ha uno schema ed una istanza. 27 | 28 | Lo schema è la struttura, ci dice come è fatta una tabella ed in seguito come è fatto il database. 29 | 30 | L'istanza è l'insieme dei dati del DB, inseriti in tabelle rispettanti lo schema. 31 | 32 | 33 | # Schema ER 34 | 35 | Viene disegnato uno schema ER per le tabelle Corso / Prof / Stipendio. 36 | 37 | Uno schema ER is a class of real world objects that are of interest for a database application. 38 | 39 | # passi della progettazione 40 | 41 | Prima di tutto si fa la progettazione concettuale, in cui si produce uno schema ER. Poi si prosegue a fare la progettazione logica, al fine di produrre una schema relazionale (le tabelle), che posso tradurre in SQL DDL. 42 | Viene popolato il DB e si possono fare query tramite SQL DML. 43 | 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /RetiSistemiOperativi/2016-10-04.md: -------------------------------------------------------------------------------- 1 | Backbone = parte interna 2 | 3 | Accesso = parte esterna della rete 4 | 5 | 6 | Concetto di rere locale, terminali 7 | 8 | 9 | Sono generalmente reti wired 10 | PArliamo solo delle wireless lan 802/11 11 | 12 | 13 | Router 14 | Switch 15 | 16 | Problema del routing tra i vari nodi (algoritmi di routing) 17 | 18 | Gli host possono fare da client e da server 19 | 20 | 21 | Internet = connessioni eterogenee 22 | 23 | 24 | le reti "private" sono sistemi autonomi 25 | , vivono la looro vita, all'interno fanno come vogliono autonomamente, pero' per far funzionare internet devono stare interconnessi 26 | 27 | 28 | Basi alla base del tcp ip 29 | 30 | Commutazione a pacchetto 31 | 32 | Payload + Header 33 | Header = metadata 34 | 35 | Evenutualmente Trailer 36 | 37 | Commutazione di circuito: creare una rete dedicato per tutta la connessione ("BUSY WAITING" della rete) 38 | Commutazione di pacchetto: don't care della strada, basta che arrivi 39 | 40 | 41 | Buffer: sala di aspetto per i pacchetti che trovano la linea occupata 42 | 43 | Analizziamo la vita del pacchetto da host A ad host B 44 | 45 | (balle varie sul qos, delay, jitter, ping) 46 | 47 | L bit 48 | R b/s 49 | T = L/R 50 | T = ritardo di trasmissione 51 | 1000/1 000 000 = 0,000001s 52 | 53 | Ci sarà sempre un ritardo dovuto alla velocità di propagazione (limite fisico della luce) 54 | 55 | ritardo di propagazione = L/S => S è velocità della luce rispettivamente al mezzo trasmissivo (C\*coeff) 56 | 57 | ritardo di processazione = k 58 | 59 | ritardo di nL/R smth sui buffer 60 | 61 | Throughput 62 | Quanti paccehtti passano sull'unità di tempo, preso tutto in considerazione 63 | 64 | Una rete è veloce quanto è veloce il suo componentne più lento 65 | Una applicazione è veloce quanto è veloce la rete più lenta che usa tra sè e il server 66 | 67 | PROTOCOLLO 68 | 69 | Insieme di regoli e formati e tempistiche e specifiche e cose 70 | Ci sono tanti problemi, un protocollo non puo' risolverli tutti tutti e certe cose non possono nemmeno essere risolte a quel livello 71 | Quindi ci son tanti protocolli che collaborano tra loro a strati etcetc 72 | 73 | Specifica 74 | Implementazione 75 | Verifica 76 | 77 | Presentazione della pila a caso 78 | :w 79 | 80 | -------------------------------------------------------------------------------- /Architettura/approfondimento/IEEE754.md: -------------------------------------------------------------------------------- 1 | # IEEE754 2 | 3 | Precisione singola (32bit) e doppia (64bit) 4 | 5 | ## Struttura 6 | 7 | * 1bit: segno 8 | * 8bit (o 11bit): segno, eccesso 127 9 | * 23bit (o 52bit): esponente 10 | 11 | ## Forma Normalizzata 12 | 13 | Una frazione normalizzata iniza con un "1." implicito seguito da 23 o 52 bit. Se tutti i 23 o 52 bit sono a zero la frazione ha valore 1.0. Se tutti sono a 1 la frazione ha valore numerico inferiore di 2.0. 14 | 15 | I 23 (o 52) bit sono detti significandi e insieme all'"1." rappresentano un valore $1 \leq s < 2$. 16 | 17 | ### Estremi 18 | 19 | * Numero più grande: esponente tutto a 1 tranne l'ultimo bit, frazione tutto a 1 20 | ** $2 * 2^{127}$ circa 21 | * Numero più piccolo: esponente tutto a 0 tranne l'ultimo bit, frazione tutto a 0 22 | ** $1.0 * 2^{-126}$ esatti 23 | 24 | ## Forma Denormalizzata 25 | 26 | Potrebbe esserci la necessità di rappresentare numeri talmente piccoli in seguito all'esecuzione di operazioni di calcolo, talmente piccoli che non potrebbero essere rappresentati in IEEE754. Per questo sono stati inventati i numeri denormalizzati. 27 | 28 | In questi numeri l'esponente è sempre messo a 0 (l'esponente a 0 è l'unica caratteristica che distingue un numero non normalizzato da uno normalizzato). L'"1." implicito diventa "0." nei numeri denormalizzati. 29 | 30 | ### Estremi 31 | 32 | * Numero più grande: esponente per forza tutto a 0, frazione tutto a 1 33 | ** un po' più piccolo di $2^{-126}$ 34 | * Numero più piccolo: esponente per forza tutto a 0, frazione tutto a 0 tranne l'ultimo bit 35 | ** $10^{-45} = 2^{-149}$ 36 | 37 | ## Rappresentazioni speciali 38 | 39 | ### Infinito 40 | 41 | E' usata al posto dell'overflow. Esponente tutto a 1 e frazione a 0. Questo valore può essere usato come operando. 42 | 43 | ### Not a Number 44 | 45 | Detto anche NaN. Esponente tutto a 1 e frazione ad un numero diverso da 0. Questo valore può essere usato come operando. 46 | 47 | ### Zero 48 | 49 | Il numero zero è rappresentato dai bit dell'esponente e della frazione tutti a 0. Formalmente è un numero denormalizzato. 50 | 51 | 52 | ## Operazioni 53 | 54 | ### Somma 55 | 56 | * Porto il numero con esponente più piccolo in esponente più grande 57 | * Sommo le due parti frazionarie 58 | * Converto in notazione scientifica -------------------------------------------------------------------------------- /Computabilita/lab/lab03/films.y: -------------------------------------------------------------------------------- 1 | %{ 2 | import java.io.*; 3 | %} 4 | 5 | %token NL /* newline */ 6 | %token XML_PREAMBLE 7 | %token DOCTYPE_OPEN, DOCTYPE_CLOSE, DOCTYPE_ROOT_TAG, DOCTYPE_SYSTEM_AND_FILENAME 8 | %token OPEN_FILMS, OPEN_FILM, OPEN_TITLE, OPEN_SUBTITLE, OPEN_ACTOR, OPEN_ACTORS, OPEN_NAME, OPEN_SURNAME, OPEN_COMPANIES, OPEN_COMPANY, OPEN_CATEGORIES, OPEN_CATEGORY, CLOSE_FILMS, CLOSE_FILM, CLOSE_TITLE, CLOSE_SUBTITLE, CLOSE_ACTOR, CLOSE_ACTORS, CLOSE_NAME, CLOSE_SURNAME, CLOSE_COMPANIES, CLOSE_COMPANY, CLOSE_CATEGORIES, CLOSE_CATEGORY 9 | %token CLOSE_OPENING, CLOSE_SELF_CLOSING 10 | %token TAG_CONTENT 11 | 12 | %type newline, doctype, preamble 13 | %% 14 | 15 | xml: preamble newline doctype newline films; 16 | 17 | newline: NL { $$ = System.lineSeparator(); } 18 | | newline NL { $$ = $1 + System.lineSeparator(); } 19 | 20 | preamble: XML_PREAMBLE { $$ = "PREAMBOLO"; } 21 | doctype: DOCTYPE_OPEN DOCTYPE_ROOT_TAG DOCTYPE_SYSTEM_AND_FILENAME DOCTYPE_CLOSE { $$ = "DOCTYPE"; } 22 | 23 | films: OPEN_FILMS CLOSE_OPENING newline film CLOSE_FILMS { System.out.println("HO TROVATO FILM DA SOLO"); } 24 | | OPEN_FILMS CLOSE_OPENING newline film CLOSE_FILMS newline films { System.out.println("HO TROVATO FILMS");} 25 | %% 26 | 27 | film: OPEN_FILM CLOSE_OPENING CLOSE_FILM { System.out.println("Questo è un film") } 28 | 29 | private Yylex lexer; 30 | 31 | 32 | private int yylex () { 33 | int yyl_return = -1; 34 | try { 35 | yylval = new ParserVal(0); 36 | yyl_return = lexer.yylex(); 37 | } 38 | catch (IOException e) { 39 | System.err.println("IO error :"+e); 40 | } 41 | return yyl_return; 42 | } 43 | 44 | 45 | public void yyerror (String error) { 46 | System.err.println ("Error: " + error); 47 | } 48 | 49 | 50 | public Parser(Reader r) { 51 | lexer = new Yylex(r, this); 52 | } 53 | 54 | 55 | static boolean interactive; 56 | 57 | public static void main(String args[]) throws IOException { 58 | Parser yyparser; 59 | if ( args.length > 0 ) { 60 | // parse a file 61 | yyparser = new Parser(new FileReader(args[0])); 62 | yyparser.yyparse(); 63 | } 64 | else { 65 | System.out.println("ERROR: Provide an input file as Parser argument"); 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /Architettura/approfondimento/esercizi.md: -------------------------------------------------------------------------------- 1 | # IEEE 754 2 | 3 | ## Dec to Bin 4 | 5 | 13.25 6 | 7 | 13 = 1101 8 | 9 | 0.25 * 2 = 0 10 | 0.5 * 2 = 1 11 | 12 | 0.25 = 0.01 13 | 14 | 1101.01 * 2^0 15 | 1.10101 * 2^3 16 | 17 | exp = 10000010 18 | 19 | 0 10000011 10101000000000000000000 20 | 21 | 22 | ## Bin to Dec 23 | 24 | 1 10000100 01101100000000000000000 25 | 26 | 1: negativo 27 | 28 | 10000100b = 128+4 = 132-127 = 5 29 | 30 | 1.011011b * 2^5 -> 101101.1b * 2^0 31 | 32 | 101101b = 1 + 4 + 8 + 32 = 45 33 | 34 | 0.1b = 0.5 -> 1 * 2^-1 = 1/2 = 0.5 35 | 36 | 37 | ## Dec to bin con rounding 38 | 39 | -0.10 40 | 41 | Segno: 1 42 | 43 | Intero: 0d = 0b 44 | 45 | 0.10dec = 0.00011001100110011001100110011001100.... 46 | 47 | 0.1 * 2 = 0 48 | 0.2 * 2 = 0 49 | 0.4 * 2 = 0 50 | 0.8 * 2 = 1 51 | 0.6 * 2 = 1 52 | 0.2 * 2 = 0 53 | 54 | 0.0001100110011001100... * 2^0 55 | 1.10011001100... * 2^-4 56 | 57 | Esponente: -4+127 = 123 = 64+32+16+8+2+1 = 01111011 58 | 59 | Devo fare il rounding 60 | 61 | 1100 -> this is a tie: round up if the mantissa's bit just before G is 1, else round down=do nothing 62 | xxxx1101 63 | 64 | ## Addizione 65 | 66 | 0.75 + 1.23 67 | 68 | 69 | 0 = 0 70 | 71 | 0.75 = 0.11 72 | 73 | 0.75 * 2 = 1 74 | 5 * 2 = 1 75 | 76 | 0.11 77 | 78 | 1.1 * 2^-1 79 | 80 | -1+127 = 126 81 | 82 | 0 01111110 10000... 83 | 84 | 1.23 85 | 1 = 1 86 | 87 | 0.23 = 0.0011101011100001010001111 88 | 89 | 1.11111010111000010100011 11 * 2^0 90 | 11111010111000010100100 91 | 92 | 0.23 * 2 = 0 93 | 0.46 * 2 = 0 94 | 0.92 * 2 = 1 95 | 0.84 * 2 = 1 96 | 0.68 * 2 = 1 97 | 0.36 * 2 = 0 98 | 0.72 * 2 = 1 99 | 0.44 * 2 = 0 100 | 0.88 * 2 = 1 101 | 0.76 * 2 = 1 102 | 0.52 * 2 = 1 103 | 0.04 * 2 = 0 104 | 0.08 * 2 = 0 105 | 0.16 * 2 = 0 106 | 0.32 * 2 = 0 107 | 0.64 * 2 = 1 108 | 0.28 * 2 = 0 109 | 0.56 * 2 = 1 110 | 0.12 * 2 = 0 111 | 0.24 * 2 = 0 112 | 0.48 * 2 = 0 113 | 0.96 * 2 = 1 114 | 0.92 * 2 = 1 115 | 0.84 * 2 = 1 116 | 0.68 * 2 = 1 117 | 118 | 119 | # Divisione 120 | 121 | 122 | -7.25 / 1.5 123 | 124 | 125 | 111. 126 | 127 | 0.25 = 01 128 | 129 | 1.1101 * 2^2 130 | 131 | 1.5 132 | 133 | 1.1 * 2^0 134 | 135 | 136 | 1.1101 137 | 1.1000 138 | ______ 139 | 11101000 140 | 111010000 141 | 142 | 10.10111000 * 2^2 143 | 144 | 145 | 146 | -------------------------------------------------------------------------------- /Computabilita/riassunto/25-NFA.md: -------------------------------------------------------------------------------- 1 | # Automi a stati finiti non-deterministici 2 | 3 | Un NFA è un automa a stati finiti non deterministico. Un NFA ha la caratteristicha che in un determinato istante della sua computazione può trovarsi in più di uno stato. Questa sua abilità è generalmente espressa con l'abilità dell'automa di provare ad "indovinare" qualcosa del suo input. 4 | 5 | Un NFA è praticamente uguale ad un DFA, l'unica differenza sta nella funzione $\delta$ che non ritorna più un solo stato ma un insieme di stati. 6 | 7 | ## $\delta^*$ 8 | 9 | Anche in questo caso la $\delta^*$ è definita per induzione. 10 | 11 | \begin{definition} 12 | 13 | \begin{itemize} 14 | \item Caso base: $\delta^*(q,\lambda)=\{q\}$ 15 | \item Passo induttivo: $w=xa$, $\delta^*(q,x) = \{p_1, p_2, \ldots, p_n\}$ e $$\bigcup \delta(p_i,a) = \{r_1, r_2, \ldots, r_m\}$$ quindi $\delta^*(q,x) = \{r_1, r_2, \ldots, r_m\}$ 16 | \end{itemize} 17 | \end{definition} 18 | 19 | ## Equivalenza tra DFA e NFA 20 | 21 | Ogni linguaggio accettabile con una NFA è anche accettabile con un DFA. Un NFA è semplicemente una rappresentazione diversa per un DFA, fatta ad esempio per semplificare o rendere più chiaro il funzionamento. 22 | 23 | \begin{theorem} 24 | Un linguaggio L accettato da un DFA se e solo se L è accettato anche da un NFA. 25 | \end{theorem} 26 | 27 | E' possibile convertire un NFA in un DFA. 28 | 29 | 30 | ## $\epsilon$-NFA 31 | 32 | Un $\epsilon$-NFA è un NFA che permette di fare transizioni che non consumano input, cioè delle $\epsilon$-transizioni. Questo vuol dire che l'automa può fare transizioni da solo, senza ricevere un input. Come per gli NFA, questa funzionalità non aumenta la classe di linguaggi riconoscibili tramite automi a stati finiti, rimane la stessa dei DFA. 33 | 34 | ### $\delta$ di un $\epsilon$-NFA 35 | 36 | La funzione di transizione di un $\epsilon$-NFA prende in input uno stato e un elemento di $\Sigma \cup \{\epsilon\}$ e ritorna un insieme di stati. 37 | 38 | ### $\epsilon$-chiusura 39 | 40 | Importantissimo per i eNFA è il concetto di ECLOSE di uno stato, è l'insieme di tutti gli stati raggiungibili con e-transizioni senza consumare input. E' definita per induzione. 41 | 42 | \begin{definition} 43 | \end{definition} 44 | 45 | * Caso base: $q$ è nell'ECLOSE($q$). 46 | * Passo induttivo: Se $p$ è nell'ECLOSE($q$) e c'è una $\epsilon$-transizione dallo stato $p$ allo stato $r$, quindi $r$ è nell'ECLOSE($q$). 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /BasiDiDati/video/04-Progettazione-Concettuale.md: -------------------------------------------------------------------------------- 1 | # Progettazione Concettuale 2 | 3 | Schema concettuale: schema che descrive i requisiti degli utenti, più vicina all'utente. 4 | 5 | Schema logico: trasforma lo schema concettuale in uno schema logico-relazionale. Lo si sviluppa ottimizzando il più possibile le operazioni. 6 | 7 | Schema fisico: quello che viene salvato su disco. Si aggiungono le caratteristiche fisiche: ad esempio la lunghezza del blocco. 8 | 9 | Per progettare concettualmente ho bisogno di raccogliere i requisiti: è una operazione lunga e complessa, è necessario raccoglierli secondo strategie. 10 | 11 | ## Qualità scherma concettuale 12 | 13 | Caratteristica desiderabile dello schema: 14 | 15 | * correttezza 16 | * rispetto ai requisiti: i requisiti sono rappresentati nello schema coerentemente con il signficato dei concetti nel modello ER 17 | * rispetto al modello: i concetti del modello sono usati nello schema in accordo al loro significato, non uso un entità per un numero civico, uso un'entità per rappresentare una persona. 18 | * completezza: tutti i requisiti devono stare nello schema 19 | * pertinenza: non vi devono essere concetti che non ci sono nei requisiti 20 | * minimalità: un solo concetto per ogni requisito. non posso togliere un concetto e rispettare ancora i requisiti. 21 | * leggibilità: i requisiti devono essere rappresentati in modo comprensibile 22 | * leggibilità grafica: non si devono incrociare le linee, le linee non devono essere oblique 23 | * leggibilità concettuale: scegliere le strutture del modello che danno luogo ad uno schema compatto 24 | 25 | ## Strategie di progettazione 26 | 27 | ### Bottom up 28 | 29 | Si individua per prima cosa i concetti più elementari (gli attributi). Si identificano poi le entità (e si presta attenzione alle generalizzazioni che potrebbero crearsi). Infine si sviluppano le relazioni (con gli attributi ad essse collegati) e le cardinalità. 30 | 31 | ### Inside Out 32 | 33 | Si identificano i concetti principali (e non quelli più elementari) e li si rappresenta con un entità. Si implementano poi le relazioni più importanti che coinvolgono le entità e ci si dedica poi alle generalizzazioni. In generale ci si sposta da dentro (l'entità più importante) verso l'esterno. 34 | 35 | ### Top Down 36 | 37 | Si parte da una visione d'insieme dello schema (una sola entità) e via via la si divide in entità più piccole. Si aggiungono alla fine generalizzazioni ed attributi. 38 | -------------------------------------------------------------------------------- /LinguaggiDiProgrammazione/lisp/lab-2016-12-02.lisp: -------------------------------------------------------------------------------- 1 | (defun double-number(x) 2 | (* x 2)) 3 | 4 | (defun double-list(list-to-double) 5 | "Doubles LIST-TO-DOUBLE 6 | LIST-TO-DOUBLE: the list that needs to be doubled" 7 | (mapcar 'double-number list-to-double)) 8 | 9 | (defun times-param(list-to-multiply factor) 10 | "Multiplies each element in LIST-TO-MULTIPLY by FACTOR" 11 | (mapcar (lambda (x) (* x factor)) list-to-multiply)) 12 | 13 | (defun count-first-level-numbers(list-to-explore) 14 | "Counts first-level atoms that are also numbers 15 | LIST-TO-EXPLORE: the list that needs to be explored, with and without atomic components" 16 | (cond ((null list-to-explore) 0) 17 | ((numberp (first list-to-explore)) (+ 1 (count-first-level-numbers (rest list-to-explore)))) 18 | (T (count-first-level-numbers (rest list-to-explore))) 19 | )) 20 | 21 | (defun count-all-levels-numbers(list-to-explore) 22 | "Counts all numbers on all levels of the list" 23 | (cond ((numberp list-to-explore) 1) 24 | ((atom list-to-explore) 0) 25 | (T (+ (count-all-levels-numbers (first list-to-explore)) 26 | (count-all-levels-numbers (rest list-to-explore)))))) 27 | 28 | (defun count-all-levels-lists(list-to-explore) 29 | "Count all lists inside LIST-TO-EXPLORE on all levels" 30 | (cond ((atom list-to-explore) 0) 31 | ((listp (first list-to-explore)) (+ 1 (count-all-levels-lists (first list-to-explore)) (count-all-levels-lists (rest list-to-explore)))) 32 | (T (count-all-levels-lists (rest list-to-explore))))) 33 | 34 | (defun remove-element(list-to-remove-from element) 35 | "Remove ELEMENT from LIST-TO-REMOVE-FROM" 36 | (cond ((null list-to-remove-from) nil) 37 | ((equal (first list-to-remove-from) element) (remove-element (rest list-to-remove-from) element)) 38 | (T (append (list (first list-to-remove-from)) (remove-element (rest list-to-remove-from) element))))) 39 | 40 | (defun remove-element-all-levels(list-to-remove-from element) 41 | (error "Please implement this function")) 42 | 43 | (defun remove-element-lambda(list-to-remove-from element) 44 | "FIXME: it does not remove but replaces with `nil`." 45 | (mapcar (lambda (x) (cond ((equal x element) nil)(T x))) list-to-remove-from)) 46 | 47 | (defun last-element(thelist) 48 | "Get the last element of THELIST" 49 | (cond ((null thelist) nil) 50 | ((null (rest thelist)) (first thelist)) 51 | (T (last-element (rest thelist))))) 52 | 53 | (defun function-factory(x) 54 | "!?" 55 | (lambda () (+ 1 x))) 56 | -------------------------------------------------------------------------------- /RetiSistemiOperativi/2016-10-11.md: -------------------------------------------------------------------------------- 1 | Sistema Operativo 2 | Qualcosa di software legato all' hardware 3 | 4 | Gestione risorse fisiche e logiche 5 | Cpu, RAM, I/O, accesso ai file, cose 6 | Gestione dei processi e scegliere chi e cosa mandare in esecuzione 7 | VIrtualizzare le risorse e gestirne la condivisione (accesso in sequenza e suddivisa) 8 | NUMA??? Not uniform memory access 9 | 10 | Un OS fa funzionare sia cose fisiche che virtuali, duh 11 | 12 | Gestire interazione fra programmi e risorse sincronizzazione... 13 | Le risorse vengono astratte verso il sistema operativo in modo da far sembrarle lato software tutte uguali, aka driver e API 14 | Offrire protezione e sicurezza in modo che venga sandboxed il codice user side 15 | Gestione HW 16 | Necessità real time 17 | Again, API 18 | 19 | Processo 20 | Codice in esecuzione in uno spazio di memoria virtuale 21 | Che ha uno stato di esecuzione determinato da program counter e registri 22 | 23 | # Kernel mode 24 | Accessi a registri, istruzioni e simili che non puoi accedere in user mode 25 | 26 | # User mode 27 | Safe space per il processo, accedi solo a quello che voglio 28 | 29 | # Archetipi S.0. 30 | Sono solo cose teoriche, non pratiche, nessun O.S. rispetta a pieno tutta la definizione ma ognuno fa come vuole a seconda delle necessità 31 | + Microkernel, snello, poche funzioni semplici 32 | + Scheduler 33 | + Gestione comunicazione 34 | + Interrupt 35 | + gestione memoria virtuale 36 | + primitive di sync 37 | + Quello che non è li' sta in user mode, gestione file system ad esempio 38 | + MACH, sistema microkernel più puro 39 | + Problemi di prestazioni, ogni cosa deve passare per una chiamata di sisteam 40 | 41 | + Kernel monolitico 42 | + Tutto quello che mi serve c'è 43 | + Sta tutto dentro il S.O quindi ci mette magari un po' ad accendersi ma è buono per le prestazioni 44 | + Linux 45 | 46 | + Stratificato 47 | + Ispirato dai protocolli a strati 48 | + Mai realizzato 49 | + Alcune parti O.S. sono a strati (Windows Driver Model) 50 | 51 | + Modulare 52 | + ... 53 | ???? 54 | 55 | # System call 56 | + Controllo dei processi 57 | + Comunicazione tra processi 58 | + Messaggi 59 | + Connessioni, p2p tra processi 60 | + ???? 61 | + Wait signal 62 | + File managment 63 | + Apertura 64 | + Chiusura 65 | + Creazione 66 | + Manipolazione attributi / permessi 67 | 68 | Ad un opportuno livello di astrazione un file e una rete non sono molto diversi... socket etc ! 69 | 70 | 71 | -------------------------------------------------------------------------------- /Fondamenti/Riassunto/15_Proprieta_Relazioni.md: -------------------------------------------------------------------------------- 1 | # Proprietà delle relazioni 2 | 3 | Una **relazione binaria** $R$ (con Dominio $S$) può soddisfare le seguenti proprietà: 4 | 5 | * **Riflessiva**, cioè $\langle x,x \rangle \in R$ per ogni $x \in S$, cioè ogni $x$ è in relazione con se stesso 6 | * **Irriflessiva**, cioè $\langle x,x\rangle \not\in R$ per ogni $x \in S$, cioè nemmeno un $x$ è in relazione con se stesso 7 | * **Simmetrica**, cioè ogni volta che esite $\langle x,y\rangle \in R$ esiste anche $\langle y,x\rangle \in R$ 8 | * **Asimmetrica**, cioè ogni volta che eiste $\langle x,y\rangle \in R$ non esiste mai $\langle y,x\rangle \in R$ 9 | * **Antisimmetrica**, cioè che se $\langle x,y\rangle \in R$ e $\langle y,x\rangle \in R$ possiamo dire che $x = y$ 10 | * **Transitiva**, cioè se $\langle x,y\rangle \in R$ e $\langle y,z\rangle \in R$ c'è anche $\langle x,z\rangle \in R$ 11 | 12 | ## Chiarimenti sulla proprietà Antisimmetrica 13 | 14 | Se $x$ in relazione con $y$ e $y$ in relazione con $x$ allora $x=y$ 15 | 16 | ### Esempio 17 | 18 | Considero l'insieme degli abitanti dell'Italia e considero la relazione "abita nella stessa città" 19 | la relazione non è antisimmetrica: infatti se Maria abita nella stessa città di Carlo e Carlo abita nella stessa città di Maria non segue che Carlo è uguale a Maria 20 | 21 | Considero i numeri naturali e considero la relazione "è maggiore o uguale a" 22 | La relazione è antisimmetrica perché perché se un numero è maggiore o uguale ad un secondo numero ed il secondo è maggiore uguale del primo allora i due numeri sono uguali 23 | 24 | Nella rappresentazione a Grafi si capisce che è antisimmetrica perché ha cicli di lunghezza massima 1 (Solo cappi ammessi) 25 | 26 | ## Proposizioni derivate dalle proprietà 27 | 28 | Dalla *riflessiva*: 29 | 30 | * Se $R$ è riflessiva anche $R^{-1}$ (l'inversa) è riflessiva 31 | * $R$ è riflessiva se e solo se $\bar{R}$ è irriflessiva 32 | * Se $R$ e $R'$ sono riflessive anche $R \cup R'$ e $R \cap R'$ sono riflessive 33 | 34 | Dalla *simmetrica*: 35 | 36 | * $R$ è simmetrica se e solo se $R = R^{-1}$ 37 | * se $R$ è simmetrica anche $R^{-1}$ e $\bar{R}$ sono simmetriche 38 | * se $R$ e $R'$ sono simmetriche anche $R \cup R'$ e $R \cap R'$ sono simmetriche 39 | 40 | Dall' *antisimmetrica*: 41 | 42 | * $R$ è antisimmetrica se e solo se $R \cap R^{-1} \subseteq \varphi S$ 43 | * $R$ è antisimmetrica se e solo se $R \cup R^{-1} = \emptyset$ 44 | 45 | Dalla *transitiva*: 46 | 47 | * Se $R$ e $R'$ sono transitive anche $R \cap R'$ è transitiva 48 | 49 | -------------------------------------------------------------------------------- /APSoftware/teoria/03-Casi-Uso.md: -------------------------------------------------------------------------------- 1 | # Casi d'uso 2 | 3 | Un caso d'uso è una storia testuale, utilizzata per scoprire e catalogare i requisiti. 4 | 5 | ## Elementi di un caso d'uso 6 | 7 | * Attore, qualcosa che interagisce con il sistema 8 | * Scenario, una specifica sequenza di azioni tra gli attori e il sistema 9 | * Detta anche **istanza di un caso d'uso** 10 | * Goal, obiettivo che lo scenario vuole portare a raggiungere 11 | 12 | Un caso d'uso è una collezione di scenari *successfull* e *failure* che descrivono un attore usante un sistema in supporto ad un goal. 13 | 14 | ## Tipi di attore 15 | 16 | * **Attore primario**: raggiunge degli obiettivi utente usando i servizi del sistema 17 | * **Attore di supporto**: offre un servizio, spesso è un sistema informatico 18 | * **Attore fuori scena**: ha un interesse nel caso d'uso, ma non rientra nelle prime due categorie 19 | 20 | ## Tipo di caso d'uso 21 | 22 | * **brief**, un paragrafo scarso 23 | * generalmente descrive un solo scenario di successo 24 | * **informale**, più paragrafi che coprono vari scenari sia di successoc che di fallimento 25 | * **full**, tutti gli step e le variazioni del caso d'uso sono descritte in dettaglio 26 | * Nome del caso d'uso 27 | * Inizia con un verbo 28 | * Portata 29 | * Il sistema che si sta progettando 30 | * Livello 31 | * Obiettivo utente o sottofunzione 32 | * Attore primario 33 | * Parti interessate e interessi 34 | * Pre-condizioni 35 | * Garanzia di successo 36 | * Cosa deve essere vero se il caso d'uso viene completato con successo 37 | * Scenario principale di successo 38 | * Estensioni 39 | * Scenari alternativi di successo e di fallimento 40 | * Requisiti speciali 41 | * Non funzionali 42 | * Elenco delle variabili tecnologiche e dei dati 43 | * "Varianti nei metodi I/O e nel formato dei dati" 44 | * 45 | * Frequenza di ripetizione 46 | * Altre note 47 | 48 | ## Come scrivere casi d'uso 49 | 50 | Concentrarsi su: 51 | 52 | * lo scopo dell'attore 53 | * cosa deve fare il sistema 54 | 55 | Ignorare: 56 | 57 | * l'interfaccia utente 58 | * come il sistema fa le azioni richieste 59 | 60 | 61 | ## Verificare un caso d'uso 62 | 63 | * Test del Capo 64 | * Se rispondendo con il nome del caso d'uso alla domanda del capo "Cosa hai fatto tutto il giorno?", il capo non si arrabbierà 65 | * Test EBP 66 | * Ci si chiede se il caso d'uso aggiunge valore di business e lascia i dati in uno stato coerente 67 | * Tese della dimensione 68 | * Il caso d'uso deve essere tra le 3 e le 10 pagine nel formato dettagliato 69 | 70 | -------------------------------------------------------------------------------- /Statistica/esercizi/Approfondimento2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Esercizio 48\n", 8 | "\n", 9 | "F1 ha 0.015 di probabilità di essere rotto.\n", 10 | "F2 ha 0.005.\n", 11 | "F3 ha 0.02.\n", 12 | "\n", 13 | "F1 è blu, F2 è verde, F3 è gialla. \n", 14 | "\n", 15 | "Sceglie il verde con 0.5, il giallo con 0.3 e il blu con 0.2.\n", 16 | "\n", 17 | "**Estrae un razzo, quale è la probabilità che sia non funzionante?**\n", 18 | "\n", 19 | "P(N|E) = P(F1,E1) + P(F2,E2) + P(F3,E3) = P(F1|E1)*P(E1) + P(F2|E2)*P(E2) + P(F3|E3)*P(E3)\n", 20 | "\n", 21 | "**Sapendo che il razzo non funziona, quale cassa è la più probabile?**\n", 22 | "\n", 23 | "P(F1|E1) = P(F1,E1)/P(E1)\n", 24 | "P(F2|E2) = P(F2,E2)/P(E2)\n", 25 | "P(F3|E3) = P(F3,E3)/P(E3)\n", 26 | "\n", 27 | "## Esercizio 49\n", 28 | "\n", 29 | "3 monete. T1=1/2, T2=1/3, T3=1/4\n", 30 | "\n", 31 | "Si sceglie una moneta a caso.\n", 32 | "\n", 33 | "\n", 34 | "**Probabilità che non si ottenga mai testa su due lanci**\n", 35 | "\n", 36 | "P(CC) = P(CC1,M1) + P(CC2,M2) + P(CC3,M3) = P(CC1|M1)*P(M1) + ....\n", 37 | "\n", 38 | "**Probabilità che si ottenga esattamente un esito testa su due lanci**\n", 39 | "\n", 40 | "P(TCoCT,M1) + P(TCoCT,M2) + P(TCoCT,M3) = P(TCoCT|M1)*P(M1) + ....\n", 41 | "\n", 42 | "P(TCoCT|M1) = P(TC|M1)+P(CT|M1) = 1/2*1/2 + 1/2*1/2\n", 43 | "\n", 44 | "**Probabilità che la moneta estratta sia M1 sapendo he su 3 lanci non esce mai testa**\n", 45 | "\n", 46 | "P(M1|CCC) = P(M1,CCC)/P(CCC) = P(CCC|M1)*P(M1)/P(CCC)\n", 47 | "\n", 48 | "P(CCC) = P(CCC,M1) + P(CCC,M2) + P(CCC,M3)\n", 49 | "\n", 50 | "**Probabilità che si ottenga testa, sapendo che è uscito testa**\n", 51 | "\n", 52 | "P(T2|T1) = P(T2,T1)/P(T1) = P(T2,T1,M1) + P(T2,T1,M2) + P(T2,T1,M3) / P(T,M1) + P(T,M2) + P(T,M3)" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": { 59 | "collapsed": true 60 | }, 61 | "outputs": [], 62 | "source": [] 63 | } 64 | ], 65 | "metadata": { 66 | "kernelspec": { 67 | "display_name": "R", 68 | "language": "R", 69 | "name": "ir" 70 | }, 71 | "language_info": { 72 | "codemirror_mode": "r", 73 | "file_extension": ".r", 74 | "mimetype": "text/x-r-source", 75 | "name": "R", 76 | "pygments_lexer": "r", 77 | "version": "3.3.3" 78 | } 79 | }, 80 | "nbformat": 4, 81 | "nbformat_minor": 2 82 | } 83 | -------------------------------------------------------------------------------- /RetiSistemiOperativi/2016-11-22.md: -------------------------------------------------------------------------------- 1 | # Data link 2 | 3 | Tante variabili e differenze in gioco. 4 | 5 | Ci sono Data Link point to point, altri che stanno in broadcast (wifi ad esempio o un ethernet broadcast) 6 | 7 | Posso avere un mezzo wireless e uno wireline 8 | 9 | Ho "frame" diversi a seconda della rete. 10 | 11 | ## Features 12 | 13 | ### Comuni a tutti 14 | 15 | * Framing 16 | * Addressing (indirizzo fisico) 17 | * Error detection (e alcuni anche la correction) 18 | 19 | ### Alcuni hanno 20 | * Controllo dell'accesso, Medium Access Control 21 | * Broadcasting 22 | 23 | 24 | ## Error detection 25 | 26 | * Tramite la parità, aggiungendo un bit in coda 27 | * Parità bidimensionale, come la parità ma su una matrice bidimensionale. 28 | * Faccio un incrocio tra la riga e la colona e trovo l'errore 29 | * E' poco efficiente, spreco tanto 30 | * In alcune configurazione di errori posso scoprire due errori (poco probabili ma meglio cosi') 31 | 32 | ### CRC 33 | * D = dati 34 | * G = generatori di r+1 bit 35 | * R = parola di r bit 36 | 37 | D * 2^r = n * G XOR R 38 | 39 | #### Esempio 40 | 41 | D = 100101 = x^5+x^2+1 42 | 43 | G = 101 = x^2+1 -> r = 2 44 | 45 | 100101 * 2^2 = x^7+x^4+x^2 * G XOR R 46 | 47 | 10010100 = nG XOR R 48 | 49 | Prendo quello che ricevo, divido per G e se viene 0 allora ho ricevuto un multiplo di G e quindi non ci sono errori, altrimenti ci sono. 50 | 51 | Faccio la divisione tra polinomi di D00/G 52 | 53 | R = x -> 10 e va bene 54 | R sono i bit da mettere al posto di G00 55 | 56 | 57 | ## Controllo accesso 58 | 59 | ### Rigido 60 | 61 | * TDM, ognuno parla in uno slot di tempo 62 | * FDM, ognuno parla sulla sua frequenza 63 | 64 | ### Flessibile 65 | 66 | * A contesa, ALOHA, SLOTTED ALOHA, CSMA/CD, CSMA/CA 67 | * A turni, esiste un qualche elemento che da il controllo della trasmissione. 68 | Io posso parlare finchè ho il token. Problema: se perdo il token? 69 | * Arbitrati, esiste qualcuno che comanda, decide l'access point chi e quanto parla. 70 | 71 | ## ALOHA 72 | Era inizialmente pensato per comunicare con un satellite. 73 | Tutte le stazioni sono equidistanti. Tutte le stazioni ricevono segnali con la stessa potenza 74 | 75 | Usiamo un meccanismo distribuito. Aloha Slotted. Il tempo è diviso in slot tutti uguali. Le stazioni trasmettono eventualmente in un certo time slot e sono in grado di riconoscere se c'è stata collisione. 76 | 77 | Se c'è un conflitto la stazione ritrasmetta con una probabilità P, che è da decidere per permettere a tutto di funzionare bene 78 | 79 | Efficienza = % slot ok 80 | N grande stazioni 81 | p = probabilità di trasmissione 82 | -------------------------------------------------------------------------------- /SistemiDistribuiti/2017-02-28.md: -------------------------------------------------------------------------------- 1 | # Libri 2 | Tanenbaum: Distributed Systems - 2nd Edition 3 | 4 | # Sistema distribuito 5 | 6 | Un sistema distribuito è una cosa hardware o software localizzate su computer interconnessi che comunicano e si coordinano attraverso la comunicazione di messaggi. 7 | 8 | Non esiste memoria condivisa. 9 | 10 | Un sistema distribuito è una collezione di computer indipendenti che appaiono ai suoi utenti come un sistema singolo e coerente/coeso. Tanenbaum 11 | 12 | Per T. c'è un middleware service che coordina i vari OS locali. 13 | 14 | ## Caratteristiche fondamentali: 15 | 16 | * Non c'è memoria condivisa, non c'è uno stato globale. Conosco il mio stato e posso sondare in un determinato istante lo stato degli altri, che però può variare. 17 | * Esecuzione concorrente, ogni componente fa da solo, serve quindi un coordinamento. 18 | * Non c'è un clock globale, non c'è possibilità di controllo e scheduling globale 19 | * Indipendent failures, i fallimenti dei singoli nodi non si ripercuotono sull'intero S.D. Non c'è fallimneto globale. 20 | 21 | ## Problematiche 22 | 23 | * Individuare la controparte della comunicazione (come faccio a sapere con chi devo parlare? naming) 24 | * Accedere alla costroparte (come faccio a raggiungerla? access point) 25 | * Comunicare 1 (come faccio a mandare e ricevere i messaggi? protocollo) 26 | * Comunicare 2 (come faccio a capre cosa mi ha inviato la controparte? formato dei messaggi) 27 | 28 | ## Architettura software 29 | 30 | * Architetture a strati (layered) 31 | * SW architecture che organizza software a strati. Ogni strato è costruito su uno o più strati più generici. Un layer è un set di sistemi con lo stesso grado di generalità. Più si sale, più ci si avvicina all'applicazione. Più si scende, più si va sul generale. 32 | * Sistemi Operativi 33 | * Middleware 34 | * A livelli (tier) 35 | * Vari livelli che si parlano (web) 36 | 37 | Oppure 38 | 39 | * Architetture basati sugli oggetti 40 | * RMI (remote method invocation) 41 | * Architetture centralizzate sui dati 42 | * web come file system condiviso 43 | * Architeture basate sugli eventi 44 | 45 | ## Distributed OS 46 | 47 | * Fa i servizi trasparenti all'applicazione 48 | * Si basa su macchine omogenee che girano lo stesso server 49 | 50 | ## Network Operating System 51 | 52 | La mia applicazione distribuita è consapevole che ci sono macchine diverse sotto. Comunicano via rete tramite TCP/IP e socket. 53 | I servizi sono managed dalle applicazioni. 54 | I servizi sono managed dalle applicazioni. 55 | 56 | ## Middleware 57 | 58 | Implementa servizi per renderli trasparenti all'applicazione. 59 | Java/RMI 60 | -------------------------------------------------------------------------------- /Algoritmi/2016-03-18.md: -------------------------------------------------------------------------------- 1 | presi due array, quante volte ogni elemento è presente nell'altro 2 | 3 | c+3c\ctod n+2c\sum{i=1}{n}t_{wi}+c \cdot t_{if} 4 | 5 | worst case 6 | l'if al peggio diventa n 7 | t_{wi} al peggio n+n+n+n+n n \forall i T_{worst}(n)= 2c+3cn+2c\sum{i=1}{n}n\forall i = 2c+3cn+2cn^2 = voglio limitarlo da sopra = O(n^2) 8 | 9 | best case 10 | L'importante è che il 2 array contenga tutto lo stesso numero ripetuto e quel numero è in prima posizione del primo array 11 | 12 | t_{best}(n)= 2c+3cn+0+(t_{if} = c\ctod n) = O(n) 13 | 14 | t_{avg}(n) = mi aspetto che il primo n lo trovo a meta, idem il secondo, idem il terzo = n/2 \forall i = 1/2 \sum{i=1}{n} n = \theta (n^2) 15 | 16 | 17 | Per complicare le cose, assumiamo che l'input non possa contenere due input uguli, ne in un vettore ne nell'altro 18 | 19 | Il caso peggiore è uguale 20 | Il caso migliore ha lo stesso ordine di grandezza, l'algoritmo funziona sempre con un tempo di esecuzione \theta(n^2) 21 | E se gli array fossero ordinati? Caso migliore: ogni numero da ricercare è più piccolo di ogni numero in cui deve essere cercato. 22 | 23 | 24 | max{f(n),g(n)}=\theta(funzione max) 25 | 26 | 27 | ## post pausa 28 | 29 | 30 | Array A di n bit 31 | Array B di n bit 32 | Il bit meno significativo sia alla posizione n 33 | 34 | Somma(A[],B[], C[]) 35 | carry = 0 c 36 | for i=n downto 1 cn 37 | c[i+1] = a[i]+b[1]+carry cn 38 | if c[i+1] <= 1 cn 39 | carry = 0 ct_if 40 | else cn 41 | c[i+1] = c[i] - 2 cf_if 42 | carry = 1 cf_if 43 | c[i] = carry c 44 | 45 | 46 | Caso peggiore, quando c'è sempre overflow = c+5cn+0+2cn+c=O(n) 47 | Caso migliore, quando non c'è mai overflow = O(n) 48 | 49 | 50 | int f(n) 51 | z=n 52 | t=0 2c 53 | while z>0 c log(n) 54 | x = z mod 2 c log(n) 55 | z = z div 2 c log(n) 56 | if x==0 c log(n) 57 | for i=1 to n n * t_{if_k} 58 | t = t+1 n * t_{if_k} 59 | return t c 60 | 61 | T(n) = 3c + 4c log(n) è 2n t_{if_k} 62 | Caso peggiore = quando n=2^h t{_if_k} * (h-1) = 3c + 4c log(n) + 2n(log(n)-1) = O(nlog(n)) = 63 | 64 | if x==0 c log(n) 65 | t = t+n c * t_ifx 66 | 67 | for I=1 to n-1 c n-1 68 | for j=i+1 to n c \sum{i=1}{n} n-i 69 | for k=1 to j j 70 | r = r+1 j 71 | 72 | -------------------------------------------------------------------------------- /Computabilita/riassunto/30-GrammaticheRegolari.md: -------------------------------------------------------------------------------- 1 | # Grammatiche regolari 2 | 3 | Le grammatiche regolari sono di **tipo 3** sulla gerarchia di Chomsky. 4 | 5 | Le grammatiche regolari sono tutte quelle accettabili con un DFA e rappresentabili con un espressione regolare. 6 | 7 | ## Definizione formale 8 | 9 | \begin{definition} 10 | \end{definition} 11 | Chiamiamo grammatica regolare una 4-upla $G=(V,T,P,S)$ dove: 12 | 13 | * $V$ è l'insieme delle variabili, esse verrano usate nelle regole di produzione, sono dette anche non-terminali. 14 | * $T$ è l'insieme dei terminali, simboli che formano le stringhe del linguaggio. 15 | * $P$, è l'insieme delle regole di produzione, la rappresentazione ricorsiva della definizione del linguaggio. 16 | * $S$. è il simbolo di partenza, una delle variabili di $V$. 17 | 18 | Imponiamo su $P$ dei vincoli: 19 | 20 | * $\epsilon$ può solo comparire in $S \to \epsilon$ 21 | * Le produzioni sono tutte lineari a sinistra o a destra 22 | 23 | 24 | ## Lineare a destra o sinistra 25 | 26 | \begin{definition} 27 | Una produzione è lineare a destra se è nel formato: 28 | 29 | * $A \to aB$ 30 | 31 | oppure 32 | 33 | * $A \to c$. 34 | 35 | Le variabili, se ci sono, stanno sempre a destra di tutti i terminali. 36 | \end{definition} 37 | 38 | \begin{definition} 39 | Una produzione è lineare a sinistra se è nel formato: 40 | 41 | * $A \to Ba$ 42 | 43 | oppure 44 | 45 | * $A \to c$. 46 | 47 | Le variabili, se ci sono, stanno sempre a sinistra di tutti i terminali. 48 | \end{definition} 49 | 50 | Non sempre è possibile convertire da lineare a destra a lineare a sinistra, o viceversa. 51 | 52 | ## Espressioni regolari 53 | 54 | Definiamo induttivamente un'espressione regolare 55 | 56 | \begin{definition} 57 | \end{definition} 58 | 59 | Base: 60 | 61 | * $\epsilon$ e $\emptyset$ sono espressioni regolari 62 | * Se $a$ è un simbolo, allora $a$ è un espressione regolare. $L(a)=\{a\}$ 63 | * Una variabile è una variabile e rappresenta un linguaggio. 64 | 65 | Induzione: 66 | 67 | * Se $E$ ed $F$ sono E.R. allora $E+F$ (unione) è espressione regolare. $$L(E+F) = L(E) \cup L(F)$$. 68 | * Se $E$ ed $F$ sono E.R. allora $EF$ (concatenazione) è espressione regolare. $$L(EF) = L(E)L(F)$$. 69 | * Se $E$ è E.R. allora $E^*$ è espressione regolare. $$L(E) = (L(E))^*$$ 70 | * SE $E$ è E.R. allora $(E)$ è espressione regolare. $$L((E)) = L(E)$$ 71 | 72 | 73 | ## Pumping Lemma per linguaggi regolari 74 | 75 | Supponiamo $L$ un linguaggio regolare. Esiste quindi una costante $n$ tale che se $w$ è una stringa di $L$ allora $|w| \geq n$. Possiamo quindi scrivere $w = xyz$ tale che: 76 | 77 | * $y \neq \epsilon$ 78 | * $|xy| \leq n$ 79 | * Per ogni $k \geq 0$, $xy^kz$ è in L 80 | 81 | -------------------------------------------------------------------------------- /RetiSistemiOperativi/2016-10-28.md: -------------------------------------------------------------------------------- 1 | # Thread 2 | 3 | ## Thread Vs Processo 4 | Passare da un processo ad un altro è costoso a livello di risorse. E' infatti necessario re-inizializzare lo spazio di memoria. Mentre nei thread la memoria è condivisa e quindi non è necessario fare il context-switch. 5 | 6 | Non tutti i modelli multithreading sono identici. 7 | Abbiamo un livello user e un livello kernel. 8 | Ci sono più modelli posssibili. 9 | 10 | https://www.tutorialspoint.com/operating_system/os_multi_threading.htm 11 | http://softwareengineering.stackexchange.com/questions/300927/threads-the-difference-of-concurrency-between-many-to-one-model-and-one-to-one 12 | 13 | ## Modello many to one 14 | Utente vede tanti thread indipendenti ma il kernel ne vede uno solo e schedula un solo flusso di elaborazione. Lo scheduler simula il threading. Il sistema operativo non ha meccanismi per gestire direttamente questi thread. Vede solo il blocco visto che poi la divisione è soft. Se uno di questi thread va in loop può essere che il gestore software non è in grado di gestire la cosa e gli altri thread non vengono mai messi in esecuzione. 15 | 16 | ## Modello one to one 17 | Il sistema operativo vede dei thread singoli e ha il controllo diretto su questi. Può gestire le situazioni scomode tipo looping. Mi assicura che tutti i thread girino prima o poi. 18 | 19 | Linux è One to One 20 | Windows è One to One, ma offre la possiiblità di usare il modello molti a uno. 21 | 22 | ## Modello many to many 23 | Ho diversi scheduler / motori in esecuzione ed io gli assegno una serie di thread ad uno scheduler in particolare. 24 | 25 | 26 | Pthreads su Linux - Libreria / Helper 27 | Win32 su Windows - API / Primitiva 28 | 29 | C non ha multithreading implicito 30 | Java ha il multithreading out of the box 31 | 32 | # Primitive thread 33 | ## Unix 34 | exec() =~ fork() 35 | pthreads.create =~ clone 36 | 37 | ## Windows 38 | CreateThreads(ThreadAttributes, 39 | StackSize, //se non default 40 | StartAddress, //punto di inizio del thread 41 | Parameters, //parametri della procedura a StartAddress 42 | CreationFlags, 43 | ThreadId) 44 | 45 | # Segnali 46 | pthreadKill(tid, signal) 47 | Viene mandato un segnale al gestore dei thread che uccide il thread. 48 | //TODO: Cercare di più sui segnali 49 | 50 | In windows non esiste nulla di simile. Ci sono delle soluzioni alternative, ci assomigliano. 51 | 52 | # Thread Pool 53 | Insieme di thread in stato sospeso 54 | Ne prendo uno, lo metto in esecuzione e quando ho finito lo rimetto nel pool 55 | Quando alloco un thread va a finire nel thread pool, posso allocarli finchè sono liberi. 56 | Cerca i Thread Pool 57 | 58 | -------------------------------------------------------------------------------- /Fondamenti/Riassunto/21_Strutture_Relazionali.md: -------------------------------------------------------------------------------- 1 | \newcommand{\pangle}[1]{\langle #1 \rangle} 2 | 3 | # Strutture Relazionali 4 | 5 | Definiamo una *struttura relazionale* ($SR$) come una n-upla ($\langle ... \rangle$) in cui il primo elemento è un insieme non vuoto $S$, chiamato dominio o universo di $SR$, e i rimanenti elementi sono relazioni (che possono avere arietà varia) definite su S. 6 | 7 | I casi da noi studiati sono solitamente caratterizzati dall'avere un insieme S (richiesto per definizione) ed una sola relazione associata, generalmente binaria. 8 | 9 | ### Esempio 10 | 11 | **Insieme Universo** 12 | 13 | $U$ = Insieme $N$ (dei numeri naturali) 14 | 15 | **Relazioni** 16 | 17 | $R1 = n2=m$ = relazione che associa ad ogni numero il suo quadrato 18 | 19 | $R2 = n+m=o$ = relazione che associa a due numeri la loro somma 20 | 21 | $SR = \langle U, R1, R2 \rangle$ 22 | 23 | ## Strutture Relazionali Notevoli 24 | 25 | ### Preordine 26 | 27 | Un **preordine** è una struttura relazionale data da una coppia $\langle S,R \rangle$ in cui S è un insieme ed R è una relazione **binaria**, **riflessiva** e **transitiva** su $S$ 28 | 29 | ### Quasi-ordine 30 | 31 | Un **quasi-ordine** è una struttura relazionale data da una coppia $\pangle{S,R}$ in cui S è un insieme ed R è una relazione **binaria**, **irriflessiva** e **transitiva** su $S$. 32 | 33 | ### Poset 34 | 35 | Un **poset** (chiamato anche *ordine parziale* o *semiordinamento*) è una struttura relazionale data da una coppia $\pangle{S,R}$ in cui $S$ è un insieme e $R$ è una relazione **binaria**, **riflessiva**, **antisimmetrica** e **transitiva**. 36 | 37 | ### Ordinamento 38 | 39 | **Particolare semiordinamento** che esiste se e solo se per ogni $x,y \in S$ una ed una sola delle seguenti condizioni è soddisfatta: 40 | 41 | * $x = y$ 42 | * $\pangle{x,y} \in R$ 43 | * $\pangle{y,x} \in R$ 44 | 45 | Detto semplicemente, in un ordinamento **presi due elementi** dell'insieme di partenza (o insieme universo) **questi sono confrontabili**: posso dire se sono uguali oppure chi è il maggiore e il minore tra i due. 46 | 47 | L'ordinamento prende anche il nome di **ordine totale**. 48 | 49 | ### Buon Ordinamento 50 | 51 | **todo** 52 | 53 | ### Ordini totali vs ordini parziali 54 | 55 | Possiamo facilmente distingurere tra un poset (ordine parziale) e un ordinamento (ordine totale) osservando la rappresentazione del grafo associato ad entrambe le strutture. Nel caso di un ordine totale tutti gli elementi della struttura relazionale sono collegati e confrontabili tra loro, cosa che non è vera per gli ordini parziali, in cui alcuni elementi sono completamente isolati dagli altri. 56 | 57 | 58 | ## Reticoli 59 | 60 | I **reticoli** sono poset in cui per ogni coppia di $\pangle{x,y} \in S$ esistono un mimino maggiorante e un massimo minorante. 61 | 62 | -------------------------------------------------------------------------------- /Architettura/2016-05-12.md: -------------------------------------------------------------------------------- 1 | Cosa succede quando si eseguono istruzioni? 2 | 3 | Puntatore 4 | Punta ad una cella della memoria: contiene l'indirizzo della cella aka label dell'asm 5 | 6 | Posso fare operazioni su un puntatore 7 | 8 | Dentro la CPU ci sono registri "interni" come l'istruction pointer IP (o program counter PC) o lo stack pointer SP etc 9 | 10 | Vediamo "percorso dei dati" / fetch dell'istruzione 11 | 12 | * FETCH 13 | * DECODE 14 | * UPDATE_PC 15 | * EXECUTE 16 | 17 | #Datapath 18 | 19 | Tutto parte dal program counter. 20 | Si chiede alla memoria l'istruzione, i bit 21 | 22 | Il program counter viene mandato alla memoria per chiedere l'istruzione 23 | In output la memoria invia all'istruction register (che contiene quindi l'istruzione corrente). 24 | IR la suddivide "logicamente" in base all'opcode 25 | 26 | In particolare per una R-type non c'è solo bisogno dell'opcode ma anche la "Funct" 27 | (Tralasciamo l'analisi dell'istruzione per ora) 28 | 29 | In seguito dall''IR si tira fuori registroA e registroB, si invia al registerfile, che butta i valori di A e B dentro l'ALU (per ora senza opcode). 30 | 31 | L'ALU produce il risultato e lo butta di nuovo nel register file attraverdo DataIn e AddressIn 32 | 33 | Inoltre va aggiornato il program counter, in qualche momento il PC deve essere collegato alla ALU, come anche deve esserci un +4 da aggiungere al PC. 34 | 35 | 36 | # Istruzioni I type 37 | 38 | Load Word 39 | 40 | LW rt, imm(rs) 41 | Per fare da 16bit di imm a 32, uso SIGN EXTENDER (che non fa altro che fare 16zeri&&16ingresso in out) 42 | 43 | Nulla di strano, stare attenti che non avviene tutto insieme, ma a cicli 44 | 45 | 46 | Store Word 47 | 48 | Molto simile 49 | Solo che il result IMM+RS va dalla ALU alla memoria insieme al valore da scrivere 50 | 51 | 52 | # Branch Equal 53 | 54 | Prima cosa faccio il confronto, se è soddisfatto allora devo costruire il target address. 55 | Si realizza facendo PC+IMM*4 (IMM&&00) 56 | 57 | Shift2 = infilo due zeri nella parte più significativa, i primi 2 arrivano dalla massa i due shiftati fuori muoiono li' 58 | 59 | # Salto incodinzionato 60 | 61 | Occhio al circuito first4 che prende i primi 4 dal PC e gli altri dall' 62 | 63 | 64 | Selezionare con il mux 65 | # Altro 66 | 67 | ## Sul libro 68 | Implementazione singolo ciclo: irrealizzabile ma utile per scopi didattici 69 | Architettura Harward, memoria dati divisa da memoria istruzioni. 70 | Alla fine si comporta quasi come una rete combinatoria, che non è che ci piace tantissimo 71 | 72 | 73 | Implementazione multiciclo: 74 | non c'è più nella 4th e 5th ed. 75 | Ma va studiata. 76 | Fisicamente realizzabile e utile per capire bene. 77 | L'esecuzione dell'istruzione è "sparsa" su più cicli. 78 | 79 | Pipelining: 80 | livello di realismo paragonabile alle CPU 80-90 (approfondimento?) 81 | -------------------------------------------------------------------------------- /Fondamenti/Riassunto/40_Algebra_Booleana.md: -------------------------------------------------------------------------------- 1 | # Algebra Booleana 2 | 3 | 4 | ## Definizione 5 | 6 | Si definisce **algebra booleana** un **reticolo** $\pangle{B,R}$ caratterizzato dall'essere **distributivo**, **limitato** e **complementato**. 7 | 8 | Più precisamente, si parla di algebra di Boole in riferimento ad un insieme B sul quale sono definite due operazioni binarie $\sqcap$ e $\sqcup$, un'operazione unaria ('), e $\underline{1}$ e $\underline{0}$ due costanti, in modo da ottenere la sestupla ordinata(?) $\pangle{B,\sqcap,\sqcup,',\underline{0},\underline{1}}$, che costituisce un reticolo distributivo, limitato e complementato. 9 | 10 | **Chiarimento** 11 | 12 | Generalmente l'operazione $\sqcap$ è chiamata **AND** e si indica anche con $\**$, l'operazione $\sqcup$ è chiamata **OR** e si indica anche con $+$ e l'operazione $'$ è chiamata **NOT** e si indica anche con $!$ o con $\neg$ o anche con $-$. 13 | 14 | ## Enunciato 15 | 16 | E' detto enunciato booleano una proposizione della quale si può sempre dire se è vera o falsa (non lascia cioè spazio ad ambiguità). 17 | 18 | Nell'algebra di Boole un enunciato è ottenuto dalla combinazione di **termini** e **operatori**. 19 | 20 | ## Termini 21 | 22 | I termini di un enunciato sono essi stessi degli enunciati, ovviamente meno complessi dell'enunciato che sto costruendo. Preso un termine posso infatti dire con certezza se è vero o falso. 23 | 24 | Tra tutti i termini riconosciamo dei termini elementari che possono essere o delle costanti ($\underline{0}$ e $\underline{1}$) o delle variabili, generalmente indicate con le lettere minuscole $a,b,c,...$, che come suggerisce il nome variano a seconda dei casi. 25 | 26 | La presenza di variabili non lascia comunque spazio ad ambiguità perché, sostituita una variabile con $\underline{0}$ o con $\underline{1}$, posso sempre dire se l'espressione che contiene le varibili è vera o falsa. 27 | 28 | ## Proprietà Algebra di Boole 29 | 30 | **Commutativa** 31 | $a+b=b+a \qquad a*b=b*a$ 32 | 33 | **Associativa** 34 | $a+(b+c)=(a+b)+c \qquad a*(b*c)=(a*b)*c$ 35 | 36 | **Assorbimento** 37 | $a+(a*b)=a \qquad a*(a+b)=a$ 38 | 39 | **Distributiva** 40 | $a*(b+c)=(a*b)+(a*c) \qquad a+(b*c)=(a+b)*(a+c)$ 41 | 42 | **Idempotenza** 43 | $a+a=a \qquad a*a=a$ 44 | 45 | **Esistenza di minimo e massimo** 46 | $a*0=0 \qquad a+1=1$ 47 | 48 | **Esistenza del complemento** 49 | $a*!a=0 \qquad a+!a=1$ 50 | 51 | ## Extra 52 | 53 | La **più piccola algebra di Boole** esistente è quella definita sull'insime {0,1}. 54 | 55 | È possibile definire un'algebra di Boole su ogni insieme che ha come numero di elementi una potenza di due. 56 | 57 | È detto enunciato duale $D'$ di un enunciato $D$, l'enunciato ottenuto scambiando $\sqcap$ con $\sqcup$ e $\underline{1}$ con $\underline{0}$. Se è dimostrabile $D$ anche il suo duale $D'$ sarà dimostrabile. 58 | -------------------------------------------------------------------------------- /APSoftware/2017-03-17.md: -------------------------------------------------------------------------------- 1 | # Modello di dominio 2 | 3 | Un modello di dominio è una rappresentazione visuale di classi concettuali o di oggetti del mondo reale di dominio. 4 | 5 | Non rappresenta oggetti software. 6 | 7 | ## Motivazioni 8 | 9 | Per comprendere lo spazio del problema: serve a capire 10 | 11 | ## Esempio 12 | Va bene: 13 | +-------------+ 14 | | Sale | 15 | +-------------+ 16 | | dateTime | 17 | +-------------+ 18 | 19 | Non va bene, è un elaborato software, fa riferimento al DB e al metodo print() 20 | +-------------+ 21 | | SalesDB | 22 | +-------------+ 23 | | print | 24 | +-------------+ 25 | 26 | ## Classi concettuali 27 | 28 | E' un idea, una cosa, un oggetto considerato attraverso un simbolo, un intensione e un estensione 29 | 30 | ### Ad esempio 31 | 32 | Sale è il simbolo 33 | 34 | ## Attributo o classe? 35 | 36 | Cio che non è un numero o un testo è spesso rappresentato come una classe concettualmente separata. 37 | 38 | +-------------+ +-------------+ +-------------+ 39 | | Sale | | Store | e non | Sale | 40 | +-------------+ +-------------+ +-------------+ 41 | | - store | 42 | +-------------+ 43 | oppure 44 | 45 | +-------------+ +--------------+ 46 | | Volo | | Destinazione| 47 | +-------------+ +--------------+ 48 | 49 | ## Associazioni 50 | 51 | Relazioni tra oggetti (istanze), indica connessione significativa ed interessante per la realtà di dominio 52 | 53 | +----------------+ +---------------+ 54 | | Cassiere +----> Vendita | 55 | +----------------+ +---------------+ 56 | 57 | ### Ruoli 58 | 59 | Le estremità delle associazioni 60 | 61 | * Molteplicità 62 | * Nome 63 | * Navigabilità 64 | 65 | Nei modelli di dominio generalmente uso solo la molteplicità. In alcuni casi conviene dare il nome (nel caso di associazioni multiple) 66 | 67 | ## Altri consigli 68 | 69 | * Non usare chiavi esterne come attributi 70 | 71 | # Diagrammi di attività 72 | 73 | Capitolo 31e di "Applying UML..." 74 | 75 | ## Cosa è 76 | 77 | Diagramma per rappresentare come il sistema si comporta. 78 | 79 | ## Come è fatto 80 | 81 | Vedi [Diagramma-Attività.png] 82 | 83 | 84 | ### Varianti 85 | 86 | * Alcuni dati potrebbero venire forniti dall'esterno del sistema 87 | * Simbolo "rastrello": indica che un'attività è descritta da un altro diagramma di attività 88 | * Clessidra: un segnale regolare, una cosa che si ripete ogni tot 89 | * Quadrato-Cuneo: segnale asincrono, una cosa che succede da un input esterno, in un momento non definitio 90 | 91 | 92 | # Diagrammi di interazione 93 | 94 | Illustrano le interazioni tra gli oggetti del sistema 95 | Due tipi, diagramma di sequenza e diagramma di comunicazione. 96 | 97 | -------------------------------------------------------------------------------- /RetiSistemiOperativi/routing.md: -------------------------------------------------------------------------------- 1 | # Algoritmi di Routing 2 | 3 | Trovare il percorso migliore, a costo minimo 4 | Assegnare ad ogni tratta che viene percorsa nella rete un costo, numero intero. 5 | 6 | Il problema del routing non esiste se c'è una sola tratta che collega due punti, ovviamente. 7 | 8 | # Distance Vector 9 | Implementazione distribuita di Bellman Ford 10 | 11 | dist(S,X) = min{dist(AdiacS,X)+c(S,AdiacS)} 12 | 13 | dist = somma dei costi 14 | 15 | Facilmente implementabile in maniera distribuita 16 | 17 | ## Implementazione 18 | Ciascusa coppia di nodi ha una tabella che dice quanto il nodo dista dagli altri. Se due nodi sono collegati ad ogni passo dell'agoritmo i due nodi si scambiano la tabella/vettore. In base a quello che dice il vicino e il costo tra i due nodi, essi fanno i conti. 19 | 20 | t0 21 | 22 | A -1> B 23 | A -3> D 24 | A -0> A 25 | A -inf> altri 26 | 27 | B -1> A 28 | B -1> C 29 | B -3> D 30 | B -0> B 31 | B -inf> altri 32 | 33 | D -3> A 34 | D -3> B 35 | D -inf> C 36 | D -0> D 37 | D -2> E 38 | 39 | t1 40 | A riceve nuove informazioni 41 | In particolare B gli dice che vede a distanza 1 il nodo C, quindi A-\>B-\>C = 1+1=2 42 | E da D gli dice che D vede E a distanza 2. Quindi A -> E = 5 43 | 44 | B riceve che la distanza B-E non è infinita ma si passa per C 45 | 46 | t2 47 | B passa ad A il fatto che si puo' passare per BC per arrivare ad E e costa 1+2=3. Quindi costa 4 e non più 5 fare AE. 48 | 49 | ## Vantaggi Svantaggi 50 | 51 | E' lento, soprattutto se ci sono modifiche nella rete. Il router più lento fa da bottleneck. 52 | Ci sono protocolli che lo usano. RIP (Inet), IGRP, EIGRP, BGP (protocollo di routing che usa path vector che pur essendo diverso usa concetti simili, usato inter dominio, inter AS). 53 | 54 | # Link State 55 | Non è distribuito. Ogni nodo fa da solo. Le informazioni sulla topologia della rete vengono distribuite in modo flooding (simil broadcast). 56 | 57 | Poi usa l'algoritmo di Dijkstra per calcolare il percorso migliore, costruendo un albero di copertura. 58 | 59 | ## Alg 60 | N={Origine} 61 | Per ogni nodo adiacente calcolo il costo, per tutti gli altri metto distanza=inf 62 | finchè non ho tutti i nodi del grafo 63 | Aggiungo un nodo per volta, aggiungo il nodo più vicino a tutti i nodi adiacenti all'insieme dei nodi N. Accresce i nodi uno per volta. 64 | Una volta che lo ho aggiunto, ricalcolo la distanza tra i nodi. Magari posso raggiungere nodi già in N con i nuovi nodi aggiunti ad un costo minore. 65 | 66 | ## Esempio 67 | 68 | Il nodo manda messaggi in tutte le direzioni, ovviamente in modo furbo, se l'ho già inoltrato non lo inoltro. 69 | 70 | Prendiamo N={A} 71 | N può raggiungere B:1 D:3 72 | Prendo B e lo metto in N. 73 | Posso raggiungere A -> C con costo 2 e AD a costo 3. Scelgo C e lo metto in N. 74 | Ora posso fare D3 E4 75 | Prendo D e lo metto dentro N 76 | Ora manca solo E, che lo posso raggiungere a costo 4 o costo 5. Aggiungo quindi E4 ad N. 77 | 78 | -------------------------------------------------------------------------------- /APSoftware/2017-03-30.md: -------------------------------------------------------------------------------- 1 | # Statechart 2 | 3 | Molto molto simili agli FSM. 4 | 5 | Modellano un oggeto reattivo complesso in risposta ad eventi. Gli oggetti modellano valide operazioni ovverso specifiche di protocollo o di linguaggio. 6 | 7 | ## Tipi di oggetti 8 | 9 | * Indipendenti dallo stato: risponde sempre allo stesso modo ad un determinato evento. E' il caso di una funzione. 10 | * Dipendente dallo stato: risponde in modi diversi ad un determinato evento a seconda dello stato in cui si trova l'oggetto. 11 | 12 | ### Esempi di oggetti 13 | 14 | * dispositivi fisici (telefono, auto, forno a microonde) 15 | * transazioni e oggetti di business (ordine, lettera, pacco) 16 | * mutatori di ruolo 17 | 18 | ### Esempi di protocolli e sequenza validi 19 | 20 | * protocolli di comunicazione 21 | * TCP ha vari stati 22 | * flusso e navigazione delle pagine/finestre UI 23 | * controller di flusso e sessioni 24 | * cookie 25 | * Operazioni di sistema dei casi d'uso 26 | * procedimenti di business ad esempio la vendita 27 | * gestione degli eventi di una singola finestra di UI 28 | 29 | 30 | ## Estensioni degli stati finiti 31 | 32 | * Posso introdurre stati annidati (cioè un macro stato all'interno può avere altri sottostati/sottodiagrammi) 33 | * Quando sono dentro il macrostato sono in N sottostati. Posso uscire da ogni sottostato in ogni momento, e se esco dal sottostato esco dal macrostato. 34 | * Posso introdurre "history" 35 | * Mi permette di aggiungere memoria al mio sistema 36 | * In particolare mi ricordo lo stato in cui ero prima, perchè in uno stato ci posso arrivare in N modi diversi. 37 | * Ortogonalità 38 | * Si usa una linea tratteggiata che divide lo stato iniziale in due macrostati 39 | * Sono negli entrambi macrostati contemporaneamente 40 | * Un macrostato può condizionare l'altro 41 | * C'è nei compitini!! 42 | 43 | 44 | # Eserczio: riproduzione musicale 45 | 46 | Un piccolo sistema di riproduzione musicsale può essere acceso e spento con i comandi on off 47 | 48 | Quando acceso il sisteam può esporre il segnale radio o il contenuto di un dispositivo USB. Si può passare da ascolto a ascolto usb, e viceversa. Contemporaneamente il display visualizza il titolo della canzone o la data 49 | 50 | Si può passare da data e ora e viceversa con i comandi titolo e ora. Quando il sistema veine accesso entra nello stato riproduzione radio e visualizza l'ora, sccessivamente nello stato in cui si torvava prima dello spegnimento 51 | 52 | # Architettura software 53 | 54 | Abbiamo il tipo di architettura (il modello) e l'architettura (quella istanziata). 55 | 56 | ## Architettura Logica 57 | 58 | A strati. Organizzazione logica di classi in: 59 | 60 | * package 61 | * sottosistemi 62 | * strati: 63 | * gruppi a grana molto grossa di: 64 | * classi 65 | * package 66 | * sottoinsiemi 67 | 68 | 69 | A strati stretta: uno stato può richiamare i servizi allo strato più basso 70 | A strati rilassata: uno stato può richimare i servizi di uno qualsiasi degli strati più in basso -------------------------------------------------------------------------------- /Computabilita/riassunto/20-DFA.md: -------------------------------------------------------------------------------- 1 | # Automi a stati finiti deterministici 2 | 3 | ## Definizione informale 4 | 5 | An automaton is supposed to run on some given sequence of inputs in discrete time steps. An automaton gets one input every time step that is picked up from a set of symbols or letters, which is called an alphabet. At any time, the symbols so far fed to the automaton as input, form a finite sequence of symbols, which finite sequences are called words. An automaton contains a finite set of states. At each instance in time of some run, the automaton is in one of its states. At each time step when the automaton reads a symbol, it jumps or transitions to another state that is decided by a function that takes the current state and symbol as parameters. This function is called the transition function. The automaton reads the symbols of the input word one after another and transitions from state to state according to the transition function, until the word is read completely. Once the input word has been read, the automaton is said to have stopped and the state at which automaton has stopped is called the final state. Depending on the final state, it's said that the automaton either accepts or rejects an input word. There is a subset of states of the automaton, which is defined as the set of accepting states. If the final state is an accepting state, then the automaton accepts the word. Otherwise, the word is rejected. The set of all the words accepted by an automaton is called the "language of that automaton". Any subset of the language of an automaton is a language recognized by that automaton. 6 | 7 | In short, an automaton is a mathematical object that takes a word as input and decides either to accept it or reject it. Since all computational problems are reducible into the accept/reject question on words (all problem instances can be represented in a finite length of symbols), automata theory plays a crucial role in computational theory. 8 | 9 | ## Definizione formale 10 | 11 | Un automa a stati finiti deterministico (DFA) è costituito da: 12 | 13 | * Un insieme finito di stati, $Q$. 14 | * Un insieme finito di simboli di input, $\Sigma$. 15 | * Una funzione di transizione $\delta$, che ha come parametro uno stato ed un simbolo e ritorna uno stato. 16 | * Uno stato di partenza, appartenente a $Q$ 17 | * Un insieme di stati accettanti, sottoinsieme di $Q$. 18 | 19 | $$A = (Q, \Sigma, \delta, q_0, F)$$ 20 | 21 | ## La funzione di transizione estesa 22 | 23 | $\delta^*$ è detta funzione di transizione estesa. Essa prende in input uno stato e una stringa e ritorna uno stato. 24 | 25 | E' definita per induzione come segue: 26 | 27 | \begin{definition} 28 | \end{definition} 29 | 30 | * Caso base: $\delta^*(q,\lambda) = q$ 31 | * Passo induttivo: suppniamo $w = xa$, quindi: $$\delta^*(q,w) = \delta(\delta^*(q,x),a)$$ 32 | 33 | 34 | ## Linguaggio dei DFA 35 | 36 | Dato un DFA $A$, chiamiamo $L(A)$ il linguaggio accettato da $A$, cioè: $$L(A) = \{w | \delta^*(q_0,w) \in F\}$$ 37 | 38 | Tutti i linguaggi accettabili da un DFA qualsiasi sono **linguaggi regolari**. 39 | 40 | -------------------------------------------------------------------------------- /APSoftware/teoria/13-Testing.md: -------------------------------------------------------------------------------- 1 | # Agile Testing 2 | 3 | ## Short releases, incremental delivery 4 | 5 | Tests developed incrmentally along with the software 6 | 7 | No testing phase 8 | 9 | Ogni new feature e miglioramento deve essere descritto da un set di test cases 10 | 11 | ## Time Boxed Iterations 12 | 13 | Il progresso deve essere misurabile oggettivamente 14 | 15 | Specifica le feature attraverso i test costruiti prima delle feature 16 | 17 | Assicurarsi che non si scrivano i test solo per la parte di codice che è già stata scritta 18 | 19 | ## Pair Programming and Collective Ownership 20 | 21 | Continuos code inspection: controllo continuo 22 | 23 | Implicit check list: costruiamo nel gruppo cosa è importante e cosa no === team culture 24 | 25 | ## Refactoring 26 | 27 | Si testa per capire se il refactoring è andato a buon fine. 28 | 29 | ## Customer involment 30 | 31 | Se si fa progresso o si peggiora lo si comunica all'utente: per capire questo guardo i test. 32 | 33 | Inoltre i test mi permettono di capire quali requisiti sono ambigui o mal specificati. 34 | 35 | # Testing Granularity 36 | 37 | ## Tipologia di Test 38 | 39 | ### Unit Testing 40 | 41 | Testo i singoli pezzi, nella speranza che sono fatti bene. Se non va l'unit test non va il tutto. 42 | 43 | ### Integration Testing 44 | 45 | Metto insieme i pezzi: capisco se il sistema si monta insieme bene 46 | 47 | ### System Testing 48 | 49 | Testo le funzionalità complete 50 | 51 | ### Test di accettazione 52 | 53 | L'utente va bene con la soluzione? 54 | 55 | ### Test di non regressione 56 | 57 | La versione del prodotto va almeno tanto bene quanto la versione precedente 58 | 59 | ## Testing Goals 60 | 61 | * Test alle functional properties: quello che fa 62 | * Due macchine entrambe mi portano dal punto A al punto B 63 | * Test alle non functional properties: come lo fa 64 | * Una macchina mi porta "bene" l'altra "male" 65 | 66 | ## Testing Approaches 67 | 68 | * Test Funzionale 69 | * Faccio test partendo da quello che penso il software debba far 70 | * Test Strutturale 71 | * Guardo dentro la struttura e genero i test in base alla struttura del codice 72 | (* Test basato sui difetti 73 | * Testo i casi critici) 74 | 75 | ## Test in agile 76 | 77 | * Definisco nella startup le unit test 78 | * Nello sprint faccio i test di integrazione/funzionale 79 | * Quando torno nella startup faccio regression testing. Mi chiedo anche se il software è testato bene, attraverso il test strutturale 80 | * Faccio acceptance testing durante la review 81 | ... 82 | 83 | ## Come creare i casi di test 84 | 85 | I test sono un campione dello spazio, di tutte le possibilità 86 | 87 | * Expert Judgement: una persona genera i casi di test usando la sua esperienza 88 | * Svantaggio: costo (in tempo) e misurabilità (non so se i test che ha fatto sono abbastanza, devo fidarmi di chi scrive i test) 89 | * Combinatorial testing: 90 | * Definisice meccanismi automatici di generazioni di varianti di test 91 | * La qualità è determinata da: 92 | * Numero di test per caso 93 | * Numero di casi 94 | * Model based testing: 95 | * Segue un modello di passi per scrivere i test, scegliendo un modello -------------------------------------------------------------------------------- /APSoftware/teoria/10-GRASP.md: -------------------------------------------------------------------------------- 1 | # RDD 2 | 3 | Responsibility Driven Development 4 | 5 | E' una progettazione basata su: 6 | 7 | * responsabilità 8 | * cioè che si deve fare 9 | * gli oggetti hanno responsabilità 10 | * ruoli 11 | * obiettimo o capacità che un oggetto o una classe ha di partecipare ad una relazione con un altro oggetto 12 | * collaborazioni 13 | * oggetti collaborano per raggiungere un obiettivo 14 | 15 | ## Responsabilità 16 | 17 | * Responsabilità di fare 18 | * Di fare qualcosa: calcolo, creare oggetti, iniziare azioni, controllare 19 | * Di conoscere: conoscere i dati incapsulati, gli oggetti correlati 20 | 21 | Granularità delle responsabilità: 22 | 23 | * Fine: aggiungere un metodo ad una classe 24 | * Grossa: progettazione di numerose classi 25 | 26 | Quando assegno le responsabilità? O durante la modellazione o durante la codifica. In UML durante la modellazione statica e dinamica. 27 | 28 | ## Principi della progettazione 29 | 30 | * Information Expert: principio generale di assegnazione delle responsabilità 31 | * una classe possiede le informazioni necessarie per soddisfare le responsabilità 32 | * modellando il sistema trovo nuove responsabilità 33 | * Esempio: per avere il totale di una vendita bisogna conoscere le istanze ddi ogni item venduto. L'istanza della vendita tiene info sul totale ma non puo' fare tutto da solo. 34 | * creator: responsabile creazione di una nuova istanza di una classe 35 | * chi deve essere responsabile della creazione di una nuova istanza di una classe? 36 | * assegnare a B le responsabilità di creare istanze di tipo A se e solo se: 37 | * B aggrega oggetti di tipo A 38 | * B utilizza A 39 | * B possiede tutti i dati per l'inizializzazione di A 40 | * low coupling: dipendenza bassa e riuso maggiore 41 | * estremizzato in un sistema per cui si comunica via messaggi, ma cio' non e' sempre buono 42 | * accoppiare tanto rende difficili i cambiamenti locali 43 | * classi molto accoppiate sono a volte incomprensibili prese da sole 44 | * difficile riusare classi molto accoppiate 45 | * high cohesion: mantenere oggetti focalizzati, comprensibili e gestibili 46 | * la coesione indica quanto siano correlate e concentrate le responsabilita' di un elemento 47 | * un oggetto che fa non troppe cose e tutte correlate ha coesione alta 48 | * una classe con coesione bassa fa tante cose non correlate 49 | * regola pratica, una classe con coesione alta: ha pochi metodi con funzioni correlate e non fa troppe cose, collabora con gli altri oggetti per condividere lo sforzo 50 | * controller: primo oggetto oltre lo strato di ui che coordina un'operazione di sistema 51 | * vantaggi: 52 | * La logica applicativa non è gestita nello strato di interfaccia 53 | * Riuso della logica (svincolata dalla UI) 54 | * Si possono utilizzare interfacce diverse 55 | * Se si usano controller basati sui caso d’uso è possibile verificare che le operazioni si susseguano in una sequenza legale 56 | * tipici errori (controller gonfi) 57 | * esiste una unica classe controller che riceve tutti i numerosi eventi di sistema 58 | * Il controller svolge parte del lavoro prima di delegarlo 59 | * Il controller ha numerosi attributi e conserva informazioni sul sistema e sul dominio -------------------------------------------------------------------------------- /BasiDiDati/video/02-Modello-ER.md: -------------------------------------------------------------------------------- 1 | # Entità e attributi di entità 2 | 3 | Schema concettuale: insieme di concetti decritti per mezzo di strutture di rappresentazione. Più astratto del modello logico. 4 | 5 | ## Entità 6 | 7 | Una entità è una classe di oggetti che: 8 | 9 | * Sono di interesse per l'applicazione 10 | * hanno esistenza autonoma 11 | * hanno proprietà comuni 12 | 13 | Ogni entità ha un nome, univoco, singolare, espressivo. E' rappresentata graficamente da un rettangolo 14 | 15 | Ad ogni entità è associata una descrizione. 16 | 17 | Una istanza di un'identità denota un oggetto dell'insieme rappresentato dall'entità 18 | 19 | ## Attributo di entità 20 | 21 | Proprietà locale e caratteristica di un'entità, di interesse ai fini dell'applicazione. Proprietà il cui valore in ogni istanza dipende solamente dall'istanza dell'entità e non da altri elementi dello schema. Il valore di un attributo appartiene ad un dominio. 22 | 23 | Ogni attributo ha un nome (univoco dentro l'entità). Un attributo si rappresenta da un cerchio collegato alla entità a cui l'entità appartiene. 24 | 25 | # Relazioni 26 | 27 | Fra due o più entità definiamo il concetto di relazione: un legame logica fra più entità. Il numero di entità coinvolte nella relazione definisce il grado dell'entitò. 28 | 29 | Ogni relazione ha un nome che identifica la relazione nell'ambito nello schema. Si rappresenta con un rombo collegato alle entità che la relazione collega. 30 | 31 | Una relazione può essere istanziata, specificando in una tupla le entità che sono coinvolte. 32 | 33 | Il nome della relazione deve essere singolare, espressivo e si preferiscono i sostantivi invece che i verbi (se possibile e naturale) 34 | 35 | ## Attributo di relazione 36 | 37 | E' un attributo che non appartiene ad alcuna entità coinvolta nella relazione. E' una proprietà del legame logico rappresentato dalla relazione. Anche in questo caso l'attributo ha un dominio. 38 | 39 | # Cardinalità 40 | 41 | Un vincolo di cardinalità tra un entità E ed una relazione R espreime un valore minimo ed un valore massimo di istanze della relazzione R a cui può partecipare ogni istanza dell'entità E. Serve a caratterizzare meglio il significato di una relazione. 42 | 43 | # Tipi di relazioni 44 | 45 | 1 a 1 46 | 1 a n 47 | n a n 48 | 49 | # Relazione IS-A 50 | 51 | Definibile tra due entità, una padre e una figlia. L'entità figlia rappresenta un sottoinsieme delle istanze dell'entità padre. 52 | 53 | Si rappresenta con una freccia dal padre al figlio. 54 | 55 | Tutti gli attributi del padre li ha il figlio. 56 | 57 | Il padre potrebbe generalizzare più entita figlie, attraverso la propriet dell'erediterietà. 58 | 59 | Una generalizzazione può essere di due tipi: 60 | 61 | * Completa, cioè se l'unione dei figli da il padre 62 | * Non complete, cioè se l'unione dei figlio non da il padre 63 | 64 | # Relazione n-arie e identificatori 65 | 66 | Attributo composto: attributo definito su un dominio complesso, un dominio di tipo record. 67 | 68 | Identificatore: insieme di proprietà/attributi che permettono di identificare univocamente un'entità. 69 | 70 | Identificatori interni: formato solo da attributi dell'entità. 71 | Identificatori esterni: formato da attributi dell'entità e da relazione che coinvolgono l'entità -------------------------------------------------------------------------------- /Complementi/CoseSuMatrici.md: -------------------------------------------------------------------------------- 1 | # Matrici 2 | 3 | ## Definizione 4 | 5 | Tabella di numeri a $p$ righe e $q$ colonne, composta da elementi 6 | 7 | ## Puo' essere 8 | 9 | ### Quadrata 10 | se $p = q$ 11 | 12 | ### Triangolare superiore 13 | Una matrice quadrata A di ordine $n$ si dice triangolare superiore se tutti gli elementi che si trovano sotto la diagonale principale sono nulli. 14 | 15 | ### Simmetrica 16 | Una matrice quadrata si dice simmetrica se i suoi elementi in posizioni simmetriche rispetto alla diagonale principale sono uguali. 17 | 18 | ### Identità 19 | Chiamiamo matrice unità o matrice identica di ordine n la matrice quadrata $I_n$ avente tutti gli elementi della diagonale principale uguali a 1 e tutti gli altri elementi uguali a 0 (la matrice identica è, quindi, una matrice diagonale). 20 | ## Operazioni 21 | 22 | ### Trasposta 23 | E' la matrice avente come elemento di posto $(j, i)$ l’elemento di posto $(i, j)$ della matrice di partenza. 24 | 25 | ### Somma tra matrici 26 | Solo se hanno lo stesso numero di righe e colonne. Sommo termine a termine. 27 | 28 | ### Moltiplicazione per uno scalare 29 | Moltiplico tutti i termini per un numero 30 | 31 | ### Prodotto tra matrici 32 | A, B due matrici. Possibile solo se righe A = colonne B e colonne A = righe B 33 | $c_{ij} := a_{i1}b_{1j} + a_{i2}b_{2j} + \ldots + a_{iq}b_{qj}$ 34 | 35 | ### Inversa 36 | Si dice inversa di A la matrice ottenuta facendo nell'ordine: 37 | 38 | + Trasposta di A 39 | + Complemento algebrico di A^t 40 | + cA^t/det(A) 41 | 42 | ## Determinante 43 | 44 | ### Metodi di calcolo 45 | * Sarrus (solo 3x3) 46 | * Calcolo per matrici ridotte 47 | * Su riga o colonna 48 | 49 | ### Proprietà 50 | Una matrice quadrata con due righe o due colonne uguali ha determinante nullo. 51 | 52 | Siano A e B due matrici quadrate di ordine n che si ottengono una dall’altra scambiando fra loro due righe. Allora det A = − det B. Un’analoga proprietà vale per lo scambio di colonne. 53 | 54 | Se una matrice quadrata A ha una riga che è multipla di un’altra, allora det A = 0. Un’analoga proprietà vale per le colonne. 55 | 56 | Sia A una matrice quadrata di ordine n e k un numero reale. Si ha allora: $\det (kA) = k^n \det A$. 57 | 58 | **Teorema di Binet** Date due matrici quadrate dello stesso ordine A e B si ha: $\det(AB) = \det A \det B$. 59 | 60 | # Sistemi lineari 61 | 62 | ## Teoria 63 | 64 | ### Teorema di Cramer 65 | 66 | Se $\det(A) \ne 0$, allora c'è una ed una sola soluzione, altrimenti nessuna o infinite. 67 | 68 | ## Metodi risolutivi 69 | 70 | ### Cramer 71 | 72 | Solo se la matrice delle incognite è quadrata 73 | 74 | A_x = \frac{det A(x)}{det A} 75 | A_y = \frac{det A(y)}{det A} 76 | A_z = \frac{det A(z)}{det A} 77 | 78 | ### Gauss 79 | 80 | Si riduce a scala la matrice e si sostituisce 81 | 82 | Operazioni permesse: 83 | * Scambio di righe e colonne (se scambio le colonne devo fare attenzione) 84 | * Moltiplico per uno scalare una riga/colonna 85 | * Scrivo una riga come $k * \text{riga} + q * \text{altraRiga}$ 86 | 87 | ### Gauss Jordan 88 | 89 | Solo se la matrice delle incognite è quadrata, mi serve ALTRIALTRIcalcolare l'inversa. 90 | 91 | $Ax=b \rightarrow A\cdot x \cdot A^{-1} = b \cdot A^{-1} \rightarrow I\cdot x = b \cdot A^{-1}$ 92 | 93 | 94 | # Vettori 95 | -------------------------------------------------------------------------------- /RetiSistemiOperativi/2016-10-25.md: -------------------------------------------------------------------------------- 1 | # Processi 2 | 3 | Vedere autonomamente la inter process communication 4 | 5 | ## Caratteristiche processi 6 | * Testo, eseguibile, pezzo di programma 7 | * Program Counter, valore di un registro della CPU quando il programma è eseguito dalla CPU, in sostanza li ci metto il PC quando il processo viene sospeso per essere ripreso 8 | * Registri CPU 9 | * Spazio di memoria dedicato 10 | * Stack 11 | * Dati dinamici (heap) 12 | 13 | Creazione -> Pronto --DISPATCH--> Esecuzione --INTERRUPT--> Pronto 14 | Esecuzione --WAIT--> Attesa --SIGNAL--> Pronto 15 | Esecuzione -- --> TERMINAZIONE 16 | Dispatch = fa cose sul memory managment,caricamentento registri etc 17 | 18 | Process control block, descrittore del processo 19 | PID 20 | Stato 21 | Registri (Incluso PC) 22 | Memory Managment (Page Table) 23 | Priorità, Scheduling 24 | File e risorse aperte dal processo 25 | 26 | Sospendere un processo = salvare nel PCB lo stato dei registri e caricare lo stato dei processi presente in un altro PCB 27 | 28 | Dopo la creazione un processo va nella ready list insieme ad altri processi. La CPU prende il processo e lo esegue. 29 | Dopo un po' di tempo la CPU parcheggia il processo e ne prende un altro nella ready list, time slice scheduling. 30 | Oppure torno nella ready list dopo che ho ricevuto un interrupt 31 | Oppure faccio IO request, vado in coda IO, esco dalla coda IO vado in ready list. 32 | Oppure dopo una wait 33 | Oppure faccio una fork, mi sospendo perchè ci sono due processi operativi 34 | 35 | T0 P1=esecuzione 36 | T1 P1=sospeso 37 | Salvo stato p1 38 | Scheduling 39 | Ripristino p2 40 | p2=esecuzione 41 | 42 | Il contenxt switch ci mette un po' di tempo 43 | Non posso saltare da un processo all'altro quanto voglio. Se switcho al 100% nessun processo viene mai eseguito 44 | 45 | while true 46 | getRequest() 47 | pippo = fork() //si sdoppia il processo, una copia per il padre e una per il figlio, e c'è da gestire entrambi i cas 48 | 49 | if(pippo==0) 50 | io sono il figlio 51 | handleRequest() 52 | else if pippo>0 53 | io sono il padre 54 | gobacktop 55 | 56 | 57 | Albero 58 | 59 | Sched 60 | init 61 | login 62 | bash 63 | sshd 64 | kthreadd 65 | memoryMan 66 | fileSystem 67 | 68 | exit() 69 | kill(pid, ....) 70 | 71 | 72 | Su windows non esiste questo albero concettuale 73 | CreateProcess(ApplicationName, //path to exe 74 | CommandLine, //params 75 | Process Attribute, //parametri di sicurezza del processo 76 | Thread Attributes, //attributi del thread creato insieme al processo 77 | IneritHandles, //inerita gli handle, identifica le risorse aperte 78 | CreationFlags, //importante la flag che dice CREATE_WAIT or CREATE_EXECUTE 79 | Environment // 80 | CurrentDirectory, //quale è la $CWD del file system del processo 81 | StartupInfo, 82 | ProcessInformation //PID e Handle processo creato 83 | ); 84 | CreateThread() 85 | Ogni processo vive in un suo ambiente e puo' generare un nuovo processo su cui ha controlo. Questo processo puo' essere di qualsiasi tipo. 86 | Su windows un processo ha la lista di thread. Quando creo un processo creo anche un thread. Su Linux sono entità separate. 87 | 88 | -------------------------------------------------------------------------------- /APSoftware/2017-02-23.md: -------------------------------------------------------------------------------- 1 | # Aspetti Organizzativi del corso 2 | 3 | Scrum, UML, Pattern, (Testing, forse) 4 | 5 | Scrum = lavorare insieme riuscendo a fare di più di quello che si riuscirebbe se si lavorasse insieme ma separati 6 | 7 | ## Libri 8 | 9 | * Applicare UML e i pattern, Larman, 4th 10 | * Ing. Sw., Sommerville 11 | * UML distilled, Fowler 12 | * Patterns of Enerprise App. Arc, Fowler 13 | 14 | ## Laboratorio 15 | 16 | Version control e UML 17 | Consegna incrementale 18 | Da 0 a 4 punti per lo scritto 19 | 20 | 21 | # Software 22 | 23 | Il SW è complesso (dimensione e interconnessione articolata), costruito da più persone, con più versioni ed in uso per un periodo di molti anni, con requisiti volatili. 24 | 25 | # Ingegneria 26 | 27 | Distinguiamo progetti di routine e progetti innovativi. 28 | 29 | Generalmente i sw di routine sono pochi, perchè si presentano sempre problemi nuovi che richiedono soluzioni innovativi 30 | 31 | Il SW non è un progetto tradizionale 32 | 33 | * Le specifiche variano, anche molto spesso, cambia più di ogni cosa 34 | * E' soggetto a evoluzione continua, aggiornamenti, bugix, perfezionamenti 35 | * E' una disciplina nuova 36 | * ha una storia breve 37 | 38 | The mythical man-month 39 | 40 | "programmare per te stesso rispettoa programmare per gli altri porta al quadrato dei costi" 41 | "aggiungere persone ad un progetto in ritardo, lo fa diventare più in ritardo" 42 | 43 | # Processo di sviluppo 44 | 45 | (capitolo 2,3 del Larman) 46 | 47 | Insieme di attivià per sviluppo ed evoluzione del software: 48 | 49 | + analisi dei requisiti, capire cosa fa il sistema 50 | + progettazione, progetto del sistema da implementare 51 | + sviluppo, produzione del sistema software 52 | + convalida, verifico che il progetto soddisfa i requisiti 53 | + evoluzione, il sw viene modificato 54 | 55 | Non è detto che si fanno in questo ordine 56 | 57 | ---- 58 | 59 | "Sviluppare il SW non è come mietere il grano" 60 | 61 | Se aggingo persone il tempo diminuisce ma dopo un po' inizia ad aumentare 62 | 63 | ---- 64 | 65 | Proprietà = avere una caratteristica (tempo di esecuzione) 66 | Qualità = la proprietà soddisfa certi vincoli (tempo di esecuzione < X) 67 | 68 | Il SW deve: 69 | 70 | * fornire le funzionalità e prestazioni richieste dal cliente 71 | 72 | Non funzionali: 73 | * manutenibili 74 | * affidabile 75 | * efficiente 76 | * usabile 77 | 78 | proprietà funzionale = quello che il sw deve fare 79 | proprietà non funzionale = come il sw deve farlo 80 | 81 | ---- 82 | 83 | Modelli di processo 84 | 85 | Un processo di sviluppo è basato su un modello di processo. Ad esempio un processo di sviluppo è scrum, agile etc 86 | 87 | ## Modello a cascata 88 | 89 | Royce, 1970, contesto industriale 90 | 91 | Studio di fattibilità -> Analisi requisiti e specifiche -> design -> coding e testing -> integrazione e test di sistema -> deployment -> manutenzione 92 | 93 | Va bene per cose non variabili, se cambia qualcosa c'è da rifare tutto. 94 | 95 | ## Modello a spirale 96 | Boehm, 1988 97 | 98 | Determinare obbiettivi, alternative, dipendenze -> valutare rischi ed alternative -> sviluppo e test -> pianifico per la prossima iterazione -> REDO 99 | 100 | 101 | --------------------------------------------------------------------------------