rrdgraphexamples Skift data framåt med en vecka (604800 sekunder) Om den specialiserade funktionen RRA finns för avvikande beteende detektering, kan de användas för att generera grafen för en tidsserie med konfidensband och fel. I det här exemplet genereras en graf för dataserien i blått (LINE2 med scaledobs virtuella datakälla), konfidensgränser i virtuella datakällor (scaledupper och scaledlower-virtuella källor) och potentiella fel (dvs potentiellt avvikande avvikande beteende) markerade med vertikala gula linjer ( feldatakällan). Rådata kommer från en genomsnittlig RRA. Den finaste upplösningen av de observerade tidsserierna (en konsoliderad datapunkt per primär datapunkt). De förutspådda (eller jämnade) värdena lagras i HWPREDICT RRA. De förväntade avvikelserna (tänk standardavvikelse) värden lagras i DEVPREDICT RRA. Slutligen innehåller FAILURES RRA indikatorer, där 1 betecknar ett potentiellt misslyckande. Alla data återkalsas till bitar (i stället för oktetter) genom att multiplicera med 8. Förtroendegränserna beräknas med en förskjutning av 2 avvikelser både över och under de förutsagda värdena (CDEFs övre och nedre). Vertikala linjer indikerade att potentiella fel grafiseras via TICK-grafelementet, vilket omvandlar icke-nollvärden i ett RRA till fältmarkeringar. Här betyder ett axelfraktionsargument på 1,0 att fältmarkeringen spänner över hela y-axeln och blir följaktligen vertikala linjer i diagrammet. Valet av 2 avvikelser (en skaleringsfaktor) matchar den standard som används internt av FAILURES RRA. Om det interna värdet ändras (se rrdtune), bör detta grafikkommando ändras för att vara konsekvent. Kommandot rrdtool graph är utformat för att plotta data vid en bestämd tidsmässig upplösning, oavsett den faktiska upplösningen av data i RRD-filen. Detta kan innebära ett problem för de specialiserade konsolideringsfunktionerna som upprätthåller en en-till-en-kartläggning mellan primära datapunkter och konsoliderade datapunkter. Om en graf insisterar på att se innehållet i dessa RRA i grov temporär skala försöker grafkommandot att göra något intelligent, men konfidensband och misslyckanden har inte längre samma betydelse och kan vara vilseledande. rrdgraph ger en översikt över hur rrdtool graf fungerar. rrdgraphdata beskriver DEF, CDEF och VDEF i detalj. rrdgraphrpn beskriver det RPN-språk som används i xDEF-uttalandena. rrdgraphgraph-sidan beskriver alla graf - och utskriftsfunktioner. Program av Tobias Oetiker 60tobioetiker. ch62 Denna bruksanvisning av Alex van den Bogaerdt 60alexvandenbogaerdt. nl62 med korrigeringar och tillägg av flera personerDetta kapitel introducerar dig till begreppen bakom referenser till Perl-moduler, paket och klasser. Det visar också hur du skapar några provmoduler. En Perl-modul är en uppsättning Perl-kod som fungerar som ett bibliotek med funktionssamtal. Termen modul i Perl är synonym med ordet paket. Paket är en funktion av Perl 4, medan moduler är vanliga i Perl 5. Du kan behålla all din återanvändbara Perl-kod som är specifik för en uppsättning uppgifter i en Perl-modul. Därför finns all funktionalitet som avser en typ av uppgift i en fil. Det är lättare att bygga en applikation på dessa modulära block. Ordmodulen gäller därför lite mer än paketet. Här är en snabb introduktion till moduler. Vissa ämnen i detta avsnitt kommer att beskrivas i detalj under resten av boken. Läs följande avsnitt noggrant för att få en översikt över vad som ligger framåt när du skriver och använder dina egna moduler. Vad som är förvirrande är att termoelementet och paketet används utbytbart i alla Perl-dokumentation, och dessa två termer betyder detsamma. Så när du läser Perl-dokument, tänk bara på quotpackagequot när du ser quotmodulequot och vice versa. Så, vad är förutsättningen för att använda moduler Tja, moduler finns där för att paketera (pardon pun) variabler, symboler och sammankopplade dataposter tillsammans. Till exempel använder du globala variabler med mycket vanliga namn som k. j. eller jag i ett program är i allmänhet inte en bra idé. Också en slinga, i. bör tillåtas arbeta självständigt i två olika delar av koden. Deklarera jag som en global variabel och sedan öka den från en subrutin kommer att skapa omanagliga problem med din ansökningskod eftersom subrutinen kan ha blivit kallad från en loop som också använder en variabel som heter i. Användningen av moduler i Perl tillåter variabler med samma namn som ska skapas på olika, olika platser i samma program. Symbolerna som definieras för dina variabler lagras i en associativ array, kallad symboltabell. Dessa symboltabeller är unika för ett paket. Därför kan variabler med samma namn i två olika paket ha olika värden. Varje modul har sin egen symboltabell över alla symboler som deklareras inom den. Symboltabellen isolerar i synnerhet synonyma namn i en modul från en annan. Symboltabellen definierar en namnrymd. det vill säga ett utrymme för oberoende variabla namn finns i. Således förhindrar användningen av moduler, var och en med sin egen symboltabell, en variabel som deklareras i ett avsnitt från att skriva över värdena för andra variabler med samma namn som deklareras på annat håll i samma program. Faktum är att alla variabler i Perl tillhör ett paket. Variablerna i ett Perl-program hör till huvudpaketet. Alla andra paket inom ett Perl-program är antingen kapslade i detta huvudpaket eller finns på samma nivå. Det finns några riktigt globala variabler, som signalbehandlaren SIG. som är tillgängliga för alla andra moduler i ett applikationsprogram och kan inte isoleras via namnområden. Endast de variabla identifierare som börjar med bokstäver eller understreck hålls i en modulsymboltabell. Alla andra symboler, till exempel namnen STDIN. STDOUT. STDERR. ARGV. ARGVOUT. ENV. Inc. och SIG tvingas vara i paketets huvud. Byte mellan paket påverkar bara namnrymden. Allt du gör när du använder ett paket eller en annan är att förklara vilket symbolbord som ska användas som standardtabell för uppslag av variabla namn. Endast dynamiska variabler påverkas av användningen av symboltabeller. Variabler som deklareras av användningen av mitt sökord löses fortfarande med kodblocket som de råkar vara bosatta i och refereras inte genom symboltabeller. Faktum är att en paketdeklarations omfattning fortfarande är aktiv endast inom kodblocket som deklareras. Därför om du byter symboltabeller genom att använda ett paket i en subrutin, kommer den ursprungliga symboltabellen som var i kraft när samtalet gjordes att återställas när subrutinen återvänder. Omkopplingssymboltabeller påverkar bara standarduppslaget av dynamiska variabla namn. Du kan fortfarande explicit hänvisa till variabler, filhanteringar och så vidare i ett specifikt paket genom att lägga ut ett paketnamn. till variabelnamnet. Du såg vad ett paketkontext var när du använde referenser i kapitel 3. Ett paketkontext innebär helt enkelt användningen av symboltabellen av Perl-tolken för att lösa variabla namn i ett program. Genom att byta symboltabeller byter du paketkontexten. Moduler kan nästas i andra moduler. Den kapslade modulen kan använda variablerna och funktionerna i den modul som den är kapslad inuti. För kapslade moduler måste du använda modulnamn. nestedModuleName och så vidare. Att använda dubbelt kolon (::) är synonymt med att använda ett tillbaka citat (). Dubbel kolon är dock det föredragna, framtida sättet att adressera variabler inom moduler. Explicit adressering av modulvariabler görs alltid med en fullständig referens. Antag att du har en modul, Investment. vilket är standardpaketet som används och du vill adressera en annan modul, obligationer. som är indelad inom investeringsmodulen. I det här fallet kan du inte använda Bond ::. I stället måste du använda Investment :: Bond :: för att adressera variabler och funktioner inom Bond-modulen. Använda Bond :: skulle innebära användning av ett paket Bond som är näst i huvudmodulen och inte inom investeringsmodulen. Symboltabellen för en modul lagras faktiskt i en associativ grupp av modulnamnen bifogade med två kolonner. Symboltabellen för en modul som heter Bond kommer att kallas den associativa gruppen Bond ::. Namnet på symboltabellen för huvudmodulen är huvud ::. och kan till och med kortas till ::. På samma sätt har alla kapslade paket sina symboler lagrade i associativa arrays med dubbla kolon som skiljer varje nestningsnivå. Till exempel, i Bond-modulen som är indelad inom investeringsmodulen, kommer den associativa gruppen för symbolerna i Bond-modulen att kallas Investeringar :: Bond ::. En typeglob är verkligen en global typ för ett symbolnamn. Du kan utföra aliasingoperationer genom att tilldela en typglob. En eller flera poster i en associativ grupp för symboler kommer att användas när en uppgift via en typglob används. Det verkliga värdet i varje post i den associativa arrayen är vad du hänvisar till när du använder variabelnamnnotationen. Således finns det två sätt att hänvisa till variabla namn i ett paket: Investeringar :: pengar Investeringar :: räkningar I den första metoden hänvisar du till variablerna via en typeglobreferens. Användningen av symboltabellen Investeringar ::. är underförstådd här, och Perl kommer att optimera uppslaget för symboler pengar och räkningar. Detta är det snabbare och föredragna sättet att adressera en symbol. Den andra metoden använder en sökning för värdet av en variabel adresserad av pengar och räkningar i den associativa arrayen som används för symboler, Investeringar :: explicit. Denna lookup skulle ske dynamiskt och kommer inte att optimeras av Perl. Därför kommer uppslaget att tvingas att kontrollera den associativa gruppen varje gång uttalandet utförs. Som ett resultat är den andra metoden inte effektiv och bör endast användas för demonstration av hur symboltabellen implementeras internt. Ett annat exempel i detta uttalande kamran husain orsakar variabler, subrutiner och filhandtag som heter via symbolen kamran för att också adresseras via symbolen husain. Det vill säga att alla symbolposter i det nuvarande symbolbordet med nyckel kamran nu kommer att innehålla hänvisningar till de symboler som adresseras av nyckelhuven. För att förhindra en sådan global uppgift kan du använda uttryckliga referenser. Till exempel kommer följande uttalande att låta dig adressera innehållet i husän via den variabla kamranen. kamran husain Men alla arrays som kamran och husain kommer inte att vara desamma. Endast vad hänvisningarna specifikt kommer att ändras. För att sammanfatta, när du tilldelar en typeglob till en annan, påverkar du alla poster i ett symbolbord oavsett vilken typ av variabel som refereras till. När du tilldelar en referens från en variabel typ till en annan påverkar du bara en post i symboltabellen. En Perl-modulfil har följande format: paketmodulnamn. Sätt in modulkoden. 1 Filnamnet måste kallas ModuleName. pm. Namnet på en modul måste sluta i strängen. pm enligt konventionen. Paketet är den första raden i filen. Den sista raden i filen måste innehålla raden med 1-satsen. Detta ger i själva verket ett sant värde till applikationsprogrammet med hjälp av modulen. Om du inte använder 1-satsen kommer inte modulen att laddas korrekt. Paketutlåtandet berättar Perl-tolken att börja med en ny namnområdesdomän. I princip hör alla dina variabler i ett Perl-skript till ett paket som heter huvud. Varje variabel i huvudpaketet kan betecknas som huvudvariabel. Häri syntaxen för sådana referenser: packageNamevariableName Det enda citatet () är synonymt med dubbelt kolon (::) operatören. Jag täcker fler användningar av :: operatören i nästa kapitel. För tillfället måste du komma ihåg att följande två uttalanden är likvärdiga: packageNamevariableName packageName :: variableName Synkroniseringen med dubbla kolonner anses vara standard i Perl-världen. Därför, för att bevara läsbarheten använder jag dubbla kolonnsyntaxen i resten av denna bok om det inte är absolut nödvändigt att göra undantag för att bevisa en punkt. Standardanvändningen av ett variabelnamn försvinner till det aktuella paketet som är aktivt vid sammansättningen. Således, om du är i paketet Finance. pm och ange en variabel pv. variabeln är faktiskt lika med Finance :: pv. Använda Perl-moduler: använd vs. kräver att du inkluderar Perl-moduler i ditt program med hjälp av användningen eller kravet. Heres sättet att använda något av dessa uttalanden: använd modulnamn kräver modulnamn Observera att. pm-tillägget inte används i koden som visas ovan. Observera också att ingen uppgift gör det möjligt att inkludera en fil mer än en gång i ett program. Det returnerade värdet av sant (1) som det sista uttalandet är nödvändigt för att låta Perl veta att en krav d eller använd d-modulen laddas korrekt och låter Perl-tolken ignorera eventuella omladningar. I allmänhet är det bättre att använda användningsmodulet än vad som krävs för modulmodul i ett Perl-program för att förbli kompatibelt med framtida versioner av Perl. För moduler kanske du vill överväga att fortsätta använda kraven. Heres varför: Användningsförklaringen fungerar lite mer än det krav som krävs genom att det ändrar namnskylten i modulen som innehåller en annan modul. Du vill ha den här extra uppdateringen av namnrymden som ska göras i ett program. Men när du skriver kod för en modul kanske du inte vill att namespace ska ändras om det inte uttryckligen krävs det. I det här fallet kommer du att använda kravet. Kravet innehåller en fullständig sökväg för en fil i Inc-arrayen så att funktionerna och variablerna i modulfilen är på en känd plats under exekveringstiden. Därför importeras de funktioner som importeras från en modul via en explicit modulreferens vid körning med kravet. Användningsdeklarationen gör detsamma som kravet på att det uppdateras Inc-serien med fullständiga sökvägar för laddade moduler. Koden för användningsfunktionen går också ett steg längre och kallar en importfunktion i modulen som används d för att uttryckligen ladda listan över exporterade funktioner vid kompileringstid, vilket sparar tid som krävs för en explicit upplösning av ett funktionsnamn under körning. I grund och botten motsvarar användningsförklaringen att det krävs en modulnamn-importmodullista med importerade funktioner Användningen av användningsdeklarationen ändrar ditt programs namnrymd eftersom de importerade funktionsnamnen sätts in i symboltabellen. Krävs uttalandet ändrar inte ditt programs namnutrymme. Följande uttalande använder modulnamn () motsvarar detta uttalande: kräver modulnamn Funktioner importeras från en modul via ett samtal till en funktion som kallas import. Du kan skriva en egen importfunktion i en modul, eller du kan använda exportörsmodulen och använda dess importfunktion. I nästan alla fall kommer du att använda exportörsmodulen för att tillhandahålla en importfunktion istället för att återuppfinna hjulet. (Du kommer lära dig mer om detta i nästa avsnitt.) Om du väljer att inte använda Exporter-modulen måste du skriva en egen importfunktion i varje modul som du skriver. Det är mycket lättare att helt enkelt använda Exporter-modulen och låta Perl göra jobbet för dig. Sample Letter. pm-modulen Det bästa sättet att illustrera semantiken för hur en modul används i Perl är att skriva en enkel modul och visa hur man använder den. Låt oss ta exemplet på en lokal lånehaj, Rudious Maximus, som helt enkelt är trött på att skriva samma kvot för betalningsbrev. Att vara en ivrig fläkt av datorer och Perl tar Rudious de lazy programmerare och skriver en Perl-modul för att hjälpa honom att skapa sina noteringar och brev. Nu, istället för att skriva in fält i en memo-mallfil, är det bara att skriva några rader för att producera sin fina, hotande anteckning. Listning 4.1 visar vad han måste skriva. Notering 4.1. Använda Letter-modulen. 1 usrbinperl - w 2 3 Ovanstående linjen nedan för att inkludera den aktuella dir i Inc. 4 push (Inc, pwd) 5 6 använd Letter 7 8 Letter :: To (citationstecken), quotThe money for Lucky Dog, Race 2quot) 9 Brev :: ClaimMoneyNice () 10 Brev :: ThankDem () 11 Brev :: Finish () Användningsbokstäverna är närvarande för att tvinga Perl-tolken att inkludera koden för modulen i applikationsprogrammet. Modulen ska placeras i katalogen usrlibperl5, eller du kan placera den i en katalog som anges i Inc-arrayen. Inc-arrayen är listan över kataloger som Perl-tolken ska leta efter när man försöker ladda koden för den angivna modulen. Den kommenterade raden (nummer 4) visar hur man lägger till den aktuella arbetsmappen för att inkludera sökvägen. De följande fyra raderna i filen genererar ämnet för brevet. Heres utgången från att använda Brevmodulen: Till: Mr Gambling Man Fm: Rudious Maximus, Loan Shark Dt: Ons Feb 7 10:35:51 CST 1996 Re: Pengarna till Lucky Dog, Race 2 Det har kommit till min uppmärksamhet att ditt konto är långt över förfallet. Du betalar oss snart Eller vill du att jag ska komma okej Tack för ditt stöd. Brevmodulfilen visas i Listning 4.2. Paketets namn anges i första raden. Eftersom de här modulernas funktioner kommer att exporteras använder jag Exporter-modulen. Därför är uttalandet med Exporter krävs för att ärva i funktion från exportörsmodulen. Ett annat nödvändigt steg är att lägga ordet Exporterad i ISA-arrayen för att tillåta att söka efter exporterad. pm. ISA-arrayen är en särskild array inom varje paket. Varje objekt i arrayen listar var annat för att leta efter en metod om den inte kan hittas i det aktuella paketet. Ordningen i vilken paket är listade i ISA-arrayen är den ordning i vilken Perl söker efter olösta symboler. En klass som är listad i ISA-arrayen kallas basklassen för den särskilda klassen. Perl cachar bort saknade metoder som finns i basklasserna för framtida referenser. Om du ändrar ISA-matrisen spolas cacheminnet och får Perl att leta upp alla metoder igen. Låt oss nu titta på koden för Letter. pm i Listing 4.2. Notering 4.2. Letter. pm-modulen. 1 paket Brev 2 3 kräver exportör 4 ISA (Exporter) 5 6 huvud1 NAMN 7 8 Brev - Provmodul för att skapa brevhuvud för dig 9 10 huvud1 SYNOPSIS 11 12 Använd Brev 13 14 Brev :: Datum () 15 Brev :: Till (Namn , företag, adress) 16 17 Sedan ett av följande: 18 Brev :: ClaimMoneyNice () 19 Brev :: ClaimMoney () 20 Brev :: ThreatBreakLeg () 21 22 Brev :: ThankDem () 23 Brev :: Finish () 24 25 head1 BESKRIVNING 26 27 Den här modulen ger ett kort exempel på att generera ett brev för en 28 vänlig grannbödslånshark. 29 30 Koden börjar efter quotcutquot-satsen. 31 skära 32 33 EXPORT qw (Datum 34 till 35 Ansökningsvinst 36 ClaimMoneyNice 37 ThankDem 38 Avsluta) 39 40 41 Utskriftsdatum 42 43 Underrubrik :: Datum 44 Datumdatum 45 Utskrifts kvot Idag är datumkvot 46 47 48 sub Brev :: Till 49 lokalt (namn) skift 50 lokalt (ämne) skift 51 utskriftskvot Till: namnkvot 52 utskriftskvitton Fm: Rudious Maximus, Lån Sharkquot 53 utskriftskvot Dt: citat, datum 54 utskriftskvot Re: subjectquot 55 print quotnnquot 56 skriv ut quotnnquot 57 58 underbrev :: ClaimMoney () 59 tryckkvot Du är skyldig mig pengar. Få din handling togetherquot 60 print quotn Vill du att jag ska skicka Bruno över till citat 61 print quotn samla den. eller kommer du att betala upquot 62 63 64 subbrev :: ClaimMoneyNice () 65 print quotn Det är uppmärksammat att ditt konto är kvittot 66 utskriftskvot långt över due. quot 67 print quotn Du betalar oss snart .. skriv ut kvot eller vill du att jag ska komma ovahquot 69 70 71 underbrev :: ThreatBreakLeg () 72 skriv ut kvitto tydligen bokstäver som dessa dont helpquot 73 print quotn Jag måste göra ett exempel på youquot 74 print quotn n Se dig på sjukhuset , palquot 75 76 77 underrubrik :: ThankDem () 78 print quotnn Tack för ditt supportquot 79 80 81 underbrev :: Finish () 82 printf quotnnnn Vänlig hälsning 83 prenumerationskvitton Röddräkt 84 85 86 1 Linjer som innehåller lika tecken används för dokumentation. Du måste dokumentera varje modul för egen referens. Perl-moduler behöver inte dokumenteras, men det är en bra idé att skriva några rader om vad din kod gör. Några år från nu kan du glömma vad en modul handlar om. Bra dokumentation är alltid ett måste om du vill komma ihåg vad du gjorde tidigare täcker jag dokumentationsstilar som används för Perl i kapitel 8. quotDocumenting Perl Scripts. quot För den här provmodulen startar head1-dokumentationen dokumentationen. Allt upp till det snittiga uttalandet ignoreras av Perl-tolken. Därefter listas modulen alla funktioner som exporteras av denna modul i EXPORT-matrisen. EXPORT-arrayen definierar alla funktionsnamn som kan ringas av extern kod. Om du inte listar en funktion i EXPORT-matrisen kommer den inte att ses av externa kodmoduler. Efter EXPORT-matrisen är koden av koden, en subrutin åt gången. När alla subrutiner har definierats slutar slutrapporten 1 modulfilen. 1 måste vara den sista körbara raden i filen. Låt oss titta på några av de funktioner som definieras i den här modulen. Den första funktionen att titta på är den enkla Datum-funktionen, raderna 43 till 46, som skriver ut det aktuella UNIX-datumet och tiden. Det finns inga parametrar för denna funktion, och den returnerar inte något meningsfullt tillbaka till den som ringer. Notera användningen av min före datumvariabeln i rad 44. Mitt sökord används för att begränsa variabelns räckvidd till inom kretslocket för datumfunktioner. Kod mellan lockiga hängslen kallas ett block. Variabler som deklareras inom ett block är begränsade inom ramen för de krökta axlarna. I 49 och 50 är de lokala variablerna namn och ämne synliga för alla funktioner. Du kan också deklarera variabler med den lokala kvalificatören. Användningen av lokal gör det möjligt för en variabel att vara i räckvidd för det aktuella blocket såväl som för andra block av kod som kallas från detta block. Således är en lokal x deklarerad inom ett block synlig för alla efterföljande block som kallas från detta block och kan hänvisas till. I följande provkod kan accessnivån till ToTitled-funktionerna nås men inte data i iphone. 1 underbrev :: ToTitled 2 Local (name) shift 3 min (telefon) shift Samplingskoden för Letter. pm visade hur man extraherar en parameter i taget. Subrutinen To () tar två parametrar för att ställa in rubriken för memo. Att använda funktioner inom en modul är inte annorlunda än att använda och definiera Perl-moduler inom samma kodfil. Parametrar skickas genom referens om inget annat anges. Multipla arrays passerade in i en subrutin, om de inte uttryckligen avlägsnades med hjälp av backslash, sammanfogas. Inmatningsraden i en funktion är alltid en uppsättning av skalärvärden. Passningsvärden genom referens är det föredragna sättet i Perl att skicka en stor mängd data till en subrutin. (Se kapitel 3. quotReferences. quot) En annan provmodul: Finans Finansmodulen, som visas i Listning 4.3, används för att ge enkla beräkningar för lånevärden. Att använda Finance-modulen är okomplicerad. Alla funktioner skrivs med samma parametrar, som visas i formeln för funktionerna. Låt oss se hur det framtida värdet av en investering kan beräknas. Till exempel, om du investerar några dollar, pv. i ett obligationslån som erbjuder en fast procentuell ränta, r. appliceras med kända intervaller under n tidsperioder, vad är värdet av bindningen vid utgången av det här datumet. I så fall ska du använda följande formel: fv pv (1r) n Funktionen för att få framtidens värde deklareras som FutureValue . Se Lista 4.3 för att se hur du använder den. Notering 4.3. Använda finansmodulen. 1 usrbinperl - w 2 3 push (Inc, pwd) 4 använd Ekonomi 5 6 lån 5000,00 7 apr 3,5 apr 8 år 10 år. 9 10 ------------------------------------------------ ---------------- 11 Beräkna värdet vid slutet av lånet om ränta 12 tillämpas varje år. 13 ------------------------------------------------- --------------- 14 tid år 15 fv1 Finans :: FutureValue (lån, apr, tid) 16 print kvot Om ränta tillämpas vid årsskiftets slut 17 Skriv ut kvot Det framtida värdet för en lån av kvoter lån. quotnquot 18 prenumerera på ett APR av kvot, apr. citationstecken för tid, kvot årskurs 19 utgåva kvot är 8,2f nquot. fv1 20 21 ----------------------------------------------- ----------------- 22 Beräkna värdet vid slutet av lånet om ränta 23 tillämpas varje månad. 24 ------------------------------------------------- --------------- 25 betyg 12 april 26 april år 12 i månader 27 fv2 Finans :: FutureValue (lån, ränta, tid) 28 29 print quotn Om ränta tillämpas vid slutet av varje månadskvot 30 tryckkvot Det framtida värdet för ett lån på kvot. lån. quotnquot 31 prenumerera på ett APR av cv, apr. citationstecken för kvot, tid, månadskvot 32 printf citationstecken är 8.2f nquot. fv2 33 34 printf quotn Skillnaden i värde är 8.2fquot, fv2 - fv1 35 printf quotn Därför får du genom att använda ränta vid kortare tidsperioder, 36 printf-kvoter, vi faktiskt få mer pengar i intresse. notot Här är provinmatning och utmatning av Listing 4.3. testme Om räntan tillämpas vid årets slut Det framtida värdet på ett lån på 5000 till ett APR på 3,5 år för 10 år är 7052,99 Om räntan tillämpas vid slutet av varje månad Det framtida värdet för ett lån på 5000 till ett APR på 3,5 för 120 månader är 7091,72 Skillnaden i värde är 38,73 Därför får vi rent mer pengar i intresse genom att tillämpa ränta på kortare perioder. Uppenbarelsen i utgången är resultatet av jämförelsen av värden mellan fv1 och fv2. Fv1-värdet beräknas med tillämpning av ränta en gång per år under obligationslivets livslängd. fv2 är värdet om räntan tillämpas varje månad till motsvarande månatlig ränta. Paketet Finance. pm visas i Lista 4.4 i dess tidiga utvecklingsstadier. Notering 4.4. Finance. pm-paketet. 1 paket Finans 2 3 kräver exportör 4 ISA (Exportör) 5 6 head1 Finance. pm 7 8 Finansiell kalkylator - Finansiella beräkningar görs enkelt med Perl 9 10 huvud 2 11 Användning Finans 12 13 pv 10000,0 14 15 ränta 12,5 12 APR per månad. 16 17 tid 360 månader för lån till mogna 18 19 fv FutureValue () 20 21 print fv 22 23 cut 24 25 EXPORT qw (FutureValue, 26 PresentValue, 27 FVofAnnuity, 28 AnnuityOfFV, 29 getLastAverage, 30 getMovingAverage, 31 SetInterest) 32 33 34 Globals, om någon 35 36 37 lokal defaultInterest 5,0 38 39 sub Finans :: SetInterest () 40 min kursförskjutning () 41 defaultInterest rate 42 printf quotn defaultInterest ratequot 43 44 45 -------------- -------------------------------------------------- ---- 46 Anteckningar: 47 1. Räntan r anges i ett värde av 0-100. 48 2. Den n som anges i villkoren är den takt som räntan 49 appliceras på. 50 51 ------------------------------------------------ -------------------- 52 53 ---------------------------- ---------------------------------------- 54 Nuvärdet av en investering som ges 55 fv - ett framtida värde 56 r - kurs per period 57 n - antal period 58 ---------------------------------- ---------------------------------- 59 sub Finance :: FutureValue () 60 min (pv, r, n ) 61 min fv pv ((1 (r100)) n) 62 retur fv 63 64 65 ------------------------------ -------------------------------------- 66 Nuvärdet av en investering som ges 67 fv - en framtid värde 68 r - pris per period 69 n - antal period 70 ------------------------------------ -------------------------------- 71 sub Finance :: PresentValue () 72 min pv 73 min (fv, r, n) 74 pv fv ((1 (r100)) n) 75 retur pv 76 77 78 79 ----------------------------- --------------------------------------- 80 Få det framtida värdet av en livränta som ges 81 mp - Månatlig betalning av livränta 82 r - skattesats per period 83 n - nummer o f period 84 ----------------------------------------------- --------------------- 85 86 sub FVofAnnuity () 87 min fv 88 min oneR 89 min (mp, r, n) 90 91 oneR (1r) n 92 fv mp ((oneR - 1) r) 93 return fv 94 95 96 --------------------------------- ----------------------------------- 97 Få livränta från följande bitar av information 98 r - rate per period 99 n - antal period 100 fv - framtida värde 101 ------------------------------------- ------------------------------- 102 103 under AnnuityOfFV () 104 min mp mp - Månadsbetalning av livränta 105 min oneR 106 min (fv, r, n) 107 108 enR (1 r) n 109 mp fv (r (oneR - 1)) 110 retur smp 111 112 113 ----------------- -------------------------------------------------- - 114 Hämta medelvärdet av de sista quotnotvärdena i en array. 115 ------------------------------------------------- ------------------- 116 Det sista räkneantalet av element från arrayen i värden 117 Det totala antalet element i värden är i antal 118 119 sub getLastAverage () 120 min (räkning, antal, värden) 121 min i 122 123 min a 0 124 retur 0 om (räkna 0) 125 för (i 0 ilträkning i) 126 a värdenummer - i - 1 127 128 returnera ett tal 129 130 131 --- -------------------------------------------------- --------------- 132 Få ett glidande medelvärde av värdena. 133 ------------------------------------------------- ------------------- 134 Fönstermåttet är den första parametern, antalet poster i 135 passerade matrisen är nästa. (Det här kan enkelt beräknas inom 136-funktionen med funktionen skalar (), men den nedan angivna subrutinen används också för att illustrera hur man ska skicka pekare.) Referensen till värdena av värdena matas vidare, följt av en hänvisning till platsen 139 returvärdena ska lagras. 140 141 sub getMovingAve () 142 min (antal, antal, värden, movingAve) 143 min i 144 min a 0 145 min v 0 146 147 returnera 0 om (räkna 0) 148 returnera -1 om (räkna gt nummer) 149 returnera - 2 if (count lt 2) 150 151 movingAve0 0 152 movingAvenumber - 1 0 153 för (i0 iltcounti) 154 v värdeni 155 av räkne 156 movingAvei 0 157 158 för (icount iltnumberi) 159 v värdeni 160 av räkning 161 v värdeni - räkning - 1 162 a - v count 163 movingAvei 164 165 retur 0 166 167 168 1 Titta på deklarationen av funktionen FutureValue med (). De tre dollar tecknen tillsammans innebär att tre skalär tal sänds in i funktionen. Denna extra scoping är närvarande för att validera typen av parametrar som passerat till funktionen. Om du skulle skicka en sträng i stället för ett nummer i funktionen skulle du få ett meddelande som mycket liknar det här: För många argument för Finance :: FutureValue vid. f4.pl linje 15, nära quottime) c Execution of. f4.pl avbrutet på grund av kompileringsfel. Användningen av prototyper vid definition av funktioner hindrar dig från att skicka in andra värden än vad funktionen förväntar sig. Använd eller för att passera i en rad värden. Om du refererar till referens, använd eller för att visa en skalärreferens till en array eller hash. Om du inte använder backslash ignoreras alla andra typer i prototypen för argumentlistan. Andra typer av diskvalificatorer inkluderar en ampersand för en referens till en funktion, en asterisk för vilken typ som helst och en semikolon för att indikera att alla andra parametrar är valfria. 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. Jag ignorerar vilken DBMS-plattform som används. Men i alla fall kunde Joe svara mer än 10 år sedan med standard SQL. Joe Celko SQL Pussel och svar citation: Det senaste uppdateringsförsöket antyder att vi skulle kunna använda predikatet för att konstruera en fråga som skulle ge oss ett glidande medelvärde: Är den extra kolumnen eller frågeställningen bättre Frågan är tekniskt bättre eftersom UPDATE-metoden kommer att denormalisera databasen. Om de historiska data som registreras inte kommer att förändras och beräkningen är det rörliga genomsnittet är dyrt, kan du överväga att använda kolumninriktningen. SQL Pusselfråga: för all del enhetlig. Du kastar bara till lämplig vikthink beroende på avståndet från aktuell tidpunkt. Till exempel kvittot vikt1 för datapoäng inom 24 timmar från nuvarande datapoint weight0.5 för datapoäng inom 48hrsquot. I det fallet spelar det roll hur mycket efterföljande datapoäng (som 6:12 och 11:48) är avlägsna från varandra. Ett användningsfall som jag kan tänka på skulle vara ett försök att släta histogramet där datapunkter inte är täta nog. Ndash msciwoj 27 maj 15 på 22:22 Jag är inte säker på att ditt förväntade resultat (output) visar klassiskt enkelt rörligt (rullande) medelvärde i 3 dagar. Eftersom exempelvis den första trippeln av siffror per definition ger: men du förväntar dig 4,360 och det är förvirrande. Ändå föreslår jag följande lösning, som använder fönsterfunktion AVG. Detta tillvägagångssätt är mycket effektivare (klart och mindre resursintensivt) än SELF-JOIN infört i andra svar (och jag är förvånad över att ingen har givit en bättre lösning). Du ser att AVG är förpackad med fall då rownum gt pays sedan för att tvinga NULL s i första raden, där 3 dagars rörande medelvärde är meningslöst. svarade 23 februari 16 kl 13:12 Vi kan använda Joe Celkos smutsiga vänster yttre anslutningsmetod (som citerad ovan av Diego Scaravaggi) för att svara på frågan som den ställdes. Generates the requested output: answered Jan 9 16 at 0:33 Your Answer 2017 Stack Exchange, Inc
No comments:
Post a Comment