DidaWiki

Questa pagina è in sola lettura. Puoi visualizzare il sorgente, ma non puoi modificarlo. Contatta l'amministratore se pensi che ci sia un errore.
====== Esercitazione 2: libreria matematica ed array ======

Per la soluzione di alcuni di questi esercizi serve utilizzare la libreria matematica 

[[http://www.tutorialspoint.com/c_standard_library/math_h.htm|La libreria matematica ''math.h'']] 
Includendo all'inizio l'header file
<code>
#include <math.h>
</code>
e compilando con
<code>
gcc -Wall -pedantic file.c -o nome_eseguibile -lm
</code>

===== Esercizio 1: Approssimazione dell'integrale ======
Consideriamo la funzione
<code>
f(x) = 5x^3 + 4x^2 + 7x + 5:
</code>
Si vuole calcolare l'integrale di ''f(x)'' su un intervallo ''[a, b]'' dividendo l'intervallo
 in //n// intervalli di lunghezza //(b-a)/n// e calcolando l'integrale come somma dell'area di //n// trapezi, come spiegato in {{:fisica:informatica:201415:esercitazioni:eserciziomatematica1.pdf|questo documento}}.

Il programma chiede all'utente due reali positivi ''a'' e ''b'' e un intero positivo
''nmax'' numero di intervalli in cui suddividere l'intervallo ''[a, b]''. Il programma deve calcolare le approssimazioni dell' integrale di ''f(x)'' ottenute con
il procedimento dei trapezio per ''n = 2, 3, 4,...nmax''. Stampando su standard output i valori ottenuti e la differenza con l'integrale esatto calcolato analiticamente.

===== Esercizio 2: Somma e prodotto di matrici =====
Scrivere un programma C costituito da un ''main()'' che legge da standard input due matrici quadrate di reali, le somma, calcola il prodotto e stampa i risultati sullo standard output.

===== Esercizio 3: Calcolo della radice quadrata ======
Dato un numero reale positivo //a// si consideri la sequenza dei numeri reali //x// definita da 
<code>
x[0] = 1
x[i+1] = 1/2*(x[i] + a/x[i])
</code>
si puo' dimostrare che ''x[i]'' tende alla radice quadrata di //a// per //i// che tende all'infinito.

Scrivere un programma che legga il valore di //a// da standard input e calcoli la radice quadrata di //a// utilizzando la sequenza. In particolare, si calcoli la sequenza fino a che ''x[i]'' non diventa uguale a ''x[i+1]'', il valore ottenuto e' l'approssimazione cercata per la radice quadrata di //a//.

Ad ogni ciclo, far stampare su standard output il numero dell'iterazione ''i'', il valore di ''x[i]'' ed il valore di ''a-x[i]*x[i]'' per controllare la convergenza.

===== Esercizio 4: MSS, Maximum Segment Sum =====

Dato un array di interi positivi e negativi, il segmento di somma massima e' la porzione contigua dell'array in cui la somma deigli elementi ha valore piu' alto.
Ad esempio l'array 
<code c>
[2,-4,2,-1,6-3] 
</code>
ha come SSM il segmento [2,-1,6] di valore 7. Si chiede di realizzare in programma C che legge dallo standard input N interi, li inserisce in un array lungo N, calcola il segmento di somma massima e lo stampa sullo standard output.

===== Esercizio 5: Mandelbrot (Avanzato) ======
L'[[http://it.wikipedia.org/wiki/Insieme_di_Mandelbrot|insieme di Mandelbrot]]e' un insieme frattale definito come l'insieme dei numeri complessi //c// per i quali la successione definita da:
<code>
z(0) = 0
z(n+1) = z(n)^2 + c
</code>
e' limitata, cioe' ''|z( n )|< 2'' per ogni ''n >=0''. 
Infatti al variare di ''c'', la sequenza puo' tendere
all’infinito o rimanere confinata in un disco di raggio 2 del piano complesso centrato
nell’origine.

L’algoritmo piu' semplice per visualizzare (una approssimazione de) l’insieme di Mandelbrot ´e l’//Escape Time Algorithm//. In questo algoritmo, dati ''A'' (l’area del piano complesso
da visualizzare) ed ''r'' (una precisione fissata) si effettuano i seguenti passi:
  - Si suddivide A in una griglia di punti a distanza uniforme (pixel) 
  - per ogni pixel (x, y) 
      - si calcolano r valori della sequenza con c=(x,y)
      - se dopo r iterazioni ''|z( r )|<= 2'' si considera c appartenente all'insieme e si assegna a c il colore NERO
  - altrimenti si assegna a c il colore j, che e' il minimo indice per cui ''| z(j) |>=2''
Di seguito viene mostrato un possibile pseudocodice per il calcolo del singolo pixel:
<code>
Per ogni pixel:
{
x = x0 = x co-ordinate of pixel
y = y0 = y co-ordinate of pixel
x2 = x*x
y2 = y*y
iteration = 0
maxiteration = 1000
while ( x2 + y2 < (2*2)
AND iteration < maxiteration )
{
y = 2*x*y + y0
x = x2 - y2 + x0
x2 = x*x
y2 = y*y
iteration = iteration + 1
}
if ( iteration == maxiteration )
colour = black
else
colour = iteration
}
</code>
Nel codice, le coordinate del pixel (x, y) sono usate come valore iniziale per il calcolo. Il risultato di ogni iterazione e' usato come punto d’inizio della successiva. Ad ogni
iterazione si controlla se siamo usciti dal cerchio di raggio 2 (e quindi se (x,y) non
appartiene a M), se questo e' vero si assegna il numero di iterazioni come colore a (x, y) e
si considera il prossimo punto, altrimenti si calcola la nuova iterazione. Quindi, rispetto
alla definizione iniziale:

<code>
z = x + iy 
c = x0 + iy0 
z^2 = x^2 + i2xy − y^2. 
</code>
Inoltre, ''r'' e' ''maxiteration''(1000).

Scrivere un programma C che calcola l'insieme di Mandelbrot per il rettangolo di estremi (-2,1) (1,-1) e stampando sullo standard output i colori dei pixel suppenendo di dividere il rettangolo in 100x100 pixel.