\newpage

\section{Inleiding}
Een computertaal kennen, programmeren dus, is een vaardigheid die voor de meeste natuurkundigen
een noodzaak is.  Naaast numeriek natuurkundige problemen doorrekenen worden ook instrumenten aangestuurd 
met behulp van computers. Deze cursus in de programmeertaal C is een voorbereiding op beide.
De instrumentbesturing is een onderdeel van het  praktikum dat volgt op deze cursus en 'Numerieke Natuurkunde' is een vervolgcursus
in het tweede jaar.  Als we nog verder denken, komen we in het 3de jaar terecht, of zelf de masteropleiding, voor sommige
studierichtingen zal je werken met grote software-pakketten in andere programmeertalen, zoals C++, Java of Python. 
Toch zul je veel aan de je C kennis hebben omdat dit de basis van al deze programmeertalen is. Tot slot moet opgemerkt worden
dat programmeren een goede training is voor je hersenen om eens abstract te denken en leer je uiteindelijk om problemen te vertalen
naar wiskundige algoritmes. 

Voor deze cursus werken we in de Labwindows omgeving, maar we houden het zo algemeen mogelijk. De vervolgcursus
 instrumentbesturing zal dieper ingaan op het besturen van interfaces waarvoor de Labwindow omgeving uitermate
geschikt is.

\subsection{Materiaal}
Naast deze syllabus is er studiemateriaal en voorbeelden te vinden
op de website: 


http://www.nikhef.nl/\~{ }h73/ccursus.html
\begin{itemize}
\item Als U een uitgebreider {\sl boek} over C zoekt, is het volgende
  geschikt : \\
  Al Kelley en Ira Pohl : "A Book on C : Programming in C"
\item Technischer, maar zeker de moeite waard: \emph{The C Programming
    language} door B.~Kernighan en D.~Ritchie.
\item Er is veel informatie over C beschikbaar op het web. Als je zoekt naar een
bepaald onderwerp, bijvoorbeeld 'sinus functie', kun je in een zoekmachine even
zoeken naar 'ANSI C sinus' en je krijgt meteen talloze voorbeelden. Overigens staat ANSI voor
'American National Standards Institute'; dit is de standaard waaran we ons zoveel mogelijk aan
zullen houden. 
\end{itemize}


\subsection{Computers en accounts}
We werken voor deze cursus op de computers van de UvA  waarvoor jullie allemaal al een account hebben. Werk zo mogelijk iedere sessie op dezelfde computer en meldt als er iets niet werkt. Start het programma Labwindows dat onder het startmenu beschikbaar is, 
 waarschijnlijk onder de firma-naam 'National Instruments'.

\subsection{Werkwijze}
De werkwijze bij deze cursus, waarbij U {\sl zelf} programma's schrijft 
en laat uitvoeren, bevat de volgende {\sl basiselementen} :
\begin{itemize}
\item U moet de door U gemaakte programma-{\sl code} 'intikken' met 
      behulp van een {\sl tekst-editor}. De {\sl file} die aldus 
      ontstaat bevat Uw {\bf source-code}.
\item Deze code moet worden {\sl vertaald} door een {\bf C-compiler}.
      Deze compiler controleert ook of Uw programma aan de {\sl spelregels} 
      van de {\bf taal C} voldoet. De {\sl file} die aldus ontstaat 
      bevat de {\bf object-code}.  De object code wordt
      niet altijd als aparte file opgeslagen, maar is dan tijdelijk aanwezig in het
      computer geheugen.       
\item Vervolgens moet de {\sl object-code} worden {\sl omgezet} in 
      een vorm die {\sl in werking} kan worden gesteld ({\sl executeerbaar} 
      is). Deze file heet de {\bf executable}.
\item Ten slotte moet de {\sl executable} in werking worden gezet. 
      De resultaten 
      van Uw programma zullen moeten worden {\sl geprint}, of {\sl geplot} als 
      het om {\sl grafische} resultaten gaat.
\end{itemize}

Wat betekent dit nu allemaal praktisch? In de Labwindows omgeving zijn al deze stappen onder de verschillende menu's beschikbaar en
daar gaan we in de volgende sectie gebruik van maken.

\subsubsection{Specifiek voor Labwindows}
Labwindows is ontworpen om grote programma's te maken die weer kunnen bestaan uit verschillende projecten en dat brengt
enige overhead met zich mee. Daar willen we niet te lang bij stil staan, want we willen gewoon beginnen.

\paragraph{Begin met een bestaande workspace voor deze cursus}
De makkelijkste methode om te beginnen is om een zogenaamde workspace te kopieren die voor deze cursus is klaargezet
in de directory 'labwindows' via de link onder: 


http://www.nikhef.nl/\~{ }h73/ccursus.html

vervolgens de directory 'labwindows' kopieren vanuit je browser (aanklikken en save-as naar je eigen lokale disc). Als dat niet lukt, kun je het per file (of alle files selectie) proberen. Dus eerst een directory maken op je lokale disc en vervolgens kopieren uit 'labwindows' (de directories hoef je niet te kopieeren).

Open de workspace (door via je PC op 'voorbeeld.cws' te klikken) of door Labwindows te openen en dan onder 'File-$>$Open' de 'voorbeeld.cws' workspace te openen. In de werkruimte staan
verschillende projecten waar een eigen C file aanhangt. Als je een bepaald voorbeeld in een project wilt bekijken kun je op de file klikken. Als je op het icoon van het project met de rechtermuis klikt krijg je het menu voor het project. Voor straks is het belangrijk om het eerste project 'hello' actief te maken, dat kan o.a. via 'File-$>$Set Active Project'.


\paragraph{Helemaal vanuit het niets beginnen}
\label{project}
 Dat doe je het snelst door onder het menu 'File-$>$New' een nieuwe 'workspace' te maken. Er wordt meteen ook een project in de workspace gemaakt. Je kunt ook zelf nog  een een nieuw project beginnen dat ook
onder het menu 'File-$>$New' te vinden is. Save nu eerst de workspace en je nieuwe project(en); dat is belangrijk, want als alles 'Untitled' heet  zie je door de bomen het bos niet meer.
 Je kunt ook het icoon van je project aanklikken en met
de rechterklik meer opties krijgen, bijvoorbeeld om het project te Saven of om de title van het project kunt veranderen (die hoeft weer niet hetzelfde te zijn als de file-naam, dat is een beetje verwarrend).

Vervolgens wil je een file openen waarin je C-code getyped kan worden. Je raad het al: wederom onder 'File-$>$New'. Save de file onder een goede naam. Voer al deze stappen uit. De C file hoort
onder een project te te staan. Als dat niet vanzelf is gebeurd, was het project niet actief. Als je meerdere projecten in je workspace hebt gedefinieerd moet je altijd opletten welk project actief is. Dat kun je doen onder 'File-$>$Set Active Project'. Vervolgens kun je aan het project de C-file toevoegen door met rechtermuis op het project te klikken en dan 'Add File'. Een project kan meerdere files bevatten, maar dat hoeft niet.

Een volledige introductie Labwindows kun je vinden op


 http://www.nikhef.nl/\~{ }h73/docu\_labwindows.pdf

maar in deze cursus gaat het ons met name om het programmeren in C.



\subsubsection{In den beginne: ``Mijn eerste C-programma''}
In deze sectie ga je je eigen een programma maken, waarna je dit programma kunt compileren  met menu 'Compile' en kunt uitvoeren met 'Run'. Zoek
deze menu's alvast maar even. Verder gaan we ervan uit dat je weet hoe je files kunt opslaan en weer openen op de gebruikelijke manier zoals o.a. in de microsoft
 producten Word en Powerpoint. Als je dat nog niet kunt, moet je dat maar even aan je buurman vragen en uiteraard zorgen dat je Word/Powerpoint zo snel mogelijk leert.


Een minimaal C programma ziet er als volgt uit:
\begin{verbatim}
// Begin met een goede beschrijving van je programma. 
// Noteer hier ook je naam en de datum.
int main (void)
{
// Geef commentaar bij ieder belangrijk gedeelte van je programma!

    return 0 ;

}
\end{verbatim}
\begin{itemize}
\item Dit programma {\sl doet niks}, {\sl maar} :
\item De C-compiler zal er {\sl niet} tegen protesteren, omdat de {\sl vorm} 
      correct is :
\begin{itemize}
\item Er komt een {\sl hoofd}-programma in voor, via
\begin{verbatim}
int main (void)
\end{verbatim}
\item Het hoofdprogramma wordt netjes afgesloten, via de terugkeer-opdracht
\begin{verbatim}
    return 0 ;
\end{verbatim}
      Merk op dat deze opdracht wordt afgesloten met een {\sl punt-komma}
\item De (afsluitende) {\sl code} is {\sl netjes ingebed} tussen 
\begin{verbatim}
{
}
\end{verbatim}
\end{itemize}
\item Elk programma moet dus {\sl in elk geval} bovenstaande vorm hebben.
\end{itemize}



Een eerste poging voor een klein C-programma, maar nog steeds minimaal, zie je in de file 'hello.c', klik daar maar op
of type het onderstaande over:
\begin{verbatim}
 #include <ansi_c.h>   // maakt de standaard bekend in labwindows.
//  Buiten labwindows zie je vaak #include ``stdio.h''.
// Mijn eerste programma in Labwindows....
int main(void) {
 char s;  // declareer een karakter s voor dummy input met getchar
// 
// hier kun je van alles programmeren......
//
//--
// bijvoorbeel een printf
//--
printf("hello world \n");

// truukje om het output venster even open te houden
printf("type enter to continue");
s=getchar();
// geef een 0 terug aan het operating systeem.
return 0;
}
\end{verbatim}

Vergeet niet het 'hello' project te activeren 'File-$>$Set Active Project'. Vervolgens kun je de C code compileren met
'Build-$>$Compile'. Als er fouten worden gevonden kijk je in het schermpje onderin naar de lijnregel en los je fouten op (begin altijd met de eerste en probeer het opniew, want soms
zijn vele fouten het gevolg van een eerste simpele fout). Hierna kun je de code excuteren onder 'Run-$>$Debug' (of direct via de groene pijl onder menu's). Als je echt wil leren 
debuggen kun je de labwindows manual gebruiken voor meer informatie; in deze cursus slaan we dit over. Verander het programma zodat je eigen naam wordt uitgeprint en executeer opnieuw.
Je bent nu klaar voor meer!


\subsection{Iets meer dan het minimum}
Een voorbeeld van een programma dat {\sl wel iets doet} is :
\begin{verbatim}
int main (void)
{
    int iks ;   // variable voor de berekening.

    iks = 1 ;
    iks = iks + 2 ;

    return 0 ;

}
\end{verbatim}
Dit programma :
\begin{itemize}
\item Werkt met een {\sl variabele} met de {\sl naam} iks, 
      {\sl gedeclareerd} in 
\begin{verbatim}
    int iks ;
\end{verbatim}
\item Kent eerst de waarde 1 toe aan de variabele iks, in 
\begin{verbatim}
    iks = 1 ;
\end{verbatim}
\item Telt vervolgens 2 op bij de waarde van iks, en \\
      Slaat het resultaat op in de variabele iks, in
\begin{verbatim}
    iks = iks + 2 ;
\end{verbatim}
\item Merk op dat (bijna) alle regels worden afgesloten met een 
      {\sl punt-komma}
\end{itemize}

\subsection{Basis elementen van de taal C}
Bovenstaand programmaatje stelt ons in staat een aantal {\sl basis-
elementen} van de taal {\bf C} te bespreken.
\subsubsection{De character set}

De {\bf character} set , die gebruikt kan worden, bestaat uit \\

\begin{tabular}{|l|l|} \hline
Kleine letters  & a,b,---------,z       \\ \hline
Hoofdletters    & A,B,---------,Z       \\ \hline
Cijfers         & 0,1,---------,9       \\ \hline
Underscore      & \_                    \\ \hline
Speciale tekens & spatie = + - / * enz. \\ \hline 
\end{tabular}

\subsubsection{Constanten}

\begin{itemize}
\item De meest voorkomende vorm van {\bf constanten} 
      zijn gewoon {\sl getallen}, zoals : 
\begin{verbatim}
      1   2   5.73  12.3e9
\end{verbatim}
      Dit zijn {\sl arithmetische} constanten.
\item Een andere voorkomende vorm is die van een 
      {\sl character string}, ingesloten tussen 
      {\sl dubbele quotes}, zoals : 
\begin{verbatim}
      "Numeriek"  "1" 
\end{verbatim}
\end{itemize}               

\subsubsection{Symbolische namen}
\begin{itemize}
\item Worden gebruikt ter aanduiding van:variabelen,
      programma-delen etc.
\item Moeten bestaan uit alphanumerieke symbolen 
      (letters of cijfers)
\item Mogen underscores bevatten.
\item Het eerste symbool moet een letter zijn. 
\item Er is verschil tussen hoofd- en kleine letters;
      de {\sl conventie} is om {\sl geen} hoofdletters
      te gebruiken.
\item Voor de leesbaarheid van het programma is het 
      van belang 'betekenisvolle' \\ (en niet te lange) 
      namen te kiezen,zoals \\
      dag, maand, jaar  in plaats van a, i, j
\item In ons voorbeeld is 'iks' een {\sl voorbeeld} van een 
      symbolische naam.
\item Ook 'main' is trouwens een symbolische naam, hier 
      (verplicht) gebruikt voor het {\sl hoofd}-programma.
\end{itemize}

\subsubsection{Variabelen}

\begin{itemize}
\item Worden genoemd met een symbolische naam.
\item Het {\bf type} wordt bepaald in een {\bf declaratie}
 statement.\\
\begin{tabular}{lll}
 int    & iks       & een geheel getal (integer)        \\
 float  & snelheid  & een reeel getal (gewone precisie) \\
 double & snelheid  & een reeel getal (hogere precisie) \\
 char   & letter    & kan een character bevatten        \\
\end{tabular}
\item Voor {\sl elke} variabele {\sl moet} het type worden 
      gedeclareerd. Dit moet in elk geval gebeuren {\sl voordat} de 
      variabele wordt {\sl gebruikt}. Een goede conventie is, om dit 
      te doen aan het {\sl begin} van het programma-deel, waarin de 
      variable wordt gebruikt.
\item In ons programma declareren we het type van de variabele 'iks' 
      via
\begin{verbatim}
    int iks ;
\end{verbatim}
\end{itemize}



\subsection{Arithmetische expressies}
\begin{itemize}
\item Een voorbeeld van een arithmetische expressie in ons programma 
      is :
\begin{verbatim}
          iks + 2 
\end{verbatim}
\item In een arithmetische expressie worden (arithmetische) constanten 
      en variabelen met elkaar 'gecombineerd' via (arithmetische) 
      {\sl operatoren}. Deze operatoren zijn : \\
\begin{tabular}{ll}
   $+$   &  optellen         \\
   $-$   &  aftrekken        \\
   $*$   &  vermenigvuldigen \\
   $/$   &  delen            \\
   $\%$   &  bereken modulus  \\
\end{tabular}
\item (Andere) Voorbeelden zijn :
\begin{verbatim}
          a + b / 2.
          c + 3. * d 
\end{verbatim}
\item Belangrijk is de {\sl volgorde} waarin expressies worden verwerkt.
      De {\sl regels} hiervoor zijn :
\begin{itemize}
\item $*\;\;/$ en $\%$ hebben {\sl prioriteit} boven $+$ en $-$ . 
\item $*\;\;/$ en $\%$ zijn {\sl onderling gelijkwaardig}, dwz dat ze 
      worden afgewerkt in de volgorde waarin ze voorkomen, werkend 
      van links naar rechts.
\item $+$ en $-$ zijn onderling gelijkwaardig, en worden (ook) in 
      volgorde afgewerkt.
\item deze {\sl standaard}-volgorde kan worden gewijzigd door het 
      gebruik van 'haakjes' $(\;\;)$. Het uitwerken van delen van 
      expressies 'tussen haakjes" heeft voorrang.
\item voorbeelden zijn :
\begin{verbatim}
          a + b / 2.      (a + b)  / 2.
          c + 3. * d      (c + 3.) * d 
          d / 4. + a      d / (4. + a)
\end{verbatim}
\end{itemize}
\item Wanneer twee {\sl integer} variabelen of constanten op elkaar worden
      {\sl gedeeld} wordt het {\sl resultaat} weer een integer (naar beneden 
      afgerond).
      $1/6$ levert dus 0 als resultaat.
\end{itemize}

\subsection{Arithmetisch assignment}
\begin{itemize}
\item Voorbeelden van een arithmetisch assignment zijn :
\begin{verbatim}
    iks = 1 ;
    iks = iks + 2 ;
\end{verbatim}
      Merk op dat beide {\sl regels} worden afgesloten met een 
      '{\sl punt-komma}'.
\item De vorm is : {\bf variabele=expressie ; } \\
      Variabele en Expressie moeten {\bf arithmetisch} zijn
\item De {\bf expressie} mag bestaan uit een {\bf enkele}
     (arithmetische) constante of variabele, eventueel voorafgegaan 
      door een $-$ teken.
\begin{verbatim}
    iks = - 1   ;
    iks = - iks ;
    iks = - iks + 2 ;
\end{verbatim}

\item N.B. Een assignment is heel iets anders als een
      'vergelijking'.\\
      iks =iks + 1  is dus prima.
\end{itemize}

\subsection{Uitvoer via 'printf'}
\begin{itemize}
\item In het voorbeeldprogramma wordt wel iets uitgerekend, maar het resultaat 
      wordt op geen enkele wijze {\sl zichtbaar} gemaakt. Hierin kan worden 
      voorzien door het programma op de volgende wijze {\sl uit te breiden} :
\begin{verbatim}
#include <stdio.h>

int main (void)
{
    int iks ;

    iks = 1 ;
    iks = iks + 2 ;

    printf(" de waarde van iks = %d \n", iks) ;
 // LET OP: %d voor integer waarden, %f voor float waarden. 

    return 0 ;

}
\end{verbatim}
\item Bij executie van het programma zal op Uw scherm de volgende 
      tekst verschijnen :
\begin{verbatim}
 de waarde van iks = 3
\end{verbatim}
\end{itemize}

De 'printf'-opdracht is een (eerste) voorbeeld van {\sl aanroep van een 
functie}.
\begin{itemize}
\item de {\sl naam} van de functie is 'printf'
\item de functie wordt aangeroepen met {\sl twee parameters}, 
      van elkaar gescheiden door een 'komma'.
    \item U hoeft deze functie niet zelf te 'schrijven' : hij is
      beschikbaar
      in een {\sl bibliotheek} van de C-compiler. \\
      de naam van deze bibliotheek is 'stdio' - de definities van de
      functies in deze bibliothees staan in de header-file 'stdio.h'
\item U moet {\sl wel} in Uw programma aangeven dat U deze bibliotheek 
      wilt gebruiken. Dit gebeurt aan het begin van het programma, via 
\begin{verbatim}
#include <stdio.h>
\end{verbatim}
\item de eerste parameter in de aanroep van 'printf' is een 
      {\sl character string} (ingesloten tussen 'dubbele quotes' "  ").
      \\ de tweede variable is de {\sl naam} van een {\sl variable}.
\begin{itemize}
\item de tekst ' de waarde van iks = ' wordt gewoon uitgeprint. 
\item de \%d is een {\sl format descriptor}. U geeft er mee aan dat 
      'op deze plaats' de {\sl waarde van een variabele} moet worden 
      uitgeprint. \\
      welke variabele dat is, wordt aangegeven in de tweede parameter.
\item met $\backslash$n wordt aangegeven dat na deze print moet worden gestart
      op een {\sl nieuwe regel}

\end{itemize}
\item er zijn verschillende {\sl format descriptors}.
\begin{itemize}
\item \%d wordt gebruikt voor het printen van {\sl gehele getallen}. \\
      het aantal printposities dat nodig is, wordt bepaald door de 
      waarde van de variabele. \\
      met bijv. \%10d geeft U {\sl zelf} aan dat er 10 printposities 
      moeten worden gereserveerd.
\item \%f wordt gebruikt voor het printen van {\sl reele getallen}. \\
      U heeft {\sl geen controle} over het totale aantal printposities, 
      en ook niet over het aantal decimalen. \\
      met bijv \%10f reserveert U in totaal 10 printposities voor het 
      getal; U heeft geen controle over het aantal decimalen. \\
      met bijv \%10.3f reserveert U in totaal 10 printposities voor 
      het getal, en U vraagt om drie decimalen.
\end{itemize}
\end{itemize}



\subsection{Invoer via 'scanf"}
Het is mogelijk om vanuit Uw programma opdracht te geven om getalwaarden 
van variabelen in te lezen'vanaf het toetsenbord'.  Een voorbeeld vind je 
in het volgende programma of in de file 'ex1.c' van de Workspace.
\begin{verbatim}
#include <stdio.h>

int main (void)
{
    float a, b, c ;

    printf(" geef de waarden van de getallen a,b,c\n");
    scanf ("%f %f %f", &a, &b, &c);

    printf(" de ingetikte waarden van a b c zijn : %f %f %f\n",a,b,c);

    return 0 ;

}
\end{verbatim}
\begin{itemize}
\item  het eerste deel van de de scanf-opdracht geeft aan dat er 
       drie {\sl reele} getallen moeten worden ingetikt. \\
       de rest van de opdracht geeft aan dat de waarden moeten 
       worden opgeslagen in de variablen a,b,c.
\item  Merk op dat de namen van de variabelen in de scanf-opdracht 
       elk worden voorafgegaan door een \&. Dit heeft te maken 
       met het begrip {\sl pointer}, waar we later uitgebreid op 
       zullen terugkomen.
\item  De scanf-opdracht wordt voorafgegaan door een printf-opdracht 
       waarin wordt uitgelegd wat er ingetikt moet worden. Dit is 
       niet verplicht, maar wel handig.
\item  U kunt de getallen {\sl op een regel} intikken, van elkaar 
       gescheiden door spaties; afsluiten met de {\sl return}-toets.
\item  Ook de functie 'scanf' staat op de bibliotheek 'stdio.h',
       die wordt geactiveerd via de {\sl include}-opdracht.
\end{itemize}

\subsection{Mathematische functies}
Het ligt voor de hand dat we bij numerieke berekeningen regelmatig 
{\sl mathematische functies} zullen gebruiken. Een aantal daarvan is 
in C beschikbaar op een programma-bibliotheek met de naam 'math.h'. 
Deze bibliotheek wordt geactiveerd met een {\sl include}-opdracht. \\
Het volgende programma berekent de wortel van het product van twee 
getallen die U via het toetsenbord intikt. 
\begin{verbatim}
#include <stdio.h>
#include <math.h>

int main (void)
{
    float a,b ;
    float wortel ;

    printf(" geef de waarden twee positieve getallen \n ");
    scanf ("%f %f", &a, &b);
    printf(" de ingetikte waarden van a b zijn : %f %f\n",a,b);

    wortel = sqrt ( a*b)      ;

    printf(" de wortel uit hun product is : %f \n", wortel) ;

    return 0 ;

}
\end{verbatim}
Voorbeelden van beschikbare mathematische functies zijn : \\
\begin{tabular}{|l|l|} \hline
sqrt(x) & levert $\sqrt(x)$ \\ \hline
log(x)  & levert $\ln(x)$   \\ \hline
exp(x)  & levert $\exp(x)$  \\ \hline
pow(x,y)& levert $x^y$      \\ \hline
fabs(x) & levert $|x|$      \\ \hline
        &                   \\ \hline
sin(x)  & levert $\sin(x)$  \\ \hline
cos(x)  & levert $\cos(x)$  \\ \hline
        &                   \\ \hline
etc.    &                   \\ \hline
\end{tabular}


\subsection{Losse opmerkingen}
\begin{itemize}
\item {\sl Blanco} regels mogen naar willekeur worden ingevoegd
      (verhoogt de leesbaarheid).
\item Tekst die is ingesloten tussen $/*$ en $*/$ wordt
      beschouwd als {\sl commentaar} (verhoogt de leesbaarheid).
\item Het {\sl inspringen} van tekst 
      is verplicht (verhoogt de leesbaarheid)
\item Het gebruik van {\sl spaties} binnen een regel is op veel 
      plaatsen toegestaan, en kan de leesbaarheid verhogen.
\end{itemize}

\subsection{Opdrachten}
\subsubsection{Opdracht 1}
Welke van de volgende namen van variabelen zijn {\sl niet legaal} ?
\begin{verbatim}
naam      quotient    x_1        x-1
eind!     4impuls     4_impuls   x12
\end{verbatim}

\subsubsection{Opdracht 2}
Welke van de volgende arithmetische expressies zijn {\sl niet in orde} ?
\begin{verbatim}
a+b       -c            d+(-f)
a+-c      (a+b)(c+d)    4.*((a-d)-(b-c)
\end{verbatim}

\subsubsection{Opdracht 3}
Schrijf en test een programma dat :
\begin{itemize}
\item de waarde van drie reele getallen a,b,c inleest via het 
      toetsenbord, en deze getallen uitprint.
\item de wortels berekent van de vergelijking $ax^2 + bx + c = 0 $
\item de waarde van beide wortels uitprint.
\item
\begin{tabular}{llll}
pas dit toe op & a=1. & b=-1.5  & c=0.5 \\
               & a=2. & b=-2.   & c=0.5 \\
               & a=1. & b=-1.5  & c=1.5 \\
\end{tabular} \\
{\bf NB} : in het laatste geval 'gaat er iets mis'. Waarom ?
\end{itemize}

