topic Re: Use of real types can result in precision problems in Libraries & objects

Use of real types can result in precision problems

Anonymous — Sun, 28 Aug 2005 12:51:24 GMT

I have tried to do some GDL editing and have encountered a script problem under the folowing message:
"Use of real types can result in precision problems at line ..."

What does this mean?
I assume "real types" are normal numbers like 0, 1,2, 3, etc.
Can someone explain the origin of this kind of warning message?

Re: Use of real types can result in precision problems

TomWaltz — Sun, 28 Aug 2005 14:30:47 GMT

It means that you are using a statement something like:

IF realNumber = 6 THEN

Where this could cause problems if is reaNumber is not actually 6, but is 6.0000001 or 5.9999999. Since it's a real number, that's a perfectly real possibility. Is that were the case, realNumber <> 6, even though it is so close no one could tell the difference.

There was a "preferred method" on this somewhere, in checking if a real number was within a certain range of the preferred value, but I cannot seem to find it.

Re: Use of real types can result in precision problems

Anonymous — Sun, 28 Aug 2005 15:51:25 GMT

Jaime wrote:
I have tried to do some GDL editing and have encountered a script problem under the folowing message:
"Use of real types can result in precision problems at line ..."

Jaime, the question was discussed in this thread
http://archicad-talk.graphisoft.com/viewtopic.php?t=4677&start=0

additional info here
http://download.graphisoft.com/ftp/techsupport/documentation/developer_docs/BasicLibraryDoc/LibDevGuide/TechnicalStandards.html#title31

Re: Use of real types can result in precision problems

Anonymous — Sun, 28 Aug 2005 20:05:30 GMT

Olivier wrote:
Jaime, the question was discussed in this thread
http://archicad-talk.graphisoft.com/viewtopic.php?t=4677&start=0

additional info here
http://download.graphisoft.com/ftp/techsupport/documentation/developer_docs/BasicLibraryDoc/LibDevGuide/TechnicalStandards.html#title31

OOPpss! I did not noticed that discussion!
Sorry for the incovenience and thank you for your kind reply!

Re: Use of real types can result in precision problems

Anonymous — Mon, 29 Aug 2005 01:00:49 GMT

I was reading "GDL Technical Standards 2"
about this precision issue and read these statements.

"Until ArchiCAD 9, there was only one numeric type, floating point number. You had the possibility to distinguish between some dimension types, but all of them were represented as 'real' numbers.

From ArchiCAD 9 on, the integer inner type was introduced. In connection with the parameter types, the current state is the following: "

What is "integer inner type" ?
I don't see any new parameter types.
In fact, the more times I read these two sentences
the less I understand them.
The first statement I don't understand because there are
two numeric types, integer and floating point.

Comments anyone ?
Peter Devlin

Re: Use of real types can result in precision problems

Frank Beister — Mon, 29 Aug 2005 06:27:17 GMT

When I read the AC9 documentation I thought, that we are getting real different numeric types. But it seems for me variables are only real integer, if one does not use them in floating point operations. Is that right?
I ever deplored, that all numeric types behave as their declaration only in the parameter list and not inside the script.

In fact, the more times I read these two sentences the less I understand them.

So do I.

The first statement I don't understand because there are two numeric types, integer and floating point.

No. I don't think it means there are two numeric types. It means: There are two types: string and numeric. And numeric is always floting point.

And as I understand the technical standards a numeric type is from AC9 on as long an integer type, as you don't use it in a way it receives a floating point result. I don't see, that this makes things better.

Re: Use of real types can result in precision problems

Anonymous — Mon, 29 Aug 2005 19:17:48 GMT

Hello Frank,
You say in your post:
"No. I don't think it means there are two numeric types. It means: There are two types: string and numeric. And numeric is always floting point."

Is it not true that length, angle, and real number are floating point type
while integer, boolean, material, line type and fill pattern are integer type and text, of course, is a character type or, as you say, string type.

Though Integer is numeric, it is clearly not a floating point because
you are not allowed to type decimal values in the integer field.
Therefor there are two numeric types integer and floating point.
Is this not so ?

You say:
"I ever deplored, that all numeric types behave as their declaration only in the parameter list and not inside the script."
Are you saying that you wish GDL should require in a variable declaration
what the data type is for that variable ?
I always wondered how GDL could function without this.
Peter Devlin

Re: Use of real types can result in precision problems

Frank Beister — Tue, 30 Aug 2005 00:24:00 GMT

You have to differ between parameters (out of the parameter list) and variables. When a script is started for each parameters will be set a variable. And this can be string (one type) or real (floating point, one type). Try Debugger in edit menu and list all available variables. You will see. That's all ... 'till nine. Since nine it should give real integers. But I have not found any kind of statement to declare them. As I understand the technical standards, variables are as long from type integer, as long you just do integer operations with them (add, subtract, booleans etc.). In the moment you do an operation, which gives a floting point result (e.g. 2+5*PI/1.75) they change back to floating point.

All other parameters, for which it makes no sense, that they are floats, can have a fraction part too .

Define a new pen in the parameter list. Named "CheckPen" try this in 2D-Script:

pen CheckPen
rect2 0,0,0.5,0.5
CheckPen=Checkpen+1.7
pen CheckPen
text2 0,0,CheckPen

In some cases it's very helpful, but if comparations as IF A=12 THEN ... need so horrible constructions as described in tech standards I would prefer to have a basic set of types as string, real, integer, double integer and binary.

Re: Use of real types can result in precision problems

Frank Beister — Tue, 30 Aug 2005 00:33:38 GMT

Though Integer is numeric, it is clearly not a floating point because
you are not allowed to type decimal values in the integer field.
Therefor there are two numeric types integer and floating point.
Is this not so ?

No, it isn't. As I described before: The parameter list limitations are nothing else than an input mask.

The Plan-Dump shows, that they are stored without fraction part, but the become floating point, when script is running.

SYMBOL 3 {
"Test.7" 86 1 " " 0 "0. Geschoß " 0
"demo_object"
9.7686 0.0347 0.0000 0.00°
1.000000 1.000000
0 0
29
8
"A" 1.0000
"B" 0.2000
"Typ" "Flach"
"D" 2.5000
"penH" 64
"penB" 5
"zzyzx" 0.0000
0.000000 0.000000

PROPERTIES 3 {
}
}

Re: Use of real types can result in precision problems

Anonymous — Tue, 30 Aug 2005 02:48:58 GMT

Hello Frank,
I did what you suggested and you are absolutely right !
When the script is run the the integer variables are floating point.
I wonder why the ruse or as you say "input mask".

You say:
"As I understand the technical standards, variables are as long from type integer, as long you just do integer operations with them (add, subtract, booleans etc.). In the moment you do an operation, which gives a floting point result (e.g. 2+5*PI/1.75) they change back to floating point."

Another quote from "GDL Technical Standards 2" might explain this.
"GDL variables still don't require type definition, the type is determined
during the interpretation from the value to be loaded into the variable."
Which is exactly what you observed and stated above.

You said:
"but if comparations as IF A=12 THEN ... need so horrible constructions as described in tech standards I would prefer to have a basic set of types as string, real, integer, double integer and binary."

I completely agree, especially now after what you demonstrated to me.
It seems like GS is trying to preserve this no type declaration required "feature" by suggesting these "horrible constructions".

Thank you for showing me the "input mask"
Peter Devlin
P.S.
I still wonder what is "integer inner type"

Re: Use of real types can result in precision problems

Frank Beister — Tue, 30 Aug 2005 06:11:54 GMT

I still wonder what is "integer inner type"

I think they mean: no declaration requiered, declared inside (=inner) the compiler/interpreter as integer by usage.

But thats awful, because you have no control to proof, if your script does anwhere something to discard the integer state of a variable.

Re: Use of real types can result in precision problems

Oleg — Tue, 30 Aug 2005 08:03:43 GMT

Peter wrote:
Comments anyone ?
Peter Devlin

Just IMHO.

There are two stuffs: a variable(parameter) and value.
A variable has a name and value. A variable has type and value has
type, but it is not identical. A type of value is an internal type,
type of representation. A variable from point of view GDL on former
can have type of number ( both integer and floating ) and string as we
can not find out it by GDL ( see VARTYPE ).
So, 9 has introduced internal distinction of types of values for
numbers on integer and floating, like number subtype.
( May be for more effective calculations, I do not know. )
I think, that the internal GDL engine uses this type information in
expressions. I guess it keeps the integer type while possible and will
internally convert type to floating in mixed type expressions.
So I think, that we can use comparisons safely:
IF ivar = 12
If we are sure, that "ivar" has integer value.

Re: Use of real types can result in precision problems

Frank Beister — Tue, 30 Aug 2005 08:17:40 GMT

If we are sure, that "ivar" has integer value.

Yes. If we are shure. So we have to be aware that it does not become floating point.

But mostly we will not program the change intended. We can not proof, if it has happened accidentally.

I book this feature under "nice for the compiler, not realy helpful for me". 😉

Re: Use of real types can result in precision problems

Frank Beister — Tue, 30 Aug 2005 08:26:06 GMT

Even the debugger doesn't show, if its integer or floating point.

BTW. The debugger just displays as many decimals as adjusted in the general settings for dialogs. It would be more helpful to give us the full or individual selectable precision. As one can see in the plan dump posted before AC/GDL works internal with more decimal places than we can see in the dialogs.

Re: Use of real types can result in precision problems

Oleg — Tue, 30 Aug 2005 08:55:57 GMT

F. wrote:
[Yes. If we are shure. So we have to be aware that it does not become floating point.

But mostly we will not program the change intended. We can not proof, if it has happened accidentally.

As far as I remember, AC9 shows a warning of it at script checking.
I do not see a good way to avoid mistakes like this.
For example in strong typed languages C/C++ ( a type of each variable is declared ), I can use the similar mixed type comparison too.
It will be valid ( compiler may generate a warning, but it is not language error ).

Unfortunately there are a lot of things in GDL where possible to be mistaken.
For example, all variables are global - it is awful.

Re: Use of real types can result in precision problems

Ed_Brown — Tue, 30 Aug 2005 13:28:30 GMT

Hello everybody,

We will soon be updating the Technical Standards document. I must agree the original text was not too clear. Hopefully the below makes a bit more sense.

++++++++++++++++++
Before ArchiCAD 9 all numeric values were stored internally as floating point values. This meant that integer values were imprecisely stored. From ArchiCAD 9 integers and hence GDL parameter types that are best described with integers are correctly stored internally as integers.

GDL types internally stored as an Integer
Integer
Boolean
Material
Line type
Fillpattern
Pencolor
Intensity (Light)

GDL types internally stored as a Floating-point
Length
Angle
Real
RGB Color component (Light)

GDL variables still don't require type definition, the type is determined during the interpretation from the value to be loaded into the variable. The output of numeric operators now have a type. You should consult the GDL Manual for this information..

The programmer can safely compare integer types with the equality operator. In fact, from ArchiCAD 9 warnings are now issued, if a programmer tries to directly compare floating point values with integer values using the equality operator. For equality-comparisons of floating-point numbers use a small epsilon value meaning the precision of the comparison. For equality-comparisons of a floating-point number and an integer use the round_int function.

Below some sample methods of testing for equivalence between different numeric types are described:
+++++++++++++++++

Hope this is helpful
Ed

Re: Use of real types can result in precision problems

Anonymous — Tue, 30 Aug 2005 20:54:17 GMT

Thank you Ed.
That is very helpfull.
Peter Devlin