Rrdgraphexamples Deslocar os dados para a frente por uma semana (604800 segundos) Se a função especializada RRAs existem para detecção de comportamento aberrante, eles podem ser usados para gerar o gráfico de uma série temporal com bandas de confiança e falhas. Este exemplo gera um gráfico da série de dados em azul (LINE2 com a fonte de dados virtual scaledobs), limites de confiança em vermelho (fontes de dados virtuais escalonadas e escalonadas) e falhas potenciais (isto é, comportamento aberrante aberrante potencial) marcadas por linhas amarelas verticais A fonte de dados de falha). Os dados brutos são provenientes de um RRA MÉDIO. A melhor resolução das séries temporais observadas (um ponto de dados consolidado por ponto de dados primário). Os valores previstos (ou suavizados) são armazenados no RPR HWPREDICT. Os valores dos desvios previstos (pense o desvio padrão) são armazenados no DEVPREDICT RRA. Finalmente, o RAS de FALHAS contém indicadores, com 1 denotando uma falha potencial. Todos os dados são redimensionados em bits (em vez de Octetos) multiplicando por 8. Os limites de confiança são calculados por um desvio de 2 desvios tanto acima como abaixo dos valores previstos (os CDEFs superior e inferior). Linhas verticais indicadas falhas potenciais são graficadas através do elemento de gráfico TICK, que converte valores não-zero em um RRA em marcas de carrapatos. Aqui, um argumento de fração de eixo de 1,0 significa que as marcas de carrapato abrangem todo o eixo y e, portanto, tornam-se linhas verticais no gráfico. A escolha de 2 desvios (um fator de escala) corresponde ao padrão usado internamente pelo FAILURES RRA. Se o valor interno for alterado (ver rrdtune), este comando gráfico deve ser alterado para ser consistente. O comando rrdtool graph é projetado para plotar dados em uma resolução temporal especificada, independentemente da resolução real dos dados no arquivo RRD. Isso pode apresentar um problema para as funções de consolidação especializadas que mantêm um mapeamento um-para-um entre pontos de dados primários e pontos de dados consolidados. Se um gráfico insiste em ver o conteúdo desses RRAs em uma escala temporal mais grosseira, o comando de gráfico tenta fazer algo inteligente, mas as bandas de confiança e falhas já não têm o mesmo significado e podem ser enganosas. Rrdgraph dá uma visão geral de como funciona rrdtool gráfico. Rrdgraphdata descreve DEF, CDEF e VDEF em detalhe. Rrdgraphrpn descreve o idioma RPN usado nas instruções xDEF. A página rrdgraphgraph descreve todas as funções gráficas e de impressão. Programa por Tobias Oetiker 60tobioetiker. ch62 Esta página de manual por Alex van den Bogaerdt 60alexvandenbogaerdt. nl62 com correções e / ou adições por várias pessoas Este capítulo apresenta os conceitos por trás das referências a módulos, pacotes e classes do Perl. Ele também mostra como criar alguns módulos de exemplo. 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 do pacote de palavras. Os pacotes são uma característica do Perl 4, enquanto os módulos são prevalentes no Perl 5. Você pode manter todo o seu código Perl reutilizável específico para um conjunto de tarefas em um módulo Perl. Portanto, toda a funcionalidade pertencente a um tipo de tarefa está contida em um arquivo. É mais fácil construir uma aplicação nestes blocos modulares. Assim, o módulo palavra aplica um pouco mais do que o pacote. Heres uma introdução rápida aos módulos. Alguns tópicos nesta seção serão abordados em detalhes ao longo do restante do livro. Leia atentamente os parágrafos seguintes para obter uma visão geral do que está à sua frente enquanto escreve e utiliza os seus próprios módulos. O que é confuso é que os termos módulo e pacote são usados de forma intercambiável em toda a documentação do Perl, e esses dois termos significam a mesma coisa. Então, ao ler documentos Perl, basta pensar quotpackagequot quando você ver quotmodulequot e vice-versa. Então, qual é a premissa para usar módulos Bem, os módulos estão lá para embalar (perdoar o trocadilho) variáveis, símbolos e itens de dados interligados juntos. Por exemplo, usando variáveis globais com nomes muito comuns, como k. J. Ou i em um programa geralmente não é uma boa idéia. Além disso, um contador de loop, i. Devem ser autorizados a trabalhar de forma independente em duas partes diferentes do código. Declarar i como uma variável global e, em seguida, incrementá-lo a partir de dentro de uma sub-rotina irá criar problemas não gerenciáveis com o código do aplicativo porque a sub-rotina pode ter sido chamado de dentro de um loop que também usa uma variável chamada i. O uso de módulos em Perl permite que variáveis com o mesmo nome sejam criadas em diferentes lugares distintos no mesmo programa. Os símbolos definidos para suas variáveis são armazenados em uma matriz associativa, denominada tabela de símbolos. Essas tabelas de símbolos são exclusivas de um pacote. Portanto, variáveis do mesmo nome em dois pacotes diferentes podem ter valores diferentes. Cada módulo tem sua própria tabela de símbolos de todos os símbolos que são declarados dentro dela. A tabela de símbolos basicamente isola nomes sinônimos em um módulo de outro. A tabela de símbolos define um namespace. Ou seja, o uso de módulos, cada um com sua própria tabela de símbolos, impede que uma variável declarada em uma seção sobrescreva os valores de outras variáveis com o mesmo nome declarado em outra parte da mesma programa. Como uma questão 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 ou estã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 via namespaces. Somente 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 forçados a estar no pacote principal. Alternar entre pacotes afeta somente namespaces. Tudo o que você está fazendo quando você usa um pacote ou outro é declarar qual tabela de símbolos para usar como a tabela de símbolos padrão para pesquisa de nomes de variáveis. Somente as variáveis dinâmicas são afetadas pelo uso de tabelas de símbolos. As variáveis declaradas pelo uso da palavra-chave my ainda são resolvidas com o bloco de código em que residem e não são referenciadas através de tabelas de símbolos. Na verdade, o escopo de uma declaração de pacote permanece ativo somente dentro do bloco de código em que ele é 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 foi feita será restaurada Quando a subrotina retorna. Alterar tabelas de símbolos afeta somente a pesquisa padrão de nomes de variáveis dinâmicas. Você ainda pode referenciar explicitamente variáveis, manipuladores de arquivo e assim por diante em um pacote específico prepending um packageName. Para o nome da variável. Você viu o contexto de um pacote ao usar referências no Capítulo 3. Um contexto de pacote simplesmente implica o uso da tabela de símbolos pelo interpretador Perl para resolver nomes de variáveis em um programa. Ao mudar de tabelas de símbolos, você está mudando o contexto do pacote. Os módulos podem ser aninhados dentro de outros módulos. O módulo aninhado pode usar as variáveis e funções do módulo em que está aninhado. Para os módulos aninhados, você teria que usar moduleName. NestedModuleName e assim por diante. Usando o duplo cólon (::) é sinônimo de usar um back quote (). No entanto, o duplo cólon é a maneira preferida de abordar as variáveis dentro dos módulos. O endereçamento explícito de variáveis de módulo é sempre feito com uma referência completa. Por exemplo, suponha que você tenha um módulo, Investimento. Que é o pacote padrão em uso, e você deseja endereço outro módulo, Bonds. Que está aninhado dentro do módulo de investimento. Neste maiúsculas e minúsculas, você não pode usar Bond ::. Em vez disso, você teria que usar Investment :: Bond :: para endereço 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 de módulos anexados com dois 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 mesmo ser encurtado para ::. Da mesma forma, todos os pacotes aninhados têm seus símbolos armazenados em matrizes associativas com dois pontos separando cada nível de aninhamento. Por exemplo, no módulo Bond que está aninhado dentro do módulo de investimento, 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 tipoglob é usada. O valor real em cada entrada da matriz associativa é o que você está se referindo quando você usa a notação variableName. Assim, há 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 ::. É implícita 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 será feita dinamicamente e não será otimizada pelo 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 nessa declaração kamran husain causa variáveis, subrotinas e identificadores de arquivo que são nomeados através do símbolo kamran para também ser endereçados via o símbolo husain. Ou seja, todas as entradas de símbolo na tabela de símbolos atual com a chave kamran agora conterão referências aos símbolos endereçados pela chave husain. Para evitar tal atribuição global, você pode usar referências explícitas. Por exemplo, a seguinte instrução permitirá que você abordar o conteúdo de husain através da variável kamran. Kamran husain No entanto, quaisquer matrizes como kamran e husain não será o mesmo. Somente o que as referências especificadas explicitamente serão alteradas. Para resumir, quando você atribui um tipo de objeto a outro, você afeta todas as entradas em uma tabela de símbolos, independentemente do tipo de variável a ser consultado. 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 tem 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 instrução de pacote é a primeira linha do arquivo. A última linha do arquivo deve conter a linha com a instrução 1. Isso, com efeito, retorna um valor verdadeiro para o programa aplicativo usando o módulo. Não usar a instrução 1 não permitirá que o módulo seja carregado corretamente. A instrução package diz ao interpretador Perl para iniciar com um novo domínio de espaço para nome. Basicamente, todas as suas variáveis em um script Perl pertencem a um pacote chamado main. Cada variável no pacote principal pode ser referida como mainvariable. Heres a sintaxe para essas referências: packageNamevariableName A única citação () é sinônimo com o operador de dois pontos (::). Eu cubro 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 de dois pontos é considerada padrão no mundo Perl. Portanto, para preservar a legibilidade, eu uso a sintaxe de dois pontos no restante 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 especificar uma variável pv. A variável é realmente igual a Finance :: pv. Usando módulos Perl: use vs. require Você inclui módulos Perl em seu programa usando o use ou a instrução require. Heres a maneira de usar uma destas 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 instrução é necessário para permitir que o Perl saiba que um require d ou use o módulo d carregado corretamente e deixa o interpretador Perl ignorar quaisquer recargas. Em geral, é melhor usar a instrução Módulo de uso do que a instrução Módulo de exigir em um programa Perl para permanecer compatível com versões futuras do Perl. Para módulos, convém considerar continuar a usar a instrução require. Heres porquê: A declaração de uso faz um pouco mais de trabalho do que a instrução require, na medida em que altera o namespace do módulo que inclui outro módulo. Você deseja que esta atualização extra do namespace seja feita em um programa. No entanto, ao escrever código para um módulo, você pode não desejar que o espaço para nome seja alterado a menos que seja explicitamente necessário. Neste evento, você usará a instrução require. A instrução require inclui o 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 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 require. A instrução use faz a mesma coisa que a instrução require porque atualiza a matriz Inc com caminhos completos de módulos carregados. O código para a função de uso também vai um passo além 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 assim o tempo necessário para uma resolução explícita de um nome de função durante a execução. Basicamente, a instrução use é equivalente a exigir ModuleName import ModuleName lista de funções importadas O uso da instrução use altera o namespace dos programas porque os nomes das funções importadas são inseridos na tabela de símbolos. A instrução require não altera o namespace dos programas. Portanto, a seguinte instrução use ModuleName () é equivalente a essa instrução: require ModuleName As funções são importadas de um módulo através de uma chamada para uma função chamada import. Você pode escrever sua própria função de importação em um módulo, ou você 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ê vai 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ê escreve. É muito mais fácil simplesmente usar o módulo Exportador e deixar Perl fazer 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 está simplesmente cansado de digitar a mesma quotrequest para letras de pagamento. Sendo um ávido fã de computadores e Perl, Rudious leva a abordagem programadores preguiçoso 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 memorando, tudo o que ele tem que 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 Carta. 1 usrbinperl - w 2 3 Descomente a linha abaixo para incluir o atual dir em Inc. 4 push (Inc, pwd) 5 6 use Letter 7 8 Letter :: To (quotMr. Gambling Manquot, o dinheiro para Lucky Dog, Race 2quot) 9 Letra :: ClaimMoneyNice () 10 Letter :: ThankDem () 11 Letter :: Finish () A instrução use Letter está presente para forçar o interpretador Perl a incluir o código para o módulo no programa de aplicação. 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 interpretador Perl irá 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 da carta. Heres a saída de usar o módulo de letra: Para: Sr. Gambling Man Fm: Rudious Maximus, Empréstimo Shark Dt: Qua Feb 7 10:35:51 CST 1996 Re: O dinheiro para Lucky Dog, Race 2 Tem vindo a minha atenção Que a sua conta está muito atrasada. Você vai nos pagar logo Ou você gostaria que eu viesse ovah Obrigado pelo seu apoio. O arquivo do módulo Letter é mostrado na Listagem 4.2. O nome do pacote é declarado na primeira linha. Como essas funções de módulos serão exportadas, eu uso o módulo Exportador. Portanto, o uso de declaração Exportador é obrigado a herdar funcionalidade do módulo Exportador. Outra etapa necessária é colocar a palavra exportada na matriz ISA para permitir a pesquisa para Exported. pm. A matriz ISA é uma matriz especial dentro de cada pacote. Cada item na matriz lista onde mais procurar um método se ele não puder ser encontrado no pacote atual. A ordem na qual os pacotes são listados na matriz ISA é a ordem na qual o Perl procura por símbolos não resolvidos. Uma classe que está listada na matriz ISA é referida como a classe base dessa classe específica. O Perl armazenará em cache os métodos ausentes encontrados nas classes base para futuras referências. Modificar a matriz ISA liberará o cache e fará com que o Perl procure todos os métodos novamente. Vamos agora olhar para o código de Letter. pm na Listagem 4.2. Listagem 4.2. O módulo Letter. pm. 1 pacote Carta 2 3 requer Exporter 4 ISA (Exportador) 5 6 head1 NOME 7 8 Carta - Módulo de amostra para gerar papel timbrado para você 9 10 head1 SINOPSE 11 12 use Letter 13 14 Letter :: Date () 15 Letter :: To (name , Empresa, endereço) 16 17 Uma das seguintes opções: 18 Carta :: ClaimMoneyNice () 19 Carta :: ClaimMoney () 20 Letter :: ThreatBreakLeg () 21 22 Carta :: ThankDem () 23 Letter :: Finish () 24 25 head1 DESCRIÇÃO 26 27 Este módulo fornece um pequeno exemplo de como gerar uma carta para um 28 simpático vizinho de empréstimo de tubarão. 29 30 O código começa após a instrução quotcutquot. 31 corte 32 33 EXPORTACÃO qw (Data, 34 Para, 35 ReivindicaçãoMoney, 36 ClaimMoneyNice, 37 ThankDem, 38 Concluir) 39 40 41 Imprimir data de hoje 42 43 sub Letra :: Data 44 data data 45 imprimir quotn Hoje é dataquot 46 47 48 sub Letra: Para 49 mudança local (nome) 50 mudança local (sujeito) 51 impressão quotn Para: nomequot 52 imprimir quotn Fm: Rudious Maximus, Empréstimo Sharkquot 53 imprimir quotn Dt: quot, data 54 imprimir quotn Re: subjectquot 55 print quotnnquot 56 Print quotnnquot 57 58 sub Letra :: ClaimMoney () 59 print quotn Você me deve dinheiro. Você quer que eu envie Bruno para quot 61 imprimir quotn coletá-lo. Ou você vai pagar upquot 62 63 64 sub Carta :: ClaimMoneyNice () 65 imprimir quotn Cheguei à minha atenção que a sua conta é quotn 66 impressão quotn maneira mais de due. quot 67 impressão quotn Você vai nos pagar em breve .. 68 Impressão quotn ou você gostaria que viesse ovahquot 69 70 71 sub Letter :: ThreatBreakLeg () 72 impressão quotn aparentemente cartas como estas não helpquot 73 impressão quotn Vou ter que fazer um exemplo de você 74 impressão quotn n Vejo você no hospital , Palquot 75 76 77 sub Letra :: ThankDem () 78 print quotnn Obrigado pelo seu apoio 79 80 81 sub Letra :: Acabamento () 82 printf quotnnnn Sinceramentequot 83 printf quotn Rudious n quot 84 85 86 1 São utilizadas linhas contendo o sinal de igual 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. Alguns anos a partir de agora, você pode esquecer o que é um módulo. Boa documentação é sempre uma obrigação se você quiser lembrar o que você fez no passado eu cobrir estilos de documentação usados para Perl no Capítulo 8. QuotDocumenting Perl Scripts. quot Para este módulo de exemplo, a instrução head1 começa a documentação. Tudo até a instrução de corte é ignorado pelo interpretador 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 de funções que podem ser chamados pelo código externo. Se você não listar uma função nesta matriz EXPORT, ele não será visto por módulos de código externo. Após a matriz EXPORT é o corpo do código, uma sub-rotina de cada vez. Depois que todas as subrotinas são definidas, a instrução final 1 termina o arquivo de 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 ser observada é a função Data simples, linhas 43 a 46, que imprime a data e hora atuais do UNIX. Não há parâmetros para esta função, e ele não retorna nada significativo para o chamador. Observe o uso do meu antes da variável de data na linha 44. A palavra-chave my é usada para limitar o escopo da variável para dentro das chaves Date curly chaves. Código entre chaves é referido como um bloco. As variáveis declaradas dentro de um bloco são limitadas no escopo dentro das chaves. Em 49 e 50, as variáveis locais nome e assunto são visíveis para todas as funções. Você também pode declarar variáveis com o qualificador local. O uso de local permite que uma variável esteja no escopo para o bloco atual assim como para outros blocos de código chamados dentro deste bloco. Assim, um local x declarado dentro de um bloco é visível a todos os blocos subseqüentes chamados dentro deste bloco e pode ser referenciado. 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 (nome) shift 3 my (phone) shift O código de exemplo para Letter. pm mostrou como extrair um parâmetro de cada vez. A subrotina To () leva dois parâmetros para configurar o cabeçalho para o memorando. O uso de funções dentro de um módulo não é diferente do uso e definição de 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. Múltiplos arrays passados em uma sub-rotina, se não explicitamente dereferenced usando o backslash, são concatenados. A matriz de entrada em uma função é sempre uma matriz de valores escalares. Passando 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 Amostra: Finanças O módulo Finance, 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, como mostrado na fórmula para as funções. Vejamos como o valor futuro de um investimento pode ser calculado. Por exemplo, se você investir alguns dólares, pv. Em uma obrigação que oferece uma taxa de porcentagem fixa, r. Aplicado a intervalos conhecidos durante n períodos de tempo, qual é o valor da ligação no momento da sua 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 a Listagem 4.3 para ver como usá-la. Listagem 4.3. Usando o módulo Finanças. 1 usrbinperl - w 2 3 push (Inc, pwd) 4 uso Finanças 5 6 loan 5000.00 7 apr 3.5 APR 8 ano 10 em anos. 9 10 ------------------------------------------------ ---------------- 11 Calcule o valor no final do empréstimo se juros 12 é aplicado a cada ano. 13 ------------------------------------------------- --------------- 14 anos de tempo 15 fv1 Finanças :: FutureValue (empréstimo, abril, hora) 16 imprimir quotn Se o juro é aplicado no final do ano 17 print quotn O valor futuro para um Empréstimo da quot. empréstimo. Quotnquot 18 imprimir quot em um APR de quot, abr. Quot para quot, tempo, quot anos 19 printf quot é 8.2f nquot. Fv1 20 21 ----------------------------------------------- ----------------- 22 Calcule o valor no final do empréstimo se juros 23 é aplicado a cada mês. 24 ------------------------------------------------- --------------- 25 taxa abril 12 APR 26 tempo ano 12 em meses 27 fv2 Finanças :: FutureValue (empréstimo, taxa, tempo) 28 29 imprimir quotn Se o interesse é aplicado no final de Cada mês 30 impressão quotn O valor futuro para um empréstimo de quot. empréstimo. Quotnquot 31 print quot em um APR de quot, abr. Quot por quot, tempo, quot meses 32 printf quot é 8.2f nquot. Fv2 33 34 printf quotn A diferença de valor é 8.2fquot, fv2 - fv1 35 printf quotn Portanto, aplicando juros em períodos de tempo mais curtos, 36 printf quotn estamos realmente recebendo mais dinheiro em interest. nquot Aqui está a amostra de entrada e saída da Listagem 4.3. Testme Se juros é aplicado no final do ano O valor futuro para um empréstimo de 5000 em uma TAEG de 3,5 por 10 anos é 7052.99 Se juros é aplicado no final de cada mês O valor futuro para um empréstimo de 5000 a uma TAEG de 3,5 para 120 meses é 7091.72 A diferença de valor é 38.73 Portanto, aplicando juros em períodos de tempo mais curtos estamos realmente recebendo mais dinheiro em juros. A revelação na saída é o resultado da comparação de valores entre fv1 e fv2. O valor de fv1 é calculado com a aplicação de juros uma vez por ano durante a vida útil da obrigação. Fv2 é o valor se o juro for aplicado mensalmente à taxa de juros mensal equivalente. O pacote Finance. pm é mostrado na Listagem 4.4 em seus estágios iniciais de desenvolvimento. Listagem 4.4. O pacote Finance. pm. 1 pacote Finanças 2 3 exigem exportador 4 ISA (exportador) 5 6 head1 Finance. pm 7 8 Calculadora financeira - cálculos financeiros tornados mais fáceis com Perl 9 10 cabeça 2 11 uso Finanças 12 13 pv 10000,0 14 15 taxa 12,5 12 APR por mês. 16 17 tempo 360 meses para o empréstimo a amadurecer 18 19 fv FutureValue () 20 21 impressão fv 22 23 corte 24 25 EXPORTAÇÃO 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 Finanças :: SetInterest () 40 meu deslocamento de taxa () 41 defaultTotal de interesse 42 printf quotn defaultInterest ratequot 43 44 45 -------------- -------------------------------------------------- ---- 46 Notas: 47 1. A taxa de juro r é dada num valor de 0-100. 48 2. O n dado nos termos é a taxa em que os juros 49 são aplicados. 50 51 ------------------------------------------------ -------------------- 52 53 ---------------------------- ---------------------------------------- 54 Valor presente de um investimento dado 55 fv - Um valor futuro 56 r - taxa por período 57 n - número do período 58 ---------------------------------- ---------------------------------- 59 sub Finance :: FutureValue () 60 meu (pv, r, n ) 61 meu fv pv ((1 (r100)) n) 62 retorno 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 do período 70 ------------------------------------ -------------------------------- 71 sub Finance :: PresentValue () 72 meu pv 73 meu (fv, r, N) 74 pv fv ((1 (r100)) n) 75 pv de retorno 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 meu oneR 89 my (mp, r, n) 90 91 oneR (1 r) n 92 fv mp ((umR - 1) r) 93 retorno fv 94 95 96 --------------------------------- ----------------------------------- 97 Obtenha a anuidade dos seguintes bits de informação 98 r - rate per Período 99 n - número do período 100 fv - Valor Futuro 101 ------------------------------------- ------------------------------- 102 103 sub AnnuityOfFV () 104 meu mp mp - Pagamento Mensal de Anuidade 105 meu oneR 106 (F, r, n) 107 108 1R) n 109 mp fv (r (1R-1)) 110 retorno mp 111 112 113 ----------------- -------------------------------------------------- - 114 Obtém 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 meu i 122 123 meu a 0 124 retorno 0 se (contagem 0) 125 para (i 0 contagem i) 126 a valoresnumber - i - 1 127 128 retornar uma contagem 129 130 131 --- -------------------------------------------------- --------------- 132 Obtenha 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 subrotina mostrada aqui 137 também está sendo usada para ilustrar como passar ponteiros.) A referência à matriz de valores 138 é passada em seguida, seguida de uma Referência ao local onde os valores de retorno devem ser armazenados. 140 141 sub getMovingAve () 142 meu (contagem, número, valores, movingAve) 143 meu i 144 meu a 0 145 meu v 0 146 147 retorno 0 se (contagem 0) 148 retorno -1 se (contagem número gt) 149 retorno - 2 if (lt 2) 150 151 movingAve0 0 152 movingAvenumber - 1 0 153 para (i0 iltcounti) 154 v valuesi 155 av count 156 movingAvei 0 157 158 para (icount numeração) 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 Examine a declaração da função FutureValue com (). Os três sinais do dólar junto significam três números scalar que estão sendo passados na função. Esse escopo extra está presente para validar o tipo de parâmetros passados para a função. Se você passar uma string em vez de um número para a função, você receberia uma mensagem muito semelhante a esta: Muitos argumentos para Finance :: FutureValue na linha. f4.pl 15, próximo quottime) quot Execução de. f4.pl cancelado devido a erros de compilação. O uso de protótipos ao definir funções impede que você envie valores diferentes do que a função espera. Use ou para passar em uma matriz de valores. Se você estiver passando por referência, use ou para mostrar uma referência escalar para um array 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. Now, lets look at the lastMovingAverage function declaration, which specifies two integers in the front followed by an array. The way the arguments are used in the function is to assign a value to each of the two scalars, count and number . whereas everything else is sent to the array. Look at the function getMovingAverage() to see how two arrays are passed in order to get the moving average on a list of values. The way to call the getMovingAverage function is shown in Listing 4.5. Listing 4.5. Using the moving average function. 1 usrbinperl - w 2 3 push(Inc, pwd) 4 use Finance 5 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 ---------------------------------------------------------------- 13 Calculate the average of the above function 14 ---------------------------------------------------------------- 15 ave Finance::getLastAverage(5,size, values) 16 print quotn Average of last 5 days ave nquot 17 18 Finance::getMovingAve(5,size, values, mv) 19 print quotn Moving Average with 5 days window n nquot Heres the output from Listing 4.5: Values to work with Number of values 14 Average of last 5 days 26.2 The getMovingAverage() function takes two scalars and then two references to arrays as scalars. 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.This is an Evergreen Joe Celko question. Eu ignoro qual plataforma DBMS é usada. Mas, em qualquer caso, Joe foi capaz de responder há mais de 10 anos com o SQL padrão. A tentativa de última atualização sugere que poderíamos usar o predicado para construir uma consulta que nos daria uma média móvel: A coluna extra ou a abordagem de consulta melhor A consulta é tecnicamente melhor porque a abordagem UPDATE Desnormalizar o banco de dados. No entanto, se os dados históricos que estão sendo gravados não vai mudar ea computação da média móvel é cara, você pode considerar usar a abordagem de coluna. SQL consulta Quebra-cabeça: por todos os meios uniforme. Você joga apenas para o balde de peso apropriado, dependendo da distância do ponto de tempo atual. Por exemplo quottake weight1 para datapoints dentro de 24hrs de datapoint atual weight0.5 para datapoints dentro de 48hrsquot. Esse caso importa quanto pontos de dados consecutivos (como 6:12 am e 11:48 pm) estão distantes uns dos outros Um caso de uso que eu posso pensar seria uma tentativa de suavizar o histograma onde quer que os pontos de dados não são densos o suficiente ndash msciwoj May 27 15 at 22:22 Eu não tenho certeza que seu resultado esperado (saída) mostra clássico simples movendo (rolando) média de 3 dias. Porque, por exemplo, o primeiro triplo de números por definição dá: mas você espera 4.360 e sua confusão. No entanto, sugiro a seguinte solução, que usa a função de janela AVG. Essa abordagem é muito mais eficiente (clara e menos intensiva em recursos) do que o SELF-JOIN introduzido em outras respostas (e estou surpreso que ninguém tenha dado uma solução melhor). Você vê que o AVG está envolvido com o caso quando rownum gt p. days, em seguida, para forçar NULL s nas primeiras linhas, onde 3 dias Moving Average é sem sentido. Respondeu Feb 23 16 at 13:12 Podemos aplicar Joe Celkos suja deixada externa juntar método (como citado acima por Diego Scaravaggi) para responder à pergunta como foi perguntado. Gera a saída solicitada: respondeu Jan 9 16 at 0:33 Sua resposta 2017 Stack Exchange, Inc
No comments:
Post a Comment