timeSeries/0000755000176000001440000000000012140125101012376 5ustar ripleyuserstimeSeries/MD50000644000176000001440000002426612140125101012720 0ustar ripleyuserscf3f989c24c9afd694949ebcef28fae6 *ChangeLog f1f33bb49f37bb7dfa2fd45dc835820d *DESCRIPTION 66ef515797290a1c361cc351d79841a7 *NAMESPACE ebc257531e5df7b8c51f923c1ce2d1f9 *R/AllClass.R 986ff4a7732a0be3985408bd195f6134 *R/AllGeneric.R 347cdf20d4b2289ee4e0d28422729462 *R/aaa-Deprecated.R ea6df6f4e86075afa23b71770d562840 *R/base-apply.R 28f9eba9e78f7336f2883a45a93cfead *R/base-attach.R de266f28352a206c4e5d3a8eb779b97a *R/base-cbind.R 2eeca7a21c26761502206062612fb560 *R/base-diff.R ea71fcbfaa1a702a7477eef25244244d *R/base-dim.R edca49510c5dd70bd94d7ffd9d392a4c *R/base-merge.R 5571063d5a2df380ecfb95fc1d509cb1 *R/base-rank.R a00b57f8ede1b3d6d1e74cbec7c38bab *R/base-rev.R a4ab768410837ac64ea14dab3f463fe7 *R/base-sample.R d0b2a4ed49f3ab4bd71aaf5c8ba933eb *R/base-scale.R 8b2ece5fb392489978d20cad444b84b3 *R/base-sort.R 3b5d882044aea7a06318630483a58903 *R/base-start.R ab4f46c1ea8a7f3c5a1c246b743e5264 *R/base-subset.R 668a0499be18f2991b18b43e7e7be9cf *R/base-subsetting.R 787d5636b21ee586692fa57b10271810 *R/base-t.R d41d8cd98f00b204e9800998ecf8427e *R/data-examples.R 0332216b8979a790975086317ca9f3ce *R/fin-align.R 8b34763dd7cb183e4518fb305b94f090 *R/fin-cumulated.R 54f9517f06f4e04b9d9bbbb8c07f4e93 *R/fin-daily.R 07e39d90316f0ff470167b9fae88e6ff *R/fin-drawdowns.R 131e1e4aa6636df82259ef9665362d79 *R/fin-durations.R 67ec6073ebf7d291725044d3f15176c6 *R/fin-monthly.R 78670ff47f437c5b7290ea4d8ffd448c *R/fin-periodical.R 69cec6cf4fdd4869e2cc8f84d246996b *R/fin-returns.R b4c64e66d5c802e514d38c08044dc7cb *R/fin-runlengths.R 205d5b79a5161e8e7eaf1520a2cf121b *R/fin-splits.R 7aa1a1ed9a7c3fa8de49fa6aed2f5c08 *R/fin-spreads.R 440d8d3daf4e97ed30069a5bcad26aa8 *R/fin-turnpoints.R c05c98f89b4f32fc376dee43082fd71a *R/methods-as.R 58f5a50dfbf8669c239615e1ccdbf58f *R/methods-comment.R 542f896dd39d377ccc9b91242d2cf02a *R/methods-is.R 0460cf41cccd7c62e0aefe2b482db7fc *R/methods-mathOps.R 528fc1767dcf958332dc10f93d5663ee *R/methods-plot.R 313a83baf9d2a2ff221fb09c78bc819e *R/methods-show.R 4e252059ec665d2650267d3fc8b8a098 *R/statistics-colCumsums.R 92117bad84cd47d95a11bc5fb88d7e25 *R/statistics-colSums.R 88a7e055e296e25f9c7d45f6bfae9ced *R/statistics-orderColnames.R 97d48f32243b61df5214da1acb00006d *R/statistics-orderStatistics.R 4e7187c17a34e389652ea79585e69bd2 *R/statistics-rollMean.R 2127cd77fff199b213284e448c4af346 *R/statistics-rowCumsums.R 4b889c1bf19dd81e71872eb621feeecf *R/statistics-smoothLowess.R 05e5a8eb2db8d2e6ff0f8719e8b6ef46 *R/stats-aggregate.R 0ad7fc0b4b419899bced1c79602f8aef *R/stats-filter.R 5dc36b1ce7572b35630e7338ab1c7f8c *R/stats-lag.R 6b8155afc716a3b640e16fdea6e003a1 *R/stats-model.frame.R 28eb9c7d10bb03ea64c5514a18f2014d *R/stats-na.contiguous.R aeee71a46662f134a84fdd74f0376e1e *R/stats-na.omit.R 06337c1348e786e33a0634e66d0214f1 *R/stats-window.R 4de0b93a16d24e7aeb1a584f4dc2a32f *R/timeSeries-dummy.R b6019c6be24f38b69ca42404d3a48a56 *R/timeSeries-getDataPart.R 56489f9b98c52a583063b3bec3841172 *R/timeSeries-isOHLC.R b6b29df5a4e9370f07e51a740ac84719 *R/timeSeries-isRegular.R 7c62bd60abd550fc3896d44de660bbc7 *R/timeSeries-isUnivariate.R b2e3d7f9c02b8015fc85de16e26ecaa6 *R/timeSeries-readSeries.R 184369cd20ebaf4cc05464ef17aa00f4 *R/timeSeries-signalCounts.R 3497ade73292c5dec2652335dd984588 *R/timeSeries-slotFinCenter.R 21fb8e437c058c8b89d48ff52a297b4e *R/timeSeries-slotSeries.R dc9e173fa59128f80b21225e3999ffa5 *R/timeSeries-slotTime.R 8db0473b89e630ae6290a6f168db1c8b *R/timeSeries-slotUnits.R ea15aeb6e86b03bd63e4029a103bcd25 *R/timeSeries.R 4f24ad3daf9dfd14c6f3b3ca847cb0a1 *R/utils-description.R d345cd583c4d6403b4d45687578922a2 *R/utils-head.R c4d5d58ff1dfb91f1c1db4e742d87c0c *R/utils-old2new.R 2d76dbcbae420743ba74789ec629faac *R/utils-structure.R e83fb0c03a5b5909b6be7103e364ec85 *R/zzz.R 08783f26722d600f1d895921a23adb91 *data/LPP2005REC.rda 99535a09b0b8189278aff6d651041d6f *data/MSFT.rda b59874b3fc70b45400dc76a7774bd34c *data/USDCHF.rda 575a9649d181e899167b5b7fd7811c4d *inst/COPYING 29ddc76d19a7435c4101fdbd13ec0146 *inst/COPYRIGHTS df11bf613071e8b06eaeeccab8e9faac *inst/README 68b329da9893e34099c7d8ad5cb9c940 *inst/THANKS d90ef228922a0262007e1e0d57d51960 *inst/unitTests/Makefile 89dc29af114e6a2a3c80a502b4f4c95b *inst/unitTests/runTests.R 63d0f736e1454c6745cb7aad063ef759 *inst/unitTests/runit.NA.R 94ab54bfea1b4edec5a3b5f04167d42b *inst/unitTests/runit.Omit.R 402ee2327b370fb07e5c53f84818825f *inst/unitTests/runit.TimeSeriesClass.R 8e685661d5ae69c3347782f6ce75d9a0 *inst/unitTests/runit.TimeSeriesCoercion.R 849fa2a5ae5a5b1f6d16e8b86ff3cac5 *inst/unitTests/runit.TimeSeriesData.R 90b7820b07832910daf1afd5dc224856 *inst/unitTests/runit.TimeSeriesPositions.R c132373dac907f3ce1ee549d855652d3 *inst/unitTests/runit.aggregate.R 54e1197ea897c2b1fed028f45cf3e1e8 *inst/unitTests/runit.align.R 3bda0d794fe86888602d8f23414f39f2 *inst/unitTests/runit.apply.R eb8242069cc228fb00172b9acfb35cdf *inst/unitTests/runit.as.R f2dee6d70982efbc28ae37bbb8ee57da *inst/unitTests/runit.attach.R cda8c7942140e7cfe218a2ce6bba0982 *inst/unitTests/runit.bind.R ec0eb8243b004d056ddd14a21f0f4e60 *inst/unitTests/runit.colCum.R f3fbf0a01f8c829180b87766b5dae26c *inst/unitTests/runit.colStats.R ecf69175edcff5551790c179f11db117 *inst/unitTests/runit.cor.R 7987dfe562590cc70bec48bde41142c0 *inst/unitTests/runit.cumulated.R 21c034e99f1666e27dcee33d785bb2da *inst/unitTests/runit.daily.R ef380731926ca03e283be11bf34e3f32 *inst/unitTests/runit.dim.R ddf81974440ba5c80cb35bbe6ea5213a *inst/unitTests/runit.drawdowns.R 320bf5c925d2f3abedea2da686730107 *inst/unitTests/runit.durations.R 4fd8879fb2feabc9530501e63a8b72d0 *inst/unitTests/runit.lag.R 776e1aa61e6f1a666fddfa4546e59286 *inst/unitTests/runit.mathOps.R efacc4efe053f3255399912767bc127e *inst/unitTests/runit.merge.R e0352cd00443ed64c2a0004bd4fb3fdc *inst/unitTests/runit.methods-plot.R e6868109cc1c537fea76ac57c333740a *inst/unitTests/runit.methods-print.R 3ad927a3804d96a9736216041a9a87e9 *inst/unitTests/runit.methods-summary.R 18fbd863b2c420249df32513d41dad5f *inst/unitTests/runit.model.frame.R 334271359fb9c749a7dfde8f6608defc *inst/unitTests/runit.monthly.R eb124eec56065e3395c63cab251bcf13 *inst/unitTests/runit.na.contiguous.R c3bf679bb5a7bdd5e3b9df1cf1a0d124 *inst/unitTests/runit.order.R d073d9b64074dc094dff6f987c519288 *inst/unitTests/runit.periodical.R 0965a3517f6e21aca3d18841387b1c5b *inst/unitTests/runit.rank.R a49a96a4356e8deae4b44daedab98373 *inst/unitTests/runit.returns.R d8ba4ac6486f022a81ab101ed8e631a3 *inst/unitTests/runit.rowCum.R d33bd4274e713eb2d401b53feb7c9461 *inst/unitTests/runit.signalCounts.R 9960b28a8601cb8f6f849107cfc8fc8d *inst/unitTests/runit.spreads.R ae94687a209d31a2a430a8a72f759483 *inst/unitTests/runit.subset.R 8c98a57d8736b0515851139c13a08036 *inst/unitTests/runit.time.R 31c51655d159665b6391203a329965ea *inst/unitTests/runit.timeSeries.R 3aacdeeee29c2506711db0f2c4a950e7 *man/00timeSeries-package.Rd 62e8d2d7a4e5da0c03c060803f9c4c90 *man/base-apply.Rd fa7a773441b5f5276b3d5c70386f70bc *man/base-attach.Rd 683bd36a1a974dabdb8e8cce098df138 *man/base-cbind.Rd ba608518d5e8aad0eff9177228ea1fe5 *man/base-diff.Rd 0d7bc4687cd11f2610ff99462f687e21 *man/base-dim.Rd 842d3836baa7aebbc4375d30c71bfd19 *man/base-merge.Rd 39b8a1952f16f1c045a77c0cd77d979d *man/base-rank.Rd 393c5320432848544a807a9b4973e1f3 *man/base-rev.Rd 19a15548084f3cf35305bad4d8478205 *man/base-sample.Rd 20d43b7e7cfddb182d786bddfd9b01c2 *man/base-scale.Rd 661220e102ba1533d2b3bbc26f8d0d67 *man/base-sort.Rd 1d35122f3ab88c752b7873040c90900d *man/base-start.Rd aea748507742cf7ad99a30a72624ee56 *man/base-subset.Rd 6b80bd6a4f5dd2af10270c9460f8d426 *man/base-subsetting.Rd 84aaf9bbd63e0f89d29e70d6dee896ae *man/base-t.Rd 35d34abe2d754918ba6f90965909e38d *man/data-examples.Rd 80cf5451f0bbeb7d5dfae0c798859323 *man/fin-align.Rd 91b80056851051452705b9fcbb4e8f06 *man/fin-cumulated.Rd 30c506c5ae7aadf0414a178382edaa8d *man/fin-daily.Rd 396272381c50bb673d52b50d2d0a86b5 *man/fin-drawdowns.Rd a49a9fb5ba06f0eba3ef0a74a937338d *man/fin-durations.Rd b87c20a77b141c075294999c1cb3efff *man/fin-monthly.Rd 0412aa46fbdbf6ce778014664b8176b8 *man/fin-periodical.Rd 1bc64b8c09a69ff2164fadfc5c9d4bb8 *man/fin-returns.Rd d7f765e7dfaf099a0ca015cc50d37664 *man/fin-runlengths.Rd bebff2b100c0e6e869951130d331adf0 *man/fin-splits.Rd 2a708241ccbd40d08bdb759bdba265b3 *man/fin-spreads.Rd a19ed896adebda92e6ab8e4a64dc6baa *man/fin-turnpoints.Rd 7b97d3dced76f0fa77e0ed78f8855ee7 *man/methods-as.Rd 661279498cd8d56cd3a3b0b33e3dc43f *man/methods-base.Rd 73cf06f477635b906b9fdd84dc11582b *man/methods-comment.Rd e77c109ade1a0e9a0c19825e51e72773 *man/methods-is.Rd 05b3e5042fd3a7f0c153e3f215a4fd01 *man/methods-mathOps.Rd 27f3df99a96669f25cb94f3ad29dc606 *man/methods-plot.Rd 2a602f61bd0733de1c1243fe30e89301 *man/methods-show.Rd da7db95577645a1b362d399bd7bf7c72 *man/methods-stats.Rd 699c2c2f02a41c219fe1e756397d94c2 *man/statistics-colCumsums.Rd c9a1c2942c562105850fa9e469d88b2a *man/statistics-colSums.Rd 93435dbbbc5ec02a84111ac7364e976e *man/statistics-orderColnames.Rd 9627526478e368b426f742c0aa511c91 *man/statistics-orderStatistics.Rd 99d24ae42af6303597243a7a8d1451eb *man/statistics-rollMean.Rd 62060fd02cc11cc9bd9e6fd184ab4289 *man/statistics-rowCumsums.Rd 62d6f88328d03e2c50aeadcfe5b6bd28 *man/statistics-smoothLowess.Rd 071d621811ae897ac055b84a818ddeba *man/stats-aggregate.Rd 045c7c7fabf69bdacc6036ff3b0cec2d *man/stats-filter.Rd 1c581f2794304edc7df42121cf24811e *man/stats-lag.Rd 3e91758241038d9ea5a319931177a441 *man/stats-model.frame.Rd 24ce47db3079e5392c6ef2f914b15d5b *man/stats-na.contiguous.Rd 7bc33c7e2db2d9d13d3d526bfafb5c63 *man/stats-na.omit.Rd 90214aad8fb62ce5e871d1d02c409768 *man/stats-window.Rd ecf919bd976dc902a6b1a2b71123aae5 *man/timeSeries-deprecated.Rd 228c80f19cf6f176c10977d79ac15518 *man/timeSeries-getDataPart.Rd 8ef91545cee4f3ae45caea4c679a55bc *man/timeSeries-isRegular.Rd a78785a2a8c31a4c0c30084e2770364e *man/timeSeries-isUnivariate.Rd 7a4d6aeca69153eb4add1859fcf64957 *man/timeSeries-readSeries.Rd fce0eaf91526a05e95f91f8d61b0d886 *man/timeSeries-slotFinCenter.Rd 4a6b746ba998d773bae0f6b7fa8d11be *man/timeSeries-slotSeries.Rd a3412d4c660ec641da23dd153eab09c2 *man/timeSeries-slotTime.Rd 0797db59edfb3b472970776aa3d23c1e *man/timeSeries-slotUnits.Rd 403069f480d6ab385534b133085b12d8 *man/timeSeries.Rd 49800352c3d12eb47acf6bc69a7cb711 *man/utils-description.Rd 75ac950d1297b4fb2a6909017977ccd2 *man/utils-structure.Rd 2f5fc3b43ee968e0dfdcf69c1e84424e *tests/doRUnit.R d9fbe377cad1b0d2f684d3b71f324966 *tests/msft.dat.csv timeSeries/tests/0000755000176000001440000000000011731573516013566 5ustar ripleyuserstimeSeries/tests/msft.dat.csv0000644000176000001440000003146411370220766016026 0ustar ripleyusers"X.Y..m..d";"Open";"High";"Low";"Close";"Volume" "1";"2000-09-27";63.4375;63.5625;59.8125;60.625;53077800 "2";"2000-09-28";60.8125;61.875;60.625;61.3125;26180200 "3";"2000-09-29";61;61.3125;58.625;60.3125;37026800 "4";"2000-10-02";60.5;60.8125;58.25;59.125;29281200 "5";"2000-10-03";59.5625;59.8125;56.5;56.5625;42687000 "6";"2000-10-04";56.375;56.5625;54.5;55.4375;68226700 "7";"2000-10-05";55.5;57.25;55.25;55.375;40549700 "8";"2000-10-06";55.8125;56.75;54.75;55.5625;30897000 "9";"2000-10-09";55.625;55.75;53;54.1875;29161800 "10";"2000-10-10";53.9375;55.5625;53.8125;54.5625;31033100 "11";"2000-10-11";54;56.9375;54;55.75;50602900 "12";"2000-10-12";56.3125;56.875;53.8125;54.375;45109800 "13";"2000-10-13";53.875;54.875;52.125;53.75;52260600 "14";"2000-10-16";53.5;53.8125;49.5625;50.375;59879500 "15";"2000-10-17";51.875;52.4375;50.25;50.4375;40638300 "16";"2000-10-18";49.625;53.25;48.4375;51.75;55268200 "17";"2000-10-19";58.4375;62.1875;58;61.875;128496600 "18";"2000-10-20";61.3125;66.125;61.125;65.1875;80189300 "19";"2000-10-23";64.625;66.25;60.6875;62.125;92585200 "20";"2000-10-24";62.625;62.9375;60.1875;61.5;47213700 "21";"2000-10-25";61.9375;63.4375;60.4375;61.25;83801900 "22";"2000-10-26";61;65.0625;60.8125;64.4375;57413300 "23";"2000-10-27";64.6875;69.1875;64.625;67.6875;62146200 "24";"2000-10-30";67.5;70.125;67.375;69.0625;55028800 "25";"2000-10-31";69;69.5;68;68.875;52237000 "26";"2000-11-01";68.5;70.0625;68.4375;69.625;40654700 "27";"2000-11-02";70.375;70.8438;69.625;70.3125;38992600 "28";"2000-11-03";69.25;69.625;68.0625;68.25;34355500 "29";"2000-11-06";68.6875;70.125;68.25;69.5;37425700 "30";"2000-11-07";69.75;71.875;69.5;70.5;52165600 "31";"2000-11-08";71.125;72.375;68;69.4375;103074700 "32";"2000-11-09";68.5;71.3125;68.4375;70.875;45529300 "33";"2000-11-10";69.9375;70.3125;66.8125;67.375;46872200 "34";"2000-11-13";66.6875;68.125;64.4062;66.4375;41682400 "35";"2000-11-14";68;69.8125;67.3125;68.8125;42109300 "36";"2000-11-15";69.0625;70.875;68.6875;70.0625;30211100 "37";"2000-11-16";69.4375;71.5;68.9375;68.9375;46064300 "38";"2000-11-17";69.4375;70;67.7969;69.0625;53262800 "39";"2000-11-20";68.125;68.5;65.5625;67.1875;40078600 "40";"2000-11-21";67.375;69.25;67.375;67.75;29743800 "41";"2000-11-22";66.0625;69.5;66;68.25;38171600 "42";"2000-11-24";69;70.4375;68.5;69.9375;17219600 "43";"2000-11-27";71.4375;72.25;70.625;70.6875;42653800 "44";"2000-11-28";69.375;69.75;66.8125;67;63723100 "45";"2000-11-29";66.8125;67.125;63.25;65.0625;49140200 "46";"2000-11-30";62;62.0625;57;57.375;98600400 "47";"2000-12-01";58.0625;60.625;56.0625;56.625;54904900 "48";"2000-12-04";57.25;59;55.1875;56.4375;40203600 "49";"2000-12-05";59.1875;60.5;58.25;59.875;50867200 "50";"2000-12-06";60;60.0625;56.0625;56.6875;45280400 "51";"2000-12-07";53.4375;54;52.25;53.125;72654200 "52";"2000-12-08";54.625;55.875;53.4375;54.4375;60469900 "53";"2000-12-11";55.5;58.75;55;58.0625;47788100 "54";"2000-12-12";57.8125;60;56.75;58.375;31553000 "55";"2000-12-13";60.5;60.5;56.8125;57.25;49180200 "56";"2000-12-14";57.9375;58.7344;55.375;55.5;35600700 "57";"2000-12-15";51.0469;52;47.75;49.1875;58449900 "58";"2000-12-18";49;50;47;47.8125;53593700 "59";"2000-12-19";47.4375;48;44.5;44.8125;60135900 "60";"2000-12-20";42.8125;44;41.375;41.5;74518900 "61";"2000-12-21";40.75;45.125;40.3125;43.4375;81586500 "62";"2000-12-22";44.75;47.125;44.75;46.4375;54775900 "63";"2000-12-26";46.875;48.5625;45.875;46.875;33470800 "64";"2000-12-27";46.125;46.8125;45;46.4375;34501900 "65";"2000-12-28";45.125;46.25;43.875;44.5625;38809600 "66";"2000-12-29";43.9375;45.8125;43;43.375;49988800 "67";"2001-01-02";44.125;45;42.875;43.375;41206600 "68";"2001-01-03";43.1875;48.875;43.125;47.9375;67981100 "69";"2001-01-04";47.8125;50.5;46.875;48.4375;56198500 "70";"2001-01-05";48.5;49.875;47.5625;49.125;46707300 "71";"2001-01-08";48.9375;49.75;46.6875;48.9375;39908800 "72";"2001-01-09";50;52.625;49.75;51.8125;57482700 "73";"2001-01-10";51;53.8125;50.75;52.875;45115100 "74";"2001-01-11";53;55.75;52.3125;55;50927400 "75";"2001-01-12";54.875;55;52.5;53.5;36856000 "76";"2001-01-16";53.375;53.5;51.125;52.5625;34231200 "77";"2001-01-17";53.625;54.875;52.5625;52.9375;36422100 "78";"2001-01-18";53.6875;56.1875;52.625;55.5;54894400 "79";"2001-01-19";60;61.4375;58.875;61;104674400 "80";"2001-01-22";60.75;61;59;60.125;38336500 "81";"2001-01-23";59.75;60.9375;58.9375;60.5625;35147600 "82";"2001-01-24";61;63.4375;60.75;62.9375;55227500 "83";"2001-01-25";62.75;64;61.5625;61.8125;42828700 "84";"2001-01-26";61;64.3125;61;64;46540000 "85";"2001-01-29";63.5625;64.625;63.5;64.5;42491900 "86";"2001-01-30";64.5;64.75;62.875;63.375;28638400 "87";"2001-01-31";63;63.75;61;61.0625;40949400 "88";"2001-02-01";60.8125;62.625;60.375;62.375;35896400 "89";"2001-02-02";62.5;63.375;60.75;60.8125;35550000 "90";"2001-02-05";60.75;62.0625;60.25;61.9375;25699600 "91";"2001-02-06";62.0625;63.8125;61.6875;62.5625;48221000 "92";"2001-02-07";62;65.0625;61.8125;64.6875;63030900 "93";"2001-02-08";63.75;64.5;62;62.25;44020600 "94";"2001-02-09";61.3125;61.5625;58.5;59.125;50287600 "95";"2001-02-12";58.8125;59.4375;57.1875;58.75;35644700 "96";"2001-02-13";59.625;61.0625;58.125;58.1875;38035300 "97";"2001-02-14";57.625;59;56.375;58.375;30864200 "98";"2001-02-15";59;60.1875;57.875;58.8125;32813900 "99";"2001-02-16";57;58.25;56.125;57.3125;33479200 "100";"2001-02-20";57.375;58.25;55.375;55.875;30365400 "101";"2001-02-21";55.25;58.0625;55.1875;56.25;31973600 "102";"2001-02-22";56.3125;56.8125;53.875;55.1875;50408200 "103";"2001-02-23";54.4375;57.5;54.3125;56.75;46310300 "104";"2001-02-26";57.625;59.9375;57.375;59.5625;43968400 "105";"2001-02-27";59.375;61.1875;58.6719;59.375;49574300 "106";"2001-02-28";59.5625;60.0781;58.1875;59;42304200 "107";"2001-03-01";58.5625;59.5;56.25;59.3594;40890800 "108";"2001-03-02";57.5;58.125;56.4375;56.6875;39900400 "109";"2001-03-05";57.25;58.625;56.5625;57.4375;24691800 "110";"2001-03-06";58.625;60;58.375;59.4375;33390900 "111";"2001-03-07";59.875;61.125;59.3125;60.6875;29871800 "112";"2001-03-08";60.3125;60.5938;58.4375;59.25;27313000 "113";"2001-03-09";57.9375;58.1875;54.875;56.6875;51897200 "114";"2001-03-12";54.6875;55;51.625;51.9375;57188000 "115";"2001-03-13";52.1875;54.75;52;54.1875;45517800 "116";"2001-03-14";52.5;55.25;52.1875;54;45343100 "117";"2001-03-15";55.3125;56.0781;53.5;53.6875;35819200 "118";"2001-03-16";52.5;55.125;52.4844;54.5625;56424400 "119";"2001-03-19";54.5;55.5;53.125;54.3125;30518200 "120";"2001-03-20";54.5625;56.125;52.625;52.6875;45911400 "121";"2001-03-21";52.25;53.25;49.75;50.0625;62494300 "122";"2001-03-22";50.5625;54.0625;50.5;54;63181600 "123";"2001-03-23";54.9375;57;54.375;56.5625;49759800 "124";"2001-03-26";57.125;57.5;55.5625;56.0625;31559300 "125";"2001-03-27";56.0625;58.5625;55.875;58.25;47567800 "126";"2001-03-28";57.375;57.9375;55.375;55.5625;39340800 "127";"2001-03-29";55.375;57.1875;54.5625;55.375;43492500 "128";"2001-03-30";55.75;56.1875;53.875;54.6875;45600800 "129";"2001-04-02";54.8125;56.9375;54.625;55.8125;37962000 "130";"2001-04-03";55.3125;55.3125;52.75;53.375;47093800 "131";"2001-04-04";53.375;55;51.0625;51.9375;52023300 "132";"2001-04-05";53.75;57.375;53.5;56.75;56682000 "133";"2001-04-06";56.375;57.1875;55.0625;56.1875;46311000 "134";"2001-04-09";56.57;57.42;55.66;57.15;28147800 "135";"2001-04-10";57.95;60.09;57.78;59.68;54599700 "136";"2001-04-11";60.65;61.5;59.7;60.04;54939800 "137";"2001-04-12";59.56;62.31;59.35;62.18;43760000 "138";"2001-04-16";61.4;61.58;60.12;60.79;32928700 "139";"2001-04-17";60.52;62.11;60.04;61.48;42574600 "140";"2001-04-18";63.39;66.31;63;65.43;78348200 "141";"2001-04-19";65.81;69;65.75;68.04;79687800 "142";"2001-04-20";70.3;71.1;68.5;69;96459800 "143";"2001-04-23";68.11;68.47;66.9;68.25;46085600 "144";"2001-04-24";68.2;69.93;67.14;67.55;44588300 "145";"2001-04-25";67.57;69.79;67.25;69.69;38372000 "146";"2001-04-26";70.07;71;68.25;69.13;59368800 "147";"2001-04-27";69.53;69.68;66.21;67.12;60786200 "148";"2001-04-30";68.53;69.06;67.68;67.75;37184100 "149";"2001-05-01";67.66;70.3;67.6;70.17;41851400 "150";"2001-05-02";71;71.15;69.35;69.76;46432200 "151";"2001-05-03";69.25;70.18;68.14;68.53;33136700 "152";"2001-05-04";68;71.05;67.96;70.75;59769200 "153";"2001-05-07";70.83;72.15;70.7;71.38;54678100 "154";"2001-05-08";71.75;72.1;70.75;72.06;37542000 "155";"2001-05-09";71.24;71.3;69.86;70.4;38338300 "156";"2001-05-10";71.13;71.24;69.96;70;32167300 "157";"2001-05-11";69.96;70;68.65;69.4;25564400 "158";"2001-05-14";69.13;69.2;68.3;68.72;22484000 "159";"2001-05-15";68.74;69.3;68;68.27;30692800 "160";"2001-05-16";67.7;69.88;67.33;69.16;45946900 "161";"2001-05-17";69.1;70.14;67.55;68.17;53492400 "162";"2001-05-18";67.69;69.2;67.25;68.09;45302700 "163";"2001-05-21";68.05;69.99;67.75;68.79;51745800 "164";"2001-05-22";69.45;70.35;69.18;70.31;41727800 "165";"2001-05-23";70.39;71.6;69.51;69.7;46818700 "166";"2001-05-24";69.94;71.78;69.27;71.72;40390800 "167";"2001-05-25";71.66;71.9;70.36;70.91;26373800 "168";"2001-05-29";70.8;71.75;70.05;70.34;35605400 "169";"2001-05-30";69.56;70.58;68.65;69.19;43250900 "170";"2001-05-31";69.49;70.38;68.4;69.18;35341300 "171";"2001-06-01";69.6;70.7;68.7;70.34;28793800 "172";"2001-06-04";70.55;71.02;69.8;70.78;21868300 "173";"2001-06-05";70.76;73.08;70.5;72.6;44727100 "174";"2001-06-06";72.89;73.48;71.55;72.36;40011400 "175";"2001-06-07";72.12;73.73;72.08;73.68;33480000 "176";"2001-06-08";73.7;73.75;72.05;73.19;25933500 "177";"2001-06-11";72.85;72.85;71.51;72.12;23672800 "178";"2001-06-12";71.02;72.41;70.81;72.08;33357300 "179";"2001-06-13";72.05;72.3;70.64;70.69;27651200 "180";"2001-06-14";70.22;70.55;68.4;68.9;35986200 "181";"2001-06-15";67.51;68.3;66.4;68.02;54177200 "182";"2001-06-18";67.95;67.96;66.01;66.88;28423400 "183";"2001-06-19";68.21;68.85;66.85;67.32;31728700 "184";"2001-06-20";67.14;69.59;67.1;69.41;32054200 "185";"2001-06-21";69.15;70.55;68.92;69.84;34801900 "186";"2001-06-22";70;70.61;68.58;68.83;25546000 "187";"2001-06-25";69.1;69.81;67.77;68.85;24607800 "188";"2001-06-26";67.82;70.21;67.7;70.14;31538500 "189";"2001-06-27";69.86;71.53;69.36;71.14;34599900 "190";"2001-06-28";71.55;76.15;70.53;72.74;64487800 "191";"2001-06-29";72.6;73.41;71.4;73;47141900 "192";"2001-07-02";72.05;73.15;70.15;70.6;36405100 "193";"2001-07-03";70.3;70.8;69.93;70.47;14018700 "194";"2001-07-05";70.22;70.72;68.44;68.51;24621300 "195";"2001-07-06";68.3;68.4;65.67;66.06;33733900 "196";"2001-07-09";66.2;66.91;65.04;65.69;33238300 "197";"2001-07-10";65.9;66.25;64.35;64.48;33281300 "198";"2001-07-11";64.21;66.75;64.2;66.5;36911300 "199";"2001-07-12";70.7;72.05;70.33;71.6;64039000 "200";"2001-07-13";71.4;72;70.94;71.34;29467300 "201";"2001-07-16";71.45;72.16;70.15;71.18;27995400 "202";"2001-07-17";70.66;72.01;70.14;71.82;31620500 "203";"2001-07-18";70.6;71.5;69.87;70.57;28795400 "204";"2001-07-19";71.22;73;71.22;72.57;38274700 "205";"2001-07-20";68.03;69.4;67.94;69.18;62101800 "206";"2001-07-23";69.24;69.24;66.35;67.09;39999700 "207";"2001-07-24";67;67.99;65.7;66.32;33765100 "208";"2001-07-25";66.26;67.52;65.61;67.48;37032700 "209";"2001-07-26";67.12;67.32;65.5;66.59;38987000 "210";"2001-07-27";66.05;66.25;65.05;65.47;32698000 "211";"2001-07-30";65.65;66.88;65.54;65.8;21098200 "212";"2001-07-31";66.01;67.39;65.85;66.19;29515800 "213";"2001-08-01";66.8;66.81;65.76;66.47;27839500 "214";"2001-08-02";67.21;67.54;66.26;67.45;27099200 "215";"2001-08-03";67.3;67.36;66;66.89;21630200 "216";"2001-08-06";66.53;67.12;65.68;66.13;13915800 "217";"2001-08-07";66.04;67.05;65.99;66.35;15673900 "218";"2001-08-08";66.51;67.24;64.49;64.86;27498200 "219";"2001-08-09";64.98;65.55;64.3;65.01;22768100 "220";"2001-08-10";64.77;65.86;62.9;65.52;25878200 "221";"2001-08-13";65.24;65.99;64.75;65.83;16337700 "222";"2001-08-14";65.75;66.09;64.45;64.69;18240600 "223";"2001-08-15";64.71;65.05;63.2;63.2;19751500 "224";"2001-08-16";62.84;64.71;62.7;64.62;21952800 "225";"2001-08-17";63.78;64.13;61.5;61.88;26117100 "226";"2001-08-20";61.66;62.75;61.1;62.7;24185600 "227";"2001-08-21";62.7;63.2;60.71;60.78;23555900 "228";"2001-08-22";61.13;61.15;59.08;60.66;39053600 "229";"2001-08-23";60.67;61.53;59;59.12;25906600 "230";"2001-08-24";59.6;62.28;59.23;62.05;31699500 "231";"2001-08-27";61.9;63.36;61.57;62.31;22281400 "232";"2001-08-28";62.34;62.95;60.58;60.74;23711400 "233";"2001-08-29";61.05;61.3;59.54;60.25;24085000 "234";"2001-08-30";59.04;59.66;56.52;56.94;48816000 "235";"2001-08-31";56.85;58.06;56.3;57.05;28950400 "236";"2001-09-04";57.19;59.08;56.07;56.1;33594600 "237";"2001-09-05";56.18;58.39;55.39;57.74;44735300 "238";"2001-09-06";56.56;58.39;55.9;56.02;56178400 "239";"2001-09-07";56.11;57.36;55.31;55.4;44931900 "240";"2001-09-10";54.92;57.95;54.7;57.58;42235900 "241";"2001-09-17";54.02;55.1;52.8;52.91;63751000 "242";"2001-09-18";53.41;55;53.17;54.32;41591300 "243";"2001-09-19";54.46;54.7;50.6;53.87;63475100 "244";"2001-09-20";52.35;52.61;50.67;50.76;58991600 "245";"2001-09-21";47.92;50.6;47.5;49.71;92488300 "246";"2001-09-24";50.65;52.45;49.87;52.01;42790100 "247";"2001-09-25";52.27;53;50.16;51.3;42470300 "248";"2001-09-26";51.51;51.8;49.55;50.27;29262200 "249";"2001-09-27";50.1;50.68;48;49.96;40595600 timeSeries/tests/doRUnit.R0000644000176000001440000000164211370220766015273 0ustar ripleyusers#### doRUnit.R --- Run RUnit tests ####------------------------------------------------------------------------ ### Origianlly follows Gregor Gojanc's example in CRAN package 'gdata' ### and the corresponding section in the R Wiki: ### http://wiki.r-project.org/rwiki/doku.php?id=developers:runit ### MM: Vastly changed: This should also be "runnable" for *installed* ## package which has no ./tests/ ## ----> put the bulk of the code e.g. in ../inst/unitTests/runTests.R : if(require("RUnit", quietly = TRUE)) { ## --- Setup --- wd <- getwd() pkg <- sub("\\.Rcheck$", '', basename(dirname(wd))) library(package = pkg, character.only=TRUE) path <- system.file("unitTests", package = pkg) stopifnot(file.exists(path), file.info(path.expand(path))$isdir) source(file.path(path, "runTests.R"), echo = TRUE) } ################################################################################ timeSeries/man/0000755000176000001440000000000011732460200013161 5ustar ripleyuserstimeSeries/man/utils-structure.Rd0000644000176000001440000000124311560011675016655 0ustar ripleyusers\name{str-methods} \title{Object Str} \alias{str} \alias{str,timeSeries-method} \description{ Compactly Display the Structure of a 'timeSeries' Object. } \usage{ \S4method{str}{timeSeries}(object, \dots) } \arguments{ \item{object}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments passed to other methods. } } \value{ returns a str report for an object of class \code{timeSeries}. } \examples{ ## Load Microsoft Data Set - data(MSFT) X = MSFT[1:12, 1:4] colnames(X) <- abbreviate(colnames(X), 4) ## Display Structure - str(X) } \keyword{chron} timeSeries/man/utils-description.Rd0000644000176000001440000000042611560011675017142 0ustar ripleyusers\name{description} \alias{description} \title{Creates Date and User Information} \description{ Creates and returns a data and user string. } \usage{ description() } \examples{ ## Show Default Description String - description() } \keyword{programming} timeSeries/man/timeSeries.Rd0000644000176000001440000001363511525723157015606 0ustar ripleyusers\name{TimeSeriesClass} \title{timeSeries Class} \alias{TimeSeriesClass} \alias{timeSeries} \alias{timeSeries,ANY,ANY-method} \alias{timeSeries,ANY,missing-method} \alias{timeSeries,ANY,timeDate-method} \alias{timeSeries,matrix,ANY-method} \alias{timeSeries,matrix,missing-method} \alias{timeSeries,matrix,timeDate-method} \alias{timeSeries,missing,ANY-method} \alias{timeSeries,missing,missing-method} \alias{timeSeries,missing,timeDate-method} \alias{timeSeries,matrix,numeric-method} \alias{index_timeSeries} \alias{time_timeSeries} \alias{timeSeries-class} \alias{index_timeSeries-class} \alias{time_timeSeries-class} \alias{initialize,timeSeries-method} \alias{seriesData} \description{ A collection and description of functions and methods dealing with regular and irregular 'timeSeries' objects. Dates and times are implemented as 'timeDate' objects. \cr Functions to generate and modify 'timeSeries' objects: \tabular{ll}{ \code{timeSeries} \tab Creates a 'timeSeries' object from scratch.} Data Slot and classification of 'timeSeries' objects: \tabular{ll}{ \code{seriesData} \tab Extracts data slot from a 'timeSeries'. } } \usage{ timeSeries(data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, \dots) seriesData(object) } \arguments{ \item{charvec}{ a character vector of dates and times or any objects which can be coerced to a \code{timeDate} object. } \item{data}{ a \code{matrix} object or any objects which can be coereced to a matrix. } \item{documentation}{ optional documentation string, or a vector of character strings. } \item{FinCenter}{ a character with the the location of the financial center named as "continent/city". } \item{format}{ the format specification of the input character vector, \cr [as.timeSeries] - \cr a character string with the format in POSIX notation to be passed to the time series object. } \item{object}{ [is][seriesData][seriesPositions][show][summary] - an object of class \code{timeSeries}. } \item{recordIDs}{ a data frame which can be used for record identification information. \cr [print] - \cr a logical value. Should the \code{recordIDs} printed together with the data matrix and time series positions? } \item{title}{ an optional title string, if not specified the inputs data name is deparsed. } \item{units}{ an optional character string, which allows to overwrite the current column names of a \code{timeSeries} object. By default \code{NULL} which means that the column names are selected automatically. } \item{zone}{ the time zone or financial center where the data were recorded. } \item{\dots}{ arguments passed to other methods. } } \value{ \code{timeSeries}\cr \code{returnSeries}\cr \cr return a S4 object of class \code{timeSeries}. \cr \code{orderStatistics} \cr returns ... \cr \code{series}\cr \cr extracts the \code{@.Data} slot from a \code{timeSeries} object and is equivalent to \code{as.amtrix}. } \details{ \bold{Generation of Time Series Objects:} \cr We have defined a \code{timeSeries} class which is in many aspects similar to the S-Plus class with the same name, but has also some important differences. The class has seven Slots, the 'Data' slot which holds the time series data in matrix form, the 'position' slot which holds the time/date as a character vector, the 'format' and 'FinCenter' slots which are the same as for the 'timeDate' object, the 'units' slot which holds the column names of the data matrix, and a 'title' and a 'documentation' slot which hold descriptive character strings. Date and time is managed in the same way as for \code{timeDate} objects. } \note{ These functions were written for Rmetrics users using R and Rmetrics under Microsoft's Windows operating system where timze zones, daylight saving times and holiday calendars are insuffeciently supported. } \examples{ ## Load Microsoft Data - # Microsoft Data: setRmetricsOptions(myFinCenter = "GMT") data(MSFT) head(MSFT) ## Create a timeSeries Object, The Direct Way ... Close = MSFT[, 5] head(Close) ## Create a timeSeries Object from Scratch - data = as.matrix(MSFT[, 4]) charvec = rownames(MSFT) Close = timeSeries(data, charvec, units = "Close") head(Close) c(start(Close), end(Close)) ## Cut out April Data from 2001 - tsApril01 = window(Close, "2001-04-01", "2001-04-30") tsApril01 ## Compute Continuous Returns - returns(tsApril01) ## Compute Discrete Returns - returns(tsApril01, type = "discrete") ## Compute Discrete Returns, Don't trim - returns(tsApril01, trim = FALSE) ## Compute Discrete Returns, Use Percentage Values - tsRet = returns(tsApril01, percentage = TRUE, trim = FALSE) tsRet ## Aggregate Weekly - GoodFriday(2001) to = timeSequence(from = "2001-04-11", length.out = 3, by = "week") from = to - 6*24*3600 from to applySeries(tsRet, from, to, FUN = sum) ## Create large timeSeries objects with different 'charvec' object classes - # charvec is a 'timeDate' object head(timeSeries(1:1e6L, timeSequence(length.out = 1e6L, by = "sec"))) head(timeSeries(1:1e6L, seq(Sys.timeDate(), length.out = 1e6L, by = "sec"))) # 'charvec' is a 'POSIXt' object head(timeSeries(1:1e6L, seq(Sys.time(), length.out = 1e6L, by = "sec"))) # 'charvec' is a 'numeric' object head(timeSeries(1:1e6L, 1:1e6L)) } \keyword{chron} timeSeries/man/timeSeries-slotUnits.Rd0000644000176000001440000000143511560011675017575 0ustar ripleyusers\name{units} \alias{getUnits} \alias{setUnits<-} \title{Get and Set Unit Names of a 'timeSeries'} \description{ Gets and sets the column names of a 'timeSeries' object. The column names are also called units or unit names. } \usage{ getUnits(x) setUnits(x) <- value } \arguments{ \item{x}{ a \code{timeSeries} object. } \item{value}{ a \code{vector}, a \code{data.frame} or a \code{matrix} object of numeric data. } } \seealso{timeSeries()} \examples{ ## A Dummy timeSeries Object tS <- dummySeries() tS ## Get the Units - getUnits(tS) ## Assign New Units to the Series - setUnits(tS) <- c("A", "B") head(tS) } \keyword{programming} timeSeries/man/timeSeries-slotTime.Rd0000644000176000001440000000174211560011675017372 0ustar ripleyusers\name{time} \title{Get and Set Time stamps of a 'timeSeries'} \alias{time} \alias{time<-} \alias{time,timeSeries-method} \alias{time.timeSeries} \alias{time<-.timeSeries} \alias{sample,timeSeries-method} \alias{getTime} \alias{setTime<-} \description{ Functions and methods extracting and modifying positions of 'timeSeries' objects. } \usage{ \S4method{time}{timeSeries}(x, \dots) \method{time}{timeSeries}(x) <- value getTime(x) setTime(x) <- value } \arguments{ \item{value}{ a valid value for the component of \code{time(x)}. } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ optional arguments passed to other methods. } } \value{ returns a \code{timeSeries} object. } \examples{ ## Create Dummy timeSeries - X = timeSeries(matrix(rnorm(24), 12), timeCalendar()) ## Return Series Positions - time(X) } \keyword{chron} timeSeries/man/timeSeries-slotSeries.Rd0000644000176000001440000000230311732173216017721 0ustar ripleyusers\name{series-methods} \docType{methods} \alias{series} \alias{series<-} \alias{series,timeSeries-method} \alias{series<-,timeSeries,matrix-method} \alias{series<-,timeSeries,ANY-method} \alias{series<-,timeSeries,data.frame-method} \alias{series<-,timeSeries,vector-method} %\alias{getSeries} %\alias{getSeries.timeSeries} %\alias{setSeries<-} \title{Get and Set Data of a 'timeSeries'} \description{ \code{series} returns \code{Data} slot a \code{timeSeries} object in a \code{matrix} form. New series can also be assign to the \code{timeSeries}. } \usage{ %\S4method{series}{timeSeries}(x) series(x) series(x) <- value % %getSeries(x) %setSeries(x) <- value } \arguments{ \item{x}{ a \code{timeSeries} object. } \item{value}{ a \code{vector}, a \code{data.frame} or a \code{matrix} object of numeric data. } } \seealso{timeSeries()} \examples{ ## A Dummy timeSeries Object ts <- timeSeries() ts ## Get the Matrix Part - mat <- series(ts) class(mat) mat ## Assign a New Univariate Series - series(ts) <- rnorm(12) ts ## Assign a New Bivariate Series - series(ts) <- rnorm(12) ts } \keyword{programming} timeSeries/man/timeSeries-slotFinCenter.Rd0000644000176000001440000000177311560011675020355 0ustar ripleyusers\name{finCenter} \title{Get and Set Financial Center of a 'timeSeries'} \alias{finCenter,timeSeries-method} \alias{finCenter<-,timeSeries-method} \alias{getFinCenter} \alias{setFinCenter<-} \description{ Print or assign new financial center to a \code{timeSeries} object. } \usage{ \S4method{finCenter}{timeSeries}(x) \S4method{finCenter}{timeSeries}(x) <- value getFinCenter(x) setFinCenter(x) <- value } \arguments{ \item{x}{ a \code{timeSeries} object. } \item{value}{ a character with the the location of the financial center named as "continent/city". } } \seealso{listFinCenter} \examples{ ## An artificial timeSeries Object - tS <- dummySeries() tS ## Print Financial Center - finCenter(tS) getFinCenter(tS) ## Assign New Financial Center - finCenter(tS) <- "Zurich" tS setFinCenter(tS) <- "New_York" tS } \keyword{programming} timeSeries/man/timeSeries-readSeries.Rd0000644000176000001440000000327111560011675017657 0ustar ripleyusers\name{readSeries} \title{Reads a 'timeSeries' from a File} \alias{readSeries} \description{ Reads a file in table format and creates a \code{timeSeries} object from it. The first column of the table must hold the timestamps. Format of the stimestamps can be either specified in the header of the first column or by the \code{format} argument. } \usage{ readSeries(file, header = TRUE, sep = ";", zone = "", FinCenter = "", format, \dots) } \arguments{ \item{file}{ the filename of a spreadsheet data set from which to import the data records. } \item{FinCenter}{ a character with the the location of the financial center named as "continent/city". } \item{header}{ a logical value indicating whether the file contains the names of the variables as its first line. If missing, the value is determined from the file format: 'header' is set to 'TRUE' if and only if the first row contains one fewer field than the number of columns. } \item{format}{ a character string with the format in POSIX notation specifying the timestamp format. Note the function assumes that the first column in the csv file has the timestamps. } \item{sep}{ the field seperator used in the spreadsheet file to separate columns. } \item{zone}{ the time zone or financial center where the data were recorded. } \item{\dots}{ Additional arguments passed to \code{read.table()} function which is used to read the file. } } \value{ Return a S4 object of class \code{timeSeries}. } timeSeries/man/timeSeries-isUnivariate.Rd0000644000176000001440000000212111370220767020230 0ustar ripleyusers\name{isUnivariate} \title{Checks if a Time Series is Univariate} \alias{isUnivariate} \alias{isMultivariate} \description{ Checks if a time series o bject or any other rectangular object is univariate or multivariate. } \usage{ isUnivariate(x) isMultivariate(x) } \arguments{ \item{x}{ an object of class \code{timeSeries} or any other rectangular object. } } \value{ \code{isUnivariate}\cr \code{isMultivariate}\cr \cr return a logical depending if the test is true or not. } \details{ A rectangular object \code{x} is considered to be univariate if the function \code{NCOL(x)} returns one, and is considered to be multivariate if \code{NCOL(x)} returns a value bigger than one. } \examples{ ## Load Microsoft Data - setRmetricsOptions(myFinCenter = "GMT") data(MSFT) Open = MSFT[, "Open"] ## Is the timeSeries Univariate - isUnivariate(MSFT) isUnivariate(Open) ## Is the timeSeries Multivariate - isMultivariate(MSFT) isMultivariate(Open) } \keyword{chron} timeSeries/man/timeSeries-isRegular.Rd0000644000176000001440000000326111370220767017530 0ustar ripleyusers\name{isRegular} \title{Checks if a time series is regular} \alias{isDaily,timeSeries-method} \alias{isMonthly,timeSeries-method} \alias{isQuarterly,timeSeries-method} \alias{isRegular,timeSeries-method} \alias{frequency,timeSeries-method} \description{ Checks if a time series is regular. i.e. if a series is a daily, a monthly, or a weekly time series. If the series is regular the frequency of the serie scan determined calling the function frequency. } \usage{ \S4method{isDaily}{timeSeries}(x) \S4method{isMonthly}{timeSeries}(x) \S4method{isQuarterly}{timeSeries}(x) \S4method{isRegular}{timeSeries}(x) \S4method{frequency}{timeSeries}(x, \dots) } \arguments{ \item{x}{ an R object of class \code{timeSeries}. } \item{\dots}{ arguments to be passed. } } \details{ A time series is defined as daily if the series has not more than one date/time stamp per day. A time series is defined as monthly if the series has not more than one date/time stamp per month. A time series is defined as quarterly if the series has not more than one date/time stamp per quarter. A monthly series is also a daily series, a quarterly series is also a monthly series. A regular series is either a monthly or a quarterly series. NOT yet implemented is the case of weekly series. } \value{ The \code{is*} functions return \code{TRUE} or \code{FALSE} depending on whether the series fulfills the condition or not. The function frequency returns in general 1, for quarterly series 4, and for monthly series 12. } \examples{ ## None } \keyword{chron} timeSeries/man/timeSeries-getDataPart.Rd0000644000176000001440000000057711370220767020002 0ustar ripleyusers\name{DataPart,timeSeries-method} \title{DataPart,timeSeries-method} \alias{getDataPart,timeSeries-method} \alias{setDataPart,timeSeries-method} \description{ utilites called to implement object@.Data of \code{timeSeries} objects. } \examples{ ## Load Microsoft Data - data(MSFT) X <- MSFT[1:10, 1:4] ## Get Data Part - getDataPart(X) } \keyword{chron} timeSeries/man/timeSeries-deprecated.Rd0000644000176000001440000000052211370220767017670 0ustar ripleyusers\name{timeSeries-deprecated} \title{Deprecated functions in timeSeries package} \alias{seriesPositions} \alias{newPositions<-} \description{ \tabular{ll}{ \code{seriesPositions} \tab Extracts positions slot from a 'timeSeries', \cr \code{newPositions<-} \tab Modifies positions of a 'timeSeries' object, \cr } } timeSeries/man/stats-window.Rd0000644000176000001440000000026611560011675016126 0ustar ripleyusers\name{window} \title{window} \description{ Description ... } timeSeries/man/stats-na.omit.Rd0000644000176000001440000001152311370220767016165 0ustar ripleyusers\name{na} \title{Handling Missing Time Series Values} \alias{na} \alias{na.omit} \alias{na.omit,timeSeries-method} \alias{na.omit.timeSeries} \alias{removeNA} \alias{substituteNA} \alias{interpNA} \description{ Functions for handling missing values in 'timeSeries' objects or in objects which can be transformed into a vector or a two dimensional matrix. \cr The functions are listed by topic. \cr \tabular{ll}{ \code{na.omit} \tab Handles NAs, \cr \code{removeNA} \tab Removes NAs from a matrix object, \cr \code{substituteNA} \tab substitute NAs by zero, the column mean or median, \cr \code{interpNA} \tab interpolates NAs using R's "approx" function. } } \usage{ \S4method{na.omit}{timeSeries}(object, method = c("r", "s", "z", "ir", "iz", "ie"), interp = c("before", "linear", "after"), \dots) removeNA(x, \dots) substituteNA(x, type = c("zeros", "mean", "median"), \dots) interpNA(x, method = c("linear", "before", "after"), \dots) } \arguments{ \item{interp, type}{ [nna.omit][substituteNA] - \cr Three alternative methods are provided to remove NAs from the data: \code{type="zeros"} replaces the missing values by zeros, \code{type="mean"} replaces the missing values by the column mean, \code{type="median"} replaces the missing values by the the column median. } \item{method}{ [na.omit] - \cr Specifies the method how to handle NAs. One of the applied vector strings: \cr \code{method="s"} na.rm = FALSE, skip, i.e. do nothing, \code{method="r"} remove NAs, \code{method="z"} substitute NAs by zeros, \code{method="ir"} interpolate NAs and remove NAs at the beginning and end of the series, \code{method="iz"} interpolate NAs and substitute NAs at the beginning and end of the series, \code{method="ie"} interpolate NAs and extrapolate NAs at the beginning and end of the series, [interpNA] - \cr Specifies the method how to interpolate the matrix column by column. One of the applied vector strings: \code{method="linear"}, \code{method="before"} or \code{method="after"}.\cr For the interpolation the function \code{approx} is used. } \item{object}{ an object of class("timeSeries"). } \item{x}{ a numeric matrix, or any other object which can be transformed into a matrix through \code{x = as.matrix(x, ...)}. If \code{x} is a vector, it will be transformed into a one-dimensional matrix. } \item{\dots}{ arguments to be passed to the function \code{as.matrix}. } } \details{ \bold{Missing Values in Price and Index Series:} Applied to \code{timeSeries} objects the function \code{removeNA} just removes rows with NAs from the series. For an interpolation of time series points one can use the function \code{interpNA}. Three different methods of interpolation are offered: \code{"linear"} does a linear interpolation, \code{"before"} uses the previous value, and \code{"after"} uses the following value. Note, that the interpolation is done on the index scale and not on the time scale. \bold{Missing Values in Return Series:} For return series the function \code{substituteNA} may be useful. The function allows to fill missing values either by \code{method="zeros"}, the \code{method="mean"} or the \code{method="median"} value of the appropriate columns. } \note{ The functions \code{removeNA}, \code{substituteNA} and \code{interpNA} are older implementations. Please use in all cases if possible the new function \code{na.omit}. } \references{ Troyanskaya O., Cantor M., Sherlock G., Brown P., Hastie T., Tibshirani R., Botstein D., Altman R.B., (2001); \emph{Missing Value Estimation Methods for DNA microarrays} Bioinformatics 17, 520--525. } \examples{ ## Create a Matrix - X = matrix(rnorm(100), ncol = 5) ## Replace a Single NA Inside - X[3, 5] = NA ## Replace Three in a Row Inside - X[17, 2:4] = c(NA, NA, NA) ## Replace Three in a Column Inside - X[13:15, 4] = c(NA, NA, NA) ## Replace Two at the Right Border - X[11:12, 5] = c(NA, NA) ## Replace One in the Lower Left Corner - X[20, 1] = NA print(X) ## Remove Rows with NAs - removeNA(X) ## Subsitute NA's by Zeros or Column Mean - substituteNA(X, type = "zeros") substituteNA(X, type = "mean") ## Interpolate NA's Linearily - interpNA(X, method = "linear") # Note the corner missing value cannot be interpolated! ## Take Previous Values in a Column - interpNA(X, method = "before") # Also here, the corner value is excluded } \keyword{math} timeSeries/man/stats-na.contiguous.Rd0000644000176000001440000000141111370220767017407 0ustar ripleyusers\name{na.contiguous} \title{Find Longest Contiguous Stretch of non-NAs} \alias{na.contiguous,timeSeries-method} \description{ Find the longest consecutive stretch of non-missing values in a timeSeries object. (In the event of a tie, the first such stretch.) } \usage{ \S4method{na.contiguous}{timeSeries}(object, ...) } \arguments{ \item{object}{ a timeSeries object. } \item{\dots}{ further arguments passed to or from other methods. } } \value{ A timeSeries object without missing values. } \examples{ ## Dummy timeSeries with NAs entries data <- matrix(sample(c(1:20, rep(NA,4))), ncol = 2) s <- timeSeries(data, timeCalendar()) ## Find the longest consecutive non-missing values na.contiguous(s) } timeSeries/man/stats-model.frame.Rd0000644000176000001440000000277211370220767017017 0ustar ripleyusers\name{model.frame} \title{Model Frames for Time Series Objects} \alias{model.frame} \alias{model.frame.default,ANY,timeSeries-method} \description{ Allow to work with model frames for 'timeSeries' objects. } % \usage{ % model.frame(formula, data, ...) % } % \arguments{ % \item{formula}{ % a model formula object. % } % \item{data}{ % an object of class \code{timeSeries}. % } % \item{\dots}{ % arguments passed to the function \code{stats::model.frame}. % } % } \value{ an object of class \code{timeSeries}. } \details{ The function \code{model.frame} is a generic function which returns in the R-ststs framework by default a data.frame with the variables needed to use formula and any ... arguments. In contrast to this the method returns an object of class \code{timeSeries} when the argument data was not a \code{data.frame} but also an object of class \code{timeSeries}. } \note{ This function is preliminary and untested. } \seealso{ \code{\link{model.frame}}. } \examples{ ## Load Microsoft Data - setRmetricsOptions(myFinCenter = "GMT") data(MSFT) X = MSFT[1:12, ] ## Extract High's and Low's: model.frame( ~ High + Low, data = X) ## Extract Open Prices and their log10's: base = 10 Open = model.frame(Open ~ log(Open, base = `base`), data = X) colnames(Open) <- c("X", "log10(X)") Open } \keyword{chron} timeSeries/man/stats-lag.Rd0000644000176000001440000000234511370220767015365 0ustar ripleyusers\name{lag} \title{Lag a Time Series} \alias{lag} \alias{lag,timeSeries-method} \alias{lag.timeSeries} \description{ Compute a lagged version of a 'timeSeries' object. } \usage{ \S4method{lag}{timeSeries}(x, k = 1, trim = FALSE, units = NULL, \dots) } \arguments{ \item{k}{ [lagSeries] - \cr an integer value. The number of lags (in units of observations). By default 1. } \item{trim}{ a logical value. By default \code{TRUE}, the first missing observation in the return series will be removed. } \item{units}{ an optional character string, which allows to overwrite the current column names of a \code{timeSeries} object. By default \code{NULL} which means that the column names are selected automatically. } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments passed to other methods. } } \value{ returns a lagged S4 object of class \code{timeSeries}. } \examples{ ## Load Micsrosoft Data Set - x = MSFT[1:20, "Open"] ## Lag the timeSeries Object: lag(x, k = -1:1) } \keyword{chron} timeSeries/man/stats-filter.Rd0000644000176000001440000000071211370220767016103 0ustar ripleyusers \name{filter} \title{Linear Filtering on a Time Series} \alias{filter,timeSeries-method} \description{ Applies linear filtering to a univariate time series or to each series separately of a multivariate time series. } \value{ A timeSeries object without missing values. } \examples{ ## Dummy timeSeries data <- matrix(rnorm(24), ncol = 2) s <- timeSeries(data, timeCalendar()) ## Filter filter(s, rep(1, 3)) } timeSeries/man/stats-aggregate.Rd0000644000176000001440000000276711370220767016560 0ustar ripleyusers\name{aggregate-methods} \docType{methods} \alias{aggregate} \alias{aggregate.timeSeries} \alias{aggregate-methods} \alias{aggregate,timeSeries-method} \title{timeSeries Class, Functions and Methods} \description{ Aggregates a 'timeSeries' Object. } \usage{ \S4method{aggregate}{timeSeries}(x, by, FUN, \dots) } \arguments{ \item{by}{ [aggregate] - \cr sequence of \code{timeDate} objects denoting the aggregation period. } \item{FUN}{ the function to be applied. } % \item{units}{ % an optional character string, which allows to overwrite the % current column names of a \code{timeSeries} object. By default % \code{NULL} which means that the column names are selected % automatically. % } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments passed to other methods. } } \value{ returns an aggregated S4 object of class \code{timeSeries}. } \examples{ ## Load Microsoft Data Set - data(MSFT) x <- MSFT ## Aggregate by Weeks - by <- timeSequence(from = start(x), to = end(x), by = "week") aggregate(x, by, mean) ## Aggregate to Last Friday of Month - by <- unique(timeLastNdayInMonth(time(x), 5)) aggregate(x, by, mean) ## Aggregate to Last Day of Quarter - by <- unique(timeLastDayInQuarter(time(x))) aggregate(x, by, mean) } \keyword{methods} \keyword{chron} timeSeries/man/statistics-smoothLowess.Rd0000644000176000001440000000517011560011675020360 0ustar ripleyusers\name{smooth} \title{Smoothes Time Series Objects} \alias{smoothLowess} \alias{smoothSpline} \alias{smoothSupsmu} \description{ Smoothes a 'timeSeries' object. } \usage{ smoothLowess(x, f = 0.5, \dots) smoothSpline(x, spar = NULL, \dots) smoothSupsmu(x, bass = 5, \dots) } \arguments{ \item{x}{ an univariate 'timeSeries' object. } \item{f}{ the lowess smoother span. This gives the proportion of points in the plot which influence the smooth at each value. Larger values give more smoothness. } \item{spar}{ smoothing parameter, typically (but not necessarily) in (0,1]. By default \code{NULL}, i.e. the value will be automatically selected. } \item{bass}{ controls the smoothness of the fitted curve. Values of up to 10 indicate increasing smoothness. } \item{\dots}{ optional arguments to be passed to the underlying smoothers. } } \details{ The functions \code{smoothLowess}, \code{smoothSpline}, \code{smoothSupsmu} allow to smooth \code{timeSerie} object. The are interfaces to the function \code{lowess}, \code{supmsu}. and \code{smooth.spline} in R's \code{stats} package. The \code{\dots} arguments allow to pass optional arguments to the underlying \code{stats} functions and tailor the smoothing process. We refer to the manual pages of these functions for a proper setting of these options. } \value{ returns a bivariate 'timeSeries' object, the first column holds the original time series data, the second the smoothed series. } \author{ The R core team for the underlying smoother functions. } \examples{ ## Use Close from MSFT's Price Series - head(MSFT) MSFT.CLOSE <- MSFT[, "Close"] head(MSFT.CLOSE) ## Plot Original and Smoothed Series by Lowess - MSFT.LOWESS <- smoothLowess(MSFT.CLOSE, f = 0.1) head(MSFT.LOWESS) plot(MSFT.LOWESS, main = "Close - Lowess Smoothed") ## Plot Original and Smoothed Series by Splines - MSFT.SPLINE <- smoothSpline(MSFT.CLOSE, spar = 0.4) head(MSFT.SPLINE) plot(MSFT.SPLINE, main = "Close - Spline Smoothed") ## Plot Original and Smoothed Series by Supsmu - MSFT.SUPSMU <- smoothSupsmu(MSFT.CLOSE) head(MSFT.SUPSMU) plot(MSFT.SUPSMU, main = "Close - Spline Smoothed") } \keyword{chron} timeSeries/man/statistics-rowCumsums.Rd0000644000176000001440000000155311560011675020037 0ustar ripleyusers\name{rowCum} \title{Cumulated Column Statistics} \alias{rowCum} \alias{rowCumsums} \alias{rowCumsums,ANY-method} \alias{rowCumsums,timeSeries-method} \description{ Compute cumulative row Statistics. } \usage{ \S4method{rowCumsums}{ANY}(x, na.rm = FALSE, \dots) \S4method{rowCumsums}{timeSeries}(x, na.rm = FALSE, \dots) } \arguments{ \item{na.rm}{ a logical. Should missing values be removed? } \item{x}{ a time series, may be an object of class \code{"matrix"} or \code{"timeSeries"}. } \item{\dots}{ arguments to be passed. } } \value{ all functions return an S4 object of class \code{timeSeries}. } \examples{ ## Simulated Monthly Return Data - X = matrix(rnorm(24), ncol = 2) ## Compute cumulated Sums - rowCumsums(X) } \keyword{univar} timeSeries/man/statistics-rollMean.Rd0000644000176000001440000000454211560011675017425 0ustar ripleyusers\name{rollMean} \title{Rolling Statistics} \alias{rollStats} \alias{rollMean} \alias{rollMin} \alias{rollMax} \alias{rollMedian} \description{ Computes rolling mean, min, max and median for a 'timeSeries' object. } \usage{ rollStats(x, k, FUN=mean, na.pad=FALSE, align=c("center", "left", "right"), \dots) rollMean(x, k, na.pad = FALSE, align = c("center", "left", "right"), \dots) rollMin(x, k, na.pad = FALSE, align = c("center", "left", "right"), \dots) rollMax(x, k, na.pad = FALSE, align = c("center", "left", "right"), \dots) rollMedian(x, k, na.pad = FALSE, align = c("center", "left", "right"), \dots) } \arguments{ \item{x}{ an uni- or multivariate 'timeSeries' object. } \item{k}{ an integer width of the rolling window. Must be odd for \code{rollMedian}. } \item{FUN}{ the function to be rolled. } \item{na.pad}{ a logical flag. Should NA padding be added at beginning? By default \code{FALSE}. } \item{align}{ a character string specifying whether the index of the result should be left- or right-aligned or centered compared to the rolling window of observations. The default choice is set to \code{align="center"}. } \item{\dots}{ optional arguments to be passed. } } \value{ returns an object of class 'timeSeries'. } \details{ The code in the core of the functions \code{rollMean}, \code{rollMin}, \code{rollMax}, and \code{rollMedian} was borrowed from the package \code{zoo} authored by Achim Zeileis, Gabor Grothendieck and Felix Andrews. } \author{ Achim Zeileis, Gabor Grothendieck and Felix Andrews for code from the contributed R package \code{zoo} used in the functions \code{rollMean}, \code{rollMin}, \code{rollMax}, and \code{rollMedian}. } \examples{ ## Use Swiss Pension Fund Data Set of Returns - head(LPP2005REC) SPI <- LPP2005REC[, "SPI"] head(SPI) ## Plot Drawdowns - rmean <- rollMean(SPI, k = 10) plot(rmean) } \keyword{chron} timeSeries/man/statistics-orderStatistics.Rd0000644000176000001440000000104411560011675021034 0ustar ripleyusers\name{orderStatistics} \title{order Statistics} \alias{orderStatistics} \description{ Computes order statistic of a 'timeSeries'. } \usage{ orderStatistics(x) } \arguments{ \item{x}{ an object of class \code{timeSeries}. } } \value{ \code{orderStatistics} \cr returns ... } \examples{ ## Load Swiss Pension Fund Benchmark Data - setRmetricsOptions(myFinCenter = "GMT") data(LPP2005REC) ## Compute Order Statistics - head(orderStatistics(LPP2005REC)) } \keyword{chron} timeSeries/man/statistics-orderColnames.Rd0000644000176000001440000000750011560011675020446 0ustar ripleyusers\name{orderColnames} \title{Reorder Column Names of a Time Series} \alias{orderColnames} \alias{sortColnames} \alias{sampleColnames} \alias{statsColnames} \alias{pcaColnames} \alias{hclustColnames} \description{ Functions and methods dealing with the rearrangement of column names of 'timeSeries' objects. \cr \tabular{ll}{ \code{orderColnames} \tab Returns ordered column names of a time Series, \cr \code{sortColnames} \tab Returns sorted column names of a time Series, \cr \code{sampleColnames} \tab Returns sampled column names of a time Series, \cr \code{statsColnames} \tab Returns statistically rearranged column names, \cr \code{pcaColnames} \tab Returns PCA correlation ordered column names, \cr \code{hclustColnames} \tab Returns hierarchical clustered column names. } } \usage{ orderColnames(x, \dots) sortColnames(x, \dots) sampleColnames(x, \dots) statsColnames(x, FUN = colMeans, \dots) pcaColnames(x, robust = FALSE, \dots) hclustColnames(x, method = c("euclidean", "complete"), \dots) } \arguments{ \item{FUN}{ a character string indicating which statistical function should be applied. By default statistical ordering operates on the column means of the time series. } \item{method}{ a character string with two elements. The first determines the choice of the distance measure, see \code{dist}, and the second determines the choice of the agglomeration method, see \code{hclust}. } \item{robust}{ a logical flag which indicates if robust correlations should be used. } \item{x}{ an object of class \code{timesSeries} or any other rectangular object which can be transformed by the function \code{as.matrix} into a numeric matrix. } \item{\dots}{ further arguments to be passed, see details. } } \details{ \bold{Statistically Motivated Rearrangement} The function \code{statsColnames} rearranges the column names according to a statical measure. These measure must operate on the columns of the time series and return a vector of values which can be sorted. Typical functions ar those listed in in help page \code{colStats} but one can also crete his own functions which compute for example risk or any other statistical measure. The \code{\dots} argument allows to pass additional arguments to the underlying function \code{FUN}.\cr \bold{PCA Ordering of the Correlation Matrix} The function \code{pcaColnames} rearranges the column names according to the PCA ordered correlation matrix. The argument \code{robust} allsows to select between the use of the standard \code{cor} and computation of robust correlations using the function \code{covMcd} from contributed R package \code{robustbase}. The \code{\dots} argument allows to pass additional arguments to the two underlying functions \code{cor} or \code{covMcd}. E.g. adding \code{method="kendall"} to the argument list calculates Kendall's rank correlations instead the default which calculates Person's correlations.\cr \bold{Ordering by Hierarchical Clustering} The function \code{pcaColnames} uses the hierarchical clustering approach \code{hclust} to rearrange the column names of the time series. } \value{ returns a vector of character string, the rearranged column names. } \examples{ ## Load Swiss Pension Fund Benchmark Data - data(LPP2005REC) ## Abbreviate Column Names - colnames(LPP2005REC) ## Sort Alphabetically - sortColnames(LPP2005REC) ## Sort by Column Names by Hierarchical Clustering - hclustColnames(LPP2005REC) head(LPP2005REC[, hclustColnames(LPP2005REC)]) } \keyword{chron} timeSeries/man/statistics-colSums.Rd0000644000176000001440000000460211560011675017276 0ustar ripleyusers\name{colStats} \alias{colStats} \alias{colSums,timeSeries-method} \alias{colMeans,timeSeries-method} \alias{colSds} \alias{colVars} \alias{colSkewness} \alias{colKurtosis} \alias{colMaxs} \alias{colMins} \alias{colProds} \alias{colQuantiles} \alias{colAvgs} \alias{colStdevs} % \alias{mean.timeSeries} % \alias{var.timeSeries} \title{Column Statistics} \description{ A collection and description of functions to compute column statistical properties of financial and economic time series data. \cr The functions are: \tabular{ll}{ \code{colStats}\tab calculates column statistics, \cr \code{colSums} \tab calculates column sums, \cr \code{colMeans} \tab calculates column means, \cr \code{colSds} \tab calculates column standard deviations, \cr \code{colVars} \tab calculates column variances, \cr \code{colSkewness} \tab calculates column skewness, \cr \code{colKurtosis} \tab calculates column kurtosis, \cr \code{colMaxs} \tab calculates maximum values in each column, \cr \code{colMins} \tab calculates minimum values in each column, \cr \code{colProds} \tab computes product of all values in each column, \cr \code{colQuantiles} \tab computes quantiles of each column. } } \usage{ colStats(x, FUN, \dots) colSds(x, \dots) colVars(x, \dots) colSkewness(x, \dots) colKurtosis(x, \dots) colMaxs(x, \dots) colMins(x, \dots) colProds(x, \dots) colQuantiles(x, prob = 0.05, \dots) colStdevs(x, \dots) colAvgs(x, \dots) % \method{mean}{timeSeries}(x, \dots) % \method{var}{timeSeries}(x, \dots) } \arguments{ \item{FUN}{ a function name. The statistical function to be applied. } \item{prob}{ a numeric value, the probability with value in [0,1]. } \item{x}{ a rectangular object which can be transformed into a matrix by the function \code{as.matrix}. } \item{\dots}{ arguments to be passed. } } \value{ the functions return a numeric vector of the statistics. } \seealso{ \code{link{rowStats}}. } \examples{ ## Simulated Return Data in Matrix Form - x = matrix(rnorm(252), ncol = 2) ## Mean Columnwise Statistics - colStats(x, FUN = mean) ## Quantiles Column by Column - colQuantiles(x, prob = 0.10, type = 1) } \keyword{univar} timeSeries/man/statistics-colCumsums.Rd0000644000176000001440000000314611560011675020005 0ustar ripleyusers\name{colCum} \title{Cumulated Column Statistics} \alias{colCum} \alias{colCummaxs} \alias{colCummins} \alias{colCumprods} \alias{colCumreturns} \alias{colCumsums} \alias{colCummaxs,matrix-method} \alias{colCummaxs,timeSeries-method} \alias{colCummins,matrix-method} \alias{colCummins,timeSeries-method} \alias{colCumprods,matrix-method} \alias{colCumprods,timeSeries-method} \alias{colCumreturns,matrix-method} \alias{colCumreturns,timeSeries-method} \alias{colCumsums,matrix-method} \alias{colCumsums,timeSeries-method} \description{ Functions to compute cumulative column statistics. } \usage{ \S4method{colCumsums}{timeSeries}(x, na.rm = FALSE, \dots) \S4method{colCummaxs}{timeSeries}(x, na.rm = FALSE, \dots) \S4method{colCummins}{timeSeries}(x, na.rm = FALSE, \dots) \S4method{colCumprods}{timeSeries}(x, na.rm = FALSE, \dots) \S4method{colCumreturns}{timeSeries}(x, method = c("geometric", "simple"), na.rm = FALSE, \dots) } \arguments{ \item{method}{ a character string to indicate if geometric (TRUE) or simple (FALSE) returns should be computed. } \item{na.rm}{ a logical. Should missing values be removed? } \item{x}{ a time series, may be an object of class \code{"matrix"}, or \code{"timeSeries"}. } \item{\dots}{ arguments to be passed. } } \value{ all functions return an S4 object of class \code{timeSeries}. } \examples{ ## Simulated Return Data - x = matrix(rnorm(24), ncol = 2) ## Cumulative Sums Column by Column - colCumsums(x) } \keyword{univar} timeSeries/man/methods-stats.Rd0000644000176000001440000000404411370220767016263 0ustar ripleyusers\name{timeSeries-method-stats} \docType{methods} \alias{sd-methods} \alias{var-methods} \alias{cov-methods} \alias{cor-methods} \alias{dcauchy-methods} \alias{dnorm-methods} \alias{dt-methods} \alias{sd,timeSeries-method} \alias{var,timeSeries-method} \alias{cov,timeSeries-method} \alias{cor,timeSeries-method} \alias{dcauchy,timeSeries-method} \alias{dnorm,timeSeries-method} \alias{dt,timeSeries-method} \title{Time Series Correlations} \description{ S4 methods of stats package for \code{timeSeries} objects. \cr \tabular{ll}{ \code{cov} \tab Computes Covariance from a 'timeSeries' object, \cr \code{cor} \tab Computes Correlations from a 'timeSeries' object. \cr \code{dcauchy} \tab ... \cr \code{dnorm} \tab ... \cr \code{dt} \tab ... \cr } } \usage{ \S4method{cov}{timeSeries}(x, y = NULL, use = "all.obs", method = c("pearson", "kendall", "spearman")) \S4method{cor}{timeSeries}(x, y = NULL, use = "all.obs", method = c("pearson", "kendall", "spearman")) } \arguments{ \item{method}{ a character string indicating which correlation coefficient (or covariance) is to be computed. One of \code{"pearson"} (default), \code{"kendall"}, or \code{"spearman"}, can be abbreviated. } \item{use}{ an optional character string giving a method for computing covariances in the presence of missing values. This must be (an abbreviation of) one of the strings \code{"all.obs"}, \code{"complete.obs"} or \code{"pairwise.complete.obs"}. } \item{x}{ an univariate object of class \code{timeSeries}. } \item{y}{ NULL (default) or a \code{timeSeries} object with compatible dimensions to \code{x}. The default is equivalent to y = x (but more efficient). } } \value{ returns the covariance or correlation matrix. } \examples{ ## Load Microsoft Data Set - data(MSFT) X = MSFT[, 1:4] X = 100 * returns(X) ## Compute Covariance Matrix - cov(X[, "Open"], X[, "Close"]) cov(X) } \keyword{methods} \keyword{chron} timeSeries/man/methods-show.Rd0000644000176000001440000000126411370220767016106 0ustar ripleyusers\name{print-methods} \title{Print a Time Series} \alias{show,timeSeries-method} \alias{print,timeSeries-method} \description{ Print 'timeSeries' pbjects. } % \usage{ % show.timeSeries(object) % } \arguments{ \item{object}{ an object of class \code{timeSeries}. } } \value{ prints an object of class \code{timeSeries}. } \examples{ ## Load Micsrosoft Data - setRmetricsOptions(myFinCenter = "GMT") LPP = MSFT[1:12, 1:4] ## Abbreviate Column Names - colnames(LPP) <- abbreviate(colnames(LPP), 6) ## Print Data Set - print(LPP) ## Alternative Use, Show Data Set - show(LPP) } \keyword{chron} timeSeries/man/methods-plot.Rd0000644000176000001440000001314611731572411016103 0ustar ripleyusers\name{plot-methods} \title{Plot a Time Series} \alias{plot} \alias{plot,timeSeries-method} \alias{lines,timeSeries-method} \alias{points,timeSeries-method} \alias{pretty.timeSeries} \description{ Plot 'timeSeries' objects and add lines and points to an already existing chart or graph. } \usage{ \S4method{plot}{timeSeries}(x, y, FinCenter = NULL, plot.type = c("multiple", "single"), format = "auto", at = pretty(x), widths = 1, heights = 1, xy.labels, xy.lines, panel = lines, nc, yax.flip = FALSE, mar.multi = c(0, 5.1, 0, if (yax.flip) 5.1 else 2.1), oma.multi = c(6, 0, 5, 0), axes = TRUE, \ldots) \S4method{lines}{timeSeries}(x, FinCenter = NULL, \dots) \S4method{points}{timeSeries}(x, FinCenter = NULL, \dots) \method{pretty}{timeSeries}(x, n=5, min.n=n\%/\%3, shrink.sml=0.75, high.u.bias=1.5, u5.bias=0.5+1.5*high.u.bias, eps.correct=0, \dots) } \arguments{ \item{x,y }{ objects of class \code{timeSeries}. } \item{FinCenter}{ a character with the the location of the financial center named as \code{"continent/city"}. } \item{plot.type}{ for multivariate time series, should the series by plotted separately (with a common time axis) or on a single plot? } \item{format}{POSIX label format, e.g. "\%Y-\%m-\%d" or "\%F" for ISO-8601 standard date format. } \item{at}{ a \code{timeDate} object setting the plot label positions. If \code{at=pretty(x)}, the postitions are generated automatized calling the function \code{pretty}. Former default option \code{at="auto"} selects 6 equal spaced time label positions. } \item{widths, heights}{ widths and heights for individual graphs, see \code{layout}. } \item{xy.labels}{ logical, indicating if \code{text()} labels should be used for an x-y plot, \_or\_ character, supplying a vector of labels to be used. The default is to label for up to 150 points, and not for more. } \item{xy.lines}{ logical, indicating if \code{lines} should be drawn for an x-y plot. Defaults to the value of \code{xy.labels} if that is logical, otherwise to \code{TRUE} } \item{panel}{ a \code{function(x, col, bg, pch, type, ...)} which gives the action to be carried out in each panel of the display for \code{plot.type="multiple"}. The default is \code{lines}. } \item{nc}{ the number of columns to use when \code{type="multiple"}. Defaults to 1 for up to 4 series, otherwise to 2. } \item{yax.flip}{ logical indicating if the y-axis (ticks and numbering) should flip from side 2 (left) to 4 (right) from series to series when \code{type="multiple"}. } \item{mar.multi, oma.multi}{ the (default) \code{par} settings for \code{plot.type="multiple"}. } \item{axes}{ logical indicating if x- and y- axes should be drawn. } \item{n}{ an integer giving the desired number of intervals. } \item{min.n}{ a nonnegative integer giving the minimal number of intervals. } \item{shrink.sml}{ a positive numeric by a which a default scale is shrunk in the case when range(x) is very small. } \item{high.u.bias}{ a non-negative numeric, typically > 1. Larger high.u.bias values favor larger units. } \item{u5.bias}{ a non-negative numeric multiplier favoring factor 5 over 2. } \item{eps.correct}{ an integer code, one of {0,1,2}. If non-0, a correction is made at the boundaries. } \item{\dots}{ additional graphical arguments, see \code{plot}, \code{plot.default} and \code{par}. } } \value{ a plot or plot elements of an object of class \code{timeSeries}. } \examples{ ## Load Swiss Pension Fund Benchmark Data - LPP <- LPP2005REC[1:12, 1:4] colnames(LPP) <- abbreviate(colnames(LPP), 2) finCenter(LPP) <- "GMT" ## Example Plot 1 - plot(LPP[, 1], type = "o", col = "steelblue", main = "LPP", xlab = "2005", ylab = "Return") plot(LPP[, 1], at="auto", type = "o", col = "steelblue", main = "LPP", xlab = "2005", ylab = "Return") ## Example Plot 2 - plot(LPP[, 1:2], type = "o", col = "steelblue", main = "LPP", xlab = "2005", ylab = "Return") ## Example Plot 3 - plot(LPP[, 1], LPP[, 2], type = "p", col = "steelblue", main = "LPP", xlab = "Return 1", ylab = "Return 2") ## Example Plot 4a, The Wrong Way to do it! - LPP <- as.timeSeries(data(LPP2005REC)) ZRH <- as.timeSeries(LPP[,"SPI"], zone = "Zurich", FinCenter = "Zurich") NYC <- as.timeSeries(LPP[,"LMI"], zone = "NewYork", FinCenter = "NewYork") finCenter(ZRH) finCenter(NYC) plot(ZRH, at="auto", type = "p", pch = 19, col = "blue") points(NYC, pch = 19, col = "red") ## Example Plot 4b, Convert NYC to Zurich Time - finCenter(ZRH) <- "Zurich" finCenter(NYC) <- "Zurich" at <- unique(round(time(ZRH))) plot(ZRH, type = "p", pch = 19, col = "blue", format = "\%b \%d", at = at, xlab = paste(ZRH@FinCenter, "local Time"), main = ZRH@FinCenter) points(NYC, pch = 19, col = "red") ## Example 4c, Force Everything to GMT Using "FinCenter" Argument - finCenter(ZRH) <- "Zurich" finCenter(NYC) <- "NewYork" at <- unique(round(time(ZRH))) plot(ZRH, type = "p", pch = 19, col = "blue", format = "\%b \%d", at = at, FinCenter = "GMT", xlab = "GMT", main = "ZRH - GMT") points(NYC, FinCenter = "GMT", pch = 19, col = "red") } \keyword{chron} timeSeries/man/methods-mathOps.Rd0000644000176000001440000000701111370220767016535 0ustar ripleyusers\name{math} \alias{math} \alias{Ops,vector,timeSeries-method} \alias{Ops,array,timeSeries-method} \alias{Ops,ts,timeSeries-method} \alias{Ops,timeSeries,vector-method} \alias{Ops,timeSeries,array-method} \alias{Ops,timeSeries,ts-method} \alias{Ops,timeSeries,timeSeries-method} \alias{-,timeSeries,missing-method} \alias{+,timeSeries,missing-method} \alias{cummax,timeSeries-method} \alias{cummin,timeSeries-method} \alias{cumprod,timeSeries-method} \alias{cumsum,timeSeries-method} \alias{Math,timeSeries-method} \alias{Math2,timeSeries-method} \alias{Summary,timeSeries-method} \alias{trunc,timeSeries-method} \alias{log,timeSeries-method} \alias{\%*\%,timeSeries,vector-method} \alias{\%*\%,timeSeries,ANY-method} \alias{\%*\%,ANY,timeSeries-method} \alias{diff,timeSeries-method} \alias{scale,timeSeries-method} \alias{quantile,timeSeries-method} \alias{diff.timeSeries} \alias{scale.timeSeries} \alias{quantile.timeSeries} \title{Mathematical Time Series Operations} \description{ Functions and methods dealing with mathematical 'timeSeries' operations. \cr \tabular{ll}{ \code{Ops-method} \tab Group 'Ops' methods for a 'timeSeries' object \cr \code{Math-method} \tab Group 'Math' methods for a 'timeSeries' object \cr \code{Math2-method} \tab Group 'Math2' methods for a 'timeSeries' object \cr \code{Summary-method} \tab Group 'Summary' methods for a 'timeSeries' object \cr \code{diff} \tab Differences a 'timeSeries' object, \cr \code{scale} \tab Centers and/or scales a 'timeSeries' object, \cr \code{quantile} \tab Returns quantiles of an univariate 'timeSeries'. } } \usage{ % \S4method{Ops}{timeSeries}(e1, e2) % \S4method{Math}{timeSeries}(x, ...) % \S4method{Math2}{timeSeries}(x, digits) % \S4method{Summary}{timeSeries}(x, ..., na.rm = FALSE) \S4method{diff}{timeSeries}(x, lag = 1, diff = 1, trim = FALSE, pad = NA, \dots) \S4method{scale}{timeSeries}(x, center = TRUE, scale = TRUE) \S4method{quantile}{timeSeries}(x, \dots) } \arguments{ \item{center, scale}{ [scale] - \cr either a logical value or a numeric vector of length equal to the number of columns of \code{x}. } \item{diff}{ an integer indicating the order of the difference. By default 1. } % \item{digits} { % number of digits to be used in 'round' or 'signif'. % } % \item{e1, e2}{ % [Ops] - \cr % two objects of class \code{timeSeries}. % } \item{lag}{ an integer indicating which lag to use. By default 1. } % \item{na.rm}{ % logical: should missing values be removed? % } \item{pad}{ [diffSeries] - \cr which value should get the padded values? By default \code{NA}. Another choice often used would be zero. } \item{trim}{ a logical value. By default \code{TRUE}, the first missing observation in the return series will be removed. } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments to be passed. } } \value{ returns the value from a mathematical or logical operation operating on objects of class \code{timeSeries}, or the value computed by a mathematical function. } \examples{ ## Create an Artificial timeSeries Object - setRmetricsOptions(myFinCenter = "GMT") charvec = timeCalendar() set.seed(4711) data = matrix(exp(cumsum(rnorm(12, sd = 0.1)))) TS = timeSeries(data, charvec, units = "TS") TS ## Mathematical Operations: | +/- * ^ ... - TS^2 TS[2:4] OR = returns(TS) OR OR > 0 } \keyword{chron} \keyword{methods} timeSeries/man/methods-is.Rd0000644000176000001440000000154311370220767015541 0ustar ripleyusers\name{is.timeSeries} \title{timeSeries Class, Coercion and Transformation} \alias{is.timeSeries} \alias{is.signalSeries} \alias{is.na,timeSeries-method} \alias{is.unsorted,timeSeries-method} \description{ \code{is.timeSeries} tests if its argument is a \code{timeSeries}. \code{is.timeSeries} tests if series has no timestamps. } \usage{ is.timeSeries(x) is.signalSeries(x) } \arguments{ \item{x}{ an R object. } } \value{ returns \code{TRUE} or \code{FALSE} depending on whether its argument is of \code{timeSeries} type or not. } \examples{ ## Create an Artificial timeSeries Object - setRmetricsOptions(myFinCenter = "GMT") charvec = timeCalendar() data = matrix(rnorm(12)) TS = timeSeries(data, charvec, units = "RAND") TS ## Test for timeSeries - is.timeSeries(TS) } \keyword{chron} timeSeries/man/methods-comment.Rd0000644000176000001440000000106211560011675016561 0ustar ripleyusers\name{comment} \alias{comment,timeSeries-method} \alias{comment<-,timeSeries-method} \title{comment for timeSeries objects} \description{ Print or assign new comment to a \code{timeSeries} object. } \usage{ \S4method{comment}{timeSeries}(x) \S4method{comment}{timeSeries}(x) <- value } \arguments{ \item{x}{ a \code{timeSeries} object. } \item{value}{ a character string. } } \examples{ ## Load Swiss Pension Fund Benchmark - data(LPP2005REC) ## Get Description from timeSeries - comment(LPP2005REC) } \keyword{chron} timeSeries/man/methods-base.Rd0000644000176000001440000000063011370220767016034 0ustar ripleyusers\name{base-methods} \title{Methods for 'timeSeries' object} \docType{methods} \alias{mean,timeSeries-method} \alias{summary,timeSeries-method} \description{ Methods for function in Package `base' for \code{timeSeries} object. var summary var } \section{Methods}{ \describe{ \item{x = "timeSeries"}{a \code{timeSeries} object.} }} \examples{ ## None - } \keyword{chron} timeSeries/man/methods-as.Rd0000644000176000001440000001005611370220767015530 0ustar ripleyusers\name{as} \title{timeSeries Class, Coercion and Transformation} \alias{as} \alias{as.timeSeries} \alias{as.timeSeries.default} \alias{as.timeSeries.ts} \alias{as.timeSeries.data.frame} \alias{as.timeSeries.character} \alias{as.timeSeries.zoo} \alias{as.ts,timeSeries-method} \alias{as.data.frame,timeSeries-method} \alias{as.list,timeSeries-method} \alias{as.matrix,timeSeries-method} \alias{as.ts.timeSeries} \alias{as.data.frame.timeSeries} \alias{as.list.timeSeries} \alias{as.matrix.timeSeries} \alias{coerce,ANY,timeSeries-method} \alias{coerce,ts,timeSeries-method} \alias{coerce,data.frame,timeSeries-method} \alias{coerce,character,timeSeries-method} \alias{coerce,ANY,timeSeries-method} \alias{coerce,timeSeries,tse-method} \alias{coerce,timeSeries,data.frame-method} \alias{coerce,timeSeries,list-method} \alias{coerce,timeSeries,matrix-method} \alias{coerce,timeSeries,ts-method} \description{ Functions and methods dealing with the coercion of 'timeSeries' objects. \cr Functions to create 'timeSeries' objects from other objects: \tabular{ll}{ \code{as.timeSeries} \tab Generic function to convert an object to a 'timeSeries' object, \cr \code{as.timeSeries.default} \tab Returns the unchanged object, \cr \code{as.timeSeries.numeric} \tab Converts from a numeric vector, \cr \code{as.timeSseries.data.frame} \tab Converts from a numeric vector, \cr \code{as.timeSeries.matrix} \tab Converts from a matrix, \cr \code{as.timeSeries.ts} \tab Converts from an object of class 'ts', \cr \code{as.timeSeries.character} \tab Converts from a named demo file, \cr \code{as.timeSeries.zoo} \tab Converts an object of class zoo. } Functions to transform 'timeSeries' objects into other objects: \tabular{ll}{ % \code{as.vector.timeSeries} \tab Coerces a 'timeSeries' to a vector, % \cr % \code{as.numeric.timeSeries} \tab Coerces a 'timeSeries' to numeric, % \cr \code{as.matrix.timeSeries} \tab Coerces a 'timeSeries' to a matrix, \cr \code{as.data.frame.timeSeries} \tab Coerces a 'timeSeries' to a data.frame, \cr \code{as.ts.timeSeries} \tab S3: Coerces a 'timeSeries' to a 'ts' object. \cr \code{as.ts.timeSeries} \tab S3: Coerces a 'timeSeries' to a 'logical' object. } } \usage{ \method{as.timeSeries}{default}(x, \dots) \method{as.timeSeries}{ts}(x, \dots) \method{as.timeSeries}{data.frame}(x, \dots) \method{as.timeSeries}{character}(x, \dots) \method{as.timeSeries}{zoo}(x, \dots) \S4method{as.matrix}{timeSeries}(x, \dots) \S4method{as.ts}{timeSeries}(x, \dots) \S4method{as.data.frame}{timeSeries}(x, row.names = NULL, optional = FALSE, \dots) \S4method{as.ts}{timeSeries}(x, \dots) } \arguments{ % \item{mode}{ % a character string giving an atomic mode or \code{"list"}, % or (not for 'vector') \code{"any"}. % } \item{optional}{ A logical value. If \code{TRUE}, setting row names and converting column names (to syntactic names) is optional. } \item{row.names}{ \code{NULL} or a character vector giving the row names for the data frame. Missing values are not allowed. } \item{x}{ an object which is coerced according to the generic function. } \item{\dots}{ arguments passed to other methods. } } \value{ \code{as.timeSeries}\cr \cr returns a S4 object of class \code{timeSeries}. \cr % \code{as.vector}\cr \code{as.numeric}\cr \code{as.data.frame}\cr \code{as.matrix}\cr \code{as.ts} \cr return depending on the generic function a numeric vector, a data frame, a matrix, or an object of class \code{ts}. } \examples{ ## Create an Artificial timeSeries Object - setRmetricsOptions(myFinCenter = "GMT") charvec = timeCalendar() data = matrix(rnorm(12)) TS = timeSeries(data, charvec, units = "RAND") TS ## Coerce to Vector - as.vector(TS) ## Coerce to Matrix - as.matrix(TS) ## Coerce to Data Frame - as.data.frame(TS) } \keyword{chron} timeSeries/man/fin-turnpoints.Rd0000644000176000001440000000675611560011675016474 0ustar ripleyusers\name{turns} \title{Turning Points of a Time Series} \alias{turns} \alias{turnsStats} \description{ Extracts and analyzes turn points of an univariate \code{timeSeries} object. } \usage{ turns(x, \dots) turnsStats(x, doplot = TRUE) } \arguments{ \item{x}{ an univariate 'timeSeries' object of financial indices or prices. } \item{\dots}{ optional arguments passed to the function \code{na.omit}. } \item{doplot}{ a logical flag, should the results be plotted? By default TRUE. } } \details{ The function \code{turns} determines the number and the position of extrema (turning points, either peaks or pits) in a regular time series. The function \code{turnsStats} calculates the quantity of information associated to the observations in this series, according to Kendall's information theory. The functions are borrowed from the contributed R package \code{pastecs} and made ready for working together with univariate \code{timeSeries} objects. You need not to load the R package \code{pastecs}, the code parts we need here are builtin in the \code{timeSeries} package. We have renamed the function \code{turnpoints} to \code{turns} to distinguish between the original function in the contributed R package \code{pastecs} and our Rmetrics function wrapper. For further details please consult the help page from the contributed R package \code{pastecs}. } \value{ \code{turns}\cr returns an object of class \code{timeSeries}. \code{turnsStats}\cr returns an object of class \code{turnpoints} with the following entries:\cr \code{data} - The dataset to which the calculation is done.\cr \code{n} - The number of observations.\cr \code{points} - The value of the points in the series, after elimination of ex-aequos.\cr \code{pos} - The position of the points on the time scale in the series (including ex-aequos).\cr \code{exaequos} - Location of exaequos (1), or not (0).\cr \code{nturns} - Total number of tunring points in the whole time series.\cr \code{firstispeak} - Is the first turning point a peak (TRUE), or not (FALSE).\cr \code{peaks} - Logical vector. Location of the peaks in the time series without ex-aequos.\cr \code{pits} - Logical vector. Location of the pits in the time series without ex-aequos.\cr \code{tppos} - Position of the turning points in the initial series (with ex-aequos).\cr \code{proba} - Probability to find a turning point at this location.\cr \code{info} - Quantity of information associated with this point.\cr } \author{ Frederic Ibanez and Philippe Grosjean for code from the contributed R package \code{pastecs} and Rmetrics for the function wrapper. } \references{ Ibanez, F., 1982, Sur une nouvelle application de la theorie de l'information a la description des series chronologiques planctoniques. J. Exp. Mar. Biol. Ecol., 4, 619--632 Kendall, M.G., 1976, Time Series, 2nd ed. Charles Griffin and Co, London. } \examples{ ## Load Swiss Equities Series - SPI.RET <- LPP2005REC[, "SPI"] head(SPI.RET) ## Cumulate and Smooth the Series - SPI <- smoothLowess(cumulated(SPI.RET), f=0.05) plot(SPI) ## Plot Turn Points Series - SPI.SMOOTH <- SPI[, 2] tP <- turns(SPI.SMOOTH) plot(tP) ## Compute Statistics - turnsStats(SPI.SMOOTH) } \keyword{chron} timeSeries/man/fin-spreads.Rd0000644000176000001440000000336111370220767015700 0ustar ripleyusers\name{spreads} \title{Spreads and Mid Quotes} \alias{spreads} \alias{midquotes} \alias{spreadSeries} \alias{midquoteSeries} \description{ Compute spreads and midquotes from price streams. } \usage{ spreads(x, which = c("Bid", "Ask"), tickSize = NULL) midquotes(x, which = c("Bid", "Ask")) midquoteSeries(\dots) spreadSeries(\dots) } \arguments{ \item{tickSize}{ the default is NULL to simply compute price changes in original price levels. If ticksize is supplied, the price changes will be divided by the value of \code{inTicksOfSize} to compute price changes in ticks. } \item{which}{ a vector with two character strings naming the column names of the time series from which to compute the mid quotes and spreads. By default these are bid and ask prices with column names \code{c("Bid", "Ask")}. } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments to be passed. } } \value{ all functions return an object of class \code{timeSeries}. } \note{ The functions \code{returnSeries}, \code{getReturns}, \code{midquoteSeries}, \code{spreadSeries} are synonymes for \code{returns}, \code{midquotes}, and \code{spreads}. } \examples{ ## Load the Microsoft Data - setRmetricsOptions(myFinCenter = "GMT") data(MSFT) X = MSFT[1:10, ] head(X) ## Compute Open/Close Midquotes - X.MID <- midquotes(X, which = c("Close", "Open")) colnames(X.MID) <- "X.MID" X.MID ## Compute Open/Close Spreads - X.SPREAD <- spreads(X, which = c("Close", "Open")) colnames(X.SPREAD) <- "X.SPREAD" X.SPREAD } \keyword{chron} timeSeries/man/fin-splits.Rd0000644000176000001440000000026611560011675015553 0ustar ripleyusers\name{splits} \title{splits} \description{ Description ... } timeSeries/man/fin-runlengths.Rd0000644000176000001440000000123111560011675016417 0ustar ripleyusers\name{runlengths} \title{Runlengths of a Time Series} \alias{runlengths} \description{ Computes runlengths of an univariate \code{timeSeries} object. } \usage{ runlengths(x, \dots) } \arguments{ \item{x}{ an univariate time series of class \code{timeSeries}. } \item{\dots}{ arguments to be passed. } } \value{ returns an object of class \code{timeSeries}. } \examples{ ## random time series - set.seed(4711) x <- rnorm(12) tS <- timeSeries(data=x, charvec=timeCalendar(), units="x") tS ## return runlengths - runlengths(tS) } \keyword{chron} timeSeries/man/fin-returns.Rd0000644000176000001440000000366611370220767015751 0ustar ripleyusers\name{returns} \title{Financial Returns} \alias{returns} \alias{returns,ANY-method} \alias{returns,timeSeries-method} \alias{returnSeries} \alias{getReturns} \description{ Compute financial returns from prices or indexes. } \usage{ returns(x, \dots) \S4method{returns}{ANY}(x, method = c("continuous", "discrete", "compound", "simple"), percentage = FALSE, \dots) \S4method{returns}{timeSeries}(x, method = c("continuous", "discrete", "compound", "simple"), percentage = FALSE, na.rm = TRUE, trim = TRUE, \dots) getReturns(\dots) returnSeries(\dots) } \arguments{ \item{percentage}{ a logical value. By default \code{FALSE}, if \code{TRUE} the series will be expressed in percentage changes. } \item{method}{ a character string. Which method should be used to compute the returns, "continuous", "discrete", or "compound", "simple". The second pair of methods is a synonyme for the first two methods. } \item{na.rm}{ a logical value. Should NAs be removed? By Default \code{TRUE}. } \item{trim}{ a logical value. Should the time series be trimmed? By Default \code{TRUE}. } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments to be passed. } } \value{ all functions return an object of class \code{timeSeries}. } \note{ The functions \code{returnSeries}, \code{getReturns}, are synonymes for \code{returns.timeSeries}. } \examples{ ## Load Microsoft Data - setRmetricsOptions(myFinCenter = "GMT") data(MSFT) X = MSFT[1:10, 1:4] X ## Continuous Returns - returns(X) ## Discrete Returns: returns(X, type = "discrete") ## Don't trim: returns(X, trim = FALSE) ## Use Percentage Values: returns(X, percentage = TRUE, trim = FALSE) } \keyword{chron} timeSeries/man/fin-periodical.Rd0000644000176000001440000000027611560011675016351 0ustar ripleyusers\name{periodical} \title{periodical} \description{ Description ... } timeSeries/man/fin-monthly.Rd0000644000176000001440000000320311370220767015724 0ustar ripleyusers\name{monthly} \alias{monthly} \alias{countMonthlyRecords} \alias{rollMonthlyWindows} \alias{rollMonthlySeries} \title{Special Monthly Series} \description{ Functions and methods dealing with special monthly 'timeSeries' objects. \cr \tabular{ll}{ \code{countMonthlyRecords} \tab Returns a series with monthly counts of records, \cr \code{rollMonthlyWindows} \tab Returns start and end dates for rolling time windows, \cr \code{rollMonthlySeries} \tab Rolls monthly a 'timeSeries' on a given period. } } \usage{ countMonthlyRecords(x) rollMonthlyWindows(x, period = "12m", by = "1m") rollMonthlySeries(x, period = "12m", by = "1m", FUN, \dots) } \arguments{ \item{by}{ a character string specifying the rolling shift composed by the length of the shift and its unit, e.g. \code{"3m"} represents quarterly shifts. } \item{FUN}{ the function to be applied.\cr [applySeries] - \cr a function to use for aggregation, by default \code{colAvgs}. } \item{period}{ [rollMonthlySeries] - \cr a character string specifying the rollling period composed by the length of the period and its unit, e.g. \code{"12m"} represents one year. } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments passed to other methods. } } \value{ NA } \examples{ ## Load Microsoft Daily Data Set: data(MSFT) ## Count Monthly Records - MSFT.CTS <- countMonthlyRecords(MSFT) MSFT.CTS } \keyword{chron} timeSeries/man/fin-durations.Rd0000644000176000001440000000251611560011675016245 0ustar ripleyusers\name{durations} \title{Durations from a Time Series} \alias{durations} \alias{durationSeries} \description{ Compute durations from an object of class 'timeSeries'. } \usage{ durations(x, trim = FALSE, units = c("secs", "mins", "hours", "days")) } \arguments{ \item{x}{ an object of class \code{timeSeries}. } \item{trim}{ a logical value. By default \code{TRUE}, the first missing observation in the return series will be removed. } \item{units}{ a character value or vector which allows to set the units in which the durations are measured. By default durations are measured in seconds. } } \details{ Durations measure how long it takes until we get the next record in a \code{timesSeries} object. We return a time series in which for each time stamp we get the length of the period from when we got the last record. This period is measured in length specified by the argument \code{units}, for daily data use \code{units="days"}. } \value{ returns an object of class \code{timeSeries}. } \examples{ ## Compute Durations in days for the MSFT Sereries - head(durations(MSFT, units = "days")) head(durations(MSFT, trim = TRUE, units = "days")) } \keyword{chron} timeSeries/man/fin-drawdowns.Rd0000644000176000001440000000413111560011675016240 0ustar ripleyusers\name{drawdowns} \title{Calculations of Drawdowns} \alias{drawdowns} \alias{drawdownsStats} \description{ Compute series of drawdowns from financial returns and calculate drawdown statisitcs. } \usage{ drawdowns(x, \dots) drawdownsStats(x, \dots) } \arguments{ \item{x}{ a 'timeSeries' object of financial returns. Note, drawdowns can be calculated from an uni- or multivariate time deries object, statistics can only be computed from an univariate time series object. } \item{\dots}{ optional arguments passed to the function \code{na.omit}. } } \value{ \code{drawdowns}\cr returns an object of class 'timeSeries'. \code{drawdownsStats}\cr returns an object of class 'data.frame' with the following entries:\cr \code{"drawdown"} - the depth of the drawdown, \cr \code{"from"} - the start date, \cr \code{"trough"} - the trough period, \cr \code{"to"} - the end date, \cr \code{"length"} - the length in number of records, \cr \code{"peaktrough"} - the peak trough, and , \cr \code{"recovery"} - the recovery length in number of records. } \details{ The code in the core of the function \code{drawdownsStats} was was borrowed from the package \code{PerformanceAnalytics} authored by Peter Carl and Sankalp Upadhyay. } \author{ Peter Carl and Sankalp Upadhyay for code from the contributed R package \code{PerformanceAnalytics} used in the function \code{drawdownsStats}. } \examples{ ## Use Swiss Pension Fund Data Set of Returns - head(LPP2005REC) SPI <- LPP2005REC[, "SPI"] head(SPI) ## Plot Drawdowns - dd = drawdowns(LPP2005REC[, "SPI"], main = "Drawdowns") plot(dd) dd = drawdowns(LPP2005REC[, 1:6], main = "Drawdowns") plot(dd) ## Compute Drawdowns Statistics - ddStats <- drawdownsStats(SPI) class(ddStats) ddStats ## Note, Only Univariate Series are allowd - ddStats <- try(drawdownsStats(LPP2005REC)) class(ddStats) } \keyword{chron} timeSeries/man/fin-daily.Rd0000644000176000001440000001224711656243252015345 0ustar ripleyusers\name{SpecialDailySeries} \title{Special Daily Time Series} \alias{dummyDailySeries} \alias{dummySeries} \alias{alignDailySeries} \alias{rollDailySeries} \alias{ohlcDailyPlot} \description{ Special daily 'timeSeries' functions. \cr \tabular{ll}{ \code{dummyDailySeries} \tab Creates a dummy daily 'timeSeries' object, \cr \code{alignDailySeries} \tab Aligns a daily 'timeSeries' to new positions,\cr \code{rollDailySeries} \tab Rolls daily a 'timeSeries' on a given period, \cr \code{ohlcDailyPlot} \tab Plots open high low close bar chart, \cr \code{dummySeries} \tab Creates a dummy monthly 'timeSeries' object} } \usage{ dummyDailySeries(x = rnorm(365), units = NULL, zone = "", FinCenter = "") alignDailySeries(x, method = c("before", "after", "interp", "fillNA", "fmm", "periodic", "natural", "monoH.FC"), include.weekends = FALSE, units = NULL, zone = "", FinCenter = "", ...) rollDailySeries(x, period = "7d", FUN, \dots) ohlcDailyPlot(x, volume = TRUE, colOrder = c(1:5), units = 1e6, xlab = c("Date", "Date"), ylab = c("Price", "Volume"), main = c("O-H-L-C", "Volume"), grid.nx = 7, grid.lty = "solid", \dots) } \arguments{ \item{colOrder}{ [ohlcDailyPlot] - \cr an integer vector which gives the order of the prices and the volume in the input object. By default the following order of columns from 1 to 5 is assumed: Open, high, low, close, and volume. } \item{FinCenter}{ a character with the the location of the financial center named as "continent/city". } \item{FUN}{ the function to be applied.\cr [applySeries] - \cr a function to use for aggregation, by default \code{colAvgs}. } \item{grid.lty, grid.nx}{ [ohlcDailyPlot] - \cr The type of grid line and the number of grid lines used in the plot. } \item{include.weekends}{ [alignDailySeries] - \cr a logical value. Should weekend dates be included or removed from the series. } \item{main}{ [ohlcDailyPlot] - \cr a character string to title the price and volume plot. } \item{method}{ [alignDailySeries] - \cr the method to be used for the alignment. A character string, one of \code{"before"}, use the data from the row whose position is just before the unmatched position, or \code{"after"}, use the data from the row whose position is just after the unmatched position, or \code{"linear"}, interpolate linearly between \code{"before"} and \code{"after"}. } \item{period}{ [rollDailySeries] - \cr a character string specifying the rollling period composed by the length of the period and its unit, e.g. \code{"7d"} represents one week. } \item{units}{ [allignDailySeries] - \cr an optional character string, which allows to overwrite the current column names of a \code{timeSeries} object. By default \code{NULL} which means that the column names are selected automatically. \cr [ohlcDailyPlot] - \cr a numeric value, specifying in which multiples the volume should be referenced on the plot labels. By default 1e6, i.e. in units of 1 Million. } \item{volume}{ [ohlcDailyPlot] - \cr a logigical value. Should a volume plot added to the OHLC Plot. By default \code{TRUE}. } \item{x}{ an object of class \code{timeSeries}. } \item{xlab, ylab}{ [ohlcDailyPlot] - \cr two string vectors to name the x and y axis of the price and volume plot. } \item{zone}{ the time zone or financial center where the data were recorded. } \item{\dots}{ arguments passed to interpolating methods. } } \value{ \code{dummyDailySeries} \cr creates from a numeric matrix with daily records of unknown dates a \code{timeSeries} object with dummy daily dates. \cr \code{alignDailySeries} \cr returns from a daily time series with missing holidays a weekly aligned daily \code{timeSeries} object \cr \code{rollDailySeries}\cr \cr returns an object of class \code{timeSeries} with rolling values, computed from the function \code{FUN}. \cr \code{ohlcDailyPlot} displays a Open-High-Low-Close Plot of daily data records. } \examples{ ## Use Microsofts' OHLCV Price Series - head(MSFT) end(MSFT) ## Cut out April Data from 2001 - Close <- MSFT[, "Close"] tsApril01 <- window(Close, start="2001-04-01", end="2001-04-30") tsApril01 ## Align Daily Series with NA - tsRet <- returns(tsApril01, trim = TRUE) GoodFriday(2001) EasterMonday(2001) alignDailySeries(tsRet, method = "fillNA", include.weekends = FALSE) alignDailySeries(tsRet, method = "fillNA", include.weekends = TRUE) ## Align Daily Series by Interpolated Values - alignDailySeries(tsRet, method = "interp", include.weekend = FALSE) alignDailySeries(tsRet, method = "interp", include.weekend = TRUE) } \keyword{chron} timeSeries/man/fin-cumulated.Rd0000644000176000001440000000316411560011675016220 0ustar ripleyusers\name{cumulated} \title{Cumulated Time Series from Returns} \alias{cumulated} \alias{cumulated.default} \description{ Compute cumulated financial series, e.g. prices or indexes, from financial returns. } \usage{ cumulated(x, \dots) \method{cumulated}{default}(x, method = c("continuous", "discrete", "compound", "simple"), percentage = FALSE, \dots) } \arguments{ \item{method}{ a character string naming the method how the returns were computed. } \item{percentage}{ a logical value. By default \code{FALSE}, if \code{TRUE} the series will be expressed in percentage changes. } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments to be passed. } } \details{ Note, the function \code{cumulated} assumes as input discrete returns from a price or index series. Only then the cumulatrd series agrees with the original price or index series. The first values of the cumulated series cannot be computed, it is assumed that the series is indexed to 1. } \value{ returns a time series object of the same class as the input argument \code{x}. } \examples{ ## Use the Microsofts' Close Prices Indexed to 1 - MSFT.CL <- MSFT[, "Close"] MSFT.CL <- MSFT.CL/MSFT[[1, "Close"]] head(MSFT.CL) ## Compute Discrete Return - MSFT.RET <- returns(MSFT.CL, method = "discrete") ## Cumulative Series and Compare - MSFT.CUM <- cumulated(MSFT.RET, method = "discrete") head(cbind(MSFT.CL, MSFT.CUM)) } \keyword{chron} timeSeries/man/fin-align.Rd0000644000176000001440000000226211656243252015331 0ustar ripleyusers\name{align-methods} \docType{methods} \alias{align-methods} \alias{align,timeSeries-method} \title{timeSeries Class, Functions and Methods} \description{ Aligns a 'timeSeries' Object. } \usage{ \S4method{align}{timeSeries}(x, by = "1d", offset = "0s", method = c("before", "after", "interp", "fillNA", "fmm", "periodic", "natural", "monoH.FC"), include.weekends = FALSE, ...) } \arguments{ \item{x}{ an object of class \code{timeSeries}. } \item{by}{ a character string denoting the period } \item{offset}{ a character string denoting the offset } \item{method}{ a character string denoting the alignment approach. } \item{include.weekends}{ a logical flag, should weekend be included. } \item{\ldots}{ Further arguments to be passed to the interpolating function. } } \value{ returns an aligned S4 object of class \code{timeSeries}. } \examples{ ## Use MSFT and Compute Sample Size - dim(MSFT) ## Align the Series - MSFT.AL <- align(MSFT) ## Show the Size of the Aligned Series - dim(MSFT.AL) } \keyword{methods} \keyword{chron} timeSeries/man/data-examples.Rd0000644000176000001440000000140711560011675016206 0ustar ripleyusers\name{TimeSeriesData} \alias{TimeSeriesData} \alias{LPP2005REC} \alias{MSFT} \alias{USDCHF} \title{Time Series Data Sets} \description{ Three data sets used in example files. The data sets are: \tabular{ll}{ \code{LPP2005REC} \tab Swiss pension fund assets returns benchmark, \cr \code{MSFT} \tab Daily Microsoft OHLC prices and volume, \cr \code{USDCHF} \tab USD CHF intraday foreign exchange xchange rates.} } \examples{ ## Plot LPP2005 Example Data Set - data(LPP2005REC) plot(LPP2005REC, type = "l") ## Plot MSFT Example Data Set - data(MSFT) plot(MSFT[, 1:4], type = "l") plot(MSFT[, 5], type = "h") ## Plot USDCHF Example Data Set - plot(USDCHF, type = "l") } \keyword{datasets} timeSeries/man/base-t.Rd0000644000176000001440000000064311370220767014640 0ustar ripleyusers\name{t} \title{timeSeries Transpose} \alias{t,timeSeries-method} \description{ Returns the transpose of a timeSries object. } \usage{ \S4method{t}{timeSeries}(x) } \arguments{ \item{x}{ a timeSeries object. } } \value{ A matrix object. } \examples{ ## Dummy timeSeries with NAs entries data <- matrix(1:24, ncol = 2) s <- timeSeries(data, timeCalendar()) ## transpose t(s) } timeSeries/man/base-subsetting.Rd0000644000176000001440000000027011560011675016555 0ustar ripleyusers\name{extract} \title{extract} \description{ Description ... } timeSeries/man/base-subset.Rd0000644000176000001440000001230511370220767015700 0ustar ripleyusers\name{TimeSeriesSubsettings} \alias{TimeSeriesSubsettings} \alias{[,timeSeries,ANY,index_timeSeries-method} \alias{[,timeSeries,character,character-method} \alias{[,timeSeries,character,index_timeSeries-method} \alias{[,timeSeries,character,missing-method} \alias{[,timeSeries,index_timeSeries,character-method} \alias{[,timeSeries,index_timeSeries,index_timeSeries-method} \alias{[,timeSeries,index_timeSeries,missing-method} \alias{[,timeSeries,matrix,index_timeSeries-method} \alias{[,timeSeries,matrix,missing-method} \alias{[,timeSeries,missing,character-method} \alias{[,timeSeries,missing,index_timeSeries-method} \alias{[,timeSeries,missing,missing-method} \alias{[,timeSeries,timeDate,character-method} \alias{[,timeSeries,timeDate,index_timeSeries-method} \alias{[,timeSeries,timeDate,missing-method} \alias{[,timeSeries,timeSeries,index_timeSeries-method} \alias{[,timeSeries,timeSeries,missing-method} \alias{[,timeSeries,time_timeSeries,ANY-method} \alias{[,timeSeries,time_timeSeries,character-method} \alias{[,timeSeries,time_timeSeries,index_timeSeries-method} \alias{[,timeSeries,time_timeSeries,missing-method} \alias{$,timeSeries-method} \alias{[<-,timeSeries,timeDate,index_timeSeries-method} \alias{[<-,timeSeries,timeDate,missing-method} \alias{[<-,timeSeries,timeSeries,index_timeSeries-method} \alias{[<-,timeSeries,timeSeries,missing-method} \alias{[<-,timeSeries,character,character-method} \alias{[<-,timeSeries,character,index_timeSeries-method} \alias{[<-,timeSeries,character,missing-method} \alias{[<-,timeSeries,index_timeSeries,character-method} \alias{[<-,timeSeries,matrix,character-method} \alias{[<-,timeSeries,timeDate,character-method} \alias{[<-,timeSeries,timeSeries,character-method} \alias{[<-,timeSeries,character,ANY-method} \alias{[<-,timeSeries,timeDate,ANY-method} \alias{$<-,timeSeries,ANY-method} \alias{$<-,timeSeries,factor-method} \alias{$<-,timeSeries,numeric-method} \alias{$<-,timeSeries,ANY,ANY-method} \alias{$<-,timeSeries,ANY,factor-method} \alias{$<-,timeSeries,ANY,numeric-method} \alias{window,timeSeries-method} \alias{cut,timeSeries-method} \alias{head,timeSeries-method} \alias{tail,timeSeries-method} \alias{window.timeSeries} \alias{cut.timeSeries} \alias{head.timeSeries} \alias{tail.timeSeries} \alias{outlier} \alias{outlier,timeSeries-method} \alias{outlier,ANY-method} \title{Subsettig Time Series} \description{ Subset a 'timeSeries' objects due to different aspects. \cr \tabular{ll}{ \code{[} \tab "[" method for a 'timeSeries' object, \cr \code{[<-} \tab "[<-" method to assign value for a subset of a 'timeSeries' object, \cr \code{window} \tab Windows a piece from a 'timeSeries' object, \cr \code{cut} \tab A no longer used synonyme for window, \cr \code{head} \tab Returns the head of a 'timeSeries' object, \cr \code{tail} \tab Returns the tail of a 'timeSeries' object, \cr \code{outliers} \tab Removes outliers from a 'timeSeries' object. } } \usage{ % \method{[}{timeSeries}(x, i, j, drop) % \method{[}{timeSeries}(x, i, j) <- value \S4method{window}{timeSeries}(x, start, end, \dots) \S4method{head}{timeSeries}(x, n = 6, recordIDs = FALSE, \dots) \S4method{tail}{timeSeries}(x, n = 6, recordIDs = FALSE, \dots) \S4method{outlier}{timeSeries}(x, sd = 10, complement = TRUE, \dots) \S4method{cut}{timeSeries}(x, from, to, \dots) } \arguments{ \item{complement}{ [outlierSeries] - \cr a logical flag, should the outler series or its complement be returns, by default \code{TRUE} which returns the series free of outliers. } \item{from, to}{ starting date and end date, \code{to} must be after \code{from}. } \item{start, end}{ starting date and end date, \code{end} must be after \code{start}. } % \item{i, j}{ % ["["] - \cr % index arguments used for subsettings. % } \item{n}{ [head][tail] - \cr an integer specifying the number of lines to be returned. By default \code{n=6}. } \item{recordIDs}{ [head][tail] - \cr a logical value. Should the \code{recordIDs} returned together with the data matrix and time series positions? } \item{sd}{ [outlierSeries] - \cr a numeric value of standard deviations, e.g. 10 means that values larger or smaller tahn ten times the standard deviation will be removed from the series. } % \item{value}{ % a numeric value to use as a replacement. It will be repeated a % whole number of times if necessary. % } \item{x}{ an object of class \code{timeSeries}. } \item{\dots}{ arguments passed to other methods. } } \value{ all functions return an object of class \code{timeSeries}. } \examples{ ## Create an Artificial timeSeries Object - setRmetricsOptions(myFinCenter = "GMT") charvec = timeCalendar() set.seed(4711) data = matrix(exp(cumsum(rnorm(12, sd = 0.1)))) tS = timeSeries(data, charvec, units = "tS") tS ## Subset Series by Counts "[" - tS[1:3, ] ## Subset the Head of the Series - head(tS, 6) } \keyword{chron} timeSeries/man/base-start.Rd0000644000176000001440000000162511560011675015530 0ustar ripleyusers\name{start} \alias{start,timeSeries-method} \alias{start.timeSeries} \alias{end,timeSeries-method} \alias{end.timeSeries} \title{Start and End of a 'timeSeries'} \description{ Returns start and end time stamps of a 'timeSeries'. } \usage{ \S4method{start}{timeSeries}(x, \dots) \S4method{end}{timeSeries}(x, \dots) } \arguments{ \item{x}{ an uni- or multivariate \code{timeSeries} object. } \item{\dots}{ optional arguments passed to other methods. } } \value{ returns a \code{timeSeries} object. } \examples{ ## Create Dummy timeSeries - tS <- dummySeries() ## Return Start Time Stamp - start(tS) ## Return End Time Stamp - end(tS) } \keyword{chron} timeSeries/man/base-sort.Rd0000644000176000001440000000203611560011675015357 0ustar ripleyusers\name{sort} \alias{sort,timeSeries-method} \alias{sort.timeSeries} \title{Sorting a 'timeSeries' by Time Stamps} \description{ Sorts a 'timeSeries' according to increasing or decreasing order of the time stamps. } \usage{ \S4method{sort}{timeSeries}(x, decreasing = FALSE, \dots) } \arguments{ \item{x}{ an uni- or multivariate \code{timeSeries} object. } \item{decreasing}{ a logical flag. Should we sort in increasing or decreasing order? By default FALSE. } \item{\dots}{ optional arguments passed to other methods. } } \value{ returns a \code{timeSeries} object. } \examples{ ## Create Dummy timeSeries - tS <- dummySeries() ## Sort the Series in Decreasing Order - sort(tS, decreasing = TRUE) ## Sort the Series - sort(tS) } \keyword{chron} timeSeries/man/base-scale.Rd0000644000176000001440000000026411560011675015460 0ustar ripleyusers\name{scale} \title{scale} \description{ Description ... } timeSeries/man/base-sample.Rd0000644000176000001440000000026611560011675015654 0ustar ripleyusers\name{sample} \title{sample} \description{ Description ... } timeSeries/man/base-rev.Rd0000644000176000001440000000130611560011675015163 0ustar ripleyusers\name{rev} \alias{rev,timeSeries-method} \alias{rev.timeSeries} \title{Reversion of a 'timeSeries'} \description{ Reverses an uni- or multivariate 'timeSeries' object by reversing the order of the time stamps. } \usage{ \S4method{rev}{timeSeries}(x) } \arguments{ \item{x}{ an uni- or multivariate \code{timeSeries} object. } } \value{ returns a \code{timeSeries} object. } \examples{ ## Create Dummy timeSeries - tS <- dummySeries() ## Reverse Series - rev(tS) } \keyword{chron} timeSeries/man/base-rank.Rd0000644000176000001440000000153011370220767015324 0ustar ripleyusers\name{rank} \title{Sample Ranks of a Time Series} \alias{rank,timeSeries-method} \description{ Return the sample ranks of the values of a 'timeSeries' object. } % \usage{ % \S4method{rank}{timeSeries}(x, na.last = TRUE, ties.method = % c("average", "first", "random", "max", "min")) % } % \arguments{ % \item{x}{ % an univariate object of class \code{timeSeries}. % } % \item{\dots}{ % arguments to be passed to the default rank function . % } % } \value{ returns the ranks of a \code{timeSeries} object } \examples{ ## Load Microsoft Data - data(MSFT) X = 100 * returns(MSFT) ## Compute the Ranks - head(rank(X[, "Open"]), 10) ## Only Interested in the Vector, then use - head(rank(series(X[, "Open"])), 10) } \keyword{chron} timeSeries/man/base-merge.Rd0000644000176000001440000000026411560011675015470 0ustar ripleyusers\name{merge} \title{merge} \description{ Description ... } timeSeries/man/base-dim.Rd0000644000176000001440000000404011370220767015141 0ustar ripleyusers\name{dimnames} \title{Time Series Columns and Rows} \alias{dim,timeSeries-method} \alias{dim<-,timeSeries-method} \alias{dimnames,timeSeries-method} \alias{dimnames<-,timeSeries,list-method} \alias{colnames<-,timeSeries-method} \alias{colnames,timeSeries-method} \alias{rownames,timeSeries-method} \alias{rownames<-,timeSeries,timeDate-method} \alias{rownames<-,timeSeries,ANY-method} \alias{names,timeSeries-method} \alias{names<-,timeSeries-method} \description{ Functions and methods handling columns and rows of 'timeSeries' objects. \cr \tabular{ll}{ \code{dim} \tab Returns the dimension of a 'timeSeries' object, \cr \code{dimnames} \tab Returns the dimension names of a 'timeSeries' object, \cr \code{colnames<-} \tab Assigns column names to a 'timeSeries' object, \cr \code{rownames<-} \tab Assigns row names to a 'timeSeries' object, \cr % \code{is.array} \tab Allows that NCOL and NROW work properly. } } % \usage{ % %\S4method{dim}{timeSeries}(x) % %\S4method{dimnames}{timeSeries}(x) % %\S4method{dimnames}{timeSeries}(x) <- value % dim(x) % dimnames(x) % dimnames(x) <- value % colnames(x) % colnames(x) <- value % rownames(x) % rownames(x) <- value % \method{is.array}{timeSeries}(x) % } \arguments{ \item{value}{ a valid value for names component of \code{dimnames(x)}. % For a \code{"timeSeries"} object this is either \code{NULL} or a % character vector of length the column dimension. Not, row names % cannot be assigne for a \code{"timeSeries"} object, the function % \code{rownames()} will stop and return an error message. } \item{x}{ an object of class \code{timeSeries}. } } \value{ NA } \examples{ ## Load Swiss Pension Fund Benchmark Data - data(LPP2005REC) X = LPP2005REC[1:10, 1:3] ## Get Dimension - dim(X) ## Get Column and Row Names - dimnames(X) ## Get Column Names - colnames(X) ## Get Row Names - rownames(X) } \keyword{chron} timeSeries/man/base-diff.Rd0000644000176000001440000000026211560011675015277 0ustar ripleyusers\name{diff} \title{diff} \description{ Description ... } timeSeries/man/base-cbind.Rd0000644000176000001440000000374611370220767015463 0ustar ripleyusers\name{bind} \title{Bind two timeSeries objects} \alias{merge} \alias{cbind} \alias{rbind} \alias{cbind2} \alias{rbind2} % \alias{cbind,timeSeries-method} % \alias{rbind,timeSeries-method} \alias{cbind.timeSeries} \alias{rbind.timeSeries} % \alias{c.timeSeries} \alias{merge,ANY,timeSeries-method} \alias{merge,timeSeries,ANY-method} \alias{merge,timeSeries,missing-method} \alias{merge,timeSeries,numeric-method} \alias{merge,timeSeries,matrix-method} \alias{merge,timeSeries,timeSeries-method} \alias{merge,matrix,timeSeries-method} \alias{merge,numeric,timeSeries-method} \alias{merge.timeSeries} \alias{cbind2,ANY,timeSeries-method} \alias{cbind2,timeSeries,ANY-method} \alias{cbind2,timeSeries,missing-method} \alias{cbind2,timeSeries,timeSeries-method} \alias{rbind2,ANY,timeSeries-method} \alias{rbind2,timeSeries,ANY-method} \alias{rbind2,timeSeries,missing-method} \alias{rbind2,timeSeries,timeSeries-method} \description{ Binds two 'timeSeries' objects either by column or row. } % \usage{ % \S4method{merge}{timeSeries,timeSeries}(x, y, ...) % \S4method{cbind2}{timeSeries,timeSeries}(x, y) % \S4method{rbind2}{timeSeries,timeSeries}(x, y) % \S4method{cbind2}{timeSeries,timeSeries}(x, y) % } % \arguments{ % % \item{units}{ % % an optional character string, which allows to overwrite the % % current column names of a \code{timeSeries} object. By default % % \code{NULL} which means that the column names are selected % % automatically. % % } % \item{x, y}{ % two objects of class \code{timeSeries}. % } % % \item{\dots}{ % % arguments passed to returned timeSeries object. % % } % } \value{ returns a S4 object of class \code{timedate}. } \examples{ ## Load Microsoft Data Set - data(MSFT) x = MSFT[1:12, ] ## Bind Columnwise - X <- cbind(x[, "Open"], returns(x[, "Open"])) colnames(X) <- c("Open", "Return") X ## Bind Rowwise - Y <- rbind(x[1:3, "Open"], x[10:12, "Open"]) Y } \keyword{chron} timeSeries/man/base-attach.Rd0000644000176000001440000000346511370220767015646 0ustar ripleyusers\name{attach} \title{Attach a timSeries to the search path} \alias{attach} \alias{attach,timeSeries-method} \description{ Attach a 'timeSeries' object to the search path. \cr \tabular{ll}{ \code{attach} \tab attaches a 'timeSeries' object, \cr \code{detach} \tab detaches a 'timeSeries' object [see base package]. } } \usage{ \S4method{attach}{timeSeries}(what, pos = 2, name = deparse(substitute(what)), warn.conflicts = TRUE) } \note{ Preliminary, further work has to be done. } \arguments{ \item{name}{ [attach] - \cr alternative way to specify the database to be attached. See for details \code{help(attach,package=base)}. } \item{pos}{ [attach] - \cr an integer specifying position in \code{search()} where to attach the database. See for details \code{help(attach,package=base)}. } \item{warn.conflicts}{ [attach] - \cr a logical value. If \code{TRUE}, warnings are printed about conflicts from attaching the database, unless that database contains an object \code{.conflicts.OK}. A conflict is a function masking a function, or a non-function masking a non-function. See for details \code{help(attach,package=base)}. } \item{what}{ [attach] - \cr database to be attached. This may currently be a timeSeries object, a data.frame or a list or a R data file created with save or NULL or an environment. See for details \code{help(attach,package=base)}. } } \examples{ ## Load Microsoft Data Set - data(MSFT) x <- MSFT[1:10, ] ## Attach the Series and Compute the Range - attach(x) High - Low } \keyword{chron} timeSeries/man/base-apply.Rd0000644000176000001440000001120711370220767015520 0ustar ripleyusers\name{apply} \title{Apply Functions Over Time Series Periods} \alias{fapply} \alias{applySeries} \alias{apply,timeSeries-method} \description{ Apply a function over time series peridos of arbitrary positons and lengths. } \usage{ fapply(x, from, to, FUN, \dots) applySeries(x, from = NULL, to = NULL, by = c("monthly", "quarterly"), FUN = colMeans, units = NULL, format = x@format, zone = x@FinCenter, FinCenter = x@FinCenter, recordIDs = data.frame(), title = x@title, documentation = x@documentation, \dots) } \arguments{ \item{x}{ an object of class \code{timeSeries}. } \item{from, to}{ starting date and end date as timeDate objects. Note, \code{to} must be time ordered after \code{from}. If \code{from} and \code{to} are missing in function \code{fapply} they are set by default to \code{from=start(x)}, and \code{to=end(x)}. } \item{FUN}{ the function to be applied. For the function \code{applySeries} the default setting is \code{FUN=colMeans}. } \item{by}{ a character value either \code{"monthly"} or \code{"quarterly"} used in the function \code{applySeries}. The default value is \code{"monthly"}. Only operative when both arguments \code{from} and \code{to} have their default values \code{NULL}. In this case the function \code{FUN} will be applied to monthly or quarterly periods. } \item{units}{ an optional character string, which allows to overwrite the current column names of a \code{timeSeries} object. By default \code{NULL} which means that the column names are selected automatically. } \item{format}{ the format specification of the input character vector in POSIX notation. } \item{zone}{ the time zone or financial center where the data were recorded. } \item{FinCenter}{ a character value with the the location of the financial center named as "continent/city", or "city". } \item{recordIDs}{ a data frame which can be used for record identification information. Note, this is not yet handled by the apply functions, an empty data.frame will be returned. } \item{title}{ an optional title string, if not specified the inputs data name is deparsed. } \item{documentation}{ optional documentation string, or a vector of character strings. } \item{\dots}{ arguments passed to other methods. } } \details{ Like \code{apply} applies a function to the margins of an array, the function \code{fapply} applies a function to the time stamps or signal counts of a financial (therefore the "f" in front of the function name) time series of class \code{'timeSeries'}. The function \code{fapply} inputs a \code{timeSeries} object, and if \code{from} and \code{to} are missing, they take the start and end time stamps of the series as default falues. The function then behaves like \code{apply} on the column margin. Note, the function \code{fapply} can be used repetitive in the following sense: If \code{from} and \code{to} are two \code{timeDate} vectors of equal length then for each period spanned by the elelemts of the two vectors the function \code{FUN} will be applied to each period. The resulting time stamps, are the time stamps of the \code{to} vector. Note, the periods can be regular or irregelar, and they can even overlap. The function \code{fapply} calls the more general function \code{applySeries} which also offers, to create automatical monthly and quarterly periods. } \examples{ ## Percentual Returns of Swiss Bond Index and Performance Index - data(LPP2005REC) LPP = 100 * LPP2005REC[, c("SBI", "SPI")] head(LPP, 20) ## Aggregate Quarterly Returns - applySeries(LPP, by = "quarterly", FUN = colSums) ## Aggregate Quarterly every last Friday in Quarter - oneDay = 24*3600 from = unique(timeFirstDayInQuarter(time(LPP))) - oneDay from = timeLastNdayInMonth(from, nday = 5) to = unique(timeLastDayInQuarter(time(LPP))) to = timeLastNdayInMonth(to, nday = 5) data.frame(from = as.character(from), to = as.character(to)) applySeries(LPP, from, to, FUN = colSums) ## Alternative Use - fapply(LPP, from, to, FUN = colSums) ## Count Trading Days per Month - colCounts = function(x) rep(NROW(x), times = NCOL(x)) applySeries(LPP, FUN = colCounts, by = "monthly") } \keyword{chron} timeSeries/man/00timeSeries-package.Rd0000644000176000001440000001257011560011675017326 0ustar ripleyusers\name{timeSeries-package} \alias{timeSeries-package} \docType{package} \title{Utilities and Tools Package} \description{ Package of time series tools and utilities. } \details{ \tabular{ll}{ Package: \tab timeSeries\cr Type: \tab Package\cr Version: \tab see description file\cr Date: \tab 2011\cr License: \tab GPL Version 2 or later\cr Copyright: \tab (c) 1999-2011 Rmetrics Association\cr URL: \tab \url{http://www.rmetrics.org} } } \section{timeSeries - S4 timeSeries Class}{ List of Functions: \tabular{ll}{ \code{timeSeries} \tab Creates a 'timeSeries' from scratuch, \cr \code{description} \tab ..., \cr \code{finCenter} \tab ..., \cr \code{getDataPart} \tab ..., \cr \code{isReguar} \tab ..., \cr \code{isUnivariate} \tab ..., \cr \code{series} \tab ... . } } \section{methods - Time Series Methods}{ List of Functions: \tabular{ll}{ \code{as} \tab ..., \cr \code{base} \tab ..., \cr \code{comment} \tab ..., \cr \code{is} \tab ..., \cr \code{mathOps} \tab ..., \cr \code{plot} \tab ..., \cr \code{show} \tab ..., \cr \code{stats} \tab ... . } mathOps - List of Functions: \tabular{ll}{ \code{Ops.timeSeries} \tab S3: Arith method for a 'timeSeries' object, \cr \code{abs} \tab Returns absolute values of a 'timeSeries' object, \cr \code{sqrt} \tab Returns square root of a 'timeSeries' object, \cr \code{exp} \tab Returns the exponential values of a 'timeSeries' object, \cr \code{log} \tab Returns the logarithm of a 'timeSeries' object, \cr \code{sign} \tab Returns the signs of a 'timeSeries' object, \cr \code{diff} \tab Differences a 'timeSeries' object, \cr \code{scale} \tab Centers and/or scales a 'timeSeries' object, \cr \code{quantile} \tab Returns quantiles of an univariate 'timeSeries'. } na.omit - List of Functions: \tabular{ll}{ \code{na.omit} \tab Handles NAs in a timeSeries object, \cr \code{removeNA} \tab removes NAs from a matrix object, \cr \code{substituteNA} \tab substitutes NAs by zero, the column mean or median, \cr \code{interpNA} \tab interpolates NAs using R's "approx" function. } } \section{base - Basic Time Series Functions}{ List of Functions: \tabular{ll}{ \code{apply} \tab ..., \cr \code{attach} \tab ..., \cr \code{cbind} \tab ..., \cr \code{diff} \tab ..., \cr \code{dim} \tab ..., \cr \code{extract} \tab ..., \cr \code{merge} \tab ..., \cr \code{rank} \tab ..., \cr \code{rev} \tab ..., \cr \code{sample} \tab ..., \cr \code{scale} \tab ..., \cr \code{sort} \tab ..., \cr \code{start} \tab ..., \cr \code{subset} \tab ..., \cr \code{t} \tab ..., \cr \code{colCumsums} \tab ..., \cr \code{colSums} \tab ..., \cr \code{rowCumsums} \tab ... . } } \section{fin - Financial Time Series Functions}{ List of Functions: \tabular{ll}{ \code{align} ...,\cr \code{cumulated} \tab compute cumulated series from a returns, \cr \code{daily} ..., \cr \code{drawdowns} \tab compute series of drawdowns from financial returns,\cr \code{durations} \tab compute durations from a financial time series,\cr \code{miquotes} \tab compute mid quotes from a price/index stream,\cr \code{periodicals} ..., \cr \code{returns} \tab Compute returns from prices or indexes, \cr \code{runlengths} ..., \cr \code{smooth} ..., \cr \code{splits} ..., \cr \code{spreads} \tab compute spreads from a price/index stream, \cr \code{turns} ... , \cr \code{orderColnames} ..., \cr \code{orderStatistics} ..., \cr \code{rollMean} ..., \cr } } \section{more ...}{ Daily and Monthly - List of Functions: \tabular{ll}{ \code{dummyDailySeries} \tab Creates a dummy daily 'timeSeries' object, \cr \code{alignDailySeries} \tab Aligns a daily 'timeSeries' to new positions,\cr \code{rollDailySeries} \tab Rolls daily a 'timeSeries' on a given period, \cr \code{ohlcDailyPlot} \tab Plots open high low close bar chart, \cr \code{countMonthlyRecords} \tab Returns a series with monthly counts of records, \cr \code{isMonthly} \tab Decides if the series consists of monthly records, \cr \code{rollMonthlyWindows} \tab Returns start and end dates for rolling time windows, \cr \code{rollMonthlySeries} \tab Rolls monthly a 'timeSeries' on a given period. } Column/Row Statistics - List of Functions: \tabular{ll}{ \code{colStats} \tab ..., \cr \code{rowStats} \tab ... . } Coercion of timeSeries Objects - List of Functions: \tabular{ll}{ \code{as}\cr \code{is.timeSeries} \tab ..., \cr \code{as.timeSeries} ..., \cr \code{as.timeSeries.default} ..., \cr \code{as.timeSeries.numeric} ..., \cr \code{as.timeSeries.data.frame} ..., \cr \code{as.timeSeries.matrix} ..., \cr \code{as.timeSeries.ts} ..., \cr \code{as.timeSeries.character} ..., \cr \code{as.timeSeries.zoo} ..., \cr \code{as.vector.timeSeries} ..., \cr \code{as.matrix.timeSeries} ..., \cr \code{as.data.frame.timeSeries} ..., \cr \code{as.ts.timeSeries} ... . } } \keyword{package} timeSeries/inst/0000755000176000001440000000000011731573515013400 5ustar ripleyuserstimeSeries/inst/unitTests/0000755000176000001440000000000011731573516015403 5ustar ripleyuserstimeSeries/inst/unitTests/runit.timeSeries.R0000644000176000001440000000327611370220767021003 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.signalSeries.Internal <- function() { # RUnit Test: x = rnorm(12) y = rnorm(12) timeSeries:::.signalSeries(as.matrix(x), 1:12) timeSeries:::.signalSeries(as.matrix(cbind(x,y)), 1:12) } # ------------------------------------------------------------------------------ test.timeSeries.Internal <- function() { # this is to test the problem when a ts object is passed to # timeSeries. It seems that as.matrix does not convert the object # to a matrix !!! z <- ts(matrix(rnorm(300), 100, 3), start=c(1961, 1), frequency=12) # class(as.matrix(z)) #<< mts ts and not matrix in R 2.9.0 # Note that is is possible that a ts object is considered as a # matrix when timeSeries method as dispatched. Hence this check t <- timeSeries(z) checkTrue(identical(as(z, "matrix"), as(t, "matrix"))) } ################################################################################ timeSeries/inst/unitTests/runit.time.R0000644000176000001440000000162611370220767017625 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.time <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.subset.R0000644000176000001440000001243111370220767020170 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.subset <- function() { ts <- dummySeries() mat <- as.matrix(ts) # we want the same subset-ting rules as for a matrix # but we always print result in vertical style ! # -------------------------------------------------------------------------- # index checkIdentical( ts[], ts) checkTrue(suppressWarnings(is.na(ts[""]))) checkTrue(is.na(mat[""])) checkIdentical( as.matrix(ts[seq(4),2]), mat[seq(4),2,drop=FALSE]) checkIdentical( as.matrix(ts[rep(FALSE, 3), 1]), mat[rep(FALSE, 3), 1,drop=FALSE]) checkIdentical( as.matrix(ts[FALSE, 1]), mat[FALSE, 1, drop = FALSE]) checkIdentical( as.matrix(ts[rep(TRUE), 2]), mat[rep(TRUE), 2, drop=FALSE]) charvec <- as.character(timeCalendar()[1:3]) checkIdentical( as.matrix(ts[charvec, 1]), mat[charvec, 1, drop = FALSE]) checkIdentical( as.matrix(ts[seq(4),]), mat[seq(4),,drop=FALSE]) checkIdentical( as.matrix(ts[rep(FALSE, 3), ]), mat[rep(FALSE, 3), ,drop=FALSE]) checkIdentical( as.matrix(ts[FALSE, ]), mat[FALSE, ,drop=FALSE]) checkIdentical( as.matrix(ts[rep(TRUE), ]), mat[rep(TRUE), ,drop=FALSE ]) dd <- as.character(time(ts)[1]) checkIdentical( as.matrix(ts[dd, ]), mat[dd, ,drop=FALSE]) checkIdentical( as.matrix(ts[,2]), mat[,2,drop=FALSE]) checkIdentical( as.matrix(ts[2,FALSE]), mat[2,FALSE, drop=FALSE]) # prefer to have an empty timeSeries instead of empty data with row names checkIdentical( as.matrix(ts[,FALSE]), mat[,FALSE, drop = FALSE]) checkIdentical( as.matrix(ts[,TRUE ]), mat[,TRUE ,drop=FALSE]) checkIdentical( as.matrix(ts[, "TS.1"]), mat[, "TS.1", drop = FALSE]) # -------------------------------------------------------------------------- # timeDate checkIdentical( ts[timeCalendar()[1:5], 2], ts[1:5,2]) checkIdentical( ts[timeCalendar()[1:5], ], ts[1:5,]) # -------------------------------------------------------------------------- # logical matrix and timeSeries i <- ts < 0.4 checkException(ts[series(i), ], silent = TRUE) checkException(ts[i, ], silent = TRUE) checkException(mat[series(i), ], silent = TRUE) # it fails as expected checkIdentical( as.matrix(ts[series(i)[,1], ]), mat[series(i)[,1], , drop=FALSE]) checkIdentical( as.matrix(ts[i[,1], ]), mat[series(i)[,1], , drop=FALSE]) checkIdentical( as.matrix(ts[series(i)[,1],1]), mat[series(i)[,1],1,drop=FALSE]) checkIdentical( as.matrix(ts[i[,1],1]), mat[series(i)[,1],1,drop=FALSE]) # this should fail checkException(ts[series(i), 2], silent = TRUE) checkException(ts[i, 2], silent = TRUE) checkException(ts[series(i), 1], silent = TRUE) checkException(ts[series(i),1], silent = TRUE) checkException(ts[i,1], silent = TRUE) checkException(mat[series(i),1], silent = TRUE) checkException(ts[series(i),], silent = TRUE) checkException(mat[series(i),], silent = TRUE) checkIdentical( ts[series(i)], mat[series(i)]) checkIdentical( ts[i], mat[series(i)]) # -------------------------------------------------------------------------- # $,timeSeries method df <- as.data.frame(ts) checkIdentical( ts$TS., df$TS.) checkIdentical( ts$TS.1, df$TS.1) checkIdentical( ts$a, df$a) colnames(ts) <- c("aa", "bb") colnames(df) <- c("aa", "bb") checkIdentical( ts$a, df$a) checkIdentical( ts$b, df$b) } ################################################################################ timeSeries/inst/unitTests/runit.spreads.R0000644000176000001440000000177611370220767020336 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.spreads <- function() { # RUnit Test: tS = dummySeries(units = c("Bid", "Ask")) head(tS) midquotes(tS) spreads(tS) } ################################################################################ timeSeries/inst/unitTests/runit.signalCounts.R0000644000176000001440000000255711370220767021344 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.signalCounts <- function() { # RUnit Test: int = c(1, 10, 100, 21, 135) print(timeSeries:::.signalCounts(sample(int))) nc = timeSeries:::.signalCounts(int) nc ns = sample(nc) ns sorted = sort(ns) sorted as.integer(sorted) ns ordered = order(ns) ordered ns[ordered] as.integer(ns[ordered]) timeSeries:::.signalCounts(1:12) timeSeries:::.signalCounts(sample(1:12)) timeSeries:::.signalCounts(timeSeries:::.signalCounts(1:12)) } ################################################################################ timeSeries/inst/unitTests/runit.rowCum.R0000644000176000001440000000163011370220767020136 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.rowCum <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.returns.R0000644000176000001440000000163111370220767020365 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.returns <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.rank.R0000644000176000001440000000162611370220767017622 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.rank <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.periodical.R0000644000176000001440000000163411370220767021001 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.periodical <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.order.R0000644000176000001440000000266211370220767020003 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.order <- function() { # RUnit Test: tS = timeSeries(matrix(rnorm(500), 100), units = sample(LETTERS[1:5])) head(tS) colnames(tS) sortColnames(tS) sampleColnames(tS) orderColnames(tS) statsColnames(tS, FUN = colMeans) pcaColnames(tS) hclustColnames(tS) tS = timeSeries(matrix(rnorm(500), 100), units = sample(LETTERS[1:5]), format = "counts") head(tS) colnames(tS) sortColnames(tS) sampleColnames(tS) orderColnames(tS) statsColnames(tS, FUN = colMeans) pcaColnames(tS) hclustColnames(tS) } ################################################################################ timeSeries/inst/unitTests/runit.na.contiguous.R0000644000176000001440000000245211370220767021461 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.na.contiguous = function() { ## Dummy timeSeries with NAs entries data1 <- matrix(c(NA, 1), ncol = 2) data2 <- matrix(rep(2, 4), ncol = 2) data3 <- matrix(c(NA, 3), ncol = 2) data4 <- matrix(rep(4, 4), ncol = 2) data <- rbind(data1, data2, data3, data4) ts <- timeSeries(data, timeCalendar()[1:6]) ## Find the longest consecutive non-missing values ans <- na.contiguous(ts) check <- getDataPart(ans) dimnames(check) <- NULL checkIdentical(data2, getDataPart(check)) } timeSeries/inst/unitTests/runit.monthly.R0000644000176000001440000000163111370220767020355 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.monthly <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.model.frame.R0000644000176000001440000000163511370220767021060 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.model.frame <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.methods-summary.R0000644000176000001440000000163111370220767022021 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.summary <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.methods-print.R0000644000176000001440000000162711370220767021465 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.print <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.methods-plot.R0000644000176000001440000000162611370220767021306 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.plot <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.merge.R0000644000176000001440000000316011656243252017762 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.merge.timeSeries = function() { # RUnit Test: # Time Stamps: x = timeSeries()[,1] x y = timeSeries() y merge(x, y) # Signal Counts: x = timeSeries(format = "counts")[,1] x y = timeSeries(format = "counts") y merge(x, y) x <- dummySeries()[,1] x y <- dummySeries() y merge(x, y) # check that merge method can deal with timeSeries that have # colnames that are invalid data.frame colnames. For example # "S[-1]". data <- matrix(runif(18), ncol = 3) charvec <- rev(paste("2009-0", 1:6, "-01", sep = "")) S <- timeSeries(data, charvec) colnames(S) <- paste("S", 1:3, sep = ".") ts <- merge(S[,2], lag(S[,1], -1:1)) checkIdentical(dim(ts), c(6L,4L)) } ################################################################################ timeSeries/inst/unitTests/runit.mathOps.R0000644000176000001440000000213511370220767020276 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.mathOps <- function() { # RUnit Test: tS = dummySeries(format = "counts") tS tS - 2 log(abs(tS)) diff(tS) scale(tS) tS = dummySeries() tS tS - 2 log(abs(tS)) diff(tS) scale(tS) } ################################################################################ timeSeries/inst/unitTests/runit.lag.R0000644000176000001440000000303411656243252017426 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.lag <- function() { # RUnit Test: tS = round(dummySeries(flormat = "counts"), 3)[, 1] tS lag(tS) lag(tS, k = -2:2) lag(tS, k = -2:2, trim = TRUE) tS = round(dummySeries(), 3)[, 1] tS lag(tS) lag(tS, k = -2:2) lag(tS, k = -2:2, trim = TRUE) # check colnames when using multiple lag indexes. data <- matrix(runif(12), ncol = 2) charvec <- rev(paste("2009-0", 1:6, "-01", sep = "")) S <- timeSeries(data, charvec) colnames(S) <- paste("S", 1:2, sep = ".") ts <- lag(S, -1:1) checkIdentical(colnames(ts), c("S.1[-1]", "S.1[0]", "S.1[1]", "S.2[-1]", "S.2[0]", "S.2[1]")) } ################################################################################ timeSeries/inst/unitTests/runit.durations.R0000644000176000001440000000233711370220767020677 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.durations <- function() { # RUnit Test: # Signal Series: tS = sort(sample(dummySeries())[1:6, ]) tS durations(tS) durations(tS, trim = TRUE) durations(tS, trim = TRUE)/(24*3600) # Time Series: tS = sort(sample(dummySeries(format = "counts"))[1:6, ]) tS # BUG !!! # durations(tS) # durations(tS, trim = TRUE) } ################################################################################ timeSeries/inst/unitTests/runit.drawdowns.R0000644000176000001440000000234611370220767020677 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.drawdowns <- function() { # RUnit Test: tS = timeSeries( data = matrix(rnorm(200, sd = 1e-3), 100), charvec = format(timeSequence(length.out = 100)) ) tS drawdowns(tS) tS = timeSeries( data = matrix(rnorm(200, sd = 1e-3), 100), charvec = 1:100, format = "counts" ) tS drawdowns(tS) } ################################################################################ timeSeries/inst/unitTests/runit.dim.R0000644000176000001440000000344511370220767017441 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.dim.timeSeries = function() { # RUnit Test: # Univariate Case: tS = timeSeries(format = "counts")[, 1] dim(tS) NCOL(tS) NROW(tS) ncol(tS) nrow(tS) dimnames(tS) colnames(tS) rownames(tS) # colnames<- # rownames<- is.array(tS) # Multivariate Case: tS = timeSeries(format = "counts") dim(tS) NCOL(tS) NROW(tS) ncol(tS) nrow(tS) dimnames(tS) colnames(tS) rownames(tS) # colnames<- # rownames<- is.array(tS) # Univariate Case: tS = timeSeries()[, 1] dim(tS) NCOL(tS) NROW(tS) ncol(tS) nrow(tS) dimnames(tS) colnames(tS) rownames(tS) # colnames<- # rownames<- is.array(tS) # Multivariate Case: tS = timeSeries() dim(tS) NCOL(tS) NROW(tS) ncol(tS) nrow(tS) dimnames(tS) colnames(tS) rownames(tS) # colnames<- # rownames<- is.array(tS) } ################################################################################ timeSeries/inst/unitTests/runit.daily.R0000644000176000001440000000162711370220767017772 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.daily <- function() { NA } ################################################################################ timeSeries/inst/unitTests/runit.cumulated.R0000644000176000001440000000211511370220767020644 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.cumulated = function() { # RUnit Test: # Signal Series: tS = dummySeries(format = "counts") # problem with Fincenter cumulated(tS) # timeDate Series: tS = dummySeries() cumulated(tS) } ################################################################################ timeSeries/inst/unitTests/runit.cor.R0000644000176000001440000000211711370220767017446 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.cor.timeSeries = function() { # RUnit Test: # Signal Series tS = dummySeries(format = "counts") tS cor(tS) cov(tS) # timeDate Series: tS = dummySeries() tS cor(tS) cov(tS) } ################################################################################ timeSeries/inst/unitTests/runit.colStats.R0000644000176000001440000000264311370220767020463 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.colStats = function() { # RUnit Test: # Signal Series: tS = dummySeries(format = "counts") tS colStats(tS, mean) colSums(tS) colMeans(tS) colSds(tS) colVars(tS) colSkewness(tS) colKurtosis(tS) colMaxs(tS) colMins(tS) colProds(tS) colQuantiles(tS) # timDate Series: tS = dummySeries() tS colStats(tS, mean) colSums(tS) colMeans(tS) colSds(tS) colVars(tS) colSkewness(tS) colKurtosis(tS) colMaxs(tS) colMins(tS) colProds(tS) colQuantiles(tS) } ################################################################################ timeSeries/inst/unitTests/runit.colCum.R0000644000176000001440000000333211370220767020105 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.colCum <- function() { # RUnit Test: # Signal Series ts <- dummySeries(format = "counts") colCumsums(ts) colCummaxs(ts) colCummins(ts) colCumprods(ts) colCumreturns(ts) # Time Series: ts <- dummySeries() colCumsums(ts) colCummaxs(ts) colCummins(ts) colCumprods(ts) colCumreturns(ts) # check that timeSeries with one row still works ... t <- ts[1,] checkTrue(is(colCumsums(t), "timeSeries")) checkTrue(is(colCummaxs(t), "timeSeries")) checkTrue(is(colCummins(t), "timeSeries")) checkTrue(is(colCumprods(t), "timeSeries")) checkTrue(is(colCumreturns(t), "timeSeries")) checkEquals(nrow(colCumsums(t)), 1) checkEquals(nrow(colCummaxs(t)), 1) checkEquals(nrow(colCummins(t)), 1) checkEquals(nrow(colCumprods(t)), 1) checkEquals(nrow(colCumreturns(t)), 1) } ################################################################################ timeSeries/inst/unitTests/runit.bind.R0000644000176000001440000000451711433442120017572 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.bind <- function() { ts <- dummySeries() ts@documentation <- character(0) # -------------------------------------------------------------------------- # if NULL are in args, result identical except @documentation cts <- cbind(ts, NULL) rts <- rbind(ts, NULL) checkTrue(!identical(slot(cts, "documentation"), ts@documentation)) checkTrue(!identical(slot(rts, "documentation"), ts@documentation)) # check that the rest is identical cts@documentation <- character(0) rts@documentation <- character(0) checkIdentical(cts, ts) checkIdentical(rts, ts) # -------------------------------------------------------------------------- ts1 <- ts[seq(1, nrow(ts), by = 2),] ts0 <- ts[seq(2, nrow(ts), by = 2),] # test rbind checkTrue(all(time(rbind(ts1, ts0)) == c(time(ts1),time(ts0)))) # test cbind checkIdentical(as.vector(is.na(cbind(ts1, ts0))), c(rep(c(FALSE, TRUE), 12), rep(c(TRUE, FALSE), 12))) checkTrue(all(time(cbind(ts1, ts0)) == time(ts))) # -------------------------------------------------------------------------- # issues with single number element a <- timeSeries(1, as.Date(0, origin="2010-01-01") ) b <- timeSeries( 2:3, as.Date(1:2, origin="2010-01-01") ) d <- timeSeries( 2:10, as.Date(1:9, origin="2010-01-01") ) cbind(a, b) cbind(b, a) cbind(b, d) cbind(d, b) cbind(a, 1) cbind(b, 1) cbind(a, matrix(1)) cbind(b, matrix(1)) } ################################################################################ timeSeries/inst/unitTests/runit.attach.R0000644000176000001440000000200211370220767020120 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.attach.timeSeries = function() { # RUnit Test: # Attach Signal Series tS = timeSeries() attach(tS) SS.1 detach(tS) } ################################################################################ timeSeries/inst/unitTests/runit.as.R0000644000176000001440000000252211370220767017266 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.as <- function() { # RUnit Test: # Note, you can also use ... is(timeSeries(), "timeSeries") # Series ts = dummySeries() x = timeSeries:::.signalSeries(as.matrix(ts)) y = timeSeries:::.timeSeries(as.matrix(ts), as.numeric(time(ts), "sec")) # A vector to a timeSeries as.vector(x) as.vector(x[,1]) as.vector(y) as.vector(y[,1]) # as.numeric: as.numeric(x) as.numeric(x[,1]) as.numeric(y) as.numeric(y[,1]) } ################################################################################ timeSeries/inst/unitTests/runit.apply.R0000644000176000001440000000243411370220767020012 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.apply <- function() { x = timeSeries(rnorm(90), timeSequence(length.out = 90)) fapply applySeries <- function(x, from = NULL, to = NULL, by = c("monthly", "quarterly"), FUN = colMeans, units = NULL, format = x@format, zone = x@FinCenter, FinCenter = x@FinCenter, recordIDs = data.frame(), title = x@title, documentation = x@documentation, ...) applySeries(x, from = start(x), to = end(x)) } ################################################################################ timeSeries/inst/unitTests/runit.align.R0000644000176000001440000000254711370220767017764 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.align.timeSeries <- function() { # RUnit Test: # .align.timeSeries(x, method = c("before", "after", "interp"), # startOn = "hours", by = "30 m") set.seed(1953) tD = timeCalendar( y = rep(2008, times = 6), m = rep(4, times = 6), d = rep(10:11, each = 3), h = sample(1:23)[1:6], min = sample(1:59)[1:6], s = sample(1:59)[1:6]) tS = timeSeries(rnorm(6), tD) align(tS) align(tS, method="interp") # Note, we should als add an argument to trim NAs } ################################################################################ timeSeries/inst/unitTests/runit.aggregate.R0000644000176000001440000000447411370220767020621 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.aggregate.timeSeries <- function() { # RUnit Test: # aggregate.timeSeries(x, by = c("monthly", "quarterly"), FUN = colMeans, # units = NULL, ...) # A daily Series: charvec <- timeSequence(length.out = 365) x <- timeSeries(rnorm(365), charvec) # Aggregate Returns Monthly: by <- unique(timeFirstDayInMonth(charvec)) aggregate(x, by, sum, units = "MonthReturns") # Count Monthly Records: aggregate(sign(abs(x)), end(charvec), sum, units = "NoOfRecords") # Aggregate Returns Quarterly: by <- unique(timeLastDayInQuarter(charvec)) aggregate(x, by, sum, units = "QrtReturns") # Another example x <- as.timeSeries(data(LPP2005REC))[,1:4] by <- timeSequence(from = "2006-01-01", to = "2008-01-01", by = "quarter") aggregate(x, by, mean) x <- timeSeries(seq(12), timeCalendar()) # relative from and to to make test work for future years ... from <- timeCalendar(y=getRmetricsOptions("currentYear") - 1, m=1, d=1) to <- timeCalendar(y=getRmetricsOptions("currentYear") + 1, m=1, d=1) by <- timeSequence( from = from, to = to, by = "quarter") x a <- aggregate(x, by, sum) a ### DW here are mismatches - corrected above ... checkEquals(sum(x[1]), a[1]) checkEquals(sum(x[2:4]), a[2]) checkEquals(sum(x[5:7]), a[3]) checkEquals(sum(x[8:10]), a[4]) checkEquals(sum(x[11:12]), a[5]) } ################################################################################ timeSeries/inst/unitTests/runit.TimeSeriesPositions.R0000644000176000001440000000513211370220767022644 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.time = function() { # Generate nivariate daily random sequence set.seed(4711) data = round(rnorm(12), 2) charvec = timeCalendar(2006) uTS = timeSeries(data, charvec, units = "uTS") uTS # Get Positions: POS = time(uTS) POS checkIdentical(charvec, POS) # Return Value: return() } # ------------------------------------------------------------------------------ "test.time<-" = function() { # Generate nivariate daily random sequence set.seed(4711) data = round(rnorm(12), 2) charvec = timeCalendar(2006) uTS = timeSeries(data, charvec, units = "uTS") uTS # Add one Day to Positions: POS = time(uTS) time(uTS) <- POS + 24*3600 uTS # Return Value: return() } # ------------------------------------------------------------------------------ test.timeSeriesOrdering = function() { # sample.timeSeries - Resamples a 'timeSeries' object in time # sort.timeSeries - Sorts reverts a 'timeSeries' object in time # rev.timeSeries - Reverts a 'timeSeries' object in time # start.timeSeries - Extracts start date of a 'timeSeries' object # end.timeSeries - Extracts end date of a 'timeSeries' object # Generate univariate monthly random sequence: set.seed(4711) data = cbind(1:12, round(rnorm(12), 2)) positions = timeCalendar(2006) uTS = timeSeries(data, positions) uTS # Sample/Sort: target = uTS target # current = sort(sample(uTS)) # current # checkIdentical(target, current) # Revert: target = uTS target current = rev(rev(uTS)) current checkTrue(!sum(target - current)) # Start/End date of Series: start(uTS) end(uTS) # Return Value: return() } ################################################################################ timeSeries/inst/unitTests/runit.TimeSeriesData.R0000644000176000001440000002416511656243252021536 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.diffTimeSeries = function() { # diff.timeSeries - Differences a 'timeSeries' object # Univariate Series: # Multivariate Data Set: set.seed(4711) data = cbind(RNORM = round(rnorm(6), 2)) charvec = timeCalendar()[1:6] recordIDs = data.frame(IDs = LETTERS[1:6]) uTS = timeSeries(data, charvec, recordIDs = recordIDs) uTS uTS@recordIDs # Differencing over 1 lag X = diff(x = uTS, lag = 1, diff = 1, trim = FALSE, pad = NA) X X@recordIDs # X = diff(x = uTS, lag = 1, diff = 1, trim = TRUE, pad = NA) # X # X@recordIDs X = diff(x = uTS, lag = 1, diff = 1, trim = FALSE, pad = 0) X X@recordIDs # Differencing over 2 lags X = diff(x = uTS, lag = 2, diff = 1, trim = FALSE, pad = NA) X X@recordIDs # X = diff(x = uTS, lag = 2, diff = 1, trim = TRUE, pad = NA) # X # X@recordIDs X = diff(x = uTS, lag = 2, diff = 1, trim = FALSE, pad = 0) X X@recordIDs # Differencing twice: # X = diff(x = uTS, lag = 1, diff = 2, trim = FALSE, pad = NA) #ERROR # X # X@recordIDs # X = diff(x = uTS, lag = 2, diff = 2, trim = FALSE, pad = NA) # ERROR # X # X@recordIDs # X = diff(x = uTS, lag = 1, diff = 2, trim = TRUE, pad = NA) # X # X@recordIDs # X = diff(x = uTS, lag = 2, diff = 2, trim = TRUE, pad = NA) # X # X@recordIDs # Return Value: return() } # ------------------------------------------------------------------------------ test.lagTimeSeries = function() { # lag.timeSeries - Lags a 'timeSeries' object # Univariate Series: set.seed(4711) data = cbind(RNORM = round(rnorm(6), 2)) charvec = timeCalendar()[1:6] recordIDs = data.frame(IDs = LETTERS[1:6]) uTS = timeSeries(data, charvec, recordIDs = recordIDs) # Multivariate Data Set: set.seed(4711) data = cbind(round(rnorm(12), 2), round(rt(12, df = 4), 2) ) charvec = format(timeCalendar(2006)) mTS = timeSeries(data, charvec, units = c("RNORM", "RT")) mTS # Time Series Lags: X = lag(x = uTS, k = 1, trim = FALSE, units = NULL) X X@recordIDs X = lag(x = uTS, k = c(2,4), trim = FALSE, units = NULL) X X@recordIDs X = lag(x = uTS, k = c(2,4), trim = TRUE, units = NULL) X X@recordIDs X = lag(x = uTS, k = -1:1, trim = FALSE, units = LETTERS[1:3]) X X@recordIDs # Multivariaye Series: diff(mTS, 1, 1) lag(mTS, 1) # Return Value: return() } # ------------------------------------------------------------------------------ test.mergeTimeSeries = function() { # merge.timeSeries - Merges two 'timeSeries' objects # scale.timeSeries - Centers and/or scales a 'timeSeries' object # summary.timeSeries - Summarizes a 'timeDate' object # var.timeSeries - Returns variance for a 'timeSeries' object # Univariate Series: set.seed(4711) data = cbind(RNORM = round(rnorm(6), 2)) charvec = timeCalendar()[1:6] recordIDs = data.frame(IDs = LETTERS[1:6]) uTS = timeSeries(data, charvec, recordIDs = recordIDs) # Merge: X = uTS Y = log(abs(uTS)) merge(x = X, y = Y, units = "One column") colnames(Y) <- "log" merge(x = X, y = Y, units = c("RN", "logAbsRN")) merge(x = X[-6,], y = Y[-3,], units = c("RN", "logAbsRN")) merge(x = X[2:5,], y = Y[4:6,], units = c("RN", "logAbsRN")) # Return Value: return() } # ------------------------------------------------------------------------------ test.scaleTimeSeries = function() { # scale.timeSeries - Centers and/or scales a 'timeSeries' object # Univariate Series: set.seed(4711) data = cbind(RNORM = round(rnorm(6), 2)) charvec = timeCalendar()[1:6] recordIDs = data.frame(IDs = LETTERS[1:6]) uTS = timeSeries(data, charvec, recordIDs = recordIDs) # Multivariate Data Set: set.seed(4711) data = cbind(round(rnorm(12), 2), round(rt(12, df = 4), 2) ) charvec = format(timeCalendar(2006)) mTS = timeSeries(data, charvec, units = c("RNORM", "RT")) # Scale: scale(uTS) scale(mTS) # Return Value: return() } # ------------------------------------------------------------------------------ test.summaryTimeSeries = function() { # summary.timeSeries - Summarizes a 'timeDate' object # Univariate Series: set.seed(4711) data = cbind(RNORM = round(rnorm(6), 2)) charvec = timeCalendar()[1:6] recordIDs = data.frame(IDs = LETTERS[1:6]) uTS = timeSeries(data, charvec, recordIDs = recordIDs) # Multivariate Data Set: set.seed(4711) data = cbind(round(rnorm(12), 2), round(rt(12, df = 4), 2) ) charvec = format(timeCalendar(2006)) mTS = timeSeries(data, charvec, units = c("RNORM", "RT")) # Summary: summary(uTS) summary(mTS) # Return Value: return() } # ------------------------------------------------------------------------------ test.varTimeSeries = function() { # var.timeSeries - Returns variance for a 'timeSeries' object # Univariate Series: set.seed(4711) data = cbind(RNORM = round(rnorm(6), 2)) charvec = timeCalendar()[1:6] recordIDs = data.frame(IDs = LETTERS[1:6]) uTS = timeSeries(data, charvec, recordIDs = recordIDs) # Multivariate Data Set: set.seed(4711) data = cbind(round(rnorm(12), 2), round(rt(12, df = 4), 2) ) charvec = format(timeCalendar(2006)) mTS = timeSeries(data, charvec, units = c("RNORM", "RT")) # Covariance Matrix: var(x = uTS, y = NULL, na.rm = FALSE) var(x = mTS, y = NULL, na.rm = FALSE) # Note, using function cov() fails, since cov() requires an atomic # object as input. # Return Value: return() } # ------------------------------------------------------------------------------ test.mathOpsTimeSeries = function() { # Ops.timeSeries - Arith method for a 'timeSeries' object # abs.timeSeries - Returns abolute values of a 'timeSeries' object # sqrt.timeSeries - Returns sqrt values of a 'timeSeries' object # exp.timeSeries - Returns exponentials of a 'timeSeries' object # log.timeSeries - Returns logarithms of a 'timeSeries' object # quantile.timeSeries - produces sample quantiles of a 'timeSeries' object # Univariate Series: setRmetricsOptions(myFinCenter = "GMT") data = matrix(round(rnorm(12), 2)) charvec = format(timeCalendar(2006)) uTS = timeSeries(data, charvec, units = "RNORM") uTS # Multivariate Series: data = cbind(round(rnorm(12), 2), round(rt(12, df = 4), 2) ) charvec = format(timeCalendar(2006)) mTS = timeSeries(data, charvec, units = c("RNORM", "RT")) mTS # Univariate Ops: uTS < 0 uTS == abs(uTS) # Math Operations: uTS + 5 uTS - 5 100 * uTS uTS / 100 uTS^2 # mathematical Functions: log(abs(uTS)) sqrt(exp(uTS)) # Quantiles: quantile(uTS) quantile(uTS, probs = c(0.9, 0.95)) quantile(uTS, probs = c(0.9, 0.95), type = 5) # Logical Operations: mTS < 0 # Return Value: return() } # ------------------------------------------------------------------------------ test.subsetTimeSeries = function() { # [.timeSeries - subsets of a 'timeSeries' object # cut.timeSeries - cuts a block from a 'timeSeries' object # head.timeSeries - returns the head of a 'timeSeries' object # tail.timeSeries - returns the tail of a 'timeSeries' object # outlier.timeSeries - Removes outliers from a 'timeSeries' object # Univariate Series: setRmetricsOptions(myFinCenter = "GMT") data = matrix(round(rnorm(12), 2)) charvec = format(timeCalendar(2006)) uTS = timeSeries(data, charvec, units = "RNORM") uTS # Multivariate Series: data = cbind(round(rnorm(12), 2), round(rt(12, df = 4), 2) ) charvec = format(timeCalendar(2006)) mTS = timeSeries(data, charvec, units = c("RNORM", "RT")) mTS # Subsets: X = uTS[4:6, ] X X@recordIDs # Head and Tail: head(uTS) tail(uTS) head(mTS) tail(mTS) # Data Subsetting: mTS[, 1] # First Series mTS[4:6, 1] # Second Quarter # Return Value: return() } # ------------------------------------------------------------------------------ test.dimOpsTimeSeries = function() { # dim - Returns the dimension of a 'timeSeries' object # dimnames - Returns the dimension names of a 'timeSeries' object # colnames<-.timeS* - Assigns column names to a 'timeSeries' object # rownames<-.timeS* - Assigns row names to a 'timeSeries' object # is.array.timeSeries - Allows that NCOL and NROW work properly # Univariate Series: setRmetricsOptions(myFinCenter = "GMT") data = matrix(round(rnorm(12), 2)) charvec = format(timeCalendar(2006)) uTS = timeSeries(data, charvec, units = "RNORM") uTS # Multivariate Series: data = cbind(round(rnorm(12), 2), round(rt(12, df = 4), 2) ) charvec = format(timeCalendar(2006)) mTS = timeSeries(data, charvec, units = c("RNORM", "RT")) mTS # Dimension: dim(uTS) == c(12, 1) dimnames(uTS) # Column and Rownames: # X = uTS # colnames(X) = "X" # rownames(X) = as.character(timeCalendar()+24*3600) # X # series(X) # Array: is.array(uTS) # Number of Columns/Rows: NCOL(uTS) NROW(uTS) ncol(uTS) nrow(uTS) # Return Value: return() } ################################################################################ timeSeries/inst/unitTests/runit.TimeSeriesCoercion.R0000644000176000001440000001554111370220767022423 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.asTimeSeries = function() { # as.timeSeries.default - Returns the input # as.timeSeries.numeric - Transforms a numeric vector into a 'timeSeries' # as.timeSeries.data.frame - Transformas a 'data.frame' into a 'timeSeries' # as.timeSeries.matrix - Trasformas a 'matrix' into a 'timeSeries' # as.timeSeries.ts - Tranf orms a 'ts' object into a 'timeSeries' # as.timeSeries.character - Loads and transformas from a demo file # as.timeSeries.zoo - Transforms a 'zoo' object into a 'timeSeries' # Create timeSeries Object: RNGkind(kind = "Marsaglia-Multicarry", normal.kind = "Inversion") set.seed(4711, kind = "Marsaglia-Multicarry") data = round(rnorm(12), 3) charvec = timeCalendar(2006) uTS = timeSeries(data, charvec, units = "uTS") uTS checkTrue(inherits(uTS, "timeSeries")) checkTrue(is.timeSeries(uTS)) # Check Positions: positions = timeCalendar() class(positions) whichFormat(format(positions)) whichFormat(as.character(positions)) # Data Input is a Vector - Returns a timeSeries with dummy positions: RNGkind(kind = "Marsaglia-Multicarry", normal.kind = "Inversion") set.seed(4711, kind = "Marsaglia-Multicarry") x = rnorm(12) # as.numeric - add dummy dates: data = as.numeric(x) tS = as.timeSeries(data) head(tS) # as. numeric [as.vector] - add dummy dates: data = as.vector(x) tS = as.timeSeries(data) head(tS) # Data Inpiut is a data.frame: data(MSFT) x.df = as.data.frame(MSFT) head(x.df) # First Column holds Positions: tS = MSFT head(tS) # Missing Positions - return signal series # x.df = msft.dat[, -1] # head(x.df) # tS = as.timeSeries(x.df) # head(tS) # Data Input is a Matrix: data(MSFT) x.mat = as.matrix(MSFT) # tS = as.timeSeries(x.mat) # head(tS) # CHECK # Data Input is an Univariate/Muiltivariate timeSeries: x = MSFT class(x) tS = as.timeSeries(x) head(tS) # Note, data is a demo file ... tS = MSFT head(tS) # Return Value: return() } # ------------------------------------------------------------------------------ test.asTimeSeriesDJ1 = function() { # Load Data: # use instead dummy data set just for testing ... Data = matrix(exp(cumsum(rnorm(30*100, sd = 0.1))), ncol = 30) Positions = format(timeSequence("2006-01-01", length.out = 100)) DowJones30 = data.frame(Positions, Data) # Taking Dates from First Column: DJ = DowJones30[21:30, c(1, 11:15)] DJ class(DJ) as.timeSeries(DJ) # Adding Dates through Rownames Assignment: DJ = DowJones30[21:30, c(11:15)] rownames(DJ)<-DowJones30[21:30, 1] DJ as.timeSeries(DJ) # Missing Dates - Using Dummy Dates: DJ = DowJones30[21:30, c(11:15)] DJ class(DJ) as.timeSeries(DJ) # With recordIDs: if (FALSE) { DJ = DowJones30[21:30, c(1,11:15)] DJ = cbind(DJ, LETTERS[1:10]) class(DJ) tsDJ = as.timeSeries(DJ) tsDJ tsDJ@recordIDs } DJ = DowJones30[21:30, c(11:15)] rownames(DJ) = DowJones30[21:30, 1] DJ = cbind(DJ, LETTERS[1:10]) tsDJ = as.timeSeries(DJ) tsDJ tsDJ@recordIDs DJ = DowJones30[21:30, c(11:15)] DJ =cbind(DJ, LETTERS[1:10]) tsDJ = as.timeSeries(DJ) tsDJ tsDJ@recordIDs # Return Value: return() } # ------------------------------------------------------------------------------ test.fromTimeSeriesUV = function() { if (FALSE) { # DW has to be fixed ... # as.vector.timeSeries - Converts a univariate 'timeSeries' to a vector # as.matrix.timeSeries - Converts a 'timeSeries' to a 'matrix' # as.data.frame.timeSeries - Converts a 'timeSeries' to a 'data.frame' # as.ts.timeSeries - Converts a 'timeSeries' to a 'ts' # Univariate Case: RNGkind(kind = "Marsaglia-Multicarry", normal.kind = "Inversion") set.seed(4711, kind = "Marsaglia-Multicarry") data = round(rnorm(12), 3) charvec = timeCalendar(2006) uTS = timeSeries(data, charvec, units = "uTS") uTS # Vector: VEC = as.vector(uTS) head(VEC) class(VEC) checkIdentical(class(VEC), "numeric") # Numeric: # VEC = as.numeric(uTS) # Not implemented ! # head(VEC) # class(VEC) # checkIdentical(class(VEC), "numeric") # Matrix: MAT = as.matrix(uTS) head(MAT) class(MAT) checkIdentical(class(MAT), "matrix") # Data Frame: DF = as.data.frame(uTS) head(DF) checkIdentical(class(DF), "data.frame") # Time Series: TS = as.ts(uTS) head(TS) class(TS) checkIdentical(class(TS), "ts") } # Return Value: return() } # ------------------------------------------------------------------------------ test.fromTimeSeriesMV = function() { if (FALSE) { # DW has to be fixed ... # as.vector.timeSeries - Converts a univariate 'timeSeries' to a vector # as.matrix.timeSeries - Converts a 'timeSeries' to a 'matrix' # as.data.frame.timeSeries - Converts a 'timeSeries' to a 'data.frame' # as.ts.timeSeries - Converts a 'timeSeries' to a 'ts' # Multivariate Case: RNGkind(kind = "Marsaglia-Multicarry", normal.kind = "Inversion") set.seed(4711, kind = "Marsaglia-Multicarry") data = matrix(round(rnorm(24), 3), ncol = 2) charvec = timeCalendar(2006) mTS = timeSeries(data, charvec) mTS # Matrix: MAT = as.matrix(mTS) head(MAT) class(MAT) checkIdentical( target = class(MAT), current = "matrix") checkIdentical( target = as.vector(MAT[, 1]), current = as.numeric(MAT)[1:12]) # Data Frame: DF = as.data.frame(mTS) head(DF) class(DF) checkIdentical( target = class(DF), current = "data.frame") # Time Series: TS = as.ts(mTS) head(TS) class(TS) checkIdentical( target = class(TS), current = c("mts", "ts")) } # Return Value: return() } ################################################################################ timeSeries/inst/unitTests/runit.TimeSeriesClass.R0000644000176000001440000002571711370220767021735 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.timeSeries = function() { # timeSeries - Creates a 'timeSeries' object from scratch # Settings: setRmetricsOptions(myFinCenter = "GMT") set.seed(4711) data = matrix(round(rnorm(12), 3)) data class(data) charvec = format(timeCalendar(2006)) charvec class(charvec) # Compose Univariate daily random sequence setRmetricsOptions(myFinCenter = "GMT") uTS = timeSeries(data, charvec, units = "uTS") series(uTS) print(uTS) # FinCenter Functionality: timeSeries(data, charvec, units = "uTS", zone = "GMT", FinCenter = "GMT") timeSeries(data, charvec, units = "uTS", zone = "Zurich", FinCenter = "Zurich") timeSeries(data, charvec, units = "uTS", zone = "GMT", FinCenter = "Zurich") timeSeries(data, charvec, units = "uTS", zone = "Zurich", FinCenter = "GMT") # Return Value: return() } # ------------------------------------------------------------------------------ test.readSeries = function() { # readSeries - Reads from a spreadsheet and creates a 'timeSeries' # Load Microsoft Data: data(MSFT) MSFT.df = as.data.frame(MSFT) # Read Data Frame: write.table(MSFT.df, file = "msft.dat.csv", sep = ";") read.table("msft.dat.csv", sep = ";") # Read Time Series: # X = readSeries("msft.dat.csv") # X = X[1:12, ] # class(X) # Show Part of Series: # head(X)[, 1:5] # head(X[, 1:5]) # head(X[, 1:5], 2) # Return Value: return() } # ------------------------------------------------------------------------------ test.returns = function() { # returns - Computes returns from a 'timeSeries' object # Load Time Series: X = MSFT head(X) # returns : OPEN = X[, 1] print(OPEN) MSFT.RET = returns(OPEN) print(MSFT.RET) # Return Value: return() } # ------------------------------------------------------------------------------ test.applySeries = function() { # applySeries - Applies a function to blocks of a 'timeSeries' NA # Return Value: return() } # ------------------------------------------------------------------------------ test.orderStatistics = function() { # orderStatistics - Compute order statistic of a 'timeSeries' # Load Data: X = MSFT head(X) # returns: OPEN = X[, 1] print(OPEN) # ORDER STATISTICS: orderStatistics(OPEN) orderStatistics(X[, -5]) orderStatistics(X[, -5])$Open # Return Value: return() } # ------------------------------------------------------------------------------ test.series = function() { # series - Extracts data slot from 'timeSeries' object # Load Microsoft Data: X = MSFT X = X[1:12, ] class(X) # Return Series: OPEN = X[, 1] OPEN returns(OPEN) # Volatility Series: abs(returns(OPEN)) # Data Matrix: series(OPEN) Y = series(X) Y class(Y) # Position Vector: PO = time(OPEN) PO PX = time(X) PX class(PX) checkEquals( target = sum(as.integer(PO - PX)), current = 0) # Return Value: return() } # ------------------------------------------------------------------------------ test.isUnivariate = function() { # isUnivariate Tests if an object of class 'timeSeries' is univariate # Load Microsoft Data: X = MSFT OPEN = X[, 1] # Is Univariate? checkTrue(!isUnivariate(X)) checkTrue(isUnivariate(OPEN)) checkTrue(isMultivariate(X)) checkTrue(!isMultivariate(OPEN)) # Return Value: return() } # ------------------------------------------------------------------------------ test.isMultivariate = function() { # isMultivariate - Tests if an object of class 'timeSeries' is multivariate # Load Microsoft Data: X = MSFT OPEN = X[, 1] # Is Multivariate? checkTrue(isMultivariate(X)) checkTrue(!isMultivariate(OPEN)) # Return Value: return() } # ------------------------------------------------------------------------------ test.displayMethods = function() { # print.timeSeries Print method for a 'timeSeries' object # plot.timeSeries Plot method for a 'timeSeries' object # lines.timeSeries Lines method for a 'timeSeries' object # points.timeSeries Points method for a 'timeSeries' object ## FIXME(MM) - if we store this -- make it a package data set! ## Microsoft Data: ## MSFT.df = data.frame(matrix(c( ## 20010326, 57.1250, 57.5000, 55.5625, 56.0625, 31559300, ## 20010327, 56.0625, 58.5625, 55.8750, 58.2500, 47567800, ## 20010328, 57.3750, 57.9375, 55.3750, 55.5625, 39340800, ## 20010329, 55.3750, 57.1875, 54.5625, 55.3750, 43492500, ## 20010330, 55.7500, 56.1875, 53.8750, 54.6875, 45600800, ## 20010402, 54.8125, 56.9375, 54.6250, 55.8125, 37962000, ## 20010403, 55.3125, 55.3125, 52.7500, 53.3750, 47093800, ## 20010404, 53.3750, 55.0000, 51.0625, 51.9375, 52023300, ## 20010405, 53.7500, 57.3750, 53.5000, 56.7500, 56682000, ## 20010406, 56.3750, 57.1875, 55.0625, 56.1875, 46311000, ## 20010409, 56.5700, 57.4200, 55.6600, 57.1500, 28147800, ## 20010410, 57.9500, 60.0900, 57.7800, 59.6800, 54599700, ## 20010411, 60.6500, 61.5000, 59.7000, 60.0400, 54939800, ## 20010412, 59.5600, 62.3100, 59.3500, 62.1800, 43760000, ## 20010416, 61.4000, 61.5800, 60.1200, 60.7900, 32928700, ## 20010417, 60.5200, 62.1100, 60.0400, 61.4800, 42574600, ## 20010418, 63.3900, 66.3100, 63.0000, 65.4300, 78348200, ## 20010419, 65.8100, 69.0000, 65.7500, 68.0400, 79687800, ## 20010420, 70.3000, 71.1000, 68.5000, 69.0000, 96459800, ## 20010423, 68.1100, 68.4700, 66.9000, 68.2500, 46085600, ## 20010424, 68.2000, 69.9300, 67.1400, 67.5500, 44588300, ## 20010425, 67.5700, 69.7900, 67.2500, 69.6900, 38372000, ## 20010426, 70.0700, 71.0000, 68.2500, 69.1300, 59368800, ## 20010427, 69.5300, 69.6800, 66.2100, 67.1200, 60786200, ## 20010430, 68.5300, 69.0600, 67.6800, 67.7500, 37184100, ## 20010501, 67.6600, 70.3000, 67.6000, 70.1700, 41851400, ## 20010502, 71.0000, 71.1500, 69.3500, 69.7600, 46432200, ## 20010503, 69.2500, 70.1800, 68.1400, 68.5300, 33136700, ## 20010504, 68.0000, 71.0500, 67.9600, 70.7500, 59769200, ## 20010507, 70.8300, 72.1500, 70.7000, 71.3800, 54678100), ## byrow = TRUE, ncol = 6)) ## colnames(MSFT.df) = c("YYMMDD", "Open", "High", "Low", "Close", "Volume") # Data: X = MSFT X = X[1:12, ] OPEN = X[, 1] # Print: print(X) print(OPEN) # Plot: par(mfrow = c(1, 1)) plot(OPEN, type = "l") # GMT - Plot: tC = timeCalendar(2006, 1, 1, 0:23, 0, 0, zone = "GMT", FinCenter = "GMT") tS = timeSeries(data = matrix(rnorm(24), ncol = 1), charvec = tC) plot(tS) # Zurich - Plot: tC = timeCalendar(2006, 1, 1, 0:23, 0, 0, zone = "GMT", FinCenter = "Zurich") tS = timeSeries(data = matrix(rnorm(24), ncol = 1), charvec = tC, zone = "GMT", FinCenter = "Zurich") plot(tS) # New York - Plot: tC = timeCalendar(2006, 1, 1, 0:23, 0, 0, zone = "GMT", FinCenter = "NewYork") tS = timeSeries(data = matrix(rnorm(24), ncol = 1), charvec = tC, zone = "GMT", FinCenter = "NewYork") plot(tS, type = "h") lines (tS, col = "red", lty = 3) points(tS, col = "blue", pch = 19) abline(h=0, col = "grey") # Return Value: return() } # ------------------------------------------------------------------------------ test.dummyDailySeries = function() { # dummyDailySeries - Creates a dummy daily 'timeSeries' object # Create Dummy Time Series: setRmetricsOptions(myFinCenter = "GMT") tS = dummyDailySeries(matrix(rnorm(12))) print(tS) # Return Value: return() } # ------------------------------------------------------------------------------ test.alignDailySeries = function() { # alignDailySeries - Aligns a 'timeSeries' object to new positions # Time Series: setRmetricsOptions(myFinCenter = "GMT") tS = MSFT[1:25, ] print(tS) dim(tS) # Align Daily Series: alignDailySeries(tS, method = "interp") # Align Daily Series: alignDailySeries(tS, method = "fillNA") # Align Daily Series: alignDailySeries(tS, method = "fillNA", include.weekends = TRUE) # Return Value: return() } # ------------------------------------------------------------------------------ test.ohlcDailyPlot = function() { # ohlcDailyPlot - Plots open–high–low–close bar chart # Price or Incdex Series: setRmetricsOptions(myFinCenter = "GMT") tS = MSFT[1:25, ] print(tS) dim(tS) colnames(tS) # Graph Frame: par(mfrow = c(2, 1), cex = 0.7) ohlcDailyPlot(tS) # Return Value: return() } # ------------------------------------------------------------------------------ test.modelSeries = function() { if (FALSE) { # Move to fArma ... # Undocumented Material: Matrix = cbind(X = rnorm(10), Y = rnorm(10)) Matrix = cbind(Matrix, Z = Matrix[, "Y"] - Matrix[, "X"]) TS = dummyDailySeries(Matrix, units = c("X", "Y", "Z") ) head(TS) .modelSeries(Y ~ ar(2), data = TS, lhs = TRUE) .modelSeries(log(abs(Z)) ~ lm(X + sin(Y)), data = TS, fake = TRUE) .modelSeries(log(abs(Z)) ~ lm(X + sin(Y)), data = TS, lhs = TRUE) .modelSeries(Y ~ ar(2), data = as.data.frame(TS), lhs = TRUE) .modelSeries(log(abs(Z)) ~ lm(X + sin(Y)), data = TS, fake = TRUE) .modelSeries(log(abs(Z)) ~ lm(X + sin(Y)), data = TS, lhs = TRUE) require(timeSeries) .modelSeries(Y ~ ar(2), data = rnorm(10)) .modelSeries(Y ~ ar(2), data = as.ts(rnorm(10))) .modelSeries(x ~ arima(2, 0, 1), data = armaSim(n=10)) .modelSeries(~ ar(2), rnorm(10)) # attach(TS) # CHECK # .modelSeries(Y ~ ar(2), lhs = TRUE) .modelSeries(Y ~ ar(2) + garch(1,1), data = rnorm(10)) .modelSeries(Y ~ ar(2) + garch(1,1), data = rnorm(10), lhs = TRUE) .modelSeries(Y ~ ar(2) + garch(1,1), data = TS, lhs = TRUE) } else { NA } # Return Value: return() } ################################################################################ timeSeries/inst/unitTests/runit.Omit.R0000644000176000001440000000346711370220767017604 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.naOmitMatrix = function() { x = as.timeSeries(data(LPP2005REC))[1:20, 1:4] colnames(x) = abbreviate(colnames(x), 6) x[1, 1] = NA x[3:4, 2] = NA x[18:20, 4] = NA show(x) timeSeries:::.naOmitMatrix(as.matrix(x)) timeSeries:::.naOmitMatrix(as.matrix(x), "s") timeSeries:::.naOmitMatrix(as.matrix(x), "z") timeSeries:::.naOmitMatrix(as.matrix(x), "ir") timeSeries:::.naOmitMatrix(as.matrix(x), "iz") timeSeries:::.naOmitMatrix(as.matrix(x), "ie") # Return Value: return() } # ------------------------------------------------------------------------------ test.na.omit = function() { x = as.timeSeries(data(LPP2005REC))[1:20, 1:4] colnames(x) = abbreviate(colnames(x), 6) x[1, 1] = NA x[3:4, 2] = NA x[18:20, 4] = NA show(x) na.omit(x) na.omit(x, "s") na.omit(x, "z") na.omit(x, "ir") na.omit(x, "iz") na.omit(x, "ie") # Return Value: return() } ################################################################################ timeSeries/inst/unitTests/runit.NA.R0000644000176000001440000000653611370220767017172 0ustar ripleyusers # Rmetrics is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # Rmetrics is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ test.removeNA = function() { # Create matrix object: set.seed(1985) M = 5 N = 20 x = matrix(round(rnorm(M*N), 3), ncol = M) colnames(x) = 1:M rownames(x) = 1:N nNA = 10 nCol = trunc(runif(nNA, 1, M+1)) nRow = trunc(runif(nNA, 1, N+1)) for (i in 1:nNA) x[nRow[i], nCol[i]] = NA print(x) ans = removeNA(x) print(ans) # Create data.frame object: x.df = as.data.frame(x) class(x.df) ans = removeNA(x.df) print(ans) class(ans) # Create timeSeries object: tD = timeCalendar(m = 1, d = 1:N) x.tS = timeSeries(x, tD) print(x.tS) ans = removeNA(x.tS) print(ans) class(ans) # Return Value: return() } # ------------------------------------------------------------------------------ test.substituteNA = function() { # Create matrix object: set.seed(1985) M = 5 N = 20 x = matrix(round(rnorm(M*N), 3), ncol = M) colnames(x) = 1:M rownames(x) = 1:N nNA = 10 nCol = trunc(runif(nNA, 1, M+1)) nRow = trunc(runif(nNA, 1, N+1)) for (i in 1:nNA) x[nRow[i], nCol[i]] = NA print(x) # Substitute: ans = substituteNA(x) print(ans) ans = substituteNA(x, "mean") print(ans) ans = substituteNA(x, "median") print(ans) # Create data.frame object: x.df = as.data.frame(x) print(x.df) class(x.df) # Substitute: ans = substituteNA(x.df) print(ans) ans = substituteNA(x.df, "mean") print(ans) ans = substituteNA(x.df, "median") print(ans) # Create timeSeries object: tD = timeCalendar(m = 1, d = 1:N) x.tS = timeSeries(x, tD) print(x.tS) class(x.tS) # Substitute: ans = substituteNA(x.tS) print(ans) ans = substituteNA(x.tS, "mean") print(ans) ans = substituteNA(x.tS, "median") print(ans) # Return Value: return() } # ------------------------------------------------------------------------------ test.interpNA = function() { # Interpolate Column-by-Column # Create matrix object: set.seed(1985) M = 5 N = 20 x = matrix(round(rnorm(M*N), 3), ncol = M) colnames(x) = 1:M rownames(x) = 1:N nNA = 10 nCol = trunc(runif(nNA, 1, M+1)) nRow = trunc(runif(nNA, 1, N+1)) for (i in 1:nNA) x[nRow[i], nCol[i]] = NA print(x) # Interpolate: ans = interpNA(x, "linear") print(ans) ans = interpNA(x, "before") print(ans) ans = interpNA(x, "after") print(ans) # Return Value: return() } ################################################################################ timeSeries/inst/unitTests/runTests.R0000644000176000001440000000453311370220767017356 0ustar ripleyuserspkg <- "timeSeries" if(require("RUnit", quietly = TRUE)) { library(package=pkg, character.only = TRUE) if(!(exists("path") && file.exists(path))) path <- system.file("unitTests", package = pkg) ## --- Testing --- ## Define tests testSuite <- defineTestSuite(name = paste(pkg, "unit testing"), dirs = path) if(interactive()) { cat("Now have RUnit Test Suite 'testSuite' for package '", pkg, "' :\n", sep='') str(testSuite) cat('', "Consider doing", "\t tests <- runTestSuite(testSuite)", "\nand later", "\t printTextProtocol(tests)", '', sep = "\n") } else { ## run from shell / Rscript / R CMD Batch / ... ## Run tests <- runTestSuite(testSuite) if(file.access(path, 02) != 0) { ## cannot write to path -> use writable one tdir <- tempfile(paste(pkg, "unitTests", sep="_")) dir.create(tdir) pathReport <- file.path(tdir, "report") cat("RUnit reports are written into ", tdir, "/report.(txt|html)", sep = "") } else { pathReport <- file.path(path, "report") } ## Print Results: printTextProtocol(tests, showDetails = FALSE) printTextProtocol(tests, showDetails = FALSE, fileName = paste(pathReport, "Summary.txt", sep = "")) printTextProtocol(tests, showDetails = TRUE, fileName = paste(pathReport, ".txt", sep = "")) ## Print HTML Version to a File: ## printHTMLProtocol has problems on Mac OS X if (Sys.info()["sysname"] != "Darwin") printHTMLProtocol(tests, fileName = paste(pathReport, ".html", sep = "")) ## stop() if there are any failures i.e. FALSE to unit test. ## This will cause R CMD check to return error and stop tmp <- getErrors(tests) if(tmp$nFail > 0 | tmp$nErr > 0) { stop(paste("\n\nunit testing failed (#test failures: ", tmp$nFail, ", R errors: ", tmp$nErr, ")\n\n", sep="")) } } } else { cat("R package 'RUnit' cannot be loaded -- no unit tests run\n", "for package", pkg,"\n") } ################################################################################ timeSeries/inst/unitTests/Makefile0000644000176000001440000000042211370220767017035 0ustar ripleyusersPKG=timeSeries TOP=../.. SUITE=doRUnit.R R=R all: inst test inst: # Install package -- but where ?? -- will that be in R_LIBS ? cd ${TOP}/..;\ ${R} CMD INSTALL ${PKG} test: # Run unit tests export RCMDCHECK=FALSE;\ cd ${TOP}/tests;\ ${R} --vanilla --slave < ${SUITE}timeSeries/inst/THANKS0000644000176000001440000000000111370220770014271 0ustar ripleyusers timeSeries/inst/README0000644000176000001440000000012011370220770014240 0ustar ripleyusersintroduction of timeSeries package in the Rmetrics suite after svn revision 3319timeSeries/inst/COPYRIGHTS0000644000176000001440000000770511370220770015016 0ustar ripleyusers________________________________________________________________________________ Copyrights (C) for R: see R's copyright and license file Version R 2.0.0 claims: - The stub packages from 1.9.x have been removed. - All the datasets formerly in packages 'base' and 'stats' have been moved to a new package 'datasets'. - Package 'graphics' has been split into 'grDevices' (the graphics devices shared between base and grid graphics) and 'graphics' (base graphics). - Packages must have been re-installed for this version, and library() will enforce this. - Package names must now be given exactly in library() and require(), regardless of whether the underlying file system is case-sensitive or not. ________________________________________________________________________________ for Rmetrics: (C) 1999-2005, Diethelm Wuertz, GPL Diethelm Wuertz www.rmetrics.org info@rmetrics.org ________________________________________________________________________________ for non default loaded basic packages part of R's basic distribution MASS: Main Package of Venables and Ripley's MASS. We assume that MASS is available. Package 'lqs' has been returned to 'MASS'. S original by Venables & Ripley. R port by Brian Ripley . Earlier work by Kurt Hornik and Albrecht Gebhardt. methods: Formally defined methods and classes for R objects, plus other programming tools, as described in the reference "Programming with Data" (1998), John M. Chambers, Springer NY. R Development Core Team. mgcv: Routines for GAMs and other generalized ridge regression with multiple smoothing parameter selection by GCV or UBRE. Also GAMMs by REML or PQL. Includes a gam() function. Simon Wood nnet: Feed-forward Neural Networks and Multinomial Log-Linear Models Original by Venables & Ripley. R port by Brian Ripley . Earlier work by Kurt Hornik and Albrecht Gebhardt. ________________________________________________________________________________ for the code partly included as builtin functions from other R ports: fSeries:bdstest.c C Program to compute the BDS Test. Blake LeBaron fSeries:fracdiff R functions, help pages and the Fortran Code for the 'fracdiff' function are included. S original by Chris Fraley R-port by Fritz Leisch since 2003-12: Martin Maechler fSeries:lmtest R functions and help pages for the linear modelling tests are included . Compiled by Torsten Hothorn , Achim Zeileis , and David Mitchell fSeries:mda R functions, help pages and the Fortran Code for the 'mars' function are implemeted. S original by Trevor Hastie & Robert Tibshirani, R port by Friedrich Leisch, Kurt Hornik and Brian D. Ripley fSeries:modreg Brian Ripley and the R Core Team fSeries:polspline R functions, help pages and the C/Fortran Code for the 'polymars' function are implemented Charles Kooperberg fSeries:systemfit Simultaneous Equation Estimation Package. R port by Jeff D. Hamann and Arne Henningsen fSeries:tseries Functions for time series analysis and computational finance. Compiled by Adrian Trapletti fSeries:UnitrootDistribution: The program uses the Fortran routine and the tables from J.G. McKinnon. fSeries:urca Unit root and cointegration tests for time series data. R port by Bernhard Pfaff . timeSeries/inst/COPYING0000644000176000001440000004310711370220770014427 0ustar ripleyusers GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License.timeSeries/data/0000755000176000001440000000000011731573515013334 5ustar ripleyuserstimeSeries/data/USDCHF.rda0000644000176000001440000042737011731572506015014 0ustar ripleyusersý7zXZi"Þ6!ÏXÌåÞïþ])TW"änRÊŸãXl΀8[ï Ïp ñ5¡*jÊãŒã«ª×iÚ8-›=.@âo ©-·âsI±Jɬ…±\Ö¥-½GÛAe3ÊС6¶ÒÌ>ªBŒ¥¡á0, `±;ÙÐ(%/âÅ…âg:åJï Êw¦?tÙ?ú¢<_]Îá W‘K{˜wwÆÎt˜úWº ²ŸðvEu, kðz^!E+_kŸMµºí^­©ã'iÞ¦žê×ó\µ–(ñ] Ï,j O¿2öçŠ ß+ô¼—L$ÒÒÊ3k!ºŽ¦ºY¶µYÄ…á­D@¦ÙÙCû¢Q}ÊÞˆývPT\¶„ÀÁ–hójíÃ`\GBg ¨ö” äJKZÛ qõco†zÀôR3/¹Jßé7$Hª[ÆÝe£íœt~'ÈV‚où/-‚n<*©–¥DlmtžŠ€›{GC ¹m}K¤œDB,WÑ« œáãЦÄN!ê\/HhÖDMê¤WïE,udÿF/?:Ä4«™• Ûz Žz#°L ÄO˜!T&¹zg¾jë]\_ÐcJù¹¦ŠEJ«´$Ua?\Ó&Æ…Ž›bîÓxó*{¾`ÎßÎbå‹C>]Ï YS'æ?ôQ‰jœxdÆfض¢¾ C¿.¶`RÝP‡ÚžŸ;æ1ÃaÀ»S‚„¤*Š#,˜8WxbúÙPMÂV¨ƒ]ô§ŠúT`ÖÞô›å¥¹†Ê}b×ÜõÃ÷£S«¸7°M#ê,0‡| X8>EFE-éÛͶ4¯±öL­8=^Ê”ÓMÑU­ß·}¥#"_+HÄôm?&ÝåaËHƒÚìo ϼ¦p6© K¯[<”ü7Ÿ*%ÅuOñÒÞD£¥ XÄ3«ºv û^®R—ðìY*Xk|#£Ƭ‚=OO¼‹ò"ºS,OõÚ{÷9~.•4¶ÅOa ÉNkæöÌò mØòІFî§…ƒ«êÿL°\ú Þõm– «Rå0.ª†¿.• Ïö‰™5‘ŸÑƪabа×m¡.A(œ9u´•bӀljuJ¾÷WBÔµ®’¨i™’·Ì8í_ÙuÜÆŽ®åï]f}Ú)ÃUž„¶5Ï3ðlc@l.Kßü¹Þ\Á£û0 7(·ñRÐ:É™Pœ•˜{ô^ó ¯gåÄÆ(Œ™š8k~sŸ:N6…©eó}f±¢,XþÙ¾õ4r‡2¤à3rYFƒD-gYyžAà- ŠD[ø!ô˜èÎîl"2]R-AX:;W=þÜ%W>ðÚÈ;Óå¼…ÈY¢þÑ+ Øi‘|öOìG3dþÏùø’^;àVˆˆ^©ó§{(é²{¤¦EGý“3ñ%2´!oè~Ì‰ØæsV`“‡a‘S:цš.ÁB¸tyçç<ýrfOò%á9µu£õŸÖBãTÒãwÓ÷ ฬ…ð•œaVÖCÙþ»]¶ r»q9 W±,ª²¹;mƒÓýŒÿfYÞ )[Úöi®elÚsk%RO©mCòâî4zÖgã7ú~mñøÄ’Ó=˜BGçŠÔ%>]¾:èû¿¼í+;M5ï×MÍš¦€¡]Fb…ZΉ`È5&vN°bçE‚P•Á{ôÔ¢hùyN%â1€`Œ"º!üÓü§Ñußò}>M6 ís­‘1çðGÑÔ´§îÜõÚpišwÑœÁM+ìd_õÆì:’wÿ4W¦ùyFÖ¹°vŸCT.pÏŠ¶™e±!g¯,ÿé6Ú;º~gW}Ir´­`ÂEá2Jf·ù =N ’5à˜Ž’àîÆª¥m…áï08'­ÖÜÙ³KòçR+3üGœ¼n\Ô¶%òlÏ“#Dh¥Cˆ¥9…÷x±o;JÂûãLW|²Mñ‡NbbK~-…«IГB«èö7R1X©… y~͉2~ÝB¹~‰Å7‰#%EX-~Dàœ‘ð³FÓ¹e˜¯¬Ã¸Ë,×¾Ç›× Í†ë{á4Óxj:ÙKÑåõ«ïqAòbÎ;°kÂàmVWµ¼kºuÄè8ù.ÆÓ:{ÙjJÕ/Å!´ëÄÓSu›7Ž*BÀ—EpïuÛºãY¾4ÕË8C¤ënËZ«ëŒþc&éÛRCËdAÂŽ<Þ|ûÀÿ~ˆÞ2¡¨Ê–;¤¯è4ÉyâÕÕ^þÕz€Ъ7'á( _ç…Š’­‹P†žp¶hB9êÍÔ€¸ô·»¦ JÍÖ"SëÇ"CºÌüPý¿<úÓÁHç̧\õ¾ª{ÎŽø™ÅrÚ“ÈúïB(w˜ˆò´PŒH=·D7“T\»À†¤£Hä%Õ~u9ú »™•½=5ëÀ”VZ: ?edòŸMcœ.|ú 1²š+e (p78dK$Ê*^cò¾{«b–À‡”èüÁ…ÄzMJ”š±®Xìv·"Ø~ãéÀ„#Úá®F&›³¿;ÚaÉ O‹ÏÝ… ¦ìÄ\­GÄ.­Ò)ü£îˆ“-Aj¾F¾ïé–±Yp³9;ÖÙŸÈ3›,ÿy— ØwvÐ0–ššÖ²¢pHÕb·Hë½~1~Ke½1Få[|²E7á±Q¬¦,ƒB쉩®4£²dH).³õ%a‚ž¶õ17ç^_@ü¨°ö.Õ»Šä:ô[8‘ù®Ñ+—j׬6SȆ.Ô䩦"Ð*ªf`âu¬È¢±³•GžK€>Êw™zôΣQÕìçvý÷J¹èWâ¢>"m°ü]m8ÒÏÏ->™d-‰D×…ˆkÐ3Bmí‹büÅÔÖCqµ0ù“ÐäÀ+…Å„¯küÖ›Œ!ö©†‡1Žy™¥“âA‹üö!b;0ƒ]ç¥Ø¢D)¤í®å 4D&àÜ×­ŠÓ 4xˆ^Ë4™Öÿ¦ŸºÑàxÿVÄŸºPZ7$½FŠív&iEƒp!måBå ì9vaBôåcìlðP.[OÖ¦e‰`¹²R˜-må‹"üjCòv_&´ô,º¦n}Nõ b:!¿qÖñ¾jj5@)+©Ìšæoúg¸¼ŽÈ/‡Æ’)©ü£X2£Crê‘‹¦S0G¥}@mÜÁqç†å°!~ضH,,=Í]u4¬–d­>¤KOwp"¯ÎYA'ý<Ç¥Ž’¸ ñ¢ ¢çEu=›ýó]K(.©€q,‰“”Hœ‘MfïMÏ}<¢a3Cá0Ò*ƒÕÚÖˆ^Uhòßµ ÿ¹•Ü&À¨†¿Ð‘HQÀdk½Ggo¿+n⃋(W·E zþ‘/ø¬óß^zñìëR„Wk?{Œ j%®+h¿ê¢£Æ’œÁj™¼ò7£ ÛÑÏÎøK&Š‚‘glåqÏvX¤>!|jq)êº!‡ƒ|ÿ±ád@ljd&±ì€iCF§'ò.ègb›¦Ä¿¥Óí/\À+ÊüI÷&=Ù w@Öv'Gú‚®ã~Âß²ÌsÊ,=CaÔ?Rxà‰ƒªû¤Óÿ(ÆrÛ)0ï µÁèmö5pžàôµÓÕN !LÏZôs&æ0 îŽhïbª‹F?6XêY§ ©¤8… Ô{}LôP`þES€J9Œ gB‚1¹“ª“®*£DSypgޱÍÜÑ÷Aý*£ÎÁŸ‹]¨Ä®qc¼ŠzÞÃ["E}¶#yvÔ÷eª (9^4:÷8w¥]4Tlõ!Ô±¨ë‘÷©¶¡üÂ$Ü@ÚÏÆ¿ù6 ïÖõºQÌ^º}G§°{$û'µü˜£)ÝkÂuÖ?*)5²S¢¢§a9ïtýz•;RÊ™ÁÌSàž•Ò‚çèÀÜuúX0U>r*ØŸ¶'Z{%7*ÓmÚã[ÍýÿŸé´s–â–+};‘UôáãyÖ$»JL“CÅÖψìzìモX¿ "šU>#;·þÐ#j+ÇÜá=ø£¤¼°Ê<Ï~UEÉ“OÁ²å\}Ýq®L³}s¥åXmþð!ØÒ‡êùïü‰Í:ŒQvãÛ®þŒ ú‹¸F²(EÓmE´1xŸðÚöBA²(ÖÁqoáY©Ã´’‰3%– ËSGpO}q‰N8·F¹(pì{ØZ,ªf3DŽo;ñuÝ¢‡É}‹gå¼ÏsfÙ5í¢Ë@EÚóåÔñuAžÉnüæätS| ½O†·²6þÐ(DyÞšM¢¡‚êÐYj@ ‡Ƀ¸Ÿµ#=ØJp:&µ[4¦-Á;˜øÞ ŽuÏ•Ítñ…åeŒ’ï öG’êˆ ÇÃ[(8Ñ6=`W uÑß?”*¯tgŸ ë–lÃ^âí—4¦•÷”ÿ&1#ñ¬û`sÔ>*4;GWb ¡š{F'q«òˆ•5ØfPÙ¨3iJ~¹wBO!êß ‹v®Z\Ÿ r½õ¢a>•Ê.žEÿéaŸX"U'S‹lˆY-ŠH{\ŠSåbˆL"ÎëŸì¤iC€}+¬ê £Œ}´Kæ¦æ3,PeD3ÛîbeŒ>6ÞPÔǦÍf]\šI»Xéãé‹Þl*¿´BÁ\É&éš)¤–kÌÐUÚZš3(~ ^•ùáSØr901–"– ,Ü’ùg6z1"4~Ÿüat•{õºdX´ŒÁ®ÏxD™c”´§äëÎ=ùg^«6K‰jûÎo|7ñ{€Ñ-Âr÷J5NGoêQ” ‹õ†—$Ÿì§Œ^m¢ž 6ƒ›|XŽç¾`³Ú͈”þ”: ;sq0á.jçI¼Þ¤B© û|¸ddgƒ Ü³D »=sYscU‡C”~­DÚ\‹,b‡Ò¶ƒï¡ÜË‘Ê Ñ"V¶ÇÈL%›ñ™™˜·¶0† ã ){X!üpaÜÁá»a±sŠO89°ßŒÏ°ò…áêœÃ/ã¾Å#PýF,±œå{çŒôÊ•Š¯YŸˆ˜ðáqhÌvBAŸä|sQ%$’û*q¨ŠºÇTM³°`ËoDþzá5[Lì6sÉÂðS`deñ&XÊ7i9Q÷0Íòè?mÛ´vfXPž"¸ OªxÉsµScl.·ä½ÔAØi$A!uwwYýÊ^ O0?å>²ï¼îj%‘9¾ªVòkòJ_î*îl¨±là U^h8ÛÿÓ&Û_Ú‚áò¹ZhBÕœKE€µøB¡fôî¤T-4ª'÷´TÔ£êåTY5÷+¢ã²­™Ìq)»pø Þñ縦2V½!G™¯ý_Y«Ò¹Ä@¢ j_ol†Š×ç(Ú[í'0‡$vmÛI{–šß3[vd`|VˆÇÿW!à~­ÇRˆ&fÄ%É…žÃ5¢â4ãIç„È[’—$Ž+ˆ€RÕÀÊYÏt¯}­¢cm;mÖ&×ê7çú—ñÕcyL%ã£g)$­[9‘TË•‰ke µ9°úóZü£òð`‹Š˜žux%›§®$¬dŒBÙIP])?ddÕaB2ÐF-Ö uíDþôWÍ'´£«—Xtˆ¨¿’ûQ´ˆÝ»tÅŠâ¾÷[Úl2Ë|á{Ó%©.ï+áYv Ÿí Åf;9i¸V‰¢÷ö äWÚad½½x.Åa2?óRÛ—ßák¥yãÉy¨Ëq¾"<­0ÀÑÜù·Ó€¦tˆ€AÛ¥˜,¯RÐx’æ­·ìË21~Í2RR-  Œ,–õbºj–ÖLlYÂã–æuc#¶Võ¸®zkr)ʉËÇ«Klnš»™hÈï˜è &ã°>1Ö..¥T ZDÌY•}Æ<¬ºÀügñ¦‡ð¨'ôà›è‚² ƒÐný)Äay?´¶=Y+&تœa‡ýäð´‘î(| ·dC²Ìµ.ˆÅrÌûð^#R‡ öc,–öåé‚Ã^ÑïÍMu¬Gî†cb¬“m#A·¼Èù •ÙXøÌñÚ£¢!xr;æ&hOàgæì‹—$?ÈÈ•!)N—é…£ŸyŲd:·³ßAʪ÷§lê YËþ°ƒW†ÇÍ#ÅÐêµ°-\‹>~¦‘c$%,7ŤÔÊÅc¦Í™1íĬEÀݵݽ,'£„™¡†ø!ÃçgÒÑn%¿‹9̪¹#¯ûTT»\cI¯)¾f8\€ã$­y~£þN0ÇûßűëPÉ,Ÿ€)ÝÜ´©þ:O9 5&ÓâìêÌ…gúž‹V3‡òtsãZÊoøSûª;cv Ò@Ä©’¬ø.:Š‚´Ûœù~îõÿ׎xžgÚÚïÅÝ &àÏ eëŠÂ:JI^@¢i…!¼Zf´GÐzÚU**¶ýÚ o—`BE?ϪoØ3)õ4yä†4"Êë}u= H½ÝÄôÞݱ0d†€B]ª?®>µ– Ñlûc…h×,Ëç¸Ï6¾mC[‚v£}t_³–ã[²“Z#"£oOx½5äRnèºÉOuñx"öçC«–Wç*¥ëZ&—„…ÒÍrB%JF”K7Eß[‡µ>÷/ þÌÿ iÓÖ‰ãï±fv¡b{ͶŸãO·¦&‹o@¾Qü+{òßóïYCôaèßÈÙ^”ž)}UzR^ “M[¤þ]WÔë eqàb°€åb¥yºY‚9uYÁCÃÉl…\BÕwM¼º,xþ3ê Ýã‚ÍÈ€ŒX’t]Ÿä³Z¤aßA˜ÚÝû~$9)÷ßNÿ¥E>íà)&‘ëññYnk2ÍßKdÖWÃ3…¡žÃÀ»l%AÄæÚŒ¤_¬Ql¶;wþeÓNACúë(½!mà Æ}uŒMXÜ3¤É軂8£¹æ€R¦ªÖõúŠ K¸^ÀË×BT]ulÇÚ.ý´Áø`½Ù )\ÎRAáê% Å~ŽˆK4d©çެTrN·<ßîÃO,ºÞ6Zì,ÊäªZ–mŽV‚Ø*L—XÖ- Gk7þQÔ³zÌX‘+TBˆà#Åú¢r=Ú1Úœõ$²Æ†Ð~9hý¾L€Êæ÷ÑûÈÈcôì²]Xû÷%éë½w@Öøx1‡˜ŸPG^°MÓŸ(G¨ìµ‘‰ò}¸wSgVþ®‘ÓëþCHÖlz7¸páû± 0ŠœÒ¤?Ùù)@I–9—ÉÝù§I½i|ëZg-I …é:9šdŒ¶™Þå(Ú>Þ.v!®m½÷Oèþô}x´ÍyÔzÞD9,":…X¶§ÔuÑÿö3@ߤs .ÒŸÝ$ì“·/ÙãÔ3È.ÃãÓöÈØe r ‹ÐÆ3ÿ±mãÈË·bØU앸‚ùýºxŠôæ.Ù9yæ¯ ŠdÝj^!燩*] &uª?Îfx¨|Šœš[#…_hU)U¿rÊo›á/šº¾øKÅhD‘Æ7d†vhÌ“g¹·‡Qä¬%à æ¢DÀù_Sîÿ¥ŽAÄk|!J¾Ê^UŠ„âkàD6B’æ>G¯)I®Çvf§Žb›Iðª½p»›Ý¡·y;õ÷g Ìü±¨‡” ®¹Uÿ££øŽ¿1ŠÄ`bM$߯Ré)O¿A´+RáöÚćÜåœÔñA´}ú¿CxvoËfMŒ÷·þrØ:7hFÉÑ™3½†b'v¨+y—8_ShTEºjŒ‰Ä%!FVídx¡q^¦<ÿŽ"£ÅúÚ]f =Çc¨Ž Õ> ÅvØ$Ç• U‚ÜL¶äžðÌö—;SŸ¹Yåa÷–—ºÎ³^èÓ> ±—&þ(Ìy<Ù¼«ÔiÓ.Šá»†Â%SÛËVu³qdh5˜3ùíÉ'ý¤@ÕMsðU:»¿°~…Öò†fiË2O¬—ŽÜëÍHÑÉ ÈrîÓ¿Ùè€ÕýY Ôy5 åþˆ^‰Ç›-…ªbÛÐJ‡ <Ÿ’ ®¸œ’Ñ®LÊ…4yˆ6ê;¬¦šÈ«Û¾;HÍcþBïXPáIpðØor™ÕZàwOª†š¨Œ>XÀ·ç¾É¾x”vuݲèðp2¾Â]K»S¨¦€3[ÐM˜ß0ʶ¼Î/¥[6¦)Z™õDä¢ÉÊÈÆèÀÙv>R¡Oæ¾î&ò^¢ûV‘—¼ ¢ãm<½oÐMŸ¯qo¸ÞJDÚG!÷í :CC˜^i÷–aN0<õp–ÑØ‡¬-Uù\'Uœ¸hégôâR.Þ•PM´l[Å´¹¿çö>mUÆPÙŠÞùAƒ3æMÏPλÇTákêÁDºÛ€¥hhÇ7ÛL6AÆ‹Üñ0jB[¼°Ï3¢&©…m )’gâ[ó@.Ø«lïìÂe*›f“3û? ·Q-§œ;YÒJ‡Ç‘¹¿á¶w¬4¿$ý`5·ï)#ìüG²Ov, ´­êN"´÷Føþ*>«_N+ºfŠ‹˜k°WŸÎá1×t!µšUôVÔ}Ç:⇿‘b¼d:ÙüÛö<Òr8¡b,Ä!ÝÞ3f®Ý›¶vAL´öü–Óp±biõ*ýõºR#œŽ÷„ٚÊòñxšœ×쉧¨wÇÔ~:ì@Žæ'.(MÕ“‘ÙÑ© >½¹¥¦x<å©9|ÚoÂÿ£Ü”°ÉýÚQZÑ$Û:¦Þð*¦9žhÓÄÕà<žžÓÅ/lÊ0/š±b/A–éE4ÒÑX'ü·äNÞéÈi3VÌ~$ôÊÔ6”ú“dtdìC!Àêc2¬…€ýÿùV^FJ tÊv¸¡Ñéh@ž]Ù¿-bTbù¾X¦*ÉÚœ¸‰‹#G4<ýÔ<¢â™Éô|¬g¬‹¼¢såÝ$ÓÔgª)6!WÓxå©=w±(ú™&—**¹L{ŸL dg‡,^ÄR¥uvþ²ÓeqoêG¢|¤_;аg¢¦¹HûJŒ/Nɯ`ütΚ_ [Ùç[N°õJk&Âp6úzmo?qé†wYW¬¨ äl{¶¾áÕHÖš*®"ÛvÂõç7ʺzøAÖÅ<\FªlBë³MÂþ' eõ:Í…gg{ß®¦OP«¨‡ç¡n(Ô‹&&Ž¢i²¯¯ÕÚ¦ÝCãË]#<‘nº·~¹êk¯¥ ö‹ýõ|MóË´žƒ`ê­•2ë;½Â±\.\æ¾×Qs¼é”j‹“|ß"°êª:aïàš¥‚n]ˆÜBI‹I”òµKÓv»ìŒ pôí&˜€U[J¥Ž1øÑ\ìÁ¨Ä‹½þûú+2³°åË3K'ÿ#…а”3äŸÐ™‹KÚÍ%Ì#w Âµêƒ ÷²“¡Ú \î!F5AÒï×vàÈ;ö\«ÎrmozKÀ®";̆ó@W9? »arõµ¯™0ˆ"+žPcË9•¡Ùñ`óCÚ·—£åFtlÑ6\ÞºÕhì¾ï_ü1®¦³ì{/CN%ÕëÊ¥T€Õœ¶÷úï¹ÎÏÁD†~¨ÐðïÔ·Œ/§ ,T‡,ûkL@d.Ca…+ë•u¸¶¤prº“^mºUBúxìäȃÐTHûó÷î·0è¡ÎžXŒ‚n®ŠŽSò/HD¾`î,¬Õvy_±øªZ§±Ëåî*aUÈX XÇä­ñ€wÊ/à-÷€){Ï:PÂ9Õ÷Ä£ª(|nÛCö‰8ówû«ñ›»œJ•Æ@Ò‘ÛoOF#æà7YmÙ¶‰üGdc!؃y7¿uy½™s} &ᙃ?Éš29³Qøaø‰oñ3Ø¡›ÅfV·ì™À›§»ƒ9VÝÁžÃ÷8ÃYr ¤¹XÜLžQ5 u¨%ßs÷·x3½5VÊÙ‹XRiòÓïH¹`·¯r{P§\¢Õ!¢§,[b ÅAf4ôÁU×EfMàqÍRXqTe ‡¨nÆ=—Òó6ö $¨ uõȉyPYÌ£X”·[$*]ˆ¸ø¨Í³Ao0EŸ±K%vüït–£¬#ªŠí¸èœî-œò¹é¸êƒW#…ëÁ¨x–aS{Ï©æ:bmFúsák3 ÔÐ:À†¯1šINë׺|·uP|Ó3B¨H÷+6Á6„fæúhJô3u¿Úµ3å'û¤¯ $øOdtÍ»¤eŸ&k;çVLí›q3J,¡!Ô5Œ‡]jrSÄX厮#c"w¸h*¯X`Ab5|7sÕå‡ìÃÌî 6±jMÏ×ûçé­œ‰'amú—pcþ7‰sYÂ\»óòwE®áŠ'ÔR¬mÙýéǪKËOyîv³_- ¬=GòêëàVÐke)_ÀîCïÍcêW¿Ù=‚tvu%Ð"riÊ+Á‡\˜ÎzÀ¨Ñ~™Ý§¤V»AUâätSµ{ g©I¾5ÍO_ÉÅÖ,ìƒ ˜³C˜GÊÖ Ï~YIòÑÆ#øQqÔg›pžƒØi¨¿Gkb¥Þ™'ëÅpãöùШâMu@&Á ?~s=ÆÖÍg~zsb§1)õ°QüÑÔ´­üeù0²ãÕ\H[¿‰y¡1Ïæ”ð¢”?6EU FF:^)\óý5 ÒÜSPm‰R2 Æ£;™òÛn^ó:ä&^IR‹ŒêÃàÌpèãi$(ò$°‡»cNÁpîF ˜˜Uï+~”î1ýÌîÅp;_Ê϶( êîîx†TpêE}cè´¨/Ô ™{Á½ßƒ‚11÷Ò6aõKÄg˜uT¶¨#ε( Ñ áÖ}x¿¿/_é©6ŸÓN«Ñ—­Ç¦‰^„ò¤æ 3J@¹*|M³éãG9Í`ˆóbˆÓ'¸W…‚3;˜‚G€E.E‚n×ê‡HbÆ5Û´Ô:êü0 Ü;ÓŸR–‹n%úQÌë‘Ä 6i«êéÌ Þ“âñÖ›Õ‘¾>spp Þþ¸LËn’8Qº„À¸ä´·îVWifx™:Õ¾õ&¤Ø¶K—V¿¬àÌ`¿Vj;,ãÀeŽÉ579RÌ9I ehÍ™Íê®­ÜßÚXŽÉa–].VU€„á­FÁ5Ää~<ôbjKi–!“$Êï6)kÝN&Y ¡[§$xÊd\¶ÌÇL\¡ñ¾ B6–ŒÿK«³Á“¾¸‘Áa -¿½ˆïæå?Öù¡÷u[Òö‰…޵”·¯éˆ8”Å \¦ªÊ&ø7ÌC8H%r¹QvúÒ¿,Ãê±W·!niµRøW)D>ÖÞÓ^ÈAôÍžºn°W.ýj­Ä-îŠ|¡è„5D^º#°£©çfÀpU`U’xÙ}ÏFÃÒƒN”®±Ù¬x"'æo‰rÅ2ôsTEíQ`ÀÕJ¿›swó†›z×5jÆIGl˜Æ¨×)Zlâ1`V5à}ÒÊ™î§-Y"6H pH¥Ó-òâ½Í¥ØÆj|Cykr_š|\k™ÌLÅ ²Ø¦VW½L)öòÞ7Þaùø‡!^B5-ÉÛ= é7Ñr]„•çFÜF²† ŸnjèÒM/YþSAƒ?ÜÌü uÒR¾¯š€î2,‰$¢x½ذ“&q}M•Qÿ%QðÍõ–œá:1¬»µG*¤9aÕ……ÿÌÇ&åî<0–—´¸Ê²@ÐÊ#)¤——5Uêœ@“Ã&"1Š3ÎjÝIÅCŸc8p\ —Zížû\¶5ñ»êsx¾2bÞêçàÈ™GpSYÇæçÇ£f÷ÍÔ´ÍŽ´PDÂíc±éLÍpÇîï9˜,¹èeÏóWí¾ºbwæ§¾µ.¡¶NRUòŽ: Ý1¸e¨n½$¡™ªð^Z¯›$P†s|‹±Aü óÓ/™W]Wèúf%ÌãeLÐ"Ëèñ¯XÁë[Þh,âá´Q!_\)ÛI2!š=Ï+g dÜšúA4^²xŠ×D7-üëB•pXc…SNé‰ñ&Ëè<3Öá§•Z;Å·—QþÉ+úá '¦h Èao—Q9àÓ¨O¾ÍM•¤{wï)Ó¢SÜOêNÁ ­éK l·7ÉÈ#U`0þ0’y;bñÄbLSëð³, ;brN:RK ·U<Åvbê*uéâü£u~ºÄÇî˶™YP1³q˜H¼ËÇOš.;èº-[€Ù,t“A–å2‘ƒÜ‰¶4òL"ñgè™8¦¤[¡'+zø× £<›)Ñ-Œ,ŸñÖpžhþÇéí 4ϸ"†$qn¹ö8S¼®¾ŸöÙŠ2óYË+yàÉ¢¤×ñˆ—ù¥bP 6½–óyà¶$»× 3(¤‹.­*µe(`œa§À—Î9n{¹Žh€„‹Oy¥²óôy:Î>j(…dÏ©ý0Þ‹«±ÿoÌ q5øf‰º–JY•°f"ýlºÃàûUôV°CÛDàÄA÷o< Ô)÷ÄÇý vYcØ!ÙŠ,Áö7"­:FuÜX¯Hȃ’E6‡Iº1’eÃô«~‹¬ïÍŸJÚó—­-ñnøK€q¬±Ã+mLuÓ]d6 ÆáyLÁúß)å¡ÛãJvùœ-•Sýˆ„‰7¸£®p´úö"„pŽ\ŽÎ¥=ft;J<­Dæpò06/ûáùŸº¾Ý*êçPÝAÝi²¦äžd!žp÷5꽨µg¡Ì2É+¢Ê’hÚÚ>qðûÂ?•ѵ,ò1±šq®`·ný¼e}®ªê¹ßƒýȇSœ‘Õ_¿XpqøÔ¶Sã°,Øý»àLš@„T‰~½=Ùy›Wo èŽ)‚H8´…‰õºT1Cùç=y ¬ÉŠ‘-¢b|8bÓ¦6DÌç;ö0Ìx ¼‚6º£ºD4ɈÎȇºW|KmÛ“„6…{Gû„ö®¡¾!oSÅùq£ƒ¹¤$KŒ iìÆ]Az›À Æãþ¿_õt0ïOýã*¾OYˆDÝ£NÀí'zèǸ)1ƒ}κÀ²õn×>åûˆþþ¡í8¡ë„ƒõÑ ôÉ )9wûØ›šÕ| þZ†KêñîÂâèZñð:,h áèÎ3¬,CÊk9‚áF¸¦;¤ÚRÇùÍrªDËKÔò]m[ÂÖ5z¾œ¨ì±û§ª÷GÑÕrNØ’Ë)]Aŧ ýÂÇ+³Ð§ö+E‘;‘lƒPøI#›aâ-öÅÖUkñÝäˆò„k@S奟QÆüºH@θøzðAo0sˆÉÀÏ™‹¹¯î[¼iÄX¶ÅšWOŽ—Nz¤üOƸ–w=qh0 ,öµŠêgàÏR௎ =–rc^Ôk f½ ëø¥†`y»rÁU2â‰âª^A‡º­× : (+B`|‘MXØû¯/Bý® ïŠH_†‰ÿâ­°·Õ-s>÷’º„ Í!Û¿ö&θk*ü#3^=Ìg –_8ƒÇ†ÁþM/éàñ©ÂDm=ø~ó}Ž3ôѲÃLŒ3ØNJ†VW3¯byCJtÞÜ|«¨ŸGoj-ZÒC°m„Ÿ§'³x„©½,rbÒ†lèü!Þë;ã¤iþ_›ÌË^FIÙúÿ޲ †:<1 S«ž¨Ê`Ãu-¤—%ðš–@¨ïr¾>7#Ÿ´Ñ@”¥:¹…„*m?Б”R#h`*¶Î¶+I¶Í_.©YÂoãHzÒ¯yÐlQfITž–:Æ~.y÷ÕÃd•~†ïƒ˜FY Y»vÎtî@ÈÝ 7ºŽR$'Át‹<ȧH:8oFì^%+ÈU >>ÁLËJbY¤ôÊW³ög Ü?ðAÛ>k.™çaîr‘ lµãDãÕ%bJŸ3}yE™²Q¨ŸöL‰±Z…PƒÓøícôNš :ÇKëet*«Ñ/q2áÖo©¾ÿ1Ç #ß/(›U[0B×ÅœÛ:MhmÌj0QÔ×–ž`ÇWGýÝ>53 a€šU¶ùµ"ùÇ÷s7›<„ÄÃ-†Ls¡=Ê·HD8Ÿ¦-¬wq°fXýÒce{ªx/½0â¶z`>Äì²â¤:*¹Ìy SÄat.ÖæHPo„6?çùÝç—ÐlÅ~ÁŸwì1Sdeâ¹W¹!:1ñã3`“ i\û.úãfµ¾y°¶˜fuiÁ»Å³ØÅXÔ¬ø$Ù\ºÏÎÝê Mpa¬ª_‡3Ò™¥%Ø¢.`Kpô™–Sþöa¹¿Žlö`.Ø:È ³Ï¨¶ôõžþºJ)¡›êe^7L‹4× KÕ×H|ßËA ÿø‘#"ñ–<Ì€²eÕðŠ‹øõ9õü‡ÙÅáYV+¡‰žèËbª=§œÛç=M¨`¤)5¤v£mX;í;uЏQ`ÂxÓf#𤥉L¸é=S ±³Î\ %ËyU½}&ˆ¿ªíá<ž{#ˆøR}7òdµO1€]ðªpÕ7ŸE*ù¢ â Oצ8UY Å’*“ÌÅ60u/ç1ÁHà‘ÏãÐÁˆ§¹\ð¶TŽ ¼çD }`'œ©‚c³¶•pÌSºqíq6:zÃöŸ¥JyÖË.çÎDI[HM¿!µÌйo˜ÝPè+5lx|ÿšëã+Ñf*¼R•ßl™îˆU´ìúª?+öÒŠhëùœ€6/'D攡ŒpРÿE@|£2L/¶üž%@í<ýSÃ8h/”I®å±}QÖÐÒz¥:Ýòç½@?kTIОMåòoˆÓÉ¿‰E2ýd¼ç,vœ†9k¬IÝäûŽmí%Ÿ]ÉÀòK!X{—£i’•ˆüÐ!ŲòW3Æ~PÌd›Åðj7y Ükç(¢š³…u·jÕ°ÿ¡-*ù³u®¤–Þ ÿ>PÄp°TÆAAš=rŠWVw¶.óYÇŽ ëܯ‡Ôù¯R­ð&È£ä7Éå*Äg—p Jy^€àºÊmAF+4ªQlÀ9X÷ÿûÃ9:åY70/sÕ“׫°œŒÃ!£ƒè1¬6çõýòLÞ”¤4ؼǎû“A÷5w Ì„©‡Ýâ+@$+P!'.fÎÑé1ˆ’ˆ2W áîžö¹T`AîT•Ÿ&,!ä4ZI PyÃÚ&¡WVŠ8zÕc;- ÔF]cö{aÃ% Ëþ¸D}àvZšß‘,K µ€xbmÝÏòíUíÒ‘$òN;Ÿ*¿ò–tLâÔ|_/ÍÅÑ”IpV˜«±#•/e®I_ oå?Ä{Å÷½®Rdë¤ìäæÁQÉÛ8ð{1x:ŒŠÊiºû ˆ\ÿ‰~á»ê˜mröz®FÏm‹i)HpAp,² #KÔÙ.¿øØ@¦` ‹>5ÀÛY–@À‚Yèã¢t…3ÓûK¯áþªiZÊ??Æ1°©Äïó,õ‚óUKa‰ô¬´AŸú ±Ìl]]µšCUíjÔ •GÀ¤13Õ9ê5-|\ŽgÉ !ÅaSÖƒb@ ñK26«]ŠcEa“ðñU« â/ {SjàŒur©æ´@ãNgÓj"_!M¾¹^¿a™ÐŠI9…½N/ó{]¾QÄ;Œì*»½Y2']*QÐ(·h†4‡d6˜1}è¶ÑÀðàˆkÁ^"éǦZ·]h à¾4ð¹Ï:ÞaÌp ;Üz)Cd·õ±unŒj‡udæC‚ˆîâcdðz5w°VJBtñÍÍ( 6‰RêUžå á¤Õâµælq[5¶9¯„ËW“‹Mã¸&Ñ´œg#Eÿ±°kR3?eIi´¿CTÓ“OSá̪¢7X·•—d£›ÚÿP5[õV ¿Èa¬¢b§1=±ÀgfÔ§„4t³’zÀÜKV©åD¾‡ ´¾o”f›/¬íä0%øÎ¾ƒM¸/áö±x­öV:Þ¬4{&j›Z¨#ÁV8Ò=½[³à8ÔyLÁ¬þƒ4t=× 9”ùó €u6 ‡@eÛæ'þwm,‘Ø=`Rn jWr uKÍÖPÞ/ç¥öïÍøkàS≴©’ˆÔŒ]õ>Ø@}®÷1e ÷†ùù‡B]§sHQŽÆ0.aƒýÍ|Ðj„]Þ’qßY¼†ño¸Í‰¹ø¼ÅM **•…(r»7‰Éˆk)ø©¹î`æ“’Æ$®WÿÎyP>ÄÊ'nx1¬;(c°ÈQ ôäõΤPáñò(€¦á„ IMª€"õ ]§*j•¨uÅ}¢g¬7‡"qj= Õy AB îôÆ34àëŠI…7ý®†ìÌ`¬Ø;:ø¾öOiìÃØÝ>Fíy¬™ž$Œ¿;°ËòKªR›¢Pv1wŠìJ;Â?œÊmx€Vì—« ³Év<[Àçþ¸î*Æàº¦–^h¾JGHP‡èuXÆ„¿¶Èd ¿çÎkûXt†‘ÓŸùîÞè±7í^:ähB™Pž‘Óz4kꈼñËã’/7ž`àeU¡Õb¯,.¡ü»^¤yHÇþïLˆ¸/†ª?±Í„ÔVxÆ@6"x9æs3pb"JËôÛ åûo33²Æ…Q€mO™ìì-ö屫×»T)lU³t9R”·D‹KÏJŠ4%¬MÒFmz·wVZ€´žÐë+@øh¡YâýÓ?É•ãÝ/G {¼.Ng !ú§Õ°+$1¡ÂÚ#툌ùÌ ÈT˜B”ÕrC®.)þ™ú0ŸëzþêÿÅÍeBx?ÅG…uòºn“Õ'ëK?» 4]˜ \>Xªˆ˜Áb‰úâ¡…  D€úɲú¥É˜`"îš&o+–! ’Ç%ú)…É™XR,»ß¦ã¹ß;þî9'†Ç·²A1¹èf ì–¼&ànæã®CÑJ­­ •á‰ÝΓõB÷]Ýé½ð‡$|ºludùö¼„$%‡Ï|àøV8±¿% Q]-µ2ŒÓ‹¦4¨0ÿL:׉ýÆ¡ñ÷HYFu2cz‚ð“9¢üNKA*ë~?ê½sæà­\o§:wè\”›8£¦W ­ ;- ò÷ØWÓœ©­i7ùÒQ?ñ•´·‡æ?¹à]aò‚uRm‚‡UµÜd-Ìàv¡]Aà®iŒˆSæ±Äh²vga<õãx |®xnïêó3-9c¤j>Ô‰”ÕkºÉjµ”xšzB¼öhUWV²DíÕ{%oóºwÉôçvî°Ÿ>ZO½—Ý»¦¥I.›Í¾²ê %ffýMŸ~ÌJÞ¯¬Ó[»Op…ï"Š¢ï(Â1­À:ݘeÄu³T¼[o‚¬Dce“¡~9&<¾Éš5 `$ƒŒ'!ÌÐL=Øàüw®EìÕ5ìö­AtVGl³³º9™DRˆ×i9ñ©Ñ<¡³†<Ð5Ï©S²Ñ8Þ]БáÔ+lv™)V?¯U·Â²<¡U2A&•K¶ª%YS²‹pPX® ©` ƪ6oXk ½En“4滳œJ©€þKv7¾­ÇgÍϤžeÁPÃ"ûU {pâìå” Â;ÜÀ{|yú`î LoÚ募Õr5wc˜l¦3õ†G‡ °ëÄØqÒì›,æ;§3¨ïiµ?E ¦ý‹ZQ–TF·c÷Ô&5ª.ÿCËz÷tŽB-çŸàÃb‘×9Ó™ …DzñcªëzY”Í|ðe˜j“‘žÌ‹ÂÜ5ã:ù½“˜†%ÉQ)AR†®àRª1s¢»\ºlqÛkù!°˜/ÃÄã Ô¿(‡)‹þô~Ž¶Èš-mô™7 S[«½F˜6ø†ÀÊ^Öã¥QW½ÿýdÖò^a3ý,º®ö±I©ªÏùPÎ=0ü-¨«7Ô±_ úx>yL¯Æ÷•ì,›(ª†EÔS•dôú÷‰w'RœlS$ãïçs4ÂÐÛÀ¤}LûSî ÏçÑ”MÄâ÷ð)‚ýßO©¤×uû}iæêÏÖHùUÆ+àÞ©´ä%®)dÁ†+#E¨â0Ü#@O2#·r{WŒ‡œÞ†+3­ûJó¡yç0­4*ÓT(Cóƒ¶OC{¾6¼“ãICæ¾²i3gÞ=ºNÌ:f–þà1ó 1B;i*¶Q"š„!;ÔäÌûý½í¿®UH˾k[ÇïN ÎzQ,Š‘»åŒ¡ÅYR»T`ò)°þLÛR–tü ·ûÙ¸òžéfºmƒhøÛOñ&OÉf÷ÈGÕ[ÉC]꾚ǗÓàð/4ŽnÎY^°Íi¨uÒŸ„ÙSÿ…Ī%†¯ÿ­û>ب‚¡pÆIÞÓ¡GxiŒ`tNŒ^eþÞ"w:äÚY b`ûq޲ÿˆªâ*£¤¦,OÈï|TðÍyrØagÍÈ*T“59S§š8Ü“Úží²¥µ´ÐNàÚ%Ù«õIÈ8¶yr02GÍ× õÎt±—²Q’7¤ëÍj>ò”£/|OÞ·øðüúq–,§j_I‘ñ™ñ¶¾O€‚™ 5*°êMJs Øc½Î;cë“ñx—!ÅÔ2`q‘3?_®äy³‹*oÇHoÇ® S/¿†Ú}vÛ»Þ½£N¿16‡ßúl. Í«æª8¡9¯ûïUôh¦‘ç .·8™2„§‡3 ß.oáã™Ã@®ø²lµÚ°|§]†uHÏB‘n [²“‰!©tR kÍœ7+D‘, a¸=Tå ¤üõ_¡é¥cI}êjÏá$;«¼B ]}ÆÙa;!ÜMJ ñúq (2òmš9£2Û¿kÁÝX>$á0âI¥#øÇ·_ Æ-œÏM‘™”§ŒNû2ÈÖ⛓¯¦ògUpì»fi\Gjh1ñ°tï sé*Y^=g¦Bø+ÝR{WxÒZÈÔ@.¹à«þHAçÔ«£×G=ÆU3QFÎø=%}P+HËïºÇhß6ñ¢Ãxå{ôh-Yx6R !|: í‘‹ÓÉÑ:Ði'̃?êã’æ}77)Òf"^.qQ]ÆU pæº(²Ïk$jxŽ:‡W›Q:|G#)%nˆ8Õü9¯™Hº@u¯àY}¦ª†Ó²ŽzÄÑÑƒ{oÄO‰iÓÉâÙþ{Z¬ëhì°Ék<Ó;ÍK$~_õÓÅkø!I…‘5áˤb?†g0öhéÌlÖUýiúÁ¤Ù¯ØßL²82PøµH/tÿ°žò&72¼~›š½ó`Ä’¤žjûa{Ñ*&€D ½ƒÈ|Ì»¶,œÜÉÆLe— EEFɉT»i™ R˜ÊQSèŽô¨A†hv9@@Šô^ΙÅw°|V¿(NÀEøú ‡ú¶Ë©X") –ÿr™•}<Í3Qû¥8w©Ý„òÙ ŽÈ¡uFûÊ×ÈHÑWG¬lá6œx±J7çB@"É~õºbv ‹&¼X'ûÃGM{Ūhײã’D"-@ YÜ·ÎåÄ{”ËØ¶ÜäH¯èºVSldoRO¼N·¿Y©âX¤tBp ´4tWÁ0'{k0ÑæX²ÉBaýÑä÷?ðƒgŽ,6«M}7°» ã!pïdy©¾Ú´mFV–Tï€ ƒ= 'ÿè—_¦RYH~+nÄwê¡°Q<à»Â¶ºjéå­hÁ«ˆåÒDÏÆÑ·Ý,¿}J5K/²àoEtOÙáhý®E"Ÿ }‚§oî4TÜâ$Þ‘KŽFY­}mD:ýì*,4;W† CÎ,€œ‚Hs'f ¶ â`oB}qýÇtû:¹@SÄwÅ@gÅx]ņĸ0±  °Yø1*eP!Þ\’ª>#Rênž¬•¡;:$Ÿý¦÷ h:- SZ]½>^&:ÕíOt6QR¯Ÿç2ÉjETë*äH™ 6Èý ùKZsÇ%{4–dï—ÛÏ)!w½Rø¡ØfRÀ=·õ{ Óœÿ3ûGÓ-Ftõ"õ’̱ Î3¡÷Ή%§˜ãXŒ/ Ý^ç¶g7_¸ÎLœhæè:ð)%•X."ä œ )`b‰ïÕðhìvUÓwwtT^}“¼¬$›ÊºDio7+tä1€ÕÈ•ÏXz±¤Sà†­ÆYÐȆòß^åÇŠpC¯R£W¡†—%4À$^¶Œ!És·m|·4?@ÊëTÿ+#y¢ÞÑ2â±Tš#…‰ÏÂ(D%gèÇ4ã>Ÿ “J×WJÉxýÞº ~Suº§™Æ%&v/Ÿ¹µS'‘ B%ûÖY·''Ô]Ù^§ )š*‹ÊÉÔ€KY®?îZY· Y¼3lû¨fP8‚=$²ºzT‰·à”.²·9_½#P ±kZv½tª} XéHÆ$f•Ñ|}9丕» rgÑEñÎ$?9x³:÷ R»»Eê^f¬#ñLdamaXGr'B(P$ù„lñ•è˜Zay±ïÃ&ºåÃñÞDÀÈ^£°y9Ú[CTÙßĦÜoYnÎÖR,Œ°ÅVš ~?–V@‰€'ŠQÊ<¾‡ÆR #/UÄ2ªŽý Í'Ùâ vlp—¶bÃü¤D>Õ žRYzºm6]‘D'ŒˆŠoP75ÉY6HƒZÂüg_$ts‹;ž=.yÌ>¢ÒŒÒ5ºÝO¸Êð“ÊÒsd€6"ä×»–iŒ¡¸nÆ;ã‡æù²#äIÑi6µmº’ÑFG_ƒiA)ý™=†ˆ¯P· 5‡Là¤ÿpò…ñz;1ÕÖè´æ·—®4¡=&šÄôÀKЧ¥ßä†"@÷Ôð‘C³¾)¸–kÀ<æä5°å' E…ÐIlRE½xãÕ¶ªi‚èb’è 4%§ F}ÛŸI×ÙŽÄ™ýúžÿnë’CÓ‰zy}¸Æó—ÄWPÈV>Ý1#ÄJµJO¢«•3ŠÑÅfå)È:çÇ­ ¬ ÃàÜØ˜6—áÆ@•œ/>ð( QˆÚße%4in¯r7O{&Xí±¸k°mXÑoz|,äR¹Ö~ý[w”D*  ò‘,|…žó–çzõµ¶ôÏ6–ÏeaFý;,£ ëmêU<Ӏͣ'¸µáÔÅ:†2¾)šµ>…Ñ™“ûç°àGÀ©‹è½ëÎýÊ=_QÎxZw<5},˜6¶O!Ú ¢ ñ]º31B]ù-ˆ8•8AÈÓñr  pÆòØ“(Íéh¦Ôêh”Ú2Œuï´VOB>z¹ÜYvÓÀ”Lˆtàþʪô=ÃSÓ"ñûÇ#aÈ’Ã|;²Û)•Ö·ñl]8i1Úä€$x†Û Ø~ær½¾|¦±“ý„§Yä^ªSãòÇñ£o¤Ù9ÏC¡zMÚù P YB7G¦jhŸëàÇvÂüÑì1R¯Ð W½Ÿ+~9oÑ™ß9ãn~íݱ³”yh&ˇ:…D;-Ôw×™q£\z;ÆZ6ûÉÄIi×öáÂñöxCÚpî|›‡U•É;í“nøÍin\hmíòl^:(ëmkÖŽÞ ñZ1Ó¦ç…$_\ÉA½Jý'¡uÚ…TmÚ¾ ¿w‡~n"&êeÉv9øÔ¦ÊâîbŸN9Ö Í•ðîZÂì뇭º­ž²ämÖAGó&s å…3W5‹·}±¼šÊœ9_ý÷aé#WŸ¤®v渷¥JbnlÛªÇÙIì‰ã=ÝåH²•Û'8ƒ‹™ˆ}x?¿0:[ß, +ƒçnìèÌ÷ßaŠkr5Ý„ør»ÑŒÀºõZøÇÇâÌt玦–G¯yƒFøêMiØ"F bÖi…õþ›ƒÄv¶Ð^X½Æ{òjM«g£«¥#8”í×úó?ÌWBEŸÍ¹eœ?1ò<Òã7{D”æƒYàG+2 aªïãSý=oÔ.Æëì1Á²³ÎD ¸ëu­·"Õb¡ÿv`ÇMQ?h AšxïdÑÿæmY┥ š§ˆnZ¶´üEÌÙî40Њ;Ì7uÖdu—m§Ð~‚ë~$iò}boÅ¡R'¡ZÐ7ÏçЗI¸sùk¿£î¦VùóÎj£ªÚ—ŒY]‚ì¢ð™"ЙHçÏÌ>Ó·®:þj÷D±Kð}}„·‰JR}LæRÐë]Ó7ŒF1Ú–ÉUËɶÓ¡+iØ™rláÜq¥î+œ±HaJÒ˜åøÏµXFwéÏ}†¬)kÉkÞ?í¡¶„O7*qhr²†«l™Ñ;›Qr7@#ŽÝµ®}ÈWJŽi¨½:ÑûE:‹•fܯô]ùãà(j‹ºèäj*F®¢æ±¶+•ë–Ëûú@SlËÈöü–6J=U/XOTwoäxTý8Œc¤¥÷ÿ¿T¨eÙ^'}Ó,?NX«8 5í¿È}•ôÜñK`€2]i®!/À틦Ž98a·ñX½àgÚ“rÙͬ“ø¾A{àëäkª4Çíõï(‹÷%túá’fmõ-º/ËòVþôñˆ tEC”=1Ö× på_¢F¸Õÿzƒiúà¯íbÃ}:GôüVáÕÜþußnÎûã É~ Ÿc’å(läæ³Ä&`Óä& 3ï‹­¦Éˆ{­½!­47Jh6àéµp›Wp$µ3æÆ ñfɹ¤(i‡TóÖþP)aLî~´h‡W'¿[¶dß8î%ë8|QªÁÛæ–ä呆šF¾sŠ^"—^Xïb&?ZÄ™yŒKÐfiP%7å:h9»¬p-`cî={s`m¾<Ô×IÒŠh+ 10$ÔsëE"òÈ´leÉ®gp—{سª½‹)>§ k¨E¹Û—‡¹Äy¢i …NoQû< Xt 8A65ýširI^Òê•° Õ±¨¨.Ôé)°Ë|$/Ø^}p- H/Î’ilêõË‚b/èz|“™ÏóγRV 8²=7Òð‰¢é»ßòÌN½§*+-¥^ëbqÃ!ú-Xð°>jó×óæÝQ_åB‹õNR´XÚI/x ºЗÓÇ€¸×8žÊƒ¨>(´ºŠÉEÝ>Öyl¯¿gƒÑšRÞlz‘ø¶É#/ ¹FŪ‹Ðx¿!«µe†ç}˜ÐêÚEò¹¹Bùæ˜è¡«Í£|Kg™;\²Kk‡ÎŸ½Rð;¼cz•ÉæÑè iдíÂxá wŽïá1’ZÐJx4fßfuN6À¯ë¹² ^pÛM2•tjSÆgyôI·Ä€VÞ*.Èh2Àû]¾‚Ëþ’'nc¸·ô]®nûFê¦Ý_k§è?è±JãY]z,Mò㦟 ·­Pû|€HêˆùÐŽ‰Ï¢a뢣¾1Â;Qç)ÅðõôOZÿ'ÞkübOøâüQ´Å :l,-hÆ@‚ïG-¸¿†ÙúTö7ƒVmñcðÍ4ÉÓ¨T=ö}éµ´§yóvŒäÊ{+squM&"°xô'Òç;Jô³8þÜçŸ,,“©n°ò™@ÍH+˜ý´Ÿhf÷vXl™Ê3¹ãõ!©·œi[Є̣¾qãÓurÚÈ>U_߉^ÜuÃd ѧ/°p‹²ÕMÕ€:ÙWœÆÚP%IeÑ' Iü†÷ÎË ‘!rÃ!5”?NTŒ™…/ºtHB7 =ŸÓ !ñ±â$Wx¬íƒ‘17ŸÇñ !Tâ‘&[¯XÚ1YÒ Ù€±º‚زfãôœöGÞÇÑÌs£òM[اß<¿H.Qm±~í’ù™Ù ¶õ_YÆ9»&[i!ÕõËa`‘¬%¢œË±rØmˆBÛ¢LêkWæó£–Ÿ{kø×Q¸ ü9‰Õ»Ì/&lS(;¶¦¶ KQ…¶+«XæÕØÿ¤¾ßr®ø”Aª|Æ~v8¯5Ú4`ÓmƒOŠQëzO‘é¸" 2€»Ìˆ{ö-8:+aÏx?Éà› `±¿Ô­-•5ö+ê⫨­¶ŒMãbÚiöå®§ŸùK°íú‘Þ!¢ži;J @bÇ*÷X o!«Œˆ&Øçx¶LqÀºÃ[küë¾U@jjR'WìOþÆ€8 4©übz „ô;Ç=@ƒçÇfÓºçP}gÇ¢¯Ž‡Ø[>b Ep"ßâ¿£Á¤Âm¡G£2Õ|u…ÝñŠèk01û=‰$8Ê!äíƒt@‚ØXôZ8]ç… Ï ´m«ÇkÏwbCï‘Mõc8ÃA Ô”ËÄ0K(ý|ßGÖ¸h‰pLö’ãNq‘ç €Djš<æM™?bÕØ, Á­†:[œò#` r£°*ÿŃ¥b,¸p˜€Á8L-¨ Ü.ü$¡¶R®ñœÖвn`7>¨=Xæa¡Æ4 †ÄX!J+Äö.X䘲2ˆ!›JߢUù_žLžCøÝCê¹wE‹€L+ȽŒ¹\Æ&™S¸ dêä­ à—Ir4RŽd=ÄŒaùXÐ< FzW4û\Gäð½ES( ]Àx×–Î|SÕŽ·r׸ŸH8EѲ#ÞTkÏL[»|¡ ­¡5K5‚ÝΑ7(/y»ZüÔW⛨ù™"1T­/ø.Óé‡ù{ÎÿMa« ñsø¤tPA¦¼T»Wo»³(é•OIpºLº‡<ÄÂû®kYEûJL¯Îå~Áôñ•È Þëä¡AÒ/G²ÈØP]1ÒRF¡Çï!ƒ‚JNn†/»8«e9mÀ¸¬Üâçý©žŠçÑŸÎdq68å·±.FӪ˅\#¯*ÆÄÒ#àÏŸ TD¦ytä"œ×qÏÅ?Oe&{Ü|É0‘Ú|£º.îømû æAR£j-³€8q¢<»M ƒJ.ïHŽ|Q™GñÒ@ƒÜX`ÕʦjéPj0HiÚŠ …æ ¤07±Î³¹ÒÁâ Mbñ1.KÊJÛÕSuÿÎõFH½ÌÎ@D0]oײÇ[wA·Sê¨9%@ Ts:ãqBˆ¯æž;⎙²¢ÖMYëqkÜŒS³ ph°‰>ú¡Ä¯V ‘YH:„@ÂJ•‘é “ÜÇÞEUb‰;ƒ{ýLìu²Ê4×L;»œè[(tD)â Ñm?&gIÄ¢:ÌXëR }`$¨]v>‘¨o Æê D»Ía&¤û”¾'q‰ZÝMöÅR˜Ž7é.TÍIçgKÐâîlžƒ­­ð[qJùS“H¡Áå`˜1Ѐq>x;“Þ²¹wÒ ÆszåùÁŸ_ÑŒ¦uü¿kbæY¦ãä¯ þ © Þ±euoàêC„/T…ÅDi£‹ÈaMj=úâÈcÉ€áÎ'uD/Ýž]÷ûoq»ó(\Å2ŽjcFÖý´ebaŽ ø%سÀ(4¼KuhÍn{nÞ–^Vz턲ˆ¨ÐŽ»£bk2 ¨’.*Ôã\ý°R)›=d4 iÊ_n)Ã$Ó¨sfæµù‡µ.½ðÙ=7×G鄆ñeÆ*Iþ¯qL:`ïÞ?ë¶R¤Lä“cø’9Kþœ¯™Å!´~râê¤v_DÝY7ÎeMýTµq«‚s 0öi>O*SØŒ[dåk§°PIR­8¶— ÞÍÁ ¤;“¨>xÇ F†È›ª²Yê]™3÷ÁE,½#-åvɦ›µ½)žª™p‘ÆeÍOß_¿þôh-“ïç‚lýuœÞ¿ÄÍÒñh­pٛشápˆaMá",®LöÈÊ]Zg• èÇžBõ.|P?ônäó$âËMâèºÄà\r½Ç ýv3s”m&óŽ"ÞMOUa߉ÙsŒcèè) D”'°áÊA”Rç»kÊr“¿ÌÑæ;æ??þŽ\² ñ^v%‘K§ý‘Ç”­wÉgå“.$gu®ÔÃ4/þûËö°ÿ6ßé‹3ž¿œDj¯õ]‰—2zÙµzûÜ»ù.xðv<’A;8`rp’"òÙ¿q}ïÕÜ5Ör"kºß\›­3Ú0Ñ%q,!¶–r´©çâsßLRWë©s——hn=úû§ÉÎÛ¤›iw‘ð8¯,Ù ØÈà1ÞT VkÄœl¦àpÎ*"Cè?é~áš}èJ‚­áXÙ‚AR>(©@ë·ãšJ…ˆ¯Ê{úX`ö¬¡®8¹œÕHídGV¤îñ3ýû8E“~Ï:ÌÿŽŒ,vަÀá.ƒ €nu ‘.„aEž|4 W:–ðá„Öλ@¾an’ß(N®™OC§~k‘4íߨXˆq‹3Ò³ÁŸí²ö­F´,Õ÷hx"Ú£ù€‰ò-`ÞIA¿ýJ¨WÖs9s7j+¸ësVÊ%à¬Hd–|ç³~WÆYB®žéÄMjâÕ/× 3ŸTfÓÚøòþ´çæÉÃÛ Ð<€]‚‡wJ­ÆÎ_šú½•H¢`÷®ÁU±$$ˆI@*ªG‚Þ>-°ïííÂ!Σ®îÍ' 1þ)%è±Y®cI¡ ~¹½%ïŽWàjö`~Iðíô Õd®¬Œ«îq·&p8£Ö–ãb7{^ÕÅ‹6,ã¶sT∾f¶ö_ó+àã¸X]·ÛùÁÀó-ºuïÃE Å*Á-TÙÚyôïk}N‹ˆtŒ×ÙU}Û#°ÒåS›^4¿&V GÕAZwJNú‰¾´QeŸIŸ¸ab‹š¥‡ý2Û¶EÕã°‘_Ãaˆ_<”ð¼‹u¥çkÖaÖ’XÞëcï¦y[ITž'àòêôWû,Ñ$p áÏAæŠ/¢³Ó0Z0ÿ¿|#(\ÿOiÿË­¦­Tò³‹oa´gŽ”Ãì»eã$ùv¹˜þ%† mŒŠE1(c²o&ù´}”;hŽ G‰)ÓöÄ‘ƒr_æê&]ÑßÈLᤦˆ#Ie—ï°µ9ãh ×É”EšNòÚôe“ÿJzùÔL焯¢¿¥.šg XÊÍ„K®¡ÿ¼KEçq_Ÿ†×ð™+ž5áF¨<ÊRöÍ›NG4Òo'%øÉö_V’x<êç©K~v*W;&fþ : ÏÉ@7%«|>&å]FC¢lKûAÇþxw†ÑnÔ‚ñä5!„•äY=2_f»^R8is‘áA ÓI’¯E¨®=Y9 J.äý@<Üéî0˜åLê·ûô†ÐT.ò'jÚOçD É 6ÝÕ+Ôлe^Ž.ꃛÏ1f 4ò¡Ç.¶/nÊu5äùgîsÚs¥|…ˆ@©uö¡O#Nt$ ’èèsG¦±lŒ¹mÃÞæ´Å]û«ÀìEA ^¤Æs! ·{ŒÔCÙ‘Mâ–G•ÎΙ¬t„¶]Ú¹!‰Ã rô×D¹eOÝeÛ8}’ïèþt†ã1=˜fCÐoÔ{û¡i`Q[eçD§PõSgVRŒÏ¿?Ô¦y#ô¼ZD¨þÔMÇÆ4Ý z}‰Z<$æ´äE ’‚º; rÈðâÚýÐÕ“øIß÷¶c~ý°ø·¶¨ÌHé*6q1™Fª {ë%ÀhEÔUfvú¶qL¨¾õC¨„¬I^lœÄ5~è&$Ça¨Õ¯äCÌ8E=i/ÞÛD&'P ŸÂBçýèRÖö”RysÙË¢RølæYF \´è/†åÁ`qY<ÌJ˜2å…ñ·Ù2½Ôœ/¹Ñp…œ§§>jrˆ[„§„pÌ×ñÆÛøf(pËKævHˆ’rž¹À™$Óì•&MºæôJïÒð¤¤6â›M™†EýÊ– »ÄD[vØXÃÞtSº$©›úrã…"gÁñ">+…u†x#ï¬[ø°\Ä4ü¸R.N[óRtÄ0Fï(<3‡¿Ãî9t*Âpèˆeuv˜ÿ\ùCc FŸÄ‘ÿÀLJ{Š+4åt2Ðb±Ø\H¿âŽÉZuWøñl,;îãÌ„Ý U'yWƒtÕ¹dŸ”€€@œ¯Ý‡²FöC5ÈçþLbo™6ï¿€«È«óå®ßù¡ÿ{Ot{ŽsL·Ë÷yÐ~f: â༷‰i7 3W.8 $,»¸fG€nã+$Ûì>ÅLsy8û–á}öì>ÀÉüÀ§@ZuÉ.+TÌPƒ)Š ÉüÌôÅ38þ€$°7ÕTe]0{Vg¢kÚ™§ LÈ "bÕL­¢:* #žoqŠh´þ…YãN›ª´Ý© u• #•ò2-úüÇuöÝ,Â×B<»Ð›·\ pï9õ‡úø›ŽGtb½Âo½áU`ÀðØ®÷<ÝåŒ$Í' šøÌß*j‹à‡B·SôºF‡ cpbˆ‡œ À·ã•į~PÇèħ„Š$‘G¿è)u&½ÓÔœ”.©;,DJÊôìDÚÀ%y]vß­:‡<æ¥yDȸå«äâ;J^° ØÆË›>É–#k´y„·’ŸÉ!"¨Qˆ³»¡è1AÛÃKÿoÔàñI¡ñå—Ø÷ªÐ¦A±ù'3ä ÁeÍ­(êÿIRUËY6‡{=hÙsÚ ¼o“«=JH@/û}ÞÙ1=& È.Ã]– w^o “ó¥’ëIœ³7* i¬–ræÍŒ‘iMómöêp€v,¸ÄFŽ#Wk·Æc¡–¸ïÅß~¢ª>P³ÇBŸ!{Ͻ¾*ÓõÖVFüÈ0§„X›úƒs97Á^§E›b€Ea>ËÊOém’pPÌS’85èÞ/žãizIlf\âçyUTCSòî¤ÞŸäÊ«E’@N§Å\ 9Ë÷2a›x™Fë kÉ…zÓU99ö9F._tc-Þ)ËÄm¹3TW¬£ÚEdŽ·;efÇë?Fû•VÖ}ú ±l8]‹ Å8*/…1‰a@7¢äü ?â7†œJ$’ä´èä,j›“ƒ_áwV µF‘C‘pÂã0Q»·èÞÔt8H {Ç CScœ™»~Ý®Å|ÞúØ‘–¶™ê~ ‘˜5kºø7Õ B…ï{ç=3C‰zˆ Ìl—߯üZ÷ ýŸ"_ã®LO’Ah÷±¨×Ú"è ýC«º Sö^ú8'dí.¯Üè2ÍqX¿-ŠV0_žÚr –Ïž=˜¯žk-àÄÂ%“>´ëî1æÌ/ I=¢ä#”œª,¯ì pÁ4Æá¥™æŠïZõMfUÙØÚ†–Ãn5«.p­SnD”Ê£ï!¯ÄÀ´„ó»LŠì¼qÙJ‚ ÆÃ»öJ–Eðê¡¶ÿ^N|™cÇ[—[”ŸC•³kÓ)˾±I×ðemh.N̦?b! å ÚÉ‹ìWÜddÚpè|ƒXü VÔ5ø¹-·ï^FÒÔ§2]€n6}ª ÌÛç¶³K:¤eRæ›u'Dî:\¬''AF™Ë(›hݤL‘³fÇ h dÃgî­¦ÝÏ'~UiE¬˜¯dúüàw ‹e"ÿœ%Š=—.&מ>þYƒX?€àMFÛ¼ÖBJU˜`Œol¦‰™l¿6H‘M„Þ…ïK&Ùz›ƒ¢™XÆ }¿14ÚtpY™¢#›u„¹9Äxpý¯q (ê…­¶I Yä©F 5Oõ‰:ßêCúåÏ T騛LæRèEs'RŽdÀ®ß ÌJ] Ŧ·öq¡$ä"–”+Ž|Oi# |¢òÒ"ŸŒ ºSXÕl˜ÉZØHÊ„TE)éÍóW°4¹ ÈÊ¥òf‰MÃrS°=ÊTÔm;7 ¾;¿‡¿°r¸la‘ÁÉ-œ=žrÊ0L÷ƒ’U¿èªió}A4Û[SVú¨M³¾ÎéËÔ^†*dß¹? wâ~¼‘‡ztZC›¥¤ÓÄÙ•hS¯÷X€{³‘™¡˜ÌÉܨÿ¯éä™ÌY© ˆªã.Ÿv,&.C~é ëñ(2°ñ¸_%Üß@Ö¶ÀŠpÁ| ÞŽžþ$·ÝSÔ.±pˆ·(b‹€$•=7CS³Ì*“ŸúZl£Švrsi‡nIÀŠR“&P!×î^Ä]>D.Xz@f^G0 «;Í<ë¡ð´.ÅÒùñØÃiUSŽ¢£!ø½&#Y¥ èÆZû˜ÛÍ61•çW£ND3 dS–ME3QˆÓ‘uÒ©)†¥(ŠâšH@¾öçZØ£ÐpÉš×5"mDNÛ¾¯öYÊ£_þ‡ð0³£N•S—È>ª©Š1ŽË€o–J Õ53(ð{W›,ªôp€©úìßæªGh‘J\åœGõUb`Ø‹Z°sŠ ˆ ÿb18/–ë¼$Ÿ\˜ ¥ þÈÀ½Z­œxw_WVµä·¹»W»›’Ö¡gðoÓ—€Ã˜€2@ñÔè‘%Q(€Œ³†cºc [¨)ÔY‘¦ð.ú«©a[bӔä1¥3 ‹=¹‹ÐÄQ")™Î8°Ôí3ˆ½ÎQÔÁ&v¦;%h+ö„cXâPŽZоëN¯†Ý^ú²{`·%çÁçÔ:Ô…!ºïª=‘$ÒÈädÈðfó„ñƯŠüw‘ÀJ0ë'?÷ÍïÐjzò-!K‹°Û¶BG DRkºÏ5è·ßì3R®[|×iö¹eê,Ö´ÞEI“Å 1g®·®z3K89N ŠÛajS,ÿhívŒiS¢_”;¡Ûùk—>9nQh^¥ÞŸ‡.yâ·iãò@eÓ‰ñûØÕ‡óÚ“Ïéþ¹pïV\x°¬V6±;»Öñ/î–’ñÕ»àGWßã#‰ŒØ¿JcÓðˆ‘Œ]Î0yÔ¦ŽhüÎ*¥ƒ˜«‰»à¢[¥êòüò]sñZ¿>SÖ+ÑSÄ´í Ùœøös½Y}ÍGšØÁ þ”I¯£ZË£‡y6Q`‡¾³)êËÿ­eÿïfw"A1 LÖÏm_<Ít¹‘z.u|⎫¸½ {œšÞ â€[4*ß{]ë>–¸¨‰‡Së»S«;Ñ+ôÔÕMÒ`‚]>(ͬÍËznð"”ýR‡ž•F´Ê,}ÅWšåüX>9¼ç®ŠûLßAòOŸ <í4R[€ÝÉå?ôT¼f¦e‡¥àjJ1’#¼BÄÔ¯¥‹`=¤ªÿ•K+/ã•l, ðí°h^¯ãþiI©æ±£›bE ÞXV± +ˆÒêç¡ïºŽj~ÅNÍÀ‘3¡bpä§WÁyàFCêÿôésÑóÿ¹¡K¦ qÄ¿êJe]€?Ø:1Èò%­v<à2ÇYh¨hßà –˜7¨uì´9bÙ5´ÁÍ/°uÏv§Â'm¡>Ùf>ñ­i‰¨Ë€¶“ηeò¤óª]KŽÀšŽs/ >ð¹ytb½¼¢Ù,ØÈèf¸Ï®5ͧ%8ÅOxS‚fŸØ¨ìTƒº'tN»/Y Âeª]£ÝˆÓª*…òƒ${¡\#åw¹HÖW;Æ@AýjŸëßDÉ̉YßóçAÜ+#þgË´ŠpÕŠÃ΃¶(/å5óÙ—#J’îÀ\Ë4ü--Ò–âÞžVsÔ1í=׿å9ËWJj!-PO‰˜T\:+˜œér…DLWbj¬Ž‰.ŠÀ$A”N¥Ôk ºE=”æÏ9ó,ÇceÕÃ<ÿmÇdzq®i>Ãý]Ç»¸ÂîmteK±·!¨ÇÉûû„rƒ¥É]D,ßz’k¨WP!îi–áÅÁm-zäš# DJ ç —ú/yA”üç6ÌÁÛ/% S$$Ƕe8øiàh°ÿ‰˜<$ È41Ë@ê“\ÝT®ˆqŒë_,('u¦áÜ ïê‹4›.—>Ï‚Ça‰L‘ÅVó¨ØüýsVÃîöü\‰k#ªY¼éK£*”FdΖ©™ñ€Îu‘±õ.}—0 0ç Î"jž ŠÀè ìAd”AÞÓ¸ÎÙTÞ ÁôΦ· §ÎáC`AïcN:rì|¤š,ÏÞÎ÷¡ç8ªˆ3Û¼ŒÒ'Ñ‹åûí¸¤ÏT§ƒ»à;¢»‡N=®RHú8O_ê_D—z%è4žcÕŽ‚·é{âozæ<Óý¼ “ԫк¦Ê†™)ÉoAÜX3Ô*ìë)Ρò¹V¤Bè ÓÆ@Ï:Ù´tX ÒMë‘žÅøkb¡;À~0AåLjÃuɬa‚ðýøÙçÍ;R _Ák¼àSí®ú&Auò6Ðe¹›M×–Á—{²[ ÌñÔŠÐ,(F]#g”ZÞßüCg¾Þ%k!Á¾u†ô17Òš2N-Y,â©X²Ù*™}´ Š%k…’&ýd;!,¤Gzºðt|Ê“sÃ2JöÜ1…IË\úàÛ°À$<â¬f«o,5œM…ÔWÚÓŸj’‘«/m“º4¢^ˆ;»Ú2”+>ªÍ¦-a^­ÂÞÜ¢lìc¥ ô&ªv.á^q'd¤èWM† ?Ë\¤º•ÌE2KÉ;'c¾bku#t:Ku÷l§Rßw¦â‡91Qcg i¡—»F´Þ eË*ª!ëmCÖÁ¾r¦=gL·yøÈUUñÓ*­Ço©žÚƒgºy–ʨ#x:ež¦ªœ/í,d×4ʃTgS›¯‰ÆÆì£B°  ‘ª{g1ë¬É~¾™ëLbÒƒ'ï?+²¢˜ ¯±ÁÑMET¦‹U¬ùçàqŠëHmð̦ÁCÔ+&ÐÈ2—UÀO;w©ï1T*è-jà=ö›×T7œDŸ,=ÓVç}ÊuÉ a€ùûìᄜ7›ÚŸMè/•–´n)) ­Žÿ¡·;‚1\ƯnìÎKNb“”gç1Õ>Y"CâÌJ >µ#aò*éÌJµ-Ï8gTÖJ.ĦÞ.»³sùÉš¹)Ôg,ÁÕ”ÜV&Ý«´ÇÊöXËšž¢¼HÛµZei_}¼ r†l b}%uöÊ4ƒû¬Zîy}–kº^<åƒKmK¯|Ý A9eä9yÁ ˜:™-}²R?†%讬}OYªïÙ!Á5x#Â')aÞÒ%¦9¿ê÷m´RØ')0 ]˜²…wï8‡7¡{qû±„ p¿¼ž½B³ÄÛLÚ²ˆÅ•ð˜ %*›¯ ³V>&eRÒæ±ë6ç$+H§m©”e ngÀÄ›Œï¤ŠÇš9ëCz€Ü¶³è<3œmgw÷ HËN¸~ †t™xŸzÈ9eɇ•ôöþ›'8Ò‡œ 4QŸv×ûà Yán| ÔzÊl88eRÎÖ8®·ŒuCF_Ì 3´a!X§Ç91 <Ñ’Š©o2zúä`y/q?úæ"PÅw‹û»®=°‚¬AÕøó i¿èƆÙ8óð5éBϘ×¥¸à/w-L@BwÈy4.Þ1§“ºÂŒ¯oáó,U.{Ôg%ˆ&ÃR»˜t]ÿvªªtúQ0Ð¥úæÇg/à,™ (qËRí ô•|žŠÎóP󚎄´Ó¸ݳ.P³2T¹·u-0Ÿ ûP|ÿÐB†7fš6Î áçßsëÀCÑM+♾þ+·ïê¨/! ຂšà»`:¿ß¹ï]'Wwnµ—wÀ€¿ ”ÊÏ¡•lÅ+×XhÉØ¤à×Cw>Š‘+U5‰ {œ¤*£-‹¦õt?×.ºð^!åpÝOõ»ÀÔu· &æ+lƒ#ÇûA ;6wU7”Áh#Ì9¤½5Ùü]¶¯[7öüõÖàv­/'‹°,“‚_(]'ïÃÖ4Ç *ÿ5¸¡.°ÜÀiàt.í“ÛÅÂ:–蟴ª‚@;¨A3à Î 5šH22R Ú¡Å)C1Ð-Rݧuvƒo4Ü/"Áa&RLÝ6Z5¼Ò~ŒÍŽn'2÷˜°™m\fXè¼Òd<ê.[ðÐo\wºgÈ,îr‡öáç”Ð3)d‰µõ‹à¯3ô{¬m# ”"°õz=Ø^h{ÚŸs úë4˜>Ätz.$K..¥Møœâñ¾§Î]”<“÷ÉúÔŽ%K¶sõ¸ËÁ¼AMuæ…m_¸‘røal‘¯•‘.hü<ïúYåæ‹UEÅ~ÿý”¤d‘³lÆOåxUéhÁI8æè ÔsË,¹ÔÖ…dð­½Z^ }4>IÌã$áôÛ¦Î@¦p«zÐ&‘f%ËXmL_¤B0Jª`oíºö 9ë«=¾*#Bq+‚õµ‘¶;îŸÔBEN…1¹·£çþHO7Qœ`#cÙ±æ¯Äï1GÍN³àÛUÓŽÙ÷—åôç¢psäÜ$É·ûˆX2lUO`äÍ­|õp„ê-¯´ jnBà*îE‘ùÜc>¬Y Ž]nÈÖh݉û£Óþ°¡á½ñË2·£ÿ^ŒÇS÷ă0ËøØþû%¬B™}«»›ý/üég¶®ÅNxÒÆ¦•È[!šèé¶m³¡'®·®×æh›$/ž^Û«K²ÜP`”â5K™VøÈMn Û8Õ5`œqÜÓRœI÷Dïc¾ïqyxëAïר[·†æ/r…Ñ=¿¥ÏX3wÒ%L• Ki_Ó– H-p÷}â›æ¢:±IÝ(ï™=&ëôT½A0WŽ.I‹¦²‘ï§‹žváiRù´6ú~ýrZJ›Ô¼J:ëÙÍQÿ\Jõ»T3NÓã÷®­Qˆ)ÁªÑ5¿#‘jf§<_냋–QA2m½Í¦l¿‰ òõoNw ©¡³ÁÐî>´½Õ…Ï<÷¡<ŸBO:îL†T(ÂÌx)]ݦ…«zãÃYˆˆüJ”q3¤šº_ý+µ²¯ü+…ótó §“ÞH¶}x cm’(éÕ×)izÑÀ3ƒsV’î»Á’‹iô·ƒA®\ñrP,E‰,tR©‹ˆjH8–Þ7ÙƒÆ#ÄmÊ»Œù2:J®m„=)p²WÒu>íþBÕÝ%¡eûã¦+0*¯KùDO— •”!©*_•¯*µ]qu¡ÓvvQ­†fP2œVQ©KzAßgìä¸/H!D2Ý*QÄ•®(ÖÆ<ÀÔC»B”A‚±œ½:«t¸ñnKü‘]„™ÕJ¿×ùÜ¿¿¾¦ŸŽ`ÇJ±©x-‹IØn¸7hZj‡Ÿ.ªÃÖoßäÁ7côu+–/x€Ëqì6bœCk®=ê4ûvR”}¢êå¬Ú¨Ï^öPEqKnB“ŽpµÝÊx±š„ÞÑÊ7#Ñõ»¥CË%J1¨ƒ$LSG8hô}EJ·ËBÈhÿÜ&§à‡^NãGß¡æÿ¨–„åz4“ضHÿ@ 6¶djç£x0‹Kp’ÓY¤„(kÛ&ÝSŒ½ÎoŸ×ÞäÖRê ªYy$|(Eu|«‘c®F_V46\<-ÅæXYÃe2@WnõAêq™3ÝMãèàˆœ@•©I'1¸ºjrˆ]©S7d9˜Tüu$! Ñlrm4O)Ü‘êIrlXRÕ€ÿD&ß|d¿•t¸útÚ;m¨É+ Oü@ÕlŽWOàÈóKu[ÆûÀ ˆ3sð8 *QÙv‹°ìá,LÐ9Zdg÷š$a¼áÃm ÈîÙVO¼ª“¥Ê¸“?q@Oˆh‡ÆÇ÷ðò‚\ƒfˆøî+ÙFm…kçd&ë#~>±U€1×/à9Cž›`(»9k•"µ Lö,ú-Y‚¤/X®£A™Öb¦¬dr˜-t‘n‡ô)G“Z98³ ¤SmЊ|î„L)È«U•CŠ“JN¦UÕ±59 ¥Q—ãqH¨b\P6:AVr¿úíh ù ±ÿ_†…Ô™JxO-´W¡Òç69®O¦Ét²£ÿðbÑÖsÛ1ïàK柅Íñ´¼ùñPÆ|ØÇÆO§y B]ïKÌFækáÓÀÙfdëÖÌLŒÒõÆ£q0n%‰h,L¢ÿ d[f³w¤_%Y;—CaаiR¹Ü¡âhžÕõÕe߉Ô"º~®+´¤ÿPµE:±„Ÿ#IN¸œ6ã¯PxTkŠ4 ïVÈAW Uíln7Lû•múüÕá\SÔLÀWï¬LIï˜M}EJW·÷j6SC.2‘žôk54­§§¨r‰×Xm‚:œóÚhB­ÑO±þÔ¶<øØÓ¾ƒLJ/¹ Ô=¥¦“nñ}ˉ?ˬZ;GõdËÈ y† —Œú7² ÎöP Gê\% èTÞ‘HiHûŒ€Í‡ý–rç„ó—šJ¥¢ …Ò¯Põã1¤Â²'TõÿôÐkvÒÈñWØ\t e™Œð…¸Ãè•–Ö¾Ð~-ñ€KºUYò›Ëí°&ìÌ!œ]*=Èß(7Ö@R·øŒs`&¶¦YN!‰5ãîÖ·üÊG_Ͻ7îØÿÛPµú¹`°ÖW êÂ`ËÒ%'é#L²@h¢Ó *Âúl^4ü`ËÉƪuù+OGê¿`‹—™#Ì+¹OÇû®¹ÐA]â"ùS—¶`ù©I“[J÷š£>;Æ;¢X8@<æ{@eo„ôs"§Vp¡ÐoGû¤‚êÅ{^z0yù‚ºŒh¼¼æ«@ȉýí+Û—¤¨-Á®ä ±•#ÏÚ0Š FïU@ùôàkAW0-½…¢8 †šÌ@ô5´Äá£}ì“°FåG8ŸþAE/ùKD â‘Ü”xÁǨ±³NÂ.)\1ø»¼Ê]„4ç2BãÖ#T¼ßÈŒoª‘ÉSïò~'d†¿OøyÍ\Hе¦y¹’(l¬`ë…•mŸù ÿÚÒf†ˆB7§Ç³æè­gŠ!\CÏUÞÚËÿ°£šÃþµ\Q;×B51‰†p9!<3„ÅDZLL=ÓEsE/H°U‡)ó*½n;³|<™!ÿ38 ~6ô?~še •²ß¯žEÙC$*)¬Œ§&üý9­T¹Ï½• èþJr™L^‹¼i¼9·«/;³çáÛ‹GJ¿™CŠö]3Êžaò5]rp‚O¤=ûé4ˆ@ƒ«µ'žôØÝĚі:)Öx4ÌKÜ)y©2/jAZÖ©¿á(Õ\*©ä«K7"ûˆg„+4eóÒ€æ¶[[Éóâ°ÑÕÎ/Uxõ£PŽ?ÖgªÂò3¤=÷-á6%úqÌc¬6_ß•e-'Wø0¾¹aÀ`ÊyåjÁ—Ó–".$»Šû/’dâ £3^#'Ï ÌðtEVœÕÐÜ^ Bú ã?û¬l1³£»ƒã: A“?ã4'Ïô8¡¨³`%ÂsèË2ˆè3óß—bê FBç­÷J±\|úâËv\1ê†s7=âgjÖO‡´î^›±èèÞI½$å8"Â8{ÒR׋MOçÑ#ê‰2{> 9²¿Ú ¬7—¤ž–jm”œóúcý£ðâ^‰]s‹Ø®ËÂr'Ó"hU™‚/Ö6®2¦TŒúµ$ÒàG‹4ÂT}°)ýï[°´‹ùÂÈ¥3IOý•ƒ ¹â¾®6 ·EE˜ýQ^%€ýû- òu§9Úë Â&L²üK”C¡[s …nþ#ã?–Ší)¤p”‡žìžª>%o†cuþ5Í>TÉY€ÌÞDÙA¯3c3!å1«6t×DÕ°(\Ÿ|‰;ñ‘” º|÷†®‚Â:\“vÏtZã‘B×~0œcyZT:Ó*¥Óa— %Bß±¬ê0ïpGíQ"ì:1#o ¨³§ªlÏÈp/o—ÎyIv¹ÜѼ-„¶]·~¤Îëô¡‘(ÔGý¨TZC…J¡³æûÏ»ZÊ‚NööDjpá«_v-×ùV8ûr+ðNîŽïò-×7Vd”y*vœ¼öŸf/¥ÃÄGÙÒ4ÑN!'úYµáKžéâ/’¨Ð->C Šû¥|ÄŽw“À‹ ›(K/Ó-´øƒ·Á´ÐmŒ;ŸTÈ{ÂõÍ cР—4HT†+½EÛ6›·N*âÛØÀ§ªónXØÞÔµ;ò‰WÓú’­ß„ßQ‰ÝÑââ#"DV+¾•ö¿/2úþñw^šHëD@Zú WÓ›ˆ\'øTT{ãhæ+ÅMÀñldæ0A=1ÝAúF7b_fø-ÏwÑûðP^Ä|Î^m‚–žñżꋈÌO ‘Þž·PÇ@º!Ñ[õ¯-ì°—ÓEñK”5z7¦’Ôº† tvLqç•×@¬¬Û¦œîýGsŒ¼CÄG3öY•IäæcW:aÞ’þªöX4Z‡­Ü-Ìb3—x)é©Ö‘þ¾­?ü;²˜ˆKÀ½›©b¨YSø(¡,ðݱÃCÏç±£ðî\BZüeg$^:SáÞ!)ˆ¨»g˜Št¶-ÁneJ ³{¼L6.Ûü›=aXh‹E—޼w@lDCÀíŒã‹ŒO{ÁLã^}¾I[’Ñ$Wû&Þâ+͆ ḣËúˆé—©¦S^Ÿç¬°cwsoãiY¤»¶ÍÈ’Ÿé¹ÁÍ7Kк3rN ÛšÆsİÁäâ³–.Öç¿)ÕÀ?ºÇ‘~…r3˜ƒ}Th •g¼§ž‰•Óf—äÈðÓ®ôà5ßÔ2MI/bkÕMõîhTMÑjÀiw—­¨@óâ¼ï?Ám[ÿ¥ `"xðËG—#…[Ñzj†:Dw1G$H5¾¤é/-ÞÊ%ÚâúÒ—cÞ¤¨ÁÊÁv‰w‚¹ž¸€ÌÔ·ó„C€ëXÒ†„µÛàŸn±è ;#ç0˜ì4ÅIU;ç]r™7se¶ÿÇ(Á¿”¹\_rYÁýɇÊ2Âp=k­Œ!—»9ÙÖÓÈ!CÁêô: ·ÇÛÅÿ&vlÍ:“&Ùt‚ÕW½Å5·îoþ£þC ?íp½LÆÉ‰ÁôÆ|< ›[7Kã&c >zèRù:ÍÙ6K#¢|!Ñ—e÷Þ( ¼Úeœá­÷ĵ¸(é§mh‡¬e —aÁiùŸˆâDºªªCÙ¥YÕKíd|L>‰ê‚ù²éIÓ{LÖ„£¢ ü<lÊà~ È}çÀH€®ý§€ý@]ýÚˆ“ûa ÌÉ¥ˆ©¿g,ŸöØà{$H‡o ²lxõÌi“‚a™² ÍP:ß4u´_âMnE씦{K²3:%ø³ä¢®êBhR£r1

îÏá0ã³Áì§ßÛFð|ïG:^§"¿¸@©“±©H4?° øÂIÈã^Àðº|t{y·e¿Ææž dÁæ^ÿß.‡Âò6àG-H?ø»A«²ó°{¿ý=Æ":É;{£Té[UçRHóT©á/ C]¡ÌR¢„Ö¥åƒ Xâäw+FYfËhœ =´Ý‹› ’p’Û@´’ßCSu›P„<{I^8 …Dé/HÑmØ"Úô=¾ùZó=ö3Âéäs%N±ž=wVæ’þ‹“†§|žË¢‹jþ.¸‚ÔvšÿB§G\¥Â{½9Ì@ÐO ŽL²ëV Gˆ=õR› ÖòëöH%AöÛµn*H'ô@ ‹ï5Îå>ɘ>Ô7î:¼´ tbbq4þÌþM³}&õWÃ9jÄ_TbÂ4:x’ÝPhºªsK½¶Þ|')Nz®ÀÙŠšâ_A⎠·Vø›ÆK²Â÷øº¶OÜÕ§¬DûíÓÐùò,}R´–‹MÈj…¡gQ7›WqÐw€²yéÂ+‹Daª\×ai¡nÄl@f€pžOž òl\MÔ?‹eþ¢Ð5sF4ñ7LÙ§¦K­ý/9‰áÁiЬùý b•}»\4צÆ(nê_Àƒ•ã’ª¸hÊ“(WΞJ˜˜6ÁÁ¤&âÊ)ÅÕ÷lWÝ¿™Âás[¦ÉvžÐ¤©Ä–]Øm¿þs?cdŒ‹ÁK%ŠšhýÇ?Á„2ìd^éÖô b9¬²ña°êÅ~P…GP (1 Í'Ùî|ïñòê``v“Cq6)§ñG³ûX $?ÝE¸†9Œÿ=SâÚñW»ã²¨k*³´¹­¹G¥…Äù ‹þJ£×Áv¹‰§çÝ&ÅQËÝáñXß-PCœ–)"}¹œ8+|Þ=ßϲ î>oaH tIqìë‹x_$„ ñ©‰d˜™ª¥ý¦úâø_Vf³1pÂe_`ò  ‹RšÅÊøcƒëÀĽZVƒGu…B8§´î:h®€ÓîæTÝÊ'EŒW±OåW7ê|ÐL§‡"^ãÉBϹy¬å$zžm G0Ý-ÈÙ†ÈGå Ð]ò1k’¡7Zµ¤öð,WGºÒè;[8c\²Dî7áîg^3©»œj§ÿ1¨yX·8‡ß)ãxÏlƒ÷ò´éº4R* «ŠLÿˉ#S>áÆÓ@\…¡‘=Ù*â$‹W% è oãߺex2i0ÊG=ànµáa»ã(V?q< Ò«nÃféOP¿¶aYô¥Ÿ)Š«îW@Ý•ÆÞŠ—Åé_T*CJÏ—Y¸ù¢~K‹|j¹VZîæÕ!Rÿë]x´¦ ¿ÍAó…·Tí'2©¥æ»—ç1yìØæ×’bGB Ð S„êÒ.^@ŠlØ=šÇZ!¬J£s}±©Â™þiW %á…9vÓ0Ë XKÓOÌ¿]|F—³UÏ‚zŸ2ž¡ x½ý(ßT s—zð-OV 'á)Œ%²‰<~Ôö¸s\²+_!Dc |ô¢”¤Ÿzùo¢@*rP§_ì‡Ã¾6¦Z¿dMÜØûÞà Ş @"H}Ê=­«»å,ùÁÁ4޾WÒÒ[¶É ¶9þäº/úìí˜vųÊ_în9šT<!öÛÅÙ r³¹ ™ž)EâL®Ý§P“ÕŽYa ›ºêâäB¬Ø{E!;SòFPu¢{áRg«¯À:Ó=üäƒsfó*È‹†o»2abÆOPßÜ]‹¨gÄÓÄžmz &¦©ßÕ'q¶C' HŠã&Úq bíT§½ %4Z?ô±÷˜Ô]!×Ê7‰óBŸ9$óä  œ5û–çq0Ü8û\³W{.^c¯d)Þù!D_ª¯ˆ7™JçgCØ2év´§„ZCÁέb|nûK|Sö¢ES{0´!¯ÿ"Â𖸿xáP¯v3¸ô y¶_'ƒL"J_™MMÖh#Úi²Ü%C FÄ QBt•Q1¡üFàJ>±‚z¯’tkR^ÐË>7¿õ¨× ÅžBÙwD¸0ºÆÐÜ&ùáÂDÿeŠNüÒ_Ë„8Û¶Ï*šÑ‘ֵמ0{¬Ÿ>j± ¢-vëh-®e[ö‡€«30—Àá0|äVrJòfvº³Ø]Ì<›J-Èɦ ˆ5GºxYeãÌÓ¿´í~Š÷­ý>û·v=r4Ð*= &/òò'víœúIH”H}zOsií÷êpÄõÃs/:8½)Ý'/bQ,[™'ÈÀDòƒPyòFhƒÝ2.ïº h}Ë·œ¼èÉz®†{™ƒ¦Û»óÙÔj ®Î팂0­D/— ž#I#Vu)aóhº&WUæûœWÕÁ4LÛßÁ‡bÞ„ûü ×(²vé‘nßÓ¸¢/5GEÙ«™ÜW¸=±Ì2 Wci„uêJ%; ¤úA<½¨E“©'k¬•óÜjë뎤lòÞÉO¶éq¿„ybý±óC"øD/+b«Øô7ÁQnÆã¸P¶Â¶¼£÷§Ž¶QÓïk„Ú6Ë{¸öGšÃÞýkÝò¶6b8‹>Z!„­QD(Ú+.Z>è\ÅNÏ'sâóLÃk§ÜYÓö¡¢íqûí?ðdH%^þ<ö8eî%QÍÞ®?*þz Jã~OYëˉÇQàÙõènš+Z»wù>²Ÿ\ÏýÂ߬b«~¸Æ ôñ.F=3¿šñCbTÔµ½ É<Øh¡î`U×߬‡`Oèü5õ›`cŠÐ½‘Ÿ“Šz‚JØQÏztÀô, šJXõ}×QŽûpÆfhÑÃ… ÊÞ%¨íh:Íæˆž¦<£’”ö9({¿ªõðÖËû¼ˆ«V옷d2ÿÊ‚~­¼¦FÑŽÐ}¬é/ ùá¾z¤|#ž# æÎРZ6$b¯áüÉ×Yátб†¢Ôeõ0wsÊeNDÉ ”–w:"ÄŨfsɇ@#æ8³†Â=c¨5ä®g­8Þˆ»dÄÑ5Џ1Lí&4œôf¬wÜxë b›•É#¡·­?–xÅ{F›ŒÏVÜÆeK쪜ˆð1¹›‚hÉ´V$qöqÉWÏ:1ÃÞ Ÿäøà´V8è‹÷’ÌÐðw3šÔÐGÓ¬¶ô~—â}±é8Že­í q9»ªÀ@YßI¶eû™i:Céíÿ‡gžÜ\r ŠÔXuVfBtÔqOM?[/δ–ëbL›‘´u¢èf=ƒ(‘á4& q’ã8Mz4Í#Eÿz.ÉJ!¬°jkÌ» þÂÁ5V$6U²œ&¤©ÑòìŸc«J325:&7à…l @ÁËÀ7äÒ¸Zz°€Úã#Цw™¼©e¤é4 S»#ëïèÊyÓ¤„Š`žÓ+ƒ Šƒ 0œ@¿w#ñ…ø\þ6ÜE7¿Ni •°ß’„Ãân…éS!÷ÆL ñP Ü?(¶L]#G>{öNˆÈHUzß @ÔË-Óà¼?Ð zëþXSŸ’T»8ŠÄ¸u‚0Êa‰f­©—]àU ⳈDÛIBš³aÌp©¡%…’5ÄÅBÇ+#´Ô‘Y²Kª¹·ØyáñésŸüå%? P%xÛ8ÃnÍÁ¦+¿Ð=@ÖÆ*å)\UãL#¢P'ßcø‘IA×ÞóýÀ« øwOi§¦ïG2ßÁÕ,ã¸end þÞŸí”»ßz %Š7r¯G5ç*ˆéœ'û¥ÿénèÑüFªu¾TýëÊò©pˆù-=’U/–ãsHz¢Nö‹z4XZ¿Whœ¢%?׬×Òt‰QªÇu5Ä„AºhÊÁ!KŸ0&m_ÝÞQ  ²U¹æ ^¿1òk¶óJp(.ØJãßË-qAƒ±? Œ:f|Óy:.#kvXjù÷DüÄÔ ÃÓíS?‰íîR×Q$_ÿt¾ñŠXÝ„Eq6èNs‚¡V|ù L›§@ QšðX¿œ}BÑðÑ·¬Å3MkdYáI66#¼lWˆ¯ËgÚ-¯ÊRhš)þ ©Œ÷»\“ÄË?N•´2+^øÇZÃŽº¨u ¦<¤Ÿš „\8È(³±I¢ª¦ÁS„;RÓÓí˜ùa¼¨àÄ–îÑè8¼["QÕcÖš´LÝ-0C_ÿ'èpµ>ûl‡OžÁ¹ §)ìá¦!¬QÒMÌ‚<ûYušnµ_¿Yiê00¡á$°Â÷f.žgвØžëXmˆåå“ãŒâBåèàüÆ59C›í#ò»ô?ÍÎ\€n°“÷ôî{c”5Úrbƒ—g‹ RR,²}Â=k%W²OR2FF³0~Eâ~sYMÎ^eĈf[®D€–åz66'Õù¥r¿9‘½Îhw™¬u•bú¶ÆÓmsFPáR&´æ NÁŽ”ÂêEl!².ÊmÆR&}¥JöÔ::⹡šï‘Á–;8IÍÆ§ë|8Xo‘Íw ìÅMÇñ9Ïö¦…ܹq¯ô ÿÀÊ8x@õ‡^‹ªÖl8ÒÚpñâGBÝd w¢lë#·Ó{¶éãÚ†ôŸ^÷‹ NÍLj€÷^+îñ¾sŠeá®c=‹rîÍ#I¢@­Áàì?™ŽÀ)`A1XRr#}Ý]ù ý·Û|aÇÑq6xû¬g‰g¶¶É[>±Ô2C«—Pè€tåi<û–¨Ú`<ƒ'å<+©Ž[gy¦_7Ûà·™c€v"ÿ£–>»ž«)dÏΞ~߈9ÈÅkR†6m³¶>Š›ËÚ|8KáÇ8?ᎈš€ÄNèZÓõ¢(…ñáõ1¢Hµ=†¶ç«ÈKë<#àN9&àAZĄφ:ÈC.ZÙ½<4ž‰ä†\P¯Iü—äœÆS´+`q±ù€m3Ã_F7îÉFŽ7\ƒU  êµ_‹\fË StzÎgã¨~r[#lšçîÈI­ëþH¦T|=§fz¾¬3Õ™Ùhº/Þ¾ªþÇ9›kÇ0  Eù玄O#æGÚz©ñàÄÒ£º5y¯påd¹±³¨ ³¦?ÙJ:v¨Xœæê*OŽƒÎ0'r‚*‰ %+l»*>h\+zè3Y‹Ù:\E‹†P%€ø)¿:uK˜„ÓÎ|>%“àXNçYrwÄ…•ê¹ç|C)Y¸ oa˜¸(^Ÿd<(¤™ï5ƒù²ª‡Ûö“eó_®ŽÐxRêt~öÔ«"…Ög¤3&_ÞĤÏÑè1— R"šM¢K4¶n=Ö’“xµ<€~Í"Ѽå§MiáRU¹QsÜðÙ×!>|‹OЋ<„\v7Ý<¦×ÑJéøëžä<7ô¡®æÇxS{]x£¯¶o€éóüƹ¦Ð² ^ǹíxJ•ÙÝqh7Éc6Zm#@åðBÖþì´"¸Qâ4lÎ:Ýrfò›:"tyùfÎ&¡)Q¢%âu5hü&þéQÇ,³-åU›÷3º~°DïO‰ab ÖsˆŽÎ·þ3¼îïóÄÅÕ˜Zjý"ÿ(vS,¨®-&"è‹…õyÙ4Tà¥5´ŠdVL̸°þ͵ư9àÞ¥QZƒVÜF!¨½)Ƭ eî6nxÝyÊZ ݽà¤l€Ý Ï.DV=êÍŠú£@óäÚ‹¿ÂÃŒî™~tYø¾œ*ù7V_J™VJ–ý|µ H!@ó>Ñî#1»ž0ö÷Iò÷Å ‹É(J[Š’Þ79 ’ì¥{²µ–mêû‘àLûÉ ˜t^¸´ ;S_‰é5¢ˆ†µc*ÐÌÉeîv Ø÷}w ¶°þ=í*“ßì=w¬´>—“ª8|åãÇúõÔ¨!Žx™Ò€ AÕ'NKÑ®@r&ÆÜ‹KØ|#@ÉÞ¶aoáA ç?ëÔS8dæµ…•¥ëZ±0 #Ú6ØKN¾EZ¡Ñ †+{E§ßy—F‹4£›EÐ8È.½”UÀÁN kæ³'ùŸªp4ÎõN!u¿Y]ÈQ¯æ¢¼ÂFŽE­—VU2²~û :Ü¿³X·.fR9šŸ¢…’>yKj GŠ‰Ãž˜^j¸—ÚÆ"Ôc꬙UMÀ>»zë¿%Õ3$e=aøÀ ÁE×a¡â‘¾ÛÅÕÁ±˜«”"æ×z¿XÏYBç•>© ~+Õ®ØÕ7öc‰xûoŠ®˜$òÞoâjK–ˆéoí¿ÔBÑŸý¬ÏÀ Ž'Kõ‘üÓ%ùÏh»#mõ†eÆ[¦8kÓa5ºв¤RýFL˜¶ ½êÁ6¥h­c¢_ÂõbŒ£30]¤­˜WÚ_åÑÌv'„×Q–¿¸ ÷lÉãXÜ`y²´µêÒ‡|Ý"4 _º Œ?-ËݾÒ¾ÆÌîðãªdžÏR{yG .ò"+57ÑKÕ4½%usŒÔ›1H{ÿ§;ñyW+ÖfF*‚€Å [5X¾Xrl–šR>BK d,ñêZW?zµË»²¯8È•½íáú€Ågð¦Öµ¯ªA¦›6Ðê8qÙ˿Ջqé(aÍš“{ìõPÇ¥ï#Ýä©îUi"Ÿ ˆôÙ2ý\§2ÿ¸l›ž|Ù†ç¦åéJ¹¸zƒçƒ©«Å/âþ‰[LU0•Ûè­þăç;ád.¹¤T„e=z›(Æéˆi¶1?š8— DŽ "„lú}Á&fúýh*œ Ñnnňƒ`‡eº.Ý]…êµã "¬Ÿe?“¬o|)»c绲œª&óÍÃ3ƒìI}NHÀB[R ¦"íÛCZŸ 0iË[Z¸ißïͺi ·5k=+E±%\W”!'ÓèsÏiौÀh:ƒŸn3ÃÄúH¢0[ÛOªéÁä‘Ë}ýæ59G”‡?'%šÎ »Ñ›wJ+³?”T*Rš#‡Õ‡ü©/w•N ¼ì‡^²cfÙ=KÓØ±’6¡œ>fU½zƒåZ´näÃE ‘¿½"EE?VAµÌ|¥üVC *€-Á¤-ÔËasP$øeþ1Öx¯¦lF†möÚi‘mžêš+û]¸hoÙ*:ë7pn¯< ñðÒ)½—ËÁ©õKÄN4[D–?±‰ ˜ƒÖq`ø¹›ÕñÕÝ„¤æ¿M‡B™Sl@”Ž9£Ú=,Ö’3›·jR¦'ãòn)T~.žsÆö;MSÏwݘ¨§?íÁ`Ý*ó¤scè!Îg«õZâ0ã5ʈQöžæøøÌ«T'ÂÖQBšáRq¿SbºAÝKªÞŒçæ–m ûØ+ÌïòT¶É*øÞ45‰ã¾t˜ RçÉ|w‹8%ÉÃ<ÍbI €Ò.1ÍÒ@C—hâ0þXaÞS¸À'¾¦«)4æ²dˆsSî Wp„ÕÛºRïþ£¦A½<þ`AH o±SCÞƒ¥¹‡{¡¦aÇÞI¹±‚ÌSDººW@CæyŒÀ|W¡À>®+M…ì,>¡}­1šØ:‘ Òfë£ xwYkQ“ÒÓ –Ð7Œ 잦`y'Ë ü*Ó`ñöÙþäܪ»|‘Åe½èާ‹zŸkL`yªT{s¢L%Ç0"ùì((ÅÍ5¶”b½LoCÕþɼ䈥É@X˜Û˜è4ó€>dqg¤!y+¹‰qòçûg¼Ü¾‡u/j¦í2 ›"°’݆¦›F¹ %p˜4æ4nfFž'¡)öƼ¥D؜ٙE 7‹,Ä N½?‘sŸ·a½%æÖk™1 æ–ŸÆíÈ– æ¡°è¦uá§j¡¸â–z.OP¶ú[èóÐÌ¢\á~ÀÐSþ–Ç©×ú4ä–5“ ñ ›Ák©ûãm˜ •Uâ+<•Ê’._ôŸ- ¦ö x¬Å",9x:àÒh qÿW“.xšÖºk¹Âõ~>÷ÀEFçGÝ’ÆÆÓ¬>›9§¼ç:Ç5ìÇDuË¿8­•1œˆ·la7 -Û>ž)© ãp ¿Ú.ÿCÁð2¥Ä¸O_¯\ó7¿È&Ÿ7¼-èܰÅeDE§¥ª¶XþËNœe§U®>ÁnŠaBÎjÛ­Î%ö†H¾mÏ ø¦–{¦:ÿÐîVšýÖˆR…p“Y|Lò(í·*¸2—lÛËLKá,½¸“Tá­K{‡Š¥Ï.7Üo­áCò— ߸£r#q`¢.÷û-i5ˆ'"Ñ‚,ž²OßÛ§5èëµ\§ÚP쮜YT§;¬ºþ4ÃÒ¯cû Ú¬W­«õ*]Æ[Ñ7˜‰Jöÿ÷kV„–åLîpÓ€;5üq ÚªÇ P—’ruÃ8µ’ž$_5¾É´™úØêçCª c6ÂäZ0Z2±î0yÛ“+*VÏôðÂôRo1@õÍ–)ñ\œ 1 2«ºË‡ZÃQjtÁì¹(Reâß©h‡‰Ë§¼¦©‡G0ˆ{®8]"ž6¶HU£JëQî{øÈ OÓ6?ç^ Vec 0±^šÞƒ"‹PeÕ¸ —)u—›ë)~(@ÕQN%¢eo ÜŒhŸe¤ VÿJN£b0»Mî*p Ë1}™/Ä‹¯’Šs¹» ›ý9ƱŒèz€l‰¤¢œi5GE’/ÙŒYz’OȺ‚„$³‹»™ëˆy¦jçf$|ÐÒº×FSBLÏ·TÒýí)ZVœ–(Q£’ZB¹£Õ3¹ÓÞ¢—kÌ2&#ò‹€XNs¡&<¸$OlKgÏÈÚΦ3ˆæ7nû,†£ÊÕ‡yâì\É&bHªê£ŸèKçÒèçj‘¡™bï]DÙ9»2q§d“`` ¤ª¢ñ[ DYÂøéþ||œÃþ„)"Û©®œ`PáË0õK²ùŒß‚¥J+(•-K;h‹v&rg|¶h_•³ÆsÁ·aµ’J$ÊgÃ;4™õ^´–y¶–ªW—î:CU+µ¥ZVÃÛ}a' î½®)xÛz Ã=èdûLFêÈ[S>_Î@Bz~¤÷2óî²0åvÆWødµlqóPvÅX\©àŸú¡1Uü}¿¨ã¦}<Æ€`QäÏs2Fjýˆàj#Ñ:‹}*4;Ð1+~~# D©fÑùð æ ÙÌs®l²{r%DÙðä0ŠÓF¼¼V8Mt<±¿EÕúy§krÃI¼{’³ú”Y]G´³Ò+…vgP2KeÈñM{ºp~C£éÉúž'SÙ}¬ÃסÎÎ a1h&nP'LG¤ÒOî”_Ó,ཱིé›ýzàrÜO‚1vã­œ²¨¥»S®4ü•᣹[%è¡9bXŒÁÇåã§¢½„\?']m”ét¥e§KÓ$K.Lƒ¾=;~²á0Iƒæ=.86/óÿM°Pd?jxuû.¸Õãå3­œº~É÷oê8kòËÖ¼¿ Lw'Z›­ÕaÀøx…¼gñŽ©$¨g‰¡là˜øå¸O .yλÖhÂo—à)Tq¿ôèÓµŸ¦XÌ4ÉÞ·/_¸H ³×„/øà{@t @ž·:w¤kA›íPÖóìü"Žàކˆæñ6g¯òzFovY ¯EÈ&ME¨kg|‹Ú)mÛ3×YUÿDZsqõ‚G%X—¾ðà‡lnî« †ž,žÀ›—"ËEÕ•–né¦þY+‰-½í½8C2XRƒ­¸…@O»Ÿ©™IfÞ ö½£¹k°íÀ²3˾ «ˆôlÏ•àc®Qo{þðîqÏQ¬˜V¼£ThVºõ hoç$kÛ%v“ކ&2QŒ‚½lÇC1õO;o7‹èQ³OsÅ_·÷¯™y&¤OóG¦@ñ$žWÖo“Ì`X•ìû`WÆeryYäžã4™[àšF¿!*ÌÆ ݆íâ2è÷¦!| é/< O*K¬p; ‹Ò ±dj°Ýß^©ÎF3'Ä_o‹/Õ41ÏÅOÛÀÍÔæ;3™l Ô£¶d §Ò&Ê”‘2ÝÃfÁ…%êËí¸Ö4<õ«|ŠÕ}aT,±{ÁÆÙo1Öy2ñmb掖ífEöþƒá úy£„.ƒÜº2¿:3¶Ö Œf‰ûzÉ{L…X<|'10ø^+ © Ò~£€mU´UcWA&M­|—É|):Bä…2 ÏY%ê¼.òZõþ—gýÏœ™’á~ðܬâØTªývl¾é^®G †„}‹CÆBD‘`öå|½ê…øD’„ƒ«0æ8K0hôöïÅ…«ô@ÞÆÄ!:@¢pðq£ùÓØ¶¨jp‡•Ã]v‰ ¬2BÛ6E–ýiRåÅqc9?)°îcûþ_oÌŽ·/ÁɈp›Œ×“`;ݯt[&CTkv@re˜ÝKôŠ^±<ñ»-Ÿa™öýùë5´•S‹e`D¬mW¢ºƒ‡‚Ðû¤2Iy&ÐyLˆdš³UÎ_Üé\怼L9ÿzKýçÙQá¬4Ó0.Ÿ’Ô’ˆ·­&3$ð™~îÆš$—LZsÃx>÷R»Aßf˜P2X»¦i%¹[½oî…ž²kÔ7_GYaOc­äëÕHÑ'¼_1g`CenÙbC`à_{\îKEfÜB­H¼Í˜ÊE[ »"5Ø¥™ƒ—ÜŠè Ù¼ð¤¾æ{¹žE*Öbt»‡ó•L–ü Šc/ž?™q…“TYù‹cm ßm) ø4Ψšso}ÿCÔ® ø:›ì(¨Í:ÀqøK™Œ.å,.I{{æÇÊgKMþªÊ Oݦ`ㇰûÛi¾Èi#Ýþ’'iQ²á"X:¿òêù‡ 3'Õ˜ÔþŽÉK#“FPú!ð•úé¯[þ"»Ò3•É«t}Nà ÞVEûÕ,éøG¿º˜ò°®ÖrìQŸG8w®¿°xÿ= svÁIoõ·n?{ã3`°Ç4²’u•ÍÙêÀ»§,l9úÉ'ï·oÛ”«Nß]TÖBÓ%Ý´%I„…ú¸îާ&M›´üóLêc;r¥ð6ŸoÙTžDé. Š4íÎmƒ Yˆõx_¸ñÓÀ¤¸WòDðŸAffc"ð¨X³T»±TqG8A½|¯RHÔX/WMS3ŒÕJÒÿQ:¡*T…çY ^ûÄWdâg|ÞŽàÔN¶¿ë7‡ánùàıXš; g”ÊgèãfPF¸Jÿ\ ©>&ñ½%Ú1¯QxX}*Ì?:ZÝϾJRÒøhÞ¥¨šáh´¹±~!ZÓ¢<åXéŽ<"qàñr\ÚuzY#Á˯"tú?‚Ïw†SËWÓ+›š¹ðàáAcd¬ó8iŽ"0xõƒr'kãÊïþƒ>¿ß0J^µw4ŠN ±„-‰þÓÅ’ÂÅPpáâ©4 s:µéV.ŠÃô¤¨4…2¡iÖÈ&&jMƒñ€¿Ëf+rÛ½¸àÖ º A™¥Ó*ô»St.lý6xa»ä0Oí¢?íȶÒÛ8Ïf/\‰‡ãB¤Õ6‡ÝÓ–¾ÜaxÏW¥^Ω¦»ÌÙü+¤ð€çH•ìÏàûóAN¼õVPàÜñ亶\Ñ~<ö RÑк"ìxïºR¢À…¾]æ:¿æ©‚3ÎÀaR´ÖgöSro*Àò<ìC®‘1ª)Pã(û•~fì!;£(“ûxoá]§\cAM­ÒŒ;þ®„Ö¼'äx ïëçU$Þ´½.šÀþÍ—ñ÷ØÍùGÙ]h_AŸ—–ì(t—±:Lþgy iЍãøàRÌ©•/ÀˆöÄIߨÆÇì6|tÏ£<‚ÆMb¯+wû¬cOI²©Ò›“ÆÓ¯x“cK‡{l¡p+¿(…©‘ø}>R`r­BåÙL€IN…„‡"Xi¢ËËH‚)É÷’píDþ8x‚—)ô±ž#ŠÐîê¢GÂ4 †êÇ– Òx42ɬôæ§…¶•ÌqUð ,õ=a˜b–Ùµ`´¬¥-ÎóiâºßþÔi^Égn…ܧµVdé¸T«ê˜ò+»hË@&·à·lVO YóBZ!Ž£M=Naßi^ 1ÞY»>Âëé-€ä»Rß=ß`˜‘Ý—M½™:?pG~|;™^Ò §ý ›‘ŸÐšæÿ{NhÎø7èTë¬NöÎÑåEë¦S×>?ŒªÌ£5Í–úªœ7é%”¾"ÔÜ) BiM×c²<îª8²íôPb9HãíJK§R{az1‹Š6)æ`cÓ'*:4±¼eÃ'õ~É“Paãä°Lú¥/ŽZ¼øµ¨=±§ñûÐyĨ›)˜ÿáC÷a€–H®Y½ŒUE¦ ‡Á`áÅbÒsa‘V±OÞè Aù•8ÚïλZ5ÿé`ÚOŸ=oÙ 8xÛŠ×VZÿ·Ü°D8R˜oCxŒ_‡æÁƒÑœÓ¥ßvDvçÂ×Á²ptŠÎ»€(é÷@—ñSµJ6Xþ¹a‚.ÐIº¢Ï7^ZfþOÜlŽá$@|/]Ë{Ï"Uþ._Ç–¼Õéýr£ïYó`9Hû¢™ re™+€¶Ðe­oò#°Æ™ˆNIlºÍô"Æhnšõ\¯4Säð…/PªJÏ ñºÔ! y¹Ymñÿ2šÒÍ‘ŠÏûf}÷¿áÕvr´*?âN›žH«~±±þçé¡Êç ¥ø›Agž` #Ê!ð’:ýššœW°Ë‰àåóìY{usd\XYí¦ˆ ™…ü¥N¡æ4×FVXA7ìX(”'À«®dÃ|æ¯ÏÄN’ò¡WÉj‰øÀa”ŽmBù\€¶« ¤1˜ö€E›¦¡[Ég~އŸ®ëÔç>ƒ²«E/ù1Ïk4Gf³‚„™9]àõ‡=iÔ:0ñ_Á’9៮ұ´ºw©d=ÁGߚͯ~µþˆqOëQÿ!ä„e„åÕ`T;öÎJ?Cêëî¾Zù/‡S­Õ*¨ TmŽð‘žj’2\³ðëzm ~Xâdšgµ(”i\• ®Breß°T%…ë¤wh¥s_ÐÜ죘ë(…òÏå‚,t‘øôƒ`eÈ¡-àóªË" ¸?µÅn‚ÈÖ‘h^w-Ÿ!‘$Gk £û %¿Íµ¶ ƒö5ª;Ù™ÁF^Vœûö^ÀÃ!>6æp»¤û„ä-[«)„àß„‚úUƒì‰!4Z¾4«Ó/‘×|{¦àìÕÁ0,ÓáWÑzK ûèZ hKw}d]ç˜,%ypuþNP¿­ùkûH~à幘ˆ¿¸§šK’CÔ”Ovä÷ÐðßðŸYbÌȧÙãtE3æÞŽ£ÓĨo•Äb£H²RŠãß!]8âˆ`¤D€“hëÙÊ+‚ýËT^Ä$`–'ºD8*j«Š^œ Õ:KR0p¡©‚¿€ Fú×È´r~¼³ÉR˜^&Ÿâœt}¡Îvß ¢åë鄿„R™öOIÐDzêŠOU«ýÖH‹qe5ŸZŽÐGޥ؟ÿ¢®€Xƒº¨! Î4ùͧ?ªC»HIÜ B%+Öü؈x·!¯=g†H Øÿ×@æ±O”LšfP«e)²??&‹Z¥jA5#İ™9Ï:’L£kS ‚e­‘›[Âal'c¶·/´Xõc(ƒî,úí3ȳOV$@wL§†!€ Æèµ´z/ ‹©æÔÝ¥…‘Wâ`1<Z,ýÝ,¤³AZîÙ rºÀ„ÚÞÊsI•Ô¨Ã{ˆ&&»€mxªê#L¯UµÀ7ÄöíµùÈ9Dƒó-ÍQû_˽ØÈƒùpJ‹kçòE²Iýg–Ï\Ïâðë×q*³žÛÉŽi@é §?éØ_ ïã^PÔî­5øÝtÊXfÿ‚Œ­Á‡àLøQà¸cô²5«òV?ŠÌí®œY¬æ;IŒPšÏDïÂéÎèŽüìUE7Ÿ˜·ÑÝ@Ö3¢7«¤íÐdãGÕåÒZ¼…X-Ä/ªäp¡ºuH;Z ˜pèÌ\;+ QÀ< þÈ>” ÕþA7À¢·‡HÒ™_²Ú膓ïi´fíÜâ$¦ |ùbà ǘ âö¿êñÖ0¼YW6ð%¾{w†Š” o§B4NÞ“ î+?2žp>áz«úLÁ»Ê0ë'@±ªl–eD4ò_kœPì–(fÄЦ¶LchÌ[ÆË½¬ ñ‹+fE²•Ÿ®{ØTw<Ýî<'ö[ñ>›øs¹vE†wE f ØÌýÐnÉÙp²ýÓÃg/ù¤Ùœ„é€,‡‘Eä.³çãRæ”Na‹‡HAªáªP8·Ý‹ƒ4m }ôu6y6(ьŸ¢q™ 0 &-?^—:h²¯–‡ÙvÉÔ¦ªÍPæ \;+Å<Z»V½xÁHª­ž»VݾcÁ6+ô£¥ËŠFÙ‹@ÍЛQpšfjÝ@…†À6åo,©]S”ƒþ°ý†~ï’ƒeeÉ24BŠ&f¾¹™ˆ­¹SåÔ‹×yàb9¾’Žå«¦BK|Ésë6äÚ¿9ÖåqúÚVpýšÛçT•€P»n]µâ\Ð}(Øœ/Žœ,/YÛŸªxfch³¨Q7Ä´]eòlíÚÃGÕuápeî÷üü»¥l’•ÎB¨šjîÊu¦ã-D¡¤¥Ü|ÜRC_SN>ÚhÞB—p€ æú\Â;•ƃ•pfêÁ¦Ï*•VÇFS¸×Êk¬bÝ+„åæÉå+ /#g.ãÖ4fr`&+ðô|÷çmpψtkPZp«’“ÀC^VÇïÅ.%©OB¤òSÄ7VDMÖ\<[±tbèkÊ·-Z æêŠ :g®|3káwóv²w쬩òé=æ•zV7ªÈ£ÐÙ³òÖÀËÐûÇcùý‚úxë/ ;GÌCC G¯výþÌK{5ýQg3‚%«„¨„¡‚{›¼ÊõÿH å@éaPìU‡æú[Æ5)MÂ2´¦Ê»–üM ‘Ź{HTÙûl„ÚÉiÖ¬ÙÍFök1+·Wßî&.ÁÄõ8¨ô±Ô1= sAª_óÓãXÀ9̃W–lÕŽ¿Úï{'§NìþO®ÌœBîTãóü¯á}ñ…'Èb¾ÁÒŠÆ[]«Ì£E `ÄØ­ýøˆ31Ž ÜYâä%:—ȯ:š/À¥'£ïªyÖǘ­Ëx4Ö_r¢Õ(Ns Ÿs=ža©Ì‰ üŠ!Þ Ö(Ø@x4 ^´À¹‚Þb#ëò?_-P4›ßI¦ø ¶L࿨²—«iÐôNûTŽ‘Ý뾂Z“֮йRІÐQ,?Ÿí¤X¤~Ã鎟‹úž-Än- ¤‹IÍOZ+~“'ÕôÈ©ù{Âîà‹lhR·ÿns¹]Z)|ãvÓ7ÎÓ MfV‰7iÆ¡Z*]’³€˜ŽŠ¤ëÇyïs4¡I“ñi…‰QpC :ÅÙX9ö+»Nñ„GUåè…è>"'gL®¾`m¨$¥“Z‹•zî¶!ù³Ž+IÇ+s¬ç ·ö>ez~d!1°”MÖ€€,6æ¾+#ì`̆°åE£LŒè¨ãǼºaºi·üÒªw}ÔîŽþ§ù q'Ú‡ &/ɵø’ðõÅî)ÓÎ Ø‚¡ÀyDožÊ®‰™YûžjzÏÍ>Û ûDm„]GÀÀ¢p³w~eÜJÁ¡Äœ dÖè*< L”DgÕ±w”¢æ$ ½ê©ª@-$@g{ž×¬:aY‹ÕG\cãQùsJEQ> –÷ç«ìom• ëmi­$ÐIl#ÍC™Î_ѱU}(°xeaô ¨BMW^ç߃¤•ŸT„“ŠÚ}¨›O–¬'dò=a1-!Bèò³ŠØJ¾Î¤Ë©0_þ@ƒEêæT·d^ù‚„jO¥$èÃÞ÷Ó nª¶Âù׫S#6/ùg­jŒZa“ÏXϡ崥 7auÖöQ}ˆWÌô¤àÜÐðj’?Åk\Lrõ¦ŽDZA¤L€¿ûªÈSr-P¿ã®hl††·Iæù¶ý;¡ùŸðÉv!þIJ3>ØQ¤5ϼ.{5Þ>Ó82ÚÍQŒ¾Û߯P1àÞ)Љ`f¤X»lÂSÞõBÏø²ÏÜý6-îÃK›é³YíåZÀ*.Oã_´"Ä7©Û «‡¹b@Ü€®ÝE83\çYT™™o}F~£mT¢È´wd Ó.“mcBeÂÄ©k3®£ˆÍû&*¦}íèßÈ¢8c^/9¢`´pæÆŠp[Î%ô8]#-ýÍ4 7)pÛ³6UËÆú] .ý´¶z³†B”› ø ²û\}Ñ2 ˆ@oT¿‰êßqB¼6¥5³£ë|:„|fl–Y ¦á=ë[`† þu Mq¿#)c·áý&*§ºÉÏUÐH#ÿ§Ö–é]Šs*.Y¯ØHööä{8ÿH©a©çéN  Ç•‰]#÷PxËŠÎõ ä·^±¯ÄL-JE^tÇÔÆ8d=l\ aŸâ½>¯U3úo”6‚*À[‚{æÏûœ©ùÃf‰³s–ù-;ŸØ¤{” ‰zÀŽgVÿZ¡ö„lv,“ãx­7ó‰™Z6‡?ÍùÖ'‰‚_¢é#å¤,,–þ°ÓÏ$P¹Ìn T…õ÷}‡"$Ъ¿HÅTÚ±ÍG:<, ê¿ó09<y»Z3|™{HXʸ›ÿ­ó§ÊY4ƒ.M ¡Db_¨uÝ0„ jŒ]øÆéqy§rP°Ÿ™ßa‘. 3GÊþýù–ˆâÌ‹Ø*šÅ…2’øð¡Ð vD¬Ù°´¨¯´‡úìGcÒ·F-xÔñŒèœr%X y¶ûŒ6~ÁN—Üc2ò8ÿ¡õ.n¸ ˆÕq‹×óM¼òPýxP6Ùß·§Ï·"eøtÂ6zReNË!ø±9Ùò=^b*+IºkÏV.f‹_N0ë¤Fôü Ø7ø(‰ÜÎð¢îØYŒ½<}`…|ÐM ×ùØ8]¯Ý%‹1#Š^ʯ¤£SÜ’§>㽩W ÕäÝÐvç§2žòƒ´Ë|͵Î&˜¶Ï{ÂI·X¡áÏZé®28¾™`#W´R›×©HdMܬ|4°Ü^—¿õ\kÝÀwÇëiñüµ›VvöÞöM”eÅ—ˆáaBŽ‘ø­—_Ýæ#‰÷w½_Æ»’•îÅ,ÄCõ²Ü%ÞÜÜéÌuŸò>ö Gzçh'jÉI~\R#” G• y)áC˜¡´‡=c~H#,½—6®“g•ƒ¾£«oŸ(}ð÷EÈüº‘2<È2÷xçÑÖôgãO8öº’+¿É><# t…'?>Ã(z7¯6ÕýÖßZ“‚‹JAÃëM1ËJÐ TýÌW/&Žv[ öõwÍÈUâT–8÷é>·â¹¬r0Ì.XW¥ÔoÜÛ¹ÆÊÞûKü¡¦,J´A¥Ó9–hÄr‘új³˜ëÑÇ—¢WÁvþs H!¹ÃKJßioÁîè†K„r1ÿÜñæ¢K/'ö\Bègóç Žs×-½(_:r?Þ(ûCÀͲÝI˜Þ´­yXvrÁ„Œ#?íû팠4ÿ¹k íhš§G9ñÔ³ÿƒuòÜ_°šVÿÓÒç¢>Œa1õq2"„­Ñï_ÄžÉØ=Š‘MÆ.ÊnB 94ÎöygÍÜd¾~.·wwŒK4Å3tZò‹¤_u޾º.LV =|ˆs%RøqkÓkpTŽ¢ŒÇÄC½õÈå·V󸔶ñÅߪPôJ±4ÚÒ°³ØRoÇì¥&¸[WÈÔ² ‰Ö«¬·E㘬® 4ô[k£=š|GYEäì3œ„Ç|e|hÆl{„ùì@ïÀy3®¸rËÿ©|˜1µê;eƳš$è›Q%ÛþjòbjÌ €=ÌûBgýÞ¥ë e9¨6ÊU§ÀäÔÌ›±¶å B€ Ê1o˜¤]àµ@¤ê®%Qñ‡cÝgL€f+f°ŒMV렠näÛ)óíS.Ω“þôåRs!¼[« -o×eMým°UɽØä4ð×o½Eë”ÈU¸èRƒ(É(hÞJ̬ø#v^ ¬ bGÊy68oâÙàôâ<~uÜr9lžógPiRIÅ¡mÕmâ#«&Ê‚ó¦¨l=¨'áäø=ìÊhûBâ¢ÍˆPÀe}³í{h»Ã@ÓêrHÊHù†Ø>†×¡2=òÐŒàñEF.9³Å5ÍKvé>xÎïà%dÄ‚[dÁÙX“cìÜÛ·~+¥tt/“dõÕ%‰Ž°XïôøzhF+KÈ»/t²¬'}í‡ ñö´áéÆçŠo\\ßyÇîìÇ´2ƒÀ̾¹m3\ùñ+w§%€•4X¶$7á_Á e’Æ©;¹n»Z8°ã'@ÏJׇ«›ÁëÂ#V¶ vH'î"ð4BúXdˆL÷lyö÷ò3Ñ IÌ×j ]¦gÞ¦œÒG^z"±Æ'M¬|"ÊSQFô=çŒjDØ=$•ôˆ*Ø\¹žB²þ Ç'/,½NDÂ|z[,Ôhî(jiÿ~Í&éu+HÎ1ßBqSVÑžÈàܯÜJý s@{0÷À;}FÅéÆ.Ô§C6ÅTζÆü•‚ño‰Ìtc„B# y¢ ]:Á‰Þvõ» ‚ª`í/Éag`×M€Ü¶‚Ö r‰HÒ"qŽ×ùüßw§÷q‹Ea;¿QΣ~úôÇÞŒŒ5#U³,ˆê//E{üôRã$Ît¿\ï¼TMQ?›‹Ãb8¸´Äì«qŒF£Êh%I|ö|¨ð ÆâI6ñ°ýÏê+¬ôÊÑ,M»ÃôíQWhfölA™‚Zü¤èXÞwÿÍ$SBáˆÝqM÷[l׸¶]áì ¬ÙBKbŠÒfJ‹Nê`µèW1zj¦ÚF.ƒËËâ4ǘ¦Ï@¥9yo‰wñjרˆ¼¾ó¿  ‘L$¸l Áøü¾W¼¨ñêííô•°aLQ°är´ÄÇ®yÀÛøö‹qEû:¤Ò¶Ò­à&8Z=ìoÙh®–{„¤Ÿ­¬#Å; ÐÕ†9KѼ|  M0|Õö)Ý=L,}ü˜Ž3ÀÎ.nNFÍœÑ+ì€+¢BNfÜ®eÊAêÜÛ§N+ !à3š'°âq:fÈb6à ²ÐGš­ü@=È÷F^'¤W3 î xß4ÕŸÇj¬¶ÓèPNa>í´÷ik$²šM™{Ú°övh̲rü:ºWs Ù'ïG| §ŸŸãu¨<=øéʯS.Xð<æ«ÿÎ’I¹Vø…£‘~jB„ £K¾é˜KuÍÂûûmþFõ[êŰ3céÏ#}ºón,âÀJíF­4¤xíX‚ t>ˆîüuf ´/_ñ% Iê ‡ ŸÐaC]àª3¯ú°DDZLÇj$¡*o«Ï2,bp™uhŒNÐLD€°"³­5æ´Œé` %E´.ˆDOdêòÖŽÝD½`6ÆÁ“ªtO/õr1ü±N¬×ö)Pž0ï¡ÜÄl×;™ë†“qú‘é:ãÌRcXÖîlõ*o1ÈœˆÀ›£0¸º‰‘1=y–‹Âc¿äw&„"d#Š)þ‚z[O§ÎÚ§ˆîb÷DÐý—"0m÷œi˜DRù5Fg)0Õá±QtŽgVdŽò»Ïm£­ÈgDã|®¦šÊö ØÈðéÖ¿ M®éS nìy!)¤Eûy³5ïcH‹PD<ë_cø}K­Ñã•#þ¥tšOk³Ðžaé`eÒ-ܱa Üž6‚µäÎÛÿÛ™¹ àÛúÙ2å牞ŒI¶œU6§íâL國 n#’KJÎBA:ÚãJæ­Z¶ŠðI¡ìáÃ'ã9{înOŒ˜¾!xÀ냙~¨x¥*`b¦­ù!ËJYä>̲·‡Z(.ù6Þ@S’L–WeŒx DobóæEA4r·¦:O@”#Œôõá‡{Ï;&kC3hŽÙíÌ5K¶'¡°±T?óÒølÆ{ °ó¤§3 ¸ÑﻉO“Þ€q–!±™íc ë úª–<'k¨¤K†_§ \âÎ<‰7Á²H“ä”mF}¦›YËâj`ó­O¸ìµ¢ƒuON í| ­ûRfbõÍÛ&_nJÑ'¾«$ù¶&bSÃB3¶Ûp.°ÍCŒfëô{MgÚÅu#1”±}Å’uUw[°¿¼Vú!”¨"¤6oX ‚h¤O{@´¶ª«’_oà+u'¿"ÌëȲ|ÆÍ²äD͇äšIÿ*²‘×n?&Ç |fC=Õ*Ü+ öØ2Ï”¥Á…=xÄ5£C!‘2¸æL UÃ|‡~ ?2Ë\ˆl§'ê”Jýí,Vë>42ŽŠíÞUQ‘K‘À†“-* cõz½©:€sŽ/Õߎ^ ‰d¨ºS›keZÔhá–FpæèY°’Ð<ß?4°P¦ ô˹¢ìiÿù¬•,Jñã¯./¼ƒf½<«‚D–­I带O±8XçœŠnÍ‚«G}°™ÚÙ“)©í…\iþõÂ|]¡:>ÏØÏ5ÆwÒ°Ò#K¾ŽTµ6ê¯E8Ü`v>‘»wy‹+b_Š-e²¬ßšM-«ã4WÆUÒ`kžHHP‰¨ /|·±'¢„uÚ …1«ÌmÐW…¤Ä=1—§M\ˆ$xªn²2zÓœäábgaHVÌÔªUL>B«+âT«R…=Y>n½A6=LCàÞ8ìRH_؈ '#öÀè’ë6Û´‚˜.EnËÒŸð+¾Ù‡s††˜¸*r·TlÇÚ‘-£nþ„®Ð¾çY$“w¨ÙuäJþ»_JÕáJ­Ê@úÞO½×Øf´®üÇÇ·šë„“(åAt”ø ç—ôª>ÙZªg ‡y ΢ÂgŒ7‹šîÁ“6óyú4²¼§.n©î{wzáÙy@S÷H…–1­m¬*?©“T~O BZèÜ3^ÛLÔR"U4cYJ~sîÌ_äšÅKÆ_zÐX%Ùþg.>õ àSv«ý] –Ëgâ“éìñOõïe§Bžu¨3Zª´v~Øë«×ÐÜX-.éÓ×ÔštŒt–‰ÈˆÜÒ4FÀz^tl*hT-ÏVú'Ë—èë ÈñXcà9•£¹\Eèé.õ?¶ c¸Kéµ _]G'\©H ˆ—¡(ÓFî;Jº?1RÇÇ!¢¬Š'`Doòó²Žk8zû):«–›G¡Ï^—¸ï4¨BiZHãÞ$ÝI!XÏðÎ:An iÀM!wÉ!ãd?б'8Ìœî›õ®ø|2l ‘,¥àò»d+z›¡¢•&£QÅhÖLº*Õ«'‚6HÕ÷’B˜£›^zªÃNnPŒQšû'¸ÉœÅ.ääBôø­àÖô£$Â(¡Í¤ü}1ì·Ö<À®8é„7‚³<à$zæ:žN椅ì60÷ è¦}¨@æ ˆï{*FÅW„›wã]²ˆ¶¢:ë!ñœ>áj]\Áa”h6äfÁ%FiW¶þ*®§¡#Z¼i$Å®aaª ª òïµ k¢Ùò%ãÄ't!/…ÝÄÃ×f‹òÀöÈÞÐL3 ª.ÅØú„6œyœ›$]ª‘£J°Æ,[ç?ÃÌL¯4<ö=ËŽ@•g4Pe’Ý'˜Ã‚¬`—Œñ蜢?³™nþ‚ÛCq'U9Q¬Ûƒ(Ó e¥+²î<Ñ(oÕô/í–´ˆþ# ÷Wá1…€‹Ùa·vð¹'wlÁÐ`!¶u[HFÄ÷Vì5§2"[ÛlVÃ#ÅE‡QÍú~•®¤Á9?cvGò|©¥¦zSk\1Fºá¥.û`¢á'¾›˜DPÎúÝ•§Áøu˜+—ju³äýµã?ky³öra ‘ª à  Mòiw‰qÄ]﫤»âm¡ë±éZ’ãO'·Š ‚ã8éDàoÒYZlwt•+FqÂÚwøÎÃ|@"¯Éb†&ª]p[6¨ ~Àж zãsJÌÓH1(4f0U{uT}Ów±ø¦ MÇ(¤\{ö2‡­™¾ýÏé#'FD˜×Øé ·9Œ*Ãq,)H Gm²`N6afüÏR8Ålz‡stTGñ¡Ÿõ±ÌG¨×â%À tÃF˜KYÔÎÕE{ß³TÓü‰ø§ö Ò³å_U´XÔ «ºøºêÀÑL®|s¶ÞEVðŠ gí®‹ëùüÎe½ì¡qDëëzÝpòÀù ‰“4û‰}AS<×ɰ U9!#¼¦×-ÕùëÁ=U>Ž £tJžJ(Õ†ÚvÀ½hüœÁn %ð¿]’½î_K| E”·[VÃå@›à±4‡’Ë °xHX¾ø°ÆÅÊëw(ñcŧ5Þ·ŒSÕø"õ j\Ö:áÎPŠè$ â ¢8T“ ¹!ZÄWòº—¼-Îq…«?î *½(ËðÂÆ[!Z ÿkLtm•#αLo…üív“QßœÔNÁ/µn%jp»ÃÚõ÷Ø,_¦ÚwÿÍàŽ³¡2@T7V —Évá&ÿ ëi†B‡A°þÔ4tTêœÒ -8—š¦Á9±öÒFÕ'©¡ÚÓo‰¬“·òeTÛ™"ÿeÓ™«@:0èb*˜<NQÞÆŽ–­‚MŒA½øÉÓ×-:w‰“&üÍÕIU4¶+˜IcÀø¿ 9‹9’¯e!rnƒ›”ûʶN»úÕUU´»äŽ}²f‹5§®õ$Ö¾‚ D=uî¹[«‚´ìŠõBÍâ«ÌÉÕW! Ê=?ë=—)a.ÔÃ/@œ˜•Óc¸'iö ¨xêÉî®2Ye¬[9+îY"C´€³æl3x§7K *ɪIr‚릒©f.u@Yo‚EfœaÆ•†U·¨XÝ3Ž`mþ°Rm‹2O¿3~—·»”o *UñI1øY-vÜëíÉä2‹ž/™Ê¹Mæ…R]Yâ‡Y½è‰Ÿá'.˜ôfš×௴~¨sv ¡ÀbFèñµ*ïíBÒ§pÕb@€,Uj=6èô6ë}Ý…L½·›¶ QnhÍêM c ÈóYA’3:>¬Ð}„Iilÿ¡|L¿+ÅŒ*bz'†„æ=ZäÉL”õ$þHKŠq€)·Ä¡1n_O¦æ’]²nÀç"Ï ²A²ÌÍ¿~æ¹ÿQUXTD*±sB€Å“Sµ¹íǵÛ%Y—ˆrûBß»r CYwʈÂôpåÇkw~6 ¶p2ÕqÖ'½6]eTm¶’М‘]¼€GÁ5ÞÁÞ)^­ í,¨bÑÙDá ]¨~F˜Â´ÄKå™KØëÉ[?Sãkðy„ãÊë÷ Ÿ¼3¿ðê”äå2zBšˆ‘D·Eèû±§Ú³ÀÿrX¸í–\ÿÞßVŠqP}^#C…™‚ ”:Ž€X B~KFÄ´Ò‡Ièía'¯«|¤õ8p˜i1€ ›K¦9²»‚¬/æœOX3? ’&R»¹¬§´D}jàHnü¾²‡™÷æ284“ºšã,FïÌEÓ5T«ç‚Š_^£ëÀ9æF9ð02;‚¤-ã AÕIúë#a·ËõÜ*`Îo#5±cxl¤cVêf<öŠv'^”Kò%“†4ü¼S6mg–‹t·¶~ç™hù m¦_5ÑE-ê—Ÿ"ÂN¦ÔiiCH“†dGtL+~Ï寻 H¿Ãs¤dåb$ïNSíÓŸËGÆÑ¥Áýñ¬ûR+òT™yƒ×¼â@ß·t’‡3¢ª#`SØä†÷Z]À޾åX ¶é™£½ÞãÚ=1@ì[h¾Á8É–šwWäÙH¾µŠJ»vÒ/â”´pŽqRäü”jÑWîè)‹yuŸ5Þ“ì9da)h¦&0}èLÖO:‘2WÈr{õ?Gc8ñ æv.8áXÏÀò_J=ÞÏq\Ò®,žmŒtš Lýó"Ž«iæ. \ËtÒÊ[z­þëü¤Ý`QòE61Ðí@$èÏÈÅÚ»!GN5Ÿ4–¡™†!ä(uŸÿ³I'•ÎØû2G'‚ŒÍôWÙ釖õSŸyÌÙ€žJv¹<$4±Ú ‡sèqM°9ÅŽ¤NF}ª°_+c77z‡$gÆZ„jEnŽº<Ã"þ1J=:ýòf`øñ„é§H-`¬V*èG¾Ô”7¸^CÇù׳Œ»|BèÒÝp1%újî”·ê\:±±Et^¯‘²ÐÓuáåee±¾’r†á9mB”òê*ÓߊÖíË2Õ©‘Sío4»Ý+Ï-Ʊ¹ Ð=‹  >¦ÿ,B¹¼y7™­aŠ‹âI6ØÃI”Üáźá7®ÃŽá’7ã÷(3zi;äRb_Yš–´±£df’CLã‚‘ÕHw_WlKÒgv^ýuÏ»Ú X‡S ÏÄO0Å ˜”÷(üVÒmü-ýÁ/‡—3Jí ¤Áè<ƒ&*/ÅîzLäĶF«_å/sš´ÁÁ}§ËA©Ö}ððV3Nâ0ùpy,¾ë5¢½|ÈY‘¾Âøn¼N—‹Êwalö¥ÀšäâêSß ê—³ˆ¬¹'*Ch´Lr39p‡ZaDšé`––îj÷ f*…‚üùÔ5©ñÅ‹¨Îª©êïà6='£éU/T‹¬µÅÍ·Ò«!Šâ¼*6ï|º³{)Ù8DU ÄÞÛMÊ¿ak B§ j¨·ƒç„†©Ë2+ªgËôc@ƒ-Öfa…÷"7³|¿ùW_sNiû@‹rB:»´>­ó•±¸ÛP0b5Çb8ÔÍáð /ˆvÆ,÷ä^ró+‹ÎSªàË&ÏéñÂ(®õÄüdÀÙÿâ?¶_1qNø°°‘`-„ãXÒÿ‹À±éD{ò‡Ã×'U’@ë 0Uä?È\rôS>9¡óÃ>Ô—¥ÒôGîa,3V”PP”ÊØ g;¤ðaÕzQ—Û\€RÄúdøÑ„€4æ„á;¹ ^í]dƒõ].hG¯º£¿±Èd0sÏ@¥ZüñC:±ûÆâéÅ£paJõ½&B››”lÆl+[<$Ã_ùtYðcç@#aYÒ—ódþß²{ámñx¥ôk©D¦ŸåçR6Iëe0YðwþSÅ„6ަPÔw¾>¿À¶Vºô5“3“âKü»ç>1M­É»ðn•¦G.X_ÑÜêOî{£ 螺Õª‡NÎÌÒ÷üi7*/Ñc>©I:ýD¬ë*’’z(kûJ+: rz<˜Ø35„,õ¸¡1ÎQ@¥«§±I-ðÑKº=HÓ&Ák¶[/jXµiäY‘Ö'‰ þ‘¼€ÊFÀm×i"1/Ê$zÆoÃyŸ w VdUë‹·ÜF`jå0\¿$û< Ûðe{¿ A¥Õé»á$Ê"­˜×Yº9¥L)×$ZíâÐáG v/òÿ~64°o(m¤X’€ö0€ž> AEäá!jüž©å·q“ø ¸‡[99'°[¦×Šü’1‘ô dz·î=pæÍˆ‡ƒ \tt=©º.á¾MÑï…¼fé¯ËÌŠvJ¨F&˜ˆP$ímW,„T¾q˜PYÇ;"“’OÜ#Šnõô$FÀœŒŒ]­ÚZßbàêdi*rÓô‘:p{ÞMç¤ 4žý4]ÛìS¡h r€Vdï‘o"Šóøåð ãE¼ž³iÒÕ{‰¿-ÎèƒR—Û°ö43äuÞú¤lb 1?úÌ%NCdIuÙÏÛYÔ©xÖ9ñžT6–LÑ{_îý°ÎbÌâÔɺp‚qßí3}`Á½#›§âÛ>„a n*nú êÉb²‡Úl|ß$j¸¡l¹ÜßAXŒÌÌ®àãá7)°/_ÍöëK“ùg sÉg¢cosF׺Õü¨tpЗ[s ÙƒÝZ¸:-ä¢&yr²Ç.eWÊçy+á³3øÿé9—øÈ4­øI³_ ¨'Ç}Åt½?la neºÙn"¬ç©÷JZSRÊîÐ .Ñ,Á%×½ W¢ãèFK¶mÜPYÕÔðFÇç²UÎ@*ƒÞƒF’ŽEÌQÿQsò £÷µ³tœÐÈ›]œ—P8ŒŸq]†æŽ°ôYKÞ7Ã/ýA¹À:í}HòAZ˜%s{_Ð4¥ºèº=9 VKüXÚÔÖ7>¼!L˜øÕóVL‚ŽÃDZπ“ÑV…¨T§{‚ݳÁÉkŒ<ª&Ò8fdã"Ùd(É)äøåY”¨¦–.«#6#¹³ë€f+ÁlÑTìÅrVCCèҀĜ¡†ä]]80…_Ê”ù€ßK àBn^ KwüUÝ#º÷½ñëèZ+«èùrNCç ;„ÿ ì¶m+Ò%­“e5<ö"ÊœbüäžÆ³p*ŠB* }YâS»È¼(œTû²-°*Óˆ:n7F * RõuÊé»q!;ïæ¶oV!J.þ]šž‚rãÊ×@?™¾Õ‰ t«Xòr“ïë3Wgk:Æ>ðˆ£ Æú'›ØøF+dÝ#gšoÝXwíÅ¢±šPÿƒ§Â݃§lê’i:5þó>ÄÏa&á[a'òÂs°\æl‰™æ›=O¦']Á£/£^›³!’q¼÷Àr™¦Þ@D1·>žƒk¨×–”™8Õ·³œŒKóÕ Eí… …(?-Ù¹Ywë^Ó½ÅÍL{îöï¡„L‹ù•)·]H¨ý1€¸@­µ^65|PmGð §Ta»—“ì ¥¬~væîÑÛI¥ð¯W¶àó8T½l?º/ð³+²³É,!‚EY“7P"Âæ%eÖaû=‡;V ‘Ä(¨ øý8õ ¬£RÑp§vh+q k¨ê™Ñ±`v©ai!mïÀ!'9Ý‹ªcöîa6Lðw¼ã¹Ž<þ {gjx·}°ÜA¾~_Æt –-Y’OâÌãÔ\ÊI"e. ™s4“¦±·9ŒJKÖanœÓµq¹î 9-=ÞhóíÕ50år·‚Í›¹×° ܼ‡sW‹I“Öä«/)ÜrØöŠØ?sÚÐÒ.Qh)ºšì—\-±µø:ôÇåëÚ©±÷•9”Â:€£Îã Cf§ÌeþÅL‘üÕ¾o!û»^¢Î½/Ååû Ñ“lþzˆT?uަ9ü©è]ò˜¢©ÁüK[´GúãQ”ä5UMª£«µ(¦,8"Ö V„εÁµ“’$üâN‚éí™X'h`ðØŒü²P¶Èf‚ÕÚÚUvÚ¼< š–‰8.ßI”•ZûV’7 ›Òð¨Ë=©ü*—xÅb,½F§an‹«ü|ëÛk§ý©Êá¸OrxXz|tÓ­zO@Pü`/ £ÛÏæ…æÝzOo±Jòoµ§®Õ(´ 9V‚J׸xÕé8üß âìúÍÐ$:'ÙÈÎ|½äÌZjé cfð÷ÛóiëC ?€ubÙ#ªmE*u:6=œ5P|éá´Ètp2N–𓹬‘Ü·é쪱/ ãb$ÉEæ]r2°S¾¨÷ ?µß|öý…qαqŽC"ñ ™Â÷•grŠëŒ&vòVæ?p»v èrNàpÎ×RŸ6QÄRŠ\*ny‚/‹ô‹gPÔì"n qa—7D/Õh¾ü3;i(7sÆ®7h²ÅÔÝ™lDÕ€$2oþœºÒ]ê Mt7»èÉtœÀœ°ªýtÎîl׳Šÿu7H”9ÏÌpõG¼Ê=o¢•b€¹)zÓr«®¸òÙ—°è‰LÐà ½¦ß©fJÎQ¼9²´ò‚´+ï)É)(²_}äy’°<§±…2L(òû1c/pc¦úf,¢1¾û*å‹i—e”¼CFpGëýsæwîÈ þà²3Š*¡µÇ¸êi;ø&ìºÄ—T7ý£©åžŸ%¼åãŽL»Ö¡”iôغ4Š#«‘qb|Õ/ÈÌcÜ Tµû„׉ ”ížcŒ9,ñAæœôä›ýº ˜œ°MÀs½·Ž JôþH³™n!¢ô ±,QÝsœ™Á€V­"7¸3=•…ˆHdnÔ| å ¶˜›‚?-Ä9VùE €¹2â´f3n]¹ßõwÖ§ÆIV{"‡ï*gqE¼íÎkñ³Nó´„6OLFÄæbWÆÎÛîÚ¸®/ŸÂ8-mäb£'>ÀÉ_@‚ú¶†N÷˜cDL’µéÒ–—JsàanÙã€ò)0ýñAÜ;wú-y¾ôäîÊ@òÂ&¨6"T¤«Gõ8*‡îO/Z”žÆä#Öá+?Êé î§É#ôêA‘ïÉb ¡ à”0krCĺ¥ùŒAw=qC9f¸-0ªqŸÐ>WçÎÄ’5:…Ù0_åc™%1alðG ç{3ÈÝ·ð£ù*Ÿå V!>Éè-`7g¥=Œ4|‡štC³ÇCça†{1Á—g8mŽ#¸|»J3™ÆÔEʯÑdIY^ÀDÉŽð±øà|¿¿5¥˜TÈìZjª®p²nØc¨nÛ—ý—åØ{d·© O;å†=ÏЀ4|•nØoXG]ÀÕ1Çeq÷…Í ÷vG2ÔÝu¥äë}Õ±7ó"3€„løÒ¾£º|H*au­MU•À‚ÅXs/À3ÇI{µ©Ö&î9ýR«ãOü8º¤Žú,»w‰0ýå׊‚/,´oQ‡;žºy35÷ŒÚÆßËÚÌ·£«K»Fì›A#"Îuë¯äV¿ÓÖ¯jýCˆfˆÄ>¸™‹ªÜø| Ã9×bšD†ü霤Gà@§ömÁ€éøÌM‰—¨Ì‰Lô©¹ ΟƒÆCèÈÈÂüLCØòB@ßáâ­ÐUŒ+C;€¯YÚ ý%ú©?2†ìïþÔdL;—GA*¢ŽØn?>(@Hfëœh‰ñ¿*•"S¡,omŸVK?àLÃxU^’º‡Æ°`Q-ÇôÈÇ%²âuÖ^Bûþû¡%P"ŒÅŒº/ŒüUNÏÆðì¡6ð{R¢¸P¢æ«XuK ¯à×>—§Ž÷7P|~IÀß¶¹CÓ¢éJ¶>ˆ*•©²M›ž cdÑôšmÃFé­j:žü®‹Ü¬‚ÕõCÁ-K$"ø˜¹g9¯ô+û×èÃéæÝáçeÁ&éÚòLµÉù*YïQ§_“átôß# Q1±ù>»u&n1’¡'éRÐŽ+¯]Å[½Z!h:²¡L-™´BbÒV±ê@nœÖÄv¶bË´JÒý\‡ZÉO٠ƹ»ŠðÄ!vÅçàÅm αTçÇ“Úù>n«Œ€g¨f£Ô Ëס÷MÜ|ñ•„«ªã×9ç•T8®[ìI1@Ø1EAò)‘Ð_ÿé6)J…w™±O6[Ä×£ŠmF½¶+ë$^€Ùe‚¾o@¡–V£€PC‚³“Zú‹PáÈ<;Þvüפ7˜4FÿyíÍ$µÔq³SN«…™ wp¥ÄN©v°iº.¢fÐtÀ}‡ÆWÈtº?U¬+ƒx6|7b£~\2J‘; á¡˜áLÒÕ.v6ëI²\ö@‹E¬@[šš´ºfaŒh<—ÆhŠ@#÷c V«É¬žÔ¿¢IZñ_XÁSYMF΋}Ì#¨ÇM+À/a§­ºà@÷¯Jfè5Îêx8ᚥv3•-J˾ÄÄ˧u>"ÙBgÁ—ñ¥þˆZ´EržÇAkLa™é™`v7Âqxáo nJ6m[–Ð-+°ˆŸáN1ùGÝ‘0ß5SýƒRM“îŸõBUÒzu ˜« å+œ‹Ñ”éM¢(® Ý:`ÇVÔ¯Ô˜¢Ð‚™¤g˯áˆWw%²FØ™'n>ÄŒ?¥i¹"u^ó fô^VÚâ^èJ³¹BÍÕ‡ž¿‘ouj·Š—Z WÆÜÚ2Þ‰7dŸíb¢šAŠÎaïiúO¡›öCå0àÊB¸^ÐÞüß3JàÕzv7Jް<·‰¯SB1’_bêä1¹¯Šã×®d¸×ª•j®îâ•tž°ü-kîM eæ¼âܵ+ñGB0¬ ·½OÏýˆ¾†íüÏÏÃiÁª =êûb7‚ÊqýåÐ(ìÄeÄG ®Ù.? ÏelLhÕ=wê¶tðñZê‹9g$ýz®­¥Òö` øÑÚFSëü3®Pù“•Ëpqð·)÷öEñ¦Mf~_)Åt]µX­Ÿš-P µŒÈå…¹527 ÀU=_Õ³”ð(øð! áŽ\.‘Ýò(8xÃQ–gª=pÐԫdžùùù€]MÝ8`êË M%R7‹§1¼ÄêÁÑ¢ü ›Œ"‹ƒ9UHÎ ~Ž] r¹µÙª¢©šPfŒ-Ø—[¼*±/°õf|vr‘ô¬b‘ó,Ö²¥£Ï*Nˆ/4˜ð” y•+jæå¼÷4Ò™clÒj6/9XY*‡;/tq?yõ6'xŠ·-G€zP9Ÿ^W¨Ðm‹C‹µ“M?r-ýÁÌž½u”çk£Ð¦øÍbWÓ¥a¤Àd_¹_L¾·ÿ¨óÎ𿤾 f=¢ó–æg¢„&Ô?“Üs8ñ|c,Mptƒë 2ÜØ'•Qsx¼MWM¥Þ5hç‘ b’)¦Ž‰ßv‘íÎ/};áš7w aiHo ÇÐð©«z†?´ÈªN‡ ÐÚÁÕ„ÛÑZ*ÂÐK¤  :ŒÚ²1…]€«‚+ÓßÏ#bS›Wí…¢•ð’*ÞAeÃÞ î(sËáʶÝ5 “§±×ýTyšÂøÂ;îã°=ú@€mùßç|ûwä' …'o?Ãñç×î£ÒÞýâæái©ÉU"Gt© t‚XÏ´Tj¥+‡[ÂéL x[¢OÜ}ïrD‡\Ñâ´'4_¹È]¹WîF¹¸ÌÊØ[ÄÓkQ{‘Wïéïâ¤ùkÞ£AÎûGmenðäWì«` •·$5…‰O Z«ÛF¤â–"` 5îŽEöêÈKéãPnO5µaø‰bo„¡Ê²‡lµ§üD°Á=w 1ÚøÚZr­î›ú?>Pû–³mgƒPAFØãG£ÂT"uQ ùOÙóK2Íùòº„83ÛYå;ÑȉØõHÀ8Lp ¸ý?q“<`—1³às $—SÉ‹|KÁÆ'-EË" ÆkhÒ!\[,#~ÀøS+Ú,Çßèô'`ÓxƒÙRdR=r6Œš¨”„»_hañz˜ll$öU%KÏa&8£éáʇî‡!íÉjËÑÉEW?œLvõ–§1@æ5œþ 7óÖ¢Á«õ:ij>ÚûŽG¬v¨ZHd¥ô‚Ãd0‚f&Ä»ÄFTŽQ•%±ãy$Úl‚Éç˜ú8™¸¹Æ÷wñ7?B`Èw)Tk)q3v¶†Ã±u1+)Çs}ÇÐWufƒY½²õùýµ÷=œ[`h?úDų̈IMGdÁO ¯°Z ñFŠ›æ7ÈCM|¥·cBã‹ÿCdÃõMç-¯zÄëos,2ö´õF·8÷‡DA£`ëÛø(ÖJuΪñYJ,˜TCL5×vÚ=<Í‚»ó-q'~yJkâ“ÍD™cAbè "©$•"’Ô[cï]ÐññÃô[¾ycK¿ø—™Z{d†\‰N‹’KY—¡dO5¶ž9*I0›8Vè¡s VDeO‚3÷‚Í sMiF>´ì:k5ïb½g Üã´‡ áðpX$ê]~)eIŒèäe…¤M¯p N¥ÀzÙ.·ÅëO…Ìj¹;ZèîO@˜ø§&ÿµäÛyŽ™ËŒÅ'pêo_Šq¿{øŽikL¿²‹{ydˆ‘ÀZT²ÀÏ$™‘.¹[Æù¶Ÿ«'4}Ø'(‰zwY`~¾„×3 }§dh=@¾ž'Æÿ±B‘K× ¼–>‚JþÓ·­J€ »Æ†3ÏyHße¨¤ê¾‡l`S¤•P’6 æ›®ûñJ'ð #+¥ÇãîŽò$&4ÚªÎüÂ?¡÷I·Œ'löÚ¥M ªx´Œ^•Ž“!î u>ó<£³ëyfg*K9¢ð«SWŸ8|½ë¶¸Q戦ÚÝ ž§4•hÐóXJY ¨#A_Rz5Éß6°H_+à"â d±$r(+ÞJªÙ1ø¸IÚÝD£½ù-¹–Cí)dPj©mWŸ­Ú;uØæª07{À‰WýíçL: &fŽÄKyÆÅƦ'Ø‘ðãàvδç·"·òqÎD裙 Xæ9.Á•K—,"$¿e*n<DÇMãR¯Ã#N4×=*²Ùþ)Q—ÆPè]ÝŽ¢2ÿ)«f½¡|,뺎!6XžtûKÛýÇÉUÌ8w¾tí—ŸÚÇVÙ΄Æ»§Óù¶¯VzÜ6@@$”ªœfÝçœèý‰‹9µ« º»-maÁCÛsµN°K?U2~êíwWü#‰{L™Ñ4’mÏ+þφô$OG¶Xôã~¤ Fa€ñ¨‹‰H +N“ÁÒÒ? [§ÿ,'Pí¸ÎÓñÍž¥RG `3%ó Ò¥ºØÀ¢«Måxžsî‚ —…AëÁlåx•v9x4¾ ¡‰|$du­h׫_mU›yC½ÑépH¢øtÄÇrí ›ddš\­• öݘæwÛùÖ€5ô6C¯ØµÆÈèu¨3@ùÛŒdÖ€¬ƒð¹‡ÜçE¤lwɇ„Þ+Ïýß“Ûu:–jO m¯•}盥oçA,Œ‰KT$O®Ovc°*µßu£pS£ŸnÑEK†—”A¡ö”«A#§=–dT^êC°…wô¦ó\œ÷zoî?ì¹Â˜¦Ç°iG2µÜ7­aè”Ôùħ„4T ™˜¶þS.€D§Ú3Ezuqk8) éµtúo0M̱L—ýÙ÷ŒÁfˆíÙádÇÚþ´Ö’÷†'h“6½"O>ê…À´IàJ)3EѲeOxÍ|ÀÝdL´±C–Û7Ó" ¹öBwë_mjÿ®?š>õ ëþ‘…KH¯DVÎUu3ÊfrƧZqúq ÙïE ßg0A“é&£×±þ!ðãUy|HjB] û¸«W¡!L>3g€%Ýw%Kìõ¨{Ýh¶Ó•"£\rD%¿ÕØdo'øÐJĹ»ò±â_OЪx ÖúÓWRëì9ï¼±¹mRf«ÉU ¼Í¿x ¦¶Jœ¦õùØÖ£n>K?bt­OEJjù›[@œ÷¹\‹ª½Ö˜Q>á49‚£B#ECOLŽë½Ðs‚ªÉŸnpWS‘weT²½qLÛõú†¶3ï#y…Ê®õ˜ýh UÄ*ƒ)D}Dy—³Ì—+Î/VD?IXpK¿ÈÅ0äm³wBäH4Èî_ΧHk1ÈeE°¸e¥¬°få„M(àñÊ%ó”lËݧ0$íj÷’óßH0ܰ¤ÈüÉ*¡_Þs¬.Ý`ÿr´½˜È>j3’ š›Ï4øÂ9ïÝ=nÃ+5¤ 4îë´ôc•L*{à;ïL5_ͰÀzibÖqÈ“%¾M6!¼Mó¡ôÈ•ÐHÛIŸy<ûöEÞ»©êœÉ›{‰ }ŸÍèwŸCîYÀ€…½Œþe4BG\m…êX™@¨  , ”|0Öb-*Àóãê­ó܃pØÞüÉ ]ûIuî «üì9laïÞø6¼s:Ó’Ëx¼ ¼ ØŽõ60u‰#´æ«Ý=,ŽÛöRQ² Ÿœ7¶íé@þqìæ…¶qœèà3=¬ÚÀ')赦ökÍ5üW?Ôõé7×Ä>‡ v¡©•=–ɶÕ‡O!5ÛÇt¶é¡Ó>›'6Õáî][÷Zzžܶ[0.`±£ÕVJã|ßëx„ÌnÖ5âKé±iœ’ÂÁ¨%엤ݼ§¾+žTŠÔ¤˜F*eÕôÆc,aú=ÇX;*?èÿ…üƒqöÉ–§h¥èÁœ7¯O·£x«q?å¹!Ún@Cà#g8 Ò˜åmRB¢2'Ô°ò/áj)Ä9Û6Vh"°ÊVQ ¸ÈtiýžŸM.´ÑokkÚr–­'e³"6µÑ×CÐXŒ‚M éªÁ¨’uB¶l\â[ï)0;U°êGå=‘FGЭ-ÅN%üB:uÊŒ-*x'-¥  u7\ÁrW,„bgxZÛLˆô7"ÖÛó·ÅÜ‘<ˆ8ã¡´Ññ*„f=`k ˬ|Gذ/øP^Ua†Å¥Á;è3X Z8?w£Ísª995BUqœùsôCNI3 ºCNºA“;4Å'ÛÿA¯xÙ§8ûF Þº¦wRÜ8ø°dlÔ:Ÿ­C\;-ÜØþÅÛ–2ï¹Óɬ%.=#jq¶%ûàÉ™Ä ³õµVL%‹ÍÛ/ÉâÑBòGkS­$bOlÊœs+ÔÐc¢2Ù}¹±a%âŽéôËDî™hMÿˆHæUÿ 4»ëåºá?ôúº.°-AzÌ–™WÌz˜›yQC?oRêÞˆ+/QôÑ#¥svà¦ÑÕÃöåÌ•…¨x’ ?ýò —¾–<øî´mqF_"£ÓÑ}¼ñ$ýdOQüåUvý t±È6 ¢çËÁ>}éǯÊ"ûe`ÓÛ‚ø¬ü{¯fMè+C˜aäJ¤~Ì>ré9£_çmœ]È8œgÊ´aîhÜω²µðÒ¦Ë? —ôE›TÕ ¢€g¾_‘ÑÌö÷>Ðû#Ò ÅŠH’ÿŸÛÚ_› M!ðT_6­’Cv^‚”߬ï"aS­\8| gÂ6t”Üã¾ð:a«ñÃÀ“òêÏ4—«*ÓmMQõï°ZH±¹RD‹¸ll5Åèó²Wûÿû/sèvë`ÜOnî0ïw¯ˆ#¥7].öõ*þöûRÐEŽ05·'Á-á±Ì”R¹êQÉNõVyw|ycäÝêF íY²6ÅøH»ï÷kEaø´Ðj -¬Q‡ø:e/5øò y ·Ÿ ¹Èpþ¤0ªlÄÞ¿VA£BË–çóW?Þ§Ë0ÁÓØŽGZ¦Ô$=D§˜àg­h•<àÈ‹½‡T}°é(Ê–XY1Ù=ÐKO4®Ä1{-ÄO5pB˨Åé;>±Ø:[bK–<¬q9jª4qËvüÅT¶% ŽSÐg¼[®ä 'ÿló$Ï­UejNÙ±YOP9ñaø<&O‰¥}üawQ‹Tš5¥+·­DEk$뢻jy({¹ìâ[°Âq'Ë:œq2=zMQÅŽaû™º†hŽÅ€m‚£Þ²“µÜüòÛ•IЛÀÊfˆ'ãòî\×`â¿qùQÄÇ@F6Â8Ñßý¤˜ƒF²U@ùÏãûÑð"æNóu¹`VºNi»àØÔtÓe%€@¬ÀÌÑYLT™‘ ¾ETfÇC”"¿Òl’œÖ(±Ö«ÙgÞÃã†ðQ Rž‡aÈ„ò¹þ,ïMqHê(;HÞPOÃìÈ l”à e’§I²æÜß¿ª£HÓ)8²,b™je]T•_gJlAð+pYh(ÎÃûNÄŽRxL’v‚&lYû=3aŒ ŸöÛ3ü#‡ÅÛ3 sCoÑ3Ï$]{u®Ÿe´Ñ.”þŠÄá]?²†– ûÛ/à|ó|Û`€¤Y7ƒ\Ñv#)4Õ9Nß›põO©©–ª1ªæŒ«ýGíÇÿÇöƒ~Ôz2¿÷~0KV¨2¼õ±fãÂÔý¤¶,Ìþ{º¦&D´"¦á› âQ¦í–# Švzºˆ~R ÕåL¹šKØ}Hte–Œ 2Ž'Ÿ'*Þþ Âo"ö倘m‘y «°‰J6ÞÒsÉ®5:c‚ B«ù6Qéd‘‰ã†Õö'ÁʲÏQ²‘E¾àÞ)1ÈÆWH×ùèÌ×zÎëQofzJA,N›·-§Èpì}z‘ z2šþ)ð‰õ ý”£l¤ÿÏÙd„Ÿä°~(ž“í¶™të ó–÷ÐD˜cÿT –rh».Úþ™Æ^µHž’œ­¢ˆÍ•­™jb§km5ú‡c~H‚nVmB‹üçígo}˜PãtD™ØýáŽÆDЖlOð¾é©-Â?FGr+—ÏøŒž F«¹–îßò¤H©ˆ¿•-þiëiû$ ÃBF·iÍTÔ;Aþþž(œwÉ ËÙÌSÚ<åJø‡Õ±Dýl߈ò Æ>³/Fͬ7µJÒ ÍZ¾°þ”šQ#j #sÿÚî¶ÜøfÎu­B ¥‚Mr‡±ÜÏ-ܺÒǺ‰®±‚É¿_r™¸¸Fóúï‘”'ðÎØ!Ct;=öµÅ—¤îAŸÄpË‚ ß þAäß{¹o.Æi„¦G¦„v™(DþlMãÇàã¹ÛšÒõSÖQÀàÞû9·NÖõx¥ö B|ìõ™ƒª¦ºK‰iDzOïàƒ i«ñ¹ÓѹÞ×â²ÁÚ­?z¿·:¤Z7®Y´w˾]‚l~Ùûd7Ò7›Q$‘Üý¢Òì5P·L_â: ˆ×ªv¢×tjÝ^&Pÿo:ý6¹u%G(«6ŒŸÿþOíl‡Š˜gÓS+®§my=Æîm‘y9öM‘eoúµÆÞ®nsú~øÃïO­Š…ãúlEÿ«ÍˆµŸ É#™¯–É»"Ü‘¶+ÉɬÙõ³ ŽX” îøÊë·DxÎ û—-vz=£êªê]n2N!jä¿ò©Bvƒ°Ùþm¯ÑÑè f$|SÁKд¤êˆÆqÂŽß¡ò äºŠNÉñ”õ;i¿µ.ýö¥`ædÔE–X‹QÏÔßê±°ÄmÅ$•GlØ*Ɇ<¼%™ŽÞõ“ŸY³×Kæ®ü—ã­tÁ‘OëǶ¡*¦‡»÷¢Úĺˆ)´…ª"žÞ¢"emØ(Š:ïÓ'A¢ÇÚ„uŸ”8”@‰‡|2B>îÜÉÆ„§Ç0 _÷ªAûlÞ-Åç†ù÷N‹|øå­’}‡ð#lBÚÇÈCñàƒj—õ‡'D Ù+šFþŸ‹~Í¡‚{¨‹á üì’)“ñÚTÒ Gvy¡àØ5ºÒq•cÊÚe¿?€‡é<¹»UáÝÓ*6)ò¤aïxvÿ—óžÚ<ܧßàÛ Á3q¶\îͤžàвmIøÀÔŠAŒ7ä2QŸ2ºZä£òôú4¨À£{¸%¾`W¿-d”„6 „Fysoۼǯ ,@Ý®~0¥®Ü zhåœÉ 5nF²q$)\ÇŽe´§9-Ê•ñ'žEÕté©™Ýa¯jÈàhaiK¯˜ÌÜaP‰ÁbI6r7'%ÛB¨§y$‰ú«Ü¸·¢<sdQ(ºRÎÙÄ ¥ü_—?ŽÀ懧½R³d˜+r`i |DO¸µ+LÚ¿!8MIR5ïÄk±ó§‚¡¤@Õ^]àkcº•…ôJ<”D–‰ÛÌ}N/sÙК¾ÝUF¬÷ МYs©Œ[AÀ/®÷¿½&á«UåßÏš­S¡Sòã³ÕÑlºU?Ú²®Eùc&¤Y—4]³ ‰ÿ)e™šÐ]sˆœOÃéªLÁÈ© ¯ ±ufò‡†QšËÒ¿ vÚ‘èvƒÐA/5†EéöIóó{7NoŒ4ô ƒì…4î³×lZ»u=2àuý(K”Eû3AqU†}ÞZ†Cœ=ì/jOü܆@–ªnéÂúÿÑõ톸‹Y»J¬ió*›À/ø^Š–¿¼à?ð±î˜²sÏË€ƒQuJænõ¥_ÄéPÈÌ?JªÚ¿×H§b;Ò='áÞ„³aRfIôÁz;t“Þ1Ð|‰‰òlâìB¬zæ W+*›þÓÍà[Ž!Ùµ×BWì+ODù}áÖ·™!P^¨9VZú>·±.W'Âw§€0Ó¼VÈJÉJó +äàW1Êë1÷ñ'nb©Â„½Ñþ‹CÊ3fâ Þ.ˆŸ0ˆ@VïžýÉ<ÿ07áÔƒD5åg4Þöô;ÇÇ%ÏÌ©]õxíÞSß©i!ؼ)~ @HÍgèw1g_u´‹ª¹ D š§V«ß=J›¯_¬vß×µ âQ[á˜'Ìü¦áxR¹´m¬¿Á)MÖNäß0Û±È=žt¨#™nµ‚‘?Ñ[Æ{‹D…Ç"Ý>Ãw¡”)È™‡¯5œ:×,˜³/`q=У%hYJ)†â±bÇç ^¦ªÕ’pÕb@;hîv.F?ûDê B›–‡îå~$ÌÅ©ËþÊΧ}¶¨Ž™)½wÍäºOíY®«À\ÜÏöRDZÇàÊ&"Šs´è)àœÉzá™›uh®ÉÎ º"Û­ÈPÏК!¯±QHÂ÷N –‰—/†¨Ì ëè q_‘íè ‹Ô?iKn\O˜Z«6(áaX§WY A<öaM…Ï6º?ƒaU.ž=ᥒ 5ÊÄh\@£Ž¿ÎœP÷ê-e­#®÷j×ãIòñ sŸÀx ³_'ÃZsSƒ×d+–I^ÅD9ÊeÆh%ù—U̪ƒ.¢ QË–øûòúþWò=Ë÷˜¦fÎÀn‰Ã‘ =A^(ßÀ‚àé±:ãÌMko{Õ¶X>ùuîŒÃe«Aå¹áoèu,wó68ûp…‘… FUF‹¦<¥Ý ¡1ÿ@®>¼¬ò©T–†ÝÉX#îÈ®¡Ú¼ÕÕ’²ÄÕžµ½Ó_–6s&¸½r)Š«žË·8Ò´ åÆ8ó&£@Eÿ7¸\N9Èz‹˜ òc>‰Xò¥‘j,•‹¬kšˆpî±çki¢%ÒNø}€µMùµO7˜çK,†‚»Qѧ1\'ÜtÌ“µGÍQé@«vQ˜‘}ÌŒ^X^rmÂ!Ýä4ÖÍÉÞî Y û.P¤ßú/*Çﺼ¸¾1kJ¿&¬hÐ'lcæÝŒ‰–ÞzàâW¨¹ÅÜóhdâ€w ë¥^€ü:ÃÊì­ªºü?CCÓÁR.áä¦þyЭÓAJÖ{PÚõÛãgF×´+Åtíïf¸;Õ_×ÒêRd)VÐáD†¥Nö2û3î#t‰—ªªŸ¹úŸïŒµûÌ1ù“OCêÛ¸_üñg•›dm¹³‘ɵïÏòjý^Ü:C"Ó0|½2LÍø¸ˆ¼øÅ¢ê›n¡©%x”‰’ÔnG„yu_À2V)on±9öÔaOÁ´ ÛȦðámpœDF½“ú‡Â”©VÖí&3h@í7DÂËæbpÄw”"ï³·sâÚúéyL¬/iÏœJ›Ž€Zº¡¶7,ø†vóB¶„c˜x·þª]‚jƒ14â;õ3¦÷1sÕ£Ž‡Ê¦eJJVìý›Êf˜ïøjw½~Ô,J 󵨶·,¡ÖòpÄ‘’Tƒ¯9¡¿Y3ÄÖ5¹QÍ%G@ b3vÑ&Ÿ£vT³³Ao#;Á¾¿ë@ ¼´;¶»9<°M+5¯Ÿt úõ™y&ê, É 9µJ½Ã„ˆª )œ&F×_ˆTÕGK6cF+@˜`YÝÄvM—­¥ísä*G¸ <ïTUªîôp+f}tx†¾SAñÉv)RÒZ¨“£cöêåŠfn}^vù‰Ð¹ï6µš™meb*”NÚ<莸NwR×’J¦ù ‰K­&j§âfF7]÷fÓ× Ý§Š´žØ¦G'‘lïL-$/z;ÑSi<²¢¼¤í°!xy–#o~ì‰e¯¼pD¥©|âæ?Z‹ °"&ò™Ä«XÑÑÖ”Àâ–ƒEÐöv¤<^†Æ9*ÑŒeªëÛ 2h ¶©ºìµçmguHe?´ ±‘쪷‘NÝH–!Zóâ"µx}QQÖÐØÿdG‘1ßïñÁ éÑ_¿–¥Uioj®œ×õËÞLSXÁ#`ùÐ…uVèVŸ]·¯¢¾ØÚ¢†Dh‚oa§1bw½Ú â,b]pèÍ'ï"{@Ûdv—ÈS-MaŠé‡©P¤*a ú_{ýβìÇËrð·]8èðËUtÕw^hÓåyíʾ»¿Ø!úŠm³bR”o˜<7DúV<5ö…í„ÍËU?ëv°TÑš,0’>ËÒ—CCü’Ÿ@—®¼º¢“g„Q“/Oô‡tÙ‹ T¯§ÌÏç­î|œÂa@çïîM3çdÊŽo…©e dªO]Å—ON)MúdÁ_š¿»!ƒ™=Õp6Ùpwµü1Ö¡?“¸ù9ŽO‚ù‚ö<Á¨ÜÜï«þ8ØÛP}k9¸åì=Ú!ðÃú¹ç0Õ—µ± #[¹£ø[˯óîÀaÿœâD½ã ¶1Ï}QD ãþ¬ºð³ T1GÉYflMZ4Nz>[à›ãüL«™²òìwÍô'fÇÄI¦—ã+‘™.o½ÕfwÚØN"ùm6þ5Ùç€S[Ũý ŠÓñ“+ýr_§ƒ¤³¯ÉSNšFñÏÿÀ€S1D!…ðýÂÖÕÒ;Üšwµ.ƒWçLòÞ_¾“{6ß§š“â=”€„À´Ö¦ªÕ”×2Õ0õÂDC4e׿u~N}ŠdªÐûïhš®ÒLP†tš"žepbnd½p4°Áfgь܌BQÄ”¬Eµ‚ã*}.mR0Éúæ=Ož7qD¡!9–ñòB¨‘ ¼2DÆíR–];ÑY`ôìÍ)tH¦JÎÔºZßù[=óøMˆÀt ˆŸìœW}¾óþ,ªP˜«UðWOÕ*BÜ‚ÖÈôÚ¤DȶӸGúëµþž ê ‹.J×oð£ï»Ô”R6¦Õ±±w¬se—¦¸\VÛi$šnTB÷¸ÿÊ%EònÉÈé+n†ŽÅ`æÞƒ÷Ÿ$½_­ø.Zg¶ "­åû/éG_@¨7Äßsj‡]ÎÕ0±TTΣ{<P™–½’XP”#UpŠ.Ùr!ëðëKhÚúž(w"jAb3. ÈW\{TulÕøwrqG¦†ri)&|Ôw>ò”Þ¿ÍcZó$ÉDï)‹Ý\ȯq/k iYq ]c±”¦èJ§„‚Ü0 ]õ‘Ýú[à!¿ªš Òö®sóÙ OŽ$çbOz5™MÇËuâi‡Ýâß MЪܖ‘ë¢o–yÊÝ¡Î1xíbBBààXWÙ[뚌8RÈF‡6®Îô` ýëipƒK„y“X…ÙøÅB7(Œ2z0]ˆ~*ºÊöhÃO-“§ÏoÚâ‚t/{Óœ€ÉÔ8E½4@Œ3)ê>ßU¦hÅŒÚ>,¬Eö)ι¦O0NþðÛi ýPôFÔ9½…fù²¨êœh¤êrrC”›`«Ûi¶âÐÚ TøÚ >Ì9÷ré0ïgÑ=XšA©’äÈ: ‡¥rú½Ã£HåVp«. !À¯ý¢êÛBÄ8‡ƒ*'pýƧ¹k?9ÎÕ°NºõŒÊŠqV½‡ØN•ÅÚ‘{x’Fî#œaü'RM¯ÿÌ:²X^·Õ o+°Žò¢!hØD/¶1A‹aïžß(f¹¼S^îÁ¾àµà.ÈmÞiæ;9Âû®/kët!¼h¸F> æ«jõ4ú¼<¢\±ÇwIÅ"&—Èx—@”igË³Š™?þi& Ò Ðÿ¼kÚ•™75Ó»3´O'ËEX² fÂj­Ý­ôx¯È»øZÒppy¾ÐüYÖÑèv×½Jkt§;ýÉýÌÙt[™1YTMáGYÚî~Ó-TÊ3ÐÝšEv ‹ö„±-AOLÞDBˆw çï ^+Ì §rUf®$QÔíê.zØ™BIcñ¿<Ýù;B‹ËÍ„_ºØƒí F!Ê‚Yoæ‹Ä"vë¬&–x‡qÌe½ðF§BD‡VžÓ“$¨·O×õ×pi›)~ôéHg´È²>©*´­Öí¹Â ’‰í!YÁõCI† FLÌ*Ô~2<_¬c¥Æ4ÎLw1¯ÂÉ`›K!ÛÞ-9Û<—aþ çkí_²gTà4ÞÄ4¦„ÈdÕ Lµ÷ÝÄP¬éQ\l’)ƒßEŽ’•® )ؤúê| 1ïÈwpl:Yî—œ€{¾hÑÞóѺ ¯DªZóíR ÔèžF©qíæ(g±q’n ßÝÁkµT 1VÉaöqW®;úr)3«„ åTO2Óàÿ¨¤éi-ÝBE ±ËYP ñ&q€OhÛÎì³¶3¤ÄhAGb9ç­ÅV:²Çn0Ȭ8íB_ û{6Ø‘·=ÄËùˆx>PxY|nppâ›@ßóÏŠÿ›Ä™‰Œ°Ì;«à œliîL)Ã)M‚Ê[û?©ÚaøÙWß6¥V7ÃI °±çi#m=ðŠŒåJÅñ—ŽÄ©_Þ½BÜ ‹ò1•f,|ØÉ~“9’ “."²a¨˜Ÿ¡¾Rpé¢{6tµÍÆœ°Ž XönÏo–[÷Pö«¢X“¸|p¼-AÔÙv~4_×ÐêƒÅ¡Ì±é f›3’’Ü¡æÍœÏ™¤)p'…Æ¥W·º‘‰‰mQ6:{ƒ· Ù ^tc‰ÁVlø%NsŠ8»jwBYp´ò™×P%òg¾sÒŠ0­cŽtùÅñµ@ªfAÍ2\UK$»Yô.P‘©åm5¬pð™‘j(e‡šá4,O?4î^yˆì k¯ïÕU“_©=ü–Y?¤Ögâ©‘]œðŽD”úÍ ìÞïŸ+jVøéyÂwZ> bbÂÄ ×wÞûqÄZûä8'&½Õ¦&Ï1ø¾VEìH82éMi!=ýåšÏ{q:«~ƒ$|‚âYzTbœ‘¤UèašÑ(­ ˆø™Ì¾L"DP£áÁ’T:lÜ”¨á,M§Zìzu¬ü*•¾[ç±@Y"ÔÍž¡Ò ê ˜· ÅÚ ZµÍa%z¾5ù7äiôOÀ?àb-¬ÏDÆ!¹îâlÕoVáì^›³¤#†@cŒFÎõ£àíZVžÍÈe6Ú´.ˆp!íëdºþ\}¹5áúÌ&&Õ5Ô ôYð‰B·¿ƒÇ¡@œMVÖkh*ðËԈݚ5ž*qóe½f)øí$ƒIZ”bÄð‡¹9w‘@ûÓ{ÔM~nÚ=/ú%Z—ÌÉôëB.Yj0-3Ä¡·Jv+¥FðÎYoM×=J!bçÆP3̟҃JΉ=4íU{·ÿ$—8T¨Ÿ ‰do.g6BE5ì…có(\?I¢~„4M:È>y]éïS–a?äë¥w®¯¬° ±f€BAU5t”z|}Iñ­uÃÛÈ~uü!µV¤ìBN Ò‘Œ_¡!è¾'JãèL‰–ƒÜzÞ“Ì@,PzMHë¦ò'í%b׊Áó¿z¹ìu…rd³ Ô *hÉ:ͨV!Mw²ìÚ8éYÛg¹íñÒS‘¥Jb0ãÆb˧<Âð€¬;ÑøoJiû½}[sš…c=¼ ®úç„>þJÃìºeŽÜGv0š†?àùhîG›ˆxô—‘[½´ty°¡¥<³D6Ïð”¥Bþ­—C:˜I#Ü=8c¥‘Ç^¢õð˰È"ÚÃ$ãÄn¾rĦÞÚû¦üæd"ïR?pàp'—)Y:UÔ­«+–Õçm”žhj­Î/séÖ㟑œì§jø ;³Ä Ã^Ö¹ôu<¶ì´£ H.óŠÜ9:z0=‡ ïÆ=ô¥(îu|4t—êŠeÙÐâ€èQlõÇ0i”»î©¹ :5‘)0KìmûœMžN}"JÔ}¸›7Áïcþ8O[´˜Í]Ö»2C€hvnr™’C$ Ò€3rS‰[+MY[ìTåš"fž`ÿÒTøêsîÝà4s€ñ×IÛ˜×HgÈTa/ìXÖˆõ4j[y¼Ž[¨ÿ5yê=»D¨‚Ï‹æ™% õc…IÑfOí¹­`݇åÖâ•Ĝµ[$øüQlâêQ*Ñ&8Â÷°ø¦‰Ô€PÏè}<˜îG:`5eÔ“Ú5»¤|¼TuÑÎêùkcºPGn+WÞùÅ! ¯Ñ1*•¾Ôä3=攄ÿ¯6:ø]ÝÉZü‰e˜Ù 3Žuù·CfC·Ú׊môÏ“,-8çJU1¶\Û1-ôºÌÌØs4Þü³µhÜÑŒ-P°ì`£f GAý'éÙÜ#РWR I…S>@ªFÁCø˜àÓ"ù$±ä •ZHÔ:WݟѪ†ØB‹XêâcÃjqjfòŽ#b††X"ÀÝâ‚–ßÛ=¿ÝB:òV'´Ož¬6éÕzôcxÙó³uQ‰“}®Ç¼«æûï]Ò|c#ÖÖ/)_Š81ã{’æIüy L,ÔP„Hìö½xÜxÇE\¼í#'ŽpÍån™­ì€äÓ†ßnÑã' ôqg[àãjXÜ ~;4 ˦FLî㟔É&/ùz¿mý}9L*™]3²œa,‘o)¼] L ç Ÿµ•)(É]]¯Õ§3¾g»¯[Cè˜þÛM‰wkóO¹]ÚƒœSît‹zÞûðÊ •’œXát/nÌ\€ÉL2©Ä\âj lzØ8b‹PWN¬ß?ò EŸ(ņPꪛqU` ÎW,ž~F`,±ÎdÕ²ØA°ƒ{nÆ)ÿØÆmвVϾ:5\—ìV”~ÊÄÙþ% @GĵI‘Û þVs(87'¼_6Z»ïüùKí¾O8¸©;‹êr¿X›‚_¤Äm¸cÏoôÿmÈû$eùE@Ö—Fúç±he ïé}Ø8eG6n¢Ž[y´èôÅ£!õØðPHö÷„´ä¡K§/fI9ŠÔÿ¨ m”ÑÞÿ]s8“gi`ŽmôÞLv†‰8cÙo ‚;¾¶&Äqì̱úTH¯bÁô3ĉE¨˜WÕè{6ö0ùAx©zNY‹¨HÛËh¸œ¿>‰àÚü0©|]“º7Êkn˜y#­®Ç%î÷ó—­*æ(êç˦ù.]ÍâjðY³1Œf ‰´Ow Óc˜Ý_YÕЇEq ÏèQ@~Y^P}X‡32÷d.Y!yÞ‘¡$^‘#ͱ°â±Ã³%ÖîP'5²îù—íÚô8 e(_ìqOýsyaRóÜ#kpÞK+‰ŒûÊáaÎ1I[F›ýíx-¶N`%Å”Gs»I­¥‚»@„=¨cÔsðÙ.–!wL…o•8ÎìD)ŒJ°}ÚVŠ}·OG¸^a¢Ô$æ¹ €‚tIÿ‰V gtC°˜û‰·h•#yHþ¼ò¨‹áøÝ[ÁùÑ’ô“a-' }+V쮇²ù‘fOò;EƒEÚ)qîçBfˆ¸o„ªM<Ä,’­FUrïT®YHŽ‘^–5‘̨s¥ZŸ Líš6¶ S1n~ü‰(gMòMó»«°s8U(°½B©ÔßS¹¤AŸuR?óÛÝú“#v-Q‰`9^jc¨E íÂû•b8³=ç/nìí…x…;Ï´´ºuAÀlGÛ½›ÛÇI™(êŸ)Ö‡ú¿­ͬ¹2‘V-@ešÆl-Åh#k‚@™›–²oÞáêøœÌÊcG5+±rÁXýf¬|¥ß |ŸC‘XoL¾†(ç³¶®ê€¡™KŒ‚|îW<·ô¸éÓ#I(ô¿lØ}6:8á+¬¶€eòÎòŽw&õU¼¯g$‚[=Ÿd;g­Ýq'l¥g|ž[0Ë_á¼)ÞÊ! ÒÖ)¯ '%ì†Yý/Ï¢†@„ò9Ú«ñrÚ@ˆËÃ Õ G]¼pëɨ!4Òh¯kÕ5l"-;7©å®yF_‚mVv8[‚†Û¾-F—µ“…ôÓÇí²Öý׬ûµ ö–¡'a1cXla?—.®.OlŠ E´×¤gì UhÜZº‡Íî7Œ¨ŒƒDœˆp"úbúoEkÒ )¾È’I²/}<ñ÷ÅnšOEÿúÀS·OæÃº«”Ãeª\H#3ÁøPa”µã,ú'hоßà˜§sŠQ”îȼ9yR8Œ·qÅ)°eé×ôp|Ù·óçèðwv|¨’ÉruŸr6YK¥yèõÁ8'%Š¿<«&0¶îÈÑÎ E:/Té¹&d~pkch ¾ºÄßór;ï鳈ù+žœp…¦¢ü­–u&“¸èƒGb®Hh]Ühµ« âÄÚ$.l™×Q \p ®~7ûŽkþŠ<žþU¨@¤ÕVq­|¼Ïkm3d¨˜uNï^q l)Fœu}î³A;.‡·èÃ@ú{*‰ ’“øõÇàEñúAYç—”\`¯Xƒ#ûÛßéÿ{+ƒö\å žž2Øt£f‚åËÍ\³Ê{>ÆK¡±f–÷¿‹?¯¼uÁ}Rñ j;â¿Ö:°YÂR(¿¿½Ș›÷çC\ô%ÞƒO~‹ uÿ3‘tgÖa9ÔQ7hlµ8 qucWƒË&)–ƤX„Â18²,réà×Â=X˜å1µ÷ßÔèõ¡Òë¯6ûñy(ÝÖôC†.A›ì²ˆpƒmÃã PUªZk¯9̳Qðð¼¡Þì¿Û{#þãR`Û8„VoyÔðî^~»!u[@þ—ð'ð`¥—·8ôÚ·VçIp Ç]X=y=íIw–QGÿŸÖÕ§‹Áœn½¢1úÞ9–µ¿IÌÜ< Ž+5co8©îï\*¥jxz 0$d§]*V®9<-¿»ÂhŸ(Z&³g–=“&½ðç<r´xìê2²L…e€O€Ø“xzºa]v+ˆŽÿ‹ÕEÊ>è_UÓ·›¶}®Á¯mܵ®)^ÿ êôêç?íT.ºí'°™g>-kÙA`¨íä#ÒÒ«>ÆðSŒ»®Uê¾/ó'?osDâR„,ªl»a:‡‘%¸~qäsÁd“ ²]åðfK= ¯„€VµH³;jùˆ7§¼(B ,9q<§¾_˜2'wt †88ð×!R¯}ÎÑá/°!?Ýsßã²2M˜õ/£¬Ø‘)3jíN…¼Se@;¨ÿF£ÂU=åpý‚ûG@’Nâñ¶Øè ÎbmZ_mM1­‚{§ ¡¶X"Tœ¬‡èÖwY¥ÙÒháÓ–‹YU‰S€j3xdFí8Æ Ó5'nõ·Qø„ÞáÂð©ÿýY( wäÖ(¢ …û8Ùq†¨YC¾†ñ#ü6•ÛÊ)éL˜YÃ9KÐvËÖe5ªŸÙ2&{Ða JcËJýåzû¢¦<ùD[šÚŽÕUvàaåDÜ^9u·ÀUâmfçQ½ÇUÎ] ´¾u6²Ñ*+PßpÔæØW6iäÕŠ˜b_ž4ãaó³êó¿Lzì´~,/wœÂç=r,¹’jâ‰Ú£ù„ÚЪUÎîØIæü8× ¦››º\3ZÂo¡G(õ¥?h’`›ì?6?ŠåWTŽ›”:F1NNcLÂMj!ËÿмœÐ³é˜[vRO˜Ã÷¾?cÖ0$EW_çí¨!›ö›º O5Ó`L«=¹àê;œ²ð"-Tß“’[Fã?uëý&GÈ ëÛ'4kðùúy—DP¨1­‡ÁPÄ%hIuCRDztn½(«ÚñÙ‹¤§º¥ûB{9x…þñ´‡µº‡•-ÐjãÍ/ÕŽpcÿÛaTlî)¯[ù½$1õÎ Ò…vž‘áÝ0|îÅeå‘ å¿gr¹_51x)‰ŠßÀ©p¸{4‚ý3ŸÌðÒ¡9({ï²ü„|Ô+ÑZ”À^ !~J|5ÂËù×Êþ\KÂðÁ¢²Yƒíì^d`ýS+6™©¨zA›–þû.â¥Pñ åã?Ö}®ó3ùƒb‹ÍZèñ•À„(J¨9Ü Óì³5£¡§xâ ºN¡0¯ÕœûsùßÐM'¨¸ôH4„qÝ4‹…ÃSÏ)bezå%!óXVIšŠÖZI,Â0Runþ„´î›ú¿]íªÄ‰]€=Ë“üÃH-Xè–"žÇš¹Ð!ù®‹PÅA͈!q0õ½Iêx"?…L D‡“ð«_Ü}ôô²„ï©v«ÖoÛz°3¨å“f å2psúVÌ R ’R`k´;ôúÆ ÚÖ 1y°y  c‡Å”º«ñ[lãp£?Ð~‚é€èþEÐ÷'+h*ãdÝׯ<‡·`6„¼T@7q] eqS¢…}_›î”¾fAA~¬ñ*ÕÕîëÒŒ–®µF]„¤J.×äM¿îqÇ>Að×ñ¿ÐP~èÅ®ê%)âÂökGFI<ËÖÞ ƒö她ዢ ñÄ'Ì)&^áaý»z3Á–fŽ.J¦öÖá<¼Î—üŠ!íZ¼ÒrMÎRµ*–H/šç*#žÄz¨ƒ'ã÷àOŸ§s“ s –ä@£îHü­¶Œ·ÝÏnÄIZúŒ!åqÊ ²IЏЕIlƒbÙäߎX{îpTD$B~3,i ƒf=âLZœŠ€ ðl´êsê‹Ý']~[‡A‰a#£‡ñý)!çEÅuà×€±ýù Ž·ðúIþ€ômõR:ŽNÃIVÒ—=±CiDæ}žN¥}³U»ù9a‰°Ý©Àõpqع՟î‘îÐñÓ0¡øzÐÇ(îdy&ïQÛL¾=Œô™ûÓé=ˆ*=²µo4köù7 ®kuz|)¼ký &x”¿.'O"1òªV*˜LPUy3^rvh R‰cB…sÄ>{z וhŠÏþ!ûšOçt÷íÿBL.ê&t‘Ñ%=Í<32UnµrõÙêC^1¦öºj® ÀöÛþödç(0ÄÖ†§Ž£â­F«ÿ²lG(ãö¢^lˆÆ¿™’³[VÍÌ•r°Ã+³ÿ»üò/ÅvÀ(¹bAnÌp¢Z&Ç»aw­ÁÉ]G\šG#®B3—0Jádà bJìÜw×+ÎIï»ûjŽ>iË>ær–!Œ*GŒ‡ô( ë­H®×ÀK|Ís@ÅÀö´Æ.éi½“½ÖÏ‹ä»*ê€õ£ž#ØçRÔHSëÓ$´PE(<>mA>¶Ù—D‚¼ØÙNú$: SpÅ<££ªh iPòæU‚i5Ù 6jY ÷o,¢4g/Bð wh‰Ú~23qa ʪ·5¢NÂê8½à¢1”¯ÝûÕá ½6†ÏÀ#ñë”·zÀ–n&©"E¹Híi—ì\B‘¢¶ [ºWq °Ä“fËvá§6pg AÜxãøcÅ–^Žáév¶Q žî ÚqMÁ<ÎøØp¸ø¢l[´UÍ…¹ 5"É6Dmv2GÇRŠÍœŠ ¥?¸Þæj=÷HD·vx;ÒNÚ7;ê¿Þ×tƒSÊJœÖ:Ô’xèéêóqe²Ë¶žú F—×Ć¿' ÂÃBeZ:µp,ƒÝc䀺?:FgÒYÀÌŽ”z/Ëó;g€¬à%\Îé™ìˆÖŸå_æÉr6HÓ¼µ…ÙšTï‚94¯ÿ—àŒGÏŸu‚^¸^¾bÌiŸº"«æºkƒ#š‚Q´ ¾µý(€¼·I`?ÑÊ÷£ê}{—ë wä(­¥òȸg#~¦›njQñ ‚‰ú/Rs¡ÛU;ùâ¨ßÌ…OÆaNž4܆}šºJ0z¹I-°Œ )`ÖäX¼dBž¸ƒ÷ËrÓƒ=ëƯ‡³¦ 9f[ü0ål†r®FHûj4ÒF­ˆ`w?¦ÄÆÅÊsã’ l"½Eô|ýÐÄÖEFí§ ¾-žö–A@0w£%t·žonG;kÈ÷Í#©ÄjX° sdô6ÑÂþãEšÓÄ$ ÃÿØÈ°Ù(vx]B]îMªSÊy¿Š© RŒõ&_êY¼(é˰éøØÕwÛï$ éü¶g×|FüÏJ›ÍÍö“e— ﬦ=lÝ!sªÀš ?̲@öÐìE(hSˆöíît#ôG·êå<Ó=%³Ë1æ>ݱ˜½ˆÄëLRQ©™Ú±òÓNý¾i™¨A<ÿWgƒ'Ö+¡SÔAùiºÞ¨d¦âÆ&˜Ó(XsIº–=FžÄGþ–ŽÂzè¤2cÏxU`¼'–‚ž#oLfù#¯5]Œì û»Ð_ãcå lÛ¸p´9¹ã·3fö_ ›êí: 1‚<ËݨZ@ h(Ü¿¬ZmIÜüûyò+ës­p: 0zpÚ°…q`E$çU*{¢z˜¹1"´ï“%iõ?¤ZãRý›¶5 ä]NåéI8i_²š¢*P5ñUÓLüŠ–l¢q8¹+›Šý,¹êþkÃÈ6–&¨Ð7¶à«ùÓËÿí·ÓÄ\À8\¿Ã–¨LÛ;µìªgxÕÃÅödªÒ~ªtb6‘NZtë9:A†«ãûŒ7 )2Îföhɵ º³§>ó(xg¢ þÐ2‚q]ÎÏj85™…ÔAüêYŽÔ\Ù°§Þ¬Ê.èqT_Ž8B©L´^-ˆw„ZòÒу9nÛ9•µ£0¥à'¶[×½=; _4ë[„¹r‹™,À ]´üiüÒ¡ííרÿÌ¢­Yã Lö»µ|+Ú‰Z8Ç›†<fuU¢LsX—tÀ4Tƒ—¹Ê“«éDGòÊ ï«tn\`¦' £_my8©üüu—lÞ#ùÑL"½’Ÿ—Ä&“ö0`'m‹³[¸D¹Ù¶‹a®P¿³òc¡iq¹Ë$„ûBCˆ*q ^ßC~Ó¦ëâ €ó MFÒM¥“Gp2Ðõž€³›'aÀ’ðÇQdƘ¶¸Œ|ùõYóÄ¡í$H2’8«à!ùô Ý \5vÄ&TÅ@ÿÿÚc®aŸËR Üû0¤ã·¯DKÌ(JNŒÃħÛ.Ð@±¶³©}ÚRì(›n±dHS¾kÕß1‰²Xv~Õíô– —à§•t®âtYã¾G"â¦=gN¯-Rkó`z¢V;õ‹àùÌe™R8ŸU…©ÁÿÖéÐBXsP–—ì’ÉãêÃ-tNå‚_Y>è„#8®2übé4üÕ¼iåXKý•ÚÛã9³–”ìωͭ`! 'Ç|g°¼zµ çfzâ®6lCt]·»ºùé}-·¶&DW¹Dî¼~È(ÄWT@–"œ¥áÔO–OgšÜЯß3V£üÖÌe5¾…]ˆ‘ƒpA]Û{øÄ-ædŸŽÕ ¢}ºvtb62˜£›µýõ ±ª1SÒ Àäòž5z·¹DÞ*º¶þÂOÙùaõì%ÉTáç%YqšËk+´|Çàʱ)À$úÅiÔœ©1–]ºä–GØ4!Ø"«†ï´´¦¹Œ.@‡Ñ“Í«d.B¡þWaÍ%‘6VrE­B¨ìÚ&똰2Þ.ô2rO½}¬ºzæ$O¦éj ¿f¯3ǃÂG÷<*›\01¯½Œ7¿ÅAªç¥á]ÿj1ò†ÏТ‚©…¨÷—<¼ÜòçK!ƒ²\9»ÍQüpbBxœˆŸ ’™y…û…§²ôé¡Û‘ªCRð®]‡09[Í\h½ôâ;T)­L˜ÞÇÉÙ¶À#ÓÊ2ƒ=OÃÅoßÈÉUOCpÕI§|EK“¢8·´  ¡ÅÂñ:bá…,BÛô …hþ.]]žÌm7¦j%:™½¼cŽ*òKw­<Ú*.éù½/x9³þ,jN} óAõ&¢Z;(“ú}Ñ+÷·Æ8;ŸB^Må×Kc¬Ë¿®:¡]%Ãú)’bå)H`.¨ðŠ ʇígŸÔ¿›túéý1òœÖXu¬ÆY1Œ´ÌLá`†£é‰y’G„¾¢ü`ˆ@nÏæÇt)êlHúZ'5ØLõø?ãKV=åóÀr“gÞé‡C¦'<8*á}ò¡ñQJ€Ûغ;³“±iÏ@<Þ@zMŽOì3&‡”Ôhµ–“—<ŸCCZí$æ,K TËOäya*'ŒGS ëÄŒ\1£s€};RË&5ûÓ {z>Íg„*Ó@¯œ« ½ŽQùóRôò×'ï}s‘º»±›…UR÷ü ¦§2Tt¶¬Â×Äòö¼¿´OÔ켩xm0ß:¢CÎùdBÞŸ5 ÷2źÆò>ëPÌ´t¨6€Ý™»»*|~ç÷!u½+æ¢^"ö›r“Ÿ¬·Os„×왪rh›bÇ`ÓŠmRu¶ánüH±*6ã¹ÚRY,bš`Ô$˜MBä_Ac“¾þ6fpËpºg"(Émv)U'Ký%ÅÎÿ±ôâz¢!â°Ž`˜áãšüt‘ã—/ž}œÙD]"E{ï©ì>ýøš8·-Øs÷ 2<ÔM·ñ˜9uè !¸:É>—zý¬¸SöeØRèÍò WWî§f³Ý¢±˜Uv<Þ 8§öÙKøg=‚‰À‘âr3qÁʇkµ¦V÷@ÒŽ±C¨$1yès_•eÇ~ú]C[,x·_ž:Ø Dm>Iº[Rxç¼O(‹öó Ëͤ³£¤£u˜’\®xî_¸žy­i måÓ«"ø£ë@ñì&{ýÃþõÇ¢öÜf‘2›ÈæÌ.{i`=sÐ`rs¡â(íï¥3lÂv°g°¥›œ¤ƒ„%¶8pa—Æuˆ£=¬ÔBºûó!†xF>mqYJÂu›ˆ¿i·Ñwùj{‹ÕÛdN™Ìž¯¬°Õ³?ʽ¾[câ–ÐúIÚl0lˆØìè!Lù ¶0Ö‡1Ië™Eéðy@üÍÙ—âCn¤‘E%ŸÆèù¤Ì˜6,R¸¹»L¶bY„®µMÕÝ,"„¦äñ4bóð%(š´ëÜï ‡ù¦¨FNÞuÁ‡•ÜKà±ÿ{zß\ã;=Gß1AfF½j|íå‡fMëcÙÒÒ›Š•ú¢¶J-±Lh]Râ’ãb~] ApHïŽîá8û×¥ë&ê@»d€Î•î8y^šÅ­¯K”I?lÏL×–ϲHÇ³Ø ìWDàÀòü/ù2&Ïâ99Ž^o]3ñÿ±Iý,cWqanv™$1Âyæ¢fˆFÉHÖXµ6fß”ç†ßÃPIlŒ²a=” „hm{ž¸c5< ÿÔaË’fÞ¦’fOê†bÃ?Ë抷 ]0âÄQ ?Šd‘¹‹hûnh˜†0q”yªÿ›ï•µ§ Ú²¬¼‹Šñ‹ËÜÀã$ÕŦ øF¼‘~áÁfÕ¤Ÿ»Ñ©iîRÄgµ`Ç¡ýI}ãD—¹óö*,–pu~âs¦0 ç´J·>ÇWf·ýŒ– 4/͌䗉ÒÓ*ZJÍ«‘¯®¹GŠ»ž7ʾíÜÄ+zAQ3uÈô€•oݘÖÊ£y£|{í†dÿÇËM'g ‡QÁ ¦‡Õ%¢Gø®IÞu£÷)†,¢bY²‹zˆ¤íBµm’ÅÕ°+†£²öïú•’¦8ö:¢' ËÀ:Rõ{F¥ç‘rŸñ:ó÷ÁJ¢“Ko%gož%õâÑÉãânuå›`ÿTͶ0ùZ,ù*¸ØkZa8=Îà»ü¿©—áŽ_×Þ ‰jœíHE%ÿdtôŒ…Èd5?ÖûmM±%ˆ¿ ðŒ'Œ¨8É;¯»iø§¬RT… ò™kÅvÁà=­Ðã<²_ÉÄ€š (ký¾*£+ÓD‹{{Þõ¾ØJöÄÚ()ÇQÞÞÄA±½ûCøÀ£y­–½û¡€“J $îVC¤ºU¢Còn=m†Hèòê´í5yQžþƒþ›6uæ»xr ¤ŒO ˜¾õzðîIÃlÉ4Õ )µTL¾U¹×òɽ~¥®™PôjÒ;ü›©=õ)WÂù¥EÚ–úŠ(ÇÃq¨É¼Ä:ñ‡Ä4íװक़?H-'þ2¾`¥¡"Rª*(â%ë’}sľוǒÃ>Eáh™ zrÕDرŒCL¬ \Ù¿’.ø/mÃ^MSg^ô¬Ç¿g,‰™û[չ޶ÿÇ !µ*1ˆB8––ávÞ­†¥R}"ø—DÍ=¾w=˜ølª q 4Ç$zPüŽ¥ŒíÔe¼¨9Í›^ì” x~玼ÉcU¯‹„#Ñ«¶-ø%‹ú'–_¶ê­`±“±•j¹ôò¹Õƒ­47öŒ½×®þ³2Φe „»<‹B‹ZTZàìì>_gÕr"h–é ×£naùGm\¬á9JQÓvÚãî˜HB³E†Òý":ßgñüÊ^þ±•K©ßØÖ¤ÞЧ‹Y1“¸#½©‡Ìgujè7ääP#*)t›NŸFï¼Eâ9h¹ÞDŒmWVþøPÅ®ãÕ{EhTŒèžÀùt‰ÇSWûïÈÔ·h >;ßS@þðd›½qu™7ÌèãOî³WÞ¯^¦RÓmåߢ«x ád}ÜË5 ¿K¬”r ‰Ø2hõk_ õcâøDèéÒÝ•kˆýøæü.†Í>äs¯b{¦…XÈó5^PQÊf=‡l"¯9#Õ¹–‡yËhqOÀ)ØxtYGË«“8±¸Eb˜Ûµ-Æ;,¡ä;ص³Zâþ©DZãÄÙJ“MÖE²¢ÃÁ&ëÐ-:³mNîlê—P£Þ!ó©NM DV€×R —7ï2éŸRÔ¡)üʪ[¥’gÃdb1Ãóˆ Î♳@C™›ÂÏ×ÿ?ÁŒ‰¨\ly}Ùùe-`Æ–WdúáWÎÆ¥Ícã¶é!§!!ë \4ßžšÚùèk"×Yš#¯Àƒ½Þ^·—.ø#t |ÃÀŒ¤ôÆž6c¢ÈÂ<ˆ‡‰ZÔJÝ7kVzÞ<ÏI+©åž »ƒ&INÓþ „¶Ê¯ÃþåªÈEk­ƒžûÆ]¤à¤S¬ÀyG€VÃx_÷r/›ðdÕ¤9F(³Yƒ–-)ãB÷±DÓ÷±Ó|….Ö%¿cwäöGIm›{­ô$#1Îãz¤1 ¼"LD)AÎëvÂÜj‹dYY¶‹¥Ü÷~“6VŸœ9‘GÔ³+ý¯²Ž0öp&ý§`%Ü/öá C»:!c1yêÂWè9i`ˆ©¿Þò`){~ßÓ]¤íKNØfIï"qßL>|£ûÐêd•ù1óÏuòvåábˆS…ÝŽ¥íÃîfª¸ÿ.J.2×uHÑ6ÈM+Q»íVù&0áÐ'cæ©Fé0ÕC1Ï/Eņ Pè2¢ =°Ã&žv}eZ'XH•WÌ…4Ó»Þ…öéªúÄ»UÛ ><ÖXåßl„Û+Aù´ÐŠ™‘Ýj±â;´À%‰q½÷€;¨LذÖïÝHźvlâ‰É’/9ØHˆ™9½€šòÔB·ŸÒýÁî¡ íWÎù„™ƒ ”ÚÎþ¾à˜ß&£àÛá¤A¢E~Y(7ÞÀÅ üÖ ^PY¬Ë¯Øåž¶sÆ…c·»m*áÍNÏÝf̸ ÏëÀ]Ã)†T¿-Q ÷ŸOÈ>sAÿþï;t –ÐÛÁ”Û›B˜žÇµdÍ`à–¹* öÆ5â“>Ý0õ²Ð°²•¤@êìâì;g~ƒ:©Q$ĹÍÿÙïJÝÍ“¼»>É:Ò©ÍVQb”ë þ‚p-/o¡Ùêã-„¦` I=¥aâF°šqPÁç(;7ú}4ó$+?d¸u6)EäÊ‹ëž÷rfúù…P¥[êž°Ùø °J#míP±—GNßQèvÜÓ¿Šäot &×s¶ó ¦¶½9'ž1/Žl¨Ðl»7`Š-6–Ð ™´}Bpÿ yÎz¨$ïµV`E¾·X¬êVàHjϵ e#ä€8('­‹}ÐiÌ£JpEŒ>¤À ËÍ)‘º#Ϋ*渴Œ‚›Šû!áÏ42À p·p¼ìHF6» žÌÎE-â› ¬¤ºãBÅMmwÖÝòþX|‹ÒÕ(­Å´¨ÏµµšÔÆ%D#´Ü•ʶG]néŽ^ÜY5?òÊÊ'û™‡bü2] ÜfÏÜ5DsiGcîˆÊù2uXí¸£¯ &ÇæZV±B)/»Ø¼$B"EáÇø<}‰6³Ž•ýU'õÜoY–º·Æ;# Çnn0¦ï5ŒäT¹u—ïÆNÚÄ—?PI»ñ‘Ÿí pC¯%¨7]›êÅÇè Ã\#{!e³«þ ±D`MI=p¡‹‘ÕðÍHóÆÆ8Z& ;,CÑ'ÔoÖ„¿`šÝ';òËqp+ H?±„‡[.®—Ù×G4Xœˆ …wAa2s-­)4ÿ'IÁ¼ñ!#éTË¡è<¦ûøºÛH ZˆáÈ4° OM¼¤pÝð®…#bz…ÖÍ"vYЏçÕÞ_ëŽ{jQ¶™2ÓJn=GLôœ`$y7+Ñßè< îƒûAóA‰|Pûú@´jAänÒ6?ÃP©%QÎwan÷ðonáX÷6fs'%R¬Øt¢éêmQÉlp6?VÃç>¥H‹@mÐä¼–­“É×phÓëÿf·,‡²\Û{ÛKŠ-IsnX·B'ÛSCçë`®} ‹ý{s$Ûšî{·DyLéJ§,I‘36dó¹ÚD‚)®˜žP ÿ¿gYiNÝF탥ÅùÍrˆÒòò¦è1[ã«F¶ïãBÙÔI?Šo8à  Ø•GÐß·Å0†#`õµàmηì O—×Óüõ»ÈŒšè‡´&ÍøYeåô? Ó·®Ýðaèéøö»þ€É˜ÎN1›€Âcpl‚´Žj†Ó<5íkôA³Qb︄5~ä†÷p+­Ãû¿·¼°:¦HÅ‘QBƒlÕ@"?vÊþ±lÏîj[ì/ xjµÞXÊþQZ ¥rjûRv<·0ë&³ßøÖPl³±C_Ä 0— Q¨ŸÕ!Ï$¾J©^ê²Çè9E,Kcö{VñEK ýÐFeál!úyzZ„é« 0Õþ¾hH«Ëd–ùQ™×4íròh´Ò*ªgð$q ’Ådµ‹ã×ýD 3˜éPâcg‚Ò”é¸ä´($Ç’È¿°êƒΘ-«$]ˆ¹ÎðÊb  Z³MS·Y~õìyL÷WÖ(a¢S[v» ‹¬ÿ\Ü%;¨˜OG4äAxñÙ)aÿä$ó ÛFáã,ÁŸnVujß·t˜¯½:èK¬%‘dmäõÎRS-îOA—ÿÖKõüÅë}ìöÑrè@5ŽïtÖxR±r‘ǃ6Õ~ü~ cPÏöQ{IBŸ€\°Rá¾-¨ÉÈU$ÄBiÇb¾¡VÁÀ†V¿þS•7^´'ì :iÕÕöqoZ=^¼ÑÕb@Õ[ â¡³¯ìä²^¸°òç2űMt^M“kÛ~Îå‚CÇ-¢›1)ÊW¸îpJ"Ó¿hûëTÖUÍ›ä}Aæ8Îŵeß&{Ôþã@Â;Ú½ÃÛ¸" •O&Mƒ/ذ¢¦‹À"è·—d ›·kBÆJÇü4®~×Wû±þ4ô8¥qýi<ªšÖ\þèöåb߬jp»Ø£gE2+J¿2¨.Lö'i#úƒ¶ áØÿÓZ†¦f4b_pW«(ïþ.p¨`5µ6«'u …ƒtI¹ Š€‹ßrÖ{ ªSš<ÌSYú'ÉÒqð»ÈD“ª$=ÍéøTûÕ¯y¸`ŽÀƒ|£DBmû)1Y¨yÐÆÉÍ•‘«} ùñ f¶ìRÁ;k]2/R°ß?æ¥J€[@™ Oè«ýÊ í]…´ôéô| ±8b[÷!&ý tìp§D²%‰ß[æRZõýx.Ÿâ<Ñú\0¯˜”¾Ët¦œæ4ÔÁÁL7²ÐÏ|„œS…ö@àZvÃØÜ™?e¦’¢S¶ÞaÈܨ}a#’8#…Òz3Žõ#`Êé*Ì.bEcžx}šÚMk:‘9ˆÿ5ÍzŸW*\ÍÌ%þaÆ]sÒŽstÓ Õ.(…o;ºÜ÷,Šm¥]ÀãÌÙbëX¤Êk_𣬧ä)öð„Œ¡êÔÙ¦wæés㮵]s½r…­Î/IY%KÝi ZšÓ¼Û²øúòáa{¦=ë?8ßçR¾á‘S‹E¤»¦uûnA4"Í’Ðg„o&ßÞ(J|¯³š¬Ê@] ?Z¬¯\;†Fçï‘(”`77ò^êCßÚ’;›Eu‚,R˜¢û,Fd<É£®GA‘Z: äJ}õCø®F°¤¿È„ë~¥%(^o.Ü$÷ªÀ̆ØRÜÆØHÅO†eg€ž¢%IðÆøN[ %•EÇ©ùGÉ_¾rÜ3\0Óxª¶çxMPt“.ÐBÚrè;J ¼r:¿HÒfî>¹Þ`ð)µ†Ã[„ÎÞ‘õ¬¡ å3˘ßqðÞXNKY‘¾{§– ¢H>…9¨á4šÃ.™@\aÊKŽõ\QÉÁcÒlVÙYÛbk©lËѰí4þH¬¸KŸ-V+yà !¿‘ík¼Ébî8·ñ>b¼k¢S7üž+ºoOÞôؤ̸h¿’½÷®ç¢¯È‘8EYÄw.ÙÛjœ¶è³#$^§ŸærÄ&~¹5qŽé*3 X³ÿy§®ª†“èyåv’ÜÇñ} (7¼ìW? +BQ Û¦ÀiXÖ)Š\¯LÓ]Cu]µÔD£AÍg¥O´Õï›#i½¬òÓ+NqýD–äbù¸þjàcéøýÁ‘Î߈»Õûà”í]{b÷Þè™ Ê2ÿ(öo0û½Û˜Èk¤­÷òN¨Ê§òƒÇ¤Âg6á±çA1•ÃDB¬ïÓ›z3c>É£iF>ÀÛu›•$Yz-ÍëXUÌí\+┎ä‹.p[C¦ŽN¹.Þà‹L!8Ú]‡µtoŸK,8m”'/ñ¹îòB¿Ø°äRÚã7dq"eh ³T˜g®V™õ1/, 0ʯV¸}g¤œ›rd&ù‰”÷V_¾Ô ¨uÙåÀ¥ïuìÆ÷tŸ­4›$v“í²ŸG¥›!Ÿè¦]ªî‹&¿Ž;Døþ[!¾BÒÚªÿ¹k,ã^(Î3ðƼJ™)ç(Ú1ÕaˆÈ©•_sáÉ'‰å,§¶ó3xE/Ô\ôý¥ùi-ùIÈ-7wèîéó©¾pŽUç”]1šˆÖ…uýW¬ÃPvóhæ­º^ç¸?6$Òˆcgù·£ Ý¹´ø„Ϻ D*,¶~å9¤_q¢kÏ#BOب죢(Ñì#:‘>• Ù{ĸ[´y¾Ì:ìjm¯ 'èT^1¶C°'™9P0H4ë׿AÐCnˆ]4ŒÛôp‘¯Ù7>>f=:P%Õ#dd)Ù©âååLbX†`:UdÛÔÔ##8Rríb}”@ÖÀÃ'û^_“õî‚£‹ÃíUµžbä’ „/ {Ý »õ«Ÿ‘c€åˆÆtò‡»REsëOBòæE¨Ý#/Þ{‹¾³~£ †äL…¹¸PKoð–áÄ{crTuV=ë˜aMÌ_î ³‡n=Uªƒw¼ÜMœO“U§¬¤áUü²+ªµ!ó;ıBl5- rMÿ¶H(Ã)_9•µÛÄquØÔ¹¢dw¥säº×z¿¢%[צ¶0I¾âRv’˜ÍPW$?•Á(4×ù %ÿÇ-jö”ƒsãìÌ©„þ#•/†;K*ÙûÚÊ-¹‡•“ùBÝi´™ýu-ô£ºCQ)ÑN‚bÛmÅBÐ8¡!ñFKüãµôïiØ’æýdˆ«’·0œÏ¿t9Ô3™lðu‹Äç'ʈµp˜¿ÕX"·š}c€7mï­üƒï¢òJ¤À6wËnxÑÝ ´•À €*‚aÆ3”tAñÍ̸†Ÿ‹“Bg«®³ŸQóX…´I¢C//(O¯Céźv´caßö6eœƒÅ,ÅÞk{£º¼PΫ—œ‰ù¨ÑYY(¢]ÓIj­27A¬¶ß–;¹V_B›Ø A®˜ãMRæsrÈО„qIÊ‹еöj™64[¡ µŠ|sô´GBâXÑkph¨cåiôóóït%´éÜ´äš…®Fb‚) ¬ÝÊíjÔ‹ý£üù'Qï]|°Ý|öx;ÕUZ›l›»°„㬠ל16Gõ²6>|Š€o /¦¼óµ|¢¥G€mW†HÜ"ú8ˆUfµKá1ÝŸe¨ª¶@1pÍO®ò¡}ú µÉÃ,ø<'¼õÆI?öN‚±UúÚÀÑ?¹æ“µBg¥XŸ,‘Á5cÈ€\·Ž5d~A[¸¼îÓ³ŠÜr‰0s”­¿Î.³Ô’ÓŸ½²£9ÄE­M'ð6ð}ð¸*£½·°)Dìw·Å§q£AÆ=“ÖržÂ5ërúËhÞ@zZtr¨¨¿ÆmK_¿ˆ}Xb‘³l÷Þ 6ê×ÖKVŒIÝaûCgà{·kœûÀÃp?Ò :(jÉììLÛ§ùá(xšj±1ØÖN+úÛÚpÑþë¸-QN]ýžKcôÎÌ9u\+0©gÍa|l¥ê¹ì‘c ׎¯Ã‘¢Ç…þ‹-¹=;XD/áþ3‰dÃwã$ýo*')Â÷þáž[øy{ lgáÂùÁ'ˆ•Ûˆs°(Ä‹†»0#ß7Ã?¢ÎD7%Iœm˜7¼†5ï_±±5Ì8JŸ[µ3WJ{Z=#ÓÔ[[—êí/¶Qˆ wê_ðyI”©[dƒºÆ¯HŸ ö¿5Þ«µ°Œ—réó˜\Ü @=_â ÛÁ’?¾îÓvÞÂM§”ŒE?‚îÛ”Í7ÛF$P\7÷u}+…À•qZü x:‰u?¿“ˆúþEÆ7]8êÉÂ=¢Á¤¤Âë 3'¥I™81AF?N}V<vü-Ô§Ðõ|ñp’Y¸åÛdˆ¾¡£½¾¯XHòÌãiàˆ0:µ±c:qáÁI2ì6 ¸Úaôl¹Œ&®;¯Ú^õŽeçÕC_q$O^¸Ѭ¢˜­ÌGF§€ÀåÏ)°±Hþ•ZÑÃÃ25Ž’!—t¢¯´OêÝk v1ƒ+u6uífº]ËHK© á¹Ž:×¾g£»Û¥ÖXO^©+ÉÇ,¥5Š¢<èèšëz–ž#&k1Å[ŸWï”oÉ ºî&óõÀ;Ýp,¢9uÚSLfˆxÐ^sÇ„·4”h“‡étŸþa’‡q𱕋br^„C•aZ1}à)ñ¾²bËYÇñp¥O+.L¨«÷‰Ëþ.1'°r³ŽÛôVŒgQ†Ñ*ocíAŒ‰ï&?hY¾Êœà ©È7¶Ž). {ÄC–6j}$Qõ2u­ÎÊ"iío—Š8bnþy,%6 yãb|gpšŠÆÑFÄCþ"–ÎÀ§ê,œ‹œ›SˆÀîÇÇ!Ñ÷ÜYJŒ¨ÁõùÿË µç—5L§Mÿ÷`ÞI˜£²ÖókqÇ©-O•Â;b/ýœ”›–9ÊçiT›Æð²Km3?ShØOÀÊŠ‘Ò¤YÑQíwÐV¥Ð{Cø1 °^öyƒ†SQa¯˜ÆÐE{ÀÈpÓ¡ZÍ€‘U˨¿Þ^GÛeíix™KRG¨{ìjíg%á/Næ$£HYÙ—ïĺ܀ä¬\œNfŒóZ§gG·V2ÖݾÀJrNü½mÝýäýõƒÊ5Ó¹(s-?á*S$Üβ#@ù¡ë«CŠM‘„Ô¸fí“çeyñE1hjœñ¨x°¢õº@èðk ”Õ3P–‹·Xø)®«¥¥–\6T’ªw/’éIRAyïlCZPý /+§ÝŸ½ë]E>:gåžu…"%Äyl~…´þãc‘#²?t¢ÝãŸßÒ±¿ £,Ÿ^Ó°¯:[ÆÃ‰aRàô]béõò%o @ÞGqLŠOú¬W«MyÆúöðËg&, Ùz[/Æ~¤Ký™¬0ödì \3¬,iˆªn4’ È'¸ŽÌì0¬œ³¾ñެ¹H ß ¨ºžËÿ/½¹wï*lOtr]—ú÷[€é‰wƒHÿ ,ñŸšHQÖ‰'‡gDâ–‚aZä#†ãàQ7°<žl~¦×z¦¯ZöåNŸ¦+Ò™þGQ¥éXgƒ½¨# Í‹HÑ×#¿ÔeDÀÙ>î%)6Lj¹ÿS´¡ËÍ¡Ó;ílByÝÄw'ß·¶F°“Í@S8Õ$œ×9ÓMHòÇlñ{Q8¬Ýk+øìƒD‰ê‚Ý ¬·¢ôÙlÒòsƒ á#L.àŒEB¹ú‡ ‘¨‹žâ6–MPPÎx xdËb¾ušó·Ýÿ×| ©,‘žeNžñ‡À?™Ž·s=ú€ë½+8²ÛÃQDÕüÁôlñÜþ½ÆæÍ4D(UZ‰HcƒcéÞ×;÷-îÂøjÐL"˜CP’ëêÉu‰mÅPë~Âh#~ó.¢GO¹mxÅXÿÄzןvǤýäÞqèKšL&D¸7HQy_¬%O¾k"sé> xn•!I¤`–Ü>dVõÜ©< þtþ5¤w*ò;­º('s_‰å ðšîŸm÷”vÿ4Á<ì0›·”‡L6슓Ùð$tušÇ·F^YK^G? YíûAƒNsþ½)ØüCáÓ`±Æþ°R£½Àéæõª›!h2Za^‡è¿ûÓSR.Èí 'ÓFÔvÅ8§CæŸWX×8Ð, ¢Isc…¨/SÃH÷®†vIÁGÎxž¿¶0º7>Ü ±œäY'êޝ嬂~? ,p˜Z%{ÎauM4ÕYa…ýPP`±–ªûR14FÀÜØ˜çC·Ô úÖÉ€ÈÍuêþœ§ÚcHà ÑÈCÿW£fÈ&wÁà13~LÉ¢ò·GþCµï ¨ ÁˆÐ#¸¤ŽpNYô™òfߪÞ#¨•³fÊÖ5„¦Ú”ŽV¢qß;oãÈtA'ë\ÖE#Äž(Äv׊¥£$ö‚‰ÙÚ0“P,×î¤L2u-Æ^ü')ï=š-¶¸Èuà³S>€®í 9ŸÜß²!f-Ú†Î.`¥æ¶¦„cŠBÝeÓ¯ÓFA>š¯7”aNì™c¤ÓEò-Ü>–4ÍÑšÊèa¢vÆb¤ù Ë™7(m¿ýzŒ'³Çú¶ƒÂm–…Òli¾„oAf2ËÝÂë(9;éßDFSŒõ°LQÐaÕ þˆßuˆGOfÓ+}%>E®ù™‚°ŠoZ› ƒƒ+ÂÂàžô‡­/®¸Š“/¿Þ¬¸4½2ì—j7ŒŒk[fªdLÍ;µ! Þ‘w ¸ßŸ…<”žó½œ]IŸ-rÕGØ×ßÇ’#ç)egü®ù²v·¨¼'£õ ¼GxçA’<"5 ÿzÂ^F¦! =Ý ÆÄ.±‡H\ r”õMÓ[¶Í uŒ*Çk7š“ý§¶8ÖÝf~ú2ËÅlk¨*]z 3`óìí€ú]}Ôé'ò0WÙ‚Ü3…Þù¬îÚŠ:J#¹qÿu?x-KÈdãà|ßð l‘Ç l-2Z/Km,+&8î£b:=5OFA¦í•µ‰CÔRçD×”_Ž«"Ë™Å>ÌÍKE¬°§‘’Ø5¸Qífœ!k]áža«#0xÍkYíJŠè?9’çêdÙ‹z Oéè¨ÒÎE‹iO?]ß9ÏîÆHY@˜‹4>`o[íDÄå–Êí×Îçv¾C™7Ê"<Šñ>xmßÛØ±øKL.ª€sÿº:“LêÑÞ墱á}«ºyÇ‹|Ò™ñš£ŠËçFsrð¥éw(EÔe¤qÀyN"Ï MJåˆé7¨BK¹N¢ö!„O3ÍXÕ¸ÂvÔ„2êvà•¯U<83Z½‚Ze¥MK«7%óiµì-ÁAàgíVÛÝ®J%.~# ¼Ê8I‘CëšOĹÎHÚ…•X“œÉRR÷½ã¿ÌÏü6S•×B›K±er8~uȦï\=üña´ÜWÜŠEÓ›hÝŽÙ$¦¶‰½íà‚å)Í’a ¼å‘@RiódwWŠ¥¤@…Û5÷¯ 'Ñeœ±K¬áNxΰÁ«¿•ä¡mZÓ4&ßT¸]¦8ôôw6cÛ¼¤S]Äp¦ýØB©<¡gÅ¿n4çp3ÊY¦÷-w‚Ð0Xuó€x’çGÜ‚üÏ?(©yªë¾±9©>K$Ñ÷“±:țԅ. ME,äå†â—_!²É«¿›]%¤Yéµa°ƒÃ¦¿1hôT^‘½¾òËö7¢ffæàÞ$©+±ÂÈCÎÔõ˜&Õœ‘·*¶…çŸwáFÅÿØsoç <:<Ýù‡Tíø#Hï1‰Ž“‡“3GâßóJ;Ηéágâ5§CÏù'ŒÕz0¯-½€ìl{Ö¥8ñ"#£ûgQoãkÅ*°Mv°]ê€0ü^Ôä7íဂH”ý™Ž¸ú`â`»Ÿ‡(ùÉç(ŠÑ ªî}˜9X¶âŠ­Ú¬€ýÑ_ÍX-àŽ`­>=ƒÇKƒƒë“¯è'[•øs7°ÙK;ôËÁû&TÌÛ1"hŸmUÞ(4Ä›e¸ÆÄ^ˆ)áEæX‘«ëóÿñ+^ù[ó;¨?évü˜ƒmr_ØÊ˜¬òïELC|\.·”÷KÚ2L®}¬s bN¶Œq‘hðMÁÚw‰ P,$ûÒ‡§xºJ§çª²o¡õp– ò{2ͼÁ›XöJC7™Â¹‡¾Œ‰Z‘ÞN_·fñú1ŒŠŸ‘@—é Èø;SÙ“k¯ÊÊ ÆÏ‹A¨½º×oÑø%;à¤Â^ʽcöJ\~Nýh5g•èè´‘áV®ÿàï2ú“/Ðq^c[¯-pFBNE{ï£îfÿn3ûwZñvbŸ© àÈÄ—š _T‘ßÕЯçt#¥ÐmÄôé7’7 ]tê$•?™h.Žvw •­ßÓ0De\e:P!mRËZX¿Žž!6 »Æ$k—ƒeg‚3§NØKõÛÛr3–5^{cÉÔ6½x°¿±½×âä6 VR½žáõe2L‚Ò»ý4ÖgG 4Ðäê]\‘4²*À{ulųeøÿàˆ¶V¦K¾u,|z$søK™L,i ÛÏÌWÚ©2¶7é÷±3מ,t¦¨{ýN¯4à«í"í ­¤`“ Чӫž>¹aK ·|PBþ¬ùÛ¯X×1XÇäH/ö€¼"¶Uñó D€Ò¿r¡"C<ñX¼Ú"–1î»M7{Ã,š£æˆé êõ¥ýB? ꟯=¸òB%=jíÕ}2â‡#R×_ÇåÓ„Lcié&ª[îfkQuõK{Œ:æ0‹{NrñFñ¶>Ÿ„G˜#HY|<óÁÉî\~"+ÚôÞ§-•Ú m9o,”IªX…2¡Ä+ `P™fu(î5ZrÁ Ý&°wS`Ó3)A«Ç*ѳ—?Dô9jÞ6Àô Ží„ÂPHDMa·p±{M£ eÙngÆÁaX¾÷«ª÷/aí í¿åœp¸4÷JAÓq”Z%ò¹kîµùë;S¹ºó,z'R•ЬU÷"¼¯ç^~±ôI`C7. «ªÌ×mW_cD HšÁÖ,L°8‡—‰`¢ûk®¦ôWnîéÑSømVb‚ZfUHøâŽÉo֛ѮN™…Ysëáë«x[„÷M¥Q¯»Ó¼´æ%ìÂ==Í~NÕW ‘Õ žÍ*ø•DQ?:qG}µÖa2²GãŒòÇ1'6"Iòš’VàT;*ºŠ4YLÊå·ÝÙŠ(M~—ZBsr•ˆZ¦ƒ¬¿ð hê¢x'Ë™fsùí^›šsæ•Â[Š,èÃfë¿ïYÛöˆˆË&;ï†WL§/&{¤±\>¨©µNÇnF5PÀ´úäq’ÉœòóÆð3¶i+9­Û‹ërÂDÕµ® ­2ùÙ.SÅwh’þ¦Â–X¶×~4 ~Ï/9±Ï¿¸uT>Ú“«––¤#«?b/l×µöv]ÍqÏË_âxÀZ`[Ü–2._O%OND&Czø™Ådäñ¶q$ÐGèYˆŸW÷úi¿ÿü¦ëµ|H£ˆH?-’Nx5ÒÀà‡!:û»0LÅ;«]øÄæk…³û‰ÍÍ‚<ÊÁ˜i¥L~vßN7ý¼n±:À‚yvÁ]Š%ð™¼Áäç;4gtýïž9^±ÞÄ×HÁ„ùXÊuÜå\ÚyLqþñkúÔ¬Ê̪1!º_3xEßòº‡¨•&ñ h­)äÞ~dÈЃ»Þ,{u,O‰î>T,&“Sï¼ k&ί5p”B÷‡W +™¡g£s°ÖƒV÷{÷uôÃÄŽ™ÿ¢s]í[°Ó’™~s#ÝO!«ty"'‡¿çìëw.³z+Ó §Igsš>ßpælxX+ 5@?ò¬¬N~¢ÂÜ¢€@#?q¾:‰Âw©¡_ìÂHÝ÷mP ·_UÜï_h°Øpúãˆ[K€ed0*lþEú7¼Øï½p;{ĪÎèÙ¨ÊjoVŒy5BâH:“+bZ!ª/˜<ï~"˜‹¨üÅ8·|.W2KU8ˆl)›õµ(·EªþƒÆV;T8Ÿ:¯Õooá¾ÆpŠŠ´}Éû߆–Å€¯“¸+¯~ ôŒs¡Ù/6|p¿l{Zì|¿éøéÔ¦ÓëH¿sZXe‚¦ÖµLBüÁyn–~¢Ú°'¤Rcä7ÿ/ó/äNU-m€šGÓv§?‘žV[k W†òiݬ:) –& \½&Æí¥:ë}PŸDàVÕ®£“ZÚn…,„Ã"UÚí½/U¸ø?ÑuŒ‡ølqAÈ¥•«°½Á'5_ÊÒyl-­£¢9]¬×•eü-êõov’óø¯+‚Ä~ËgÈà `¦"Z[á É3 Œ‚ÇDéçw{t¡3v“r"-{q]{%JÍ}{‘žšÓÞ:yÄÍ´/; Š!}ÎxûäÉ㜠‹ªa7E W59áüKâ@cŽOÇ@k6<=Cš*žÝü“¥†ò$ùÇ"+Jhϸ-K&`uî@=…fö ûcNaëµ—S@ܱÑ[œÊ‘’›¾ˆÔFä]ôzü»@Ý ‰D>H†@Kó_ˆc ÂqŠòãåC¿ Çâ÷ÑÀ«4‡ ZL:±õ^è–Ô¬ÓäSŠï’iÇËó:øÑÙ³ÍÀ«¬˜Ë;G½€íãƒÁÓ03JKîir|ÐÏØÚ„2BÃgOƒ8‹µ×ö‚]¡4’¹ ÿ„ɤúŠ·‡÷ /o¸Õ_ÇmF]·%>Ÿ«Ç˜^@¹Gzr¾‡3k>G.ä®ß¾?®×idL¢(õÕQHÿÃqõY¯`ñl9™g› ^æ—À£ |¿}®%НD‹SiûÔF¢¤âÞò´´‰ L2àƒ\ñU(óK1;¨\Ðc…|vÓúÓZ't>,ç{ÕçÃÛÖÛþN\#Þy½Áü;ߺÙ/¦‡Ftiƒþ )žûÕÉãwÉ©{ó/BwMOgf§€P­(ЯL¡Ø»M¡ÂÀ€Ó”Hàó âo^·{€Rñ°Ìê[²•G1]W{#”âlôÅqa¬$ÞÞøMûs|«A ÔFð®üŸ–I~!Á…¶0ˆz+ŠGN8¯5ƒj»'jÀ„!¸/ÉpXsñ‹ô¸h²ù“ë_7sZÍL1Ï«¿ ’…úËð7{ô$|3Ö_]ž T§ ›·{‚õçŽ2ÎjEOÆLÅoXžì í¬µ:Í‹ aÊ6vL¸jØ\áPÝà4ñ+¸’Wò߯ †;‡K,%þ×f†•êÅê—9Sïð2Z‡‰Ýt5^ ߦ ZZ@ÃBÝR}Êó×-AAÑŒ=C ÙXÑ£³‡ÔtO›po·è‰l±+>páí:bh‰›)YÓêÄM¨uô”.Ò Oc…0.¥¼sTÜ·ŠA¥Íª¹~æ4»àsŰ[ûoÓ†«#WƒdWhéḛ̀ô`¯‚'Þ"äa8"@´{Aj`>nñ×âcV"¦Jˆ–!‡—°¤”0x†¸n ‹ß½‚+™v[ηĿDZ7ŒÓóB©äØy yŠG”±‘ŸÑiêiá¾6U:NžÁ!Ú§Ã Lš“¬fj®>$‘á(¥zø4¼E·JfCîô^¥A1þrL‡«¾~Ì¡›IyïM˜*` yz!â€bÈs!µ¤„ñ%1•‡wï߀%¯‘zèFÆáô˜ÿýîÜúž™$µ¿p:‚;`†•¾||«s“­+¬‰rƨ•K GžœíwMû2´H–Žc…$¦˜Ì9©p‚¼/m->mŸp£ÕbÏ¥zõÜÆ-\ØiÆ*Hj!±tf¬¼rÞiÆaÅo×ÇiHG`F–tõrVÈÒ3ÒæQŸHeL´$d“°kuE_g.wÂŒ^¨ÍsK·†Ï»È{án0ãŸitò5½Å<qþ°»­úƒi¯ß`‡Ì5ŒóÌ*³ã´§bŠW½£æôñ¿h—àCEñžžhùè,¡n§’À¼)¯•pQÞ«’ $QŒ™ä¢F(ó 0fh÷}-×a„.|âçÁ"zàu¹&UäŸaFÀ1^Áâ¼-à ±tQhó9Ö €qFGÎî9âÁ±×LÞ(D寃©¥­Å$ä-ÉQ O /g>t] ÇPz"ìz¡scÙ;™ÿtø}™jÕ†™qH‰y!lôš¬OÆÕÛŒ *»³yó­¿xÁžQSúÖf£D«Ù ÍÃ+@6¸D%¦G!—lõßåÜÚÓiÇ€S ,Ú*MyDV“æ„qtºP;}NBUXh›æˆòØîHÙ¢€åÒ Ê½`N[yÔxè¦Ú”5<ýh$?iëjíÅm5 RRú±Æ¸)—'g5ޏn&b»[%¡¶ëæÆ ø§-¦RìRÊØˆ7X«î!„ìVX[`ø2‹L%€$Úî>£·¦5‡@û^ÁõÀ½ÞOšÍ$¬ãN@nJ6LôÏ&vmÂØæÆU°U†fÖÙÆÆ5v2_Zˆp‡ú‡*ä ã)”ðŽê·éebŽz2 œéþë ÿºÛrî•+ôUlÄîÝ™/UJÕ VÂêÜÒ‚ë§|¥d:ysœ×7ÆU¢7o°Ü>›-xfqä·½™C.þÀ—m¨¨l×ëuf`x3h’ئíÜ=e;µ7Ug¦ª,àŽÑD13z‚¶ê•kM½R±g^¦ALǯlDt¾ùÎaoç‘EÕsUÆ¿}tµÒÓ|-Ywf&Ç4&o¬îrEZx6€K´•XÜ^…÷¦·›ì¼¡S“£káh'aTÔ\•FÛÂfI¢Ü J2wßT‹°†¤«™K+ÐùžÑ{2£<ýEÒW‘*ïÕTØ@lI–È(¥jÚ!¢:˜¶p„bË Ñ¡V$+®„JwþGeÐé 3«¶8R è¾àgUÂf£<#ÕÅêÁÄÆ¾¿ N¥KDãV¼ Ù<*(³¤‡[˜ÙØ„œlÑÚwƒ¡ÇL¦Ç=ËȾý‡£¹Á$ŠÏW{Áœ€uB-³MÅ$ç7åÈ\WÚúÆlâ£ëD¬?=êÏž„k-ENqüMŠzµtÓ v¯¦OÝ©^èO“œi¥IMàL#…ºÎ1›¶™@DwÊ¿{ÔßmžH›%FtÖQõ,ƒ&Ó;Û‹â‹™Êb7uhhüS³¬›ÑµI[ß(Ä”.Zj¿µx"%äME\omÎâh?Ð¥B‰2?ÂÛÖ†ô¥¨ò§©Øÿ¢ˆZ\7-Ê(Ù}ÆK”ÞE’•ø rˆÚÝÍ[ëYþ8ÆY?¦B×Rmn¸=-øgã–ƒäz™rµÄýgû¨’ÉùMŠº:‹nôr®]"3 õIk¿§Î»€_é=ŒÔ‘£ñç÷(tÞ²8È3±©hòËïè]?Àˆ.åæWí¨÷†˜X³Wtºº*9€·PÏ äe[þ8/»¹i‹g‚Ö|í‚Iú³û»ïÛìÿM]§KNŠ9yõ¿°âiÎï=8ªÍ&¡[ùÈ¥˜’µ5,û)-Iå}T_Ž,0Ü8ÝÈØ±—=ÌŸ@ <ÞÊAG áž°dXX¡^¹x™i‰²(€ðäQ}t#’ÆjÝ/…ï­øòÌÁª¤wóN¯ÀÆ•ñ-°_?í›cÎ0lhð‰=ÅGŒ˜†êB‘ oéûåµda¨q‘£k&}Såt“~Ô$¸Á½õ…¹m%4³þë•­Hèf”2Ä‘ÃDêeU†ôÄiUèL;Bó̆¹Æ§ÄÓž’EˆàdEõ˜³ŽÎ£Œ8ôÏ"¯@Me¼%Œ[f?r8EîÝ.êÕœEtÙM¢Ñô¹0»TV%¯ÐC¶4²ã9p-ÁÙß.<á·*³ç’1ó›sG'©éY,®ŒKè¾çWdqë<¦­-æò!+éÚ±ÍÕKÑQir@[ŠX É&q‘zÎüêw6 \/'¥5Þ»çh(*ö,ÊwqY)ET§’ŒOØŠê}|dõ¡¨ÉÓï*†²È:”¥ø5Á߬åŠQË%FAz v‚84åøãC Ä3ßfÏTÝvæ××£†ÅGîæ7³Š>ÇTLIΧ¼#ÿ—¢¤³®žì›0šr„bC?ËážNm>¾©6 Ü*ó®uD¶œÅlÌì1è»2Õ-V‰ ¿Tü@Btʳœ Äl¬ò'²uºaCC?KëÊZP*2c"ë™.éäÝ á<ó}·„ŠwpdòÃUÑr_¥.Ù"R©àÓ½H£<ˆà2^›âsÿž-ò•·Ç§k(óÒ9],BQ(g½ÄÉ17=Sè 5ÂiÞ³ö w"íAZ)@ƒñä—†c¿C;2ƒØ± ‹@+lÛhO•Ä'˜é­©Ã s•°¼ËT[ú7ö¬¬*üb-ÁqôÑ £Còû&AÌV÷Åø?ã’E `¨á(å±B™Š6:Êojå³:WPf¨`²:ä3šdî÷ΈYñ9‹·×£jÈŠI²b«cÅäí3]º!}À¦ZÉl"ß6×í{‰Â>!êÛGiˆ¬ÍyO­{ú†ÈX† &Vä_‚æ°Šå8¡Ð wª¿2¯c@ûN¸yaói†IßÝmÿèú±÷˜]iÂe³ì0î|+aÄÇþ„+3€x‘ -¤CÍ+¢tr TáNoMª]³õljQ˜Ê´¾xÈ8äN#ºL O ì_ôc–RQ¹XÔå!×úVµÇŸ¡o°î'6D¬‹YÆNÍ3Î,ÊEüÌQî-=UàÚ@°„[1(ÓvWu%è²0Ž‹ cºü'[“ï½þö0„¸çª•{²Ô9N‡ìg¥#­å“è}øE]Ú_·& ¢Ù ¯†iB 9Û÷Â]"úY¾Þeôi¸çSzÒt`w¢—`š‹;5²ÿ<%xë€ç_äÉ‚j‚9=Í|Z~Äà¢Ú?çÅ©uîW—g+ª±ªx,áZœU?»ÚŒïœ¿ uÒ;é|ì%’ÅÛòGÃÞhÎCâCë:ø}ã}×¥k«ÞÒŽ ‡8 =ÎݦILZpI Ä<—€à³«lt…hÏ([iÁ²‰ûÄ5O²2Vkám…TO²oýY2·fÕÏ`¨f*àœÝ~i·Œ–!xáÃÑuY9ªÉâYÓ 3B”À¥Eo'ëI½µ2´`E]ÉœT>Å…ËB}Rñ@ìgÓ8?•‘¡(9 ÛS|J}ôÆîÃ7Ì&ŽÊ}*ÉÞS¹£Ô‹­ûb³ÏÆ=WIÉLr2×ãsµPzê¬KG6æJYO«Ç2Ê]tÿfŽ™Âߢ¾ÜIû;Y_»Ù‡à“29üƒôýDÔ¬ÇM¿ÕTA›|Ï-·L©]Ý®{VÔåÓ%½‘¿CizYÓv¦…šãf²Â“W׃D¾ÜÇÿ§jÁ JziäÂîžáe¼÷‹ú]Z¼ÿ%â†Ò×Ò)‚¿W°´R^-`-F¥iD¬ÉÇÄ.?o0t(}@è•+^Hï9_€<ôûzЋ€Öƒž4wÝ DÖÌJC0ž¢`(n¥'òxú§"/Ó[Õî×¥…„—,9•ðNÉüP‘D»‘•Ö-¬—u†mŸ‡™%62äOħýÌ2VKhbe7f”àÇ·ÒK£þ¨à/Aúš‘üå»d AËÌv‰Ú–P‰"–?vÒü{±‘v$ÛH-·™×RTðÔùˆ:9N—À&ÌÅi–ä!^NŒÒº¬ÏvHîö¸>E"¼¢+Ý–LªWÊ|D“åþNK˶¬•éy ZДhƦ¸ñx†“¨nC¸íÎMT'O´K± [œêªzµäÕIŽ&MÐÅ÷ZtJâ¨Ì·É7 Á‹®™øXV/öøêûÛîc1±ì*û½.ÐF!:¬ ‚pÔb“²}wÒËГx—\ÜrþÚ!“„νu»êœ n[…¾(¶¡¤F?‡Â4­v0 [6SÞ®X ¬Z…–Ο «·ô¢À%NQV°Çx½; ”z…¶6ÙPbYâìé܉v“Á ú©!\ÖS†C ¸”ÝÜ•ìrÌmï'‚J ceÁÍ®ã.^ª/ÊÑX5»Š¨•WW $ž 4Ba3ײó¹YàsªXµì™B–_žPnÒm÷èš¿àX•«Ÿýf`̘׫jã‹n®JTs@ŽªWlHZ÷éAþ—>ÿfâ;Íó4ó»–i»È@Qù©†„ô¹³Ø¨ªm±?B%<¯ËÍ ší˜íih!CÖ·e¯ägeP/¶T2@D§n[N‚ÉA]q–VB*mOKnoÐühèm纟HÞlÍrùãès~ý Îަû˜ƒ`Ô—HÞ÷Ç€üèa> ²ätR;†»¢+`«b=å#‚H`åYùÖ(`,L©F+Þp!„È]¾ ëPF¦-mKê”T'¿µø%TÒí™õò0¦.)9¾`³žçaâúÖ‡9OG߇otÙ—yÌóÜ|±Æéx•* ÁaƒÏ¾×ÍW´Ã"Ÿ®:ìq2é·=œ´ýH¿iíQ¤Þ­i¾ç2;Š=\Š2%Œzv´+À&uîÙË2öªX5Þ˜6SA0éÙä˜æf¿cȾ%¿Â »QutA‘Þé¿n?Í÷¿¯Œ[ŠÊE'ÑO寱†Ö_Eïa´üxD‡†©9Ù£Ó^°%Eþr÷­Ÿ¢¶FÚJÿ‚aÞù­¬ÐÚµwÛÚ6=;R•Z\ËA°¾íÝPíï,àí$Qy'P.·8Òg®£Ä¥9˜ï ,Qã±j;ó+ r2Fž vcbw“ó?èôÖë5Xܘð›e³ü­“?ä,ÑêÅ3Ds‚ˆmDXó~Ý'3¤2ùˆŒázÃRgô{+È·SxóÕ2*„dj~ë0ãè\Eã»Ëâ:få.ÕÎYé!»üª©‹ÊÎññ&·„jøÆ•ãç=%$®duê.1íØª‚È";­÷ïîvèÌ7Ö±ªæº!ÇË5T©R¼°Š®6øòuoUŒ“äó56ö~œç9¾½°¦lK#±A¸)u Å7TÏû>ùVi:ЋâJÖõù½c„¸Äw~/aód8™hT·—ó.Dr4§Ã¢#=¸·ÚÄÄ…ñá¬ÎFÊ iGž'Qé!A]œ! '\$©ÀŒt1ƒèjX“›•³}!/Ò Ht›³ëó¼[Tëqè˜6 ÃÂ1„¶] æQ}×z˾ïÁ8y;wч¯ï0ã]Àx'ÆÄ¼´;ÒÂ%ÈSÈ· w¦uº 9ß’M=:Â>Íj„ïa¿*^Ù–œ•‡XÔåÝ 7í¡…±ÃÔìh”SuöœgQ¬]$»¬ßRv+ ¤hóÅÆS¯{ÏáÓXoL—×®ÀRˆò»-v²zÉì7‹­äN×1ã÷¡¸>¬ôêk1£)É'±±²Æê‘[Ó CfïíÙ+¬y^ãfí}=d ì"-ÌÄìŸøòÖè-{-õ*Vðàƒ…´.Vn•苨«ñŸßGvɬðð»‹ø|#·vk ×|&ýè†zßt׸O«PúË•ÏÆ(r—‡)h|@vúd× èóßßýË;&=YƒbM§-'ÛÑ.dÒŸxd¶z -ßó-²É‘ %yržI€Ì¥¢ŸÅ ®õÕ˜>—Ó^‚›€Å)2‚ëE¤ør½oçû.Ir’Ýø•˜SÅ´9~?¨8ºZ €ÝÙž†)¶ø4û–ý‡ËK‡aZ÷ë°2tòŽ2ÍÄÛreüÞ 3]Ç=tËå°…SŦQ®u ÿ$T)34 czº>*9—²ñt>ÅɰjˆÏx0['|ÝÆåùäv~¼8StF>Ïôïp¬‘Žu„D»út9?g&+öbί2ûYÔð˜²Dˆgÿ é™›ñòÝgÉ)t .’Ü®•zý Ôsuj”fŸ˜g,Ýhk­‡Üôؘcc&o”ÿèýðo¯I3)pO_|(¦4‡˜X°žo†nK VÔéMîɽÈs)ö›!SÖ¡F$·åxm~H;¡˜ÑË,ÌÄ‹G”bÞƒþÊïÇîëBR3ݨq†Uºµü)àîö¶—VltÃvX¦Û¯KÆÝe°/É/7ša@uçüVŒÍ…É&ù« Á¨cQÈ,“Cøb'+*¼9žâ)–vÙ¾Ò{ó¸bù »3{˜U¼GfË#\}D¦;ñ Æ°óÐP’ú£°ý|°Æ-z±Ì´ãVù"?†û×(¼2ñ6µœ¨‚óW­}ÔVT$Oîî¹(¹íPð­É¦—Q<ç?ß8–FiÒ¿]E”Üi4;r‚áJÝô1’„éûŽvólB3)bÂ1k ¯›ìn»¾Üù’7Ô(­Ä ÔX'ÿgfU=½A´çg/+ð³ÝÐBeŠÆ}ŠÞ}/oA´ôÔ¼fÜvÍÎïCrâ¢%aVÁC¤N3|Ú߆Èè„ýV­3 ~­Ìý 2¨›Lrƒ<”°]ÉEåërä¾µ|ÔØï\uDA¾9oƒˆÆ2ÞÊ*7î©Ò-“>ÑåðÉoðˆqŠcrŠÌÕ ±fPfZ ÇÖùV “6ü]LSu/Q T+™7ư€Ôœ¸ ž°|M©Å óZ’ù¼´®eˆ°ˆ'-ãš½Ó³Œ­Øîtt¬ŸËg4’íâ±ÀZêÚkÔ½üe”ûg)£p9º3ƒÐuÎÛvÈ©º.ÈDV-OLkÕûj ðNñY!êç¤ï¢±Ê¤P‹ìDU®‡‚#®³l×) _Á«Õß³í V8‰u4@e ‹d¤eÂ’´6:ÙÊ—\-œ5"ûþeƒ4¯Þ8±AYÐM¯íê­_k4B~h‰¼ZXÕ\…?€u†@î×ü-×4”éRHëÎâ­D$—àz ¥ý~/äI#ÙÏ tQщ.®¤*§¡~(˜ ÍSÔC[ÞÖíZèŽV³—këCÝ-1LcÁÛÆuT‰É9)ÞÛÕJµ)³ƒ%bVxL ãÜ8ÜsgMä›bÝÍB•ÇÚÊá?'­˜fcN<·º‡c™#/B,Ø%œ¡öZóÒŸ"Gc^Š(¶TQoH:“VçR–€úr̃51O_9ÞšS ápÝ¥+ç.jãÌŽ’zááµ_Dy%ȵl'.(pÍžßéqï•Κ1VÒÉ2 W|-I›v¨Ö]ÜûIz‹²OsÙÜc¼å\‰“¤…d^øJ¤+Òæ MÙ‡f‘8€î³ïÏg¹h{† TN4ÍÒªÐ&Ø?Ê*Wޝ‡7/ÝcÄar­U>^¤‹Ö‚¨×SÓáÒ.9z‹’@$»&WÑ%°«= šN¦†«Ç`VY±p÷Ý\;7¿7µ¡äç†ï® Ó² fžçf ÎL¦·‹ Iã]:Ïbqª—šéÇœø“¡?ak(£9^a´0žjå4ÈžR1y WÅ}â6ØRڟ_šH ©(ø¡¨ïCg†:îÔ¿c‘bæÚr@_ tÂì©Ì˜¹2ž ¸ÙGN¥”ˆÆ‰—¸ÒçÂKüiïÔ@N‰lØ9´2Êqn—´“ä¨Þ…­JÕSœ¼‚ÿ…y§Ížwº‘µzz›ƒ™ø§aȇm* Òû•[LTLå»G´§èñ´ ¹¯ì‡ƒÚ™ª»ḛ́1…m…] b|ô‘ËÉázùˆÌ‚Ó1‹ ÿ·HOyÞ=ð x PNN“hÞAJB4»š;üO$ž:bñ„$7l®14èJ~½+ÕùD8æ{5ÿiÐ|Á6R{Ԥ·ï0²îöV`ðéâ7ù¾ísvï¼oìŠ!ÒØ‚¢&­d(V³rÔðœãY ûXG8¶£ÁÊë÷lird®ÀBŒXT$Ì<ÙÓ~ðeÚÑ"ra œ— ·KÓÇÑ‹õîÒ¼ö™XVi«hRS,c­Ñ‹¾vÀj9!ݽîiÙlgUØÒ¹-£¿ú <¡ò /_c„¡ùf-æënˆC£'îe=0rQeåW‹œ¶ÝQ€;Nä«¶%9f5’báá¬LDà\½¹ÔWÛƒá{ Øå[¸ÄȲ³‡ZÏ3þÛQµÂûkPâU Û©0Z]ÍÕ\Jk쌖7w ._¦9ü6æ…è"f÷7í]…ŠM3ªM 2 *êê‰J„¼VÛ+#ò?÷ý¦6‚¶PôžÈµIáUéGОFå›È>4/Nˆ€’ÈÑLïν‡Øs»|°ü¾Ðé8‘F¼å8ª=]'.CL~Hxk©«¿ê+lÊw7u'Ü›ËP ^ª${„°¹A©þ0É>XИe}e%UáH…­B­ ŠuwBõØc˜—KiŽª×çYu¥2`gìãPËø³È}£GÍó¹ÂM$áÓ˜nÇãÆU~(iY…Ãtt[Ö„j¼ÀŒ>m‚2ŸNšñêt³ö›Êѽ׊³ùâãÈ*ß÷9WßÔÖ«—Øöá° MÛFB“Ÿ8ƒ»½ß\ÖP†áãú¸ï0£#Š@í® }ôÀ72£¶Ë|‚›´êÁ£×4,µG ’BlW°ö5s¨6©²0ëŸ4^9D¼ÿ¼œ«Bâ¥#w®|%p'> -‡Îøå»P†œ½ì‘_¾Áø8?ÓU9žúÁtÝ&F§âa«ÀÜaýýª Ï9‡_Ã, 䜛ñeÏ“j‚õ¤rðÖ£ªTËtlOYݶ¤jižMß÷Ï·Ñ{T6\Š}A²skÕü)ªW¯tàJ•UxÕÐî2‰XË—– ‡{ÊqaódÈ´ <þÒ¦þÔÆz~póÙ4ä6#ñ¡ÁŸàqWåQе‹ ÁÒtן¯p‰b ¼­ ú¹W¿ðêNȈñße“M=Ÿ/xÕ:ìYG a=þ'Þ£ Ù å]#CWæñþ9/ƒÿrH4£¹æÏ1·‚)»›†Hº¾¯“H \ÏXSŽÊ~{Hecb¸-¥Ü“¤Ö:š‰S  •ÀÒ{:ê**ÕÉÞaàç…9õö©Eªz{ÏMr>Q÷ªšL}LI(ü¼Uð¨G@ò'ŸÏœœž±~CìÔ4êf1†2Ú@R¿¢d l€ð<ÕÊC6?ÒV"Ú¡;¥»`o{È(IY4Qñ“üªG&„7‚º­ªØvCÔ[ïÖË þ0V.µïãgò»<ªÒvß¶ygÂ÷ ȃpÍ5ÑJåpãf»œgÀ“ÕÚ×Ý;†º®{OЄ‡É1gi´'°o?c €ôÔ,ÒœäÓÖ*_àÚsD÷4ö‚Í9©ŒžÔ%T1‹‰âö©¿ý}À|R ¤†9Š•ÚÆuØØ…ŸpŸ0­47 Œ{Ìt#ÆvKæÑ÷‡1Ád›°ÖãÊhVZ^i’(€ ôL‘Éññ]V\¡â .kê¯Ñšó>X ¹Q·DüøŒõ“—î3[R2?˜j.ªRÖ½’<pÀÛ)…â¸LºåÍ0šÁeÎ|H˜‘Ä Ëu!@Ôº‹èâí! Ø‹j®¯E ÙŽz™#è笹 ç›zeŽyŸûÜW¤Ôª»j$šáù?Ç^†¨d~QøýÏ…ëÉu›´x2^I~É—%GJÂÌÍ3‰&ÆwŸ {ÀQ-T ~ IªÓ„b~Û(Ak‡2²IóœÖ¯g£QCöe~†ïSèÐF(ûÓ:‰|Hïôì@áûœ mVz‹,´tr"KN©l>x³e…/p>r4q…¤ ðNËιQxR' ß—cøYa2’”‡v™á=ûŒ¯üwäd=Khÿ‘ŠÊãÔ$FêïÍ!àÆ[†×Ç—M½Ïúå½Göm%fh%da‹cÒD”3ö»GábC¦îv¶Qt šSúþI¶WŸ¦ï†Sh²)üÄ/Ñ&Fª~›‘ç7ýúGš\ÕåmÀsð8 înª‰b [ËÄî?±2Ÿ¤ñ‡A„ÁzÒ›q±+@qi0÷dYåí+€a²Wˆo7A!’–:áÚdú:å¸òÁ2Œl—ôÇ9’ãêxb.l¢-Â…Á_£Z^Ë­ëÂÕÏó¤K_D·4Õ¦9»‰‘îã>©E†T0H"™ÿ´sË6ûgù,gœÜ—ÈÊ㟗¬î[4±>%:–<÷ÐüpÄŸ¢ ¥÷ .ªj“NãO&NIÑòšBœ‡Æñ'‹®3B–l\Çå‚ÔÚRC}Ž‡Í·kõ²{•*PZvä{lË:¦©³57HûÑŽêGå ÖËV¯Þ¸v—½ˆ2Ì{‘ M[B%ô•Y“":¨­ñÅ¢Æ+·×­à ï–fSj~É \9Õû³ ÖnEáÚ1î'¦¼ÓW–µ¿·*¦žuNÄr<1lop eì%™%#›—‚’~äaHZ²²æÍtŸ—œX³ÜWXùÊõ)¿æÁ£†&~#™|X3^ éûÍEÅÖið-…KDtŸOèôÛnèíÛÛ7Av}¯~˜*q!3II(þü_¸æ?;Ç÷ϳ”=¿$6uuVH랤ƒç5î6á¢H1NâI= g"jòÂëÍ:5ƒt~°F‘_–¾9”-4éwPæñàúÝ;â!:i"oö™ÛÆ]!Š2MI›zLÁ"Ú&É'³*´¿D” sÜé.[R&é‰4;êtÿÓ«-/ñwõœÖ£â÷(žÕ›9„,ÉÅÒVäOä xظ‘8îaQ·3YVýî¿è¹%‘3f¿ÛÃèÆ€à\+Iù…Òxa±ú¼èš©—c‚+(Û—&¶…ƒï34yÏX3°„> +.[µ-_šV›Ì;Ü%é+`çÑ€Ù`k4¡"Ý¥\îçT[öb‰À*"|T=sÞtüÇGú[ >—sÁêVK˜«¹šÿç¹ú…˜MR±˜æp˜ÂSV!ùZ[î°o`/}pÅp{Sº¢^W2äkÞ¶W ‘A¼ÐµÓS':—ª×Š> V¶MS 1¿´‹×áß=7s-jeä«Ík<}žN§.ÃĬm.?6n-UA”ÏÍB.ãê_þu@6¦®v ©Çähg Æ:8ИFÑàÁÛÛ·ü-™›4ƒn½É«‰õNùøŠHj1,™‰óªFXbú:Ö$Âçx¤K¢6FXÆYgx)ˆMHtÓ¢Ž1ÈXS2ÍÿÖ ]=×½-ò| sÞ°†EÜZÛÛý Íùˆ)Þ¯»FBr}k˜Iåa­‡&ûYëP «J–¯Bî‘XVu€ì¤„§YO6‚í­·ß óùÓñŽ#òh£©³Ç=tÜÄšÉHg’•}ÐHœ{cÇÞðhØ“cÝŽK]pײiÙ’9maHî¤ÙNÊÄlmABFæ& H2Ž ¢Ã[—>r­þƒ;å˜÷ÆYp«˜;³[`¶ô}Móó¸ŠCþÙ¿e˜ ÝŸì#Ó},<½’³¾b4ÌÎ’ºNä6Uëi3Ô¦†l…,$’®ªÎ›ö¨kÁ¯HJ<«ý@ª³*Þë@Ìê1ôh…šíƒÝ×mÐÎë×ïnqÖ’!‡¡Q(«ùÓ2äVÍq>¦§ÝýfYs R-ÌŠ@o®þ¤P_-ä#Dw •ópÞƒßX¤’ˆ»U.NèŸßÈvéP‰%öêÌŽsöóR D'÷1{ÿØÝøv¦ØF‘±È¿˜÷Yîg(‰ì<FeùÿT©Z>A¯¾ÀÀç  "_Q.Yˆz0ÚC&a/Ôá¢Õ®¸d¸0ºÙH)“™°öø‡ÊÉ$jS&p*n…æ1‰O.JäÓÎø›_>iD:éßÓûÎÞuO¾±*·ÁL&0ŽÕúì4 üI¶àÏ\±G'tï¾Þ‚fë tE§ãX·;îf’¯óo-m#vÔª’PÚ|¶€ÓI„I€x_ØV_ÿt-è'ì)ð×qfJôÑŸÍ¿mÇY†èW,A8Óé7E0ö0‡˜½ˆOY„ÏoÂÀB}ÓÐ ³.¡jšÌŸb‰z¯€‚A;ë;qr‘>¦û½––™SÏrFñµYónjôôPøÞ‚ã^û½owg‰#s)÷òÂHEÎG››m°‡›x Cb˜ýÐ"Bén@ÑÉ@ÅQ¸¤ûí&ç³\꿪'«Ñ"ß½R/Au: ^û5*»¦K^î³)¥QÁªA_ç72Ç•Œž?Ï4œê+Щq#¾}&Ú¡–Ò!knŒŽiÙ=yÁpwq€è!èò-N?Ó=:Ô5»ÂÇ}ñ^ø˜v òz´e¶E™`J×òYziävlY˧9/ˆòt¤PtGŽ„í`Ùš»‚YÒ7ùu_·•n„n‚ßMCªp³Ûì45v‰d^[P« Ñ{}·ËÉÄN¶0$y…çÀ“0½—ËeSƒ2ᚃeÜ7(mç ÓJ8«&iÆCÃ" ç~í˜÷™Í¬¦¯ì^_Ëö¸¨þ&£H™wM‡C Zc­®=$ǕЦ7ÛÔCo$tT 6ßj€ ³p:1bOn"Ìûú¼Üß_®|W8­HrÑ"º R¢¦$]Á9qgœXB$ g//Ié³¶gÏduœ /‚µîídç6E¦K†ŽR𭃞ñV 0 ^dJ~÷H†Á9ºAc? £×S÷ Áñ@Sø'î,–óÍf6u4~b¥aN¤ßiAÆ3eüô¹!IK i›«.üÎ ¼‚ð‡Â“¯åUVvÚÓƒîÖ SŸÄ+µ¡ òT¯­”õNùÿg£2Á4p1>f¬FY÷ɵ7²Þqøk‚E£î¹¡'Ö´ßöÜ gêG8Þ&“@ÕÐÈ ð׬àÍö9;lñÄùÖ@ÜoKECœXF.õAJD¹Ù<@dKñ³ ¿tê 5Ôjú—ÆðY,oÞòÑäf¬={[žøkœ[Q)3câBûwßúÏG^v)ûa$¾ÙûQ‰l×}P{Â]Ñ©ø]‘'ï2Ä/¬d9ªÓˆDW F¾ù3›¸ã:Õ¡>•ŽßþjåÞuÉ>º2ᑳ@¯°Gižzråžé&Óv@„KøÐx2— "¸MR\®H¸½Œó8×Êuk”hëdü>È㾓8Áýá(Qý‚×ù–R&”Ÿ‘˜lO]Ó{Ÿ[Åø™*Æñ‹Îÿ½ž.deÀŠžxîR*ÿåÚšþˆˆ"Ç%ùW°´ˆf«3Ï ¼˜{ü²ëD9ƒÐç]‘WCÒÀ‡!å¢9LÓpôÆ»ufù<‡1,bLgxXŒçZ÷ÖoŒÂ_œ©,@ TZ1 &ìÝwTÿ­Ú•~Ø|»…[| "§fzŠ×øCY'ÅŽ¯Hí“ánßá/lìÜêWüò²H´$c†ª±Â$ fá5¦Aņ|¸ŽâmMûŤÏûÐaë\ÏX¨Ž9ÚeIÒºý+"0íÉñÃ8vŒk)æ%ù ƒŒ·{ƒ ¡ú£áÈѽcO×eg§hht‰ÏŽâ¥—eL®Ae-E‰aŽ’È„´Ý‹€ù,*."K4dæqþ”jå©÷»ïhÕM‚¶õõÇ­QKÂ"@j•FO/¨@ÍV* h0ºIY3êÿ,ø1 hs{|Ç…ëY½K^øÛÛ)­´9PÊ$¸í|ÂfòTã ¶z1úÝï Í¢§,«ZhpY›‰Œ[éI7Îî„€w¦¡ÖóLǵs#4Dq,füS3¶9ħ¤þ ÿM(y²zi­%þ’ÿ‘6[miìÒµ«€xˆõ&ýØ[ßtÓÏb¸,Òê‚ÓÚ cÕ"ÔŸô‰@èd깟0y¢³ÜŠ »žGïàÓæ¡5YémÚ;(êxÂeºÀÙŒõïû§`Dùeª pΜŠÂ—á Çoî0¹ùîúù­íľ_?Ùšøœí*M¶4ïØï–W`ú[!Ƚô8¸Ù‡°æ•{˜=–fÀýI ïˆòì¯ð41¡æßyg½aðakµrNMý%ÛuÎ\Ð  Î±[¾¹œ„ÙÃo]ÉX%Jxþ “MÿlñhÍ’£5c^3EoDˆ Ö<ÌJÊÇ*`ŒM‰oæ>ùÁÐr´;_ÑVkÛ‚JÚx†FëÉ_—¥ÿØL”rÆìEü›C`i»äwm4†9¹¾ÓX4ŽŠüY¿^GÁÐÂ…œ–,´h²•Ü®`¶ÐþBÔ’¥ŠI,ÚI¤XÞa6íT/qGS°™ö·„±c¨f5E§rG+ >B©VáßAtù[‹¥÷pÎ  H©¾øÿ Ú˜ÏUµðâêá®1à–‰D©”€è­Q MÈg¢ÑUÑmŽq}ÐìhA@ªÙ­fÐ+ÂæÏû´‘&£L]ØÂ(Î"nÎïuœÛq:[ÁU³˜ã€^6L´vV»…“û™­¯5æ5—ømªˆ¦©Sâ]&.PÍìR,F17ñŠþ\ÅQœŸ@Ÿë, í"ÿÇH2_¯‘ûã¶þ¼~/=ÍäûôýÙ|™èïd*è°ßi<)8WS÷ +wþÂ<·2§$æ‚;Ú?(›À-y `ÇþïšÅøha…ãöhLIsr®®˜´Ê!r?C¸V‰aVÎçÊQ>õi„À˜ž‘»}k—žF–„ù2UÃgXð²ž|~:¿ÿ¨šâžë®äÕ‡% 2Ã+Ï;˳£Í?àÓ;ÙrÑ-«kÛaë6_!)üoàŸ¦¸ ¾šï¸á¸øÉB¤"kÀ5ZÁ£1—§ùγ” z§Ð÷Áÿ^óF‰12N._ó–Ÿ å-É­Ab„à¨ñÕ` Áq'1ã©YÕÃ?ãìHQÅ÷®³¢ON„ü2µ¿= öŒOÒ “§p3dI<ÚŽ¢qŸi[Vä'çÐC»¢Ù¾3~šfÔÙ™N¢Aì´Üµ“"ù_ü÷ߘXE9Òcþá¼ÁŹ ¯%céžñ¥ñìo£Ï'!"o ÓXL>’l{Wω¶X¼j¹/V èœÑp˜°Úâ=/é¸Òm{Î`@ï 6Øf¦[Y¹aéru;|›Ž×¼'Ÿ¬ µÝØø~‚J`Ù<‰`É—Þ‹¢]Ú¡ä˜1œ޶£¾´zã}UÖFðo褻oE¸ÛbÊ<ŽÉ¹Þèsåå3§§óKÝ…›½ê-’çb¿/ÎK1Tò˜:˜Ë7hDWëâxÂÿ¡Àâܱö3ªŠ‹ÊÜ €³â%Å1¯ÏžK^58×£ÇÁNMHÅ|º<^“Af¯Ðæ]2*L}Ó<=…]Éhz ×È¥©ñË‚2\82°ÎñâDýDèüŒ¦M yéqW¼~¬@ÿÃø©š´vJû†9°Þ…áU±?jø98ƒ‹¡DØ·ÃþY{PjºÛ<8~Ã"9FuJ Dî!Ü“vÌË+ì4™²}Å)®ªÞS¾/ë ’ÍR|ÃRYB…íŒ*gÃ|h=´ÁtùÒ#úAjà[ ÈSqŠ´g‹>‡œS5ÿˆï²Û!Gnìü݆Kì”Qªnt•‡zªw¡J"38«ˆuèM® fY˜ŽÐ'×1̬HùCuá­7⪌†Z }œqãV•-Ÿå/xhHiÛˆ†ÍV4KÍ% £°á_Èð¶°„‰Ø÷ŒÜæ¡~:lémÁþêæ¡JæÝÜð>F_EFíÇaeeÒˆÊdzAsÂyðàܸåùE&&¦ûÊòõ3o‹æMÓŒçÁÚ¨#‡ ~³¹Ín &…ñYÒ³—œh•ÿÍGV÷0}Vïžp{µ8.Aó×ù¶Ö´Þv?$˜ƒy/{éc£‰UÈWVX+†—1µ79¤˜Yþs$6“vWž[¨n'¼¢…¶ù`:˜U déä|*¶(LùÞÁU¼­$†ÐÔ|¥LFòÌ«f³Á3j/sM%ÛþÁ lPÛºÅ8º˜APBOŒt]ÿü9ÒoŽ“Sšõ¯¹$‡Ó”Ë:íÈy—n½¾yÉX«KëÛ—Q „Õ¯C®a+‰ºë?ô)¨vqqxL¿èb,TƲÀñØÚYŸͯUìK¿<«l¥¦tðÚ¾ïq6— qÄâ4®÷ÿGâ¿Îã¹nƒ£Ò[Œ*øfþ[O§mçoÉ9Ì?Ègpß±­"ͦAC«ágëýµk¯ù=¢6Ü8­`q95êfKJ‰hOÈ'fCe‹à0Eˆz€r«3ï“ÿüÂ[ª{¤2¸¼ÌÚøw#³}˜:~¡¦œB¶¡¸â8E’Ê:æø–XÛÊ×5-Š•Ùø • ža»Î¯$“‘@FQRfÓKÎ…ß¶Éþ‰U.8[ÜKÕ«J¬:½ ¡c®£u¶; *`ù3NÅ&ÇËN7yÄ ª4„¦ZM½´+¾ì4»£iýlœ‹¡*óþÑ/h»€÷Wi嬂CÏÛBájý'R¤X›Ž'QâT·:“Ûvåe MD‚¼§¡Z4Ê€'r“.}9دzëOÄišPi±ãÖÂéq6©‡Ó–T8ðì†Ð N²“Ëo!ƒ•$'âzj½Ñx…é¹ Øq=Õecf=€ßÜã_! Ã?/¦çڢ׬Ң؉æ~Û¼è™Ï\š0‚?¡aƒT¶pæýã°Á±ª-À¥dƒ"Ð9Ò±ËB&û¼gyƒá0Ÿùg¿•ZŠíÒö¿…û ñï$+I¿&Åè(=°csž1}œiˆ66R•ëžrPß;wØ¥KI}xs!l:Øý×.Ó«_b\½g=H¸¡?èêÝ%UþâhÞ ˜Ï#a³#.¡avµ°S…ÉdWÜQ$ Çê˜8!=|`ö˺ï÷ÝlN© &È1¸â(»Œ•½–¼TŠ;Rj!•Τ‹²±o¿:$.ç£: ™Ú=~Ž•s-ù‡m‰¡V‰‹y[UéÇPÛÝCq$俱8Ùbri="æ™Müáüàå&çµu\?¦ÙšEäám+± j?—¤)µ˜¯Ì?Ë6§X ~WösvÒ`p›˜O¥a7´ÜÚÉ]òáö'ûLô~gq@— ÁÙãÖcDʯÀNOö1šºürViˆùÖqQ–°½·…þÕØJ#O{ùÖ¡³=:´ð?@ÏHâE[§*¯À¡±æ‹B¡¾èª;”h¾q<š h5˜¿Ÿ'ŽrHÕámf¥`CÈšñ‘ÛÉêéë_SýWêŸð.†NjzNÖ@j^2ÈÀZEÊ>1§ìŽå!¡óf_ǹò‡)?ig`CòK3AÎÙËü¡Ÿ ɳ¦1† Í Ã³™¢÷£C \|‡‡D>zð/Ãß wÏ‘¯5E¢ ò 2Å´I2ö26U óvLü†ïÿÒIÝ·[ >¢·¦BØYu¥²µ7@¿+æ7¹Îï=nñ–” œ®0¦’% .[Ø¡ë ›éçböþZy$ÄÇŒ]ÿ/ûGµïAaº+zzüm+HÑ®¥ž\öˆ˜È´A@î6gø½V”‘ͬðˆDÒÊÜè,;`íé.§Fú„|^ôz†E3÷žHœÆ¡“ƻۨÖÊ{1ï×DõöÌädNK Vþ Õ¼:»;) ~–âó}Âý!´ S½µü)$iƈhÌÜ Ÿéìáò  çØw ™œ|Ç1ßX_+ðÏD^åbXMƒð@Ñ1¼¦Í6Ì"ÂÓ¾«‰Ö™Ì¹à á'H_HOôh ~ٺ÷a¹?ÃfÏZ˜ƒGƒjÌ„$5õŒgÝcnQ/jÓŒ0厯¶3ÐIPŽ+…QQ^Èy_ôØA~ð^ˆ®À­sÿ›ÞÉjf—E6Eø˜A˜½6¾ìkz#`7ÊÎÆiÿ{2,ßDoCVŸÖ϶&«œ¦oPÛjWªŒ áÛ :ëe‚a¨ ’ëÿFä }„ÂÙwµ³×3±†¬+ΑǡŒ ÒÀą̀õ½Gºæ"#þOë;Ìœ8e ÐveÁ 5¿a›v|Arųá}Í×5„ÑÎ/Ö´ì×›×ñîÑ}£F{ócÿ‘醿’gP…3d‰“Ô¼O½`x¾T VOï,Ñ=ä¹âØ@{%´Fê‰ò(0[ÑÂTéêi&s@#ä¤!Cö ÷Jj°jOþÓIVbtq÷1Žðw2÷¾µÅ“=ÊOü²à‚á¢êú%î„á ¨p°¢ÌŽ%²èä W¾ò ÃC7’Ÿ;,ÝžÐc±·CðUÐBâCã(z¾g>êpñ݈úù÷!Øã8ô$/JÇõåÐŽŸh%ÂÅ"Z4c ¡òŸ»êDMDË>}ö°Ÿa‘˜—fä/‹¡« ¦L†Ëjhk´9éûK ŽB,B¥XÑ·SØ.–gñ .'y`3ï‘æŠÜ;9lÅ’¡ÕO˜»£èÚå«dáõ$䣸_×Dé m ڟƽ[‘¢4 V¼ñ%­«1„ oã…åÛ¹›aø0“lÔjÃ誰°²#{F ÙÝü’ìÛ"^¹<ÚX¬4o.8zü‘2õCh‡§aÙgðN€,÷f–1îœÇÿ ~×u^ÚLØÍ~Š(‰â7~Z†¿g{;|‡‡>Ý{MšË™2  ôý®ÎmO&ï9†<–z· Q9cffšæõ±äÌÿX)²ùXI8¯si{Žcr&òf”-ɺ»¾¦$¥g+ÿ˜'ËGF‚áAD¾³èµm³}k„Ó„ÕL~PFåýäz%¬Ù8ÞüŽ0¹ôi366µ+g­ “˜ ££«,Ìv³§$˜Ë1Bþ3-ÄSROBæP=1Œ] ü u’…‰ÁÐÍ+GO·Z ¶,a$¨øàËš4ÞËâ|o{¬¥ß/ì¨D¤‹uñ˜v¡0`»*±&ù²Cåü’̪ý ¾£¢†ÁU•Ðã?*À6kD î0é€<ÿ=˜M[§N[–¸ñLLe  †(yÙãÆäʸyZ%’^†`÷9{“ч&ñ±^à ûÓy7) §xØ0””PgœàÊŸG±ùvïffbヱ‹H2RÌÝÜW±~E±—z¹DGVv„té]#ßA¾²SDQÆt9¾Ô6±†­*ú²©iðΔž²çŸx¥r±‚øÅM]¤„ &> ³®3IýëoÔ}‚C¡±#Ôbâ?õ¸{Yƒ5#¶3… ýŒwwçoOdwtcãÐ%WMñ!ÃL»EQ«®YŒD‡,®¿ºã¶ƒ¼†áˆ~Ÿ£³– (鸽ËšÞ,3ÖñÍÃ+¨N‚°Ò%»X—dm9wÀ¯Í>æcnßÁÛž‚CÇhú,ë~±Ê‡;.wÑÁëÑ8x)xcxw¤Ä­ÏÚ—2è«É×1°Q~¶¾Ê6ÎCRðڮѢˆ¿Ñœ½çÿe}¾Ȩ¬'å™m«eÕw”²YøFÖ¶ÎWµPcWpµ1Ç~¨Þ{:€ßîúù%LZ›D(dz!9æ¿Ö–)ÊùL©TÚt÷]v~â®ÜàŽÕCÍ–á*è½|aþ¼ø¼/eỒSiwô6͈ü™*H@ò¾@ëÛ£©àÁ^¨#¶Ã¥H4´B›'²D:ïèÓo º†Fš{mÛPj#ôýúQmÎc¤Øt9éµ»ãe¶Uáò³= Žÿ—}÷-â7§¬ œ»ö  ¬÷ ÄåO~ø ÄkÍʶБqîXôJ¾cO9û§+$+*ƒ×hø±þ®Ç ±—3ý¼Õ]ÓËI'Cà»\=ÚõÂV2d„F#q™ÙL¾mãœGåß*Þ9r&bxÆÀÁ .Õ¸ÊÙAÍ ;œ•÷·Wüî"oodܤךúÇf!¢ÜҌ٬€ÂžY]7Yä&¢L§®’1¶×]¥’1<Œæ…§¯{.ÏX˜óÉï‰Å¥“m¾ðÐÉH ·27>xl¤·k ù °+Ù2;ݶ- ùÝCÅ€(«Ã_¤`‘†w­€t.D-Ãï\o¨cØ€Ú]izÚ‹TÍÜ©íÂó¸ëK0›ÇO”аûÍ—¾åGDMœcoÎlEGE~¯ÌèYH*Àà »ˆÂw%M­HÐkâ\. Äæ“Éhu¢žÇNÈÊl°ïÙŒÕpBŒ¥dØÇBˆBKãƒiðÀê¨ýqtOÎIílÙ-«— Îsò! $Õ£_ €*õ0ÜDù¡ü9]Àjš7$à ýkÕ Ú7~Ÿ”šÙŽž8„ks±ò¬ ºóa¹öªŽP(j”~5î—OH¯ŠÑvïúµ’µRü#€Â%—2¢£h¸h(_56ÊUþ´_£fX<ø¢O†½ebrcá4­A¥è~kàt€4ܤUìêò©!oLy4bSnÜ]œ%V¤Üg‚J”kg PzTÊ{ª}Žý|+w©¶½+‚Þ ½¤f4ΈØ|Í›ªÕ•€%}bÓ»ÖB(Ôݽî•¶h›'Y^Qâó[$¾ÇÝŠ³A“ÔMM\¼¥Ð;Å£ˆV AÚHÚ¹íd­f™÷pùIv-Ä$€[zt4°Q©+xöëçµÔÀ"òh‡KÌ3X:9ÕmÖôò¤1o­ÀĹÉÙ'6å9Öט$îû.âJØ IB; L(ë¶$£€ñ®ú1:ËpC„‹ïÄÎ~ŒT𮤠¸•—­5Šï:‚§Gž/Mت0TìX]4§±“Èœ‹!¥Â2ÜsãbqF¼ò@.œWÊTŸØ‹:¼QÈØ¿ëÕélRz+ŽÄX!m Ä?d<²nÈ,¥hIÑ//‡Î)Ûã&¶-ÒJ8ܾM[5îbo~O*àVù+éh‚v“ˆzd ˜TþˆÂ‘)5Ðß÷£œôLÏ~^¾óv ¤ç»%3EQLgV X;áà •Á0 hÍa7ú&‰z(Ô’„ø9— n£e\)—Zf–TÔ™|ŒÐâ˜cnš-)¿ùÃXµæïz×x¢çK®Ôã—>ÆCîîZ‰d¶…ŽE‰Ì€O4¡Í!\m›ëæ1}¶‹u4)øB8HÜAÌÆˆ?cŸ¿î3o<)§æƒiÖÎám1沌²K1Þ· ¹Œ¸Áã,Ÿœß|ŸÎͯ¨¯/@Ò2|r£š)nÔó½IYÜb/E¡içLtC]¯òž½ò`%ÅP<£Y°ÙAy…ffÏ+­AË»í½½¢P_ÄÿÉ÷d†Î¿íÔƒ.ÆÁ$ìÂLŒé£¤I4Kp‰û‡Õ(G8ÈêQ§îûÔ@BÇÏ–­äIþû­¬ÎŒ¯JxœcúØå7ŒÈù2ŠÛƒµåT´…ax¥è. ‹ðL4ð°’-HH˜† kj‘>Bônõ£/¨kb¼ŽõÆ+pÔ`Q€9lK²ZÅäFLP–œ›c_¡ŒÆÍjQ¸@T„ËàÛjÝ5q×)ÿŠléØéâ®’º ¡ Ì£¨-ò":JØC©Py/:†ž_˜ Y;~Eäî à úÔ#ôŽ:.Ükñ@€1³½ºÆ^£šÒ…`6ï:`…-ݨYøçWXŽ‚ˆVg‚Hºï\ýGJ¸¸F[)æUNëó»YÙÌÄòªÃ öwlAô/…€Ê˜":ÄæãK«Sá ¯8Ks —¯’$ìÎÍ òÑ¥½@´Â”lDóÍX0y¡O#•7‘U¸]ðÕ‹óÄ]âŠIùuD–á;ŠËÀK™o©·C“ˆ&ÅoXY3åL>œµ¾pnÃ2—ì~Ÿ{8ó z¿„RÃVzÝyªÍïÇZ¼Ì_±P–†ÒâÖUr¬ Dåò¥¸ d“ù ^”ï’ÐÄXq§œ’Ý´k LS$¢:Ê©ÂÒµ!óÁ §K…$áx[ ‡B2þaç7pm[”94Ö5.«´{¥­Ðw]Ú¾UØ Òaa„ƒW8hÚ'šÈüœÁÍ z!2Õþe·Áw5~yÃjѦ¡Öˆ 3fEI½¨±QÁe™¿аwI¥ÖÏÖnSmß}å{@ñ¦¸D £>Ü®¶z -¦ÝÅ-Ÿì ó7Þ¤ <Ü›DOÙ)¤ëj—¼XH‰ãêãêiN :2c×MiVf&•ÆæR;K­ólø'÷šŒõÒêøù„>R¨ô—ôþŽkRt|¢¦f±Î²m*O(~«%3˜ ¶Ç¶,lå×Dc68•>Á© t>øï£ŸM0$ZÀWo¶ê8¼mÏ0~/Ó>×ZiØ„ÎBëXGÊ&üµJﲉIŸæƒÅóàÀÂûibÐÏ]6ïÊfþ}Xr`ÁMF{úDÉæ:ª¥@OüÃwæ’ì>és$”Í')'ÚÅ•©o—j¤(gñör d#UF’òÞ/S†ŽñCßìxîH”Æë¦×͈ݯ¿*nîšUù;ç×0)B“àâŽ<«_–tù¶k)ë`‰FvQ +*Ÿ¦¹#N÷{ïaR˜Ö Y,¸l%ÃùH𲛢qôíY¨_Ŭx¿H¯[÷kðŸêhHO» Ù!!˜2ñê‡#ϵ^ ?ó#@ÑâÐ ”AoÑ+²Š~¹zúyP³dhÊÜ´_oã Éðõ_µXVðyþO˜ƒ$.£ß½qPRÀÔÅŽYÓþÆ«rœ“]Äj-½¶Î_;OiÇâ3Ê“Ÿ·TäÒ|€¡,œðÿ¢Î–šLKÒ‰§8>¹—‰0KìžuZêÎû•Ž'!BóYÞ¤Xº/Qߥ^þ±ÇÌç{ãÓ®(Îû‘XÞò½¸»Òb³;¯ÿ­ ?‚ò?€ý‡peˆŠ}WÞšBÛ$!Þ•òþ`«Îâî!¥’´[9ä †¢åiÀ·a×èÇ[­ß+ìZWë­Šì ËÈW\èÓ -³¬!IçÅ„´yóÖ/Qzžò*š‘3«nüîÌafÕ!7W°ê`vèi-•‹QÊ‘¨];ß³'¦„Y}ö8üˆzt¶M?W!byƒõ.;½ê©CAÎ"VQ9u‡^H ó˜¨O‹ègwóÛ-¯zÞ‡ú×í Oõ@Q\œÅ~µg’=…ˆžÇd:¦Ó:âQoé{—ƒÕ†Í~ÍO+C¼”O’¢Ù÷›}=uÖdÑOð7¤Ž1™«[W°¥4±¹øÐðB ‰ÜÜi>w{iC&t<ìp¶>;ÙæëÓºÔfè·VŒo¶$çõRË…~ÏÓžé2ùÖÊyÏ¥¡~±‚~Bhw—=ªî ª›ÍJq/Wï}‘ÿ>üÄ]âùñþÄШNùšRè7LåwLËžžÑXÁzå£âú¡k¼Ó®CëQͦӯ Œ¨Ë"Ç׳íVÒNÛLš·57D•áª,ÚÅϬNݬ>¼B”²¶* epf²>¤ø]|C‰Ð:<.ü-¡I 墖åò(]àPv`M°,H*ëÎÄé(žÑ/ò×5‰˜T§ L½,Ôq—j$œÜ¬[Ù›aëº4~ïSTžÌÚoΓCý†G Õ…"þîïjÎ0}æáü.ÎL†ýˆŸ¨øëRqü ÚnC¥K .f:J4s³Zë¿›ÅâO€6\˜ÿ2%J7Ó.©Ëo&fÙ`pPÇðWÈã%û…vAN‰tŒ'?„'îúÖA»w‰çèø¦ès;ꉴΪ Â1ÎÁ‹dÜ”"ó1Dôb>Ï+Y®WÍŒX¹>í°V|ÐB)NÜf /â&’Vòæ}C®4 ËUG°±âÌ`:CXHéy°O­Ã"} dp‚ÊïÎ0ÀÃîEØ™+Øÿ¥ošÍTr˃P¥–.~½šsFÙI¬Kƒâe¼Ð•üŸ˜zø´)Ê/h³¼0»9(¾ü`£9SH5Kü¾¹ëœpðEôºö¡ÄÍ6†j@G“S©çö7¤¶Ý,xö—îWPqa´„šò`ï>ø°Ü0à&3NSÄ®ˆ €€]¢å¡]£æ+[å ûâgœðÅÇ©d†N¯,´˜-ÍÐ^̰hE»9B TCLk³ÄÿÛçMë_ל;ù_Nð‰©°WÜ3}¥@ß ì”#¾ 63U-/žÔƒÍ…)·ˆ÷”.ˆ¥ÁôrTþ,©>=I/Ó!Êjå'׉ËÚVϰ ©ºý'«xÍóX…Pò˜÷l&~µ¶›6ÒM32y{¯Q>ôAô)¹ø½»#]²ŒãÁba-Ö³4Wåo 0Œ|2²¸àž`›_rzå}fµ¿)¾ú0C ¯ §ê">uÀáAÆX5Iî:D^ó0ÃÓÁ'z^™D­Îåï׬Z¯ÎL×:Õª$²;FÃnö™øÙþn–ðaãÆ”­"¯œf 4é@ö é^2*ðp}^`„ßw7P‚"]r&<ÚÿõOÔJÍ€’Z0Î,^gAžð  ì–¸7âI=×eGE|zÅSyQÄc­ ¿ÜíMdÐ3ˆ"én Ýáà† âÔ£„Ä0§=PÔké¢ m LJŒÄök±D>ðGøâä)¸Ty·9k±vxzO:B éCƒ)ݧǤ4±Òû5u£|YÔ¾çfýžÐJp€›Ùœâó±Acc…ípà×lû3NEPuaÂAâ‰6Ÿ9ÌÙp€À„‘þºi áR¸ü.)%3õ—aã@Cp<ØèpªuÇ*û@‡£òiÄIr3dxîßKYþ§‚O¸§D¬æÀ÷eŒÇ ¬›…NŠŠ2ïó×RªŽ±ÔÕW`ú|— ò{5öã4JÂòͪO9@×ôHÀ Y¢Øe"?ƘŠîNÕÍ‘v.° ‹ËiÿçÎî¹n÷ Ñß2 ûý„É *ªç^7Þ‹$yr½éÍìâ™eÊ]%‘4µžÅ.«: A¡¡¶† <3©ù‰ˆq¸Í­/OÚÍ›1ƒ–¬Œ@W$¨­a˜÷·m˜#o—&«Åó ,G±á‰¬×’”*í²©ZôùªP<)Ö%±}¿ˆ%;Y=yç(íCÐÕ÷ ÒÔ‡Åïy™UFdåª}.•ÊsÝzÃT„ä}^ ¤ÑævN¨z· íuÏ›E VÓU›^ ñ?j$Úí@ ¿Zšq*›•a ¾2D„iÏq´kV¹‘gWI«Qöá/1ëYMfîdÕgÏ“fÇáó/¡6ŒGÛÞúªUÃ"lG6·Às$H÷ÝAtLP›ûÑYFÞ5ÃYøcË}6ˆÔÚMÅ¡EÎôµ¿~öùÝË £®?oåß°¬]%1²Hü[© Bü_/ï(Bº¾Y£wû¢ÅQñï–€7“¤Œ ‚ÎZä@åuC•lüEVÔÉÙ.WÅÊk߈å¿ýXG)fW½J59I*î¼û47ï¹@ËOÌÝš—Þñšg°üŸsã3 $Š Äg Vò¶_¼q|/[+Ä,0ì³D¤ Ÿ}µÉžr­í/¿âgr]r?úXçEéšA—ÌëºkµÀ Dè$ rDërÕñÇ —¨â±Çlqñ%²áp|X—‘IFü5—ãV_ÅT†Õ´92âï/}¬á³Ç¢PôLåªü tíUªv_öŸÚk ½4¥ÿ{'N>± ÇÞíÛ•î!áTÉy€Ò^"™7ÒÃd<dž5ÃQªûŒߌ€Ã+9æ2x•ôriƒ|TªB;^º™YˆO½ÊÃ4Þ–†"h—d Dy‹Ò!©,O IÁw_áOÉ…¨˜hÙÓÄC3þ}’YÃñä~Ù%Ç8˜§YíKw³í[ü}YÔ¡©Í6 ÙAÓ«iHwáùwøM¿2Å>î÷Kž_±¡üÄ—&¸|€ÙÓ»ŒKy9rpñ¹j³÷žZü[¢é¨?Ñé¨ b«Se^0ɮ亻4*u¾ÌyîëeßIøOD³Âc¢²É$ÿ)‡“)vGü„Fp©,x›µ6} m’1Ö™ÂÞT¨¤“fõ-ŸåÆÒÿ¤Ë^ŒuqEé® Ëâø\.¨] ÁË5xŸQËÞÚÆ‡™É¡—ä»é9Þä£úßî~Ûã°‚;ØxÊd¡=]"mþ ,ŒSMa(6f`Õ©DWrGò¬^Onª™Ôd„àµÊ€´Ü%4Z"OÄLf†öÜj5ÚÝ×ÝæP9Ði§\ƒ¢Š3«/p´³+O(ª÷É:ŽS— Èõ¥sÄ1郣=J’²ËÛ©áE#t˜mƒN‡A~4ëié¶A‡é1£#ëð)À¾Gª%¾[níNQ…KK‘Ãÿæ;¿ECÛͨ ý릘ø:«ËbÏ:}zÓV\ÖùßPæ’áx>6 ½¾´ûЖÏY2ÿÃûŠ!±_x¸õ„¾kHç{a ˆýÆ¿ho[ÏW9ŸZ?0½ !…¥Ûe¢·ÚÒ@£XЇ],Ë| ù÷Zmn=Ôšß÷”Ò¶ÂáTÐ1í¬à<DŽ^ÿE,®åÌ~ßC4á'Š_ý §³%p¾Ø¹“¬öãáªÌIe¿.ÑM_TFÞRÝ.–²ñÕöó ³&«4!ÚÍa'E¿&¸)üîôʰí¬T@#KâK{ƒ€Ç8C;Ùwñ¼KeA‡ÞcÜ`hÇ‹¸áW –›'í·5hÍ5Ïì‘bJš»fâzn#~{¡ýÕv.”=d?‚Vµå‹!ÀC_Ú¯S¯öóŒÝdºJÆUÓöW|v@aàø—o±µaj§…¼6“vš¿®--ay»šêrÈÇøÄjˆâÛÜ=-ߌÍ'OMl‚œí‹þ»+‹«Ò ùG1R|6ÙlKÑ*ªÄÇuAäà{rdù(Ô7 lËT%LÑÈ;g5Àl˜ýA®`(ìá½âmœ—SúºÒI&æä”ÒDY0A¸{Û†C‘ÒÝZ®e±X„T±`ý¾S]žÇÔh6oÕ'Ã>@ÈF®hÀ©eRì˜&Üš<¿©ùwº”Ç9¼ë;nCh8uVA XÒÓ2§L€ËÒÛ¤¸å#sî.YŠùlžÛM°Ä÷=/î~(WyFÈGeÄæ&ÿ¹ôˆâ³G€‡`ŠË$,è*/íÈhIÔ‡’ãEii”m~Ýÿ\™|XJ¨sÎ)(·\È;òÀÃÉ ß=þÒMô±Ø‘ãž"™xËü…ÿy–ô‚zN³t¸“¥"&|r=GîPOí?cqÿŒÞÇ:žd°%LýZ±¾}Ó(êaùÑ‹*k¡ ‹)GìF‡gnÅZ×0ÒŽ$l…V cù†4)ZdcÑbçþaÙ¨ÈÈëW¾ÿÊisO@S)WÉÚ {Htþv\?µ„èª~{ô°;ðbñÉ\¬rÁ„ËE"7þ®ú™/xJªqC˜2€ÖîÑtÿ”uðJ1 i\¡?=4T©è4Ô‚³^¥æàI+ô5€#]¢7œfJý¿ÃãmOªñ-³ï˜(õí+N“?µ4Pu+ó|Ö„{çüÓäHÇÀ}sj5yöLÈãÎsa&6ˆ\E1üÇò?3v™cÔÎc ?ƒ ‰ˆm&þ¼uÓn‘ £jþ‹<ZÇÚ··߉Öv¶p Yd0­|iNiA»+âöÝT¢ ¬ŽÙ .­ÓáýX4ÏņQ¦BÛÉ^Èm°ð  ÐlÑ„;õ\†c)GúîqÞŠ¨B©–ˆ1NHnÿì+Ú<¤œd€–þì÷4ñ}À?#sÒ Ô±äáùŸ˜òÛàÈs‰iµ¦|±;–K-Úy;6 žGÊ:Rm¼Ýžáãã‹ÕSˆnÉÔÏrZÏÞJXúßR_oˆ§†ÏCÀŸRr'^·ŒìQŠÜë¶±"¡f])ìo;Q6_1UƵvAá|v× (Ãsêë_ñ‘´”0a Y$¤éìµ| YGùLèÑG§pˆ@u±¦Â'É2&ÓrÅBŽ.¯„²eÁ…ìx˜Ò]ñ±H}­îß2ïFc¨•X»Iþ@¼8Û/7^tåWE½ ŒÀ÷HöÙûtñ‡DÒgÌþ9Kð’Û’Áª=ȬÈrügÕR ;8·ˆÙ|b´»$°ÂÚ­uVÁÀpO‰lÚ¦§„¨r¼¾YmUKNÓ‰Ë8Êœt¸'lù#Õc’Àñ,ôõP§Ã"ƒ•¢P¯»R 1G´üCQ<Ð^°vêø6?Ò ß1sÆÂÈîÌ™XjÍG¾C2ù à¾I[ ȃ{P ‘>¸®?ɬ(ÿyʳåVïû§nO$@Ëî¿!Õ'cDlâË4&'¨C!˜µ8þ°Ðµ=J×@ë’hAh •ÛþɺÛï¦r¯´Û3˘*ªtƒi¢‚ŒÛWô¼Ž:®å,~_ù‡3<Æ­G¶'ãƒðæ/Ì‘ -up8÷¬Eÿä'®¾–/zåÑ9ë‹ÎIŒ[×mÒ›PéÜ*Ucúß[-wlánéð&=æ×M+«fÖYocFþ¯ÜAÔiUIšMòÿžl±€xYS‰ ¤¥åUC>ïdë^l¨ ñ°‹ÐÊ ¯É»Ž¯½½rR¾àQ-´èðIùÛz²f\AºŽÊxðð»Ù³ËCûQòóWŒSŽ*~¯3ÈŽ¡jÉöSOw_¸2ŸËd³Ì÷XJœw3Ýá8¾ Me;2K÷ßÊï™¶úÉõÇ÷(¨²Â>ˆÇÁn¿h~̋ך0ëÌ¢ˆ¥Ýœ§7 =ŽÝ"¾_KmR$çóåð ¹ Í@{gÈóÄJuñJÏçȘ]&I–ðä—K ÑU®z:àŽˆ$2ȃëAÁ¿Ô„L¬uX[¡«ÄŽÙß«0Ä3Cí} ¡’—=fTëÂlÔ|(S~=ŸÂßÚ„´Ê!TþcŽ–yH é¦Þóš”F¸dƒ´§¦6ñêÛûÉ;h¸%)aår…ë(Õ­ì…¦eµÔ]y=ÎàLhàëí|w¬×¡™B·ÂÖ¨)Þ?Å“×k6ñÔ>ñr{¯’úúî5tº[›v¨BWP¾ø`. žG5}f̯ uYÃ@m6¹¹² “ìH|.V^žÈó3¦cSg%‚mŒÐ«4Ë}Gói[‹ª/Ìpä~AØf§¦±wñƒ%‡W€™=õµ¸#ð7ß$OYO½3_î Óì>‚kûÝøöK‚;Üß×f¥Ï̈÷Áf+‡}Øï9„À"ú’µã3³—·7žÀâU¢(¸èiÖù§½My%øˆŠ ÑÓ2Lêã½ËzSìE‘¹Ù@çÔX?½OB¨u†ÀD³px0VÓȤ+«Àùvò`Œòsn²Ñ0ä‘M ;íÜX1Ø"è·Nõóð¤r1»Và="¡+Ûø©5“¨L–E@OYa‡óÈ•B’ƒàÀº­*ÊôûÎ'­šC¹¯}rô'¢[Aêt; ( ­ë/¸ƒ°ï+¢](,Ÿìêíßµ`d@†a)B7Ð×ÄÕ䔂r‚…}Ê8Ôõ‚³Þl­QþÅä;ÌÊ ÆÜý¨¾côþP–EìF¸ÿ˜iMAhòÁuÍnMs}§æCÒi¢Å¼Ôkª ¾ô2ˆ0NÞåóVm¨óÁ^Ï)²kE¼ÅG‘ÊÑuW|I øÞæ)oÖ§fÒ8·l_ÌÎóÁ©Æ%³Œëé_q& àØ/àÚ/„0ê Nì0˜CG{~`"©KÉ¥#ÙŪÌW7Þ³™7¨`ùÉb‹@¢ ðHÁèÂaDnÓŠ¸¢†IàZÎ0n”#ž.ìï—Se¬Æ}ð>º—R"¶Þ¥¤*JµÃù033V‘{ã§0ÎÉm|Á6ò]¨~¢Þ¬ Ϫãw…/«ÅIŽ b©){¿0 $9st±ÙrDÈíå·ÇsUy¦Í¦ˆœ ÀfBAÂk]ÛÒc±Ü4ÌUf«´¯þ±ˆ»Qòß©>;kQèæ»Îñæ¼%ȵ Ðp T$>©Ë_)çz#/&y2—„¿t“?5 3lÌ¥`o~¸ŠºUÚ[°&óm÷÷Ö+yIL_*%Ʀ‡ß͇8¼ùdpzÊ{J<ïB~ˆú«åWv;Üä€áX¨P6‘E1»¬˜Díš·‡é¨9ƒC¾_Cµ¡rõ¶˜A‘5+Ð+K·pôˆÆ‹¤t)÷“õ‰ ¸åº ÿÐmÏ+·vŒP®^'†ÛŠ9Ì\{¾9 .QMöÝ£œ3åÖ¡ÍvŽˆš€HÿÏ‘¯Tr•¶o•"§°‹j\QõE/È\èqQÈ\C÷“Ü^' «6¿DÄu´á*¢çÐHÿ«¨k ›éYz?QûÒ›:Z‡$ h-š(«+…y²;ûr¹‚Ñs®ŒÔC> Àñ£_,YÔ½õ5snFÏÏ2 ²iØ[í—H¥¿ÁY;’ñ_üéÊU¥tщH]ªv•? GEÎûHFD™  ®8…ámà̵A¦+š˜b:Ž™j>–VòªŒájq]z/i *YO6¶ÃOJÅQÎ "gÀ†]¤Ý±ò–Z»¸Ð”þ­i>й0Ä\¹@,¼½JÖ?žé8­z=‰ç—©vºU‚¬ú’hW«ÐO$çý™#fß„ÍLzZy|® c•7D¿Ø1t=>Huœ´áã.Þ|önüuºÙ¾•C@N×ßö¡›.vª+ÔcßϤQ(h gMKò ¦î—C6uã5†{ûŽRÙ‘ÿ@#¥ÉŒ÷U—ù´Às®it¼„ÊÁ»ÓNÅÀ©«È[x]x«R ˜>”Ë[ë~edPB5z”½ºA<ÿϸÐ!™V­pçÑ<÷öÿF¸Jsg,HW]hJ·Djdïë½x`GòóíCªê›(®ïh’u­GÇn¸âÄ·‹6ç>æá6fHè}{Ý< 7y3i_çRÂrmv¢‹/üð¡Ü²Dµø)“ã[«ÍGäDÚIÙ}ôp–Ù¬æV*GC³,(uÿß©‘!qƒ>ίš´†R3jNÑ¢¢ŸžE­ITÆç®™(TPõ‘±—Q#é…!@ÿ̸…Zéx¯‚“¬–dÊuÙ=RakzH[À7&¾Óc,=܌⬃ÂZµ oƒ¦£ê}Ríš”„:s u¢0.‹h©÷xýŒvçBZ|ÈbÓ',Ìr@—~Ooro‡‘ܶÎóÌü$ëð²t™·äÃÿL¾ eŒRkÛ[›øÌ=0Y˜VMv1R~&–z-ò4Ò\ ©“Ôl‡‡¯ìÁ/ hÜdØØõ/H½ÉgŽp˜kNdÖÙ9ßþ!Ë$ļÓïù¼oi0aØÖ«~Å&oìh2t`­z o*1[‡nW 3I»ýc,¹[ëLÛz ÖÒ/4ÎTÒkAiõKÒYºB:" |q'W§3n¹d¸GÉ'ýâÃ’ÈÙʧŮ`愎Â+¡ò¹Ã8æÝdé¡1–þªK…>ðäÿåaGoTvWm‚å‰@¦þ {ŒõÛ›rOõY¤e#Ô_Íè_úmŸ9zã‘¶™}ùááY3voé&û…ò.>R¼LcÖ“ÖÄåùor>ÓP‚þßÑÖÑÀ¯Öaó™ÍŹVÈÓ¦Q{ˆÃ á‘ÎQ!KžÄ]¢¼çìÜDiÞ¥J}'HL*ô®y6^:bOž^ýZfÏG— MB‘ªÁD(¯g–·fÃ^ÿ‘±ùìzUH´ƒÈŘcL2 JîTàÛW‡=Œ]·q`Àë6 ‘V“ˆ<ÖÝä¡bü-AÛ,•ÞrÒr¤ÄºôÄI(B•„/ˆ’÷¯ »Já!5i÷Þ †sÊl3<6ÕjØ£êT6tZÕÈ&œè_¥ Âúµ`_Ùµ¥È˜¶¯ç;¶íf€…G=ÂPÖØxï´ËsYÆWR¢a®¾°+½Ž „´m~Ã%Q½lãtwš ‹_ƳÕþ[ŽÑT·´/ewµ_}äãk©t*P;í‚™PÙ!i_'g-¾š`g—¯ˆG]–že½uÌ! góÅLugÁ˜Ü<6˜­;*öM j±ÙÀÙFI×÷½ ­ö¹™ ²½5n¤Wu(U×`0Å`SäÛrÈ oOãšÑÏn–ìH˜0E±¹i̵iÖ½¸Èù 9b™IÚ»d+¹Q_À$» ¤” d2µ Ç[À ·j5¯‚¿îCàC§#3‚NTºEº/L ým©•ïF²ŽQ¥ñ¡íh@ð­ š[M‹›AÔµ,9è|‹—OEí`¿(ª^- Bÿ—Ƕ²èŸöo>j#zwŠpÚ,0"ˆ5‘ë ‡)¥¡8(†Z¢<Çë•öÏØl¥(×¥M?CÝ_qkt»-`S-l±‚ГÃ%êF­ždbü»9ˆ·­4¨·f /©†¢,JÌn‡ÂRéý†ÿbÖz)o¬7ún‚]ûpHÀ&êú®¶v¨!¸8idˆ“<½W¡<O>šEõM?©àuT ~pêcŒ³>h†Þ“¬›¦èĪ–w?«# l6¥ßa¸ëdš_(K¤UôÜäÇQ/;I–o1,Ï z;ƒõ¼¯° ×YM÷z[0v´ q ªÔ|׺ Ý åiöq3š@ ù4ë›Î×~ôèDÕØ|3ÙÁaÒ,Å5S'-دÿí‰1Üqœ¼‘|’;…ãZÝA…úÁÇâ<ÑF¾5_€‡ÆÐ¥7aµc½÷¬ÛÅÃúF»öq ·À-xŒ4S\ÂïÄìêõIˆ’­¹ÈHhÂÅè‚ÑçàÎÊ]¡Ø&?ì\ßôûêÒ‰ˆ»á®À ÜN¿îÍx8)úͰ«(nr÷‹+½ÞµB[p»¦39ÚÿÝzTYyd2S&/+-Œ·žãŽ»ƒÞäQDͬÏX#kz]z)Œ­Ï˜HvA:“Ьǫq¾—“‚’Â?1óÔÀlŒFš®¥or¾Àg¹i2tf'›ø"Û°VZ=q[úçç ÔOƒÞy%«f!`l^ŠºóüŒtÔGº‚’kÍ{,µ@ÜÌ/1Z;¶2pE‰GsÙOgŽDŠ9ËE?ã83åé¡UÔNÕBs[¯\ZŒÍ°K×/ÃÓ(_•eóï3b9QËÎ|>Ïz·@†zI]èÆ2DëûèÍvš‘S%O«­¶¸p'¾Ôg4DcOÐA%;z LrŒåæ=L‘¼˜•W²!…µNCçÅô–Ü" 0ÊÊùK¸Õ©øÖƒú–²Ž:¾˜‡/– ÷8Ÿ,áÛ‰>_鹿'½Øüž÷¨â‚Pß_1äÙ5¦˜_ÐI`î›åêÁ`kWë(6Õ–ñähæPX¬ß6ö5¤Ü[kÒêµÛ"Z¼kŠ&ý'r’¡Š‡3p¥ÉzÒÇe{îÓÙƒgœ2vdA˜Ù%3z9ÛYö&6]­"Ìšy—ü9~'>’©¿G–!já'QKIHSÊõZø©Ëe*ð $‰Ô¯9×ùêâRñß?X¢B Dqˆ3*©WÞ«v3wñͽ•1×ÿ’ùDBƒŠ·%oʼnzwÈWg‹f~28û0}ÅÄQ¥pœ´ÂfÍ| ŸxÎ(paP@ ½ÝP}k}8ùø*Ú¿EÇÕ1—Ýc£ ÎèPE-Œ2£¹[œCþy®ŒuOs¶yä¬Z}OÊnØñ±ô¦fíy‰1ÒXÚf(?Boò¥‰ù'·",¹ïLÌTþ‚0ßœ”FïªrÌrê—±›iªó«–xCêO%+ÍVrÚÜ‹‡F ˆ3äiZ¼‰Øm«;ZœÛ>!'e¢PmÁq-7Ê´ .;* :¹ô7Y“0^z§Œ}+9qV¦6†ƒ5­|œ2µöæÃ1´z_Ùí3Ë…—µäâä ±vž6õÎ×vC92^y'Äì2S¬Ë ¤ß®Gƒ|úùæ7ƒ}R: &Ö[ úy¬e¬Óª“Ÿè÷w\Þ¹Ïéý˜™¢úeÕ„Ò;ÞÙõý‘ŽZºkñ^Äro«=̶Þ=}Zó¸^î5Ù¿ò%îêO«A÷áû4&w3ï˜ ¡ÄSãV¬®ŽW‡×ùö‰G :|W@>Ov^/¹Øg©uÕ˜#Ͱ@©âD+žAÍ{"Ãä*cÄ÷Ï¢‚jkíeRå+efš&ah@pk)„T©7øT“€‡PöÚÃ^ä­¶ox4P-6±¥f?â)#a‹)š£SRZ_¯Ð¿Qênͧº=X)ykxÿãiP›‚4§ÈÇ‹@ÕyÈ# HE>!³$1Õiû,u‚xK@ð·"åÇÕóÐ!Ž×0’Xätgͽ‘åù°ÐáZ§!ö==ሖœ°«LÖ,þÕÉ8‘4šn{Vé8ðÞ°íËÍ9ÒWž™¨ýÖsÊÃ}(+D6ô-Ÿjdñɽ ·AÇ ¾œ øÃÞäŸL„$Óe‡7‡~ƧyFüZô—Cgù3rƒ*>nÆ ôcDÆß 2¬r~ñÈâÚ3ˆ×µ/ÓÆà„{tdíetVæ$O3À ¸HK:Z„\5›¶—×—.+¬é3lt§4Ü*Ðxvú¨«[Á¤x5¸3:ñF˜¸ÿCE˜-Œ/&Œs›Öfƒ¸oÁE:dˆ)˜ÝÔ#ÚW¢–ÇpÜtIô[|ñœ„.îÑŽð‰kIØ¥>Ÿ'’‹“9$­ è2¤ö±¨ ãMpý¦:N@¦tÅ O!‡Š¤>5Ad‰Bù¦„ŠçÁÔö¹{Dн"××Tó&ÿºO3ÀÀkìé^ȆbµÝ?Sº²NHg§Le±ÜdsÒ¢#\w¤×CÑÆ6wŽÚÁoR™E2Ðhnc¤ƒ´ {îÑ=µ4uB§å¼Á$X~ ©E:T;N1ÒŽ-hÅP[)KgdJ‹f§.`TÑLéî¥_ ªËù§Ý /¹qK…älEþxlK3÷˜æGcAïÀe4sk13Š;¸ñ–ÒÌåË"†ÏÙÄÇ¥1ð& ý# ÝW*à Ë.Å ÖËvð ö°ˆàθbLï…}÷›…mÅË‚+Ò®`‘¯< ú¼õ¾œÃ:œ7ÿ ) ´‡ìö³CãµU[}Ñjeѹï2÷M×õGú$üŸi¨¦ÖTR³+¸ÞtOuÛJ…™‘B‰Í†½‡@û)/›< ‘q*èÓù>¤4¡ÔÚÖOeñ§uÉiÈ‚ÎcuetCñÍæoµt×qwÌ(¾ ¨( “UŒ³ FRùÍ6òϧx`eaȤéó!÷F+öQž½D”¸BßõsI÷4õM%uJ¬×3TÇ‹•ý—:ÒÌPD.g€HШ*Ø3RˆÎÒ¸Ú·pË‚m1=Ürï6L‹,ÍD4Nà2Oæ]’-ó^ê<‘§lš.îe ¢ow€–}”äfxŠ _„- 8êø“vé®Éžˆ/hÊ1£szc?àä ÿ±¦}ƒ¦ŒP§_Ú gÙ8Ð]¾ A&TÆ3‰Õç°Ó>Q35+òYJi`«ÖÂ’t“  db^’ÉrLp‘°x{ÔËV¨›ÇåÊGÑ-“ŽCòOs,:ú_Õ¿C\ ßñ1:z×3YÙçx³óod 'Uú÷p­Ú‚Ñ¢ sþ­mIE•ðRž,kn#Ò¦…½´Ö2a D"áÿþ£É×<ÑãÇà;fyçten¤—Ì|Mù 8®•hµ@áÁr¸½Ù¨ãàD Iø»g¦¥¦¯.w(ý1ëO× ‘ £ú½àXìŽRòPxÉL}8?L$Ýyx3}öKó,(o®£zÜ¿Í혳c° Ö×HãF`)êyR XšÙkåqýöø8¬Ë6e0ýÊû­ D¡Œa5_ú»g®ýsã¡Â†è“Ê>bÈ}ä0üµ|Âp®v±ÁJ1qƒ ýµYG¿ƒßv×Äí<\-×~ø‘_~üçN,Oª‘”3©£•Ýëµ •H·fLþ¼½ "ö©úÂóÞÿÍàpᩲ1"[½£òž=¼{Õ©«}97ïO’û ú‘ª;%‚|ÿ3©E>òrtâE°®NrÀC˜ÈÀŒ³±eÑpAÖ•¥ëYT}n¶Û³ ˜`Ì8p­1¢~àµ-½Oµµ®Gy;T†y…rÜd†H€¨'eMÚ˜úN­[ª+9O£z¸#Ö­ #-ßäo Mœ]À.§ííZ^ÃÖƒVÑ hð)Šè:KÓ¥éâ{5 ]ã ! V!ïb œõ¼ùz¿g–ü3Ðhë%‡%R;ÉTÅ }I±ëÆš_“b|Çôek@9d¨8Fjý»Cïéö©Ãíî’â w'õ$£êOø»#B4·oÿI ÷HŽ’Gû"Q™›0®:µ4\ ŠæTC³3#ÆB!é­ÅutH…ÈÑc ~¿Ê×>2ëð…U ¯ÍŽwüvôÏÂ}÷¨Ù¸(ë[7ú B©Ž%OîšžÁHѧ¿ÿ¼ˆbÂʰ~®—nøÿ©¢ò“ÛVºŠû·eí-Y]ã×S¶ä°÷é‚Òê 9´~FTKH‚† #Dαê¶k\S*7ƒÍUú£Ð XŽ>/›žŽ"zF²T Û¥Ï‰á@î=²¹µ?}ëÇJóg{>Rqšw…à­ Pœ¶-¢ífÙ6WŸb^ÜYóéVúšåõ[C¯øª9+gÙ¡èæ[Qåz÷øòyص4€àƒÝHóƒ9GÛ(8ôïñÂ,~1*%Û?å²R¬1S/úi×_Jœº˜Ö€uÁÐÜî¶FØetáê€}4õvðiî*þøo¾?§²û t–1ï×å"'ku]¯ï ÷ kÜíöò¯áã ‹tù>d”=OÝ×ç+ŸOfTi”\? GeéX.9c…HÛ^•s§Óm÷D‹9r¸¢ûX:_në°hbçÙëuŒC$êð{ûzœ)-dðBÍ‚öزLaûŽËf ›üMÇ´ °Ù]€¥tsEñ4ÆV³X{ó.¢ñã¹^2ý]„*ånhóñrÕ3Ê HâMËQ‘&}ìq…XÛÁÌœÛsã’^ª>5u–jé^°1o)Vžn‚€Ð¨¬‹ºOªÃëÄãÃ`…\2UH˜µU‰0iN%áè“Û¢FRÔ2œØ?ïôÐG}vlŒ„M d?l’ù¦]ƒŸ{ÍÓzµ•ÑÈîs×oÐÀA‘òü“´îWÄ!Þ‘2¬óLV×0Õåç±ÈW_v¦áËL(_gæÁDÄ k›ðá5Yb¨KÁB’ Ú‡ý7,5ªfŒ[f49è:Þ°’¬ ³ä<¡(høá ,Ë=/¤CQN¼`°_O–sdÌhw<ùíÑ/irä fV¤Þ>HBžw}!Ó–„¡Ÿ@ýî7úf–‹¬O”•—TåˆLÐêæ,ƒm4N¶íu~½fb+\'kÆâê)àXå”HzeåþõQ>-ÚýÔ£tý‡NùÞHã $6 ínD_/è#¡Žã©i¾k]Õ0ø§(Pf›&X×áëç“>©ðØ¢0Ýþ «jTy  ×{‚‰G@ªc£ä ñtâçIq6„Þç3ßvv<"Ù1Zµî ¶…'Mˆ"¢O³ü^3 kѳmýŸ-®œíÈü¥¨¤Êj±:ÕÝi›ëˆg ÇØy8Ð>ôÎ'ŸµbF6?pÈ„vêJçJÚ­Dà9ß·œátÅC c´×`ÈWË”y“ਡó9áïDuBË.:œ%ƒç÷·ð ïnY(¾0pwìµOK”ª5¸3¯7Cæ$¯–„âáë ÇèDòœ$œ¡ÿÃ|ÆPè!úñ­ùãÔ#õãJôLg·• åcY&•£ù¶`z¿w&ª›ÅùŒNËIX>.°¹"è³ÅEOüücì!·^/ !ÊÕçAhÚö¾§þ6m – ¡J®ÝqBôöÒ»,.ôÈ–]yºá ?EðÏQîÒì T7Ò4WѰ>’+ÏÚ·QFfwª$]Úõ»®­Ôý@ LÄ ;̽ƒÌ—Õ4gp§žØ²ŒêâqÐ3S¸=EШñêÿ´ºB°nxô FØ‹ý¡´%¹iµ¯¦žÿ ‚¨žØXÇ= xöÔj#Åzâ%Õzø–™œ(£K“ýS‚ÍÓš9`L‰¡%úÉKÌTŠm?›Žkˆœós¾:¥³·T¹’ú•»¶d´©€”*§`šßþk¡€KŠó‹ma“]…_ç×&V8È(,«þ¤Š êW3e’3t» ØnYˆçÍvAvDñì/Ñ+`uœnj™1¥wÌ>ˆÈ ³¯dÿ.#ä«kê½™9ˆÁ4{§6ê«É0€ÿã¿—%á}A!ìý=]–NH<µæ›÷ÛÜ;êX3žEXÉd÷Œ\ ÷>@/yZ¡»ÿ¥W—&úô=§ÜÁÚ&_‘¼Û• ŸÁ!umsÈ ¹lncwïC±‚·eS¸i,úùSÁõD·jr=$Î*Û1-zçZ3uüÆw¨„Éó½j¾ë|À™âI£­87=Ï’ä—>÷äèuÆ…dvR»2G|‹ ²»(³ß˜É˜uÞª÷ã˜t(-Hcó axo7ïgÁ_¬=›rAnû_‰ˆ]äéM(ë0ÈV›Uãd°ÒœüÿêÏì£Ô€;Ôtû ÕP•õ ·>µÝµÆ¢Dï‹ÜúÉø@:§}<×"üOÌzTIû­Ñà´f})ú@«îG…§"°4P´ûâzFS"³UOæL§þçê&ÂÉu_n³Íâ¶â„šŸËâÛ]?ÆŽLŽËV¯¼´¿÷T.Ññ  ¨f¸¿Œ^L ³ôP·b,–2K§iȵÁÉø¨#LôÁ‡Þ lö/u\D(-·'ŒÉgA"<ïm£7©3ZÁfÍß ³Í²Íkù°g}hCá©F{a,=§7 ClÖ~*XOá‚)Ôk[N±¿mXs±ˆ”¬| é]1œ+@°W¨OUhWc®«Loc5Å.w÷ö2xVîIa>BÈ×ÓÒœÔðÁDÞ3?fß{Å]©YÍ¡¸Pü|ǼTÿâu8w’4þ}C(Ô¾Y!„É 2xºŒFJj'x›)Ÿ3Ëw€ R”Ó#Òƒjà¸æÛ•.v§0º³ÔN–î W”ÈIÞöuиþ~ÝøÃx–,˜6A6BÔÒŒkÏ÷†&’05ãÏÈhkA^(y[:LÁLâŽH<ë¨ÞLµ*p`¿>e±êçSåq›€²ÚŸŸynWÏ߬¶öõÕÙBtfïùæ°ÄE^¤eªqLÌ£| Çx+ëE ÏØf[êÅÈ3ŪD‰ÎE°ÒŽê©¶L4Œl¥ã€a/—íîhSÇÎRÜðà£8|«çM•C^»Š¼Å.¹ Aá# ¥€Ö`”µÙÛpøT——sÁsOBÂm¾ÞI?›åÑŒVÐÍØ÷ß;Ûöchí$;«;Ò–þz)nˆü3pE¥üÌRLòÿÕä éM`z¬5DÝÑ‹Z{c¶€ÒÚQFÀ1{îö­L5ù-~_B ½ ÞÛ?J_¤ý³)y.“Å|[h(¤9)‚Ou˜(c³¶kxJn•”vip·EÀ’³¸ 2„ˆRêk!áåNeÛ}|\½1ñÒ¾£ÿ"<ŠW/ý¹œ¨WX’Q’¡‚hL¯ƒb†@ÒcÏÅ–#^Ú /×Ùv¿¿­«(ä€9ÑBa•¬s¶8ã.sn^VÅY?¥Ë÷¦SØú I—æH…K²Ý€—Î4ºÀ‘KÈ.cPç•ìA©¿2n\tB'øúY¡ÝâwíCœÖyI/ /ëêÏݳ"Ã.’ÈÔòãš1ïµ­ u5 ´_óÇgìT]`ýäç?q«£š-î2ñ&Õ] Ðoª}` â"ËÒpÖrLÄWš¦žÐŽ˜‚Õf ï8ã„•ýœö½f9åZ³NÐá0ß.ûõ‡ úÒê*⎺–ç¾fÒáý»1MçÅsß”è.`¿ýÔïpÛ8¤ÄÅ‹—抣•è&æGz—ð-F=HfrŸ&Ó›Ÿ<=9Ïœ14Bkʨ÷a©FoÑÀÖ͈£VÁmè-vÿ§])¥D»(6dvÚäíÚtŸëšh¸µP°••®%i¢ˆ˜“(šç@éjž¦eïÅüÇÒæ4ðDŸ›ºç¸³ÖaÜví¬ŽH±›=ew†¼´5Îуõ£üU@%­ö—€Þ×/ó7›5ƧŽuSšLòV¿‹b߯Ð× [ 3 E´þó 枩Ӓö:%œ ¥M7›L‰è‡¡'‚›A}±!gŠ÷¶o¿–‚ß¹1þ§H&ÎüYTÜ™» T¨|9u¯{u„&‘I àm‰ç_@C×Ït¤éïÅWâΛ“k™þ…ytA0x£MpYÞ¾DŒñ s[ª’¡”²OuÍ|[J0¯sMMÊÖIF¢!4¾)q€Òh‘Àé¥ûÇn1SX0”Y:à üœ,Ùƒ¼ ì[¯ñ"Ši€wpıжà”_—êµJ¯ ´ ³— ¬zëÉW[òb:VL¬šëîÏ™‚«Nâhº v•ÒâRê‡^„ bÃW–¬ÚÓØjv±øŽŠ½0·ùlC$¹…3Î]A¶8Mü m ´»dù\ˆÃ³D1—y9È”n;< 1o•w™Ç¦Ð.¢«œóUâò·ˆß;ìzésN; ù±îR̼¬ïÄ`Yv| dØÎ@nxZbê@Ò€ÎTw;£æƒ¬W¯º•˜-œ–dt[| …&¤2˜d}ÇŠ«™OÖ4Þ«Üêÿ•³ Þ \€:@ÿ)‹›¡[æÓiwfÓк‚=ärýä4 ¹= —FÙ:çúŒsKs¦zd}w,¦Öðõ¶Ÿâ l5Ê‰Ê ªOÍ 4Þ¿î „W8Õh}éA½f.ÀYiž„Ä7ãÜ—{•QbœFž©F‘¾°ÓƒÙ „d‡ÿ#›Ñ´‡¡ÉÁ'¼~ùÞ6 ªb¾à1ñª˜œµ>šåŽ•Í]¯~Ñ—£o>ÍC¶mô,2íåhÄŸjŒñ˜Ë&ÍfJÚôër^þøÍ{ϢͮS½_›@%ˆƒë0÷jQ\ ]—^‹V'СARjè­M¹|Õ'¨8°*ä^â‘õÞä¤8y(ó­¹uÞ-Æ] õld4ÃOd]±Û?¼=üywPÃq8á7ù-ü×ú_ó¥(5^….üïàMü‰†i•-,h‹×ðØ¼§=ižî\e5²ôÅv¾¯®» þ¢=ä1ç—5lРΦ´ŒçÛ>¤?êöÿµ“îÉ–À9ö?‚ßS^Í‘Z¨ï97áñU}¥fo} ž9§1qrŽ»êsŒÁŠÆvm‹=pŸ›ú‹L´°}¡—¢Xä¬%E‚MÒÙ†¿Ø3 *Cpvyàô±!§XÂ){YctÙãOˆu§¯`oMOúÅ$V‡üP‘ µ‡ßÇÅv1h!‘?Aýo“)ì5›iÃC°”ÌßBø[0ØÊaWÁAa²=ÚÇפðÜé:ÜÙ¿oR:6jUï J®§æ.rñ|šðžìêëôq+/'Î1xÐE†ö®"‰ãxÊëLâ,žZƦp’är7¶®ßÃÝþŸ1™"„®le÷‚þD&HX/î)‰E1 ! Ïd¬Oº –au^6ÜÆI?Xó}”F¡“ÑܨÂY:o‰‰ÄnÿÅoNA¨ 4ù økû}ÕuT‰êoXv@/ ÃÁK9DÆfÿ’7ǽ¶W »ÇsOc:î¡1Ú9µov`¤ö;™ CÀ"R™¶Õˆï5kô +0àÖ f5n¿ Ä2¦S Æ8`‰ ®Ù cÔ¡ióìˆBb—îJJWÕ·žnÙRbêθ1\<ûdÇ 37è. ­â‘VC·`6Fí·„(’GÑ[7 ¿ü´É8Ýbký’?…´‘ÛùÉ7ÞˆµåºSç>¹Oï–h×UÔÏž®=9†¼KˆWÈ-Zæˆ.VÚ¨™KÂösjÌg^áFý:»÷4ì»eø~¥Ð_lë×PGGBóë `ªÙÃh#|²„á²Ä»&ÅhMF$Ä)pø¹40GAÓ÷ŽÕ“Ú{=²º–Ó¶só¥±\óïgœ!¿ÝÔ´†„mNÊ’ r×\»è÷ƒÁ'óKmœ6•Ò¥jë˜3Æ­\øåOÖjH×÷ZçÞ|ýóîÙXcÊWš§ï²O¤8àíÑØBŸWäÍ©Ɣǩó‘Üý³t>fî v§ÐÞÀ3y€¢y8" SÌ'燕ÄT0¼[2Ôé•¶Ù ¸RÆÇ}Ñ—‚ž‡Ð†ÈA<µTNy —ËèªÏ®›ô)¡Ø ¦ráŠþÉй ظ3ý)ÝëÒäM/Ä|íóë æ±‘"YdhY'í çìM¥®7·˜Ã˜­ï£&cþä,²<“}R“&Jœ còñk‹FÔï"÷ ƒˆörs†ÂóQøKÅn"‘޶‘ù„;di/!Y¹J++ÖGVª©èqçknQ…?d)(·ÀxiP?Ã5@õng†¬ ª7¾õ²¹´f´=èÒ¾»¹à"@ûi³Êý¬&¤T™É¹—-’É#ëê_¤Þ9 ãA9Ú‡Ö`µ[pç¡{Å<úƒnq-ì6vã kvýC©U¿ƒ"näåÁ6z ¸ G]cÜÎú šˆGìcHov*[Ó,×{n¬×UÝœòBžoÕs·9æX˜þ1é»Aÿ£Âk¢{(ëɉ ¸ŽU¢Òý­@KH J•ÆÙÄH–¥*ÍÕ¸ùá)nžÿ51*R1†ÐLêb8fTÉê¡&ÙÉ#ä“…Ê ^ iC~£tø_bOGcc¿G]† vƒ(ón°»noÀ¥1¯ãv•ྼQ°K²ç"k'À¾µa.eÚ#®™²}W;€Z4ÝCßDÑ04³i[‹×É6å·Zr˜,}Ù)Pf*oü7Ûr@t¥LŸaª=<ÖkÎbZ2µ  “$Hvã“}e/“²™·Ý‹%_4¼ò=LÙĤïˆ{™ú@³sªOËé‹¶ .:Ð{·'ÇcS¸Rn¶â4êÚÑéús°XÅ07U¹Fz:3«' ~hÿAS;W×{Pª©âø~WÑÉ…ßäE0vPÑEM£yϼÌw[ctçG.èjQ±ØÈÀ.&ÏXIP Š‘¢ìR˜U†è¸\•öÓü ³É g x|–P'#êN·½»Õ-œ’p$¯=æß„óÖdWÒ¾‚‡¿ª-›%þ7ͧu6Q±åÄÓQÜ7 ¹°~@@–®Ëw 6?ÜtБ¤ehë‡&A*zÛK<ÆJ¹qd‡`j o_ìÊ>Lçºø8c®¼¶b›uùØÆ–; @–ü–ÃÈÂõˆ‘¤Öeš!Ù²…l4ã+ÄuŠÚ»ªsÍ7àáq ’Mo´&˜a_†¯vdÎC€séëÝ("ÚÿR9V½xÛô¥ßÝìÑ¡ªÀVKä7ômÓü¢U´èAgç1˜sUˆŠZXnª$RO»JÖ@4€å»Mí{ñë>Æ iÇËü;GÇ`„qbyÅ©‰ùÏ·è;×û£¸­Žo†sD´"xÿh ­×~Í.ÆÏ)5Ù¬¬ ¨­óA›¿:Ú•¦¾0[>EI¢ˆVëÿ ôŽíÔúo/¤‹>ëŽ#ÉEºý\aw܇ðG*äUœ§‚O¯ëNwá~²$wÜùðÉ´·¬âO%Ïœ™Ù8Ñ$€=‘¶FmOÕù¼2uJ¢¡àlîOy&úµcP¨~‹#9ÃVÉ•ðæ5ª«¶½¯X®½·³Yóÿ<ÎétÑlæºWk8ÃÐ<¨l G¯xäíž‘\¹Z/ÐA)L§L§U<±J´69IS÷Á"KžØÁå§=Õió:Wû|¡OIõg)ð÷Kdy´ TŸvW”ÛíØˆ‰#Y‡^IïZüL‹,·- äϾoŠÀȬ\9 °´&åu%\=¸bÔ(…Gö˜þW£.ݾ v6Îùi—uÞëeÈñI‹öýxYÅž´ÂK-?+ø:hLfõ·ì)RçãM¤:K/é¦AúABLÏÍ}¾ËÜÏÏ+|2 ŽÅ}ý•F$½,dÏÌñÇ¶Ø ••–æKTümXªF ýXùÅ¢ÈH؆œÁ_¾½ö ¶±ºËM¦:Ë)”þ4 b]dkÖ`¢XþÓºi¸r·t¿H±þJ¸Œ,`›(°›SN¶e,áf®ôE¹;},Ž·×Qg=íþå2«´+ßB´Bú7€YÜFðT¨ç!ÿ~öhsÆ½Ó žƒ “ER¥ÌQbUÛbr£µ‹Z8X[ÔØ_„ôØŒ>…®ÐÅù ó縶ßÚvµÔ¶¦Od­ÇéDñƒ“æ‹CpÑ<8¿Ýƒ^©^ÁS2J¶<8ƒŸ«b’=F—RF)u·©cn‘؆ù Ã<d›P—Ûf­±ÓHó~t¥Ö#H*Å¿ {µàÆ»·X‚c%puüLâ:!‚ Ó´ ´6@3¯ÏHBÍö(üJ®oFB‚f'è’+\‘Má²aÌ,¦ïþìqÜjKç<:9ÿø[û€-‰<3<”„ÏÌï®o„oç¶‚“–_ЧÁgÀ‚$KI¥Òê3wÈd;HTJÕúÃŒXÒŸg)q—4|œ¡ƒc‹@Ö³vÜè5†…ÅÞþºÐVCÛ¯\y\š¯&<¢î"yøŸaµ$h¥é>{<`P*ß dùÆÃÀm¶‘ÁfÁsÿï¬O HMïqX Ê3ôUʃ‚¢^¥r'L3o#´¦#Í%r"NÀX¶NÓ%žÏ‚«Iö"ÜnR;¾¬¦âË5´‘!ŒÕ™Œ‘¬«2z–E¾]ÜWPºnÞV²µrkt¬6ɤ÷"—Óë;*^¾&©ýX™¾´ut\¡-ADÑ;´SµòÍúQ¥vt¡ˆSSË,¸T×¶¿DÁäªhuU:ž¸’CÏ3hºóu.prumUŠÔlæ"¾Xýk—¥Ù¸]O–™XBÜ-u“hûêX îlž­U[BU×D·Ëd#ëW8„ áüéˆV#bêHþe:ƒ5l.ßXlýá"ý$ÕAȾ×ÃFÓHM°ä1P %Ú¸¿;þ¯êÜ‚CÔ(v:ª'« Eš—Öa^ŽÔè¼ÑêÙó© HÁV¯•Ÿ…¦ÊA¸[6j¯/Óôxa¨P‚ËGùÂo5’%ðJ©š“÷[µ§ BgÐqò´ f£óéÔnGÈaô}Yòà›YàÞªÄÀ8¥|™qÝÌ÷w•;VOGAž[Û.Íá>íU”MÎu¥Ë@êwm<<_¹¶!!M~K¤úC¾hH=ÎÑuÿfú"·mo)£©Y½ñ¯Ê0zËÌDàâôåŒdZ'gy¸*!©å}³Rëý´„|Ûæ.OöÐt³K‡eœj6¸a-ý¾)Æ¿×îtÿRÀõæâv"ÇG&Àß¼Ëoeà¤)ñÙµRÙáÃ\´þè ˆ}éØžXÐôŸò†¹Þ[ü"é~e¢¶.•Ùø¸uô‰'‰G°,Ë]˜%Ýy L C{˜±g0SŒKPÉ’Àà¶!§Ø¼D÷u׆¨çD|‹Ð”¥/aaÅÑN¾R+ÁJè } ¶¸aš1¸·\ö B`Uú-ñð¼d7*s_J'Û½ÊÑrßšsDÜúìÖ¨Õ§«á­(2†ßåßÄgIÓOMɘŒ}"[|Q1‚cÚN/_ð4é=ÏXäSq[د3Z*ÛÎXÌ^*¨1 Ý€&ý¦§>;”¿ mcÂÿèî 2ZBÀè×p¦½¬ö)µç)³ZÒ^ö!ºk9~Ä Z†yÜ;¿VvSýÆy¸Œ$ izÈ °ô C±œûpk<Â*Å·Yê†j|èÐc§ù)K”É݈J=„)~§Vê®Zæ$)€o5Ù|“æžï8'¸äñ4(ð5Þœ;ùdØôõs°è1À~Û‚ú™pÊ€ó4Ód+ù»Z8R5O**zôðF0ë'0·´}Êwĉ\k…ŸTð¾YÜ_ñãVðO°Âî­¼sIêïîPP»nã^)i‰¶r~Ãð`C‹q@˜Í¤_éºS0˜-蹫‡ƒGÕ-Õ­Ô˜ Z·|Œ‡3ž™P'«óG£]t·É@@5¡‰=’ÀwV¯t»fkl6AÓØG.É{#Dë¾ LÊ7õëFî™ÊCÀ“û x}eÍ\‡“li·)‹Õ”À-? $lÃÀÍOÙ`Dœ¼-þ¬Z 1þ”>ùÕ[Èbë§\­R1ëã‡3éÞœžÎlÐ q¬‘tjp5Õ.ù\ᇸº³^¸ÀUÇ9®l^oö¢ñD¯KÞ·˜!gÄ“ LUP1Õ;#Ê$먬çcÕN> ¨FTðÕ'Ðêfb·sî‘D§g„Gb’Å4¯êlµ(ÓmRÜF`>1ðªhf9±¤Ï“ðúŸ„0»F{µu2Ix"‡ªÅ„¸vÚ».ƒhñbŒSô€M˜,ðDÌø‰uJ´¹X!7ˆ×+Äz…µ#Ávä~¡0ÊàÄüp°oÄûù@àªV(æ%“s«ö†*›‰ž$<¶ç$úJJ¹§¢Œz¦Æ×åíYO²9#Sv¼ FN*uæðaŸ¾Ôª9ˆDAäï…áó5å'u1òË>ç~ÝÝ+?hPaßê½Z6²Ð›Š`ÒX3“•‰÷~ K…Ù¾ß ‡oäåéÑr˜J“åŽ «œtJ1úŽÉ»r1W÷&æfü_K™·Ï PV¸0ŒRžoEÙ<†Õ=ðSäæÑœ2bö.¸5ƒ¹nn”g`Õ¨Ûë_}¾'tÕ/Öäv4ÖÂBë¹»0X‡3°Ï ½Ççj¯‡””y+³;ÓŠ¨®Õx×ÙtÀIÖRc·"( ¸éÏÂ¥/'€•¹äoÊH=pÔËè"¿6φý‰L[ðøºn»D`vaçø4°a* `+}i80Û§ÜàÛ?u²1D=¼- H15œ2d2˜wÕiÚÀÓ„ñ©g¼ÑÆ9S—áUà0 ‹YZtimeSeries/data/MSFT.rda0000644000176000001440000001172611731572504014601 0ustar ripleyusers‹­[y|”EÒîC`#‡("D…AñB@޹ç}DÄ I Á$;„ ä¬(°ŠÈ"*Š(‡¢¬ÀA>tÕŠ‹ˆ ’©ç©÷ÛÌ·~ùý¤¨®§«««ûí§«ƒØ1ƒÛŽik³ÙšÚšF…þlúkó¦¡?šØšÛÚ„ïÈøQ¶&Í:„þú¹Ý¿Ãþ±û¦QRÚ!½ïAzAºwSÖS†týFÝF|_¶Ÿ¡d?'uûyïäx› öólÿ­q\FÊ&ã4£)WR²¿I¼™Aù^>Ÿþ6Sgüf,åøÙšøc”¥q|F9†öíœýzÙßSKñúhwq=ÜŒ_óía¾u]<Ì‹³ÜöÁ«]²;˜ŸöãzÆ&BÆS&0 Ql¯&žþâÙǸ8®ƒã:fs\Æëä¸.J7ý»¶R¦<Öxž>Æã=Aýý‰:×ˈ¦Îvݯ~{c~æWóíWÿÜ_^öó2.¥—~=*¿»–:÷¥ûΈ~Äéwâuо›’ý½åÆCºŽnî×Õ”œ—{S„®’㸘'u7×ÇSM©ûM磒yqO‹‡víúÝ{çö.ßÏî¹°*ôó¤Ý7rHøÇî}wKçܯvßKÐ}Ãï{nŸÝÿ·“e=vìFæÑ¶÷f­ïÚFùræÉ2»É¼š‡BÃï]úÎͰ»9'Üý^»é ~ ìÆ)ŒoÆO ÿ„ôpóx»ÙŒqާ}%æmæÓ®ñp¾æ$ÎïŽ;þÌõ´o ?ø~­¯@*ü†¿'!l°tüEà sèo\b<í1ã=ÆåÄz˜…œ¿Îçæ3‡ùþün„ݧ¦ñxf'èF×çqø78®¹™q|Êq?£þó²ó9HM¸ž~æëhTs^Ü?F ÇMáx…´3ÏFóþˆú_¸?Š±ßŒZâï o‡žvãVäÓÐq38îøñ?ênž²ûÿõó}Œ|ùâþf|¾Biîû«Ý[‡yúÎb|ÿÍèï+Ç|½e؇®«g%ö›§+òïIÀ<=w6üº›"~×vŒï¾;,òì®þð“p8'¿7× À;¹_œüŽôœôéùÂïYÏIo½~Ç”µ”‰çò½ž#Ì›u®Ó‹ç ‹~ü<·Œ ]_¶ÓÞ3 åU%ñ&ã0•O_¯™Ó"pòR´ZÒ?Ïy‹Ï9ÓC¾áyhÎ&¯WÕ^À~Ëéï;ÊŸÉG¼ÇX÷†gyà¹mñœòrì à—@eú+º!ò¨uP^ýƒ<ª¼ŸŒõ°pÉ×zoZHüWˆ{¤æi,ÇQþ×ûÈ®Ë5äÑ×ÓóØà~Pþp?ÚÒŸ ¼§çe@×¼hñxåWäYò§5ÎäÑ8†u1^Â|Œ¯É×G1O‹ÿ¹ ®·1‰:ï/×Ó(C¾Œ´“ÏÖOëÿ*ò8÷oÆ÷÷¢džü¼ßøxoñr^ÞÓ¼•È‹÷Vä_¥‡ýõ>ìæ}Éúþ™/—8'÷¥ë.¶çä¾t>ˆy*O[ü¢2šß/×êôÜà¼Õ¯užÛë®(HÏQ'ý:Èç^â­óu‰ž«>­×yŽZç:ë;ë^ÞRù»9%Ç·ø6¯õ²q ÎKCù]ëøa´ŸµMûŸ›íÆäÆãœ¿Åï›ûõ3_Öùª|ÍóÑÊ3Ûµ¾²êríÇø•O´®J8AI\¼2–öXæKëñø3”ÄÇQS=ƒ²š~©'pý¸>ÊçNúuéû Çw²¿KëFƒó¥?åO/yDëiå[«ßM™Ñ¸Ý7(¢_4¥ÖýÜÖ;ãR^RžµêMæAùѪ[‰×w%·ÖÑ´{Gã>¥|ìa­Û9/Çñê»ízÏqæ8Œ×ªË9×}¼·US7 ­uàüÜGïÕz´æ£ë¡íôãJ¤ŸŠÆãº©»yNyX¿xYyÉ[¾?á¼ôµo黉ÖAú}¯‘'XOœ·~§ùÇ8 ¾6”GGS¶f¿?"êCÎϪ?µïGQ~d~#ˆÓ`ªqÌ‹éæ}!‘üd‚wÌôÏúÑòOþ3YG™™´×ÒŸÖÃÌU³Þ6ÉWæ&Þ+”OWEÔ§¯°ÞÖ{ë7³çó3ùQßxΛ¬_­:z>¥Þ§ºã½Áxþ ¾«Wq<Ö}æ¼·¼Á÷ õ£÷¡ð˜ÖãÆ%úå½È`½jL%ÏrßYü:‘ãÎ">ƒóÖú]÷ï{O÷¤ä:û™½ÿÝY·2ŸVÝÍ}î#ŸúÆbþs<ïZì'÷­ÏEû;¬Ã™/ß;<ܧn¾K¹YÇ»7"?_óýÆõënò¶“ï ŒÏñæçìŒïÐÁõ׺MùÛªÃyNy«!õr+¯èy ç„ÖŠ;AÉüéûœ“º“ç—“íú`°Îöó{¶ò[«ë@yŠß…Öçôgñ·Ö×ôcñ7ýXïãZÿ)³ž6o£Ôú~XãñŒ:Ê3ãð}Þäû¼õ~Ä~V}cPê=†~<ú®Z ©ï·Z*è{ˆÖeòŒ¾Ç3±´Çqž ôgñ2õx®[ÜÖÆ2õ›Þ·ŒËzW×{ýEÖák½Çv‹‡£(‰Ó÷å_¤é?ÞÓ—ÖÑ~æÃú}ãõÓŸþþÅÏþºŸõ}Cy×âW­·µ.=Cý•Ïõ>e½£3.ë{ß¾Õõô0ÿÖ;Û½µ´Sw2~ë{âüõ÷Ö÷¥÷%í׺1Þz7Ó}£ñë÷Êxõ_?¦ïé‡uoÔû ë/ë!‹¯ùnèK†îÛEG~໡i‡‹¯Ékf*ù€ïÞVÅü›•ä)žçúÞnñö1ô 4#®ŠxgÖzp ëÍ+ÉÇ<‡Í¶ôß‚õí`Æ«ï äóGögjòÜ5=Œ_y_Ûy~[ïØÌS€ü`?ëù47Óë/³ yYëTÞ§LÖÕ&ßgÍÛÙ_ëuåUòN€¿O°êd}ÿ~ŠóŠ&O–°þåº=øNÍýj½Oá¸ïsÞúŽÿ d 7uæÅx‡õð2Öß_Ðï³lŸ@ÞWþ­âøŒÏàû½±ƒ÷¸ æCïwð^`ç<’˜·lÞoúßò¸¡ïHg€·x¿'ñb}½yóó½ÇzâûŠÖ¾ïxøÎîá½ÇÃyzø¸ùþááû•+‹ïé}1/—ò5ãwç;;÷“ëæäûºã¢Øcæûï ¯lÌìóÂ;?¦hã—"óNí ÇS:öðî°¬Ž½{PX–<ðC8ò˜99C;´L䜕‚«¸¾{xÅcÊŠ—ˆßŠ“9Ò^µ°8Qú'¾~",+Ç®ûSO’öšËåÏ ¾¼d²ŒSsñ³ð³ 1[ü.|ú6±WÞ;Q⫨_.~J&î?Å+>{aÒÑ‹Ž-?_~)ø•5ee/ïåmGÿ·`¾åÅ!&ÿÐñSv¾‹ø™Ÿ|PæYÒ}šàó~^ôâ!O‰ÌHm‚þ£÷‰}ÑÄm2Ïyi‹E_QÜUdåÀáOÉÍÏI¿Š˜DéW¶b²èKÙÒ¯êÈ2·ü@±àçv öy™3ÄOá…‚[ðEâ[4DpU›Jû’·ã$Ÿ5™ÏFɸ=Š¥½àä2^aæ&䫨PôyŸÜ(²dC7ñ_}û0É{eÝÍâ·<®q·Ú"¸Ó~”þe%CÅo…ã5éWTÓþkEMè ù¬ìùÿåä-á-i/Ü›+zåëÅ_ijwñW~ëMÈçðÑóüuˆ¯|»¬KÑu_K¿Â³«DÎ.–J+¦üòXä¿Ãñ_úÇjÁÏ»¸ø†¾â¯ø†ße>sÒo“ö7öUÁé§ÅOþ¹éÒ>wnÑ+ÚŒ¿å]_éùaXõUÐû_%ö’‚…Ò^Òr£Èœª8ø?ÖIìùù'EÏm‡ï§â­kE.ˆ='ã”mDpe뮿EgI{å?ßÜœn;E–}ó˜àÖaŸ-Š^…u|ýV™ÇÜ«ëï–µ¢ïƒ|îê-y){³Hôân­Å_yÖÁW,”¼,h5í]KÿÜc-°NmlXÏÁ¥Ò^ú9Ö¥`ê=нW‹Ÿ¥/\ÜÒ†=ßò† Yß² /bžÃëE/öt½Ê3ä¥AXß$Ž’_c½.‹,x²™Ø« ¯@<—Ê8Eßí½8Ἄ7÷¬×ì$y‘‰Éž1\䜸ñ¿~·ô›_tù|ò:‰§bs-ÖñÛ×dœò‘ý¥½dx©à¿ñ‘…Çc¾ë6ˆŸÂã=Eæe¿!ö¬ãgÄ^6òS‰§¤ómˆÿ´<øÅÌÞù˜ØgÕÌEþ})öÜ ráŠ)ê{Lìó`æ]+7à˜¹ÃG`}—`®Løfÿ@úåä s;},þ ž’ñí¾óÉ­|ѸßE>ºëJÁçäý ø.X—‚m¾`—)íE«öËz,š?\Úó»ýñn;ŒñnúTô¼YÑXûmâgášÈgGœ·…×¼Šñ7­¸ŠWÜ„q~/ñgõ8-ýóol"2·j·Ø?ÖöÚCÒþhåG¢OÿßWî]ÈSö+OaÝ_Àw–ÞçêŒdàf~Ò[üeý´ëPŸè9Q[EŸ5ë¬èÅ뜰o?ŽùÝsƒ´gßÿ¾è³Ö`Ìú óIðy«å"SØüŸG٨㒷ʯJ{Y*öCi¯·°.Sº‰ß’#QÈolª´W]ßSü.oßf«à§N‘ü•ÚÇ‹=¯¾«ØKÆÉ¾Œø7pÍ&§L‰ö¶ð?“³Ù.„þki‘–’•úK”ùoçüÉiúwGÊÔiêÏ“ž£ýF¤¦g&Si9:=5{zr„ë6é™)Y)éia÷áãóBL]ýIGÝ÷q6ÈÓ2íº“õÐOUC?}W!ä×Àÿ¸ö3eÐýgÐ|Ý¿ €?Ûös7@?÷>ô_³€?ßøóïÀ~á-è§AÿýJàøKa¿ü0ô†Ð¶>h{PðAaýlzz³õЛKá’¿ßb-ì­V@om‡ÞÛ>Øf ðmè(ØîsèíËïpíQ¢ß•¹Ð;ö®cp²aï’ýª«¡_…Ï)Ø5ø«;ÂÞ­ôn/C¿vðÝ[ßýEØ{üzÏôž¿ý ð×{`ïõdï•Àõ‰®ÏÀõ]Ùïvàú}ÜŸç׿ú3ÁøÜƒ󀿥7ì·¾ 98¸!×7×·àío@:úí¿ãàï|ö»‚~OSè÷<ü°‘À»û}¿B¿t<ˆ…$Žû` ®#Á5ÐcqMÆ~ |Ü"àã‡ÂîøÒY œëfà\ ‰ ç tot_Oà}ïùô@gè]ÀL~TØG·†>úoÐÄu)8¦ðcž‡}ìèã|ÐÇ~<è1ø0ŽÇà## ?r zâ2à“î>é;Ø'€>y>ôäÁÀ'~J ìÓæ@O¹zÊ!à üôk)÷—– \zàÒß„}Æè3“ g¶>sðYã`ŸõôY¸^s6?Ûüìß`Ïýô¼ÕÐócÏ? üœ'`/¨†^x'ô¯€/ª¾x쥠—~½l.ðå7_ŽkOp~&dewà*ßnè.¸p*ôEQÐá\Œò(XÝö¥- /}zÍhàk€_¶ öåOC_ᆾâ,ð+׿*öÕ÷C_kfpÍà×ÞüÚ¯a_÷ôÚ2è9 ÜÓh&ú³ ×à³ ×à†,øÝxìEù”ã'$Ÿ›ü󸾟ö¶Cßò0ôQŽ_ÜüÖaßfBßvúKëßî~û/°¿òôWW@ßa~Ç÷À¿†kDpgô7n‡þÆçÀï*þÍ[`ßÝúî¡ïÉ~o/à÷ÖÁþö~èï¤CßkupÿàßMýïí(_îý ÀÕµî`è¢L ~”ý£3°¼ýÄÀ~×øàÑo [ü§CmòÓˆè[NIŸ9=)̰QÿÑÚºÏCúLÐgräµ >%mDrZVò̈ͼ£"±3“'¥ÏœìŒ ]!šuú/C·HKšž¬×—Hc›™é9Ðþ¿õž”š”™FÛÉIYI§ÌL _hl—#»d¥d¥&Gté8*ezrôÈä™)É™Ñþ‰&OÊŠèÖ~rú¤Ð )-+)|!ŠèΰÚ6ØäÿeøßH²Bná5Â]«Œ¤I%MŒ£Q‡ÿzëÐmP³ÎeS`þn~âéò¿´ÃóŒ—1timeSeries/data/LPP2005REC.rda0000644000176000001440000006540111731572504015323 0ustar ripleyusers‹½ýe\UíÖ?ðŠtH‹Ò(Ý9èîîîîî¤Á@P Á*b'!((* ˆ”Ôa﹟ûùŸýœ×Ç\kÉwò›s®kÍk >‹µ,´ì$©í¨IHHÈHÈ·¾nÛº¹lë )Évª­‘ÚÈÌLR\\ÆB[“„t= :j±0Šê³ O­ƒAXÛw´˜Üoz҇鮆 ƒuB•yãñ ~‰¹-õs*z½7¼ýdBÌÂ<#þT¿-9'±&oAçzÌèû²Và•¸ÿŒô˜ø½Ij‡Ö¾+ÊÉUèa@“Ö”0 ¿vG†9¥£¨ŽTapÞMÐi3úá‘“ î$áçw÷¨ Ö–þ§${Qš1»]:¬4wüR? Z{çL·wGуAý£íÒ¨^Åx²# íElaîŒø z›L¨^AšXr›à4~Ù¾l·Ž/n ]yôwqé'±£N… ”‹³c€¯ñ¾G&\`;µÀzé0X;³ª±X:/{­Úçá] SÉã Ä:ef´šl ÍàðºÁÖTYØ’$wEüç˜é~—€Àä¥(ÚîÀü{&¥[ U~³Tp™”üCõŽ '­ d^¹JÉçŠ<«~û¬)MP~uîÑëH °¸q@KÙåj®„WÅÝE‘o INð`pŽÊøŠ–ó›Ÿ?+ùùK®'~¥€Þ칩ªàt6(¨vE=š Èw<Ý@Í…ÂC½B;Ñ0¦‹bÇC9Ô[»òÀ.h-î±åÊ%£yÎw{Õø$Ô)\ŒSbUæ4!ýïû—VîÒêUS4/ ÛîÙt¥™&™ªƒ}ÁâiË¥¡ò[ Oß;Q7Ø¢t“g}[#ÿ9~UMkû0Ódù÷\§Ü¥‹Üv¹2ÂFô ´Ýuzú Ú¼î¢IyáÂE}D£É2F‹ŠÐo;5‚úÓowlx3Ðp£åø¶Ã'QµØùkÝ2‘Qè¿üʼŽsN*;òÁqé–E¨ª&÷÷Eºya©”BØÏ\’ÿú‡Ò¾íÜŸÛ¸Q+àÀWf‹3¨»úÉ‹®uÖOˆÖ~ŽÞpÖퟯX£ë2Yv…mšÿ¢4¨`åD«Ì¯Ë3G>ƒõã™Cz’Qÿ;OçÂU-w™¢“bLã3Eä=Rrh&/ì›è3#F%çôÝç}”h»k‡»&ãоÈi¸rk C>YÓ3ú&6š,¼>ƒU]ê;ÏrZðœ_‰¸bŸ†nlNŠËMÀù¤ûµeÃApk“n¼É ~khÿmåŸÇÁú¦zNc Ù?÷Ž”ø3^åÞP*ʸìvÔ S d´ŽÑ‹Íω¶dãäß¿€§pÏß*_ÞŽÃ|ìqñ·h`‰H~<Ò–hb¤‚ÀN1ÐN†½LJ%é}CtÀæ ƒí³50IYÍ“åDw¡u†Þw íd–‰î¯éNËr£%ÙlÉæcÔY»´|Ð í ¼t~|s L$ÕÞp*Ôo]ÇÓNÞ6õ2æ»üQõ„‘…G¡ƒ×Íã;P½j\/tlj®|¸@yͬêv`éÝ¢¦yÁÕ=÷Ó„;¨ÏÎý0Xæh×At›ç¬žžz 6U1ïTœ÷€ÓÛ“,Ý E­.¼?ð#¸iLŸþ´Ë<º¹uWAsN{Át—7Z´ÅåÝýýϺ`¹¬»ÛL ¤þžR×çÊF½¿×ýTêÃÁM‘zå»q,ŠüÒŸN-Ý@õXW†®B;øŸõÂU¡›¤=YT6óGÖ®¢éÙ}§¿n]Ï«Gv /uýïÏŸnƒµžøœÂ±ZTϦ«”G{ºNÖzà¥/Y®=…ölg;yi€—õ\DVÕiÔ91•tX‡cë|¥îŸÚ/Oyü»oƒ«žk¹Ò—qðåò¼óúxþxÏt3Ýy¾PZeµ­¡ÔWé¿ÖLõ(2üVÐ÷Ñ~:àXøÀ -ª¾YstйKb‚üI0Fûâhq|îhe—è=~¬c`‹4 oœ¬©¡áPw1Ëå|ÝNi®5Û{tþ™"û\K ÈP¯gŸþDø_+¾Uš¯Ç´ì¯/ò‚ރŒ”PäÚmß¾? Ò¹ÞyÈjy ÜTL>¡ÔÓ¶ëùmihnw©N¿Uî¥1ð;’ ECGG:pœL;mt ½úÇÄú<žßÏ9Üþ|‘ïGY8A~Ú‘†auB忤(+Ð'~çéÅ›»Q‹,0@ÂHœ7~¿,¿ð?ë:ƈV\øçéû¿×iؼ]2îh{+ÿ•^Ëg°¸ý¨ô!Õ;°[õ žùÓj3oÚÑÏþòDŒ yaêºäm´6zûEî/Z[~4“ܓҬïðÞA¾'Ëñé©è„ßÄ×çÀ§ž\üáæ8 oð3þ¼ ®ÜÍÃÀ…±8vLu¬¶IK;E‡€È¦Ò[UZc4LhèôŠCÃ\—~óƒC¨OóVg×'n´)y½zúëÿ®7ÌFüŸGÍÀ¼XPͪÿØÓ™²ºØE€íý££Ï³QdóMôE™FÔÉH'}v_ Ô3 YyQ¡aÖå°6¿ÀB±4¢·­( ¯ó|žQFÝ\z×`­ë¨•¤ŒêYörKTͨsx¯‚w7Jÿg^ÿÇ£E_¥CªE8èÓØÍ`"§û=©Š²gÀA^Øï£r)Èÿ–íd[ت§®n›oÌDã©;åÕÀù:z-Ýéê¾ÙçÒOm•ʘÅ9àÛx³\¦Ì_è'+aØaÁ6|)(q |:• I_H×ÉM¢DÕÌœ™!øÆ^ØÙí‰Þ{©³#ÎbPžæÐÀÌè%™¯ŒW_BI¥}Çë-FÁFãú}•üLL~íA“t¶SX>üý wÂË©;)G‚ ʧz¡N¶î3¸Ü»Âá­–ÉRŠ{1øæaÉžYèaLsÿé¬÷?OÂ÷û¿cØÁ±À¶¦uÊR ¢¤Í».`˜~í³Ê·ÿ¸Äíä‰ýi? ï›ÒâûôèþYò&p뺯ư©fcˆüä8ªHã1¡8¢ÃÛSr²˜"­ÿ€¸½ýS7GƒVÍù¹fl¾ói+åŒ{™ÖKÏփɻ„lWŒB ŠÙræ®f¦¿£|´Ø¬œšq¼¯дWAúÕüg´ò9ùt¬û¤ï¢•û¶g"?Ô=ØÅ ¶n |7ƒÀ'€ô¹W:„{×|ËÇèàFraÕEˆÏ:X~ÁŸBuRÔ;„ã“)ÊmrýÚëÝ€ú…Þd4d=èÆ®`²‚fCK¼vä‚?É“®ÏeÁ¨öøÀOûú¿˜e—ÉfÝùQÖœl®:`M£êãøËÂýU…’ Bãâ¼Ò’DQ>4“Ǹ÷MÛ}Ñ'Eiv·xÄœz=tó’¾*|£KìÌԇ⶙¾§9°7MœîeeWG ‚ªõy²ç˜ôp4{xÐí˜D;ÿ€ ?Ücϼ!ß…b|2©Ò¾^ÑùÍ«ê‹J/=dÐiÉך§´ß_ºc²? Âã6ÚTNû5º+«>OQ’†m×{=°F^ƨ< oq¹LU8>ùÓ¤½V˜‘bmÂñuß÷ŠÅß‘ó 'Í7F¸ÒqšM"÷[>½¬Iá׿å4Тw¤[w%I:DÆV]ä-T{{þÄ+%_@­·ÛþQ‰êlïRmÇÏB̬šV ¼yý|Nò²hƒ069ÛÂî]ÿçùUuAqzò7ä˜úÆwp€p™—W›ô/AäsŽ„î?ºèØ£.¿íB*†sfNÞ„Hh¾~½æ-i­Ð,£ßÞ¸ïÖüéÿÌÓ®´IÁKÌ‹^_zó:ü®ò½MÛ¾rÉJ&ùu¸!ÞðýÞzð:uôEå!´¹îfá?¿æK¿/LçâÑÀ/ †½X\7µË¾EÇoÖºb [Ûð“€™ŸË,#.§ŸHžž<-(C_2Ç‚iË%¸30çþƒ]ïÎ<þgNÆ8žŸ¹Δ6jg±Ì¼ôq]ÞGÈäØ]Çâò ì%0pXùAÒÙ;«šÇ&ÿ9/ØBÔ/@,‡ìønu2¬¦²ðâ›±„ÃQ1 VotðHthðV–†^ÌẠ5Ç B›ÞúПè»Üïø6ê)¤õ±È&¹AhM¥ïZü#ì$µ4̓c΋·5¯ú熟Ù7Ð+XæOÙ &ítb5¢ŸŸs¼ÏåFÑ»?Ÿ^£‚³!Šf }ý‰`è73pcº9G[³3¨ž/±8(AÌãòöÓò‹Õ]¹sæ—^ÒÒ.Ý¡þCš%—˜!ÂŒ;-So[ÔŽ_ (ÁlUCšnô(é gÝêûc.Ú]3‡£Ãål/I4!-$°2ÕO £Gw_U뢆cm'J:V@óÓ.!êFv¿óñý‰‰ûÓkÜ#c ÙìP®?l™ñãNÐùÏy ]Ýfqð"æ”úÞ6ªGÈ̳y¾—ùæõ‘)që¼ ž´Ö+W!‡éXS™/F­v2Þ¡çÇÞÌ%éž= éÁý:Š‚¸5W©B„ÁfÆ¥J^ð}¸ÑóH º«®®C¿–§æ§+À¿õ¡5í—\<$¸4eö^ÜŠöß‹í'ì9åÇ™À9+‚6 ä îS‘0ïÝ&ð9ÁF Œv;2ížøþ5,Z/&å ¢Ùक़Ë*½Ú½˜vÎãDgUØk0ž´EëÄOˆªë)9&sÓ/Ýnôá†Ü³e §'Àoi’Cö·>,Š)(BŒbNÝÏ%Ýö£ÌáÈ8zSÕƒÃÌŽzóŽ&¦•åÖÓ¦Ï7¿¦Ûï@õI¶Ã‘\'ìU97!8­•ö‘Œ"èò*'O©=[öòmš;Û1*ó(Sûv®­>ëµ×ãáBHÔ6´H.ß É|N/åØÁìtڣą7à· l{šG2|+"_ƒyÂëåª"î‰2ÐŽrÆæ"˜]ºn”³5¿¼³£^°WBLÙ«®W.Ô럌ÃàkqcÃCú'j)äçžÓ}Þm/”Š‘§þŽÑóÝÀ´¾Y{[ƒ r¹SEgr‚XzÝêHu!®tãp,ä0ëzî+ù ¡m½ŸÄ0N»`ÕÐÛ5™·»“ïÿÞSLS‚ŸJÁn–lS\óÚjë³¼c„ijtýÌv…w~ŸÔ/bÄL€x­ã°¦Ÿ1ø>Ø ‚ŸßæÍQ‚ÑÀžƒîëèkÀÅ“Ð/‡yW6¦ïô(c!Ãd9UÚ&œ>ž}]ò“;ÞÁôŽ€é‡öb‚yvÄá¿Û á­æÇÒô¥¸74@1 Éuvëª %þ½­:ÿ(úŽûôÏSµC|ŒÇ ÿ¦S:~ßû 8DýìØÃ Yʶj‘k¹Œ¦‡«Ñ^—öCË ãËDÖÃ'À>BíåŸ8~0yþõö“ÅUDçpüšÅÿ©Ï³…&ßæß™@·¦˜­Ê¸-èɻܧüWä~ÿÜñÉàzðèïdÑôæ­åßf‡' Í `Ì‹f±ó#Ú±è}Ò¥H„‚j¡¨C[ó´««²KÒ.ŠÇœ/¸„ž‚òWtÍê 8õl™Ð’l5# =÷ jçïüñ_1BÏ>\çœ/ªÕ–¾=ûâZÊ4…ZKÐÉ]Lë+Cfžg³j¤…ÿ›;lÈà \Yæ×ÛŸœ¸s›sÆQ6ÈÛPB",¿ž˜¢P]¶lVÜøÆ“1Ü_ЀC¤w²³ Æý|uþ²ÁCH8#¾ë¹†=y´³ÖZ=ó™&ľ€¤mŠ{Ä •Áέ2ÿ{å&øÓ… «e€±YêÝú*= x´äZ†Yæ M£öéFZñû: êtfž¢ëÇ «®»oa±Õ·Ñº!Ì‹ 4¥¥¶C7Ú¨ø¹×Sàéª<ßßš…§Ì‹Uz ÷E€‰8»%äñ]?–ÂyAñ{‚§@¦zý:Y¡ÿÆÏã™Ï¦1uÈ˽ö¹*V‰>ŸEòá£`‘n+Rdw /9{l,È@8_2É¢¤„¶>}›êGªÙƒ_Ž€ã˱)¹kæ˜Êäë5w#㬱ӳdyÊä¼ýLE:1 jú?•¤¡mÐÞcl‰-\K’ÚÖ§õs!*ÑÛþb ßÿ™'ñӟبE¶úÓÝ¥$ìëƒÀ3ä@ó³ÃF(±¨£mbXÊ£2Ð"ö’ÔêvMt2 ÏÕÞªk”8ÌÍWÊЕ£éû€K>˜=›]s-çUàq¥´éA££Q™—¾_À¸±Ð–{wá cÝرÕ÷f³¾aŽþÛrhdE^‚–ëZD¾ÿtÏíù0ù,Z”·2ãnªA×pzÿqïÅIt1XÇ^K‡ºee¥îàDEòãa\ X9ÎÈ&Î^;}úvNt+hvrí: ^ýîãg7ZÐZ¢âˆ˜ôÌþkô³¢ ùÇ= hI,5™Í,5_f*ì{F‘,Ó¿b¯ƒ®?;Uí¥Ø­u…E`©P2hzc ”bQ1,À)ÑW ’j¾\ˆ¼„¾¯µÖN¦ï@mߡ֠}²ÿœOŸšÉš µj°;õDF • ¼vr%½Û€Öz¿Øý³J] ¨!}7J3ÂMãè{{×®*C/pûX/S½G«HbæÍÁjë,ž?5‚ñ†ñG´ÝDƒ½#«.˜šæÙc¿MëÝŠE-÷üoþU$Ït¤ ÿ¤5ƒ‰Ÿ?dGpšBŒe±‘†ó}z®ý  ø¶ MC$cq;©ß9ð|Ñ÷aúg š:KvRߎß4^‹“—Ê@¥îVs}¸4Ÿ|ðr'x{~ܵÜ;R]Ͻ®Äö O÷œÀ”)þPlDyrþN°Ì¡¹ìžNç sðb*[·ügÿÜ…¨†~hOÅßðëáZàÀñÒŸÿV„}¼Åw†º¼™ªr¬oBpòÐÍûYÌÏ•«ÜàîÒ-Ên A˜²rCúOpüׯËxN€é,¥æà÷­záĦËÇVh~¡[P)äX1\ sû²;Çé]âî­ùŽõWÓÀR{½DaïôËüËž¶û&˜Mú>¸4‚{9°,uóŸÇÇ£è~‹›¸4ÖMꡞ¤cõhÚSrq[ ¡ùÃZY‡Sàù¸“Q¶æšý¹s|ΕUØž8ó_}aÖ¾¹³¿™Ðà“JÏE*ðõ(–ï^—Æ 3ŸœšÑþ“Ïáƒ+ &v—ÍïuhS<Ø=ËVR“Ú«§ÈPýÁÕ½w-ý!@^öîÒã`ˆK1êWáGÊ)ƒ^Ÿ*t4Þ^`MùêxLj0p¸Òá*û¼¿Qû!UùK¥Ä·;ÿ缡z™¼úi ÚJL6©QK€ï±¡é+>àv›ÿ´}ã鯰ýW6Ïl$U>‰‹Ü«ò„yç 5 `&µO1¹5Öª#U®¢ûËݾﮯwФ 7][õ³í_Ð÷‹Ù¿q&@•ç«!×:v¡n~Yкôœ™“(ðˆn(7<’Gþ5ÉmK‹h_Ø?zXÍ ,JÚ½B¿þØ{z‚ÿ¬ƒòIÙñƒ"øÄÍù×ú½@ç+%%Ѻ¡µCëè%–* Ù~õ§@§îº¸ :QöÏqXŸÝîª2Ô‰öç±ïMåK´I°¿ ÌrBFïÔô“sbÈÎ=\ã7:1V°EkP²mÃã#Jô¦1‚š&õ´Ð°Þø«ˆ7ÄÍ/ƈèa$ÕÇGÜ3hmTéºc± íªuž]H  o²‚úQåpCÇ]4 rêí‘ÿeŒš4ö^Ëû×%÷1ýúg¿¨Í¯tnc4HGšŠ0 £ÅÑl…˜TÎZºªð±T^:Ý!µºâ<ü»Ð -•Í­¬µDn׳˜AOvÅù±ó]à{^ñ_•&|jöé+Bw§–Èï±:t2-iö4Øítëûlææ~4Uï-Û `Ü0L€µ|Æ.íçm‚@ÁÙâ}wÝÁg%¬TŒÊÃUEs_†-ÛÄÐòÊÿ=ÿÎ19F·-0<ÃVXø¾6D“d¦þá‰F¯iÑ…„×zk¶«dbö'‹í‹ Š}üÚ(,#øû¸º þ¬øëvœ³M„“ž4l]'z™ãž¡[ íÍ×[}¶WÖðÃ] ´èFÂùö÷É[èF¹ï~íuGðO®¼˜D“KæßN ¶÷nóÌ™ ðßi=&x·mŸ½ZêÚËN½AkÔÒm:Ì·Oì2{æh´3Ñ[}ÍÖ©äØv{¾ø“¶µní(>ÑÂΙTÚùÒà{¯A}BN ÃÉ–ßõ˜¿BÿÞ"œ¢šhà±çËó»“à´}3Õ£oHfÝ£žF#Ê Û²ž ½L¨ÖF3šzD‹ÎÌÙ£px¯Út–1¸M¿¿¸d+þU…×m9 Pýe•¨µZÕ>ˆiYåE©ç©ú2Å|ùÔòÏ7ï¾f¾!ÂÆ %.Ä §2I" ÄŸ¿UǺÝûÌ·®€å`t@¿Ò¸­³ØuîßÒ»i®ïù!àq”`Í{pê¯P˜ÓÙÖ_{›^Ñ‚ýψ¸\@wä4QùzÐàžy׬;‹N#ŽÞ6a«hužƒú®í%ãÙs½ö™681Nóé$X å`h´ÿB=ˆgz¦~¼Ù‡j™ß%§­€ƒßò‹EÑîõC+æÇà–fÄ?¤kR}†ór.i™=BüÒB µôìà{÷nܵV§n=xˆ‘×F76âÔQªäÔùZེºPžÊ‚V¶¶±‡.žE©ü/;eÐ)×f‡çvà9¶>ÛP‘…®;ŽvQåBÛkG'É»'P[_ý qH’|HB_y<ÏÝ3›¾¡Ç>+11W¢ûòô@F§ú*ÝÖÜç Ç[ÿ°bd£öôów™`ž©­eÛyø¯û…‘­>°`…%ú™&èAºzÓÿ­»Ö’e·17 Ù)—ñHJ]t;ûáSkîÌÿq–/òÒ¹É}Áf±O—ˆ56%Æ(y µ—º½Ñh)hUɽ²m©@×î¼ ;Ž€yTúÕ=º.hI½<'ñè„]¿8{ý/„ÿ¡|ö‘ä †¸êF…,ÿD—&‘Rt`í|Ž»‹¦´ Ww51^·²=O­!PØ»YÂ1ÌõIØøç¢-Ûìõ9‰7ïû!E iÛâ%´t€™ÏŸ›;êÛž`w·½ãŠÀŸrÎ<¶Ý;ò"oÕïÇèú†×_ú èÔ‹p±ýÃh5Üt”¥œ}Kt(Ÿ|[•ó†| ÷Áeæ^}ëEzt÷õâœT–GçÈùîỘáwÙä¶·2D^s›^M†@¹ùD~áç¨}{a;Uç^âã>±Jƒ>…á–ÞǾ£ütkãýS×P²mäÀ=nÔÒrgTÖFƒìsÿú „_cgúöÿgÔ2|e8GV>”ý‰YàýPÛîéÙ_h%'uþÁ:Ú:Ú(/gޡ߲ ¯Ô2#¤Á[/ýÌÀÀþ<»4é}ð´Ïá´¿ÖþÅâsÔoï+Âì» b›n>.m82fõÑVö] ©ÙQsÜÇÍ3ÒpBÕø©³šwÏ@ gÍ!út>Ï^ÅF­ j‘æÑ‡‚ 6¥ê$YòM´ïü}Ô¬:,†– ¬þϺÏ!É7½rt­ç¬.´ém …ðÚªŒœ/Zj©~Þvø&ši\ÌÚV…–uëgéz‚@®fVLÝt<Ùô+ЭÃF ¸÷7Øç ÎëÉm—¡ðÐ=#¨3пr„8 Þç²×ŠŸ.ƒKý ÃXúÉþÇ)tWÑáò:¦ž°{;Ïg0Z(ú4l׊ÒMÂ’|tõà¸ÿ³7ÇtìÚ9*õ[n_ª8ýÌì 3ºÉÏkɇ#Êm6º$ÙÁ£ž‡ò#Ýic¹»rÁèP§^w>ÖÜ«n%Й3¢)ó³Ñêbpê2ͯBô¡¹ì¬ýÆÄ?ˆ8çh¬‚VG«~ËlØV=Ýt2Žq™õQú^ùÚك̠²<§èÞÏŒÒ#_DLj­ÑòHòvVu:°¼Á*{Çâ3XÝTñáK¾ÏŸ¯WÍm[õ[<_ÐŽ¨Ó¨ÏÎòeB7y%WhßNnÕ-»/nVšs¢Þɫۮü¶«‰Ly÷§¨)óðê¨cáV]"äEwéÉíUººÔß‚ÐúÅÑ)2ÅE4÷S“yÔNg<¨ÏM‚Ç k¶Ä·ûèÒ;\® Æ«lóº½AíßO— êlȲÒp³Ÿ·G·Ùˆ™wV¨÷VQ½î‡8êÅU?|zÏ·¯ÁCiÏ%¿>@û3vO88jЂ»`š©BxzšÔdxQíEŸÞdž:ZW’ç“ðÙy‰Zp8eš©áš_#ÕÕ”ÅA_ð‘J€ä1ð”‚#†÷ÐCm{7eöoôë¡ÞA‰š|êd‚O¡erXˆ%ÚsuÊ–|3Eåêá÷GTÐ…ª4ß·­mÞàK=‰Zšº÷ø4‚.ÝUi*ê¨ß²Û(b(œ¨¦¥ýÁîWt§ÓÔ‰;)Ì: Ê‹BÓøo¡weòúðu0ÏúNª+àÑõÔŒ# EN*ó¨Â Ø-oò½Të´ OYÛ;í! O¨À=±‘JCî ªG|tÒ“Ú:Þϳå\à"qëÍfh"XLsJ œ]M­>µ Ú0Ÿ^Ê ƒZgyïäõ€|÷DzÏ(Ú }ŠØ&vSäY½U §ÞÂsêîí¿D¿Ág?}maG=¼eì˜Ãžu}ÏbA™ô¯¯Á |¼]J«µž¦sXU=B]­Øý·3›Ð’â^Ôµ;©h#ßéÝðx•r.Ú<—©¾ºFK€Ú)jzU 0Ú¥¤è×zlBùZtÜ‚½b.«å!êÎôý·×@1aÏ©9°—óÎÝšßv²F¿8MQ[ ãSg£$X®œ°þcÐÎê C'Ûo€& S§æù5”ïLªm=ˆ¶ñÀn©ºŽ¤óÉ=¢g@3êqÄC¯u0 ¡Ì~;u¥/ œ°º<†‹ïiq缋Äþ8+Ó"TËßÔò¾ôdòÓfvFëûö Ò#àrBßøÓ<#EþÑ<¬Þöæïw©ÎO€Ï¯Ùõ~'pð”øi~×rx8kP;æîi @½[_I^Au’Ž%¹½ ݺnǘQÆ·~èA`8¼zÑxU» ZgÉU;_¢ËLEM¿0JˆŽ_©%A7ã$íáï¨y¤F1° ÔE2¢á;Ó¦oAi<æî½Ýy vóù!‘íU ÄIæÚtMMR²ï.:0€„})YÐZ=R=ê÷DHÏìM`[‹‘F1kðH{¿Íçë]pm€Í‰¶)·B0ç´¯I¥A¦9}»‰H “¼·0êÚvûîTƒu˜N«û•ÛxpVˆo®ý.XÖœZ8‚¦S<‰®Åàγ¬òw¾\×Üô“)ž£”åwQ6é{xVê|Ža`é@Óoýž×ÙuÐ‘Ô A‹@óPùÔ­3ÛÂ|ÚEFÑZ—KV¹H-¿ëüYxZ†·ö{š)R¢ü3‹±“$e¨ÃñbŸ«0hñßÞ>2¦ Úc NÚ"“hQEË þJ°£À ÿÄʂʋ¡ókçVÑeÍà︦'Z< *K~öTNû¬½Üªëé>ù³i1ð‚îÔSð3£uº3ìõÌ ù,%ÑšZõ}ÀsV Ž gœ°BÍ/ïñv¢Î¥©ÃQ>´¨û®ñZ‡~Úmª¾Ä} ¶g^QQƒž“mO‰òˆýf¢æ düÍÇ%Æ@å>[A‰XhÄ>¼±? lã'"²ß#×±I4{± ݶ=M)cݪç†þ}a@ý1a¥ôs\ ó@ð[¦ÒG°ÿår.áöâŽOÿç¡¿½¬ù`-i"hÍzú›òw–¾vðèW†¼ªë±T†ï÷ø -ÍÐ×Lö6ÔHÛEë‰êäNÕQfUàa œã}Ñàà!©îQ ò]‰×Ë8š‘Ï·ƒê¹åGP¡nñ¾›âÇ:ÓZ˜›Ñ‚Ó!;xpl'þô­\O7=‡rëÐàÍ»}Càᔓû"‘· y{ÍôîG)’QÐ)Þ÷¢:ÀòYcKôp3ª41ßN û?·É²ÊQ ƒª¬uÝØ«ÏˆØsƒ‘¯ýÌ>°w Þ;`µu¶_EF´øÐb£öGæeä|^Õ9|jâ÷¶Ãë ñNÿ])¿(¨ ©·–­ÝE ¤|×Uô?Ý mg--ÙþH4d±Kª|û•ïÚ}à*5åßðX8ƒäÌ•w;|©›êŒõ¾=rã*+h>N}3NE‚Y–Wj¥\nO>ÞÛmˆfß]Y÷ç±#IæÐ=)Ö·ÈþJr÷ÐÆ °w¦þî.Ô²qéҟΖAvÆ1C«ÐÈýyë€-øH&²)Vöì ÛLujp¼1Ø65î‹üiòJ¿( eW•Æ5Ã^wÁJÍ]rB;3–%4] Z”ì;m#ĪÝHñ“TÇäI).¦Yʈèݸ .gÝüõú ¨ÿÖ³<^gÎjycÚµãs—ÿ‚ûÒ­Ø´D# üÉvfìNÔ¶žˆ”ƒðX¿¨¯Œ&­[çÛ¥ˆv¶WÞ:ËÛƒ3¯8†ìÝ‹¯Þ÷Ý—zþd®Æ _VÐ{¶†¦Œâ#¤æsÒô|À„´€?µyà{±|Ijìot7Ýs$®iP>R„ô§ædôCfé÷ög¾ó`Ü3J¢Ü`=~÷¥€>ØL{µFi—bô©cÑcñúhf9gµ~""s„ÚùÞc¸¿SÊ£g´ á¹n¯)Êl¿Ç>¨VÜöbc#,h+Û_¶ôòô{Ýx¸ÉU‘ÙoºÑ­œL‘b/D*º‹DÓ ‚Où˜;×Yôl§‰?}ü/ê‡ÇQ=4ÃØR¾§Ìs:xøèpêøš ä,=vçk)fÒ-sG§÷cñ—Âx·U!¿?ô\ÉM¼#©ähìW!ç5Õ‘ÛPÊœÁô]%$n~Ièˆ^³»_ÞŠðí)¬h/O¨¿ #'ß}U]š8ÞsY ¢Wƒÿ¬²HaYׯ~Æ8ôèùv•9°â⋾÷­m2º*Rsœ¿¬¾ëÙ5ÈHtdåMõ*†ª”sœ-ßòóG ü#¢ž¯yñæWøÁqZ·îèH•m›ª¾‚ö†ó›jZ!…ç5 O‘?$Úø<ùn’ó×h¤¬ fgl£Â¡s•ò¶·Æ0fnf÷A«J k‘;?—±¤º²îjc´+]ýÊW1ˆÎL‹Z,‡Ì]/†§ß@ØÕ9ZÞ”hU$ÖÙœ[ ¡Ç?ê³ÒœDï¯÷¾Ý ¯ J;ÿW}Êjç3Ú=àþq™rñà ÃÛ–'c[ÿAˆó¤)È'é{ 5œÀÀ ý‚ão^aÚ¸g#ëdçýe¿©‚vVƒêû:ßM‰Ù›û6ß V'ºEÜå'&0˜-Ë¥s€‰C’ðšÛqˆrüÜTpøXxðTú•Aósêi¯b̼fú#Ód½"9rȃÛà/®Dá‡ÏOÛjc!ƒö¦ÉKÈ|Dæ•Ö˜Qǽϗގ„$·¢ÛO€SõüvÉ÷n˜pîSË=ç›è­ÃâÇ—!Zqžç’Œ8Fš~}`‚G^}dYK ¦õRM_Hð*×g1€Žw•Üã_Aw†ò|~+”|ô´áÛRˆãë‹Ù±‘‡AÔ¼òÖ1ðÉJŽ"ÌõîzÑ´Ë+y^WbÄÎçE¢oGíåKÁ)x¤UžŒFT PýÃÚR$¤¿o¸Âc‡§žíÏ' |If$=;À2çëHÅÈaVîo“;QåÔoäÐLñ&ïö<¬. 5#í€4fÇu›wVÙ¶rºOþ¤¼¼¹ìý ßöÖXKÚcdh†Ë#tÿö7›íu3f|Ÿ‹Xþ~×¢XÜÁ Ž_žÑaÚx\-[›©&m«ÚS²­ò&T^¬“ò„p‰|Æë…`uqÕç˜Ä"z¼](:C ¢˜J@½^â7Uh>' %wá1àTÜ0rd›ÿÑeÁd&á/”EÞþÛeÙˆž1®‡Æ¥‹ ~–_S¦ý>sŒì>ƒqõ7)l·ê¸œ«÷\˜ú±øŠVn¤.Ÿ~)åÌŒ~ìÌ‹çК] ÇDKÏ/ε¼Rô• ‡Ÿ¢à{­°Ê®ËÓ§Ð|†¤OE¥ T{À<:i>? ø8LJOBªz„‘ËDêÆÚßËkG–ßL¸Ð…««Í`,¯¢ôR/ ¯ØùÓxºØv$CPÇ—ƒÁÇ)P[;¬ÔÜÛR;XŠv›‘¢3Ó³uJ!ˆ;¹ýã©ß-Ƹ˜°R¿FÏÂ_ xë)ß¿¯AûÞ¼8ØÐ™dg\έ€,’=Qš]i¦wûFô1PÕŽ9ú½x'¸gú}ÈGÙ^«¤ˆaˆ¸.6zÄU= èý4À?€œéôy*ˆÞ¨¢Õ©JσàÑ¢¢aº‡Oý¸Œé¯ƒúµXû1VùÓNEˆS~y‰K3‹{»ú!{vϦ]ë¤ÑØ­ԋΦ37?“AºBZ³î#t£¨˜9Z1…AoFúz_ƒë«ýr‚¦[õKÖn,ÛÃsc¬"ÏÝí¥, †‹§½µtÐ?3‘"Çwn?‹Ûá_s1©ù¨ÇÓ÷¨wÃŽÜ´–r ˜>×/Òßx<‘´‡«ñ{Óž€åÁûQM>C ÍÚv{.4°‹5¬ãgƒdµ¦¨;«÷#x†Y ¼H…¯>|‰)i›OœNAL²VGìÛnŒ;ÓÛ¯ òäÆ ^/k %‹1Ì»²\oQÖÛDWƒ“IÍ3¿ ÔkX¡dá:…)-]o$¨cø‡OûÓòÐîÌ÷ͰÀ&tÛ).q±~å^<©õú¹uüïªê 9ä™Jq,è)Øâ+lŽ—´’5Û`TN8íßQŒ8×ûjó x¿ù&p¿£âƒÈû_l˜ATð-<ªNÝþÁ—ÞbÔxõJke'idGõ¨²¤xcô äî—[~ŽWÄ5íïÅÜWÏì×g0OÑÖ®J) YšÃ#¤x Àq°g;m F®ýŽTµÆDnÖîâ~ÈÈ*ðJhÏ;_Ëüvƒz7·XÁRp§O{õAmZÎ^¢â;©œQ9µ¯ÚF0!âȤ „žÔã;fù÷GG¿§CìÝiÖÃþ gyõ±ËL*jNdS‡àXïzû=rèMCmÑ÷æ ú&ZÝ:Ç)òI—Öîƒà]Oj Ý!w²ë–D~zý¬ä%€¾ÃC7»®€l°â:“!;¸°¦jâ=á:ÚGÈ»Á5xûHz¿†+n[<Ž¢7Ï“gïIߎ«¿N° »õ©1döû$ÄŠšBü“'~@¤SmRÿ$:|‘r÷ÍG‹½†Jspè|!AQ¾Û”îr´¢7ÓΔ‰è÷ÞíH‰©ä¥í}‡b¥˜~ClHpkþØD-.ý**£Šm´<[!ÀܼþÊÎ_haýy±þÄÉ×:$¯B¤0Ý®û‹^(Krná9ùiPJøñ½%ò{í·=œºÇ[HÄúÁ’e†EA¶ƒöšçJlÕo=¬šRâYöwž–vâ9jËøu/lõ­º}¯®=<»¹Èû[ê¶ÎÃíÓ9Ψå<-\­»"¼oµÈÄÀ¸ç/ân ³ƒ™jfùýÊcxFO—Ügl3ë)¿k—õbŒŠÉ|A+)f®<륋GµGh•=ƒ’•Ð`.ÕIpÐéáéb†’ô|QõÖçs‚ê; )º%TÎôÍ~Å’Óý7ŒŸ¯`éd¸VéÈy-Ú¤ „qËnT7NCñ»ó7i8!Õ?Òë’Öe1v…(zŸ¢êˆ÷Y“VÆ Ú5íµû1Xt¡,ê‘ fºøì|{òX„ª£&·êƒˆýýÚÑ?|æÞ%½fȧǷ V“;ÂOvõ/z S7€ªRI½ÑÖuôŽ’ä£>K´õiî¯ÐÈC3å#K­êèÍüM¿°W -Ú•Y$/ATÆ•¿;N»Bfà',ô„Hû ™’‰=`¸|é‡')g~‰ñL[ÏwN±«ôVýkJøŒªšŽ‹HŸ>€¶é?*ÞHŸ¡½O¨Œ"o@Ìç¶^~sˆáy’³a÷Üu_îï)‚èKéµ\L_!è´ì­öTt$7¡ ’^,ùYâYnsúì+¦™§½Yz+¾œDz4§6 ;hÁiê6¸[ç³8Ž^úâ÷žG™îZ¹P6jž8ª¹U/•ëÌ.U=ƒÈÈvÜ©´kçÎþ´U·“½%„¡ émÛe Ò¿òeJ­1¨LJÒIJ„U=H?”ñ‡t[3ó¬ŽbH?Ü©Åv¡å:vç=Û:“:®¤Þà¿ÿJ5µœ2(kúõžåýƒ¦ÛºÏçþ‡ð¯XtŸöíž.½aå·F`9MõóŠs †„)Ó»šf€³ü»ŸûÅÍÐÆ*:N@”Ùh>l–Ç,@Fw㆟n;j†¼¹)x1B?Óå¢ ‰'÷ËvIs¡Óé™l­v.49fût"’ 3ªw^1¨ÇìÃ/D¿“ü‚Œ%šë§Œv ÇèÆ=[¶·X0ïXUû§z«nØQazç¤L ~+«€¸§µ_+.ÔAÁç0ù¼àQ+»@nó`l™¼dǃ¿jqªøjt?ùØž5]<ɘbtÎÕC0Ÿ“…ó- °îøÓCÛÞƒ±k»)F(~CøòJ3ÍY[´|D7Nu “:K؆ ­Ê:y«‹B÷ýÍóõ|®à¢¡w9&n½÷¸¢Õz…¾±£Î¿úk!ý…¨n)=d½i`?Å 3÷”kÜk`ëì¬Á`(D¶{¬RMÃ\‡{7NéÕÏwozî¦ôÿ Ko®÷#^ï«3™Ö‚Xé ‰‰/è?Ì~†6£F>ñg¾ž†Tf‹Zt´„4‹xu’ù£`© ¸Ö~Y0‹]„Øo/¹Òó\02]+iÑ«â0_³äåGK÷Gü®'Íý4o´ ÂåéÈÛ D©ßd­§¤A÷Äè…+\ìè(ëE[jm€~Ï¡^”ýdEnÄŒYæcë¦kþ¯Çðôß)q?0¾ò¤'õj<ÆÍvÒ°8¯‘{Ò“W5!ȸ‘yC=€>/óÛ^Œñ ü*7Ù€éÛ/ð³IGK¥ÕšÃôèvæŒH¹˜?0SrÍÆ‚KÒöo íJ¤MíRˆ¿Â³²C|œJTЊ ×öø+ש1‘ÿñXF"xÖÿl9‚^¿ÞqÐqÖ£¿ yÈæ-Œö¹ý‰¾û(ÆOúý¶RQÚz^Žíu/¾*_7Më€ÌTu·z$“›5†Q‰CúHw¹^—2FäåÕE¯ÎyËõk˜6ÜU“y t{©Z“v`†²MfSúFixqQ¤ôaZEé²&?ÆÅ-L]Î)ƒHG ¶·šXÚÜU6–i/÷|÷÷@Ž6Ú›2òsv—ªY3¾?ÃLFÑîA‹G%Ævböòê’Â!0Ó_•XI—ÚÖ Ò UVë˘iú.dH ÝÃøk|#u0ÓjÿBü*$³ÚL& 7¢ù É|‡ó¢X´Ø¥:ú ½ú[4o˜C©¤Ùʰ¿28¿æälì/+OÞ•“}¥ó1é¼ ê$ <íZ< ‰£åÎŽ4|¨Mçü[­B¾F ÆàÁ¸¬«*ŒàJk»÷NR#ä88—,dOÕÒZVˆ —•ƒhÍ+¨d/ƒZjå§®÷hÚk½¿ÁøFÔˆ= 7¤*nÝ)†Ïpâ¹–±¨%ØGÛPÈ…Â<‹Gª‡~axû"ÝÐ!ôýÞ>^¾±¶ºJ…š~BÜTè‘eö%ˆÑ=3r;St./d¸<‡,{n5^=·Ì}]aE=sòã­Rýº³,é/„,¿æ­2g?æÞEÚÕ7è$P~´J›¬·ŸµÊ« Ãô³¬ÍçÁ²¢çîk¥Çè+õñœêm þý¨Ð6pÔLEŠ[db¢ïC)x'¿Ùu¡ê Îx"OÕ;§§‚\ š9¾B²?O ”ák}¾»žóæ”ÓÀ¤1…-êÿ@{¦¾ð«“èI{ùOÚ¥}àöñ”ìi70%Ùi·IþÂLp®GÛò„ˆ,3ˆéÒ jbz~}çLdbÀ+ïgŸbÛ:ܰaæÐù€2+x¡áFR½¹vù(D—ŸJÚ­g€aÚ'ŽÊ=ƒÄ*F-9¬ ;ô¹ë z q²˜ýie×¼÷3cðù¯®‹T#èqÁ×£øì·ì˜’ ņÄ1/1»í,Cø<´á unx´¢¯îUK`„øŸéû´) òšËü“îMð?*ÅÜpƒ’VÙ ¸„üX¾ˆÄZ~ÛÖšÔz5låyàôm=ýø×|tp³®«Pƒ8ëì•¥%tþrø<—UÄuž™m»î©×‹èSÎg€Ó¦<ö/k˜>Ú¾Â4¯ÃòÕ‹SuýnˆÓëE>x7ɼù°?ÒÎëqê¨N÷ŒêK4÷eÌÿ‚C¡g f¦‰U¾Húö¶*áÐÙª‰^×¼ÌÖ]µÚÐ?3X³ ]üu­Z&~º@øÏ}wÎ*Í„K?=7Øe8l7½eŠÑç×Ç{ÞDÏM«Òï¾mÎõ‘ú£j+ܼÕ_íízRüÄyÏäHé”`ø ’¨áu°2a{”IÚ ‰Â“ѿӣêÎ\ª–hsö)¯œ— FjËEó+˜üãoqrç$ê“Ë÷ú&@†®º$o@jw¬Ê˜|‰A®îä‹­¡QâÉÞ¼~5D’~…!8ÍS¶~Ií¹½g"Ñùsüsu–#äÅýÖÒyÓ Æ%í†ÐÎ*®ß¤¯ žÞQKZbÌ…zß„k]ÖºOæË^Ì Vä·èÔ€˜7‡[}Žè¡+ɰÞK² h 2€Ú¤µF³#fR¾ýš+~z̬Hœõ¶_@‡â¢‰Ùé!\;ì+ÉnöÍÍFµç†} {ѧöå鳓 ——nÏ€2 Ë£mýÝZ'î›|΀Ȃ֧aÀk;ÿhÏÙchöîÒ’Ò{H^®w¿ñ ’†V¬ìin>³çä7¶P™ô{º Õç?çZžêˆ“YïëÐÙÖ9îÁKc w¹y°&Lb%‚;3z‚/gàl´˜µYÈWJñ »ãëßš;*Áß-áÝËíò~§Åç—è½2êJ,…èƒ,».©˜¢Ï—ë'ßjd¢÷¿_®çާv¼Ì|Ì/†á«!N Žg1擾jÀº¦|tÿ-öZ˯qóñ~~ ½Îá‹;ËÁ^©ogÛ&äé´'–UBÛÛaŸ¢Ðëã%—‹þo1ëCAC‰8eÖ‹Þ4 ƒÃ—Î6lwÐÅà ÖË-¶QnSÁ qýö“*1_XÑ´Ãéo4sßý¸ÞgÚoe>[Ç(ßÃ]²&[£œB·vÐeLéùÓü!U-Ñ÷LÄê¤÷”Ü‚k9+WÞqBÂïôÍÊ7ÀÿÖñïŽ÷ºÐ,%;ˆq?:ÑYŒQ¬ˆAÊóÃê©{¯ƒË­'Fs÷jеMfF·Ò¹©íäü¼?¢}93¥Í™Q°W?´Rò® ”_GÅ:ù”¹Qr`þ,?“=Úx=]ßs½ÌSöujÏp‚ÿ¬UÈB{*ôí¹D¢úgd¤Bï’:¸œ<}ä45X6ÞåaP‰ź„‘)¿­>»$ÕôÅ0“´ˆísAi1EÉ[ó“$Ú‚AJ@ÆLì8zq³·XÆ‘€Þìíój h4(l\LQ¡ßšfb\zÁ,ìo¾– 7+Á3ÿlï¢m­ß–¬š·M7nÙŠƒÿó+¥iÁE. zÐä)Z­•7› €iÒ3‰Þàõ±ù¸á9W´¤\g˜{Ü B^±a:މhýmØ‚ïëÖñç¿8˜XŽ4eÎ2IÑçdˆðëéôe¼uËÛ숟–߸« 5__ h‰Ú÷†¶×!ðÉü!ÃÂ`}*ê8 /ˆ(R>.}”\YŠuô2ÚfSGn~¼v¿¿ŽÍáVý®Yœ·Tu æãg¡f³ÈŒšÝ_p-íX}Ø^‹VíÝà@ãCÛíOâ 8¹7.ÌŸBõ[܇w^£Ïæ…½œ^`j˜¯Aw7´…jœõ²ÓÀ²›iBiø=xß­¦\ñC”{qb›(ˆ¼Ý ¶æQEeçd’Ð+ZB_yå4è¿:ê·|óX·µ±ßÜêî:DË–à.#R7 31´ºq°Rùõ tÝÉÀìÝüÔžíË3îV[Cþ&®ý`þIèä-0ê  {´Ôöžøõв 4'×NÁíbî?ÆÁÈ×;‘UÜ•z”§Ó.Ç€•íøß ‹ÎÀÖVÛ4|Td‚¯ÚÆmóG3/gŠMz^ô+š&÷¡V‡ËÅ.Õ;JÛгéÌ6€ü½ï¶o ÊÎѳ7 ®¢•÷àf«w Îj©Ýsá*¨tï?Äï:Üm÷¿”Eå'_Ô¶úCëŒË’÷Ð2þß/”CgϘ+~ªºÑùaWÑ›>d•tì Øë¾Scë§b§)j•Àþ’ˆÔû’]À«åP÷ùš—Ûsì¯A7Ñf½‚pûÞGÄ •28KÚ-}iºIÿN¡EœÂÌd‚#d—?ðC—ëSâºLÈwYòÑßáe°9š¦!@Žý\z¹wÐfÈ£)ÿÌ)4\ºiÞ2Žá4]¾NI«/ŵ`¥Œ6k ÇRfÁ¬˜Oò\ãÆþ*Tš’/B댻'Âr³Á»!¶º-D£ŽG2Ð<‡ ‘7Ù%oZÐÔZCÚŸl«wý\ª'Î/ÇžÁ½³ƒZc1>Ž‚sïvpþLvf0~d_VOv¥ïB¶á_ãèZúšc2ø7LÜC–Žn¥Šè7öT^vcø¦;8¿r ]ï2„p^èÓ1ê(>¿ºÃ/Ü Â§7;ç;AÎ] «¶%Շϫë>D;¹Wû#,A&¶vÑAatîv~ÌfAóOê A!ñ·7ÁÍoÿYjtûP7{{@GÈKÿÉâ ˆjÌ:\¯ 1ÃËž¿À±Áòå¡!Ðd4ª<0ù}º•Äo?šKõ7Ù>h(.ÉýEô!¸ŽìÎo;{¦®Z}†‡"hû—|¼1t›Ú‡…¨Õëõ3K]rk†ìô-ŸíùsìL„ß5ç–÷ͫÔ¬7gâÑeâö†i¤DÇOd¶M:‚õçˆÒWôÕ ¬É.ŽS–çý@ÝJ`úYèMÐ^ zû€Ç 9þóúçÝÒÝ}ÁxÅ0ˆËà#Ø)úÒ^ÝÛ€âÔô†ýÂI _ÉÏún¯x{ó¸îÊzÆ­‰´ó5P¦GÑfz•«*¨ü!Êùe\ Rö¼'N¹ÑBO®<e ¶¦¹c‡s!¥®Rm­ïcožä«î‰3©¯€îç3 E¥)(Uù±7ÿiZåí#sh÷C·óŸŽèÌÁ`ó3—òÞGã\Kë3øû.8u}C{z›;%BÑüýWߌޭÇÁù8oJäÞM7+)AŠê»ã¢† ðŽ¹¿¦ùæ4ŸÔÀjoË'ÛÙ§`¡–´êø‘ ÔTÛ¾j³¦—ƒ|ÅP¾8 ÞRfEsè­aLBÏ”EÉ׺+`×/#öaû Ð9û®Ýž-K>2§üˆA6r>²_}AŸ9/K´}ëzáP¦‹æï ^òÓÜž'^×úÏëâ5jöŸ}Ú >tëÞäã…½QŒè©î|ߪá/Z:Ÿ¸°È^ê›×ýâ{ªÐ"F•¾F-|êÏrvñØ7íc=ÎM?°ç˜&úàŸ¿“THY8Pî |ïÖ¬˜Á˸uhî5ì/vˆøx 5™&^yB ÞÓ‰¿u= Ð#«rVMJ õrêÝó ¶öë AÀ8^ÖÞËZ|¹¦çC©¤‚ÀäéÝýžOjòûã©Àüó%~Å+ CIs kò(àp·tñµg n}CÉÚ}†õû%ѦM¤oz®$i;;ão-‚ÛeÅêP½}`”ÎÊì‘熛¦”Íö ¨#ÃÆ«µ´§Ô™§>ÅÃ6q— êqcPYŸãz÷Ö¥7$ÖÅÛvŲ?l0a(@?êzf¸¶5…¡ai‹ØÒ{1tI&wlšiÄÐ’8îcG!€ÜÖöõÅ 6vô…õúxoÏlâÅ­:ì¶CÏîAÈ'9í!‹¾§D7«ßÝÆèPª*ÇK Ôÿ¤qäy545¹ ¾'®|¼|{=žÙ?¥&®FŸohi;m×ù-ÜŒT|; EѶÞBpÿ£åWiÒ)ÆQtVò(su~)öã_ðv=šµw㘽ìiaÜšÿ N9ï¼Ï ³‹¿fIVmÕÇv©?€ œ”…ìOIÛ‘£C+O@CåfUdËC°ŠI˜¾F…Áï\“ ›ÕgTNôèDóçõkWˆ;“©;ŸN”]—ªõГڒ¶è9 ˜»½ßédŒR÷Øßí?€îf»ï×™°É…jîY³ß(ÓAû&p± ܨ»ÊÛÄÑŸëOrÓ0˜ýü<ßhàkDó­ø^¤¬óž]¿þ‚ÓÙÓˆöʲ·H×À]0w¦}«¯ð/¬“ýC‹–—‚‹í„ïŸêòPùÇ~ô15ÆpŠ«×ëîAÐî=Oø£wcð‰Æsúþ³ÕçÙXF V;øÆ&¥@ÕÌt1ü I?<ô¼ôÄvCÅŽ7ƒànÿèrä:p'DŠsö™€Á+Q7ÿèÖ§.òîk$8´Ž[|ÈU—!Jæ 4™ˆÚu¬­wå€OXÂI²†æÛëÄëüÐAX}üFøe*Sïñ,BsÎ0¡™Á»àÛãPAª¬ê.Ú,½ª`Ûó=*Æ~àÑðüÁ‡û Œûj8g·(jJ¬šš Ûî¢^í®qpoÖY²½ª„‘sۦͭÁå0{…þå?´MõÀªí9tIR½¦¡é¯ºÞWÊsÑ" íÎéËzo´ñn ßq®u4¬äè?N_ă|âuÚÑ_Á”÷‰HûÖõOk¾èïób#Ø[*¾ÖW ÎJúï^ÉõPÖ5±4íx£9Pºí6M¼ã¿aÐõÆ„ƒöôàs,¸è`ÖoTbg)Ù % Aj^jeЖÛù³êíÖóø=­Dì;o0y´!·(9V|÷ߘ%–€ÄË»F©O%QíD†ÿŸÜ‡è_¯Úd÷FmÞÊ(ð…BKÒk¼¬M=âѬFÊÉÿØ3ò|’øiºY€ï šg¿N&ƒ'ÝáÔC& ¡^{@¾áº/ÞIôDçÌu²—ÜW *Ã#Þlõãû ]¹î‡~)sŒG»9х߃¯VjêöÕ{ÖÒL™~èaôÞog#/a ªÊ¯£_߯bV)ð¿ÛdzrÓì©ÍY0ð„´µH€1 ®Õ§rcæ ¬ž°5DIh™¨K‹£Å¦ê½R&oúkí‰atCi™K ùn~aJŸƒ$noõ} ֧߀=çhòYí“àóbÛÌÎô³Ù¬NPÇèmŸ²™´£Pô¼1%÷F—Ž«F¾gƒª†ZݶSèÏû©‚Õ0ýTî÷ÙxS”fL™ˆ¸» i1gnå±€^gg5'Ýþ]$‚aè°”;îfÛ †³Ó¥Ý|‰à^Ô$DϦ‰:wjzn€²ôƒ„´Cè›.Ö,µ–Z?§ö¼é‡TëSÑÛ^‚ÅËщàópTlñhØüÍ•&áÏFžÒ¥á9`EÒ®Îõ³Ý•ÂÃÄnB€øßí<×Ìа£OÁò r÷h>”ü ŒS[¢»¨¿EnÙlOýöà û0šY^ª~²ü âç¨Cî¿£æwãÌ>‹´Ô#Ë"0iÔiýõ™Eàî¡4›¡õ4KŸVòÕT€v¤ø\Χ×tNÛ|ÉH´iú iZP·øìG{ZP¯¤r–‘@û_ã,‹_ÀeA&„Ãî#úšlN<,‹£×Zºã}À4ÂÿjÊã@pù媴Û&é9þ]¡‚“lpAÖ÷Ý™lÏ\´ ^G„ÛWdLÁÖø9µï^0éNÐ~‘iƒî$æ+2Ïd ’òjûy ´á‘ŠØVtT “y—EàÏî·æ ;1ê“,WÎNT§î½~Åó}Æ,àTô'á x¾;*0¦ù¬Ž=6‰Hã{êýJ‘ܵ8¥ÛŠg¹}/Ò„‘¢ïçdÙ0ŒcóM/„«ñ–Œ¿ ~‡H&Þ:œDëÓ ¬5Ý xTü+{ÀI´³ªèÌmCP5Îu箟¤¹ûü£`·¯~³” #-ã¿ù¿ë¯"\úgò!"á2Iñ{:p§õ±/§ÉûU#­æëK û7{ñ*zÛÞz˸UO ÷$…C›>DIeÜyIB ÿt/¸ ”û¶-‘g'‚Ô×ëû%ì·êd‘µ*^eNåR˜œ-žLࢯøXçU9¨8m! Á€Ö§;Ž•€ÿoþ:jô`T}rÉæ7è»5ØmÕ^áU½;™µ‡O±dÂnhç6ÎÇ.r&—|VÓãÇèPí0êW‚Ê7nêQíYQÿOýdeÇm%_„ ׿%ÄÉ‚ eêÍÃ3aºn]y ·•R ¸Ï#Wí•Lf´rð$É›ÉA“zn7ë¼ç "(—/Ÿ#ž_ïuÊO€Ý=qúýµp(ìVƒ\(:Kê;pAŽ7ʲhÞl®ª†N£z¢ENG©.Úg¼\}ºCü 쯻bt†ÀC‘ŸT(y´xQe¶¢âÎvPÚ,»(Œ}áAwí¹&*‰þï?ÿ—CÑU£Þø xÓ§þ€(èfT]y¦&€Vo‚zÆÒBÁû¬DÜÞ½{À¢ýôón?:°½´ÖàáIÇÙÀs2ÛÚÿÛ+T°øRuâV/†˜{O‘ì÷Ò™“sOøoÿþø¦l  ¶æm6íͽQȧ57Ò]®–?g­]!bçoéFÎ|Ô/Éž”FY{–UšùÿÔñ†4of¥ÎWB°Ø(Mö׌­ú.0«N8 ½˜ýY]C›¯y XÀ¾ dxÙš­Ñº0ŒBøõ_µ–eQ`©ÿÞ9ó‚GäªÛIqз֠]]æ¡êºuiXÐøÆ®c) C+¿–bÏ¢’zŠªçÁÏhîOVÚ“4w}Ú8– ¿ÏžñQhàµ?:>¬Âþšc®7™ué@z:Të£ãÔzz<ŸÕwÜÿoq#e+ ôÝØÁxÐñNŽÊ¯I—â¾];`wÁÈë_;TÛŸzÛ»úݺýv›€yÓí1¾]^#¥Ÿ½dl@?ñÃéÄ G”¹{å÷å`]ÜÛç|"û$ ˜|3f¾V‰JqÒ܃ GÁŽ|~*îP9Zn[z̾mÄÉìB>ãÍ×9§²0äýLJÔot¾ö¦*ãÂô»“•(SZ‰)Ÿyø; ÎÞŽfÛwN°f)‹{q±ÛiýÁi«Z)ü5ò^\u{%V1zÈ™©#n˜Þ–-Þžã ±ÏK¬WÈ¿ SiÔâ'Þ}T©ý{AøO³¼î|;ºý^ÒAÈ{9¹ö °šüÝBÖNîÇ<ì•rФv#½, Cw¾ó%•w‚°¹Î™S>¥[Ç÷ŒéE@j 8Ï\X¼ á7RÍöUýõAÿuõƒ¨0ÔÅ8ýœùÞX±´×?ÿJõXPœ³³ ê@Mé3v%‹3`Gîn[W‰ªý÷Ö¾N@liûo®×ù¼ŸJ³¶ ü.{0Iž±Ã\O|dVA¤­Édt.Ìú(nŒ³KBâtÃØ&%4eÜ¿+ñ?ë ˜Ùv=XãÜêcüœÄíýa—UJì­¶ƒkpÓïÉFðv×2yt¶Üö~í‹_«úç÷ .•ÇÞf‹.btIˆÖ› àv˜{]øs&ú<ÿNïa W?’=z·.½Mô^È+pšO…C“~hŠáv–Ãïðíǰï±}fçž‚“c·ú(ošŒ|Ÿcþy ´¹Ç ŸÁ°ðÙ} Ö`þ”¶8ém8„}]—Œ{ ÃêU;yù!ü’Pg*ïÄ´«.iâDᬂ­¼|`"Ü”ñîN*XX¥ÏW½º{ŸŠqIƒìÊïaVRtbix®Ú¤úƧ@…k›1å·&ÕÏÿ©[ý¸œØêhÑ|:T’óÈ:X —P´´Ÿ…ðkMêfÕ,覼gT¨p‚ïäÅûÛÐC(ÇûÂÝ›hEÝ:e\ìB×dåN§`„ˆ³zþã˜$ KOÕ±1B¬_¯Å¨íÏ-ëúþ`jXƒ »£xl°Ž¾4q‡Ò„&ò» óñØÎ÷c‹>÷­ž,_ üõ[e¾HÉ×9RWp’¼|ªéÔô}ÔÖzíˆ'¸0”ÉFì¾Þd‹¯]¦O£ £k Û\º3¹è½#Ë€Pùà;£ßXQønÈ=îYôÐ{¼iF ªîl+AçûÛèÕù!ÂcãÂù,`íGn¦Ó€š+‹w¬©h ¸§©+6¶bN\rt=Q‚Ú¤ º¯Uƒ÷“µyG¾éAÚµÒú«/œü(jΫ‚å«ÅÒP .¦:âö:ë¢v:ïÀ}AѰ®k(^^®<ûÇMTk]©ÆXnm¶ô_Ñi§òå}yx¨UŠúÆ-àµÜFàŒÉŽߥ!¬£åSuÃ&Dxkî.ÙêÃ;îÀb hܸòSe(ƒ>¡@DG#:1¾½]iSÖâ.oŸ¢«s×Ͼ^Œ¾ÈóûäGônšvã¨cƒàÄ› «Öyè5ùsˆÁá& §ZU˜_ý ±÷.÷2_‡ˆö%†ÂÑytK»?ƒ§'\îÙ€Íwνó^Ò³ÞzYw"ëàèÉFt>²o“½ôŸ÷)ÈÒJ-xnÿÃÍkõiQš“úzIz1é}HfÓ„Œ. ¹ålp[”÷•y톱LN·Úg/@®îÎþ’"UðW -æK“”ÊñÌjøðG¼ Jóù?ŸÕAû–´Ó94¯Zô(»·tËŸÖ–—£ÃEZòUup¡x’‘j„‘IÚݘ€õ_‹»¿žX‚G\BðµßàÓX$üû»"ì*>2@*»$­‡ !¾þÖ¿ÞÁ|_høÝ —‡Úkäl´`ÈÕ°ÁFU5§÷Mbgm×SÞ@§ãm÷g>mƒm†²®r5k`{†%`°-dè¬h/?,¿±•+¿[QÂóÇGýuðâe¾ðgkðW˜[®z»g~nï‡o«­7ÏÓc${úUë ³¾;²¾£†˜ù¼³È0z¬¢àYçHй8à˜tBR²šY«Ž Ó+Ï›®ž}š6ÇÉ] måmm»¡'Õã»sttãÐÌëû àœ_€È1mˆò7}ÄA°R^ʤ †ß”ÌC‡K øêã—ý[õŠý“;é)í`sC¢­j§†TÏËÝ\çõs­±–jŒw“×èµtÄŒs”>}¥ Z6VÕ ]2™gáÉÙï¾ @ÕóoJ|=¥ ì}¸ÄÁwàßDÊ_r Z+M¦Ë0Æš5j‘‘¢B\¨…·íDŸÀc3"lŽ`¡åÝQþ"ÔJŽG…4ÿ ˜TÏ›V†‚r… Åai | F—lÖnï^h¼ˆV-ûôæÚ€©Åbßïy T—z|Ó¼Õ*õªBì'·FA0¬nm®<ʈ,ÿé+½¶½~’½÷¯ÎÂ2˜¯ß¹´ªQr(ìS ~4¥ïsz@¶%ÈšwûúÉ4×&ëßFÞ„cËq©à±—5ç·Vj°]£}§Œn2Œ«ºÖK×ZÿC{9S úÍ¢‘>ͧ#æW!(xvïCoc]/.ÍZ ’rÝÚãyˆ;šèD~q«Î&êH°•ˆezéy ìoØô%ÞCûír²ŒKQ¤s‚Üsl¤* 7ôÀíõš}ÔHÜZ좇# ã`Œ#¨·½¡êq£-ä<´ ¾tƒû†½8QG]¼68þõ×Õ>v(îFêÿþÃ#pê=iתK ‰OÃìÿR¢Ú£¿öuÑàKS˜8–¨ŽÏׄ³”˃Eòså½Ê ²ðÛólçA¨nìZn×1ôÚpš5)îFG2•ðÕ0ðyÛ#RsMµ$þü„„ˆ“pD¼mæÿnï@£‚ÑôÞŸøöß £ÏÌo€™ç\ƒt½„ÛÎvøŽ~GËaS#t˜¦†SkT"ôéãW §õ~ÂSGžºð4{O»‹È§ &<í=ÂÓ±ž.€ðô~D>ýMÂ30žÁ›ð Ý„gì$òwÒ~§+áw¶ž‰’ðÌäD>³=ᙯž…Œð,6„gµ$òYϺFx6s³#<{‘ϾHxCÂsœ&<ÇÂïš#ò9µ Ïy‚𜿿[ƒð{€ÈßSFø=S„ß«Lø½¥„ßWDäïûDøýr„ß_@øý Ï5BäsKž;›ðÜ@”ð<‰|ž4Âó¼"<¯ áy“ Ï—@äó žŸ‡ðü±„çLx~"_p/áà /ØKx!N ³ù„¾Cøƒ,„?èOøC>Dþ¡ë„¡'¼ˆ'áE®^´È£"¼˜3áÅZ /¾ƒðÛˆ| [ÂK\"¼$ á%­/eAäK'¼Ô_ÂK›^ºžð2µD¾Ìáeõ /[CxÙß„—›!òå5 /_IxùiÂ+¨^Q…ÈW‘ïð‘ðŽR„wÌ%¼ã0áÞùÎ"„wÎ ¼ó»ÞU€ÈwM"¼ë3»ñÞ-žðî1D¾û#Â{ì'¼G$á=ú ïù€È÷ÚEx¯`Â{Ý#¼7á}˜‰|?ÂûÜ$¼/#á}½ ïçAäûuÞŸ†ðþ®„÷o#|@+‘HNø@{Â^!|áƒ6‰ü`+Â7>xð!æ„5!òCëºDø0C‡&|x5‘>GømÂGœ$|Ä/ÂGþ ò£€ðQe„š"|´ ác‰ü˜"ÂÇ|"|¬ác —GäÇ>^‚ðñÙ„ÿ@ø„·D~âAÂ'¦>ñá“ ŸÌOä''>yð)<„O‰%|j‘Ÿúði{ ŸNø´^§ß'ò3Ø ŸDøŒ;„Ïd!|ÖN"?ˇðY× ŸÍ@ølOÂç¸ù9í„Ï¥ú—ÿ¯B‡OhD°û¿>§’ñÿù_J>{¾`>¯ÿn tüC4½C¢¼#þkƒmºÆVÿm#¼=C#¼ôµ¶ZˆmÌ$ÿ7š<Ä=Øû:ÿþ&UDh¬èÿºÿ_[{¹GFþ×nP{¹G¹‹úDlm·uoã¿7‰ò òþ¯M˜¬üƒ½¹,½#ü½#¹L=¼=£þk3:¯PÏèà­£vÿWCô_›sXùEs©GûrIÊqIÈ)JÊ)JÈpIŠ‹+?„z“äßü¿{µG¤ýW E˜»g »ïïßÿ×ÿç(·Êÿ9Kÿ:Çd„ùÿ{óøïÐÿ­É^¨+ytimeSeries/R/0000755000176000001440000000000012124051744012614 5ustar ripleyuserstimeSeries/R/zzz.R0000644000176000001440000000201612111077601013567 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ .onLoad <- function(libname, pkgname) { if(!is.numeric(getRmetricsOptions("max.print"))) setRmetricsOptions(max.print = 100) #-> show() of large matrices # YC: This should really go in methods package. keep it here for # the time being. (R -2.9.0) setOldClass("difftime") } ################################################################################ timeSeries/R/utils-structure.R0000644000176000001440000000473711560011674016151 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # str,timeSeries Displays the structure of a 'timeSeries' object ################################################################################ .str.timeSeries <- function(object, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Displays the structure of a 'timeSeries' object. # Arguments: # object - an object of class 'timeSeries'. # ... - # FUNCTION: # Series Name: cat("Time Series: ") cat("\n Name: ", as.character(c(substitute(object)))) # YC : as.character(c( important to handle str(timeSeries()) # Data Matrix: Dim = dim(object) cat("\nData Matrix: ") cat("\n Dimension: ", Dim) cat("\n Column Names: ", colnames(object) ) firstName = rownames(object)[1] lastName = rownames(object)[Dim[1]] cat("\n Row Names: ", firstName, " ... ", lastName) # Date/Time Positions: cat("\nPositions: ") cat("\n Start: ", as.character(start(object))) cat("\n End: ", as.character(end(object))) # Other Attributes: cat("\nWith: ") cat("\n Format: ", object@format) cat("\n FinCenter: ", object@FinCenter) cat("\n Units: ", object@units) cat("\n Title: ", object@title) cat("\n Documentation: ", object@documentation) cat("\n") # Return Value: invisible() } setMethod("str", "timeSeries", function(object, ...) .str.timeSeries(object, ...)) # until UseMethod dispatches S4 methods in 'base' functions str.timeSeries <- function (object, ...) .str.timeSeries(object, ...) ################################################################################ timeSeries/R/utils-old2new.R0000644000176000001440000000524411560011674015455 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ .old2newTimeSeries <- function(x) { # Version 1: if ("Data" %in% slotNames(x)) { data <- x@Data charvec <- timeDate(x@positions, zone = x@FinCenter, FinCenter = x@FinCenter) units <- x@units recordIDs <- x@recordIDs title <- x@title documentation <- x@documentation x <- timeSeries(data = data, charvec = charvec, units = units, recordIDs = recordIDs, title = title, documentation = documentation) } # Version 2: if ((".Data" %in% slotNames(x)) && is.character(x@positions)) { data <- x@.Data charvec <- timeDate(x@positions, zone = x@FinCenter, FinCenter = x@FinCenter) units <- x@units recordIDs <- x@recordIDs title <- x@title documentation <- x@documentation x <- timeSeries(data = data, charvec = charvec, units = units, recordIDs = recordIDs, title = title, documentation = documentation) } x } # ------------------------------------------------------------------------------ ## # Example ## library(timeSeries) ## setwd("~/r/fPortfolio/data") ## rda <- dir() ## sapply(rda, .old2newRda, suffix = "") .old2newRda <- function(file, suffix = "_new") { stopifnot(length(file) == 1) local({ load(file) nm <- ls() lold <- mget(nm, envir = environment(NULL)) test <- sapply(lold, is.timeSeries) lold <- lold[test] lnew <- lapply(lold, .old2newTimeSeries) objects <- names(lold) for (nm in objects) assign(nm, lnew[[nm]]) newFile <- paste(file, suffix, sep = "") save(list = objects, file = newFile) }) invisible(TRUE) } ################################################################################ timeSeries/R/utils-head.R0000644000176000001440000000647111560011674015007 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # METHOD: SUBSETTING METHODS ON DATA: # head,timeSeries Returns the head of a 'timeSeries' object # tail,timeSeries Returns the tail of a 'timeSeries' object ################################################################################ .head.timeSeries <- function(x, n = 6, recordIDs = FALSE, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns the head of a 'timeSeries' object # Arguments: # x - a 'timeSeries' object. # n - a single integer. If positive, number of the first n records (rows) # to be returned. If negative, all but the n first number of # elements of x are returned. # recordIDs - a logical flag, should the record identification # be shown? By default FALSE. # ... - # Value: # Returns the tail of an object of class 'timeSeries'. # FUNCTION: # Head: if (recordIDs & dim(x)[1] == dim(x@recordIDs)[1]) cbind(head.matrix(x, n = n, ...), head(x@recordIDs, n = n, ...)) else head.matrix(x, n = n, ...) } setMethod("head", "timeSeries", function(x, n = 6, recordIDs = FALSE, ...) .head.timeSeries(x, n, recordIDs, ...)) # until UseMethod dispatches S4 methods in 'base' functions head.timeSeries <- function(x, ...) .head.timeSeries(x, ...) # ------------------------------------------------------------------------------ .tail.timeSeries <- function(x, n = 6, recordIDs = FALSE, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns the tail of a 'timeSeries' object # Arguments: # x - a 'timeSeries' object. # n - a single integer. If positive, number of the last n records (rows) # to be returned. If negative, all but the n last number of # elements of x are returned. # recordIDs - a logical flag, should the record identification # be shown? By default FALSE. # ... - # Value: # Returns the tail of an object of class 'timeSeries'. # FUNCTION: # Tail: if (recordIDs & dim(x)[1] == dim(x@recordIDs)[1]) cbind(tail.matrix(x, n = n, addrownums = FALSE, ...), tail(x@recordIDs, n = n, addrownums = FALSE, ...)) else tail.matrix(x, n = n, addrownums = FALSE, ...) } setMethod("tail", "timeSeries", function(x, n = 6, recordIDs = FALSE, ...) .tail.timeSeries(x, n, recordIDs, ...)) # until UseMethod dispatches S4 methods in 'base' functions tail.timeSeries <- function(x, ...) .tail.timeSeries(x, ...) ################################################################################ timeSeries/R/utils-description.R0000644000176000001440000000252711560011674016427 0ustar ripleyusers # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received A copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ # FUNCTION: DESCRIPTION: # description Creates default description string ################################################################################ description <- function() { # A function implemented by Diethelm Wuertz # Description: # Sets default description string: # FUNCTION: # Get Description String: ans <- paste(as.character(date()), "by user:", Sys.getenv("USERNAME")) # Return Value: ans } ################################################################################ timeSeries/R/timeSeries.R0000644000176000001440000002535211656243252015065 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # .signalSeries Creates a signal series from scratch # .timeSeries Creates a time series from scratch # METHODS: # timeSeries,ANY,ANY # timeSeries,matrix,missing # timeSeries,matrix,timeDate # timeSeries,matrix,numeric # timeSeries,matrix,ANY ################################################################################ ## .signalSeries : generate units, title, documentation if NULL ## data must be a matrix .signalSeries <- function(data, charvec, units = NULL, format, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { # Description: # Arguments: # Note: # it is possible that a ts object is considered as a # matrix when timeSeries method as dispatched. Hence this check # FUNCTION: if (!is(data, "matrix")) data <- as(data, "matrix") # Add units, title and Documentation: if (is.null(units)) units <- colnames(data) if (is.null(units)) units <- paste("SS.", seq.int(dim(data)[2]), sep = "") if (is.null(title)) title = "Signal Series Object" if (is.null(documentation)) documentation = as.character(date()) # remove rownames of data but keep colnames for # functions like var, cov ... # Note that if it fails, new("timeSeries" should fail to - normal try(dimnames(data) <- list(NULL, units), silent = TRUE) ### new("signalSeries", ### .Data = data, ### units = units, ### recordIDs = recordIDs, ### title = title, ### documentation = documentation) new("timeSeries", .Data = data, units = units, positions = numeric(0), FinCenter = "", format = "counts", recordIDs = recordIDs, title = title, documentation = documentation) } # ------------------------------------------------------------------------------ ## .timeSeries : generate units, title, documentation if NULL ## data must be a matrix and charvec a timeDate object .timeSeries <- function(data, charvec, units = NULL, format, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { # Description: # Arguments: # Note: # it is possible that a ts object is considered as a # matrix when timeSeries method as dispatched. Hence this check # FUNCTION: if (!is(data, "matrix")) data <- as(data, "matrix") stopifnot(is(charvec, "numeric")) # Add units, title and Documentation: if (is.null(units)) units <- colnames(data) if (is.null(units)) units <- paste("TS.", seq.int(dim(data)[2]), sep = "") if (is.null(title)) title = "Time Series Object" if (is.null(documentation)) documentation = as.character(date()) if (missing(format)) format <- "%Y-%m-%d" if (identical("", FinCenter)) FinCenter <- "GMT" # remove rownames of data but keep colnames for # functions like var, cov ... # Note that if it fails, new("timeSeries" should fail to - normal try(dimnames(data) <- list(NULL, units), silent = TRUE) positions <- charvec # as.numeric(charvec, "sec") attributes(positions) <- NULL new("timeSeries", .Data = data, positions = positions, units = units, format = format, # charvec@format, FinCenter = FinCenter, # charvec@FinCenter, recordIDs = recordIDs, title = title, documentation = documentation) } # ------------------------------------------------------------------------------ ## missing ANY setMethod("timeSeries", signature(data = "missing", charvec = "ANY"), function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { .signalSeries(data = matrix(NA), units = units, recordIDs = recordIDs, title = title, documentation = documentation, ...) }) # ------------------------------------------------------------------------------ ## missing missing setMethod("timeSeries", signature(data = "missing", charvec = "missing"), function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { .signalSeries(data = matrix(NA), units = units, recordIDs = recordIDs, title = title, documentation = documentation, ...) }) # ------------------------------------------------------------------------------ ## ANY ANY setMethod("timeSeries", signature(data = "ANY", charvec = "ANY"), function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { data <- as(data, "matrix") if (!is(data, "matrix")) stop("Could not coerce 'data' to a matrix") callGeneric(data = data, charvec = charvec, units = units, format = format, zone = zone, FinCenter = FinCenter, recordIDs = recordIDs, title = title, documentation = documentation, ...) }) # ------------------------------------------------------------------------------ ## ANY missing setMethod("timeSeries", signature(data = "ANY", charvec = "missing"), function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { data <- as(data, "matrix") if (!is(data, "matrix")) stop("Could not coerce 'data' to a matrix") callGeneric(data = data, units = units, format = format, zone = zone, FinCenter = FinCenter, recordIDs = recordIDs, title = title, documentation = documentation, ...) }) # ------------------------------------------------------------------------------ ## matrix missing setMethod("timeSeries", signature(data = "matrix", charvec = "missing"), function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { charvec <- rownames(data) if (is.null(charvec)) { .signalSeries(data = data, units = units, recordIDs = recordIDs, title = title, documentation = documentation, ...) } else { callGeneric(data = data, charvec = charvec, units = units, format = format, zone = zone, FinCenter = FinCenter, recordIDs = recordIDs, title = title, documentation = documentation, ...) } } ) # ------------------------------------------------------------------------------ ## matrix timeDate setMethod("timeSeries", signature(data = "matrix", charvec = "timeDate"), function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { if (any(is.na(charvec))) return(.signalSeries(data = data, units = units, recordIDs = recordIDs, title = title, documentation = documentation, ...)) if (any(!c(zone, FinCenter) %in% "")) charvec <- timeDate(charvec, format = format, zone = zone, FinCenter = FinCenter) .timeSeries(data = data, charvec = as.numeric(charvec, "sec"), units = units, format = charvec@format, FinCenter = charvec@FinCenter, recordIDs = recordIDs, title = title, documentation = documentation, ...) } ) # ------------------------------------------------------------------------------ ## matrix numeric setMethod("timeSeries", signature(data = "matrix", charvec = "numeric"), function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { if (any(!c(zone, FinCenter) %in% "")) { td <- timeDate(charvec, zone = zone, FinCenter = FinCenter) charvec <- as.numeric(td, "sec") FinCenter <- finCenter(td) } .timeSeries(data = data, charvec = charvec, units = units, FinCenter = FinCenter, recordIDs = recordIDs, title = title, documentation = documentation, ...) } ) # ------------------------------------------------------------------------------ ## matrix ANY setMethod("timeSeries", signature(data = "matrix", charvec = "ANY"), function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) { # if charvec NULL returns a signal series if (is.null(charvec)) return(.signalSeries(data = data, units = units, recordIDs = recordIDs, title = title, documentation = documentation, ...)) # coerce charvec to timeDate charvec <- timeDate(charvec = charvec, format = format, zone = zone, FinCenter = FinCenter) if (any(is.na(charvec))) # Note : there is already a warning in timeDate if there are NA's .signalSeries(data = data, units = units, recordIDs = recordIDs, title = title, documentation = documentation, ...) else .timeSeries(data = data, charvec = as.numeric(charvec, "sec"), units = units, format = charvec@format, FinCenter = charvec@FinCenter, recordIDs = recordIDs, title = title, documentation = documentation, ...) } ) ################################################################################ timeSeries/R/timeSeries-slotUnits.R0000644000176000001440000000316311560011674017056 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # getUnits Get units slot from a 'timeSeries' # setUnits<- Set new units slot to a 'timeSeries' ################################################################################ getUnits <- function(x) { # Description: # Get units slot from a 'timeSeries' object. # Arguments: # x - a 'timeSeries' object # FUNCTION: # Return Value: colnames(x) } # ------------------------------------------------------------------------------ "setUnits<-" <- function(x, value) { # Description: # Set units slot to a 'timeSeries' object. # Arguments: # x - a 'timeSeries' object # FUNCTION: # Assign Time Slot: colnames(x) <- value # Return Value: x } ################################################################################ timeSeries/R/timeSeries-slotTime.R0000644000176000001440000001040411560011674016646 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # time,timeSeries Extracs time positions from a 'timeSeries' # time<- Defines S3 UseMethod # time<-.timeSeries ... to avoid problems with zoo # FUNCTION: DESCRIPTION: # getTime Get time slot from a 'timeSeries' # setTime<- Set new time slot to a 'timeSeries' # DEPRECATED: DESCRIPTION: # seriesPositions Deprecated, use time # newPositions<- Deprecated, use time<- ################################################################################ .time.timeSeries <- function(x, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Extracs time positions from a 'timeSeries' # Arguments: # x - a 'timeSeries' object. # Value: # Returns a time resampled object of class 'timeSeries'. # FUNCTION: if (length(x@positions)>0) timeDate(x@positions, zone = "GMT", FinCenter = x@FinCenter) else seq.int(NROW(x)) } setMethod("time", "timeSeries", function(x, ...) .time.timeSeries(x, ...)) # until UseMethod dispatches S4 methods in 'base' functions time.timeSeries <- function(x, ...) .time.timeSeries(x, ...) # ------------------------------------------------------------------------------ `time<-` <- function(x, value) { UseMethod("time<-") } # ------------------------------------------------------------------------------ `time<-.timeSeries` <- function(x, value) { # A function implemented by Yohan Chalabi # Note: # To avoid conflict with zoo package. # FUNCTION: # Assign Rownames: rownames(x) <- value # Return Value: x } # ------------------------------------------------------------------------------ # setMethod("time<-", "timeSeries", function(x, value) # { # rownames(x) <- value # # Return # x # }) ############################################################################### getTime <- function(x) { # Description: # Get time slot from a 'timeSeries' object. # Arguments: # x - a 'timeSeries' object # FUNCTION: # Return Value: time(x) } # ------------------------------------------------------------------------------ "setTime<-" <- function(x, value) { # Description: # Set time slot to a 'timeSeries' object. # Arguments: # x - a 'timeSeries' object # FUNCTION: # Assign Time Slot: time(x) <- value # Return Value: x } ############################################################################### seriesPositions <- function(object) { # A function implemented by Diethelm Wuertz # Description: # Extracts the positions of a 'timeSeries' objects and # converts them to a 'timeDate' object. # Arguments: # object - a 'timeSeries' object # Value: # Returns 'timeSeries' positions as 'timeDate' objects. # FUNCTION: # Deprecated: .Deprecated(new = "time", package = "timeSeries") # Return Value: time(object) } # ------------------------------------------------------------------------------ "newPositions<-" <- function(object, value) { # A function implemented by Diethelm Wuertz # FUNCTION: # Deprecated: .Deprecated(new = "time<-", package = "timeSeries") # Assign Rownames: rownames(object) <- value # Return Value: object } ################################################################################ timeSeries/R/timeSeries-slotSeries.R0000644000176000001440000001356511732173216017217 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # series,timeSeries Get data slot from a'timeSeries' # series<-,timeSeries,ANY Set new data slot to a 'timeSeries' # series<-,timeSeries,matrix Set new data slot to a 'timeSeries' # FUNCTION: DESCRIPTION: # getSeries # getSeries.default # getSeries.timeSeries Get data slot from a 'timeSeries' # setSeries<- Set new data slot to a 'timeSeries' # DEPRECATED: DESCRIPTION: # seriesData Deprecated, use series ################################################################################ setMethod("series", "timeSeries", function(x) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Returns the series Data of an ordered data object. # Arguments: # x - a 'timeSeries' object # Value: # Returns an object of class 'matrix'. # FUNCTION: # Get Data Slot: ans <- as.matrix(x) # Return Value: ans } ) # ------------------------------------------------------------------------------ setMethod("series<-", signature(x = "timeSeries", value = "ANY"), function(x, value) { # A function implemented by Yohan Chalabi # Return Value: callGeneric(x, as(value, "matrix")) } ) # ------------------------------------------------------------------------------ setMethod("series<-", signature(x = "timeSeries", value = "matrix"), function(x, value) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Assign the series Data to a timeSeries object. # Arguments: # object - a 'timeSeries' object # Value: # Assign to be assign as series Data of a timeSeries. # FUNCTION: # if value same dimension as time series # we we can assign the value directly to @.Data # This can speed up math Ops significantly if (identical(dim(x), dim(value))) { x@.Data <- value if (!is.null(cn <- colnames(value))) colnames(x) <- cn return(x) } if (is.null(charvec <- rownames(value))) charvec <- rownames(x) if (is.null(units <- colnames(value))) units <- colnames(value) # now that we have charvec and units, better to remove # dimnames of value to avoid problems attr(value, "dimnames") <- NULL if (!identical(length(units), NCOL(value))) units <- NULL # if now same dim , drop charvec and returns .signalSeries if (!identical(length(charvec), NROW(value))) return(.signalSeries(value, units)) format <- x@format zone <- FinCenter <- finCenter(x) title <- x@title documentation <- x@documentation recordIDs <- if (identical(NROW(x), NROW(value))) x@recordIDs else data.frame() # Return Value: timeSeries(data = value, charvec = charvec, units = units, format = format, zone = zone, FinCenter = FinCenter, recordIDs = recordIDs, title = title) } ) ################################################################################ ## getSeries <- ## function(x) ## { ## # A function implemented by Diethelm Wuertz ## ## # Note: ## # Used for getSeries methods in fPortfolio package. ## ## # FUNCTION: ## ## # Return Value: ## UseMethod("getSeries") ## } # ------------------------------------------------------------------------------ ## getSeries.default <- ## function(x) ## { ## # Description: ## # Get data slot from a 'timeSeries' object ## ## # Arguments: ## # x - a 'timeSeries' object ## ## # FUNCTION: ## ## # Return Value: ## series(x) ## } # ------------------------------------------------------------------------------ ## getSeries.timeSeries <- ## function(x) ## { ## # Description: ## # Get data slot from a 'timeSeries' object ## ## # Arguments: ## # x - a 'timeSeries' object ## ## # FUNCTION: ## ## # Return Value: ## series(x) ## } # ------------------------------------------------------------------------------ ## "setSeries<-" <- ## function(x, value) ## { ## # Description: ## # Set data slot to a 'timeSeries' object ## ## # Arguments: ## # x - a 'timeSeries' object ## ## # FUNCTION: ## ## # Assign Series Slot: ## series(x) <- value ## ## # Return Value: ## x ## } ################################################################################ seriesData <- function(object) { # A function implemented by Diethelm Wuertz # Description: # Returns the series Data of an ordered data object. # Arguments: # object - a 'timeSeries' object # Value: # Returns an object of class 'matrix'. # FUNCTION: # Test: if (class(object) != "timeSeries") stop("Object is not a time Series") # Deprecated .Deprecated(new = "series", package = "timeSeries") # Get Data Slot: ans <- as.matrix(object) # Return Value: ans } ################################################################################ timeSeries/R/timeSeries-slotFinCenter.R0000644000176000001440000000610711560011674017632 0ustar ripleyusers # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # finCenter,timeSeries Get financial center slot from a 'timeSeries' # finCenter<-,timeSeries Set financial center slot from a 'timeSeries' # FUNCTION: DESCRIPTION: # getFinCenter Get financial center slot from a 'timeSeries' # setFinCenter<- Set new financial center slot from a 'timeSeries' ################################################################################ setMethod("finCenter", "timeSeries", function(x) { # A function implemented by Yohan Chalabi and Diethelm Wuertz # Description: # Get financial center slot from a 'timeSeries' object # Arguments: # x - an object of class 'timeSeries' # FUNCTION: # Extract financial center: ans <- x@FinCenter # Return Value: ans }) # ------------------------------------------------------------------------------ setMethod("finCenter<-", "timeSeries", function(x, value) { # A function implemented by Yohan Chalabi and Diethelm Wuertz # Description: # Set financial center slot from a 'timeSeries' object # Arguments: # x - an object of class 'timeSeries' # value - a character string, setting the name of the financial # center. # FUNCTION: # Check: if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Convert to user financial centre: positions <- timeDate(charvec = time(x), zone = finCenter(x), FinCenter = value) # Assign Positions to Time Stamps: time(x) <- positions # Return Value: x }) ################################################################################ getFinCenter <- function(x) { # Description: # Get financial center slot from a 'timeSeries' object # Arguments: # x - a 'timeSeries' object # FUNCTION: # Return Value: finCenter(x) } # ------------------------------------------------------------------------------ "setFinCenter<-" <- function(x, value) { # Description: # Set new financial center slot from a 'timeSeries' object # FUNCTION: # Arguments: # x - a 'timeSeries' object # Assign Financial Center Slot: finCenter(x) <- value # Return Value: x } ################################################################################ timeSeries/R/timeSeries-signalCounts.R0000644000176000001440000000267611560011674017533 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # .signalCounts Creates charvec for integer indexed time stamps ################################################################################ .signalCounts <- function(int) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Descriptions: # Creates the charvec for integer indexed time stamps # Arguments: # int - a vector of integers, the counts. # FUNCTION: # Check that int is an integer # ... # Check that all int's are positive ... # ... # Format: cint <- as.character(int) ans <- format(cint, width = max(nchar(cint)), justify = "right") # Return Value: ans } ################################################################################ timeSeries/R/timeSeries-readSeries.R0000644000176000001440000000765511560011674017152 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # readSeries Reads a CSV file and creates a 'timeSeries' ################################################################################ # DW: # I think we should add a similar function for writeSeries() using # write.table(). Proceed in the same way as in the case of the read # function. # ------------------------------------------------------------------------------ readSeries <- function(file, header = TRUE, sep = ";", zone = "", FinCenter = "", format, ...) { # A function implemented by Diethelm Wuertz # Description: # Reads from a spreadsheet and creates a 'timeSeries' object # Arguments: # file - the name of the file which the data are to be read # from. Each row of the table appears as one line of the # file. If it does not contain an absolute path, the file # name is relative to the current working directory, # getwd(). Tilde-expansion is performed where supported. # As from R 2.10.0 this can be a compressed file. # header - a logical value indicating whether the file contains # the names of the variables as its first line. If missing, # the value is determined from the file format: header is # set to TRUE if and only if the first row contains one fewer # field than the number of columns. # sep - he field separator character. Values on each line of # the file are separated by this character. If sep = "" (the # default for read.table) the separator is ‘white space’, # that is one or more spaces, tabs, newlines or carriage # returns. # zone - the time zone or financial center where the data were # recorded. # FinCenter - a character with the the location of the # financial center named as "continent/city". By default # an empty string which means that internally "GMT" will # be used. # format - the format of the timestamps as recoreded in the # first column of the data in the.. # ... - optional arguments passed to the function read.table(). # Value: # Returns a S4 object of class 'timeSeries'. # Notes: # Note we expect that the header of the spreadsheet file in # the first cell holds the time/date format specification! # FUNCTION: # Read Data: df <- read.table(file = file, header = header, sep = sep, check.names = FALSE, ...) # get timeDate from first column with header specifying the format charvec <- as.character(df[[1]]) if (missing(format)) format <- names(df)[1] td <- timeDate(charvec = charvec, format = format, zone = zone, FinCenter = FinCenter) # if format provided in file or with format argument, try to guess it if (all(is.na(td))) warning("Conversion of timestamps to timeDate objects produced only NAs. Are you sure you provided the proper format with argument 'format' or in the header of your file ?") # extract data data <- as.matrix(df[-1]) # Create Time Series from Data Frame: ans <- timeSeries(data = data, charvec = td) # Return Value: ans } ################################################################################ timeSeries/R/timeSeries-isUnivariate.R0000644000176000001440000000314011560011674017510 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # isUnivariate Tests if a 'timeSeries' object is univariate # isMultivariate Tests if a 'timeSeries' object is multivariate ################################################################################ isUnivariate <- function(x) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Tests if a time series or rectangular object is univariate # FUNCTION: # Return Value: if (NCOL(x) == 1) TRUE else FALSE } # ------------------------------------------------------------------------------ isMultivariate <- function(x) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Tests if a time series or rectangular object is multivariate # FUNCTION: # Return Value: if (NCOL(x) > 1) TRUE else FALSE } ################################################################################ timeSeries/R/timeSeries-isRegular.R0000644000176000001440000000336511560011674017013 0ustar ripleyusers # This R package is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # This R package is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this R package; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA ################################################################################ # FUNCTION: DESCRIPTION: # isDaily,timeSeries-method Tests if a time series is a daily series # isMonthly,timeSeries-method Tests if a time series is a monthly series # isQuarterly,timeSeries-method Tests if a time series is a quarterly series # isRegular,timeSeries-method Tests if a time series is a regular series # frequency,timeSeries-method Returns the frequency of a regular time series ################################################################################ setMethod("isDaily", "timeSeries", function(x) callGeneric(time(x))) setMethod("isQuarterly", "timeSeries", function(x) callGeneric(time(x))) setMethod("isMonthly", "timeSeries", function(x) callGeneric(time(x))) setMethod("isRegular", "timeSeries", function(x) callGeneric(time(x))) setMethod("frequency", "timeSeries", function(x, ...) callGeneric(time(x), ...)) ################################################################################ timeSeries/R/timeSeries-isOHLC.R0000644000176000001440000000432711560011674016136 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # .isOHLC Is the series an Open-High-Low-Close series? # .isOHLCV Is the series an Open-High-Low-Close-Volume series? ################################################################################ # DW: # I think we need a better method to detect if a series is a OHLC(V) series # or not. A possible approach would be: # any High >= Open, Close, Low # any Low <= Open, Close, High # Volume >= 0 # number of columns 4(5) # ----------------------------------------------------------------------------- .isOHLC <- function(object) { # A function implemented by Diethelm Wuertz # Description: # Is the series an Open-High-Low-Close series? # Arguments: # object - an object of class 'timeSeries' # FUNCTION: colNames <- c("Open", "High", "Low", "Close") if (colnames(object)[1:4] == colNames) { return(TRUE) } else { return(FALSE) } } # ------------------------------------------------------------------------------ .isOHLCV <- function(object) { # A function implemented by Diethelm Wuertz # Description: # Is the series an Open-High-Low-Close-Volume series? # Arguments: # object - an object of class 'timeSeries' # FUNCTION: colNames <- c("Open", "High", "Low", "Close", "Volume") if (colnames(object) == colNames) { return(TRUE) } else { return(FALSE) } } ################################################################################ timeSeries/R/timeSeries-getDataPart.R0000644000176000001440000000527711560011674017262 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # S4 METHODS: DESCRIPTION: # getDataPart,timeSeries Get data slot of an object of class 'timeSeries' # setDataPart,timeSeries Set data slot of an object of class 'timeSeries' ################################################################################ # YC: # This makes getDataPart a bit faster than default function setMethod("getDataPart", "timeSeries", #"signalSeries", function(object) { value <- object attributes(value) <- NULL attr(value, "dim") <- attr(object, "dim") attr(value, "dimnames") <- attr(object, "dimnames") value } ) # ------------------------------------------------------------------------------ # YC: # This makes setDataPart a bit faster than default function if (getRversion() < "2.8.0") { setMethod("setDataPart", "timeSeries", function(object, value) { #-> Note : do not use as.matrix because ts objects might #-> not be coerced properly value <- as(value, "matrix") supplied <- attributes(object) valueAttrs <- attributes(value) supplied[names(valueAttrs)] <- valueAttrs # YC: force @unit to be identical to colnames(value) supplied[["units"]] <- colnames(value) attributes(value) <- supplied asS4(value, TRUE) } ) } else { setMethod("setDataPart", "timeSeries", function(object, value, check = TRUE) { #-> Note : do not use as.matrix because ts objects might #-> not be coerced properly if (check) value <- as(value, "matrix") supplied <- attributes(object) valueAttrs <- attributes(value) supplied[names(valueAttrs)] <- valueAttrs # YC: force @unit to be identical to colnames(value) supplied[["units"]] <- colnames(value) attributes(value) <- supplied asS4(value, TRUE) } ) } ################################################################################ timeSeries/R/timeSeries-dummy.R0000644000176000001440000000511411560011674016203 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # dummySeries Creates a dummy monthly 'timeSeries' object # dummyDailySeries Creates a dummy daily 'timeSeries' object ################################################################################ # DW: # A more natural name for the function dummySeries() would be # dummyMonthlySeries() to have the same naming conventions like in the # case of the dummy daily series. dummySeries <- function(...) { # A function implemented by Diethelm Wuertz # Description: # Creates a monthly dummy 'time Series' object # Arguments: # ... - optional arguments passed to the function timeSeries(). # FUnction: # Return Value: timeSeries(matrix(runif(24), ncol = 2), as.character(timeCalendar()), ...) } # ------------------------------------------------------------------------------ dummyDailySeries <- function(x = rnorm(365), units = NULL, zone = "", FinCenter = "") { # A function implemented by Diethelm Wuertz # Description: # Creates a dummy daily time Series # Arguments: # x - a numeric vector # origin - the first date in the series # FUNCTION: if (zone == "") zone <- getRmetricsOptions("myFinCenter") if (FinCenter == "") FinCenter <- getRmetricsOptions("myFinCenter") # Check: stopifnot(is.numeric(x)) if (is.null(units)) units <- paste("X", 1:NCOL(x), sep = "") stopifnot(length(units) == NCOL(x)) # Time Series: if (is.vector(x)) data = matrix(x, ncol = 1) if (is.matrix(x)) data = x positions <- timeSequence(from = "1970-01-01", length.out = NROW(data), zone = zone, FinCenter = FinCenter) ans <- timeSeries(data = data, charvec = positions, units = units, zone = zone, FinCenter = FinCenter) # Return Value: ans } ################################################################################ timeSeries/R/stats-window.R0000644000176000001440000000702411560011674015406 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # window,timeSeries Extracts a piece from a 'timeSeries' object # DEPRECATED: DESCRIPTION: # cut,timeSeries Extracsts a piece from a 'timeSeries' object ################################################################################ .window.timeSeries <- function(x, start, end, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Windows a piece from a 'timeSeries' object. # Arguments: # x - a 'timeSeries' object # from, to - two 'timeDate' position vectors which size the # blocks # Details: # from and to, are both included in the window. # Value: # Returns a S4 object of class 'timeSeries'. # FUNCTION: stopifnot(is.timeSeries(x)) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # check if all argument names are used if (length(dot <- list(...))) { if (any(names(dot) %in% c("from", "to"))) { if (!is.null(from <- dot$from)) start <- from if (!is.null(to <- dot$to)) end <- to warning("Arguments 'from/to' are deprecated.\nUse instead 'start/end'.", call. = FALSE) } } start <- timeDate(start) end <- timeDate(end) Positions <- time(x) test <- (Positions >= start & Positions <= end) # Return value: x[test,] } setMethod("window", "timeSeries", function(x, start, end, ...) .window.timeSeries(x, start, end, ...)) # until UseMethod dispatches S4 methods in 'base' functions window.timeSeries <- function(x, ...) .window.timeSeries(x, ...) ############################################################################### .cut.timeSeries <- function (x, from, to, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Cuts out a piece from a 'timeSeries' object. # Arguments: # x - a 'timeSeries' object # from, to - two 'timeDate' position vectors which size the # blocks # Value: # Returns a S4 object of class 'timeSeries'. # FUNCTION: # .Deprecated("window", "timeSeries") stopifnot(is.timeSeries(x)) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") from = timeDate(from) to = timeDate(to) Positions = time(x) test = (Positions >= from & Positions <= to) ans <- x[test,] # Return value: ans } setMethod("cut", "timeSeries", function (x, from, to, ...) .cut.timeSeries(x, from, to, ...)) # until UseMethod dispatches S4 methods in 'base' functions cut.timeSeries <- function(x, ...) .cut.timeSeries(x, ...) ################################################################################ timeSeries/R/stats-na.omit.R0000644000176000001440000002235411560011674015447 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # na.omit,timeSeries Handles missing values in objects # .naOmitMatrix Internal function called from na.omit,timeSeries # OLD FUNCTIONS: DESCRIPTION: # removeNA Remove NAs from a matrix object # substituteNA Substitute NAs by zero, the column mean or median # interpNA Interpolate NAs using R's "approx" function ################################################################################ # DW: # I think we should deprecate the following functions: # removeNA, substituteNA, and interpNa since the function # na.omit() can already handle all these cases. # DW: # note we do interpolation with approx(), zoo also offers # interpolation by splines, we should also add this. ################################################################################ .na.omit.timeSeries <- function(object, method = c("r", "s", "z", "ir", "iz", "ie"), interp = c("before", "linear", "after"), ...) { # Description # Handles NAs in timeSeries objects # Detials: # Linear Interpolation is done by the function approx. # Spline interpolation like in zoo is not yet supported. # Arguments: # object - an object of class timeSeries # method - # interp - # ... - # FUNCTION: # Check Arguments: method <- match.arg(method) interp <- match.arg(interp) # Skip ? if (method == "s") return(object) # Handle NAs: if (method == "r") { # Remove NAs: object <- stats:::na.omit.default(object) } else if (method == "z") { # Substitute NAs by Zero's: object[is.na(object)] <- 0 } else if (substr(method, 1, 1) == "i") { # Interpolate: interp = match.arg(interp) f = 0 if (interp == "before") { interp = "constant" f = 0 } if (interp == "after") { interp = "constant" f = 1 } n = nrow(object) for (i in 1:ncol(object)) { y = object[, i] idy = (1:n)[!is.na(y)] ## DW: ... added # Linear/Constant Interpolation: y = approx(x = idy, y = y[idy], xout = 1:n, method = interp, f = f, ...)$y object[, i] = y } modID = FALSE if (method == "ir") { # Remove Start and End NAs: object = stats:::na.omit.default(object) } else if (method == "iz") { # Set Start and End NAs to Zero: object[is.na(object)] = 0 } else if (method == "ie") { n = nrow(object) for (k in 1:ncol(object)) { y = object[, k] if (NA %in% y) { start = sum(cumprod(is.na(y))) if (start > 0) for (i in start:1) y[i] = y[i+1] end = n+1 - sum(cumprod(rev(is.na(y)))) if (end <= n) for (i in end:n) y[i] = y[i-1] object[, k] = y } } } } # Handle recordIDs ... recordIDs <- object@recordIDs modID <- c(r = TRUE, z = FALSE, ir = TRUE, iz = FALSE, ie = FALSE) if(modID[method] > 0 && sum(dim(recordIDs)) > 0 ) { index <- attr(object, "n.action") recordIDs <- recordIDs[index, ] } # Return Value: object } setMethod("na.omit", "timeSeries", function(object, method = c("r", "s", "z", "ir", "iz", "ie"), interp = c("before", "linear", "after"), ...) .na.omit.timeSeries(object, method, interp, ...)) # until UseMethod dispatches S4 methods in 'base' functions na.omit.timeSeries <- function(object, ...) .na.omit.timeSeries(object, ...) # ------------------------------------------------------------------------------ .naOmitMatrix <- function(object, method = c("r", "s", "z", "ir", "iz", "ie"), interp = c("before", "linear", "after")) { # Description: # Internal Function called from na.omit.timSeries() # Arguments: # FUNCTION: # Extract matrix: x = object stopifnot (is.matrix(x)) # Match Arguments: method = match.arg(method) interp = match.arg(interp) # Handle NAs: if (method == "r") { # Remove NAs: x = na.omit(x) } else if (method == "z") { # Substitute NAs by Zero's: x[is.na(x)] = 0 } else if (substr(method, 1, 1) == "i") { # Interpolate: interp = match.arg(interp) f = 0 if (interp == "before") { interp = "constant" f = 0 } if (interp == "after") { interp = "constant" f = 1 } n = nrow(x) for (i in 1:ncol(x)) { y = x[, i] idy = (1:n)[!is.na(y)] y = approx(idy, y[idy], 1:n, method = interp, f = f)$y x[, i] = y } modID = FALSE if (method == "ir") { # Remove Start and End NAs: x = na.omit(x) } else if (method == "iz") { # Set Start and End NAs to Zero: x[is.na(x)] = 0 } else if (method == "ie") { n = nrow(x) for (k in 1:ncol(x)) { y = x[, k] if (NA %in% y) { start = sum(cumprod(is.na(y))) if (start > 0) for (i in start:1) y[i] = y[i+1] end = n+1 - sum(cumprod(rev(is.na(y)))) if (end <= n) for (i in end:n) y[i] = y[i-1] x[, k] = y } } } } # Add Control: if (substr(method, 1, 1) == "i") { attr(x, "control") = c(method = method, interp = interp) } else { attr(x, "control") = c(method = method) } # Return Value: x } ################################################################################ removeNA <- function (x, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Remove NA's from objects which can be transformed to a matrix # Arguments: # x - an object which can be transformed to a matrix # FUNCTION: na.omit(x, ...) } # ------------------------------------------------------------------------------ substituteNA <- function(x, type = c("zeros", "mean", "median"), ...) { # A function implemented by Diethelm Wuertz # Description: # Imputes missing data by zeros, the median or the # mean values of all matrix elements # Arguments: # x - an object which can be transformed to a matrix # type - method specifies the substitution method to be # used. Choices are "zeros", "mean", or "constant" # FUNCTION: if (!inherits(x, "matrix") && !inherits(x, "timeSeries")) x <- as(x, "matrix") # Type: type <- match.arg(type) ans <- switch(type, "zeros" = apply(x, 2, function(z) { z[is.na(z)] <- 0 z}), "median" = apply(x, 2, function(z) { z[is.na(z)] = median(z, na.rm = TRUE) z}), "mean" = apply(x, 2, function(z) { z[is.na(z)] = mean(z, na.rm = TRUE) z})) # Return Value: ans } # ------------------------------------------------------------------------------ interpNA <- function(x, method = c("linear", "before", "after"), ...) { # A function implemented by Diethelm Wuertz # Description: # Interpolates missing values in a matrix object # Arguments: # x - a numeric vector or time series object of class 'ts'. # method - the method how to interpolate the vector, one of # the applied vector strings: "linear", "before" or # after. # Details: # To interpolate the function 'approx' is used. # Value: # Returns a vector or time series object where the missing # values are interpolated. # FUNCTION: if (!inherits(x, "matrix") && !inherits(x, "timeSeries")) x <- as(x, "matrix") # Internal Function: interpVectorNA <- function(x, method, f) { n <- length(x) idx <- (1:n)[!is.na(x)] x <- approx(idx, x[idx], 1:n, method = method, f = f)$y x} # Select Method: method = method[1]; f = 0 if (method == "before") { method = "constant" f = 0 } if (method == "after") { method = "constant" f = 1 } # For each Column: for (i in 1:ncol(x)) { x[, i] = interpVectorNA(x[, i], method, f) } # Return Value: x } ################################################################################ timeSeries/R/stats-na.contiguous.R0000644000176000001440000000360611560011674016675 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # na.contiguous,timeSeries Finds the longest consecutive of non-missing values ################################################################################ setMethod("na.contiguous", "timeSeries", function(object, ...) { # Description: # Finds the longest consecutive of non-missing values # Details: # adapted stats:::na.contingous.default to timeSeries objects # Yohan Chalabi # FUNCTION: good <- apply(!is.na(object), 1L, all) if (!sum(good)) stop("all times contain an NA") tt <- cumsum(!good) ln <- sapply(0:max(tt), function(i) sum(tt == i)) seg <- (seq_along(ln)[ln == max(ln)])[1L] - 1 keep <- (tt == seg) st <- min(which(keep)) if (!good[st]) st <- st + 1 en <- max(which(keep)) omit <- integer(0L) n <- NROW(object) if (st > 1) omit <- c(omit, 1L:(st - 1)) if (en < n) omit <- c(omit, (en + 1):n) if (length(omit)) { object <- object[st:en, ] attr(omit, "class") <- "omit" attr(object, "na.action") <- omit } # Return Value: object }) ################################################################################ timeSeries/R/stats-model.frame.R0000644000176000001440000000670411560011674016274 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # model.frame.default Allows to use model.frame for "timeSeries" ################################################################################ # YC : remove mode.frame because more problems than benefits. Rely on # default model.frame as long as as.data.frame.timeSeries works in # 'base' function model.frame.default ## setMethod("model.frame.default", signature(data = "timeSeries"), ## function(formula, data = NULL, ## subset = NULL, na.action = na.fail, ## drop.unused.levels = FALSE, xlev = NULL, ...) ## { ## # A function implemented by Diethelm Wuertz ## # Description: ## # Extracting the Environment of a Model Formula ## # Arguments: ## # formula - a model formula ## # data - a 'timeSeries' object ## # Details: ## # Allows to use model.frame() for "timeSeries" objects. ## # Examples: ## # x = as.timeSeries(data(msft.dat))[1:12, ] ## # model.frame( ~ High + Low, data = x) ## # model.frame(Open ~ High + log(Low), data = x) ## # FUNCTION: ## data <- as(data, "data.frame") ## ### model.frame.default(formula, data, ## ### subset, na.action, ## ### drop.unused.levels, ## ### xlev, ...) ## model.frame(formula, data, ...) ## }) ## ## ### # Create Model Frame: ## ## ### format <- data@format ## ## ### FinCenter <- finCenter(data) ## ## ### recordIDs <- data@recordIDs ## ## ### title <- data@title ## ## data <- as(data, "data.frame") ## ## Model <- model.frame(formula, data, ...) ## ## #-> should be in parent.frame? ## ## ### recordIDs <- ## ## ### if (NROW(Model) == NROW(recordIDs)) ## ## ### recordIDs ## ## ### else ## ## ### data.frame() ## ## ### # Convert to timeSeries: ## ## ### ans <- timeSeries(data = as.matrix(Model), ## ## ### charvec = rownames(Model), ## ## ### units = colnames(Model), ## ## ### format = format, ## ## ### FinCenter = FinCenter, ## ## ### recordIDs = recordIDs, ## ## ### title = title, ## ## ### documentation = description() ## ## ### ) ## ## ### # Return value: ## ## ### ans ## ## Model ## ## }) ################################################################################ timeSeries/R/stats-lag.R0000644000176000001440000000714311656243252014651 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # lag,timeSeries Lags a 'timeSeries' object ################################################################################ setMethod("lag" , "timeSeries", function(x, k = 1, trim = FALSE, units = NULL, ...) { # A function implemented by Diethelm Wuertz # Description: # Lags a 'timeSeries' object. # Arguments: # x - a 'timeSeries' object. # k - an integer indicating which lag to use. By default 1. # Note, negative lags are to data in the future. # trim - a logical. Should NAs at the beginning of the # series be removed? By default FALSE. # units - # ... - # Details: # The arguments differ in the following way from the function # stats::lag - lag(x, k = 1, ...) # Value: # Returns a lagged object of class 'timeSeries'. # Example: # SPI = 100* as.timeSeries(data(LPP2005REC))[1:20, "SPI"] # Note negative lags are to data in the future ! # lag(SPI, k = -2:2) # lag(SPI, k = 0:2 , trim = TRUE) # FUNCTION: # Internal Function: tslagMat <- function(x, k = 1) { # Internal Function: tslag1 = function(x, k) { y = x if (k > 0) y = c(rep(NA, times = k), x[1:(length(x)-k)]) if (k < 0) y = c(x[(-k+1):length(x)], rep(NA, times = -k)) y } # Bind: ans <- NULL for (i in k) { ans <- cbind(ans, tslag1(x, i)) } # As Vector: if (length(k) == 1) ans <- as.vector(ans) # Return Value: ans } # Convert: y <- getDataPart(x) Dim <- dim(y)[2] # Lag on each Column: z <- NULL for (i in 1:Dim) { ts <- tslagMat( y[, i], k = k) #, trim = FALSE) z <- cbind(z, ts) } # Positions pos <- x@positions # Record IDs: df <- x@recordIDs # Trim: if (trim){ idx <- !is.na(apply(z, 1, sum)) z <- z[idx, , drop = FALSE] pos <- pos[idx] if (sum(dim(df)) > 0) { df <- df[idx, , drop = FALSE] rownames(df) <- seq.int(sum(idx)) } } # Augment Colnames: cn <- colnames(x) a <- if (is.null(units)) # ensure that colnames is replicated according to the length # of lag indexes. as.vector(matrix(cn, nrow = length(k), ncol = length(cn), byrow = TRUE)) else units kcols <- rep(k, times = ncol(y)) b <- paste("[", kcols, "]", sep="") ab <- paste(a, b, sep = "") units <- ab # Return Value: timeSeries(data = z, charvec = pos, units = units, format = x@format, FinCenter = x@FinCenter, recordIDs = df, title = x@title, documentation = x@documentation) }) # until UseMethod dispatches S4 methods in 'base' functions lag.timeSeries <- function(x, ...) timeSeries::lag(x, ...) ################################################################################ timeSeries/R/stats-filter.R0000644000176000001440000000525611560011674015371 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # filter,timeSeries Applies linear filtering to a 'timeSeries' object ################################################################################ setMethod("filter", "timeSeries", function(x, filter, method = c("convolution", "recursive"), sides = 2, circular = FALSE, init = NULL) { # Description: # Applies linear filtering to a 'timeSeries' object # Arguments: # x - a univariate or multivariate time series. # filter - a vector of filter coefficients in reverse time order (as # for AR or MA coefficients). # method - Either "convolution" or "recursive" (and can be # abbreviated). If "convolution" a moving average is used: # if "recursive" an autoregression is used. # sides - for convolution filters only. If sides=1 the filter # coefficients are for past values only; if sides=2 they are # centred around lag 0. In this case the length of the filter # should be odd, but if it is even, more of the filter is # forward in time than backward. # circular - for convolution filters only. If TRUE, wrap the filter # around the ends of the series, otherwise assume external # values are missing (NA). # init - for recursive filters only. Specifies the initial values # of the time series just prior to the start value, in reverse # time order. The default is a set of zeros. # Value: # Returns a 'timeSeries' object. # FUNCTION: # Filter: ans <- filter(getDataPart(x), filter = filter, method = method, sides = sides, circular = circular, init = init) # -> Note : do not use as.matrix because ts objects might # -> not be coerced properly ans <- as(ans, "matrix") # Add Column Names: colnames(ans) <- colnames(x) # Return Value: setDataPart(x, ans) }) ################################################################################ timeSeries/R/stats-aggregate.R0000644000176000001440000000644211560011674016030 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # aggregate,timeSeries Aggregates a 'timeSeries' object ################################################################################ .aggregate.timeSeries <- function(x, by, FUN, ...) { # A function implemented by Yohan Chalabi and Diethelm Wuertz # Description: # Aggregates a 'timeSeries' object # Details: # This function can be used to aggregate and coursen a # 'timeSeries' object. # Arguments: # x - a 'timeSeries' object to be aggregated # by - a calendarical block # FUN - function to be applied, by default 'colMeans' # ... - additional argument to be passed to the newly generated # 'timeSeries' object # Value: # Returns a S4 object of class 'timeSeries'. # Examples: # Quarterly Aggregation: # m = matrix(rep(1:12,2), ncol = 2) # ts = timeSeries(m, timeCalendar()) # Y = getRmetricsOptions("currentYear"); Y # from = paste(Y, "04-01", sep = "-"); to = paste(Y+1, "01-01", sep = "-") # by = timeSequence(from, to, by = "quarter") - 24*3600; by # ts; aggregate(ts, by, sum) # Weekly Aggregation: # dates = timeSequence(from = "2009-01-01", to = "2009-02-01", by = "day") # data = 10 * round(matrix(rnorm(2*length(dates)), ncol = 2), 1); data # ts = timeSeries(data = data, charvec = dates) # by = timeSequence(from = "2009-01-08", to = "2009-02-01", by = "week") # by = by - 24*3600; aggregate(ts, by, sum) # FUNCTION: # Check Arguments: if (!((inherits(by, "timeDate") && x@format != "counts") || (is.numeric(by) && x@format == "counts"))) stop("'by' should be of the same class as 'time(x)'", call.=FALSE) # Make sure that x is sorted: if (is.unsorted(x)) x <- sort(x) # Sort and remove double entries in by: by <- unique(sort(by)) INDEX <- findInterval(x@positions, as.numeric(by, "sec") + 1) INDEX <- INDEX + 1 is.na(INDEX) <- !(INDEX <= length(by)) # YC : ncol important to avoid problems of dimension dropped by apply data <- matrix(apply(getDataPart(x), 2, tapply, INDEX, FUN), ncol=ncol(x)) rownames(data) <- as.character(by[unique(na.omit(INDEX))]) colnames(data) <- colnames(x) # Return Value: timeSeries(data, ...) } setMethod("aggregate", "timeSeries", function(x, by, FUN, ...) .aggregate.timeSeries(x, by, FUN, ...)) # until UseMethod dispatches S4 methods in 'base' functions aggregate.timeSeries <- function(x, ...) .aggregate.timeSeries(x, ...) ################################################################################ timeSeries/R/statistics-smoothLowess.R0000644000176000001440000001333111560011674017637 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # smoothSupsmu Smoothes a timeSeries with the supsmu function # smoothLowess Smoothes a timeSeries with the lowess function # smoothSpline Smoothes a timeSeries with the smooth.spline function # DEPRECATED: DESCRIPTION: # .supsmuSmoother Smoothes a timeSeries with the supsmu function # .lowessSmoother Smoothes a timeSeries with the lowess function # .splineSmoother Smoothes a timeSeries with the smooth.spline function ################################################################################ # DW: # These are older functions which have to be rewritten ... # The functions are thought to be used to smooth financial # price or index series. # ------------------------------------------------------------------------------ smoothSupsmu <- function(x, bass = 5, ...) { # A function implemented by Diethelm Wuertz # Description: # Smoothes a time series with the supsmu function # Arguments: # x - an univariate timeSeries object, e.g. a price or index series # bass - controls the smoothness of the fitted curve. Values of up # to 10 indicate increasing smoothness. # ... - further arguments passed to the function supsmu() # Example: # x = smoothSupsmu(MSFT[, 4], bass = 0.1); x; plot(x) # FUNCTION: # Settings: stopifnot(isUnivariate(x)) # Handle Missing Values: x <- na.omit(x) # Convert to Vector: X <- x x <- as.vector(x) # Smooth: ans <- stats::supsmu(x = 1:length(x), y = x, bass = bass, ... ) data <- cbind(x, ans$y) colnames(data) <- c(colnames(X), "supsmu") rownames(data) <- as.character(time(X)) series(X) <- data # Return Value: X } # ------------------------------------------------------------------------------ smoothLowess <- function(x, f = 0.5, ...) { # A function implemented by Diethelm Wuertz # Description: # Smoothes a time series with the lowess function # Arguments: # x - an univariate timeSeries object, e.g. a price or index series # f - the smoother span. This gives the proportion of points in the # plot which influence the smooth at each value. Larger values # give more smoothness. # ... - further arguments passed to the function lowess() # Example: # x = smoothLowess(MSFT[, 4], f = 0.05); x; plot(x) # FUNCTION: # Settings: stopifnot(isUnivariate(x)) # Handle Missing Values: x <- na.omit(x) # Convert to Vector: X <- x x <- as.vector(x) # Smooth: ans <- stats::lowess(x, f = f, ...)$y data <- cbind(x, ans) colnames(data) <- c(colnames(X), "lowess") rownames(data) <- as.character(time(X)) series(X) <- data # Return Value: X } # ------------------------------------------------------------------------------ smoothSpline <- function(x, spar = NULL, ...) { # A function implemented by Diethelm Wuertz # Description: # Smoothes a time series with the smooth.spline function # Arguments: # x - an univariate timeSeries object, e.g. a price or index series # f - the smoother span. This gives the proportion of points in the # plot which influence the smooth at each value. Larger values # give more smoothness. # ... - further arguments passed to the function smooth.spline() # Details: # smooth.spline(x, y = NULL, w = NULL, df, spar = NULL, cv = FALSE, # all.knots = FALSE, nknots = NULL, keep.data = TRUE, df.offset = 0, # penalty = 1, control.spar = list()) # Example: # x = smoothSpline(MSFT[, 4], spar = NULL); x; plot(x) # x = smoothSpline(MSFT[, 4], spar = 0.4); x; plot(x) # FUNCTION: # Settings: stopifnot(isUnivariate(x)) # Handle Missing Values: x <- na.omit(x) # Convert to Vector: X <- x x <- as.vector(x) # Smooth: ans <- stats::smooth.spline(x, spar = spar, ...)$y data <- cbind(x, ans) colnames(data) <- c(colnames(X), "spline") rownames(data) <- as.character(time(X)) series(X) <- data # Return Value: X } ################################################################################ .supsmuSmoother <- function(...) { # FUNCTION: # Deprecated: .Deprecated(".supsmuSmoother") # Return Value: smoothSupsmu(...) } # ------------------------------------------------------------------------------ .lowessSmoother <- function(...) { # FUNCTION: # Deprecated: .Deprecated(".lowessSmoother") # Return Value: smoothLowess(...) } # ------------------------------------------------------------------------------ .splineSmoother <- function(...) { # FUNCTION: # Deprecated: .Deprecated(".splineSmoother") # Return Value: smoothSpline(...) } ################################################################################ timeSeries/R/statistics-rowCumsums.R0000644000176000001440000000330011560011674017310 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # rowCumsums,ANY Computes cumulated sums by row # rowCumsums,timeSeries Computes cumulated sums by row for timeSeries ################################################################################ setMethod("rowCumsums", "ANY", function(x, na.rm = FALSE, ...) { # Transform: if (!inherits(x, 'matrix')) x <- as(x, "matrix") if (na.rm) x <- na.omit(x) ans <- apply(x, 1, cumsum, ...) # special treatment when x has one row because apply returns a vector if (NCOL(x) > 1) t(ans) else matrix(ans, ncol = 1, dimnames = dimnames(x)) }) # ------------------------------------------------------------------------------ setMethod("rowCumsums", "timeSeries", function(x, na.rm = FALSE, ...) setDataPart(x, callGeneric(getDataPart(x), na.rm = na.rm, ...))) ################################################################################ timeSeries/R/statistics-rollMean.R0000644000176000001440000003030712120613024016672 0ustar ripleyusers # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # rollStats Returns rolling statistics of a 'timeSeries' object # rollMean Returns rolling mean of a 'timeSeries' object # rollMin Returns rolling minimum of a 'timeSeries' object # rollMax Returns rolling maximum of a 'timeSeries' object # rolMedian Returns rolling median of a 'timeSeries' object # DEPRECATED: DESCRIPTION: # .rollmean.timeSeries Returns rolling mean of a 'timeSeries' object # .rollmin.timeSeries Returns rolling minimum of a 'timeSeries' object # .rollmax.timeSeries Returns rolling maximum of a 'timeSeries' object # .rolmedian.timeSeries Returns rolling median of a 'timeSeries' object ################################################################################ rollStats <- function(x, k, FUN=mean, na.pad=FALSE, align=c("center", "left", "right"), ...) { # Description: # Returns rolling statistics of a 'timeSeries' object # Arguments: # x - an object of class timeSeries # k - integer width of the rolling window. # FUN - statistical function to be rolled. # na.pad - a logical. Should NA padding be added at beginning? # align - character specifying whether result should be left- or # right-aligned or centered (default). # ... - furter arguments passed to function FUN. # Note: # Internal function are borrowed from package zoo ... # Example: # x <- timeSeries(matrix(sample(1:24), ncol = 2), timeCalendar()) # cbind(x, roll(x, k=3, FUN = mean, align="right", na.pad = TRUE)) # Internal Function: .rollstats <- function(x, k, fun, na.pad = FALSE, align = c("center", "left", "right"), ...) { window <- matrix(1:(length(x)+1-k), ncol = 1) winFun <- function(i, fun, y, k, ...) { fun = match.fun(fun) from = 1:(length(y)+1-k) to = from + k -1 fun(y[i:to[i]], ...) } rval <- apply(window, 1, FUN=winFun, fun=FUN, y=x, k=k, ...) if (na.pad) { rval <- switch(match.arg(align), "left" = { c(rval, rep(NA, k-1)) }, "center" = { c(rep(NA, floor((k-1)/2)), rval, rep(NA, ceiling((k-1)/2))) }, "right" = { c(rep(NA, k-1), rval) }) } rval } # Roll: ans <- apply(x, 2, FUN=.rollstats, k=k, fun=FUN, na.pad=na.pad, align=align, ...) x <- setDataPart(x[seq.int(1,NROW(ans)),], ans) colnames(x) <- paste(colnames(x), "RSTATS", sep = "_") if(!na.pad) x = na.omit(x) # Return Value x } ############################################################################### rollMean <- function(x, k, na.pad=FALSE, align=c("center", "left", "right"), ...) { # Description: # Returns rolling mean of a 'timeSeries' object # Arguments: # x - an object of class timeSeries # k - integer width of the rolling window. # na.pad - a logical. Should NA padding be added at beginning? # align - character specifying whether result should be left- or # right-aligned or centered (default). # ... - furter arguments passed to methods. # Note: # Internal function are borrowed from package zoo ... # Example: # X = timeSeries(matrix(rnorm(24), ncol = 2), timeCalendar()) # R = rollMean(x = X, k = 3); R; plot(R) # FUNCTION: # Internal Function: .rollmean.default <- function(x, k, na.pad = FALSE, align = c("center", "left", "right"), ...) { n <- length(x) y <- x[k:n] - x[c(1, 1:(n-k))] y[1] <- sum(x[1:k]) rval <- cumsum(y)/k if (na.pad) { rval <- switch(match.arg(align), "left" = { c(rval, rep(NA, k-1)) }, "center" = { c(rep(NA, floor((k-1)/2)), rval, rep(NA, ceiling((k-1)/2))) }, "right" = { c(rep(NA, k-1), rval) }) } rval } # Roll: ans <- apply(x, 2, .rollmean.default, k = k, na.pad=na.pad, align=align) x <- setDataPart(x[seq.int(1,NROW(ans)),], ans) colnames(x) <- paste(colnames(x), "RMEAN", sep = "_") if(!na.pad) x = na.omit(x) # Return Value: x } # ------------------------------------------------------------------------------ rollMax <- function(x, k, na.pad=FALSE, align=c("center", "left", "right"), ...) { # Description: # Returns rolling maximum of a 'timeSeries' object # Arguments: # x - an object of class timeSeries # k - integer width of the rolling window. # na.pad - a logical. Should NA padding be added at beginning? # align - character specifying whether result should be left- or # right-aligned or centered (default). # ... - furter arguments passed to methods. # Note: # Internal function are borrowed from package zoo ... # Example: # X = timeSeries(matrix(rnorm(24), ncol = 2), timeCalendar()) # R = rollMax(x = X, k = 3); plot(R) # FUNCTION: # Internal Function: .rollmax.default <- function(x, k, na.pad = FALSE, align = c("center", "left", "right"), ...) { n <- length(x) rval <- rep(0, n) a <- 0 for (i in k:n) { rval[i] <- if (is.na(a) || is.na(rval[i=1]) || a==rval[i-1]) max(x[(i-k+1):i]) else max(rval[i-1], x[i]); # max of window = rval[i-1] a <- x[i-k+1] # point that will be removed from window } rval <- rval[-seq(k-1)] if (na.pad) { rval <- switch(match.arg(align), "left" = { c(rval, rep(NA, k-1)) }, "center" = { c(rep(NA, floor((k-1)/2)), rval, rep(NA, ceiling((k-1)/2))) }, "right" = { c(rep(NA, k-1), rval) }) } rval } # Roll: ans <- apply(getDataPart(x), 2, .rollmax.default, k = k, na.pad=na.pad, align=align) x <- setDataPart(x[seq.int(1,NROW(ans)),], ans) colnames(x) <- paste(colnames(x), "RMAX", sep = "_") if(!na.pad) x = na.omit(x) # Return Value: x } # ------------------------------------------------------------------------------ rollMin <- function(x, k, na.pad=FALSE, align=c("center", "left", "right"), ...) { # Description: # Returns rolling minimum of a 'timeSeries' object # Arguments: # x - an object of class timeSeries # k - integer width of the rolling window. # na.pad - a logical. Should NA padding be added at beginning? # align - character specifying whether result should be left- or # right-aligned or centered (default). # ... - furter arguments passed to methods. # Note: # Internal function are borrowed from package zoo ... # Example: # X = timeSeries(matrix(rnorm(24), ncol = 2), timeCalendar()) # R = rollMin(x = X, k = 3); R; plot(R) # FUNCTION: .rollmax.default <- function(x, k, na.pad = FALSE, align = c("center", "left", "right"), ...) { n <- length(x) rval <- rep(0, n) a <- 0 for (i in k:n) { rval[i] <- if (is.na(a) || is.na(rval[i=1]) || a==rval[i-1]) max(x[(i-k+1):i]) else max(rval[i-1], x[i]); # max of window = rval[i-1] a <- x[i-k+1] # point that will be removed from window } rval <- rval[-seq(k-1)] if (na.pad) { rval <- switch(match.arg(align), "left" = { c(rval, rep(NA, k-1)) }, "center" = { c(rep(NA, floor((k-1)/2)), rval, rep(NA, ceiling((k-1)/2))) }, "right" = { c(rep(NA, k-1), rval) }) } rval } .rollmin.default <- function(x, k, na.pad = FALSE, align = c("center", "left", "right"), ...) { ans = -.rollmax.default(-x, k, na.pad = na.pad, align = align, ...) ans } # Roll: ans <- apply(getDataPart(x), 2, .rollmin.default, k=k, na.pad=na.pad, align=align) x <- setDataPart(x[seq.int(1,NROW(ans)),], ans) colnames(x) <- paste(colnames(x), "RMIN", sep = "_") if(!na.pad) x = na.omit(x) # Return Value: x } # ------------------------------------------------------------------------------ rollMedian <- function(x, k, na.pad=FALSE, align=c("center", "left", "right"), ...) { # Description: # Returns rolling median of a 'timeSeries' object # Arguments: # x - an object of class timeSeries # k - integer width of the rolling window. Must be odd for rollmedian. # na.pad - a logical. Should NA padding be added at beginning? # align - character specifying whether result should be left- or # right-aligned or centered (default). # ... - furter arguments passed to methods. # Note: # Internal function are borrowed from package zoo ... # Example: # X = timeSeries(matrix(rnorm(24), ncol=2), timeCalendar()) # R = rollMedian(x = X, k = 3); R; plot(R) # FUNCTION: # Internal Function: .rollmedian.default <- function(x, k, na.pad = FALSE, align = c("center", "left", "right"), ...) { stopifnot(k <= length(x), k %% 2 == 1) n <- length(x) m <- k %/% 2 rval <- runmed(x, k, ...) attr(rval, "k") <- NULL rval <- rval[-c(1:m, (n-m+1):n)] if (na.pad) { rval <- switch(match.arg(align), "left" = { c(rval, rep(NA, k-1)) }, "center" = { c(rep(NA, floor((k-1)/2)), rval, rep(NA, ceiling((k-1)/2))) }, "right" = { c(rep(NA, k-1), rval) }) } rval } # Roll: ans <- apply(x, 2, .rollmedian.default, k=k, na.pad=na.pad, align=align) x <- setDataPart(x[seq.int(1,NROW(ans)),], ans) colnames(x) <- paste(colnames(x), "RMED", sep = "_") if(!na.pad) x = na.omit(x) # Return Value: x } ################################################################################ .rollmean.timeSeries <- function(...) { # FUNCTION: # Deprecated: .Deprecated("rollMean") # Return Value: rollMean(...) } # ------------------------------------------------------------------------------ .rollmin.timeSeries <- function(...) { # FUNCTION: # Deprecated: .Deprecated("rollMin") # Return Value: rollMin(...) } # ------------------------------------------------------------------------------ .rollmax.timeSeries <- function(...) { # FUNCTION: # Deprecated: .Deprecated("rollMax") # Return Value: rollMax(...) } # ------------------------------------------------------------------------------ .rollmedian.timeSeries <- function(...) { # FUNCTION: # Deprecated: .Deprecated("rollMedian") # Return Value: rollMedian(...) } ################################################################################ timeSeries/R/statistics-orderStatistics.R0000644000176000001440000000301611560011674020316 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # orderStatistics Compute order statistic of a 'timeSeries' object ################################################################################ orderStatistics <- function(x) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Compute the order statistics for a 'timeSeries object # Value: # A named list with the order statistics for each column of # the inputted series. # FUNCTION: # Order Statistics: td <- time(x) # Return Value: mapply( function(cl, nm) { S <- sort(cl, index.return = TRUE) timeSeries(data = S$x, charvec = td[S$ix], units = nm)}, as.list(x), colnames(x), SIMPLIFY = FALSE) } ################################################################################ timeSeries/R/statistics-orderColnames.R0000644000176000001440000001265211560011674017733 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # statsColnames Returns statistically rearranged column names # orderColnames Returns ordered column names of a time Series # sortColnames Returns sorted column names of a time Series # sampleColnames Returns sampled column names of a time Series # pcaColnames Returns PCA correlation ordered column names # hclustColnames Returns hierarchical clustered column names ################################################################################ statsColnames = function(x, FUN = colMeans, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns statistically rearranged column names # Arguments: # x - an object of class timeSeries # FUN - a character string, the name of the function to be used # ... - optional arguments to be passed to FUN # Note: # Example of function Candidates: # colStats calculates column statistics, # colSums calculates column sums, # colMeans calculates column means, # colSds calculates column standard deviations, # colVars calculates column variances, # colSkewness calculates column skewness, # colKurtosis calculates column kurtosis, # colMaxs calculates maximum values in each column, # colMins calculates minimum values in each column, # colProds computes product of all values in each column, # colQuantiles computes quantiles of each column. # FUNCTION: # Apply colStats Function: fun = match.fun(FUN) Sort = sort(fun(x, ...)) Order = names(Sort) ans = colnames(as.matrix(x)[, Order]) attr(ans, "control") <- Sort # Return Value: ans } # ------------------------------------------------------------------------------ orderColnames = function(x, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns ordered column names of a time Series # Arguments: # x - an object of class timeSeries # FUNCTION: # Order: ans = order(colnames(as.matrix(x)), ...) # Return Value: ans } # ------------------------------------------------------------------------------ sortColnames = function(x, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns sorted column names of a time Series # Arguments: # x - an object of class timeSeries # FUNCTION: # Sort: ans = sort(colnames(as.matrix(x)), ...) # Return Value: ans } # ------------------------------------------------------------------------------ sampleColnames = function(x, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns sampled column names of a time Series # Arguments: # x - an object of class timeSeries # FUNCTION: # Sample: ans = sample(colnames(as.matrix(x)), ...) # Return Value: ans } # ------------------------------------------------------------------------------ pcaColnames = function(x, robust = FALSE, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns PCA correlation ordered column names # Arguments: # x - an object of class timeSeries # robust - a logical, should we use robust covariance estimation? # FUNCTION: # Order: if (robust) { if (require(robustbase)) x.cor = covMcd(as.matrix(x), cor = TRUE, ...)$cor else stop("package \"robustbase\" cannot be loaded") } else { x.cor = cor(as.matrix(x), ...) } x.eigen = eigen(x.cor)$vectors[,1:2] e1 = x.eigen[, 1] e2 = x.eigen[, 2] Order = order(ifelse(e1 > 0, atan(e2/e1), atan(e2/e1)+pi)) ans = colnames(as.matrix(x))[Order] # Return Value: ans } # ------------------------------------------------------------------------------ hclustColnames = function(x, method = c("euclidean", "complete"), ...) { # A function implemented by Diethelm Wuertz # Description: # Returns hierarchical clustered column names # Arguments: # x - an object of class timeSeries # method - the agglomeration method to be used. This should # be (an unambiguous abbreviation of) one of "ward", "single", # "complete", "average", "mcquitty", "median" or "centroid". # ... optional arguments passed to the function hclust # FUNCTION: # Order: Order = hclust(dist(t(as.matrix(x)), method = method[1]), method = method[2], ...)$order ans = colnames(as.matrix(x))[Order] # Return Value: ans } ################################################################################ timeSeries/R/statistics-colSums.R0000644000176000001440000001204211560011674016554 0ustar ripleyusers # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Library General Public License for more details. # # You should have received a copy of the GNU Library General # Public License along with this library; if not, write to the # Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, # MA 02111-1307 USA # Copyrights (C) # for this R-port: # 1999 - 2008, Diethelm Wuertz, Rmetrics Foundation, GPL # Diethelm Wuertz # www.rmetrics.org # for the code accessed (or partly included) from other R-ports: # see R's copyright and license files # for the code accessed (or partly included) from contributed R-ports # and other sources # see Rmetrics's copyright file ################################################################################ # FUNCTION: COLUMN STATISTICS: # colStats Computes sample statistics by column # colSums Computes sums of all values in each column # colMeans Computes means of all values in each column # colSds Computes standardard deviation of each column # colVars Computes sample variance by column # colSkewness Computes sample skewness by column # colKurtosis Computes sample kurtosis by column # colMaxs Computes maximum values in each colum # colMins Computes minimum values in each colum # colProds Computes product of all values in each colum # FUNCTION: NO LONGER USED: # colAvgs Computes sample mean by column # colStdevs Computes sample standard deviation by column # mean.timeSeries Computes sample means by column # var.timeSeries Computes sample variance by column ################################################################################ # .conflicts.OK = TRUE # ------------------------------------------------------------------------------ colStats <- function(x, FUN, ...) { # A function implemented by Diethelm Wuertz # Description: # Computes sample statistics by column # FUNCTION: # Statistics: if (inherits(x, "timeSeries")) apply(na.omit(getDataPart(x), ...), 2, FUN, ...) #<< YC : as.matrix is slow ! else apply(na.omit(as.matrix(x), ...), 2, FUN, ...) } # ------------------------------------------------------------------------------ # YC important because default colSums is unefficient since it retrive # full dimnames, i.e. rownames which is very time consuming if (getRversion() < "2.9.0") { setMethod("colSums", "timeSeries", function(x, na.rm = FALSE, dims = 1L) { x <- getDataPart(x) callGeneric() }) } else { setMethod("colSums", "timeSeries", function(x, na.rm = FALSE, dims = 1L, ...) { x <- getDataPart(x) callGeneric() }) } # ------------------------------------------------------------------------------ # YC important because default colSums is unefficient since it retrive # full dimnames, i.e. rownames which is very time consuming if (getRversion() < "2.9.0") { setMethod("colMeans", "timeSeries", function(x, na.rm = FALSE, dims = 1L) { x <- getDataPart(x) callGeneric() }) } else { setMethod("colMeans", "timeSeries", function(x, na.rm = FALSE, dims = 1L, ...) { x <- getDataPart(x) callGeneric() }) } # ------------------------------------------------------------------------------ colSds <- function(x, ...) { colStats(x, "sd", ...) } colVars <- function(x, ...) { colStats(x, "var", ...) } colSkewness <- function(x, ...) { colStats(x, "skewness", ...) } colKurtosis <- function(x, ...) { colStats(x, "kurtosis", ...) } colMaxs <- function(x, ...) { colStats(x, "max", ...) } colMins <- function(x, ...) { colStats(x, "min", ...) } colProds <- function(x, ...) { colStats(x, "prod", ...) } # ------------------------------------------------------------------------------ colQuantiles <- function(x, prob = 0.05, ...) { # FUNCTION: stopifnot(length(prob) == 1) colStats(x, "quantile", probs = prob, ...) } # ------------------------------------------------------------------------------ colAvgs <- function(x, ...) colMeans(x, ...) colStdevs <- colSds # ------------------------------------------------------------------------------ # mean.timeSeries <- colMeans # var.timeSeries <- colVars ################################################################################ timeSeries/R/statistics-colCumsums.R0000644000176000001440000001443611560011674017272 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: COLUMN CUMULATIVE SUMS: # colCumsums Computes sample cumulated sums by column # colCumsums,matrix S3 default method (for matrix objects) # colCumsums,timeSeries S3 method for timeSeries objects # FUNCTION: COLUMN CUMULATIVE MAXIMA: # colCummaxs Computes cumulated maximum values # colCummaxs,matrix S3 default method (for matrix objects) # colCummaxs,timeSeries S3 method for timeSeries objects # FUNCTION: COLUMN CUMULATIVE MAXIMA: # colCummins Computes cumulated maximum values # colCummins,matrix S3 default method (for matrix objects) # colCummins,timeSeries S3 method for timeSeries objects # FUNCTION: COLUMN CUMULATIVE MINIMA: # colCumprods Computes cumulated product values # colCumprods,matrix S3 default method (for matrix objects) # colCumprods,timeSeries S3 method for timeSeries objects # FUNCTION: COLUMN CUMULATIVE RETURNS: # colCumreturns Computes cumulated product values # colCumreturns,matrix S3 default method (for matrix objects) # colCumreturns,timeSeries S3 method for timeSeries objects ################################################################################ # ------------------------------------------------------------------------------ setMethod("colCumsums", "matrix", function(x, na.rm = FALSE, ...) { if (na.rm) x <- na.omit(x) ans <- apply(x, 2, cumsum, ...) # special treatment when x has one row because apply returns a vector if (NROW(x) == 1) ans <- matrix(ans, nrow = 1, dimnames = dimnames(x)) ans }) # ------------------------------------------------------------------------------ setMethod("colCumsums", "timeSeries", function(x, na.rm = FALSE, ...) setDataPart(x, callGeneric(getDataPart(x), na.rm = na.rm, ...))) # ------------------------------------------------------------------------------ setMethod("colCummaxs", "matrix", function(x, na.rm = FALSE, ...) { if (na.rm) x <- na.omit(x) ans <- apply(x, 2, cummax, ...) # special treatment when x has one row because apply returns a vector if (NROW(x) == 1) ans <- matrix(ans, nrow = 1, dimnames = dimnames(x)) ans }) # ------------------------------------------------------------------------------ setMethod("colCummaxs", "timeSeries", function(x, na.rm = FALSE, ...) setDataPart(x, callGeneric(getDataPart(x), na.rm = na.rm, ...))) # ------------------------------------------------------------------------------ setMethod("colCummins", "matrix", function(x, na.rm = FALSE, ...) { if (na.rm) x <- na.omit(x) ans <- apply(x, 2, cummin, ...) # special treatment when x has one row because apply returns a vector if (NROW(x) == 1) ans <- matrix(ans, nrow = 1, dimnames = dimnames(x)) ans }) # ------------------------------------------------------------------------------ setMethod("colCummins", "timeSeries", function(x, na.rm = FALSE, ...) setDataPart(x, callGeneric(getDataPart(x), na.rm = na.rm, ...))) # ------------------------------------------------------------------------------ setMethod("colCumprods", "matrix", function(x, na.rm = FALSE, ...) { if (na.rm) x <- na.omit(x) ans <- apply(x, 2, cumprod, ...) # special treatment when x has one row because apply returns a vector if (NROW(x) == 1) ans <- matrix(ans, nrow = 1, dimnames = dimnames(x)) ans }) # ------------------------------------------------------------------------------ setMethod("colCumprods", "timeSeries", function(x, na.rm = FALSE, ...) setDataPart(x, callGeneric(getDataPart(x), na.rm = na.rm, ...))) # ------------------------------------------------------------------------------ setMethod("colCumreturns", "matrix", function(x, method = c("geometric", "simple"), na.rm = FALSE, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Cumulates Returns from a stream of returns # Arguments: # x : a matrix object # method : generate geometric or simple returns, # default "geometric". # FUNCTION: # Handle Missing Values: if (na.rm) x <- na.omit(x, ...) method <- match.arg(method) # Return Value switch(method, "geometric" = colCumsums(x), "simple" = colCumprods(1+x) - 1) }) # ------------------------------------------------------------------------------ setMethod("colCumreturns", "timeSeries", function(x, method = c("geometric", "simple"), na.rm = FALSE, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Cumulates Returns from a stream of returns # Arguments: # x : a timeSeries object # method : generate geometric or simple returns, # default "geometric". # FUNCTION: # Handle Missing Values: if (na.rm) x <- na.omit(x, ...) method <- match.arg(method) # Return Value switch(method, "geometric" = colCumsums(x), "simple" = colCumprods(1+x) - 1) }) ################################################################################ timeSeries/R/methods-show.R0000644000176000001440000001162611415310240015355 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # show,timeSeries Prints a 'timeSeries' object # print,timeSeries Prints a 'timeSeries' object # .print.timeSeries Called by function print,timeSerie ################################################################################ setMethod("show", "timeSeries", function(object) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Print method for an S4 object of class "timeSeries" # FUNCTION: # Check records to get printed: maxRmetrics <- as.numeric(getRmetricsOptions("max.print")) maxR <- as.numeric(getOption("max.print")) maxR <- floor(maxR / (NCOL(object) + NCOL(object@recordIDs))) max <- min(na.omit(c(maxRmetrics, maxR, Inf))) #-> Inf to cast case when maxRmetrics and maxR are NULL if (ptest <- ((omitted <- NROW(object) - max) > 0)) object <- object[seq.int(max),] data <- as(object, "matrix") recordIDs <- object@recordIDs FinCenter <- finCenter(object) # Series: cat(FinCenter, "\n", sep = "") if (prod(dim(recordIDs)) & (nrow(data) == NROW(recordIDs))) { dataIDs <- as.matrix(recordIDs) colnames(dataIDs) <- paste(colnames(dataIDs), "*", sep = "") #-> use format(data) to have same number of digits when timeSeries # is printed without @recordIDs print(cbind(format(data), dataIDs), quote = FALSE, right = TRUE) } else { print(data, quote = FALSE) #-> to be consistent with @recordIDs print } # print message if (ptest) cat(gettextf("...\n [ reached getRmetricsOption('max.print') | getOption('max.print') -- omitted %i rows ]]\n", omitted)) # Return Value: invisible(NULL) # as specified in ?show } ) # ------------------------------------------------------------------------------ .print.timeSeries <- function(x, FinCenter = NULL, format = NULL, style = c("tS", "h", "ts"), by = c("month", "quarter"), ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Allows for horizontal and ts like print output. # Arguments: # x - an object of class timeSeries # FinCenter - print with time stamps according to FinCenter # format - use specified format for printing # style - a character value specifying how to print: # "tS" Rmetrics' default vertical print style # "h" horizontal print style, # "ts" R's base style for regular time series # by - specifies the period for a regular time serie, # note only active for style="ts". # Example: # x = timeSeries(); print(x, format = "%d %b %Y"); x # FUNCTION: # Change Financial Center: if (!is.null(FinCenter)) finCenter(x) <- FinCenter # Match Arguments: style = match.arg(style) by = match.arg(by) # Change Format: if (is.null(format)) { charvec = rownames(x) } else { ans = timeDate(charvec = rownames(x), zone = "GMT", FinCenter = finCenter(x)) if (format == "%Q") { Quarters = rep(paste("Q", 1:4, sep = ""), each = 3) Y = atoms(ans)[, 1] Q = Quarters[atoms(ans)[, 2]] charvec = paste(Y, Q) } else { charvec = format(ans, format) } } # Styles: if (style == "tS") { cat(finCenter(x), "\n") X <- getDataPart(x) rownames(X) = charvec print(X) } else if (style == "h") { stopifnot(isUnivariate(x)) # print(as.vector(x)) ans = as.matrix(x)[,1] names(ans) = charvec print(ans) } else if (style == "ts") { freq = c(month = 12, quarter = 4) start(x) start = unlist(atoms(start(x))) end = unlist(atoms(end(x))) ts = ts(as.vector(x), start[1:2], end[1:2], freq[by]) print(ts) } # Return Value: invisible(x) } # ------------------------------------------------------------------------------ setMethod("print", "timeSeries", .print.timeSeries) ################################################################################ timeSeries/R/methods-plot.R0000644000176000001440000003376411732451203015371 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # plot,timeSeries Plots a 'timeSeries' object # .plot.timeSeries Internal function called by plot.timeSeries # lines,timeSeries Adds lines to a 'timeSeries' plot # points,timeSeries Adds points to a 'timeSeries' plot # FUNCTION: DESCRIPTION: # pretty.timeSeries Returns a sequence of equally spaced round values ################################################################################ .plot.timeSeries <- function(x, y, FinCenter = NULL, plot.type = c("multiple", "single"), format = "auto", at = pretty(x), widths = 1, heights = 1, xy.labels, xy.lines, panel = lines, nc, yax.flip = FALSE, mar.multi = c(0, 5.1, 0, if (yax.flip) 5.1 else 2.1), oma.multi = c(6, 0, 5, 0), axes = TRUE, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Plots 'timeSeries' objects # Arguments: # see plot.ts() # Additional Arguments: # format, at to beautify axis.POSIXct() function # widths, heights to handle layout() function # Details: # This function is build in exactly the same way as the function # plot.ts() for regular time series (R's ts) objects... # Examples: # x = as.timeSeries(data(msft.dat))[, 1:4] # .plot.timeSeries(x) # .plot.timeSeries(x[,1], x[,2], pch = 19) # .plot.timeSeries(x, plot.type = "single", col = 2:5) # FUNCTION: # Check Missing if (missing(y)) y <- NULL # Labels: xlabel <- if (!missing(x)) deparse(substitute(x)) ylabel <- if (!missing(y)) deparse(substitute(y)) # Take care of FinCenter: if (!is.null(FinCenter)) { finCenter(x) <- FinCenter if (!is.null(y)) finCenter(y) <- FinCenter if (is(at, "timeDate")) at@FinCenter <- FinCenter } # Return Value: .plotTimeSeries(x = x, y = y, plot.type = plot.type, xy.labels = xy.labels, xy.lines = xy.lines, panel = panel, nc = nc, xlabel = xlabel, ylabel = ylabel, axes = axes, mar.multi = mar.multi, oma.multi = oma.multi, yax.flip = yax.flip, format = format, at = at, widths = widths, heights = heights, ...) } setMethod("plot", "timeSeries", function(x, y, FinCenter = NULL, plot.type = c("multiple", "single"), format = "auto", at = pretty(x), widths = 1, heights = 1, xy.labels, xy.lines, panel = lines, nc, yax.flip = FALSE, mar.multi = c(0, 5.1, 0, if (yax.flip) 5.1 else 2.1), oma.multi = c(6, 0, 5, 0), axes = TRUE, ...) .plot.timeSeries(x = x, y = y, FinCenter = FinCenter, plot.type = plot.type, format = format, at = at, widths = widths, heights = heights, xy.labels=xy.labels, xy.lines=xy.lines, panel = panel, nc = nc, yax.flip = yax.flip, mar.multi = mar.multi, oma.multi = oma.multi, axes = axes, ...)) # until UseMethod dispatches S4 methods in 'base' functions plot.timeSeries <- function(x, y, ...) .plot.timeSeries(x, y, ...) # ------------------------------------------------------------------------------ # Internal Function called by plot(): .plotTimeSeries <- function(x, y = NULL, plot.type = c("multiple", "single"), xy.labels, xy.lines, panel = lines, nc, xlabel, ylabel, type = "l", xlim = NULL, ylim = NULL, xlab = "Time", ylab, log = "", col = 1:ncol(x), bg = NA, pch = 1:ncol(x), cex = par("cex"), lty = par("lty"), lwd = par("lwd"), axes = TRUE, frame.plot = axes, ann = par("ann"), main = NULL, mar.multi, oma.multi, yax.flip, format, at, widths, heights, grid = FALSE, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Plots timeSeries objects - Internal Function # Details: # A modified copy of R's internal 'plotts()' function, # see 'plot.ts()'. # FUNCTION: # Utility Function: plot.type <- match.arg(plot.type) nser <- NCOL(x) if (format == "auto") format = x@format X <- if (x@format == "counts") time(x) else as.POSIXct(time(x)) if (is.character(at) && at == "auto") { # Index = round(seq(1, length(time(x)), length = 6)) # at = X[Index] at = seq(X[1], X[length(X)], length = 6) } if(is(at, "timeDate")) at = as.POSIXct(at) # YC : force col and pch to be of same length as NCOL(x) otherwise # time series might not be plotted at all. col <- rep(col, length.out = nser) pch <- rep(pch, length.out = nser) # Multiple Plots, each one Curve, on one Page: if (plot.type == "multiple" && nser > 1) { ngraph = nser panel <- match.fun(panel) nser <- NCOL(x) if (nser > 10) stop("cannot plot more than 10 series as \"multiple\"") if (is.null(main)) main <- xlabel nm <- colnames(x) if (is.null(nm)) nm <- paste("Series", 1:nser) if (missing(nc)) nc <- if (nser > 4) 2 else 1 nr <- ceiling(nser/nc) oldpar <- par(mar = mar.multi, oma = oma.multi, mfcol = c(nr, nc)) on.exit(par(oldpar)) nr <- ceiling(ngraph/nc) layout(matrix(seq(nr * nc), nr), widths = widths, heights = heights) for (i in 1:nser) { plot(X, series(x)[, i], axes = FALSE, xlab = "", ylab = "", log = log, col = col[i], bg = bg, pch = pch[i], ann = ann, type = "n", ...) panel(X, series(x)[, i], col = col[i], bg = bg, pch = pch[i], type = type, ...) if (frame.plot) box(...) y.side <- if (i%%2 || !yax.flip) 2 else 4 do.xax <- i%%nr == 0 || i == nser if (axes) { axis(y.side, xpd = NA) if (do.xax) { if (x@format == "counts") { axis(1) } else { axis.POSIXct(1, at = at, format = format) } } } if (ann) { mtext(nm[i], y.side, line = 3, ...) if (do.xax) mtext(xlab, side = 1, line = 3, ...) } if(grid) abline(v = at, lty = 3, col = "grey") } if (ann && !is.null(main)) { par(mfcol = c(1, 1)) cex.main = par("cex.main") font.main = par("font.main") col.main = par("col.main") mtext(main, side = 3, line = 3, cex = cex.main, font = font.main, col = col.main, ...) } return(invisible()) } # Scatter Plot: if (!is.null(y)) { stopifnot(isUnivariate(x)) stopifnot(isUnivariate(y)) xy = cbind(x, y) xy <- xy.coords(series(xy)[, 1], series(xy)[, 2], xlabel, ylabel, log) xlab <- if (missing(xlab)) xy$xlab else xlab ylab <- if (missing(ylab)) xy$ylab else ylab xlim <- if (is.null(xlim)) range(xy$x[is.finite(xy$x)]) else xlim ylim <- if (is.null(ylim)) range(xy$y[is.finite(xy$y)]) else ylim n <- length(xy$x) if (missing(xy.labels)) xy.labels <- (n <= 150) if (!is.logical(xy.labels)) { if (!is.character(xy.labels)) stop("'xy.labels' must be logical or character") do.lab <- TRUE } else { do.lab <- xy.labels } ptype <- if (do.lab) "n" else if (missing(type)) "p" else type plot.default(xy, type = ptype, xlab = xlab, ylab = ylab, xlim = xlim, ylim = ylim, log = log, col = col, bg = bg, pch = pch, axes = axes, frame.plot = frame.plot, ann = ann, main = main, ...) if (missing(xy.lines)) { xy.lines <- do.lab } if (do.lab) text(xy, labels = if (is.character(xy.labels)) xy.labels else seq_along(xy$x), col = col, cex = cex) if (xy.lines) { type = if (do.lab) "c" else "l" lines(xy, col = col, lty = lty, lwd = lwd, type = type) } return(invisible()) } # Multiple Curves all in one Plot, on one Page: if (missing(ylab)) { ylab <- colnames(x) if (length(ylab) != 1) ylab <- xlabel } if (is.null(ylim)) ylim <- range(x, na.rm = TRUE) i = 1 X <- if (x@format == "counts") time(x) else as.POSIXct(time(x)) plot(X, series(x)[, i], ylim = ylim, col = col[(i - 1)%%length(col) + 1], lty = lty[(i - 1)%%length(lty) + 1], lwd = lwd[(i - 1)%%length(lwd) + 1], bg = bg[(i - 1)%%length(bg) + 1], pch = pch[(i - 1)%%length(pch) + 1], type = type, axes = FALSE, ylab = "", xlab = "") if (NCOL(x) > 1) for (i in 2:NCOL(x)) lines(X, series(x)[, i], col = col[(i - 1)%%length(col) + 1], lty = lty[(i - 1)%%length(lty) + 1], lwd = lwd[(i - 1)%%length(lwd) + 1], bg = bg[(i - 1)%%length(bg) + 1], pch = pch[(i - 1)%%length(pch) + 1], type = type) if (ann) title(main = main, xlab = xlab, ylab = ylab, ...) if (axes) { if (x@format == "counts") axis(1, ...) else axis.POSIXct(1, at = at, format = format) axis(2, ...) } if (frame.plot) box(...) if(grid) abline(v = at, lty = 3, col = "grey") return(invisible()) } # ------------------------------------------------------------------------------ .lines.timeSeries <- function(x, FinCenter = NULL, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # NEW Lines method for an object of class "timeSeries" # Arguments: # x - a "timeSeries" object # Example: # plot(MSFT[, 1]); lines(MSFT[, 1], col = "red") # FUNCTION: # Change FinCenter: if (!is.null(FinCenter)) finCenter(x) <- FinCenter # Lines: positions <- time(x) if (x@format == "counts") { lines(x = positions, y = series(x), ...) } else { lines(x = as.POSIXct(positions), y = series(x), ...) } # Return Value: invisible(x) } setMethod("lines", "timeSeries", function(x, FinCenter = NULL, ...) .lines.timeSeries(x, FinCenter, ...)) # until UseMethod dispatches S4 methods in 'base' functions lines.timeSeries <- function(x, FinCenter = NULL, ...) .lines.timeSeries(x, FinCenter = FinCenter, ...) # ------------------------------------------------------------------------------ .points.timeSeries <- function(x, FinCenter = NULL, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Plot method for an object of class "timeSeries" # Arguments: # x - a "timeSeries" object # Value: # Plots a 'timeSeries' object. # FUNCTION: # Change FinCenter: if (!is.null(FinCenter)) finCenter(x) <- FinCenter # Points: positions <- time(x) if (x@format == "counts") { points(x = positions, y = series(x), ...) } else { points(x = as.POSIXct(positions), y = series(x), ...) } # Return Value: invisible(x) } setMethod("points", "timeSeries", function(x, FinCenter = NULL, ...) .points.timeSeries(x, FinCenter = FinCenter, ...)) # until UseMethod dispatches S4 methods in 'base' functions points.timeSeries <- function(x, FinCenter = NULL, ...) .points.timeSeries(x, FinCenter = FinCenter, ...) ################################################################################ pretty.timeSeries <- function(x, n = 5, min.n = n%/%3, shrink.sml = 0.75, high.u.bias = 1.5, u5.bias = 0.5 + 1.5 * high.u.bias, eps.correct = 0, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns a sequence of equally spaced round values. # Details: # Computes a sequence of about n+1 equally spaced ‘round’ # values which cover the range of the values in x. # The values are chosen so that they are 1, 2 or 5 times # a power of 10. # Arguments: # x - a timeSeries object from which the time is # extracted # n - integer giving the desired number of intervals. # min.n - nonnegative integer giving the minimal # number of intervals. # shrink.sml - positive numeric by a which a default # scale is shrunk in the case when range(x) is # very small. # high.u.bias - non-negative numeric, typically > 1. # Larger high.u.bias values favor larger units. # u5.bias - non-negative numeric multiplier favoring # factor 5 over 2. # eps.correct - integer code, one of {0,1,2}. If # non-0, a correction is made at the boundaries. # ... - further arguments for methods. # FUNCTION: td <- time(x) if (inherits(x, "timeDate")) { x <- as.POSIXct(td) as.timeDate(pretty(x, n=n, min.n=min.n, shrink.sml=shrink.sml, high.u.bias=high.u.bias, u5.bias=u5.bias, eps.correct=eps.correct, ...)) } else { #-> signal series pretty(td) } } ############################################################################### timeSeries/R/methods-mathOps.R0000644000176000001440000001243112124051744016014 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # Ops,timeSeries Returns group 'Ops' for a 'timeSeries' object # cummax Returns cumulated maxima # cummin Returns cumulated minima # cumprod Returns cumulated products # cumsum Returns cumulated sums # quantile,timeSeries Sample qunatile of a timeSeries object ################################################################################ setMethod("Ops", c("vector", "timeSeries"), function(e1, e2) { lattrs <- attributes(e2) e2 <- getDataPart(e2) value <- callGeneric(e1, e2) if (identical(dim(value), dim(e2))) { attributes(value) <- lattrs value <- asS4(value, TRUE) } value } ) # ------------------------------------------------------------------------------ setMethod("Ops", c("array", "timeSeries"), function(e1, e2) { e1 <- as.vector(e1) lattrs <- attributes(e2) e2 <- getDataPart(e2) value <- callGeneric(e1, e2) if (identical(dim(value), dim(e2))) { attributes(value) <- lattrs value <- asS4(value, TRUE) } value } ) # ------------------------------------------------------------------------------ setMethod("Ops", c("ts", "timeSeries"), function(e1, e2) { e1 <- as(e1, "matrix") lattrs <- attributes(e2) e2 <- getDataPart(e2) value <- callGeneric(e1, e2) if (identical(dim(value), dim(e2))) { attributes(value) <- lattrs value <- asS4(value, TRUE) } value } ) # ------------------------------------------------------------------------------ setMethod("Ops", c("timeSeries", "vector"), function(e1, e2) { lattrs <- attributes(e1) e1 <- getDataPart(e1) value <- callGeneric(e1, e2) if (identical(dim(value), dim(e1))) { attributes(value) <- lattrs value <- asS4(value, TRUE) } value } ) # ------------------------------------------------------------------------------ setMethod("Ops", c("timeSeries", "array"), function(e1, e2) { lattrs <- attributes(e1) e1 <- getDataPart(e1) value <- callGeneric(e1, e2) if (identical(dim(value), dim(e1))) { attributes(value) <- lattrs value <- asS4(value, TRUE) } value } ) # ------------------------------------------------------------------------------ setMethod("Ops", c("timeSeries", "ts"), function(e1, e2) { lattrs <- attributes(e1) e1 <- getDataPart(e1) e2 <- as(e2, "matrix") value <- callGeneric(e1, e2) if (identical(dim(value), dim(e1))) { attributes(value) <- lattrs value <- asS4(value, TRUE) } value } ) # ------------------------------------------------------------------------------ setMethod("Ops", c("timeSeries", "timeSeries"), function(e1, e2) { # Note keep recordIDs of e1 only # check if conformable arrays if (!identical(dim(e1), dim(e2))) stop("non-conformable arrays") # check if positions are identical if (!identical(e1@positions, e2@positions)) stop("positions slot do not match") lattrs <- attributes(e1) e1 <- getDataPart(e1) e2 <- getDataPart(e2) value <- callGeneric(e1, e2) if (identical(dim(value), dim(e1))) { attributes(value) <- lattrs value <- asS4(value, TRUE) } value } ) # ------------------------------------------------------------------------------ setMethod("cummax", "timeSeries", function(x) callGeneric(getDataPart(x))) # ------------------------------------------------------------------------------ setMethod("cummin", "timeSeries", function(x) callGeneric(getDataPart(x))) # ------------------------------------------------------------------------------ setMethod("cumprod", "timeSeries", function(x) callGeneric(getDataPart(x))) # ------------------------------------------------------------------------------ setMethod("cumsum", "timeSeries", function(x) callGeneric(getDataPart(x))) # ------------------------------------------------------------------------------ setMethod("quantile", "timeSeries", function(x, ...) { x <- getDataPart(x) callGeneric() }) ################################################################################ timeSeries/R/methods-is.R0000644000176000001440000000427011560011674015017 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # is.timeSeries Tests for a 'timeSeries' object ################################################################################ is.timeSeries <- function (x) { # A function implemented by Diethelm Wuertz # Description: # Tests for a 'timeSeries' object. # Arguments: # object - a 'timeSeries' object to be tested. # Value: # Returns 'TRUE' or 'FALSE' depending on whether its # argument is of 'timeSeries' type or not. # Changes: # # FUNCTION: # Check: ans <- is(x, "timeSeries") # Return Value: ans } # ------------------------------------------------------------------------------ is.signalSeries <- function(x) { !as.logical(length(x@positions)) } # ------------------------------------------------------------------------------ # YC: # Note if is.na returns a timeSeries objects then we have problem # with the function quantile... setMethod("is.na", "timeSeries", function(x) setDataPart(x, is.na(getDataPart(x)))) # ------------------------------------------------------------------------------ if (getRversion() < "2.8.0") { setMethod("is.unsorted", "timeSeries", function(x, na.rm = FALSE) callGeneric(x@positions, na.rm = na.rm)) } else { setMethod("is.unsorted", "timeSeries", function(x, na.rm = FALSE, strictly = FALSE) callGeneric(x@positions, na.rm = na.rm, strictly = strictly)) } ################################################################################ timeSeries/R/methods-comment.R0000644000176000001440000000266611560011674016055 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # comment, timeSeries Get documentation slot of a timeSeries object # comment<-,timeSeries Set documentation slot of a timeSeries object ################################################################################ setMethod("comment", "timeSeries", function(x) { # A function implemented by Yohan Chalabi and Diethelm Wuertz # Return Value: x@documentation } ) # ------------------------------------------------------------------------------ setMethod("comment<-", "timeSeries", function(x, value) { x@documentation <- paste(value, collapse = " ") # Return Value: x } ) ################################################################################ timeSeries/R/methods-as.R0000644000176000001440000002564511560011674015020 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # METHOD: CREATE A TIMESERIES FROM OTHER OBJECTS: # as.timeSeries Defines method for a 'timeSeries' object # as.timeSeries.default Returns the input # as.timeSeries.ts Transforms a 'data.frame' into a 'timeSeries' # as.timeSeries.data.frame Transforms a 'data.frame' into a 'timeSeries' # as.timeSeries.character Loads and transformas from a demo file # as.timeSeries.zoo Transforms a 'zoo' object into a 'timeSeries' # METHOD: TRANSFORM A TIMESERIES INTO OTHER OBJECTS: # as.vector.timeSeries Converts a univariate 'timeSeries' to a vector # as.matrix.timeSeries Converts a 'timeSeries' to a 'matrix' # as.numeric.timeSeries Converts a 'timeSeries' to a 'numeric' # as.data.frame.timeSeries Converts a 'timeSeries' to a 'data.frame' # as.ts.timeSeries Converts a 'timeSeries' to a 'ts' # as.ts.logical Converts a 'timeSeries' to 'logical' # as.list.timeSeries Converts a 'timeSeries' to 'list' ################################################################################ # YC: # here keep S3 methods because it should expect an oldClass object as argument # ------------------------------------------------------------------------------ as.timeSeries <- function(x, ...) { UseMethod("as.timeSeries") } # ------------------------------------------------------------------------------ as.timeSeries.default <- function(x, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # FUNCTION: # Return Value: ans <- timeSeries(x, ...) ans } setAs("ANY", "timeSeries", function(from) as.timeSeries(from)) # ------------------------------------------------------------------------------ as.timeSeries.ts <- function(x, ...) { asTime <- unclass(time(x)) yearPart <- trunc(asTime) decimalPart <- asTime - yearPart leapYears <- yearPart%%4 == 0 & (yearPart%%100 != 0 | yearPart%%400 == 0) days <- trunc(decimalPart * (365 + leapYears)) + 1 freq <- frequency(x) charvec <- if (freq == 4) { # Quarterly Data: days <- days + 1 ans <- timeDate(format(strptime(paste(yearPart, days), format = "%Y %j")), zone = "GMT", FinCenter = "GMT") timeLastDayInQuarter(ans) } else if (freq == 12) { # Monthly Data: days <- days + 1 ans <- timeDate(format(strptime(paste(yearPart, days), format = "%Y %j")), zone = "GMT", FinCenter = "GMT") timeLastDayInMonth(ans) } else { NA } # Result: tS = timeSeries(x, charvec, ...) attr(tS, "ts") <- c(start = round(start(x)), frequency = round(frequency(x)), deltat = deltat(x)) # Return Value: tS } setAs("ts", "timeSeries", function(from) as.timeSeries(from)) # ------------------------------------------------------------------------------ as.timeSeries.data.frame <- function(x, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Converts a data.frame into a timeSeries object # Notes: # The first column must contain the dates. # Examples: # data(bmwRet); head(as.timeSeries(data(bmwRet))) # FUNCTION: if (all(!(num <- unlist(lapply(x, is.numeric))))) stop("x contains no numeric columns") # Check if rownames(x) or the first column has a valid ISO-format: if (num[1]) # is.numeric() is better than format == "unkown" # which can give wrong result. i.e. whichFormat(0.1253328600) suppressWarnings(charvec <- timeDate(rownames(x))) else suppressWarnings(charvec <- timeDate(as.vector(x[,1]))) data <- as.matrix(x[, num]) units <- names(x)[num] if (any(!(cl <- num[-1]))) { recordIDs <- as.data.frame(x[, !c(TRUE, cl)]) # do not take first column names(recordIDs) <- names(x)[!c(TRUE, cl)] } else { recordIDs <- data.frame() } # Create Time Series Object: timeSeries(data = data, charvec = charvec, units = units, recordIDs = recordIDs, ...) } setAs("data.frame", "timeSeries", function(from) as.timeSeries(from)) # ------------------------------------------------------------------------------ as.timeSeries.character <- function(x, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Example: # as.timeSeries(data(nyse)) # FUNCTION: # Load Demo File - Returns a data frame: x <- eval(parse(text = eval(x))) # timeSeries: ans <- as.timeSeries(x, ...) # Return Value: ans } setAs("character", "timeSeries", function(from) as.timeSeries(from)) # ------------------------------------------------------------------------------ as.timeSeries.zoo <- function(x, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # FUNCTION: # as. timeSeries: ans <- timeSeries(data = as.matrix(x), charvec = as.character(attr(x, "index")), ...) # Return Value: ans } ################################################################################ # YC: # Since 2.9.0 must define proper S4 methods .as.matrix.timeSeries <- function(x, ...) { # A function implemented by Diethelm Wuertz # Description: # Converts a multivariate "timeSeries" to a matrix # Arguments: # x - a 'timeSeries' object # Value: # Returns the data slot of a 'timesSeries' object as a vector. # FUNCTION: # Check: if (!inherits(x, "timeSeries")) stop("x is not a timeSeries object!") # Convert: ans <- getDataPart(x) # is matrix dimnames(ans) <- dimnames(x) # Results ans } setMethod("as.matrix", "timeSeries", function(x, ...) .as.matrix.timeSeries(x, ...)) # until UseMethod dispatches S4 methods in 'base' functions as.matrix.timeSeries <- function(x, ...) .as.matrix.timeSeries(x, ...) setAs("timeSeries", "matrix", function(from) as.matrix(from)) # ------------------------------------------------------------------------------ .as.data.frame.timeSeries <- function(x, row.names = NULL, optional = FALSE, ...) { # A function implemented by Diethelm Wuertz # Description: # Converts a multivariate "timeSeries" to a data.frame # Arguments: # x - a 'timeSeries' object # row.names, optional - not used # Value: # Returns the data slot of a 'timesSeries' object as a data frame. # FUNCTION: # get rownames from timeSeries if (is.null(row.names)) row.names <- rownames(x) if (any(duplicated(row.names))) stop("cannot convert to data.frame with duplicate timestamps") ans <- if (!length(x@recordIDs)) data.frame(as.list(x), row.names = row.names, ...) else data.frame(as.list(x), x@recordIDs, row.names = row.names, ...) # Return Value: ans } setMethod("as.data.frame", "timeSeries", function(x, row.names = NULL, optional = FALSE, ...) .as.data.frame.timeSeries(x, row.names = row.names, optional = optional, ...)) # until UseMethod dispatches S4 methods in 'base' functions as.data.frame.timeSeries <- function(x, ...) .as.data.frame.timeSeries(x, ...) setAs("timeSeries", "data.frame", function(from) as.data.frame(from)) # ------------------------------------------------------------------------------ .as.ts.timeSeries <- function(x, ...) { # A function implemented by Diethelm Wuertz # Description: # Converts a colum from a 'timeSeries' object into an object # of class 'ts'. # Example: # # x = dummySeries(); as.ts(x) # # x = timeSeries(seq(12), timeSequence(by = "month", length.out = 12)) # as.ts(x) # # x = dummySeries()[c(3,6,9,12),]; as.ts(x) # x = dummySeries()[c(2,5,8,11),]; as.ts(x) # x = dummySeries()[c(1,4,7,10),]; as.ts(x) # # x = dummySeries()[c(4,7,10,1),]; as.ts(x) # Changes: # # FUNCTION: # check if monthly or quarterly data td <- time(x) m <- c(timeDate::months(td)) #-> c() to remove attributes # (m[1] -1) -> shift vector to match first entry in m monthly <- seq(from = m[1]-1, length.out=length(m)) %% 12 + 1 quarterly <- seq(from = m[1]-1, by = 3, length=length(m)) %% 12 + 1 # get year of first entry y1 <- as.numeric(format(td[1], "%Y")) # important to use vector/matrix to avoid troubles with ts() data <- if (isUnivariate(x)) as.vector(x) else matrix(x, ncol = ncol(x)) if (identical(monthly, m)) # Monthly data return(ts(data, start = c(y1, m[1]), frequency = 12)) if (identical(quarterly, m)) # Quarterly data return(ts(data, start = c(y1, m[1]%/%4+1), frequency = 4)) # other frequencies not implemented yet; return default value ans <- ts(data, names = colnames(x)) attr(ans, "positions") <- time(x) ans } setMethod("as.ts", "timeSeries", function(x, ...) .as.ts.timeSeries(x, ...)) # until UseMethod dispatches S4 methods in 'base' functions as.ts.timeSeries <- function(x, ...) .as.ts.timeSeries(x, ...) setAs("timeSeries", "ts", function(from) as.ts(from)) # ------------------------------------------------------------------------------ # YC: # Unneeded since timeSeries inherits from the structure class # as.logical.timeSeries <- function(x, ...) as.logical(series(x), ...) # ------------------------------------------------------------------------------ # YC: # Important for functions like lapply and sapply to work properly .as.list.timeSeries <- function(x, ...) { data <- getDataPart(x) ncols <- NCOL(data) value <- vector("list", ncols) for (i in seq.int(ncols)) value[[i]] <- as.vector(data[, i]) names(value) <- colnames(x) value } setMethod("as.list", "timeSeries", function(x, ...) .as.list.timeSeries(x, ...)) # until UseMethod dispatches S4 methods in 'base' functions as.list.timeSeries <- function(x, ...) .as.list.timeSeries(x, ...) setAs("timeSeries", "list", function(from) as.list(from)) ################################################################################ timeSeries/R/fin-turnpoints.R0000644000176000001440000002324211560011674015742 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # turns Returns turnpoints from a 'timeSeries' # turnsStats Computes statistics of turn points # BUILTIN: DESCRIPTION: # .turnpointsPastecs Builtin function from package pastecs # .extract.turnpointsPastecs Extractor function from package pastecs # .plot.turnpointsPastecs Plot function from package pastecs # .summary.turnpointsPastecs Summary function from package pastecs # DEPRECATED: DESRIPTION: # .turnpoints2 Deprecated, use function turns # .turnpointsSeries Deprecated, use function turns # .turnpointsStats Deprecated, use function turnsStats ################################################################################ # DW: # This function is originally borrowed from the contributesd R package pastecs. # It is not necessary to load pastecs, the functions required are builtin. # ----------------------------------------------------------------------------- turns <- function(x, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns turnpoints from a timeSeries # Arguments: # x - an univariate timeSeries object, e.g. a price or index series. # ... - arguments passed to the function na.omit() # FUNCTION: # Settings: stopifnot(isUnivariate(x)) # Handle Missing Values: x <- na.omit(x, ...) # Convert to Vector: X <- x x <- as.vector(x) # Turnpoints: ans <- .turnpointsPastecs(x) tp <- .extract.turnpointsPastecs(ans) data <- cbind(x, tp) colnames(data) <- c(colnames(X), "TP") series(X) <- data # Return Value: X } # ---------------------------------------------------------------------------- turnsStats <- function(x, doplot = TRUE) { # A function implemented by Diethelm Wuertz # Description: # Computes turnpoints statistics # Arguments: # x - an univariate timeSeries object, e.g. a price or index series # doplot - a logical flag, should an optional plot be displayed? # Value: # Returns an object of class turnpoints. # FUNCTION: # Settings stopifnot(isUnivariate(x)) X <- x x <- as.vector(x) # Turnpoints: ans <- .turnpointsPastecs(x) # Summary Statistics: .summary.turnpointsPastecs(ans) # Optional Plot: if(doplot) .plot.turnpointsPastecs(ans) # Return Value: invisible(ans) } ################################################################################ .turnpoints2 <- function(...) { # Deprecated: .Deprecated(new = "turns", package = "timeSeries") # Return Value: turns(...) } # ----------------------------------------------------------------------------- .turnpointsStats <- function(...) { # Deprecated: .Deprecated(new = "turnsStats", package = "timeSeries") # Return Value: turnsStats(...) } ################################################################################ # Package: pastecs # Title: Package for Analysis of Space-Time Ecological Series # Version: 1.3-4 # Date: 2006-11-28 # Author: Frederic Ibanez , # Philippe Grosjean & # Michele Etienne # Description: Regulation, decomposition and analysis of space-time series. # The pastecs library is a PNEC-Art4 and IFREMER # (Benoit Beliaeff ) initiative # to bring PASSTEC 2000 # (http://www.obs-vlfr.fr/~enseigne/anado/passtec/passtec.htm) # functionnalities to R. # URL: http://www.sciviews.org/pastecs # Maintainer: Philippe Grosjean # License: GNU Public Licence 2.0 or above at your convenience # Depends: boot, stats # Packaged: Tue Nov 28 15:33:42 2006; Philippe Grosjean .turnpointsPastecs <- function(x) { data <- deparse(substitute(x)) if (is.null(ncol(x)) == FALSE) stop("Only one series can be treated at a time") # if (exists("is.R") && is.function(is.R) && is.R()) # We are in R # Now done with Depends: field require(stats) x <- as.vector(x) n <- length(x) diffs <- c(x[1]-1, x[1:(n-1)]) != x uniques <- x[diffs] n2 <- length(uniques) poss <- (1:n)[diffs] exaequos <- c(poss[2:n2], n+1) - poss - 1 if (n2 < 3) { # We need at least 3 unique values!!! warning("Less than 3 unique values, no calculation!") nturns <- NA firstispeak <- FALSE peaks <- rep(FALSE, n2) pits <- rep(FALSE, n2) tppos <- NA proba <- NA info <- NA } else { # The following code is faster in R, but do not work all the time! #if (exists("is.R") && is.function(is.R) && is.R()) { # We are in R # ex <- embed(uniques, 3) # Works only in R! # peaks <- c(FALSE, max.col(ex) == 2, FALSE) # pits <- c(FALSE, max.col(-ex) == 2, FALSE) #} else { # We are in S+ m <- n2 - 2 ex <- matrix(uniques[1:m + rep(3:1, rep(m, 3)) - 1], m) peaks <- c(FALSE, apply(ex, 1, max, na.rm=TRUE) == ex[, 2], FALSE) pits <- c(FALSE, apply(ex, 1, min, na.rm=TRUE) == ex[, 2], FALSE) #} tpts <- peaks | pits if (sum(tpts) == 0) { # No turning point nturns <- 0 firstispeak <- FALSE peaks <- rep(FALSE, n2) pits <- rep(FALSE, n2) tppos <- NA proba <- NA info <- NA } else { # This way, we consider the last element of duplicates, as # in PASSTEC 2000 tppos <- (poss + exaequos)[tpts] tptspos <- (1:n2)[tpts] firstispeak <- tptspos[1] == (1:n2)[peaks][1] nturns <- length(tptspos) if (nturns < 2) { inter <- n2 + 1 posinter1 <- tptspos[1] } else { inter <- c(tptspos[2:nturns], n2) - c(1, tptspos[1:(nturns-1)]) + 1 posinter1 <- tptspos - c(1, tptspos[1:(nturns-1)]) } posinter2 <- inter - posinter1 posinter <- pmax(posinter1, posinter2) proba <- 2 / (inter * gamma(posinter) * gamma(inter - posinter + 1)) info <- -log(proba, base = 2) } } res <- list(data = data, n = n, points = uniques, pos = (poss + exaequos), exaequos = exaequos, nturns = nturns, firstispeak = firstispeak, peaks = peaks, pits = pits, tppos = tppos, proba = proba, info = info) class(res) <- "turnpoints" res } # ------------------------------------------------------------------------------ .extract.turnpointsPastecs <- function(e, n, no.tp = 0, peak = 1, pit = -1, ...) { if (missing(n)) n <- -1 res <- rep(no.tp, length.out= e$n) res[e$pos[e$peaks]] <- peak res[e$pos[e$pits]] <- pit # Keep only the first n points if (n < length(res) & n > 0) res <- res[1:n] res } # ------------------------------------------------------------------------------ .plot.turnpointsPastecs <- function(x, level = 0.05, lhorz = TRUE, lcol = 2, llty = 2, type = "l", xlab = "data number", ylab = paste("I (bits), level = ", level*100, "%", sep = ""), main = paste("Information (turning points) for:",x$data), ...) { # The next function actually draws the graph turnpoints.graph <- function(X, Level, Lhorz, Lcol, Llty, Type, Xlab, Ylab, Main, Sub, ...) { plot(X$tppos, X$info, type = Type, xlab = Xlab, ylab = Ylab, main = Main, ...) abline(h = -log(Level, base = 2), lty = Llty, col = Lcol) } # Return Value: invisible(turnpoints.graph(x, level[1], lhorz, lcol, llty, type, xlab, ylab, main, ...)) } # ------------------------------------------------------------------------------ .summary.turnpointsPastecs <- function(object, ...) { cat("Turning points for:", object$data, "\n\n") cat("nbr observations :", object$n, "\n") cat("nbr ex-aequos :", sum(object$exaequos), "\n") if (object$firstispeak) { cat("nbr turning points:", object$nturns, "(first point is a peak)\n") typep <- c("peak", "pit") } else { cat("nbr turning points:", object$nturns, "(first point is a pit)\n") typep <- c("pit", "peak") } cat("E(p) =", 2 / 3 * (object$n - 2), "Var(p) =", (16 * object$n - 29) / 90, "(theoretical)\n") cat("\n") # construct the table summarizing all turning points typepts <- rep(typep, length.out=object$nturns) tablepts <- as.data.frame(list(point = object$tppos, type = typepts, proba = object$proba, info = object$info)) print(tablepts) # Return Value: invisible(object) } ################################################################################ .turnpointsSeries = function(...) { # Deprecated: .Deprecated(new = "turns") # Return Value: turns(...) } ################################################################################ timeSeries/R/fin-spreads.R0000644000176000001440000000404211560011674015153 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # spreads Computes spreads from a 'timeSeries' object # midquotes Computes mid quotes from a 'timeSeries' object ################################################################################ # DW: # Setting bid and ask for column names is maybe ot the best coice. Examples # are the TED spread or the Libo OIS spread. The spread between High and Low # is the range. # ------------------------------------------------------------------------------ spreads = function(x, which = c("Bid", "Ask"), tickSize = NULL) { # A function implemented by Diethelm Wuertz # Description: # Computes spreads from a 'timeSeries' object # FUNCTION: # Compute Spread: Spread = x[, which[2]] - x[, which[1]] if (!is.null(tickSize)) series(Spread) = round(series(Spread)/tickSize) # Return Value: Spread } # ------------------------------------------------------------------------------ midquotes = function(x, which = c("Bid", "Ask")) { # A function implemented by Diethelm Wuertz # Description: # Computes mid quotes from a 'timeSeries' object # FUNCTION: # Compute Mid Quotes: midQuotes = 0.5 * ( x[, which[1]] + x[, which[2]] ) # Return Value: midQuotes } ################################################################################ timeSeries/R/fin-splits.R0000644000176000001440000000627111560011674015036 0ustar ripleyusers # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # outlier,timeSeries Removes outliers from a 'timeSeries' object ################################################################################ # DW: # We should call this function no loger outlier, much better woud be # splits() since thefunction tries to detect splits by large outliers. # For outlier detection we should use better methods than just the sd(). # ------------------------------------------------------------------------------ setMethod("outlier", "ANY", function(x, sd = 5, complement = TRUE, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns outliers # Arguments: # x - a numeric vector # sd - a numeric value of standard deviations, e.g. 5 # means that values larger or smaller tahn five # times the standard deviation of the series will # be detected. # complement - a logical flag, should the outlier series # or its complements be returned. # Note: # This function is thought to find splits in financial # price or index series If a price or index is splitted we # observe in the returns a big jump of several standard # deviations which is identified usual as an outlier. # FUNCTION: # Find Outliers: SD = sd * sd(x) if (complement) { ans = x[x <= SD] } else { ans = x[x > SD] names(ans) = as.character(which(x > SD)) } # Return Value: ans }) # ------------------------------------------------------------------------------ setMethod("outlier", "timeSeries", function(x, sd = 10, complement = TRUE, ...) { # A function implemented by Diethelm Wuertz # Description: # Returns outliers in a timeSeries object or the complement # Arguments: # x - an object of class 'timeSeries'. # sd - a numeric value of standard deviations, e.g. 10 # means that values larger or smaller tahn ten # times the standard deviation of the series will # be removed. # complement - a logical flag, should the outler series # or its complement be returned. # FUNCTION: # Check if univariate Series: if (!isUnivariate(x)) stop("Supports only univariate timeSeries Objects") # Find Outliers: SD = sd * sd(x) if (complement) { x = x[abs(x) <= SD,] } else { x = x[abs(x) > SD,] } # Return Value: x }) ################################################################################ timeSeries/R/fin-runlengths.R0000644000176000001440000000357411560011674015714 0ustar ripleyusers # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # runlengths Returns 'timeSeries' object of runlengths ################################################################################ runlengths <- function(x, ...) { # A function implemetned by Diethelm Wuertz # Description: # Returns 'timeSeries' object of runlengths # Arguments: # x - an univariate 'timeSeries' object of financial returns # ... - arguments passed to the function na.omit() # Value: # runlengths an object of class 'timeSeries'. # Note: # Zeroes are handled as NA. # Example: # set.seed(4711) # x.tS = timeSeries(data=rnorm(12), charvec=timeCalendar(), units="x") # runlengths(x.tS) # FUNCTION: # Handle Missing Values: stopifnot(isUnivariate(x)) x[x == 0] <- NA x.vec = sign(as.vector(na.omit(x, ...))) # Compute Run Lengths: n <- length(x.vec) y <- x.vec[-1L] != x.vec[-n] Index <- c(which(y | is.na(y)), n) X = x[Index, ] series(X) <- matrix(diff(c(0L, Index)), ncol = 1) # Reset recordIDs X@recordIDs <- data.frame() # Return Value: X } ################################################################################ timeSeries/R/fin-returns.R0000644000176000001440000001004011370220766015212 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # returns,ANY Computes returns from a 'matrix' object # returns,timeSeries Computes returns from a 'timeSeries' object # OLD FUNCTIONS: KEEP THESE FUNCTIONS FOR COMPATIBILITY: # returnSeries Deprecated, use returns() # getReturns Deprecated, use returns() ################################################################################ setMethod("returns", "ANY", function(x, method = c("continuous", "discrete", "compound", "simple"), percentage = FALSE, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Computes returns from a 'matrix' object # Arguments: # x - data object containing ordered price observations # method - "continuous == "compound" and "discrete" == "simple" # percentage # Note: # To make it conform with PortfolioAnalytics: # "compound" == "continuous" # "simple" == "discrete" # FUNCTION: # Settings: method <- match.arg(method) # Calculate Returns: data <- as.matrix(x) positions <- time(x) if(method == "compound" || method == "continuous") { data <- rbind( data[1, , drop = FALSE]*NA, apply(log(data), 2, diff)) } if(method == "simple" || method == "discrete") { data <- apply(rbind(data, NA*data[1,]), 2, diff) / data data <- rbind(data[1, , drop = FALSE]*NA, data) data <- data[-(length(positions) + 1), , drop = FALSE] } if (percentage) data <- 100*data # Return Value: data } ) # ------------------------------------------------------------------------------ setMethod("returns", "timeSeries", function(x, method = c("continuous", "discrete", "compound", "simple"), percentage = FALSE, na.rm = TRUE, trim = TRUE, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Returns the returns of an object of class 'timeSeries' # Arguments: # x - an object of class 'timeSeries' # method - # percentage - # na.rm - # trim - # FUNCTION: # Make sure that series is ordered x <- sort(x) # Get Returns: if (na.rm) x <- na.omit(x, ...) series(x) <- returns(as(x, "matrix"), method, percentage) if (trim) x <- na.omit(x, "r") # Return Value: x } ) # ------------------------------------------------------------------------------ returnSeries <- function(...) { # A function implemented by Diethelm Wuertz # Description: # Arguments: # FUNCTION: # .Deprecated("returns", "timeSeries") returns(...) } # ------------------------------------------------------------------------------ getReturns <- function(...) { # A function implemented by Diethelm Wuertz # Description: # Computes returns # Arguments: # ... - passed to function returns # FUNCTION: # .Deprecated("returns", "timeSeries") # Return Value: returns(...) } ################################################################################ timeSeries/R/fin-periodical.R0000644000176000001440000002041311560011674015625 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # .endOfPeriodSeries Returns series back to a given period # .endOfPeriodStats Returns statistics back to a given period # .endOfPeriodBenchmarks Returns benchmarks back to a given period ################################################################################ .endOfPeriodSeries <- function(x, nYearsBack = c("1y", "2y", "3y", "5y", "10y", "YTD"), aggregate = c("monthly", "quarterly"), align = TRUE) { # A function implemented by Diethelm Wuertz # Description: # Returns series back to a given period # Arguments: # x - a daily 'timeSeries' object of returns # nYearsBack - a period string. How long back should the series # be extracted? Options include values from 1 year to 10 years. # and year to date: "1y", "2y", "3y", "5y", "10y", "YTD". # aggregate - a character string which defines the aggregation level, # either "monthly", the default value, or "quarterly". # align - a logical flag, should the time series be aligned? # If TRUE the function alignDailySeries() will be applied. # Note: # Add "1m" # FUNCTION: # Check: stopifnot(is.timeSeries(x)) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Should the series be aligned: if (align) x <- alignDailySeries(x) # Match Arguments: nYearsBack <- match.arg(nYearsBack) aggregate <- match.arg(aggregate) # Settings: if (nYearsBack == "YTD") yearsBack = 0 else if (nYearsBack == "1y") yearsBack = 1 else if (nYearsBack == "2y") yearsBack = 2 else if (nYearsBack == "3y") yearsBack = 3 else if (nYearsBack == "5y") yearsBack = 5 else if (nYearsBack == "10y") yearsBack = 10 currentYear <- getRmetricsOptions("currentYear") Year <- currentYear - yearsBack fromDate <- timeDate(paste(Year, "-01-01", sep = "")) if (yearsBack == 0) { toDate <- end(x) } else { toDate <- timeDate(paste(currentYear-1, "-12-31", sep = "")) } # Are there enough Data Points? stopifnot(start(x) < fromDate) # ReturnValue: cut(x, fromDate, toDate) } # ------------------------------------------------------------------------------ .endOfPeriodStats <- function(x, nYearsBack = c("1y", "2y", "3y", "5y", "10y", "YTD"), aggregate = c("monthly", "quarterly"), align = TRUE) { # A function implemented by Diethelm Wuertz # Description: # Returns series statistics back to a given period # Arguments: # x - a daily 'timeSeries' object of returns # nYearsBack - a period string. How long back should the series # be extracted? Options include values from 1 year to 10 years. # and year to date: "1y", "2y", "3y", "5y", "10y", "YTD". # aggregate - a character string which defines the aggregation level, # either "monthly", the default value, or "quarterly". # align - a logical flag, should the time series be aligned? # If TRUE the function alignDailySeries() will be applied. # Note: # Add "1m" # FUNCTION: # Check: stopifnot(is.timeSeries(x)) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Match Arguments: nYearsBack = match.arg(nYearsBack) aggregate <- match.arg(aggregate) # Should the series be aligned: if (align) x = alignDailySeries(x) # Series: Series = .endOfPeriodSeries(x, nYearsBack = nYearsBack, aggregate = aggregate, align = FALSE) # Internal Function: .cl.vals <- function(x, ci) { x = x[!is.na(x)] n = length(x) if (n <= 1) return(c(NA, NA)) se.mean = sqrt(var(x)/n) t.val = qt((1 - ci)/2, n - 1) mn = mean(x) lcl = mn + se.mean * t.val ucl = mn - se.mean * t.val c(lcl, ucl) } # Statistics: for (i in 1:ncol(Series)) { # Basic Statistics: X = as.vector(Series[, i]) X.length = length(X) X = X[!is.na(X)] X.na = X.length - length(X) ci = 0.95 z = c(X.length, X.na, min(X), max(X), as.numeric(quantile(X, prob = 0.25, na.rm = TRUE)), as.numeric(quantile(X, prob = 0.75, na.rm = TRUE)), mean(X), median(X), sum(x), sqrt(var(X)/length(X)), .cl.vals(X, ci)[1], .cl.vals(X, ci)[2], var(X), sqrt(var(X)), skewness(X), kurtosis(X)) znames = c("nobs", "NAs", "Minimum", "Maximum", "1. Quartile", "3. Quartile", "Mean", "Median", "Sum", "SE Mean", "LCL Mean", "UCL Mean", "Variance", "Stdev", "Skewness", "Kurtosis") stats1 = matrix(z, ncol = 1) row.names(stats) = znames # Monthly Return Statistics: xData = as.vector(x) noNegativePeriods = length(xData[xData < 0 ]) noPositivePeriods = length(xData[xData > 0 ]) stats1 = rbind(stats1, worstPeriod = min(xData), negativeValues = noNegativePeriods, positiveValues = noPositivePeriods) MaximumDrawdown = NA TimeUnderWater = NA AnnualizedVolatility = NA SharpeRatio = NA InformationRatio = NA ValueAtRisk = NA ExpectedShortfall = NA # Bind: if (i > 1) { stats <- cbind.data.frame(stats, stats1) } else { stats <- stats1 } } # Return Value: stats } # ------------------------------------------------------------------------------ .endOfPeriodBenchmarks <- function(x, benchmark = ncol(x), nYearsBack = c("1y", "2y", "3y", "5y", "10y", "YTD"), aggregate = c("monthly", "quarterly"), align = TRUE) { # A function implemented by Diethelm Wuertz # Description: # Returns benchmarks back to a given period # Arguments: # x - a daily 'timeSeries' object of returns # nYearsBack - a period string. How long back should the series # be extracted? Options include values from 1 year to 10 years. # and year to date: "1y", "2y", "3y", "5y", "10y", "YTD". # aggregate - a character string which defines the aggregation level, # either "monthly", the default value, or "quarterly". # align - a logical flag, should the time series be aligned? # If TRUE the function alignDailySeries() will be applied. # Note: # Add "1m" # FUNCTION: # Checks: stopifnot(is.timeSeries(x)) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Match Arguments: nYearsBack <- match.arg(nYearsBack) aggregate <- match.arg(aggregate) # Should the series be aligned: if (align) x <- alignDailySeries(x) # Series: Series <- .endOfPeriodSeries(x[, -benchmark], nYearsBack = nYearsBack, aggregate = aggregate, align = FALSE) y <- Benchmark <- .endOfPeriodSeries(x[, benchmark], nYearsBack = nYearsBack, aggregate = aggregate, align = FALSE) stats <- NULL for (i in 1:ncol(Series)) { # Gdet Series: x <- Series[, i] # Compute Statistics: stats1 <- c( TrackingError = NA, Alpha = NA, Beta = NA, CorrelationToBenchmark = NA) # Bind Results: stats <- rbind(stats, stats1) } # Return Value: invisible() } ################################################################################ timeSeries/R/fin-monthly.R0000644000176000001440000001162011560011674015204 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: FOR MONTHLY OPERATIONS: # countMonthlyRecords Returns a series with monthly counts of records # rollMonthlyWindows Returns start/end dates for rolling time windows # rollMonthlySeries Rolls Monthly a 'timeSeries' on a given period ################################################################################ # DW: # I think we should call these functions: # countRecordsMonthly, rollWindowsMonthly, rollSeriesMonthly, ... # ------------------------------------------------------------------------------ countMonthlyRecords <- function(x) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Returns a series with monthly counts of records # Example: # x = as.timeSeries(data(msft.dat)); countMonthlyRecords(x) # x = as.timeSeries(data(edhec)); countMonthlyRecords(x) # FUNCTION: stopifnot(is(x, "timeSeries")) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Count: ans <- rollMonthlySeries(x[, 1], period = "1m", by = "1m", FUN = NROW) colnames(ans) <- "Counts" # Return Value: ans } # ------------------------------------------------------------------------------ rollMonthlyWindows <- function(x, period = "12m", by = "1m") { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Returns start and end dates for rolling time windows # Arguments: # x - a 'timeSerie's object of asset returns # period - a character string denoting the length of the rolling # window, e.g. "24m" means 24 months # by - a character string denoting the shift of the rolling window, # e.g. "3m" means one quarter # FUNCTION: stopifnot(is(x, "timeSeries")) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Get Window Parameter: periodLength <- as.numeric(substr(period, 1, nchar(period)-1)) periodUnit <- substr(period, nchar(period), nchar(period)) byLength <- as.numeric(substr(by, 1, nchar(by)-1)) byUnit <- substr(by, nchar(by), nchar(by)) stopifnot(periodUnit == "m") stopifnot(byUnit == "m") # Get Window Parameter: periodLength <- as.numeric(substr(period, 1, nchar(period)-1)) periodUnit <- substr(period, nchar(period), nchar(period)) byLength <- as.numeric(substr(by, 1, nchar(by)-1)) byUnit <- substr(by, nchar(by), nchar(by)) stopifnot(periodUnit == "m") stopifnot(byUnit == "m") # Make Windows - We expect monthly data records ... positions <- time(x) Positions <- unique(timeFirstDayInMonth(positions)) numberOfPositions <- length(Positions) startDates <- Positions[1:(numberOfPositions-periodLength)] endDates <- Positions[(periodLength+1):numberOfPositions]-24*3600 # Windows: windows <- list(from = startDates, to = endDates) attr(windows, "control") = c(start = start(positions), end = end(positions)) # Return Value: windows } # ------------------------------------------------------------------------------ rollMonthlySeries <- function(x, period = "12m", by = "1m", FUN, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Rolls monthly a 'timeSeries' on a given period # Arguments: # x - a 'timeSerie's object of asset returns # period - a character string denoting the length of the rolling # window, e.g. "24m" means 24 months # by - a character string denoting the shift of the rolling window, # e.g. "3m" means one quarter # FUN - function to be applied # FUNCTION: stopifnot(is(x, "timeSeries")) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Settings: windows <- rollMonthlyWindows(x = x[, 1], period = period, by = by) # Apply Function: ans <- applySeries(x = x, from = windows$from, to = windows$to, FUN = FUN, ...) # Return Value: ans } ################################################################################ timeSeries/R/fin-durations.R0000644000176000001440000000427111560011674015526 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: FINANCIAL TIME SERIES: # durations Computes durations from a 'timeSeries' object ################################################################################ durations <- function(x, trim = FALSE, units = c("secs", "mins", "hours", "days")) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Computes durations from a financial price series # Arguments: # x - a univariate or multivariate 'timeSeries' object or a # numeric vector or matrix. # trim - a logical flag, by default TRUE, the first missing # observation in the return series will be removed. # units - a character value or vector which allows to set the # units in which the durations are measured # Value: # Returns a S4 object of class 'timeSeries'. # FUNCTION: # Check for 'timeSeries' Object: stopifnot(is(x, "timeSeries")) # Check for Signal Series: if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Match Arguments: units <- match.arg(units) # Get Positions and Durations: pos <- time(x) dur <- c(NA, diff(as.integer(difftime(pos, pos[1], units = units[1])))) # Data Matrix: ans <- timeSeries(data = dur, charvec = pos, units = "Duration") if (trim) ans <- ans[-1, ] # Return Series: ans } ################################################################################ timeSeries/R/fin-drawdowns.R0000644000176000001440000001461211731422661015530 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # drawdowns Generate 'timeSeries' object of drawdown levels # drawdownsStats Compute drawdown stats for univariate time series # FUNCTION: DESCRIPTION: # .drawdownsHistPlot Displays a histogram plot ################################################################################ drawdowns <- function(x, ...) { # A function implemented by Diethelm Wuertz and Tobias Setz # Description: # Generate 'timeSeries' object of drawdown levels # Arguments: # x - an uni- or multivariate 'timeSeries' object of financial # returns # ... - arguments passed to the function na.omit() # Value: # returns an object of class 'timeSeries'. # FUNCTION: # Handle Missing Values: r <- na.omit(x, ...) # The starting point of every time series is set to zero. # This ensures that the starting value for cumprodReturns below # (which is the wealth index) is 1. startup <- timeSeries(data=t(rep(0, ncol(r))), charvec=time(r)[1]) # Preset Drawdowns: nms <- colnames(r) drawdowns <- r <- rbind(startup,r) colnames(drawdowns) <- colnames(r) <- nms # Compute multivariate 'timeSeries' of Drawdowns: cumprodReturns <- colCumprods(1 + r) cummaxReturns <- colCummaxs(cumprodReturns) series(drawdowns) <- series(cumprodReturns)/series(cummaxReturns) - 1 drawdowns <- drawdowns[-1, ] # Return Value: drawdowns } # ------------------------------------------------------------------------------ drawdownsStats = function(x, ...) { # A function implemented by Diethelm Wuertz and Tobias Setz # Description: # Finds the drawdowns in an univariate 'timeSeries' object # Arguments: # x - an uni- or multivariate 'timeSeries' object of financial # returns # ... - arguments passed to the function drawdowns() # Value: # returns an object of class 'data.frame' returning # drawdown - the depth of the drawdown # from - the start date # trough - the trough period # to - the end date # length - the length in number of records # peaktrough - the peak trough # recovery - the recovery length in number of records # Author: # Based on Peter Carl, # partly from contributed R package Performance Analytics # Note: # modified with permission from function by Sankalp Upadhyay # # Examples: # x = drawdownsStats(as.timeSeries(data(edhec))[,1]) # FUNCTION: # Check Arguments: stopifnot(isUnivariate(x)) # Compute Drawdowns: drawdowns <- as.vector(drawdowns(x, ...)) time <- time(x) # Find Drawdowns from a Numeric Vector of Returns: draw <- begin <- end <- length <- trough <- c() index <- 1 if (drawdowns[1] >= 0) { priorSign <- 1 } else { priorSign <- 0 } from <- 1 sofar <- drawdowns[1] to <- 1 dmin <- 1 for (i in 2:length(drawdowns)) { thisSign <- ifelse(drawdowns[i] < 0, 0, 1) if (thisSign == priorSign) { if(drawdowns[i]< sofar) { sofar <- drawdowns[i] dmin <- i } to <- i + 1 } else { # @todo: recovery time (in days) draw[index] <- sofar begin[index] <- from trough[index] <- dmin end[index] <- to #cat(sofar, from, to) from <- i sofar <- drawdowns[i] to <- i + 1 dmin <- i index <- index + 1 priorSign <- thisSign } } draw[index] <- sofar begin[index] <- from trough[index] <- dmin end[index] <- to ## length: as.timeDate(pos[x$to])-as.timeDate(pos[x$from]) # If the time series ends in the middle of a drawdown, return the last # date of the time series and set the recovery time to NA endt <- end; endr <- end; if(to > length(time)) { endt[index] <- to - 1 endr[index] <- NA } # Result - an index list with all drawdowns ... ans <- data.frame(from = as.vector(as.character(time[begin])), trough = as.vector(as.character(time[trough])), to = as.vector(as.character(time[endt])), drawdown = as.vector(draw), length = (end - begin + 1), peaktotrough = (trough - begin + 1), recovery = (endr - trough), stringsAsFactors = FALSE) attr(ans, "series") <- x attr(ans, "names") <- c("From", "Trough", "To", "Depth", "Length", "ToTrough", "Recovery") ans <- ans[ans[, "Depth"] < 0, ] # Order Drawdowns: ans <- ans[order(ans[, "Depth"]), ] rownames(ans) <- 1:dim(ans)[1] # Return Value: ans } # ------------------------------------------------------------------------------ if (FALSE) { .drawdownsHistPlot <- function(x, labels = TRUE, col = "steelblue", add.fit = TRUE, rug = TRUE, skipZeros = TRUE, ...) { # Note: # We require(fExtremes) move this function to fAssets # Check Arguments: stopifnot(isUnivariate(x)) # Plot Drawdowns Histogram: X = drawdowns(x, ...) histPlot(X, labels = labels, col = col, add.fit = FALSE, rug = rug, skipZeros = skipZeros, ...) # Add GPD Fit: if (add.fit) { z = -as.vector(X) par = gpdFit(z, u = 0)@fit$par.ests u = seq(0, max(abs(z)), length = 200) v = dgpd(u, xi = par[1], mu = 0, beta = par[2]) lines(-u, v, col = "brown", lwd = 2) } # return Value: invisible() } } ################################################################################ timeSeries/R/fin-daily.R0000644000176000001440000001720011731573615014624 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # alignDailySeries Aligns a 'timeSeries' object to new positions # rollDailySeries Rolls daily a 'timeSeries' on a given period # ohlcDailyPlot Plots open high low close bar chart # .plotOHLC Internal called by function ohlcDailyPlot() ################################################################################ alignDailySeries <- function (x, method = c("before", "after", "interp", "fillNA", "fmm", "periodic", "natural", "monoH.FC"), include.weekends = FALSE, units = NULL, zone = "", FinCenter = "", ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Aligns a 'timeSeries' object to new positions # Arguments: # x - an object of class "timeSeries". # method - # "before" - use the data from the row whose position is # just before the unmatched position; # "after" - use the data from the row whose position is # just after the unmatched position; # "linear" - interpolate linearly between "before" and # "after". # "fillNA" - fill missing days with NA values # include.weekends - a logical value. Should weekend dates be # included or removed? # Note: alignDailySeries is now based on align timeSeries method. # adjust zone and FinCenter if provided if (zone != "" || FinCenter != "") { if (zone == "") zone <- getRmetricsOptions("myFinCenter") if (FinCenter == "") FinCenter <- getRmetricsOptions("myFinCenter") x <- timeSeries(x, zone = zone, FinCenter = FinCenter) } # FUNCTION: ans <- .align.timeSeries(x = x, by = "1d", offset = "0s", method = method, include.weekends = include.weekends, ...) # Add New Units: if (!is.null(units)){ colnames(ans) = units } # Return Value: ans } # ------------------------------------------------------------------------------ rollDailySeries <- function(x, period = "7d", FUN, ...) { # A function implemented by Diethelm Wuertz # Description: # Rolls daily a 'timeSeries' on a given period # Arguments: # x - an univariate "timeSeries" object or a numeric vector. # n - an integer specifying the number of periods or # terms to use in each rolling/moving sample. # trim - a logical flag: if TRUE, the first n-1 missing values in # the returned object will be removed; if FALSE, they will # be saved in the returned object. The default is TRUE. # FUN - the rolling function, arguments to this function can be # passed through the \code{\dots} argument. # FUNCTION: stopifnot(is.timeSeries(x)) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Fix missing matrix method for quantile(), still to do ... .quantile.matrix = function(x, probs = 0.95, ...) { apply(as.matrix(x), 2, quantile, probs = probs) } # Settings: periodLength = as.numeric(substr(period, 1, nchar(period) - 1)) periodUnit = substr(period, nchar(period), nchar(period)) N = nrow(x) Start = start(x) + (periodLength-1)*24*3600 Positions = time(x) to = Positions[Positions > Start] from = to - periodLength*24*3600 # Apply Function: ans = applySeries(x = x, from = from, to = to, FUN = FUN, ...) # Return Value: ans } # ------------------------------------------------------------------------------ ohlcDailyPlot <- function(x, volume = TRUE, colOrder = c(1:5), units = 1e6, xlab = c("Date", "Date"), ylab = c("Price", "Volume"), main = c("O-H-L-C", "Volume"), grid.nx = 7, grid.lty = "solid", ...) { # A function implemented by Diethelm Wuertz # Description: # Plots open | high | low | close bar chart # Arguments: # x - an S4 object of class 'timeSeries' with named entries: # Open, High, Low, Close, and Volume # Reference: # Build on top of Adrian Trapletti's plotOHLC() # function from his R-package "tseries". # FUNCTION: stopifnot(is.timeSeries(x)) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Next: x.filled = alignDailySeries(x, method = "fillNA", include.weekends = TRUE) jul = as.integer(julian(time(x.filled))) X = ts(as.matrix(x.filled)[, 1:4], start = min(jul), end = max(jul)) # Plot OHLC: .plotOHLC(X, origin = "1970-01-01", xlab = xlab[1], ylab = ylab[1]) # print(axTicks(1)) # print(axTicks(2)) title(main = main[1]) grid(nx = grid.nx, ny = NULL, lty = grid.lty, ...) # Include Volume? if (volume) { Volume = x[, 5]/units plot(Volume, type = "h", xlab = xlab[2], ylab = ylab[2]) title(main = main[2]) grid(nx = grid.nx, ny = NULL, lty = grid.lty, ...) } # Return value: invisible() } # ------------------------------------------------------------------------------ .plotOHLC = function (x, xlim = NULL, ylim = NULL, xlab = "Time", ylab, col = par("col"), bg = par("bg"), axes = TRUE, frame.plot = axes, ann = par("ann"), main = NULL, date = c("calendar", "julian"), format = "%Y-%m-%d", origin = "1899-12-30", ...) { # A Copy from Contributed R Package 'tseries' # Description: # Internal called by function ohlcDailyPlot() # FUNCTION: # Check for mts: if ((!is.mts(x)) || (colnames(x)[1] != "Open") || (colnames(x)[2] != "High") || (colnames(x)[3] != "Low") || (colnames(x)[4] != "Close")) stop("x is not a open/high/low/close time series") xlabel <- if (!missing(x)) deparse(substitute(x)) else NULL if (missing(ylab)) ylab <- xlabel date <- match.arg(date) time.x <- time(x) dt <- min(lag(time.x) - time.x)/3 if (is.null(xlim)) xlim <- range(time.x) if (is.null(ylim)) ylim <- range(x[is.finite(x)]) plot.new() plot.window(xlim, ylim, ...) segments(time.x, x[, "High"], time.x, x[, "Low"], col = col[1], bg = bg) segments(time.x - dt, x[, "Open"], time.x, x[, "Open"], col = col[1], bg = bg) segments(time.x, x[, "Close"], time.x + dt, x[, "Close"], col = col[1], bg = bg) if (ann) title(main = main, xlab = xlab, ylab = ylab, ...) if (axes) { if (date == "julian") { axis(1, ...) axis(2, ...) } else { n <- NROW(x) lab.ind <- round(seq(1, n, length = 5)) D <- as.vector(time.x[lab.ind] * 86400) + as.POSIXct(origin, tz = "GMT") DD <- format.POSIXct(D, format = format, tz = "GMT") axis(1, at = time.x[lab.ind], labels = DD, ...) axis(2, ...) } } if (frame.plot) box(...) # Return Value: invisible() } ################################################################################ timeSeries/R/fin-cumulated.R0000644000176000001440000000527711370220766015513 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # cumulated Computes cumulated series from financial returns # cumulated.default Computes cumulated series, default method ################################################################################ cumulated <- function(x, ...) { # A function implemented by Diethelm Wuertz # Description: # Computes cumulated series from financial returns # Return Value: UseMethod("cumulated") } # ------------------------------------------------------------------------------ cumulated.default <- function(x, method = c("continuous", "discrete", "compound", "simple"), percentage = FALSE, ...) { # A function implemented by Diethelm Wuertz # Description: # Computes cumulated series from financial returns # supports 'matrix' and 'timeSeries'. # Arguments: # x - data object containing ordered price observations # method - "continuous == "compound" and "discrete" == "simple" # Example: # X = as.timeSeries(data(msft.dat))[1:10, "Close"]; X = X/series(X)[1, 1] # x = returns(X, "continuous"); x; X; cumulated(x, "continuous") # x = returns(X, "discrete"); x; X; cumulated(x, "discrete") # Note: # To make it conform with PortfolioAnalytics: # "compound" == "continuous", and "simple" == "discrete" # FUNCTION: # Settings: method = match.arg(method) # Handle Missing Values: # if (na.rm) x = na.omit(x, ...) # Transform data: if (percentage) x = x/100 positions = time(x) # Calculate Returns: # ... colCumsums and colCumprods are generic functions with # methods for 'matrix' and 'timeSeries'. if(method == "geometric") { ans = colCumsums(x) } if(method == "compound" || method == "continuous") { ans = exp(colCumsums(x)) } if(method == "simple" || method == "discrete") { ans = colCumprods(1+x) } # Return Value: ans } ################################################################################ timeSeries/R/fin-align.R0000644000176000001440000001052211656243252014611 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # align Aligns a 'timeSeries object' to time stamps # .align.timeSeries Aligns a 'timeSeries object' to time stamps ################################################################################ # DW: See also ... # in package timeDate # setMethod("align", "ANY", # setMethod("align", "timeDate", # ------------------------------------------------------------------------------ .align.timeSeries <- function(x, by = "1d", offset = "0s", method = c("before", "after", "interp", "fillNA", "fmm", "periodic", "natural", "monoH.FC"), include.weekends = FALSE, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Aligns a 'timeSeries' object to equidistant time stamps # Arguments: # x - an object of class "timeSeries". # method - # "before" - use the data from the row whose position is # just before the unmatched position; # "after" - use the data from the row whose position is # just after the unmatched position; # "linear" - interpolate linearly between "before" and # "after". # "fillNA" - fill missing days with NA values # include.weekends - a logical value. Should weekend dates be # included or removed? # Example: # data(usdthb) # data = matrix(usdthb[, "BID"]) # charvec = as.character(usdthb[, "XDATE"]) # USDTHB = timeSeries(data, charvec, format = "%Y%M%d%H%M") # align(USDTHB, by = "3h", offset = "92m") # MSFT = as.timeSeries(data(msft.dat)) # align(MSFT) # See also: # in package timeDate # setMethod("align", "ANY", # setMethod("align", "timeDate", # FUNCTION: if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # check if series sorted if (is.unsorted(x)) x <- sort(x) # adjustment: Method <- match.arg(method) fun <- switch(Method, before = function(x, u, v) approxfun(x = u, y = v, method = "constant", f = 0, ...)(x), after = function(x, u, v) approxfun(x = u, y = v, method = "constant", f = 1, ...)(x), interp = , fillNA = function(x, u, v) approxfun(x = u, y = v, method = "linear", f = 0.5, ...)(x), fmm = , periodic = , natural = , monoH.FC = function(x, u, v) splinefun(x = u, y = v, method = Method, ...)(x)) # Align timeDate stamps td1 <- time(x) td2 <- align(td1, by = by, offset = offset) # extract numerical values u <- as.numeric(td1, units = "secs") xout <- as.numeric(td2, units = "secs") N = NCOL(x) data <- matrix(ncol = N, nrow = length(td2)) xx <- getDataPart(x) for (i in 1:N) { v <- as.vector(xx[, i]) # New Positions and approximated values: yout <- fun(xout, u, v) if (Method == "fillNA") yout[!(xout %in% u)] = NA # Compose data: data[, i] = yout } # build time series ans <- timeSeries(data, td2, units = colnames(x)) # Remove Weekends: if(!include.weekends) ans <- ans[isWeekday(td2), ] # Return Value: ans } # ------------------------------------------------------------------------------ setMethod("align", "timeSeries", .align.timeSeries) ################################################################################ timeSeries/R/data-examples.R0000644000176000001440000000000011560011674015453 0ustar ripleyuserstimeSeries/R/base-t.R0000644000176000001440000000177311560011674014123 0ustar ripleyusers # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # t,timeSeries Returns the transpose of timeSeries object ################################################################################ setMethod("t", "timeSeries", function(x) callGeneric(getDataPart(x))) ################################################################################ timeSeries/R/base-subsetting.R0000644000176000001440000005375612010147761016055 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # METHOD: SUBSETTING METHODS ON DATA: # .subset_timeSeries # .findIndex # $,timeSeries Subsets a time series by column names # $<-,timeSeries Replaces subset by column names # [,timeSeries Subsets a time series object # [<-,timeSeries Assigns value to subsets of a time series ################################################################################ ################################################################################ # index ################################################################################ # Note : no "character" -> because needs to be coerced to timeDate object. setClassUnion("index_timeSeries", members = c("numeric", "logical")) setClassUnion("time_timeSeries", members = c("POSIXt", "Date")) # ------------------------------------------------------------------------------ .subset_timeSeries <- function(x, i, j) { stopifnot(inherits(x, "timeSeries")) stopifnot(is(i, "index_timeSeries")) stopifnot(is(j, "index_timeSeries")) # subset data and positions t <- try(data <- .subset(x, i, j, drop = FALSE), silent = TRUE) if (inherits(t, "try-error")) { # cast error and remove calling function msg <- sub("Error in.*: \n *", "", t) stop(msg, call. = FALSE) } pos <- if (length(x@positions)>0) .subset(x@positions, i) else numeric(0) units <- .subset(x@units, j) # Record IDs: df <- x@recordIDs if (prod(dim(df))) df <- df[i, , drop = FALSE] # Result new("timeSeries", .Data = data, title = x@title, documentation = x@documentation, format = x@format, FinCenter = x@FinCenter, units = units, recordIDs = df, positions = pos) } # ------------------------------------------------------------------------------ .findIndex <- function(ipos, pos) { attributes(ipos) <- NULL if (unsorted <- is.unsorted(pos)) { or <- order(pos) pos <- pos[or] } i <- findInterval(ipos, pos) if (!identical(ipos, pos[i])) stop("subscript out of bounds", call. = FALSE) if (unsorted) i <- or[i] i } ################################################################################ # [,timeSeries Subsets of a 'timeSeries' object ################################################################################ ## i <- c("index_timeSeries", "character", "timeDate", ## "timeSeries", "missing", "ANY") ## j <- c("index_timeSeries", "character", "timeSeries", ## "missing", "ANY") ## expand.grid(i = i, j = j) ## > i j ## 1 index_timeSeries index_timeSeries ## 2 character index_timeSeries ## 3 timeDate index_timeSeries ## 4 timeSeries index_timeSeries ## 5 missing index_timeSeries ## 6 ANY index_timeSeries ## 7 index_timeSeries character ## 8 character character ## 9 timeDate character ## 10 timeSeries character ## 11 missing character ## 12 ANY character ## 13 index_timeSeries timeSeries ## 14 character timeSeries ## 15 timeDate timeSeries ## 16 timeSeries timeSeries ## 17 missing timeSeries ## 18 ANY timeSeries ## 19 index_timeSeries missing ## 20 character missing ## 21 timeDate missing ## 22 timeSeries missing ## 23 missing missing ## 24 ANY missing ## 25 index_timeSeries ANY ## 26 character ANY ## 27 timeDate ANY ## 28 timeSeries ANY ## 29 missing ANY ## 30 ANY ANY ## YC : Added i=time_timeSeries i <- "time_timeSeries" j <- c("index_timeSeries", "character", "timeSeries", "missing", "ANY") expand.grid(i = i, j = j) ## 1 time_timeSeries index_timeSeries ## 2 time_timeSeries character ## 3 time_timeSeries timeSeries ## 4 time_timeSeries missing ## 5 time_timeSeries ANY # ------------------------------------------------------------------------------ ## FIXME : deal with signal series # ------------------------------------------------------------------------------ ## 1 index_timeSeries index_timeSeries setMethod("[", signature(x = "timeSeries", i = "index_timeSeries", j = "index_timeSeries"), function(x, i, j, ..., drop = FALSE) .subset_timeSeries(x, i, j)) # ------------------------------------------------------------------------------ ## 2 character index_timeSeries setMethod("[", signature(x = "timeSeries", i = "character", j = "index_timeSeries"), function(x, i, j, ..., drop = FALSE) { td <- timeDate(i) if (any(is.na(td))) return(as.vector(NA)) # bad to use directly @Data but more efficient in this case i <- .findIndex(td@Data, x@positions) .subset_timeSeries(x, i, j) }) # ------------------------------------------------------------------------------ ## 3 timeDate index_timeSeries setMethod("[", signature(x = "timeSeries", i = "timeDate", j = "index_timeSeries"), function(x, i, j, ..., drop = FALSE) { # bad to use directly @Data but more efficient in this case i <- .findIndex(i@Data, x@positions) .subset_timeSeries(x, i, j) }) # ------------------------------------------------------------------------------ ## 4 timeSeries index_timeSeries setMethod("[", signature(x = "timeSeries", i = "timeSeries", j = "index_timeSeries"), function(x, i, j, ..., drop = FALSE) { if (x@format != "counts" && i@format != "counts" && finCenter(x) != finCenter(i)) stop("FinCenter of timeSeries and subset do not match") .subset_timeSeries(x, as.vector(i), j) }) # ------------------------------------------------------------------------------ ## 5 missing index_timeSeries setMethod("[", signature(x = "timeSeries", i = "missing", j = "index_timeSeries"), function(x, i, j, ..., drop = FALSE) .subset_timeSeries(x, TRUE, j)) # ------------------------------------------------------------------------------ ## 6 ANY index_timeSeries setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 7 index_timeSeries character setMethod("[", signature(x = "timeSeries", i = "index_timeSeries", j = "character"), function(x, i, j, ..., drop = FALSE) { j <- pmatch(j, slot(x, "units"), duplicates.ok = TRUE) if (any(is.na(j))) stop("subscript out of bounds", call. = FALSE) .subset_timeSeries(x, i, j) }) # ------------------------------------------------------------------------------ ## 8 character character setMethod("[", signature(x = "timeSeries", i = "character", j = "character"), function(x, i, j, ..., drop = FALSE) { j <- pmatch(j, slot(x, "units"), duplicates.ok = TRUE) if (any(is.na(j))) stop("subscript out of bounds", call. = FALSE) callGeneric(x=x, i=i, j=j, drop=drop) }) # ------------------------------------------------------------------------------ ## 9 timeDate character setMethod("[", signature(x = "timeSeries", i = "timeDate", j = "character"), function(x, i, j, ..., drop = FALSE) { # bad to use directly @Data but more efficient in this case i <- .findIndex(i@Data, x@positions) j <- pmatch(j, slot(x, "units"), duplicates.ok = TRUE) if (any(is.na(j))) stop("subscript out of bounds", call. = FALSE) .subset_timeSeries(x, i, j) }) # ------------------------------------------------------------------------------ ## 10 timeSeries character # inherited method works fine # ------------------------------------------------------------------------------ ## 11 missing character setMethod("[", signature(x = "timeSeries", i = "missing", j = "character"), function(x, i, j, ..., drop = FALSE) { j <- pmatch(j, slot(x, "units"), duplicates.ok = TRUE) if (any(is.na(j))) stop("subscript out of bounds", call. = FALSE) .subset_timeSeries(x, TRUE, j) }) # ------------------------------------------------------------------------------ ## 12 ANY character setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 13 index_timeSeries timeSeries ## 14 character timeSeries ## 15 timeDate timeSeries ## 16 timeSeries timeSeries ## 17 missing timeSeries ## 18 ANY timeSeries ## rely on inherited methods # ------------------------------------------------------------------------------ ## 19 index_timeSeries missing setMethod("[", signature(x = "timeSeries", i = "index_timeSeries", j = "missing"), function(x, i, j, ..., drop = FALSE) { if(nargs() == 2) { # same sub-setting as matrix if(any(as.logical(i)) || prod(dim(x)) == 0) as.vector(x)[i] } else { .subset_timeSeries(x, i, TRUE) } }) # ------------------------------------------------------------------------------ ## 20 character missing setMethod("[", signature(x = "timeSeries", i = "character", j = "missing"), function(x, i, j, ..., drop = FALSE) { if (nargs() == 2) as.numeric(NA) #-> return NA if comma missing else callGeneric(x=x, i=i, j=TRUE) }) # ------------------------------------------------------------------------------ ## 21 timeDate missing setMethod("[", signature(x = "timeSeries", i = "timeDate", j = "missing"), function(x, i, j, ..., drop = FALSE) { # do not return NA if comma missing because timeDate index # bad to use directly @Data but more efficient in this case i <- .findIndex(i@Data, x@positions) .subset_timeSeries(x, i, TRUE) }) # ------------------------------------------------------------------------------ ## 22 timeSeries missing setMethod("[", signature(x = "timeSeries", i = "timeSeries", j = "missing"), function(x, i, j, ..., drop = FALSE) { if (x@format != "counts" && i@format != "counts" && finCenter(x) != finCenter(i)) stop("FinCenter of timeSeries and subset do not match") if(nargs() == 2) { if(any(as.logical(i)) || prod(dim(x)) == 0) as.vector(x)[as.vector(i)] } else { .subset_timeSeries(x, as.vector(i), TRUE) } }) # ------------------------------------------------------------------------------ ## workaround i <- matrix. setMethod("[", signature(x = "timeSeries", i = "matrix", j = "missing"), function(x, i, j, ..., drop = FALSE) { if(nargs() == 2) { # same sub-setting as matrix if(any(as.logical(i)) || prod(dim(x)) == 0) as.vector(x)[i] } else { .subset_timeSeries(x, as.vector(i), TRUE) } }) # ------------------------------------------------------------------------------ ## 23 missing missing setMethod("[", signature(x = "timeSeries", i = "missing", j = "missing"), function(x, i, j, ..., drop = FALSE) x) # ------------------------------------------------------------------------------ ## 24 ANY missing setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 25 index_timeSeries ANY setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 26 character ANY setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 27 timeDate ANY setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 28 timeSeries ANY setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 29 missing ANY setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 30 ANY ANY setMethod("[", signature(x = "timeSeries", i = "ANY", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) stop("invalid or not-yet-implemented 'timeSeries' subsetting")) # ------------------------------------------------------------------------------ ## 1 time_timeSeries index_timeSeries setMethod("[", signature(x = "timeSeries", i = "time_timeSeries", j = "index_timeSeries"), function(x,i,j, ..., drop = FALSE) { i <- timeDate(i) callGeneric(x=x, i=i, j=j, drop=drop) }) # ------------------------------------------------------------------------------ ## 2 time_timeSeries character setMethod("[", signature(x = "timeSeries", i = "time_timeSeries", j = "character"), function(x,i,j, ..., drop = FALSE) { i <- timeDate(i) callGeneric(x=x, i=i, j=j, drop=drop) }) # ------------------------------------------------------------------------------ ## 4 time_timeSeries missing setMethod("[", signature(x = "timeSeries", i = "time_timeSeries", j = "missing"), function(x,i,j, ..., drop = FALSE) { i <- timeDate(i) callGeneric(x=x, i=i, drop=drop) }) # ------------------------------------------------------------------------------ ## 5 time_timeSeries ANY setMethod("[", signature(x = "timeSeries", i = "time_timeSeries", j = "ANY"), function(x,i,j, ..., drop = FALSE) { i <- timeDate(i) callGeneric(x=x, i=i, j=j, drop=drop) }) ################################################################################ # $,timeSeries Subset by column names ################################################################################ # should behave the same way as $,data.frame setMethod("$", signature(x = "timeSeries"), function (x, name) { nc <- colnames(x) nr <- names(x@recordIDs) dataIdx <- pmatch(name, nc) recordIDsIdx <- pmatch(name, nr) # if none or more than one match returns NULL if ((is.na(dataIdx) && is.na(recordIDsIdx)) || (!is.na(dataIdx) && !is.na(recordIDsIdx))) return(NULL) if (!is.na(dataIdx)) return(.subset(x, TRUE, dataIdx)) if (!is.na(recordIDsIdx)) return(x@recordIDs[[recordIDsIdx]]) NULL }) # methods to generate completion after $ .DollarNames.timeSeries <- function(x, pattern) grep(pattern, names(x), value = TRUE) ################################################################################ # $<-,timeSeries Subset by column names ################################################################################ .dollar_assign <- function(x, name, value) { stopifnot(inherits(x, "timeSeries")) # check size of value if (NROW(value) < nrow(x)) { value <- rep(value, length.out = nrow(x)) } else if (NROW(value) > nrow(x)) { stop(gettextf("replacement has %i rows, time series has %i", NROW(value), nrow(x))) #, call. = FALSE) } # assign value to recordIDs if (length(x@recordIDs)) { x@recordIDs[[name]] <- value } else { x@recordIDs <- as.data.frame(value) colnames(x@recordIDs) <- name } # check if object is valid validObject(x) x } setReplaceMethod("$", signature(x = "timeSeries", value = "numeric"), function(x, name, value) { # check size of value if (NROW(value) < nrow(x)) { value <- rep(value, length.out = nrow(x)) } else if (NROW(value) > nrow(x)) { stop(gettextf("replacement has %i rows, time series has %i", NROW(value), nrow(x))) #, call. = FALSE) } # get data part data <- getDataPart(x) # coerce value to matrix ncol <- NCOL(value) value <- matrix(value, ncol = NCOL(value), dimnames = NULL) # set up colnames cn <- colnames(value) if (any(is.null(cn))) cn <- if (ncol > 1) paste(name, ".", seq.int(ncol), sep = "") else name colnames(value) <- cn # if name already present - subsitute ... if (any(cdata <- (colnames(data) %in% cn))) { cvalue <- cn %in% colnames(data) data[,cdata] <- value[,cvalue] value <- cbind(data, value[,!cvalue]) ans <- setDataPart(x, value) } else { ans <- .dollar_assign(x, name, as.vector(value)) } # return ans }) setReplaceMethod("$", signature(x = "timeSeries", value = "factor"), function(x, name, value) .dollar_assign(x, name, value)) setReplaceMethod("$", signature(x = "timeSeries", value = "ANY"), function(x, name, value) .dollar_assign(x, name, value)) ################################################################################ # [<-,timeSeries Assign value to subsets of a 'timeSeries' object ################################################################################ # Note that most of the generic function works by default with [<-,timeDate # only need to deal with special cases that are i <- ("timeDate", "character") # ------------------------------------------------------------------------------ # timeDate setReplaceMethod("[", signature(x = "timeSeries", i = "timeDate", j = "ANY"), function(x, i, j, value) { # bad to use directly @Data but more efficient in this case i <- .findIndex(i@Data, x@positions) callGeneric(x=x, i=i, j=j, value=value) }) setReplaceMethod("[", signature(x = "timeSeries", i = "timeDate", j = "missing"), function(x, i, j, value) callGeneric(x=x, i=i, j=TRUE, value=value)) # ------------------------------------------------------------------------------ # character setReplaceMethod("[", signature(x = "timeSeries", i = "character", j = "ANY"), function(x, i, j, value) { i <- timeDate(i) callGeneric(x=x, i=i, j=j, value=value) }) setReplaceMethod("[", signature(x = "timeSeries", i = "character", j = "missing"), function(x, i, j, value) { i <- timeDate(i) callGeneric(x=x, i=i, j=TRUE, value=value) }) ################################################################################ timeSeries/R/base-subset.R0000644000176000001440000000175711370220766015172 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # subset,timeSeries ################################################################################ # [, moved to base-Extract.R, notation like in base R package # here should go function subset() ################################################################################ timeSeries/R/base-start.R0000644000176000001440000000403011560011674015002 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # start,timeSeries Extracts start date of a 'timeSeries' object # end,timeSeries Extracts end date of a 'timeSeries' object ################################################################################ .start.timeSeries <- function(x, ...) { # Description: # Extracts start date of a 'timeSeries' object # FUNCTION: # Extract Date: if (length(x@positions)>0) timeDate(min(x@positions), zone = "GMT", FinCenter = x@FinCenter) else NULL } setMethod("start" , "timeSeries", function(x, ...) .start.timeSeries(x, ...)) # until UseMethod dispatches S4 methods in 'base' functions start.timeSeries <- function(x, ...) .start.timeSeries(x, ...) # ------------------------------------------------------------------------------ .end.timeSeries <- function(x, ...) { # Description: # Extracts start date of a 'timeSeries' object # FUNCTION: # Extract Date: if (length(x@positions)>0) timeDate(max(x@positions), zone = "GMT", FinCenter = x@FinCenter) else NULL } setMethod("end", "timeSeries", function(x, ...) .end.timeSeries(x, ...)) # until UseMethod dispatches S4 methods in 'base' functions end.timeSeries <- function(x, ...) .end.timeSeries(x, ...) ################################################################################ timeSeries/R/base-sort.R0000644000176000001440000000343411560011674014643 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # sort,timeSeries Sorts a 'timeSeries' object in time ################################################################################ .sort.timeSeries <- function (x, decreasing = FALSE, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Time sorts a 'timeSeries' object # Arguments: # x - a 'timeSeries' object. # Value: # Returns a time sorted object of class 'timeSeries'. # FUNCTION: # check if really necessary to sort x # important in order to improve efficiency if (!decreasing && !is.unsorted(x)) return(x) if (length(x@positions)>0) x[order(x@positions, decreasing = decreasing), ] else x } setMethod("sort", "timeSeries", function (x, decreasing = FALSE, ...) .sort.timeSeries(x, decreasing = decreasing, ...)) # until UseMethod dispatches S4 methods in 'base' functions sort.timeSeries <- function(x, decreasing = FALSE, ...) .sort.timeSeries(x, decreasing = decreasing, ...) ################################################################################ timeSeries/R/base-scale.R0000644000176000001440000000310411370220766014740 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # scale,timeSeries Centers and/or scales a 'timeSeries' object ################################################################################ .scale.timeSeries <- function(x, center = TRUE, scale = TRUE) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Centers and/or scales a 'timeSeries' object. # Arguments: # FUNCTION: # Scale: setDataPart(x, scale(x = getDataPart(x), center = center, scale = scale)) } setMethod("scale", "timeSeries", function(x, center = TRUE, scale = TRUE) .scale.timeSeries(x, center = center, scale = scale)) # until UseMethod dispatches S4 methods in 'base' functions scale.timeSeries <- function (x, center = TRUE, scale = TRUE) .scale.timeSeries(x, center = center, scale = scale) ################################################################################ timeSeries/R/base-sample.R0000644000176000001440000000211711370220766015135 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # sample,timeSeries Resamples a 'timeSeries' object in time ################################################################################ setMethod("sample", "timeSeries", function(x, size, replace = FALSE, prob = NULL) { x[sample(seq(NROW(x)), size, replace, prob), ] } ) ################################################################################ timeSeries/R/base-rev.R0000644000176000001440000000220711370220766014450 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # rev,timeSeries Reverts a 'timeSeries' object in time ################################################################################ .rev.timeSeries <- function(x) x[NROW(x):1,] setMethod("rev", "timeSeries", function(x) .rev.timeSeries(x)) # until UseMethod dispatches S4 methods in 'base' functions rev.timeSeries <- function(x) .rev.timeSeries(x) ################################################################################ timeSeries/R/base-rank.R0000644000176000001440000000371511370220766014614 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: COLUMN STATISTICS IN FUTILITIES: # rank,timeSeries Returns sample ranks of a timeSeries object ################################################################################ setMethod("rank", "timeSeries", function(x, na.last = TRUE, ties.method = c("average", "first", "random", "max", "min")) { # Description: # Returns the sample ranks of the values in a timeSeries # Arguments: # x - an object of class 'timeSeries' # ties.method - # "average", replaces them by their mean, # "first" method results in a permutation with increasing # values at each index set of ties. # "random" method puts these in random order whereas the # default, # "max" and "min" replaces them by their maximum and minimum # respectively, the latter being the typical sports ranking. # Note: # Ties (i.e., equal values) and missing values can be handled # in several ways. # FUNCION: # Return Value: apply(x, 2, rank, na.last = na.last, ties.method = ties.method) } ) ################################################################################ timeSeries/R/base-merge.R0000644000176000001440000001363611656243252014765 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # merge,timeSeries,ANY Merges 'timeSeries' object and ANY # merge,timeSeries,missing Merges 'timeSeries' object and missing # merge,timeSeries,timeSeries Merges two 'timeSeries' objects # merge,ANY,timeSeries Merges ANY and 'timeSeries' object ################################################################################ setMethod("merge", c("timeSeries", "ANY"), function(x,y, ...) { callGeneric(x, as(y, "timeSeries"), ...) } ) # ------------------------------------------------------------------------------ setMethod("merge", c("timeSeries", "missing"), function(x,y, ...) { x } ) # ------------------------------------------------------------------------------ setMethod("merge", c("timeSeries", "numeric"), function(x, y, ...) { # deal with names of numeric vectors units <- names(y) if (is.null(units)) units <- paste((substitute(x)), collapse = ".") if (length(y) == 1) { y = rep(y, times = nrow(x)) return(merge(x, timeSeries(y, time(x), units = units), ...)) } else if (length(y) == nrow(x)) { return(merge(x, timeSeries(y, time(x), units = units), ...)) } else { stop("number of rows must match") } } ) # ------------------------------------------------------------------------------ setMethod("merge", c("timeSeries", "matrix"), function(x, y, ...) { # deal with names of matrix units <- colnames(y) if (is.null(units)) { units <- paste((substitute(y)), collapse = ".") if ((nc <- ncol(y)) > 1) units <- paste(units, seq(nc), sep = ".") } if (nrow(y) != nrow(x)) stop("number of rows must match") else merge(x, timeSeries(y, time(x), units = units), ...) }) # ------------------------------------------------------------------------------' .merge.timeSeries <- function(x, y, ...) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Merges two objects of class 'timeSeries' # Arguments: # x,y - two objects of class 'timeSeries' # FUNCTION: # Merge: if (is.signalSeries(x) | is.signalSeries(y)) { data <- merge(getDataPart(x), getDataPart(x)) return(timeSeries(data = data, units = colnames(data))) } # Convert to Data Frame tx <- as.numeric(time(x), "sec") ty <- as.numeric(time(y), "sec") df.x <- if (prod(dim(rec.x <- x@recordIDs))) data.frame(positions = tx, getDataPart(x), rec.x) else data.frame(positions = tx, getDataPart(x)) df.y <- if (prod(dim(rec.y <- y@recordIDs))) data.frame(positions = ty, getDataPart(y), rec.y) else data.frame(positions = ty, getDataPart(y)) # Merge as Data Frame: df <- merge(df.x, df.y, all = TRUE) #-> To avoid problems when using invalid data.frame colnames nx <- make.names(colnames(x)) nxrec <- colnames(rec.x) ny <- make.names(colnames(y)) nyrec <- colnames(rec.y) dataIdx <- colnames(df) %in% c(nx, ny) recIdx <- colnames(df) %in% c(nxrec, nyrec) data <- as.matrix(df[,dataIdx, drop=FALSE]) recordIDs <- if (any(recIdx)) df[,recIdx, drop=FALSE] else data.frame() units <- names(df)[dataIdx] charvec <- as.numeric(df[,1]) # Return Value: timeSeries(data = data, charvec = charvec, units = units, zone = "GMT", FinCenter = finCenter(x), recordIDs = recordIDs) } setMethod("merge", c("timeSeries", "timeSeries"), function(x, y, ...) .merge.timeSeries(x, y, ...)) # until UseMethod dispatches S4 methods in 'base' functions merge.timeSeries <- function(x, y, ...) .merge.timeSeries(x, y, ...) # ------------------------------------------------------------------------------ setMethod("merge", c("numeric", "timeSeries"), function(x, y, ...) { # deal with names of numeric vectors units <- names(x) if (is.null(units)) units <- paste((substitute(x)), collapse = ".") if (length(x) == 1) { x = rep(x, times = nrow(y)) return(merge(timeSeries(x, time(y), units = units), y, ...)) } else if (length(x) == nrow(y)) { return(merge(timeSeries(x, time(y), units = units), y, ...)) } else { stop("number of rows must match") } } ) # ------------------------------------------------------------------------------ setMethod("merge", c("matrix", "timeSeries"), function(x, y, ...) { # deal with names of matrix units <- colnames(x) if (is.null(units)) { units <- paste((substitute(x)), collapse = ".") if ((nc <- ncol(x)) > 1) units <- paste(units, seq(nc), sep = ".") } if (nrow(x) != nrow(y)) stop("number of rows must match") else merge(timeSeries(x, time(y), units = units), y, ...) }) setMethod("merge", c("ANY", "timeSeries"), function(x,y, ...) { callGeneric(as(x, "timeSeries"), y, ...) } ) ################################################################################ timeSeries/R/base-dim.R0000644000176000001440000002051411370220766014426 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # S4 METHOD: DIM OPERATIONS ON DATA: # dim,timeSeries Returns dimension of a 'timeSeries' object # dim<-,timeSeries Assigns dimension of a 'timeSeries' object # dimnames,timeDSeries Returns dimension names of a 'timeSeries' object # dimnames<-,timeSeries Assign dimension names of a 'timeSeries' object # colnames,timeSeries Return column names to a 'timeSeries' object # rownames,timeSeries Return row names to a 'timeSeries' object # colnames<-,timeSeries Assigns column names to a 'timeSeries' object # rownames<-,timeSeries Assigns row names to a 'timeSeries' object # names,timeSeries Return column names of a 'timeSeries' object # names<.,timeSeries Assigns column names of a 'timeSeries' object ################################################################################ # Base Functions: # Generate from Matrix: # edhec.tS = timeSeries(edhec.mat, rownames(edhec.mat)) # edhec.ts = ts(edhec.mat, start = c(1997, 1), frequency = 12) # Univariate time Series: # edhec1.tS = edhec.tS[, 1] # dim # dim(edhec.tS) # 20 4 # dim(edhec1.tS) # 20 1 # DIM # DIM = function(x) {c(NROW(x), NCOL(x))} # DIM(edhec.tS) # 20 4 # DIM(edhec1.tS) # 20 1 # length # length(edhec.tS) # 1 # # LENGTH # LENGTH = function(x) NROW(x) # LENGTH(edhec.tS) # 20 # LENGTH(edhec1.tS) # 20 # # ncol / nrow # ncol(edhec.tS) # 4 # # ncol(edhec1.tS) # 1 # # NCOL / NRWO # NCOL(edhec.tS) # 4 # # NCOL(edhec1.tS) # 1 # # isUnivariate # isUnivariate = function(x) NCOL(x) == 1 # isUnivariate(edhec.tS) # isUnivariate(edhec1.tS) # # isMultivariate # Just Negation of isUnivariate # # # # ------------------------------------------------------------------------------ # length # dim # ncol # nrow # LENGTH # DIM # NCOL # NROW # ------------------------------------------------------------------------------ # Note it is faster to access attribute rather than accessing @.Data setMethod("dim", "timeSeries", function(x) attr(x, "dim")) # This should make functions like # model.response(model.frame(dummySeries() ~1)) work setReplaceMethod("dim", "timeSeries", function(x, value) { # dim(x) <- NULL returns a vector if (is.null(value)) return(as.vector(x)) else x #<< returns same object : # setting new dim # is forbidden for a timeSeries object } ) # ------------------------------------------------------------------------------ # colnames # faster to have dedicated method than relying on dimnames[[2]] setMethod("colnames", "timeSeries", # "signalSeries", function(x, do.NULL = TRUE, prefix = "col") x@units ) # ------------------------------------------------------------------------------ # rownames # ## setMethod("rownames", "signalSeries", ## function (x, do.NULL = TRUE, prefix = "row") NULL) ## setMethod("rownames", "timeSeries", ## function (x, do.NULL = TRUE, prefix = "row") as.character(time(x))) setMethod("rownames", "timeSeries", function (x, do.NULL = TRUE, prefix = "row") { if (length(x@positions) > 0) as.character(time(x)) else NULL } ) # ------------------------------------------------------------------------------ setMethod("dimnames", "timeSeries", # "signalSeries", function(x) { list(rownames(x),colnames(x)) } ) # ------------------------------------------------------------------------------ setMethod("colnames<-", "timeSeries", function(x, value) { units <- as.character(value) if(!length(units)) if (x@format == "counts") units <- paste("SS", seq(NCOL(x)), sep = ".") else units <- paste("TS", seq(NCOL(x)), sep = ".") if (length(units) != NCOL(x)) stop("length of 'colnames' not equal to array extent",call.=FALSE) x@units <- units colnames(x@.Data) <- units x } ) # ------------------------------------------------------------------------------ setMethod("rownames<-", c("timeSeries", "timeDate"), #c("signalSeries", "timeDate"), function (x, value) { .timeSeries( data = getDataPart(x), charvec = as.numeric(value, "sec"), units = colnames(x), format = value@format, FinCenter = value@FinCenter, recordIDs = x@recordIDs, title = x@title, documentation = x@documentation) } ) # ------------------------------------------------------------------------------ setMethod("rownames<-", "timeSeries", # "signalSeries", function (x, value) { # if charvec NULL returns a signal series if (is.null(value)) return(.signalSeries(data = getDataPart(x), units = colnames(x), recordIDs = x@recordIDs, title = x@title, documentation = x@documentation)) # coerce charvec to timeDate charvec <- timeDate(charvec = value) if (any(is.na(charvec))) # Note : there is already a warning in timeDate if there are NA's .signalSeries(data = getDataPart(x), units = colnames(x), recordIDs = x@recordIDs, title = x@title, documentation = x@documentation) else .timeSeries(data = getDataPart(x), charvec = as.numeric(charvec, "sec"), units = colnames(x), format = charvec@format, FinCenter = charvec@FinCenter, recordIDs = x@recordIDs, title = x@title, documentation = x@documentation) } ) # ------------------------------------------------------------------------------ setMethod("dimnames<-", c("timeSeries", "list"), # c("signalSeries", "list"), function(x, value) { rownames(x) <- value[[1]] colnames(x) <- value[[2]] x } ) # ------------------------------------------------------------------------------ # important for completion with $ setMethod("names", "timeSeries", # "signalSeries", function(x) c(colnames(x), names(x@recordIDs))) setReplaceMethod("names", "timeSeries", # "signalSeries", function(x, value) { nc <- ncol(x) nv <- length(value) nr <- length(x@recordIDs) # Note that using [][] ensure that length of the # names are equal to array extent colnames(x) <- value[seq.int(nv)][seq.int(nc)] if (nv > nc) names(x@recordIDs) <- value[-seq.int(nc)][seq.int(nr)] x }) ################################################################################ timeSeries/R/base-diff.R0000644000176000001440000000547011415310364014563 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # diff,timeSeries Differences a 'timeSeries' object ################################################################################ .diff.timeSeries <- function(x, lag = 1, diff = 1, trim = FALSE, pad = NA, ...) { # A function implemented by Diethelm Wuertz # Modified by Yohan Chalabi # Description: # Difference 'timeSeries' objects. # Arguments: # x - a 'timeSeries' object. # lag - an integer indicating which lag to use. # By default 1. # diff - an integer indicating the order of the difference. # By default 1. # trim - a logical. Should NAs at the beginning of the # series be removed? # pad - a umeric value with which NAs should be replaced # at the beginning of the series. # Value: # Returns a differenced object of class 'timeSeries'. # FUNCTION: # Convert: y = getDataPart(x) # as.matrix(x) # Check NAs: # if (any(is.na(y))) stop("NAs are not allowed in time series") # Difference: z = diff(y, lag = lag, difference = diff) diffNums = dim(y)[1] - dim(z)[1] # Trim: if (!trim) { zpad = matrix(0*y[1:diffNums, ] + pad, nrow = diffNums) z = rbind(zpad, z) } pos <- if (!trim) x@positions else x@positions[-(1:diffNums)] # Record IDs: df <- x@recordIDs if (trim && sum(dim(df)) > 0) { df <- df[-seq.int(diffNums), , drop = FALSE] rownames(df) <- seq.int(NROW(df)) } # Return Value: timeSeries(data = z, charvec = pos, units = colnames(z), format = x@format, zone = x@FinCenter, FinCenter = x@FinCenter, recordIDs = df, title = x@title, documentation = x@documentation) } setMethod("diff", "timeSeries", function(x, lag = 1, diff = 1, trim = FALSE, pad = NA, ...) .diff.timeSeries(x, lag, diff, trim, pad, ...)) # until UseMethod dispatches S4 methods in 'base' functions diff.timeSeries <- function(x, ...) .diff.timeSeries(x, ...) ################################################################################ timeSeries/R/base-cbind.R0000644000176000001440000002211411656243252014734 0ustar ripleyusers # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # cbind.timeSeries Binds columns of two 'timeSeries' objects # rbind.timeSeries Binds rows of two 'timeSeries' objects ################################################################################ cbind.timeSeries <- function(..., deparse.level = 1) { # A function implemented by Yohan Chalabi and Diethelm Wuertz # Description: # Arguments: # FUNCTION: # Columnwise bind: dots <- list(...) # remove NULL from dots args if (any(t <- unlist(lapply(dots, is.null)))) dots[t] <- NULL # deal with numeric values vecIdx <- sapply(dots, function(obj) (!inherits(obj, "timeSeries") && prod(dim(obj)) == 1)) if (any(vecIdx)) dots[vecIdx] <- lapply(dots[vecIdx], function(vec) as.timeSeries(rep(as.vector(vec), len = NROW(dots[[1]])))) # coerce to timeSeries object if not a timeSeries if (any(t <- !unlist(lapply(dots, inherits, "timeSeries")))) dots[t] <- lapply(dots[t], as.timeSeries) # note that new timeSeries get FinCenter of first entry of args FinCenter = finCenter(dots[[1]]) # get names of arguments if any units <- unlist(lapply(dots, colnames)) if (length(t <- as.logical((nchar(nm <- names(units)))))) units[t] <- nm[t] # change colnames if they are the same if (length(unique(units)) != length(units)) { for (name in unique(units)) { pos <- grep(name, units) if (length(pos) != 1) units[pos] <- paste(units[pos], seq(pos), sep = ".") } } # ensure that data is sorted dots <- lapply(dots, sort) # get list of timestamps and recordIDs tds <- lapply(dots, slot, "positions") rec <- lapply(dots, slot, "recordIDs") # fast version when timeSeries have identical timestamps # or with signal series if (any(co <- unlist(lapply(dots, function(ts) ts@format == "counts"))) || (any(!co) & all(sapply(tds[!co], identical, tds[!co][[1]])))) { # check if all have same number of rows if (diff(range((unlist(lapply(dots, NROW)))))) stop("number of rows must match") td <- if (any(!co)) tds[!co][[1]] else NULL data <- array(unlist(dots), dim=c(NROW(dots[[1]]), sum(sapply(dots, ncol)))) recordIDs <- if (sum(recIdx <- sapply(rec, length))) do.call(cbind, rec[recIdx]) else data.frame() timeSeries(data = data, charvec = td, units = units, zone = "GMT", FinCenter = FinCenter, recordIDs = recordIDs) } else { # aligned timestamps td <- sort(unique(unlist(tds))) fun <- function(ts, td, ref) { mm <- matrix(NA, ncol = ncol(ts), nrow = length(ref)) mm[findInterval(td, ref),] <- getDataPart(ts) mm} data <- mapply(fun, ts = dots, td = tds, MoreArgs = list(ref=td), SIMPLIFY = FALSE) data <- array(unlist(data), dim=c(length(td), sum(sapply(dots, ncol)))) # Note that recordIDs are not preserved when time stamps are # not equal because don't know what value we should use for # missing entries if (sum(sapply(rec, length))) { msg <- "@recordIDs cannot be binded when timestamps are not identical" warning(msg, call. = FALSE) } # note that new timeSeries get FinCenter of first entry of args timeSeries(data = data, charvec = td, units = units, zone = FinCenter, FinCenter = FinCenter) } } # ------------------------------------------------------------------------------ ## # YC: ## # Note that since 2.9.0 S3 methods can not be defined for S4 classes ## # which extends an object like matrix. Therefore we turn all S3 ## # generics to S4 generics for backward compatibility ## # Note that since 2.8.0 it is possible to define methods for functions ## # with dots ... ## if (getRversion() < "2.9.0") { ## cbind.timeSeries <- ## function(..., deparse.level = 1) ## .cbind.timeSeries(..., deparse.level = deparse.level) ## } else { ## setGeneric("cbind", signature = "...") #-> creates warning but ## # cannot avoid it with ## # current dotsMethods scheme ## setMethod("cbind", "timeSeries", function(..., deparse.level = 1) ## .cbind.timeSeries(..., deparse.level = deparse.level)) ## } # ------------------------------------------------------------------------------ setMethod("cbind2", c("timeSeries", "timeSeries"), function(x, y) cbind(x, y)) setMethod("cbind2", c("timeSeries", "ANY"), function(x,y) callGeneric(x, as(y, "timeSeries"))) setMethod("cbind2", c("ANY", "timeSeries"), function(x,y) callGeneric(as(x, "timeSeries"), y)) setMethod("cbind2", c("timeSeries", "missing"), function(x,y) x) # ------------------------------------------------------------------------------ rbind.timeSeries <- function(..., deparse.level = 1) { # A function implemented by Yohan Chalabi and Diethelm Wuertz # Description: # Arguments: # FUNCTION: # Columnwise bind: # Row bind: dots <- list(...) # Remove NULL from dots args if (any(t <- unlist(lapply(dots, is.null)))) dots[t] <- NULL # Coerce to timeSeries object if not a timeSeries if (any(t <- !unlist(lapply(dots, inherits, "timeSeries")))) dots[t] <- lapply(dots[t], as.timeSeries) if (diff(range((unlist(lapply(dots, ncol)))))) stop("number of columns must match") # get names of arguments if any otherwise use colnames units <- unlist(lapply(dots, colnames)) if (length(t <- as.logical((nchar(nm <- names(units)))))) units[t] <- nm[t] units <- structure(units, dim = c(ncol(dots[[1]]), length(dots))) units <- apply(units, 1, paste, collapse = "_") # Bind: # data <- base::rbind(...) # no because S3 method dispatch done in C level data <- do.call(base::rbind, lapply(dots, getDataPart)) if (any(unlist(lapply(dots, function(ts) ts@format == "counts")))) { return(timeSeries(data=data, units = units)) } # recordIDs part if (length(dots) > 1) recordIDs <- tryCatch(do.call(rbind, lapply(dots, slot, "recordIDs")), error = function(e) { msg <- paste("@recordIDs cannot be binded :", conditionMessage(e)) warning(msg, call. = FALSE) data.frame()}) else recordIDs <- slot(dots[[1]], "recordIDs") tds <- unlist(lapply(dots, slot, "positions")) ans <- timeSeries(data = data, charvec = tds, zone = "GMT", FinCenter = finCenter(dots[[1]]), units = units, recordIDs = recordIDs) # Return Value: # sort(ans) ans } # ------------------------------------------------------------------------------ ## # YC: ## # Note that since 2.9.0 S3 methods can not be defined for S4 classes ## # which extends an object like matrix. Therefore we turn all S3 ## # generics to S4 generics for backward compatibility ## # Note that since 2.8.0 it is possible to define methods for functions ## # with dots ... ## if (getRversion() < "2.9.0") { ## rbind.timeSeries <- ## function(..., deparse.level = 1) ## .rbind.timeSeries(..., deparse.level = deparse.level) ## } else { ## setGeneric("rbind", signature = "...") #-> creates warning but ## # cannot avoid it with ## # current dotsMethods scheme ## setMethod("rbind", "timeSeries", function(..., deparse.level = 1) ## .rbind.timeSeries(..., deparse.level = deparse.level)) ## } # ------------------------------------------------------------------------------ setMethod("rbind2", c("timeSeries", "timeSeries"), function(x, y) rbind(x, y)) setMethod("rbind2", c("timeSeries", "ANY"), function(x,y) callGeneric(x, as(y, "timeSeries"))) setMethod("rbind2", c("ANY", "timeSeries"), function(x,y) callGeneric(as(x, "timeSeries"), y)) setMethod("rbind2", c("timeSeries", "missing"), function(x,y) x) ################################################################################ timeSeries/R/base-attach.R0000644000176000001440000000265511560011674015124 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # S4 METHOD: DATABASE ATTACHEMENT: # attach,timeSeries Attaches a 'timeSeries' object to the search path ################################################################################ setMethod("attach", "timeSeries", function(what, pos = 2, name = deparse(substitute(what)), warn.conflicts = TRUE) { # A function implemented by Diethelm Wuertz and Yohan Chalabi # Description: # Attaches a 'timeSeries' object # Details: # The function works in the same way as in the case of a # data.frame, i.e. the return value are vectors. # FUNCTION: # Return Value: callGeneric(as.data.frame(what), pos, name, warn.conflicts) }) ################################################################################ timeSeries/R/base-apply.R0000644000176000001440000003101212056067231014773 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # FUNCTION: DESCRIPTION: # apply Applies a function to blocks of a 'timeSeries' # applySeries Applies a function to blocks of a 'timeSeries' # fapply deprecated: Applies a function to 'timeSeries' windows # OLD AND OBSOLETE: DESCRIPTION: # .applySeries old and obsolete ... # .fapply old and obsolete ... ################################################################################ setMethod("apply", "timeSeries", function(X, MARGIN, FUN, ...) { pos <- X@positions rec <- X@recordIDs FinCenter <- finCenter(X) X <- getDataPart(X) ans <- callGeneric() if (is(ans, "matrix") && identical(NROW(ans), NROW(X))) ans <- timeSeries(data = ans, charvec = pos, zone = FinCenter, FinCenter = FinCenter, recordIDs = rec) ans }) # ------------------------------------------------------------------------------ ## setMethod("apply", "timeSeries", ## function(X, MARGIN, FUN, ...) ## { ## # A function implemented by Diethelm Wuertz and Yohan Chalabi ## ## # Description: ## # Returns a 'timeSeries' of values obtained by applying a function ## # to the margins of the series. ## ## # FUNCTION: ## ## # Call Generic: ## ans <- callGeneric(series(X), MARGIN, FUN) ## ## # Return as timeSeries object with proper dimensions: ## if (length(MARGIN) == 1 && MARGIN == 1) { ## # Rowwise: ## series(X) <- ans ## colnames(X) = substitute(FUN) ## } else if (length(MARGIN) == 1 && MARGIN == 2) { ## # Columnwise: ## X = X[which.max(time(X)), ] ## series(X) <- t(ans) ## } else if (length(MARGIN) == 2 && MARGIN == c(1, 2)) { ## # Row- and Columnwise: ## X = apply(X, MARGIN = 1, FUN) ## X = apply(X, MARGIN = 2, FUN) ## colnames(X) = substitute(FUN) ## } else if (length(MARGIN) == 2 && MARGIN == c(2, 1)) { ## # Column- and Rowwise: ## X = apply(X, MARGIN = 2, FUN) ## X = apply(X, MARGIN = 1, FUN) ## colnames(X) = substitute(FUN) ## } ## ## # Return Value: ## X ## }) # ------------------------------------------------------------------------------ applySeries <- function(x, from = NULL, to = NULL, by = c("monthly", "quarterly"), FUN = colMeans, units = NULL, format = x@format, zone = x@FinCenter, FinCenter = x@FinCenter, recordIDs = data.frame(), title = x@title, documentation = x@documentation, ...) { # A function implemented by Diethelm Wuertz # Description: # Apply a function to the margins of a 'timeSeries' object # Details: # This function can be used to aggregate and coursen a # 'timeSeries' object. # Arguments: # x - a 'timeSeries' object to be aggregated # from, to - two 'timeDate' position vectors which size the # blocks # by - calendarical block, only active when both 'from' # and 'to' are NULL # FUN - function to be applied, by default 'colMeans' # units - a character vector with column names, allows to # overwrite the column names of the input 'timeSeries' # object. # Value: # Returns a S4 object of class 'timeSeries'. # Notes: # The size of the 'moving' window and the selection of an # 'adj'-acent endpoint are not needed, all the information # is kept in the 'from' and 'to' position vectors. # FUNCTION: # .Deprecated("aggregate", "timeSeries") # Check object: if (class(x) != "timeSeries") stop("s is not a timeSeries object") ### if (x@format == "counts") ### stop(as.character(match.call())[1], ### " is for time series and not for signal series.") # Monthly and Quarterly from and to: if (is.null(from) & is.null(to)) { if (by[1] == "monthly") { # Use monthly blocks: from = unique(timeFirstDayInMonth(time(x))) to = unique(timeLastDayInMonth(time(x))) } else if (by[1] == "quarterly") { from = unique(timeFirstDayInQuarter(time(x))) to = unique(timeLastDayInQuarter(time(x))) } else { stop("by must be eiter monthly or quarterly") } from@FinCenter = to@FinCenter = FinCenter } # Column Names: colNames = units # Function: fun = match.fun(FUN) ### # Blocks: ### j.pos = as.POSIXct(time(x)) ### j.from = as.POSIXct(from) ### j.to = as.POSIXct(to) # Blocks: j.pos = time(x) if (is(j.pos, "timeDate")) { j.from = as.timeDate(from) j.to = as.timeDate(to) } else { j.from = as.integer(from) j.to = as.integer(to) } # Iterate: pos = time(x) rowNames = rownames(x) rowBind = NULL for (i in seq_len(length(from))) { test <- (j.pos >= j.from[i] & j.pos <= j.to[i]) if (!sum(test)) stop("outsite of range") # make sure that cutted is a matrix ... cutted = as.matrix(x[test, ]) # YC : *AND* make sure the matrix is not subbsetted to a vector!!! # YC : here it is fine because as.matrix of a timeSeries checks it # YC : but prefer to check it one more time at the end of the loop... ### if (sum(test)>0) rownames(cutted) <- rowNames[test] ans = fun(cutted, ...) rowBind = rbind(rowBind, ans) } stopifnot(NCOL(rowBind) == NCOL(x)) # YC : see above # YC : length(to) might not be == NCOL(rowBind) if (length(as.character(to)) == NROW(rowBind)) rownames(rowBind) = as.character(to) if (is.null(colNames)) { units = x@units } else { units = colNames } # Return Value: timeSeries(data = rowBind, units = units, format = format, zone = zone, FinCenter = FinCenter, recordIDs = recordIDs, title = title, documentation = documentation, ...) } # ------------------------------------------------------------------------------ fapply <- function(x, from, to, FUN, ...) { # .Deprecated("aggregate", "timeSeries") # Check x: stopifnot(is(x, "timeSeries")) if (x@format == "counts") stop(as.character(match.call())[1], " is for time series and not for signal series.") # Check for missing form/to: if(missing(from)) from = start(x) if(missing(to)) to = end(x) # Return Value: applySeries(x = x, from = from, to = to, FUN = FUN, ...) } ################################################################################ # *** OLD *** # Check if it is still used somewhere ... .applySeries <- function (x, from = NULL, to = NULL, by = c("monthly", "quarterly"), FUN = colMeans, units = NULL, ...) { # Old/Alternative Version # Chreck for 'timeSeries' Object: stopifnot(is.timeSeries(x), is(from, "timeDate") || is.null(from), is(to, "timeDate") || is.null(to)) # Allow for colMeans: if (substitute(FUN) == "colMeans") FUN = "colAvgs" # Monthly and Quarterly from and to: if (is.null(from) & is.null(to)) { by = match.arg(by) if (by == "monthly") { from = unique(timeFirstDayInMonth(time(x))) to = unique(timeLastDayInMonth(time(x))) } else if (by == "quarterly") { from = unique(timeFirstDayInQuarter(time(x))) to = unique(timeLastDayInQuarter(time(x))) } from@FinCenter = to@FinCenter = x@FinCenter } # Start Cutting Process: fun = match.fun(FUN) cutted = NULL i = 1 # Find First Interval which is not empty: while (is.null(cutted)) { cutted = cut(x, from[i], to[i]) if (!is.null(cutted)) { # Non empty Interval: ans = fun(cutted, ...) } i = i + 1 } # Continue up to the end: for (j in seq_len(length(from))) { cutted = cut(x, from[j], to[j]) if (!is.null(cutted)) { # Non empty Interval: newAns = fun(cutted, ...) ans = rbind(ans, newAns) } } # Return Value: ans } ################################################################################ # *** OLD *** # Check if it is still used somewhere ... .fapply <- function(x, from, to, FUN, ...) { # A function implemented by Diethelm Wuertz # Description: # Applies a function to 'timeSeries' windows # Details: # This function can be used to aggregate and coursen a # 'timeSeries' object. # Arguments: # x - a 'timeSeries' object to be aggregated # from, to - two 'timeDate' position vectors which size the blocks # FUN - function to be applied, by default 'colMeans' # Value: # Returns a S4 object of class 'timeSeries' if FUN returns # a time series object, otherwise a list, where the entries # for each window is the output of the function FUN. # Notes: # The size of the 'moving' window and the selection of an # 'adj'-acent endpoint are not needed, all the information # is kept in the 'from' and 'to' position vectors. # FUNCTION: # Check object: if (class(x) != "timeSeries") stop("s is not a timeSeries object") # Monthly and Quarterly from and to: if (is.null(from) & is.null(to)) { if (by[1] == "monthly") { # Use monthly blocks: from = unique(timeFirstDayInMonth(time(x))) to = unique(timeLastDayInMonth(time(x))) } else if (by[1] == "quarterly") { from = unique(timeFirstDayInQuarter(time(x))) to = unique(timeLastDayInQuarter(time(x))) } else { stop("by must be eiter monthly or quarterly") } from@FinCenter = to@FinCenter = x@FinCenter } # Column Names: colNames = units # Function: fun = match.fun(FUN) # Blocks: j.pos = as.POSIXct(time(x)) j.from = as.POSIXct(from) j.to = as.POSIXct(to) # Iterate: y = series(x) pos = time(x) rowNames = rownames(x) # Compute for the first window ... i = 1 test = (j.pos >= j.from[i] & j.pos <= j.to[i]) # make sure that cutted is a matrix ... cutted = as.matrix(y[test, ]) ### if (sum(test)>0) rownames(cutted) <- rowNames[test] ans = fun(cutted, ...) if (is.timeSeries(ans)) { ## DW can this happen - check ? rowBind = ans for (i in 2L:length(from)) { test = (j.pos >= j.from[1] & j.pos <= j.to[1]) # make sure that cutted is a matrix ... cutted = as.matrix(y[test, ]) ### if (sum(test)>0) rownames(cutted) <- rowNames[test] ans = fun(cutted, ...) rowBind = rbind(rowBind, ans) } rownames(rowBind) = as.character(to) if (is.null(colNames)) { units = x@units } else { units = colNames } # Return Value: ans = timeSeries(data = rowBind, charvec = as.character(to), units = units, format = format, zone = x@zone, FinCenter = x@FinCenter, recordIDs = x@recordIDs, title = x@title, documentation = x@documentation, ...) return(ans) } else { listBind = list() ## DW [] -> [[]] listBind[[1]] = ans for (i in 2L:length(from)) { test = (j.pos >= j.from[i] & j.pos <= j.to[i]) # make sure that cutted is a matrix ... cutted = as.matrix(y[test, ]) ### if (sum(test)>0) rownames(cutted) <- rowNames[test] ans = fun(cutted, ...) ## DW [] -> [[]] listBind[[i]] = ans } # Return Value: ans = listBind attr(ans, "control") <- list(x = x, from = from, to = to) return(invisible(ans)) } # Return Value: return() } ################################################################################ timeSeries/R/aaa-Deprecated.R0000644000176000001440000000352011560011674015520 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # DEPRECATED: # .description # durationSeries # midquoteSeries # spreadSeries ################################################################################ .description <- function() { # Deprecated: .Deprecated(new = "description", package = "timeSeries") # Return Value: description() } # ------------------------------------------------------------------------------ durationSeries <- function(...) { # Deprecated: .Deprecated(new = "returns", package = "timeSeries") # Return Value: durations(...) } # ------------------------------------------------------------------------------ midquoteSeries = function(...) { # Deprecated: .Deprecated(new = "midquotes", package = "timeSeries") # Return Value: midquotes(...) } # ------------------------------------------------------------------------------ spreadSeries = function(...) { # Deprecated: .Deprecated(new = "spreads", package = "timeSeries") # Return Value: spreads(...) } ################################################################################ timeSeries/R/AllGeneric.R0000644000176000001440000000442511370220766014755 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ setGeneric("returns", function(x, ...) standardGeneric("returns"), package = "timeSeries") setGeneric("rowCumsums", function(x, na.rm = FALSE, ...) standardGeneric("rowCumsums"), package = "timeSeries") setGeneric("series", function(x) standardGeneric("series"), package = "timeSeries") setGeneric("series<-", function(x, value) standardGeneric("series<-"), package = "timeSeries") ## setGeneric("index", function(x, ...) ## standardGeneric("index"), package = "timeSeries") ## setGeneric("index<-", function(x, value) ## standardGeneric("index<-"), package = "timeSeries") setGeneric("outlier", function(x, sd = 5, complement = TRUE, ...) standardGeneric("outlier")) setGeneric("timeSeries", function (data, charvec, units = NULL, format = NULL, zone = "", FinCenter = "", recordIDs = data.frame(), title = NULL, documentation = NULL, ...) standardGeneric("timeSeries")) setGeneric("colCumsums", function(x, na.rm = FALSE, ...) standardGeneric("colCumsums")) setGeneric("colCummaxs", function(x, na.rm = FALSE, ...) standardGeneric("colCummaxs")) setGeneric("colCummins", function(x, na.rm = FALSE, ...) standardGeneric("colCummins")) setGeneric("colCumprods", function(x, na.rm = FALSE, ...) standardGeneric("colCumprods")) setGeneric("colCumreturns", function(x, method = c("geometric", "simple"), na.rm = FALSE, ...) standardGeneric("colCumreturns")) ################################################################################ timeSeries/R/AllClass.R0000644000176000001440000001261311370220766014444 0ustar ripleyusers# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # A copy of the GNU General Public License is available at # ../../COPYING ################################################################################ # CLASS: REPRESENTATION: # 'signalSeries' S4 Class representation # 'timeSeries' S4 Class representation ################################################################################ ## setClass("signalSeries", ## representation( ## .Data = "matrix", ## units = "character", ## recordIDs = "data.frame", ## title = "character", ## documentation = "character"), ## contains = "structure", ## validity = function(object) { ## if (NCOL(getDataPart(object)) != length(object@units)) ## return("length of '@units' not equal to '@.Data' extent") ## TRUE ## }) ## # ------------------------------------------------------------------------------ ## setClass("timeSeries", ## representation(positions = "numeric", ## format = "character", ## FinCenter = "character"), ## contains = "signalSeries", ## validity = function(object) { ## if (NROW(getDataPart(object)) != length(object@positions)) ## return("length of '@positions' not equal to '@.Data' extent") ## if (NCOL(getDataPart(object)) != length(object@units)) ## return("length of '@units' not equal to '@.Data' extent") ## TRUE ## }) ################################################################################ # Note if slots are added or removed, don't forget to edit # getDataPart,timeSeries-method and setDataPart,timeSeries-method !! setClass("timeSeries", representation(.Data = "matrix", units = "character", positions = "numeric", format = "character", FinCenter = "character", recordIDs = "data.frame", title = "character", documentation = "character"), contains = "structure", prototype(matrix(NA), units = character(0), positions = numeric(0), format = character(0), FinCenter = character(0), recordIDs = data.frame(), title = character(0), documentation = character(0))) # ------------------------------------------------------------------------------ .validity_timeSeries <- function(object) { if ((length(object@positions) > 0) && NROW(object) != length(object@positions)) return("length of '@positions' not equal to '@.Data' extent") if (NCOL(object) != length(object@units)) return("length of '@units' not equal to '@.Data' extent") if (NROW(object@recordIDs) > 0 & NROW(object@recordIDs) != nrow(object)) return("length of '@recordIDs' not equal to '@.Data' extent") TRUE } setValidity("timeSeries", .validity_timeSeries) # ------------------------------------------------------------------------------ # Note it is faster to assign manually all slots of the timeSeries objects. setMethod("initialize", "timeSeries", function(.Object, .Data = new("matrix"), units = character(0), positions = numeric(0), format = character(0), FinCenter = "", #<< FIXME: use identical in code rather than FinCenter == "" recordIDs = data.frame(), title = character(0), documentation = character(0)) { # as.double -> crucial for speed improvement in subsetting if (!is.double(positions)) positions <- as.double(positions) .Object <- timeSeries::setDataPart(.Object, value = .Data) `slot<-`(.Object, "units", value = units) `slot<-`(.Object, "positions", value = positions) `slot<-`(.Object, "format", value = format) `slot<-`(.Object, "FinCenter", value = FinCenter) `slot<-`(.Object, "recordIDs", value = recordIDs) `slot<-`(.Object, "title", value = title) `slot<-`(.Object, "documentation", value = documentation) # check only one we needs rather than using validObject anyStrings <- function(x) if (identical(x, TRUE)) character() else x error <- anyStrings(.validity_timeSeries(.Object)) if (length(error) > 0) stop(paste("Initialize timeSeries :", error, collapse = "\n"), call. = FALSE, domain = NA) .Object }) ################################################################################ timeSeries/NAMESPACE0000644000176000001440000001463511732460157013651 0ustar ripleyusers ################################################ ## import name space ################################################ import("graphics") import("grDevices") import("methods") import("stats") import("utils") import("timeDate") ################################################ ## S4 classes ################################################ exportClasses("index_timeSeries", "timeSeries", "time_timeSeries" ) export("colCummaxs", "colCummins", "colCumprods", "colCumreturns", "colCumsums", "outlier", "returns", "rowCumsums", "series", "series<-", "timeSeries" ) exportMethods("$", "$<-", "+", "-", "Ops", "[", "[<-", "aggregate", "align", "apply", "as.data.frame", "as.list", "as.matrix", "as.ts", "attach", "cbind2", "coerce", "colMeans", "colSums", "colnames", "colnames<-", "comment", "comment<-", "cummax", "cummin", "cumprod", "cumsum", "cut", "diff", "dim", "dim<-", "dimnames", "dimnames<-", "end", "filter", "finCenter", "finCenter<-", "frequency", "getDataPart", "head", "initialize", "is.na", "is.unsorted", "isDaily", "isMonthly", "isQuarterly", "isRegular", "lag", "lines", "merge", "na.contiguous", "na.omit", "names", "names<-", "plot", "points", "print", "quantile", "rank", "rbind2", "rev", "rownames", "rownames<-", "sample", "scale", "setDataPart", "show", "sort", "start", "str", "t", "tail", "time", "window" ) ################################################ ## S3 classes ################################################ S3method("aggregate", "timeSeries") S3method("as.data.frame", "timeSeries") S3method("as.list", "timeSeries") S3method("as.matrix", "timeSeries") S3method("as.timeSeries", "character") S3method("as.timeSeries", "data.frame") S3method("as.timeSeries", "default") S3method("as.timeSeries", "ts") S3method("as.timeSeries", "zoo") S3method("as.ts", "timeSeries") S3method("cbind", "timeSeries") S3method("cumulated", "default") S3method("cut", "timeSeries") S3method("diff", "timeSeries") S3method("end", "timeSeries") S3method("head", "timeSeries") S3method("lag", "timeSeries") S3method("lines", "timeSeries") S3method("merge", "timeSeries") S3method("na.omit", "timeSeries") S3method("plot", "timeSeries") S3method("points", "timeSeries") S3method("pretty", "timeSeries") S3method("rbind", "timeSeries") S3method("rev", "timeSeries") S3method("scale", "timeSeries") S3method("sort", "timeSeries") S3method("start", "timeSeries") S3method("str", "timeSeries") S3method("tail", "timeSeries") S3method("time", "timeSeries") S3method("time<-", "timeSeries") S3method("window", "timeSeries") ################################################ ## functions ################################################ export( ".DollarNames.timeSeries", ".aggregate.timeSeries", ".align.timeSeries", ".applySeries", ".as.data.frame.timeSeries", ".as.list.timeSeries", ".as.matrix.timeSeries", ".as.ts.timeSeries", ".cut.timeSeries", ".description", ".diff.timeSeries", ".dollar_assign", ".end.timeSeries", ".endOfPeriodBenchmarks", ".endOfPeriodSeries", ".endOfPeriodStats", ".extract.turnpointsPastecs", ".fapply", ".findIndex", ".head.timeSeries", ".isOHLC", ".isOHLCV", ".lines.timeSeries", ".lowessSmoother", ".merge.timeSeries", ".na.omit.timeSeries", ".naOmitMatrix", ".old2newRda", ".old2newTimeSeries", ".plot.timeSeries", ".plot.turnpointsPastecs", ".plotOHLC", ".plotTimeSeries", ".points.timeSeries", ".print.timeSeries", ".rev.timeSeries", ".rollmax.timeSeries", ".rollmean.timeSeries", ".rollmedian.timeSeries", ".rollmin.timeSeries", ".scale.timeSeries", ".signalCounts", ".signalSeries", ".sort.timeSeries", ".splineSmoother", ".start.timeSeries", ".str.timeSeries", ".subset_timeSeries", ".summary.turnpointsPastecs", ".supsmuSmoother", ".tail.timeSeries", ".time.timeSeries", ".timeSeries", ".turnpoints2", ".turnpointsPastecs", ".turnpointsSeries", ".turnpointsStats", ".validity_timeSeries", ".window.timeSeries", "alignDailySeries", "applySeries", "as.timeSeries", "colAvgs", "colKurtosis", "colMaxs", "colMins", "colProds", "colQuantiles", "colSds", "colSkewness", "colStats", "colStdevs", "colVars", "countMonthlyRecords", "cumulated", "description", "drawdowns", "drawdownsStats", "dummyDailySeries", "dummySeries", "durationSeries", "durations", "fapply", "getFinCenter", "getReturns", "getTime", "getUnits", "hclustColnames", "interpNA", "is.signalSeries", "is.timeSeries", "isMultivariate", "isUnivariate", "midquoteSeries", "midquotes", "newPositions<-", "ohlcDailyPlot", "orderColnames", "orderStatistics", "pcaColnames", "readSeries", "removeNA", "returnSeries", "rollDailySeries", "rollMax", "rollMean", "rollMedian", "rollMin", "rollMonthlySeries", "rollMonthlyWindows", "rollStats", "runlengths", "sampleColnames", "seriesData", "seriesPositions", "setFinCenter<-", "setTime<-", "setUnits<-", "smoothLowess", "smoothSpline", "smoothSupsmu", "sortColnames", "spreadSeries", "spreads", "statsColnames", "substituteNA", "time<-", "turns", "turnsStats" ) timeSeries/DESCRIPTION0000644000176000001440000000145512140125101014111 0ustar ripleyusersPackage: timeSeries Version: 3010.97 Revision: 5475 Date: 2013-03-25 Title: Rmetrics - Financial Time Series Objects Author: Diethelm Wuertz and Yohan Chalabi Depends: R (>= 2.10), graphics, grDevices, methods, stats, utils, timeDate (>= 2150.95) Suggests: robustbase, RUnit Maintainer: Yohan Chalabi Description: Environment for teaching "Financial Engineering and Computational Finance" Note: Several parts are still preliminary and may be changed in the future. this typically includes function and argument names, as well as defaults for arguments and return values. LazyData: yes License: GPL (>= 2) URL: http://www.rmetrics.org Packaged: 2013-03-25 13:46:51 UTC; yankee NeedsCompilation: no Repository: CRAN Date/Publication: 2013-05-01 07:38:09 timeSeries/ChangeLog0000644000176000001440000006271312124052512014170 0ustar ripleyusers2013-03-25 chalabi * DESCRIPTION: Updated version number * R/methods-mathOps.R: callGeneric() seems to have troubles in finding variables defined in the function frame and passed to the generic with the dots arguments. 2013-03-15 chalabi * ChangeLog, DESCRIPTION: Updated ChangeLog and DSC files * DESCRIPTION: Updated maintainer field and version number * R/zzz.R: Removed deprecated .First.lib() * R/base-apply.R: Added out of range test in apply,method-timeSeries 2013-02-22 tsetz * R/statistics-rollMean.R: functions rollMin and rollMax exchanged and function rollMin corrected, rollStats timeSeries name corrected 2012-08-12 chalabi * ChangeLog, DESCRIPTION: updated DESC and ChangeLog 2012-08-07 chalabi * DESCRIPTION: updated version number * R/base-subsetting.R: Removed C level call to 'find_interv_vec' due to changes in R-devel 2012-03-21 chalabi * ChangeLog, DESCRIPTION: updated ChangeLog and DESC * NAMESPACE, R/utils-getArgs.R, man/utils-getArgs.Rd: moved getArgs to fBasics where it was already defined * ChangeLog, DESCRIPTION: updated DESC and ChangeLog * man/utils-getArgs.Rd: added manual page for getArgs * R/utils-getArgs.R: getArgs() can now handle signature of length > 1 * NAMESPACE: added getArgs to NAMESPACE * R/methods-plot.R: pretty.timeSeries can not handle signal series * NAMESPACE: updated NAMESPACE * ChangeLog, DESCRIPTION: updated DESCRIPTION and ChangeLog * DESCRIPTION: updated version number 2012-03-20 chalabi * DESCRIPTION: updated DESC file 2012-03-20 wuertz * NAMESPACE: updated * R/timeSeries-slotSeries.R: had conflicts with mu fPortfolio * man/timeSeries-slotSeries.Rd: 2012-03-19 chalabi * DESCRIPTION: updated DSC * man/methods-plot.Rd: updated manual page * R/fin-daily.R: fixed patial argument names * data/LPP2005REC.rda, data/MSFT.rda, data/USDCHF.rda: resaved data to reduce file disk storage 2012-03-17 wuertz * man/methods-plot.Rd: plot examples updated for pretty label positions * ChangeLog, NAMESPACE, R/methods-plot.R, man/methods-plot.Rd: pretty added 2012-03-16 wuertz * R/fin-drawdowns.R: drawdowns made visible 2011-11-01 chalabi * DESCRIPTION, R/fin-align.R, R/fin-daily.R, man/fin-align.Rd, man/fin-daily.Rd: alignDailySeries is now based on the align timeSeries method which is now based on the align timeDate method in timeDate (>= 2150.95). * inst/unitTests/runit.TimeSeriesData.R: updated unit test with new lag,timeSeries-method * R/stats-lag.R: fixed lag,timeSeries method when colnames are provided by 'units' argument. * R/base-cbind.R: Better handling of FinCenter in cbind.timeSeries method. * R/timeSeries.R: timeSeries method now works also with non default FinCenter when timestamps are given as a numerical vector. 2011-10-24 chalabi * R/stats-lag.R, inst/unitTests/runit.lag.R: Thanks to Daniele Amberti, lag timeSeries methods now returns proper colnames when used with multiple lag indexes. * inst/unitTests/runit.merge.R: * R/base-merge.R: Thanks to Daniele Amberti, merge timeSeries method now poperly converts colnames to valid data.frame names. 2011-10-11 tsetz * R/fin-drawdowns.R: Drawdowns are now compatible to the results of the drawdown function from performanceAnalytics... 2011-09-23 mmaechler * DESCRIPTION: remove deprecated "LazyLoad" entry 2011-08-02 chalabi * ChangeLog, DESCRIPTION: updated DESC and ChangeLog 2011-05-04 chalabi * R/fin-align.R: Fixed integer overflow when dealing with very long historical data (1800 - today) in align method. 2011-04-21 wuertz * NAMESPACE, R/statistics-rollMean.R, man/statistics-rollMean.Rd: function rollStats added 2011-03-31 wuertz * NAMESPACE, R/fin-smooth.R, R/statistics-smoothLowess.R, man/base-rev.Rd, man/base-sort.Rd, man/base-start.Rd, man/fin-smooth.Rd, man/statistics-smoothLowess.Rd, man/timeSeries-readSeries.Rd, man/timeSeries-slotFinCenter.Rd, man/timeSeries-slotSeries.Rd, man/timeSeries-slotTime.Rd, man/timeSeries-slotUnits.Rd: help pages added and script files renamed * man/timeSeries-finCenter.Rd, man/timeSeries-slotFinCenter.Rd, man/timeSeries-slotUnits.Rd, man/utils-str.Rd, man/utils-structure.Rd: function renames * R/timeSeries-description.R, R/timeSeries-finCenter.R, R/timeSeries-series.R, R/timeSeries-slotFinCenter.R, R/timeSeries-slotSeries.R, R/timeSeries-slotTime.R, R/timeSeries-slotUnits.R, R/timeSeries-time.R, R/utils-description.R, R/utils-str.R, R/utils-structure.R: files renamed * man/timeSeries-description.Rd, man/timeSeries-series.Rd, man/timeSeries-slotSeries.Rd, man/timeSeries-slotTime.Rd, man/timeSeries-time.Rd, man/utils-description.Rd: files renamed * R/base-colCumsums.R, R/base-colSums.R, R/base-rowCumsums.R, R/fin-orderColnames.R, R/fin-orderStatistics.R, R/fin-rollmean.R, R/statistics-colCumsums.R, R/statistics-colSums.R, R/statistics-orderColnames.R, R/statistics-orderStatistics.R, R/statistics-rollMean.R, R/statistics-rowCumsums.R, man/base-colCumsums.Rd, man/base-colSums.Rd, man/base-rowCumsums.Rd, man/fin-orderColnames.Rd, man/fin-orderStatistics.Rd, man/fin-rollMean.Rd, man/statistics-colCumsums.Rd, man/statistics-colSums.Rd, man/statistics-orderColnames.Rd, man/statistics-orderStatistics.Rd, man/statistics-rollMean.Rd, man/statistics-rowCumsums.Rd: new file group for statistics and inference introduced. * NAMESPACE, R/aaa-Deprecated.R, R/base-Extract.R, R/base-attach.R, R/base-colSums.R, R/base-comment.R, R/base-rowCumsums.R, R/base-sort.R, R/base-start.R, R/base-subsetting.R, R/base-t.R, R/data-examples.R, R/fin-align.R, R/fin-daily.R, R/fin-drawdowns.R, R/fin-durations.R, R/fin-monthly.R, R/fin-periodical.R, R/fin-rollmean.R, R/fin-runlengths.R, R/fin-smooth.R, R/fin-splits.R, R/fin-spreads.R, R/fin-turnpoints.R, R/graphics-plot.R, R/methods-as.R, R/methods-comment.R, R/methods-is.R, R/methods-mathOps.R, R/methods-plot.R, R/old2new.R, R/stats-aggregate.R, R/stats-filter.R, R/stats-lag.R, R/stats-model.frame.R, R/stats-na.contiguous.R, R/stats-na.omit.R, R/stats-window.R, R/timeSeries-description.R, R/timeSeries-dummy.R, R/timeSeries-finCenter.R, R/timeSeries-getDataPart.R, R/timeSeries-isOHLC.R, R/timeSeries-isRegular.R, R/timeSeries-isUnivariate.R, R/timeSeries-readSeries.R, R/timeSeries-series.R, R/timeSeries-signalCounts.R, R/timeSeries-time.R, R/timeSeries.R, R/utils-getArgs.R, R/utils-head.R, R/utils-old2new.R, R/utils-str.R, man/00timeSeries-package.Rd, man/base-diff.Rd, man/base-merge.Rd, man/base-rev.Rd, man/base-sample.Rd, man/base-scale.Rd, man/base-sort.Rd, man/base-start.Rd, man/base-subsetting.Rd, man/data-examples.Rd, man/data.Rd, man/fin-align.Rd, man/fin-cumulated.Rd, man/fin-daily.Rd, man/fin-drawdowns.Rd, man/fin-durations.Rd, man/fin-periodical.Rd, man/fin-rollMean.Rd, man/fin-runlengths.Rd, man/fin-smooth.Rd, man/fin-splits.Rd, man/fin-turnpoints.Rd, man/graphics-plot.Rd, man/methods-comment.Rd, man/methods-plot.Rd, man/stats-window.Rd: several smaller updates: man pages improved, rolling statistics and smoother function added, some obsolete functions declared as deprecated. 2011-03-09 chalabi * ChangeLog, DESCRIPTION: updated DESC and ChangeLog * inst/doc: removed empty directory * DESCRIPTION: updated version number * R/timeSeries-readSeries.R: Fixed readSeries when reading tables with multiple columns. (Reported by Chris Breton). 2011-02-10 chalabi * ChangeLog, DESCRIPTION: updated Date and Revision field in DESC file and updated Changelog file * DESCRIPTION: updated DESC file * man/timeSeries-readSeries.Rd, man/timeSeries.Rd: added manual page for function readSeries() * inst/doc/TimeSeriesFAQ.pdf: removed pdf file because new version can be found on the website 2011-01-31 chalabi * R/timeSeries-readSeries.R, man/timeSeries.Rd: Added the optional 'format' argument and and a warning when the provided format produces NAs in readSeries function 2010-10-27 chalabi * ChangeLog, DESCRIPTION: updated DESC and ChangeLog file 2010-10-26 chalabi * R/base-cbind.R: cbind now extends vectors to match number of rows of the timeSeries object. 2010-09-30 chalabi * NAMESPACE: updated NAMESPACE 2010-09-24 chalabi * DESCRIPTION, NAMESPACE: updated NAMESPACE and version number in DESC file 2010-08-20 chalabi * R/stats-na.omit.R: removeNA is now the same as na.omit 2010-08-12 chalabi * R/graphics-plot.R: added grid function in .plotTimeSeries when using single plot type. * R/base-cbind.R, inst/unitTests/runit.bind.R: fixed issued reported by Thomas Etheber when using cbind method with timeSeries object with one record. 2010-07-26 chalabi * ChangeLog, DESCRIPTION: updated DESC and ChangeLog * DESCRIPTION: updated version number 2010-07-08 chalabi * R/methods-mathOps.R, R/stats-lag.R, R/stats-na.omit.R: improved support recordIDs * R/timeSeries-finCenter.R: cleanup code * R/base-apply.R, R/base-cbind.R, R/base-diff.R, R/base-rowCumsums.R, R/fin-runlengths.R: improved support of recordIDs 2010-07-06 chalabi * ChangeLog, DESCRIPTION: updated DESC and Changelog 2010-07-05 chalabi * R/methods-show.R: code cleanup 2010-07-02 chalabi * R/methods-show.R: Improved recordIDs handling in show method. 2010-05-17 chalabi * R/base-start.R: updated start/end to handle TZ 2010-04-22 chalabi * R/timeSeries-readSeries.R: improved dates management in readSeries() 2010-04-14 chalabi * NAMESPACE: updated NAMESPACE 2010-01-23 wuertz * NAMESPACE, R/aaa-Deprecated.R, R/fin-align.R, R/timeSeries-description.R, R/utils-getArgs.R: internal function .getArgs added 2010-01-22 wuertz * R/aaa-Deprecated.R, R/fin-durations.R, R/fin-spreads.R: deprecated functions moved to aaa-deprecated.R, started to clean up .... * R/fin-rollmean.R: code cleaned and description added * NAMESPACE, R/fin-runlength.R, R/fin-runlengths.R, man/fin-runlengths.Rd: .runlengths added 2010-01-06 chalabi * DESCRIPTION: updated version number * ChangeLog, DESCRIPTION: updated Changelog and DESC file * inst/unitTests/runit.aggregate.R, inst/unitTests/runit.subset.R: fixed unit tests for new years 2009-12-24 chalabi * NAMESPACE: updated NAMESPACE 2009-12-20 wuertz * NAMESPACE, R/fin-runlength.R: .runlengths() function added 2009-12-13 chalabi * DESCRIPTION: updated version number * ChangeLog, DESCRIPTION: updated Changelog and DESC file * man/base-subset.Rd: added aliased in manual pages 2009-12-10 chalabi * DESCRIPTION: updated version number * ChangeLog, DESCRIPTION: updated Changelog and DESC file * R/base-Extract.R: added completion method after the $ sign. * R/base-Extract.R, man/base-subset.Rd: updated signature list of timeSeries,$ method according to changes in r50609 in R-devel. 2009-10-26 wuertz * R/fin-drawdowns.R: example lin in script corrected 2009-10-05 chalabi * R/graphics-plot.R: improved handling of NA's in plot,timeSeries-method 2009-09-30 chalabi * inst/doc, inst/doc/TimeSeriesFAQ.pdf: added pdf files in inst/doc 2009-09-28 chalabi * DESCRIPTION: updated version number * ChangeLog, DESCRIPTION: updated DESCR and ChangeLog * R/AllClass.R: Added prototype in timeSeries class definition. 2009-09-02 chalabi * NAMESPACE, R/base-Extract.R, man/base-subset.Rd, man/timeSeries.Rd: added methods to subset timeSeries object with POSIXt and Date time stamps * NAMESPACE, R/stats-filter.R, man/stats-filter.Rd: added filter,timeSeries-method * NAMESPACE, R/base-t.R, man/base-t.Rd: added t,timeSeries-method * R/stats-na.contiguous.R, inst/unitTests/runit.na.contiguous.R, man/stats-na.contiguous.Rd: added na.contiguous,timeSeries-method. 2009-08-30 wuertz * R/base-apply.R: back to the previous version * R/base-attach.R: description added to attach * R/base-apply.R: apply should work now in all cases 2009-08-30 chalabi * NAMESPACE, R/timeSeries-isRegular.R, man/timeSeries-isRegular.Rd: isRegular methods are now proper S4 methods. 2009-08-30 wuertz * man/base-colCumsumsRd: file with missing dot deleted * man/base-colCumsums.Rd: missing dot in file name added 2009-08-28 wuertz * R/base-diff.R, R/methods-Ops.R, R/methods-mathOps.R, man/base-rowCumsums.Rd, man/fin-align.Rd, man/methods-DataPart.Rd, man/methods-align.Rd, man/methods-rowCum.Rd, man/time.Rd, man/timeSeries-getDataPart.Rd, man/timeSeries-time.Rd: renaming of man files finished * NAMESPACE, R/fin-monthly.R, R/fin-rollmean.R, R/timeSeries-isRegular.R, man/apply.Rd, man/base-apply.Rd, man/base-attach.Rd, man/base-cbind.Rd, man/base-colCumsumsRd, man/base-colSums.Rd, man/base-dim.Rd, man/base-rank.Rd, man/base-subset.Rd, man/colCum.Rd, man/colStats.Rd, man/cumulated.Rd, man/daily.Rd, man/description.Rd, man/drawdowns.Rd, man/durations.Rd, man/fin-cumulated.Rd, man/fin-daily.Rd, man/fin-drawdowns.Rd, man/fin-durations.Rd, man/fin-monthly.Rd, man/fin-orderColnames.Rd, man/fin-orderStatistics.Rd, man/fin-returns.Rd, man/fin-spreads.Rd, man/finCenter.Rd, man/graphics-plot.Rd, man/is.Rd, man/isUnivariate.Rd, man/lag.Rd, man/methods-aggregate.Rd, man/methods-attach.Rd, man/methods-bind.Rd, man/methods-dim.Rd, man/methods-is.Rd, man/methods-na.Rd, man/methods-plot.Rd, man/methods-returns.Rd, man/methods-str.Rd, man/methods-subset.Rd, man/model.frame.Rd, man/monthly.Rd, man/order.Rd, man/orderStatistics.Rd, man/rank.Rd, man/series.Rd, man/spreads.Rd, man/stats-aggregate.Rd, man/stats-lag.Rd, man/stats-model.frame.Rd, man/stats-na.omit.Rd, man/timeSeries-description.Rd, man/timeSeries-finCenter.Rd, man/timeSeries-isRegular.Rd, man/timeSeries-isUnivariate.Rd, man/timeSeries-series.Rd, man/utils-str.Rd: man script files Rd renamed to be more compatible with the script R files and the eBook * man/colCum.Rd: deleted by mistake * man/colCum.Rd: * R/timeSeries-isPeriod.R: isPeriod file no longer needed 2009-08-27 wuertz * inst/unitTests/runit.NA.R, inst/unitTests/runit.Omit.R, inst/unitTests/runit.TimeSeriesClass.R, inst/unitTests/runit.TimeSeriesCoercion.R, inst/unitTests/runit.TimeSeriesData.R, inst/unitTests/runit.TimeSeriesPositions.R, inst/unitTests/runit.aggregate.R, inst/unitTests/runit.align.R, inst/unitTests/runit.apply.R, inst/unitTests/runit.as.R, inst/unitTests/runit.attach.R, inst/unitTests/runit.bind.R, inst/unitTests/runit.colCum.R, inst/unitTests/runit.colStats.R, inst/unitTests/runit.cor.R, inst/unitTests/runit.cumulated.R, inst/unitTests/runit.daily.R, inst/unitTests/runit.dim.R, inst/unitTests/runit.drawdowns.R, inst/unitTests/runit.durations.R, inst/unitTests/runit.lag.R, inst/unitTests/runit.mathOps.R, inst/unitTests/runit.merge.R, inst/unitTests/runit.methods-plot.R, inst/unitTests/runit.methods-print.R, inst/unitTests/runit.methods-summary.R, inst/unitTests/runit.model.frame.R, inst/unitTests/runit.monthly.R, inst/unitTests/runit.order.R, inst/unitTests/runit.periodical.R, inst/unitTests/runit.rank.R, inst/unitTests/runit.returns.R, inst/unitTests/runit.rowCum.R, inst/unitTests/runit.signalCounts.R, inst/unitTests/runit.spreads.R, inst/unitTests/runit.subset.R, inst/unitTests/runit.time.R, inst/unitTests/runit.timeSeries.R, man/apply.Rd, man/colCum.Rd, man/colStats.Rd, man/cumulated.Rd, man/daily.Rd, man/data.Rd, man/description.Rd, man/drawdowns.Rd, man/durations.Rd, man/finCenter.Rd, man/is.Rd, man/isUnivariate.Rd, man/lag.Rd, man/methods-DataPart.Rd, man/methods-aggregate.Rd, man/methods-align.Rd, man/methods-as.Rd, man/methods-attach.Rd, man/methods-base.Rd, man/methods-bind.Rd, man/methods-comment.Rd, man/methods-dim.Rd, man/methods-mathOps.Rd, man/methods-na.Rd, man/methods-plot.Rd, man/methods-returns.Rd, man/methods-rowCum.Rd, man/methods-show.Rd, man/methods-stats.Rd, man/methods-str.Rd, man/methods-subset.Rd, man/model.frame.Rd, man/monthly.Rd, man/order.Rd, man/orderStatistics.Rd, man/rank.Rd, man/series.Rd, man/spreads.Rd, man/time.Rd, man/timeSeries.Rd: As a consequnece of introducing rda data files I have adapted all manual pages and all unit test files where it was necessary * data/LPP2005REC.rda, data/MSFT.rda, data/USDCHF.rda: now the rda files are there * data/LPP2005REC.Rda, data/MSFT.Rda, data/USDCHF.Rda: data files removed * data/LPP2005REC.Rda, data/LPP2005REC.csv, data/MSFT.Rda, data/USDCHF.Rda: Rda data files added, csv deleted, now all data files are in the same format makes life easier * data/MSFT.rda, data/msft.dat.csv, data/usdchf.csv: csv and rda files deleted 2009-08-17 chalabi * R/base-colCumsums.R, inst/unitTests/runit.colCum.R: Rewrite all Colcum methods to take advantages of new apply,timeSeries-methods. * R/base-apply.R: Improved apply,timeSeries-method to handle timeSeries with one row. * NAMESPACE: new NAMESPACE structure which should ease maintenance of packages. * R/methods-show.R: show,timeSeries-method is now more friendly with default "max.print" R option. * DESCRIPTION, NAMESPACE, R/base-Extract.R, R/base-cbind.R, R/base-merge.R, R/methods-Ops.R, R/methods-as.R, R/methods-show.R, R/timeSeries.R, inst/unitTests/runit.bind.R, man/methods-bind.Rd: Merge branch 'devel-timeSeries' Conflicts: pkg/timeSeries/R/base-Extract.R pkg/timeSeries/R/timeSeries.R * NAMESPACE, R/AllClass.R, R/base-Extract.R, R/timeSeries-getDataPart.R, man/methods-subset.Rd: better handling of @recordIDs with $<-,timeSeries-method. * R/methods-as.R: improved as.ts,timeSeries-method with monthly and quarterly data. 2009-06-13 chalabi * R/base-Extract.R: Improved $,timeSeries-method when matching names in @recordIDs * R/AllClass.R, R/base-Extract.R, R/base-dim.R: names,timeSeries-method returns now also the names of data in @recordIDs. names<-,timeSeries-methods works both for data part and @recordIDs. 2009-05-17 wuertz * inst/unitTests/runit.TimeSeriesCoercion.R: unit tests - still to be updated as.ts * man/methods-as.Rd, man/methods-bind.Rd, man/timeSeries.Rd: man pages updated * NAMESPACE: namespace adapted * NAMESPACE: * R/AllClass.R, R/AllGeneric.R, R/base-Extract.R, R/base-apply.R, R/base-attach.R, R/base-cbind.R, R/base-colCumsums.R, R/base-colSums.R, R/base-comment.R, R/base-diff.R, R/base-dim.R, R/base-merge.R, R/base-rank.R, R/base-rev.R, R/base-rowCumsums.R, R/base-sample.R, R/base-scale.R, R/base-sort.R, R/base-start.R, R/base-subset.R, R/fin-align.R, R/fin-cumulated.R, R/fin-daily.R, R/fin-drawdowns.R, R/fin-durations.R, R/fin-monthly.R, R/fin-orderColnames.R, R/fin-orderStatistics.R, R/fin-periodical.R, R/fin-returns.R, R/fin-smooth.R, R/fin-splits.R, R/fin-spreads.R, R/fin-turnpoints.R, R/graphics-plot.R, R/methods-Ops.R, R/methods-as.R, R/methods-is.R, R/methods-show.R, R/old2new.R, R/stats-aggregate.R, R/stats-lag.R, R/stats-model.frame.R, R/stats-na.omit.R, R/stats-window.R, R/timeSeries-description.R, R/timeSeries-dummy.R, R/timeSeries-finCenter.R, R/timeSeries-getDataPart.R, R/timeSeries-isOHLC.R, R/timeSeries-isPeriod.R, R/timeSeries-isUnivariate.R, R/timeSeries-readSeries.R, R/timeSeries-series.R, R/timeSeries-signalCounts.R, R/timeSeries-time.R, R/timeSeries.R, R/utils-head.R, R/utils-str.R, R/zzz.R: NEW FILE ORDERING CHECKED IN ... * R/AllClass.R, R/AllGeneric.R, R/colCum.R, R/colStats.R, R/cumulated.R, R/daily.R, R/description.R, R/drawdowns.R, R/dummy.R, R/durations.R, R/is.R, R/isUnivariate.R, R/methods-DataPart.R, R/methods-aggregate.R, R/methods-align.R, R/methods-apply.R, R/methods-as.R, R/methods-attach.R, R/methods-bind.R, R/methods-comment.R, R/methods-dim.R, R/methods-finCenter.R, R/methods-head.R, R/methods-lag.R, R/methods-mathOps.R, R/methods-merge.R, R/methods-na.R, R/methods-outlier.R, R/methods-plot.R, R/methods-returns.R, R/methods-rowCum.R, R/methods-series.R, R/methods-show.R, R/methods-str.R, R/methods-subset.R, R/methods-tail.R, R/methods-window.R, R/model.frame.R, R/monthly.R, R/old2new.R, R/order.R, R/orderStatistics.R, R/periodical.R, R/rank.R, R/readSeries.R, R/signalCounts.R, R/spreads.R, R/time.R, R/timeSeries.R, R/turnpoints.R, R/zzz.R: 2009-05-07 wuertz * R/methods-show.R: .print.timeSeries missing column names fixed on "h" style can now also handle "%Q" format for quarterly data * R/methods-plot.R: .plotTimeSeries can now handle different colors and plot symbols for multivariate series 2009-04-19 chalabi * DESCRIPTION: added explicit version number in Depends field for key packages * R/methods-aggregate.R: fixed colnames in aggregate,timeSeries-method * R/AllClass.R: initialize,timeSeries-method checks object with validObject * R/colStats.R: added colMeans and colSums,timeSeries-method because default function is unefficient with large timeSeries objects. 2009-04-02 chalabi * NAMESPACE: updated NAMESPACE * DESCRIPTION: more explicit depends and suggests field in DESC file. 2009-04-01 chalabi * DESCRIPTION: updated DESC file 2009-03-31 chalabi * R/AllClass.R, R/is.R, R/methods-DataPart.R: small changes to make timeSeries work with R-2.7.0. 2009-03-30 chalabi * man/data.Rd: added MSFT (timeSeries version of mstf.dat) in data folder. * NAMESPACE, R/AllClass.R, R/zzz.R: define S4 class 'difftime' with 'setOldClass()'. We will keep it until 'methods' pkg will define it alongside the other old 'base' classes. * R/methods-mathOps.R, R/timeSeries.R, inst/unitTests/runit.mathOps.R, inst/unitTests/runit.timeSeries.R, man/methods-mathOps.Rd: added explicit methods for Ops with 'ts' and 'timeSeries' arguments. 2009-03-25 chalabi * data/MSFT.rda: added timeSeries version of msft.dat dataset 2009-03-19 chalabi * R/is.R, R/methods-aggregate.R, R/methods-as.R, R/methods-bind.R, R/methods-dim.R, R/methods-head.R, R/methods-lag.R, R/methods-mathOps.R, R/methods-merge.R, R/methods-na.R, R/methods-plot.R, R/methods-str.R, R/methods-tail.R, R/methods-window.R, R/model.frame.R, R/time.R, man/lag.Rd, man/methods-aggregate.Rd, man/methods-as.Rd, man/methods-bind.Rd, man/methods-mathOps.Rd, man/methods-na.Rd, man/methods-subset.Rd, man/time.Rd: 'base' generics have now S3 and S4 methods. S3 methods are used because 'UseMethod' does not dispatch S4 methods in 'base' functions. For example 'base' functions starting with something like 'as.list' would failed without the S3 method. * R/old2new.R: added functions to convert old timeSeries format to new class 'timeSeries' * R/methods-subset.R, R/time.R, R/timeSeries.R: @positions is numeric and makes timeSeries object much faster. * R/methods-show.R, R/zzz.R: added getRmetricsOptions("max.print") * R/methods-bind.R, R/methods-merge.R: new implementation of [cb]bind and merge functions * R/is.R: added function is.signalSeries * R/methods-tail.R: optimized tail for large timeSeries * R/methods-as.R, man/methods-as.Rd: new as.list.timeSeries S3 methods. This means that functions like sapply and lapply can now work with timeSeries objects. * R/methods-bind.R, man/methods-bind.Rd: new cbind and rbind implementation in S3 method since methods:::bind_activation might create problems. Names of arguments are now supported. * R/methods-series.R: series<-,matrix-method uses now the new timeSeires() methods. * R/methods-as.R: new implementation of as.timeSeries.data.frame. Should has the same features as the previous implementation. * R/daily.R, R/methods-dim.R: improved handling of colnames and unit. functions like var() should now returns with the appropriate colnames. * R/AllClass.R, R/AllGeneric.R, R/timeSeries.R, man/timeSeries.Rd: timeSeries() is now a generic function with methods. timeSeries() should now take advantage of new implementation of timeDate() and should be faster in creating new timeSeries objects. * R/methods-subset.R: added $,timeSeries method with auto-completion of column names * NAMESPACE, R/methods-dim.R: added name,timeSeries method which return the column names 2009-02-04 chalabi * ChangeLog: * inst/NEWS: * DESCRIPTION: updated version number 2009-01-29 chalabi * R/methods-aggregate.R, man/methods-aggregate.Rd: improved aggregate,timeSeries-method 2009-01-28 chalabi * R/methods-plot.R: small changed in plot,timeSeries to avoid warning when dealing with signal series * R/methods-subset.R: timeSeries()[''] now returns a nuermic(NA) instead of logical(NA) * inst/unitTests/runit.subset.R: added RUnit test with subsetting 2009-01-12 chalabi * man/apply.Rd: fixed warning with new Rd parser * R/AllClass.R: use getDataPart method * R/is.R: use getDataPart method * R/methods-as.R: change as.matrix to use the getDatPart method * R/methods-subset.R: improved speed of sub-setting and sub-assignment and fixed problem when sub-setting with character argument without comma. * R/methods-dim.R, R/methods-head.R, R/methods-show.R, R/methods-tail.R: faster method * R/methods-bind.R: fixed colnames problem with c,rbind * NAMESPACE, R/methods-DataPart.R: added getDataPart,timeSeries method 2009-01-11 wuertz * R/align.R: old align.R script removed * R/methods-align.R: align established as method filename renamed 2009-01-07 wuertz * NAMESPACE, R/align.R, inst/unitTests/runit.aggregate.R, inst/unitTests/runit.subset.R, man/methods-align.Rd: unit tests which failed from the change 2008 to 2009 repaired, function align added the same as .align.timeSeries and documented, added to namespace 2009-01-06 wuertz * R/methods-aggregate.R: example modified was not working for 2009 * R/methods-lag.R: example modified