Programmeren met spreadsheets: verschil tussen versies

Uit Lab
Naar navigatie springen Naar zoeken springen
 
(16 tussenliggende versies door dezelfde gebruiker niet weergegeven)
Regel 1: Regel 1:
== Programmeren met spreadsheets ==
== Programmeren met spreadsheets ==


De meeste toepassingen worden geprogrammeerd met behulp van spreadsheets.
De meeste ICT-toepassingen worden gemaakt met behulp van spreadsheets.
De drempel voor het maken van een eenvoudige spreadsheet is erg laag: binnen enkele minuten heb je al je eerste resultaat.
De drempel voor het maken van een eenvoudige spreadsheet is erg laag: binnen enkele minuten heb je al je eerste resultaat.
Een groot voordeel is dat alle stappen in een berekening zichtbaar zijn, en dat je direct het resultaat van je aanpassingen ziet.
Een groot voordeel is dat alle stappen in een berekening zichtbaar zijn, en dat je direct het resultaat van je aanpassingen ziet.
Regel 20: Regel 20:
=== Programma beschrijft proces ===
=== Programma beschrijft proces ===


Een programma beschrijft ook vaak een ''proces''.
Je kunt een programma ook zien als de beschrijving van een "proces" (of eigenlijk, van een klasse van processen).
Een proces speelt zich af in de tijd, en bestaat uit een reeks stappen die achtereenvolgens uitgevoerd worden door de processor.
Een proces speelt zich af in de tijd, en bestaat uit een reeks stappen die achtereenvolgens uitgevoerd worden door de processor.
Deze processor kan een automaat zijn, zoals een computer, maar ook een mens.
Deze processor kan een automaat zijn, zoals een computer, maar ook een mens.
Regel 30: Regel 30:
=== Beperkingen van spreadsheets ===
=== Beperkingen van spreadsheets ===


Spreadsheets zijn laagdrempelig - maar toch voor veel toepassingen niet het beste middel:
* spreadsheets zijn niet ''schaalbaar'' - noch voor grotere berekeningen, noch voor grotere hoeveelheden data.
* spreadsheets hebben geen mogelijkheden voor ''abstractie'' (zoals: procedures/functies, modules).
* fouten in spreadsheets zijn lastig te vinden;
* fouten in spreadsheets zijn lastig te vinden;
* spreadsheets zijn niet "schaalbaar" - noch voor grotere berekeningen, noch voor grotere hoeveelheden data.
== Spreadsheets: de basis ==
Een spreadsheet(bestand) bestaat uit één of meer rekenvellen (sheets).
Elk vel bestaat uit een rechthoek van cellen, ingedeeld in rijen en kolommen.
De positie van een cel in het vel geven we aan als <kolom><rij>, waarbij we voor kolommen opeenvolgende letters gebruiken, en voor rijen opeenvolgende getallen.
Voorbeelden:
* de cel linksboven is A1
* de derde cel in de eerste rij is C1; dit is ook de eerste cel in de derde kolom.
* de vierde cel in de tweede kolom is B4.
In principe kun je meer dan 26 kolommen gebruiken: na A volgt AA, AB, AC, enzovoorts.
Maar in de praktijk is het vaak handiger om een spreadsheet niet te breed te maken,
zodat deze nog op het scherm past.
Je hebt dan aan enkelvoudige letters genoeg.
Meestal laat je een spreadsheet "naar beneden groeien":
dat werkt zowel handiger op het scherm als op papier.
=== Cellen ===
Een cel:
* is leeg; of
* bevat een eenvoudige waarde: getal of tekst (of een datum?); of
* bevat een formule.
(logische waarden?)
==== Opdrachten ====
* plaats het getal 1024 in cel A7
* plaats de tekst "Hallo Wereld" in cel C4
* plaats de datum "14 maart 2019" in cel B2
==== Weergeven van een waarde ====
Een cel met een getal kun je op verschillende manieren (formats) weergeven;
als "normale" getallen, met of zonder decimale komma (of punt), als valuta (euro's, dollars, enz.), met of zonder punt (of komma) voor de duizendtallen, negatieve getallen tussen haakjes, enz.
Bovendien kun je deze weergave rechts, links, of in het middel plaatsen;
gewoonlijk staan getallen rechts in een cel.
: Deze weergave verandert niets aan het getal in de cel: als je een getal met minder decimale weergeeft, verandert alleen de weergave op het scherm, niet het getal in de cel waarmee verder gerekend wordt.
Een tekst kun je links, rechts of in het midden plaatsen.
Gewoonlijk staat een tekst links in een cel.
Een datum/tijd-waarde kun je ook op allerlei manieren weergeven.
: Hierbij moet je vooral verdacht zijn op verwarring tussen de notaties die in Europa en de VS gebruikelijk zijn: 1/2/2019 betekent in de VS 2 januari 2019, elders 1 februari.
==== Let op! ====
Een cel met een tekst levert in een berekening de waarde 0 op.
Dit kan erg misleidend zijn als die tekst een getal voorstelt.
De misleiding is nog groter als die tekst bovendien rechts in de cel staat, zoals andere getallen.
Zie het voorbeeld:
==== Automatisch vullen Handig! ====
Soms wil je een hele reeks cellen met dezelfde waarden vullen, of met waarden die elkaar logisch opvolgen.
Bijvoorbeeld: je wilt kolom A1,... vullen met de getallen 1, 2, 3, 4, ...
Met behulp van de vulgreep kun je dit snel doen:
* vul de eerste waarden in, bijvoorbeeld A1: 1  en A2: 2;
* selecteer deze beide cellen
* je vindt de vulgreep rechts onderaan deze selectie
* klik en trek deze vulgreep naar beneden, zover als nodig is.
==== Formules ====
Een formule begint met een "="-teken.
In een formule gebruik je de gebruikelijk rekenkundige operatoren, getallen, en verwijzingen naar cellen (adressen).
===== Verwijzingen =====
Er zijn twee soorten verwijzingen naar cellen:
* ''absolute verwijzingen'': deze verwijzen altijd naar dezelfde cel (rij, kolom), ook als je de formule verplaatst of kopieert;
** dit geef je aan door een $ te plaatsen voor de kolom-letter en/of voor het rij-getal; voorbeelden: <code>$B2</code>, <code>B$2</code>, <code>$B$2</code>
* ''relatieve verwijzingen'': de afstand tussen de cel (rij, kolom) en de cel met de formule blijft constant, ook als je de formule verplaatst of kopieert.
We noemen dit ook wel ''absolute adressering'' en ''relatieve adressering''.
===== Opdracht =====
# plaats in cel A2 het getal 42
# plaats in cel B2 de formule <code>=A2 + 1</code>
# plaats in cel C2 de formule <code>=$A$2 + 1</code>
# kopieer en plak de formule van B2 naar B3
# kopieer en plak de formule van C2 naar C3
Verklaar het resultaat.
===== Functies =====
Je kunt in een formule functies gebruiken.
Dit kunnen functies zijn die een enkele waarde als invoer ("parameter") hebben, bijvoorbeeld <code>SQRT(A2)</code> (voor de wortel van een getal).
Er zijn ook functies die een reeks waarden als invoer hebben, zoals een segment van een rij of van een kolom.
Voorbeelden hiervan zijn: <code>SUM(A2:A12)</code>, <code>MAX(A2:E2)</code>
Deze functies vatten een reeks waarden samen tot een enkele waarde.
===== Gevorderd =====
* gebruik van draaitabellen (pivots)
== Voorbeeld: groeiprocessen ==
Processen met groei (of krimp) kom je overal tegen:
* de hoeveelheid geld op een bankrekening
* de groei van bacteriën op een voedingsbodem
* de groei van het aantal (mogelijke) verbindingen in een netwerk
* het vollopen van een emmer water onder een kraan
* het leeglopen van een vat met water via een kraan onderin
* en veel andere vergelijkbare voorbeelden.
Deze groei hoeft niet altijd een functie van de tijd te zijn:
in de informatica gebruik je het begrip complexiteit om aan te geven hoe de hoeveelheid rekenwerk afhangt van de omvang van het probleem.
Voor verschillende algoritmen groeit de hoeveelheid rekenwerk verschillend bij eenzelfde toenamen van de omvang van het probleem.
Het triviale model is *nulgroei*: de hoeveelheid H blijft gelijk.
=== Lineaire groei ===
Het eenvoudigste niet-triviale model is lineaire groei: de hoeveelheid H neemt elke stap met een constante toe:
<math>H(t _{n+1}) = H(t_{n} )+ K</math>.
Of ook wel: <math>H(t+\Delta) = H(t) + K \cdot \Delta</math>
We kunnen dit groeiproces eenvoudig in een spreadsheet weergeven:
* de eerste kolom (A) geeft de tijd (of het nummer van de stap) weer: <math>t</math>; we beginnen, zoals gebruikelijk in de informatica, bij 0.
* de eerste rij beschrijft de begintoestand: <math>H(0)</math>, in kolom B
** <code>C1</code> bevat de constante </math>K</math>
* elke volgende rij heeft dezelfde formule: <code>=B1 + $C$1</code>
Voorbeelden:
* lineair zoeken
=== Kwadratische groei ===
Voorbeelden:
* netwerken (van internet tot Facebook etc.): het aantal mogelijke (directe) verbindingen; wet van Metcalfe (over de waarde van een netwerk)
* (minder slimme) sorteeralgoritmen


== Onderwerpen ==


=== Exponentiële groei ===
* [[/Spreadsheets-basis]]
* [[/Voorbeeld: groeiprocessen]]
* [[/Voorbeeld: zoeken en sorteren]]
* [[/Voorbeeld: cellulaire automaten]]
* [[/Voorbeeld: eindige automaten]]
* [[/Voorbeeld: omzetten van decimaal naar binair]]
* [[/Voorbeeld: KGV en GGD]]
* [[/Data in tabellen]]


Voorbeelden:
== Voorbeeld-spreadsheets ==
* rente (samengestelde interest, "rente op rente")
* sommige rekenprocessen (algoritmen): bijvoorbeeld Traveling Salesman, SAT (voor welke waarden van de logische variabelen levert een bepaalde logische uitdrukking true op?)


=== Logaritmische groei ===
De spreadsheets met de voorbeelden zijn te vinden op:
* https://drive.google.com/drive/folders/1e1oS6IRqLHkR09tRGQWd-JUi9TbTzmvO?usp=sharing


Voorbeelden:
De ODS (Open Office)- en Google Docs versies werken in elk geval.
* binair zoeken
De excel-versies zijn niet getest.

Huidige versie van 14 mrt 2019 om 13:14

Programmeren met spreadsheets

De meeste ICT-toepassingen worden gemaakt met behulp van spreadsheets. De drempel voor het maken van een eenvoudige spreadsheet is erg laag: binnen enkele minuten heb je al je eerste resultaat. Een groot voordeel is dat alle stappen in een berekening zichtbaar zijn, en dat je direct het resultaat van je aanpassingen ziet. Bovendien is het rekenmodel van spreadsheets eenvoudig: in de wereld van programmeertalen zou je dit een eenvoudige functionele taal kunnen noemen.


Aan de hand van verschillende voorbeelden leggen we een aantal principes van programmeren uit. We kunnen op twee manieren kijken naar een programma:

Programma beschrijft berekening

Een programma beschrijft een berekening. Vaak is dit een samengestelde berekening, met tussenresultaten.

In dit geval zijn we vooral geïnteresseerd in het resultaat van de berekening. De precieze volgorde van de stappen om tot het resultaat te komen is daarbij niet van belang.

Programma beschrijft proces

Je kunt een programma ook zien als de beschrijving van een "proces" (of eigenlijk, van een klasse van processen). Een proces speelt zich af in de tijd, en bestaat uit een reeks stappen die achtereenvolgens uitgevoerd worden door de processor. Deze processor kan een automaat zijn, zoals een computer, maar ook een mens. Het programma beschrijft steeds wat de volgende stap is, op basis van het programma (de beschrijving van het proces), de toestand van het proces, en de invoer. De toestand van een proces omvat de positie in het programma en een reeks variabelen met tussenresultaten.

Deze begrippen werken we in de voorbeelden verder uit.

Beperkingen van spreadsheets

Spreadsheets zijn laagdrempelig - maar toch voor veel toepassingen niet het beste middel:

  • spreadsheets zijn niet schaalbaar - noch voor grotere berekeningen, noch voor grotere hoeveelheden data.
  • spreadsheets hebben geen mogelijkheden voor abstractie (zoals: procedures/functies, modules).
  • fouten in spreadsheets zijn lastig te vinden;

Onderwerpen

Voorbeeld-spreadsheets

De spreadsheets met de voorbeelden zijn te vinden op:

De ODS (Open Office)- en Google Docs versies werken in elk geval. De excel-versies zijn niet getest.

Overgenomen van "http:///lab/index.php?title=Programmeren_met_spreadsheets&oldid=1586"