Skip to content

← Back to Overview

Integer to Decimal (Float) Type Conversion

Concept Explanation

Type conversion, or type casting, is the process of changing an entity of one data type into another. Converting an integer to a decimal (floating-point) number is a common operation. In many programming languages, this is an "upcasting" or "widening" conversion, meaning it often happens implicitly without loss of precision (though floating-point representation itself has precision limits). Explicit casting can also be used for clarity or when specific conversions are required.

Algorithm

  1. Start.
  2. Declare an integer variable and initialize it.
  3. Perform an operation that results in a decimal, observing implicit conversion.
  4. (Optional) Explicitly convert the integer to a decimal type.
  5. Display the original integer and the converted decimal values along with their types.
  6. End.

Implementations

public class TypeConversionIntToFloat {
    public static void main(String[] args) {
        int intValue = 100;

        // Implicit conversion (widening) from int to float
        float floatValue = intValue;

        // Implicit conversion (widening) from int to double
        double doubleValue = intValue;

        // Explicit conversion (casting) is generally not needed for int to float/double
        // but shown here for illustration.
        float explicitFloatValue = (float) intValue;
        double explicitDoubleValue = (double) intValue;

        System.out.println("Original int value: " + intValue);
        System.out.println("Implicitly converted to float: " + floatValue);
        System.out.println("Implicitly converted to double: " + doubleValue);
        System.out.println("Explicitly cast to float: " + explicitFloatValue);
        System.out.println("Explicitly cast to double: " + explicitDoubleValue);

        // Example with arithmetic operation resulting in float/double
        int num1 = 10;
        int num2 = 3;
        double result = (double) num1 / num2; // One operand cast to double for float division
        System.out.println("Result of (double)int / int: " + result);
    }
}

# Integer value
int_value = 100

print(f"Original integer value: {int_value} (Type: {type(int_value)})")

# Implicit conversion: division of integers results in a float
result_of_division = int_value / 3
print(f"Result of int / 3 (implicit float): {result_of_division} (Type: {type(result_of_division)})")

# Explicit conversion using float()
float_value = float(int_value)
print(f"Explicitly converted to float: {float_value} (Type: {type(float_value)})")

# Another integer
another_int = 25

# Combining integer and float in an expression often results in a float
combined_result = another_int + 5.5
print(f"Result of int + float (implicit float): {combined_result} (Type: {type(combined_result)})")

#include <stdio.h>

int main() {
    int int_value = 100;

    printf("Original integer value: %d", int_value);

    // Implicit conversion (widening) when assigning int to float/double
    float float_value = int_value;
    double double_value = int_value;
    printf("Implicitly converted to float: %f", float_value);
    printf("Implicitly converted to double: %lf", double_value);

    // Explicit conversion (casting) for integer division to float division
    int num1 = 10;
    int num2 = 3;
    float result_float = (float)num1 / num2; // Cast one operand to float
    double result_double = (double)num1 / num2; // Cast one operand to double

    printf("Result of (float)int / int: %f", result_float);
    printf("Result of (double)int / int: %lf", result_double);

    return 0;
}

SET SERVEROUTPUT ON;
DECLARE
  integer_val       PLS_INTEGER := 10;
  decimal_val       NUMBER;
BEGIN
  DBMS_OUTPUT.PUT_LINE('Original Integer: ' || integer_val);

  -- Implicit conversion: dividing an integer by another integer can result in a decimal
  decimal_val := integer_val / 3;
  DBMS_OUTPUT.PUT_LINE('Integer / 3 (Implicit Decimal): ' || decimal_val);

  -- Assigning an integer to a NUMBER type variable, which can hold decimals
  decimal_val := integer_val;
  DBMS_OUTPUT.PUT_LINE('Integer assigned to NUMBER variable: ' || decimal_val);

  -- Explicit conversion using TO_NUMBER (though often not strictly necessary for PLS_INTEGER to NUMBER)
  -- This is more relevant when converting from a string representation to a number.
  -- For converting one numeric type to another within PL/SQL, assignment often handles it implicitly.
  DECLARE
    another_integer PLS_INTEGER := 25;
    converted_decimal_explicit NUMBER(10, 2);
  BEGIN
    converted_decimal_explicit := another_integer; -- Implicit conversion
    DBMS_OUTPUT.PUT_LINE('Explicit conversion (assigning PLS_INTEGER to NUMBER(10,2)): ' || converted_decimal_explicit);
  END;
END;
/

Explanation

  • Java: Java performs implicit widening conversion from int to float or double. Explicit casting is also possible but often redundant for widening conversions. System.out.println() displays values.
  • Python: Python handles type conversions dynamically. Division of integers (/) always results in a float. The float() function can explicitly convert an int to a float. type() can be used to check the data type.
  • C: Implicit widening conversions occur when assigning an int to a float or double. Explicit type casting (e.g., (float)num1) is often used in arithmetic operations to ensure floating-point division rather than integer division.
  • Oracle: The NUMBER data type in PL/SQL can represent both integers and decimals. Implicit conversion happens when an PLS_INTEGER or INTEGER is assigned to a NUMBER variable, or when used in operations resulting in a fractional value. Explicit conversion using TO_NUMBER() is more commonly used for converting VARCHAR2 to NUMBER.

Flowchart

graph TD
    A[Start] --> B[Declare Integer Variable]
    B --> C[Divide Integer by 3]
    C --> D[Display Implicit Float Result]
    B --> E[Explicitly Convert to Float]
    E --> F[Display Explicit Conversion]
    D --> G[End]
    F --> G

Practice Problems

  • Implement conversion from decimal (float) to integer, observing truncation or rounding behavior.
  • Explore type conversion with character types (e.g., char to int in C/Java, or ASCII values).
  • Create a program that converts different units (e.g., meters to centimeters) involving type conversions.

"The function of a good software is to make the complex appear simple." - Grady Booch