COBOL COMP-1 (COMPUTATIONAL-1)

The COMP-1 usage clause in COBOL specifies single precision floating point data storage for scientific and mathematical calculations. This data type enables handling of very large or very small numbers with decimal precision, making it essential for scientific computing and advanced mathematical operations.

Overview and Purpose

COMP-1 provides single precision floating point arithmetic capabilities in COBOL, following the IEEE 754 standard for floating point representation. Unlike fixed-point arithmetic used by regular COMP fields, COMP-1 can represent numbers in scientific notation with a much wider range of values. This makes it ideal for scientific calculations, statistical analysis, engineering computations, and any application requiring decimal fractions or numbers outside the range of standard integer fields.

Basic COMP-1 Declaration

1
2
3
4
01  WS-TEMPERATURE      COMP-1.
01  WS-PRESSURE         COMP-1.
01  WS-SCIENTIFIC-RESULT COMP-1.
01  WS-CALCULATION      COMP-1.

COMP-1 fields are declared without a PIC clause because the format is predetermined by the floating point standard. Each field uses 32 bits (4 bytes) of storage and can represent approximately 7 decimal digits of precision. The temperature and pressure fields can hold scientific measurements, while the result and calculation fields store intermediate and final computation results.

Scientific Calculations

1
2
3
4
5
6
01  WS-RADIUS           COMP-1.
01  WS-AREA             COMP-1.
01  WS-PI               COMP-1 VALUE 3.14159265.
 
MOVE 5.5 TO WS-RADIUS
COMPUTE WS-AREA = WS-PI * WS-RADIUS ** 2

This example demonstrates scientific calculations using COMP-1 fields. The program calculates the area of a circle using the mathematical formula π × r². The COMP-1 format naturally handles the decimal value of π and the fractional radius, performing the exponentiation and multiplication with floating point precision. This type of calculation would be cumbersome with fixed-point arithmetic.

Statistical Analysis Operations

1
2
3
4
5
6
7
8
9
10
01  WS-DATA-POINTS      COMP-1 OCCURS 100 TIMES.
01  WS-SUM              COMP-1 VALUE ZERO.
01  WS-MEAN             COMP-1.
01  WS-COUNT            COMP-1 VALUE 100.
 
PERFORM VARYING WS-INDEX FROM 1 BY 1 UNTIL WS-INDEX > 100
    ADD WS-DATA-POINTS(WS-INDEX) TO WS-SUM
END-PERFORM
 
COMPUTE WS-MEAN = WS-SUM / WS-COUNT

This statistical analysis example shows how COMP-1 fields excel at handling arrays of decimal data and performing aggregate calculations. The floating point format automatically handles the division operation to calculate the mean, producing accurate decimal results without the need for manual scaling or decimal point management that would be required with integer arithmetic.

Tutorial: Building a Scientific Calculator

1
2
3
4
5
01  SCIENTIFIC-CONSTANTS.
    05  WS-PI               COMP-1 VALUE 3.14159265359.
    05  WS-E                COMP-1 VALUE 2.71828182846.
    05  WS-GRAVITY          COMP-1 VALUE 9.80665.
    05  WS-LIGHT-SPEED      COMP-1 VALUE 299792458.0.

1
2
3
4
5
6
7
8
9
10
11
CALCULATE-QUADRATIC-FORMULA.
    *> ax² + bx + c = 0
    COMPUTE WS-DISCRIMINANT = 
        (WS-B ** 2) - (4 * WS-A * WS-C)
    
    IF WS-DISCRIMINANT >= 0
        COMPUTE WS-ROOT1 = 
            (-WS-B + WS-DISCRIMINANT ** 0.5) / (2 * WS-A)
        COMPUTE WS-ROOT2 = 
            (-WS-B - WS-DISCRIMINANT ** 0.5) / (2 * WS-A)
    END-IF.

1
2
3
4
5
6
7
01  WS-DISPLAY-RESULT   PIC -9(3).9(6).
 
MOVE WS-ROOT1 TO WS-DISPLAY-RESULT
DISPLAY "Root 1: " WS-DISPLAY-RESULT
 
MOVE WS-ROOT2 TO WS-DISPLAY-RESULT  
DISPLAY "Root 2: " WS-DISPLAY-RESULT

Practical Exercises

1
2
3
4
5
6
7
8
9
10
11
12
13
01  TEMPERATURE-DATA.
    05  WS-CELSIUS          COMP-1.
    05  WS-FAHRENHEIT       COMP-1.
    05  WS-KELVIN           COMP-1.
 
CELSIUS-TO-FAHRENHEIT.
    COMPUTE WS-FAHRENHEIT = (WS-CELSIUS * 9.0 / 5.0) + 32.0.
 
CELSIUS-TO-KELVIN.
    COMPUTE WS-KELVIN = WS-CELSIUS + 273.15.
 
FAHRENHEIT-TO-CELSIUS.
    COMPUTE WS-CELSIUS = (WS-FAHRENHEIT - 32.0) * 5.0 / 9.0.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
01  PHYSICS-VARIABLES.
    05  WS-MASS             COMP-1.
    05  WS-VELOCITY         COMP-1.
    05  WS-HEIGHT           COMP-1.
    05  WS-KINETIC-ENERGY   COMP-1.
    05  WS-POTENTIAL-ENERGY COMP-1.
    05  WS-MOMENTUM         COMP-1.
 
CALCULATE-KINETIC-ENERGY.
    COMPUTE WS-KINETIC-ENERGY = 0.5 * WS-MASS * (WS-VELOCITY ** 2).
 
CALCULATE-POTENTIAL-ENERGY.
    COMPUTE WS-POTENTIAL-ENERGY = WS-MASS * WS-GRAVITY * WS-HEIGHT.
 
CALCULATE-MOMENTUM.
    COMPUTE WS-MOMENTUM = WS-MASS * WS-VELOCITY.

1
2
3
4
5
6
7
8
9
10
11
12
01  INTEREST-CALCULATION.
    05  WS-PRINCIPAL        COMP-1.
    05  WS-RATE             COMP-1.
    05  WS-TIME             COMP-1.
    05  WS-COMPOUND-FREQ    COMP-1.
    05  WS-FINAL-AMOUNT     COMP-1.
 
CALCULATE-COMPOUND-INTEREST.
    *> A = P(1 + r/n)^(nt)
    COMPUTE WS-FINAL-AMOUNT = WS-PRINCIPAL * 
        ((1 + (WS-RATE / WS-COMPOUND-FREQ)) ** 
         (WS-COMPOUND-FREQ * WS-TIME)).

Advanced COMP-1 Techniques

Precision and Rounding Considerations

1
2
3
4
5
6
7
8
01  WS-PRECISE-CALC     COMP-1.
01  WS-ROUNDED-RESULT   PIC 9(8)V99.
 
COMPUTE WS-PRECISE-CALC = 1.0 / 3.0
*> Results in 0.333333...
 
MOVE WS-PRECISE-CALC TO WS-ROUNDED-RESULT
*> Automatically rounds to 2 decimal places

Be aware of precision limitations when working with COMP-1 fields. Single precision floating point can represent about 7 decimal digits accurately. When converting to display format, automatic rounding occurs based on the target field's precision. For applications requiring higher precision, consider using COMP-2 (double precision) instead.

Error Handling for Mathematical Operations

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SAFE-DIVISION.
    IF WS-DIVISOR NOT = ZERO
        COMPUTE WS-RESULT = WS-DIVIDEND / WS-DIVISOR
    ELSE
        DISPLAY "Error: Division by zero"
        MOVE ZERO TO WS-RESULT
    END-IF.
 
SAFE-SQUARE-ROOT.
    IF WS-NUMBER >= ZERO
        COMPUTE WS-ROOT = WS-NUMBER ** 0.5
    ELSE
        DISPLAY "Error: Cannot take square root of negative number"
        MOVE ZERO TO WS-ROOT
    END-IF.

Implement proper error handling for mathematical operations that can produce invalid results. Check for division by zero, negative square roots, and other mathematical impossibilities before performing calculations. This prevents runtime errors and ensures program stability.