Laboratorio di Calcolo Prof.G.Ciapetti AA 2005/2006 Prof. G.Ciapetti Struttura del corso: ~ 20 h lezioni ~ 20 h esercitazioni in laboratorio ( 7 esercitazioni x 3 h – 14:15 18:15 ) Max assenze 2. Ultime 2 (realizzazione programma) valutate come prove in itinere. Prova finale con realizzazione di un programma Sito: www.roma1.infn.it/people/ciapetti/labcalc/index.htm Testi consigliati: Il Linguaggio C. – B.W.Kernighan, D.M.Ritchie – Jackson Libri C-Didattica e programmazione. – Kelley & Pohl - Addison e Wesley Programmare in C. – M.Liverani – Progetto Leonardo Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Accesso alla pagina web: http://www.roma1.infn.it/people/ciapetti/labcalc Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Sistemi Informatici Struttura generale (dai PC ai grandi Mainframes): Hardware (componenti fisici del sistema) Firmware ( microprogrammi permanenti ) Software ( programmi eseguiti dal sistema) Hardware: CPU Memoria centrale Periferiche (tastiera, mouse, video, dischi, stamp….) Software: Sistema operativo Software di comunicazione Programmi applicativi Sistema operativo: Interpretare ed eseguire comandi Gestione delle risorse di calcolo (CPU, memorie veloci) Gestione del file system Colloquio con le periferiche Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Architettura hardware: Basata sul modello della macchina di Von Neumann (Priceton, 1946. “IAS machine” a valvole. Programma in memoria) Bus di sistema CPU Memoria centrale Interfaccia periferiche Memorie di massa Terminali Stampanti Unita’ logico-aritmetica Central Processing Unit: svolge operazioni logiche e aritmetiche, gestisce il trasferimento dei dati fra memoria centrale, registri di calcolo, memorie periferiche Memoria Centrale: contiene (parte) delle istruzioni che i processori della CPU devono eseguire e i dati locali Intrefaccia periferiche: gestisce tutto il traffico di informazioni in ingresso/uscita ( I/O ) Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti CPU Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Funzionamento Memoria Memoria Centrale Laboratorio di Calcolo Prof.G.Ciapetti

CODIFICA DELL’INFORMAZIONE In un calcolatore la codifica è binaria Fenomeno fisico in due stati diversi: Tensione (alta/bassa) Magnetizzazione (n/s) Luce-buio -Unità di informazione : bit (0/1) Byte (8 bit) CODIFICA DEI NUMERI Noi utilizziamo il Sistema di numerazione “arabico”: Numero  sequenza di simboli (10 simboli: 0,1,………9) Sistema “posizionale”: il significato del simbolo dipende dalla posizione Alternativa: sistema additivo Numeri romani: I, V, X, L, C, D, M 3000  MMM Sistemi posizionali: caratterizzati dalla base p Alfabeto: a,b,c,d,e,f........ (basato su “p” simboli diversi) Nbase p  anan-1….a1a0 ai = generico simbolo (a,b,c,d,e,f........ ) m = n+1: numero delle cifre Np = an pn + an-1 pn-1 +.......+ a1 p1 + a0 p0 = n0 i ai pi Con m cifre pm numeri diversi da: 0  pm-1 SISTEMA ARABICO  10 simboli  p=10 Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti p=10 (decimale) (0,…….9) 33110 = (3*102 + 3*101 + 1*100) p=2 (binario) (0,1) 1010010112 = (1*28 + 0*27 + 1*26 + 0*25 + 0*24 + 1*23 + 0*22 + 1*21 + 1*20) = 33110 p=8 (ottale) (0,1,………..7) 5138 = (5*82 + 1*81 + 3*80) = 320 + 8 + 3 = 33110 p=16 (esadecimale) (0,1,………..9,A,B,C,D,E,F,) 14B16 = (1*162 + 4*161 + 1*160) = 33110 p = p = p = p = DECIMALE 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 .. 32 64 128 BINARIO 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 10000 .. 100000 1000000 10000000 OTTALE 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20 .. 40 100 200 ESADECIMALE 1 2 3 4 5 6 7 8 9 A B C D E F 10 .. 20 40 80 Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti CAMBIAMENTO DI BASE da base 2,8,16 a base 10 (vedi pag. 3) da base 10 a base 2 331:2 = 165 resto 1 165 : 2 = 82 resto 1 82:2 = 41 resto 0 41:2 = 20 resto 1 20:2 = 10 resto 0 10:2 = 5 resto 0 5:2 = 2 resto 1 2:2 = 1 resto 0 1:2 = 0 resto 1 1010010112 Laboratorio di Calcolo Prof.G.Ciapetti

Numeri Interi (in base 2) Da base 2 a base 8 (16) Suddividere il N binario in gruppi di 3(4) cifre e sostituire il corrispondente ottale (esadecimale) 1010010112 5 1 38 000101001011 1 4 B16 Numeri Interi (in base 2) Includono anche i numeri negativi; si aggiunge un bit (o : N positivi; 1 : N negativi) (in base 10 si aggiunge un cifra: +/-) Per semplificare operazioni aritmetiche Rappresentazione in complemento (A1, A2) Complemento ad 1: complementare tutti i bit = 2m –N (01 1  0) Complemento a 2: complemento ad 1 +1 = 2(2m-1)-N Con m cifre base 2: 2m-1 numeri diversi -2(m-1) + 1  2(m-1)-1 Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti DECIMALE 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 BINARIO 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 COMPL.1 1111 1110 1101 1100 1011 1010 1001 1000 0111 0110 0101 0100 0011 0010 0001 0000 COMPL.2 0000 1111 1110 1101 1011 1010 1001 1000 0111 0110 0101 0100 0011 0010 0001 REGOLA PRATICA Complemento a 1: si invertono tutti i B Complemento a 2: si aggiunge 1 al compl. a1 Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti NUMERI FRAZIONARI Numeri reali compresi fra 0 e 1 Si presentano con 0 a-1, a-2, a-3….a-n in cui ai sono le cifre della numerazione in case p Np = a-1 p-1 + a-2 p-2 + ….a-n p-n = -n-1 ai pi 0.10112 = (1*2-1 + 0*2-2 + 1+2-3 + 1*2-4) = 0.697510 NUMERI REALI Rappresentazione in “virgola mobile” con base 1 mantissa n. reale  caratteristica Mantissa: numero frazionario 0-1 + bit segno Caratteristica: numero intero + bit segno 0.476*10-12 mantissa base caratteristica Laboratorio di Calcolo Prof.G.Ciapetti

Somma e differenza di numeri interi (base2) Analoga somma in base 10 1111 1 riporto 1+4+8+64 = 77 1001101 1+4+8+16+32 = 61 0111101 138 10001010 Se si sommano due numeri con k bit il risultato deve avere k+1 bit 138:2 = 69 0 69:2 = 34 1 34:2 = 17 0 17:2 = 8 1 8:2 = 4 0 4:2 = 2 0 2:2 = 1 0 1:2 = 0 1 Differenza: somma N positivo + complemento 2 negativo incluso bit segno e ignorando eventuale riporto su bit segno. 15-10 0 1111 +E 1 0110 - complemento 2 di 10 0 0101 10-15 0 1010 +10 1 0001 - complemento 2 di 15 1 1101 Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti OPERATORI LOGICI (Algebra di Boole) Operandi: vero falso (1) (0) Operazioni logiche: AND (2 operandi) = vero se ambedue operandi veri OR (2 operandi) = vero se almeno 1 operando vero NOT (1 operando) = cambia valore operando AND OR NOT 0 1 0 1 0 0 0 0 0 1 0 1 1 0 1 1 1 1 1 0 CIRCUITO SEMISOMMATORE B1 R (risultato) B2 C(riporto) R = OR (AND(NOT(B1),B2),AND(B1,NOT(B2))) C = AND (B1,B2) ADD Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Circuito semisommatore R = OR ( AND(NOT(B1),B2), AND(B1, NOT(B2))) C = AND (B1, B2) Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Codifica caratteri Codice ASCII (American Standard Code for Information Interchange). 7 bit  128 caratteri : caratteri di comando, alfanumerici, segni. Ogni carattere 1 byte Ottavo bit : bit di parita’ 0 o 1 in modo che il n di 1 nel byte sia pari (errori di trasferimento). Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Codifica immagini Immagine suddivisa in punti (pixel). Per ogni punto n bit che definiscono il colore (o il tono di grigio). Risoluzione misurata in dpi (dot per inch, punti per pollice quadrato). Standard di codifica che possono permettere di ridurre le dimensioni in memoria: BMP TIFF JPEG …… Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Programmazione. Risolvere un problema in modo automatico. Trovare un “ algoritmo” che, dato un certo set di informazioni in input fornisca la soluzione del problema (output). Algoritmo: insieme di istruzioni (regole) che, esguite in un certo ordine, trasformino i dati di input nella soluzione. Linguaggio di programmazione: permette di realizzare l’ algoritmo a partire da un insieme di istruzioni (“statements”). Programma: insieme di algoritmi per risolvere problemi complessi. Esiste una moltitudine di linguaggi con set di istruzioni differenti e con differenti “ livelli” (basso livello : vicino all’ hardware alto livello : vicino al linguaggio naturale) Linguaggio macchina : istruzioni possono essere eseguite direttamente dai circuiti ( CPU ) del calcolatore. Tre fasi : fetch (caricamento), interpretazione, esecuzione. Codice operativo: operazione da fare Istruzione Operando/i : locazione/i di memoria contenente i dati su cui operare Codici operativi (istruzioni): LOAD STORE ADD DIFF MUL DIV JUMP HALT …….. Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Linguaggi di alto livello. istruzioni di assegnazione (mettere in una locazione di memoria risultato di una espressione aritmetica /logica) istruzioni di input/output (ingresso/uscita dati) istruzioni condizionali (ramificare il flusso delle istruzioni a seconda del valore di una variabile logica) istruzioni di ciclo condizionale (ripetere un certo gruppo di istruzioni condizionato a variabile logica) Per eseguire un programma: compiler : traduzione istruzioni in linguaggio macchina (controllo sintassi e logica istruzioni errori di compilazione) linker : collegamento con altri programmi di utilita’ gia’ compilati contenuti in “librerie” debugger : eliminazione di errori al livello di esecuzione Tanti linguaggi a seconda della funzione: BASIC (Beginner All-purpose Instruction Code):applicazioni didattico/scientifiche. Fortran, Pascal: applicazioni scientifiche (numeriche) C : progetto di sistemi operativi e basi dati C++, Java : applicazioni orientate ad oggetti Cobol : applicazioni gestionali Lisp, Prolog: applicazioni di AI Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Grafi di flusso. Progettazione degli algoritmi per via grafica. Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Prodotto di 2 numeri interi Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Programmare in C Programma in C : insieme di funzioni (funzione speciale : main) Funzione : insieme di istruzioni. Alla fine dell’ esecuzione puo’ ritornare un valore. Struttura funzione: tipo nome-funzione (argomenti) /* (se non ritorna nulla tipo = void. Argomenti forniti dal chiamante; se non ci sono : ( ) */ { dichiarazioni (terminano con ; ) istruzioni (terminano con ; ) /* commenti */ return valore ; (valore puo’ mancare) } Dichiarazioni: variabili usate devono essere definite , incluso il tipo di variabile. Istruzioni: di assegnazione, di selezione, di ciclo. -assegnazione: operano su variabili o su costanti e assegnano risultato a nuova variabile. nome_variabile = costante ; nome_variabile = espressione ; -selezione: se una certa condizione e’ vera o falsa esegure differenti istruz. -ciclo: ripetere blocco di istruzioni fino a che condizione non e’ vera/falsa Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Direttive al preprocessore: iniziano con # ; in genere all’ inizio del programma. #define nome valore #include <nome.h> nome.h : header file. Contiene lista di funzioni contenute nell libreria del C. stdio.h : funzioni I/O math.h : funzioni e macro matematiche string.h : funzioni per manipolare stringe di caratteri stdlib.h : funzioni di utilita’ time.h : manipolazione ora/data Programma base: /* Programma Base */ #include <stdio.h> #include <math.h> #define PIGRECO 3.14159 /* -------------------------------------------------*/ int main( ) { /* dichiarazione e assegnazione variabili*/ int a,b,c=180; /* ingresso dati */ ……………; /* istruzioni per effettuare l’ algoritmo */ /* stampa risultato algoritmo */ return; } Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Costanti e variabili. Il programma attribuisce a locazione memoria un nome e un valore. E’ necessario definire il tipo di variabile . Nome: deve iniziare con carattere alfabetico. Lunghezza arbitraria ma definito dai primi 31 caratteri. Caratteri possono essere maiusc/minusc., numerici, simboli (non usare: -, /, $, %, &. Att. alle parole risevate (vedi libro). Tipo: numerico, alfabetico (carattere). numerico: 1234, 123.456, 1.2345e-6 (int, float, ….) carattere: ‘a’ (att. Sempre fra apici singoli) ( char ) stringa (di caratteri): “hello world” (vettore di caratteri; fra doppi apici) Numeri Floating Interi short int long float double Long double float a ; Laboratorio di Calcolo Prof.G.Ciapetti Nota : il prefisso const indica valore che non puo’ essere modificato

Laboratorio di Calcolo Prof.G.Ciapetti Istruzioni di dichiarazione. int nome1, nome2 ; float nome3 = 12.314 ; int x = y = z = 0 ; Istruzioni di assegnazione. nome_variabile = espressione ; espressione : costante num., altra variabile, risultato operazioni a = pigreco ; a = b ; a = b + c/d*e ; Nota : se tipo variabile a destra diverso da sinistra viene effettuata conversione Operatori aritmetici (binari). + , - , * , / , % Note : % solo ad interi (resto divisione). Operatori * , / , % precedenza su +, - Se operandi tipo diverso si converte a precisione superiore. Operatori aritmetici (unari). + , - , & , * , ~ , ! & : restituisce indirizzo operando &a : indirizzo in memoria di a * : valore contenuto nell’ indirizzo *p : valore contenuto in indirizzo p ~ : complemento ad 1 operando ! : negazione logica ( risultato 1 se valore operando 0 e viceversa.) Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Operatori incremento e decremento ++ , - - . Possono essere prefissi o suffissi w = x++ - y w = ++x – y w = x – y x = x + 1 x = x + 1 w = x - y Operatori assegnazione abbreviata Quando operando e’ anche la variabile risultato: x += 3 y /= 3 x = x + 3 y = y / 3 Operatori di relazione < minore di <= minore o uguale > maggiore >= maggiore o uguale == uguale != diverso Confronto di due espressioni; ritorna valore 1 se vera altrimenti 0. Creano delle condizioni logiche. La codizione a > b puo’ dare come risultato vero o falso. Operatori logici ! NOT && AND || OR Operatori di relazione hanno precedenza su operatori logici . Operano solo su variabili logiche o su condizioni realizzate con operatori di relazione. Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Istruzioni condizionali if - else L’ istruzione if verifica se una condizione e’ vera; in questo caso esegue un blocco di istruzioni. Altrimenti else esegue un altro gruppo di istruzioni. if (condizione) { blocco1 di istruzioni ; } else blocco 2 di istruzioni ; Nota: else puo’ mancare; in questo caso se condizione e’ falsa si prosegue dopo il blocco1 di istruzioni. Se c’e’ una sola istruzione le graffe possono essere omesse. Le istruzioni posssono essere annidate: if (x>y) if (y<z) k++; m++; j++; Att: else fa sempre riferimento all’ ultimo if else-if Serve per scelte multiple: if(x>100) istruzioni ; else if (x== 10) else Ultimo else significa: nessuna delle precedenti condizioni Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti si no x > y si no j++ y< z k++ m++ Istruzioni di ciclo Servono a far ripetere un gruppo di istruzioni fino a quando non si verificano certe condizioni. while while (condizione) { istruzioni ; } for Analogo al while ma usato per cicli basati su una variabile che aumenta/diminuisce ad agni iterazione. Stop quando raggiunge un certo valore. for ( espress1; espress2; espress3) { istruzioni ; } espress1 : variabile di ciclo espress2 : se vera continua ciclo espress3 : modo di modifica della variabile di ciclo Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Es. : for( k=1; k<=10; k++ ) { istruzioni; } do/while Analogo al while solo che il controllo viene effettuato alla fine del ciclo. do { istruzioni; } while (condizione) break Per uscire da un ciclo continue Per saltare la corrente iterazione del ciclo Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti /* while */ int degree = 0; while (degree <= 360) { radiant = degree*PIG/180; printf(" %6i %9.6f \n" , degree,radiant) ; degree += 10 ; } /* for */ for (degree = 0 ; degree <= 360 ; degree += 10 ) /* do/while */ int degree = 0 do while (degree < 360 ) Laboratorio di Calcolo Prof.G.Ciapetti

Algoritmo di Erone per calcolo radice quadrata Supponiamo che a0 sia una approssimazione per eccesso di SQRT(x); Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti /* Programma Erone per calcolo sqrt di un numero */ #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { int count = 0; double aold,anew,x,dif,tol=0.001; /* inizio programma Erone; enter x. Se x<0 stop programma */ while (1) { printf("input x (x<0 STOP) \n"); scanf("%lf",&x); if (x <=0) return; aold=x/2; printf("x=%f,aold=%f\n",x,aold); /* loop di approssimazione della sqrt di x. Stop quando delta<tol */ count=0; do { anew=(aold+x/aold)/2; dif=fabs(aold-anew); aold=anew; count+=1; } while (dif>=tol && count<1000); /* stampa risultato e chiedi nuovo numero printf("la radice quadrata di %f e' %f\n",x,anew); printf("n. di iterazioni=%i\n",count); return 0 ; /* ---------------------------------------------------------------------------------------*/ Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Array e puntatori Int s[10], double x[100] ; Definiscono in memoria vettori (array). Vanno utilizzati come: x[ i ] ; ATT: il primo elemento del vettore sara’: x[ 0 ]. Inizzializzazione: double x[100] = {1.,2.,3.,4.,……} ; int s[10] = {0} ; int s[ ] = {1,0,3,42}; for(k=0;k<=9;k++){ s[k] = 99; } Array bidimensionali: float a [ 2 ] [10] ; sinistra indice riga; destra indice di colonna. In memoria come vettore unidimensionale memorizzato per righe. a(1,1) a(1,2) ……a(1,10) a(2,1)………a(2,10) Per gestire array molto usati (in particolare per passare vettori a funzioni): puntatori . int a[10]; int *pa; (pa e’ un intero usato come puntatore) pa = &a[ 0] ; (indirizzo in memoria di a [0] ) pa = a ; (equivalente alla precedente; valore di var. tipo vettore e’ l’indirizzo del suo primo elemento. Quindi &a[ i ] e (a+i) equival. x = *pa; (mette in x il valore di a [0] ) x = *(pa+3); (mette in x il valore di a [3] ) x = *(a+3); ATT. pa e’ una variabile a non lo e’; quindi pa = a pa++ corrette a = pa a++ non corrette Nelle chiamate a funzioni si passa l’ indirizzo della locazione 0 del vettore. Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Le funzioni Algoritmo complesso puo’ essere suddiviso in sottoalgoritmi (funzioni) che vengono chiamati in una certa sequenza logica da uno “ steering”, cioe’ da una funzione principale (“ main”). Una funzione ritornera’ un valore al programma chiamante e avra’ in ingresso uno o piu’ valori forniti dal chiamante. Una funzione deve essere dichiarata prima del main (prototipo della funzione)e successivamente deve essere definita. Dichiarazione: tipo_ritorno nome_funz ( tipo_par1, tipo_par2,………) float funz (int, double,double, ….); NB. #include <stdio.h> inserisce una lista di prototipi delle funz. di libreria Definizione: tipo_ritorno nome_funz ( tipo_par1 par1, tipo_par2 par2,………) { definizioni, istruzioni} return espressione: Es. double area (float, float); int main() double aa,h,b; aa = area (b, h); ……. double area ( float base, float altezza){ double s; s = 0.5*(base*altezza); return s ; } Il passaggio dei parametri avviene per “valore” . Se si vuole passare un vettore o se si vuole modificare le variabili bisogna passare per “indirizzo”. Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Es. Funzione scambia void scambia (float,float); float x,y; x=16.; y=8.; scambia(x,y); …… void scambia(float a, float b){ float temp; temp = a; a = b; b = temp; } return; Es. Funzione scambia void scambia ( float *, float *) float x,y; x=16.; y=8.; scambia(&x, &y); …… void scambia(float *pa,float *pb){ float temp; temp = *pa; *pa = *pb; *pb = temp; return; } Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Funzioni matematiche di libreria Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Fit retta con metodo minimi quadrati Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Input/Output dei dati printf Visualizza su schermo valori e stringhe. printf (“ strnga di controllo”,valore1,valore2,…..); Stringa di controllo contiene testo e marcatori di controllo che definiscono il formato di uscita delle variabili. printf(“var1= %f , var2=%i ,…” , var1, var2, ….); I marcatori di conversione possono essere preceduti da specifiche di formato: %5i %7.4f %.3e Il La stringa di controllo termina sempre con \ seguito da carattere (sequenza di escape) che controlla il comportamento della stampante. Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti scanf Serve per l’ immissione dei dati tramite la tastiera. scanf (“%f %lf %i..”, &a, &b , &I , …….); La funzione ritorna i valori letti “ per indirizzo “. La stringa di controllo contiene le specifiche di formato per la variabili da immettere. La scanf termina quando ha esaurito le specifiche di formato della stringa di controllo o quando c’ e’ inconsistenza fra specifica e valore digitato. Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Stringhe Un array di tipo char permette di gestire un insieme di caratteri: char stringa[80]; printf(“Inserisci una frase”); scanf(“%s”,stringa); printf(“La frase inserita e’: %s \n”); La stringa viene memorizzata come sequenza di caratteri terminata dal carattere nul ( \0 ); se si vogliono contare i caratteri contenuti nella stringa: int i = 0; while (stringa[i] != ‘\0’) i++ ; printf( “Lunghezza frase %d caratteri \n”, i); Se voglio aggiungere una seconda frase dentro stringa scanf( “%s”,stringa2 ); for( i=0 ; stringa[i] != ‘\0’; i++) ; for( j=0 ; stringa2[j] != ‘\0’ ; j++) stringa[i] = stringa2[j]; i++ ; stringa[i] = ‘\0’ ; Un altro modo per leggere una stringa e’ uso di getchar() : for ( i=0 ; (stringa[i]=getchar() ) != ‘\n’; i++) Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Funzioni di libreria( string.h ) per manipolazione stringhe : strcopy ( stringa1 , stringa2) ; strncopy (stringa1, stringa2, n); copia n caratteri di stringa2 su stringa1 strcat (stringa1 , stringa2) ; concatena stringa2 a stringa1 n = strcmp (stringa1 , stringa2) ; n=0 se uguali, +-1 se stringa1 >< stringa2 n = strlen (stringa); lunghezza della stringa (senza \0 ) Es. int strlen (char s[] ) int i=0 ; while ( i < MAX && s[i] != ‘\0’ ) i++ ; return (i) ; _________________________________________ void converti (char s[] ) int i = 0 ; if ( s[i] >= 97 && s[i] <= 122) s[i] = s[i] - 32 ; return(0); Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti I / O da file Per scrivere/leggere dati da file (non da standard input/ output): definire un puntatore speciale (che punta ad una struttura contenente informazioni sul file). associare al puntatore uno specifico file e definirne le modalita’ di apertura. Chiudere il file alla fine del suo utilizzo. FILE *fp1 ; FILE *fp2 ; fp1 = fopen( “file1.dat”, “mode”) ; fp2 = fopen( “file2.dat”, “mode”) ; ……………….. fclose (fp1); fclose (fp2); mode: “r” solo lettura; se non esiste fopen ritorna NULL “w” solo scrittura; se non esiste viene creato; il contenuto precedente viene perso “r+” lettura/scrittura; se non esiste ritorna NULL “w+” lettura/scrittura; se non esiste viene creato “a” solo scrittura; in append mode; se non esiste viene creato “a+”lettura/append; se non esiste viene creato Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti I / O formattato Leggere/scrivere su file con formato definito da utente: n = fprintf (fp, “specifica formato”,val1, val2, ……); m = fscanf (fp, “specifica formato”, &val1, &val2, …..); n rappresenta il n di caratteri scritti o n negativo in caso dierrore m numero di elementi letti o EOF in caso di fine del file di input Es. void main() [ FILE *fin; FILE * fout; float x1, y1 ; int n; fin = fopen( “filein.dat”, ”r” ); fout = fopen( “fileout.dat”, “w”); while ( ( fscanf(fin, “%f,%f”,&x1, &y1 ) == 2) n = fprintf (fout, “%f, %f \n”, x1, y1) ; fclose(fin); fclose(fout); return(); ] Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti SORT Selection sort Algoritmo di ordinamento: per i da 0 a n-1 trovare l’ elemento minimo del sotto array ( a i ,….,a n-1 ) e metterlo in posizione i Complessita’ dell’ algoritmo: (n-1) + (n-2) + …………..+ 2 + 1 = n*(n-1)/2 n2 0 1 2 3 4 5 i j 18 19 14 11 15 12 0 1 18 19 14 11 15 12 2 14 19 18 11 15 12 3 11 19 18 14 15 12 4 11 19 18 14 15 12 5 11 19 18 14 15 12 1 2 11 18 19 14 15 12 3 11 14 19 18 15 12 4 11 14 19 18 15 12 5 11 12 19 18 15 14 2 3 11 12 18 19 15 14 4 11 12 15 19 18 14 5 11 12 14 19 18 15 3 4 11 12 14 15 18 19 5 11 12 14 15 18 19 4 5 11 12 14 15 18 19 Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti #include <stdio.h> #include <stdlib.h> #define MAX 100 int leggi_array(int *); void stampa_array(int *,int); void selection_sort(int *,int); void scambia(int *,int *); void main() [ int a[MAX], n; n=leggi_array(a) ; selection_sort(a) ; stampa_array(a,n) ; return() ; ] int leggi_array(int x[]) [ int i,n ; printf("Dimensioni array: ") ; scanf("%d",&n) ; for ( i=0; i<n; i++) scanf("%d",&x[i]) ; return(n) ; void stampa_array(int x[],int n) [ int i ; printf("%d",x[i]) ; printf("\n") ; void scambia(int *p,int *q) [ int r ; r=*p ; *p = *q ; *q = r ; return() ; ] void selection_sort(int x[], int n) [ int i, j, min ; for ( i=0; i<n; i++) [ min = i ; for ( j=i+1; j<n; j++) [ if(x[j] < x[min] ) min = j ; scambia(&x[i], &x[min] ) ; Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti SORT Insertion sort Algoritmo di ordinamento: per i da 1 a n-1 poni x = ai inserisci x nella posizione corretta nel sotto-array ordinato (a0,…,a i-1) spostando in avanti gli elementi ak > x (0<= k < i) Complessita’ dell’ algoritmo: 1 + 2 + ….+ (n-1) = n*(n-1)/2 n2 0 1 2 3 4 5 i 18 19 14 11 15 12 1 18 19 2 14 18 19 3 11 14 18 19 4 11 14 15 18 19 5 11 12 14 15 18 19 Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti void insertion_sort(int x[], int n) [ int i, j, temp ; for ( i=1; i<n; i++) [ temp = x[i] ; j = i-1 while (j>=0 && x[j]>temp) [ x[ j+1] = x[ j ] ; j-- ; ] x[j+1] = temp ; return() ; Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti SORT Bubble sort Algoritmo di ordinamento: scorrere piu’ volte l’ array spostando verso la fine gli elementi piu’ “pesanti” e verso l’ inizio quelli piu’ “leggeri” flag = 1 ; k = n-1 fino a che : flag = 1 e k > 0 ripeti: flag = 0 per i = 0,…,k-1 ripeti: se a i > a i+1 scambia e poni flag = 1 k = k - 1 8 7 9 3 1 4 7 8 8 9 3 9 1 9 4 9 7 8 3 1 4 9 3 8 1 8 4 8 7 3 1 4 8 9 3 7 1 7 4 7 3 1 4 7 8 9 1 3 3 4 1 3 4 7 8 9 Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti void bubble_sort(int x[], int n) [ int flag, k, i ; flag = 1 ; k = n-1 ; while( flag ==1 && k > 0 ) [ flag = 0 ; for (i=0; i < k; i++)[ if( x[i] > x[i+1] ) [ scambia(&x[i], &x[i+1]) ; ] k-- ; return() ; Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti SORT Quick sort Algoritmo di ordinamento: si sceglie un elemento p detto pivot e si mettono tutti gli elementi <= p in un sotto array e gli elementi > p in un secondo sotto array. Poi si ripete lo stesso algoritmo sui due sotto array fino ad ottenere n sotto array costituiti da un solo elemento. Riaggregando i sotto array si ottiene un array ordinato. Complessita’ dell’ algoritmo (se l’ albero e’ bilanciato): n* log 2 n Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti void quicksort(int v[], int p, int r) [ int q ; if(p<r) [ q = partition (v, p, r) ; qicksort(v, p, q); qicksort(v, q+1, r); ] return() ; int partition(int v[], int p, int r) [ int x, i, j ; x = v[p] ; i = p ; j = r ; do [ while (v[j]>x) j-- ; while (v[i]<x) i++ ; if(i<j) scambia(&v[i], &v[j]) ; ] while (i<j) ; return(j) ; Laboratorio di Calcolo Prof.G.Ciapetti

Integrazione numerica Se non esiste alcun metodo analitico per integrare la funzione f(x) o se la funzione e’ nota per punti metodo numerico di integrazione (approssimato). Integrazione numerica: approssimazione, in “piccoli intervalli”, della funzione integranda mediante opportuni polinomi. Detto pn(x) il polinomio di Lagrange di grado n interpolante f(x) tra i punti x0,x1,….xn (x0-xn :limiti di integrazione): Formula del rettangolo Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Formula del trapezio Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Formula di Simpson Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti 1-Formula dei rettangoli con xk = punto centrale di ogni intervallo 1-Formula dei trapezi Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti 1-Formula di Simpson con xi = punto centrale di ogni intervallo Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Strutture In C si possono definire delle “strutture” ; struttura= collezione di variabili elementari o di altre strutture definite precedentemente. struct tipo_struttura { tipo1 nome_elemento1; tipo2 nome_elemento2; ………………………..; }; Come si usa: tipo_struttura nome1,nome2[n]; …………………. nome_struttura.nome_elemento= ……. (cioe’ si utilizza il “punto”per accedere ad un elemento della struttura) Una struttura puo’ essere trasmessa ad una funzione. Una struttura puo’ essere l’ argomento di ritorno di una funzione ed e’ possibile definire il puntatore ad una struttura. Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Es. -Nella grafica oggetto elementare e’ il punto caratterizzato da x,y struct point { float x ; float y ; }; -Nella dichiarazione delle variabili: struct point pt1, pt2,ptv[20]; pt1.x = 10.4; pt1.y = 1.3; pt2.x = 0. ; pt2.y = 0. ; ptv[2].x = 27. ; ptv[2].y =33.; -Le strutture possono essere nidificate: struct rect { struct p1; struct p2; struct rect rettangolo; rettangolo.p1.x = 8.7 ; (coordinata x del primo punto della struttura rettangolo) Le strutture possono essere l’ argomento di ritorno di una funzione: struct point makepoint(float x, float y) { struct point punto; punto.x = x ; punto.y = y ; return punto; } -I puntatori alle strutture sono analoghi ai puntatori alle variabili ordinarie: struct point *pp; (pp e’ il puntatore ad una struttura di tipo point) -Se pp e’ un puntatore ad una struttura di tipo point, allora: ppx definisce il suo elemento x; printf(“le coordinate sono: %f %f \n” , ppx , ppy ); Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Esempi di programmi Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti /* I/O handling */ #include <stdio.h> #include <stdlib.h> #include <math.h> #define NMAX 100 int datain(void); void dataout(int); FILE *infl; FILE *outfl; int np; float x[NMAX],y[NMAX]; int main() { int n,nout=3,; char namef[20]; printf(" enter input file name: "); scanf("%s",namef); infl=fopen(namef,"r"); if(infl == NULL) { printf(" error in infl\n"); return(0); } outfl=fopen("fileout.dat","w"); np=datain(); dataout(nout); fclose(infl); fclose(outfl); return 0; void dataout(int nc){ int i; for (i=0;i<nc;i++) fprintf(outfl,"== %f == %f\n",x[i],y[i]); return ; int datain(){ i=0; while(fscanf(infl,"%f %f",&x[i],&y[i])!=EOF) { printf("fscf=%d\n",fscanf(infl,"%f %f",&x[i],&y[i])); i++; return i; Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Generatore gaussiano Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Istogrammi di frequenza Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Minimi quadrati Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti

Laboratorio di Calcolo Prof.G.Ciapetti Compressione Laboratorio di Calcolo Prof.G.Ciapetti