Laver , rincer , répéter est un idiome de la langue anglaise qui pourrait impliquer "faites-le encore" ou impliquer avec humour une boucle infinie. La répétition d'une fonction ou d'un ensemble d'étapes dans le contexte d'un script est appelée itération ou bouclage.L'itération est une technique de script très importante. Vous trouverez ci-dessous le schéma logique et le code JSL correspondant d'un simple Pour boucle.
Une fois qu'un scripteur novice a appris la syntaxe d'un script de base Pour boucle, fréquemment, ils demandent "Comment puis-je":
- Itérer lorsque le nombre d'itérations est inconnu
- Arrêter une boucle plus tôt une fois n les événements ont été comptés
- Ignorez l'exécution du bloc d'étapes pour certaines conditions, mais continuez à boucler, etc.
Ci-dessous un extrait du chapitre 4, section " Fonctions conditionnelles ", " Répéter " de Compagnon JSL, Applications du langage de script JMP, deuxième édition qui présente les bases et aborde ces questions. Vous trouverez ci-joint l'exemple de script de cette section. Comme indiqué dans la préface du livre "Les exemples de scripts contiennent ... beaucoup plus d'informations que nous ne pourrions en mettre dans ce livre."
Répéter
JSL a plusieurs fonctions qui bouclent ou itèrent. La structure de base d'une boucle d'itération comprend les éléments suivants :
- Démarrage ou condition initiale
- Condition de test ou tant que
- Incrément, taille de pas ou séquence d'itérations
- Corps ou bloc de code JSL à exécuter
Le corps de JSL est exécuté tant que la condition de test est vraie. Le reste de ce blog et script 4_Itération.jsl fournir des exemples et des descriptions de fonctions d'itération JMP.
Pour chaque ligne et définir chaque valeur
Pour chaque ligne et Définir chaque valeur sont des messages d'itération spéciaux pour les tables de données, où la condition initiale est Row( ) = 1, la première ligne de la table de données source. La condition de fin est la dernière ligne. L'incrément est de 1 : Ligne( ) = Ligne( ) + 1. La condition de test peut être considérée comme une condition while : Row( ) <= N Row(dt). Les trois premiers composants structurels (initial, while et incrément) sont intégrés.
La syntaxe est Pour chaque ligne ( , corps ) .
Fonctions de sommation et de produit
Le Addition et Produit les fonctions sont spéciales. Dans ces fonctions, la tâche principale est intégrée à son nom. Les trois arguments sont la valeur initiale généralement attribuée à une variable, la valeur finale (i <= 6), où un incrément de 1 est implicite, et le troisième argument ou corps inclut ce qui est additionné ou multiplié.
six_evens = Summation(i=1,6,2*i); // 42 Sum of 1st 6 even integers
six_odds = Summation(i=1,6,2*i-1); // 36 Sum of 1st 6 odd integers
power3to5 = Product(i=1,5,3); // 3*3*3*3*3 = 3^5 = 243
a = 2; b = 4; d = (b - a)/10; //d is step size for 10 intervals
integration_approx = Summation( i=1, 10, d*( a + ( i-.5 )*d)^2);
// 18.66 Integral(x^2) = (x^3)/3 = 64/3 – 8/3 = 56/3
show(six_evens, six_odds, power3to5, integration_approx);
Fonctions For et While
Pour et Alors que sont des fonctions d'itération de programmation traditionnelles. Typiquement, Pour est utilisé lors du comptage et lorsque la taille du pas est cohérente ou que le nombre d'itérations peut être calculé. Alors que est le plus couramment utilisé lorsque le test ou la condition nécessite une logique plus complexe ou que l'incrément est conditionnel. Chaque Pour ( ) bloc de code peut être écrit comme un Alors que ( ) bloc de code, mais l'inverse peut ne pas être vrai.
Exemple
En utilisant le précédent intégration_approx Par exemple, créez une boucle d'itération pour obtenir successivement de meilleures approximations. Commencez avec 10 intervalles, et chaque itération successive doublera le nombre d'intervalles. Ce premier exemple s'arrête après cinq itérations.
a = 2; b = 4; lastVal = 1000;
integration_approx = 0;
For( k = 1, k <= 5, k++,
If( k == 1,
n = 10,
n = 2 * n
);
lastVal = integration_approx; //needed to check convergence
d = (b - 2) / n;
integration_approx = Summation( i = 1, n, d * (a + (i - .5) * d) ^ 2 );
//-- show convergence
Show (k, n, d, integration_approx, integration_approx - lastVal);
); //end For
Supposons qu'un critère de convergence spécifique soit recherché. Le 4_Itération.jsl Le script contient plusieurs options pour ce faire. L'extrait de code précédent a déjà la logique nécessaire : dernièreVal et intégration_approx ont des valeurs de départ. Le script s'arrête lorsque la différence successive absolue est inférieure au critère de convergence.
Une variante de ce script utilise le critère de convergence comme expression dans l'argument de test du Pour boucle. Le script suivant utilise un Casser( ) arrêter. Cet exemple montre que chacun des Pour Les arguments de boucle peuvent être un bloc de code, initiant plusieurs variables, incrémentant plusieurs variables ou effectuant d'autres tâches. Rappelez-vous que les points-virgules lient les instructions JSL pour définir le bloc de code à exécuter.
//Uses Break() to stop looping, an early stop when convergence is met
//Note n *= 2 is equivalent to n = 2*n
a = 2; b = 4;
For( k = 1; lastVal = 1000; integration_approx = 0; n = 10 , //multiple initial values
k < 100, //test
k++; n *= 2 , //increment
lastVal = integration_approx; //body...
d = (b - a) / n;
integration_approx = Summation( i = 1, n, d * (a + (i - .5) * d) ^ 2 );
If (Abs( integration_approx - lastVal ) < 1e-5, Break() );
);
Show (k, n, d, integration_approx, integration_approx - lastVal);
Si vous êtes nouveau à Pour boucles, passez en revue les valeurs de k et n dans la fenêtre Journal pour chaque variante de ce script. Après la boucle initiale, JMP exécute le bloc de code d'incrémentation avant d'exécuter le bloc de code de test. Les programmeurs appellent ça incrémentation en bas de boucle . Pour l'extrait de code précédent, lorsque k=7 et n=640, le critère de convergence est satisfait, et Casser( ) arrête le Pour boucle avant l'exécution du bloc de code d'incrémentation. Dans le script complet (qui n'est pas montré ici), une variation a le critère de convergence comme expression dans le bloc de code de test. Ainsi, le bloc d'incrémentation est exécuté en premier, k = 8 et n = 1280, puis le bloc de test arrête le Pour boucle.
Sans contrôles appropriés, Pour et Alors que les boucles peuvent itérer indéfiniment, ce qui s'appelle un boucle infinie . C'est généralement un problème. Dans le code précédent, la condition ajoutée k < 100 garantit que la boucle se terminera après 99 itérations, tant que k est incrémenté de 1 à chaque fois. La plupart des boucles infinies sont causées par un manque de contrôles aux limites et par la destruction de variables aux limites. Par exemple, si l'instruction JSL k++ a été supprimée et que l'approximation a divergé, la Pour boucle itérerait indéfiniment ou jusqu'à ce qu'elle crée une exception JMP. Il existe de rares cas où une boucle infinie intentionnelle est utile. En règle générale, ils sont utilisés pour vérifier l'état d'un service ou d'un objet et ils incluent une interruption ou une instruction de terminaison. Ils sortent du cadre de ce blog [livre].
Il peut y avoir des cas où le corps du code ne peut pas ou ne doit pas être exécuté. Considérez l'exemple d'ensemble de données JMP Capacité semi-conducteur.jmp . Les colonnes P1 et M1 n'ont qu'une seule valeur unique — une carte de contrôle ou un diagramme de distribution est une perte d'espace graphique. Les scénarios dans lesquels les valeurs sont toutes manquantes ou dans lesquels une liste de colonnes définie par l'utilisateur comprend une colonne non numérique doivent être trouvés et ignorés. Ce scénario est un bon cas pour un Continuer fonction. Dans ce cas, informez l'utilisateur, envoyez un message avec un Légende , rédigez une note dans la fenêtre Journal ou ajoutez une zone de texte aux fichiers journaux, puis poursuivez l'analyse des colonnes restantes de la liste. Il peut y avoir des cas où vous souhaitez sortir de la boucle, mais vous souhaitez également continuer le programme. Et, dans les cas les plus graves, vous voudrez peut-être arrêter l'ensemble du programme. Le tableau 4.1 décrit le comportement des fonctions pour arrêter l'itération.
Tableau 4.1 Fonctions utilisées pour arrêter l'itération
Fonction
|
Résultat
|
Continuer( )
|
Arrête l'itération en cours d'une boucle à la Continuer et commence la boucle au début de l'itération suivante.
|
Casser( )
|
Arrête l'exécution de la boucle à la Casser et recommence à s'exécuter à la première instruction en dehors de la boucle.
|
Lancer( )
|
Lancer( msg ) écrit un message dans la fenêtre Journal et interrompt l'exécution du script. Cette fonction est souvent utilisée avec Essayer( ) ou Si( ) pour détecter le problème, créez un bon message d'erreur, effectuez les étapes pour quitter en toute sécurité, puis envoyez un message.
|
Continuer et Casser peut être utilisé dans le corps du Pour , Alors que , et Pour chaque ligne les fonctions. Lancer peut être utilisé presque n'importe où. Note Arrêt( ) arrête immédiatement le script en cours d'exécution.
Exemple supplémentaire
Le 4_Itération.jsl le script inclut un bloc de code qui a de nombreuses fonctionnalités supplémentaires, en utilisant les techniques des chapitres précédents ( tel que Ouvrir , Trier , Résumé , listes et fonctions ) et les prochains chapitres. Cet extrait de code est un exemple de Continuer fonction:
//Create a custom chart for each response with a non-constant value
For( i=1, i <= nitems(cList), i++,
if( Col Std Dev( column( cList[i] ) ) == 0,
tmpStr = cList[i] || " has no variation, no charts created";
Caption( tmpStr ); //caption
VListBox( Outline Box(tmpStr) ) << journal; //journal
show( tmpStr ); //Log window
Wait( 5 ); Caption( Remove );
Continue()
//go to the bottom of the loop, skip remaining "body" of code
); // end if
cc = lot_sumry_dt << Control Chart(
Sample Label( :lot_id ),
KSigma( 3 ),
Chart Col( eval(cList[i]), Levey Jennings )
); //end control chart
report(cc)[OutlineBox(2)]<<JOURNAL></JOURNAL>
Le contenu de cet article de blog a été condensé à partir d'un extrait de notre livre, Compagnon JSL : Applications du langage de script JMP, deuxième édition , où vous trouverez d'autres techniques et exemples d'utilisation du langage de script JMP.
