Lezione 1

Introduzione

1. ripasso dei comandi fondamentali del sistema operativo;
2. include files;
3. input/output da terminale;
4. cicli for;
5. librerie matematiche;
6. cicli while.

L'esercizio

Qui di seguito ci sono dei suggerimenti su come impostare la struttura del programma e le differenze tra il FORTRAN che avete studiato nel Laboratorio di Calcolo 1 ed il C.

main

int main() {

/* All'interno della funzione deve essere inserito il codice appropriato */

return 0; /* Bisogna fornire un valore di ritorno */
}

La compilazione

1. il preprocessore,
2. il compilatore vero e proprio,
3. il linker.

Il preprocessore di fatto effettua delle sostituzioni letterali all'interno del programma, definite da alcune direttive, riconoscibili perché iniziano con un #.
La direttiva #include inserisce nel file in corso di compilazione il testo di un altro file, di solito un file che contiene le dichiarazioni delle funzioni da usare (come stdio.h per esempio). Invece una direttiva
#define PIGRECO 3.1415196
sostituisce tutte le sequenze di caratteri P,I,G,R,E,C,O incontrate nel testo con la sequenza di caratteri 3,.,1,4,1,5,1,9,6, e risulta un modo pratico di inserire delle costanti.
Il #define può anche venire usato per definire delle sostituzioni contenti delle parti variabili, ad esempio
#define FUNC(A) sin(A)/A
sostituisce espressioni come FUNC(xyx) con sin(xyz)/xyz.  Questa è una direttiva molto utile, ma anche subdola: FUNC(x+y) dà il risultato che vi aspettate? Come fare per avere il risultato corretto?

Il compilatore trasforma il codice che abbiamo scritto in una sequenza di istruzioni comprensibili per la macchina (file oggetto). A volte può essere utile terminare la compilazione dopo questa fase, utilizzando l'opzione -c del compilatore:
gcc -c -o nomefileoggetto nomefilesorgente
Se il compilatore non riesce a capire che istruzioni generare perché il file sorgente non rispetta le regole del C, esso fornisce un errore di sintassi e non crea il file oggetto. Il testo degli errori di sintassi è molto esplicativo. In più il compilatore dice sempre a quale riga dell file sorgente è presente un errore. Tranne nel caso in cui ci si sia dimenticati un ; al termine di una riga, nel qual caso l'informazione può anche risultare piuttosto criptica.

Il linker si preoccupa di aggiungere l'informazione di tutte le funzioni utilizzate dal file oggetto e non implementate esplicitamente al suo interno. Il linker viene chiamato se si invoca il gcc senza l'opzione -c:
gcc -o nomeeseguibile [lista file sorgente] [lista file oggetto] -lfilelibreria1 -lfilelibreria2...

Il comando gcc prevede molte opzioni, che si possono mettere tutte prima del -o. Una particolarmente consigliata è l'opzione -Wall che scrive un sacco di messaggi su tutte le cose che, sebbene perfettamente legali in C, suonano un po' strane al compilatore. Questi messaggi chiamati warnings sono molto utili per mettere in evidenza al momento della compilazione molti errori di logica.
 

Funzioni di input/output

Librerie matematiche

1. a livello di scrittura del codice, ricordarsi di includere il file header contenente la dichiarazione delle librerie matematiche, di modo che il compilatore sappia di che cosa stiamo parlando. Questo si fa, inserendo all'inizio del file la direttiva:
#include <math.h>
che viene interpretata dal preprocessore, che inserisce nel programma il contenuto del file math.h, che si trova tra i file di sistema;
2. al momento della compilazione, bisogna dire al linker che le funzioni matematiche si trovano precompilate in un opportuno file di libreria. Poiché le librerie matematiche sono una delle componenti maggiormente usate del C, l'opzione da fornire al compilatore è molto semplice: basta aggiungere -lm all'istruzione di compilazione.

Schema del programma

#include <stdio.h> /* per avere le definizioni di scanf e printf */
#include <math.h>  /* per avere le definizioni delle funzioni matematiche */

int main() {
  /* inserire le dichiarazioni delle variabili da usare */

  /* leggere da terminale x0, xN e N */

  h=(xN-x0);
  integrale = 0.5*h*(f(x0)+f(xN));
  for ( i=1; i<N; i++ ) {
    x = /* calcolare la coordinata x del punto i-esimo */
    integrale += h*f(x);
  }

  /* stampa dell'integrale */

  return 0; /* bisogna fornire un valore di ritorno */
}
  

Integrazione alla Simpson

Integrazione a precisione prefissata

while ( fabs( (newint-oldint)/oldint ) > EPS ) {
  oldint=newint;
  N*=2;
  h/=2;
  for ( /* costruite il for in modo che si cicli solo sui nuovi punti */ ) {
    x=...
    sum+=f(x);
  }
  newint = h*sum;
}

Relazione