floating point literals

[srvaldez]

if x is declared as double and then assigned 1.0/3.0 the value assigned is single precision, however if 1/3 is assigned then the precision is double
for a beginner this doesn't make sense and can possibly lead to wrong results, are there post-fix operators or symbols that specify the literal precision?
for example in basic you have the # symbol, so in basic to ensure that double precision is meant you could write: x=1#/3#
is there something similar in free pascal?

[KodeZwerg]

Use proper type to get desired type."Double(1.0) / Double(3.0)" should return you a Double. "Double(1.0 / 3.0)" i could imagine works too.

[srvaldez]

I knew that you could use a cast, but having to do that for this simple case is lame

[KodeZwerg]

I knew that you could use a cast, but having to do that for this simple case is lame

What kind of type is "1.0" from your point of view?
From my point of view it is first of all a float and there it begins with the "Single" type, "1.0" does fit into "Single" so compiler does treat it as such.

[srvaldez]

in this case the compiler should be smart enough to treat the literals as double because the variable on the left is of type double

[Zvoni]

in this case the compiler should be smart enough to treat the literals as double because the variable on the left is of type double

No.
Afaik, every programming language goes bottom-up from the smallest Type the literal value fits in, irrespective what's left hand side of the equal-symbol.
The same with "evaluating" if it's a mathematical calculation: It takes the smallest fitting Datatype the result fits in, AND THEN checks if it fit's in/is compatibel to the Datatype left hand side.

The only way is to "hardcast" right hand side, and IIRC, at least one operand should be enough
kinda

Code: Pascal  [Select][+][-]

1. Var d:Double;
2. d:= Double(1.0)/3.0;

[srvaldez]

my question has not been answered, is there a post-fix symbol for number literals?
in C, 1.0 is treated as double, 1.0f is treated as single and similarly for integer types, L for signed 32-bit, UL for unsigned 32-bit and LL and ULL for 64-bit integers

[explainedd]

Unfortunately no typed floating-point literals in Pascal.
The compiler is "smart" and chooses the type with the lowest bit width, where the value is representable.

You can apply the -CF64 compiler option to parse every floating-point literal as 64bit double.

Here is a more detailed explanation:
https://wiki.freepascal.org/IEEE_754_formats

[srvaldez]

thanks explainedd 

[Thaddy]

thanks explainedd 

Or {$MINFPCONSTPREC 64} in your source.

[srvaldez]

thanks Thaddy 
I like it better in the source, just in case you want to share code

[srvaldez]

is there a place to share a work-in-progress code?
I know there's the third party announcement section but my code is beginner type code with a bit of advanced stuff mixed-in

[Thaddy]

is there a place to share a work-in-progress code?
I know there's the third party announcement section but my code is beginner type code with a bit of advanced stuff mixed-in

zip it and attach is enough.

[Bart]

There is already a lenghty discussion about this on fpc ML.
No need to duplicate this here.

Bart

[nanobit]

I knew that you could use a cast, but having to do that for this simple case is lame

Besides of operand types, expressions also have operation precision.
Since FPC3.2,  {$excessprecision on} is supposed to maximize precision of operations.
But there are known bugs about this, for example:
(1.0/5), (1/5.0) are less precise than (1.0/5.0), (1/5).

And if single-type operands can represent certain exact values,
then larger precision in operations can be still appropriate (depends on intentions).