-------------------------------------------------------------------------

Disquette d'accompagnement du livre:

 Introduction ˆ l'algorithmique numerique et ˆ la programmation en Pascal
 Patrick COUSOT
 Editions McGrawHill, 1987.

Elle est disponible en 4 versions:
 
  Macintosh           400 Ko   (2 disquettes)
  Macintosh           800 Ko   (1 disquette)
  Compatible IBM PC   360 Ko   (2 disquettes)
  Compatible IBM PC   1,2 Mo   (1 disquette)

-------------------------------------------------------------------------
	
 	Pour  eviter  aux  lecteurs  un  travail  de frappe long et fastidieux,
les  programmes  Turbo  Pascal  reproduits dans ce livre sont disponibles
pour les ordinateurs compatibles IBM PC ou Macintosh sur  des  disquettes
diffusees par les editions McGraw-Hill , 28 rue Beaunier, 75014 Paris.
		En ce qui concerne les compatibles  IBM PC,  ces  programmes  utilisent
la   bibliotheque  MODULOG  dont  disposent  les  classes  preparatoires. 
Elle est diffusee par l'A.L.E.Sup dont le siege social est  au  C.I.R.M.,
70 route Leon Lachamp, 13009, Marseille.  Les disquettes d'accompagnement
ne comportent  donc  pas  cette  bibliotheque   mais  seulement  quelques 
corrections et ameliorations.
		En ce qui concerne les Macintoshs, nous avons dž  entierement  reecrire 
la bibliotheque qui est livree sous forme compilee avec les disquettes de
programmes.

-------------------------------------------------------------------------

		L'usage et la reproduction des programmes contenus dans ce livre et sur
les disquettes sont entierement libres, sauf pour un usage commercial  et
aux risques et perils des utilisateurs en ce qui concerne leur qualite ou
leur fonctionnement. L'auteur et l'editeur declinent toute responsabilite 
concernant l'usage des programmes contenus  dans  ce  livre  et  sur  les
disquettes.  Ils  ne  donnent aucune garantie explicite ou tacite que ces
programmes  ne  contiennent  pas  d'erreurs,  qu'ils   satisfont   ˆ   de
quelconques standards academiques ou commerciaux ou qu'ils sont conformes
ˆ de quelconques specifications requises pour une application quelconque,
en  particulier celles pouvant entrainer directement ou indirectement une
violation des lois d'un pays quelconque.  Ils ne pourront  en  aucun  cas
etre  tenus  pour  responsables  des  prejudices directs ou indirects, de
quelque nature que ce soit, resultant d'une erreur dans les programmes ou
le  livre,  meme  s'ils  ont  ete avises de la presence de telles erreurs
pouvant entra”ner de tels prejudices.
		(Turbo  Pascal  est  une marque deposee de Borland International, Inc.,
Microsoft et MS-DOS sont des marques deposees de  Microsoft  Corporation,
IBM  est  une  marque  deposee  de International Business Machines Corp.,
Macintosh est une marque  deposee  de  McIntosh  Laboratories  Inc.  dont
l'usage a ete concede ˆ Apple Computer, Inc).

-------------------------------------------------------------------------

Index des noms abreges des programmes

-------------------------------------------------------------------------

		Sur les  disquettes  destinees  au  Macintosh  nous  avons  utilise  la
convention  que le programme Pascal de nom P est range dans le fichier de
nom  P.Pas.   Pour  les  disquettes  destinees  aux  compatibles  IBM  PC
exploites sous MS-DOS, les  noms  de  repertoires  et  de  fichiers  sont
limites ˆ 8 caracteres.  De ce fait nous avons utilise  les  abreviations
suivantesÊ:

-------------------------------------------------------------------------
Nom du repertoire ou fichier:	                  Abreviation:	       Page:
-------------------------------------------------------------------------

AdditionGrandsEntiers.Pas	                      AddGrEnt.Pas	          49
Additionneur3Bits.Pas                          	AddBin3b.Pas         	479
AdditionneurBinaire.Pas	                        AddBin2b.Pas	          61
AffectationVariableSimple.Pas                  	AffVarSp.Pas	          69
AlgorithmeDeHorner.Pas	                         Horner.Pas	           114
AlgorithmeDeHorner_Lib                         	HornerLi.Pas	         263
ApproximationDePade.Pas                        	Pade.Pas	             272
ApproximationsSuccessives.Pas                  	AproxSuc.Pas         	292
Arrangements.Pas	                               Arrange.Pas           	73
Bibliotheques                                  	Biblioth
CalculDeArcCosX.Pas                            	ArcCosX.Pas	           60
CarteCouleur.Pas                               	CarteCou.Pas	         434
CarteNoirEtBlanc.Pas                           	CarteNeB.Pas	         442
CentreDinertie.Pas	                             CtInerti.Pas         	467
CircuitRC.Pas	                                  CircuiRC.Pas         	490
CircuitRL.Pas	                                  CircuiRL.Pas	         485
ComplexesPredefinis.Pas                         CompPred.Pas          120
Cosecante1.Pas                                 	Cosec1.Pas	           127
Cosecante2.Pas	                                 Cosec2.Pas	           129
CotgTabulaire.Pas                              	CotgTabu.Pas          	97
CourbeCartesienne1.Pas                          CourCar1.Pas	         142
CourbeCartesienne2.Pas	                         CourCar2.Pas	         154
CourbeCartesienne3.Pas	                         CourCar3.Pas	         333
CourbeParametrique.Pas	                         CourPara.Pas	         359
CourbePolaire1.Pas                              CourPol1.Pas          345
CourbePolaire2.Pas                              CourPol2.Pas          349
Cours	                                          Cours
DebordementArithmetiqueReel.Pas	                DebArith.Pas	          40
DebordementDindice.Pas                          DebInd.Pas             55
DecimalABinaire.Pas                             DecimBin.Pas           81
DichotomieGraphique.Pas                         DichoGr.Pas           306
Div0Factorielle1.Pas                            Div0Fac1.Pas          163
Div0Factorielle2.Pas                            Div0Fac2.Pas          167
DivergencePrecisionInsuffis.Pas                 Diverge.Pas           178
DivisionEuclidiennePoly.Pas                     DivEPol.Pas           264
DivPuissancesCroissantes.Pas                    DivPCPol.Pas          266
DosagePolyAcidesParBase.Pas                     DosPolyA.Pas          515
DosageTriAcideParBase.Pas                       DosTriAc.Pas          511
Ecritures.Pas                                   Ecriture.Pas           66
Electrostatique1.Pas                            Electro1.Pas          492
Electrostatique2.Pas                            Electro2.Pas          504
EliminationDeGauss.Pas                          Gauss.Pas             277
EliminationDeGaussJordan.Pas                    GausJord.Pas          281
EnveloppeConvexe.Pas                            EnvConve.Pas         	430
EnveloppeDeDroites.Pas                         	EnvDroit.Pas         	424
EpuissanceX.Pas	                                EpuissX.Pas	          313
EquaDiff2emeOrdre.Pas                          	EquDif2O.Pas         	416
EquationComplexe2emeDegre.Pas                   EqCom2D1.Pas          120
EquationComplexe2emeDg_Lib.Pas                  EqCom2D2.Pas     	120,259
ErreursDarrondi.Pas                             Arrondi.Pas            41
Euclide.Pas                                     Euclide.Pas            27
EuclideAvecHomonymes.Pas                        EucliHom.Pas      108,109
EuclideFonctionnel.Pas                          EuclFonc.Pas           94
EulerPolaire.Pas                                EulerPol.Pas          400
EvaluationNaiveDePolynome.Pas                   EvalPoly.Pas          112
Exemple1Bibliotheques.Pas                       Exem1Bib.Pas
Exercices Chimie                                ExosChim
Exercices Math. Spe.                            ExosSpe
Exercices Math. Sup. (2)                        ExosSup2
Exercices Math. Sup. (1)                        ExosSup1
Exercices Physique                              ExosPhy
FactorielleErronee.Pas                          FactErr.Pas           101
FactorielleIterative.Pas                        FactIter.Pas           99
FactorielleRecursive.Pas                        FactRec.Pas            98
Fibonacci.Pas                                   Fibona.Pas         59, 84
FibonacciRecursif.Pas                           FibRec.Pas            102
FonctionAvecEffetDeBord.Pas                     FoncEBor.Pas           96
FormulesTrigoRecursives.Pas                     TrigoRec.Pas          104
Graphique1.Pas                                  Graphiq1.Pas          134
Graphique2.Pas                                  Graphiq2.Pas          138
Graphique3.Pas                                  Graphiq3.Pas          140
Graphique4.Pas                                  Graphiq4.Pas          147
IdentiteDeBezout.Pas                            Bezout.Pas            248
ImageMiroir.Pas                                 Miroir.Pas             48
InterpolationLagrange.Pas                       Lagrange.Pas          314
InterpretationDeFonction.Pas                    IntFonct.Pas          154
InversionDeMatrice.Pas                          InvMat.Pas            284
IterationDeGaussSeidel.Pas                      GausSeid.Pas          368
LectureEcritureDeBooleen.Pas                    LeEcBool.Pas           68
Lectures.Pas                                    Lecture.Pas            64
LimiteSuiteRecurrente.Pas                       LimRec.Pas            289
LongueurDunArcDeCourbe.Pas                      LgArcCbe.Pas          324
MatriceHermitienne.Pas                          Hermit.Pas             54
Max3Entiers.Pas                                 Max3Ent.Pas            76
MaxNEntiers.Pas                                 MaxNEnt.Pas           	79
MaxSequencedEntiers.Pas                         MaxSqEnt.Pas           80
MethodeCompleteDichotomie.Pas                   DichoCo.Pas           309
MethodeDeLaSecante.Pas                          Secante.Pas           302
MethodeDeNewtonRaphson.Pas                      Newton.Pas            293
MethodedeRungeKutta.Pas                         RungKutt.Pas          389
MethodeDeSimpson.Pas                            Simpson.Pas           322
MethodeDesTrapezes.Pas                          Trapezes.Pas          321
MethodedEuler.Pas                               Euler1.Pas            385
MethodedEuler2emeOrdre.Pas                      Euler2.Pas            386
MethodePartielleDichotomie.Pas                  DichoPa.Pas           304
MethodeRungeKuttaVectoriel.Pas                  RungKutV.Pas          403
MoindresCarres.Pas                              MdrCarre.Pas          483
NewtonRaphsonGraphique.Pas                      NewtonGr.Pas          295
NombresHarmoniques.Pas                          Harmoniq.Pas          179
NombresHarmoniquesApproches.Pas                 HarmAppr.Pas          253
NombresHarmoniquesChrono.Pas                    HarmChro.Pas          254
Notion d'algorithme                             Algorith
Nplus1egalN.Pas                                 Np1egalN.Pas          255
OscillateurAmorti.Pas                           OscAmor.Pas           469
ParametresVariablesGlobales.Pas                 ParVarGl.Pas           91
Pascal                                          Pascal
PassageDeParametres.Pas                         PasParam.Pas           90
PGCD1.Pas                                       PGCD1.Pas              22
PGCD2.Pas                                       PGCD2.Pas              24
PgcdBinaire.Pas                                 PgcdBin.Pas           250
PGCDPolynomes.Pas                               PGCDPol.Pas           265
pHsolutionAcide.Pas                             pHAcide.Pas           508
PolynomesPredefinis.Pas                         PolyPred.Pas          180
PrecisionEntreesSorties.Pas                     PEntSort.Pas          252
ProduitDeMatrices.Pas                           ProdMat1.Pas           70
ProduitDeMatricesModulaire.Pas                  ProdMat2.Pas           86
PuissanceDeMatrice.Pas                          PuissMat.Pas          275
RegleDeSarrus.Pas                               Sarrus.Pas             52
RungeKuttaGraphique.Pas                         RungKutG.Pas          391
RungeKuttaVectorielParametre.Pas                RungKuVP.Pas          409
SerieDeFourier.Pas                              Fourier.Pas           378
SimulationCircuitAddition.Pas                   AddBin8b.Pas          480
SommeHarmonique.Pas                             SomHarm.Pas            78
SommeNpremiersEntiers1.Pas                      Somme1.Pas             37
SommeNpremiersEntiers2.Pas                      Somme2.Pas             38
SommeNpremiersEntiersErrone.Pas                 Somme0.Pas             36
SommeReelleNpremiersEntiers.Pas                 Somme3.Pas             43
StructureDeGroupe.Pas                           Groupe.Pas            237
SuiteDeFonctions.Pas                            SuitFonc.Pas          371
SurfaceEnPerspective.Pas                        SurfPers.Pas          446
SurfaceSansPartiesCachees1.Pas                  SurCach1.Pas          450
SurfaceSansPartiesCachees2.Pas                  SurCach2.Pas          455
SurfaceSansPartiesCachees3.Pas                  SurCach3.Pas          461
TableArgTh.Pas                                  TabArgTh.Pas          130
TablesDeVerite.Pas                              Verite.Pas             35
TrajectoirePointPesant.Pas                      TrajPt.Pas            470
TrajectoiresChampNewtonien.Pas                  TrajNewt.Pas          473
TransformationConforme.Pas                      TranConf.Pas          255
TransformationsGeometriques.Pas                 TranGeom.Pas          327
TriangleDePascal.Pas                            TriPasc.Pas           247
Trouver2Reels.Pas                               Trouv2R.Pas            75
UnSurXpuissanceN.Pas                            UnSXPN.Pas            290
VariablesSimples.Pas                            VarSimp.Pas            46

-------------------------------------------------------------------------
Abreviation:       	Nom du repertoire ou fichier:	                  Page:
-------------------------------------------------------------------------

AddBin2b.Pas        AdditionneurBinaire.Pas                            61
AddBin3b.Pas        Additionneur3Bits.Pas                             479
AddBin8b.Pas        SimulationCircuitAddition.Pas                     480
AddGrEnt.Pas        AdditionGrandsEntiers.Pas                          49
AffVarSp.Pas        AffectationVariableSimple.Pas                      69
Algorith            Notion d'algorithme	
AproxSuc.Pas        ApproximationsSuccessives.Pas                     292
ArcCosX.Pas         CalculDeArcCosX.Pas                                60
Arrange.Pas         Arrangements.Pas                                   73
Arrondi.Pas         ErreursDarrondi.Pas                                41
Bezout.Pas          IdentiteDeBezout.Pas                              248
Biblioth            Bibliotheques	
CarteCou.Pas        CarteCouleur.Pas                                  434
CarteNeB.Pas        CarteNoirEtBlanc.Pas                              442
CircuiRC.Pas        CircuitRC.Pas                                     490
CircuiRL.Pas        CircuitRL.Pas                                     485
CompPred.Pas        ComplexesPredefinis.Pas                           120
Cosec1.Pas          Cosecante1.Pas                                    127
Cosec2.Pas          Cosecante2.Pas                                    129
CotgTabu.Pas        CotgTabulaire.Pas                                  97
CourCar1.Pas        CourbeCartesienne1.Pas                            142
CourCar2.Pas        CourbeCartesienne2.Pas                            154
CourCar3.Pas        CourbeCartesienne3.Pas                            333
CourPara.Pas        CourbeParametrique.Pas                            359
CourPol1.Pas        CourbePolaire1.Pas                                345
CourPol2.Pas        CourbePolaire2.Pas                                349
Cours	Cours
CtInerti.Pas        CentreDinertie.Pas                                467
DebArith.Pas        DebordementArithmetiqueReel.Pas                    40
DebInd.Pas          DebordementDindice.Pas                             55
DecimBin.Pas        DecimalABinaire.Pas                                81
DichoCo.Pas         MethodeCompleteDichotomie.Pas                     309
DichoGr.Pas         DichotomieGraphique.Pas                           306
DichoPa.Pas         MethodePartielleDichotomie.Pas                    304
Div0Fac1.Pas        Div0Factorielle1.Pas                              163
Div0Fac2.Pas        Div0Factorielle2.Pas                              167
DivEPol.Pas         DivisionEuclidiennePoly.Pas                       264
Diverge.Pas         DivergencePrecisionInsuffis.Pas                   178
DivPCPol.Pas        DivPuissancesCroissantes.Pas                      266
DosPolyA.Pas        DosagePolyAcidesParBase.Pas                       515
DosTriAc.Pas        DosageTriAcideParBase.Pas                         511
Ecriture.Pas        Ecritures.Pas                                      66
Electro1.Pas        Electrostatique1.Pas                              492
Electro2.Pas        Electrostatique2.Pas                              504
EnvConve.Pas        EnveloppeConvexe.Pas                              430
EnvDroit.Pas        EnveloppeDeDroites.Pas                            424
EpuissX.Pas         EpuissanceX.Pas                                   313
EqCom2D1.Pas        EquationComplexe2emeDegre.Pas                     120
EqCom2D2.Pas        EquationComplexe2emeDg_Lib.Pas                120,259
EquDif2O.Pas        EquaDiff2emeOrdre.Pas                             416
EuclFonc.Pas        EuclideFonctionnel.Pas                             94
Euclide.Pas         Euclide.Pas                                        27
EucliHom.Pas        EuclideAvecHomonymes.Pas                      108,109
Euler1.Pas          MethodedEuler.Pas                                 385
Euler2.Pas          MethodedEuler2emeOrdre.Pas                        386
EulerPol.Pas        EulerPolaire.Pas                                  400
EvalPoly.Pas        EvaluationNaiveDePolynome.Pas                     112
Exem1Bib.Pas        Exemple1Bibliotheques.Pas	
ExosChim            Exercices Chimie	
ExosPhy             Exercices Physique	
ExosSpe             Exercices Math. Spe.	
ExosSup1            Exercices Math. Sup. (1)	
ExosSup2            Exercices Math. Sup (2)	
FactErr.Pas         FactorielleErronee.Pas                            101
FactIter.Pas        FactorielleIterative.Pas                           99
FactRec.Pas         FactorielleRecursive.Pas                           98
Fibona.Pas          Fibonacci.Pas                                  59, 84
FibRec.Pas          FibonacciRecursif.Pas                             102
FoncEBor.Pas        FonctionAvecEffetDeBord.Pas                        96
Fourier.Pas         SerieDeFourier.Pas                                378
GausJord.Pas        EliminationDeGaussJordan.Pas                      281
Gauss.Pas           EliminationDeGauss.Pas                            277
GausSeid.Pas        IterationDeGaussSeidel.Pas                        368
Graphiq1.Pas        Graphique1.Pas                                    134
Graphiq2.Pas        Graphique2.Pas                                    138
Graphiq3.Pas        Graphique3.Pas                                    140
Graphiq4.Pas        Graphique4.Pas                                    147
Groupe.Pas          StructureDeGroupe.Pas                             237
HarmAppr.Pas        NombresHarmoniquesApproches.Pas                   253
HarmChro.Pas        NombresHarmoniquesChrono.Pas                      254
Harmoniq.Pas        NombresHarmoniques.Pas                            179
Hermit.Pas          MatriceHermitienne.Pas                             54
Horner.Pas          AlgorithmeDeHorner.Pas                            114
HornerLi.Pas        AlgorithmeDeHorner_Lib                            263
IntFonct.Pas        InterpretationDeFonction.Pas                      154
InvMat.Pas          InversionDeMatrice.Pas                            284
Lagrange.Pas        InterpolationLagrange.Pas                         314
Lecture.Pas         Lectures.Pas                                       64
LeEcBool.Pas        LectureEcritureDeBooleen.Pas                       68
LgArcCbe.Pas        LongueurDunArcDeCourbe.Pas                        324
LimRec.Pas          LimiteSuiteRecurrente.Pas                         289
Max3Ent.Pas         Max3Entiers.Pas                                    76
MaxNEnt.Pas         MaxNEntiers.Pas                                    79
MaxSqEnt.Pas        MaxSequencedEntiers.Pas                            80
MdrCarre.Pas        MoindresCarres.Pas                                483
Miroir.Pas          ImageMiroir.Pas                                    48
Newton.Pas          MethodeDeNewtonRaphson.Pas                        293
NewtonGr.Pas        NewtonRaphsonGraphique.Pas                        295
Np1egalN.Pas        Nplus1egalN.Pas                                   255
OscAmor.Pas         OscillateurAmorti.Pas                             469
Pade.Pas            ApproximationDePade.Pas                           272
ParVarGl.Pas        ParametresVariablesGlobales.Pas                    91
Pascal              Pascal
PasParam.Pas        PassageDeParametres.Pas                            90
PEntSort.Pas        PrecisionEntreesSorties.Pas                       252
PGCD1.Pas           PGCD1.Pas                                          22
PGCD2.Pas           PGCD2.Pas                                          24
PgcdBin.Pas         PgcdBinaire.Pas                                   250
PGCDPol.Pas         PGCDPolynomes.Pas                                 265
pHAcide.Pas         pHsolutionAcide.Pas                               508
PolyPred.Pas        PolynomesPredefinis.Pas                           180
ProdMat1.Pas        ProduitDeMatrices.Pas                              70
ProdMat2.Pas        ProduitDeMatricesModulaire.Pas                     86
PuissMat.Pas        PuissanceDeMatrice.Pas                            275
RungKutG.Pas        RungeKuttaGraphique.Pas                           391
RungKutt.Pas        MethodedeRungeKutta.Pas                           389
RungKutV.Pas        MethodeRungeKuttaVectoriel.Pas                    403
RungKuVP.Pas        RungeKuttaVectorielParametre.Pas                  409
Sarrus.Pas          RegleDeSarrus.Pas                                  52
Secante.Pas         MethodeDeLaSecante.Pas                            302
Simpson.Pas         MethodeDeSimpson.Pas                              322
SomHarm.Pas         SommeHarmonique.Pas                                78
Somme0.Pas          SommeNpremiersEntiersErrone.Pas                    36
Somme1.Pas          SommeNpremiersEntiers1.Pas                         37
Somme2.Pas          SommeNpremiersEntiers2.Pas                         38
Somme3.Pas          SommeReelleNpremiersEntiers.Pas                    43
SuitFonc.Pas        SuiteDeFonctions.Pas                              371
SurCach1.Pas        SurfaceSansPartiesCachees1.Pas                    450
SurCach2.Pas        SurfaceSansPartiesCachees2.Pas                    455
SurCach3.Pas        SurfaceSansPartiesCachees3.Pas                    461
SurfPers.Pas        SurfaceEnPerspective.Pas                          446
TabArgTh.Pas        TableArgTh.Pas                                    130
TrajNewt.Pas        TrajectoiresChampNewtonien.Pas                    473
TrajPt.Pas          TrajectoirePointPesant.Pas                        470
TranConf.Pas        TransformationConforme.Pas                        255
TranGeom.Pas        TransformationsGeometriques.Pas                   327
Trapezes.Pas        MethodeDesTrapezes.Pas                            321
TrigoRec.Pas        FormulesTrigoRecursives.Pas                       104
TriPasc.Pas         TriangleDePascal.Pas                              247
Trouv2R.Pas         Trouver2Reels.Pas                                  75
UnSXPN.Pas          UnSurXpuissanceN.Pas                              290
VarSimp.Pas         VariablesSimples.Pas                               46
Verite.Pas          TablesDeVerite.Pas                                 35

-------------------------------------------------------------------------

Organisation des repertoires des disquettes Macintosh 400K ou 800K et
compatibles IBM PC 360 Ko et 1,2 Mo:

Macintosh                               Abreviation
                                        IBM PC 
   
----------------------- TAUPES_1 ----------------------------------------

Cours:                                  Cours:

 Notion d'algorithme:                   Algorith:
 
   PGCD1.Pas                            PGCD1.Pas
   PGCD2.Pas                            PGCD2.Pas
   Euclide.Pas                          Euclide.Pas

 Pascal:                                Pascal:
 
   TablesDeVerite.Pas                   Verite.Pas
   SommeNpremiersEntiersErrone.Pas      Somme0.Pas
   SommeNpremiersEntiers1.Pas           Somme1.Pas
   SommeNpremiersEntiers2.Pas           Somme2.Pas
   DebordementArithmetiqueReel.Pas      DebArith.Pas
   ErreursDarrondi.Pas                  Arrondi.Pas
   SommeReelleNpremiersEntiers.Pas      Somme3.Pas
   VariablesSimples.Pas                 VarSimp.Pas
   ImageMiroir.Pas                      Miroir.Pas
   AdditionGrandsEntiers.Pas            AddGrEnt.Pas
   RegleDeSarrus.Pas                    Sarrus.Pas
   MatriceHermitienne.Pas               Hermit.Pas
   DebordementDindice.Pas               DebInd.Pas
   Fibonacci.Pas                        Fibona.Pas
   CalculDeArcCosX.Pas                  ArcCosX.Pas
   AdditionneurBinaire.Pas              AddBin2b.Pas
   Lectures.Pas                         Lecture.Pas
   Ecritures.Pas                        Ecriture.Pas
   LectureEcritureDeBooleen.Pas         LeEcBool.Pas
   AffectationVariableSimple.Pas        AffVarSp.Pas
   ProduitDeMatrices.Pas                ProdMat1.Pas
   Arrangements.Pas                     Arrange.Pas
   Trouver2Reels.Pas                    Trouv2R.Pas
   Max3Entiers.Pas                      Max3Ent.Pas
   SommeHarmonique.Pas                  SomHarm.Pas
   MaxNEntiers.Pas                      MaxNEnt.Pas
   MaxSequencedEntiers.Pas              MaxSqEnt.Pas
   DecimalABinaire.Pas                  DecimBin.Pas
   ProduitDeMatricesModulaire.Pas       ProdMat2.Pas
   PassageDeParametres.Pas              PasParam.Pas
   ParametresVariablesGlobales.Pas      ParVarGl.Pas
   EuclideFonctionnel.Pas               EuclFonc.Pas
   FonctionAvecEffetDeBord.Pas          FoncEBor.Pas
   CotgTabulaire.Pas                    CotgTabu.Pas
   EvaluationNaiveDePolynome.Pas        EvalPoly.Pas
   AlgorithmeDeHorner.Pas               Horner.Pas
   FactorielleRecursive.Pas             FactRec.Pas
   FactorielleIterative.Pas             FactIter.Pas
   FactorielleErronee.Pas               FactErr.Pas
   FibonacciRecursif.Pas                FibRec.Pas
   FormulesTrigoRecursives.Pas          TrigoRec.Pas
   EuclideAvecHomonymes.Pas             EucliHom.Pas

 Bibliotheques:                         Biblioth:
 
   EquationComplexe2emeDegre.Pas        EqCom2D1.Pas
   Cosecante1.Pas                       Cosec1.Pas
   Cosecante2.Pas                       Cosec2.Pas
   TableArgTh.Pas                       TabArgTh.Pas
   Graphique1.Pas                       Graphiq1.Pas
   Graphique2.Pas                       Graphiq2.Pas
   Graphique3.Pas                       Graphiq3.Pas
   CourbeCartesienne1.Pas               CourCar1.Pas
   Graphique4.Pas                       Graphiq4.Pas
   InterpretationDeFonction.Pas         IntFonct.Pas
   CourbeCartesienne2.Pas               CourCar2.Pas
   Div0Factorielle1.Pas                 Div0Fac1.Pas
   Div0Factorielle2.Pas                 Div0Fac2.Pas
   Exemple1Bibliotheques.Pas            Exem1Bib.Pas

Exercices Math. Sup. (1):               ExosSup1:

 Algebre:
   Groupes:
     StructureDeGroupe.Pas              Groupe.Pas
   Entiers, Rationnels: 
     TriangleDePascal.Pas               TriPasc.Pas
     cf. Euclide.Pas (¤)
     cf. EuclideFonctionnel.Pas
     IdentiteDeBezout.Pas               Bezout.Pas
     PgcdBinaire.Pas                    PgcdBin.Pas
   Reels:
     PrecisionEntreesSorties.Pas        PEntSort.Pas
     DivergencePrecisionInsuffis.Pas    Diverge.Pas
     NombresHarmoniques.Pas             Harmoniq.Pas
     NombresHarmoniquesApproches.Pas    HarmAppr.Pas
     NombresHarmoniquesChrono.Pas       HarmChro.Pas
     Nplus1egalN.Pas                    Np1egalN.Pas
   Complexes:
     TransformationConforme.Pas         TranConf.Pas
     EquationComplexe2emeDegre.Pas      EqCom2D1.Pas
     EquationComplexe2emeDg._Lib.Pas    EqCom2D2.Pas
   Polynomes:   
     cf. EvaluationNaiveDePolynome.Pas
     cf. AlgorithmeDeHorner.Pas (¤)
     AlgorithmeDeHorner_Lib (¤)         HornerLi.Pas
     DivisionEuclidiennePoly.Pas (¤)    DivEPol.Pas
     PGCDPolynomes.Pas (¤)              PGCDPol.Pas
     DivPuissancesCroissantes.Pas (¤)   DivPCPol.Pas

----------------------- TAUPES_2 ----------------------------------------

Exercices Math. Sup (2):                ExosSup2:

   Fractions rationnelles:
     ApproximationDePade.Pas            Pade.Pas
   Matrices:
     PuissanceDeMatrice.Pas             PuissMat.Pas
   Resolution numerique de systemes lineaires:
     EliminationDeGauss.Pas (¤)         Gauss.Pas
     EliminationDeGaussJordan.Pas       GausJord.Pas
     InversionDeMatrice.Pas             InvMat.Pas

 Analyse:
   Suites Reelles et Complexes:
     LimiteSuiteRecurrente.Pas          LimRec.Pas
     UnSurXpuissanceN.Pas               UnSXPN.Pas
   Resolution d'une equation numerique:
     ApproximationsSuccessives.Pas (¤)  AproxSuc.Pas
     MethodeDeNewtonRaphson.Pas (¤)     Newton.Pas
   NewtonRaphsonGraphique.Pas           NewtonGr.Pas
     MethodeDeLaSecante.Pas (¤)         Secante.Pas
     MethodePartielleDichotomie.Pas (¤) DichoPa.Pas
   DichotomieGraphique.Pas              DichoGr.Pas
     MethodeCompleteDichotomie.Pas      DichoCo.Pas
   Developpements limites:
     EpuissanceX.Pas                    EpuissX.Pas
   Approximation de fonctions:
     InterpolationLagrange.Pas          Lagrange.Pas
   Calcul approche d'integrales
     MethodeDesTrapezes.Pas (¤)         Trapezes.Pas
     MethodeDeSimpson.Pas               Simpson.Pas
     LongueurDunArcDeCourbe.Pas         LgArcCbe.Pas
 Geometrie:
   Geometrie euclidienne du plan:
     TransformationsGeometriques.Pas    TranGeom.Pas
   Construction de courbes planes:
     cf. CourbeCartesienne1.Pas
     cf. CourbeCartesienne2.Pas
     CourbeCartesienne3.Pas             CourCar3.Pas
     CourbePolaire1.Pas                 CourPol1.Pas
     CourbePolaire2.Pas                 CourPol2.Pas
     CourbeParametrique.Pas             CourPara.Pas

Exercices Math. Spe.:                   ExosSpe:

  Resolution de systemes d'equations lineaires:
    IterationDeGaussSeidel.Pas          GausSeid.Pas
  Series:
    SuiteDeFonctions.Pas                SuitFonc.Pas
    SerieDeFourier.Pas                  Fourier.Pas
  Resolution numerique des equa. diff.:
    MethodedEuler.Pas (¤)               Euler1.Pas
    MethodedEuler2emeOrdre.Pas          Euler2.Pas
    MethodedeRungeKutta.Pas             RungKutt.Pas
    RungeKuttaGraphique.Pas             RungKutG.Pas
    EulerPolaire.Pas                    EulerPol.Pas
  Resolution systemes d'equa. diff.:
    MethodeRungeKuttaVectoriel.Pas      RungKutV.Pas
    RungeKuttaVectorielParametre.Pas    RungKuVP.Pas
    EquaDiff2emeOrdre.Pas               EquDif2O.Pas
  Geometrie algorithmique:
    EnveloppeDeDroites.Pas              EnvDroit.Pas
    EnveloppeConvexe.Pas                EnvConve.Pas
    CarteCouleur.Pas                    CarteCou.Pas
    CarteNoirEtBlanc.Pas                CarteNeB.Pas
    SurfaceEnPerspective.Pas            SurfPers.Pas
    SurfaceSansPartiesCachees1.Pas      SurCach1.Pas
    SurfaceSansPartiesCachees2.Pas      SurCach2.Pas
    SurfaceSansPartiesCachees3.Pas      SurCach3.Pas

Exercices Physique:                     ExosPhy:

   CentreDinertie.Pas                   CtInerti.Pas
   OscillateurAmorti.Pas                OscAmor.Pas
   TrajectoirePointPesant.Pas           TrajPt.Pas
   TrajectoiresChampNewtonien.Pas       TrajNewt.Pas
   Additionneur3Bits.Pas                AddBin3b.Pas
   SimulationCircuitAddition.Pas        AddBin8b.Pas
   MoindresCarres.Pas                   MdrCarre.Pas
   CircuitRL.Pas                        CircuiRL.Pas
   CircuitRC.Pas                        CircuiRC.Pas
   Electrostatique1.Pas                 Electro1.Pas
   Electrostatique2.Pas                 Electro2.Pas

Exercices Chimie:                       ExosChim:

  pHsolutionAcide.Pas                   pHAcide.Pas
  DosageTriAcideParBase.Pas             DosTriAc.Pas
  DosagePolyAcidesParBase.Pas           DosPolyA.Pas

-------------------------------------------------------------------------

  Directives d'usage des bibliotheques sur les compatibles IBM PC
  
-------------------------------------------------------------------------
  Certains programmes contenus dans les disquettes pour  compatibles  IBM
PC  utilisent  la version 1.0 du noyau de base de la bibliotheque MODULOG
en date du 22/06/87.  Cette bibliotheque est distribuee par:

  A.L.E.Sup
  C.I.R.M.
  70 route Leon Lachamp
  13009 Marseille France

  Les programmes utilisant des modules  de  bibliotheque  comportent  des 
directives de compilation de la forme:
  
  (*$i math.lib*)
  (*$i ...gr...*)
  (*$i graphe.lib*)
  (*$i entrees.lib*)
  (*$i complexe.lib*)
  
(ou la directive (*$i ...gr...*) depend de la carte graphique utilisee).
Ces directives ont pour but  d'inclure  le  texte  du  module  qu'elles
designent dans le programme.  Nous avons choisi la directive: 

  (*$i ...gr...*)
  
comme etant:

    (*$i G640x200.CGA*)
ou  (*$i G320x200.CGA*)

qui sont respectivement prevues pour les cartes graphiques

    CGA 640x200  monochrome
    CGA 320x200  4 couleurs (fond bleu, rouge, vert, jaune)
    
Elle doit etre changee selon la carte graphique utilisee.

  L'usage de directives d'inclusion de modules de bibliotheque
suppose que les fichiers contenant ces modules soient ranges 
dans le repertoire courant de Turbo-Pascal. Supposons par exemple
que ces modules soient ranges dans le repertoire MODULOG du disque
C: et que le programme P appelant ces modules soit range dans le
repertoire EXOS de la disquette A:. L'execution de P s'effectue
comme suit:

 >L
  Logged drive: A
 >A
  Active directory: EXOS
 >W
  Work file: P
 >L
  Logged drive: C
 >A
  Active directory: MODULOG
 >R
  ... compilation et execution du programme ...

Il est egalement possible de remplacer ces directives par:
  
  (*$i C:\MODULOG\math.lib*)
  (*$i C:\MODULOG\G640x200.CGA*)
  (*$i C:\MODULOG\graphe.lib*)
  (*$i C:\MODULOG\entrees.lib*)
  (*$i C:\MODULOG\complexe.lib*)

ce qui permet d'executer le programme P par:

 >L
  Logged drive: A
 >A
  Active directory: EXOS
 >W
  Work file: P
 >R
  ... compilation et execution du programme ...

ou plus simplement encore de creer un chemin (path en anglais)
sous MS-DOS pour C:\MODULOG.

*  La premiere version de la bibliotheque MODULOG contient des 
erreurs et des imperfections.  Nous proposons d'en corriger 
certaines. De plus nous proposons des complements ou amelio-
rations pour eviter d'avoir souvent a retaper certains sous-
programmes frequemment utilises.

*  Pour continuer imprimer ce fichier LISEZ.MOI puis suivre les
directives ci-dessous.

*****************************************************************
  L'usage et la reproduction des programmes contenus sur ces
disquettes est entierement libre, sauf pour une usage commer-
cial et aux risques et perils des utilisateurs en ce qui concerne
leur qualite ou leur fonctionnement.  L'auteur et l'editeur ne
donnent aucune garantie explicite ou tacite que ces program-
mes ne contiennent pas d'erreurs, qu'ils satisfont a de quelcon-
ques standards academiques ou commerciaux ou qu'ils sont
conformes a de quelconques specifications requises pour une
application quelconque, en particulier celles pouvant entrainer
la violation des lois d'un pays quelconque.  Ils ne pourront en 
aucun cas etre tenus pour responsables des prejudices directs
ou indirects, de quelque nature que ce soit, resultant d'une
erreur dans les programmes ou le livre cite ci-dessus, meme
s'ils ont ete avises de la presence de telles erreurs pouvant
entrainer de tels prejudices.
*****************************************************************

  
*****************************************************************
*****************************************************************
  MATH.LIB
*****************************************************************

1.
1.1  Apres la declaration:

  VAR
    aa_Ovflw   :  INTEGER;

ajouter les declarations:
  
  CONST
    aa_Nom_Princ = 'le programme principal';
  TYPE
    aa_string = string[80];
  VAR
    aa_Arret : boolean;
    aa_Niveau : integer;
    aa_Nom : aa_string;
    aa_NoErr : integer;


1.2  Ajouter les instructions:

    aa_Arret := true;
    aa_Niveau := -maxint;
    aa_Nom := aa_Nom_Princ;

a la fin du corps de la procedure InitMath.

1.3  Supprimer les procedures ErreurMath et ForceErreur a la
fin du module Math.Lib.

1.4  Apres la declaration de la procedure InitMath, ajouter
les declarations de procedures et fonctions suivantes:

  PROCEDURE Erreur(M:aa_string);
  BEGIN
    writeln; writeln('Erreur fatale : ',M,'.'); halt;
  END;

  PROCEDURE ForceErreur(E:integer);
  BEGIN IF aa_Ovflw=0 then aa_Ovflw:=E END;
  
  PROCEDURE ArreterSiErreur(B:boolean);
  BEGIN aa_Arret:=B; END;

  FUNCTION OptionArretSiErreur:boolean;
  BEGIN OptionArretSiErreur:=aa_Arret; END.

  FUNCTION CodeErreur : integer;
  BEGIN CodeErreur:=aa_Ovflw; aa_Ovflw:=0; END;
  
  FUNCTION ErreurMath:integer;
    VAR NoErr:integer;
  BEGIN
    NoErr:=CodeErreur;
    IF (1<=NoErr) and (NoErr<=99) THEN
      ErreurMath:=NoErr
    ELSE BEGIN
      ForceErreur(NoErr);
      ErreurMath:=0;
    END;
  END;

  PROCEDURE SignalerErreur(E:integer; M:aa_string);
  BEGIN
    IF aa_Arret THEN BEGIN
      writeln;
      IF aa_Niveau = -maxint THEN E:=-abs(E); 
      write('Erreur fatale ',E:1,': ''',M,'''');
      write(' detectee dans ',aa_Nom);
      IF aa_Ovflw <> 0 THEN
        writeln(', une erreur ',aa_Ovflw:1,' s''etant produite auparavant.')
      ELSE
        writeln('.');
      halt;
    END ELSE IF (aa_Niveau = -maxint) OR (aa_Niveau = -maxint+1) THEN
      { Erreur dans programme principal ou 1er niveau bibliotheque }
      ForceErreur(E)
    ELSE { Erreur appel > 1er niveau bibliotheque }
      ForceErreur(aa_NoErr);
  END;

  PROCEDURE DebutModule(E:integer;N:aa_string);
  BEGIN
    IF aa_Niveau=maxint THEN
      Erreur('Appels de modules de bibliotheques trop nombreux');
    IF aa_Niveau = -maxint THEN { appel 1er niveau bibliotheque }
      BEGIN aa_Nom:=N; aa_NoErr:=E; END;
    aa_Niveau:=aa_Niveau+1;
  END;

  PROCEDURE FinModule;
  BEGIN
    IF aa_Niveau=-maxint THEN
      Erreur('Plus de ''FinModule'' que de ''DebutModule''');
    aa_Niveau:=aa_Niveau-1;
    IF aa_Niveau = -maxint THEN
      aa_Nom:=aa_Nom_Princ;
  END;

1.5  Dans les fonctions mmmmm (nn) suivantes:

  AddReal (1)   SubReal (1)  MultReal (2)    DivReal (3)   
  SQR (4)       SQRT (5)     LN (6)          EXP (7)
  ACH (8)       ACOS (9)     PuissReal (15)

 - ajouter apres le BEGIN marquant le debut du corps de cette 
fonction la premiere instruction:

    DebutModule(nn,'mmmmm');

 - si necessaire, ajouter un point-virgule avant le END delimitant
la fin du corps de cette fonction,

 - ajouter avant le END delimitant la fin du corps de cette 
fonction la derniere instruction:

    FinModule;

 - remplacer les instructions de la forme:

  IF aa_Ovflw = 0 THEN
     aa_Ovflw := ...i...;

avec ...i... <> 0 et ...i... <> aa_Error100 par:

    SignalerErreur(...i...,'Debordement arithmetique reel');
    

1.6  Dans les fonctions mmmmm (nn) suivantes:

  ASIN (10)     ATH (11)     CH (12)
  SH (13)       TG (14)      Puiss (15)
  
  - ajouter apres le BEGIN marquant le debut du corps de cette 
fonction la premiere instruction:

    DebutModule(nn,'mmmmm');

 - si necessaire, ajouter un point-virgule avant le END delimitant
la fin du corps de cette fonction,

 - ajouter avant le END delimitant la fin du corps de cette 
fonction la derniere instruction:

    FinModule;

- Supprimer la declaration:
   
     VAR
       Sauveaa_Ovflw : INTEGER;
     
 - Supprimer les instructions:
 
     Sauveaa_Ovflw:=aa_Ovflw;
 
     IF  ((Sauveaa_Ovflw=0) AND (aa_Ovflw<>0)
       THEN aa_Ovflw:=...i...;
       
2.  A la fin du module, ajouter la declaration de procedure
suivante:

  PROCEDURE Pause;
    CONST
      NbLignes=25; {Nombre de lignes de l'ecran}
      LongueurLigne = 80; {Nombre de caracteres dans une ligne de l'ecran}
      Msg = ' Frappez une touche pour continuer.');
      Blc = '                                   ');
    VAR
      C:char; X,Y:integer;
  BEGIN
    X:=whereX; Y:=whereY;
    IF ((X+length(Msg)) > LongueurLigne) and (Y=NbLignes) THEN
      BEGIN writeln; X:=whereX; Y:=whereY; END;
    write(Msg); read(kbd,C); gotoXY(X,Y);
    write(Blc); gotoXY(X,Y);
  END;

*****************************************************************
  La modification 1 a pour but de modifier le traitement des
erreurs.  Dans la version originale, les erreurs ne peuvent
etre detectees que si des tests sont ajoutes dans le program-
me apres chaque utilisation d'une fonction de la bibliotheque.
Ceci reste possible apres cette modification, mais l'option par
defaut est maintenant de produire un message explicite puis 
d'arreter l'execution en cas d'erreur.
  La modification 2 a pour but de deplacer la procedure Pause de
la bibliotheque Entrees.Lib dans Math.Lib.  Cette procedure est
souvent utilisee avant de passer du mode texte au mode graphique
dans Graphe.Lib. Pour ce faire, il est moins long de charger la 
bibliotheque Math.Lib que la bibliotheque Entrees.Lib.
*****************************************************************

*****************************************************************
*****************************************************************
*   GRAPHE.LIB                                                  *
*****************************************************************
*****************************************************************
1.
1.1  Changer les 9 occurences de
   
  LargeurEcran

en

  gr_LargeurEcran

1.2  Changer les 9 occurences de
   
  HauteurEcran

en

  gr_HauteurEcran

1.3  Apres la declaration de variable:

  gr_WindOverflw            : INTEGER;

ajouter les declarations de variables:

  LargeurEcran, HauteurEcran : real;

1.4 Ajouter les instructions:
  
  LargeurEcran := gr_LargeurEcran;
  HauteurEcran := gr_HauteurEcran;

avant la premiere instruction:

  SysSwOn;

de la procedure InitGraphique.

1.5 Ajouter les instructions:

  LargeurEcran := SubReal(Xmax,Xmin);
  HauteurEcran := SubReal(Ymax,Ymin);

apres le BEGIN de l'instruction:

  IF ... AND
     ... AND
     ...
    THEN
      BEGIN
        ...
      END
  ELSE gr_windOverflw:=1

formant le corps de la procedure Fenetre.


2.
2.1  Apres la declaration de variable:

  gr_WindOverflw            : INTEGER;

ajouter les declarations de variables:

  gr_Xtexte, gr_Ytexte : integer;
  gr_Xgraphique, gr_Ygraphique : real;

2.2  Apres le BEGIN delimitant le debut du corps de la procedure
InitGraphique, ajouter les deux instructions:

  gr_Xtexte:=whereX;
  gr_Ytexte:=whereY;

2.3  Modifier le corps des procedures ModeTexte et ModeGraphique
et ajouter une declaration de la procedure Deplace comme suit:

  PROCEDURE ModeTexte;

  BEGIN
    DebutModule(125,'ModeTexte');
    IF gr_CurrSw=1 THEN
      BEGIN
        gr_Xgraphique:=X_Curseur;
        gr_Ygraphique:=Y_Curseur;
        SysSw;
        gotoXY(gr_Xtexte,gr_Ytexte);
      END;
    FinModule;
  END;

  PROCEDURE Deplace(X,Y:real); FORWARD;

  PROCEDURE ModeGraphique;

  BEGIN
    DebutModule(124,'ModeGraphique');
    IF gr_CurrSw=2 THEN
      BEGIN
        gr_Xtexte:=whereX;
        gr_Ytexte:=whereY;
        SysSw;
        Deplace(gr_Xgraphique,gr_Ygraphique);
      END;
    FinModule;
  END;

2.4  Supprimer les parametres dans l'en-tete originelle de la
procedure Deplace, comme suit:

  PROCEDURE Deplace;


3.
3.1 Ajouter:

  if abs(DivReal(SubReal(gr_XWindExt,gr_XWindOrg),Grad)) <=
     (gr_LargeurEcran div 2) then

entre le THEN et le BEGIN de l'instruction

  IF ((Grad<=gr_MaxReal) AND (Grad>=gr_MinReal))
    THEN
      BEGIN
        U:=OrgX;
        ...
      END;

de la procedure X_Axe.

3.2 Ajouter:

  if abs(DivReal(SubReal(gr_YWindExt,gr_YWindOrg),Grad)) <=
     (gr_HauteurEcran div 2) then

entre le THEN et le BEGIN de l'instruction

  IF ((Grad<=gr_MaxReal) AND (Grad>=gr_MinReal))
    THEN
      BEGIN
        U:=OrgY;
        ...
      END;

de la procedure Y_Axe.

4.  Ajouter les procedures suivantes a la fin du module Graphe.lib:

  PROCEDURE IsoFenetreX(Xmin,Xmax,Ymin:real);
  BEGIN
    DebutModule(103,'IsoFenetreX');
    gr_TestModeGraphique;
    IsoFenetre(Xmin,Xmax,Ymin);
    FinModule;
  END.

  PROCEDURE IsoFenetreY(Xmin,Ymin,Ymax:real);
    VAR Xmax:real;
  BEGIN
    DebutModule(104,'IsoFenetreY');
    gr_TestModeGraphique;
    Xmax:=AddReal(Xmin,DivReal(abs(SubReal(Ymax,Ymin)),gr_rapport));
    Fenetre(Xmin,Xmax,Ymin,Ymax);
    FinModule;
  END;

  PROCEDURE Rond(X,Y:real);
  BEGIN
    DebutModule(109,'Rond');
    gr_TestModeGraphique;
    Deplace(X-Espacement/2,Y);
    Trace(X,Y+Interligne/4);
    Trace(X+Espacement/2,Y);
    Trace(X,Y-Interligne/4);
    Trace(X-Espacement/2,Y);
    Deplace(X,Y);
    FinModule;
  END;


5. 
5.1 Apres la declaration de la procedure ModeTexte, ajouter les declarations
de procedures

  procedure gr_SignalerErreurGraphique(E:integer; M:aa_string);
  begin
    if (gr_CurrSw=1) and OptionArretSiErreur then
      begin
        ModeTexte;
        SignalerErreur(E,M);
      end
    else
      SignalerErreur(E,M);
  end;

  procedure gr_TestModeGraphique;
  begin
   if gr_CurrSw<>1 then
     gr_SignalerErreurGraphique(100,'appeler ''ModeGraphique'' avant d''utiliser une procedure de Graphe.lib');
  end;


5.2 Supprimer la declaration de la variable gr_windOverfl et 
l'instruction d'initialisation

  gr_windOverfl:=0

dans la procedure InitGraphique.

5.3 Remplacer les affectations

  gr_windOverfl := ...

dans les procedures ppppp (nn, mmmmmm):

  Fenetre (101,'taille d''une fenetre incorrecte')
  Deplace (105,'coordonnees incorrectes')
  Trace   (106,'coordonnees incorrectes')

par:

  gr_SignalerErreurGraphique(nn,'mmmmm');

ou nn est le numero d'erreur et mmmmmm le message d'erreur corres-
pondant a la procedure ppppp concernee.

  
5.4  Dans la procedure InitGraphique effectuer les deux modifications
ci-dessous:

 - apres le Begin marquant le debut du corps de la procedure InitGraphique,
ajouter une premiere intruction:

  DebutModule(100,'InitGraphique');
  
 - avant le End marquant la fin du corps de la procedure InitGraphique,
 ajouter une derniere instruction:

  FinModule;

5.5  Dans les procedures ppppp (nn) suivantes (ou nn est le 
numero d'erreur correspondant a la procedure ppppp concernee):
   
  Fenetre(101)  IsoFenetre(102)      Deplace (105)   Trace(106)
  Point (107)   Croix (108)          Ecris (112)     X_Axes (110)
  Y_Axe (111)   Efface(115)          Fond(122)       Couleur(123)   
  
effectuer les deux modifications ci-dessous:

 - apres le Begin marquant le debut du corps de la procedure ppppp,
ajouter deux premieres intructions:

  DebutModule(nn,'ppppp');
  gr_TestModeGraphique;
  
 - si necessaire, ajouter un point-virgule avant le END delimitant
la fin du corps de cette procedure,

 - avant le End marquant la fin du corps de la procedure ppppp, ajouter
une derniere instruction:

  FinModule;

5.6 Modifier la function ErreurGraphique comme suit:

  FUNCTION ErreurGraphique:INTEGER;
    VAR NoErr:integer;
  BEGIN
    NoErr:=CodeErreur;
    IF (100<=NoErr) and (NoErr<=199) THEN
      ErreurGraphique:=NoErr
    ELSE BEGIN
      ForceErreur(NoErr);
      ErreurGraphique:=0;
    END;
  END;

  
6.  Remplacer la procedure PauseGraphique par:

  PROCEDURE PauseGraphique;
    CONST Nbip=3; {Nombre de bips}
    VAR   C:char;
          I:integer;
  BEGIN
    DebutModule(114,'PauseGraphique');
    gr_TestModeGraphique;
    FOR I:= 1 TO Nbip DO BEGIN
      IF I>1 THEN Delay(500);
      Sound(440);
      Delay(500);
      NoSound;
    END;
    READ(KBD,C);
    FinModule;
  END;

*****************************************************************
  La modification 1 a pour but de rapporter LargeurEcran et
HauteurEcran au systeme de coordonnnees de l'utilisateur quand il
ne choisit pas d'utiliser celles de l'ecran. Une fois faite, il
faut imperativement faire la modification 1. correspondante dans 
le fichier G640x200.CGA (ou le fichier correspondant a la carte
graphique utilisee).
  La modification 2 a pour but de corriger une erreur lors du pas-
sage du mode texte au mode graphique et inversement qui fait que
le curseur n'est pas reste positionne ou il se trouvait lors du
dernier changement (mais est positionne en haut a gauche de 
l'ecran). On remarquera que lorsque l'execution d'un programme se
termine en mode graphique, il suffit de taper un retour chariot
pour retrouver un ecran propre sous Turbo-Pascal.
  La modification 3 a pour but d'eviter qu'un gros trait ne soit
trace voire que la procedure boucle (parceque U+Grad=Grad a cause
des erreurs d'arrondi) quand la taille Grad des graduations est
petite par rapport a la taille (gr_.WindExt - gr_.WindOrg) de la
fenetre graphique.
  La modification 4 complete la bibliotheque, le Rond etant pour
simplifier un petit losange.
  La modification 5 permet d'obtenir un message explicite en cas
d'erreur, la bibliotheque Math.lib devant alors etre incluse avant
la bibliotheque Graphe.Lib. Cependant pour que la detection des
erreurs soit complete, il faudrait remplacer tous les operateurs 
+ - * / pouvant conduire a une erreur a l'execution par des appels
aux fonctions correspondantes de Math.Lib.
		La modification 6 permet d'avertir l'utilisateur qu'il doit
enfoncer une touche par plusieurs bips successifs, la procedure 
PauseGraphique n'ayant aucun effet visuel.
*****************************************************************


*****************************************************************
*****************************************************************
*   G640x200.CGA, G320x200.CGA, G720x348.HER, G640x400.OLI      *
*****************************************************************
*****************************************************************

  Les modifications ci-dessous sont a adapter aux conditions 
locales de rangement des fichiers et a la carte graphique 
utilisee, ici, par exemple, la carte CGA 640x200 monochrome.

1.
1.1  Changer TOUTES les occurences de
   
  LargeurEcran

en

  gr_LargeurEcran

1.2  Changer TOUTES les occurences de
   
  HauteurEcran

en

  gr_HauteurEcran

2. Il se peut que la procedure Ecris de la bibliotheque Graphe.Lib
ne fonctionne pas correctement, rien n'etant ecrit sur l'ecran.
Pour corriger l'erreur, changer l'instruction
  
  ASSIGN(F,'US.IBM');

de la procedure SysLoadChar de la bibliotheque G640x200.CGA par

  ASSIGN(F,'C:\MODULOG\US.IBM');

(en supposant que le fichier US.IBM soit range dans le repertoire
MODULOG du disque C).
*****************************************************************

*****************************************************************
*****************************************************************
*   ENTREES.LIB                                                 *
*****************************************************************
*****************************************************************

1.  Supprimer la declaration de la procedure Pause.

2.  Inserer l'instruction:

  if (ligne = es_nb_lignes_ecran) and (colonne + length(message)
     > es_nb_colonnes_ecran) then
    ligne := ligne - 1;

avant l'instruction:

  write(message);

dans les trois procedures:

  es_ecrit_message
  es_choix
  es_confirmation


3.
3.1  Supprimer la declaration de procedure 

  Procedure es_arret ;
    Begin
      ...
    end ;

3.2  Dans les procedures ou fonctions:

  xx  mmmmm (nn, mm)

suivantes:

  1  Definis_Fonction (201,'liste de parametres formels incorrecte')
  1  Entre_Fonction   (202,'liste de parametres formels incorrecte')
  1  Evalue1          (203,'liste de parametres effectifs incorrecte')
  1  Evalue2          (204,'liste de parametres effectifs incorrecte')
  1  Evalue3          (205,'liste de parametres effectifs incorrecte')
  1  Evalue4          (206,'liste de parametres effectifs incorrecte')
  3  Affiche_Matrice  (210,'dimensions incorrectes')
  3  Entre_Matrice    (211,'dimensions incorrectes')

remplacer les xx PREMIERES occurrences de

  es_arret;

par:

    SignalerErreur(nn,mm)
  ELSE BEGIN

puis rajouter xx

  END

a la fin du module mmmmm.


3.3  Dans la procedure Definis_Fonction:

- Ajouter la declaration de variables:
     Err,CorpsCorrect:boolean; NoErr:integer;

- Remplacer   InitMath;   par:
     Err:=OptionArretSiErreur;
     ArreterSiErreur(false);
     NoErr:=CodeErreur;

- Apres l'instruction:
     
     Fct := aa_Fonctor(Texte) ;
     
  ajouter les instrcutions:
  
     CorpsCorrect:=(CodeErreur=0);
     ForceErreur(NoErr);
     ArreterSiErreur(Err);

- Remplacer (aa_Errno = 0) par CorpsCorrect,

- Remplacer la derniere occurrence de es_arret par:

    SignalerErreur('201,'Corps de fonction incorrecte');

3.4 dans les procedures:

  Entre_Fonction
  xy_Entre_Reel

- Ajouter la declaration de variables:
     Err,Fin:boolean; NoErr:integer;

- Remplacer aa_Errno et Erreur_Math par CodeErreur (dans 
correct_fonction et correct_reel)

- Remplacer la boucle:

    repeat
      ...x...
     Initmath;
     ...y...
    until correct_...;

par:
 
   repeat
     ...x...
     Err:=OptionArretSiErreur;
     ArreterSiErreur(false);
     NoErr:=CodeErreur;
     ...y...
     Fin:=correct_...
     ForceErreur(NoErr);
     ArreterSiErreur(Err);
   until Fin;

3.5  Dans les procedures ou fonctions ppppp (nn) suivantes:

  Definis_Fonction   (201)
  Entre_Fonction     (202)
  Evalue1            (203)
  Evalue2            (204)
  Evalue3            (205)
  Evalue4            (206)
  Affiche_Expression (207)
  Affiche_Matrice    (210)
  Entre_Matrice      (211)
  Entre_Reel         (216)
  Entre_Entier       (217)
  
faire les deux modifications ci-dessous:

   - Apres le begin marquant le debut du corps de la procedure,
ajouter la premiere instruction:

      DebutModule(nn,'ppppp');

  - Avant le end marquant la fin du corps de la procedure, ajouter
une derniere instruction:

      FinModule;

3.6   Dans la procedure   definition_globale   se trouvant dans la
procedure   es_edite_matrice   :

- Ajouter la declaration des variables:
     Err:boolean; NoErr:integer;

- Remplacer l'instruction:

     If entree_mat then
       begin
         ...
         InitMath;
         ...
       end;

par l'instruction:

     If entree_mat then
       begin
         ...
         Err:=OptionArretSiErreur; ArreterSiErreur(false); NoErr:=CodeErreur;;
         ...
         ArreterSiErreur(Err); ForceErreur(NoErr);
       end;

3.7  A la fin du module Entrees.Lib, ajouter la declaration de
fonction:

 FUNCTION ErreurEntrees:integer;
    VAR NoErr:integer;
  BEGIN
    NoErr:=CodeErreur;
    IF (200<=NoErr) and (NoErr<=299) THEN
      ErreurEntrees:=NoErr
    ELSE BEGIN
      ForceErreur(NoErr); 
      ErreurEntrees:=0;
    END;
  END;

4.  Remplacer la procedure Entre_booleen par:

  Procedure Entre_booleen(var b : Boolean);
      var C:char;
  Begin
    DebutModule(218,'Entre_booleen');
    C:=es_choix('OVT1NF0')
    write(C); readln;
    b:= (C='O') or (C='V') or (C='T') or (C='1');
    FinModule;
  End;

5.
5.1 remplacer l'en-tete de la procedure es_edite_matrice par:

  Procedure es_edite_matrice(var A1; 
                             nb_lignes_matrice:integer;
                             nb_colonnes_matrice:integer;
                             entree_mat:boolean;
                             bs:integer);
  
  (en notant bien qu'il y a deux changements).
  
5.2 Apres la declaration de variable:

  taille_curseur : integer;

ajouter les declarations suivantes:

  type Matrice = array[0..8191] of real;
  var A : Matrice absolute A1;

  function Ind(I,J:integer):integer;
  begin
    Ind:=((I-1)*Bs)+J-1;
  end;

5.3 Remplacer les 16 occurences de

   A[...i..., ...j...]

(ou ...i... est ligne ou ligne_curseur et ...j... est colonne ou
colonne_curseur) par 

   A[Ind(...i..., ...j...)]

5.4 Remplacer les deux appels de procedure:

   es_edite_matrice(A,nb_lignes,nb_colonnes,...)

dans Affiche_matrice et Entre_Matrice par

   es_edite_matrice(A,nb_lignes,nb_colonnes,...,20)

5.5 Supprimer les declarations des procedures Affiche_vecteur et
Entre_Vecteur.

5.6 A la fin du module Entrees.Lib, ajouter les declarations de 
procedures:

  Procedure AfficheMatrice(var M; Bs1,Bs2:integer);
  Begin
    DebutModule(214,'AfficheMatrice');
    if (Bs1<1) or (Bs2<1) or (MultReal(Bs1,Bs2)>8191) then
      SignalerErreur(214,'bornes incorrectes')
    else begin
      es_edite_matrice(M,Bs1,Bs2,false,Bs2);
      writeln;
     end;
    FinModule;
  end;

  Procedure EntreMatrice(var M; Bs1,Bs2:integer);
  Begin
    DebutModule(215,'EntreMatrice');
    if (Bs1<1) or (Bs2<1) or (MultReal(Bs1,Bs2)>8191) then
      SignalerErreur(215,'bornes incorrectes')
    else begin
      es_edite_matrice(M,Bs1,Bs2,true,Bs2);
      gotoXY(es_nb_colonnes_ecran,es_nb_lignes_ecran);
      writeln;
    end;
    FinModule;
 end;

 Procedure Affiche_Vecteur(var U; nb_colonnes:Integer);
 begin
   DebutModule(212,'Affiche_Vecteur');
   AfficheMatrice(U,1,nb_colonnes);
   FinModule;
 end;
 
 Procedure Entre_Vecteur(var U; nb_colonnes:Integer);
 begin
   DebutModule(211,'Entre_Vecteur');
   EntreMatrice(U,1,nb_colonnes);
   FinModule;
 end;
 
6.
6.1  Dans la procedure Affiche_Matrice ajouter une instruction:

  writeln;

apres l'instruction:

  es_edite_matrice(A,nb_lignes,nb_colonnes,...);

6.2  Dans la procedure Entre_Matrice ajouter deux instructions:

  gotoXY(es_nb_colonnes_ecran,es_nb_lignes_ecran);
  writeln;

apres l'instruction:

  es_edite_matrice(A,nb_lignes,nb_colonnes,...);

7.
7.1 Remplacer writeln par write dans Affiche_Expression.

7.2 Ajouter la procedure suivante a la fin du module:

  procedure Affiche_ExpressionLn(F:Fonction);
  begin
    DebutModule(208,'Affiche_ExpressionLn');
    Affiche_Expression(F); writeln;
    FinModule;
  end;
  
*****************************************************************
  L'inclusion de Entrees.Lib dans un programme n'est pas compa-
tible avec l'option de compilation B- qui a un effet global dans
le programme.
  La modification 1 assure la compatibilite avec la modification
6 de Math.Lib.
  La modification 2 permet d'effacer le message imprime meme si
le debut de celui-ci est passe sur la ligne precedente quand le
texte se decale d'une ligne vers le haut sur l'ecran lors de 
l'ecriture du message.
  La modification 3 a pour but de laisser le mode de choix du
traitement des erreurs a l'utilisateur.
  La modification 4 a pour effet de rendre la lecture des booleens
comparable a celle des entiers ou des reels. En particulier la
valeur lue est suivie d'un retour chariot et ecrite sur l'ecran.
  La modification 5 a pour but de permettre l'entree de matrice
(ou vecteurs si Bs1=1) de dimensions autres que 20x20.
  La modification 6 evite que les entrees-sorties suivant un 
affichage ou une entree de matrice ne se melangent sur l'ecran.
  La modification 7 laisse a l'utilisateur le choix du passage a
la ligne.

*****************************************************************
*****************************************************************
*   COMPLEXE.LIB                                                *
*****************************************************************
*****************************************************************

1
1.1  MODULE

1.1.1  Apres le BEGIN delimitant le debut du corps de la fonction
Module, ajouter

  IF Z[PartieImaginaire] = 0.0 THEN
    Module := abs(Z[PartieReelle])
  ELSE IF Z[PartieReelle] = 0.0 THEN
    Module := abs(Z[PartieImaginaire])
  ELSE IF ( abs(Z[PartieReelle]) < sqrt(maxreal/2.0) )
          and ( abs(Z[PartieImaginaire]) < sqrt(maxreal/2.0) ) THEN
    Module := sqrt(AddReal(sqr(Z[PartieReelle]),
                           sqr(Z[PartieImaginaire])))
  ELSE
  
1.1.2  Puis dans les tests de la fonction module remplacer les deux
occurrences de:

  Z[PartieImaginaire]  par  abs(Z[PartieImaginaire])
  Z[PartieReelle]      par  abs(Z[PartieReelle])

1.1.3  Et enfin remplacer les operateurs Pascal + et * par des
appels aux fonctions AddReal et MultReal de Math.Lib.

1.2  ARGUMENT

1.2.1  Entre les instructions
 
  y := Z[PartieImaginaire];
  
et

  IF x > abs(y)
    THEN ...
    
inserer:

  if abs(y)<=minreal then begin
    if abs(x)<=minreal then begin
      Theta:=0.0;
      SignalerErreur(309,'Argument indertermine');
    end else if x>0 then
      Theta:=0.0
    else
      Theta:=pi
  end else if abs(x)<=minreal then begin
    if y>0 then
      Theta:=pi/2
    else
      Theta:=3*pi/2;
  end else

1.3  RACINECOMPLEXE

1.3.1  Entre le ELSE et le BEGIN figurant dans le corps de la
fonction RacineComplexe:

  PROCEDURE RacineComplexe...
    VAR
      ...
  BEGIN
    IF n = 0
      THEN  BEGIN
              ...
            END
       ELSE BEGIN    <------------
              ...
            END;
  END;
  
inserer:

  if (abs(x[PartieReelle])<=minreal)
     and (abs(x[PartieImaginaire])<=minreal) then begin
       z[PartieReelle]:=0.0;
       z[PartieImaginaire]:=0.0;`
  end else
2. 
2.1  Dans les procedures et fonctions mmmmm (nn) suivantes
 
  AddComplexe (300)         SubComplexe (301)     MultComplexe (302)
  ScalMult (303)            Module (304)          DivComplexe(305)
  InverseComplexe (306)     Argument (309)        RhoTheta (310)
  PuissanceComplexe (311)   RacineComplexe (312)  EntreComplexe (307)

ajouter une premiere instruction:

  DebutModule(nn,'mmmmm');

puis ajouter une derniere instruction (eventuellement precedee
d'un point-virgule)
 
  FinModule;

ou (nn) est le numero d'erreur correspondant a la procedure ou
fonction mmmmm en question.

2.2  Remplacer la fonction ErreurComplexe par:

  FUNCTION ErreurComplexe:integer;
    VAR NoErr:integer;
  BEGIN
    NoErr:=CodeErreur;
    IF (300<=NoErr) and (NoErr<=399) THEN
      ErreurComplexe:=NoErr
    ELSE BEGIN
      ForceErreur(NoErr); 
      ErreurComplexe:=0;
    END;
  END;

3.  Remplacer la procedure EcrisComplexe par:

  PROCEDURE EcrisComplexe(VAR z : Complexe);
    
    VAR
      y : real;
      Imaginaire : boolean;

  BEGIN
    DebutModule(308,'EcrisComplexe');
    y := z[PartieImaginaire];
    Imaginaire:=(Y<>0.0);
    IF Imaginaire THEN write('(');
    IF (NOT Imaginaire) OR (z[PartieReelle]<>0.0) THEN
      write(z[PartieReelle] : 1 : 8);
    IF Imaginaire THEN
      IF y=1.0 THEN write('+i)')
      ELSE IF y=-1.0 THEN write('-i)')
      ELSE BEGIN
        IF Y>=0.0 THEN write('+');
        write(z[PartieImaginaire] : 1 : 8,'i)');
      END;
    FinModule;
  END;

4.
4.1
4.1.1  Remplacer la procedure ScalMult par:

  PROCEDURE ScalMult (x : real; z1:Complexe; VAR z : Complexe);
  
  BEGIN
    DebutModule(303,'ScalMult');
    z[PartieReelle] := MultReal(z1[PartieReelle],x);
    z[PartieImaginaire] := MultReal(z1[PartieImaginaire],x);
    FinModule;
  END;
  
4.1.2  Remplacer l'instruction:

  ScalMult(sqr(DivReal(1, yModule)), y);
  
de la procedure   DivComplexe   par:

  ScalMult(sqr(DivReal(1, yModule)), y, y);
  
    
4.2 Ajouter les declarations suivantes a la fin du module:

  function PartReelle(Z:Complexe):real;
  begin PartReelle:=Z[PartieReelle]; end;

  function PartImaginaire(Z:Complexe):real;
  begin PartImaginaire:=Z[PartieImaginaire]; end;

  procedure ComplexeRect(X,Y:real; var Z:Complexe);
  begin Z[PartieReelle]:=X; Z[PartieImaginaire]:=Y; end;
  
  function EgalComplexe(Z1,Z2:Complexe):boolean;
  begin
    EgalComplexe:=(PartReelle(Z1)=PartReelle(Z2)) and
                  (PartImaginaire(Z1)=PartImaginaire(Z2));
  end;

  procedure EcrisComplexeLn(Z:Complexe);
  begin
    DebutModule(313,'EcrisComplexeLn');
    EcrisComplexe(Z); writeln;
    FinModule;
  end;

  procedure EcrisRhoTheta(Z:Complexe);
   begin
    DebutModule(314,'EcrisRhoTheta');
    write('(',Module(Z):1:8,', ',Argument(Z):1:8,')');
    FinModule;
  end;
  
  procedure EcrisRhoThetaLn(Z:Complexe);
  begin
    DebutModule(315,'EcrisRhoThetaLn');
    EcrisRhoTheta(Z); writeln;
    FinModule;
  end;

  procedure ConjComplexe(Z1:Complexe; var Z:Complexe);
  begin ComplexeRect(PartReelle(Z1),-PartImaginaire(Z1),Z); end;

  procedure OppoComplexe(Z1:Complexe; var Z:Complexe);
  begin ComplexeRect(-PartReelle(Z1),-PartImaginaire(Z1),Z); end;
    
  procedure CarreComplexe(Z1:Complexe; var Z:Complexe);
  begin
    DebutModule(316,'CarreComplexe');
    PuissanceComplexe(Z1,2,Z);
    FinModule;
  end;
  
  procedure RacCarreeComp(Z1:Complexe; var Z:Complexe);
   begin
    DebutModule(317,'RacCarreeComp');
    RacineComplexe(Z1,2,Z);
    FinModule;
  end;

*****************************************************************
  La modification 1 a pour but de corriger des erreurs, le module
des complexes (-4+0i) et (0-4i) conduisant par exemple a une div-
ision par zero tandis que l'argument et la racine complexe donnent
des resultats errones quand le module est tres petit.
  La modification 2 a pour but d'une part d'offrir la possibilite
de signaler explicitement les erreurs et d'autre part de retourner
des numeros d'erreur relatifs a la bibliotheque Complexe.Lib et 
non pas relatifs a Math.lib.
  La modification 3 a pour but de respecter les conventions 
mathematiques dans l'ecriture des nombres complexes (par exemple
on ecrit 3 et non (3+0i) ou (1+i) et non (1+1.i)).
  Les complements 4 ont pour but de rendre l'utilisation de la 
bibliotheque Complexe.Lib independante de la representation des
complexes utilisee dans cette bibliotheque (les informaticiens
diraient pour faire de Complexe un type abstrait).
*****************************************************************


*****************************************************************
*****************************************************************
*   DEMO                                                        *
*****************************************************************
*****************************************************************
  Dans les exemples donnes dans le repertoire DEMO faire les
changements suivants:

 (1)  Changer la directive d'inclusion de la bibliotheque corres-
      pondant a la carte graphique utilisee,
 (2)  Changer toutes les occurrences de ErreurMath en CodeErreur,
 (3)  Apres
        InitMath;
      ajouter l'instruction:
        ArreterSiErreur(false);
 (4)  Ajouter la directive d'inclusion de bibliotheque:
        (*$i math.lib*)
      apres l'en-tete du programme   program ...;
 (5)  Ajouter l'appel de procedure:
        InitMath;
      apres le   begin  marquant le debut du corps du prgramme
      
 comme suit:
 
    Courbe1   (1) (2)
    Tabule    (2) (3)
    Cercle    (1) (4) (5)
    Implicit  (1) (2)
    Temps     (5)
    Courbe2   (1) (5)
 
comme suit:
    TABULE
faire les modifications suivantes:

- Remplacer les occurrences de:

    ErreurMath
    
  par
  
    CodeErreur
    
 - 
*****************************************************************
*****************************************************************



*****************************************************************
*****************************************************************
*   POLYNOME.LIB                                                *
*****************************************************************
*****************************************************************
  Copier le fichier POLYNOME.LIB contenu sur cette disquette
dans le repertoire contenant les fichiers des modules de la
bibliotheque MODULOG.
*****************************************************************
*****************************************************************