scalbn() function in C

The scalbn function in C is an integral part of the mathematical library (math.h) that enables efficient scaling of floating-point numbers by powers of two. This function is particularly useful in numerical computations where such scaling is required, and it offers a performance advantage over more general methods of exponentiation due to its specific focus on powers of two.

point numbers in C are typically represented using the IEEE 754 standard, which encodes numbers as a significand (or mantissa) and an exponent. By adjusting the exponent directly, scalbn achieves the desired scaling effect with minimal computational overhead.

The primary purpose of the scalbn function is to multiply a floating-point number x by 2 raised to the power of an integer n. The function has three variants to accommodate different floating-point types:

 
#include <math.h>
double scalbn(double x, int n);
float scalbnf(float x, int n);
long double scalbnl(long double x, int n);   

The scalbn operates on double precision floating-point numbers.
The scalbnf operates on float precision floating-point numbers.
The scalbnl operates on long double precision floating-point numbers.

Approach-1: Basic Scaling with scalbn

The most straightforward use of the scalbn function involves scaling a given floating-point number x by 2n. This is particularly useful in various numerical and computational contexts where efficient scaling is required.

How does scalbn work?

The scalbn function directly manipulates the exponent of the floating-point number x to scale it by 2n. In floating-point representation (typically IEEE 754), a number is represented as x=m×2^e, where m is the mantissa and e is the exponent. The scalbn function effectively adds n to the exponent e, resulting in result= x×2^n

This direct manipulation of the exponent makes scalbn more efficient than using general exponentiation functions like pow for powers of two.

Program:

 
// Include necessary header files for input/output and mathematical functions
#include <stdio.h>
#include <math.h>
// Main function to demonstrate the use of scalbn for scaling floating-point numbers
int main() {
    // Initialize variables for scaling demonstration
    double x1 = 1.5;    // First floating-point number to be scaled
    double x2 = -2.25;  // Second floating-point number to be scaled
    double x3 = 0.75;   // Third floating-point number to be scaled
    int n1 = 3;         // First exponent
    int n2 = -2;        // Second exponent
    int n3 = 5;         // Third exponent
    // Scale the first number x1 by 2^n1
    double result1 = scalbn(x1, n1);  // Compute 1.5 * 2^3
    // Print the result with detailed information
    printf("scalbn(%f, %d) = %f\n", x1, n1, result1);  // Expected: 1.5 * 8 = 12.0
    // Scale the second number x2 by 2^n2
    double result2 = scalbn(x2, n2);  // Compute -2.25 * 2^-2
    // Print the result with detailed information
    printf("scalbn(%f, %d) = %f\n", x2, n2, result2);  // Expected: -2.25 / 4 = -0.5625
    // Scale the third number x3 by 2^n3
    double result3 = scalbn(x3, n3);  // Compute 0.75 * 2^5
    // Print the result with detailed information
    printf("scalbn(%f, %d) = %f\n", x3, n3, result3);  // Expected: 0.75 * 32 = 24.0
    // Demonstrate special cases for scalbn function
    // Case 1: Scaling a zero value
    double x_zero = 0.0;
    int n_zero = 10;
    double result_zero = scalbn(x_zero, n_zero);  // Compute 0.0 * 2^10
    printf("scalbn(%f, %d) = %f\n", x_zero, n_zero, result_zero);  // Expected: 0.0
    // Case 2: Scaling infinity
    double x_inf = INFINITY;
    int n_inf = 5;
    double result_inf = scalbn(x_inf, n_inf);  // Compute infinity * 2^5
    printf("scalbn(%f, %d) = %f\n", x_inf, n_inf, result_inf);  // Expected: infinity
    // Case 3: Scaling NaN (Not a Number)
    double x_nan = NAN;
    int n_nan = 3;
    double result_nan = scalbn(x_nan, n_nan);  // Compute NaN * 2^3
    printf("scalbn(%f, %d) = %f\n", x_nan, n_nan, result_nan);  // Expected: NaN
    // Additional example to illustrate the use of scalbn with different data types
    float x_float = 2.5f;  // Floating-point number with float precision
    int n_float = 4;       // Exponent for float precision
    float result_float = scalbnf(x_float, n_float);  // Compute 2.5 * 2^4
    printf("scalbnf(%f, %d) = %f\n", x_float, n_float, result_float);  // Expected: 2.5 * 16 = 40.0
    // Demonstrate use of scalbn with long double precision
    long double x_long_double = 1.125L;  // Floating-point number with long double precision
    int n_long_double = -3;              // Exponent for long double precision
    long double result_long_double = scalbnl(x_long_double, n_long_double);  // Compute 1.125 * 2^-3
    printf("scalbnl(%Lf, %d) = %Lf\n", x_long_double, n_long_double, result_long_double);  // Expected: 1.125 / 8 = 0.140625
    // Conclusion message
    printf("Demonstration of scalbn function completed.\n");
    // Return 0 to indicate successful execution of the program
    return 0;
}   

Output:

 
scalbn(1.500000, 3) = 12.000000
scalbn(-2.250000, -2) = -0.562500
scalbn(0.750000, 5) = 24.000000
scalbn(0.000000, 10) = 0.000000
scalbn(inf, 5) = inf
scalbn(nan, 3) = nan
scalbnf(2.500000, 4) = 40.000000
scalbnl(1.125000, -3) = 0.140625
Demonstration of scalbn function completed.

Explanation:

The code demonstrates the application of the scalbn function in C, which is used to scale floating-point numbers by powers of two. The example covers basic usage, handles special cases, and showcases how the function works with different floating-point types.

Header Files
The program begins by including the necessary header files:
<stdio.h>: It provides functions for input and output operations, such as displaying results on the screen.
<math.h>: It contains mathematical functions, including scalbn, which is used for scaling floating-point numbers.
Main Function
The main function orchestrates the demonstration of the scalbn function. Here's a breakdown of its operations:
Variable Initialization:
Several floating-point variables are declared, each representing a value that will be scaled.
Exponent variables are declared, representing the power of two by which each floating-point number will be scaled.
Handling Special Cases:
Zero Value: Demonstrates that scaling zero by any power of two results in zero. This is verified by using scalbn with a zero value and checking the output.
Infinity: Shows that scaling an infinite value by any power of two still results in infinity. This is tested by applying scalbn to an infinite value and observing the result.
NaN (Not a Number): Indicates that scaling a NaN value remains NaN. This behavior is confirmed by using scalbn with a NaN value and inspecting the output.
Different Floating-Point Types:
Float Type: Demonstrates the use of scalbnf, a variant of scalbn for single-precision floating-point numbers. This part of the code scales a float value and shows the result.
Long double Type: Uses scalbnl, a variant for extended-precision floating-point numbers. This section scales a long double value and presents the result.

Complexity Analysis:

The scalbn function in C is used to scale a floating-point number by a power of two. Analyzing the time and space complexity of scalbn involves understanding how the function operates internally and how it handles floating-point numbers and exponents.

Time Complexity

The time complexity of the scalbn function is primarily influenced by the following operations:

Exponent Manipulation:

scalbn adjusts the exponent of the floating-point number to scale it by 2n. This operation involves updating the exponent field of the floating-point representation, which is a constant-time operation. Floating-point numbers are typically represented using the IEEE 754 standard, which includes a specific bit layout for the mantissa and exponent. Updating these fields is done in constant time, O(1), because it involves simple bit manipulations.

Scaling Computation:

The actual computation performed by scalbn is straightforward. It multiplies the floating-point number by 2n, which can be achieved by shifting the exponent in the floating-point representation. This multiplication is done in constant time, O(1), as it leverages the hardware's ability to handle floating-point arithmetic efficiently.

Special Case Handling:

scalbn also handles special cases such as zero, infinity, and NaN values. The checks for these conditions are minimal and are typically performed in constant time. Since scalbn directly checks these special cases and returns the appropriate result, the time complexity remains O(1) even when handling these edge cases.

Finally, the time complexity of scalbn is O(1). The function performs a constant number of operations regardless of the size of the input values. The efficiency of scalbn is due to its reliance on bitwise operations and hardware-accelerated arithmetic, which do not depend on the magnitude of the exponent or the floating-point number.

Space Complexity

The space complexity of the scalbn function can be analyzed based on the following aspects:

Input Storage:

The function takes input from a floating-point number and an integer exponent. The storage required for these inputs is constant and does not vary with their size. Therefore, the space complexity related to input storage is O(1).

Internal Variables:

Internally, scalbn may use temporary variables to store intermediate results, such as the scaled value of the floating-point number. These variables are typically of fixed size and do not depend on the size of the inputs. Hence, the space complexity for internal storage is also O(1).

Function Call Overhead:

The function call itself does not add significant overhead in terms of space, as it operates within the stack frame of the calling function. The space required for function calls is constant and does not scale with input size.

Finally, the space complexity of scalbn is O(1). The function does not require additional space that grows with the size of the input. It operates with a constant amount of memory, primarily for storing the inputs and intermediate results.

Approach-2: Bit Manipulation:

Manipulating the IEEE 754 representation of floating-point numbers directly involves understanding their structure and performing bit-level operations to adjust the exponent. Here's a detailed explanation of this approach.

Program:

 
#include <stdio.h>
#include <stdint.h>
#include <math.h>
// Union to access the bits of a double
union DoubleInt {
    double d;
    uint64_t i;
};
// Function to extract the exponent from the 64-bit representation
int extract_exponent(uint64_t bits) {
    return (bits >> 52) & 0x7FF; // Extract bits 52 to 62 (11 bits for the exponent)
}
// Function to set the exponent in the 64-bit representation
uint64_t set_exponent(uint64_t bits, int new_exponent) {
    bits &= ~(0x7FFULL << 52); // Clear the original exponent bits
    bits |= ((uint64_t)new_exponent & 0x7FF) << 52; // Set the new exponent
    return bits;
}
// Function to scale the floating-point number by a power of two
double scale(double x, int n) {
    union DoubleInt value;
    value.d = x;
    int current_exponent = extract_exponent(value.i);
    int exponent_bias = 1023; // Bias for double-precision floating-point numbers
    // Handle special cases: zero, infinity, NaN
    if (current_exponent == 0x7FF) { // All bits in the exponent field are 1
        // Infinity or NaN
        return x; // Scaling does not change infinity or NaN
    }
    if (current_exponent == 0) { // All bits in the exponent field are 0
        if (value.i << 12 == 0) {
            // Zero (both positive and negative)
            return x; // Scaling does not change zero
        } else {
            // Subnormal number
            // Normalize the subnormal number by adjusting the exponent
            while ((value.i & (1ULL << 52)) == 0) {
                value.i <<= 1;
                current_exponent--;
            }
            current_exponent++; // Adjust for the normalization shift
            value.i &= ~(1ULL << 52); // Clear the leading 1 bit
        }
    }
    // Calculate the new exponent
    int new_exponent = current_exponent + n;
    // Handle exponent overflow and underflow
    if (new_exponent >= 0x7FF) {
        // Overflow: return infinity with the same sign as the original number
        return copysign(INFINITY, x);
    }
    if (new_exponent <= 0) {
        // Underflow: the result is subnormal or zero
        if (new_exponent < -52) {
            // Too small to be represented as a subnormal number, return zero
            return copysign(0.0, x);
        } else {
            // Shift the significand to make it a subnormal number
            value.i = (value.i & ~(0x7FFULL << 52)) | ((uint64_t)(new_exponent + 52) << 52);
            return value.d;
        }
    }
    // Set the new exponent
    value.i = set_exponent(value.i, new_exponent);

    return value.d;
}
int main() {
    double x;
    int n;
    // Test cases to demonstrate the scaling function
    x = 3.14;
    n = 10;
    printf("Original: %f, Scaled: %f\n", x, scale(x, n)); // Scale by 2^10
    x = 3.14;
    n = -10;
    printf("Original: %f, Scaled: %f\n", x, scale(x, n)); // Scale by 2^-10
    x = 0.0;
    n = 5;
    printf("Original: %f, Scaled: %f\n", x, scale(x, n)); // Scale zero by 2^5
    x = -0.0;
    n = 5;
    printf("Original: %f, Scaled: %f\n", x, scale(x, n)); // Scale negative zero by 2^5
    x = INFINITY;
    n = 5;
    printf("Original: %f, Scaled: %f\n", x, scale(x, n)); // Scale infinity by 2^5
    x = -INFINITY;
    n = 5;
    printf("Original: %f, Scaled: %f\n", x, scale(x, n)); // Scale negative infinity by 2^5
    x = NAN;
    n = 5;
    printf("Original: %f, Scaled: %f\n", x, scale(x, n)); // Scale NaN by 2^5

    x = 1.0e-300;
    n = 500;
    printf("Original: %e, Scaled: %e\n", x, scale(x, n)); // Large positive scaling factor
    x = 1.0e300;
    n = -500;
    printf("Original: %e, Scaled: %e\n", x, scale(x, n)); // Large negative scaling factor
    return 0;
}   

Output:

 
Original: 3.140000, Scaled: 3215.360000
Original: 3.140000, Scaled: 0.003066
Original: 0.000000, Scaled: 0.000000
Original: -0.000000, Scaled: -0.000000
Original: inf, Scaled: inf
Original: -inf, Scaled: -inf
Original: nan, Scaled: nan
Original: 1.000000e-300, Scaled: 3.273391e-150
Original: 1.000000e+300, Scaled: 3.054936e+149

Explanation:

The provided code demonstrates the manipulation of IEEE 754 floating-point numbers directly through bit-level operations. This approach allows us to scale a floating-point number by a power of two by adjusting its exponent field directly.

Union for Bit Manipulation
The code begins with the definition of a union DoubleInt that allows the same memory location to be interpreted as both a double and a 64-bit unsigned integer. This is crucial for directly accessing and modifying the bits of a double-precision floating-point number.
Extracting the Exponent
The extract_exponent function isolates the exponent bits from the 64-bit representation of the floating-point number. In the IEEE 754 standard, the exponent is stored in bits 52 to 62. The function shifts the bits to the right by 52 places and then applies a bitmask to extract the 11-bit exponent.
Setting the Exponent
The set_exponent function clears the existing exponent bits in the 64-bit representation and sets the new exponent. This involves clearing the bits in the exponent field using a bitmask and then setting the new exponent bits in the appropriate position.
Handling Special Cases
The scale function begins by handling several special cases:
Infinity and NaN: These are identified by an exponent of 2047 (all bits in the exponent field are 1). The function checks for this condition and returns the input value as-is since scaling does not change infinity or NaN.
Zero: Both positive and negative zero have an exponent of 0 and a significand of 0. Scaling zero by any power of two still results in zero.
Subnormal Numbers: These numbers have an exponent of 0 but a non-zero significand. To handle subnormal numbers, the function normalizes the significand by shifting it left until the leading bit is 1, adjusting the exponent accordingly.
Calculating the New Exponent
After that, the function calculates the new exponent by adding the scaling factor n to the current exponent. The exponent in IEEE 754 is stored with a bias of 1023, so the function works directly with the biased exponent.
Handling Overflow and Underflow
The function handles potential overflow and underflow of the exponent:
Overflow: If the new exponent is greater than or equal to 2047, the result is positive or negative infinity, depending on the sign of the original number.

Underflow:

exponent is less

Reassembling the Number
After adjusting the exponent, the function reassembles the floating-point number by setting the new exponent in the 64-bit representation. This involves combining the modified exponent with the original sign and significand.

Complexity Analysis:

Time Complexity Analysis

The primary function of interest in this program is scale(double x, int n), which scales a floating-point number by a power of two using bit manipulation. Let's break down its time complexity.

Union Definition and Initialization:

Initializing the union DoubleInt and setting its value to the input double x is a constant-time operation, O(1).

Extracting the Exponent:

The function extract_exponent(uint64_t bits) shifts the bits to the right by 52 positions and masks the result to extract the 11-bit exponent. Both bit-shifting and masking are O(1) operations.

Calculating the New Exponent:

Adding the scaling factor n to the current exponent is a single addition operation, which is O(1).

Handling Overflow and Underflow:

Overflow Check: This is an O (1) operation that checks if the new exponent exceeds the maximum value (2047) and returns infinity if it does.

Underflow Check: Checking if the new exponent is less than or equal to zero and handling subnormal numbers or zero accordingly involves a few comparisons and potential shifts, all of which are O(1).

Setting the New Exponent:

The function set_exponent(uint64_t bits, int new_exponent) clears the existing exponent bits and sets the new exponent. This involves bit-masking and shifting operations, both of which are O(1).

Reassembling the Number:

Combining the modified exponent with the original significand and sign bit to form the new double value involves basic bitwise operations and is O(1).

Overall Time Complexity

Each step of the scale function involves constant-time operations. Hence, the overall time complexity of the scale function is O(1), meaning it performs a fixed amount of work regardless of the input size.

Space Complexity Analysis

The program's complexity involves both the space required for storing the input and output and any additional space used by the program.

Union for Bit Manipulation:

The DoubleInt union holds a double and a 64-bit integer. Both share the same memory location, so the union only requires space for the larger of the two, which is 64 bits (or 8 bytes).

Local Variables:

The function scale uses a few local variables, including current_exponent, new_exponent, and value. These are either integers or a union of a double and a 64-bit integer. The total space used by these local variables is minimal and fixed.

Return Value:

The function returns a double, which occupies 8 bytes of space.

Overall Space Complexity

The scale function's space complexity is O(1), as it uses a fixed amount of space regardless of the input size. The space required for the union, local variables, and the return value is constant and does not grow with the input.

Next TopicCopysign-function-in-c

← prev next →