Langage de programmation - Turbo Pascal

Chimie

La chimie, en tant que discipline scientifique, explore la composition, les propriétés et les réactions des substances chimiques. Dans ce cadre, les calculs de masse molaire, d'équilibrage de réactions chimiques, ou encore d'analyse de spectres peuvent être automatisés avec des outils informatiques. Turbo Pascal, un langage de programmation populaire dans les années 1980 et 1990, offre une manière simple et rapide de résoudre ces problèmes. Il permet d'écrire des programmes pour effectuer des calculs chimiques complexes tout en assurant une exécution rapide et une gestion efficace de la mémoire. En utilisant Turbo Pascal, les étudiants et chercheurs peuvent réaliser des simulations chimiques et même manipuler des formules chimiques de manière algorithmique.

L'un des calculs fondamentaux en chimie est la détermination de la masse molaire d'un composé. Dans Turbo Pascal, un programme peut être écrit pour déterminer la masse molaire d'un composé chimique en fonction des éléments qui le composent. En utilisant des tableaux et des boucles, le programme peut demander à l'utilisateur d'entrer la formule chimique et calculer la masse molaire en additionnant les masses des éléments présents. Ce genre de programme est utile pour les chimistes, car il permet d'éviter les calculs manuels fastidieux et offre une grande précision, ce qui est crucial dans les expériences chimiques.

L'équilibrage des réactions chimiques est un autre aspect de la chimie que Turbo Pascal peut simplifier. Lorsqu'une réaction chimique se déroule, il est essentiel de s'assurer que le nombre d'atomes de chaque élément est le même des deux côtés de l'équation. Turbo Pascal peut être utilisé pour créer des programmes automatisant cette tâche, en détectant les coefficients stochiométriques équilibrant les réactifs et les produits. Bien que l'équilibrage des réactions chimiques soit souvent complexe, les algorithmes de recherche de solutions et les tableaux d'éléments peuvent aider à résoudre cette problématique efficacement en utilisant la programmation.

La simulation de réactions chimiques à l'aide de Turbo Pascal peut également être une application pratique. Les chimistes peuvent simuler des réactions sous différentes conditions, telles que la température, la pression et la concentration des réactifs, pour prédire le comportement des substances. À l'aide de programmes en Turbo Pascal, des modèles mathématiques basés sur les lois chimiques peuvent être calculés pour estimer les vitesses de réaction, l'évolution des concentrations des réactifs et des produits, ainsi que d'autres paramètres critiques. Cela permet de mieux comprendre et d'anticiper les résultats des expériences chimiques avant de les réaliser physiquement.

Dans le domaine des sciences de l'environnement, la chimie joue un rôle fondamental dans l'analyse des polluants, le traitement des eaux, ou encore le contrôle des émissions de gaz. Avec Turbo Pascal, il est possible de créer des programmes qui modélisent le comportement de certains polluants dans l'atmosphère ou dans l'eau. Par exemple, des calculs de concentration et des simulations de dispersion des polluants peuvent être réalisés. Cela aide à prévoir les impacts environnementaux d'un produit chimique ou d'une substance, facilitant ainsi la gestion et la réduction des risques environnementaux liés à l'industrie chimique.

Programme simple pour calculer la masse molaire

Ce programme demande à l'utilisateur de saisir une formule chimique simple, puis calcule la masse molaire en fonction des atomes présents :



Program MasseMolaireSimple;

 
Uses Crt;

 
Var

 masseMolaire:Real;

 i:Integer;

 Element:String;

 Nombre:Integer;

 
Const

 Elements:Array[1..5] of string = ('H', 'C', 'O', 'N', 'S');        { Symboles des éléments }

 Masses:Array[1..5] of real = (1.008, 12.01, 16.00, 14.01, 32.07);  { Masse molaire des éléments }

 
BEGIN

 ClrScr;

 MasseMolaire:=0;

 Write('Entrez la formule chimique (exemple : H2O, C6H12O6): ');

 ReadLn(element);

 For i := 1 to 5 do Begin

  If Element=Elements[i]Then Begin

   MasseMolaire:=MasseMolaire+Masses[i];

   Break;

  End;

 End;

 Writeln('Masse molaire du composé: ', masseMolaire:0:2, ' g/mol');

 ReadLn;

END.

Le programme MasseMolaireSimple en Turbo Pascal permet de calculer la masse molaire d'un composé chimique en fonction des éléments chimiques qu'il contient. Tout d'abord, le programme commence par inclure l'unité Crt pour gérer l'affichage à l'écran. Il déclare ensuite plusieurs variables : masseMolaire pour entreposer la masse totale du composé, i pour parcourir les éléments, Element pour saisir la formule chimique entrée par l'utilisateur, et Nombre qui semble inutilisé dans ce programme. Deux tableaux constants sont définis : Elements, qui contient cinq éléments chimiques sous forme de symboles ('H', 'C', 'O', 'N', 'S'), et Masses, entreposant les masses molaires correspondantes en grammes par mole.

Lorsque le programme s'exécute, il affiche un message demandant à l'utilisateur d'entrer une formule chimique, par exemple "H2O" ou "C6H12O6". Il lit ensuite cette entrée et la compare aux cinq éléments stockés dans le tableau Elements. Si une correspondance est trouvée, la masse molaire du composé est mise à jour en ajoutant la masse molaire de l'élément trouvé. L'instruction Break permet d'interrompre la boucle dès qu'une correspondance est trouvée, évitant ainsi des vérifications inutiles. À la fin de l'exécution, le programme affiche la masse molaire totale calculée, mais il ne gère pas correctement les formules chimiques avec plusieurs atomes d'un même élément, ce qui limite son efficacité.

Bien que ce programme constitue une bonne base, il comporte plusieurs limitations. D'une part, il ne prend pas en compte les indices présents dans une formule chimique, ce qui signifie que les molécules plus complexes, comme "H2O", ne sont pas correctement traitées puisque le programme ne lit qu'un seul élément sans analyser le nombre d'atomes. De plus, il est sensible aux entrées utilisateur en majuscules et ne traite pas les mélanges d'éléments dans une formule. Pour améliorer ce programme, il faudrait ajouter un mécanisme d'analyse des indices et de reconnaissance des éléments pour calculer correctement la masse molaire d'un composé plus complexe.

Calcul de la masse molaire d'un composé

Voici un exemple de programme en Turbo Pascal pour calculer la masse molaire d'un composé chimique en fonction de sa formule moléculaire :



Program MasseMolaire;

 
Uses crt;

 
Var

 formula:String;

 i, quantity:Integer;

 totalMass:Real;

 element:Char;

 
Const

 Elements:Array[1..5] of string = ('H', 'C', 'O', 'N', 'S');        { Symboles des éléments }

 Masses:Array[1..5] of real = (1.008, 12.01, 16.00, 14.01, 32.07);  { Masse molaire des éléments }

 
BEGIN

 ClrScr;

 totalMass:=0;

 Write('Entrez la formule chimique (ex. H2O, C6H12O6): ');

 ReadLn(formula);

 For i := 1 to length(formula) do Begin

  Element:=Formula[i];

  Quantity:=0;

  If(i + 1 <= length(formula)) and (formula[i + 1] in ['0'..'9'])Then Begin

   Quantity:=ord(formula[i + 1]) - ord('0');  { Convertit le chiffre en entier }

   Continue;  { Passe à l'itération suivante sans exécuter le code suivant dans cette itération }

  End

   Else

  Quantity:=1;

  Case element of

   'H': totalMass := totalMass + (masses[1] * quantity);

   'C': totalMass := totalMass + (masses[2] * quantity);

   'O': totalMass := totalMass + (masses[3] * quantity);

   'N': totalMass := totalMass + (masses[4] * quantity);

   'S': totalMass := totalMass + (masses[5] * quantity);

  End;

 End;

 WriteLn('Masse molaire du composé "', formula, '" est: ', totalMass:0:2, ' g/mol');

 ReadLn;

END.

Le programme MasseMolaire en Turbo Pascal permet de calculer la masse molaire d'un composé chimique en analysant sa formule moléculaire. Il commence par inclure l'unité Crt pour la gestion de l'affichage, puis déclare plusieurs variables : formula pour entreposer la formule saisie par l'utilisateur, i pour parcourir chaque caractère de la formule, quantity pour enregistrer la quantité d'atomes d'un élément donné, totalMass pour cumuler la masse molaire totale, et element pour entreposer un symbole chimique à analyser. Deux tableaux constants sont définis : Elements, contenant cinq éléments chimiques (H, C, O, N, S), et Masses, entreposant leurs masses molaires respectives.

Lorsque l'utilisateur saisit une formule chimique comme "H2O", le programme la parcourt caractère par caractère. Il extrait d'abord un élément chimique sous forme d'un caractère unique (H, C, O, N ou S). Ensuite, il vérifie si ce caractère est suivi d'un chiffre, ce qui indiquerait la quantité de cet élément dans la molécule (exemple : "H2" signifie deux atomes d'hydrogène). Pour convertir ce chiffre en un entier, il utilise la fonction ord, transformant le caractère numérique en sa valeur ASCII et en soustrait la valeur ASCII de '0'. Si aucun chiffre ne suit l'élément, il suppose par défaut une quantité de 1.

Enfin, le programme utilise une instruction Case pour associer chaque élément à sa masse molaire correspondante et l'ajouter à la totalMass, en tenant compte du facteur de multiplication donné par quantity. Une fois la formule entièrement parcourue, la masse molaire totale du composé est affichée à l'écran. Cependant, ce programme présente quelques limitations : il ne prend en charge que les éléments d'un seul caractère (il ne reconnaît pas des symboles comme "Cl" ou "Fe"), et il ne gère que des indices numériques à un seul chiffre (exemple : "H10O" ne fonctionnerait pas correctement). Des améliorations pourraient être apportées en analysant les symboles chimiques plus complexes et en gérant les indices à plusieurs chiffres.

Calcul de la concentration molaire

Ce programme aide à calculer la concentration molaire d'une solution à partir de la quantité de soluté et du volume de la solution :



Program ConcentrationMolaire;

 
Uses crt;

 
Var

 n:Real;  { Quantité de soluté en moles }

 V:Real;  { Volume de la solution en litres }

 C:Real;  { Concentration molaire en mol/L }

 
BEGIN

 ClrScr;

  { Demander la quantité de soluté (en moles) }

 Write('Entrez la quantité de soluté (en moles) : ');

 ReadLn(n);

  { Demander le volume de la solution (en litres) }

 Write('Entrez le volume de la solution (en litres) : ');

 ReadLn(V);

  { Vérifier si le volume est non nul pour éviter la division par zéro }

 If V=0 Then WriteLn('Erreur : le volume ne peut pas être nul.')

  Else

 Begin

   { Calcul de la concentration molaire }

  C:=n/V;

   { Affichage du résultat }

  WriteLn('La concentration molaire de la solution est : ', C:0:2, ' mol/L');

 End;

 ReadLn;

END.

Le programme ConcentrationMolaire en Turbo Pascal est conçu pour calculer la concentration molaire d'une solution en fonction de la quantité de soluté et du volume de la solution. Il commence par inclure l'unité Crt afin de permettre une interaction fluide avec l'utilisateur via l'affichage et la saisie de données. Trois variables de type Real sont déclarées : n représente la quantité de soluté en moles, V le volume de la solution en litres, et C la concentration molaire en mol/L. Le programme affiche un écran vierge avec ClrScr, puis invite l'utilisateur à entrer la quantité de soluté et le volume de la solution. Ces valeurs sont saisies via ReadLn et entreposées dans les variables respectives.

Avant de procéder au calcul, le programme vérifie si la valeur du volume V est nulle afin d'éviter une division par zéro, provoquant une erreur d'exécution. Si V est égal à zéro, un message d'erreur est affiché avec WriteLn('Erreur : le volume ne peut pas être nul.') et le programme s'arrête avant tout calcul. Si V est non nul, le programme calcule la concentration molaire en appliquant la formule C = n / V, puis entrepose le résultat dans la variable C. Ce contrôle est essentiel pour garantir la robustesse du programme et éviter des erreurs mathématiques qui pourraient rendre le programme inutilisable.

Enfin, le programme affiche la valeur de C avec deux décimales grâce à WriteLn('La concentration molaire de la solution est : ', C:0:2, ' mol/L'). Ce formatage améliore la lisibilité du résultat et permet une meilleure interprétation des données. Une fois le calcul terminé, l'utilisateur doit appuyer sur une touche pour quitter le programme, grâce à l'instruction ReadLn finale. Une amélioration possible serait d'ajouter un contrôle sur les valeurs négatives de n ou V, car en chimie, une quantité de soluté ou un volume ne peuvent pas être négatifs. Ce programme simple et efficace permet ainsi d'effectuer des calculs de concentration molaire de manière interactive et sécurisée.

Calcul du pH d'une solution

Ce programme peut calculer le pH d'une solution en fonction de la concentration en ions hydrogène.



Program CalculPh;

 
Uses crt;

 
Var

 Concentration:Real;  { Concentration en ions H+ (mol/L) }

 ph:Real;             { pH de la solution }

 
Const

 LN_10=2.302585092994046;  { Valeur de ln(10) }

 
 { Fonction pour calculer le logarithme en base 10 }

Function Log10(x:Real):Real;Begin

 If x>0 Then Log10:=ln(x)/LN_10

        Else Log10 := 0;  { Retourne 0 pour les valeurs invalides }

End;

 
BEGIN

 ClrScr;

  { Demander à l'utilisateur d'entrer la concentration en ions H+ }

 Write('Entrez la concentration en ions H+ (en mol/L) : ');

 ReadLn(Concentration);

  { Vérification que la concentration est positive }

 If Concentration<=0 Then

  WriteLn('Erreur : la concentration doit être un nombre positif.')

  Else

 Begin

   { Calcul du pH en utilisant la formule pH = -log10([H+]) }

  ph:=-log10(concentration);

   { Affichage du résultat }

  Writeln('Le pH de la solution est : ', ph:0:2);

 End;

 ReadLn;

END.

Le programme CalculPh est conçu pour déterminer le pH d'une solution à partir de la concentration en ions H⁺ exprimée en mol/L. Il commence par inclure l'unité Crt pour gérer l'affichage et l'entrée des données. Deux variables de type Real sont déclarées : Concentration représente la concentration en ions H⁺, tandis que ph entreposera la valeur calculée du pH. Une constante LN_10 est également définie, correspondant à la valeur de ln(10), utilisée pour convertir un logarithme naturel en logarithme décimal. Une fonction personnalisée Log10(x:Real) est ensuite déclarée pour calculer le logarithme en base 10 d'un nombre donné. Cette fonction utilise la relation log10(x) = ln(x) / ln(10) et retourne 0 si l'entrée est invalide (valeur négative ou nulle).

Le programme commence par effacer l'écran avec ClrScr, puis invite l'utilisateur à entrer la concentration en ions H⁺ via Write et ReadLn(Concentration). Avant d'effectuer le calcul, une vérification est effectuée pour s'assurer que la concentration est un nombre strictement positif. Si la valeur saisie est nulle ou négative, un message d'erreur est affiché avec WriteLn('Erreur : la concentration doit être un nombre positif.'), et le programme s'arrête sans poursuivre le calcul. Cette vérification est essentielle car la définition du pH repose sur une concentration strictement positive ; toute valeur non conforme rendrait le calcul mathématiquement incorrect.

Si la concentration est valide, le programme applique la formule pH = -log10([H⁺]) en appelant la fonction log10(). Le résultat est ensuite affiché avec Writeln('Le pH de la solution est : ', ph:0:2);, permettant d'obtenir une valeur arrondie à deux décimales pour une meilleure lisibilité. Enfin, l'instruction ReadLn est utilisée pour suspendre l'exécution et attendre une interaction de l'utilisateur avant la fermeture du programme. Une amélioration possible serait d'afficher une indication sur l'acidité ou la basicité de la solution en fonction du pH obtenu (pH < 7 acide, pH > 7 basique, pH = 7 neutre). Ce programme simple et interactif constitue un outil utile pour les étudiants et les chimistes souhaitant calculer rapidement le pH d'une solution.

Calcul du rendement d'une réaction chimique

Un programme pour calculer le rendement théorique et le rendement réel d'une réaction chimique, en utilisant les masses des réactifs et des produits :



Program CalculRendement;

 
Uses Crt;

 
Var

 masseReactif:Real;      { Masse du réactif (en g) }

 masseProduit:Real;      { Masse du produit réel (en g) }

 masseProduitTheo:Real;  { Masse du produit théorique (en g) }

 rendementTheo:Real;     { Rendement théorique en g }

 rendementReel:Real;     { Rendement réel en g }

 rendement:Real;         { Rendement en pourcentage }

 
BEGIN

 ClrScr;

  { Demander la masse du réactif (en g) }

 Write('Entrez la masse du réactif (en g) : ');

 ReadLn(masseReactif);

 
  { Demander la masse du produit théorique (en g) }

 Write('Entrez la masse du produit théorique (en g) : ');

 ReadLn(masseProduitTheo);

 
  { Demander la masse du produit réel (en g) }

 Write('Entrez la masse du produit réel (en g) : ');

 ReadLn(masseProduit);

 
  { Vérifier que les masses sont positives }

 If(masseReactif<=0)or(masseProduitTheo<=0)or(masseProduit<=0)Then

  Writeln('Erreur : toutes les masses doivent être des valeurs positives.')

 Else Begin

   { Calcul du rendement théorique et réel en pourcentage }

  RendementTheo:=MasseProduitTheo;

  RendementReel:=MasseProduit;

   { Calcul du rendement en pourcentage }

  Rendement:=(rendementReel/RendementTheo)*100;

   { Affichage des résultats }

  Writeln('Le rendement théorique de la réaction est : ',RendementTheo:0:2,' g');

  Writeln('Le rendement réel de la réaction est : ',RendementReel:0:2,' g');

  Writeln('Le rendement de la réaction est : ',Rendement:0:2, ' %');

 End;

 ReadLn;

END.

Le programme CalculRendement permet de déterminer le rendement d'une réaction chimique en pourcentage. Il commence par inclure l'unité Crt, étant utilisée pour gérer l'affichage à l'écran. Ensuite, plusieurs variables de type Real sont déclarées : masseReactif représente la masse du réactif, masseProduitTheo est la masse du produit obtenue théoriquement, et masseProduit est la masse du produit obtenue réellement lors de l'expérience. D'autres variables, rendementTheo, rendementReel et rendement, sont utilisées pour entreposer respectivement la masse du produit théorique, la masse du produit réel et le rendement en pourcentage. Ce programme repose sur la relation fondamentale en chimie selon laquelle le rendement d'une réaction est calculé en comparant la masse du produit réellement obtenu à la masse attendue théoriquement.

Après avoir effacé l'écran avec ClrScr, le programme invite l'utilisateur à entrer successivement la masse du réactif, la masse du produit théorique et la masse du produit réel à l'aide de Write et ReadLn. Une vérification est ensuite effectuée pour s'assurer que toutes les valeurs saisies sont strictement positives. Si l'une des masses est inférieure ou égale à zéro, un message d'erreur s'affiche avec Writeln('Erreur : toutes les masses doivent être des valeurs positives.'), et le calcul du rendement est annulé. Cette vérification est essentielle pour éviter des erreurs mathématiques et garantir un résultat cohérent, car une masse négative ou nulle n'a pas de sens en chimie. L'utilisateur doit donc fournir des valeurs valides pour que le programme poursuive son exécution.

Si les valeurs saisies sont correctes, le programme calcule d'abord les rendements théorique et réel en utilisant directement masseProduitTheo et masseProduit. Ensuite, le rendement est déterminé à l'aide de la formule (rendementReel / rendementTheo) * 100, exprimant ainsi le pourcentage de produit réellement obtenu par rapport à la quantité attendue. Les résultats sont ensuite affichés avec Writeln, indiquant successivement la masse théorique, la masse réelle et le rendement final en pourcentage avec deux décimales pour plus de précision. Enfin, l'instruction ReadLn est utilisée pour suspendre l'exécution et attendre une interaction avant la fermeture du programme. Ce programme constitue un outil utile en chimie expérimentale pour évaluer l'efficacité d'une réaction chimique en laboratoire.

Conversion d'unités de pression

Ce programme permet de convertir différentes unités de pression comme les pascals (Pa), les atmosphères (atm) et les millimètres de mercure (mmHg).


	

Program ConversionPression;

 
Uses crt;

 
Const

 PascalToAtm = 1.0 / 101325;     { Conversion de Pascal en atmosphères (1 atm = 101325 Pa) }

 PascalToMmHg = 1.0 / 133.322;   { Conversion de Pascal en mmHg (1 mmHg = 133.322 Pa) }

 AtmToPascal = 101325;           { Conversion d'atmosphères en Pascal }

 AtmToMmHg = 760;                { Conversion d'atmosphères en mmHg }

 MmHgToPascal = 133.322;         { Conversion de mmHg en Pascal }

 MmHgToAtm = 1.0 / 760;          { Conversion de mmHg en atmosphères }

 
Var

 valeur:Real;

 uniteSource,uniteDest:Integer;

 
BEGIN

 ClrScr;

 Writeln('Conversion d''unités de pression');

 Writeln('1. Pascal (Pa)');

 Writeln('2. Atmosphères (atm)');

 Writeln('3. Millimètres de mercure (mmHg)');

  

  { Demander à l'utilisateur de saisir l'unité source }

 Write('Entrez l''unité de départ (1 = Pa, 2 = atm, 3 = mmHg) : ');

 ReadLn(uniteSource);

 
  { Demander à l'utilisateur de saisir la valeur }

 Write('Entrez la valeur de la pression à convertir : ');

 ReadLn(valeur);

  

  { Demander à l'utilisateur de saisir l'unité de destination }

 Write('Entrez l''unité de destination (1 = Pa, 2 = atm, 3 = mmHg) : ');

 ReadLn(uniteDest);

  

  { Conversion selon les choix de l''utilisateur }

 Case uniteSource of

  1:Begin { Source est Pascal }

   Case uniteDest of

    1:Writeln('La pression est : ', valeur:0:2, ' Pa');

    2:Writeln('La pression est : ', valeur * PascalToAtm:0:4, ' atm');

    3:Writeln('La pression est : ', valeur * PascalToMmHg:0:4, ' mmHg');

    Else Writeln('Unité de destination invalide');

   End;

  End;

  2:Begin { Source est Atmosphères }

   Case uniteDest of

    1: writeln('La pression est : ', valeur * AtmToPascal:0:2, ' Pa');

    2: writeln('La pression est : ', valeur:0:2, ' atm');

    3: writeln('La pression est : ', valeur * AtmToMmHg:0:2, ' mmHg');

    Else Writeln('Unité de destination invalide');

   End;

  End;

  3:Begin { Source est mmHg }

   Case uniteDest of

    1: Writeln('La pression est : ', valeur * MmHgToPascal:0:2, ' Pa');

    2: Writeln('La pression est : ', valeur * MmHgToAtm:0:4, ' atm');

    3: Writeln('La pression est : ', valeur:0:2, ' mmHg');

    Else Writeln('Unité de destination invalide');

   End;

  End;

  Else Writeln('Unité source invalide');

 End;

 ReadLn;

END.

Le programme ConversionPression est conçu pour convertir une pression exprimée en Pascal (Pa), atmosphères (atm) ou millimètres de mercure (mmHg) d'une unité à une autre. Il commence par inclure l'unité Crt pour gérer l'affichage, puis définit plusieurs constantes pour les facteurs de conversion entre ces unités. Par exemple, PascalToAtm est défini comme 1/101325, ce qui correspond à la conversion de Pascal en atmosphères. De même, MmHgToPascal est défini comme 133.322, représentant la conversion de mmHg en Pascal. Ces constantes permettent d'effectuer les calculs de conversion de manière précise sans avoir à répéter les valeurs dans le code. Ensuite, trois variables sont déclarées : valeur, entreposant la pression à convertir, et uniteSource et uniteDest, qui identifient les unités source et destination sélectionnées par l'utilisateur.

Le programme commence par effacer l'écran avec ClrScr puis affiche un menu avec les trois unités de pression disponibles. L'utilisateur est invité à saisir l'unité source parmi 1 (Pa), 2 (atm) ou 3 (mmHg) à l'aide de ReadLn. Ensuite, la pression à convertir est demandée, suivie du choix de l'unité de destination. Une structure Case est utilisée pour traiter les conversions. Si l'unité source est Pa, le programme effectue la conversion vers atm et mmHg en multipliant la valeur par les facteurs PascalToAtm et PascalToMmHg, respectivement. Une conversion vers la même unité n'altère pas la valeur, et un message d'erreur est affiché si l'utilisateur entre un choix invalide. Cette approche garantit une conversion simple et rapide entre les différentes unités de pression.

De la même manière, si l'unité source est atm, la pression est convertie en Pa et mmHg en multipliant respectivement par AtmToPascal et AtmToMmHg. Pour une pression initialement exprimée en mmHg, la conversion en Pa et atm est effectuée à l'aide des constantes MmHgToPascal et MmHgToAtm. Dans chaque cas, si l'utilisateur sélectionne une unité de destination incorrecte, un message d'erreur est affiché. Enfin, une instruction ReadLn est placée à la fin pour attendre une interaction avant la fermeture du programme. Ce programme est utile dans divers domaines scientifiques et techniques nécessitant des conversions précises de pression, comme la physique, la chimie ou l'ingénierie.

Équilibre chimique

Ce programme permet de résoudre des équilibres chimiques à l'aide des constantes d'équilibre et des concentrations des réactifs et produits :



Program EquilibreChimique;

 
Uses crt;

 
Var

 A, B, C, D, Kc: real;

 _a, _b, _c, _d: integer;

 x, delta, denominateur: real;

 
BEGIN

 ClrScr;

 WriteLn('=== Résolution d''un équilibre chimique ===');

 
  { Saisie des coefficients de la réaction }

 Write('Coefficient de A (_a) : ');

 ReadLn(_a);

 Write('Coefficient de B (_b) : ');

 ReadLn(_b);

 Write('Coefficient de C (_c) : ');

 ReadLn(_c);

 Write('Coefficient de D (_d) : ');

 ReadLn(_d);

 
  { Saisie des concentrations initiales }

 Write('Concentration initiale de A (mol/L) : ');

 ReadLn(A);

 Write('Concentration initiale de B (mol/L) : ');

 ReadLn(B);

 Write('Concentration initiale de C (mol/L) : ');

 ReadLn(C);

 Write('Concentration initiale de D (mol/L) : ');

 ReadLn(D);

 
  { Saisie de la constante d'équilibre Kc }

 Write('Constante d''équilibre Kc : ');

 ReadLn(Kc);

 
  { Calcul de la variation x basée sur l'équation d'équilibre }

  { Kc = ( [C]eq^c * [D]eq^d ) / ( [A]eq^a * [B]eq^b ) }

 
 Denominateur:=(_a+_b)*(_c+_d);

 If Denominateur = 0 Then Begin

  WriteLn('Erreur : Les coefficients stochiométriques ne peuvent pas être nuls.');

  Halt;

 End;

 
  { Approximation avec une variation x }

 Delta:=Sqrt((A * B) / (C * D));

 x:=Delta/Denominateur;

 
  { Mise à jour des concentrations à l'équilibre }

 A:=A-_a*x;

 B:=B-_b*x;

 C:=C+_c*x;

 D:=D+_d*x;

 
  { Affichage des résultats }

 WriteLn;

 WriteLn('=== Concentrations à l''équilibre ===');

 WriteLn('Concentration de A : ', A:0:4, ' mol/L');

 WriteLn('Concentration de B : ', B:0:4, ' mol/L');

 WriteLn('Concentration de C : ', C:0:4, ' mol/L');

 WriteLn('Concentration de D : ', D:0:4, ' mol/L');

 
 ReadLn;

END.

Ce programme en Pascal, nommé EquilibreChimique, permet de résoudre un équilibre chimique en calculant les concentrations des réactifs et des produits à l'équilibre. Il commence par demander à l'utilisateur de saisir les coefficients stochiométriques de la réaction chimique sous la forme _aA+_bB⇌_cC+_dD. Ensuite, il invite l'utilisateur à entrer les concentrations initiales de chaque espèce chimique impliquée ainsi que la constante d'équilibre K_c?, étant utilisée pour déterminer l'évolution du système vers l'équilibre. L'affichage clair et structuré du programme facilite la saisie des données par l'utilisateur.

Une fois les données saisies, le programme vérifie que la somme des coefficients stochiométriques des réactifs et des produits n'est pas nulle afin d'éviter une division par zéro. Il calcule ensuite une approximation de la variation x en se basant sur une relation approchée de la constante d'équilibre. La valeur de x correspond à la quantité de matière transformée pendant la réaction. Les nouvelles concentrations des espèces chimiques sont mises à jour en fonction de cette variation, en soustrayant x aux réactifs et en l'ajoutant aux produits, conformément aux coefficients stochiométriques de la réaction.

Enfin, le programme affiche les concentrations des réactifs et des produits après établissement de l'équilibre chimique. Ces résultats permettent d'évaluer l'évolution du système chimique et de vérifier si la constante d'équilibre saisie est respectée. Cependant, l'approximation utilisée pour x peut ne pas toujours être précise, notamment pour des systèmes où l'équilibre est fortement déplacé dans un sens ou dans l'autre. Une amélioration possible du programme serait l'utilisation d'une résolution plus rigoureuse, par exemple en résolvant numériquement l'équation du second degré qui découle de la loi d'action de masse.

Calcul du nombre d'Avogadro

Ce programme peut être utilisé pour déterminer le nombre d'atomes ou de molécules dans une quantité donnée de substance :



Program CalculAvogadro;

 
Uses crt;

 
Const

 Avogadro = 6.022e23; { Nombre d'Avogadro en atomes/molécules par mole }

 
Var

 masseSubstance, masseMolaire, nombreEntites:Real;

 moles: Real;

 
BEGIN

 ClrScr;

 WriteLn('=== Calcul du nombre d''Avogadro ===');

  

  { Demande de la masse de la substance en grammes }

 Write('Entrez la masse de la substance (en g) : ');

 ReadLn(masseSubstance);

  

  { Demande de la masse molaire de la substance en g/mol }

 Write('Entrez la masse molaire de la substance (en g/mol) : ');

 ReadLn(masseMolaire);

  

  { Calcul du nombre de moles }

 moles := masseSubstance / masseMolaire;

  

  { Calcul du nombre d''entités (atomes ou molécules) }

 nombreEntites := moles * Avogadro;

  

  { Affichage du résultat }

 WriteLn('Le nombre d''entités (atomes/molécules) dans ', masseSubstance:0:2, ' g de la substance est : ', nombreEntites:0:2);

 ReadLn;

END.

Le programme CalculAvogadro permet de calculer le nombre d'atomes ou de molécules dans une quantité donnée de substance, en se basant sur la loi d'Avogadro. Le programme commence par déclarer la constante Avogadro, représentant le nombre d'atomes ou de molécules présents dans une mole de matière. Cette constante est essentielle pour le calcul du nombre total d'entités dans une quantité de matière donnée, et sa valeur est approximativement 6,022×10236,022×1023. Ensuite, le programme demande à l'utilisateur de saisir deux informations cruciales : la masse de la substance en grammes et la masse molaire en grammes par mole. Ces données sont utilisées pour calculer le nombre de moles, une unité de mesure de la quantité de matière.

Une fois les entrées effectuées, le programme effectue un calcul simple pour obtenir le nombre de moles à partir de la formule moles=masse / masse molaire. Ce calcul permet de savoir combien de moles de la substance sont présentes dans la masse spécifiée. Le programme continue en multipliant le nombre de moles par le nombre d'Avogadro pour obtenir le nombre total d'atomes ou de molécules. Ce calcul repose sur l'idée que chaque mole d'une substance contient exactement 6.022×10236.022×1023 entités élémentaires, qu'il s'agisse d'atomes ou de molécules, en fonction de la substance étudiée.

Enfin, une fois les calculs réalisés, le programme affiche le résultat sous forme de texte lisible par l'utilisateur. Le nombre d'entités dans la masse donnée de la substance est montré à l'écran, avec une précision de deux chiffres après la virgule. Ce programme peut être utilisé pour diverses applications, notamment en chimie, pour déterminer le nombre de molécules dans une quantité précise de substance. Il est simple, mais extrêmement utile pour les étudiants ou les chercheurs travaillant avec des quantités de matière et des relations chimiques basées sur le nombre d'Avogadro.

Calcul des équivalents d'un acide ou d'une base

Ce programme calcule les équivalents d'un acide ou d'une base dans une réaction acido-basique en fonction de sa concentration et de son volume :



Program CalculEquivalentsAcideBase;

 
Uses crt;

 
Var

 concentration: Real;   { Concentration de l'acide ou de la base en mol/L }

 volume: Real;          { Volume de la solution en litres }

 equivalents: Real;     { Nombre d'équivalents calculé }

 typeSolution: Integer; { Type de solution (1 pour acide, 2 pour base) }

 
BEGIN

 ClrScr;

 
  { Afficher les instructions à l'utilisateur }

 WriteLn('=== Calcul des équivalents d''un acide ou d''une base ===');

 WriteLn('1. Acide');

 WriteLn('2. Base');

  

  { Demander à l'utilisateur de choisir entre un acide ou une base }

 Write('Entrez le type de solution (1 pour acide, 2 pour base) : ');

 ReadLn(typeSolution);

 
  { Demander à l'utilisateur de saisir la concentration de la solution }

 Write('Entrez la concentration de la solution (en mol/L) : ');

 ReadLn(concentration);

  

  { Demander à l'utilisateur de saisir le volume de la solution }

 Write('Entrez le volume de la solution (en litres) : ');

 ReadLn(volume);

 
  { Calcul des équivalents en fonction de la concentration et du volume }

  { Les équivalents sont simplement le produit de la concentration et du volume pour les acides et bases. }

 equivalents := concentration * volume;

 
  { Afficher les résultats en fonction du type de solution }

 If(typeSolution = 1)Then WriteLn('Le nombre d''équivalents d''acide est : ', equivalents:0:4) Else 

 If(typeSolution = 2)Then WriteLn('Le nombre d''équivalents de base est : ', equivalents:0:4)

                     Else WriteLn('Erreur : type de solution invalide');

 ReadLn;

END.

Le programme commence par déclarer les variables nécessaires pour effectuer le calcul. Tout d'abord, il déclare les variables concentration, volume et equivalents pour contenir respectivement la concentration de la solution en mol/L, le volume de la solution en litres, et le nombre d'équivalents calculé. La variable typeSolution est également déclarée pour permettre à l'utilisateur de choisir entre une solution acide ou une solution basique. Cela permet au programme de différencier les deux types de substances et de calculer correctement le nombre d'équivalents en fonction de cette information.

Après la déclaration des variables, le programme affiche des instructions à l'utilisateur, lui demandant de choisir entre un acide ou une base, et de fournir la concentration de la solution en mol/L ainsi que le volume en litres. Ces informations sont ensuite saisies par l'utilisateur à l'aide de la fonction ReadLn. Une fois ces valeurs récupérées, le programme passe à la phase de calcul. Le calcul du nombre d'équivalents est simple : il suffit de multiplier la concentration par le volume. Le résultat est entreposé dans la variable equivalents, étant ensuite utilisée pour afficher le résultat final.

Enfin, le programme affiche le nombre d'équivalents calculé. Si l'utilisateur a sélectionné un acide, le programme affiche le nombre d'équivalents d'acide, et si l'utilisateur a choisi une base, le programme affiche le nombre d'équivalents de base. Si l'utilisateur entre une valeur invalide pour le type de solution, un message d'erreur est affiché pour signaler l'invalidité de l'entrée. Le programme se termine après avoir affiché le résultat ou un message d'erreur, et il attend une action de l'utilisateur avant de se fermer. Ce programme est un outil simple mais efficace pour les calculs chimiques dans les réactions acido-basiques.

Balancement d'une équation chimique

Ce programme permet de balancer automatiquement une équation chimique en ajustant les coefficients des réactifs et produits :



Program BalancerEquationChimique;

 
Uses crt;

 
Var

 a, b, c, d: Integer;  { Coefficients des réactifs et produits }

 H, O, N: Integer;     { Atomes de chaque élément (hydrogène, oxygène, azote) }

 facteur: Integer;      { Facteur de multiplication pour balancer l'équation }

 
BEGIN

 ClrScr;

 WriteLn('=== Balancement d''une équation chimique ===');

 
  { Demander les coefficients des réactifs et produits }

 Write('Entrez le coefficient pour H2 + O2 -> H2O : ');

 ReadLn(a);   { Coefficient de H2 }

 ReadLn(b);   { Coefficient de O2 }

 ReadLn(c);   { Coefficient de H2O }

  

  { Calcul des atomes pour chaque élément de la réaction }

 H := 2 * a + 2 * c;  { Total des atomes de H : 2 par H2 et 2 par H2O }

 O := 2 * b + 1 * c;  { Total des atomes de O : 2 par O2 et 1 par H2O }

  

 { Affichage des résultats avant le balancement }

 WriteLn('Atomes de H avant le balancement : ', H);

 WriteLn('Atomes de O avant le balancement : ', O);

 
 { Balancer l'équation en ajustant les coefficients pour égaliser les atomes }

 WriteLn('=== Balancement ===');

 WriteLn('Equation avant le balancement : ');

 WriteLn('H2 + O2 -> H2O');

 
  { Réajuster les coefficients selon les besoins (exemple ici avec un facteur) }

 facteur := O div 2;

 a := facteur;         { Coefficients ajustés }

 b := facteur;

 c := facteur * 2;

  

  { Affichage du résultat final du balancement }

 WriteLn('Equation balancee : ');

 WriteLn(a, ' H2 + ', b, ' O2 -> ', c, ' H2O');

  

 ReadLn;

END.

Le programme commence par initialiser les coefficients des réactifs et des produits dans la réaction chimique H2 + O2 -> H2O. L'utilisateur entre les coefficients des réactifs et des produits. Ensuite, le programme calcule le nombre total d'atomes pour chaque élément, dans ce cas les atomes d'hydrogène (H) et d'oxygène (O), avant de procéder à l'ajustement des coefficients.

L'algorithme fonctionne en ajustant les coefficients pour garantir que les quantités d'atomes de chaque élément soient égales des deux côtés de l'équation. Ce balancement est effectué en utilisant un facteur de multiplication qui ajuste le nombre de molécules de chaque réactif et produit afin que le nombre d'atomes de chaque élément soit équilibré.

Une fois l'équation correctement balancée, le programme affiche les coefficients finaux de l'équation chimique. L'utilisateur peut alors voir l'équation équilibrée et vérifier que la conservation des atomes est respectée. C'est un programme relativement simple pour un cas particulier, mais le balancement d'équations chimiques plus complexes nécessiterait des méthodes plus avancées comme la résolution de systèmes d'équations linéaires.

Calcul de la densité d'un liquide

Ce programme calcule la densité d'un liquide à partir de sa masse et de son volume :



Program CalculDensiteLiquide;

 
Uses Crt;

 
Var

 masse,volume,densite:Real;  { Variables pour la masse, le volume et la densité }

 
BEGIN

 ClrScr;

 WriteLn('=== Calcul de la densité d''un liquide ===');

 
  { Demande de la masse du liquide en kilogrammes }

 Write('Entrez la masse du liquide (en kilogrammes) : ');

 ReadLn(masse);

  

  { Demande du volume du liquide en litres }

 Write('Entrez le volume du liquide (en litres) : ');

 ReadLn(volume);

 
  { Calcul de la densité }

 densite := masse / volume;

 
  { Affichage du résultat }

 WriteLn('La densité du liquide est : ', densite:0:2, ' kg/L');

 ReadLn;

END.

Le programme commence par initialiser deux variables, masse et volume, étant utilisées pour entreposer respectivement la masse du liquide et son volume. Ensuite, il demande à l'utilisateur d'entrer la masse (en kilogrammes) et le volume (en litres) du liquide. Ces valeurs sont saisies via les fonctions ReadLn.

Le calcul de la densité est effectué en divisant la masse par le volume. Le résultat de cette opération est entreposé dans la variable densite.

Enfin, le programme affiche la densité du liquide, arrondie à deux décimales à l'aide du format :0:2. L'utilisateur peut ensuite voir la densité calculée en kg/L (kilogrammes par litre). Le programme se termine après un ReadLn pour permettre à l'utilisateur de voir le résultat avant de fermer la fenêtre.

Ce programme est simple et permet de comprendre facilement le calcul de la densité d'un liquide à partir de ses deux principales caractéristiques : la masse et le volume.

Calcul du pourcentage massique d'un élément dans un composé

Ce programme calcule le pourcentage massique d'un élément dans un composé chimique à partir de sa formule chimique :



Program PourcentageMassiqueElement;

 
Uses crt;

 
Var

 masseMolaireElement, masseMolaireCompose, pourcentage:Real;

 formuleElement: String;

 
BEGIN

 ClrScr;

 WriteLn('=== Calcul du pourcentage massique d''un element dans un compose ===');

  

  { Demande de la masse molaire de l''élément (en g/mol) }

 Write('Entrez la masse molaire de l''élément (en g/mol) : ');

 ReadLn(masseMolaireElement);

  

  { Demande de la masse molaire du composé (en g/mol) }

 Write('Entrez la masse molaire du compose (en g/mol) : ');

 ReadLn(masseMolaireCompose);

  

  { Calcul du pourcentage massique de l''élément dans le composé }

 pourcentage := (masseMolaireElement / masseMolaireCompose) * 100;

 
  { Affichage du résultat }

 WriteLn('Le pourcentage massique de l''élément dans le compose est : ', pourcentage:0:2, ' %');

  

 ReadLn;

END.

Le programme Turbo Pascal que nous avons écrit permet de calculer le pourcentage massique d'un élément dans un composé chimique. Le programme commence par demander à l'utilisateur de saisir la masse molaire de l'élément et du composé chimique. Ces valeurs sont ensuite stockées dans les variables masseMolaireElement et masseMolaireCompose. La masse molaire d'un composé est la somme des masses molaires des éléments le composant, ce qui permet de calculer précisément la proportion de chaque élément dans le tout. L'utilisateur fournit ces informations via les procédures Write et ReadLn.

Une fois que les valeurs sont saisies, le programme effectue un calcul simple pour obtenir le pourcentage massique de l'élément dans le composé. La formule utilisée est :

Pourcentage massique=(Masse molaire de l'élément/Masse molaire du composé)×100

Le calcul repose sur la division de la masse molaire de l'élément par celle du composé, multipliée ensuite par 100 pour obtenir un pourcentage. Le résultat est entreposé dans la variable pourcentage et affiché à l'utilisateur sous forme d'un nombre à deux décimales, permettant ainsi de connaître précisément la proportion de l'élément dans le composé. Ce calcul est essentiel dans des domaines tels que la chimie analytique pour déterminer la composition d'une substance.

Enfin, après avoir effectué le calcul, le programme affiche le résultat sous la forme d'un pourcentage à l'aide de la procédure WriteLn. L'utilisateur peut alors voir immédiatement quel est le pourcentage massique de l'élément dans le composé chimique. Le programme se termine par une instruction ReadLn pour permettre à l'utilisateur de voir le résultat avant de fermer la fenêtre du programme. Ce type de calcul est utile pour diverses applications en chimie, notamment pour analyser des réactions chimiques, déterminer les concentrations dans des solutions ou encore pour la formulation de nouveaux composés chimiques.

Calcul du volume de gaz dans les conditions STP

Un programme pour calculer le volume d'un gaz dans les conditions standard de température et de pression (STP) :



Program VolumeGazSTP;

 
Uses crt;

 
Const

 R = 0.0821;      { Constante des gaz parfaits en L·atm/(mol·K) }

 T_STP = 273.15;  { Température STP en K }

 P_STP = 1;       { Pression STP en atmosphères (atm) }

 
Var

 n:Real;          { Nombre de moles }

 volume:Real;     { Volume du gaz en litres }

 
BEGIN

 ClrScr;

 
  { Affichage des conditions STP }

 WriteLn('=== Calcul du volume d''un gaz dans les conditions STP ===');

 WriteLn('Conditions standard :');

 WriteLn(' - Température : 0°C (273.15 K)');

 WriteLn(' - Pression : 1 atm');

  

  { Demander à l'utilisateur d'entrer le nombre de moles }

 Write('Entrez le nombre de moles de gaz : ');

 ReadLn(n);

  

  { Calcul du volume selon la loi des gaz parfaits : PV = nRT }

 volume:=(n * R * T_STP) / P_STP;

  

  { Affichage du volume en litres }

 WriteLn('Le volume du gaz dans les conditions STP est : ', volume:0:2, ' litres');

  

 ReadLn;

END.

Le programme commence par afficher les conditions standard de température et de pression (STP) : 0°C (273,15 K) et 1 atmosphère (1 atm). Ces informations sont affichées à l'utilisateur pour l'informer des conditions dans lesquelles le calcul sera effectué.

Ensuite, le programme demande à l'utilisateur de saisir le nombre de moles de gaz qu'il souhaite analyser. Le nombre de moles est une quantité fondamentale dans les calculs de gaz, et il est utilisé pour déterminer le volume dans des conditions normales.

Le calcul du volume est effectué en utilisant la loi des gaz parfaits :

PV=nRT

où P est la pression (1 atm), V est le volume que nous cherchons à calculer, n est le nombre de moles, R est la constante des gaz parfaits, et TT est la température en kelvins (273,15 K pour STP). La formule du volume est donc :

V=nRT/P

Enfin, le programme affiche le volume en litres, avec deux chiffres après la virgule pour plus de précision. L'utilisateur peut voir immédiatement combien de litres de gaz sont présents dans les conditions STP en fonction de la quantité de moles donnée.

Calcul de la solubilité d'un sel

Un programme pour calculer la solubilité d'un sel en fonction de sa constante de solubilité :



Program SolubiliteSel;

 
Uses Crt;

 
Var

 Kps, solubilite:Real;

 n, m: Integer;

 
BEGIN

 ClrScr;

  

  { Introduction du programme }

 WriteLn('=== Calcul de la solubilité d''un sel ===');

  

  { Demander à l'utilisateur de saisir la constante de solubilité (Kps) }

 Write('Entrez la constante de solubilité Kps du sel : ');

 ReadLn(Kps);

  

  { Demander à l'utilisateur de saisir le nombre d''ions dissous (n) et leur concentration (m) }

 Write('Entrez le nombre d''ions dissous (n) : ');

 ReadLn(n);

 Write('Entrez la concentration des ions dissous (m) : ');

 ReadLn(m);

  

  { Calcul de la solubilité en fonction de Kps, n et m }

 solubilite := Kps / (n * m);

  

  { Affichage du résultat }

 WriteLn('La solubilité du sel dans l''eau est : ', solubilite:0:4, ' mol/L');

  

 ReadLn;

END.

Ce programme commence par afficher une introduction pour informer l'utilisateur qu'il calcule la solubilité d'un sel. Le programme repose sur la constante de solubilité (Kps), dépendant du sel en question. La constante de solubilité représente la capacité du sel à se dissoudre dans l'eau et à se dissocier en ions.

L'utilisateur est invité à entrer la valeur de Kps, ainsi que le nombre d'ions dissous (n) et la concentration des ions dissous (m). Ces valeurs permettent de calculer la solubilité du sel.

Le programme utilise une formule simplifiée pour la solubilité du sel. Il divise la constante de solubilité par le produit des ions dissous et de leur concentration afin de calculer la solubilité dans l'eau, en mol/L. Enfin, il affiche la solubilité calculée avec une précision de quatre chiffres après la virgule pour donner un résultat précis à l'utilisateur.

Calcul de la chaleur dégagée ou absorbée dans une réaction chimique

Ce programme calcule la chaleur échangée au cours d'une réaction chimique en utilisant l'enthalpie de réaction :



Program ChaleurReactionChimique;

 
Uses crt;

 
Var

 deltaH, n, chaleur:Real;

 
BEGIN

 ClrScr;

 
  { Introduction du programme }

 WriteLn('=== Calcul de la chaleur dégagée ou absorbée lors d''une réaction chimique ===');

 
  { Demander à l'utilisateur de saisir l'enthalpie de réaction (delta H) }

 Write('Entrez l''enthalpie de réaction delta H (en joules par mole) : ');

 ReadLn(deltaH);

 
  { Demander à l'utilisateur de saisir le nombre de moles n }

 Write('Entrez le nombre de moles de réactif ou produit (n) : ');

 ReadLn(n);

 
  { Calcul de la chaleur échangée }

 chaleur := n * deltaH;

 
  { Affichage du résultat }

 WriteLn('La chaleur échangée lors de la réaction est : ', chaleur:0:4, ' joules');

 
 ReadLn;

END.

Le programme commence par afficher un message d'introduction pour indiquer à l'utilisateur qu'il va calculer la chaleur échangée lors d'une réaction chimique. L'utilisateur doit entrer deux informations principales : l'enthalpie de réaction (ΔH) et le nombre de moles (n) de réactif ou produit impliqué dans la réaction chimique.

Ensuite, le programme calcule la chaleur échangée en multipliant l'enthalpie de réaction par le nombre de moles. Le résultat est affiché avec une précision de quatre décimales pour donner la valeur de la chaleur échangée en joules.

Si l'enthalpie est négative, cela signifie que la réaction est exothermique (chaleur dégagée), tandis que si l'enthalpie est positive, la réaction est endothermique (chaleur absorbée).

Calcul de la vitesse d'une réaction chimique

Ce programme permet de calculer la vitesse d'une réaction chimique en fonction de la concentration des réactifs et des produits :



Program VitesseReactionChimique;

 
Uses crt;

 
Var

 k, concentrationA, concentrationB, vitesse:Real;

 m, n, i: Integer;

 
{ Fonction pour calculer la puissance }

Function Puissance(base: Real; exponent: Integer): Real;

Var

 Result:Real;

 i:Integer;

Begin

 Result:=1;

 For i:=1 to exponent do Result:=Result*Base;

 Puissance:=Result;

End;

 
BEGIN

 ClrScr;

 
  { Introduction du programme }

 WriteLn('=== Calcul de la vitesse d''une réaction chimique ===');

 
  { Demander à l'utilisateur de saisir la constante de vitesse k }

 Write('Entrez la constante de vitesse k : ');

 ReadLn(k);

 
  { Demander à l'utilisateur de saisir les concentrations des réactifs }

 Write('Entrez la concentration de A (mol/L) : ');

 ReadLn(concentrationA);

 
 Write('Entrez la concentration de B (mol/L) : ');

 ReadLn(concentrationB);

 
  { Demander à l'utilisateur de saisir les ordres de réaction pour A et B }

 Write('Entrez l''ordre de réaction pour A (m) : ');

 ReadLn(m);

 
 Write('Entrez l''ordre de réaction pour B (n) : ');

 ReadLn(n);

 
  { Calcul de la vitesse de réaction }

 vitesse := k * Puissance(concentrationA, m) * Puissance(concentrationB, n);

 
  { Affichage du résultat }

 WriteLn('La vitesse de la réaction est : ', vitesse:0:4, ' mol/L·s');

 ReadLn;

END.

Le programme proposé calcule la vitesse d'une réaction chimique en fonction des concentrations des réactifs et de la constante de vitesse. En chimie, la vitesse d'une réaction est souvent décrite par l'expression v=k[A]^m[B]ⁿ, où A et B sont les concentrations des réactifs, k est la constante de vitesse, et m et n sont les ordres de réaction pour chaque réactif. Dans ce programme, l'utilisateur entre ces valeurs, et la vitesse est calculée à partir de cette formule. Les ordres de réaction et les concentrations sont nécessaires pour estimer la vitesse de la réaction.

L'une des particularités de ce programme est qu'il inclut une fonction personnalisée pour calculer la puissance. En Turbo Pascal, la fonction Power n'est pas disponible, donc la fonction Puissance a été créée pour permettre d'élever un nombre à une puissance entière. Cette fonction utilise une boucle For pour multiplier la base plusieurs fois, en fonction de l'exposant. Cette approche garantit que les puissances des concentrations des réactifs peuvent être calculées, un élément essentiel pour la détermination de la vitesse de réaction.

Enfin, après avoir effectué tous les calculs nécessaires, le programme affiche la vitesse de la réaction dans un format clair. L'utilisateur peut entrer différentes valeurs pour la constante de vitesse, les concentrations et les ordres de réaction, permettant une flexibilité dans les simulations. Le résultat est présenté avec une précision de quatre chiffres après la virgule. Cette approche donne une idée précise de la vitesse de réaction dans les conditions expérimentales spécifiées, ce qui est essentiel pour les chimistes et les ingénieurs travaillant sur des processus chimiques.

PARTAGER CETTE PAGE SUR

Dernière mise à jour : Lundi, le 3 février 2025

	ABAP/4
	Ada
	Assembleur
	Assembly & bytecode
	ASP (Active Server Pages)
	Basic
	C
	C++
	C# (C Sharp)
	Cobol
	ColdFusion
	Fortran
	HTML
	Java
	JavaScript
	LISP
	Logo
	LotusScript
	Oberon
	Pascal
	Perl
	PHP
	PL/1
	Prolog
	Python
	Rebol
	REXX
	Ruby
	SAS
	NoSQL
	SQL
	Swift
	X++ (Axapta)

	Assembleur 370
	Assembleur 1802
	Assembleur 4004
	Assembleur 6502
	Assembleur 6800
	Assembleur 68000
	Assembleur 8080 et 8085
	Assembleur 8089
	Assembleur 80x86
	Assembleur AGC4
	Assembleur ARM
	Assembleur DPS 8000
	Assembleur i860
	Assembleur Itanium
	Assembleur MIPS
	Assembleur PDP-11
	Assembleur PowerPC
	Assembleur RISC-V
	Assembleur SPARC
	Assembleur SuperH
	Assembleur UNIVAC I
	Assembleur VAX
	Assembleur Z80
	Assembleur Z8000
	Assembleur z/Architecture

	CIL
	Jasmin
	LLVM
	MSIL
	Parrot
	P-Code (PCode)
	SWEET16

	ASP 1.0
	ASP 2.0
	ASP 3.0
	ASP.NET

	ABasiC (Amiga)
	Adam SmartBASIC
	Altair BASIC
	AmigaBASIC (Amiga)
	AMOS Basic (Amiga)
	Atari Basic (Atari 400, 600 XL, 800, 800XL)
	Basic Apple II (Integer BASIC/APPLESOFT)
	Basic Commodore 64 (CBM-BASIC)
	Basic Commodore 128 (BASIC 7.0)
	Basic Commodore VIC-20 (CBM-BASIC 2.0)
	Basic Coco 1 (Color Basic)
	Basic Coco 2 (Extended Color Basic)
	Basic Coco 3 (Extended Color Basic 2.0)
	BASICA (PC DOS)
	Basic Pro
	BBC BASIC
	Blitz BASIC (Amiga)
	DarkBASIC
	Dartmouth BASIC
	GFA-Basic (Atari ST/Amiga)
	GWBASIC (MS-DOS)
	Liberty BASIC
	Locomotive BASIC (Amstrad CPC)
	MSX-Basic
	Omikron Basic (Atari ST)
	Oric Extended Basic
	Power Basic
	Quick Basic/QBasic (MS-DOS)
	Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
	ST BASIC (Atari ST)
	Turbo Basic
	Vintage BASIC
	VBScript
	Visual Basic (VB)
	Visual Basic .NET (VB .NET)
	Visual Basic pour DOS
	Yabasic

Section courante

A propos

Section administrative du site