# Convert the fractional whole number to binary

Converting numbers from one numerical system to another is a fundamental concept in computer science and mathematics. In this article, we'll explore how to convert fractional whole numbers to binary using a program. We'll define the problem, provide a detailed explanation with suitable examples, present the algorithm, and analyze the time complexity of the code.

## Problem Statement

The problem is to convert a given fractional whole number (a decimal number) into its binary representation. This involves converting both the integer part and the fractional part of the number into binary form.

## Example

Let's take the number 12.55 as an example. To convert it to binary, we need to convert both the integer part (12) and the fractional part (0.55) to binary form.

• Integer Part (12): 12 in binary is 1100.
• Fractional Part (0.55):
• Multiply 0.55 by 2: 1.1, take the integer part (1).
• Subtract 1 from 1.1: 0.1, multiply by 2: 0.2, take the integer part (0).
• Multiply 0.2 by 2: 0.4, take the integer part (0).
• Multiply 0.4 by 2: 0.8, take the integer part (0).
• Multiply 0.8 by 2: 1.6, take the integer part (1).
• Subtract 1 from 1.6: 0.6, multiply by 2: 1.2, take the integer part (1).
• Subtract 1 from 1.2: 0.2, multiply by 2: 0.4, take the integer part (0).
• Multiply 0.4 by 2: 0.8, take the integer part (0).
• Multiply 0.8 by 2: 1.6, take the integer part (1).
• ... and so on.
``````Example 1
----------
num = 12.55

12 = 1100 (Binary of whole number)

0.10000000000000142 X 2 = 0.20000000000000284  0
0.20000000000000284 X 2 = 0.4000000000000057  0
0.4000000000000057 X 2 = 0.8000000000000114  0
0.8000000000000114 X 2 = 1.6000000000000227  1
0.6000000000000227 X 2 = 1.2000000000000455  1
0.20000000000004547 X 2 = 0.40000000000009095  0
0.40000000000009095 X 2 = 0.8000000000001819  0
0.8000000000001819 X 2 = 1.6000000000003638  1
0.6000000000003638 X 2 = 1.2000000000007276  1
0.2000000000007276 X 2 = 0.4000000000014552  0
0.4000000000014552 X 2 = 0.8000000000029104  0
0.8000000000029104 X 2 = 1.6000000000058208  1
0.6000000000058208 X 2 = 1.2000000000116415  1
0.20000000001164153 X 2 = 0.40000000002328306  0
0.40000000002328306 X 2 = 0.8000000000465661  0
0.8000000000465661 X 2 = 1.6000000000931323  1
0.6000000000931323 X 2 = 1.2000000001862645  1
0.20000000018626451 X 2 = 0.40000000037252903  0
0.40000000037252903 X 2 = 0.8000000007450581  0
0.8000000007450581 X 2 = 1.6000000014901161  1
0.6000000014901161 X 2 = 1.2000000029802322  1
0.20000000298023224 X 2 = 0.4000000059604645  0
0.4000000059604645 X 2 = 0.800000011920929  0
0.800000011920929 X 2 = 1.600000023841858  1
0.6000000238418579 X 2 = 1.2000000476837158  1
0.20000004768371582 X 2 = 0.40000009536743164  0
0.40000009536743164 X 2 = 0.8000001907348633  0
0.8000001907348633 X 2 = 1.6000003814697266  1
0.6000003814697266 X 2 = 1.2000007629394531  1
0.20000076293945312 X 2 = 0.40000152587890625  0
0.40000152587890625 X 2 = 0.8000030517578125  0
0.8000030517578125 X 2 = 1.600006103515625  1
0.600006103515625 X 2 = 1.20001220703125  1
0.20001220703125 X 2 = 0.4000244140625  0
0.4000244140625 X 2 = 0.800048828125  0
0.800048828125 X 2 = 1.60009765625  1
0.60009765625 X 2 = 1.2001953125  1
0.2001953125 X 2 = 0.400390625  0
0.400390625 X 2 = 0.80078125  0
0.80078125 X 2 = 1.6015625  1
0.6015625 X 2 = 1.203125  1
0.203125 X 2 = 0.40625  0
0.40625 X 2 = 0.8125  0
0.8125 X 2 = 1.625  1
0.625 X 2 = 1.25  1
0.25 X 2 = 0.5  0
0.5 X 2 = 1.0  1

// Result
1100.100011001100110011001100110011001100110011001101
or (fractional of 16 bit)
1100.10001100110011001

Example 2
-----------
num = 99.14

99 = 1100011 (Binary of whole number)

Calculate fractional

0.14 X 2 = 0.28  0
0.28 X 2 = 0.56  0
0.56 X 2 = 1.12  1
0.1200000000000001 X 2 = 0.2400000000000002  0
0.2400000000000002 X 2 = 0.4800000000000004  0
0.4800000000000004 X 2 = 0.9600000000000009  0
0.9600000000000009 X 2 = 1.9200000000000017  1
0.9200000000000017 X 2 = 1.8400000000000034  1
0.8400000000000034 X 2 = 1.6800000000000068  1
0.6800000000000068 X 2 = 1.3600000000000136  1
0.36000000000001364 X 2 = 0.7200000000000273  0
0.7200000000000273 X 2 = 1.4400000000000546  1
0.44000000000005457 X 2 = 0.8800000000001091  0
0.8800000000001091 X 2 = 1.7600000000002183  1
0.7600000000002183 X 2 = 1.5200000000004366  1
0.5200000000004366 X 2 = 1.0400000000008731  1
0.040000000000873115 X 2 = 0.08000000000174623  0
0.08000000000174623 X 2 = 0.16000000000349246  0
0.16000000000349246 X 2 = 0.3200000000069849  0
0.3200000000069849 X 2 = 0.6400000000139698  0
0.6400000000139698 X 2 = 1.2800000000279397  1
0.2800000000279397 X 2 = 0.5600000000558794  0
0.5600000000558794 X 2 = 1.1200000001117587  1
0.12000000011175871 X 2 = 0.24000000022351742  0
0.24000000022351742 X 2 = 0.48000000044703484  0
0.48000000044703484 X 2 = 0.9600000008940697  0
0.9600000008940697 X 2 = 1.9200000017881393  1
0.9200000017881393 X 2 = 1.8400000035762787  1
0.8400000035762787 X 2 = 1.6800000071525574  1
0.6800000071525574 X 2 = 1.3600000143051147  1
0.36000001430511475 X 2 = 0.7200000286102295  0
0.7200000286102295 X 2 = 1.440000057220459  1
0.440000057220459 X 2 = 0.880000114440918  0
0.880000114440918 X 2 = 1.760000228881836  1
0.7600002288818359 X 2 = 1.5200004577636719  1
0.5200004577636719 X 2 = 1.0400009155273438  1
0.04000091552734375 X 2 = 0.0800018310546875  0
0.0800018310546875 X 2 = 0.160003662109375  0
0.160003662109375 X 2 = 0.32000732421875  0
0.32000732421875 X 2 = 0.6400146484375  0
0.6400146484375 X 2 = 1.280029296875  1
0.280029296875 X 2 = 0.56005859375  0
0.56005859375 X 2 = 1.1201171875  1
0.1201171875 X 2 = 0.240234375  0
0.240234375 X 2 = 0.48046875  0
0.48046875 X 2 = 0.9609375  0
0.9609375 X 2 = 1.921875  1
0.921875 X 2 = 1.84375  1
0.84375 X 2 = 1.6875  1
0.6875 X 2 = 1.375  1
0.375 X 2 = 0.75  0
0.75 X 2 = 1.5  1
0.5 X 2 = 1.0  1
Given Number : 99.14
Result .00100011110101110000101000111101011100001010001111011
or 16 bits
1100011.0010001111010111
``````

The binary representation of the fractional part of 0.55 is approximately 0.1000110011001100...

Therefore, the complete binary representation of 12.55 is 1100.1000110011001100...

## Idea to Solve the Problem

To solve this problem, we need to separate the integer and fractional parts of the given number. Then, we'll convert each part to its binary representation and combine them to get the final binary representation of the number.

## Pseudocode

Here's the pseudocode for the solution:

``````function binaryNo(num)
if num < 0
return
end if
whole = integer part of num
fractional = num - whole
result = ""

while whole > 0
result = (whole % 2) + result
whole = whole / 2
end while

result += "."
bit = 0

while fractional > 0 and bit < 16
fractional = fractional * 2
if integer part of fractional is 1
fractional = fractional - 1
result += "1"
else
result += "0"
end if
bit += 1
end while

output "Given Number:", num
output "Result:", result
end function

main
end main``````

## Algorithm Explanation

1. The `binaryNo` function takes a single parameter, `num`, representing the fractional whole number to be converted.
2. It separates the integer and fractional parts of the number using the modulo operation and subtraction.
3. The integer part is converted to binary using a loop that continuously divides the integer by 2 and appends the remainder to the result.
4. A decimal point is added to the result to prepare for the fractional part's conversion.
5. The fractional part is converted to binary using a loop that multiplies the fractional part by 2 and checks the integer part of the result. If it's 1, the result gets a "1," otherwise, a "0."
6. The process is repeated for up to 16 bits of the fractional part.
7. The final binary representation is printed along with the original number.

## Code Solution

``````// Java Program
// Convert the fractional whole number to binary
public class Conversion
{
public void binaryNo(double num)
{
if (num < 0)
{
return;
}
// Get whole number
int whole = (int) num;
// Get approximate fraction part
double fractional = (num - whole);
String result = "";
// Find binary of whole number
while (whole > 0)
{
result = (whole % 2) + result;
whole /= 2;
}
result += ".";
int bit = 0;
// Find binary of fractional number
// Consider it up to 16 digit
while (fractional > 0 && bit < 16)
{
fractional *= 2;
if ((int) fractional == 1)
{
fractional = fractional - 1;
result += "1";
}
else
{
result += "0";
}
// increase counter of a fraction bits
bit += 1;
}
System.out.print("\n Given Number : " + num);
// Display calculated result
System.out.print("\n Result " + result);
}
public static void main(String[] args)
{
// Test Case
}
}``````

#### Output

`````` Given Number : 12.55
Result 1100.1000110011001100
Given Number : 99.14
Result 1100011.0010001111010111``````
``````// Include header file
#include <iostream>
#include <string>
using namespace std;
// C++ Program
// Convert the fractional whole number to binary
class Conversion
{
public: void binaryNo(double num)
{
if (num < 0)
{
return;
}
// Get whole number
int whole = (int) num;
// Get approximate fraction part
double fractional = (num - whole);
string result = "";
// Find binary of whole number
while (whole > 0)
{
result = to_string(whole % 2) + result;
whole /= 2;
}
result += ".";
int bit = 0;
// Find binary of fractional number
// Consider it up to 16 digit
while (fractional > 0 && bit < 16)
{
fractional *= 2;
if ((int) fractional == 1)
{
fractional = fractional - 1;
result += "1";
}
else
{
result += "0";
}
// increase counter of a fraction bits
bit += 1;
}
cout << "\n Given Number : " << num;
// Display calculated result
cout << "\n Result " << result;
}
};
int main()
{
// Test Case
return 0;
}``````

#### Output

`````` Given Number : 12.55
Result 1100.1000110011001100
Given Number : 99.14
Result 1100011.0010001111010111``````
``````// Include namespace system
using System;
// C# Program
// Convert the fractional whole number to binary
public class Conversion
{
public void binaryNo(double num)
{
if (num < 0)
{
return;
}
// Get whole number
int whole = (int) num;
// Get approximate fraction part
double fractional = (num - whole);
String result = "";
// Find binary of whole number
while (whole > 0)
{
result = (whole % 2) + result;
whole /= 2;
}
result += ".";
int bit = 0;
// Find binary of fractional number
// Consider it up to 16 digit
while (fractional > 0 && bit < 16)
{
fractional *= 2;
if ((int) fractional == 1)
{
fractional = fractional - 1;
result += "1";
}
else
{
result += "0";
}
// increase counter of a fraction bits
bit += 1;
}
Console.Write("\n Given Number : " + num);
// Display calculated result
Console.Write("\n Result " + result);
}
public static void Main(String[] args)
{
// Test Case
}
}``````

#### Output

`````` Given Number : 12.55
Result 1100.1000110011001100
Given Number : 99.14
Result 1100011.0010001111010111``````
``````<?php
// Php Program
// Convert the fractional whole number to binary
class Conversion
{
public	function binaryNo(\$num)
{
if (\$num < 0)
{
return;
}
// Get whole number
\$whole = (int) \$num;
// Get approximate fraction part
\$fractional = (\$num - \$whole);
\$result = "";
// Find binary of whole number
while (\$whole > 0)
{
\$result = (\$whole % 2) . \$result;
\$whole = intval(\$whole / 2);
}
\$result .= ".";
\$bit = 0;
// Find binary of fractional number
// Consider it up to 16 digit
while (\$fractional > 0 && \$bit < 16)
{
\$fractional *= 2;
if ((int) \$fractional == 1)
{
\$fractional = \$fractional - 1;
\$result .= "1";
}
else
{
\$result .= "0";
}
// increase counter of a fraction bits
\$bit += 1;
}
echo "\n Given Number : ". \$num;
// Display calculated result
echo "\n Result ". \$result;
}
}

function main()
{
}
main();``````

#### Output

`````` Given Number : 12.55
Result 1100.1000110011001100
Given Number : 99.14
Result 1100011.0010001111010111``````
``````// Node Js Program
// Convert the fractional whole number to binary
class Conversion
{
binaryNo(num)
{
if (num < 0)
{
return;
}
// Get whole number
var whole = parseInt(num);
// Get approximate fraction part
var fractional = (num - whole);
var result = "";
// Find binary of whole number
while (whole > 0)
{
result = (whole % 2) + result;
whole = parseInt(whole / 2);
}
result += ".";
var bit = 0;
// Find binary of fractional number
// Consider it up to 16 digit
while (fractional > 0 && bit < 16)
{
fractional *= 2;
if (parseInt(fractional) == 1)
{
fractional = fractional - 1;
result += "1";
}
else
{
result += "0";
}
// increase counter of a fraction bits
bit += 1;
}
process.stdout.write("\n Given Number : " + num);
// Display calculated result
process.stdout.write("\n Result " + result);
}
}

function main()
{
// Test Case
}
main();``````

#### Output

`````` Given Number : 12.55
Result 1100.1000110011001100
Given Number : 99.14
Result 1100011.0010001111010111``````
``````#  Python 3 Program
#  Convert the fractional whole number to binary
class Conversion :
def binaryNo(self, num) :
if (num < 0) :
return

#  Get whole number
whole = int(num)
#  Get approximate fraction part
fractional = (num - whole)
result = ""
#  Find binary of whole number
while (whole > 0) :
result = str(whole % 2) + result
whole = int(whole / 2)

result += "."
bit = 0
#  Find binary of fractional number
#  Consider it up to 16 digit
while (fractional > 0 and bit < 16) :
fractional *= 2
if (int(fractional) == 1) :
fractional = fractional - 1
result += "1"
else :
result += "0"

#  increase counter of a fraction bits
bit += 1

print("\n Given Number : ", num, end = "")
#  Display calculated result
print("\n Result ", result, end = "")

def main() :
#  Test Case

if __name__ == "__main__": main()``````

#### Output

`````` Given Number :  12.55
Result  1100.1000110011001100
Given Number :  99.14
Result  1100011.0010001111010111``````
``````#  Ruby Program
#  Convert the fractional whole number to binary
class Conversion
def binaryNo(num)
if (num < 0)
return
end

#  Get whole number
whole = (num).to_i
#  Get approximate fraction part
fractional = (num - whole)
result = ""
#  Find binary of whole number
while (whole > 0)
result = (whole % 2).to_s + result
whole /= 2
end

result += "."
bit = 0
#  Find binary of fractional number
#  Consider it up to 16 digit
while (fractional > 0 && bit < 16)
fractional *= 2
if ((fractional).to_i == 1)
fractional = fractional - 1
result += "1"
else
result += "0"
end

#  increase counter of a fraction bits
bit += 1
end

print("\n Given Number : ", num)
#  Display calculated result
print("\n Result ", result)
end

end

def main()
#  Test Case
end

main()``````

#### Output

`````` Given Number : 12.55
Result 1100.1000110011001100
Given Number : 99.14
Result 1100011.0010001111010111``````
``````// Scala Program
// Convert the fractional whole number to binary
class Conversion
{
def binaryNo(num: Double): Unit = {
if (num < 0)
{
return;
}
// Get whole number
var whole: Int = (num).toInt;
// Get approximate fraction part
var fractional: Double = (num - whole);
var result: String = "";
// Find binary of whole number
while (whole > 0)
{
result = ""+(whole % 2) + result;
whole = (whole / 2).toInt;
}
result += ".";
var bit: Int = 0;
// Find binary of fractional number
// Consider it up to 16 digit
while (fractional > 0 && bit < 16)
{
fractional *= 2;
if ((fractional).toInt == 1)
{
fractional = fractional - 1;
result += "1";
}
else
{
result += "0";
}
// increase counter of a fraction bits
bit += 1;
}
print("\n Given Number : " + num);
// Display calculated result
print("\n Result " + result);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Conversion = new Conversion();
// Test Case
}
}``````

#### Output

`````` Given Number : 12.55
Result 1100.1000110011001100
Given Number : 99.14
Result 1100011.0010001111010111``````
``````// Swift 4 Program
// Convert the fractional whole number to binary
class Conversion
{
func binaryNo(_ num: Double)
{
if (num < 0)
{
return;
}
// Get whole number
var whole: Int = Int(num);
// Get approximate fraction part
var fractional: Double = (num - Double(whole));
var result: String = "";
// Find binary of whole number
while (whole > 0)
{
result = String(whole % 2) + result;
whole /= 2;
}
result += ".";
var bit: Int = 0;
// Find binary of fractional number
// Consider it up to 16 digit
while (fractional > 0 && bit < 16)
{
fractional *= 2;
if (Int(fractional) == 1)
{
fractional = fractional - 1;
result += "1";
}
else
{
result += "0";
}
// increase counter of a fraction bits
bit += 1;
}
print("\n Given Number : ", num, terminator: "");
// Display calculated result
print("\n Result ", result, terminator: "");
}
}
func main()
{
// Test Case
}
main();``````

#### Output

`````` Given Number :  12.55
Result  1100.1000110011001100
Given Number :  99.14
Result  1100011.0010001111010111``````
``````// Kotlin Program
// Convert the fractional whole number to binary
class Conversion
{
fun binaryNo(num: Double): Unit
{
if (num < 0)
{
return;
}
// Get whole number
var whole: Int = num.toInt();
// Get approximate fraction part
var fractional: Double = (num - whole.toDouble());
var result: String = "";
// Find binary of whole number
while (whole > 0)
{
result = (whole % 2).toString() + result;
whole /= 2;
}
result += ".";
var bit: Int = 0;
// Find binary of fractional number
// Consider it up to 16 digit
while (fractional > 0 && bit < 16)
{
fractional *= 2;
if (fractional.toInt() == 1)
{
fractional = fractional - 1;
result += "1";
}
else
{
result += "0";
}
// increase counter of a fraction bits
bit += 1;
}
print("\n Given Number : " + num);
// Display calculated result
print("\n Result " + result);
}
}
fun main(args: Array < String > ): Unit
{
// Test Case
}``````

#### Output

`````` Given Number : 12.55
Result 1100.1000110011001100
Given Number : 99.14
Result 1100011.0010001111010111``````

## Resultant Output Explanation

Running the program results in the following output:

``````Given Number : 12.55
Result: 1100.1000110011001

Given Number : 99.14
Result: 1100011.00100011110101``````

The output showcases the binary representations of the given fractional whole numbers. For example, the first line indicates that the binary representation of 12.55 starts with "1100" for the integer part and continues with the approximate binary representation of the fractional part.

## Time Complexity

The time complexity of the conversion process depends on the number of bits needed to represent the integer and fractional parts. The integer part requires logarithmic time with respect to the base 2 of the input number. The fractional part's conversion has a fixed iteration count (up to 16 bits). Thus, the time complexity can be considered O(log n), where n is the given number.

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.