float item with too big value

[GitMensch]

in kill.cob:

        01 DAMAGE-AMOUNT            FLOAT-SHORT                 VALUE 3.40282346638528859811704183484516925E+38.

that's too big for FLOAT-SHORT (and that item is also passed to other programs as FLOAT-SHORT and there subtracted from another FLOAT-SHORT).

I guess that the smaller floating point is enough, in which case its VALUE should be adjusted.

[meyfa]

Can you elaborate, please, why this is too big? It is supposed to be equivalent to Java's Float.MAX_VALUE, which is the amount of damage that Minecraft deals for the /kill command. Java's float is IEEE 754 Binary32, the same as FLOAT-SHORT in COBOL, isn't it?

[GitMensch]

You may confuse that with FLOAT-BINARY-32 type (which most implementations don't have).

From the standard:

The usages float-short, float-long and float-extended define signed numeric data items that are held in
a floating-point format suitable for the machine on which the runtime module is to run. The size and
permitted range of values for these fields is defined by the implementor.

Float-short, which every implementation I know of, equals to the C float.

Without checking the details, here's the answer of "Public AI" (the swiss apertus model) to the question:
Can 3.40282346638528859811704183484516925E+38 be stored in the C “float” data type? Why?

The C float data type has a maximum value of approximately 3.40282346638508059870701485876e+38 (which is approximately 3.40282346638508059870701485876 × 10^38) and a minimum value of approximately 1.175494350825287890625e-38 (which is approximately 1.175494350825287890625 × 10^-38).

The value 3.40282346638528859811704183484516925E+38 is larger than the maximum value that can be represented by the float data type.

Therefore, the value 3.40282346638528859811704183484516925E+38 cannot be stored in the C float data type because it exceeds the maximum value that the float data type can represent.

To represent this value, you would need to use a larger data type, such as double or long double which have a larger range of values, or if necessary, use a library or data type designed for arbitrary-precision arithmetic.

Here is an example of how you might represent and handle such large numbers using double (which can represent numbers up to approximately 1.797693134862315708145274237317043361435 × 10^308):

#include <stdio.h>

int main() {
    double large_number = 3.40282346638528859811704183484516925e+38;  // This will work with double
    printf("%.20f\n", large_number);  // Print it with 20 decimal places for clarity
    return 0;
}

However, note that even with double, you might still run into precision issues if you need to work with numbers that exceed the double range, and for extreme precision, you may need to look into arbitrary-precision libraries or data types such as long double (which may or may not be supported on all systems) or third-party libraries like gmp (GNU Multiple Precision Arithmetic Library) for C.

For example, using long double (if available and supported by your system):

#include <stdio.h>

int main() {
    long double large_number = 3.40282346638528859811704183484516925e+38;  // This will work with long double if supported
    printf("%.20Lf\n", large_number);  // Print it with 20 decimal places for clarity
    return 0;
}

Always verify the capabilities and limitations of your specific system or platform when working with large numbers in C.

If you need to represent and work with extremely large numbers or high precision, consider using libraries designed for arbitrary-precision arithmetic, such as the GMP library or other similar tools, which can handle numbers of arbitrary size and precision.

For example, using the GMP library:

#include <gmp.h>

int main() {
    mpfr_t large_number;
    mpfr_init2(large_number, 2048);  // Allocate space for 2048 bits (adjust as needed)
    mpfr_set_str(large_number, "3.40282346638528859811704183484516925e+38", 10, GMP_RNDN);  // Set the value
    printf("%.20Rf\n", large_number);  // Print it with 20 decimal places for clarity (use appropriate rounding mode)
    mpfr_clear(large_number);  // Clean up
    return 0;
}

Please note that this example uses the GNU Multiple Precision Arithmetic Library (GMP), which needs to be installed and linked against your project, and mpfr is part of the GMP library for floating-point operations.

In summary, while float is not sufficient to store 3.40282346638528859811704183484516925E+38, double can be used with some caution for such values, and for greater precision or larger numbers, consider arbitrary-precision libraries. Always consider the trade-offs between precision, performance, and portability when choosing how to represent and process large numbers.

[GitMensch]

oops, used the wrong button, please reopen the issue