Cpan Moving Average

Contenido Este capítulo es una introducción a los conceptos detrás de las referencias a los módulos de Perl, paquetes y clases. También le muestra cómo crear un par de módulos de muestra. 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 de la palabra paquete. Los paquetes son una característica de Perl 4, mientras que los módulos son frecuentes en Perl 5. Puede mantener todo el código Perl reutilizable específico a un conjunto de tareas en un módulo de Perl. Por lo tanto, toda la funcionalidad relacionada con un tipo de tarea está contenida en un solo archivo. Su más fácil construir una aplicación en estos bloques modulares. Por lo tanto, la palabra módulo se aplica un poco más de paquete. Aquí está una breve introducción a los módulos. Ciertos temas de esta sección se tratarán en detalle a lo largo del resto del libro. Lea los siguientes párrafos con cuidado para obtener una visión general de lo que está por venir a medida que escribe y utiliza sus propios módulos. Lo que es confuso es que el módulo términos y el paquete se utilizan indistintamente en toda la documentación Perl, y estos dos términos significan la misma cosa. Así que cuando la lectura de documentos de Perl, sólo piensa quotpackagequot cuando vea quotmodulequot y viceversa. Por lo tanto, cuál es la premisa para el uso de módulos Bueno, los módulos están ahí para empaquetar (perdón por el juego de palabras) las variables, símbolos y elementos de datos interconectadas entre sí. Por ejemplo, usando las variables globales con nombres muy comunes, tales como k. j. o i en un programa general no es una buena idea. Además, un contador de bucle, i. se debe permitir que trabajar de forma independiente en dos partes diferentes del código. Declarando i como una variable global y luego incrementarlo desde dentro de una subrutina va a crear problemas inmanejables con el código de aplicación debido a la subrutina puede haber sido llamado desde dentro de un bucle que también utiliza una variable llamada i. El uso de módulos en Perl permite que las variables con el mismo nombre que se creen en diferentes lugares, distintos en el mismo programa. Los símbolos definidos para las variables se almacenan en un array asociativo, se refiere como una tabla de símbolos. Estas tablas de símbolos son propios de un paquete. Por lo tanto, las variables del mismo nombre en dos paquetes diferentes pueden tener diferentes valores. Cada módulo tiene su propia tabla de símbolos de todos los símbolos que se declaran dentro de ella. La tabla de símbolos básicamente aísla nombres sinónimos en un módulo a otro. La tabla de símbolos define un espacio de nombres. es decir, un espacio de nombres de variables independientes para existen en. Por lo tanto, el uso de módulos, cada uno con su propia tabla de símbolos, impide una variable declarada en una sección de sobrescribir los valores de otras variables con el mismo nombre declarado en otra parte de la misma programa. Como cuestión de hecho, todas las variables en Perl pertenecen a un paquete. Las variables en un programa Perl pertenecen al paquete principal. Todos los otros paquetes dentro de un programa Perl o bien se anidan dentro de este paquete principal o existen en el mismo nivel. Hay algunas variables verdaderamente globales, tales como la matriz de controlador de señal SIG. que están a disposición de todos los demás módulos en un programa de aplicación y no puede ser aislado a través de espacios de nombres. Sólo aquellos identificadores de variables que comienzan con las letras o un guión bajo se mantienen en una tabla de símbolos módulos. Todos los otros símbolos, tales como los nombres STDIN. STDOUT. STDERR. ARGV. ARGVOUT. ENV. Cª . y SIG se ven obligados a estar en el paquete principal. El cambio entre los paquetes sólo afecta a los espacios de nombres. Todo lo que están haciendo cuando se utiliza un paquete u otro es que especifique cuáles son tabla de símbolos a utilizar como la tabla de símbolos por defecto para las operaciones de búsqueda de nombres de variables. Sólo las variables dinámicas se ven afectados por el uso de tablas de símbolos. Las variables declaradas por el uso de la palabra clave de mi todavía se resuelven con el bloque de código que sucede que residen dentro y no se hace referencia a través de tablas de símbolos. De hecho, el alcance de una declaración del paquete permanece activa sólo dentro del bloque de código se declara. Por lo tanto, si se cambia tablas de símbolos mediante el uso de un paquete dentro de una subrutina, se restaurará la tabla de símbolos original en vigor cuando se realizó la llamada cuando la subrutina retorna. Cambio de tablas de símbolos sólo afecta a las operaciones de búsqueda predeterminado de nombres de variables dinámicas. Todavía se puede hacer referencia explícita a las variables, identificadores de archivo, y así sucesivamente en un paquete específico anteponiendo packageName. al nombre de variable. Ya viste lo que era un contexto paquete utilizando las referencias en el Capítulo 3. Un contexto paquete simplemente implica el uso de la tabla de símbolos por el intérprete Perl para la resolución de nombres de variables en un programa. Al cambiar las tablas de símbolos, que está cambiando el contexto del paquete. Los módulos se pueden anidar en otros módulos. El módulo anidada puede utilizar las variables y funciones del módulo está anidado dentro. Para los módulos anidados, que tendría que utilizar ModuleName. nestedModuleName y así sucesivamente. Usando el doble de colon (::) es sinónimo con el uso de una cita posterior (). Sin embargo, el doble de colon es la preferida forma, el futuro de hacer frente a las variables dentro de los módulos. Direccionamiento explícito de las variables de módulo se realiza siempre con una referencia completa. Por ejemplo, suponga que tiene un módulo, Inversión. el cual es el paquete por defecto en uso, y que se quiere abordar otro módulo, Bonds. el cual está anidado dentro del módulo de inversión. En este caso, no se puede utilizar Bond ::. En su lugar, tendría que utilizar Inversión :: :: Bond para hacer frente a las variables y funciones dentro del módulo de Bond. El uso de Bond :: implicaría el uso de un paquete de bonos que está anidado dentro del módulo principal y no en el módulo de inversión. La tabla de símbolos para un módulo se almacena en una matriz asociativa de los nombres de los módulos adjuntas con dos puntos dobles. La tabla de símbolos para un módulo llamado Bono se conoce como la matriz asociativa Bond ::. El nombre de la tabla de símbolos para el módulo principal es el principal ::. e incluso se puede acortar a ::. Del mismo modo, todos los paquetes anidados sus símbolos han almacenado en matrices asociativas con dos puntos dobles que separan cada nivel de anidamiento. Por ejemplo, en el módulo de Bond que está anidado dentro del módulo de inversión, la matriz asociativa de los símbolos en el módulo de Bond será nombrado Inversión :: :: Bond. Un typeglob es realmente un tipo global para un nombre de símbolo. Se pueden realizar operaciones de solapamiento mediante la asignación a un typeglob. Una o más entradas en una matriz asociativa de símbolos serán utilizados cuando se utiliza una asignación a través de un typeglob. El valor real de cada entrada de la matriz asociativa es lo que se está refiriendo a cuando se utiliza la notación variableName. Por lo tanto, hay dos formas de referirse a los nombres de variables en un paquete: Inversión :: dinero de inversión :: Cuentas en el primer método, que se refieren a las variables a través de una referencia typeglob. El uso de la tabla de símbolos, Inversión ::. está implícito aquí, y Perl optimizará las operaciones de búsqueda de símbolos dinero y facturas. Esta es la forma más rápida y preferida de dirigirse a un símbolo. El segundo método utiliza una búsqueda por el valor de una variable dirigida por el dinero y las facturas en la matriz asociativa utilizada para los símbolos, Inversión :: explícitamente. Esta búsqueda se realiza de forma dinámica y no se optimiza mediante Perl. Por lo tanto, la búsqueda se verá obligado a comprobar el arreglo asociativo cada vez que se ejecuta la sentencia. Como resultado, el segundo método no es eficiente y debe ser utilizado sólo para la demostración de cómo la tabla de símbolos se implementa internamente. Otro ejemplo en esta declaración husain Kamran hace que las variables, manijas subrutinas, y archivos que se denominan mediante el símbolo Kamran a dirigirse también a través del símbolo Husain. Es decir, todas las entradas de símbolos en la tabla de símbolos con el Kamran clave ahora contendrá referencias a los símbolos que aborda el husain clave. Para evitar una asignación tan global, puede utilizar referencias explícitas. Por ejemplo, la siguiente instrucción le permitirá abordar el contenido de Husain a través de la Kamran variable. Kamran husain Sin embargo, las matrices tales Kamran y Husain no será el mismo. Sólo lo que se cambiarán las referencias explícitamente especificados. En resumen, cuando se asigna una typeglob a otro, afecta a todas las entradas en una tabla de símbolos, independientemente del tipo de variable que se hace referencia. Cuando se asigna una referencia de un tipo variable a otra, sólo están afectando una entrada en la tabla de símbolos. Un archivo de módulo Perl tiene el siguiente formato: paquete ModuleName. Insertar código del módulo. 1 El nombre del archivo tiene que ser llamado ModuleName. pm. El nombre de un módulo debe terminar en la cadena de. pm por convención. La sentencia de paquete es la primera línea del archivo. La última línea del archivo debe contener la línea 1 con el comunicado. En efecto, esto devuelve un valor verdadero al programa de aplicación utilizando el módulo. La no utilización de la declaración 1 no permitirá que el módulo se ha cargado correctamente. La sentencia de paquete le dice al intérprete Perl para comenzar con un nuevo dominio de espacio de nombres. Básicamente, todas las variables en un script de Perl pertenecen a un paquete llamado principal. Cada variable en el paquete principal puede ser referido como mainvariable. Aquí es la sintaxis para este tipo de referencias: packageNamevariableName La comilla simple () es sinónimo de los dos puntos dobles (::) del operador. Cubro más usos del operador :: en el siguiente capítulo. Por el momento, se debe recordar que las dos afirmaciones siguientes son equivalentes: packageNamevariableName packageName :: variableName La sintaxis de dos puntos dobles se considera estándar en el mundo de Perl. Por lo tanto, para mantener su legibilidad, yo uso la sintaxis de dos puntos dobles en el resto de este libro a menos que su absolutamente necesario hacer excepciones para probar un punto. El defecto del uso de un nombre de variable difiere al paquete corriente activa en el momento de la compilación. Por lo tanto, si se encuentra en el paquete Finance. pm y especifique una variable PV. la variable es en realidad igual a Finanzas :: pv. El uso de módulos de Perl: utilizar vs. requieren Usted incluye módulos de Perl en su programa mediante el uso o la declaración requerir. Aquí tiene la forma de utilizar cualquiera de estas declaraciones: utilizar ModuleName requiere ModuleName Tenga en cuenta que la extensión. pm no se utiliza en el código mostrado anteriormente. También tenga en cuenta que ni la sentencia permite que un archivo se incluye más de una vez en un programa. El valor devuelto de la verdadera (1) ya que se requiere la última declaración para dejar Perl saben que un módulo requieren d o el uso d cargado correctamente y deja que el intérprete de Perl ignorar cualquier recargas. En general, es mejor utilizar la instrucción utilización del módulo de la declaración requerir módulo en un programa de Perl para seguir siendo compatible con futuras versiones de Perl. Para los módulos, es posible que desee considerar la posibilidad de continuar a utilizar la instrucción requiere. Aquí es por qué: La sentencia use hace un poco más de trabajo que requieren la declaración en que altera el espacio de nombres del módulo que incluye otro módulo. ¿Quieres esta actualización adicional del espacio de nombres para hacerse de un programa. Sin embargo, cuando se escribe código para un módulo, puede que no desee el espacio de nombres para ser alterada a menos que su requerido explícitamente. En este caso, se requieren utilizar el comunicado. La declaración incluye requieren la ruta completa de un archivo en la matriz Inc manera que las funciones y variables en el archivo de módulos están 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 a través de una referencia explícita módulo en tiempo de ejecución con la declaración requerir. La sentencia use hace lo mismo que la requieren declaración porque actualiza la matriz Inc con rutas completas de los módulos cargados. El código de la función de uso también va un paso más allá y llama a una función de importación en el bienestar módulo de uso d para cargar explícitamente la lista de funciones exportadas en tiempo de compilación, ahorrando así el tiempo necesario para una resolución explícita de un nombre de función durante la ejecución. Básicamente, la declaración de uso es equivalente a requerir ModuleName lista ModuleName importación de funciones importadas El uso de la cuenta de utilización no cambiar su espacio de nombres de programas debido a que los nombres de las funciones importadas se insertan en la tabla de símbolos. La declaración requerirá no altera su programas de espacio de nombres. Por lo tanto, la siguiente declaración utilizar ModuleName () es equivalente a la presente declaración: Funciones requiere ModuleName se importan desde un módulo a través de una llamada a una función llamada de importación. Usted 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. (Usted aprenderá más sobre esto en la siguiente sección.) Si decide no utilizar el módulo exportador, que tendrá que escribir su propia función de importación en cada módulo que se escribe. Es mucho más fácil de usar simplemente el módulo de Perl exportador y dejar que haga el trabajo por usted. La muestra Letter. pm Módulo La mejor manera de ilustrar la semántica de cómo se utiliza un módulo en Perl es escribir un módulo simple y mostrar cómo usarlo. Tomemos el ejemplo de un usurero local Rudious Máximo, que es simplemente cansado de escribir el mismo quotrequest para las letras paymentquot. Siendo un ávido fanático de los ordenadores y Perl, Rudious adopta el enfoque programadores perezosos y escribe un módulo de Perl para ayudarle a generar sus notas y cartas. Ahora, en lugar de escribir dentro de los campos de un archivo de plantilla de notas, todo lo que tiene que hacer es escribir unas pocas líneas para producir su buena nota, amenazante. Listado 4.1 muestra lo que tiene que escribir. Listado 4.1. Con el módulo de la letra. 1 / usr / bin / perl - w 2 3 Elimine la línea siguiente para incluir el directorio actual en el Inc. 4 de empuje (Inc, pwd) 5 6 7 8 utilización Carta Carta :: A (quotMr. Manquot juegos de azar, dinero quotThe para Lucky perro, raza 2quot) 9 Carta :: ClaimMoneyNice () 10 Carta :: ThankDem () 11 Carta :: Finalizar () la sentencia use Carta está presente para forzar el intérprete Perl para incluir el código para el módulo en el programa de aplicación. El módulo debe estar ubicado en el directorio usr / lib / perl5 / directorio / o se puede colocar en cualquier directorio que aparece en la matriz Inc. La matriz Inc es la lista de directorios que el intérprete Perl tener en cuenta al intentar cargar el código para el módulo llamado. La línea comentada (número 4) muestra cómo añadir el directorio de trabajo actual para incluir la ruta. Las siguientes cuatro líneas en el archivo generan la materia objeto de la carta. Aquí está la salida de utilizar el módulo de letras: a: El Sr. Sirva el juego Fm: Rudious Máximo, Loan Shark Dt: Vie Dic 7 10:35:51 CST 1996 Re: El dinero para Lucky Dog, Carrera 2 Ha llegado a mi conocimiento que su cuenta está muy por encima de vencimiento. Usted nos va a pagar pronto O ¿me gustaría venir Ovah Gracias por su apoyo. El archivo de módulo carta se muestra en el Listado 4.2. El nombre del paquete que se declara en la primera línea. Debido a que este Módulos funciones serán exportados, utilizo el módulo exportador. Por lo tanto, se requiere que el exportador uso declaración de heredar la funcionalidad del módulo exportador. Otro paso necesario es poner la palabra que se exportan en la matriz de ISA para permitir la búsqueda de Exported. pm. La matriz de ISA es una matriz especial dentro de cada paquete. Cada elemento de las listas de matriz en otro lugar para buscar un método si no se puede encontrar en el paquete actual. El orden en que los paquetes se enumeran en la matriz de ISA es el orden en que Perl busca de símbolos sin resolver. Una clase que se muestra en la matriz de ISA se conoce como la clase base de esa clase en particular. Perl en caché métodos que faltan se encuentran en las clases base para futuras referencias. La modificación de la matriz de ISA hará que se vacíe la caché y provocar Perl para buscar todos los métodos de nuevo. Ahora veamos el código para Letter. pm en el listado 4.2. Listado 4.2. El módulo Letter. pm. 1 paquete de Carta 2 3 4 ISA requieren Exportador (exportador) 5 6 7 8 head1 NOMBRE Carta - Módulo de muestra para generar membrete para usted 9 10 11 12 SINOPSIS head1 uso Carta 13 14 Carta :: Fecha () 15 Carta :: Para (nombre , empresa, dirección) 16 17 Entonces uno de los siguientes: 18 :: Carta ClaimMoneyNice () 19 Carta :: ClaimMoney () 20 Carta :: ThreatBreakLeg () 21 22 Carta :: ThankDem () 23 Carta :: Finalizar () 24 25 26 27 head1 DESCRIPCIÓN Este módulo ofrece un breve ejemplo de cómo generar una carta de un usurero 28 neighborbood amigable. 29 30 El código comienza después de la declaración quotcutquot. 31 32 33 EXPORTAR cortar qw (Fecha, 34 A, 35 ClaimMoney, 36 ClaimMoneyNice, 37 ThankDem, 38 Finalizar) 39 40 41 Imprimir la fecha de hoy 42 43 sub Carta :: Fecha 44 Fecha 45 Fecha de impresión quotn Hoy es datequot 46 47 48 sub carta :: Para 49 local (nombre) de desplazamiento 50 local (sujeto) de cambio 51 quotn impresión Para: namequot quotn 52 de impresión Fm: Rudious Máximo, Préstamo Sharkquot quotn 53 de impresión Dt: quot, fecha 54 de impresión quotn Re: subjectquot 55 quotnnquot de impresión 56 imprimir quotnnquot 57 58 Carta sub :: ClaimMoney () 59 de impresión quotn me debes dinero. Conseguir su actuar togetherquot 60 quotn de impresión ¿Quieres que mande a Bruno a 61 quot impresión quotn recogerlo. o es usted va a pagar upquot 62 63 64 sub Carta :: ClaimMoneyNice () 65 de impresión quotn Se procede a mi atención que su cuenta es quot 66 quotn impresión de manera más due. quot 67 de impresión quotn Usted nos va a pagar 68 soon..quot quotn de impresión o le gustaría que yo vaya ovahquot 69 70 71 sub Carta :: ThreatBreakLeg () 72 quotn de impresión aparentemente cartas como éstas dont helpquot 73 quotn de impresión voy a tener que hacer un ejemplo de youquot quotn 74 print n Nos vemos en el hospital , palquot 75 76 77 sub Carta :: ThankDem () 78 de impresión quotnn Gracias por su supportquot 79 80 81 sub Carta :: Finalizar () 82 printf quotnnnn Sincerelyquot 83 printf quotn Rudious n quot se utilizan 84 85 86 1 Líneas que contienen el signo igual para la documentación. Usted debe documentar cada módulo para sus módulos propia referencia de Perl no necesitan ser documentados, pero es una buena idea para escribir unas líneas sobre lo que hace el código. Unos pocos años a partir de ahora, se le puede olvidar lo que un módulo se trata. Una buena documentación es siempre una necesidad si se quiere recordar lo que hizo en el pasado cubro estilos documentación usadas para Perl en el Capítulo 8. quotDocumenting Perl Scripts. quot Para este módulo de ejemplo, la declaración head1 comienza la documentación. Todo hasta el estado de corte es ignorado por el intérprete de Perl. A continuación, el módulo se enumeran todas las funciones exportadas por este módulo en la matriz de exportación. La matriz de exportación define todos los nombres de las funciones que pueden ser llamadas por el código externo. Si usted no incluye una función en esta matriz EXPORTACIÓN, que no será visto por los módulos de código externos. Después de la matriz de exportación es el cuerpo del código, una subrutina a la vez. Una vez definidas todas las subrutinas, la liquidación final 1 termina el archivo del módulo. 1 debe ser la última línea en el archivo ejecutable. Veamos algunas de las funciones definidas en este módulo. La primera función que mirar es la función Fecha simple, líneas 43 a 46, que imprime la fecha y la hora actual UNIX. No hay parámetros para esta función, y es imposible volver algo significativo de nuevo a la persona que llama. Tenga en cuenta el uso de mi antes de que la variable de fecha en la línea 44. El mi palabra clave se utiliza para limitar el alcance de la variable que dentro de las funciones de fecha llaves. Código entre corchetes se refiere como un bloque. Las variables declaradas dentro de un bloque están limitados en su alcance a dentro de las llaves. En 49 y 50, el nombre de las variables y sujeto son visibles para todas las funciones. También puede declarar variables con el torneo local. El uso de local permite que una variable sea de alcance para el bloque actual, así como para otros bloques de código llamadas desde dentro de este bloque. Por lo tanto, una x locales declaradas dentro de un bloque es visible para todos los bloques posteriores llamadas desde dentro de este bloque y se puede hacer referencia. En el siguiente código de ejemplo, el nombre de la variable ToTitled funciones se puede acceder a los datos, pero no en iPhone. 1 sub Carta :: ToTitled 2 local (nombre) de desplazamiento 3 mi (teléfono) cambiar el código de ejemplo para Letter. pm mostró cómo extraer un parámetro a la vez. Para la subrutina () toma dos parámetros para configurar el encabezado de la nota. Uso de las funciones dentro de un módulo no es diferente que el uso y la definición de 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 arrays pasados ​​en una subrutina, si no dejar de hacer referencia de forma explícita el uso de la barra invertida, se concatenan. La matriz de entrada en una función es siempre una matriz de valores escalares. los valores de paso por referencia es la manera preferida en Perl para pasar una gran cantidad de datos en una subrutina. (Véase el Capítulo 3. quotReferences. quot) otro módulo de la 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 de préstamo. Con 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 lazo que ofrece una tasa de porcentaje fijo, r. aplicado a intervalos conocidos para n periodos de tiempo, lo que es el valor de la fianza en el momento de su vencimiento En este caso, usted puede utilizar la siguiente fórmula: pv fv (1r) n La función para obtener el valor futuro está declarada como FutureValue . El listado 4.3 para ver cómo usarlo. Listado 4.3. Con el módulo de Finanzas. 1 / usr / bin / perl - w 2 3 push (Inc, pwd) 4 5 6 Finanzas uso préstamo 5000.00 7 apr 3,5-ABR-10 en 8 años años. 9 10 ------------------------------------------------ ---------------- 11 Calcular el valor al final del préstamo en caso de interés 12 se aplica cada año. 13 ------------------------------------------------- --------------- 14 veces el año 15 fv1 Finanzas :: FutureValue (préstamo, abril, tiempo) quotn 16 de impresión Si el interés se aplica al final de la impresión yearquot 17 quotn El valor futuro de una préstamo de quot. préstamo. quotnquot 18 quot de impresión a una TAE del quot, abr. quot quot para, tiempo, quot quot yearsquot 19 printf es 8.2f nquot. fv1 20 21 ----------------------------------------------- ----------------- 22 Calcular el valor al final del préstamo en caso de interés 23 se aplica cada mes. 24 ------------------------------------------------- --------------- 25 tasa abr / 12-ABR-26 veces el año 12 en 27 meses fv2 Finanzas :: FutureValue (préstamo, tipo, tiempo) quotn 28 29 de impresión Si el interés se aplica al final de cada 30 monthquot de impresión quotn El valor futuro de un préstamo de quot. préstamo. quotnquot 31 quot de impresión a una TAE del quot, abr. quot quot para, tiempo, quot quot monthsquot 32 printf es 8.2f nquot. fv2 33 34 printf quotn La diferencia de valor es 8.2fquot, fv2 - fv1 35 printf quotn Por lo tanto mediante la aplicación de un interés del tiempo más corto periodsquot 36 quotn printf en realidad estamos recibiendo más dinero en interest. nquot Aquí está la entrada y salida del listado 4.3 muestra. testme Si el interés se aplica al final del año El valor futuro de un préstamo de 5000 a una TAE de 3,5 durante 10 años es 7052.99 Si se aplica un interés del final de cada mes El valor futuro de un préstamo de 5000 a una TAE del 3,5 por 120 meses es 7,091.72 La diferencia de valor es 38.73 por lo tanto, aplicando el interés en períodos de tiempo más cortos que estamos realmente conseguir más dinero en intereses. La revelación de la salida es el resultado de la comparación de valores entre fv1 y fv2. El valor fv1 se calcula mediante 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 en la tasa de interés mensual equivalente. El paquete Finance. pm se muestra en el listado 4.4 en sus primeras fases de desarrollo. Listado 4.4. El paquete Finance. pm. 1 paquete de Finanzas 2 3 4 ISA requiere Exportador (exportador) 5 6 7 8 head1 Finance. pm Calculadora Financiera - Cálculos financieros fáciles con Perl 9 10 2 11 cabeza utilización Finanzas 12 13 14 15 pv 10000.0 tasa de 12,5 / 12-ABR-por mes. 16: 17 veces 360 meses para préstamo a madurar 18 19 FutureValue fv () 20 21 fv de impresión 22 23 cortada 24 25 qw EXPORTACIÓN (FutureValue, 26 PresentValue, 27 FVofAnnuity, 28 AnnuityOfFV, 29 getLastAverage, 30 getMovingAverage, 31 SetInterest) 32 33 34 globales, en su caso defaultInterest 35 36 37 38 39 5.0 local de sub Finanzas :: SetInterest () 40 mi turno tasa () 41 42 printf tasa defaultInterest quotn ratequot defaultInterest 43 44 45 -------------- -------------------------------------------------- ---- 46 Notas: 47 1. La tasa de interés r se da en un valor de 0-100. 48 2. El n dado en los términos es la velocidad a la que se aplica el interés 49. 50 51 ------------------------------------------------ -------------------- 52 53 ---------------------------- ---------------------------------------- 54 valor actual de una inversión dada fv 55 - un futuro valor de 56 r - tasa por un periodo de 57 n - número de tiempo 58 ---------------------------------- ---------------------------------- 59 sub Finanzas :: FutureValue () 60 mi (pv, r, n ) 61 mi fv pv ((1 (/ 100) r) n) 62 63 64 65 fv retorno ---------------------------- ---------------------------------------- 66 valor actual de una inversión dada fv 67 - un futuro valor de 68 r - tasa por un periodo de 69 n - número de período de 70 ---------------------------------- ---------------------------------- 71 sub Finanzas :: PresentValue () 72 mi pv 73 mi (fv, r, n) 74 pv fv / ((1 (/ 100) r) n) 75 pv 76 77 78 79 retorno ------------------------ -------------------------------------------- 80 Obtener el valor futuro de una anualidad dado 81 mp - Pago mensual de anualidad 82 r - tasa por un periodo de 83 n - número de período de 84 --------------------------- ----------------------------------------- 85 86 sub FVofAnnuity () 87 mi fv 88 mi 89 mi Oner (mp, r, n) 90 91 Oner (1 r) n fv 92 mp ((Oner - 1) / r) 93 de retorno fv 94 95 96 ------------ -------------------------------------------------- ------ 97 Obtener la anualidad de los siguientes bits de información 98 r - tasa por un periodo de 99 n - número de período de 100 fv - Valor futuro 101 ---------------- -------------------------------------------------- - 102 103 sub AnnuityOfFV () 104 mi mp mp - Pago mensual de Anualidad 105 mi 106 mi Oner (fv, r, n) 107 108 Oner (1 r) n fv 109 mp (r / (Oner - 1)) 110 volver pf 111 112 113 --------------------------------------------- ----------------------- 114 Obtener el promedio de los últimos valores quotnquot en una matriz. 115 ------------------------------------------------- ------------------- 116 el último número de recuento de elementos de la matriz de valores de 117, el número total de elementos de valor es en el número 118 119 sub getLastAverage () 120 mi (contar, número, valores) 121 122 123 mi i mi un 0 124 0 retorno Si (recuento 0) 125 para (i 0 ILT recuento i) un valuesnumber 126 - i - 1 127 128 de retorno a / cuento 129 130 131 - -------------------------------------------------- ---------------- 132 Obtener un promedio móvil de los valores. 133 ------------------------------------------------- ------------------- 134 el tamaño de la ventana es el primer parámetro, el número de elementos de la matriz pasada 135 es el siguiente. (Esto se puede calcular fácilmente dentro de la función 136 usando la función escalar (), pero la subrutina muestra aquí 137 también se está utilizando para ilustrar cómo pasar punteros.) La referencia a la 138 matriz de valores se hace pasar a continuación, seguido por una referencia al lugar 139 de los valores de retorno se van a almacenar. 140 141 sub getMovingAve (142) (mis contar, número, valores, movingAve) 143 mi 144 mi i un 0 145 mi v 0 146 147 0 retorno Si (recuento 0) 148 return -1 Si (recuento número GT) 149 de retorno - 2 si (LT recuento 2) 150 151 movingAve0 0 152 movingAvenumber - 1 0 153 para (iltcounti i0) 154 v valuesi 155 av / cuenta 156 movingAvei 0 157 158 para (iltnumberi contadori) 159 v valuesi 160 av / recuento 161 v valuesi - contar - 1 162 a - v / cuenta 163 164 165 movingAvei un retorno 0 166 167 168 1 consulte la declaración de la función con FutureValue (). Los tres signos de dólar en conjunto significan tres números escalares que se pasa a la función. Este alcance adicional está presente para validar el tipo de los parámetros pasados ​​a la función. Si se va a pasar una cadena en lugar de un número en la función, se obtendría un mensaje muy similar a éste: Demasiados argumentos de Finanzas :: FutureValue en la línea ./f4.pl 15, cerca de quottime) Ejecución del quot. /f4.pl abortado debido a errores de compilación. El uso de prototipos en la definición de funciones impide el envío de los valores distintos de lo que la función espera. Utilice o para pasar de una matriz de valores. Si está de paso por referencia, utilice o para mostrar una referencia a escalar una matriz o hachís, respectivamente. Si no se utiliza la barra invertida, se ignoran todos los otros tipos en el prototipo lista de argumentos. Otros tipos de descalificación incluyen un ampersand 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, echemos un vistazo a la declaración de la función lastMovingAverage, que especifica dos enteros en la parte delantera, seguido de una matriz. La forma en que los argumentos se utilizan en la función es el de asignar un valor a cada uno de los dos escalares, contar y número. mientras que todo lo demás se envía a la matriz. Mira el getMovingAverage () para ver cómo se pasan dos matrices con el fin de obtener la media móvil de una lista de valores. La forma de llamar a la función getMovingAverage se muestra en el listado 4.5. Listado 4.5. Utilizando la función de media móvil. 1 / usr / bin / perl - w 2 3 push (Inc, pwd) 4 5 6 uso Finanzas valores (12,22,23,24,21,23,24,23,23,21,29,27,26, 28) 7 mv (0) 8 tamaño escalar (valores) valores quotn 9 de impresión para trabajar con nquot 10 de impresión quot Número de valores de tamaño nquot 11 12 ------------------- --------------------------------------------- 13 Calcular el promedio de la función anterior 14 ---------------------------------------------- ------------------ 15 ave Finanzas :: getLastAverage (5, tamaño, valores) 16 de impresión quotn media de los últimos 5 días nquot Ave 17 18 Finanzas :: getMovingAve (5, tamaño, los valores, mv) 19 quotn impresión de media móvil con ventana 5 días n nquot Aquí está la salida del listado 4.5: valores de 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 las matrices escalares. Dentro de la función, los dos escalares a las matrices se eliminan las referencias para su uso como matrices numéricas. El conjunto de valores obtenidos se inserta en el área que se pasa como segunda referencia. Si los parámetros de entrada no se han especificado por cada matriz de referencia, la referencia de matriz movingAve habrían estado vacía y habrían provocado errores en tiempo de ejecución. En otras palabras, la siguiente declaración no es correcta: sub getMovingAve () El spew resultante de mensajes de error de una mala prototipo de la función es la 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 la línea Finance. pm 128. 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 la línea Finance. pm 133. uso del valor no inicializado Finance. pm en la línea 135. uso del valor no inicializado en la línea Finance. pm 133. uso del valor no inicializado en la línea Finance. pm 135. uso del valor no inicializado en la línea Finance. pm 133. uso del valor no inicializado en la línea 135 Finance. pm . uso del valor no inicializado en la línea Finance. pm 133. uso del valor no inicializado en la línea Finance. pm 135. uso del valor no inicializado en la línea Finance. pm 133. uso del valor no inicializado en la línea Finance. pm 135. uso del valor no inicializado en