Langage de programmation - Turbo Pascal - Turbo Pascal et Assembleur

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.

Dernière mise à jour : Dimanche, le 1 mai 2016

Section courante

A propos

Section administrative du site