Questions about enhancement and Correction to Java OpenJDK Floating Point?

[Remi Forax]

----- Original Message -----
> From: "A Z" <poweruserm at live.com.au>
> To: "core-libs-dev" <core-libs-dev at openjdk.java.net>
> Sent: Monday, March 14, 2022 7:49:04 AM
> Subject: Questions about enhancement and Correction to Java OpenJDK Floating Point?

Hi Terry,
if you want to have the same output as C, instead of println() use printf().

In your example, using
  out.printf("%f\n", c);

prints
  0.010000

  0.010000

regards,
Rémi

> To whom it may concern,
> 
> Having noticed
> 
> https://bugs.java.com/bugdatabase/view_bug.do?bug_id=8190947
> https://bugs.openjdk.java.net/browse/JDK-8190991
> 
> and similar, at
> https://community.oracle.com/tech/developers/discussion/4126262/big-issue-with-float-double-java-floating-point
> 
> I have been referred on to the core-libs-dev area.
> 
> The software development company I represent wishes to keep its name
> confidential,
> and no-mentioned, at this time.
> 
> A number of us at our end have found that floating point and StrictMath
> arithmetic
> on both float and double does not result in range accuracy, but produces
> denormal
> and pronormal values.
> 
> We are aware of the Java Language Specification, and IEEE 754 specifications,
> to these issues, but are still finding that they are not the most relevant or
> great issue.
> 
> While we are aware of the BigDecimal and BigInteger workarounds, and
> furthermore, the calculator class including big-math
> https://github.com/eobermuhlner,
> we are finding in the development, debugging, and editing of our Java programs,
> that using other classes to operate and exchange for the lack of range accuracy
> from float,
> double and java.lang.StrictMath, that we are getting bogged down with what turns
> into
> more inferior software.  The known and available workaround approaches are
> becoming
> stop-gap measures, perforcedly put in place, while introducing other problems
> into OpenJDK or Java software that don't have any particular, immediate,
> solutions.
> 
> Substituting float and double data in and out of BigDecimal and BigInteger
> produces
> source code which is much messier, complicated, error prone, difficult to
> understand
> and to change, is definitely slower, and is an inferior substitute when float
> and double are more than enough in the overwhelming majority of corresponding
> cases.
> This is particularly showing up in 2D and 3D Graphics software, by the default
> OpenJDK Libraries, but also through JMonkeyEngine 3.5.
> 
> Possessing the option to immediately deal with the precondition, postcondition
> and field types of float and double is far superior and more than ideal.
> All this is before the massive advantage of being able to use operators,
> but the change case becomes overwhelming when along a range accurate,
> double (or maybe float, also) supporting Scientific Calculator class.
> 
> If I want to discuss (at least OpenJDK) change in this area, I have
> been pointed to the core-libs area, by one of the respondents
> of the article:
> 
> https://community.oracle.com/tech/developers/discussion/4126262/big-issue-with-float-double-java-floating-point.
> 
> Is there anyone here, at core-libs-dev, who can point
> me in a better Oracle or OpenJDK direction, to discuss further
> and see about Java float and double and StrictMath floating point
> arithmetic denormal and pronormal values being repaired away
> and being made range accurate for all evaluation operations
> with them?
> 
> Certainly since other languages already have, that are open source
> and open resource file ones.  It is a mathematical fact that, for
> consistent, necessary and even fast term, 10% of 10% must
> always precisely be 1%, and by no means anything else.
> 
> Consider these three different language API evaluations,
> using their equivalents of float and double to perform
> the floating point equivalent of that precise evaluation:
> 
> //----------------------------------------------------------
> //The C Language.
> #include <stdio.h>
> 
> int main()
> {
>    printf("Program has started...");
>    printf("\n");
>    printf("\n");
>    double a = 0.1D;
>    double b = 0.1D;
>    double c = a*b;
>    printf("%lf",c);
>    printf("\n");
>    printf("\n");
>    float d = 0.1F;
>    float e = 0.1F;
>    float f = d*e;
>    printf("%lf",f);
>    printf("\n");
>    printf("\n");
>    printf("Program has Finished.");
>    return 0;
> }
> 
> /*
> Program has started...
> 
> 0.010000
> 
> 0.010000
> 
> Program has Finished.
> */
> //----------------------------------------------------------
> //The C++ Language.
> 
> #include <iostream>
> 
> using namespace std;
> 
> int main()
> {
>    cout << "Program has started..." << endl;
>    double a = 0.1D;
>    double b = 0.1D;
>    double c = a*b;
>    cout << endl << c << endl << endl;
>    float d = 0.1F;
>    float e = 0.1F;
>    float f = d*e;
>    cout << f << endl << endl;
>    cout << "Program has Finished.";
>    return 0;
> }
> 
> /*
> Program has started...
> 
> 0.01
> 
> 0.01
> 
> Program has Finished.
> */
> 
> //----------------------------------------------------------
> //The Java Language.
> 
> import static java.lang.System.*;
> public class Start
> {
>    public static void main(String ... args)
>    {
>    out.println("Program has started...");
>    double a = 0.1D;
>    double b = 0.1D;
>    double c = a*b;
>    out.println();
>    out.println(c);
>    float d = 0.1F;
>    float e = 0.1F;
>    float f = d*e;
>    out.println();
>    out.println(f);   out.println();
>    out.println("Program has Finished.");
>    }}
> 
> /*
> Program has started...
> 
> 0.010000000000000002
> 
> 0.010000001
> 
> Program has Finished..
> */
> //----------------------------------------------------------
> 
> In order for java to introduce either default alteration,
> or a compatibility mode alteration, where,
> how and who should I begin to speak with?
> 
> Yours Sincerely,
> 
> Terry Neale