Programmation des algorithmes de conversion

new_irem, new_iquo

Nouvelles définition pour la division entière et le reste de la division entière de telle façon que m=nq+r avec 0<r<|n| (et pas |r| < |n| et comme il est proposé en standart dans Maple).

new_irem:=proc(m,n)
local result;
option remember;
   result := irem(m,n);
   if result < 0 then result:=result-n; fi;
   if result>9 and (n=16 or n=-16) then 
       result:=op(result-9,[A,B,C,D,E,F]) 
   fi;
   RETURN(result);
end:

new_iquo:=proc(m,n)
local result;
option remember;
   result := iquo(m,n);
   if irem(m,n) < 0 then result:=result+1; fi;
   RETURN(result);
end:

radix_int

Cette fonction réalise trait pour trait l'algorithme de conversion du nombre entier u en base B. Le résultat est donné sous la forme d'une liste de chiffres rangés de telle façon que les chiffres les plus significatifs soient en tête de liste.

radix_int := proc(u,B) 
local U, u_local;
option remember;
    if u < 0 and B > 0 then RETURN(-radix_int(-u,B)) fi;
    U:=[]; u_local:=u;
    while u_local<>0 do
        U:=[new_irem(u_local,B), op(U)];
        u_local:=new_iquo(u_local,B);
    od;
    RETURN(U);
end:

Tant que u est non nul, je rajoute à la liste U le reste de la division entière de u par B puis je remplace u par le résultat de la division entière de u par B.

radix_frac1

Cette fonction réalise trait pour trait l'algorithme de conversion du nombre fractionnaire u en base B. Le résultat est donné sous la forme d'une liste de n chiffres rangés de telle façon que les chiffres les plus significatifs soient en tête de liste.

radix_frac1 := proc(u,B,n) 
local U, index, u_local; 
U:=[]; u_local:=u;
    for index from 1 to n by 1 do
        U:=[op(U), floor(u_local*B)];
        u_local:=frac(u_local*B);
    od;
    RETURN(U);
end:

Je répète n fois l'opération qui consiste à rajouter la partie entière de uB à la liste U puis à remplacer u par la partie fractionnaire positive de uB.

radix_frac2

Cette fonction réalise en principe la même chose que la fonction précédante, mais de manière différente. En multipliant u par , je décalle la virgule de représentation de u en base B de n chiffres vers la gauche. En conséquence la représentation en base B de la partie entière de correspond exactement aux n premiers chiffres de la représentation enbase base B du nombre fractionnaire u.

radix_frac2 := proc(u,B,n)
local result, OldDigits;
    oldDigits := Digits;
    Digits := max(10,ceil(evalf(log10(abs(B^n)))));
    result := radix_int(floor(B^n*u),B);
    if nops(result) < n then 
       result := [ 0$(n-nops(")),op(")];
    fi;
    Digits := oldDigits;
    RETURN(result);
end:

En théorie, la liste obtenue devrait contenir n chiffres. Mais comme on ne note jamais les premiers 0 dans une notation entière (on écrit pas 007 mais 7 - sauf cas très particuliers!), il faut rajouter les 0 qui ont disparu. C'est le sens de cette dernière instruction que de compléter les zéros manquants de la liste U.

On vérifie que la fonction donne des résultats cohérents avec les conversions obtenues au chapitre précédant:

 > radix_int(196,6);
 [5, 2, 4]
 > radix_int(314,2);
 [1, 0, 0, 1, 1, 1, 0, 1, 0]
 > radix_int(45408,16);
 [B, 1, 6, 0]
 > radix_int(340,8);
 [5, 2, 4]
 > radix_int(19,2);
 [1, 0, 0, 1, 1]
 > radix_int(19,8);
 [2, 3]
 > radix_int(19,16);
 [1, 3]