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

La libreria matematica ''math.h'' Includendo all'inizio l'header file

#include <math.h>

e compilando con

gcc -Wall -pedantic file.c -o nome_eseguibile -lm

Consideriamo la funzione

f(x) = 5x^3 + 4x^2 + 7x + 5:

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 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.

Dato un numero reale positivo a si consideri la sequenza dei numeri reali x definita da

x[0] = 1
x[i+1] = 1/2*(x[i] + a/x[i])

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.

L'insieme di Mandelbrote' un insieme frattale definito come l'insieme dei numeri complessi c per i quali la successione definita da:

z(0) = 0
z(n+1) = z(n)^2 + c

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:

1. Si suddivide A in una griglia di punti a distanza uniforme (pixel)
2. per ogni pixel (x, y)
   1. si calcolano r valori della sequenza con c=(x,y)
   2. se dopo r iterazioni |z( r )|⇐ 2 si considera c appartenente all'insieme e si assegna a c il colore NERO
3. 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:

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
}

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:

z = x + iy 
c = x0 + iy0 
z^2 = x^2 + i2xy − y^2. 

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 100×100 pixel.