It's hard to know exactly what you are asking for here. I'll make an assumption that you have a list of floating point sets {Sign, Exp, Mantiss}. If so, you could use replacement:

In[4]:= fps = {{-1,-4,1.2345},{1,2,9.8765}}
Out[4]= {{-1,-4,1.2345},{1,2,9.8765}}
In[5]:= fps/.{a_,b_,c_}->a c 10^b
Out[5]= {-0.00012345,987.65}

The replacement rule at In[5] simply places the numbers in their proper location.

EDIT: note that I assumed an exponent base of 10 and I used mantissa that are themselves decimals and this is not a straight from binary code, which would be implementation specific anyhow.

My bad, I should have given an example as well.

I have some value displayed in double precision fp format:

0.01111111111.1001111110011001100110011001100110011001100110011010 

OBS. the dots are not supposed to be there, I've just put them there manually to help you distinguish the different parts (S, Exp, M).

And would like to convert it into lets say, scientific form.

It doesn't seem possible to use the replace function (/.) with binary numbers. Tried to do something similar:

In[101]:= fps = {0 , 011, 1111}

Out[101]= {0, 11, 1111}

In[107]:= fps /. {a_, b_, c_} -> 2^^b

During evaluation of In[107]:= General::digit: Digit at position 1 in b is too large to be used in base 2. >>

Cheers

I show interconversion with floating point and real number.

(* convert to IEEE 754 single precision floating point  binary seqence (length: 32) from number *)
real32Digits[x_] := 
 IntegerDigits[
  First[ImportString[ExportString[x, "Real32"], "UnsignedInteger32"]],
   2, 32]

(* generate {Sign, Exp, Mantissa} list from Real 32 binary sequence (except special number) *)
real32Format[li_] :=
 {If[First[li] === 0, 1, -1],
  FromDigits[Take[li, {2, 9}], 2] - 2^7 + 1,
  FromDigits[{Join[{1}, Take[li, {10, 32}]], 1}, 2]}

(* convert to real number from Real32 binary sequence *)
fromReal32Digits[li_] := First[ImportString[ExportString[FromDigits[li, 2], "UnsignedInteger32"], "Real32"]]

Example:

In[1] := real32Digits[-118.625]
Out[1] := {1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, \
0, 0, 0, 0, 0, 0, 0, 0, 0}

In[2]:= real32Format[%]
Out[2] := {-1, 6, 949/512}

In[3] := fromReal32Digits[%%]
Out[3] := -118.625

Mathematica supports floating point representations; Real16, Real32, Real64, and Real128.

refer to

IEEE floating point - Wikipedia, the free encyclopedia

Binary Data—Wolfram Mathematica 9 Documentation

appendix: Coloring parts of floating point sequence

nLi = IntegerDigits[First[ImportString[ExportString[-118.625, "Real32"], "UnsignedInteger32"]], 2, 32]
sgnLi = Take[nLi, 1]; (* Sign *)
eLi = Take[nLi, {2, 9}]; (* Exp *)
sLi = Take[nLi, {10, 32}]; (* Mantissa *)
Grid[{Join @@ {Item[#, Background -> LightBlue] & /@ sgnLi, 
    Item[#, Background -> LightGreen] & /@ eLi, 
    Item[#, Background -> LightRed] & /@ sLi}}]

Thanks Yuki, exactly what I was looking for. Highly appreciated.

Cheers