Programmeer programma`s die je op de GR kan maken en

Profielwerkstuk Victoria van Tets
Inhoud
Inhoud
Inleiding
Verslag:
1.1 de ABC-formule: Over de ABC-formule
1.2 de ABC-formule: Uitleg script ABC-formule
2.1 Binair en Decimaal convertor: Over het Binaire Stelsel
2.2 Binair en Decimaal convertor: Uitleg script Binair/Decimaal
3.1 Intersect: Over Intersect
3.2 Intersect: Uitleg script Intersect
4.1 Priemgetallen: Over Priemgetallen
4.2 Priemgetallen: Uitleg script Priemgetallen
5.1 Vergelijking met twee onbekenden: Over vergelijking met twee onbekenden
5.2 Vergelijking met twee onbekenden: Uitleg vergelijking met twee onbekenden
Logboek
Conclusie
Bronnen
1
blz. 01
blz. 02
blz.
blz.
blz.
blz.
blz.
blz.
blz.
blz.
blz.
blz.
blz.
blz.
blz.
03
04
05
06
08
09
12
14
16
17
19
20
21
Profielwerkstuk Victoria van Tets
Inleiding
Ik heb als onderwerp voor mijn profielwerkstuk “functies van de grafische
rekenmachine programmeren in Javascript” gekozen. Dit heb ik gedaan omdat ik
voor mijn profielwerkstuk een onderwerp wilde kiezen dat mij daadwerkelijk
interesseert, aangezien je er vrij lang mee bezig bent. Ik wilde al een tijdje leren
programmeren in Javascript en ik heb altijd op de grafische rekenmachine
geprogrammeerd, vandaar dat ik die ook bij mijn profielwerkstuk wilde betrekken. In
de grafische rekenmachine programmeren is namelijk vrij makkelijk, vandaar dat je
als je wil gaan programmeren daar mee kan beginnen. Het gebruikt engelse woorden
zoals If, Then, While etc. die te begrijpen zijn. Vervolgens ben ik op het internet
gaan zoeken naar zogenaamde tutorials (een soort van handleidingen) om Javascript
te leren, en heb ik een boek gekocht (zie bronvermelding). Er was op het internet
een goede tutorial voor als je al geprogrammeerd had en je in Javascript wilde gaan
programmeren. Als voordeel heeft Javascript dat een computer veel sneller is dan
een grafische rekenmachine en je het op het internet kan zetten, wat ik ook gedaan
heb. Mijn hele profielwerkstuk is eigenlijk meer gemaakt als een website, ik denk dat
je ook het beste naar de site kan gaan, http://clik.to/profielwerkstuk, omdat ik elke
keer als ik iets programmeerde het direct in HTML (HTML is de taal waarin je
websites schrijft) zette. Ik heb ook pas op het laatst alles in een ‘normaal’ verslag
gezet. Bovendien kan je op papier niet een script (een script is een programma dat is
geschreven in Javascript) uitproberen, je kan alleen proberen na te gaan of ik het
goed in elkaar heb gezet.
Als hoofdvraag heb ik genomen "Hoe programmeer je functies van de grafische
rekenmachine in Javascript?"
Ik heb deze hoofdvraag onderverdeeld in deelvragen:
 Hoe programmeer je de ABC-formule in Javascript?
 Hoe programmeer je een binair en decimaal convertor in Javascript?
 Hoe programmeer je de Grafische Rekenmachine functie intersect in Javascript?
 Hoe programmeer je een programma dat kijkt of een getal een priemgetal is in
Javascript?
 Hoe programmeer je een vergelijking met 2 onbekenden in Javascript?
Ik heb van elke deelvraag een paragraaf gemaakt.
2
Profielwerkstuk Victoria van Tets
De ABC-formule:
Over de ABC-formule
De ABC-formule rekent uit wat de twee waardes voor x zijn als je een vergelijking
hebt herleid tot ax2 + bx + c = 0. Om de ABC-formule te berekenen vul je a, b en c
in. De ABC-formule is:
de discriminant is b2 - 4ac . Als de discriminant gelijk aan 0 of negatief is, werkt de
formule niet [immers de wortel van 0 of de wortel van een negatief getal is
onmogelijk].
Ik zal eerst deze formule bewijzen:
ax² + bx + c = 0
4a²x² + 4abx + 4ac = 0
4a²x² + 4abx = -4ac
4a²x² + 4abx + b² = -4ac + b²
(2ax +b) ² = -4ac + b²
2ax + b = ±√(-4ac + b²)
Alles keer 4a
4 ac naar rechts halen
b² toevoegen
4a²x² + 4abx + b² herleiden tot (2ax + b)(2 ax + b)
Wortel trekken
B naar rechts halen
2ax = -b ± √ (-4ac + b²)
x = (-b ± √ (-4ac + b²)) / 2a
Door 2a delen
Je hebt 2 gevallen waarbij de ABC-formule niet werkt:
 b²-4ac ≤ 0  je kan geen wortel trekken  formule werkt niet
 a = 0 , want je kan niet door 0 delen. Je moet in dat geval de formule x = -c/b
gebruiken.
Omdat het maar 2 uitzonderingen zijn heb ik ze beide ingeprogrammeerd.
3
Profielwerkstuk Victoria van Tets
De ABC-formule:
Uitleg script ABC-formule
Normaal
In Script
d = b2 - 4ac
d = (b * b) - (4 * a * c)
als a 0 [dus er geen x2 is ingevuld;je moet
deze als inbouwen omdat de computer
if (a == 0)
anders een error geeft aangezien hij dan niet
dooor 2a kan delen]
{document.berekening.ans.value = ((-1 * c) /
vul bij "x is" -c / b in.
b)
document.berekening.twee.value = ((-1 * c) /
vul bij "of x is" ook -c / b in
b)}
als b en c niet 0 zijn en a niet 0 is
Else
als d gelijk aan of kleiner dan 0 is
if (d <= 0)
Geef de gebruiker een alert: discriminant is
{alert('Discriminant is Negatief!')
negatief
Stop
return}
als b en c niet 0 zijn en a niet - is en de
Else
discriminant niet gelijk aan of kleiner dan 0 i
eerste x = -(b - wortel d) / 2a
{x = -(b - Math.sqrt(d)) / (2 * a)
tweede x = -(b + wortel d) / 2a
y = -(b + Math.sqrt(d)) / (2 * a)
vul bij "x is" x in/
document.berekening.ans.value = x
vul bij "of x is" y in.
document.berekening.twee.value = y}
Uiteindelijk resultaat:
<script language="JavaScript">
function rekenen() {
a = eval(document.berekening.a.value)
b = eval(document.berekening.b.value)
c = eval(document.berekening.c.value)
d = (b * b) - (4 * a * c)
if (a == 0)
{document.berekening.ans.value = ((-1 * c) / b)
document.berekening.twee.value = ((-1 * c) / b)}
else
if (d <= 0)
{alert('Discriminant is Negatief!')
return}
else
{x = -(b - Math.sqrt(d)) / (2 * a)
y = -(b + Math.sqrt(d)) / (2 * a)
document.berekening.ans.value = x
document.berekening.twee.value = y}
}
</script>
4
Profielwerkstuk Victoria van Tets
Binair en Decimaal convertor:
Over het Binaire Stelsel
Het binaire stelsel is een tweetallig getallenstelsel. Dat betekent dat het slechts twee
cijfers kent: de 0 en de 1. Een binair getal heeft in de computerwereld 8 decimalen.
10 is dus 00000010. Dit is zo omdat de computer ook een reeks binaire getallen
moet herkennen. Als je niet zou weten hoeveel decimalen een binair getal heeft, zou
je niet weten of 1001001110011001 een, twee, drie, vier etc. getallen voorstelt.
Omdat een binair getal 8 decimalen heeft weet je nu dat het het getal 10010011 en
10011001 is.
Elke 1 stelt 2positie - 1 voor. Bij 00000010 staat de 1 bijvoorbeeld tweede van rechts;
deze 1 symboliseert 21 = 2. Ik zal het hieronder op een rijtje zetten.
00000001 = 20 = 1
00000010 = 21 = 2
00000100 = 22 = 4
00001000 = 23 = 8
00010000 = 24 = 16
00100000 = 25 = 32
01000000 = 26 = 64
10000000 = 27 = 128
Je kan combinaties maken. 01100000 is in feite 01000000 + 00100000 = 64 + 32 =
96. Je kan het ook op de volgende manier berekenenL 01100000 =
0 * 2 0 + 0 * 2 1 + 0 * 2 2 + 0 * 2 3 + 0 * 2 4 + 1 * 2 5 + 1 * 2 6 + 0 * 27 = 0 + 0 + 0 +
0 + 0 + 32 + 64 = 96
Deze manier kost welliswaar wat meer tijd maar is uiteindelijk makkelijker.
11111111 bereken je hier sneller mee; 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 = 1 +
2 + 4 + 8 + 16 + 32 + 64 + 128 = 255.
Je kan ook van decimalen naar binair omrekenen. Stel je voor dat je het getal y
hebt. Je pakt eerst de grootste 2x macht die er in past. Dan heb je nog y - 2x over.
Dan pak je de grootste 2a macht. Dan heb je nog y - 2x - 2a over. Etc. totdat je 0 over
hebt. Dan ga je het binaire getal opschrijven. Je begint helemaal links. Zat er 2 7 in?
Zo ja, dan schrijf je een 1 op, zo nee een 0. Je schuift eentje naar rechts. Zat er 2 6
in? Ga zo maar door en dan krijg je er een binair getal uit. Met programmeren kan je
niet zo maar een 1 opschrijven. Als er een 1 voorkomt dan tel je gewoon 10 x bij je
getal op, zodat de 1 er wel staat. Voor een 0 hoef je niets te doen.
Ik heb als beperking ingevoerd dat een binair getal niet groter dan 11111111 [het
grootst mogelijke binaire getal met 8 decimalen] en een decimaal getal niet groter
dan 255 [de decimale versie van het grootst mogelijke binaire getal met 8
decimalen] mag zijn, omdat dit in de computerwereld ook niet mag.
5
Profielwerkstuk Victoria van Tets
Binair en Decimaal convertor
Uitleg script Binair/Decimaal
Normaal
dit script heet "rekenen" ; dit is het script dat
binaire getallen naar decimale getallen omzet
In Script
function rekenen() {
x=
eval(document.berekening.binair.value)
if (x>11111111)
{alert('Binaire getallen mogen niet groter
dan 11111111 zijn!')
x is het ingevoerde [binaire] getal
als x groter is dan 11111111
geef een alert met de tekst "binaire getallen
mogen niet groter dan 11111111 zijn"
stop [dit geld als x groter dan 11111111 is] [einde
return}
van de als]
a = 7 [hij trekt 10 tot de a-de van x af totdat x 0
a=7
is; hij begint met het meest linkse getal = 107]
c = 0 [c is het uiteindelijke decimale getal]
c=0
zolang x niet 0 is [dus zolang het converteren niet
Do
klaar is] doe:
als x - 10 tot de a-de groter dan of gelijk aan 0 is
{if (x-(Math.pow(10,a)) >= 0)
[dit zou betekenen dat het a-de cijfer een 1 is]
c = c + 2 tot de a-de [in decimalen stelt elke
{c = c+(Math.pow(2,a))
binaire 1 2 tot de a-de voor]
x = x - 10 tot de a-de [je hebt 10 tot de a-de als
decimaal getal opgeslagen; je moet het nu van het x = x-(Math.pow(10,a))}
binaire getal aftrekken]
Als a kleiner dan 0 is [dus als je alle 8 de cijfers
bent afgegaan maar nog steeds het getal niet hebt
geconverteerd -> dit is onmogelijk dus moet het if (a < 0)
betekenen dat de gebruiker geen binair getal heeft
ingevuld]
Geef een alert : ingevoerde getal + de tekst "is
{alert(document.berekening.binair.value +
geen binair getal"
' is geen binair getal')
stop met het uitvoeren van het script + einde van
return}
de als
a
trek 1 van a af [je gaat nu opnieuw kijken of 10
a = a-1}
in het binaire getal zit]
einde van wat je moet doen zolang x niet 0 is
while (x != 0)
vul bij decimaal getal: c in.
document.berekening.ans.value = c
einde van dit script
}
dit script heet "naarbinair"
function naarbinair() {
x=
x is het ingevoerde decimale getal
eval(document.berekening.decimaal.value)
als x groter dan 255
if (x>255)
geef een alert met de tekst "decimale getallen
{alert('Decimale getallen mogen niet
mogen niet groter dan 255 zijn"
groter dan 255 zijn!')
stop [ } geeft het einde van de als aan ]
return}
a = 0 [a wordt het binaire getal]
a=0
c = 7 [c is voor het 2 tot de c-de getal]
c=7
zolang als x niet 0 is, doe:
do
als x - 2 tot de c-de gelijk aan of groter dan 0 is
{if (x-(Math.pow(2,c)) >= 0)
a = a + 10 tot de c-de
{a = a+(Math.pow(10,c))
x = x - 2 tot de c-de
x = x-(Math.pow(2,c))}
c=c-1
c = c-1}
einde van wat je moet doen zolang x niet 0 is
while (x != 0)
vul bij decimaal getal: a in
document.berekening.ans2.value = a}
6
Profielwerkstuk Victoria van Tets
Uiteindelijk resultaat:
<script language="JavaScript">
function rekenen() {
x = eval(document.berekening.binair.value)
if (x>11111111)
{alert('Binaire getallen mogen niet groter dan 11111111 zijn!')
return}
a = 7
c = 0
do
{if (x-(Math.pow(10,a)) >= 0)
{c = c+(Math.pow(2,a))
x = x-(Math.pow(10,a));}
if (a < 0)
{alert(document.berekening.binair.value + ' is geen binair getal')
return}
a = a - 1}
while (x != 0)
document.berekening.ans.value = c
}
function naarbinair() {
x = eval(document.berekening.decimaal.value)
if (x>255)
{alert('Decimale getallen mogen niet groter dan 255 zijn!')
return}
a = 0
c = 7
do
{if (x - (Math.pow(2,c)) >= 0)
{a = a + (Math.pow(10,c))
x = x - (Math.pow(2,c));}
c = c - 1}
while (x != 0)
document.berekening.ans2.value = a
}
</script>
7
Profielwerkstuk Victoria van Tets
Intersect
Over Intersect
Intersect is een functie die ook op de Grafische Rekenmachine (GR) aanwezig is. Met
intersect kan je het snijpunt van twee grafieken berekenen. De GR vraagt om een
left-bound (wat x minimaal is) en een right-bound (wat x maximaal is). Hierna
berekent de GR het snijpunt.
Het snijpunt van twee grafieken berekenen kan nog vrij lastig zijn. De vergelijking ax
+ b = c kan iedereen oplossen. Dan krijg je namelijk x = (c-b)/a. De vergelijking ax²
+ bx + c = dx² + ex + f valt ook nog op te lossen; dit doe je met de ABC formule.
Dit kan je, als mens, bedenken, maar de computer/grafische rekenmachine kan niet
zelfstandig nadenken. Je kan het hem wel aanleren, maar dan kan hij het alleen als
er zo'n soort vergelijking ingevoerd wordt. Als je dan een x3 zou invoeren, zou hij
prompt vastlopen of gewoon niets doen. Gelukkig kan de mens dit met logica
bedenken.
Maar probeer maar eens de vergelijking ax4 + bx3 + cx2 + dx + e = fx4 + gx3 + hx2
+ ix + j op te lossen. Dit is vrijwel onmogelijk. De computer/grafische rekenmachine
kan dit wel oplossen, door namelijk te 'gokken'. Hij maakt eerst grote stappen, maar
zodra het verschil weer groter wordt, gaat hij terug naar waar het verschil kleiner
was. Dan maakt hij daar kleinere stapjes, etc. totdat hij het snijpunt van de twee
grafieken gevonden heeft. Ik heb dit geprobeerd na te bootsen. 'Mijn' intersect doet
precies hetzelfde; hij neemt steeds kleinere stappen totdat hij het snijpunt heeft
gevonden. Als tussen de left- en right-bound geen snijpunt ligt, meldt hij dat netjes.
Omdat het moeilijk is om de gebruiker de formule 'gewoon' te laten invullen en dan
in te lezen en het veel tijd kost om dit in te programmeren, moet de gebruiker de
coëfficiënten zelf invullen. Ook een grafiek plotten kost te veel tijd om te
programmeren. Ik heb dus zelf moeten kiezen wat de gebruiker allemaal mag
invoeren. Alles is in principe mogelijk maar als ik alles neer had moeten zetten was
dat wel heel veel geworden, ook met programmeren. Ik moet namelijk als ik de
gebruiker a x4 laat invoeren, in elke berekening die a keer x 4 gebruiken. Je begrijpt
dat ik als ik de sinus, cosinus, tangens, x5, x6 etc. er bij had gezet, ik wel erg veel
had moeten programmeren. Aangezien de meeste formules niet verder gaan dan x 4,
heb ik het daarbij gelaten
8
Profielwerkstuk Victoria van Tets
Intersect
Uitleg script Intersect
dit script heet intersect
lees waarde a in [staat voor a * x kwadraat in
formule 1]
lees waarde b in [staat voor b * x in formule 1]
lees waarde c in [staat voor c in formule 1]
lees waarde d in [staat voor d * x kwadraat in
formule 2]
lees waarde e in [staat voor e * x in formule 2]
lees waarde f in [staat voor f in formule 2]
lees waarde g in en sla op in l [staat voor leftbound]
lees waarde h in en als op in r [staat voor
rightbound]
lees waarde j in [staat voor j * x tot de derde in
formule 1]
lees waarde k in [staat voor k * x tot de derde in
formule 2]
lees waarde m in [staat voor m * x tot de vierde in
formule 1]
lees waarde n in [staat voor n * x tot de vierde in
formule 2]
g = (r - l) / 10 [g staat voor stapgrootte]
x=l-g
Function intersect() {
a = eval(document.berekening.a.value)
b = eval(document.berekening.b.value)
c = eval(document.berekening.c.value)
d = eval(document.berekening.d.value)
e = eval(document.berekening.e.value)
f = eval(document.berekening.f.value)
l = eval(document.berekening.g.value)
r = eval(document.berekening.h.value)
j = eval(document.berekening.j.value)
k = eval(document.berekening.k.value)
m = eval(document.berekening.m.value)
n = eval(document.berekening.n.value)
g = (r - l) / 10
x=l-g
w = (m * Math.pow((x + g),4) + j *
je stelt een verschilfunctie in, de eerste formule min
Math.pow((x + g),3) + a * Math.pow((x
de tweede formule. Hier berekent hij de waarde van
+ g),2) + b * (x + g) + c) - (n *
de verschilfunctie voor x = x + g. dit doet hij zodat
Math.pow((x + g),4) + k * Math.pow((x
hij later kan kijken of het verschil groter wordt als je
+ g),3) + d * Math.pow((x + g),2) + e *
een stap vooruit gaat.
(x + g) + f)
als de uitkomst negatief is
if (w < 0)
maak hem dan positief [einde van de als]
{w = (-1 * w)}
v = (m * Math.pow(x,4) + j *
Math.pow(x,3) + a * Math.pow(x,2) + b
hier berekent hij de waarde van de verschlifunctie
* x + c) - (n * Math.pow(x,4) + k *
voor x = x
Math.pow(x,3) + d * Math.pow(x,2) + e
* x + f)
als de uitkomst negatief is
if (v < 0)
maak hem dan positief [einde van de als]
{v = (-1 * v)}
zolang de uitkomst van de verschilfunctie (v) groter
do
is dan 1 keer 10 tot de -9, doe:
x = x + g [hij loopt de verschilfunctie langs totdat hij
{x = x + g
het laagste punt heeft gevonden)
als x + g gelijk is aan x [dus de stapgrootte 0 is]
if ((x + g) == x)
zeg dan dat het kruispunt buiten de left en right
{alert("verkeerde left en rightbound " +
bound ligt.
x)
stop [einde van de als]
Return}
w = (m * Math.pow((x + g),4) + j *
Math.pow((x + g),3) + a * Math.pow((x
hij berekent de waarde van de verschilfunctie voor x + g),2) + b * (x + g) + c) - (n *
=x+g
Math.pow((x + g),4) + k * Math.pow((x
+ g),3) + d * Math.pow((x + g),2) + e *
(x + g) + f)
als w negatief is
if (w < 0)
9
Profielwerkstuk Victoria van Tets
maak hem positief [einde van de als]
{w = (-1 * w)}
v = (m * Math.pow(x,4) + j *
Math.pow(x,3) + a * Math.pow(x,2) + b
hij berekent de waarde van de verschilfunctie voor x
* x + c) - (n * Math.pow(x,4) + k *
=x
Math.pow(x,3) + d * Math.pow(x,2) + e
* x + f)
als v negatief is
if (v < 0)
maak hem dan positief [einde van de als]
{v = (-1 * v)}
als x groter dan de rightbound of kleinder dan de
if (x > r || x < l)
leftbound is [dus hij ligt buiten de left en rightbound]
zeg dan dat het kruispunt buiten de left en
{alert('error: het kruispunt ligt buiten de
rightbound ligt
gegeven left en rightbound')
stop [einde van de als]
Return}
als w groter dan v is [dus de x zich verder verwijdert
if (w > v)
van het kruispunt]
als v gelijk is aan 0
{if (v == 0)
zet dan achter " x is" de x
{document.berekening.x.value = x
stop [einde van de tweede als]
Return}
leftbound = x - g [je stelt een nieuwe left-bound,
zodat de x uiteindelijk tussen de left en right bound l = x - g
in zit geklemd]
rightbound = x + g
r=x+g
stapgrootte = (2 *g) / 10
g = ((2 * g) / 10)
x = l - g [je begint weer vanaf het linkerpunt]
x=l-g
als de stapgrootte kleiner dan 0.0000000001 [de
stapgrootte is zo klein terwijl hij nog steeds niet
if (g < 0.00000000001)
dichterbij de 0 komt]
{alert('error: het kruispunt ligt buiten de
zeg dat het kruispunt buiten de left en rightbound
gegeven left en rightbound ' + x + ' ' + g
ligt
+ ' ' + r)
stop [einde van de tweede als]
Return}
ga terug naar het begin van de while
Continue}
einde van de als
}
einde van de zolang als het verschil groter dan 10
While (v > Math.pow(10,-9))
tot de -9 is
[hier wordt het antwoord afgerond] rond x op 9
x = Math.round(x * Math.pow(10,9)) *
decimalen af
Math.pow(10,-9)
schrijf achter " x is" x
Document.berekening.x.value = x
einde van het script
}
Uiteindelijke Resultaat:
<script language="Javascript">
function intersect() {
a = eval(document.berekening.a.value)
b = eval(document.berekening.b.value)
c = eval(document.berekening.c.value)
d = eval(document.berekening.d.value)
e = eval(document.berekening.e.value)
f = eval(document.berekening.f.value)
l = eval(document.berekening.g.value)
r = eval(document.berekening.h.value)
j = eval(document.berekening.j.value)
k = eval(document.berekening.k.value)
m = eval(document.berekening.m.value)
n = eval(document.berekening.n.value)
10
Profielwerkstuk Victoria van Tets
g = (r - l) / 10
x = l - g
w = (m * Math.pow((x + g),4) + j * Math.pow((x + g),3) + a *
Math.pow((x + g),2) + b * (x + g) + c) - (n * Math.pow((x + g),4) + k *
Math.pow((x + g),3) + d * Math.pow((x + g),2) + e * (x + g) + f)
if (w < 0)
{w = (-1 * w)}
v = (m * Math.pow(x,4) + j * Math.pow(x,3) + a * Math.pow(x,2) + b * x
+ c) - (n * Math.pow(x,4) + k * Math.pow(x,3) + d * Math.pow(x,2) + e *
x + f)
if (v < 0)
{v = (-1 * v)}
do
{x = x + g
if ((x + g) == x)
{alert("unknown error" + " " + x)
return}
w = (m * Math.pow((x + g),4) + j * Math.pow((x + g),3) + a *
Math.pow((x + g),2) + b * (x + g) + c) - (n * Math.pow((x + g),4) + k *
Math.pow((x + g),3) + d * Math.pow((x + g),2) + e * (x + g) + f)
if (w < 0)
{w = (-1 * w)}
v = (m * Math.pow(x,4) + j * Math.pow(x,3) + a * Math.pow(x,2) + b * x
+ c) - (n * Math.pow(x,4) + k * Math.pow(x,3) + d * Math.pow(x,2) + e *
x + f)
if (v < 0)
{v = (-1 * v)}
if (x > r || x < l)
{alert('error: het kruispunt ligt buiten de gegeven left en
rightbound')
return}
if (w > v)
{if (v == 0)
{document.berekening.x.value = x
return}
l = x - g
r = x + g
g = ((2 * g) / 10)
x = l - g
if (g < 0.00000000001)
{alert('error: hhet kruispunt ligt buiten de gegeven left en rightbound
' + x + ' ' + g + ' ' + r)
return}
continue}
}
while (v > Math.pow(10,-9))
x = Math.round(x * Math.pow(10,9)) * Math.pow(10,-9)
document.berekening.x.value = x
}
</script>
11
Profielwerkstuk Victoria van Tets
Priemgetallen
Over Priemgetallen
Een priemgetal is een getal dat alleen als het door 1 of zichzelf wordt gedeeld, een
geheel getal als uitkomst geeft. Priemgetallen zijn als het ware unieke getallen. Er
zijn dan ook wiskundige stellingen die betrekkingen hebben op priemgetallen. Ik zal
hieronder een van die stellingen, de stelling van Euphledices, bewijzen:
Zijn er oneindig veel priemgetallen? Dit zou je denken aangezien er
oneindig veel getallen zijn maar kan je dit bewijzen?
Dit zal ik bewijzen door aan te tonen dat de stelling dat er maar een gelimiteerd
aantal priemgetallen is onjuist is en daardoor tot een tegenspraak leidt.
Allereerst zal ik de begrippen die ik in mijn bewijzen zal gaan gebruiken toe lichten:
Deler: Als een getal door een van zijn delers gedeeld wordt is de uitkomst een
geheel getal.
Echte deler: een deler die niet 1 is of het getal zelf
Priemdeler: een deler dat ook een priemgetal is
Ten tweede zal ik de stellingen waar ik gebruik van ga maken bewijzen.
Stelling 1: Ieder geheel getal a ≥ 2 heeft minstens één priemdeler. (Een priemdeler
is een priemgetal waar een getal door deelbaar is. Voorbeeld: 20 is deelbaar door 5).
Bewijs:
De kleinste deler (we noemen deze d en d>1) van een getal x is een priemgetal.
Stel d is geen priemgetal  d = d1 * d2 en 1<d1<d
Dan zou d1 ook een deler moeten zijn van x, maar d was juist de kleinste deler van
x.
Oftewel de stelling d is geen priemgetal is onjuist, dus d is wel een priemgetal  de
kleinste deler van een getal is altijd een priemgetal oftewel elk getal heeft een
priemdeler
Stelling 2: Als een getal x een deler is van een getal a en datzelfde getal x een deler
is van een getal b, is x ook een deler van a + b.
immers: F
a=c*x
b=d*x
 a + b = c * x + d * x = (c + d) * x
Dan zal ik nu de stelling `er zijn oneindig veel priemgetallen' gaan bewijzen.
Stel er is maar een gelimiteerd aantal priemgetallen:
Stel er zijn r priemgetallen. Ik noem de priemgetallen p1, p2, p3 … pr. P = p1 * p2 *
p3 … * pr en Q = P + 1. Q heeft dan minstens één priemdeler want alle getallen
hebben priemdelers (Stelling 1). Deze priemdeler moet wel een van de getallen p1,
p2, p3 … pr zijn want dat zijn alle priemgetallen. We noemen de priemdeler van Q pi.
Pi is dan ook een deler van P want P = p1 * p2 * p3 … * pr. Volgens stelling 2 is pi
12
Profielwerkstuk Victoria van Tets
dan ook een deler van Q - P = P + 1 - P = 1. Maar pi kan geen deler van 1 zijn want
pi is een priemgetal en priemgetallen zijn altijd groter dan 1.
Conclusie: de aanname dat er maar een gelimiteerd aantal priemgetallen zijn leidt
tot een tegenstrijdigheid en is daarom onjuist. Dit betekent dat er niet een
gelimiteerd aantal priemgetallen is, met andere woorden er zijn oneindig veel
priemgetallen.
De eenvoudigste manier om een reeks priemgetallen te vinden is om 1 t/m 400 op te
schrijven. Streep vervolgens de veelvouden van 2 weg, de veelvouden van 3, etc.
Dan hou je alle priemgetallen t/m 400 over.
[Er is een site waar 400 getallen staan. Als je op de 2 klikt verdwijnen alle getallen
deelbaar door 2 etc. http://www.faust.fr.bw.schule.de/mhb/eratosiv.htm]
Dit duurt echter een tijdje. Als je zelf zou willen controleren of een getal een
priemgetal is, moet je je getal delen door 2, 3, 4, 5, 6 etc. Je kan echter beter delen
dooor 2, 3, 5, 7, 11 etc. [priemgetallen]; immers als een getal door 6 deelbaar is is
het ook door 2 deelbaar -> dan zou je het al gemerkt hebben. Stel je hebt het getal
71. Dan deel je het door 2, 3, 5, 7 [ je deelt totdat het getal waardoor je het wil
delen groter is dan de wortel van [in dit geval] 71 = 8,43 -> je deelt tot 8 maar 8 is
geen priemgetal -> je deelt tot 7]. De uitkomst is geen geheel getal -> 71 is een
priemgetal.
Als je met de computer/grafische rekenmachine een programma maakt dat
controleert of een getal een priemgetal is, en je deelt het door 1, 2, 3, 4 etc. , dan
duurt dit nogal lang. Desondanks zijn de meeste priem scripts zo gemaakt. Ik wilde
het echter anders doen. Als je de pagina van Priemgetallen laad, berekent hij
automatisch de eerste 150 priemgetallen en slaat deze op in de lijst "priemgetallen".
Als je vervolgens een priemgetal invult, zal hij dit eerst gaan delen door de eerste
150 priemgetallen uit de lijst. Ik heb voor 150 priemgetallen gekozen omdat ik niet
wilde dat de pagina langzamer dan normaal laadde. De eerste 150 priemgetallen kan
hij vrij snel uitrekenen zonder dat de pagina langer laadt dan normaal.
Als je getal echter groter dan het kwadraat van het 149ste priemgetal [857 2] [dus
734449] is, zal hij vervolgens op de trage manier overschakelen; je getal wordt
vanaf het 149ste priemgetal [857] gedeeld door 858, 859 etc. De meeste getallen
die ingevoerd worden zijn kleiner dan 734449, dus dit script is veel sneller dan de
andere scripts.
13
Profielwerkstuk Victoria van Tets
Priemgetallen
Uitleg script Priemgetallen
Normaal
In Script
Dit onderstaande script voert de computer uit als je de
pagina laadt. Het slaat de eerste 150 priemgetallen op in
een lijst "priemgetallen"
dit is het script "start"
function start() {
maak een nieuwe lijst die je priemgetallen noemt.
priemgetallen = new Array()
het eerste getal van de lijst is 1
priemgetallen[1] = 1
het tweede getal van de lijst is 2
priemgetallen[2] = 2
a = 3 [a symboliseert het zoveelste getal in de lijst]
a=3
x = 3 [x symboliseert het getal]
x=3
y = 2 [y symboliseert het getal waar het getal door
y=2
wordt gedeeld]
terwijl het aantal getallen in de lijst kleiner is dan 150,
do
moet je doen
terwijl x / y geen even getal is, moet je doen
{do
y is y plus 1 [het getal waardoor x gedeeld wordt wordt
{y = y + 1
groter]
als de wortel van x kleiner is dan y [dus x een
if (Math.sqrt(x) < y)
priemgetal is]
stop dan de x in de priemgetallen lijst als het a-de
{priemgetallen[a] = x
nummer
tel 1bij a op [want de lijst is 1 groter geworden]
a=a+1
tel 1 bij de x op
x=x+1
y = 2 [want je moet weer overnieuw beginnen met delen
y = 2}
omdat je nu een andere x hebt]
}
einde van wat je moest doen terwijl x / y geen even
while( x % y != 0)
getal is
tel 1 bij x op [je komt hier namelijk terecht als x geen
x=x+1
priemgetal was, dus a blijft hetzelfde]
y=2
y=2
}
einde van wat je moest doen als a kleiner dan 150 was while (a != 150)
einde van het script waarmee je de eerste 150
}
priemgetallen berekent.
tonderstaand script controleert of het ingevoerde getal,
x, wel of niet een priemgetal is
dit is het script "priem"
function priem() {
x=
x is wat de bezoeker voor x heeft ingetypt
eval(document.berekening.x.value)
a [het a-de nummer van de lijst] is 1
a=1
y = het a-de getal uit de lijst priemgetallen [hij roept de
y = priemgetallen[a]
getallen uit lijst a aan en probeert x daardoor te delen]
terwijl x / y geen even getal is
do
tel 1 bij a op [hij pakt het volgende getal uit de lijst]
{a = a + 1
als a groter dan of gelijk is aan 150 [hij heeft alle
if (a >= 150)
getallen uit de lijst gebruikt]
tel 1 bij y op [vanaf 150 deelt hij x door 150, 151, 152
{y = y + 1}
etc.]
anders [dus als a kleiner is dan 150]
else
y = het a-de nummer uit de lijst priemgetallen
{y = priemgetallen[a]}
14
Profielwerkstuk Victoria van Tets
als de wortel van x kleiner is dan y
Geef een alert met x en de tekst “is een priemgetal”
stop met het lopen van dit script [het resultaat is
namelijk bereikt]
einde van wat je moet doen terwijl x / y geen even getal
is [nu komt dus wat je moet doen als x /y WEL een even
getal is, dus als x geen priemgetal is]
Geef een alert met x en de tekst “is geen priemgetal
want” en x en “is deelbaar door” en y
if (Math.sqrt(x) < y)
{alert(x + ‘is een priemgetal’)
return}}
while (x % y != 0)
alert(x + ‘ is geen priemgetal want ‘
+ x + ‘ is deelbaar door ‘ + y)}
Uiteindelijk resultaat:
<script language="JavaScript">
function start() {
priemgetallen = new Array()
priemgetallen[1] = 1
priemgetallen[2] = 2
a = 3
x = 3
y = 2
do
{
do
{y = y + 1
if (y == x)
{priemgetallen[a] = x
a = a + 1
x = x + 1
y = 2}
}
while (x % y != 0)
x = x + 1
y = 2
}
while (a != 150)
}
function priem() {
x = eval(document.berekening.x.value)
a = 1
y = priemgetallen[a]
do
{a = a + 1
if (a >= 150)
{y = y + 1}
else
{y = priemgetallen[a]}
if (Math.sqrt(x) < y)
{alert(x + " is een priemgetal")
return}
}
while (x % y != 0)
alert(x + " is geen priemgetal want " + x + " is deelbaar door " + y)
}
</script>
15
Profielwerkstuk Victoria van Tets
Vergelijking met twee onbekenden
Over vergelijking met twee onbekenden
Vergelijking met twee onbekenden komt tegenwoordig niet meer zo veel voor bij
wiskunde B op school maar is toch handig en bovendien makkelijk om mee te
beginnen (om te experimenteren met javascript).
Het gaat om het stelsel ax + by = c en dx + ey = f.
ax + by = c
dx + ey = f
Om achter x en y te komen maak je eerste de coëfficiënten van x aan elkaar gelijk
zodat je deze van elkaar af kan trekken. Je maakt de coëfficiënten aan elkaar gelijk
door de formules met een geschikte factor te vermenigvuldigen.
vervolgens maak je de x-waardes gelijk aan elkaar. Ik noem de
vermenigvuldigingsfactor v.
vax + vby = vc
dx + ey = f
Je hebt v zo gekozen, dat va = d.
dan kan je de x-waardes van elkaar af trekken [want va - d = 0]
vby - ey = vc - f
hierdoor kan je y uitrekenen:
(vb-e)y = vc-f
y = (vc-f)/(vb-e)
en daarna kan je x uitrekenen want je weet dan ook y
 x = (c - by) / a
Dit kan je ook met de grafische rekenmachine berekenen met zogenaamde matrices.
Het enige verraderlijke van vergelijkingen met meerdere onbekenden is dat je zo
veel mogelijkheden heb hoe je het kan berekenen maar dat velen niet gelden omdat
het product 0 is. Aangezien de computer/grafische rekenmachine dat zelf niet
bedenkt [en dan een error geeft of niets doet] moet je talloze zogenaamde if's
programmere. Een if is [de naam zegt het al] een voorwaarde, bijvoorbeeld als x
groter dan 0 is, stop dan [if x >0 {return}]. Je moet zo'n if talloze malen inbouwen
voor alle mogelijkheden. Dit is natuurlijk wel mogelijk maar tijdrovend werk.
Vandaar dat ik het bij een vergelijking met 2 onbekenden gehouden heb. Dit is ook
vrij makkelijk op de grafische rekenmachine te programmeren. Dit heb ik al een keer
gedaan, vandaar dat ik het nog eens wilde doen, maar dan in Javascript.
16
Profielwerkstuk Victoria van Tets
Vergelijking met twee onbekenden
Uitleg vergelijking met twee onbekenden
Ik zal eerst uitleggen hoe dit script in 'programmeertaal werkt':
Normaal:
2x + 5y = 23
6x + 2y = 30
bovenste rij keer 3->allebei 6x
6x + 15y = 69
Rijen aftrekkken
-13y = -39
-39 door -13 delen
y=3
nu is y bekend->kan je x uitrekenen
6x + 2y = 30
6x + 2 * 3 = 30
6x + 6 = 30
6x = 24
x=4
Programmeertaal:
ax + by = c
dx + ey = f
d/a * a + d/a * b = d/a * c
e - d/a * b = f - d/a * c
y = (e - d/a * b) / (f - d/a * c)
dx + ey = f
dx + ey = f
dx + ey = f
dx = f - ey
x = (f - ey) / d
Hieronder uitleg van het script:
dit script heet xy
lees a in
lees b in
lees c in
lees d in
lees e in
lees f in
als a 0 is en d 0 is [dus er geen x is ingevuld]
sla in x de tekst "niet ingevuld" op
y = c/b [want je hebt geen x]
z = c/f [dit om te controleren dat dit gelijk is aan x;
anders is het tegenstrijd]
als y niet z is
geef een alert met de tekst "tegenstrijdig"
sla in y op: "tegenstrijdig"
vul bij "x is" de waarde van x in
vul bij "y is" de waarde van y in
stop met dit script
einde van de als
als b 0 is en e 0 is [dus er geen y in ingevuld]
sla in y de tekst "niet ingevuld" op
sla in x c/a op
z = f/d [dit om te controleren of dit wel gelijk is aan
x; anders is de vergelijking tegenstrijdig]
als x niet gelijk is aan z
geef een alert met de tekst "tegenstrijdig"
sla in x de tekst "tegenstrijdig" op
voer bij "x is" x in
voer bij "y is" y in
stop
einde van de als
17
function xy() {
a = eval(document.berekening.a.value)
b = eval(document.berekening.b.value)
c = eval(document.berekening.c.value)
d = eval(document.berekening.d.value)
e = eval(document.berekening.e.value)
f = eval(document.berekening.f.value)
if (a == 0 && d == 0)
{x = "niet ingevuld"
y=c/b
z=f/e
if (y != z)
{alert('tegenstrijdig!')
y = "tegenstrijdig"}
document.berekening.x.value = x
document.berekening.y.value = y
return
}
if (b == 0 && e == 0)
{y = "niet ingevuld"
x=c/a
z=f/d
if (x != z)
{alert('tegenstrijdig!')
x = "tegenstrijdig"}
document.berekening.x.value = x
document.berekening.y.value = y
return
}
Profielwerkstuk Victoria van Tets
[dit is dus als alles gewoon netjes is ingevuld]
bereken de y [uitleg staat hierboven bij
programmeertaal]
bereken de x [uitleg staat hierboven bij
programmeertaal]
bereken wat x ook zou kunnen zijn door de tweede
vergelijking te gebruiken; als dit niet gelijk is aan x
is de vergelijking tegenstrijdig.
als x niet gelijk aan z is
geef een alert met "te weinig gegevens"
stop
vul bij "x is" x in
vul bij "y is" y in
y = (f - (d * c) / a) / (e - (d * b) / a)
x = (c - (b * y)) / a
z = (f - (e * y)) / d
if (x != z)
{alert('Te weinig gegevens!')
return}
document.berekening.x.value = x
document.berekening.y.value = y
Uiteindelijk Resultaat:
<script language="Javascript">
function xy() {
a = eval(document.berekening.a.value)
b = eval(document.berekening.b.value)
c = eval(document.berekening.c.value)
d = eval(document.berekening.d.value)
e = eval(document.berekening.e.value)
f = eval(document.berekening.f.value)
if (a == 0 && d == 0)
{x = "niet ingevuld"
y = c / b
z = f / e
if (y != z)
{alert('tegenstrijdig!')
y = "tegenstrijdig"}
document.berekening.x.value = x
document.berekening.y.value = y
return
}
if (b == 0 && e == 0)
{y = "niet ingevuld"
x = c / a
z = f / d
if (x != z)
{alert('tegenstrijdig!')
x = "tegenstrijdig"}
document.berekening.x.value = x
document.berekening.y.value = y
return
}
y = (f - (d * c) / a) / (e - (d * b) / a)
x = (c - (b * y)) / a
z = (f - (e * y)) / d
if (x != z)
{alert('Te weinig gegevens!')
return}
document.berekening.x.value = x
document.berekening.y.value = y
}
</script
18
Profielwerkstuk Victoria van Tets
Logboek
verschillende
data
25 - 11 - 2001
Resultaat:
14 - 12 - 2001
12 - 01 - 2002
Resultaat:
13 - 01 - 2002
21 - 01 - 2002
12 - 02 - 2002
20 - 02 - 2002
30 - 03 - 2002
12 - 04 - 2002
13 - 04 - 2002
13 - 04 - 2002
14 - 04 - 2002
15 - 04 - 2002
16 - 04 - 2002
20 - 04 - 2002
21 - 04 - 2002
28 - 06 - 2002
29 - 08 - 2002
02 - 09 - 2002
19
01
03
03
03
03
-
09
10
10
10
10
10
-
2002
2002
2002
2002
2002
2002
Gesprekjes met mijn profielwerkstuk-begeleider [Dhr. Piet]
210 min
Op Internet naar Javascript-Tutorials gezocht
In Javascript een script dat binaire getallen naar decimale getallen
converteert en andersom gemaakt.
Website gemaakt
Op internet gezocht hoe je de wortel uit een getal trekt
Een script van de abc-formule gemaakt
Eerste versie van priem gemaakt
In de bibliotheek gezocht naar meer boeken over javascript
Vergelijking met 2 onbekenden gemaakt + uitleg.
Priem drastisch verbeterd, o.a. door aan het begin de eerste 100
priemgetallen op te slaan.
Aan intersect begonnen om het principe door te krijgen
Doorgegaan met intersect, ditmaal met een left & rightbound >>
helemaal overnieuw begonnen. Ook heb ik het logboek bijgewerkt
[15 min]
Intersect afgemaakt, ook x3 zijn in de formule mogelijk.
Op het internet gezocht naar mogelijkheden om een grafiek te
plotten. Dit is heel erg moeilijk -> lukt niet
Kleine wijziging bij intersect script aangebracht; je kan nu ook x4
invoeren. Ook rond hij nu op 1 decimaal minder af.
Een uitleg bij alle scripts gegeven en sommigen iets ingekort bij
het herzien van de scripts.
Aan Verslag begonnen, op zoek gegaan naar priem-scripts die op
internet staan [0 gevonden]
Verslag deels afgemaakt;alle scripts + uitleg gecontroleerd; bij
elke uitleg het uiteindelijke script erbij gezet
Verslag in Word gemaakt; Inleiding etc. gemaakt zodat ik
maandag 80% op papier heb; dingen afgerond etc.
Fouten verbeterd, kleine dingetjes toegevoegd etc.
Nogmaals fouten verbeterd en deze ook in de website-versie
doorgevoerd.
Een stelling over priemgetallen gezocht; deze stelling grondig
doorgenomen zodat ik hem in mijn eigen woorden uit kan leggen
Fout in mijn stelling verbeterd + naar bewijs gezocht op internet
Verslag nog eens doorgelezen en verbeterd
HTML versie verbeterd
Logboek bijgewerkt
Titelblad gemaakt
Bij printerette afgedrukt en ingebonden
Totaal:
60 min
19
30 min
120 min
30 min
30 min
30 min
210 min
100 min
210 min
180 min
300 min
100 min.
30 min
30 min.
360 min.
360 min
400 min
300 min
100 min
210 min
300 min
100 min
100 min
210 min
30 min
30 min
30 min
4200 min
Profielwerkstuk Victoria van Tets
Conclusie
Mijn doel voor dit profielwerkstuk was:
Programmeer programma’s die je op de GR kan maken en programmeer een
functie van de GR in Javascript.
Dit heb ik gedaan. Ik heb de ABC-formule (die iedereen in zijn GR heeft staan)
geprogrammeerd in Javascript, een binair-decimaal converter en een stelsel
vergelijkingen met twee onbekenden.
De functie van de GR die ik heb geprogrammeerd is Intersect. Ik had het liefste ook
een grafiek erbij willen programmeren maar dit is mij helaas niet gelukt; het bleek te
moeilijk te zijn. Ook was het te moeilijk om de gebruiker ‘gewoon’ de formule in te
laten typen.
Ik vond het programmeren het leukst. Het uitleggen was wat minder leuk omdat het
voor mij vanzelfsprekend leek. Hopelijk valt het toch nog te begrijpen.
Wat ik heb geleerd met dit profielwerkstuk is natuurlijk programmeren in Javascript.
Daarnaast heb ik geleerd hoe de functie Intersect in elkaar zit en hoe je iets moet
uitleggen aan non-informatici.
Al met al vond ik het een leuke opdracht. Dit kwam voornamelijk doordat het een
zelfgekozen onderwerp was. Wat ik iets minder leuk vond was het feit dat je er
officiëel tachtig studielasturen aan moest besteden. Dit was wel een beetje erg veel,
en zorgde ervoor dat je het idee had dat je het profielwerkstuk nooit af zou krijgen.
20
Profielwerkstuk Victoria van Tets
Bronnen
Javascript Tutorial for Programmers
Aaron Weiss
http://www.wdvl.com/Authoring/JavaScript/Tutorial/
JavaScript: Uw blauwdruk voor het maken van dynamische websites
Kelly L. Murdock
Schoonhoven, Academic Service, 2001
Herleiden van de ABC-formule
Dhr. A.J. Ringeling
http://home.tip.nl/users/ajringeling
21