#!/usr/bin/perl

########
##
##	DeciHexaBinMod_USE3.pl -> 6/4/2011 ->
##
##  More recent versions may exist to better handle rounding
##
##  accepts a decimal value and returns 
##  32 bit floating point hex and bin values
##
##  tested to .00000001
##  returns
##  00110010001010111100110001110111
##  322BCC77
##
##  fails at .000000001
##  returns 
##  00000000000000000000000000000000
##  00000000
##  
########

####
#### All Code by Steve Michel
####


$Test = $ARGV[0];  ## Accepts initial decimal value entered as first argument

if ($Test eq ""){
		$Test = 329.390625;} ## if no initial decimal value entered

print "source     " . $Test . "\n";

if ($Test >= 0){
	$Sign = 0;}
	
if ($Test < 0){
	$Sign = 1;}
	
	
$IntTest = int($Test);
$AbsIntTest = abs($IntTest);
#	print "Abs of " . $IntTest .  "    ABS =    " . $AbsIntTest . "\n";

$BinTest = sprintf ("%b",$AbsIntTest);

#	print "Integer   " . $IntTest .  "    Binary of Integer   " . $BinTest . "\n";

$right = int(abs ($Test -  int($Test))*100000000);
$right =  $right / 100000000;

#	print "Stuff to Right of decimal  " . $right . "\n";

$NewBin = $BinTest;
$LenNewBin = length($NewBin);
$LessLenNewBin = $LenNewBin -1;
$MantissaBinStart = substr($NewBin,1,$LessLenNewBin);
#	print "length of Binary is  " . $LenNewBin ;
#	print "\n";


###########  if integer is 1 or greater then determine exponent

if ($Test == 0){
	$HexBits = "00000000";
}


if ($AbsIntTest >= 1){
 for($expTest = 0; $expTest <=128;$expTest ++){
#		print "potential Binary " . $NewBin . "    potential exp " . $expTest;
#		print "\n";

	if (int($NewBin)==1){
		$ExpUSE = $expTest + 127;
		$BinExpUSE = sprintf ("%b",$ExpUSE);
		$Mantissa = $NewBin;
		$expTest = 128;
		}
	$NewBin = $NewBin /10;
	}

	$PrintExp = $ExpUSE;
	
#	print "exp + 127 for positive integers = " . $ExpUSE . "    and in Binary =  " . $BinExpUSE;
#	print "\n";

#	print "Sign = " . $Sign; 
#	print "\n";

################# BreakDown $Right

	$LoopThing[1] = $right;
#	print $LoopThing[1];
#	print "\n";
#	print "\n";

	$BinLoop = 1;
	$LoopThing[$BinLoop] = $LoopThing[$BinLoop] * 10000000;	
	
	for ($BinLoop = 1; $BinLoop<=(26);$BinLoop++){	
				
	$NextThing[$BinLoop] = $LoopThing[$BinLoop] * 2;
	
	$NextThing[$BinLoop] =($NextThing[$BinLoop])/10000000;
	
	$BinVal[$BinLoop] = int($NextThing[$BinLoop]);
	
#		print $BinLoop . "   " . ($LoopThing[$BinLoop]/10000000) . " x 2 = " . $NextThing[$BinLoop] . " with Bin Val = " . $BinVal[$BinLoop];
#		print "\n";
	
	$DealWithFP_Int = $NextThing[$BinLoop] * 10000000;
	$DealWithFP_Dec = int($NextThing[$BinLoop]) * 10000000;
	
	$DealWithFP = $DealWithFP_Int - $DealWithFP_Dec;
	
#		print $DealWithFP_Int . "  " . $DealWithFP_Dec . " " . $DealWithFP;
#		print "\n";
	
	$LoopThing[$BinLoop + 1] = (($DealWithFP));
		
		}#End BinLoop
	


$ExponentLength = length($BinExpUSE);
	
$ExpFill = "";
if ($ExponentLength == 8){$ExpFill = "";}
if ($ExponentLength == 7){$ExpFill = "0";}
if ($ExponentLength == 6){$ExpFill = "00";}
if ($ExponentLength == 5){$ExpFill = "000";}
if ($ExponentLength == 4){$ExpFill = "0000";}
if ($ExponentLength == 3){$ExpFill = "00000";}
if ($ExponentLength == 2){$ExpFill = "000000";}
if ($ExponentLength == 1){$ExpFill = "0000000";}
if ($ExponentLength == 0){$ExpFill = "00000000";}

		

#		print "sign       " . $Sign;
#		print "\n";
#		print "exponent   " . $ExpFill . $BinExpUSE;
#		print "\n";
#		print "mantissa   1." .$MantissaBinStart;
#		print " ";
		
	$BinAdd = "" ;
	for ($BinLoop = 1; $BinLoop<=(25);$BinLoop++){
	$BinAdd = $BinAdd . $BinVal[$BinLoop];
#	print $BinVal[$BinLoop] . "";	
}
#	print "\n";
#	print "hello world 2" . "\n";
	
	$MantissaPrint = $MantissaBinStart . $BinAdd;

	$TotalBinPrep = $Sign . $ExpFill . $BinExpUSE . $MantissaBinStart . $BinAdd;
#	print "\n";
#	print $TotalBinPrep;
#	print "\n";
	$LenTotalBin= length($TotalBinPrep);
#	print $LenTotalBin;
#	print "\n";
	
	$TotalBin = substr($TotalBinPrep,0,32);
#	print $TotalBin;

##########Now break it into bits - 4 bit pieces
$Increment=0;

 for($BitLoop = 1; $BitLoop <= 8; $BitLoop++){
	 
$BitPrep[$BitLoop] = substr($TotalBin,$Increment,4);
#	print $BitPrep[$BitLoop];
#print " ";
$Increment = $Increment +4;
}
#	print "\n";
#	print "\n";

for($BitLoop = 1; $BitLoop <= 8; $BitLoop++){
#	print $BitPrep[$BitLoop];
#	print " ";
}
#	print "\n";

$adHexBit = "";
for($BitLoop = 1; $BitLoop <= 8; $BitLoop++){

	if ($BitPrep[$BitLoop] eq "0000"){$HexPrep[$BitLoop] = "0"};
	if ($BitPrep[$BitLoop] eq "0001"){$HexPrep[$BitLoop] = "1"};
	if ($BitPrep[$BitLoop] eq "0010"){$HexPrep[$BitLoop] = "2"};
	if ($BitPrep[$BitLoop] eq "0011"){$HexPrep[$BitLoop] = "3"};
	if ($BitPrep[$BitLoop] eq "0100"){$HexPrep[$BitLoop] = "4"};
	if ($BitPrep[$BitLoop] eq "0101"){$HexPrep[$BitLoop] = "5"};
	if ($BitPrep[$BitLoop] eq "0110"){$HexPrep[$BitLoop] = "6"};
	if ($BitPrep[$BitLoop] eq "0111"){$HexPrep[$BitLoop] = "7"};
	if ($BitPrep[$BitLoop] eq "1000"){$HexPrep[$BitLoop] = "8"};
	if ($BitPrep[$BitLoop] eq "1001"){$HexPrep[$BitLoop] = "9"};
	if ($BitPrep[$BitLoop] eq "1010"){$HexPrep[$BitLoop] = "A"};
	if ($BitPrep[$BitLoop] eq "1011"){$HexPrep[$BitLoop] = "B"};
	if ($BitPrep[$BitLoop] eq "1100"){$HexPrep[$BitLoop] = "C"};
	if ($BitPrep[$BitLoop] eq "1101"){$HexPrep[$BitLoop] = "D"};
	if ($BitPrep[$BitLoop] eq "1110"){$HexPrep[$BitLoop] = "E"};
	if ($BitPrep[$BitLoop] eq "1111"){$HexPrep[$BitLoop] = "F"};

	$adHexBit = $adHexBit . $HexPrep[$BitLoop];
}

$HexBits = $adHexBit;




}	#End if ($AbsIntTest >= 1)
###############################################
###############################################
#
#
# now working out the ABS val less than 1
#
#
###############################################
###############################################
else { 
	if ($AbsIntTest < 1){
#		print "ABS VAlUE OF INTEGER IS LESS THAN ONE -  solution soon";
#		print "\n";
#		print $Test;
#		print "\n";
#		print $right	
		
	$Recursion = 50;	
		
	$LoopThing[1] = $right;			
	$BinLoop = 1;
	$LoopThing[$BinLoop] = $LoopThing[$BinLoop] * 10000000;	
	
	for ($BinLoop = 1; $BinLoop<=$Recursion;$BinLoop++){	
	
			
	$NextThing[$BinLoop] = $LoopThing[$BinLoop] * 2;
	
	$NextThing[$BinLoop] =($NextThing[$BinLoop])/10000000;
	
	$BinVal[$BinLoop] = int($NextThing[$BinLoop]);
	
#		print $BinLoop . "   " . ($LoopThing[$BinLoop]/10000000) . " x 2 = " . $NextThing[$BinLoop] . " with Bin Val = " . $BinVal[$BinLoop];
#		print "\n";
	
	$DealWithFP_Int = $NextThing[$BinLoop] * 10000000;
	$DealWithFP_Dec = int($NextThing[$BinLoop]) * 10000000;
	
	$DealWithFP = $DealWithFP_Int - $DealWithFP_Dec;
	
#		print $DealWithFP_Int . "  " . $DealWithFP_Dec . " " . $DealWithFP;
#		print "\n";
	
	$LoopThing[$BinLoop + 1] = (($DealWithFP));
		
		}#End BinLoop					

		$AddBinVal = "";
		for ($BinLoop = 1; $BinLoop<=$Recursion;$BinLoop++){
#			print $BinVal[$BinLoop];
			$AddBinVal = $AddBinVal . $BinVal[$BinLoop];
		}
#		print "\n";
#		print "hello world";
#		print $AddBinVal;
#		print "\n";
		
		for ($BinLoop = 1; $BinLoop<=$Recursion;$BinLoop++){
			if ($BinVal[$BinLoop] ==1){
				$ExpTemp = $BinLoop;
				$ExpNow = $BinLoop * -1;
				$ExpNowUSE = $ExpNow + 127;
				$BinLoop = $Recursion;
			}
		
		}
		
#		$BitPrep[$BitLoop] = substr($TotalBin,$Increment,4);
        $MantissaPrep = substr($AddBinVal,$ExpTemp,23);	
        
        for($gapfill = 1;$gapfill <= $ExpTemp; $gapfill++){
#	        print "x";
        }
        
#       print "\n";
#		print "hello world";
#		print $MantissaPrep;
#		print "\n";
#		print "\n";
        	
		
		$PrintExp = $ExpNowUSE;
		
		
		$BinExpUSE = sprintf ("%b",$ExpNowUSE);
		$ExponentLength = length($BinExpUSE);	
		
		$ExpFill = "";
		if ($ExponentLength == 8){$ExpFill = "";}
		if ($ExponentLength == 7){$ExpFill = "0";}
		if ($ExponentLength == 6){$ExpFill = "00";}
		if ($ExponentLength == 5){$ExpFill = "000";}
		if ($ExponentLength == 4){$ExpFill = "0000";}
		if ($ExponentLength == 3){$ExpFill = "00000";}
		if ($ExponentLength == 2){$ExpFill = "000000";}
		if ($ExponentLength == 1){$ExpFill = "0000000";}
		if ($ExponentLength == 0){$ExpFill = "00000000";}
	
#		print "\n";
#		print $ExpNow . "    Exponent   "  . $ExpNowUSE . "   and in bin =  " . $ExpFill . $BinExpUSE;
#		print "\n";
#		print "\n";
		
		$MantissaPrint = $MantissaPrep;

#		print "sign       " . $Sign;
#		print "\n";
#		print "exponent   " . $ExpFill . $BinExpUSE;
#		print "\n";
#		print "mantissa   1." . $MantissaPrint;
#		print "\n";
#		print "\n";
		
		$TotalBin = $Sign . $ExpFill . $BinExpUSE . $MantissaPrep;	
#		print "Binary   " . $TotalBin;
		
		
		##########Now break it into bits - 4 bit pieces
		$Increment=0;
		for($BitLoop = 1; $BitLoop <= 8; $BitLoop++){
	 
		$BitPrep[$BitLoop] = substr($TotalBin,$Increment,4);
#		print $BitPrep[$BitLoop];
#		print " ";
		$Increment = $Increment +4;
		}
#		print "\n";
#		print "\n";

		for($BitLoop = 1; $BitLoop <= 8; $BitLoop++){
#		print $BitPrep[$BitLoop];
#		print " ";
		}
#		print "\n";

		$adHexBit = "";
		for($BitLoop = 1; $BitLoop <= 8; $BitLoop++){

			if ($BitPrep[$BitLoop] eq "0000"){$HexPrep[$BitLoop] = "0"};
			if ($BitPrep[$BitLoop] eq "0001"){$HexPrep[$BitLoop] = "1"};
			if ($BitPrep[$BitLoop] eq "0010"){$HexPrep[$BitLoop] = "2"};
			if ($BitPrep[$BitLoop] eq "0011"){$HexPrep[$BitLoop] = "3"};
			if ($BitPrep[$BitLoop] eq "0100"){$HexPrep[$BitLoop] = "4"};
			if ($BitPrep[$BitLoop] eq "0101"){$HexPrep[$BitLoop] = "5"};
			if ($BitPrep[$BitLoop] eq "0110"){$HexPrep[$BitLoop] = "6"};
			if ($BitPrep[$BitLoop] eq "0111"){$HexPrep[$BitLoop] = "7"};
			if ($BitPrep[$BitLoop] eq "1000"){$HexPrep[$BitLoop] = "8"};
			if ($BitPrep[$BitLoop] eq "1001"){$HexPrep[$BitLoop] = "9"};
			if ($BitPrep[$BitLoop] eq "1010"){$HexPrep[$BitLoop] = "A"};
			if ($BitPrep[$BitLoop] eq "1011"){$HexPrep[$BitLoop] = "B"};
			if ($BitPrep[$BitLoop] eq "1100"){$HexPrep[$BitLoop] = "C"};
			if ($BitPrep[$BitLoop] eq "1101"){$HexPrep[$BitLoop] = "D"};
			if ($BitPrep[$BitLoop] eq "1110"){$HexPrep[$BitLoop] = "E"};
			if ($BitPrep[$BitLoop] eq "1111"){$HexPrep[$BitLoop] = "F"};

			$adHexBit = $adHexBit . $HexPrep[$BitLoop];
		}

		$HexBits = $adHexBit;
		

	} ## End if ($Test > 0)


} ## end Else

		$PrintExpUse = $ExpFill . $BinExpUSE;
#		$decExp = sprintf("%d", $int);
#		print "\n";

#		print "Exp  xxxxx  " . $PrintExp;

		$FinalExp = $PrintExp - 127;
		
		if ($Sign eq "0"){$SignText = "Pos";}
		if ($Sign eq "1"){$SignText = "Neg";}
		if ($Sign eq "0"){$SignValue = 1;}
		if ($Sign eq "1"){$SignValue = -1;}
		
		print "\n";
		print "sign       " . $Sign . " = " . $SignText;
		print "\n";
		print "exponent   " . $PrintExpUse . "   decimal = " . $PrintExp . " - 127 = " . $FinalExp;
		print "\n";


		$MantissaPrint23 = substr($MantissaPrint,0,23);	
		$LenMantissaPrint = length($MantissaPrint23);
		print $LenMantissaPrint . "    ";

#		$MantissaPrint = "1." . $MantissaPrint23;
		$MantissaPrint = "(1.)" . $MantissaPrint23;
		print "mantissa   " . $MantissaPrint;
#		print "\n";
		
		$DecTotal = 1;
		$AltDecTotal = 1;
		$DecInc = 0;
		
		for($NewDecLoop=0;$NewDecLoop<=23;$NewDecLoop++){
			$DecBuild[$NewDecLoop] = substr($MantissaPrint23,$DecInc,1);
			$AltDecBuild[$NewDecLoop] = substr($MantissaPrint23,$DecInc,1);
#			print "\n";
#			print $DecBuild[$NewDecLoop];	
			$DecInc = $DecInc + 1;
			}
#		print "\n";
			
#		for($NewDecLoop=0;$NewDecLoop<=24;$NewDecLoop++){
#			print $DecBuild[$NewDecLoop];
#			}
		
#		print "\n";
#		print "\n";
		
		for($NewDecLoop=0;$NewDecLoop<=24;$NewDecLoop++){
			$DecExpBuild[$NewDecLoop] = ($DecBuild[$NewDecLoop]) * (2**(($NewDecLoop+1) * -1));
			$DecTotal = $DecTotal  + $DecExpBuild[$NewDecLoop];
#			print $DecExpBuild[$NewDecLoop];
#			print "\n";
			}
		$DecTotal = $SignValue * ($DecTotal * (2**$FinalExp));
	
##  Here is where to Eval $DecTotal
##  if $DecTotal = $Test then "we have a winner"
##  if $DecTotal <> $Test then eval $MantissaPrint23
##
##  so if $MantissaPrint23 end in 0 then re-calc with 1 and ...
##  and if $MantissaPrint23 end in 1 then re-calc with 0
##  which result closer to $Test
##  $$DecBuild[23] = final 0 or 1 so re-eval is easy
##  $AltDecBuild[$NewDecLoop] is now in place 
##
##  so if $DecBuild[23] == 0 then $AltDecBuild[23] == 1
## or
##  so if $DecBuild[23] == 1 then $AltDecBuild[23] == 0
## then rebuild with alt to get total
		
#		$NewDec = ($MantissaPrint * (2**$FinalExp));

if ($DecBuild[23] == 0){$AltDecBuild[23] = 1;}
if ($DecBuild[23] == 1){$AltDecBuild[23] = 0;}

		
		print "\n";
		print "\n";
		print "decimal value:";
		print "\n";
		print $DecTotal;
		print "\n";
		print "\n";
		print "Single precision (32 bits):";
		print "\n";
		print $TotalBin;
		print "\n";
		print $HexBits;

# end