CONTENIDO Este capítulo le presenta los conceptos detrás de las referencias a módulos, paquetes y clases de Perl. También muestra cómo crear algunos módulos de ejemplo. Un módulo Perl es un conjunto de código Perl que actúa como una biblioteca de llamadas a funciones. El término módulo en Perl es sinónimo del paquete de palabras. Los paquetes son una característica de Perl 4, mientras que los módulos son frecuentes en Perl 5. Puede mantener todo su código Perl reutilizable específico para un conjunto de tareas en un módulo Perl. Por lo tanto, toda la funcionalidad perteneciente a un tipo de tarea está contenida en un archivo. Es más fácil construir una aplicación en estos bloques modulares. Por lo tanto, el módulo de la palabra aplica un poco más que el paquete. Heres una introducción rápida a los módulos. Ciertos temas de esta sección se tratarán en detalle en el resto del libro. Lea los párrafos siguientes cuidadosamente para obtener una visión general de lo que está por venir mientras escribe y usa sus propios módulos. Lo que es confuso es que los términos módulo y paquete se utilizan indistintamente en toda la documentación de Perl, y estos dos términos significan lo mismo. Así que al leer documentos de Perl, sólo piensa en quotpackagequot cuando ves quotmodulequot y viceversa. Así que, cuál es la premisa para el uso de módulos? Bueno, los módulos están ahí para empaquetar (perdonar el juego de palabras) variables, símbolos y elementos de datos interconectados juntos. Por ejemplo, usar variables globales con nombres muy comunes como k. J. O i en un programa generalmente no es una buena idea. También, un contador de bucle, i. Debe ser permitido trabajar independientemente en dos porciones diferentes del código. Declarar i como una variable global y luego incrementarla desde dentro de una subrutina creará problemas inmanejables con su código de aplicación porque la subrutina puede haber sido llamada desde dentro de un bucle que también usa una variable llamada i. El uso de módulos en Perl permite que las variables con el mismo nombre se creen en diferentes lugares distintos en el mismo programa. Los símbolos definidos para las variables se almacenan en una matriz asociativa, denominada tabla de símbolos. Estas tablas de símbolos son exclusivas de un paquete. Por lo tanto, las variables del mismo nombre en dos paquetes diferentes pueden tener valores diferentes. Cada módulo tiene su propia tabla de símbolos de todos los símbolos que se declaran dentro de él. La tabla de símbolos básicamente aísla nombres sinónimos en un módulo de otro. La tabla de símbolos define un espacio de nombres. Es decir, el uso de módulos, cada uno con su propia tabla de símbolos, impide que una variable declarada en una sección sobrescriba los valores de otras variables con el mismo nombre declarado en otra parte de la misma programa. De hecho, todas las variables en Perl pertenecen a un paquete. Las variables de un programa Perl pertenecen al paquete principal. Todos los demás paquetes dentro de un programa de Perl están anidados dentro de este paquete principal o existen al mismo nivel. Hay algunas variables verdaderamente globales, como la matriz SIG de manejadores de señales. Que están disponibles para todos los otros módulos en un programa de aplicación y no se pueden aislar a través de espacios de nombres. Sólo aquellos identificadores de variables que comienzan con letras o subrayado se mantienen en una tabla de símbolos de módulos. Todos los demás símbolos, como los nombres STDIN. STDOUT. STDERR. ARGV. ARGVOUT. ENV. Cª . Y SIG son obligados a estar en el paquete principal. Cambiar entre paquetes afecta sólo a los espacios de nombres. Todo lo que está haciendo cuando utiliza un paquete u otro es declarar qué tabla de símbolos se usará como tabla de símbolos predeterminada para buscar nombres de variables. Sólo las variables dinámicas se ven afectadas por el uso de tablas de símbolos. Las variables declaradas por el uso de la palabra clave my todavía se resuelven con el bloque de código en el que residen y no se hace referencia a través de tablas de símbolos. De hecho, el ámbito de una declaración de paquete permanece activo sólo dentro del bloque de código en el que se declara. Por lo tanto, si cambia tablas de símbolos mediante un paquete dentro de una subrutina, se restaurará la tabla de símbolos original en efecto cuando se realizó la llamada Cuando la subrutina regresa. Cambiar las tablas de símbolos sólo afecta a la búsqueda predeterminada de los nombres de las variables dinámicas. Todavía puede referirse explícitamente a variables, manejadores de archivos y así sucesivamente en un paquete específico añadiendo un nombre de paquete. Al nombre de la variable. Usted vio lo que era un contexto de paquete al usar referencias en el Capítulo 3. Un contexto de paquete simplemente implica el uso de la tabla de símbolos por el intérprete de Perl para resolver nombres de variables en un programa. Cambiando las tablas de símbolos, cambia el contexto del paquete. Los módulos se pueden anidar dentro de otros módulos. El módulo anidado puede utilizar las variables y funciones del módulo en el que está anidado. Para los módulos anidados, tendría que utilizar moduleName. NestedModuleName y así sucesivamente. Usando el doble colon (::) es sinónimo de usar una cita de retorno (). Sin embargo, el doble colon es la forma preferida de abordar las variables dentro de los módulos. El direccionamiento explícito de variables de módulo se realiza siempre con una referencia completa. Por ejemplo, supongamos que tiene un módulo, Inversión. Que es el paquete predeterminado en uso, y desea dirigirse a otro módulo, Bonds. Que está anidado dentro del módulo de inversión. En este caso, no puede utilizar Bond ::. En su lugar, tendría que utilizar Investment :: Bond :: para abordar variables y funciones dentro del módulo Bond. El uso de Bond :: implicaría el uso de un paquete Bond que está anidado dentro del módulo principal y no dentro del módulo de Inversión. La tabla de símbolos para un módulo se almacena realmente en una matriz asociativa de los nombres de módulos anexados con dos puntos. La tabla de símbolos de un módulo denominado Bond se denominará la matriz asociativa Bond ::. El nombre de la tabla de símbolos del módulo principal es main ::. E incluso se puede acortar a ::. Del mismo modo, todos los paquetes anidados tienen sus símbolos almacenados en matrices asociativas con dos puntos separados cada nivel de anidamiento. Por ejemplo, en el módulo Bond que está anidado dentro del módulo de inversión, la matriz asociativa para los símbolos del módulo Bond se denominará Investment :: Bond ::. Un typeglob es realmente un tipo global para un nombre de símbolo. Puede realizar operaciones de aliasing asignando a un typeglob. Una o más entradas en una matriz asociativa para símbolos se utilizarán cuando se utilice una asignación a través de un comando typeglob. El valor real en cada entrada de la matriz asociativa es a lo que se está refiriendo cuando se utiliza la notación variableName. Por lo tanto, hay dos maneras de referirse a los nombres de variables en un paquete: Inversión :: dinero Inversión :: cuentas En el primer método, se está refiriendo a las variables a través de una referencia typeglob. El uso de la tabla de símbolos, Investment ::. Está implícito aquí, y Perl optimizará la búsqueda de símbolos de dinero y facturas. Esta es la manera más rápida y preferida de abordar un símbolo. El segundo método utiliza una búsqueda para el valor de una variable dirigida por dinero y facturas en la matriz asociativa utilizada para los símbolos, Investment :: explicitly. Esta búsqueda se haría dinámicamente y no será optimizada por Perl. Por lo tanto, la búsqueda se verá obligado a comprobar la matriz asociativa cada vez que se ejecuta la instrucción. Como resultado, el segundo método no es eficiente y debe utilizarse sólo para demostrar cómo se implementa internamente la tabla de símbolos. Otro ejemplo en esta declaración kamran husain hace que variables, subrutinas y manejadores de archivos que se nombran a través del símbolo kamran sean también dirigidos a través del símbolo husain. Es decir, todas las entradas de símbolo en la tabla de símbolos actual con la clave kamran ahora contendrán referencias a los símbolos dirigidos por la clave husain. Para evitar dicha asignación global, puede utilizar referencias explícitas. Por ejemplo, la siguiente sentencia le permitirá abordar el contenido de husain a través de la variable kamran. Kamran husain Sin embargo, cualquier arrays como kamran y husain no será el mismo. Sólo se cambiarán las referencias especificadas explícitamente. Para resumir, cuando se asigna un typeglob a otro, se afectan todas las entradas en una tabla de símbolos independientemente del tipo de variable a la que se hace referencia. Cuando asigna una referencia de un tipo de variable a otro, sólo afecta a una entrada de la tabla de símbolos. Un archivo de módulo Perl tiene el siguiente formato: package ModuleName. Insertar el código del módulo. 1 El nombre de archivo debe llamarse ModuleName. pm. El nombre de un módulo debe terminar en la cadena. pm por convención. La instrucción del paquete es la primera línea del archivo. La última línea del archivo debe contener la línea con la instrucción 1. Esto en efecto devuelve un valor verdadero al programa de aplicación usando el módulo. No utilizar la instrucción 1 no permitirá que el módulo se cargue correctamente. La instrucción package le dice al intérprete de Perl que comience con un nuevo dominio de espacio de nombres. Básicamente, todas sus variables en un script Perl pertenecen a un paquete llamado main. Cada variable en el paquete principal se puede denominar mainvariable. Heres la sintaxis para tales referencias: packageNamevariableName La cita simple () es sinónimo del operador doble de dos puntos (::). Cubro más usos del operador :: en el próximo capítulo. Por el momento, debe recordar que las siguientes dos sentencias son equivalentes: packageNamevariableName packageName :: variableName La sintaxis de dos puntos se considera estándar en el mundo de Perl. Por lo tanto, para preservar la legibilidad, utilizo la sintaxis de dos puntos en el resto de este libro a menos que sea absolutamente necesario hacer excepciones para probar un punto. El uso predeterminado de un nombre de variable difiere al paquete actual activo en el momento de la compilación. Por lo tanto, si está en el paquete Finance. pm y especifique una variable pv. La variable es realmente igual a Finance :: pv. Uso de módulos Perl: use vs. require Incluya módulos Perl en su programa usando el uso o la instrucción require. Heres la manera de utilizar cualquiera de estas declaraciones: use ModuleName require ModuleName Observe que la extensión. pm no se usa en el código mostrado arriba. También tenga en cuenta que ninguna de las sentencias permite que un archivo se incluya más de una vez en un programa. El valor devuelto de true (1) como la última instrucción es necesario para permitir que Perl sepa que un módulo require d o use d se carga correctamente y permite que el intérprete Perl ignore cualquier recarga. En general, es mejor usar la instrucción Módulo de uso que la instrucción Module requerida en un programa Perl para seguir siendo compatible con versiones futuras de Perl. Para los módulos, es posible que desee considerar seguir utilizando la instrucción require. Heres why: La instrucción use hace un poco más de trabajo que la instrucción require en que altera el espacio de nombres del módulo que incluye otro módulo. Desea que esta actualización adicional del espacio de nombres se realice en un programa. Sin embargo, al escribir código para un módulo, es posible que no desee que el espacio de nombres se modifique a menos que sea explícitamente necesario. En este caso, utilizará la instrucción require. La instrucción require incluye la ruta de acceso completa de un archivo en la matriz Inc para que las funciones y variables en el archivo de módulos se encuentren en una ubicación conocida durante el tiempo de ejecución. Por lo tanto, las funciones que se importan de un módulo se importan mediante una referencia de módulo explícita en tiempo de ejecución con la instrucción require. La instrucción use hace lo mismo que la instrucción require porque actualiza la matriz Inc con nombres de ruta completos de módulos cargados. El código para la función de uso también va un paso más y llama a una función de importación en el módulo que se utiliza d para cargar explícitamente la lista de funciones exportadas en tiempo de compilación, ahorrando así el tiempo requerido para una resolución explícita de un nombre de función durante la ejecución. El uso de la instrucción use cambia el espacio de nombres de los programas porque los nombres de las funciones importadas se insertan en la tabla de símbolos. La instrucción require no altera el espacio de nombres de los programas. Por lo tanto, el siguiente uso de sentencia ModuleName () es equivalente a esta sentencia: require ModuleName Las funciones se importan de un módulo a través de una llamada a una función llamada import. Puede escribir su propia función de importación en un módulo, o puede utilizar el módulo Exportador y utilizar su función de importación. En casi todos los casos, se utilizará el módulo Exportador para proporcionar una función de importación en lugar de reinventar la rueda. Si desea no utilizar el módulo Exportador, tendrá que escribir su propia función de importación en cada módulo que escriba. Es mucho más fácil simplemente usar el módulo Exportador y dejar Perl hacer el trabajo para usted. Módulo Sample Letter. pm La mejor manera de ilustrar la semántica de cómo se usa un módulo en Perl es escribir un módulo simple y mostrar cómo usarlo. Tomemos el ejemplo de un tiburón de préstamo local, Rudious Maximus, que simplemente está cansado de escribir el mismo quotrequest para cartas de pago. Al ser un ávido fan de las computadoras y Perl, Rudious toma el enfoque de los programadores perezosos y escribe un módulo Perl para ayudarle a generar sus memorandos y cartas. Ahora, en lugar de escribir dentro de los campos en un archivo de plantilla de memo, todo lo que tiene que hacer es escribir unas líneas para producir su nota agradable y amenazante. El Listado 4.1 le muestra lo que tiene que escribir. Listado 4.1. Uso del módulo Carta. 1 / usr / bin / perl - w 2 3 Descomente la línea de abajo para incluir el directorio actual en Inc. 4 push (Inc, pwd) 5 6 use Letter 7 8 Letter :: To (quotMr. Gambling Manquot, quotThe money for Lucky Perro, Raza 2quot) 9 Carta :: ClaimMoneyNice () 10 Letter :: ThankDem () 11 Letter :: Finish () La instrucción Letter de uso está presente para obligar al intérprete de Perl a incluir el código para el módulo en el programa de aplicación. El módulo debe ubicarse en el directorio / usr / lib / perl5 /, o puede colocarlo en cualquier directorio listado en la matriz Inc. La matriz Inc es la lista de directorios que el intérprete de Perl buscará al intentar cargar el código para el módulo nombrado. La línea comentada (número 4) muestra cómo agregar el directorio de trabajo actual para incluir la ruta. Las siguientes cuatro líneas del archivo generan el tema de la carta. Heres la salida de usar el módulo de la letra: A: Sr. Gambling Man Fm: Rudious Maximus, Shark del préstamo Dt: Mie Feb 7 10:35:51 CST 1996 Re: El dinero para el perro afortunado, raza 2 Ha venido a mi atención Que su cuenta está por encima de debido. Nos vas a pagar pronto o te gustaría que viniera ovah Gracias por tu apoyo. El archivo del módulo Carta se muestra en el listado 4.2. El nombre del paquete se declara en la primera línea. Debido a que las funciones de este módulo se exportan, yo uso el módulo Exportador. Por lo tanto, el uso de la instrucción Exportador debe heredar la funcionalidad del módulo Exportador. Otro paso necesario es poner la palabra exportada en la matriz ISA para permitir la búsqueda de Exported. pm. La matriz ISA es una matriz especial dentro de cada paquete. Cada elemento de la matriz muestra dónde buscar un método si no se encuentra en el paquete actual. El orden en el que los paquetes se enumeran en la matriz ISA es el orden en que Perl busca símbolos no resueltos. Una clase que se muestra en la matriz ISA se conoce como la clase base de esa clase en particular. Perl almacenará en caché los métodos faltantes encontrados en las clases base para futuras referencias. La modificación de la matriz ISA descargará la caché y hará que Perl vuelva a buscar todos los métodos. Veamos ahora el código de Letter. pm en el Listado 4.2. Listado 4.2. El módulo Letter. pm. 1 paquete Carta 2 3 requieren Exportador 4 ISA (Exportador) 5 6 head1 NOMBRE 7 8 Carta - Módulo de muestra para generar encabezados para usted 9 10 head1 SINOPSIS 11 12 use Letter 13 14 Letter :: Date () 15 Letter :: To (name , La dirección de la empresa) 16 17 Una de las siguientes: 18 Carta :: ClaimMoneyNice () 19 Carta :: ClaimMoney () 20 Carta :: ThreatBreakLeg () 21 22 Carta :: ThankDem () 23 Letter :: Finish () 24 25 head1 DESCRIPCIÓN 26 27 Este módulo proporciona un breve ejemplo de la generación de una carta para un tiburón de préstamo agradable de vecino. 29 30 El código comienza después de la sentencia quotcutquot. 31 corte 32 33 EXPORTACIÓN qw (Fecha, 34 A, 35 ReclamaciónMoney, 36 ReclamaciónMoneyNice, 37 Agradecimiento, 38 Finalización) 39 40 41 Impresión de la fecha de hoy 42 43 sub Letra :: Fecha 44 fecha fecha 45 impresión quotn Hoy es la fecha 46 47 48 sub Letra :: A 49 cambio local (nombre) 50 cambio local (sujeto) 51 impresión quotn A: nombrequot 52 impresión quotn Fm: Rudious Maximus, Préstamo Sharkquot 53 impresión quotn Dt: quot, fecha 54 impresión quotn Re: subjectquot 55 print quotnnquot 56 Print quotnnquot 57 58 sub Letra :: ClaimMoney () 59 print quotn Me debes dinero. Quieres que envíe a Bruno a quot 61 imprimir quotn recogerlo. O vas a pagar 62 63 64 sub Letra :: ClaimMoneyNice () 65 imprimir quotn Se ha llegado a mi atención que su cuenta es quotn 66 impresión quotn camino más de debido. quot 67 imprimir quotn Usted va a pagar pronto ... 68 Imprimir quotn o le gustaría que me vienen ovahquot 69 70 71 sub Letter :: ThreatBreakLeg () 72 imprimir quotn aparentemente cartas como estas no helpquot 73 imprimir quotn Voy a tener que hacer un ejemplo de youquot 74 imprimir quotn n Nos vemos en el hospital , Palquot 75 76 77 sub Letra :: ThankDem () 78 print quotnn Gracias por su apoyo 79 80 81 sub Letter :: Finish () 82 printf quotnnnn Sinceramentequot 83 printf quotn Rudious n quot 84 85 86 1 Se utilizan líneas que contienen el signo de igual Para la documentación. Debe documentar cada módulo para su propia referencia Los módulos Perl no necesitan ser documentados, pero es una buena idea escribir algunas líneas sobre lo que hace su código. Dentro de unos años, usted puede olvidar lo que es un módulo. Una buena documentación es siempre una necesidad si desea recordar lo que hizo en el pasado. Cubro los estilos de documentación utilizados para Perl en el capítulo 8. quotDocumenting Perl Scripts. quot Para este módulo de ejemplo, la instrucción head1 comienza la documentación. El intérprete de Perl ignora todo hasta la sentencia de corte. A continuación, el módulo lista todas las funciones exportadas por este módulo en la matriz EXPORT. La matriz EXPORT define todos los nombres de funciones que pueden ser llamados por código externo. Si no se lista una función en esta matriz EXPORT, no será visto por módulos de código externos. Después de la matriz EXPORT es el cuerpo del código, una subrutina a la vez. Después de definir todas las subrutinas, la instrucción final 1 termina el archivo de módulo. 1 debe ser la última línea ejecutable en el archivo. Veamos algunas de las funciones definidas en este módulo. La primera función a observar es la simple función de fecha, líneas 43 a 46, que imprime la fecha y hora actuales de UNIX. No hay parámetros para esta función, y no devuelve nada significativo a la persona que llama. Tenga en cuenta el uso de mi antes de la variable de fecha en la línea 44. La palabra clave mi se utiliza para limitar el alcance de la variable a dentro de las funciones de fecha rizadores. El código entre llaves se refiere como un bloque. Las variables declaradas dentro de un bloque tienen un alcance limitado dentro de las llaves. En 49 y 50, el nombre de las variables locales y el sujeto son visibles para todas las funciones. También puede declarar variables con el calificador local. El uso de local permite que una variable esté en alcance para el bloque actual así como para otros bloques de código llamados desde dentro de este bloque. Así, una x local declarada dentro de un bloque es visible para todos los bloques subsiguientes llamados desde dentro de este bloque y puede ser referenciado. En el siguiente código de ejemplo, se puede acceder a la variable de nombre de funciones ToTitled pero no a los datos en iphone. 1 sub Letter :: ToTitled 2 local (nombre) shift 3 my (phone) shift El código de ejemplo para Letter. pm mostró cómo extraer un parámetro a la vez. La subrutina To () toma dos parámetros para configurar el encabezado para el memo. El uso de funciones dentro de un módulo no es diferente de usar y definir módulos Perl dentro del mismo archivo de código. Los parámetros se pasan por referencia a menos que se especifique lo contrario. Múltiples matrices pasan a una subrutina, si no se desreferencia explícitamente usando la barra invertida, se concatenan. La matriz de entrada en una función es siempre una matriz de valores escalares. Pasar valores por referencia es la forma preferida en Perl para pasar una gran cantidad de datos a una subrutina. (Véase el capítulo 3. quotReferences. quot) Otro Módulo de Muestra: Finanzas El módulo de Finanzas, que se muestra en el Listado 4.3, se utiliza para proporcionar cálculos simples para los valores del préstamo. Usar el módulo de Finanzas es sencillo. Todas las funciones se escriben con los mismos parámetros, como se muestra en la fórmula para las funciones. Veamos cómo se puede calcular el valor futuro de una inversión. Por ejemplo, si usted invierte algunos dólares, pv. En un bono que ofrece un porcentaje fijo, r. Aplicada a intervalos conocidos durante n periodos de tiempo, cuál es el valor del enlace en el momento de su vencimiento En este caso, usará la siguiente fórmula: fv pv (1r) n La función para obtener el valor futuro se declara como FutureValue . Consulte el Listado 4.3 para ver cómo usarlo. Listado 4.3. Uso del módulo Finanzas. 1 / usr / bin / perl - w 2 3 push (Inc, pwd) 4 uso Finanzas 5 6 préstamo 5000.00 7 abr 3.5 APR 8 año 10 en años. 9 10 ------------------------------------------------ ---------------- 11 Calcule el valor al final del préstamo si se aplican intereses 12 cada año. 13 ------------------------------------------------- --------------- 14 año de tiempo 15 fv1 Finanzas :: FutureValue (préstamo, abril, tiempo) 16 print quotn Si se aplica interés al final del año 17 print quotn El valor futuro para un Préstamo de quot. préstamo. Quotnquot 18 print quot en una APR de quot, abr. Quot for quot, time, quot yearsquot 19 printf quot is 8.2f nquot. Fv1 20 21 ----------------------------------------------- ----------------- 22 Calcule el valor al final del préstamo si el interés 23 se aplica cada mes. 24 ------------------------------------------------- --------------- 25 tasa apr / 12 APR 26 tiempo año 12 en meses 27 fv2 Finanzas :: FutureValue (préstamo, tasa, tiempo) 28 29 imprimir quotn Si se aplica interés al final De cada mesquot 30 print quotn El valor futuro para un préstamo de quotn. préstamo. Quotnquot 31 print quot en una APR de quot, abr. Quot for quot, time, quot monthsquot 32 printf quot is 8.2f nquot. Fv2 33 34 printf quotn La diferencia de valor es 8.2fquot, fv2 - fv1 35 printf quotn Por lo tanto, al aplicar el interés en periodos de tiempo más cortos en 36 printf quotn estamos recibiendo más dinero en interest. nquot Aquí está la muestra de entrada y salida del listado 4.3. Testme Si el interés se aplica al final del año El valor futuro para un préstamo de 5000 a una TAE de 3,5 por 10 años es 7052.99 Si se aplica el interés al final de cada mes El valor futuro para un préstamo de 5000 a una TAE de 3,5 para 120 meses es 7091.72 La diferencia en el valor es 38.73 Por lo tanto, al aplicar el interés en períodos de tiempo más cortos que realmente están recibiendo más dinero en interés. La revelación en la salida es el resultado de la comparación de valores entre fv1 y fv2. El valor fv1 se calcula con la aplicación de intereses una vez al año durante la vida del bono. Fv2 es el valor si el interés se aplica cada mes al tipo de interés mensual equivalente. El paquete Finance. pm se muestra en el listado 4.4 en sus primeras etapas de desarrollo. Listado 4.4. El paquete Finance. pm. 1 paquete Finanzas 2 3 requieren Exportador 4 ISA (Exportador) 5 6 head1 Finance. pm 7 8 Calculadora financiera - Cálculos financieros simplificados con Perl 9 10 cabeza 2 11 uso Finanzas 12 13 pv 10000.0 14 15 tasa 12.5 / 12 APR por mes. 16 17 tiempo 360 meses para que el préstamo madure 18 19 fv FutureValue () 20 21 impresión fv 22 23 recorte 24 25 EXPORTACIÓN qw (FutureValue, 26 PresentValue, 27 FVofAnnuity, 28 AnnuityOfFV, 29 getLastAverage, 30 getMovingAverage, 31 SetInterest) 32 33 34 Globals, si hay alguno 35 36 37 default localInterest 5.0 38 39 sub Finanzas :: SetInterest () 40 mi cambio de velocidad () 41 defaultTest de interés 42 printf quotn defaultInterest ratequot 43 44 45 -------------- -------------------------------------------------- ---- 46 Notas: 47 1. El tipo de interés r se da en un valor de 0-100. 48 2. El n dado en los términos es la tasa a la que se aplica el interés 49. 50 51 ------------------------------------------------ -------------------- 52 53 ---------------------------- ---------------------------------------- 54 Valor presente de una inversión dada 55 fv - Un valor futuro 56 r - tasa por período 57 n - número de período 58 ---------------------------------- ---------------------------------- 59 sub Finanzas :: FutureValue () 60 my (pv, r, n ) 61 mi fv pv ((1 (r / 100)) n) 62 retorno fv 63 64 65 ---------------------------- ---------------------------------------- 66 Valor presente de una inversión dada 67 fv - Un valor futuro 68 r - tasa por período 69 n - número del período 70 ---------------------------------- ---------------------------------- 71 sub Finanzas :: PresentValue () 72 mi pv 73 mi (fv, R, n) 74 pv fv / ((1 (r / 100)) n) 75 pv de retorno 76 77 78 79 ------------------------ -------------------------------------------- 80 Obtenga el valor futuro de Una anualidad dada 81 mp - Pago Mensual de Anualidad 82 r - tasa por período 83 n - número del período 84 --------------------------- ----------------------------------------- 85 86 sub FVofAnnuity () 87 mi fv 88 mi unoR 89 mi (mp, r, n) 90 91 unR (1 r) n 92 fv mp ((unoR - 1) / r) 93 retorno fv 94 95 96 ------------ -------------------------------------------------- ------ 97 Obtener la anualidad de los siguientes bits de información 98 r - tasa por período 99 n - número de período 100 fv - Valor futuro 101 ---------------- -------------------------------------------------- - 102 103 sub AnnuityOfFV () 104 mi mp mp - Pago mensual de la anualidad 105 mi unoR 106 mi (fv, r, n) 107 108 unR (1 r) n 109 mp fv (r / (unoR - 1)) 110 Return mp 111 112 113 --------------------------------------------- ----------------------- 114 Obtenga el promedio de los últimos valores quotnquot en una matriz. 115 ------------------------------------------------- ------------------- 116 El último número de conteo de elementos de la matriz en valores 117 El número total de elementos en valores está en el número 118 119 sub getLastAverage () 120 my (Recuento, número, valores) 121 my i 122 123 my a 0 124 return 0 si (count 0) 125 para (i 0 ilt count i) 126 a valoresnumber - i - 1 127 128 return a / count 129 130 131 - -------------------------------------------------- ---------------- 132 Obtener una media móvil de los valores. 133 ------------------------------------------------- ------------------- 134 El tamaño de la ventana es el primer parámetro, el número de elementos en la matriz pasada 135 es el siguiente. (Esto se puede calcular fácilmente dentro de la función 136 usando la función scalar (), pero la subrutina mostrada aquí 137 también se está usando para ilustrar cómo pasar los punteros.) La referencia a la matriz de valores 138 se pasa después, seguida por una Referencia al lugar en el que se almacenarán los valores de retorno. 140 141 sub getMovingAve () 142 mi (cuenta, número, valores, movingAve) 143 mi i 144 mi a 0 145 mi v 0 146 147 devuelve 0 si (cuenta 0) (Contando lt 2) 150 151 moviendoAve0 0 152 moviendoAveno - 1 0 153 para (i0 iltcounti) 154 v valuesi 155 av / count 156 movingAvei 0 157 158 para (icount número) 159 v valuesi 160 av / count 161 v valuesi - Count - 1 162 a - v / count 163 movingAvei a 164 165 return 0 166 167 168 1 Consulte la declaración de la función FutureValue con (). Los signos de tres dólares juntos significan tres números escalares que pasan a la función. Este escopo extra está presente para validar el tipo de parámetros pasados a la función. Si tuvieras que pasar una cadena en lugar de un número en la función, obtendrías un mensaje muy similar a éste: Demasiados argumentos para Finance :: FutureValue en ./f4.pl línea 15, cerca de quottime) quot Ejecución de. /f4.pl abortado debido a errores de compilación. El uso de prototipos al definir funciones impide enviar valores distintos de los que la función espera. Utilice o para pasar en una matriz de valores. Si está pasando por referencia, use o para mostrar una referencia escalar a una matriz o hash, respectivamente. Si no utiliza la barra invertida, se ignoran todos los demás tipos del prototipo de la lista de argumentos. Otros tipos de descalificadores incluyen un esperma para una referencia a una función, un asterisco para cualquier tipo y un punto y coma para indicar que todos los demás parámetros son opcionales. Ahora, veamos la declaración de la función lastMovingAverage, que especifica dos enteros en el frente seguido de una matriz. La forma en que se usan los argumentos en la función es asignar un valor a cada uno de los dos escalares, count y number. Mientras que todo lo demás se envía a la matriz. Observe la función getMovingAverage () para ver cómo se pasan dos matrices para obtener el promedio móvil en una lista de valores. La forma de llamar a la función getMovingAverage se muestra en el Listado 4.5. Listado 4.5. Uso de la función de promedio móvil. 1 / usr / bin / perl - w 2 3 push (Inc, pwd) 4 uso Finanzas 5 6 valores (12,22,23,24,21,23,24,23,23,21,29,27,26, 28) 7 mv (0) 8 size scalar (valores) 9 print quotn Valores para trabajar con nquot 10 print quot Número de valores size nquot 11 12 ------------------- --------------------------------------------- 13 Calcular el promedio de La función anterior 14 ---------------------------------------------- ------------------ 15 ave Finanzas :: getLastAverage (5, size, values) 16 print quotn Promedio de los últimos 5 días ave nquot 17 18 Finanzas :: getMovingAve (5, Tamaño, valores, mv) 19 print quotn Promedio móvil con ventana de 5 días n nquot Heres la salida del listado 4.5: Valores para trabajar con Número de valores 14 Promedio de los últimos 5 días 26.2 La función getMovingAverage () toma dos escalares y luego dos referencias A arreglos como escalares. Dentro de la función, los dos escalares a las matrices son dereferenced para el uso como arrays numéricos. El conjunto de valores devueltos se inserta en el área pasada como segunda referencia. Si los parámetros de entrada no se hubieran especificado con cada matriz referenciada, la referencia del array movingAve estaría vacía y habría causado errores en tiempo de ejecución. En otras palabras, la siguiente declaración no es correcta: sub getMovingAve () El resultado de mensajes de error de un prototipo de función incorrecta es el siguiente: Uso del valor no inicializado en la línea Finance. pm 128. Uso del valor no inicializado en la línea Finance. pm 128. Uso del valor no inicializado en Finance. pm línea 128. Uso del valor no inicializado en Finance. pm línea 128. Uso del valor no inicializado en Finance. pm línea 128. Uso del valor no inicializado en Finance. pm línea 133. Uso de valor no inicializado En Finance. pm línea 135. Uso del valor no inicializado en Finance. pm línea 133. Uso del valor no inicializado en Finance. pm línea 135. Uso del valor no inicializado en Finance. pm línea 133. Uso de uninitialized valor en Finance. pm línea 135 Uso del valor no inicializado en Finance. pm línea 133. Uso del valor no inicializado en Finance. pm línea 135. Uso del valor no inicializado en Finance. pm línea 133. Uso del valor no inicializado en Finance. pm línea 135. Uso de valor no inicializado en Finance. pm line 133. Use of uninitialized value at Finance. pm line 135. Use of uninitialized value at Finance. pm line 133. Use of uninitialized value at Finance. pm line 135. Use of uninitialized value at Finance. pm line 133. Use of uninitialized value at Finance. pm line 135. Use of uninitialized value at Finance. pm line 133. Use of uninitialized value at Finance. pm line 135. Average of last 5 days 26.2 Moving Average with 5 days window This is obviously not the correct output. Therefore, its critical that you pass by reference when sending more than one array. Global variables for use within the package can also be declared. Look at the following segment of code from the Finance. pm module to see what the default value of the Interest variable would be if nothing was specified in the input. (The current module requires the interest to be passed in, but you can change this.) Heres a little snippet of code that can be added to the end of the program shown in Listing 4.5 to add the ability to set interest rates. 20 local defaultInterest 5.0 21 sub Finance::SetInterest() 22 my rate shift() 23 rate -1 if (rate lt 0) 24 defaultInterest rate 25 printf quotn defaultInterest ratequot 26 The local variable defaultInterest is declared in line 20. The subroutine SetInterest to modify the rate is declared in lines 21 through 26. The rate variable uses the values passed into the subroutine and simply assigns a positive value for it. You can always add more error checking if necessary. To access the defaultInterest variables value, you could define either a subroutine that returns the value or refer to the value directly with a call to the following in your application program: Finance::defaultInterest The variable holding the return value from the module function is declared as my variable . The scope of this variable is within the curly braces of the function only. When the called subroutine returns, the reference to my variable is returned. If the calling program uses this returned reference somewhere, the link counter on the variable is not zero therefore, the storage area containing the returned values is not freed to the memory pool. Thus, the function that declares my pv and then later returns the value of pv returns a reference to the value stored at that location. If the calling routine performs a call like this one: Finance::FVofAnnuity(monthly, rate, time) there is no variable specified here into which Perl stores the returned reference therefore, any returned value (or a list of values) is destroyed. Instead, the call with the returned value assigned to a local variable, such as this one: fv Finance::FVofAnnuity(monthly, rate, time) maintains the variable with the value. Consider the example shown in Listing 4.6, which manipulates values returned by functions. Listing 4.6. Sample usage of the my function. 1 /usr/bin/perl - w 2 3 push(Inc, pwd) 4 use Finance 5 6 monthly 400 7 rate 0.2 i. e. 6 APR 8 time 36 in months 9 10 print quotn ------------------------------------------------quot 11 fv Finance::FVofAnnuity(monthly, rate, time) 12 printf quotn For a monthly 8.2f at a rate of 6.2f for d periodsquot, 13 monthly, rate, time 14 printf quotn you get a future value of 8.2f quot, fv 15 16 fv 1.1 allow 10 gain in the house value. 17 18 mo Finance::AnnuityOfFV(fv, rate, time) 19 20 printf quotn To get 10 percent more at the end, i. e. 8.2fquot, fv 21 printf quotn you need a monthly payment value of 8.2fquot, mo, fv 22 23 print quotn ------------------------------------------------ nquot Here is sample input and output for this function: testme ------------------------------------------------ For a monthly 400.00 at a rate of 0.20 for 36 periods you get a future value of 1415603.75 To get 10 percent more at the end, i. e. 1557164.12 you need a monthly payment value of 440.00 ------------------------------------------------ Modules implement classes in a Perl program that uses the object-oriented features of Perl. Included in object-oriented features is the concept of inheritance . (Youll learn more on the object-oriented features of Perl in Chapter 5. quotObject-Oriented Programming in Perl. quot) Inheritance means the process with which a module inherits the functions from its base classes. A module that is nested within another module inherits its parent modules functions. So inheritance in Perl is accomplished with the :: construct. Heres the basic syntax: SuperClass::NextSubClass. ThisClass. The file for these is stored in ./SuperClass/NextSubClass/133 . Each double colon indicates a lower-level directory in which to look for the module. Each module, in turn, declares itself as a package with statements like the following: package SuperClass::NextSubClass package SuperClass::NextSubClass::EvenLower For example, say that you really want to create a Money class with two subclasses, Stocks and Finance . Heres how to structure the hierarchy, assuming you are in the /usr/lib/perl5 directory: Create a Money directory under the /usr/lib/perl5 directory. Copy the existing Finance. pm file into the Money subdirectory. Create the new Stocks. pm file in the Money subdirectory. Edit the Finance. pm file to use the line package Money::Finance instead of package Finance . Edit scripts to use Money::Finance as the subroutine prefix instead of Finance:: . Create a Money. pm file in the /usr/lib/perl5 directory. The Perl script that gets the moving average for a series of numbers is presented in Listing 4.7. Listing 4.7. Using inheriting modules. 1 /usr/bin/perl - w 2 aa pwd 3 aa . quot/Moneyquot 4 push(Inc, aa) 5 use Money::Finance 6 values ( 12,22,23,24,21,23,24,23,23,21,29,27,26,28 ) 7 mv (0) 8 size scalar(values) 9 print quotn Values to work with nquot 10 print quot Number of values size nquot 11 ---------------------------------------------------------------- 12 Calculate the average of the above function 13 ---------------------------------------------------------------- 14 ave Money::Finance::getLastAverage(5,size, values) 15 print quotn Average of last 5 days ave nquot 16 Money::Finance::getMovingAve(5,size, values, mv) 17 foreach i (values) 18 print quotn Moving with 5 days window mvi nquot 19 20 print quotn Moving Average with 5 days window n nquot Lines 2 through 4 add the path to the Money subdirectory. The use statement in line 5 now addresses the Finance. pm file in the ./Money subdirectory. The calls to the functions within Finance. pm are now called with the prefix Money::Finance:: instead of Finance:: . Therefore, a new subdirectory is shown via the :: symbol when Perl is searching for modules to load. The Money. pm file is not required. Even so, you should create a template for future use. Actually, the file would be required to put any special requirements for initialization that the entire hierarchy of modules uses. The code for initialization is placed in the BEGIN() function. The sample Money. pm file is shown in Listing 4.8. Listing 4.8. The superclass module for Finance. pm . 1 package Money 2 require Exporter 3 4 BEGIN 5 printf quotn Hello Zipping into existence for younquot 6 7 1 To see the line of output from the printf statement in line 5, you have to insert the following commands at the beginning of your Perl script: use Money use Money::Finance To use the functions in the Stocks. pm module, you use this line: use Money::Stocks The Stocks. pm file appears in the Money subdirectory and is defined in the same format as the Finance. pm file, with the exceptions that use Stocks is used instead of use Finance and the set of functions to export is different. A number of modules are included in the Perl distribution. Check the /usr/lib/perl5/lib directory for a complete listing after you install Perl. There are two kinds of modules you should know about and look for in your Perl 5 release, Pragmatic and Standard modules. Pragmatic modules, which are also like pragmas in C compiler directives, tend to affect the compilation of your program. They are similar in operation to the preprocessor elements of a C program. Pragmas are locally scoped so that they can be turned off with the no command. Thus, the command no POSIX turns off the POSIX features in the script. These features can be turned back on with the use statement. Standard modules bundled with the Perl package include several functioning packages of code for you to use. Refer to appendix B, quotPerl Module Archives, quot for a complete list of these standard modules. To find out all the. pm modules installed on your system, issue the following command. (If you get an error, add the /usr/lib/perl5 directory to your path.) find /usr/lib/perl5 - name perl quot. pmquot - print Extension modules are written in C (or a mixture of Perl and C) and are dynamically loaded into Perl if and when you need them. These types of modules for dynamic loading require support in the kernel. Solaris lets you use these modules. For a Linux machine, check the installation pages on how to upgrade to the ELF format binaries for your Linux kernel. The term CPAN (Comprehensive Perl Archive Network) refers to all the hosts containing copies of sets of data, documents, and Perl modules on the Net. To find out about the CPAN site nearest you, search on the keyword CPAN in search engines such as Yahoo. AltaVista, or Magellan. A good place to start is the metronet site . This chapter introduced you to Perl 5 modules and described what they have to offer. A more comprehensive list is found on the Internet via the addresses shown in the Web sites metronet and perl . A Perl package is a set of Perl code that looks like a library file. A Perl module is a package that is defined in a library file of the same name. A module is designed to be reusable. You can do some type checking with Perl function prototypes to see whether parameters are being passed correctly. A module has to export its functions with the EXPORT array and therefore requires the Exporter module. Modules are searched for in the directories listed in the Inc array. Obviously, there is a lot more to writing modules for Perl than what is shown in this chapter. The simple examples in this chapter show you how to get started with Perl modules. In the rest of the book I cover the modules and their features, so hang in there. I cover Perl objects, classes, and related concepts in Chapter 5.Thanks for the feedback already. In the above code the 39input39 is from a sensor that is being read every 100ms so for however many samples (39count39) I choose to look at the max value returned. I would think return max(dataset) would be work fine. I just don39t know how to generate the dataset from the 39input39. The data set needs to constantly update with the new inputs while the oldest data is dropped. The perl interpreter is built into automotive diagnostic software so the method above calc() is how it needs to be done. ndash Primiano19 Aug 24 12 at 16:45 Well, I39m out of my element with PDL. I assumed there would be a max() function and googled it. But as for creating piddles from data, I39d just end up reading the PDL docs for you. ndash Len Jaffe Aug 24 12 at 18:48 EDIT: Here is the loop I take it you need. Read input data from sensor append new data to stored data Throw away excess data Evaluate Heres how Id do it. Im not sure if this answers your question, but your comment below seems pretty different from the question you have above. Consider editing the above to better reflect what youre having trouble with or asking a new question. An easy way to get a running average is with a finite impulse response filter, aka convolution. Convolve any signal with a (normalized) rectangular impulse and you get running average. There is one thing to be careful of with this method, which is that the values at the beginning and end of the runningAve piddle arent really running averages. To ensure that the output is the same size as the input convolveND (by default) effectively concatenates zeroes to the beginning and end of the input, the result being that the first and last few elements of runningAve are lower than actual running averages. (Note that a running average should have N - (window - 1) elements in principle, N being the size of input .) Since these bad values will necessarily be lower than the actual running average values, they wont disturb the maximum that you want. (Re by default: convolveND has other ways of handling edges, as you will see in the documentation linked to above.) (NB: I am not a PDL expert. There may be a cheaper way to get the running average thats cheaper than convolveND, something like ra input-gtrange(. )-gtsumover(0) / count. but I dont know what youd put in the. and the above is readable. See also search. cpan. org/ Part of my problem is that I really don39t know enough about Perl and how Perl handles data. Does it automatically store the incoming data as an array of some form Anyway, despite my Perl ineptitude this is what I need (in human), and it needs to follow the structure of the code example in my OP as sub calc . ndash Primiano19 Oct 4 12 at 19:39Moving Averages - Simple and Exponential Moving Averages - Simple and Exponential Introduction Moving averages smooth the price data to form a trend following indicator. They do not predict price direction, but rather define the current direction with a lag. Moving averages lag because they are based on past prices. A pesar de este retraso, las medias móviles ayudan a suavizar la acción de los precios y filtran el ruido. También forman los bloques de construcción de muchos otros indicadores técnicos y superposiciones, como Bollinger Bands. MACD y el oscilador de McClellan. Los dos tipos más populares de promedios móviles son el promedio móvil simple (SMA) y el promedio móvil exponencial (EMA). Estos promedios móviles pueden usarse para identificar la dirección de la tendencia o definir niveles potenciales de soporte y resistencia. Aquí hay un gráfico con un SMA y un EMA en él: Cálculo del promedio móvil simple Un promedio móvil simple se forma computando el precio medio de un título sobre un número específico de períodos. La mayoría de las medias móviles se basan en los precios de cierre. Una media móvil simple de 5 días es la suma de cinco días de los precios de cierre dividida por cinco. Como su nombre lo indica, un promedio móvil es un promedio que se mueve. Los datos antiguos se eliminan a medida que vienen disponibles nuevos datos. Esto hace que el promedio se mueva a lo largo de la escala de tiempo. A continuación se muestra un ejemplo de un promedio móvil de 5 días que evoluciona en tres días. El primer día de la media móvil simplemente cubre los últimos cinco días. El segundo día de la media móvil desciende el primer punto de datos (11) y añade el nuevo punto de datos (16). El tercer día de la media móvil continúa cayendo el primer punto de datos (12) y añadiendo el nuevo punto de datos (17). En el ejemplo anterior, los precios aumentan gradualmente de 11 a 17 en un total de siete días. Observe que la media móvil también aumenta de 13 a 15 durante un período de cálculo de tres días. También observe que cada valor promedio móvil es justo debajo del último precio. Por ejemplo, el promedio móvil para el primer día es igual a 13 y el último precio es 15. Los precios de los cuatro días anteriores fueron más bajos y esto hace que el promedio móvil se retrasa. Cálculo del promedio móvil exponencial Los promedios móviles exponenciales reducen el retraso aplicando más peso a los precios recientes. La ponderación aplicada al precio más reciente depende del número de periodos de la media móvil. Hay tres pasos para calcular una media móvil exponencial. En primer lugar, calcular el promedio móvil simple. Un promedio móvil exponencial (EMA) tiene que comenzar en alguna parte así que una media móvil simple se utiliza como EMA anterior del período anterior en el primer cálculo. Segundo, calcule el multiplicador de ponderación. En tercer lugar, calcular la media móvil exponencial. La siguiente fórmula es para una EMA de 10 días. Una media móvil exponencial de 10 períodos aplica una ponderación de 18.18 al precio más reciente. Un EMA de 10 periodos también puede ser llamado un EMA 18.18. Una EMA de 20 periodos aplica una ponderación de 9.52 al precio más reciente (2 / (201) .0952). Observe que la ponderación para el período de tiempo más corto es más que la ponderación para el período de tiempo más largo. De hecho, la ponderación disminuye a la mitad cada vez que el período de media móvil se duplica. Si desea un porcentaje específico para un EMA, puede usar esta fórmula para convertirlo en períodos de tiempo y luego ingresar ese valor como el parámetro EMA039s: A continuación se muestra un ejemplo de hoja de cálculo de una media móvil sencilla de 10 días y un valor de 10- Promedio móvil exponencial para Intel. Los promedios móviles simples son directos y requieren poca explicación. El promedio de 10 días se mueve simplemente mientras que nuevos precios están disponibles y los viejos precios caen apagado. El promedio móvil exponencial comienza con el valor de la media móvil simple (22,22) en el primer cálculo. Después del primer cálculo, la fórmula normal se hace cargo. Debido a que un EMA comienza con un promedio móvil simple, su verdadero valor no se realizará hasta 20 o más períodos más tarde. En otras palabras, el valor de la hoja de cálculo Excel puede diferir del valor del gráfico debido al corto período de revisión. Esta hoja de cálculo sólo se remonta a 30 períodos, lo que significa que el efecto de la media móvil simple ha tenido 20 períodos para disipar. StockCharts se remonta al menos 250 períodos (por lo general mucho más) para sus cálculos de modo que los efectos de la media móvil simple en el primer cálculo se han disipado completamente. El factor de Lag Cuanto más largo es el promedio móvil, más el retraso. Una media móvil exponencial de 10 días abrazará los precios de cerca y se convertirá poco después de que los precios giren. Los promedios móviles cortos son como los veleros, ágiles y rápidos de cambiar. Por el contrario, una media móvil de 100 días contiene muchos datos pasados que lo ralentizan. Los promedios móviles más largos son como los petroleros oceánicos - letárgicos y lentos para cambiar. Se necesita un movimiento de precios más grande y más largo para una media móvil de 100 días para cambiar el rumbo. La tabla de arriba muestra el SampP 500 ETF con una EMA de 10 días siguiendo de cerca los precios y una molienda SMA de 100 días más alta. Incluso con la disminución de enero-febrero, la SMA de 100 días mantuvo el curso y no rechazó. La SMA de 50 días se sitúa entre los promedios móviles de 10 y 100 días cuando se trata del factor de retraso. Simples versus promedios móviles exponenciales Aunque hay claras diferencias entre promedios móviles simples y promedios móviles exponenciales, uno no es necesariamente mejor que el otro. Los promedios móviles exponenciales tienen menos retraso y, por lo tanto, son más sensibles a los precios recientes y las recientes variaciones de precios. Los promedios móviles exponenciales se convertirán antes de promedios móviles simples. Los promedios móviles simples, por otro lado, representan un verdadero promedio de precios para todo el período de tiempo. Como tales, los promedios móviles simples pueden ser más adecuados para identificar niveles de soporte o resistencia. La preferencia media móvil depende de los objetivos, el estilo analítico y el horizonte temporal. Los cartistas deben experimentar con ambos tipos de promedios móviles, así como diferentes plazos para encontrar el mejor ajuste. La siguiente tabla muestra IBM con la SMA de 50 días en rojo y la EMA de 50 días en verde. Ambos culminaron a finales de enero, pero la disminución en la EMA fue más nítida que la disminución de la SMA. La EMA apareció a mediados de febrero, pero la SMA continuó baja hasta finales de marzo. Tenga en cuenta que la SMA apareció más de un mes después de la EMA. Longitudes y plazos La longitud del promedio móvil depende de los objetivos analíticos. Promedios cortos móviles (5-20 períodos) son los más adecuados para las tendencias a corto plazo y el comercio. Los cartistas interesados en las tendencias a mediano plazo optarían por promedios móviles más largos que podrían extenderse de 20 a 60 períodos. Los inversores a largo plazo preferirán las medias móviles con 100 o más períodos. Algunas longitudes móviles son más populares que otras. El promedio móvil de 200 días es quizás el más popular. Debido a su longitud, esto es claramente una media móvil a largo plazo. A continuación, el promedio móvil de 50 días es muy popular para la tendencia a mediano plazo. Muchos cartistas utilizan los promedios móviles de 50 días y 200 días juntos. A corto plazo, una media móvil de 10 días fue muy popular en el pasado porque era fácil de calcular. Uno simplemente agregó los números y movió el punto decimal. Identificación de tendencias Las mismas señales pueden generarse utilizando promedios móviles simples o exponenciales. Como se mencionó anteriormente, la preferencia depende de cada individuo. Estos ejemplos a continuación utilizarán promedios móviles simples y exponenciales. El término media móvil se aplica a promedios móviles simples y exponenciales. La dirección de la media móvil transmite información importante sobre los precios. Una media móvil en ascenso muestra que los precios están aumentando. Una media móvil decreciente indica que los precios, en promedio, están cayendo. El aumento de la media móvil a largo plazo refleja una tendencia alcista a largo plazo. Una caída del promedio móvil a largo plazo refleja una tendencia a la baja a largo plazo. El gráfico anterior muestra 3M (MMM) con una media móvil exponencial de 150 días. Este ejemplo muestra cuán bien funcionan las medias móviles cuando la tendencia es fuerte. La EMA de 150 días rechazó en noviembre de 2007 y otra vez en enero de 2008. Observe que tomó una declinación 15 para invertir la dirección de esta media móvil. Estos indicadores rezagados identifican reversiones de tendencias a medida que ocurren (en el mejor de los casos) o después de que ocurren (en el peor). MMM continuó más bajo en marzo de 2009 y luego subió 40-50. Observe que la EMA de 150 días no apareció hasta después de este aumento. Una vez que lo hizo, sin embargo, MMM continuó más alto en los próximos 12 meses. Los promedios móviles trabajan brillantemente en fuertes tendencias. Crossovers dobles Dos medias móviles se pueden usar juntas para generar señales de cruce. En Análisis Técnico de los Mercados Financieros. John Murphy llama a esto el método de crossover doble. Los crossovers dobles implican una media móvil relativamente corta y una media móvil relativamente larga. Como con todas las medias móviles, la longitud general de la media móvil define el marco de tiempo para el sistema. Un sistema que utilice un EMA de 5 días y un EMA de 35 días se consideraría a corto plazo. Un sistema que utilizara un SMA de 50 días y un SMA de 200 días se consideraría a medio plazo, tal vez incluso a largo plazo. Un cruce alcista ocurre cuando el promedio móvil más corto cruza por encima del promedio móvil más largo. Esto también se conoce como una cruz de oro. Un crossover bajista ocurre cuando el promedio móvil más corto cruza debajo de la media móvil más larga. Esto se conoce como una cruz muerta. Los cruces de media móvil producen señales relativamente tardías. Después de todo, el sistema emplea dos indicadores retardados. Cuanto más largo sea el promedio móvil, mayor será el desfase en las señales. Estas señales funcionan muy bien cuando una buena tendencia se apodera. Sin embargo, un sistema de crossover de media móvil producirá muchos whipsaws en ausencia de una tendencia fuerte. También hay un método triple crossover que implica tres promedios móviles. De nuevo, se genera una señal cuando la media móvil más corta cruza las dos medias móviles más largas. Un simple sistema de crossover triple puede implicar promedios móviles de 5 días, 10 días y 20 días. La tabla anterior muestra Home Depot (HD) con una EMA de 10 días (línea punteada verde) y EMA de 50 días (línea roja). La línea negra es el cierre diario. El uso de un crossover promedio móvil habría dado lugar a tres whipsaws antes de coger un buen comercio. La EMA de 10 días se rompió por debajo de la EMA de 50 días a finales de octubre (1), pero esto no duró mucho ya que los 10 días retrocedieron a mediados de noviembre (2). Esta cruz duró más tiempo, pero el siguiente cruce bajista en enero (3) ocurrió cerca de finales de noviembre los niveles de precios, dando lugar a otro whipsaw. Esta cruz bajista no duró mucho ya que la EMA de 10 días retrocedió por encima de los 50 días unos días después (4). Después de tres malas señales, la cuarta señal prefiguró un movimiento fuerte mientras que la acción avanzó sobre 20. Hay dos takeaways aquí. Primero, los crossovers son propensos al whipsaw. Se puede aplicar un filtro de precio o tiempo para ayudar a prevenir las sierras. Los operadores pueden requerir que el crossover dure 3 días antes de actuar o requiera que el EMA de 10 días se mueva por encima / por debajo del EMA de 50 días por una cierta cantidad antes de actuar. En segundo lugar, MACD se puede utilizar para identificar y cuantificar estos crossovers. MACD (10, 50, 1) mostrará una línea que representa la diferencia entre las dos medias móviles exponenciales. MACD se vuelve positivo durante una cruz de oro y negativo durante una cruz muerta. El oscilador de precio porcentual (PPO) se puede utilizar de la misma manera para mostrar diferencias porcentuales. Tenga en cuenta que MACD y el PPO se basan en promedios móviles exponenciales y no coincidirá con los promedios móviles simples. Este gráfico muestra Oracle (ORCL) con EMA de 50 días, EMA de 200 días y MACD (50.200,1). Hubo cuatro crossovers de media móvil durante un período de 2 1/2 años. Los tres primeros resultaron en whipsaws o malos oficios. Una tendencia sostenida comenzó con el cuarto crossover como ORCL avanzó a mediados de los 20s. Una vez más, los crossovers medios móviles funcionan muy bien cuando la tendencia es fuerte, pero producen pérdidas en ausencia de una tendencia. Crossovers de precios Los promedios móviles también pueden usarse para generar señales con crossovers de precios simples. Una señal alcista se genera cuando los precios se mueven por encima de la media móvil. Se genera una señal bajista cuando los precios se mueven por debajo de la media móvil. Los crossovers de precios se pueden combinar para comerciar dentro de la tendencia más grande. La media móvil más larga establece el tono para la tendencia más grande y la media móvil más corta se utiliza para generar las señales. Uno buscaría cruces de precios alcistas sólo cuando los precios ya están por encima de la media móvil más larga. Esto estaría negociando en armonía con la tendencia más grande. Por ejemplo, si el precio está por encima de la media móvil de 200 días, los cartistas sólo se centrarán en las señales cuando el precio se mueve por encima de la media móvil de 50 días. Obviamente, un movimiento por debajo de la media móvil de 50 días precedería a tal señal, pero tales cruces bajistas serían ignorados porque la tendencia más grande es hacia arriba. Una cruz bajista simplemente sugeriría un retroceso dentro de una mayor tendencia alcista. Un retroceso por encima de la media móvil de 50 días señalaría una subida de los precios y la continuación de la mayor tendencia alcista. El siguiente gráfico muestra Emerson Electric (EMR) con la EMA de 50 días y EMA de 200 días. La acción se movió por encima y se mantuvo por encima de la media móvil de 200 días en agosto. Hubo bajadas por debajo de los 50 días EMA a principios de noviembre y de nuevo a principios de febrero. Los precios se movieron rápidamente por encima de la EMA de 50 días para proporcionar señales alcistas (flechas verdes) en armonía con la mayor tendencia alcista. MACD (1,50,1) se muestra en la ventana del indicador para confirmar los cruces de precios por encima o por debajo de la EMA de 50 días. El EMA de 1 día es igual al precio de cierre. El MACD (1,50,1) es positivo cuando el cierre está por encima del EMA de 50 días y negativo cuando el cierre está por debajo del EMA de 50 días. Soporte y Resistencia Los promedios móviles también pueden actuar como soporte en una tendencia alcista y resistencia en una tendencia bajista. Una tendencia alcista a corto plazo podría encontrar apoyo cerca de la media móvil simple de 20 días, que también se utiliza en bandas de Bollinger. Una tendencia alcista a largo plazo podría encontrar apoyo cerca del promedio móvil de 200 días, que es el promedio móvil más popular a largo plazo. De hecho, el promedio móvil de 200 días puede ofrecer soporte o resistencia simplemente porque es tan ampliamente utilizado. Es casi como una profecía autocumplida. El gráfico de arriba muestra el NY Composite con el promedio móvil simple de 200 días desde mediados de 2004 hasta finales de 2008. Los 200 días de apoyo brindado numerosas veces durante el avance. Una vez que la tendencia se invirtió con una ruptura de apoyo superior doble, el promedio móvil de 200 días actuó como resistencia alrededor de 9500. No espere soporte exacto y niveles de resistencia de promedios móviles, especialmente medias móviles más largas. Los mercados son impulsados por la emoción, lo que los hace propensos a los rebasamientos. En lugar de los niveles exactos, las medias móviles se pueden utilizar para identificar las zonas de apoyo o resistencia. Conclusiones Las ventajas de utilizar promedios móviles deben sopesarse contra las desventajas. Los promedios móviles son tendencia que sigue, o rezagada, los indicadores que serán siempre un paso detrás. Esto no es necesariamente una cosa mala. Después de todo, la tendencia es su amigo y es mejor el comercio en la dirección de la tendencia. Medias móviles aseguran que un comerciante está en línea con la tendencia actual. A pesar de que la tendencia es su amigo, los valores pasan una gran cantidad de tiempo en rangos comerciales, lo que hace que los promedios móviles sean ineficaces. Una vez en una tendencia, los promedios móviles le mantendrá en, pero también dar señales tardías. Don039t esperan vender en la parte superior y comprar en la parte inferior utilizando promedios móviles. Al igual que con la mayoría de las herramientas de análisis técnico, las medias móviles no deben usarse por sí solas, sino en conjunto con otras herramientas complementarias. Los cartistas pueden usar promedios móviles para definir la tendencia general y luego usar RSI para definir los niveles de sobrecompra o sobreventa. Adición de promedios móviles a los gráficos de StockCharts Los promedios móviles están disponibles como una función de superposición de precios en el workbench de SharpCharts. Utilizando el menú desplegable Superposiciones, los usuarios pueden elegir un promedio móvil simple o un promedio móvil exponencial. El primer parámetro se utiliza para establecer el número de períodos de tiempo. Se puede agregar un parámetro opcional para especificar el campo de precio que se debe utilizar en los cálculos: O para el Abierto, H para el Alto, L para el Bajo y C para el Cierre. Una coma se utiliza para separar los parámetros. Se puede agregar otro parámetro opcional para cambiar las medias móviles a la izquierda (pasado) oa la derecha (futuro). Un número negativo (-10) cambiaría la media móvil a la izquierda 10 períodos. Un número positivo (10) cambiaría la media móvil a los 10 periodos correctos. Múltiples promedios móviles pueden superponerse a la gráfica de precios simplemente agregando otra línea de superposición al workbench. Los miembros de StockCharts pueden cambiar los colores y el estilo para diferenciar entre varios promedios móviles. Después de seleccionar un indicador, abra Opciones avanzadas haciendo clic en el pequeño triángulo verde. Las Opciones avanzadas también se pueden usar para agregar una superposición de promedio móvil a otros indicadores técnicos como RSI, CCI y Volumen. Haga clic aquí para un gráfico en vivo con varios promedios móviles diferentes. Usando los promedios móviles con las exploraciones de StockCharts Aquí hay algunas exploraciones de la muestra que los miembros de StockCharts pueden utilizar para explorar diversas situaciones del promedio móvil: Movimiento alcista de la media cruzada: Esta exploraciones busca las poblaciones con una media móvil simple de 150 días y una cruz alcista de los 5 EMA y EMA de 35 días. La media móvil de 150 días está subiendo, siempre y cuando se está negociando por encima de su nivel hace cinco días. Una cruz alcista ocurre cuando la EMA de 5 días se mueve por encima de la EMA de 35 días sobre un volumen por encima del promedio. Media bajista media móvil: esta escanea busca acciones con una media móvil simple descendente de 150 días y un cruce bajista de la EMA de 5 días y de la EMA de 35 días. La media móvil de 150 días está cayendo, siempre y cuando se está negociando por debajo de su nivel hace cinco días. Una cruz bajista ocurre cuando la EMA de 5 días se mueve por debajo de la EMA de 35 días sobre un volumen por encima del promedio. Estudio adicional El libro de John Murphy tiene un capítulo dedicado a los promedios móviles ya sus diversos usos. Murphy cubre los pros y los contras de los promedios móviles. Además, Murphy muestra cómo los promedios móviles trabajan con Bollinger Bands y los sistemas comerciales basados en canales. Análisis Técnico de los Mercados Financieros John Murphy
No comments:
Post a Comment