Programmer Guide/Command Reference/INT - Revision history

Toni at 09:49, 26 April 2011

2011-04-26T09:49:31Z

← Older revision		Revision as of 11:49, 26 April 2011
Line 15:		Line 15:
	:* The <code>INT</code> command converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.		:* The <code>INT</code> command converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.
	:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.		:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.
	;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]]		;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]], [[../SEGMENT\|SEGMENT]]
	;Examples:		;Examples:
	#result := int 3.1 // #result is set to 3		#result := int 3.1 // #result is set to 3

Christian at 17:58, 21 April 2011

2011-04-21T17:58:50Z

← Older revision		Revision as of 19:58, 21 April 2011
Line 16:		Line 16:
	:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.		:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.
	;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]]		;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]]


	;Examples:		;Examples:
	#result := int 3.1 // #result is set to 3		#result := int 3.1 // #result is set to 3

193.171.195.48 at 13:05, 21 April 2011

2011-04-21T13:05:30Z

← Older revision		Revision as of 15:05, 21 April 2011
Line 11:		Line 11:
	\|0<BR>warning code		\|0<BR>warning code
	\|}		\|}
			;Description: The ''expression'' will be evaluated numerically, and the result will be converted to an integer whose textual representation is the return value. The calculation itself will be done with floating point accuracy. The same evaluation rules as defined for the [[../NUM\|NUM command]] apply to this command.
	;Description: ~~This statement will cause your expression being evaluated as an integer expression. More precisely, the~~ expression will be evaluated numerically, and the result will be converted to an integer whose textual representation is the return value. The calculation itself will be done with ~~64bit~~ floating point accuracy. The same evaluation rules as defined for the [[../NUM\|NUM command]] apply to this command.
	;Notes:		;Notes:
	:* The <code>INT</code> command converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.		:* The <code>INT</code> command converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.
	:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.		:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.
	;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]]		;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]]
	~~<!-- C.G. 31.3.2011 -->~~

	;Examples:		;Examples:

193.171.195.48 at 13:03, 21 April 2011

2011-04-21T13:03:38Z

← Older revision		Revision as of 15:03, 21 April 2011
Line 12:		Line 12:
	\|}		\|}

			;Description: This statement will cause your expression being evaluated as an integer expression. More precisely, the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation is the return value. The calculation itself will be done with 64bit floating point accuracy. The same evaluation rules as defined for the [[../NUM\|NUM command]] apply to this command.
	This statement will cause your expression being evaluated as an integer expression. More precisely, the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation is the return value. The calculation itself will be done with 64bit floating point accuracy. The same evaluation rules as defined for the [[../NUM\|NUM command]] apply to this command.

	;Notes:		;Notes:
	:* The <code>INT</code> command converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.		:* The <code>INT</code> command converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.
	:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.		:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.
			;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]]
			<!-- C.G. 31.3.2011 -->

	;Examples:		;Examples:
Line 28:		Line 27:
	// compare the preceding example with the following one:		// compare the preceding example with the following one:
	#result := int 3 * int(3.9) // here, #result will be assigned 9 - cool, isn't it?		#result := int 3 * int(3.9) // here, #result will be assigned 9 - cool, isn't it?

	~~;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]]~~
	~~<!-- C.G. 31.3.2011 -->~~

193.171.195.48 at 12:56, 21 April 2011

2011-04-21T12:56:33Z

← Older revision		Revision as of 14:56, 21 April 2011
Line 3:		Line 3:
	!command !!return value !!value of RC		!command !!return value !!value of RC
	\|-		\|-
	\|<code>~~<var>var</var> :=~~ INT <var>expression</var></code>		\|<code>INT <var>expression</var></code>
	\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails		\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails
	\|0<BR>error code		\|0<BR>error code
	\|-		\|-
	\|<code>~~<var>var</var> :=~~ INTCHECK <var>expression</var></code>		\|<code>INTCHECK <var>expression</var></code>
	\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails		\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails
	\|0<BR>warning code		\|0<BR>warning code
Line 13:		Line 13:


	This statement will cause your expression being evaluated as an integer expression. More precisely, the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation ~~will be the string to be assigned to~~ the ~~destination variable~~. The calculation itself will be done with 64bit floating point accuracy.		This statement will cause your expression being evaluated as an integer expression. More precisely, the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation is the return value. The calculation itself will be done with 64bit floating point accuracy. The same evaluation rules as defined for the [[../NUM\|NUM command]] apply to this command.

	;Notes:		;Notes:
	:* The <code>INT</code> ~~statement~~ converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.		:* The <code>INT</code> command converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.
	:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.		:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.

193.171.195.48 at 12:53, 21 April 2011

2011-04-21T12:53:09Z

← Older revision		Revision as of 14:53, 21 April 2011
Line 1:		Line 1:
	{{DISPLAYTITLE:~~{{SUBPAGENAME}}~~}}		{{DISPLAYTITLE:INT, INTCHECK}}
	{\|class="einrahmen"		{\|class="einrahmen"
	!command !!return value !!value of RC		!command !!return value !!value of RC
Line 12:		Line 12:
	\|}		\|}

	The <code>INT</code> statement will cause your expression being evaluated as an integer expression. More precisely (more precisely less wrongly), the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation will be the string to be assigned to the destination variable. The calculation itself will be done with in 64bit floating point, though (see the below examples for what that means).

	If the ~~evaluation fails~~, the ~~return value is~~ the ~~empty~~ string ~~(<nowiki>''</nowiki>) and the error information (code and message) is stored in~~ the ~~variables variables~~		This statement will cause your expression being evaluated as an integer expression. More precisely, the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation will be the string to be assigned to the destination variable. The calculation itself will be done with 64bit floating point accuracy.

	~~Note that the~~ <code>INT</code> statement converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.		;Notes:
			:* The <code>INT</code> statement converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.
			:* In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.

	~~In case of the expression being syntactically ill-formed, an error (<code>INT</code>) or warning (<code>INTCHECK</code>) is reported.~~

			;Examples:
	#result := int 3.1 // #result is set to 3		#result := int 3.1 // #result is set to 3
	#result := int 3.9 // #result is set to 3, too		#result := int 3.9 // #result is set to 3, too

193.171.195.48 at 12:49, 21 April 2011

2011-04-21T12:49:35Z

← Older revision		Revision as of 14:49, 21 April 2011
Line 5:		Line 5:
	\|<code><var>var</var> := INT <var>expression</var></code>		\|<code><var>var</var> := INT <var>expression</var></code>
	\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails		\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails
	\|error code		\|0<BR>error code
	\|-		\|-
	\|<code><var>var</var> := INTCHECK <var>expression</var></code>		\|<code><var>var</var> := INTCHECK <var>expression</var></code>
	\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails		\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails
	\|warning code		\|0<BR>warning code
	\|}		\|}

193.171.195.48 at 12:48, 21 April 2011

2011-04-21T12:48:51Z

← Older revision		Revision as of 14:48, 21 April 2011
Line 1:		Line 1:
	{{DISPLAYTITLE:{{SUBPAGENAME}}}}		{{DISPLAYTITLE:{{SUBPAGENAME}}}}
	{\|class="~~keinrahmen~~"		{\|class="einrahmen"
	!command !!return value !!value of RC		!command !!return value !!value of RC
	\|-		\|-

193.171.195.48 at 12:48, 21 April 2011

2011-04-21T12:48:37Z

← Older revision		Revision as of 14:48, 21 April 2011
Line 1:		Line 1:
	{{DISPLAYTITLE:{{SUBPAGENAME}}}}		{{DISPLAYTITLE:{{SUBPAGENAME}}}}
	<var>var</var> := INT <var>expression</var>		{\|class="keinrahmen"
	<var>var</var> := INTCHECK <var>expression</var>		!command !!return value !!value of RC
			\|-
			\|<code><var>var</var> := INT <var>expression</var></code>
			\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails
			\|error code
			\|-
			\|<code><var>var</var> := INTCHECK <var>expression</var></code>
			\|integer part of evaluated ''expression'' or<BR>empty string if the evaluation fails
			\|warning code
			\|}

	The <code>INT</code> statement will cause your expression being evaluated as an integer expression. More precisely (more precisely less wrongly), the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation will be the string to be assigned to the destination variable. The calculation itself will be done with ~~the~~ point ~~floating~~, though (see the below examples for what that means).		The <code>INT</code> statement will cause your expression being evaluated as an integer expression. More precisely (more precisely less wrongly), the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation will be the string to be assigned to the destination variable. The calculation itself will be done with in 64bit floating point, though (see the below examples for what that means).

			If the evaluation fails, the return value is the empty string (<nowiki>''</nowiki>) and the error information (code and message) is stored in the variables variables

	Note that the <code>INT</code> statement converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.		Note that the <code>INT</code> statement converts the result to an integer by ''truncating'' it. There is no rounding involved, no rounding at all.
Line 17:		Line 28:
	#result := int 3 * int(3.9) // here, #result will be assigned 9 - cool, isn't it?		#result := int 3 * int(3.9) // here, #result will be assigned 9 - cool, isn't it?

	See also: [[~~Programmer Guide/Command Reference~~/NUM\|NUM~~]] ([[Programmer Guide/Command Reference/NUMCHECK\|~~NUMCHECK]]), [[~~Programmer Guide/Command Reference~~/EVAL\|EVAL~~]] ([[Programmer Guide/Command Reference/EVALCHECK\|~~EVALCHECK]])		;See also: [[../NUM\|NUM, NUMCHECK]], [[../EVAL\|EVAL, EVALCHECK]]
	<!-- C.G. 31.3.2011 -->		<!-- C.G. 31.3.2011 -->

Christian at 11:39, 31 March 2011

2011-03-31T11:39:27Z

← Older revision		Revision as of 13:39, 31 March 2011
Line 1:		Line 1:
	{{DISPLAYTITLE:{{SUBPAGENAME}}}}		{{DISPLAYTITLE:{{SUBPAGENAME}}}}
	<var>var</var> := INT <var>expression</var>		<var>var</var> := INT <var>expression</var>
	var>var</var> := INTCHECK <var>expression</var>		<var>var</var> := INTCHECK <var>expression</var>

	The <code>INT</code> statement will cause your expression being evaluated as an integer expression. More precisely (more precisely less wrongly), the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation will be the string to be assigned to the destination variable. The calculation itself will be done with the point floating, though (see the below examples for what that means).		The <code>INT</code> statement will cause your expression being evaluated as an integer expression. More precisely (more precisely less wrongly), the expression will be evaluated numerically, and the result will be converted to an integer whose textual representation will be the string to be assigned to the destination variable. The calculation itself will be done with the point floating, though (see the below examples for what that means).