|
Sommaire
Multiplication
32 bits en 16 bits
Malgré les apparences, il n'est pas
impossible d'effectuer des multiplications en 32 bits sur un
processeurs 16 bits comme un 8088 et 8086. Pour ce faire, il suffit
d'effectuer les opérations en deux parties (par tranche de 16
bits) de les additions à la partie base ou haute (dépendamment
de la tranche en question).
Ces opérations est donc
équivalente à DX:AX = a x b:
|
LES
AX,a
; Valeur a
MOV
DX,ES
LES CX,b
; Valeur b
MOV
BX,ES
MOV SI,AX
MOV DI,DX
MUL CX
PUSH AX
PUSH DX
MOV AX,SI
MUL BX
MOV BX,AX
MOV AX,DI
MUL CX
MOV CX,AX
POP DX
POP AX
ADD DX,BX
ADD DX,CX
|
Comment
fixer un nombre Single en Real sans coprocesseur
mathématique
Étant
sans doute un programmeur un peu fou disons de façon un peu
plus poli ne voulant pas être à la merci d'une puce
électronique, j'ai rencontrer, à certain moment donnée,
en voulant charger le contenu d'une image de Studio 3D en
mémoire, des problèmes de conversion de nombre de
format Single à Real sans passer par un
coprocesseur mathématique lequel n'étant pas disponible
sur l'une de mes deux machines, c'est-à-dire celle posséder
un excellant microprocesseur 386AMD-40Mhz. Sachant très
bien que ce genre de situation a pu vous arrivez, car contrairement à
ce que les fabricants croient, nous ne fonctionnons pas tous sur des
Pentium INTEL. Au bout de multiples péripéties
ayant durant environ 5 heures, j'ai résolu le problème
en utilisant une technique assez simple de manipulation des octets de
façon individuel. Après se calvaire, ayant le sang
bouillant de vitriol et comprenant presque les paroles de la musique
allemande de Rammstein, j'ai
décidée de ne pas garder secret se genre de formule
exaigu. L'idée
réside essentiellement dans le fait de déplacer les
bits au bonne endroit en tenant compte des limites du format. En
voici d'ailleurs le code en langage de programmation Pascal:
|
Function SingleToReal(X:Single):Real;
Var
SingleByte:Record
A,B,C,D:Byte;
End
Absolute X;
Y:Real;
RealByte:Record
A,B,C,D,E,F:Byte;
End
Absolute Y;
Begin
Y:=0.0;
RealByte.A:=(SingleByte.D
shl 1)+1+((SingleByte.C
and$80)shr
6);
If(RealByte.A
and 1=1)and(SingleByte.D
and$F<>$F)Then
Inc(RealByte.A);
RealByte.D:=SingleByte.A;
RealByte.E:=SingleByte.B;
RealByte.F:=(SingleByte.C
and$7F)or(SingleByte.D
and$80);
SingleToReal:=Y;
End;
|
Si vous n'arrivez pas a une réponse
parfaitement exacte, vous n'avez qu'a utiliser des constantes en
fonction de l'octet SingleByte.D
envers RealByte.A, toutefois la
précision a toujours été suffisante pour mes
besoins logiciel, j'imagine que pour les vôtres aussi, en tout
cas cela vous donnera une piste intéressante afin que vous
compreniez le problème.
Comment
fixer un nombre Double en Real sans coprocesseur
mathématique
Plus
tard, m'ayant frotter, lorsque de je me suis frotter un l'écriture
d'un tableur supportant le format de Lotus 1-2-3, je dus me rendre
compte qu'un problème des plus choquant m'attendait à
nouveau, celui de devoir transformer leur format Double (un
format à virgule flottante) en format Real compatible
avec le compilateur Turbo Pascal . Bien qu'il soit possible à
l'aide d'un 80x87 avec se compilateur de transformer ses nombres d'un
format à l'autre, il est cependant impossible de le faire sans
coprocesseur mathématique. Je ne pouvais me résoudre à
l'idée d'être à la merci d'une puce électronique!
J'ai donc du élaborer des routines permettant de surmonter
cette situation. L'idée réside essentiellement dans le
fait de déplacer les bits au bonne endroit en tenant compte
des limites du format. Voici donc le code en langage de programmation
Pascal:
|
Type
TPReal=Record
Exponent:Byte;
Mantissa1:Word;
Mantissa2:Word;
MS:Byte;
End;
DoubleStruct=Record
Mantissa1:Word;
Mantissa2:Word;
Mantissa3:Word;
M4ES:Word;
End;
{ Cette fonction permet de convertir un
nombre de format «Double» en format «Real».
}
Function
DoubleToReal(X:Double):Real;
Var
DStruct:DoubleStruct
Absolute X;
Real48:TPReal;
Y:Real
Absolute Real48;
Begin
FillChar(Real48,SizeOf(Real48),0);
Real48.Exponent:=((DStruct.M4ES
and$7FF0)shr
4)-894;
Real48.MS:=(((((DStruct.M4ES
and$000F)shl
3)or
((DStruct.Mantissa3
and$E000)shr
13)))and$7F)or(Hi(DStruct.M4ES)and$80);
Real48.Mantissa2:=(((DStruct.Mantissa3
and$1FFF)shl
3)or((DStruct.Mantissa2
and$E000)shr
13));
Real48.Mantissa1:=(((DStruct.Mantissa2
and$1FFF)shl
3)or((DStruct.Mantissa1
and$E000)shr
13));
DoubleToReal:=Y;
End;
{ Cette fonction permet de convertir un
nombre de format «Real» en format «Double».}
Procedure
RealToDouble(X:Real;Var
Y:Double);
Var
DStruct:DoubleStruct
Absolute Y;
Real48:TPReal
Absolute X;
Begin
DStruct.M4ES:=((Real48.MS
and$80)shl
8);
DStruct.M4ES:=DStruct.M4ES
or((Real48.Exponent+894)shl
4);
DStruct.M4ES:=DStruct.M4ES
or((Real48.MS
and$7F)shr
3);
DStruct.Mantissa3:=((Real48.MS
and$7F)shl
13)or(Real48.Mantissa2
shr 3);
DStruct.Mantissa2:=(Real48.Mantissa2
shl 13)or(Real48.Mantissa1
shr 3);
DStruct.Mantissa1:=Real48.Mantissa1
shl 13;
End;
|
Si
vous n'arrivez pas a une réponse satisfaisante, il vous
restera à vous tourner vers le code écrit en langage de
programmation C/C++.
Déterminer
l'identité de deux matrices
La
procédure suivante écrite en langage de programmation
Pascal permet de
déterminer l'identité de deux matrices, il restera
cependant à définir un type Matrice pour un
tableau de deux dimensions avec des variables réels:
|
Procedure IdentiteMatrice(Var
R:Matrice);
Var
I,J:Word;
Begin
For
J:=1to(DimensionY)do
For I:=1to(DimensionX)do
If(I=J)Then
R[I,J]:=1.0
Else R[I,J]:=0.0;
End;
|
Additionner
deux matrices
Cette
procédure écrite en langage
de programmation Pascal
permet d'additionner le contenu de deux matrices, toutefois il
restera à définir
un type Matrice pour un tableau de deux dimensions avec des
variables réels:
|
Procedure AdditionneMatrice(Const
M,N:Matrice;Var
R:Matrice);
Var
I,J:Word;
Begin
For
J:=1to(DimensionY)do
For I:=1to(DimensionX)do
R[I,J]:=M[I,J]+N[I,J];
End;
|
Le
scalaire de deux matrices
Cette
procédure écrite en langage
de programmation Pascal
permet d'effectuer le produit scalaire de deux matrices,
toutefois il restera à
définir un type Matrice pour un tableau de deux
dimensions avec des variables réels:
|
Procedure ScalaireMatrice(L:Real;Const
M:Matrice;Var
R:Matrice);
Var
I,J:Word;
Begin
For
J:=1to(DimensionY)do
For I:=1to(DimensionX)do
R[I,J]:=L*M[I,J];
End;
|
La
multiplication de deux matrices
Cette
procédure écrite en langage
de programmation Pascal
permet d'effectuer la multiplication de deux matrices,
toutefois il restera à
définir un type Matrice pour un tableau de deux
dimensions avec des variables réels:
|
Procedure MultiplieMatrice(Const
M,N:Matrice;Var
R:Matrice);
Var
I,J,K:Word;
Begin
For
I:=1to(Dimension)do
For J:=1to(Dimension)do
Begin
R[I,J]:=0;
For
K:=1to(Dimension)do
R[I,J]:=R[I,J]+M[I,K]*N[K,J];
End;
End;
|
Calcul
à virgule fixe
A la fin des années 1980, on assista à l'arriver des
VGA et des démos des Hackers. Ceux-ci
avait l'extraordinaire talent d'avoir des performances phénoménal
avec un équipement pourtant lent et assez souvent désuet.
L'un de leur secret, fut d'utiliser les nombres a virgule fixe plutôt
que l'exploitation des virgules flottantes. On renoncera à la
précision d'un nombre afin d'atteindre cette objectif.
Généralement, on utilisera une structure de deux
entiers. La première contiendra la partie entière se
trouvant avant la virgule, tandis que l'autre contiendra la partie
décimal. Prenons par exemple le nombre 18,2, bien la première
partie contiendra 18 et l'autre contiendra la décimale 02 (à
cause du facteur décimal 100). Voici une exemple:
|
Program VirguleFixe;
Type
Fixe=Record
{Structure d'un nombre à virgule
fixe}
PEntier:Integer;
PDecimal:Integer;
End;
Var
{Les variables temporaire pour cette
exemple }
Var1:Fixe;
Var2:Fixe;
Const
FactorDecimal=100;
{Garde deux chiffres après la
virgule }
NombreDecimal=2;
{transforme un nombre à virgule
fixe en chaîne de chiffres}
Function
Fixe2String(FNombre:Fixe):String;
Var
PDecimalStr:String;
{Chaîne de caractères de la
partie décimale}
PEntierStr:String;
{Chaîne de
caractères de la partie entière}
I:Word;
Begin
If
FNombre.PDecimal<0Then
FNombre.PDecimal:=-FNombre.PDecimal;
{Élimine le signe après la
virgule}
Str(FNombre.PDecimal:NombreDecimal,PDecimalStr);{crée
la chaîne de caractères
décimale (après la virgule)}
For
I:=0to(NombreDecimal)do
If PDecimalStr[I]='
'Then PDecimalStr[I]:='0';
{remplace les espaces par un '0'}
Str(FNombre.PEntier,PEntierStr);
{crée
la chaîne de caractères
de la partie entière (avant la virgule)}
Fixe2String:=PEntierStr+','+PDecimalStr;
{Concataine les deux chaîne
de caractères}
End;
{Cette
procédure convertit un nombre Real RNombre
en nombre à virgule fixe FNombre }
Procedure Real2Fixe(RNombre:Real;Var
FNombre:Fixe);Begin
FNombre.PEntier:=Trunc(RNombre);
{Partie entière}
FNombre.PDecimal:=Trunc(Round(Frac(RNombre)*FactorDecimal));
{Partie décimale stockée
comme entier }
End;
{Cette procédure remet le
nombre à virgule fixe transmis en format légal}
Procedure Adjust(Var
FNombre:Fixe);Begin
If
FNombre.PDecimal>FactorDecimal
Then Begin
Dec(FNombre.PDecimal,FactorDecimal);
{si la partie décimale est
trop grande }
Inc(FNombre.PEntier);
{la diminuer et augmenter la partie entière
}
End;
If
FNombre.PDecimal<-FactorDecimal
Then Begin
Inc(FNombre.PDecimal,FactorDecimal);
{si la partie décimale est
trop petite}
Dec(FNombre.PEntier);
{l'augmenter et diminuer la partie
entière }
End;
End;
{Cette procédure
additionne FNombre1 à FNombre2 et par la
suite mémorise le résultat dans Somme}
Procedure Add(Var
Somme:Fixe;FNombre1,FNombre2:Fixe);
Var Resultat:Fixe;
Begin
Resultat.PDecimal:=FNombre1.PDecimal+FNombre2.PDecimal;
{Somme les parties décimales}
Resultat.PEntier:=FNombre1.PEntier+FNombre2.PEntier;
{Somme les parties entières}
Adjust(Resultat);
{Ajuste le résultat dans un format
correct }
Somme:=Resultat;
End;
{Soustrait
FNombre2 de FNombre1 et mémorise le résultat
dans la variable Difference }
Procedure
Sub(Var
Difference:Fixe;FNombre1,FNombre2:Fixe);
Var Resultat:Fixe;
Begin
Resultat.PDecimal:=FNombre1.PDecimal-FNombre2.PDecimal;
{Soustraction des parties décimales
}
Resultat.PEntier:=FNombre1.PEntier-FNombre2.PEntier;
{Soustraction des parties entières }
Adjust(Resultat);
{Ajuste le résultat dans une forme
correcte }
Difference:=Resultat;
End;
{Cette procédure
multiplie FNombre1 par FNombre et après
mémorise le résultat dans la variable Produit
}
Procedure Mul(Var
Produit:Fixe;FNombre1,FNombre2:Fixe);
Var Resultat:LongInt;
Begin
Resultat:=Var1.PEntier*FactorDecimal+Var1.PDecimal;
{Multiplicande}
Resultat:=Resultat*(Var2.PEntier*FactorDecimal+Var2.PDecimal);
{Multiplicateur}
Resultat:=Resultat
div FactorDecimal;
{Redivise par le facteur décimal
de la variable FactorDecimal }
Produit.PEntier:=Resultat
div FactorDecimal;
Produit.PDecimal:=Resultat
mod FactorDecimal;
{Calcul les parties entière
et décimale }
End;
{Cette procédure divise
FNombre1 par FNombre2 et ensuite mémorise le
résultat dans la variable Quotient }
Procedure
Divi(Var
Quotient:Fixe;FNombre1,FNombre2:Fixe);
Var Resultat:LongInt;
{Résultat intermédiaire}
Begin
Resultat:=FNombre1.PEntier*FactorDecimal+FNombre1.PDecimal;
{Dividende...
}
Resultat:=Resultat*FactorDecimal
div
(FNombre2.PEntier*FactorDecimal+FNombre2.PDecimal);
{...
multiplié par le facteur décimal pour plus de
précision et divisé par le diviseur }
Quotient.PEntier:=Resultat
div FactorDecimal;
{Extrait
les parties entière et décimale }
Quotient.PDecimal:=Resultat
mod FactorDecimal;
End;
BEGIN
WriteLn;
Real2Fixe(-81.2,Var1);
{On a besoin de deux nombres pour la
démonstration) }
Real2Fixe(73.1,Var2);
{Effectue
un calcul avec chaque opérateur pour le tester:}
Write(Fixe2String(Var1),'*',Fixe2String(Var2),'=
');
Mul(Var1,Var1,Var2);
WriteLn(Fixe2String(Var1));
Write(Fixe2String(Var1),'÷',Fixe2String(Var2),'=
');
Divi(Var1,Var1,Var2);
WriteLn(Fixe2String(Var1));
Write(Fixe2String(Var1),'+',Fixe2String(Var2),'=
');
Add(Var1,Var1,Var2);
WriteLn(Fixe2String(Var1));
Write(Fixe2String(Var1),'-',Fixe2String(Var2),'=
');
Sub(Var1,Var1,Var2);
WriteLn(Fixe2String(Var1));
END.
|
|
Multiplication 32 bits en 16 bits