Programmation de processus informatiques cycliques de traitement de données. Programmation de processus de calcul cycliques. Exemple d'utilisation de l'instruction for
En programmation, il existe souvent des tâches qui nécessitent l'exécution multiple du même groupe d'instructions de programme avec différentes valeurs de leurs opérandes. De tels processus sont appelés cyclique ou simplement cycles. Un groupe d'instructions se répétant cycliquement forme ce que l'on appelle corps de boucle, qui peut être représenté par une expression simple ou composée. Une seule exécution du corps de la boucle sera appelée itération.
Le corps de la boucle dans le programme est toujours précédé de titre du cycle, contenant la notation opérateur de boucle et une expression spécifiant (directement ou indirectement) le nombre d'itérations. Notez que le corps du cycle est un opérande de l'opérateur de cycle, par conséquent, l'en-tête et le corps du cycle constituent une unité structurelle indivisible du programme. Ci-après, en utilisant le terme instruction de boucle", on retiendra à la fois le titre et le corps de la boucle.
Pour organiser les cycles dans tous les systèmes de programmation, il existe des instructions de boucle, dont l'utilisation évite au programmeur d'avoir à programmer les cycles "manuellement". MathCAD prend en charge deux types d'opérateurs de ce type : cycle avec prédestination Pour (aussi appelé boucle avec compteur) Et boucle avec précondition Alors que . La structure de ces opérateurs est décrite dans le tableau 5.
5.4.1 Opérateur Pour
Cet opérateur doit être utilisé dans les cas où le nombre d'itérations est prédéterminé, c'est-à-dire connu à l'avance.
En-tête de cycle de cet opérateur (l'opérande de droite) contient une variable appelée paramètre(ou compteur) cycle, Et liste de valeurs ce paramètre. Le nombre d'éléments de la liste détermine le nombre d'itérations - lors de chaque itération, le paramètre de boucle reçoit la valeur suivante de la liste spécifiée dans l'en-tête.
Paramètre de cycle a le statut d'une variable interne du programme et possède toutes ses propriétés (décrites au paragraphe 5.1.4). En règle générale, le paramètre de boucle est utilisé du côté droit des expressions qui font partie du corps de la boucle, bien qu'il ne soit pas formellement interdit de l'utiliser du côté gauche des expressions (c'est-à-dire à gauche du paramètre local opérateur de définition "f"). Il convient de rappeler que si le paramètre a été modifié dans le corps de la boucle, sa valeur modifiée ne sera valide que jusqu'à la fin de l'itération en cours, car avant la prochaine itération, le paramètre recevra toujours la valeur suivante de la liste spécifiée dans le en-tête de boucle.
Formellement, il est permis de ne pas utiliser du tout le paramètre de boucle dans les expressions du corps de la boucle - dans ce cas, la liste des valeurs des paramètres ne joue aucun rôle - seule la longueur de cette liste est significative, ce qui détermine le nombre d'itérations (éventuellement sans signification).
À la fin de la dernière itération, l'instruction de programme suivant l'instruction de boucle sera exécutée. Dans ce cas, la variable utilisée comme paramètre de la boucle complétée conserve la valeur qu'elle avait dans le dernier effectivement terminé itérations[*]. Notez que cette valeur ne coïncide pas toujours avec la dernière valeur de la liste spécifiée dans l'en-tête de la boucle, car il est possible de sortir "précocement" de la boucle lorsque l'opérateur est déclenché Casser inclus dans le corps de la boucle.
Liste de valeurs le paramètre de la boucle est écrit dans l'en-tête de la boucle après le symbole " Î ", indiquant l'appartenance à un ensemble (ce symbole n'a pas besoin d'être saisi "manuellement" - il sera automatiquement affiché lors de la saisie de l'opérateur Pour ). MathCAD permet l'utilisation trois formes entrées dans cette liste : transfert direct– les éléments de la liste sont explicitement spécifiés séparés par des virgules, le paramètre reçoit les valeurs de la liste dans l'ordre dans lequel elles apparaissent ; dans le style d'une variable étendue − les éléments de la liste forment la suite arithmétique correspondante ; déployer– les éléments de la liste reçoivent séquentiellement les valeurs des éléments du tableau dans l'ordre de leurs indices (d'abord - colonnes de gauche à droite, puis - lignes de haut en bas).
Les trois programmes illustrés à la Figure 21 illustrent différentes utilisations de l'opérateur Pour .
Programme Fait(n) calcule la factorielle d'un nombre n . L'opérateur de boucle dans ce programme fait partie d'une expression composée, qui, à son tour, est l'opérande de l'opérateur conditionnel sinon. Paramètre de cycle k obtient des valeurs à partir d'une série arithmétique entière.
Programme Ch(V,N,p) traite le vecteur d'entrée V , en le remplaçant par la valeur p les éléments dont les indices sont donnés par les éléments du deuxième vecteur d'entrée N . Dans cet exemple, la liste des valeurs du paramètre de boucle je donnée par un ensemble d'éléments vectoriels N . Notez que ces deux programmes effectuent le contrôle des données d'entrée et bloquent l'exécution de l'algorithme principal si les arguments réels du programme sont spécifiés de manière incorrecte.
Programme L(M,z) , donné dans l'exemple V ), est accompagné de commentaires détaillés et ne nécessite pas d'explication. Ce programme illustre la possibilité d'utiliser plusieurs instructions de boucle, dont l'une est incluse dans les instructions corps un autre. Usage boucles imbriquées est une astuce typique utilisée pour traiter les tableaux multidimensionnels.
Figure 21 - Exemples de cycles de programmation Pour
La figure 22 illustre l'utilisation des opérateurs Casser Et Continuer dans le corps de la boucle. Typiquement, ces opérateurs sont eux-mêmes des opérandes. expressions conditionnelles Si ou sinon .
Opérateur Casser ("avorter") interrompt l'exécution de la boucle et transfère le contrôle à l'instruction suivant l'instruction de boucle interrompue. Notez que si l'opérateur Casser interrompu boucle imbriquée, l'exécution de la boucle externe se poursuivra.
Opérateur Continuer ("continuer") agit différemment - il interrompt uniquement l'itération actuelle de la boucle et transfère le contrôle à l'en-tête de ce cycle, après quoi l'exécution du cycle continueà partir de l'itération suivante (à moins, bien sûr, que l'itération interrompue soit la dernière).
Opérateur Casser autorisé à utiliser et dehors corps cyclables. Dans ce cas, l'exécution du sous-programme entier est interrompue et le résultat de l'évaluation de la dernière expression de sous-programme réellement exécutée est renvoyé.
Figure 22 - Exemples d'utilisation d'opérateurs Casser Et Continuer
Fonction SommeN(V) additionne uniquement les éléments du vecteur qui contiennent des données scalaires de type numérique et ignore le reste des éléments. Fonction Inverse(V) génère un vecteur dont les éléments sont les inverses des valeurs des éléments correspondants du vecteur d'origine. Dans ce cas, si l'élément suivant contient le nombre "0" ou n'est pas un scalaire de type numérique, le cycle est interrompu. A noter que l'opérateur Casser dans le dernier exemple, n'interrompt pas le programme, mais transfère le contrôle à l'opérateur retour immédiatement après l'opérateur Pour .
5.4.3 Opérateur Alors que
Contrairement à l'opérateur Pour , en-tête de déclaration Alors que (en traduction - " Au revoir") ne contient pas d'indications explicites du nombre d'itérations - il contient Expression booléenne, dont la valeur est automatiquement calculée avant le début exécution de chaque itération successive[†]. Tant que cette expression est "vraie", les itérations de la boucle continueront ; dès qu'après l'achèvement de la prochaine itération, l'expression devient "fausse", la prochaine itération de la boucle ne sera pas exécutée et le contrôle sera reçu par l'instruction de programme suivant l'instruction Alors que .
Évidemment, si une expression logique identiquement fausse est placée dans l'en-tête de la boucle, cette boucle n'effectuera aucune de ses itérations, et si cette expression est identiquement vraie, la boucle sera infinie (cette dernière situation est appelée boucle programmes). Afin d'éviter de telles situations, une ou plusieurs variables qui changent de valeur doivent être incluses dans le nombre d'opérandes d'une expression logique. dans le corps de la boucle de telle sorte que la boucle soit finie (d'autres moyens peuvent être utilisés pour empêcher le bouclage - par exemple, une sortie forcée de la boucle par l'opérateur Casser ).
Exemples d'utilisation de l'opérateur Alors que sont illustrés à la Figure 23. Trois options pour résoudre le même problème sont données : chacun des programmes F0 , F1 Et F2 renvoie l'indice du premier des éléments du vecteur d'origineV dépassant la valeur donnéez .
Premier programme (exemple UN ) ajoute un au compteur k dans le corps de la boucle Alors que jusqu'à la prochaine k -ème élément du vecteur d'origine ne dépassera pas la valeur donnée z . Après cela, la boucle se termine et le programme renvoie la dernière valeur modifiée de la variable k , qui est la solution au problème. Notez que, contrairement au cycle Pour , comptoir k ici, il est nécessaire de traiter avec des instructions séparées : initialiser (c'est-à-dire lui attribuer une valeur initiale) avant l'instruction de boucle et modifier sa valeur dans le corps de la boucle.
Il est facile de voir que l'option UN ) du programme a un inconvénient important : il n'empêche pas le programme de boucler dans le cas où le problème n'a pas de solution, c'est-à-dire lorsque le paramètre z dépasse la valeur du plus grand élément du vecteur V . Dans cet exemple, la boucle dans une telle situation ne se produira pas vraiment - mais ce n'est pas le mérite de notre programme, mais du système MathCAD, qui contrôle la sortie de l'index vectoriel V hors plage et générera un message d'erreur.
Libre de cette lacune est l'option b ) d'un programme dans lequel le corps de la boucle contient une vérification supplémentaire de la validité de la valeur d'index suivante et interrompt de force la boucle avec l'opérateur Casser dans la situation correspondante avec l'émission d'un message texte.
Le moyen le plus efficace de résoudre ce problème consiste peut-être à V ), qui n'utilise pas du tout l'opérateur Alors que . Dans ce programme, la variable k utilisé uniquement pour maintenir la "pureté du style" - pour exclure le traitement du paramètre de cycle je en dehors de l'opérateur Pour .
Figure 23 - Exemples de cycles de programmation Alors que
Objectif du travail :
Pour étudier les instructions cycliques for, while, do - while, apprenez à composer et à programmer des algorithmes cycliques.
Brèves informations théoriques
Les opérateurs de cycle sont utilisés lorsqu'il est nécessaire de répéter plusieurs fois certaines actions (opérateurs et opérations), et ces sections d'algorithmes sont appelées cycles.
pour l'instruction de la boucle
La forme de base de l'opérateur de boucle for est
pour (expression_1 ; expression_2 ; expression_3)
opérateur;
Où expression_1– valeur initiale du paramètre cycle;
expression_2– vérifier la condition de poursuite du cycle ;
expression_3– changement de paramètre de cycle (correction) ;
opérateur est un opérateur C simple ou composé.
Le schéma de fonctionnement de l'opérateur est le suivant : une fois que expression_1 est calculée, alors expression_2 est vérifiée, et si elle est "vraie", alors la section cyclique du programme est exécutée, puis le paramètre est corrigé, et ainsi de suite jusqu'à expression_2 prend la valeur "faux".
Par exemple: pour (k=1; k<5; k++)
printf("\n %d", k);
À la suite de l'exécution de cette instruction, les nombres de 1 à 4 sont imprimés dans une colonne.
Vous pouvez utiliser une variable de n'importe quel type de base comme paramètre de boucle.
Par exemple:
pour(ch='a'; ch<=’z’; ch++) // Вывод на экран букв
printf("%c",ch); // alphabet latin
Vous devez contrôler soigneusement la structure des boucles for dans le programme afin de ne pas vous retrouver avec une boucle infinie (de laquelle il n'y a pas de sortie).
Par exemple:
pour(k=10;k>6;k++)
printf("boucle infinie \n");
Sortir de la boucle tôt de la manière suivante :
Par condition supplémentaire ;
En utilisant les déclarations suivantes :
casser;- sortie de la boucle dans laquelle se trouve la rupture, le contrôle est transféré à la première instruction exécutée après la boucle ;
sortie(intCode);- sortie du programme ;
retour;- quitter la fonction ;
Utilisation de l'opérateur de saut inconditionnel aller à<метка>;
Tôt fin de l'étape cyclique en cours possible à l'aide d'une condition ou d'un opérateur supplémentaire continuer, qui interrompt l'exécution de l'étape de boucle en cours, c'est-à-dire ignore les instructions du reste de la boucle et transfère le contrôle à l'instruction principale de la boucle pour corriger le paramètre et tester la condition.
Il est interdit de transférer le contrôle de l'extérieur vers l'intérieur de la boucle.
Toutes les expressions de la boucle for entre parenthèses peuvent être absentes, mais le caractère ";" ne peut pas être lâché.
Par exemple:
pour(;je<3; i++)
met("Bonjour!");
Boucler les instructions while et do-while
Forme de base de l'opérateur cyclique alors que:
Alors que (état)
opérateur;
Où opérateur
La boucle est exécutée tant que la condition est évaluée à "vrai", c'est-à-dire l'expression entre parenthèses renvoie un résultat non nul. Il s'agit d'une boucle avec une condition préalable - la condition est d'abord vérifiée, puis l'instruction est exécutée. Par conséquent, la boucle while ne sera pas exécutée une seule fois si le résultat initial de l'évaluation de la condition est 0.
Formulaire d'opérateur de base faire pendant:
opérateur;
tandis que (condition);
Où opérateur est une instruction simple, composée ou vide.
Opérateur faire–alors que est un opérateur de boucle avec une postcondition, c'est-à-dire d'abord, l'instruction est exécutée, puis la condition est vérifiée pour la vérité. Puisque dans une boucle do-while la condition est vérifiée à la fin de la boucle, la boucle sera exécutée au moins une fois.
Dans des boucles comme while et do–while, les mêmes méthodes de sortie anticipée de la boucle et de fin anticipée de l'étape en cours de la boucle sont autorisées, comme dans l'instruction for, mais dans ce dernier cas, contrairement à la boucle for, le contrôle est transféré à la vérification de l'état. Pour éviter une boucle infinie à l'intérieur des boucles while et do-while, vous devez prévoir de modifier les variables incluses dans la condition.
Par exemple:
pour (i=1;i<=300;i++) // Печать целых чисел, кратных 5
si (i%5!=0) continuer ;
printf("%5d",i);
Exemples de boucles infinies :
opérateur;
2) while(number_not_0) // Toujours vrai !
opérateur;
opérateur;
while(number_not_0); // Toujours vrai!
Parmi les instructions de la boucle, il doit y avoir une condition de sortie.
Boucles imbriquées
Dans le cas des boucles imbriquées, une boucle est à l'intérieur d'une autre, par exemple :
pour(i=nn;i pour(j=mn;j opérateur; Où opérateur est une instruction simple, composée ou vide. La boucle interne sera exécutée pour chaque valeur du paramètre i qui satisfait la condition de la boucle externe. Exemple: pour(i=1;i<10;i++) // Печать таблицы умножения pour(j=1;j<4;j++) printf("\n %d*%d=%2d", je, j, je*j); printf("\n"); Exemple d'utilisation de l'instruction for Calculez. Le programme doit imprimer les résultats intermédiaires et finaux. Le texte du programme peut ressembler à #inclure #inclure met("Entrez N"); scanf("%d",&N); pour (s=0, k=1; k<=N; k++) // В заголовке цикла можно выпол- ( // prend et double affectation printf(" \n k=%d s=%f ", k, s); printf("\n REPONSE : s=%f, appuyez sur n'importe quelle touche...",s); Variantes de tâches individuelles Écrire un programme pour définir une table de valeurs de fonctions à dans une plage arbitraire [ un,b] changements d'arguments X avec pas arbitraire h. Valeurs un, b, h saisie au clavier. Le tableau doit contenir les colonnes suivantes : numéro de série, valeur d'argument X, valeur de la fonction, message sur la fonction croissante ou décroissante, différence entre deux valeurs de fonction voisines. Déterminez les valeurs maximale et minimale de la fonction. 1. 2. 3. 4. 5. 6. 7.a=-0.4p ; b=0,4p ; h=0,5. 8. 9. 10. « Programmation de processus de calcul cycliques » Objectif du travail : maîtriser les méthodes de compilation d'algorithmes pour les processus de calcul cycliques et organiser des programmes cycliques de structure complexe. Partie théorique 4.1.1. Algorithmes cycliques. Une boucle est une séquence d'actions qui peut être effectuée plusieurs fois. Un algorithme cyclique est un algorithme qui contient un ou plusieurs cycles. Il existe 3 types de cycles : Boucle avec précondition ; Boucle avec postcondition ; Cycle avec un compteur (cycle de comptage). Si l'exécution de la boucle est associée à une condition logique, des boucles avec une précondition ou une postcondition sont utilisées. Les boucles de comptage représentent une classe dans laquelle l'exécution du corps de la boucle doit être répétée un nombre de fois prédéterminé. Les schémas fonctionnels des algorithmes cycliques ressemblent à ceci : 1. Boucle avec un compteur. 2. Boucle avec précondition. 3. Boucle avec postcondition. 4.1.2 Instructions de boucle dans le langage de programmation C++. En C++, il existe un opérateur correspondant pour chaque type de boucle : boucle while (avec précondition); boucle do...while (avec postcondition); Pour la boucle (dénombrable). 1. Opérateur de boucle comme while Formulaire d'enregistrement : instruction while (condition); où : (condition) – expression logique ; instruction - l'instruction ou le corps de la boucle qui est exécutée dans la boucle. Si le corps de la boucle est une instruction composée, elle doit être placée entre parenthèses d'opérateurs (...) : tandis que (état) groupe d'opérateurs Le schéma de fonctionnement d'un tel cycle: tant que la condition est vraie (vraie), le corps du cycle est exécuté et la condition est à nouveau vérifiée, etc. Lorsque la condition devient fausse, la boucle se termine. 2. Opérateur de boucle comme do…while Formulaire d'enregistrement : opérateur; tandis que (condition); Le schéma de fonctionnement d'un tel cycle: d'abord, l'opérateur est exécuté, puis la condition est vérifiée, si la condition est vraie, l'opérateur est exécuté et la condition est à nouveau vérifiée, etc. Lorsque la condition devient fausse, la boucle se termine. Si le corps de la boucle est une instruction composée, alors, comme pour une boucle avec une précondition, elle doit être placée entre parenthèses d'opérateurs (...) : groupe d'opérateurs tandis que (condition); 3. Opérateur de boucle comme pour Formulaire d'enregistrement : opérateur; A est une expression initiale qui définit des valeurs initiales pour le paramètre de boucle et, si nécessaire, des valeurs initiales pour d'autres paramètres. Par exemple: i=0, x=0.5, p=1, s=0 B est une expression conditionnelle qui vérifie la condition de poursuite de la boucle. Par exemple: C est une expression d'incrémentation qui incrémente le paramètre de boucle et, si nécessaire, d'autres paramètres, puis ils sont écrits sous forme de liste. Par exemple : x+=0.1, i++ 4.1.3 Un exemple de compilation d'un algorithme et d'un programme en C++ pour un processus de calcul cyclique. Calculer la valeur d'une expression : b- la valeur initiale, sa valeur est saisie au clavier et ne change pas ; un– changements de gamme avec l'étape 1; y– résultat, ses valeurs sont affichées à l'écran. Sur la base de la condition d'affectation, la variable a est un nombre entier, elle peut donc être utilisée comme compteur dans le cycle de comptage. Le schéma fonctionnel de l'algorithme de résolution de ce problème à l'aide du cycle de comptage est le suivant : #inclure #inclure #inclure printf("Entrez b : "); scanf("%f",&b); printf("a y\n"); pour (a=0;a<=10;a++) printf("%3d",a); printf("%8.2f\n",y); y=(a-b)/sqrt(a); printf("%8.2f\n",y); Le schéma fonctionnel de l'algorithme de résolution de ce problème à l'aide d'une boucle avec une précondition est le suivant : Le texte du programme C++ correspondant à cet algorithme est le suivant : #inclure #inclure #inclure printf("Entrez b : "); scanf("%f",&b); printf("a y\n"); printf("%3d",a); printf("%8.2f\n",y); y=(a-b)/sqrt(a); printf("%8.2f\n",y); else printf(" y n'existe pas\n"); Le schéma fonctionnel de l'algorithme de résolution de ce problème à l'aide d'une boucle avec une postcondition est le suivant : Le texte du programme C++ correspondant à cet algorithme est le suivant : #inclure #inclure #inclure printf("Entrez b : "); scanf("%f",&b); printf("a y\n"); printf("%3d",a); printf("%8.2f\n",y); y=(a-b)/sqrt(a); printf("%8.2f\n",y); else printf(" y n'existe pas\n"); tandis que (un<=10); Partie pratique 4.2.1 Exigences pour l'exécution des travaux : Complétez la tâche du travail de laboratoire n ° 3 pour une plage de valeurs de l'une des variables. La variable variable, sa plage de variation et l'étape sont indiquées dans le tableau 4. Élaborez des organigrammes d'algorithmes et de programmes pour deux types de cycles indiqués dans la tâche individuelle (tableau 4). Organisez la sortie des résultats de manière à ce que les valeurs du paramètre variable soient clairement distinguées et, pour chacune de ses valeurs spécifiques, les valeurs du résultat (trois variables de la colonne 2 du tableau 3) soient affichées sous forme de tableau. L'ordre des travaux. 1. Effectuez une analyse des tâches, formulez un énoncé de problème. 2. Faire des schémas fonctionnels d'algorithmes. 3. Écrivez un programme en C++. Fournissez l'entrée des données initiales du clavier et la sortie des résultats à l'écran. 4. Vérifier les performances du programme sur différentes données initiales. 5. Effectuez une analyse des résultats. Variantes de tâches individuelles. Les variantes des tâches individuelles sont sélectionnées dans le tableau 4 en fonction du numéro de l'élève dans la liste des groupes du journal de l'enseignant. Tableau 4. Variantes des tâches individuelles 4.3 Questions de contrôle et tâches pratiques : 1. Comment fonctionne l'instruction while ? 2. Comment fonctionne l'instruction do ... while ? 3. Comment fonctionne l'instruction for ? 4. Soulignez les instructions du programme qui forment la boucle. 5. Quelle est la différence entre les instructions while et do ... while ? 6. Remplacez un opérateur de boucle par un autre dans le programme. Il sera facile pour un programmeur novice de les comprendre à l'aide d'un exemple généralisé. De plus, il est important de comprendre que dans tous les langages de programmation, il existe des moyens d'implémenter des cycles. Avec le concept de cycle, on ne se rencontre pas qu'en programmation. Il y a des cycles dans de nombreux domaines de notre vie. Par exemple, le cycle de l'eau dans la nature est un cycle naturel de notre vie. Et maintenant, considérons les règles générales et les concepts utilisés dans les cycles de calcul. 1. Méthodes de construction de processus de calcul cycliques dans des programmes. 2. Entré dans l'ordinateurNnombres réels. Écrivez un programme qui affiche la moyenne arithmétique de cet ensemble. Introduction Les programmes en boucle sont utilisés dans presque tous les logiciels. Dans ce cas, les cycles peuvent être explicites et implicites. En particulier, la boucle implicite est présente dans les gestionnaires d'interruption, qui s'exécutent en fait dans une boucle infinie dont le corps est déclenché par l'interruption. Les sous-programmes sont également cycliques - fonctions de fenêtre des applications Windows. De plus, des programmes avec un cycle sont considérés, dont le corps contient des modules fonctionnels. Processus cyclique est un processus de calcul dans lequel les calculs sont effectués à plusieurs reprises en utilisant les mêmes formules pour différentes valeurs de l'argument. Programmes qui implémentent un processus cyclique sont appelés programmes cycliques. L'organisation du cycle peut être divisée selon les étapes suivantes : préparation (initialisation) du cycle (AND) ; exécution des calculs de boucle (corps de boucle) (T) ; modification des paramètres (M) ; vérification de la condition de fin de cycle (U). L'ordre dans lequel ces étapes, par exemple T et M, peuvent être effectuées peut varier. Selon l'emplacement du test, les conditions de terminaison de boucle distinguent les boucles avec des terminaisons inférieures et supérieures. Pour une boucle avec une extrémité inférieure, le corps de la boucle est exécuté au moins une fois, car les calculs sont d'abord effectués, puis la condition de sortie de la boucle est vérifiée. Dans le cas d'une boucle terminée par le haut, le corps de la boucle peut ne pas être exécuté une seule fois si la condition de sortie est remplie immédiatement. Une boucle est dite déterministe si le nombre de répétitions du corps de la boucle est connu ou déterminé à l'avance. Le cycle est dit itératif si le nombre de répétitions du corps du cycle n'est pas connu à l'avance, mais dépend des valeurs des paramètres (certaines variables) intervenant dans les calculs. Corps de la boucle C'est une partie du programme qui se répète plusieurs fois. Paramètre de cycle est une variable qui prend de nouvelles valeurs à chaque répétition de la boucle (il existe des boucles simples et des boucles complexes). Vue générale du cycle n fois En général, le cycle n fois s'écrit comme suit : nc nombre de répétitions fois Les mots de service nts (début de cycle) et kts (fin de cycle) s'écrivent strictement l'un sous l'autre et sont reliés par une barre verticale. À droite de cette ligne, une séquence répétée de commandes (corps de la boucle) est écrite. Le nombre de répétitions est un entier arbitraire. Lorsque l'algorithme est exécuté, la séquence de commandes dans le corps de la boucle est répétée le nombre de fois spécifié. Les règles du langage algorithmique permettent de spécifier n'importe quel nombre entier de répétitions. Il peut être nul voire négatif. Ces cas ne sont pas considérés comme erronés, seul le corps de la boucle ne sera pas exécuté une seule fois, et l'ordinateur procédera immédiatement à l'exécution des commandes écrites après le kts Vue générale du cycle En général, le cycle s'écrit comme suit : nc au revoir condition | corps de la boucle (séquence de commandes) Lors de l'exécution d'un cycle, l'ordinateur répète les étapes suivantes : a) vérifie la condition écrite après le mot de service ; b) si la condition n'est pas remplie, alors l'exécution de la boucle se termine et le calculateur commence à exécuter les commandes écrites après les kts. Si la condition est remplie, l'ordinateur exécute le corps de la boucle, vérifie à nouveau la condition, et ainsi de suite. Vue générale du cycle pour nc pour i de i1 à i2 | corps de la boucle (séquence de commandes) Ici i est le nom d'une valeur de type entier, i1, i2 sont des entiers arbitraires ou des expressions avec des valeurs entières. Le corps de la boucle est exécuté séquentiellement pour i = i1, i = i1 + 1, i1 + 2, …i = i2. Les règles du langage algorithmique permettent de spécifier n'importe quels entiers i1, i2. en particulier, i2 peut être inférieur à i1. ce cas n'est pas considéré comme erroné - seul le corps de la boucle ne sera pas exécuté une seule fois, et l'ordinateur procédera immédiatement à l'exécution des commandes écrites après le kts. Boucle n fois et boucle tant que Les boucles n fois et jusqu'à présent sont disposées dans le langage algorithmique presque de la même manière. Ce n'est pas surprenant, car ces deux commandes configurent un cycle - une séquence de commandes répétitives. Les mots de service nts et kts indiquent qu'un cycle est en cours d'exécution, et l'en-tête de cycle spécifie un mécanisme spécifique pour son exécution. Cependant, ces deux cycles ont une différence significative. En commençant à exécuter la boucle n fois, l'ordinateur sait combien de fois il devra répéter le corps de la boucle. Lors de l'exécution d'une boucle, ce n'est pas encore le cas : l'ordinateur vérifie à chaque fois l'état de la boucle et ne peut pas déterminer à l'avance quand l'exécution se terminera. Vous ne pouvez connaître le nombre de répétitions du cycle qu'après la fin du cycle. Cela indique clairement dans quels cas quel cycle doit être utilisé. Si le nombre de répétitions est connu au moment où la boucle commence, il est pratique d'utiliser la boucle n fois. Si le nombre de répétitions ne peut pas être prédéterminé, un cycle de loin est nécessaire. Par exemple, le programme de contrôle automatique a la structure illustrée à la Fig. 1. Modules inclus dans le cycle(ainsi que les modules de gestion des interruptions), avec une entrée et une sortie chacun, ont généralement une caractéristique : les modules contiennent des variables statiques auxquelles une valeur est affectée dans le cycle en cours, et l'analyse de ces variables est effectuée dans le cycle suivant. Ainsi, les variables mentionnées caractérisent l'état du module à la fin du cycle de programme en cours ou au début du cycle de programme suivant. À l'avenir, nous ne considérerons que ces modules de programmes cycliques et les désignerons brièvement par MCP. Fig. 1. Structure typique d'un programme de commande avec une boucle infinie. Les MCP ont une structure diversifiée, dont la complexité doit être évaluée selon des critères particuliers. V.V. Lipaev a proposé un critère pratique et objectif pour la complexité des modules de programme, à savoir: le nombre et la longueur totale des chemins dans le graphe de contrôle du module. Cela ne prend en compte que les instructions conditionnelles et select. Cependant, ce critère n'est clairement pas suffisant pour le MCP à mémoire statique, car lors de l'analyse du MCP, il est nécessaire de se souvenir des valeurs de toutes les variables statiques définies lors du cycle précédent. De plus, il n'y a pas de recommandations pour la normalisation des algorithmes et des programmes, à l'exception de la programmation structurée connue de longue date dans les langages de programmation couramment utilisés tels que C et Pascal. Cet article se propose de combler ces lacunes par rapport au MCP. 2. Fragments de modules de programmes cycliques Un fragment bipolaire, ou simplement un fragment, nous considérerons une section de programme avec une entrée et une sortie (y compris les opérateurs de boucle) sous l'hypothèse que les MCP considérés sont structurés. Le fragment le plus simple comprend un seul opérateur. Une séquence de fragments est aussi un fragment. Le MCP, à son tour, est un fragment et consiste en une séquence de fragments. Une méthode de fragments indépendants est proposée pour synthétiser la structure de modules qui implémentent des tables de décision. Dans ce cas, un fragment est considéré comme indépendant s'il peut être inséré n'importe où dans la séquence des fragments de module. L'indépendance de l'emplacement d'un tel fragment est due au fait que les données qui y sont analysées ne sont pas formées dans la séquence de fragments spécifiée et que les données générées dans le fragment indépendant ne sont pas analysées dans cette séquence de fragments. Par conséquent, des fragments indépendants peuvent être exécutés en parallèle (pseudo-parallèle). Sur la fig. 2 montre des implémentations possibles d'un module avec deux fragments indépendants. Dans les options "a" et "b", les fragments sont réarrangés sans déformer l'essence du programme ; dans la version "c", les fragments sont implémentés en parallèle. Fig.2. Options pour implémenter un module avec des fragments indépendants : a) et b) - mise en œuvre séquentielle, c) - mise en œuvre parallèle : une double ligne horizontale indique la parallélisation du programme, une ligne horizontale grasse indique l'achèvement des processus parallèles. On appellera fragment fixe un fragment dépendant dont la localisation dans le module est strictement définie. Par exemple, dans le module de reconnaissance d'un caractère saisi au clavier, le premier doit être le fragment dépendant du bas du caractère directement saisi. Les opérateurs "début" et "fin" d'un module sont des fragments fixes. Les fragments absolument indépendants n'existent pas, ne serait-ce que parce que dans tout module sont mentionnés des fragments fixes du début et de la fin. Par conséquent, un fragment indépendant, en général, a une région de localisation possible limitée par deux fragments mutuellement dépendants. C'est-à-dire qu'une définition plus stricte d'un fragment indépendant est la suivante : indépendant par rapport à deux fragments fixes est un fragment qui peut être placé n'importe où dans la séquence de fragments délimités au-dessus et au-dessous par les fragments fixes indiqués.
a=-p ; b=p; h=0,4.
a = 0,7 ; b=1,8 ; h=0,1.
a=-0,5 ; b=2,5 ; h=0,2.
a=-0,9 ; b=2,7 ; h=0,3.
un=-2 ; b = 0,8 ; h=0,2.
a=-1,9 ; b=2,7 ; h=0,3.
a=-0,3p ; b=1,3p ; h=p/10.
a=-p/2 ; b=p/2 ; h=p/10.
a=-3 ; b=3 ; h=0,5.
Nbre p/p variable modifiable Type de boucle
10 ≤ a ≤ 10,Δ un=1
-4 ≤ d ≤ 4, Δ d = 0,5
-6 ≤ x ≤ 3, Δ x = 0,5
0 ≤ b ≤ 3 0, Δ b = 1,5
1. Avec précondition, 2. Dénombrable
-15 ≤ j ≤ 1 0, Δ j = 0,5
1. Avec précondition, 2. Avec postcondition
5 ≤ e ≤ 35,Δ e = 2
1. Dénombrable, 2. Avec postcondition
-5 ≤ m ≤ 15,Δ m = 1
1. Avec précondition, 2. Dénombrable
1 ≤ c ≤ 70,Δ c=3
1. Avec précondition, 2. Avec postcondition
1,5 ≤ c ≤ 15,Δ c = 0,5
1. Dénombrable, 2. Avec postcondition
-8 ≤ b ≤ 28,Δ b = 2
1. Avec précondition, 2. Dénombrable
-4,5 ≤ x ≤ 11,5,Δ x = 0,5
1. Avec précondition, 2. Avec postcondition
-7 ≤ k ≤ 2,Δ k = 0,3
1. Dénombrable, 2. Avec postcondition
-1 ≤ m ≤ 21,Δ m = 1
1. Avec précondition, 2. Dénombrable
-2 ≤ e ≤ 34,Δ e = 2
1. Avec précondition, 2. Avec postcondition
-11 ≤ c ≤ 23,Δ c = 2
1. Dénombrable, 2. Avec postcondition
-13 ≤ p ≤ 50,Δ p=3
1. Avec précondition, 2. Dénombrable
3,3 ≤ b ≤ 9,3,Δ b = 0,3
1. Avec précondition, 2. Avec postcondition
3,5 ≤ y ≤ 12,3,Δ y=0.4
1. Dénombrable, 2. Avec postcondition
-7,5 ≤ a ≤ 5,7,Δ un = 0,6
1. Avec précondition, 2. Dénombrable
-1,5 ≤ h ≤ 1,2,Δ h = 0,1
1. Avec précondition, 2. Avec postcondition
0 ≤ h ≤ 10,Δ h=0.5
1. Dénombrable, 2. Avec postcondition
-15 ≤ b ≤ 15, Δ b=2
1. Avec précondition, 2. Dénombrable
-7 ≤ l ≤ 3, Δ l = 0,5
1. Avec précondition, 2. Avec postcondition
-5,5 ≤ b ≤ 6,5, Δ b = 0,5
1. Dénombrable, 2. Avec postcondition
1 ≤ k ≤ 9, Δ k = 0,4
1. Avec précondition, 2. Dénombrable
0 ≤ b ≤ 6,9,Δ b = 0,3
1. Avec précondition, 2. Avec postcondition
-3 ≤ v ≤ 9,Δ v = 0,6
1. Dénombrable, 2. Avec postcondition
-2 ≤ p ≤ 2,6,Δ p = 0,2
1. Avec précondition, 2. Dénombrable
Qu'est-ce qu'un cycle en programmation ?
Cycle - en programmation, on parle de répétition répétée des mêmes actions ou calculs, mais selon les mêmes dépendances avec différentes valeurs de variables. Étapes du processus cyclique
En général, le cycle doit être mis en œuvre en 4 étapes :
Il y a 3 instructions de boucle en pascal qui peuvent implémenter n'importe algorithmiquement - structure cyclique :
Définition de la valeur initiale du paramètre et de la variable de boucle.
Paramètre de cycle- cette valeur qui compte le nombre de pas de cycle (le nombre de répétitions du cycle).
variable de boucle est une valeur qui change de valeur à chaque étape du cycle.
Initialisation est l'affectation des valeurs initiales au paramètre et à la variable de boucle.
Il s'agit d'une répétition multiple d'une action dans un cycle ou de calculs sur les mêmes dépendances mathématiques avec des valeurs de variables différentes.
Il s'agit d'un test de la condition de poursuite ou de début de cycle.
Nous les verrons en détail dans le prochain article.
