Sommaire
- Introduction
- Multiplication 32 bits en 16 bits
- Comment convertir un nombre Single en Real sans coprocesseur mathématique
- Comment convertir un nombre Double en Real sans coprocesseur mathématique
- Déterminer l'identité de deux matrices
- Additionner deux matrices
- Le scalaire de deux matrices
- La multiplication de deux matrices
- Calcul à virgule fixe
Introduction
Cette page présente différentes résolutions de problèmes mathématiques à l'aide du Turbo Pascal et de l'Assembleur :
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 Turbo 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 Turbo 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 Turbo 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 Turbo 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 Turbo 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 Turbo 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.