Multi-Language Code Vault: Implementing Number Base Conversion

To illustrate how number base conversion is handled in practice and to highlight the underlying data type limitations, here are code snippets in various popular programming languages. These examples demonstrate conversions and implicitly show the types of numbers they can handle natively.

1. Python (Arbitrary-Precision Integers)

Python's built-in integers handle arbitrary precision, making them very flexible for large number conversions.

# Decimal to Binary
decimal_num = 12345678901234567890
binary_representation = bin(decimal_num)
print(f"Decimal: {decimal_num}")
print(f"Binary: {binary_representation}") # Output will have '0b' prefix

# Decimal to Hexadecimal
hex_representation = hex(decimal_num)
print(f"Hexadecimal: {hex_representation}") # Output will have '0x' prefix

# Hexadecimal to Decimal
hex_str = "0x123456789ABCDEF0123456789ABCDEF"
decimal_from_hex = int(hex_str, 16)
print(f"Hex: {hex_str}")
print(f"Decimal: {decimal_from_hex}")

# Binary to Decimal
bin_str = "0b111010110111100110100010101010101010101010101010101010101010101"
decimal_from_bin = int(bin_str, 2)
print(f"Binary: {bin_str}")
print(f"Decimal: {decimal_from_bin}")
            

Note: Python's `int()` function with a base argument is the standard way. The `bin()`, `hex()`, and `oct()` functions are convenient for direct conversion to string representations.

2. JavaScript (Number Type Limitations)

JavaScript's standard `Number` type is a 64-bit floating-point number (IEEE 754 double-precision). It can represent integers accurately up to `Number.MAX_SAFE_INTEGER` (2⁵³ - 1). For larger integers, `BigInt` must be used.

// Using standard Number type (up to 2^53 - 1)
let decimalNum = 1234567890123456; // Within safe integer range
let binaryRepresentation = decimalNum.toString(2);
console.log(`Decimal: ${decimalNum}`);
console.log(`Binary: ${binaryRepresentation}`);

let hexRepresentation = decimalNum.toString(16);
console.log(`Hexadecimal: ${hexRepresentation}`);

// Hexadecimal to Decimal
let hexStr = "0x123456789ABCDEF"; // Represents a number up to 2^56 - 1
let decimalFromHex = parseInt(hexStr, 16);
console.log(`Hex: ${hexStr}`);
console.log(`Decimal: ${decimalFromHex}`);

// Using BigInt for larger numbers
let bigDecimalNum = BigInt("123456789012345678901234567890");
let bigBinary = bigDecimalNum.toString(2);
console.log(`BigInt Decimal: ${bigDecimalNum}`);
console.log(`BigInt Binary: ${bigBinary}`);

let bigHex = bigDecimalNum.toString(16);
console.log(`BigInt Hexadecimal: ${bigHex}`);

// BigInt from Hex
let bigHexStr = "0x123456789ABCDEF0123456789ABCDEF0123456789";
let bigDecimalFromHex = BigInt(bigHexStr);
console.log(`BigInt Hex: ${bigHexStr}`);
console.log(`BigInt Decimal: ${bigDecimalFromHex}`);
            

Note: For numbers exceeding 2⁵³ - 1, `BigInt` is essential in JavaScript.

3. Java (Fixed-Width Primitives and BigInteger)

Java offers fixed-width primitive types and the `BigInteger` class for arbitrary precision.

import java.math.BigInteger;

public class NumberConverter {
    public static void main(String[] args) {
        // Using long (64-bit signed integer)
        long decimalNumLong = 1234567890123456789L; // Max ~9.22 x 10^18
        System.out.println("Using long:");
        System.out.println("Decimal: " + decimalNumLong);
        System.out.println("Binary: " + Long.toBinaryString(decimalNumLong));
        System.out.println("Hexadecimal: " + Long.toHexString(decimalNumLong));

        // Converting from Hex String to long
        String hexStrLong = "123456789ABCDEF0"; // Max for unsigned 64-bit is FFFFFFFFFFFFFFFF
        long decimalFromHexLong = Long.parseLong(hexStrLong, 16);
        System.out.println("Hex: " + hexStrLong);
        System.out.println("Decimal: " + decimalFromHexLong);

        System.out.println("\nUsing BigInteger for arbitrary precision:");
        // Using BigInteger for very large numbers
        BigInteger bigDecimalNum = new BigInteger("1234567890123456789012345678901234567890");
        System.out.println("BigInt Decimal: " + bigDecimalNum);
        System.out.println("BigInt Binary: " + bigDecimalNum.toString(2));
        System.out.println("BigInt Hexadecimal: " + bigDecimalNum.toString(16));

        // Converting from Hex String to BigInteger
        String bigHexStr = "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0";
        BigInteger bigDecimalFromHex = new BigInteger(bigHexStr, 16);
        System.out.println("BigInt Hex: " + bigHexStr);
        System.out.println("BigInt Decimal: " + bigDecimalFromHex);

        // Example of overflow with int (32-bit signed)
        int maxInt = Integer.MAX_VALUE; // 2147483647
        int overflowInt = maxInt + 1;   // Wraps around to Integer.MIN_VALUE (-2147483648)
        System.out.println("\nInteger Overflow Example:");
        System.out.println("Integer.MAX_VALUE: " + maxInt);
        System.out.println("maxInt + 1 (overflowed): " + overflowInt);
    }
}
            

Note: `long` is for 64-bit integers. For numbers exceeding `Long.MAX_VALUE`, `BigInteger` is the solution.

4. C++ (Fixed-Width Types and Libraries)

C++ has fixed-width integer types and requires external libraries for arbitrary precision.

#include <iostream>
#include <string>
#include <algorithm> // For std::reverse
#include <cmath>     // For pow (though often avoided for large numbers)

// Basic function to convert decimal to binary string (limited by unsigned long long)
std::string decToBin(unsigned long long n) {
    if (n == 0) return "0";
    std::string binaryString = "";
    while (n > 0) {
        binaryString += ((n % 2) == 0 ? "0" : "1");
        n /= 2;
    }
    std::reverse(binaryString.begin(), binaryString.end());
    return binaryString;
}

// Basic function to convert decimal to hex string (limited by unsigned long long)
std::string decToHex(unsigned long long n) {
    if (n == 0) return "0";
    std::string hexString = "";
    char hexDigits[] = "0123456789ABCDEF";
    while (n > 0) {
        hexString += hexDigits[n % 16];
        n /= 16;
    }
    std::reverse(hexString.begin(), hexString.end());
    return hexString;
}

// Basic function to convert hex string to unsigned long long
unsigned long long hexToDec(std::string hexString) {
    unsigned long long decimalValue = 0;
    unsigned long long power = 1;
    for (int i = hexString.length() - 1; i >= 0; i--) {
        if (hexString[i] >= '0' && hexString[i] <= '9') {
            decimalValue += (hexString[i] - '0') * power;
        } else if (hexString[i] >= 'A' && hexString[i] <= 'F') {
            decimalValue += (hexString[i] - 'A' + 10) * power;
        } else if (hexString[i] >= 'a' && hexString[i] <= 'f') {
            decimalValue += (hexString[i] - 'a' + 10) * power;
        }
        power *= 16;
    }
    return decimalValue;
}

int main() {
    // Using unsigned long long (typically 64-bit)
    unsigned long long decimalNum = 18446744073709551615ULL; // Max value for unsigned 64-bit
    std::cout << "Using unsigned long long:" << std::endl;
    std::cout << "Decimal: " << decimalNum << std::endl;
    std::cout << "Binary: " << decToBin(decimalNum) << std::endl;
    std::cout << "Hexadecimal: " << decToHex(decimalNum) << std::endl;

    std::string hexStr = "FFFFFFFFFFFFFFFF";
    std::cout << "Hex: " << hexStr << std::endl;
    std::cout << "Decimal: " << hexToDec(hexStr) << std::endl;

    // For numbers beyond unsigned long long, you'd need a Big Integer library
    // like GMP (GNU Multiple Precision Arithmetic Library) or Boost.Multiprecision.
    std::cout << "\nFor numbers exceeding 64-bit limits, use a Big Integer library." << std::endl;

    // Example of overflow with int (32-bit signed)
    int maxInt = 2147483647;
    // int overflowInt = maxInt + 1; // This would cause overflow, undefined behavior
    std::cout << "\nInteger overflow example (int, 32-bit signed):" << std::endl;
    std::cout << "INT_MAX: " << maxInt << std::endl;
    // Demonstrating how it would wrap around if not for compiler warnings/errors
    // std::cout << "INT_MAX + 1 (would wrap): " << overflowInt << std::endl;


    return 0;
}
            

Note: C++ standard library does not provide built-in arbitrary-precision integers. You must use external libraries for numbers exceeding `unsigned long long` (typically 64-bit).

5. C# (Fixed-Width Types and BigInteger)

C# provides fixed-width integer types and the `BigInteger` struct.

using System;
using System.Numerics; // For BigInteger

public class NumberConverter
{
    public static void Main(string[] args)
    {
        // Using ulong (64-bit unsigned integer)
        ulong decimalNumUlong = 18446744073709551615; // Max value for ulong
        Console.WriteLine("Using ulong:");
        Console.WriteLine($"Decimal: {decimalNumUlong}");
        Console.WriteLine($"Binary: {Convert.ToString((long)decimalNumUlong, 2)}"); // Note: Convert.ToString(long, 2) for ulong is tricky, better to use custom logic or BigInteger
        Console.WriteLine($"Hexadecimal: {decimalNumUlong:X}"); // X for uppercase hex

        // Converting from Hex String to ulong
        string hexStrUlong = "FFFFFFFFFFFFFFFF";
        ulong decimalFromHexUlong = Convert.ToUInt64(hexStrUlong, 16);
        Console.WriteLine($"Hex: {hexStrUlong}");
        Console.WriteLine($"Decimal: {decimalFromHexUlong}");

        Console.WriteLine("\nUsing BigInteger for arbitrary precision:");
        // Using BigInteger for very large numbers
        BigInteger bigDecimalNum = BigInteger.Parse("12345678901234567890123456789012345678901234567890");
        Console.WriteLine($"BigInt Decimal: {bigDecimalNum}");
        Console.WriteLine($"BigInt Binary: {bigDecimalNum.ToString(2)}");
        Console.WriteLine($"BigInt Hexadecimal: {bigDecimalNum.ToString("X")}"); // "X" for uppercase hex

        // Converting from Hex String to BigInteger
        string bigHexStr = "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0";
        BigInteger bigDecimalFromHex = BigInteger.Parse(bigHexStr, System.Globalization.NumberStyles.HexNumber);
        Console.WriteLine($"BigInt Hex: {bigHexStr}");
        Console.WriteLine($"BigInt Decimal: {bigDecimalFromHex}");

        // Example of overflow with int (32-bit signed)
        int maxInt = int.MaxValue; // 2147483647
        // int overflowInt = maxInt + 1; // This would cause an OverflowException at runtime if checked, or wrap around if unchecked
        Console.WriteLine("\nInteger overflow example (int, 32-bit signed):");
        Console.WriteLine($"int.MaxValue: {maxInt}");
        // Console.WriteLine($"maxInt + 1 (would overflow): {overflowInt}");
    }
}
            

Note: `ulong` is for 64-bit unsigned integers. For numbers exceeding `ulong.MaxValue`, use `System.Numerics.BigInteger`.

These examples demonstrate that while basic conversions are straightforward, the "size" of numbers you can convert is fundamentally tied to the data types available in the language or the libraries you employ. For cybersecurity professionals, understanding these underlying mechanics is key to building robust and secure applications that handle numerical data correctly, regardless of its magnitude.