All Your Base in Cobol: Complete Solution & Deep Dive Guide

From Binary to Hexadecimal: Master Number Base Conversion in Cobol

This comprehensive guide explains how to convert numbers between different bases (radix), such as binary, octal, and hexadecimal, using the powerful and structured language of Cobol. We will build a solution from scratch, focusing on the core two-step algorithm: converting to a base-10 intermediate and then to the target base.

The Universal Translator: Why Number Base Conversion is Your Secret Superpower

Ever stared at a cryptic string of ones and zeros in a data dump and wondered what it truly represents? Or perhaps you've seen a color code like #FF5733 and questioned how a computer translates that into a vibrant orange. These are not random characters; they are numbers expressed in different "languages" or bases—binary (base-2) and hexadecimal (base-16), respectively.

For many developers, especially those working with modern, high-level languages, the nitty-gritty of number systems feels like a relic of a bygone era. The language often handles it for you. But for those who work with systems closer to the hardware, or with robust, enterprise-level languages like Cobol, understanding this conversion is not just academic—it's a fundamental skill. It's the key to unlocking data integrity, interfacing with legacy systems, and truly comprehending how computers manipulate information at their core.

This guide demystifies the entire process. We won't just show you the code; we'll walk you through the logic, the mathematics, and the meticulous implementation in Cobol, turning what seems complex into a clear, manageable algorithm. By the end, you'll be equipped to build your own universal number translator, a crucial tool from the kodikra learning path.

What is Number Base Conversion?

Number base conversion is the process of taking a number represented in one positional notation system (like base-10, which we use daily) and representing the exact same quantity in another system (like base-2, which computers use).

The system we're most familiar with is decimal, or base-10. It uses ten unique digits (0-9). The position of each digit determines its value. For example, the number 123 is really (1 * 10²) + (2 * 10¹) + (3 * 10⁰).

Other common bases in computing include:

Binary (Base-2): Uses only two digits, 0 and 1. This is the native language of digital circuits.
Octal (Base-8): Uses digits 0-7. It's a convenient way to represent binary numbers more compactly.
Hexadecimal (Base-16): Uses digits 0-9 and letters A-F to represent values 10-15. It's widely used for memory addresses, color codes, and file permissions.

The core principle, known as positional notation or radix, remains the same across all bases. The value of a digit is its face value multiplied by the base raised to the power of its position.

Why is This Still a Critical Skill for Programmers?

In an age of abstraction, you might wonder why you need to manually implement base conversion, especially in a language like Cobol. The answer lies in control, compatibility, and foundational knowledge.

Modern languages often provide built-in functions that hide the complexity. While convenient, this can create a black box where developers don't understand the underlying process. In contrast, Cobol's design philosophy encourages explicit, precise control over data manipulation. This is vital in mainframe environments where data formats are rigidly defined and must be processed with 100% accuracy.

You'll encounter base conversion in various domains:

Data Representation: Understanding how a 32-bit integer is stored in memory (binary).
Networking: Interpreting IP addresses or network masks.
Cryptography: Working with keys and hashes often represented in hexadecimal.
Legacy System Integration: Reading or writing data from older systems that might use non-standard data encodings or packed decimal formats.

Mastering this algorithm in Cobol not only solves the immediate problem but also deepens your understanding of computer science fundamentals, a cornerstone of the complete Cobol guide on kodikra.com.

How to Convert Between Any Two Bases: The Universal Algorithm

Directly converting from an arbitrary base (e.g., base-7) to another (e.g., base-12) is complex and requires specialized algorithms. A much simpler and universally applicable method is to use base-10 (decimal) as a common intermediate language.

The process is a two-step translation:

From Input Base to Base-10: Convert the number from its original base into its decimal equivalent.
From Base-10 to Output Base: Convert the resulting decimal number into the target base.

This approach breaks down a complex problem into two smaller, well-defined sub-problems, each with a straightforward mathematical solution.

ASCII Art Diagram: The Two-Step Conversion Flow

Here is a visual representation of the universal conversion strategy.

    ● Start: Input Number (Base B1)
    │
    ▼
  ┌───────────────────────────────┐
  │ Step 1: Convert to Decimal    │
  │ (Sum of digit * B1^position)  │
  └──────────────┬────────────────┘
                 │
                 ▼
       Intermediate Decimal Value (Base 10)
                 │
                 ▼
  ┌───────────────────────────────┐
  │ Step 2: Convert from Decimal  │
  │ (Repeated Division/Modulo B2) │
  └──────────────┬────────────────┘
                 │
                 ▼
    ● End: Output Number (Base B2)

Step 1: Converting to Base-10 (Decimal)

To convert a number from any base B to base-10, you iterate through its digits from right to left. For each digit, you multiply it by B raised to the power of its position (starting from 0) and add the result to a running total.

For example, converting 10110 from base-2 to base-10:

(1 * 2⁴) + (0 * 2³) + (1 * 2²) + (1 * 2¹) + (0 * 2⁰)

= (1 * 16) + (0 * 8) + (1 * 4) + (1 * 2) + (0 * 1)

= 16 + 0 + 4 + 2 + 0 = 22

Step 2: Converting from Base-10 (Decimal)

To convert a decimal number N to a target base B, you use the method of repeated division and remainder.

Divide the decimal number N by the target base B.
The remainder of this division is the rightmost digit of your new number.
The quotient from the division becomes the new N.
Repeat steps 1-3 until the quotient is 0.

The sequence of remainders you collected, when read in reverse order, gives you the number in the new base.

For example, converting 22 from base-10 to base-2:

22 / 2 = 11 with a remainder of 0
11 / 2 = 5 with a remainder of 1
5 / 2 = 2 with a remainder of 1
2 / 2 = 1 with a remainder of 0
1 / 2 = 0 with a remainder of 1

Reading the remainders from bottom to top gives us 10110, which is the correct binary representation of 22.

Where the Logic Meets the Code: A Cobol Implementation

Now, let's translate this universal algorithm into a robust Cobol program. Cobol's verbosity is a feature, not a bug—it forces us to be explicit about every step, making the logic transparent and easy to follow.

This solution, from the exclusive kodikra.com curriculum, is structured into logical paragraphs for validation, conversion to decimal, conversion from decimal, and final output processing.

The Complete Cobol Solution


       IDENTIFICATION DIVISION.
       PROGRAM-ID. ALL-YOUR-BASE.
       AUTHOR. Kodikra.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
      *----------------------------------------------------------------*
      * Input / Output Parameters
      *----------------------------------------------------------------*
       01 WS-INPUT-BASE         PIC 9(02) VALUE 0.
       01 WS-OUTPUT-BASE        PIC 9(02) VALUE 0.
       01 WS-INPUT-DIGIT-COUNT  PIC 9(03) VALUE 0.
       01 WS-INPUT-DIGITS-TABLE.
          05 WS-INPUT-DIGIT     PIC 9(02) OCCURS 100 TIMES
                                INDEXED BY IDX-IN.
       01 WS-OUTPUT-DIGIT-COUNT PIC 9(03) VALUE 0.
       01 WS-OUTPUT-DIGITS-TABLE.
          05 WS-OUTPUT-DIGIT    PIC 9(02) OCCURS 100 TIMES
                                INDEXED BY IDX-OUT.

      *----------------------------------------------------------------*
      * Internal Working Variables
      *----------------------------------------------------------------*
       01 WS-DECIMAL-VALUE      PIC 9(18) VALUE 0.
       01 WS-TEMP-DECIMAL       PIC 9(18) VALUE 0.
       01 WS-QUOTIENT           PIC 9(18) VALUE 0.
       01 WS-REMAINDER          PIC 9(02) VALUE 0.
       01 WS-POWER-OF-BASE      PIC 9(18) VALUE 0.
       01 WS-STATUS-CODE        PIC X(01) VALUE '0'.
          88 SC-SUCCESS         VALUE '0'.
          88 SC-INVALID-BASE    VALUE '1'.
          88 SC-INVALID-DIGIT   VALUE '2'.

       01 WS-IDX                PIC 9(03).
       01 WS-JDX                PIC 9(03).
       01 WS-TEMP-DIGIT         PIC 9(02).

       PROCEDURE DIVISION.
      *----------------------------------------------------------------*
      * Main entry point for the base conversion logic.
      *----------------------------------------------------------------*
       REBASE.
           PERFORM INITIALIZE-VARIABLES.
           PERFORM VALIDATE-INPUTS.
           IF SC-SUCCESS
              IF WS-INPUT-DIGIT-COUNT > 0
                 PERFORM CONVERT-TO-DECIMAL
                 IF WS-DECIMAL-VALUE > 0
                    PERFORM CONVERT-FROM-DECIMAL
                    PERFORM REVERSE-OUTPUT-DIGITS
                 ELSE
                    MOVE 1 TO WS-OUTPUT-DIGIT-COUNT
                    MOVE 0 TO WS-OUTPUT-DIGIT(1)
                 END-IF
              ELSE
                 MOVE 1 TO WS-OUTPUT-DIGIT-COUNT
                 MOVE 0 TO WS-OUTPUT-DIGIT(1)
              END-IF
           END-IF.
           GOBACK.

      *----------------------------------------------------------------*
      * Reset working storage for a clean run.
      *----------------------------------------------------------------*
       INITIALIZE-VARIABLES.
           MOVE 0 TO WS-DECIMAL-VALUE.
           MOVE 0 TO WS-OUTPUT-DIGIT-COUNT.
           MOVE '0' TO WS-STATUS-CODE.
           PERFORM VARYING IDX-OUT FROM 1 BY 1
               UNTIL IDX-OUT > 100
               MOVE 0 TO WS-OUTPUT-DIGIT(IDX-OUT)
           END-PERFORM.

      *----------------------------------------------------------------*
      * Validate input base, output base, and all input digits.
      *----------------------------------------------------------------*
       VALIDATE-INPUTS.
           IF WS-INPUT-BASE < 2 OR WS-OUTPUT-BASE < 2
              MOVE '1' TO WS-STATUS-CODE
              EXIT PARAGRAPH
           END-IF.

           PERFORM VARYING IDX-IN FROM 1 BY 1
               UNTIL IDX-IN > WS-INPUT-DIGIT-COUNT
               IF WS-INPUT-DIGIT(IDX-IN) >= WS-INPUT-BASE
                  MOVE '2' TO WS-STATUS-CODE
                  EXIT PERFORM
               END-IF
           END-PERFORM.

      *----------------------------------------------------------------*
      * Step 1: Convert the input number to its decimal (base-10) value.
      *----------------------------------------------------------------*
       CONVERT-TO-DECIMAL.
           MOVE 0 TO WS-DECIMAL-VALUE.
           PERFORM VARYING IDX-IN FROM 1 BY 1
               UNTIL IDX-IN > WS-INPUT-DIGIT-COUNT
               COMPUTE WS-POWER-OF-BASE =
                   WS-INPUT-BASE ** (WS-INPUT-DIGIT-COUNT - IDX-IN)
               COMPUTE WS-DECIMAL-VALUE = WS-DECIMAL-VALUE +
                   (WS-INPUT-DIGIT(IDX-IN) * WS-POWER-OF-BASE)
           END-PERFORM.

      *----------------------------------------------------------------*
      * Step 2: Convert the decimal value to the target output base.
      *----------------------------------------------------------------*
       CONVERT-FROM-DECIMAL.
           MOVE WS-DECIMAL-VALUE TO WS-TEMP-DECIMAL.
           MOVE 0 TO WS-OUTPUT-DIGIT-COUNT.
           PERFORM UNTIL WS-TEMP-DECIMAL = 0
              DIVIDE WS-TEMP-DECIMAL BY WS-OUTPUT-BASE
                  GIVING WS-QUOTIENT
                  REMAINDER WS-REMAINDER
              ADD 1 TO WS-OUTPUT-DIGIT-COUNT
              MOVE WS-REMAINDER TO WS-OUTPUT-DIGIT(WS-OUTPUT-DIGIT-COUNT)
              MOVE WS-QUOTIENT TO WS-TEMP-DECIMAL
           END-PERFORM.

      *----------------------------------------------------------------*
      * The division method produces digits in reverse. This reverses them.
      *----------------------------------------------------------------*
       REVERSE-OUTPUT-DIGITS.
           MOVE 1 TO WS-IDX.
           MOVE WS-OUTPUT-DIGIT-COUNT TO WS-JDX.
           PERFORM UNTIL WS-IDX >= WS-JDX
               MOVE WS-OUTPUT-DIGIT(WS-IDX) TO WS-TEMP-DIGIT
               MOVE WS-OUTPUT-DIGIT(WS-JDX) TO WS-OUTPUT-DIGIT(WS-IDX)
               MOVE WS-TEMP-DIGIT TO WS-OUTPUT-DIGIT(WS-JDX)
               ADD 1 TO WS-IDX
               SUBTRACT 1 FROM WS-JDX
           END-PERFORM.

Code Walkthrough: A Step-by-Step Explanation

`DATA DIVISION`

This is where we define all our variables. Notice the use of the OCCURS clause to define tables (Cobol's version of arrays), such as WS-INPUT-DIGITS-TABLE. We also define status codes using level 88 condition names (e.g., SC-SUCCESS), which makes the code more readable than comparing a variable to a literal value like '0'.

`PROCEDURE DIVISION - REBASE`

This is the main driver paragraph. It orchestrates the entire process by calling other paragraphs in a specific order: initialize, validate, convert to decimal, convert from decimal, and finally, reverse the output. It also handles the edge case of an input number being zero or empty.

`VALIDATE-INPUTS`

Before any calculation, we must ensure our inputs are valid. This paragraph checks two critical conditions:

Both the input and output bases must be 2 or greater. A number system cannot exist with a base less than 2.
Every digit in the input number must be strictly less than the input base. For example, a base-8 (octal) number cannot contain the digit 8 or 9.

If either condition fails, it sets a status code and exits, preventing incorrect calculations.

`CONVERT-TO-DECIMAL`

This paragraph implements the first half of our algorithm. It loops through the input digits using a PERFORM VARYING loop. Inside the loop, it calculates the positional value using the exponentiation operator (**) and adds the result to our accumulator, WS-DECIMAL-VALUE. The logic (WS-INPUT-DIGIT-COUNT - IDX-IN) correctly computes the power for each position, starting from the rightmost digit (power 0).

`CONVERT-FROM-DECIMAL`

This paragraph implements the second half: the repeated division algorithm. It uses a PERFORM UNTIL loop that continues as long as our temporary decimal value is not zero. The key here is the DIVIDE verb with the GIVING and REMAINDER clauses. This single statement performs the division, stores the quotient for the next iteration, and captures the remainder, which is our new digit.

ASCII Art Diagram: The "Convert from Decimal" Loop Logic

This diagram illustrates the core logic inside the CONVERT-FROM-DECIMAL paragraph.

    ● Start: N = WS-DECIMAL-VALUE, Base = WS-OUTPUT-BASE
    │
    ▼
  ┌─────────────────┐
  │ Loop while N > 0│
  └────────┬────────┘
           │
           ▼
  ┌───────────────────────────┐
  │ Remainder = N % Base      │
  │ Quotient  = N / Base      │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Store Remainder in Output │
  │ Array (at next position)  │
  └────────────┬──────────────┘
               │
               ▼
  ┌───────────────────────────┐
  │ Update: N = Quotient      │
  └────────────┬──────────────┘
               │
               └─────────→ (Back to Loop)

`REVERSE-OUTPUT-DIGITS`

A crucial final step! The division algorithm naturally produces digits in reverse order (from least significant to most significant). This paragraph performs a classic in-place array reversal. It uses two index variables, one starting from the beginning (WS-IDX) and one from the end (WS-JDX), and swaps elements until they meet in the middle.

When to Handle Edge Cases and Errors

A robust program is defined by how well it handles unexpected or tricky inputs. Our Cobol solution explicitly checks for several edge cases:

Invalid Bases: If WS-INPUT-BASE or WS-OUTPUT-BASE is less than 2, the operation is mathematically impossible. Our VALIDATE-INPUTS paragraph catches this immediately.
Invalid Digits: If a digit is greater than or equal to its base (e.g., digit 4 in a base-3 number), the input is malformed. The loop in VALIDATE-INPUTS detects this.
Input is Zero: If the input digit array contains just a zero, or the calculated decimal value is zero, we should not enter the conversion loop. The main `REBASE` logic handles this by directly setting the output to a single digit `0`.
Empty Input: If the input digit count is zero, it represents the number 0. This is also handled by the main logic, resulting in an output of `0`.

By handling these cases upfront, we ensure the core conversion logic only operates on clean, valid data, preventing runtime errors and incorrect results.

Pros and Cons of the Cobol Approach

Implementing this algorithm in Cobol has distinct advantages and disadvantages compared to more modern languages.

Pros	Cons
Explicit Control: The code is transparent. You see every calculation and data movement, which is excellent for learning and debugging.	Verbosity: Cobol requires significantly more lines of code to achieve the same result as a language like Python or Java.
Performance: Cobol is highly optimized for numerical and arithmetic operations on mainframes, making it very efficient for this kind of task.	No Built-in Functions: Lacks high-level functions for base conversion, requiring manual implementation of the algorithm.
Data Structure Clarity: The `DATA DIVISION` forces a clear, upfront definition of all data structures, reducing ambiguity.	Manual Array Management: Reversing the array requires a manual loop, whereas modern languages often have a built-in `reverse()` method.
Robustness: The structured nature of Cobol encourages building robust validation and error-handling routines.	Limited Scope: This implementation is designed for non-negative integers. Handling fractional parts or negative numbers would add significant complexity.

Frequently Asked Questions (FAQ)

Why use base-10 as an intermediate step? Can't you convert directly?: Using base-10 as a "universal translator" dramatically simplifies the problem. While direct conversion algorithms exist (e.g., from base-2 to base-8), creating a single algorithm to convert between *any* two arbitrary bases is very complex. The two-step process (to decimal, then from decimal) is easy to understand, implement, and verify for any valid base.
What is the purpose of the `OCCURS` clause in the Cobol solution?: The OCCURS clause is Cobol's way of defining an array or, more accurately, a table. 05 WS-INPUT-DIGIT PIC 9(02) OCCURS 100 TIMES reserves memory for 100 instances of the WS-INPUT-DIGIT field, allowing us to store a sequence of digits. We can then access individual elements using an index, like WS-INPUT-DIGIT(IDX-IN).
Why does the repeated division method produce digits in reverse order?: The first remainder you calculate from dividing N / B corresponds to the value in the B⁰ (units) position—the rightmost digit. The next remainder corresponds to the B¹ position, and so on. Because you are calculating the least significant digit first, the sequence of digits you generate is naturally reversed from the way we typically write numbers.
How would this code handle hexadecimal (base-16) conversion?: This specific code is designed for numeric digits only (PIC 9). To handle hexadecimal, you would need to modify the DATA DIVISION to use alphanumeric fields (PIC X) for digits and add logic in the PROCEDURE DIVISION to translate characters 'A'-'F' to their numeric equivalents (10-15) during the conversion to decimal, and back again during the conversion from decimal.
Can this Cobol program handle very large numbers?: Yes, within limits. We defined WS-DECIMAL-VALUE as PIC 9(18), which can hold a number up to 18 digits long (quintillions). This is a standard size for a 64-bit integer. For numbers larger than this, you would need to implement arbitrary-precision arithmetic, which is a much more complex task involving string or array manipulation for calculations.
Is Cobol still a relevant language for new development?: While not typically chosen for new web or mobile apps, Cobol is incredibly relevant and dominant in the world of finance, insurance, and government systems running on mainframes. Billions of lines of Cobol code are still in production, and there is a high demand for developers who can maintain and modernize these critical systems. Learning it provides a unique and valuable skill set.

Conclusion: From Theory to Practical Mastery

We've journeyed from the abstract theory of positional notation to a concrete, working implementation in Cobol. The "All Your Base" problem is more than just a coding challenge; it's a gateway to understanding the fundamental principles of data representation that underpin all of modern computing.

By building this solution from the ground up, you've seen how to break a complex problem into manageable steps, validate inputs for robustness, and use core language features like loops and arithmetic verbs to execute a precise algorithm. This hands-on experience, a key part of the kodikra.com learning curriculum, solidifies concepts in a way that simply reading about them cannot.

Whether you are maintaining mission-critical legacy systems or simply wish to deepen your computer science knowledge, mastering these foundational algorithms is a timeless skill that will serve you well throughout your career. To continue your journey, explore our complete Cobol guide for more in-depth modules.

Disclaimer: The code in this article is written based on GnuCOBOL 3.1+ standards. Syntax and features may vary slightly with other Cobol compilers like those from IBM or Micro Focus.

Published by Kodikra — Your trusted Cobol learning resource.

kodikra

Search this blog