Programmeren in C/Berekeningen

Je kunt makkelijk rekenen met C. Rekenen wordt gedaan met + (optellen), - (aftrekken), * (vermenigvuldiging), / (deling) en % (modulo). Ook zijn er operatoren voor het beïnvloeden van bits; dit zijn << (left shift), >> (right shift), | (OF), & (EN), ^ (XOF) en ~ (inversie). Voor het berekenen van machtsverheffingen en wortels zijn speciale functies gedefinieerd.

Gewone berekeningen: het gebruik van variabelen en rekenkundige bewerkingen

Conversie tabel van graden naar radialen Veel voorkomende functies in C zijn genereren of testen van signalen

Machtsverheffingen en wortels

Voor het berekenen van machtsverheffingen en wortels zijn speciale functies gedefinieerd in de header "math.h".

Een wortel kan berekend worden door middel van de functie sqrt (samentrekking van het Engelse square root) die een double ontvangt en een double teruggeeft. Sinds de standaard C99 (officieel ISO/IEC 9899:1999) zijn ook de functies sqrtf en sqrtl toegevoegd, respectievelijk voor het berekenen van de wortel van een float en een long double.

Om machtsverheffingen te berekenen bestaan de functies pow (double), powf (float) en powl (long double). Deze functies krijgen twee waarden, het grondtal en de exponent, en geven het grondtal tot de macht van de exponent. Hetzelfde verhaal als van de functie sqrt geldt ook voor de functie pow.

C-code:

#include <stdio.h>
#include <math.h>

int main(void)
{
    float a       =  16.0F;
    double b      =  25.0;
    long double c = 144.0L;

    printf("%f\n",  sqrtf(a)); //  4.000000
    printf("%f\n",  sqrt(b));  //  5.000000
    printf("%Lf\n", sqrtl(c)); // 12.000000

    printf("%f\n",  powf(2.0F, 5.0F)); // 32.000000
    printf("%f\n",  pow(3.0, 4.0));    // 81.000000
    printf("%Lf\n", powl(7.0L, 2.0L)); // 49.000000
}

Post* en pre*

i++ is zowat kenmerkend voor C en al diens derivaten. Eigenlijk wil dit gewoon zeggen i=i+1. Maar door het frequente gebruik hiervan (denk aan een for lus) is deze afkorting ontstaan. Nu zijn er echter enige finesses die bij het gebruik van deze operator horen en soms beginnelingen in de weg liggen. Het betreft hier het verschil tussen preincrement (++i) en postincrement (i++). En de tegenhangers predecrement (--i) en postdecrement (i--). Het verschil tussen post en pre ligt gewoon in de volgorde van gebruik. Bij een preincrement gaat de variabele in waarde verhoogd worden voor deze variabele gebruikt wordt bij een postincrement gebeurt dit pas nadat de variabele gebruikt is. Een kort voorbeeld kan hier natuurlijk veel duidelijk maken:

C-code:

#include <stdio.h>

main()
{
        int a=1;
        printf("%i\n", a++);  // print 1 (a is nu 2)
        printf("%i\n", ++a);  // print 3 (a is nu 3)
        printf("%i\n", --a);  // print 2 (a is nu 2)
        printf("%i\n", a--);  // print 2 (a is nu 1)
}

De modulo-operator wordt gebruikt om de rest te bepalen bij deling van een geheel getal door een ander; dat komt er op neer dat een getal zo vaak als kan van een ander getal wordt afgetrokken. Voor de modulo-operator wordt het symbool '%' gebruikt. Voorbeelden:

9 % 2 = 1, immers 9 = 4*2 + 1; 9 -2 -2 -2 -2 = 1

8 % 2 = 0, immers 8 = 4*2 + 0; 8 -2 -2 -2 -2 = 0

5 % 2 = 1

8 % 3 = 2, 8 -3 -3 = 2 etc.

Als er een min-teken voorkomt in deeltal of deler dan schrijft de C-standaard ISO/IEC 9899:1999 (bekend als C99) voor dat het teken van het resultaat gelijk is aan het teken van het deeltal. Dus:

(-17) % 3 = -2

(-17) % (-3) = -2

17 % (-3) = 2

Willekeurige getallen

Er is een functie in de header "stdlib.h" die je een willekeurig getal geeft. De functie heet rand() (van het Engelse woord random, dat willekeurig betekent). Hij is simpel te gebruiken: int i = rand(); Dat getal kan natuurlijk wel heel hoog worden, daarom is het misschien handig te gebruiken met een modulo: int i = rand() % 5; om het getal maximaal 4 te laten worden. In dit geval vraag je de rest van een deling van een getal n gedeeld door k, dit kan dus alle getallen opleveren van 0 tot en met k-1. Beschouw het volgende stuk code:

C-code:

#include <stdlib.h>
#include <stdio.h>

int main()
{
        int i;
        int max=20;
        for(i=0;i<5;i++)
        {
                printf("%i\n", rand()%20);
        }
}

Wanneer deze code gecompileerd wordt, en een aantal keer uitgevoerd wordt zal deze echter telken male dezelfde random tekenreeks op het scherm getoond worden. Dit is zo omdat er vele sequenties van random getallen beschikbaar zijn, het oproepen van rand() geeft gewoon het volgende getal uit die sequentie terug. Bij het begin van een programma wordt dus telkens dezelfde sequentie van voorafaan afgelopen. Gelukkig is hiervoor een oplossing. Door de functie void srand(unsigned int seed) toe te voegen bij het begin van de code is het mogelijk om een selectie van de randomsequentie te maken. Indien u voor de for los srand(0) zou toevoegen zou u terug hetzelfde resultaat krijgen als het vorige programma (er wordt dus standaard de sequentie gebruikt die samengaan met het nummer nul). Maar nu lost dit het probleem nog niet op. Onder Linux is het bijvoorbeeld mogelijk om de randomgenerator te seeden met de huidige systeemtijd. Dit kan er dan bijvoorbeeld uitzien als in volgende code:

C-code:

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

main(){
        srand(time(NULL));
        int i;
        int max=20;
        for(i=0;i<5;i++)
        {
                printf("%i\n", rand()%20);
        }
}

De functie time(NULL) (vereist #include <time.h> ) geeft gewoon de huidige systeemtijd in seconden (een grote integer) terug. Andere compilers en omgevingen hebben andere methodes om de random generator te seeden. Maar een opmerking hier is toch op zijn plaats: in de informatica bestaat niets zoals een perfect willekeurig getal, tenzij hier extra exotische hardware aan toegevoegd wordt. Indien men in deze context bijvoorbeeld weet met welk getal de random generater geseed zal worden zal men alle random getallen op voorhand reeds bepalen. De reden hiervoor is simpel, een computer kan niets anders doen dan reageren volgens een geprogrammeerd patroon op zijn omgeving. Dit kan enkel meer complex gemaakt worden maar nooit uitgesloten worden.