function[snb] = conversion(val, nb)

//  Conversion de la valeur val de double pr\'ecision 
//  en une valeur snb avec mantisse nb

    [s,l,r] = d2b(val, nb);
     snb = b2d(s, l,r);  
     
endfunction;     

//============================================
function[res] = b2d(s, lhs, rhs)

//  Conversion binaire vers d\'ecimlal
//   s = signe, lhs = partie enti\`ere, rhs = partie fractionnaire

//  Partie enti\`ere
     res = 0;
     p = 1;
     l = length(lhs);
     for i=0:l-1
           if (lhs(l-i) == 1) then res = res+p; end;
           p = p*2;
     end;

//  Partie fractionnaire

   p = 1/2;
   l = length(rhs);
   for i = 1:l
       if(rhs(i) == 1) then res = res + p;  end;
       p = p/2;
   end;
   res = s * res;
   
endfunction;   


//============================================

function[s, lhsb, rhsb] =  d2b(nbr, nbBits);

//  Conversion d\'ecimal vers binaire, avec
//  nbr = d\'ecimal \`a convertir, mode = mode de conversion, 
//  nbBits = nombre bits de la mantisse

       nbra = abs(nbr);
       s = sign(nbr);
       lhs = floor(nbra);
       rhs = nbra - lhs;
                             
       lhsb = [];
       rhsb = [];

//  Partie enti\`ere

       i = 1;
       while (lhs <> 0)
          lhsb(i) = 0; 
          ml = lhs - 2 * int (lhs / 2)
          if (ml <> 0) then lhsb(i) = 1; end;
//          if (modulo(lhs, 2) <> 0) then lhsb(i) = 1; end;
          lhs = floor(lhs / 2);
          i = i+1;
       end;
       l = length(lhsb);
       if (l == 0) then
           lhsb(1) = 0;
           l = 1;
       end;    
       for i = 1:l
           aux(i) = lhsb(l-i+1);
       end;
       lhsb = aux;
 
//  Partie d\'ecimale

// Mode troncature
           for i = 1:nbBits
               rhsb(i) = floor(2 * rhs);
               rhs = 2*rhs - rhsb(i);
           end;
               
endfunction;   


//==============================================


