Maple unterminated loop error.

[Flisk]

Iemand een idee waarom onderstaande code een error geeft?

Ik kom er maar niet uit.

L:=[seq(i*0,i=0..12)];

rond:=false;

x:=1;

while(rond=false) do

if(L[x]=1) then rond:=true;

else L[x]:=1; x:=(2*x+11)mod 13;

end if;

end do;

[In physics I trust]

Het heeft niets te maken met shift-enters?

[Flisk]

Heb ik ook gevonden, maar ik kom er nog steeds niet uit.

[Flisk]

Kleine update:

Het moet L[x+1] ipv L[x], maple gaat blijkbaar anders om met indices dan java.

Dat terzijde, op mijn computer en mijn maple versie werkt het nog steeds niet.

Op mijn examen deze morgen werkte diezelfde code gelukkig wel! Dit was een andere maple versie en een computer van de universiteit. Ik schrok toch even toen ik soortgelijke vraag zag staan waarin dit gebruikt moest worden

[In physics I trust]

Werkt hier ook nog steeds niet. Gelukkig deze morgen bij jou wel!

[Flisk]

Okay, ik heb het werkende gekregen ook op mijn maple, de ronde haakjes na while en if zorgde voor de error. Zonder die ronde haakjes werkt het.

Mocht je geïnteresseerd zijn, het ging over een programma om de periode van een pseudorandom generator te bepalen. Ik zou het posten, maar blijkbaar zijn maple worksheets niet toegestaan om te uploaden...

[Xenion]

Je kan evt code plaatsen in [ code] tags of je kan het document eens proberen te zippen.

[EvilBro]

Ik ben wel geinteresseerd in de probleemomschrijving.

[Flisk]

Het gaat over dit type generator: klik

Heb als voorbeeld eentje met periode 100 al ingevuld.

Worksheets (maple 16 en maple classic) zitten in zip.

Eerste stukje code:

Code: Selecteer alles

#Berekenen van de periode van een random generator.

#Geef een modulus, increment, factor en seed in voor de randomgenerator.

modulus := 100:

increment := 7:

factr := 41:

seed := 50:

#Dit gedeelte kijkt wanneer de generator eenmaal rond is en onthoud de seed die voor het eerst herhaald werd.

L := Array(1 .. modulus, fill = 0, datatype = integer):

rond := false:

while  rond=false do

if L[seed+1]=1 then rond:=true;

else L[seed+1]:=1;  seed:=(factr*seed+increment)mod modulus;

end if;

end do;

#Dit gedeelte berekent de periode aan de hand van de nieuwe seed.

L := Array(1 .. modulus, fill = 0, datatype = integer):

periode:=0:

rond := false:

while  rond=false do

if L[seed+1]=1 then rond:=true;

else L[seed+1]:=1;  seed:=(factr*seed+increment)mod modulus; periode:=periode+1;

end if;

end do;

#Print de periode af

periode;

Met dit stukje geneer je het volgende "random" getal, moet na het eerste stuk worden uitgevoerd (kan ook zonder eerste stuk, maar dan moet je de variabelen initialiseren), voer het meerdere malen na elkaar uit voor verschillende getallen:

Code: Selecteer alles

#genereer pseudorandom getal

seed := (factr*seed+increment)mod modulus:

seed;

pseudorandom

(10.41 KiB) 146 keer gedownload

[/url]

[EvilBro]

Als de modulus bekend is dan zou ik eerst de modules aan stappen naar voren in de sequence gaan en dan zoeken totdat ik hetzelfde element tegenkom als waar je je dan bevindt. Dit heeft natuurlijk het nadeel dat je niet weet vanaf welk element de herhaling start. In Haskell:

Code: Selecteer alles

pseudoRandom a b m s = s : pseudoRandom a b m ((a*s + b) `mod` m)  



periodLength m ys = 1 + (length $ takeWhile (/=x) xs)

	where

		(x:xs) = drop m ys

[Flisk]

Die Haskell code is niet echt leesbaar voor mij, enkel ervaring in java/maple hier.

Bedoel je dat je eigenlijk zoekt todat je je allereerste seed tegenkomt?

In de meeste gevallen is dit een goede methode, maar soms kom je die nooit meer tegen.

De periode van dit type generator is maximum gelijk aan de modulus (De randomizer van Java bijvoorbeeld heeft een periode en modulus van 2^31-1).. Elk getal dat je invult heeft namelijk een vaste opvolger (daarom noemt het ook pseudorandom).

Het probleem bij dit soort generatoren is dat je niet gewoon willekeurig een modulus, increment en factor kan kiezen en kan verwachten dat de periode groot zal zijn. Dit merk je als je wat 'speelt' met de increment en factor. Er bestaat wel wiskunde omtrent dit onderwerp maar het is natuurlijk handig om de periode met pc te kunnen checken.

De seed (altijd kleiner dan de modulus bij afspraak) heeft ook van belang bij de lengte van de periode, wel enkel als de periode niet gelijk is aan de modulus.

Bijvoorbeeld

De generator x_n+1=(2x_n+11) mod 13 met seed x₀=2 heeft periode 1, je krijgt dan:

2,2,2,2,2,2,2,2.....

met seed x₀=1 (of gelijk wat behalve 2) krijg je periode=12:

1, 0, 11, 7, 12, 9, 3, 4, 6, 10, 5, 8

Maar er komen nog meer problemen bij kijken, je kan bijvoorbeeld volgende situaties tegenkomen:

1,8,3,9,4,6,5,6,5,6,5,6,5,6,5....

Wat periode 2 heeft. Zoals je ziet kom je het getal 1 (je eerste seed) ook nooit meer tegen.

Daarom heb ik twee loops in mijn code. De eerste kijk vanaf wanneer er herhaling voorkomt.

De tweede begint te tellen.

[EvilBro]

Bedoel je dat je eigenlijk zoekt todat je je allereerste seed tegenkomt?

Ik gooi de eerste m elementen van de reeks weg. Op dat moment zit ik altijd in de loop. Dan is het dus simpelweg zoeken totdat je het nu eerste element vindt. Wat je dan niet weet is na hoeveel elementen je voor het eerst in deze loop zit (omdat het begin in het weggegooide deel kan zitten).

[Flisk]

Aha, zo had ik het nog niet bekeken, dat is korter qua code omdat je dan niet zit te prutsen met arrays etc.

Ik vraag me wel af welke van de twee sneller zou zijn. Jouw code zal minder assignments hebben omdat er geen arrays in voor komen, maar je moet wel altijd minstens een modulus aantal keer het sommetje uitrekenen.

Tegenover mijn code, die extra assignments heeft met arrays, maar wel uit de loop gaat vanaf er herhaling voorkomt.

[EvilBro]

Ik ken geen Maple (als in: "ik heb nog nooit iets in Maple gedaan"), maar ik denk dat ik een loop uit jouw code kan besparen:

Code: Selecteer alles

L := Array(1 .. modulus, fill = 0, datatype = integer):

pos := 1:

while L[seed]=0 do

L[seed]:=pos;

pos:=pos+1;

seed:=(factr*seed+increment)mod modulus;

end do;

period := pos - L[seed];

Dit werkt toch? (kan ik zelf niet testen, want ik heb geen Maple.)

[Flisk]

Ja die werkt ook, het moet wel overal L[seed+1] zijn, eerste element in maple is (vrij verwarrend) 1 en niet 0.

Maar dat is slechts een detail. Het algoritme erachter werkt.