Lavar , enjuagar , repetir es una expresión idiomática en inglés que podría implicar "hazlo de nuevo" o, con humor, implicar un bucle infinito. La repetición de una función o un conjunto de pasos en el contexto de secuencias de comandos se denomina iteración o bucle.La iteración es una técnica de secuencias de comandos muy importante. A continuación se muestra el diagrama lógico y el código JSL correspondiente de un simple Para bucle.
Una vez que un scripter novato aprende la sintaxis de un básico Para bucle, con frecuencia, preguntan "¿Cómo hago?":
- Iterar cuando se desconoce el número de iteraciones
- Detener un ciclo antes de tiempo una vez norte los eventos han sido contados
- Omita la ejecución del bloque de pasos para ciertas condiciones, pero continúe con el bucle, etc.
A continuación se muestra un extracto del capítulo 4, sección " Funciones condicionales ", " Iterar " de JSL Companion, aplicaciones del lenguaje de scripting JMP, segunda edición que presenta los conceptos básicos y aborda estas preguntas. Se adjunta el script de ejemplo de esa sección. Como se indica en el prefacio del libro, "Los guiones de ejemplo contienen... mucha más información de la que podríamos incluir en este libro".
Iterar
JSL tiene varias funciones que repiten o iteran. La estructura básica de un ciclo de iteración incluye lo siguiente:
- Inicio o condición inicial
- Prueba o condición while
- Incremento, tamaño de paso o secuencia de iteración
- Cuerpo o bloque de código JSL a ejecutar
El cuerpo de JSL se ejecuta siempre que la condición de prueba sea verdadera. El resto de este blog y script 4_Iterando.jsl proporcione ejemplos y descripciones de las funciones de iteración de JMP.
Para cada fila y establecer cada valor
Por cada fila y Establecer cada valor son mensajes de iteración especiales para tablas de datos, donde la condición inicial es Row( ) = 1, la primera fila de la tabla de datos de origen. La condición final es la última fila. El incremento es 1: Fila( ) = Fila( ) + 1. La condición de prueba puede considerarse una condición while: Fila( ) <= N Fila(dt). Los tres primeros componentes estructurales (inicial, while e incremento) están incorporados.
la sintaxis es Por cada fila ( , cuerpo ) .
Funciones de suma y producto
El Suma y Producto Las funciones son especiales. En estas funciones, la tarea principal está integrada en su nombre. Los tres argumentos son el valor inicial normalmente asignado a una variable, el valor final (i <= 6), donde se implica un incremento de 1, y el tercer argumento o cuerpo incluye lo que se suma o multiplica.
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);
Funciones para y mientras
Para y Mientras son funciones de iteración de programación tradicionales. Típicamente, Para se usa al contar, y cuando el tamaño del paso es consistente o se puede calcular el número de iteraciones. Mientras se usa más comúnmente cuando la condición de prueba o while requiere una lógica más compleja o el incremento es condicional. Cada Para ( ) bloque de código se puede escribir como un Mientras ( ) bloque de código, pero lo contrario podría no ser cierto.
Ejemplo
Usando el anterior integración_aprox Por ejemplo, cree un bucle de iteración para obtener aproximaciones cada vez mejores. Comience con 10 intervalos y cada iteración sucesiva duplicará el número de intervalos. Este primer ejemplo se detiene después de cinco iteraciones.
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
Supongamos que se desea un criterio de convergencia específico. El 4_Iterando.jsl script contiene varias opciones para hacer esto. El fragmento de código anterior ya tiene la lógica necesaria: último valor y integración_aprox tener valores iniciales. El guión se detiene cuando la diferencia sucesiva absoluta es menor que el criterio de convergencia.
Una variación de este script usa el criterio de convergencia como una expresión en el argumento de prueba del Para bucle. El siguiente script utiliza un Romper( ) para detener. Este ejemplo demuestra que cada uno de los Para Los argumentos de bucle pueden ser un bloque de código, iniciar múltiples variables, incrementar múltiples variables o realizar otras tareas. Recuerde que los puntos y coma unen las sentencias JSL para definir el bloque de código que se ejecutará.
//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 eres nuevo en Para bucles, revise los valores de k y n en la ventana de registro para cada variación de este script. Después del bucle inicial, JMP ejecuta el bloque de código de incremento antes de ejecutar el bloque de código de prueba. Los programadores llaman a eso incrementando en la parte inferior del ciclo . Para el fragmento de código anterior, cuando k=7 y n=640, se cumple el criterio de convergencia, y Romper( ) detiene el Para bucle antes de que se ejecute el bloque de código de incremento. En el script completo (que no se muestra aquí), una variación tiene el criterio de convergencia como una expresión en el bloque de código de prueba. Entonces, el bloque de incremento se ejecuta primero, k = 8 y n = 1280, y luego el bloque de prueba detiene el Para bucle.
Sin controles adecuados, Para y Mientras los bucles pueden iterar indefinidamente, lo que se denomina Bucle infinito . Esto suele ser un problema. En el código anterior, la condición agregada k < 100 asegura que el bucle terminará después de 99 iteraciones, siempre que k se incremente en 1 cada vez. La mayoría de los bucles infinitos son causados por la falta de controles de límites y por la destrucción de variables de límites. Por ejemplo, si se eliminó la instrucción JSL k++ y la aproximación divergió, el Para loop iteraría indefinidamente o hasta que creara una excepción JMP. Hay casos raros en los que un bucle infinito intencional es útil. Por lo general, se utilizan para comprobar el estado de un servicio o un objeto e incluyen una instrucción de interrupción o terminación. Están más allá del alcance de este blog [libro].
Puede haber casos en los que el cuerpo del código no pueda o no deba ejecutarse. Considere el conjunto de datos de muestra de JMP Semiconductor Capability.jmp . Las columnas P1 y M1 solo tienen un valor único: un gráfico de control o un diagrama de distribución es una pérdida de espacio gráfico. Los escenarios en los que faltan todos los valores o en los que una lista de columnas definida por el usuario incluye una columna no numérica deben buscarse e ignorarse. Este escenario es un buen caso para un Continuar función. En este caso, informar al usuario, enviar un mensaje con un Subtítulo , escriba una nota en la ventana Registro o agregue un cuadro de texto a los archivos de diario y continúe analizando las columnas restantes de la lista. Puede haber instancias en las que desee salir del circuito, pero también desee continuar con el programa. Y, en casos más graves, es posible que desee detener todo el programa. La Tabla 4.1 describe el comportamiento de las funciones para detener la iteración.
Tabla 4.1 Funciones utilizadas para detener la iteración
Función
|
Resultado
|
Continuar( )
|
Detiene la iteración actual de un bucle en el Continuar declaración, y comienza el bucle al comienzo de la siguiente iteración.
|
Romper( )
|
Detiene la ejecución del ciclo en el Romper declaración, y comienza a ejecutarse de nuevo en la primera declaración fuera del bucle.
|
Tirar( )
|
Tirar( mensaje ) escribe un mensaje en la ventana de registro y anula la ejecución del script. Esta función se utiliza a menudo con Intentar( ) o Si( ) para detectar el problema, cree un buen mensaje de error, siga los pasos para salir de forma segura y luego envíe un mensaje.
|
Continuar y Romper se puede utilizar en el cuerpo del Para , Mientras , y Por cada fila funciones Tirar se puede utilizar en casi cualquier lugar. Nota Detener( ) detiene inmediatamente el script que se está ejecutando.
Ejemplo adicional
El 4_Iterando.jsl script incluye un bloque de código que tiene muchas funciones adicionales, utilizando técnicas de capítulos anteriores ( como Abierto , Clasificar , Resumen , listas y funciones ) y futuros capítulos. Este fragmento de código es un ejemplo de la Continuar función:
//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>
El contenido de esta publicación de blog se condensó a partir de un extracto de nuestro libro, JSL Companion: aplicaciones del lenguaje de secuencias de comandos JMP, segunda edición , donde encontrará más técnicas y ejemplos de trabajo con JMP Scripting Language.
