Loops - Revision history

85.144.194.29: /* Manipulating a loop */ Grammar error.

2008-02-29T19:03:41Z

Manipulating a loop - Grammar error.

←Older revision		Revision as of 19:03, 29 February 2008
Line 54:		Line 54:
	If the code inside a loop reaches a [[break]]; statement, the loop is immediately ended. This is particularly useful in the Loop-End loop, because that one has no other way to end the loop and continue code beneath it.		If the code inside a loop reaches a [[break]]; statement, the loop is immediately ended. This is particularly useful in the Loop-End loop, because that one has no other way to end the loop and continue code beneath it.

-	If the code inside a loop reaches a [[continue]]; statement, it executes the possible count- or stepping statement and then continues to the checking of the condition. So in a Repeat-Until loop, it would just skip to the Until() part. Note [[Fenix]] [[0.85]] and before have a bug: the count- or stepping statement does not get ~~executing~~ before jumping to the checking of the condition.	+	If the code inside a loop reaches a [[continue]]; statement, it executes the possible count- or stepping statement and then continues to the checking of the condition. So in a Repeat-Until loop, it would just skip to the Until() part. Note [[Fenix]] [[0.85]] and before have a bug: the count- or stepping statement does not get executed before jumping to the checking of the condition.

	If the loop is run in a specific [[process]], one can influence the execution of the loop, by changing the state of that process, by use of [[signal]]() and [[signals]].		If the loop is run in a specific [[process]], one can influence the execution of the loop, by changing the state of that process, by use of [[signal]]() and [[signals]].

Sandman: /* Manipulating a loop */

2008-01-16T21:06:56Z

Manipulating a loop

←Older revision		Revision as of 21:06, 16 January 2008
Line 54:		Line 54:
	If the code inside a loop reaches a [[break]]; statement, the loop is immediately ended. This is particularly useful in the Loop-End loop, because that one has no other way to end the loop and continue code beneath it.		If the code inside a loop reaches a [[break]]; statement, the loop is immediately ended. This is particularly useful in the Loop-End loop, because that one has no other way to end the loop and continue code beneath it.

-	If the code inside a loop reaches a [[continue]]; statement, it executes the possible count- or stepping statement and then continues to the checking of the condition. So in a Repeat-Until loop, it would just skip to the Until() part. Note ~~that in~~ [[Fenix]] [[0.85]] and before have a bug: the count- or stepping statement does not get executing before jumping to the checking of the condition.	+	If the code inside a loop reaches a [[continue]]; statement, it executes the possible count- or stepping statement and then continues to the checking of the condition. So in a Repeat-Until loop, it would just skip to the Until() part. Note [[Fenix]] [[0.85]] and before have a bug: the count- or stepping statement does not get executing before jumping to the checking of the condition.

	If the loop is run in a specific [[process]], one can influence the execution of the loop, by changing the state of that process, by use of [[signal]]() and [[signals]].		If the loop is run in a specific [[process]], one can influence the execution of the loop, by changing the state of that process, by use of [[signal]]() and [[signals]].

Sandman: /* Manipulating a loop */

2008-01-16T21:06:35Z

Manipulating a loop

←Older revision		Revision as of 21:06, 16 January 2008
Line 54:		Line 54:
	If the code inside a loop reaches a [[break]]; statement, the loop is immediately ended. This is particularly useful in the Loop-End loop, because that one has no other way to end the loop and continue code beneath it.		If the code inside a loop reaches a [[break]]; statement, the loop is immediately ended. This is particularly useful in the Loop-End loop, because that one has no other way to end the loop and continue code beneath it.

-	If the code inside a loop reaches a [[continue]]; statement, it executes the possible count- or stepping statement and then continues to the checking of the condition. So in a Repeat-Until loop, it would just skip to the Until() part.	+	If the code inside a loop reaches a [[continue]]; statement, it executes the possible count- or stepping statement and then continues to the checking of the condition. So in a Repeat-Until loop, it would just skip to the Until() part. Note that in [[Fenix]] [[0.85]] and before have a bug: the count- or stepping statement does not get executing before jumping to the checking of the condition.

	If the loop is run in a specific [[process]], one can influence the execution of the loop, by changing the state of that process, by use of [[signal]]() and [[signals]].		If the loop is run in a specific [[process]], one can influence the execution of the loop, by changing the state of that process, by use of [[signal]]() and [[signals]].

Sandman: /* Example */

2007-07-17T11:12:34Z

Example

←Older revision		Revision as of 11:12, 17 July 2007
Line 84:		Line 84:
	// WHILE		// WHILE
	c = startvalue;		c = startvalue;
-	While(c<endvalue)	+	While(c<=endvalue)
	say("While: " + c);		say("While: " + c);
	c+=incrementvalue;		c+=incrementvalue;
Line 99:		Line 99:

	// FOR		// FOR
-	For(c=startvalue;c<endvalue;c+=incrementvalue)	+	For(c=startvalue;c<=endvalue;c+=incrementvalue)
	say("For: " + c);		say("For: " + c);
	End		End

Sandman: category

2007-05-12T15:37:05Z

Sandman: Loop moved to Loops

2007-05-01T21:46:42Z

Loop moved to Loops

←Older revision

Revision as of 21:46, 1 May 2007

Sandman: overhaul

2007-05-01T21:26:53Z

overhaul

←Older revision		Revision as of 21:26, 1 May 2007
Line 1:		Line 1:
	[[category:reserved]]		[[category:reserved]]
-	~~== Definition ==~~	+	[[category:language]]
-	~~'''LOOP'''~~	+

-	Loop is a reserved word used to create iterations in your code. The terminator for a loop is [[end]]. the statements between these words will get repeated indefinately. There are several types of loops:	+	== Loops ==
		+	'''LOOP-END''', '''WHILE-END''', '''REPEAT-UNTIL''', '''FOR-END''', '''FROM-END'''

-	* the ~~normal~~ [[~~loop~~]]	+	Loops are used to create iterations in your code. The statements between these words will get repeated depending on a condition. There are several types of loops:
-	* [[~~while~~]] loop ~~(terminator: [[~~end~~]])~~	+
-	* [[~~repeat~~]] loop (~~terminator: [[until]]~~)	+	=== Loop ... End ===
-	* [[~~for~~]] loop ~~(terminator:~~ [[~~end~~]])	+	<pre>
-	* [[~~from~~]] ~~loop (terminator: [[end]])~~	+	Loop
		+	// Statements
		+	End
		+	</pre>
		+	The statements will be repeated indefinitely.
		+
		+	=== While ... End ===
		+	<pre>
		+	While(<condition>)
		+	// Statements
		+	End
		+	</pre>
		+	The statements will be repeated while the condition is fulfilled.
		+
		+	=== Repeat ... Until ===
		+	<pre>
		+	Repeat
		+	// Statements
		+	Until(<condition>)
		+	</pre>
		+	The statements will be repeated until the condition is fulfilled.
		+
		+	=== For ... End ===
		+	<pre>
		+	For(<initializer>;<condition>;<counting expression>)
		+	// Statements
		+	End
		+	</pre>
		+	First, the initializer will be executed.<br />
		+	Then the statements will be repeated until the condition is fulfilled.<br />
		+	After each run of the statements, the counting expression is executed.
		+
		+	=== From ... End ===
		+	<pre>
		+	From <variable>=<startvalue> To <endvalue> Step <incrementvalue>
		+	// Statements
		+	End
		+	</pre>
		+	First, the startvalue will be assigned to the variable. Then the statements will be repeated and the incrementvalue added to the variable. When the variable is greater than the endvalue, the loop ends. Note that the incrementvalue ''has'' to be a [[constant]]. The ''Step <incrementvalue>'' is optional.
		+
		+	== Manipulating a loop ==
		+
		+	There are more ways to manipulate a loop, both internally and externally.
		+
		+	If the code inside a loop reaches a [[break]]; statement, the loop is immediately ended. This is particularly useful in the Loop-End loop, because that one has no other way to end the loop and continue code beneath it.
		+
		+	If the code inside a loop reaches a [[continue]]; statement, it executes the possible count- or stepping statement and then continues to the checking of the condition. So in a Repeat-Until loop, it would just skip to the Until() part.
		+
		+	If the loop is run in a specific [[process]], one can influence the execution of the loop, by changing the state of that process, by use of [[signal]]() and [[signals]].

	== Example ==		== Example ==
	<pre>		<pre>
-	~~Process~~ loops()	+	Program loops;
		+	Const
		+	startvalue = 1;
		+	endvalue = 8;
		+	incrementvalue = 2;
		+	End
	Private		Private
-	~~var1 = 999~~;	+	int c;
-	~~var2 = 999;~~	+	End
-	~~var3 = 999;~~	+
-	~~var4 = 999;~~	+
	Begin		Begin
-	~~var1~~ = 0;	+
-	~~while~~(~~var1 <~~= 10)	+	// LOOP
-	~~var1+~~+; ~~//this statement will be processed 10 times~~	+	c = startvalue;
-	~~end~~	+	Loop
-	~~var2~~ = 0;	+	say("Loop: " + c);
-	~~repeat~~	+	c+=incrementvalue;
-	~~var2~~++; ~~//this does exactly the same but the check is at the end of the loop,~~	+	if(c>endvalue)
-	//~~meaning this loop will be processed at least once!~~	+	break;
-	~~until~~(~~var2~~ > 10)	+	end
-	~~for~~(~~var3~~ = 0;~~var3~~ <~~= 10~~;~~var3+~~+)	+	End
-	~~//this does exactly the same as the while loop but you control the incremention~~	+	say("End Loop: " + c);
-	~~//in the header of the loop which makes it more readable~~	+
-	~~end~~	+	// WHILE
-	~~from var4 = 0 to 10 step 1~~	+	c = startvalue;
-	//~~this does exactly the same as the while and the for loop. The '''step 1''' is optional~~	+	While(c<endvalue)
-	~~end~~	+	say("While: " + c);
-	~~loop~~	+	c+=incrementvalue;
-	frame; ~~//the frame statement will be processed forever~~	+	End
-	~~end~~	+	say("End While: " + c);
		+
		+	// REPEAT
		+	c = startvalue;
		+	Repeat
		+	say("Repeat: " + c);
		+	c+=incrementvalue;
		+	Until(c>endvalue)
		+	say("End Repeat: " + c);
		+
		+	// FOR
		+	For(c=startvalue;c<endvalue;c+=incrementvalue)
		+	say("For: " + c);
		+	End
		+	say("End For: " + c);
		+
		+	// FROM
		+	From c=startvalue To endvalue Step incrementvalue
		+	say("From: " + c);
		+	End
		+	say("End From: " + c);
		+
		+	Loop
		+	frame;
		+	End
		+
	End		End
	</pre>		</pre>
		+	Used in example: [[say]](), [[constants]]
		+
		+	In the example, all the loops do the same thing, illustrated by the use of the same constants.

FCR at 15:27, 1 May 2007

2007-05-01T15:27:30Z

←Older revision		Revision as of 15:27, 1 May 2007
Line 1:		Line 1:
	[[category:reserved]]		[[category:reserved]]
-
	== Definition ==		== Definition ==
	'''LOOP'''		'''LOOP'''

FCR at 15:26, 1 May 2007

2007-05-01T15:26:03Z

←Older revision		Revision as of 15:26, 1 May 2007
Line 27:		Line 27:
	var2 = 0;		var2 = 0;
	repeat		repeat
-	var2++; //this does exactly the same but the check is at the end of the loop, ~~thus~~ this loop will be processed at least once!	+	var2++; //this does exactly the same but the check is at the end of the loop,
		+	//meaning this loop will be processed at least once!
	until(var2 > 10)		until(var2 > 10)
	for(var3 = 0;var3 <= 10;var3++)		for(var3 = 0;var3 <= 10;var3++)
-	//this does exactly the same as the while loop but you control the incremention in the header of the loop which makes it more readable	+	//this does exactly the same as the while loop but you control the incremention
		+	//in the header of the loop which makes it more readable
	end		end
	from var4 = 0 to 10 step 1		from var4 = 0 to 10 step 1

FCR at 15:25, 1 May 2007

2007-05-01T15:25:04Z

←Older revision		Revision as of 15:25, 1 May 2007
Line 15:		Line 15:
	<pre>		<pre>
	Process loops()		Process loops()
		+	Private
		+	var1 = 999;
		+	var2 = 999;
		+	var3 = 999;
		+	var4 = 999;
	Begin		Begin
-		+	var1 = 0;
		+	while(var1 <= 10)
		+	var1++; //this statement will be processed 10 times
		+	end
		+	var2 = 0;
		+	repeat
		+	var2++; //this does exactly the same but the check is at the end of the loop, thus this loop will be processed at least once!
		+	until(var2 > 10)
		+	for(var3 = 0;var3 <= 10;var3++)
		+	//this does exactly the same as the while loop but you control the incremention in the header of the loop which makes it more readable
		+	end
		+	from var4 = 0 to 10 step 1
		+	//this does exactly the same as the while and the for loop. The '''step 1''' is optional
		+	end
		+	loop
		+	frame; //the frame statement will be processed forever
		+	end
	End		End
	</pre>		</pre>

←Older revision		Revision as of 15:37, 12 May 2007
Line 1:		Line 1:
-	[[category:~~reserved]]~~	+	[[category:general]]
-	~~[[category:language~~]]	+

	== Loops ==		== Loops ==