Exemplo Médio Móvel Perl

Média móvel Este exemplo ensina como calcular a média móvel de uma série temporal no Excel. Uma média móvel é usada para suavizar irregularidades (picos e vales) para reconhecer facilmente as tendências. 1. Primeiro, vamos dar uma olhada em nossas séries temporais. 2. Na guia Dados, clique em Análise de dados. Nota: não consigo encontrar o botão Análise de dados Clique aqui para carregar o complemento Analysis ToolPak. 3. Selecione Média móvel e clique em OK. 4. Clique na caixa Intervalo de entrada e selecione o intervalo B2: M2. 5. Clique na caixa Intervalo e digite 6. 6. Clique na caixa Escala de saída e selecione a célula B3. 8. Traçar um gráfico desses valores. Explicação: porque definimos o intervalo para 6, a média móvel é a média dos 5 pontos de dados anteriores e o ponto de dados atual. Como resultado, picos e vales são alisados. O gráfico mostra uma tendência crescente. O Excel não pode calcular a média móvel para os primeiros 5 pontos de dados porque não há suficientes pontos de dados anteriores. 9. Repita os passos 2 a 8 para o intervalo 2 e o intervalo 4. Conclusão: quanto maior o intervalo, mais os picos e os vales são alisados. Quanto menor o intervalo, mais próximas as médias móveis são para os pontos reais de dados. Com o vetor de peso eu significo o vetor com pesos que você tem que multiplicar as observações na janela que desliza sobre seus dados, então se você adicionar esses produtos juntos Retorna o valor da EMA no lado direito da janela. Para uma média móvel ponderada linear, a fórmula para encontrar o vetor de peso é: (1: n) soma (1: n) (no código R). Esta série de comprimento n aumenta até 1. Para n10 será 0.01818182 0.03636364 0.05454545 0.07272727 0.09090909 0.10909091 0.12727273 0.14545455 0.16363636 0.18181818 os números 1 a 10 55, com 55 a soma dos números 1 a 10. Como você calcula o vetor de peso Para uma média móvel exponencial (EMA) de comprimento n se n é o comprimento da janela, então alphalt-2 (n1) e ilt-1: n então EmaWeightVectorlt - ((alfa (1-alfa) (1-i)) ) Isso é correto Mesmo que o EMA não esteja realmente confinado a uma janela com um começo e um fim, não deveria os pesos somar 1 como o LWMA Thanks Jason, qualquer ponteiro de como aproximar o filtro EMA para qualquer precisão desejada Ao aproximá-lo com um filtro FIR longo, há um script perl em. wikipedia. orgwikihellip que fez a imagem do vetor de peso EMA, mas não entendi: se eles definiram o número de pesos para 15, por que há 20 vermelhos Barras em vez de 15 ndash MisterH 19 de dezembro 12 em 22: 40 Este capítulo apresenta você ao c Recebe referências a módulos Perl, pacotes e aulas. Ele também mostra como criar alguns módulos de amostra. Um módulo Perl é um conjunto de código Perl que funciona como uma biblioteca de chamadas de função. O termo módulo em Perl é sinônimo da palavra pacote. Os pacotes são uma característica do Perl 4, enquanto os módulos são prevalentes no Perl 5. Você pode manter todo seu código Perl reutilizável específico para um conjunto de tarefas em um módulo Perl. Portanto, todas as funcionalidades pertencentes a um tipo de tarefa estão contidas em um arquivo. É mais fácil criar uma aplicação nesses blocos modulares. Portanto, o módulo da palavra aplica um pouco mais do que o pacote. Heres uma introdução rápida aos módulos. Certos tópicos nesta seção serão abordados em detalhes ao longo do resto do livro. Leia atentamente os seguintes parágrafos para obter uma visão geral sobre o que está por vir enquanto escreve e usa seus próprios módulos. O que é confuso é que os termos módulo e pacote são usados ​​indistintamente em toda a documentação Perl, e estes dois termos significam a mesma coisa. Então, ao ler documentos Perl, basta pensar em quotpackagequot quando você vê quotmodulequot e vice-versa. Então, qual é a premissa para o uso de módulos Bem, os módulos estão lá para empacotar (desculpar as palavras), símbolos e itens de dados interligados em conjunto. Por exemplo, usando variáveis ​​globais com nomes muito comuns, como k. J. Ou eu em um programa geralmente não é uma boa idéia. Além disso, um contador de contatos, eu. Deve ser permitido trabalhar de forma independente em duas porções diferentes do código. Declarar i como uma variável global e, em seguida, incrementá-lo dentro de uma sub-rotina criará problemas impossíveis de gerenciar com seu código de aplicativo porque a sub-rotina pode ter sido chamada de dentro de um ciclo que também usa uma variável chamada i. O uso de módulos no Perl permite que variáveis ​​com o mesmo nome sejam criadas em locais diferentes e distintos no mesmo programa. Os símbolos definidos para suas variáveis ​​são armazenados em uma matriz associativa, referida como uma tabela de símbolos. Essas tabelas de símbolos são exclusivas de um pacote. Portanto, as variáveis ​​do mesmo nome em dois pacotes diferentes podem ter valores diferentes. Cada módulo possui sua própria tabela de símbolos de todos os símbolos que são declarados dentro dele. A tabela de símbolos basicamente isola nomes sinônimos em um módulo de outro. A tabela de símbolos define um namespace. Isto é, um espaço para nomes de variáveis ​​independentes existe. Assim, o uso de módulos, cada um com sua própria tabela de símbolos, evita que uma variável declarada em uma seção sobrescreva os valores de outras variáveis ​​com o mesmo nome declarado em outro lugar no mesmo programa. De fato, todas as variáveis ​​em Perl pertencem a um pacote. As variáveis ​​em um programa Perl pertencem ao pacote principal. Todos os outros pacotes dentro de um programa Perl são aninhados dentro deste pacote principal ou existem no mesmo nível. Existem algumas variáveis ​​verdadeiramente globais, como a matriz de manipuladores de sinal SIG. Que estão disponíveis para todos os outros módulos em um programa aplicativo e não podem ser isolados por espaços de nome. Apenas os identificadores de variáveis ​​que começam com letras ou um sublinhado são mantidos em uma tabela de símbolos de módulos. Todos os outros símbolos, como os nomes STDIN. STDOUT. STDERR. ARGV. ARGVOUT. ENV. Inc. E SIG são obrigados a estar no pacote principal. Alternar entre pacotes afeta apenas namespaces. Tudo o que você está fazendo quando usa um pacote ou outro é declarar qual tabela de símbolos usar como a tabela de símbolos padrão para pesquisa de nomes de variáveis. Somente variáveis ​​dinâmicas são afetadas pelo uso de tabelas de símbolos. As variáveis ​​declaradas pelo uso da minha palavra-chave ainda são resolvidas com o bloco de código em que elas residem e não são referenciadas através de tabelas de símbolos. De fato, o escopo de uma declaração de pacote permanece ativo apenas dentro do bloco de código em que é declarado. Portanto, se você alternar tabelas de símbolos usando um pacote dentro de uma sub-rotina, a tabela de símbolos original em vigor quando a chamada for feita será restaurada Quando a sub-rotina retorna. Alterar tabelas de símbolos afeta apenas a pesquisa padrão de nomes de variáveis ​​dinâmicas. Você ainda pode se referir explicitamente a variáveis, alças de arquivo, e assim por diante em um pacote específico, antecipando um pacoteName. Para o nome da variável. Você viu o que era um contexto de pacote ao usar referências no Capítulo 3. Um contexto de pacote simplesmente implica o uso da tabela de símbolos pelo intérprete de Perl para resolver nomes de variáveis ​​em um programa. Ao mudar as tabelas de símbolos, você está alternando o contexto do pacote. Os módulos podem ser aninhados em outros módulos. O módulo aninhado pode usar as variáveis ​​e funções do módulo em que está aninhado. Para módulos aninhados, você precisaria usar moduleName. AninhadoModuleName e assim por diante. Usar o duplo colo (::) é sinônimo de usar uma cotação anterior (). No entanto, o cólon duplo é a maneira preferida e futura de abordar variáveis ​​dentro dos módulos. O endereçamento explícito das variáveis ​​do módulo sempre é feito com uma referência completa. Por exemplo, suponha que você tenha um módulo, Investimento. Qual é o pacote padrão em uso, e você deseja endereçar outro módulo, Bonds. Que está aninhado no módulo Investimento. Nesse caso, você não pode usar Bond ::. Em vez disso, você precisaria usar o Investment :: Bond :: para abordar variáveis ​​e funções dentro do módulo Bond. Usando Bond :: implicaria o uso de um pacote Bond que está aninhado dentro do módulo principal e não dentro do módulo de Investimento. A tabela de símbolos para um módulo é realmente armazenada em uma matriz associativa dos nomes dos módulos anexados com dois pontos. A tabela de símbolos para um módulo chamado Bond será referida como a matriz associativa Bond ::. O nome da tabela de símbolos para o módulo principal é main ::. E pode até ser encurtado para ::. Da mesma forma, todos os pacotes aninhados têm seus símbolos armazenados em matrizes associativas com dois pontos separados por cada nível de nidificação. Por exemplo, no módulo Bond que está aninhado no módulo Investment, a matriz associativa para os símbolos no módulo Bond será denominada Investment :: Bond ::. Um typeglob é realmente um tipo global para um nome de símbolo. Você pode executar operações de aliasing atribuindo a um typeglob. Uma ou mais entradas em uma matriz associativa para símbolos serão usadas quando uma atribuição através de um typeglob é usada. O valor real em cada entrada da matriz associativa é o que você está se referindo ao usar a notação do nome da variável. Assim, existem duas maneiras de se referir a nomes de variáveis ​​em um pacote: Investimento :: dinheiro Investimento :: contas No primeiro método, você está se referindo às variáveis ​​através de uma referência typeglob. O uso da tabela de símbolos, Investment ::. Está implícito aqui, e Perl irá otimizar a pesquisa de símbolos de dinheiro e contas. Esta é a maneira mais rápida e preferida de endereçar um símbolo. O segundo método usa uma pesquisa para o valor de uma variável endereçada por dinheiro e contas na matriz associativa usada para símbolos, Investimento :: explicitamente. Essa pesquisa seria feita dinamicamente e não será otimizada pela Perl. Portanto, a pesquisa será forçada a verificar a matriz associativa sempre que a instrução for executada. Como resultado, o segundo método não é eficiente e deve ser usado apenas para demonstração de como a tabela de símbolos é implementada internamente. Outro exemplo nesta afirmação kamran husain provoca variáveis, sub-rotinas e identificadores de arquivo que são nomeados através do símbolo kamran para também ser direcionado através do símbolo de um dono. Ou seja, todas as entradas de símbolos na tabela de símbolos atual com a chave kamran agora conterão referências aos símbolos abordados pelo caderno-chave. Para evitar tal atribuição global, você pode usar referências explícitas. Por exemplo, a seguinte afirmação permitirá que você aborde o conteúdo do site por meio da variável kamran. Kamran husain No entanto, qualquer arrays como kamran e husain não serão os mesmos. Somente o que as referências especificadas explicitamente serão alteradas. Para resumir, quando você atribui um typeglob a outro, você afeta todas as entradas em uma tabela de símbolos independentemente do tipo de variável a que se refere. Quando você atribui uma referência de um tipo de variável para outro, você está afetando apenas uma entrada na tabela de símbolos. Um arquivo de módulo Perl possui o seguinte formato: package ModuleName. Insira o código do módulo. 1 O nome do arquivo deve ser chamado ModuleName. pm. O nome de um módulo deve terminar na string. pm por convenção. A declaração do pacote é a primeira linha do arquivo. A última linha do arquivo deve conter a linha com a declaração 1. Isso, de fato, retorna um valor verdadeiro para o programa aplicativo usando o módulo. Não usar a declaração 1 não permitirá que o módulo seja carregado corretamente. A declaração do pacote informa ao intérprete Perl para começar com um novo domínio do namespace. Basicamente, todas as suas variáveis ​​em um script Perl pertencem a um pacote chamado main. Toda variável no pacote principal pode ser referida como mainvariable. Heres a sintaxe para tais referências: packageNamevariableName A citação única () é sinônimo do operador dobro do dois-pontos (::). Eu cobrei mais usos do :: operador no próximo capítulo. Por enquanto, você deve lembrar que as duas instruções a seguir são equivalentes: packageNamevariableName packageName :: variableName A sintaxe do duplo-cólon é considerada padrão no mundo Perl. Portanto, para preservar a legibilidade, uso a sintaxe de dois-cóculos no resto deste livro, a menos que seja absolutamente necessário fazer exceções para provar um ponto. O uso padrão de um nome de variável difere para o pacote atual ativo no momento da compilação. Assim, se você estiver no pacote Finance. pm e especifique uma variável pv. A variável é na verdade igual a Finanças :: pv. Usando Módulos Perl: use vs. require Você inclui módulos Perl em seu programa usando a declaração de uso ou exigir. Existe a maneira de usar qualquer uma dessas instruções: use ModuleName require ModuleName. Observe que a extensão. pm não é usada no código mostrado acima. Observe também que nenhuma das instruções permite que um arquivo seja incluído mais de uma vez em um programa. O valor retornado de true (1) como a última declaração é necessário para permitir que Perl saiba que um módulo d requer ou d é carregado corretamente e permite que o intérprete Perl ignore qualquer recarga. Em geral, é melhor usar a instrução Módulo de uso do que a instrução requerida do Módulo em um programa Perl para permanecer compatível com futuras versões do Perl. Para módulos, você pode querer considerar continuar a usar a instrução exigida. Heres por que: A declaração de uso faz um pouco mais de trabalho do que a instrução exigida na medida em que altera o namespace do módulo que inclui outro módulo. Você deseja que esta atualização adicional do namespace seja feita em um programa. No entanto, ao escrever código para um módulo, você pode não querer que o namespace seja alterado a menos que seja explicitamente necessário. Nesse caso, você usará a declaração obrigatória. A instrução exigir inclui o nome de caminho completo de um arquivo na matriz Inc para que as funções e variáveis ​​no arquivo de módulos estejam em um local conhecido durante o tempo de execução. Portanto, as funções que são importadas de um módulo são importadas através de uma referência de módulo explícita em tempo de execução com a instrução exigida. A declaração de uso faz a mesma coisa que a instrução exigida porque atualiza a matriz Inc com os nomes de caminho completos dos módulos carregados. O código para a função de uso também vai um passo adiante e chama uma função de importação no módulo que está sendo usado d para carregar explicitamente a lista de funções exportadas em tempo de compilação, economizando o tempo necessário para uma resolução explícita de um nome de função durante a execução. Basicamente, a indicação de uso é equivalente a exigir a importação do Nome do módulo Lista do Módulo das funções importadas O uso da declaração de uso altera o namespace de seus programas porque os nomes das funções importadas são inseridos na tabela de símbolos. A declaração exigida não altera o espaço para nome de seus programas. Portanto, a seguinte instrução usa ModuleName () é equivalente a esta declaração: require ModuleName As funções são importadas de um módulo via uma chamada para uma função chamada importação. Você pode escrever sua própria função de importação em um módulo, ou pode usar o módulo Exportador e usar sua função de importação. Em quase todos os casos, você usará o módulo Exportador para fornecer uma função de importação em vez de reinventar a roda. (Você aprenderá mais sobre isso na próxima seção.) Se você decidir não usar o módulo Exportador, você terá que escrever sua própria função de importação em cada módulo que você escreva. É muito mais fácil simplesmente usar o módulo Exportador e permitir que Perl faça o trabalho para você. O Módulo Sample Letter. pm A melhor maneira de ilustrar a semântica de como um módulo é usado no Perl é escrever um módulo simples e mostrar como usá-lo. Vamos tomar o exemplo de um tubarão de empréstimo local, Rudious Maximus, que simplesmente está cansado de digitar o mesmo pedido para cartas de pagamento. Sendo um ávido fã de computadores e Perl, Rudious leva os programadores preguiçosos e escreve um módulo Perl para ajudá-lo a gerar seus memorandos e cartas. Agora, em vez de digitar dentro de campos em um arquivo de modelo de memo, tudo o que ele tem a fazer é digitar algumas linhas para produzir sua nota agradável e ameaçadora. A Listagem 4.1 mostra o que ele tem que digitar. Listagem 4.1. Usando o módulo Letter. 1 usrbinperl - w 2 3 Descomente a linha abaixo para incluir o diretório atual em Inc. 4 push (Inc, pwd) 5 6 use Letter 7 8 Letter :: To (quotMar Gambling Manquot, quotThe money for Lucky Dog, Race 2quot) 9 Letter :: ClaimMoneyNice () 10 Letter :: ThankDem () 11 Letter :: Finish () A declaração Letter de uso está presente para forçar o intérprete Perl a incluir o código do módulo no programa aplicativo. O módulo deve estar localizado no diretório usrlibperl5, ou você pode colocá-lo em qualquer diretório listado na matriz Inc. A matriz Inc é a lista de diretórios que o intérprete Perl procurará ao tentar carregar o código para o módulo nomeado. A linha comentada (número 4) mostra como adicionar o diretório de trabalho atual para incluir o caminho. As próximas quatro linhas no arquivo geram o assunto para a carta. É o resultado da utilização do módulo Letter: Para: Mr. Gambling Man Fm: Rudious Maximus, Loan Shark Dt: Qua 7 de fevereiro 10:35:51 CST 1996 Re: O dinheiro para Lucky Dog, Race 2 Chegou à minha atenção Que sua conta está muito atrasada. Você vai nos pagar em breve Ou quer que eu venha ova Obrigado pelo seu apoio. O arquivo do módulo de letras é mostrado na Listagem 4.2. O nome do pacote é declarado na primeira linha. Como essas funções de módulos serão exportadas, uso o módulo Exportador. Portanto, a declaração usa o Exportador para herdar a funcionalidade do módulo Exportador. Outra etapa necessária é colocar a palavra Exportada na matriz ISA para permitir a procura de Exportados. pm. A matriz ISA é uma matriz especial dentro de cada pacote. Cada item na matriz lista onde mais procurar um método se não puder ser encontrado no pacote atual. A ordem em que os pacotes estão listados na matriz ISA é a ordem em que Perl procura símbolos não resolvidos. Uma classe que está listada na matriz ISA é referida como a classe base dessa classe específica. Perl irá armazenar em cache os métodos que faltam encontrados nas classes base para futuras referências. A modificação da matriz ISA irá eliminar o cache e fazer com que Perl procure todos os métodos novamente. Vejamos agora o código para Letter. pm na Listagem 4.2. Listagem 4.2. O módulo Letter. pm. 1 pacote Carta 2 3 requer Exportador 4 ISA (Exportador) 5 6 cabeça1 NOME 7 8 Carta - Módulo de amostra para gerar cabeçalho para você 9 10 cabeça1 SINOPSE 11 12 uso Carta 13 14 Carta :: Data () 15 Carta :: Para (nome , Empresa, endereço) 16 17 Então, um dos seguintes: 18 Letter :: ClaimMoneyNice () 19 Letter :: ClaimMoney () 20 Letter :: ThreatBreakLeg () 21 22 Letter :: ThankDem () 23 Letter :: Finish () 24 25 head1 DESCRIÇÃO 26 27 Este módulo fornece um pequeno exemplo de geração de uma carta para um 28 tubarão de empréstimo de vizinhança amigável. 29 30 O código começa após a instrução quotcutquot. 31 corte 32 33 EXPORTAÇÃO qw (Data, 34 Para, 35 ReclamoMoney, 36 ReclamoMoneyNice, 37 ThankDem, 38 Conclusão) 39 40 41 Imprimir data de hoje 42 43 sub Letter :: Data 44 data data 45 imprimir quotn Hoje é data 46 47 48 sub Carta :: Para 49 local (nome) deslocamento 50 local (assunto) mudança 51 imprimir quotn Para: nomequot 52 imprimir quotn Fm: Rudious Maximus, empréstimo Sharkquot 53 imprimir quotn Dt: quot, date 54 imprimir quotn Re: subjectquot 55 imprimir quotnnquot 56 Imprimir quotnnquot 57 58 sub Letter :: ClaimMoney () 59 imprimir quotn Você me deve dinheiro. Obtenha seu ato togetherquot 60 print quotn Você quer que eu envie Bruno para quot 61 print quotn cole-o. Ou você vai pagar a subscrição 62 63 64 sub Letter :: ClaimMoneyNice () 65 imprimir quotn Chegou a minha atenção que sua conta é quot 66 imprimir quotn way over due. quot 67 imprimir quotn Você vai nos pagar em breve ... não 68 Imprimir quotn ou você gostaria que eu venha ovahquot 69 70 71 sub Letter :: ThreatBreakLeg () 72 imprimir quotn aparentemente cartas como estas não ajudam 73 imprimir quotn Eu vou ter que fazer um exemplo de youquot 74 imprimir quotn n Ver você no hospital , Palquot 75 76 77 sub Letter :: ThankDem () 78 imprimir quotnn Obrigado pelo seu suporte 79 80 81 sub Letter :: Finish () 82 printf quotnnnn Sincerelyquot 83 printf quotn Rudious n 84 84 86 86 1 Linhas que contêm o sinal de igualdade são usadas Para documentação. Você deve documentar cada módulo para sua própria referência. Os módulos Perl não precisam ser documentados, mas é uma boa idéia escrever algumas linhas sobre o que seu código faz. Daqui a poucos anos, você pode esquecer sobre o que é um módulo. Uma boa documentação é sempre uma obrigação se você quiser lembrar o que fez no passado. Eu cobrem os estilos de documentação usados ​​para o Perl no Capítulo 8. quotDocumenting Perl Scripts. quot Para este módulo de exemplo, a declaração head1 inicia a documentação. Tudo para a declaração de corte é ignorado pelo intérprete Perl. Em seguida, o módulo lista todas as funções exportadas por este módulo na matriz EXPORT. A matriz EXPORT define todos os nomes das funções que podem ser chamados pelo código externo. Se você não listar uma função nesta matriz EXPORT, não será visto por módulos de código externos. Seguir a matriz EXPORT é o corpo do código, uma sub-rotina de cada vez. Depois de todas as sub-rotinas serem definidas, a declaração final 1 encerra o arquivo do módulo. 1 deve ser a última linha executável no arquivo. Vejamos algumas das funções definidas neste módulo. A primeira função a observar é a função Data simples, as linhas 43 a 46, que imprime a data e a hora do UNIX atual. Não há parâmetros para esta função, e ele não retorna nada significativo de volta ao chamador. Observe o uso da minha antes da variável de data na linha 44. A minha palavra-chave é usada para limitar o escopo da variável dentro das chaves de curvatura das funções da Data. O código entre chaves é conhecido como um bloco. As variáveis ​​declaradas dentro de um bloco são limitadas no escopo dentro das chaves curly. Em 49 e 50, o nome e o assunto das variáveis ​​locais são visíveis para todas as funções. Você também pode declarar variáveis ​​com o qualificador local. O uso do local permite que uma variável esteja no escopo para o bloco atual, bem como para outros blocos de código chamados de dentro deste bloco. Assim, um x local declarado dentro de um bloco é visível para todos os blocos subsequentes chamados de dentro deste bloco e podem ser referenciados. No código de exemplo a seguir, a variável de nome de funções ToTitled pode ser acessada, mas não os dados no iphone. 1 sub Letter :: ToTitled 2 local (name) shift 3 my (phone) shift O código de exemplo para Letter. pm mostrou como extrair um parâmetro por vez. A sub-rotina To () leva dois parâmetros para configurar o cabeçalho do memorando. O uso de funções dentro de um módulo não é diferente de usar e definir módulos Perl dentro do mesmo arquivo de código. Os parâmetros são passados ​​por referência, a menos que especificado de outra forma. As múltiplas matrizes passadas para uma sub-rotina, se não for explicitamente desreferenciada usando a barra invertida, são concatenadas. A matriz de entrada em uma função é sempre uma matriz de valores escalares. Passar valores por referência é a maneira preferida em Perl para passar uma grande quantidade de dados em uma sub-rotina. (Consulte o Capítulo 3. quotReferences. quot) Outro módulo de exemplo: Finanças O módulo Finanças, mostrado na Listagem 4.3, é usado para fornecer cálculos simples para valores de empréstimo. Usar o módulo Finanças é direto. Todas as funções são escritas com os mesmos parâmetros, conforme mostrado na fórmula para as funções. Vamos ver como o valor futuro de um investimento pode ser calculado. Por exemplo, se você investir alguns dólares, pv. Em uma ligação que oferece uma taxa de porcentagem fixa, r. Aplicado em intervalos conhecidos para n períodos de tempo, qual é o valor da ligação no momento da expiração. Neste caso, você estará usando a seguinte fórmula: fv pv (1r) n A função para obter o valor futuro é declarada como FutureValue . Consulte o Listado 4.3 para ver como usá-lo. Lista 4.3. Usando o módulo Finanças. 1 usrbinperl - w 2 3 push (Inc, pwd) 4 uso Finanças 5 6 empréstimo 5000.00 7 apr 3.5 APR 8 ano 10 em anos. 9 10 ------------------------------------------------ ---------------- 11 Calcule o valor no final do empréstimo se o interesse 12 for aplicado todos os anos. 13 ------------------------------------------------- --------------- 14 time-year 15 fv1 Finanças :: FutureValue (empréstimo, abril, hora) 16 imprimir quotn Se o interesse for aplicado no final do ano 17 imprimir quotn O valor futuro para um Empréstimo de quot. empréstimo. Quotnquot 18 imprime quot em um APR de quot, apr. Quot for quot, time, quot yearsquot 19 printf quot is 8.2f nquot. Fv1 20 21 ----------------------------------------------- ----------------- 22 Calcule o valor no final do empréstimo se o interesse 23 for aplicado todos os meses. 24 ------------------------------------------------- --------------- 25 taxa 12 de abril APR 26 horário 12 em meses 27 fv2 Finanças :: FutureValue (empréstimo, taxa e tempo) 28 29 imprimir quotn Se o interesse for aplicado no final de Cada mês 30 imprimir quotn O valor futuro para um empréstimo de quot. empréstimo. Quotnot 31 imprimir quot em um APR de quot, apr. Quot for quot, time, quot monthsquot 32 printf quot is 8.2f nquot. Fv2 33 34 printf quotn A diferença de valor é 8.2fquot, fv2 - fv1 35 printf quotn Portanto, ao aplicar o interesse em períodos de tempo mais curtos, 36 imprimir o quotn estamos realmente recebendo mais dinheiro em interesse. nquot Aqui está o exemplo de entrada e saída do Listado 4.3. Testme Se os juros forem aplicados no final do ano O valor futuro para um empréstimo de 5000 em um APR de 3,5 para 10 anos é de 7052.99 Se os juros forem aplicados no final de cada mês O valor futuro de um empréstimo de 5000 em um APR de 3,5 para 120 meses é 7091.72 A diferença de valor é 38.73 Portanto, ao aplicar o interesse em períodos de tempo mais curtos, estamos realmente recebendo mais dinheiro em interesse. A revelação na saída é o resultado da comparação de valores entre fv1 e fv2. O valor fv1 é calculado com a aplicação de interesse uma vez por ano durante a vida do vínculo. Fv2 é o valor se o interesse é aplicado a cada mês na taxa de juros mensal equivalente. O pacote Finance. pm é mostrado na Listagem 4.4 nas fases iniciais de desenvolvimento. Lista 4.4. O pacote Finance. pm. 1 pacote Finanças 2 3 requerem Exportador 4 ISA (Exportador) 5 6 head1 Finance. pm 7 8 Calculadora Financeira - Cálculos financeiros facilitados com Perl 9 10 cabeça 2 11 uso Finanças 12 13 pv 10000.0 14 15 taxa 12,5 12 TAEG por mês. 16 17 tempo 360 meses para empréstimo para amadurecer 18 19 fv FutureValue () 20 21 imprimir fv 22 23 cortar 24 25 EXPORTAR qw (FutureValue, 26 PresentValue, 27 FVofAnnuity, 28 AnnuityOfFV, 29 getLastAverage, 30 getMovingAverage, 31 SetInterest) 32 33 34 Globals, se houver 35 36 37 local defaultInterest 5.0 38 39 sub Finance :: SetInterest () 40 my rate shift () 41 defaultInterest rate 42 printf quotn defaultInterest ratequot 43 44 45 -------------- -------------------------------------------------- ---- 46 Notas: 47 1. A taxa de juros r é dada em um valor de 0-100. 48 2. O n dado nos termos é a taxa em que o interesse 49 é aplicado. 50 51 ------------------------------------------------ -------------------- 52 53 ---------------------------- ---------------------------------------- 54 Valor atual de um investimento dado 55 fv - Um valor futuro 56 r - taxa por período 57 n - número de período 58 ---------------------------------- ---------------------------------- 59 sub Finance :: FutureValue () 60 my (pv, r, n ) 61 my fv pv ((1 (r100)) n) 62 return fv 63 64 65 ------------------------------ -------------------------------------- 66 Valor presente de um investimento dado 67 fv - um futuro Valor 68 r - taxa por período 69 n - número de período 70 ------------------------------------ -------------------------------- 71 sub Finance :: PresentValue () 72 my pv 73 my (fv, r, N) 74 pv fv ((1 (r100)) n) 75 retorno pv 76 77 78 79 ----------------------------- --------------------------------------- 80 Obter o valor futuro de uma anuidade dada 81 mp - Pagamento mensal da anuidade 82 r - taxa por período 83 n - número o F período 84 ----------------------------------------------- --------------------- 85 86 sub FVofAnnuity () 87 my fv 88 my oneR 89 my (mp, r, n) 90 91 oneR (1 r) n 92 fv mp ((oneR - 1) r) 93 retorno fv 94 95 96 --------------------------------- ----------------------------------- 97 Obter a anuidade dos seguintes bits de informação 98 r - taxa por Período 99 n - número de período 100 fv - Valor futuro 101 ------------------------------------- ------------------------------- 102 103 sub AnnuityOfFV () 104 my mp mp - Pagamento mensal da anuidade 105 my oneR 106 My (fv, r, n) 107 108 oneR (1 r) n 109 mp fv (r (oneR-1)) 110 retorno mp 111 112 113 ----------------- -------------------------------------------------- - 114 Obter a média dos últimos valores quotnquot em uma matriz. 115 ------------------------------------------------- ------------------- 116 O último número de contagem de elementos da matriz em valores 117 O número total de elementos em valores está no número 118 119 sub getLastAverage () 120 my (Contagem, número, valores) 121 my i 122 123 my a 0 124 retorno 0 se (contagem 0) 125 para (i 0 ilt count i) 126 um número de valores - i - 1 127 128 retornar uma contagem 129 130 131 --- -------------------------------------------------- --------------- 132 Obter uma média móvel dos valores. 133 ------------------------------------------------- ------------------- 134 O tamanho da janela é o primeiro parâmetro, o número de itens na matriz passada 135 é o próximo. (Isso pode ser facilmente calculado dentro da função 136 usando a função scalar (), mas a sub-rotina mostrada aqui 137 também está sendo usada para ilustrar como passar ponteiros.) A referência à matriz 138 de valores é passada a seguir, seguida de um Referência ao lugar 139, os valores de retorno devem ser armazenados. 140 141 sub getMovingAve () 142 my (contagem, número, valores, motionAve) 143 meu i 144 meu a 0 145 meu v 0 146 147 retorno 0 se (contagem 0) 148 retorno -1 se (número de contagem gt) 149 retornar - 2 se (count lt 2) 150 151 moveAve0 0 152 movingAvenumber - 1 0 153 para (i0 iltcounti) 154 v valuesi 155 av count 156 movingAvei 0 157 158 para (icount iltnumberi) 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 a declaração da função FutureValue com (). Os sinais de três dólares juntos significam que três números escalares passaram para a função. Este escopo extra está presente para validar o tipo de parâmetros passados ​​para a função. Se você fosse passar uma string em vez de um número na função, você receberia uma mensagem muito semelhante a esta: Demasiados argumentos para Finanças :: FutureValue na. f4.pl linha 15, quase quottime) quot Execução de. f4.pl abortado devido a erros de compilação. O uso de protótipos ao definir funções impede o envio de valores diferentes do que a função espera. Use ou para passar em uma série de valores. Se você está passando por referência, use ou para mostrar uma referência escalar para uma matriz ou hash, respectivamente. Se você não usar a barra invertida, todos os outros tipos no protótipo da lista de argumentos serão ignorados. Outros tipos de desqualificadores incluem um e comercial para uma referência a uma função, um asterisco para qualquer tipo e um ponto e vírgula para indicar que todos os outros parâmetros são opcionais. Agora, olhe para a última declaração de função MovingAverage, que especifica dois números inteiros na frente seguido de uma matriz. A maneira como os argumentos são usados ​​na função é atribuir um valor a cada um dos dois escalares, contagem e número. Enquanto tudo o resto é enviado para a matriz. Olhe para a função getMovingAverage () para ver como dois arrays são passados ​​para obter a média móvel em uma lista de valores. A maneira de chamar a função getMovingAverage é mostrada na Listagem 4.5. Listagem 4.5. Usando a função de média móvel. 1 usrbinperl - w 2 3 push (Inc, pwd) 4 use Finance 5 6 valores (12,22,23,24,21,23,24,23,23,21,29,27,26,28) 7 mv ( 0) 8 tamanho escalar (valores) 9 imprimir quotn Valores para trabalhar com nquot 10 imprimir quot Número de valores tamanho nquot 11 12 ------------------------ ---------------------------------------- 13 Calcular a média da função acima 14 - -------------------------------------------------- ------------- 15 ave Finanças :: getLastAverage (5, tamanho, valores) 16 imprimir quotn Média dos últimos 5 dias ave nquot 17 18 Finanças :: getMovingAve (5, tamanho, valores, mv ) 19 imprimir quotn Média móvel com janela de 5 dias n nquot Heres o resultado da Lista 4.5: Valores para trabalhar com Número de valores 14 Média dos últimos 5 dias 26.2 A função getMovingAverage () leva dois escalares e duas referências a arrays como escalares. Within the function, the two scalars to the arrays are dereferenced for use as numeric arrays. The returned set of values is inserted in the area passed in as the second reference. Had the input parameters not been specified with for each referenced array, the movingAve array reference would have been empty and would have caused errors at runtime. In other words, the following declaration is not correct: sub getMovingAve() The resulting spew of error messages from a bad function prototype is as follows: Use of uninitialized value at Finance. pm line 128. Use of uninitialized value at Finance. pm line 128. Use of uninitialized value at Finance. pm line 128. Use of uninitialized value at Finance. pm line 128. Use of uninitialized value at Finance. pm line 128. 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. 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 valu e 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 usrbinperl - 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. SuperClassNextSubClass133 . 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 usrlibperl5 directory: Create a Money directory under the usrlibperl5 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 usrlibperl5 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 usrbinperl - w 2 aa pwd 3 aa . quotMoneyquot 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 usrlibperl5lib 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 usrlibperl5 directory to your path.) find usrlibperl5 - 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.