xts/ 0000755 0001762 0000144 00000000000 14703523232 011071 5 ustar ligges users xts/tests/ 0000755 0001762 0000144 00000000000 14702522224 012232 5 ustar ligges users xts/tests/tinytest.R 0000644 0001762 0000144 00000000672 14702522224 014245 0 ustar ligges users # run package unit tests
if (requireNamespace("tinytest", quietly = TRUE)) {
suppressPackageStartupMessages(library("xts"))
use_color <- as.logical(Sys.getenv("_PKG_TINYTEST_COLOR_", FALSE))
verbosity <- as.integer(Sys.getenv("_PKG_TINYTEST_VERBOSE_", 1))
cat("tinytest colored output:", use_color,
"\ntinytest verbosity:", verbosity, "\n")
tinytest::test_package("xts", color = use_color, verbose = verbosity)
}
xts/MD5 0000644 0001762 0000144 00000024262 14703523232 011407 0 ustar ligges users 896fa2f025ba7e4bbfd4a5d9bf3b3110 *DESCRIPTION
8d109e152836d68726ca4ad3a9fcd5ee *NAMESPACE
bf55c9d4b0ab774609f105bb5373ac72 *NEWS.md
13a4d087d20c9296a93a4e7daf48d8be *R/Date.R
9a9e41ee0a003e798ccabff5e10c3b04 *R/Math.xts.R
111bccff1a4d380bff44b14bdff23fa3 *R/OHLC.R
c2ef20cbcbf35a1d1c98d0c50589fe81 *R/Ops.xts.R
187fce032fe9c8b0f2d1617b3a8819e1 *R/POSIX.R
d79b3d7e48a62b93c930de0a71b59c69 *R/adj.time.R
5e30116de2ec1a593ed9b21f50f0c58d *R/align.time.R
719a384387f0229a76a1e28883bdfa62 *R/all.equal.R
69e7d41b342c8b5b5831142207f9e77c *R/as.environment.xts.R
3854d55602258e5e5e2f9c4c165edd33 *R/as.numeric.R
85a4d6658ac4ed00d47939447b14c35b *R/axTicksByTime.R
61c4324133b2263fa9e5a95a898df871 *R/bind.R
1a1014c478e9498604867f18a522cf15 *R/coredata.xts.R
a62e13734091171a8cc697f8d63fb941 *R/data.frame.R
a175decdc727e56ac811c35cb96dcbbe *R/dimnames.R
edc446ca16acada8f0015add2151f68b *R/endpoints.R
2f0b31a5bcd2df6ff3ea4baa7a16b77d *R/first.R
acdda8c521fe61c300fe9866b500db4f *R/index.R
15cef7a8e3232ea1b8515331ca0285af *R/irts.R
6d3b847230363a674d11959938e1be79 *R/isOrdered.R
a55d1464f2877692bffd8dc284052483 *R/lag.xts.R
5b7c1546bcc98af59701cd0a8d210f5b *R/last.R
2b6ac08a19465c8f082b8bda4b543c28 *R/list.R
1b0f3343529429f934b16a714fd1a131 *R/matrix.R
2503ee75bc5ceaeaaba573a8e90058aa *R/merge.R
371654b7ba3f1d48e9c39eea77f4f58f *R/modify.args.R
4d30e9f7f637e4872d0392c0436fb0c4 *R/na.R
365a50fcf07717f387a618fc4edebb7f *R/nperiods.R
f7016e97f94c2bfb2c7ce34877e7f4d5 *R/origin.fix.R
a33c7b4d2606bfde5b3f260f78a1bb02 *R/parse8601.R
f311a96152cc09db7c8e09652e8ee23c *R/period.R
ad50f4ef7687e36f7d329ec16a19cbb9 *R/period.apply.R
0832d8b88027394fb093521164aca44c *R/periodicity.R
c99642a0afe07d468aebec835db3402a *R/plot.R
adb99ee829ce42523e56ce58c6db8036 *R/print.R
587766097ce7edf9ab923b1b0f4a90c3 *R/reclass.R
1517c9051358464b9b0450b4be931c17 *R/rollapply.xts.R
9665fa327a6762098c18cd4c7bfa2c8f *R/split.R
015c507263eb0e0e3382b16f60836bb3 *R/start.R
e80dd17312e93580379a96b81b4b5510 *R/startOfYear.R
8ac7f617f8cc6c11f0e974169d8f42c5 *R/str.R
39d15e2bed04e0d6d698597374d556a0 *R/tclass.R
4fefc28a68ff070d4e3aa3f294949002 *R/tformat.R
dd86b3fdd667b41841f55544f728e64e *R/timeBasedRange.R
4c5e863153e9dc9a8423a0f7814c1de5 *R/timeBasedSeq.R
b2cdfd460e70f9e7e4a810d08cf01a8f *R/timeDate.R
85be96f160431b64f0ef2efe647df272 *R/timeSeries.R
fbbd08e88d7a152f313bc679972ecc17 *R/toperiod.R
b2c1bbf5daa17fad7960ce6b73cf12a7 *R/ts.R
7d7da34e53c6a87bb4764990ef5238d3 *R/tzone.R
d53f58770c0c597019f4f12959e35a54 *R/utils.R
3cb664b4811affcee63d885fdb4719a6 *R/xts-package.R
03dcb034252a8d451a764f7d44f9e8da *R/xts.R
5d9bb181816baae33ef3df318a051f65 *R/xts.methods.R
bfcb5771a061dfd6d6c168be0fd4ef66 *R/yearmon.R
6ed20824a80602ace874fbc43b859902 *R/zoo.R
ac12dbb14b106eed16be76bba725f338 *R/zzz.R
8610078036551f864b330b180a87e2a4 *README.md
2a51be2906d8327018de52b80df9bbd4 *build/vignette.rds
e25f1e32e3b80ef3ff29d103a2c841c9 *data/sample_matrix.rda
d273075b03c4d62b61a42ba4217bf49e *inst/api_example/DESCRIPTION
55d4cc70531955e6a4fd244e7d84c6c1 *inst/api_example/NAMESPACE
6497fbcaf2b3a892cb3dd0776a233dc6 *inst/api_example/R/checkOrder.R
df23f6d544fca7b695962d1f4421bb99 *inst/api_example/README
09118e96879feba050a17474ceff8a8d *inst/api_example/man/checkOrder.Rd
e24ef2161cbc80e1297fe776762ba86d *inst/api_example/man/linkXTS-package.Rd
c0648d7cd58a619e37191ce4f80c6e9f *inst/api_example/src/checkOrder.c
aaa8de0969962f40c9e2d069e115430c *inst/benchmarks/benchmark.subset.R
e45027a27ff403b51af95ea2f1945d95 *inst/doc/xts-faq.R
71177aa2e5c7c8cf3cc3f91b5e635cfe *inst/doc/xts-faq.Rnw
ce79634b8ede1e57d4a3799edeab7c30 *inst/doc/xts-faq.pdf
3d81a4a65b40e6b1cd3cec726449d49d *inst/doc/xts.R
ff730516ee7c76aaabb6b97bbb326b53 *inst/doc/xts.Rnw
e6cb9343ecb1b7604bdfb9695170d975 *inst/doc/xts.pdf
d415cb5e7772a846f462beaeaeb4aebf *inst/include/xts.h
086af5ee3a7aca5dfcaac1096ac4246d *inst/include/xtsAPI.h
fb8b821627015068f6c24f22e183728a *inst/include/xts_stubs.c
ca0456713e0804be8a3c74c37fabd9bd *inst/tinytest/runit.rowSums-rowMeans.R
dce145c15320daf4a6b65e76a9fa5e18 *inst/tinytest/test-Ops.R
e4406914c419f5e370c6481be56b6bb0 *inst/tinytest/test-align.time.R
cb990770472c5bd58bea7ef19624d0d6 *inst/tinytest/test-all.equal.R
9a23ca91be43cb533e70b3ee7125d338 *inst/tinytest/test-binsearch.R
33e1cab561e827bcfc9c7d7668bac885 *inst/tinytest/test-coredata.R
84b4bb6b7855a074d3233a239abc6fc3 *inst/tinytest/test-data.frame.R
5867588c1558b0940d1906fc9ff20097 *inst/tinytest/test-diff.R
ddade7a38f6c21542bdfd50ea2e26915 *inst/tinytest/test-dimnames.R
48a0394f33c87625f436c3af133c07ae *inst/tinytest/test-endpoints.R
e8eb1428568d8bb2ae6e8b37ffb4ed92 *inst/tinytest/test-first-last.R
53d7177c598db078cb35dd52bbed43fb *inst/tinytest/test-index.R
ef46414a4700a955d3b6dd23ef044245 *inst/tinytest/test-irts.R
d1ea8d93f0a9f8ed68d6065262b81f22 *inst/tinytest/test-isordered.R
cf9bfd641615dcb427934adf47859b43 *inst/tinytest/test-lag.R
c95214b252e3204228dd12776b1f8a2c *inst/tinytest/test-matrix.R
5319df2f5cc00d328d464f58e27e4bbd *inst/tinytest/test-merge.R
6d05dc15e012ad76ca468fc08b65c65d *inst/tinytest/test-na.fill.R
c34cbb79cf898c3e4e18cdb993824bd5 *inst/tinytest/test-na.locf.R
57ce6a9082199275ff24c3ab15df05d7 *inst/tinytest/test-na.omit.R
189e95e4940e6ea9fe9464e55f98923b *inst/tinytest/test-parseISO8601.R
ba463b3d1841f34648b1f8e33a91974b *inst/tinytest/test-period.apply.R
939ea7f949fdeae74619591faea3f1f2 *inst/tinytest/test-periodicity.R
70a787661c83533b3f915c36a6e44be4 *inst/tinytest/test-plot.R
082f8b19f7b4e1ce38ca455a1b1d4e05 *inst/tinytest/test-print.R
f1a83dc9f2eaeee878bd7138b2759088 *inst/tinytest/test-reclass.R
b6b66b3cfa0727eaf1def392611bd5d5 *inst/tinytest/test-split.R
270a4ad5c57f259f69244a2f90e40bee *inst/tinytest/test-subset-time-of-day.R
8d7543cb5014325353472f6fdbe4ff2e *inst/tinytest/test-subset.R
917eed127e060a2028d5c653da03f0a2 *inst/tinytest/test-tclass.R
2406e4f31af0d8b18720b19e33a356a9 *inst/tinytest/test-tformat.R
0b700524e0885b162f0536f8c892df63 *inst/tinytest/test-timeBasedSeq.R
db8f51cd33ed4db2c324a95704e5316d *inst/tinytest/test-timeSeries.R
5ef6c25f551d5b7dee43d2ec7182bce7 *inst/tinytest/test-to.period.R
0ef61cea7a0d5818d57a84be6557d253 *inst/tinytest/test-ts.R
71a0014e95a45208e500ae88ccdd2809 *inst/tinytest/test-tzone.R
866a2d8b6ec3fa41316727f3366597d1 *inst/tinytest/test-xts.R
3f2a81d0c93d39369ad40fde049b5c57 *inst/tinytest/test-xts.methods.R
c55d666140103d930dcd40754a28dd3c *inst/tinytest/test-zoo.R
0fca212ba456c3993191f3b18cd41b4a *man/CLASS.Rd
9bd5f4a6241f497f60a2a8e07e9eaa48 *man/addEventLines.Rd
7c16ff70f9e563555085a6447517fc4d *man/addLegend.Rd
a2a5d513493e88e4db004ab9860e5188 *man/addPanel.Rd
15e5bfc37bba693bcdf55416cf37d8b9 *man/addPolygon.Rd
4554dd68ce6833f01b23a5d4c4aec4b5 *man/addSeries.Rd
211b22b5c985f96dc7248b2a20ed654c *man/align.time.Rd
9f1e893b1c0d1a43ffce5236ce725359 *man/apply.monthly.Rd
754a2b311c832d96a4519e261f51bc47 *man/as.environment.xts.Rd
ec5ca7a5f1fe83bee2e5219c7a9f251e *man/as.xts.Rd
01cd14a3e920251beb58aa9876ab21bb *man/axTicksByTime.Rd
aaf5dd3389385a04c16a1698208b17a8 *man/coredata.xts.Rd
8a803fcd5b39753706b655e43db0defd *man/diff.xts.Rd
f260f3946100bbed3ee52ec37fdbeed1 *man/dimnames.xts.Rd
a1b3867b33361972d4927d1dff0d5f1e *man/endpoints.Rd
a1260ca32c2ec63d4eda7044284f4fbb *man/first.Rd
9001160596bf7fb42b2954de8d1ac4e4 *man/firstof.Rd
c013c792539377623137797077ce516f *man/index.xts.Rd
ca4105116cc570760f1332167078b495 *man/isOrdered.Rd
3d7690ea93f681bde0b44de136388227 *man/make.index.unique.Rd
96f15c80498132cebadd903eb041fb9d *man/merge.xts.Rd
b9efca06212de054c15037af26f31e57 *man/na.locf.xts.Rd
cacfffc5e4946902fc0e3659f415844b *man/ndays.Rd
4fc896dab44c718a075e897a4df3280d *man/parseISO8601.Rd
58288fa74051abebbb9f20d946727f65 *man/period.apply.Rd
7201acae67a0cefc4b613f65ead0ed10 *man/period_math.Rd
71875c7f7b461b1b28a9272de416bcd4 *man/periodicity.Rd
dceb0782ff76a34641720c2a2d6182fc *man/plot.xts.Rd
becbb33ddcbc405d82ce9a1d8a3ed838 *man/print.xts.Rd
f8298a87d8208fbc2f405affc28d80e6 *man/rbind.xts.Rd
e4e1421d9f034eb2253b5d54e30ff653 *man/reclass.Rd
03bfabb3754364845f6b6d262d5fbd83 *man/sample.data.Rd
11a2562aa4804cce38362f5fd77ca7e3 *man/split.xts.Rd
7bc9167cd9971127480369f517be7ccd *man/subset.xts.Rd
f551c16ce8192173d38359c689f6f5e0 *man/tclass.Rd
5e5a59e254e1c7a4656f92cb6b793d33 *man/tformat.Rd
5b158dfbd2d354c73eb8f623983c7d16 *man/timeBased.Rd
20bcba1ebebadffa3d7b34b1ed59b87b *man/timeBasedSeq.Rd
626c294bd8cf5bf889e0438f4862b838 *man/to.period.Rd
14868cc17a2908eacc75935aedfd8213 *man/tzone.Rd
2bfdc0f8e2ebb0b54d17d01bce764000 *man/window.xts.Rd
2929e244a621384bbc08a79fe3b11621 *man/xts-internals.Rd
bd9168fb6aee9477153d3954ac8f007d *man/xts-package.Rd
cd8ba60d194ecedf2d8c862f27dbcd3e *man/xts.Rd
afc7f16f7f8aac67c7e2067d41fcba2d *man/xtsAPI.Rd
6f32697828e85b03121a85f26c04bb3e *man/xtsAttributes.Rd
3f03da795dd26373156bddc78d41e95d *src/Makevars
3f03da795dd26373156bddc78d41e95d *src/Makevars.win
6b0374aa67a0cb5dd38f879e708132b4 *src/add_class.c
f485a4c5521e77204579b020f825bccc *src/any.c
352b7b0f1c8c49702baf9945fd20ff5f *src/attr.c
d1eb6437796db5e54605264b1f3548cc *src/binsearch.c
c91fe2075d20c8cf572452b7a69d4f5c *src/coredata.c
c9aa1258d5793b5bde6e98974b9700b1 *src/dimnames.c
4d148e934a4f7b8c13d06f356f79e246 *src/endpoints.c
56be552537e6dfb9e4cd32adf66d2522 *src/extract_col.c
f76f72c7348fe190d1b22376df918d9a *src/init.c
5a1131c5c4cda826587411b399762e94 *src/isOrdered.c
6406378662cae4ddb780b572e3c207f5 *src/isXts.c
76eef6c210f46da6f0f43f388096b1a7 *src/lag.c
b1c669347285967a1dd0b282ef0ed09c *src/merge.c
100daa62d01821334ed99b3d5a0667b2 *src/na.c
da1b6df2c0b5b64c331335cf525dc143 *src/period_apply.c
98c3542c73b9d2e3bcb0874c93c199c8 *src/period_arithmetic.c
9d155812d858824aed442e88555e4e27 *src/period_quantile.c
1d7cd5483505427cfd2e6776e14d571f *src/rbind.c
7a60c01780f630c072175e7134ef08d9 *src/rollfun.c
b6339594a3cf5d8dde13a6f9f771187c *src/runSum.c
e0c8a91a3f89dc44f3d3033a3c7c8335 *src/startofyear.c
8b82aa3c1336652137236dfbdce1123c *src/subset.c
215a490e1edcdbf627eea9fe03f5359b *src/subset.old.c
0139eb8441e8dffcfc001dc33b1986e4 *src/toperiod.c
8b6df2194602bcec234c8840a3121e3e *src/totalcols.c
4c2811f9dd0f501b9105838cd78c2652 *src/tryXts.c
ddcf2148cb8071a63182c5721e80b404 *src/unique.time.c
74a087b663e6fb7a2eaec9ec333120b6 *src/xts.c
72514cfd44456eea7b95ba4701c92887 *tests/tinytest.R
71177aa2e5c7c8cf3cc3f91b5e635cfe *vignettes/xts-faq.Rnw
ff730516ee7c76aaabb6b97bbb326b53 *vignettes/xts.Rnw
xts/R/ 0000755 0001762 0000144 00000000000 14703504524 011275 5 ustar ligges users xts/R/tzone.R 0000644 0001762 0000144 00000015422 14702273721 012564 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname tzone
indexTZ <- function(x, ...)
{
.Deprecated("tzone", "xts")
tzone(x, ...)
}
#' Get or Replace the Timezone of an xts Object's Index
#'
#' Generic functions to get or replace the timezone of an xts object's index.
#'
#' Internally, an xts object's index is a *numeric* value corresponding to
#' seconds since the epoch in the UTC timezone. When an xts object is created,
#' all time index values are converted internally to [`POSIXct()`]
#' (which is also in seconds since the UNIX epoch), using the underlying OS
#' conventions and the \env{TZ} environment variable. The `xts()` function
#' manages timezone information as transparently as possible.
#'
#' The `tzone<-` function *does not* change the internal index values
#' (i.e. the index will remain the same time in the UTC timezone).
#'
#' @param x An xts object.
#' @param value A valid timezone value (see [`OlsonNames()`]).
#' @param \dots Arguments passed to other methods.
#'
#' @return A one element named vector containing the timezone of the object's
#' index.
#'
#' @note Both `indexTZ()` and `indexTZ<-` are deprecated in favor of
#' `tzone()` and `tzone<-`, respectively.
#'
#' Problems may arise when an object that had been created under one timezone
#' are used in a session using another timezone. This isn't usually a issue,
#' but when it is a warning is given upon printing or subsetting. This warning
#' may be suppressed by setting `options(xts_check_TZ = FALSE)`.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`index()`][xts::index.xts] has more information on the xts index, [`tformat()`]
#' describes how the index values are formatted when printed, and [`tclass()`]
#' provides details how \pkg{xts} handles the class of the index.
#'
#' @keywords ts utilities
#' @examples
#'
#' # Date indexes always have a "UTC" timezone
#' x <- xts(1, Sys.Date())
#' tzone(x)
#' str(x)
#' print(x)
#'
#' # The default 'tzone' is blank -- your machine's local timezone,
#' # determined by the 'TZ' environment variable.
#' x <- xts(1, Sys.time())
#' tzone(x)
#' str(x)
#'
#' # now set 'tzone' to different values
#' tzone(x) <- "UTC"
#' str(x)
#'
#' tzone(x) <- "America/Chicago"
#' str(x)
#'
#' y <- timeBasedSeq('2010-01-01/2010-01-03 12:00/H')
#' y <- xts(seq_along(y), y, tzone = "America/New_York")
#'
#' # Changing the tzone does not change the internal index values, but it
#' # does change how the index is printed!
#' head(y)
#' head(.index(y))
#' tzone(y) <- "Europe/London"
#' head(y) # the index prints with hours, but
#' head(.index(y)) # the internal index is not changed!
#'
tzone <- function(x, ...) {
UseMethod("tzone")
}
#' @rdname tzone
`indexTZ<-` <- function(x, value) {
.Deprecated("tzone<-", "xts")
`tzone<-`(x, value)
}
#' @rdname tzone
`tzone<-` <- function(x, value) {
UseMethod("tzone<-")
}
`tzone<-.xts` <-
function(x, value)
{
if (is.null(value)) {
value <- ""
}
tzone <- as.character(value)
attr(attr(x, "index"), "tzone") <- tzone
# Remove tz attrs (object created before 0.10-3)
attr(x, ".indexTZ") <- NULL
attr(x, "tzone") <- NULL
x
}
tzone.default <-
function(x, ...)
{
attr(x, "tzone")
}
`tzone<-.default` <-
function(x, value)
{
if (!is.null(value)) {
value <- as.character(value)
}
attr(x, "tzone") <- value
x
}
tzone.xts <-
function(x, ...)
{
tzone <- attr(attr(x, "index"), "tzone")
# For xts objects created pre-0.10.3
if (is.null(tzone)) {
# no tzone on the index
sq_tzone <- sQuote("tzone")
sq_both <- paste(sq_tzone, "or", sQuote(".indexTZ"))
warn_msg <-
paste0("index does not have a ", sq_tzone, " attribute")
tzone <- attr(x, "tzone")
if (is.null(tzone)) {
# no tzone on the xts object, look for .indexTZ
tzone <- attr(x, ".indexTZ")
}
if (is.null(tzone)) {
# no .indexTZ on the xts object
tzone <- ""
warn_msg <- paste0(warn_msg, "\n and xts object does not have a ",
sq_both, " attribute\n", " returning ", dQuote(tzone))
warning(warn_msg)
return(tzone)
}
sym <- deparse(substitute(x))
warning(warn_msg, "\n use ", sym,
" <- xts:::.update_index_attributes(", sym, ") to update the object")
}
return(tzone)
}
isClassWithoutTZ <-
function(tclass, object = NULL)
{
.classesWithoutTZ <- c("chron","dates","times","Date","yearmon","yearqtr")
has_no_tz <- FALSE
if (is.null(object)) {
has_no_tz <- any(tclass %in% .classesWithoutTZ)
} else {
has_no_tz <- inherits(object, .classesWithoutTZ)
}
return(has_no_tz)
}
isUTC <- function(tz = NULL) {
if (is.null(tz)) {
tz <- Sys.timezone()
}
switch(tz,
"UTC" = ,
"GMT" = ,
"Etc/UTC" = ,
"Etc/GMT" = ,
"GMT-0" = ,
"GMT+0" = ,
"GMT0" = TRUE,
FALSE)
}
check.TZ <- function(x, ...)
{
check <- getOption("xts_check_TZ")
if (!is.null(check) && !check) {
return()
}
x_tz <- tzone(x)
x_tclass <- tclass(x)
if (isClassWithoutTZ(x_tclass)) {
# warn if tzone is not UTC or GMT (GMT is not technically correct, since
# it *is* a timezone, but it should work for all practical purposes)
if (!isUTC(x_tz)) {
warning(paste0("object index class (", paste(x_tclass, collapse = ", "),
") does not support timezones.\nExpected 'UTC' timezone, but tzone is ",
sQuote(x_tz)), call. = FALSE)
} else {
return()
}
}
x_tz_str <- as.character(x_tz)
sys_tz <- Sys.getenv("TZ")
if (!is.null(x_tz) && x_tz_str != "" && !identical(sys_tz, x_tz_str)) {
msg <- paste0("object timezone ('", x_tz, "') is different ",
"from system timezone ('", sys_tz, "')")
if (is.null(check)) {
# xts_check_TZ is NULL by default
# set to TRUE after messaging user how to disable the warning
msg <- paste0(msg, "\n NOTE: set 'options(xts_check_TZ = FALSE)' ",
"to disable this warning\n",
" This note is displayed once per session")
options(xts_check_TZ = TRUE)
}
warning(msg, call. = FALSE)
}
}
xts/R/OHLC.R 0000644 0001762 0000144 00000007247 14654242576 012172 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# functions from quantmod to check for OHLC style/columns
# NOT TO BE EXPORTED
#
`OHLCV` <-
function (x)
{
if (is.OHLCV(x))
return(x[, has.OHLCV(x, 1)])
NULL
}
`is.OHLCV` <-
function(x)
{
all(has.Op(x),has.Hi(x),has.Lo(x),has.Cl(x),has.Vo(x))
}
`has.OHLCV` <-
function(x,which=FALSE)
{
if(which) {
c(has.Op(x,1),has.Hi(x,1),has.Lo(x,1),has.Cl(x,1),has.Vo(x,1))
} else {
c(has.Op(x),has.Hi(x),has.Lo(x),has.Cl(x),has.Vo(x))
}
}
`OHLC` <-
function (x)
{
if (is.OHLC(x))
return(x[, has.OHLC(x, 1)])
NULL
}
`is.OHLC` <-
function(x)
{
all(has.Op(x),has.Hi(x),has.Lo(x),has.Cl(x))
}
`has.OHLC` <-
function(x,which=FALSE)
{
if(which) {
c(has.Op(x,1),has.Hi(x,1),has.Lo(x,1),has.Cl(x,1))
} else {
c(has.Op(x),has.Hi(x),has.Lo(x),has.Cl(x))
}
}
`HLC` <-
function (x)
{
if (is.HLC(x))
return(x[, has.HLC(x, 1)])
NULL
}
`is.HLC` <-
function(x)
{
all(has.Hi(x),has.Lo(x),has.Cl(x))
}
`has.HLC` <-
function(x,which=FALSE)
{
if(which) {
c(has.Hi(x,1),has.Lo(x,1),has.Cl(x,1))
} else {
c(has.Hi(x),has.Lo(x),has.Cl(x))
}
}
`Op` <-
function(x)
{
if(has.Op(x))
return(x[,grep('Open',colnames(x),ignore.case=TRUE)])
NULL
}
`has.Op` <-
function(x,which=FALSE)
{
loc <- grep('Open',colnames(x),ignore.case=TRUE)
if(!identical(loc,integer(0)))
return(ifelse(which,loc,TRUE))
ifelse(which,loc,FALSE)
}
`Hi` <-
function(x)
{
if(has.Hi(x))
return(x[,grep('High',colnames(x),ignore.case=TRUE)])
NULL
}
`has.Hi` <-
function(x,which=FALSE)
{
loc <- grep('High',colnames(x),ignore.case=TRUE)
if(!identical(loc,integer(0)))
return(ifelse(which,loc,TRUE))
ifelse(which,loc,FALSE)
}
`Lo` <-
function(x)
{
if(has.Lo(x))
return(x[,grep('Low',colnames(x),ignore.case=TRUE)])
NULL
}
`has.Lo` <-
function(x,which=FALSE)
{
loc <- grep('Low',colnames(x),ignore.case=TRUE)
if(!identical(loc,integer(0)))
return(ifelse(which,loc,TRUE))
ifelse(which,loc,FALSE)
}
`Cl` <-
function(x)
{
if(has.Cl(x))
return(x[,grep('Close',colnames(x),ignore.case=TRUE)])
NULL
}
`has.Cl` <-
function(x,which=FALSE)
{
loc <- grep('Close',colnames(x),ignore.case=TRUE)
if(!identical(loc,integer(0)))
return(ifelse(which,loc,TRUE))
ifelse(which,loc,FALSE)
}
`Vo` <-
function(x)
{
#vo <- grep('Volume',colnames(x))
#if(!identical(vo,integer(0)))
if(has.Vo(x))
return(x[,grep('Volume',colnames(x),ignore.case=TRUE)])
NULL
}
`has.Vo` <-
function(x,which=FALSE)
{
loc <- grep('Volume',colnames(x),ignore.case=TRUE)
if(!identical(loc,integer(0)))
return(ifelse(which,loc,TRUE))
ifelse(which,loc,FALSE)
}
`Ad` <-
function(x)
{
if(has.Ad(x))
return(x[,grep('Adjusted',colnames(x),ignore.case=TRUE)])
NULL
}
`has.Ad` <-
function(x,which=FALSE)
{
loc <- grep('Adjusted',colnames(x),ignore.case=TRUE)
if(!identical(loc,integer(0)))
return(ifelse(which,loc,TRUE))
ifelse(which,loc,FALSE)
}
xts/R/plot.R 0000644 0001762 0000144 00000172105 14702260001 012370 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2009-2015 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Ross Bennett and Joshua M. Ulrich
#
# 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, see .
current.xts_chob <- function() invisible(get(".xts_chob",.plotxtsEnv))
# Current design
#
# There is a main plot object that contains the plot title (and optional
# timespan), the x-axis labels and tick marks, and a list of 'panel' objects.
# The main plot object contains the objects/functions below.
#
# * Env: an environment holds all the plot information.
# * add_main_header(): add the main plot header
# * add_main_xaxis(): add the x-axis labels and ticks to the main plot.
# * new_panel(): create a new panel and add it to the plot.
# * get_xcoords(): get the x-coordinate values for the plot.
# * get_panel(): get a specific panel.
# * get_last_action_panel(): get the panel that had the last rendered action.
# * new_environment: create a new environment with 'Env' as its parent.
# Functions that aren't intended to be called externally:
#
# * update_panels(): re-calculate the x-axis and y-axis values.
# * render_panels(): render all the plot panels.
# * x_grid_lines(): plot the x-axis grid lines.
# * create_ylim(): create y-axis max/min, handling when max(x) == min(x).
# The panel object is composed of the following fields:
#
# * id: the numeric index of the panel in the plot's list of panels.
# * asp: the x/y aspect ratio for the panel (relative vertical size).
# * ylim: the ylim of the panel when it was created.
# * ylim_render: the ylim of the panel to use when rendering.
# * use_fixed_ylim: do not update the panel ylim based on all panels data
# * header: the panel title.
# * actions: a list of expressions used to render the panel.
# * add_action(): a function to add an action to the list.
#
# The panel has the 'yaxis_expr' expression for rendering the y-axis min/max
# values, labels, and grid lines/ticks. It also contains the x-axis grid
# expression because we need the y-axis min/max values to know where to draw
# the x-axis grid lines on the panel.
# Other notes
#
# Environments created by new_environment() (e.g. the 'lenv') are children of
# Env, so expressions evaluated in 'lenv' will look in Env for anything not
# found in 'lenv'.
#
# Visual representation of plot structure
#
# ____________________________________________________________________________
# / \
# | plot object / window |
# | |
# | ______________________________________________________________________ |
# | / \ |
# | | panel #1 | |
# | | __________________________________________________________________ | |
# | | / \ | |
# | | | header frame | | |
# | | \__________________________________________________________________/ | |
# | | __________________________________________________________________ | |
# | | / \ | |
# | | | series frame | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | \__________________________________________________________________/ | |
# | \______________________________________________________________________/ |
# | |
# | ______________________________________________________________________ |
# | / \ |
# | | panel #2 | |
# | | __________________________________________________________________ | |
# | | / \ | |
# | | | header frame | | |
# | | \__________________________________________________________________/ | |
# | | __________________________________________________________________ | |
# | | / \ | |
# | | | series frame | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | | | | |
# | | \__________________________________________________________________/ | |
# | \______________________________________________________________________/ |
# | |
# \____________________________________________________________________________/
#
# Currently not necessary, but potentially very useful:
# http://www.fromthebottomoftheheap.net/2011/07/23/passing-non-graphical-parameters-to-graphical-functions-using/
chart.lines <- function(x,
type="l",
lty=1,
lwd=2,
lend=1,
col=NULL,
up.col=NULL,
dn.col=NULL,
legend.loc=NULL,
log=FALSE,
...){
xx <- current.xts_chob()
switch(type,
h={
# use up.col and dn.col if specified
if (!is.null(up.col) && !is.null(dn.col)){
colors <- ifelse(x[,1] < 0, dn.col, up.col)
} else {
colors <- if (is.null(col)) 1 else col
}
if (length(colors) < nrow(x[,1]))
colors <- colors[1]
# x-coordinates for this column
xcoords <- xx$get_xcoords(x[,1])
lines(xcoords,x[,1],lwd=2,col=colors,lend=lend,lty=1,type="h",...)
},
p=, l=, b=, c=, o=, s=, S=, n={
if(is.null(col))
col <- xx$Env$theme$col
# ensure pars have ncol(x) elements
lty <- rep(lty, length.out = NCOL(x))
lwd <- rep(lwd, length.out = NCOL(x))
col <- rep(col, length.out = NCOL(x))
for(i in NCOL(x):1) {
# x-coordinates for this column
xcoords <- xx$get_xcoords(x[,i])
xi <- x[,i]
if (isTRUE(log)) xi <- log(xi)
lines(xcoords, xi, type=type, lend=lend, col=col[i],
lty=lty[i], lwd=lwd[i], ...)
}
},
{
# default case
warning(paste(type, "not recognized. Type must be one of
'p', 'l', 'b, 'c', 'o', 'h', 's', 'S', 'n'.
plot.xts supports the same types as plot.default,
see ?plot for valid arguments for type"))
}
)
if(!is.null(legend.loc)){
lc <- legend.coords(legend.loc, xx$Env$xlim, range(x, na.rm=TRUE))
legend(x=lc$x, y=lc$y, legend=colnames(x), xjust=lc$xjust, yjust=lc$yjust,
fill=col[1:NCOL(x)], bty="n")
}
}
add.par.from.dots <- function(call., ...) {
stopifnot(is.call(call.))
# from graphics:::.Pars
parnames <- c("xlog","ylog","adj","ann","ask","bg","bty","cex","cex.axis",
"cex.lab","cex.main","cex.sub","cin","col","col.axis","col.lab",
"col.main","col.sub","cra","crt","csi","cxy","din","err",
"family", "fg","fig","fin","font","font.axis","font.lab",
"font.main","font.sub","lab","las","lend","lheight","ljoin",
"lmitre","lty","lwd","mai","mar","mex","mfcol","mfg","mfrow",
"mgp","mkh","new","oma","omd","omi","page","pch","pin","plt",
"ps","pty","smo","srt","tck","tcl","usr","xaxp","xaxs","xaxt",
"xpd","yaxp","yaxs","yaxt","ylbias")
dots <- list(...)
argnames <- names(dots)
pm <- match(argnames, parnames, nomatch = 0L)
call.list <- as.list(call.)
# only pass the args from dots ('...') that are in parnames
as.call(c(call.list, dots[pm > 0L]))
}
isNullOrFalse <- function(x) {
is.null(x) || identical(x, FALSE)
}
# Main plot.xts method.
# author: Ross Bennett (adapted from Jeffrey Ryan's chart_Series)
#' Plotting xts Objects
#'
#' Plotting for xts objects.
#'
#' Possible values for arguments `major.ticks`, `minor.ticks`, and
#' `grid.ticks.on` include \sQuote{auto}, \sQuote{minute}, \sQuote{hours},
#' \sQuote{days}, \sQuote{weeks}, \sQuote{months}, \sQuote{quarters}, and
#' \sQuote{years}. The default is \sQuote{auto}, which attempts to determine
#' sensible locations from the periodicity and locations of observations. The
#' other values are based on the possible values for the `ticks.on`
#' argument of [`axTicksByTime()`].
#'
#' @param x A xts object.
#' @param y Not used, always `NULL`.
#' @param \dots Any passthrough arguments for `lines()` and `points()`.
#' @param subset An ISO8601-style subset string.
#' @param panels Character vector of expressions to plot as panels.
#' @param multi.panel Either `TRUE`, `FALSE`, or an integer less than or equal
#' to the number of columns in the data set. When `TRUE`, each column of the
#' data is plotted in a separate panel. When an integer 'n', the data will be
#' plotted in groups of 'n' columns per panel and each group will be plotted
#' in a separate panel.
#' @param col Color palette to use.
#' @param up.col Color for positive bars when `type = "h"`.
#' @param dn.col Color for negative bars when `type = "h"`.
#' @param bg Background color of plotting area, same as in [`par()`].
#' @param type The type of plot to be drawn, same as in [`plot()`].
#' @param lty Set the line type, same as in [`par()`].
#' @param lwd Set the line width, same as in [`par()`].
#' @param lend Set the line end style, same as in [`par()`].
#' @param main Main plot title.
#' @param main.timespan Should the timespan of the series be shown in the top
#' right corner of the plot?
#' @param observation.based When `TRUE`, all the observations are equally spaced
#' along the x-axis. When `FALSE` (the default) the observations on the x-axis
#' are spaced based on the time index of the data.
#' @param log Should the y-axis be in log scale? Default `FALSE`.
#' @param ylim The range of the y axis.
#' @param yaxis.same Should 'ylim' be the same for every panel? Default `TRUE`.
#' @param yaxis.left Add y-axis labels to the left side of the plot?
#' @param yaxis.right Add y-axis labels to the right side of the plot?
#' @param yaxis.ticks Desired number of y-axis grid lines. The actual number of
#' grid lines is determined by the `n` argument to [`pretty()`].
#' @param major.ticks Period specifying locations for major tick marks and labels
#' on the x-axis. See Details for possible values.
#' @param minor.ticks Period specifying locations for minor tick marks on the
#' x-axis. When `NULL`, minor ticks are not drawn. See details for possible
#' values.
#' @param grid.ticks.on Period specifying locations for vertical grid lines.
#' See details for possible values.
#' @param grid.ticks.lwd Line width of the grid.
#' @param grid.ticks.lty Line type of the grid.
#' @param grid.col Color of the grid.
#' @param labels.col Color of the axis labels.
#' @param format.labels Label format to draw lower frequency x-axis ticks and
#' labels passed to [`axTicksByTime()`]
#' @param grid2 Color for secondary x-axis grid.
#' @param legend.loc Places a legend into one of nine locations on the chart:
#' bottomright, bottom, bottomleft, left, topleft, top, topright, right, or
#' center. Default `NULL` does not draw a legend.
#' @param on Panel number to draw on. A new panel will be drawn if `on = NA`.
#' The default, `on = 0`, will add to the active panel. The active panel is
#' defined as the panel on which the most recent action was performed. Note
#' that only the first element of `on` is checked for the default behavior to
#' add to the last active panel.
#' @param extend.xaxis When `TRUE`, extend the x-axis before and/or after the
#' plot's existing time index range, so all of of the time index values of
#' the new series are included in the plot. Default `FALSE`.
#'
#' @author Ross Bennett
#'
#' @seealso [`addSeries()`], [`addPanel()`]
#'
#' @references based on [`chart_Series()`][quantmod::quantmod] in \pkg{quantmod}
#' written by Jeffrey A. Ryan
#'
#' @examples
#'
#' \dontrun{
#' data(sample_matrix)
#' sample.xts <- as.xts(sample_matrix)
#'
#' # plot the Close
#' plot(sample.xts[,"Close"])
#'
#' # plot a subset of the data
#' plot(sample.xts[,"Close"], subset = "2007-04-01/2007-06-31")
#'
#' # function to compute simple returns
#' simple.ret <- function(x, col.name){
#' x[,col.name] / lag(x[,col.name]) - 1
#' }
#'
#' # plot the close and add a panel with the simple returns
#' plot(sample.xts[,"Close"])
#' R <- simple.ret(sample.xts, "Close")
#' lines(R, type = "h", on = NA)
#'
#' # add the 50 period simple moving average to panel 1 of the plot
#' library(TTR)
#' lines(SMA(sample.xts[,"Close"], n = 50), on = 1, col = "blue")
#'
#' # add month end points to the chart
#' points(sample.xts[endpoints(sample.xts[,"Close"], on = "months"), "Close"],
#' col = "red", pch = 17, on = 1)
#'
#' # add legend to panel 1
#' addLegend("topright", on = 1,
#' legend.names = c("Close", "SMA(50)"),
#' lty = c(1, 1), lwd = c(2, 1),
#' col = c("black", "blue", "red"))
#' }
#'
plot.xts <- function(x,
y=NULL,
...,
subset="",
panels=NULL,
multi.panel=FALSE,
col=1:8,
up.col=NULL,
dn.col=NULL,
bg="#FFFFFF",
type="l",
lty=1,
lwd=2,
lend=1,
main=deparse(substitute(x)),
main.timespan=TRUE,
observation.based=FALSE,
log=FALSE,
ylim=NULL,
yaxis.same=TRUE,
yaxis.left=TRUE,
yaxis.right=TRUE,
yaxis.ticks=5,
major.ticks="auto",
minor.ticks=NULL,
grid.ticks.on="auto",
grid.ticks.lwd=1,
grid.ticks.lty=1,
grid.col="darkgray",
labels.col="#333333",
format.labels=TRUE,
grid2="#F5F5F5",
legend.loc=NULL,
extend.xaxis=FALSE){
# check for colorset or col argument
if(hasArg("colorset")) {
col <- eval.parent(plot.call$colorset)
}
# ensure pars have ncol(x) elements
col <- rep(col, length.out = NCOL(x))
lty <- rep(lty, length.out = NCOL(x))
lwd <- rep(lwd, length.out = NCOL(x))
# Small multiples with multiple pages behavior occurs when multi.panel is
# an integer. (i.e. multi.panel=2 means to iterate over the data in a step
# size of 2 and plot 2 panels on each page
# Make recursive calls and return
if(is.numeric(multi.panel)){
multi.panel <- min(NCOL(x), multi.panel)
idx <- seq.int(1L, NCOL(x), 1L)
chunks <- split(idx, ceiling(seq_along(idx)/multi.panel))
if(!is.null(panels) && nchar(panels) > 0){
# we will plot the panels, but not plot the data by column
multi.panel <- FALSE
} else {
# we will plot the data by column, but not the panels
multi.panel <- TRUE
panels <- NULL
# set the ylim based on the data passed into the x argument
if(yaxis.same)
ylim <- range(x[subset], na.rm=TRUE)
}
for(i in 1:length(chunks)){
tmp <- chunks[[i]]
p <- plot.xts(x=x[,tmp],
y=y,
...=...,
subset=subset,
panels=panels,
multi.panel=multi.panel,
col=col[tmp],
up.col=up.col,
dn.col=dn.col,
bg=bg,
type=type,
lty=lty[tmp],
lwd=lwd[tmp],
lend=lend,
main=main,
observation.based=observation.based,
log=log,
ylim=ylim,
yaxis.same=yaxis.same,
yaxis.left=yaxis.left,
yaxis.right=yaxis.right,
yaxis.ticks=yaxis.ticks,
major.ticks=major.ticks,
minor.ticks=minor.ticks,
grid.ticks.on=grid.ticks.on,
grid.ticks.lwd=grid.ticks.lwd,
grid.ticks.lty=grid.ticks.lty,
grid.col=grid.col,
labels.col=labels.col,
format.labels=format.labels,
grid2=grid2,
legend.loc=legend.loc,
extend.xaxis=extend.xaxis)
if(i < length(chunks))
print(p)
}
# NOTE: return here so we don't draw another chart
return(p)
}
cs <- new.replot_xts()
# major.ticks shouldn't be null so we'll set major.ticks here if it is null
if(is.null(major.ticks)) {
xs <- x[subset]
mt <- c(years=nyears(xs),
months=nmonths(xs),
days=ndays(xs))
major.ticks <- names(mt)[rev(which(mt < 30))[1]]
}
# add theme and charting parameters to Env
plot.call <- match.call(expand.dots=TRUE)
cs$Env$theme <-
list(up.col = up.col,
dn.col = dn.col,
col = col,
rylab = yaxis.right,
lylab = yaxis.left,
bg = bg,
grid = grid.col,
grid2 = grid2,
labels = labels.col,
# String rotation in degrees. See comment about 'crt'. Only supported by text()
srt = if (hasArg("srt")) eval.parent(plot.call$srt) else 0,
# Rotation of axis labels:
# 0: parallel to the axis (default),
# 1: horizontal,
# 2: perpendicular to the axis,
# 3: vertical
las = if (hasArg("las")) eval.parent(plot.call$las) else 0,
# magnification for axis annotation relative to current 'cex' value
cex.axis = if (hasArg("cex.axis")) eval.parent(plot.call$cex.axis) else 0.9)
# /theme
# multiplier to magnify plotting text and symbols
cs$Env$cex <- if (hasArg("cex")) eval.parent(plot.call$cex) else 0.6
# lines of margin to the 4 sides of the plot: c(bottom, left, top, right)
cs$Env$mar <- if (hasArg("mar")) eval.parent(plot.call$mar) else c(3,2,0,2)
cs$Env$format.labels <- format.labels
cs$Env$yaxis.ticks <- yaxis.ticks
cs$Env$major.ticks <- if (isTRUE(major.ticks)) "auto" else major.ticks
cs$Env$minor.ticks <- if (isTRUE(minor.ticks)) "auto" else minor.ticks
cs$Env$grid.ticks.on <- if (isTRUE(grid.ticks.on)) "auto" else grid.ticks.on
cs$Env$grid.ticks.lwd <- grid.ticks.lwd
cs$Env$grid.ticks.lty <- grid.ticks.lty
cs$Env$type <- type
cs$Env$lty <- lty
cs$Env$lwd <- lwd
cs$Env$lend <- lend
cs$Env$legend.loc <- legend.loc
cs$Env$extend.xaxis <- extend.xaxis
cs$Env$observation.based <- observation.based
cs$Env$log <- isTRUE(log)
# Do some checks on x
if(is.character(x))
stop("'x' must be a time-series object")
# Raw returns data passed into function
cs$Env$xdata <- x
cs$Env$xsubset <- subset
cs$Env$column_names <- colnames(x)
cs$Env$nobs <- NROW(cs$Env$xdata)
cs$Env$main <- main
cs$Env$main.timespan <- main.timespan
cs$Env$ylab <- if (hasArg("ylab")) eval.parent(plot.call$ylab) else ""
xdata_ylim <- cs$create_ylim(cs$Env$xdata[subset,])
if(isTRUE(multi.panel)){
n_cols <- NCOL(cs$Env$xdata)
asp <- ifelse(n_cols > 1, n_cols, 3)
if (hasArg("yaxis.same") && hasArg("ylim") && !is.null(ylim)) {
warning("only 'ylim' or 'yaxis.same' should be provided; using 'ylim'")
}
for(i in seq_len(n_cols)) {
# create a local environment for each panel
lenv <- cs$new_environment()
lenv$xdata <- cs$Env$xdata[subset,i]
lenv$type <- cs$Env$type
if (is.null(ylim)) {
if (yaxis.same) {
lenv$ylim <- xdata_ylim # set panel ylim using all columns
lenv$use_fixed_ylim <- FALSE # update panel ylim when rendering
} else {
panel_ylim <- cs$create_ylim(lenv$xdata)
lenv$ylim <- panel_ylim # set panel ylim using this column
lenv$use_fixed_ylim <- TRUE # do NOT update panel ylim when rendering
}
} else {
lenv$ylim <- ylim # use the ylim argument value
lenv$use_fixed_ylim <- TRUE # do NOT update panel ylim when rendering
}
# allow color and line attributes for each panel in a multi.panel plot
lenv$lty <- cs$Env$lty[i]
lenv$lwd <- cs$Env$lwd[i]
lenv$col <- cs$Env$theme$col[i]
lenv$log <- isTRUE(log)
exp <- quote(chart.lines(xdata[xsubset],
type=type,
lty=lty,
lwd=lwd,
lend=lend,
col=col,
log=log,
up.col=theme$up.col,
dn.col=theme$dn.col,
legend.loc=legend.loc))
exp <- as.expression(add.par.from.dots(exp, ...))
# create the panels
this_panel <-
cs$new_panel(lenv$ylim,
asp = asp,
envir = lenv,
header = cs$Env$column_names[i],
draw_left_yaxis = yaxis.left,
draw_right_yaxis = yaxis.right,
use_fixed_ylim = lenv$use_fixed_ylim,
use_log_yaxis = log)
# plot data
this_panel$add_action(exp, env = lenv)
}
} else {
if(type == "h" && NCOL(x) > 1)
warning("only the univariate series will be plotted")
if (is.null(ylim)) {
yrange <- xdata_ylim # set ylim using all columns
use_fixed_ylim <- FALSE # update panel ylim when rendering
} else {
yrange <- ylim # use the ylim argument value
use_fixed_ylim <- TRUE # do NOT update panel ylim when rendering
}
# create the chart's main panel
main_panel <-
cs$new_panel(ylim = yrange,
asp = 3,
envir = cs$Env,
header = "",
use_fixed_ylim = use_fixed_ylim,
draw_left_yaxis = yaxis.left,
draw_right_yaxis = yaxis.right,
use_log_yaxis = log)
exp <- quote(chart.lines(xdata[xsubset],
type=type,
lty=lty,
lwd=lwd,
lend=lend,
col=theme$col,
log=log,
up.col=theme$up.col,
dn.col=theme$dn.col,
legend.loc=legend.loc))
exp <- as.expression(add.par.from.dots(exp, ...))
main_panel$add_action(exp)
assign(".xts_chob", cs, .plotxtsEnv)
}
# Plot the panels or default to a simple line chart
if(!is.null(panels) && nchar(panels) > 0) {
panels <- parse(text=panels, srcfile=NULL)
for( p in 1:length(panels)) {
if(length(panels[p][[1]][-1]) > 0) {
cs <- eval(panels[p])
} else {
cs <- eval(panels[p])
}
}
}
assign(".xts_chob", cs, .plotxtsEnv)
cs
}
# apply a function to the xdata in the xts chob and add a panel with the result
#' Add a panel to an existing xts plot
#'
#' Apply a function to the data of an existing xts plot object and plot the
#' result on an existing or new panel. `FUN` should have arguments `x` or `R`
#' for the data of the existing xts plot object to be passed to. All other
#' additional arguments for `FUN` are passed through \dots.
#'
#' @param FUN An xts object to plot.
#' @param main Main title for a new panel if drawn.
#' @param on Panel number to draw on. A new panel will be drawn if `on = NA`.
#' @param type The type of plot to be drawn, same as in [`plot()`].
#' @param col Color palette to use, set by default to rational choices.
#' @param lty Set the line type, same as in [`par()`].
#' @param lwd Set the line width, same as in [`par()`].
#' @param pch The type of plot to be drawn, same as in [`par()`].
#' @param \dots Additional named arguments passed through to `FUN` and any
#' other graphical passthrough parameters.
#'
#' @seealso [`plot.xts()`], [`addSeries()`]
#'
#' @author Ross Bennett
#'
#' @examples
#'
#' library(xts)
#' data(sample_matrix)
#' sample.xts <- as.xts(sample_matrix)
#'
#' calcReturns <- function(price, method = c("discrete", "log")){
#' px <- try.xts(price)
#' method <- match.arg(method)[1L]
#' returns <- switch(method,
#' simple = ,
#' discrete = px / lag(px) - 1,
#' compound = ,
#' log = diff(log(px)))
#' reclass(returns, px)
#' }
#'
#' # plot the Close
#' plot(sample.xts[,"Close"])
#' # calculate returns
#' addPanel(calcReturns, method = "discrete", type = "h")
#' # Add simple moving average to panel 1
#' addPanel(rollmean, k = 20, on = 1)
#' addPanel(rollmean, k = 40, col = "blue", on = 1)
#'
addPanel <- function(FUN, main="", on=NA, type="l", col=NULL, lty=1, lwd=1, pch=1, ...){
# get the chob and the raw data (i.e. xdata)
chob <- current.xts_chob()
# xdata will be passed as first argument to FUN
xdata <- chob$Env$xdata
fun <- match.fun(FUN)
.formals <- formals(fun)
if("..." %in% names(.formals)) {
# Just call do.call if FUN has '...'
x <- try(do.call(fun, c(list(xdata), list(...)), quote=TRUE), silent=TRUE)
} else {
# Otherwise, ensure we only pass relevant args to FUN
.formals <- modify.args(formals=.formals, arglist=list(...))
.formals[[1]] <- quote(xdata)
x <- try(do.call(fun, .formals), silent=TRUE)
}
if(inherits(x, "try-error")) {
message(paste("FUN function failed with message", x))
return(NULL)
}
addSeriesCall <- quote(addSeries(x = x, main = main, on = on,
type = type, col = col, lty = lty, lwd = lwd, pch = pch))
addSeriesCall <- add.par.from.dots(addSeriesCall, ...)
eval(addSeriesCall)
}
# Add a time series to an existing xts plot
# author: Ross Bennett
#' Add a time series to an existing xts plot
#'
#' Add a time series to an existing xts plot
#'
#' @param x An xts object to add to the plot.
#' @param main Main title for a new panel if drawn.
#' @param on Panel number to draw on. A new panel will be drawn if `on = NA`.
#' @param type The type of plot to be drawn, same as in [`plot()`].
#' @param col Color palette to use, set by default to rational choices.
#' @param lty Set the line type, same as in [`par()`].
#' @param lwd Set the line width, same as in [`par()`].
#' @param pch The type of plot to be drawn, same as in [`par()`].
#' @param \dots Any other passthrough graphical parameters.
#'
#' @author Ross Bennett
#'
addSeries <- function(x, main="", on=NA, type="l", col=NULL, lty=1, lwd=1, pch=1, ...){
plot_object <- current.xts_chob()
lenv <- plot_object$new_environment()
lenv$plot_lines <- function(x, ta, on, type, col, lty, lwd, pch, ...){
xdata <- x$Env$xdata
xsubset <- x$Env$xsubset
xDataSubset <- xdata[xsubset]
# we can add points that are not necessarily at the points
# on the main series, but need to ensure the new series only
# has index values within the xdata subset
if(xsubset == "") {
subset.range <- xsubset
} else {
fmt <- "%Y-%m-%d %H:%M:%OS6"
subset.range <- paste(format(start(xDataSubset), fmt),
format(end(xDataSubset), fmt), sep = "/")
}
xds <- .xts(, .index(xDataSubset), tzone=tzone(xdata))
ta.y <- merge(ta, xds)[subset.range]
if (!isTRUE(x$Env$extend.xaxis)) {
xi <- .index(ta.y)
xc <- .index(xds)
xsubset <- which(xi >= xc[1] & xi <= xc[length(xc)])
ta.y <- ta.y[xsubset]
}
chart.lines(ta.y, type=type, col=col, lty=lty, lwd=lwd, pch=pch, ...)
}
# get tag/value from dots
expargs <- substitute(alist(ta=x,
on=on,
type=type,
col=col,
lty=lty,
lwd=lwd,
pch=pch,
...))
# capture values from caller, so we don't need to copy objects to lenv,
# since this gives us evaluated versions of all the object values
expargs <- lapply(expargs[-1L], eval, parent.frame())
exp <- as.call(c(quote(plot_lines),
x = quote(current.xts_chob()),
expargs))
xdata <- plot_object$Env$xdata
xsubset <- plot_object$Env$xsubset
lenv$xdata <- merge(x,xdata,retside=c(TRUE,FALSE))
if(hasArg("ylim")) {
ylim <- eval.parent(substitute(alist(...))$ylim)
} else {
ylim <- range(lenv$xdata[xsubset], na.rm=TRUE)
if(all(ylim == 0)) ylim <- c(-1, 1)
}
lenv$ylim <- ylim
if(is.na(on[1])){
# add series to a new panel
use_log <- isTRUE(eval.parent(substitute(alist(...))$log))
this_panel <- plot_object$new_panel(lenv$ylim,
asp = 1,
envir = lenv,
header = main,
use_log_yaxis = use_log)
# plot data
this_panel$add_action(exp, env = lenv)
} else {
for(i in on) {
plot_object$add_panel_action(i, exp, lenv)
}
}
plot_object
}
# Add time series of lines to an existing xts plot
# author: Ross Bennett
#' @param pch the plotting character to use, same as in 'par'
#' @rdname plot.xts
lines.xts <- function(x, ..., main="", on=0, col=NULL, type="l", lty=1, lwd=1, pch=1){
if(!is.na(on[1]))
if(on[1] == 0) on[1] <- current.xts_chob()$get_last_action_panel()$id
addSeries(x, ...=..., main=main, on=on, type=type, col=col, lty=lty, lwd=lwd, pch=pch)
}
# Add time series of points to an existing xts plot
# author: Ross Bennett
#' @param pch the plotting character to use, same as in 'par'
#' @rdname plot.xts
points.xts <- function(x, ..., main="", on=0, col=NULL, pch=1){
if(!is.na(on[1]))
if(on[1] == 0) on[1] <- current.xts_chob()$get_last_action_panel()$id
addSeries(x, ...=..., main=main, on=on, type="p", col=col, pch=pch)
}
# Add vertical lines to an existing xts plot
# author: Ross Bennett
#' Add vertical lines to an existing xts plot
#'
#' Add vertical lines and labels to an existing xts plot.
#'
#' @param events An xts object of events and their associated labels. It is
#' ensured that the first column of `events` is the event description/label.
#' @param main Main title for a new panel, if drawn.
#' @param on Panel number to draw on. A new panel will be drawn if `on = NA`.
#' The default, `on = 0`, will add to the active panel. The active panel is
#' defined as the panel on which the most recent action was performed. Note
#' that only the first element of `on` is checked for the default behavior to
#' add to the last active panel.
#' @param lty Set the line type, same as in [`par()`].
#' @param lwd Set the line width, same as in [`par()`].
#' @param col Color palette to use, set by default to rational choices.
#' @param \dots Any other passthrough parameters to [`text()`] to control how
#' the event labels are drawn.
#'
#' @author Ross Bennett
#'
#' @examples
#'
#' \dontrun{
#' library(xts)
#' data(sample_matrix)
#' sample.xts <- as.xts(sample_matrix)
#' events <- xts(letters[1:3],
#' as.Date(c("2007-01-12", "2007-04-22", "2007-06-13")))
#' plot(sample.xts[,4])
#' addEventLines(events, srt = 90, pos = 2)
#' }
#'
addEventLines <- function(events, main="", on=0, lty=1, lwd=1, col=1, ...){
events <- try.xts(events)
plot_object <- current.xts_chob()
if(!is.na(on[1]))
if(on[1] == 0) on[1] <- plot_object$get_last_action_panel()$id
if(nrow(events) > 1){
if(length(lty) == 1) lty <- rep(lty, nrow(events))
if(length(lwd) == 1) lwd <- rep(lwd, nrow(events))
if(length(col) == 1) col <- rep(col, nrow(events))
}
lenv <- plot_object$new_environment()
lenv$plot_event_lines <- function(x, events, on, lty, lwd, col, ...){
xdata <- x$Env$xdata
xsubset <- x$Env$xsubset
panel <- x$get_active_panel()
if (panel$use_log_yaxis) {
ypos <- log(exp(panel$ylim_render[2]) * 0.995)
} else {
ypos <- panel$ylim_render[2] * 0.995
}
# we can add points that are not necessarily at the points on the main series
subset.range <-
paste(format(start(xdata[xsubset]), "%Y%m%d %H:%M:%OS6"),
format(end(xdata[xsubset]), "%Y%m%d %H:%M:%OS6"),
sep = "/")
ta.adj <- merge(n=.xts(1:NROW(xdata[xsubset]),
.index(xdata[xsubset]),
tzone=tzone(xdata)),
.xts(rep(1, NROW(events)),# use numeric for the merge
.index(events)))[subset.range]
# should we not merge and only add events that are in index(xdata)?
ta.y <- ta.adj[,-1]
# the merge should result in NAs for any object that is not in events
event.ind <- which(!is.na(ta.y))
abline(v=x$get_xcoords()[event.ind], col=col, lty=lty, lwd=lwd)
text(x=x$get_xcoords()[event.ind], y=ypos,
labels=as.character(events[,1]),
col=x$Env$theme$labels, ...)
}
# get tag/value from dots
expargs <- substitute(alist(events=events,
on=on,
lty=lty,
lwd=lwd,
col=col,
...))
# capture values from caller, so we don't need to copy objects to lenv,
# since this gives us evaluated versions of all the object values
expargs <- lapply(expargs[-1L], eval, parent.frame())
exp <- as.call(c(quote(plot_event_lines),
x = quote(current.xts_chob()),
expargs))
if(is.na(on[1])){
xdata <- plot_object$Env$xdata
xsubset <- plot_object$Env$xsubset
lenv$xdata <- xdata
ylim <- range(xdata[xsubset], na.rm=TRUE)
lenv$ylim <- ylim
# add series to a new panel
this_panel <- plot_object$new_panel(lenv$ylim,
asp = 1,
envir = lenv,
header = main)
# plot data
this_panel$add_action(exp, env = lenv)
} else {
for(i in on) {
plot_object$add_panel_action(i, exp, lenv)
}
}
plot_object
}
# Add legend to an existing xts plot
# author: Ross Bennett
#' Add Legend
#'
#' Add a legend to an existing panel.
#'
#' @param legend.loc One of nine locations: bottomright, bottom, bottomleft,
#' left, topleft, top, topright, right, or center.
#' @param legend.names Character vector of names for the legend. When `NULL`,
#' the column names of the current plot object are used.
#' @param col Fill colors for the legend. When `NULL`, the colorset of the
#' current plot object data is used.
#' @param ncol Number of columns for the legend.
#' @param on Panel number to draw on. A new panel will be drawn if `on = NA`.
#' The default, `on = 0`, will add to the active panel. The active panel is
#' defined as the panel on which the most recent action was performed. Note
#' that only the first element of `on` is checked for the default behavior to
#' add to the last active panel.
#' @param \dots Any other passthrough parameters to [`legend()`].
#'
#' @author Ross Bennett
#'
addLegend <- function(legend.loc="topright", legend.names=NULL, col=NULL, ncol=1, on=0, ...){
plot_object <- current.xts_chob()
if(!is.na(on[1]))
if(on[1] == 0) on[1] <- plot_object$get_last_action_panel()$id
lenv <- plot_object$new_environment()
lenv$plot_legend <- function(x, legend.loc, legend.names, col, ncol, on, bty, text.col, ...){
if(is.na(on[1])){
yrange <- c(0, 1)
} else {
panel <- x$get_active_panel()
yrange <- panel$ylim_render
}
# this just gets the data of the main plot
# TODO: get the data of panels[on]
if(is.null(ncol)){
ncol <- NCOL(x$Env$xdata)
}
if(is.null(col)){
col <- x$Env$theme$col[1:NCOL(x$Env$xdata)]
}
if(is.null(legend.names)){
legend.names <- x$Env$column_names
}
if(missing(bty)){
bty <- "n"
}
if(missing(text.col)){
text.col <- x$Env$theme$labels
}
lc <- legend.coords(legend.loc, x$Env$xlim, yrange)
legend(x=lc$x, y=lc$y, legend=legend.names, xjust=lc$xjust, yjust=lc$yjust,
ncol=ncol, col=col, bty=bty, text.col=text.col, ...)
}
# get tag/value from dots
expargs <- substitute(alist(legend.loc=legend.loc,
legend.names=legend.names,
col=col,
ncol=ncol,
on=on,
...))
# capture values from caller, so we don't need to copy objects to lenv,
# since this gives us evaluated versions of all the object values
expargs <- lapply(expargs[-1L], eval, parent.frame())
exp <- as.call(c(quote(plot_legend),
x = quote(current.xts_chob()),
expargs))
# if on[1] is NA, then add a new frame for the legend
if(is.na(on[1])){
# add legend to a new panel
this_panel <- plot_object$new_panel(ylim = c(0, 1),
asp = 0.8,
envir = lenv,
header = "")
# legend data
this_panel$add_action(exp, env = lenv)
} else {
for(i in on) {
plot_object$add_panel_action(i, exp, lenv)
}
}
plot_object
}
# Determine legend coordinates based on legend location,
# range of x values and range of y values
legend.coords <- function(legend.loc, xrange, yrange) {
switch(legend.loc,
topleft = list(xjust = 0, yjust = 1, x = xrange[1], y = yrange[2]),
left = list(xjust = 0, yjust = 0.5, x = xrange[1], y = sum(yrange) / 2),
bottomleft = list(xjust = 0, yjust = 0, x = xrange[1], y = yrange[1]),
top = list(xjust = 0.5, yjust = 1, x = (xrange[1] + xrange[2]) / 2, y = yrange[2]),
center = list(xjust = 0.5, yjust = 0.5, x = (xrange[1] + xrange[2]) / 2, y = sum(yrange) / 2),
bottom = list(xjust = 0.5, yjust = 0, x = (xrange[1] + xrange[2]) / 2, y = yrange[1]),
topright = list(xjust = 1, yjust = 1, x = xrange[2], y = yrange[2]),
right = list(xjust = 1, yjust = 0.5, x = xrange[2], y = sum(yrange) / 2),
bottomright = list(xjust = 1, yjust = 0, x = xrange[2], y = yrange[1])
)
}
# Add a polygon to an existing xts plot
# author: Ross Bennett
#' Add a polygon to an existing xts plot
#'
#' Draw a polygon on an existing xts plot by specifying a time series of y
#' coordinates. The xts index is used for the x coordinates and the first two
#' columns are the upper and lower y coordinates, respectively.
#'
#' @param x An xts object to plot. Must contain 2 columns for the upper and
#' the lower y coordinates for the polygon. The first column is interpreted
#' as upper y coordinates and the second column as the lower y coordinates.
#' @param y `NULL`, not used.
#' @param main Main title for a new panel, if drawn.
#' @param on Panel number to draw on. A new panel will be drawn if `on = NA`.
#' @param col Color palette to use, set by default to rational choices.
#' @param \dots Any other passthrough parameters to [`par()`].
#'
#' @author Ross Bennett
#'
#' @references Based on code by Dirk Eddelbuettel from
#'
#'
#' @examples
#'
#' \dontrun{
#' library(xts)
#' data(sample_matrix)
#' x <- as.xts(sample_matrix)[,1]
#' ix <- index(x["2007-02"])
#' shade <- xts(matrix(rep(range(x), each = length(ix)), ncol = 2), ix)
#'
#' plot(x)
#'
#' # set on = -1 to draw the shaded region *behind* the main series
#' addPolygon(shade, on = -1, col = "lightgrey")
#' }
#'
addPolygon <- function(x, y=NULL, main="", on=NA, col=NULL, ...){
# add polygon to xts plot based on http://dirk.eddelbuettel.com/blog/2011/01/16/
# some simple checks
x <- try.xts(x)
if(!is.null(y)) stop("y is not null")
if(ncol(x) > 2) warning("more than 2 columns detected in x, only the first 2 will be used")
plot_object <- current.xts_chob()
lenv <- plot_object$new_environment()
lenv$plot_lines <- function(x, ta, on, col, ...){
xdata <- x$Env$xdata
xsubset <- x$Env$xsubset
xDataSubset <- xdata[xsubset]
if(is.null(col)) col <- x$Env$theme$col
# we can add points that are not necessarily at the points
# on the main series, but need to ensure the new series only
# has index values within the xdata subset
if(xsubset == "") {
subset.range <- xsubset
} else {
fmt <- "%Y-%m-%d %H:%M:%OS6"
subset.range <- paste(format(start(xDataSubset), fmt),
format(end(xDataSubset), fmt), sep = "/")
}
xds <- .xts(, .index(xDataSubset), tzone=tzone(xdata))
ta.y <- merge(ta, xds)[subset.range]
# NAs in the coordinates break the polygon which is not the behavior we want
ta.y <- na.omit(ta.y)
# x coordinates
n <- seq_len(NROW(ta.y))
xx <- x$get_xcoords(ta.y)[c(1, n, rev(n))]
# y coordinates upper and lower
# assume first column is upper and second column is lower y coords for
# initial prototype
yu <- as.vector(coredata(ta.y[,1]))
yl <- as.vector(coredata(ta.y[,2]))
polygon(x=xx, y=c(yl[1], yu, rev(yl)), border=NA, col=col, ...)
}
# get tag/value from dots
expargs <- substitute(alist(ta=x,
col=col,
on=on,
...))
# capture values from caller, so we don't need to copy objects to lenv,
# since this gives us evaluated versions of all the object values
expargs <- lapply(expargs[-1L], eval, parent.frame())
exp <- as.call(c(quote(plot_lines),
x = quote(current.xts_chob()),
expargs))
xdata <- plot_object$Env$xdata
xsubset <- plot_object$Env$xsubset
lenv$xdata <- merge(x,xdata,retside=c(TRUE,FALSE))
if(hasArg("ylim")) {
ylim <- eval.parent(substitute(alist(...))$ylim)
} else {
ylim <- range(lenv$xdata[xsubset], na.rm=TRUE)
if(all(ylim == 0)) ylim <- c(-1, 1)
}
lenv$ylim <- ylim
if(is.na(on[1])){
# add series to a new panel
this_panel <- plot_object$new_panel(ylim = lenv$ylim,
asp = 1,
envir = lenv,
header = main)
# plot data
this_panel$add_action(exp, env = lenv)
} else {
for(i in on) {
plot_object$add_panel_action(i, exp, lenv)
}
}
plot_object
}# polygon
# Based on quantmod/R/replot.R
new.replot_xts <- function(panel=1,asp=1,xlim=c(1,10),ylim=list(structure(c(1,10),fixed=FALSE))) {
# global variables
# 'Env' is mainly the environment for the plot window, but some elements are for panels/frames
Env <- new.env()
Env$active_panel_i <- panel
Env$asp <- 1
Env$xlim <- xlim # vector: c(min, max) (same for every panel)
Env$last_action_panel_id <- 1
# getters
get_ylim <- function() { update_panels(); get_active_panel()[["ylim_render"]] }
get_xlim <- function() { update_panels(); Env$xlim }
get_active_panel <- function() { get_panel(Env$active_panel_i) }
get_last_action_panel <- function() { get_panel(Env$last_action_panel_id) }
get_panel <- function(n)
{
if (n == 0) {
get_last_action_panel()
} else if (n > 0) {
Env$panels[[n]]
} else {
stop("'n' must be a positive integer")
}
}
add_panel_action <-
function(id,
expr,
env,
clip = TRUE,
where = c("last", "first", "background"),
...)
{
if (id < 0) {
where <- "first"
} else {
where <- match.arg(where)
}
this_panel <- get_panel(abs(id))
this_panel$add_action(expr, env, clip, where, ...)
}
create_ylim <-
function(x, const_y_mult = 0.2)
{
# Create y-axis limits from 'x'. Jitter the max/min limits by
# 'const_y_mult' if the max/min values are the same.
lim <- range(x, na.rm = TRUE)
if(isTRUE(all.equal(lim[1L], lim[2L]))) {
# if max and min are the same
if(lim[1L] == 0) {
lim <- c(-1, 1)
} else {
adj <- sign(lim[1L]) * const_y_mult
lim <- lim[1L] * c(1 - adj, 1 + adj)
}
}
return(lim)
}
# loop over panels and then actions
render_panels <-
function()
{
update_panels()
# all panel header/series asp pairs
all_asp <- lapply(Env$panels, function(p) p[["asp"]])
all_asp <- do.call(c, all_asp)
# panel header asp is always 5% of the total asp
panel_header_asp <- 0.05 * sum(all_asp)
# update panel header asp values
header_loc <- seq(1, length(all_asp), by = 2)
all_asp[header_loc] <- panel_header_asp
# main header asp is always 4% of the grand total asp
main_title_asp <- 0.04 * sum(all_asp)
all_asp <- c(main_title_asp, all_asp)
n_asp <- length(all_asp)
# render main plot header and x-axis
plot.window(Env$xlim, c(0, 1))
clip(par("usr")[1], par("usr")[2], 0, 1)
eval(Env$main_header_expr, Env) # header
eval(Env$main_xaxis_expr, Env) # x-axis
# render each panel
for (panel_n in seq_along(Env$panels)) {
panel <- Env$panels[[panel_n]]
# set the current active panel for the entire plot
Env$active_panel_i <- panel_n
is_header <- TRUE # header is always the first action
for (action in panel$actions) {
if (is_header) {
is_header <- FALSE
asp <- panel_header_asp
asp_n <- 2 * panel_n
ylim <- c(0, 1)
} else {
asp <- panel$asp["series"]
asp_n <- 2 * panel_n + 1
ylim <- panel$ylim_render
}
# scaled ylim
ylim_scale <- all_asp / asp * abs(diff(ylim))
ymin_adj <- sum(ylim_scale[-seq_len(asp_n)])
ymax_adj <- sum(ylim_scale[-(asp_n:n_asp)])
scaled_ylim <- c(ylim[1] - ymin_adj, ylim[2] + ymax_adj)
plot.window(Env$xlim, scaled_ylim)
if (attr(action, "clip")) {
clip(par("usr")[1], par("usr")[2], ylim[1], ylim[2])
}
action_env <- attr(action, "env")
eval(action, action_env)
}
}
}
get_xcoords <- function(xts_object = NULL, at_posix = FALSE) {
# unique index for all series (always POSIXct)
xcoords <- Env$xycoords$x
if (!is.null(xts_object)) {
# get the x-coordinates for the observations in xts_object
temp_xts <- .xts(seq_along(xcoords), xcoords, tzone = tzone(xts_object))
xcoords <- merge(temp_xts, xts_object,
fill = na.locf, # for duplicate index values
join = "right", retside = c(TRUE, FALSE))
if (!isTRUE(Env$extend.xaxis)) {
xc <- Env$xycoords$x
xi <- .index(xcoords)
xsubset <- which(xi >= xc[1] & xi <= xc[length(xc)])
xcoords <- xcoords[xsubset]
}
if(Env$observation.based && !at_posix) {
result <- drop(coredata(xcoords))
} else {
result <- .index(xcoords)
}
} else {
if(Env$observation.based && !at_posix) {
result <- seq_along(xcoords)
} else {
result <- xcoords
}
}
return(result)
}
# main plot header
Env$main_header_expr <- expression({
local({
text(x = xlim[1],
y = 1.0,
labels = main,
adj = c(0, 1),
cex = 1.1,
col = theme$labels,
font = 2)
if (main.timespan) {
text(x = xlim[2],
y = 1.0,
labels = paste(start(xdata[xsubset]),
end(xdata[xsubset]), sep = " / "),
adj = c(1, 1),
cex = 1,
col = theme$labels,
font = NULL)
}
}, new.env(TRUE, Env))
})
# main plot x-axis
Env$main_xaxis_expr <- expression({
local({
# add observation level ticks on x-axis if < 400 obs.
if (NROW(xdata[xsubset]) < 400) {
axis(1,
at = get_xcoords(),
labels = FALSE,
las = theme$las,
lwd.ticks = NULL,
mgp = NULL,
tcl = 0.3,
cex.axis = theme$cex.axis,
col = theme$labels,
col.axis = theme$grid2)
}
# and major and/or minor x-axis ticks and labels
xcoords <- get_xcoords()
x_index <- get_xcoords(at_posix = TRUE)
x_data <- .xts(, x_index, tzone = tzone(xdata))[xsubset]
use_major <- !isNullOrFalse(major.ticks)
use_minor <- !isNullOrFalse(minor.ticks)
types <- c("major", "minor")[c(use_major, use_minor)]
for (type in types) {
if (type== "major") {
axt <- axTicksByTime(x_data,
ticks.on = major.ticks,
format.labels = format.labels)
labels <- names(axt)
lwd.ticks <- 1.5
} else {
axt <- axTicksByTime(x_data,
ticks.on = minor.ticks,
format.labels = format.labels)
labels <- FALSE
lwd.ticks <- 0.75
}
axis(1,
at = xcoords[axt],
labels = labels,
las = theme$las,
lwd.ticks = lwd.ticks,
mgp = c(3,1.5,0),
tcl = -0.4,
cex.axis = theme$cex.axis,
col = theme$labels,
col.axis = theme$labels)
}
}, new.env(TRUE, Env))
})
# panel functionality
Env$panels <- list()
new_panel <-
function(ylim,
asp,
envir,
header,
...,
use_fixed_ylim = FALSE,
draw_left_yaxis = NULL,
draw_right_yaxis = NULL,
use_log_yaxis = FALSE,
title_timespan = FALSE)
{
panel <- new.env(TRUE, envir)
panel$id <- length(Env$panels) + 1
panel$asp <- c(header = 0.25, series = asp)
panel$ylim <- ylim
panel$ylim_render <- ylim
panel$use_fixed_ylim <- isTRUE(use_fixed_ylim)
panel$draw_left_yaxis <- ifelse(is.null(draw_left_yaxis), Env$theme$lylab, draw_left_yaxis)
panel$draw_right_yaxis <- ifelse(is.null(draw_right_yaxis), Env$theme$rylab, draw_right_yaxis)
panel$use_log_yaxis <- isTRUE(use_log_yaxis)
panel$header <- header
### actions
panel$actions <- list()
panel$add_action <-
function(expr,
env = Env,
clip = TRUE,
where = c("last", "first", "background"),
...)
{
if (!is.expression(expr)) {
expr <- as.expression(expr)
}
action <- structure(expr, clip = clip, env = env, ...)
panel$actions <-
switch(match.arg(where),
last = {
# after all the existing actions
append(panel$actions, list(action))
},
first = {
# after the header and grid lines
append(panel$actions, list(action), after = 3)
},
background = {
# after the header (which must be the 1st panel action)
append(panel$actions, list(action), after = 1)
})
Env$last_action_panel_id <<- panel$id
}
### header
# NOTE: this must be the 1st action for a panel
header_expr <-
expression({
text(x = xlim[1],
y = 0.3,
labels = header,
adj = c(0, 0),
pos = 4,
offset = 0,
cex = 0.9,
col = theme$labels,
font = NULL)
})
panel$add_action(header_expr, env = panel)
### y-axis
yaxis_expr <- expression({
if (use_fixed_ylim) {
# use the ylim argument
yl <- ylim
} else {
# use the updated ylim based on all panel data
yl <- ylim_render
}
# y-axis grid line labels and locations
if (use_log_yaxis) {
ylim_series <- exp(ylim_render)
# labels are based on the raw series values
grid_lbl <- pretty(ylim_series, Env$yaxis.ticks)
grid_lbl <- grid_lbl[grid_lbl >= ylim_series[1] & grid_lbl <= ylim_series[2]]
# locations are based on the log series values
grid_loc <- log(grid_lbl)
} else {
grid_loc <- pretty(yl, Env$yaxis.ticks)
grid_loc <- grid_loc[grid_loc >= yl[1] & grid_loc <= yl[2]]
grid_lbl <- grid_loc
}
# draw y-axis grid lines
segments(x0 = xlim[1], y0 = grid_loc,
x1 = xlim[2], y1 = grid_loc,
col = theme$grid,
lwd = grid.ticks.lwd,
lty = grid.ticks.lty)
# draw left y-axis grid labels
if (draw_left_yaxis) {
text(x = xlim[1],
y = grid_loc,
labels = format(grid_lbl, justify = "right"),
col = theme$labels,
srt = theme$srt,
offset = 0.5,
pos = 2,
cex = theme$cex.axis,
xpd = TRUE)
}
# draw right y-axis grid labels
if (draw_right_yaxis) {
text(x = xlim[2],
y = grid_loc,
labels = format(grid_lbl, justify = "right"),
col = theme$labels,
srt = theme$srt,
offset = 0.5,
pos = 4,
cex = theme$cex.axis,
xpd = TRUE)
}
# draw y-axis label
title(ylab = ylab[1], mgp = c(1, 1, 0))
})
panel$add_action(yaxis_expr, env = panel)
# x-axis grid
xaxis_action <- expression(x_grid_lines(xdata, grid.ticks.on, par("usr")[3:4]))
panel$add_action(xaxis_action, env = panel)
# append the new panel to the panel list
Env$panels <- append(Env$panels, list(panel))
return(panel)
}
update_panels <- function(headers=TRUE) {
# Recalculate each panel's 'ylim_render' value based on the
# 'xdata' of every action in the panel
for (panel_n in seq_along(Env$panels)) {
panel <- get_panel(panel_n)
if (!panel$use_fixed_ylim) {
# set 'ylim_render' to +/-Inf when ylim is NOT fixed, so
# it will be updated to include all the panel's data
panel$ylim_render <- c(Inf, -Inf)
# calculate a new ylim based on all the panel's data
for (action in panel$actions) {
action_env <- attr(action, "env")
action_data <- action_env$xdata
if (!is.null(action_data)) {
# some actions (e.g. addLegend) do not have 'xdata'
dat.range <- create_ylim(action_data[Env$xsubset])
# calculate new ylim based on the combination of the panel's
# original ylim and the action's 'xdata' ylim
new_ylim <-
c(min(panel$ylim[1], dat.range, na.rm = TRUE),
max(panel$ylim[2], dat.range, na.rm = TRUE))
# set to new ylim values
panel$ylim_render <- new_ylim
}
}
}
if (panel$use_log_yaxis) {
panel$ylim_render <- log(panel$ylim_render)
}
}
update_xaxis <- function(panel, x_axis)
{
# Create x-axis values using index values from data from all panels
for (action in panel$actions) {
action_env <- attr(action, "env")
action_data <- action_env$xdata
if (!is.null(action_data)) {
# some actions (e.g. addLegend) do not have 'xdata'
action_xaxis <- .index(action_data[Env$xsubset])
new_xaxis <- sort(unique(c(x_axis, action_xaxis)))
if (isTRUE(Env$extend.xaxis)) {
result <- new_xaxis
} else {
xaxis_rng <- range(x_axis, na.rm = TRUE)
result <- new_xaxis[new_xaxis >= xaxis_rng[1L] &
new_xaxis <= xaxis_rng[2L]]
}
}
}
return(result)
}
x_axis <- .index(Env$xdata[Env$xsubset])
for (panel in Env$panels) {
x_axis <- update_xaxis(panel, x_axis)
}
# Create x/y coordinates using the combined x-axis index
Env$xycoords <- xy.coords(x_axis, seq_along(x_axis))
if (Env$observation.based) {
Env$xlim <- c(1, length(get_xcoords()))
} else {
Env$xlim <- range(get_xcoords(), na.rm = TRUE)
}
}
# return
replot_env <- new.env()
class(replot_env) <- c("replot_xts","environment")
replot_env$Env <- Env
replot_env$new_panel <- new_panel
replot_env$get_xcoords <- get_xcoords
replot_env$update_panels <- update_panels
replot_env$render_panels <- render_panels
replot_env$get_panel <- get_panel
replot_env$add_panel_action <- add_panel_action
replot_env$get_xlim <- get_xlim
replot_env$get_ylim <- get_ylim
replot_env$create_ylim <- create_ylim
replot_env$get_active_panel <- get_active_panel
replot_env$get_last_action_panel <- get_last_action_panel
replot_env$new_environment <- function() { new.env(TRUE, Env) }
# function to plot the x-axis grid lines
replot_env$Env$x_grid_lines <- function(x, ticks.on, ylim)
{
if (isNullOrFalse(ticks.on)) {
invisible()
} else {
if (isTRUE(ticks.on)) ticks.on <- "auto"
xcoords <- get_xcoords()
x_index <- get_xcoords(at_posix = TRUE)
atbt <- axTicksByTime(.xts(, x_index, tzone = tzone(x)),
ticks.on = ticks.on)
segments(xcoords[atbt], ylim[1L],
xcoords[atbt], ylim[2L],
col = Env$theme$grid,
lwd = Env$grid.ticks.lwd,
lty = Env$grid.ticks.lty)
}
}
return(replot_env)
}
str.replot_xts <- function(object, ...) {
print(str(unclass(object)))
}
print.replot_xts <- function(x, ...) plot(x,...)
plot.replot_xts <- function(x, ...) {
# must set the background color before calling plot.new
obg <- par(bg = x$Env$theme$bg)
plot.new()
assign(".xts_chob",x,.plotxtsEnv)
# only reasonable way to fix X11/quartz issue
ocex <- par(cex = if(.Device == "X11") x$Env$cex else x$Env$cex * 1.5)
omar <- par(mar = x$Env$mar)
oxpd <- par(xpd = FALSE)
usr <- par("usr")
# reset par
on.exit(par(xpd = oxpd$xpd, cex = ocex$cex, mar = omar$mar, bg = obg$bg))
x$render_panels()
do.call("clip", as.list(usr)) # reset clipping region
invisible(x$Env$actions)
}
xts/R/isOrdered.R 0000644 0001762 0000144 00000004055 14654242576 013357 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Check If A Vector Is Ordered
#'
#' Check if a vector is strictly increasing, strictly decreasing, not
#' decreasing, or not increasing.
#'
#' Designed for internal use with \pkg{xts}, this provides highly optimized
#' tests for ordering.
#'
#' @param x A numeric vector.
#' @param increasing Test for increasing (`TRUE`) or decreasing (`FALSE`) values?
#' @param strictly When `TRUE`, vectors with duplicate values are *not*
#' considered ordered.
#'
#' @return A logical scalar indicating whether or not `x` is ordered.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`is.unsorted()`]
#'
#' @keywords misc
#' @examples
#'
#' # strictly increasing
#' isOrdered(1:10, increasing=TRUE)
#' isOrdered(1:10, increasing=FALSE)
#' isOrdered(c(1,1:10), increasing=TRUE)
#' isOrdered(c(1,1:10), increasing=TRUE, strictly=FALSE)
#'
#' # decreasing
#' isOrdered(10:1, increasing=TRUE)
#' isOrdered(10:1, increasing=FALSE)
#'
`isOrdered` <- function(x, increasing=TRUE, strictly=TRUE) {
# x must be of type double or integer. Checked in the C code.
if(is.character(x))
stop('character ordering unsupported')
if(!is.numeric(x))
x = as.numeric(x)
.Call(C_do_is_ordered,
x = x,
increasing = as.logical(increasing),
strictly = as.logical(strictly))
}
xts/R/all.equal.R 0000644 0001762 0000144 00000003073 14634167654 013315 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2019 Joshua M. Ulrich
#
# 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, see .
all.equal.xts <-
function(target,
current,
...,
check.attributes = TRUE)
{
if (isTRUE(check.attributes)) {
# Remove potential index attributes on the objects
attrNames <- c(".indexCLASS", ".indexTZ", "tclass", "tzone")
for (aname in attrNames) {
attr(target, aname) <- NULL
attr(current, aname) <- NULL
}
# Order the object attributes
a <- attributes(target)
attributes(target) <- a[sort(names(a))]
a <- attributes(current)
attributes(current) <- a[sort(names(a))]
# Order the index attributes
a <- attributes(.index(target))
attributes(.index(target)) <- a[sort(names(a))]
a <- attributes(.index(current))
attributes(.index(current)) <- a[sort(names(a))]
}
NextMethod("all.equal")
}
xts/R/timeSeries.R 0000644 0001762 0000144 00000005612 14654242576 013550 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# functions to handle timeSeries <--> xts conversions
`re.timeSeries` <-
function(x,...) {
if(!requireNamespace('timeSeries', quietly=TRUE)) {
timeSeries <- function(...) message("package 'timeSeries' is required")
} else {
timeSeries <- timeSeries::timeSeries
}
# strip all non-'core' attributes so they're not attached to the Data slot
x.attr <- attributes(x)
xx <- structure(x,dimnames=x.attr$dimnames,index=x.attr$index)
original.attr <- attributes(x)[!names(attributes(x)) %in%
c("dim","dimnames","index","class")]
for(i in names(original.attr)) {
attr(xx,i) <- NULL
}
timeSeries(coredata(xx),charvec=as.POSIXct(format(index(x)),tz="GMT"),format=x.attr$format,
zone=x.attr$FinCenter,FinCenter=x.attr$FinCenter,
recordIDs=x.attr$recordIDs,title=x.attr$title,
documentation=x.attr$documentation,...)
}
#' @rdname as.xts
`as.xts.timeSeries` <-
function(x,dateFormat="POSIXct",FinCenter,recordIDs,title,documentation,..., .RECLASS=FALSE) {
if(missing(FinCenter))
FinCenter <- x@FinCenter
if(missing(recordIDs))
recordIDs <- x@recordIDs
if(missing(title))
title <- x@title
if(missing(documentation))
documentation <- x@documentation
indexBy <- structure(x@positions, class=c("POSIXct","POSIXt"), tzone=FinCenter)
order.by <- do.call(paste('as',dateFormat,sep='.'),list(as.character(indexBy)))
if(.RECLASS) {
xts(as.matrix(x@.Data),
order.by=order.by,
format=x@format,
FinCenter=FinCenter,
recordIDs=recordIDs,
title=title,
documentation=documentation,
.CLASS='timeSeries',
.CLASSnames=c('FinCenter','recordIDs','title','documentation','format'),
.RECLASS=TRUE,
...)
} else {
xts(as.matrix(x@.Data),
order.by=order.by,
...)
}
}
as.timeSeries.xts <- function(x, ...) {
if(!requireNamespace('timeSeries', quietly=TRUE)) {
timeSeries <- function(...) message("package 'timeSeries' is required")
} else {
timeSeries <- timeSeries::timeSeries
}
timeSeries(data=coredata(x), charvec=as.character(index(x)), ...)
}
xts/R/Ops.xts.R 0000644 0001762 0000144 00000006141 14654242576 013013 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
`Ops.xts` <-
function(e1, e2)
{
# determine and output class
# use 'e1' first because e2 is missing for unary +/-/!
if(inherits(e1, "xts")) {
# e1 could be a derived class; use its class for output
# NOTE: we want the output to be an xts object even if e2 is a derived
# class, because Ops.xts() might not create an appropriate derived class
# object
out_class <- class(e1)
} else {
# if 'e1' isn't xts, then e2 must be xts or a derived class, otherwise
# this method wouldn't have been called
out_class <- class(e2)
}
e <- if (missing(e2)) {
.Class <- "matrix"
NextMethod(.Generic)
}
else if (any(nchar(.Method) == 0)) {
.Class <- "matrix"
NextMethod(.Generic)
}
else {
if( NROW(e1)==NROW(e2) && identical(.index(e1),.index(e2)) ) {
.Class <- "matrix"
NextMethod(.Generic)
} else {
tmp.e1 <- merge.xts(e1, e2, all=FALSE, retclass=FALSE, retside=c(TRUE,FALSE), check.names=FALSE)
e2 <- merge.xts(e2, e1, all=FALSE, retclass=FALSE, retside=c(TRUE,FALSE), check.names=FALSE)
e1 <- tmp.e1
.Class <- "matrix"
NextMethod(.Generic)
}
}
# These return an object the same class as input(s); others return a logical object
if(.Generic %in% c("+","-","*","/","^","%%","%/%")) {
e <- .Call(C_add_class, e, out_class)
}
if(length(e)==0) {
if(is.xts(e1)) {
idx <- .index(e1)
} else {
idx <- .index(e2)
}
idx[] <- idx[0]
attr(e,'index') <- idx
}
dn <- dimnames(e)
if(!is.null(dn[[1L]])) {
if(is.null(dn[[2L]])) {
attr(e, "dimnames") <- NULL
} else {
dimnames(e) <- list(NULL, dn[[2L]])
}
}
if(is.null(attr(e,'index'))) {
if(is.xts(e1)) {
e <- .xts(e, .index(e1), tclass(e1), tzone(e1), tformat = tformat(e1))
} else if(is.xts(e2)) {
e <- .xts(e, .index(e2), tclass(e2), tzone(e2), tformat = tformat(e2))
} else {
# neither have class = ('xts', 'zoo'), because they were overwritten
# by the result of merge(..., retclass = FALSE). But they still have
# an 'index' attribute.
ix <- .index(e1)
if (is.null(ix)) {
ix <- .index(e2)
}
e <- .xts(e, ix, tclass(ix), tzone(ix), tformat = tformat(ix))
}
if(is.null(dim(e1)) && is.null(dim(e2)))
dim(e) <- NULL
}
attr(e, "names") <- NULL
e
}
xts/R/data.frame.R 0000644 0001762 0000144 00000004506 14654242576 013442 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# functions to handle data.frame <--> xts conversions
`re.data.frame` <-
function(x,...) {
data.frame(x,...)
}
#' @rdname as.xts
`as.xts.data.frame` <-
function(x,
order.by,
dateFormat = "POSIXct",
frequency = NULL,
...,
.RECLASS = FALSE)
{
# Should allow 'order.by' to be a vector of dates or a scaler
# representing the column number to use.
if(missing(order.by)) {
order_by_ <- try({
coerce.rownames <- paste("as", dateFormat, sep = ".")
do.call(coerce.rownames, list(rownames(x)))
}, silent = TRUE)
if(inherits(order_by_, "try-error")) {
# parsing row names failed, so look for a time-based column
time.based.col <- vapply(x, is.timeBased, logical(1))
if(any(time.based.col)) {
# use the first time-based column
which.col <- which.max(time.based.col)
order_by_ <- x[[which.col]]
x <- x[, -which.col, drop = FALSE]
} else {
stop("could not convert row names to a date-time and could not find a time-based column")
}
}
} else {
order_by_ <- order.by
}
if(.RECLASS) {
xx <- xts(x,
order.by=order_by_,
frequency=frequency,
.CLASS='data.frame',
...)
} else {
xx <- xts(x,
order.by=order_by_,
frequency=frequency,
...)
}
xx
}
`as.data.frame.xts` <-
function(x,row.names=NULL,optional=FALSE,...) {
if(missing(row.names))
row.names <- as.character(index(x))
as.data.frame(coredata(x),row.names,optional,...)
}
xts/R/print.R 0000644 0001762 0000144 00000011423 14702273202 012550 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Print An xts Time-Series Object
#'
#' Method for printing an extensible time-series object.
#'
#' @param x An xts object.
#' @param fmt Passed to [`coredata()`][zoo::coredata] to format the time index.
#' @param \dots Arguments passed to other methods.
#' @param show.rows The number of first and last rows to print if the number of
#' rows is truncated (default 10, or `getOption("xts.print.show.rows")`).
#' @param max.rows The output will contain at most `max.rows` rows before being
#' truncated (default 100, or `getOption("xts.print.max.rows")`).
#'
#' @return Returns `x` invisibly.
#'
#' @author Joshua M. Ulrich
#'
#' @keywords print
#' @examples
#'
#' data(sample_matrix)
#' sample.xts <- as.xts(sample_matrix)
#'
#' # output is truncated and shows first and last 10 observations
#' print(sample.xts)
#'
#' # show the first and last 5 observations
#' print(sample.xts, show.rows = 5)
#'
print.xts <-
function(x,
fmt,
...,
show.rows = 10,
max.rows = 100)
{
check.TZ(x)
nr <- NROW(x)
nc <- NCOL(x)
dots <- list(...)
if (missing(max.rows)) {
# the user didn't specify a value; use the global option value if it's
# set; if it's not set, use the default value
max.rows <- getOption("xts.print.max.rows", max.rows)
}
# 'max' in print.default() takes precedence over 'show.rows'
if (hasArg("max")) {
# 'max' is the number of *elements* (not rows) to print
if (nr < 1) {
show.rows <- 0
} else {
# convert 'max' to 'show.rows'
if (!is.null(dots$max)) {
show.rows <- trunc(dots$max / nc)
}
}
} else if (missing(show.rows)) {
# the user didn't specify a value; use the global option value if it's
# set; if it's not set, use the default value
show.rows <- getOption("xts.print.show.rows", show.rows)
}
if (missing(fmt)) {
fmt <- tformat(x)
}
if (is.null(fmt)) {
fmt <- TRUE
}
if (!hasArg("quote")) {
dots$quote <- FALSE
}
if (!hasArg("right")) {
dots$right <- TRUE
}
if (nr > max.rows && nr > 2 * show.rows) {
# 'show.rows' can't be more than 2*nrow(x) or observations will be printed
# twice, once before the "..." and once after.
seq.row <- seq_len(show.rows)
seq.col <- seq_len(nc)
seq.n <- (nr - show.rows + 1):nr
# format all the index values that will be printed,
# so every row will have the same number of characters
index <- format(index(x)[c(seq.row, seq.n)])
# combine the index values with the '...' separator
index <- c(index[seq.row], "...", index[-c(seq.row, tail(seq.row, 1))])
# as.matrix() to ensure we have dims
# unclass() avoids as.matrix() method dispatch
m <- as.matrix(unclass(x))
# convert to data.frame to format each column individually
m <- data.frame(m[c(seq.row, seq.n), seq.col, drop = FALSE])
m[] <- lapply(m, format)
m <- as.matrix(m)
# insert blank row between top and bottom rows
y <- rbind(utils::head(m, show.rows),
rep("", nc),
utils::tail(m, show.rows))
rownames(y) <- format(index, justify = "right")
colnames(y) <- colnames(m[, seq.col, drop = FALSE])
} else {
y <- coredata(x, fmt)
}
if (length(y) == 0) {
if (!is.null(dim(x))) {
p <- structure(vector(storage.mode(y)), dim = dim(x),
dimnames = list(format(index(x)), colnames(x)))
print(p)
} else {
cat('Data:\n')
print(vector(storage.mode(y)))
cat('\n')
cat('Index:\n')
index <- index(x)
if (length(index) == 0) {
print(index)
} else {
print(str(index))
}
}
} else {
# ensure 'y' has dims and row names
if (is.null(dim(y))) {
y_names <- as.character(index(x))
y <- matrix(y, nrow = length(y), dimnames = list(y_names, NULL))
}
# Create column names as column indexes.
if (is.null(colnames(y))) {
colnames(y) <- paste0("[,", seq_len(ncol(y)), "]")
}
do.call("print", c(list(y), dots))
}
invisible(x)
}
xts/R/period.apply.R 0000644 0001762 0000144 00000020701 14654242576 014041 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
.mean_by_column_message <-
function(caller)
{
if (getOption("xts.message.period.apply.mean", TRUE)) {
message("NOTE: `", caller, "(..., FUN = mean)` operates by column, unlike other math\n ",
"functions (e.g. median, sum, var, sd). Please use `FUN = colMeans` instead,\n ",
"and use `FUN = function(x) mean(x)` to take the mean of all columns. Set\n ",
"`options(xts.message.period.apply.mean = FALSE)` to suppress this message.")
}
# changing this behavior will break code in the following dependencies:
#
# ATAforecasting/R/ATA_Find_Multi_Freq.R
# bidask/R/utils.R
# dsa/R/HelperFunctions.R # {.tomonth}
# RavenR/inst/doc/Introduction_to_RavenR.R
# RavenR/inst/doc/Introduction_to_RavenR.Rmd
# RavenR/R/rvn_apply_wyearly.R
# RavenR/R/rvn_monthly_vbias.R
# rts/man/apply.monthly.Rd
# rts/man/period.apply.Rd
# RWDataPlyr/R/xts_helperFunctions.R
}
#' Apply Function Over Specified Interval
#'
#' Apply a specified function to data over intervals specified by `INDEX`. The
#' intervals are defined as the observations from `INDEX[k]+1` to `INDEX[k+1]`,
#' for `k = 1:(length(INDEX)-1)`.
#'
#' Similar to the rest of the apply family, `period.apply()` calculates the
#' specified function's value over a subset of data. The primary difference is
#' that `period.apply()` applies the function to non-overlapping intervals of a
#' vector or matrix.
#'
#' Useful for applying functions over an entire data object by any
#' non-overlapping intervals. For example, when `INDEX` is the result of a
#' call to `endpoints()`.
#'
#' `period.apply()` checks that `INDEX` is sorted, unique, starts with 0, and
#' ends with `nrow(x)`. All those conditions are true of vectors returned by
#' `endpoints()`.
#'
#' @param x The data that `FUN` will be applied to.
#' @param INDEX A numeric vector of index breakpoint locations. The vector
#' should begin with 0 and end with `nrow(x)`.
#' @param FUN A function to apply to each interval in `x`.
#' @param \dots Additional arguments for `FUN`.
#'
#' @return An object with `length(INDEX) - 1` observations, assuming `INDEX`
#' starts with 0 and ends with `nrow(x)`.
#'
#' @note When `FUN = mean` the results will contain one column for every
#' column in the input, which is different from other math functions (e.g.
#' `median`, `sum`, `prod`, `sd`, etc.).
#'
#' `FUN = mean` works by column because the default method `stats::mean`
#' previously worked by column for matrices and data.frames. R Core changed the
#' behavior of `mean` to always return one column in order to be consistent
#' with the other math functions. This broke some \pkg{xts} dependencies and
#' `mean.xts()` was created to maintain the original behavior.
#'
#' Using `FUN = mean` will print a message that describes this inconsistency.
#' To avoid the message and confusion, use `FUN = colMeans` to calculate means
#' by column and use `FUN = function(x) mean` to calculate one mean for all the
#' data. Set `options(xts.message.period.apply.mean = FALSE)` to suppress this
#' message.
#'
#' @author Jeffrey A. Ryan, Joshua M. Ulrich
#'
#' @seealso [`endpoints()`] [`apply.monthly()`]
#'
#' @keywords utilities
#' @examples
#'
#' zoo.data <- zoo(rnorm(31)+10,as.Date(13514:13744,origin="1970-01-01"))
#' ep <- endpoints(zoo.data,'weeks')
#' period.apply(zoo.data, INDEX=ep, FUN=function(x) colMeans(x))
#' period.apply(zoo.data, INDEX=ep, FUN=colMeans) #same
#'
#' period.apply(letters,c(0,5,7,26), paste0)
#'
`period.apply` <-
function(x, INDEX, FUN, ...)
{
if (deparse(substitute(FUN))[1] == "mean") {
.mean_by_column_message("period.apply")
}
x <- try.xts(x, error = FALSE)
FUN <- match.fun(FUN)
if(!isOrdered(INDEX)) {
# isOrdered returns FALSE if there are duplicates
INDEX <- sort(unique(INDEX))
}
if(INDEX[1] != 0) {
INDEX <- c(0, INDEX)
}
if(last(INDEX) != NROW(x)) {
INDEX <- c(INDEX, NROW(x))
}
xx <- sapply(1:(length(INDEX) - 1), function(y) {
FUN(x[(INDEX[y] + 1):INDEX[y + 1]], ...)
})
if(is.vector(xx))
xx <- t(xx)
xx <- t(xx)
if(is.null(colnames(xx)) && NCOL(x)==NCOL(xx))
colnames(xx) <- colnames(x)
reclass(xx, x[INDEX])
}
#' @rdname apply.monthly
`apply.daily` <-
function(x,FUN, ...)
{
if (deparse(substitute(FUN))[1] == "mean") {
.mean_by_column_message("apply.daily")
}
ep <- endpoints(x,'days')
period.apply(x,ep,FUN, ...)
}
#' @rdname apply.monthly
`apply.weekly` <-
function(x,FUN, ...)
{
if (deparse(substitute(FUN))[1] == "mean") {
.mean_by_column_message("apply.weekly")
}
ep <- endpoints(x,'weeks')
period.apply(x,ep,FUN, ...)
}
#' Apply Function over Calendar Periods
#'
#' Apply a specified function to each distinct period in a given time series
#' object.
#'
#' Simple mechanism to apply a function to non-overlapping time periods, e.g.
#' weekly, monthly, etc. Different from rolling functions in that this will
#' subset the data based on the specified time period (implicit in the call),
#' and return a vector of values for each period in the original data.
#'
#' Essentially a wrapper to the \pkg{xts} functions `endpoints()` and
#' `period.apply()`, mainly as a convenience.
#'
#' @param x A time-series object coercible to xts.
#' @param FUN A function to apply to each period.
#' @param \dots Additional arguments to `FUN`.
#'
#' @return A vector of results produced by `FUN`, corresponding to the
#' appropriate periods.
#'
#' @note When `FUN = mean` the results will contain one column for every
#' column in the input, which is different from other math functions (e.g.
#' `median`, `sum`, `prod`, `sd`, etc.).
#'
#' `FUN = mean` works by column because the default method `stats::mean`
#' previously worked by column for matrices and data.frames. R Core changed the
#' behavior of `mean` to always return one column in order to be consistent
#' with the other math functions. This broke some \pkg{xts} dependencies and
#' `mean.xts()` was created to maintain the original behavior.
#'
#' Using `FUN = mean` will print a message that describes this inconsistency.
#' To avoid the message and confusion, use `FUN = colMeans` to calculate means
#' by column and use `FUN = function(x) mean` to calculate one mean for all the
#' data. Set `options(xts.message.period.apply.mean = FALSE)` to suppress this
#' message.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`endpoints()`], [`period.apply()`], [`to.monthly()`]
#'
#' @keywords utilities
#' @examples
#'
#' xts.ts <- xts(rnorm(231),as.Date(13514:13744,origin="1970-01-01"))
#'
#' start(xts.ts)
#' end(xts.ts)
#'
#' apply.monthly(xts.ts,colMeans)
#' apply.monthly(xts.ts,function(x) var(x))
#'
`apply.monthly` <-
function(x,FUN, ...)
{
if (deparse(substitute(FUN))[1] == "mean") {
.mean_by_column_message("apply.monthly")
}
ep <- endpoints(x,'months')
period.apply(x,ep,FUN, ...)
}
#' @rdname apply.monthly
`apply.quarterly` <-
function(x,FUN, ...)
{
if (deparse(substitute(FUN))[1] == "mean") {
.mean_by_column_message("apply.quarterly")
}
ep <- endpoints(x,'quarters')
period.apply(x,ep,FUN, ...)
}
#' @rdname apply.monthly
`apply.yearly` <-
function(x,FUN, ...)
{
if (deparse(substitute(FUN))[1] == "mean") {
.mean_by_column_message("apply.yearly")
}
ep <- endpoints(x,'years')
period.apply(x,ep,FUN, ...)
}
period_apply <- function(x, INDEX, FUN, ...) {
fun <- substitute(FUN)
e <- new.env()
if (INDEX[1] != 0) {
INDEX <- c(0, INDEX)
}
if (INDEX[length(INDEX)] != NROW(x)) {
INDEX <- c(INDEX, NROW(x))
}
pl <- .Call(C_xts_period_apply, x, INDEX, fun, e)
.xts(do.call(rbind, pl), .index(x)[INDEX], tclass = tclass(x), tzone = tzone(x))
}
xts/R/index.R 0000644 0001762 0000144 00000032603 14654242576 012546 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Get and Replace the Class of an xts Index
#'
#' Functions to get and replace an xts object's index values and it's
#' components.
#'
#' An xts object's index is stored internally as the number of seconds since
#' UNIX epoch in the UTC timezone. The `.index()` and `.index<-` functions get
#' and replace the internal numeric value of the index, respectively. These
#' functions are primarily for internal use, but are exported because they may
#' be useful for users.
#'
#' The replacement method also updates the [`tclass()`] and [`tzone()`] of the
#' index to match the class and timezone of the new index, respectively. The
#' `index()` method converts the internal numeric index to the class specified
#' by the 'tclass' attribute and with the timezone specified by the 'tzone'
#' attribute before returning the index values to the user.
#'
#' The `.indexXXX()` functions below extract time components from the internal
#' time index. They return values like the values of [POSIXlt] components.
#'
#' \describe{
#' \item{`.indexsec`}{0 - 61: seconds of the minute (local time)}
#' \item{`.indexmin`}{0 - 59: minutes of the hour (local time)}
#' \item{`.indexhour`}{0 - 23: hours of the day (local time)}
#' \item{`.indexDate`}{date as seconds since the epoch (UTC *not local time*}
#' \item{`.indexday`}{date as seconds since the epoch (UTC *not local time*}
#' \item{`.indexwday`}{0 - 6: day of the week (Sunday - Saturday, local time)}
#' \item{`.indexmday`}{1 - 31: day of the month (local time)}
#' \item{`.indexweek`}{weeks since the epoch (UTC *not local time*}
#' \item{`.indexmon`}{0 - 11: month of the year (local time)}
#' \item{`.indexyear`}{years since 1900 (local time)}
#' \item{`.indexyday`}{0 - 365: day of the year (local time, 365 only in leap years)}
#' \item{`.indexisdst`}{1, 0, -1: Daylight Saving Time flag. Positive if
#' Daylight Saving Time is in effect, zero if not, negative if unknown.}
#' }
#'
#' Changes in timezone, index class, and index format internal structure, by
#' \pkg{xts} version:
#'
#' \describe{
#' \item{Version 0.12.0:}{The `.indexTZ`, `.indexCLASS` and `.indexFORMAT`
#' attributes are no longer stored on xts objects, only on the index itself.
#' \cr\cr
#' The `indexTZ()`, `indexClass()`, and `indexFormat()` functions (and
#' their respective replacement methods) are deprecated in favor of their
#' respective `tzone()`, `tclass()`, and `tformat()` versions. The previous
#' versions throw a warning that they're deprecated, but they will continue
#' to work. They will never be removed or throw an error. Ever.
#' \cr\cr
#' The new versions are careful to look for the old attributes on the xts
#' object, in case they're ever called on an xts object that was created prior
#' to the attributes being added to the index itself.
#' \cr\cr
#' You can set `options(xts.warn.index.missing.tzone = TRUE)` and
#' `options(xts.warn.index.missing.tclass = TRUE)` to identify xts objects
#' that do not have a 'tzone' or 'tclass' attribute on the index, even if
#' there is a 'tzone' or 'tclass' attribute on the xts object itself. The
#' warnings will be thrown when the object is printed.
#' Use `x <- as.xts(x)` to update these objects to the new structure.}
#'
#' \item{Version 0.9.8:}{The index timezone is now set to "UTC" for time classes
#' that do not have any intra-day component (e.g. days, months, quarters).
#' Previously the timezone was blank, which meant "local time" as determined by
#' \R and the OS.}
#'
#' \item{Version 0.9.2:}{There are new get/set methods for the timezone, index
#' class, and index format attributes: `tzone()` and, `tzone<-`, `tclass()`
#' and `tclass<-`, and `tformat()` and `tformat<-`. These new functions are
#' aliases to their `indexTZ()`, `indexClass()`, and `indexFormat()`
#' counterparts.}
#'
#' \item{Version 0.7.5:}{The timezone, index class, and index format were added
#' as attributes to the index itself, as 'tzone', 'tclass', and 'tformat',
#' respectively. This is in order to remove those three attributes from the xts
#' object, so they're only on the index itself.
#' \cr\cr
#' The `indexTZ()`, `indexClass()`, and `indexFormat()` functions (and their
#' respective replacement methods) will continue to work as in prior \pkg{xts}
#' versions. The attributes on the index take priority over their respective
#' counterparts that may be on the xts object.}
#'
#' \item{Versions 0.6.4 and prior:}{Objects track their timezone and index class
#' in their '.indexTZ' and '.indexCLASS' attributes, respectively.}
#' }
#'
#' @param x An xts object.
#' @param value A new time index value.
#' @param \dots Arguments passed to other methods.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`tformat()`] describes how the index values are formatted when
#' printed, [`tclass()`] documents how \pkg{xts} handles the index class, and
#' [`tzone()`] has more information about index timezone settings.
#'
#' @keywords ts utilities
#' @examples
#'
#' x <- timeBasedSeq('2010-01-01/2010-01-01 12:00/H')
#' x <- xts(seq_along(x), x)
#'
#' # the index values, converted to 'tclass' (POSIXct in this case)
#' index(x)
#' class(index(x)) # POSIXct
#' tclass(x) # POSIXct
#'
#' # the internal numeric index
#' .index(x)
#' # add 1 hour (3600 seconds) to the numeric index
#' .index(x) <- index(x) + 3600
#' index(x)
#'
#' y <- timeBasedSeq('2010-01-01/2010-01-02 12:00')
#' y <- xts(seq_along(y), y)
#'
#' # Select all observations in the first 6 and last 3 minutes of the
#' # 8th and 15th hours on each day
#' y[.indexhour(y) %in% c(8, 15) & .indexmin(y) %in% c(0:5, 57:59)]
#'
#' i <- 0:60000
#' focal_date <- as.numeric(as.POSIXct("2018-02-01", tz = "UTC"))
#' y <- .xts(i, c(focal_date + i * 15), tz = "UTC", dimnames = list(NULL, "value"))
#'
#' # Select all observations for the first minute of each hour
#' y[.indexmin(y) == 0]
#'
#' # Select all observations on Monday
#' mon <- y[.indexwday(y) == 1]
#' head(mon)
#' tail(mon)
#' unique(weekdays(index(mon))) # check
#'
#' # Disjoint time of day selections
#'
#' # Select all observations between 08:30 and 08:59:59.9999 or between 12:00 and 12:14:59.99999:
#' y[.indexhour(y) == 8 & .indexmin(y) >= 30 | .indexhour(y) == 12 & .indexmin(x) %in% 0:14]
#'
#' ### Compound selections
#'
#' # Select all observations for Wednesdays or Fridays between 9am and 4pm (exclusive of 4pm):
#' y[.indexwday(y) %in% c(3, 5) & (.indexhour(y) %in% c(9:15))]
#'
#' # Select all observations on Monday between 8:59:45 and 09:04:30:
#'
#' y[.indexwday(y) == 1 & (.indexhour(y) == 8 & .indexmin(y) == 59 & .indexsec(y) >= 45 |
#' .indexhour(y) == 9 &
#' (.indexmin(y) < 4 | .indexmin(y) == 4 & .indexsec(y) <= 30))]
#'
#' i <- 0:30000
#' u <- .xts(i, c(focal_date + i * 1800), tz = "UTC", dimnames = list(NULL, "value"))
#'
#' # Select all observations for January or February:
#' u[.indexmon(u) %in% c(0, 1)]
#'
#' # Select all data for the 28th to 31st of each month, excluding any Fridays:
#' u[.indexmday(u) %in% 28:31 & .indexwday(u) != 5]
#'
#' # Subset by week since origin
#' unique(.indexweek(u))
#' origin <- xts(1, as.POSIXct("1970-01-01"))
#' unique(.indexweek(origin))
#'
#' # Select all observations in weeks 2515 to 2517.
#' u2 <- u[.indexweek(u) %in% 2515:2517]
#' head(u2); tail(u2)
#'
#' # Select all observations after 12pm for day 50 and 51 in each year
#' u[.indexyday(u) %in% 50:51 & .indexhour(u) >= 12]
#'
index.xts <-
function(x, ...) {
value <- tclass(x)
if(is.null(value) || !nzchar(value[1L])) {
warning("index does not have a ", sQuote("tclass"), " attribute\n",
" returning c(\"POSIXct\", \"POSIXt\")")
ix <- .index(x)
attr(ix, "tclass") <- attr(ix, "class") <- c("POSIXct", "POSIXt")
return(ix)
}
# if tclass is Date, POSIXct time is set to 00:00:00 GMT. Convert here
# to avoid ugly and hard to debug TZ conversion. What will this break?
if(value[[1]] == "Date")
#return( as.Date(.index(x)/86400) )
return( structure(.index(x) %/% 86400, class="Date"))
#x.index <- structure(.index(x), class=c("POSIXct","POSIXt"))
x.index <- .POSIXct(.index(x), tz=attr(.index(x), "tzone"))
if(!is.list(value))
value <- as.list(value)
switch(value[[1]],
multitime = as.Date(as.character(x.index)),
POSIXt = {
# get specific ct/lt value
do.call(paste('as',value[[2]],sep='.'),list(x.index))
},
POSIXct = as.POSIXct(x.index),
POSIXlt = as.POSIXlt(x.index),
timeDate = {
if(!requireNamespace("timeDate", quietly=TRUE))
stop("package:",dQuote("timeDate"),"cannot be loaded.")
timeDate::as.timeDate(x.index)
},
chron = ,
dates = {
if(!requireNamespace("chron", quietly=TRUE))
stop("package:",dQuote("chron"),"cannot be loaded.")
chron::as.chron(format(x.index))
},
#Date = as.Date(as.character(x.index)), # handled above
yearmon = as.yearmon(x.index),
yearqtr = as.yearqtr(x.index),
stop(paste('unsupported',sQuote('tclass'),'indexing type:',value[[1]]))
)
}
#' @rdname index.xts
`index<-.xts` <- function(x, value) {
if(length(index(x)) != length(value)) stop('length of index vectors does not match')
if( !timeBased(value) )
stop(paste('unsupported',sQuote('index'),
'index type of class',sQuote(class(value))))
# copy original index attributes
ixattr <- attributes(attr(x, 'index'))
# set index to the numeric value of the desired index class
if(inherits(value,"Date"))
attr(x, 'index') <- structure(unclass(value)*86400, tclass="Date", tzone="UTC")
else attr(x, 'index') <- as.numeric(as.POSIXct(value))
# ensure new index is sorted
if(!isOrdered(.index(x), strictly=FALSE))
stop("new index needs to be sorted")
# set tclass attribute to the end-user specified class
attr(attr(x, 'index'), 'tclass') <- class(value)
# set tzone attribute
if(isClassWithoutTZ(object = value)) {
attr(attr(x, 'index'), 'tzone') <- 'UTC'
} else {
if (is.null(attr(value, 'tzone'))) {
# ensure index has tzone attribute if value does not
attr(attr(x, 'index'), 'tzone') <- ixattr[["tzone"]]
} else {
attr(attr(x, 'index'), 'tzone') <- attr(value, 'tzone')
}
}
return(x)
}
#' @rdname index.xts
`time<-.xts` <- `index<-.xts`
#' @rdname index.xts
time.xts <- index.xts
#' @rdname index.xts
`.index` <- function(x, ...) {
if(is.list(attr(x, "index"))) {
attr(x, 'index')[[1]]
} else attr(x, "index")
}
#' @rdname index.xts
`.index<-` <- function(x, value) {
if(timeBased(value)) {
if(inherits(value, 'Date')) {
attr(x, 'index') <- as.numeric(value)
} else {
attr(x, 'index') <- as.numeric(as.POSIXct(value))
}
} else
if(is.numeric(value)) {
attr(value, 'tclass') <- tclass(x)
attr(value, 'tzone') <- tzone(x)
attr(x, 'index') <- value
} else stop(".index is used for low level operations - data must be numeric or timeBased")
return(x)
}
#' @rdname index.xts
`.indexsec` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$sec
}
#' @rdname index.xts
`.indexmin` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$min
}
#' @rdname index.xts
`.indexhour` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$hour
}
#' @rdname index.xts
`.indexmday` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$mday
}
#' @rdname index.xts
`.indexmon` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$mon
}
#' @rdname index.xts
`.indexyear` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$year
}
#' @rdname index.xts
`.indexwday` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$wday
}
#' @rdname index.xts
`.indexbday` <- function(x) {
# is business day T/F
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$wday %% 6 > 0
}
#' @rdname index.xts
`.indexyday` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$yday
}
#' @rdname index.xts
`.indexisdst` <- function(x) {
as.POSIXlt(.POSIXct(.index(x), tz=tzone(x)))$isdst }
#' @rdname index.xts
`.indexDate` <- function(x) {
.index(x) %/% 86400L
}
#' @rdname index.xts
`.indexday` <- .indexDate
#' @rdname index.xts
`.indexweek` <- function(x) {
(.index(x) + (3 * 86400)) %/% 86400 %/% 7
}
#' @rdname index.xts
`.indexyweek` <- function(x) {
((.index(x) + (3 * 86400)) %/% 86400 %/% 7) -
((startOfYear() * 86400 + (3 * 86400)) %/% 86400 %/% 7)[.indexyear(x) + 1]
}
#' @rdname index.xts
`convertIndex` <-
function(x,value) {
tclass(x) <- value
x
}
.update_index_attributes <- function(x) {
suppressWarnings({
tclass(x) <- tclass(x)
tzone(x) <- tzone(x)
})
return(x)
}
xts/R/toperiod.R 0000644 0001762 0000144 00000030432 14654242576 013262 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Convert time series data to an OHLC series
#'
#' Convert an OHLC or univariate object to a specified periodicity lower than
#' the given data object. For example, convert a daily series to a monthly
#' series, or a monthly series to a yearly one, or a one minute series to an
#' hourly series.
#'
#' The result will contain the open and close for the given period, as well as
#' the maximum and minimum over the new period, reflected in the new high and
#' low, respectively. Aggregate volume will also be calculated if applicable.
#'
#' An easy and reliable way to convert one periodicity of data into any new
#' periodicity. It is important to note that all dates will be aligned to the
#' *end* of each period by default - with the exception of `to.monthly()` and
#' `to.quarterly()`, which use the \pkg{zoo} package's [yearmon][zoo::zoo] and
#' [yearqtr][zoo::zoo] classes, respectively.
#'
#' Valid period character strings include: `"seconds"`, `"minutes"`, `"hours"`,
#' `"days"`, `"weeks"`, `"months"`, `"quarters"`, and `"years"`. These are
#' calculated internally via [`endpoints()`]. See that function's help page for
#' further details.
#'
#' To adjust the final indexing style, it is possible to set `indexAt` to one
#' of the following: \sQuote{yearmon}, \sQuote{yearqtr}, \sQuote{firstof},
#' \sQuote{lastof}, \sQuote{startof}, or \sQuote{endof}. The final index will
#' then be `yearmon`, `yearqtr`, the first time of the period, the last time
#' of the period, the starting time in the data for that period, or the ending
#' time in the data for that period, respectively.
#'
#' It is also possible to pass a single time series, such as a univariate
#' exchange rate, and return an OHLC object of lower frequency - e.g. the
#' weekly OHLC of the daily series.
#'
#' Setting `drop.time = TRUE` (the default) will convert a series that includes
#' a time component into one with just a date index, since the time component
#' is often of little value in lower frequency series.
#'
#' @param x A univariate or OHLC type time-series object.
#' @param period Period to convert to. See details.
#' @param indexAt Convert final index to new class or date. See details.
#' @param drop.time Remove time component of POSIX datestamp (if any)?
#' @param k Number of sub periods to aggregate on (only for minutes and
#' seconds).
#' @param name Override column names?
#' @param OHLC Should an OHLC object be returned? (only `OHLC = TRUE`
#' currently supported)
#' @param \dots Additional arguments.
#'
#' @return An object of the original type, with new periodicity.
#'
#' @note In order for this function to work properly on OHLC data, it is
#' necessary that the Open, High, Low and Close columns be names as such;
#' including the first letter capitalized and the full spelling found.
#' Internally a call is made to reorder the data into the correct column order,
#' and then a verification step to make sure that this ordering and naming has
#' succeeded. All other data formats must be aggregated with functions such as
#' `aggregate()` and `period.apply()`.
#'
#' This method should work on almost all time-series-like objects. Including
#' \sQuote{timeSeries}, \sQuote{zoo}, \sQuote{ts}, and \sQuote{irts}. It is
#' even likely to work well for other data structures - including
#' \sQuote{data.frames} and \sQuote{matrix} objects.
#'
#' Internally a call to `as.xts()` converts the original `x` into the
#' universal xts format, and then re-converts back to the original type.
#'
#' A special note with respect to \sQuote{ts} objects. As these are strictly
#' regular they may include `NA` values. These are removed before aggregation,
#' though replaced before returning the result. This inevitably leads to many
#' additional `NA` values in the result. Consider using an xts object or
#' converting to xts using `as.xts()`.
#'
#' @author Jeffrey A. Ryan
#'
#' @keywords utilities
#' @aliases to_period
#' @examples
#'
#' data(sample_matrix)
#'
#' samplexts <- as.xts(sample_matrix)
#'
#' to.monthly(samplexts)
#' to.monthly(sample_matrix)
#'
#' str(to.monthly(samplexts))
#' str(to.monthly(sample_matrix))
#'
to.period <- to_period <- function(x, period='months', k=1, indexAt=NULL, name=NULL, OHLC=TRUE, ...) {
if(missing(name)) name <- deparse(substitute(x))
xo <- x
x <- try.xts(x)
if(NROW(x)==0 || NCOL(x)==0)
stop(sQuote("x")," contains no data")
if(any(is.na(x))) {
x <- na.omit(x)
warning("missing values removed from data")
}
if(is.character(period)) {
ep <- endpoints(x, period, k)
} else {
if(!is.numeric(period)) {
stop("'period' must be a character or a vector of endpoint locations")
}
if(!missing("k")) {
warning("'k' is ignored when using custom 'period' locations")
}
if(!is.null(indexAt)) {
warning("'indexAt' is ignored when using custom 'period' locations")
indexAt <- NULL
}
ep <- as.integer(period)
# ensure 'ep' starts with 0 and ends with nrow(x)
if(ep[1] != 0) {
ep <- c(0L, ep)
}
if (ep[length(ep)] != NROW(x)) {
ep <- c(ep, NROW(x))
}
}
if(!OHLC) {
xx <- x[ep, ]
} else {
if(!is.null(indexAt)) {
index_at <- switch(indexAt,
"startof" = TRUE, # start time of period
"endof" = FALSE, # end time of period
FALSE
)
} else index_at <- FALSE
# make suitable name vector
cnames <- c("Open", "High", "Low", "Close")
if (has.Vo(x))
cnames <- c(cnames, "Volume")
if (has.Ad(x) && is.OHLC(x))
cnames <- c(cnames, "Adjusted")
cnames <- paste(name,cnames,sep=".")
if(is.null(name))
cnames <- NULL
xx <- .Call(C_toPeriod,
x,
ep,
has.Vo(x), has.Vo(x,which=TRUE),
has.Ad(x) && is.OHLC(x),
index_at,
cnames)
}
if(!is.null(indexAt)) {
if(indexAt=="yearmon" || indexAt=="yearqtr")
tclass(xx) <- indexAt
if(indexAt=="firstof") {
ix <- as.POSIXlt(c(.index(xx)), tz=tzone(xx))
if(period %in% c("years","months","quarters","days"))
index(xx) <- firstof(ix$year + 1900, ix$mon + 1)
else
index(xx) <- firstof(ix$year + 1900, ix$mon + 1, ix$mday,
ix$hour, ix$min, ix$sec)
}
if(indexAt=="lastof") {
ix <- as.POSIXlt(c(.index(xx)), tz=tzone(xx))
if(period %in% c("years","months","quarters","days"))
index(xx) <- as.Date(lastof(ix$year + 1900, ix$mon + 1))
else
index(xx) <- lastof(ix$year + 1900, ix$mon + 1, ix$mday,
ix$hour, ix$min, ix$sec)
}
}
reclass(xx,xo)
}
#' @rdname to.period
`to.minutes` <-
function(x,k,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
if(missing(k)) k <- 1
to.period(x,'minutes',k=k,name=name,...)
}
#' @rdname to.period
`to.minutes3` <-
function(x,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
to.period(x,'minutes',k=3,name=name,...)
}
#' @rdname to.period
`to.minutes5` <-
function(x,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
to.period(x,'minutes',k=5,name=name,...)
}
#' @rdname to.period
`to.minutes10` <-
function(x,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
to.period(x,'minutes',k=10,name=name,...)
}
#' @rdname to.period
`to.minutes15` <-
function(x,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
to.period(x,'minutes',k=15,name=name,...)
}
#' @rdname to.period
`to.minutes30` <-
function(x,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
to.period(x,'minutes',k=30,name=name,...)
}
#' @rdname to.period
`to.hourly` <-
function(x,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
to.period(x,'hours',name=name,...)
}
#' @rdname to.period
`to.daily` <-
function(x,drop.time=TRUE,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
x <- to.period(x,'days',name=name,...)
if(drop.time) x <- .drop.time(x)
return(x)
}
#' @rdname to.period
`to.weekly` <-
function(x,drop.time=TRUE,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
x <- to.period(x,'weeks',name=name,...)
if(drop.time) x <- .drop.time(x)
return(x)
}
#' @rdname to.period
`to.monthly` <-
function(x,indexAt='yearmon',drop.time=TRUE,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
x <- to.period(x,'months',indexAt=indexAt,name=name,...)
if(drop.time) x <- .drop.time(x)
return(x)
}
#' @rdname to.period
`to.quarterly` <-
function(x,indexAt='yearqtr',drop.time=TRUE,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
x <- to.period(x,'quarters',indexAt=indexAt,name=name,...)
if(drop.time) x <- .drop.time(x)
return(x)
}
#' @rdname to.period
`to.yearly` <-
function(x,drop.time=TRUE,name,...)
{
if(missing(name)) name <- deparse(substitute(x))
x <- to.period(x,'years',name=name,...)
if(drop.time) x <- .drop.time(x)
return(x)
}
`.drop.time` <-
function(x) {
# function to remove HHMMSS portion of time index
xts.in <- is.xts(x) # is the input xts?
if(!xts.in) # if not, try to convert to xts
x <- try.xts(x, error=FALSE)
if(is.xts(x)) {
# if x is xts, drop HHMMSS from index
if(any(tclass(x)=='POSIXt')) {
# convert index to Date
index(x) <- as.Date(as.POSIXlt(index(x)))
tclass(x) <- "Date" # set tclass to Date
}
if(isClassWithoutTZ(tclass(x))) {
tzone(x) <- "UTC" # set tzone to UTC
}
# force conversion, even if we didn't set tclass to Date
# because indexAt yearmon/yearqtr won't drop time from index
index(x) <- index(x)
if(xts.in) x # if input already was xts
else reclass(x) # if input wasn't xts, but could be converted
} else x # if input wasn't xts, and couldn't be converted
}
`by.period` <-
function(x, FUN, on=Cl, period="days", k=1, fill=na.locf, ...) {
# aggregate 'x' to a higher periodicity, apply 'FUN' to the 'on' columns
# of the aggregate, then merge the aggregate results with 'x' and fill NAs
# with na.locf. E.g. you can apply a 5-day SMA of volume to tick data.
x <- try.xts(x, error = FALSE)
FUN <- match.fun(FUN)
on <- match.fun(on) # Allow function or name
agg <- to.period(x, period, k, ...)
res <- FUN(on(agg), ...)
full <- merge(.xts(NULL,index(x)),res)
full <- fill(full) # Allow function or value
return(full)
}
`to.frequency` <-
function(x, by, k=1, name=NULL, OHLC=TRUE, ...) {
# similar to to.period, but aggregates on something other than time.
# E.g. aggregate by volume, where a "period" is 10% of the 5-day volume SMA.
# Most code pulled from to.period
if(missing(name)) name <- deparse(substitute(x))
xo <- x
x <- try.xts(x)
if(any(is.na(x))) {
x <- na.omit(x)
warning("missing values removed from data")
}
# make suitable name vector
cnames <- c("Open", "High", "Low", "Close")
if (has.Vo(x))
cnames <- c(cnames, "Volume")
if (has.Ad(x) && is.OHLC(x))
cnames <- c(cnames, "Adjusted")
cnames <- paste(name,cnames,sep=".")
if(is.null(name))
cnames <- NULL
# start to.frequency-specific code
if (missing(by)) by <- rep(1L, nrow(x))
byVec <- cumsum(by)
bins <- byVec %/% k
# ep contents must have the same format as output generated by endpoints():
# first element must be zero and last must be nrow(x)
ep <- c(0L, which(diff(bins) != 0))
if (ep[length(ep)] != nrow(bins)) ep <- c(ep, nrow(bins))
# end to.frequency-specific code
xx <- .Call(C_toPeriod,
x,
ep,
has.Vo(x), has.Vo(x,which=TRUE),
has.Ad(x) && is.OHLC(x),
FALSE,
cnames)
reclass(xx,xo)
}
xts/R/timeDate.R 0000644 0001762 0000144 00000001564 14654242576 013175 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname as.xts
as.xts.timeDate <- function(x, ...)
{
xts(x=NULL, order.by=x)
}
xts/R/str.R 0000644 0001762 0000144 00000006257 14671414605 012246 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
`str.xts` <-
function(object, ..., ncols = 5)
{
is.data.empty <- is.null(dim(object)) || sum(dim(object)) == 0
is.zero.index <- (length(.index(object)) == 0)
nr <- NROW(object)
nc <- ifelse(is.data.empty, 0, NCOL(object))
# "zero-length" xts
# * index length == 0, but tclass and tzone are set
# * NROW == 0
# * NCOL > 0 and may have column names
# examples:
# str(.xts(1, 1)["1900"])
# str(.xts(cbind(a = 1, b = 2), 1)["1900"])
is.zero.length <- (is.zero.index && nr == 0 && !is.data.empty)
# "zero-width" xts
# * index length > 0
# * NROW == 0
# * NCOL == 0
# example:
# str(.xts(, 1:5))
is.zero.width <- (!is.zero.index && is.data.empty)
# "empty" xts
# * index length == 0, but tclass and tzone are set
# * NROW == 0
# * NCOL == 0
# example:
# str(.xts(, numeric(0)))
# str(.xts(matrix()[0,0], numeric(0)))
is.empty <- (is.zero.index && is.data.empty)
if (is.empty) {
header <- "An empty xts object"
} else if (is.zero.length) {
header <- "A zero-length xts object"
} else {
# zero-width and regular xts objects
if (is.zero.width) {
header <- "A zero-width xts object on"
} else {
header <- "An xts object on"
}
time.range <- sub("/", " / ", .makeISO8601(object), fixed = TRUE)
header <- paste(header, time.range, "containing:")
}
cat(header, "\n")
# Data
cat(sprintf(" Data: %s [%d, %d]\n",
storage.mode(object), nr, nc))
# Column names
cnames <- colnames(object)
if (!is.null(cnames)) {
if (nc > ncols) {
more <- nc - ncols
cname.str <- sprintf("%s ... with %d more %s",
paste(cnames[seq_len(ncols)], collapse = ", "),
more,
ifelse(more > 1, "columns", "column"))
} else {
cname.str <- paste(colnames(object), collapse = ", ")
}
cat(sprintf(" Columns: %s\n", cname.str))
}
# Index
cat(sprintf(" Index: %s [%d] (TZ: \"%s\")\n",
paste(tclass(object), collapse = ","),
length(.index(object)),
tzone(object)))
if (!is.null(CLASS(object))) {
cat(sprintf(" Original class: '%s'\n", CLASS(object)))
}
xts.attr <- xtsAttributes(object)
if (!is.null(xts.attr)) {
cat(" xts Attributes:\n")
str(xts.attr, ..., comp.str = " $ ", no.list = TRUE)
}
invisible(NULL)
}
xts/R/start.R 0000644 0001762 0000144 00000001713 14654242576 012572 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
`start.xts` <-
function(x, ...) {
index(x[1,])
}
`end.xts` <-
function(x, ...) {
if(length(x)==0) {
index(x[length(.index(x)),])
} else
index(x[NROW(x),])
}
xts/R/origin.fix.R 0000644 0001762 0000144 00000003604 14654242576 013512 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# fixes for R new/broken as.Date, as.POSIXlt and as.POSIXct
# hopefully to be removed when remedied in R
# taken directly from 'base', with origin set to '1970-01-01' (1970-01-01)
`as.Date.numeric` <- function(x, origin='1970-01-01', ...) {
as.Date(origin,...) + x
}
`as.POSIXct.numeric` <- function(x, tz="", origin='1970-01-01', ...) {
structure(x, class=c("POSIXct", "POSIXt"))
}
`as.POSIXlt.numeric` <- function(x, tz="", origin='1970-01-01', ...) {
as.POSIXlt(as.POSIXct(origin,tz="UTC",...) + x, tz=tz)
}
as.POSIXct.Date <- function(x, ...)
{
as.POSIXct(as.character(x))
}
as.Date.POSIXct <- function(x, ...)
{
as.Date(strftime(x))
}
as.POSIXlt.Date <- function(x, ...)
{
as.POSIXlt(as.POSIXct.Date(x))
}
as.POSIXct.dates <- function(x, ...)
{
# need to implement our own method to correctly handle TZ
structure(as.POSIXct(as.POSIXlt(x, tz="GMT"), tz="GMT"),class=c("POSIXct","POSIXt"))
}
as.chron.POSIXct <- function(x, ...)
{
if(!requireNamespace('chron', quietly=TRUE))
as.chron <- function(...) message("package 'chron' required")
structure(as.chron(as.POSIXlt(as.character(x))))
}
xts/R/list.R 0000644 0001762 0000144 00000002132 14654242576 012404 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
as.list.xts <- function(x, ...)
{
if( NCOL(x) == 1 )
return(structure(list(x),.Names=colnames(x)))
cindex <- cnames <- colnames(x)
if(is.null(cnames)) {
cindex <- 1:NCOL(x)
cnames <- paste("x",cindex,sep=".")
}
names(cindex) <- cnames
lapply(cindex,
function(f) x[,f], ...)
}
xts/R/dimnames.R 0000644 0001762 0000144 00000004120 14654242576 013225 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# dimnames will return the actual dimnames of the xts object
# dimnames<-.xts will force the rownames to always be NULL
#' Dimnames of an xts Object
#'
#' Get or set dimnames of an xts object.
#'
#' For efficienty, xts objects do not have rownames (unlike zoo objects).
#' Attempts to set rownames on an xts object will silently set them to `NULL`.
#' This is done for internal compatibility reasons, as well as to provide
#' consistency in performance regardless of object use.
#'
#' @param x An xts object.
#' @param value A two element list. See Details.
#'
#' @return A list or character string containing coerced row names and/or
#' actual column names.
#'
#' Attempts to set rownames on xts objects via rownames or dimnames will
#' silently fail.
#'
#' @note Unlike zoo, all xts objects have dimensions. xts objects cannot be
#' plain vectors.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`xts()`]
#'
#' @keywords misc
#' @examples
#'
#' x <- xts(1:10, Sys.Date()+1:10)
#' dimnames(x)
#' rownames(x)
#' rownames(x) <- 1:10
#' rownames(x)
#' str(x)
#'
`dimnames.xts` <-
function(x) {
#list(NULL, colnames(unclass(x)))
.Call(C_dimnames_zoo,x);
#list(as.character(index(x)), colnames(unclass(x)))
}
#' @rdname dimnames.xts
`dimnames<-.xts` <-
function(x, value) {
.Call(C_xts_set_dimnames, x, value)
}
xts/R/irts.R 0000644 0001762 0000144 00000003017 14654242576 012415 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# methods for tseries::irts
`re.irts` <-
function(x,...) {
if(!requireNamespace('tseries', quietly=TRUE)) {
irts <- function(...) message("package 'tseries' is required for re.irts")
} else {
irts <- tseries::irts
}
tclass(x) <- "POSIXct"
xx <- coredata(x)
# rownames(xx) <- attr(x,'irts.rownames')
irts(index(x),xx)
}
#' @rdname as.xts
`as.xts.irts` <-
function(x,order.by,frequency=NULL,...,.RECLASS=FALSE) {
if(.RECLASS) {
xx <- xts(x=x$value,
order.by=x$time,
frequency=frequency,
.CLASS='irts',
# irts.rownames=rownames(x$value),
...)
} else {
xx <- xts(x=x$value,
order.by=x$time,
frequency=frequency,
...)
}
xx
}
xts/R/nperiods.R 0000644 0001762 0000144 00000004454 14654242576 013265 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname ndays
`nseconds` <-
function(x) {
length(endpoints(x,on='seconds'))-1
}
#' @rdname ndays
`nminutes` <-
function(x) {
length(endpoints(x,on='minutes'))-1
}
#' @rdname ndays
`nhours` <-
function(x) {
length(endpoints(x,on='hours'))-1
}
#' Number of Periods in Data
#'
#' Calculate the number of specified periods in a given time series like data
#' object.
#'
#' Essentially a wrapper to `endpoints()` with the appropriate period
#' specified. The result is the number of endpoints found.
#'
#' As a compromise between simplicity and accuracy, the results will always
#' round up to the nearest complete period. Subtract 1 from the result to
#' get the completed periods.
#'
#' For finer grain detail one should call the higher frequency functions.
#'
#' An alternative summary can be found with `periodicity(x)` and
#' `unclass(periodicity(x))`.
#'
#' @param x A time-based object.
#'
#' @return The number of respective periods in `x`.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`endpoints()`]
#'
#' @keywords utilities
#' @examples
#'
#' \dontrun{
#' getSymbols("QQQQ")
#'
#' ndays(QQQQ)
#' nweeks(QQQQ)
#' }
#'
`ndays` <-
function(x) {
length(endpoints(x,on='days'))-1
}
#' @rdname ndays
`nweeks` <-
function(x) {
length(endpoints(x,on='weeks'))-1
}
#' @rdname ndays
`nmonths` <-
function(x) {
length(endpoints(x,on='months'))-1
}
#' @rdname ndays
`nquarters` <-
function(x) {
length(endpoints(x,on='quarters'))-1
}
#' @rdname ndays
`nyears` <-
function(x) {
length(endpoints(x,on='years'))-1
}
xts/R/matrix.R 0000644 0001762 0000144 00000004745 14654242576 012751 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# functions for matrix <--> xts conversions
`as.matrix.xts` <-
function(x, ...) {
# This function follows the pattern of as.matrix.zoo()
cd <- coredata(x)
y <- as.matrix(cd, ...)
if (length(cd) == 0) {
dim(y) <- c(0, 0)
}
# colnames
if (length(y) > 0) {
cnx <- colnames(x)
if (length(cnx) > 0) {
colnames(y) <- cnx
} else {
cn <- deparse(substitute(x), width.cutoff = 100, nlines = 1)
if (NCOL(x) == 1) {
colnames(y) <- cn
} else {
colnames(y) <- paste(cn, 1:ncol(x), sep = ".")
}
}
} else if (nrow(y) != length(.index(x))) {
dim(y) <- c(length(.index(x)), 0)
}
# rownames
if (!is.null(y) && nrow(y) > 0 && is.null(rownames(y))) {
rownames(y) <- as.character(index(x))
}
y
}
`re.matrix` <-
function(x,...) {
as.matrix(x,...)
}
#' @rdname as.xts
`as.xts.matrix` <-
function(x,order.by,dateFormat="POSIXct",frequency=NULL,...,.RECLASS=FALSE) {
# Should allow 'order.by' to be a vector of dates or a scaler
# representing the column number to use.
if(missing(order.by)) {
# The 'index' of zoo objects is set to 'rownames' when converted with 'as.matrix',
# but it is of class 'Date', not 'POSIXct'... - jmu
if(is.null(rownames(x)))
stop("order.by must be either 'rownames()' or otherwise specified")
else
# added '...' args to allow for tz specification
order.by <- do.call(paste('as',dateFormat,sep='.'),list(rownames(x)))
}
if(.RECLASS) {
xx <- xts(x,
order.by=order.by,
frequency=frequency,
.CLASS='matrix',
...)
} else {
xx <- xts(x,
order.by=order.by,
frequency=frequency,
...)
}
xx
}
xts/R/last.R 0000644 0001762 0000144 00000011710 14654242576 012376 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname first
`last` <-
function(x,...)
{
UseMethod("last")
}
#' @rdname first
`last.default` <-
function(x,n=1,keep=FALSE,...)
{
if(length(x) == 0)
return(x)
if(is.character(n)) {
xx <- try.xts(x, error=FALSE)
if(is.xts(xx)) {
xx <- last.xts(x, n=n, keep=keep, ...)
return(reclass(xx))
}
}
if(is.null(dim(x))) {
if(n > 0) {
sub <- seq.int(to = length(x), length.out = min(n, length(x)))
xx <- x[sub]
if(keep) xx <- structure(xx,keep=x[1:(NROW(x)+(-n))])
xx
} else if(n < 0) {
sub <- seq_len(max(length(x) + n, 0L))
xx <- x[sub]
if(keep) xx <- structure(xx,keep=x[((NROW(x)-(-n)+1):NROW(x))])
xx
} else {
xx <- x[0]
if(keep) xx <- structure(xx,keep=x[0])
xx
}
} else {
if(n > 0) {
sub <- seq.int(to = NROW(x), length.out = min(n, NROW(x)))
xx <- x[sub,,drop=FALSE]
if(keep) xx <- structure(xx,keep=x[1:(NROW(x)+(-n)),])
xx
} else if(n < 0) {
sub <- seq_len(max(NROW(x) + n, 0L))
xx <- x[sub,,drop=FALSE]
if(keep) xx <- structure(xx,keep=x[((NROW(x)-(-n)+1):NROW(x)),])
xx
} else {
xx <- x[0,,drop=FALSE]
if(keep) xx <- structure(xx,keep=x[0,])
xx
}
}
}
#' @rdname first
`last.xts` <-
function(x,n=1,keep=FALSE,...)
{
if(length(x) == 0)
return(x)
if(is.character(n)) {
# n period set
np <- strsplit(n," ",fixed=TRUE)[[1]]
if(length(np) > 2 || length(np) < 1)
stop(paste("incorrectly specified",sQuote("n"),sep=" "))
# series periodicity
sp <- periodicity(x)
sp.units <- sp[["units"]]
# requested periodicity$units
rpu <- np[length(np)]
rpf <- ifelse(length(np) > 1, as.numeric(np[1]), 1)
if(rpu == sp.units) {
n <- rpf
} else {
# if singular - add an s to make it work
if(substr(rpu,length(strsplit(rpu,'')[[1]]),length(strsplit(rpu,'')[[1]])) != 's')
rpu <- paste(rpu,'s',sep='')
u.list <- list(secs=4,seconds=4,mins=3,minutes=3,hours=2,days=1,
weeks=1,months=1,quarters=1,years=1)
dt.options <- c('seconds','secs','minutes','mins','hours','days',
'weeks','months','quarters','years')
if(!rpu %in% dt.options)
stop(paste("n must be numeric or use",paste(dt.options,collapse=',')))
dt <- dt.options[pmatch(rpu,dt.options)]
if(u.list[[dt]] > u.list[[sp.units]]) {
# req is for higher freq data period e.g. 100 mins of daily data
stop(paste("At present, without some sort of magic, it isn't possible",
"to resolve",rpu,"from",sp$scale,"data"))
}
ep <- endpoints(x,dt)
if(rpf > length(ep)-1) {
rpf <- length(ep)-1
warning("requested length is greater than original")
}
if(rpf > 0) {
n <- ep[length(ep)-rpf]+1
if(is.null(dim(x))) {
xx <- x[n:NROW(x)]
} else {
xx <- x[n:NROW(x),,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[1:(ep[length(ep)+(-rpf)])])
return(xx)
} else if(rpf < 0) {
n <- ep[length(ep)+rpf]
if(is.null(dim(x))) {
xx <- x[1:n]
} else {
xx <- x[1:n,,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[(ep[length(ep)-(-rpf)]+1):NROW(x)])
return(xx)
} else {
if(is.null(dim(x))) {
xx <- x[0]
} else {
xx <- x[0,,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[0])
return(xx)
}
}
}
if(length(n) != 1) stop("n must be of length 1")
if(n > 0) {
n <- min(n, NROW(x))
if(is.null(dim(x))) {
xx <- x[(NROW(x)-n+1):NROW(x)]
} else {
xx <- x[(NROW(x)-n+1):NROW(x),,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[1:(NROW(x)+(-n))])
xx
} else if(n < 0) {
if(abs(n) >= NROW(x))
return(x[0])
if(is.null(dim(x))) {
xx <- x[1:(NROW(x)+n)]
} else {
xx <- x[1:(NROW(x)+n),,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[((NROW(x)-(-n)+1):NROW(x))])
xx
} else {
if(is.null(dim(x))) {
xx <- x[0]
} else {
xx <- x[0,,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[0])
xx
}
}
xts/R/zoo.R 0000644 0001762 0000144 00000003314 14654242576 012243 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# functions to handle zoo <--> xts conversions
`re.zoo` <-
function(x,...) {
xx <- coredata(x)
xx <- zoo(xx,
order.by=index(x),
...)
if(length(dimnames(x)[[2]]) < 2) {
dimnames(xx) <- NULL
dim(xx) <- NULL
attr(xx,'names') <- as.character(index(x))
}
xx
}
#' @rdname as.xts
`as.xts.zoo` <-
function(x,order.by=index(x),frequency=NULL,...,.RECLASS=FALSE) {
if(.RECLASS) {
xx <- xts(coredata(x), # Cannot use 'zoo()' on objects of class 'zoo' - jmu
order.by=order.by,
frequency=frequency,
.CLASS='zoo',
...)
} else {
xx <- xts(coredata(x), # Cannot use 'zoo()' on objects of class 'zoo' - jmu
order.by=order.by,
frequency=frequency,
...)
}
xx
}
`as.zoo.xts` <-
function(x,...) {
cd <- coredata(x);
if( length(cd)==0 )
cd <- NULL
zoo(cd,
order.by=index(x),
...)
}
xts/R/timeBasedRange.R 0000644 0001762 0000144 00000002165 14654242576 014311 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname timeBasedSeq
`timeBasedRange` <-
function(x, ...) {
# convert unquoted time range to
if (!is.character(x))
x <- deparse(match.call()$x)
# determine start and end points
tblist <- timeBasedSeq(x,NULL)
# if(!is.null(tblist$length.out))
# return(tblist$from)
c(as.numeric(tblist$from), as.numeric(tblist$to))
}
xts/R/coredata.xts.R 0000644 0001762 0000144 00000015175 14654242576 014043 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Extract/Replace Core Data of an xts Object
#'
#' Mechanism to extract and replace the core data of an xts object.
#'
#' Extract coredata of an xts object - removing all attributes except
#' `dim` and `dimnames` and returning a matrix object with rownames
#' converted from the index of the xts object.
#'
#' The rownames of the result use the format specified by `tformat(x)` when
#' `fmt = TRUE`. When `fmt` is a character string to be passed to `format()`.
#' See [`strptime()`] for valid format strings. Setting `fmt = FALSE` will
#' return the row names by simply coercing the index class to a character
#' string in the default manner.
#'
#' `xcoredata()` is the complement to `coredata()`. It returns all of the
#' attributes normally removed by `coredata()`. Its purpose, along with the
#' the replacement function `xcoredata<-` is primarily for developers using
#' \pkg{xts}' [`try.xts()`] and [`reclass()`] functionality inside functions
#' so the functions can take any time series class as an input and return the
#' same time series class.
#'
#' @param x An xts object.
#' @param fmt Should the rownames be formated using `tformat()`? Alternatively
#' a date/time string to be passed to `format()`. See details.
#' @param value Non-core attributes to assign.
#' @param \dots Unused.
#'
#' @return Returns either a matrix object for coredata, or a list of named
#' attributes.
#'
#' The replacement functions are called for their side-effects.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`coredata()`][zoo::zoo], [`xtsAttributes()`]
#'
#' @keywords utilities
#' @examples
#'
#' data(sample_matrix)
#' x <- as.xts(sample_matrix, myattr=100)
#' coredata(x)
#' xcoredata(x)
#'
coredata.xts <- function(x, fmt=FALSE, ...) {
x.attr <- attributes(x)
if(is.character(fmt)) {
tformat(x) <- fmt
fmt <- TRUE
}
if(length(x) > 0 && fmt) {
if(!is.null(tformat(x))) {
x.attr$dimnames <- list(format(index(x), format=tformat(x)),
dimnames(x)[[2]])
tformat(x) <- NULL # remove before printing
} else {
x.attr$dimnames <- list(format(index(x)),dimnames(x)[[2]])
}
#attributes not to be kept
original.attr <- x.attr[!names(x.attr) %in%
c('dim','dimnames')]
if(is.null(dim(x))) {
xx <- structure(coredata(x), names=x.attr$dimnames[[1]])
} else {
xx <- structure(coredata(x), dim=dim(x), dimnames=x.attr$dimnames)
}
for(i in names(original.attr)) {
attr(xx,i) <- NULL
}
return(xx)
}
if(length(x) == 0) {
xx <- NextMethod(x)
attr(xx, ".indexCLASS") <- NULL
attr(xx, "tclass") <- NULL
# Remove tz attrs (object created before 0.10-3)
attr(xx, ".indexTZ") <- NULL
attr(xx, "tzone") <- NULL
return(xx)
} else
return(.Call(C_coredata_xts, x))
}
`xcoredata.default` <-
function(x,...) {
x.attr <- attributes(x)
original.attr <- x.attr[!names(x.attr) %in%
c('dim','dimnames')]
original.attr
}
#' @rdname coredata.xts
`xcoredata` <-
function(x,...) {
UseMethod('xcoredata')
}
#' @rdname coredata.xts
`xcoredata<-` <- function(x,value) {
UseMethod('xcoredata<-')
}
`xcoredata<-.default` <- function(x,value) {
if(is.null(value)) {
return(coredata(x))
} else {
for(att in names(value)) {
if(!att %in% c('dim','dimnames'))
attr(x,att) <- value[[att]]
}
return(x)
}
}
#' Extract and Replace xts Attributes
#'
#' Extract and replace non-core xts attributes.
#'
#' This function allows users to assign custom attributes to the xts objects,
#' without altering core xts attributes (i.e. tclass, tzone, and tformat).
#'
#' [`attributes()`] returns all attributes, including core attributes of the
#' xts class.
#'
#' @param x An xts object.
#' @param user Should user-defined attributes be returned? The default of
#' `NULL` returns all xts attributes.
#' @param value A list of new `name = value` attributes.
#'
#' @return A named list of user-defined attributes.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`attributes()`]
#'
#' @keywords utilities
#' @examples
#'
#' x <- xts(matrix(1:(9*6),nc=6),
#' order.by=as.Date(13000,origin="1970-01-01")+1:9,
#' a1='my attribute')
#'
#' xtsAttributes(x)
#' xtsAttributes(x) <- list(a2=2020)
#'
#' xtsAttributes(x)
#' xtsAttributes(x) <- list(a1=NULL)
#' xtsAttributes(x)
#'
`xtsAttributes` <-
function(x, user=NULL) {
# get all additional attributes not standard to xts object
#stopifnot(is.xts(x))
rm.attr <- c('dim','dimnames','index','class','names')
x.attr <- attributes(x)
if(is.null(user)) {
# Both xts and user attributes
rm.attr <- c(rm.attr,'.CLASS','.CLASSnames','.ROWNAMES', '.indexCLASS', '.indexFORMAT', '.indexTZ', 'tzone', 'tclass')
xa <- x.attr[!names(x.attr) %in% rm.attr]
}
else
if(user) {
# Only user attributes
rm.attr <- c(rm.attr,'.CLASS','.CLASSnames','.ROWNAMES', '.indexCLASS', '.indexFORMAT','.indexTZ','tzone','tclass',
x.attr$.CLASSnames)
xa <- x.attr[!names(x.attr) %in% rm.attr]
} else {
# Only xts attributes
xa <- x.attr[names(x.attr) %in% x.attr$.CLASSnames]
}
if(length(xa) == 0) return(NULL)
xa
}
#' @rdname xtsAttributes
`xtsAttributes<-` <-
function(x,value) {
UseMethod('xtsAttributes<-')
}
`xtsAttributes<-.xts` <-
function(x,value) {
if(is.null(value)) {
for(nm in names(xtsAttributes(x))) {
attr(x,nm) <- NULL
}
} else
for(nv in names(value)) {
if(!nv %in% c('dim','dimnames','index','class','.CLASS','.ROWNAMES','.CLASSnames'))
attr(x,nv) <- value[[nv]]
}
# Remove tz attrs (object created before 0.10-3)
attr(x, ".indexTZ") <- NULL
attr(x, "tzone") <- NULL
# Remove index class attrs (object created before 0.10-3)
attr(x, ".indexCLASS") <- NULL
attr(x, "tclass") <- NULL
# Remove index format attr (object created before 0.10-3)
attr(x, ".indexFORMAT") <- NULL
x
}
xts/R/parse8601.R 0000644 0001762 0000144 00000021312 14654242576 013063 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# This function corresponds to the ISO 8601 standard
# for specifying dates and times as described in
# the ISO 8601:2004e standard.
#
# See:
# http://en.wikipedia.org/wiki/ISO_8601
# http://www.iso.org/iso/support/faqs/faqs_widely_used_standards/widely_used_standards_other/date_and_time_format.htm
#
# This implementation is currently restricted
# to interval based parsing, with basic or
# extended formats, and duration strings.
# Currently the duration must be in basic format
# e.g. PnnYnnMnnDTnnHnnMnnS
#
# The return value is a list of start and
# end times, in POSIXt space.
#
# Copyright 2009. Jeffrey A. Ryan. All rights reserved.
# This is licensed under the GPL version 2 or later
#
#' Create an ISO8601 string from a time series object
#'
#' This function uses the `start()` and `end()` of a time series object to
#' create an ISO8601 string that spans the time range of the object.
#'
#' This is not exported an therefore not part of the official xts API.
#'
#' @param x A time series object with `start()` and `end()` methods.
#'
#' @return A character vector of length one describing the ISO-style format
#' for the range of a given time series object.
#'
#' @noRd
#' @examples
#'
#' data(sample_matrix)
#' x <- as.xts(sample_matrix)
#' .makeISO8601(x)
#'
.makeISO8601 <- function(x) {
paste(start(x), end(x), sep = "/")
}
#' Internal ISO 8601:2004(e) Time Parser
#'
#' This function replicates most of the ISO standard for parsing times and
#' time-based ranges in a universally accepted way. The best documentation is
#' the official ISO page as well as the Wikipedia entry for ISO 8601:2004.
#'
#' The basic idea is to create the endpoints of a range, given a string
#' representation. These endpoints are aligned in POSIXct time to the zero
#' second of the day at the beginning, and the 59.9999th second of the 59th
#' minute of the 23rd hour of the final day.
#'
#' For dates prior to the epoch (1970-01-01) the ending time is aligned to the
#' 59.0000 second. This is due to a bug/feature in the \R implementation of
#' `as.POSIXct()` and `mktime0()` at the C-source level. This limits the
#' precision of ranges prior to 1970 to 1 minute granularity with the current
#' \pkg{xts} workaround.
#'
#' Recurring times over multiple days may be specified using the "T" notation.
#' See the examples for details.
#'
#' @param x A character string conforming to the ISO 8601:2004(e) rules.
#' @param start Lower constraint on range.
#' @param end Upper constraint of range
#' @param tz Timezone (tzone) to use internally.
#'
#' @return A two element list with an entry named \sQuote{first.time} and
#' one named \sQuote{last.time}.
#'
#' @note There is no checking done to test for a properly constructed ISO
#' format string. This must be correctly entered by the user.
#'
#' When using durations, it is important to note that the time of the duration
#' specified is not necessarily the same as the realized periods that may be
#' returned when applied to an irregular time series. This is not a bug, it is
#' a standards and implementation gotcha.
#'
#' @author Jeffrey A. Ryan
#'
#' @references \cr
#'
#'
#' @aliases ISO8601 parseISO8601
#' @rdname parseISO8601
#'
#' @keywords utilities
#' @examples
#'
#' # the start and end of 2000
#' .parseISO8601('2000')
#'
#' # the start of 2000 and end of 2001
#' .parseISO8601('2000/2001')
#'
#' # May 1, 2000 to Dec 31, 2001
#' .parseISO8601('2000-05/2001')
#'
#' # May 1, 2000 to end of Feb 2001
#' .parseISO8601('2000-05/2001-02')
#'
#' # Jan 1, 2000 to Feb 29, 2000; note the truncated time on the LHS
#' .parseISO8601('2000-01/02')
#'
#' # 8:30 to 15:00 (used in xts subsetting to extract recurring times)
#' .parseISO8601('T08:30/T15:00')
#'
.parseISO8601 <- function(x, start, end, tz="") {
# x: character vector of length 1 in ISO8601:2004(e) format
# start: optional earliest time
# end: optional latest time
# tz: optional tzone to create with
as_numeric <- function(.x) {
# simple helper function
if(gsub(" ","",.x)=="")
NULL
else as.numeric(.x)
}
x <- gsub("NOW",format(Sys.time(),"%Y%m%dT%H%M%S"),x)
x <- gsub("TODAY",format(Sys.Date(),"%Y%m%d"),x)
if(identical(grep("/|(--)|(::)", x), integer(0))) {
x <- paste(x,x,sep="/")
}
intervals <- unlist(strsplit(x, "/|(--)|(::)"))
# e.g. "/2009": "" "xxx" end of defined, needs context
# e.g. "2009/": "xxx" start of defined, needs context
# check for duration specification
DURATION <- ""
if(length(intervals)==2L) {
if(substr(intervals[1],0,1)=="P") {
# duration on LHS
DURATION <- intervals[1]
DURATION_LHS <- TRUE
intervals[1] <- ""
}
if(substr(intervals[2],0,1)=="P") {
# duration on RHS
DURATION <- intervals[2]
DURATION_LHS <- FALSE
intervals <- intervals[1]
}
# leave alone if no duration
}
parse.side <- function(x, startof) {
if( is.na(x) || !nzchar(x))
return(c(NULL))
basic <- gsub(":|-", "", x, perl=TRUE) #, extended=TRUE)
date.time <- unlist(strsplit(basic, " |T"))
# dates
date <- date.time[1]
if(!missing(startof) && nchar(basic)==2L) {
startof <- gsub(":|-", "", startof, perl=TRUE) #, extended=TRUE)
if(nchar(startof) - nchar(date) >= 4) {
# FIXME 200901/2009 needs to work, fix is ex-post now
# pad to last place of startof
# with startof values
sstartof <- substr(startof,0,nchar(startof)-nchar(date))
date <- paste(sstartof,date,sep="")
}
}
date <- sprintf("%-8s", date)
YYYY <- substr(date,0,4)
MM <- substr(date,5,6)
DD <- substr(date,7,8)
# times
time <- date.time[2]
if( !is.na(time)) {
time <- sprintf("%-6s", time)
H <- substr(time,0,2)
M <- substr(time,3,4)
S <- substr(time,5,10000L)
} else H<-M<-S<-""
# return as list
c(as.list(c(
year=as_numeric(YYYY),
month=as_numeric(MM),
day=as_numeric(DD),
hour=as_numeric(H),
min=as_numeric(M),
sec=as_numeric(S)
)
),tz=tz)
}
s <- e <- NA
if(nzchar(intervals[1])) # LHS
s <- as.POSIXlt(do.call(firstof, parse.side(intervals[1])))
if(length(intervals) == 2L) { # RHS
e <- as.POSIXlt(do.call(lastof, parse.side(intervals[2],intervals[1])))
if(is.na(e))
e <- as.POSIXlt(do.call(lastof, parse.side(intervals[2])))
}
if(is.na(s) && is.na(e) && !nzchar(DURATION) && intervals[1L] != "") {
warning("cannot determine first and last time from ", x)
return(list(first.time=NA_real_,last.time=NA_real_))
}
if(!missing(start)) {
start <- as.numeric(start)
#s <- as.POSIXlt(structure(max(start, as.numeric(s), na.rm=TRUE),
# class=c("POSIXct","POSIXt"),tz=tz))
s <- as.POSIXlt(.POSIXct(max(start, as.numeric(s), na.rm=TRUE),tz=tz))
}
if(!missing(end)) {
end <- as.numeric(end)
#e <- as.POSIXlt(structure(min(end, as.numeric(e), na.rm=TRUE),
# class=c("POSIXct","POSIXt"),tz=tz))
e <- as.POSIXlt(.POSIXct(min(end, as.numeric(e), na.rm=TRUE),tz=tz))
}
if(nzchar(DURATION)) {
parse_duration <- function(P) {
# TODO:
# strip leading P from string
# convert second M (min) to 'm' IFF following a T
# remove/ignore T
# convert extended format (PYYYYMMDD) to basic format (PnnYnnMnnD)
P <- gsub("P","",P)
P <- gsub("T(.*)M","\\1m",P)
n <- unlist(strsplit(P, "[[:alpha:]]"))
d <- unlist(strsplit(gsub("[[:digit:]]", "", P),""))
dur.vec <- list(as.numeric(n),unname(c(Y=6,M=5,D=4,H=3,m=2,S=1)[d]))
init.vec <- rep(0, 9)
init.vec[dur.vec[[2]]] <- dur.vec[[1]]
init.vec
}
if(DURATION_LHS) {
s <- as.POSIXct(structure(as.list(mapply(`-`,e,parse_duration(DURATION))),
class=c("POSIXlt","POSIXt"), tzone=attr(e,"tzone")))
} else {
e <- as.POSIXct(structure(as.list(mapply(`+`,s,parse_duration(DURATION))),
class=c("POSIXlt","POSIXt"), tzone=attr(e,"tzone")))
}
}
list(first.time=as.POSIXct(s),last.time=as.POSIXct(e))
}
xts/R/zzz.R 0000644 0001762 0000144 00000007536 14654242576 012303 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# internal package environment for use with lines.xts
# Do we still need this env?
.xtsEnv <- new.env()
# Environment for our xts chart objects (xts_chob)
.plotxtsEnv <- new.env()
register_s3_method <-
function(pkg, generic, class, fun = NULL)
{
stopifnot(is.character(pkg), length(pkg) == 1L)
stopifnot(is.character(generic), length(generic) == 1L)
stopifnot(is.character(class), length(class) == 1L)
if (is.null(fun)) {
fun <- get(paste0(generic, ".", class), envir = parent.frame())
} else {
stopifnot(is.function(fun))
}
if (isNamespaceLoaded(pkg)) {
registerS3method(generic, class, fun, envir = asNamespace(pkg))
}
# Always register hook in case package is later unloaded & reloaded
setHook(
packageEvent(pkg, "onLoad"),
function(...) {
registerS3method(generic, class, fun, envir = asNamespace(pkg))
}
)
}
.onAttach <- function(libname, pkgname)
{
warn_dplyr_lag <- getOption("xts.warn_dplyr_breaks_lag", TRUE)
dplyr_will_mask_lag <- conflictRules("dplyr")
if (is.null(dplyr_will_mask_lag)) {
dplyr_will_mask_lag <- TRUE
} else {
dplyr_will_mask_lag <- all(dplyr_will_mask_lag$exclude != "lag")
}
if (warn_dplyr_lag && dplyr_will_mask_lag) {
ugly_message <- "
######################### Warning from 'xts' package ##########################
# #
# The dplyr lag() function breaks how base R's lag() function is supposed to #
# work, which breaks lag(my_xts). Calls to lag(my_xts) that you type or #
# source() into this session won't work correctly. #
# #
# Use stats::lag() to make sure you're not using dplyr::lag(), or you can add #
# conflictRules('dplyr', exclude = 'lag') to your .Rprofile to stop #
# dplyr from breaking base R's lag() function. #
# #
# Code in packages is not affected. It's protected by R's namespace mechanism #
# Set `options(xts.warn_dplyr_breaks_lag = FALSE)` to suppress this warning. #
# #
###############################################################################"
if ("package:dplyr" %in% search()) {
packageStartupMessage(ugly_message)
} else {
setHook(packageEvent("dplyr", "attach"),
function(...) packageStartupMessage(ugly_message))
}
}
}
.onLoad <- function(libname, pkgname)
{
if (getRversion() < "3.6.0") {
register_s3_method("timeSeries", "as.timeSeries", "xts")
if (utils::packageVersion("zoo") < "1.8.5") {
# xts:::as.zoo.xts was copied to zoo:::as.zoo.xts in zoo 1.8-5
register_s3_method("zoo", "as.zoo", "xts")
}
}
invisible()
}
.onUnload <- function(libpath) {
library.dynam.unload("xts", libpath)
}
if(getRversion() < "2.11.0") {
.POSIXct <- function(xx, tz = NULL)
structure(xx, class = c("POSIXct", "POSIXt"), tzone = tz)
}
xts/R/xts-package.R 0000644 0001762 0000144 00000014305 14654242576 013645 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Sample Data Matrix For xts Example and Unit Testing
#'
#' Simulated 180 observations on 4 variables.
#'
#' @usage data(sample_matrix)
#'
#' @format \preformatted{The format is:
#' num [1:180, 1:4] 50.0 50.2 50.4 50.4 50.2 ...
#' - attr(*, "dimnames")=List of 2
#' ..$ : chr [1:180] "2007-01-02" "2007-01-03" "2007-01-04" "2007-01-05" ...
#' ..$ : chr [1:4] "Open" "High" "Low" "Close" }
#'
#' @rdname sample.data
#' @keywords datasets
#' @examples
#'
#' data(sample_matrix)
#'
"sample_matrix"
#' Internal Documentation
#'
#' This help file is to help in development of xts, as well as provide some
#' clarity and insight into its purpose and implementation.
#'
#' Last modified: 2008-08-06 by Jeffrey A. Ryan Version: 0.5-0 and above
#'
#' The \pkg{xts} package xts designed as a drop-in replacement for the very
#' popular \pkg{zoo} package. Most all functionality of zoo has been extended
#' or carries into the xts package.
#'
#' Notable changes in direction include the use of time-based indexing, at
#' first explicitely, now implicitely.
#'
#' An xts object consists of data in the form of a matrix, an index -
#' ordered and increasing, either numeric or integer, and additional attributes
#' for use internally, or for end-user purposes.
#'
#' The current implementation enforces two major rules on the object. One is
#' that the index must be coercible to numeric, by way of `as.POSIXct`.
#' There are defined types that meet this criteria. See `timeBased` for
#' details.
#'
#' The second requirement is that the object cannot have rownames. The
#' motivation from this comes in part from the work Matthew Doyle has done in
#' his data.table class, in the package of the same name. Rownames in must be
#' character vectors, and as such are inefficient in both storage and
#' conversion. By eliminating the rownames, and providing a numeric index of
#' internal type `REAL` or `INTEGER`, it is possible to maintain a
#' connection to standard date and time classes via the POSIXct functions,
#' while at at the same time maximizing efficiencies in data handling.
#'
#' User level functions `index`, as well as conversion to other classes
#' proceeds as if there were rownames. The code for `index` automatically
#' converts time to numeric in both extraction and replacement functionality.
#' This provides a level of abstraction to facilitate internal, and external
#' package use and inter-operability.
#'
#' There is also new work on providing a C-level API to some of the xts
#' functionality to facilitate external package developers to utilize the fast
#' utility routines such as subsetting and merges, without having to call only
#' from . Obviously this places far more burden on the developer to not only
#' understand the internal xts implementation, but also to understand all of
#' what is documented for R-internals (and much that isn't). At present the
#' functions and macros available can be found in the \sQuote{xts.h} file in
#' the src directory.
#'
#' There is no current documentation for this API. The adventure starts here.
#' Future documentation is planned, not implemented.
#'
#' @name xts-internals
#' @author Jeffrey A. Ryan
#' @keywords utilities
NULL
#' xts: extensible time-series
#'
#' Extensible time series class and methods, extending and behaving like zoo.
#'
#' Easily convert one of \R's many time-series (and non-time-series) classes to a
#' true time-based object which inherits all of zoo's methods, while allowing
#' for new time-based tools where appropriate.
#'
#' Additionally, one may use \pkg{xts} to create new objects which can contain
#' arbitrary attributes named during creation as name=value pairs.
#'
#' @name xts-package
#' @author Jeffrey A. Ryan and Joshua M. Ulrich
#'
#' Maintainer: Joshua M. Ulrich
#' @seealso [`xts()`], [`as.xts()`], [`reclass()`], [`zoo()`][zoo::zoo]
#' @keywords package
"_PACKAGE"
#' xts C API Documentation
#'
#' This help file is to help in development of xts, as well as provide some
#' clarity and insight into its purpose and implementation.
#'
#' By Jeffrey A. Ryan, Dirk Eddelbuettel, and Joshua M. Ulrich Last modified:
#' 2018-05-02 Version: 0.10-3 and above
#'
#' At present the \pkg{xts} API has publicly available interfaces to the
#' following functions (as defined in `xtsAPI.h`):
#'
#' \preformatted{Callable from other R packages:
#' SEXP xtsIsOrdered(SEXP x, SEXP increasing, SEXP strictly)
#' SEXP xtsNaCheck(SEXP x, SEXP check)
#' SEXP xtsTry(SEXP x)
#' SEXP xtsRbind(SEXP x, SEXP y, SEXP dup)
#' SEXP xtsCoredata(SEXP x)
#' SEXP xtsLag(SEXP x, SEXP k, SEXP pad)
#'
#' Internal use functions:
#' SEXP isXts(SEXP x)
#' void copy_xtsAttributes(SEXP x, SEXP y)
#' void copy_xtsCoreAttributes(SEXP x, SEXP y)
#'
#' Internal use macros:
#' xts_ATTRIB(x)
#' xts_COREATTRIB(x)
#' GET_xtsIndex(x)
#' SET_xtsIndex(x,value)
#' GET_xtsIndexFormat(x)
#' SET_xtsIndexFormat(x,value)
#' GET_xtsCLASS(x)
#' SET_xtsCLASS(x,value)
#'
#' Internal use SYMBOLS:
#' xts_IndexSymbol
#' xts_ClassSymbol
#' xts_IndexFormatSymbol
#'
#' Callable from R:
#' SEXP mergeXts(SEXP args)
#' SEXP rbindXts(SEXP args)
#' SEXP tryXts(SEXP x)
#' }
#'
#' @name xtsAPI
#' @author Jeffrey A. Ryan
#' @keywords utilities
#' @examples
#'
#' \dontrun{
#' # some example code to look at
#'
#' file.show(system.file('api_example/README', package="xts"))
#' file.show(system.file('api_example/src/checkOrder.c', package="xts"))
#' }
#'
NULL
xts/R/periodicity.R 0000644 0001762 0000144 00000013073 14654242576 013763 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
time_frequency <- function(x) {
x <- gsub(":|/|-| ", "", x)
nc <- nchar(x)
if(nc < 4) stop("unrecognizable time.scale")
if(nc == 4) res <- 2678400 * 12 #"yearly"
if(nc > 4) res <- 2678400 #"monthly"
if(nc > 6) res <- 86400 #"daily"
if(nc > 8) res <- 3600 #"hourly"
if(nc > 10) res <- 60 #"minute"
if(nc > 12) res <- 1 #"seconds"
return(res)
}
#' Approximate Series Periodicity
#'
#' Estimate the periodicity of a time-series-like object by calculating the
#' median time between observations in days.
#'
#' A simple wrapper to quickly estimate the periodicity of a given data.
#' Returning an object of type `periodicity`.
#'
#' This calculates the median time difference between observations as a
#' difftime object, the numerical difference, the units of measurement, and the
#' derived scale of the data as a string.
#'
#' The time index currently must be of either a 'Date' or 'POSIXct' class, or
#' or coercible to one of them.
#'
#' The 'scale' component of the result is an estimate of the periodicity of the
#' data in common terms - e.g. 7 day daily data is best described as 'weekly',
#' and would be returned as such.
#'
#' @param x A time-series-like object.
#' @param \dots Unused.
#'
#' @return A 'periodicity' object with the following elements:
#' * the `difftime` object,
#' * frequency: the median time difference between observations
#' * start: the first observation
#' * end: the last observation
#' * units: one of secs, mins, hours, or days
#' * scale: one of seconds, minute, hourly, daily, weekly, monthly, quarterly, or yearly
#' * label: one of second, minute, hour, day, week, month, quarter, year
#'
#' Possible `scale` values are: \sQuote{minute}, \sQuote{hourly}, \sQuote{daily},
#' \sQuote{weekly}, \sQuote{monthly}, \sQuote{quarterly}, and \sQuote{yearly}.
#'
#' @note This function only attempts to be a *good estimate* for the underlying
#' periodicity. If the series is too short, or has highly irregular periodicity,
#' the return values will not be accurate. That said, it is quite robust and
#' used internally within \pkg{xts}.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`difftime()`]
#'
#' @keywords utilities
#' @examples
#'
#' zoo.ts <- zoo(rnorm(231),as.Date(13514:13744,origin="1970-01-01"))
#' periodicity(zoo.ts)
#'
periodicity <- function(x, ...) {
if( timeBased(x) ) {
if( anyNA(x) ) {
warning("removing NA in 'x' to calculate periodicity")
x <- x[!is.na(x)]
}
x <- try.xts(x, error = "cannot convert 'x' to xts")
}
if (!is.xts(x)) {
x <- try.xts(x, error = "cannot convert 'x' to xts")
}
n <- length(.index(x))
if( n < 2 ) {
res <- list(difftime = structure(0, units='secs', class='difftime'),
frequency = 0,
start = NA,
end = NA,
units = 'secs',
scale = 'seconds',
label = 'second')
res <- structure(res, class='periodicity')
if( n == 0 ) {
warning("can not calculate periodicity of empty object")
} else {
warning("can not calculate periodicity of 1 observation")
res$start <- start(x)
res$end <- end(x)
}
return(res)
}
p <- median(diff( .index(x) ))
# Date and POSIXct
if(p < 60) {
units <- "secs"
scale <- "seconds"
label <- "second"
} else
if(p < 3600) {
units <- "mins"
scale <- "minute"
label <- "minute"
p <- p/60L
} else
if(p < 86400) {
# < 1 day
units <- "hours"
scale <- "hourly"
label <- "hour"
} else
if(p == 86400) {
units <- "days"
scale <- "daily"
label <- "day"
} else
if(p <= 604800) {
# 86400 * 7
units <- "days"
scale <- "weekly"
label <- "week"
} else
if(p <= 2678400) {
# 86400 * 31
units <- "days"
scale <- "monthly"
label <- "month"
} else
if(p <= 7948800) {
# 86400 * 92
units <- "days"
scale <- "quarterly"
label <- "quarter"
} else {
# years
units <- "days"
scale <- "yearly"
label <- "year"
}
structure(list(difftime = as.difftime(p, units = units),
frequency = p,
start = start(x),
end = end(x),
units = units,
scale = scale,
label = label),
class = 'periodicity')
}
`print.periodicity` <-
function (x, ...)
{
x.freq <- ifelse(x$scale %in% c("minute", "seconds"), x$frequency,
"")
if (x.freq == "") {
cap.scale <- paste(toupper(substring(x$scale, 1, 1)),
substring(x$scale, 2), sep = "")
cat(paste(cap.scale, "periodicity from", x$start, "to",
x$end, "\n", sep = " "))
}
else {
cat(paste(x.freq, x$scale, "periodicity from", x$start,
"to", x$end, "\n", sep = " "))
}
}
xts/R/rollapply.xts.R 0000644 0001762 0000144 00000013605 14654242576 014273 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
rollapply.xts <- function(data, width, FUN, ..., by=1, by.column=TRUE,
fill=if(na.pad) NA, na.pad=TRUE, partial=TRUE,
align=c("right","center","left")) {
if (!missing(na.pad)) {
warning("na.pad argument is deprecated")
}
if (!missing(partial)) {
warning("partial argument is not currently supported")
}
data <- try.xts(data) # jmu: is this necessary?
# Code taken/adapted from rollapply.zoo from the 'zoo' package
# xts doesn't currently have these functions
# if(by.column && by == 1 && ascending && length(list(...)) < 1)
# switch(deparse(substitute(FUN)),
# mean = return(rollmean(data, width, na.pad = na.pad, align = align)),
# max = return(rollmax(data, width, na.pad = na.pad, align = align)),
# median = return(rollmedian(data, width, na.pad = na.pad, align = align)))
nr <- NROW(data)
nc <- NCOL(data)
width <- as.integer(width)[1]
stopifnot( width > 0, width <= nr )
## process alignment
align <- match.arg(align)
n1 <- switch(align,
"left" = { width - 1},
"center" = { floor(width/2) },
"right" = { 0 })
idx <- index(data)
tt <- index(data)[seq((width-n1), (nr-n1), by)]
#tt <- idx[seq((width-n1), (nr-n1), 1)]
## evaluate FUN only on coredata(data)
#data <- coredata(data)
FUN <- match.fun(FUN)
ind <- as.matrix(seq.int(width,nr,by))
#e <- embedi(nr, width, by, ascending)
if( nc==1 ) {
#xx <- apply(e, 1, function(i) FUN(data[i,],...))
#xx <- sapply(1:NROW(e), function(i) FUN(data[e[i,],],...))
##xx <- sapply(ind, function(i) FUN(data[(i-width+1):i,],...))
xx <- sapply(ind, function(i) FUN(.subset_xts(data,(i-width+1):i),...))
if(!is.null(dim(xx))) xx <- t(xx)
res <- xts(xx, tt, if (by == 1) attr(data, "frequency"))
} else if( by.column ) {
res <- xts( sapply( 1:NCOL(data), function(j)
#apply(e, 1, function(i) FUN(data[i,j],...)) ),
#apply(ind, 1, function(i) FUN(data[(i-width+1):i,j],...)) ),
apply(ind, 1, function(i) FUN(.subset_xts(data,(i-width+1):i,j),...)) ),
tt, if (by == 1) attr(data, "frequency") )
} else {
#xx <- apply(e, 1, function(i) FUN(data[i,],...))
##xx <- apply(ind, 1, function(i) FUN(data[(i-width+1):i,],...))
xx <- apply(ind, 1, function(i) FUN(.subset_xts(data,(i-width+1):i),...))
if(!is.null(dim(xx))) xx <- t(xx)
res <- xts(xx, tt, if (by == 1) attr(data, "frequency"))
}
ix <- index(data) %in% index(res)
tmp <- merge(res, xts(,idx, attr(data, "frequency")))
if(is.null(colnames(res))) {
# remove dimnames (xts objects don't have rownames)
dimnames(tmp) <- NULL
}
res <- na.fill(tmp, fill, ix)
if( by.column && !is.null(dim(data)) ) {
colnames(res) <- colnames(data)
}
return(res)
}
rollsum.xts <- function (x, k, fill=if(na.pad) NA, na.pad=TRUE,
align=c("right", "center", "left"), ...) {
## FIXME: align and fill are not respected!
# from rollapply.xts; is this necessary?
x <- try.xts(x)
# from rollmean.zoo
if (!missing(na.pad))
warning("na.pad is deprecated. Use fill.")
# process alignment
align <- match.arg(align)
#n1 <- switch(align,
# "left" = { k - 1 },
# "center" = { floor(k/2) },
# "right" = { 0 })
#ix <- index(x)[seq((k-n1), (nrow(x)-n1), 1)]
res <- .Call(C_roll_sum, x, k)
res
}
rollmean.xts <- function (x, k, fill=if(na.pad) NA, na.pad=TRUE,
align=c("right", "center", "left"), ...) {
rollsum.xts(x=x, k=k, fill=fill, align=align, ...) / k
}
rollmax.xts <- function (x, k, fill=if(na.pad) NA, na.pad=TRUE,
align=c("right", "center", "left"), ...) {
## FIXME: align and fill are not respected!
# from rollapply.xts; is this necessary?
x <- try.xts(x)
# from rollmean.zoo
if (!missing(na.pad))
warning("na.pad is deprecated. Use fill.")
# process alignment
align <- match.arg(align)
#n1 <- switch(align,
# "left" = { k - 1 },
# "center" = { floor(k/2) },
# "right" = { 0 })
#ix <- index(x)[seq((k-n1), (nrow(x)-n1), 1)]
res <- .Call(C_roll_max, x, k)
res
}
rollmin.xts <- function (x, k, fill=if(na.pad) NA, na.pad=TRUE,
align=c("right", "center", "left"), ...) {
## FIXME: align and fill are not respected!
# from rollapply.xts; is this necessary?
x <- try.xts(x)
# from rollmean.zoo
if (!missing(na.pad))
warning("na.pad is deprecated. Use fill.")
# process alignment
align <- match.arg(align)
#n1 <- switch(align,
# "left" = { k - 1 },
# "center" = { floor(k/2) },
# "right" = { 0 })
#ix <- index(x)[seq((k-n1), (nrow(x)-n1), 1)]
res <- .Call(C_roll_min, x, k)
res
}
rollcov.xts <- function (x, y, k, fill=if(na.pad) NA, na.pad=TRUE,
align=c("right", "center", "left"), sample=TRUE, ...) {
## FIXME: align and fill are not respected!
# from rollapply.xts; is this necessary?
x <- try.xts(x)
y <- try.xts(y)
# from rollmean.zoo
if (!missing(na.pad))
warning("na.pad is deprecated. Use fill.")
# process alignment
align <- match.arg(align)
#n1 <- switch(align,
# "left" = { k - 1 },
# "center" = { floor(k/2) },
# "right" = { 0 })
#ix <- index(x)[seq((k-n1), (nrow(x)-n1), 1)]
res <- .Call(C_roll_cov, x, y, k, sample)
res
}
xts/R/timeBasedSeq.R 0000644 0001762 0000144 00000015435 14654242576 014011 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Create a Sequence or Range of Times
#'
#' A function to create a vector of time-based objects suitable for indexing an
#' xts object, given a string conforming to the ISO-8601 time and date standard
#' for range-based specification. The resulting series can be of any class
#' supported by xts, including POSIXct, Date, chron, timeDate, yearmon, and
#' yearqtr.
#'
#' `timeBasedRange()` creates a one or two element numeric vector representing
#' the start and end number of seconds since epoch (1970-01-01). For internal
#' use.
#'
#' `timeBasedSeq()` creates sequences of time-based observations using strings
#' formatted according to the ISO-8601 specification. The general format is
#' *from/to/by* or *from::to::by*, where *to* and *by* are optional when the
#' 'length.out' argument is specified.
#'
#' The *from* and *to* elements of the string must be left-specified with
#' respect to the standard *CCYYMMDD HHMMSS* form. All dates/times specified
#' will be set to either the earliest point (from) or the latest (to), to the
#' given the level of specificity. For example, \sQuote{1999} in the *from*
#' field would set the start to the beginning of 1999. \sQuote{1999} in the
#' *to* field would set the end to the end of 1999.
#'
#' The amount of resolution in the result is determined by the resolution of
#' the *from* and *to* component, unless the optional *by* component is
#' specified.
#'
#' For example, `timeBasedSeq("1999/2008")` returns a vector of Dates for
#' January 1st of each year. `timeBasedSeq("199501/1996")` returns a yearmon
#' vector of 24 months in 1995 and 1996. And `timeBasedSeq("19950101/1996")`
#' creates a Date vector for all the days in those two years.
#'
#' The optional *by* field (the third delimited element to the string), will
#' the resolution heuristic described above and will use the specified *by*
#' resolution. The possible values for *by* are: 'Y' (years), 'm' (months),
#' 'd' (days), 'H' (hours), 'M' (minutes), 'S' (seconds). Sub-second
#' resolutions are not supported.
#'
#' @param x An ISO-8601 time-date range string.
#' @param retclass The return class desired.
#' @param length.out Passed to `seq()` internally.
#' @param \dots Unused.
#'
#' @return `timeBasedSeq()` returns a vector of time-based observations.
#' `timeBasedRange()` returns a one or two element numeric vector representing
#' the start and end number of seconds since epoch (1970-01-01).
#'
#' When `retclass = NULL`, the result of `timeBasedSeq()` is a named list
#' containing elements "from", "to", "by" and "length.out".
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`timeBased()`], [`xts()`]
#'
#' @references International Organization for Standardization: ISO 8601
#'
#'
#' @keywords utilities
#' @examples
#'
#' timeBasedSeq('1999/2008')
#' timeBasedSeq('199901/2008')
#' timeBasedSeq('199901/2008/d')
#' timeBasedSeq('20080101 0830',length=100) # 100 minutes
#' timeBasedSeq('20080101 083000',length=100) # 100 seconds
#'
`timeBasedSeq` <-
function(x, retclass=NULL, length.out=NULL) {
if(!is.character(x))
# allows for unquoted numerical expressions to work
x <- deparse(match.call()$x)
x <- gsub('::','/',x, perl=TRUE) # replace all '::' range ops with '/'
x <- gsub('[-:]','',x, perl=TRUE) # strip all remaining '-' and ':' seps
x <- gsub('[ ]','',x, perl=TRUE) # strip all remaining white space
x <- unlist(strsplit(x,"/"))
from <- x[1]
to <- x[2]
BY <- x[3]
# need to test for user specified length.out, currently just overriding
if(from == "")
from <- NA
if(!is.na(from)) {
year <- as.numeric(substr(from,1,4))
month <- as.numeric(substr(from,5,6))
day <- as.numeric(substr(from,7,8))
hour <- as.numeric(substr(from,9,10))
mins <- as.numeric(substr(from,11,12))
secs <- as.numeric(substr(from,13,14))
time.args.from <- as.list(unlist(sapply(c(year,month,day,hour,mins,secs),
function(x) if(!is.na(x)) x)
))
from <- do.call('firstof',time.args.from)
}
else time.args.from <- list()
# only calculate if to is specified
if(!is.na(to)) {
year <- as.numeric(substr(to,1,4))
month <- as.numeric(substr(to,5,6))
day <- as.numeric(substr(to,7,8))
hour <- as.numeric(substr(to,9,10))
mins <- as.numeric(substr(to,11,12))
secs <- as.numeric(substr(to,13,14))
time.args.to <- as.list(unlist(sapply(c(year,month,day,hour,mins,secs),
function(x) if(!is.na(x)) x)
))
to <- do.call('lastof',time.args.to)
}
else time.args.to <- list()
max.resolution <- max(length(time.args.from), length(time.args.to))
# if neither is set
if(max.resolution == 0)
max.resolution <- 1
resolution <- c('year','month','DSTday','hour','mins','secs')[max.resolution]
if(!is.na(BY)) resolution <- names(match.arg(BY, list(year ='Y',
month ='m',
day ='d',
hour ='H',
mins ='M',
secs ='S')))
convert.to <- 'Date'
if(max.resolution == 2 || resolution == 'month' ) convert.to <- 'yearmon'
if(max.resolution > 3 || resolution %in% c("hour","mins","secs")) convert.to <- 'POSIXct'
if(is.na(to) && missing(length.out))
length.out <- 1L
if(((!missing(retclass) && is.null(retclass)) || any(is.na(to),is.na(from)))) {
# return the calculated values only
return(list(from=from,to=to,by=resolution,length.out=length.out))
}
if(is.null(length.out)) {
SEQ <- seq(from,to,by=resolution)
} else {
SEQ <- seq(from, by=resolution, length.out=length.out)
}
if(!is.null(retclass)) convert.to <- retclass
if(convert.to == 'POSIXct') {
structure(SEQ, class=c('POSIXct','POSIXt')) # need to force the TZ to be used
} else
do.call(paste('as',convert.to,sep='.'), list(SEQ))
}
xts/R/period.R 0000644 0001762 0000144 00000011147 14654242576 012721 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Check if Class is Time-Based
#'
#' Used to verify that the object is one of the known time-based classes in R.
#' Current time-based objects supported are `Date`, `POSIXct`, `chron`,
#' `yearmon`, `yearqtr`, and `timeDate`.
#'
#' @param x Object to test.
#'
#' @return A logical scalar.
#'
#' @author Jeffrey A. Ryan
#'
#' @rdname timeBased
#' @keywords utilities
#' @examples
#'
#' timeBased(Sys.time())
#' timeBased(Sys.Date())
#'
#' timeBased(200701)
#'
`is.timeBased` <-
function(x) {
time.classes <-
c("Date", "POSIXt", "chron", "dates", "times", "timeDate",
"yearmon", "yearqtr", "xtime")
inherits(x, time.classes)
}
#' @rdname timeBased
`timeBased` <- `is.timeBased`
#' Optimized Calculations By Period
#'
#' Calculate a sum, product, minimum, or maximum for each non-overlapping
#' period specified by `INDEX`.
#'
#' These functions are similar to calling `period.apply()` with the same
#' endpoints and function. There may be slight differences in the results due
#' to numerical accuracy.
#'
#' For xts-coercible objects, an appropriate `INDEX` can be created by a call
#' to `endpoints()`.
#'
#' @param x A univariate data object.
#' @param INDEX A numeric vector of endpoints for each period.
#'
#' @return An xts or zoo object containing the sum, product, minimum, or
#' maximum for each endpoint in `INDEX`.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`endpoints()`], [`period.apply()`]
#'
#' @keywords utilities
#' @rdname period_math
#' @examples
#'
#' x <- c(1, 1, 4, 2, 2, 6, 7, 8, -1, 20)
#' i <- c(0, 3, 5, 8, 10)
#'
#' period.sum(x, i)
#' period.prod(x, i)
#' period.min(x, i)
#' period.max(x, i)
#'
#' data(sample_matrix)
#' y <- sample_matrix[, 1]
#' ep <- endpoints(sample_matrix)
#'
#' period.sum(y, ep)
#' period.sum(as.xts(y), ep)
#'
#' period.prod(y, ep)
#' period.prod(as.xts(y), ep)
#'
#' period.min(y, ep)
#' period.min(as.xts(y), ep)
#'
#' period.max(y, ep)
#' period.max(as.xts(y), ep)
#'
`period.sum` <-
function(x,INDEX) {
if(NCOL(x) > 1) stop("single column data only")
if(min(INDEX) < 0 || max(INDEX) > NROW(x)) stop("INDEX must be >= 0 and <= nrow(x)")
ep <- as.integer(INDEX)
if(ep[1L] != 0L) ep <- c(0L,ep)
if(ep[length(ep)] != NROW(x)) ep <- c(ep,NROW(x))
xx <- as.double(x)
xa <- .Call(C_xts_period_sum, xx, ep)
if(timeBased(index(x))) {
tz <- xts(xa, index(x)[ep[-1]])
} else {
tz <- zoo(xa, index(x)[ep[-1]])
}
tz
}
#' @rdname period_math
`period.prod` <-
function(x,INDEX) {
if(NCOL(x) > 1) stop("single column data only")
if(min(INDEX) < 0 || max(INDEX) > NROW(x)) stop("INDEX must be >= 0 and <= nrow(x)")
ep <- as.integer(INDEX)
if(ep[1] != 0L) ep <- c(0L,ep)
if(ep[length(ep)] != NROW(x)) ep <- c(ep,NROW(x))
xx <- as.double(x)
xa <- .Call(C_xts_period_prod, xx, ep)
if(timeBased(index(x))) {
tz <- xts(xa, index(x)[ep[-1]])
} else {
tz <- zoo(xa, index(x)[ep[-1]])
}
tz
}
#' @rdname period_math
`period.max` <-
function(x,INDEX) {
if(NCOL(x) > 1) stop("single column data only")
if(min(INDEX) < 0 || max(INDEX) > NROW(x)) stop("INDEX must be >= 0 and <= nrow(x)")
ep <- as.integer(INDEX)
if(ep[1] != 0L) ep <- c(0L,ep)
if(ep[length(ep)] != NROW(x)) ep <- c(ep,NROW(x))
xx <- as.double(x)
xa <- .Call(C_xts_period_max, xx, ep)
if(timeBased(index(x))) {
tz <- xts(xa, index(x)[ep[-1]])
} else {
tz <- zoo(xa, index(x)[ep[-1]])
}
tz
}
#' @rdname period_math
`period.min` <-
function(x,INDEX) {
if(NCOL(x) > 1) stop("single column data only")
if(min(INDEX) < 0 || max(INDEX) > NROW(x)) stop("INDEX must be >= 0 and <= nrow(x)")
ep <- as.integer(INDEX)
if(ep[1] != 0L) ep <- c(0L,ep)
if(ep[length(ep)] != NROW(x)) ep <- c(ep,NROW(x))
xx <- as.double(x)
xa <- .Call(C_xts_period_min, xx, ep)
if(timeBased(index(x))) {
tz <- xts(xa, index(x)[ep[-1]])
} else {
tz <- zoo(xa, index(x)[ep[-1]])
}
tz
}
xts/R/as.environment.xts.R 0000644 0001762 0000144 00000003424 14654242576 015221 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Coerce an xts Object to an Environment by Column
#'
#' Method to automatically convert an xts object to an environment containing
#' vectors representing each column of the original xts object. The name of
#' each object in the resulting environment corresponds to the name of the
#' column of the xts object.
#'
#' @param x An xts object.
#'
#' @return An environment containing `ncol(x)` vectors extracted by
#' column from `x`.
#'
#' @note Environments do not preserve (or have knowledge) of column order and
#' cannot be subset by an integer index.
#'
#' @author Jeffrey A. Ryan
#'
#' @keywords manip
#' @examples
#'
#' x <- xts(1:10, Sys.Date()+1:10)
#' colnames(x) <- "X"
#' y <- xts(1:10, Sys.Date()+1:10)
#' colnames(x) <- "Y"
#' xy <- cbind(x,y)
#' colnames(xy)
#' e <- as.environment(xy) # currently using xts-style positive k
#' ls(xy)
#' ls.str(xy)
#'
as.environment.xts <- function(x) {
e <- new.env()
lapply(1:NCOL(x), function(.) assign(colnames(x)[.], x[,.],envir=e))
e
}
xts/R/yearmon.R 0000644 0001762 0000144 00000001707 14654242576 013112 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname as.xts
as.xts.yearmon <- function(x, ...)
{
xts(x=NULL, order.by=x)
}
#' @rdname as.xts
as.xts.yearqtr <- function(x, ...)
{
xts(x=NULL, order.by=x)
}
xts/R/axTicksByTime.R 0000644 0001762 0000144 00000011147 14654242576 014157 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Compute x-Axis Tickmark Locations by Time
#'
#' Compute x-axis tickmarks like [`axTicks()`] in base but with respect to
#' time. This function is written for internal use, and documented for those
#' wishing to use it for customized plots.
#'
#' The default `ticks.on = "auto"` uses heuristics to compute sensible tick
#' locations. Use a combination of `ticks.on` and `k` to create tick locations
#' at specific intervals. For example, `ticks.on = "days"` and `k = 7` will
#' create tick marks every 7 days.
#'
#' When `format.labels` is a character string the possible values are the same
#' as those listed in the Details section of [`strptime()`].
#'
#' @param x An object indexed by time or a vector of times/dates.
#' @param ticks.on Time unit for tick locations.
#' @param k Frequency of tick locations.
#' @param labels Should a labeled vector be returned?
#' @param format.labels Either a logical value specifying whether labels should
#' be formatted, or a character string specifying the format to use.
#' @param ends Should the ends be adjusted?
#' @param gt Lower bound on number of tick locations.
#' @param lt Upper bound on number of tick locations.
#'
#' @return A numeric vector of index element locations where tick marks should
#' be drawn. These are *locations* (e.g. 1, 2, 3, ...), *not* the
#' index timestamps.
#'
#' If possible, the result will be named using formatted values from the index
#' timestamps. The names will be used for the tick mark labels.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`endpoints()`]
#' @keywords utilities
#' @examples
#'
#' data(sample_matrix)
#' axTicksByTime(as.xts(sample_matrix),'auto')
#' axTicksByTime(as.xts(sample_matrix),'weeks')
#' axTicksByTime(as.xts(sample_matrix),'months',7)
#'
axTicksByTime <-
function(x, ticks.on = "auto", k = 1, labels = TRUE, format.labels = TRUE,
ends = TRUE, gt = 2, lt = 30)
{
# if a vector of times/dates, convert to dummy xts object
if (timeBased(x)) {
x <- xts(rep(1, length(x)), x)
}
ticks.on <- ticks.on[1L]
# special-case for "secs" and "mins"
if (ticks.on == "secs" || ticks.on == "mins") {
ticks.on <- substr(ticks.on, 1L, 3L)
}
tick.opts <- c("years", "quarters", "months", "weeks", "days", "hours",
"minutes", "seconds")
ticks.on <- match.arg(ticks.on, c("auto", tick.opts))
if (ticks.on == "auto") {
tick.k.opts <- c(10, 5, 2, 1, 3, 6, 1, 1, 1, 4, 2, 1, 30, 15, 1, 1)
tick.opts <- rep(tick.opts, c(4, 1, 2, 1, 1, 3, 3, 1))
is <- structure(rep(0, length(tick.opts)), .Names = tick.opts)
for (i in 1:length(tick.opts)) {
ep <- endpoints(x, tick.opts[i], tick.k.opts[i])
is[i] <- length(ep) - 1
if (is[i] > lt) {
break
}
}
loc <- rev(which(is > gt & is < lt))[1L]
cl <- tick.opts[loc]
ck <- tick.k.opts[loc]
} else {
cl <- ticks.on[1L]
ck <- k
}
if (is.null(cl) || is.na(cl) || is.na(ck)) {
ep <- c(0, NROW(x))
} else {
ep <- endpoints(x, cl, ck)
}
if (ends) {
ep <- ep + c(rep(1, length(ep) - 1), 0)
}
if (labels) {
if (is.logical(format.labels) || is.character(format.labels)) {
# format by platform...
unix <- (.Platform$OS.type == "unix")
# ...and level of time detail
fmt <- switch(periodicity(x)$scale,
weekly = ,
daily = if (unix) "%b %d%n%Y" else "%b %d %Y",
minute = ,
hourly = if (unix) "%b %d%n%H:%M" else "%b %d %H:%M",
seconds = if (unix) "%b %d%n%H:%M:%S" else "%b %d %H:%M:%S",
if (unix) "%n%b%n%Y" else "%b %Y")
# special case yearqtr index
if (inherits(index(x), "yearqtr")) {
fmt <- "%Y-Q%q"
}
if (is.character(format.labels)) {
fmt <- format.labels
}
names(ep) <- format(index(x)[ep], fmt)
} else {
names(ep) <- as.character(index(x)[ep])
}
}
ep
}
xts/R/reclass.R 0000644 0001762 0000144 00000016760 14703317760 013072 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname reclass
#' @aliases use.xts
try.xts <- function(x, ..., error=TRUE)
{
if(is.xts(x)) {
#attr(x,'.RECLASS') <- FALSE
return(x)
}
xx <- try(as.xts(x,..., .RECLASS=TRUE),silent=TRUE)
if(inherits(xx,'try-error')) {
if(is.character(error)) {
stop(error)
} else
if(is.function(error)) {
return(error(x, ...))
} else
if(error) {
stop(gsub('\n','',xx))
} else {
return(x)
}
} else {
# made positive: now test if needs to be reclassed
structure(xx, .RECLASS=TRUE)
}
}
use.xts <- try.xts
#' Convert Objects to xts and Back to Original Class
#'
#' Functions to convert objects of arbitrary classes to xts and then back to
#' the original class, without losing any attributes of the original class.
#'
#' A simple and reliable way to convert many different objects into a uniform
#' format for use within \R.
#'
#' `try.xts()` and `reclass()` are functions that enable external developers
#' access to the reclassing tools within \pkg{xts} to help speed development of
#' time-aware functions, as well as provide a more robust and seemless end-user
#' experience, regardless of the end-user's choice of data-classes.
#'
#' `try.xts()` calls `as.xts()` internally. See [`as.xts()`] for available xts
#' methods and arguments for each coercible class. Since it calls `as.xts()`,
#' you can add custom attributes as `name = value` pairs in the same way. But
#' these custom attributes will not be copied back to the original object when
#' `reclass()` is called.
#'
#' The `error` argument can be a logical value indicating whether an error
#' should be thrown (or fail silently), a character string allowing for custom
#' error error messages, or a function of the form `f(x, ...)` that will be
#' called if the conversion fails.
#'
#' `reclass()` converts an object created by `try.xts()` back to its original
#' class with all the original attributes intact (unless they were changed
#' after the object was converted to xts). The `match.to` argument allows you
#' copy the index attributes ([`tclass`], [`tformat`], and [`tzone`]) and
#' [`xtsAttributes()`] from another xts object to the result. `match.to` must
#' be an xts object with an index value for every observation in `x`.
#'
#' `Reclass()` is designed for top-level use, where it is desirable to have
#' the object returned from an arbitrary function in the same class as the
#' object passed in. Most functions in \R are not designed to return objects
#' matching the original object's class. It attempts to handle conversion and
#' reconversion transparently but it requires the original object must be
#' coercible to xts, the result of the function must have the same number of
#' rows as the input, and the object to be converted/reclassed must be the
#' first argument to the function being wrapped. Note that this function
#' hasn't been tested for robustness.
#'
#' See the accompanying vignette for more details on the above usage.
#'
#' @param x Data object to convert. See details for supported types.
#' @param match.to An xts object whose attributes will be copied to the result.
#' @param error Error handling option. See Details.
#' @param \dots Additional parameters or attributes.
#'
#' @return `try.xts()` returns an xts object when conversion is successful.
#' The `error` argument controls the function's behavior when conversion fails.
#'
#' `Reclass()` and `reclass()` return the object as its original class, as
#' specified by the 'CLASS' attribute.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`as.xts()`]
#'
#' @keywords utilities
#' @examples
#'
#' a <- 1:10
#'
#' # fails silently, the result is still an integer vector
#' try.xts(a, error = FALSE)
#'
#' # control the result with a function
#' try.xts(a, error = function(x, ...) { "I'm afraid I can't do that." })
#'
#' z <- zoo(1:10, timeBasedSeq("2020-01-01/2020-01-10"))
#' x <- try.xts(z) # zoo to xts
#' str(x)
#' str(reclass(x)) # reclass back to zoo
#'
`reclass` <-
function(x, match.to, error=FALSE, ...) {
if(!missing(match.to) && is.xts(match.to)) {
if(NROW(x) != length(.index(match.to)))
if(error) {
stop('incompatible match.to attibutes')
} else return(x)
if(!is.xts(x)) {
x <- .xts(coredata(x), .index(match.to),
tclass = tclass(match.to),
tzone = tzone(match.to),
tformat = tformat(match.to))
}
attr(x, ".CLASS") <- CLASS(match.to)
xtsAttributes(x) <- xtsAttributes(match.to)
tclass(x) <- tclass(match.to)
tformat(x) <- tformat(match.to)
tzone(x) <- tzone(match.to)
}
oldCLASS <- CLASS(x)
# should this be is.null(oldCLASS)?
if(length(oldCLASS) > 0 && !inherits(oldClass,'xts')) {
if(!is.null(dim(x))) {
if(!is.null(attr(x,'.ROWNAMES'))) {
# rownames<- (i.e. dimnames<-.xts) will not set row names
# force them directly
attr(x, "dimnames")[[1]] <- attr(x,'.ROWNAMES')[1:NROW(x)]
}
}
attr(x,'.ROWNAMES') <- NULL
#if(is.null(attr(x,'.RECLASS')) || attr(x,'.RECLASS')) {#should it be reclassed?
if(isTRUE(attr(x,'.RECLASS'))) {#should it be reclassed?
#attr(x,'.RECLASS') <- NULL
do.call(paste('re',oldCLASS,sep='.'),list(x))
} else {
#attr(x,'.RECLASS') <- NULL
x
}
} else {
#attr(x,'.RECLASS') <- NULL
x
}
}
#' @rdname reclass
#' @aliases use.reclass
Reclass <- function(x) {
xx <- match.call()
xxObj <- eval.parent(parse(text=all.vars(xx)[1]), 1)
inObj <- try.xts(xxObj, error=FALSE)
xx <- eval(match.call()[[-1]])
reclass(xx, inObj)
}
use.reclass <- Reclass
#' Extract and Set .CLASS Attribute
#'
#' Extraction and replacement functions to access the xts '.CLASS' attribute.
#' The '.CLASS' attribute is used by `reclass()` to transform an xts object
#' back to its original class.
#'
#' This is meant for use in conjunction with `try.xts()` and `reclass()` and is
#' is not intended for daily use. While it's possible to interactively coerce
#' objects to other classes than originally derived from, it's likely to cause
#' unexpected behavior. It is best to use the usual `as.xts()` and other
#' classes' `as` methods.
#'
#' @param x An xts object.
#' @param value The new value to assign to the '.CLASS' attribute.
#'
#' @return Called for its side-effect of changing the '.CLASS' attribute.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`as.xts()`], [`reclass()`]
#'
#' @keywords utilities
`CLASS` <-
function(x) {
cl <- attr(x,'.CLASS')
if(!is.null(cl)) {
attr(cl, 'class') <- 'CLASS'
return(cl)
}
return(NULL)
}
`print.CLASS` <-
function(x,...) {
cat(paste("previous class:",x),"\n")
}
#' @rdname CLASS
`CLASS<-` <-
function(x,value) {
UseMethod("CLASS<-")
}
`CLASS<-.xts` <-
function(x,value) {
attr(x,".CLASS") <- value
x
}
xts/R/POSIX.R 0000644 0001762 0000144 00000001560 14654242576 012337 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname as.xts
as.xts.POSIXt <- function(x, ...)
{
xts(NULL, order.by=x)
}
xts/R/adj.time.R 0000644 0001762 0000144 00000002556 14654242576 013136 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname align.time
adj.time <-
function(x, ...) {
tr <- match.call(expand.dots=FALSE)$...
if(length(tr) < 1) return(x)
oClass <- class(x)
x <- as.POSIXlt(x)
ntime <- as.environment(unclass(x))
lapply(tr, function(T) {
assign(all.vars(T), with(x, eval(T)), envir=ntime)
})
x <- structure(list(
sec=ntime$sec, min=ntime$min, hour=ntime$hour,
mday=ntime$mday, month=ntime$mon, year=ntime$year,
wday=ntime$wday, yday=ntime$yday,isdst=ntime$isdst), tzone=attr(x,"tzone"),
class=c("POSIXlt","POSIXt"))
do.call(paste('as',oClass[1],sep='.'), list(x))
}
xts/R/endpoints.R 0000644 0001762 0000144 00000015324 14654242576 013443 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Locate Endpoints by Time
#'
#' Extract index locations for an xts object that correspond to the *last*
#' observation in each period specified by `on` and `k`.
#'
#' `endpoints()` returns a numeric vector that always begins with zero and ends
#' with the number of observations in `x`.
#'
#' Periods are always based on the distance from the UNIX epoch (midnight
#' 1970-01-01 UTC), *not the first observation in `x`*. See the examples.
#'
#' Valid values for the `on` argument are: \dQuote{us} (microseconds),
#' \dQuote{microseconds}, \dQuote{ms} (milliseconds), \dQuote{milliseconds},
#' \dQuote{secs} (seconds), \dQuote{seconds}, \dQuote{mins} (minutes),
#' \dQuote{minutes}, \dQuote{hours}, \dQuote{days}, \dQuote{weeks},
#' \dQuote{months}, \dQuote{quarters}, and \dQuote{years}.
#'
#' @param x An xts object.
#' @param on A character string specifying the period.
#' @param k The number of periods each endpoint should cover.
#'
#' @return A numeric vector of beginning with 0 and ending with the number of
#' of observations in `x`.
#'
#' @author Jeffrey A. Ryan
#' @keywords utilities
#' @examples
#'
#' data(sample_matrix)
#'
#' endpoints(sample_matrix)
#' endpoints(sample_matrix, "weeks")
#'
#' ### example of how periods are based on the UNIX epoch,
#' ### *not* the first observation of the data series
#' x <- xts(1:38, yearmon(seq(2018 - 1/12, 2021, 1/12)))
#' # endpoints for the end of every other year
#' ep <- endpoints(x, "years", k = 2)
#' # Dec-2017 is the end of the *first* year in the data. But when you start from
#' # Jan-1970 and use every second year end as your endpoints, the endpoints are
#' # always December of every odd year.
#' x[ep, ]
#'
endpoints <-
function(x,on='months',k=1) {
if(k < 1) {
stop("'k' must be > 0")
}
if(timeBased(x)) {
NR <- length(x)
x <- xts(, order.by=x)
} else NR <- NROW(x)
addlast <- TRUE # remove automatic NR last value
if(!is.xts(x))
x <- try.xts(x, error='must be either xts-coercible or timeBased')
# special-case "secs" and "mins" for back-compatibility
if(on == "secs" || on == "mins")
on <- substr(on, 1L, 3L)
on <- match.arg(on, c("years", "quarters", "months", "weeks", "days", "hours",
"minutes", "seconds", "milliseconds", "microseconds", "ms", "us"))
# posixltindex is costly in memory (9x length of time)
# make sure we really need it
if(on %in% c('years','quarters','months','weeks','days'))
posixltindex <- as.POSIXlt(.POSIXct(.index(x)),tz=tzone(x))
include_last <- function(x, k) {
len <- length(x)
i <- seq(1L ,len, k)
if(i[length(i)] != len) {
i <- c(i, len)
}
ep[i]
}
switch(on,
"years" = {
as.integer(c(0, which(diff(posixltindex$year %/% k + 1) != 0), NR))
},
"quarters" = {
ixyear <- posixltindex$year * 100L + 190000L
ixqtr <- ixyear + posixltindex$mon %/% 3L + 1L
ep <- c(0L, which(diff(ixqtr) != 0L), NR)
if(k > 1) {
ep <- include_last(ep, k)
}
ep
},
"months" = {
ixmon <- posixltindex$year * 100L + 190000L + posixltindex$mon
ep <- .Call(C_endpoints, ixmon, 1L, 1L, addlast)
if(k > 1) {
ep <- include_last(ep, k)
}
ep
},
"weeks" = {
.Call(C_endpoints, .index(x)+3L*86400L, 604800L, k, addlast)
},
"days" = {
ixyday <- posixltindex$year * 1000L + 1900000L + posixltindex$yday
.Call(C_endpoints, ixyday, 1L, k, addlast)
},
# non-date slicing should be indifferent to TZ and DST, so use math instead
"hours" = {
.Call(C_endpoints, .index(x), 3600L, k, addlast)
},
"minutes" = {
.Call(C_endpoints, .index(x), 60L, k, addlast)
},
"seconds" = {
.Call(C_endpoints, .index(x), 1L, k, addlast)
},
"ms" = ,
"milliseconds" = {
sec2ms <- .index(x) * 1e3
.Call(C_endpoints, sec2ms, 1L, k, addlast)
},
"us" = ,
"microseconds" = {
sec2us <- .index(x) * 1e6
.Call(C_endpoints, sec2us, 1L, k, addlast)
}
)
}
`startof` <-
function(x,by='months', k=1) {
ep <- endpoints(x,on=by, k=k)
(ep+1)[-length(ep)]
}
`endof` <-
function(x,by='months', k=1) {
endpoints(x,on=by, k=k)[-1]
}
#' Create a POSIXct Object
#'
#' Easily create of time stamps corresponding to the first or last observation
#' in a specified time period.
#'
#' This is a wrapper to [`ISOdatetime()`] with defaults corresponding to the
#' first or last possible time in a given period.
#'
#' @param year,month,day Numeric values to specify a day.
#' @param hour,min,sec Numeric vaues to specify time within a day.
#' @param tz Timezone used for conversion.
#'
#' @return An POSIXct object.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`ISOdatetime()`]
#'
#' @keywords utilities
#' @examples
#'
#' firstof(2000)
#' firstof(2005,01,01)
#'
#' lastof(2007)
#' lastof(2007,10)
#'
`firstof` <-
function(year=1970,month=1,day=1,hour=0,min=0,sec=0,tz="") {
ISOdatetime(year,month,day,hour,min,sec,tz)
}
#' @param subsec Number of sub-seconds.
#' @rdname firstof
lastof <-
function (year = 1970,
month = 12,
day = 31,
hour = 23,
min = 59,
sec = 59,
subsec=.99999, tz = "")
{
if(!missing(sec) && sec %% 1 != 0)
subsec <- 0
sec <- ifelse(year < 1970, sec, sec+subsec) # <1970 asPOSIXct bug workaround
#sec <- sec + subsec
mon.lengths <- c(31, 28, 31, 30, 31, 30, 31, 31, 30, 31,
30, 31)
if (missing(day)) {
day <- ifelse(month %in% 2, ifelse(((year%%4 %in% 0 &
!year%%100 %in% 0) | (year%%400 %in% 0)), 29, 28),
mon.lengths[month])
}
# strptime has an issue (bug?) which returns NA when passed
# 1969-12-31-23-59-59; pass 58.9 secs instead.
sysTZ <- Sys.getenv("TZ")
if (length(c(year, month, day, hour, min, sec)) == 6 &&
all(c(year, month, day, hour, min, sec) == c(1969, 12, 31, 23, 59, 59)) &&
(sysTZ == "" || isUTC(sysTZ)))
sec <- sec-1
ISOdatetime(year, month, day, hour, min, sec, tz)
}
xts/R/xts.R 0000644 0001762 0000144 00000043152 14702273113 012237 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# xts() index attribute precedence should be:
# 1. .index* value (e.g. .indexTZ) # backward compatibility
# 2. t* value (e.g. tzone) # current function to override index attribute
# 3. attribute on order.by # overridden by either 2 above
#
# Do we always have to override the value of an existing tzone on the index
# because the default value is Sys.getenv("TZ")?
#
# .xts() index attribute precedence is similar. But we cannot override tclass
# because it's a formal argument with a specific default. Historically .xts()
# has always set the tclass to POSIXct by default, whether or not the 'index'
# argument already had a tclass attribute.
#' Create or Test For An xts Time-Series Object
#'
#' Constructor function for creating an extensible time-series object.
#'
#' `xts()` is used to create an xts object from raw data inputs. The xts class
#' inherits from and extends the zoo class, which means most zoo functions can
#' be used on xts objects.
#'
#' The `xts()` constructor is the preferred way to create xts objects. It
#' performs several checks to ensure it returns a well-formed xts object. The
#' `.xts()` constructor is mainly for internal use. It is more efficient then
#' the regular `xts()` constructor because it doesn't perform as many validity
#' checks. Use it with caution.
#'
#' Similar to zoo objects, xts objects must have an ordered index. While zoo
#' indexes cannot contain duplicate values, xts objects have optionally
#' supported duplicate index elements since version 0.5-0. The xts class has
#' one additional requirement: the index must be a time-based class. Currently
#' supported classes include: \sQuote{Date}, \sQuote{POSIXct}, \sQuote{timeDate},
#' as well as \sQuote{yearmon} and \sQuote{yearqtr} where the index values
#' remain unique.
#'
#' The uniqueness requirement was relaxed in version 0.5-0, but is still
#' enforced by default. Setting `unique = FALSE` skips the uniqueness check and
#' only ensures that the index is ordered via the `isOrdered()` function.
#'
#' As of version 0.10-0, xts no longer allows missing values in the index. This
#' is because many xts functions expect all index values to be finite. The most
#' important of these is `merge.xts()`, which is used ubiquitously. Missing
#' values in the index are usually the result of a date-time conversion error
#' (e.g. incorrect format, non-existent time due to daylight saving time, etc.).
#' Because of how non-finite numbers are represented, a missing timestamp will
#' always be at the end of the index (except if it is `-Inf`, which will be
#' first).
#'
#' Another difference from \pkg{zoo} is that xts object may carry additional
#' attributes that may be desired in individual time-series handling. This
#' includes the ability to augment the objects data with meta-data otherwise
#' not cleanly attachable to a standard zoo object. These attributes may be
#' assigned and extracted via [`xtsAttributes()`] and [`xtsAttributes<-`],
#' respectively.
#'
#' Examples of usage from finance may include the addition of data for keeping
#' track of sources, last-update times, financial instrument descriptions or
#' details, etc.
#'
#' The idea behind \pkg{xts} is to offer the user the ability to utilize a
#' standard zoo object, while providing an mechanism to customize the object's
#' meta-data, as well as create custom methods to handle the object in a manner
#' required by the user.
#'
#' Many xts-specific methods have been written to better handle the unique
#' aspects of xts. These include, subsetting (`[`), `merge()`, `cbind()`,
#' `rbind()`, `c()`, math and logical operations, `lag()`, `diff()`,
#' `coredata()`, `head()`, and `tail()`. There are also xts-specific methods
#' for converting to/from R's different time-series classes.
#'
#' Subsetting via `[` methods offers the ability to specify dates by range, if
#' they are enclosed in quotes. The style borrows from python by creating
#' ranges separated by a double colon \dQuote{"::"} or \dQuote{"/"}. Each side
#' of the range may be left blank, which would then default to the start and
#' end of the data, respectively. To specify a subset of times, it is only
#' required that the time specified be in standard ISO format, with some form
#' of separation between the elements. The time must be *left-filled*, that is
#' to specify a full year one needs only to provide the year, a month requires
#' the full year and the integer of the month requested - e.g. '1999-01'. This
#' format would extend all the way down to seconds - e.g. '1999-01-01 08:35:23'.
#' Leading zeros are not necessary. See the examples for more detail.
#'
#' Users may also extend the xts class to new classes to allow for method
#' overloading.
#'
#' Additional benefits derive from the use of [`as.xts()`] and [`reclass()`],
#' which allow for lossless two-way conversion between common R time-series
#' classes and the xts object structure. See those functions for more detail.
#'
#' @param x An object containing the underlying data.
#' @param order.by A corresponding vector of dates/times of a known time-based
#' class. See Details.
#' @param index A corresponding *numeric* vector specified as seconds since
#' the UNIX epoch (1970-01-01 00:00:00.000).
#' @param frequency Numeric value indicating the frequency of `order.by`. See
#' details.
#' @param unique Can the index only include unique timestamps? Ignored when
#' `check = FALSE`.
#' @param check Must the index be ordered? The index cannot contain duplicates
#' when `check = TRUE` and `unique = TRUE`.
#' @param tclass Time class to use for the index. See [`tclass()`].
#' @param tzone Time zone of the index (ignored for indices without a time
#' component, e.g. Date, yearmon, yearqtr). See [`tzone()`].
#' @param \dots Additional attributes to be added. See details.
#'
#' @return An S3 object of class xts.
#'
#' @author Jeffrey A. Ryan and Joshua M. Ulrich
#'
#' @seealso [`as.xts()`], [`index()`][xts::index.xts], [`tclass()`], [`tformat()`], [`tzone()`],
#' [`xtsAttributes()`]
#'
#' @references \pkg{zoo}
#'
#' @keywords utilities
#' @examples
#'
#' data(sample_matrix)
#' sample.xts <- as.xts(sample_matrix, descr='my new xts object')
#'
#' class(sample.xts)
#' str(sample.xts)
#'
#' head(sample.xts) # attribute 'descr' hidden from view
#' attr(sample.xts,'descr')
#'
#' sample.xts['2007'] # all of 2007
#' sample.xts['2007-03/'] # March 2007 to the end of the data set
#' sample.xts['2007-03/2007'] # March 2007 to the end of 2007
#' sample.xts['/'] # the whole data set
#' sample.xts['/2007'] # the beginning of the data through 2007
#' sample.xts['2007-01-03'] # just the 3rd of January 2007
#'
`xts` <-
function(x=NULL,
order.by=index(x),
frequency=NULL,
unique=TRUE,
tzone=Sys.getenv("TZ"),
...)
{
if(is.null(x) && missing(order.by))
return(.xts(NULL, integer()))
if(!timeBased(order.by))
stop("order.by requires an appropriate time-based object")
#if(NROW(x) != length(order.by))
if(NROW(x) > 0 && NROW(x) != length(order.by))
stop("NROW(x) must match length(order.by)")
order.by_ <- order.by # make local copy and don't change order.by
if(inherits(order.by, 'Date')) {
# convert to GMT POSIXct if specified
order.by_ <- .POSIXct(unclass(order.by) * 86400, tz = "UTC")
}
if(!isOrdered(order.by_, strictly = !unique)) {
indx <- order(order.by_)
if(!is.null(x)) {
if(NCOL(x) > 1 || is.matrix(x) || is.data.frame(x)) {
x <- x[indx,,drop=FALSE]
} else x <- x[indx]
}
order.by_ <- order.by_[indx]
}
if(is.null(x)) {
x <- numeric(0)
} else if (is.list(x)) {
# list or data.frame
if (is.data.frame(x)) {
x <- as.matrix(x)
} else {
stop("cannot convert lists to xts objects")
}
} else if (NROW(x) > 0) {
x <- as.matrix(x)
}
# else 'x' is a zero-length vector. Do not *add* dims via as.matrix().
# It's okay if 'x' already has dims.
if(inherits(order.by, "dates")) {
fmt <- "%m/%d/%y"
if(inherits(order.by, "chron")) {
fmt <- paste0("(", fmt, " %H:%M:%S)")
}
order.by_ <- strptime(as.character(order.by_), fmt) # POSIXlt
}
index <- as.numeric(as.POSIXct(order.by_))
if(any(!is.finite(index)))
stop("'order.by' cannot contain 'NA', 'NaN', or 'Inf'")
# process index attributes
ctor.call <- match.call(expand.dots = TRUE)
tformat. <- attr(order.by, "tformat")
if(hasArg(".indexFORMAT")) {
warning(sQuote(".indexFORMAT"), " is deprecated, use tformat instead.")
tformat. <- eval.parent(ctor.call$.indexFORMAT)
} else if(hasArg("tformat")) {
tformat. <- eval.parent(ctor.call$tformat)
}
tclass. <- attr(order.by, "tclass")
if(hasArg(".indexCLASS")) {
warning(sQuote(".indexCLASS"), " is deprecated, use tclass instead.")
tclass. <- eval.parent(ctor.call$.indexCLASS)
} else if(hasArg("tclass")) {
tclass. <- eval.parent(ctor.call$tclass)
} else if(is.null(tclass.)) {
tclass. <- class(order.by)
if(inherits(order.by, "POSIXt")) {
#tclass. <- tclass.[tclass. != "POSIXt"]
}
}
tzone. <- tzone # default Sys.getenv("TZ")
if(hasArg(".indexTZ")) {
warning(sQuote(".indexTZ"), " is deprecated, use tzone instead.")
tzone. <- eval.parent(ctor.call$.indexTZ)
} else if(hasArg("tzone")) {
tzone. <- eval.parent(ctor.call$tzone)
} else {
# no tzone argument
if(inherits(order.by, "timeDate")) {
tzone. <- order.by@FinCenter
} else if(!is.null(attr(order.by, "tzone"))) {
tzone. <- attr(order.by, "tzone")
}
}
if(isClassWithoutTZ(object = order.by)) {
if((hasArg(".indexTZ") || hasArg("tzone")) && !isUTC(tzone.)) {
warning(paste(sQuote('tzone'),"setting ignored for ",
paste(class(order.by), collapse=", "), " indexes"))
}
tzone. <- "UTC" # change anything in isUTC() to UTC
}
# xts' tzone must only contain one element (POSIXlt tzone has 3)
tzone. <- tzone.[1L]
x <- structure(.Data = x,
index = structure(index, tzone = tzone.,
tclass = tclass., tformat = tformat.),
class=c('xts','zoo'),
...)
# remove any index attributes that came through '...'
index.attr <- c(".indexFORMAT", "tformat",
".indexCLASS", "tclass",
".indexTZ", "tzone")
for(iattr in index.attr) {
attr(x, iattr) <- NULL
}
if(!is.null(attributes(x)$dimnames[[1]]))
# this is very slow if user adds rownames, but maybe that is deserved :)
dimnames(x) <- dimnames(x) # removes row.names
x
}
#' @rdname xts
`.xts` <-
function(x=NULL, index, tclass=c("POSIXct","POSIXt"),
tzone=Sys.getenv("TZ"),
check=TRUE, unique=FALSE, ...) {
if(check) {
if( !isOrdered(index, increasing=TRUE, strictly=unique) )
stop('index is not in ',ifelse(unique, 'strictly', ''),' increasing order')
}
index_out <- index
if(!is.numeric(index) && timeBased(index))
index_out <- as.numeric(as.POSIXct(index))
if(!is.null(x) && NROW(x) != length(index))
stop("index length must match number of observations")
if(any(!is.finite(index_out)))
stop("'index' cannot contain 'NA', 'NaN', or 'Inf'")
if(!is.null(x)) {
if(!is.matrix(x))
x <- as.matrix(x)
} else
if(length(x) == 0 && !is.null(x)) {
x <- vector(storage.mode(x))
} else x <- numeric(0)
# process index attributes
ctor.call <- match.call(expand.dots = TRUE)
tformat. <- attr(index, "tformat")
if(hasArg(".indexFORMAT")) {
warning(sQuote(".indexFORMAT"), " is deprecated, use tformat instead.")
tformat. <- eval.parent(ctor.call$.indexFORMAT)
} else if(hasArg("tformat")) {
tformat. <- eval.parent(ctor.call$tformat)
}
tclass. <- tclass # default POSIXct
if(hasArg(".indexCLASS")) {
warning(sQuote(".indexCLASS"), " is deprecated, use tclass instead.")
tclass. <- eval.parent(ctor.call$.indexCLASS)
} else if(hasArg("tclass")) {
tclass. <- eval.parent(ctor.call$tclass)
} else {
# no tclass argument
tclass. <- attr(index, "tclass")
if(is.null(tclass.) && timeBased(index)) {
tclass. <- class(index)
} else {
if(!identical(tclass., c("POSIXct", "POSIXt"))) {
# index argument has 'tclass' attribute but it will be ignored
# FIXME:
# This warning causes errors in dependencies (e.g. portfolioBacktest,
# when the warning is thrown from PerformanceAnalytics). Reinstate this
# warning after fixing downstream packages.
# warning("the index tclass attribute is ", index.class,
# " but will be changed to (POSIXct, POSIXt)")
tclass. <- tclass # default POSIXct
}
}
}
tzone. <- tzone # default Sys.getenv("TZ")
if(hasArg(".indexTZ")) {
warning(sQuote(".indexTZ"), " is deprecated, use tzone instead.")
tzone. <- eval.parent(ctor.call$.indexTZ)
} else if(hasArg("tzone")) {
tzone. <- eval.parent(ctor.call$tzone)
} else {
# no tzone argument
if(inherits(index, "timeDate")) {
tzone. <- index@FinCenter
} else if(!is.null(attr(index, "tzone"))) {
tzone. <- attr(index, "tzone")
}
}
if(isClassWithoutTZ(object = index)) {
if((hasArg(".indexTZ") || hasArg("tzone")) && !isUTC(tzone.)) {
warning(paste(sQuote('tzone'),"setting ignored for ",
paste(class(index), collapse=", "), " indexes"))
}
tzone. <- "UTC" # change anything in isUTC() to UTC
}
# xts' tzone must only contain one element (POSIXlt tzone has 3)
tzone <- tzone[1L]
xx <- .Call(C_add_xtsCoreAttributes, x, index_out, tzone., tclass.,
c('xts','zoo'), tformat.)
# remove any index attributes that came through '...'
# and set any user attributes (and/or dim, dimnames, etc)
dots.names <- eval(substitute(alist(...)))
if(length(dots.names) > 0L) {
dot.attrs <- list(...)
drop.attr <- c(".indexFORMAT", "tformat", ".indexCLASS", ".indexTZ")
dot.attrs[drop.attr] <- NULL
attributes(xx) <- c(attributes(xx), dot.attrs)
}
# ensure there are no rownames (they may have come though dimnames)
rn <- dimnames(xx)[[1]]
if(!is.null(rn)) {
attr(xx, '.ROWNAMES') <- rn
dimnames(xx)[1] <- list(NULL)
}
xx
}
#' @rdname xts
`is.xts` <-
function(x) {
inherits(x,'xts') &&
is.numeric(.index(x)) &&
!is.null(tclass(x))
}
#' Convert Objects To and From xts
#'
#' Conversion S3 methods to coerce data objects of arbitrary classes to xts
#' and back, without losing any attributes of the original format.
#'
#' A simple and reliable way to convert many different objects into a uniform
#' format for use within \R.
#'
#' `as.xts()` can convert objects of the following classes into an xts object:
#' object: [timeSeries][timeSeries::timeSeries], [ts], [matrix], [data.frame],
#' and [zoo][zoo::zoo]. `xtsible()` safely checks whether an object can be converted to
#' an xts object.
#'
#' Additional `name = value` pairs may be passed to the function to be added to
#' the new object. A special [`print.xts()`] method ensures the attributes are
#' hidden from view, but will be available via \R's standard `attr()` function,
#' as well as the [`xtsAttributes()`] function.
#'
#' When `.RECLASS = TRUE`, the returned xts object internally preserves all
#' relevant attribute/slot data from the input `x`. This allows for temporary
#' conversion to xts in order to use zoo and xts compatible methods. See
#' [`reclass()`] for details.
#'
#' @param x Data object to convert. See details for supported types.
#' @param dateFormat What class should the dates be converted to?
#' @param FinCenter,recordIDs,title,documentation See [timeSeries][timeSeries::timeSeries] help.
#' @param order.by,frequency See [zoo][zoo::zoo] help.
#' @param \dots Additional parameters or attributes.
#' @param .RECLASS Should the conversion be reversible via [`reclass()`]?
#'
#' @return An S3 object of class xts.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`xts()`], [`reclass()`], [`zoo()`][zoo::zoo]
#'
#' @keywords utilities
#' @examples
#'
#' \dontrun{
#' # timeSeries
#' library(timeSeries)
#' x <- timeSeries(1:10, 1:10)
#'
#' str(as.xts(x))
#' str(reclass(as.xts(x)))
#' str(try.xts(x))
#' str(reclass(try.xts(x)))
#' }
#'
`as.xts` <-
function(x,...) {
UseMethod('as.xts')
}
#' @rdname as.xts
xtsible <- function(x)
{
if(inherits(try(as.xts(x),silent=TRUE),'try-error')) {
FALSE
} else TRUE
}
`re.xts` <-
function(x,...) {
# simply return the object
return(x)
}
`as.xts.xts` <-
function(x,...,.RECLASS=FALSE) {
# Cannot use 'zoo()' on objects of class 'zoo' or '.CLASS' (etc.?)
# Is the equivalent of a 'coredata.xts' needed? - jmu
#yy <- coredata(x)
#attr(yy, ".CLASS") <- NULL
# using new coredata.xts method - jar
if(length(x) == 0 && (!is.null(index(x)) && length(index(x))==0))
return(x)
if(.RECLASS) {
xx <- xts(coredata(x),
order.by=index(x),
.CLASS='xts',
...)
} else {
xx <- xts(coredata(x),
order.by=index(x),
...)
}
xx
}
xts/R/startOfYear.R 0000644 0001762 0000144 00000002016 14654242576 013675 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
`startOfYear` <- function(from=1900,
to=2200,
origin=1970)
{
.Call(C_do_startofyear,
from = as.integer(from),
to = as.integer(to),
origin = as.integer(origin))
}
xts/R/utils.R 0000644 0001762 0000144 00000002026 14654242576 012573 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
naCheck <- function(x, n=0) {
if(is.null(dim(x)[2])) {
NAs <- .Call(C_naCheck, x, TRUE)
} else NAs <- .Call(C_naCheck, rowSums(x), TRUE)
ret <- list()
ret$NAs <- NAs
ret$nonNA <- (1+NAs):NROW(x)
ret$beg <- n+NAs
invisible(ret)
}
xts/R/first.R 0000644 0001762 0000144 00000015656 14654242576 012577 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Return First or Last n Elements of A Data Object
#'
#' Generic functions to return the first or last elements or rows of a vector
#' or two-dimensional data object.
#'
#' A more advanced subsetting is available for zoo objects with indexes
#' inheriting from POSIXt or Date classes.
#'
#' Quickly and easily extract the first or last `n` observations of an object.
#' When `n` is a number, these functions are similar to [`head()`] and
#' [`tail()`], but only return the *first* or *last* observation by default.
#'
#' `n` can be a character string if `x` is an xts object or coerceable to xts.
#' It must be of the form \sQuote{n period}, where 'n' is a numeric value
#' (1 if not provided) describing the number of periods to return. Valid
#' periods are: secs, seconds, mins, minutes, hours, days, weeks, months,
#' quarters, and years.
#'
#' The 'period' portion can be any frequency greater than or equal to the
#' frequency of the object's time index. For example, `first(x, "2 months")`
#' will return the first 2 months of data even if `x` is hourly frequency.
#' Attempts to set 'period' to a frequency less than the object's frequency
#' will throw an error.
#'
#' `n` may be positive or negative, whether it's a number or character string.
#' When `n` is positive, the functions return the obvious result. For example,
#' `first(x, "1 month")` returns the first month's data. When `n` is negative,
#' all data *except* first month's is returned.
#'
#' Requesting more data than is in `x` will throw a warning and simply return
#' `x`.
#'
#' @param x An object.
#' @param n Number of observations to return.
#' @param keep Should removed values be kept as an attribute on the result?
#' @param \dots Arguments passed to other methods.
#'
#' @return A subset of elements/rows of the original data.
#'
#' @author Jeffrey A. Ryan
#'
#' @keywords utilities
#' @examples
#'
#' first(1:100)
#' last(1:100)
#'
#' data(LakeHuron)
#' first(LakeHuron,10)
#' last(LakeHuron)
#'
#' x <- xts(1:100, Sys.Date()+1:100)
#' first(x, 10)
#' first(x, '1 day')
#' first(x, '4 days')
#' first(x, 'month')
#' last(x, '2 months')
#' last(x, '6 weeks')
#'
`first` <-
function(x,...)
{
UseMethod("first")
}
#' @rdname first
`first.default` <-
function(x,n=1,keep=FALSE,...)
{
if(length(x) == 0)
return(x)
if(is.character(n)) {
xx <- try.xts(x, error=FALSE)
if(is.xts(xx)) {
xx <- first.xts(x, n=n, keep=keep, ...)
return(reclass(xx))
}
}
if(is.null(dim(x))) {
if(n > 0) {
sub <- seq_len(min(n, length(x)))
xx <- x[sub]
if(keep) xx <- structure(xx,keep=x[(-(-n)+1):NROW(x)])
xx
} else if(n < 0) {
sub <- seq.int(to = length(x), length.out = max(length(x)-(-n), 0L))
xx <- x[sub]
if(keep) xx <- structure(xx,keep=x[1:(-n)])
xx
} else {
xx <- x[0]
if(keep) xx <- structure(xx,keep=x[0])
xx
}
} else {
if(n > 0) {
sub <- seq_len(min(n, NROW(x)))
xx <- x[sub,,drop=FALSE]
if(keep) xx <- structure(xx,keep=x[(-(-n)+1):NROW(x),])
xx
} else if(n < 0) {
sub <- seq.int(to = NROW(x), length.out = max(NROW(x)-(-n), 0L))
xx <- x[sub,,drop=FALSE]
if(keep) xx <- structure(xx,keep=x[1:(-n),])
xx
} else {
xx <- x[0,,drop=FALSE]
if(keep) xx <- structure(xx,keep=x[0,])
xx
}
}
}
#' @rdname first
`first.xts` <-
function(x,n=1,keep=FALSE,...)
{
if(length(x) == 0)
return(x)
if(is.character(n)) {
# n period set
np <- strsplit(n," ",fixed=TRUE)[[1]]
if(length(np) > 2 || length(np) < 1)
stop(paste("incorrectly specified",sQuote("n"),sep=" "))
# series periodicity
sp <- periodicity(x)
# requested periodicity$units
sp.units <- sp[["units"]]
rpu <- np[length(np)]
rpf <- ifelse(length(np) > 1, as.numeric(np[1]), 1)
if(rpu == sp.units) {
n <- rpf
} else {
# if singular - add an s to make it work
if(substr(rpu,length(strsplit(rpu,'')[[1]]),length(strsplit(rpu,'')[[1]])) != 's')
rpu <- paste(rpu,'s',sep='')
u.list <- list(secs=4,seconds=4,mins=3,minutes=3,hours=2,days=1,
weeks=1,months=1,quarters=1,years=1)
dt.options <- c('seconds','secs','minutes','mins','hours','days',
'weeks','months','quarters','years')
if(!rpu %in% dt.options)
stop(paste("n must be numeric or use",paste(dt.options,collapse=',')))
dt <- dt.options[pmatch(rpu,dt.options)]
if(u.list[[dt]] > u.list[[sp.units]]) {
# req is for higher freq data period e.g. 100 mins of daily data
stop(paste("At present, without some sort of magic, it isn't possible",
"to resolve",rpu,"from",sp$scale,"data"))
}
ep <- endpoints(x,dt)
if(rpf > length(ep)-1) {
rpf <- length(ep)-1
warning("requested length is greater than original")
}
if(rpf > 0) {
n <- ep[rpf+1]
if(is.null(dim(x))) {
xx <- x[1:n]
} else {
xx <- x[1:n,,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[(ep[-(-rpf)+1]+1):NROW(x)])
return(xx)
} else if(rpf < 0) {
n <- ep[-rpf+1]+1
if(is.null(dim(x))) {
xx <- x[n:NROW(x)]
} else {
xx <- x[n:NROW(x),,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[1:(ep[-rpf+1])])
return(xx)
} else {
if(is.null(dim(x))) {
xx <- x[0]
} else {
xx <- x[0,,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[0])
return(xx)
}
}
}
if(length(n) != 1) stop("n must be of length 1")
if(n > 0) {
n <- min(n, NROW(x))
if(is.null(dim(x))) {
xx <- x[1:n]
} else {
xx <- x[1:n,,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[(-(-n)+1):NROW(x)])
xx
} else if(n < 0) {
if(abs(n) >= NROW(x))
return(x[0])
if(is.null(dim(x))) {
xx <- x[(-n+1):NROW(x)]
} else {
xx <- x[(-n+1):NROW(x),,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[1:(-n)])
xx
} else {
if(is.null(dim(x))) {
xx <- x[0]
} else {
xx <- x[0,,drop=FALSE]
}
if(keep) xx <- structure(xx,keep=x[0])
xx
}
}
xts/R/na.R 0000644 0001762 0000144 00000011212 14654242576 012026 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
na.omit.xts <- function(object, ...) {
xx <- .Call(C_na_omit_xts, object)
if(length(xx)==0)
return(structure(xts(,),.Dim=c(0,NCOL(object))))
naa <- attr(xx,'na.action')
if(length(naa) == 0)
return(xx)
naa.index <- .index(object)[naa]
ROWNAMES <- attr(object,'.ROWNAMES')
if(!is.null(ROWNAMES)) {
naa.rownames <- ROWNAMES[naa]
} else naa.rownames <- NULL
attr(xx,'na.action') <- structure(naa,
index=naa.index,
.ROWNAMES=naa.rownames)
return(xx)
}
na.exclude.xts <- function(object, ...) {
xx <- .Call(C_na_omit_xts, object)
naa <- attr(xx,'na.action')
if(length(naa) == 0)
return(xx)
naa.index <- .index(object)[naa]
ROWNAMES <- attr(object,'.ROWNAMES')
if(!is.null(ROWNAMES)) {
naa.rownames <- ROWNAMES[naa]
} else naa.rownames <- NULL
attr(xx,'na.action') <- structure(naa,
class="exclude",
index=naa.index,
.ROWNAMES=naa.rownames)
return(xx)
}
na.restore <- function(object, ...) {
UseMethod("na.restore")
}
na.restore.xts <- function(object, ...) {
if(is.null(na.action(object)))
return(object)
structure(merge(structure(object,na.action=NULL),
.xts(,attr(na.action(object),"index"))),
.Dimnames=list(NULL, colnames(object)))
}
na.replace <- function(x) {
.Deprecated("na.restore")
if(is.null(xtsAttributes(x)$na.action))
return(x)
# Create 'NA' xts object
tmp <- xts(matrix(rep(NA,NCOL(x)*NROW(x)), ncol=NCOL(x)),
attr(xtsAttributes(x)$na.action, 'index'))
# Ensure xts 'NA' object has *all* the same attributes
# as the object 'x'; this is necessary for rbind to
# work correctly
CLASS(tmp) <- CLASS(x)
xtsAttributes(tmp) <- xtsAttributes(x)
attr(x,'na.action') <- attr(tmp,'na.action') <- NULL
colnames(tmp) <- colnames(x)
rbind(x,tmp)
}
#' Last Observation Carried Forward
#'
#' \pkg{xts} method replace `NA` with most recent non-NA
#'
#' This is the \pkg{xts} method for the S3 generic `na.locf()`. The primary
#' difference to note is that after the `NA` fill action is carried out, the
#' default it to leave trailing or leading `NA`'s in place. This is different
#' than \pkg{zoo} behavior.
#'
#' @param object An xts object.
#' @param na.rm Logical indicating whether leading/trailing `NA` should be
#' removed. The default is `FALSE` unlike the zoo method.
#' @param fromLast Logical indicating whether observations should be carried
#' backward rather than forward. Default is `FALSE`.
#' @param maxgap Consecutive runs of observations more than 'maxgap' will
#' remain `NA`. See [`na.locf()`][zoo::zoo] for details.
#' @param \dots Unused.
#'
#' @return An object where each `NA` in `object` is replaced by the most recent
#' non-NA prior to it. See [`na.locf()`][zoo::zoo] for details.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`na.locf()`][zoo::zoo]
#'
#' @keywords misc
#' @examples
#'
#' x <- xts(1:10, Sys.Date()+1:10)
#' x[c(1,2,5,9,10)] <- NA
#'
#' x
#' na.locf(x)
#' na.locf(x, fromLast=TRUE)
#' na.locf(x, na.rm=TRUE, fromLast=TRUE)
#'
na.locf.xts <- function(object, na.rm=FALSE, fromLast=FALSE, maxgap=Inf, ...) {
maxgap <- min(maxgap, NROW(object))
if(length(object) == 0)
return(object)
if(hasArg("x") || hasArg("xout"))
return(NextMethod(.Generic))
x <- .Call(C_na_locf, object, fromLast, maxgap, Inf)
if(na.rm) {
return(structure(na.omit(x),na.action=NULL))
} else x
}
na.fill.xts <- function(object, fill, ix, ...) {
if (length(fill) == 1 && missing(ix)) {
# na.fill0() may change the storage type of 'object'
# make sure 'fill' argument is same type as 'object'
fill. <- fill
storage.mode(fill.) <- storage.mode(object)
return(na.fill0(object, fill.))
} else {
NextMethod(.Generic)
}
}
xts/R/ts.R 0000644 0001762 0000144 00000007137 14654242576 012071 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# methods for handling ts <--> xts
`re.ts` <-
function(x,...) {
# major issue with quick reclass. Basically fails on data < 1970...
#tsp.attr <- attr(x,'.tsp')
#freq.attr <- attr(x,'.frequency')
#xtsAttributes(x) <- NULL
#ts(coredata(x), start=tsp.attr[1],frequency=freq.attr)
dim <- attr(x, 'dim')
if(!is.null(dim) && dim[2]==1) {
attr(x,'dim') <- attr(x, 'dimnames') <- NULL
}
as.ts(x)
}
#' @rdname as.xts
`as.xts.ts` <-
function(x,dateFormat,...,.RECLASS=FALSE) {
x.mat <- structure(as.matrix(x),dimnames=dimnames(x))
colnames(x.mat) <- colnames(x)
# quick hueristic - if numeric index is larger than one
# full day of seconds (60*60*24) than use POSIXct, otherwise
# assume we are counting my days, not seconds, and use Date -jar
#
# I am sure this can be improved upon, but for now it is effective
# in most circumstances. Will break if frequency or time is from 1
# not _break_ but be less useful
# a bigger question is _should_ it throw an error if it can't guess,
# or should the user simply beware.
if(missing(dateFormat)) {
if(frequency(x) == 1) {
# assume yearly series: Date
yr <- tsp(x)[1] %/% 1
mo <- tsp(x)[1] %% 1
if(mo %% (1/12) != 0 || yr > 3000) {
# something finer than year.month is specified - can't reliable convert
dateFormat <- ifelse(max(time(x)) > 86400,'POSIXct','Date')
order.by <- do.call(paste('as',dateFormat,sep='.'),
list(as.numeric(time(x)),origin='1970-01-01',...))
} else {
mo <- ifelse(length(mo) < 1, 1,floor(mo * 12)+1)
from <- as.Date(firstof(yr,mo),origin='1970-01-01')
order.by <- seq.Date(from,length.out=length(time(x)),by='year')
}
} else
if(frequency(x) == 4) {
# quarterly series: yearqtr
order.by <- as.yearqtr(time(x))
} else
if(frequency(x) == 12) {
# monthly series: yearmon
order.by <- as.yearmon(time(x))
} else stop('could not convert index to appropriate type')
} else {
order.by <- do.call(paste('as',dateFormat,sep='.'),
list(as.numeric(time(x)),...))
}
if(.RECLASS) {
xx <- xts(x.mat,
order.by=order.by,
frequency=frequency(x),
.CLASS='ts',
.CLASSnames=c('frequency'),
.tsp=tsp(x),
# .frequency=frequency(x),
...)
} else {
xx <- xts(x.mat,
order.by=order.by,
frequency=frequency(x),
...)
}
attr(xx, 'tsp') <- NULL
xx
}
`as.ts.xts` <-
function(x,...) {
#if(attr(x,'.CLASS')=='ts') return(re.ts(x,...))
TSP <- attr(x, '.tsp')
attr(x, '.tsp') <- NULL
x <- ts(coredata(x), frequency=frequency(x), ...)
if(!is.null(dim(x)) && dim(x)[2]==1)
dim(x) <- NULL
if(!is.null(TSP))
tsp(x) <- TSP
x
}
xts/R/xts.methods.R 0000644 0001762 0000144 00000051162 14654242576 013720 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
# window.xts contributed by Corwin Joy
#
# 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, see .
.subsetTimeOfDay <- function(x, fromTimeString, toTimeString) {
validateTimestring <- function(time) {
h <- "(?:[01]?\\d|2[0-3])"
hm <- paste0(h, "(?::?[0-5]\\d)")
hms <- paste0(hm, "(?::?[0-5]\\d)")
hmsS <- paste0(hms, "(?:\\.\\d{1,9})?")
pattern <- paste(h, hm, hms, hmsS, sep = ")$|^(")
pattern <- paste0("^(", pattern, "$)")
if (!grepl(pattern, time)) {
# FIXME: this isn't necessarily true...
# colons aren't required, and neither are all of the components
stop("Supply time-of-day subsetting in the format of T%H:%M:%OS/T%H:%M:%OS",
call. = FALSE)
}
}
validateTimestring(fromTimeString)
validateTimestring(toTimeString)
getTimeComponents <- function(time) {
# split on decimal point
time. <- strsplit(time, ".", fixed = TRUE)[[1]]
hms <- time.[1L]
# ensure hms string has even nchar
nocolon <- gsub(":", "", hms, fixed = TRUE)
if (nchar(nocolon) %% 2 > 0) {
# odd nchar means leading zero is omitted from hours
# all other components require zero padding
hms <- paste0("0", hms)
}
# add colons
hms <- gsub("(.{2}):?", ":\\1", hms, perl = TRUE)
# remove first character (a colon)
hms <- substr(hms, 2, nchar(hms))
# extract components
comp <- strsplit(hms, ":", fixed = TRUE)[[1]]
complist <-
list(hour = comp[1L],
min = comp[2L],
sec = comp[3L],
subsec = time.[2L])
# remove all missing components
complist <- complist[!vapply(complist, is.na, logical(1))]
# convert to numeric
complist <- lapply(complist, as.numeric)
# add timezone and return
c(tz = "UTC", complist)
}
# first second in period (no subseconds)
from <- do.call(firstof, getTimeComponents(fromTimeString)[-5L])
secBegin <- as.numeric(from) %% 86400L
# last second in period
to <- do.call(lastof, getTimeComponents(toTimeString))
secEnd <- as.numeric(to) %% 86400L
# do subsetting
tz <- tzone(x)
secOfDay <- as.POSIXlt(index(x), tz = tz)
secOfDay <- secOfDay$hour * 60 * 60 + secOfDay$min * 60 + secOfDay$sec
if (secBegin <= secEnd) {
i <- secOfDay >= secBegin & secOfDay <= secEnd
} else {
i <- secOfDay >= secBegin | secOfDay <= secEnd
}
which(i)
}
.subset_xts <- function(x, i, j, ...) {
if(missing(i)) {
i <- 1:NROW(x)
}
if(missing(j)) {
j <- 1:NCOL(x)
}
.Call(C__do_subset_xts, x, i, j, FALSE)
}
#' Extract Subsets of xts Objects
#'
#' Details on efficient subsetting of xts objects for maximum performance
#' and compatibility.
#'
#' One of the primary motivations and key points of differentiation of xts is
#' the ability to subset rows by specifying ISO-8601 compatible range strings.
#' This allows for natural range-based time queries without requiring prior
#' knowledge of the underlying class used for the time index.
#'
#' When `i` is a character string, it is processed as an ISO-8601 formatted
#' datetime or time range using [`.parseISO8601()`]. A single datetime is
#' parsed from left to to right, according to the following specification:
#'
#' CCYYMMDD HH:MM:SS.ss+
#'
#' A time range can be specified by two datetimes separated by a forward slash
#' or double-colon. For example:
#'
#' CCYYMMDD HH:MM:SS.ss+/CCYYMMDD HH:MM:SS.ss
#'
#' The ISO8601 time range subsetting uses a custom binary search algorithm to
#' efficiently find the beginning and end of the time range. `i` can also be a
#' vector of ISO8601 time ranges, which enables subsetting by multiple
#' non-contiguous time ranges in one subset call.
#'
#' The above parsing, both for single datetimes and time ranges, will be done
#' on each element when `i` is a character *vector*. This is very inefficient,
#' especially for long vectors. In this case, it's recommened to use `I(i)` so
#' the xts subset function can process the vector more efficiently. Another
#' alternative is to convert `i` to POSIXct before passing it to the subset
#' function. See the examples for an illustration of using `I(i)`.
#'
#' The xts index is stored as POSIXct internally, regardless of the value of
#' its `tclass` attribute. So the fastest time-based subsetting is always when
#' `i` is a POSIXct vector.
#'
#' @param x An xts object.
#' @param i The rows to extract. Can be a numeric vector, time-based vector, or
#' an ISO-8601 style range string (see details).
#' @param j The columns to extract, either a numeric vector of column locations
#' or a character vector of column names.
#' @param drop Should dimension be dropped, if possible? See notes section.
#' @param which.i Logical value that determines whether a subset xts object is
#' returned (the default), or the locations of the matching rows (when
#' `which.i = TRUE`).
#' @param \dots Additional arguments (currently unused).
#'
#' @return An xts object containing the subset of `x`. When `which.i = TRUE`,
#' the corresponding integer locations of the matching rows is returned.
#'
#' @note By design, xts objects always have two dimensions. They cannot be
#' vectors like zoo objects. Therefore `drop = FALSE` by default in order to
#' preserve the xts object's dimensions. This is different from both matrix and
#' zoo, which use `drop = TRUE` by default. Explicitly setting `drop = TRUE`
#' may be needed when performing certain matrix operations.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`xts()`], [`.parseISO8601()`], [`.index()`]
#'
#' @references ISO 8601: Date elements and interchange formats - Information
#' interchange - Representation of dates and time
#'
#' @rdname subset.xts
#'
#' @aliases [.xts subset.xts .subset.xts .subset_xts
#' @keywords utilities
#' @examples
#'
#' x <- xts(1:3, Sys.Date()+1:3)
#' xx <- cbind(x,x)
#'
#' # drop = FALSE for xts, differs from zoo and matrix
#' z <- as.zoo(xx)
#' z/z[,1]
#'
#' m <- as.matrix(xx)
#' m/m[,1]
#'
#' # this will fail with non-conformable arrays (both retain dim)
#' tryCatch(
#' xx/x[,1],
#' error = function(e) print("need to set drop = TRUE")
#' )
#'
#' # correct way
#' xx/xx[,1,drop = TRUE]
#'
#' # or less efficiently
#' xx/drop(xx[,1])
#' # likewise
#' xx/coredata(xx)[,1]
#'
#'
#' x <- xts(1:1000, as.Date("2000-01-01")+1:1000)
#' y <- xts(1:1000, as.POSIXct(format(as.Date("2000-01-01")+1:1000)))
#'
#' x.subset <- index(x)[1:20]
#' x[x.subset] # by original index type
#' system.time(x[x.subset])
#' x[as.character(x.subset)] # by character string. Beware!
#' system.time(x[as.character(x.subset)]) # slow!
#' system.time(x[I(as.character(x.subset))]) # wrapped with I(), faster!
#'
#' x['200001'] # January 2000
#' x['1999/2000'] # All of 2000 (note there is no need to use the exact start)
#' x['1999/200001'] # January 2000
#'
#' x['2000/200005'] # 2000-01 to 2000-05
#' x['2000/2000-04-01'] # through April 01, 2000
#' y['2000/2000-04-01'] # through April 01, 2000 (using POSIXct series)
#'
#'
#' ### Time of day subsetting
#'
#' i <- 0:60000
#' focal_date <- as.numeric(as.POSIXct("2018-02-01", tz = "UTC"))
#' x <- .xts(i, c(focal_date + i * 15), tz = "UTC", dimnames = list(NULL, "value"))
#'
#' # Select all observations between 9am and 15:59:59.99999:
#' w1 <- x["T09/T15"] # or x["T9/T15"]
#' head(w1)
#'
#' # timestring is of the form THH:MM:SS.ss/THH:MM:SS.ss
#'
#' # Select all observations between 13:00:00 and 13:59:59.9999 in two ways:
#' y1 <- x["T13/T13"]
#' head(y1)
#'
#' x[.indexhour(x) == 13]
#'
#' # Select all observations between 9:30am and 30 seconds, and 4.10pm:
#' x["T09:30:30/T16:10"]
#'
#' # It is possible to subset time of day overnight.
#' # e.g. This is useful for subsetting FX time series which trade 24 hours on week days
#'
#' # Select all observations between 23:50 and 00:15 the following day, in the xts time zone
#' z <- x["T23:50/T00:14"]
#' z["2018-02-10 12:00/"] # check the last day
#'
#'
#' # Select all observations between 7pm and 8.30am the following day:
#' z2 <- x["T19:00/T08:29:59"]
#' head(z2); tail(z2)
#'
`[.xts` <-
function(x, i, j, drop = FALSE, which.i=FALSE,...)
{
USE_EXTRACT <- FALSE # initialize to FALSE
dimx <- dim(x)
if(is.null(dimx)) {
nr <- length(x)
if(nr==0 && !which.i) {
idx <- index(x)
if(length(idx) == 0) {
# this is an empty xts object (zero-length index and no columns)
# return it unchanged to match [.zoo
return(x)
} else {
return(xts(rep(NA, length(idx)), idx)[i])
}
}
nr <- length(.index(x))
nc <- 1L
} else {
nr <- dimx[1L]
nc <- dimx[2L]
}
if(!missing(i)) {
# test for negative subscripting in i
if (is.numeric(i)) {
# warn and convert if 'i' is not integer-like
i_int <- as.integer(i)
i_eps <- abs(i) - abs(i_int)
if (isTRUE(any(i_eps > sqrt(.Machine$double.eps)))) {
warning("converting 'i' to integer because it appears to contain fractions")
i <- i_int
}
#if(any(i < 0)) {
if(.Call(C_any_negative, i)) {
if(!all(i <= 0))
stop('only zeros may be mixed with negative subscripts')
i <- (1:nr)[i]
}
# check boundary; length check avoids Warning from max(), and
# any_negative ensures no NA (as of r608)
#if(max(i) > nr)
if(length(i) > 0 && max(i) > nr)
stop('subscript out of bounds')
#i <- i[-which(i == 0)]
} else
if (timeBased(i) || (inherits(i, "AsIs") && is.character(i)) ) {
# Fast binary search on set of dates
i <- window_idx(x, index. = i)
} else
if(is.logical(i)) {
i <- which(i) #(1:NROW(x))[rep(i,length.out=NROW(x))]
} else
if (is.character(i)) {
time.of.day.pattern <- "(^/T)|(^T.*?/T)|(^T.*/$)"
if (length(i) == 1 && !identical(integer(), grep(time.of.day.pattern, i[1]))) {
# time of day subsetting
ii <- gsub("T", "", i, fixed = TRUE)
ii <- strsplit(ii, "/", fixed = TRUE)[[1L]]
if (length(ii) == 1) {
# i is right open ended (T.*/)
ii <- c(ii, "23:59:59.999999999")
} else if (nchar(ii[1L]) == 0) {
# i is left open ended (/T)
ii[1L] <- "00:00:00.000000000"
} # else i is bounded on both sides (T.*/T.*)
i <- .subsetTimeOfDay(x, ii[1L], ii[2L])
} else {
# enables subsetting by date style strings
# must be able to process - and then allow for operations???
i.tmp <- NULL
tz <- as.character(tzone(x))
for(ii in i) {
adjusted.times <- .parseISO8601(ii, .index(x)[1], .index(x)[nr], tz=tz)
if(length(adjusted.times) > 1) {
i.tmp <- c(i.tmp, index_bsearch(.index(x), adjusted.times$first.time, adjusted.times$last.time))
}
}
i <- i.tmp
}
i_len <- length(i)
if(i_len == 1L) # IFF we are using ISO8601 subsetting
USE_EXTRACT <- TRUE
}
if(!isOrdered(i,strictly=FALSE)) {
i <- sort(i)
}
# subset is picky, 0's in the 'i' position cause failures
zero.index <- binsearch(0L, i, FALSE)
if(!is.na(zero.index)) {
# at least one 0; binsearch returns location of last 0
i <- i[-(1L:zero.index)]
}
if(length(i) <= 0 && USE_EXTRACT)
USE_EXTRACT <- FALSE
if(which.i)
return(i)
} # if(!missing(i)) { end
if (missing(j)) {
if(missing(i))
i <- seq_len(nr)
if(length(x)==0) {
cdata <- rep(NA, length(i))
storage.mode(cdata) <- storage.mode(x)
x.tmp <- .xts(cdata, .index(x)[i], tclass(x), tzone(x),
dimnames = list(NULL, colnames(x)))
return(x.tmp)
} else {
if(USE_EXTRACT) {
return(.Call(C_extract_col,
x, as.integer(1:nc),
drop,
as.integer(i[1]), as.integer(i[length(i)])))
} else {
return(.Call(C__do_subset_xts,
x, as.integer(i),
as.integer(1:nc),
drop))
}
}
} else
# test for negative subscripting in j
if (is.numeric(j)) {
# warn and convert if 'j' is not integer-like
j_int <- as.integer(j)
j_eps <- abs(j) - abs(j_int)
if (isTRUE(any(j_eps > sqrt(.Machine$double.eps)))) {
warning("converting 'j' to integer because it appears to contain fractions")
j <- j_int
}
if(min(j,na.rm=TRUE) < 0) {
if(max(j,na.rm=TRUE) > 0)
stop('only zeros may be mixed with negative subscripts')
j <- (1:nc)[j]
}
if(max(j,na.rm=TRUE) > nc)
stop('subscript out of bounds')
} else
if(is.logical(j)) {
if(length(j) == 1) {
j <- (1:nc)[rep(j, nc)]
}
else if (length(j) > nc) {
stop("(subscript) logical subscript too long")
} else j <- (1:nc)[j]
} else
if(is.character(j)) {
j <- match(j, colnames(x), nomatch=0L)
# ensure all j are in colnames(x)
if(any(j==0))
stop("subscript out of bounds")
}
j0 <- which(!as.logical(j))
if(length(j0))
j <- j[-j0]
if(length(j) == 0 || (length(j)==1 && (is.na(j) || j==0))) {
if(missing(i))
i <- seq_len(nr)
output <- .xts(coredata(x)[i,j,drop=FALSE], .index(x)[i],
tclass(x), tzone(x), class = class(x))
xtsAttributes(output) <- xtsAttributes(x)
return(output)
}
if(missing(i))
return(.Call(C_extract_col, x, as.integer(j), drop, 1, nr))
if(USE_EXTRACT) {
return(.Call(C_extract_col,
x, as.integer(j),
drop,
as.integer(i[1]), as.integer(i[length(i)])))
} else
return(.Call(C__do_subset_xts, x, as.integer(i), as.integer(j), drop))
}
`.subset.xts` <- `[.xts`
# Replacement method for xts objects
#
# Adapted from [.xts code, making use of NextGeneric as
# replacement function in R already preserves all attributes
# and index value is left untouched
`[<-.xts` <-
#`xtsreplacement` <-
function(x, i, j, value)
{
if (!missing(i)) {
i <- x[i, which.i=TRUE]
}
.Class <- "matrix"
NextMethod(.Generic)
}
# Convert a character or time type to POSIXct for use by subsetting and window
# We make this an explicit function so that subset and window will convert dates consistently.
.toPOSIXct <-
function(i, tz) {
if(inherits(i, "POSIXct")) {
dts <- i
} else if(is.character(i)) {
dts <- as.POSIXct(as.character(i),tz=tz) # Need as.character because i could be AsIs from I(dates)
} else if (timeBased(i)) {
if(inherits(i, "Date")) {
dts <- as.POSIXct(as.character(i),tz=tz)
} else {
# force all other time classes to be POSIXct
dts <- as.POSIXct(i,tz=tz)
}
} else {
stop("invalid time / time based class")
}
dts
}
# find the rows of index. where the date is in [start, end].
# use binary search.
# convention is that NA start or end returns empty
index_bsearch <- function(index., start, end)
{
if(!is.null(start) && is.na(start)) return(NULL)
if(!is.null(end) && is.na(end)) return(NULL)
if(is.null(start)) {
si <- 1
} else {
si <- binsearch(start, index., TRUE)
}
if(is.null(end)) {
ei <- length(index.)
} else {
ei <- binsearch(end, index., FALSE)
}
if(is.na(si) || is.na(ei) || si > ei) return(NULL)
firstlast <- seq.int(si, ei)
firstlast
}
# window function for xts series
# return indexes in x matching dates
window_idx <- function(x, index. = NULL, start = NULL, end = NULL)
{
if(is.null(index.)) {
usr_idx <- FALSE
index. <- .index(x)
} else {
# Translate the user index to the xts index
usr_idx <- TRUE
idx <- .index(x)
index. <- .toPOSIXct(index., tzone(x))
index. <- unclass(index.)
index. <- index.[!is.na(index.)]
if(is.unsorted(index.)) {
# index. must be sorted for index_bsearch
# N.B!! This forces the returned values to be in ascending time order, regardless of the ordering in index, as is done in subset.xts.
index. <- sort(index.)
}
# Fast search on index., faster than binsearch if index. is sorted (see findInterval)
base_idx <- findInterval(index., idx)
base_idx <- pmax(base_idx, 1L)
# Only include indexes where we have an exact match in the xts series
match <- idx[base_idx] == index.
base_idx <- base_idx[match]
index. <- index.[match]
index. <- .POSIXct(index., tz = tzone(x))
if(length(base_idx) < 1) return(x[NULL,])
}
if(!is.null(start)) {
start <- .toPOSIXct(start, tzone(x))
}
if(!is.null(end)) {
end <- .toPOSIXct(end, tzone(x))
}
firstlast <- index_bsearch(index., start, end)
if(usr_idx && !is.null(firstlast)) {
# Translate from user .index to xts index
# We get back upper bound of index as per findInterval
tmp <- base_idx[firstlast]
res <- .Call(C_fill_window_dups_rev, tmp, .index(x))
firstlast <- rev(res)
}
firstlast
}
# window function for xts series, use binary search to be faster than base zoo function
# index. defaults to the xts time index. If you use something else, it must conform to the standard for order.by in the xts constructor.
# that is, index. must be time based,
#' Extract Time Windows from xts Objects
#'
#' Method for extracting time windows from xts objects.
#'
#' The xts `window()` method provides an efficient way to subset an xts object
#' between a start and end date using a binary search algorithm. Specifically,
#' it converts `start` and `end` to POSIXct and then does a binary search of
#' the index to quickly return a subset of `x` between `start` and `end`.
#'
#' Both `start` and `end` may be any class that is convertible to POSIXct, such
#' as a character string in the format \sQuote{yyyy-mm-dd}. When `start = NULL`
#' the returned subset will begin at the first value of `index.`. When
#' `end = NULL` the returned subset will end with the last value of `index.`.
#' Otherwise the subset will contain all timestamps where `index.` is between
#' `start` and `end`, inclusive.
#'
#' When `index.` is specified, [`findInterval()`] is used to quickly retrieve
#' large sets of sorted timestamps. For the best performance, `index.` must be
#' a *sorted* POSIXct vector or a numeric vector of seconds since the epoch.
#' `index.` is typically a subset of the timestamps in `x`.
#'
#' @param x An xts object.
#' @param index. A user defined time index (default `.index(x)`).
#' @param start A start time coercible to POSIXct.
#' @param end An end time coercible to POSIXct.
#' @param \dots Unused.
#'
#' @return The subset of `x` that matches the time window.
#'
#' @author Corwin Joy
#'
#' @seealso [`subset.xts()`], [`findInterval()`], [`xts()`]
#'
#' @keywords ts
#' @examples
#'
#' ## xts example
#' x.date <- as.Date(paste(2003, rep(1:4, 4:1), seq(1,19,2), sep = "-"))
#' x <- xts(matrix(rnorm(20), ncol = 2), x.date)
#' x
#'
#' window(x, start = "2003-02-01", end = "2003-03-01")
#' window(x, start = as.Date("2003-02-01"), end = as.Date("2003-03-01"))
#' window(x, index. = x.date[1:6], start = as.Date("2003-02-01"))
#' window(x, index. = x.date[c(4, 8, 10)])
#'
#' ## Assign to subset
#' window(x, index. = x.date[c(4, 8, 10)]) <- matrix(1:6, ncol = 2)
#' x
#'
window.xts <- function(x, index. = NULL, start = NULL, end = NULL, ...)
{
# scalar NA values are treated as NULL
if (isTRUE(is.na(start))) start <- NULL
if (isTRUE(is.na(end))) end <- NULL
if(is.null(start) && is.null(end) && is.null(index.)) return(x)
# dispatch to window.zoo() for yearmon and yearqtr
if(any(tclass(x) %in% c("yearmon", "yearqtr"))) {
return(NextMethod(.Generic))
}
firstlast <- window_idx(x, index., start, end) # firstlast may be NULL
.Call(C__do_subset_xts,
x, as.integer(firstlast),
seq.int(1, ncol(x)),
drop = FALSE)
}
# Declare binsearch to call the routine in binsearch.c
binsearch <- function(key, vec, start=TRUE) {
# Convert to double if both are not integer
if (storage.mode(key) != storage.mode(vec)) {
storage.mode(key) <- storage.mode(vec) <- "double"
}
.Call(C_binsearch, key, vec, start)
}
xts/R/tformat.R 0000644 0001762 0000144 00000006206 14702273713 013102 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Get or Replace the Format of an xts Object's Index
#'
#' Generic functions to get or replace the format that determines how an xts
#' object's index is printed.
#'
#' Valid values for the `value` argument are the same as specified in the
#' *Details* section of [`strptime()`].
#'
#' An xts object's `tformat` is `NULL` by default, so the index will be
#' be formatted according to its [`tclass()`] (e.g. Date, POSIXct, timeDate,
#' yearmon, etc.).
#'
#' The `tformat` only changes how the index is *printed* and how the row names
#' are formatted when xts objects are converted to other classes (e.g. matrix
#' or data.frame). It does not affect the internal index in any way.
#'
#' @param x An xts object.
#' @param value New index format string (see [`strptime()`] details for valid
#' values).
#' @param \dots Arguments passed to other methods.
#'
#' @return A vector containing the format for the object's index.
#'
#' @note Both `indexFormat()` and `indexFormat<-` are deprecated in
#' favor of `tformat()` and `tformat<-`, respectively.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`index()`][xts::index.xts] has more information on the xts index, [`tclass()`]
#' details how \pkg{xts} handles the class of the index, [`tzone()`] has more
#' information about the index timezone settings.
#'
#' @keywords ts utilities
#' @examples
#'
#' x <- timeBasedSeq('2010-01-01/2010-01-02 12:00')
#' x <- xts(seq_along(x), x)
#'
#' # set a custom index format
#' head(x)
#' tformat(x) <- "%Y-%b-%d %H:%M:%OS3"
#' head(x)
#'
`tformat` <-
function(x, ...) {
UseMethod('tformat')
}
#' @rdname tformat
`tformat<-` <-
function(x, value) {
UseMethod('tformat<-')
}
`tformat.default` <-
function(x, ...) {
attr(x, 'tformat')
}
`tormat<-.default` <-
function(x, value) {
attr(x, '.tformat') <- value
x
}
`tformat.xts` <-
function(x, ...) {
ix <- .index(x)
attr(ix, 'tformat')
}
`tformat<-.xts` <-
function(x, value) {
if(!is.character(value) && !is.null(value))
stop('must provide valid POSIX formatting string')
# Remove format attrs (object created before 0.10-3)
attr(x, ".indexFORMAT") <- NULL
attr(attr(x, 'index'), 'tformat') <- value
x
}
#' @rdname tformat
`indexFormat` <-
function(x) {
.Deprecated("tformat", "xts")
tformat(x)
}
#' @rdname tformat
`indexFormat<-` <-
function(x, value) {
.Deprecated("tformat<-", "xts")
`tformat<-`(x, value)
}
xts/R/bind.R 0000644 0001762 0000144 00000005420 14654242576 012350 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname rbind.xts
`c.xts` <-
function(...) {
.External(C_rbindXts, dup=FALSE, ...)
}
#' Concatenate Two or More xts Objects by Row
#'
#' Concatenate or bind by row two or more xts objects along a time-based index.
#' All objects must have the same number of columns and be xts objects or
#' coercible to xts.
#'
#' Duplicate index values are supported. When one or more input has the same
#' index value, the duplicated index values in the result are in the same order
#' the objects are passed to `rbind()`. See examples.
#'
#' `c()` is an alias for `rbind()` for xts objects.
#'
#' See [`merge.xts()`] for traditional merge operations.
#'
#' @param \dots Objects to bind by row.
#' @param deparse.level Not implemented.
#'
#' @return An xts object with one row per row for each object concatenated.
#'
#' @note `rbind()` is a '.Primitive' function in \R, which means method dispatch
#' occurs at the C-level, and may not be consistent with normal S3 method
#' dispatch (see [`rbind()`] for details). Call `rbind.xts()` directly to
#' avoid potential dispatch ambiguity.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`merge.xts()`] [`rbind()`]
#'
#' @keywords utilities
#' @examples
#'
#' x <- xts(1:10, Sys.Date()+1:10)
#' str(x)
#'
#' merge(x,x)
#' rbind(x,x)
#' rbind(x[1:5],x[6:10])
#'
#' c(x,x)
#'
#' # this also works on non-unique index values
#' x <- xts(rep(1,5), Sys.Date()+c(1,2,2,2,3))
#' y <- xts(rep(2,3), Sys.Date()+c(1,2,3))
#'
#' # overlapping indexes are appended
#' rbind(x,y)
#' rbind(y,x)
#'
rbind.xts <- function(..., deparse.level=1)
{
.External(C_rbindXts, dup=FALSE, ...)
}
`.rbind.xts` <-
function(..., deparse.level=1) {
dots <- list(...)
if(length(dots) < 2) return(dots[[1]])
x <- dots[[1]]
dots <- dots[-1]
while( length(dots) > 0 ) {
y <- dots[[1]]
if( length(dots) > 0)
dots <- dots[-1]
if(!is.null(colnames(y)) && colnames(x) != colnames(y))
warning('column names differ')
x <- .Call(C_do_rbind_xts,x,y,FALSE)
}
return(x)
}
xts/R/lag.xts.R 0000644 0001762 0000144 00000011412 14702273514 013000 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname diff.xts
lag.xts <- function(x, k=1, na.pad=TRUE, ...) {
zooCompat <- getOption('xts.compat.zoo.lag')
if(is.logical(zooCompat) && zooCompat) {
k <- -k
if(missing(na.pad)) na.pad <- FALSE
}
if(length(k) > 1) {
if(is.null(names(k)))
names(k) <- paste("lag",k,sep="")
return(do.call("merge.xts", lapply(k, lag.xts, x=x, na.pad=na.pad,...)))
}
.Call(C_lag_xts, x, k, na.pad)
}
lagts.xts <- function(x, k=1, na.pad=TRUE, ...) {
# NOTE: not exported
if(length(k) > 1) {
if(is.null(names(k)))
names(k) <- paste("lag",k,sep="")
return(do.call("merge.xts", lapply(k, lag.xts, x=x, na.pad=na.pad,...)))
}
.Call(C_lag_xts, x, k, na.pad)
}
#' Lags and Differences of xts Objects
#'
#' Methods for computing lags and differences on xts objects. This provides
#' similar functionality as the \pkg{zoo} counterparts, but with some different
#' defaults.
#'
#' The primary motivation for these methods was to take advantage of a faster
#' C-level implementation. Another motivation was to make `lag()` behave using
#' standard sign for `k`. Both [zoo's lag() method][zoo::lag.zoo] and [`lag.default()`] require a
#' *negative* value for `k` in order to shift a series backward. So `k = 1`,
#' shifts the series *forward* one observation. This is especially confusing
#' because `k = 1` is the default for those functions. When `x` is an xts
#' object, `lag(x, 1)` returns an object where the value at time 't' is the
#' value at time 't-1' in the original object.
#'
#' Another difference is that `na.pad = TRUE` by default, to better reflect the
#' transformation visually and for functions the require positional alignment
#' of data.
#'
#' Set `options(xts.compat.zoo.lag = TRUE)` to use make `lag.xts()` consistent
#' with `lag.zoo()` by reversing the sign of `k` and setting `na.pad = FALSE`.
#'
#' @param x An xts object.
#' @param k Number of periods to shift.
#' @param lag Period to difference over.
#' @param differences Order of differencing.
#' @param arithmetic Should arithmetic or geometric differencing be used?
#' @param log Should (geometric) log differences be returned?
#' @param na.pad Should `NA` be added so the result has the same number of
#' observations as `x`?
#' @param \dots Additional arguments.
#'
#' @return An xts object with the desired lag and/or differencing.
#'
#' @author Jeffrey A. Ryan
#'
#' @references
#'
#' @keywords manip chron
#' @examples
#'
#' x <- xts(1:10, Sys.Date()+1:10)
#' lag(x) # currently using xts-style positive k
#'
#' lag(x, k=2)
#'
#' lag(x, k=-1, na.pad=FALSE) # matches lag.zoo(x, k=1)
#'
#' diff(x)
#' diff(x, lag=1)
#' diff(x, diff=2)
#' diff(diff(x))
#'
diff.xts <- function(x, lag=1, differences=1, arithmetic=TRUE, log=FALSE, na.pad=TRUE, ...)
{
if(!is.integer(lag) && any(is.na(as.integer(lag))))
stop("'lag' must be integer")
differences <- as.integer(differences[1L])
if(is.na(differences))
stop("'differences' must be integer")
if(is.logical(x)) {
x <- .xts(matrix(as.integer(x), ncol=NCOL(x)), .index(x),
tclass(x), dimnames=dimnames(x))
}
if(lag < 1 || differences < 1)
stop("'diff.xts' defined only for positive lag and differences arguments")
zooCompat <- getOption('xts.compat.zoo.lag')
if(is.logical(zooCompat) && zooCompat) {
# this has to negated to satisfy the test in lag.xts... oh my
lag <- -lag
if(missing(na.pad)) na.pad <- FALSE
}
if(differences > 1) {
if(arithmetic && !log) { #log is FALSE or missing
x <- x - lag.xts(x, k=lag, na.pad=na.pad)
} else {
if(log) {
x <- log(x/lag.xts(x, k=lag, na.pad=na.pad))
} else x <- x/lag.xts(x, k=lag, na.pad=na.pad)
}
diff(x, lag, differences=differences-1, arithmetic=arithmetic, log=log, na.pad=na.pad, ...)
} else {
if(arithmetic && !log) {
x - lag.xts(x, k=lag, na.pad=na.pad)
} else {
if(log) {
log(x/lag.xts(x, k=lag, na.pad=na.pad))
} else x/lag.xts(x, k=lag, na.pad=na.pad)
}
}
}
xts/R/as.numeric.R 0000644 0001762 0000144 00000011062 14654242576 013477 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
as.numeric.xts <- function(x, drop=TRUE, ...)
{
if(drop)
return(as.numeric(coredata(x)))
.xts(matrix(as.numeric(coredata(x)),ncol=NCOL(x)), .index(x))
}
as.xts.numeric <-
function(x,order.by,dateFormat="POSIXct",frequency=NULL,...) {
# jmu
if(missing(order.by)) {
if(is.null(names(x)))
stop("order.by must be either 'names()' or otherwise specified")
else
# added '...' args to allow for tz specification
order.by <- do.call(paste('as',dateFormat,sep='.'),list(names(x)))
}
xx <- xts(x, order.by=order.by, frequency=frequency,
.CLASS='numeric', ...)
return(xx)
}
re.numeric <-
function(x,...) {
if( !is.null(dim(x)))
return(as.matrix(x))
# jmu
y <- as.numeric(x,...)
names(y) <- index(x)
return(y)
}
as.integer.xts <- function(x, drop=TRUE, ...)
{
if(drop)
return(as.integer(coredata(x)))
.xts(matrix(as.integer(coredata(x)),ncol=NCOL(x)), .index(x))
}
as.xts.integer <-
function(x,order.by,dateFormat="POSIXct",frequency=NULL,...) {
# jmu
if(missing(order.by)) {
if(is.null(names(x)))
stop("order.by must be either 'names()' or otherwise specified")
else
# added '...' args to allow for tz specification
order.by <- do.call(paste('as',dateFormat,sep='.'),list(names(x)))
}
xx <- xts(x, order.by=order.by, frequency=frequency,
.CLASS='integer', ...)
return(xx)
}
re.integer <-
function(x,...) {
if( !is.null(dim(x)))
return(as.matrix(x))
# jmu
y <- as.integer(x,...)
names(y) <- index(x)
return(y)
}
as.double.xts <- function(x, drop=TRUE, ...)
{
if(drop)
return(as.double(coredata(x)))
.xts(matrix(as.double(coredata(x)),ncol=NCOL(x)), .index(x))
}
as.xts.double <-
function(x,order.by,dateFormat="POSIXct",frequency=NULL,...) {
# jmu
if(missing(order.by)) {
if(is.null(names(x)))
stop("order.by must be either 'names()' or otherwise specified")
else
# added '...' args to allow for tz specification
order.by <- do.call(paste('as',dateFormat,sep='.'),list(names(x)))
}
xx <- xts(x, order.by=order.by, frequency=frequency,
.CLASS='double', ...)
return(xx)
}
re.double <-
function(x,...) {
if( !is.null(dim(x)))
return(as.matrix(x))
# jmu
y <- as.double(x,...)
names(y) <- index(x)
return(y)
}
as.complex.xts <- function(x, drop=TRUE, ...)
{
if(drop)
return(as.complex(coredata(x)))
.xts(matrix(as.complex(coredata(x)),ncol=NCOL(x)), .index(x))
}
as.xts.complex <-
function(x,order.by,dateFormat="POSIXct",frequency=NULL,...) {
# jmu
if(missing(order.by)) {
if(is.null(names(x)))
stop("order.by must be either 'names()' or otherwise specified")
else
# added '...' args to allow for tz specification
order.by <- do.call(paste('as',dateFormat,sep='.'),list(names(x)))
}
xx <- xts(x, order.by=order.by, frequency=frequency,
.CLASS='complex', ...)
return(xx)
}
re.complex <-
function(x,...) {
if( !is.null(dim(x)))
return(as.matrix(x))
# jmu
y <- as.complex(x,...)
names(y) <- index(x)
return(y)
}
as.logical.xts <- function(x, drop=TRUE, ...)
{
if(drop)
return(as.logical(coredata(x)))
.xts(matrix(as.logical(coredata(x)),ncol=NCOL(x)), .index(x))
}
as.xts.logical <-
function(x,order.by,dateFormat="POSIXct",frequency=NULL,...) {
# jmu
if(missing(order.by)) {
if(is.null(names(x)))
stop("order.by must be either 'names()' or otherwise specified")
else
# added '...' args to allow for tz specification
order.by <- do.call(paste('as',dateFormat,sep='.'),list(names(x)))
}
xx <- xts(x, order.by=order.by, frequency=frequency,
.CLASS='logical', ...)
return(xx)
}
re.logical <-
function(x,...) {
if( !is.null(dim(x)))
return(as.matrix(x))
# jmu
y <- as.logical(x,...)
names(y) <- index(x)
return(y)
}
xts/R/align.time.R 0000644 0001762 0000144 00000011632 14654242576 013465 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Align seconds, minutes, and hours to beginning of next period.
#'
#' Change timestamps to the start of the next period, specified in multiples of
#' seconds.
#'
#' This function is an S3 generic. The result is to round up to the next period
#' determined by 'n modulo x'.
#'
#' @param x Object containing timestamps to align.
#' @param n Number of seconds to adjust by.
#' @param \dots Additional arguments. See details.
#'
#' @return A new object with the same class as `x`.
#'
#' @author Jeffrey A. Ryan with input from Brian Peterson
#'
#' @seealso [`to.period()`]
#'
#' @keywords chron manip ts misc
#' @examples
#'
#' x <- Sys.time() + 1:1000
#'
#' # every 10 seconds
#' align.time(x, 10)
#'
#' # align to next whole minute
#' align.time(x, 60)
#'
#' # align to next whole 10 min interval
#' align.time(x, 10 * 60)
#'
align.time <- function(x, ...) {
UseMethod("align.time")
}
#' @rdname align.time
align.time.xts <- function(x, n=60, ...) {
if(n <= 0) stop("'n' must be positive")
.xts(x, .index(x) + (n-.index(x) %% n), tzone=tzone(x), tclass=tclass(x))
}
align.time.POSIXct <- function(x, n=60, ...) {
if(n <= 0) stop("'n' must be positive")
structure(unclass(x) + (n - unclass(x) %% n),class=c("POSIXct","POSIXt"))
}
align.time.POSIXlt <- function(x, n=60, ...) {
if(n <= 0) stop("'n' must be positive")
as.POSIXlt(align.time(as.POSIXct(x),n=n,...))
}
#' @rdname align.time
shift.time <- function(x, n=60, ...) {
UseMethod("shift.time")
}
shift.time.xts <- function(x, n=60, ...) {
.xts(x, .index(x) + n, tzone=tzone(x), tclass=tclass(x))
}
#' @rdname make.index.unique
is.index.unique <- function(x) {
UseMethod("is.time.unique")
}
#' @rdname make.index.unique
is.time.unique <- is.index.unique
is.time.unique.xts <- function(x) {
isOrdered(.index(x), strictly=TRUE)
}
is.time.unique.zoo <- function(x) {
isOrdered(index(x), strictly=TRUE)
}
#' Force Time Values To Be Unique
#'
#' A generic function to force sorted time vectors to be unique. Useful for
#' high-frequency time-series where original time-stamps may have identical
#' values. For the case of xts objects, the default `eps` is set to ten
#' microseconds. In practice this advances each subsequent identical time by
#' `eps` over the previous (possibly also advanced) value.
#'
#' The returned time-series object will have new time-stamps so that
#' `isOrdered(.index(x))` evaluates to `TRUE`.
#'
#' @param x An xts object, or POSIXct vector.
#' @param eps A value to add to force uniqueness.
#' @param drop Should duplicates be dropped instead of adjusted by `eps`?
#' @param fromLast When `drop = TRUE`, `fromLast` controls which duplicated
#' times are dropped. When `fromLast = FALSE`, the earliest observation with
#' an identical timestamp is kept and subsequent observations are dropped.
#' @param \dots Unused.
#'
#' @return A modified version of `x` with unique timestamps.
#'
#' @note Incoming values must be pre-sorted, and no check is done to make sure
#' that this is the case. \sQuote{integer} index value will be coerced to
#' \sQuote{double} when `drop = FALSE`.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`align.time()`]
#'
#' @rdname make.index.unique
#' @keywords ts
#' @examples
#'
#' ds <- options(digits.secs=6) # so we can see the change
#'
#' x <- xts(1:10, as.POSIXct("2011-01-21") + c(1,1,1,2:8)/1e3)
#' x
#' make.index.unique(x)
#'
#' options(ds)
#'
make.index.unique <- function(x, eps=0.000001, drop=FALSE, fromLast=FALSE, ...) {
UseMethod("make.index.unique")
}
#' @rdname make.index.unique
make.time.unique <- make.index.unique
make.index.unique.xts <- function(x, eps=0.000001, drop=FALSE, fromLast=FALSE, ...) {
if( !drop) {
.Call(C_make_index_unique, x, eps)
} else {
x[.Call(C_non_duplicates, .index(x), fromLast)]
}
}
make.index.unique.numeric <- function(x, eps=0.000001, drop=FALSE, fromLast=FALSE, ...) {
if( !drop) {
.Call(C_make_unique, x, eps)
} else {
x[.Call(C_non_duplicates, x, fromLast)]
}
}
make.index.unique.POSIXct <- function(x, eps=0.000001, drop=FALSE, fromLast=FALSE, ...) {
if( !drop) {
.Call(C_make_unique, x, eps)
} else {
x[.Call(C_non_duplicates, x, fromLast)]
}
}
xts/R/Date.R 0000644 0001762 0000144 00000001564 14654242576 012316 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' @rdname as.xts
`as.xts.Date` <- function(x,...) {
xts(x=NULL,order.by=x,...)
}
xts/R/modify.args.R 0000644 0001762 0000144 00000003772 14654242576 013666 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2009-2015 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Ross Bennett and Joshua M. Ulrich
#
# 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, see .
modify.args <- function(formals, arglist, ..., dots=FALSE)
{
# modify.args function from quantstrat
# avoid evaluating '...' to make things faster
dots.names <- eval(substitute(alist(...)))
if(missing(arglist))
arglist <- NULL
arglist <- c(arglist, dots.names)
# see 'S Programming' p. 67 for this matching
# nothing to do if arglist is empty; return formals as a list
if(!length(arglist))
return(as.list(formals))
argnames <- names(arglist)
if(!is.list(arglist) && !is.null(argnames) && !any(argnames == ""))
stop("'arglist' must be a *named* list, with no names == \"\"")
.formals <- formals
onames <- names(.formals)
pm <- pmatch(argnames, onames, nomatch = 0L)
#if(any(pm == 0L))
# message(paste("some arguments stored for", fun, "do not match"))
names(arglist[pm > 0L]) <- onames[pm]
.formals[pm] <- arglist[pm > 0L]
# include all elements from arglist if function formals contain '...'
if(dots && !is.null(.formals$...)) {
dotnames <- names(arglist[pm == 0L])
.formals[dotnames] <- arglist[dotnames]
#.formals$... <- NULL # should we assume we matched them all?
}
# return a list (not a pairlist)
as.list(.formals)
}
xts/R/tclass.R 0000644 0001762 0000144 00000013422 14702273705 012716 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Get or Replace the Class of an xts Object's Index
#'
#' Generic functions to get or replace the class of an xts object's index.
#'
#' Internally, an xts object's index is a *numeric* value corresponding to
#' seconds since the epoch in the UTC timezone. The index class is stored as
#' the `tclass` attribute on the internal index. This is used to convert
#' the internal index values to the desired class when the `index`
#' function is called.
#'
#' The `tclass` function retrieves the class of the internal index, and
#' the `tclass<-` function sets it. The specified value for
#' `tclass<-` must be one of the following character strings:
#' `"Date"`, `"POSIXct"`, `"chron"`, `"yearmon"`,
#' `"yearqtr"`, or `"timeDate"`.
#'
#' @param x An xts object.
#' @param value The new index class (see Details for valid values).
#' @param \dots Arguments passed to other methods.
#'
#' @return A vector containing the class of the object's index.
#'
#' @note Both `indexClass` and `indexClass<-` are deprecated in favor
#' of `tclass` and `tclass<-`, respectively.
#'
#' Replacing the `tclass` can *potentially change* the values of the internal
#' index. For example, changing the 'tclass' from POSIXct to Date will
#' truncate the POSIXct value and convert the timezone to UTC (since the Date
#' class doesn't have a timezone). See the examples.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`index()`][xts::index.xts] has more information on the xts index, [`tformat()`]
#' details how the index values are formatted when printed, and [`tzone()`]
#' has more information about the index timezone settings.
#'
#' The following help pages describe the characteristics of the valid index
#' classes: [`POSIXct()`], [`Date()`], [chron()][chron::chron],
#' [`yearmon()`][zoo::zoo], [`yearqtr()`][zoo::zoo],
#' [`timeDate()`][timeDate::timeDate]
#'
#' @keywords ts utilities
#' @examples
#'
#' x <- timeBasedSeq('2010-01-01/2010-01-02 12:00')
#' x <- xts(seq_along(x), x)
#'
#' y <- timeBasedSeq('2010-01-01/2010-01-03 12:00/H')
#' y <- xts(seq_along(y), y, tzone = "America/New_York")
#'
#' # Changing the tclass *changes* the internal index values
#' head(y) # the index has times
#' head(.index(y))
#' tclass(y) <- "Date"
#' head(y) # the index prints as a Date
#' head(.index(y)) # the internal index is truncated
#'
tclass <-
function(x, ...) {
UseMethod('tclass')
}
#' @rdname tclass
tclass.default <-
function(x, ...)
{
attr(x, "tclass")
}
#' @rdname tclass
tclass.xts <-
function(x, ...)
{
tclass <- attr(attr(x, "index"), "tclass")
# For xts objects created pre-0.10.3
if (is.null(tclass)) {
# no tclass on the index
sq_tclass <- sQuote("tclass")
sq_both <- paste(sq_tclass, "or", sQuote(".indexCLASS"))
warn_msg <-
paste0("index does not have a ", sq_tclass, " attribute")
tclass <- attr(x, "tclass")
if (is.null(tclass)) {
# no tclass on the xts object, look for .indexCLASS
tclass <- attr(x, ".indexCLASS")
}
if (is.null(tclass)) {
# no .indexCLASS on the xts object
tc <- c("POSIXct", "POSIXt")
warn_msg <- paste0(warn_msg, "\n and xts object does not have a ",
sq_both, " attribute\n", " returning ", dQuote(tc))
warning(warn_msg)
return(tc)
}
sym <- deparse(substitute(x))
warning(warn_msg, "\n use ", sym,
" <- xts:::.update_index_attributes(", sym, ") to update the object")
}
return(tclass)
}
#' @rdname tclass
`tclass<-` <-
function(x,value) {
UseMethod('tclass<-')
}
#' @rdname tclass
`tclass<-.default` <-
function(x, value)
{
if (!is.null(value)) {
value <- as.character(value)
}
attr(x, "tclass") <- value
x
}
#' @rdname tclass
indexClass <-
function(x) {
.Deprecated("tclass", "xts")
tclass(x)
}
#' @rdname tclass
`indexClass<-` <-
function(x, value) {
.Deprecated("tclass<-", "xts")
`tclass<-`(x, value)
}
#' @rdname tclass
`tclass<-.xts` <-
function(x, value) {
if(!is.character(value) && length(value) != 1)
stop('improperly specified value for tclass')
# remove 'POSIXt' from value, to prevent tclass(x) <- 'POSIXt'
value <- value[!value %in% "POSIXt"]
if(length(value)==0L)
stop(paste('unsupported',sQuote('tclass'),'indexing type: POSIXt'))
if(!value[1] %in% c('dates','chron','POSIXlt','POSIXct','Date','timeDate','yearmon','yearqtr','xtime') )
stop(paste('unsupported',sQuote('tclass'),'indexing type:',as.character(value[[1]])))
# Add 'POSIXt' virtual class
if(value %in% c('POSIXlt','POSIXct'))
value <- c(value,'POSIXt')
# all index related meta-data will be stored in the index
# as attributes
if(isClassWithoutTZ(value)) {
attr(attr(x,'index'), 'tzone') <- 'UTC'
}
attr(attr(x,'index'), 'tclass') <- value
x_has_tz <- !isClassWithoutTZ(x)
if(x_has_tz && isClassWithoutTZ(value)) {
# update index values to midnight UTC (this also changes the tzone)
index(x) <- index(x)
}
# Remove class attrs (object created before 0.10-3)
attr(x, ".indexCLASS") <- NULL
attr(x, "tclass") <- NULL
x
}
xts/R/split.R 0000644 0001762 0000144 00000006326 14702273624 012565 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Divide into Groups by Time
#'
#' Creates a list of xts objects split along time periods.
#'
#' A quick way to break up a large xts object by standard time periods; e.g.
#' 'months', 'quarters', etc.
#'
#' [`endpoints()`] is used to find the start and end of each period (or
#' k-periods). See that function for valid arguments.
#'
#' The inputs are passed to [`split.zoo()`][zoo::split.zoo] when `f` is not a character vector.
#'
#' @param x An xts object.
#' @param f A character vector describing the period to split by.
#' @param drop Ignored by `split.xts()`.
#' @param k Number of periods to aggregate into each split. See details.
#' @param \dots Further arguments passed to other methods.
#'
#' @return A list of xts objects.
#'
#' @note [`aggregate.zoo()`][zoo::aggregate.zoo] is more flexible, though not
#' as fast for xts objects.
#'
#' @author Jeffrey A. Ryan
#'
#' @seealso [`endpoints()`], [`split.zoo()`][zoo::split.zoo],
#' [`aggregate.zoo()`][zoo::aggregate.zoo]
#'
#' @keywords utilities
#' @examples
#'
#' data(sample_matrix)
#' x <- as.xts(sample_matrix)
#'
#'
#' split(x)
#' split(x, f="weeks")
#' split(x, f="weeks", k=4)
#'
split.xts <-
function(x, f="months", drop=FALSE, k=1, ...) {
if(is.character(f) && length(f) == 1L) {
ep <- endpoints(x, on=f, k=k)
sp <- (ep + 1)[-length(ep)]
ep <- ep[-1]
out <- lapply(seq_along(ep), function(X) x[sp[X]:ep[X]])
if(f == "secs" || f == "mins") {
f <- substr(f, 1L, 3L)
}
f <- match.arg(f, c("years", "quarters", "months", "weeks", "days", "hours",
"minutes", "seconds", "milliseconds", "microseconds", "ms", "us"))
obs.for.names <- index(x)[sp]
outnames <-
switch(f,
"years" = format(obs.for.names, "%Y"),
"quarters" = as.character(as.yearqtr(as.POSIXlt(obs.for.names))),
"months" = format(obs.for.names, "%b %Y"),
"weeks" = format(obs.for.names, "%Y-%m-%d"),
"days" = format(obs.for.names, "%Y-%m-%d"),
"hours" = format(obs.for.names, "%Y-%m-%d %H:00:00"),
"minutes" = format(obs.for.names, "%Y-%m-%d %H:%M:00"),
"seconds" = format(obs.for.names, "%Y-%m-%d %H:%M:%S"),
"milliseconds" = ,
"ms" = format(obs.for.names, "%Y-%m-%d %H:%M:%OS3"),
"microseconds" = ,
"us" = format(obs.for.names, "%Y-%m-%d %H:%M:%OS6"))
setNames(out, outnames)
} else
NextMethod("split")
}
xts/R/merge.R 0000644 0001762 0000144 00000020035 14702273432 012517 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
#' Merge xts Objects
#'
#' Perform merge operations on xts objects by time index.
#'
#' This xts method is compatible with [zoo's merge() method][zoo::merge.zoo] but implemented almost
#' entirely in C-level code for efficiency.
#'
#' The function can perform all common database join operations along the time
#' index by setting 'join' to one of the values below. Note that 'left' and
#' 'right' are only implemented for two objects.
#'
#' * outer: full outer (all rows in all objects)
#' * inner: only rows with common indexes in all objects
#' * left: all rows in the first object, and rows from the second object that
#' have the same index as the first object
#' * right: all rows in the second object, and rows from the first object that
#' have the same index as the second object
#'
#' The above join types can also be accomplished by setting 'all' to one of the
#' values below.
#'
#' * outer: `all = TRUE` or `all = c(TRUE, TRUE)`
#' * inner: `all = FALSE` or `all = c(FALSE, FALSE)`
#' * left: `all = c(TRUE, FALSE)`
#' * right: `all = c(FALSE, TRUE)`
#'
#' The result will have the timezone of the leftmost argument if available. Use
#' the 'tzone' argument to override the default behavior.
#'
#' When `retclass = NULL` the joined objects will be split and reassigned
#' silently back to the original environment they are called from. This is for
#' backward compatibility with zoo, but unused by xts. When `retclass = FALSE`
#' the object will be stripped of its class attribute. This is for internal use.
#'
#' See the examples in order to join using an 'all' argument that is the same
#' arguments to join, like you can do with `merge.zoo()`.
#'
#' @param \dots One or more xts objects, or objects coercible to class xts.
#' @param all A logical vector indicating merge type.
#' @param fill Values to be used for missing elements.
#' @param suffixes Suffix to be added to merged column names.
#' @param join Type of database join. One of 'outer', 'inner', 'left', or 'right'.
#' @param retside Which side of the merged object should be returned (2-case only)?
#' @param retclass Either a logical value indicating whether the result should
#' have a 'class' attribute, or the name of the desired class for the result.
#' @param tzone Time zone to use for the merged result.
#' @param drop Not currently used.
#' @param check.names Use [`make.names()`] to ensure column names are vaild \R
#' object names?
#'
#' @return A new xts object containing the appropriate elements of the
#' objects passed in to be merged.
#'
#' @note This is a highly optimized merge, specifically designed for ordered
#' data. The only supported merging is based on the underlying time index.
#'
#' @author Jeffrey A. Ryan
#'
#' @references Merge Join Discussion:
#'
#'
#' @keywords manip utilities
#' @examples
#'
#' (x <- xts(4:10, Sys.Date()+4:10))
#' (y <- xts(1:6, Sys.Date()+1:6))
#'
#' merge(x,y)
#' merge(x,y, join='inner')
#' merge(x,y, join='left')
#' merge(x,y, join='right')
#'
#' merge.zoo(zoo(x),zoo(y),zoo(x), all=c(TRUE, FALSE, TRUE))
#' merge(merge(x,x),y,join='left')[,c(1,3,2)]
#'
#' # zero-width objects (only index values) can be used
#' xi <- xts( , index(x))
#' merge(y, xi)
#'
merge.xts <- function(...,
all=TRUE,
fill=NA,
suffixes=NULL,
join="outer",
retside=TRUE,
retclass="xts",
tzone=NULL,
drop=NULL,
check.names=NULL) {
if(is.null(check.names)) {
check.names <- TRUE
}
if(is.logical(retclass) && !retclass) {
setclass=FALSE
} else setclass <- TRUE
fill.fun <- NULL
if(is.function(fill)) {
fill.fun <- fill
fill <- NA
}
# as.list(substitute(list(...))) # this is how zoo handles colnames - jar
mc <- match.call(expand.dots=FALSE)
dots <- mc$...
if(is.null(suffixes)) {
syms <- names(dots)
if(is.null(syms)) {
# Based on makeNames() in merge.zoo()
syms <- substitute(alist(...))[-1L]
nm <- names(syms)
fixup <- if (is.null(nm)) seq_along(syms) else !nzchar(nm)
dep <- sapply(syms[fixup], function(x) deparse(x, nlines = 1L))
if(is.null(nm)) {
nm <- dep
} else if(any(fixup)) {
nm[fixup] <- dep
}
syms <- nm
} else {
have.symnames <- nzchar(syms)
if(any(!have.symnames)) {
syms[!have.symnames] <- as.character(dots[!have.symnames])
}
}
} else
if(length(suffixes) != length(dots)) {
warning("length of suffixes and does not match number of merged objects")
syms <- as.character(dots)
# should we ignore suffixes here?
#suffixes <- NULL
} else {
syms <- as.character(suffixes)
}
.times <- .External(C_number_of_cols, ...)
# moved call to make.names inside of mergeXts/do_merge_xts
symnames <- rep(syms, .times)
suffixes <- rep(suffixes, .times)
if(length(dots) == 1) {
# this is for compat with zoo; one object AND a name
if(!is.null(names(dots))) {
x <- list(...)[[1]]
if(is.null(colnames(x)))
colnames(x) <- symnames
return(x)
}
}
if( !missing(join) ) {
# join logic applied to index:
# inspired by: http://blogs.msdn.com/craigfr/archive/2006/08/03/687584.aspx
#
# (full) outer - all cases, equivelant to all=c(TRUE,TRUE)
# left - all x, && y's that match x
# right - all ,y && x's that match y
# inner - only x and y where index(x)==index(y)
all <- switch(pmatch(join,c("outer","left","right","inner")),
c(TRUE, TRUE ), # outer
c(TRUE, FALSE), # left
c(FALSE, TRUE ), # right
c(FALSE, FALSE) # inner
)
if( length(dots) > 2 ) {
all <- all[1]
warning("'join' only applicable to two object merges")
}
}
if( length(all) != 2 ) {
if( length(all) > 2 )
warning("'all' must be of length two")
all <- rep(all[1], 2)
}
if( length(dots) > 2 )
retside <- TRUE
if( length(retside) != 2 )
retside <- rep(retside[1], 2)
x <- .External(C_mergeXts,
all=all[1:2],
fill=fill,
setclass=setclass,
symnames=symnames,
suffixes=suffixes,
retside=retside,
env=new.env(),
tzone=tzone,
check.names=check.names,
...)
if(!is.logical(retclass) && retclass != 'xts') {
asFun <- paste("as", retclass, sep=".")
if(!exists(asFun)) {
warning(paste("could not locate",asFun,"returning 'xts' object instead"))
return(x)
}
xx <- try(do.call(asFun, list(x)))
if(!inherits(xx,'try-error')) {
return(xx)
}
}
if(!is.null(fill.fun)) {
fill.fun(x)
} else
return(x)
}
#' @rdname merge.xts
cbind.xts <- function(..., all=TRUE, fill=NA, suffixes=NULL) {
merge.xts(..., all=all, fill=fill, suffixes=suffixes)
}
.merge.xts.scalar <- function(x, length.out, ...) {
if( length.out == 0)
return(vector(storage.mode(x), 0))
if( length(x) == 1 )
return(matrix(rep(x, length.out=length.out)))
if( NROW(x) == length.out )
return(x)
stop("improper length of one or more arguments to merge.xts")
}
xts/R/Math.xts.R 0000644 0001762 0000144 00000003400 14654242576 013136 0 ustar ligges users #
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
# This code adapted from Ops.zoo.R
cumsum.xts <- function(x)
{
if( NCOL(x) == 1 ) {
x[] <- cumsum(coredata(x))
} else x[] <- apply(coredata(x), 2, function(y) cumsum(y))
x
}
cumprod.xts <- function(x)
{
if( NCOL(x) == 1 ) {
x[] <- cumprod(coredata(x))
} else x[] <- apply(coredata(x), 2, function(y) cumprod(y))
x
}
cummin.xts <- function(x)
{
if( NCOL(x) == 1 ) {
x[] <- cummin(coredata(x))
} else x[] <- apply(coredata(x), 2, function(y) cummin(y))
x
}
cummax.xts <- function(x)
{
if( NCOL(x) == 1 ) {
x[] <- cummax(coredata(x))
} else x[] <- apply(coredata(x), 2, function(y) cummax(y))
x
}
mean.xts <- function(x,...) {
if(is.vector(x) ||is.null(ncol(x)) || ncol(x)==1){
x<-as.numeric(x)
mean(x,...)
} else apply(x,2,mean.xts,...)
}
sd.xts <- function(x,na.rm=FALSE) {
if(is.vector(x) || is.null(ncol(x)) || ncol(x)==1){
x<-as.numeric(x)
sd(x,na.rm=na.rm)
} else apply(x,2,sd,na.rm=na.rm)
}
xts/vignettes/ 0000755 0001762 0000144 00000000000 14703504525 013105 5 ustar ligges users xts/vignettes/xts.Rnw 0000644 0001762 0000144 00000100654 14634167654 014434 0 ustar ligges users %\VignetteIndexEntry{xts: Extensible Time Series}
\documentclass{article}
\usepackage{hyperref}
\hypersetup{colorlinks,%
citecolor=black,%
linkcolor=blue,%
urlcolor=blue,%
}
\title{\bf xts: Extensible Time Series }
\author{Jeffrey A. Ryan \and Joshua M. Ulrich}
\date{May 18, 2008}
\begin{document}
\maketitle
\tableofcontents
\section{Introduction}
The statistical language {\tt R}~\cite{R}
offers the time-series analyst a variety of mechanisms
to both store and manage time-indexed data.
Native {\tt R} classes potentially suitable
for time-series data include {\tt data.frame}, {\tt matrix}, {\tt vector}, and
{\tt ts} objects. Additional time-series tools have been subsequently introduced
in contributed packages to
handle some of the domain-specific shortcomings of the native {\tt R} classes.
These include {\tt irts} from the {\tt tseries} package\cite{tseries},
{\tt timeSeries} from the {\tt Rmetrics} bundle\cite{rmetrics}, and
{\tt zoo}~\cite{zoo} from their
respective packages. Each of these contributed classes provides unique solution
to many of the issues
related to working with time-series in R.
While it seems a bit paradoxical with all the current options
available, what {\tt R} really needed was one more
time-series class. Why? Users of R have had many choices over the
years for managing time-series data. This variety has meant that
developers have had to pick and choose the classes they would support,
or impose the necessary conversions upon the end-user. With the sheer
magnitude of software packages available from CRAN, it has become a challenge
for users and developers
to select a time-series class that will manage the needs of the
individual user, as well as remain compatible with the broadest audience.
What may be sufficient for one use --- say a quick correlation matrix may be
too limiting when more information needs to be incorporated
in a complex calculation.
This is especially true for functions that rely on time-based indexes to
be manipulated or checked.
The previous solution to managing different data needs often
involved a series of {\tt as} calls,
to coerce objects from one type to another. While this may
be sufficient for many cases, it is less flexible than allowing the users
to simply use the object they are accustomed to, or quite possibly require.
Additionally, all current coercion methods fail to maintain the original
object's data in its entirety. Converting from a {\tt timeSeries} class to
{\tt zoo} would cause attributes such as
{\em FinCenter}, {\em format}, and {\em recordIDs} to be lost.
Converting back to a {\tt timeSeries} would then add new
values different than the original.
For many calculations that do not modify the data, this is most likely
an acceptable side effect. For functions that convert data ---
such as {\tt xts}'s {\tt to.period} --- it limits the value of the function,
as the returned object is missing
much of what may have been a factor in the original class consideration.
One of the most important additions the new {\tt xts} class makes
to the R user's
workflow doesn't use {\tt xts} at all, at least not explicitly.
By converting data to {\tt xts} inside a function, the function developer
is guaranteed to have to only manage a single class of objects.
It becomes unecessary to write specific methods to handle different data.
While many functions do have
methods to accommodate different classes, most do not. Before {\tt xts}, the
{\tt chartSeries} function in the {\tt quantmod} package\cite{quantmod}
was only able to handle {\tt zoo} objects well.
Work had been done to allow for {\tt timeSeries} objects to be used as well, but
many issues were still being worked out.
With {\tt xts} now used internally, it is
possible to use \emph{any} of R's time-series classes.
Simultaneously saving development time and
reducing the learning/using curve for the end user. The function now
simply handles whatever time-series object it receives
exactly as the user expects --- without complaint.
More details, as well as examples of incorporating {\tt xts} into
functions will be covered later in this document.
While it may seem that {\tt xts} is primarily a tool
to help make existing R code
more user-friendly, the opportunity to add exciting
(to software people) new functionality
could not be passed up. To this end, {\tt xts}
offers the user the ability to add
custom attributes to any object --- during its construction
or at any time thereafter. Additionally,
by requiring that the index attribute be derived from one of
R's existing time-based classes, {\tt xts} methods can
make assumptions, while subsetting by time or date, that allow for
much cleaner and accurate data manipulation.
The remainder of this introduction will
examine what an {\tt xts} object consists of and
its basic usage, explain how developing with {\tt xts} can save
package development time, and finally will demonstrate
how to extend the class - informally
and formally.
\pagebreak
\section{The structure of {\tt xts}}
To understand a bit more of \emph{what an xts object can do}, it may
be beneficial to know \emph{what an xts object is}. This section
is intended to provide a quick overview of the basics of the
class, as well as what features make it unique.
\subsection{It's a {\tt zoo} in here}
At the core of an {\tt xts} object is a {\tt zoo} object from the package of
the same name. Simplified, this class contains an array of values
comprising your data (often in matrix form) and an index
attribute to provide information about
the data's ordering. Most of the details surrounding zoo
objects apply equally to xts. As it would be redundent to simply retell
the excellent introductory zoo vignette, the reader is advised to
read, absorb, and re-read that documentation to best
understand the power of this class. The authors of the {\tt xts}
package recognize that
{\tt zoo}'s strength comes from its
simplicity of use, as well as its overall flexibility. What motivated the
{\tt xts} extension was a desire to have even more flexibility, while
imposing reasonable constraints to make this class into a true time-based one.
\subsection{{\tt xts} modifications}
Objects of class {\tt xts} differ from objects of class
{\tt zoo} in three key ways: the use of formal time-based
classes for indexing,
internal xts properties, and perhaps most uniquely
--- user-added attributes.
\subsubsection*{True time-based indexes}
To allow for functions that make use of {\tt xts} objects
as a general time-series object - it was necessary to
impose a simple rule on the class. The index of each
{\tt xts} object \emph{must} be of a known and supported
time or date class. At present this includes any one of
the following - Date, POSIXct, chron, yearmon, yearqtr, or
timeDate. The relative merits of each are left to
the judgement of the user, though the first three are expected
to be sufficient for most applications.
\subsubsection*{Internal attributes: .CLASS, .ROWNAMES, etc.}
In order for one major feature of the {\tt xts} class
to be possible - the conversion and re-conversion of classes
to and from {\tt xts} - certain elements must be preserved within
the converted object. These are for internal use, and
as such require little further explanation in an introductory
document. Interested readers are invited to examine the source as
well as read the developer documentation.
\subsubsection*{xtsAttributes}
This is what makes the xts class an \emph{extensible}
time-series class. Arbitrary attributes may be assigned
and removed from the object without causing issues with the data's display or
otherwise. Additionally this is where \emph{other}
class specific attributes (e.g. \emph{FinCenter} from {\tt timeSeries})
are stored during conversion
to an xts object so they may be restored with {\tt reclass}.
\pagebreak
\section{Using the {\tt xts} package}
Just what is required to start using {\tt xts}? Nothing more
than a simple conversion of your current time-series data with
{\tt as.xts}, or the creation of a new object with the {\tt xts} constructor.
\subsection{Creating data objects: {\tt as.xts} and {\tt xts}}
There are two equally valid mechanisms to create an {\tt xts}
object - coerce a supported time-series class to {\tt xts} with
a call to {\tt as.xts} or create a new object from scratch
with {\tt xts}.
\subsubsection*{Converting your \emph{existing} time-series data: {\tt as.xts}}
If you are already comfortable using a particular
time-series class in {\tt R}, you can still access
the functionality of {\tt xts} by converting your
current objects.
Presently it is possible to convert all the major
time-series like classes in {\tt R} to {\tt xts}. This list
includes objects of class:
matrix, data.frame, ts, zoo, irts, and timeSeries.
The new object will maintain all the necessary information
needed to {\tt reclass} this object back to its
original class if that is desired. Most classes
after re-conversion will be identical to similar modifications
on the original object, even
after sub-setting or other changes while an {\tt xts} object.
<>=
require(xts)
data(sample_matrix)
class(sample_matrix)
str(sample_matrix)
matrix_xts <- as.xts(sample_matrix,dateFormat='Date')
str(matrix_xts)
df_xts <- as.xts(as.data.frame(sample_matrix),
important='very important info!')
str(df_xts)
@
A few comments about the above. {\tt as.xts} takes different arguments, depending
on the original object to be converted. Some classes do not contain enough
information to infer a time-date class. If that is the case, POSIXct is used by
default. This is the case with both matrix and data.frame objects. In the preceding
examples we first requested that the new date format be of type 'Date'. The
second example was left to the default {\tt xts} method
with a custom attribute added.
\subsubsection*{Creating new data: the {\tt xts} constructor}
Data objects can also be constructed directly from raw data with
the {\tt xts} constructor function, in essentially the same way
a {\tt zoo} object is created with the exception that at present
there is no equivelant {\tt zooreg} class.
<>=
xts(1:10, Sys.Date()+1:10)
@
\subsection{{\tt xts} methods}
There is a full complement of standard methods to make use of the features
present in {\tt xts} objects. The generic methods currently
extended to {\tt xts} include ``{\tt [}'',
{\tt cbind}, {\tt rbind}, {\tt c}, {\tt str}, {\tt Ops},
{\tt print}, {\tt na.omit}, {\tt time}, {\tt index},
{\tt plot} and {\tt coredata}. In addition, most methods that can accept
zoo or matrix objects will simply work as expected.
A quick tour of some of the methods leveraged by {\tt xts}
will be presented here, including subsetting via ``{\tt [}'',
indexing objects with {\tt tclass} and {\tt convertIndex},
and a quick look at plotting {\tt xts} objects with the {\tt plot}
function.
\subsubsection*{Subsetting}
The most noticable difference in the behavior of \texttt{xts} objects
will be apparent in the use of the ``{\tt [}'' operator. Using
special notation, one can use date-like strings to extract
data based on the time-index. Using increasing levels of time-detail,
it is possible to subset the object by year, week, days - or even seconds.
The {\em i} (row)
argument to the subset operator ``{\tt [}'', in addition to accepting numeric
values for indexing,
can also be a character string, a time-based object, or a vector of either.
The format must left-specified with respect to the standard ISO:8601
time format --- {\em ``CCYY-MM-DD HH:MM:SS''}~\cite{ISO}. This means that for one
to extract a particular month, it is necesssary to fully specify the
year as well. To identify a particular hour, say all observations
in the eighth hour on January 1, 2007, one would likewise need
to include the full year, month and day - e.g. ``2007-01-01 08''.
It is also possible to explicitly request a range of times via
this index-based subsetting, using
the ISO-recommended ``/'' as the range seperater.
The basic form is {\em ``from/to''},
where both {\em from} and {\em to}
are optional. If either side is missing, it is interpretted as
a request to retrieve data from the beginning, or through the end of the
data object.
Another benefit to this method is that exact starting and ending
times need not match the underlying data - the nearest available
observation will be returned that is within the requested time
period.
The following example shows how
to extract the entire month of March 2007 - without having to
manually identify the index positions or match the underlying
index type. The results have been abbreviated to save space.
<>=
matrix_xts['2007-03']
@
<>=
head(matrix_xts['2007-03'],5)
cat('...\n')
@
Now extract all the data from the beginning through
January 7, 2007.
<>=
matrix_xts['/2007-01-07']
@
<>=
matrix_xts['/2007-01-07']
@
Additional xts tools providing subsetting are the
{\tt first} and {\tt last} functions.
In the spirit of head and tail from
the {\em utils} recommended package, they allow
for string based subsetting, without forcing
the user to conform to the specifics of the
time index, similar in usage to the {\em by}
arguments of {\tt aggregate.zoo} and {\tt seq.POSIXt}.
Here is the first 1 week of the data
<>=
first(matrix_xts,'1 week')
@
<>=
head(first(matrix_xts,'1 week'))
@
...and here is the first 3 days of the
last week of the data.
<>=
first(last(matrix_xts,'1 week'),'3 days')
@
\subsubsection*{Indexing}
While the subsetting ability of the above makes
exactly {\em which} time-based class you choose
for your index a bit less relevant, it is none-the-less
a factor that is beneficial to have control over.
To that end, {\tt xts} provides facilities for indexing
based on any of the current time-based classes. These
include {\tt Date}, {\tt POSIXct}, {\tt chron}, {\tt yearmon},
{\tt yearqtr}, and {\tt timeDate}. The index itself may
be accessed via the zoo generics extended to xts --- {\tt index} and
the replacement function {\tt index<-}.
It is also possible to directly query and set the
index class of an {\tt xts} object by using the respective functions
{\tt tclass} and {\tt tclass<-}.
Temporary conversion, resulting in a new object with the requested
index class, can be accomplished via the {\tt convertIndex} function.
<>=
tclass(matrix_xts)
tclass(convertIndex(matrix_xts,'POSIXct'))
@
\pagebreak
\subsubsection*{Plotting}
\SweaveOpts{height=5,width=10}
%\setkeys{Gin}{width=0.8\textwidth}
The use of time-based indexes within {\tt xts} allows
for assumptions to be made regarding the x-axis
of plots. The {\tt plot} method
makes use of the {\tt xts} function {\tt axTicksByTime}, which
heuristically identifies suitable tickmark locations
for printing given a time-based object.
When {\tt axTickByTime} is called with its
{\tt ticks.on} argument set to ``auto'', the result
is a vector of suitably chosen tickmark locations.
One can also specify the specific points to use
by passing a character string to the argument
indicating which time period to create tickmarks on.
<>=
axTicksByTime(matrix_xts, ticks.on='months')
@
A simple example of the plotting functionality
offered by this labelling can be seen here:
\begin{center}
<>=
plot(matrix_xts[,1],major.ticks='months',minor.ticks=FALSE,main=NULL,col=3)
@
\end{center}
\subsection{Restoring the original class - {\tt reclass} \& {\tt Reclass}}
By now you may be interested in some of the xts functionality
presented, and wondering how to incorporate it into
a current workflow --- but not yet ready to commit
to using it exclusively.
If it is desirable to only use the subsetting tools
for instance, a quick conversion to xts via {\tt as.xts}
will allow full access to the above subsetting tools. When
it is then necessary to continue your analysis using
the original class, it is as simple as calling the
function {\tt reclass} to return the object to its
original class.
\subsubsection*{(Re)converting classes manually: {\tt reclass}}
<>=
# using xts-style subsetting doesn't work on non-xts objects
sample_matrix['2007-06']
# convert to xts to use time-based subsetting
str(as.xts(sample_matrix)['2007-06'])
# reclass to get to original class back
str(reclass(as.xts(sample_matrix)['2007-06']))
@
This differs dramatically from the standard {\tt as.*****}
conversion though. Internally, key attributes of your
original data object are preserved and adjusted to
assure that the process introduces no changes other
than those requested. Think of it as a smart {\tt as}.
Behind the scenes, {\tt reclass} has enormous value
in functions that convert all incoming data to {\tt xts}
for simplified processing. Often it is necessary to
return an object back to the user in the class he
is expecting --- following the principal of least surprise.
It is in these circumstances where {\tt reclass} can
turn hours of tedious development into mere minutes per function. More
details on the details of using this functionality
for developers will be covered in section \ref{developer},
\textbf{Developing with xts}.
A user friendly interface of this \emph{reclass} functionality, though
implicit, is available in the {\tt Reclass} function.
It's purpose is to make it easy to preserve an object's attributes after calling
a function that is not programmed to be aware of your particular class.
\pagebreak
\subsubsection*{Letting xts handle the details: {\tt Reclass}}
If the function you require does not make use of
{\tt reclass} internally, it may still be possible to let
xts convert and reconvert your time-based object for you.
The caveat here is that the object returned:
\begin{quote}
\begin{itemize}
\item must be of the same length as the first argument to
the function.
\item intended to be coerced back to the class of the first
argument
\end{itemize}
\end{quote}
Simply wrapping the function
that meets these criteria in {\tt Reclass} will
result in an
attempt to coerce the returned output of the function
<>=
z <- zoo(1:10,Sys.Date()+1:10)
# filter converts to a ts object - and loses the zoo class
(zf <- filter(z, 0.2))
class(zf)
# using Reclass, the zoo class is preserved
(zf <- Reclass(filter(z, 0.2)))
class(zf)
@
The {\tt Reclass} function is still a bit experimental, and will
certainly improve in time, but for now provides at least
an alternative option to maintain your object's class
and attributes when the function you require can't on its own.
\subsection{Additional time-based tools}
In addition to the core {\tt xts} tools covered
above, there are more functions that are included
in xts to make the process of dealing with
time-series data easier. Some of these have been
moved from the package {\tt quantmod} to {\tt xts}
to make it easier to use them within other applications.
\subsubsection*{Calculate periodicity}
The {\tt periodicity} function provides
a quick summary as to the underlying
periodicity of most time-series like
objects. Primarily a wrapper to {\tt difftime}
it provides a quick and concise summary
of your data.
<>=
periodicity(matrix_xts)
@
\subsubsection*{Find endpoints by time}
Another common issue with time-series data
is identifying the endpoints with respect to
time. Often it is necessary to break data
into hourly or monthly intervals to calculate
some statistic. A simple call to {\tt endpoints}
offers a quick vector of values suitable
for subsetting a dataset by. Note that the first
element it zero, which is used to delineate the \emph{end}.
<>=
endpoints(matrix_xts,on='months')
endpoints(matrix_xts,on='weeks')
@
\subsubsection*{Change periodicity}
One of the most ubiquitous type of data
in finance is OHLC data (Open-High-Low-Close). Often is is necessary
to change the periodicity of this data to something
coarser - e.g. take daily data and aggregate to weekly
or monthly. With {\tt to.period} and related wrapper
functions it is a simple proposition.
<>=
to.period(matrix_xts,'months')
periodicity(to.period(matrix_xts,'months'))
# changing the index to something more appropriate
to.monthly(matrix_xts)
@
The {\tt to.monthly} wrapper automatically requests that the
returned object have an index/rownames using
the {\tt yearmon} class. With the {\tt indexAt}
argument it is possible to align most series
returned to the end of the period, the beginning of the period,
or the first or last observation of the period ---
even converting to something like {\tt yearmon} is supported. The online
documentation provides more details as to additional
arguments.
\subsubsection*{Periodically apply a function}
Often it is desirable to be able to calculate a
particular statistic, or evaluate a function, over
a set of non-overlapping time periods. With the
{\tt period.apply} family of functions
it is quite simple.
The following examples illustrate a
simple application of the {\tt max} function
to our example data.
<>=
# the general function, internally calls sapply
period.apply(matrix_xts[,4],INDEX=endpoints(matrix_xts),FUN=max)
@
<>=
# same result as above, just a monthly interface
apply.monthly(matrix_xts[,4],FUN=max)
@
<>=
# using one of the optimized functions - about 4x faster
period.max(matrix_xts[,4], endpoints(matrix_xts))
@
In addition to {\tt apply.monthly}, there are
wrappers to other common time frames including:
{\tt apply.daily}, {\tt apply.weekly}, {\tt apply.quarterly},
and {\tt apply.yearly}. Current optimized functions
include {\tt period.max}, {\tt period.min}, {\tt period.sum},
and {\tt period.prod}.
\pagebreak
\section{Developing with {\tt xts}}
\label{developer}
While the tools available to the xts \emph{user} are quite
useful, possibly greater utility comes from using xts
internally as a \emph{developer}. Bypassing
traditional S3/S4 method dispatch and
custom if-else constructs to handle different time-based
classes, {\tt xts} not only makes it easy to
handle all supported classes in one consistent manner,
it also allows the whole process to be invisible
to the function user.
\subsection{One function for all classes: {\tt try.xts}}
With the proliferation of data classes in R, it can be
tedious, if not entirely impractical, to manage interfaces to all
classes.
Not only does trying to handle every possible class present
non-trivial design issues, the developer is also forced
to learn and understand the nuances of up to eight or
more classes. For each of these classes it is then
ncessary to write and manage
corresponding methods for each case.
At best, this reduces the time available
to devote to core function functionality --- at worst
is a prime opportunity to introduce errors that
inevitibly come from this massive increase in code.
The solution to this issue is to use one class
internally within your package, or more generally your
entire workflow. This can
be accomplished in one of two ways: force your users
to adopt the convention you do, or allow for
multiple object classes by relying on internal
code to convert to one consistent type.
Using the second approach offers the most end-user
flexibility, as class conversions are no longer
required simply to make use of package functionality. The
user's own workflow need not be interrupted with unproductive and
potentially error-prone conversions and reconversions.
Using the functionality of {\tt try.xts} and {\tt reclass} offered
by the xts package allows the developer an opportunity
to cleanly, and reliably, manage data with the least amount
of code, and the least number of artificial end-user restrictions.
An example from the xts package illustrates just how simple
this can be.
<>=
period.apply
@
Some explanation of the above code is needed. The
{\tt try.xts} function takes three arguments, the first
is the object that the developer is trying to
convert, the second \ldots is any additional arguments to
the {\tt as.xts} constructor that is called internally
(ignore this for the most part --- though it should
be noted that this is an R dots argument \ldots), and the third is
a what the result of an error should be.
Of the three, {\tt error} is probably the most useful
from a design standpoint. Some functions may not
be able to deal with data that isn't time-based. Simple
numerical vectors might not contain enough information
to be of any use. The \emph{error} argument
lets the developer decide if the function should be
halted at this point, or continue onward.
If a logical value, the result is
handled by R's standard error mechanism during the try-catch
block of code internal to {\tt try.xts}. If error is
a character string, it is returned to the standard output
as the message. This allows for diagnostic messages to
be fine tuned to your particular application.
The result of this call, if successful (or if {\tt error=FALSE})
is an object that may be of class {\tt xts}. If
your function can handle either numeric data or time-based
input, you can branch code here for cases you expect. If your
code has been written to be more general
at this point, you can simply continue with your calculations,
the originally converted object will contain
the information that will be required to reclass it at the end.
A note of importance here: if you are planning on
returning an object that is of the original class, it
is important to not modify the originally coverted object - in this
case that would be the {\tt x} result of the {\tt try.xts} call.
You will notice that the function's result is assigned to
{\tt xx} so as not to impact the original converted function. If
this is not possible, it is recommended to copy the object first
to preserve an untouched copy for use in the {\tt reclass} function.
Which leads to the second part of the process of developing with
xts.
\subsection{Returning the original class: {\tt reclass}}
The {\tt reclass} function takes the object you are
expecting to return to your user (the result of all your
calculations) and optionally an {\tt xts} object
that was the result of the original {\tt try.xts} call.
It is important to stress that the {\tt match.to} object
\emph{must be an untouched object} returned from the
{\tt try.xts} call. The only exception here is
when the resultant data has changed dimension --- as is
the case in the {\tt period.apply} example. As reclass
will try and convert the first argument to the orginal
class of the second (the original class passed to the function),
it must have the same general row dimension of the original.
A final note on using {\tt reclass}. If the {\tt match.to} argument
is left off, the conversion will only be attempted if the object
is of class {\tt xts} and has a {\tt CLASS} attribute that is
not {\tt NULL}, else the object is simply
returned. Essentially if the object meant to be
reconverted is already of in the form needed by
the individual reclass methods, generally nothing
more needs to be done by the developer.
In many cases your function does not need to return
an object that is expected to be used in the same context
as the original. This would be the case for functions
that summarize an object, or perform some statistical analysis.
For functions that do not need the {\tt reclass} functionality,
a simple use of {\tt try.xts} at the beginning of the function
is all that is needed to make use of this single-interface
tool within {\tt xts}.
Further examples can be found in the {\tt xts} functions
{\tt periodicity} and {\tt endpoints} (no use of reclass), and
{\tt to.period} (returns an object of the original's class).
The package {\tt quantmod} also utilizes the {\tt try.xts}
functionality in its {\tt chartSeries} function --- allowing
financial charts for all time-based classes.
Forthcoming developer documentation will examine the functions
highlighted above, as well go into more detail on exceptional
cases and requirements.
\pagebreak
\section{Customizing and Extending xts}
As \emph{extensible} is in the name of
the package, it is only logical that it can be extended.
The two obvious mechanisms to make {\tt xts}
match the individual needs of a diverse user
base is the introduction of custom
attributes, and the idea of subclassing the entire
{\tt xts} class.
\subsection{{\tt xtsAttributes}}
What makes an R attribute an {\tt xtsAttribute}?
Beyond the sematics, xtsAttributes are designed to
persist once attached to an object, as well as not get
in the way of other object functionality.
All xtsAttributes are indeed R attributes, though
the same can not be said of the reverse --- all
R attributes are \emph{not} xtsAttributes!
Attaching arbitrary attributes to most (all?) classes
other than {\tt xts} will cause the attribute to be displayed
during most calls that print the object. While this isn't
necessarily devestating, it is often time unsightly, and sometimes
even confusing to the end user (this may depend on the quality your users).
xts offers the developer and end-user the opportunity to attach attributes
with a few different mechanisms - and all will be suppressed
from normal view, unless specifically called upon.
What makes an xtsAttribute special is that it
is principally a mechanism to store and view meta-data, that is,
attributes that would be seen with a call to R's
{\tt attributes}.
<>=
str(attributes(matrix_xts))
str(xtsAttributes(matrix_xts))
# attach some attributes
xtsAttributes(matrix_xts) <- list(myattr="my meta comment")
attr(matrix_xts, 'another.item') <- "one more thing..."
str(attributes(matrix_xts))
str(xtsAttributes(matrix_xts))
@
In general - the only attributes that should be
handled directly by the user (\emph{without} the assistance
of xts functions) are ones returned by {\tt xtsAttributes}.
The additional attributes seen in the {\tt attributes}
example are for internal R and xts use, and if you expect
unbroken code, should be left alone.
\subsection{Subclassing {\tt xts}}
Subclassing xts is as simple as extending any other
S3 class in R. Simply include the full class of
the xts system in your new class.
<>=
xtssubclass <- structure(matrix_xts, class=c('xts2','xts','zoo'))
class(xtssubclass)
@
This will allow the user to override methods of xts and zoo,
while still allowing for backward compatibility with
all the tools of xts and zoo, much the way {\tt xts} benefits from
extending {\tt zoo}.
\section{Conclusion}
The {\tt xts} package offers both R developers and R users
an extensive set of time-aware tools for use in
time-based applications. By extending the {\tt zoo} class,
xts leverages an excellent infrastructure tool into
a true time-based class. This simple requirement for
time-based indexing allows for code to
make assumptions about the object's purpose, and facilitates
a great number of useful utilities --- such as time-based
subsetting.
Additionally, by embedding knowledge of the currently
used time-based classes available in R, xts can offer
the developer and end-user a single interface mechanism
to make internal class decisions user-driven. This
affords developers an opportunity to design applications
for there intended purposes, while freeing up time
previously used to manage the data structures.
Future development of xts will focus on integrating
xts into more external packages, as well as additional useful
additions to the time-based utilities currently available
within the package. An effort to provide external disk and
memory based data access will also be examined for potential
inclusion or extension.
\begin{thebibliography}{99}
\bibitem{zoo} Achim Zeileis and Gabor Grothendieck (2005):
\emph{ zoo: S3 Infrastructure for Regular and Irregular Time Series.}
Journal of Statistical Software, 14(6), 1-27. URL http://www.jstatsoft.org/v14/i06/
\bibitem{tseries} Adrian Trapletti and Kurt Hornik (2007):
\emph{tseries: Time Series Analysis and Computational Finance.} R package version 0.10-11.
\bibitem{rmetrics} Diethelm Wuertz, many others and see the SOURCE file (2007):
\emph{Rmetrics: Rmetrics - Financial Engineering and Computational Finance.}
R package version 260.72. http://www.rmetrics.org
\bibitem{ISO} International Organization for Standardization (2004):
\emph{ISO 8601: Data elements and interchage formats ---
Information interchange --- Representation of dates and time}
URL http://www.iso.org
\bibitem{R} R Development Core Team:
\emph{R: A Language and Environment for Statistical Computing},
R Foundation for Statistical Computing, Vienna, Austria.
ISBN 3-900051-07-0, URL http://www.R-project.org
\bibitem{quantmod} Jeffrey A. Ryan (2008):
\emph{quantmod: Quantitative Financial Modelling Framework.}
R package version 0.3-5. URL http://www.quantmod.com
URL http://r-forge.r-project.org/projects/quantmod
\end{thebibliography}
\end{document}
xts/vignettes/xts-faq.Rnw 0000644 0001762 0000144 00000030054 14634167654 015175 0 ustar ligges users %\documentclass[article,nojss]{jss}
%\DeclareGraphicsExtensions{.pdf,.eps}
%%\newcommand{\mysection}[2]{\subsubsection[#2]{\textbf{#1}}}
%\let\mysection=\subsubsection
%\renewcommand{\jsssubsubsec}[2][default]{\vskip \preSskip%
% \pdfbookmark[3]{#1}{Subsubsection.\thesubsubsection.#1}%
% \refstepcounter{subsubsection}%
% {\large \textbf{\textit{#2}}} \nopagebreak
% \vskip \postSskip \nopagebreak}
%% -*- encoding: utf-8 -*-
%\VignetteIndexEntry{xts FAQ}
%\VignetteDepends{zoo}
\documentclass{article}
%
\usepackage{Rd}
\usepackage{Sweave}
\usepackage{hyperref}
\hypersetup{colorlinks,%
citecolor=black,%
linkcolor=blue,%
urlcolor=blue,%
}
%%\encoding{UTF-8}
%%\usepackage[UTF-8]{inputenc}
%
\newcommand{\q}[1]{\section*{#1}\addcontentsline{toc}{subsection}{#1}}
\author{xts Deveopment Team%
\footnote{Contact author: Joshua M. Ulrich \email{josh.m.ulrich@gmail.com}}
\footnote{Thanks to Alberto Giannetti and Michael R. Weylandt for their many contributions.}
}
\title{\bf xts FAQ}
%\Keywords{irregular time series, time index, daily data, weekly data, returns}
%\Abstract{
% This is a collection of frequently asked questions (FAQ) about the
% \pkg{xts} package together with their answers.
%}
\begin{document}
\SweaveOpts{concordance=TRUE, engine=R, eps=FALSE}
%\SweaveOpts{engine=R, eps=FALSE}
<>=
library("xts")
Sys.setenv(TZ="GMT")
@
\makeatletter
\makeatother
\maketitle
\tableofcontents
\q{What is \pkg{xts}?}
%
\pkg{xts} is an \pkg{R} package offering a number of functionalities to work on
time-indexed data. \pkg{xts} extends \pkg{\pkg{zoo}}, another popular package
for time-series analysis.
% should point to the zoo FAQ here (or at some early point)
\q{Why should I use \pkg{xts} rather than \pkg{zoo} or another time-series
package?}
%
The main benefit of \pkg{xts} is its seamless compatibility with other packages
using different time-series classes (\pkg{timeSeries}, \pkg{zoo}, ...). In
addition, \pkg{xts} allows the user to add custom attributes to any object. See
the main \pkg{xts} vignette for more information.
\q{How do I install \pkg{xts}?}
%
\pkg{xts} depends on \pkg{zoo} and suggests some other packages. You should be
able to install \pkg{xts} and all the other required components by simply
calling \code{install.packages('pkg')} from the \pkg{R} prompt.
\q{I have multiple .csv time-series files that I need to load in a single
\pkg{xts} object. What is the most efficient way to import the files?}
%
If the files have the same format, load them with \code{read.zoo} and
then call \code{rbind} to join the series together; finally, call \code{as.xts}
on the result. Using a combination of \code{lapply} and \code{do.call} can
accomplish this with very little code:
<>=
filenames <- c("a.csv", "b.csv", "c.csv")
sample.xts <- as.xts(do.call("rbind", lapply(filenames, read.zoo)))
@
\q{Why is \pkg{xts} implemented as a matrix rather than a data frame?}
%
\pkg{xts} uses a matrix rather than data.frame because:
\begin{enumerate}
\item \pkg{xts} is a subclass of \pkg{zoo}, and that's how \pkg{zoo} objects
are structured; and
\item matrix objects have much better performance than data.frames.
\end{enumerate}
\q{How can I simplify the syntax when referring to \pkg{xts} object column names?}
%
\code{with} allows you to use the colmn names while avoiding the full square
brackets syntax. For example:
<>=
lm(sample.xts[, "Res"] ~ sample.xts[, "ThisVar"] + sample.xts[, "ThatVar"])
@
can be converted to
<>=
with(sample.xts, lm(Res ~ ThisVar + ThatVar))
@
\q{How can I replace the zeros in an \pkg{xts} object with the last non-zero value
in the series?}
%
Convert the zeros to \code{NA} and then use \code{na.locf}:
<<>>=
sample.xts <- xts(c(1:3, 0, 0, 0), as.POSIXct("1970-01-01")+0:5)
sample.xts[sample.xts==0] <- NA
cbind(orig=sample.xts, locf=na.locf(sample.xts))
@
\q{How do I create an \pkg{xts} index with millisecond precision?}
%
Milliseconds in \pkg{xts} indexes are stored as decimal values. This example
builds an index spaced by 100 milliseconds, starting at the current system time:
<<>>=
data(sample_matrix)
sample.xts <- xts(1:10, seq(as.POSIXct("1970-01-01"), by=0.1, length=10))
@
\q{I have a millisecond-resolution index, but the milliseconds aren't
displayed. What went wrong?}
%
Set the \code{digits.secs} option to some sub-second precision. Continuing from
the previous example, if you are interested in milliseconds:
<<>>=
options(digits.secs=3)
head(sample.xts)
@
\q{I set \code{digits.sec=3}, but \pkg{R} doesn't show the values correctly.}
%
Sub-second values are stored with approximately microsecond precision. Setting
the precision to only 3 decimal hides the full index value in microseconds and
might be tricky to interpret depending how the machine rounds the millisecond
(3rd) digit. Set the \code{digits.secs} option to a value higher than 3 or
convert the date-time to numeric and use \code{print}'s \code{digits} argument,
or \code{sprintf} to display the full value. For example:
<<>>=
dt <- as.POSIXct("2012-03-20 09:02:50.001")
print(as.numeric(dt), digits=20)
sprintf("%20.10f", dt)
@
\q{I am using \code{apply} to run a custom function on my \pkg{xts} object.
Why does the returned matrix have different dimensions than the original one?}
%
When working on rows, \code{apply} returns a transposed version of the
original matrix. Simply call \code{t} on the returned matrix to restore the
original dimensions:
<>=
sample.xts.2 <- xts(t(apply(sample.xts, 1, myfun)), index(sample.xts))
@
\q{I have an \pkg{xts} object with varying numbers of observations per day (e.g.,
one day might contain 10 observations, while another day contains 20 observations).
How can I apply a function to all observations for each day?}
%
You can use \code{apply.daily}, or \code{period.apply} more generally:
<<>>=
sample.xts <- xts(1:50, seq(as.POSIXct("1970-01-01"),
as.POSIXct("1970-01-03")-1, length=50))
apply.daily(sample.xts, colMeans)
period.apply(sample.xts, endpoints(sample.xts, "days"), colMeans)
period.apply(sample.xts, endpoints(sample.xts, "hours", 6), colMeans)
@
\q{How can I process daily data for a specific time subset?}
%
First use time-of-day subsetting to extract the time range you want to work on (note
the leading \code{"T"} and leading zeros are required for each time in the range:
\code{"T06:00"}), then use \code{apply.daily} to apply your function to the subset:
<>=
apply.daily(sample.xts['T06:00/T17:00',], colMeans)
@
\q{How can I analyze my irregular data in regular blocks, adding observations
for each regular block if one doesn't exist in the origianl time-series object?}
%
Use \code{align.time} to round-up the indexes to the periods you are interested
in, then call \code{period.apply} to apply your function. Finally, merge the
result with an empty xts object that contains all the regular index values
you want:
<<>>=
sample.xts <- xts(1:6, as.POSIXct(c("2009-09-22 07:43:30",
"2009-10-01 03:50:30", "2009-10-01 08:45:00", "2009-10-01 09:48:15",
"2009-11-11 10:30:30", "2009-11-11 11:12:45")))
# align index into regular (e.g. 3-hour) blocks
aligned.xts <- align.time(sample.xts, n=60*60*3)
# apply your function to each block
count <- period.apply(aligned.xts, endpoints(aligned.xts, "hours", 3), length)
# create an empty xts object with the desired regular index
empty.xts <- xts(, seq(start(aligned.xts), end(aligned.xts), by="3 hours"))
# merge the counts with the empty object
head(out1 <- merge(empty.xts, count))
# or fill with zeros
head(out2 <- merge(empty.xts, count, fill=0))
@
\q{Why do I get a \pkg{zoo} object when I call \code{transform} on my
\pkg{xts} object?}
%
There's no \pkg{xts} method for \code{transform}, so the \pkg{zoo} method is
dispatched. The \pkg{zoo} method explicitly creates a new \pkg{zoo} object. To
convert the transformed object back to an \pkg{xts} object wrap the
\code{transform} call in \code{as.xts}:
<>=
sample.xts <- as.xts(transform(sample.xts, ABC=1))
@
You might also have to reset the index timezone:
<>=
tzone(sample.xts) <- Sys.getenv("TZ")
@
\q{Why can't I use the \code{\&} operator in \pkg{xts} objects when querying
dates?}
%
\code{"2011-09-21"} is not a logical vector and cannot be coerced to a logical
vector. See \code{?"\&"} for details.
\pkg{xts}' ISO-8601 style subsetting is nice, but there's nothing we can do to
change the behavior of \code{.Primitive("\&")}. You can do something like this
though:
<>=
sample.xts[sample.xts$Symbol == "AAPL" & index(sample.xts) == as.POSIXct("2011-09-21"),]
@
or:
<>=
sample.xts[sample.xts$Symbol == "AAPL"]['2011-09-21']
@
\q{How do I subset an \pkg{xts} object to only include weekdays (excluding
Saturday and Sundays)?}
%
Use \code{.indexwday} to only include Mon-Fri days:
<<>>=
data(sample_matrix)
sample.xts <- as.xts(sample_matrix)
wday.xts <- sample.xts[.indexwday(sample.xts) %in% 1:5]
head(wday.xts)
@
\q{I need to quickly convert a data.frame that contains the time-stamps in one
of the columns. Using \code{as.xts(Data)} returns an error. How do I build my
\pkg{xts} object?}
%
The \code{as.xts} function assumes the date-time index is contained in the
\code{rownames} of the object to be converted. If this is not the case, you
need to use the \code{xts} constructor, which requires two arguments: a
vector or a matrix carrying data and a vector of type \code{Date},
\code{POSIXct}, \code{chron}, \ldots, supplying the time index information.
If you are certain the time-stamps are in a specific column, you can use:
<<>>=
Data <- data.frame(timestamp=as.Date("1970-01-01"), obs=21)
sample.xts <- xts(Data[,-1], order.by=Data[,1])
@
If you aren't certain, you need to explicitly reference the column name that
contains the time-stamps:
<<>>=
Data <- data.frame(obs=21, timestamp=as.Date("1970-01-01"))
sample.xts <- xts(Data[,!grepl("timestamp",colnames(Data))],
order.by=Data$timestamp)
@
\q{I have two time-series with different frequency. I want to combine the data
into a single \pkg{xts} object, but the times are not exactly aligned. I want
to have one row in the result for each ten minute period, with the time index
showing the beginning of the time period.}
%
\code{align.time} creates evenly spaced time-series from a set of indexes,
\code{merge} ensure two time-series are combined in a single \pkg{xts} object
with all original columns and indexes preserved. The new object has one entry
for each timestamp from both series and missing values are replaced with
\code{NA}.
<>=
x1 <- align.time(xts(Data1$obs, Data1$timestamp), n=600)
x2 <- align.time(xts(Data2$obs, Data2$timestamp), n=600)
merge(x1, x2)
@
\q{Why do I get a warning when running the code below?}
<<>>=
data(sample_matrix)
sample.xts <- as.xts(sample_matrix)
sample.xts["2007-01"]$Close <- sample.xts["2007-01"]$Close + 1
#Warning message:
#In NextMethod(.Generic) :
# number of items to replace is not a multiple of replacement length
@
%
This code creates two calls to the subset-replacement function
\code{xts:::`[<-.xts`}. The first call replaces the value of \code{Close}
in a temporary copy of the first row of the object on the left-hand-side of
the assignment, which works fine. The second call tries to replace
the first \emph{element} of the object on the left-hand-side of the
assignment with the modified temporary copy of the first row. This is
the problem.
For the command to work, there needs to be a comma in the first
subset call on the left-hand-side:
<>=
sample.xts["2007-01",]$Close <- sample.xts["2007-01"]$Close + 1
@
This isn't encouraged, because the code isn't clear. Simply remember to
subset by column first, then row, if you insist on making two calls to
the subset-replacement function. A cleaner and faster solution is below.
It's only one function call and it avoids the \code{\$} function (which
is marginally slower on xts objects).
<>=
sample.xts["2007-01","Close"] <- sample.xts["2007-01","Close"] + 1
@
%%% What is the fastest way to subset an xts object?
\end{document}
xts/data/ 0000755 0001762 0000144 00000000000 14703504524 012005 5 ustar ligges users xts/data/sample_matrix.rda 0000644 0001762 0000144 00000012041 14522244665 015346 0 ustar ligges users ‹ …˜y8UëÛÇM™24Sš‹H…=¡¤»’µVQ4BŠ¢L%
ÒtŠTTN"Ê¡‰TÆ’(S¦’ÊB
‹”÷î÷žÎº®žß{½°özöÚkÝë¹?ûó|×^mhΑ6—Çÿ¢øRLÿ ’¬‡‹»³ƒ‹Ýî]Nûð9ü{Ì¥¿ªýÔ€™t¤yÑÝñÀðßUë‹Š£YR¢œæÌ#yQ`F}[Öã
Œ˜Q¯÷ ‡Í]8 ×~fáQ+ñoeÀð¾”Øq˜¹‚[Îf¸¯vâÜéÀÌSÒýèýë Úÿ9±îÕç¼€™pz·j»0 w08kN 0雡 èoWt§›Ý ꤪ$['í¢=ÀHx&q˜‰é±k®£ÛŸýÖ$ïóÚS¹%XÇÃRíY*×Ó·v$0V÷s·\fÑ´"çÂ×À,ÿèîum飻c®u@V˜õUù1Î.ÀìlÕº&îŒÇ²
J!Àìï_bpX ¿ KõŸ/æœ7³¥;˜ƒŠžf h`BKNœ9ÌìÅaºrÀ2÷³§oWÿF`6š¬¿” ŒóˆK7%l€±7n?þE‡ÑÑ/–ÆýMÇUß``lUÖ ?Ãóš×;µöá}:îß0ÕK ˜•²et öÍ:ót<ç‰cøêMöwÚÇÌÓÞNÀ̘eæ¨þ˜1G÷ûª™ýeÚËÆ@÷ð¯nÚôûžÁqó€n3«p
þ ô‡Î«Æ¡@¿ž’þ·øH o;· »áü¸[´ýà}ß zè|ˆ·òm:jÒ
¹°¹@?7:L‰]ÌqªR´:ó^¥xã ST¿úÌ[ ôÕ6?äÆíÚ´ßÎÈ
h¨ˆÔ°Ú´F¡( é ôT3óRa¼îlËŽ&se W” –‰;´ûÎ ‘©@{m9öýd2Ðû^ÍËvÁGù|É …@ŸÈ5oñŒúrsBlV>ÐÉR-— €Ž“á ù`½/쮤´à4×Qè´Ú= -7°~ãÏæîx½:çý‘;ô®Ÿ0ÂsóI ß ×
ùtm[Ž²ÌQ|?rLÚ¯¸mÒ];]èON ž§°î¯rÛ´%MR¶æ¨ÐïÖù‡é Ð?b–+ÏY̬ÏɯŠ£öµÆ*Oè΢›.¾3®éxét·å õ [挲:OhE¹¹+Îg®ŽÂ0~ÏïÉë¬ôú„îú .ÔP¸ tºñ}íò8ÏY±W.ãýÝÕ’ÕýT ô…ÅN5š@?ê«žò
ç=PHc ~,ÐÁIé÷Mð:Ûßìb‚»qž/œ42êÛG «s@KL80z@
¨2 ÆÐ ¨’ÈÆÓI½@U,·ü’Ôû¸sr]9@•ë o¯Ø‡ÛV]·€Êï ì² ð<‘RªJÛ€j}¤ùPA¨/Åg¬Kêõ0úPß3ô>lŽzL0=Ý5ha“´ªp>P=v¡‡vkU!»dÏL“”±Ò&ÀPܯÓÜmX?óëúƒî GÕJ®GÞ“cjDñ<Ó½Mܳ™©9Âë׬ŸeŽ…Øâ¸5®Gi+úf\:¯4‘Âõ:èåæµr5ª¸ôOØ€×7Ü{¢éá!`ôeÄç¤àõe
Õ„±X½ã{C
ëg ¾ÒêZ[ô¤§ï—zœŸ]E‹l™Aôž¬è«b`<÷Ïs;ºåúúYÀ ±+/–ÃóøŠ^׿l̙ʩR¬Ÿ÷ßÚªdLÌØe³ µâÖáÛÇšT`ÎO Z´õ³k•°`´0ÞJÆ’opÿf±Ì^*¦dÔÖÏBõ#qÝÙ /qsÑFÖÏõ;ïÿ)Ëú™·æËq›Àh\Ø›0ðý0$Õ €þ ßäé¡Œó¶wµ¼¡)ëç®æåÙšèá.1ëÎéèÏžP¾~úâMÒ|ÅY艜ü׳³l.}\kÓ1èòs1{s Y?W¾=2jR3Ž§…GQ£ñ8ë•ü~ úpô›NG‹ÿßÏzÓã>êä ÍPÊ/°.Ãлȕ@[\(kN úµÿ Ñw ý=réw@ äYý<îTÖÆ”YÕ@GØ{-[RtBÁÇÛ(ÖÏÉWòÜý„€~&¦9ïÐE^1 y6@g§·\¸tÓKƒÙ/ÐÃ53ÄßLC?‡vŽÉBžÚõb}²J€nøq«³sÉû3{“²ÑÏ £í% ç
ž‰:ƒ9@ïukZú¹bœÂFônÕ¡³¸ÞüN0ßçáRSŸ+¬Ÿ{Ü\s¤RpžÝ2í§·’~Ηši3Ö‚õsœ÷“™‹qýȶµöåbý\µó‰ýÙU¬ŸOož‹ëÕƒú–{á²~ŽŒšØÝéÂúÙYO>·fñ¿~¦Åxw-*X?W?sMHDOÕ\¤ä €ê¬¤tÇ‘õs½ª¦¬j%Pe¦zÆŠèa•ÞÔ\GES7o j`“Õ짴cñrg ÿlµEAèq»åg¼bý,’{múdôÔÿ¨àè½n+ŸU#qß<úõãùàS;ÕY?×m ea®Ãú9çddº—*P©9eaOÐÓùFëuŸ•õ<ùdc6PÙ½Ïþø¹¤}uvçY?GŸÞxôzÜâìÃèÅ'çÊò]Þ³~N,ÿt¶}žXX#mç}èåZ÷~úw¢Âãxe jšT×yâ}¶FÕr;5X?USSÄãÑçÉrzÞXWT³êòL R2C¢ 7õ¬:Áæ+ž÷mƳ‚«ÇðsZ·æâü5R?&¦àý=àrª¹ ˆÖltêbóó´Òù“þˆAŸ-¯T^¹RN_Æï¨#®ÿ}ã‚÷ OCSv%¦]ºù›„¯R+™Ÿ‡TÂF¾&ó³þßW&TÖC ØT¿Æ ½cÓý|€ážÞ¾½"
ýQ)öjûôiF†A†z÷¤iÓ !\F†|šƒ¾»w¦©p 0’s*=÷~Æuá„ýŸ²’˜W6wL¼5ë:bÉYy¤ï„GsË,áEÅø}ªMïã³ùùq¼x\GÔE‡£ºhŒ¤>?p=Ãκâøü×1/»p>•ßûty1™Ÿ×_c*£M’‚nÞgóóÑ?]ïU£7ÏøÉK³õÙzfÏ·_{üŠbô÷‘§ß’¿þû %A›w §ö§$àxàªKŽ˜ç÷& <®¸ ìÒÞ t
˜µ“Ï!ôëñ9-+GÿÎöZ¶©”ÍÏ›ÂÏ~:„ëÀ*ÎÇa}`Œo´?ÊÅç
zq™{"®‹‹%Ó];à¼nÉ.:‚uOi6qtÏdó³Â—Ór“ß`ÿ¾ÜyŸúó_Lc\#ú¤NbwýMôÍ¥’Ó¾8f5Ö+N ý²ìñ†§øý½sjè?ûÑ–²Eñ9%Qzû"îTôíòÏkÃ@ÇöË\ËgóóÙØ)Æ
ø¾Æu™Éè»ä%QQ[ÑÑmúOÐë{Õ]FUà÷w©ÛÖ}ŽèÕÙÙ¢qR@«(D™n4z²á»L™p6?3ÇÀ|«™Ÿ·]¹°oÖm6?{æÅÔ :Ô»7ñd-^O×+Ëà™Ÿ“)Nœ…ãƉ~ZËÉü\*¶(ú¤êê\z >?”D+‰¾º¢º(IýÿfX¥þ;~¾Ñ÷ìƒþô±Ý‚CÞëþè1!àS" o›|†ÍÏS l/1}ôç?¸¯RÖbnžÙd³ÍÏuµ¥zè«ÇÒiõ"@ß°Ê«û‹ÏK , •}&mþ4ƈÍÏqo25kûÙüœÔW³«è Ž¯¤e+›Ÿmm-üÓØül=ꥑ=^Wëú¢È =@
I…oz„ÛîÅ&鲘_3uWµœªð˜ô³A@ooþëX4z$§j•ÜU ò‚ Ôeós‰·÷–&!6?7vd>¸YTKý“ã"‡17‡w[lÀ÷»4Æho Dÿ|Uæ·¹Õ ²q«zg×-‰fÌë•ñgÏtâys$,„Ùü\ë®i§¾ËÓЕÂ÷ŸÞò_‡þ…Ücµ4P1íBÏ€º$±¥læÖŠ*hÚ Tïn9wv…°ó|ÌJó zî°~þ±ïíºS ü^· äîF.†öÿŹ Áæç™Gš·; ªÂbÛÑÆCjkÏ Æà’ŸíÈŸ>«Wx¢ûKﺧ[Ãä¼¢®M$ýü+?ÿòó¯ü<)rüè÷Ks•Ø( ̃’ß“g\Äë
;ܸxç5rŸí¸zv6Ð}¡\—ì!óóÜ’çßà:¢iè2&Û¹½–¯O“ùù—ŸM‚jÚ¿¢ß 5ÜÊç0¬Ÿ-¤g>ŒÁy۰䪴;›Ÿ=Öåjm¸Íægß«sŒ·ógN¿"›ŸÏۿؤˆëOðƒ¾Y?o vRÜÉæg»¶žï+Æ¡—Kn¨LòÆ lŸ‘ƒ4ëgó î"[ØüÌÈq—X ÌÊ¢”·v*8¯>Q:ú‡q½Ì›ªõëW©ò¹Ò6‹ôs_@òÍ*ìo˪ûãjÑ;]~qQÁY˜'ëÆլ܆ÏõÙš¼=꬟åç̃ò".˜ÛÔ† 5¢7Ü4ˇ±å…%¥ÈIn]óÉÏèǬwƒ¢¢èkÓER¯Ðë÷Š³õ/.%ý¬áíЄõ󬃺NÆ/Èü¼7cdU³z¸ °Ü¢h·Wt—¦í§øÔWKœÍÏ·ö˜zýÌ ‚Þ®ßÀæçœFËû=4ëç_ù¹á”Q‰!æåºãáOÌAoº ŒKEïÖÔ•çÌÓI VÓƒÑËÏ&U{Ô¡‡mÓÛ̈üü¯Ÿ{/û«½ðaó³zÜ𵙸.uݦl=“õs—yo)ÞçûM‘Tr4éç@3Î ©·l~~¸^ÏZRè»+·Db.-R6,;ºôó¯üüËψKÛmû?ýL‹xé,(´eý\±¥¥ÑÏ s¢Ty± ¨ŽÞ
€z~ÖË>¹
¨WAO?y²~þ'?ÿëç60#Eô/1Œë´ð.÷Gƒ¸ž+d˜V‰5|Ôì6ˆ“~î¼ïù7z´írƺ묟Ë|§5LÆ\ßèZ~Í„õóyÑna=áþºÝèóÄ%ÃËÜѯ÷;m £ÿ3šwòÿ^Íæçßýü+?ÿòó¨Ðï c3=¸y¬Ÿï[sÕ`ý\)ܦ"Äúùù©ñ—爰~þ•ŸÃg¸ê4Þ$óóssõŠG»qþRµày—÷5XÕÀÝV}²û· ©Eí\~þVýŸß±…„’~þˆýÛ!’xˆ«‹ƒ¾ ûÏq£þ9öçûÒ --¹ZÚsµ8Ä—á#|bD@Œè#ºÄˆÞï#ÚZĈ61BÔ¬MÔ¬MÔ¬MÔ¬MÔ¬MÔ¬MÔ¬MÔÌ!jæ5sˆš9DÍ ¢fQ3‡¨™CÔÌ!jæ5s‰š¹¿ÕÌÁAb„CŒp‰ 1Â'FĈ1¢KŒèý>ò;- ‚A ‡ …CÐÂ!há´pZ8- ‚A ‡ …CÐÂ!há´pZ8- ‚A —è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;—è;÷¿ôýwKp Kp KðZx-<‚ A …GÐÂ#há´ðZx-<‚ A …GÐÂ#há´ðZx-<‚ A …GÐÂ#há´ðZx-<‚ A …GÐÂ'Øàlð 6ø|‚
>ÁŸ`ƒO°Á'Øàlð 6ø|‚
>ÁŸ`ƒO°Á'Øàlð 6ø|‚
>ÁŸ`ƒO°Á'Øàlð 6ø|‚
þaãw“Z-‚A‹€ E@Ð" h´Z-‚A‹€ E@Ð" h´Z-‚A‹€ E@Ð" h´Z-‚A‹€ Eð¿´ü|^ûç ±U^ÓNÛ ÿy-jì¶÷Ÿ—#–:»y8à‹ ?ÿþSƒ0[ë# xts/src/ 0000755 0001762 0000144 00000000000 14703504525 011664 5 ustar ligges users xts/src/isOrdered.c 0000644 0001762 0000144 00000007574 14634167654 014000 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include
SEXP do_is_ordered (SEXP x, SEXP increasing, SEXP strictly)
{
int i;
int nx = LENGTH(x) - 1;
double *real_x;
int *int_x;
/*
If length is 0 then it is ordered
*/
if (nx < 0)
return ScalarLogical(1);
if(TYPEOF(x) == REALSXP) {
/*
Check for increasing order, strict or non-strict
*/
real_x = REAL(x);
if(LOGICAL(increasing)[ 0 ] == 1) { /* INCREASING */
if(LOGICAL(strictly)[ 0 ] == 1) { /* STRICTLY INCREASING ( > 0 ) */
for(i = 0; i < nx; i++) {
if( real_x[i+1] <= real_x[i] ) {
return ScalarLogical(0);
}
}
} else { /* NOT-STRICTLY ( 0 || > 0 ) */
for(i = 0; i < nx; i++) {
if( real_x[i+1] < real_x[i] ) {
return ScalarLogical(0);
}
}
}
/*
Check for decreasing order, strict or non-strict
*/
} else {
if(LOGICAL(strictly)[ 0 ] == 1) { /* STRICTLY DECREASING ( < 0 ) */
for(i = 0; i < nx; i++) {
if( real_x[i+1] >= real_x[i] ) {
return ScalarLogical(0);
}
}
} else { /* NOT-STRICTLY ( 0 || < 0 ) */
for(i = 0; i < nx; i++) {
if( real_x[i+1] > real_x[i] ) {
return ScalarLogical(0);
}
}
}
}
} else
if(TYPEOF(x) == INTSXP) {
/*
Check for increasing order, strict or non-strict
*/
int_x = INTEGER(x);
if(LOGICAL(increasing)[ 0 ] == 1) { /* INCREASING */
/* Not increasing order if first element is NA. We know x has at least 1 element. */
if( int_x[0] == NA_INTEGER )
return ScalarLogical(0);
if(LOGICAL(strictly)[ 0 ] == 1) { /* STRICTLY INCREASING ( > 0 ) */
for(i = 0; i < nx; i++) {
if( int_x[i+1] <= int_x[i] ) {
if (i == (nx-1) && int_x[i+1] == NA_INTEGER) {
continue; /* OK if NA is last element */
}
return ScalarLogical(0);
}
}
} else { /* NOT-STRICTLY ( 0 || > 0 ) */
for(i = 0; i < nx; i++) {
if( int_x[i+1] < int_x[i] ) {
if (i == (nx-1) && int_x[i+1] == NA_INTEGER) {
continue; /* OK if NA is last element */
}
return ScalarLogical(0);
}
}
}
/*
Check for decreasing order, strict or non-strict
*/
} else { /* DECREASING */
/* Not decreasing order if last element is NA */
if( int_x[nx] == NA_INTEGER )
return ScalarLogical(0);
if(LOGICAL(strictly)[ 0 ] == 1) { /* STRICTLY DECREASING ( < 0 ) */
for(i = 0; i < nx; i++) {
if( int_x[i+1] >= int_x[i] ) {
if (i == 0 && int_x[i] == NA_INTEGER) {
continue; /* OK if NA is first element */
}
return ScalarLogical(0);
}
}
} else { /* NOT-STRICTLY ( 0 || < 0 ) */
for(i = 0; i < nx; i++) {
if( int_x[i+1] > int_x[i] ) {
if (i == 0 && int_x[i] == NA_INTEGER) {
continue; /* OK if NA is first element */
}
return ScalarLogical(0);
}
}
}
}
} else {
error("'x' must be of type double or integer");
}
return ScalarLogical(1); /* default to true */
}
xts/src/lag.c 0000644 0001762 0000144 00000015655 14634167654 012622 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include
#include "xts.h"
SEXP lagXts(SEXP x, SEXP k, SEXP pad)
{
SEXP result;
int nrs, ncs;
int i, j, ij, iijj, K, NApad;
int mode;
int P=0; /*PROTECT counter*/
int *int_result=NULL, *int_x=NULL;
int *lgl_result=NULL, *lgl_x=NULL;
double *real_result=NULL, *real_x=NULL;
int *int_oindex=NULL, *int_nindex=NULL;
double *real_oindex=NULL, *real_nindex=NULL;
nrs = nrows(x);
ncs = ncols(x);
K = INTEGER(k)[ 0 ];
K = (K > nrs) ? nrs : K;
mode = TYPEOF(x);
NApad = INTEGER(pad)[ 0 ];
if(NApad) {
PROTECT(result = allocVector(TYPEOF(x), nrs*ncs)); P++;
} else {
if(K > 0) {
PROTECT(result = allocVector(TYPEOF(x), (nrs-K)*ncs)); P++;
} else {
PROTECT(result = allocVector(TYPEOF(x), (nrs+K)*ncs)); P++;
}
}
switch( TYPEOF(x) ) {
case LGLSXP:
lgl_x = LOGICAL(x);
lgl_result = LOGICAL(result);
break;
case INTSXP:
int_x = INTEGER(x);
int_result = INTEGER(result);
break;
case REALSXP:
real_x = REAL(x);
real_result = REAL(result);
break;
case CPLXSXP:
case STRSXP:
case VECSXP:
case RAWSXP:
break;
default:
error("unsupported type");
break;
}
for(i = 0; i < nrs; i++) {
/*
need to figue out how many duplicate values we have, in order to know how far to go back.
probably best accomplished with some sort of look-ahead approach, though this may be messy
if k is negative...
something like:
while( i+tmp+K < nrs && xindex[i] == xindex[i+tmp_K] )
tmp_K++;
*/
for(j = 0; j < ncs; j++) {
ij = i + j * nrs;
if(i < K ||
(K < 0 && i > (nrs+K-1)) ) {
/* Pad NA values at beginning */
if(NApad) {
switch ( mode ) {
case LGLSXP:
lgl_result[ ij ] = NA_INTEGER;
break;
case INTSXP:
int_result[ ij ] = NA_INTEGER;
break;
case REALSXP:
real_result[ ij ] = NA_REAL;
break;
case CPLXSXP:
COMPLEX(result)[ij].r = NA_REAL;
COMPLEX(result)[ij].i = NA_REAL;
break;
case STRSXP:
SET_STRING_ELT(result, ij, NA_STRING);
break;
case VECSXP:
SET_VECTOR_ELT(result, ij, R_NilValue);
break;
case RAWSXP:
RAW(result)[ij] = (Rbyte) 0;
break;
default:
error("matrix subscripting not handled for this type");
break;
} /* NA insertion */
} /* NApad */
} else {
iijj = i - K + j * nrs; /* move back K positions to get data */
if(!NApad && K > 0) ij = i - K + j * (nrs - K); /* if not padding, start at the correct spot */
if(!NApad && K < 0) ij = i + j * (nrs + K); /* if not padding, start at the correct spot */
switch ( mode ) {
case LGLSXP:
lgl_result[ ij ] = lgl_x[ iijj ];
break;
case INTSXP:
int_result[ ij ] = int_x[ iijj ];
break;
case REALSXP:
real_result[ ij ] = real_x[ iijj ];
break;
case CPLXSXP:
COMPLEX(result)[ij] = COMPLEX(x)[iijj];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, iijj));
break;
case VECSXP:
SET_VECTOR_ELT(result, ij, VECTOR_ELT(x, iijj));
break;
case RAWSXP:
RAW(result)[ij] = RAW(x)[iijj];
break;
default:
error("matrix subscripting not handled for this type");
break;
}
}
} /* j-loop */
} /* i-loop */
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
if(!NApad) { /* No NA padding */
SEXP oindex, nindex, dims;
int nRows = (K > 0) ? nrs-K : nrs+K;
int incr = (K > 0) ? K : 0;
PROTECT(oindex = getAttrib(x, xts_IndexSymbol));
PROTECT(nindex = allocVector(TYPEOF(oindex), nRows));
switch(TYPEOF(oindex)) {
case REALSXP:
real_oindex = REAL(oindex);
real_oindex = real_oindex + incr;
real_nindex = REAL(nindex);
for( i = 0; i < nRows; real_nindex++, real_oindex++, i++)
*real_nindex = *real_oindex;
break;
case INTSXP:
int_oindex = INTEGER(oindex);
int_oindex = int_oindex + incr;
int_nindex = INTEGER(nindex);
for( i = 0; i < nRows; int_nindex++, int_oindex++, i++)
*int_nindex = *int_oindex;
break;
default:
break;
}
setAttrib(result, xts_IndexSymbol, nindex);
PROTECT(dims = allocVector(INTSXP, 2));
INTEGER(dims)[0] = nRows;
INTEGER(dims)[1] = ncs;
setAttrib(result, R_DimSymbol, dims);
setAttrib(result, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
UNPROTECT(3);
} else {
/* NA pad */
setAttrib(result, xts_IndexSymbol, getAttrib(x, xts_IndexSymbol));
setAttrib(result, R_DimSymbol, getAttrib(x, R_DimSymbol));
setAttrib(result, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
}
setAttrib(result, xts_ClassSymbol, getAttrib(x, xts_ClassSymbol));
UNPROTECT(P);
return result;
}
SEXP lag_xts (SEXP x, SEXP _k, SEXP _pad) {
/* this will eventually revert to NOT changing R default behaviors
for now it uses the 'standard' convention adopted by xts */
int k = asInteger(_k);
/* ensure args are correct types; error if conversion fails */
if(k == NA_INTEGER)
error("'k' must be integer");
if(asLogical(_pad) == NA_LOGICAL)
error("'na.pad' must be logical");
k = k * -1; /* change zoo default negative handling */
return zoo_lag (x, ScalarInteger(k), _pad);
}
SEXP lagts_xts (SEXP x, SEXP _k, SEXP _pad) {
/* this will use positive values of lag for carrying forward observations
i.e. y = lagts(x, 1) is y(t) = x(t-1)
*/
int k = asInteger(_k)*-1; /* change zoo default negative handling */
/* ensure args are correct types; error if conversion fails */
if(k == NA_INTEGER)
error("'k' must be integer");
if(asLogical(_pad) == NA_LOGICAL)
error("'na.pad' must be logical");
return zoo_lag (x, ScalarInteger(k), _pad);
}
xts/src/rbind.c 0000644 0001762 0000144 00000045164 14634167654 013153 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include
#include "xts.h"
SEXP rbind_append(SEXP, SEXP);
//SEXP do_rbind_xts (SEXP x, SEXP y, SEXP env) {{{
SEXP do_rbind_xts (SEXP x, SEXP y, SEXP dup)
{
int nrx, ncx, nry, ncy, truelen, len;
int no_duplicate = LOGICAL(dup)[0];
int i, j, ij, ij_x, ij_y, xp=1, yp=1, add_y=0;
int P=0; // PROTECT counter
int mode;
SEXP result, xindex, yindex, newindex;
int *int_result=NULL, *int_x=NULL, *int_y=NULL;
int *int_newindex=NULL, *int_xindex=NULL, *int_yindex=NULL;
double *real_result=NULL, *real_x=NULL, *real_y=NULL;
double *real_newindex=NULL, *real_xindex=NULL, *real_yindex=NULL;
nrx = nrows(x);
ncx = ncols(x);
nry = nrows(y);
ncy = ncols(y);
truelen = len = nrx + nry;
if( isNull(x) || isNull(y) ) {
/* Handle NULL values by returning non-null object */
if(!isNull(x)) return x;
return y;
}
if( !Rf_asInteger(isXts(x)) ) {
PROTECT( x = tryXts(x) ); P++;
}
if( !Rf_asInteger(isXts(y)) ) {
PROTECT( y = tryXts(y) ); P++;
}
/* need to convert different types of x and y if needed */
if( TYPEOF(x) != TYPEOF(y) ) {
warning("mismatched types: converting objects to numeric"); // FIXME not working!!!????
PROTECT(x = coerceVector(x, REALSXP)); P++;
PROTECT(y = coerceVector(y, REALSXP)); P++;
}
mode = TYPEOF(x);
if(ncx != ncy)
error("data must have same number of columns to bind by row");
PROTECT(xindex = getAttrib(x, xts_IndexSymbol)); P++;
PROTECT(yindex = getAttrib(y, xts_IndexSymbol)); P++;
if( TYPEOF(xindex) != TYPEOF(yindex) )
{
PROTECT(xindex = coerceVector(xindex, REALSXP)); P++;
PROTECT(yindex = coerceVector(yindex, REALSXP)); P++;
}
#ifdef RBIND_APPEND
if(TYPEOF(xindex)==REALSXP) {
if(REAL(xindex)[length(xindex)-1] < REAL(yindex)[0]) {
UNPROTECT(P);
return rbind_append(x,y);
}
} else
if(TYPEOF(xindex)==INTSXP) {
if(INTEGER(xindex)[length(xindex)-1] < INTEGER(yindex)[0]) {
UNPROTECT(P);
return rbind_append(x,y);
}
}
#endif
if(nrx != length(xindex) || nry != length(yindex))
error("zero-length vectors with non-zero-length index are not allowed");
PROTECT(newindex = allocVector(TYPEOF(xindex), len)); P++;
PROTECT(result = allocVector(TYPEOF(x), len * ncx)); P++;
switch( TYPEOF(x) ) {
case INTSXP:
int_x = INTEGER(x);
int_y = INTEGER(y);
int_result = INTEGER(result);
break;
case REALSXP:
real_x = REAL(x);
real_y = REAL(y);
real_result = REAL(result);
break;
default:
break;
}
/*
if( TYPEOF(xindex) == REALSXP ) {
if(REAL(xindex)[nrx-1] < REAL(yindex)[0]) {
memcpy(REAL(newindex), REAL(xindex), sizeof(double) * nrx);
memcpy(REAL(newindex)+nrx, REAL(yindex), sizeof(double) * nry);
switch(TYPEOF(x)) {
case INTSXP:
memcpy(INTEGER(result), INTEGER(x), sizeof(int) * (nrx*ncx));
memcpy(INTEGER(result)+(nrx*ncx), INTEGER(y), sizeof(int) * (nry*ncy));
break;
case REALSXP:
memcpy(REAL(result), REAL(x), sizeof(double) * (nrx*ncx));
memcpy(REAL(result)+(nrx*ncx), REAL(y), sizeof(double) * (nry*ncy));
break;
default:
break;
}
UNPROTECT(P);
return(result);
}
} else {
}
*/
/*
The main body of code to follow branches based on the type
of index, removing the need to test at each position.
*/
if( TYPEOF(xindex) == REALSXP ) {
real_newindex = REAL(newindex);
real_xindex = REAL(xindex);
real_yindex = REAL(yindex);
for( i = 0; i < len; i++ ) {
if( i >= truelen ) {
break;
} else
if( xp > nrx ) {
real_newindex[ i ] = real_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
yp++;
} else
if( yp > nry ) {
real_newindex[ i ] = real_xindex[ xp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
break;
default:
break;
}
}
xp++;
} else
if( real_xindex[ xp-1 ] == real_yindex[ yp-1 ] ) {
if( xp < nrx && real_xindex[ xp-1 ] < real_xindex[ xp ] )
add_y = 1; /* add y values only if next xindex is new */
if(no_duplicate) {
add_y = 0;
truelen--;
}
real_newindex[ i ] = real_xindex[ xp-1 ];
if(add_y) real_newindex[ i+ 1 ] = real_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
if(add_y) LOGICAL(result)[ ij+1 ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
if(add_y) int_result[ ij+1 ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
if(add_y) real_result[ ij+1 ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
if(add_y) COMPLEX(result)[ ij+1 ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
if(add_y) SET_STRING_ELT(result, ij+1, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
xp++;
if(no_duplicate || add_y) {
yp++;
if(!no_duplicate) i++; // need to increase i as we now have filled in 2 values
add_y = 0;
}
} else
if( real_xindex[ xp-1 ] < real_yindex[ yp-1 ] ) {
real_newindex[ i ] = real_xindex[ xp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
break;
default:
break;
}
}
xp++;
} else
if( real_xindex[ xp-1 ] > real_yindex[ yp-1 ] ) {
real_newindex[ i ] = real_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
yp++;
}
}
} else
if( TYPEOF(xindex) == INTSXP ) {
int_newindex = INTEGER(newindex);
int_xindex = INTEGER(xindex);
int_yindex = INTEGER(yindex);
for(i = 0; i < len; i++) {
/*Rprintf("xp:%i, yp:%i, i:%i\n",xp,yp,i);*/
if( i >= truelen ) {
break;
} else
if( xp > nrx ) {
int_newindex[ i ] = int_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
yp++;
} else
if( yp > nry ) {
int_newindex[ i ] = int_xindex[ xp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
break;
default:
break;
}
}
xp++;
} else
if( int_xindex[ xp-1 ] == int_yindex[ yp-1 ] ) {
if( xp < nrx && int_xindex[ xp-1 ] < int_xindex[ xp ] )
add_y = 1;
if(no_duplicate) {
add_y = 0;
truelen--;
}
int_newindex[ i ] = int_xindex[ xp-1 ];
if(add_y) int_newindex[ i+1 ] = int_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
if(add_y) LOGICAL(result)[ ij+1 ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
if(add_y) int_result[ ij+1 ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
if(add_y) real_result[ ij+1 ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
if(add_y) COMPLEX(result)[ ij+1 ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
if(add_y) SET_STRING_ELT(result, ij+1, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
xp++;
if(no_duplicate || add_y) {
yp++;
if(!no_duplicate) i++; // need to increase i as we now have filled in 2 values
add_y = 0;
}
} else
if( int_xindex[ xp-1 ] < int_yindex[ yp-1 ] ) {
int_newindex[ i ] = int_xindex[ xp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_x = (xp-1) + j * nrx;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(x)[ ij_x ];
break;
case INTSXP:
int_result[ ij ] = int_x[ ij_x ];
break;
case REALSXP:
real_result[ ij ] = real_x[ ij_x ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(x)[ ij_x ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, ij_x));
break;
default:
break;
}
}
xp++;
} else
if( int_xindex[ xp-1 ] > int_yindex[ yp-1 ] ) {
int_newindex[ i ] = int_yindex[ yp-1 ];
for(j = 0; j < ncx; j++) {
ij = i + j * len;
ij_y = (yp-1) + j * nry;
switch( mode ) {
case LGLSXP:
LOGICAL(result)[ ij ] = LOGICAL(y)[ ij_y ];
break;
case INTSXP:
int_result[ ij ] = int_y[ ij_y ];
break;
case REALSXP:
real_result[ ij ] = real_y[ ij_y ];
break;
case CPLXSXP:
COMPLEX(result)[ ij ] = COMPLEX(y)[ ij_y ];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(y, ij_y));
break;
default:
break;
}
}
yp++;
}}
}
if(truelen != len) {
PROTECT(result = lengthgets(result, truelen * ncx)); P++; /* reset length */
}
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
SEXP dim;
PROTECT(dim = allocVector(INTSXP, 2));
INTEGER(dim)[0] = truelen;
INTEGER(dim)[1] = ncx;
UNPROTECT(1);
setAttrib(result, R_DimSymbol, dim);
setAttrib(result, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
if(truelen != len) {
PROTECT(newindex = lengthgets(newindex, truelen)); P++;
}
copyMostAttrib(xindex, newindex);
setAttrib(result, xts_IndexSymbol, newindex);
setAttrib(result, xts_ClassSymbol, getAttrib(x, xts_ClassSymbol));
copy_xtsAttributes(x, result);
UNPROTECT(P);
return result;
} //}}}
// SEXP rbindXts ( .External("rbindXts", ...) ) {{{
SEXP rbindXts (SEXP args)
{
SEXP _x;
SEXP dup;
int P=0;
PROTECT_INDEX ipx;
args = CDR(args); // 'rbindXts' call name
PROTECT(dup = CAR(args)); P++;
args = CDR(args);
PROTECT(_x = CAR(args)); P++;
args = CDR(args);
if(args == R_NilValue) {
UNPROTECT(P);
return(_x);
}
PROTECT_WITH_INDEX(_x = do_rbind_xts(_x, CAR(args), dup), &ipx); P++;
args = CDR(args);
while(args != R_NilValue) {
REPROTECT(_x = do_rbind_xts(_x, CAR(args), dup), ipx);
args = CDR(args);
}
if(P > 0) UNPROTECT(P);
return _x;
} //}}}
SEXP rbind_append (SEXP x, SEXP y) {
/*
Provide fast row binding of xts objects if the
left-hand object (binding target) has a last
index value less than the right-hand object
(object to bind). This is an optimization to allow
for real-time updating of objects without having to
do much more than a memcpy of the two in coordinated
fashion
*/
/*Rprintf("rbind_append called\n");*/
SEXP result;
int nrs_x, nrs_y, ncs_x, ncs_y, nr;
int i;
ncs_x = ncols(x); ncs_y = ncols(y); nrs_x = nrows(x); nrs_y = nrows(y);
if(ncs_x != ncs_y)
error("objects must have the same number of columns"); /* FIXME */
PROTECT(result = allocVector(TYPEOF(x), (nrs_x + nrs_y) * ncs_x));
nr = nrs_x + nrs_y;
switch(TYPEOF(x)) {
case REALSXP:
for(i=0; i< ncs_x; i++) {
memcpy(&(REAL(result)[i*nr]),
&(REAL(x)[i*nrs_x]),
nrs_x*sizeof(double));
memcpy(&(REAL(result)[i*nr + nrs_x]),
&(REAL(y)[i*nrs_y]),
nrs_y*sizeof(double));
}
break;
case INTSXP:
for(i=0; i< ncs_x; i++) {
memcpy(&(INTEGER(result)[i*nr]),
&(INTEGER(x)[i*nrs_x]),
nrs_x*sizeof(int));
memcpy(&(INTEGER(result)[i*nr + nrs_x]),
&(INTEGER(y)[i*nrs_y]),
nrs_y*sizeof(int));
}
break;
case LGLSXP:
for(i=0; i< ncs_x; i++) {
memcpy(&(LOGICAL(result)[i*nr]),
&(LOGICAL(x)[i*nrs_x]),
nrs_x*sizeof(int));
memcpy(&(LOGICAL(result)[i*nr + nrs_x]),
&(LOGICAL(y)[i*nrs_y]),
nrs_y*sizeof(int));
}
break;
case CPLXSXP:
for(i=0; i< ncs_x; i++) {
memcpy(&(COMPLEX(result)[i*nr]),
&(COMPLEX(x)[i*nrs_x]),
nrs_x*sizeof(Rcomplex));
memcpy(&(COMPLEX(result)[i*nr + nrs_x]),
&(COMPLEX(y)[i*nrs_y]),
nrs_y*sizeof(Rcomplex));
}
break;
case RAWSXP:
for(i=0; i< ncs_x; i++) {
memcpy(&(RAW(result)[i*nr]),
&(RAW(x)[i*nrs_x]),
nrs_x*sizeof(Rbyte));
memcpy(&(RAW(result)[i*nr + nrs_x]),
&(RAW(y)[i*nrs_y]),
nrs_y*sizeof(Rbyte));
}
break;
case STRSXP:
/* this requires an explicit loop like rbind.c and
needs to be left with rbind.c
*/
break;
default:
error("unsupported type");
}
copyAttributes(x, result);
SEXP index, xindex, yindex;
xindex = getAttrib(x, xts_IndexSymbol);
yindex = getAttrib(y, xts_IndexSymbol);
int INDEXTYPE = TYPEOF(xindex);
if(INDEXTYPE != NILSXP) {
PROTECT(index = allocVector(INDEXTYPE, nr));
if(INDEXTYPE==REALSXP) {
memcpy(REAL(index), REAL(xindex), nrs_x * sizeof(double));
memcpy(&(REAL(index)[nrs_x]), REAL(yindex), nrs_y * sizeof(double));
} else
if(INDEXTYPE==INTSXP) {
memcpy(INTEGER(index), INTEGER(xindex), nrs_x * sizeof(int));
memcpy(&(INTEGER(index)[nrs_x]), INTEGER(yindex), nrs_y * sizeof(int));
}
copyMostAttrib(xindex, index);
setAttrib(result, xts_IndexSymbol, index);
UNPROTECT(1);
}
SEXP dim;
PROTECT(dim = allocVector(INTSXP, 2));
INTEGER(dim)[0] = nr;
INTEGER(dim)[1] = ncs_x; /* should be the same */
setAttrib(result, R_DimSymbol, dim);
UNPROTECT(1);
setAttrib(result, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
/*
SEXP dimnames, currentnames, newnames;
PROTECT(dimnames = allocVector(VECSXP, 2));
PROTECT(newnames = allocVector(STRSXP, length(j)));
currentnames = getAttrib(x, R_DimNamesSymbol);
if(!isNull(currentnames)) {
SET_VECTOR_ELT(dimnames, 0, R_NilValue);
for(i=0; i.
*/
#include
#include
#include
#include "xts.h"
SEXP isXts(SEXP x)
{
int i;
SEXP attr, index;
index = getAttrib(x, xts_IndexSymbol);
PROTECT( attr = coerceVector(getAttrib(x, R_ClassSymbol),STRSXP) );
if(length(attr) <= 1) {
UNPROTECT(1);
return Rf_ScalarInteger(0);
}
for(i = 0; i < length(attr); i++) {
if(STRING_ELT(attr, i) == mkChar("xts")) {
/* check for index attribute */
if(TYPEOF(index)==REALSXP || TYPEOF(index)==INTSXP) {
UNPROTECT(1);
return Rf_ScalarInteger(1);
} else {
UNPROTECT(1);
return Rf_ScalarInteger(0);
}
}
}
UNPROTECT(1);
return Rf_ScalarInteger(FALSE);
}
/* test function and example */
SEXP test_isXts(SEXP x)
{
if(Rf_asInteger(isXts(x))) {
Rprintf("TRUE\n");
} else {
Rprintf("FALSE\n");
}
return R_NilValue;
}
xts/src/unique.time.c 0000644 0001762 0000144 00000007475 14634167654 014323 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include "xts.h" /* for coredata_xts */
SEXP make_unique (SEXP index_, SEXP eps_) {
int P = 0, i;
int len = length(index_);
double eps = asReal(eps_);
if (TYPEOF(index_) == INTSXP) {
PROTECT(index_ = coerceVector(index_, REALSXP)); P++;
}
SEXP newindex_ = PROTECT(allocVector(REALSXP, len)); P++;
copyAttributes(index_, newindex_);
double *newindex_real = REAL(newindex_);
memcpy(REAL(newindex_), REAL(index_), len * sizeof(double));
double last_index = newindex_real[0];
int warn_once = 1;
for(i=1; i.
*/
#include
#include
#include "xts.h"
/* http://en.wikipedia.org/wiki/Kahan_summation_algorithm
* sum += x, and updates the accumulated error "c" */
void kahan_sum(long double x, long double * c, long double * sum)
{
/* Author: Ivan Popivanov */
long double y = x - *c;
long double t = *sum + y;
*c = ( t - *sum ) - y;
*sum = t;
}
SEXP roll_sum (SEXP x, SEXP n)
{
/* Author: Joshua Ulrich, with contributions from Ivan Popivanov */
int i, P=0, nrs;
nrs = nrows(x);
/* Get values from pointers */
int int_n = asInteger(n);
/* Initalize result R object */
SEXP result;
PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
int *int_result=NULL, *int_x=NULL;
int int_sum = 0;
double *real_result=NULL, *real_x=NULL;
/* check for non-leading NAs and get first non-NA location */
SEXP first;
PROTECT(first = naCheck(x, ScalarLogical(TRUE))); P++;
int int_first = asInteger(first);
if(int_n + int_first > nrs)
error("not enough non-NA values");
long double sum = 0.0;
long double comp = 0.0;
switch(TYPEOF(x)) {
case REALSXP:
real_result = REAL(result);
real_x = REAL(x);
//int_result = int_x = NULL;
/* set leading NAs, find initial sum value */
for(i=0; i= int_first)
kahan_sum(real_x[i], &comp, &sum);
}
real_result[ int_n + int_first - 1 ] = (double)sum;
/* loop over all other values */
for(i=int_n+int_first; i= int_first)
int_sum += int_x[i];
}
int_result[ int_n + int_first -1 ] = int_sum;
/* loop over all other values */
for(i=int_n+int_first; i nrs)
error("not enough non-NA values");
/* The branch by type allows for fewer type checks/branching
* within the algorithm, providing a _much_ faster mechanism
*/
switch(TYPEOF(x)) {
/* need to implement other types (checking)? */
case REALSXP:
real_result = REAL(result);
real_x = REAL(x);
real_min = real_x[0];
loc = 0;
for(i=0; i= int_n-1) {
/* find the min over the entire window */
real_min = real_x[i];
for(j=0; j= int_n - 1) {
/* find the min over the entire window */
int_min = int_x[i];
for(j=0; j nrs)
error("not enough non-NA values");
/* The branch by type allows for fewer type checks/branching
* within the algorithm, providing a _much_ faster mechanism
*/
switch(TYPEOF(x)) {
/* need to implement other types (checking)? */
case REALSXP:
real_result = REAL(result);
real_x = REAL(x);
real_max = real_x[0];
loc = 0;
for(i=0; i real_max) {
real_max = real_x[i]; /* set min value */
loc = 0; /* set min location in window */
}
loc++;
continue;
} else {
/* if the min leaves the window */
if(loc >= int_n-1) {
/* find the min over the entire window */
real_max = real_x[i];
for(j=0; j real_max) {
real_max = real_x[i-j];
loc = j;
}
}
} else {
/* if the new value is the new min */
if(real_x[i] > real_max) {
real_max = real_x[i];
loc = 0;
}
}
}
/* set result, increment location */
real_result[i] = real_max;
loc++;
}
break;
case INTSXP:
int_result = INTEGER(result);
int_x = INTEGER(x);
int_min = int_x[0];
loc = 0;
for(i=0; i int_min) {
int_min = int_x[i]; /* set min value */
loc = 0; /* set min location in window */
}
loc++;
continue;
} else {
/* if the min leaves the window */
if(loc >= int_n - 1) {
/* find the min over the entire window */
int_min = int_x[i];
for(j=0; j int_min) {
int_min = int_x[i-j];
loc = j;
}
}
} else {
/* if the new value is the new min */
if(int_x[i] > int_min) {
int_min = int_x[i];
loc = 0;
}
}
}
/* set result, increment location */
int_result[i] = int_min;
loc++;
}
break;
/*
case STRSXP: fail!
case LGLSXP: convert to int??
case CPLXSXP:
*/
default:
error("unsupported data type");
}
copyMostAttrib(x, result);
/* still need to set dims and dimnames */
setAttrib(result, R_DimSymbol, getAttrib(x, R_DimSymbol));
setAttrib(result, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
UNPROTECT(P);
return result;
}
SEXP roll_cov (SEXP x, SEXP y, SEXP n, SEXP samp)
{
/* Author: Joshua Ulrich */
int i, P=0;
/* ensure x and y have same length in R functions, since it's
* easier to throw user-informative errors */
int nrx = nrows(x);
int nry = nrows(y);
if(nrx != nry) error("nrx != nry, blame the R function writer");
/* Coerce to REALSXP to ensure roll_sum returns REALSXP */
PROTECT(x = coerceVector(x, REALSXP)); P++;
PROTECT(y = coerceVector(y, REALSXP)); P++;
/* Get values from function arguments */
double *real_x = REAL(PROTECT(coerceVector(x, REALSXP))); P++;
double *real_y = REAL(PROTECT(coerceVector(y, REALSXP))); P++;
int int_n = asInteger(n);
int int_samp = asLogical(samp);
/* Initalize result R object */
SEXP result;
PROTECT(result = allocVector(REALSXP, nrx)); P++;
double *real_result = REAL(result);
/* rolling sums for mean calculation */
SEXP sum_x, sum_y, xy, sum_xy;
PROTECT(sum_x = roll_sum(x, n)); P++;
PROTECT(sum_y = roll_sum(y, n)); P++;
double *real_sum_x = REAL(sum_x);
double *real_sum_y = REAL(sum_y);
/* rolling sum of x * y */
PROTECT(xy = allocVector(REALSXP, nrx)); P++;
double *real_xy = REAL(xy);
for(i=nrx; i--;) {
real_xy[i] = real_x[i] * real_y[i];
}
PROTECT(sum_xy = roll_sum(xy, n)); P++;
double *real_sum_xy = REAL(sum_xy);
/* check for non-leading NAs and get first non-NA location */
SEXP first;
PROTECT(first = naCheck(sum_xy, ScalarLogical(TRUE))); P++;
int int_first = asInteger(first);
if(int_n + int_first > nrx)
error("not enough non-NA values");
/* set leading NAs */
for(i=0; i.
*/
#include
#include
#include
#include
SEXP endpoints (SEXP _x, SEXP _on, SEXP _k, SEXP _addlast /* TRUE */)
{
/*
efficient implementation of:
c(0,which(diff(_x%/%on%/%k+1) != 0),NROW(_x))
*/
int *int_index = NULL;
double *real_index = NULL;
int i=1,j=1, nr, P=0;
int int_tmp[2];
int64_t int64_tmp[2];
/* shouldn't force to INTSXP, as this now excludes
microsecond and millisecond calculations FIXME */
int on = INTEGER(coerceVector(_on,INTSXP))[0];
int k = INTEGER(coerceVector(_k,INTSXP))[0];
nr = nrows(_x);
/* ensure k > 0 (bug #4920) */
if(k <= 0) error("'k' must be > 0");
/* endpoints objects. max nr+2 ( c(0,ep,nr) ) */
SEXP _ep = PROTECT(allocVector(INTSXP,nr+2)); P++;
int *ep = INTEGER(_ep);
/*switch(TYPEOF(getAttrib(_x, install("index")))) {*/
switch(TYPEOF(_x)) {
case INTSXP:
/* start i at second elem */
/*int_index = INTEGER(getAttrib(_x, install("index")));*/
int_index = INTEGER(_x);
ep[0] = 0;
/* special handling if index values < 1970-01-01 00:00:00 UTC */
if(int_index[0] < 0) {
int_tmp[1] = (int_index[0] + 1) / on / k;
for(i=1,j=1; i.
*/
#include
#include
SEXP any_negative (SEXP i_)
{
int i;
int len = length(i_);
int *int_i=NULL;
double *real_i=NULL;
if(TYPEOF(i_)==INTSXP) {
int_i = INTEGER(i_);
for(i=0; i= 0)
continue;
return ScalarLogical(1);
}
} else
if(TYPEOF(i_)==REALSXP) {
real_i = REAL(i_);
for(i=0; i= 0)
continue;
return ScalarLogical(1);
}
}
return ScalarLogical(0);
}
xts/src/merge.c 0000644 0001762 0000144 00000111616 14702522134 013130 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include
#include "xts.h"
SEXP xts_merge_make_colnames (SEXP colnames, SEXP suffixes, SEXP check_names, SEXP env)
{
int p = 0;
SEXP newcolnames = colnames;
// add suffixes
if (R_NilValue != suffixes) {
SEXP args = PROTECT(allocList(3)); p++;
SEXP vals = args;
SETCAR(vals, newcolnames); vals = CDR(vals);
SETCAR(vals, suffixes); vals = CDR(vals);
SETCAR(vals, mkString(""));
SET_TAG(vals, install("sep"));
SEXP expr = PROTECT(LCONS(install("paste"), args)); p++;
PROTECT(newcolnames = eval(expr, env)); p++;
}
// check that names are 'valid R names'
if (LOGICAL(check_names)[0]) {
SEXP args = PROTECT(allocList(2)); p++;
SEXP vals = args;
SETCAR(vals, newcolnames); vals = CDR(vals);
SETCAR(vals, ScalarLogical(1));
SET_TAG(vals, install("unique"));
SEXP expr = PROTECT(LCONS(install("make.names"), args)); p++;
PROTECT(newcolnames = eval(expr, env)); p++;
}
UNPROTECT(p);
return(newcolnames);
}
SEXP xts_merge_make_dimnames (SEXP _x, SEXP _y, int ncol_x, int ncol_y,
SEXP _orig_colnames, SEXP _suffixes, SEXP _check_names, SEXP _env)
{
int p = 0;
int ncols = ncol_x + ncol_y;
SEXP colnames = PROTECT(allocVector(STRSXP, ncols)); p++;
SEXP dimnames_x = PROTECT(getAttrib(_x, R_DimNamesSymbol)); p++;
SEXP dimnames_y = PROTECT(getAttrib(_y, R_DimNamesSymbol)); p++;
// do 'x' and/or 'y' have column names?
SEXP colnames_x = R_NilValue;
SEXP colnames_y = R_NilValue;
if (!isNull(dimnames_x) && !isNull(VECTOR_ELT(dimnames_x, 1))) {
colnames_x = VECTOR_ELT(dimnames_x, 1);
}
if (!isNull(dimnames_y) && !isNull(VECTOR_ELT(dimnames_y, 1))) {
colnames_y = VECTOR_ELT(dimnames_y, 1);
}
// time to combine the two
for (int i = 0; i < ncols; i++) {
if (i < ncol_x) {
// copy column names from 'x'
if (R_NilValue != colnames_x) {
SET_STRING_ELT(colnames, i, STRING_ELT(colnames_x, i));
} else {
SET_STRING_ELT(colnames, i, STRING_ELT(_orig_colnames, i));
}
} else {
// copy column names from 'y'
if (R_NilValue != colnames_y) {
SET_STRING_ELT(colnames, i, STRING_ELT(colnames_y, i - ncol_x));
} else {
SET_STRING_ELT(colnames, i, STRING_ELT(_orig_colnames, i));
}
}
}
colnames = PROTECT(xts_merge_make_colnames(colnames, _suffixes, _check_names, _env)); p++;
SEXP dimnames = PROTECT(allocVector(VECSXP, 2)); p++;
SET_VECTOR_ELT(dimnames, 0, R_NilValue);
SET_VECTOR_ELT(dimnames, 1, colnames);
UNPROTECT(p);
return(dimnames);
}
/*
* These macros allow _XTS_DO_MERGE_ to handle character xts objects as well
* as all the other storage types.
*/
#define _XTS_SET_EQ_(_DES_, _DES_I_, _SRC_, _SRC_I_) \
_DES_[_DES_I_] = _SRC_[_SRC_I_]
#define _XTS_SET_FN_(_DES_, _DES_I_, _SRC_, _SRC_I_) \
SET_STRING_ELT(_DES_, _DES_I_, STRING_ELT(_SRC_, _SRC_I_))
/*
* This is the core merge algorithm. It is implemented as a macro so it can be
* called inside a switch() statement for each coredata storage type. Moving
* the switch() statement outside the main loop improves performance by ~10%.
*
* This macro does (and should) not use any variables that aren't arguments or
* defined within its scope. This isn't enforceable by the compiler, so all the
* local variables have an underscore prefix and suffix to avoid referencing a
* value outside of the macro's scope.
*/
#define _XTS_DO_MERGE_(_RESULT_, _X_, _Y_, _FILL_, _R_JOIN_, _L_JOIN_, \
_INDEX_, _X_INDEX_, _Y_INDEX_, _NROWS_, _X_NR_, _Y_NR_, _X_NC_, _Y_NC_) \
int _xp_ = 1; \
int _yp_ = 1; \
int _i_, _j_, _ij_in_, _ij_out_; \
\
for (_i_ = 0; _i_ < _NROWS_; _i_++) { \
/* If we are past the last row in x, assign NA to merged data \
and copy the y column values to the second side of result \
*/ \
if (_xp_ > _X_NR_) { \
/* past the last row of x */ \
if (_R_JOIN_) { \
_INDEX_[_i_] = _Y_INDEX_[_yp_-1]; \
/* we are out of x-values, so fill merged result with NAs */ \
for (_j_ = 0; _j_ < _X_NC_; _j_++) { /* x-values */ \
_ij_out_ = _i_ + _j_ * _NROWS_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _FILL_, 0); \
} \
for (_j_ = 0; _j_ < _Y_NC_; _j_++) { /* y-values */ \
_ij_out_ = _i_ + (_j_+_X_NC_) * _NROWS_; \
_ij_in_ = (_yp_-1) + _j_ * _Y_NR_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _Y_, _ij_in_); \
} \
} else { \
_i_--; /* if all=FALSE, we must decrement i for each non-match */ \
} \
_yp_++; \
} else if (_yp_ > _Y_NR_) { \
/* past the last row of y */ \
if (_L_JOIN_) { \
_INDEX_[_i_] = _X_INDEX_[_xp_-1]; \
\
for (_j_ = 0; _j_ < _X_NC_; _j_++) { /* x-values */ \
_ij_out_ = _i_ + _j_ * _NROWS_; \
_ij_in_ = (_xp_-1) + _j_ * _X_NR_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _X_, _ij_in_); \
} \
\
/* we are out of y-values, so fill merged result with NAs */ \
for (_j_ = 0; _j_ < _Y_NC_; _j_++) { /* y-values */ \
_ij_out_ = _i_ + (_j_+_X_NC_) * _NROWS_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _FILL_, 0); \
} \
} else { \
_i_--; /* if all=FALSE, we must decrement i for each non-match */ \
} \
_xp_++; \
} else if (_X_INDEX_[_xp_-1] == _Y_INDEX_[_yp_-1]) { \
/* matching index values copy all column values from x and y to results */ \
_INDEX_[_i_] = _X_INDEX_[_xp_-1]; \
\
for (_j_ = 0; _j_ < _X_NC_; _j_++) { /* x-values */ \
_ij_out_ = _i_ + _j_ * _NROWS_; \
_ij_in_ = (_xp_-1) + _j_ * _X_NR_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _X_, _ij_in_); \
} \
for (_j_ = 0; _j_ < _Y_NC_; _j_++) { /* y-values */ \
_ij_out_ = _i_ + (_j_+_X_NC_) * _NROWS_; \
_ij_in_ = (_yp_-1) + _j_ * _Y_NR_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _Y_, _ij_in_); \
} \
_xp_++; \
_yp_++; \
} else if (_X_INDEX_[_xp_-1] < _Y_INDEX_[_yp_-1]) { \
if (_L_JOIN_) { \
_INDEX_[_i_] = _X_INDEX_[_xp_-1]; \
\
for (_j_ = 0; _j_ < _X_NC_; _j_++) { /* x-values */ \
_ij_out_ = _i_ + _j_ * _NROWS_; \
_ij_in_ = (_xp_-1) + _j_ * _X_NR_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _X_, _ij_in_); \
} \
for (_j_ = 0; _j_ < _Y_NC_; _j_++) { /* y-values */ \
_ij_out_ = _i_ + (_j_+_X_NC_) * _NROWS_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _FILL_, 0); \
} \
} else { \
_i_--; \
} \
_xp_++; \
} else if (_X_INDEX_[_xp_-1] > _Y_INDEX_[_yp_-1]) { \
if (_R_JOIN_) { \
_INDEX_[_i_] = _Y_INDEX_[_yp_-1]; \
\
for (_j_ = 0; _j_ < _X_NC_; _j_++) { /* x-values */ \
_ij_out_ = _i_ + _j_ * _NROWS_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _FILL_, 0); \
} \
for (_j_ = 0; _j_ < _Y_NC_; _j_++) { /* y-values */ \
_ij_out_ = _i_ + (_j_+_X_NC_) * _NROWS_; \
_ij_in_ = (_yp_-1) + _j_ * _Y_NR_; \
_XTS_SET_ELT_(_RESULT_, _ij_out_, _Y_, _ij_in_); \
} \
} else { \
_i_--; \
} \
_yp_++; \
} \
} \
/*
This is a merge_join algorithm used to
allow two xts objects to be merged as one
along a common index efficiently and fast
The code is branched for REAL and INTEGER indexed values
which allows for efficient memory usage and minimal
testing/coercion
Copyright Jeffrey A. Ryan 2008
*/
/* do_merge_xts {{{ */
SEXP do_merge_xts (SEXP x, SEXP y,
SEXP all,
SEXP fill,
SEXP retclass,
SEXP colnames,
SEXP suffixes,
SEXP retside,
SEXP check_names,
SEXP env,
SEXP coerce)
{
int nrx, ncx, nry, ncy, len;
int left_join, right_join;
int p = 0;
SEXP xindex, yindex, index, result, attr;
int *int_index=NULL, *int_xindex=NULL, *int_yindex=NULL;
double *real_index=NULL, *real_xindex=NULL, *real_yindex=NULL;
/* Check whether the objects are NULL and treat NULL objects as
* zero-width with an index that matches the non-null object
*/
if (isNull(x) || isNull(y)) {
if (!isNull(x)) {
return(x);
} else {
return(y);
}
}
PROTECT(xindex = getAttrib(x, xts_IndexSymbol)); p++;
/* convert to xts object if needed */
if (!asInteger(isXts(y))) {
SEXP args = PROTECT(allocList(3)); p++;
SEXP vals = args;
SETCAR(vals, y); vals = CDR(vals);
SET_TAG(vals, install("length.out"));
SETCAR(vals, ScalarInteger(length(xindex))); vals = CDR(vals);
SET_TAG(vals, install("error"));
SETCAR(vals, install(".merge.xts.scalar"));
SEXP expr = PROTECT(LCONS(install("try.xts"), args)); p++;
PROTECT(y = eval(expr, env)); p++;
}
if (asInteger(isXts(y))) {
PROTECT(yindex = getAttrib(y, xts_IndexSymbol)); p++;
} else {
PROTECT(yindex = getAttrib(x, xts_IndexSymbol)); p++;
}
if (TYPEOF(retside) != LGLSXP) {
error("retside must be a logical value of TRUE or FALSE");
}
/* determine number of rows and columns to use for the inputs */
int return_x_data = LOGICAL(retside)[0];
int is_xobs_zero = LENGTH(x) == 0;
int is_xdim_null = isNull(getAttrib(x, R_DimSymbol));
nrx = nrows(x);
ncx = ncols(x);
if (return_x_data) {
if (is_xdim_null) {
if (is_xobs_zero) {
nrx = LENGTH(xindex);
ncx = 0;
PROTECT(x = coerceVector(x, TYPEOF(y))); p++;
}
} else {
if (is_xobs_zero) {
nrx = LENGTH(xindex);
ncx = INTEGER(getAttrib(x, R_DimSymbol))[1];
PROTECT(x = coerceVector(x, TYPEOF(y))); p++;
}
}
} else {
nrx = LENGTH(xindex);
ncx = 0;
}
int return_y_data = LOGICAL(retside)[1];
int is_yobs_zero = LENGTH(y) == 0;
int is_ydim_null = isNull(getAttrib(y, R_DimSymbol));
nry = nrows(y);
ncy = ncols(y);
if (return_y_data) {
if (is_ydim_null) {
if (is_yobs_zero) {
nry = LENGTH(yindex);
ncy = 0;
PROTECT(y = coerceVector(y, TYPEOF(x))); p++;
}
} else {
if (is_yobs_zero) {
nry = LENGTH(yindex);
ncy = INTEGER(getAttrib(y, R_DimSymbol))[1];
PROTECT(y = coerceVector(y, TYPEOF(x))); p++;
}
}
} else {
nry = LENGTH(yindex);
ncy = 0;
}
/* do the inputs have any data to merge? */
len = nrx + nry;
if (len < 1 && ncx < 1 && ncy < 1) {
/* return empty xts object if there are no rows or columns */
PROTECT(result = allocVector(TYPEOF(x), 0)); p++;
PROTECT(index = allocVector(TYPEOF(xindex), 0)); p++;
setAttrib(index, xts_IndexTzoneSymbol, getAttrib(xindex, xts_IndexTzoneSymbol));
setAttrib(index, xts_IndexTclassSymbol, getAttrib(xindex, xts_IndexTclassSymbol));
setAttrib(index, xts_IndexTformatSymbol, getAttrib(xindex, xts_IndexTformatSymbol));
setAttrib(result, xts_IndexSymbol, index);
if (LOGICAL(retclass)[0]) {
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
}
setAttrib(result, xts_ClassSymbol, getAttrib(x, xts_ClassSymbol));
UNPROTECT(p);
return result;
}
/* Ensure both indexes are REAL if they are not the same type. */
if (TYPEOF(xindex) != TYPEOF(yindex)) {
PROTECT(xindex = coerceVector(xindex, REALSXP)); p++;
PROTECT(yindex = coerceVector(yindex, REALSXP)); p++;
}
int index_type = TYPEOF(xindex);
if (TYPEOF(all) != LGLSXP) {
error("all must be a logical value of TRUE or FALSE");
}
left_join = INTEGER(all)[0];
right_join = INTEGER(all)[1];
/* determine num_rows of final merged xts object
this seems to only cost 1/1000 of a sec per
1e6 observations. Acceptable 'waste' given
that now we can properly allocate space
for our results
We also check the index type and use the appropriate macros
*/
int i = 0, xp = 1, yp = 1; /* x and y positions in index */
if (index_type == REALSXP) {
real_xindex = REAL(xindex);
real_yindex = REAL(yindex);
/* Check for illegal values before looping. Due to ordered index,
* -Inf must be first, while NA, Inf, and NaN must be last. */
int bad_x_index = nrx > 0 && (!R_FINITE(real_xindex[0]) || !R_FINITE(real_xindex[nrx-1]));
int bad_y_index = nry > 0 && (!R_FINITE(real_yindex[0]) || !R_FINITE(real_yindex[nry-1]));
if (bad_x_index || bad_y_index) {
error("'index' cannot contain 'NA', 'NaN', or '+/-Inf'");
}
while ((xp + yp) <= (len + 1)) {
if (xp > nrx) {
yp++;
if (right_join) i++;
} else if (yp > nry) {
xp++;
if (left_join) i++;
} else {
double xi = real_xindex[xp-1];
double yi = real_yindex[yp-1];
if (xi == yi) {
/* INNER JOIN -- only result if all = FALSE */
yp++;
xp++;
i++;
} else if (xi < yi) {
/* LEFT JOIN */
xp++;
if (left_join) i++;
} else if (xi > yi) {
/* RIGHT JOIN */
yp++;
if (right_join) i++;
} else {
error("Invalid index element comparison (should never happen)");
}
}
}
} else if (index_type == INTSXP) {
int_xindex = INTEGER(xindex);
int_yindex = INTEGER(yindex);
/* Check for NA before looping; logical ops on NA may yield surprising
* results. Note that the NA_integer_ will appear in the last value of
* the index because of sorting at the R level, even though NA_INTEGER
* equals INT_MIN at the C level. */
int bad_x_index = nrx > 0 && int_xindex[nrx-1] == NA_INTEGER;
int bad_y_index = nry > 0 && int_yindex[nry-1] == NA_INTEGER;
if (bad_x_index || bad_y_index) {
error("'index' cannot contain 'NA'");
}
while ((xp + yp) <= (len + 1)) {
if (xp > nrx) {
yp++;
if (right_join) i++;
} else if (yp > nry) {
xp++;
if (left_join) i++;
} else {
int xi = int_xindex[xp-1];
int yi = int_yindex[yp-1];
if (xi == yi) {
/* INNER JOIN -- only result if all = FALSE */
yp++;
xp++;
i++;
} else if (xi < yi) {
/* LEFT JOIN */
xp++;
if (left_join) i++;
} else if (xi > yi) {
/* RIGHT JOIN */
yp++;
if (right_join) i++;
} else {
error("Invalid index element comparison (should never happen)");
}
}
}
} else {
error("'index' must be either double or integer");
}
if (i == 0) {
/* return a zero-length xts object if no rows match, consistent w/zoo */
PROTECT(result = allocMatrix(TYPEOF(x), 0, ncx + ncy)); p++;
PROTECT(index = allocVector(TYPEOF(xindex), 0)); p++;
/* set tclass, tzone, and tformat from x-index */
setAttrib(index, xts_IndexTzoneSymbol, getAttrib(xindex, xts_IndexTzoneSymbol));
setAttrib(index, xts_IndexTclassSymbol, getAttrib(xindex, xts_IndexTclassSymbol));
setAttrib(index, xts_IndexTformatSymbol, getAttrib(xindex, xts_IndexTformatSymbol));
SET_xtsIndex(result, index);
/* dimnames */
if (!isNull(colnames)) {
/* only set DimNamesSymbol if passed colnames is not NULL */
SEXP dimnames = PROTECT(xts_merge_make_dimnames(x, y, ncx, ncy, colnames, suffixes, check_names, env)); p++;
setAttrib(result, R_DimNamesSymbol, dimnames);
}
if (LOGICAL(retclass)[0]) {
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
}
UNPROTECT(p);
return result;
}
int num_rows = i;
xp = 1; yp = 1;
PROTECT(index = allocVector(TYPEOF(xindex), num_rows)); p++;
/* coercion/matching of TYPE for x and y needs to be checked,
either here or in the calling R code. I suspect here is
more useful if other function can call the C code as well.
If objects are not the same type, convert to REALSXP. */
if (asInteger(coerce) || TYPEOF(x) != TYPEOF(y)) {
PROTECT(x = coerceVector(x, REALSXP)); p++;
PROTECT(y = coerceVector(y, REALSXP)); p++;
}
PROTECT(result = allocVector(TYPEOF(x), (ncx + ncy) * num_rows)); p++;
/* Ensure fill is the correct length and type */
if (length(fill) < 1) {
PROTECT(fill = ScalarLogical(NA_LOGICAL)); p++;
}
if (TYPEOF(fill) != TYPEOF(x)) {
PROTECT(fill = coerceVector(fill, TYPEOF(x))); p++;
}
/* There are two type of supported index types, each branched from here */
if (index_type == REALSXP) {
real_index = REAL(index);
switch (TYPEOF(x)) {
case LGLSXP: {
int *lgl_r = LOGICAL(result);
int *lgl_x = LOGICAL(x);
int *lgl_y = LOGICAL(y);
int *lgl_fill = LOGICAL(fill);
#define _XTS_SET_ELT_ _XTS_SET_EQ_
_XTS_DO_MERGE_(lgl_r, lgl_x, lgl_y, lgl_fill, right_join, left_join,
real_index, real_xindex, real_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
case INTSXP: {
int *int_r = INTEGER(result);
int *int_x = INTEGER(x);
int *int_y = INTEGER(y);
int *int_fill = INTEGER(fill);
#define _XTS_SET_ELT_ _XTS_SET_EQ_
_XTS_DO_MERGE_(int_r, int_x, int_y, int_fill, right_join, left_join,
real_index, real_xindex, real_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
case REALSXP: {
double *real_r = REAL(result);
double *real_x = REAL(x);
double *real_y = REAL(y);
double *real_fill = REAL(fill);
#define _XTS_SET_ELT_ _XTS_SET_EQ_
_XTS_DO_MERGE_(real_r, real_x, real_y, real_fill, right_join, left_join,
real_index, real_xindex, real_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
case CPLXSXP: {
Rcomplex *cplx_r = COMPLEX(result);
Rcomplex *cplx_x = COMPLEX(x);
Rcomplex *cplx_y = COMPLEX(y);
Rcomplex *cplx_fill = COMPLEX(fill);
#define _XTS_SET_ELT_ _XTS_SET_EQ_
_XTS_DO_MERGE_(cplx_r, cplx_x, cplx_y, cplx_fill, right_join, left_join,
real_index, real_xindex, real_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
case STRSXP: {
#define _XTS_SET_ELT_ _XTS_SET_FN_
_XTS_DO_MERGE_(result, x, y, fill, right_join, left_join,
real_index, real_xindex, real_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
default:
error("unsupported data type");
break;
}
} else if (index_type == INTSXP) {
int_index = INTEGER(index);
switch (TYPEOF(x)) {
case LGLSXP: {
int *lgl_r = LOGICAL(result);
int *lgl_x = LOGICAL(x);
int *lgl_y = LOGICAL(y);
int *lgl_fill = LOGICAL(fill);
#define _XTS_SET_ELT_ _XTS_SET_EQ_
_XTS_DO_MERGE_(lgl_r, lgl_x, lgl_y, lgl_fill, right_join, left_join,
int_index, int_xindex, int_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
case INTSXP: {
int *int_r = INTEGER(result);
int *int_x = INTEGER(x);
int *int_y = INTEGER(y);
int *int_fill = INTEGER(fill);
#define _XTS_SET_ELT_ _XTS_SET_EQ_
_XTS_DO_MERGE_(int_r, int_x, int_y, int_fill, right_join, left_join,
int_index, int_xindex, int_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
case REALSXP: {
double *real_r = REAL(result);
double *real_x = REAL(x);
double *real_y = REAL(y);
double *real_fill = REAL(fill);
#define _XTS_SET_ELT_ _XTS_SET_EQ_
_XTS_DO_MERGE_(real_r, real_x, real_y, real_fill, right_join, left_join,
int_index, int_xindex, int_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
case CPLXSXP: {
Rcomplex *cplx_r = COMPLEX(result);
Rcomplex *cplx_x = COMPLEX(x);
Rcomplex *cplx_y = COMPLEX(y);
Rcomplex *cplx_fill = COMPLEX(fill);
#define _XTS_SET_ELT_ _XTS_SET_EQ_
_XTS_DO_MERGE_(cplx_r, cplx_x, cplx_y, cplx_fill, right_join, left_join,
int_index, int_xindex, int_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
case STRSXP: {
#define _XTS_SET_ELT_ _XTS_SET_FN_
_XTS_DO_MERGE_(result, x, y, fill, right_join, left_join,
int_index, int_xindex, int_yindex, num_rows, nrx, nry, ncx, ncy);
#undef _XTS_SET_ELT_
}
break;
default:
error("unsupported data type");
break;
}
} else {
error("'index' must be either double or integer");
}
/* following logic to allow for dimensionless xts objects (unsupported)
to be used in Ops.xts calls This maps to how zoo behaves */
if (return_x_data && !return_y_data && is_xdim_null) {
setAttrib(result, R_DimSymbol, R_NilValue);
} else
if (return_y_data && !return_x_data && is_ydim_null) {
setAttrib(result, R_DimSymbol, R_NilValue);
} else /* set Dim and DimNames if there is at least 1 column */
if ((ncx + ncy) > 0) {
/* DIM */
PROTECT(attr = allocVector(INTSXP, 2));
INTEGER(attr)[0] = num_rows;
INTEGER(attr)[1] = ncx + ncy;
setAttrib(result, R_DimSymbol, attr);
UNPROTECT(1);
/* DIMNAMES */
if (!isNull(colnames)) {
/* only set DimNamesSymbol if passed colnames is not NULL */
SEXP dimnames = PROTECT(xts_merge_make_dimnames(x, y, ncx, ncy, colnames, suffixes, check_names, env)); p++;
setAttrib(result, R_DimNamesSymbol, dimnames);
}
} else {
/* only used for zero-width results! xts always has dimension */
setAttrib(result, R_DimSymbol, R_NilValue);
}
setAttrib(result, xts_IndexSymbol, index);
if (LOGICAL(retclass)[0]) {
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
}
setAttrib(result, xts_ClassSymbol, getAttrib(x, xts_ClassSymbol));
copy_xtsAttributes(x, result);
UNPROTECT(p);
return result;
} //}}}
//SEXP mergeXts (SEXP all, SEXP fill, SEXP retclass, SEXP colnames, SEXP retside, SEXP env, SEXP args)
/* called via .External("mergeXts", ...) */
SEXP mergeXts (SEXP args) // mergeXts {{{
{
SEXP _x, _y, xtmp, result, _INDEX;
/* colnames should be renamed as suffixes, as colnames need to be added at the C level */
SEXP all, fill, retc, retclass, symnames,
suffixes, rets, retside, env, tzone, check_names;
int nr, nc, ncs=0;
int index_len;
int i, n=0, P=0;
SEXP argstart;
args = CDR(args); all = CAR(args);
args = CDR(args); fill = CAR(args);
args = CDR(args); retclass = CAR(args);
args = CDR(args); symnames = CAR(args);
args = CDR(args); suffixes = CAR(args);
args = CDR(args); retside = CAR(args);
args = CDR(args); env = CAR(args);
args = CDR(args); tzone = CAR(args);
args = CDR(args); check_names = CAR(args);
args = CDR(args);
/* args should now correspond to the ... objects we are looking to merge */
argstart = args; // use this to rewind list...
n = 0;
int type_of;
SEXP coerce = PROTECT(ScalarInteger(0)); P++;
if (args != R_NilValue) {
type_of = TYPEOF(CAR(args));
}
/* number of columns in the output */
while (args != R_NilValue) {
ncs += xts_ncols(CAR(args));
if (length(CAR(args)) > 0) {
/* need to convert all objects if one non-zero-width needs to be converted */
if (TYPEOF(CAR(args)) != type_of) {
INTEGER(coerce)[0] = 1;
}
}
args = CDR(args);
n++;
}
/* build an index to be used in all subsequent calls */
args = argstart;
_x = CAR(args);
args = CDR(args);
int leading_non_xts = 0;
while (!asInteger(isXts(_x))) {
if (args == R_NilValue) {
error("no xts object to merge");
}
leading_non_xts = 1;
/*warning("leading non-xts objects may have been dropped");*/
_x = CAR(args);
args = CDR(args);
}
/* test for NULLs that may be present from cbind dispatch */
if (!leading_non_xts) {
/* leading non-xts in 2 case scenario was igoring non-xts value */
if (n < 3 && (args == R_NilValue || (isNull(CAR(args)) && length(args) == 1))) { /* no y arg or y==NULL */
UNPROTECT(P);
return(_x);
}
}
if (args != R_NilValue) {
_y = CAR(args);
args = CDR(args);
} else {
PROTECT(_y = duplicate(_x)); P++;
}
if (n > 2 || leading_non_xts) {
/* generalized n-case optimization
currently if n>2 this is faster and more memory efficient
than recursively building a merged object, object by object. */
PROTECT(retc = allocVector(LGLSXP, 1)); P++;
LOGICAL(retc)[0] = 1; /* return class == TRUE */
PROTECT(rets = allocVector(LGLSXP, 2)); P++;
LOGICAL(rets)[0] = 0; /* don't return left */
LOGICAL(rets)[1] = 0; /* don't return right */
if (isNull(_y)) {
PROTECT(_y = duplicate(_x)); P++;
}
/* REPROTECT _INDEX in while loop */
PROTECT_INDEX idx;
PROTECT_WITH_INDEX(_INDEX = do_merge_xts(_x,
_y,
all,
fill,
retc,
R_NilValue,
R_NilValue,
rets,
check_names,
env,
coerce), &idx); P++;
/* merge all objects into one zero-width common index */
while (args != R_NilValue) {
if (!isNull(CAR(args))) {
REPROTECT(_INDEX = do_merge_xts(_INDEX,
CAR(args),
all,
fill,
retc,
R_NilValue,
R_NilValue,
rets,
check_names,
env,
coerce), idx);
}
args = CDR(args);
}
index_len = length(GET_xtsIndex(_INDEX));
args = argstart; // reset args
int ii, jj, iijj, jj_result;
PROTECT(result = allocVector(TYPEOF(_INDEX), index_len * ncs)); P++;
SEXP ColNames, NewColNames;
PROTECT(NewColNames = allocVector(STRSXP, ncs)); P++;
ncs = 0;
/* REPROTECT xtmp inside for loop */
PROTECT_INDEX idxtmp, cnmtmp;
PROTECT_WITH_INDEX(xtmp = NULL, &idxtmp); P++;
PROTECT_WITH_INDEX(ColNames = NULL, &cnmtmp); P++;
/* merge each object with index */
for (i = 0, nc = 0; args != R_NilValue; i = i+nc, args = CDR(args)) {
/* i is object current being merged/copied
* nc is offset in current object
*/
if (isNull(CAR(args))) {
i = i-nc;
continue; // if NULL is passed, skip to the next object.
}
REPROTECT(xtmp = do_merge_xts(_INDEX,
CAR(args),
all,
fill,
retclass,
R_NilValue,
R_NilValue,
retside,
check_names,
env,
coerce), idxtmp);
nr = nrows(xtmp);
nc = xts_ncols(xtmp);
ncs += nc;
/* Use colnames from merged object, if it has them. Otherwise, use
* use deparsed names */
REPROTECT(ColNames = getAttrib(CAR(args),R_DimNamesSymbol), cnmtmp);
SEXP colnames = R_NilValue;
if (R_NilValue != ColNames) {
colnames = VECTOR_ELT(ColNames, 1);
}
if (R_NilValue == colnames) {
for (jj = 0; jj < nc; jj++) {
SET_STRING_ELT(NewColNames, i+jj, STRING_ELT(symnames,i+jj));
}
} else {
for (jj = 0; jj < nc; jj++) {
SET_STRING_ELT(NewColNames, i+jj, STRING_ELT(colnames, jj));
}
}
/* by type, insert merged data into result object */
switch(TYPEOF(xtmp)) {
case LGLSXP:
{
int *xtmp_ = LOGICAL(xtmp);
int *result_ = LOGICAL(result);
for (jj = 0; jj < nc; jj++) {
for (ii = 0; ii < nr; ii++) {
iijj = ii + jj * nr;
jj_result = ii + (i+jj) * nr;
result_[jj_result] = xtmp_[iijj];
}
}
}
break;
case INTSXP:
{
int *xtmp_ = INTEGER(xtmp);
int *result_ = INTEGER(result);
for (jj = 0; jj < nc; jj++) {
for (ii = 0; ii < nr; ii++) {
iijj = ii + jj * nr;
jj_result = ii + (i+jj) * nr;
result_[jj_result] = xtmp_[iijj];
}
}
}
break;
case REALSXP:
{
double *xtmp_ = REAL(xtmp);
double *result_ = REAL(result);
for (jj = 0; jj < nc; jj++) {
for (ii = 0; ii < nr; ii++) {
iijj = ii + jj * nr;
jj_result = ii + (i+jj) * nr;
result_[jj_result] = xtmp_[iijj];
}
}
}
break;
case CPLXSXP:
{
Rcomplex *xtmp_ = COMPLEX(xtmp);
Rcomplex *result_ = COMPLEX(result);
for (jj = 0; jj < nc; jj++) {
for (ii = 0; ii < nr; ii++) {
iijj = ii + jj * nr;
jj_result = ii + (i+jj) * nr;
result_[jj_result] = xtmp_[iijj];
}
}
}
break;
case STRSXP:
{
for (jj = 0; jj < nc; jj++) {
for (ii = 0; ii < nr; ii++) {
iijj = ii + jj * nr;
jj_result = ii + (i+jj) * nr;
SET_STRING_ELT(result, jj_result, STRING_ELT(xtmp, iijj));
}
}
}
break;
default:
error("unsupported data type");
break;
}
}
if (ncs > 0) {
SEXP dim;
PROTECT(dim = allocVector(INTSXP, 2)); P++;
INTEGER(dim)[0] = index_len;
INTEGER(dim)[1] = ncs;
setAttrib(result, R_DimSymbol, dim);
PROTECT(NewColNames = xts_merge_make_colnames(NewColNames, suffixes, check_names, env)); P++;
SEXP dimnames = PROTECT(allocVector(VECSXP, 2)); P++;
SET_VECTOR_ELT(dimnames, 0, R_NilValue);
SET_VECTOR_ELT(dimnames, 1, NewColNames);
setAttrib(result, R_DimNamesSymbol, dimnames);
}
SET_xtsIndex(result, GET_xtsIndex(_INDEX));
copy_xtsCoreAttributes(_INDEX, result);
copy_xtsAttributes(_INDEX, result);
} else { /* 2-case optimization --- simply call main routine */
/* likely bug in handling of merge(1, xts) case */
PROTECT(result = do_merge_xts(_x,
_y,
all,
fill,
retclass,
symnames,
suffixes,
retside,
check_names,
env,
coerce)); P++;
}
SEXP index_tmp = getAttrib(result, xts_IndexSymbol);
PROTECT(index_tmp); P++;
if (isNull(tzone)) {
setAttrib(index_tmp, xts_IndexTzoneSymbol,
getAttrib(getAttrib(_x,xts_IndexSymbol), xts_IndexTzoneSymbol));
} else {
setAttrib(index_tmp, xts_IndexTzoneSymbol, tzone);
}
copyMostAttrib(getAttrib(_x,xts_IndexSymbol), index_tmp);
setAttrib(result, xts_IndexSymbol, index_tmp);
UNPROTECT(P);
return(result);
} //}}} end of mergeXts
xts/src/subset.c 0000644 0001762 0000144 00000034330 14634167654 013353 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include "xts.h"
static SEXP xts_ExtractSubset(SEXP x, SEXP result, SEXP indx) //, SEXP call)
{
/* ExtractSubset is currently copied/inspired by subset.c from GNU-R
This is slated to be reimplemented using the previous method
in xts to get the correct dimnames
*/
int i, ii, n, nx, mode;
SEXP tmp, tmp2;
mode = TYPEOF(x);
n = LENGTH(indx);
nx = length(x);
tmp = result;
/*if (x == R_NilValue)*/
if (isNull(x))
return x;
for (i = 0; i < n; i++) {
ii = INTEGER(indx)[i];
if (ii != NA_INTEGER)
ii--;
switch (mode) {
case LGLSXP:
if (0 <= ii && ii < nx && ii != NA_LOGICAL)
LOGICAL(result)[i] = LOGICAL(x)[ii];
else
LOGICAL(result)[i] = NA_LOGICAL;
break;
case INTSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
INTEGER(result)[i] = INTEGER(x)[ii];
else
INTEGER(result)[i] = NA_INTEGER;
break;
case REALSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
REAL(result)[i] = REAL(x)[ii];
else
REAL(result)[i] = NA_REAL;
break;
case CPLXSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER) {
COMPLEX(result)[i] = COMPLEX(x)[ii];
}
else {
COMPLEX(result)[i].r = NA_REAL;
COMPLEX(result)[i].i = NA_REAL;
}
break;
case STRSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
SET_STRING_ELT(result, i, STRING_ELT(x, ii));
else
SET_STRING_ELT(result, i, NA_STRING);
break;
case VECSXP:
case EXPRSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
SET_VECTOR_ELT(result, i, VECTOR_ELT(x, ii));
else
SET_VECTOR_ELT(result, i, R_NilValue);
break;
case LISTSXP:
/* cannot happen: pairlists are coerced to lists */
case LANGSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER) {
tmp2 = nthcdr(x, ii);
SETCAR(tmp, CAR(tmp2));
SET_TAG(tmp, TAG(tmp2));
}
else
SETCAR(tmp, R_NilValue);
tmp = CDR(tmp);
break;
case RAWSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
RAW(result)[i] = RAW(x)[ii];
else
RAW(result)[i] = (Rbyte) 0;
break;
default:
error("error in subset\n");
break;
}
}
return result;
}
SEXP _do_subset_xts (SEXP x, SEXP sr, SEXP sc, SEXP drop) {
SEXP result;
int i, j, nr, nc, nrs, ncs;
int P=0;
SEXP Dim = getAttrib(x, R_DimSymbol);
nrs = nrows(x);ncs = ncols(x);
nr = length(sr); nc = length(sc);
SEXP oindex, nindex;
oindex = getAttrib(x, xts_IndexSymbol);
PROTECT(nindex = allocVector(TYPEOF(oindex), nr)); P++;
PROTECT(result = allocVector(TYPEOF(x), nr*nc)); P++;
j = 0;
double *real_nindex=NULL, *real_oindex, *real_result=NULL, *real_x=NULL;
int *int_nindex=NULL, *int_oindex, *int_result=NULL, *int_x=NULL;
int *int_sr=NULL, *int_sc=NULL;
int_sr = INTEGER(sr);
int_sc = INTEGER(sc);
copyAttributes(x, result);
if(TYPEOF(x)==LGLSXP) {
int_x = LOGICAL(x);
int_result = LOGICAL(result);
if(TYPEOF(nindex)==INTSXP) {
int_nindex = INTEGER(nindex);
int_oindex = INTEGER(oindex);
for(i=0; i nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
int_nindex[i] = int_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
int_result[i+j*nr] = NA_INTEGER;
else
int_result[i+j*nr] = int_x[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
} else
if(TYPEOF(nindex)==REALSXP) {
real_nindex = REAL(nindex);
real_oindex = REAL(oindex);
for(i=0; i nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
real_nindex[i] = real_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
int_result[i+j*nr] = NA_INTEGER;
else
int_result[i+j*nr] = int_x[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
}
copyAttributes(oindex, nindex);
setAttrib(result, xts_IndexSymbol, nindex);
for(j=1; j nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
int_nindex[i] = int_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
int_result[i+j*nr] = NA_INTEGER;
else
int_result[i+j*nr] = int_x[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
} else
if(TYPEOF(nindex)==REALSXP) {
real_nindex = REAL(nindex);
real_oindex = REAL(oindex);
for(i=0; i nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
real_nindex[i] = real_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
int_result[i+j*nr] = NA_INTEGER;
else
int_result[i+j*nr] = int_x[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
}
copyAttributes(oindex, nindex);
setAttrib(result, xts_IndexSymbol, nindex);
/* loop through remaining columns */
for(j=1; j nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
int_nindex[i] = int_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
real_result[i+j*nr] = NA_REAL;
else
real_result[i+j*nr] = real_x[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
} else
if(TYPEOF(nindex)==REALSXP) {
real_nindex = REAL(nindex);
real_oindex = REAL(oindex);
for(i=0; i nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
real_nindex[i] = real_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
real_result[i+j*nr] = NA_REAL;
else
real_result[i+j*nr] = real_x[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
}
copyAttributes(oindex, nindex);
setAttrib(result, xts_IndexSymbol, nindex);
for(j=1; j nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
int_nindex[i] = int_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER) {
COMPLEX(result)[i+j*nr].r = NA_REAL;
COMPLEX(result)[i+j*nr].i = NA_REAL;
} else
COMPLEX(result)[i+j*nr] = COMPLEX(x)[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
} else
if(TYPEOF(nindex)==REALSXP) {
real_nindex = REAL(nindex);
real_oindex = REAL(oindex);
for(i=0; i nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
real_nindex[i] = real_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER) {
COMPLEX(result)[i+j*nr].r = NA_REAL;
COMPLEX(result)[i+j*nr].i = NA_REAL;
} else
COMPLEX(result)[i+j*nr] = COMPLEX(x)[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
}
copyAttributes(oindex, nindex);
setAttrib(result, xts_IndexSymbol, nindex);
for(j=1; j nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
int_nindex[i] = int_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
SET_STRING_ELT(result, i+j*nr, NA_STRING);
else
SET_STRING_ELT(result, i+j*nr, STRING_ELT(x, int_sr[i]-1 + ((int_sc[j]-1) * nrs)));
}
} else
if(TYPEOF(nindex)==REALSXP) {
real_nindex = REAL(nindex);
real_oindex = REAL(oindex);
for(i=0; i nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
real_nindex[i] = real_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
SET_STRING_ELT(result, i+j*nr, NA_STRING);
else
SET_STRING_ELT(result, i+j*nr, STRING_ELT(x, int_sr[i]-1 + ((int_sc[j]-1) * nrs)));
}
}
copyAttributes(oindex, nindex);
setAttrib(result, xts_IndexSymbol, nindex);
for(j=1; j nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
int_nindex[i] = int_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
RAW(result)[i+j*nr] = 0;
else
RAW(result)[i+j*nr] = RAW(x)[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
} else
if(TYPEOF(nindex)==REALSXP) {
real_nindex = REAL(nindex);
real_oindex = REAL(oindex);
for(i=0; i nrs || int_sc[j] > ncs)
error("'i' or 'j' out of range");
real_nindex[i] = real_oindex[int_sr[i]-1];
if(int_sc[j] == NA_INTEGER)
RAW(result)[i+j*nr] = 0;
else
RAW(result)[i+j*nr] = RAW(x)[int_sr[i]-1 + ((int_sc[j]-1) * nrs)];
}
}
copyAttributes(oindex, nindex);
setAttrib(result, xts_IndexSymbol, nindex);
for(j=1; j= 0 && nc >= 0) {
SEXP dim;
PROTECT(dim = allocVector(INTSXP,2));P++;
INTEGER(dim)[0] = nr;
INTEGER(dim)[1] = nc;
setAttrib(result, R_DimSymbol, dim);
if (nr >= 0 && nc >= 0) {
SEXP dimnames, dimnamesnames, newdimnames;
dimnames = getAttrib(x, R_DimNamesSymbol);
dimnamesnames = getAttrib(dimnames, R_NamesSymbol);
if (!isNull(dimnames)) {
PROTECT(newdimnames = allocVector(VECSXP, 2));
if (TYPEOF(dimnames) == VECSXP) {
SET_VECTOR_ELT(newdimnames, 0,
xts_ExtractSubset(VECTOR_ELT(dimnames, 0),
allocVector(STRSXP, nr), sr));
SET_VECTOR_ELT(newdimnames, 1,
xts_ExtractSubset(VECTOR_ELT(dimnames, 1),
allocVector(STRSXP, nc), sc));
}
else {
SET_VECTOR_ELT(newdimnames, 0,
xts_ExtractSubset(CAR(dimnames),
allocVector(STRSXP, nr), sr));
SET_VECTOR_ELT(newdimnames, 1,
xts_ExtractSubset(CADR(dimnames),
allocVector(STRSXP, nc), sc));
}
setAttrib(newdimnames, R_NamesSymbol, dimnamesnames);
setAttrib(result, R_DimNamesSymbol, newdimnames);
UNPROTECT(1);
}
}
}
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
if(nc == 1 && LOGICAL(drop)[0])
setAttrib(result, R_DimSymbol, R_NilValue);
UNPROTECT(P);
return result;
}
xts/src/binsearch.c 0000644 0001762 0000144 00000013525 14634167654 014007 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include
/* Binary search range to find interval written by Corwin Joy, with
* contributions by Joshua Ulrich
*/
struct keyvec {
double *dvec;
double dkey;
int *ivec;
int ikey;
};
/* Predicate function definition and functions to determine which of the
* two groups contains the value being searched for. Note that they're all
* 'static inline' to hopefully help with the compiler optimizations.
*/
typedef int (*bound_comparer)(const struct keyvec, const int);
static inline int
cmp_dbl_upper(const struct keyvec kv, const int i)
{
const double cv = kv.dvec[i];
const double ck = kv.dkey;
return cv > ck;
}
static inline int
cmp_dbl_lower(const struct keyvec kv, const int i)
{
const double cv = kv.dvec[i];
const double ck = kv.dkey;
return cv >= ck;
}
static inline int
cmp_int_upper(const struct keyvec kv, const int i)
{
const int cv = kv.ivec[i];
const int ck = kv.ikey;
return cv > ck;
}
static inline int
cmp_int_lower(const struct keyvec kv, const int i)
{
const int cv = kv.ivec[i];
const int ck = kv.ikey;
return cv >= ck;
}
/* Binary search function */
SEXP binsearch(SEXP key, SEXP vec, SEXP start)
{
if (!isLogical(start)) {
error("start must be specified as true or false");
}
if (length(vec) < 1 || length(key) < 1) {
return ScalarInteger(NA_INTEGER);
}
int use_start = LOGICAL(start)[0];
bound_comparer cmp_func = NULL;
struct keyvec data;
switch (TYPEOF(vec)) {
case REALSXP:
data.dkey = REAL(key)[0];
data.dvec = REAL(vec);
cmp_func = (use_start) ? cmp_dbl_lower : cmp_dbl_upper;
if (!R_finite(data.dkey)) {
return ScalarInteger(NA_INTEGER);
}
break;
case INTSXP:
data.ikey = INTEGER(key)[0];
data.ivec = INTEGER(vec);
cmp_func = (use_start) ? cmp_int_lower : cmp_int_upper;
if (NA_INTEGER == data.ikey) {
return ScalarInteger(NA_INTEGER);
}
break;
default:
error("unsupported type");
}
int mid;
int lo = 0;
int hi = length(vec) - 1;
while (lo < hi) {
mid = lo + (hi - lo) / 2;
if (cmp_func(data, mid)) {
hi = mid;
}
else {
lo = mid + 1;
}
}
/* 'lo' contains the smallest index where cmp_func() is true, but we need
* to handle edge cases where 'lo' is at the max/min end of the vector.
*/
if (use_start) {
/* cmp_func() := vector[index] >= key when start == true, and we need
* to return the smallest index subject to vector[index] >= key.
*/
if (!cmp_func(data, length(vec)-1)) {
/* entire vector < key */
return ScalarInteger(NA_INTEGER);
}
} else {
/* cmp_func() := vector[index] > key when start == false, and we need
* to return the largest index subject to vector[index] <= key.
*/
if (cmp_func(data, lo)) {
/* previous index value must satisfy vector[index] <= key, unless
* current index value is zero.
*/
lo--;
if (lo < 0) {
/* entire vector > key */
return ScalarInteger(NA_INTEGER);
}
}
}
/* Convert from 0-based index to 1-based index */
lo++;
return ScalarInteger(lo);
}
SEXP fill_window_dups_rev(SEXP _x, SEXP _index)
{
/* Translate user index (_x) to xts index (_index). '_x' contains the
* upper bound of the location of the user index in the xts index.
* This is necessary to handle duplicate dates in the xts index.
*/
int n_x = length(_x);
int *x = INTEGER(_x);
if (length(_index) < 1) {
return allocVector(INTSXP, 0);
}
PROTECT_INDEX px;
SEXP _out;
PROTECT_WITH_INDEX(_out = allocVector(INTSXP, length(_index)), &px);
int *out = INTEGER(_out);
int i, xi, j, k = 0, n_out = length(_out);
switch (TYPEOF(_index)) {
case REALSXP:
{
double *index = REAL(_index);
/* Loop over locations in _x in reverse order */
for (i = n_x; i > 0; i--) {
xi = x[i-1];
j = xi;
do {
/* Check if we need to lengthen output due to duplicates */
if (k == n_out) {
REPROTECT(_out = xlengthgets(_out, k+2*(i+1)), px);
out = INTEGER(_out);
n_out = length(_out);
}
out[k++] = j--;
} while (j > 0 && index[xi-1] == index[j-1]);
}
}
break;
case INTSXP:
{
int *index = INTEGER(_index);
/* Loop over locations in _x in reverse order */
for (i = n_x; i > 0; i--) {
xi = x[i-1];
j = xi;
do {
/* Check if we need to lengthen output due to duplicates */
if (k == n_out) {
REPROTECT(_out = xlengthgets(_out, k+2*(i+1)), px);
out = INTEGER(_out);
n_out = length(_out);
}
out[k++] = j--;
} while (j > 0 && index[xi-1] == index[j-1]);
}
}
break;
default:
error("unsupported index type");
}
/* truncate so length(_out) = k
* NB: output is in reverse order!
*/
REPROTECT(_out = xlengthgets(_out, k), px);
UNPROTECT(1);
return _out;
}
xts/src/subset.old.c 0000644 0001762 0000144 00000021716 14634166720 014125 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
/*
Base code borrowed from R's main/src/subset.c to see how to create a function to subset
an xts object in it's entirety
All modification are by Jeffrey A. Ryan 2008
*/
#include
#include
#include
#include "xts.h"
// xtsExtractSubset {{{
static SEXP xtsExtractSubset(SEXP x, SEXP result, SEXP indx) //, SEXP call)
{
int i, ii, n, nx, mode;
SEXP tmp, tmp2;
mode = TYPEOF(x);
n = LENGTH(indx);
nx = length(x);
tmp = result;
if (x == R_NilValue)
return x;
for (i = 0; i < n; i++) {
ii = INTEGER(indx)[i];
if (ii != NA_INTEGER)
ii--;
switch (mode) {
case LGLSXP:
if (0 <= ii && ii < nx && ii != NA_LOGICAL)
LOGICAL(result)[i] = LOGICAL(x)[ii];
else
LOGICAL(result)[i] = NA_LOGICAL;
break;
case INTSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
INTEGER(result)[i] = INTEGER(x)[ii];
else
INTEGER(result)[i] = NA_INTEGER;
break;
case REALSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
REAL(result)[i] = REAL(x)[ii];
else
REAL(result)[i] = NA_REAL;
break;
case CPLXSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER) {
COMPLEX(result)[i] = COMPLEX(x)[ii];
}
else {
COMPLEX(result)[i].r = NA_REAL;
COMPLEX(result)[i].i = NA_REAL;
}
break;
case STRSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
SET_STRING_ELT(result, i, STRING_ELT(x, ii));
else
SET_STRING_ELT(result, i, NA_STRING);
break;
case VECSXP:
case EXPRSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
SET_VECTOR_ELT(result, i, VECTOR_ELT(x, ii));
else
SET_VECTOR_ELT(result, i, R_NilValue);
break;
case LISTSXP:
/* cannot happen: pairlists are coerced to lists */
case LANGSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER) {
tmp2 = nthcdr(x, ii);
SETCAR(tmp, CAR(tmp2));
SET_TAG(tmp, TAG(tmp2));
}
else
SETCAR(tmp, R_NilValue);
tmp = CDR(tmp);
break;
case RAWSXP:
if (0 <= ii && ii < nx && ii != NA_INTEGER)
RAW(result)[i] = RAW(x)[ii];
else
RAW(result)[i] = (Rbyte) 0;
break;
default:
error("error in subset\n");
// errorcall(call, R_MSG_ob_nonsub, type2char(mode));
break;
}
}
return result;
} //}}}
SEXP do_subset_xts(SEXP x, SEXP sr, SEXP sc, SEXP drop) //SEXP s, SEXP call, int drop)
{
SEXP attr, result, dim;
int nr, nc, nrs, ncs;
int i, j, ii, jj, ij, iijj;
int mode;
int *int_x=NULL, *int_result=NULL, *int_newindex=NULL, *int_index=NULL;
double *real_x=NULL, *real_result=NULL, *real_newindex=NULL, *real_index=NULL;
nr = nrows(x);
nc = ncols(x);
if( length(x)==0 )
return x;
dim = getAttrib(x, R_DimSymbol);
nrs = LENGTH(sr);
ncs = LENGTH(sc);
int *int_sr=NULL, *int_sc=NULL;
int_sr = INTEGER(sr);
int_sc = INTEGER(sc);
mode = TYPEOF(x);
result = allocVector(mode, nrs*ncs);
PROTECT(result);
if( mode==INTSXP ) {
int_x = INTEGER(x);
int_result = INTEGER(result);
} else
if( mode==REALSXP ) {
real_x = REAL(x);
real_result = REAL(result);
}
/* code to handle index of xts object efficiently */
SEXP index, newindex;
int indx;
index = getAttrib(x, xts_IndexSymbol);
PROTECT(index);
if(TYPEOF(index) == INTSXP) {
newindex = allocVector(INTSXP, LENGTH(sr));
PROTECT(newindex);
int_newindex = INTEGER(newindex);
int_index = INTEGER(index);
for(indx = 0; indx < nrs; indx++) {
int_newindex[indx] = int_index[ (int_sr[indx])-1];
}
copyAttributes(index, newindex);
setAttrib(result, xts_IndexSymbol, newindex);
UNPROTECT(1);
}
if(TYPEOF(index) == REALSXP) {
newindex = allocVector(REALSXP, LENGTH(sr));
PROTECT(newindex);
real_newindex = REAL(newindex);
real_index = REAL(index);
for(indx = 0; indx < nrs; indx++) {
real_newindex[indx] = real_index[ (int_sr[indx])-1 ];
}
copyAttributes(index, newindex);
setAttrib(result, xts_IndexSymbol, newindex);
UNPROTECT(1);
}
for (i = 0; i < nrs; i++) {
ii = int_sr[i];
if (ii != NA_INTEGER) {
if (ii < 1 || ii > nr)
error("i is out of range\n");
ii--;
}
/* Begin column loop */
for (j = 0; j < ncs; j++) {
//jj = INTEGER(sc)[j];
jj = int_sc[j];
if (jj != NA_INTEGER) {
if (jj < 1 || jj > nc)
error("j is out of range\n");
jj--;
}
ij = i + j * nrs;
if (ii == NA_INTEGER || jj == NA_INTEGER) {
switch ( mode ) {
case REALSXP:
real_result[ij] = NA_REAL;
break;
case LGLSXP:
case INTSXP:
int_result[ij] = NA_INTEGER;
break;
case CPLXSXP:
COMPLEX(result)[ij].r = NA_REAL;
COMPLEX(result)[ij].i = NA_REAL;
break;
case STRSXP:
SET_STRING_ELT(result, ij, NA_STRING);
break;
case VECSXP:
SET_VECTOR_ELT(result, ij, R_NilValue);
break;
case RAWSXP:
RAW(result)[ij] = (Rbyte) 0;
break;
default:
error("xts subscripting not handled for this type");
break;
}
}
else {
iijj = ii + jj * nr;
switch ( mode ) {
case REALSXP:
real_result[ij] = real_x[iijj];
break;
case LGLSXP:
LOGICAL(result)[ij] = LOGICAL(x)[iijj];
break;
case INTSXP:
int_result[ij] = int_x[iijj];
break;
case CPLXSXP:
COMPLEX(result)[ij] = COMPLEX(x)[iijj];
break;
case STRSXP:
SET_STRING_ELT(result, ij, STRING_ELT(x, iijj));
break;
case VECSXP:
SET_VECTOR_ELT(result, ij, VECTOR_ELT(x, iijj));
break;
case RAWSXP:
RAW(result)[ij] = RAW(x)[iijj];
break;
default:
error("matrix subscripting not handled for this type");
break;
}
}
} /* end of column loop */
} /* end of row loop */
if(nrs >= 0 && ncs >= 0 && !isNull(dim)) {
PROTECT(attr = allocVector(INTSXP, 2));
INTEGER(attr)[0] = nrs;
INTEGER(attr)[1] = ncs;
setAttrib(result, R_DimSymbol, attr);
UNPROTECT(1);
}
/* The matrix elements have been transferred. Now we need to */
/* transfer the attributes. Most importantly, we need to subset */
/* the dimnames of the returned value. */
if (nrs >= 0 && ncs >= 0 && !isNull(dim)) {
SEXP dimnames, dimnamesnames, newdimnames;
dimnames = getAttrib(x, R_DimNamesSymbol);
dimnamesnames = getAttrib(dimnames, R_NamesSymbol);
if (!isNull(dimnames)) {
PROTECT(newdimnames = allocVector(VECSXP, 2));
if (TYPEOF(dimnames) == VECSXP) {
SET_VECTOR_ELT(newdimnames, 0,
xtsExtractSubset(VECTOR_ELT(dimnames, 0),
allocVector(STRSXP, nrs), sr));
SET_VECTOR_ELT(newdimnames, 1,
xtsExtractSubset(VECTOR_ELT(dimnames, 1),
allocVector(STRSXP, ncs), sc));
}
else {
SET_VECTOR_ELT(newdimnames, 0,
xtsExtractSubset(CAR(dimnames),
allocVector(STRSXP, nrs), sr));
SET_VECTOR_ELT(newdimnames, 1,
xtsExtractSubset(CADR(dimnames),
allocVector(STRSXP, ncs), sc));
}
setAttrib(newdimnames, R_NamesSymbol, dimnamesnames);
setAttrib(result, R_DimNamesSymbol, newdimnames);
UNPROTECT(1);
}
}
copyAttributes(x, result);
if(ncs == 1 && LOGICAL(drop)[0])
setAttrib(result, R_DimSymbol, R_NilValue);
UNPROTECT(2);
return result;
}
xts/src/toperiod.c 0000644 0001762 0000144 00000020265 14634166720 013666 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
/*
Possible solution to allow for a generalized single function
might be to pass in a vector of available 'actions':
{0=first, 1=max, 2=min, 3=last, 4=sum}
This would lead to OHLC to have:
0,1,2,3 [,4[,3]]
The current algorithm is in 3 stages per endpoint interation:
Stage 1:
Calculate first (0) of each column, this is the Op and
set Hi and Lo to this value
Stage 2:
Cycle through all x[j] where j is ep[i]:ep[i+1] and i is 1:NROW(ep)
Keep running min, max, and summation (Lo, Hi, "Volume")
Stage 3:
Get last value for close.
Repeat for next endpoint
*/
#include
#include
/*#include */
#include "xts.h"
#ifndef MAX
#define MAX(a,b) (a > b ? a : b)
#endif
#ifndef MIN
#define MIN(a,b) (a < b ? a : b)
#endif
SEXP toPeriod(SEXP x, SEXP endpoints, SEXP hasVolume, SEXP whichVolume, SEXP hasAdjusted, SEXP first, SEXP colnames)
{
SEXP result, ohlc, xindex, newindex, dimnames;
int i, j=0, nrx, ncx, ncr, n, P=0;
nrx = nrows(x);
ncx = ncols(x);
n = nrows(endpoints) - 1;
ncr = 4; /* OHLC */
int mode = TYPEOF(x);
int Hi, Lo, Cl, Vo;
if(ncx >= 4) {
/* needs OHLC or bust, clearly not the best solution
since we can't just skip over columns */
Hi=1; Lo=2; Cl=3;
} else {
Hi=Lo=Cl=0;
}
if(INTEGER(hasVolume)[0]) ncr++; /* Volume */
if(INTEGER(hasAdjusted)[0]) ncr++; /* Adjusted (Yahoo) */
/* handle index values in xts */
PROTECT(xindex = getAttrib(x, xts_IndexSymbol)); P++;
int index_mode = TYPEOF(xindex);
PROTECT(newindex = allocVector(index_mode, n)); P++;
PROTECT(result = allocVector(mode, n * ncr )); P++;
PROTECT(ohlc = allocVector(mode, 6)); P++;
int _FIRST = (INTEGER(first)[0]);
int *ohlc_int = NULL,
*result_int = NULL,
*x_int = NULL;
double *ohlc_real = NULL,
*result_real = NULL,
*x_real = NULL;
switch(mode) {
case INTSXP:
ohlc_int = INTEGER(ohlc);
result_int = INTEGER(result);
x_int = INTEGER(x);
break;
case REALSXP:
ohlc_real = REAL(ohlc);
result_real = REAL(result);
x_real = REAL(x);
break;
default:
error("unsupported type");
}
int *_endpoints = INTEGER(endpoints);
int _hasAdjusted = INTEGER(hasAdjusted)[0];
int _hasVolume = INTEGER(hasVolume)[0];
/* volume column number */
Vo = _hasVolume ? asInteger(whichVolume)-1 : 0;
for(i = 0; i < n; i++) {
j = _endpoints[i];
if(_FIRST) {
switch(index_mode) {
case INTSXP:
INTEGER(newindex)[i] = INTEGER(xindex)[j];
break;
case REALSXP:
REAL(newindex)[i] = REAL(xindex)[j];
break;
}
}
/* set the Open, and initialize High, Low and Volume */
switch(mode) {
case INTSXP:
ohlc_int[0] = x_int[j]; /* Op */
ohlc_int[1] = x_int[j + Hi*nrx]; /* Hi */
ohlc_int[2] = x_int[j + Lo*nrx]; /* Lo */
if(_hasVolume)
ohlc_int[4] = (int)0; /* Vo */
break;
case REALSXP:
ohlc_real[0] = x_real[j]; /* Op */
ohlc_real[1] = x_real[j + Hi*nrx]; /* Hi */
ohlc_real[2] = x_real[j + Lo*nrx]; /* Lo */
if(_hasVolume)
ohlc_real[4] = (double)0; /* Vo */
break;
}
// set the High, Low, and Volume
switch(mode) {
case INTSXP:
for( ; j < _endpoints[i+1]; j++) {
ohlc_int[1] = MAX(ohlc_int[1], x_int[j + Hi*nrx]); /* HI */
ohlc_int[2] = MIN(ohlc_int[2], x_int[j + Lo*nrx]); /* LO */
if(_hasVolume)
ohlc_int[4] = ohlc_int[4] + x_int[j + Vo*nrx]; /* VO */
}
break;
case REALSXP:
for( ; j < _endpoints[i+1]; j++) {
ohlc_real[1] = MAX(ohlc_real[1], x_real[j + Hi*nrx]); /* HI */
ohlc_real[2] = MIN(ohlc_real[2], x_real[j + Lo*nrx]); /* LO */
if(_hasVolume) {
ohlc_real[4] = ohlc_real[4] + x_real[j + Vo*nrx]; /* VO */
}
}
break;
}
/* set the Close and Adjusted columns */
/* Rprintf("i,j: %i,%i\t",i,j); */
j--;
switch(mode) {
case INTSXP:
ohlc_int[3] = x_int[j + Cl*nrx];
if(_hasAdjusted)
ohlc_int[5] = x_int[j + 5*nrx];
break;
case REALSXP:
ohlc_real[3] = x_real[j + Cl*nrx];
if(_hasAdjusted)
ohlc_real[5] = x_real[j + 5*nrx];
break;
}
if(!_FIRST) { /* index at last position */
switch(index_mode) {
case INTSXP:
INTEGER(newindex)[i] = INTEGER(xindex)[j];
break;
case REALSXP:
REAL(newindex)[i] = REAL(xindex)[j];
break;
}
}
/*
switch(mode) {
case INTSXP:
INTEGER(result)[i] = ohlc_int[0];
INTEGER(result)[i+1*n] = ohlc_int[1];
INTEGER(result)[i+2*n] = ohlc_int[2];
INTEGER(result)[i+3*n] = ohlc_int[3];
if(_hasVolume)
INTEGER(result)[i+4*n] = ohlc_int[4];
if(_hasAdjusted)
INTEGER(result)[i+5*n] = ohlc_int[5];
break;
case REALSXP:
REAL(result)[i] = REAL(ohlc)[0];
REAL(result)[i+1*n] = REAL(ohlc)[1];
REAL(result)[i+2*n] = REAL(ohlc)[2];
REAL(result)[i+3*n] = REAL(ohlc)[3];
if(_hasVolume)
REAL(result)[i+4*n] = REAL(ohlc)[4];
if(_hasAdjusted)
REAL(result)[i+5*n] = REAL(ohlc)[5];
break;
}
*/
switch(mode) {
case INTSXP:
result_int[i] = ohlc_int[0];
result_int[i+1*n] = ohlc_int[1];
result_int[i+2*n] = ohlc_int[2];
result_int[i+3*n] = ohlc_int[3];
if(_hasVolume)
result_int[i+4*n] = ohlc_int[4];
if(_hasAdjusted)
result_int[i+5*n] = ohlc_int[5];
break;
case REALSXP:
result_real[i] = ohlc_real[0];
result_real[i+1*n] = ohlc_real[1];
result_real[i+2*n] = ohlc_real[2];
result_real[i+3*n] = ohlc_real[3];
if(_hasVolume)
result_real[i+4*n] = ohlc_real[4];
if(_hasAdjusted)
result_real[i+5*n] = ohlc_real[5];
break;
}
/* Rprintf("i,j: %i,%i\n",i,j); */
}
SEXP dim;
dim = PROTECT(allocVector(INTSXP, 2)); P++;
INTEGER(dim)[0] = n;
INTEGER(dim)[1] = ncr;
setAttrib(result, R_DimSymbol, dim);
PROTECT(dimnames = allocVector(VECSXP, 2)); P++;
SET_VECTOR_ELT(dimnames, 0, R_NilValue); /* no rownames ever! */
if(!isNull(colnames)) {
SET_VECTOR_ELT(dimnames, 1, colnames);
} else {
SEXP newcolnames;
PROTECT(newcolnames = allocVector(STRSXP, ncr));P++;
SET_STRING_ELT(newcolnames, 0, mkChar("Open"));
SET_STRING_ELT(newcolnames, 1, mkChar("High"));
SET_STRING_ELT(newcolnames, 2, mkChar("Low"));
SET_STRING_ELT(newcolnames, 3, mkChar("Close"));
if(INTEGER(hasVolume)[0])
SET_STRING_ELT(newcolnames, 4, mkChar("Volume"));
if(INTEGER(hasAdjusted)[0])
SET_STRING_ELT(newcolnames, 5, mkChar("Adjusted"));
SET_VECTOR_ELT(dimnames, 1, newcolnames);
}
setAttrib(result, R_DimNamesSymbol, dimnames);
copyMostAttrib(xindex, newindex);
setAttrib(result, xts_IndexSymbol, newindex);
copy_xtsAttributes(x, result);
copy_xtsCoreAttributes(x, result);
UNPROTECT(P);
return result;
}
xts/src/init.c 0000644 0001762 0000144 00000014574 14634167654 013021 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 - 2013 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich and Dirk Eddelbuettel
#
# 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, see .
*/
#include "xts.h"
#include
#include
#include
static const
R_CallMethodDef callMethods[] = {
{"add_class", (DL_FUNC) &add_class, 2},
{"coredata_xts", (DL_FUNC) &coredata_xts, 1},
{"do_xtsAttributes", (DL_FUNC) &do_xtsAttributes, 1},
{"add_xtsCoreAttributes", (DL_FUNC) &add_xtsCoreAttributes, 6},
{"lag_xts", (DL_FUNC) &lag_xts, 3},
{"lagXts", (DL_FUNC) &lagXts, 3},
{"do_is_ordered", (DL_FUNC) &do_is_ordered, 3},
{"isXts", (DL_FUNC) &isXts, 1},
{"tryXts", (DL_FUNC) &tryXts, 1},
{"na_locf", (DL_FUNC) &na_locf, 4},
{"na_omit_xts", (DL_FUNC) &na_omit_xts, 1},
{"do_rbind_xts", (DL_FUNC) &do_rbind_xts, 3},
{"_do_subset_xts", (DL_FUNC) &_do_subset_xts, 4},
{"do_merge_xts", (DL_FUNC) &do_merge_xts, 11},
{"naCheck", (DL_FUNC) &naCheck, 2},
{"make_index_unique", (DL_FUNC) &make_index_unique, 2},
{"make_unique", (DL_FUNC) &make_unique, 2},
{"any_negative", (DL_FUNC) &any_negative, 1},
{"extract_col", (DL_FUNC) &extract_col, 5},
{"binsearch", (DL_FUNC) &binsearch, 3},
{"fill_window_dups_rev", (DL_FUNC) &fill_window_dups_rev, 2},
{"non_duplicates", (DL_FUNC) &non_duplicates, 2},
{"roll_min", (DL_FUNC) &roll_min, 2},
{"roll_max", (DL_FUNC) &roll_max, 2},
{"roll_sum", (DL_FUNC) &roll_sum, 2},
{"roll_cov", (DL_FUNC) &roll_cov, 4},
{"toPeriod", (DL_FUNC) &toPeriod, 7},
{"xts_period_apply", (DL_FUNC) &xts_period_apply, 4},
{"xts_period_min", (DL_FUNC) &xts_period_min, 2},
{"xts_period_max", (DL_FUNC) &xts_period_max, 2},
{"xts_period_sum", (DL_FUNC) &xts_period_sum, 2},
{"xts_period_prod", (DL_FUNC) &xts_period_prod, 2},
{"endpoints", (DL_FUNC) &endpoints, 4},
{"dimnames_zoo", (DL_FUNC) &dimnames_zoo, 1},
{"xts_set_dimnames", (DL_FUNC) &xts_set_dimnames, 2},
{"do_startofyear", (DL_FUNC) &do_startofyear, 3},
{NULL, NULL, 0}
};
static const
R_ExternalMethodDef externalMethods[] = {
{"number_of_cols", (DL_FUNC) &number_of_cols, -1},
{"mergeXts", (DL_FUNC) &mergeXts, -1},
{"rbindXts", (DL_FUNC) &rbindXts, -1},
{NULL, NULL, 0}
};
/* define globals */
SEXP xts_IndexSymbol;
SEXP xts_ClassSymbol;
SEXP xts_IndexTformatSymbol;
SEXP xts_IndexTclassSymbol;
SEXP xts_IndexTzoneSymbol;
/* define imports from zoo */
SEXP (*zoo_lag)(SEXP,SEXP,SEXP);
SEXP (*zoo_coredata)(SEXP,SEXP);
/*
* Taken from R/src/main/names.c
* "Set up a set of globals so that a symbol table search can be
* avoided when matching something like dim or dimnames."
*
* This also prevents flags from rchk's maacheck (Multiple-Allocating-
* Arguments) tool for calls like:
* setAttrib(result, xts_IndexSymbol, getAttrib(x, xts_IndexSymbol));
*/
static void SymbolShortcuts(void)
{
xts_IndexSymbol = install("index");
xts_ClassSymbol = install(".CLASS");
xts_IndexTformatSymbol = install("tformat");
xts_IndexTclassSymbol = install("tclass");
xts_IndexTzoneSymbol = install("tzone");
}
void R_init_xts(DllInfo *info)
{
SymbolShortcuts();
R_registerRoutines(info,
NULL,
callMethods,
NULL,
externalMethods);
R_useDynamicSymbols(info, FALSE);
R_forceSymbols(info, TRUE);
/* used by external packages linking to internal xts code from C */
R_RegisterCCallable("xts","do_is_ordered",(DL_FUNC) &do_is_ordered);
R_RegisterCCallable("xts","coredata_xts", (DL_FUNC) &coredata_xts);
R_RegisterCCallable("xts","isXts", (DL_FUNC) &isXts);
R_RegisterCCallable("xts","tryXts", (DL_FUNC) &tryXts);
R_RegisterCCallable("xts","do_rbind_xts", (DL_FUNC) &do_rbind_xts);
R_RegisterCCallable("xts","naCheck", (DL_FUNC) &naCheck);
R_RegisterCCallable("xts","lagXts", (DL_FUNC) &lagXts);
R_RegisterCCallable("xts","make_index_unique", (DL_FUNC) &make_index_unique);
R_RegisterCCallable("xts","make_unique", (DL_FUNC) &make_unique);
R_RegisterCCallable("xts","endpoints", (DL_FUNC) &endpoints);
R_RegisterCCallable("xts","do_merge_xts", (DL_FUNC) &do_merge_xts);
R_RegisterCCallable("xts","na_omit_xts", (DL_FUNC) &na_omit_xts);
R_RegisterCCallable("xts","na_locf", (DL_FUNC) &na_locf);
R_RegisterCCallable("xts","xts_period_min", (DL_FUNC) &xts_period_min);
R_RegisterCCallable("xts","xts_period_max", (DL_FUNC) &xts_period_max);
R_RegisterCCallable("xts","xts_period_sum", (DL_FUNC) &xts_period_sum);
R_RegisterCCallable("xts","xts_period_prod", (DL_FUNC) &xts_period_prod);
R_RegisterCCallable("xts","xts_set_dimnames", (DL_FUNC) &xts_set_dimnames);
/* used by xts (functions moved from xts to zoo) */
zoo_lag = (SEXP(*)(SEXP,SEXP,SEXP)) R_GetCCallable("zoo","zoo_lag");
zoo_coredata = (SEXP(*)(SEXP,SEXP)) R_GetCCallable("zoo","zoo_coredata");
}
xts/src/attr.c 0000644 0001762 0000144 00000012334 14636572747 013025 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include
#include "xts.h"
SEXP do_xtsAttributes(SEXP x)
{
SEXP a, values, names;
int i=0, P=0;
a = ATTRIB(x);
if(length(a) <= 0)
return R_NilValue;
PROTECT(a); P++; /* all attributes */
PROTECT(values = allocVector(VECSXP, length(a))); P++;
PROTECT(names = allocVector(STRSXP, length(a))); P++;
/*
CAR gets the first element of the dotted pair list
CDR gets the rest of the dotted pair list
TAG gets the symbol/name of the first element of dotted pair list
*/
for( /* a=ATTRIB(a) */; a != R_NilValue; a = CDR(a) ) {
if(TAG(a) != xts_IndexSymbol &&
TAG(a) != xts_ClassSymbol &&
TAG(a) != R_ClassSymbol &&
TAG(a) != R_DimSymbol &&
TAG(a) != R_DimNamesSymbol &&
TAG(a) != R_NamesSymbol)
{
SET_VECTOR_ELT(values, i, CAR(a));
SET_STRING_ELT(names, i, PRINTNAME(TAG(a)));
i++;
}
}
if(i == 0) {
UNPROTECT(P);
return R_NilValue;
}
/* truncate list back to i-size */
PROTECT(values = lengthgets(values, i)); P++;
PROTECT(names = lengthgets(names, i)); P++;
setAttrib(values, R_NamesSymbol, names);
UNPROTECT(P);
return values;
}
SEXP do_xtsCoreAttributes(SEXP x)
{
SEXP a, values, names;
int i=0, P=0;
a = ATTRIB(x);
if(length(a) <= 0)
return R_NilValue;
PROTECT(a); P++; /* all attributes */
PROTECT(values = allocVector(VECSXP, length(a))); P++;
PROTECT(names = allocVector(STRSXP, length(a))); P++;
/*
CAR gets the first element of the dotted pair list
CDR gets the rest of the dotted pair list
TAG gets the symbol/name of the first element of dotted pair list
*/
for( /* a=ATTRIB(a) */; a != R_NilValue; a = CDR(a) ) {
if(TAG(a) == xts_ClassSymbol ||
TAG(a) == R_ClassSymbol)
{
SET_VECTOR_ELT(values, i, CAR(a));
SET_STRING_ELT(names, i, PRINTNAME(TAG(a)));
i++;
}
}
if(i == 0) {
UNPROTECT(P);
return R_NilValue;
}
/* truncate list back to i-size */
PROTECT(values = lengthgets(values, i)); P++;
PROTECT(names = lengthgets(names, i)); P++;
setAttrib(values, R_NamesSymbol, names);
UNPROTECT(P);
return values;
}
void copyAttributes(SEXP x, SEXP y)
{
/* similar to copyMostAttr except that we add index
to the list of attributes to exclude */
SEXP attr;
int P=0;
attr = ATTRIB(x); /* this returns a LISTSXP */
if(length(attr) > 0 || y != R_NilValue) {
PROTECT(attr); P++;
for( ; attr != R_NilValue; attr = CDR(attr) ) {
if( (TAG(attr) != xts_IndexSymbol) &&
(TAG(attr) != R_DimSymbol) &&
(TAG(attr) != R_DimNamesSymbol) &&
(TAG(attr) != R_NamesSymbol) ) {
setAttrib(y, TAG(attr), CAR(attr));
}
}
UNPROTECT(P);
}
}
void copy_xtsAttributes(SEXP x, SEXP y)
{
SEXP attr;
int P=0;
attr = PROTECT(do_xtsAttributes(x)); P++;
attr = PROTECT(coerceVector(attr, LISTSXP)); P++;
if(length(attr) > 0 || y != R_NilValue) {
for( ; attr != R_NilValue; attr = CDR(attr) ) {
setAttrib(y, TAG(attr), CAR(attr));
}
}
UNPROTECT(P);
}
void copy_xtsCoreAttributes(SEXP x, SEXP y)
{
SEXP attr;
int P=0;
attr = PROTECT(do_xtsCoreAttributes(x)); P++;
attr = PROTECT(coerceVector(attr, LISTSXP)); P++;
if(length(attr) > 0 || y != R_NilValue) {
for( ; attr != R_NilValue; attr = CDR(attr) ) {
setAttrib(y, TAG(attr), CAR(attr));
}
}
UNPROTECT(P);
}
SEXP ca (SEXP x, SEXP y)
{
/* an example of internal copying of user-defined xts attributes
this will be used inside of do_xts_subset and do_xts_merge
This particular usage is bad, as y is modified without copying
resulting in all y and reference to y within R envir being altered
the 'y' should only be the new value that is to be returned */
copy_xtsAttributes(x,y);
return R_NilValue;
}
SEXP add_xtsCoreAttributes(SEXP _x, SEXP _index, SEXP _tzone,
SEXP _tclass, SEXP _class, SEXP _tformat)
{
int P=0;
if(MAYBE_SHARED(_index)) {
PROTECT(_index = duplicate(_index)); P++;
}
/* add tzone and tclass to index */
setAttrib(_index, xts_IndexTclassSymbol, _tclass);
setAttrib(_index, xts_IndexTzoneSymbol, _tzone);
setAttrib(_index, xts_IndexTformatSymbol, _tformat);
if(MAYBE_SHARED(_x)) {
PROTECT(_x = duplicate(_x)); P++;
//_x = duplicate(_x);
}
setAttrib(_x, xts_IndexSymbol, _index); /* index */
setAttrib(_x, R_ClassSymbol, _class); /* class */
UNPROTECT(P);
return(_x);
}
xts/src/Makevars 0000644 0001762 0000144 00000000041 14636572747 013373 0 ustar ligges users PKG_CPPFLAGS = -I../inst/include
xts/src/startofyear.c 0000644 0001762 0000144 00000004657 14634167654 014422 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
SEXP do_startofyear (SEXP _from, SEXP _to, SEXP _origin)
{
// do_startofyear {{{
int i, P = 0;
int from = INTEGER(_from)[0];
int to = INTEGER(_to)[0];
int origin = INTEGER(_origin)[0];
// _fromto is a vector of length (from:to)
SEXP _fromto = PROTECT(allocVector(INTSXP, to-from+1)); P++;
int *fromto = INTEGER(_fromto);
int nyear[1] = { (to - from + 1) };
int leap[nyear[0]];
// generate sequence of dates to work with
fromto[0] = from;
for(i=1; i < nyear[0]; i++) {
fromto[i] = fromto[i-1] + 1;
}
for(i = 0; i < nyear[0]; i++) {
leap[ i ] = ( (fromto[ i ] % 4 == 0 && fromto[ i ] % 100 != 0)
||
fromto[ i ] % 400 == 0) ? 1 : 0;
}
for(i=0; i < nyear[0]; i++) {
if(leap[i] == 1) { // a leapyear (366 days)
fromto[i] = 366;
} else { // a non-leapyear (365 days)
fromto[i] = 365;
}
}
/*
fromto now has proper number of days per year
now calculate the cumulative sum back from origin (negative)
and from origin (positive)
*/
int days_before_origin = origin - from;
//int days_after_origin = nyear[0] - days_before_origin - 1; //why is this here?
int tmp=0;
for(i = days_before_origin; i < nyear[0]; i++) {
tmp += fromto[i];
fromto[i] = tmp;
}
tmp = 0;
for(i = days_before_origin-1; i >= 0; i--) {
tmp -= fromto[i];
fromto[i] = tmp;
}
/* now insert a 0 at the origin, by going backwards */
for(i = nyear[0] - 1; i > days_before_origin; i--)
fromto[ i ] = fromto[ i-1 ];
fromto[ days_before_origin ] = 0;
UNPROTECT(P);
return _fromto;
} //}}}
xts/src/period_quantile.c 0000644 0001762 0000144 00000004401 14634167654 015226 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan (FORTRAN implementation)
# Copyright (C) 2018 Joshua M. Ulrich (C implementation)
#
# 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, see .
*/
#include
SEXP xts_period_max(SEXP _data, SEXP _index)
{
if (ncols(_data) > 1) {
error("single column data only");
}
if (!isInteger(_index)) {
error("index must be integer");
}
if (!isReal(_data)) {
error("data must be double");
}
int i, j;
int n = length(_index) - 1;
SEXP _result = PROTECT(allocVector(REALSXP, n));
double *result = REAL(_result);
int *index = INTEGER(_index);
double *data = REAL(_data);
int k = 0;
for (i = 0; i < n; i++) {
int idx0 = index[i];
int idx1 = index[i + 1];
double max = data[idx0];
for (j = idx0+1; j < idx1; j++) {
if (data[j] > max) {
max = data[j];
}
}
result[k++] = max;
}
UNPROTECT(1);
return _result;
}
SEXP xts_period_min(SEXP _data, SEXP _index)
{
if (ncols(_data) > 1) {
error("single column data only");
}
if (!isInteger(_index)) {
error("index must be integer");
}
if (!isReal(_data)) {
error("data must be double");
}
int i, j;
int n = length(_index) - 1;
SEXP _result = PROTECT(allocVector(REALSXP, n));
double *result = REAL(_result);
int *index = INTEGER(_index);
double *data = REAL(_data);
int k = 0;
for (i = 0; i < n; i++) {
int idx0 = index[i];
int idx1 = index[i + 1];
double min = data[idx0];
for (j = idx0+1; j < idx1; j++) {
if (data[j] < min) {
min = data[j];
}
}
result[k++] = min;
}
UNPROTECT(1);
return _result;
}
xts/src/extract_col.c 0000644 0001762 0000144 00000013705 14634167654 014360 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include "xts.h"
/*
provide fast memcpy extraction by column
major orientation for matrix objects. Should
be as fast as extracting list elements or
data.frame columns in R. ( update: it is much faster actually -jar )
One key difference is that we are also reattaching
the index attribute to allow for the object to
remain a zoo/xts object
*/
SEXP extract_col (SEXP x, SEXP j, SEXP drop, SEXP first_, SEXP last_) {
SEXP result, index, new_index;
int nrs, nrsx, i, ii, jj, first, last;
/* ensure 'j' is integer with length > 0 */
if(length(j) == 0) {
error("'j' cannot have zero length");
}
if(asInteger(j) == 0) {
error("'j' cannot equal 0");
}
nrsx = nrows(x);
first = asInteger(first_)-1;
last = asInteger(last_)-1;
/* nrs = offset_end - offset_start - 1; */
nrs = last - first + 1;
PROTECT(result = allocVector(TYPEOF(x), nrs * length(j)));
switch(TYPEOF(x)) {
case REALSXP:
for(i=0; i.
*/
#include
#include
#include
#include "xts.h"
/* Internal use only
* called by: firstNonNA, naCheck, na_locf
*/
static int firstNonNACol (SEXP x, int col)
{
int i=0, nr;
int *int_x=NULL;
double *real_x=NULL;
nr = nrows(x);
if(col > ncols(x)-1 || col < 0L)
error("column out of range");
switch(TYPEOF(x)) {
case LGLSXP:
int_x = LOGICAL(x);
for(i=0+col*nr; i<(nr+col*nr); i++) {
if(int_x[i]!=NA_LOGICAL) {
break;
}
}
break;
case INTSXP:
int_x = INTEGER(x);
for(i=0+col*nr; i<(nr+col*nr); i++) {
if(int_x[i]!=NA_INTEGER) {
break;
}
}
break;
case REALSXP:
real_x = REAL(x);
for(i=0+col*nr; i<(nr+col*nr); i++) {
if(!ISNA(real_x[i]) && !ISNAN(real_x[i])) {
break;
}
}
break;
case STRSXP:
for(i=0+col*nr; i<(nr+col*nr); i++) {
if(STRING_ELT(x, i)!=NA_STRING) {
break;
}
}
break;
default:
error("unsupported type");
break;
}
return(i);
}
/* Should be internal use only (static), but is in xts.h
*/
int firstNonNA (SEXP x)
{
return firstNonNACol(x, 0);
}
SEXP naCheck (SEXP x, SEXP check)
{
/*
Check for non-leading NA values, throw error if found
*/
SEXP first;
int _first;
_first = firstNonNA(x);
PROTECT(first = allocVector(INTSXP, 1));
INTEGER(first)[0] = _first;
if(LOGICAL(check)[0]) {
/* check for NAs in rest of data */
int i, nr;
int *int_x = NULL;
double *real_x = NULL;
nr = nrows(x);
switch(TYPEOF(x)) {
case LGLSXP:
int_x = LOGICAL(x);
for(i=_first; i (int)maxgap) { /* check that we don't have excessive trailing gap */
for(ii = i-1; ii > i-gap-1; ii--) {
int_result[ii] = NA_LOGICAL;
}
}
}
} else {
/* nr-2 is first position to fill fromLast=TRUE */
for(j=0; j < nc; j++) {
int_result[nr-1+j*nr] = int_x[nr-1+j*nr];
gap = 0;
for(i=nr-2 + j*nr; i>=0+j*nr; i--) {
int_result[i] = int_x[i];
if(int_result[i] == NA_LOGICAL && gap < maxgap) {
int_result[i] = int_result[i+1];
gap++;
}
}
}
}
break;
case INTSXP:
int_x = INTEGER(x);
int_result = INTEGER(result);
if(!LOGICAL(fromLast)[0]) {
for(j=0; j < nc; j++) {
/* copy leading NAs */
_first = firstNonNACol(x, j);
if (_first == nr + j*nr)
_first--;
for(i=0+j*nr; i < (_first+1); i++) {
int_result[i] = int_x[i];
}
/* result[_first] now has first value fromLast=FALSE */
gap = 0;
for(i=_first+1; i gap)
int_result[i] = int_result[i-1];
gap++;
} else {
if((int)gap > (int)maxgap) {
for(ii = i-1; ii > i-gap-1; ii--) {
int_result[ii] = NA_INTEGER;
}
}
gap=0;
}
}
if((int)gap > (int)maxgap) { /* check that we don't have excessive trailing gap */
for(ii = i-1; ii > i-gap-1; ii--) {
int_result[ii] = NA_INTEGER;
}
}
}
} else {
/* nr-2 is first position to fill fromLast=TRUE */
for(j=0; j < nc; j++) {
int_result[nr-1+j*nr] = int_x[nr-1+j*nr];
gap = 0;
for(i=nr-2 + j*nr; i>=0+j*nr; i--) {
int_result[i] = int_x[i];
if(int_result[i] == NA_INTEGER) {
if(limit > gap)
int_result[i] = int_result[i+1];
gap++;
} else {
if((int)gap > (int)maxgap) {
for(ii = i+1; ii < i+gap+1; ii++) {
int_result[ii] = NA_INTEGER;
}
}
gap=0;
}
}
if((int)gap > (int)maxgap) { /* check that we don't have leading trailing gap */
for(ii = i+1; ii < i+gap+1; ii++) {
int_result[ii] = NA_INTEGER;
}
}
}
}
break;
case REALSXP:
real_x = REAL(x);
real_result = REAL(result);
if(!LOGICAL(fromLast)[0]) { /* fromLast=FALSE */
for(j=0; j < nc; j++) {
/* copy leading NAs */
_first = firstNonNACol(x, j);
if (_first == nr + j*nr)
_first--;
for(i=0+j*nr; i < (_first+1); i++) {
real_result[i] = real_x[i];
}
/* result[_first] now has first value fromLast=FALSE */
gap = 0;
for(i=_first+1; i gap)
real_result[i] = real_result[i-1];
gap++;
} else {
if((int)gap > (int)maxgap) {
for(ii = i-1; ii > i-gap-1; ii--) {
real_result[ii] = NA_REAL;
}
}
gap=0;
}
}
if((int)gap > (int)maxgap) { /* check that we don't have excessive trailing gap */
for(ii = i-1; ii > i-gap-1; ii--) {
real_result[ii] = NA_REAL;
}
}
}
} else { /* fromLast=TRUE */
for(j=0; j < nc; j++) {
real_result[nr-1+j*nr] = real_x[nr-1+j*nr];
gap = 0;
for(i=nr-2 + j*nr; i>=0+j*nr; i--) {
real_result[i] = real_x[i];
if(ISNA(real_result[i]) || ISNAN(real_result[i])) {
if(limit > gap)
real_result[i] = real_result[i+1];
gap++;
} else {
if((int)gap > (int)maxgap) {
for(ii = i+1; ii < i+gap+1; ii++) {
real_result[ii] = NA_REAL;
}
}
gap=0;
}
}
if((int)gap > (int)maxgap) { /* check that we don't have leading trailing gap */
for(ii = i+1; ii < i+gap+1; ii++) {
real_result[ii] = NA_REAL;
}
}
}
}
break;
case STRSXP:
if(!LOGICAL(fromLast)[0]) { /* fromLast=FALSE */
for(j=0; j < nc; j++) {
/* copy leading NAs */
_first = firstNonNACol(x, j);
if (_first == nr + j*nr)
_first--;
for(i=0+j*nr; i < (_first+1); i++) {
SET_STRING_ELT(result, i, STRING_ELT(x, i));
}
/* result[_first] now has first value fromLast=FALSE */
gap = 0;
for(i=_first+1; i gap)
SET_STRING_ELT(result, i, STRING_ELT(result, i-1));
gap++;
} else {
if((int)gap > (int)maxgap) {
for(ii = i-1; ii > i-gap-1; ii--) {
SET_STRING_ELT(result, ii, NA_STRING);
}
}
gap=0;
}
}
if((int)gap > (int)maxgap) { /* check that we don't have excessive trailing gap */
for(ii = i-1; ii > i-gap-1; ii--) {
SET_STRING_ELT(result, ii, NA_STRING);
}
}
}
} else { /* fromLast=TRUE */
for(j=0; j < nc; j++) {
SET_STRING_ELT(result, nr-1+j*nr, STRING_ELT(x, nr-1+j*nr));
gap = 0;
for(i=nr-2 + j*nr; i>=0+j*nr; i--) {
SET_STRING_ELT(result, i, STRING_ELT(x, i));
if(STRING_ELT(result, i) == NA_STRING) {
if(limit > gap)
SET_STRING_ELT(result, i, STRING_ELT(result, i+1));
gap++;
} else {
if((int)gap > (int)maxgap) {
for(ii = i+1; ii < i+gap+1; ii++) {
SET_STRING_ELT(result, ii, NA_STRING);
}
}
gap=0;
}
}
if((int)gap > (int)maxgap) { /* check that we don't have leading trailing gap */
for(ii = i+1; ii < i+gap+1; ii++) {
SET_STRING_ELT(result, ii, NA_STRING);
}
}
}
}
break;
default:
error("unsupported type");
break;
}
if(Rf_asInteger(isXts(x))) {
setAttrib(result, R_DimSymbol, getAttrib(x, R_DimSymbol));
setAttrib(result, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
setAttrib(result, xts_IndexSymbol, getAttrib(x, xts_IndexSymbol));
copy_xtsCoreAttributes(x, result);
copy_xtsAttributes(x, result);
}
UNPROTECT(P);
return(result);
}
SEXP na_omit_xts (SEXP x)
{
SEXP na_index, not_na_index, col_index, result;
int i, j, ij, nr, nc;
int not_NA, NA;
nr = nrows(x);
nc = ncols(x);
not_NA = nr;
int *int_x=NULL, *int_na_index=NULL, *int_not_na_index=NULL;
double *real_x=NULL;
switch(TYPEOF(x)) {
case LGLSXP:
for(i=0; i.
*/
#include
SEXP xts_period_prod(SEXP _data, SEXP _index)
{
if (ncols(_data) > 1) {
error("single column data only");
}
if (!isInteger(_index)) {
error("index must be integer");
}
if (!isReal(_data)) {
error("data must be double");
}
int i, j;
int n = length(_index) - 1;
SEXP _result = PROTECT(allocVector(REALSXP, n));
double *result = REAL(_result);
int *index = INTEGER(_index);
double *data = REAL(_data);
int k = 0;
for (i = 0; i < n; i++) {
int idx0 = index[i];
int idx1 = index[i + 1];
double prod = data[idx0];
for (j = idx0+1; j < idx1; j++) {
prod *= data[j];
}
result[k++] = prod;
}
UNPROTECT(1);
return _result;
}
SEXP xts_period_sum(SEXP _data, SEXP _index)
{
if (ncols(_data) > 1) {
error("single column data only");
}
if (!isInteger(_index)) {
error("index must be integer");
}
if (!isReal(_data)) {
error("data must be double");
}
int i, j;
int n = length(_index) - 1;
SEXP _result = PROTECT(allocVector(REALSXP, n));
double *result = REAL(_result);
int *index = INTEGER(_index);
double *data = REAL(_data);
int k = 0;
for (i = 0; i < n; i++) {
int idx0 = index[i];
int idx1 = index[i + 1];
double sum = data[idx0];
for (j = idx0+1; j < idx1; j++) {
sum += data[j];
}
result[k++] = sum;
}
UNPROTECT(1);
return _result;
}
xts/src/add_class.c 0000644 0001762 0000144 00000001753 14634167023 013754 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include
SEXP add_class (SEXP x, SEXP class)
{
if(MAYBE_SHARED(x))
x = duplicate(x);
setAttrib(x, R_ClassSymbol, class);
return(x);
}
xts/src/totalcols.c 0000644 0001762 0000144 00000003041 14636572747 014052 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include
#include "xts.h"
int xts_ncols (SEXP _x)
{
int ncols_x = 0;
// use dims if possible
if (isNull(getAttrib(_x, R_DimSymbol))) {
// no dims, so we want:
// * ncols_x == 0 for zero-length vectors, and
// * ncols_x == 1 for anything else that doesn't have dims
ncols_x = LENGTH(_x) > 0;
} else {
// use dims
ncols_x = INTEGER(getAttrib(_x, R_DimSymbol))[1];
}
return ncols_x;
}
SEXP number_of_cols (SEXP args)
{
int i = 0;
args = CDR(args); // calling function name
SEXP tcols = PROTECT(allocVector(INTSXP, length(args)));
for(;args != R_NilValue; i++, args = CDR(args)) {
INTEGER(tcols)[i] = xts_ncols(CAR(args));
}
UNPROTECT(1);
return tcols;
}
xts/src/period_apply.c 0000644 0001762 0000144 00000004773 14634167654 014545 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan (FORTRAN implementation)
# Copyright (C) 2018 Joshua M. Ulrich (C implementation)
#
# 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, see .
*/
#include
#include "xts.h"
SEXP xts_period_apply(SEXP _data, SEXP _index, SEXP _function, SEXP _env)
{
int i;
R_xlen_t n = xlength(_index);
SEXP _result = PROTECT(allocVector(VECSXP, n));
SEXP _j = PROTECT(allocVector(INTSXP, ncols(_data)));
SEXP _drop = PROTECT(ScalarLogical(0));
for (i = 0; i < ncols(_data); i++)
INTEGER(_j)[i] = i + 1;
SEXP _idx0 = PROTECT(ScalarInteger(0));
SEXP _idx1 = PROTECT(ScalarInteger(0));
int *idx0 = INTEGER(_idx0);
int *idx1 = INTEGER(_idx1);
/* reprotect the subset object */
SEXP _xsubset;
PROTECT_INDEX px;
PROTECT_WITH_INDEX(_xsubset = R_NilValue, &px);
/* subset object name */
SEXP _subsym = install("_.*crazy*._.*name*._");
defineVar(_subsym, _xsubset, _env);
/* function call on subset */
SEXP _subcall = PROTECT(lang3(_function, _subsym, R_DotsSymbol));
int N = n - 1;
switch(TYPEOF(_index)) {
case REALSXP:
;
double *d_index = REAL(_index);
for (i = 0; i < N; i++) {
idx0[0] = d_index[i] + 1;
idx1[0] = d_index[i + 1];
REPROTECT(_xsubset = extract_col(_data, _j, _drop, _idx0, _idx1), px);
defineVar(_subsym, _xsubset, _env);
SET_VECTOR_ELT(_result, i, eval(_subcall, _env));
}
break;
case INTSXP:
;
int *i_index = INTEGER(_index);
for (i = 0; i < N; i++) {
idx0[0] = i_index[i] + 1;
idx1[0] = i_index[i + 1];
REPROTECT(_xsubset = extract_col(_data, _j, _drop, _idx0, _idx1), px);
defineVar(_subsym, _xsubset, _env);
SET_VECTOR_ELT(_result, i, eval(_subcall, _env));
}
break;
default:
error("unsupported index type");
}
UNPROTECT(7);
return _result;
}
xts/src/runSum.c 0000644 0001762 0000144 00000010716 14634167654 013341 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
/***********************************************************************/
/* xts, copyright (C) Jeffrey A. Ryan, 2008 */
//
// experimental code to provide rollapply functionality to standard
// functions. Essentially a .Call port of Josh's run*** functions
// from TTR. Though it should be obvious these are a lot more complex.
//
// runSum, runMin, runMax, runMedian, runMean, runSD
//
/***********************************************************************/
#include
#include
#include "xts.h"
/*
SEXP do_runsum (SEXP x, SEXP n, SEXP result)
{
}
SEXP do_run (SEXP x, SEXP n, (*void)FUN)
{
SEXP result;
int P=0;
int i, nrs;
int *int_n=NULL;
if(TYPEOF(n) != INTSXP) {
// assure that 'n' is an integer
PROTECT(n = coerceVector(n, INTSXP)); P++;
}
int_n = INTEGER(n); // get the first element (everything from R is a vector)
int *int_result=NULL, *int_x=NULL;
int int_sum = 0;
double *real_result=NULL, *real_x=NULL;
double real_sum = 0.0;
PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
int _firstNonNA = firstNonNA(x);
}
*/
SEXP runSum (SEXP x, SEXP n)
{
SEXP result;
int P=0;
int i, nrs;
int *int_n=NULL;
if(TYPEOF(n) != INTSXP) {
// assure that 'n' is an integer
PROTECT(n = coerceVector(n, INTSXP)); P++;
}
int_n = INTEGER(n); // get the first element (everything from R is a vector)
int *int_result=NULL, *int_x=NULL;
int int_sum = 0;
double *real_result=NULL, *real_x=NULL;
double real_sum = 0.0;
PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
int _firstNonNA = firstNonNA(x);
switch(TYPEOF(x)) {
/* still need to implement other types, and checking
// The branch by type allows for fewer type checks/branching
// within the algorithm, providing a _much_ faster mechanism
// to calculate the sum
//
// This part of the code should probably be a function
// call to a function pointer passed in to the top-level
// call... maybe???
// This should make it easier to extend the framework
// and _more_ importantly allow for user-level C
// functions (via R) to be used ad hoc
*/
case REALSXP:
real_result = REAL(result);
real_x = REAL(x);
int_result = int_x = NULL;
for(i = 0; i < (*int_n)+_firstNonNA; i++) {
real_result[i] = NA_REAL;
if(i >= _firstNonNA)
real_sum = real_sum + real_x[i];
}
real_result[ (*int_n) + _firstNonNA - 1 ] = real_sum;
nrs = nrows(x);
for(i = (*int_n)+_firstNonNA; i < nrs; i++) {
if(ISNA(real_x[i]) || ISNAN(real_x[i])) error("Series contains non-leading NAs");
real_result[i] = real_result[i-1] + real_x[i] - real_x[i-(*int_n)];
}
break;
case INTSXP:
int_result = INTEGER(result);
int_x = INTEGER(x);
real_result = real_x = NULL;
for(i = 0; i < (*int_n)+_firstNonNA; i++) { // (*int_n) is faster that INTEGER(n)[1], a constant would be equal
int_result[i] = NA_INTEGER;
if(i >= _firstNonNA)
int_sum = int_sum + int_x[i];
}
int_result[ (*int_n) + _firstNonNA -1 ] = int_sum;
nrs = nrows(x);
for(i = (*int_n)+_firstNonNA; i < nrs; i++) {
if(int_x[i]==NA_INTEGER) error("Series contains non-leading NAs");
int_result[i] = int_result[i-1] + int_x[i] - int_x[i-(*int_n)];
}
break;
/*
case STRSXP: fail!
case LGLSXP: convert to int??
case CPLXSXP:
*/
}
setAttrib(result, R_DimSymbol, getAttrib(x, R_DimSymbol));
setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
setAttrib(result, xts_IndexSymbol, getAttrib(x, xts_IndexSymbol));
UNPROTECT(P);
return result;
}
xts/src/dimnames.c 0000644 0001762 0000144 00000002434 14634167654 013643 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2010 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
SEXP dimnames_zoo (SEXP x) {
return(getAttrib(x, R_DimNamesSymbol));
}
SEXP xts_set_dimnames (SEXP x, SEXP value) {
if (R_NilValue == value) {
setAttrib(x, R_DimNamesSymbol, R_NilValue);
} else {
if (TYPEOF(value) != VECSXP || length(value) != 2) {
error("invalid 'dimnames' given for xts");
}
/* xts objects never have row names */
SET_VECTOR_ELT(value, 0, R_NilValue);
setAttrib(x, R_DimNamesSymbol, value);
}
return x;
}
xts/src/xts.c 0000644 0001762 0000144 00000003267 14636561324 012663 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include "xts.h"
//
//SEXP xts_new (SEXP _data, SEXP _index, SEXP _tclass, SEXP _tzone, SEXP _tformat)
//{
// PROTECT(result = allocVector(TYPEOF(x), 0)); p++;
// PROTECT(index = allocVector(TYPEOF(xindex), 0)); p++;
// setAttrib(index, xts_IndexTzoneSymbol, getAttrib(xindex, xts_IndexTzoneSymbol));
// setAttrib(index, xts_IndexTclassSymbol, getAttrib(xindex, xts_IndexTclassSymbol));
// setAttrib(index, xts_IndexTformatSymbol, getAttrib(xindex, xts_IndexTformatSymbol));
// setAttrib(result, xts_IndexSymbol, index);
//
// if (LOGICAL(retclass)[0]) {
// setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
// }
// setAttrib(result, xts_ClassSymbol, getAttrib(x, xts_ClassSymbol));
//
//}
//
//SEXP xts_set_typeof(SEXP _x, SEXPTYPE _typeof)
//{
// SEXP _result = PROTECT(allocVector(_typeof, xlength(_x)));
// xts_set_index(_result, xts_get_index(_x));
//
//}
xts/src/coredata.c 0000644 0001762 0000144 00000005350 14634166720 013621 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include "xts.h"
SEXP coredata (SEXP x, SEXP copyAttr)
{
/* copyAttr is a LGLSXP flag to indicate whether all
attributes are to be left intact. This provides
compatability with xts, by stripping all attributes
if desired, without the overhead or adding then
removing
*/
SEXP result;
int i, j, ncs, nrs;
int P=0;
PROTECT(result = allocVector(TYPEOF(x), length(x))); P++;
switch( TYPEOF(x)) {
case REALSXP:
memcpy(REAL(result), REAL(x), length(result) * sizeof(double));
break;
case INTSXP:
memcpy(INTEGER(result), INTEGER(x), length(result) * sizeof(int));
break;
case LGLSXP:
memcpy(LOGICAL(result), LOGICAL(x), length(result) * sizeof(int));
break;
case CPLXSXP:
memcpy(COMPLEX(result), COMPLEX(x), length(result) * sizeof(Rcomplex));
break;
case STRSXP:
ncs = ncols(x); nrs = nrows(x);
for(j=0; j< ncs; j++)
for(i=0; i< nrs; i++)
SET_STRING_ELT(result, i+j*nrs, STRING_ELT(x, i+j*nrs));
break;
case RAWSXP:
memcpy(RAW(result), RAW(x), length(result) * sizeof(unsigned char));
break;
default:
error("currently unsupported data type");
break;
}
if( !isNull(getAttrib(x, R_DimSymbol))) {
setAttrib(result, R_DimSymbol, getAttrib(x, R_DimSymbol));
if( !isNull(getAttrib(x, R_DimNamesSymbol)) ) {
setAttrib(result, R_DimNamesSymbol, getAttrib(x,R_DimNamesSymbol));
}
} else {
setAttrib(result, R_NamesSymbol, getAttrib(x, R_NamesSymbol));
}
if( asLogical(copyAttr)) {
copyMostAttrib(x,result);
setAttrib(result, R_ClassSymbol, getAttrib(x, install("oclass")));
}
setAttrib(result, xts_IndexSymbol, R_NilValue);
setAttrib(result, install("oclass"), R_NilValue);
setAttrib(result, install("frequency"), R_NilValue);
UNPROTECT(P);
return result;
}
SEXP coredata_xts(SEXP x) {
return zoo_coredata(x, ScalarLogical(0));
}
xts/src/tryXts.c 0000644 0001762 0000144 00000002633 14703317772 013357 0 ustar ligges users /*
# xts: eXtensible time-series
#
# Copyright (C) 2008 Jeffrey A. Ryan jeff.a.ryan @ gmail.com
#
# Contributions from Joshua M. Ulrich
#
# 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, see .
*/
#include
#include
#include "xts.h"
SEXP tryXts (SEXP x)
{
if( !Rf_asInteger(isXts(x)) ) {
int P = 0;
SEXP expr, result, env, str_xts;
PROTECT(str_xts = mkString("xts")); P++;
PROTECT(env = R_FindNamespace(str_xts)); P++;
PROTECT(expr = lang2(install("try.xts"), x)); P++;
PROTECT(result = eval(expr, env)); P++;
if( !Rf_asInteger(isXts(result)) ) {
UNPROTECT(P);
error("rbind.xts requires xtsible data");
}
UNPROTECT(P);
return result;
}
return x;
}
/*
SEXP try_xts (SEXP x)
{
SEXP y;
PROTECT(y = tryXts(x));
UNPROTECT(1);
return y;
}
*/
xts/NAMESPACE 0000644 0001762 0000144 00000013567 14654242576 012342 0 ustar ligges users # load symbol table
useDynLib(xts, .registration = TRUE, .fixes = "C_")
# non-base package imports
importFrom(stats,
lag,
time,
sd,
median,
na.omit,
na.action,
na.pass,
start,
end,
window,
setNames,
ts,
as.ts,
frequency,
tsp,
'tsp<-')
importFrom(methods,
hasArg)
importFrom(grDevices,
xy.coords)
importFrom(graphics,
abline,
clip,
legend,
lines,
par,
plot,
plot.new,
plot.window,
polygon,
segments,
text)
importFrom(utils,
str,
tail)
# xts exports
export(.parseISO8601)
export(firstof,
lastof)
export(is.timeBased,
timeBased,
timeBasedRange,
timeBasedSeq)
export(.indexsec,
.indexmin,
.indexhour,
.indexday,
.indexDate,
.indexmon,
.indexmday,
.indexwday,
.indexyday,
.indexisdst,
.indexyear,
.indexweek)
export(isOrdered)
export(.subset.xts)
export(.subset_xts)
# user visible core xts functions
export(xts, .xts)
export(as.xts)
export(is.xts)
export(endpoints)
export(align.time)
export(shift.time)
export(adj.time)
export(make.index.unique)
export(make.time.unique)
export(is.time.unique)
export(is.index.unique)
export(dimnames.xts)
export('dimnames<-.xts')
export(xcoredata)
export('xcoredata<-')
export(.index)
export('.index<-')
export(xtsible)
export(as.environment.xts)
export(use.xts, try.xts)
export(Reclass, use.reclass)
export(reclass)
export(CLASS)
export('CLASS<-')
export(indexFormat)
export('indexFormat<-')
export(tformat)
export('tformat<-')
export(indexClass)
export('indexClass<-')
export(tclass)
export('tclass<-')
export(indexTZ)
export('indexTZ<-')
export(tzone)
export('tzone<-')
export(convertIndex)
export(nseconds,
nminutes,
nhours,
ndays,
nweeks,
nmonths,
nquarters,
nyears)
export(to_period) # testing
export(to.period,
to.minutes,
to.minutes3,
to.minutes5,
to.minutes10,
to.minutes15,
to.minutes30,
to.hourly,
to.daily,
to.weekly,
to.monthly,
to.quarterly,
to.yearly)
export(xtsAttributes)
export('xtsAttributes<-')
export(periodicity)
export(period.apply,
period.max,
period.min,
period.sum,
period.prod)
export(first,
last)
export(apply.daily,
apply.weekly,
apply.monthly,
apply.quarterly,
apply.yearly)
export(rbind.xts,
cbind.xts,
c.xts)
export(split.xts)
export(axTicksByTime)
export(plot.xts)
export(addLegend)
export(addEventLines)
export(addSeries)
export(addPanel)
export(addPolygon)
S3method(plot,xts)
S3method(lines,xts)
S3method(points,xts)
S3method(print, replot_xts)
S3method(plot, replot_xts)
S3method(str, replot_xts)
export(lag.xts)
export(diff.xts)
export(merge.xts)
S3method(all.equal, xts)
S3method(split, xts)
S3method(lag,xts)
S3method(diff,xts)
S3method(first,default)
S3method(last,default)
S3method(first,xts)
S3method(last,xts)
S3method(print,periodicity)
S3method(align.time, xts)
S3method(align.time, POSIXct)
S3method(align.time, POSIXlt)
S3method(shift.time, xts)
S3method(make.index.unique, xts)
S3method(make.index.unique, numeric)
S3method(make.index.unique, POSIXct)
S3method(is.time.unique, xts)
S3method(is.time.unique, zoo)
# xts methods
importFrom(zoo,coredata)
importFrom(zoo, index)
importFrom(zoo,'index<-')
importFrom(zoo,'time<-')
importFrom(zoo, na.locf)
importFrom(zoo, as.zoo)
importFrom(zoo, rollapply)
importFrom(zoo, na.approx)
importFrom(zoo, na.fill)
importFrom(zoo, na.fill0)
importFrom(zoo, as.yearmon)
importFrom(zoo, as.yearqtr)
importFrom(zoo, is.regular)
importFrom(zoo, zoo)
importFrom(zoo, MATCH)
S3method(coredata,xts)
S3method(xcoredata,default)
S3method('xcoredata<-',default)
S3method(as.xts,xts)
S3method('[',xts)
S3method('[<-',xts)
S3method(str,xts)
S3method(start, xts)
S3method(end, xts)
S3method(na.omit,xts)
S3method(na.locf,xts)
S3method(na.fill,xts)
S3method(print,xts)
S3method(print,CLASS)
S3method('CLASS<-',xts)
S3method(window,xts)
S3method(dimnames, xts)
S3method('dimnames<-', xts)
S3method(tclass, default)
S3method('tclass<-', default)
S3method(tclass,xts)
S3method('tclass<-',xts)
S3method(tformat,default)
S3method(tformat,xts)
S3method('tformat<-',xts)
S3method(tzone, default)
S3method('tzone<-', default)
S3method(tzone,xts)
S3method('tzone<-',xts)
S3method('index',xts)
S3method('index<-',xts)
S3method('time<-',xts)
S3method('xtsAttributes<-',xts)
S3method(merge,xts)
S3method(rbind,xts)
S3method(cbind,xts)
S3method(c,xts)
S3method(Ops,xts)
S3method(as.numeric,xts)
S3method(as.xts,numeric)
S3method(as.double,xts)
S3method(as.xts,double)
S3method(as.integer,xts)
S3method(as.xts,integer)
S3method(as.complex,xts)
S3method(as.xts,complex)
S3method(as.logical,xts)
S3method(as.xts,logical)
S3method(cumsum, xts)
S3method(cumprod, xts)
S3method(cummin, xts)
S3method(cummax, xts)
S3method(rollapply, xts)
# list specific methods
S3method(as.list,xts)
# ts specific methods
S3method(as.xts, ts)
S3method(as.ts, xts)
# zoo specific methods
S3method(as.xts,zoo)
if (getRversion() >= "3.6.0" && utils::packageVersion("zoo") < "1.8.5") {
# xts:::as.zoo.xts was copied to zoo:::as.zoo.xts in zoo 1.8-5
S3method(zoo::as.zoo, xts)
}
# data.frame specific methods
S3method(as.xts,data.frame)
S3method(as.data.frame, xts)
# matrix specific methods
S3method(as.xts,matrix)
S3method(as.matrix,xts)
# environment specific methods
S3method(as.environment,xts)
# timeSeries (package:timeSeries) specific methods
if (getRversion() >= "3.6.0") {
S3method(timeSeries::as.timeSeries, xts)
}
S3method(as.xts,timeSeries)
# irts (package:tseries) specific methods
S3method(as.xts,irts)
# Date specific methods
S3method(as.xts,Date)
# POSIX specific methods
S3method(as.xts,POSIXt)
# yearmon/yearqtr specific methods
S3method(as.xts,yearmon)
S3method(as.xts,yearqtr)
# timeDate specific methods
S3method(as.xts,timeDate)
## currently unexported functions that _may_ be exported at some point
xts/NEWS.md 0000644 0001762 0000144 00000134771 14702260001 012173 0 ustar ligges users # xts 0.14.x (202x-xx-xx)
* `plot.xts()` now renders all panels when 'x' has more than 8 columns and
`multi.panel = TRUE`. Columns 9 and later didn't render because the default
of `plot.xts()` is 'col = 1:8'. Thanks to Ethan Smith for the report and
patch.
([#423](https://github.com/joshuaulrich/xts/issues/423))
([#424](https://github.com/joshuaulrich/xts/issues/424))
* `plot.xts()` no longer errors when 'ylim' is constant and negative. Thanks
to Ethan Smith for the report.
([#422](https://github.com/joshuaulrich/xts/issues/422))
* Do not use `SET_TYPEOF()` in C because it is not part of the public R API.
* `merge.xts()` no longer converts 'x' or 'y' from double to integer in the C
code when they are not used in the result. This avoids an unnecessary and
confusing warning. Thanks to Jeff Ryan for the report.
# xts 0.14.0 (2024-06-05)
* `addEventLines()` and `addLegend()` now draw on multiple panels when `on` is
a vector. Thanks to Ethan Smith for the report.
([#420](https://github.com/joshuaulrich/xts/issues/420))
* Replace `SET_TYPEOF()` in merge.c because it will error when it tries to
convert a REAL to an INTEGER. Thanks to Kurt Hornik for the report!
([#419](https://github.com/joshuaulrich/xts/issues/419))
* Fix crash when 'j' is not an integer and in [0, 1) (e.g. `j = 0.1`). Also
throw a warning when 'j' is not an integer.
([#413](https://github.com/joshuaulrich/xts/issues/413))
([#415](https://github.com/joshuaulrich/xts/issues/415))
* Fix plot header when `layout()` is used to draw multiple plots on a single
device. Thanks to Dirk Eddelbuettel for the report and testing!
([#412](https://github.com/joshuaulrich/xts/issues/412))
* Fix plot legend location when the y-axis is log scale.
([#407](https://github.com/joshuaulrich/xts/issues/407))
# xts 0.13.2 (2024-01-21)
* Print a message when `period.apply()` is called with `FUN = mean` because it
calculates the mean for each column, not all the data in the subset like it
does for all other functions. The message says to use `FUN = colMeans` for
current behavior and `FUN = function(x) mean(x)` to calculate the mean for
all the data. This information is also included in the help files. The option
`xts.message.period.apply.mean = FALSE` suppresses the message.
([#124](https://github.com/joshuaulrich/xts/issues/124))
* Fix error when `print.xts()` is called 'quote' or 'right' arguments.
([#401](https://github.com/joshuaulrich/xts/issues/401))
* Fix `addPolygon()` so it renders when `observation.based = TRUE`.
([#403](https://github.com/joshuaulrich/xts/issues/403))
* Print trailing zeros for index value with fractional seconds, so every index
value has the same number of characters.
([#404](https://github.com/joshuaulrich/xts/issues/404))
* Add ability to log scale the y-axis in `plot.xts()`.
([#103](https://github.com/joshuaulrich/xts/issues/103))
* Actually change the underlying index values when 'tclass' is changed from a
class with a timezone (e.g. POSIXct) to one without a timezone (e.g. Date).
Add a warning when this happens, with a global option to always suppress the
warning.
([#311](https://github.com/joshuaulrich/xts/issues/311)).
* Significantly refactor the internals of `plot.xts()`.
([#408](https://github.com/joshuaulrich/xts/issues/408))
# xts 0.13.1 (2023-04-16)
* Ignore attribute order in `all.equal()`. Attribute order shouldn't matter.
That can be checked with `identical()`.
* Only call `tzone()` and `tclass()` once in `check.TZ()`. Calling these
functions multiple times throws multiple warnings for xts objects created
before the tclass and tzone were attached to the index instead of the xts
object.
([#306](https://github.com/joshuaulrich/xts/issues/306))
* Add instructions to update old objects. Old xts objects do not have tclass
and tzone attributes on the index. Add a function to update the object
attributes and add a note to the warning to show how to use it.
([#306](https://github.com/joshuaulrich/xts/issues/306))
* Return 'POSIXct' if object has no 'tclass'. An empty string is not a valid
'tclass', so it can cause an error.
* Add notes on `plot.xts()` nomenclature and structure. Also add ASCII art to
illustrate definitions and layout.
([#103](https://github.com/joshuaulrich/xts/issues/103))
* Remove 'tis' support. The implementation was not even a bare minimum, and
it's not clear it even worked correctly.
([#398](https://github.com/joshuaulrich/xts/issues/398))
* Register missing S3 methods and update signatures. With R-devel (83995-ish),
`R CMD check` notes these S3 methods are not registered. It also notes that
the signatures for `as.POSIXct.tis()` and `str.replot_xts()` do not match
the respective generics.
It also thinks `time.frequency()` is a S3 method because `time()` is a
generic. The function isn't exported, so renaming won't break any external
code. Thanks to Kurt Hornik for the report.
([#398](https://github.com/joshuaulrich/xts/issues/398))
* Format each column individually before printing. The top/bottom rows could
have a different number of decimal places and there are often multiple
variying spaces between columns. For example:
close volume ma bsi
2022-01-03 09:31:00 476.470 803961.000 NA 54191.000
2022-01-03 09:32:00 476.700 179476.000 NA 53444.791
2022-01-03 09:33:00 476.540 197919.000 NA -16334.994
...
2023-03-16 14:52:00 394.6000 46728.0000 392.8636 28319.4691
2023-03-16 14:53:00 394.6500 64648.0000 392.8755 15137.6857
2023-03-16 14:54:00 394.6500 69900.0000 392.8873 -1167.9368
There are 4 spaces between the index and the 'close' column, 2 between
'close' and 'volume', 4 between 'volume' and 'ma', and 2 between 'ma' and
'bsi'. There should be a consistent number of spaces between the columns. Most
other classes of objects print with 1 space between the columns.
The top rows have 3 decimals and the bottom rows have 4. These should also be
the same.
([#321](https://github.com/joshuaulrich/xts/issues/321))
* Only convert printed index values to character. Converting the entire index
to character is time-consuming for xts objects with many observations. It can
take more than a second to print an xts object with 1mm observations.
* Make column names based on number of columns. The original code was a lot
more complicated because it tried to account for truncating the number of
printed columns. That functionality was removed because of how complicated
it was. So now we can simply create printed column names from the number of
columns.
([#395](https://github.com/joshuaulrich/xts/issues/395))
* Fix `xts()` for zero-row data.frame. The `xts()` constructor would create an
object with a list for coredata when 'x' is a data.frame with no rows. It
needs to convert 'x' to a matrix and throw an error if 'x' is a list.
([#394](https://github.com/joshuaulrich/xts/issues/394))
* Reduce instances when `dplyr::lag()` warning is shown. The warning was shown
whenever it detected dplyr is installed, even if the user wasn't actively
using dplyr. That caused an excessive amount of noise when other packages
attached xts (e.g. quantmod). Thanks to Duncan Murdoch for the report and
suggested fix!
([#393](https://github.com/joshuaulrich/xts/issues/393))
* Keep colname when only one non-time-based column. The subset `x[, -which.col]`
would return a vector when the data frame has a time-based column and only
one additional column. Do not drop dimensions, so 'x' will still be a
data.frame in this case.
([#391](https://github.com/joshuaulrich/xts/issues/391))
* Treat NA the same as NULL for start or end values. NULL represents an
undefined index value. NA represents an unknown or missing index value. xts
does not allow NA as index values. Subsetting an xts or zoo object by NA
returns a zero-length object. So a NA (unknown) index value is essentially
the same as an undefined index value.
([#345](https://github.com/joshuaulrich/xts/issues/345),
[#383](https://github.com/joshuaulrich/xts/pull/383))
* Warn and remove NA when `periodicity()` called on date-time with NA.
Otherwise the uninformative error below will be thrown.
([#289](https://github.com/joshuaulrich/xts/issues/289))
Error in try.xts(x, error = "'x' needs to be timeBased or xtsible") :
'x' needs to be timeBased or xtsible
* Account for TZ when making names for `split.xts()`. `as.yearmon.POSIXct()`
always sets `tz = "GMT"` when calling `as.POSIXlt()`, regardless of the xts'
index tzone. That can cause the `as.yearmon()` results to be different days
for GMT and the index's timezone.
Use `format.POSIXct()` for "months" because it checks for a 'tzone' attribute
before converting to POSIXlt and calling `format.POSIXlt()`. The conversion
to POSIXlt is important because it checks and uses the 'tzone' attribute
before considering the 'tz' argument. So it effectively ignores the
`tz = "GMT"` setting in `as.yearmon()`. This is also the reason for calling
`as.POSIXlt()` before calling `as.yearqtr()`.
([#392](https://github.com/joshuaulrich/xts/issues/392))
# xts 0.13.0 (2023-02-21)
## New Features
* Added a xts method for `na.fill()` to significantly increase performance when
'fill' is a scalar.
([#259](https://github.com/joshuaulrich/xts/issues/259))
* `as.xts()` will look for a time-based column in a data.frame if it cannot
create an index from the row names.
([#381](https://github.com/joshuaulrich/xts/issues/381))
* Change `print()` xts method to only show the first and last 'show.rows' rows
if number of rows is > 'max.rows'.
([#321](https://github.com/joshuaulrich/xts/issues/321))
* Made `str()` output more descriptive for xts objects. It now differentiates
between xts objects that are empty, zero-width, or zero-length, and defines
each type of object. It also adds column names to the output.
([#168](https://github.com/joshuaulrich/xts/issues/168),
[#378](https://github.com/joshuaulrich/xts/issues/378))
* Add startup warning that `dplyr::lag()` breaks method dispatch, which means
calls to `lag(my_xts)` won't work any more.
* Added open-ended time of day subsetting ranges. This allows users to subset
by time of day from the start/end of the day without providing the start/end
times (00:00:00.000/23:59:59.999).
For example:
x["/T1800"] # between the start of the day and 5pm
x["T0500/"] # between 5am and the end of the day
Thanks to Chris Katsulis for the suggestion!
([#243](https://github.com/joshuaulrich/xts/issues/243))
* Updated `to.period()` to accept custom 'endpoints' via the 'period' argument.
Now you can aggregate on something other than the times that 'endpoints()'
supports. Thanks to Ethan B. Smith for the suggestion!
([#302](https://github.com/joshuaulrich/xts/issues/302))
## Fixes
* Fixed typo and expand `period.apply()` documentation. ([#205](https://github.com/joshuaulrich/xts/issues/205))
The original description has:
* "the data from INDEX[k] to INDEX[k+1]"
But that's not consistent with the code. It should be:
* "the data from INDEX[k]+1 to INDEX[k+1]"
* Calls to `merge.xts()` on zero-width objects now match `merge.zoo()`.
Previously, `merge.xts()` would return empty xts objects if called on two or
more zero-width xts objects. `merge.zoo()` would return a zero-width object
with the correct index.
([#227](https://github.com/joshuaulrich/xts/issues/227),
[#379](https://github.com/joshuaulrich/xts/issues/379))
* Fixed `Ops.xts()` so it always returned an object with the same class as the
first (left-hand side) argument. It previously returned an xts object even
if the first argument was a subclass of xts.
([#49](https://github.com/joshuaulrich/xts/issues/49))
## Other
* Migrated unit tests from RUnit to tinytest. Thanks Mark van der Loo!
* Updated the `endpoints()` documentation to make it clearer that the result
is based on the UNIX epoch (midnight 1970, UTC). Thanks to GitHub user
Eluvias for the suggestion!
([#299](https://github.com/joshuaulrich/xts/issues/299))
* Fixed `reclass()` to ensure it always adds index attributes from the
'match.to' argument. It was not copying `tclass`, `tzone`, or `tformat` from
'match.to' to the result object.
([#43](https://github.com/joshuaulrich/xts/issues/43))
* Removed an unnecessary check in `na.locf()` (which is not user-facing).
Thanks to GitHub user @cgiachalis for the suggestion!
([#307](https://github.com/joshuaulrich/xts/issues/307))
* Updated C entry points so they're not able to accidentally be found via
dynamic lookup (i.e. `.Call("foo", ...)`). This makes each call to the C
code a few microseconds faster, which is nice.
([#260](https://github.com/joshuaulrich/xts/issues/260))
* Made `merge.xts()` results consistent with `merge.zoo()` for zero-length xts
objects with columns. The result of `merge.xts()` did not include the
columns of any objects that had one or more columns, but zero rows. A join
should include all the columns of the joined objects, regardless of the
number of rows in the object. This is consistent with `merge.zoo()`. Thanks
to Ethan B. Smith for the report and testing!
([#222](https://github.com/joshuaulrich/xts/issues/222))
# xts 0.12.2 (2022-10-16)
* `Ops.xts()` no longer changes column names (via `make.names()`) when the two
objects do not have identical indexes. This makes it consistent with
`Ops.zoo()`.
([#114](https://github.com/joshuaulrich/xts/issues/114))
* Subsetting a zero-length xts object now returns an object with the same
storage type as the input. It previously always returned a 'logical' xts
object.
([#376](https://github.com/joshuaulrich/xts/issues/376))
* `tclass()` and `tzone()` now return the correct values for zero-length xts
objects, instead of the defaults in the `.xts()` constructor. Thanks to Andre
Mikulec for the report and suggested patch!
([#255](https://github.com/joshuaulrich/xts/issues/255))
* `first()` and `last()` now return a zero-length xts object when `n = 0`. They
previously returned the entire object. This is consistent with the default
`head()` and `tail()` functions, and data.table's `first()` and `last()`
functions. Thanks to Ethan B. Smith for the report and patch!
([#350](https://github.com/joshuaulrich/xts/issues/350))
* `plot.xts()` now has a `yaxis.ticks` argument to control the number of y-axis
grid lines, instead of always drawing 5 grid lines. Thanks to Fredrik
Wartenberg for the feature request and patch!
([#374](https://github.com/joshuaulrich/xts/issues/374))
* Subsetting a zero-width xts now returns an object with the same class, tclass,
tzone, and xtsAttributes as the input. Thanks to @shikokuchuo for the report!
([#359](https://github.com/joshuaulrich/xts/issues/359))
* `endpoints()` now always returns last observation. Thanks to GitHub user
Eluvias for the report.
([#300](https://github.com/joshuaulrich/xts/issues/300))
* Ensure `endpoints()` errors for every 'on' value when `k < 1`. It was not
throwing an error for `k < 1` for `on` of "years", "quarters", or "months".
Thanks to Eluvias for the report.
([#301](https://github.com/joshuaulrich/xts/issues/301))
* Fix `window()` for yearmon and yearqtr indexes. In xts < 0.11-0, `window.zoo()`
was dispatched when `window()` was called on a xts object because there was no
`window.xts()` method. `window.zoo()` supports additional types of values for the
`start` argument, and possibly other features. So this fixes a breaking change
in xts >= 0.11-0. Thanks to @annaymj for the report.
([#312](https://github.com/joshuaulrich/xts/issues/312))
* Clarify whether `axTicksByTime()` returns index timestamps or locations (e.g.
1, 2, 3). Thanks to @ggrothendieck for the suggestion and feedback.
([#354](https://github.com/joshuaulrich/xts/issues/354))
* Fix merge on complex types when 'fill' is needed. `merge()` would throw an
error because it treated 'fill' as double instead of complex. Thanks to
@ggrothendieck for the report.
([#346](https://github.com/joshuaulrich/xts/issues/346))
* Add a message to tell the user how to disable 'xts_check_TZ' warning. Thanks
to Jerzy Pawlowski for the nudge.
([#113](https://github.com/joshuaulrich/xts/issues/113))
* Update `rbind()` to handle xts objects without dim attribute. `rbind()` threw
an obscure error if one of the xts objects does not have a dim attribute. We
can handle this case even though all xts objects should always have a dim
attribute.
([#361](https://github.com/joshuaulrich/xts/issues/361))
* `split.xts()` now always return a named list, which makes it consistent with
`split.zoo()`. Thanks to Gabor Grothendieck for the report.
([#357](https://github.com/joshuaulrich/xts/issues/357))
* xts objects with a zero-length POSIXct index now return a zero-length POSIXct
vector instead of a zero-length integer vector. Thanks to Jasper Schelfhout
for the report and PR!
([#363](https://github.com/joshuaulrich/xts/issues/363),
[#364](https://github.com/joshuaulrich/xts/pull/364))
* Add suffixes to output of `merge.xts()`. The suffixes are consistent with
`merge.default()` and not `merge.zoo()`, because `merge.zoo()` automatically
uses "." as a separator between column names, but the default method doesn't.
Thanks to Pierre Lamarche for the nudge. Better late than never?
([#38](https://github.com/joshuaulrich/xts/issues/38),
[#371](https://github.com/joshuaulrich/xts/issues/371))
## Changes to plotting functionality
* You can now omit the data time range from the upper-right portion of a plot
by setting `main.timespan = FALSE`.
([#247](https://github.com/joshuaulrich/xts/issues/247))
* Fix `addEventLines()` when plotted objects have a 'yearmon' index. The ISO-8601
range string was not created correctly. Thanks to @paessens for the report.
([#353](https://github.com/joshuaulrich/xts/issues/353))
* Make 'ylim' robust against numerical precision issues by replacing `==` with
`all.equal()`. Thanks to @bollard for the report, PR, and a ton of help
debugging intermediate solutions!
([#368](https://github.com/joshuaulrich/xts/issues/368))
* Series added to a panel now extend the panel's y-axis. Previously the y-axis
limits were based on the first series' values and not updated when new series
were added. So values of the new series did not appear on the plot if they
were outside of the original series' min/max. Thanks to Vitalie Spinu for the
report and help debugging and testing!
([#360](https://github.com/joshuaulrich/xts/issues/360))
* All series added to any panel of a plot now update the x-axis of all panels.
So the entire plot's x-axis will include every series' time index values
within the original plot's time range. This behavior is consistent with
`chart_Series()`. Thanks to Vitalie Spinu for the report and help debugging
and testing!
([#360](https://github.com/joshuaulrich/xts/issues/360),
[#216](https://github.com/joshuaulrich/xts/issues/216))
* All y-values are now plotted for series that have duplicate index values, but
different data values. Thanks to Vitalie Spinu for the report and help
debugging and testing!
([#360](https://github.com/joshuaulrich/xts/issues/360))
* Adding a series can now extend the x-axis before/after the plot's existing
time index range, so all of the new series' time index values are included in
the plot. This is FALSE by default to maintain backward compatibility. Thanks
to Vitalie Spinu for the report and help debugging and testing!
([#360](https://github.com/joshuaulrich/xts/issues/360))
# xts 0.12.1 (2020-09-09)
* Various function could change the tclass of xts objects. This would happen
in calls to reclass(), period.apply(), and for logical operations on
POSIXct indexes. Thanks to Tom Andrews for the report and testing, and to
Panagiotis Cheilaris for contributing test cases.
([#322](https://github.com/joshuaulrich/xts/issues/322),
[#323](https://github.com/joshuaulrich/xts/pull/323))
* plot.xts() now supports y-axis labels via 'ylab'. Thanks to Jasen Mackie
for the suggestion and PR.
([#333](https://github.com/joshuaulrich/xts/issues/333),
[#334](https://github.com/joshuaulrich/xts/pull/334))
* The API header has been updated to fix the signatures of do_merge_xts() and
is_xts, which did not return a SEXP as required of functions callable by
.Call(). Thanks to Tomas Kalibera for the report ([#317](https://github.com/joshuaulrich/xts/issues/317)),
and Dirk Eddelbuettel for the PR ([#337](https://github.com/joshuaulrich/xts/pull/337)).
This is a breaking change, but is required to avoid the potential for a segfault.
* Michael Chirico added an internal isUTC() function to recognize many UTC-
equivalent time zones.
([#319](https://github.com/joshuaulrich/xts/issues/319))
* first() now operates correctly on non-xts objects when 'n = -1'. Previously
it would always return the last two values. Thanks to GitHub user vxg20
for the report.
([#325](https://github.com/joshuaulrich/xts/issues/325))
* The .xts() constructor would create an xts object with row names if 'x' had
row names. This shouldn't happen, because xts objects do not have or
support row names.
([#298](https://github.com/joshuaulrich/xts/issues/298))
* Claymore Marshall added many examples of time-of-day subsetting to
?subset.xts. He also fixed a bug in time-of-day subsetting where subsetting
by hour only returned wrong results.
([#304](https://github.com/joshuaulrich/xts/issues/304),
[#326](https://github.com/joshuaulrich/xts/issues/326),
[#328](https://github.com/joshuaulrich/xts/pull/328))
# xts 0.12-0 (2020-01-19)
* All the index-attributes have been removed from the xts object and are now
only attached to the index itself. We took great care to maintain backward
compatibility, and throw warnings when deprecated functions are called and
when index-attributes are found on the xts object. But there still may be
some breaking changes lurking in edge cases.
([#245](https://github.com/joshuaulrich/xts/issues/245))
* @SamoPP found one edge case where an error was thrown when index()
was called on an xts object with an index that had no tclass attribute.
([#297](https://github.com/joshuaulrich/xts/issues/297))
* ...which led Joshua to find that the index setting functions did not
always copy index attributes.
([#305](https://github.com/joshuaulrich/xts/issues/305))
* Several binary operations (e.g. +, -, !=, <, etc.) on variations of
uncommon xts objects with other xts, matrix, or vector objects, could
result in malformed xts objects. Some examples of the types of uncommon
xts objects: no dim attribute, zero-width, zero-length.
([#295](https://github.com/joshuaulrich/xts/issues/295))
* Calling as.matrix() on an xts object without a dim attribute no longer
throws an error. ([#294](https://github.com/joshuaulrich/xts/issues/294))
* merge.xts() now honors check.names = FALSE.
([#293](https://github.com/joshuaulrich/xts/issues/293))
* The possible values for major.ticks, minor.ticks, and grid.ticks.on in the
Details section of ?plot.xts have been corrected. Thanks to Harvey Smith
(@harvey131) for the report and patch.
([#291](https://github.com/joshuaulrich/xts/issues/291))
* as.zoo.xts() is now only registered for zoo versions prior to 1.8-5. Methods
to convert an object to another class should reside in the package that
implements the target class. Thanks to Kurt Hornik for the report.
([#287](https://github.com/joshuaulrich/xts/issues/287))
* .parseISO8601() no longer has a potential length-1 logical error. Thanks to
Kurt Hornik for the report.
([#280](https://github.com/joshuaulrich/xts/issues/280))
* endpoints() now honors k > 0 when on = "quarters". Thanks to @alkment for
the report.
([#279](https://github.com/joshuaulrich/xts/issues/279))
* Performance for the period.XYZ() functions (sum, prod, min, max) is much
faster. Thanks to Chris Katsulis for the report, and Harvey Smith
(@harvey131) for several examples.
([#278](https://github.com/joshuaulrich/xts/issues/278))
* merge.xts() now creates shorter column names when passed unnamed objects.
This is now consistent with zoo.
([#248](https://github.com/joshuaulrich/xts/issues/248))
* Time-of-day performance is ~200x faster, thanks to StackOverflow
user3226167 ([#193](https://github.com/joshuaulrich/xts/issues/193)).
# xts 0.11-2 (2018-11-05)
* The to.period() family of functions now use the index timezone when
converting intraday index values to daily values (or lower frequency).
Thanks to Garrett See and Gabor Grothendieck for the reports.
([#53](https://github.com/joshuaulrich/xts/issues/53),
[#277](https://github.com/joshuaulrich/xts/issues/277))
* Make column names for merge() results with unnamed objects shorter and more
like zoo. This also makes na.fill() much faster. NOTE: This may break
existing code for integer unnamed objects.
([#248](https://github.com/joshuaulrich/xts/issues/248)
[#259](https://github.com/joshuaulrich/xts/issues/259))
* Fix subset when 'index(x)' and 'i' contain duplicates. Thanks to Stack
Overflow user [scs](https://stackoverflow.com/users/4024268/scs) for the
report, and Philippe Verspeelt for debugging.
([#275](https://github.com/joshuaulrich/xts/issues/275))
* Fix if-statement in xts constructor that may use a logical with length > 1.
Thanks to @HughParsonage for the report and PR.
([#270](https://github.com/joshuaulrich/xts/issues/270),
[#272](https://github.com/joshuaulrich/xts/pull/272))
* Register shift.time.xts() method. Thanks to Philippe Verspeelt for the
report and PR.
([#268](https://github.com/joshuaulrich/xts/issues/268),
[#273](https://github.com/joshuaulrich/xts/pull/273))
* Conditionally register S3 methods for as.timeSeries.xts() and as.fts.xts()
when their respective packages are available (as requested by CRAN). Note
that this means these two functions are no longer exported. This may break
some existing code that calls the methods directly, though 'best practice'
is to let method dispatch determine which method to invoke.
# xts 0.11-1 (2018-09-12)
* Fix regression in .xts() that caused 'tclass' argument/attribute to be
incorrectly set to POSIXct regardless of user-provided value. Thanks to
@Eluvias for the report and Tom Andrews for the PR.
([#249](https://github.com/joshuaulrich/xts/issues/249),
[#250](https://github.com/joshuaulrich/xts/pull/250))
* Fix performance regression when xts object is subset by a date-time vector.
Thanks to Tom Andrews for the report, and the PR to fix the bug in my patch.
([#251](https://github.com/joshuaulrich/xts/issues/251),
[#263](https://github.com/joshuaulrich/xts/issues/263),
[#264](https://github.com/joshuaulrich/xts/pull/264))
* Restore behavior from 0.10-2 so subsetting an empty xts object by a date-
time vector returns an empty xts object instead of throwing an error.
Thanks to @alkment for the report.
([#252](https://github.com/joshuaulrich/xts/issues/252))
* Add ability for merge.xts() to handle multiple character or complex xts
objects. Thanks to Ken Williams for the report.
([#44](https://github.com/joshuaulrich/xts/issues/44))
* Add ability to use "quarters" to specify tick/grid mark locations on plots.
This ran but produced an incorrect result in 0.10-2 and threw an error in
0.11-0. Thanks to Marc Weibel for the report.
([#256](https://github.com/joshuaulrich/xts/issues/256))
* Fix illegal read reported by valgrind. Thanks to Tom Andrews for the report
and PR.
([#236](https://github.com/joshuaulrich/xts/issues/236),
[#261](https://github.com/joshuaulrich/xts/pull/261))
# xts 0.11-0 (2018-07-16)
* Fix make.index.unique() to always return a unique and sorted index. Thanks
to Chris Katsulis for the report and example.
([#241](https://github.com/joshuaulrich/xts/issues/241))
* Add window.xts() method and completely refactor the internal binary search
function it depends on. Thanks to Corwin Joy for the PR, tests, review, and
patience.
([#100](https://github.com/joshuaulrich/xts/pull/100),
[#240](https://github.com/joshuaulrich/xts/pull/240))
* Better axis tick mark locations for plots. Thanks to Dirk Eddelbuettel for
the report. Also incorporate axTicksByTime2() into axTicksByTime() to
reduce code duplication from the migration of quantmod::chart_Series() to
xts::plot.xts().
([#246](https://github.com/joshuaulrich/xts/issues/246),
[#74](https://github.com/joshuaulrich/xts/issues/74))
* Add details to plot.xts() parameters that are periodicity, now that RStudio
has argument completion. Thanks to Evelyn Mitchell for the PR.
([#154](https://github.com/joshuaulrich/xts/issues/154))
* periodicity() now warns instead of errors if the xts object contains less
than 2 observations.
([#230](https://github.com/joshuaulrich/xts/issues/230))
* first() and last() now keep dims when they would otherwise be dropped by a
regular row subset. This is consistent with head() and tail(). Thanks to
Davis Vaughan for the report.
([#226](https://github.com/joshuaulrich/xts/issues/226))
* Fix subset when ISO8601 string is outside the valid range, so it returns no
data instead of all rows.
([#96](https://github.com/joshuaulrich/xts/issues/96))
* Avoid partial name matches from parse.side() (inside .parseISO8601())
results that are passed to firstof() and lastof(). Thanks to @gp2x for the
report and the patch.
([#231](https://github.com/joshuaulrich/xts/issues/231))
* na.locf.xts() now loops over columns of multivariate objects in C code,
instead of in R. This should improve speed and memory performance. Thanks to
Chris Katsulis and Tom Andrews for their reports and patches.
([#232](https://github.com/joshuaulrich/xts/issues/232),
[#233](https://github.com/joshuaulrich/xts/issues/233),
[#234](https://github.com/joshuaulrich/xts/issues/234),
[#235](https://github.com/joshuaulrich/xts/pull/235),
[#237](https://github.com/joshuaulrich/xts/pull/237))
* Change plot.xts() default 'pch = 0' (rectangles) to 'pch = 1' (circles) so
it looks more like base and zoo plots.
([#203](https://github.com/joshuaulrich/xts/issues/203))
# xts 0.10-2 (2018-03-15)
* na.locf.xts() and na.omit.xts() now support character xts objects. Thanks to
Ken Williams and Samo Pahor for the reports.
([#42](https://github.com/joshuaulrich/xts/issues/42))
* na.locf.xts() now honors 'x' and 'xout' arguments by dispatching to the next
method. Thanks to Morten Grum for the report.
([#215](https://github.com/joshuaulrich/xts/issues/215))
* coredata.xts() now functions the same as coredata.zoo() on zero-length
objects, and only removes xts-related attributes. Thanks to Vincent Guyader
for the report.
([#223](https://github.com/joshuaulrich/xts/issues/223))
* plot.xts() no longer ignores 'col.up' and 'col.dn' when 'type="h"'
([#224](https://github.com/joshuaulrich/xts/issues/224)).
Thanks to Charlie Friedemann for the report. This was inadvertently broken
as part of the fix for [#210](https://github.com/joshuaulrich/xts/issues/210).
# xts 0.10-1 (2017-12-20)
* 'ylim' values passed to 'addSeries' and 'addPolygon' via '...' are now
captured and honored ([#220](https://github.com/joshuaulrich/xts/issues/220)).
* 'addPolygon' now checks for ylim of zeros, as 'addSeries' does
([#164](https://github.com/joshuaulrich/xts/issues/164)).
* The 'base::as.Date.numeric' method is no longer over-ridden. The exported,
but not registered, method in zoo should prevent any change in behavior.
* Series added to an existing plot are now given the same index values as
the main panel ([#216](https://github.com/joshuaulrich/xts/issues/216)).
There still may be some weird behavior if the new data does not have
observations within the timespan of the main panel data, but no observations
on the same timestamps.
* Existing 'par' values are now captured and reset before returning from
plotting functions
([#217](https://github.com/joshuaulrich/xts/issues/217)).
* User-defined 'col' values are now honored when 'type="h"'
([#210](https://github.com/joshuaulrich/xts/issues/210)).
* Values passed to plotting functions are now copied from the calling
environment. This enables plotting arguments to be objects passed
through multiple layers of function calls.
* indexFormat is now generic, consistent with indexFormat<-
([#188](https://github.com/joshuaulrich/xts/issues/188)).
* Calling as.matrix() on a zero-width xts object now behaves consistently
with zoo, and no longer throws an error
([#130](https://github.com/joshuaulrich/xts/issues/130)).
* Fix weird result in merge.xts() when 'fill' argument is NULL or a zero-
length vector
([#261](https://github.com/joshuaulrich/xts/issues/261)).
* Fixed bug in endpoints() due to sub-second representation error via using
integer division (%/%) with non- integer arguments
([#202](https://github.com/joshuaulrich/xts/issues/202)).
* endpoints() gained sub-second accuracy on Windows
([#202](https://github.com/joshuaulrich/xts/issues/202)).
* plot.xts() no longer errors when called on an object containing a constant
value. It chooses ylim values +/-20% from the series value
([#156](https://github.com/joshuaulrich/xts/issues/156)).
* plot.xts() now places y-axis labels in the same location on the plot,
regardless of data periodicity
([#85](https://github.com/joshuaulrich/xts/issues/85)).
* rbind.xts() now throws an error if passed an xts object with different
number of observations in the index and data (e.g., zero-width)
([#98](https://github.com/joshuaulrich/xts/issues/98)).
# xts 0.10-0 (2017-07-07)
Major changes include:
* A new plot.xts() that is incompatible with earlier versions of plot.xts().
* Moved development from R-Forge to GitHub.
* New xts FAQ.
Other, less disruptive changes include:
* merge.xts() now throws an error if the index contains non-finite values
([#174](https://github.com/joshuaulrich/xts/issues/174)).
* Constructors xts() and .xts() now ensure order.by and index arguments do not
contain non-finite values. Many xts functions, most notably merge.xts(),
expect all index values to be finite. Missing index values usually indicate
an error, and always occurred at the end of the index
([#173](https://github.com/joshuaulrich/xts/issues/173),
([#194](https://github.com/joshuaulrich/xts/issues/194),
([#199](https://github.com/joshuaulrich/xts/issues/199)).
* Fixed bug in endpoints() when called on sparse data that have the same month
and day, but different years
([#169](https://github.com/joshuaulrich/xts/issues/169)).
* Fixed bug in [.xts did not do the same checks on logical xts objects as it
does for all other data types
([#163](https://github.com/joshuaulrich/xts/issues/163)).
* Fixed bug that caused split.xts() to error if 'f' is a character vector with
more than 1 element
([#134](https://github.com/joshuaulrich/xts/issues/134)).
* Fixed bug that crashed R if 'k' argument to lag.xts() was not an integer and
would be NA when coerced to integer
([#152](https://github.com/joshuaulrich/xts/issues/152)).
* period.apply() now checks to ensure the object's index is unique and sorted,
and sets INDEX <- sort(unique(INDEX)) if it is not. It also ensures INDEX
starts with 0 and ends with NROW(x)
([#171](https://github.com/joshuaulrich/xts/issues/171)).
* All references to the 'its' package have been removed, since it is now
archived on CRAN at the request of its maintainer.
* Fixed bug that crashed R when merge.xts() was called on an empty xts object
and more than one non-xts object
([#157](https://github.com/joshuaulrich/xts/issues/157)).
* Fixed bug that did not set the index's tzone attribute to UTC when
index<-.xts or indexClass<- were called and 'value' did not have a tzone
attribute
([#148](https://github.com/joshuaulrich/xts/issues/148)).
* Fixed a bug in endpoints() that caused incorrect results if the index was
less than the epoch
([#144](https://github.com/joshuaulrich/xts/issues/144)).
* Fixed a bug that caused diff.xts() on a logical xts object to return an
object with a POSIXct index.
* index.xts() works even if the package containing the class for the index
is not attached (it needs to be loaded, however).
* [.xts now returns NA if a one-column xts object is subsect by NA, instead
of throwing an uninformative error
([#97](https://github.com/joshuaulrich/xts/issues/97)).
* Fixed bugs that would crash R when [.xts was called a certain way and 'j'
contained NA values
([#97](https://github.com/joshuaulrich/xts/issues/97),
[#181](https://github.com/joshuaulrich/xts/issues/181)).
* Fixed a bug in endpoints() where 1 second would be subtracted for any date
in the year 1969. The subtraction is only supposed to occur on
1969-12-31 23:59:59.9... to work around behavior in strptime().
* timeBasedSeq() now honors hour/min/sec 'BY' values
([#91](https://github.com/joshuaulrich/xts/issues/91)).
* [.xts now throws an error if 'j' is character and not one of the column
names. This is consistent with [.zoo and [.matrix
([#48](https://github.com/joshuaulrich/xts/issues/48)).
* timeBasedSeq() now works correctly when resolution is "days" the sequence
includes a daylight saving time change
([#67](https://github.com/joshuaulrich/xts/issues/67)).
* Explicitly set indexTZ="UTC" for all index classes that do not have a TZ
([#66](https://github.com/joshuaulrich/xts/issues/66)). indexTZ="GMT" is also allowed.
* Fixed as.xts() when called on an 'mts' object ([#64](https://github.com/joshuaulrich/xts/issues/64)).
* Moved development from R-Forge to GitHub.
* Fixed bug in to.period() that errored when name=NULL
([#2](https://github.com/joshuaulrich/xts/issues/2)).
* Fixed bug in `.index*` functions that did not account for timezones
([#3](https://github.com/joshuaulrich/xts/issues/3)).
* Fixed bug that allowed index<-.xts to produce an unsorted index
([#4](https://github.com/joshuaulrich/xts/issues/4)).
* Fixed bug so subsetting a zero-width xts object with a zero-length 'i'
vector no longer returns an object with column names
([#5](https://github.com/joshuaulrich/xts/issues/5)).
* Updated [.xts to handle 'i' containing multiple zeros (e.g. subsetting by a
"logical" column of an integer xts object).
* endpoints() now errors if k < 0.
# xts 0.9-7 (2014-01-02)
* Fixed bug that caused logical operators on xts objects to drop the 'tzone'
attribute ([#10](https://github.com/joshuaulrich/xts/issues/10)).
* Fixed bug that ignored 'which.i' argument to [.xts on zero-width xts
objects ([#12](https://github.com/joshuaulrich/xts/issues/12)).
* Fixed bug where xts() does not sort 'order.by' if x is missing
([#13](https://github.com/joshuaulrich/xts/issues/13)).
* Fixed bug where setting dimnames to NULL would break as.xts()
([#14](https://github.com/joshuaulrich/xts/issues/14)).
* Added checks to period.sum/prod/min/max to ensure INDEX is in [0,nrow(x)].
* Fixed missing argument to na_locf() in the C/C++ xtsAPI (Dirk Eddelbuettel).
# xts 0.9-5 (2013-06-24)
* Increased zoo dependency version to 1.7-10 for changes in C code.
* Fixed several minor issues in the C/C++ xtsAPI (Dirk Eddelbuettel).
# xts 0.9-4 (2013-06-09)
* Fixed bug where the index was missing the 'tzone' attribute.
* Fixed to.period() bug when 'indexAt' is "firstof" or "lastof". (bug [#15](https://github.com/joshuaulrich/xts/issues/15),
patch [#35](https://github.com/joshuaulrich/xts/issues/35), thanks to Garrett See)
* Fixed subsetting bug on zero-width xts objects that returned NA data and an
NA index ([#16](https://github.com/joshuaulrich/xts/issues/16)).
* xts' merge() method now has 'drop' and 'check.names' arguments to match
the zoo merge() method.
* 'index<-' now correctly handles UTC Date objects when resetting index
values. '.index<-' behaved correctly.
* xts' rollapply() method now handles the 'fill' argument.
* Added several functions to the C/C++ API:
- make_index_unique
- make_unique
- endpoints
- do_merge_xts
- na_omit_xts
- na_locf
* Fixed xts' rollapply() method when input has one column, but function
output has more than one column.
# xts 0.9-3 (2013-01-20)
* No user-visible changes.
# xts 0.9-2 (2013-01-18)
* Added C/C++ xtsAPI (Dirk Eddelbuettel)
* Added tzone() and tclass() functions as aliases to indexTZ() and
indexClass(), respectively. Eventually will Deprecate/Defunct the former.
# xts 0.9-1 (2012-12-29)
* xts() now ignores timezone arguments when order.by is Date class, with a
warning.
# xts 0.8-8 (2012-11-06)
* Modified str() output to make use of proper ISO-8601 range formating
* Fixed bug in reclass() when 'tzone' of object is different than system TZ.
* Fixed bug in xts() that dropped dims when 'x' is a 1-column matrix or
data.frame.
* [.xts no longer warns if 'i' is zero-length.
* to.period() now checks that 'x' is not zero-length/width.
* Fixed edge case in Ops.xts where two objects with no common index create
an invalid 'xts' object with no index.
* to.monthly() and to.quarterly() now default to drop.time=TRUE.
* Internal .drop.time() now changes the index class to Date. This affects
the to.period() family of functions.
* Restore Date index/tclass conversion to POSIXct with a UTC timezone via
integer division instead of double-precision division.
# xts 0.8-6 (2012-03-25)
* Revert Date index/tclass conversion to POSIXct with a UTC timezone to
previous behavior as in 0.8-2.
# xts 0.8-5 (2012-03-24)
* A Date index/tclass is now internally converted to POSIXct with a UTC
timezone ensure proper conversion regardless of user TZ settings.
* tclass is now an argument to .xts()
* Fix endpoints() properly handles millisecond time stamps (and microsecond
on not Windows).
* Subsetting zero-width xts objects now behaves like zoo, with NA values
returned for valid row requests.
# xts 0.8-2 (2011-08-09)
* Fixed bug in lag() and diff() for character coredata.
* Fixed subsetting bug that returned a contiguous chunk of data even when
a non-contiguous 'i' was provided.
* Fixed bug that ignored FinCenter/TZ for timeDate index
* period.apply() now only sets colnames if the number of columns in the input
and output are equal.
* Fixed periodicity() when scale = "yearly"
* Fixed [.xts when row-subsetting via a POSIXct vector, which returned an
object full of NA.
* Added '...' to axis() call inside of plot.xts() to allow for 'cex.axis'
and 'cex.lab' to be passed in.
* Fixed axes=FALSE issue in plot.xts().
* Dependency now on 1.7-0 or better of zoo (R-forge at present)
This build now links to C code moved from xts to zoo. At present
this is only for zoo_lag (used in lag and lagts)
* Added 'drop' and 'fromLast' arguments to make.index.unique().
* Added adj.time() and shift.time()
* Fixed na.locf() bug that would fill trailing NA larger than 'maxgap'
observations ([#22](https://github.com/joshuaulrich/xts/issues/22))
* Updated indexFormat() documentation and add an example
# xts 0.8-0 (2011-02-22)
* Fix print formatting ([#27](https://github.com/joshuaulrich/xts/issues/27))
* Fix bug related to na.locf() and zero-width objects ([#28](https://github.com/joshuaulrich/xts/issues/28))
* Add .RECLASS = FALSE after '...' for as.xts.*() methods. This makes all
as.xts.*() methods one-way (i.e. not reclass-able). Objects converted to
xts via try.xts() can still be converted back to their original class
via relcass().
* Fix bug that caused colnames to be dropped if object is subset by time
that is not in the index.
# xts 0.7-5 (2010-08-21)
* try.xts and reclass now are more efficient on xts objects,
no longer appending a .RECLASS attribute. This penalty
(copying) is shifted to classes that are internally converted
to xts.
# xts 0.7-4 (2010-08-04)
* internal attributes of index are now maintaining
timezone (tzone), time class (tclass) information.
* `[.xts` method is now using new C code. This may revert
back as character-based objects are not supported. Changed
for future code refactoring into zoo, as well as performance
gains on integer, double and logical values. Also added in
checks for NAs. drop=TRUE now works correctly in all known
applications.
* (cbind)merge.xts and rbind.xts now copy index attributes
to handle internal changes to index characteristics (in C code)
* indexTZ.Rd updated to provide information regarding internal
changes. Also indexTZ<- is now exported to facilitate
timezone changing of xts objects.
# xts 0.7-1 (2010-05-08)
* subsecond ISO8601 subsetting on dates
before 1970 (epoch) is disabled. This is due to a bug
in the R implementation of POSIX handling of fractional
seconds pre-1970. 10 microsecond granularity is still
functional for all other times. Thanks to Andreas Noack Jensen
for the early bug report.
* new 'tzone' arg in xts constructor and 'tz' in .parseISO8601
allows for future support of non-system TZ dependent indexing
* internal index attribute (numeric) now can have attributes
set (tzone is currently the only one used in xts). These should
remain during all xts operations. Still experimental.
* naCheck has been exposed at the C level for use in packages
"LinkingTo: xts". See ?xtsAPI for more details.
# xts 0.7-0 (2010-01-26)
* A new NEWS file.
* print.xts now passes ...
* endpoints speedup and bug fix (thanks Ismail Onur Filiz)
* na.omit bug on logical and NaN fixes (thanks Fabrizio Pollastri
and Koert Kuipers)
* fromLast=FALSE for na.locf.xts. Matching to zoo. (thanks
to Sandor Benczik)
* LGLSXP support in leadingNA (R fun naCheck)
* fixed logical and NA 'j' subsetting. Thanks Koert Kuipers.
* as.xts and as.timeSeries fixes for timeSeries changes
* merge and subset now support dimensionless xts (non-standard).
merge segfault fixed when merging all 3 or more zero-width xts objects
and only zero-width objects. Thanks to Koert Kuipers for the report.
* added which.i to [.xts to return i values found via
ISO8601 subset string
* new lines.xts and plot.xts, similar to methods in zoo
* lastof now has sec to 10 microsecond precision, and subsec
arg to append to secs.
* xts() further consistency in NROW/index check
* align.time error checks for positive n= values (thanks Brian Peterson)
* toPeriod updates in C, almost exported. ~600-1200x faster
* new lag_xts in C. Increased speed and index flexibility.
* endpoints 'days' bug fix
* .makeISO8601 function to create ISO8601 compliant string
from xts objects
xts/inst/ 0000755 0001762 0000144 00000000000 14703504524 012051 5 ustar ligges users xts/inst/include/ 0000755 0001762 0000144 00000000000 14636572747 013515 5 ustar ligges users xts/inst/include/xts.h 0000644 0001762 0000144 00000007466 14636572747 014521 0 ustar ligges users /*
Header file for using internal C-level facilities
provided by xts.
This is not 100% designed for end users, so
any user comments and bug reports are very
welcomed.
Copyright Jeffrey A. Ryan 2008
This source is distributed with the same license
as the full xts software, GPL (>= 2).
*/
#include
#include
#include
#ifndef _XTS
#define _XTS
#ifdef __cplusplus
extern "C" {
#endif
/*
INTERNAL SYMBOLS
*/
extern SEXP xts_IndexSymbol;
extern SEXP xts_ClassSymbol;
extern SEXP xts_IndexTformatSymbol;
extern SEXP xts_IndexTclassSymbol;
extern SEXP xts_IndexTzoneSymbol;
/*
DATA TOOLS
*/
#define xts_ATTRIB(x) coerceVector(do_xtsAttributes(x),LISTSXP)
#define xts_COREATTRIB(x) coerceVector(do_xtsCoreAttributes(x),LISTSXP)
// attr(x, 'index') or .index(x)
#define GET_xtsIndex(x) getAttrib(x, xts_IndexSymbol)
#define SET_xtsIndex(x,value) setAttrib(x, xts_IndexSymbol, value)
// attr(x, '.indexFORMAT') or indexFormat(x)
#define GET_xtsIndexFormat(x) getAttrib(x, xts_IndexFormatSymbol)
#define SET_xtsIndexFormat(x,value) setAttrib(x, xts_IndexFormatSymbol, value)
// attr(x, '.CLASS') or CLASS(x)
#define GET_xtsCLASS(x) getAttrib(x, xts_ClassSymbol)
#define SET_xtsCLASS(x,value) setAttrib(x, xts_ClassSymbol, value)
/*
IMPORTS FROM zoo
*/
extern SEXP(*zoo_lag)(SEXP,SEXP,SEXP);
extern SEXP(*zoo_coredata)(SEXP,SEXP);
/*
FUNCTIONS
*/
SEXP do_xtsAttributes(SEXP x); // xtsAttributes i.e. user-added attributes
SEXP add_xtsCoreAttributes(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP);
SEXP do_xtsCoreAttributes(SEXP x); /* xtsCoreAttributes xts-specific attributes
CLASS, .indexFORMAT, tclass, & class */
SEXP coredata(SEXP x, SEXP copyAttr);
SEXP coredata_xts(SEXP x);
SEXP add_class(SEXP x, SEXP klass);
SEXP lagXts(SEXP x, SEXP k, SEXP pad);
SEXP lag_xts(SEXP x, SEXP k, SEXP pad);
SEXP do_is_ordered(SEXP x, SEXP increasing, SEXP strictly);
SEXP mergeXts(SEXP args);
SEXP do_rbind_xts(SEXP x, SEXP y, SEXP dup);
SEXP rbindXts(SEXP args);
SEXP do_subset_xts(SEXP x, SEXP sr, SEXP sc, SEXP drop);
SEXP _do_subset_xts(SEXP x, SEXP sr, SEXP sc, SEXP drop);
SEXP number_of_cols(SEXP args);
SEXP naCheck(SEXP x, SEXP check);
SEXP make_index_unique(SEXP x, SEXP eps);
SEXP make_unique(SEXP X, SEXP eps);
SEXP endpoints(SEXP _x, SEXP _on, SEXP _k, SEXP _addlast);
SEXP do_merge_xts(SEXP x, SEXP y, SEXP all, SEXP fill, SEXP retclass, SEXP colnames,
SEXP suffixes, SEXP retside, SEXP check_names, SEXP env, SEXP coerce);
SEXP na_omit_xts(SEXP x);
SEXP na_locf(SEXP x, SEXP fromlast, SEXP maxgap, SEXP limit);
SEXP tryXts(SEXP x);
SEXP binsearch(SEXP, SEXP, SEXP);
SEXP any_negative(SEXP);
SEXP fill_window_dups_rev(SEXP data, SEXP index);
SEXP non_duplicates(SEXP data, SEXP from_last);
SEXP toPeriod(SEXP, SEXP, SEXP, SEXP, SEXP, SEXP, SEXP);
SEXP xts_period_apply(SEXP data, SEXP index, SEXP function, SEXP env);
SEXP xts_period_min(SEXP data, SEXP index);
SEXP xts_period_max(SEXP data, SEXP index);
SEXP xts_period_sum(SEXP data, SEXP index);
SEXP xts_period_prod(SEXP data, SEXP index);
SEXP roll_min(SEXP x, SEXP n);
SEXP roll_max(SEXP x, SEXP n);
SEXP roll_sum(SEXP x, SEXP n);
SEXP roll_cov(SEXP x, SEXP n, SEXP sample, SEXP);
SEXP dimnames_zoo(SEXP x);
SEXP xts_set_dimnames(SEXP x, SEXP value);
void copyAttributes(SEXP x, SEXP y); // internal only
void copy_xtsAttributes(SEXP x, SEXP y); // internal only
void copy_xtsCoreAttributes(SEXP x, SEXP y);// internal only
SEXP isXts(SEXP x); // is.xts analogue
int firstNonNA(SEXP x);
SEXP extract_col (SEXP x, SEXP j, SEXP drop, SEXP first_, SEXP last_);
SEXP do_startofyear(SEXP from, SEXP to, SEXP origin);
int xts_ncols(SEXP x);
#endif /* _XTS */
#ifdef __cplusplus
}
#endif
xts/inst/include/xts_stubs.c 0000644 0001762 0000144 00000000114 14634166522 015677 0 ustar ligges users
#warning("This header is deprecated. Please include 'xtsAPI.h' instead.")
xts/inst/include/xtsAPI.h 0000644 0001762 0000144 00000007320 14634167654 015033 0 ustar ligges users /*
Header file for using internal C-level facilities
provided by xts.
This is not 100% designed for end users, so
any user comments and bug reports are very
welcomed.
Copyright 2008 - 2014 Jeffrey A. Ryan
Copyright 2014 Dirk Eddelbuettel
This source is distributed with the same license
as the full xts software, GPL (>= 2).
*/
#ifndef _XTS_API_H
#define _XTS_API_H
#include // also includes R.h, Rinternals.h, Rdefines.h
#include
#include
#ifdef HAVE_VISIBILITY_ATTRIBUTE
# define attribute_hidden __attribute__ ((visibility ("hidden")))
#else
# define attribute_hidden
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*
To aid those looking for answers on interfacing compiled code from
another package.
This is simply constructing a function pointer for use.
static RETURNTYPE(*fun)(ARG1,ARG2) = NULL where ARGS are the types accepted, comma seperated
fun = ( RETURNTYPE(*)(ARG1,ARG2)) R_GetCCallable("PACKAGENAME", "FUNCTIONNAME")
*/
SEXP attribute_hidden xtsIs(SEXP x) {
static SEXP(*fun)(SEXP) = (SEXP(*)(SEXP)) R_GetCCallable("xts","isXts");
return fun(x);
}
SEXP attribute_hidden xtsIsOrdered(SEXP x, SEXP increasing, SEXP strictly) {
static SEXP(*fun)(SEXP,SEXP,SEXP) = (SEXP(*)(SEXP,SEXP,SEXP)) R_GetCCallable("xts","do_is_ordered");
return fun(x, increasing, strictly);
}
SEXP attribute_hidden xtsNaCheck(SEXP x, SEXP check) {
static SEXP(*fun)(SEXP,SEXP) = (SEXP(*)(SEXP,SEXP)) R_GetCCallable("xts","naCheck");
return fun(x, check);
}
SEXP attribute_hidden xtsTry(SEXP x) {
static SEXP(*fun)(SEXP) = (SEXP(*)(SEXP)) R_GetCCallable("xts","tryXts");
return fun(x);
}
SEXP attribute_hidden xtsRbind(SEXP x, SEXP y, SEXP dup) {
static SEXP(*fun)(SEXP, SEXP, SEXP) =
(SEXP(*)(SEXP,SEXP,SEXP)) R_GetCCallable("xts","do_rbind_xts");
return fun(x, y, dup);
}
SEXP attribute_hidden xtsCoredata(SEXP x) {
static SEXP(*fun)(SEXP) = (SEXP(*)(SEXP)) R_GetCCallable("xts","coredata_xts");
return fun(x);
}
SEXP attribute_hidden xtsLag(SEXP x, SEXP k, SEXP pad) {
static SEXP(*fun)(SEXP,SEXP,SEXP) = (SEXP(*)(SEXP,SEXP,SEXP)) R_GetCCallable("xts","lagXts");
return fun(x, k, pad);
}
SEXP attribute_hidden xtsMakeIndexUnique(SEXP x, SEXP eps) {
static SEXP(*fun)(SEXP,SEXP) = (SEXP(*)(SEXP,SEXP)) R_GetCCallable("xts","make_index_unique");
return fun(x, eps);
}
SEXP attribute_hidden xtsMakeUnique(SEXP x, SEXP eps) {
static SEXP(*fun)(SEXP,SEXP) = (SEXP(*)(SEXP,SEXP)) R_GetCCallable("xts","make_unique");
return fun(x, eps);
}
SEXP attribute_hidden xtsEndpoints(SEXP x, SEXP on, SEXP k, SEXP addlast) {
static SEXP(*fun)(SEXP,SEXP,SEXP,SEXP) =
(SEXP(*)(SEXP,SEXP,SEXP,SEXP)) R_GetCCallable("xts","endpoints");
return fun(x, on, k, addlast);
}
SEXP attribute_hidden xtsMerge(SEXP x, SEXP y, SEXP all, SEXP fill, SEXP retclass,
SEXP colnames, SEXP suffixes, SEXP retside, SEXP check_names,
SEXP env, SEXP coerce) {
static SEXP(*fun)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP) =
(SEXP(*)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP)) R_GetCCallable("xts","do_merge_xts");
return fun(x, y, all, fill, retclass, colnames, suffixes, retside, check_names, env, coerce);
}
SEXP attribute_hidden xtsNaOmit(SEXP x) {
static SEXP(*fun)(SEXP) = (SEXP(*)(SEXP)) R_GetCCallable("xts","na_omit_xts");
return fun(x);
}
SEXP attribute_hidden xtsNaLocf(SEXP x, SEXP fromLast, SEXP maxgap, SEXP limit) {
static SEXP(*fun)(SEXP,SEXP,SEXP,SEXP) =
(SEXP(*)(SEXP,SEXP,SEXP,SEXP)) R_GetCCallable("xts","na_locf");
return fun(x, fromLast, maxgap, limit);
}
#ifdef __cplusplus
}
#endif
#endif /* !_XTS_API_H */
xts/inst/doc/ 0000755 0001762 0000144 00000000000 14703504524 012616 5 ustar ligges users xts/inst/doc/xts.pdf 0000644 0001762 0000144 00001234541 14703504524 014141 0 ustar ligges users %PDF-1.5
%ÐÔÅØ
89 0 obj
<<
/Length 1818
/Filter /FlateDecode
>>
stream
xÚÝY[“Ó6~çWä©ufˆÐÝRß(fÚÎ,ËåÁ›h7.‰½õX~}Ï‘'v²L;´ðdYVŽÎí;·ÐÙ͌Ξ? 'ž?_>xôLØË gJÎ.¯gÌ
b¸™i¦ˆ°ùìr5{“}ìÚŸæ ™ÛìéÇÎUmyµqó…Ð4»,·qõÊ5¥kço/_>z&éŒ1b•âž$%|¶à†c½—î*Dãîà§\g >óìânÎMVTs8lEö²n×sØî‹ðùWŽ¿Þ4å?¬ñ¶™Î‰ .Dä2\ðkß#yf †§Ô›1I„ÔžÁ9QhHN¤ÕÆ“ºš –¼sA³Î‹šÑf
ªÏA ¥%Vs´(0¢³H„Í–«ìÐàY×ÔÈH¶ê—] ÔÁ`ŠÙ›×Ôäð‹ô=e(ó@ùrú7"k»ÈöM|¯£¤â€9Fa‚©YG² 0䆱îyBÓœKÍÄRš Îlkf¶*¼rY ·S6…ýž4žŸÕø2 …ÉÇ1@¤¾nËê&€³[»„EÀv\æG] QTíÎÜKŒ+ïæZfÅÍ‘ûs&Džé{â6gÄ°‰ëˆ¶O÷ ØVEW„U}êÓÙŸn‰9"r¸$°.Z’ö4!÷ƒ\EµJ‘²DèütðäŠØÝѯî5ú,N9•iøTÛÿP]·ŽX=¨Uò›èyÅçg/0'zÑË/\ÛÕÍàæO®Bf°wSVÅ&l/7EsØ"姊jÙÎ çNK>`ã‡) ´wù‹=¥Snâ1õÏý~ª[_˜Ðó^-Á…ÅQ ‘Q»±¼[JÌ ;]vå¾fn1gÙ®ŠÖâ§àÃõæȉµeÿsgô
ã_˜< $µ’“‡ Éã÷ #½ÛÔ·CùPvëd‘G‰Ü爳E ;,òØ}³…€žAL$‡tñ{傯û*» G×uk¿Í!–\:uÈœh:ƒ]sGÎ}ð~aùW û÷0ÿù,ÀŒ!Ö )‘Ñêùê^Ñ(©?Ž`x"ÔŸ&\Uý%g¾7 Ô§÷G* çI}[~Pƒµ…_øVv5ìO]˧+UÆìý ±C¯·eD¯"ì>ýq×5åUß¹ÏZ'‡jŒ‰ÿÀ»¿šáíYÄXM(Ÿ$5 æUåS†wt´ì±îsM$»o eÕA ú5Îé—¦(Fñe 5 ¡VWËMß&'B±xÙtøBqb@ Ä©ÝÀî ~bÂâÄ„ NL&&
SÃlø¹ ‡Hø}ÛA»Òvåä¤,ÛÕM ›¤£Œi‰TC»p‘¸ÆÉ. x3‘bÍdãm`¢Æ1—kÚðÖíxjž6ÌÌüfý®íâKx¼ŸCkUÀ™.Ž³<Ñëðܺ%ÖSk_‚¢e ѹC£¨Êvë/ྜÂg€H
µƒ×K‹¬À7–5. ð[àé&nÏnQV+÷Ñů؂siE³ß@×ï‘™”vyeÔg´»ŸJÅŠ \r™uU“ 󙱘] õªG¨¬íË®ðóI|ó.<ÿƒ¾a#´°¸*ÑmWIÇ°”(= /ñuSl]BÅ ß× S¡‡ˆ}'¼- äL5Ì1Ïм‡Æd 2KòÜ|c†È=#ÆÀfR2 š-ê‹Ï`Á|?um’îÁêbpë5‚dÓ/Iý dWß·ÿ LûdÃÙáÐ ´ ¶Rh«£`Ì‚q
DPó|7xè«S×£q‰œÌj¢l˜£Nɦ‡ ìbëÀß–)âJD>îªGO;I$Dòw§ñ¬¡"RìÌ :#Nf4–ÈhxáHìÒ7sGâ4Är@1œ™ÂÊû›Ìž ®#HsJ(›¨± r…·x×Ìõ1pýæ.Yàá[ˆGÊUØÑY_•5Â׶Þô±…/ˆmÜ… ‡¿¹ »×†EéñÛö»+·HasSt‡S lÒ> Ùºy7´o¾]ßÍ<â¡Ã“*i yjôÀýŸgcÓ<½|ð7ÙÃ\
endstream
endobj
107 0 obj
<<
/Length 3351
/Filter /FlateDecode
>>
stream
xÚZIs嶾ûWè6T•D“¸R¶“I9U‰«ÆJù`û ‘„ ùÌe$åק7€|ÇÊåakbit½à%WWÉÕß¿I¤üþî›o?ªòªŽë"+®î ®R]Åeš]yg*¿ºk¯~~yr½¾Íê:r3—“µ§‰«†‹{?t6£i‡ë¬Š^\c:î|vó“wÒ5?ÑœUÔ\ߦÑ2Ž×id±Úã·2ÙpžÝЇ•`àËu^DÆuæ¾³7×·*)¢ç'3_ÿ~÷o?æjs–ÛTǵÖP¦qËY>1áš˸Jj`Œvø
æuÔ[ÛÚ–ëϸ¸™¸1ô–+§a”ÚìNöv²£³BÓtfšâë[%ÀAüúõ/Üú7ù‰ ¸üÄÅ“ ~¬ï‘õO†øòŠû¿ºå-_œ¬Áá§Á5¸äÜA)sÜC,ÇÊ+õšQ( !€EÌ£ë …|{$ìhñz ÜÓlà`E‘DwONÆà^òÈ íÌÛ¤Î'#£'käZqûÉåÎg¼¿[œi-ï·ÎpjÜøÄ—Œáž–+óÀåÙ>sËô2,l¡é† ?NEöh/ÉÊ"ÐûÊ5ºìaédŽi9ó~†qF™ËÔŽNâNçu¡¬N¼' Jp/“_¹I2?\“°‡Kš¼¨'Ñ"óô»ilßÞ.p%(W
äJÔ*])¦'‹×Õ“yìݼ´öb«o%O)ÐäánŒå¥{ÏF˜‰—úH R
ÈÝãpâÚŸ¾û×
W°$ÀÊ=lªŒl3œ¬Ÿ
¾ P:Û?ú Q ±²¦ 0š®W'êXbp ÅË 9m;ÛÌÜ62|)ÛŠ%AÆH u¢¶°4Ãúq© >È7ÈN?v$}뾸vA‹œn õ†[;¹™à [ÏO¶ç£6Ö\‡8ù¥¡C®ÔÏ…¥®ÿ€U•Ç3£‘àQ.
xa}9°ŒÍÂg&Q ”fUùÒN"Ó›ó¸X®û©²ô7“HA÷‰5à*n–¾,LªŠEÿÞLdÙp¹¾µ/v: bŠUà±"UpgÜ;äµU‰&[¹Zü ýºÔÝ‘Uyt í7,¨G•8ê¾
#%®.ìд„QÙ1#’´f6\óZ ”€mV¦r}° C÷·ˆÛG"óuÙò ¡Ê5ü¡ª¸ª+ï;˜éÀ»€y³$÷$pïÝ„š5ðÌÍ ÐÕXY
ø
û -Y\ Çz!b;{7ƒ]4a è8 " ‘ÈKåÝ7" ÃÚ…Zå*Nõ5µRÕúC§ tÉ®II:ÆLäÆÑ)Ì 9 eg'©Áœ¹}ñxV¡àö<0‰¼—gV^Uz„«Ä$0ý »³Û½ iãQžÉç¹bÖæÄZî£4lü°Ò4 `[ÕÊ '/YØ¡0l–9ÏYš Ž#óhF‹·¤Ñwxž¶u(Ü¤Í y7‡¦Lú&à¯"žÖÞi 4V ;ÙYü{ | óÌc¤@HcXþg2&Ú»@84ŒTËÈþ|˜¸K4 ¾q²¢›ÑB6 gžY àˆpúXô𪟠“µòr5s ]iVÇIÔ ëgÖÈ·j–q¡V5k®H)ô¶ŒA5<õ‡á`Æ,‰•zšKˆ³6†d‹v>ƒµº_fÐÛL«X%åIFGø¤¨PäúrOª
{úèú l?Ûñ`gZÇ90](oæ*ã²lâŽNˆè•®ó€ fäZ½Hunb¼Î1XƒŸ@'@ÞÛ ÿzt1:‡X%\ dQð‚n˜f”J×,(åNPÞ;¤Ôò³˜Ã°¯ÎâªÜEGïÉNÐÿö¦LgvVÛ–Á³·ÏÜþp·°(ßZ&žÀôa*qÑ9Bè<úx])ŠF¦»Œõdw_s piø J§Q;p®œ Ü맵\AÕF\Ó™7
ÐéËÓ0ÉŒcsÞÉ÷t ,›Æžg 4‚_{èýZâJƒw¬áx GµÞ:/ØôÇÐÇ!’Œ1$aM M¨† a[ÑÈÒ'ÈâË|h¯ó¸¨‚¤8š'Mâ4ËV‘ŽÏ YC{$YI¬«[X7ëä ä¡zܨASr½ÉñL%¾îiRøV¤ë¸ç#^gÁ™ŠÍ8Z£y{vTÓ„a'ô'7Mâ1Cº?÷t¹ì3_SqéŸïìÁ.hOQ´ÞJ@c¸x0Íì}HŽuôѬæ‰\LÆuö6Q>z”¹Qüè¯ùš?Qº¦à(
KŽ–¡Â2ž!N!Ä7!Flö´û1à@2ê"){GÂ*°ÅÎTÑn ë™_kØù‰·ºpL;~ð‚f¬Êå™ÅÆÏèd
àƒeÒ„´Fÿaæ 4doOR'q]êw’¦AŒÌÌ
n4
=5Äf”°Ï¾œ;׸=!…n‚Nuôý+6îBô ç9´êl¨Vïè÷[–dz xF3Ô(d4Ü>¡T +}¸
”^é¸õ6Á1 fÑãbF‘-KŠˆ°;p¹Ó•0‚"ΰ›ù đψžâoÿØY®ˆ•–ÊMX~¸Î?Î<$Š‰ÉùhÙd¬°M&Êç‘ü^Z.„§ dºáÎ7Ê_ ‚Cß’ÝH³³‰†²Œœ Á¤Ù6ÖHÓ ãŸ \frØžîw…4³Ð‚
NÞBBL{ÄÞ·§V>uxƒ6ÍKìÇMh–tdr™EßÛL8 E©â2×ÿ‡=*7N.'i¦½üi ¦kžÌ8Õç)à|«w»
2nü|ò hŽœ¬¬,Á5/.ùôÇbúùthÁ Ì‚o»Ë.þŠôáQÆ‹}Çï¬
!¿Õ €™à€xá:àx®c¥«?wüÁKHª€"»`ÜoÃv轡ú »3ŸýÒ-WV[Ç
ØT» »åh^I. D¾„ÖØ|ƃS ïW¿ýÏ][‰õ¼»³lÖ]“\ÐX&Ní”’†,ñÈ% Ybzˆv6¡åCð Øæ/$WT—jg¢¦™Ò«YÂú²
Ö‹³HØW“/Hq9ù‘YÎÙdMçïš.¾ôÁB–•œ kŽ°b°MÄû”g0$ Ÿë> € Vê&#γ „Ui ±J´Ûô¯Çò˜®±ç¡ÀŒ)vT/Ÿ·0hWUz™ßVUxéÀˆ£*¢ŸÝ ¶tàìØa™H•€
³µàl³X]<Èœ,sƒp~^‰_Z k´íÒà—G‰DÊ6(rÆ ˆ¾]&IhLtxÇM~ò> V,eû¹*˜Õ*u!ùC¥·Ðp“ØÄÕ Ð™µ›‡2z +¼x!¸ð™ñuÀɓ–Ò}ñžöØpiiå„SùÏx
OçMè,D "ðÛ˜¬åðÁŒòÊ>£#ÊðO~‰,ÁI²³q”d̪œŸ,¡×k0¶Tè…bŠZZä Céúf×ì¶ÜéÞØ—–Ùûj¶zˆ²ãWY7d¥!VÚ¥MøæM
ºÙ¾m2V©3Òo¢'Ñ‚¸½Ír²žm_‘çî\ž»óõaøö͵ùøá9M4@ýû Td+g&žñ<º“]'KY‡“~C·iBùd»³ßßgÿf -ûâ ZÉaE85uîÍm å
Œòîôü6¢Ù
Œ· ÿ 8䤣ïáÃ
V`¯¢ø$LÐÜ»ðü+ÆKJœàö¥q>ùW‚¬ç‰'Ù·T
endstream
endobj
113 0 obj
<<
/Length 395
/Filter /FlateDecode
>>
stream
xÚ…’ÁnÜ †ïû ± ìk¤¦Rξ59›]ÓØ°2¤»}û‚‡DݨROž>fþ0E'DÑ÷-߇ápÿÈêI/™DÃ5mGTÊ0.Ð0¡ x˜MU³ŽáͬںÉl9m°?B9Î6@źŠu8n>§xz £õ ‹]€ÌU¯Ö•–—YG(kW½ O÷‚ÿ¥‡µI‡ì’Ú]É5€nEw¤í›Æ¿Vµø§KãÑ»`ÜD©B‰¢ ÕMCzQ f'œÒ¤aÊA2’ð½òªƒ !|údîr¬’‡ó’Vðì³ë P“ù•3³ø³u' .6Îÿ2Ç8éÔ½IÕ0£v0%èŠ) “ rÖcÎÞ*!pÒùEL]Ì·Œˆ¶ÿbþ¼x·t‰+ íºÛä]Ù—ø™òÖéeù
>
stream
xÚYKsܸ¾ûWÌm9U † A“›’ݤœÊ®S±ª6Uq I\sH$%Ù¿>ýÉÑ–/C ñêntÝIvw»d÷÷7‰|ÿrýæOËÕNé8Ó&Ý]ßîT–Å…)w&/â4Ëw×õî¿Qº?(•$Ñõ½Û 2c¢aôS5NžºEÔßîÿwýØ*?ÛJ§qR”pmò<<++vÇøhRƒ“aÖ!Uq©Jž{½/³¨‡Íõ1š:8=ª FÛÕL³ðɓ覹qê‰hͬèÕ!*-`ï4pòtoq]‘E¶ã/òFþ潊Ü>WQ%s*섉u¿!ƒR*N’cØþ-r¢£™7»OËè‹p¼?¤Eä–N¹Î}L2]5¶eòHg€B²2.S*Rñ1—«øÔõ¸ÝÓ†”i ›L]™Ši2%! ¡ß€È[wS±.MØ0Þ t–‚
4°MzÌ£ÁUcÓwØ1Q 6Ý ]W»š) ÍxðÄùcS; °Lÿ<5|bjë ‘àücãžXJe±R…èÂ0Gpׇ,Ë¢‘Ì2ÓÑ šj`âÅ Þ#˜Qk‡á-÷L|¢³Ú–·˜©¬>hÝ:‹–>ðøÉ~¢ù<ÖÈœ©k>O.–K1;¾1ò‚.¬¯ ®+t¦4Þ?‘Ñ¡"x]±^gòX':(ÿkßomž¦ñ1›'5 ïwïÀ6\,ã,OSð- ^s…Ò€Ú”¬*
þ\‘;! µˆ°!>>[Û‡Ž50ý]ÿNÀƒ™Ã L>7ûØ-·Gë¡c6NÉS°Âì…"~඿õý‰["b=X1º ô'riçYƒ=91À¢ˆMZž`ÃàFëèCszhtdWƒie` p³B³“&8 jÜ6PÐ=éëýŒÇ#óäÇ=ˆbÛ ÕEFcUzðÍÐtw<ç ®ë'Ͻڎ¤G4½5t|Lò¤¿×„MTÂÖ’ Á¢Gß<3í¶÷'˜¦¸Çp S켤v2ÓŽ°êf Ï@'Gò™“óÜÓ2PÐ^Œzý4òÔõ³(ùÇ\Ùúƒ°¨j€«_ûa”[þ²C£v ØV–
“÷ýÔÕ¤&$|í }{Y¼X‰,°ínºÏ“m¹“@¾àì ÊTtEësFø>!„õS[sW`ž;ÞÕÀ’c”déñMˆŽ40mdHÂq–ÎDî¹¢ëÄe³n=8TOÇÔ—{/»Ìo°ÿØÜun ¢¡Òr܇w´Íw…öK—]?6â9]Xσ8QÛ›¡÷7ÔÉ«ñî€sÂ5ž¹fF«é$’°ql°ˆ'i‚ñÖ±‹ú É€Ö¸5ùw غ8Fb¨õL'w‚Åâ”Ð"§„,Àá)±A¢ÆûÞËŒeÛÀ¥´<Æåké
SRÌ™Á%è²€N@ä‹Ðæ]ÕßuÍWb«dí½dÁq¢óïC£‚¬ œ¹üià
!sÝ jNkÄû““J 6c˜KÐVu3:!USDÓ€¤ CG–pŠ=K©5V„¡4.²ìüª58ê[ŽÅ
+ËÝssÓ´álÈ
1
ÑYô»ÄgÌýÆæ‘4:’‰fÉ7.LIl’W. bãq¹T÷ p90vÁ¾dQœ!$”ƒÂ§vCƒöç9¦!ßä!0toE*Îø€âXÄNb
XP Ö™&$•MÓmñÑÉR
éIÓÊ4¸ ¶yŽH·úÎÞ„)tàÂmÃþ60‘¸„ï*£A*ù-
ù’ ËeÑf€¢@ò¢±9¹dc|!:ê» LŽÒT(K(ô^ÞÛF*4§ 'ŠGQM¹"„Ù¬>ò,Î’”HŠ÷çAç gà[µ¨±é9g>3²8Rê;Æj‘‡xÌráö?(¡8>å fÅÞʆƒæø
œM9€ÆããCؾp‡œ™³’áϘ %PÀp}©SR¨Sf ËW¹9ÀEôç¢8·
#9(§A˜ÈTJ2À”ÑÒËb.(|ÇÛ˜P¬QEÁ¦ïüظApü Ãؽ}¶ÌõÄyÄœ¾Sìcý˜¤Fèƒó[×lÆÙ’ô ÁšÓ•jјó¸>
stream
xÚmRËRã0¼ç+tC>Xèa½ŽìÖf«¸âp0¶¢›’!Ï8’S¤’‹g$õ´{¦‡¢
¢èÿŠ–ø§]Ý®…F–XÅj_‚he’šp!Q; G¼÷骵8½¹œ ]ênbÉ}üØv7ø/¦P"ÀÃÞGGªº
ß͘aðÉOc·Ý N_ˆ–¸‡2W=·÷·kÙüǵ"Êj~”u¤Ï°³ ¸"
g ªßv±ðƪ®ž‹\ ˜A5cÄÊÒkhz(`w)ÿò™ÜLÀ ~¢’:²!W´K„äËO×~üëÆtU^cˆ6fA¾†iWèÄï F. äwîÁ:.ù$'ÜžÚ‰¬ˆ.' žáT1ðÅ
¹‘á3øq“Ÿûiœ}ùš?.Dð&‡3A SçãI »qŽ
þÚs>½Tµ”øÝõ)_ÄŸ9ÛÖžÎ5vù\LE àŽwe*à·vé5¸lîåL,
mÜѯÓÒ£ZS"^ËF@EÆÈ3Ì¿võmÖÌK
endstream
endobj
131 0 obj
<<
/Length 1897
/Filter /FlateDecode
>>
stream
xÚ•XYsÜD~ϯX¶¨B Öd.¤ÂQ༨”¬õÙ•Œ¤c~=ÝÓ-d+vò⣧ϯY..rñã#ɿߟ?zü,V %zq¾Y(cDšd‹$N…6ñâ|½x ˜U¨””Á«ÖU—«Ð$IÐmíêïóð< ?Ïc‘DÀÛ?{ßµL3¡S¡¤î‰®ŠreTðv•¨ ¸d¦&]ä"Ot‚ô¡ÒZ¤‘^„Z‰LeôîÅ¡íV¡ŽUp½-xåZúmì¿×Ø5íºeÐvEÄoéfF¢T¬…ÒæŽ}ؘ¥=Í·«0RiðKÝm½sý¾n,ËÞ
VÂí¯v|YÖÕJ§Á»•ÎÛ´¶
ìMR°~•ÈcA½¿çIpƒÄõ¡¡]yh[áQGÛÛ°µ³- ¬‹® Õµë¶s&ƒ0-ãÞœ¢óV%L: Õ:¨½ ±G)ÔØ¢CCü®Wš5¨ì5Ÿ_¬Â8 þ±eÇ癈3¶8!^ßÐ3ÂÚXq“‹,R„*Rf=
ø»íšCÙÕ`†É‚œìÆ°Ìgàÿ¬Ç¾Pˆ~ gÞ6Ÿ iÜ;VhM¢½5í)óMÇ|}<¥šsñT|œ
éSTë9n:†e~¿Ý!¤®PQ Í€eJ´ç[‹¸Œ²8(hn <×Ú uŠÝî†ÈÞ LÅÎi»·%’¦]»oé¬ãw>ò=÷j&^:JDª¢û×RÄGš1N¼ø—˜Ñ)äLÙ $iIJ¾…£öpuä5M‡%Á@µ™¦ ”»¢å%4“% (‰ -ù1|=~}ê{à×{D$|>œ‡‘HÒK>‘7{$Ž²
Þ‹ñ(Û0‰É§fÓÔ{J·¶lŠ®DHpþ} rdKú§ÔÊ>ëôªy"¤1 U,²\áT£~ðÇ6œt™êXýˆO6Ö$™A’}ïÚîXãÇ##t>8pŠy}:gm*R? èQ‰G
e 7«çXu„Õ
î9
ñ¢ØA ×7´)ëýÀZ\ì,‘ ¸ï"!ý\A+såaW4D15y0 aéf³*n64áßg,‰!•òQ½gý±û̲à~ed$dt Oà~‚» Š²´”]w
8Ü ª;T_ƒnè ZÆ\öÅ"5ÉGÔú O”PÀ½×Çí–Ae̸¥‚Ó–
×£"Ô
nWÐ{Òü–Á¿5¶å‡X>Mb‡, 5à\‚{®Cmë(´p…å¯ü,
ÊÑ! ¤ò^ƒ“}A¹ìó öÓ¸åνE#™»Geé³80ÚˆØd÷¼‰À2)«óeR ™ZE£HCgr Ö .”÷½‡n¹;¬ Óñ$|²a(¢§ÈK‚‹ºÆ½÷€¥ñGlšboýAt-ßüWS0øÜ5Ã
÷]?¤i:2:üïoT]IlªÀÈHª·2Ó®…×>f_8Bþú b$êŽ|0[Šæ†¶®‚Z°ç¡
+k×~´…ËÙ È©Æ¥Z0ÓJr¡Ž¤ÛÒøœM†?¸(|ßK;š§Áe]O߸K‰L;®<¸t¢ìxBÏ‚^ÄtïÃ<ø¹n»ÑcÛÒ³bÓÙ†K ©zË°pš5;&:ðÍØñ8ž_ø`[:vkÎSW|笠‚ñÜù¢Š‡{‚ÈÚý%MTú´DVWülkiqt¿>:ðÄë+$–®¨â™ÔzÍݱ6Õ|_¶/P<‚]Òìíyë|5AV³¥ ²ReŸ2(÷OZtiÙõ;Ÿ™
gþ»,ï¿Ë¾§‘ü ö—Œ%H„ 5ç&Æ,EʶÀ£7€v IüÀ3–É;xÖÞÝMŒ±¦¯ÕßÄgI%c‰»(XMSÜ,g –³–Â'ÅT÷´ø ÔU'|ªÃž8½V§*“'´QÀå4b
cÙÿ
=¬¢é*Ý
!æüÒmÑ‘Ê_²¨åÚ°}U²]¢ÞO^:LȘ+,þjϵ óâs¢8å lÒ†¬é]¬¡7‡R…R/oŸ€lsç0ºss|>`Û}zôn\þze«žñOîrÛ¯_Ö×}ôÏvukç¢ *pt>
stream
xÚX_oÜÈ
ϧ؜Œz'óO#ɤ×^›¢@
ÄEsyµ³»ºìJ>iÛ÷éK)íÊ‘ w/«‡â òGråj·’«¿¿’üüËõ«7?¥fUˆÂi·ºÞ®”1"sùÊ¥™Ð&]]oV “·ÍÅ:Õir zZ´7¿ø*àÚ&-oj)³µTk©éýÍ9Ù]¨dm$‘ª¶ eÝÔÍîêâÓõ?WJ
›«µR¢HùÈ¿–¡¼ºXkYɦ nž¾ý¨ryIKû)~-ç þØ †cÓ_Ïû[ß\’žÿ¨w{þò_í ¯~<´½_ó®Ùø{¢ÒÌ&ÿ~ÿáݪpŸá¤È'Zþ,Syýß+:æõkxUK"'ï½
¡«o†à{ðÊ™ ræwÄÿ q×ÇÛ¶ eø€jßÑÆë/¾{xÄïͶýÈ~²ßüd²³ ^§¢ÈÌjá$•ñý^¬vÉÖßá"ƒ : }s¡óUFJyw‘%íè=ì=}7ò¤Eæ/øt•:x YNŠ l“tfÙ tÈ×
šT8mF¶P~ŽRYMý³4Æw¬ ëÐ톨/èÕÃÅZ 1ã×ѱ`§äÍ®â6*í›
Ä ÊP1ŠÖ£a:i»zW7å·ÁÌÔ%õH-±‘_ølöºà7âbÉ"ùÐ =}V ʾ.ꉰa9MË‚Y&È,ˆ8(|Ó»ýÅÚätÍݱ 5*or•â
ßѲäúè×›2x¢F5@9'UònK´°/1×ýHÙËÞƒ_
ä"§ŸÓ/ÅùÐû
ì§)8,y õÆoËáàÐTæÉõ> ’¦Éø¤ÃR: W6¹«Ã~ƒŒ^m6wõ=m•
Ö•bÛ•GþúìÊúxjI½¤/lMrÛùÊSH«_ oy¸yÇÁ;ƒ¶ëmtþ×Á÷!Úl1€ðvKÈ>ÞgñpŘ^Há{ Ý QÉFÞh·üqô ‡ë’òßPúïÁ>›+ðjü´GÎW›
™ås+Ë1ߘ¤Ül0·H9}v08ÔË Ãµ ó ñ>sÃþÏ£ÿ±¶¤JEƒ
ÀQ¹â+#gg‘©œ þîC7T¡í–@WY)\fa‘ “秇å«)Å*Qª²¡Eyè[ZMP÷ÇóbÜaSCô†Ã½m;ðg\u%^ù 3ñ‰Ùx@[v‘N@¾óž%øääÆ\—`S5¿ÃÉ=kãT² š
aÅå€Xø„œt$ü«ËC4Æ)ŽJXô”Ü°ºCˆ-Gxq˜p ¡
Çgf*%¿µí²
:Ÿ®q†ó(7Â<+ ¥èk<œç¦ø°3JHõ(lý}åožÖØ„žqú©”K, À‡'Ö¨ ì4-=mj*0‡’¿\°\"Ïí™åß-ÕZ+Ü)™¹*¸â<|µµ"Í
î8|˜šBl€Ô•³ ýC/™pû¡?ãöØ=R:M¢™è—Šš»5ož{UKm×J®•ãþp±Ûš¸2æÒÏråÌežå*˜Ë.•æ‘KKæJŸ“¥s¹g¹4seÏræÊŸå²ÌU<Ë•rÓ«$ß•[Ÿ 6ƒØ⯌ÐÌ•s@»S8áçL”Ö¢8e'W -Q¿Ø¶‘:5P¨w 6VFÆ4±ºÀŠ‚íp8Ðô²PýŽ§†hX]‘«‡–ySvz;«S=ñQ“;Ü„uè=‘£dÛ3a 1@J/ùw–êüKýÝ£\°€¨…y u5Ì
ê1`` NÅf'wŽš. —
§ªRÔå‚ ÇèÝÔÐ)-è턲Ӵ²$ʼntR¥ûC¤Tß2è)“ƒ¡È.Õ8©òìÅBÞßö¿_ÈmW7á)¤/Ó”¢=ÖK‚ŒNš  h9< å^,¥Æ¿~¿U·‡vÑ7Pe‹‰© #j&š«L8gçèRAÍÝ×Bù fãDjqÄ’ØI×܆Y«’cÛ#R B©¯ QKî`pûÓ(¡Â ‡Ö¿ª´ô† >Çi-ÒÎ݈¬ÞÌš»Ñ»¾ô~ N(Î.m÷™g î‹ü=OGUà™`¥¬(ì#½&—&ÐŽê甈»)OytåI7Øš=,6£VX}£¡†âvª›ä’ʳ!¾œU’ñT¬ƒ—ãüáQ<ú7n[y²Í’~¸é}Óû—º¤Å°«°‘>ÁØ q¦pE 3 ôhα<‡,œãGžŸþŠér{ÜË5{6¥|ñ]x÷D";-²y CÆÁðV@vÏGÒ8_c Rtþ
xÀä™ 70í´cßù Ý¿4{¦ÂóíÁKf C 'Å8Ý™'¦»Ìˆâ‹O£‘6Ó8°Å›þ@^A”20÷¤ÐÍÉ‚x³Ïß®_ý™S
endstream
endobj
146 0 obj
<<
/Length 2249
/Filter /FlateDecode
>>
stream
xÚµXK“¤¸¾Ï¯¨›©ˆI˜ƒ#ìY¯ÇnïaÚ‡Ý ]¥êÂKA¨~ü{çK ª¡Ç¯ð )•Je¦2¿L‘n 6éæïRùþþîÝÍ÷¹ÚTIe•ÝÜ 6™ÖIaËÍ‹Dé|s·ßü }>ßnššîaûåïuìH7qV&º,˜÷î趱ª²èÔº~jvõ}+ ûæ—Tk7¸nG”4j:^™üÞ{ø”‘;Ö[ø<5ýÀäþÀçç:8_ei¢ò
ô ó_¦qEIÐ0/çéA~n£¿» 0“ÏMÛ^ Í“úñ±=Q ±Té›X©2)Û³¤Ê-ËeýK G€ÆðUËÊ/©JWŒ°&©ªÜë÷óŠy¢Ôl$Hɶ±¶6ê Yß¡žú!ÙÆFÑ_G¼):n”å]S·¬ ¸ 9mÁ¸©é»÷hèÙ‰~»º»2a_#³Ãm1 Z 4¿nÅI qœ8od¿pʈ[$|¦ tÕ6r/ÓPï&ž€ØšG÷õèö<ì;þ’»hÐœ\Üt{÷‚¶åÚÛ†kM·\½Ì[÷´ë];Š°C c了iß“’é¥z
i¤£†ö™]VDý86÷hkëx™ —R2õ4 Q9EîÑA¯ÌõJΪ‡÷¼ôLS÷ë{^ÝS¿Êá11âñ‹&s'G£>n×wû1!K2såmL@0s‘%IZY ?ÍJ€YˆÀb °< z<û†k•êáá|š³)ä“ÊßW•“sHɉçáɼod@VT‰¶ÿY
€MF9Éúí÷
Æt¨[ Õ;Thç =~aò‰ÕÙ¥ßÈ.°ohvœêO[Àˆº=;ÁˆÃÂÄ#£Ü©$e€^·c¿€H1ƒ¯îPþ±Æ p"ˆ3GÄE«¤Î¬Z^R*7´ >œ»É“ €àë¸#ˆ¬Œ*˜tªÙ vOd?a6¬´î0Å z bÒ–žAoÜÌ!ÛÐéôõ'ŒSÝíëa¡ºÀåŸ>ÿø¡´)D—²ŽnK€
×lWÂ9KˤHu éÇ?ýßÞÆß}ÇþüôéÃí- ևϟ .WŠ‚V‰-‹‹›K#Ì5á ¬ÿ!V ª'Ww£èô:c pœ™,ÑÕÕ}!Òê2çø„ï‚Š0©ùUJ湞Ÿ´Á˜¯w:"tT%#,rÁ·s;7Žc=¼^ q8·-‘,Œæà™Ž”°<ñP%ÚŒkÇøÕ¶àŒ ü|·Å:‡LÔì fé«™èØŸ1b¬=T½Æ2Œz Ù20ç25ŠüÎë,úºæáH ¹" [Óý‡šÓœ]èÀ’F*M ò
UÔPÎ힧-V=pÝs3
CGUÑɺ ¨Kíy/€(Èh蘔<îÔË¥2 ¤Ëšâû:((1×
—<`@CñÄic>!SZbØ¯Ô Ÿ}R©¸ìå‚^¾ –\ [©o\ü0X Ûf×LN@ Ü? ERÍ<ö݃ãWaCé-'=C#ÌÓÑ—]BUA>Êžµâ6Î(FOY`qý/Jq5 WâÊä ŠÕžnˆè¢î›ŒUÚ@.‚è‡É jûè–ÊE¸™ã&®‚–P%V® ¡ ÷‘[¿†- œ¼0!j †m©}º™ú7P
0Ä,eŠ„&€¹ôgÜ°ö`È×çAŸªù<ÖÊ!J%eZzF‰ÁkÌ…ŽwQ "bQ3(Ñ3 Ö¬"¡GÌáº%ø„û9°æ\“˜elönv }OÍ8Ò=s0”:©´]éÜfüÃŽ°À
Ýá›Þبt² ˜‰>½»s«,°ºb îÕ·D<%ãqpFBÞí+IG;Gñw@J·‰~.RÛÖ´üà4*›k‰åZ¼üâÃÑüâÃÉàâÕK; ?R´¸hNM QÓ]= $Îæ]ÔÞàÈK#ðíV>6e°Ò¶ÜK¸1®èôØ
ÏxdŽ§*:z~\à à
ÒkÑK§*&u{U%®«8ÅE©·õ —ö&Dc B_æ|W–¼ÓŸ'¦ù'=ß,wéH?ùÂL
®\öÈ#—n¹T0ÍתFº¤a"ÛE„ñö•«=±FÏ@N5‹j®Ü—”Ú;Ÿ¤vçv’â%fyüÐ – ?Ý 6Þßî©©—xðÏI¿³ð;ÇÇzçàêêOKD2é·
ä9€®—¿½L£¼™l¾êŠ¤*æêñ›©¯*n"ôŠ m›š[З•'^,2bhK ¨˜ñÇGt‘²ÊDŸ°™‹ufªèÏ=D®Ê M>¶ýèäßB™(7_E(L]z#O“2³Ð`À#3 ³Üš|a΋˜‹|-2fÙjf·iìå"P©
¤¥PEæ,æ¼ú¦l½ˆÒ
ØM‚™I+U-³ õÖú›²ÍÌ®+”]è@ZY.²•©Ôb¤Vè@m×Þl³ì|ÙlÑÌà´Ió4\ÖT…̶ð²)Xt’$k-…@L3ñØF]0bȤg¾ü—ágÄZI5XÎû$~¼LW¬è3ø"Nz9þå „Bþß GÖ²uÇÿsÎÞ̱" ZÀ\ýoiË"«úo“ö"ˆ²0±R‰U,É“e…ŸÐ%OƒT€5f~3ø³0±”Æ\ Bš‚² —ƒ5]º*Û¢PveCB0SÖdAR†_%Öµì%±4ä+ B‚™Wë@¶ù`²ÅŒaüÁ,Ë2ø "‹2õMÙ‹b™™IŸå $ñ.«¬ÌÃ"j~ñ¯å,þ„æ_UIYJ –;þp÷k$
endstream
endobj
152 0 obj
<<
/Length 1954
/Filter /FlateDecode
>>
stream
xÚ½ÙŽÛ6ð=_aä¥21¼DJ@Q Wš-
¤@h$(d™¶ÕÈ–#É»ë|}gHêòr>¤O"‡£áÜéb» ‹_^PÿýáúÅë7B/2’)®×›‚h•.T¢ Éâz½x }¿äi´^—]Y òj ®¢»%‹ºÖ»zs Õ•ß ›ÿ¸)×åa‹ $jO«ÖtÝ°ÏãÿÝ™åÇë__¿IÄ„
Î$¬50iØ”MÛ9´·<#"Mz¬ü°báé@©ÊÄ$a‰®;
”µ%ËXJ ] ð—E tˆÎ’EÌɯ ˆx,›²ÃµŠjÐÎÆ-w&_;äÏ.º¼¬ÜjÓÔ{ô §Ìƒ2Ê{ÆN] :°ÏHª=4¦¨÷{sXß1/–`ŸOK`'ßšW U o<{ƪÊìÖ3U7N^¦3p=—·ígÅDD«¼uwð‰‘|ÄÊnWŸ:w
$‹á/¯1 À_Xd·C/Âã¢> ú~ þiàkidŠò²hÝq½± Ó€i¤”QWîýªÜ‡R³¨-÷e•7ýûžZÐÿ«öß°i@9B§½ÒWç€]˜ © ܳٞÀ*¨h ¤ìؾpXÅ •ƒÃæÛmc¶ygÈ—º\¡9Yöx@ i¢”¼0¤ùL~÷ÇÕ_¡€H8áëÉçB!{wPî豑,DT¢-„ô¦ ãÖn˜ûÜ¢#óÉíêûú_d´Î»Ü MÀt ‘€qÏÿwË8LbsÚÐ}žy÷÷]±×¾rTPÉÀ` /Ó7{Âù Kæèß"·÷‰ ÖOžM d!Ë€±µÌ µ€JYêpß ÁKb®¸ŒÞ–Û h†É,ú†ðäŒÒèǪn³ˆN‰Ê)Õ1e1åN€„*2PŠN cºßIà&¡’MÏ r ¢Úb@ç‚zB€ä,M§Ç“3‘!m¥ ¥-'¤v¦¦€ÉŽ+ÉFd!8 õ(ídD×Ð¥ž&;ªÚ…Ì ¥=aL"ºSÀdÇã}§ ŸÑV´GƘ“ÿs¨\l´%¸Q2Ý2 ¹É‡”õ<íãœW¤ &w>°¥l l [ç˜ØÎíe`Û ï6¶ööY í³€¼ÌÂfòdPá4€·ôé d·!˜Oˆ SçÿŸ‚L'é³ÉxŸZççöëå(&8©ú
IJż÷Uh7)f@rù°cBÒdz†Èüá€ÚjD—ì” ÅcÓãù™‹°Çhë#m.€fJ;E)K&È6f^Ï|¢g¸ <2Í„»é
;ì™î‡.ò”Bçë£öÏ]YÙÈ¡}±y¿
ùª¬ 9Åu t“?ò•kâ±@ßØøtûü“ݵÍÜå @aÝUç@_ÄeB=ôÒ·»²Ø…ZVÐ |´¸ï&áÒ¢¸õM·DP6Ï‹gd©>²„†YÞÕ¶/D§³@lbí£ÚïÿÜAî>+۳â2mëS™Û,»n
;Z©"‡èó!üp¨&ýÅýŸž¦Œ6yÑõ÷w»Ü_P¶!Z¹~ö`l?[Úù
“aíÓp>7ˆí-WM]ùüi‡-‹Ñ¸NmÈ““{®—)äeŒSÝó+˜^b Æ1Úh¨€¤ÐÜ©jœù¬§ iPú\éö©· ”½gÛ]ouX‚`=ì€bŸ=|Ó³mÜ¢85±s’ 2LóîâS²÷)ƒ3It½3è*xP Šê´¡,EÒ¡ÿ Úð+S[A=RHzÚLÛž»5ÝBA¶Ï&TìšúâG&ճɜMÞ샄,?ò?úÜ5Ï#Ó„½É‹iúÁ^ÎrÅ–€B•
1N-±TZã±Ë®5z•dàzWƒF‡•D¶õN8º)sîz‚_ü»‡Ûm!†›ÒN¤°3w›À¬ŠžŠ ÿô~×ùÁéå* ü\('Dð)D*5ç“UcŽU^˜~ u§ýCGHåÐ<ŒNmoý6~Ò´~PäøžÅ,g_uN.}BIªÚÚAŽ>u·åÊ2 Yå ÒºlL…ÆB?ŸLsö ¼Y Ìù_vþßÁÎ} ±ÐÚ›;IËSÉ,{"áe„¦ƒ·×à*P"þ1…ÏA‚)’jy™Ý]Éå:‰NMz¸´¼â¢1ÃFWöY †7¨m$”D=¼
uCµ¼´
XÉ'žÇR¢S5'4ôýØ‚ŽÆ³÷Ä~;o¼´¶Lõ•«iA ÷\¤„Ñ‹¸=œ*ß®hm_c Ùz
Ûƒ¹uû©Òí ¾2¹#g~ 5ܤílØj=x Xá°˜§iTäþŠ1â"¾Þ «²ÝùȽ(Ö.ø¸º¯L!ˆ Ÿ„@7¦é® ˆX¥UÙå›cpîÉ2’àÃË´÷s³ØôýÃ>Ì>ÐËÓ9÷죣òêËÀÕô‰K{±bƒ˜³w˜ðÔ¥9yõÙCɬZΧ›YæyÖtóЄÃ!´¡ŸÃ£r</q+ý¶³Ú^Ò/S…ʈ€t c¤B…´³Ù ?_¿øtbÁô
endstream
endobj
158 0 obj
<<
/Length 1737
/Filter /FlateDecode
>>
stream
xÚ½ËnÜ6ðî¯Ð©•#Š)H‹é+uÑC ´–ö*ÖÃ¥Øû÷áÚ]Wn{*t 9 ÍûÅ4ºÒèû³Ô¯¯/Ï^\YT±Jf2º¼‰¸LÉ2’…b™(¢Ëmô1þ¹ ¦©éoÏ?]¾{q!Ô~%¼d¢T„y¹3çIžñlÝFÆÃ
¦¦3ɵ¶fKç¦ßšGc é¡™vMOä q,Ž„=¯€#ÿ8ÙxÅTV ݶÃyVÆžöÍ9‡‘öÚÚ¹»Ÿš¡·^ªÖëó~ñ²wzk
ªV1™ç°á¬*$1Í ·hŽDi<¡Ê¸yLôcciZãz–³ ÈV¹³ÍŠ†éË =þ°¢b–³<©3Ónpo‰M§ïPeã¹;ã ‹1³æS\þ«q¹ÊÎÍÜ×h¾j‰HK–fܡŽ~¼lê;ûz þ_!/«ÔâßÍyRp?ìšõÙᔊwf ;55¸vO fkzĘš«Tä.Œ jçó„ÇͤÁå׸mÑ£JÐSñ]§Ç;BmÑ~*®u€Ý@˜8·{¡N¹ ÏÑ9^äñmóŽǣˆ5-ÇqŽXRñgSOÌQç9«–òÄß™5“f%“‚/íLù¼% ÕÅ’ˆYÅc´Š‚{Ì2Ú5ÁÕ'ì”`|‰± ÝÆ‚§O8å9SbAÔãíÜyoukü³ ׫4Kõ<
°rp±H—ˆŒ’,S,…òqbÑعE"à;§ ¬š–/èH0&¦4ž1Äqµ3øýãO>ƒEçd! Ê i)| `Šf2þ©7þíÔ <ƒ{ªusã™ ÒSማ5è+‹˜`ƒ!K@´®”¯ËÜîý P¬(Öà i YÁc ñQדÁÈ·ylq?pl`{KàÀ…
Sè1„@1nÐTâ…|Á;JGŒhŒpŠu¯èØ ŠfÀ@k==™‡´zæc°zÒOà”y[~ É“§Uä*-Ò”ÔÓØ<þUkCH!b_Y™žT1Á ÅCÌ~½Â¹`Y¶¤O7ôÓήœ Uüg: +_«•ÐZdv’™yI¸ï0æP‘4»â"ï³4UÈã síoøÉMÿ ÇÕ›<~u?>ûÏþé
XÓ_¾›û¿ÿ†1ó@ñ´¸s@U*mD\T R¥NŠ2æíª˜“%¢dÒÂV¤§ls¨2{¶LWªRPmú
㻌mÓÝ·.ú¡v<êp(©AÐçFéú¯/ñ íN·Í„ñ»'02!ÌèJ<üsÈZ$äF €¶Úm»Ðse…~¡yc|˜ÐQvÀâDYæµ°>“4ò$iP—+K¢€›?nø§M§?#sù²š,J±COþßreÓ5ý"ÖÅ«÷¿¾Ù€Ànú—?þöþý¦ Ú—"$ÔÙ›Ë3ìŒiÄaH,¡qUQ¦DTwgžÁ<êfÆ4:ìÜEøÃ^¼íxôÝpö |á* ÔOŽfd‘²ã!9Ë Æ¹÷›`Š.Ã0Ú9]…º ›kvsKÅY·ÌãºÕx´–po%uÌ/Ks–¥Ë 0øɆ~"ä@!“µFÌÍ Ç´Nó)“’I¥ü€ï굋s÷æà ö˜ ÃL1Þé% äa®ÆCC-¢ÚN”;æV×»†ÎcRZÊ–Êͦrš‘KÚÝM?ƒ˜í†L©ûíZ~=8aáõ<‰¶(£|û‚µéëa¼wSâ0R#Cèn. WÓRÏã¸LB ^ã Ô‹‚ %‡AHÒîzö¨ýà7Î˜Æ …n÷k=yi²C×9™D¾Àf?7/.¬æ±nggc?´Â Tæñóé[ô@Y’¦0>
/ExtGState <<
>>/ColorSpace <<
/sRGB 163 0 R
>>>>
/Length 3078
/Filter /FlateDecode
>>
stream
xœ½šI¯ ·…÷÷Wôòi!Šó°´
;€ H$ à űB[ˆ-Aþ}jêÛ§„öp_€,,é˜_÷%Ù,Éô½ÞÒöaûùöêÓ_ÿôåöý§[
1Æ
ÿüôýÇ[Üâ6r$½•.ýòÃöãí/ÛÏ[naåÅ0ÆÖû ©oyP
#Û>Þ¾|w¾=†LÏâŸüöWßdªÆ» ·Ä¿¸Åû ª[顧Tz‚°Ÿ¶'zp¼ŒéeÌÛ«MEYâ‹í݇Û×ï¸Zö“_½½øÉ·_ý™þïhÛ¿oß~G
ûÇ-m¯é¿·$¿úæFéc+3̹ýDZÜ •û¶½ý¬\UÍÜZ\CÊg±(, ¡Í³Xwjt=\×P×Y,
‹GXí,Å#…ïŪ°¸†ÙÏbQX[iÒ=Œ€HJä ¾* PB‡fªtÀ:J%Æí & P‚fªtÀ:J%‘ š©Ò5è(•aÂxP‰ Åe†fªt@
:J¥h®„ñ ŠÎÍTé€"t”JÌÐ ™*˜Y¦ôPé€*Œ•˜<ýŸ€H(R t”J´0a<¨tÀ
:J% ™¢uœ eÒ&~ D:`…Þ ‰@*!ãÁ¤zh ‘pö<;ʤJ¨ ‘èa D"@ÑZÎñ`Ò%Lh¦JP↎R‰ Eë8ǃIÔ¡™* 00wšD ¥ ™* P1štÀÄ jŠÖÍT逊YÔ¤f¨0 T"@Ñ:¡™* Ð0—štÀ š©ŠVȧ& Ð0£štÀ
š©ŠVȪ& ÐC„ñ Ò+4h¦J
E+$V“è¡ D:`ab5‰ E+$V“èaF D"@Ñ
‰Õ¤J ‘!A3U"@Ñ
‰Õ¤jˆÐL•˜XM"@Ñ
‰Õ¤h5 ÍT选Õ$å & @kJh¦JLL¬& h ÐL•h˜XM:`bb5‰À Õ%4S¥&V“ &Œ•P´Vh¦J4L¬& @»h¦J(Z!±št åA* °x›t"¨±`b5é Úºu D"@[.Ø+™t@ÁÄjÒ´Â, ˆD€¢«IÐ
³ ÒwM& h…ÄjÒ´ÂL ˆtÀÀ½“IjÂÄjÒ5th¦JLL¬& hmçx0逆»(“˜˜XM"@Ѻ`<¨t@Ãm”ILL¬& h-ÐL•h˜XM:€V˜0 T"@Ñ
Û(“è˜XM:`É‘Æ ‰À*¸2逎‰Õ¤VXÐL• 4ŠVH¬& @yp ŠVØF™t@ÁÄjÒ#ä€H(ZaeÒ«IÐ
š©’0±št 0+ " 0qeŠVH¬& @+Ì€HLL¬& h…ÄjÒ
·Q& 01±šD S „ñ Ò
·Q& °0±šD€¢µA3U: cb5逅‰Õ$°2逎‰Õ¤h… ãA%°2逎‰Õ$ =ÊYç˜t@ÁÄjÒ«I(ZaeÒ«I w©ŠV<ŒT逊‰Õ¤ HšD€¢«ITL¬& 0qeŠVH¬& ÐðhÒ¤&n£L"Ð2&V“hx>iÒ«I(Z!±št@Ãm”I,L¬&]¾øíSóÄ#ð~æ~u†^
'R…/è ¸>' àz'Àõb€ëé
€ë.àï#~æ}¨ÛÒø€…³^eçãÛ§×/HmOï?n1¿øn{÷š
þ™ßyÏâ ÊâEÄa nÉï?œ¨´"†Z|ó‚öÙÛÓßbz |–KÁõÌjdê Zûß«ñôæý/üûü´ã¥lñÌŸ/Tù½ðôÅ? ûyÞ.§g„JÓÊHø޼ׯðŸÇ>B¥X£|õÌj4¶³Öňü×ÇǪÑÚàé3«Ñ©4]V£ÄªÁ3eþ•1qÚ›%'®¬ù›” û:ìÍ_ó@Gâ÷nd§Õ'þùGÝÈ+×ñ>˘†™7
žV€P
D.â)Ý Ó8{G9ˆ8ç2ÕB°ú¿Oh²‘IQ’(wxD>ÜÅ‘‡×£ó¡÷Òømñч âV»=ø¶˜Tág6úxúy¶§ŸÙl{ú²Ýÿ¯ÿÙA¯ È€¼2³±üÊÆòkCÕ—^¤#.móz“’]¤á¥=mMw»8ÃC;±Ô«1YÿÚíbL¦†Ñ_»]„É´jâ,is¿¹s©^máüdz‹-ì˜6~•^]Éyòô´ÛÅ•L•« ëÕ”Lµ‘R½Š’{ç©a·I'Á]³ÛÅ–…a»YÂ^\¢å" ˆ)‰–{#¹ë â¸5’Û:´dl¶M¥Ñ6geúJIÞ¯w>¤»h¹â‘yíÊ}f7:¸-Qx½À‘kçϺ ×7x‚¡¿ ·5²ºMû1!²ù<µ\._° ¢õ®E®I;Ööm²;“çõ&E¦ÝåöëÅ ®ÿ’úè= î,Ïë|ši)³äy½‘g±ßÓKÌëózÇíTí ½Ò—œ¸íÇ…†L_XÛ«Xgé3}Å´DËuÖSµÜ>` S¾çq÷@ý~Õ E
ÇÍJ ò=Ž‹¼„”çm®×õå~¿&7c?nðºE‹ëŸ§ Æì‡çÏά|óôóœ:üÌÂgÝDkæÈ«r7î‡_ÏãQ¢Æüx1“…×mu^ Á¢ÅmÏãh¯šë\ ùžæ¥çž×<”[áxÛã\^#íQcœÃt©n‰‰‡É~¸à¬‹”«ËsÖ86S;Ó´”¤?4«å\y¹³ 6ws–þQ‡:ªß× é §öŸùÏü™¥>f7ç8ø³ì‡ÙœæQ®92Ó÷ªÅ;æÏÞ¸?Ì*αh|›3œÖÔx0#˜‡aæúšïËaQºh <K}Ÿf\ki¿™¸)GíólOÓÒ µheã-ïWG6Ñ÷(òûjÀòâRú×NIÍfò},'š–Ô_ÝÔ4dØ쇗Êa•äýê•&¯]xµF9¬ª–‹šuA¹ >(‡>¯«îÿ&íS[Sú_ÊÕÅÌ4í5y¿š–¬e|™GÉß[âÍ,I.—ö›ÉZêgk Ö2™›¿Èa&í3;1vûa&rXIÿšYÈa+ñcÞ UH|™˜[çaµ N R3ú2=¦õU_/§ÉÓÊ~¸z9ËÑÓ~˜x2-¯& ÷ŸäóäÅ«ÖW×=iØ|e‡\Iý¤ýðÛ2mMd¾7?¿Ï”ßWûŒÇ³ô¯¹e<-vé 5ÇÍŸO¶Š’iQÞ§ÖOËKË¥ã™_R®IM¦Õý°µx5
x!oÖ¥/=Ûe¨† ½¹È¢Pÿ)[I4Úa?Kþ,v´ÏS–¼JòiªŒò»zlÏ™L¨+húrÚ@=’§yTâÎàÇÒ´bÇíÔ½2+ØáúŒšTl©=³¶WÚçVüeí½KšIëY gO·ÿ£àpI
endstream
endobj
2 0 obj
<<
/Type /ObjStm
/N 100
/First 812
/Length 2127
/Filter /FlateDecode
>>
stream
xÚÅZ]oÛÈ}ׯ˜·Æ;š;ß dãf ‹,lhëøA–¹‰ºŽèÊT›Í¯ï¹¤E‘")ɲ„G ÎÜ9÷Ü3 — %œ0JxAŠDd¿„v(ŒÐõV˜„AXcEá pÞŒ´>F´A£Ò‹„&:‰ä%e¢@kRÁîl,îʈû(È',FrÞ¬äFq‹´°:ÁªÅØÉaX "ï1<Ê„# %߇
DÀ£ÂÈk”¨÷À
]µAx´” H½%ÔEPÂh£E @† ü ÝÛ0
à! _ ö‚VÁ8CÖ
ed‚”IX•ÀŸõ% œ.Å„ÒÀãFÑ
G4:¸¤´ˆìúcç`$!2ÌCbÑ?¡}@ Ð=Z#@»‹hK
®)E#R¾ØSQx
z¨¼†k3Þ (!˜ðŒnLÌPäôòpŽ=Ü x;B îËX³UÄÄGV„†±dQÃmRäÐR*HƒO
YP)
Ϻ3 ~bŠÕ#Œ,œ†¹à¸á `• à5×ÀJ`»Lka±„ãqHˆ AMQ:A6‘@+17 jðÈ”¢ˆVs‹ Ü êŽC€à 8&Ç@¬ ºŠäSô£7oÄøRŒÎ¯r1>¯ ³i1Ëç’ÎÄ?Ž^}2Áã_ø¤”úÀ—9_
¾,ø’óåŽ/K¾L맳úéülpÝ äŠ/_ø’ñ哲ŠËÇö°ƒ-ëNåð¿5k¾Õ] {P-ok`ƒþ—ÿTCZž4o¾×ƒçÍêYÍߪfíg~¦ º5
mÇfV1«‰›ô…jˆ™'¦ àoõØk÷>7¡ý þPC+Aþ^ß~ÞMé Ú»¶46¼î½k·štôtË—Õ§m?^wDQVË-.Oj w‡HÕÿ”/î²EéºÿeüaüîšÊ¦cZˆk¤#2 »MAdš´ŒÈ¶œòÒ%‡voÅöƒÿqa'#qæJi 2F+}ÜŠB … eêm@Bà|Z$wH«QOý0º©Àq±€‰¤ÓÛ$ Jë•D:¼‹>Att”Ê&¡ mk"x²[ÃcN@ y©’Æ™X$ÚËwRbN Ì…ùAŬ·de2»¡œ@µ&A€ ÃÄ(M2-S؃•DÈD@áOÉ€ h$¥ÝXìñEk èàwyNA¬^Ÿ$Ñö5Åž€ ¡D~·ÑŽqA’ÝI‰=…h±Ò*`0^†Lçdwc9Ášb°áXlÈFE¬)šßAJ]îÂÃáq' ³Åbc×VaßcX¬–Ù"<ØÞ~Hò«G’4C»`÷pwÔðh,8iÉ`ÍÕ!€'¿5<þ%0” í :ž¼„ 9EÀ!¬q¼Übƒ‹ý*™ÎŠL^ ƒ…lù– “Qóö
€‰¼ÆŽì‡1Ùb–= “
%=¿p¶¼¼B XC<~i+£a$‹¯Y±˜MÅ(‡!k$<‹6»‘|Ïó&ˆÆ9þïÿø§(Uçù[„“Ê‹ùòþþf°©)›zuÊا3<±ô^mYyÞºvÛ÷È)J¿ÞcƒMú)±J$óôÛ‘Hnõ[‹äW¿H«„Å‘ª fÇ¿.òéeJ‘¸œ¿ã«ì[±yºßÈhH…Í”†¿u ”Óðg“åÅù‡… ‘Oð^kº]MkX)Œ/'óâk~·¡þ¼³—<¡©émÓ^~J/âL‡w¢çðÞpŒôq ;Ø—®†È ê‹ß{o´Ý>‰{#-•Þèý[C2lNã¡Æ»‹ó´_c^|ÚÓ2Ã8q١ȶV
þ(™:KEK¿¸áï„juƒ-@SŸäëèP•è®Jô¡*Ñ/›Ê-÷_,C]ÇÒŽµ¿üÛmwÈ¿¯±ã•'Õýë Mô/Ó]SPòknvü™Û®nøã÷jݼL‘¦ó:?‚ï8 V:‘‹Ïˆ\ìY^b’1˜ýkd¢:
)úÌ6É
Æ¡ÌZßaÖÚg1Û8VXsÌc… ^òÿ{p|÷N˜hÊ·bŽÏàYty¬øpùqóDaÝþ1o·]ÍÖ„ÙJƒal„k£Èñ'ˆÓ0:uèq´?Yí¶O[jPÒhý‚³Ú0AÇØß\ì’å!ëÝ"›pö{>)2ñêüµVHß8qü¿±Î`.¿|v5+îñäBü¼˜<|A¢&>.‹‡eqV:u·œf ~jË×AOcå\uÆÃÿ‰tŠ
endstream
endobj
166 0 obj
<<
/Alternate /DeviceRGB
/N 3
/Length 2596
/Filter /FlateDecode
>>
stream
xœ–wTSهϽ7½P’Š”ÐkhRH
½H‘.*1 JÀ "6DTpDQ‘¦2(à€£C‘±"Š…Q±ëDÔqp–Idß¼yïÍ›ß ÷~kŸ½ÏÝgï}Öº üƒÂLX € ¡Xáçň‹g` ð l àp³³BøF™|ØŒl™ø½º ùû*Ó?ŒÁ ÿŸ”¹Y"1 P˜ŒçòøÙ\É8=Wœ%·Oɘ¶4MÎ0JÎ"Y‚2V“sò,[|ö™e9ó2„<ËsÎâeðäÜ'ã9¾Œ‘`çø¹2¾&cƒtI†@Æoä±|N6 (’Ü.æsSdl-c’(2‚-ãy àHÉ_ðÒ/XÌÏËÅÎÌZ.$§ˆ&\S†“‹áÏÏMç‹ÅÌ07#â1Ø™Y ár fÏüYym²";Ø8980m-m¾(Ô]ü›’÷v–^„îD øÃöW~™
°¦eµÙú‡mi ]ëP»ý‡Í`/ Š²¾u}q º|^RÄâ,g+«ÜÜ\KŸk)/èïúŸC_|ÏR¾Ýïåaxó“8’t1C^7nfz¦DÄÈÎâpù 柇ø þu ü$¾ˆ/”ED˦L L–µ[Ȉ™B†@øŸšøÃþ¤Ù¹–‰ÚøЖX¥!@~ (* {d+Ðï} ÆGùÍ‹Ñ™˜ûÏ‚þ}W¸LþÈ$ŽcGD2¸QÎìšüZ4 E@ê@èÀ¶À¸ àA(ˆq`1à‚D €µ ”‚`'¨u 4ƒ6ptcà48.Ë`ÜR0ž€)ð
Ì@„…ÈR‡t CÈ ²…XäCP ”%CBH@ë R¨ ª†ê¡fè[è(tº
C· Qhúz#0 ¦ÁZ°l³`O8Ž„ÁÉð28 .‚·À•p|î„O×àX
?§€:¢‹0ÂFB‘x$ !«¤i@Ú ¤ ¹ŠH‘§È[EE1PL” Ê …⢖¡V¡6£ªQP¨>ÔUÔ(j
õMFk¢ÍÑÎè t,:‹.FW ›Ð è³èô8úƒ¡cŒ1ŽL &³³³ÓŽ9…ÆŒa¦±X¬:Ö ëŠ
År°bl1¶
{{{;Ž}ƒ#âtp¶8_\¡8áú"ãEy‹.,ÖXœ¾øøÅ%œ%Gщ1‰-‰ï9¡œÎôÒ€¥µK§¸lî.îžoo’ïÊ/çO$¹&•'=JvMÞž<™âžR‘òTÀT ž§ú§Ö¥¾N MÛŸö)=&½=—‘˜qTH¦ û2µ3ó2‡³Ì³Š³¤Ëœ—í\6%
5eCÙ‹²»Å4ÙÏÔ€ÄD²^2šã–S“ó&7:÷Hžrž0o`¹ÙòMË'ò}ó¿^ZÁ]Ñ[ [°¶`t¥çÊúUЪ¥«zWë¯.Z=¾Æo͵„µik(´.,/|¹.f]O‘VÑš¢±õ~ë[‹ŠEÅ76¸l¨ÛˆÚ(Ø8¸iM Kx%KK+Jßoæn¾ø•ÍW•_}Ú’´e°Ì¡lÏVÌVáÖëÛÜ· (W.Ï/ Û ²½scGÉŽ—;—ì¼PaWQ·‹°K²KZ\Ù]ePµµê}uJõHWM{fí¦Ú×»y»¯ìñØÓV§UWZ÷n¯`ïÍz¿úΣ†Š}˜}9û 6F7öÍúº¹I£©´éÃ~á~éˆ}ÍŽÍÍ-š-ep«¤uò`ÂÁËßxÓÝÆl«o§·— ‡$‡ ›øíõÃA‡{°Ž´}gø]mµ£¤ê\Þ9Õ•Ò%íŽë >x´·Ç¥§ã{Ëï÷ Ó=Vs\åx٠‰¢ŸN柜>•uêééäÓc½Kz=s/¼oðlÐÙóç|Ïé÷ì?yÞõü± ÎŽ^d]ìºäp©sÀ~ ãû : ;‡ ‡º/;]îž7|âŠû•ÓW½¯ž»píÒÈü‘áëQ×oÞH¸!½É»ùèVúç·snÏÜYs}·äžÒ½Šûš÷~4ý±]ê =>ê=:ð`Áƒ;cܱ'?eÿô~¼è!ùaÅ„ÎDó#ÛGÇ&}'/?^øxüIÖ“™§Å?+ÿ\ûÌäÙw¿xü20;5þ\ôüÓ¯›_¨¿ØÿÒîeïtØôýW¯f^—¼Qsà-ëmÿ»˜w3¹ï±ï+?˜~èùôñOŸ~÷„óû
endstream
endobj
170 0 obj
<<
/Length 1716
/Filter /FlateDecode
>>
stream
xÚÅXYsÛ6~÷¯Ð¤¡:B?t&GtÚ&“ú¡SÇÓ¡(HbL‘* Æö¿ï.¤I›nÒéåa¹X ‹Ýo8\ìáâÛ“Ð/ÎOž}#ù"gy“Åùv ÁÒ$[$2e\ÈÅùfq¼eøNÁoT¶ÍRðà#þ(m«f·\‰Le]£ }
Š‚®¨ëÛeœ-/Ï¿‡cÄø˜$ga–€î Ü^0 ®zÉU”1‘¥$ÿÕr%¹ ¾ ¡3NÉãàÆš•±·µ¢Ó²ÖOË`Ó*ÓÐ)I8V'˳^§3ŠHÆyÞ XÚîºÕWDYÜùMÛ¬@Ï\P¥u·õsÁâ4"b¹L&÷0ÅáX«ß…ÕÕÍÅŒ~™`I’|¶z< ÓU˜Ìl$–„ñgot9ãºU$B–òl±âp“È{ä"º¤»üô|fÓÐ gsîL},‘mKÌÁˆ=£3Þ§¶:¨Õº `µyàf´uè,§F¶q\{#…V‡]Ã#¾çŒ Å ‹#ù?X 5šõ@¥±QŸ7÷,Gð#³¶~Òë¶
#ú~6fƒ1’•¯Ø¢jÀ¦.~QÈbPubÙW…-Ζ+ æ9„V·îÃîB„§DÅ—xØ¿lëîИ3’ysTÍ)©ù]µÛû•?´×žzY·àûǾn6ê6‰doßüüú—ÒžºÑzxT¢¿Ï=£Sž<všlü% kŸ©&`Ý);k««]Õµ7%¢Ì/’Áº(¯>
SŽG,l0í§ûÓÙ?‹ØÇP 儉è¿mö7A+ÿ-ÐÊà-hÿ¹¸•ÜŠtdÚ˜ÅX!dž=ßW`ÑXFÁ¦z
¡´û ƒ. 3µ´æ@‰]ù/š¤<ŒÂÞ”üH Ch³˜?¶ýÚ‚:^ûu®> JûÙŠ:’ͼúiÿ&DÒR)„Éþ¸¢Xƒj·ž
€l5Ñ£›ºÀ º)!ÁNdMÄ.ÛQ¬cT!ÓùFÓ#¯uaÏîp-4¾½‘x÷íÉâ Æ~š^åp§>©ñé#jœ_)z…ƒ¦Ã3üºÂj‚Ô#y!„¤{—|ÒÍ$“â^—ô nÇ>ðÚêJ5×3ÀWÕâmQ*b9ËÃèÌMÚÇ“Wä¤øÁK‰EOö<“› yè:*þRľoðŠa†++ë¦dP
¯ïŒ… Ï4!‘ë0»WuáAȬ”àsÑÃí^$&ÄL¯Õ»?«,ÐÞמ!."È
O
q„¤áàä*³;ÝÏ`Láx(®|ËÄs*ÃÈ…´s;•7'Ä)|.ŽB¸{|ïî£.ç©+éɤmrßP4‘Ø-ÈOC'ú¢ò‡Tå—7g@ÙAÓyp5E[‡8¢M1ûaZ=–q±ã¸kâ°-9BûQ•]]hšuî`ÓhŠ’„e)þ) Þ ´_M¤¾>?ù>äc
endstream
endobj
175 0 obj
<<
/Length 1609
/Filter /FlateDecode
>>
stream
xÚXKsÛ6¾çWhÒC¨©ÅàKÌ´i§I'žjß’ ` ²Ñð¡P ç×w_ I…nÒN6Åb±» %«›U²úíI"ß_®ž<•ëUW….VW‡•JÓ¸,¶«"/cæ««ýêMô‡õÞµ7ëMºM£O~àÁíz£"ÓîkËs+ƒ½õÆÕËõ»«ßA|:Ÿqžoápü§ÝÕf˜1-'Œ›À¹QÛ8Ý–Ìÿú '$¹ •ÑáÔî¼ëZ&߯õ6êN<é-ê÷a¢“ë…}ß7Àbfi;σƼÇÂu,“»Ã‚ Z%q¦FúGMH«¸ÈòÀçZ<ÁÛ¾5u}¿7]À!JEnÔîY…Á»ºF™«Î“8)Rp„Š«¼`i×lü/«èH“nÜu-$ßñ·¶ ŽRv )ò‘ìíe¢È«`ÍÒº8¶á®±›k3XÙÔ6yýewž ‡N8e_¼ÞdºŒ® jhR"¶ºvæá@ƒÎH³èÖRÈÒ4rýmXãà‰ÎÍñ\Œ´gboý©oížÐ7ýüûüU¡¦¡*â-¹HZÔz žÉ8 /BtÔþ4 ýiBÑ)):0m´®Xm ¦‘QmÛËlf8c{›¤YOabú›Sc!2e$Šð”?\…øL陡ÖnW\eÿÁ΀âvÁ§htì÷‘8ÙÉ=ëwÌËf‡;ßÏ7¡ä;ÄQ=œ…ytNfŽ û‘Aì f ;¹ —®9Öx•¶Et×›ãQ²W’Ô,sÀLÐ µœàhá&„õK CME”]zgx ü²)ò*Î u}5ÙeQòÑÇwxõIjo‡S-fê
øÓj~u\+^iÙgÆ{Û ÅUÁÉ“`̼žwE òÇ“ŸaÂ:º‹Í¬&ÚÃuÖ ¤DÒé'¸”:>óç‡L;ðY÷6ÉõB%—÷Cü«ñ ð§¾G*–„HüŽ?WCÅq†Éì#$©WÐ`ü™
¹»Æ A §¢¥< ÔÝ`ƒ ´–•eEÚ´GÔB> ¦Öf¢#\ðJk4/˜x†”3^¹F¹´½³\IÏ¿ô¦“~äN¥—X_[ õ¢§_õöÃɶ»û;³æ1d™9ûõn´. 2ö@²)q: „Yf˜uœ, m#:,À¢Ä¡ø6 º?õÃÓoFµ`ð4PBAÝåV_œ#h bu³#ÜkÛ„{÷ïP%GáÒ?ìÛ mT²QE Îø@*§$˜oÏæ+æ:™¯¸æsÊÀ„B[$ÙÜbO¦ªŠÑ#£b meD ’ïØ„(=. O¿°Pgg檧FUÔ¨Ê#ð Ûÿ_|”ž.
•A ?;L:¬ó:„å¥øz‚†µJƆuR S-m˜’Æ”H†)×ÔÀÂÀ~:J¡q¡Bpv}!ìížRß`Çr·q-Uj<£9öÝC/È-óºã/Ë^]26¢Ø[B• iÔ{fÔÜ£
wé–Ÿ
_t?â%*彫¬,ÜÝÚö±šLä‡ÇuÁ äÕ|;Ó> u]˜Ý9‰›F€M±bUu@do·¢xŠ·S)€äÏkˆ¹qïPƒñ,óÙÀæØ@%—ЖÈÓN û5+ Þ³Lž‘ü’Í0ØuýÄUÚe#Æñµ³pcªX—iàñÜ¡r"yòî! Pnk'Kˆæ‚úÈ^T2aÐt4Ê©GïPt&y~.S BÀVZÇ¥:«¨,+ËâÔrÖ'n´‰‚ß"ú„" “{2y¿Ò‹gì,XFÔãKdgÙ@} °ì©¹'âCåh'p žƒ—öÆ^‚ûál /v"]#v“x× ¤ÛÉëŽåudÛെ½¸¯ïšiÜt ïxð™›Å,‰P?¼T>œLë›n¿Ônçð€× ,àIÇYª¿§¢˜Â ü” ú»±{¨—zþˆg—N›õL~{à[ÞÈ͇ð8ið;ÄdŠã±v;C›¿ùVª€7QY@A‚Q„:¦gL/¯žü
ž°|Š
endstream
endobj
181 0 obj
<<
/Length 1730
/Filter /FlateDecode
>>
stream
xÚÍ]Û6콿"À æ ‹«OËzØ€®[W Ýnì¡-_¢$Þ%öÍvz½ýú‘"•89_Q @±'QMñ›”Ål3³_ž ^¼~öü•U3ŸûB³ëõLj»¢œÖåJÛÙõjö6{Yí–‡]5„ùB—:»ƒEe¡«Û¬êe=Ìx˜¿¿þõù+íFüÄl!Ë\—Ž8]oY="R"·@!ˆæ9G¦S ‘{kíúÐ,‡ºm@c³»®«2ûP¯BO˜
“ýs¨—xrKØþ°ßWÝ“ôD3´´ ¶€C³
Ýî¡n6D j‹°@¡f‹RæÖHÐN‚<I-4d ðŠÒfíšÖ}Û
õ>,zP4
ˆ]}‹ þàf¾°EöwX} ÷Ù ]
2×;fYÑrßUw,WÇœÛ){™¡“ÕVõzL˜×ؼ ÷3!h•ÕÚåÂ%m9*.¬MJë3köjVt¼l›eÝž| ›h X æÊeí¡£Ýªªœµñ1å!¦HŒ À>ÊŽ£æ°b_
s ùø×Ç¡„œ°
ðQ¢œ½÷S{Á &[w힎”n!äB(ÚcØ0 .„£b¡_¦..³¹sl¼Wu´
dShV”PmÝ`
1"LvC)ižpVJ.¶Ä‹¦…àq ÀØû}Ì‹Rfuß ¡ïëaKÐEÊhn:ª{^W¡AGõšÓ ¿‹ùô$8 £àHÕ®À°çñÒ…žCu Y`LmWÂÜÖWëîŒØš©P\›° } cÆwüø¦ Õ-¤Aü†$j‰t‹!%³Ý|!³"h;ZÑFH¹Ý=œÉÌ1Á|B÷an!év¨¢%ÁµuÙrTaÛ·û
ÕP÷C½Äì•&{Áèz· ÇowM§¬6¹÷>e"ì 6~ Vä…´‰²}'´]O¼+˜RÒAJÆ|V%¤¹4çþù0'ß iT LJ\YõÆ îûC=T7¨îÖ‰¼?Üôabœà¾¢}xÚÜ sð3ØÅ@ŠÿÞÌgØVC‚Š˜®glØ…=F#˜k*¸0X°füºö;*7÷[*C[:©¹H ú°"Lô"Ö™°«›@^‚áأ̸1EnäØ ž6WN%š©Ú +óÂË©vô1°®† 컶ùž˜â¬Y[°À±q~;q ¤ŽBC°Û~‚‘–¹vö³ù2ÉÚÖ2P(>*qöŽÝ! R& ¤&)•¥òBºžåç[%Þ3¹V ðü)’Ï5Er~‘®u†‰ËÏè®/·U³ù‚i•óòªA Êó|’z x’Ôᦆâ:´‡žN*q2‹D(Ÿz,@56£†`,tMÕ,™9U*‘]½~óòì3Àa`_1ëfñºÞlSåðM Íî/wm 0Ú ÞzaíµtÔVG븽–Ü^a¥JæŒø-(„c»^̼xŒ}º€»s™Þ¥ÌØ=:Î §Åªëã4›.0+åPœ•
Õq^†ãnFSDs'pǦ *ñžg}Xï#p›>nùºñT !”Oò˜sÙ·! µL‰>´9Í’Óm[—ÇfÁS²†1
™Ó|ïh¾LzñôÜÕ†óîÆ#øqÐ ætžÓú¿œlK
˜ÔS]é¨Âãš:UPá-§þG IxZ^Ô¨DÔ ¿ºÃtÀº2BbV‘î#ä›öþaÌ..y.·ê┞
%Œ> í]yÜ‚%¡hi
õOP؇ǷHàà* WÊýD¶s~=1Wʘã›i®aŒTÌ ¤—Bž˜;'¼œŠmb®Ï$/emf$9cHòík’ä°õÎxñ´äŸIÄ
‰îŒ9<9Kyb^
튘CŒ‚ÍÓÌíIr$6Ö©ã™^`?#æà9é|‘˜ÃWBòb$9£Ì 2÷Fªs0±1#æ…ƒçé¦øÔ«r;Ëy:>‹¥ÎÅidýªÉøTBBˆæ¥UçÓÛoxñ£·7h:0îñó[Ë‹ç7PŸ¼ó¹æý†–%ö·Øx0Ác‡C4<ÑÃÇókF=*Ö‚¶cZ(ÓPf»[ÌDäœjéžtMÞ±ÏÿQ ÿÍ]>-àýQºÔðy™ ÇŸü|ýì?Éõð¹
endstream
endobj
189 0 obj
<<
/Length 1453
/Filter /FlateDecode
>>
stream
xÚíXKÛ6¾çWèEÖ
") R m³mƒ4éÁE $AÁµi[©,9¢´Ùô×wÈ!eÉÖ&zíeù~Ùùf4^²Ø/ÈâÇ'$ŒßŸ<½|Q¤…dr±Þ-hNÒœ/¤P)ãb±Þ.Þ&GݵåßMßœL½\ &’ã’&çýŸÊý!ìŸ7_5Ÿæd¿¯k–ï×/«L¥D²ÅŠÒ´AÛK 40BÔr•Ñ¢HI /Tî—¹[*Ź\®¸TY’©’œ¸SÅ2wʘ a§‚LÁoÍÝ 8cY6€Ó”3ž± §´ „žÁ•"ÿE·sà9•Œœ_ –øò ¼,³ørX*+È øóÓ5¸“ϲ°ôàœ«œžÁsqàœü\Æ—¾ùL(Àa) R¨®RAU!#¸J¨ž}ùËþ: N>Ëø ®ÀÊFààâ,KE þô–«]AU4GUëƒA¡ §XQõ2]“ ›º;TŸgð„H3RDÑO>–+–'œÏ)Otß5Àðr£+¸ï·Zó±7¶³¸êºs33º¾ÍW# L>˜M‡½÷îOÈ
%R™O}èr¢—”õÖ<Eû|^@Ç3
s¯k:œ és íÀ^˜¬–tr·O&CdÊ£ÁÙe‚¸Ò'TKŸz¬ô1èš` IzrÛ£u ˜UŸZª¥.ÐÆ£³Þ=ßy 0«cˆ Œ ûÒ;HhËã©2ža š¹Ö`ªÁ} AwžìšªÂOˆ÷ƒ‚c ´»ì”YÜ)«ª·]ëÃã.iÜF%a zb.¹
çï N q”dД Åÿ¨ fü¬bpæÀp„mÂG¡)'|j`Ó·è”Áç–îtL»â"?`ÅBô-6)ßààk¦›ì—î‹`Z—Ñn="¤[–ugÚ3T@¯â’Õâ‘ âIê jL“wD£]±M~{“½¿ùùõ/þx ¤SŠ,
E †
zsûÛëgàH7Ÿû*ó”‘|Ú&:ðx<~žëÓV„B-ÄwB_)¡¦ sÖ 8ƒðqšR/^‹ó : .¾ ž8Ä9óâr®“Eq1 CÛ*r âJ=Ž.tl5A>
stream
xÚ”Os›0Åïþ:ÂLP´+þôØNÓiϾer`‚œ05àb<©ûé»lŠÓLO€xúiõÞJJ< %¾¬Ôøü¸^ÝÞ‘A‹V¬7%*–œDMb]ˆûäþ Ò‡õ7‘9/v"Æ¿¨”ËdÒŒRÒ:ŸB¢©Ÿ¤–䘡 å ¡—‡p]®'t –Ór“iu–kìåv"·ÊéL7A’·,wî:ÝžéÆIg Ë¡/æöŽ½¹x FcD†L ?¾ÖifÀ$yQ”]Ùô_”tÍ0}…µRkäú‰ùn·=ʪ©»çíqa1ëdpþ¤¾a®fîslã¸àéå¥eTÊö'±ÝC¼|ÿl^õCEMU5c]YÅ!~`ÌÔ”M›W‘Iˆ˜”õãöP”õÓ‡…
9n)GÓ
y¹¸ n?ÂËnþ†·éÌœ—¿/{ƒÒ™ð/Li?yÛÅv8 ƒ‹ÙhØáºX £–ÆÎ
=Ƽ}G¡r0];”hjú§CÛÆ:å;nEå“fÇ1•¿b1|niIýøÚcûahÈ&.ÔÜ‚3ë–s‚ µu³¥vmS\kN˜Ät¾R…g÷‚ÏŸ—útÏ MDŸ×«ßdûV!
endstream
endobj
198 0 obj
<<
/Length 2238
/Filter /FlateDecode
>>
stream
xÚÙŽÜÆñ]_1ÖK8À’fó¦a)HÈ@´FX†À öì´Å!ivsù÷ÔÅcF\9VWWW×]ÕîîwáBùþpûêÛw©Ú©$ˆ“,ÚÝ w*Žƒ<+vYšQœînëÝ/^²÷•
CïGý°•§›®7íýÞ³Ü{4î´ÿõöïÀ(½`”¨ Êàâðä,Åù® Ê v€Æ"?RA¡
&ý×É4xÇ…çN”žëö~”{]cy]í£Â{ا™W™¦º›é;!ß+ï2{‚ŸoO“Õí
TŒ£bq´zØ1Š‚,™hªA8þ>' œ;ŽÍ
,’ÐëAÎÂë¬5wÍ3ïߺrÀš‰i|¼tÏñ’ ”©XÚ8Ô OªÂ;tgm<Ý™¡Ñ²é«E€i÷` ¸¤šFW²Wmiž'A’«I«Z? K÷)lËqñìÊ`ï'`ã žûÊ.²¸¡ª3 HÀˆñ· Ö4°sÑ4c6gíN Y«†ªôjcûÊ P“cªV¶£u¨…ž9úº±Z6ºÖºa< !p ñ'8ŠA¸Ú| ãXºEÓ:&pæ¬ý»ÊêšD /½ph@5moÄtñÚ ØB}=¬UDe4Ñ´ÃL‰¼®%ß t®>£,ä\X!Е
døNz ®eÀŽ½„„ù€a¨Ð†q¦Hp\Ú™uË]+\Àbi¨(¾TÜëf;avŸ«¶Õwžˆœsí&¨éÐa–ל° <žºFÀ~`7 ´¨:f~GIyaèÚƒ™£×t+®Ç±= zg z»å:Ìâ@ü–íx‡êÐEyPSI µ(õ~"Óä)qÇ–U7°ÖlwÀPTPU±ßÉ
ùúUAžÏõÄ
ÏÁKeO(}Uq1Õ=,¤ZRö Ó5樇ŠÅBTwäo]¹Š! V^!ûç¬U²1Ûœ.ÒµéF‹´¸WXSÀ" ¹¬˜ACànØÚœû¡“ **q,8Á°©î5ãرPœŽÕÂrEǶ„(AžÃ.R&Éå]ïQ¨(+%‹ª¹) O\‚½©ÜñwÊ „¡waÎ
rz]©…B L»ƒ¶s" ¢…¼qƒy0XßèvmÍ}+¥|C`cíˆ%ÄËH"¸PXjI
,·>‰ƒx¨j–÷%µ ñwÐ5cà]
¶5ãƶփu²VÓU¡GÒUËF‡ :Ñ_8Sê1ß‘xÚÜŸÈí¼¤,€ï¹£ÖW¤‹«ü´,¼wû™(…vÀKO¼âû”ÈjW)Ä#×°þ)Ò¶Œi¹^€¦Xåže[„| °ýn„$›j‰@¸µÀ=mÍ= £tiA—œô ¬4AÐ(^Í7S½ŒCJ/,ìî†×îDš4èz”ø§Á&¤>PD#MþÅHÃ
·k*ó<“#œE!ê'Ô«¶Zù/GiÕÌGT”ÞÇ0Ê‚±Áñ÷Åê Àx‰ÚÐ6Ó÷ɘnjJƒÛ ¦”ŒE1ih
Þ×à f‡¦%ä§énÓê˜)h’ œ‡¶œ.ÃÖ17V Èlε© `³Ô±îˆ0_qï-ù*Ê<Û5£7’æ¥Ó•€¡ŒŸÀ5Q†]‰îÃÑÜLˆøzzƒmœªÜôLN ^õ ™Ÿ÷iêA„ßløV2c9‚åÔEè^C3çKp¹0Æ•”;3?Òî𦧴Cø‘&¿ BQPJWA@ÂžÕ Õ7Æž°~!ÆiOÀ‘¿&|Ñ–ci‡ã™ãCyßíýLe\ y¾[´ÀÁûÿÕ0XÕ]?}'9c?!¢¥ÍQ‹"a(Óc‡Ý1QdMâF#JMûGÂ>SÅmœé›Í8íÀL߿郻èz¼¸c= ÆŽ+e*öºvi¤Sœ\EﺫÆ+å ;îr“#©¬!›®F>$¤Ô•öôrZü,³2u·ÇNÏx8“©ÐUƒÌRPáDÇ#¹½:î°Î J·µO2Zaê'sgæjUÄ ½¸b~ç Í”PÉzÆÝ\Æ þ¦fŸò«–ƆÄkºö ïFÜ á7P$ÃÊÂÌÃóG"CF:Oó¼¢TG€b È®–7§Ò¼Ô_èj˜_QDg£A£9þ„†Ðp)[^\%jŽ¡‡±×jš €‚Ÿ ÌyŠ‹y0ÆÞM¤ôœ'hlû¥T»¥–ÂwY ¤§º)…¨¶lD>•x ø‚o¢â ܘø ‰&¿ð×ÿŽÉNɆ‘
Žùò]§T
¶ì‡÷$ ¨œÿhë-f%<¯ã‰4¡Øü#^’ä‰}µˆ<«ÄOþd UE?´£ÞêºÅKÁ" O¯©8ÝžE_µüÝîè¸Ãµ$ƒœÓŽã»7Œ÷aÚ4¦ÂÎ-™
{ËH–Êó¡éÿ£ë!1#x 4} X»qÊsI±|©ƒ7ø
Y
ÜØbÂs1Õê»Yï5·jpø—ArY?_U#\Á, /Š¬¯ä©Úú©:÷Œ ëIE2=
y4_<Ê5¿iF¸rZæšßF+uú4µ!DS]Ò—CPÌý·åÕ7=ŒËËÿàXø„Ÿþƒû 4*˜Bz=˜® ~sZ_…yxyh>ñìÇ0
ŸnN¼¿½ÿñí¿oÿîç÷A DjËùÿ!dóüêYu\Ø׺¯«´#ôœ;ëŒ !àdŽ¿_Ô¯|æûïùûú aûšî&ñV·e—57@ÊOwÏŸ0ûÛOg|“(tÞñzmŸ×³.þ'‘û¿[j>±<öùËE'Åx©ŒÇ¬€˜ðÍ?>¼}Ét ø%×3þ©¦¼S þYYfóA¿2î7Æþ4ÔTŽ!ȉ“M™nÃp‰ˆ/å°4ä;dåä÷QÉôKëe_±ÞZZâ#ŽN¼oÄPᕨó ß×Ø%)°-w~œ©Š˜½Ê.Ž¼½}õ?6€ z
endstream
endobj
202 0 obj
<<
/Length 2347
/Filter /FlateDecode
>>
stream
xÚYYÜÆ~ׯ˜¼X d‡æ},,v"
6py zÉžÆ rÌC;ƒ ÿ=u5¯åJz™î®¾ªª«¾ªâ8›ÃÆÙüò‘öç»ß¿ ýMj§‘mîö7íÈq7QÛž nîòÍ'ëí»¿¿þ×vz¡õÃŽÛìw'tœ <w{÷ÍÎsìÔ6;×µÓPŽø M9sb±çÃð¬Rµ ¶ãYtô_^ñ’w Þÿ†Óœ2Ó¡õ_:víÂçx~ûnëZ0uóܹß(BÄÄËe~G«Îçn¸â¡î-I¦«Cw|"[hɺVØÙ÷°·Êº¢®pÃõ[$}óÏw$Á§áŠO×{ÞôWV"Ýp+S“¸ûþ^n¶mû+âÓ_xÅ¢µ?묫âd™ëuíÜ¥É
.—/3óµM‹WZ°Xõe‰Ý¬Æ§ªÔI·ãþQåß}'6ò·÷¿6¤W¯X³ÃÔ×å„Ë7MEæó_–¾Ñ¸‹œ$ïwùôdÁ'¾_lŽ¿Áx¸v:«s}˧9—p 9p Šr•d{çÇÕ]ºú\4uuÒU'AØ¥Û³Êôí¥kiß÷oüxŠ1pG¹ õ±>éíÎ÷=K_Î¥ªº ê=¶¾Õ e…zØî¼Äª·ðó„žÕDÏeX´ÜVZç:··» ¬»ãvü1W3äó¼ØŽ¢d$†ºæjÿ+ìûÐu=³nß³»ò]úƒjEÿ‰g‡ž7×Zwl4²:–j=(·tí
Ò&wü i; 0г5(! ÿ€·™Õ-ÖäšÕSÖgÒŒn‡5Wx¬¢:È°æ6«+Qm [º›5¢;‚ÀµZ0›*ç>èØ"nbÓàe8©èЫ ò¼@©ÇFø4¢ ^† á4Þ¶öb‰y Õ>÷`¡ ì¶]Ó#HÉ%¤8ìæÙ"ÇŽÜ`Ὺ,5
ꃙKÝ€ å•i„-‡ªn4»#Iî»Öžnòåa°sªñ]±wVMgö{‘YV÷‡£Ü$³-ÐJ¹Í_Žªê¸ZqN±‡8N°gZUqû›¼îÌÄÄ ™2}Ìa$ËOð¨ÜÜ¢‡ëš|q 7–dq£Û¾"9:s·"nÔ#"Q†ï¤ 0S›¶d™î{§&Ư’ýïfÅž"×v#ßØ ß÷Ôš<èÆYEÂéç¦~Ph |£
ø±±×·zß—Üß7õ‰ùQLÈu æÃý¶µ²ÏÖbk,àÎu"ÛIܹˆ ž^’ hÔâ0¶N
}øÊ°^$*ã0-½®æu¹F¯DÊc‚MuJVÑ"h«—(¦ »â¤wªe¨õRëcq:—z
Ì=
Á¬Ô¼1ˆ®5Ó³"—5˜Ã,¤Îy‡
@S€€ÁQ•– x:8âpWðÂs»£ô"¶Â`Ò¨¿ Ýõš©L|Ä Õàû§Nj½Ýó¤â¦¬üÜ8ø¼
AÿeOOW&à¤Á„ I-ÃÔ ‚á— ˜"É
H|xI˜›°©&ç‘`vO:CÎá¼¢=1)ïŠØˆN06î2ÕexÕ‘I%'DûƒihKØNr N„œW¯ βŸÏ9"¨ÊÐG‰Ë
v½A:—s l7"j£²NË
ˆ} ì
2åqt™lkt×7©F}±%ÐÞA©0ªûîÜ3 Q 3‰ 옷…$¸: «E‘®VȈ£”Ï=ʘc&tòBAPm»"“YésvÍíhõ0Àä©’~׳H“µW¼«î›5tÂ\d}©$Ú`E–‹®ö|”AЀ¼! Œûh زoa“ˆÄ¢„üImŸe c Âc Ö<57ö!;‰fqêÕ›Ÿ~ýøzÅp Œ,⢃~0𢀳ÉH²IfYIcˆñ¶`ø™‹>èÝRÆVh©@Ya>HìØR¶ucwC;J≱©GÆŽ_Ѥñåh4ɾñR% F î낌ϵdË$ø0c1/ùñÊXê(°7\T½Õ¹Gp tkBÓ‚'ƻ֕b–ªñ)`ùQ7zfòh$±íÉÉVF¬ê¬#ÿ€ £Rhÿô†”Ñ2] J¯¦WMÑuºâÐMnâ%—â‰S[ t%IKž¥ ·²K{+q$ý‰@ž¼.m1U¸
ñi„ñL*‚ó_r]p/t\Ê€èmbƒ<ÁŠCaòu'™T9 8Dyæ ¸ï%-Ê’G´+–ô r~2Ï=@.´¦i: ‘eô 4úϾh´¤µœ¸ø¦ÔçAÑñ$eÑcEìC”?M?¡ §T(`/X‚Øz’'j ×3™D{¼E€÷¡’ñÍp“j4w°J¯(nÒ™S9‚9|I–ø’ø’ E×ëÄi² Ø1È#R
Ö!‡2¤²a;N²/:ªæ–³aèœjÊ
ób}æ²R&²zi0´j"ÚÊkïðt,²¹•P =ôrC#]@ï‘ýó8 Ž‰zì=S»Pܺc
|YÓØN½Ô, OÚÝgNÛO’oú â© 8›Qñß[¨dÈlP22zìâ‹LÊ£Az.AÄQºÌKé5F¨Ùò¸AŒt-–&MåáÁäZ¬£øuÒõ´Ë
Û
\Ö´æú6¤mfI[›Ã¹ëa¤ô ÍMe†fXžZkºü¬b‚ ”œv˜Æs 3‚*Ã4áàGu%×›áPwr]„([; úD3^L˜Ô'(FrB™„'2¨;øã ÈR¹Î¼ ã'©$Õ.íý ñ³\À ¤zvúçhhnr7,Ú›¿oe{Q`·ò”Ih{£™¸\ÿjç˯vRU{®cÍ%ùíX˜¸|”Zå‚Ãœƒá#ù‹ö .é#ytƦÛΗMŠ@þ$;8ìá,8 1;üwV ÌúPÆù®ÈgT7žy}÷âÿ
×¹Ö
endstream
endobj
206 0 obj
<<
/Length 2042
/Filter /FlateDecode
>>
stream
xÚXK“㶾ï¯Ð-TÕˆ!ð•Û&e§6µåCv|rrÀD›™=3þõîF7øÐpv÷"âÑhôó놢Ãå þý!âï? ?üýÇ$=ÄqX$‰8<ž±”a–æ‡4ÉB!“Ãcuø%P¡8žâX$Á†®î.Ç“Ì’À^
ú¡¾ÔnhV6z ÿqüÿã€}¶f/"ʬ€Û ãÁ8R¢”Ù¡‹T¤Hxò”§8ežý#ÜG\åŠVDa ×|“§,Â4šéÎSWÚºï@ä(¬þí(²ÀŒ$J© ùÛ’÷ûÁ‚Ù`àö¥ó4îägZRßíîsœ@.&nµ-¯!0z+³JC‘È=;WµÖ/ÚÙ'í4¢ I< K*Ðãnmêl?• lUì¼KÅ[+ôO¿:áF8Q„y±Ês ¡¦ ,ÏCßÒhß¹ ‹#ÞwšŠÂ<ͶN;e¢p0áø÷ †3ŽÌKin”î8½šIœáû|5ÝF(P6Qa¦’½HD7çÎÍB•¶šFWí¸M0
®º»Î`Ⱥ5”{,&¡Hé, £.”zäQÝ-[;y™G8ö¦¸™¡î«Pßn þ ¶2ùF1ó¢Û[cB
Ó˜–RÌhêí¹vðËà~À ìIþÀ 3pªrŠ
ÐUªa´|f¸L`
¶ c×ówIi_NµÇsÐoƒŠ„ a0£¢ñ™0YÕ'9†?izs
B T4'iVl}©@Ø| ™jK´-:z"Íbðøbƒ{Ñtk6:°Ù/¦3 &ƒ¡GvÏ4¡¡
5ÃÞlS5ëDH«°Pw¨ù|ÉÆwºã¤ë¡‘‹C`8X®v°R8Ë¿£¬¦PVgìÄTqðéL—ìÇ+Àòû0.–³ ÛÀAö.c@‡Æœy¥må"Y¶ª) cVd[ël"ýuuIQ©" ð ! Žž|¡Ç‰¶Ö´7ë"¦õ™¾ä#`°~°Pû¸ÃM¦^v›Õ‰s©¾Ym£<ž-Ô±$‰ð½ÃX%ašÌgþõùã—/{0!¡ö%iºµh<ÔO“5>5çpÍ ¶Lq(“Óúùóç½¢°Ï¥ïø™f4÷èÀVõ}Py'¹yõ æJ’UŒm?Œ#QÍýœq®[•†Þ!KîgíO¡’ 5s)€"é —1H\Tád0.Ô² 1\påÅSºŒ®^i£ÂmvÌòÊlÎýÐÒRgLåy|çf ÆšOoßHL£š9š—GÎŽè¬\IP‘òË +8IÝ#€·Ñû¸BvJ¹~¸%Æ-k^,m¹T_Ó.•á”¸vȉÏdŸ¦Zî&?¥ñrÚ5 ;añG.óv } ®¹ÜSÛê¡þ“]ël‡…êèP“óæÁWxÚäwÓ@Ñ+cß2ƒÑ“e´ué룥^Çz|?D~<æÄ[Åb-(N¹õ†Æ~]¸!„ð„û9Dñ úÒ,¾fêZ—ª àÕ*M×9¸24žF ¼á$â$T¹Ø‚ÒW;äd® ÎK…´3HA¨ð‹¾ ôÙ“(åXOøéè<[¿åÁÉíöômùuM3§#_æ†ÄÜøÑ^0ï.9Õô°‚@Ñ¥Yàã¹ñÝ)bÔžãàÕš%âujbž-] e24*ªHvBlÀBfBß94+1ìq°Ô ˜œû K3<% ØÅW£,/¾!lÑ›Ûë!T -„Ü> 겶{ïüãa¡ÅVbG¼<é|³éª[_w»2Bû }¸{4bWÞ¡ß %vq€Wò–Ç·ÙÞ–ûB@g¥Éü@ìCÒk/ŠP.”x9ûH;W¡ ›²>KÄ ˆ¢yHýŸœÅž"Žü?Sþy¨îþ/¸éSÿ·#T}Ùmˆó0*fhù}Òm÷‚†8›ÃT7#"™LƒÉÖ
ïH³ýÐÊT¸ÍWA£PùûøånpïQüÚ½¨ËSP~fQ^õ`¿€‹Ìþ?}@ wq²‚ Hmz*cq àéQŒç¹¡×MWÖ¾HðÛ{° sÝ"ÐBà€—Õéɽ æ»SèP³WYÒMe±×²oÝå˜Ão»^'h*ççŠ&epïÙ=1P ugH ¸X*N¯õåÚ¸c¨¥WBÂêýnCöôËû†«®æšýLR³=.=Ö$kßæUÆêºábÎ.™ÿP™ÍÎm:©c£æ÷© Œ7Ywþûù§)<1SüÏ/‚7¤$áã|CõÃㇿ Ͳæù
endstream
endobj
210 0 obj
<<
/Length 1891
/Filter /FlateDecode
>>
stream
xÚ½XÝÛ6Ï_áú
D¾[±¢¨ÏàÚ"ÍõEÐÁ÷ÐŵÙÊ’O¤²ÙüõáŒdÉÑöòt/&9 Î óE9Ú 6ÑæûgßÜ>ûâ»Tnd"T’Å›ÛûTJäY±ÉÒ\Ä*ÝÜÖ›_ƒtJEÁ«Áºîd>˜ö° U–U[ã$¾}ït[›v'ƒQÞ;»ûíöÇ/¾Sù¦eg(>Ú„±…,HðKæI“LEžfÀêY4J¶æ®Ñ+â’Ld*YÝ…‰Ê0Æ"pGM„¶:i"u÷D™¶ÎÕ~Á »4
ªƒ¾j¦ãˆ}”صÍ#Íšî`öU3*¨ «äq_±î»]ç·yf±På0ešÎ®UëZìÂ2N‚[oO©‡Ö<àOG„îïL7X"œ4XœÇª5öÄ4Ç̧êäf¨R5ƒ*ŽK! 5bµîž8iYŒ<§ÊypŽ¬d´Ñ€§ß™z üõâ¤y!ù‚ nµ®Á:Uæ tUAEK8ìì&Â`uO³»
ŽÈ€é†Ï{ÅžÐâA×Ãma¬‡½3]»Ô±÷!J´Ê¹ÞÜ
N[t«T ®,M–N1µF•"q* ì@ŽÜ7•õ¦Qè+F'šŒ2ýêPOþsYŠ(ÊG ¯H°¤lCÖùÌ eRˆ8Á ‘JM!™9Ÿ3«Hdq1SürÄ2tÍŠO„²ªàôü7Å·,§ÀÂx“àÉ–Èox9 ÷TØ]A"QBåùªI ›“'åÈüõ.Ì¡ü|£ }b Q$è·BÕìÑ?ÞÕªôò1M\È1eB‚ì…¿Çð GPÌzôh‘µ¶æÐêšÈ˜[H=û ƒ¨5ÖÑN×îù @uäx}
‘ò¼GPb~×ÞJwÃÁª}Âë¦á3Lm;G„ƒv«áŠ^HÇb–²˜
¯ýH_îp–ž˜/†8"ÜÏ£ª1¾ø<î
@Y*d¼D“P Á a>9ÃÈoyØpbÐ/¼®ßð>» ZÇ ‘@ÁÇn8 qžqjÁ-¬¯ÛHòu'„ ì–MMû>qç2z=¯6°ó6Š3Úª<à±·‡K½àý)¥“e ›ß
ZIêBÄY:ö9zö3
JȈX.Å1_E5ÞWùθ¾ê GL/–âÚ×Ou4{¥Üïk%úRQeLHæk\*%ñÿ챚x Là <*bY,;¾бŠÈ;8™UŽXI$ßQ®Ñ¢6öÜTšH™<ô L= XmwÒÈÎf°¦vÍØ}×ÞöÒª:jf³–UÓ„;/ìa¼ð ¾#n¿¨5—>:•¾çÎ[à‡Kñð T§‡þ¢Åb ú¾†¯Í2I–cx… bó6R
ØqÅYŒd,¤{Ó)ï{bðè Òmçº3ÙÞõnh'=KG —ÒÍ/©åCyÍÚã|©Šü“&–Á½~ umÈ~=Ư_lH ù¼Ç$p-Š(‰ülJ\Øá|î!Ø4óß÷þ•;mן*>òÎ臛EDpî
m£-;׿cÆ=Ú›`Ò°çpªÇè`ìÚ§ýF/%Óù AAçðõÈ 7¤ÚI½· (>ò`t,0¡¬Á‘w0‰÷æ̦¡¢}nÁè²îißÁóÐ÷ù¤dða‚°Á,EW¹*¬+Waö¥j4xŒeÒ¢K$åŒå½Ü
K½øVû”G.
ÔO:÷ä{Õeó›çví=•Ã7ÛôÂ[FíU•Nc—rd —åüõ—•ð!Uâ3I¤¹$Ư 8Æà+×ûf2iÀ¼"áÉÕ›÷ÿcjû>󱕋$‰¯ýÓ …b›Æ1ñN|,/ý9í×\gð…ô‚¦e ¿Êño4•E„“„¥EOIÂÏ@ûb4"™ŒˆG#Ô2i„೬û§_^¿^ÓpÍ·?ö¤ lLØÆíÏgÝnyþTúqþº, ÆÕ«¦³zKÑ;3hyxhé÷Äi>ÁÒ§ €cFÈ\ÿ#*Éšù*ý‹Õ5§â éâ!±`p`Xüý†l݇®Õ[ Š/˜À¹}µ]GñIaþé².í_•[Á+[à5~¼ÍðšÌÂh ¡<ú|ò¡ë¶k©ÂÁ: ëe¢Ì¾l@
¥Ë'åÊ\0§àqŸlÃß&«ý‘àÃwÃØYk»ÂŸ%Ì?ÌÈv¸ÅÂ|âû'{«tòl(þËíé‘Ôb%e¬»ÓI·n;^û Å£Û/Xâº}Ín_–êðXΞ¯àCðŒ¥±õ]aœ>HÃ/Íô“…}|ÿ-:ßØ7¤9|¸CÚp`Ê<ivõÿÈÿ£ºfŸR]“|V]AóÓ–Ëõô÷áõ7O&E–àÿ¥(Æ¿d¹8òíí³?tDH
endstream
endobj
215 0 obj
<<
/Length 1935
/Filter /FlateDecode
>>
stream
xÚÕXYoäÆ~ß_1˜“h:¼!6`obÇÁ"´òÓÚ0zÈ
³<&lr%í¯w]äJë§ ~twu±ºú«³ÇÝÜoÜÍo\¿»{ó×ï£`“©,öãÍÝaã©Ê²dG‰òƒhsWl>8Úî"?rŠ²ntmìvç»Yæܼ+mÏ;íGûËÝ¿6|¹ÙyžÊ" ”ˆ¸ááß?½{G¬îë|ù±ÃIè|ðnÂ_˜võŸ“i®dþÏòþ8Îßµ[ÏWo«Öš+:dw© S6…yÜî‚8 Ç#›¡æÉæÝx©+çzÊKÌ_Ül}…̯lÏW
™Õ‹Hí˜K÷}÷³¹¾f®úÏmc®€ä}½ îúÓÝÛ«œñ…啶v]ÚßuÿEàèó%p“ Î ÍõØÛÑ&ŸÛöjÍì"´~B=AªfR¯ê'Ö½6½–½¶®MÓ¿&R7m4*{Sßð÷g‰€§ Üv2ëes¯”"™Ù,4
?Ûì|8ÆKù˜oø3ËðÂU¿…”û¡ ŒEZðø+l!ØøÑó¨s—R_ ,Tà]Ìî—©Ä‹–wü±mC×¹7ét… ÏÙ1
ÎåIÛTO<Ó‚+lxŽ ÙtÏ3{l‡ª`{HO‰cxqÔMQ™‚¹Š²3y?JÜoíéÙƒ5 »¾ª, —È =ÅzáìvJ“P$ž‡²eú‚XùY4òñ‘àl-˜[79C29ÒÁcxrš¼/Û† ˆyt' ƒ „«3ýÐ5tU`Ë]zš ø*ü.ZÌ<]ê '*K²‘›“ØDKlîð>¡—8º(JTmzñÙr–÷1
Ïʆ9ŠKM½*‘;_S3ŠUú#«yÔõ©Õé Ÿrh»éX?uzÓ‰Š‰sË÷òýH‘·¼8@b D ¹fÒ´W x|BØÛæñ®˜:àsLèà}×~ÄQ@qyK\Å(tòe˜ïY /*sèù]Ý•`oX]L$‰JSQ Ä‹Ñù~ØcvàÄ
* 'ó=×Wq’Î|cêÝȵóR¤Í$ Tă.CæÇ™SZ&hYÛ²Æ8&#áZ˾yìMSð÷Hn$FqAÙˆÙÞL’*„$ô% oo½/ÁžÆ½¼
³–ë8
ÜÃPUb)m@lŬÂ:ÖG7°O2£Ø¿YØ¿ãUc xB"ÕJIqW« Àf‡½èy÷o»©Ì 9„¹Y–ëyMöœ¯ósžŠÝy쇑Jâɾ_(DÿlM
¿Aˆ?ÅíõŠˆÃ%L~¸áE*NÓÿ£Ð¼¼¤Fò»…Ì{ H¤A¦ÒÌ_ºä73kJSÁÞ ¦µö÷5 ¼Y÷åí{/¬<{îÆžøXøæòîŽÁiå
ãgºªZÌc¼¤Á •P&µ<¶Ÿ(çu]Y 4#GI}"Ã
ÇGìž–AÆ€iƒ¹¢À½ÔùŒó–J|{, À±¬D¦í/ÕÛ½\Ï)ÑAĵƒz¯süè㪬»bLÑõI÷徬Ê~쀌¥ž¿×œ<¢s¦à»;meyƒSI8V‘h¬ áóá^‡ ¤ÉQıÜТ~©º?ËnëÜË”ëN‘#%¦œ„½$¾C×Öc3òJ…vcå†éE€,O[Äé˜=t³ Œ}.)ÐP$h hN²0`Ö+—ë:o[L߶lÉ.`×OÏ®ºÖL@ÒòƒìõÊõ,I¦&â$ž°Åí ÑwÁC¤Àtˆ’ç
t-9lÞ2µ0ìêU+ådg‹Ãä–ù1P¦- m[² &YÓËÙ&ôemħ!}¸Þó~…cÝ £æ'NÙ vG\s3'¨O¨ƒ‘ÄïµÅN9õéT•¹¦jkÆÎwOÌ:«Öôå*òëªè 뺓€y‚sÿF©ïZ®Hå&¼ôkðÎZ¢OxSx@Ü!”ÁçQ½ÎiVU†Û>Þ-›C§§rŠ´ìŒ/¥MlE¬ðtƒa 'Ü‘H¸œ.WÞã¶ä¾Ô§~ý¼GêI-$’Y|èßQ:ª½ÛÒƒÆ#cZœàyÈA]p§Eçlg‚"î.§SéŽ0Öú£ø˜ÏO¡>‘‰×š$-Ž>x’Œ *؈bç¿Ðá~%🆎ݾ•.93 8 ^"ÇK`"Õ=›,alSç¾3ZN L†šÚe "Þà4š¢ÛBÇ&ó Å•£üìúñÚ-ì"¡jÉtK3B÷=ì!âú’jÎýôGÍZõøÅM h6ÓÀÁV,¥·eŠU"‚ŽÛP6—WiÁá‚ô
[ ž§˜^D¯} `œäC׉ƒT"n U‰ë¬ú‹Ž¼’þ±Ë.Ÿ¶`1]VzOž˜qóŠãí5ܵÃ$ Â1ûñ&×{˜\æ;9
ÍŽÈ;i
H ìaÖ#<¿Ë:_mÖkÃÔMikþ†üÄÍüy.‰^xty)¾xp^Zrw"¡v»¢“¼Û`¾Òô€<o»Â¾tc
›é_UxºÆ*MbÈ^ð.…ZGÚûî‚é wo~^¥}•
endstream
endobj
219 0 obj
<<
/Length 1709
/Filter /FlateDecode
>>
stream
xÚWKsÛ8 ¾÷WøHÍD²(Q¯ÜÒGºév·³±»;³iªM;l$Ê¥$;é¯_€ œÈU¶½Ø$’ >àζ³pööEèþ_._Ì/ãlVE¥³åfÆã8ÈÒ|–&YÅÉl¹žÝ°R{~TÖìv0ÈXcº^«Îƒá®Ä¬kHc-[µÕ$+w»Jy>g«²SnIºi ©v·ÒH’)GuR¯åš$»ÞàU9kZÙžy~ Fìp«*·ac¤Ä“•ÞzŸ—ïà->çA‘8{{ØÇ`•ª%ŽÛ¹WMßV´Ò·x“ÕiH£.u¹•Nvëë²+iÔv¦_u½‘m`oä"(„_{éåp2*y¾ÈÐ{ž «fWKÃÖlHá¾kipPUE£McŸ½êÝJ£é_Ñ~¹5àLxõx¿s`C³º,÷4¾5ØŸ²X—xm²]¹Âóï¼$eàt¹à+áü¸(Ø—h#ÎPŠ›ÊõZ!²Ã!àÔM_×ÜÖ4[ÏÚ@ã) PèÎNU°I¶S˜®zcœ-ˆàÆÚ[“UU~Áà@ñAu·à;&$³ôôç'YÈ.œšüÆ1D5éÚ éÎ4¸g¯ÖîdëNû\œU{ç Ñë‘É)™\K@Âڲ᩠‚
„åj%Û–ÆÏÖŸRµÛhãAÒDÞ—µÒÃA6•PìR¥sþQ¥;EéUÕ·ªÑ¤?¨Ë{Êð um|Ï/Ž1 ‹4BZ Õ8‚ø‰HõZn yõŠ :ÒÉ —@Àå3?âAÎsÚwÃ?6Ìnü‚áÍ^!š·ª£ˆý+!ÙUKô¯ ¼-É ö%87
¬×–f¤CØ®|
“0
Ãþù¹{‘xb[eA`…5ì{ã%à sÎ$a‹»ÒƒòrÈ~œHZCçÛ¼ŠxL)ÆÐ_“&ülûª4󜞃+'E?¬/-]áh!rLsÊÏÀËY:˜ý®é]<æ¡eü_t@m§Vè”aqÑl:tÏJ#‘S‹ˆqŽJÑKgŽ&è‚Qdp ý€xðãõ{âË[jÝî|>? Á×nmá’ 1Ûùž‹¹
Óùl8;EÿðžÈ}= k£°ô ±¥— fÊ]%»N‘ˆÜÉ9û½ÇÌEÑoÑꎤ.²g# Ì 0ùàÊ®µ>‡HC1@
ÇÖ¨9ó¡UóV1?q…k’³WM½ë»ràÈ8ÉØ¥Ò¥^Ù蘄 fñ`Ô59Ý’Wv$/Rm1ýÆãL0aÀC4çÔ÷"8vr¾ Ó›xÒù¯•„´ªj,ö9ûÇ–5iºïg˜|9–Ê¡ôgÐ `!oIÕ¾ …-Ög”XÆÁâÃÇk´øÕšã
[ÎAû§P)$kô耡–Q«öÜ%aÎHé1Oõùræãß ‚£ÉŒ½Ñ[ U‹‰ñ¨©°Ú„#(œâ˜ýGxaFOaLÄ0’å¤92ümã0R°+ “ÉgÜ#1÷~%åÄ$êW®Å F9VõT°f[jõÝÊHbëŽHc¶°E»¤ØÆî#2~Ôxųð¦d¤óÖÕâv/9ËÓôý #k&ù+9)[²’Ð]a'„>v¹‡=%¼ñYÝRÊ$Öðº 4?…àU«
4oÈ݉íÕÃæG}"÷ UƒVjªøwÇórbfH~¨ü²%Ñ‘#l:Aa ñ±>9Úùì òªm¦@D lIzŠz2‰:Æ&¤ÉkÛOOô«¸øÊR ‚‹¾ –H ²¬§Ðä" òB cÿ ßÉ;á/bïm=ÕÛÞÂOpHý²>m4JBêq`ãPÕ†n6JèOzD{¸ÍÐÂ%ûB8ñny|dY¬…iLYšamwVÁa v¥„c6“=–ØÖ—¹³þVRëÒM.zè TI ¾»{døÕâ埄oì!´-Ü3?<ûÿš{íc‡êCÃòUÚbÅ þ%H'£áí„nOŠŒ]ôý`ÛM3—ÏùsùÌc¸09FÀ·¾Ô]m¬5C!öŠ:q/±à†O)²žýÑ`ƒ´–0…mÕðNƒk’bœj— 25jµ<4ænŠ‘(!ùÓŠ×<~$TXQ¸· ;Ž}Q±Ÿ4¶X¤ð5z‚>ÒJjú€[«¦&›ÝÍ#À§òÙø,ã¾NŒC6Ed©¥z52góo ÜS)¦[`Ƙr‘ÐNb‘pwG|¤õfùâ?MM*Þ
endstream
endobj
238 0 obj
<<
/Length1 739
/Length2 18638
/Length3 0
/Length 19171
/Filter /FlateDecode
>>
stream
xÚlºsp¦ÍÖ/ ÛvîØöĶLœ;¶mÛ¶ms‰9q2±m'ß³÷>ï{jŸúêúg±×o¡ºº».
{;5O #󀪄ˆ4 333€™‘
Ž‚BÔ häbio'fäüКT V +33 @ÔÞÁÓÉÒÜÂ@mBóo!@ÃÆÈÔÒÖÒ aocïfibàsssrsvetr`üÇI¸X f–6@€¨¢’¶´‚$€ZRA ´:Ù ”\m,M r–&@;g
ÀÌÞ `ó `bogjù/LÎŒÿ`çtrù˜™“½-@^\MXBQA
.ʤ&
0²3ÈIýãnçâüã k ‰±å¿²£¸ü/ecô¿”ñÿRÿ«uòøÅÇÂ0µ4qÍ-íà˜þU7i;3{ çĦ®ÿ£úó?ø ÔÿÔ`
4ûÇÚÕÆFÁÈ µ·upu:äíMNv {S€¸‡ ÐÎôŸ$¤]ŒþÉóœŒl-m<ÿÝþÅÌ…íÌÿ)$ ;#3ûä–Ζ @S%K—ÊofdóOÙþ-×þ§Wÿ
úŸ%þ ø§Ç¦öv6žÿ'ê?‰ý;&“˜¶˜’°ÝÿŽÄ¿Õâv&ö¦–væ U—ªkädú¿‚«•Œ,ÿ3O æÿ»Ü¿y–ÿË˹8Yz t™ÿ50Ìÿúþ‡Òû¿V""ö Þ ,¬\ 6V '7;€‡Å÷¿àš¸:9í\þÝ‚rù þߣz MàÖ–íMxC¬ÒÛÂ*ýÄ‹çª éæf Õé–Y@W¦û®uQ-‡-L
.ñîÔð
Ügùw.¶¥ïZIâG“S1$zËx/¥dUæ~u[oÊ…¯úW¸¶&
ב·.™ëkAJ´SìÙygu2Žåü¨’,1†](V ì$iô¨Ð²t¾€{tµ(s¡EWÆ‚/»k`áÁ;׸E•áÚwæ߃ET“B‰Ž “N(<Ú×ÁŸ¨Ü]¢aü)2lô" 9NwAœ‰T_¦2)ß‚ù7x|‡É‡Ð’µÇHW‹tìY»“x ôq#ÁœmŽ²cºzÔ¢ÍéNš!-§¼$P„²†Ã',Ð'o´0vØ *`„´™ gû=€_ߺѲ HãH8oV˜ÖU2ÁÁZ4.u3Šê?ï\_RÒßµïCÿlëo ªh¿™¯Í>èzò~âE#?@”1‡ ˆì!wp ‡ Kìz!KPv»ÓÃòÊ99)f‡Tlêh…2B(ñûöt"
Åš%fêyá±Û€m 6Õh@6Ș%<]ñÉЛ)ß)KDMã$¥òà2¿@ˆڷ†9ÙõÁò8[ìO:¥É’¹s0_鿶ŬÅêĸH•ÑémI¸ƒ¼Ä|^äR’6ì®lþ;üG#ÜgÆÞè±gÙjF:f‘]‹pþhýJ› wŽ³@á÷GÝl¿=Ú u/ói ì²’%|¹R›S.x¬ä)©G«1
L :2¯òH{La ÷Î!,EU½p¼Ü*/0AQ§sØT¥´ŸyäèºÏþ›P^”=õÆÖækùvóK&i¿z;ÚÅVî’Gu‰ñû~Ü^™Â!¬Æ³R&V‰É_yFÃ<¾æê=A3n„õ{äî‘2îtš¦‚d¼Ë ÐPÅÊÐ0EŸSÉöDܯŽ<Ÿtž
ËdÂëA˜ÛÀè"7Ôö¿g¦SLjE•¡ØšÇGÞÃ“Ü ,áyßuo±£T+Þ|=¨_y@¯^î˜IÑóz? "A1`ïû ïòN
œ@ÿ¡L¦XQ+ñŒCØlóîAÇ–`H1Ž/°Äy2LâÌñ"cŽ“|Ã…½ìÙÍ JŠ2C¥‰¤&;ÂÄ'F€ÿîü;¤T°±\1¾à;»å3.j‘Ý>„Ë‘“¯`¹l¾Ç°›iÆEíÕBÊ2!ƒÎ+ã4ùI¶$Ñ®i5Wȯœ=‹²ïsü<“d=Y\×r÷GŸÛU>I &zxc‘ÿcqàO‚ˆ¿t™wWÍty_þ†‰ý?Bļ9¹ 14®ÁÁ{[·ó|eCÂtÌæd.?âhaCgFwFgÉvëóU[ñÊÊøðõ ©@+í¤ŸªGl=WTÙ{.Ðu–‹ðž$Ù£%º5.o)Œ"ûÑ“R•!ë†âvø80 ¨5Vª‹™S’Ýäu @9.ÊÈíäG2T/o¾²„›z%3Çðøa¶Õå–ÎܲðnøÔ(“à¾Åùä3†Ð«1ìãòÛ©èα$’^Ù=mÕ¥N=—½ð×Þ‡56%¸VH'xXÇ‹n•|ø>Ê×3)1¼nDGÓºYÔºh‡ÕÁ¤ÃÛ¤Ü6CR¤ãžÞWV´×Éð~GçÛVÿE¨
ù[r¿•6Ûr˜Ý5çAÛ W½b“h¦ÒwÁƒ-Ëý‡dø¬R¢‚Hªû[Ò<¬
ÉÄ0åÂî`+H۴鎞ü¸½Mô‡$SÐÉkzüËÇíì
ü˜wï¤"œÓ}È`~X¬nñÜ4,{_6–õ…®äšÝ.¬\±¢´Çšj“($‚ºrz–Ãn;ÈÔÿ¬åŠA‰^I±![n™}P‡à¤õ6d c1öùšI76 ï9Ð/Ãnjß-e•aöz±¸%¶X_Jx‹[OªÃñ{áÉ=Ótÿ©ÆGà/ ¯Gg\ùùâL}!‚Ö7P>‚#n×#åx1 á’A÷ºk Ûî:ö¿íúEàŒÆzÚZÍ1µ=þ<Íd¨û¤¸Å²z¤ž áX3YÍ;$^¬ çUfpåæFMô«üãHYMªd#>oJÙ¬Vg G’^¥º¼ˆEnÕEÿ=*Â÷ó^ìOÈšp{úd~´ðªxø§Åï¡}(7^¾'¦Xœx@@¢ÄŠì–„Lð5€¸¥â÷È*/Ÿ¡Ô"+žÃí!ç’øé(þÈÐï#¿bn«¸ÖK
§hsƒ 0-ÓØ÷%pýↈò!%
qÎ+Ä<Ô }çäúÕè ئÊSØÅèÈ À:âw‘O)B¡±õd¸÷ª]qÑ €œ’:YËb T£U:el‰iGæ6ÕU"º'¿“)«H ²ßNäZ]HVúžÄìjÓÓug—¼i*‡¯Ç£oœÞÕFåeΰ:Ç5j‚nK.œ²Åïë¼i£E¹U¾`ÒwçÍ÷“–ž÷¹Àµ×vµ¤;ki+
^0nÑÄt ·|³
`„ØÅчRæCÊX!2GR
_ÿ6ua½²ïŠN¿>0E¥¤|²}AX,ÅLm½q# &g,_%Ä¿·|è'0ˆ¯3(xîéšUU^jSÏ;•bT»f*–0<çr0öàŽ·ñÍOjÕÒ' »ir‚ÃÕëˆ&ùϙǧh±Èͪ{aW½RÇCðØWÒ†Æ$©éèQ šãGhõŽEÿû[Õl¶<+4œ÷a˽³V(Ô QÏÉü`²«˜ÏÚŽK JtÔÀQ„@HÏc`¯„û9ÎQ¿ÂÌçëbŽŒ)‘|£Ÿk‚¤ú5ºÖƒ^B»§R °šŸê½`Ó(¡¼áçi"ÂZ•ÌveKzdÉÓj³é(6ÅÁ+¡fžl8sÚDå|¯ø%‘»«Nº*‰ v°ÇåÄÐ¥Ô"IfõG‘a¾É\P8'…ØRü`{Ú††ãã{ü:ú
Î
Ù…A¤˜ÞUCp¸ ˲#ÕØd+?Á9ïkúu¨“v:¬
¹q¼I:ÃZ×ôhBÈÕ[ô\âàUØ?F S›3Û£
ì‹æÓòn7»´_T}"vƒž°…ß±“$jÄŒ‰m½ðAÜH™öGÇ:žkëíYúŒ<%æ‰TÕÒ8ºíRX €6œñÈö3ÎÃí}0ªGŒÔ80^àR:u@ÙåNY^œ×5 e—ÇPÛ6Ûë
üp™qüçß{<Èy¤§}D`›dŒŸ°àÓý±T÷™¸huHþ¨´Ú4Œà4úa¼¸
\
îÚ
9cK<šÅ$÷”x+SpŽ”®6IëÛÍß_<›Dñ/3M¡¯:êô¢8×ðï
åŽñ1Ý묷$U%C2ÃŒàÇ0ÃɲÀWk¨¼õwÓÎ5 žÍ¦èÎ,Í-…R‰—«†p d”Cï'
¬§H3K̬ã¥ñDZð‡
÷(cÝÿ¾ øÿÐ<ý¦žsÇ©’&Ω ! ç ¦éø5؉év ‹z¥…m½1ó†D…Ò>³ ‘¹/Ò#»RoÙô‰r½}ct¿þNÌij×ï]û"úÜd6\æH@qr,¼É†Üê‚
U
!¹É)s «qÞ=™¾ÒãÁ…y‡£e ÌÄKñþ1ÍlÅ8.IT“Oæ»3«ˆMɈ4o"é¿m1u÷âQ² ˜6+ï²K*$ÌÄr Ÿ‚þsë÷fC=ÇqËóFâ>ê³¼^ ¾ àöK
—\&ÔÔfM+yÅ/¸R=¨e@úWLlä6‡„
>jJ““ØæîxÞ¬Ú!§èßËHX #²¿²™ãèʤc®þ¬Ê<Ðu߈ˆšáYùÖõŠSt#ܹd“¥ä#r¹, O•;+‰Ö6$q-г ÆçÍZÖ˜G<âÚM’ŸLêw»WÐOÊF©c³Pûk”P=¥Ù°ÍT ؽÊö§*Š³Ïý1äOÿ¨å£Õ×auA…g:vŸ»mRl E‰ÚEß„Vçó’Ü5}Âï0PµEYÌÏÈš¿µW?;¡Üè8
¾¼µHTè,
L D±Ô¤ÖßÕHOšá^w®wø?¥£¹†™‰TøF_× ñàk3IÙÚnÛå„+n>ëøYôPM8“±D”jS5í¬áúî=JYG9Ôóá-AÍè3FÞwt¨vÑ~"¼,|Cžñj‚¢KÑ.¸ÊxSí{ëæ‚ëí FÖjG^u=g´3$û¨*)©–c¿¹ Þ;6Gj?²VPù9ÙC$µnÁCÅÚÛàšaÀ¸`²`tà©,'šB5,‰áÜ2äCáŠÐ,¼Þ}DLÒvÄ(9=&%— Á_‘F%Ë «Õ×x¡[ mŒ±²LÚ.ÓHôáÖ^—zÁ…ä”ÜÞþN߇%F á¾g9¼¦O ¢¼=½n׳ O‡íõlÞÁ—&O#ç-XEb$ÕÝjb~
:SäHÍO{WC°ï”¡0S°ï#õ5ÃÀ_E²I`–óˆk±»â9û×ìP:&YDÎÇnU~>"gceõmF§ó&v?-¡5G¶èżõ)y§ò…$l8CmŒø{d(3iv÷dÇÇñÿê”ðeo8»jcqÜb“†€–Å mªöfÜ¿½"c³ù—v„"Z„-+ ӂ'Ûu% ÿT» ðÛC6çJNZ¼l²;˜äjá¨Wc qel†ÃÚÞDŒ¦8H·Xê£Æ;Ö€Bò…¹ž`Ywð‹£KÝR
¸d$:ù¸> íÒ _ÀUŸÒZì³’' ÷çË ¤PßχÛqæAY]svÓ£Ô•ïÂzBBÍø³îŠÌžÃ°Ü¼#¤H ž|ÈjìM¯ œ¼œºDJS j.š*¦ó ?Žâ– D¬l+¸ÖpµÓKè´nF=Hš¸»{"™0Û «ª4²sy‰ZÛ Vòœô‹ Áñ÷Ô/Ë?{3.lœE"üšnŒÜqx©û¿Ì
z)o½ ã4~æWe½u6 «úÆQ“øXÃćàcÔ(—µ† ½
é<¿U+Ù/Åøî1ÊÜÞ· ¹ê(û¶* 4 “( 'ƒÒ(QhÊû€ûÓ˜äØcfwŸ²ªDÇ9gH.J¬['_óª~9°S”þÂ5QãËŽ<ø2]© ìƱîÜÓ;`Êö{¬×³a¢i5Â5šPž½ÎÍû˜¨x½ÓŽpµøQ„èys}ÌC¡s™£:ÉrÁ €>Ñ“¿ñà ;Öºtóêž„ \ýs”x…%ïüÊþÖþ( ¹Åóœš÷nÖÚ—h%|u!k‚(bÃ'Ð Öœ""é¤Õ¸ 7õ„ð'éj\•=}\#—‡¿¶ ½(´îæÑÙÕAoÕ¥þlÁIR
Ÿ†%®{¬¡|ß›žé¯ØÞɈ
üLšb*º'É_3ýózD
BˆPa’#^)mlû·ªV]Í®”èZ][D³û ì½ÙE±/@xy&RtôR¯ª”àkÂÐãÉ[~N1”—É¢*< :bŠ2‘±|. ßôÓ¦†àòêøø• º8m£ï9´>6!àêæ,{íðɧJCk;´Áöþ'½`M*bÄ!--Ó=éýðlwJè3ÏÁëÝ_S£;ÒûÈN¿åEþqšèG
÷Çߎ5÷Œ&Ó&rܾÛð’Qþ£4׆@e¢öõ°‡ä½;¬Ï>·ÞŽ[,Õ§„Óß \ž]7ïÍ ßÒi/9Àäû?/lq880¸HÃÐ2 %?¦Òײ߮·ö¯””ÃÖ£iáË]~Ö\爻sfdV7ãeÌEø†"Ó–ŒX¿x£$íÇ_À|Jš®ÒÓÎ)”3æ¾*{ˆ¯…þ^õ¥Þ‹êiþÓ]_½GÊy8ÖQ¹Õ‹b쉔곃í!'W @Ÿ‹þðLàžŸ¸¼hCÊøU@¨eÿýKoÑÞ=6ºæh”ð’I1;²ªC݆ÕyYX‘Û>—™ÎŽ ¤Bÿ½Òèêö
«\çxŠ¾õ$Š–Vr¿›p,e¦!‘Bx81ïóÜ]‹ßPû ªå¿É0Râhl±çs8µ?[–×k®X®vˆ(<+!{Ûb
ú£p'ˆ” ¤únõáæmu7S^R—s؆ØrÄÏ `gõb•”˜5Z…Ò¯Ž€°±¦Þ†æ™ ÜZZ?ݵâp’Sç!ØT»E‹ m“˜P ¼¯qrÚO²ê;+‘³éL<¨YNo
”S靈~ðÉë ¾¸ü4UvP
âëôÝü¤HÊ,gz²O6#à8xaÃÀ=N‡5󂨜Hª%}ñl#çTÍâ¾± í±,ðH¼hÍÕà$HïAnÒÈpÓF%,EqlÈ7¸ÞÔÀ~<º Œ¢ßï,Ðz,ð”CWšcLiáscÿa»¿á”æÜÌý¤ðÚ.·gógzEzÆCâ9¯°W£P?ÇNôZÒ³ ÷º@-Ûa¹u#Ö¢ÞŸ
YÅÜžÔ™H{N:Ê|¹ÝlW Æ /úÈ1ÌòXû&ÿŸ%‚ˆ÷šº®}ç°%€Á¸‰.BîðøX-ØOóà 9±”t»^Ã@Ó¸ÚÎSâ=(wÛÎ×xG»äí–¾Mu|‘ÛŠ~IòMá{M?#_¶^B×€žº2e4Zñ‚=‹¦e b¥Í‚×Zµã`zûúAMnk¢"žGÁwÛYóï1Cr~Ü}áY›Ð:-g¸j·£Ú~XËÀi6BS3]îòÞ2;€üýS©™ .À¨
ˆâ'· p.}} qÉGµÅ vçp¿Óç*ðO©Ô"@¸à&›cÞŠ}RcF•ZÔI0ÑØïRçü$ßÞˆœ‰1íñêòìïPŸ¬vSØ›Š§×ÓÖ™Òå²Ñåz]›
e¥ºÐptA¼/ÔäÔÀï3Nç ³ÀrGHîú@X aFcù ?Öi3ÆæúE€,¶çc"p+aª»(×çOÏ®„ö±¿á÷ .eA"—vO·Ñ¢È''j`¤ñ2•𑴰˜a¼ƒ÷õ<‹tO_Ím–¦—ݺž6çGGUž¥D(½f^vfez¨ºÌ*ÁáÑÂè Ÿâk¯"…•†4ërÈÐ;öÑd-”‰a}àÙ`Z§ò£„û7Fû\!¨€ˆZî mú›ô@F˜h,¹/ÈϹFþìo—ªšßÉnyµÊRvêùø›ØâÊT˜rñ.OMØÈáá §D UãëÄç˜J—ó§¢iðÀ",r³fTÏ›~8æªV 6û½âš×ãi"g8ž ¨ƒˆLÓ)ï’)¤ H-ðÞ5~Å‚h] ï‰N]êd®4`J1ÉÇÇÙßäÈÚªHñ Ÿsp¢öîûzŸœ¨˜äÁîmݹœçí™;®z€?hèþÈÜm
¿ú“\6ŸÎÙU ÿÜŒÜÀiÖœç!P©M‹±J$¹ }Ëx“†\H=K£'.ä >Cग़ИÀq³sNð œxóÚvaÞ©uŠ\§;IT/BÕ‹¼™,èm¿«B» u‹šçYkWWÔj|§#·Â«Þì‹Å•ÙZ0N $dä†Zô¿„Œb™c<ÕWéƒ>Ñ]À‹ˆ3eÃà…·û®b
Öf‡ñ¥4‚²·$àV-ËÌêíŽ~úfÿsôÄôg†~1ÁeW ÂS+î´dp…ÙÎ Ùñø®×tØ +æ çHÄ8]Á3È9àAMLEl_÷¨9s a^h!|‹Im“æ#e” )–ÅÙŠ¤(®“cV+’ÄPcîÔïæü4IuHÚòéH3M¥G=;P«ÜS Ú¥ÃG
ø¥‘‘Ù²tJ]`õ¬]lXŒªh—ó`ä±6¹‘^Z®1Ò7»úó›É Ä3‹)º¼¨%qI콬YȘŒ¹'ÚÁ²¾“—´L¢w©·à x¬ Ë(5ºÝ ñI(°U^0*£r4þ^DÙç(¶§Á ~ «–±ýÑ* G,ËïÊ,„Áe`Ü?7Û-ë»3+ >p½&À·ØVL#á–ÉZ˜ Vy|qMêT
µƒô®$*ú®* Sñú£YEÚD¹ŒltÆ•ArtÐò ³¹àìÎŽ5X¹a}†±î¡pc±'Vïù÷¾©Hôæ‚`M ]$É„zë—HðÒ3JäЫ Æ Š³n—¼sÆ+PÕ !cnjêàÇm;j—:›4¤uè>¸n[WùíÔ”æÎZÓt¯éqU`NÛ,•<¨D3³òæ8˜PuêWèqgãoÊ’7á‰åu¿=¾
÷’Ÿ²ñÑNÈt½†Å_£+ú1Ýc?¬ ž&âqXŽ".µm%£¼ Rð;¢HebÎTƒ«\¤±ƒ7t<Ð?I]d@ Cý2äAÉÒ{6ü Ô¶Ü)o·wvþ›w)R ÷˜–ø e/óƒ$µ°¦`@_—Ú0jw”€ÉR§Jå t éWœŠ«ÂZ ~”)¢Pº'‹óÖU)LƒÏùPC‰]ìUšwêuçöÈt:
A°g%µ>šžIĜۓ Ú/)ÛVáZâ³v«PI· ñ5ûÀ É̤bN¿PäÜÌ…¤? OnN¸g£»p#³K–¦ôµÃí[lfdb‰xŸä.ì4µ™4=É.×iW/P•æ´õ5gI…îu
2Ô6(Nµ>Õð ŠŒ¦RŒÓË觙gõVû¨î4vIØðÆùfTœ >v‘Ó¾psq®2®jHjã€`Œ¥qƒ… ÏÔ³Øup_¨¹k¹,E»R’æbZ”Þ³ÙH 7ÄŽd§äO5È4,básû¦È)FÉò¬ ÐìÕ¹¡ ®ÍÃý QøN–:ƒ4uðÖç¶æhO10佶jOe{…•NÈB-XÜÄ挙ü¡Ø«ZÃù—etCKSžÿÚ¨õÖì 8
Ð=Iã»7; ª2*Z¡²õ§ðØ
Ç6ÛZý(
2A¿üÒ’J?U[¤´ýJŸ´LÖ}µ§È·,CLI•fÑ›×ÍÒhçªs¹Lò‚ø…Ï@çÑëØy‰nnax • ܃l[ØÛ“^ág4%ƒñ£ÈÊû~SùØVꎅt1ðµ>ïºR>µÎ~N7 'ï¬fsD~õlÏ úNÚŠ9ÄüO —K—Ù*Ûr›‰Ô¸2vPÎõpj0õyøÒŸZ/'P[¹™? ¹*HYê¶E<Åšh]$ž‚¾×a<']£µ,þ »YáQæJ8ˆÙE~«’RÖ¿S¦
â=Ø+$BYÑ—\CÏ&ÎZ‹ï솴 øŽÚ§\»ô™ä¥
Cžñµã=9^AúG#}@‡ó-°AeÐ`cÆ D÷²˜ñé·ø´Ó_-½Ù¿9°÷Æ[ÅT‘Ã9kN••Ð*C¼»8„u‹;Ž£VÆ%'¢ËÈoEAjØtÙöTߺŪÑ9:B ü(³*ê¢ wŽTt{¸hº}©oŠNæà‹K. åtÓÙ“Þ½#î[Nâ‡sÓ¬ ^e¤h
–½D þŠ¶„—ÂÚ.&K}÷¿ý“fuÏÀ{Åh¾<*hû§ð):µ4 Ù€ÞŽ¨Rd´‚Ûš„
º·¸¦»q£%ús½wˆ"‡›2MíNvU7Gý_8W‰q2 äOÖ»‡4°Èf¦ðéÀ24ʸg]ööjç&>t‡†Äô
˜à=†+…‡þ"÷±HcE_é¨Dd
‰Ÿ*» /žÏéÇŸ4‚5_KáN½Ò£ù"/¸ë×Òˆ‘0¢þiH
Q“œÓ½Ä{ò™€¯éEqת e·²lç+³”@ìtµaÍŽ¡ÈÌuü¯¨>íØnLEÉ0„
,jÓÝp»7 ~þ,ÂÞ˜žiñµÚð\2ÉÃsE©ÎO/îý±°W÷2?@+WkH‚õèT=q·ˆk%¶Bûb8¶ÓFZ±+Cšò[Aw;¼éD _|¢SfÒ]•xñõp nø ìQ¯öDE uæEBÄŠ5— é2²Åx†¨í“²îÊIÀã~\
Y=X™ÏiÕ"]N ¨ŠA¦Ö@ÍÔ(²Ü³y,œ6K« "Q”ž¾GJ?{âЛ²…ü™Uá.4_ÚÂ&™=…q§³UUÌÖ ¿Öfس;N×àSëÚ@•‚–åxžYÊ
yÐë? Y{)±+eH>S–Ÿà“Ümn7ʺ|{yHš{×*c¢’ ¶óB1;õ×DüïÇȽi*Z fH2•Ä)¨íûï7œ ]i-]K;Ä&2‡üÄ]”~ÒàÚÈžCX[£Þ«Æ… IîO½dqópþn¥—#å(¸5 ‚„¸qóo “mƒ5_Q#q-l¼S¿ì¢Ï—KÄÛX`+¦%˜˜ËyÙÂÒQöa¯Së.(1&4Áì‡à3Xü™§µëHTCÁd‡û£l“˜6ÜQÐSumK'ÿgƒÄ+ß>Õévs†ìvã)-¼«Áò§»’î*€«µ‘³ <
È×Û+¾MÄå¸#EwÝèŠð“žc~¯í/Lq/~ lhªéÿ‡9ÓÉ•R«YŽ‰ ªžo×Ö<ËПÏÃécÐuÞΧÂËçâ6¯døã Bz?{ËïiêsC%êlØœþƒmÃ.V”ôAÝæTâÛ»Ú¦,ú¦¶òPèÿ¾YêO0[DÁ"ÝQÜÍ{Æ1ÌN9•GŒ RÊ-;jþyýDºÙ¡ fÈÑ¥PNN’=ŒCDé¿»>4ú=Âë÷±< Ú6^ÔÉÃ×Ãù.ì ôNXö¹à²,a@Q6«S:ùA£³ø„õ°7á,àê ]å
CrVˆ®®d{Ä-úhç Ùž^磼‘ÏnàâE‰U(®úCLæê¦\ü3Ê_g“G”œ‡eG²!Šî-)¥mÜyÏZza[À´tKM‡ÎOƒ«ª+ G©¨Š¶Êîl÷ùΈÿù·i®Ú—%³Mˆï¬†šUÔømºÞE*D¯A9¼ænæCÌ!œö ¬aVäî24XU ÅoÕ㛨P¢¤éº«ßoì³³8.èQîKÃM—™ç€åyÛÔðh3q™ßÚ!]Më”å˜ S ~¥ ôïD*”¸g-P{*0v.È.rfY§º…RJçi)‘ÁðÔx]BÅ3/æ5Ú’›PŽ»Åó¶lŒ:Om ÐÖrbánž lqžèù“¸ºJf Þƒ†²¼C¥5xÀ âÈ#Ñš¢×nί·UüO8Ž¨:ÿý§ÃÇÀØïêÅIÖ®³o )rOè¸4°Ûz¸vÌ7ñÄ4 °¨X®ñVÉÑeId[¢#2¿™5§àÛUSŠµg̱@d×ëfÜÀtújÀ‡¥~?aÖÌèœåAO§c‹¦Ý`Ös8AqrÓ6eI‹ù,ïä›!™8°õfö&æ‹s ýXÛ6%à‚? <¿Wž(í
ŠrHFPªêõÓ¯"Lì¢AQ1y5÷ê—±«dbfÔ®À¢îÑðÏb7
tŒßßÈ@„~Êï›!˽*S°–õ^Xiû(Œ†ÁÔËγ—Û
s.k×ÏܯERþÐÎ#*â]Á§ÔË© ù]M9Ú!+WŽDL |Y²±KðªԽéH+]F¤û—faõàÑ„Œ-rvGöH÷
õr>¶¹¡æç§[ŸÛÉg^ð`¾I…5cŒ»†l< ÿnî |ë!3Ðÿ‘r{Ï$2ƒºÁîû<Á’KÐbö¿žõ¤@ ¬›@ õÂêWòˆIJý£®{d "ò‚Ëaå×@žj©Ùà‹ZNS÷Ân ¾‘g²½mG½¾!‘ÁS7Ee°iO )2 ¿%þCãƒÝþl¡²új‘¤À—lB1±„Ê(y/š‰5 3j,þ·ñè§5f[í°JÞ“I¸ >5¢vò_
ëòX{¦xiâ…{Wâ™$g(ŸÊ *˜”®ÐˆAžIÏ®››m];z. ؼٛÑ*Òèd:Tˆ¾¦´ß_ÈÆH[ÍåÇÓ²…HT`£ÁÂzó¿Ì 4~
E¡¨½ØZM½7–Iæ°*±ÌQïsæý,¡^—§öx?gxÿ¾¿·è$R’&Ž´¯ÞÒD ú‰hJ¯9ê f}]_‹÷€U”˜(ÊÉ]@å{ôc¤kV½šë‚©ªuÓ©UîÛAÈ vJ@ÿb¤
%óœ[|§Ž+¥…¤šf¹ûâËs
!£å.`¹qæ’,±X¤{«O¢ü£Ùßc‚à”ÛcŽiÍÏÜÆe¾‘DS¯Ã–u’ÎvIkÆzîJPÙuΞãÏ{¡›Ó ü6 DY  CgÑ…fÖZ=Þ¢¯8¦›¸Ôj Ùc‹ËXÜ^ð*~ÞÐÚœ¨‡Òp`Ì+Φ+Èî“SBàÖÁÐGñ
À §žº•jƒÍ¿œeñ}ׄq…‘u_þ©8A°Ê;6Ï>XÑÙ@æ †v|Ävj Z¬LÎLç=T’[©>í…U •kl2]ãMS¼âðÕž8¶Ù?Ejó¯,¸Boégp³sšâ‹‚#;T3Ò²¿¶ßÃ
5ÏdmJhÔ6²#P?@ÙTþ¸Šcèi]þ+T&\'äüˆ.6"õʵТ–/¬†¦…Z¦$/â¾åÜ`â=Âd {ÎK8ÿoYÅçg-‹³¶ÌÐ/WXîŽ5»„Í‘òDL–|ÎS“pΓªä{1ƒ`HXž2kéêY ®ùžY‚0 ¾ÝIݧRNºªŽGDýªè¯üTÞWr¤÷œ<ÉÏÇGQºêãßØ zl„ç¸9fMã{ƒ%<’+šÑÈ£iN1*÷QƒØv“zt‰ÈWßxu¿8]͹Ðø\ -7NÖL,f5¸ºë ,Kà–žFV&H•êï²bž—yà˜…¶bä G ý„õ
W®=§ W¢ ©f4Éìú$ääï47CãÌfþ•Ï«V/nÁïà›Nn¢²9'€²Õâ‰'à®?Mî·vŸ‰Z×8u‰bÀYéí §Ý%²¥·ÒZTÂ0»;Ý㪄üÏE®%w~òªˆ¥
ý$ƒv5 Rhõ¯öžßÑ ²sU²0?ï{Ñ*®õrÀï“•yü)=ÕŒû,Ž¾,Ê‹èrÙ4 &XÛéÙÔ‰—]T?´KÑ$5ݧÉfž¥ ø[¿fC-PôÝjÅ0«ô¨6¹÷·xåiLÅe.K¸’Ï;ÏÕ˜ƒíêR`aü ÏBtÿ_ '
ØõÚh ®aýîT¹Oùb î cÔYP¨1ŒV?oê‹šX(˜Í£XbB©UÖŠS’†óÅýÀÎâ5vaÂqoÈG}ÀýÒ4¢ Ø `¢ß؃ÜC·Šæ±høÒB–îöæC
,–!*&–R/äZ*Š7QÙ3*Œè4X®ÜÂN¦8v»?;ÌÚùÆšÓ
:}°@¼ë\LÙžñ/ÓÍ‘ë!:’TTÊO?0!ñüûÁE’PØ`ƒ#„D&
‘F’ctzˆ¾T*!§Z Žì@¼ïb¢óšòåÇ!ÏïÓ£±£^HAÝ8]DQw ßJµ>#»•^F›>Ê<>è{;mºòT¹Bïšœú#J#ö ââIÓ(º ¯Æ¯IÖ=4]Á^,)…ÙŠ˜z9Bzt×µäÉÛIÅ뇒™ò_‡”è52ä%ú(iÊèŽx5Œšw=æÏsãò‹.E*0Hzôäí&S ±²Å¬· YpÊúÅ5Éq9|ÆXJäKWߘ(•b(ëEÝõ ÒÝÐçð—{°ûh4Z_ºqTgVdŒÖy°7.’´Š°ÉíìÄyÄçðaYÖ›ösGÑkœI6*Æ©øOŽ*\Ü£vÇu¾©†`GohL©Š6]Ò°JWãþÏZý5¶jd±Òý_ûž)ïÛ+pæFvø†`‹{ âGàº4Ü‹|CßF™Q¨xÜèU¡¶ËŒÿÜà3/ü*ÉÈò¸øÏÿ®f‘½7ä1ΡvÓœ°r×·†÷ÎÃ+?ÌÔXÙ©ô²l2Ö`˃ gÓÕŸlI—+éM÷Hö&ŒüM0&§€Ä
Êx¹›mÔÍ÷²u [j¯vjÊÊèVïÄð™EöçŽík[Ýoö¶x
^ÑÅU!±l)nÖJº §@ãËQÓÒm7u—£C&a ¿Wã!bsáÒ &kýï —¢…À›GGsæ9Æ}ÕÒÕŸœ Ï/C¤ ¿ž’y¤~ùEòFŽ›h„ü,Þþ>
æ]aȺ:²?vÁºþòÝ—äÏ Å’“øfÓÒ]„øjÊQަȥ°¥™}l[×HG„A¥çëy}ŽÛâW–Ü-Jº tÕ{£Èß+Žp“Øa4h G Æ3 åøøš¼lFÚ±ÅÖÆýkÐtûÏì%p6†3±W% äŸ×œz¦5Ù¢jðžc>HËh ø¾íÄ ?=üFhà3%T
UÁ 3kk¬àÝ óàÊv}B ÇxUtNP3äËÇŠÀÂ>pö=bO~âñO,¯0?$™U¾|×`Ži0]ÑTúk5}ý¥WßMÛ†ú# Mä³ Ú\9{–K ¸¨„÷©Cˆ„ÌA»Œ¸ …¡-&UDãî©w3)Û2О˜!öÅñšd…͋׻«4 kmE Ndæ!}þ“6},ùÖš7Æ=§ .UôÜ ¬´4P~wáÞ½®i•²ïâÅoåhvøgq5/ ä™
<:ÜÅ×8À¤å{ì…tòúô«Z`BMÿOVÌÖ/¡fKƒ!ªEújŸ2ZvX2®LlÍ¿ßÎzî$K?Ž´ä×(ß’¾àùž÷¬'íã*œ %0>—ܺ²>#Ü„Úä7©¶É⿦Rî¢ìNBASjžÃ, ò¿‚ª2y‚'D2i
!”H!Ü×{ãÓÔ¹ïŽ,’7š6c©Ë3J‹LkÕzE€€ý”¨¨”ϲÿoÌÕ4/VàÑ®àì~ìý½¨0@ÄbºBgl6`s6ó”ðÓD`;O=³¦ŠÙXQÀœ˜ùÎ×3¬3 ì–i5¸&GÛQræÀzWbÜ“í,P„‹IÈ„` ðO,uùÐ7Õ>ôTj{
s®ÒسMß%Ù"Ø<À÷°ow \@Ö/“ó~ùüÂÞì–ÿ¸o
ÿ&áhè ·Ï’!1[(å-Ò¿*m^ÞÙ²×Ùš\ñãËð꞉R¨ù‹ AÃâÚ/ |ל¡e* r™éâ²:¯`Kÿ8¶5GaKt¢¤`¥Ž§Ï @æµ>ç)+õ¼Ÿ‹l&×>F ‹áÖÀ ùË YÆ-1u( ΀ú#“Ò_ß¡^xꜚR”
¶$DÊŒl¸ñÍÒ÷/†ûÞ›
Ãáˆ×ç×ÊmƒéòvàKÈÞO%orGí 0̉•½\ T2"à³gÛ§£ÊÏP$BÒ;mFšHg`ò½ ¤Cäè«W ÀepÛ
8,{ȵ}Ø‘íÇ:'š•jüü†ÌHŠ}U¾{QÀƒÝeHå—Bh¯O\;[}ëÜŒ ´hû:QÊãù5ËA—î0]ei±Ñm¶³nEÄ ¬ø…1ëû¢-žÁ´A¾ÁêÒ}Ù‚àûœ£éþ AÙ&©!?
&OO8«,IÐÔEªWœ
endstream
endobj
240 0 obj
<<
/Length1 727
/Length2 23167
/Length3 0
/Length 23754
/Filter /FlateDecode
>>
stream
xÚl»cpfÝ- ÛvžØ¶mÛÎÛ¶;N:îtlÛ¶m§“tlë{Ï9÷œ[·ê«ýgjÕ s¬QµöÚU›‚DÒÑÁMÝÛ ÈÂÀÂÈÌ P“Õfaff03²ÁQPˆ¹ Mܬ ÄMÜ€¼ - 9@
è`a°23³ÀQ Ä ¼]¬-Ü Ôf4ÿ4íLÌí] šŽvŽ ÖfV ~aWwFwAÆ© 7+ ÀÂÚSRÖ‘Q”PK)j ¤€@;€²»©µ@ÞÚ èà
¤X8º ìþã Ì Ìÿ…É•ñß <€.nÿ ³pq´(H¨‹H*)ª$ĘÔÅ &æ yé–;¸¹òþS
43õú×tô ·ÿYv&ÿ³Lÿgý/ëâõ ‹Ž…`nmæ0ZZ;À1ý‹7 G çÂæîNÿMýÈõ | ê8¤˜-þ©v·³S4±¨Å íÜÝ€. Gs ‹@ÔÑÎ áåt0šÿ·ÚÄÞÚÎûÿ·þÿTȸ™üLjƒå? 2ÿ'dí*ií4W¶vû‡r »¨úw\ øŸýùW£ÿ¬þ§àŸ}5wt°óþ?
ÿæßí˜ÄÅĤ%´éþ'ƒ§% Ì Í ,jnÿ0jâbþ¿À¿ÓÊ&ÖÿÑСüWS –ÿë+˜¸¹X{ô˜ÿ%æ=ÿµ þo•¨¨£—/++€…ÀÂÅÆàaãñÿàš¹»¸ ÜþMû?³ü×ÿ·œ€@/ ÜúŠ£_˜MzKDy€Dá\$ÝÜŒ±Ý
èêtϵ ªõ•¹ÑŸK¼;u¼Ø Ö2U¯^Ío³—pdQË[GW@÷JzS¬…&+ªüþêÇ Èãû➶tr–ƒT:'!³!àÍ"u"ÔÊR9 fž—Éõ'cµ=’øê]—2xJ¥"@ÚOz·5VæÝê¼õâÒ…zÔß—´u%
c]96¤Cû`Ímê·UIp‹ÆÌX óËm› ž×Àjwð
n!y,Û€Z Á¥ÎÀáãæ…Pú¹m_lµäô¯5è‰K4&x Ž0ƒx¡<žà+7”áË^~•"¿ŒüéôµÙDze²A8Ç®¬ À혥¿¬×/& £
vŽŸŠ‡TúS’Óˆ9Zr-úG0;QýeHÔ?—‡§9Œ}}©…& Á‰ ȶ;nn˜×‰àe,¬œx÷Ä•¸Àlñ¢+,D~øÇ15Á$ä"tpà:rš Ün#n;%WqB;”»‹÷X’z*ͦÁ„‚ÛY-d³¶/y!ŒxK</¾=— kœuàLN!µõUë±AÈ¢Y1õÒäES†!‹óJs„Òzc›ÆË”é’ÿv·¯=¯g¨ºÎkj¿Ì‰[ÕïìZXôRx‘¸´=ÅͧáwäŽ~ÜRœî2\p§cAÙj(3V€íµý T „™°wdDRF¬r‹±ëvN…°¹tê߃Ë0Åh¶´Äµë›^¡X ÞPV{ßk·—ÜßöðÈþĵ/“Ù&×s\<â®õLþüí¦‹Ks1¶Ç/ªJÍaât
äû3—ÏsZ|ú(¤‘õäXÚÉsZm«m2 ±ºÃ i<ÙÔ‘5ÌßN&ÚÞ
zúL.ySÜr™Ñ»*Fc6S2>sZ%†ª{:Ý2ûgJ«7öjòÕ»…7Çê÷m wÌ c–N§‹’9=UjXOž \’‘Ø–Š•§4íÏ¿ÈéôTùâ§xé}(ò`¿×l¿v€±ïXÁ$bõ†A yÝÃ* ŽY#/uTF‹t‹Ñ pbƒ¬÷eƒWrRQ«f¥¬Úðлrh¥>z.ŠC}¾Ä'hô5 n ËRân^ºZ3ÕÏ‚îr1Ó
ú"n$)jÁ¶¡÷·dläÒ[&Ôf˜ý0írZ¥D¹ì%ÎY#KV´Î\´¹A¬nn uµlà?³Ø~£V‘Vý±•1ó1Ðd†ÿL:«²Håø\@˜kc@Y]N´vo
Á¹³pKiS˜ýP½0!¾Ì¶%dÿJ¯öã* ×Ø%L{\˜»³óJsãÊï;ºþ(± zðé!O
£ue̬Tþ»ð šC± mam¿†½L»«¥ê±Š/í•1{0¯“óÃ|´Z˜ÙÇýë1Uk¼v6q…¶áã7Þ]»$ŽÃ=e¢öÀ}ÍíÅÙV2:1 GoP1|ÛKd¢í›¦Îáõ͸g [»p‹Ð;N ²èß³Î#\ê{žfÆù kO? ï‚êú‰ %Ò˜$7LŬ°H°îC!Tåc?ȇUfM»ÐL;í |àaÚŸ©# ²‰½ë 6fù&vý`¬sØ•èÕü«3;¤@îöŸåZ»îÁ춤ê³5ŽŠrÈ®¾Ögp&Ùñ—Ñ€åÂl2ÑXð‹>Ò>48¬í°O¶“ñg!@?–ñR%!Ö¥Ä5\V¿rê
ÑÛué}•j7ý éi6ŽfU‡VHa‘¾7ƒûLi0/A!¤¹¬Æ™^þÞuÚâ|E¿f¦±·rSÎ#™Ô`¬Ë“ȵHíÉ·Ò_ºTÑו¹o…ÛÍ“Óïëðv£@óÚ¶-¿ê× B>5ð§ßµbåRØ´ËFZ«‘Ä "$(‡NЮ='µ& öî¿™ÝÙÝXQÜ„@ aD„·\÷\|‡‘ú63‘Êâ‘] «< 5uƒ"i3 RêaKH?#©ÅÉ[ Ð Ö‹¦ ”%j¤!º‚D‹ Q/CHâ@¯¬‡Je\j)+( ĪùlÿÊDñÈKjZ+cë¡\KQúaE¢L`Dìëx3±ß5þ;·ð`ÄÆê˘)G¸ôÅzï:My+!µùþD3ºf²ÀÞ¦Pþ¥3â>:woåƒã@⤇TŒÏ-Ñê—;£?m©É¯h*6"óxmÄï 8¢l5
Ô¡<œ
¦KÚ'œK)ÍhY”ý1CãaFÉ:Å_ù¸ uJäqñÝr ŽÀR|Í=«´Ê6AûÒ«¡Þ Ö¹aWWõ *fmFl^\TH µ;ÏlK¼
÷ÀnbÂ'‰¯3xª©L1ïò»˜=
M®÷<œáµZ¤‡Ì>×^œ¸Ñˆjã™]”-f¹I³ó^ühTCúKYC¨ÉÃÝoiu+s‡Ü.•7
v²´ôAâ±6Í`+·¥å¥j°wYßLë`‚B'v«y2EºÃ´Ï
¿Ÿy Ã'“ø3#WM÷˜ÑEW·Eï™™bZ0½Ê2ÜðD-²Q\³{{(k]Ïæµd.éè8Ûë S–ÖÙháð‚ö‹çˆ?•?/žŸéÔlÓÓ5$±„:WX²d›š¾nYëdNæjÿ:U瘟¡$Û{UæÂTŸG"ÑÊÇ«Á³“¢T±o‰p‰¸Z¸ç ׎q™©Ê{ÕáV.áÒÔš»%el\ ® ¡CÞPvÃï‹=ªåpU‹]>´½ßóBá[tÒ°ˆEfÛCË~ìh(ì*NêHh€ßà ª{Ê8>m4Vb¯bæRp=™ßš¿ŒÎü†a¨ÊE=MWsÔ\E2§)®ÔËCãÊßnVíÙý•@jÚžËÂ|òÞ¹»MÐf{C&Íìøü‰|™ñ’çm/¶ä˜ÉQ_/cÈëÅ»[Ë-ê9-î&Kª Ó@Q÷>ñýc^tÍQh“câ¹vS˜-oÎS`úg²¾l¼44!\3ŽCÞ7•”SbÌêz)9€‹ÔM°Ü"1ɯR(E>*< Œ)®Õ“´w cô—D¤ªFšËõÜl‰ !J;½®²ü™ƒÏ¯løèߒÂl¡;„•}3 zJHJˆ*µÁŠeãh
Ä þ£’t\Ýß–ù!Q»XŽh¦\`J
’éÓ59WŒÂ ‹æ-V»FøâF9ph(}w2¹õǪ̈s $f%&-žf)£ª¸¡T¡Ÿý6S a¶[QÌF»¾ön¾©Uýð
»É)fvO<ö%ϲMv™ÒA_ L°.šÂÖ¶\ˆÝÙÅ\XÁøK^ˆ…¡?æ}ý` ÄÚ¥Év“o=âeÒ2;+X·ò%wøPÅ]©q ) D¶†°smŠ÷$KNNlx¯ºä½2R}¬$Õr}n©¢Ì¾D•ã¹=¬= (@ÅK?LŽ«é?ˆux$ý%T=ùâ|È+é@4(À*wx?~þ0àl]d }ˆ•Ý®Vû«s¾{ŒÄÜ¿xÛ”p !¦ q‡ ‚yÇ¡Û¨÷cšñÁ ×Ë=NWšøLd»#:-æ’¶M.Äœ VáU™y*uèmŠ7a P¸ ò˜O7‡ÉDzãNÝ…8t/gÏzÁš qôñ"ip…ÊCêói©ÙÃ|ËeLÿVù-ŠF…áuOÁP”Ò%ª.þ¸kàšP8ƒ
µ`ÿÂg¸ÂqÉ‹*ííõÍî2¡Pc`B +€Yª1)´9.™µ´îgÇ>!3vôr‘Cí|®òE† ÎK™¤Ó~Tpè7mt™a!NÄc3¢Q ÜBùÅÍ7HZ;êR²õ8F»¹Ü®ã Òmö¹*J,/×ΘÇ.Ðe¬‡ÅŒË
a—}yêúñX A
8|ü…ˆp}xxÉZåòí8n°eEm.p•Së8†H²é…‚3‚[Nµ
¶½Ýcñ HÄåžöʦox2ÏàòÃåXdz†
]λ¢Saãºip9{1š1¥×Ï Q??ÀŒ‰2iÐؘ˅" S±8«!ÚýJ.Ú9ÜtÑëúˆê¹÷qK'Éåk[-‘“ Gªt—¬WËK®çèÌŸY¦ahZÓŽ /,,óŠ: QÜ°©S¢VŠZê#?çq F™F½Ô/’©¥FAâ$¡‘$ÿ´µccKàË ‚È™óêYå˜òÂ×Y ¯…Ú/ì
²ú}_‘ÍŽtƒ%‘>÷·;"U´&ͧ!p}Šéiu¢û?ëJÆþ| ¦#®òia¯;Ló“·ma/{&àT“´3 ‹c rÅžyNs¾pÁ×ÒAø0+Å΄Äq xV‘G—<‧&¨°)(B«)ÆòP,„‹¤‚ T>»‡rÉúQ’ÍÔÙé´07û¡ jw¨iUWZÌ ý¡áÉ}é[¦›ÇÌèVg¬\-ˆîH¼SÁ –F’ãØãòøY¬a…PíÁªƒñÝS”¿s/UØÜ|pÚ5Ab‡/ÓõÍ•ò}®%³W ¥XNð‰ú
͵M¬efØœÿ .0Ë¥j+2Ëù»¨üù//œ=¼+aöò¦÷§VûûSÉì”òØ ÁQKAn²Ù¤r*]Ö<µ%Åw¸èd¼g{Ä>A•É[YÙ¾Ú|oá€k'ðŸ XÔŽ)Ú̈òã…õÌ®wRX7¤%¡ò~M-C<§HllëÐwë4¤(GB `YÙtõcd×[^¨ýVTB ôº*ì“Pƒ1Jb}?F[SÍŸìŽ 14rÈÃB*Þ¼çvÄ›Mz »ì6
uüäÅ¢>TksŠ¬eËç hànŽÂ4•~hî^L>õkF˜ú š3ll¡‡Ÿ ×û»0h~²±&c³Fº 6Éþ~Ý3»íR_à&YPŠòªPÍáò‘asÊàæC7»+~½R¶I7
¹·ùxF²Þ²˜Æ¹òvëŸ+rK)Kó‘#S|¯x>>ª´1tªD–šÆ\øù„Àôdö¦Øöˆû¶Ž€R:,´Ã Áôhj;™6áÉxû:øLúsä$ûJÀ[–‡=Í8ªfEKƒ^óc¿©¨Ûëáó¸x Tö…#Ý›°ÍVxFUÑîB _Q¤ù¦FˆŸJ÷j&c¨4¦xTð =K,+Ö©¿°iL á'±Ä/N$w˜-
¦‚Aˆ{‘—J©š =›±`¿†+¥ ™û˜ú_òæwW ½ k¬‘ÙYM¼•,ª4¿°°¢³ì´–äý²cr<ö/73vLÃtå1Íð)ÒÈx߀ÀÖaÅæY•¼ë£¾—(FÐb¨dÇYЫB¬ñ 6„äη ËƉƒ”?òšÐéPª;hª«§ æ:"ëˊϣʉ$N¯‹Í_,4N{w¾?ßxÞ Ü Á)éjR¬”y Ë2ž¶†Ž{pqH®TúœäY,÷\>ЄÎõT>º¼æyvášY<·D5<ˆïòœƒùt…þà—á`™7%ÚŸ3z3æÕM‘¹¾¦ÈJ×ß?EA0“Scˆ:6à0© ù9á g æX›€ì·¾E:[TÞ.©) XÊîìbtÀ ›RTï›ÙD&íbMˆkËl¤Ëp˜ñ‹éU’&æJÎy—^x7/gëéè]’ BO¨yʃlœþ^º]h ^ôÚµDùJ òN#ò°†Y<7TÛð›l’#}‹«ÿ²§ç–'¬Kó±ôýú+Uö×(lv„ ?s:è¤m–¹"}› [*»’¹•¦÷+ÖHT"ujä@|?-Ÿ÷A;§R
cx¼®_)ÍŸuøýµœuÐçºMf’W¬ ƒ„Áð¦(ZLû?QÎÑàÃÉ«xËÒJ’
Ü'mxVË™]çòûãP
¡ªŽC¬('äšÏ†ý®¼Yû¡J, $5P»q«fåÁI^ú7Ââ C·÷ô”¼ ¡P7†+ÌÔÁ/fÊl2-":„É¢êS=i÷úÅÂt
ÐÕža(“´w7>¾~皉Èôx|8¼‘ˆÄ>—¨E>™Á¢«hº°†ÓŒ ®«
åh0Kåý °Ùža ÖÕX]ªz )ˆÇŠÂU6‰èÕbs–= Àvr¾¸î½®z$‰Åñ}Ì–¤
ÖÏ ç½ CâÓ‰?®ÁxGå¨Û`K)ú
¢œ‰;9Ön)À™ý¯C …Æ¥Q#cÂVêUЋÓ-Æ·0
Xd% PÌø×ø§>è çÝÁ€¶¯P CÑEšâ n“x xËAí‚®÷Üvé«JÛ¤Ÿ ‘,<×)0,ªoঅ‡q³eCãöÉí:å29à I›<•³Ðco!+‰ÓZ V¥ñfQâh`îï âý…ƒ|\‚©û/(|N0T¸Æ Ç:ÃNý A%$ïO7
îjÃzx?‚l[£Ó‰ìAhÕ:ùmûèmSŒ§ñƒŒ9(ç6Øâš¹b€#Ð
›§¿ :22é‘óÌeUn¹¯°Æ—jG]&7øBª7ø+QÛJÊ# ³KûVFR’\Z¥É¾)ÜnBà뱎BŸêüž õŸÛaý‡fg &¡¨(”«0Š+õ_D’&óBý"X§ß¥S´Æ éÌ]"§ » 2][: J Y¼k4UæÌ‚ˆÃ5 ‡j4¼‘&a ö×Uƒ¯â³üx¦Lb
N@/W·¦&çv*H´•«£9í?ÏφÈuÈÍÉÜb‰ù¸ºìX]‡§À•¯Â«ñ Ê(—í¤^x }PɵÜJD iÊŠ¡xÐûœS—Õ
Ü÷Õoîd½Ê–PË
¸l°zøiéz9Ê‹Õ&ÌÌؼ4Opý&{˜´Ÿ‡€pÒŠª*Œ',ƒH4Q¿COf©ÐM¶ÝTüÛå‰Qv)µ~3ðª0ÿ+d á@̬>êUÄžúŸ3àoýÝÐ "•–x!ˉ’_zC½cîgæ-È.RÑß5wî/ÓX«7C$j‡f¾àFDjÒE´l!n7”¶zØþFÃ
—gœvòªGÆô¬FÍ02¢&7?Í0e´¼¡Ó*ÇjTžø© ØÇÒOJs8ÁEý×@‚LýP³
†‚ªC.,. Ü)EÔØ|Y²ç¥_¨ÒMu/ÈÖ˜'2ä® Èn Å‹ZX½Ñ†pùRŠ[~‡Ã“XÚ—èêöbôà:¢[\vZdá ý f®`tþ½ØATy>ñ¾>Ñ(£
@O /x:˶(Ý'Q8ÑàÝÓãÏ €š¦ ¦=`ÄÆüxñMÊ’ÆjÔ¶‰ûÉ¿âî?ŠPz£‘ü‹©Ku{$¥’ŽÌ–¬‰á̈‰ às~ TËÙž¢Å›0½‚®©ólÞ5î à©’¿õTVì_ëÌñÉ,ºoþEÉÞbν½ˆI팟wøÇÑá¤=ò—}“[ ŠôuUì);džR™™Í'nØã! ¸kŽ÷ Ô(Ã%.í [Èü¡\É6•¾àö2áyaæ+mýçÒŽ€-§0ödê¡°b ‡Gî‹h’÷©µ$µÚGjP¤Z“ð tJ ñ
¡×›q ` »±ª” PA!@¢Ûoi\’B
Q¬…§Î
½2¹|¾GzÕ
ºà0°°rsù3>*é ’ø?ÿŒd„IC¾.¶ßŽ
Ù°°;¬û¦‘l t¶ü +k“3ÜÍx>ŠÌ›äÉd²a&mk6 |½thl¯2Y7¨Çg¨áD-Þ ºu?©d»<¢6Áª»d꺨Âl– jºívÃôá9xF¡‘¼ŽHÑøÁ7åÃn)'…aÛĘ̂‹-ë !†òNu“ þЀ)m 2
\~xqf¼ ‘á‹Æ`Üæ éE.ˆ ¬Ëv,1i²K'¯Ô-©ç‚VY5ÓF³êÓ€¡z# É›x4i¹‡êý”{;~,F’©Ÿ€w'óÒ;û‚LV“ì>Õ-ë_£~ßùc,‘ZûO„½þœ
€$+G`¿_¨ž ¾¬ŒãûT‚•jî#–¹†3#ü5‡¢
y2–ºRÆ$Ÿc{¥Äÿ <
\û0/û}Ö<9Íÿ3ÉÎZ„ø@ð !–òæf` À¶ö–\«ÝxYl‰ÀY½5½Aö·qmãwUñ¹$]Ì+æÁ²`² žï/.ž¿ÕF]…•CÄcÌlÏæ—¬·ß}[2L
,a”Ÿ~Û§°Ó$D© ‰?²º<Â\äÍÎ--V’<:‰Ý7i”är•ÒÀ×ÔãÄ\°Æõ-þ´ŽéB¸qònÊ
ï€Ë ñŒú_SMgOúv{n»H ÍM³~ÒÆ=5Ï¿–‚f®–t×iÃ'Ã}¿ê¨Ã*s8{Ërýzq~
µ¸{ÉVÈ!÷NbnÕ¯)ƒr§ÏÌå~ØLÉyw!ôÇ(¥õϹp `{T¨YÿEaÊÜ°6\L –Pwþöz… §ÊÓïúK -”?
/xÉO «5ß;¾Ðu‚A-;ƒ\*à‚f'³9iÒ"þkTäÚw€ÂP›µº ÚûKCU ¥0éÀê7åwwn™Ù=ó¼UËŠ†iÖ›0ùÊÀ‚öŽ x\{”sü¸Õ¤á‡Ãã‹ÄØ|2–]¢‡#˦è^QŸYÀЖúýdò[§AN7|3&å/…ú@I‚”aoîÂ>d𠟆˜:”MhL6ì½ûžMó)<ô R¼´ ÇË
ì¿‚çÎ~®³ì·¹uØÔ=ñH‚”ò »&±Ã$tCEžM :]1¿?XScï0‡×Ç
Œyg¤@ÇYptR,äÿõöGž2z׈+-D?·%xu®ó«)–{ï;kÝ‚Á“¼ò¡ˆë ‡°ßljÀmi bÇ0‘¬ÔMsåø6ŠpÛf]3gÝÒkì(/ ¡B³šÈª..JŠntö^ s>%^Oá…¹æÒ6DÀ ÞIÈÕ.½á¢Ïû ‚²šb щª•ïj¥¤'’½x×ÆŽã¯ÂPM”³ Mø[×2}ÕÖFöZÍÌà0ìÙ’¡›tqž ËM‰b&ê‰Âá”Øøëkàuœ0oö™ë¦*4 ¿†ßðˆëI¶ -/®.¶Õ>R—ËÎyµ1þïø½Ç6¾'nâÃ’¥¥á™Nhú ê þ‡Š‚ã”ÚWdž– ‰ÌxÄqº+À¹©µ÷ñøà±YÐy‚rž,ˆÉ‰´1¶uí~:øúx`$Iàuà
ɾH2k¸ %²ÛÕWÛ)"ˆ/@6CÁØs·Šøp}ýÔǨUbQg.†X
míLƒb5mÜÚÄkt(
Z¼ Þ®ôgòý‹›Íwøk˱^MIÁ{† éúûÞ–¼.¸_ÓJB$]VÎéÒôëü »oÍy}žqÂGÙ2Hœ:޻὆¿eçÝB \wd"¦@*Ó¼Òž«… ùóçÙê¹Éªøeœ|¶ýŒ?ãMÖ:™ nýÕ!ÓiÑgÉ5xZ¼FG"s»§R¾@|L¯£Öä–LÍA"|ÔM†¾ØÉ’Ïï†;I ¼êDEA3»4MzÊŸ2Õœ1ÆÓ‡åíØORLò*Ò(V‰” —•éÀõ"ú î_úlÆy3‘c*·X4rxn734Ç" 3BÍÇïN#™„ãÑêæ•À¤9…˜ßýiéR.tÃX£±›œÝ':ožm%ßtð™SÛ¹èvß´9#]Ü52<Ú
ò8 #" “Ö#í{cAÁËÛÖb¥ºjø¾kö?[ýŸ²²õ á²$òŽ\—æSY ¨úòÚ)aÐð6¥å'Â@ž2’ÎH¤7ûÈWou‰w-娈ΚŽ™N«u0_\kN¥H#>°]DÊ#ˆ¦ÏwµÜ2èP¶+ î«BöH¨Šù¤tò©!%x¼œƒÆó—ikÕOJ¿b\æ|–BÖ±¸Î–€¦Už¬Â÷Û¶ZÍÜçXÜœˆ±LDo(Š·èòô[ÆÀÈúÁû&õ î=J¦¡|Otð¨«ÛGWžÿ8v:4|iÛR|PÀ±Ýž™ê ûcS€Ê•FCœ †£f»õyš¸¨ž¹x㽋¢þ-Lnö¼‰pìqã°7ŽÖèrÿƒBù<…Ž™
ͬ ú…ý¹xm@‰¥åÁ¡²ôë$³ç¼¹¯ã=»“ý]Ï©êU“NÇç@üƒ¼¢~‡îË“vctWåÓúŸ—Ë
É0 ¹gœ¡6û–NÙ>Z-ŒˆÐùr·-xVÝ›:Cª§7(ÆC˜×ž‘]:9ìÅXÇVUíO=™V8èàbÂ5ù *´äØÆkÏyYeàÂóÅMlRÙSwºÛó÷݈¤Ìd}€©¯ÕPÿøûåò·•gÅá%
±´•
H*&ùõÎ| °€+á£m"ɹó,ßÇ° f Óµ¿œß% ÷G9…UÔŒ`ÏOŠwÉh9°g
Þ¯üãMd•€½x K½Yað
qÉ¡DÙfïaHænçN%›1ÈniÆ„‡>C-ô¢÷|Î
Ⱥ9UaVì'¶´ðtÎ&Hdˆ4éÉKŸËe–åÜAy¡„£OrïNÇ^á0xöÆ ŠÚJ&Îh¿ØÂ{-ZS ]
öÛ“ûȨ Æ%/BÚð^£›Tš[žVË sJ@Œ=&@zO‡h®ÛV6ßÃÑãøÃewbÿí(íýª· §ÉØš¥³' ¸²?!=†½Ö²¸A €Â £pîyËÐ*ïŸÀç\ú‰É³õ=Ý«Ìê'âEGÑ^ÍŠ³¦”¼‡’;¨¥n6¢
ýY·!™+û™%/ѵà|³¦P … H'WÕE±{]#žè\Ѷ¢9¼êkm³ 2!’zNÇ–9 £Rÿ4TÕH»8d|·9ÏùŠbuÚ*¹õw‡Q@é5‚î‹Ú)6#¿A-ºPÿ(¶“—Ž@=.ìÒ ˜ö‚ýñ¹« ;œp„ûÎpu‰ùK°á:ʱżpŸ_Úˆ~ì¯ÃGœÓÀO{ÊÔ‰Æ8TÉS»tqôâ±ñ¥1#Ï …¾Ž¡^Ù+¯®Îþl¼bºú
yî$6zeò¾·%F+ ‚Tg£’™„h& ? ]ª±„™ h°'1ÌnZK0\ek9- «µ|Áw#‚1÷M*~› ¸ÕÜÌY¬Ÿr{ßt|À¿n»SÁôF&]#ûIó¹pÍ$|JÈ 9:y¸í™Æ›a…¸©uš† \µSÔ±0ž²ñ’K¥áDy¬íï<Ÿ¸ÝË,y™Þè5Ø
g
eAñc&»áýÝàŒ .Óî/Ó.’»3UÌ¥Òt~n#\õK@ABm|kRâ;ÖÑ6ÅVý2ƒ€ëhÝé¸ÉÛ·4¦ªh“¼ƒ6ÓUã¾É@
-¤„ñe IšÞdd‚jšÊ¨¯Ù
Tòu˜ws+ÒÈr$÷¢a ý SüM8îS³šÍtš,NÀ"í ‚Ña³Oc5yù2òÅ1¨&úy¬çaï¹Ôø¶¬Tw j¬Iù•×+>nþ¦–}.»èßèð¥ÁMÚ ½+½àPUk9ŠÏýkP^_›Ç;§Ôü áUëT!hàrTþªoÿ©Í[
д¯ `ÿÖ䌴}¯"cdvÆ æÃVù³ý€-_jÀú!´¸i&ÉrENO‡MYêhÙŒòÒ!Pny±õ³Wvà
8‡×‚¦2‰‚6äÁ60™L{|e7 =¨"øh]ÂvkËà ¹G¡Úù8x ‘JûÄÿÎþla.N£é>¼‰nã
y´æ°ä UÌÀ‹_™!˜+¶7C»dûóñ÷×NßÏï/¿¥?i dzt'˜²×ÞŸSúŸá~+9B³
ç|†S/z6äcÉ ÇS‘‘¡üíL\ö‘lÈdçö˜V>øŠå&ScþöG˜cÀ|\Aôïì›[&vâV…ø]‰X™G@d¸*×®
™?ƒõ1ë¨XàŠø3D)Õu^Å à
ÓY‰ó,׿ŽT×6eS,“
¹T»Mànß®,Vé;!nf™F(%…!™¬DRE70Ýäzs–äeÄ`b(7ú5Ý(7!Ö÷×eÄSf0 U’Á5‹Y)×N)ÍfhhÝ·Ö Iã|êÍÒ™ó,\¶C= ¬Š|zÐêÔ[O `×EØYÿÑŒ•©T•ÓàÓ¥å1ñËËÖqÞãÝ{¸Š¥/*[ök8+
!3•i >êOÒÿ È‚æx
m–Y‹þH*$¤Ùá›>åúP=fÐÓBV¹Ÿy 74erVš9þ=Ro‡ê@‰¹k q&™ñ('
ÑPY_ £Ï„ë¶MÓöð‰=xØeÄ‘=Ÿ´Z}$ýbƒˆeZŠß¾(kå‡Ä”¯9tmùî0¢Žµp®¢z®BI߯MtUZýWðˆ3&×>ãJûJlùáÖÿÌk=sóa¸‚‚–¼ô*v?o‡îšý¹O
ŽF5–\Ƙ|S3êþ’›™z¯„À¸€° <Ë¢Ws•hd@ÈI*Îl7Ï,ºùÖ«Ý= †º¸îò~ègA~°š‹€v«ê4˜Ù>0.³‡É~îŽ}¹‘0Ñé^©F÷etŠÉѺ J ¤S£qó¼|›>ÒxóeÙ/xÙCuÖc¢š¨ú.ZÎè!òKï—èMmà çÍà|ˆœM"£0·æeû}ôYoÚ4¢y.¦›Î&Vˆ†øü‚R°“#0aÒwÉD2DnÂ<Õψ`ï Xuv€mkžá o l€T©½#Þ3l`__B^ª·µž!²JÏùžóUßk=ÄÅY‹ýð|Ñ
YðдN„+EÏÀ BÇÎ~n£YÿÒiÏ$‘™‰ "eúËB ÆÅШųUö[Åîƒj
§¿ ?)–ßô^iÀJpúlå²j¥çjÝfx ¾¼Â¶ä0îtßn§ê¸Væ/—d#7£`Ç Ñœ…€6‰ü\_”mqNm´Ô/º ¿²iïž®Š¢7 õ¦³ñL×yÉ F ¨ã¡î@±Ì3cëN~ñ‰üN{´°]‹~"Ð{Eô_óU(ìIÓnw=Ó𠈔Š:”ïÆ$1C•ü› Î3ó¸a}"RGɧÔ~|ÕW[¨ì‡ƒ ýaÈœâ dàµ8Ábü‡ôù‚6S¦)zÃf¹›;¬©mä™ò2uÉö^æMm#^Á÷Ϙý€ R É S)’` Ìή¡lz—cý'lE3®i”¬ú¶ÏJ²kÏŽF ˜¨¢—èUâ8O96·S/wuÙLK´ð–0>€’ ’ã Öº„‹,EYVbcr J.xD1+|Zñ1Ž ‚R°Ílù G¼¬`7²(ÂV¢É,Ó BDå‡7ži˜¦è}¯Òé´ì áŒÎþ?
˜g§-]j ¡qäkCA>÷,ÊÝ{ªKÃçI©ÆÉ]àÇ!“
Ú ŒZ#u>7ÿpV.öHtCŸwþFóªEÖU37ðD4°2vça, ²‹RÈD;Ý£°²^]ž$RºiËîCb8VÞ±}çõcÔV)ÖÌÆbb–¸m Œˆn¢ÖªF‰PìÐÚ|êVäÚO:5n‘›RûË
f õãûú›|nš¥)$>¯Qõ‘] *xëšñ*õ:‰¢AètÆË‚ ŒWý²ÈAjÉCfòŠâÿý® i¾(š!8
ZÞ.ÞŠÛb½´Q>÷U³ýÞš®G
`²A« þXû C¶CË\LâÜhÐ7KDñ_ýs§”KòáðQ-³b!Kc$Ž»"6•€.ú)1e´A?$^³xnžK–ƒ}(m#ð8Í•jz—´jžþ™%¶ … ³8Ü uÚá’¯¨¼Rs;öƒÙ†q\Š¨ê7=˜Ó¯“â#C½$±T¯´'$›ò-MO?aDTµi˜€0tF¯XÍs¸j’°ð¸“ý6}â£ë|ÍA9_MC¢ÛA¿i%ñ2‘ŒE™á ŽN›×…Ö ç¨Úr]Ù´‰ú^¦|?œ0zÖ\¦‹ÿê¼^×›î½ÎšœÂ| hîìã""j<õ©âwÉ\¶‹,ÖËAÖ Ù&öڃÔ8\VÏGÕ×â?þäÎm¤Ó ± ù£}³V$Èî¿Õ4¨œÕ„<1Ýc*¸mP¡!°×¤
ùØøƒQù£E€gKÉ/Ü©7/&Be5øÌ&mÅ_ºdí¯ŒCÈhIøÿý á庋D¸† ÀÑ–lÔt‘Ee6ß©E\£zÂ%•ž ¿¹ð3oü!|EìÆ%7|é…ÔÓcúC%^0T;õ´Ë¦iN$‘éô`É|ÉÏ·CJ*ÊžwEèÑG‡—¿`QÅ•]˜-ʦ”˜´¾>9T1¨÷÷ïsª55ØM´3á¬oïd^ÅÌ_€iÛ6E5w
n"lïÃO§~jÔÆ ê2 تê¾4WÝõxYo) è§ü¬2Ìgüòé‚)ªpx‰wÌáªÛ‚5õÙ9eÖK
²9é/š Oì 5Õû¼Æž“f&þe—˜Z¥²’ Ú»6?„¦[LxAÉ pÂõUµZÓ`ñ&[ŸfLj ÂrkÑk\Oì‚œÇf¶.ÿ9ùGï*ßÀàëN 3Óèâ£Â ƒðt<ß*ξà¨Ñ µ:¢d*TÕ9jx ÅEvjmªjƒ¯?ï7€,§ÀÐûÃ% áYŠ°ž Â=ʤ ºó{‹º®³o7F`TŠ@m¥–ÜÝ~˲Weƒ=‡…<£êë‘ô'9U (ä—µ^ò0f³ÃJìáêÈ*WIÉ[Ók'wM ÷š˜Œ4ñ
Ÿ5‰Š ›¢-Z™r_[PÄXCw]ãL„†þËõk'§iSÏãùp\Ž’ >ˆì.Õqßc
Ó!M]í›Ìh× ÁñQƒ\oÁóŠ²ùAETˆÔ˜øTô,þÎD=8Ô}2Ë8'Xçä-“úkÈö|ž¯"ZFá %pxˆ Mºñ‘YŠ%ƼÂ'eôñÖ ¡qP=é?ºTbgIÒ.ÃÄÃX uÛÄ#ök9ÉúîÊAádæÃ1ü^‘çÀ¹¨vœý|qþ¶è€NâþÀÁ)?Ky–Zô¯¾H1xiB½™÷ÒRâ )ç‚*Ùx?¼¬ú½Z+M
õÉG
o§âëïL•uäùFï”0û5Þ`õtÑš[ÁÏ7úô4äþ\p[NXÁv
ü=#çÕƒ$Ç0.ÉÓkÌo
Œ¼r=~ïZï [',ì– yX-ðR'ºü9ŒbõÅ_ÜLn2W§Mþ”@ƒ±ÏKV·6@ˆ ëÜPkp=ªV
ôVh¯zˆ÷™Û V'#Ýs
Ý%ÍnÐã³ò;~t›Ï¹\EíkÙ7Ûýsjò5“ÁÝ•pãƒcöDã;ÃvÄå -.Sõ[‹Œ¶*ù©BBj ų¶¯r˜%¨ã÷ÜÈyjxp7«_L½PÙ…ATôÞFˆ‘B6Ï(pÙBŽz ŸqÛê.71_Øþ椳Ižõ›SŽÓîV(W—"M|f»1î¥ ^YtJµÂF„J›J1 –Hf5Ûð Ë [¥Æ¥Á¨Ÿþñ·‘ªPm5 "BTOÈúþ™íÒD‹ª¤„)²9K ¼7Â$ *„6,õÃà2”r?QûïW$ÞwÓÚ!¹Àm÷ô!Öc|—[î“Z¢VçÏèÙú'O ¹/;X¦É ÃþJ›á
ºmþÕ”wôúÜ®®á3Jf(YöŸÆ4žægueÉâ".¦÷æ×QOóEutx" Ë…s#ib3IMú˜^xÈ‘Œ~¶©˜"*³Û&hB"ÿD†ç•·5 DùuñÏY@ÊÝŽåä.<¨…‡Û¿Èü´ðZN%j+™áŒ{{“½ýw4ŸtJΩ>{À?PAx ÒC±ní=»tÛý™¡5ñ–ì8Ê áî¬mï87êsqö ÊçÂ?‡ì0n´_XåfP®ëYÏÉ_ˆtþhn:Ýv*¬Ú„WØ…ŽÝc"¦²oû£Zé.+0¯r/àšêYØÖ¥_’^! ¶“Î9ã,iv^í¶ ¹l‚°—’©gª©
re/J·Y:&3º¿©Wþà‘è@
~‚Þ’Ü mdÁ Y9ÌÞ/Ò “Z!lZ4~rLŽ0ûÙ©*=C(xèÃ2sùl6
±óÁªóÀ\ŸórüÜÌ/el¼e·iñj‰àŽ¥ŽÌ½™æ$"GB,ëK´^j‡»ç½ÊU43úðÅÄæY$L6K)(C¸çÈ]Ùjcê!#˜Ö3x>™ÝRd¸CñÒÊlˆ}¸É./¯ØëÐÿü¨ê‰Ñç/ãQ*ÏŸ;ä ÖnáÍ¥¬!E ‚„
BÂo·Øƒ"p ²¨ –¤j!¦þ–(4;À–ÿµEÔ¨•n¥-ì€{ä°ÛýÅeFª²’·öÞh[‘
>_Œë„2½¶˜ˆÊ ôÏÑ/nÿCàÞCˆ
f‹UmÃ8‡£%Ŷ4z…\ªãÐl0¦îÏÞO Ñt»mh©½™µzg<ÕH'î‰g··îaʨìT^¿k[#ÒW“«:ó!ŠWÁ_¿Ù™#ÅW\ןû™àS+šAw©™¿¤>v¢«‹˜T²ZÜámþ¾ á
ä c#®&ö/^u•/p[l%Vy¾[BS M±L—Õ+ãÛæå Í7|Ÿ¹çFÕ72Ñéßjw,1 V ‡Õ1Œ‡ÁG.¯ Ùœ`Ò̯µ-aà*³ßJDïñ1RËÕÑØÁVgÍæ4;AŒh4h€VûªöçHÛŽZû15Çp2êu4'=+m”µßÃq,Å»Wk0þel7ò2±™Jܧ»t ¾^¹Ìáê›;pAMB†)qbš{•¶ W‹ëúQê$ö2×?}u)y¾: Æ'y†Ï¸vÐYQ‡{Ê•ÅÏ«²•"äG•)æ®>î-ZK’;
¬@ROC
±Ù&V¹-h€}££€Å·e‚òT¿WÙÏKCý‰Ð±òϹW.JÔ"…z³p£Ò^ñÄò:ñ¸nðÓ$\[Ÿº
ÎĹ}§vùIYÕbF
XÕ¬õ³1ÜBD@M¨ÿ÷'Ãl¤°T3“ncYTû´ª×|Ò8ê¡ÉA¤ ¼¿! ò€€m~· A‡ã÷†¦÷úo”^/sÒcÃû+×ÄpóÓÉ¢f¶Œx–ï¦ø¤†1µ‰)Yr÷
üª£•ž MÿB:ú–¬8‘¼Y#ómJNΚJ×l`&Åß÷´–8Òà¬Z¶8|ÉÉ«XÀé´JSMV²Â’²:â1ƒìŠE“ŽL_#Dz€ìÓç@Ö7Ôѳov%Æ£XýcØ®LÌGÍýh$æ!ìÿ âãÞŸ¢Î~B£h*V®À9~}üíO
Ôz¶}¿DXi
=™«Y(öº û×TT‚bÞÞØÞ¬÷Û¢?§Ý¶Å 8Ý‹ îu.|ºëzÑ ºÐE}ù€‚etrÃ$Ô äú‰c»
YA>û,²è-DÏ=ü7P!(ýŒ$Êí1#RZ›…D³¡µjO|T±âÒ]á \0C¿ª—B@"}´•Ê³øUßјٚ!פYÛ?Å.થ”à ŠF¨uYWà n#„8ù#,‘ñzú0'±NåÖ±ðp1: Þ)N 9=€D¡ß„ì¹1ƒ¦o¡”ªI´ö5dŸ ;c– ¶A#™ÚB_W«viþ¡Ãkü÷OÈpS§„Â.3ªE7"Ñœ¹Ÿ;ÇÌÊ&Ê&ă ’L Vh~_C>ÑM“&ú«—Y£à%ŒV™”Ó9Ë,Y™Ãæê /ùðþ|µ pé2„dv"Øe*&ÕÍ]· x8VGø)|(¬¹7¶Ë=(qÃ0¥õrmÆs2p ¦
Áe—+Ð@ns®Ž‡}#¼Ýh_ðÉöqóŽ/úáPÿµ‹¼d¤7(î“[¡ ñà•øñM” ß.lcIû~¸“p&îÒ1^=z"ÿÑCzÇÌþÛÃm!WÆôižÂüTÖ{xéÂ6Œ<21zõ¿#ŽC?·8%h¤TX´¨…|18Ê¥˜Fº´z2$"Ê 0O"ˆv®ÛàÑ~ÕM—JèíSÝ59L^:öa]üóÚ~ûë*+wíÔbxãÎÕ ªŸR¨[=2!%à7êëd MŸÎ{¾{SáÚaì~ñÊ_ž ’¥þ€<=Uƒ—Ášc`Š»1›¹é×^Õ$º".Díå¨-.·ËÛ ð¿© ‡Ý³¤IïZG1²¥6¸ÅýB9KKŸ“ÂØî–õ'„˜x(ï…(à"`\ºì1ü‹Ü¡4Ø8È?¨ÏÛN2· ¯‡é oU'p ?:æDɃ¸ÂÝs#
þlUÄÄ‘÷‰Üi
Ü
ƒ¢A¬ðæïV5TF¤9l»÷Ò,Nø.»èK;²Ô©(
„–ÓQwj(´Zxr0–/º+ñü°È} ðIhe²}Uup7{œƒ„nÙ;eMîŒ}Ì À‡´+àX/80²ŠÒ ±Ú”}GG2ü¦d¸\Ë{vŠšVpE™øৌ%2çÕpøÐî [_DÊüD‚Ä œX™l bFY~ ç³}Â7Hõ-ä$®¾¦ß Ñi$Òc«Þ5:8ÔeÝ¿ô#žƒÐ§0fòY,?Ð1…->Ѳ €àBPT¢û,áÐP ,ýpûÿ²£
›…+J…œJNÖmQIÑçìdî÷rê1_TìÅæ8@¨å™|ª%’ÛYî tR͸PÎ.übãu×
¡aê¼ê¼}'>q$¯®[z÷‚1SKAœ‡WžŠ*ƒÇC5O^Cúa àu)§FH.“}Ô¤Íl@¢’HVìeKî-os¨JC//0£nÇEöï[<-ý‹#d7¿¬{âVD\ ¢ƒÒ\kwâ掟°wõ¾0l£p¬egÈ@¾µÒAyæ÷W.%”uÎg
âÞFÕUÄQ“IÁ¥ôsÈ ˜×jÞ¸<Èû<†f¹„9S41x Ée²3FY=EÆ™7÷Ä“=v$Hû ›¸0_²kW;úŒõ>ËýíÆå2—å
4ý_Ÿ±-’{ã‰Än!m‡oÿÍF¢y,躪Z Þ‘8~ÊLÐS¤²Ûü 8Þ¾ôXU¸b‚o5‹ô&*:œ²)tD…L£x¾¬Þ¿O¢ú¯r~¿OhBnöÊ[ê‰tgHŠÇ¸°ÿ“ãùDæ
yýÒãíÐáù 4 `5ŽºQøê÷OÔ—3ÿZ¶Ž8x I€Í匚¡¬9ý ŒÓì6ñš‚n|Õ¹YŸ/a(d8µA°’ì: Sæþš;×Í5bbˆÎFxa è ¸Q`m2Í[|â¯ÐÇB †£Â C6}òýN;¨=Â걩U rŸt×,wZË-Ï‘ö1hvðè•,P†J-ˆ[q&³×Ì@{Ù¬ñŽ%†Ë ~nöu]°F·OçÐ}fë#ð‚B Ï&’Jpžê%Ì rek¿û1%à€tS<x`ÇY÷[ÚÞf¯=ó i‘E6sùRiÕ¢ëLâ¸<æ%eÈ}Ç%¨G’êÁ2HB•yzÛôq"8PìÌåþ|æž
¶©÷»Á(5›‘·K‡§£ånSÌ°Ý`”e—7•U$Çß$Ö6^‚ ]ìÒˆ%Îÿly6ï;ÝdßÃM=æº÷`9by‡ anðÄ“äHÎð^й,Ñ8{V#½Âô/Òrc Ö 8•N2,D * ªb; …Þ‘{¨¼eÎgÂXܨÝÄ´ þ–‹¤:M„2šL:+~º$øãC`Ìý劊Ÿ0Æ۴⟠W=ÚÐ^M¤dïh^tBqñâhz’9#^4õi¬ýÂ? ³¯>’źr é¥íT|#hë©´ŠöÀ_€âÔÈÄP—Íõæ3,b`¤P°Ø‰&oQ¤2;[Ò¥us;[Þ*æ" „96·<³>h7©F©§¸=0ãXÂLWuâc
¡ wh¡Jn.>Å©Cë|`pÍ>÷í{uÊu~~œ7>æ}¢ç¡ú½ú‰8‡…À Âo85ðœ•áôqqÿe
ÇAïJ1ã OÚ”ÃÒè U–ªÁÜK69ƒézÉuôX¥ é"˜„q
p›ìH¸©meËIã•ûò¸øü-:"â*ŸýhS8ÚƒŒ¹B3÷Ÿ?âåG²¯[½‹PM+=& 0lŒº5Í(Æq"I ýÊ,DÓ•íMMR@YéÂÙkŸ÷²ë«÷[ Ë9!Ù?^ð”B0Шç†ï~/×®×¹ìjBgÄEöÆNå‘®îHûñÓeÐ i'ÒXuþh¦|× ~x¦Ýó2Ôq´œÐ – ¡¯AóFÙØgo ¼ÿ„GÛŠ”?1\Må×/|¯n¥È²âGÇÞ
½Ž®d®Ÿd¹ ú°äL M¢—±20²x~R¥d²2žÑj¿‘IÃü Ÿ[ú~¼ªY6ÍÚY±Íîµó ÕâRiüÁϯÓU:4dVÖ‚ü]Uå¨UUë•qã*ÚiÉq&*5ó—e|4DX–güà†ò š§§-‡™ÂÍ"5ÀF᯶óæ«3
ѦZ
4ŠJÖ¹j€ øÆÊ % |8é5©åOa4ú9Ð˨â=/›ÆXoí†Õi
ƒ—³òÕ¨VÑÄç±^uêz#[wzÉÈVg?‚N
²¼…–iÊ;;
*aho4½ô}6•ÚÔ¬\ä=Â$ƒ5£f¯MH{2D¿Š´`s0þ×kÛî؈tsUðw3.³á‚æ·Ý™G%©®Ó-|«Å´Ù:¼PëçIÅjSyMƒ)«¨7Sú“° ´úÉ àáú+’øÃñ_¥_](䀲iBés9ú‡å‘ÿ–¡
-ñÅÞ/OU4ÿÅ.Ý=6ó
C©ÿdh]µ{Iê‘ÇË°ÅëÿôÒgÐÐ’ùŽÔqï3dÝùž1(õøk£ ð¥À€ðBFlŒõK¨mÒ}wV Q}àÙ* Wx' àç$ñOÔ9ÌQ¤ S—rf¥\ éA‹’öýË oëÖl–ž)áä"ÕRcDÍ-Un²!óDåt”#Ý [M]c Ÿ%¦çÞÏ,qºðˆ´:£WbŒÔ7f=Ÿ»úv_KGñȸ÷^;[§²ZCæF[ÿ‹KÿÃýAl)ùý ´Ît Í¢ø
"×(&†…|W›'s®ýÔ¥vê)¯TŒñt@hÃù$匋{Øi=ÉÐæî!_c?ʵaŸùÝZKÙ$ðùèVI…¼m°©^Û¸ëéb‰¯ƒ·1æ¾€Æßž@¦V¥»“fŠäùª1«Ùï×ÁãÐät|Ò±0Ì¡PIz eBBÖ©lF
vkÕ—þ—,Q§±!êmf2U9¹ÁŒ¡,Šé˜ò
ÞêÄðš6{e½Æ<þ âY®‹†‰ØL1FîY)q®6†ÓŒûÓó/3%éÛ"em¬u &îG[B§„ùÀئÔgL ŸÐO„“âgN©1L fà0œ/¦ê
¢„*©¨kø…Pé~ÇîöJGQh×Æ^{³Ö쮿é!Jó žÈÈ+½z ¡ ‘ê¼og¸V)ÀœÖæ⹚490pó—wð§£*`1Ny€o4{IÀ³mËDþŽ`%Ñ^R5Ñg0Ûž× ¸X6i!›\Kë¢æA]@ã‚mdzÞÆO ƒ÷úͨ_f=ß(.1©)$a·ÐêæSÇz]ë ´»Ãð3ŸJ>4e˜Sf9Λg¶}ÞKuצ¹äÁX;‚AÀ¤ax¤=Á ¿¹<4Z G0‡¶*–æP»”¿³šMp’ÏêAfÊ¡ìpriöz•=(O7 ;œveXÿ€cH™œÁåä¶PÉqïë#GC^ÈisÊV~?œ=.”h>e÷Š4 {V‹B¸D‰PñÐg,+ñí"ñf‹ã~Ñ採ÿ@#ÖÍ¡oq#'
PQau•2eø"κd> .öp,¶†p}£ZáO.>²2Æ*ýÁTÆ›ºÒ÷è¨[ í<ÑWÃËÄöÑ—y©÷Kk½ïlÿ‰QscîJ<¡ãDZ ˆE`NÓ@(}éi¼ $–HYåÿLåX¾¬V$ßfž:ƒ±ð˜4,!íX èù`õouzkמvyßKV SË•7Z”xUdiRÔÒ^?´’…ÅXØ$‰z|¢ôùíÜ– ä‚ú*`ÐwàZ¬šo¤¥0¡žÿHƒgptoã=Äï·Î¬Úb’2`y„ בÆÀ—¶ùÄõ6 kòg&g§¶
¹R±}9#´ÀYüpH5÷læ…J¨ôÙ4únªËp±úxuˆQ[‹*ªo™ÁÈãÂF¤aÿ䊬.‘\¶Wö`&KŒCÌBªÈ¯\‘ܽÜ*-/œó
—ØeË ,ÁhPþ9:Ó·éiÒHé =àÈ8‚ÎmRÌ p4ÿæ¦QÜEdßã)×ê˜y SØv‡OH›£îiZ‚ªa6°® ‚¯[,Ø Ëa˜ÏUê ò&?#©ÐwÅ]<¹5T-M`Ñ3µœj¿7ìËJ’øJ—'â
ozË‘Áø¹Ð ²˜pÍÂVñ-••hмö¼ûêlºÝPjC¼è +ÿ°”¶¬X¿.ÄFÕÍa.˜
®ˆ¼ÈÞi{„©â€oE‡…Vx³Ãõá
RÐ>ú‡Çw1~4€ØHZa’ÚÓjœ Ñ= ¸š˜ÕÙ©î j„!iôÑù[áT_aL ‡ë!aK^C8óv5ˆÿ 7ýJH>¿¯XoÿuÒ³‡PQf™pý¹À2y 4ž© k€ÈþXˆÓ=.ðÊ,¨^¢ Z¥™ à!»ž^TÓ+ýó¬‚ïd…ýÖÌ Ö Þïaô2Eœœ˜ Pf>ÚÛ¢QžDmIsë¥_rJàú@B¶öž$¯£F æ‹°Ô©vý<ɶ:= öÜõ½C AÁÜêf»èÔ”Y v“JðÈyFxÖªDEû™ 1ÑÑzîdðLç9.çÅ-W¼ŸÃB &Ó©{Ä|ϱ«Kâê÷û ¸ðoÄu0a2a ~2½ÛVa"ÌMŒ/ÛÔˆú»·ôÔZìÔMÙhÞÞôA‹Ç‰rƒ M'½›iëq6´B0 +ÓÙØDGÕùJ(åMQÁ_PjTÈ‘w›D3@t
"q3ÂÕ<
ï¢ÆÄuÚ¦êñAñͯY&}×/h
õ}Pß¼Q£KŠß¦Ù“†C:©/·Z@5üýЕ^¨âº{ Jœ?\ñUKyŠ5±®¦l¦}CËvEžè;‘̉KnŠYLÇÑx/äO¢¬Ò´™Tà—öx†øÑhVÉ™z€/÷ =»:žÓ†N $JÈ—MVQŸg“l«×ãˆå^ÐL‚)J»´æ_H(2–_Ñ¢µVÖ ,§žj @Ò¢ÂB\Z ¢+KÎF( Û?„Ãf‚-\º“+Ž‰î3MawĽôb q„v´óšv±]îWÍ:{ŽÃd–™ô5dªƒ}.åÇ_· º žÙDc5m°é¬åªi*™ñÊYùѨ`Åe+8ê>HCnÊ%‘&ѽUSh"‘Ý5¡ €;“I9frT)ÿ6LFÙ‹]î=¦·v¯› †À À(aÛí9Ûè&³wËMR;–‚(ÿÌ÷VÚöþ]=u`È[[ÒÉE}3ˆ}
yrÃ…µÒG ‰úžò¶bzhá4–0|þƒ
½ˆÈi*
5sbÛÍRë(ºW¼=‰«¢f’Ì.€à¡54¯!ºYä Ïâ¼xö"
Ý0îÃ}j£ä‡`·&:#¦LIæÚ$ùH4ˆÁé’ö>ñyì¥ÚnX²·,\k±¤šµ|
I i†4c†äƒgZ´å']HMë{´”w$·ÞÐxu{g r–’j ‘·õÈwºßoi gh–ÇÓŽnãʽä¬ä
endstream
endobj
242 0 obj
<<
/Length1 727
/Length2 15782
/Length3 0
/Length 16350
/Filter /FlateDecode
>>
stream
xÚm¹ct&ÌÒ5 ;™ØÉ\±‰m{bóŠmÛ¶5±mÛÖĶí÷>ç¼çy¿goõŸêªÝ«ví® µºÉˆÄlmœTÜíL˜è˜è¹ ÊbBêLÌŒŒ Fz822a's['.€š‰1@ÙÄÀÄ øÂG¶µsw07:(¨þí¨Z›[›; Tml]Ì€ Ggzg>ú)›˜ œ€& Ss+€°¼‚†¤œ8€R\î7@ÜÄÆÄÁÀ
àlhen172±q4¡˜Ú: ¬þ³ÙÚ›ÿ‹“#ý¿ ظ˜88ýCÌÔÁÖ +ª"(&/§fPØd$þ9nãäÈõÚÄÈÐí_ÕÑœþDz2ø Ëð¬ÿ‰:¸ýÇ¢‡cb›9 MÌÌmàþ¥›¤©-€í?ncg»ÿ†þ!äø? å?RŒMLÿA;[YÉX› (…míœL ²¶Æ&6 ![+c€¨›“‰±‰ñÑÖæVîÿ¿øÿ‹t2øGA³düËÜQÌÜÍÄXÁÜé ÉM
¬þ‘êß~5“ÿÜÏ¿ýçô?© ÿÜ«±•ûÿMøO1ÿNÇ ®þ[R]ŽæÚàßaQ#[cs3€²Ó?Š8ÿãßaóÿôЩü·§ Lÿo/kàä`îÐb¤ÿW“0þký×Òù(!![7O:ff €‰“ÀÉüËûÑ5rvp0±qú·ìÿÔòßý¿ÛÉÄÄÍÄnmÙÖˆ;È"µ9¤ÌG´p¶ ’fvZÿ7Í2èÊT÷µŠù ÐXïà÷N7Ï`Æßwçb[ò®‰Ø Öáhb2Š(Lg÷¥ˆ¤Ü̧zóM1ÿµ.L÷
BÇÚHâ:üÖ)ýïZ€õ$kfÎYµ”} /Š8S”~i{ $òVÜêƒ8•j†æ‚É Mò,0¸àÊÿew
,4/páš GXPæowª™·÷`ÐŽy¶Î Dc
2bÁ¢ÑÞ–5UÌW!
ú ¶-³³¶‘ §Jþ‹(en5üró¾µ
'O3H—úö4²x^—ï”TCU3ç$^[†Ëuw™dKÚ-Ÿõ"Ýq4T©ÝÈÔ„ŠØ¼:™]|L_+Õ<_×>ÇMŽ-Flôãuîñã·Å*« ¡‚R.^{‰Y’q«Úƒ“•úŽðZDÍ;Ñ[$rÊk4 f1pµaÚ„ ®ä´ð¹LY²&¢ª®Ú¤W'*0 ®ÃÄPuÄKèààx‹nêÁs†*]u¯ xÚÒk¨ÂÐŽÆ+34 佫…ïìŸ\(þ&àýcS¹è´.#Ͷ‹ûQ` ý™ºhA°+DE0R€õ@œ‡Ìzš >¯Ó:Î&—0ð+‘›:§<ÊYqou®:4¢G:P‡ŠÛ=ÿš¼Ó:æ3k™Ä¼N¿ÉÅHæu„v.G˜×·e4þ¡8$Ôýëwð>”ÌnúMªð^åŽ'GVjª,h6£QoX˜e76ûþæ"óMC„l3&Ë!©K-³5èߦ*‡å›<¸w¹þwx
CŽãbHeî€8y‚ëÀd’=—‡N`¡[X‹¢ì, ¶HxߥËßè¸H,$ôz3Nü,!Ddú¬J仂/qÍe¹ üT.#–SŠªxì þ? 8Å0'ëÖ.TZ-ËIJÆ^øÜVå%VÚÿÎ{øCö»Òñ£»ö´ûêÜj1ôëò—ò$gŸmŽÎÞÜ“ån7ÃÇó£ÚËgP…
ÿ:›éHáJÝîíÖ¾pÔ¹bÔ•L*Z ¾?ÒUdSÃ/‹|CMMÜöcÍû¢’‚´ÅøB}7iî>žÁRS;ì´Õ\·‹²õÉ9¸€ {fnùaÂJIbÙitKh=—OELsè{¦Äô‘#Àˆ‘î$YÚGjAFƒ[<’Y¿ªVú~é܃°.4oq¬ ÿi8÷š'LÕŽOàVÙý£<ÊØ™>÷“g†UVH¥³¤©h&YÃdZ1» žÚ˜V:X}u?«—wrýr;»ì ï.í]ìÞÖž:ZVYRéÁ aѦÿ«ç”àlH(,JÝ£C76ÛÔ¢‹aco‰<ËFŠA_Â/jõ&6xJ¦D‡ù+„ÃAÛ¿áW"²B#0Dç˜1&bã’Õß¿µTè;þ%4‹¼ˆÚF3Ü|Q㡈j@Ð’_yYf3ÁÚé®Å¨Ød)»8.}Ùå ybišdÉ µQv$D#w”Îhd¶Eoß G'[qůjºm½¼ÃÛ=±‰$cЛ9M‰H¬&ò‚_Ò·:4ÔÙÎû
Åé
\¿5ú1tÕß±f~öÚºTjŸ?“®/y¹n¸{ƒœ“ d2}šWìœK¾s~M3“’#‡?žû^gû‡1æÌ…¾[4w8Êu󜜩®Ðè4+ÙxÙdzûu $qëí-`7½ á™ÆL*Záüر<Í+ò‹qFA¸5Ò»Æ&yÛ*I`Æ£_Þ ø,$Y™
f Œò7.M~Wã}B+Ñ?\»¬Oi—š Ph=Ü󇢿Hj‹%vå´…“
Ž© =è/vòÛn&¬±0ÛÚ pêÑ¡BŸnCÀ¥˜.6 [Ié(0^?KFáè¯ )«Ê&„¼Òx.6„<‰ÿJKà ÌeH<Þ,©šQ_AøârRØžá{Wºþ=t )Và«…`Yžc÷lê ]{³nåéæ2Ôu@s«ÜðY
°\ŠU–§.LÕì«¥µÁ<ÂxõDÊ<Ž¯Ç¦^ùeÇ’#~‡Éwþ¹·Vÿ’Lá<‘ŽðýTä™
ì+ö®ÎŠXiÁI„÷H*ä\îõIA5–':þƒ’«sA\æv| ·®àã<-Ûv¿Ebô’,ÿ¦¢˜‡C±MÁ&Tû £¾%dhúD ÃS
›bÚ$ê¸Ò&S—ä'nR‹nÍ—Qxsþ®tv
Ï«ñï¿Gµîðný eÀwë3Ä{²\7p…ÄkÝ°K'øÖDïPǪ¤VVh)1s„ÛÞwñþÙ«zSï ®Ä”9Ó³’a˜á”)oõ€ ÷´èyŠóõp1d¼½ï¦Wˆ±°3ØpSÀݨ¤"ÈFËáŒ0ËÐk¤V÷þ9ª2Ør×L7q¬O¬ÙmƒÉZÀ㞈\qy)š—çÃÓFëé‹ý×°0rÀQÚõ qËT2þJiPÉÆO-]<”ÁÁž´Ó…c’²eo•CE6Abë`
—¶«™5³µ° íT£]Ÿ`kmW§uóL¹å¬À±‚≅S Qž#þΰwhùs@}ÉŽÓ§ì½1ÝË<òâ×>½ÕÕÙT‡¾[ióÙg"sùÇŽJ\Õó~su—¸ êW”x2ú;èZiÛj$8ëOYu÷V æëšïЀWoŽˆÐlð{ˆ#ˆ¼òöŒ‰9¦ËqKkgé¦",§~ L¶hÖ}X?TE¿Ò/ƒ•ß4¤’Dk?iBÎ*\]ÿ|;>Ê
úÿúKÊ÷gdÙ~×àO˜È÷zŠú”z5ƒ¤_f¥ïûÉ•Nå_¼éyÀVT'Z”ÜÄâ "9½Y ¶ŒÁe†BnÛªU’‡ìç>éÍëÙö'±†8¸ÅY̬º ß(å~G%þþ
S
áµ$OÔ‘>!>^×5Ô ü¾/lªù‘*€ÏØX ¦+«! à¸ZŽI‰¶Ú„”¹d%¿íxDy“‘z˜
IB² š|"³qmð‡{Qê…a4¥æùÌá¤p-|øi|“熀N¸Š>Ðœo;Ïù¸TWÿ‹ ¾dãΓ}Ìõ:àvôO#u]ïbzÂòÁz&pú˜‹ŒZm¬f&n5ô?/@ë5†{î{ _1‡tu÷e9øg[O•’|º´ô·z'.–Ty‹òAîâ±q¹}ôì*¤ù[5oFD—CòƒÒ»·Ó0#ýñm] ˆ’Ð= W`§5gæ:]>2Õ>¥&c6bÏÈn"®Üýä5\Bß"´º×¾¦QjÌ M$–¢á… ƒ}Pö‚OÓ‹¬{§/Õ$|*ëD¾Q'Yè³.b¬$Ã*êî
0xà®UŠ›öÎ勨#¢»°Ç“$OFn<ìëùðƒ²UŠ¬ëóqfìEУ10\þÞƒòã”+=ç]' ¤ƒ"
k[©bÔ”¦ô]7¡E£8& ÑÍÌC×JœÛg£: 5©HsMËZÚeþh
½Á©G‘ë–Œ}bÇi¥Á;—þª~6m3QMÕÕzêÑD˜ó“$Y§×¡J1çúƹNî›+Lû“®b Û,ƒæWC½ÄÊ4qÅð$qƒŽÕsÑ‘|ã:Ó=© ‚çD…ý¼cûE†éó)®æ±¾ÂüöËÏCG·á¬Z…Ú)9GúgxÛŠÆ!Ë9¼Â'mÞϘ~®`áHriLâ ÛŽÙî–Œ?cžAá¹(CBvG0’]þˆÕÞ¦“m!2}£á4h^vÅ_
ÊpÒƒûîÖ”mB6VJì\/µ•ºm»&íùHÓðµqr?•I ½ÞƘnaY¿ê¿C>8¤‰)›’j?K9þÆ· ùkGå˜Íþ†*³µß%¥$”.;èoW4Š4Þâe®Ðx~"„€¯ d ÑÝwîÿ;(Rƒ˜
h†(Mrî3õ×
{
m'²Ä¤å¤#ÙË%‰7c+9@|6Ǧ]’ˆáξvÂœõìOK>ÄÓ ¹‰±ë215@)™Ü¸&µ ‚ Ñ¥¤œÚd‚†Õ›5œÃóÞ™È5g*|i«}3#=ÕXýœô ›™Är6´wåo–"q7üVXÈPùn« Y<7IÄ*vÈF¹OÙïCH2Ô—ƒ=›u¨D£…"ÁCjgw~ ™·å16£§@S…´RŒÔó —û“?œ’ÖZ6pÚÍöÇÑJ’ÍÀÓºÝг•0fõÈÎîûhÀa‘ÿÒÀ+ËMg4 Ý©GnO°ÿ:ÅòÜ€MŒ,i®á$7<5½xÕßüG¸K±}´Öº—JÅÊSá[i³Û6ú€™Ãk"w¶Ü æç'v-Ñz½¡GÉ3Þr«–ë…\¶€½÷1Ý›µÎ:,çj•PorløßLg,AÑk©”'—¼"˜Õ?Q3u+Eþ-7w%y_ yŸIË7… 7Ô
|ý¬hñݨ¨‚HÂ5=˜Wcy< ¹*ä–È„ G˞³¡ù¨;àz^›*¢c~Õ<4öSêë~fq‚Ö´üA™EÔ·Þ=ÏÁs°€ÔÐüpTbk5 ãô¼³qÓÌÅ›½rVŽ·á×MLÅY".OÉŒ ¹ƒÒSŸçà\}LêÑç‚ý‹–¦T•”éÑßÈa÷gG—«
H3é—L\ÕâÎ ûë1Gs}°qá*%˜”KE³¾¹žöeѲg‹(Ô‡æg¶ä³d·Uq‡óþ#žÈqµ a¦6|Œ
¶Î)]r|~Dl¬u?¼»ö Y 0hàÄ(Í°'Z2Û66ýׇNd3?WlÃ(Þ?¶åÁ _]õ()W¡5æ¸Ök$½éæ+?VAÃ¥‹É†K$L-Ê|´Ö‹§Š<«!óËĉY§xº»Ž&vq×® °ù+
4~ÞaH²ø´ÛÙÌ·,üŒV,×&Ä¿T' áL˶Ëû©\«¯9;ªY·Zt ÂùÍéðŒÃ ûk(V•?zóO†RÁ»6¦uZ?ª?ŸVNLøXrF§ ⚥8›^„˜Ã 0×Ï$Ø÷@‘U:A,™Lu±¡Ò'££ „ŽÕÔ”vÌîQM%G§¹×¸u ‡—J>é¨Rþý ~x§^H]Á›F‚âófKˆa‚‹©ï1^7'‚üÏý //W“¯é˜!t8fN^šà †EžMZ‰Óéb›BTèÚÛ!Û ·ÇŽD¼DçõJÒJÝ©´ÃCj€,‡‹ ™*nÅ×Û™FWü†x¦‡ U ®“ûSÉÍ
¦M÷RG`âvA«)þ);¤Bq„—I¦58?¬t;Å bG
¤²>''ݹø®²TRüÁÕÚFÎÛÙ[‘ œBI>€öƒ ½-™mÕ«ñèª]XûÏxì—í#Ûn#x!o€~c¤&›î×*~…ФHó.:®F ÔÅdA¾¨oYï|b³‘žˆç+c˜%üµ}·FEŒ|È
–‘ISÿ©Û¢Cx 1 -™ìm[ómðí©9ºö Ú5x¹fÃ0Éw¶“ |ôÂh³9‰€Ë¼ÇšKðÝžTêO§¼ŠãX|*ˆ6¹SµoJÝ':8? ^j¨œÑ tòš£ 'ëwñ}›îË8E„’ÙŒw~颿 » aˆÿR€³€Xz éí‚ÕÛ'K®ÝU
2¬±|¬ùeëç(SéÝÐ6Ç…••Yî§ã#ù‡1×:5ñû£€Œœœü _ŠI’ýõçj®Ñí½ÊnJ)š}蘜˜™;ß¡ëÑ5š‘¦ ÈËÃò¬Foaëú‡k7Ä Eë%#dü[܇]¯>HYÈíù3<} ì—?m3àŒCGyW}ŒÝáD7ú×
v™>„„ õžòãbj¸ºtý¸y{óÔï^ CjO1¨ÒÞl-ÑñH8ZÓƒ‡ðY¨b_3õu9y¼!7Yº==†ÎM¾É‘XWžàÉ"ÔÃsBâ:NyceqûQ`ƒÐé+ Ps¶`ŒrHWÓI¥ ÷·‰;>ÅSÛÆ‚ë3$(2^8–Tµ}d¿f2_—CtYᩇ=ÊÒ™º¶hº—ÒLìÆîžS6{ªš¢Ie‰Ié7Ô×_—ù\è‰2œÌìþrd+! Jü¹ÃFÓ hÏÕ©õºåo'_¾¦KCÜ]ÈÎ:øõ`tœ"àÏc¬ ‘ÿÁÍÙ|ëô}Q_•ÍॸÂà ˜¦#žƒßZ1O% }šñYyÍ‘¼ Æ<†GÂÙ',¨ÎÝ .i‚¤[‘º/‡>¾c;üòZJªÝ[¦½'LH9@}½ÇEu÷
æeg‰0°ƒÅÂJ-°¶H̳ױº\ûštíACiM&L$AΕø™QœÿÈꯊ
Aàœ3,ÅR{5£b(ø)™#ícFÞóub&RÃD*[2èÛÜ1,ýxìÑLö‹{Ù'AÊšêL¢ÎÎT8^!X²¾."3¹cT£ö$yþû=Mv0ÙIÕ'¸µbÏ’ÝÍêËéÇ‘ÆíJkvZ’¼ÒèXaŽKÄOGØóöàÈ£ìHæ‹• ß”FÉS8 ÚÉÝô!¯‰Jù»Jc!…dî=ƒvL›M.UJ®æè\î ŸL½ËÍìû.‚ã åøòyaý”bo«žžÿ÷Œ‹²Mî`©-Z«¦‡;°†Cˆÿ³vüȲc“#[T¸íM|<Ê”ˆ*íªßÕšõ[€¼[›g@™KókZš?ÛR'%ߣ«’-cÊ<×ãkJð==o(Áq“™ï#T`¬
hz¿"Ó:”ѵûùdfé AéÁÞQ*C-öÊõ=]¢õ&?·p3Ø Ôå;Pëh%”´duÆ4!9¦©<wDòìˆÿ
ªä˜–ÒCÙóýß²/ÌuO¹Å8›dýšõ£ß—úxí’’×@þ[ ]ØT¦7ïU…íxúó™l5Btèðÿ~ÁA œÑM±mâ%ʼnµ×Ìÿxü}…YÛûüxÜ&Æ›k‹ )EÞ„²Be çÂéÆ>¸ ßY9I"?]MÚðÍo÷öó½UoÂoF59¨I_B, ¡ð–‚)ĶîTù])íit-: "(ù´|Œ*zÍ`ýj O
¾å—ž ÇÚÂp;B?þãÑ•fòÇØ’2
ݽ™Ç3Rõ‘Ä1¿Êš¥Ú ¸LÁ€õ¨«¬ œLÙd?(ôU‘âÏR4GØ[U²dªFW ¶Ø.='/Ï$§¸ Ðß@:dT¶0ÄY’ôäù ~¡œ«9|0C¶i,|¥v»ê¿„Ì(YÎKQ;œ[‚*ڛɸ»–VÖ\aÒy—+º¾6aF=Th@×ÂE: 8ôŠ‡mƒ72_ëzYBÙÓWs舤àÅ2V·‚<_ÑhÈÑ<ªŒ»Ç™0CêLûÅ»PÝ„o k´$N§@3±gÈ«Š˜Y~¬0Ì6÷P-7"ÇÐrËËx-/ ÜàW‡ˆfª&ÙÏ{Yðã>6tfìXEÅÖ¯‚æÔ²hƒt“?0ëeÌZÁrèŸæ÷A]è#¶ÆÇVBv3Dz·Òþô²aèérw³”ð+ &Ü”L*C(.[õð²Ð˜p•r©»yµp°E§„6*uªþ€U¶a#øHLößgÞú}ÖbÜ÷h=» §MÈžTòŒ}4¸Ò}û3šÅ¸W£)‹@R–«xêÖÈuçuM‹ÿì7—¨Ç(ó?¥£—Œ‰p¥€_W²Zç(:ôznµAâ6¸$üTPßÀIôù¥xa_µÍŸXoú¸ gøÐmºã1%YÁAu™äwOÝŒŸGžW—„Ì'“|Ü8Is*¢P÷´F~óùð›\®·ïÕ»Õ=&øˆfÀ<²B†ëcqЛìÜêþçᑨÓùT Ì}u±,ßv½Q‰´òJ?¶võŽk>!ÀUšºóå'uXI†\ÃðØ*z’û#º5‰áºÇIbr‘¼…´E“ˆ!
IWF¦ï[ÂËÒ ¹ó»7è¹Ç˜ï®Ÿð¬°ŽiJ÷‰Yr¸ ÙY °U— } ‘7Œø×.|!°»8B*b‹šM
9A21°ÐÃ1ï=¤CÃuü,‘ù’ooë.»)yœx,.ç@a«˜ÕÛ¶Û Î,˜À4—ö“þ9öùÒ7¢ã>@»z•A‰Œm‚ò#&¹kÔ¼ò‡ÓÒ%ëÓþ¾…í ÉÈ q²6¡¤õÄkÛÒn ’ÑÜ\+|@M”¡Š–9m/K±U×ÆPO‘Xd–mG{r}
Ã3Ê{°¥êšŸN¿®¦¤ ùN]!Š[>•SSÇiû8@º+w–*6‚ŽÅw
5êö4àÀIsŸ
=léÚ̈[Ö‡ú´ Bû¾ ¨MÇ:΋Ðê ¤%ðD(: ¨‘\ægÕÁíËÖ¥¥
^XAuàÈ35Δm;oˆ¼8é€sS4lÒJKôªƒ™àÞÍ^ˆ>l—¼àÐÝY4œ2ø=ò,¶ wrfšêÞ;¹Ûö‡Á"rŽä*V!½’Äð|„M€Ê;ùÞ³æºÿ—†Lƒ•zú Q'©N<(ц¤ÿ` H~úBíßÜ6[„W'ãÁ̦,©m¨`733VH ™öia&yåf¨‚=Žç °íß›8P8;](\Ÿy£Ü¯ ¥RÒEBÇú7³“O.¢¿É+QI7»' ¨àöàF8/ŠËøçá…›H—£‡ùäH LcëJÞ >gCb,xp æ “Ë’Mêå6ãÁ¡_»`@,t"ÓW¤«q䙉 ‹-.>T”;¢QÛB<èaF]ªÔÒ¸4Ñþ¼wi6*¯‰éßoTCØ/®M‹å%÷yýu™¢Lãš²?3 1ô´Ï&!a¨›TbË2€ÕGÕô¦`YòuÌ- ìÎÅ]Ó#XÉžDÉËRÖü‹úÉúwYýn+ÒF8Ó³óУ m ‡Ñ±¾»Œ¾Ë{?Åå²=( Ñe<šÛàUñ»ÈÞ{1ÞqÎúõ6çÅ(LpGXoJvçõ)Ç_dUÍìY Bª Ã%q
c9X·ÙÊ@ó{
é‰(Ö(Z
Ó ¾_4¸C?¿ìÌô×¢Ék.öub S4µümn'Ýþt ´µ^¹†ô^çùÜÕbŒ0]¾ Ä\´üKW´öNjç±Xš+7#ü.I¡—ëíØYt¾ßY±ýmØ’P…ü
WaDÓˆÒh†Î°lõëEÊ ;ñ†%(¬n=Ë‚ýç‚•ßGw`3ÝdoE'tIlÄÛtÚ÷øJ
Ë
†´m–n~Ç»AÝ¡Ï⌦¼~5Œ©~\~”^"^§XÂÃs’Z¦bÒs3!š`”Hiræ2û¯²ÉJ0f/tÊE·ú©6J‚É¿±çbÊåc#ïÈÖ÷ú@qvø†v,°§-~åÛéâhºu![% 5ªþóU|¾BðŽ¾øzw ‡Š·Õ¼£ Æ]n·þhš½|‰ÏÚBÝè{ü…"= ‘úá¯PŸúø}”dBá%£æwUÙÄ#°_Œ¹êX ãö\Ÿ3»s¯³3ºX±Ÿôµ¡§£š ‚“2 7”‹K‚÷› ý|ümåøæëAÉ4
ÆO™|Ûê>ÂUì]}“"‡nÃÁˆ-âa÷ “ ¨
O_ þ[¦$¢
Ù—½5èÁ<ÓDé·pÜ=¹Z&¥ºûu¤{» )W€5&:¹˜ èýGÑê•Ç-ªO³¢™ÚxD£ŠBžS]enÞ²Q r.Ñ×=â/þâå’XŒ ä󼟆‰õ§²t‘MýD
(Š-G"2töWwØ}š¢O´#\º*9V¢}0¶x¾ä8y ˜{Y±™µ¾[ïŒ ‚Ú¡?eÑdꌚpÔrd•Ç
ø8ë7ü,Sx‰²Ìð¹t?æ-Yÿ––¨w²t#¶¶³R›!²ÃYÝI·=>×jŸ@-×ÂYÀþíÌ• ¤â;Œ•<ˆú çäKäÄ Ý.tÃÔiqgÇrîòåÄ U¯®/À2ɦýLãÏ©4v蘄[n‹6j!)±§S:œÞ½¥…C¶Ö[ÖÜü©Ò€V¹ÿªu;ʇÚPW›t¸ðv2¦îÎPA“Ûˆ27ÖçQ¿J®u$—ÿ¾2ûåÀ»fÂL^ëÀ¼†l!ù¬ÙNÅ—Pï@^ˆr»ÑÉgÜ$Úç2åþ8º‚œ³³…pSIÚË M{U//`¢—?)ùß_g9#šÚÔfØÝKâ ª›ñ¹{ˆŒÁi=©ÍLý1c ñ°/ÏwðRpPúÖ,½Ž9½/þ/vWé˜}U¢óQ¤ ‰»?EÂæx…°ª†u|ðufï»Qþ@7_h¿\Ô‡8! 4S’„z[œS%ç˜ Ôf¯´vZÒXkàsPÌkáÔèðÁ¿ß[ ô\]gÆ.jƒk`éÜùÁ”Ó5w5úÚ4Õv÷(-š)~·$ýˆEXäO5{zgsr)Ú™g$×DèØÍ5µ¿—é+@ xv—uòÎÊ;çþmøØà ;1¤¹{xxåèmÄÇô;ŸY(øf~«T5çÜ“+0åôqJKy¤epoUcgÂ2XHËI2äV5Ïçµ8$¬CƒWˆ9 èIZ¡Z꿦5Ò‹ü‚(É’A+=ŸbÉB,ÝÇÕD ?Ø^Z^¦Y>)m;æ–½B)É×CG‘¸½‹ÿ®Wùãi‰ÝÅ1¼Ö$Èu´ó´ vúœx4
îñP¿ý³Ãð´…œ‰Yÿ¶·M¬³wlÆRw&¹æNç6k‚×›¾Y»vq›}½BglJ Ñú!ìåøç#³i™fSø´•Ü¦Ùˆ!LYÃJ‘!¦;/+¯ÕâPcðþàæ à·"ù£OðÊóÍk·)Ûð<í)ÈAs ?äž*)J1 ï»Æ‡×( êh{Åá–—#,¸`í‡OCÉ{Ä@v°”ƒäÅ
ŽhÞ6붊 *i÷¤Îlú›2ëC»n6E*KƳN^nS®íåõ1¢¹2šN4»Ô^ !%ˆmÒx»i_.Ëm»ÙM9VqdB•.è¼Åç;y
+¥â~)¡ ãcF¼T}Y ’½Êë,åÍ ÛÃ¥â¡=»ß:ü w; ´Ê ¢ôT6õé« ¬Ç@u¬W¶·†B+¼žjC6¯s ´0à7H
ïrâÎ…Ò²Æv冴›lMAO7~~Þ³× •ÏöX¸ÙIý£ãÙÐ ?¹ei‹Å‘„”wÍ”cbwyØÏàsPfä>öû@äÚQ@OZƇž½S51GJI3T÷¨T N{Ë£ÌαáL@jfZ¼r"XÊi«iXŒ)Äé`ÀØÞV‡Ô§ÎÞ
lÈ Í@õFÍ08äXf‘f߸V,wáVnW8G×O¹ <%Ñ÷¬39¥"Üd !pK¼96¹sÅŸsš}ŸoN„RÈiáÊ©‡Êµ¤£!Àïÿó»RöV¶I¡`Zùþ[•šå*˜ù„J«žÌG(êÿ±–ú³Òx†…ïýb:iô@à ®Ã¬Šü×r#–h IZî‰Yìæ<Ôƒ›úƒO²ê$<ø8mÎÊPŠ âzj³Î»þ •%€ZÃbÜ4KüNöŽÈ3ÍàÈdÔ~!, ²íæ¥Î nòù¯ §öÓÍWH‚)↲%®Õû‡[]¦PÓ¤¢‚`ï*Ò_fT&" <é€Ôè ªN¬þzÃ{N4¡ã|{òœVÌD µ,.xÒ1—@UÉlÃâÂ|¦iæÚlÇ`Ê¿hmåW³I+·¦ÚÜ =äzBÓ2ž‡è÷ž-Ì™á?ÜØG‰<4C¥?rç%›ßYFâ|X#.šÜ5 m´œx2ä ¤ÅM§Eÿ’!…§öK¼EdX@m¿ÀªxÉ,e¡O«‹¯ŽÕZGmµf2Ä2Q1}F}~"‡¾Þ` G }ïýƒíŸ 9
D•ªP4†{[«î5¦t
Ó;ÈÃʧÃb½\ÎÆ°œÌáGbXëˆøÙÒ7‰åËY %ä$ÖÁÀP/x%j¨ôã ºˆì DÉ‘µKè&ž8YêÒp 0üd_ØÞ)z. Ú
Mvi†õSðf×'·yFd dµ9¤Mù·iqÉè™ ‹KÆp•K$fEݡ·i}ÄÝÉé”…–cÓɬwŸüKš;tŠâóøŽ ‡üÏ‚`^qsòˆ¤s¢³þéÆr“W±ÍÞÜÝ ¿¦‚ŒË¾¬U&“îV–ç¶ ¾ªÑ‹¦ÃN7ƒÊíõ,½GåµEÔ‰º…ͪnºwŠýZ¼ &Ô‹ˆ•>÷:ß2 Ž 鉿6~»£– vi`ÒøNÆ”ôt€¶¥êtxrZëZ4ÁÔZ¢³ûs)yAGsÑF°oG5oËËÞZ–βŠ*ð°mº½£7fµ—x¤Ñ(£ eû•¶O»Fø*.¯7q·Ôd ¨Î®§Ê³1xVå/s Þ¦µ=”ç:?—J²Þ@c{«ÿ¸¢:§!ìi‚ÖT'9B%&açöŠª-zH£þhˆÞ¿PÃ9uéäøÜß*Ô9›á3[ìçS ]ï
UÀ*n/Tž.É·#ƒù¶¸ŠMj×lkº,ãFFè·å¦ø¥º~”ð•pâ\áÉÊì|ùni Q‡B¨Ç…Íš0õE¬Áô5ÏÓUÆ(ò!>L
m‚Îœ
`˜¨É]s„ ugÇM‹„t%P{/PõC¨c©2¡ô«'ëËÔÐà JMð¯š-”ßyk›rV³šþ%;¤óø\¯#:Wdæ_êLÆß5×=¡…Ó™ïm’í—XÙÖPûuÔÅNK 3TÉÔÖbûósjÈ©¥¯Q=…iqGwƒÀÌífwq· -ÍFÉc2,ïºQÞêƒxtpA^i‡ècÉ*áŽM¨Œ ÑHg¥w¶&z»~Q›v
P«l{ÊO.hUÀÎڛ׫
ùaÊÜ ~¾<·žÎ 0é½DéÕÝXÁ Ë¢ ó¼%Lgb³µ®´Z8Šî„{™¶<*Ò©Û»\éÏßѲy’¤Ê’ “D &Œ£¹^$Ûpü'9 k ?Ýû Sdºôaµ Eåo—\µÍíK5 ÝŸ-Oµ:Z÷Ì’
ã~Ô"ÍÜ
Û°
1R¥öŒé½!Áƒ <ðaz¾zE€I/e¡ê߃]=©uUú{i;ÖL@ž†ÀCžÏf̲.xRkÉÍAÅW2
BZ,F>àYjJU/¶Ÿsá\ãÒ8± ƒ¹!w/?ªVFÈØÔÑ
Rk#¦C»
Çï§ü±"©}×À€š¤|
œûpæy[wbgT O½ïÙJa®œþ8Cûãä·KÉK jÒŒf}Cq¯y ÔE «wQh+zÉ`dÑLñèÕSUÒwØŸD2®ã/mCÏ‹ ÃêÊîx>®þèiž¢U=6¸ÞÜD<Œk¯Ÿö³ßr|õ85`O[ÉJµHJ’CFQmÓ—·BOÎׂ6Wd‰uÓšU7ÈŸ¥¸$”leFâ‚éÑ@ÁÝ?ÿ‘®±Žiå<,‚Ù¿·×Æí¿RDKhŸ‚ -Tñ¦€S,QÓ÷¨MM1¸³síW1e¼‰{‚Ì®ž p%Lè?€¥»ŽHÊWÂ@.º»s)FÖS3˜
˜Kò]éo5’%›IÙc‹y&•zñS¶&çÝ'¤ÛÏíïSÍïæ,¢ç Ù˜£-úœ6ÇíM¾ª8]ÖØ°×8uVójM›Ô»8V©«˜1@áÀ±
.Ƕ¹¤Úz‡ÂWt‰óL‡ýn‡ŒTäÈ#{j1xÿÍÉ¡žø.ÎE1\0˜Â¯ÑcËëúÈn'=Ed§€í7ð|f6¼bÏ Ö r³ç&A =Wóéä0dãþF Q¼@›Ñ¹ ˆ·Ÿ‘síEbØyÎÑ©>CoO|¸oò•)%IâÖàÞ’³®‹¤ù›5È™´ðo½ Â’
RÆunRøžTãã·ø€o$P™\h/æ4¯\9˜Oò°¦¥ø»V[X|G ýÒÝ
¤
ŒU¾c6rDD3ÐÑŨ^ƒxyÈ%tŠø"seb9å(œÛëðòF•§n²¿QCÔÑ_½2œÀÿ´ŒÛ~ÂÆ rÊÜq‚Úö˜lEô8ÇÑü¯C¶€i¨«˜§a¢*ýºùíôŽÞÙêHK|…¤;I¯À0ý]Ñî‚U" `´[IÚÊÛŽ
¼Ä)µ ,ý±å®¤™ÜÍr¸ƒÓcôÈÉFÊÀ©±¶po‚¤>CQ„5÷ÍêŽ×‘ëù~ä' Th¡Ö¨‹ª¹º“£{Þf¯þ#^BIÞ”Ð_jâ WVßoÞ㵈MJ‰:¢Ë
·/;aÖJ4 ¾b¡é&»‰(ëÒÙ ä:͌ԵÖÁÒîY† y°F‹oRf,ž
|£VºóÏ™æyÕ%âl’FÿYÜ„ÿ,Jž%§ÚZŠ‚8M¨ºG2*È×è”…ðv©>½õ÷çP0¼AæÔQœ¢Í‰éõ(xÈ˹3·müA øŸ
øçå+„É\â’A;9´ZÒÁ`A,M¸ëš.[ÑKåX¸v«&19Á*l{ì.Žñ2¨„úZ\ºõ+;8@'þaÒl-Ô—§umõ°XÉË°GÀ| „³Qi#±î_éC×K¸Žä*.Œãí ¯åÀ ÛnÏ"«ÇYÇiÑӤQÛ¹ddõž¦–Dnhšútçœ}*®Ãó"O 2¯`%â+
ÿíÔð'ˆ2SxÂapÂ,üÈæ˜êŽºø6dKÔçØaÆ¡_ „º¡ÁìzTÃ=G‘M’îÀ
ÛŸÃ3,ÇÐ) Ë(Ù™z3`û 2)vpŠÁU½D`¡ JÞŸñ}•¢Öõfz1²ŠòuYË)›ƒ%_£>m6ê£Öé žrÎ1}œ–Q\öäÅã†üÈ 0ä2=Ý¡Ê!gE« á˜íÚLÒ›í¿¨‘ ¡²ã(óO"ýòrí‹üxz33ó™šÆ,S~Ùñ E‘R…ÿHËp™ ‚†ÖÔrZV™Š‘IUZëÏë4ÞSFá[kìÙ•{Îû k}3Óß ó·Ym *¹Ð Ö=(‰+óYz—ßzWGCÑè8f7Ãk_Ä.ïÙGsºC}]öÕ89 bôÆ& ÏhøÓ6׃üûêŸQðD+½´ –þN Ô@+aE¿»öÁlÁ®ð$:çj\/S:µYcKâf}Jxè
³â³9ÃÐS„€â´Kþ亴UªE}×H¾¹SUÅr0w Óu!?m–mÓ (óÁöþfg·±üe.åX-:‚§ƒ0Ù`?Êéc¹³Û }à’E‘õ"TÌ?œÑTâJA•< 90XHH¾hÎy TÓ½‡µ¨äí|²:¹P={ý·R. %Ø©Û˜Ž°‡dÂ#)®jÍúq
+kD)¡|úøyÛ}eö“ð!G)¡‘\†,©×•ðÄsïJëžBØôõtÝÅVÚbÛc °
*/Í^JD*»¬“¼¤ÌD&öMf›8s [KMÚõ0pâÎj€=h¶ °L'+¼ÅÀ½ØÕ±R¹¾¼Õ¡ðf(ˆqÁú„ Y^ÐyÄÞH ,Ïjy`Û—6ק¡q}wô§!¢ý|GÉÎŽæ’†6ÚC§Ë—œVÔ5 úª.mP'—)e`^~{·§µ.¬q)–=_1
”>Bp#à(FñOývIø@Ú^„¶iÎhÞóƒ|æø®q:nÂ4B ¡ª@bm?»÷r—àáÝ…æØf<ä}àèŠ[Ñãß@ b]ñšf
özš¾ §{8¿FªZúÚ«ƒpÁdkJcž“¦RàDò7BÍÍØ· Õrk &ôì FîGÏý>yÝžÿáÆv`t/¹tò ±cדmôMnºŒœØ+M«ô#¨Ï÷ Ã3O‘ì›q€ÜR@4b7ërW‡›£GåË@¡o]Þ˜ÓjÓ”ÔóÖQ ÏÖB3•Ü"ÿÒZBç‹ÀÃæ¥×®Æ×,Yꙑ „;¼ ú³:‡ ùï›c‰JwtuÎr¶V‡P ÃfD…#ÂÜÌ (Ù*¼A—=Ö|Xh°Mvåï6sp†¿¡É” ‰hó
kÐÐYyš/ßYzLèL)t^âK!¸ÜÌ¢4ú/n!6¶æ’Šø˜¼·Ö‚A S˜°æ‚<‚"V¡aêf\ÁèPNG—ÿµ¯ŸˆEÂp„ðëùÚÞ ?~ˆYÈ%oPêëšY÷LjÂxÑ?Ôë`…ï¹ÀénK5Þ ŒYáÈ'¿~h°® „FÊ;J Txó
Í# v,Lø<ËâŠ}Øb¥›-‘þ_øE¿’ yX Y]…mÎln¾F õU|Ö³ª I8¹
¬V¼s½JÏ%ìrH+-p¢¿ÊgVGTh$Isã.ýŠn7ÿ 5> ß œ¼0²Ô5ͨÙ<¾G†RÓ %a¥ ¼\ñ‰¢k†;) QÈ7’KòïŘ“mÞ†% GZX‘ä9ãÕ.{› šxú0õÕ+™l!ùvÃ’hÈA®íz€¬¦èCøx½†—*ÓÌÍ_¡ûja‚°AuÀÙ3p˜Î+ý¼:õÇ59ÓôçpÜC8ÿp4 þLbûì}…è·?l°×ëTaQNl¿»Ž9£§‰Ü”}ÔLÖãêuqÚ…³n‚ °3¿Kþ£:Z,ñŽBï\’nîüÊøgLMïk?·œÆaLì7Ý©Ùúë¶p ¨®±g°æhiRsG-W@j/~à%•cÄó}á 0w"ºŒgÏdÖ§x•P.ÆU28’Íl«Ô/*ô÷hšT›ç Âá¼oŒ!_h¹ ŽäÀt•‰¨ñLÒòØ Ì{*®5tê$ô9óòyÆê•‘m¶ä<3ö‹fÄû–^·x_“¯&úëx
‘'[»ˆ6bd/á¤*9BÖ´kã“$Šk7ÃÄNsš(˜Q(™9ç ÊéQ5•bˆ\ˆ2œÿÒÛÂ𥳈ñŶ¡²¬ù hnÀIP Ëç‹÷ß[©i~÷S’ çû13kÀ v:šúÜQŠŒG/èSÝd b}ç&žõÔEpÏŠÕêSÂBÂæZ2õkƒ3äÓí4¬¾eÎõjØ-~hg5Œâ:ºY t8:aCÐ…‡¤rã8z…mŽDv$%T}“EÅæ7$d _ÛÜÌ:@ü6Š$ÌN‡iùSMåîÖ â0 1ï59cD!1Ë @’ Ü èµ>6JaG¨„ièñ@Kò˜eðñþ¹¶t§G~Hö-®ƒí ÄWu5è¿ÈâY…³-ÝIÇs.Q¢4-ħ™ÐL^˜c„ú'´.Ó·¹ú¶ 3_¿> Yuݯ
ÂL¬$ØÒCa¹o%ð†:9ÿ“½Ó·M•ß‡Ê lE7Cx>÷ý„±K_ÃÁd[›¥R¨ii63ïn÷+£ f©N—ÀÞáŽ{*—£sü5$oHûHýÓæjCuçâl¹EaO8¨§X—Çòúãk{…TÙvÆ*-?•œ×â§> «#±Éì„=V»ªú˜Ñ»!‚lÔ¼ý«/ºˆ¦vi©4Pú^0‚R´óöWSlwRØ^õ »3Ý$ü·ö}Jéðã9÷G¢ü>aÇ]@…á Ë6_±•î‘ñ×±B®Áçïù(F«Š‡ ölI¶‡ K¾ ò óÉ=uì9 9ª>m¶" ²ˆƒU@4nŸ©»i‹BŽŠi+<ú6⯩(U—X_Äoºôç¨F&C—L¸»Ý^×þ‡ÝIUÜ=ÝЙšwu‘N` q›7>ïÆôþ|ª¥à§`J ÑY¶G ¬\+«_ú¬¡‹ =søÞçl¼ÄÇc·.uÈxßËSíØ{oíEŒ ‹cÓÏ^žSDz½Ý1sR,÷÷JµF3ÀÞ£ñ`²6LHF±3al•é^ßÎFÊ´%ùŒø€Í¢Þ÷wÄ3lG…]C Çr¢ëh¢ƒŽÍf—"Ð} ¯øØ
›ÿ*‰åô
endstream
endobj
244 0 obj
<<
/Length1 727
/Length2 14782
/Length3 0
/Length 15352
/Filter /FlateDecode
>>
stream
xÚm¹StníÒ-ÛæÌÛ¶mÛ¶mÛ¶ÍÛ¶5cgÆv²¿µÖ^ÿnÿi§›B¯V½úSc<ƒ”PÌÞÎEÅÓÁ”‘–‘Ž ,&¤ÁÈ ` c†!%v25t±´·1t1娛š ”M ŒL &FR€°½ƒ§“¥¹… €Â˜òßA€š¡‰¥¥@ÍÞÆÞÍÒØÀãææ&àæìJçäÊG÷O‘²©)ÀÅÂ`fic
–WД”PˆË©ÄMíL m
®F6–Æ KcS;gSJ€™½Àæ?ÀØÞÎÄò_œœéþMÀÎÍÔÉå bfNö¶ YQA1y9€¨0½Š0ÀÐÎ #ñO¹‹3×?hSc#MGpù ËÆð,£ÿ±þ'ëäñ ‹†‘`biì025·´ƒ¡ÿ—n’vfö ¶ÿ„M\ þ›ú‡ó?ü ÿhH 015ûíjc#ghk
¶·upu1uÈÚ›˜:Ù„ìmL ¢ .¦v&¦&ÿEÚZÚxþÿâÿ/BÒÅð =íÌÿQá?!Kg1KSK—$73´ùGªÇÕMÿs>ÿjôŸêZþ9W{;ÏÿÛðŸaþÝŽ^EHY\S‹úÖàßiQ;c{K;s€²Ë?Š:™üOàßiCËÿìЩüw§ ŒÿÏ—5tq²ô h3ÐýkIþõü×Òý(!!{oZ&F -3#€‘• ÀÉÈêû¿è»:9™Ú¹ü[öfù¯ÿïu25õ05†ÙXµ7æ±Jo
«ô-ž¯§žŸ5P¥^e^›é½ÑF¶ ¶0Ñ?ºÂ¹WÁ)p‡ÃŸ 4âݻܕ¼o!2Œ7…;™šŽ!ŒÐ]Åy-%®2÷«Û~W,|û ¡w
¦†mk,vyç’¹¹¤@5Í’÷·NʱœYœ1Æ ¢s i'a}éÑNœR— %KëÎô€ºiÞ"´èÚˆÿu$¼ xî†[ߢ¨2Ðá(\«ààÑ°ãï ¦j[ 1»OCþcö(G¬l¾c!õ:F˜ÊpCŽÒ|
Ón‡,Dù…Z•píÎÝqÐrU³”Äó £LÜ4(¹8ê#»WðFì…ØC¬Øζj7,“¾Ö"?m!<¦Ù#µ4’
†(¦f²Ïw‹NžµÒøœ¢Nç}—¤íê¶=Xzë#
½¶¯??Ìw-ÇbJᎾèHÚI9ЗFx×i—’kà8@ÈÉz§E_â}Ó·pÉ×*‰ˆîSaD “(¹bæb}û
šR¡[ž‘·v˜a¡‡]ÑqAÜ,Œ_(G¾Ã›„Ê7rbº?;%oâ©
"ÑËÞµˆÑ0à.gèµ=}
©_Íôt*VBÑÑ óÛ™ùªLë
-‚-?Á²y³ŸöíÁô —©ÄœÔ² Z#Ë«©€@\z8 ^E3„A]hG¨ï8 ÏB؈0}R ´£ŽÅ:«’ö]!‚¥tõoË®äÎ0 c®}”„—0 ¾£Œ— Š²Æ‚/zf¤ø‰ÿÎff›£Ï±ÞÚ|S…Vá±ðûÚî(}é&–BpNZºKà µž´±g>Œ´ÄäÄØ™ ô¡˜‹9FN×µ†u–s°æ1ªDÆõ)ždJ½eÝi†à0±Jë‹Á„…à„nÔ÷Q MEÑíîÆÅ9hÐQËÇK— jñ%ÊŽF°Ï&Šb³Cn2 ¡‡ MV9OªK ¦‡tQx#õ…Ì]*ññ¹d" ÍcѼÑÜmz²K’¬À& Èhâ¥o\_¢jL®‘Ø¿
:Äü".ý Vÿ ž¢Uè¥Ân7Í][øRxÔ= GsÆj–ä“ÿÕbòÞÅUêR 6ú;¿Zk¸qM›{¤ Ýbý”ùú]e9:ÂgjGÑCè]ç3äÿ¹öÆ¥ãò¥Î ']!{é¤Ö> ;eÇ BÙ‹¡ `]0¶B==¤Ç¶WF×çH _²µaðÆP)ß)•çÐgç^Ú¢iZ$§¹—,Ì.à!C¸ íu‹š/T;èÐyfâ{Ýh²T#ëíLö§”£y
p¦ŸmŠÛ ™rITíõ›O„ÇöúòBñÑ[W1,µM,wÅ;Çœ„¹æU'xö&Â¥‰îü¾ƒ_”jŽ¡PJ09–:eëAqòHdQ\焪Ö(/YŸÛ
‘^ó– ’ƒ±ºÍæ“<†)«;|W(´qU}v8eÌq $¤µ’ùfð¸HÌÌ[YTY\{™zw¡‚Aà„ú}”¯¥ñ\5/Ñ?ÆHm×*Ÿi^ìžù¨²ÆÎ +"ô;’ö›@‰Øäðejpk”2é¬ÂN§ ~׳ SѬEÕ˜€ÿ1sÆÛÛ™/«n1r<×Ù‡¤Ó-Ütçiy€±¤BEv/³GÞ¼×8 C:“PƒL‡PÚAQi'Õ"•J= XyŸ&¿:Wb âêwð©?
¥ò]™"yŸ±¯bÊÙGó¨‚l°)y}qG-}ƒWìÎK”}¨¿(iMÄ"W<õ+ŽÄ"ØŸ{<¢3gQ% ì,4Ê9ÙÕ1ùD™XT åéù´ÍGéÈ:O2†MbÇtNvÅç zÕrÕíAÑ0$Î.Zö,†ªyb ÖÔb1ƒHÖüCûˆcàD%wjsýS¬‚Sü8°òÐÛ¸¶±¼' ŽÖuvû“’¼çB4Vä9tðgµæùÑ]iµ¢&¡ ê Êv¡_?w…b€0H}kï¹ØI˜x‚o‰/"Ü•oý¢ ßa†º@Mìâ onïn3—s˜üÄ–_÷U«Š,ê:.Î +Ž}o¬±ûÑ ä2ŒTê†XÅq wÉñËr35àÚav½ 3Z™Óg“%A… þ¨ÓJ—™~œ!)ù_’<¡z™DŒÂm¤·Æsà”Üh·IòTq üb¸>ùN P§â[šd8pk¸¬ Q¤jYzzÿU HãRÿñŒ¡y‰
á*UqE¾®¤eùe•Mé™Ç-efå:ÏQÆóÞ‡ÈÒr®<›!ÖÆ&Ê—ª¾Ð™§‘ŽQxZŸ3ïvjñ™Òè²¼¡°ŸÒKÌ›qÃRõið½5áö¨è¿õ§Òrï—WG*¨Z~$^µ'Möséò8¶XàQ‚'0©L‘(ž©£í‡ºHYfh\ÈdÂ.×T(«ur›õš±aµë¯7”¢Ò…F¼í¡Û]ÐüpY´‰³—‡U| Å{ëÈøL[ˆ?’ ó
ÅÝâfÁÁgH &=ª;hÒ«µ5%5â•ÈÇߊN²—e@ÍBÔ^€¤)w6ÕYSŒ€Ù¾™ª~)ƒ?òWö2øò¼rèyZùä <ºÓq75þ¶tÅÙŽ«”¢Þ¥Sud@Ž -/Sq¤Ç‡á4ÐI ½)ž¤kVߘç=‹í~8¯ ßa$ Ò¬ú“l+ž7Eû¼0#|œˆôJAní“}Üó
^k›kùx†D¶ÐaÒQœ×Cù
þÓ¿%I/ëÇBöå³]¿ôÛþêgOmŠÅÕE¦‡ÇÔ¶GŒ"ôÑ ¯©e‡ÔƒsJÎGd¥ÖBù½[™çÅBÖ[¤¶ "T†¶Âš}
’¥RŽA±R:ïŸïíX¶Ç5sbÔ¢…›«5«ùÆÊÓTÃÁ¹Œ°]Æjˆë k8LÑâªoËú4D>ÂZeJëðÏDûÂÃå@H'-†[qán-Ý,ëÕÏÖ¯Ž? gðQo"e„îãV{ÜFX7”)bù3ì{ ®Ûïý“ç$4._ Pj ›Ñ³-€á®ÂÜ÷„yBÆ#œ}šý4 Oz±yPS S{°L¥'¼™nG:’¨{“.][Þ]«s ’)7þ Ù¯ÑN›Wi¬p4JéZÀ©½ÅaÿÝèvt¡;PKÐVfŒ}BI:r׎YåtOd€ŠZëŽQªéÇËÀs§Ù1 4å#"~ú×Ì õAþ—¥OÓœ¾—! güf]ºû%Ô!p±ÅñÛ 7kvtÞò¨»Ã±YÝn0kÈË ðÛ%¯«ÒÚž@ü®B[£é€‚¿ ‹ÌXhmë¨"ëÒfŽÖé=o£-‡ð·™ ¹Ä¦tÐ Ú p•Ê¦9[{Cfeô¶iÙkÚ‚]ròý*Ú,t¡L„ÈŽ{z¸ìõjÐ/à"£µn
Ù#ì}e+®©Ãeàªw˜âüW§ŽZêÙÞ‡ñ Ö[O º– #J!R20kò§¼{N&üb:!V-¾ÒGf”ñÝô6øçºh…Ü4¥Ÿµ{Tû$c~›+z$wö»ÑÖ¶'¼¼Í´ÕÛæb€JµžAN¬ø~à»™¶{–в?ƒ˜¶@+(1‚Hëj†™c¼—¹YâX° +ƒòTø ï^TÉËSã ƒÕøIÒÖ< ‘T–#Þ-ºTG×Ú†ÜÛ‚)_ìó€Àr(æðIìzvј™ d§f+sPH/Êe{È"ä[…<}\üjÂKå \ì1ÆB ê‡ï|„§N´ç/Pš²=ÒP`dX%O_¶r§]ŒèóøÓ‹2à _ÇÌL9áêºÁ澯#.4Àº„
¢‡ '·o[\رdê·%Ëî¥Ô\pG‹½4KmM4òÏ׬?ÿÉCˆ*a!Ò)®µÀö5Å¿úÆ~ž÷ªEÌ ÷dr,ˆî£î+g»ÕX‡ïÙìÉ1`zŠq þ›ºì$“‰ñtm”:qz¸e¾~¤_7ŒTÉà8ì¸/qSëì‚=ß!–ï©Û…ÛÇå;Þñ@×4ïS׳öžäH—àªÑœqA¢0¤F—á ¥Ús½ÎX;Ü€ nXŽÇ Âë}Š]˜—O—á ¢6 "ÎÃ#2ÆD)µ3fÙ9Ïuè~;ªÖEv=¿(| cÞ»¾r*f"2lDÚ‡¼u° Y±íDD†Öñú kø4œé0Þ D õ nÄ€’÷̲LC×áT¢¥V¿~ÀWЕ)Á.Î@!ÕœêE Rd|½PAä eºÑ[•dÃi:Ö_Ö24å×àÈriGMãGÃBk!ùøBsÓz+!js`wØwíŽ*äþÔ¢–Üœ!3% oÕ¢3„ÁÈ;Ö—tov¿’é¾%P6ã.æzg'"½·
\Ž$n3×ÊoiâŒ'8~¾}Ö–ö~ E‘ ¹X`ÍV,—
.Ô/©ÈPf ’Qp ~ £žN Î6Bü»ëŒ5Ö¢7äó‡ëç?jyïÄ“Ó¥ÃØËß%AÕ6íÊ"ox”µ¬—I¼ªä ¤óÛ>G/¦U UV‹<܃Vv¬Æ UÊá[>ûÞ[½E´câ@Ø…¦Ÿ‘kÓð¼¢1½W—ع-¦c ù ´éwŒÇñrļèõ´ÿØ ˜Dòw¦3lmHf©^àPñ ûIÃá)^çu±/ìx»Ý|§í>¥”rièøg´zº½{£Ó÷úÚ©ïä ×(åoÏÎUZôHµÇ@nÀ^féóöSÙ˜- ßT¢0ØWiýÉMC9Ö@V–Ö¢e>
êCjŠy„ƒ3 î㜂ȕì+IW‚þ'…®#+ÜÈX{„ô, n ï]ê<¢ùz'Bƒ|’lçK<ÇÂÇ39å5àÛ-äÔ¸nèë”ÏË ¡<«Ô²¡o±¤¹$ØØ_jä“™eŽq[Ÿ
Ê"Qð·ŸrEÊÖ:Ót2ÊšA3/a§—(þ}fdT‚*Ñꬌær[`m+pIhLF!mß>{XÍ´Qý‰œ‰õ‘=ªõüƒÓ ÜúN˜!h0¿÷R§’öªRõ÷v¼Ó'aŽãÉ“ G„B;h'§ùoX¸ p””Ô™¥:H_mét®Ë_ÛíÑ|y˜˜Q^\Uþx³8P•6nŠ†¥²:@.rNP”_·Ÿ(Îs(Ñb‚1šuQMÐ矓Ž‘Ýö¨ŸK¸¼ƒthÌ
á
üj2ÚÁÕAÖÉSwã4¨
ŒBÅ2\c`ãD¢¥hèc'ý+¶½Þq¸—ôÅ¿ãµRþ˜
wíðw²¹Áe©.Q‹¼@Lx8]4Gz"ÙvóH#î I
=|ÝÃ=pV^„w»ó’J®®ÉV+ÇP@Ï[*tyÍ}|"
ÑTˆ1Kج÷ÖG]Âç ÝãÍîå#l3 O¸œý4íüúÈ
ÙßÁ–ËpgHù‹¢†2‡Ò\Ð ¶‹?äâdÈéÝ4NdŽðeí8¨{2y »m÷ úب,T½4$Ê<¢=INy´q=##-‚Tu:Jð5âº|IIÓ‡ÂöÒòóœùz¤Î©#iW ‘ Ò—+AŽ$µì/Þ‡º5²¬fÊí×ú[èFëgOYRsùÿ\žJÉ‹]Ž<çHÛáÃjð ع8è3ðÌŠ±›Åó÷ 2{•’½§(4}#<Ä•`q×±‰N iÞ> d
§F2ñ
ºñ]K¤ÄqúÇ NÓ¯eíëðj’±ƒ=ñT,ÿ3EÅA‚êC(Ý(!¬<’E–Òa[‰ƒƒ™ì¾Ý5LPe¦zÖû)ØàŽXMñÑ”Æm¿¥ ³HnÚÅÝH¨¿b—ÁDxÆð˼¹mÈ÷ŒS}‘zÝ#xÀÏØröy7ƒ¥ –å+‰Æ¹”½†Î´&uöß@µXøõž8¥Õ¶ªj:idÕ¥ „¦=3Âã]‘·›~º¹ RÔõ²0¡äzGÚÆ?1ÿ& ¯4†<ÅýÁ4Ö]™/Þè6ñyˆS“ê àS¯xøK6 ˆ“‘šöèeéãïÏØ‚¯›ùì,« ƱwãÛBÚC;ö‰\ÔSy\_9Ö€åΕ>é7ê(f˜âen„ÊDÞb™*‘6GᎧqc ë®7Î:M9
ÅS-Ò(J$mÆÂ5 ˜§H šµ¡Î„6©Î‰w÷MÞM3¾c•Ü¿«µÉx¨ÄÇŒ‘xÉmº ¶ŽÏø¼j
áð ?w)áÃè–ÈdS[Í
› ³Ô+úÅ´ãž=¥Ù£ÄLº Á¸¨æ[ìyî׊½"¸ÁhrŸhÚÎŸÖ t –(z ~öh«EGq:¾ª©ZG çTaÃ:3Ö‹ø’íKÇz8GµÎü5"û£ä€öCà‹|ŠýWln³†¼hò >®±ß…‘<ó5™£ /cç#âÞè¨Cþña;ÃŒVî²—>MDð¤Tö5Me$øYÜT’JœÙé[Ö• Ü4ïÞf™ˆ¦æÄå©‘RZ%oYs¤Õ‰ £ e Ç·*ƒ/¡ÑµÃÁÓÅîâ^^šŒ%¬°òÏo?ó>µR ¶2t«z»aÂMIHà?…ƒS)ÃLjt(±Ü’äÔã$ÒÒ›’rËî(yÃ?õZNñÎ ð¼NœP4àh›âþDpv7@ –·¬óa°Xl“,ŸXAÓRk$(u4óyËôÖó¦G@¦ïsVî8|Bñªï0ìïû‹½³šŒJmÚe²høÓv4YKà›kµ_²€ýK0Ô"3Nö'ÚLß6[ô ߃PoHYËBì¤é.æ0QM™%‡¹ó,†sÉ\¹Ým÷"q´A¢¦n 3¦äÏu€ø€kõ}™«œä T, 9<>Œ*yPZ oæŸ@ÃX+ájçØJ®Õ«»Æ¦+¡êÌ_dd³]¡¿9"G:ÁÚ_6 9¾”±À›ÖË{‰èØhk[ò`°=ª¹Ò«ÛD¾¡.¢Å£¡°oÓܶÀ·ÿáÇåon@ÌD%ɱÿ5„\oaVÔ ÚëàÑ6ð;Òüìd¡ Éú´'ÐTVÚw¾bfÍ=zÀóÿ³Ÿä<èØ‹ÍW*ÒÐrÞCL7ò„,‰Æñ¥ †§ÝŠºbQð›f¬%ÊÒÇóËå<³9³ÑuÔ‘Ü&±·0dþZÎU ¾YÌðÄ
¦páõ£©~áÝ>é%ž¾xYw£Î¹tL}ŠÊµæ«šÜ%a{QÛR4…îÞëQß’|ÕEZ‡õž¼5igVä¶2wT1ÛÁDúCÔf`€¥“¯@«ËM9hæ«êU:¡Üܱ^µ’\üÜ™.ìÚ8 (m[L²'>ÈÎEƒê''ך&àøk½ŽØ厒t½A@Žþ¸Eµ]y½Ò¶÷Ú&iK÷»\EˆH4Aí‘´1r²†£{9#4GµE¶´ÒeôOo?->òâ•$&ãhåÅ(æ;/Îé!®¥C¾:5†Uò«›ý%›6wW+<:2Ž?õx§Jx¦ ÒƒlÃGÔ["Ut€)btAp
–ûÇ\U|¥Uw$•®é6…úשO=ªcœ†ž¾
tõð„h·Ç XãO
¤‚kZM"õê}‚+^¦é Ê
ºu}S\ÚÛ›_Ÿ4‹ÓE®Õ¤TÎÄq£ÙvÝ ø»bRÃyÒq „ƺñª§[¨KkÏ£Kð3)Ï…ü˜ß# ½‹a¡$Ëz(:1ï'Rìæ&gÓïEÊY¤zû8÷ÛGÓã¯í¦¬MkÕæ¢qê~Gý®7ƒ
@‹ÑŸjs…ÉqŠ§„NR©º«Bå&‡<®Lîï# HCÖ.ÉëE@áOCUú1©`q»k»MsÛY?W];ÅVad •Om^°ï–IâÇу#y×Ê®RQöï6Gyó²BÇhÆ2yŠ½]±xº÷›jøpº\¦\½RrR ô™ëÄïl£Üã†}üH)f¶ðÊ"Äñü £Qïs O ¾)Ìp‹cf×hžÚ¨Ažª Øi uÐ Š“ ÿüz±þJÐne ß^Õ
…¹ÔÎ↫÷…Ç(:KDC“,¢ªfíï©'—ö^’Xò!‹Ì_ü×ìÍÃe•ý,+Ï îÐ}q7tó~¨R¢ço¥$'è"Ö¸ÞdgìÈ'Ñ__õ¢´GÛwºvšéï}º1÷K§˜»¥÷ùî!\ îÎÒ|Ž Z ;¾ 2M¡=çå#ë8ìö–QWË®L À ‹ ÑüÃdEoZv˺ú‘9Ƈê™Åû
ß! G; 1JäƒÃ&,¿°e Si2“°E ~¼grˆŠØæ:ƒc@40¾¶9Ucqã‰ÎÎŽŸÅ)@ùªÎH cÐþJª sÖ
úNÓï¥
=C1
NŒŽå:K3xWSœ€z>3lq‹ß RAª(`¢ø½(˜™ÈT Øþg,â!ÚL_°Zø-%C¡;1Q¢•øŸlë5y~20)|ƒ=Óðš†ØåÙ(tˆl߉vx§)jÌ!È–#™¤ØfÖ[’3
ä>uÞ¶¤g%$–Bn‡öKëõP–fˆ¼Å+„b¾ÁªýÂÄ‚—î©5²PR IÂíÄHÂJ·mIV¼ ’ºBÙt{á¡Å!5è G‹&öˆ{œ.ÇCa
E C†Ìæ„Q¬J(ïk½ùöç Z…A¾üÔSžsêχþ[ÙÍ€ä¥Ëj†KuaYÂ[¬.‘Sx¼rÏo§ºäti†Ÿ\ÂÊ•ùŸ9±»Øm’_Hµ$èg[9Y…ÝÄïý%ÇævEÕ‰æ$Ìg¬¬·¶f’*½ï¿À¾_ŸØ]Ýø µîtŸr
‚ÐR 3£Ò°‚î<æ¸#BuP6N5&•Ùñ\±«åO€ÓXì!²éìZÃù*}ü•ü,€;¼© ò«u–U>°}Z³–GR
¸cYÏ'îqd£.Žyye/ Øý¬‹j¶DBbˆÇþ¹ë¢E%à|ccèÇ«ÇXºryá"æe_;±Šþï¿pøÏêБ¦ýq›úcF›VÍtƒY=o¬‹Ÿ@â ‹o åÇñABM –ô¶[lG?}©³“1\³à;¡áa*œ$
WJ>’¨Ü>A¶bäèΫ®¡yN žA4¡Jbç›!}jóÞ×*¤ÀñÐÍ·,Þä®oI Uf¾“p“™þþÅÍŠc‰Ÿ,ÃYŠÌ¡¾•£ÂCŠƒd'\¨[áÁù?$tîo!ñl*rqPŸ¨î,bDáó:¦:èØ¢6¯-)r9]
'$¤"$ð-èž,Ó3ä~\¨6ÆÿT$t ¤ÛZ㸰v)+c$ |¶z³^69ŽMüD:¥VàyЄXÖÓ ê|ù¡›üß
P üÆ΄s¤×kH
ùƒhÞš0hÖ¼™Z›Ï‡ýOqÖô‰‰X6ùV¶.äÀÚD4}$«3ÂbY´ŠN=àNÇ…ìÁ’ÎEЪ{%i„Lö[ÏØW¬¿K¨¿³C[¡`‡ÆÞFiâJƒeŠÑQü¸ºY¶«ƒà4Bùºpú ,Õ ¾9Jþ½Ê{ÜðSú7Ç!ÃãÃk”D_DŠ«FÁ‚Ýò»@&šRò¦îº_i ¹i·’ ëõ»¸
‹¼W0Q“£W7´È¯ƒ‰ã>q5pÀ½å© $YÞï(8n±ÄÄ;÷kcÒŒ‰‡ïçwÑê8ÅDù¦ôÕ ýyÌ{âîÂO?Ÿ¼8ö̵GÉo©WËi78—ŒX}´ÆÏ=U8J
Î)(¦é¤%eØ‚Yóä:z¿ú³Ó¿2À΢iª(_z¢Äú– uäõé´Z
¤l†ñ0´/à?§ÿÆ°€TBiŠ•ë-øÎ4‡É>]{úáÄöZÖY‘*ôno‚vÞ}<¾T>Цx8;çêË9Û3¶jæî À£
˜¢„l &Td½ðŠýW0:î÷¯4¥:Öý¸À
ò0šR©Vݲ Å¥£RÕ¨\·¦É)Ýqlð9[e¹k4‹å`ØOâ/ Î-Ù÷Y_xK:ùÕG¾áÿM$¯§òâªk¿ h…âÒø§½y9:¹ëÛ,_Ñž·Qnñ³ F&Ú±äÛ!0TGÃbº>R¾â>`Ò2u ×€#ÿH?½è±"°â׉ê8C²·ºä(_è9
KQÔåEa´˜vb}ôEÄçËÖí Þdœê÷}2Ìk6Ý䋈Ԭ)Îo¦Ìþr×N˜Jd¿é·a+6ÁÚ,¶&bH žG¯×@“°¹øÇí÷²)…~{¿|¶Eõ½„Þ-ºÅŠÌ(-Ûþ ä¢ÔÌ°?’ê/Q’Hw•‡ t6J MŽÉˆ8bf¸Þ<Ú,…wÀ:ÁòôÄdy–Ýt—‘V;óEn 4½ï9E€~+fϱ~<-âmìY°·Zý’ÿ fïS–ëý.jŒ×Z»ú'ü§÷Q1 ڤךÉ
”>öH
1.OIJ±Ü70±°âf^
ó<ÀCx $Ó\Éî…^Þß„· ö6WAP ÌK*¥ vÈcs1^¸¼È€òß4nRñ<Ÿìc€çÞoí¡õ¹s»0fV&ú9ÛÉŸÞV@é˜tô±az}EU©%¢ÑK$Dª'X0¥©ÙD%)¶6×IÜ*¯¾‘¯|~¦î%ÅàQç%³±b“d©NŒ¬b7 3Þ*Ún<
—roN¢ÖƒÏ©uK†Ç>ƒÌžH¦ßÈ å—˜Ž½ÿÇ|ái£e²O'PúÜ $ãÃ_®*"7béd]é†yJ4
|$ØB£\¬ö€ƒ÷ò—àoœ=êD0½Q>P¢–ÝÌI±ïÕÐ ¨PJ
C±ÛÎá¯p”u]ÁW¾þU{´÷ÿgúx³lfîgû“ÉL‚æìO å°ð‘mžâd£"Aâ ð~YJS!ÅåP.TÈpž¿*‡?øaú<À³cl8¨éh Œºó‘º’³P9ÒÙƒmÞ1)ͽŽšW¤‘7‹S6š¯ð±Äck<‚Æè´þw Æmn
Ë´éÏÊ$ãNÕ…¨ >L~«ùY‡)˜Býr‹Íˆ5U Y lØ@…XžQ$Ö„ÊJ6'x)T‹NŽùü«Ü\(*D öú"‹Rtu©Äbü í2ÐOƒ)H
´äN-O=
ùÄ…•‰ÿäý¶¶]¾ L
Mô³ë.ìVª²_3@ͳ¿òw*”*Û¼Qí^FPƒ$ Jj>ÓÜ-DÚ·W3â<°Öǘ‹Z·ß vÛ%H#ã{„ÅŽÒ#2"Ç,ÿâÀù°"Œ³*q¨#7§lQ&~9ûÖíšÆËý„\©%#Hä&à yÙÔ Qc?´MÌe·%¿~Œ€ó„Zd™RV8°+sbP_² o2Eš%Mú‰—¾Ñ"í¨Ißú\@\² û—#ŠûópÓ;WË^Ôq/Liˈ¯¬…´P·ä³€T~ü!=&qqò>¯`ßš®*®H¤Ò›£Ë&©—ç¡$" ¥fC@VCbÆ»±§[®Ä€èyŸÚÜc±`yƒïL¨ÀÚ(¸è ÐÏãäýËh±Ïf>?¹¾9T ¯
¹\w‚-¥ô'ào™6Et†
§zÞ*G' ”á¼êq±}¤tô0» á“:Y› c
ÎSlÏq@$™´ê@xÆG YÛú È«·jšýô}à @) q*ÁÜ×Y¹H
·\*{ÓÈëÅfcM§ÿ#'/
h Q±ó8q¾DBw×ÿƒ ›&pw^
$õ´öüé<}™-øÏ+¦ñ—Vm©hY€XN×0»p„âw …~?•NЯ ®zZ 馟ž˜NîH=LWŸ—,?1+œ+ Pwrô£Ã¬¯iRGÕêž‚RAOÅê…Ù÷@u| ðáÏq³G_5_tAv-®°–ÏwO'¹(ë ðÅm‹M<Åš(uaÉáRùêÓB³ouÈf!Ú×Ó'àmMpµ½Ðøe§xyJSUÞGó¸}¡vOo“êGF;P¾n·÷´ÉÄq÷¥«LÂ<ÀnšHi ‰Ü¨ß7Ñ_¦gê‡b
Aj“¤ÝRw²D¬€Â93M¼.aæ:-òˆý€ ïù¢#ð6-ãÍOe¿5:Ú
å5ùFÎ?QYýZí+.|ëµË’Ï©•$±ÈžMUI9šr˱ó¯žÃI éè}Ù±üa¶Ð¶í]9À‰Ì[,þ·¡˜t¿r‚æôhß²ó±( ¾rYEÝýÖðt…K‚ÀÎ÷¹Þ¦Ï±&®Ä xsX Ô$EúAÕ`ã]Å£ ¢Ø¬dâ‘SMŒçøŽ/ˆ“é)ÒæS½gr¡ÚD08°ß9AJFî›+„ß÷e>“¬T™;1T!¡$k²úÙV8I“DÔ5oJšsnY¦ŠÜÞ³CÞ@Ïŧz–ðG”hï<â\¯ßÁ¥QòØíF31!tGpŒÖºƒ'L÷Æ^trT
t,nJèÔ¤Úý‡÷
£‘ßXÂÀÔÁó™ßs† ÑàÓ«YŽ¾F)¼_.LÌûðpY×4Ûb§£ÐÁÌMÚtÉm:È> RYÅa»¢¦UvÊÆ>–`
„pƲä¯î¡Ø/XÛjíp™ ÚÈe!æÝ m†êÑE§ŠlC‡›.MŒÅz… €9YºÅ؃¯¢8àKBY'1–äÞËê¸Æ"l¥ kÝðOè®í-5æ¡
ÚC/'3Nk½^Ë‹3ßÁG®Áñ»l«ÊZÏ4ý¸MžZäƒÑC™ïF±Y`æu¡éïÒ‡jž/ÒÏ,f"m«?ÖUC«ñêí&iMÌâO½ÀPÁf?˜%&[ÌUŽ—‚Š ׊ð¥žWé‡dýjÎáÇYº
ÄLiõ xp™šw“\<–ª ™OgkæÙ]/˜•Î¼\Õˆ â QÏÔêÉ¢F_«p(ÂiD F‘Ø,ÄÃ$!´àz ·=Î×ÕŽ_Ë0Ìž-ø¥`“nÇ
×u f5½ ÖÎ.M²sÌ?v¿-m1šuxMoP“Þ6 %'iÙ¡3‘Í6i É5£«yO¤eäVÒ†ìÌ
'¶Çm „ zÌ-“îj?†`.Rç@å!Æ~eªOŠ°J¯´±€p`K+3é4@éUìI`d>›1\$Üõ¤íO:åà|¾ˆ»|F4xºXFªKnË(†ÙNOìø°
†a 4³•2I©¸~G©·7Ì· ê·â‰a4¯ä™_æ(V0\Á¨7'ûf†›*K¯œI¹®,D{¾MÊW v¾x΢Zkúº·Eæpª}ÖÛüú>Í—yµóµÆX;š¼.š”¹ñï®Ü°¤ôxš[%—‰}7žŽ[ˆQ_ß;Ÿ pÍ=á[µ[ »0i*‡I5èpÇ3rau—2LY¢dÌ¿ûºÆo(†ßFôgL›9È¡!wק&\2'€ÿŽÐ
jþS›0½4vÕÆGyÜÀ°ª5ø;€½º1·¡À۲ט/Î}AÿÉ}È„?î7Ñzg
’ƒ„CëæàÔúsÕÚDŠÍ 3yŽÙgÉHˆ¿i p»\¤XOð=—™'C;“Kôihηí{Ù!JÊju¼½kh>òñ ‹Ÿ½Fu;ÃX}VsïÇ(ŧÚb¾}Ð 3}ùk¥xœ’¸¼P æÍ'Û‘J[{ë…;
™ ¶$«x¤†®;rŒnõ«H¤nÑùåRµm%P)ŽÞ zëzõ
;4@æB„Ûb]Ìbì/Kwˆ•Ý+ 7£$ɼŸ'0‹-•X˜=_Hi¦ùùæ¿®ÿS¼å“I졆âê³È„¡´™âõRiþtñ ìïœ5NE¾T‡·U£“«–ÿRtcçm½ >u!„ŠêtC»/—¾¹«VªYU•LbZ$–e°óU ¨L¿ à¯ËŽâ‡|CÅE žË'©ükªE/›½¶— Û¯¹è•¼.ëºÍñFBuh}]L .ì8žªóHIß ÆNõ2)‹Jbõ½3'¯ï%'oŸ2 )š'_“’žQA¹ßvîÉñhóaÌOTŸØó˜’©…к<΂KÝ*ìJÙRÀL¶5YÒËQlvÙ¥Í˪"͵HÊO”÷*cÆš¾öë©”ƒÔ÷¨ðÖ)A/YÍ>ûÛ–‡3k
¾LY€¯s\ø®)7åcŽê5‚d§/ » æ)…|`WT=ÀXhО ÅÈPÙB5dp òb&ND2ºpñÑÛv-½FO»pïRŠsš.祸nØ5dŸÊËà.Y>@"cy£çaÚUµ6D! í¤°ð“á¼ñÆÃûå´î˜³¾ qÿ ¾Mø" D& Ïuv9QÊ×!©pú¶¶S,\Ͷ†}þ5\ïDnó`Vuþgd¯²ú–ü6v¿#[-GPjUšR4&%påN üüÎm’— ‚l»÷#/1E…iÆ™K®LˆEKNlÈ)N™QWÙö÷óÙ61
ª¦…å¾^†Ügƒ %œv5]'4X£þU´ÀáOÓÚ_IZù0d/‹bbq4a]®õæzÎÂ\ãÜ:»Œ¸ïÁö¡Ÿ£Lçãct?¯‹½ÔhU„f ê„/ }¢+ „|ùZÄ?#«ÊžºùB”ó×>fD£Ì>Cb 2Þ5‡ˆDÙ—å‹)¬¬˜áeŽÃaÎ^ÍÜGƒLò àŽå„í§wü³ÁQþS™ºQ,,õ‘@Zi|ÑGÛ[u4j‡ <´ö“k·É –äêr 44hú ÿ(àÉÝqâÅSû<§ßgéB‘nˆeèÀðúŠŠLA³ÁÇBõHÈ®ÿy+ÐS¶žò :fê•Ž‘ÝÓ“|Z|)Ó¯WòN}…i†”.ÜopˆPÞ ímþ
àöa¯ÔýE6Û\ ˆE¤®
ó5 N¡7üš‚9LPA²‚&?W²øÁë4˜œOäV¡1È*|æÒæçð¬ÔrÜþ›"/ ™ì`šš+õÖñúAãÙìÇtaüþkÏÔ?È$þ›®RÑÎ`·yWµO²¸ƒ ¾zeæR¿m÷âÁt¥ö–‡ÑÑðŽlõËæˆEüj×!{Òâkè
(DÀÑv²u VBO~"ÐfدdVŠQí̘"Ÿ×Q0/¦ RŠ|µô~ÀML…Ý‹šë0ðî•×Ø e ëÀ½‡;WIYðØ9 ¾ÔhzR<~á6KÚ&¯Ü J=õûõÌ…Œ•V‹ux»ó?¸µp+úà“°mˆÁ`•~£ŽÈ_è 6„§^Ñü³te†rÏ:1Û™guöŒË¢µÇÆÁëÇã;ÊU&ÖUƒ0rc4óX1À*‘*×áÏ>*‡[úU\ñB'ÉriªjB§Q?š i(^çÅÉŽ
ÏAEN.nQ ß19ò23/aÁýÎ8WP´P ì‘ú׊…¯@PÃœ9Ê50‚q+ß½OŒìˆ¹'-ts èÆ IB•¦Jt¤2ã¦Cw)w?:baC²Šò\¨W©Æ¤c&„dKêM„«·MØÝ9ºZuæaiOŠr$Û ûMIpq£3àù Ô0Ÿ°5¤kw@[žj€=.ñA YDèoêî®fà5ÐãSØH³Þö–ã’ è Ì*KP‰ˆúò`WLAúk
à ¤oÕåלoFÄÚ ÁöÜtNË l‡ÐóíþÞz˜Qrÿùœý‘ FÀhѺ5_¥ÖFJ±Éªz®ØÌ,LŽŸµbï¹vr< A¬è[‰ ׎¨÷Æ|˜aVŒöá
þˆ!mÎ: ’+©ù2ÇHYF ai± ÓÙNû[FM:#Zš]µå¤p ¿Øª„ý/¦Ï ú‡ùþ È*',XýÞ9 ÉBž©°¯Ò›b%qöÍ©ÁL7Ãe•kïáá˜)wCŶå+úËF¸×N`¶°LzV¿oÒF Y*\¾âxÊYe[2†àC†ýÇUÐËÄ¥'Œþw€©àEì
³ôÖ4Ô¨~£x”Š 6,Õ`YS¼/jN×5¢Â]£MI§å²!”rêá×ûê÷ù9=<ýÒ䇥íÇþÃNõ¾Ü2V6iäb{wÛ•WQÓƒ(o˜â™vÌöÚA¦Iãæàª%lGùfô#“ú¬ÙGWá+ï`°á}ÔÀ¥Zj‰ŠQ;·?—qQ¿9Þ äM°î™ÅrúxFZ…1é3Gb0Â噧Ð/ä#HÏìFøÜÃá—²*»N»0v¼ækx=
¼Q(x%Až9.Ó¤;("Ð ‡Ñ¤U<õS"ÁTÙ_ÁΫœªîuŸ>Ù¨>’¼„NH mçá
S˜&õ`ùßj]Ñs¯D ‹éìÎü[Øhƒþúk Ùnµý³¹²7¶w^ÿwKBäUôV‘ÎT6ZZ3É)˜aõÊ›RZ:
öù-
vMûO°
vr0·©ÖöéJ¥“n~9{†«ÄÌP
ç6©æßwþK7/þ ª%ÂœÆþ$dn…†*'©V»úìéJÞìýÏò XDv£R>Ðá
;±Õø3ªÛôa f:@yÙ4 Fã@ÅsQàÍlRÚÂø†áUåJ1ï}Ô“§*HañeíÂxÉ)Yv¼Ó’Ãd$'BÚ àQ]Û†¢ ºRëTÔ@| ßò|ŸØ¼äÄÄG[ÃZ쇢Èn
4K!½ª÷ÄâÁóÅÓþÀE`3
%¤C$òä ~9Ïáü½p !ÚMAf¡÷P2v²tš~—¿¾„ô©ð3¨Ñt3ØKkAô„"ŽQÈ~ŠH5VÑɺEg¼ u9°–ÐOØ@ˆB0nðqÀ‰–J˜uœ‚XÖüÃÀßöjì%‰nH®Þù-s
d• €Í»w ‰¬½‹ õ‹1˜ªvÍï,dûâ%÷DáfšÈh© zîV(‚F™žì$¶*8ª_ÒDðV¤¤7Ö™A½v¤b:‹èæ*•eÉ Ó²K>KT„oÖ3‰$È}ˆêRœÖcïò>ï>u (4ž•©{WäMÖùRE]~ÆPQß¹q”k"’åCe³Ož}vû~÷WÏ‚kÖÙù¦Ò1 ¿€}MjáüÅ(Þùƒ0Kv ¤è"ïŠóÍ?GG↗4âbW9CYþø}qÁ dÐcm..SXL Ö 9hwÔrÂþ Èolš(ZÞ =d½\¾‡˜l˜{·9"8#À¿=;^-,„[ÒU[TFÛ©‚ïLü>B ¢=®&ùç½Þ„(JH
ºÛÄ{[,¯E/î³ÆKXk%ˆ#ÿì –
endstream
endobj
246 0 obj
<<
/Length1 727
/Length2 11566
/Length3 0
/Length 12139
/Filter /FlateDecode
>>
stream
xÚmueP]ݲ-îîwwwwwgww÷àîîÜ]‚»šàïÜsnݪWëO÷è1«GÙ5‰¤ƒ½«º—#……‘™ &)ªÍÂÅÊ
`fdC sš¸‚ ìÅM\¼ - 9@
è`a°23³ P Ä ½œA–V® j3š@€¦‰9Èä Ðt°up™YøÝÝÝ…Ý]ÜÝÿ R®V@€ÈSRÖ‘Q”PK)j ¤€ö@g[€²›©-È 2Ú» i Î Û' 3{sп4¹0þ#ÀÞ èìúW˜…³ƒ @AB]DRIQ !Ƥ.0±7ÈKÿ=nïêÂû—
43õü×tô ×ÿF¶&ÿLÿý·êìù`2s˜-AöLÿòMÆÞÂÀùoØÜÍñ?¥¿‚\þêPÿõ`´øËv³µU4±¨Å ì Ý\Î s ³=@ÔÁÖ áé
´7šÿ‡mb²õúÿòÿ‡!ãjò×{Ë¿2ÿ¹H‚<æÊ ×¿–[˜Øþµê \ øïûùW£ŸþÛ
ð÷^Í ìm½þ§áßaþiÇ$*¥¥¥¨B÷ß5ø§,aoæ`²·¨¹þuÔÄÙü¿À?eeпwè?Rþ³S –ÿÍL\Až =fÆ- ó¿¾ÿDÿËuðôa`ea0°±pX8Y¸ <,Ü~ÿG®™›³3ÐÞõ ÛÿÎòŸüŸu=fë+f|¡Öéá•þÅsUÐts3Æt+,à«Ó½—zè a+s£ƒó/7ê_
<ˆfƒL~žíÊÜ´š|" ý˜Š%‰4XùòTJVeé_·ý¢RøÜix¥‰og¦uuíš¹± ¬L;Åž÷»NÖ©\ ]Š%Ö¸¢s m'amñÎ^ŠÆ€
#K÷ ¸OW‹6gVta*ô´·Qòé’ßȪ¨2Èñ B·`ÿΤç÷&k( ؘý›‰Ð¡-W´^#±;»¢ÿ‚ݳÐÅÙÙ”Óþ+;}F'ô^CëÛÂ#òÍíêDhê4À ÉÄ\à`"Ȇ
±º' q&aòŸo’…^?\H¹ý_m*x‹>ÒšÀ^´‡—baîâ^®ŠyQž>ôWòµ¿÷Â=á_DK Þ#šÕ é¤ëT¡d °;§'LZКMì°=äm=´é*'½R¤-— t9>.é¯Ë4Ô¯«Aáu!øXD¨žÔ?Ò´ó×Û%£µ4 hïF]
ýŸåû‚–ëwb„T—thœ² Â~„K¬|QÅ9",€kÆ D•f¦>r› ˆU~$n}¢ÒÙ¾ÚgåÎGXf5újrKW.-G¥þæ„Wçs£…EÎp~ªÏÜÛò^‘MpðãèªÅ1Z—2§äX
›~>íl½…Uhs»º^PÞýâ±ð0¬9 EV# Jõ$LQT½¹…»Á´1LÁûò
læ ^¼|¸UµåP‘nÄEI¼:b—6‰_ˆ½¾Æ-–ß ¼¯¾]ÛQ
JŠ›WÕêÛ–ì(¾©vÚì)o+QvI@‚;Á ®¦e.¯»ï2 PPë}ª}x÷¦éX´|°$ I /ãýÆonú¡Ü!Žwjlîù³«¸ÎÁ$b¬ìFüa䜑½uÀ¡?Z¯ ž4±[I¿lëßWòréCïXà8`˜rA()H¦O×å\0ŠõØ|7èÍ .íÝ(9Ìt‡»°
ÐÍÌÏ-û™B^S]&'Ü¥=ß1ù sU8_¦ƒ÷B–mÌ_ùûó2g3Hn2cŽÄ¸ã#²”Ñ›—w BS¡ÏI¢ÛHç;vÐT.Ö•£âHb†õ¤…%Pî¹Ôœ9qÙÂ'´ÇrЉœÈï®>ÙSDÎaýyf@ÝY|[Ì7wò‹ ÖTªl Íðc|Á*½)¥GU/2ØyP1nq”Ú”Z€#óZA]†ÆŸÉ5‘†€§"“%
,‚3 ª½üÁ—w˜ù¨»IIBF-™iåÊ|’Ùø½Íl'ˆ/KjÉVTmX»õŽpñØnu 똟oE!@ S Âé³Ä̲7·žTI»A€FkìàµDí^Ð7Ââæ|âôºÔ=dZ€²2Ög¢ÌĵÜ{˜¬ ö0ò‘ÝÈá¨Õ2šE‹ö순Ä4 æYÊ^†ûô x’6qÊs'Db†LØÄÛ*
&E¡Ÿ•`:*bÉcɈÅ(1´B¬h>dOhËk
2·,>^ÍUüŒwæ²w*ë×@ëâƦDõâCþ¯*Äa !_r2ý]–š›í'ï1.jUæHê# CH÷¯ÇwDW^ H îÐJ—Æ&Š¯â gSR˜xM}Až}íûª8á“A‹‘{§!EvW˜Ÿcgm0÷i\Ò8
å\çB‚§wA³„=PÃ*ôý\ºø¹ÐB™`P–æºL¾ .üJ™3Ÿ¡R}Ô ÅÚgeÏb.º=i:îWÒÏ C N_£Î?müª|ÌSe"&2ïÚʯÊ~Û àò4ä3Eض¼]kñ·Üìí¸¹iL‘d^$&?šfÒ¶6àýƒl„2µV °½@~ò;_‹D¼Œ˜Ž¯ÏÞ¤÷¬îlqŠGäeè-ä½-=®„@ß]z¬+ÃêyÑ<ÝžPÑ?r"ÑŠq|N´ò;Ô¸$Ä%îøáXŠ1è™Ô:G¯F (ßKÕ ëª•‚? ’ò¦
¾Ød|]VÞÙ…ÙÔfÇ_¿Ýs7 g&(½Ê)n
sãÔre}n²þhÚ'BGáÓ¾ìe^^3á륔æç]
~”@Ðp9(Î%6¥ÑeÇdÙ{”áqo„Æõé×µO•/_ð2…O«93ã
sø¯¶¼•÷Šûäïnoøøöv;
wö,¯ü*¿)$‹Ô2÷áèÖPîŽr˜ŸÃ-gs¸ ÎÃy þLge£{pT
{„˜ ü÷Ë€§_Ÿ=‰/švB}CæÔ»Ùbßób¿²]ãŠû¹Cæ§ )½Jí#À «Çê%ù|Îîœ<‰ˆ¾‡’RP%¿˜qòzJ2tbPùßý¢†‰È£;•·¦¸È2nvÜíà %\Œ½ ×£º|±€-X]e-§U7…|}Ô~«þÍqå´§žÒáMu¸}˜øƒ ÅýºÖÕÛ8R汤ǪztnàEOƒ\ÿ®fkx`ÏyÐíû-\ulH¤4t ÅÜŸÙWowUÉ‹·ú÷ߣžOÅV”>q… õ§›H?ï·Iç˜Û1ü^·é2ÜFÓÁÚZ·5XÒ8ïFsñœƒÐqy¼
z-ùëÑËRQ•ÉÇ–Ç#A쑽æQy”¢€.‘7Ibzùç£Ù+7Ú*/,õNð@õÉòå˜Ê)\3ëÝT(2óê(žçL›.¿þßB;A‰€“ŸÃtpz»¾ä@狶e£ûj¨eud¤4=
¢†Á ò»?7ëÛ¤ÎÖù*AÓҙ FvœžêzÞ•æ7«æì2Rª IE®4£ù"¬fÚûà‚á¸I'´kCüOéñÙ¥4¶Åu ªÅÖxÌ›éøYÒ: è¸ M? Cè÷êÕÛ:ù$:Üa‰D.-A _Øü–$ÖèÉÞÎ •L,kGVEþO¤,8ìOh¯_Z©7c¬o OC Í“°¡4%UH³+ õ¬B²›P|>Y–äá*¦ol¬ñø®Y(¯(*ÓR…¶¸°¼+tKh½<¯EBÛ
E¤Üéá—
·Ê›ŸCÛ¹½Aļ`‘íGcE26†«Êê9ÜIÖ·ZîûO¯«“Íð¹É««W!ÚNõ)“Ÿ-^¥f,?0¥5š¤_ÃA|µ
Év Ð0œË.ò(ð_u
[J¥EqËn3NDDÑ;œßñ*‹vŠµ:e£’òiêàóTwé×¼Üi‰ŠŽ2«¶è®ãx'pYËõœ‹ûÂTÏnSKµº×•µûÇ{˜o·tX~¤ÉOòäi>Ì\ñȨ8¯K}ÕÖ±‘‹ïó^76”«÷mÙÜ’&»ºáq=*ÏÃg-0‰áª2,—¡AÜ aÀLâËĵö¶º ¯_aÂdÒð8º÷©Á‘3‘¨EÂLÑnÒðz±•/Cßcº£4Öw¨……oÍ …Üm&‰
géun©Üéª3ê^¤BÍJ²:gÃìŠî8Tʆõ[ú›A‚œF¼£ÆTŽcg•
¢!Ç°Ò»‚•ü_ÊXðµ°¸ò¾Þ~?’C¤Ï ¼+ݹøŠ¶£ö$dšÆ×—zž8¿Éç ‘J¯Üöë4Æý³DÀÚßç1XkÆãVÒ{•®:®‰ø£å[ ²ÄûAôMs§¡pýOA¬‰é5S¯ùcÝÀs `0ÞÄT¨^‡”´h>Æøàâ2â-T“'X :ˆ-M¯ï¹öµ ² g¶çcÔ…Å^‘\<‡°“x–+Òˆ÷Ôañô0£ƒ¼±1¯`$-ÛÞ0IŽ5ØXd嫘vÏÏΞ™ó
Xóh}< ¾Å}7[ ŒT x¥>戙—4žÀDÅæÄNxž{Va£@Èœ”Âíæcðâ{)´¦ª-8±•÷p½Wì~PZJ*™¿¥‚ð´}Ê®(}PUØ‚-l{&là›ã‚äà ÒÝùŒ^…G[
€…$V¥Êúe‰`¨O>ùµSBM—b‚´–ø~‹×Ú$)Ìd
øç}&ÿüpöèƒH½æ¿²þ…‚Î3ö2·À
Ũ: Ç*1y¹´.†ÊH¬öüh.m:Mªèüž4-·-õzVƒ!lxÓµúrÚ«ÐÃ^–4ž~¯Ö%9ˆßYkÄ™íçbFÆí9-4²ÉŽÇm?»ÍØe3²8¾r©4hl w wßÁ´.k¸˜ú1zÒía箸 ^VKš_Á+õgY¿KЩlò(yý‡ÀçË©¡•”“¦ˆóa Ø)62©QÅ*Ò¢^Ð
cS}9Ñ=9ú¡î¶É 0Èsoh õDp –ÈÍ\5²ì춆Èüˆ®óøî0Ìl4K᤽§ñö>Yéfá‚'U—Ýæ…û§ÉòGø3î@‡†P‹Ý0GµN`ñB5ãÈœ~OÆáˆÄ)S¼G JàHW××"<§Åû"XQ™Î¬©Ë©S!KMö¥g…ïk´ý‘N–AzT©2¦¦ ÊywŽIê´ ÃãïüåpDÉžgbkZÒÈœ={žLVÅž8Œ>“”¢ØpbëXäM
¤ 3GNTŠäÏ>oîfª¡¼ž=®kÝáÔ íõtÝÂ#°. 2‹oõ´’ª–ƒ'ú´.^ŸA™.5Í=…Û(Ü´˜ýÚ¼*HÒ.R ñ`i—£ì‚ôI«jom—>§ ”[iÚž‘Uï®u4±öv0qÑX¨h%0‘ L›[k¿ªRÞé ThkG{Må) ¸©}À1§˜?é †änáL‹õpÞ,xs°\m§DSñÜïŠavýi7ý%ñ3Açºþ±³Ý1¹e‡zLh{³ ;ãSFc_=â’«çÒéöÇpüuM ŽLtê65NƒIEhmÛ‹ÉÎàzbBª¯“lqŠ2è&~Ça“-‚õ1Ó/ ¨ ‡Â@ñ 4ß´aºÒ¯kÓËý ?±æeõÂJSõÿôoÖúhuîe®ŒþÁ ¥ É”ÇR7 ›j°ÌÄM£V'*¶¾ ç!÷ ¥t¸ßÔБÆ<í~$1£s_lDšªÚ-¯ˆ!Ɔë lÉVµ«^$,4Gùü>¿:[5 §æ¼~˜yÉiاq9<·1Þݦ\gÅjAàdOÒ8‡ñ¹n»€pÚ'ò<óZÌâQÕ[QþØþæüF’ãêd·±µ‡ç¡}©ûØÇò bù)BlQ'QÍ DDlx‡
•>GÔÙ6âÒ Õávìè; Ï/J»RþÕœÀ¥'1ºuusÂ"%Ô {ò
€aÈ”Z¶gH;íV›„~•=£\E4
Ò<WcSÝéÎ}O£—ÙK¿`TóËΆÃÚ^™ð$$*þÕGªiô
–5É¡
Œ‹àÔÉpƒzáêöØ¡æ'ë²[Ãœó`ª eÊds ºä©mº8–¥¹ÝZŽÃA ~ÇÇ7÷{NÉe‹¾å`EÖ¹·r*e;XÞ…ïèÕ9_ GÅBk…Þ >ßЊׯ6ɯŸ×
7Ô‘cð ‰3b}™bFOe×9‰—šÃÂb-Ò,jæ9í=ŒèÖ LÓMƒoß Q@[ÓxÞŒ ç^îZ;¾ß¤¬KèÒ‚ÅÝÝCaG&¦nø6 ú²
ð(Å öŽX¸ì6¨šK´ž?ƒ ‡^ˆ à5xiÀZ®/uÄÚ^ ‡k0ÃXV.)Ò¹n|TÚâ
ðψcÛƒç¹k ®E†Ýó 2uh5Ø¿ áQMÙ‰eú5Ñ »ù
Œ¢i¼“Ôk„ˆPö9a¤¼°NÚË“ ×L1ue¨/4¼ÁÉ{ˆ³Ë„ŸäýéN„TžXR±¸5Ï‹YB69°Ææ秘ÛÂÐ*×}ˆÍ —R³†°\gtkû* ZÝnk>Õ4Û¢Éj>ã.Ë“ø³IÅîyô~݇äàt°œ# ƒ ïõ4¤Z. n,.ý|Gª"7›¬ÓFÇd ¦9-pÞëeh7¿qZ{ÿ;z΂{!néÃI±M¢ÉëØZÎ…ýol½ö*vã©éM€S|•oÐâ3Ì›Rì4o`'ìif@ý3#[up Ëìò ýzÆipÆ‚KJ}€Õ«ýc¢e„ä [ŸQJÉí.;JZ½bJ+/øÑ3$çïfŸŒöy¥–» yÊ+…ì.>´8Å⪠¸Bq•ÍwÒÓdè Ñu?—š¥Ãs [•'•(~ñ2ÓîÆä‚®²:®nT¿ìFö!oÌCƒ{Q±~&BÃpØøë”Y÷GÊÏ¥I ¬¸•dÝ?½Ô"DÆ.S‰DoøJ2=¯øâT9_øçüÕ”ñê
‡õˆe
¬ŒZ0òR;Okð+ºì=%Wù¯,®{ð¸ø" bÃ[4ZlÚ‰À'ª?Êjd_˜ÝåoW]”d&dºV éL‹²èÅúxžö8½|Þ÷…=Ççˆl¨ìó^V « /_BN”òRyÓgFð[¯›Ä5~iˆfœËë#Pöì«3X‚ Ä+UyöÙBøQØj`ˆ›í‹f¿oY²[˜ó¶ŠÆu{Øs®~ -\_] ™—vip6l[w•¢R\e÷P+¨ÈnPKØ(5¼°Ô<Ë»~sô¼ o‚’¢õÉpµ>W„P*cVñ߱贔 û¼ˆ/“4›Ë+Ä˵ºµ6
܉•ßQj>` ¶V_]G„ôö,‘’WŒ¸°µÁ(¡¡M z'ª]|w•Ÿ#(4 ·É-qX_ò¿°+¢§ rYÿ&ðgƒ É-P\®JóeWÐË°AH µLÆ:Þ"}$)÷ŠhMYrm sj({†U*¾Á ´ Т‚Ù!E5ý= ð~r;/-&5¦ØodKLä8(…@Œkp>sÃú·Ð‡hËØjÜÁÜrg]´¬Hp© í œ [y bÏn-UaИ›`˜_þ$#ðA1è§ïä“HÍØ <;.:hÍ"ùkð
3¹Ìi-'
aæx³}†˜R¡tœãzYëõˆF‘£Ê[“‘ÄzzQ.“|%–‹*dÄa’]«Ú}”.7úT‹ ¸çA
trá7 ²G|Íyˆ=ÃÙ >+“a¿cÆ„ î}Ou6ÅËý7BKÒûd.*J²‚“¦„•ôÊKן†'hÉäÆ¡Ò ÿïCŸKº÷ÚH·i¬<öÊ1Ã&k2¢çº/Gcy
ç°FIß W K•YqäÙÙ1Fá¥-â=†I9Ë )uÉDÖ™vÞ‘Ba@ôO²ÙO,š
Ýy«˜E0˜žRê¢ ?“LÕKýVÓûs±¿¯¼º¼OÏ¿gßð¡€ráúíÎ$T¦OçŠ3åý¶œÙ¿§Ç™HR ÑùGŸ?joì‹D Ù ÷®æ¡œÏ”´ø;#owey$A!ˆž–X)‚JÛaqº“ÖO?G¡4îÕÖg¦@§3þ Q ÊÓ¯XžÅ‘Å^'Å;f¥×ØТz2èÆÌ 3§¹@. G¦ePYX&‹Ð3‰W´V!Þ²ÎHX
¯/ôñ`ä‡5w«I±ÍC™‡á«›
/Œ“±rIÄŒ©5ÝÄEÕ™1n:ø*ûÀÒ`úÔÜ}•ûÍÀ : dñœ’ÐT)Î?¥e$°«d§ ;Ç Xâ Uñ$ì@©¦‚")aj1 &àÇ¢]Ÿl“t5ŠÙl\T‡Åôò™]1xÝæÇ_å šüÂÎTaµ:$,g ¤j‚«* „ .ùÃü:'9 rRÜ*VÓræØ
´Q¹8[ZÃý•6ZüDѺϹ‡w";ÉñËa³p…µ[8̶{…Ô²#„Õ¿Ä»!k-j…;Ààéµô«LŽ¤~«•ü‰BnùÅåæ]¬¾œBÖ Ù÷*ÑsÇ™SD}jòîèFþ¯_p É„ƒVcžã‰žù? 7(e&b)ì×!æ+ml£?ÿûeÖªHüjì9uÐzÚõ|¸QKgäU“Ö6ªTµû‡…¤EC œ]U‚4»r7½âæß.‹,|¤½sïg픸ÛÕÍ)¥Z)FNE>ô±Þ"<˜ßÉÅs:+»Ãq‹âl,T…Ç mMÃ
Zæ6±ØB(W¦2F¹¹…µ½h½`퀆6ϤònÛoÛÎì@rÂQ#Wnþ!K#IqÄùPP„h ú¹¶É¤Þ I øå|¦¸$>.
âáHŠ9Ä‹à?¦¥>Nܺ2DõøC¤U ‹‚VjŠ¯õ‘»£•eúõÌtCY7•–Rˆäúì8üwrþ%f_a™Ý0ªž>)ö)¿ªŽÊÓ›IŒÙ~±(bø´U {W3Eíš¾îlÞÅ j¬žd‘_—öýÉ«f¨IiS¢Ë½â] ®)Òy/û\tt ƒ4†ÆiðÓ–Rª¦¾+©ôdOsˆ+[Þ;ÃGö±m&óÑ÷ÀɆqs0‘¯ôà Î)í±Âp6‹>•G ±˜šXÒº÷Óú¸(
xÔVûf×êÊ„ô}Ÿ2?(Öb¼LÇ«»-–í̺þ(7³!ûÂ\tˆÃâìX1϶㶹*¥j
žÁæ‰*4ºê
èq=¦#Ež
ýø¾uÇóªI…ýìõB
{‹È¦KÜi¯ÉÖE“8e‰ÉÓË1Â
(òDE ‡3[ý%·™ÈÝj²=±Y !¼ÜMÙÍ“›“O$<Áx'åØD¨o.è²€®M#¿h¨æ‚Ä%”ÿd‘É¥¯U5‰Ö¡Ô¥jOŸš…ß„ï+Q=ÔC§ï!ëåG§×ø“!“ä§,ãÆ1«ÛB%x±™± ”÷®Âó5áR
¹V¦HXÇü—‰<¨,D*‚äKŸGFÉF“ƒCñÃo¬I©P©ãU Ê·°N𥸠£¨D¹è6‹" íPƒøúˆÀž$D§»ë°àe‘AWÊúM£n•,Ï0ãL@vÎáduÕ’…¨ráâ ’Dñ¤¶ÎæÎæ“ Ðô“Þ*¸0=–r‰FI_Ðfá _†ëmö’xÍõAbÏŸ9 áÅKµv •ùK¶ð"•FãA|r•Á¬GPå üN\«çð“8¶tæ}a™ øÇøŸËÌÚÓgB¸qí½.·Ö£;0ILkz•G\ú>o fÚ’¥<¨¹ò•–¯Dþ] ‚à²îÛ‚`ÔApGpÏ«¬û†ÁÄ/Ì2%ÂÆz¢uGº¦{¥èØkÃ+f¢¬«X1¹½UaæáU(fÆ)gPö ;!ڦ;6L°”öQR5TÍŽSÏÎàíé‡S”v› yS¬ 0Þ„>Õø3B¨ì8s Ù. p
ZÑÑaõÁ3F!ËTίù/%ϲÆ
‰ŸðÑßð<pe$½ •äM_~vÎj.„Vê¼RMÜÔcždä#ÏòxôKBjG]€ž-oÏa;.ûrž„ û7]7ÍðÓo7~±›ÊP'ÆÙŠÖCuý$`Ö¨î[çAÒÏŸ1ù,QP'ò<£ƒ×•zWQ§:"Ȧ¶âCKåT~©ÍÂù.ªå” Jy¢™û›Ô0´yl曑}:úkŸç9F§’{°L‰£ Ø/"Áº÷¤/¹äi{<€®=€taú´Ÿ mO•$#×ro-jÄ¤Ú Nä§Õãë>Þýv °{Mxrçq©OQÎ-,ßqjx«ŒSüóÌ£À‹ zÝ=ÒФ¨ŸNGF×hC¾òèÒt€êþMfhBx‹7ÆÏRŽþ¡åÚmæÉîûÕ¨öSI ¶ò%‚•É@šÄL0µ `:ÚTµ ã'[ƒê;7
7"~¥³˜‚…X‚¯wT´Ð÷˜î&ô“ a}ó•w•¤ódÑ/²'Žp#—~ *c`äÅêë·ZÜQÏŸà±W "ª¼‘Š4Øåá[?ŒU…°•<Ñ6>1hgÉqY²ŸŠm¿£Šþ…ÇE//åû ø ¢×ùmkþjE$>&1§¸D ¯ø×2c¥ƒ cù˜gèDfq0dÉö–Fòç-ê´BÊ׶)… G†‚]*ªõ½*†|¢±
ç) çMC{ ¤)ÜÐ"Ù>4ÚR’KÃÀMúœ³o+•(#¶â‘!ýI•&s(ÙM!tI^t& Ú¹pÚ ž)éb‹ª5(5žT\„ûêœb°wpÎ{(^¯C¾v é{;MÑXÊ*2t]ÑÎx Ó8˜#„ÑHêsGOaàuƒª3ÊjÜ\Õ€0¦‚!km úë6ž÷ ¯u—×P»(i?1bÝ°¤)ØÁ]+_á{žÇ¨q ¸XÜûåÊÔ˜*êVe²U*ÄZÕ ;©öc)J@eÓ‚;#¦~ÌUÁ@Ó¥PmFîƒ ôb‘VLè\«ö"Oë³p cú‡3?Ç
, %žQ[3QãoÒ‰ZS’ô"å„"zbÍǨ‹c–!ÁE»FÊÛïÝr3²¡à¬äˆ?¿îDûGá©®à´S¨Fî¿!š#:à]ãÖIGwT|j ΢mÞ¯6F•ºX
Dˆåð3?Øó kÀ¼zyÙÌV×mH÷Ù ¯,J?µã´Ï{=Ç«y¿¾ ê!íμY½Ã…K™UºAågŠ?ôa˜ôéÒ/ ^0Ýæð2ª5¢…ëü@TÃÀï?ùP±Ÿ HK•¯J®^GÆ:? ÔY¶á;1WvxPa/4 b}m? žz/—
éåv«ŽúRù WæYhœ†“G0ÛíÔÁë!öäIcvæs’t¾Ûö« _—ì
d‹ï¨ 4¼Mg{D ©jóM}»ï«q5l²èN#lG£¤ã(rñ·‘¯ÈØž†ÄÛ½#ƒE—Ú‘h±î:$ê¹ ëm»Áq†È†>pÞ?½òD
¯ˆ‡ÝMŸ7b¦ÑØSjD".LÂN—ãÙ„RUPPWë_2è\Y ~PM¡'pØï®Å¯'Å%‹€’P,È›o˜“Ÿô2Mì–c…·ÚéÁ…¾Wrf›3}犊¡ü9ðâ5T2w|§ÒkDî›ðJ¦¹Ð e¿Älž“7 Ð å¿^Úåµñì$Á®×ž!½Hÿ
…ýª'ªÑ ó³t¼Ùø>N1!
•”‰ˆñ
+-ð6÷†!V\=å5"Ú3ZêËt.®Ébj$¾ g I½¯l763¹Êv
ÆlY ;WSÙî}Æ]
²f^ þˆv¡}Ÿ~†cÔPŽüÝw
1fBçï¹ââN|¸0’¦rêJCäÃR4?÷‰Ón
Iø&Z¾µö Ž 1|ÐØŒÛý"<É ‚d!á˜
dª¸nl²†°…IÍ8²«“®#ÛkiêHŸÍCs1è¢{§B"‰à/âM²Â…0з/l$Mà}aÍÓîüeT¯Ðè”,ïOä] Oíµ9¾•yÉŽÙûì7oþ˜öžœÂe{õ¼9½ÌÛ$ëu&P}ª~‰±.¡þ¹ÌQ—`íZB¬g|ýf*d‹«¡ „cÝ1RølQ°Û×Lj1¿£äðaSÉxk(Jä`䥞F öõ»uQf“=þ@ëÖÿÄ¢ÝßüÆÑ ëóÚ‹Në
ö:÷uÆ&'±ájÂûÉ¢Éb9’ ö¥õ^H¦6„ƒÊÇnðõÇ«öoŠhšÙŠ!I¾&_ýWè€æ¯C½ MôqÂìp¬Qñe‰ÔnDéý|ï6óL¯ö‚‡ º-h~óÑ°v…¢–€—kOYÈYtxô÷ÜíyFÃTÕ†…ÂR½Áîß(äq‹Àòy#”0åéT–µ0€Ë;1ÆÜ›•¾a\Mv+ñd"9¹ ¿òÚN‡Où›yûÖ^Ka¶j¢ŠçŸ… ¤wg½Ó¥ö 3svk®ü¾z‡'.(ä”Ò?3ˆÊ £«ÕX¹¬ú2ÃàK Tvêfp,ÛV„AïŠ÷Š¬:xÈá,ß5d?†’h»ßBžTp‡ÑÐÀ¿Ýß9 ƒØC!äV³ÂX„—¸—ÆP½3=¿p2Uúc [`¥»é0!4WöÈü‰ãHT&n˜Ã€Ð Ë ™øÉëµË
Õ¹ R›*"§:4éËI’Ûz DÂ96¥ýécjÓ\!¡ßdL"©;„/Ÿk³ó>‚âÙi¤ñÊûUs$€býãœÁ©¾¿Å¶íG昗ùy¼j>â$É«‰eûâk÷ku‚îŽ}K½ú :œã§z(+›šXcÉß+Û#Iz¢X7ØÎö{0}Þì?Œâƒ ¶"Á°Ž<8åÆÑÚMˉîn
áÔÌåZÿÔÙÀbR‰Ì+ÃÇýÈ8æ’Ýò-S£æ×’3h½_\Ç$æBõMÿŠå j±ôDWôDyznO‰Mó€øòsü2ÒÏôè¹8ÅœITFðþ3ÇQb¼¬Ð;Õ–ÄT´Š^C)g;e2‚ÕÃBk—ùÙͺÍ!ØàÅOÇ?€½$Xåç‰ÉΓ Š ?¼…£%½"¢Z¾üœ‚Vfœ|äjÈ5QWýW; Ë£½E\)…St‹úÏPŸ{c^-ýgÔ$Dà©bºöÑk–’ /=Æ{ÔÂ’;CltÌke#Â$7~”¡fUpì
Ç,n¯ó>@aÛÁšt±Ÿ6Øâ¥P²v_Ü'¡"/nÄ/Ï¢š8¹#ãò *Zü>LÄ=C¼L¦ã=˼ˆýã⢠ե$Ľü…ÌØ ÖÛ‘Kÿ‡é)Ê W)—¾¯~ú$S0æo UEj°ü˜TAxF½$¯Æý¤X‰AÔZp‚;½mEŒ¯!1¯Ñ¯ã>Ûü÷ â|ô 0¶óhNôqpSÖè+µ<‘nCèíÛæ±E÷ÌŒ6
5隤+ÖX Š Y?õÁUÃÇW¨ùovùŒPBlSÌ’auƒõ(|®µµœôs·¨ýÄ3¾2çR鬋CPhÅhÜ:vQƒL<9‰¥ùç6™ªý‘CÚQ¶ƒ¶¹e°ÏäA×_Ia}
CÀ»ã5S/TÀ/ €‘u–žÍŠ&Ƽ›Ý©›Ð„qÊ|Óù}$Ãw׿®¿‡ ‡§æàçxk72•G¾WöQÛ m ȬØÀŠ=ÊnÚ«¢£¡ø ò‘‡EJRä®ÅpI<È Ú8¹—0³ ûÕš2z‚…?-õCÜ'nwZa1@áY4ÊÇšz: {›")U‘Æà]m¶'‹Æèå— ve°ï.Î÷\[Þ£qÃIZp·D9´:šöåXâK¶žúÜÎyÍCvé·Ã±~°á È—d&f.¾‚Éá£ïÜÑ¿ä\« a{+!΂žþ©Ê+/ß ‘GÙ°ò Q©üÜ?ä%YßpW}4ˆÓ°
tÈJO>Yî²Bã&*ñ”b×^8'o“û¥£MÀç/;”ÓÇÖÏ%Á›¶ZÒ”¡wS&|V1YŠ[,’ékÙ JG2¾Ö|Â8A œÐ.†ÞI ÏH™.¹#ÀæÄÔbR £"HSm’µËY F$…”ô~/}½2?ä/“÷s47ß¹¿^‹ãjgR{xÀI²Ëžºß;6¹tgûþËÉ0 |{9¯^ f *é8
ëÃú‡Ïu"œ4Pã½QRò ¬ý·®…¹÷uÓLî šl¶à®i@ »„> Û»{:¨0\
- ÿ/Ý”=Þž ¿ÃÉð”—?Pr7VsWÓŒê÷ r© \õ„õ[[t…·ì>ã«Eä±-ÈkùÎ@D¬ãàÿŠ]é
endstream
endobj
248 0 obj
<<
/Length1 721
/Length2 24828
/Length3 0
/Length 25399
/Filter /FlateDecode
>>
stream
xÚlxSfݲmÙ]6¿²mÛ¶mÛ¶mÛ¶mw©Ëê²mÝï}÷¹q"n¬—ÄȘ#Ç̇¹’”PÌÞÎEÅÓÁ”‘–‘Ž ,¦$ËÈÀÀ ` c†!%v25t±´·1t1娛š ”M ŒL &FR€°½ƒ§“¥¹… €Â˜òßA€š¡‰¥¥@ÍÞÆÞÍÒØÀãææ&àæìJçäÊG÷O‘²©)ÀÅÂ`fic
–WД”PˆË©ÄMíL m
®F6–Æ KcS;gSJ€™½Àæ?ÀØÞÎÄò_œœéþMÀÎÍÔÉå bfNö¶ YQA1y9€¨0½Š0ÀÐÎ #ñO¹‹3×?hSc'ÛuGpù ËÆð,£ÿ±þ'ëäñ ‹†‘`biì025·´ƒ¡ÿ—n’vfö ¶ÿ„M\ þ›ú‡ó?ü ÿhH 015ûíjc#ghk
¶·upu1uÈÚ›˜:Ù”ìm
íþ‹2´µ´ñüÿâþ/BÒÅð íÌÿQŽá?!Kg1KSK—¤63´ùG¢ÇÕMÿs/²¦&–®¶ÿ©7ýGnÔÄÞÎÆóÿ ùOÿ>^MKYDDšúàßiQ;c{K;s€²Ë?Z:™üOàßiCËÿLÏÉüwš ŒÿÏ—5tq²ô h3Ðýk<þõý×Òý(!!{oZFN -3#€‘…•
ÀÉÌîû¿è»:9™Ú¹ü[ðzù¯ÿïA25õ05†YÿcoÌ b•ÞVé'Zü»
œú÷œ*õ FàÕÙ¾m$Ë ýÃ+ì{ìw8¼ù@#Þ½Ë]ÉûV"ÃxS¸ãé™ÂÝ?د¥ÄUæ~uÛoz×`jX¶Ær`7‘w.™ëA
T3,ÙyçuRŽå¼HâŒ1]ƒàˆ; kKv┺äÈYZßp¦©k[„]ñ¿î¯ƒ„ïÁÝbé[U: †kÞ›3êïÙõ;/ºgIY‹Q a …Gr–DÜ#¦”[’Î’l,«s-ͳ ’9ÄÜÚùõö=iª@!ÚF>b.x ^i[)ÅE‚Tqé#VçıR5M”B„€)Ä+<×óÈië ?ТŸ\à+ß·
mÇl€«Bÿ1òzué»ÅÄ Ž)å;™üî¾@#§#P»+ü9ßÜ{q&¥üDìq&Ü- `à þ<ÝS]é hIE×£c8è‹&5ä&/NOr?úËÛÚö$ Ôvb3 Ci5•oªâu~&÷Ò\Ü´fìÆ~Å“?®$d¼€ ŠäO$ƒÈYÕÁÉÒ†tÝ—ª]A@¼÷öúðsäé\
ÛqÈY¾ê:‹NiášD’PÒ§‘͘Ayì )Óк;Lêäæf(S!Wóî´ÓëöŽb»î€ø WýrLçD[Ïu¸ eäψÉ_¥p$gÄ‘nZ/;ÚKüç©M"_Šwu”#•Õo•ç¹£Ëä¶JVÍ^G™œ/yÏz*zÄi+ž=”¦
V– a^r:·%Áê)~¨èö7ø{½
Y›vy¢›Ï$|V“2.qƨÏã»B6[‰E7oÅ‘¢(ƒÞ|×ßzSL/|6:¶ù®ŽoÎû-©þ-s‚ 6Z —‚üƒÞjëM³~æ8„›ÿžl8ä
n¡×08Pv_üE†ÆxÛŒs¿¹pµçühcä
\txÔ‘ÄÔì0šã(ºÚwåˆ-ûÈ ·/SÑÚ Š4IÁ #ÿA»p2s j’Š«A)Æ›4êVÍ,¶ ®Å7+„wå oNcú_"QFf#+b&ÞÁ䑹 | ‡HÝóÜÆPøµ¼\ÛB ™5y*IûÙ,T/ÿØýäme
¹°îJ0Ï éòÑ0¸yìÄ!œm}UIÑ„ ~5K§z)nÉG
*3œ; °‘;éLARoP6ªÃfŸ%QU§59XX1ç†k¸q¢Ýææê-SKV4IñÔko+S[ͯó½øžKOò$qw¾Vðu~^a Ÿ{qƒü
&rÓbƒ‰ÚV®Ípw/¾Òé¡n/÷iïgH?jn|õTö`âǯ=bµY¤,Zgž¼pÖ?FÔ6#‹1Ëy}ųÆÌž$¢¼há1h¢F ½¿Š¾Z3s¯©¢»XI~5Hžã)QòÆ+X³« þàe<ôKÂ
@å¿XR&”`ûx”Á°¹Íé„„ÅýpGV=³t††‡‹‹&µ#ªI)' rh¢8umþ' ¥ Ò¶¸¢¿£‘Œ7žß+B+"ö%XS›¢Ÿõ1%¬å ÿHîp=¡ ´÷ÁUw½Æ_PžYô’
¢`
3 Øã>¼ïhº@QÄ ¢ Å+/h{Œr“…ùrãÇT/ù©áÍú\¿v‹‡Ê±¦€ÁV¿‰rdÛ¼ó ÇàöüÕ´^ƒì®Áöô4 _wƒKR_Ùé·8õ®?¨ä-ÂÈfj1'|Ž´M“ýêýî‡õ ¿f©YXLŠ°lâèê µÏ_ÕÁEŽ†pŽ™4i®Š´cÞL{ý朤e§RΡ„Бªùs}-%ÿ¨, V‰6Uœ9.‚é-̈NšÜÄ%ÑY¿7FýÎ% ™íH€€–,¶AÝ Ç‡ndׇŒ,¿»h¾¸•ÿÛ +#ÔU}ÿˆ ›¢¦üÑ©g:#ÅÛ`Ëê+2h~J׌W:Yb Uè GM½ÇØúˆ“ÃÙæÔ²Áࣻg¥HeZ¾P“Y÷Mî’õ[¤dÏ$Â[œi¨ÅBþ¥eŒƒÃ;F]i½|-éäjõ¯ÅV̪‰4ý€ýýöD•MËÕÁ[•áǵíÆ{êÉf· bu㮑+û òTêìR ^&ñ`! ˜ý']„Ž:‚âØÃÜ#‰ž¸£ü@Ç—4ÐFpÉ P«fŽG¢Ëƒz?s¼Še€ÍѨ~OàJµæ0©û#p¼yñ8.é}¿ï–MÚ©óêð`!ˆŽ&…‹DµòõÔ’J/=bŽU@ˆä£,ØÄfºDýg– 1˜R,H“¬µˆ=î”êdÿ<Áª›xÊØÒ²¹s¯i ÐËzGÌ$PÌ:uGÒ€ãtÀ÷é‚#¬× k)FQé÷H)}(ö“ú@×t"þ »í¤³—ôk9‹—C(¶½Âæm‘Rœµ¯g}&¼ÎVbÙš+¾Êë¹d™?q¬=N«Øß•´Žé'À°4Þ¤–cîvÅQúfŸÐg2¬P&³…Ù€*º¿=ð™í£doqCzîÖ½vãÚæ†uWÍÆžuÐU“É®·€^â\Nžl>öðwøhü–+¥w6¡ô\ìk|²ýZ‰ÊplvCƒ75Ä„³œ'tN²Eò4MÐ^k…ÿÆ0o5tfB¿£þÀ+n$@‚rwÂþ9ÙÃ(¡²°U\4,#w4úYB<`-¶â×f¸
vÂ>ÊwC‹YÓJÖ0®·JŒI=Ï9yf Iõ ‘7öo
W€@ŘOˤÃr IÄ´|ÕÜÖu{õ0Chð—æÞ]µTè†C¨E¤Qyd `6Ÿ© žMÌQÙÙ°;JMɨ5Á‘·Ãò•¿Ìx© `ß!šon˜ ÞãGá‡U™6ÍðË(‘•¹– [3âwóö¹•ƒR|úBÉð ´è“ïû«Ù#Á¢Ûgõ'?n |Í°*/1ó¤B{µdùvhbf W,IÃnbxïÒCdÐfni¨&w~ʪ¡@+>1Kºý%uƒmLšk*Ϻ¥€‡—6vÓí›6¦"ÖËU5µg¨M¹7ªIƒz›®im]]Ü'U'Š«âRuƒ!PÜÃ\}#'Ô¨h°Æx ü„çE]qùÛVÀCì±Ð,&¹§Äë·Qrɱè⧢vrè…l¹FYœY¢¼s5´Ïo°F: ²F®'vÆ+G+’ù&‚‹øÇÓ›šp:š@.D4!¯vz«Š}e“º}NÜÈÆã4XððÓ'\Øú™N“½fO+8Ç« Ù`µ†l”rù02üßÛ‘M!XZ´u –ežèkÄv¤!|ìóƒâuE,ÏÍSFª_õ£ÔZa`Û®ƒmt´ÙmÆÝ?"/®žÊmëé‰úA‘v}šþ˜sð™o~RÝõ²ÅKjZs±.׶û¿ 9ÏJÏžøUs"Že-ß!:gŠP¢ÖGf¢jì¤.^ª;炱8
tŠ°üKZVÎ5pඃ¡8׌ü€COV2=ÁOÝF×Uù¯‹–”ö
wÉ"8¥ôÖȯo›}ÃHp¥9/F²rj qœ€™ É#¾¨Á§Ï3åÝ KM>÷îpòJ)©}ú/!ìÏòÀ3›Jæç5–Å/xÄ H
7û·4ŠdMïˆ.q‘áš!DZÍjÔËCVä榎 TBjZ¼ÚW|%˜ÜÌÚ%R0½S˜Ek"ët¸¥Àñp °ñ˘ï)I‘ÃDPëÃB´ÄjÆ£ž‰²œ«¸jˆ‹õh¡‹¾=w”‰ZçºIÄ7!Ûø4^qbçáx=÷ ½5™3·YÌÊŒòP®+Pc:´r“1Gêǃêò6Ë÷Ö@±åñ^Ö²£)³§–6ZƒIÃy[øLƒ8’$ Ôp!íÔS &ð7Ö§~ýJZ-&ƒ
Q„à“
d_3#KÄPUÕ¸3ȵ¼
žhUþPè˜s¿æyD‚ ¦ê} =ƒ?8:ö¨š¾a–¼G@ÛËŽ
"öº½!à7ñuzóün2*`Ón¦hÉHí÷Á24ÒúÖüMœcÈÙWôä($ùwR/ËYSÇ2+gT(\ XæíF¨öò;î!£Øwf ~Qòyù/‹NüýIzãÇUp^Y' i 'sºö«éGÉ ùk«*
µþ!Õ‡ämeñµ^v̧Үv€ÜH²êqäÌqÁ„‰„Â,|×Ö//2W zi$—ž¨´ ÇØøé ½ô`²yÄùÒ£·lq<Ûð4¾Pû *ªÚtóT« Eí+ÕåiÌ1ªçšÿ ÜZC• ˆ8ÊRÕ;Ñóhiʾ‡ÀÇÎl%t’¯áÙ h1í‡L?Dþ“ঠè¸Ð)yÓËmfz[Ÿè…Ä•Ëdm%º4„Î^‚SSs‰=È ,Š,ÀæJ]“PÂ/U-.¾ÔÔ ªØ¨IëVu¤%K4Ü:T[DVB«øçø< =áŒ~ä³Ð$üZ_ #Ü(þ‘5YŒ¨ÊåÜï›.'n•—JÉvFÁŽ òÊúeøËöIî·¿~ŸuiGz˜€¤Ýˆè¯ãñ,ÐUÕª®›\ì=A ‰ÚÇ•ß¿¶=“:Ä „a"Ü F“ÍÛH.´/_lð&Ðñý˜¸à—FssChp5º$3ÍôXô FwýpýûE l½z¼‚ sMžrÚBÛqezïtô^—Sšš k•?£/¨`H#H ¨’{ÿV‘á]ŒÃ{u
éý6ìmhHÄâˆSL¹(ëQŸ/³ÞX?ö8¿™S
Ú–Öî%B‚[_Ë¿-ž’êüJã–ÜvÏx)·ŒŠù`y‡ÿûÍÈlŠK-æÝÄ++6þ<Ø,0“»#sCÕ§Rgûú¶r¢Äïµï
‡Ñ%¶$•£,¡ƒ(hiµ À©'c&LóGœä
îkÑ?3BÐÓÀÇ|Š]!!Âé ·“I¡+•EýºY¹Ë*×zôÕãÒŽ$ÛÝ4\ÿJ¿( ±T?óÓÞ´ Gí°^éÕC½dw’ƒJƒ¨—c¿‡ÓKš¯† ·;ß1 ?¯$! ñYIøeÀµ"d}ì&Ђ8x‘iëѪ™v’ÀFZ5–MQ
ŒÓÀÎYèÁ+™lNå„3~a9‘¦A‘…јqGÉ–Î:D”5gn¶n½åñ9‚~ptÛá™ 10tÛÆI·Ù¶¡zwïò´CW×1¡}Bi8,I
72\Ü ž-©ËŠù@-¦@Év:øðõ¨Ç7WH] ‹(äÖÜ"§±¦ƒåŹ€ª÷%éò,é(©•«ZPÂi–òöõ9«„ÉçaŸþ¾VTA÷Ò-ÉÜ÷/x™/Ïÿ“{¨Èµ™¿†ï8 õª¤uO‡™ôa&°ê™¤³iWˆß¿è²]üYÇžßµ
”hc<ºË"nð|ågßëšîãQäý–ñ>e j¨¶Ü]Ð4†BûàW…zÄ0«HÖÌýTCf öc:¦Z7« $Aì[Úߢl,ŠíÁ* G8'Nnzì'ö”r”
Z¦³ Ãâ7ûWð åÞêcZ™ Èb8S´$ $7)EfXòàãºhËw™:m:ëfïyii«rI”Š Óæ @4nzõ¥Æe•üW% 'nÇ"+Aº¢ ¹…ØXÇ Ì\ÛWÜ1Ó‘k¿‰Ty¯$U7?ý³o/²5ÈhP² [Ø 'Î ¬€MjàCþ8²ÙálW°fscuÕ%„ìDž{*´R@é(MÊé³sëA³u¥]´yHY«Ùôݱ¦`B¡Ë%o5Â/hV¦é¶îåîî˘,˜…'qš\¹£Ìð›ÙͯpßqÃ=e¤%ýÝôÆÇ8qdÙ½D$eTRY %ÅUÊÉ‚ŽÿI‹”„Ì
•@d¦|b. "˜àS–¶Ž_X诞Ø|xý×c)4ÄÛ¼=»ä›;´³ôOì§/0EPCjOsDoIÏâ´…MtÿÃþ ”®‚âJ¸c;ƒYUÕïE¿Öxß Ÿõ_ÆaæPø”¶µ8Á›W:hÐñ0Õ›ÊÁ
_iÏ~%ëÉÛÛöÆ!–{\—y‹1O‰v¿!dó¨Ñ¾7eÁîÑûOcI6rüufU'G³[èAVh[ùõŠà½8žÐø‚zÕ©Zy0‘ >’F«Àø©Ðt‡HmO¼KóvpR ‚ÉÊ™NCµ6ÿãÕS[›Ã›š.]Ò:¶ïø¬Î˜ÿyÌW†Ùí'ÛK ó ¦Çæ@Í/,Â0Ó5Á({Y‘2Vc€t&‘hs++9c¢ uô‰”üNÓ »«94ü&1¾6vjs_aƒO¤Üo#¤$½_òº¢$+ð‚ÑH\—oúÛ›2©müù˜#W鬚⠆èË•ßøÕ4_©#6¨ˆ0±ûhÐ8æ]ôÙw4š1)=0>®kIo1~l£þYî&}òÇÉ ê¾˜bdJ^Ê[øa%3D´lÚh›e¿0é )o*…HK «BªÖß!1¼,”+ê/(æW ˆ¡i†}lŠŠ¯*å–¦U(º÷ Uƒ 5c¬¥{у0Ö4J^–4ýp`°’a:–kx!ŠÐGÿÁþæÖ BPo$tî*}w¯çt‚ "·š”]W}–kPÔÁõ`ö«Jؾéø¸bF»6Ó>œö½‰Âºb`Ji—¹}~!B+¤ûEwþmË0csf¤@@Gëù¶QÒáeqpD|yĶñ
9ÿdÖÈ9 ™j5õžÌ #Î'P´Ñ.Ý8c:R»_DåEhõgs`~<*ßWøïiÝ«>ÛqKœï<ˆt÷¦N$Á]È4Ë=çóÖ즎pºsnÂtÝLÖT¥jâ— Wª6Ú†æñ[ŒoX,F`õ§f¸17!á^ù.àI'’U+ð{7rˆÉßBxYÂðw#¹_êÿÞ¬ô)-Ö|¡Iaz
÷ºLPÐúééËXǩĶ X«»v
}- .™›ª>ï‹)†"B!ƒ°„n“ÄS‡ ^ÞÇ>-i¬úØ<Ôë”`:=~è
€†x¬ñ #¿žõ>¹áÝxt羃Ê/…æýaîÛ¾· i§ú•ZÆ) /©@kz)ËŒ†CR¸¥½»ÿû‡ë@W.þ#w‡xNZË,}3üB[ ꉰÚâZºT,"RŠÞ.zÿþX°R¢âu›3hãK8UÏq‘Ãøéü׃”úÔ—Î#WJ„¸´RU ÐcØT;8§ëˆ£YãȽr_ÂäªçDÎØg PÉ9]Òà ¬Ú’F‚ÛŸŽ_WûÃqÚ…C z À-ñå“‘•©P©P²Z#"sÉšh9Úš:¬YÅ4'ªë»ÞjO0kþÞ¤9øÉéêh¬|ýØñ×6áòüöèÏYmœÂ¸zrÁ ´ùfFÇ K"d*R•‹¨ŒÕbcêrÆ–,ÛwìQ@.Û `Ý$¥
u;ïT¹>÷ÞYú2èN¾kõ¿lz‰¦E`M Ê /Õ‚žÅ `”QÂ5° =Þ pùç©cÌSíÁv[t FNi¹jriÛ:° )å«G;Lu› œí æÚÇ2(
?|\Öun Ë -‘òVøù³A [Q™û7zÆTg…!‹Èãø&aâgjbm”°,qÛ "'ìšA¯Ïdù”}!OÝö0ÙáÜÇ~úãè+"C~ÙùëèF†/Ñ4Ö-²UKŽOÀÞ!¸ŠÚ]YÅ› <ëF~zÝtB¯ÁS‰CîoÖ)òÁBþ™kúD”8%Ys
î÷€ï‘Å¥ÙÎÅcº?Sl-ÀºL ˆéZ`¨-¬NM…@ñà y÷–=c>pÿÃì«$§«°Àèîöf N°jµï üãÕ÷„ÛH€Ð¤õ'"µ¸YVÇm‰Fw‡ZÈ÷iÓ©>%>ºå‰®-¦Ê ²b)›Ë9"ù÷î1# v±
¥/UØÈÁ÷lÛã §ðojmÒDAD‘2rƒYö+-+PcÍÝm©J27Ë›Y]kJƒãØßõ²ë¹WÝ` B3%{«o£u8pPMòaÁ œ(kž—6N§81C!
ŸOƒêHoÓTîáó¼2£Sñ.—à–¦Uq ùb/¬+¦'i•n·‰q:TXØ`cÇŸàP÷[øD—’–Ùg6Æꀬ£S\WÛDž¼Ú‡(Qö¹ÂIÉÊ /«I œM™×_ À™ŒÏñA„D¶Ou1õøœBÞ®N§ ‘Cô
û93”¾ Ó/LŽ'ôüt°cyaWÞ@ú [a\A8r;²ÒâTlôË]ïŒ÷·Û[?*ÁÊu»Ä> SÓóËí{ VŽ¯‘è/s9ìáò;Ñ @N&iûîºÂ¹Q ŒçJÐ7þ=—¹ž`tJ+ýÕ{9£ê,(ÏŽ%à(/‹Ê!
® ·¨ÛJïEMž?P‰ÆêÚ†„µ Ê£ñ
\ÀïFÒž£„ýEMŠK#LL¾ rü,ÊÙ94Q{~îu¿ÔQ‰ÈËUb>EnˆðªŠU;‰ (‡: wé>é« c\i¿¦d “¡…ÔqWD’-UÌ1Ü=Ú-o™{rš¡½L„²“W¡ªÚ°~ÏÜàv¹ëÉÁìóR®6RVëV›í¹Õ\© Ï’È>KÜPÁY}l©~+K]¸z󣶧M}Ò
€\„Ž8)ß²ŠxêµõšŽB^Šï1 át¤Ú‚Çò¨¼XFNIÉŒW_Lø©{¨Š]ÇS{ óx‣«$Fü¥½ßGVdB*Xµâ´½ »Hö)µ•”÷à€èÙ|+t0&
°âTÛ¬wÏådŸ ü¥ø I
hÀ<Ÿ - ÊgI("»wŠ´œ:AiuØîÓŒ±ÈŸ»qyGÙ¥¼B!¯b¯FÖÏh‚
tP4ùQ¨¿äÎ&DîÒᗪȶš ¥
}ì”Åv“×;6÷’¾ ºàvüsÝXñ æXóxvÕÍÊâ÷Š6l³ˆ*¤ªÜS®£ ™œŒ¾«'{A ¡³k§Þ ´øûí.ƒ7´øÉã˜@ 5mpò
lHLÔS´3t¯Tæóà1RÛ ¯Óc(ú-3 › éGƒÛX+ÌнtoóA ò38$ƒù†Ë)¥c ›ã˜kQ&ÈÉèyõ3þ..NK.ô/Âá%XèݦÝn¾h§dRI£ÛJM¢ç÷«À%àSB³@¾U_s<ØWbO°hd)‡ú\^yuÌ´‚êLjýnP:³ÃÝ„´ºjˆ¹²¨éÍ¿Dí#íxY“V
ã
/‰kågmµ6>bdýSw¤ðÉ0Bbõ¡ÌLœ "à í®u—¹²jéÐgòè]ÛëµU£DyèÐOƒ^¯úõù1·Žm³‰Ï»°g´èu$ ¬{ð3ŒXqq´1Âf¨c2’ü!ýLco³1ƒáÊÄlbôx’Ï{¶Ë¯›z‘=³Þ#Ip•æ.Ä"Ž…kHÕ—¦® Y÷íi'&zYa²–ϳ!2r@ {6Àɳ<Moør¢.T6ãqÏ…=0ºº)yò—ØmngàY¢01õ,æÖ]&î±|½‚ჼwÍø ´’G;le-ÏÝœM¸›ä ¼ä¬ê0ó^2ìE=PiRâ¢Ô/JKŒ™ .˜{ëö C~IwÈ’¦ÌŸBªÔñã·[KP3™úÎùÄì•6- ª¾¶¢É…3áÓ‘o–kŽJ¤PóÈ—àøhÖ ¤·¤/6ŸR ?‡¸š “uîw‡0IÛœé%£§¶Ž© ´5ÑË]®¨ëìíÑ¿K%by ºî6ü+ÜOjMà¬J#=ºæUc†ŠíÅX¸ï
¶YûNZlR*,=¬œ%l<û¤ ׂ[’™ÕÀN G™¡®6Pƒ@túA¹š¶iˆÂ
2o«2
€=v/%R£ÓÈ…8]Ľ™lÕGSø…êçi/ 3H“??¢êñ7y ¯VxÅl6@ªBL(—Qöpq òó€5ñª;̨իÊl Ì]}'(΀ ?Á²ÓçÉH–.Ó'žù[öÞõȶX„*.éºGñ“x’:‹1úºo‚®4Ž©Àˆ½ÙL=ƒégx½ñØèZGƒvɼ\{w¤7ú1¦‰yÜñy¿Æ3óCµ
GÃbh¥,`ºSsÓ ¼í5ÇžF{úáMqm@j ƒX9«`®ºQ JÒOq–Ý,pú[Bß·»6¡‚_ˆ‡%Y›:ð(©a÷²º*E~t ] &AÌB ÇRÝ µ£ì9ß;L³t_7ÄíÝ°L!©€ÏgͤQ¯ø²qÑçžÁÁû»ZB°«µª*¥~k ¼xó¶‚GØï!=uZm
í wÛ½o®5ª:÷6‹†îczW†W Ô§ÏÿÅØ‚ÒY;ûE¦±ÕB+¿3Š†RÊYÉÒZÓÃÙtãÍ·úýÒû{ä~F¾!rÕVhã9|I$…Wþ\Å}{±ÇI)k-gùü™b„£u»’Wˆ™Kþ`0 F©‘˜@g¯‹Êrv¦®’ç—Mž'Ž2ÉwJðFèû„ ‚* jyÈ Ò—7ÓÝ6:dÂ0
bóðž¹D≴–×µU`HÅúåbŽBsn‚AÌ3Èè³Ú£¸Å~ÓL£ƒýb-PKnÀ’Dv§à0^´¬„[ÉéAâ½øÀBD~~L!:ð#jT„⣒hñëI™GªÃ“³P1ZV€,ªÎ·ï[È‘: [âbTIÅzP™]·dyZ .¯JH{Æ«ÚÂWVÁÔ:U 'x°&Ut¹›_ÑXé£Ôׄð,ÈCÞÕ‰¶C 9´{ç»w. úà”çó•GR*Ò‘>£-׉æ
½)_s2 v* côösÀ©ÑDÐ46¦ñ»t£‹?ª º`ÈçȳÂ6 µ=npüUù^qus‡[G+¬¼5çFæëWI#È< Ü}§ÿµE‚‚%ÛÑû¹Q3B7ß
NÚÅBm·Ã„{»4L /1¬ûAàm=\Øòó–Ë‘èÃS>œM´Õ&ò‚í4=
©Äâߪ?ùè¡&µ¯¢ º”ȪKùNÌ›K߉dG cH .¡4 ¿Š<ŸÔè}ke#Ö:^¿JíiaÉpÒârÈSPþš´««ÊH2N—繇q²Éía_ðN¬ËL£[&Σ•h?»˜ _Ÿ-Eª3¸â}‹õã\¥`—u|ÃŒ(º¢ÈÅ
m %µWzÚÔPHOµŸ… Ép•PóÒf˜“Câi5ðž´MÜû »mÞïH¨c†_®c¬J.àÏ(Ÿ>ÇY&žê¸÷:ÏGÙ¥[I…<ëò¨ÚÀŸ¥Ú}ØqÙà¢}i¬} eèm¨ Ue¼;m$È2$õ¬«qlXq²• ô^ȸjAþÕ—p;Á5í¤ê+heý‹4¤´½ªØ1ÛwGêëuËÅüÆ (,Së˧¤•×·) `v”Jå®@ýÓÑÉŽ)L
ªzfÀ°ÞwPÆú“P)½ ¥ªR|íÔñzÍœCþ ¬¿õZ¬ØÚ5ú:©{Úr1{ÛPk¯^…þ_6,Í8㶷À×J;z¾Œ»©çïËEÜ Ä e(4"CUÜ̧7o^;[<éìaÄðþ=BN| $ëæ
ãûy%D2Œ‚¹¶šôùé¬ ý0¢Ì;
E.P©PÙǯRX=ÊrÏ›µø¾ ò—@š
nT…V²®GØ!j¤i~EÛÇCKžþ¯ fX£ÝÕ«ÿΈ5¢P˜WMªG™ÛŽôáó9Žò ’S
@ÿºb\FÁ EAè…KJhœÕ -u¦Az_B·Ð£YþŒcs
uŒ{̉¦z!°PÔeWÖW’×ßLÁq×QD ƈn•†¾x¤~ Œ-æ¦ýLÞšŸ ’òûoòaFmî1ÇœWŠ«p Ù‚°°à®óäA+ Dzv&Šp;õ—›3?I-4iRjtÐŒzi±¯×~±pØDTxÓäNnPDŒñ ?x_
_t•}1M±Æƒ''¾ K?¦«½à¬!~ÃÌõvÏR6>Çàr&Щ›Áaœ„iÆùHQ3ŠkTÒE¬Öøàô*ÊÒe“Ñ*³°)pÎ Ùf[þß´Ëß#õDÑý…9²ðèpf ãeB ò´›†_ƒ€®åÉÙðéÀ|+$”øÉȰ‘–÷iͽ7\@|ëàÑr,ã—Ç"¼F_Âó£ )·Û›ÈŽÝ"?-Õèv“´È¤a ž°DœYÌœâñ¯Þ¯Ìט¸kkÚÚ*£Ò6·Ò‚úP&¦ÝBºÓ\+Oñ_ÒÕ8±½¡V‘Š=þ½e¼ h‘qö74yN·[–årB‘²"`"]¥ .óõÚW¥hŸ ‹`ëoÁ7‡K>=ÃH@º8Š²bÙsaªýRµW+
-Ôøüá&Ò^/ãC}á}Ú1OÓ#dnBézL.uM}ƒ".PöFv¼ ÏádyOi(&ÉÙ ‹ikNŸ †ø}íXÎ
3};ÍÛ ÿpeâ§Ï àCšc—Ë=Šyáq—ãÀ»ý$j|«¡<úÚ²¾¾»H?¢çZDZ–®æÛQ¨À÷©“–ôÁÚ
ÀÁLl×({ß8%g. îJŠ´"¾¦æÝÊë(ŒnÑaë˜ñY>Uy|.µ'D‰>S¨ýµ§ò<ÏÂÍšRðQˆ lTŒ¸pt‰4m ïðCµÙ.?îUþûo|I*±ü¨
IrÇí`x’ò´¥§d¡l˜_[šôªŠÔ:ŸGt¿‘8ƒ ˜ˆˆyWgç?öØÕ`<µ÷<ÅÔ“=j`|ßᄱ‚îÂŒ¸P’Ë~
,[Š5Ø_ZË›;?öêU—Ʊx˜O/v+FÜÁ’„idë ׆•ªmþðnœ-Í+±n¨ÑMêÅø¹l@õs÷9žoÑÔi4…s^TÑ §zƾð¥Pè¥o¸¢FZëHC5@ÒÒbVì¹¹aÆW÷ïn(Ýú$ q« J¸„ßRàE ç8%DÒ/yã÷¹
—à.÷RG,oæøEÒ̶‚à-€½øP$)U˜¸LEµY]Ì 8Xî~aL%ýŽš¶ü¨wª¬[ Ÿ< ˆ5©ÎJõ¨k¤yõÑÖÇ™ÚÝ*åí-Lõ¼F?Ï
Jk |nÐJ„¨Œ›»~4yÏ~#g4Dpy«(àÝÈÅ.¥É!ˆè™s"·_¨ÖµD‰{tbãÁvbú§KÓä43#ÿ²¸{ˆfc1)‚6lüQ›¼òãCÄÄ=Ôú9> Ÿ)ðĶU‘©•!ÿžÅì ,‹:)^¹ÍŸµh'†ý×òØW \áD§)ˆx´0ˆhü‡2áz˜phçkpþô22í@ÍE3cGÂ2¢@Ûg±óîê§Xé[šñ¨ ~æ+ëK[‚u‚¥¦'£ßÿùó´AÛmâ LN~DÞ%š}¶>^sHâÜvÎ?ö—ô"pAzóí&|¾sypÚ{jÐâk™þA=Y]C ®â NdßEÅ Þ{ÜÞoÜ=ðá(¦ ø‘{?~ èeÓŸ(õÐ {|ü)TpF3°ÂÉͤÃÌ™e É!Š›ìƒWÔ%°ÔH1ˆˆFA ¸… •+)Ò È
¥ÆÖ”} Ž*Êüv·ãd‡Nö:LZdÕÕ=¬—|ØïqÖHÐÓÊ—KCêV©øweaÏÙ^ˆ[Çe éü”íQ[âU]/{À8FJD8±øÁd¹âø×¾SYX‡ä]㟠D d8ï}öÉÜä‰cmà 5õY.Umsü=‰¡N½‘ªqBåDvŽÇŸ0‡H(Ñ^x §*~dšm X¹r&ßNkÎܤڰÀe]‰³f“(Ǹ“7Lÿ…©‡žÃz]*ô¼Zmw æfšH ‚È¢Ÿ¶4sSŒx¹ =aä(ÿò¾Ý€xÃÀCiú©«È…+Z˜ÇGÎþl@]{êl™ ƒ4âj%mU¹˜~aâ| R ïùìYÝü½X±…Išaˆð‰–8.‘M¸žîXÒµYà„½vâ¯þöÎw4à 6ƒm°
‡‚K•w'æ—º‰ip2Ù§‰.Ã5‰Úðj'’UÙ´aêû%¬¥æ»T*ü ª ¶—]¨Nˆ/]'¾Qq®°þŠe ÂœŽ÷e›ÚGFÒ7üúœî5 æÜÐðç—‡–‡böÉqž½fÔS®¾ ( ©u ÖHü§ûHJÞɦ 7º»õ‹©Úʘ²æ×IzäÑ°\fÒéßÓ‰ŒVÚK& o,¬Gñ…ˆ””akÖ2 ÎÚH&…]
ZÐ ¸p «¶&.C¬ätD²”*hÜÏ9ËÜ•ÑF”&OFµ¸¦+†w™å÷DHÁs E@àPøyñD ºXêüƒ§cñÁŠªq6ž?5²7îiÄ·ÂÁ¹›€j™¢;†å7¾V€Öœh¯ ‚µ¥j£©3QŠEÀ¦#-&Æ ?fl0k…°q¢÷tQ œœd,ãŒw_BÆa†¡=ÓJ5
@”to¢†tK&šüÙîÑA%¡}\Õyî!ͦECÿ2±¢Z×»OѬµYÃIü9ªs~ÃAÙ”–Å„|°¨Ûv ×TMï‚Ë8×*ÖÖÏØßÍ¿›11MÇ|ô5³ù³ÈŠø9B¥°ëA…!o¯*ØnÃ0Ö]< ]j€ù$G
‡¥W=" @î¨xæá7Ï%½õ¸Û¹0 {;cá ‘o—ƒ\kLºòɪ c9óJš¥QAîþ.
„çH³ (FdL ÑcñW$0±–˜O„Áß(~S¸®Â,ç¶a–fGÙ;±>ú¾Œ·j*²a1r-_i×æàÓ¬žÖ:dÃÉ”Þüþ´æF|o ª“ƒ9µ/¹·²¡ò†Âìó½±úé›K\ËßTfq*1ˆš®|¨8Ͷã >5÷“,œÚ[ìéÈÞWŸûK#*tAÊLþãâ¹"9 ö‡GhÃñõ<Ý^/„tîœ#ê~°m Û«‡RE›íí9nÊ&ô˜pëîd0#ãÄ)Ž•g‰C=¦>3;nƒ¬§ß{=L
û€ ' É¥§†‹ðo;¬q~Ù¡p{NõŸ = Œ¬›óîq}ÜN/—áò¨TWç½ Õ|àywÉÔf`1zÒF`g¢@6Ÿ G`Ԋ׶×"t¾]ÑQ4«z·˜oç\Ôä‚8 -ýqÔ%‰ª^EõÆVÕá½V¢s®ÛnâFS‚°©¼¶”ù³õà¡ÝoÈXÓ üx`š"±â³ªš¶c¦›G»J’ª…L¢íÜåå“wǧ®é7¦ŸÊû;_$Ÿy†oÿ'“"lÝmŒ¾lVawЕËλ >Ê*®^)#ú!—ï¬H c_Jü5&s*B @߬@˜øYÉß„³× ‚¿¾O Á¼ek°©Š¹%¸îÓºMìí¯,Œº^A5éˆt›xmsb]Ëýÿ%XØJ²XÖ‘äuiîÔVyº:ÿ% è0–fþõ 2û/P·'ø§ÿé/Î H\¯'œèoÉ%¸Ž>Q°³à¯€C¥HYdÞwßÂ@eã°L/H.Hô'lÝJ±wˆsw
¡¦©B–´'kµ*5tñ+Ôñ0´^ù+a¬-;Þ„þïAœ‚Ò^õ—ÜzÆ—$Wºm혃ƒ"c…8ë¨ì-1‡‡[´Ã·™Z¬½T_< .Aë})óÄNƒ5ÁÓÀ¡!Gî£:#‚ýÓQȤx*ôàœvŠ±M¦”méqªý!˜ø¼u ‘p„ ~>;§Üâæçü6C"¡ü½±DŒŽ ë Ûj(4…iVIöŠ‰J{ú‘k‹1´|¼¯Q r‹lÕ9Ý¿àDCG{·Z
‰ÄdrÃÿë1ÝÓ(6â™7Ú æG9ÍœÏä…A÷!@@ÔÚ^× X 01_ç?ÛÇî˜Æê$ –'
vôJÖ>Ê"o(—žÔ³z|} þmE”ñZäþT)zú®9‘ÜxX
Àô?‹§ì³)R¹-íÕ(¥ëʈtOÙVKÂnxífž¦RVÝ(ä‚O4ùÔnZÇRº#,ïàêYÉBëý¬U܈@‚£_ÑsÕ†
³—ôU˜6e¯»âè `Bs—¼6Éxùã Y¥}FjŽŒsYhÏO“@&$G[…õš¯SQu†”ÑkÜxücŒjFü.)ÀnÉMrÞ*%êf[ðôêà40€da ’A7çŸ(· =HtB!ó„‹EŠ¨kïúñ.ÌYÓê4ïå‚×>Ä
&ÿINZ#ý£tYè D´
ÁŠÎ„ÞXz³\'Û= JÌýa#y6ó¹¶Ô S¥^V‹üþ”óõ:] ͯÔû¥Âœ_Lö¨™Î àmã†U)¹Â=c«U[<ÁWÜûøý"ŠT‰E:‘ãG¨¢>ÆÞ×IíHK¾©üØ°[xHCV†ÜI Ô›"5e¼º·ÑÐUÏ©,tu E´œò/WTG²« ñôœ$MrÖýtò‚ÌÔ3›¢·e¹Ï‚L(çïh!\gQi½"7vÇâŠhHZp¼*ceÞú1;ÏB©!ÍD5›—]™á-€µUá)nJ¶,þ ƒ“IXÒœ¸åÔÍò(ÉBEZc—Ïl¦E‰ì±iÓÄÎÄν+°çrÈä¼ç0sbðtP PL]è].ÈDg|.E™íÚcµÈéÈpŒÄ__ <^ÈG™¼\b¨7½0¾”$gé(áû´âR¤l˜Ä¥ÆAú¾á/Ðgט¦~½Rˈx èƽ’ÆFe¡ÜÈ"ù:ž*åT¯<»Žã}D{>¥çÚ£…y@yö,clÎlîœ~CÏÎ&ŽmÎÊSxÒ-ædGê ìô]]r‚‚ó
˜•[”8‰ú}§š|CrK'â¶4lG{îj]æÈ&e>à6ÝD£ÎN)8)oâ—$Qèió1Ø…eèÁL¨ÎË—ŒÈã]Læk=²¹ó”ûèÒêþé üí·è´ü‚BIœìƒ%p™Fmæ^=5?Œ Ôó‘ ó $ÕÜXõö‡€yMzÈ-Ü k‚¢‘7&Hè‚-Mz*võT 8U¡Â- àzͧërêºÐa1¨\†ATŸužÖôzåŠé;w˜¬îOîœX¶|µd%.
Ìæ¼lJqT
$uAÞéÁ°Ü4#U·ñ‘ClØâ!„³%|£ZqK¡¸~_è÷a]ª¤ƒâêßc/1ÒŒ\ÄÄÈ1HIÒODg8È[ƒ[…ðÊñþÎŽn“Ùâ¸K‡°Çô& ÙŒÆA%Ê{‰Ì=sã`õ •±·v IƒÉ·k¢ Æоç
ª´“®
\ºä\ª-£´ûçœa ¹^Vê##âÇЛC€g—[”úVAÊÂüóá0]ZçQ¢ÂïR
j¤K)Å^Še–ué7èõ‰XÌ|6ªUìÇl¬QD>{ëÀeýH^j*áX@ –šx%lÚ“÷
î‰ÌXŽ‡ÇÓtôwV´ãq&,ÿÔýÊŠù7I9V,œw
eEóìrúg_ØÉ ä¤Ç4G¸ê»’L"SSÝ<… !Ù‡Ù$½r¦ÍÞü¿ì äF)PžÙ˜É¹ö`&¿Ó8›º7j•‡§mèˆñ2ü©‰€ÿ»»~ðìÝž&fú•ð“p0Á±¥n®Š^/²Ö; ˆM £&9éñžH˜êµªéoùªþ¨º{îê;¹Ê“ÜdªO`X§^Ì`79ºéÑÎÎÊŽ‹Bg+È saú©ù¯ã#/šµqìx»J*1³8ï0éõ²ã7´KÇÉ(PÒ$‰íØbÇiD¯ Ó¬;•* Í«>ô²3…ßÂ0íË#AD¿CÞ|q’ÛZt @Ögü ó̼ÁR¡z3ã›]ªÏYƒ×Ì6¥šìaþ
z¤ƒ2E õ…ôí¦ûx_øYËoDå>Þ~<ÓMk TûBBø¡í½ÞíœÈ^q/XoΩ} ²¨ˆŒl#EÛ50´ãÞûŒcj6/™?»³IgC{aÕŽQ3³Q ˜¾'žk
Fº/8cžO‡ÁÉg5rJ “¾Î6gõ(4ó¸]F1™ ðÖ~òÀ¹ázlTm‡ã —yò!›¾¦¡¶–}¾·aÀ›Ê™ñDsÁ<™¼ƒwÍ
ž«ºÍd_ã!:Á"¡§qÎÇ·ÍØPmôóÅÇMWŽÝ2íüÌ-îÃŒMû€:¶…pÕ9Ãþ)! aßw,L
‰5ôovÚ4!ÒT•Ý¾‘ÄŽ^ÃW 2ÏÖÝ_þo?ÔnoàyÝù(¶Ÿk is¬ÐòFéÛZÎ)ÍA0’åÞ¿l¨±ð EÆ™ Óé—+ÏÇt+i༗+x€ÒÍÞiœXs)”¾é)ÙÑÑéЯ}kü
é_ºöÑÙ-}ß$Þ„˜Ž·~¡aßF¿¢‡€ª3"„
?K?ÿ¬·1Q]·»—ÔjÉb¿éømÜ1cýºyØs¨þ2 ‰Òÿê•œ†,—˜24K[e¨OV؃o·öNºÅßEËÔä§Ú¸n3 ä´ãJÊ?ͼµZ·ŠîänKøº>ÃUž²—ÕtéÅÔ £Û×^Ö ‰f>й[Œ6öj81++¿™\ݯ~§g¶ ðD4å×Ešž± Š^!Löƒð7IQ¨¤g”Þ6z»o[TÑŸ‡ i÷©"Ï`raØ°L²VêYºcÒ •Ê¨?h|3¶nTu6~j€ó£ ·*`x_W›¹÷¾VlŽ¤F€YÅÔs$à4Âxö܈ÛRDèXƒ]çsÓ›ýï܈a¾wsÍJ`º„–ÆÈ%>`ænH«Ç*6гFcjx>_(dîÝ^Ó"XÛ•taµRƒFŒïØòýÚÇצ´5J+] 4•d&Êá!‹Ã\vúñüØe øù˜8èðdrÓG04µ…»ÏÊQQ…3\J˜<Èã_uƒ@¡œÂ> ¯ zÔ¼l§yñB)³í—üÌfÚ [Û_ þ-áªþA§5ê`Œ´Â6vÄ=‡ê%yƒ]ƒt
ÀúxGYc‡^E³C›%ç×—ñF·‡W„mœ&Þ.¹c;yœQaö O”‹¥‹tqW\'ášâÎ.¥«Ø´ó¥˜öŒãÉ5t‹hx •¤»Ý½ˆß7=i µæz nšýó^ ƒÅm¾ù®c¹äÅ:¿|
Ô’ fl=©ÕB¸‡}¬R² ܺ†((ÿ~pôxÊÈùÚ_gfú:ü“^óä_ˆÃ´“{hgwõÁ§\+÷òYÀ6XÂF©_a"R ¬HÚß´C ú¹cœK7–
I«s°
·¦C=
X÷\4{*Ë·¿‰ÛÛN&wO\ ÷ÏØ\Ü^VkÙ¡çY{Ā쫴,œ¾˜0¡2 ¬Gwh¡Ä}¿(½¹š¼ XWHöÇ»hz,€¾È&ÿÖP²´‚;"0^½ŽŠ6Ð ‹Ûoö½„q-bv„†ù.ÃÄ8#©FÃõ×ÆÔ&ÈÁÉ[ë¹7]üZ¨{|²CG€Úƒc UI1mugb-Xèª kÐ|ã=¾éš|净œý`DZ_ ÏÎ9t·vô åàekàŽ_PF4¢î?Ôúe_oŽëó‹1ÔȾ>OUßf›c˜¶¶F-©2fáÀ ¡{}§
SËjIþxÀlU¹[Xþ~l°bòr~]3mÌH‹½8ËU% ˆðÂõÒ<Ó#¸5á+©:o…ü&}º+QŒŸtÎÂ+["xc)n2*ÒoËÉ{BØÿg"ó¬ŒÔ *«{kŽìå?8vHîćžù üœ'™€a\ Ò÷a@ËÝPöÐCB’Ä<žSÄª× V.y‡ƒ+‹Ãd·LÌÈòêgŒ«ês°<öË`60Új !ö—™C„%f™«ísœébõõSôu xõ5 Í]ž–PÍ熡–Gb¬lÇ®iú‘åÝ‚Íz¼× &ÒV¶ÒÒ½¨²RÀÉL€¿Ïåþá¿+£¯pôæV‹4kæäµ&ï® HC;ª·*Dþ„F5f¿pz–E»»Á¤Ž$%7² VµsžWd˜—YqpÅ#N·MS® È©‡½É“*ÌGŒê‹Z’vg °„âáuKœä?vƨ5@ ;ÑCÓßÌê~ÜÜ’»¯¶Ø/}1ǾEÄÄ=u&E0ÃCPù»§ÌVµŠ¼çK½1t]•Þ «s»gAŠÃ3ó§Ø89» ´À³ëK½-ÕüçXÇeúbrîU —Lq3ÏEìÉDò)úyÅ%íº¼“‹ª¸³—WíªâM3F§á×LOÁ MoÙ`'ÉNÛƒ™®dQßù÷ öЫžÍ%=cbÊàšQ~þ~zge·Ç~ÜÕÂÊm˜=rÄÎ1¹Gºï„6i2›DÁT&@œM/.ÀK?5µcŠ‰RŸ÷&à4T&0×+Ò¼¸/£UIdÎ ¼bNq)cPFY"±©G‘‹, ýÂMÇ“;ºŒ*
©aó"~ ÕÛ™FÎË5¸¦Èôk°0@è´Æ ™ÁU(àˆI„û½ÛbfrJT¾+{µ .À±Í\=˜¸ VÝQEE@üÃi‹áyj ?CÏ‹óafÑ>鄸å¢Õ ⠸ƒ
Œ$Ç` duŒ7ßí‰Ê÷Ïøèy%jÖ›©|·Â/Þk×XDt·? 2ÁœôÞ¤ ÿNÝ™|F+á3W§C… ³+¨÷‚7þ¼`Ô á‰È¶^/àZSŽ¹SAÝý T2Œx
÷D?cÞI=Å+Å´;†"üP´~Z¦Û?ˆšC…‡ÞòÚI ‹c`•ñ÷²2¨×ªÀƒÚ”oIoã,AÝÇs£ã#VYIƒðâÏš™ª\-9؈‚¯¡Š¬ßèÔèØÅMvÔ”¸XÉ\ã=è¶X”IŒ
à›·µ !•Ö±J?pÎ!¤×
TvìÅ r„Ía
”õðþh–ª·±Hȳ«Þ 7Æ¿`)èÝÿe¨¶Ì4ù×8Ý ù ¼¿¶žüZ)öVh¡6ó,û®OX̲÷JêÑX>RÓâ/^Ú5Kš‡Çq®Î-ð†qT‰u€2$\*ût½n†}ãÞ^-O³07ú-¼ÏK™®Ss ]fÙ_4‰áù›\þðÀÐwÂb5˜~h¬ÀnX®¥òxG#ÌX—»‰VD%ŸJ—`ö[ Òd aûÊL li<¢õcÜZ‰Ç¼¨âûÜå^´½hñBÄc Õþrñ%oG¸–‡Š õÚóÐìÂœM-N+f‚°çÓÁd±w]w%àц† EË-â`?ÏZÝ4«UIU=Œ=¬FÜ(í^(Ϧô^&-@`‚õ¨—#ÉÕ»z–PÎ
²œËÞ0}er _Ô.€ÕWô8sE`µÄ¨_Ì‹qQ·AõÍW# WT>n#ª³+Ï
c=Ñ3²Õ˜n
ªd‹Š>5Œë®Ý<\åv’^ü©(kç¥óãÝFÈèµÏr(‹p>ÄÂ*–ˆ„Ñ·w”³¯ âH
•ÞùDu×EǨ›aüÖ531¤
Ë C¶;·Ä½ ˜Ã«ód»ÿÕIA¯(·Œ+Õ
˨•Ø¥Æ¼ÏEbû®Ñ?OÔã']
ô¸lwOÓ²‹)~ã$Ø€Åum=®ÿ@ÌhVˆ4*¯)“³øxúWûp Ÿ
è³óh9a!@‘¿ƒŽœT°Fkc åfY—¯ù½Îûcn§<×Yë*Hë¤Ô«¼{Dµ¥êRéÄúm_*+H#ý§uDÑVËsÃxnÛÀåÌ9¦æ À½*1–b~Ú¾Ú;t ÇzþÀŒÏáÊëÀÀ>Aîlœñ‚H rü ‹:¤ã#DªÍ¥rÙ:H×m½¾ìÝçIzwÖ-«s vƒL4¸êUD“|DßÐhebkj’F‘¦$,1 Dè§Øe³€ïÈðÜ
½«û.¦¿Ó ¤Hˆ]š
^÷`W‡cl{\8LcÒ×qÓ«é›8 Òš–Æâ >²¿ˆÆ 9¥ýÐÌ®¼[^+†$³ÖâÞxþž™)Q#•Ó -4ë+3ÑŒGOÏ¥°¼$6œxÄáLk4AÉèyÜié%c¨’Æ*ÔëÉ¥ë¢ ‰çݦ1„xá>Q|¾@$Eæ.M'Ùqh‡§ê ¯Þ ÄÂYÝh\â1Ät¬®†Y1¬‹
µ.ظ6mqt³§¶’"-¡.AðT°U¸íµ:À#Jk+töÕº¯zZfÍû³¸|ß‚}"¿µ§°÷ã‰>J‹Õ°C9ëÝh ‰"Í)ˆ9-’õö
W½¸ïÆí>:æ»utÕ9L¨Çñ¢Ô³MVóœv/0SÒñì¯wâçPc»Áý Bmý…«ìQŽHÞš"j¢‚Tç°/0ÈÃÚÞPý£vŸòÐö >0Ý6ÓÜÇlÓAùÿfT¡ Yy0¼u< ›{ú¼wU¬í”îþ»âÅñïÂ)¿¦‹Ÿw»íÉ+¹4€tµ7X£ Ñhv áÄVH¤UfµÜ‹ç.õVœïäîS Q²,$µy}V|M±Xøaî+À çà–¿´³1u€¾'w¥š PaÆr¾ ²¹ã ×;w,!Ê\ÄŠ æF¡Ì2ÿ!°f¹°–Uˆ<û²ü”~Õ,Â:E¦±]q¹q§$Æø „õõÞ€y–Y ˆ 'µ/2 r G¡¬v6 ûÆ¥£ëÃ"§œ ;àâî^èÉ«ƒõœ« ò‰Vò)Àk }´àI(dƒÊ¾Ûæ@ítô¥ÞÝ̦6ê5»ìk5]X±Næÿ¹Ôz¹q¦´Œ0©Ÿ) ÊÒÞ:[oHü ûÏÖ„Vƒ@è€á©Xl‘¤´µr Œõ¦Õ•1o> Ki3gš
`ãX`)DÒç¬ nò„Qg²ò08””FŽˆ¸
˜ôb¶Í¨ÊËNÝjmìÍzŠÎÌ‹Ý]}Ø™¡ô
á.¿
|Õ g1☠ʓt‰Á:«€wŽoÐÝd5¸ƒ8·=l^t«îê Êßa fØsúsC–Ì)‹?ï…- =ç£<þÊ÷›"üÌï«õéÈù³SÐ$ÝV# &ËH6ÄÖ\&¡aòåÌþ3hº w¼Œ!fö ~lÞÆEšL n`¹¶.>¬ÒÔæZ.ù#¨Àróˆ›NÓ@áS’aˆŸÍÈ}Øòeº`óí‚æR„5`5@–~ÂĦww'$ F9¢í%nT87pÁ«ÀHÑQ’²|%j§.ßýqG‡ã ªJÂé¶cTÁB¼«[®0Q èvc‡/kFÝŽU¤'ß!QÜ…Ãê©2}©\¸G´.ÑÞi3[;½% ~ψk•ï)§ü-"¬Nˆ# ꤉#¤x2çaRÖzz(Ší%+ÅžŸÅè¢#R½oè¯&L‡L·èŠ¡EL•¹€Ð–,K t¢™ k_Žß- { »aNSm³Ò øÓv/¯˜:õEƒHåòº Øz5UmUÜ—A[ôH=
] —Emxž æ MDEÿº`ONSi¼Z¦žö^ê®ÒÌ«Xñ¡œŒhq#òvÌøY˜Å¡pVLÈŽË5¾d {!ÈÞ 6¶^ãûéPeŠØÊwi劅\4˜Ý8òoSòdá†Þ¦Ýe³BÅÿÝÒÜS© ¤ÙYËÂäše0š“3ÎKíŸ A½ˆY;CtÇU/`“Jâ§g›*—L° ô¸-2ñâN¸õm‡ßL¢-žÚ[ ¬ažs H†ð´œ [˜zZ¯šé'#¸qëï"•ŽMÓ
²»-d
7èh`W«—@Ør´f/—éàz0”2S›yë¥:º$Ã&QˆY¥µ^¬Y…\v£JÙÏœ©Øpç˜CÂm‡‚4˜ñwêþ„jÕ4+Kăäú¯Ê9"[‚§Üh
&ãÇF›ñm$|žÕW˜Ë¿Ae
Ö~ý>Ÿ– —Ò´~i V*„´ b™×l‰k{P¸*úåÕBŽR™%ä#Q3í±è« ’y¶ñ€÷=ÖÍä oˆ®P.ð· £üÓCEê-à i ‘QØ£,K… g×éüõ$,Ã¢è ‹ò²`”Ý©Je«à8®¾Ö¿ nÜ,Ix€VXšÏÐRjX=…X¢ !sÊ)r_{(¾Gq¹³.8¨µRŒt¢Y! óôÄlr7“BÒ0kqÚY©°BÏ°C–ò@·Ÿ‰ÿYÉžXS¾/mßDöŠsEyG'ÿ’›Ci!d×bÒÌÁs^¯³]-Õcû—357µŸ7¢Õߟžº´sŠàô µï2 Åö¥ëdÞåžd‡Yãÿß¹ÕM,zoë®)SåCÝ»"sÒ; }”ØÞ[¾Å
â5´_Vsù:ñ»‡"ñ*Ã8y‹{ùS¼¹LY6úežE¿´=Qå‡ rŒ½å¹/¤ l± Sœq‡ÀfäÊæôÖÕ å€%K„*‰¾"=§î¥7§È¹O^FÍÅÊÔÇéiDy÷Õ¶v ämjƵ…6- Á_‰š*«Ë’ Fâu‰9îã$\D…îÛñ%I²Z÷MÔniΆM^2Øòî#¯8iùf GY@¦-˜³ w¹ØÜÇã¶Â.¨‹üi\ B'×éVð|4µ0Œ_ž‰{¥¯ì|‹sÒàkô)öŽB‡¬=¥M{Q¿ ã»wé D¥×öÉ:iXGsˆ{ï ŸP0E.‹oWRn½|ƒÊ Þd0ä˹ Š²¨~ÀDÃþVy¹¥U¢)Éé<Ë~¹ '@[™o©Z·Õ›ÓŒ-Á6N$í¦e]ñ9ŽÏ²¤Ã§.XCr@þ¢M í. Q™.p¦žP tÂI-Í7àU$ã#”‚ZíKéZ-)¿, Úvˆp–¾ŽÚ,ÁÅS¨ÂN>„yõ\¼‰1ÊTDE ŸõMÛSðeEç©®ÖcnÒ¥K0OnQÍuÉFbìv ý¨Ô‘jšShøG#éæR¾ý2‡a'Ÿ£z@ol±'Y6¥qIþŠÊØhN/SclZ)·=òç?3+c¤Êe™òêè#ž„âó–4$Al°
óôŠ}^‰ÍÜÇ(°ö0íõ9r‡j ²,}
$[î£æZä°-¦W y¨gàm.m‹Flr´Ö™X#H§x´‚l°8˜'9ÀCb ‚¯ØÞ‰ àfÀŠIÙ\âùÅö½yhŽìX
endstream
endobj
250 0 obj
<<
/Length1 721
/Length2 13325
/Length3 0
/Length 13898
/Filter /FlateDecode
>>
stream
xÚmwcpnÝÖelÛy’œØ¶qbÛ¶mÛ¶mÛ6OlÛæIúýîí{»º«kWíš³Ö˜c {“‰ÙÙ:+{Ø›0Ò2Ò1p”Äe™ tÌ0¤¤ÂŽ&Îv¶"Î&\ 5c€’‰=€‘ ð„† lgïáhafî 0¢üW jm`lacáPµ³¶sµ02𸺺
¸:¹Ð9ºðÑý3¤dbp67˜ZX› „åä5$d(~˪ ~›Øš8Xä] -Œ ÒF&¶N&” S;G€õ¿€‘±Åÿpr¢û[WG爙:ÚÙ dD•Åäd•¢ÂôÊ [c€´ø?ã¶ÎN\ÿ MŒ mþg;€ó#kƒÿF†ÿþÛutÿwDÃÈ0¶0rš˜YØÂÐÿn¶¦v ¶—]ìÿÓú‡Ó?ü ÿhH 061ýíbm-k`c ¶³±wq6qÈØ›8Úíl lÿƒ2°±°öøÿâþ7BÂÙà mÍþQŽáß% '1 wcy ç¤65°þG¢ÕÕLþ}/2&Æ.6ÿž7ùGnÔØÎÖÚã ùÏÿ:^]NAYNšú¿øW[ÔÖÈÎØÂÖ äü–ŽÆÿ-ü«-o`ño÷ü‡ÌÜ`ü?¹Œ³£…;@‹îìÁð?Ï"ÿƒ²s÷¢eä`Ð231 Yþyq²0ùü_t\ Mlÿ%ø?»ü'ÿ—‘LLÜMŒ`ÖW쌸ƒ-ÓZC+|E‹æ+Á©çgõU¨WWgzoµ-†ÍõŽ®q ”qòÝàðç y÷®v% Zˆ
âLàN¦¦£‰ÂuVpÞJH*Í|k·?
ÞÂuoÀT±mŒdÁn#î36Ö婦Y²r/j% Êx‘3Fë—w€#íį->Ùþ¦Ô!GÉÔü†39 ®Aš7)¼1äÛ_ ËÚƒ»%ÅÖ3/¬°?
Óxd¥hçÜ]ê ½“x°étû ´*ðRh ‡ÇGs×Xâ> ñ©û¡:ºÉ>â›6²×è;Ðêw©I¼EZ‰¹²ZvÓNwJÄ 9þ¶ qOÕ˜ g{ø[!ÃANX8å¶
®O)¥gêÜV ?>Q5Ý“€®O8ó9ãËóEà«f¨ü|§WEºEÊÓbpÅæœ(\»ì;‘µ‰©_?é2[Ëòsohü Ò›hVÝ£‡®ÇHìDž¸oOüÀM(öý ‘z<س÷;ºUÀÚ1 Fm˜®(yXkcÝ$•ˆÚƒ¯‡÷&Ëb{Ap±WMsúxrÅš!©æ’D ¦²¹ÍåÂ}îh
ù¦&®÷µÌ²ïæá{Îùö³ÒÈ'”Ð¥Í`xEï÷gVäZ¨k¢i»&åy‹!µÙÛ©V:5ó{$j÷Ò¼<Þ%„Ò"NÚŽ’Ӟ׊2È"I•È2Ñ;—Ú¾7ãq$gGv€äÎj ¢H雌 ý¯Û %îß™ neÿÎjá*ì;B¾s natåÕtƆ©ŽDÖ‹þ)’—Ej=‚†€;©Uøý4#ŠŸ{¤ØVª\ž Ÿ wRdß¼cEK#æÀØ·°åžz}EMG€§sß7‡ä·$‡_iŠeÒ§üyÊò%íÆ â+\OÄþÓž –¦;,•."µe^lÄoXoµâ݉vlƒâN³X¸ "“ý~4—-_£I(Ãã‘ÀàIËoKV)ˆ—×0æ‚lvª4f¶'Co2 4|aÒ_?Yï8Ž¡¨®J^…Áq¶øW¦¬Éû{e^5Öy¦œÁFx%×þ3Ž–Iú“h¿EŽa6óeýûòò.É×”ïu†ñ€¸Á¯A£LGg9*|êVoÈ[5±Ým=ñ%ÚH4Ìxìº“à– ÈÎ:ÑÀ^÷g®šäæ/•™$Ð ÄÙË‚ãÖ2+rFöÍ/2 é/òêÜÊ ÿúeºÎ1"ÐøÀÂÓö×—RÞ#„3Ò[>Þõ[òÔïkÿ©éîö¿”Zª[çwË™¯¯:¸’4i–¥~°·`ÜQ—ª§HxZÅÏ™Zz½ªŒ‹Î'6ŸR¼Å+ðßd¦Ær)»k°ºHZL*VÊðÔ´j€õ.Ø}>ýâ9ŽõOÛ1€Ò…A’,ëñarK;¢ll,ï}2žßŸÈô2L~z›srºxõ”@0MójAú°lÑåòÄñ2³{”"ú맡¾í$ ¿¥þ0âl/;ž˜ÈaŠê!‰ï^x W
Ƨ¹$¨?©”Ù)eB¸å¦NÅÞ4%Xt{µ> ç74Ž·~jÅë Ùø“CÒD¢ìq·&ì{a©"
wãå|¹yZ¡øw¨8RÃüeðeUüP+ŸŽJ´¦‰ª° c1›f#7¯0ƒµq$ð•õÓ*$'Š!—Ù]ˆy¬ ÓejV²“_º·=÷5ï ™ûÇ[=²_Èý ³ÃÆïh>f%0œöP„;`!Ê3¯ì8ģȟ´‹"R|÷ Û%à›èš¡˜¨Õƒ;t³W}ž$ÚCZ² T¶¾õ¥jÒž›4 —6ýyÙ$™NÿE'ÛžCìÅøø=Ü&œû›–éWö#jz7烼©±tÕ°€ ìGú €·HY÷xVŸÅ ¢òŒ’×%&©Áò¶ÝÄ¥e*¹név_`žK\__°©4ßÊëDKKE䀙4ãWç;“]\«“e
-XH²‡ßÆgñuˆ0«G×\Ç£\€¨) yŽQ8>êÁ® wÍùÁ¡í²ÚçÆ æ-1:‘éÜ©‡Tà¯Ä“ —qþi›¬z¼9HY]ø]_ ¨t:b!AûeÔnúúB÷Ý·ÙSù”Î?õ7+_цcµNQr15K³ÀÄÚßdzï©*b¼ ¦£ì6-M %8 ,º$•”i§
Îð=Ç®†oŠðtp¬çm¶
ï3ëÂX+iõÅFÜnlUc‰2O,*¬ƒ| ?QHšd¸£ J‰p jގ̺–DR¬…0(=$™©ü›€À¡Ò½àÑO„|¼Ž`£/äÇöB²f-šª…Fk"šMé"ñKÚ+×z‘ƒÞºnd;Î2JUÌ6ÞÂÖ…}X›†RiŸÓ‚¾$¿dÈ“™ãrëñM)‡xù÷Ð÷";ÍžIÏ:´ß/—Zô(þøò_V!œò˜øcŠÜÐ@XêŒ!ˆÁ]×Ò#¬tù7(Ô‡&wÊþÊ%\
Tzì cT ›1¨u>¾Ûp†Vqg÷§Yz³æî+‡¯ýF9:`w¤íT *¶®ërûÅäv ¥¼´ã£?²Ç§_jUqƒ'&dûU vn°*òD#e3ëCi¥T)ÖµgèÁ´Ã÷8q ËζŽµ˜ê³´”råàñS°
YÚGÞáŸñ¬6d bÖh†Š
·%A ÏUù륥Ù"u…š›ð÷õ‰!µX˧ҾfkûÌÎ;úzöñ*µ· &ÙÛó@i”¼ÈøFß}n…Ëâå½ í‘â4ÏñÊjÖ|¯PLg
’-×PXÅÔÖÅîRÚW˜ËãZ\ˆ@ÿºDSd -È™ñà“äËê8 `žÀ7”€·t<"îôÅžÐJÄÛ×<©©0|¹CܾA¶$+èºõ¿ÅYH¨Æ-B6ðç›dÛC¹wHì]³[¬~„õF…ëùyÀûÙ¢Kë‡t˜B±§D sò f²F2VŽü÷jÄs’{þ‚Ú-ikPã.Ÿ¹§8%c)JOdi; õO«¿
h°VÔå|øjF=ºžÝc¾O$¾~æN© “V]GJ¤´½2á lO/:ÉIwá écÖDן’øFö|@<S‚Ìî×hmv'öJ„XC™\”Ž:0›ÝÿâC¢j·N æ&îÿbaTèm1Œî8Gן„>Ì¥SxìÙ[Ò_'SûmˆÈªóå[ê--Äþöë–‰¶"·Kó„ÒéœÌ:‡]=ùYHïÑŸ ïTa%Ù Ç3ç‹Ý§ñwœ“‹ÜÞd”Àæ°€‰üÀqy2›4éÕÓ
ÌN~ßò8Á´CP˜a"ðβ› ò‹dg'eÌög°%õ½Š‹µ@™¥dÑ6ùD‰u»×ØßËú*3êÅŠO A“0žDÞ2tApu6Å1陚í]Šm铸¿°õ¨gu%*šwò•…æZKnþÆBØîi6–VÄyihyxtÜdÔ£þKÎû}ï¢Æ¯È0žßc%gy~©w° N/
ÕA
Ë*pÜeÎ Œ·ùqÙ]ÇGȃÀ
¿Ýþúè8•öíO~êà,ìÆ:õ§â‡þ”Þ;Ga·ób¸Š—afô4±UËi• g¼Ùót3Ç\ÄO/Ý&Ýv÷“Bͧd
Ø£ «^Fÿ™~PÏoèÉúºb+FæaFÆïŠÒ &¶NHÊÀžW næ()˜,Ua”mœcÕlv¶ƒ o¦±(ܬrRºC_Àð×B–Î>Ózg›¨:—lÇü0{H,*’ÅËìSЫÁÀ2ô¬€ån³ñ˜\LOØ]ë¿¢%3ÚÚžY^óÙOËE)W„oâ¨f0з‹r&ë‡Á;=põwm He±‰ö” ²Uœµ>;ùãË.«çÈ #â•„”*6¯âm-¢Î@¼vÚÑ/…°¤Y
ú
³yÞ¸€iÂõ]$ļcžáŽ®*d÷X–}÷æãô™„Y"èNÒ"T β·¿ãtÿ;q v´Ú´¿^"ïOË:=2A xƒœÂáaél}LÏÞtYÒæ•HÐqÑ㥿8ên Lv¦÷1ž÷Plb§ç©ûøÖ®¸’KÔ©W¦1µÅ kÜ]/š=Ñ<íW+“ØOÿãÑ1€
~JrJô’o2ôÝ´Ó5ÓåóÝÎAÖCÄ‚Ç6Ó8Ä ®Ä/j¸à6jêÉXzÜ£Ç6ÔêâhÔÞÇ]
ÌíØ“ñiÛ!¾)ÀÖ•ý`eú,) å[Ó¤’v+±H¨©"ìã Änðñæ°OD[¼×>[oBx²ßÖË3SÍÚ*ý€å Ž” jƒpe¿À}Y•V:¾j ‚Ð
ütJ$iÜÑýÕéƒv[S€îP%\â艽¶#æ0gí !$IýÞŸ/²ZȳÉ穱/†xº²OŇêq$‡Ò‹šœ7—§Iï÷È-÷–c©X3å¨Ã/_žJ÷È¢cBÇRè}9}Zö¸Sœ%+ÎÀàL7ŸÈa8 †ÇÙØEf 9ê±ð¾¡Ú@)’5æÓwFËòÉ’´ïi²p[!âEk¦{G»JVvHêØî£ õ2’ ÜB¸ *72{1f-ˆ¿‘§Ö§wX
qÇFáìÙ«Ú)ãàbïè5ù ?×d ý¶<%÷ 4;²é©‹½ûz¹¬Ìý@ Y¿DŽ´7O>ù–f
x½¯’
ß‚âWþ9„¤ÿ.õÀÒ*pH8h¹]U¸+NaöJší#V ‡+E é"¿½l¡Ón#0ö&ZÇ
gr€?m#¬:³‘e8°!&ø£Á?6Aô˜g”ìË•‹ÞƵå5q3+¨§Hšì–Þs U ›¢
‡ ¹¿z!hyækøúXuÕ§x§‡UÑNµáw<þ ”9×›ýÿXÊ7VÌgòˆG\X0{PxE“ˆêSÛ¯' |C¯ ÊC(92 Ë –±\m?ÜgLÿW{6¯¸‰Ã.gKÃþ1ø”çiÜ;šÁ ´84ömš»¸TÇÛù¹R|¤M[D'ÜÔö¢Ï¥–Ôšq|®4–e8OÖØi5=ÞýXL9…pÈy¨ßutËT¸ ¥ß\WÑ›9ùñÖx¬ú¿ð#—öî@|)‚z/Pá6‰,÷KÌprxÚË…ê¹Ã ;mÇðÔ™ŠÈ®f}Û˦)п×6^ÄOÔ“÷CYGE
ç9}o˜Ùᄪj.ÃדG¨ñ „Þâ`4Û LÎ ØŠâa&ω°9H—K½Y¯žX)Fç>´T~i?Uo
OÒÖ°íÏ ¬iÐ÷éÊÐv=9 øƒ à&<á¡ôØ[ºÊkø=ºgñD]ƒ|®ç¯i ŸÙ®j¬`. k¥ýõ½oóÕÚOÓ; œ•ÙäŸ3A}kÐ ™;‡Pñ7þŒ<‰ !W=€ü ‚½¬#w|•d,`©p€¦Ävá9᪋éïôÎrĉwûZy(RBò~ÅëÒÚ u>£DÃíC R€n†‰çÑÈ1®÷þlS@@á3@Ì1šr9Ñ6È‘r„$(*^¸ ƒŠÔ"ƒ*zp½ .óÄ6ÿäN;´áä{Þz·®eÌÈûäsj¦Ë£ßF7S·m¯Ðls >£œÙ eçΚCféB·x×缞@Ê
¿~© 5óå8åZYú¢ÿ&J—h•ð+ÝÍéV¤³Z;¯
è&œÙ0µ=¸'Ô¼¼lrÂŒÇ~l,é‚~$/š¶Ýv4ë¯ç õ»o@Ôw¶ú¬¢´
ûD ‰KÛKLE\’? ½ºN¹î¿ã‡#
ÑñÏuäÇAŒ¼¤»ŽÇ@Û_rb_æFt0¨ äĊíÆ#ä}ãö 1 Í’\Ž"ÞßU–$Ç;C&’³^vô®8'ÉÈp 9|†¼—#(tšàîK‹&¥§•05¡%ôïxÚÇ´NB5³YUË“žÌÓÝõ ÄÜ‚Ö QCž Á uÚ_«Á åDµÞµk=:+ŽFßÜÁe/ú@µù'Û/—¥øÊxèŸÑx.J»uƒS8$O›‹_·nKŠ‰Håy2TVÒTM“þ}î~E` BËÒ>4üÕ æ2+öNÜ4$_N¢ÈiÎÌ \?á1h•e[ðµ‘:Ä]zJâÅT >:’•¶*)@y¥I§©•R#˜ÞUÆV˜@f-ø`: ! C ˜ ?fä ¤ ²¡B¬$˜Ëcøs?†²àÓNÙ?“JþjìQ""Cî ýXQij”Þ‡æÔ.fÂy’jü$'eæ´Çœ Ìpq‚óz•™x¿†sJ[™(WÙÊÏ©Uš%É.ÑbÙŠó,)–W"s¹‘„7 úßéû»å²hñ&ø[TôøÌcô!~•ÔD/»‚“_Âb»L¸Ä`ÓV ‹¸eCa6eeÝJÑ%ÁXß#œŸi¹às‹LöÉlÕä¾sÑÅĸ¿ÂüÜäqSãûÑÄû̺EgO ?.µ1iô-“„ àUã—9iŠŒlØ;•Q_|Ñ»Â××–’³~¶áàB¸5ç@g¾æ‰CO©£øh‘†yfŒÅƒ€ð;i|‰£¤"EÙªZ¡*ªÆcêmø3 Ή(=˜¸Õ0×s1<ÚPrF~]‚0"v’BÅz—2ˆsáâ t6€öeáOR>ÈÊþÚ˜ W»ç¼‹¢§Ç…—Ã\•…Ê g…3ç•ÚÁ;DíÑôŸsIÆ>s¬€HÐë‚´Zo&D³/Š}õ|º·5‰jÑBC§g¬ ƒõëäÊÜžÉ&0ÑÈkKÕœú{”öFËÊ&F ;t°¯`VžÛˆ™_w6w¼:Šå…œê±¸?ñ1)3¸{/ºè¬Ê w±Ô#¤ã `¦¨» 1+A.»ßʵ¸¼êBK#ÁWïÁB~îPÛ5ˆai2I—ͪ ÑçæÇ’šåE¦‚ˆôcך±rö#ÞÉà^wÅ_P‹ÑÊ--8(–ÈGT-M9])ÊÕ ˆb9׿ *Püz9÷J¥Q4(¢Î9f žö"
/Lº»ïŠµ)ìÆ¡.—@ub%Vx* ÷èÚüò/-NÂB€Cp©ñÔÔ¾
;" 2+°XA¢çñ䘷ªU
ùíy®TÂ|$òö-MËg٤嵪-UÃ"8&dUwòÁu’‘gÊP
-m`.?„Ý€¤èÛ¾× mÏô;È5¡|ýÕ“Xµd;ep`‡,Y7±ë麚½ ƒñ1ÿœÌÕjÖÃeê2Z‘ø// z®ôùø%ì‚ÑÛË Ý¹7R»
swO'¡v´d8R)‚…–$\¼”äuk|ŽµÍÖÄ4„5ú¥Zœ¨À«¤ûÓ˜"ʲi•¦&ÒÄ
8°¡ˆ‹©°A²¢ŠˆL0t©vÑ•°×®ñVtÐÉ™¶°nÏ·Ê*ªµòƒ¶zìÿrMè\32Zñ°°TïòŒòbßi ŽrI@^7Ô‘ÉʃÛ*¡&…‘µe Yîª
á_ÁÒƒt;—!m2áï,>ü6µë…å]~=Øó"סcÉaÊr¿Ñª<¹µ2kIx á ¨R_^µÏÝ©ž Ý¥WJu ~øãÒ¦0È|QÄïE" ´ ] RщqŒÓDçò ÷dŒÏEð<Ç§Ý uÅ
Ö‚’¿¡bn
ƒû5 „9)ËÇ£Rræ¸É M{Ð ëÅÕÄìE¢Q m0£^DeÍ3ºYl&v6áJ™ð•q‹Én$çÆoƒ¿£Ë”K.LÜ-k`‹¶´í!¿qg¬äÚߌ
o3V7‹§»CAøgBx7Ê´Žqf¾Åuyn 7/ôJ“ðàåž5°óPQvÑ…^³6HBÖ >#8Q”¶€ææ—|S‰õêðxf—&zsIò ï‰ÉÃ&kõ6ÃÖ¹k[¦Â>¹åéþbF8¶5ÙMýC³Ýui:êWÚ´è•k¿ À6VE†ŠÌ,ðêZ¼y&ø7³8¶2v¤‰{½ÊY1LkèB‹ÀŒüÿ‚æºïΞ¿Ù®F€ž`’uqð^`òž áHUÃPŽ—#S^Fj.§|ñ~ý“íÉ––Jnö¦ Kém|Z×{J„n¤Æ=,´{Ç€g~Ï]òÉ2?É ’3„4 ˽/Ùmp¾„ Ta4œeS¼OÇÃË íB ¢¿o”† ‚ÁÙ"éÑ)¼…Bùgª³T†î×T‡¢ÊAîmU¤1GeµÓ/
M!lÆòÜ»¸,$mÓA‡
õt#é6›Õ8ˇ†~—ÔËwÊóóšôU1yS ª/ÍQ:yÕéß¹éÿ÷ÿ¹°uþÝíÜw çûÄUâývë˪¼¥¿ù;]YÖWÂ…¢XÁƒ&k—I`Ï%5ê2Œ%vÔ©ƒ.¼¬ÏÈVú˜pqu'µµ¶2ø•UR)ï´oΔ,èØ1±0ƒ¶²¯åz£$ T%–¥7£? ÊK“® (rþZÎKÁ¼b8nÈ¡F©^:–à\Rôs‹!<%F¢NšÚDcºàëçš±ñ9éáQµ«x3í7ÔÓS^Ÿ~/°Çw‡¼>ôÃlˆVGÛð=x—îzÑ—í—Å^‘Ãq0…œzÖäá—Ÿ›†ýó e ôíÂÎïR¡žˆÐl ™:µ—Ü:šœðѳ‡j‘Ü6
Ä°‚&”Ó‡ ñüSÕ™ºH0`¤E ¼ilÝ`::ü¶ÍVÃDïR¨Æxø+ÆßÕS!’Î;-£bŒ¡Î7L¨‚›N9l«xͶeuÏÒ
7D0À£à¼Sq š çukHmŒ¡ï—Cá›éÑ@ÃP3ßúwZžK†Tü^‹ÞØ ˜‹³ÛpǨ…«ÎÃdËL£ ÃÀReE·5—Å?Ç;¨Ý6n:væ1;Fàí~cðì@Å–Ú1§Ùƒp&%fãpžCúO¡ÔöÑé½pª(…uø–NEìzåÓ†xËPú5Þî—D—–x×®?l{e¡–ŠqŽ£¯¡Â¢C\N0oFaG|óú›KL•°k†|sUU Ëà z°ÜbéÕ-;1…¿EØþÊ@Fȶ5Ž2Áü›¸±Çñ6«ðW®7é, £4>TáKn7‰Õ"ýr,tœQÉyúó=ŽUÄ6ïÇ$cõMœ ,ë!F$y²YË–ü?[¼_d²· |e]˜æï{ùòòZº‚>—N[á®îºc÷o«?kG!‰[´ 1·K&Çiô±v(£(TÎœÃíÎ,ŠÍY ¬¯ŸDžte¨æñjŸØÃñ¡$Àég/ªÒ ·vzm÷OkAI{«vì'jRû f¡‰µ# 6r[µ™Ò7udú¢úýÎÝz<8‘JªË_\2 Œõ3kÂ~¾©ó Û…˜äŤ-Õ‚Mñ¶¹PêèEm
ƒ • ÓœÍ NJlkúI»é  b :õ»[6Ûút§2©ÎŸîÓ‚ Q® '` ¦+³ÞJïâùàX\q ¿ñ| ¢P ² Oó?ÆÝßóìõ`ÓUúvRøKKqÆøùoŠJþæ4X¢Ícb¹ù‰ßé«·kÇ_uÈ«BìlcÍ« Ê‚[@:¬‰ìIƒ‚”¯<ß»1³†ÖÔî"jŸ´Î¡¡§•“u½€0èX+DNÏšßÃǦ‚ º0Ç|$=‚~*ã ^±÷¦SfLžNŠïZ ¢µW F£‚÷QŒ)–»×^ó7rè¯jŸdÐ¥Êrþ <‚僙Õ~ÅÓš¥–Ë€å(¶Æ°ÕyªÑ‘¶ÿõm‹|'숀\œ™ánÆ®o(2´’ R^àïN&kì‡ú^ÙÆXõf e8ôȸ*tÖêC0%»ªÞ0ãË~ä•A«fÐÑŽÛSºvÊ|IKªA%ÒzEuµ%²3 *‹µ‰õG@zy´‰Ò£S3#Oܘ›-üÇYÜΤ¨ÿ°Ä¦«s`†vl7âë ¨–YHeZr´þʼ¥ŒÆø5Ó'Hm
†K)Û±pêÝ- –E¬ûöF•ñ=Ãd“+ Ú4˜ÐÍÌ §äk?5K¾^‡™·ÒûÎ3õ]Úþáì8
¥Ô‚€0í£î K ˘¿Öþ^í0æ> 'ú,ØzGqªÀdD
Ù5àÉt€±lš–ò›X35+;æ6ÕÎ9™Eêƒ åÒ/:^]JøLï~Œ KåÓÙpph/jµ ]®ÿE8%1WÇlÞWS=€¬‘Âo5ì,zòZ¨ÞܵùL`© –o›gæáù[¼M8,"W8µÂN/¿®+áåJ6ÖÒ¹H3Xu«J&”ZF9Ч¬ãHÜë;»lVú28©ÃŒ &²æ'eªÏ·c1¸[£l¡¥Ô ²žf
;Óö $µKùiZ ä6 6Dô<ü øI¿”êÀoJÍË5s'ǬË3Ælá>?öBØuÃu¸‡d¯Ÿ®«6ªH.TwÆu «
ŠGfhl¡õ—³©áy9©Ä…›öÝŒ´r°À÷Ößn"ÎÄÇÈ« öµˆ²:ü? O%YçdŸ5 œGUG$þ7µQ;M¸ÆF‚3'µ‘Û©Õn”]xÙ¨ª¸z rÀ÷êf á¹›ob*/ZiÈô ()nÊ`»Ÿ±îƒâ»“ÃãOÔÞ›Bnc~&$LJ×} nü—:C‰ñs×i§J︤Wæ ¥I-pUƒÒ¢%‚SJ«r¢üÌŽw†Mˤ´¼.†
{¡ <¹ygÄ—'T÷^”Š3¥"0ƒé¿ íÁôž1Þ_«^ÿ`ž_m#Ý Ñ*G}bØŸ0oÌBäî.…/1; ¹ã{zt_F¨¤þå”Ï îøB€-åÓ3öȈêOK„_•›gÃpžmјýÂWN¢°1…}5Ù²A’\Á—D;2ê¿Ù²b/ÛDj®îðn2ºLü…c–ñc‘ÎõØ ‰× †5 ÃÞÁÄlÇw‚àZ¥ Ž?ë §”£;›9oÞzüq¡%smÍÎÀª”Þ_ž¯²´ÊŠ5«= ¯ScãK`º/z¡ÉHSâ#”†ØF!TV³º›5²–O'âf¢ÎIʨ‚D
y0…{Ñ»5CÕÁƒªîZÓœº5øÞ‡n¢vÈvív—Av`¸Èø<,ÿð ÍÕF‰—AJcU:Y
g aÜ×b)¸|(y›G]™Ñ [l·W]rkW7áŽð;-pìaÖ\Ž©¾kYC5¹ëÆ#§>kœâ½|®Äd!‰œqf¾P†Ãˆ–€rˆi¡-y
0žDm©ôi¨R„ªÊgøB`ÂX‡P}rѲ½ ð0ÚÞú\ŒG€,r±H´4WÀä ájαҒçŒßáûa˜ð ØdR”ÁŸRÞkäòs©”†ëàú‘ ãš >í
,‘mÕY—ñÅy¸4€‘á8hQàEo™†—ø°mO w-¸=“wäê\—û7Sð摵<˜6Iïf¤W™Œ~=4 v~Ǧ+èÉæ¤b[èër]M‘³`Áý¼ÝCg%/i>¶GøÓÔ¥»a\ÇZ˜›¡’žó×—fzF&:æ#|ìD_‘2ºôK^’AÐIÐ× øʯ[ þË.ËÈ·ü1Z”õ“!WIJtj"RNÒ "ƒÓ}M§µ¡î54*ï'!ˆó,iZ䨬"þþGI»–»è}ŽEâYDLCI ¨Ô¥M)~úH_ûÝ.8£Ê¬OŽ- «¿ jËž®*›@8\à8
1ÈC“~”îvhrEÊLi8‡ ý=®”Ž»§ þ42ÇÏÊÆ"×ÅgÄN€µ„ˆqÏTN±¥øŠ w€¦`Zg΄
8Æ„äì† ‹|AS¯”©àoÝ[\J¥øÚÅÈò~
Ä ðqÛ$8! ˜!Œkä ø¬H‰ÐÂÅñÍAÜÚfh—[2k¤†`µ¿É%×0Ťm•
ÜeõU½ûϦ?Ãî¿þ À»tÜñYcÛ¨OTm¼
\q*x4qL‚Û£‘6 {ɾµ®ëùÄÍ&ÞÎ¯Æ w{*ùâñyªðôêîÂY6üIj2X+ Njuä;ÿrò»Ûàlº¹ óz(žmŽdFxîÉ‚yª‡ßg(Zì´•cÙÚýn íÛÑÙ=B·Ñ_¾ #Oî¿[f€µW‹´(ß&ê$ 1-[lÖÏï[¦p q—Þ•p±t³’íÿX‹€4 *Jm'l”Þßs·Œ.ò!jŽÏ»TLŠåEŠFW@ùÕÌ+×£_/Û–£×.~3§ó 5¸³ Ìûõ¹Q€ŽO ÷H†jôÒ÷ ¼))iö+WT2…›Tá3lzE§Í?Œ‰£Cx¢ãä$@õÇm—øÞm4& âG¯x¸ô˜»šªÑƒÉñ© >Y}Ÿ;5j\ Ì)w˜Œ:V¨£/aË‹š¸¿+‹gð»ªà×èx§I¶‚:³èD©IF¼ ÛJÐÃÞù÷óÀö ÷¥wÒ Ÿ‹dkèÇˬOWK±Üi;I UW•o!š³à->Õ5.ö—?Îíg{ÀØAt³Ìv†ç@Ÿ‰!,bU ~ÍjÓª9Ü{üÑ.ø äí|Z‰Ö9©vÎÍs¨·³.,Lix›BN‘3Íšš2xáë¬B9¦ Ê•M™úδν<‚“M]rdp•´JÂM¸N»é3ž’‘ÿé„#§×éÿ0qkÏIi°Ï?ß½í—Re3%Z5 ªƒ°h£1‰ |EVJG¶V ÃØó#¥5
êÝCÉå-²SÈ¡ø¼—3ó9íÐE>÷–ÐO!,ÛÆÃèÀŸ’«>‹u|ñèz¡¦ÀÙ\¤j-ŸËªª‡'eGx¡`* šy 3²ÏÆŸ!F¯\á<ßvyû¿Rù=LþQçÅQ´ùÇ®AT*:
Mç"êä¨Àš@6Ä
.”öž¢È1Âã½Ý3ëB]L .UÑùõ†çÎî&xÆASö:m¨K€¿¢ï4Ú`Ƙÿ$S1á#>Ý52]”!ɬᕼ[`€2ý$ZgÜK@#Ó¶æ}ûëM½å2j×ÞðĘVBåçJf«'œéY¸þ Äj‰)¿
ÿ¸:)±3m_ÿ¥µ£òn6sÜc ;+/IÞßkßä™»:Rí»V‹*»÷9ßa:5¤Ûuà UL[eHmï r*ÖöUÿæÕvüY’ò™7dÏ“4§Ýaå‘q ¨«ËíúçÍŸ}ÃÕÒ8ô©ôÛðwï,X’³0F®Ž¸toïŠ_u9ä– ‘¤Ð ´{ÐþxØòóõU}“k#çTð~ï)a/ªÓ]‚_L’-ð º!²§0Äè\Ü(ÈL ƒhÚâöÄP²ÁØkÇÓ5€Î¡Ø;ÙG%¹øúG ¬6ŸF ³údèVL“[´)q&*ƒo•BSº •ƒlÚL” Hü†…øKv y§
ª\Þ@Bjī̱µ ïK:î³ÜR©‰ö³ RâúÊð7÷¨uÔ0Eö4À7˜¯„Ä£¼n ”>u¾Ã>pdÿ±½\fS*Ú÷£–ÊxI}ŒÙ€ìÌ¡.ùu%f°ƒFM‹õ‹q… *ú誩›•4 Px²øþI+žíMcn#yÞ'9 î˜æŠúæŸy±¶ûPQ]Ü G €gZ PD¢CH’¬±c4Áyw ÔʹƘ{ª„±/|Êp€~’ºÝÂõìb¡¤€*f±ÇëüLì14c>êu$a×+çmÛ+ÑóEÞ@H蟲E¾,À_ÐHåÀüuƒF*Á×C6©|AN埡Àp Ù“:—iÕÆê“B,¯Eî pþÒ±‘%úÔ £òŒ(ëQ¢¶$½ëÒ8” /‰dxìÚV¤º¡C {Ó%’Åj8Yç×ÜÅ&y|
;œrwsÙ3þ®²”ýäV|~ï¥z™ Øò{}ÛUpÓó´@*1ƹÙ|¸µ4Ëž– ÕøO¹^¤=‘#€~\À·¸Å.à/a€½ûd Ú5;M¤mš—Ö8%OZ`~d–àHyÂù×·N=}¯wc w5ýÀeêü±
e` þ;pŠRk¥4(Ô .MÐ5ܯ4Ì÷Ä>ߦOZP»inßÅ¢/–¿oxj Ë,L6õtÅŒD¦Â»%™ø\#‡–ƒY‡ ¦$gcp]Í k9˜LéŽà„ã‰ð4üX¢
²‘Äe±z°½'œš«úc°¸‹ÅÕ.´›éw£º=Ñÿ œ4å–
endstream
endobj
252 0 obj
<<
/Length1 737
/Length2 30291
/Length3 0
/Length 30894
/Filter /FlateDecode
>>
stream
xÚlwpfÝÒnlÛycÛ¶mÛ¶1±'¶9±mÛ¶=±Üïœsÿó׺µ«v5×ê~º÷Ú«ÉˆÄ ì]U½ ͘è˜è¹*â*ªLŒŒŒ Fz22g3#W+{Q#W3n€†™)@ÅÌÀÄ `fdd‚!ˆ88z9[YXº(M¨þ-¨Û™ZÙY9Ô l ÜL,¼îîî‚î.nôÎnüôÿ8©˜™\-Í æV¶f E-)y ¥„¼@ÂÌÞÌÙÈ èflkeµ21³w1£˜;8lÿà L ìMþ“ ý¿°w7svý'0sg;€œ˜ª¸‚¼*@L„AU`do
•üÇÝÞÕ…û k3×eG pý/ekô_Êø¿ÔµÎžÿ¡èa˜˜ ¦V&® c3 +{†á&eoî `ÿØÔÍñTÿäòO| Ê0¤˜š™ÿcífk+odg q°sts5sÈ9˜š9Ûþ…½‡³Õ¿$*¶Föÿdò?.FvV¶^ÿ_§ÿk!åjô(BöÿÀHÇEÏÊþ ±•‹¸•§™©¢•ë?Ø»:»™ýG¬aöŸ:É™™Z¹Ùýg ³ðù§Â¦ö¶^ÿw×Òú÷ž Âb*R2â4ÿmˆ«ÅìM Lì- *®ÿ`kälú_Á¿ÕŠFVÿé& ãÿ.÷ožéy9#Wg+O€#ý¿Ú…ñ_ÏÿPzÿk%,ìàéCÇÄÎ cùçÅÄÂÉàdáôûÂ5qsv6³wýwþÉåø7–™™§™ ÌúŠƒ OˆuZKX¹¿XÑ\8ÍÜŒ¡Í
ðêtϲե©ÁÑν*N¾ þl 1ßÞå®Ô}3±QœÜÉäT Q„Þ
Îk I……Íö»RÁ[}„þ5˜:¶‰<ØMäkÆÆz"õkVîßi§R>d ¦Ã²Ž~p¤øµÅG{ *=
”Lío8³šj¤9ËÐÂkc×ýuðüà=¸2lËÂò@Ç£pí‚ú+k -Åy¦.IÌÖŠN¿È£½Y÷ÿ
]
§¨ ×
½ é1b˜ vAØ#ŸQ»}îÜ
™eWY§MAŸ ®Íñ5
jür«“¹ƒ- âÊ趨¤…kçóÂwl>Û]2aåt×MSù öBP{°MÓ¼@ûS8Y‘³0è±³¶6éD¸r–w GB†Á1‹ }FXû8K„ųƒ®Îf¶ƒ
‰1+–̦ØA !6¡¤Uöƒ¿ªæ
`d ~tkÈ’
ð4å©‘žçG#UÉ |÷ õ´ÍM/lòÒþüŠ¡$ ¡5UÂÛ¼Æ^â?Ðñ=Ƀ“gð'Bú–ï\¿;Nî¾»_¦„ ÀúVæ.”Lm³CFîL”O”Ë‘+Š@¸çÀ¸0Îõ° ^n<¬k3˜-¼k¹ 6yr[+—Â[EQt1ØóY e 2ÞàîÁ-‘GŠŸûäFÈq
²†ùjŸå_ð’§ú±³‚\±Î%Åfã ŠÁ;¥ ½:µzs~’Ã<›ç_«k²¡•ã ìÊ4ïV_½˜l{›Ôá¼L»!2_I\G!HÞp~Ħ:à ϣþ¤ifuìèêåuœÅ…+'pÚÊ7>c%ïwûˆ.K>Ý7ú€åOöïÔ‰í}i–Eú+¬téú†îC”tÔ_ùÊ«Ty‹Ü@¡gì@È=¯¿ÔÁÝ|Å
p;{l㸘“…D…†®‚vR|ë¢ åDƆx›ÏÇ+½ÏJ®œQx—Iû$?²]÷£cXJ-¸8âÙ.NLŒ¸b¸¡°çFô·žäò¹C//Émfí¦Ïaež.'À‹»{gÜÐ;ø6sLxë >žÜ}5‹ø‹³(µ<ôä„÷d‚Žr¸ËTÚQ´Ð¥óà°)´´æWí§yèLØfC±30z<×À;¥ëâ-?ø ‚_ÂÆ;Á†´¥ð½/`h}1ÝCÕQM
gë†\&”OHlO"R ò³GK‚îo?XÞh£´eçUÅu£Þæ¢ùcõT+×*†D[i…sãe(ⶖCÏhØe0í¸XÙÄ°_y÷§ixN-Ö¹UEQ`g
¢ ùŽWß%ZRd“¥0RÂðÙ‹-µE
^ìø˜¤
ŒR/ ×éÀÂÞ—|t1ÚnÔ„`XH#Ûª¾\ØË(Ð/bËòuª¯,j³ò6…¦Ù¬5 ó: »õÀ~…œ hw½°ê*$
(~Qûi±ËZ…JÉkΫˆMõ×ÍO2!øÚU”Åž`ù ë¤K9øúHÈI ÇÂ#ƒÝjiØi‘ 6QΜÎ([ûÂ@»Yó¡ðYë,ÃvL eßÖÁ¼{ ‰Øš™WŸN ’¥1 |V
ÚO uÁwg‹òF'Óìã=AÊÌÝÔ7BÊð~Ê>‡©( .½UE£ê9‘Ê`¦Öbä
nhù6Q\íHó`öÀ±Ø©o梢,}³ˆ^¼‚´fõ)yÂbfv‡AÔic4³hJÇZÕNEí•ùPWš^¯
_#› gË,£ç“ÛÅP 0ò'~&9EE‡“Ï9äúѺ÷ÇHîÎVNaŒS_!Õb‡´=²üd¹ÁXb ÑäŒÖ¹„ͯÆ3ë'Þ1'2í°ÂØ™€ãà·w™G/§oËêÀF™ÂôMS r_OÐûn&¿‚êßÅa~‘îû½È‰ ØB¤,ˆjßR°Sè«DëÜ'÷u½Zë%‚¸W(îVK»ã®¬-]Ò_ ôקSù»LWûBgŠò€Â@ÝWå9Ʊ÷[ÖÝ!´¤ÞðCÆã¡V3ͦ/Ð
ßMö™Vð×PMª¿|Xé,n AC2#m&®`üÞ_ dbÝCv(´n´•ò§5…0$ï`;‡™šY{-¤H›¥&®ü£Ã9hüµ«J Mé #7"¨B¨¯çHGáæ
rÆsÍËY–Ú¾°ìöŽe|Dá™æ¼˜¹“ãA~ªÜŸö3ÈLå ø‚ßݤ1 ‘Ú¼’zÄ>ŽàlSÅøáj•>Lf›°}06žu¬‚VozüI/ þ ñˆÛ/`¶7 š¤!.ª§Å‘ÌÀâ’Ô›Œ Ú¬JïT¤2ÁÝkAòœ›_EpäŸ Á§Sêèàm·ýéÒ”± è/¬ˆ¾¿†$yt@lM: •˜×TÌíV²d0Öùƒê6EvÚj¼¸y5 ñ¾‰=:“|iÚ@"T—‘ì´Ü5aÏOcÄiÕÐ `€—Yl¡·ª<Ë4I÷zïNÓËî"²ÎÐ.µ×ÄÈe^"Œ$ô2{`ç"NHmT&–Ñ©T†ß ¿#
‚¨¬úT‘ïH}sÞsÒþIŠGÞ‰w34 ž«¼Üm!‘rì8¿ôÍ€@ G¬ÂEuÁ>˜ Ou&¦¯Á®ØY¦Ÿùwù›î2Îp?:¶\ÝüÍ5¿€ZU/j•¬‰Úˈàg9ç+4
¤Ë4w¼µ€I–RÖÜj>Æûkh†kÁ[yðÁðê*¾é ùOvM5…x óþß³ÒG£ôu Ñþu°›Ð[B4nì>Èï«Y4ÉÜSkeõb›ptÒ¥¨¶?ÜLè©5
*0v ½6ƒWiòôæëÄ3€{¡yÃWÚD9žšXÇÌôÅ—ÝÓÔví>8;¸•Žˆ®ºë.+9^r”ììf8í=³WŠ E•z X~?úky`eÿ{öãZTe÷1äD‘FGlÈœÙÌÕ%ÁèÞ`N tóö>¶2G¨Í$Hê-0Ͼ-)†¨…/ Ö|g‹—wpG»&‚D×Ó_°Îd”h¢ƒðÞ $¢ÙÛƒ²›w׃ÒfˆûÌq(<
rõ…—¬°éÈù·Ô\_é¯
Ý&ùËÙl-éð©¿ØÃj Âxžž¹`Å…îÝ ›´ê
.s"]=öÃÚþöÏvÅ•Sø÷È––HXåÞ›Ï)´{×xO£š1ò6k, VçÔ9ªeEÝÈñ[úï=郪U0yÅ£6vâûÉPüa¬ µÆ'Ñ?ÇÀ†Åd ´üÝâʘ5ò“5{Üâ#Õg½yÿ¦àuA!U רx‡ˆ» |
ÈÞÜL:ŸF¿ø¡Jù.¤ z‰Í_…y2&÷¨èºnH~eiQfÑ…%-6–ñÿ rxp bÉs)äK¿+Þ\;étC6,æå‚øqNvh^OÅfà•]ÜþØ GŸXDq\Ïý‹j ¤qû0ïk ´}x¶£gÓ]Í®Š"‘ªWxR¹¹©[‹{O{ÌLaŸ¤¦i䢾šA/(}é•™úúéF¬ŒŽ Wæ¡b 5!Zªp¯‚
ß
‹†CÌ@o)þ¨($6ú^¼÷ôÇ%©Èa,ÇÂò—ø·OŸbB*Ü ÝÙÄ+–Í `4Ü¢¸Š-U ¢ÈyÊK¤b-3È—ĵ¬CúFïÎBvΈ;¶·{ä\¹m ó)Žcž)ÚÔõh }Û
šK…&f$AE¡S«pÖ€p¡—C,£Ùá,Äyƒx@°ˆ–Ä_OÐÒxh ÚCg0©ô)O"k¨.eT±`Rcf ´È4„ÂBGßœo/û¾lŒezV{Êb’ÅF/³a?Mn)ÑmÔíý¶è|JzAŽ©söNá‹sUj#ÿ¾¢YÙè˜HŠ{Y`‡"%"öïÜpK†JÖB§H
0…øyY¸¨˜÷‘åÚLž˜ù£>iË·EmfŸ6u—¾5,‡V‚m$nv—Ú8µ÷¢Î!~º¼I9oG..K¦ˆh—Ð ê¸{lÓ?½úš¨Ïio‡YufŽÊc~”}
öåOödIþBZâqúîuÇó§î™¿Y×òe¥©$³ÓÉhNÃ%(ž\5=ïh„Írj,lß²‹~ ?±ëx3û½|†
°švÆÓn“lÌmùÉKÙ4]BFÇ æùnªœ#cÍæ>FäYk •ÅõfÚ¯ÏXŒ`
_m¯_>cÖb>õ›ªÃ(Ɔª¿™MaFÈUcí]@ÿÜM©ÚUÍ}5z;tlklh³¸I¡›¥.¤Íke¾…°ç·v‚)b[áµ8FŽ Ú7‚2]Ÿ+ÄG¾Ôêö’1=¥(ʱ븿¦x[/#3¯´4šC𞀵ÉþL=&Ï¡…Ÿåõ¥a²vÚáûFº%E=oÄ,¥òXþI9òEÞh^iùÝÅGÝ"–L¤É?ÊA¤|XR N,<¾Émj)t–Ρ xšJ‰o]Boþ%ó»j¥Ø ‡.XD«úb0wÇõ<ÜÿØ%
k\ƒœë¯zeEjkd«Ñ!‘î|ó°ÂF´ÉÉ;Š&Ñ9¢%¹mNõ+ ÉyàÕ»©ÕÎ ´Ž'¾\•-ã}Ü!úpÌd)()l <굧’™o‰äËIJÏÔ¯jSNùòÕ‡bäôµïo›œÕ¼ª7D¤—\["Óï<ㇿE‹·›%•Ã7Ø1)Ô×ו“…ê5¶Äzá K°¸²ÞòÍ`EÆÒ]V•ÞœW¥¹ ûz2èãŠsüÚyº1öZ ä ¡Ù4aSØÖXîeVýÛiÁ§ÆhGVpºŽmÕL3]¬üÌþÊ´ôï&˜íÁSKk!Ïô@î¸aµ1 â”ÁõRÛwÅsADº7XWJî¬
’"F±D`³„§ ·ë ù ‡uô¨l“Ø$uÄìBBšQYäÞ!¯2½µ¼Œà`׈Ó#÷¾ÓÏfü>û¯¼Ôèõ-r. úü©Àš²ŠARbÛBÆçÌI^:¤†=I7Ý^;´ ·ŽmöúçSy{3û]Ëõ6~™x·Ýò¼`Ä8Íéëûr ˜¼å’v4Øåœ)Ž±?I‚¼,æ«Î¶ë5¿ãÌ»§ Ç›ôÛP»
üñé1
á‚°Ñ»Åþ1Ó®¿³ê ˜0söó+†ýÉ~è–& .Íwñ°`:*õ™¸R•E¬äÍ{„~æ9ŠÊyªW]ÃvMã$–IW T;rxýÌNÑÕVÅסÆß’&sg>¯$ìk(8¦bĤ b¶Â2Ø©´A¹þæN U/œA¸°« Ço΂ êh:ØvÏ/ àâ) flÏÿýÁ+ÞFuðXx,UqÇ«gÈEÓ!,¹1ÅYh ò©<~o7QóÆîOâª7h)öœèRÇ\÷/6×
Ôk¢Ï1-Àç¡Ÿì½-ή ²ýPö‡¿bú*é0ö[xѬP
®L$ÍCÌÝÅf¹š…†/„©SšB/ùÔ= WÉÛÈ°; ¹¤Õ"à4eÂðPÝ ãÝÿ\¹W0pч‹ ¨PÔǪ '1|³ôz † lÅȇü˜À|òÌidbs
â^a)p+H•·+Ü dk
„⣃êÏ ñ³!«óp%ý,Ú²Ûœ«¸Þëþ‘N
’’
xÔ˜w´¼G ˆŒ‘0›çf@(’ †)8‘ü†+7Öï’VË\¤´´#½ccH³Rú„8k„ý²ÖÁ$uFz\™×¢YkÞå”(t„?êø)¶Àó ãaÎèν¦¥Ñøn½³ŠlQ¼ Ž”4×€÷U_¹ ŸA4O˜µ ðŠ©oûÈà’w/| T¶äK%>{¥›èži€ øl(í#Ìã“èŹü¼Ô4¥¿‡š:dNA4»b³àyç¸Úâ0 3×äÛ8~>ÕÅ<’(#ž
H¼ \q½] Šè¶h0gßmœNpåtìcýÆg ;“Ü}°#‰F9ùÍ5ÉWàŒhZLãvË%;ÊY7¤6‘Sˆ¿©Åœ3_ä¡ÇdiÕÞñ¥Õ›çËÒmjdÞ Å8¡ùï=[‡ç˜u*AunÌ"¬Ë n=yt8P
CÌ]à–.|µôåþô“ØZNJòý°3ë5bùHåµg6!ÿîTÃÙÖ#L»ZƒNQ»:V
3_ûu„Eª L\„80„óÕKq?¨4ÎhJýÜä X0‹"!8VarÇä@ønsc avìÅõÎlEîFÓ³éÝ¿ Qp]ÀØ'N¸”¥?Ç›ÉK ³q»›ÉëHFqÿâZá^Ieµo’çu,~t« Ó0Æê]Ýè¹”bVQ»SØï"§j¾^©s‹º
œmé³ À[¥¬û ¼+vQe…ðB cä Mé
á ZZæºRºüe4 L -_!¤Áý§ÇHøØ÷XxÅDL€rJÿÖr™êöâEf XW2 •Ïår}GJÀ
`¿ì ñÅ
÷/½U KÌaèRÞ m^بXÔÖ ”ï¯*Î;nÇÌÒ×C60¡õ‰·ÏŠŒpPe xýj÷øSÞI—ý‘Q®TN)Ô¹ú¢§WW"§2ÜåErS{íIK¯MÒ0íèmÀLjIþ*qY¼,Ô; h„í‹4=ùìš3h %x6D °!ždºÉ)0#ú£=÷Ï¿DÝD6€yv±ÈžÃ}Ï£íÍ&>6
X¤úâ%í5¯nj`"®y×U©ß‘¦ºyçM%³2w\®Øå~JO%++á ÏqE&ªCÚ²q†ÐýÌpôòíZU$a ì8#½u…¸;. G >$óh)O>»ÙéÇ Î³/mMPé{$5’űiÈUª¨ýÍô* ?°)9W&•Hì‹ÞKD3Kx(rdƒÒê¼j¤R¸Œd·½ƒ¶¹ÀRD71—%üÆ/½ÆÐåÛ>ß¾T‚[«5bîß\ãOãfÚp2ÿL
Çþ“+Ìå² ¸e :x#Ö69º{¯%jPo»ÛÇòñ ùÛ®‰Ï1@‚\¾ßr¹GY‹ÀQƒý.ø=ÏC&šè/ÛLFáýR«—‡áx‚)U]?ÛlÖ+ÁJ8ˆAr/âÕ?Þì÷þ@Ä §ŠÊÇ0åØ“wÁë†å¼€ ú¡¥µ]s±q¸JuG3~Ü K`p@¿›Mg#õnLÞ¿Ê»¬¿ÔMü¸k×@,¤êõ…`FÏþ^\¦ˆ d¶þÔÇ; ›†Ü´`O)¢¡ËŒšÂZ ú¼Ï‡¢WO™‹×ý¾ä¾‘
±Ü%¡¸uçñNÈdÀrž+„bõU¤÷ËµÒ '& ÉÓ´á(œÇkØ"HWúú°£øáôÖõß'|CÈ»Œ’®aÛ>B.ÿÍüÞæ3ÍO|ö oºì.ãØf—tÕ§µµzÃŒ[\'a{·&éNÒ‘ÄW3½P‹è‡ HŠvy’¯ƒööÔŸþòèF!Žv)œÝ³j 1¥§(©oÊTU¼ÞõôДz\=_¼F v !w¼D¹âêDh#Ƕ{K9 ’Íû³cGj ¦_c d/õ˜—æ©h6`eõÑ‘ ÝÄ yÉ'{H¢@î…ÂðÛd÷Ë!}äžÎGœ’Xm¾úÒdŒ˜å±"½áÐãW… ²›vƒm£ÝÖÔJêF°XÛ69M48ÚMüSP¤ ƒ/:— 6"‘§ƒök-l 8F &ýXîË¢hž&
Y Pv'’öì•Ãm[ç°AË‘D"&«Ž:Ýyµ
¬Î8„¸Wõv:PWÈ·©Y:9Çé¦ÁR~«yÌëAëb‘)Qêv¼¨ÌYaïÏw¿¤¾Á4þt<è^Þ+Ï Ø×¥†è´ ,ëdÁQm™ª¦S*G˜›0|›¨ ´ë0cžQ,/ÞE駸£yaÍU#_Û—ÿÖ칇DÓAGÇßQŠê²ï€€ñ½'é.É"CüÜò øºéN‰ ÜŽ¿>“2¬¨!Áºx͇2uÅc˜’‹Æb!Å.†-}ÝV©qºëAÞ
žÂÏ!݃”ƒÌ'.áE 춥5ƒh‚bþŽ‚"} i·}ö<œ
ÇFc•›•GKJt ³Ü·ÔÀ¥`iDú/æªSïaœ-i0å¿ N \mn*’þ ± ³ëM¿´klm
¢b³°”&CÇ €©5n:¡ã(“l0Î=\-«Á¾™¼‘¡kJìŸÚGˆSûØ¿Kó
Œ¦
‘Šj".{y<íFµµ€èº®Ö]Ÿó!ˆrcK‡¼Ø%ø L‰Ï`
¦Çü’©¦dÞ†ˆ9ŸU´Q5?:íUÒt…Ü”Æݪ.O[¹‰ü¢ùr=9ƒjqgtþ¡‹áÄ>5²(lŠÙþ¾³}z4 ÿuʤ/í$ˆ ; ø÷Fÿ;zÝ/üFƒ,|óÐwNf{ǃ°gµvm5Ü¿ _Û@V‹‹‘,΀©?àÒu ÓÐO“º3Á°äTÓ AÂ0ƒ(¡<2šïèy¢gaô.¸? "b{*µƒÍqÛ¥õUCñA7\¯ çY‹
‡$¯V
øWVýq¦#>¸I‘8±)!’‚È #Ž}:~ÎI„´Qk‘&›hCjXä#šž÷Ö×–´¦FÀ ‘ÇýmÄjmŽ'
J×Qa4E×¹º;ðŽ X…€+b±ü—‹þ†ø¢L“ß&ÉùnÎ:ªÂGdžÉXŸ1Yà‘\[.Äáb¶ðS‰.®ôˆ`Ì„¼å„!>Çßæ›…‡.Ê<-üy¯gámÜ÷C‚I“ï#~e¼Xœ{ÉRMÝC{…$+—x†Ý % †>ŸX@Zy|¾åYç|"U³=ÛJvÈå3i‘öÁ!ÊyXØ+®« â·G\sšÂKƒàmz3FŽÔ¼´öMÍQ5¼..÷t¾¬MÔjµ…ºŽ+±û¨@ª²0>=pÍi¤MvM<Ú
@=¾¥VÔñ—ûUèíp#×,Ÿ§F2a™yî^[Tm\QÖF¤ªóD{,Ó‡£6lK†”ÈÇÉ“~Ü\vœ,eÖTcºÔ(x 4*.¿æ0y&XÄ>C"Smʧ»Mi8ÎXE t ›
i1ƒ ôäoøJïÃæ8e³à#VmY
ÕfF¡'x‚på’†¨úViŸ|C}Ê®æ¢üù'/*îÙ«nŠ6ùAÆ¿–Þhãnh ÿÅ {¯B.ló¡-CIñõißãÄ&¿€ÿV•Ò‚Ñ
'ãŸE¤C¶"K-l‰BkÞ6 £ß±dÍÝÓ΃ª¼lX ¾k@¥c=†FèŸ[’-³ªŸZ˜5Æ{—ø2…Hû¿1~¦m«— –óÂ!ÔF-¶}.³&Ï
% ì%r
š– ALá¼h౦‰ P©z„[5r6Ëçq¯£xS-!–º}Í«iÒÞtÃrÉQN^Wƒõ²äߧKÔ•*†T4† úåö”ƒÝ޶Зhµ³ãÐè•dÌi¤Æ¸LBD^-ÄëZd‘d ì”ó¯x$ lù@vÀH—#ötü¬Ñ›µ`cXùIØÑæÑ<šîª´šw5
ïkÄm¢`1f¦)ËòsE ÊŽWY×òxxãÒ3¼{:gñÁÇûæö”»áß -ÅìêâúKEܸëß`<ô×]|å…@ þ@Ádc™õ•˜=Ç+¨ ùEå„p'öD+–ŽÞ{{ÚÁAn•¿Ù»ìýZÕÓi ]IÐòÿ3(Ï4,wú†ÖEN¤³ È•Þ%ZÍ|Î2¤cÛnÂé’½|\f’ÏèøÏf«<}Zë$ü
b(
È!Í9Ú%íê×TˆtÜàÛ0ç?VÍÇý»R„‡¶hmI+:±_óà€ 2Þ ¦Á³ŽQ8I<æ5sò6œÑqªvrkžÍè,Ó%B/#î›U'©º¢g ‚Sñäé“nWËD›ÅV¦µ C}X· ‡ƒ×ô€dLïq7%–ÝØx–JKXÀavü†“bBeÃÉž’aÈwál sd€fïÃJÛ |<|ý¦¶±Û×DŠ‘A 2 æÓPµA±¸7Inñ€ÂLqÈ`“qšVáþ"¦lŒÒô®+çÍäÙꃮ€re–àØá…á{pc”2ÿšýz—ÿÁ'é“ømÓÎDŽe £KÄÓy;Ix¾ úC ^"+õ|[—Š1ô˜¦9Ú#PC9VmköÅDAÒ
51@°Ú [0Q(e£¿ª¨š
™hý á¢D ä YÞ©Qaˆë%ï&(ësÕ °F»°œÒT=N*yÅæ’l¡¨(ZóoH÷Me]S=î©»ßo9luIêZ”nbSZOqopÙ8¥0aQ| qŒ!ò” ] Æ×ï¸ö.½T¬:ñ4®ß
~´\ž —”5Ø,œ¨I¤$äņ®|òW”Nã`„¬á%£5\˜¸ã«wÎ)5¨[¦Qü¤2 èzy°<ÚG¼ð\•\–¤$‘±LþIjh†Ÿ?Ýì¡¿+V&=Küì|é¦ÿòPd©}»ùd“ò5H xä*ÌO¼×kmVl_Kq•"CéëQž(r¨'ý‡Å}cnHã Ú^#MùûáÏ’2í<Ùªð
Æë«Ãò‰ÄB¥Ê N‘?´¥3v^ˆýyÃÀÓ#óƒÿåŠÅ ýOâw UÛje|$’Œ^P dLˆ9+ðõWëFZN©NûN™™YY¯Y)Ç·é´°Íj¬dEnŠF |·‘.±åfÕ ~÷‹þCÊH¨¢ ¾å ÉjhßÒõ]^åÃmM%
þ“EÁ—è§M‡~Ýò‡ˆ JÖùNò]¬¯¾éß¼pŠp«N›ð±§ãY-à¸è`´ R"j&לb×èï9™`ŽDB4ÖÁh$ûY:^*ÊÄ’ÄÉGŽ•ðv’õ¾¥ö¬d¯æÒÓf^9—&õ‹ÍaKwúE×
ÿ“/îd+o~³Â‰éE{¡•N‘²ª\Ñk:!æBß{ƒ~0÷ê e(ãø.(F¸ÃTæX¢Ïò÷1èønŸjpCã«ccÿ> ‹Qq¨òÆÕ¯éé$Um0~¬ªËC"0–×™ÿˆûS!\פ“ø8`´«-@4x«Ý ÿj¬‰ÓWvÚ(3° &ž‚]ð^á»›@Sð¦pµ_³Ëºò0Ú¥Méßõz¼7ÂJ,FãCËÚB¿9ºõYžc4»‹€Ÿ~®ŠÏ{5† Ë)YÊ æ= u®¢B£â&•*n5ؽbö&QÏÎ0ÿ
fýx%rËgä ¦m:…kkúîY&ßÊl/ãKJ¡rzû½Èø}4é²Võ§®êðì³ \#Ö'7ÓJJÕ‡b3ihCB•ÄšP<1tOg™
4HDßµô‹`=*Uz²»q”ZÂÚ¹ÛùbªW¢ó¬#æ2”Èj ©†´xÇht…ÁS¿%´Gû¯•p4êæ©öݨɲƧZç}0µ¨Íæ¼ÒfÇž5#ûTÏ+äÁ9·KŠÉ9¶}¸§G†¨ö°
sÉ» [eyõÉ™øÚM‚WÁ*ßO&{ÕhþáC®üÜ” ‡Òž‚ˆ£—=fÀX¥æ¤4“²§vˆ›”µjƒÍ¶Ã¡rÔ BÓ8[ˆµÁº)Dw7Œ" ¶Z ±ô‰–ù!&¦¶‘:zúvT7Þ-“$¦àNy=VnÇ%Ã2„XјàòMþl }ÑÊq“9
¸§ žÝˆô·£b¸fb¤õç„ãôØ”B(?L(i‘ÞvºÚø“è"1 ôŒ‚æ@f£RTSØúwˆsc½Ç¹žŸ¹Tî 1„ˆ?>yó«—l§ ôï‡ ë'cµ5}††*Z È:æ°.§ò“÷J®¹-÷¨-ÝG9ë›p•ejÂÈ7£N9§„kQ>óD¡…¯{ f‘MÿÒ»¯B›=øý¤«Ë@â!ž~39ÙBÌ\2Š8kuœÞÇu™l7¥òË 0°ˆ9ïGPº¢Æš|UŠiÎåñ,9ÞûÖЉhQ'VÒ0Ø9ÝËóTü!»3 k,ùÑh;NfóN÷í6ÝÒx+Rù(D«ŸÍȸ Íãúzaƒ#Ê™ü>¤*7ˆ¹_¾0J÷4{d§- Ã(n~´&zÿ»`ŒAåV0ó…4zÏâìW£˜îOƸ Žã0-54Õ¬ãÓ£,F…ØS6 ‚ÆÊjçÖ„û-ùj\¡ CÏEä»Tµ4q§åœ#+#,ÿ*íšA®iŸ ˆ¦áÂå’V^¡h^õÀ‡ö¾îº!5aR[Ú6ª{dTm#Ÿ ŒŸ¤Sja”p¿š\À"3 éƒEÃq‹d-%NÀLsÇwĹó]n "ßKq¯aƒO€dªi ó'€“‹îñ'ç§1¨½·>0ièhZ¿!ÈÁòþ§á6j¶á×An ¡+R0û
€Nƒ¡!³wØ7;}50 uç W¨ÑŠcšf+A,ãH¯rVKE[ 8EÈ„Q‡ùRð 2 1
>éŽèñ‹Hchѵ0¿R;¢ —efñbÇ Ç ò˜Åû¿Í‰+à«ò¬n|Ú>™ýy¡–ïv¹”i7=¹;*™†âÛ›Jäæ[+Z o
pwí2¼àæðò'š:L«ZH8Nv#ùÞ¾ ýã™=?Ãö! »Yv|;‹Vžšœì‘r·e¶½`Ö«ôµ‚äì‰ÕÛK sufú~ Îd}-×ô š µPÎ÷ÄÙK·b ¿: ši’YÖ"C’…{ó‹‹üjÊ€N˜ÌŠ|—^ S¤z à<Ħ|ev=T .Ë¿½S /ÁðT®e(âb”ò¥SUÄ×ÑÜYÏUŸ/}Žú8 }ÞÅœ?ûµ(z´JYÖÀPX!Æ5ü–q'5Ûü'E¡²r˜…+ F…¿Ìø4ø莎›éá½hú,ËUða™R¿å°Æ=½KnsTžÒæç`áùn‰š™.÷ +ê7Š
}æDÛ?4|Ú~€Qïøw1ºNjHìÚ2 K÷ÌêªMÄV2PíOu¸Ð³Ê/‹&'fÒîÅúKY¥{úæ¹NM´9‡Ä•™u)Deué÷ÿõ
^ GÙŒY&Ÿ|˲¾ÜU|rFçbEä½ ;p唸½ÝÙ[t8c uÿN ã1ò¿È½‡ª?l|àwPW;Ý¡HŸt(¹‘_X°¯¾¤Ï»j<Îi8Ù£)äŠ~ÐÂQ™ò¾ÃêDÕwT""xQËÃs’ Û©:?¨åÙf2¾6H•ÿÏ á –zºÎXnƤˆHòÒ(«Ù®ä±+`®¨ãt8 Ë£îj‰øíoYʦ Ü«ê_çáø ·b×Êz íôƒøNŒƒ”æÓ+ÝyíµŸõJ›ŠëÀêi¤ Ì<%ÚFžO‚3?
W*`O@Ü|¢é
¥º7F Ÿ¶?)£qã¯ùRG¬³˜ ‰…PrFmÏz‘ 9–þÄ™õáؽLyÉÓ ÓÒœœ5Ž,,g‹>¨©#—#³Ù•ãÍü5Ï©& qlQ³½S´ˆ>ƒ"ìRG"eÖÀ¹A½K÷ë2ã@vÁ·¯ø°l¥6M rµë·ÞéÏ¡©pôÖ‚@U•)‰zkZjÐKÚÀe¥c@1»LyŒ©1ž×¡äÖOáÔ»íØØ€4}Jz
¥ÿ±Æ¡ÂÐì üF<2ç€)…ôžªDþßÑi =„·9>/~}öÌÂ7GïzË4Z]²}Ö?ôвû¿kV‚ÑÁÜË• $@³°ÞÌâͬ°*è©žÌx8CJÉîÁ{ª÷º8ì@6ûÞ§1ý
šð@W"'î,U\]V-=LÒ‘¿ÞÜÀ…
Ö
)Åáçh£',]ãÈŠÕ‚± œŠØÖ\Ÿ
p£G¹Ý·¢V‚04Qö–h ¥¿euXˆ&nŽ Ás×ÓºÝd©mórUG ¥é†ÿ¨)Þ%4XàÑ݈D™Ò>¦Æ™ë©ê,t×XÞ
¢FdßL‘ˆ¡uü7LEÄm¦Õ¾·úc¼{ªÔé-!P
ïv~.צj¼Ôðù·K‘‹LìøèjñÕNÆ~.÷wÆ·pÉsi6ðÝJ9ï½>1_ nËçcj·>2æÆá0T~ÅW ã¥àI‹ì]}ž…[:·-'·C#ˆ^åaˆ¸RÎÆsOùš«ñÕN´›Tp¢Ñdé¢gi}ÅÓ“OÀeM<åÈZB¾ÚøoÒJâ7þ’ 6lܹ(ó~ ˆm¾xÉ9ÌFÔ Z6Â[uºZu‹x"å4ò|Ý4ÝFÖýTœ³zTwªßÖ—ºšZ=„©É8ñܹǖXåËó'âØ_RÁtYj€V2ÖÝ¥¬ŸZ•Ž×µ"¥ên ;‡p°¤ûVÜ1ûˆ,(öôªýR4wà u´ªJ,W¦–Pÿbé-¯ 0² ?Ø–U+·2Ï?ò Ü"ê~ù\ÚéŠè71M4Û+”!—m†É”bñÚß5…Ñ’‡Ž£T[ ¬JÝÖÖJá ³ô4ï” N®£{ xÉ¿Çm¯l¨p3¤h(§š¼ ž ¸@·Ò¢n_üÓoÖÓsÐé3éRAá‚ÞzV›…«3Æpø vUeç.¯o‘Ð{ÅR „h¶—]TTÈ£ëw@¦æp>s:8ñQs<ŠÛÍ‚—Ü©! ¨Ä÷ §`wàÆp/Ú>·S±‚ø•.OÌ¿ˆ°Ið0 x2Vûd ¿ÍÈìW…`txØòºÐÊUð³ßlÛŸà‘͆×5¨ÍÂBG ’”ú܈=¿Ì@(‡ ÒJÐ ²¢NH/1sÙp3ˆ×k© f#Á™
&ôh=
·H
…Š2)ÜJ,µª„¢X ›?éžzí j^žz*ÌÜgíä +Z|¶I'Ùëf°ŠL(H_“ŽÂ_m;€Îmr‹Œ+ڑܶb´ÿ* ²ÐÃHÂ!ÀËFe\XªH;æSh ®›ÛôÅ©…è“éúC\eçöl~½¶ô‘¸ðLzÙ±AŽ¡¦<ää :˜¸”mˆ·1
Õünz[ç˜ÊÝA~Ñû4éÖL:P
Óéß•™Æsú™3„bEÒ#7Øj§w‹9£¯„¬{¡ 몾͚À]µJÍQªØð¬[(ÖK·öóÞ¶hÓ׺”¨MÌ*v²Uõkbl‘—š(ÖÖkTìpÜØWÍ_°zœ6Dóµ£%@]8Ù!¤Ä±+â;MâaQÃ_,ûóÆ1s¹ƒÿIH¯Æ®Q¸W1pãÔä¶_¢QBû´`» ówηWËSš@õ ‰íÒl·ëÔa“6Cæ/Õ¬z[#6íߊ 5Ìc=#Ä_éÔUðñ¾°»iÁMs¯~rOCUS6rb”€£…[ûçÍ naÏ¿Ñ<í•Ÿ´ žˆó?Û"|$¯‘¼H¾É/E£Œj'¡ ¬Ú Y:)ˆæIF÷*Íqú\NêÆÝÒxã¦Ó\§ùÄ +PB½–òÜàu¿î¦1Ûr P›PŒ¿Õ_DT}Y8˜À{Ø, 4ÚÓüm¯×ºËºj±±ÃákÖÅ=ÒÉgïWñ-öÇJ¦!ó¦
–m û /M7ÙnWõðÖñ¹2„‘í«ZÇ,×@ä°ŠÐÛñ•Ã\cLì^½Á`†H Ù ®êzîÅ… /K´EFˆ 0wØ·r÷ö
Ó# ê{b*H~{¥ë®~ÅŠÙï’ˆ%+™ÀvAÅ
5
ž~ ÍòHV9ƒµAeçüSIåÍZ»¨¼:ïP6õÃè]gL‹ xéo¥ÆÕ<(Ò Ý~_ñ-(×?ÅLP M÷™@ŽÜlmTßz€Ç3!ýÝ=ùfb¢Ù1µ1þálQ_¶Ý^Ñ_¨BöÕ‚P§Ð×.(=M ÙÛ²\[:ùä-LPslø)1¤ø2:q—š‹' ™Ü9â˜2Š\vU„Ü°Kl0L°¢ûO‘kŒVÿ:9ÓJÅ-ÄÏ!+[v3Yi#O9ŒO¾Xß"®ºuj*mVκõ¬Î#!…ÈÖxؽ˙嗜=ÄØÌZ˜fµýAñ"ÕêSæ µ‹å‚d!õYoÖç˜ÖB\^Ê—ÉèÒ?Nða}ÿúøÇÐÿ†Ynû¼þ÷g_y ^°ÿÕ âîÃõ,ÿæŸ0T²5à'´HÜƣđóvð”y&pô?ƒÃŠÙ`¥›‡˜ºA÷QŠþØôÎ2á—g³O§ŒKýG‰ û×ß}1Ü“’£ÅzOn³w“=ž7Ö`åNÿ²5~eŽ¥ò#s…øš:Ù. HûÞ'µŸÛŸXüi¹Ã;§—¯hþð|WÉh—@èÀë믲Š0!·•åëBnK…â ×õÉ[Wåép½ Ú¿±:ö3óIÅQüÛOÁºQ; üu
–rÐá^ í*o‰„Ûþ yLÚ=@Ôˆ¬Ôz"*Kçt}5 Þu@ó
„¸¸ñVÖúÏáN¿ ɦ'Æö@¼hºŽ;”âë‹!&×ïåíQCm9¼s©»"za‚è«Ks…¬ Z: ¦Œ¬üë’ôÙ˜ÕSØ4bîÄ‹î÷† D â„ŒAÎ
·§šØèilsXYŸ½˜z÷…U¨ª¨Ñ›·‚4M©ÇgPS) a ö›žã ã†ÚþÇTx[¹A[Ó¶ÕßÅAíšö]}ƒ|Ëƒì² oðR“ÌMÞ
z—.T{6k³pj
úG b12¹VÚ„î½–=95D¶¶'-ã‰Î—g¸òz ¹•õp0®?d-G¦š;œª‡Þë±J©Cþ5ñ¯¬0Ç+é
3]yn=/4mï‡ý#mkÅŠE6Gé>š‚ÿÊÐ>!pÙ'¾/<5iÝm… 7vҥΟå÷ *½î«žEy„~øañ\2ÂŒjLDd²D †íÄÂâ’NïÖwx\=ã¦o¾–tøås!Htí=7nÕª7{m&EÊôé¢jMcárµ•(ˆì;š2Z>ªçF•›3G‚ùÒ¡‹jÌ颈߿`Dv£d=uñ’
8É=’~S leH<½ý
·ÿ˜ÿÑÍ_¹Æeé| ˆ[r[& ëcƒq˜ÆÉÝšw+:myò–,E´™4Fâ°¤ÎjŽœZȺSF®Z ¹„÷Ø{åo {i9›‘7=ëtÝ
¤50šØèÙ7OêÄH‰- ‰ýê˜ßC×ÝRú~Åb‚7æ;s=bž°Ô†º¬wë©É9 Cm‰‹~ï—«g æ³½«&XQý… ë%<ØÚ˜é§ôG”·Õt„¾-ÿñÜ‚QÈ×гY¥šï™+µ?:œ4î Ó)VÃ5pÞ¿{qh¿ALEX§ºßEì9©1Àø)-;¤ë¦…nó¦çfÊ΂Åݸ]Nn\[KûýĤƽcfZZÎÄÕ¸° yáŠe·Eß«ÝŠzæQ{ „ŸBaœà>½ùâ©À. ° (²åßÂ&;ù·Ä¨oÿF xIþ ƒ0/ zûü£Õ!rL6Ág^^å|LZ•_Ý“Æ }¦N¼ü"Ywš^\Žns4°_v³^²=i Ø”fy`銓To”ÈtøkæÍݥɟ·£)4*.î8¦ºQñlƒ5aµÓM) E7"÷pqä ÔOEF¦w,_ˆò'
Ÿ’Ÿ bÝm¡7ïÚêô8ù’€Üc‘:²fÐ}óÒ»¢?¯jø[
S{ˆë®Ü¦8 ¦9s© ‚Qô ¡¶p ÛëC(h¶iàÉeÄ!ŸïNA…Ð @öCè—|ÇxÌ%ÓùmM¼‰qRמþ„•ïVõ £ v* ÓôAVN¦õòi÷@̯U€ÝÞ[1¼ì ç쪨üÉú¡Dh˜mÜÎr¡öð’v¡|“!ÐN4äÿ"–Ør7ÊÑx®æðm¥ m¦†éÏgR|Ì Ùñ¶Û?¶ði¥ßK "|ºFã¼ NÖŽ–r½œÛH¢î0‰ª-¯µpNèÖ½Ú TŸÙ_íØÂwŒ„QŒVZ¬¹¤(HCXƒÈ àšb.樮7- ¶Œ5MÑGz~x ü]YëÐŽ#;«G†
þ¸ÖÜ»µÚ§<ÕP6 $Ѓ²GX7v±&qd:ÁýGãŒùl'jâï7@MlÔü S3ŸÄb¥þ÷¥>n¿±Ñ
Í“tBh‘pwdX6«\œÆsn-€±ÊÝ)²‡‚¶·VOüOž„§Ü h¤£ûŸŠ\D ݬsG)» “Ä¥ò1Â^>9þHq/àŽââ
F~S¦®H 'U,È’|ôVüÖ‡Å]‹¡ 4yf g bßÆa„ÜÚÍÆŠ€4¼RóGaˆ$Éù˲åÿ9K#¢bTÊýì Ã$ù•vú‡»ï}K×|Nç1-G Ö•ÐTFâ"mãÖ§/Ù¶öÐH¸žŸ‘¼-jGŠt½ï‰È »Fý1£±)=ƒ¬N0Ú•è5WpI§8Àt®5ij{ßIµ2çÑ‹1IÏ'/Æ$=R;„íW I¤k;Y fîFŠYa“:ÕË’t/ñÂ×óèŽ ê\"½Ú·…™¿Ä‚½w·£n=¶h/^Ðqš)y©Úv.XkîÓ1¸y…ºHémB>ÄöÂVCg’M-»§ÔXö.Åyñ*{Ëfå™ÄU1 .ÆÛÞA23|ÔirZ„–yÕêÁ¾"Eÿ:ÜôñL
Ý.Åž‡ªµo Ý“÷õE‚'±J
=œ#þ.*¼²ð³ófùX Ž)‚ƒÒ–Yéò}Àù6ÒÜ'g–¯Úöû£2ì7B†1ƒ]óûœ½ú·Ö%6Ê€ ÉÚS¡ WÌk‡tov¦½êU'ÆÏf¼)¹-ýúæ×á&“À)»‹ÐÁ
ýqÝaòð˜qð…pâl"_ãŸlj¦’ êaƒ—åÕ3¦®Ü$p:+êc-Àte L>³õ5µÝ\Ï!š¯ŒŠ©¨ñ×u%YF 6ôµšIVîƒ^”Sn“A ÝŠ@À®©¯Y ±¢®'J‰¦¶²é¸©Zº¦J(<Ôbáº"Ù/m…®-:µÄî
Ý·ÚÆkS 1ËÎ
Ìjü2)Þ º÷ŸÍ•Úg µH¿ÿû7È+S.mõ}3é…€¾î}•Èå×´ Õô{ø»ý±ªöâÈ;«"M(”0Ÿ ß"—¨$äš{¼Ÿp¬uüt)(í\¾”žÿÆ“/è#;µPv¦k ¡Æê{Á̧†onƒ1”Ô®=„j—&‘zÝÄ”ÃØ’£Ç@nr P£ÝsÎe8ö±Mo~ž©DŒT»•t[nšokOð|C›»`+–¬nTÙ˜¸äAótã´#ük t´ìð+y¿v±ÆM{ð¥ñdÔMåîµ[Z!´s°†jà ÄüúÞž~åËsU-ÉžäPÞ¦4}o¾i
gŽRK4§SȽ:ê ää=ƒ ØÒO”Ýý×ݼ}¯ }jš!ꇩHL_î•Ó»I~ë8ð.&ø+û=ÜØï~¢Vφő½?yúErüÁY' ¾ZÒ§3Õèv@ öPyÝô+àØ+.ä¤ç~0T‡ %ᙬ}tŒüeaµêb,[îÇ5¯Ø¿q^€ÌñPpÞ–6%Ý®¤><’¥ø¦]D¼¬*ÏW9'?xs¡dáh¤ü%¿A+“‚”^!Û…ÌA“Ù"¿@ª«g%*Pn¢â8KØ\&íËé=ŽmuˆÇ[.Ø¿ŠUâî5¡]kFGìij¥¡
Àíø‰æž@~NÜ&€^… ÚÐÎ"
GÊëèBátäsŠ… ’Í®îÇú= SEðív^ Úœ ?;J[¢uzÕ%ôF ƒOæ*u‚Ì=ò‹(Ç Ê.)XïL“¼,”«{ 4‰MðÀâ× Ë|¬¶¨"ÿpd`ƒ-d¶µÇ¯Å‰ûs8¸ºNhZÍp̲ôÅ\
r âk.ꩽãÿ·¼1º „æ~ê“(,ŽÊªUøÆR$Æ4BzâpS&’Ñ«ZÜjσ®æ¨g’ÿD´^ë–Ù"¯ïˆ ¢úJËcˆ/ˆ&¾wÃ_Äe×%"2 $Éfåzµ Äßd¿ ›™·é + aLÿåys ÄâÎ=pPÓE.æ½i˜VäDY_‡ýÔ Ẋ‹÷æÕ‹x \ˆè*&–=×H§ÑQ
P’I—3vñá¯KÇÔ…È[Ï=«m¿« «U‹Q *Acѵ“ÔótM<ü‘2Sa9gÍ»˜?íC3¦Mu`ï/¨8ýœ ùWº‰¶È¿µÝØl6”ZTkÿ$¿\:
óÌ5—ò¤°Kî,À¾ŒHTQxÆö|úErüÁY' ¾ZÒ§3Ô0AŸ22 ¢þ×UZen˨=Rİ̸ûWÅ ÐG)lßÜJåç3+ä¦8Øjt“Ÿ¤Ö;ƒsiÊÊ Ø‹ÑÅEÄùÅHݘ8ņ„ÿò¹¨s ÏoÝþ}φÙáÞ0s\r5©P(-DGís§ÖœŽ—ËÙŠ¨¡cÏì,ê‹-Þ%u/E’݇NÃhãWåp™ó>Nð«žW9#'ÚïŸß€ÉàõJ¼[Ë£` ž©áÁ ÌÞko;Y”„ ñ€¾¼L ÌdÓu5…·lý=¾ø¡”¡§`M&¢R|Ë^ο´á"ÓÍ´Âðw^'›Ã°Ò…³±¶dQÙOÜü=Š«J+ŒævÙ© ~–Ø‘“ÕRK';¸™a¼ Û2i^4ër8i.¸–!àV %S,OB³è¾bûênŽ5*=+¾Ìa| ÐPM|ùœŒÔÅÉ ^»oî6f¢”_B5g
9UË+@ø3bW#äçÙ½²È|lù†ñÕWbý?õ¥±7+»Žüž äš‚3PŠDf„Nt‚ÝlÙ4ÃÊ0/8&
5bH¯ºÀ4Å–Ð
5Z—Ž°jM«aÍ µ”£ÖÓöïƒ`öÜç]ØʸÕÜÍ?1P%òáq‘ÛŸVEÁtÞzCÔàþã²jº†q·'¾B eJ)쬞¯^¦†!GÇA26Rh üŽ|Ì7˜§AÞævƒŸô©ÄÔGK¶&z?"\`Ž>go¦ü y¶8ß“7‘Ý•sfyLNqƒÓéÒY»Cí|®ñŠ4d ýÑ ÀÚ 3$VBG}ÅO¾ <îÕ³
ŠØT^eµ»Êðq¤øÆBþ^™c@ÜP"XðRq,„þ‹Æê>ãOÅEzxo00šR;À 9 :yö5úÛ€Ë&üéëÀ¤ë÷-Üõî Ó¿vÂH*(6”WŒ@Œàb‘þ”;yà` I"PR쬈ÖÂz
$ÑE-²ùoÔ
Œï¬$øŠÞÐÑ\q)êÐ/ rÞÎR£MÓ¥ÇlÈ2y 3[RBH4º môUí2ñðP|‚¡û¼4°†€ÿm’[¨$ ü¥OÇY¬uÿ5²*µVgÈÑIK‡ üwáÏÍov©>_‰2~¶©ïïÒE-d…8Dé2]S)êò—ák=H3xa±(wÉõt©D=0}#NàMc`9“]9%|pÔ›Ën8” æÂê!÷H-¥&,Ì…YY
!2¿¬
Ä#b@®ÿP¯n?¢L—HM™ö¤B(1Š± >ï87!]J¿*¥!ï-^€Û,œåÔÀ¡?'TçÝ;¸Çý^¼d@D“̱˛³Ó:Œ×LPeíà§Ç̃µ½Hè)ÈoÞåŸZ
,ïô6ô4¦ŠÆ
âŽÜz[áüH^x#V©H ¶BBCÜw^é#ôÛÓüïwÔR’¨ŸM Ñõ’‘?ýsÁGŠúG´;P‰p…¨$¢«•[ìÊ^ÆÞ
»ØÖ°òÇòÿÿà,3tK<èvotôå>
¼T,l‹N;Ø’p¶ÚéáEò9Ñõ
}à‚t‹¼íÒë×ínž”j£Oq…••ŠGëf_Æ*™B ªƒ®Li!&í~â o˜_æ
y©ÃÈP£Q÷ñÓ£¢ŸjcWä34îíZ‚õ¼Yꇽ-MsR£—=)Â$ &úƒ@Ÿ¯™ÛKõh*ÉÀ†ƒºbsÍ3’vaŒÄæ_A¶àay‹óev"±´w{FÞ+¥c´›SÙZŒeÀæeÁ)ô¿4 0–]ÕJöF1QÍ³è ƒ;í y ^–ƒ J
¶ÇÞ´l'ÇlǪoÚ¬jÉÛ#}mý2õL—^5~§ìe`,×kî+¡ jk&ÏÃnpw®ðòÛÕ»ÌÏgЧói…¯ãP˜-¬ùIAöÉRÜß“Y qõB˜@,²ÙiªwÂiÍÈðöGwÏÑìBÇœ Ó Ûo©„§¸$ž+Õ ´¸uEx¼R¸©§ìÙdÐ’œáÍ3€6¶!àƒ ®6iG³ŽF*
oôV?¿% é/»$z8BèBà€ƒÏ…éäÂú«>‰ÚLneñÈÇ ¿Aä¸m—Ôfn|³—ö…‡2qU"G ƒ£
öÊÉ=äÐl;¥Ãb¢…¹²W'©Ø*bTuï¹-ƒ7ëeLzÈ2Ew¬?èÕ~äûªÌáϲ#g±Aô”™ö9*‘áªhÏÛ:ß7›©ï‘kÑQ.’Œ‡ª ÷H":<»%.fˀ͢ޱŸ 1 óÝH×ÕYY+;S¶Pu¦8æY
³!ƒIóBkíYµHéѲ ïyà‘
ê®Ë–»ø ›êÀV
k~(…«zžÉoåj²hÂ\rcŸ-<`cµcFÁa
çÍ ÚõÿLûoŽRšá ä¿õòjׇF^f¯)aÑûTÒ ˜ÎV9Bmû.XÐzöý'˜+*u~Ù‚Q;¹Ôé\{Ú>ý—!¿Ñô3€Z°!1T>öÖ\â°.¹‡r>E„¯ ç
€{Rô Žª¢9é#=Ï‚æqÕæ8ÆL:Ò4¡°Nà>êŒÏiØÄÕRÞyvδ©ã]Ìcµ£‹ÿ7}ÙŒ* 3‚]„t´u‹×‹ë'bÁ¸›õ¿jÇ~{ÐyÁ xC"Œp=üFÌ}\ƒé<ˆ§±òÏIL£¶òû‚Ž´¬S¯M‡…eÀC
oÕ¨Dºh 0Þ… bfèáýzZ:ë,“s5öS/µ•¡i†+YÀãw\&%Å’èíªw"‰sÀLi-ûŠkc —³ÁÓœ]‘¬"I€V¢–‘Ö‰ÆQÊ?Xw‡Ä-B8ëƒëÉÙr(ó Òf¬®Aë8µÒô?cF\elôßãåˆvš÷ …Ü[²*â e4Uj6ËcÄ#í¦~¹
“Òþr‹è4H"ÏI7
€
w]5-ÔÉ+¤P~I÷®)Û;°"lc^‹6 Ủ]Í\®Œ¼Uµ@ðy —=&¾ç6uÓfLºwðÀò)ôfˆÖ»ú~‡,œ¥ˆ 5ÚµO ã æ—þ
"8–#;•šNoyáRÚ AØ ¨ë•º ¶lîtȯ4íW=Ö8 ¿“ ú5 ½kN¢Èœc gNƹE™nðQ<|ŒyâKZ2˜Ïô ÷Áùòš"i¤òòÅ©Ò+Юb0SÖ3ÛÂ…–Rÿ-Nñµ|qÛxšW(+›%Û¸T¥vÏÌ ¶sQ2d$”`‘8&×Aé~#s·Jo$¯ÔHÖ–¡¬®Z $X$XL&H²Ì¦….“©àîr6à U&‡I‚f5¦3,$¨Çæe áDWɯî¥Ke’ †|#f0S›ù¼Îô,>/Gî!æÆåÆÙ£‚½w.†ž{ÔX%Š?¿"k¯#ëfÌ©<¨ÀvÀû_S÷2Péy {Mþ¥12lK˜œÜJ*ÀÕ»™nä uäžI%ëùî>´ÿ6öÝÅýéÆ<…›$— ÿÞµ©/í#©GÕIÕì=Ëu‹û"÷½|^ ß%%×`e¢•2 .0Û{
b}× D½A’1(nZâMÝAFÓ½Y
Mê:m¥Þ24[øeóò¼vn¢´2åÐ(šN׿ܡ2$§ÈJ~f©¯|Õ!‘\örP«¦ EÞ)¤@¼ówÌ3_ͲðB#+FÕaQÐé)³zŒŸ»¸ À$Ž•ƒÍ_™ãÆkFçðêôGdšÎ3‘§‹Ì!ªá¸`„ 6ø¤díJzä9톉"ê¥ÏAãñ‡p+¥M©cÛµ‹]’… 6¦RPx¬ðÃU 7&¼ÍWüö¸²,€ÊæIüŒŒ;j.´“'¤ nä4¶»O ´éˆm ÷œ ÕÄÉt:ù·Ø©¤ ͧŒÁ(ÃÐf! ›š!l©#ûv}NAkk!f¢žÂy c1ùh »¢ªõêO¹Ò/kÙ9·þ籌q·ÍÜßM+–P\§}; äƒKG+ÿÅõ ?`\Œ
¿ÞA¬ •·wo
®ßÛ¬'¥öök“§ô¢¾û²Û ‰å—ån°( Eë16ì|xLãÅÜ$@:ü±ÂΚIÓó×_S“𰈤†
p '–©2+jX ãÿÌ÷’Êù½¥O_EeEX«Eþt½7©ð2 /HH™â¾wš½Bb¤×u> Ù WÕ†,|ˆøêí¼>É.1lð‚ýÙ¯\5ûgÔDy!zØäË+ÄBFë“{B0» IÊÈ>õM ¨¥ªÒ/¶GEziŠüh6¤=j,;ÊvŠ¢@kI›î^ŽaÙˆ;0«¦µ‰ÚÈ6¶¨›û £‚ãNß—ÇåЈegGÆôå+ÈFJÚ5ÚÀO‘Í_lËžp°.3‚UsÀm¼Tµ1ös4e©‚Š£\÷Ï[Íå {YJù¸xÙö øPÅð3õª«ž¹Ïo±O¯6ÿîD Ÿ4ŠP¡^†‡Þ5Û]][EâÅeÔ#Tñïm<¦Ö'|J…s’î´€ww¯@‘±s§ÂSÊ/³uõ¸b׎¶Ò$ljœæ ¨ ¦–ŠNp¼~é#®£st<2ÏsDlÞ6Õ½4jN†”yö•ÅýUñ‚IHà0 ê µ…¡cxW*>[4 ÌMõ¬#M ¹™â³1~gwãw`#»Ñ{^ &úE)Ê‘a¦Dê»wÝÒÌX’µANA+Lj è„_
Õ^0Q?‹uA‚P8H^“º•3àHÐΣBèƒ8‹É”¿C ÿsË‘l¦óH¹2}öJ4ZÁÊ
ÿjUÕpÿÁ/± ó‘ïÞ€*òØèXDXƒ ªº˜â VÝ’d¨# ;ÏEÑ-Ê‹ Õ6W‰È±Íæš&¦2 04S–y³nìMYÑåbáïÅ+~¿I hd»‚÷äÄ9&:JW’P+>¿ ßx.§åVô›ÍPj'–›sâõXÅ{Æÿ$Eï[鶋šòB—cC.9OøpÞTKfª¹éYNb«Ú0·3y•.^ÅÄÅu9E¥+¹Mè›!«p¼£½Y~ñ¼~’•³ÊV³²™ ,ò UÀõkÉ
³w &¢y ÕuƒÒô35©ËO£¬ÏGàlü)ÄèéÛ !@ÃüD±Z ‰ þ*ÎGQ2ìÔU%:É
ÿV_݉\PQÒ …]ówµ{òý10í‹Â ;‡ù-z÷Ž[Hám²Ö’NÔ »® … ?Fw£šˆ=¯†ìdD‘ÉE(Cg6ÿzD$QLI>Ðʉ;´Š|¹
¶ØŒ^ÅrÝñ2È,„(TÖ¸ŽZé3îrV©#±¾?¤¯™ß
ØOBì?™,ÕÁ—ú~}ŠëE¨ä<*\OZ¦
3ˆ mY;‡‘T°¤Õ¿X~鋃]þ:6“_ºÉ.T؃T¿þ«"fE^aëùŒ(Ê’å-þ´ki„Â:E ‡aW×=f«424ºz…p*†’»à{N–³|î±ìÚíCŸ«u'®¨8¥Ø¼ .q•º|† »–Ô?ñ„n€ü–ÐÇèf£À2,"O¼¨u¦FòW =8M™º(ô¯jµ=ŸÓ¸WתAj`¨˜†7e… ’…z ók
v9YFåÿι֜ˆžVàb= ñ%ß®çûÀ| ê„'á<Ôù—kJòvc³AÀ%^ Œ ÑK¸ÿtÊíí*°Áá6x«ýýú¦áÞÓÓ B ÉêM¢,´’²V†¤¤òH(’Ÿä]í•mfü¹(>f%ëš³ð7!9…›Ýµxy¼²Uý+Ôu£Å ú¦PæÔÍ:$5·ËÂÐâî=S`0ïÎŽãd1X|ä‰ Û&u‚'yÕ¦œ0/0EdÓ—m'ZªÈY ³PGÀ-€rÔ˜ mÓ;V3Þ#~¡<îvYºáò ˆ£Âs€oy|Él7(íD3™UjnÞü88«[ã"\ÂQ;#L´ìa°èÄ W¤ 3%"Å9ÎËÚ@Í ó à$\Ïõ@*¶£œðSºp19«n‚tÈÛ=7+è ýpMÜñz‚<é¤ë¸9FE*¢^b·'„p5ž…Û
«f¼A€b¶ vaf`›5T‰×âæUÕ¤{