Rmpfr/0000755000176200001440000000000014553206226011345 5ustar liggesusersRmpfr/NAMESPACE0000644000176200001440000001571614552770112012575 0ustar liggesusersuseDynLib(Rmpfr, .registration=TRUE) ##-- From 'gmp' (on which we 'Depend' ------------------------------------------ ## The user can and typically should just use mpfr() or mpfr() export(.mpfr2bigz, .bigz2mpfr, .bigq2mpfr, .mpfr2bigq, # new in Jan. 2024 ## e.g., for use in gmp :: Math.bigz & Math.bigq : ..bigz2mpfr, ..bigq2mpfr) ## Import all we need, but not more importMethodsFrom("methods" ## as we define methods for them: , coerce, "coerce<-", show , Arith, Compare, Logic, Math, Math2, Ops, Summary ) importFrom("methods", as, "as<-", callGeneric, callNextMethod, is, extends, new, validObject, setClass, setClassUnion, setMethod, setOldClass, setValidity, slot, "slot<-", .slotNames, getDataPart, setDataPart, getClass, getClassDef, signature, representation, prototype ## needed implicitly [or "bug" ..]: , loadMethod) importFrom("utils", str) importFrom("stats" # import *and* rename -- we extend these : ,stats__pnorm = pnorm ,stats__qnorm = qnorm ,stats__dnorm = dnorm ,stats__dpois = dpois ,stats__dbinom = dbinom ,stats__dgamma = dgamma ,stats__dnbinom = dnbinom ,stats__dt = dt ) importClassesFrom("gmp", "bigz", "bigq") importFrom("gmp" , asNumeric, as.bigz, as.bigq, .as.char.bigz, ..as.bigz , apply # , apply.default # *.default: else apply() breaks in pkg SNscan , crossprod, tcrossprod# <- as we write (S4) methods for those (*not* '%*%' !) , matrix, numerator, denominator, frexpZ, chooseZ , is.whole, formatN # because we add own S3 methods ) if(packageVersion("gmp") >= "0.5.8") importFrom("gmp", is.matrixZQ, #-> R/gmp-convert.R which.min, which.max)# the generics if(packageVersion("gmp") >= "0.6-1") importFrom("gmp", c_bigz, c_bigq)# for sapply() like usage ##------------------------------------------------------------------------------ exportClasses("mpfr1", "mpfr" , "mpfrArray" , "mpfrMatrix" , "summaryMpfr" # mainly for printing , "atomicVector" , "array_or_vector" , "Mnumber" ## new, *not* containing "matrix" (which has -> "character"!): , "numericVector" , "mNumber" ) ## Standard (base, stats) functions which we made into S4 generics export(mean, median, quantile) export(.mpfr, .mpfr. ## ".Arith.codes" ## , ".Arith.mpfr.num" ## , ".Arith.num.mpfr" ## , ".Compare.codes" ## , ".Compare.codesRev" ## , ".Compare.mpfr.num" ## , ".Compare.num.mpfr" ## , ".Math.codes" ## , ".Math.gen" ## , ".Summary.codes" ## , ".abs.mpfr" ## , ".dimCheck" , .getPrec , .getSign , .mpfr_erange, .mpfr_erange_set, .mpfr_erange_kinds, .mpfr_erange_is_int , .mpfr_maxPrec, .mpfr_minPrec ## , ".mA.subAssign" ## , ".matmult.R" ## , ".mpfr_debug" , ".mpfr_negative" ## , ".mpfr_negativeR" ## , ".mpfr_repl" , ".mpfr_sign" ## , ".mpfr_subset" , ".mpfr2str" , .mpfr2d, .mpfr2i , .mpfr_formatinfo , .mpfr2exp ## , ".mpfrA.subset" , .mpfrVersion, .mpfr_gmp_numbbits , .mpfr2list, mpfrImport, mpfrXport # <- experimental: for a possible save format ## , ".packageName" ## , ".print.mpfr" ## , ".requireCachedGenerics" , "Ai" , "Bernoulli" , "Const" , "Ei" , "Li2" , "all.equal" , "aperm" , "apply" ## <- we make it S4 generic , "atan2" , "beta", "lbeta" ## S3 "c.mpfr" , "chooseMpfr", "chooseMpfr.all", "sumBinomMpfr" , "dbinom", "dpois", "dnorm", "dgamma" , "dnbinom" , dt , "erf", "erfc" , "factorial" , "factorialMpfr" , "format" , formatMpfr, formatBin, formatDec, formatHex , frexpMpfr, ldexpMpfr , "getD" , "getPrec" , "hypot" , igamma # working iff MPFR version >= 3.2.0 >>> R/special-fun.R <<< , "integrateR" , is.mpfr , "j0" , "j1" , "jn" , log1mexp, log1pexp , matmult , "mpfr" , mpfrIs0, .mpfr.is.whole # as substitutes of , "mpfr.is.0", "mpfr.is.integer" # <-- now (Aug. 2015) deprecated , "mpfr2array", "mpfrArray" , "mpfrVersion" , "mpfr_default_prec" , "optimizeR" , outer # <- our own instead of base, so it uses tcrossprod() methods , "hjkMpfr" ## <-- FIXME, rather part of an optimR(...., method = "hjk") , "pbetaI" , "pmax", "pmin" , "pnorm" , qnormI , "pochMpfr" , "roundMpfr" , sapplyMpfr , "seqMpfr" , "t" , "toNum" , "unique" , "unirootR" , "y0", "y1", "yn" , "zeta" ) exportMethods(##___ "own generics" ___ "apply" # <- we made it into S4 generic (with "ANY" method = S3 generic from gmp!) , "asNumeric" ##___ "other generics" ___ ## Group Methods , Arith, Compare, Logic, Math, Math2, Ops, Summary , "abs", "log", "sign" , "Re", "Im", "Mod", "Arg", "Conj" , "all.equal", "aperm" , "as.vector", "as.integer", "as.numeric" , "coerce", "coerce<-" , "cbind", "rbind" , "diag", "diag<-" , "dim", "dim<-", "dimnames", "dimnames<-" , "atan2", "beta", "lbeta" , "factorial" , "is.finite", "is.infinite", "is.na", "is.nan" , "%*%", "crossprod", "tcrossprod", "t" , "format" , "mean", "pmax", "pmin" , "show", "unique" , "colSums", "colMeans" , "rowSums", "rowMeans", "norm" , summary , head, tail , "which.min", "which.max" ) ## Our own S3 generic mpfr(): S3method(mpfr, default) S3method(mpfr, bigz) S3method(mpfr, bigq) S3method(mpfr, mpfr) S3method(mpfr, NULL) S3method(mpfr, Ncharacter) ## needed because gmp "forgets" to S3method() these: ## (and so things only work, when gmp / Rmpfr is attached): ## S3method(apply, default) ## S3method(apply, bigz) ## S3method(apply, bigq) S3method(c, mpfr) S3method(as.array, mpfr) S3method(as.matrix, mpfr) ## Would break the working of vapply(, FUN) e.g. in pbetaI(): ## S3method(as.list, mpfr1) ## S3method(as.list, mpfr) S3method(determinant, mpfrMatrix) S3method(scale, mpfrMatrix) S3method(diff, mpfr) S3method(str, mpfr) S3method(is.whole, mpfr) #S3method(is.whole, mpfrArray) S3method(formatN, mpfr) S3method(print, mpfr) S3method(print, mpfr1) S3method(print, mpfrArray) S3method(print, integrateR) S3method(print, Ncharacter) S3method(print, summaryMpfr) S3method("[", Ncharacter) S3method(as.data.frame, Ncharacter) ## not easily ## S3method("cbind", Ncharacter) ## S3method("rbind", Ncharacter) S3method(matrix, mpfr) ## useful, to have base::outer() work automatically: S3method(rep, mpfr) S3method(t, mpfr) S3method(t, mpfrMatrix) S3method(aperm, mpfrArray) ## trying to get base::factor() to work: S3method(unique, mpfr) Rmpfr/demo/0000755000176200001440000000000014552770135012275 5ustar liggesusersRmpfr/demo/hjkMpfr.R0000644000176200001440000000601611764511504014017 0ustar liggesusers## some platforms hit zero exactly on the first step: ## if so the estimated precision is 2/3. cyq.f <- function (x) { rv <- cyq.res(x) ## mm <- length(rv) ## f <- 0 ## for (ii in 1:mm) f <- f+rv[ii]*rv[ii] ## f <- sum(rv*rv) f <- crossprod(rv) } cyq200.f <- function (xx) { rv <- cyq200.res(xx) ## mm <- length(rv) ## f <- 0 ## for (ii in 1:mm) f <- f+rv[ii]*rv[ii] ## f <- sum(rv*rv) ## f <- crossprod(rv) f <- sum(rv*rv) } cyq.res <- function (x) { ## Fletcher's chebyquad function m = n -- residuals n <- length(x) res <- rep(0,n) ## res <- mpfrArray(rep(0,n), 200, dim=n) # initialize for (i in 1:n) { ## loop over resids rr <- 0 for (k in 1:n) { z7 <- 1 z2 <- 2*x[k]-1 z8 <- z2 j <- 1 while (j * inst/NEWS.Rd: new; this 'ChangeLog' should not be used anymore 2015-02-28 Martin Maechler * R/array.R (matrix.mpfr): new S3 method for 'matrix(, ...)', mostly to help confused users. * R/special-fun.R (pnorm, j0, ...): do *NOT* use as(x, "mpfr") when 'x' is an "mpfrMatrix" / "mpfrArray" (-> uses dim(), etc!) 2015-02-16 Martin Maechler * R/array.R (norm): new matrix norm()'s of "all kinds" 2014-12-13 Martin Maechler * DESCRIPTION (Version): 0.6-0 * is.finite(M), is.na(M) now keep dim() for "mpfrArray" inputs. 2014-11-27 Martin Maechler * DESCRIPTION (Version): 0.5-7, released to CRAN, 2014-11-27, r205 * R/as.R (as.integer): fix bug, ensuring that "Z" rounding is used 2014-09-05 Martin Maechler * R/as.R (mpfrImport, mpfrXport): new utilities, somewhat experimental 2014-06-23 Martin Maechler * R/integrate-Romberg.R (integrateR): when 'ord' is specified and one of 'rel.tol' or 'abs.tol', convergence is checked, and if achieved, computations stop earlier. When 'ord' is NULL (default), and '*.tol' is specified, continue until convergence (or memory explosion). The default (none of these specified) is to try convergence up to 'ord = 13'. * DESCRIPTION (Version): 0.5-6, released to CRAN, 2014-09-05, r203 * R/as.R (mpfr): also allow rounding mode "A" (= "Away from zero") * R/array.R (mpfrArray): as that is supported from MPFR 3.0.0 on * R/array.R (toNum): new optional argument 'rnd.mode' * man/mpfr.Rd: doku and mini check * src/convert.c (R_rnd2MP): allow "A" as well * src/convert.c (mpfr2d, mpfr2i): extra argument rnd_mode. NOTA BENE: "D" rounding previously, but new default is "N". Consequently, asNumeric(x) etc give 'Inf' instead of 1.797693e+308. * R/gmp-convert.R (..bigz2mpfr,...): add 'rnd.mode' argument 2014-06-19 Martin Maechler * DESCRIPTION (Version): 0.5-5 released to CRAN, 2014-06-19, r190 * R/integrate-Romberg.R (print.integrateR): own print method: print _value_ even when warning. 2014-05-19 Martin Maechler * vignettes/log1mexp-note.Rnw: update to log1pexp(); cosmetics 2014-05-01 Martin Maechler * R/special-fun.R: pbetaI(a,b) for larger (a,b); new mpfr versions of * man/distr-etc.Rd: dbinom(), dpois(), dnorm() * R/mpfr.R (mpfr_default_prec, .mpfr.minPrec, .mpfr.erange, ..): * src/utils.c (R_mpfr_get_default_prec, ...): new functions to get, check, (and partly working) set default exponent ranges and precision. 2014-01-01 Martin Maechler * src/Ops.c (Math_mpfr): new sinpi(), cospi() for R >= 3.1.0 2013-10-21 Martin Maechler * DESCRIPTION (Version): 0.5-4, released to CRAN, 2013-10-22, r173 Now again depends on 'methods' (instead of just importing). 2013-05-04 Martin Maechler * R/mpfr.R (.mat2ind): from a proposal by Serguei Sokol, new utility, to be used for matrix subsetting and replacement, in .mpfr.subset() and .mpfr.repl(). __FIXME__ add checking code! 2013-02-28 Martin Maechler * R/Math.R (sumBinomMpfr): oops: docu had (-1)^k instead of (-1)^(n-k); alternating=FALSE has been wrong, since (r101, 2012-05-15) 2013-02-14 Martin Maechler * R/gmp-convert.R (..bigq2mpfr): precB = NULL --> at least 128 2013-02-05 Martin Maechler * DESCRIPTION (Version): 0.5-2 * R/as.R (asNumeric): new function; mainly for 'mpfrArray' * src/Ops.c (R_mpfr_mod): for Arith_mpfr[_i|_d]), R's %% and %/%: now working correctly, checked in * tests/arith-ex.R: * R/array.R (mkDet, determinant): provide recursive method for determinant() and hence det(). *Only* for small matrices !! * src/Summary.c (R_mpfr_sumprod): new for sum(x * y) == x %*% y -> 20-40% faster matrix multiplication {still not fast!}. 2012-12-03 Martin Maechler * DESCRIPTION (Version): 0.5-1, released to CRAN 2012-12-03 * man/Rmpfr-package.Rd: a nice overview help page * inst/doc/log1mexp-note.Rnw: cosmetic changes {would be ready to submit now}. 2012-06-16 Martin Maechler * DESCRIPTION (Version): 0.5-0, released to CRAN on 2012-07-07 * R/as.R (mpfr): or arguments now "work" (with a warning). * R/gmp-convert.R (.bigz2mpfr, .bigq2mpfr): new optional argument \code{precB}, typically for increasing the default precision. 2012-06-04 Martin Maechler * R/optimizers.R (optimizeR): new simple golden ratio, thanks to Hans Werner Borchers. 2012-05-22 Martin Maechler * DESCRIPTION (Version, Depends): 0.4-8, released to CRAN on 2012-05-23 * R/mpfr.R (diff.mpfr): new method; as diff.default() commits unclass(x) (str.mpfr): new. 2012-05-04 Martin Maechler * R/as.R (formatN.mpfr): add method * NAMESPACE: import S3 generic 'formatN' from gmp. 2012-05-01 Martin Maechler * NAMESPACE: import S3 generic 'is.whole' from gmp( >= 0.5-2) now. * man/is.whole.Rd: only mpfr method. 2012-04-30 Martin Maechler * DESCRIPTION (Version, Depends): 0.4-7; depend on new gmp; can get rid of if() tests. * R/gmp-convert.R (.bigq2mpfr): new. 2012-02-06 Martin Maechler * DESCRIPTION (Version): 0.4-6, released to CRAN on 2012-02-06; (Depends): gmp, not just "suggest", so we have a well-defined search() path order: Rmpfr comes before gmp. * R/special-fun.R (pnorm): much improved partly bad code, thanks to a report from Jerry Lewis. 2012-01-14 Martin Maechler * src/utils.c (my_mpfr_choose, my_mpfr_poch): fix case n == 0. * R/mpfr.R, R/array.R: add argument 'right = TRUE' to the print() * man/mpfr-utils.Rd: methods which looks better, e.g., for integers. * src/utils.c (R_MPFR_2_Numeric_Function) (R_MPFR_2_Num_Long_Function): do *not* warn anymore when arguments are of "non-matching" lengths. * R/Math.R (chooseMpfr.all): new arguments 'k0', 'alternating' and 'precBits'. 2011-12-27 Martin Maechler * DESCRIPTION (Version): 0.4-5 * src/convert.c (mpfr2str): dig_n_max was off 2011-11-28 Martin Maechler * DESCRIPTION (Version): 0.4-4, released to CRAN on 2011-11-30 * src/Ops.c (Compare_mpfr, etc): fix (silly!) nx * ny integer overflow; problem reported by Anton Korobeynikov. * R/unirootR.R: produce warning when convergence happen to "pole". 2011-09-08 Martin Maechler * DESCRIPTION (Version): 0.4-3, released to CRAN on 2011-09-09 * R/array.R (applyMpfr): -> apply() method for "mfprArray" (mpfr2array): fix for the case of dim() <- (colSums, etc): also add simple methods for colSums, rowMeans, etc. * man/mpfrArray.Rd: add apply() examples 2011-08-23 Martin Maechler * R/unirootR.R (unirootR): R-only version of uniroot(), carefully ensuring * man/unirootR.Rd: that as.numeric(.) is used only in some cases; thanks to John Nash's very recent R code in his 'rootoned' package. 2011-08-11 Martin Maechler * R/Arith.R: add "Logic" methods (mpfr, numeric), avoiding inf.recursion. * tests/arith-ex.R: now checks that. 2011-08-09 Martin Maechler * DESCRIPTION (Version): 0.4-2, now with a * NAMESPACE: 2011-07-30 Martin Maechler * src/Ops.c (Rmpfr_minus, Rmpfr_abs): new C versions, called in * R/Arith.R * R/Math.R 2011-07-29 Martin Maechler * R/array.R (mpfr2array): speedup, not using new(cl, ...) for check=FALSE (= new default). 2011-07-21 Martin Maechler * R/mpfr.R ([[): finished adding a '[[' method which returns one "mpfr" number (instead of a "mpfr1" one). Needed a bit of changes, notably in .getPrec() etc. 2011-05-12 Martin Maechler * DESCRIPTION (Version): 0.3-0 -- "finished" integrateR(); using vapply() 2011-04-30 Martin Maechler * R/special-fun.R (Bernoulli): B(0) = 1 now also works. 2011-03-09 Martin Maechler * R/integrate-Romberg.R (integrateR): new pure Rfunction for Romberg integration; works with "mpfr". * man/integrateR.Rd: docu & examples. 2011-01-18 Martin Maechler * R/Math.R (roundMpfr): "round" to precBits (bits!) also to *increase* precision for further computation. * src/utils.c (my_mpfr_round): C implementation. * R/Math.R (factorialMpfr, pochMpfr): new functions, e.g., as tools for choose(). * src/utils.c (my_mpfr_poch, R_mpfr_fac): underlying C code. 2011-01-17 Martin Maechler * R/as.R (formatMpfr): fix the case where 'Ex == digits' 2011-01-16 Martin Maechler * src/Ops.c (Math_mpfr): enable digamma() for mpfr 3.0.0 and later (Math_mpfr): implement cummax(), cummin(), cumprod(), cumsum() * src/Ops.c, R/special-fun.R: enable Airy function ai() 2011-01-15 Martin Maechler * R/mpfr.R (.getPrec): return default precision instead of NULL for 0-length input; this enables [FALSE] <- 1. * R/array.R (mpfr2array): new utility as alternative to 'dim(.) <- *' * R/as.R (mpfr): now also works with matrix or array input, returning "mpfrArray"/"..Matrix". 2011-01-10 Martin Maechler * DESCRIPTION (Version): 0.2-4 * R/Math.R (factorial): improve integer test (thanks to Petr Savicky). 2010-01-22 Martin Maechler * DESCRIPTION (Version): 0.2-3 * src/convert.c (R_rnd2GMP): new; allow to specify "rounding mode" from R. For now, for conversion to MPFR. Change default to use (round to) [N]earest rather than [D]ownwards. 2010-01-21 Martin Maechler * DESCRIPTION (Version): 0.2-2 * R/as.R (formatMpfr): add 'showNeg0' argument, and fix printing of zeros. * R/mpfr.R ([): ensure out-of-range indexing returns valid "mpfr". * tests/create.R: test the above. 2010-01-20 Martin Maechler * R/mpfr.R (.getPrec, getPrec): previous getPrec() renamed to .getPrec(); the new getPrec() also works for simple R "numbers", and is used in mpfr(), and the following : * R/mpfr.R ([<-): for non-"mpfr" value, use at least the previous precision, following a chat with Petr Savicky. * src/convert.c (d2mpfr1_list): ensure x is recycled when prec is longer than x. (str2mpfr1_list): ditto. 2010-01-18 Martin Maechler * DESCRIPTION (Version): 0.2-1 * R/array.R (.matmult.R): "obvious" speed up, replacing the innermost for() loop by a sum(); inspired by a patch from Petr. *However* the real speedup would use a .Call(..) directly! 2010-01-16 Martin Maechler * R/mpfr.R (.mpfr.repl, [<-): change such that x[] <- 1 works; also z[i] <- v when i is larger than length(z). * tests/create.R: test the above. 2010-01-15 Martin Maechler * R/array.R (.matmult.R): tcrossprod changes along to the bug fix in R (!). * DESCRIPTION (Version): 0.2-0 2010-01-14 Martin Maechler * R/array.R ([<-): define for more signatures (%*%, crossprod, tcrossprod): extend signatures to include more pairs, and using "Mnumber" instead of just "array_or_vector". * tests/matrix-ex.R: test part of that * man/*-class.Rd: additions, notably as.vector() and as(, "vector"). 2010-01-13 Martin Maechler * DESCRIPTION (Version): 0.1-8 * R/Math.R (.mpfr.sign): fix to ensure sign(0) |-> 0. Reported by Petr Savicky. * tests/arith-ex.R: test it. * src/init.c, src/convert.c (d2mpfr): outcomment unused function 2009-10-31 Martin Maechler * R/array.R: add "mpfrArray" -> "matrix" coercion * R/Arith.R (Arith): fix length check in ("mpfr", "array") * R/Consts.R (Const): nicer error message when 'name' is invalid. 2009-10-29 Martin Maechler * R/special-fun.R (beta, lbeta): new methods added * src/utils.c (my_mpfr_beta, my_mpfr_lbeta): own C functions, calling mpfr_*() ones, for beta() and lbeta(). * tests/special-fun-ex.R (B,lB): add tests for beta(), lbeta() 2009-09-14 Martin Maechler * src/Makevars.win: -lmpfr *before* -lgmp (does matter some places) 2009-09-10 Martin Maechler * R/mpfr.R (mpfrVersion): factor out .mpfrVersion() 2009-09-07 Martin Maechler * DESCRIPTION (Version): 0.1-7; released to CRAN * R/mpfr.R (mpfrVersion): amend for funny version string on Debian testings. * R/mpfr.R (mpfrVersion): new utility * src/utils.c (R_mpfr_get_version): C level * man/utils.Rd: doc * src/Ops.c (Math_mpfr): older MPFR libraries do not provide Li2(). 2009-09-03 Martin Maechler * R/Math.R (factorial): method which rounds in integer case. * man/mpfr-class.Rd: docu and examples. * man/is.whole.Rd: new for new is.whole() 2009-09-02 Martin Maechler * R/special-fun.R (Li2): add Li2() * man/mpfr-class.Rd: explicitly "enumerate" the 'Math' and 'Summary' group functions. 2009-09-01 Martin Maechler * DESCRIPTION (Version): 0.1-6, CRAN-released on 2009-09-04 * R/Math.R (Math2, i.e., round, signif): allow missing digits { => default digits = 0 or 6, respectively}. * R/mpfr.R (print, etc): use drop0trailing = TRUE per default. * R/as.R (formatMpfr): renamed from .format.mpfr; finalize using prettyNum(), add corresponding arguments and document: * man/formatMpfr.Rd: new * src/convert.c (mpfr2str): allocate the char 'ch' ourselves, carefully using R_alloc() and S_realloc(); unfortunately, the MPFR allocator *still* messes with our SEXPs. 2009-08-31 Martin Maechler * R/mpfr.R (seqMpfr): seqMpfr(3,1) works (again?) 2009-08-16 Martin Maechler * src/convert.c (mpfr2str): be over-PROTECT()ive, as Kurt reports VECTOR_ELT() errors on some platforms, and I can "randomly systematically" reproduce them with gctorture(). 2009-08-06 Martin Maechler * DESCRIPTION (Version): 0.1-5 -- release-ready * man/seqMpfr.Rd, ...: add all missing *Rd pages. * R/mpfr.R (seqMpfr): remove FIXME, using new pmin(), pmax(). * R/Math.R (Math2): group methods - for round() and signif() * src/convert.c (mpfr2i): new, for as(. "integer") 2009-08-05 Martin Maechler * R/mpfr.R (pmin, pmax): now seem to work * R/as.R (mpfr): as(, "mpfr") now uses mpfr() (mpfr): now also works for 'raw' and 'logical'; adding as(*,.) methods ==> x[.] <- NA should work * R/array.R (cbind, rbind): correct behavior when length/dims do not quite match. * R/array.R (dim<-): make work for NULL. * tests/matrix-ex.R: test these. * src/convert.c (d2mpfr, etc): PROTECT(.) all coerceVector()s. 2009-04-30 Martin Maechler * man/mpfr-class.Rd: mention sort(),.., duplicated(), ... 2009-04-13 Martin Maechler * src/convert.c (d2mpfr1_list, str2mpfr1_list): allow 'prec' to be a vector. * R/as.R (mpfr): now support mpfr(, prec) * src/convert.c (str2mpfr1_list): implement character |-> mpfr * src/utils.c (R_mpfr_set_default_prec, *_get_*): * R/array.R (cbind, rbind): also work when there are "character" * R/AllClasses.R (array_or_vector): only contain 'atomicVector' 2009-03-31 Martin Maechler * src/Makevars.win: add this after suggestions from Uwe 2009-02-06 Martin Maechler * R/Arith.R (Compare): add missing ', .Generic' to some methods. * tests/matrix-ex.R: testing 'A >= 3' etc 2009-02-02 Martin Maechler * R/array.R (cbind, rbind): new "..." methods for cbind(), rbind(), * R/AllClasses.R: using new "Mnumber" class * man/bind-methods.Rd: docu 2009-01-31 Martin Maechler * R/array.R (aperm): method. * R/AllClasses.R: 'Dimnames', not 'DimNames' * R/Arith.R: use .Arith.mpfr.num() macros etc, and make sure, these are used also in the o cases. * tests/matrix-ex.R: test array / mpfr 2009-01-27 Martin Maechler * R/array.R (.mpfrA.subset): if A[...] has length(dim(.))== 2, ensure it becomes an "mpfrMatrix" 2009-01-24 Martin Maechler * R/array.R (mpfrArray): make more (user friendly) like array() ([<-): render working also for A[i,j,k] <- val. (.mpfrA.subset): make A[,,1] working (.mA.subAssign): separate auxiliary function for more than 1 method 2009-01-22 Martin Maechler * src/Ops.c (Math_mpfr): activate (trunc,floor,ceiling) * tests/arith-ex.R: and test them minimally 2009-01-12 Martin Maechler * DESCRIPTION (Version): 0.1-1 -- another "snapshot" * R/array.R (t . mpfr): --> [ 1 x n ] - matrix * R/Arith.R (.dimCheck): add o methods, further o ones, etc. * tests/matrix-ex.R: testing them 2008-12-31 Martin Maechler * R/Math.R: slightly re-write methods so they automagically work for mpfrArray. * R/array.R (.matmult.R): %*%, crossprod(), tcrossprod(), t(), .. * tests/matrix-ex.R: new 2008-12-29 Martin Maechler * R/AllClasses.R: add "mpfrArray" and "mpfrMatrix" classes. * R/array.R (dim<-): from "mpfr" to "mpfrArray/Matrix" 2008-12-16 Martin Maechler * DESCRIPTION (Version): 0.1-0 -- "snapshot", not released. Rmpfr/.Rinstignore0000644000176200001440000000002211776116354013651 0ustar liggesusersinst/doc/Makefile Rmpfr/README.md0000644000176200001440000000264013735036657012640 0ustar liggesusers# Installation and Reference of the R package 'Rmpfr' Installation is non-trivial if you install from __source_ because of the `SystemRequirements` (listed in `./DESCRIPTION`): ## The package Rmpfr interfaces R to the C Library MPFR: __MPFR, the "Multiple Precision Floating-Point Reliably" library__ which is Free/Libre Software, available under the LGPL license. [MPFR Website](https://www.mpfr.org/) ## MPFR itself is built on and requires the GMP library __GNU Multiple Precision arithmetic library (GMP)__ Obtain that from [GMP Website](https://gmplib.org/) or from your operating system vendor / package system: + Under _Debian_, _Ubuntu_ (and other Debian derivative) Linux distributions, it is sufficient (for *both* libraries) to simply do ```sh sudo apt-get install libmpfr-dev ``` + In Fedora, Redhat, CentOS, opensuse, etc, you get these via ```sh sudo dnf install mpfr-devel ``` ## The standard reference to MPFR is ```bibtex @article{FouLHLPZ-2007, author = {Laurent Fousse and Guillaume Hanrot and Vincent Lef\`{e}vre and Patrick P\'{e}lissier and Paul Zimmermann}, title = {MPFR: A multiple-precision binary floating-point library with correct rounding}, year = {2007}, journal = {ACM Trans. Math. Softw.}, volume = {33}, number = {2}, issn = {0098-3500}, pages = {13}, doi = {http://doi.acm.org/10.1145/1236463.1236468}, publisher = {ACM}, address = {New York, NY, USA}, } ``` Rmpfr/man/0000755000176200001440000000000014552770135012124 5ustar liggesusersRmpfr/man/asNumeric-methods.Rd0000644000176200001440000000325012110004116015753 0ustar liggesusers\name{asNumeric-methods} \docType{methods} %% FIXME?? Should this migrate to base ?? --> have implicit generic and S3 generic there! %% ----- there, with semantic storage.mode(x) <- "numeric" \alias{asNumeric-methods} \alias{asNumeric,mpfr-method} \alias{asNumeric,mpfrArray-method} \title{Methods for \code{asNumeric()}} \description{% --> ~/R/Pkgs/gmp/man/asNumeric.Rd Methods for function \code{\link[gmp]{asNumeric}} (in package \pkg{gmp}). } \usage{ %\S4method{asNumeric}{mpfr}(x) \S4method{asNumeric}{mpfrArray}(x) } \arguments{ \item{x}{a \dQuote{number-like} object, here, a \code{\linkS4class{mpfr}} or typically \code{\linkS4class{mpfrArray}}one.} } \section{Methods}{ \describe{ \item{\code{signature(x = "mpfrArray")}}{this method also dispatches for \code{\linkS4class{mpfrMatrix}} and returns a numeric array.} \item{\code{signature(x = "mpfr")}}{for non-array/matrix, \code{asNumeric(x)} is basically the same as \code{as.numeric(x)}.} } } \value{ an \R object of type (\code{\link{typeof}}) \code{"numeric"}, a \code{\link{matrix}} or \code{\link{array}} if \code{x} had non-NULL dimension \code{\link{dim}()}. } \author{Martin Maechler} \seealso{ our lower level (non-generic) \code{\link{toNum}()}. Further, \code{\link[gmp]{asNumeric}} (package \pkg{gmp}), standard \R's \code{\link{as.numeric}()}. } \examples{ x <- (0:7)/8 # (exact) X <- mpfr(x, 99) stopifnot(identical(asNumeric(x), x), identical(asNumeric(X), x)) m <- matrix(1:6, 3,2) (M <- mpfr(m, 99) / 5) ##-> "mpfrMatrix" asNumeric(M) # numeric matrix stopifnot(all.equal(asNumeric(M), m/5), identical(asNumeric(m), m))# remains matrix } \keyword{methods} Rmpfr/man/distr-etc.Rd0000644000176200001440000000754614533575120014321 0ustar liggesusers\name{mpfr-distr-etc} \title{Distribution Functions with MPFR Arithmetic} \alias{pnorm} \alias{dnorm} \alias{dbinom} \alias{dnbinom} \alias{dgamma} \alias{dpois} \alias{dt} \alias{mpfr-distr}% <- alternative for \link \usage{% >>>> ../R/special-fun.R <<<< dpois (x, lambda, log = FALSE, useLog = ) dbinom (x, size, prob, log = FALSE, useLog = ) dnbinom(x, size, prob, mu, log = FALSE, useLog = any(x > 1e6)) dnorm (x, mean = 0, sd = 1, log = FALSE) dgamma(x, shape, rate = 1, scale = 1/rate, log = FALSE) dt (x, df, ncp, log = FALSE) pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE) } \description{ For some \R standard (probability) density, distribution or quantile functions, we provide MPFR versions. } \details{ \code{pnorm()} is based on \code{\link{erf}()} and \code{erfc()} which have direct MPFR counter parts and are both reparametrizations of \code{pnorm}, \code{erf(x) = 2*pnorm(sqrt(2)*x)} and \code{erfc(x) = 2* pnorm(sqrt(2)*x, lower=FALSE)}. } \note{E.g., for \code{pnorm(*, log.p = TRUE)} to be useful, i.e., not to underflow or overflow, you may want to extend the exponential range of MPFR numbers, using \code{\link{.mpfr_erange_set}()}, see the examples. } \arguments{ \item{x,q, lambda, size,prob, mu, mean,sd, shape,rate,scale, df,ncp}{% \code{\link{numeric}} or \code{\linkS4class{mpfr}} vectors. % for the function call. All of these are \dQuote{recycled} to the length of the longest one. For their meaning/definition, see the corresponding standard R (\pkg{stats} package) function.} \item{log, log.p, lower.tail}{logical, see \code{\link[stats:Normal]{pnorm}}, \code{\link[stats:Poisson]{dpois}}, etc.} \item{useLog}{\code{\link{logical}} with default depending on \code{x} etc, indicating if log-scale computation should be used even when \code{log = FALSE}, for performance or against overflow / underflow.} } \value{ A vector of the same length as the longest of \code{x,q, ...}, of class \code{\linkS4class{mpfr}} with the high accuracy results of the corresponding standard \R function. } \seealso{\code{\link[stats:Normal]{pnorm}}, \code{\link[stats]{dt}}, \code{\link[stats]{dbinom}}, \code{\link[stats]{dnbinom}}, \code{\link[stats]{dgamma}}, \code{\link[stats]{dpois}} in standard package \pkg{stats}. \code{\link{pbetaI}(x, a,b)} is a \code{\link{mpfr}} version of \code{\link{pbeta}} only for \emph{integer} \code{a} and \code{b}. } \examples{ x <- 1400+ 0:10 print(dpois(x, 1000), digits =18) ## standard R's double precision (px <- dpois(mpfr(x, 120), 1000))## more accuracy for the same px. <- dpois(mpfr(x, 120), 1000, useLog=TRUE)# {failed in 0.8-8} stopifnot(all.equal(px, px., tol = 1e-31)) dpois(0:5, mpfr(10000, 80)) ## very small exponents (underflowing in dbl.prec.) print(dbinom(0:8, 8, pr = 4 / 5), digits=18) dbinom(0:8, 8, pr = 4/mpfr(5, 99)) -> dB; dB print(dnorm( -5:5), digits=18) dnorm(mpfr(-5:5, prec=99)) ## For pnorm() in the extreme tails, need an exponent range ## larger than the (MPFR and Rmpfr) default: (old_eranges <- .mpfr_erange()) # typically -/+ 2^30: log2(abs(old_eranges)) # 30 30 .mpfr_erange_set(value = (1-2^-52)*.mpfr_erange(c("min.emin","max.emax"))) log2(abs(.mpfr_erange()))# 62 62 *if* setup -- 2023-01: *not* on Winbuilder, nor ## other Windows where long is 4 bytes (32 bit) and the erange typically cannot be extended. tens <- mpfr(10^(4:7), 128) pnorm(tens, lower.tail=FALSE, log.p=TRUE) # "works" (iff ...) ## "the" boundary: pnorm(mpfr(- 38581.371, 128), log.p=TRUE) # still does not underflow {but *.372 does} ## -744261105.599283824811986753129188937418 (iff ...) .mpfr_erange()*log(2) # the boundary ## Emin Emax ## -3.196577e+18 3.196577e+18 (iff ...) ## reset to previous .mpfr_erange_set( , old_eranges) pnorm(tens, lower.tail=FALSE, log.p=TRUE) # all but first underflow to -Inf } \keyword{distribution} Rmpfr/man/pmax.Rd0000644000176200001440000000336211764636731013371 0ustar liggesusers\name{pmax} \Rdversion{1.1} \alias{pmax} \alias{pmin} \alias{pmax-methods} \alias{pmin-methods} \alias{pmax,ANY-method} \alias{pmax,mNumber-method} \alias{pmin,ANY-method} \alias{pmin,mNumber-method} \title{Parallel Maxima and Minima} \description{ Returns the parallel maxima and minima of the input values. The functions \code{pmin} and \code{pmax} have been made S4 generics, and this page documents the \dQuote{\code{...} method for class \code{"mNumber"}}, i.e., for arguments that are numeric or from \code{\link{class} "\linkS4class{mpfr}"}. } \usage{ pmax(\dots, na.rm = FALSE) pmin(\dots, na.rm = FALSE) } \arguments{ \item{\dots}{numeric or arbitrary precision numbers (class \code{\linkS4class{mpfr}}).} \item{na.rm}{a logical indicating whether missing values should be removed.} } \details{ See \code{\link[base:Extremes]{pmax}}, the documentation of the base functions, i.e., default methods. } \value{ vector-like, of length the longest of the input vectors; typically of class \code{\linkS4class{mpfr}}, for the methods here. } \section{Methods}{ \describe{ \item{... = "ANY"}{the default method, really just \code{\link[base:Extremes]{base::pmin}} or \code{base::pmax}, respectively.} \item{... = "mNumber"}{the method for \code{\linkS4class{mpfr}} arguments, mixed with numbers; designed to follow the same semantic as the default method.} } } \seealso{ The documentation of the \pkg{base} functions, \code{\link[base:Extremes]{pmin}} and \code{pmax}; also \code{\link{min}} and \code{max}; further, \code{\link{range}} (\emph{both} min and max). } \examples{ (pm <- pmin(1.35, mpfr(0:10, 77))) stopifnot(pm == pmin(1.35, 0:10)) } \keyword{methods} \keyword{univar} \keyword{arith} Rmpfr/man/mpfr-utils.Rd0000644000176200001440000003341314552770112014514 0ustar liggesusers\name{mpfr-utils} \title{Rmpfr -- Utilities for Precision Setting, Printing, etc} \alias{getPrec} \alias{.getPrec} \alias{getD} \alias{mpfr_default_prec} \alias{mpfr2array} \alias{mpfrImport} \alias{mpfrXport} %\alias{.mpfr1tolist}% not exported \alias{print.mpfr} \alias{print.mpfrArray} \alias{toNum} \alias{.mpfr2d} \alias{.mpfr2i} \alias{.mpfr2list} %- \alias{.mpfr_formatinfo} \alias{.mpfr2exp} %- \alias{.mpfr_erange} \alias{.mpfr_erange_set} \alias{.mpfr_erange_kinds} \alias{.mpfr_erange_is_int} \alias{.mpfr_maxPrec} \alias{.mpfr_minPrec} \alias{.mpfr_gmp_numbbits} \alias{.mpfrVersion} %- really internal \alias{..bigq2mpfr} \alias{..bigz2mpfr} \alias{.getSign} \alias{.mpfr_negative} \alias{.mpfr_sign} \alias{.mpfr} \alias{.mpfr.} \description{ This page documents utilities from package \pkg{Rmpfr} which are typically not called by the user, but may come handy in some situations. Notably, the (base-2) maximal (and minimal) precision and the \dQuote{erange}, the range of possible (base-2) exponents of \code{\link{mpfr}}-numbers can be queried and partly extended. } \usage{ getPrec(x, base = 10, doNumeric = TRUE, is.mpfr = NA, bigq. = 128L) .getPrec(x) getD(x) mpfr_default_prec(prec) \S3method{print}{mpfrArray}(x, digits = NULL, drop0trailing = FALSE, right = TRUE, max.digits = getOption("Rmpfr.print.max.digits", 999L), exponent.plus = getOption("Rmpfr.print.exponent.plus", TRUE), \dots) \S3method{print}{mpfr}(x, digits = NULL, drop0trailing = TRUE, right = TRUE, max.digits = getOption("Rmpfr.print.max.digits", 999L), exponent.plus = getOption("Rmpfr.print.exponent.plus", TRUE), \dots) toNum(from, rnd.mode = c('N','D','U','Z','A')) .mpfr2d(from) .mpfr2i(from) mpfr2array(x, dim, dimnames = NULL, check = FALSE) .mpfr2list(x, names = FALSE) mpfrXport(x, names = FALSE) mpfrImport(mxp) .mpfr_formatinfo(x) .mpfr2exp(x) .mpfr_erange(kind = c("Emin", "Emax"), names = TRUE) .mpfr_erange_set(kind = c("Emin", "Emax"), value) .mpfr_erange_kinds .mpfr_erange_is_int() .mpfr_maxPrec() .mpfr_minPrec() .mpfr_gmp_numbbits() .mpfrVersion() ## Really Internal and low level, no error checking (for when you know ..) .mpfr (x, precBits) .mpfr.(x, precBits, rnd.mode) .getSign(x) .mpfr_negative(x) .mpfr_sign(x) ..bigq2mpfr(x, precB = NULL, rnd.mode = c("N", "D", "U", "Z", "A")) ..bigz2mpfr(x, precB = NULL, rnd.mode = c("N", "D", "U", "Z", "A")) } \arguments{ \item{x, from}{typically, an \R object of class \code{"\linkS4class{mpfr}"}, or \code{"\linkS4class{mpfrArray}"}, respectively. For \code{getPrec()}, any number-like \R object, or \code{\link{NULL}}.} \item{base}{(only when \code{x} is \code{\link{character}}) the base with respect to which \code{x[i]} represent numbers; \code{base} \eqn{b} must fulfill \eqn{2 \le b \le 62}{2 <= b <= 62}.} \item{doNumeric}{logical indicating \code{\link{integer}} or \code{\link{double}} typed \code{x} should be accepted and a default precision be returned. Should typically be kept at default \code{TRUE}.} \item{is.mpfr}{logical indicating if \code{\link{class}(x)} is already known to be \code{"mpfr"}; typically should be kept at default, \code{NA}.} \item{bigq.}{for \code{getPrec()}, the precision to use for a big rational (class \code{"bigq"}); if not specified gives warning when used.} \item{prec, precB, precBits}{a positive integer, or missing.} \item{drop0trailing}{logical indicating if trailing \code{"0"}s should be omitted.} \item{right}{logical indicating \code{print()}ing should right justify the strings; see \code{\link{print.default}()} to which it is passed.} \item{digits, \dots}{further arguments to print methods.} \item{max.digits}{a number (possibly \code{Inf}) to limit the number of (mantissa) digits to be printed, simply passed to \code{\link{formatMpfr}()}. The default is finite to protect from printing very long strings which is often undesirable, notably in \code{\link{interactive}} use.} \item{exponent.plus}{logical, simply passed to \code{\link{formatMpfr}()}. Was \code{FALSE} hardwired in Rmpfr versions before 0.8-0, and hence is allowed to be tweaked by an \code{\link{options}()} setting.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see details of \code{\link{mpfr}}.} \item{dim, dimnames}{for \code{"\linkS4class{mpfrArray}"} construction.} \item{check}{logical indicating if the mpfrArray construction should happen with internal safety check. Previously, the implicit default used to be true.} \item{names}{(for \code{.mpfr2list()}) \code{\link{logical}} or \code{\link{character}} vector, indicating if the list returned should have \code{\link{names}}. If character, it specifies the names; if true, the names are set to \code{format(x)}.} \item{mxp}{an \code{"mpfrXport"} object, as resulting from \code{mpfrXport()}.} \item{kind}{a \code{\link{character}} string or vector, specifying the kind of \dQuote{erange} value; must be an element of \code{.mpfr_erange_kinds}, i.e., one of \code{"Emin"}, \code{"Emax"}, \code{"min.emin"}, \code{"max.emin"}, \code{"min.emax"}, \code{"max.emax"}.} \item{value}{\code{\link{numeric}}, for \code{.mpfr_erange_set()} one number per \code{kind}. Must be in range specified by the \code{*."emin"} and \code{*."emax"} erange values.} } \details{ The \code{print} method is currently built on the \code{\link{format}} method for class \code{\linkS4class{mpfr}}. This, currently does \emph{not} format columns jointly which leads to suboptimally looking output. There are plans to change this. Note that \code{\link{formatMpfr}()} which is called by \code{print()} (or \code{show()} or \R's implicit printing) uses \code{max.digits = Inf}, differing from our \code{print()}'s default on purpose. If you do want to see the full accuracy even in cases it is large, use \code{\link{options}(Rmpfr.print.max.digits = Inf)} or \code{(.. = 1e7)}, say. The \code{.mpfr_erange*} functions (and variable) allow to query and set the allowed range of values for the base-2 \emph{exponents} of \code{"mpfr"} numbers. See the examples below and GNU MPFR library documentation on the C functions \code{mpfr_get_emin()}, \code{mpfr_set_emin(.)}, \code{mpfr_get_emin_min()}, and \code{mpfr_get_emin_max()}, (and those four with \sQuote{_emin} replaced by \sQuote{_emax} above). } \value{ \code{getPrec(x)} returns a \code{\link{integer}} vector of length one or the same length as \code{x} when that is positive, whereas \code{getPrec(NULL)} returns \code{mpfr_default_prec()}, see below. % the current MPFR default precision, see \code{mpfr_default_prec()} If you need to \emph{change} the precision of \code{x}, i.e., need something like \dQuote{setPrec}, use \code{\link{roundMpfr}()}. \code{.getPrec(x)} is a simplified version of \code{getPrec()} which only works for \code{"mpfr"} objects \code{x}. \code{getD(x)} is intended to be a fast version of \code{x@.Data}, and should not be used outside of lower level functions. \code{mpfr_default_prec()} returns the current MPFR default precision, an \code{\link{integer}}. This is currently % ?? not made use of much in package \pkg{Rmpfr}, where functions have their own default precision where needed, and otherwise we'd rather not be dependent of such a \emph{global} setting. \cr \code{mpfr_default_prec(prec)} \emph{sets} the current MPFR default precision and returns the previous one; see above. \code{.mpfr_maxPrec()} and (less interestingly) \code{.mpfr_minPrec()} give the maximal and minimal base-2 precision allowed in the current version of the MPFR library linked to by \R package \pkg{Rmpfr}. The maximal precision is typically \eqn{2^{63}}, i.e., \preformatted{ all.equal(.mpfr_maxPrec(), 2^63) } is typically true. \code{toNum(m)} returns a numeric \code{\link{array}} or \code{\link{matrix}}, when \code{m} is of class \code{"\linkS4class{mpfrArray}"} or \code{"\linkS4class{mpfrMatrix}"}, respectively. It should be equivalent to \code{as(m, "array")} or \code{... "matrix"}. Note that the slightly more general \code{\link{asNumeric}()} is preferred now. \code{.mpfr2d()} is similar to but simpler than \code{toNum()}, whereas \code{.mpfr2i()} is an analogue low level utility for \code{\link{as.integer}()}. \code{mpfr2array()} a slightly more flexible alternative to \code{dim(.) <- dd}. \code{.mpfr2exp(x)} returns the base-2 (integer valued) exponents of \code{x}, i.e., it is the \R interface to MPFR C's \code{mpfr_get_exp()}. The result is \code{\link{integer}} iff \code{.mpfr_erange_is_int()} is true, otherwise \code{\link{double}}. Note that the MPFR (4.0.1) manual says about \code{mpfr_get_exp()}: \emph{The behavior for NaN, infinity or zero is undefined}. \code{.mpfr_erange_is_int()} returns \code{TRUE} iff the \code{.mpfr_erange(c("Emin","Emax"))} range lies inside the range of \R's \code{\link{integer}} limits, i.e., has absolute values not larger than \code{\link{.Machine}$integer.max} (\eqn{ = 2^{31} - 1}). \code{.mpfr_erange_set()} \emph{invisibly} (see \code{\link{invisible}()}) returns \code{TRUE} iff the change was successful. \code{.mpfr_gmp_numbbits()} returns the \file{GMP} library \dQuote{numb} size, which is either 32 or 64 bit (as \code{\link{integer}}, i.e., \code{64L} or \code{32L}). If it is \emph{not} 64, you typically cannot enlarge the exponential range of mpfr numbers via \code{.mpfr_erange()}, see above. \code{.mpfrVersion()} returns a string, the version of the \file{MPFR} library we are linking to. \code{.mpfr_formatinfo(x)} returns conceptually a subset of \code{\link{.mpfr2str}()}'s result, a list with three components \describe{ \item{exp}{the base-2 exponents of \code{x}, identical to \code{.mpfr2exp(x)}.} \item{finite}{\code{\link{logical}} identical to \code{\link{is.finite}(x)}.} \item{is.0}{\code{\link{logical}} indicating if the corresponding \code{x[i]} is zero; identical to \code{\link{mpfrIs0}(x)}.}} (Note that \code{\link{.mpfr2str}(x, .., base)$exp} is wrt \code{base} \emph{and} is not undefined but ...)% FIXME \code{.mpfr_sign(x)} only works for \code{mpfr} objects, then identical to \code{\link{sign}(x)}. Analogously, \code{.mpfr_negative(x)} is \code{-x} in that case. \code{.getSign(x)} is a low-level version of \code{\link{sign}(x)} returning -1 or +1, but not 0. \cr Finally, \code{..bigq2mpfr(x, ..)} and \code{..bigz2mpfr(x, ..)} are fast ways to coerce \code{bigz} and \code{bigq} number objects (created by package \CRANpkg{gmp}'s functionality) to our \code{"mpfr"} class. } \note{ \code{mpfrXport()} and \code{mpfrImport()} are \bold{experimental} and used to explore reported platform incompatibilities of \code{\link{save}()}d and \code{\link{load}()}ed \code{"mpfr"} objects between Windows and non-Windows platforms. In other words, the format of the result of \code{mpfrXport()} and hence the \code{mxp} argument to \code{mpfrImport()} are considered internal, not part of the API and subject to change. } \seealso{ Start using \code{\link{mpfr}(..)}, and compute with these numbers. \code{\link{mpfrArray}(x)} is for numeric (\dQuote{non-mpfr}) \code{x}, whereas \code{mpfr2array(x)} is for \code{"mpfr"} classed \code{x}, only. } \examples{ getPrec(as(c(1,pi), "mpfr")) # 128 for both (opr <- mpfr_default_prec()) ## typically 53, the MPFR system default stopifnot(opr == (oprec <- mpfr_default_prec(70)), 70 == mpfr_default_prec()) ## and reset it: mpfr_default_prec(opr) ## Explore behavior of rounding modes 'rnd.mode': x <- mpfr(10,99)^512 # too large for regular (double prec. / numeric): sapply(c("N", "D", "U", "Z", "A"), function(RM) sapply(list(-x,x), function(.) toNum(., RM))) ## N D U Z A ## -Inf -Inf -1.797693e+308 -1.797693e+308 -Inf ## Inf 1.797693e+308 Inf 1.797693e+308 Inf ## Printing of "MPFR" matrices is less nice than R's usual matrix printing: m <- outer(c(1, 3.14, -1024.5678), c(1, 1e-3, 10,100)) m[3,3] <- round(m[3,3]) m mpfr(m, 50) B6 <- mpfr2array(Bernoulli(1:6, 60), c(2,3), dimnames = list(LETTERS[1:2], letters[1:3])) B6 ## Ranges of (base 2) exponents of MPFR numbers: .mpfr_erange() # the currently active range of possible base 2 exponents: ## A factory fresh setting fulfills .mpfr_erange(c("Emin","Emax")) == c(-1,1) * (2^30 - 1) ## There are more 'kind's, the latter 4 showing how you could change the first two : .mpfr_erange_kinds .mpfr_erange(.mpfr_erange_kinds) eLimits <- .mpfr_erange(c("min.emin", "max.emin", "min.emax", "max.emax")) ## Typically true in MPFR versions *iff* long is 64-bit, i.e. *not* on Windows if(.Machine$sizeof.long == 8L) { eLimits == c(-1,1, -1,1) * (2^62 - 1) } else if(.Machine$sizeof.long == 4L) # on Windows eLimits == c(-1,1, -1,1) * (2^30 - 1) ## Looking at internal representation [for power users only!]: i8 <- mpfr(-2:5, 32) x4 <- mpfr(c(NA, NaN, -Inf, Inf), 32) stopifnot(exprs = { identical(x4[1], x4[2]) is.na(x4[1] == x4[2]) # <- was *wrong* in Rmpfr <= 0.9-4 is.na(x4[1] != x4[2]) # (ditto) identical(x4 < i8[1:4], c(NA,NA, TRUE,FALSE)) !is.finite(x4) identical(is.infinite(x4), c(FALSE,FALSE, TRUE,TRUE)) }) ## The output of the following depends on the GMP "numb" size ## (32 bit vs. 64 bit), *and* additionally ## on sizeof.long (mostly non-Windows <-> Windows, see above): str( .mpfr2list(i8) ) str( .mpfr2list(x4, names = TRUE) ) str(xp4 <- mpfrXport(x4, names = TRUE)) stopifnot(identical(x4, mpfrImport(mpfrXport(x4))), identical(i8, mpfrImport(mpfrXport(i8)))) ## FIXME, need c(.), as dim(.) "get lost": stopifnot(identical(c(B6), mpfrImport(mpfrXport(B6)))) } \keyword{utilities} Rmpfr/man/chooseMpfr.Rd0000644000176200001440000001314614026150166014515 0ustar liggesusers\name{chooseMpfr} \alias{chooseMpfr} \alias{chooseMpfr.all} \alias{pochMpfr} \title{Binomial Coefficients and Pochhammer Symbol aka Rising Factorial} \description{ Compute binomial coefficients, \code{chooseMpfr(a,n)} being mathematically the same as \code{\link{choose}(a,n)}, but using high precision (MPFR) arithmetic. \code{chooseMpfr.all(n)} means the vector \code{\link{choose}(n, 1:n)}, using enough bits for exact computation via MPFR. However, \code{chooseMpfr.all()} is now \bold{deprecated} in favor of \code{\link[gmp]{chooseZ}} from package \pkg{gmp}, as that is now vectorized. \code{pochMpfr()} computes the Pochhammer symbol or \dQuote{rising factorial}, also called the \dQuote{Pochhammer function}, \dQuote{Pochhammer polynomial}, \dQuote{ascending factorial}, \dQuote{rising sequential product} or \dQuote{upper factorial}, \deqn{x^{(n)}=x(x+1)(x+2)\cdots(x+n-1)= \frac{(x+n-1)!}{(x-1)!} = \frac{\Gamma(x+n)}{\Gamma(x)}. }{x^(n) = x(x+1)(x+2)...(x+n-1) = (x+n-1)! / (x-1)! = Gamma(x+n) / Gamma(x).} } \usage{ chooseMpfr (a, n, rnd.mode = c("N","D","U","Z","A")) chooseMpfr.all(n, precBits=NULL, k0=1, alternating=FALSE) pochMpfr(a, n, rnd.mode = c("N","D","U","Z","A")) } \arguments{ \item{a}{a numeric or \code{\linkS4class{mpfr}} vector.} \item{n}{an \code{\link{integer}} vector; if not of length one, \code{n} and \code{a} are recycled to the same length.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see \code{\link{mpfr}}.} \item{precBits}{integer or NULL for increasing the default precision of the result.} \item{k0}{integer scalar} \item{alternating}{logical, for \code{chooseMpfr.all()}, indicating if \emph{alternating sign} coefficients should be returned, see below.} } \note{ Currently this works via a (C level) \code{for(i in 1:n)}-loop which really slow for large \code{n}, say \eqn{10^6}, with computational cost \eqn{O(n^2)}. In such cases, if you need high precision \code{choose(a,n)} (or Pochhammer(a,n)) for large \code{n}, preferably work with the corresponding \code{\link{factorial}(mpfr(..))}, or \code{\link{gamma}(mpfr(..))} terms. } \value{ For \describe{ \item{\code{chooseMpfr()}, \code{pochMpfr()}:}{an \code{\linkS4class{mpfr}} vector of length \code{max(length(a), length(n))};} \item{\code{chooseMpfr.all(n, k0)}:}{a \code{mpfr} vector of length \code{n-k0+1}, of binomial coefficients \eqn{C_{n,m}}{C[n,m]} or, if \code{alternating} is true, \eqn{(-1)^m\cdot C_{n,m}}{(-1)^m * C[n,m]} for \eqn{m \in}{m in} \code{k0:n}.} } } \seealso{ \code{\link{choose}(n,m)} (\pkg{base} \R) computes the binomial coefficient \eqn{C_{n,m}}{C[n,m]} which can also be expressed via Pochhammer symbol as \eqn{C_{n,m} = (n-m+1)^{(m)}/m!}{C[n,m] = (n-m+1)^(m) / m!}. \code{\link[gmp]{chooseZ}} from package \pkg{gmp}; for now, %% as we "deprecate" it, in favor of factorialZ() : \code{\link{factorialMpfr}}. For (alternating) binomial sums, directly use \code{\link{sumBinomMpfr}}, as that is potentially % once we do it in C more efficient. } \examples{ pochMpfr(100, 4) == 100*101*102*103 # TRUE a <- 100:110 pochMpfr(a, 10) # exact (but too high precision) x <- mpfr(a, 70)# should be enough (px <- pochMpfr(x, 10)) # the same as above (needing only 70 bits) stopifnot(pochMpfr(a, 10) == px, px[1] ==prod(mpfr(100:109, 100)))# used to fail (c1 <- chooseMpfr(1000:997, 60)) # -> automatic "correct" precision stopifnot(all.equal(c1, choose(1000:997, 60), tolerance=1e-12)) ## --- Experimenting & Checking n.set <- c(1:10, 20, 50:55, 100:105, 200:203, 300:303, 500:503, 699:702, 999:1001) if(!Rmpfr:::doExtras()) { ## speed up: smaller set n. <- n.set[-(1:10)] n.set <- c(1:10, n.[ c(TRUE, diff(n.) > 1)]) } C1 <- C2 <- numeric(length(n.set)) for(i.n in seq_along(n.set)) { cat(n <- n.set[i.n],":") C1[i.n] <- system.time(c.c <- chooseMpfr.all(n) )[1] C2[i.n] <- system.time(c.2 <- chooseMpfr(n, 1:n))[1] stopifnot(is.whole(c.c), c.c == c.2, if(n > 60) TRUE else all.equal(c.c, choose(n, 1:n), tolerance = 1e-15)) cat(" [Ok]\n") } matplot(n.set, cbind(C1,C2), type="b", log="xy", xlab = "n", ylab = "system.time(.) [s]") legend("topleft", c("chooseMpfr.all(n)", "chooseMpfr(n, 1:n)"), pch=as.character(1:2), col=1:2, lty=1:2, bty="n") ## Currently, chooseMpfr.all() is faster only for large n (>= 300) ## That would change if we used C-code for the *.all() version ## If you want to measure more: measureMore <- TRUE measureMore <- FALSE if(measureMore) { ## takes ~ 2 minutes (on "lynne", Intel i7-7700T, ~2019) n.s <- 2^(5:20) r <- lapply(n.s, function(n) { N <- ceiling(10000/n) cat(sprintf("n=\%9g => N=\%d: ",n,N)) ct <- system.time(C <- replicate(N, chooseMpfr(n, n/2))) cat("[Ok]\n") list(C=C, ct=ct/N) }) print(ct.n <- t(sapply(r, `[[`, "ct"))) hasSfS <- requireNamespace("sfsmisc") plot(ct.n[,"user.self"] ~ n.s, xlab=quote(n), ylab="system.time(.) [s]", main = "CPU Time for chooseMpfr(n, n/2)", log ="xy", type = "b", axes = !hasSfS) if(hasSfS) for(side in 1:2) sfsmisc::eaxis(side) summary(fm <- lm(log(ct.n[,"user.self"]) ~ log(n.s), subset = n.s >= 10^4)) ## --> slope ~= 2 ==> It's O(n^2) nn <- 2^seq(11,21, by=1/16) ; Lcol <- adjustcolor(2, 1/2) bet <- coef(fm) lines(nn, exp(predict(fm, list(n.s = nn))), col=Lcol, lwd=3) text(500000,1, substitute(AA \%*\% n^EE, list(AA = signif(exp(bet[1]),3), EE = signif( bet[2], 3))), col=2) } # measure more }% example \keyword{arith} Rmpfr/man/mpfrArray.Rd0000644000176200001440000000631113735036657014365 0ustar liggesusers\name{mpfrArray} \alias{mpfrArray} \title{Construct "mpfrArray" almost as by 'array()'}% <--> ./mpfrMatrix-class.Rd \description{ Utility to construct an \R object of class \code{\linkS4class{mpfrArray}}, very analogously to the numeric \code{\link{array}} function. } \usage{ mpfrArray(x, precBits, dim = length(x), dimnames = NULL, rnd.mode = c("N","D","U","Z","A")) } \arguments{ \item{x}{numeric(like) vector, typically of length \code{prod(dim)} or shorter in which case it is recycled.} \item{precBits}{a number, the maximal precision to be used, in \bold{\emph{bits}}; i.e., \code{53} corresponds to double precision. Must be at least 2.} \item{dim}{the dimension of the array to be created, that is a vector of length one or more giving the maximal indices in each dimension.} \item{dimnames}{either \code{NULL} or the names for the dimensions. This is a list with one component for each dimension, either \code{NULL} or a character vector of the length given by \code{dim} for that dimension.} %% ?array has more, about named dimnames etc... \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see details of \code{\link{mpfr}}.} } \value{ an object of class \code{"\linkS4class{mpfrArray}"}, specifically \code{"\linkS4class{mpfrMatrix}"} when \code{length(dim) == 2}. } \seealso{\code{\link{mpfr}}, \code{\link{array}}; \code{\link{asNumeric}()} as \dQuote{inverse} of \code{mpfrArray()}, to get back a numeric array. \code{\link{mpfr2array}(x)} is for \code{"mpfr"} classed \code{x}, only, whereas \code{mpfrArray(x)} is for numeric (\dQuote{non-mpfr}) \code{x}. } \examples{ ## preallocating is possible here too ma <- mpfrArray(NA, prec = 80, dim = 2:4) validObject(A2 <- mpfrArray(1:24, prec = 64, dim = 2:4)) ## recycles, gives an "mpfrMatrix" and dimnames : mat <- mpfrArray(1:5, 64, dim = c(5,3), dimnames=list(NULL, letters[1:3])) mat asNumeric(mat) stopifnot(identical(asNumeric(mat), matrix(1:5 +0, 5,3, dimnames=dimnames(mat)))) ## Testing the apply() method : apply(mat, 2, range) apply(A2, 1:2, range) apply(A2, 2:3, max) (fA2 <- apply(A2, 2, fivenum)) a2 <- as(A2, "array") stopifnot(as(apply(A2, 2, range), "matrix") == apply(a2, 2, range) , all.equal(fA2, apply(a2, 2, fivenum)) , all.equal(apply(A2, 2, quantile), apply(a2, 2, quantile)) , all.equal(A2, apply(A2, 2:3, identity) -> aA2, check.attributes=FALSE) , dim(A2) == dim(aA2) ) \dontshow{ for(nf in c("colSums", "colMeans", "rowSums", "rowMeans")) { FUN <- getFunction(nf) for(di in c(1,2)) { r <- FUN(a2, dims = di) R <- FUN(A2, dims = di) stopifnot(identical(dim(r), dim(R)), # possibly both NULL all.equal(as(R, if(is.array(r)) "array" else "numeric"), unname(r), tol = 1e-15)) } } ## with non-trivial dimnames: ma2 <- mat dimnames(ma2) <- list(row=paste0("r",1:5), col=colnames(mat)) stopifnot(identical(ma2, apply(ma2, 2, identity)), identical(ma2, t(apply(ma2, 1, identity))), identical(names(apply(ma2,2,sum)), colnames(ma2)) ) }%end{ dontshow } } \keyword{array} Rmpfr/man/matmult.Rd0000644000176200001440000000507013637431043014073 0ustar liggesusers\name{matmult} \title{(MPFR) Matrix (Vector) Multiplication} %% Note : all the %*%, crossprod(), and tcrossprod() methods are documented in %% ---- ===> ./mpfrMatrix-class.Rd %% ^^^^^^^^^^^^^^^^^^^ \alias{matmult} \alias{.matmult.R}% hidden, not exported \description{ Matrix / vector multiplication of \code{\link{mpfr}} (and \dQuote{simple} \code{\link{numeric}}) matrices and vectors. \code{ matmult (x,y, fPrec = 2)} or \code{crossprod(x,y, fPrec = 2)} use higher precision in underlying computations. } \usage{ matmult(x, y, ...) %% .matmult.R(x,y, op = 0L, fPrec = 1, precBits = fPrec * max(getPrec(x), getPrec(y))) } \arguments{ \item{x, y}{\code{\link{numeric}} or \code{\linkS4class{mpfrMatrix}}-classed \R objects, i.e. semantically numeric matrices or vectors.} \item{\dots}{arguments passed to the hidden underlying \code{.matmult.R()} work horse which is also underlying the \code{\link{\%*\%}}, \code{\link{crossprod}()}, and \code{\link{tcrossprod}()} methods, see the \code{\linkS4class{mpfrMatrix}} class documentation: \describe{ \item{fPrec}{a multiplication factor, a positive number determining the number of bits \code{precBits} used for the underlying multiplication and summation arithmetic. The default is \code{fPrec = 1}. Setting \code{fPrec = 2} doubles the precision which has been recommended, e.g., by John Nash.} \item{precBits}{the number of bits used for the underlying multiplication and summation arithmetic; by default \code{precBits = fPrec * max(getPrec(x), getPrec(y))} which typically uses the same accuracy as regular \code{\link{mpfr}}-arithmetic would use.} }} } %% \details{ %% %% ~~ If necessary, more details than the description above ~~ %% } \value{ a (base \R) \code{\link{matrix}} or \code{\linkS4class{mpfrMatrix}}, depending on the classes of \code{x} and \code{y}. } %% \references{ %% } \author{Martin Maechler} \note{ Using \code{matmult(x,y)} instead of \code{x \link{\%*\%} y}, makes sense mainly \emph{if} you use non-default \code{fPrec} or \code{precBits} arguments. The \code{\link{crossprod}()}, and \code{\link{tcrossprod}()} function have the \emph{identical} optional arguments \code{fPrec} or \code{precBits}. } \seealso{ \code{\link{\%*\%}}, \code{\link{crossprod}}, \code{\link{tcrossprod}}. } \examples{ %% ## The function is currently defined as %% function (x, y, ...) %% .matmult.R(x, y, op = 0L, ...) ## FIXME: add example ## 1) matmult() <--> \%*\% ## 2) crossprod() , tcrossprod() %% <--> ./mpfrMatrix-class.Rd examples (!) } \keyword{arith} Rmpfr/man/qnormI.Rd0000644000176200001440000001473214533561037013665 0ustar liggesusers\name{qnormI} \alias{qnormI} \title{Gaussian / Normal Quantiles \code{qnorm()} via Inversion} \description{ Compute Gaussian or Normal Quantiles \code{\link{qnorm}(p, *)} via inversion of our \dQuote{mpfr-ified} arbitrary accurate \code{\link[Rmpfr]{pnorm}()}, using our \code{\link{unirootR}()} root finder. } \usage{%--> ../R/unirootR.R qnormI(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE, trace = 0, verbose = as.logical(trace), tol, useMpfr = any(prec > 53), give.full = FALSE, \dots) } \arguments{% ~/R/D/r-devel/R/src/library/stats/man/Normal.Rd <<<<< \item{p}{vector of probabilities.} \item{mean}{vector of means.} \item{sd}{vector of standard deviations.} \item{log.p}{logical; if TRUE, probabilities p are given as log(p).} \item{lower.tail}{logical; if TRUE (default), probabilities are \eqn{P[X \le x]} otherwise, \eqn{P[X > x]}.} %%-- \item{trace}{integer passed to \code{\link{unirootR}()}. If positive, information about a search interval extension will be printed to the console.} \item{verbose}{logical indicating if progress details should be printed to the console.} \item{tol}{optionally the desired accuracy (convergence tolerance); if missing or not finite, it is computed as \eqn{2^-{pr+2}} where the precision \eqn{pr} is basically \code{max(\link{getPrec}(p+mean+sd))}.} \item{useMpfr}{logical indicating if \code{\link{mpfr}} arithmetic should be used.}% Its default is derived from \code{tol} when that is specified.} \item{give.full}{logical indicating if the \emph{full} result of \code{\link{unirootR}()} should be returned (when applicable).} \item{\dots}{optional further arguments passed to \code{\link{unirootR}()} such as \code{maxiter}, \code{verbDigits}, \code{check.conv}, \code{warn.no.convergence}, and \code{epsC}.} } \value{ If \code{give.full} is true, return a \code{\link{list}}, say \code{r}, of \code{\link{unirootR}(.)} results, with \code{length(r) == length(p)}. Otherwise, return a \dQuote{numeric vector} like \code{p}, e.g., of \code{class "mpfr"} when \code{p} is. } \author{Martin Maechler} \seealso{ Standard \R's \code{\link[stats]{qnorm}}. } \examples{ doX <- Rmpfr:::doExtras() # slow parts only if(doX) cat("doExtras: ", doX, "\n") p <- (0:32)/32 lp <- -c(1000, 500, 200, 100, 50, 20:1, 2^-(1:8)) if(doX) { tol1 <- 2.3e-16 tolM <- 1e-20 tolRIlog <- 4e-14 } else { # use one more than a third of the points: ip <- c(TRUE,FALSE, rep_len(c(TRUE,FALSE,FALSE), length(p)-2L)) p <- p[ip] lp <- lp[ip] tol1 <- 1e-9 tolM <- 1e-12 tolRIlog <- 25*tolM } f.all.eq <- function(a,b) sub("^Mean relative difference:", '', format(all.equal(a, b, tol=0))) for(logp in c(FALSE,TRUE)) { pp <- if(logp) lp else p mp <- mpfr(pp, precBits = if(doX) 80 else 64) # precBits = 128 gave "the same" as 80 for(l.tail in c(FALSE,TRUE)) { qn <- qnorm (pp, lower.tail = l.tail, log.p = logp) qnI <- qnormI(pp, lower.tail = l.tail, log.p = logp, tol = tol1) qnM <- qnormI(mp, lower.tail = l.tail, log.p = logp, tol = tolM) cat(sprintf("Accuracy of qnorm(*, lower.t=\%-5s, log.p=\%-5s): \%s || qnI: \%s\n", l.tail, logp, f.all.eq(qnM, qn ), f.all.eq(qnM, qnI))) stopifnot(exprs = { all.equal(qn, qnI, tol = if(logp) tolRIlog else 4*tol1) all.equal(qnM, qnI, tol = tol1) }) } } ## useMpfr, using mpfr() : if(doX) { p2 <- 2^-c(1:27, 5*(6:20), 20*(6:15)) e2 <- 88 } else { p2 <- 2^-c(1:2, 7, 77, 177, 307) e2 <- 60 } system.time( pn2 <- pnorm(qnormI(mpfr(p2, e2))) ) # 4.1 or 0.68 all.equal(p2, pn2, tol = 0) # 5.48e-29 // 5.2e-18 2^-e2 stopifnot(all.equal(p2, pn2, tol = 6 * 2^-e2)) # '4 *' needed ## Boundary -- from limits in mpfr maximal exponent range! ## 1) Use maximal ranges: (old_eranges <- .mpfr_erange()) # typically -/+ 2^30 (myERng <- (1-2^-52) * .mpfr_erange(c("min.emin","max.emax"))) (doIncr <- !isTRUE(all.equal(unname(myERng), unname(old_eranges)))) # ==> ## TRUE only if long is 64-bit, i.e., *not* on Windows if(doIncr) .mpfr_erange_set(value = myERng) log2(abs(.mpfr_erange()))# 62 62 if(doIncr) i.e. not on Windows (lrgOK <- all(log2(abs(.mpfr_erange())) >= 62)) # FALSE on Windows ## The largest quantile for which our mpfr-ized qnorm() does *NOT* underflow : cM <- if(doX) { "2528468770.343293436810768159197281514373932815851856314908753969469064" } else "2528468770.34329343681" ## 1 3 5 7 9 1 3 5 7 9 1 3 5 7 9 1 3 5 7 9 1 3 5 7 9 1 3 5 7 9 1 3 5 7 9 1 3 ## 10 20 30 40 50 60 70 (qM <- mpfr(cM)) (pM <- pnorm(-qM)) # precision if(doX) 233 else 70 bits of precision ; ## |--> 0 on Windows {limited erange}; otherwise and if(doX) : ## 7.64890682545699845135633468495894619457903458325606933043966616334460003e-1388255822130839040 log(pM) # 233 bits: -3196577161300663205.8575919621115614148120323933633827052786873078552904 if(lrgOK) withAutoprint({ %% FIXME : here, the internal qnInt() gives (-Inf, -Inf) : try( qnormI(pM) ) ## Error: lower < upper not fulfilled (evt. TODO) ## but this works print(qnI <- qnormI(log(pM), log.p=TRUE)) # -2528468770.343293436 all.equal(-qM, qnI, tol = 0) # << show how close; seen 1.084202e-19 stopifnot( all.equal(-qM, qnI, tol = 1e-18) ) }) if(FALSE) # this (*SLOW*) gives 21 x the *same* (wrong) result --- FIXME! qnormI(log(pM) * (2:22), log.p=TRUE) %% 21 'mpfr' numbers of precision 233 bits --- actually see *2* slightly differing: %% [1] -2528468770.34329343681076815919728151437393281585185631490875396946906388 %% [2] -2528468770.34329343681076815919728151437393281585185631490875396946906388 %% ............... %% [20] -2528468770.34329343681076815919728151437393281585185631490875396946906419 << %% [21] -2528468770.34329343681076815919728151437393281585185631490875396946906388 if(doX) ## Show how bad it is (currently ca. 220 iterations, and then *wrong*) str(qnormI(round(log(pM)), log.p=TRUE, trace=1, give.full = TRUE)) if(requireNamespace("DPQ")) new("mpfr", as(DPQ::qnormR(pM, trace=1), "mpfr")) # as(*, "mpfr") also works for +/- Inf # qnormR1(p= 0, m=0, s=1, l.t.= 1, log= 0): q = -0.5 # somewhat close to 0 or 1: r := sqrt(-lp) = 1.7879e+09 # r > 5, using rational form R_3(t), for t=1.787897e+09 -- that is *not* accurate # [1] -94658744.369295865460462720............ ## reset to previous status if needed if(doIncr) .mpfr_erange_set( , old_eranges) } \keyword{distribution} \keyword{math} Rmpfr/man/special-math.Rd0000644000176200001440000000463514231543360014762 0ustar liggesusers\name{mpfr-special-functions} \alias{zeta} \alias{Ei} \alias{Li2} \alias{erf} \alias{erfc} \title{Special Mathematical Functions (MPFR)} \description{ Special Mathematical Functions, supported by the MPFR Library. Note that additionally, all the \code{\link{Math}} and \code{\link{Math2}} group member functions are \dQuote{mpfr-ified}, too; ditto, for many more standard \R functions. See see the methods listed in \code{\linkS4class{mpfr}} (aka \code{?`\link{mpfr-class}`}). % ./mpfr-class.Rd } \usage{ zeta(x) Ei(x) Li2(x) erf(x) erfc(x) } \arguments{ \item{x}{a \code{\link{numeric}} or \code{\linkS4class{mpfr}} vector.} } \details{ \code{zeta(x)} computes Riemann's Zeta function \eqn{\zeta(x)}{zeta(x)} important in analytical number theory and related fields. The traditional definition is \deqn{\zeta(x) = \sum_{n=1}^\infty \frac{1}{n^x}.}{Zeta(x) = sum[n=1..Inf; 1/(n^x)].} \code{Ei(x)} computes the \bold{e}xponential integral, \deqn{\int_{-\infty}^{x} \frac{e^t}{t} \; dt.}{Integral(-Inf,x; e^t/t dt).} \code{Li2(x)} computes the dilogarithm, \deqn{\int_{0}^{x} \frac{-log(1-t)}{t} \; dt.}{Integral(0,x; -log(1-t)/t dt).} \code{erf(x)} and \code{erfc(x)} are the error, respectively \bold{c}omplementary error function which are both reparametrizations of \code{\link{pnorm}}, \code{erf(x) = 2*pnorm(sqrt(2)*x)} and \code{erfc(x) = 2* pnorm(sqrt(2)*x, lower=FALSE)}, and hence \pkg{Rmpfr} provides its own version of \code{\link{pnorm}}. } \value{ A vector of the same length as \code{x}, of class \code{\linkS4class{mpfr}}. } \seealso{\code{\link[stats:Normal]{pnorm}} in standard package \pkg{stats}; the class description \code{\linkS4class{mpfr}} mentioning the generic arithmetic and mathematical functions (\code{sin}, \code{log}, \dots, etc) for which \code{"mpfr"} methods are available. Note the (integer order, non modified) Bessel functions \eqn{j_0()}, \eqn{y_n()}, etc, named \code{\link{j0}, \link{yn}} etc, and Airy function \eqn{Ai()} in \link{Bessel_mpfr}. } \examples{ curve(Ei, 0, 5, n=2001) ## As we now require (mpfrVersion() >= "2.4.0"): curve(Li2, 0, 5, n=2001) curve(Li2, -2, 13, n=2000); abline(h=0,v=0, lty=3) curve(Li2, -200,400, n=2000); abline(h=0,v=0, lty=3) curve(erf, -3,3, col = "red", ylim = c(-1,2)) curve(erfc, add = TRUE, col = "blue") abline(h=0, v=0, lty=3) legend(-3,1, c("erf(x)", "erfc(x)"), col = c("red","blue"), lty=1) } \keyword{math} Rmpfr/man/seqMpfr.Rd0000644000176200001440000000420413417136645014031 0ustar liggesusers\name{seqMpfr} %% This is to contain the "true" seq() methods --- once we can ! --- \Rdversion{1.1} \alias{seqMpfr} \title{"mpfr" Sequence Generation} \description{ Generate \sQuote{regular}, i.e., arithmetic sequences. This is in lieu of methods for \code{\link{seq}} (dispatching on all three of \code{from}, \code{to}, and \code{by}. } \usage{ seqMpfr(from = 1, to = 1, by = ((to - from)/(length.out - 1)), length.out = NULL, along.with = NULL, \dots) } \arguments{ \item{from, to}{the starting and (maximal) end value (numeric or \code{"\linkS4class{mpfr}"}) of the sequence.} \item{by}{number (numeric or \code{"\linkS4class{mpfr}"}): increment of the sequence.} \item{length.out}{desired length of the sequence. A non-negative number, which will be rounded up if fractional.} \item{along.with}{take the length from the length of this argument.} \item{\dots}{arguments passed to or from methods.} } \details{ see \code{\link[base]{seq}} (default method in package \pkg{base}), whose semantic we want to replicate (almost).% not seq(9:6) => seq(4) } \value{ a \sQuote{vector} of class \code{"\linkS4class{mpfr}"}, when one of the first three arguments was. } \author{Martin Maechler} \seealso{ The documentation of the \pkg{base} function \code{\link[base]{seq}}; \code{\link{mpfr}} } \examples{ seqMpfr(0, 1, by = mpfr(0.25, prec=88)) seqMpfr(7, 3) # -> default prec. \dontshow{ eq.test <- function(...) { args <- list(...) r <- do.call(seqMpfr, args) is(r, "mpfr") && all(r == do.call(seq, lapply(args, as.numeric))) } m <- mpfr(8, 60); m2 <- as(2, "mpfr") stopifnot(seqMpfr(7,3) == 7:3, seqMpfr(to=1) == 1, eq.test(pi), eq.test(1,12,3), eq.test(1, by= 2, length= 5), eq.test(1, by=m2, length= 5), eq.test(1, length.out = 8), eq.test(1, length.out = m), eq.test(1, 8, length.out=8), eq.test(1, 8, length.out=m), eq.test(1, m, length.out=m), eq.test(1, m, length.out=8), eq.test(to=17, by= 2, length=4), eq.test(to=17, by=m2, length=4), TRUE) }% {dontshow} -- but test } \keyword{manip} Rmpfr/man/integrateR.Rd0000644000176200001440000001232712402301607014506 0ustar liggesusers\name{integrateR} \title{One-Dimensional Numerical Integration - in pure R} \alias{integrateR} \alias{print.integrateR} \alias{show,integrateR-method} \description{ Numerical integration of one-dimensional functions in pure \R, with care so it also works for \code{"mpfr"}-numbers. Currently, only classical Romberg integration of order \code{ord} is available. } \usage{ integrateR(f, lower, upper, \dots, ord = NULL, rel.tol = .Machine$double.eps^0.25, abs.tol = rel.tol, max.ord = 19, verbose = FALSE) } \arguments{ \item{f}{an \R function taking a numeric or \code{"mpfr"} first argument and returning a numeric (or \code{"mpfr"}) vector of the same length. Returning a non-finite element will generate an error. } \item{lower, upper}{the limits of integration. Currently \emph{must} be finite. Do use \code{"mpfr"}-numbers to get higher than double precision, see the examples.} \item{\dots}{additional arguments to be passed to \code{f}.} \item{ord}{integer, the order of Romberg integration to be used. If this is \code{NULL}, as per default, and either \code{rel.tol} or \code{abs.tol} are specified, the order is increased until convergence.} \item{rel.tol}{relative accuracy requested. The default is 1.2e-4, about 4 digits only, see the Note.} \item{abs.tol}{absolute accuracy requested.} \item{max.ord}{only used, when neither \code{ord} or one of \code{rel.tol}, \code{abs.tol} are specified: Stop Romberg iterations after the order reaches \code{max.ord}; may prevent infinite loops or memory explosion.} \item{verbose}{logical or integer, indicating if and how much information should be printed during computation.} } \details{ Note that arguments after \code{\dots} must be matched exactly. For convergence, \emph{both} relative and absolute changes must be smaller than \code{rel.tol} and \code{abs.tol}, respectively. \code{rel.tol} cannot be less than \code{max(50*.Machine$double.eps, 0.5e-28)} if \code{abs.tol <= 0}. } \note{ \code{f} must accept a vector of inputs and produce a vector of function evaluations at those points. The \code{\link{Vectorize}} function may be helpful to convert \code{f} to this form. If you want to use higher accuracy, you \emph{must} set \code{lower} or \code{upper} to \code{"\link{mpfr}"} numbers (and typically lower the relative tolerance, \code{rel.tol}), see also the examples. Note that the default tolerances (\code{rel.tol}, \code{abs.tol}) are not very accurate, but the same as for \code{\link{integrate}}, which however often returns considerably more accurate results than requested. This is typically \emph{not} the case for \code{integrateR()}. } \value{ A list of class \code{"integrateR"} (as from standard \R's \code{\link{integrate}()}) with a \code{\link{print}} method and components \item{value}{the final estimate of the integral.} \item{abs.error}{estimate of the modulus of the absolute error.} \item{subdivisions}{for Romberg, the number of function evaluations.} \item{message}{\code{"OK"} or a character string giving the error message.} \item{call}{the matched call.} } \references{ Bauer, F.L. (1961) Algorithm 60 -- Romberg Integration, \emph{Communications of the ACM} \bold{4}(6), p.255. } \author{Martin Maechler} \seealso{ \R's standard, \code{\link{integrate}}, is much more adaptive, also allowing infinite integration boundaries, and typically considerably faster for a given accuracy. } \note{ We use practically the same \code{print} S3 method as \code{\link{print.integrate}}, provided by \R,% 'stats' package with a difference when the \code{message} component is not \code{"Ok"}. } \examples{ ## See more from ?integrate ## this is in the region where integrate() can get problems: integrateR(dnorm,0,2000) integrateR(dnorm,0,2000, rel.tol=1e-15) (Id <- integrateR(dnorm,0,2000, rel.tol=1e-15, verbose=TRUE)) Id$value == 0.5 # exactly ## Demonstrating that 'subdivisions' is correct: Exp <- function(x) { .N <<- .N+ length(x); exp(x) } .N <- 0; str(integrateR(Exp, 0,1, rel.tol=1e-10), digits=15); .N ### Using high-precision functions ----- ## Polynomials are very nice: integrateR(function(x) (x-2)^4 - 3*(x-3)^2, 0, 5, verbose=TRUE) # n= 1, 2^n= 2 | I = 46.04, abs.err = 98.9583 # n= 2, 2^n= 4 | I = 20, abs.err = 26.0417 # n= 3, 2^n= 8 | I = 20, abs.err = 7.10543e-15 ## 20 with absolute error < 7.1e-15 ## Now, using higher accuracy: I <- integrateR(function(x) (x-2)^4 - 3*(x-3)^2, 0, mpfr(5,128), rel.tol = 1e-20, verbose=TRUE) I ; I$value ## all fine ## with floats: integrateR(exp, 0 , 1, rel.tol=1e-15, verbose=TRUE) ## with "mpfr": (I <- integrateR(exp, mpfr(0,200), 1, rel.tol=1e-25, verbose=TRUE)) (I.true <- exp(mpfr(1, 200)) - 1) ## true absolute error: stopifnot(print(as.numeric(I.true - I$value)) < 4e-25) ## Want absolute tolerance check only (=> set 'rel.tol' very high, e.g. 1): (Ia <- integrateR(exp, mpfr(0,200), 1, abs.tol = 1e-6, rel.tol=1, verbose=TRUE)) ## Set 'ord' (but no '*.tol') --> Using 'ord'; no convergence checking (I <- integrateR(exp, mpfr(0,200), 1, ord = 13, verbose=TRUE)) } \keyword{math} \keyword{utilities} Rmpfr/man/sumBinomMpfr.Rd0000644000176200001440000001032413546047111015022 0ustar liggesusers\name{sumBinomMpfr} \alias{sumBinomMpfr} \title{(Alternating) Binomial Sums via Rmpfr} \concept{Rice integral} \concept{Forward Difference} \description{ Compute (alternating) binomial sums via high-precision arithmetic. If \eqn{sBn(f, n) :=}\code{sumBinomMpfr(n, f)}, (default \code{alternating} is true, and \code{n0 = 0}), \deqn{sBn(f,n) = \sum_{k = n0}^n (-1)^(n-k) {n \choose k}\cdot f(k) = \Delta^n f,}{% sBn(f,n) = sum(k = n0:n ; (-1)^(n-k) choose(n,k) * f(k)) = \Delta^n f,} see Details for the \eqn{n}-th forward difference operator \eqn{\Delta^n f}. If \code{alternating} is false, the \eqn{(-1)^(n-k)} factor is dropped (or replaced by \eqn{1}) above. Such sums appear in different contexts and are typically challenging, i.e., currently impossible, to evaluate reliably as soon as \eqn{n} is larger than around \eqn{50--70}. } \usage{ sumBinomMpfr(n, f, n0 = 0, alternating = TRUE, precBits = 256, f.k = f(mpfr(k, precBits=precBits))) } \arguments{ \item{n}{upper summation index (integer).} \item{f}{\code{\link{function}} to be evaluated at \eqn{k} for \code{k in n0:n} (and which must return \emph{one} value per \code{k}).} \item{n0}{lower summation index, typically \code{0} (= default) or \code{1}.} \item{alternating}{logical indicating if the sum is alternating, see below.} \item{precBits}{the number of bits for MPFR precision, see \code{\link{mpfr}}.} \item{f.k}{can be specified instead of \code{f} and \code{precBits}, and must contain the equivalent of its default, \code{f(mpfr(k, precBits=precBits))}.} } \details{ The alternating binomial sum \eqn{sB(f,n) := sumBinom(n, f, n0=0)} is equal to the \eqn{n}-th forward difference operator \eqn{\Delta^n f}, \deqn{sB(f,n) = \Delta^n f,} where \deqn{\Delta^n f = \sum_{k=0}^{n} (-1)^{n-k}{n \choose k}\cdot f(k),}{% Delta^n f = sum(k = n0:n ; (-1)^(n-k) choose(n,k) * f(k)),} is the \eqn{n}-fold iterated forward difference \eqn{\Delta f(x) = f(x+1) - f(x)} (for \eqn{x = 0}). The current implementation might be improved in the future, notably for the case where \eqn{sB(f,n)=}\code{sumBinomMpfr(n, f, *)} is to be computed for a whole sequence \eqn{n = 1,\dots,N}{n = 1,...,N}. } %% Now (2012-05-15) have the first version (hidden) as sumBinomMpfr.v1() \value{ an \code{\linkS4class{mpfr}} number of precision \code{precBits}. \eqn{s}. If \code{alternating} is true (as per default), \deqn{s = \sum_{k = n0}^n (-1)^k {n \choose k}\cdot f(k),}{% s = sum(k = n0:n ; (-1)^k choose(n,k) * f(k)),} if \code{alternating} is false, the \eqn{(-1)^k} factor is dropped (or replaced by \eqn{1}) above. } \references{ Wikipedia (2012) The N\"orlund-Rice integral, \url{https://en.wikipedia.org/wiki/Rice_integral} Flajolet, P. and Sedgewick, R. (1995) Mellin Transforms and Asymptotics: Finite Differences and Rice's Integrals, \emph{Theoretical Computer Science} \bold{144}, 101--124. } \author{Martin Maechler, after conversations with Christophe Dutang.} \seealso{ \code{\link{chooseMpfr}}, \code{\link[gmp]{chooseZ}} from package \pkg{gmp}. } \examples{ ## "naive" R implementation: sumBinom <- function(n, f, n0=0, ...) { k <- n0:n sum( choose(n, k) * (-1)^(n-k) * f(k, ...)) } ## compute sumBinomMpfr(.) for a whole set of 'n' values: sumBin.all <- function(n, f, n0=0, precBits = 256, ...) { N <- length(n) precBits <- rep(precBits, length = N) ll <- lapply(seq_len(N), function(i) sumBinomMpfr(n[i], f, n0=n0, precBits=precBits[i], ...)) sapply(ll, as, "double") } sumBin.all.R <- function(n, f, n0=0, ...) sapply(n, sumBinom, f=f, n0=n0, ...) n.set <- 5:80 system.time(res.R <- sumBin.all.R(n.set, f = sqrt)) ## instantaneous.. system.time(resMpfr <- sumBin.all (n.set, f = sqrt)) ## ~ 0.6 seconds \dontshow{ stopifnot( all.equal(resMpfr[1:10], res.R[1:10], tolerance=1e-12), all.equal(resMpfr[1:20], res.R[1:20], tolerance=1e-9 ), all.equal(resMpfr[1:30], res.R[1:30], tolerance=1e-6 )) } matplot(n.set, cbind(res.R, resMpfr), type = "l", lty=1, ylim = extendrange(resMpfr, f = 0.25), xlab = "n", main = "sumBinomMpfr(n, f = sqrt) vs. R double precision") legend("topleft", leg=c("double prec.", "mpfr"), lty=1, col=1:2, bty = "n") } \keyword{arith} Rmpfr/man/formatMpfr.Rd0000644000176200001440000001616014245753567014545 0ustar liggesusers\name{formatMpfr} \title{Formatting MPFR (multiprecision) Numbers} \alias{formatMpfr} \alias{formatN.mpfr} \alias{.mpfr2str} \description{ Flexible formatting of \dQuote{multiprecision numbers}, i.e., objects of class \code{\linkS4class{mpfr}}. \code{formatMpfr()} is also the \code{mpfr} method of the generic \code{\link{format}} function. The \code{formatN()} methods for \code{\linkS4class{mpfr}} numbers renders them differently than their double precision equivalents, by appending \code{"_M"}. Function \code{.mpfr2str()} is the low level work horse for \code{formatMpfr()} and hence all \code{\link{print}()}ing of \code{"\linkS4class{mpfr}"} objects. } \usage{ formatMpfr(x, digits = NULL, trim = FALSE, scientific = NA, maybe.full = (!is.null(digits) && is.na(scientific)) || isFALSE(scientific), base = 10, showNeg0 = TRUE, max.digits = Inf, big.mark = "", big.interval = 3L, small.mark = "", small.interval = 5L, decimal.mark = ".", exponent.char = if(base <= 14) "e" else if(base <= 36) "E" else "|e", exponent.plus = TRUE, zero.print = NULL, drop0trailing = FALSE, ...) \S3method{formatN}{mpfr}(x, drop0trailing = TRUE, \dots) .mpfr2str(x, digits = NULL, maybe.full = !is.null(digits), base = 10L) } \arguments{ \item{x}{an MPFR number (vector or array).} \item{digits}{how many significant digits (in the \code{base} chosen!) are to be used in the result. The default, \code{NULL}, uses enough digits to represent the full precision, often one or two digits more than \dQuote{you} would expect. For \code{base}s 2,4,8,16, or 32, MPFR requires \code{digits} at least 2. For such bases, \code{digits = 1} is changed into \code{2}, with a message.} \item{trim}{logical; if \code{FALSE}, numbers are right-justified to a common width: if \code{TRUE} the leading blanks for justification are suppressed.} \item{scientific}{either a logical specifying whether MPFR numbers should be encoded in scientific format (\dQuote{exponential representation}), or an integer penalty (see \code{\link{options}("scipen")}). Missing values correspond to the current default penalty.} \item{maybe.full}{\code{\link{logical}}, passed to \code{\link{.mpfr2str}()}.} \item{base}{an integer in \eqn{2,3,..,62}; the base (\dQuote{basis}) in which the numbers should be represented. Apart from the default base 10, binary (\code{base = 2}) or hexadecimal (\code{base = 16}) are particularly interesting.} \item{showNeg0}{logical indicating if \dQuote{\bold{neg}ative} zeros should be shown with a \code{"-"}. The default, \code{TRUE} is intentially different from \code{\link{format}()}.} \item{exponent.char}{the \dQuote{exponent} character to be used in scientific notation. The default takes into account that for \code{base} \eqn{B \ge 15}{B >= 15}, \code{"e"} is part of the (mantissa) digits and the same is true for \code{"E"} when \eqn{B \ge 37}{B >= 37}.} \item{exponent.plus}{\code{\link{logical}} indicating if \code{"+"} should be for positive exponents in exponential (aka \dQuote{scientific}) representation. This used to be hardcoded to \code{FALSE}; the new default is compatible to \R's \code{\link{format}()}ing of numbers and helps to note visually when exponents are in use.} \item{max.digits}{a (large) positive number to limit the number of (mantissa) digits, notably when \code{digits} is \code{NULL} (as by default). Otherwise, a numeric \code{digits} is \emph{preferred} to setting \code{max.digits} (which should not be smaller than \code{digits}).} \item{big.mark, big.interval, small.mark, small.interval, decimal.mark, zero.print, drop0trailing}{% used for prettying decimal sequences, these are passed to \code{\link{prettyNum}} and that help page explains the details.} \item{\dots}{further arguments passed to or from other methods.} } \value{ a character vector or array, say \code{cx}, of the same length as \code{x}. Since Rmpfr version 0.5-3 (2013-09), if \code{x} is an \code{\linkS4class{mpfrArray}}, then \code{cx} is a character \code{\link{array}} with the same \code{\link{dim}} and \code{\link{dimnames}} as \code{x}. Note that in scientific notation, the integer exponent is always in \emph{decimal}, i.e., base 10 (even when \code{base} is not 10), but of course meaning \code{base} powers, e.g., in base 32, \code{"u.giE3"}is the same as \code{"ugi0"} which is \eqn{32^3} times \code{"u.gi"}. This is in contrast, e.g., with \code{\link{sprintf}("\%a", x)} where the powers after \code{"p"} are powers of \eqn{2}. } \note{ Currently, \code{formatMpfr(x, scientific = FALSE)} does \emph{not work correctly}, e.g., for \code{x <- Const("pi", 128) * 2^c(-200,200)}, i.e., it uses the scientific / exponential-style format. This is considered bogous and hopefully will change. } \references{ The MPFR manual's description of \samp{mpfr_get_str()} which is the C-internal workhorse for \code{.mpfr2str()} (on which \code{formatMpfr()} builds).% as we say in description{..} already } \author{Martin Maechler} \seealso{ \code{\link{mpfr}} for creation and the \code{\linkS4class{mpfr}} class description with its many methods. The \code{\link{format}} generic, and the \code{\link{prettyNum}} utility on which \code{formatMpfr} is based as well. The S3 generic function \code{\link[gmp]{formatN}} from package \pkg{gmp}. \code{\link{.mpfr_formatinfo}(x)} provides the (cheap) non-string parts of \code{.mpfr2str(x)}; the (base 2) \code{exp} exponents are also available via \code{\link{.mpfr2exp}(x)}. } \examples{ ## Printing of MPFR numbers uses formatMpfr() internally. ## Note how each components uses the "necessary" number of digits: ( x3 <- c(Const("pi", 168), mpfr(pi, 140), 3.14) ) format(x3[3], 15) format(x3[3], 15, drop0 = TRUE)# "3.14" .. dropping the trailing zeros x3[4] <- 2^30 x3[4] # automatically drops trailing zeros format(x3[1], dig = 41, small.mark = "'") # (41 - 1 = ) 40 digits after "." rbind(formatN( x3, digits = 15), formatN(as.numeric(x3), digits = 15)) (Zero <- mpfr(c(0,1/-Inf), 20)) # 0 and "-0" xx <- c(Zero, 1:2, Const("pi", 120), -100*pi, -.00987) format(xx, digits = 2) format(xx, digits = 1, showNeg0 = FALSE)# "-0" no longer shown ## Output in other bases : formatMpfr(mpfr(10^6, 40), base=32, drop0trailing=TRUE) ## "ugi0" mpfr("ugi0", base=32) #-> 1'000'000 \dontshow{ stopifnot( identical("ugi0", formatMpfr(mpfr(10^6, 40), base=32, drop0trailing=TRUE)), mpfr("ugi0", base=32) == 10^6) } ## This now works: The large number shows "as" large integer: x <- Const("pi", 128) * 2^c(-200,200) formatMpfr(x, scientific = FALSE) # was 1.955...e-60 5.048...e+60 i32 <- mpfr(1:32, precBits = 64) format(i32, base= 2, drop0trailing=TRUE) format(i32, base= 16, drop0trailing=TRUE) format(1/i32, base= 2, drop0trailing=TRUE)# using scientific notation for [17..32] format(1/i32, base= 32) format(1/i32, base= 62, drop0trailing=TRUE) format(mpfr(2, 64)^-(1:16), base=16, drop0trailing=TRUE) } \keyword{character} \keyword{print} Rmpfr/man/bind-methods.Rd0000644000176200001440000000341012772467643014777 0ustar liggesusers\name{bind-methods} \title{"mpfr" '...' - Methods for Functions cbind(), rbind()} \docType{methods} \alias{cbind} \alias{rbind} \alias{cbind-methods} \alias{rbind-methods} \alias{cbind,ANY-method} \alias{cbind,Mnumber-method} \alias{rbind,ANY-method} \alias{rbind,Mnumber-method} \description{ \code{\link{cbind}} and \code{\link{rbind}} methods for signature \code{...} (see \code{\link[methods]{dotsMethods}} are provided for class \code{\linkS4class{Mnumber}}, i.e., for binding numeric vectors and class \code{"\linkS4class{mpfr}"} vectors and matrices (\code{"\linkS4class{mpfrMatrix}"}) together. } \usage{ cbind(\dots, deparse.level = 1) rbind(\dots, deparse.level = 1) } \arguments{ \item{\dots}{matrix-/vector-like \R objects to be bound together, see the \pkg{base} documentation, \code{\link[base:cbind]{cbind}}. } \item{deparse.level}{integer determining under which circumstances column and row names are built from the actual arguments' \sQuote{expression}, see \code{\link{cbind}}.} } \section{Methods}{ \describe{ \item{... = "Mnumber"}{is used to (c|r)bind multiprecision \dQuote{numbers} (inheriting from class \code{"\linkS4class{mpfr}"}) together, maybe combined with simple numeric vectors.} \item{... = "ANY"}{reverts to \code{\link[base]{cbind}} and \code{rbind} from package \pkg{base}.} } } \value{ typically a \sQuote{matrix-like} object, here typically of \code{\link{class} "\linkS4class{mpfrMatrix}"}. } % \references{ ~put references to the literature/web site here ~ } \author{Martin Maechler} \seealso{\code{\link{cbind2}}, \code{\link{cbind}}, Documentation in base \R's \pkg{methods} package% R <= 3.3.1 \code{\link[methods]{Methods}} } \examples{ cbind(1, mpfr(6:3, 70)/7, 3:0) } \keyword{methods} Rmpfr/man/array_or_vector-class.Rd0000644000176200001440000000172714245753567016736 0ustar liggesusers\name{array_or_vector-class} \docType{class} \alias{array_or_vector-class} \title{Auxiliary Class "array_or_vector"} \description{ \code{"array_or_vector"} is the class union of \code{c("array", "matrix", "vector")} and exists for its use in signatures of method definitions. } \section{Objects from the Class}{A virtual Class: No objects may be created from it. } % \section{Methods}{ % \describe{ % \item{...}{.....} % } % } \details{ Using \code{"array_or_vector"} instead of just \code{"vector"} in a signature makes an important difference: E.g., if we had \code{setMethod(crossprod, c(x="mpfr", y="vector"), function(x,y) CPR(x,y))}, a call \code{crossprod(x, matrix(1:6, 2,3))} would extend into a call of \code{CPR(x, as(y, "vector"))} such that \code{CPR()}'s second argument would simply be a vector instead of the desired \eqn{2\times3}{2 x 3} matrix. } %\author{Martin Maechler} \examples{ showClass("array_or_vector") } \keyword{classes} Rmpfr/man/Bessel_mpfr.Rd0000644000176200001440000000463214134764740014662 0ustar liggesusers\name{Bessel_mpfr} \title{Bessel functions of Integer Order in multiple precisions} \alias{Bessel_mpfr} \alias{Ai} \alias{j0} \alias{j1} \alias{jn} \alias{y0} \alias{y1} \alias{yn} \description{ Bessel functions of integer orders, provided via arbitrary precision algorithms from the MPFR library. Note that the computation can be very slow when \code{n} \emph{and} \code{x} are large (and of similar magnitude). % e.g. on nb-mm3, jn(4e4, 4e4) takes 14 sec [1.1. 2015] } \usage{ Ai(x) j0(x) j1(x) jn(n, x, rnd.mode = c("N","D","U","Z","A")) y0(x) y1(x) yn(n, x, rnd.mode = c("N","D","U","Z","A")) } \arguments{ \item{x}{a \code{\link{numeric}} or \code{\linkS4class{mpfr}} vector.} \item{n}{non-negative integer (vector).} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see \code{\link{mpfr}}.} } \value{ Computes multiple precision versions of the Bessel functions of \emph{integer} order, \eqn{J_n(x)}{J[n](x)} and \eqn{Y_n(x)}{Y[n](x)}, and---when using MPFR library 3.0.0 or newer---also of the Airy function \eqn{Ai(x)}. Note that currently \code{Ai(x)} is very slow to compute for large \code{x}. } \seealso{\code{\link{besselJ}}, and \code{\link{besselY}} compute the same bessel functions but for arbitrary \emph{real} order and only precision of a bit more than ten digits. %% Connection Formulas https://dlmf.nist.gov/10.27 [ J,Y <--> I,K ] but %% via *complex* args } \examples{ x <- (0:100)/8 # (have exact binary representation) stopifnot(exprs = { all.equal(besselY(x, 0), bY0 <- y0(x)) all.equal(besselJ(x, 1), bJ1 <- j1(x)) all.equal(yn(0,x), bY0) all.equal(jn(1,x), bJ1) }) mpfrVersion() # now typically 4.1.0 if(mpfrVersion() >= "3.0.0") { ## Ai() not available previously print( aix <- Ai(x) ) plot(x, aix, log="y", type="l", col=2) stopifnot( all.equal(Ai (0) , 1/(3^(2/3) * gamma(2/3))) , # see https://dlmf.nist.gov/9.2.ii all.equal(Ai(100), mpfr("2.6344821520881844895505525695264981561e-291"), tol=1e-37) ) two3rd <- 2/mpfr(3, 144) print( all.equal(Ai(0), 1/(3^two3rd * gamma(two3rd)), tol=0) ) # 1.7....e-40 if(Rmpfr:::doExtras()) withAutoprint({ # slowish: system.time(ai1k <- Ai(1000)) # 1.4 sec (on 2017 lynne) stopifnot(all.equal(print(log10(ai1k)), -9157.031193409585185582, tol=2e-16)) # seen 8.8..e-17 | 1.1..e-16 }) } # ver >= 3.0 } \keyword{math} Rmpfr/man/log1mexp.Rd0000644000176200001440000001025113751607232014143 0ustar liggesusers\name{log1mexp}% originally ~/R/Pkgs/copula/man/log1mexp.Rd __keep in sync !!__ \alias{log1pexp} \alias{log1mexp} \title{Compute f(a) = \eqn{\mathrm{log}}{log}(1 +/- \eqn{\mathrm{exp}}{exp}(-a)) Numerically Optimally} \description{ Compute f(a) = log(1 - exp(-a)), respectively g(x) = log(1 + exp(x)) quickly numerically accurately. } \usage{ log1mexp(a, cutoff = log(2)) log1pexp(x, c0 = -37, c1 = 18, c2 = 33.3) } \arguments{ \item{a}{numeric (or \code{\link{mpfr}}) vector of positive values.} \item{x}{numeric vector, may also be an \code{"\link{mpfr}"} object.} \item{cutoff}{positive number; \code{log(2)} is \dQuote{optimal}, %% see below, TODO but the exact value is unimportant, and anything in \eqn{[0.5, 1]} is fine.} \item{c0, c1, c2}{cutoffs for \code{log1pexp}; see below.} } \value{ \deqn{log1mexp(a) := f(a) = \log(1 - \exp(-a)) = \mathrm{log1p}(-\exp(-a)) = \log(-\mathrm{expm1}(-a))}{% log1mexp(a) := f(a) = log(1 - exp(-a)) = log1p(- exp(-a)) = log(- expm1(-a))} or, respectively, \deqn{log1pexp(x) := g(x) = \log(1 + \exp(x)) = \mathrm{log1p}(\exp(x))}{% log1pexp(x) := g(x) = log(1 + exp(x)) = log1p(exp(x))} computed accurately and quickly. } \author{Martin Maechler, May 2002; \code{log1pexp()} in 2012} \references{% ~/R/Pkgs/Rmpfr/vignettes/log1mexp-note.Rnw Martin \enc{Mächler}{Maechler} (2012). Accurately Computing \eqn{\log(1-\exp(-|a|))}; \url{https://CRAN.R-project.org/package=Rmpfr/vignettes/log1mexp-note.pdf}. % see also <> in ~/R/Pkgs/copula/inst/doc/Frank-Rmpfr.Rnw } \examples{ fExpr <- expression( DEF = log(1 - exp(-a)), expm1 = log(-expm1(-a)), log1p = log1p(-exp(-a)), F = log1mexp(a)) a. <- 2^seq(-58, 10, length = 256) a <- a. ; str(fa <- do.call(cbind, as.list(fExpr))) head(fa)# expm1() works here tail(fa)# log1p() works here ## graphically: lwd <- 1.5*(5:2); col <- adjustcolor(1:4, 0.4) op <- par(mfcol=c(1,2), mgp = c(1.25, .6, 0), mar = .1+c(3,2,1,1)) matplot(a, fa, type = "l", log = "x", col=col, lwd=lwd) legend("topleft", fExpr, col=col, lwd=lwd, lty=1:4, bty="n") # expm1() & log1mexp() work here matplot(a, -fa, type = "l", log = "xy", col=col, lwd=lwd) legend("left", paste("-",fExpr), col=col, lwd=lwd, lty=1:4, bty="n") # log1p() & log1mexp() work here par(op) aM <- 2^seqMpfr(-58, 10, length=length(a.)) # => default prec = 128 a <- aM; dim(faM <- do.call(cbind, as.list(fExpr))) # 256 x 4, "same" as 'fa' ## Here, for small 'a' log1p() and even 'DEF' is still good enough l_f <- asNumeric(log(-faM)) all.equal(l_f[,"F"], l_f[,"log1p"], tol=0) # see TRUE (Lnx 64-bit) io <- a. < 80 # for these, the differences are small all.equal(l_f[io,"F"], l_f[io,"expm1"], tol=0) # see 6.662e-9 all.equal(l_f[io,"F"], l_f[io, "DEF" ], tol=0) stopifnot(exprs = { all.equal(l_f[,"F"], l_f[,"log1p"], tol= 1e-15) all.equal(l_f[io,"F"], l_f[io,"expm1"], tol= 1e-7) all.equal(l_f[io,"F"], l_f[io, "DEF" ], tol= 1e-7) }) ## For 128-bit prec, if we go down to 2^-130, "log1p" is no longer ok: aM2 <- 2^seqMpfr(-130, 10, by = 1/2) a <- aM2; fa2 <- do.call(cbind, as.list(fExpr)) head(asNumeric(fa2), 12) tail(asNumeric(fa2), 12) matplot(a, log(-fa2[,1:3]) -log(-fa2[,"F"]), type="l", log="x", lty=1:3, lwd=2*(3:1)-1, col=adjustcolor(2:4, 1/3)) legend("top", colnames(fa2)[1:3], lty=1:3, lwd=2*(3:1)-1, col=adjustcolor(2:4, 1/3)) cols <- adjustcolor(2:4, 1/3); lwd <- 2*(3:1)-1 matplot(a, 1e-40+abs(log(-fa2[,1:3]) -log(-fa2[,"F"])), type="o", log="xy", main = "log1mexp(a) -- approximation rel.errors, mpfr(*, prec=128)", pch=21:23, cex=.6, bg=5:7, lty=1:2, lwd=lwd, col=cols) legend("top", colnames(fa2)[1:3], bty="n", lty=1:2, lwd=lwd, col=cols, pch=21:23, pt.cex=.6, pt.bg=5:7) ## -------------------------- log1pexp() [simpler] -------------------- curve(log1pexp, -10, 10, asp=1) abline(0,1, h=0,v=0, lty=3, col="gray") ## Cutoff c1 for log1pexp() -- not often "needed": curve(log1p(exp(x)) - log1pexp(x), 16, 20, n=2049) ## need for *some* cutoff: x <- seq(700, 720, by=2) cbind(x, log1p(exp(x)), log1pexp(x)) ## Cutoff c2 for log1pexp(): curve((x+exp(-x)) - x, 20, 40, n=1025) curve((x+exp(-x)) - x, 33.1, 33.5, n=1025) } \keyword{math} Rmpfr/man/Rmpfr-package.Rd0000644000176200001440000001033714460520411015062 0ustar liggesusers\name{Rmpfr-package} \alias{Rmpfr-package} \alias{Rmpfr} \docType{package} \title{R MPFR - Multiple Precision Floating-Point Reliable} \description{ Rmpfr provides S4 classes and methods for arithmetic including transcendental ("special") functions for arbitrary precision floating point numbers, here often called \dQuote{mpfr - numbers}. To this end, it interfaces to the LGPL'ed MPFR (Multiple Precision Floating-Point Reliable) Library which itself is based on the GMP (GNU Multiple Precision) Library. } \details{ % The DESCRIPTION file: \packageDESCRIPTION{Rmpfr} \packageIndices{Rmpfr} The following (help pages) index does not really mention that we provide \emph{many} methods for mathematical functions, including \code{\link{gamma}}, \code{\link{digamma}}, etc, namely, all of \R's (S4) \code{Math} group (with the only exception of \code{\link{trigamma}}), see the list in the examples. Additionally also \code{\link{pnorm}}, the \dQuote{error function}, and more, see the list in \code{\link{zeta}}, and further note the first vignette (below). %% MM: could try more systematically \bold{\emph{Partial} index}: \tabular{ll}{ \code{\link{mpfr}} \tab Create "mpfr" Numbers (Objects) \cr \code{\link{mpfrArray}} \tab Construct "mpfrArray" almost as by \code{\link{array}()} \cr \code{\link{mpfr-class}} \tab Class "mpfr" of Multiple Precision Floating Point Numbers \cr \code{\link{mpfrMatrix-class}} \tab Classes "mpfrMatrix" and "mpfrArray" \cr \tab \cr \code{\link{Bernoulli}} \tab Bernoulli Numbers in Arbitrary Precision \cr \code{\link{Bessel_mpfr}} \tab Bessel functions of Integer Order in multiple precisions \cr \code{\link{c.mpfr}} \tab MPFR Number Utilities \cr \code{\link{cbind}} \tab "mpfr" \code{...} - Methods for Functions cbind(), rbind() \cr \code{\link{chooseMpfr}} \tab Binomial Coefficients and Pochhammer Symbol aka \cr \tab Rising Factorial \cr \code{\link{factorialMpfr}} \tab Factorial 'n!' in Arbitrary Precision \cr \code{\link{formatMpfr}} \tab Formatting MPFR (multiprecision) Numbers \cr \code{\link{getPrec}} \tab Rmpfr - Utilities for Precision Setting, Printing, etc \cr \code{\link{roundMpfr}} \tab Rounding to Binary bits, "mpfr-internally" \cr \code{\link{seqMpfr}} \tab "mpfr" Sequence Generation \cr \code{\link{sumBinomMpfr}} \tab (Alternating) Binomial Sums via Rmpfr \cr \code{\link{zeta}} \tab Special Mathematical Functions (MPFR) \cr \tab \cr \code{\link{integrateR}} \tab One-Dimensional Numerical Integration - in pure R \cr \code{\link{unirootR}} \tab One Dimensional Root (Zero) Finding - in pure R \cr \code{\link{optimizeR}} \tab High Precisione One-Dimensional Optimization \cr \code{\link{hjkMpfr}} \tab Hooke-Jeeves Derivative-Free Minimization R (working for MPFR) \cr } Further information is available in the following vignettes: \tabular{ll}{ \code{Rmpfr-pkg} \tab Arbitrarily Accurate Computation with R: The 'Rmpfr' package (source, pdf)\cr \code{log1mexp-note} \tab Acccurately Computing log(1 - exp(.)) -- Assessed by Rmpfr (source, pdf)\cr } }%- end{details} \author{Martin Maechler} \references{ MPFR (MP Floating-Point Reliable Library), \url{https://www.mpfr.org/}% or http://mpfr.org/ (unfortunately the % http*s* needs the "www") GMP (GNU Multiple Precision library), \url{https://gmplib.org/} and see the vignettes mentioned above. } \seealso{ The \R package \CRANpkg{gmp} for big integer \pkg{\link[gmp:biginteger]{gmp}} and rational numbers (\code{\link[gmp]{bigrational}}) on which \pkg{Rmpfr} depends. } \examples{ ## Using "mpfr" numbers instead of regular numbers... n1.25 <- mpfr(5, precBits = 256)/4 n1.25 ## and then "everything" just works with the desired chosen precision:hig n1.25 ^ c(1:7, 20, 30) ## fully precise; compare with print(1.25 ^ 30, digits=19) exp(n1.25) ## Show all math functions which work with "MPFR" numbers (1 exception: trigamma) getGroupMembers("Math") ## We provide *many* arithmetic, special function, and other methods: showMethods(classes = "mpfr") showMethods(classes = "mpfrArray") } \keyword{package} Rmpfr/man/mpfrMatrix-utils.Rd0000644000176200001440000000415612330435565015705 0ustar liggesusers\name{mpfrMatrix-utils} %\alias{det}% "the function" (our copy of base::det) \alias{determinant.mpfrMatrix} % \title{Functions for mpfrMatrix Objects} \description{ \code{determinant(x, ..)} computes the determinant of the mpfr square matrix \code{x}. May work via coercion to \code{"numeric"}, i.e., compute \code{determinant(\link{asNumeric}(x), logarithm)}, if \code{asNumeric} is true, by default, if the dimension is larger than three. Otherwise, use precision \code{precBits} for the \dQuote{accumulator} of the result, and use the recursive mathematical definition of the determinant (with computational complexity \eqn{n!}, where \eqn{n} is the matrix dimension, i.e., \bold{very} inefficient for all but small matrices!) } \usage{ \S3method{determinant}{mpfrMatrix}(x, logarithm = TRUE, asNumeric = (d[1] > 3), precBits = max(.getPrec(x)), \dots) } \arguments{ \item{x}{an \code{\linkS4class{mpfrMatrix}} object of \emph{square} dimension.} \item{logarithm}{logical indicating if the \code{\link{log}} of the absolute determinant should be returned. } \item{asNumeric}{logical .. .. if rather \code{determinant(\link{asNumeric}(x), ...)} should be computed. } \item{precBits}{the number of binary digits for the result (and the intermediate accumulations).} \item{\dots}{unused (potentially further arguments passed to methods).} } \value{ as \code{\link{determinant}()}, an object of S3 class \code{"det"}, a \code{\link{list}} with components \item{modulus}{the (logarithm of) the absolute value (\code{\link{abs}}) of the determinant of \code{x}.} \item{sign}{the sign of the determinant.} } %% \details{ %% } %% \references{ %% } \seealso{ \code{\link{determinant}} in base \R, which relies on a fast LU decomposition. \code{\linkS4class{mpfrMatrix}} } \author{Martin Maechler} \examples{ m6 <- mpfrArray(1:6, prec=128, dim = c(2L, 3L)) m6 S2 <- m6[,-3] # 2 x 2 S3 <- rbind(m6, c(1:2,10)) det(S2) str(determinant(S2)) det(S3) stopifnot(all.equal(det(S2), det(asNumeric(S2)), tolerance=1e-15), all.equal(det(S3), det(asNumeric(S3)), tolerance=1e-15)) } \keyword{array} Rmpfr/man/formatHex.Rd0000644000176200001440000001634313220705115014342 0ustar liggesusers\name{formatHex} \title{Flexibly Format Numbers in Binary, Hex and Decimal Format} \alias{formatHex} \alias{formatBin} \alias{formatDec} %% \alias{formatHexInternal} \alias{print.Ncharacter}% not mentioned \description{ Show numbers in binary, hex and decimal format. The resulting character-like objects can be back-transformed to \code{"mpfr"} numbers via \code{\link{mpfr}()}. } \usage{ formatHex(x, precBits = min(getPrec(x)), style = "+", expAlign = TRUE) formatBin(x, precBits = min(getPrec(x)), scientific = TRUE, left.pad = "_", right.pad = left.pad, style = "+", expAlign = TRUE) %% FIXME: Currently needed mainly because decimal point alignment. %% ----- TODO: Allow formatMpfr(.) to do decimal alignment -- even by default formatDec(x, precBits = min(getPrec(x)), digits = decdigits, nsmall = NULL, scientific = FALSE, style = "+", decimalPointAlign = TRUE, \dots) %% ## not exported: %% formatHexInternal(x, precBits = min(Rmpfr::getPrec(x)), style = "+", expAlign=TRUE) %% formatAlign(x, leftpad=" ", rightpad=leftpad, \dots) %% sprintfMpfr(x, bits, style = "+", expAlign=TRUE) } \arguments{ \item{x}{a \code{numeric} or \code{\link{mpfr}} \R object.} \item{precBits}{integer, the number of bits of precision, typically derived from \code{x}, see \code{\link{getPrec}}. Numeric, i.e., double precision numbers have 53 bits. For more detail, see \code{\link[Rmpfr]{mpfr}}.} \item{style}{a single character, to be used in \code{\link{sprintf}}'s format (\code{fmt}), immediately after the "%". The default always sets a sign in the output, i.e., \code{"+"} or \code{"-"}, where as \code{style = " "} may seem more standard.} \item{expAlign}{\code{\link{logical}} indicating if for scientific (\dQuote{exponential}) representations the exponents should be aligned to the same width, i.e., zero-padded to the same number of digits.} \item{scientific}{\code{\link{logical}} indicating that \code{formatBin} should display the binary representation in scientific notation (\code{mpfr(3, 5)} is displayed as \code{+0b1.1000p+1}). When \code{FALSE}, \code{formatBin} will display the binary representation in regular format shifted to align binary points (\code{mpfr(3, 5)} is displayed \code{+0b11.000}).} \item{\dots}{additional optional arguments. %% \code{formatHexInternal}, \code{formatHex}, \code{formatBin}: \code{precBits} is the only \code{\dots} argument acted on. Other \code{\dots} arguments are ignored. \code{formatDec}: \code{precBits} is acted on. Any argument accepted by \code{\link[base]{format}} (except \code{nsmall}) is acted on. Other \code{\dots} arguments are ignored. } \item{left.pad, right.pad}{characters (one-character strings) that will be used for left- and right-padding of the formatted string when \code{scientific=FALSE}. \emph{Do not change these unless for display-only purpose !!}} \item{nsmall}{only used when \code{scientific} is false, then passed to \code{\link{format}()}. If \code{NULL}, the default is computed from the range of the non-zero values of \code{x}.} \item{digits}{integer; the number of decimal digits displayed is the larger of this argument and the internally generated value that is a function of \code{precBits}. This is related to but different than \code{digits} in \code{\link{format}}.} \item{decimalPointAlign}{logical indicating if padding should be used to ensure that the resulting strings align on the decimal point (\code{"."}).} } \details{ For the hexadecimal representation, when the precision is not larger than double precision, \code{\link[base]{sprintf}()} is used directly, otherwise \code{\link{formatMpfr}()} is used and post processed. For the binary representation, the hexadecimal value is calculated and then edited by substitution of the binary representation of the hex characters coded in the \code{HextoBin} vector. For binary with \code{scientific=FALSE}, the result of the \code{scientific=TRUE} version is edited to align binary points. For the decimal representation, the hexadecimal value is calculated with the specified precision and then sent to the \code{format} function for \code{scientific=FALSE} or to the sprintf function for \code{scientific=TRUE}. } \value{ a character vector (or matrix) like \code{x}, say \code{r}, containing the formatted represention of \code{x}, with a \code{\link{class}} (unless \code{left.pad} or \code{right.pad} were not \code{"_"}). In that case, \code{formatHex()} and \code{formatBin()} return class \code{"Ncharacter"}; for that, \code{\link{mpfr}(.)} has a method and will basically return \code{x}, i.e., work as \emph{inverse} function. Since \pkg{Rmpfr} version \command{0.6-2}, the S3 class \code{"Ncharacter"} extends \code{"character"}. (\code{class(.)} is now of length two and \code{class(.)[2]} is \code{"character"}.). There are simple \code{[} and \code{\link{print}} methods; modifying or setting \code{dim} works as well. } \references{ R FAQ 7.31: Why doesn't R think these numbers are equal? \code{system.file("../../doc/FAQ")} } \author{Richard M. Heiberger \email{rmh@temple.edu}, with minor tweaking by Martin M.} \seealso{ \code{\link[Rmpfr]{mpfr}}, \code{\link[base]{sprintf}} } \examples{ FourBits <- mpfr(matrix(0:31, 8, 4, dimnames = list(0:7, c(0,8,16,24))), precBits=4) ## 4 significant bits FourBits formatHex(FourBits) formatBin(FourBits, style = " ") formatBin(FourBits, scientific=FALSE) formatDec(FourBits) ## as "Ncharacter" 'inherits from' "character", this now works too : data.frame(Dec = c( formatDec(FourBits) ), formatHex(FourBits), Bin = formatBin(FourBits, style = " ")) FBB <- formatBin(FourBits) ; clB <- class(FBB) (nFBB <- mpfr(FBB)) stopifnot(class(FBB)[1] == "Ncharacter", all.equal(nFBB, FourBits, tol=0)) FBH <- formatHex(FourBits) ; clH <- class(FBH) (nFBH <- mpfr(FBH)) stopifnot(class(FBH)[1] == "Ncharacter", all.equal(nFBH, FourBits, tol=0)) ## Compare the different "formattings" (details will change, i.e. improve!)%% FIXME M <- mpfr(c(-Inf, -1.25, 1/(-Inf), NA, 0, .5, 1:2, Inf), 3) data.frame(fH = formatHex(M), f16 = format(M, base=16), fB = formatBin(M), f2 = format(M, base= 2), fD = formatDec(M), f10 = format(M), # base = 10 is default fSci= format(M, scientific=TRUE), fFix= format(M, scientific=FALSE)) ## Other methods ("[", t()) also work : stopifnot(dim(F1 <- FBB[, 1, drop=FALSE]) == c(8,1), identical(class( F1), clB), dim(t(F1)) == c(1,8), identical(class(t(F1)),clB), is.null(dim(F.2 <- FBB[,2])), identical(class( F.2), clB), dim(F22 <- FBH[1:2, 3:4]) == c(2,2), identical(class(F22), clH), identical(class(FBH[2,3]), clH), is.null(dim(FBH[2,3])), identical(FBH[2,3:4], F22[2,]), identical(FBH[2,3], unname(FBH[,3][2])), TRUE) TenFrac <- matrix((1:10)/10, dimnames=list(1:10, expression(1/x))) TenFrac9 <- mpfr(TenFrac, precBits=9) ## 9 significant bits TenFrac9 formatHex(TenFrac9) formatBin(TenFrac9) formatBin(TenFrac9, scientific=FALSE) formatDec(TenFrac9) formatDec(TenFrac9, precBits=10) } \keyword{ arith } Rmpfr/man/sapplyMpfr.Rd0000644000176200001440000000765014360044651014552 0ustar liggesusers\name{sapplyMpfr} \alias{sapplyMpfr} \title{Apply a Function over a "mpfr" Vector} \description{ Users may be disappointed to note that \code{\link{sapply}()} or \code{\link{vapply}()} typically do not work with \code{"mpfr"} numbers. This is a simple (but strong) approach to work around the problem, based on \code{\link{lapply}()}. } \usage{ sapplyMpfr(X, FUN, \dots, drop_1_ = TRUE) } \arguments{ \item{X}{a vector, possibly of class \code{"\linkS4class{mpfr}"}.} \item{FUN}{a \code{\link{function}} returning an \code{"\linkS4class{mpfr}"} vector or even an \code{"\linkS4class{mpfrArray}"}. May also be a function returning a \code{\link{numeric}} vector or array for numeric \code{X}, \emph{and} which returns \code{"mpfr(Array)"} for an \code{X} argument inheriting from \code{"\linkS4class{mpfr}"}.} \item{\dots}{further arguments passed to \code{\link{lapply}}, typically further arguments to \code{FUN}.} \item{drop_1_}{logical (with unusual name on purpose!) indicating if 1-column matrices (\code{"mpfrMatrix"}) should be \dQuote{dropped} to vectors (\code{"mpfr"}), the same as in base \R's own \code{\link{sapply}}. This has been implicitly \code{FALSE} in \pkg{Rmpfr} versions 0.8-5 to 0.8-9 (Oct 2021 to June 2022), accidentally. Since \pkg{Rmpfr} 0.9-0, this has been made an argument with default \code{TRUE} to be compatible by default with \R's \code{\link{sapply}}. } } \details{ In the case \code{FUN()} returns an \code{\link{array}} or \code{"mpfrArray"}, i.e., with two or more dimensions, \code{sapplyMpfr()} returns an \code{"mpfrArray"}; this is analogous to \code{\link{sapply}(X, FUN, simplify = "array")} (rather than the default \code{sapply()} behaviour which returns a \code{matrix} also when a higher array would be more \dQuote{logical}.) } \value{ an \code{"\linkS4class{mpfr}"} vector, typically of the same length as \code{X}. } \author{Martin Maechler} \note{ This may still not always work as well as \code{\link{sapply}()} does for atomic vectors. The examples seem to indicate that it typically does work as desired, since \pkg{Rmpfr} version 0.9-0. If you want to transform back to regular numbers anyway, it maybe simpler and more efficient to use \preformatted{ res <- lapply(....) sapply(res, asNumeric, simplify = "array") } instead of \code{sapplyMpfr()}. } \seealso{ \code{\link{sapply}}, \code{\link{lapply}}, etc. } \examples{ sapplyMpfr0 <- ## Originally, the function was simply defined as function (X, FUN, ...) new("mpfr", unlist(lapply(X, FUN, ...), recursive = FALSE)) (m1 <- sapply ( 3, function(k) (1:3)^k)) # 3 x 1 matrix (numeric) (p1 <- sapplyMpfr(mpfr(3, 64), function(k) (1:3)^k)) stopifnot(m1 == p1, is(p1, "mpfrMatrix"), dim(p1) == c(3,1), dim(p1) == dim(m1)) k.s <- c(2, 5, 10, 20) (mk <- sapply ( k.s, function(k) (1:3)^k)) # 3 x 4 " " (pm <- sapplyMpfr(mpfr(k.s, 64), function(k) (1:3)^k)) stopifnot(mk == pm, is(pm, "mpfrMatrix"), dim(pm) == 3:4, 3:4 == dim(mk)) ## was *wrongly* 4x3 in Rmpfr 0.8-x f5k <- function(k) outer(1:5, k+0:2, `^`)# matrix-valued (mk5 <- sapply ( k.s, f5k)) # sapply()'s default; not "ideal" (ak5 <- sapply ( k.s, f5k, simplify = "array")) # what we want (pm5 <- sapplyMpfr(mpfr(k.s, 64), f5k)) stopifnot(c(mk5) == c(ak5), ak5 == pm5, is(pm5, "mpfrArray"), is.array(ak5), dim(pm5) == dim(ak5), dim(pm5) == c(5,3, 4)) if(require("Bessel")) { # here X, is simple bI1 <- function(k) besselI.nuAsym(mpfr(1.31e9, 128), 10, expon.scaled=TRUE, k.max=k) bImp1 <- sapplyMpfr (0:4, bI1, drop_1_ = FALSE) # 1x5 mpfrMatrix -- as in DPQ 0.8-8 bImp <- sapplyMpfr (0:4, bI1, drop_1_ = TRUE ) # 5 "mpfr" vector {by default} bImp0 <- sapplyMpfr0(0:4, bI1) # 5-vector stopifnot(identical(bImp, bImp0), bImp == bImp1, is(bImp, "mpfr"), is(bImp1, "mpfrMatrix"), dim(bImp1) == c(1, 5)) }# {Bessel} } \keyword{manip} Rmpfr/man/optimizeR.Rd0000644000176200001440000001337613752457464014417 0ustar liggesusers\name{optimizeR} \alias{optimizeR} \title{High Precision One-Dimensional Optimization} %% Compare with ~/R/D/r-devel/R/src/library/stats/man/optimize.Rd \description{ \code{optimizeR} searches the interval from \code{lower} to \code{upper} for a minimum % TODO ? or maximum of the function \code{f} with respect to its first argument. } \usage{ optimizeR(f, lower, upper, ..., tol = 1e-20, method = c("Brent", "GoldenRatio"), maximum = FALSE, precFactor = 2.0, precBits = -log2(tol) * precFactor, maxiter = 1000, trace = FALSE) } \arguments{ \item{f}{the function to be optimized. \code{f(x)} must work \dQuote{in \pkg{Rmpfr} arithmetic} for \code{optimizer()} to make sense. The function is either minimized or maximized over its first argument depending on the value of \code{maximum}.} \item{\dots}{additional named or unnamed arguments to be passed to \code{f}.} \item{lower}{the lower end point of the interval to be searched.} \item{upper}{the upper end point of the interval to be searched.} \item{tol}{the desired accuracy, typically higher than double precision, i.e., \code{tol < 2e-16}.} \item{method}{\code{\link{character}} string specifying the optimization method.}% \item{maximum}{logical indicating if \eqn{f()} should be maximized or minimized (the default).} \item{precFactor}{only for default \code{precBits} construction: a factor to multiply with the number of bits directly needed for \code{tol}.} \item{precBits}{number of bits to be used for \code{\link[Rmpfr]{mpfr}} numbers used internally.} \item{maxiter}{maximal number of iterations to be used.} \item{trace}{integer or logical indicating if and how iterations should be monitored; if an integer \eqn{k}, print every \eqn{k}-th iteration.} } \details{ \describe{ \item{\code{"Brent"}:}{Brent(1973)'s simple and robust algorithm is a hybrid, using a combination of the golden ratio and local quadratic (\dQuote{parabolic}) interpolation. This is the same algorithm as standard \R's \code{\link{optimize}()}, adapted to high precision numbers. In smooth cases, the convergence is considerably faster than the golden section or Fibonacci ratio algorithms. } \item{\code{"GoldenRatio"}:}{The golden ratio method, aka \sQuote{golden-section search} works as follows: from a given interval containing the solution, it constructs the next point in the golden ratio between the interval boundaries. } }% end{describe} } \value{ A \code{\link{list}} with components \code{minimum} (or \code{maximum}) and \code{objective} which give the location of the minimum (or maximum) and the value of the function at that point; \code{iter} specifiying the number of iterations, the logical \code{convergence} indicating if the iterations converged and \code{estim.prec} which is an estimate or an upper bound of the final precision (in \eqn{x}). \code{method} the string of the method used. } % \references{ % } \author{ \code{"GoldenRatio"} is based on Hans Werner Borchers' \code{\link[pracma]{golden_ratio}} (package \CRANpkg{pracma}); modifications and \code{"Brent"} by Martin Maechler. } % \note{ % } \seealso{ \R's standard \code{\link{optimize}}; for multivariate optimization, \pkg{Rmpfr}'s \code{\link{hjkMpfr}()}; for root finding, \pkg{Rmpfr}'s \code{\link{unirootR}}. } \examples{ ## The minimum of the Gamma (and lgamma) function (for x > 0): Gmin <- optimizeR(gamma, .1, 3, tol = 1e-50) str(Gmin, digits = 8) ## high precision chosen for "objective"; minimum has "estim.prec" = 1.79e-50 Gmin[c("minimum","objective")] ## it is however more accurate to 59 digits: asNumeric(optimizeR(gamma, 1, 2, tol = 1e-100)$minimum - Gmin$minimum) iG5 <- function(x) -exp(-(x-5)^2/2) curve(iG5, 0, 10, 200) o.dp <- optimize (iG5, c(0, 10)) #-> 5 of course oM.gs <- optimizeR(iG5, 0, 10, method="Golden") oM.Br <- optimizeR(iG5, 0, 10, method="Brent", trace=TRUE) oM.gs$min ; oM.gs$iter oM.Br$min ; oM.Br$iter (doExtras <- Rmpfr:::doExtras()) if(doExtras) {## more accuracy {takes a few seconds} oM.gs <- optimizeR(iG5, 0, 10, method="Golden", tol = 1e-70) oM.Br <- optimizeR(iG5, 0, 10, tol = 1e-70) } rbind(Golden = c(err = as.numeric(oM.gs$min -5), iter = oM.gs$iter), Brent = c(err = as.numeric(oM.Br$min -5), iter = oM.Br$iter)) ## ==> Brent is orders of magnitude more efficient ! ## Testing on the sine curve with 40 correct digits: sol <- optimizeR(sin, 2, 6, tol = 1e-40) str(sol) sol <- optimizeR(sin, 2, 6, tol = 1e-50, precFactor = 3.0, trace = TRUE) pi.. <- 2*sol$min/3 print(pi.., digits=51) stopifnot(all.equal(pi.., Const("pi", 256), tolerance = 10*1e-50)) if(doExtras) { # considerably more expensive ## a harder one: f.sq <- function(x) sin(x-2)^4 + sqrt(pmax(0,(x-1)*(x-4)))*(x-2)^2 curve(f.sq, 0, 4.5, n=1000) msq <- optimizeR(f.sq, 0, 5, tol = 1e-50, trace=5) str(msq) # ok stopifnot(abs(msq$minimum - 2) < 1e-49) ## find the other local minimum: -- non-smooth ==> Golden ratio -section is used msq2 <- optimizeR(f.sq, 3.5, 5, tol = 1e-50, trace=10) stopifnot(abs(msq2$minimum - 4) < 1e-49) ## and a local maximum: msq3 <- optimizeR(f.sq, 3, 4, maximum=TRUE, trace=2) stopifnot(abs(msq3$maximum - 3.57) < 1e-2) }#end {doExtras} ##----- "impossible" one to get precisely ------------------------ ff <- function(x) exp(-1/(x-8)^2) curve(exp(-1/(x-8)^2), -3, 13, n=1001) (opt. <- optimizeR(function(x) exp(-1/(x-8)^2), -3, 13, trace = 5)) ## -> close to 8 {but not very close!} ff(opt.$minimum) # gives 0 if(doExtras) { ## try harder ... in vain .. str(opt1 <- optimizeR(ff, -3,13, tol = 1e-60, precFactor = 4)) print(opt1$minimum, digits=20) ## still just 7.99998038 or 8.000036655 {depending on method} } } \keyword{optimize} Rmpfr/man/atomicVector-class.Rd0000644000176200001440000000241511247771434016160 0ustar liggesusers%% almost straight copy of ../../Matrix/man/atomicVector-class.Rd \name{atomicVector-class} \docType{class} \alias{atomicVector-class} \title{Virtual Class "atomicVector" of Atomic Vectors} \description{ The \code{\link{class}} \code{"atomicVector"} is a \emph{virtual} class containing all atomic vector classes of base \R, as also implicitly defined via \code{\link{is.atomic}}. } \section{Objects from the Class}{A virtual Class: No objects may be created from it.} \section{Methods}{ In the \pkg{Matrix} package, the "atomicVector" is used in signatures where typically \dQuote{old-style} "matrix" objects can be used and can be substituted by simple vectors. } \section{Extends}{%% FIXME: promptClass() should show the direct subclasses ! The atomic classes \code{"logical"}, \code{"integer"}, \code{"double"}, \code{"numeric"}, \code{"complex"}, \code{"raw"} and \code{"character"} are extended directly. Note that \code{"numeric"} already contains \code{"integer"} and \code{"double"}, but we want all of them to be direct subclasses of \code{"atomicVector"}. } \author{Martin Maechler} \seealso{ \code{\link{is.atomic}}, \code{\link{integer}}, \code{\link{numeric}}, \code{\link{complex}}, etc. } \examples{ showClass("atomicVector") } \keyword{classes} Rmpfr/man/utils.Rd0000644000176200001440000000555412612522074013554 0ustar liggesusers\name{mpfr.utils} \title{MPFR Number Utilities} \alias{c.mpfr} \alias{diff.mpfr} \alias{mpfrIs0} \alias{.mpfr.is.whole} \alias{mpfrVersion} %% next two are deprecated since Aug.2015 (for Rmpfr 0.6.0): \alias{mpfr.is.0} \alias{mpfr.is.integer} % \description{ \code{mpfrVersion()} returns the version of the MPFR library which \pkg{Rmpfr} is currently linked to. \code{\link{c}(x,y,...)} can be used to combine MPFR numbers in the same way as regular numbers \bold{IFF} the first argument \code{x} is of class \code{\linkS4class{mpfr}}. \code{mpfrIs0(.)} uses the MPFR library in the documented way to check if (a vector of) MPFR numbers are zero. It was called \code{mpfr.is.0} which is strongly deprecated now. \code{.mpfr.is.whole(x)} uses the MPFR library in the documented way to check if (a vector of) MPFR numbers is integer \emph{valued}. This is equivalent to \code{x == round(x)}, but \emph{not} at all to \code{is.integer(as(x, "numeric"))}.\cr You should typically rather use (the \code{"mpfr"} method of the generic function) \code{\link{is.whole}(x)} instead. The former name \code{mpfr.is.integer} is deprecated now. } \usage{ mpfrVersion() mpfrIs0(x) %% .mpfr.is.whole(x) \method{c}{mpfr}(\dots) \method{diff}{mpfr}(x, lag = 1L, differences = 1L, \dots) } \arguments{ \item{x}{an object of class \code{\linkS4class{mpfr}}.} \item{\dots}{for \code{diff}, further \code{\linkS4class{mpfr}} class objects or simple numbers (\code{\link{numeric}} vectors) which are coerced to \code{mpfr} with default precision of 128 bits.} \item{lag, differences}{for \code{diff()}: exact same meaning as in \code{\link{diff}()}'s default method, \code{\link{diff.default}}.} } % \details{ % ~~ If necessary, more details than the description above ~~ % } \value{ \code{mpfrIs0} returns a logical vector of length \code{length(x)} with values \code{TRUE} iff the corresponding \code{x[i]} is an MPFR representation of zero (\code{0}). \cr Similarly, \code{.mpfr.is.whole} and \code{is.whole} return a logical vector of length \code{length(x)}. \code{mpfrVersion} returns an object of S3 class \code{"\link{numeric_version}"}, so it can be used in comparisons. The other functions return MPFR number (vectors), i.e., extending class \code{\linkS4class{mpfr}}. } \seealso{ \code{\link{str.mpfr}} for the \code{\link{str}} method. \code{\link{erf}} for special mathematical functions on MPFR. The class description \code{\linkS4class{mpfr}} page mentions many generic arithmetic and mathematical functions for which \code{"mpfr"} methods are available. } \examples{ mpfrVersion() (x <- c(Const("pi", 64), mpfr(-2:2, 64))) mpfrIs0(x) # one of them is x[mpfrIs0(x)] # but it may not have been obvious.. str(x) x <- rep(-2:2, 5) stopifnot(is.whole(mpfr(2, 500) ^ (1:200)), all.equal(diff(x), diff(as.numeric(x)))) } \keyword{arith} Rmpfr/man/roundMpfr.Rd0000644000176200001440000000234112561376373014373 0ustar liggesusers\name{roundMpfr} \title{Rounding to Binary bits, "mpfr-internally"} \alias{roundMpfr} \alias{setPrec}% <- so its found \description{Rounding to binary bits, not decimal digits. Closer to the number representation, this also allows to \emph{increase} or decrease a number's precBits. In other words, it acts as \code{setPrec()}, see \code{\link{getPrec}()}. } \usage{ roundMpfr(x, precBits, rnd.mode = c("N","D","U","Z","A")) } \arguments{ \item{x}{an mpfr number (vector)} \item{precBits}{integer specifying the desired precision in bits.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see \code{\link{mpfr}}.} } % \details{ % } \value{an mpfr number as \code{x} but with the new 'precBits' precision} \seealso{ The \code{\linkS4class{mpfr}} class group method \code{Math2} implements a method for \code{\link{round}(x, digits)} which rounds to \emph{decimal} digits. } \examples{ (p1 <- Const("pi", 100)) # 100 bit prec roundMpfr(p1, 120) # 20 bits more, but "random noise" Const("pi", 120) # same "precision", but really precise \dontshow{ stopifnot(120 == getPrec(roundMpfr(p1, 120)), 75 == getPrec(roundMpfr(p1, 75))) } } \keyword{arith} Rmpfr/man/mpfr.Rd0000644000176200001440000001337214250370720013354 0ustar liggesusers\name{mpfr} \title{Create "mpfr" Numbers (Objects)} \alias{mpfr} \alias{is.mpfr} \alias{mpfr.default} \alias{mpfr.mpfr}% and more \alias{Const} \description{ Create multiple (i.e. typically \emph{high}) precision numbers, to be used in arithmetic and mathematical computations with \R. } \usage{ mpfr(x, precBits, \dots) \S3method{mpfr}{default}(x, precBits, base = 10, rnd.mode = c("N","D","U","Z","A"), scientific = NA, \dots) Const(name = c("pi", "gamma", "catalan", "log2"), prec = 120L, rnd.mode = c("N","D","U","Z","A")) is.mpfr(x) } \arguments{ \item{x}{a \code{\link{numeric}}, \code{\linkS4class{mpfr}}, \code{\link[gmp]{bigz}}, \code{\link[gmp]{bigq}}, or \code{\link{character}} vector or \code{\link{array}}.} \item{precBits, prec}{a number, the maximal precision to be used, in \bold{\emph{bits}}; i.e. \code{53} corresponds to double precision. Must be at least 2. If \code{\link{missing}}, \code{\link{getPrec}(x)} determines a default precision.} \item{base}{(only when \code{x} is \code{\link{character}}) the base with respect to which \code{x[i]} represent numbers; \code{base} \eqn{b} must fulfill \eqn{2 \le b \le 62}{2 <= b <= 62}.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see details.} \item{scientific}{(used only when \code{x} is the result of \code{\link{formatBin}()}, i.e., of class \code{"Bcharacter"}:) logical indicating that the binary representation of \code{x} is in scientific notation. When \code{TRUE}, \code{mpfr()} will substitute \code{0} for \code{_}; when \code{NA}, \code{mpfr()} will guess, and use \code{TRUE} when finding a \code{"p"} in \code{x}; see also \code{\link{formatBin}}.} \item{name}{a string specifying the mpfrlib - internal constant computation. \code{"gamma"} is Euler's gamma (\eqn{\gamma}), and \code{"catalan"} Catalan's constant.} \item{\dots}{potentially further arguments passed to and from methods.} } \value{ an object of (S4) class \code{\linkS4class{mpfr}}, or for \code{mpfr(x)} when \code{x} is an array, \code{\linkS4class{mpfrMatrix}}, or \code{\linkS4class{mpfrArray}} which the user should just as a normal numeric vector or array. \code{is.mpfr()} returns \code{TRUE} or \code{FALSE}. } \details{ The \code{"\linkS4class{mpfr}"} method of \code{mpfr()} is a simple wrapper around \code{\link{roundMpfr}()}. MPFR supports the following rounding modes, %% the following is +- cut & paste from the MPFR manual \describe{ \item{GMP_RND\bold{N}:}{round to \bold{n}earest (roundTiesToEven in IEEE 754-2008).} \item{GMP_RND\bold{Z}:}{round toward \bold{z}ero (roundTowardZero in IEEE 754-2008).} \item{GMP_RND\bold{U}:}{round toward plus infinity (\dQuote{Up}, roundTowardPositive in IEEE 754-2008).} \item{GMP_RND\bold{D}:}{round toward minus infinity (\dQuote{Down}, roundTowardNegative in IEEE 754-2008).} \item{GMP_RND\bold{A}:}{round \bold{a}way from zero (new since MPFR 3.0.0).} } The \sQuote{round to nearest} (\code{"N"}) mode, the default here, works as in the IEEE 754 standard: in case the number to be rounded lies exactly in the middle of two representable numbers, it is rounded to the one with the least significant bit set to zero. For example, the number 5/2, which is represented by (10.1) in binary, is rounded to (10.0)=2 with a precision of two bits, and not to (11.0)=3. This rule avoids the "drift" phenomenon mentioned by Knuth in volume 2 of The Art of Computer Programming (Section 4.2.2). When \code{x} is \code{\link{character}}, \code{mpfr()} will detect the precision of the input object. %% FIXME examples } \references{ The MPFR team. (202x). \emph{GNU MPFR -- The Multiple Precision Floating-Point Reliable Library}; see \url{https://www.mpfr.org/mpfr-current/#doc} or directly \url{https://www.mpfr.org/mpfr-current/mpfr.pdf}. } \author{Martin Maechler} \seealso{The class documentation \code{\linkS4class{mpfr}} contains more details. Use \code{\link{asNumeric}} to transform back to double precision ("\code{\link{numeric}}"). } \examples{ mpfr(pi, 120) ## the double-precision pi "translated" to 120-bit precision pi. <- Const("pi", prec = 260) # pi "computed" to correct 260-bit precision pi. # nicely prints 80 digits [260 * log10(2) ~= 78.3 ~ 80] Const("gamma", 128L) # 0.5772... Const("catalan", 128L) # 0.9159... x <- mpfr(0:7, 100)/7 # a more precise version of k/7, k=0,..,7 x 1 / x ## character input : mpfr("2.718281828459045235360287471352662497757") - exp(mpfr(1, 150)) ## ~= -4 * 10^-40 ## Also works for NA, NaN, ... : cx <- c("1234567890123456", 345, "NA", "NaN", "Inf", "-Inf") mpfr(cx) ## with some 'base' choices : print(mpfr("111.1111", base=2)) * 2^4 mpfr("af21.01020300a0b0c", base=16) ## 68 bit prec. 44833.00393694653820642 mpfr("ugi0", base = 32) == 10^6 ## TRUE ## --- Large integers from package 'gmp': Z <- as.bigz(7)^(1:200) head(Z, 40) ## mfpr(Z) by default chooses the correct *maximal* default precision: mZ. <- mpfr(Z) ## more efficiently chooses precision individually m.Z <- mpfr(Z, precBits = frexpZ(Z)$exp) ## the precBits chosen are large enough to keep full precision: stopifnot(identical(cZ <- as.character(Z), as(mZ.,"character")), identical(cZ, as(m.Z,"character"))) ## compare mpfr-arithmetic with exact rational one: stopifnot(all.equal(mpfr(as.bigq(355,113), 99), mpfr(355, 99) / 113, tol = 2^-98)) ## look at different "rounding modes": sapply(c("N", "D","U","Z","A"), function(RND) mpfr(c(-1,1)/5, 20, rnd.mode = RND), simplify=FALSE) symnum(sapply(c("N", "D","U","Z","A"), function(RND) mpfr(0.2, prec = 5:15, rnd.mode = RND) < 0.2 )) } \keyword{classes} Rmpfr/man/base-copies.Rd0000644000176200001440000000070113325623111014567 0ustar liggesusers\name{Rmpfr-workarounds} \alias{outer} \title{Base Functions etc, as an Rmpfr version} \description{ Functions from \pkg{base} etc which need a \emph{copy} in the \pkg{Rmpfr} namespace so they correctly dispatch. } \usage{ outer(X, Y, FUN = "*", ...) } \arguments{ \item{X, Y, FUN, ...}{See \pkg{base} package help: \code{\link[base]{outer}}.} } \seealso{ \code{\link[base]{outer}}. } \examples{ outer(1/mpfr(1:10, 70), 0:2) } \keyword{misc} Rmpfr/man/Mnumber-class.Rd0000644000176200001440000000344511764636731015136 0ustar liggesusers\name{Mnumber-class} \Rdversion{1.1} \docType{class} \alias{Mnumber-class} \alias{mNumber-class} \alias{numericVector-class} \title{Class "Mnumber" and "mNumber" of "mpfr" and regular numbers and arrays from them} \description{ Classes \code{"Mnumber"} \code{"mNumber"} are class unions of \code{"\linkS4class{mpfr}"} and regular numbers and arrays from them.\cr Its purpose is for method dispatch, notably defining a \code{cbind(...)} method where \code{...} contains objects of one of the member classes of \code{"Mnumber"}. Classes \code{"mNumber"} is considerably smaller is it does \emph{not} contain \code{"matrix"} and \code{"array"} since these also extend \code{"character"} which is not really desirable for generalized numbers. It extends the simple \code{"numericVector"} class by \code{mpfr*} classes. } \section{Methods}{ \describe{ \item{\%*\%}{\code{signature(x = "mpfrMatrix", y = "Mnumber")}: ... } \item{crossprod}{\code{signature(x = "mpfr", y = "Mnumber")}: ... } \item{tcrossprod}{\code{signature(x = "Mnumber", y = "mpfr")}: ...} } etc. These are documented with the classes \code{\linkS4class{mpfr}} and or \code{\linkS4class{mpfrMatrix}}. } \seealso{ the \code{\linkS4class{array_or_vector}} sub class; \code{\link{cbind-methods}}. } \examples{ ## "Mnumber" encompasses (i.e., "extends") quite a few ## "vector / array - like" classes: showClass("Mnumber") stopifnot(extends("mpfrMatrix", "Mnumber"), extends("array", "Mnumber")) Mnsub <- names(getClass("Mnumber")@subclasses) (mNsub <- names(getClass("mNumber")@subclasses)) ## mNumber has *one* subclass which is not in Mnumber: setdiff(mNsub, Mnsub)# namely "numericVector" ## The following are only subclasses of "Mnumber", but not of "mNumber": setdiff(Mnsub, mNsub) } \keyword{classes} Rmpfr/man/str.mpfr.Rd0000644000176200001440000000414113523036312014153 0ustar liggesusers\name{str.mpfr} \alias{str.mpfr} \title{Compactly Show STRucture of Rmpfr Number Object} \description{ The \code{\link{str}} method for objects of class \code{\linkS4class{mpfr}} produces a bit more useful output than the default method \code{\link{str.default}}. } \usage{ \method{str}{mpfr}(object, nest.lev, internal = FALSE, give.head = TRUE, digits.d = 12, vec.len = NULL, drop0trailing=TRUE, width = getOption("width"), \dots) } \arguments{ \item{object}{an object of class \code{\linkS4class{mpfr}}.} \item{nest.lev}{for \code{\link{str}()}, typically only used when called by a higher level \code{str()}.} \item{internal}{logical indicating if the low-level internal structure should be shown; if true (not by default), uses \code{str(object@.Data)}.} \item{give.head}{logical indicating if the \dQuote{header} should be printed.} \item{digits.d}{the number of digits to be used, will be passed \code{\link{formatMpfr}()} and hence \code{NULL} will use \dQuote{as many as needed}, i.e. often too many. If this is a number, as per default, less digits will be used in case the precision (\code{\link{getPrec}(object)}) is smaller.} \item{vec.len}{the number of \emph{elements} that will be shown. The default depends on the precision of \code{object} and \code{width} (since \pkg{Rmpfr} 0.6-0, it was \code{3} previously).} \item{drop0trailing}{logical, passed to \code{\link{formatMpfr}()} (with a different default here).} \item{width}{the (approximately) desired width of output, see \code{\link{options}(width = .)}.} \item{\dots}{further arguments, passed to \code{\link{formatMpfr}()}.} } \seealso{ \code{\link{.mpfr2list}()} puts the internal structure into a \code{\link{list}}, and its help page documents many more (low level) utilities. } \examples{ (x <- c(Const("pi", 64), mpfr(-2:2, 64))) str(x) str(list(pi = pi, x.mpfr = x)) str(x ^ 1000) str(x ^ -1e4, digits=NULL) # full precision str(x, internal = TRUE) # internal low-level (for experts) uu <- Const("pi", 16)# unaccurate str(uu) # very similar to just 'uu' } \keyword{utilities} Rmpfr/man/mpfr-class.Rd0000644000176200001440000004707314245753567014506 0ustar liggesusers\name{mpfr-class} \docType{class} \title{Class "mpfr" of Multiple Precision Floating Point Numbers} % \alias{mpfr-class} \alias{mpfr1-class} \alias{summaryMpfr-class} % \alias{[[,mpfr-method} \alias{[,mpfr,ANY,missing,missing-method} \alias{[<-,mpfr,missing,missing,ANY-method} \alias{[<-,mpfr,ANY,missing,ANY-method} \alias{[<-,mpfr,ANY,missing,mpfr-method} % FIXME: many of these are just \alias{}ed, but *NOT* documented: \alias{as.numeric,mpfr-method} \alias{as.vector,mpfrArray-method} \alias{as.integer,mpfr-method} \alias{beta,ANY,mpfr-method} \alias{beta,ANY,mpfrArray-method} \alias{beta,mpfr,ANY-method} \alias{beta,mpfr,mpfr-method} \alias{beta,mpfr,numeric-method} \alias{beta,numeric,mpfr-method} \alias{beta,mpfrArray,ANY-method} \alias{beta,mpfrArray,mpfrArray-method} \alias{lbeta,ANY,mpfr-method} \alias{lbeta,ANY,mpfrArray-method} \alias{lbeta,mpfr,ANY-method} \alias{lbeta,mpfr,mpfr-method} \alias{lbeta,mpfr,numeric-method} \alias{lbeta,numeric,mpfr-method} \alias{lbeta,mpfrArray,ANY-method} \alias{lbeta,mpfrArray,mpfrArray-method} \alias{atan2,ANY,mpfr-method} \alias{atan2,ANY,mpfrArray-method} \alias{atan2,mpfr,ANY-method} \alias{atan2,mpfr,mpfr-method} \alias{atan2,mpfr,numeric-method} \alias{atan2,numeric,mpfr-method} \alias{atan2,mpfrArray,ANY-method} \alias{atan2,mpfrArray,mpfrArray-method} \alias{hypot} % \alias{coerce,mpfr,character-method} \alias{coerce,mpfr,numeric-method} \alias{coerce,mpfr,bigz-method} \alias{coerce,mpfr,integer-method} \alias{coerce,mpfr1,numeric-method} \alias{coerce,mpfr1,mpfr-method} \alias{coerce,integer,mpfr-method} \alias{coerce,logical,mpfr-method} \alias{coerce,raw,mpfr-method} \alias{coerce,numeric,mpfr-method} \alias{coerce,numeric,mpfr1-method} \alias{coerce,array,mpfr-method} \alias{coerce,character,mpfr-method} \alias{coerce,mpfr,mpfr1-method} % \alias{Ops,mpfr,ANY-method} \alias{Ops,ANY,mpfr-method} \alias{Ops,mpfr,bigq-method} \alias{Ops,bigq,mpfr-method} \alias{Ops,mpfr,bigz-method} \alias{Ops,bigz,mpfr-method} \alias{Ops,array,mpfr-method} \alias{Ops,mpfr,array-method} \alias{Ops,mpfr,vector-method} \alias{Ops,vector,mpfr-method} \alias{Arith,mpfr,array-method} \alias{Arith,mpfr,missing-method} \alias{Arith,mpfr,mpfr-method} \alias{Arith,mpfr,integer-method} \alias{Arith,mpfr,numeric-method} \alias{Arith,integer,mpfr-method} \alias{Arith,numeric,mpfr-method} \alias{Arith,array,mpfr-method} % \alias{Compare,mpfr,mpfr-method} \alias{Compare,mpfr,integer-method} \alias{Compare,mpfr,numeric-method} \alias{Compare,integer,mpfr-method} \alias{Compare,numeric,mpfr-method} \alias{Compare,mpfr,array-method} \alias{Compare,array,mpfr-method} % \alias{Logic,mpfr,mpfr-method} \alias{Logic,mpfr,numeric-method} \alias{Logic,numeric,mpfr-method} \alias{Summary,mpfr-method} \alias{Math,mpfr-method} \alias{Math2,mpfr-method} \alias{abs,mpfr-method} \alias{log,mpfr-method} \alias{factorial,mpfr-method} \alias{sign,mpfr-method} % "Complex" (cheap methods for "real"s): \alias{Re,mpfr-method} \alias{Im,mpfr-method} \alias{Mod,mpfr-method} \alias{Arg,mpfr-method} \alias{Conj,mpfr-method} \alias{format,mpfr-method} \alias{is.finite,mpfr-method} \alias{is.infinite,mpfr-method} \alias{is.na,mpfr-method} \alias{is.nan,mpfr-method} \alias{is.finite,mpfrArray-method} \alias{is.infinite,mpfrArray-method} \alias{is.na,mpfrArray-method} \alias{is.nan,mpfrArray-method} \alias{unique,mpfr-method}% <--- wanted by R CMD check \alias{unique,mpfr,ANY-method}% not sufficient for R CMD .. \alias{unique.mpfr} % \alias{all.equal,mpfr,mpfr-method} \alias{all.equal,mpfr,ANY-method} \alias{all.equal,ANY,mpfr-method} \alias{mean,mpfr-method} \alias{median,mpfr-method} \alias{quantile,mpfr-method} \alias{summary,mpfr-method} \alias{dim<-,mpfr-method} \alias{t,mpfr-method} \alias{\%*\%,array_or_vector,mpfr-method} \alias{\%*\%,mpfr,array_or_vector-method} \alias{crossprod,array_or_vector,mpfr-method} \alias{crossprod,mpfr,array_or_vector-method} \alias{tcrossprod,array_or_vector,mpfr-method} \alias{tcrossprod,mpfr,array_or_vector-method} \alias{which.min,mpfr-method} \alias{which.max,mpfr-method} \alias{show,mpfr-method} \alias{show,mpfr1-method} \alias{show,summaryMpfr-method} \alias{print.mpfr1} \alias{print.summaryMpfr} % \description{ \code{"mpfr"} is the class of \bold{M}ultiple \bold{P}recision \bold{F}loatingpoint numbers with \bold{R}eliable arithmetic. sFor the high-level user, \code{"mpfr"} objects should behave as standard \R's \code{\link{numeric}} \emph{vectors}. They would just print differently and use the prespecified (typically high) precision instead of the double precision of \sQuote{traditional} \R numbers (with \code{\link{class}(.) == "numeric"} and \code{\link{typeof}(.) == "double"}). \code{hypot(x,y)} computes the hypothenuse length \eqn{z} in a rectangular triangle with \dQuote{leg} side lengths \eqn{x} and \eqn{y}, i.e., \deqn{z = hypot(x,y) = \sqrt{x^2 + y^2},}{z = hypot(x,y) = sqrt(x^2 + y^2),} in a numerically stable way. } \usage{ hypot(x,y, rnd.mode = c("N","D","U","Z","A")) } \arguments{ \item{x,y}{an object of class \code{mpfr}.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see \code{\link{mpfr}}.} } \section{Objects from the Class}{ Objects are typically created by \code{\link{mpfr}(, precBits)}. \code{summary()} returns an object of class \code{"summaryMpfr"} which contains \code{"mpfr"} but has its own \code{\link{print}} method. } \section{Slots}{ Internally, \code{"mpfr"} objects just contain standard \R \code{\link{list}}s where each list element is of class \code{"mpfr1"}, representing \emph{one} MPFR number, in a structure with four slots, very much parallelizing the C \code{struc} in the \code{mpfr} C library to which the \pkg{Rmpfr} package interfaces. An object of class \code{"mpfr1"} has slots \describe{ \item{\code{prec}:}{\code{"integer"} specifying the maxmimal precision in \bold{bits}.} \item{\code{exp}:}{\code{"integer"} specifying the base-\bold{2} exponent of the number.} \item{\code{sign}:}{\code{"integer"}, typically \code{-1} or \code{1}, specifying the sign (i.e. \code{\link{sign}(.)}) of the number.} \item{\code{d}:}{an \code{"integer"} vector (of 32-bit \dQuote{limbs}) which corresponds to the full mantissa of the number.} }% desc } % \section{Extends}{ % Class \code{"\linkS4class{list}"}, from data part. % Class \code{"\linkS4class{vector}"}, by class "list", distance 2. % } \section{Methods}{ \describe{ \item{abs}{\code{signature(x = "mpfr")}: ... } \item{atan2}{\code{signature(y = "mpfr", x = "ANY")}, and} \item{atan2}{\code{signature(x = "ANY", y = "mpfr")}: compute the arc-tangent of two arguments: \code{atan2(y, x)} returns the angle between the x-axis and the vector from the origin to \eqn{(x, y)}, i.e., for positive arguments \code{atan2(y, x) == \link{atan}(y/x)}.} \item{lbeta}{\code{signature(a = "ANY", b = "mpfrArray")}, is \eqn{\log(|B(a,b)|)}{log(abs(B(a,b)))} where \eqn{B(a,b)} is the Beta function, \code{beta(a,b)}.} \item{beta}{\code{signature(a = "mpfr", b = "ANY")},} \item{beta}{\code{signature(a = "mpfr", b = "mpfr")}, \dots, etc: Compute the beta function \eqn{B(a,b)}, using high precision, building on internal \code{\link{gamma}} or \code{\link{lgamma}}. See the help for \R's base function \code{\link[base]{beta}} for more. Currently, there, \eqn{a,b \ge 0}{a,b >= 0} is required. Here, we provide (non-\code{\link{NaN}}) for all numeric \code{a, b}. When either \eqn{a}, \eqn{b}, or \eqn{a+b} is a negative \emph{integer}, \eqn{\Gamma(.)} has a pole there and is undefined (\code{NaN}). However the Beta function can be defined there as \dQuote{limit}, in some cases. Following other software such as SAGE, Maple or Mathematica, we provide finite values in these cases. However, note that these are not proper limits (two-dimensional in \eqn{(a,b)}), but useful for some applications. E.g., \eqn{B(a,b)} is defined as zero when \eqn{a+b} is a negative integer, but neither \eqn{a} nor \eqn{b} is. Further, if \eqn{a > b > 0} are integers, \eqn{B(-a,b)= B(b,-a)} can be seen as \eqn{(-1)^b * B(a-b+1,b)}. } \item{dim<-}{\code{signature(x = "mpfr")}: Setting a dimension \code{\link{dim}} on an \code{"mpfr"} object makes it into an object of class \code{"\linkS4class{mpfrArray}"} or (more specifically) \code{"mpfrMatrix"} for a length-2 dimension, see their help page; note that \code{t(x)} (below) is a special case of this.} \item{Ops}{\code{signature(e1 = "mpfr", e2 = "ANY")}: ... } \item{Ops}{\code{signature(e1 = "ANY", e2 = "mpfr")}: ... } \item{Arith}{\code{signature(e1 = "mpfr", e2 = "missing")}: ... } \item{Arith}{\code{signature(e1 = "mpfr", e2 = "mpfr")}: ... } \item{Arith}{\code{signature(e1 = "mpfr", e2 = "integer")}: ... } \item{Arith}{\code{signature(e1 = "mpfr", e2 = "numeric")}: ... } \item{Arith}{\code{signature(e1 = "integer", e2 = "mpfr")}: ... } \item{Arith}{\code{signature(e1 = "numeric", e2 = "mpfr")}: ... } \item{Compare}{\code{signature(e1 = "mpfr", e2 = "mpfr")}: ... } \item{Compare}{\code{signature(e1 = "mpfr", e2 = "integer")}: ... } \item{Compare}{\code{signature(e1 = "mpfr", e2 = "numeric")}: ... } \item{Compare}{\code{signature(e1 = "integer", e2 = "mpfr")}: ... } \item{Compare}{\code{signature(e1 = "numeric", e2 = "mpfr")}: ... } \item{Logic}{\code{signature(e1 = "mpfr", e2 = "mpfr")}: ... } \item{Summary}{\code{signature(x = "mpfr")}: The S4 \code{\link[methods:S4groupGeneric]{Summary}} group functions, \code{\link{max}}, \code{\link{min}}, \code{\link{range}}, \code{\link{prod}}, \code{\link{sum}}, \code{\link{any}}, and \code{\link{all}} are all defined for MPFR numbers. \code{\link{mean}(x, trim)} for non-0 \code{trim} works analogously to \code{\link{mean.default}}.} \item{median}{\code{signature(x = "mpfr")}: works via}% quantile(*, probs = 0.5) : \item{quantile}{\code{signature(x = "mpfr")}: a simple wrapper of the \code{quantile.default} method from \pkg{stats}.} \item{summary}{\code{signature(object = "mpfr")}: modeled after \code{\link{summary.default}}, ensuring to provide the full "mpfr" range of numbers.} \item{Math}{\code{signature(x = "mpfr")}: All the S4 \code{\link[methods:S4groupGeneric]{Math}} group functions are defined, using multiple precision (MPFR) arithmetic, from \code{\link{getGroupMembers}("Math")}, these are (in alphabetical order): % keep in sync w/ >> ../R/Math.R << \code{\link{abs}}, \code{\link{sign}}, \code{\link{sqrt}}, \code{\link{ceiling}}, \code{\link{floor}}, \code{\link{trunc}}, \code{\link{cummax}}, \code{\link{cummin}}, \code{\link{cumprod}}, \code{\link{cumsum}}, \code{\link{exp}}, \code{\link{expm1}}, \code{\link{log}}, \code{\link{log10}}, \code{\link{log2}}, \code{\link{log1p}}, \code{\link{cos}}, \code{\link{cosh}}, \code{\link{sin}}, \code{\link{sinh}}, \code{\link{tan}}, \code{\link{tanh}}, \code{\link{acos}}, \code{\link{acosh}}, \code{\link{asin}}, \code{\link{asinh}}, \code{\link{atan}}, \code{\link{atanh}}, \code{\link{cospi}}, \code{\link{sinpi}}, \code{\link{tanpi}}, \code{\link{gamma}}, \code{\link{lgamma}}, \code{\link{digamma}}, and \code{\link{trigamma}}. Currently, \code{trigamma} is not provided by the MPFR library and hence not yet implemented. \cr Further, the \code{cum*()} methods are \emph{not yet} implemented.} \item{factorial}{\code{signature(x = "mpfr")}: this will \code{\link{round}} the result when \code{x} is integer valued. Note however that \code{\link{factorialMpfr}(n)} for integer \code{n} is slightly more efficient, using the MPFR function \samp{mpfr_fac_ui}.} \item{Math2}{\code{signature(x = "mpfr")}: \code{\link{round}(x, digits)} and \code{\link{signif}(x, digits)} methods. Note that these do not change the formal precision (\code{'prec'} slot), and you may often want to apply \code{\link{roundMpfr}()} in addition or preference.} \item{as.numeric}{\code{signature(x = "mpfr")}: ... } \item{as.vector}{\code{signature(x = "mpfrArray")}: as for standard \code{\link{array}}s, this \dQuote{drops} the \code{dim} (and \code{dimnames}), i.e., transforms \code{x} into an \sQuote{MPFR} number vector, i.e., class \code{\linkS4class{mpfr}}.} \item{[[}{\code{signature(x = "mpfr", i = "ANY")}, and} \item{[}{\code{signature(x = "mpfr", i = "ANY", j = "missing", drop = "missing")}: subsetting aka \dQuote{indexing} happens as for numeric vectors.} \item{format}{\code{signature(x = "mpfr")}, further arguments \code{digits = NULL, scientific = NA}, etc: returns \code{\link{character}} vector of same length as \code{x}; when \code{digits} is \code{NULL}, with \emph{enough} digits to recreate \code{x} accurately. For details, see \code{\link{formatMpfr}}.} \item{is.finite}{\code{signature(x = "mpfr")}: ... } \item{is.infinite}{\code{signature(x = "mpfr")}: ... } \item{is.na}{\code{signature(x = "mpfr")}: ... } \item{is.nan}{\code{signature(x = "mpfr")}: ... } \item{log}{\code{signature(x = "mpfr")}: ... } \item{show}{\code{signature(object = "mpfr")}: ... } \item{sign}{\code{signature(x = "mpfr")}: ... } \item{Re, Im}{\code{signature(z = "mpfr")}: simply return \code{z} or \code{0} (as \code{"mpfr"} numbers of correct precision), as mpfr numbers are \sQuote{real} numbers.} \item{Arg, Mod, Conj}{\code{signature(z = "mpfr")}: these are trivial for our \sQuote{real} mpfr numbers, but defined to work correctly when used in \R code that also allows complex number input.} \item{all.equal}{\code{signature(target = "mpfr", current = "mpfr")},} \item{all.equal}{\code{signature(target = "mpfr", current = "ANY")}, and} \item{all.equal}{\code{signature(target = "ANY", current = "mpfr")}: methods for numerical (approximate) equality, \code{\link[base]{all.equal}} of multiple precision numbers. Note that the default \code{tolerance} (argument) is taken to correspond to the (smaller of the two) precisions when both main arguments are of class \code{"mpfr"}, and hence can be considerably less than double precision machine epsilon \code{\link{.Machine}$double.eps}.} \item{coerce}{\code{signature(from = "numeric", to = "mpfr")}: \code{\link{as}(., "mpfr")} coercion methods are available for \code{\link{character}} strings, \code{\link{numeric}}, \code{\link{integer}}, \code{\link{logical}}, and even \code{\link{raw}}. Note however, that \code{\link{mpfr}(., precBits, base)} is more flexible.} \item{coerce}{\code{signature(from = "mpfr", to = "bigz")}: coerces to biginteger, see \code{\link[gmp]{bigz}} in package \pkg{gmp}.} \item{coerce}{\code{signature(from = "mpfr", to = "numeric")}: ... } \item{coerce}{\code{signature(from = "mpfr", to = "character")}: ... } \item{unique}{\code{signature(x = "mpfr")}, and corresponding S3 method (such that \code{unique()} works inside \pkg{base} functions), see \code{\link{unique}}. Note that \code{\link{duplicated}()} works for \code{"mpfr"} objects without the need for a specific method.} \item{t}{\code{signature(x = "mpfr")}: makes \code{x} into an \eqn{n \times 1}{n x 1} \code{\linkS4class{mpfrMatrix}}.} \item{which.min}{\code{signature(x = "mpfr")}: gives the index of the first minimum, see \code{\link{which.min}}.} \item{which.max}{\code{signature(x = "mpfr")}: gives the index of the first maximum, see \code{\link{which.max}}.} } } \author{Martin Maechler} \note{Many more methods (\dQuote{functions}) automagically work for \code{"mpfr"} number vectors (and matrices, see the \code{\linkS4class{mpfrMatrix}} class doc), notably \code{\link{sort}}, \code{\link{order}}, \code{\link{quantile}}, \code{\link{rank}}. } \seealso{ The \code{"\linkS4class{mpfrMatrix}"} class, which extends the \code{"mpfr"} one. \code{\link{roundMpfr}} to \emph{change} precision of an \code{"mpfr"} object which is typically desirable \emph{instead} of or in addition to \code{signif()} or \code{round()}; \code{\link{is.whole}()} etc. Special mathematical functions such as some Bessel ones, e.g., \code{\link{jn}}; further, \code{\link{zeta}(.)} \eqn{(= \zeta(.))}, \code{Ei()} etc. \code{\link{Bernoulli}} numbers and the Pochhammer function \code{\link{pochMpfr}}. } \examples{ ## 30 digit precision (x <- mpfr(c(2:3, pi), prec = 30 * log2(10))) str(x) # str() displays *compact*ly => not full precision x^2 x[1] / x[2] # 0.66666... ~ 30 digits ## indexing - as with numeric vectors stopifnot(exprs = { identical(x[2], x[[2]]) ## indexing "outside" gives NA (well: "mpfr-NaN" for now): is.na(x[5]) ## whereas "[[" cannot index outside: inherits(tryCatch(x[[5]], error=identity), "error") ## and only select *one* element: inherits(tryCatch(x[[2:3]], error=identity), "error") }) ## factorial() & lfactorial would work automagically via [l]gamma(), ## but factorial() additionally has an "mpfr" method which rounds f200 <- factorial(mpfr(200, prec = 1500)) # need high prec.! f200 as.numeric(log2(f200))# 1245.38 -- need precBits >~ 1246 for full precision ##--> see factorialMpfr() for more such computations. ##--- "Underflow" **much** later -- exponents have 30(+1) bits themselves: mpfr.min.exp2 <- - (2^30 + 1) two <- mpfr(2, 55) stopifnot(two ^ mpfr.min.exp2 == 0) ## whereas two ^ (mpfr.min.exp2 * (1 - 1e-15)) ## 2.38256490488795107e-323228497 ["typically"] ##--- "Assert" that {sort}, {order}, {quantile}, {rank}, all work : p <- mpfr(rpois(32, lambda=500), precBits=128)^10 np <- as.numeric(log(p)) (sp <- summary(p))# using the print.summaryMpfr() method stopifnot(all(diff(sort(p)) >= 0), identical(order(p), order(np)), identical(rank (p), rank (np)), all.equal(sapply(1:9, function(Typ) quantile(np, type=Typ, names=FALSE)), sapply(lapply(1:9, function(Typ) quantile( p, type=Typ, names=FALSE)), function(x) as.numeric(log(x))), tol = 1e-3),# quantiles: interpolated in orig. <--> log scale TRUE) m0 <- mpfr(numeric(), 99) xy <- expand.grid(x = -2:2, y = -2:2) ; x <- xy[,"x"] ; y <- xy[,"y"] a2. <- atan2(y,x) stopifnot(identical(which.min(m0), integer(0)), identical(which.max(m0), integer(0)), all.equal(a2., atan2(as(y,"mpfr"), x)), max(m0) == mpfr(-Inf, 53), # (53 is not a feature, but ok) min(m0) == mpfr(+Inf, 53), sum(m0) == 0, prod(m0) == 1) ## unique(), now even base::factor() "works" on : set.seed(17) p <- rlnorm(20) * mpfr(10, 100)^-999 pp <- sample(p, 50, replace=TRUE) str(unique(pp)) # length 18 .. (from originally 20) ## Class 'mpfr' [package "Rmpfr"] of length 18 and precision 100 ## 5.56520587824e-999 4.41636588227e-1000 .. facp <- factor(pp) str(facp) # the factor *levels* are a bit verbose : # Factor w/ 18 levels "new(\"mpfr1\", ...........)" ... # At least *some* factor methods work : stopifnot(exprs = { is.factor(facp) identical(unname(table(facp)), unname(table(asNumeric(pp * mpfr(10,100)^1000)))) }) ## ((unfortunately, the expressions are wrong; should integer "L")) # ## More useful: levels with which to *invert* factor() : ## -- this is not quite ok: ## simplified from 'utils' : deparse1 <- function(x, ...) paste(deparse(x, 500L, ...), collapse = " ") if(FALSE) { str(pp.levs <- vapply(unclass(sort(unique(pp))), deparse1, "")) facp2 <- factor(pp, levels = pp.levs) } } \keyword{classes} Rmpfr/man/hjkMpfr.Rd0000644000176200001440000001165614365710754014030 0ustar liggesusers\name{hjkMpfr} \alias{hjkMpfr} \title{Hooke-Jeeves Derivative-Free Minimization R (working for MPFR)} \description{ An implementation of the Hooke-Jeeves algorithm for derivative-free optimization. %% TODO: hjkb() A bounded and an unbounded version are provided. --> ~/R/Pkgs/dfoptim/R/ This is a slight adaption \code{\link[dfoptim]{hjk}()} from package \CRANpkg{dfoptim}. } \usage{ hjkMpfr(par, fn, control = list(), ...) } \arguments{ \item{par}{Starting vector of parameter values. The initial vector may lie on the boundary. If \code{lower[i]=upper[i]} for some \code{i}, the \code{i}-th component of the solution vector will simply be kept fixed.} \item{fn}{Nonlinear objective function that is to be optimized. A scalar function that takes a real vector as argument and returns a scalar that is the value of the function at that point.} \item{control}{\code{\link{list}} of control parameters. See \bold{Details} for more information.} \item{\dots}{Additional arguments passed to \code{fn}.} } \details{ Argument \code{control} is a list specifing changes to default values of algorithm control parameters. Note that parameter names may be abbreviated as long as they are unique. The list items are as follows: \describe{ \item{\code{tol}}{Convergence tolerance. Iteration is terminated when the step length of the main loop becomes smaller than \code{tol}. This does \emph{not} imply that the optimum is found with the same accuracy. Default is 1.e-06.} \item{\code{maxfeval}}{Maximum number of objective function evaluations allowed. Default is Inf, that is no restriction at all.} \item{\code{maximize}}{A logical indicating whether the objective function is to be maximized (TRUE) or minimized (FALSE). Default is FALSE.} \item{\code{target}}{A real number restricting the absolute function value. The procedure stops if this value is exceeded. Default is Inf, that is no restriction.} \item{\code{info}}{A logical variable indicating whether the step number, number of function calls, best function value, and the first component of the solution vector will be printed to the console. Default is FALSE.} } If the minimization process threatens to go into an infinite loop, set either \code{maxfeval} or \code{target}. } \value{ A \code{\link{list}} with the following components: \item{par}{Best estimate of the parameter vector found by the algorithm.} \item{value}{value of the objective function at termination.} \item{convergence}{indicates convergence (\code{TRUE}) or not (\code{FALSE}).} \item{feval}{number of times the objective \code{fn} was evaluated.} \item{niter}{number of iterations (\dQuote{steps}) in the main loop.} } \references{ C.T. Kelley (1999), Iterative Methods for Optimization, SIAM. Quarteroni, Sacco, and Saleri (2007), Numerical Mathematics, Springer. } \note{ This algorithm is based on the Matlab code of Prof. C. T. Kelley, given in his book \dQuote{Iterative methods for optimization}. It has been implemented for package \pkg{dfoptim} with the permission of Prof. Kelley. This version does not (yet) implement a cache for storing function values that have already been computed as searching the cache makes it slower. } \author{Hans W Borchers \email{hwborchers@googlemail.com}; for \pkg{Rmpfr}: John Nash, June 2012. Modifications by Martin Maechler.} % \note{ % } \seealso{ Standard \R's \code{\link{optim}}; \code{\link{optimizeR}} provides \emph{one}-dimensional minimization methods that work with \code{\linkS4class{mpfr}}-class numbers. } \examples{ ## simple smooth example: ff <- function(x) sum((x - c(2:4))^2) str(rr <- hjkMpfr(rep(mpfr(0,128), 3), ff, control=list(info=TRUE))) doX <- Rmpfr:::doExtras(); cat("doExtras: ", doX, "\n") # slow parts only if(doX) ## Hooke-Jeeves solves high-dim. Rosenbrock function {but slowly!} rosenbrock <- function(x) { n <- length(x) sum (100*((x1 <- x[1:(n-1)])^2 - x[2:n])^2 + (x1 - 1)^2) } par0 <- rep(0, 10) str(rb.db <- hjkMpfr(rep(0, 10), rosenbrock, control=list(info=TRUE))) if(doX) { ## rosenbrook() is quite slow with mpfr-numbers: str(rb.M. <- hjkMpfr(mpfr(numeric(10), prec=128), rosenbrock, control = list(tol = 1e-8, info=TRUE))) } %% Once we have it: *bounded* version: %% hjkbMpfr(c(0, 0, 0), rosenbrock, upper = 0.5) ## Hooke-Jeeves does not work well on non-smooth functions nsf <- function(x) { f1 <- x[1]^2 + x[2]^2 f2 <- x[1]^2 + x[2]^2 + 10 * (-4*x[1] - x[2] + 4) f3 <- x[1]^2 + x[2]^2 + 10 * (-x[1] - 2*x[2] + 6) max(f1, f2, f3) } par0 <- c(1, 1) # true min 7.2 at (1.2, 2.4) h.d <- hjkMpfr(par0, nsf) # fmin=8 at xmin=(2,2) if(doX) { ## and this is not at all better (but slower!) h.M <- hjkMpfr(mpfr(c(1,1), 128), nsf, control = list(tol = 1e-15)) } %% --> ../demo/hjkMpfr.R : ## --> demo(hjkMpfr) # -> Fletcher's chebyquad function m = n -- residuals } \keyword{optimize} Rmpfr/man/mpfrMatrix-class.Rd0000644000176200001440000002463713637431043015656 0ustar liggesusers\name{mpfrMatrix} \title{Classes "mpfrMatrix" and "mpfrArray"}% <--> ./mpfrArray.Rd \docType{class} \alias{mpfrMatrix-class} \alias{mpfrArray-class} % \alias{Arith,mpfrArray,mpfr-method} \alias{Arith,mpfrArray,mpfrArray-method} \alias{Arith,mpfr,mpfrArray-method} \alias{Arith,mpfrArray,numeric-method} \alias{Arith,numeric,mpfrArray-method} \alias{Compare,mpfrArray,mpfr-method} \alias{Compare,mpfrArray,numeric-method} \alias{Compare,mpfr,mpfrArray-method} \alias{Compare,numeric,mpfrArray-method} % \alias{apply,mpfrArray-method} \alias{colSums,mpfrArray-method} \alias{colMeans,mpfrArray-method} \alias{rowSums,mpfrArray-method} \alias{rowMeans,mpfrArray-method} \alias{as.vector,mpfrArray,missing-method} \alias{coerce,mpfrArray,array-method} \alias{coerce,array,mpfrArray-method} \alias{coerce,mpfrArray,matrix-method} \alias{coerce,mpfrMatrix,matrix-method} \alias{coerce,matrix,mpfrMatrix-method} %% the following two from the same setAs(); the 2nd one is auto-produced %% *and* needed by codoc(). Behavior seems a bit bogous : \alias{coerce,mpfrArray,vector-method} \alias{coerce<-,mpfrArray,vector-method} \alias{diag,mpfrMatrix-method} \alias{diag<-,mpfrMatrix-method} % \alias{[<-,mpfrArray,ANY,ANY,ANY-method} \alias{[<-,mpfrArray,ANY,ANY,mpfr-method} \alias{[<-,mpfrArray,ANY,missing,ANY-method} \alias{[<-,mpfrArray,ANY,missing,mpfr-method} \alias{[<-,mpfrArray,missing,ANY,ANY-method} \alias{[<-,mpfrArray,missing,ANY,mpfr-method} \alias{[<-,mpfrArray,missing,missing,ANY-method} \alias{[<-,mpfrArray,missing,missing,mpfr-method} \alias{[<-,mpfrArray,matrix,missing,ANY-method} \alias{[<-,mpfrArray,matrix,missing,mpfr-method} % \alias{[,mpfrArray,ANY,ANY,ANY-method} \alias{[,mpfrArray,ANY,missing,missing-method} \alias{[,mpfrArray,matrix,missing,missing-method} \alias{\%*\%,Mnumber,mpfr-method} \alias{\%*\%,mpfrMatrix,mpfr-method} \alias{\%*\%,mpfrMatrix,mpfrMatrix-method} \alias{\%*\%,mpfr,Mnumber-method} \alias{\%*\%,mpfr,mpfr-method} \alias{\%*\%,mpfr,mpfrMatrix-method} \alias{crossprod,mpfr,missing-method} \alias{crossprod,mpfrMatrix,mpfr-method} \alias{crossprod,mpfrMatrix,mpfrMatrix-method} \alias{crossprod,mpfr,Mnumber-method} \alias{crossprod,mpfr,mpfr-method} \alias{crossprod,mpfr,mpfrMatrix-method} \alias{crossprod,Mnumber,mpfr-method} \alias{tcrossprod,mpfr,missing-method} \alias{tcrossprod,mpfrMatrix,mpfr-method} \alias{tcrossprod,mpfrMatrix,mpfrMatrix-method} \alias{tcrossprod,mpfr,Mnumber-method} \alias{tcrossprod,mpfr,mpfr-method} \alias{tcrossprod,mpfr,mpfrMatrix-method} \alias{tcrossprod,Mnumber,mpfr-method} \alias{dim,mpfrArray-method} \alias{dimnames<-,mpfrArray-method} \alias{dimnames,mpfrArray-method} \alias{norm,ANY,missing-method} \alias{norm,mpfrMatrix,character-method} \alias{show,mpfrArray-method} \alias{sign,mpfrArray-method} \alias{t,mpfrMatrix-method} \alias{aperm,mpfrArray-method} % \description{The classes \code{"mpfrMatrix"} and \code{"mpfrArray"} are, analogously to the \pkg{base} \code{\link{matrix}} and \code{\link{array}} functions and classes simply \dQuote{numbers} of class \code{\linkS4class{mpfr}} with an additional \code{Dim} and \code{Dimnames} slot. } \section{Objects from the Class}{ Objects should typically be created by \code{\link{mpfrArray}()}, but can also be created by \code{new("mpfrMatrix", ...)} or \code{new("mpfrArray", ...)}, or also by \code{t(x)}, \code{dim(x) <- dd}, or \code{\link{mpfr2array}(x, dim=dd)} where \code{x} is a an \code{\linkS4class{mpfr}} \dQuote{number vector}. A (slightly more flexible) alternative to \code{dim(x) <- dd} is \code{\link{mpfr2array}(x, dd, dimnames)}. } \section{Slots}{ \describe{ \item{\code{.Data}:}{as for the \code{\linkS4class{mpfr}} class, a \code{"list"} of \code{\linkS4class{mpfr1}} numbers.} \item{\code{Dim}:}{of class \code{"integer"}, specifying the array dimension.} \item{\code{Dimnames}:}{of class \code{"list"} and the same length as \code{Dim}, each list component either \code{\link{NULL}} or a \code{\link{character}} vector of length \code{Dim[j]}.} } } \section{Extends}{ Class \code{"mpfrMatrix"} extends \code{"mpfrArray"}, directly. Class \code{"mpfrArray"} extends class \code{"\linkS4class{mpfr}"}, by class "mpfrArray", distance 2; class \code{"\linkS4class{list}"}, by class "mpfrArray", distance 3; class \code{"\linkS4class{vector}"}, by class "mpfrArray", distance 4. } \section{Methods}{ \describe{ \item{Arith}{\code{signature(e1 = "mpfr", e2 = "mpfrArray")}: ... } \item{Arith}{\code{signature(e1 = "numeric", e2 = "mpfrArray")}: ... } \item{Arith}{\code{signature(e1 = "mpfrArray", e2 = "mpfrArray")}: ... } \item{Arith}{\code{signature(e1 = "mpfrArray", e2 = "mpfr")}: ... } \item{Arith}{\code{signature(e1 = "mpfrArray", e2 = "numeric")}: ... } \item{as.vector}{\code{signature(x = "mpfrArray", mode = "missing")}: drops the dimension \sQuote{attribute}, i.e., transforms \code{x} into a simple \code{\linkS4class{mpfr}} vector. This is an inverse of \code{t(.)} or \code{dim(.) <- *} on such a vector.} \item{atan2}{\code{signature(y = "ANY", x = "mpfrArray")}: ... } \item{atan2}{\code{signature(y = "mpfrArray", x = "mpfrArray")}: ... } \item{atan2}{\code{signature(y = "mpfrArray", x = "ANY")}: ... } \item{[<-}{\code{signature(x = "mpfrArray", i = "ANY", j = "ANY", value = "ANY")}: ... } \item{[}{\code{signature(x = "mpfrArray", i = "ANY", j = "ANY", drop = "ANY")}: ... } \item{[}{\code{signature(x = "mpfrArray", i = "ANY", j = "missing", drop = "missing")}: \code{"mpfrArray"}s can be subset (\dQuote{indexed}) as regular \R \code{\link{array}}s.} \item{\%*\%}{\code{signature(x = "mpfr", y = "mpfrMatrix")}: Compute the matrix/vector product \eqn{x y} when the dimensions (\code{\link{dim}}) of \code{x} and \code{y} match. If \code{x} is not a matrix, it is treated as a 1-row or 1-column matrix (aka \dQuote{row vector} or \dQuote{column vector}) depending on which one makes sense, see the documentation of the \pkg{base} function \code{\link[base:matmult]{\%*\%}}.} \item{\%*\%}{\code{signature(x = "mpfr", y = "Mnumber")}: method definition for cases with one \code{\linkS4class{mpfr}} and any \dQuote{number-like} argument are to use MPFR arithmetic as well.} \item{\%*\%}{\code{signature(x = "mpfrMatrix", y = "mpfrMatrix")},} \item{\%*\%}{\code{signature(x = "mpfrMatrix", y = "mpfr")}, etc. Further method definitions with identical semantic.} \item{crossprod}{\code{signature(x = "mpfr", y = "missing")}: Computes \eqn{x'x}, i.e., \code{t(x) \%*\% x}, typically more efficiently.} \item{crossprod}{\code{signature(x = "mpfr", y = "mpfrMatrix")}: Computes \eqn{x'y}, i.e., \code{t(x) \%*\% y}, typically more efficiently.} \item{crossprod}{\code{signature(x = "mpfrMatrix", y = "mpfrMatrix")}: ... } \item{crossprod}{\code{signature(x = "mpfrMatrix", y = "mpfr")}: ... } \item{tcrossprod}{\code{signature(x = "mpfr", y = "missing")}: Computes \eqn{xx'}, i.e., \code{x \%*\% t(x)}, typically more efficiently.} \item{tcrossprod}{\code{signature(x = "mpfrMatrix", y = "mpfrMatrix")}: Computes \eqn{xy'}, i.e., \code{x \%*\% t(y)}, typically more efficiently.} \item{tcrossprod}{\code{signature(x = "mpfrMatrix", y = "mpfr")}: ... } \item{tcrossprod}{\code{signature(x = "mpfr", y = "mpfrMatrix")}: ... } \item{coerce}{\code{signature(from = "mpfrArray", to = "array")}: coerces \code{from} to a \emph{numeric} array of the same dimension.} \item{coerce}{\code{signature(from = "mpfrArray", to = "vector")}: as for standard \code{\link{array}}s, this \dQuote{drops} the \code{dim} (and \code{dimnames}), i.e., returns an \code{\linkS4class{mpfr}} vector.} \item{Compare}{\code{signature(e1 = "mpfr", e2 = "mpfrArray")}: ... } \item{Compare}{\code{signature(e1 = "numeric", e2 = "mpfrArray")}: ... } \item{Compare}{\code{signature(e1 = "mpfrArray", e2 = "mpfr")}: ... } \item{Compare}{\code{signature(e1 = "mpfrArray", e2 = "numeric")}: ... } \item{dim}{\code{signature(x = "mpfrArray")}: ... } \item{dimnames<-}{\code{signature(x = "mpfrArray")}: ... } \item{dimnames}{\code{signature(x = "mpfrArray")}: ... } \item{show}{\code{signature(object = "mpfrArray")}: ... } \item{sign}{\code{signature(x = "mpfrArray")}: ... } \item{norm}{\code{signature(x = "mpfrMatrix", type = "character")}: computes the matrix norm of \code{x}, see \code{\link[base]{norm}} or the one in package \pkg{Matrix}.} \item{t}{\code{signature(x = "mpfrMatrix")}: tranpose the mpfrMatrix.} \item{aperm}{\code{signature(a = "mpfrArray")}: \code{aperm(a, perm)} is a generalization of \code{t(.)} to \emph{perm}ute the dimensions of an mpfrArray; it has the same semantics as the standard \code{\link{aperm}()} method for simple \R \code{\link{array}}s.} } } \author{Martin Maechler} \seealso{ \code{\link{mpfrArray}}, also for more examples. } \examples{ showClass("mpfrMatrix") validObject(mm <- new("mpfrMatrix")) validObject(aa <- new("mpfrArray")) v6 <- mpfr(1:6, 128) m6 <- new("mpfrMatrix", v6, Dim = c(2L, 3L)) validObject(m6) m6 which(m6 == 3, arr.ind = TRUE) # |--> (1, 2) ## Coercion back to "vector": Both of these work: stopifnot(identical(as(m6, "mpfr"), v6), identical(as.vector(m6), v6)) # < but this is a "coincidence" S2 <- m6[,-3] # 2 x 2 S3 <- rbind(m6, c(1:2,10)) ; s3 <- asNumeric(S3) det(S2) str(determinant(S2)) det(S3) stopifnot(all.equal(det(S2), det(asNumeric(S2)), tol=1e-15), all.equal(det(S3), det(s3), tol=1e-15)) ## 2-column matrix indexing and replacement: (sS <- S3[i2 <- cbind(1:2, 2:3)]) stopifnot(identical(asNumeric(sS), s3[i2])) C3 <- S3; c3 <- s3 C3[i2] <- 10:11 c3[i2] <- 10:11 stopifnot(identical(asNumeric(C3), c3)) AA <- new("mpfrArray", as.vector(cbind(S3, -S3)), Dim=c(3L,3:2)) stopifnot(identical(AA[,,1] , S3), identical(AA[,,2] , -S3)) aa <- asNumeric(AA) i3 <- cbind(3:1, 1:3, c(2L, 1:2)) ii3 <- Rmpfr:::.mat2ind(i3, dim(AA), dimnames(AA)) stopifnot(aa[i3] == new("mpfr", getD(AA)[ii3])) stopifnot(identical(aa[i3], asNumeric(AA[i3]))) CA <- AA; ca <- aa ca[i3] <- ca[i3] ^ 3 CA[i3] <- CA[i3] ^ 3 ## scale(): S2. <- scale(S2) stopifnot(all.equal(abs(as.vector(S2.)), rep(sqrt(1/mpfr(2, 128)), 4), tol = 1e-30)) ## norm() : norm(S2) stopifnot(identical(norm(S2), norm(S2, "1")), norm(S2, "I") == 6, norm(S2, "M") == 4, abs(norm(S2, "F") - 5.477225575051661) < 1e-15) } \keyword{classes} Rmpfr/man/factorialMpfr.Rd0000644000176200001440000000341512561376373015213 0ustar liggesusers\name{factorialMpfr} \alias{factorialMpfr} \title{Factorial 'n!' in Arbitrary Precision} \description{ Efficiently compute \eqn{n!} in arbitrary precision, using the MPFR-internal implementation. This is mathematically (but not numerically) the same as \eqn{\Gamma(n+1)}{Gamma(n+1)}. %% FIXME: factorialZ() is not yet *vectorized* __ FIXME ___ \code{\link[gmp]{factorialZ}} (package \pkg{gmp}) should typically be used \emph{instead} of \code{factorialMpfr()} nowadays. Hence, \code{factorialMpfr} now is somewhat \bold{deprecated}. } \usage{ factorialMpfr(n, precBits = max(2, ceiling(lgamma(n+1)/log(2))), rnd.mode = c("N","D","U","Z","A")) } \arguments{ \item{n}{non-negative integer (vector).} \item{precBits}{desired precision in bits (\dQuote{binary digits}); the default sets the precision high enough for the result to be \emph{exact}.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see \code{\link{mpfr}}.} } \value{ a number of (S4) class \code{\linkS4class{mpfr}}. } \seealso{ \code{\link{factorial}} and \code{\link{gamma}} in base \R. \code{\link[gmp]{factorialZ}} (package \pkg{gmp}), to \emph{replace} \code{factorialMpfr}, see above. \code{chooseMpfr()} and \code{\link{pochMpfr}()} (on the same page). } \examples{ factorialMpfr(200) n <- 1000:1010 f1000 <- factorialMpfr(n) stopifnot(1e-15 > abs(as.numeric(1 - lfactorial(n)/log(f1000)))) ## Note that---astonishingly--- measurements show only ## *small* efficiency gain of ~ 10\% : over using the previous "technique" system.time(replicate(8, f1e4 <- factorialMpfr(10000))) system.time(replicate(8, f.1e4 <- factorial(mpfr(10000, prec=1+lfactorial(10000)/log(2))))) } \keyword{arith} Rmpfr/man/pbetaI.Rd0000644000176200001440000001334114245753567013632 0ustar liggesusers\name{pbetaI} \alias{pbetaI} \title{Accurate Incomplete Beta / Beta Probabilities For Integer Shapes} \description{ For integers \eqn{a}, \eqn{b}, \eqn{I_x(a,b)}{I(x; a,b)} aka \code{pbeta(x, a,b)} is a polynomial in x with rational coefficients, and hence arbitarily accurately computable. TODO (\emph{not yet}): It's sufficient for \emph{one} of \eqn{a,b} to be integer such that the result is a \emph{finite sum} (but the coefficients will no longer be rational, see Abramowitz and Stegun, 26.5.6 and *.7, p.944). % \url{https://personal.math.ubc.ca/~cbm/aands/page_944.htm} } \usage{%% code --> ../R/special-fun.R pbetaI(q, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE, precBits = NULL, useRational = !log.p && !is.mpfr(q) && is.null(precBits) && int2, rnd.mode = c("N","D","U","Z","A")) } \arguments{ \item{q}{called \eqn{x}, above; vector of quantiles, in \eqn{[0,1]}; can be \code{\link{numeric}}, or of class \code{"\link{mpfr}"} or also \code{"\link[gmp]{bigq}"} (\dQuote{big rational} from package \CRANpkg{gmp}); in the latter case, if \code{log.p = FALSE} as by default, \emph{all computations} are exact, using big rational arithmetic.} \item{shape1, shape2}{the positive Beta \dQuote{shape} parameters, called \eqn{a, b}, above. \bold{Must} be integer valued for this function.} \item{ncp}{unused, only for compatibility with \code{\link{pbeta}}, must be kept at its default, 0.} \item{lower.tail}{logical; if TRUE (default), probabilities are \eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.} \item{log.p}{logical; if TRUE, probabilities p are given as log(p).} \item{precBits}{the precision (in number of bits) to be used in \code{\link{sumBinomMpfr}()}.} \item{useRational}{optional \code{\link{logical}}, specifying if we should try to do everything in exact \emph{rational arithmetic}, i.e, using package \CRANpkg{gmp} functionality only, and return \code{\link{bigq}} numbers instead of \code{\link{mpfr}} numbers.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see \code{\link{mpfr}}.} } \value{ an \code{"\linkS4class{mpfr}"} vector of the same length as \code{q}. } \note{For upper tail probabilities, i.e., when \code{lower.tail=FALSE}, we may need large \code{precBits}, because the implicit or explicit \eqn{1 - P} computation suffers from severe cancellation. %% FIXME: Indeed, we may want to %% 1) determine a smart default precBits there %% 2) produce a warning when cancellation is in the same order as precBits } \references{ Abramowitz, M. and Stegun, I. A. (1972) \emph{Handbook of Mathematical Functions}. New York: Dover. \url{https://en.wikipedia.org/wiki/Abramowitz_and_Stegun} provides links to the full text which is in public domain. } \author{Martin Maechler} \seealso{ \code{\link{pbeta}}, \code{\link{sumBinomMpfr}} \code{\link[gmp]{chooseZ}}. } \examples{ x <- (0:12)/16 # not all the way up .. a <- 7; b <- 788 p. <- pbetaI(x, a, b) ## a bit slower: system.time( pp <- pbetaI(x, a, b, precBits = 2048) ) # 0.23 -- 0.50 sec ## Currently, the lower.tail=FALSE are computed "badly": lp <- log(pp) ## = pbetaI(x, a, b, log.p=TRUE) lIp <- log1p(-pp) ## = pbetaI(x, a, b, lower.tail=FALSE, log.p=TRUE) Ip <- 1 - pp ## = pbetaI(x, a, b, lower.tail=FALSE) if(Rmpfr:::doExtras()) { ## somewhat slow stopifnot( all.equal(lp, pbetaI(x, a, b, precBits = 2048, log.p=TRUE)), all.equal(lIp, pbetaI(x, a, b, precBits = 2048, lower.tail=FALSE, log.p=TRUE), tol = 1e-230), all.equal( Ip, pbetaI(x, a, b, precBits = 2048, lower.tail=FALSE)) ) } rErr <- function(approx, true, eps = 1e-200) { true <- as.numeric(true) # for "mpfr" ifelse(Mod(true) >= eps, ## relative error, catching '-Inf' etc : ifelse(true == approx, 0, 1 - approx / true), ## else: absolute error (e.g. when true=0) true - approx) } rErr(pbeta(x, a, b), pp) rErr(pbeta(x, a, b, lower=FALSE), Ip) rErr(pbeta(x, a, b, log = TRUE), lp) rErr(pbeta(x, a, b, lower=FALSE, log = TRUE), lIp) a.EQ <- function(..., tol=1e-15) all.equal(..., tolerance=tol) stopifnot( a.EQ(pp, pbeta(x, a, b)), a.EQ(lp, pbeta(x, a, b, log.p=TRUE)), a.EQ(lIp, pbeta(x, a, b, lower.tail=FALSE, log.p=TRUE)), a.EQ( Ip, pbeta(x, a, b, lower.tail=FALSE)) ) ## When 'q' is a bigrational (i.e., class "bigq", package 'gmp'), everything ## is computed *exactly* with bigrational arithmetic: (q4 <- as.bigq(1, 2^(0:4))) pb4 <- pbetaI(q4, 10, 288, lower.tail=FALSE) stopifnot( is.bigq(pb4) ) mpb4 <- as(pb4, "mpfr") mpb4[1:2] getPrec(mpb4) # 128 349 1100 1746 2362 (pb. <- pbeta(asNumeric(q4), 10, 288, lower.tail=FALSE)) stopifnot(mpb4[1] == 0, all.equal(mpb4, pb., tol=4e-15)) qbetaI. <- function(p, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE, precBits = NULL, rnd.mode = c("N", "D", "U", "Z", "A"), tolerance = 1e-20, ...) { if(is.na(a <- as.integer(shape1))) stop("a = shape1 is not coercable to finite integer") if(is.na(b <- as.integer(shape2))) stop("b = shape2 is not coercable to finite integer") unirootR(function(q) pbetaI(q, a, b, lower.tail=lower.tail, log.p=log.p, precBits=precBits, rnd.mode=rnd.mode) - p, interval = if(log.p) c(-double.xmax, 0) else 0:1, tol = tolerance, ...) } # end{qbetaI} (p <- 1 - mpfr(1,128)/20) # 'p' must be high precision q95.1.3 <- qbetaI.(p, 1,3, tolerance = 1e-29) # -> ~29 digits accuracy str(q95.1.3) ; roundMpfr(q95.1.3$root, precBits = 29 * log2(10)) ## relative error is really small: (relE <- asNumeric(1 - pbetaI(q95.1.3$root, 1,3) / p)) stopifnot(abs(relE) < 1e-28) }%examples \keyword{arith} \keyword{distribution} Rmpfr/man/fr_ld_expMpfr.Rd0000644000176200001440000000475414365314231015205 0ustar liggesusers\name{frexpMpfr} \alias{frexpMpfr} \alias{ldexpMpfr} \title{Base-2 Representation and Multiplication of Mpfr Numbers}% ../DPQ/man/fr_ld_exp.Rd \description{ MPFR - versions of the C99 (and POSIX) standard C (and C++) mathlib functions \code{frexp()} and \code{ldexp()}. \code{frexpMpfr(x)} computes base-2 exponent \code{e} and \dQuote{mantissa}, or \emph{fraction} \code{r}, such that \eqn{x = r * 2^e}, where \eqn{r \in [0.5, 1)} (unless when \code{x} is in \code{c(0, -Inf, Inf, NaN)} where \code{r == x} and \code{e} is 0), and \eqn{e} is integer valued. \code{ldexpMpfr(f, E)} is the \emph{inverse} of \code{frexpMpfr()}: Given fraction or mantissa \code{f} and integer exponent \code{E}, it returns \eqn{x = f * 2^E}. Viewed differently, it's the fastest way to multiply or divide MPFR numbers with \eqn{2^E}. } \usage{ frexpMpfr(x, rnd.mode = c("N", "D", "U", "Z", "A")) ldexpMpfr(f, E, rnd.mode = c("N", "D", "U", "Z", "A")) } \arguments{ \item{x}{numeric (coerced to \code{double}) vector.} \item{f}{numeric fraction (vector), in \eqn{[0.5, 1)}.} \item{E}{integer valued, exponent of \code{2}, i.e., typically in \code{(-1024-50):1024}, otherwise the result will underflow to 0 or overflow to \code{+/- Inf}.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see \code{\link{mpfr}}.} } %% \details{ %% } \value{ \code{frexpMpfr} returns a \code{\link{list}} with named components \code{r} (of class \code{mpfr}) and \code{e} (integer valued, of type \code{integer} is small enough, \code{"double"} otherwise). } \references{ On unix-alikes, typically \command{man frexp} and \command{man ldexp} } \author{Martin Maechler} \seealso{ Somewhat related, \code{\link{.mpfr2exp}()}. \code{\link[DPQ]{frexp}()} and \code{ldexp()} in package \CRANpkg{DPQ}. } \examples{ set.seed(47) x <- c(0, 2^(-3:3), (-1:1)/0, sort(rlnorm(2^12, 10, 20) * sample(c(-1,1), 512, replace=TRUE))) head(xM <- mpfr(x, 128), 11) str(rFM <- frexpMpfr(xM)) d.fr <- with(rFM, data.frame(x=x, r=asNumeric(r), e=e)) head(d.fr , 16) tail(d.fr) ar <- abs(rFM$r) stopifnot(0.5 <= ar[is.finite(x) & x != 0], ar[is.finite(x)] < 1, is.integer(rFM$e)) ldx <- with(rFM, ldexpMpfr(r, e)) (iN <- which(is.na(x))) # 10 stopifnot(exprs = { all.equal(xM, ldx, tol = 2^-124) # allow 4 bits loss, but apart from the NA, even: identical(xM[-iN], ldx[-iN]) is.na(xM [iN]) is.na(ldx[iN]) }) } \keyword{arithmetic} \keyword{utilities} Rmpfr/man/igamma.Rd0000644000176200001440000000465214371453423013652 0ustar liggesusers\name{igamma} \alias{igamma} \title{Incomplete Gamma Function} \description{% >> ../R/special-fun.R <<< For MPFR version >= 3.2.0, the following MPFR library function is provided: \code{mpfr_gamma_inc(a,x)}, the \R interface of which is \code{igamma(a,x)}, where \code{igamma(a,x)} is the \dQuote{upper} incomplete gamma function %% fails in LaTeX (R "bug"): \deqn{γ(a,x) :=: Γ(a) - Γ(a,x),} \deqn{\Gamma(a,x) :=: \Gamma(a) - \gamma(a,x),}{Γ(a,x) :=: Γ(a) - γ(a,x),} where \deqn{\gamma(a,x) := \int_0^x t^{a-1} e^{-t} dt,}{γ(a,x) := ∫₀ˣ tᵃâ»Â¹ eâ»áµ— dt,} and hence \deqn{\Gamma(a,x) := \int_x^\infty t^{a-1} e^{-t} dt,}{Γ(a,x) := ∫ (x..∞) tᵃâ»Â¹ eâ»áµ— dt,} and \deqn{\Gamma(a) := \gamma(a, \infty).}{Γ(a) := γ(a, ∞).} As \R's \code{\link{pgamma}(x,a)} is \deqn{\code{pgamma(x, a)} := \gamma(a,x) / \Gamma(a),}{\code{pgamma(x, a)} := γ(a,x) / Γ(a),} we get \preformatted{ igamma(a,x) == gamma(a) * pgamma(x, a, lower.tail=FALSE)} } \usage{ igamma(a, x, rnd.mode = c("N", "D", "U", "Z", "A")) } %% MM FIXME: "Copy paste" from hypot() -- which strangely we have in >> ./mpfr-class.Rd << \arguments{ \item{a, x}{an object of class \code{mpfr} or \code{\link{numeric}}.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see \code{\link{mpfr}}.} } %% \details{ %% } \value{ a numeric vector of \dQuote{common length}, recyling along \code{a} and \code{x}. } \references{ NIST Digital Library of Mathematical Functions, section 8.2. \url{https://dlmf.nist.gov/8.2.i} Wikipedia (2019). \emph{Incomplete gamma function}; \url{https://en.wikipedia.org/wiki/Incomplete_gamma_function} %% .. arXiv paper TODO % see --> ../TODO } \author{\R interface: Martin Maechler} \seealso{ \R's \code{\link{gamma}} (function) and \code{\link{pgamma}} (probability distribution). } \examples{ ## show how close pgamma() is : x <- c(seq(0,20, by=1/4), 21:50, seq(55, 100, by=5)) if(mpfrVersion() >= "3.2.0") { print( all.equal(igamma(Const("pi", 80), x), pgamma(x, pi, lower.tail=FALSE) * gamma(pi), tol=0, formatFUN = function(., ...) format(., digits = 7)) #-> 2.75e-16 (was 3.13e-16) ) ## and ensure *some* closeness: stopifnot(exprs = { all.equal(igamma(Const("pi", 80), x), pgamma(x, pi, lower.tail=FALSE) * gamma(pi), tol = 1e-15) }) } # only if MPFR version >= 3.2.0 } \keyword{math} Rmpfr/man/is.whole.Rd0000644000176200001440000000207011754461676014152 0ustar liggesusers\name{is.whole} \alias{is.whole.mpfr} \title{Whole ("Integer") Numbers} \description{ Check which elements of \code{x[]} are integer valued aka \dQuote{whole} numbers,including MPFR numbers (class \code{\linkS4class{mpfr}}). } \usage{ \S3method{is.whole}{mpfr}(x) } \arguments{ \item{x}{any \R vector, here of \code{\link{class}} \code{\linkS4class{mpfr}}.} } \value{ logical vector of the same length as \code{x}, indicating where \code{x[.]} is integer valued. } \author{Martin Maechler} \seealso{ \code{\link{is.integer}(x)} (\pkg{base} package) checks for the \emph{internal} mode or class, not if \code{x[i]} are integer valued. The \code{\link[gmp]{is.whole}()} methods in package \pkg{gmp}. } \examples{ is.integer(3) # FALSE, it's internally a double is.whole(3) # TRUE x <- c(as(2,"mpfr") ^ 100, 3, 3.2, 1000000, 2^40) is.whole(x) # one FALSE, only \dontshow{ xt <- c(x, as.bigz(2)^120, as.bigq(3,1:3)) stopifnot(identical(is.whole(x), (1:5)!=3), is(xt, "mpfr"), identical(is.whole(xt), is.na(match(1:9, c(3,8))))) }%dont } \keyword{math} Rmpfr/man/Bernoulli.Rd0000644000176200001440000000327013735036657014356 0ustar liggesusers\name{Bernoulli} \alias{Bernoulli} \title{Bernoulli Numbers in Arbitrary Precision} \description{ Computes the Bernoulli numbers in the desired (binary) precision. The computation happens via the \code{\link{zeta}} function and the formula \deqn{B_k = -k \zeta(1 - k),} and hence the only non-zero odd Bernoulli number is \eqn{B_1 = +1/2}. (Another tradition defines it, equally sensibly, as \eqn{-1/2}.) } \usage{ Bernoulli(k, precBits = 128) } \arguments{ \item{k}{non-negative integer vector} \item{precBits}{the precision in \emph{bits} desired.} } \value{ an \code{\linkS4class{mpfr}} class vector of the same length as \code{k}, with i-th component the \code{k[i]}-th Bernoulli number. } \references{\url{https://en.wikipedia.org/wiki/Bernoulli_number} } \author{Martin Maechler} \seealso{\code{\link{zeta}} is used to compute them. The next version of package \CRANpkg{gmp} is to contain %\code{\link[gmp]{BernoulliQ}()} \code{BernoulliQ()}, providing exact Bernoulli numbers as big rationals (class \code{"bigq"}). } \examples{ \dontshow{sessionInfo() .libPaths() packageDescription("gmp")} Bernoulli(0:10) plot(as.numeric(Bernoulli(0:15)), type = "h") curve(-x*zeta(1-x), -.2, 15.03, n=300, main = expression(-x \%.\% zeta(1-x))) legend("top", paste(c("even","odd "), "Bernoulli numbers"), pch=c(1,3), col=2, pt.cex=2, inset=1/64) abline(h=0,v=0, lty=3, col="gray") k <- 0:15; k[1] <- 1e-4 points(k, -k*zeta(1-k), col=2, cex=2, pch=1+2*(k\%\%2)) ## They pretty much explode for larger k : k2 <- 2*(1:120) plot(k2, abs(as.numeric(Bernoulli(k2))), log = "y") title("Bernoulli numbers exponential growth") Bernoulli(10000)# - 9.0494239636 * 10^27677 } \keyword{arith} Rmpfr/man/gmp-conversions.Rd0000644000176200001440000000537714552770112015553 0ustar liggesusers\name{gmp-conversions} \title{Conversion Utilities gmp <-> Rmpfr} \alias{.bigq2mpfr} \alias{.bigz2mpfr} \alias{.mpfr2bigz} \alias{.mpfr2bigq} \alias{coerce,bigq,mpfr-method} \alias{coerce,bigz,mpfr-method} \description{ Coerce from and to big integers (\code{\link[gmp]{bigz}}) and \code{\link{mpfr}} numbers. Further, coerce from big rationals (\code{\link[gmp]{bigq}}) to \code{\link{mpfr}} numbers. } \usage{ .bigz2mpfr(x, precB = NULL, rnd.mode = c('N','D','U','Z','A')) .bigq2mpfr(x, precB = NULL, rnd.mode = c('N','D','U','Z','A')) .mpfr2bigz(x, mod = NA) .mpfr2bigq(x) }% TODO as(x, "mpfr") \arguments{ \item{x}{an \R object of class \code{bigz}, \code{bigq} or \code{mpfr} respectively.} \item{precB}{precision in bits for the result. The default, \code{NULL}, means to use the \emph{minimal} precision necessary for correct representation.} \item{rnd.mode}{a 1-letter string specifying how \emph{rounding} should happen at C-level conversion to MPFR, see details of \code{\link{mpfr}}.} \item{mod}{a possible modulus, see \code{\link[gmp]{as.bigz}} in package \pkg{gmp}.} } \details{ Note that we also provide the natural (S4) coercions, \code{as(x, "mpfr")} for \code{x} inheriting from class \code{"bigz"} or \code{"bigq"}. } \value{ a numeric vector of the same length as \code{x}, of the desired class. } \seealso{ \code{\link{mpfr}()}, \code{\link[gmp]{as.bigz}} and \code{\link[gmp]{as.bigq}} in package \pkg{gmp}. } \examples{ S <- gmp::Stirling2(50,10) show(S) SS <- S * as.bigz(1:3)^128 stopifnot(all.equal(log2(SS[2]) - log2(S), 128, tolerance=1e-15), identical(SS, .mpfr2bigz(.bigz2mpfr(SS)))) .bigz2mpfr(S) # 148 bit precision .bigz2mpfr(S, precB=256) # 256 bit ## rational --> mpfr: sq <- SS / as.bigz(2)^100 MP <- as(sq, "mpfr") stopifnot(identical(MP, .bigq2mpfr(sq)), SS == MP * as(2, "mpfr")^100) ## New since 2024-01-20: mpfr --> big rational "bigq" Pi <- Const("pi", 128) m <- Pi* 2^(-5:5) (m <- c(m, mpfr(2, 128)^(-5:5))) getDenom <- Rmpfr:::getDenom stopifnot(is.whole(m * (d.m <- getDenom(m)))) stopifnot(all.equal(m, mpfr(.mpfr2bigq(m), 130), tolerance = 2^-130)) # I see even all.equal(m, mpfr(.mpfr2bigq(m), 130), tolerance = 0) # TRUE m <- m * mpfr(2, 128)^200 # quite a bit larger stopifnot(is.whole(m * (d.m <- getDenom(m)))) stopifnot(all.equal(m, mpfr(.mpfr2bigq(m), 130), tolerance = 2^-130)) # I see even all.equal(m, mpfr(.mpfr2bigq(m), 130), tolerance = 0) # TRUE m2 <- m * mpfr(2, 128)^20000 ## really huge stopifnot(is.whole(m2 * (d.m2 <- getDenom(m2)))) stopifnot(all.equal(m2, mpfr(.mpfr2bigq(m2), 130), tolerance = 2^-130)) # I see even all.equal(m2, mpfr(.mpfr2bigq(m2), 130), tolerance = 0) # TRUE } \keyword{arith}% <- or better ? Rmpfr/man/unirootR.Rd0000644000176200001440000002141014275412624014230 0ustar liggesusers\name{unirootR} \alias{unirootR} \title{One Dimensional Root (Zero) Finding -- in pure \R} \usage{ unirootR(f, interval, \dots, lower = min(interval), upper = max(interval), f.lower = f(lower, ...), f.upper = f(upper, ...), extendInt = c("no", "yes", "downX", "upX"), trace = 0, verbose = as.logical(trace), verbDigits = max(3, min(20, -log10(tol)/2)), tol = .Machine$double.eps^0.25, maxiter = 1000L, check.conv = FALSE, warn.no.convergence = !check.conv, epsC = NULL) } \arguments{% base R : ~/R/D/r-devel/R/src/library/stats/man/uniroot.Rd \item{f}{the function for which the root is sought.} \item{interval}{a vector containing the end-points of the interval to be searched for the root.} \item{\dots}{additional named or unnamed arguments to be passed to \code{f}} \item{lower, upper}{the lower and upper end points of the interval to be searched.} \item{f.lower, f.upper}{the same as \code{f(upper)} and \code{f(lower)}, respectively. Passing these values from the caller where they are often known is more economical as soon as \code{f()} contains non-trivial computations.} \item{extendInt}{character string specifying if the interval \code{c(lower,upper)} should be extended or directly produce an error when \code{f()} does not have differing signs at the endpoints. The default, \code{"no"}, keeps the search interval and hence produces an error. Can be abbreviated.} \item{trace}{integer number; if positive, tracing information is produced. Higher values giving more details.} \item{verbose}{logical (or integer) indicating if (and how much) verbose output should be produced during the iterations.} \item{verbDigits}{used only if \code{verbose} is true, indicates the number of digits numbers should be printed with, using \code{\link{format}(., digits=verbDigits)}.} \item{tol}{the desired accuracy (convergence tolerance).} \item{maxiter}{the maximum number of iterations.} \item{check.conv}{logical indicating whether non convergence should be caught as an error, notably non-convergence in \code{maxiter} iterations should be an error instead of a warning.} \item{warn.no.convergence}{if set to \code{FALSE} there's no warning about non-convergence. Useful to just run a few iterations.} \item{epsC}{positive number or \code{NULL} in which case a smart default is sought. This should specify the \dQuote{achievable machine precision} \emph{for} the given numbers and their arithmetic. The default will set this to \code{\link{.Machine}$double.eps} for double precision numbers, and will basically use \code{2 ^ - min(getPrec(f.lower), getPrec(f.upper))} when that works (as, e.g., for \code{\linkS4class{mpfr}}-numbers) otherwise. This is factually a lower bound for the achievable lower bound, and hence, setting \code{tol} smaller than \code{epsC} is typically non-sensical and produces a warning. } } \description{ The function \code{unirootR} searches the interval from \code{lower} to \code{upper} for a root (i.e., zero) of the function \code{f} with respect to its first argument. \code{unirootR()} is \dQuote{clone} of \code{\link{uniroot}()}, written entirely in \R, in a way that it works with \code{\linkS4class{mpfr}}-numbers as well. } \details{ Note that arguments after \code{\dots} must be matched exactly. Either \code{interval} or both \code{lower} and \code{upper} must be specified: the upper endpoint must be strictly larger than the lower endpoint. The function values at the endpoints must be of opposite signs (or zero), for \code{extendInt="no"}, the default. Otherwise, if \code{extendInt="yes"}, the interval is extended on both sides, in search of a sign change, i.e., until the search interval \eqn{[l,u]} satisfies \eqn{f(l) \cdot f(u) \le 0}{f(l) * f(u) <= 0}. If it is \emph{known how} \eqn{f} changes sign at the root \eqn{x_0}{x0}, that is, if the function is increasing or decreasing there, \code{extendInt} can (and typically should) be specified as \code{"upX"} (for \dQuote{upward crossing}) or \code{"downX"}, respectively. Equivalently, define \eqn{S := \pm 1}{S:= +/- 1}, to require \eqn{S = \mathrm{sign}(f(x_0 + \epsilon))}{S = sign(f(x0 + eps))} at the solution. In that case, the search interval \eqn{[l,u]} possibly is extended to be such that \eqn{S\cdot f(l)\le 0}{% S * f(l) <= 0} and \eqn{S \cdot f(u) \ge 0}{S * f(u) >= 0}. The function only uses \R code with basic arithmetic, such that it should also work with \dQuote{generalized} numbers (such as \code{\linkS4class{mpfr}}-numbers) as long the necessary \code{\link{Ops}} methods are defined for those. The underlying algorithm assumes a continuous function (which then is known to have at least one root in the interval). Convergence is declared either if \code{f(x) == 0} or the change in \code{x} for one step of the algorithm is less than \code{tol} (plus an allowance for representation error in \code{x}). If the algorithm does not converge in \code{maxiter} steps, a warning is printed and the current approximation is returned. \code{f} will be called as \code{f(\var{x}, ...)} for a (generalized) numeric value of \var{x}. } \value{ A list with four components: \code{root} and \code{f.root} give the location of the root and the value of the function evaluated at that point. \code{iter} and \code{estim.prec} give the number of iterations used and an approximate estimated precision for \code{root}. (If the root occurs at one of the endpoints, the estimated precision is \code{NA}.) } \source{ Based on \code{zeroin()} (in package \pkg{rootoned}) by John Nash who manually translated the C code in \R's \code{zeroin.c} and on \code{\link{uniroot}()} in \R's sources. } \references{ Brent, R. (1973), see \code{\link{uniroot}}. } \seealso{ \R's own (\pkg{stats} package) \code{\link{uniroot}}. \code{\link{polyroot}} for all complex roots of a polynomial; \code{\link{optimize}}, \code{\link{nlm}}. } \examples{ require(utils) # for str ## some platforms hit zero exactly on the first step: ## if so the estimated precision is 2/3. f <- function (x,a) x - a str(xmin <- unirootR(f, c(0, 1), tol = 0.0001, a = 1/3)) ## handheld calculator example: fixpoint of cos(.): rc <- unirootR(function(x) cos(x) - x, lower=-pi, upper=pi, tol = 1e-9) rc$root ## the same with much higher precision: rcM <- unirootR(function(x) cos(x) - x, interval= mpfr(c(-3,3), 300), tol = 1e-40) rcM x0 <- rcM$root stopifnot(all.equal(cos(x0), x0, tol = 1e-40))## 40 digits accurate! str(unirootR(function(x) x*(x^2-1) + .5, lower = -2, upper = 2, tol = 0.0001), digits.d = 10) str(unirootR(function(x) x*(x^2-1) + .5, lower = -2, upper = 2, tol = 1e-10 ), digits.d = 10) ## A sign change of f(.), but not a zero but rather a "pole": tan. <- function(x) tan(x * (Const("pi",200)/180))# == tan( ) (rtan <- unirootR(tan., interval = mpfr(c(80,100), 200), tol = 1e-40)) ## finds 90 {"ok"}, and now gives a warning \dontshow{stopifnot(all.equal(rtan$root, 90, tolerance = 1e-38))} ## Find the smallest value x for which exp(x) > 0 (numerically): r <- unirootR(function(x) 1e80*exp(x)-1e-300, c(-1000,0), tol = 1e-15) str(r, digits.d = 15) ##> around -745, depending on the platform. exp(r$root) # = 0, but not for r$root * 0.999... minexp <- r$root * (1 - 10*.Machine$double.eps) exp(minexp) # typically denormalized ## --- using mpfr-numbers : ## Find the smallest value x for which exp(x) > 0 ("numerically"); ## Note that mpfr-numbers underflow *MUCH* later than doubles: ## one of the smallest mpfr-numbers {see also ?mpfr-class } : (ep.M <- mpfr(2, 55) ^ - ((2^30 + 1) * (1 - 1e-15))) r <- unirootR(function(x) 1e99* exp(x) - ep.M, mpfr(c(-1e20, 0), 200)) r # 97 iterations; f.root is very similar to ep.M ## interval extension 'extendInt' -------------- f1 <- function(x) (121 - x^2)/(x^2+1) f2 <- function(x) exp(-x)*(x - 12) tools::assertError(unirootR(f1, c(0,10)), verbose=TRUE) ##--> error: f() .. end points not of opposite sign ## where as 'extendInt="yes"' simply first enlarges the search interval: u1 <- unirootR(f1, c(0,10),extendInt="yes", trace=1) u2 <- unirootR(f2, mpfr(c(0,2), 128), extendInt="yes", trace=2, verbose=FALSE, tol = 1e-25) stopifnot(all.equal(u1$root, 11, tolerance = 1e-5), all.equal(u2$root, 12, tolerance = 1e-23)) ## The *danger* of interval extension: ## No way to find a zero of a positive function, but ## numerically, f(-|M|) becomes zero : u3 <- unirootR(exp, c(0,2), extendInt="yes", trace=TRUE) ## Nonsense example (must give an error): tools::assertCondition( unirootR(function(x) 1, 0:1, extendInt="yes"), "error", verbose=TRUE) } \keyword{optimize} Rmpfr/TODO0000644000176200001440000003240014411121562012024 0ustar liggesusers -*- org -*--> Emacs [Tab] key + [Org] menu; C-c C-o follows links * Very Short Term ** TODO 67) BUG: igamma() [incomplete gamma] always returns 53-bit ??????? ** TODO 61) Q: Why is quantile() so slow [hence summary() very slow!]? A: because sort() |--> rank() is so slow (in C code!) l2x <- seqMpfr(mpfr(4, 1024), 513, by=1/16) # 8000 numbers of 1024 bits system.time(ql2x <- quantile(l2x, names=FALSE)) # user: 10.735 (nb-mm5, Nov.2020) *** quantile() -> sort(*, partial=.) -> xtfrm.default() -> rank(l2x) is so slow *** Partial SOLUTION (not yet implemented): use is.unsorted(.) which is *fast* FALSE for sorted vetors (as 'l2x' above) ** TODO 55b) possibly more documentation on .mpfr* functions, e.g. .getSign(), at least *internally* (roxygen) ** TODO 31) Valgrind problems + leaks: Brian's e-mail 2014-06-19; ~/R/Pkgs/Rmpfr.Rcheck_valgrind/ ** TODO 11) format() method for "mpfr", "mpfrArray" (and hence "mpfrMatrix") which nicely and correctly *jointly* formats (for "mpfr") and aligns columns ! Then, formatDec() would be unnecessary. drop0trailing is not really sensible there. ** TODO 19) outer() now works always ? {as rep() now S3 dispatches ---> need systematic checks *AND* docu changes! ** TODO 17b) see 'Ops' in R/Arith.R , Rmpfr:::.Math.codes, and design a "test all Ops" with all combinations of "mpfr", "numeric","logical" (and possibly more). * Short or Mid Term *** TODO Split this section into Short | Mid (?) ** TODO 66) Improve pnorm(*, log.p=TRUE) using Abramowitz asymptotic formulas ==> 1st need Rmpfr'ified DPQ:pnormAsymp() Abramowitz and Stegun (1972), p.932, (26.2.12) and (26.2.13) see also ~/R/Pkgs/DPQ/vignettes/qnorm-asymp.Rnw *** TODO 66a) "mpfrify" pnormAsymp() and qnormAsymp() but in pkg {DPQmpfr} !! ** TODO 60) Should have *exact* as.bigq.mpfr(), i.e, "mpfr" --> "bigq". (R's "bigq" is C 'mpq') ** TODO 62) integrateR(): option 'all.sums=TRUE' --> R/integrate-Romberg.R *** Inside the GMP library, have # -- Function: void mpq_set_f (mpq_t ROP, const mpf_t OP) # Set ROP to the value of OP. There is no rounding, this conversion is exact. *** MPFR documents 'mpf2mpfr.h' after which you can compile any mpf_ program.. ** TODO 53) plogis() {and dlogis, qlogis} are "easy": do use /src/nmath/[dpq]logis.c, as they already use all the numerical tricks including R_Log1_Exp(x) .. : R_Log1_Exp(x) := ((x) > -M_LN2 ? log(-expm1(x)) : log1p(-exp(x))) ** TODO 54) zapsmall() would be nice, base::zapsmall() fails ** TODO 35) tests/bit-repr.R : Bits() fails to work with 2^k ** TODO 37) mpfrXport()/*Import() should work for arrays. Test Windows-portability: - as save() seems not portable; see ~/R/MM/Pkg-ex/Rmpfr/save-load-ex.R ** TODO 2) Now have working "mpfrMatrix", dim(.) <- ..; t(), %*%, crossprod()... - %*% should work the same as with numeric vectors - %*% t() ditto Note that matrix multiplication seems too slow --> ./Savicky-matrix-mult_tst.R - [i] & [i] work but [i,j] not yet --> want things to work like which( == ., arr.ind = TRUE) - ok [No longer sure if this is true :] For this, we must ensure that the methods are used, instead of the .Primitive base functions : One way: --> see ~/R/MM/NUMERICS/bessel-large-x.R -------------------------------- ## really interesting is bI(x., nu) {for "mpfr" argument}: ## it uses outer(), but that needs to dispatch on, e.g. "^", ## i.e., not only look at "base" environment(outer) <- as.environment("package:Rmpfr") environment(dim) <- as.environment("package:Rmpfr") environment(dimnames) <- as.environment("package:Rmpfr") environment(`dim<-`) <- as.environment("package:Rmpfr") environment(`dimnames<-`) <- as.environment("package:Rmpfr") environment(which) <- as.environment("package:Rmpfr") ** TODO 5) have seqMpfr(), but would like seq() methods, but that seems currently impossible because of a "design infelicity" in base::seq.default --- ???? E-mail to R-core ?? --> R/mpfr.R ** TODO 6) It is "wrong" that the class "Mnumber" also extends "character", "list"; but it's not clear we can find better definitions, see R/AllClasses.R ** TODO 7) Add tests for hypot() & atan2() to tests/special-fun-ex.R ** TODO 8) round(x, .) & signif(x, .) currently return "mpfr" numbers of the same precision. That *looks* ugly. Potentially add a swith 'keepPrec = FALSE' -- i.e. by default *reduce* precision to "match" 'digits' argument. ** TODO 16) psigamma(x, n) {and digamma(), trigamma() aliases} --> experiments in ~/R/MM/Pkg-ex/Rmpfr/psigamma.R ) Note that since, MPFR 3.0.0, there is a digamma(); .. which we now interface to ** TODO 18) ifelse() fails ... maybe I should mask it {or "fix it" via assign*() in base ?? -- they will love that!} or provide ifelse2() -- a fast simplified version ? ** TODO 24) Bernoulli(): we use builtin zeta(); alternatively, use *exact* rationals from 'gmp', using "bigq" (and "bigz") -- and R code from ~/R/Pkgs/copula/R/special-func.R ** TODO 26) (?) Revert the decision to *not* care about rounding mode in Ops/function, and rather expose that as in mpfr(), e.g., in R/Math.R roundMpfr -- see MPFR_RNDN in src/utils.c and others; --> use src/convert.c R_rnd2MP() -- and all the SEXP functions get an additional SEXP rnd_mode argument, the same as SEXP d2mpfr1() in src/convert.c has already. ** TODO 29) Our sum() should use system mpfr_sum() : mpfr_sum (mpfr_t ROP, mpfr_ptr const TAB[], unsigned long int N, mpfr_rnd_t RND) ** TODO 32) Use ./LUP.R to compute the lu() decomposition of an mpfrMatrix ---> solve() and use this for determinant() for larger (n >= 4 ?) dimensions! ** TODO 50) For *complex* arithmetic, build interface to the "MPC" library ---> http://www.multiprecision.org/mpc -- which is LGPL and itself builds on MPFR and GMP. Ubuntu now has 'libmpc-dev' (!) {but there's no '*-doc' package yet; on nb-mm, I've installed from source --> Info comes along} One idea: Since the names are so much in parallel, try to take each src/*.c file and mechanically s/mpfr/mpc/ producing a mpc version of that; then "the same" for the R interface code. ** TODO 51) Incomplete gamma, i.e. pgamma(), is being added to MPFR. -> do in Rmpfr! ~/F/IN-lists--2016-08 : From: paul zimmermann Subject: [MPFR] incomplete Gamma function Date: Mon, 18 Jan 2016 09:54:51 +0100 zimmerma@tomate:~/mpfr/tests$ ./tgamma_inc 60 30 100 1.3868299023788801161747839921242e80 *** Will be in MPFR 3.2.x (Oct.2016: current is 3.1.5) *** MPFR-devel(svn): https://gforge.inria.fr/scm/viewvc.php/mpfr/trunk/src/gamma_inc.c?view=markup - get: --> http://mpfr.loria.fr/gforge.html explains: - svn checkout https://scm.gforge.inria.fr/anonscm/svn/mpfr/trunk mpfr * Accomplished ** DONE 1) R: character -> mpfr "3.14159265358979323846264" -> mpfr ** DONE 3) "Arith" and "Compare" methods currently ``lose dim + dimnames'' for "mpfrArray" (& "mpfrMatrix") The solution is a bit tedious because the Ops do recycling pretty generously for vectors, but pretty stringently when one of the operands is a matrix. If the other part is a matrix their dim() must be identical, if just a vector, its length must be a divisor of length() ** DONE 10b) a factorialMPFR() which automatically uses full precision for integer-valued argument, notably using MPFR's mpfr_fac_ui; see also end of man/mpfr-class.Rd ** DONE 13) all the NOT_YET in src/Ops.c are implemented, *apart* from trigamma() --> TODO 16) ** DONE 14) Want to *change* 'precBits' of existing MPFR numbers; MPFR has mpfr_set_prec(X, PREC) but that sets the value to NaN. Manual: "In case you want to keep the previous value stored in X, use `mpfr_prec_round' instead." --> fulfilled via roundMpfr(x, precBits) ** DONE 15) beta(.,.) and lbeta(.,.) .. using my_mpfr_beta() in C. Interestingly, the speedup is not dramatical (50% for length 200; 300% for length 1) ** DONE 4) format() got more (optional) arguments, along the format.default() example. Note that an option to "round() after decimal" should not be needed, rather format(round(..), digits= ., drop0trailing=TRUE) does work. ** DONE 12) crossprod(), tcrossprod() (and more?) methods for "mpfrMatrix". ** DONE 10) chooseMpfr(a,n) is now implemented --- *NOT* based on gamma(), but rather n. ** DONE 11b) No longer --- problem were missing mpfr_clear() statements in src/utils.c : format() --> .mpfr2str() -> C mpfr2str() still suffers from a memory bug, inspite of my efforts in src/convert.c I think this is the MPFR library just allocating memory that's in use by R, but it seems hard to prove and or fix that. ** DONE 17a) as(1, "mpfr") & TRUE : no longer gives infinite recursion error ** DONE 17a) Write a 'Rmpfr-package' help page that mentions that we have *many* Math etc functions, including gamma, digamma, .... {which are not quickly visible on the help pages now}. ** DONE 20) integrateR( ... rel.tol, verbose= TRUE) : the precision of the output should be increased a bit, (still depending on rel.tol !) ** DONE 21) What's the exponent range -- and possibly change it: R interface in R/mpfr.R via .mpfr_erange() [and .mpfr_erange(.) <- v ] to - Function: mpfr_exp_t mpfr_get_emin (void) - Function: mpfr_exp_t mpfr_get_emax (void) - Function: int mpfr_set_emin (mpfr_exp_t exp) - Function: int mpfr_set_emax (mpfr_exp_t exp) - Function: mpfr_exp_t mpfr_get_emin_min (void) - Function: mpfr_exp_t mpfr_get_emin_max (void) - Function: mpfr_exp_t mpfr_get_emax_min (void) - Function: mpfr_exp_t mpfr_get_emax_max (void) ** DONE 22) apply(, .) --> S4 method ** DONE 22x) *do* test rank(), sort(), order() : we claim they work in man/mpfr-class.Rd quantile() should work from R 2.15.1 (June 2012) on ~~~~~~~~~~~~~~~~~ ** DONE 23) quantile() does not work ---- but will from R 2.15.1 with better quantile.default() Reason: in stats::quantile.default(), ifelse(h == 0, qs[i], (1 - h) * qs[i] + h * x[hi[i]]) produces a list of 'mpfr1' instead a real 'mpfr' vector. -> Fixed in ~/R/D/r-devel/R/src/library/stats/R/quantile.R ** DONE 23x) sumBinomMpfr() accept f.x ** DONE 28) determinant() and hence det() "fail" (with a reasonable error message). Easy: go via asNumeric(.) with a warning() that can be suppressed Standard R uses LAPACK's LU() decomposition. Would be cool to have that in C (using MPFR). Alternatively, do it for 2x2 and via recursion mxm for small m. (but it is *really* inefficient: complexity \propto m! ) ** DONE 30) pmin() and pmax(), for simple cases pmin(x,n) are now, 2013-02, quite "fast", (see also --> ~/R/MM/Pkg-ex/Rmpfr/SLOW-pmin.R) ** DONE 33) asNumeric(mpfr(10, 99)^500) gives 1.797693e+308 without warning. Should (warn or) give Inf ** DONE 36) got mpfrImport(), reading mpfrXport() ** DONE 38) Define a norm() method. For expm(*, "Higham08") need solve() ! ** DONE 34) Can specify the rounding mode in mpfr() and roundMpfr(), since 2015-08-08 ** DONE 9) median() now works, as does mean(, trim = *) and quantile() w/o warning. ** DONE is.finite(.) etc: *Must* keep matrices -> src/utils.c ** DONE 52) No longer use 'representation' but rather 'slots' in 'setClass(..)' ** DONE 25) mpfr(, ...) should work: return argument unchanged *if* precision and rounding mode are ok; otherwise use roundMpfr() *BUT* that needs an additional rnd.mode argument -- as mpfr ** DONE 27) Now have simple sapplyMpfr() ** DONE 57) Fix pnorm() bugs reported by Jerry Lewis (>> ~/R/MM/Pkg-ex/Rmpfr/pnorm-* ) ** DONE 58) print() somehow fails to use max.digits = 9999 [print.mpfr(*, max.digits = ...)] ??? *** Why did we introduce 'max.digits' *and* allow digits=NULL to use *all* digits before the decimal point? **** I now think max.digits is almost superfluous if digits=NULL behaved as promised: We have in R code comments __digits = NULL : use as many digits "as needed"__ , and in help man/formatMpfr.Rd __The default, \code{NULL}, uses enough digits to represent the full precision, often one or two digits more than you would expect.__ ** DONE 56) Add regr.tests for new dgamma() !! ** DONE 55a) .getPrec(), .mpfr_erange, .mpfr_erange_set, .mpfr_maxPrec, .mpfr_minPrec etc are documented now. ** DONE 59) *exact* dhyper(), phyper().. -> in package 'DPQmpfr' dhyperQ() etc exact via 'gmp' exact rationals ** DONE 63) R interface to mpfr's functions `mpfr_get_ld_2exp()` and `mpfr_frexp()` compatibly to DPQ's `ldexp(f, E)` and `frexp(x)`: -> frexpMpfr() and ldexpMpfr(). ** DONE 64) formatMpfr(x, scientific=FALSE) does *not* "work" e.g., for `x <- Const("pi", 128) * 2^200`. ** DONE 64b) formatMpfr(x, scientific=FALSE) does *not* yet "work" for small x, i.e., x << 1; e.g. `x <- Const("pi", 128) * 2^-(10:20)`. indeed we had the scipen = *penalize* scientific wrong: *and* we used 'scientific' instead of 'scipen' ! ** DONE 65) unirootR(): *update* with R's uniroot() enhancements: extendInt = c("no", "yes", "downX", "upX"), check.conv = FALSE, ** DONE 67) BUG: igamma() [incomplete gamma] always returns 53-bit ??????? Rmpfr/DESCRIPTION0000644000176200001440000000431114553206225013051 0ustar liggesusersPackage: Rmpfr Title: R MPFR - Multiple Precision Floating-Point Reliable Version: 0.9-5 Date: 2024-01-20 DateNote: Previous CRAN version 0.9-4 on 2023-12-04 Type: Package Authors@R: c(person("Martin","Maechler", role = c("aut","cre"), email = "maechler@stat.math.ethz.ch", comment = c(ORCID="0000-0002-8685-9910")) , person(c("Richard", "M."), "Heiberger", role = "ctb", email="rmh@temple.edu", comment = "formatHex(), *Bin, *Dec") , person(c("John", "C."), "Nash", role = "ctb", email="nashjc@uottawa.ca", comment = "hjkMpfr(), origin of unirootR()") , person(c("Hans", "W."), "Borchers", role = "ctb", email="hwborchers@googlemail.com", comment = "optimizeR(*, \"GoldenRatio\"); origin of hjkMpfr()") ) Description: Arithmetic (via S4 classes and methods) for arbitrary precision floating point numbers, including transcendental ("special") functions. To this end, the package interfaces to the 'LGPL' licensed 'MPFR' (Multiple Precision Floating-Point Reliable) Library which itself is based on the 'GMP' (GNU Multiple Precision) Library. SystemRequirements: gmp (>= 4.2.3), mpfr (>= 3.0.0), pdfcrop (part of TexLive) is required to rebuild the vignettes. SystemRequirementsNote: 'MPFR' (MP Floating-Point Reliable Library, https://www.mpfr.org/) and 'GMP' (GNU Multiple Precision library, https://gmplib.org/), see >> README.md Depends: gmp (>= 0.6-1), R (>= 3.6.0) Imports: stats, utils, methods Suggests: MASS, Bessel, polynom, sfsmisc (>= 1.1-14) SuggestsNote: MASS, polynom, sfsmisc: only for vignette; Enhances: dfoptim, pracma, DPQ EnhancesNote: mentioned in Rd xrefs | used in example URL: https://rmpfr.r-forge.r-project.org/ BugReports: https://r-forge.r-project.org/tracker/?group_id=386 License: GPL (>= 2) Encoding: UTF-8 NeedsCompilation: yes Packaged: 2024-01-20 16:10:31 UTC; maechler Author: Martin Maechler [aut, cre] (), Richard M. Heiberger [ctb] (formatHex(), *Bin, *Dec), John C. Nash [ctb] (hjkMpfr(), origin of unirootR()), Hans W. Borchers [ctb] (optimizeR(*, "GoldenRatio"); origin of hjkMpfr()) Maintainer: Martin Maechler Repository: CRAN Date/Publication: 2024-01-21 12:22:45 UTC Rmpfr/build/0000755000176200001440000000000014552770166012454 5ustar liggesusersRmpfr/build/vignette.rds0000644000176200001440000000053114552770166015012 0ustar liggesusers‹RKOÂ@^ÚŠ‚!>¸{„Ã6ÖăG"ábLHãÁYÚ¡lè+»K*7ÿ¸â¶R &$ûšoæûæ‘ýhB,âرl|Ú]<š¸¯Kƒ8¤…÷ý‡`ƒœ,ø“ÇÏc|ª´tý´01?Ég’勨ÞÄYä%ð™³4Ó°qì+ß–‚l'Èm„ÒPóâVE&ÑÞOÔ’YáVÉ:åGýÂc½^VÄ\UU`;äš»3‰|´~~%2œ9êRmpfr/build/partial.rdb0000644000176200001440000002474214552770147014611 0ustar liggesusers‹í}{wÓȲ¯ˆ ‰Ã#¼_L³Û;ÄgÈÂ`œÀ0{<Ö嶭A–<’œÍ{ÖºŸä®û…îßw­û!Î:àìÓ%•ìöC!zDÑ:$k‰_aµ]ÕÕÕÕÕï÷c‚ GCÂPÈsìŸ#‚¼ÒùÿÐi I†'‹fUÏ5Eé£X£‚ptˆ{y¬Xù`Š5Fñ_9ún¹ø¬7¥¡K:­2f'á6#añÒçz¾5¾U• ?*ØÿÑ“$±¬J=ü‡ßn®äî÷¤¥ª¤UdµÖ“¿‰‡U±AžŸ]nÿ‚ðŸ=_Hš2û‚)6šL¢Sðâßþ¤ù?½¿,)¢áüò“ÍõµÕ÷’éèÊú¯9€Í((dëítW!å‹•žï mWz¾qkÊl4§ŠìŸ_Þì”?¦Šå–¬Tfæʳ"½w§|wîîôô”õ³¶Ž,ÉõüWFnIÚ…ÏÿБÞTÃ%;gðrè_=–â<ç;é,ÝÑí•mWÁs‘ãèæòûM1.pˆ1öZÏúEëÔ¬.Ñ ¬GÏ#íKC¹+‰Š,.| rª‰ºd€ýEñ ©d†±x*‘–à ¤ODP" ,À“HŸŒ¾D€ý)ñ ©DF¾PK\„‚&d ñ4Ò§C+“ÑRE“6wšƒ<ØQ, À3HŸ‰¾T€ýYñ ©TîIa}¥Hr¤ÐRL¹©P²®SI6dM%+Š&š¬íÌ­k²j’"eö[V¼–à0Ö$Ày¤çC¬U¦l*ƒÊoË ðÒ¢/?`ÿC||–ßhPqà9Å¡ÿJοýËá’¦®mÉj9bEMŒÕ iP³®U RÕt"ê²YgÈ’WáÐð¤,üBdURZ&SUC¢j…ª¦¨LÊh²ê *©,©¶TÉdõÂÉEYf‰õ¯™EÁŸ ý$p&î¦{§âV±â’¦UqÕV£Luc’Ô©N‰V5©J$QQh…x”=‰òZ‘¾çÛ˜‡z›Ë„r^šDE.#½X¡Ç ûCÍyh 5xéã¡y¼‘RåMK3¹¼$Ö `|i_L—&æ ÙÔˆY— Â*Æ$‘MVaLªWE‰Uo^Qòêùú«4³(«9É8­‰×²ÉO"¾@úEà¬/·jYòJ.C}&ÛuYª³LT©–ç²h°|iª×¼pE/¬ ½8/“ÄR÷óÂ:É<ýv@»ÝÎIÞ«Ä'PJÀI¤'C3Ü%Ö0HºÜ'êÒ4aèËw£n°‡8Äǧ›*Î)¬ âP+—o²:ÍÌhiyc±¸º¾¹ºöšÀ€À¼›ÓY\+–_p‹ ð2Ò—£/6`…C|Š1DˆG9N£ N ]]mŸr8£MK¥ ú©©ÿªSƒÕwã‘^™4LÖ›zdýöÙÔ4ŘŸŸ/V>`?ëW´™ÔÄL*û×^úÆÉ·ËÅÂÂbqÍ%o ÄkH_óš·®A®á†(éZOòs%Ì—û» „A}™!EñQV×¹ü\÷“ëyþWPMœ.1’ë¶2çýXr8â€v7î%S,G¦ŒcdסÕD¢$é‘)"&Æ9² ½÷CÓd8Gö,æÐ÷Í˾cýDVP‡¦ oÉtþÇÜÝXjâk4ÎcK¢yèdíQÙéÙ¹ÜôLnv:–êøÍs Ìóµvh¢ÖÛ[ÐêoÉZË ‹Å…×dËnX,—:GÁ,øNnf67=Km}| æ­—á(Y÷5Ï{h›ûÖä-´Ìº¦O‹‡*ÀD™”i2—ª©™TAÔYŸ*5É*Õª§&‰®±~×#–(%¶LöŠýT*;¢|—„I)B¢¬0S û©aŠf¾!šõ<5ëÿÌKu–Ik4(ë*B^ÖŠ‹«KRÓì/ÇžÙÜý{÷ïæ~üqf:•ÍÆ#oo’“Ë…é¾(KuQ¯°l¤ y¦’zAå2Õk|¥$³Ìþg©ãQJoÔŸš´ÁºÍyZi¥bRd·’ð×)‹TUÓYA½ Ÿ2,W·žÉ*ûw‰J©˜ë®bx©ÕU(ƒE» ^‹FÝMý*{÷‡ô´¥™¦¸-æ%1.%0Û[õ?>šUô¯érMV‰V%-UÖ5Í,f²q)‰÷]%ñBT (‰Ÿí’x¦éR½t+úvS<­iZM±>Î3%Ä¥T–{KEkšrCþ'-fnM’R깦T¨ZMY+¥²¸’j_\ j(™e»ú5;'—:ṠáÃYh/·"™-YtY™•…EMñ(Ã礳¸j‹šÜÖnÅ#3 dð²Þ55°¦g=»×Ä#E{ÕIÚZåC™iŤaÂ"ÝYîãa™M<òµB\—ûØ~^XOy¡M,Í×èÿÏoì¬P¤¶dBla6 S¤Öh’ÌãGd.?›¿ÃBHk­%|p'?ŸŽK÷I³R•t‰Úd}s÷6é§Wòó¬jêv±V`Í¡N­¥/V-Ý’k*5MjVĸTÄËýñp„¿“µÛÍu·vÒiZbR/ŸÕM³iÌOMmooçÁuä5½6•µ"È]ÛH+Ä)'Ì2Éì\LƒRB?&¤¸¼°TXÎ7*±4ӯё$—h“EȇÍ8¼½ÞnƧó÷r3Ìr‹Ø†ßcmx,ôUÚìj£©é‡¡§õö"Ù ÖQo™²Âb©™¯ÑXÇ6Zµ5­Õz{›66&É3jT™$MMÙQµ ªFC6$ËÝÎägr3s‡þ6.&|Ê1áÃ.F÷šï<ÑTeÇÚÀêtšÄR]_£-«uQ•è¡'†·H¥jM 2+ÖE©!N’¥õ7±TÌ×h¬§c=ô¹ÎØa.YSi…È*)VÈ'–Ø ÿƒ´ û#úI„õ)±ÔÕ×hÃÃo‹¯M—áM⌋éÖàžžcB2lêÚT2­²X*êk´ÛÏZµ"=bpÞÎuÌw áš,~øHõ©'5]k5?È•Gwîß‹¥Þ¾FkN¾²—š²”ž¯¿²fÇâb¡cÎ)¢‡& o wüjÌ4ñ5Z稽ÁãÐ6X;hïé ÎŽò«Ø2' ûÊo$óÐ 4]’+Vh0`KÄã¸,†¹Oîƒ …¿ýÐ}sÛãX*ì+1ã\GÁXZŠ¸o €7Å ^ϧ?ñPÒT•ZËë»ü朲®2¯wž€eêý¬9îXêÏš{êý¬9Y­°>¼Ö9sŸâe¤=))Nô¦wŽ–[µ%¶“ZÇʵ ö 'õ?R÷/Ÿa’ÒOÖÆ7ª4‰©5eɘ?8Ù@U÷÷¬*—“ö÷GUòe¹ö笵²½ëoQSS4Þš²"›25¬•tsíáâ‘…gTWµ–¢ÈÝò“Îç¯ímO0›´ÐÞ$Õ^ml¬Ø‹g>ô„ý9w6³êUդЩYÓ+ì_–­Æ—ŽŽ4/Ä寽1͈‡ K{G\ÎÚÜÇ¿õÿ¾NYK¶S×ø?V)('ëóxää‘›ÊuZƒÃÙúgåDÔuqÇ U]kÀVF<²°Øu1 —…½ñŒ|çVÎ>…xˆ9o™ÁMÿ°Å@­S ZŸ˜¿‰Õ 'a*òß V!©.K9ç¦û¯ÀÝ›n'Ê<ózœMÇCú碩5dé]·êÙß;Y7[¢ÒÖ=—Ìò< ÖÄþ$&~4/åû«( âÚn³EÄCæ©Ì"ðµ]{:ŸÏ§ÁépÖ´Òn„­/gvx‹4/n‡è¶˜ñò…T×4ƒú,噬2››×hµ*K2ì|³ZªuMª×Å«Àdc§QÖ"~ã‘›¬«—g-“Z#+"TPy—=õ‘Š{©BMª7dUTM«²DS—?ÅC¸Ýt¹Òu}LGl²V†… 1q%OªNY÷ØvÛHZý.MbÝYlOô–B?Éee‡¬X øÞ«¸°M‘À—b §ÝŒi‰é»ÁÊÂÎG<„]°µÞïm!­³;ìÛaì.^ç,†xdc©ªÓOÍþ\g¢As³,òe’pÄÔf˵c0/KöG»LþDš“›nÖce.VJ_¨QœH dß ÅÛ€÷ìtš6¨eX1 ^¾wÓøºÎºt '¡¦ûµgÑÚ9N öÉúBÓ>ÒÜKJ·˜¶—Xc‹™õÍ­è”’‚¬Âä§mèÅxä䶛Ö3ÛšþÜØ ¸ž˜D³r‚b¿À«ª¤Á q“’çV 'hˆ‡Ü/àd¢š.š´Ø-÷šJsKrƒªP'Y³„ýTF­â7À\rÐÎ6[zL ®º™MLÌzV6òÛuM¡½ÒŸáC’IáÐi*f 芢Õf¬ íÕë"³í3íjFÌ’G„%ËÌÛS9ÂÒfrb6Û±Åý|¨Hó’r³‘5X9³ ¢ª~h¹=‚]Œ=Ô’í‰X⑇ûƒÇ]˜Ý蔹g0ÉÙ3ØoŠ‰O_²F|{ßI{üÝ^«î6òœ¸1Ö 5±ò5Ë ÖÓíó5ªaê-É´5o%IQih†IDƒ”wHÚ ÎÄeõQgH ÛŒñ´ÆT'3‹ÓÎY<²°Ô^×S/äZ³÷ÞpaÍþZŒ|ÑS5Tƒœt¹¡ÍO‚9‰*öTpž9¹Xi–©)®öçbA’ZÆñç3–”LÙ°®ke±«1n× …ÅöÎ$òF]lÆEà;͆Ø;þd»QQ‡Ë—Ö(b1„=‚ݪ˜Œ/5UMo |If.U.·¬`¾S¶e³nì,|ùfïHsòìOÈÉû.¶ Cf•vŠ¼†Á)…¼i‰¬ƒ®07›¶¾Äš²%ǤD\£ÐU5VþfQ×ZjeÀ B>·ŽèÕp •”e8ÈjÂrÖ·*DÓ1iÈb³©ìôçd>&~9ÑX°ÿcxg‡×ñÈÃþ9p|eÝ ¶¨*QòœªTQÛû‚y™s°Ð%“ÀF]Û&›Eßµ¬+í±õÅéY»gÜ<6Z kR°·,2 Šeõøg;ó†­†ž'NëÒ^8û3zK„r„äŠ,ÉüêZ–¬Èv•oúÄe\åñ?!Äð·aÓ å:ejk«ÓÎevq ד¥&KdϯÐJd*ŒÉÚؘˆñp¥¥3‹Õ‹vQ@à ³NÁ–(+Öa®²}šxUSm*EûÄb· ×£YÈ+¸pwÙËðß„yLL(Ü»ÌC“Ë’ç\¼ÔÔ«žËÎ6¡-ƒ?ÌNÏÌäÄ2‹\¤..®--Gî‡K’V¡ÑÙ2‰¥3qÛI¶?J¸§-s“`#ÉZK—h6–úùšü]oENâBéµÃš?ËŒ¶æ>i/(“Y¯=DiÏÚA•5ÔTt®ÅNßaåŽiå>éLçTÍt;õî°‚5|±]©Yý¶«5ô…ìuö*€|6Kr9²^phby簒Ǧ’äºÛÖïýå|ôÕêƦË/„´Ñ›ÏÀ•Îu žµÒtŸ€b¬nv Id¬ýÅMÖ®Y"[›Ž+5óÝD§08ïœoJ̺h’mJšº¶%W(ñ˜l+,\Ez5´VçhCTw|H´Ž¸ôFˆm m4ë.l_"n"½½yû·âPŒ|ƒÛmÔà‡TÛû¹Ë½Ê|í0t> ²¥ak¦GÑ.°ç$â¤Ï„hLŠ¬~ta;‚xé³û/]@å_º*v@ãš$>´~‘£C6ˆ‘Šì×$Rˆ¤3јÄ5Ä,ÒÙhLâ"â-¤o6‰‹“öjUl°øq’° &þ|”ÄmħH? = *]x/ >CúY`½Œ¦ ’Ù˜ó|6H±ˆøé—áµÂ0‰æf8n]>0”Ä1¤Çöß^/Úò[xéãËe‚X§ “Œ5hÓ?ÖÕô“D›¸MÈ«ñ‚€'óH‡ß蚺/'R=@|†´/óöæä€Ý]ÄE¤£1š)Ä%¤—MÂûù‡ À2âs¤Ÿä\‰F«È†éÌ_âýFÞ«Œ—°VÞ@úF`Ï.T*²i­<€E9Š¡y­P—Q@®“vi-¨ó!Ú·ˆHOìmâºéÂßþÛþ×&`wñ&Ò7È1û^ušÿñ6Ò·CkOQ]g"§äC¶9ĤB+ž‘RåM«=TÛÇxñÒÁc—!ÏÞø/".!Üí^…5¸ M§öU°¼ßó(ß»È-¼ŠôÕÐ=ÊQXÂäC²4â-¤}EåÞ °ûñ6Ò¾j“7‡ì¾AœDz2 ‡²ÛÙ»h>‡8‹ôl`Y²U\u“+öò"Yg6ë,-"™2U´í¬çÆš3[«×xDðÙk 6*õ ²v0œAϿݼI …y"i-¸<^ß±ª=1¬ÛÊíñ)Åmôpdq­PX~=HØk( àßöÕlÓ°¿É!>Q‹q5à ÿ¢Ã5RƒÇbÖáÈ`ÑëB)ˆ?O"žCÚ×€•‹Crëv#ˆç‘>Ü!Ù#õ>Tpñ*Ò¾)”5eÐZT.òçkwÐÂóa¨7°†ÜÚ§û<¾7Ü%|â!GÚ×8„%ÏÿZ‹AŒSâ´¸<ŸrLÐT*ûˆa‡T»V¼›dãˆg‘öÕ}ôR»$â9¤Ãô`.!°K žG:¸;Õ½ßG \@L ívŸ¶!¸qwY&\'¿GúûÀI}qÇ»-¥_ ý"t-¹¬‚¦«ˆ?!ýSô1 °Å!>‘{³ïÛƒîŸ7K¶·†ûoñÒ—öߥ»$âe¤#XììB§ƒšÂXß‘ôëÍ@Œ«ˆ)¤£ófÀu1ôtÖT÷iN~ô—F,#]ŽÊÏS ‘"ÜÁxösÀ¾Ê!>‘û¹ Áöm€ûççN÷OåCÊqÄHßØoì’Bg =iã~{;`—:£8nr ¶áÄõ)¡Ý³ˆÈÏMpOx~.½·#Ñü¨*X@º•K¦¯ב^Þ¥û7âPŒcIöçÙt¹i4ëÿG"5]à:‚8šézîOûã¦í'£¦'aðV._ÇëÙ(ý8‡·¿ëqø·Þ}éM4BÀýkg“í»Þ|ˆ7ŽáÈ°K"F8rìˆ1¹1®":=œèœp@ ¯½½÷{ý¨+øi팷L‹ˆ›HÀ®+`ÿ–Ãpv]ywkß ¶+Ü?·vœ»Ò‡€ãˆWsÀÂű»$âU¤Ã\$áâØ€]ñ¤ƒ/’ñçÖ@ˆkˆ)¤£skœ+ Ñ­=ðx)wÓ§õ¥E¤# ¦eÄ ö”à N ¶kÜ?7w̾=Їlãˆç‘öµ²Â›‡vIÄ HûÚ2éÍûâE¤/¶ˆV‘€$—„Έæ%!J7ç :8ž"7wÙåÆJ?ºqžÇŒÆ‡³'ˆ HûÚî̇ûgâ¹Ë¶ßÜ?6l]êC´qÄsH‡¹&ÍÅ…»$ây¤Ãôœ.. Ø%/ ío³9ÿöd•p ÊE¡³½ü¢¥®ˆáù°dû°jÊH#N!=¨¢ð©ù|ÞÍbÜ–E€$÷ï#}?CFüé—Ë­/Þ%ìÜÖë§àæ%¤¥¨Z`ZA¬"]¾µö5ñ‰¼µÉÚ¦oáþµ6c›”}È7Žáú `—D¼"D¶~Ø%~ýHñ bJˆzýp@ ¯µ™õ|{·­¥ß#ý>*ïLAüé_£÷nÀ¾Ä!>Åð7ÅxK°½Ú-á ¦ëbxSŒçúom÷£–ãˆ×ÑLý >̘Þ@d‚[ÀÃèÍØÇá#û‰¼¾f ¸ðÉ®[ß}ˆ8Žø Ò¾F¬½µÃÀ.‰x ékûß»âu¤ýmìb秾U0…ttî ¸N#2Âq_YÂù­´ú]š„4åb¦×^‹Ê©ÓuÄ"ÒÅè°ßàŸÈÚ¤`;2À}ìYØ—±øðh ׸Ð9ð$¢ž°K"Fسv ăïYp‡u@ϸN †çÔn[·TÂM—YÃò{zÑñfY¿ ±AÐ4bä+)€iñWRû·ÔJŠœ`»2Àýsk#5jB+èC¸qÄ H‡9ÙçâÓ€]ñ"Ò¾&û¼ù4`—@¼„´¯ÅpÝ‹Xüσ —SHGçÖ€ëbxníG‚‡óç¸éEîiÔòy“ì#Yµ)jJ~”—Fü€ô‡¨œ0ýbérôNØKâ¹“Ë ¶cÜ?'—lß$ëC¼qÄWÁ»$b„«`]ñ Ò¾"ÆpVÁ‚WSBÔ«`ëbxN.çåöb? K#n í¯CæñÓMÄwH¿‹Þ±ûŸ9Ä'rÇ6%ØÎ p£7¼•Ù‡pãˆFoÀ.)t:Ž(zv ÄXDo ÈeÄè£7à:žc»¾ÛMà~„‹,¬#YÓ‚ÏC¸ý82`º„¸‚ôJôŽ Ø?çŸÈÙ´`;/Àýsd'ø{Í}H8Žxé0—Ö»x3`—Düé0'*\¼°K ^CÚ×DEÏÉ~Èp1…ttŽ ¸N †çÈ2„d+ƒf¶3‹¿ÑjdK±›êCWiÄ×H¿ŽÊ§Ó5Ä7H߉ëÙ§û"‡øDîÓfÛîŸOós¬6H4ŽxVˆì H`—D<‡t˜ëm]|°K Æå HåbJˆú Hà:ªOÛhR œX¿:­³Ò2Óž×W‚”iÄÈ}0]C<@Ÿì‹†ãÓü­@šl_6‹ÿvpA<ÀC€ýq#=䘞@<%Ø!À~œÃƒ:äà!àþ5´c0fVƒ›€‹>äGŒpjØ%¯‘MÍ»âÁO̓ß ¦„¨§æëbx í!k*Í-É ªÖUR0Ou«µ]E+…‘¬Cj¶tJŠ~ô–Fü;ÒÊ¿Ó_Cú·èý°ÿC|"÷os‚íÓ÷Ï¿¶TY×4Ó«w©Æ/"æx«‹wvIÄKH‡9iæâÝ€]Bè\h•¸}ÌwG丂˜B::ÿ\'Ãóo³–#¼+2Ã$™¿S]Ë’ÙžÙ àÝ@Þ4b䛀é/ˆ¸©Ø—8 gSƒwïvW°=àþy·¤Ö4å†üOÏÁˆ5Žáä<°K"F89ìˆWö3†39b\EL QOÎ× Äð¼Û!/äZ½³àˆöEsk¶­úšÕaÓˆo‘ö·°Ð‡k¦ïß#íϯòo=»6`ÿ ‡øDîÚî ¶;Ü?×6Rÿ㣠-j1Âéy`—D¼(D6=숱˜žA.#¦„¨§çëbx®m¹6MûHs/)Ý¢Yb}Ò-æŶhnE§”dµã׊$³­é!’ƒõ—¾††Aü4b iÛÎ}8;`ZGüé?¢wvÀþ#‡ø„T¡FÁ€ZŠ8Hß ¶KûŸ¨ì‡8Ä'j1î£ GVðÆTYµ·AÕ‘ "n‰²"–êÜs^ÕEÛ†Úä\¦jx¾dðGðÒ|W'(‡Aí•÷Ka?íbðKO-iã‡øD^<À"z „^ð©’Ö„\ócÍ­­u;7äI"žAúÌþ7ñÀ.xé³Áý€ŸR9Ç!>5ìÀõ<â%¤ƒÇ9?µw³ÊÊY¤̃E­Ñl™¶OÚ–Í:)ΓMæ‹Ò–é¤IS”>Š5J2†ÖÒ%:Iš•jÖ‡:/#–‘.GÕÄS ñoíöUñ‰ZŒ‡‚íc §…óî÷¸¦iüÞIE«Í4è§f.)÷êû@¦$b„çS»âE¤}õª‚ù>`‰C|"ò}Àõ2â7H?†xüíð˜ï³]„YÌL23$G˜¥dòÙ,ÉåÈ\ðaÐ Üh/ß âù ×+Hû; ׇ禱†tð½<»`_çŸ:7ó‚íX Ú¹öCúîܸ( BMÖ‘0p>…™~DG‡¸7Ç+;ªØ¥E“:‰?zl€žÆo²Š¥V>£x¹È?²¸V(,¿¤¸'¨¬'ø•!£.?`†C|Bj«Æ ¢Îœ)ˆTª+T÷(ÜSÁn ÃŸC)‰-³® ª\O±è/#|Õsáû+âã³pNg+…ƒøÔJUÎÖÛéåì‹ôŠT‘­1„WrNªÉNzù`éÜ„„‹È0üðBÝ4›ÆüÔÔöö¶uVz^ÓkSn"¾[.>sqñÒáýt´ÔÒ® ÄëH_\@K7‰¦Ð SJ[!„dZ0Je¶T;X‚q©›V²[Æ-¢RZ1¬ÏRL)·phŸ™¸("-Fï6€}™C|¢c íÜÁp"” !Ï™§È<ývÐUœŠ_O±Œrg‚Gî)V7`øžâœã)j&S•?‚"^E:¼fn~¸%ûÂųMûkâµÏÑ0 §je‰u,«A©åÛãô¤AUCcG±¬mѼWq_ ˆ€Y¤³¡™ÌñKCuØm;¨Ÿ°€ WCÕ•ç"öCúî(Yõz<¨8/{šÂA|jå±ÆW=Êò–ÊOøìt…<0T*ºðAEz4°’í¡eªH"šš°Ä·÷Juöò³ãû‹ ¯óÅ\S×þ ’iµ(™¿>—škŸñ—3ÃÚ —l$ßn, ‹Å5—¼œE¼ô ¯y'zSŒ– ÖÌÏgó¾ßC®Ý3èÖBž¾åòö­Ÿ¼µgüÜVÎì¢ùÝ (Á\Zçöt[„\‡-óÝO¶]Z?c­÷(Ë5"ãýeÊ` é©@!\ˆÆá<…†VL%UQ¬|€¥­šÚ#þ)&þ4üâÒ ¶KE×"‚(ÏBú§}woÀí"GGíÞ€uC|‚!Ú¤jÅðÜ1.ØÅjáq¤}-Èu´Äºò¢bh8¿Dn¯…íû!ƒõŠÏìU×åkX÷[ ]rü01AÞZ÷‡8ǃ©í«¿ “Š¸,W§5˜êu^åó®Öä*ý:$ ³èõ‡ÀÒO¨3ùÙ»äaŽ€ì™»“Öí½ÏdÓ ÈìÝ{Ù©9Ï’¾Aé'ž,é1KRÏÂQ€¢tü!˜ñm oé“/™ñAøeÖ©JRt‹ê;fÙbŠüÑ2LkÜ {u úU¨!ë´B¤ºf°ôíÃÔçërÍs†61€ŽÃy8C÷l{üH™™ù&Éìô$¹3%,ŸÕ–¢ì Ðô‘´FSÔ©•;Ï¿Eï!<š¸Ö„C›3˜ƒ;Lô ë™Æ£™³žE|‡b^CzG£]åøy;Žá‡•KVY{×Ì{”0PÃP3¿ oÃÑL‘™úF]Û&¢¢†ÈªnçÚu;P…ZmWêL®wœÌ ¡Ÿ$jõÈ物Ë5±Ñ½+øï˜@Îí)Ö¨ù\×Z͵Äͤद”wñ~E‘#XÀá*G y;Nù¯°òÿ™2?§mÉJn5DuçuVÞ jÊÒ$1ð +Ç.&­&@³vj4ì[F]w_¸fæ7Ì 7M037 fÉxóiFRDX£È ;Pò^ò¿£`€7>&8±‹ º.îøôJ(È6Y¢ŸÄFS8'¶†ìþªYzŽþý‡Á¢ÿÞþñï{ nŒ!žFútˆ}²t‡yçŠ ç#ˆgö?ùã»T€ýYññ§€¾TCÅAYwþʘmÁABŠS‚[¹ ŸuR7DI× È;òèÅÿ:³2bçW¹ZeRÃÔTe§ÃæÈ耄ΜE;Ñ…žÖtdûí©ž·¸„œÏk•“§¢©0GoöË3ð Ã%C„‘Âv┌7-ksA;Ùñž$£%IS!ŽàÒu¼g·€=?&›¿àÒœî“Én·¸$çðã–LóézdÚ˜ôc=?Ô^z¼kG­ ê-µ[§½ ïìIzÞi·»å±Ò‹ùŒ&–eåKe9R*VÖš&ÏslÀ/áàÿ3}i%¹úÅ<;ªÖ4džß±ü蟼VÏw›uïÓ£›-Qiñ™ÿÂ7ì}»TH­ÅÛú j÷õšŒ+Û‘RU®µt^Òó}y¡ fˆýšë–a5xƒlÇU„1Vü[,ضæèøéJÕ½ÊfPþº’Ÿ,±^¸½#ؤ¼Ù÷Öc%S6Úý“=ªÿXîù…¶²ÕUåÝ5$*²ø%˃:-mî4éàŒîªÍã%•nKëT©¼Ð—úQ*ZW•;50[Öj¸Þ¬Ð6+˜½°euJ•º+h¯»¦†¤Ëe>ëgp< qj×µð†K’¼«ó¶|?—à¬kM‘«T1øߺ¸‡ò€J)õ9âZvF«ÜŸ|cŠ„3 E³§ÑÐâÚÓvíD'fÎÞˆµ‡šu´T©òÒ¹™:Ë¸Ý äÒö7¼©;þßëkí{MkPº$˜—§Ÿíb,¯&cÚÓ”ô™éV¿Ý÷Z–5 ø…0lp-Pü¯õú?.pÿb•D½Ö‚U“<ëñAå>!WÕJW ˜œ¾¶°·±|m¿p=É´Þ Ûë‡KeMPÎ~ËÙ>óE}› j¥+0˜ès'PI6欮õŒŒUw<Óãš{XËÕ>ýöü\UVè2<ÌÚáfý‹Â±¦”ÜOt gõ,®»p8WÂ.ëï[‡œŸºâÒ‘ënrº-‘å]Ve,sþKKvôø«N–bôʤaÂb¸rKV*¿}65M1æçç‹•(ÔÎãgR3©ì_zrßÚÂZXEºÚéÉñ=-øl¸o¸äíæJî¾ýòXïKÁþ|BM>²ðÿäfåÿþÿ{º‡ÎÂÇ‘õµÕ÷’éƒõ_³£ù±^÷§ZS ܬ6UœZšÒsMÑ”ê´2SuSF]ÔéT±2e÷$§Œƒµ^y§O{¼÷÷nM™æT‘ýóË›òÇÂTÑRïÌ\yV¤÷î”ïÎÝžžÂ‰ü]ûÍ#¬§‹†ê–¤qa»^ôeP•¾Œõ™O—ÉÀ»ëÅÌÄÌ@#¹ˆ†ÈíÚwŒ„îyˆÁ%È{%nÒ÷\F/ûÏèM ;>+¬©ÿô×gè|þlsø믿>ÛÄ€<Îb¾Íºó¡å1Éâk­¦ˆÐŒ†Qž³Yb¤iT­ÅÀÁ¿²É+ôéG~³ÙÓâ¶Wù†‘C¿‹ û³Œƒ.„’eL Žé^T¦ÿ“•$”«+˜Ài¤§ƒØë >¡­áM»ÇF©>öÞŒYýM÷Œ›Håg¹‚éaO]ÇqG?«,Z²ºÙahè©w É6wM¢^Gú÷Ð|[' ZÞX,®®o®®½G>‚Nw}p={×G—N9zXÀ@; <ñ®;ÎwÏ} s ÈMx†àY_W“ÃÉwn cæžË)ÌàS¤Ÿ.ã³NDY5ÙCC*çEïåÜh‹à®…›˜sÀ ҕнcO')êrp²¯âì=”g½u §³uÛî!t¢›¦Naq(ÑêÊ<ùwÁùCFzE8Ýÿ›Âþº{zÎzRmpfr/tests/0000755000176200001440000000000014552770135012513 5ustar liggesusersRmpfr/tests/create.R0000644000176200001440000001273114552770112014100 0ustar liggesusersrequire("Rmpfr") ### Simple basic examples of creation of "mpfr" objects pi. <- Const("pi", prec = 260) pi. # nicely prints 80 digits [260 * log10(2) ~= 78.3 ~ 80] ## These both failed (in mpfr2str(.)) with a seg.fault: c(mpfr(1, prec=3), pi.) m0 <- mpfr(numeric(), prec=64) ## print()ing / str() of 0-length mpfr stopifnot( grepl("0 'mpfr' numbers", capture.output( m0)), grepl("0 'mpfr' numbers", capture.output(str(m0)))) c(m0,m0) # failed in Rmpfr <= 0.6-0 stopifnot(identical(c(m0,m0), m0), identical(c(m0,pi.), pi.), identical(c(pi.,m0), pi.)) ## This is TRUE for 0 and -0 : Zero <- mpfr(c(0,1/-Inf), 20) stopifnot(mpfrIs0(Zero), is.whole(Zero)) stopifnot(mpfr.is.0(Zero))# deprecated but must work stopifnot(mpfr.is.integer(Zero))# deprecated but must work Zero # the "-0" should print correctly stopifnot(.getSign(Zero) == c(1,-1), sign(Zero) == 0, identical(format(Zero, digits=1), c("0.", "-0."))) ## testing 'recycling' b <- c(20,120,80, 60) (x <- mpfr(2^-(5:7), precBits = b)) d.spec <- c(0,NA,NaN,Inf,-Inf) (spec <- mpfr(d.spec, 3)) stopifnot(length(x) == 4, x[1] == x[4], getPrec(x) == b, identical(is.na(spec), is.na(d.spec)), identical(is.finite(spec), is.finite(d.spec)), identical(is.infinite(spec), is.infinite(d.spec)), ## mpfr(, .) : identical(x, mpfr(x, getPrec(x))), identical(spec, mpfr(spec, getPrec(spec))), asNumeric(1/mpfr(x, 16)) == 2^c(5:7,5), identical(format(spec), c("0.", "NaN", "NaN", "Inf", "-Inf")), mpfr(0.2, prec = 5:15, rnd.mode = "D") < 0.2) B.set <- setNames(2:62, paste0("B=",2:62)) str(lapply(B.set, function(B) format(spec, base= B)))# "0.0" and "0.00" -- FIXME t2 <- mpfr(2^10,3) ## digits = 1 used to crash: MPFR assertion failed: m >= 2 || ((((b) & ((b) - 1)) == 0) == 0 && m >= 1) ## ---------- (+ seg.fault) for 'base = 2' (and others, not for default base = 10), ## digits = NULL should choose "enough" ... but does not str(r <- lapply(B.set, function(B) .mpfr2str(t2, digits=1, base = B))) str(r. <- lapply(B.set, function(B) .mpfr2str(t2, base = B))) ## FIXME: still too short x <- c(-12, 1:3 * pi) sss <- mpfr(x, 100) validObject(sss) sss sss2 <- sss * sss stopifnot(identical(sss2, sss * x), identical(sss2, x * sss), sss ^ 2 == sss2) ## and go back {not sure if identical() is guaranteed here, but it seems...}: stopifnot(identical(x, as(sss, "numeric"))) (cs <- as(sss, "character")) y <- c(0, 100,-10, 1.25, -2.5, x * c(1,100,1e5,1e20), x / 100^(1:4)) (Y <- mpfr(y, 100)) cbind(y, as.data.frame(.mpfr2str(Y, 20))[,c("exp","str")]) s <- mpfr(43208, 14)# low precision eps8 <- 8 * .Machine$double.eps ## checking mpfr -> character -> mpfr: i1..5f <- c("4.e+4", "4.3e+4", "4.32e+4", "43210.", "43208.") stopifnot(exprs = { all.equal(y, as.numeric(format(Y, digits=20)), tol= eps8) all.equal(Y, as(format(Y), "mpfr"), tol= eps8) identical(sapply(1:5, formatMpfr, x=s), i1..5f) identical(sapply(1:5, formatMpfr, x=s, exponent.plus=FALSE), sub("e[+]", "e", i1..5f)) }) ## More character -> mpfr checking : ## from echo 'scale=200; 4*a(1)' | bc -l : cpi <- "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196" pi. <- Const("pi", prec=667) stopifnot(cpi == format(mpfr(cpi, prec=667), digits=201), all.equal(pi., as(cpi, "mpfr")), all.equal(pi., as(cpi, "mpfr"), tol = 1e-200)) set.seed(17) ## Check double -> mpfr -> character -> double : ## Unfortunately, format(, .) -> .mpfr2str() triggers a memory bug ## that I think is an MPFR library "mis-feature" ## 2011-02-09 -- bug *no longer* triggered ! rSign <- function(n) sample(c(-1,1), size = n, replace=TRUE) N <- function(x) as.numeric(x) ntry <- if(Sys.getenv("USER") == "maechler") 150 else 5 for(n in 1:ntry) { cat(if(n %% 10)"." else n) x. <- rSign(100) * rlnorm(100) prec <- rpois(1, 110); digs <- floor(0.95*(prec / log2(10))) X. <- mpfr(x., precBits = prec) stopifnot(all.equal(x., N(format(X., digits=digs)), tol = eps8) , all.equal(x., N(log(exp(X.))), tol = 32*eps8) ) }; cat("\n") stopifnot(identical(mpfr.is.0(X.),# deprecated but must work mpfrIs0 (X.))) X. <- X.[!mpfrIs0(X.)] stopifnot(all( X./X. == 1)) # TRUE u <- mpfr(as.raw(0:100)) z <- mpfr(1:12, 200) z[z > 100] <- 100 # nothing done (but used to fail) z[] <- 0 stopifnot(0:100 == u, is(z,"mpfr"), mpfrIs0(z), all.equal(u, mpfr(0:100, prec = 8), tol = 0), 0:1 == mpfr(1:2 %% 2 == 0)) z[3] <- Const("pi",200) ## z has length 12 -- now extend it: z[15:17] <- 1/mpfr(10:12, 100) stopifnot(all.equal(z[1:4], c(0,0,pi,0), tol = 1e-15), validObject(z), all.equal(z[13:17], c(NaN,NaN, 1/(10:12)), tol = 1e-15)) ## These seg.faulted (each via different R -> C interface) in the past: assertError <- tools::assertError assertError( pp <- Const("pi", prec = 1e11) ) assertError( mpfr("123.456", precBits= 1e11) ) assertError( mpfr(as.bigz(3), precBits= 1e11) ) stopifnot(identical(mpfr(NULL), mpfr(logical()))) ## mpfr --> bigInteger "bigz" Pi <- Const("pi", prec = 300) twoP <- mpfr(2, 100)^(-2:80) m <- Pi * twoP L <- mpfr(2, 256)^1000 stopifnot(exprs = { .mpfr2bigz(Pi) == 3 .mpfr2bigz(twoP) == as.bigz(c(0,0, 2^(0:80))) .mpfr2bigz(m) == floor(m) .mpfr2bigz(m / L) == 0 .mpfr2bigz(m * L) == floor(m * L) ## used to fail .mpfr2bigz(m * L^8) == floor(m * L^8) ## (ditto) }) Rmpfr/tests/bit-repr.Rout.save0000644000176200001440000002151213220705115016033 0ustar liggesusers R Under development (unstable) (2017-06-24 r72853) -- "Unsuffered Consequences" Copyright (C) 2017 The R Foundation for Statistical Computing Platform: x86_64-pc-linux-gnu (64-bit) R is free software and comes with ABSOLUTELY NO WARRANTY. You are welcome to redistribute it under certain conditions. Type 'license()' or 'licence()' for distribution details. R is a collaborative project with many contributors. Type 'contributors()' for more information and 'citation()' on how to cite R or R packages in publications. Type 'demo()' for some demos, 'help()' for on-line help, or 'help.start()' for an HTML browser interface to help. Type 'q()' to quit R. > stopifnot(suppressPackageStartupMessages(require("Rmpfr"))) > ## (checking that the 32 / 64 bit GMP message does *not* show here) > > ### Try to look at the internal bit-representation of the limbs > > .limbs <- function(x) { + stopifnot(is(x, "mpfr")) + lapply(x@.Data, slot, "d") # not sapply() each can have different prec. & #{limbs} + } > .expo <- function(x) { + stopifnot(is(x, "mpfr")) + sapply(x@.Data, slot, "exp") + } > > Bits <- function(x) { + L <- .limbs(x)# list(length n) each of "k(prec)" 32-bit ints + ## NB: mpfr(2, .) and all mpfr(2^k, .) also have a 'd' ending in NA integer! + ## [reason: after all, R's NA_integer_ is INT_MAX+1 = 2^31 ] + ## and the mpfr(c(NA,NaN, Inf, -Inf), .) have *no* NA in 'd' (but all in 'exp'! + ## see .mpfr2list() example below + + hasNA <- any(iNA <- sapply(lapply(L, is.na), any)) # iNA: TRUE if there's an NA + ## need to catch them later + CC <- function(ch) paste(ch, collapse="") + hex <- sapply(L, function(.) CC(sprintf("%x", rev(.)))) + if(hasNA) hex[iNA] <- NA_character_ + hex <- strsplit(hex, NULL) + + db <- t(expand.grid(0:1,0:1,0:1,0:1, KEEP.OUT.ATTRS=FALSE)[,4:1]) + storage.mode(db) <- "character" # "0" or "1" + dimnames(db) <- list(NULL, c(paste(0:9), letters[1:6])) + ## db is 4 x 16 matrix with col.names "0" "1" .. "9" "a" "b" ... "f" + + ex <- .expo(x) + if(is.matrix(ex)) { + ## 64-bit case: exponent is long == two ints + ## ----------- the 2nd int is in {0, -1, NA} (NA : for 0) + ex2 <- ex[2,] + ex <- ex[1,] + } + pat <- paste("(", sapply(pmax(0, ex), + function(n) CC(rep.int(".", n))), + ")0+$", sep="") + ## pat <- ifelse(iNA, NA_character_, pat) + + getbits <- function(ch) CC(as.vector(db[,ch])) + + ## drop trailing zeros (from r[[i]], via pat[i]), keeping correct number: + drop0.r <- function(i) sub(pat[i], "\\1", r[[i]]) + + if(hasNA) { + r <- as.list(iNA) + r[!iNA] <- lapply(hex[!iNA], getbits) + r[!iNA] <- lapply(which(!iNA), drop0.r) + ## FIXME this is wrong -- really have powers of 2, and want their (easy) bits : + r[iNA ] <- NA_character_ + unlist(r) + } + else { + r <- lapply(hex, getbits) + sapply(seq_along(r), drop0.r) + } + + } > > x <- mpfr(r <- c(NA,NaN, Inf, -Inf), 64) > stopifnot(identical(asNumeric(x), # mpfr has no NA, just NaN's: + c(NaN,NaN, Inf, -Inf)), + identical(as.character(fDec <- formatDec(x)), + as.character(asNumeric(x))) # of different nchar() for now + ) > formatDec(x) # should print fine (no quotes) [1] NaN NaN Inf -Inf > > > if(FALSE) # platform dependent: + ## The "non-finite" mpfr value internals (in 64-bit: 'exp' has NA): + str(.mpfr2list(x)) > > > ## bug in Bits(): all (exact) powers of 2 will show as NA: > > x <- mpfr(c(3:5,11:16, 59, 125:128, 1024:1025), 64) > x 16 'mpfr' numbers of precision 64 bits [1] 3 4 5 11 12 13 14 15 16 59 125 126 127 128 1024 [16] 1025 > data.frame(x= as.numeric(x), I(Bits(x))) x Bits.x. 1 3 11 2 4 3 5 101 4 11 1011 5 12 1100 6 13 1101 7 14 1110 8 15 1111 9 16 10 59 111011 11 125 1111101 12 126 1111110 13 127 1111111 14 128 15 1024 16 1025 10000000001 > > x <- mpfr(c(-20:-1, 1:30),64)# w/o 0 - as its mantissa is "random" (in 64-bit) > data.frame(x= as.numeric(x), I(Bits(x))) x Bits.x. 1 -20 10100 2 -19 10011 3 -18 10010 4 -17 10001 5 -16 6 -15 1111 7 -14 1110 8 -13 1101 9 -12 1100 10 -11 1011 11 -10 1010 12 -9 1001 13 -8 14 -7 111 15 -6 110 16 -5 101 17 -4 18 -3 11 19 -2 20 -1 21 1 22 2 23 3 11 24 4 25 5 101 26 6 110 27 7 111 28 8 29 9 1001 30 10 1010 31 11 1011 32 12 1100 33 13 1101 34 14 1110 35 15 1111 36 16 37 17 10001 38 18 10010 39 19 10011 40 20 10100 41 21 10101 42 22 10110 43 23 10111 44 24 11000 45 25 11001 46 26 11010 47 27 11011 48 28 11100 49 29 11101 50 30 11110 > b0 <- Bits(mpfr(0, 64)) # not printing it here -- they are "random" for this special case! > > (half <- mpfr(0.5, 64)*(1 + mpfr(2, 64)^-16 * (-3:3))) 7 'mpfr' numbers of precision 64 bits [1] 0.49997711181640625 0.4999847412109375 0.49999237060546875 [4] 0.5 0.50000762939453125 0.5000152587890625 [7] 0.50002288818359375 > Bits(half) [1] "1111111111111101" "111111111111111" "1111111111111111" [4] NA "10000000000000001" "1000000000000001" [7] "10000000000000011" > > ## pi, in varying number of bits : > p. <- round(pi* 2^c(10,16,5*(4:8))) > dput(p.)#-> the definition of p : c(3217, 205887, 3294199, 105414357, 3373259426, 107944301636, 3454217652358) > p <- mpfr(c(3217, 205887, 3294199, 105414357, + 3373259426, 107944301636, 3454217652358), 64) > stopifnot(all.equal(p., p, tolerance = 1e-15)) > ## all the mantissas are those of pi, rounded differently: > Bits(c(p, Const("pi", 64))) [1] "110010010001" [2] "110010010000111111" [3] "1100100100001111110111" [4] "110010010000111111011010101" [5] "11001001000011111101101010100010" [6] "1100100100001111110110101010001000100" [7] "110010010000111111011010101000100010000110" [8] "1100100100001111110110101010001000100001011010001100001000110101" > > ###--- and possibly the _internal_ sprintfMpfr() --- see also ./tstHexBin.R > ## TODO: use examples above for checking formatBin() <---> ============ > spr <- Rmpfr:::sprintfMpfr > ##= ~~~~~~~~~~~ > (fB.04 <- formatBin(i16.04 <- mpfr(0:16, 4))) [1] +0b0.000p+0 +0b1.000p+0 +0b1.000p+1 +0b1.100p+1 +0b1.000p+2 +0b1.010p+2 [7] +0b1.100p+2 +0b1.110p+2 +0b1.000p+3 +0b1.001p+3 +0b1.010p+3 +0b1.011p+3 [13] +0b1.100p+3 +0b1.101p+3 +0b1.110p+3 +0b1.111p+3 +0b1.000p+4 > (fB.60 <- formatBin(i16.60 <- mpfr(0:16, 60))) [1] +0b0.00000000000000000000000000000000000000000000000000000000000p+0 [2] +0b1.00000000000000000000000000000000000000000000000000000000000p+0 [3] +0b1.00000000000000000000000000000000000000000000000000000000000p+1 [4] +0b1.10000000000000000000000000000000000000000000000000000000000p+1 [5] +0b1.00000000000000000000000000000000000000000000000000000000000p+2 [6] +0b1.01000000000000000000000000000000000000000000000000000000000p+2 [7] +0b1.10000000000000000000000000000000000000000000000000000000000p+2 [8] +0b1.11000000000000000000000000000000000000000000000000000000000p+2 [9] +0b1.00000000000000000000000000000000000000000000000000000000000p+3 [10] +0b1.00100000000000000000000000000000000000000000000000000000000p+3 [11] +0b1.01000000000000000000000000000000000000000000000000000000000p+3 [12] +0b1.01100000000000000000000000000000000000000000000000000000000p+3 [13] +0b1.10000000000000000000000000000000000000000000000000000000000p+3 [14] +0b1.10100000000000000000000000000000000000000000000000000000000p+3 [15] +0b1.11000000000000000000000000000000000000000000000000000000000p+3 [16] +0b1.11100000000000000000000000000000000000000000000000000000000p+3 [17] +0b1.00000000000000000000000000000000000000000000000000000000000p+4 > stopifnot( + identical(sub("00p","p", spr(i16.60, bits = 10)), + spr(i16.60, bits = 4)), + identical(spr(i16.60, bits = 4), + spr(i16.04, bits = 4)) + , + all.equal(i16.04, mpfr(fB.04), tolerance = 0) + , + all.equal(i16.60, mpfr(fB.60), tolerance = 0) + ) > > ## not even this one > two <- mpfr(2, precBits = 60) > stopifnot(identical(two, mpfr(formatBin(two)))) > > > cat('Time elapsed: ', proc.time(),'\n') # "stats" Time elapsed: 0.67 0.102 0.855 0.002 0.001 > > if(!interactive()) warnings() > > proc.time() user system elapsed 0.672 0.103 0.855 Rmpfr/tests/functionals.R0000644000176200001440000000724314274665772015204 0ustar liggesusers#### Tests for "Functionals": Root finding, Optimization, Integration, etc stopifnot(require("Rmpfr")) (f.chk <- system.file("check-tools.R", package="Rmpfr", mustWork=TRUE)) source(f.chk, keep.source=FALSE) ## -> assert.EQ.() showSys.time() options(warn = 1)# warnings *immediately* (doExtras <- Rmpfr:::doExtras()) ### 1. Integration ----------------------------------------------- ## Example from Lauren K, June 2014 (~/R/MM/Pkg-ex/Rmpfr/integrateR-LaurenK.R): beta0 <- 0.05 beta1 <- 0.05 (tau <- sqrt(0.01*0.05*0.95/0.99))# = 0.0219.. ## Z00 <- 9 Z01 <- 1 Z10 <- 18 Z11 <- 2 N <- Z00+Z01+Z10+Z11 integrand <- function(u) { ee.u <- exp(-u^2/2)/(sqrt(2*pi)*tau) b0u <- beta0 + tau*u b1u <- beta1 + b0u # == beta0+beta1+ tau*u ee.u ^ (Z00+Z01 + Z10+Z11) * (1-b0u)^Z00 * b0u ^ Z01 * (1-b1u)^Z10 * b1u ^ Z11 } ## MM: note how the integrand() function looks: op <- par(mfcol=c(3,1), mgp=c(1.5, .6, 0), mar=.1+c(3,3,0,0)) ax1 <- function(a,b) axis(1, at=c(a,b), col=2, col.axis=2, tcl= +3/4, mgp=c(3,0,0)) curve(integrand, -5,5, n=1000) cc <- adjustcolor(2, 1/4) ## look closer: ep <- .01; rect(-3, -ep, 0, +ep, col=cc, border=cc); ax1(-3,0) curve(integrand, -3,0, n=1000, ylim = c(-ep,ep)) ## but now look really closely : ep <- .001; rect(-3, -ep, -2, +ep, col=cc); ax1(-3,-2) curve(integrand, -3,-2, n=1000, ylim = c(-ep, ep)) par(op) (I1 <- integrate(integrand,lower = -100, upper = 100)) (I1. <- integrate(integrand,lower = -100, upper = 100, rel.tol = 1e-14)) showSys.time(I2 <- integrateR(integrand, lower = -100, upper = 100)) I2 ## ... Warning ‘no convergence up to order 13’ ## Solaris Sparc (2014-06, CRAN checks); thanks Brian: print(I2[1:2], digits=15) I2.Solaris <- list(value = 1.3963550396006e+33, abs.error = 1.79487857486724e+28) I.db <- list(value = 1.39635503960059e+33, abs.error = 1.79487857478077e+28) stopifnot( all.equal(I2[1:2], I.db, tol = 1e-10)# Solaris SPARC needs at least 4.8e-11 ) ## Now using high accuracy showSys.time(I3 <- integrateR(integrand, lower = mpfr(-100, precBits=256), upper = 100)) ## much slower but not better (and not worse) I3 assert.EQ.(sapply(I3[1:2], asNumeric), unlist(I.db)) ## Really get better when decreasing the integration interval ## from [-100, 100] to [-10, 10] ... which should give "the same" showSys.time(I4 <- integrateR(integrand, lower = mpfr(-10, precBits=256), upper = 10, ord = 15, verbose=TRUE)) ## ~ 6.6 sec [lynne 2013] I4 ## on the left side, there is "nothing" (and negative, as we know!): showSys.time(I0.1 <- integrateR(integrand, lower = mpfr(-1000, precBits=256), upper = -10, ord= 11, verbose=TRUE)) showSys.time(I0.2 <- integrateR(integrand, lower = mpfr(10, precBits=256), upper = 1000, ord= 11, verbose=TRUE)) I0.1 I0.2 I4 ## Integral [-1000, +1000 ] = Int[-1000, -10] + Int[-10, +10] + Int[+10, +1000]: I4 $value + I0.1 $value + I0.2 $value ## but this is really the same as just the middle: stopifnot(I4 $value + I0.1 $value + I0.2 $value == I4 $value) value <- I4$value; delta <- I4$abs.err nDig <- -asNumeric(log10(delta/value)) cat("Correct number of digits: ", round(nDig, 2),"\n", "Integral I = ", format(I4$value, digits = ceiling(nDig)), " (last change change= ", format(delta, digits = 7),")\n", "integrate(.) = ", format(I1 $value, digits = 22),"\n", "integrate(., rtol=1e-15)= ", format(I1.$value, digits = 22),"\n", sep="") ### 2. Root Finding ---------------------------------------------- ### 3. Optimization / Minimization, .. --------------------------- cat('Time elapsed: ', proc.time(),'\n') # "stats" Rmpfr/tests/matrix-ex.R0000644000176200001440000001506314274665772014574 0ustar liggesusersstopifnot(require("Rmpfr")) x <- mpfr(0:7, 64)/7 mx <- x dim(mx) <- c(4,2) (m. <- mx) # "print" m.[,2] <- Const("pi", 80) m.[,] <- exp(mpfr(1, 90)) stopifnot(is(mx, "mpfrMatrix"), dim(mx) == c(4,2), is(m., "mpfrMatrix"), dim(m.) == dim(mx), dim(is.finite(mx)) == dim(mx), dim(is.nan(mx)) == dim(mx), getPrec(m.) == 90) xx <- (0:7)/7 m.x <- matrix(xx, 4,2) m2 <- mpfr(xx, 64); dim(m2) <- dim(m.x) ## u <- 10*(1:4) y <- 7 * mpfr(1:12, 80) my <- y dim(my) <- 3:4 m.y <- asNumeric(my) stopifnot(all.equal(m2, mpfr(m.x, 64), tol=0), # not identical(..) my[2,2] == 35, my[,1] == 7*(1:3)) .N <- function(x) { if(!is.null(dim(x))) as(x,"array") else as(x,"numeric") } noDN <- function(.) { dimnames(.) <- NULL ; . } allEQ <- function(x,y) all.equal(x,y, tol=1e-15) ## FIXME write "functions" that take x -> {mx , m.x} and run the following as *function* ## ---- then use previous case *and* cases with NA's ! ## and use higher precision via fPrec = 2 etc ... stopifnot(allEQ(m.x, noDN(.N(mx))), allEQ(m.y, noDN(.N(my))), allEQ(noDN(.N(my %*% mx)), m.y %*% m.x), allEQ(noDN(.N(crossprod(mx, t(my)))), crossprod(m.x, t(m.y))), allEQ(noDN(.N(tcrossprod(my, t(mx)))), tcrossprod(m.y, t(m.x))), ## identical(mx, t(t(mx))), identical(my, t(t(my))), ## matrix o vector .. even vector o vector identical(noDN(.N(my %*% 1:4)), m.y %*% 1:4 ), identical(noDN(.N(my %*% my[2,])), m.y %*% .N(my[2,])), identical( crossprod(1:3, my), 1:3 %*% my), identical(tcrossprod(1:4, my), 1:4 %*% t(my)), identical(crossprod(y), t(y) %*% y), identical(tcrossprod(y), y %*% t(y)), identical(noDN(.N( crossprod(y))), crossprod(7 * 1:12)), identical(noDN(.N(tcrossprod(y))),tcrossprod(7 * 1:12)), identical(tcrossprod(1:3, u), noDN(.N(tcrossprod(1:3, as(u,"mpfr"))))) ) mx[3,1] <- Const("pi", 64) stopifnot(allEQ(sum(mx[,1]), pi + 4/7)) m2 <- mx[c(1,4),] stopifnot(dim(m2) == c(2,2), sum(m2) == 2) ## "mpfrArray" o "mpfr" : Tmx <- array(TRUE, dim(mx), dimnames=dimnames(mx)) stopifnot(identical(Tmx, mx == (mx - mpfr(0, 10))), identical(Tmx, mx - mpfr(1, 10) * mx == 0)) ## subassignment, many kinds mx[5] <- pi mx[6] <- Const("pi",100) stopifnot(validObject(mx), allEQ(mx[5], mx[6]), getPrec(mx) == c(rep(64,5), 100, 64,64)) ## %*% with vectors on LHS, ... y <- t(2:4) # 1 x 3 matrix m1 <- (0:10) %*% y m2 <- mpfr(0:10, 50) %*% y stopifnot((d <- m1 - m2) == 0, identical(dim(m1), dim(d)), m2 == m1, m1 == m2) r <- 10*(0:4) y <- t(2:6) m1 <- 1:3 %*% y %*% r y. <- t(mpfr(2:6, 20)) m2 <- 1:3 %*% y. %*% r stopifnot(m1 == m2, m1 - m2 == 0, identical(dim(m1), dim(m2))) ### Array (non-matrix) ---- indexing & sub-assignment : A <- mpfrArray(1:24, prec = 96, dim = 2:4) a <- array(1:24, dim = 2:4) a.1 <- as(A[,,1], "array") a1. <- as(A[1,,], "array") A1. <- as(A[1,,], "mpfr") stopifnot(all.equal(noDN(a.1), a[,,1], tol=0), identical(A1., as.vector(A[1,,])), ## arithmetic, subsetting etc: allEQ(noDN(.N(A / A1.)), a/c(a1.)), allEQ(noDN(.N(a / A1.)), a/c(a1.)), identical(noDN(A == 23), a == 23), identical(noDN(10 >= A), 10 >= a), identical(noDN(A <= 2), a <= 2), identical(noDN(A < 2.5), a < 2.5), identical(noDN(A != 5), a != 5), identical(A != 3, !(3 == A)), identical(-1 > A, A == 100), identical(noDN(A <= 0), a == pi) ) A[1,2,3] <- Const("pi") A[1, ,2] <- 1 / A[1,,2] A ## check that A is "==" a where a <- array(1:24, 2:4); a[1,2,3] <- pi; a[1,,2] <- 1/a[1,,2] stopifnot(allEQ(noDN(.N(A)), a), ## check aperm() methods : allEQ(noDN(.N(aperm(A))), aperm(a)), {p <- c(3,1:2); allEQ(noDN(.N(aperm(A,p))), aperm(a,p))}, {p <- c(2:1,3); allEQ(noDN(.N(aperm(A,p))), aperm(a,p))}) ## cbind() / rbind(): options(warn = 2)## no warnings here - ("exact recycling"): validObject(m0 <- cbind(pi=pi, i = 1:6)) validObject(m1 <- cbind(a=Const("pi",60),i = 1:6, "1/mp" = 1/mpfr(1:3,70))) validObject(m2 <- cbind(pi=pi, i = 1:2, 1/mpfr(1:6,70))) validObject(n2 <- rbind(pi=pi, i = 1:2, 1/mpfr(1:6,70))) stopifnot(is(m0,"matrix"), is(m1, "mpfrMatrix"), is(m2, "mpfrMatrix"), dim(m0) == c(6,2), dim(m1) == c(6,3), dim(m2) == c(6,3)) options(warn = 1) suppressWarnings(eval(ex <- quote(m3 <- cbind(I=10, 1:3, inv=1/mpfr(2:3,80))))) validObject(suppressWarnings( n3 <- rbind(I=10, 1:3, inv=1/mpfr(2:3,80)))) stopifnot(identical(t(n2), m2), identical(t(n3), m3), validObject(m3), is(tryCatch(eval(ex), warning=function(.).), "warning"), identical(cbind("A", "c"), matrix(c("A", "c"), 1,2)), identical(rbind("A", 2), matrix(c("A", "2"), 2,1)) ) ## head() / tail() : stopifnot(all.equal(c(21, 12), dim(mm3 <- m3[rep(1:3, each=7), rep(3:1, 4)])), all.equal(dim(t3 <- tail(mm3)), c(6, 12)), all.equal(head(mm3), mm3[1:6,])) ## matrix() works since 2015-02-28: x <- mpfr(pi,64)*mpfr(2,64)^(2^(0:19)) (mx <- matrix(x, 4,5)) stopifnot(is(mx, "mpfrMatrix"), all.equal(matrix(0:19, 4,5), asNumeric(log2(log2(mx) - log2(Const("pi")))), tol = 1e-15)) # 64b-lnx: see 8.1e-17 ## Ensure that apply() continues to work with 'bigz'/'bigq' A <- matrix(2^as.bigz(1:12), 3,4) Aq <- as.bigq(A) mA <- as(A, "mpfr") # failed {as dim(A) is "double", not "integer"} (Qm <- A / (A^2 - 1)) # big rational matrix MQ <- mpfr(Qm, precBits = 64) stopifnot(exprs = { mA == A mA == Aq is.bigq(Aq) mA == mpfr(A, precBits=16) mA == asNumeric(A) is.bigq(Qm) is(MQ, "mpfrMatrix") all.equal(Qm, MQ, tol = 1e-18) identical(dim(mA), dim(A)) identical(dim(mA), dim(Qm)) identical(asNumeric(apply(A, 1, min)), apply(asNumeric(A), 1, min)) identical(asNumeric(apply(A, 1, max)), apply(asNumeric(A), 1, max)) identical(asNumeric(apply(A, 2, max)), apply(asNumeric(A), 2, max)) identical(asNumeric(apply(A, 2, min)), apply(asNumeric(A), 2, min)) }) ## mA etc, failed up to Rmpfr 0.8-1; the apply() parts failed up to Rmpfr 0.6.0 if(FALSE) ## Bug in gmp : apply(*, range) does *not* return matrix stopifnot( identical(asNumeric(apply(A, 1, range)), apply(asNumeric(A), 1, range)) ) if(FALSE) ## Bug in gmp : --- no mean method for bigz, just mean.bigq stopifnot( all.equal(asNumeric(apply(A, 1, mean)), apply(asNumeric(A), 1, mean)) , all.equal(asNumeric(apply(A, 2, mean)), apply(asNumeric(A), 2, mean)) ) cat('Time elapsed: ', proc.time(),'\n') # "stats" if(!interactive()) warnings() Rmpfr/tests/lowlevel.R0000644000176200001440000002410513523623603014463 0ustar liggesusers#### Low level stuff - debugging etc #### ========= ========= require("Rmpfr") options(warn = 2)# warning -> error identical3 <- function(x,y,z) identical(x,y) && identical (y,z) identical4 <- function(a,b,c,d) identical(a,b) && identical3(b,c,d) ## sane state [when re-source()ing this file]: .mpfr_erange_set("Emin", -(2^30-1)) .mpfr_erange_set("Emax", +(2^30-1)) ###----- _1_ mpfr1 , import, xport etc ----------------------------------------- i8 <- mpfr(-2:5, 32) x4 <- mpfr(c(NA, NaN, -Inf, Inf), 32); x4 # NA -> NaN as well stopifnot(identical3(is.na(x4), is.nan(x4), c(T,T,F,F))) o1 <- as(x4[1], "mpfr1") stopifnot(is(o1, "mpfr1")) # failed previously validObject(o1) # ditto (failed on 64-bit only) stopifnot( getPrec("0xabc", base=16, doNumeric=FALSE) == 3*4, getPrec( "abc", base=16, doNumeric=FALSE) == 3*4, getPrec("0b1001", base=2, doNumeric=FALSE) == 4, getPrec( "1001", base=2, doNumeric=FALSE) == 4, identical3(mpfr("0b101", base= 2), mpfr( "101", base= 2), mpfr(5, precBits = 3)) , identical3(mpfr("0xabc", base=16), mpfr( "abc", base=16), mpfr(2748, base=16, precBits = 12)) ) ## save initial (Emin, Emax) eranges : erangesOrig <- .mpfr_erange() ###----- _2_ Debugging, changing MPFR defaults, .. ----------------------------- ## NB: Currently mostly *not* documented, not even .mpfr_erange() stopifnot(Rmpfr:::.mpfr_debug() == 0 # the default level ## Activate debugging level 1: , Rmpfr:::.mpfr_debug(1) == 0 # the previous level ## and check it : , Rmpfr:::.mpfr_debug() == 1 # the current level ) r <- mpfr(7, 100)^-1000 r ## (same as without debugging) ## where as this does print info: -- notably the very large values [3..6]: .eranges <- function() sapply(.mpfr_erange_kinds, .mpfr_erange, USE.NAMES=FALSE) ## now, mpfr_erange() works with a *vector* of args: .erange2 <- function() .mpfr_erange(.mpfr_erange_kinds) ## now returning *double* - which loses some precision [ending in '04' instead of '03']: formatC(.eranges(), format="fg") stopifnot(identical(.eranges(), .erange2())) .mpfr_minPrec() .mpfr_maxPrec()# debug printing shows the long integer (on 64 bit) ## Now, level 2 : stopifnot(Rmpfr:::.mpfr_debug(2) == 1) r ## with quite a bit of output if(FALSE) # on Winbuilder [2019-08-08, both 32 and 64 bit]: .mpfr_erange_set("Emax", 1073741823) r2 <- r^100 r2 L <- r^-100000 L3 <- L^3 str(L3, internal=TRUE) ## Class 'mpfr' [package "Rmpfr"] of length 1 and precision 100 ## internally @.Data: List of 1 ## $ :Formal class 'mpfr1' [package "Rmpfr"] with 4 slots ## .. ..@ prec: int 100 ## .. ..@ exp : int [1:2] 842206477 0 ## .. ..@ sign: int 1 ## .. ..@ d : int [1:4] 268435456 761715680 1492345294 -1000766770 str(L3) ## lots of debugging output, then ## 1.00989692356e+253529412 ## ^^~~~~~~~~~ 10 ^ 253'529'412 that is humongous if(!interactive()) # not seg.faulting, but printing a *huge* line [no longer!] show(L3) ## segmentation fault -- randomly; 2017-06: no longer see any problem, not even with if(FALSE) ## well, not really, definitely not interactively for now if(interactive()) for(i in 1:256) show(L3) ## ## quite platform dependent {valgrind ==> bug? even in mpfr/gmp/.. ?} str(.mpfr2list(x4)) ## slightly nicer ["uniformly not worse"] (still very similar) : str(x4, internal=TRUE) x4 ## "similar info" as .mpfr2list(.) ## Increase maximal exponent: tools:::assertWarning( .mpfr_erange_set("Emax", 5e18)) # too large {FIXME why only warning and not error ??} .mpfr_erange("Emax") # is unchanged if(4e18 < .mpfr_erange("max.emax")) { .mpfr_erange_set("Emax", 4e18) # now ok: stopifnot(.mpfr_erange("Emax") == 4e18) } ## revert to no debugging: stopifnot(Rmpfr:::.mpfr_debug(0) == 2) .mpfr_maxPrec() L / (r2^-1000)# 1.00000....448 (could be more accurate?) stopifnot(exprs = { all.equal(L, r2^-1000, tol= 1e-27) # why not more accurate? all.equal(log(L), -100000 * (-1000) * log(7), tol = 1e-15) }) ## Now, our experimental "transport vehicle": stopifnot(length(rv <- c(r, r2, L)) == 3) str(mpfrXport(rv)) str(mpfrXport(mpfr(2, 64)^(-3:3))) str(mpfrXport(Const("pi")* 2^(-3:3))) ## and a very large one mil <- mpfr(1025, 111) str(mm <- mpfrXport(xx <- mil^(2^25))) stopifnot(all.equal(log2(xx) * 2^-25, log2(mil), tol=1e-15)) ## even larger -- strictly needs extended erange: if(.mpfr_erange("min.emin") <= -2^40) { .mpfr_erange_set("Emin", - 2^40) show(xe <- 2^mpfr(-seq(1,70, by=3)*8e8, 64)) ## used to print wrongly {because of integer overflow in .mpfr2str()$exp}, ## with some exponents large positive stopifnot(exprs = { ! .mpfr_erange_is_int() # as 'exp's now are double (ee <- as.numeric(sub(".*e","", formatMpfr(xe)))) < -240e6 (diff(ee) + 722471990) %in% 0:1 }) } else { cat(sprintf( "Cannot set 'Emin' to -2^40 (= %g), as .mpfr_erange(\"min.emin\") is larger, namely %g.\n", - 2^40, .mpfr_erange("min.emin"))) } ## Bill Dunlap's example (with patch about convert S_alloc bug): ## (precision increases, then decreases) z <- c(mpfr(1,8)/19, mpfr(1,32)/19, mpfr(1,24)/19) cbind(fz <- format(z)) stopifnot(identical(fz, rev(format(rev(z))))) stopifnot(identical(fz, c("0.05273", "0.052631578947", "0.0526315793"))) # << smaller prec, again since 2019-08-09 e.xx. <- .mpfr2exp(xx) e.z. <- .mpfr2exp(z) ## revert to original 'erange' settings (which gives integer 'exp'): .mpfr_erange_set("Emax", erangesOrig[["Emax"]]) # typically 2^30 - 1 = 1073741823 .mpfr_erange_set("Emin", erangesOrig[["Emin"]]) e.xx <- .mpfr2exp(xx) e.z <- .mpfr2exp(z) stopifnot(exprs = { .mpfr_erange_is_int() e.xx == e.xx. e.xx == 335591572 e.z == e.z. e.z == -4 is.integer(e.xx) # but e.xx. is double is.integer(e.z) }) k1 <- mpfr( c(123, 1234, 12345, 123456), precBits=2) (N1 <- asNumeric(k1))# 128 1024 12288 131072 -- correct str(sk1 <- .mpfr2str(k1)) str(sk1. <- .mpfr2str(k1, maybe.full=TRUE)) str(sk1.2 <- .mpfr2str(k1, digits=2, base=2)) str(sk1.2F <- .mpfr2str(k1, maybe.full=TRUE, base=2)) stopifnot(exprs = { identical(sk1 [1:2], list(str = c("13", "10", "12", "13"), exp = 3:6)) identical(sk1.[1:2], list(str = c("128", "1024", "12288", "131072"), exp = 3:6)) identical(sk1.2, list(str = c("10", "10", "11", "10"), exp = c( 8L, 11L, 14L, 18L), finite = rep(TRUE, 4), is.0 = rep(FALSE, 4))) all.equal(sk1.2[2:4], .mpfr_formatinfo(k1), tol=0) # not identical(): int <-> double identical(formatMpfr(k1, base=2, digits=20, drop0trailing=TRUE), with(sk1.2, paste0(str, sapply(exp - nchar(str), strrep, x="0")))) identical(formatMpfr(k1, base=2, digits=2, exponent.plus=FALSE), c("1.0e7", "1.0e10", "1.1e13", "1.0e17")) }) ## MM: --> need_dig is fine but is not used in the string that is returned !! (fk1sF <- formatMpfr(k1, scientific=FALSE)) # "the bug" --- now fixed! ==> new "Bug" in new Rmpfr ???? ## was "128." "1024." "12288." "131072." , but now obeying internal precision gives ## "1.e2" "1.e3" "1.e4" "1.e5" (fk1 <- formatMpfr(k1, digits=6)) stopifnot(exprs = { N1 == as.numeric(fk1) ## FIXME: This should change again "1024" identical(format(k1, digits=3), c("128.", "1020.", "1.23e+4", "1.31e+5")) }) ## digs <- setNames(1:6, 1:6) ## Each of these are 4 x 6 matrices ffix <- sapply(digs, function(d) format(k1, digits = d, scientific = FALSE)) ## *not* good at all .. ## ==> need a maybe.full=TRUE even here ff <- sapply(digs, function(d) format(k1, digits = d))# sci..fic = NA -- digits=1 failing for '128' fsci <- sapply(digs, function(d) format(k1, digits = d, scientific = TRUE)) # perfect stopifnot(exprs = { length(dd <- dim(ff)) == 2 identical(dd, dim(ffix)) identical(dd, dim(fsci)) all.equal(asNumeric(fsci), asNumeric(ffix) -> dmat, tol=0) all.equal(asNumeric(ff), asNumeric(ffix), tol=0) }) rE <- 1 - dmat / asNumeric(k1) i <- 1:5 summary(fm <- lm(log10(colMeans(abs(rE)))[i] ~ i)) stopifnot(exprs = { rE[ cbind(FALSE, upper.tri(rE)[,-6]) ] == 0 abs(residuals(fm)) < 0.15 }) ## formatting / printing : tenth <- mpfr(-12:12, 52)/10 cents <- mpfr(-11:11, 64)/100 (kxi <- sort(c(k1, x4, i8, tenth, cents), na.last=FALSE)) mstr <- .mpfr2str (kxi) mfi <- .mpfr_formatinfo(kxi) es <- mstr$exp # base 10 ; with '0' when !is.finite or is0 ef <- mfi $exp # base 2 ; "undefined" when !is.finite or is0 j2 <- c("finite", "is.0") dxi <- cbind(x = asNumeric(kxi), prec = .getPrec(kxi), as.data.frame(mstr, stringsAsFactors = FALSE)) stopifnot(is.data.frame(dxi), identical(mstr$str, dxi[,"str"]), identical(mstr[j2], mfi[j2]), identical(ef, .mpfr2exp(kxi))) dxi ## 2019-08-09: again *varying* size of 'str' rather than only growing !! ## Show that *order* no longer matters: n <- length(ixk <- rev(kxi)) dix <- cbind(x = asNumeric(ixk), prec = .getPrec(ixk), as.data.frame(.mpfr2str(ixk), stringsAsFactors = FALSE))[n:1,] attr(dix, "row.names") <- .set_row_names(n) stopifnot(identical(dxi, dix)) ## somewhat (but not so much) revealing : cbind(prec = .getPrec(kxi), kxi = asNumeric(kxi), str = es, fi.10 = ceiling(ef/log2(10)), str.2 = as.integer(es*log2(10)), fi = ef) ## Bug example from RMH 2018-03-16 : (x <- mpfr(c(65, 650, 6500, 65000, 650000), precBits=6)) data.frame(fDec = formatDec(x), f = formatMpfr(x)) x. <- as.numeric(xDec <- formatDec(x)) stopifnot(abs(x - x.) <= c(0, 0, 2, 12, 360)) cat("Checking compatibility .mpfr_formatinfo() <--> .mpfr2str(*, base=2) :\n") for(nm in ls()) if(is(OO <- get(nm), "mpfr")) { cat(nm,": str(*) :\n"); str(OO); cat("compatibility: ") I <- .mpfr_formatinfo(OO) S <- .mpfr2str(OO, base = 2L) if(identical(I, S[-1])) cat("[Ok]\n") else { if(any(B <- !I$finite)) I$exp[B] <- S$exp[B] if(any(B <- I $ is.0)) I$exp[B] <- S$exp[B] if(identical(I, S[-1])) cat(" after fixup [Ok]\n") else stop(".mpfr_formatinfo(*) and .mpfr2str(*, base=2) do not match") } } Rmpfr/tests/binomial-etc.R0000644000176200001440000000230214547462101015171 0ustar liggesusersstopifnot(require("Rmpfr")) n <- 10000 + 0:10 stopifnot(exprs = { chooseMpfr(1:10, 0) == 1 # failed earlier chooseMpfr(20, 0:20) == choose(20, 0:20) chooseMpfr(19, 0:20) == choose(19, 0:20) chooseMpfr (30, 4:30) * (-1)^(4:30) == chooseMpfr.all(30, k0=4, alternating=TRUE) chooseMpfr(mpfr(1111, 2^8), 1111) == 1 chooseMpfr(mpfr(n,256), n ) == 1 # was wrong in <= 2023 chooseMpfr(mpfr(n,256), n-1) == n # " " }) cat('Time elapsed: ', proc.time(),'\n') # "stats" ## sumBinomMpfr() ... had embarrasing bug for a while sBn <- Rmpfr:::sumBinomMpfr.v1 stopifnot( all.equal( sBn(10, sqrt), sumBinomMpfr(10, sqrt), tol=1e-77) , all.equal( sBn(10, log, n0=1, alternating=FALSE), sumBinomMpfr(10, log, n0=1, alternating=FALSE), tol=1e-77) ) fBin <- function(k) x^k * (1-x)^(n-k) ## \sum_{k=0}^n (n \\ k) x^k (1-x)^{n-k} == sum(dbinom(0:n, n, prob=x)) == 1 : for(x in runif(50)) { n <- 1 + rpois(1, lambda=10) cat(".") stopifnot(all.equal(1, sumBinomMpfr(n, fBin, alternating=FALSE), tol = 1e-15)) };cat("\n") cat('Time elapsed: ', proc.time(),'\n') # "stats" if(!interactive()) warnings() Rmpfr/tests/bit-repr.R0000644000176200001440000001031013220705115014340 0ustar liggesusersstopifnot(suppressPackageStartupMessages(require("Rmpfr"))) ## (checking that the 32 / 64 bit GMP message does *not* show here) ### Try to look at the internal bit-representation of the limbs .limbs <- function(x) { stopifnot(is(x, "mpfr")) lapply(x@.Data, slot, "d") # not sapply() each can have different prec. & #{limbs} } .expo <- function(x) { stopifnot(is(x, "mpfr")) sapply(x@.Data, slot, "exp") } Bits <- function(x) { L <- .limbs(x)# list(length n) each of "k(prec)" 32-bit ints ## NB: mpfr(2, .) and all mpfr(2^k, .) also have a 'd' ending in NA integer! ## [reason: after all, R's NA_integer_ is INT_MAX+1 = 2^31 ] ## and the mpfr(c(NA,NaN, Inf, -Inf), .) have *no* NA in 'd' (but all in 'exp'! ## see .mpfr2list() example below hasNA <- any(iNA <- sapply(lapply(L, is.na), any)) # iNA: TRUE if there's an NA ## need to catch them later CC <- function(ch) paste(ch, collapse="") hex <- sapply(L, function(.) CC(sprintf("%x", rev(.)))) if(hasNA) hex[iNA] <- NA_character_ hex <- strsplit(hex, NULL) db <- t(expand.grid(0:1,0:1,0:1,0:1, KEEP.OUT.ATTRS=FALSE)[,4:1]) storage.mode(db) <- "character" # "0" or "1" dimnames(db) <- list(NULL, c(paste(0:9), letters[1:6])) ## db is 4 x 16 matrix with col.names "0" "1" .. "9" "a" "b" ... "f" ex <- .expo(x) if(is.matrix(ex)) { ## 64-bit case: exponent is long == two ints ## ----------- the 2nd int is in {0, -1, NA} (NA : for 0) ex2 <- ex[2,] ex <- ex[1,] } pat <- paste("(", sapply(pmax(0, ex), function(n) CC(rep.int(".", n))), ")0+$", sep="") ## pat <- ifelse(iNA, NA_character_, pat) getbits <- function(ch) CC(as.vector(db[,ch])) ## drop trailing zeros (from r[[i]], via pat[i]), keeping correct number: drop0.r <- function(i) sub(pat[i], "\\1", r[[i]]) if(hasNA) { r <- as.list(iNA) r[!iNA] <- lapply(hex[!iNA], getbits) r[!iNA] <- lapply(which(!iNA), drop0.r) ## FIXME this is wrong -- really have powers of 2, and want their (easy) bits : r[iNA ] <- NA_character_ unlist(r) } else { r <- lapply(hex, getbits) sapply(seq_along(r), drop0.r) } } x <- mpfr(r <- c(NA,NaN, Inf, -Inf), 64) stopifnot(identical(asNumeric(x), # mpfr has no NA, just NaN's: c(NaN,NaN, Inf, -Inf)), identical(as.character(fDec <- formatDec(x)), as.character(asNumeric(x))) # of different nchar() for now ) formatDec(x) # should print fine (no quotes) if(FALSE) # platform dependent: ## The "non-finite" mpfr value internals (in 64-bit: 'exp' has NA): str(.mpfr2list(x)) ## bug in Bits(): all (exact) powers of 2 will show as NA: x <- mpfr(c(3:5,11:16, 59, 125:128, 1024:1025), 64) x data.frame(x= as.numeric(x), I(Bits(x))) x <- mpfr(c(-20:-1, 1:30),64)# w/o 0 - as its mantissa is "random" (in 64-bit) data.frame(x= as.numeric(x), I(Bits(x))) b0 <- Bits(mpfr(0, 64)) # not printing it here -- they are "random" for this special case! (half <- mpfr(0.5, 64)*(1 + mpfr(2, 64)^-16 * (-3:3))) Bits(half) ## pi, in varying number of bits : p. <- round(pi* 2^c(10,16,5*(4:8))) dput(p.)#-> the definition of p : p <- mpfr(c(3217, 205887, 3294199, 105414357, 3373259426, 107944301636, 3454217652358), 64) stopifnot(all.equal(p., p, tolerance = 1e-15)) ## all the mantissas are those of pi, rounded differently: Bits(c(p, Const("pi", 64))) ###--- and possibly the _internal_ sprintfMpfr() --- see also ./tstHexBin.R ## TODO: use examples above for checking formatBin() <---> ============ spr <- Rmpfr:::sprintfMpfr ##= ~~~~~~~~~~~ (fB.04 <- formatBin(i16.04 <- mpfr(0:16, 4))) (fB.60 <- formatBin(i16.60 <- mpfr(0:16, 60))) stopifnot( identical(sub("00p","p", spr(i16.60, bits = 10)), spr(i16.60, bits = 4)), identical(spr(i16.60, bits = 4), spr(i16.04, bits = 4)) , all.equal(i16.04, mpfr(fB.04), tolerance = 0) , all.equal(i16.60, mpfr(fB.60), tolerance = 0) ) ## not even this one two <- mpfr(2, precBits = 60) stopifnot(identical(two, mpfr(formatBin(two)))) cat('Time elapsed: ', proc.time(),'\n') # "stats" if(!interactive()) warnings() Rmpfr/tests/tstHexBin.R0000644000176200001440000001470014420454417014544 0ustar liggesusersrequire(Rmpfr) sessionInfo() nums <- c(0, .625, .1, .3, .3125, .5, .6, (.3+.6), .9, 1, 3.3125) nums9 <- mpfr(nums, precBits = 9) n5.b2 <- mpfr("101", base=2) stopifnot(identical(n5.b2, mpfr(5, precBits=3)), identical(n5.b2, mpfr("0b101", base=2))) if(FALSE)## 0b101 could also be a Hex number with no initial '0x' -- hence NOT true: identical(n5.b2, mpfr("0b101")) ## We *could* say that anything starting with '0b' is binary, anything with '0x' is hexadecimal ### mpfr_Bcharacter() {no longer method} [was 'mpfrBchar', was 'scanBin'] : ##' Check the inverse of formatBin(), i.e., mpfr() working correctly chkInv.fBin <- function(x, ...) { stopifnot(is(x, "mpfr")) nb <- formatBin(x, ...) xx <- mpfr(nb) ## Inverse should work {apart from 0: that is not uniquely represented in MPFR!} stopifnot(identical(mpfrIs0(x ) -> i0, mpfrIs0(xx)), identical(x[!i0], xx[!i0])) invisible(nb) } (nums9bc <- chkInv.fBin(nums9)) (nums9bF <- chkInv.fBin(nums9, scientific=FALSE)) # "F": Fixed format (as in Fortran) ## higher precision, 0,Inf, sign change: (i12 <- 1 / mpfr(c(-2:12, Inf), 64)) (i12.50 <- roundMpfr(i12, precBits=50)) # "same", with 50 (< 53) bits try({ ## FIXME -- formatBin() bug -- fails for 'Inf' ! (nI.12 <- chkInv.fBin(i12 )) (nI.12.50 <- chkInv.fBin(i12.50)) }) ii <- mpfr(c(-Inf, 17, Inf), 7) formatHex(ii) ## fine formatDec(ii) ## not 100% ok, as it has "." [FIXME ?] n9. <- Rmpfr:::mpfr.Ncharacter(nums9bc) n9_ <- mpfr(nums9bc) ## Inverse worked {apart from 0: it is not at all uniquely represented in MPFR!} stopifnot(identical(mpfrIs0(n9.), mpfrIs0(n9_)), all.equal(n9_, n9., tolerance=0), identical(nums9[-1], n9.[-1])) mpfr(nums9bc, precBits=5) (n9.5 <- mpfr(nums9bF, scientific=FALSE, precBits=5)) stopifnot(all.equal(n9.5, mpfr(nums9bF, precBits=5), tol=0)) stopifnot(all.equal(n9., n9.5, tol = 0.02), getPrec(n9.5) == 5) mpfr(nums9bF, scientific=FALSE) mpfr(nums9bF) ### mpfr() -> mpfrHchar (was 'scanHex') : nums9hc <- formatHex(nums9) stopifnot(all.equal(n9., mpfr(nums9hc), tol = 0), all.equal(n9.5, mpfr(nums9hc, precBits=5), tol = 0)) ### Rest from ../R/formatHex.R -- heavily modified (m32 <- matrix(0:31, 8, 4, dimnames = list(0:7, c(0,8,16,24)))) FourBits <- mpfr(m32, precBits=4) FiveBits <- mpfr(m32, precBits=5) stopifnot(all.equal(m32, asNumeric(FiveBits), tol=0), all.equal(m32, asNumeric(FourBits), tol= 0.05)) ## HH:::formatHexInternal(FourBits) formatHex(FourBits) formatHex(FourBits, precBits=5) formatHex(FourBits, precBits=6) formatBin(FourBits) formatBin(FourBits, precBits=5) formatBin(FourBits, scientific=FALSE) formatBin(FourBits, scientific=FALSE, precBits=5) formatDec(FourBits) formatDec(FourBits, precBits=5) formatDec(FourBits, precBits=7) ## HH:::formatHexInternal(FiveBits) formatHex(FiveBits) formatHex(FiveBits, precBits=5) formatHex(FiveBits, precBits=6) formatBin(FiveBits) formatBin(FiveBits, precBits=5) formatBin(FiveBits, precBits=6) formatBin(FiveBits, scientific=FALSE) formatBin(FiveBits, scientific=FALSE, precBits=6) formatDec(FiveBits) formatDec(FiveBits, precBits=5) formatDec(FiveBits, precBits=7) TenPowers <- mpfr(matrix(10^(-3:5)), precBits=53) row.names(TenPowers) <- -3:5 TenPowers options(width = 180) # for several "wide" displays below ## This indirectly "checks' as.data.frame.Ncharacter(): mkDF <- function(mv, displaydigits = 4, stringsAsFactors = FALSE) { stopifnot(is.numeric(mv) || inherits(mv, "mpfr")) data.frame(Hex = formatHex(mv), Bin = formatBin(mv), BinF= formatBin(mv, scientific=FALSE), Dec = formatDec(mv), Dec4= formatDec(mv, displaydigits=displaydigits), Dec.= formatDec(mv, scientific=TRUE), Dec.4=formatDec(mv, scientific=TRUE, displaydigits=displaydigits), stringsAsFactors = stringsAsFactors) } nmsMkDF <- c("Hex", "Bin", "BinF", "Dec", "Dec4", "Dec.", "Dec.4") d10p. <- mkDF(TenPowers) (d10p <- mkDF(as.vector(TenPowers))) TenFrac <- matrix((1:10)/10, dimnames=list(1:10, expression(1/x))) TenFrac stopifnot(exprs = { is.matrix(print(formatHex(TenFrac))) # stays a matrix is.matrix(print(formatBin(TenFrac))) is.matrix(print(formatBin(TenFrac, scientific=FALSE))) is.matrix(print(formatDec(TenFrac))) }) TenFrac9 <- mpfr(TenFrac, precBits=9) TenFrac9 data.frame(Hex = formatHex(TenFrac9), ## checking as.data.frame.Ncharacter as well Bin = formatBin(TenFrac9), BinF= formatBin(TenFrac9, scientific=FALSE), Dec = formatDec(TenFrac9)) -> d9 d9 ## Does not print the column names but the colnames of each 1-col. matrix ("1/x"). ## This is how R in general works { in format.data.frame() } ## now use vectors: tenfrac9 <- as.vector(TenFrac9) stopifnot(identical(tenfrac9, c(TenFrac9))) data.frame(Hex = formatHex(tenfrac9), Bin = formatBin(tenfrac9), BinF= formatBin(tenfrac9, scientific=FALSE), Dec = formatDec(tenfrac9)) -> dl9 dl9 # (now prints as d9 had printed in the past) stopifnot(exprs = { getPrec(TenFrac ) == 53 getPrec(TenFrac9) == 9 colnames(d9) == c("Hex", "Bin", "BinF", "Dec") inherits(d9, "data.frame") all.equal(dim(d9), c(10,4)) }) (Ten <- matrix(1:10 + 0.0, dimnames=list(1:10, "x"))) ## + 0.0 forces double precision dT <- mkDF(Ten) dt <- mkDF(as.vector(Ten)) dt # large (Ten4 <- mpfr(Ten, precBits=4)) ten4 <- as.vector(Ten4) D4 <- mkDF(Ten4) # would be printing "x" --- because we added one-column matrices !! (d4 <- mkDF(ten4)) # printing fine ! stopifnot(identical(names(d4), names(D4)), identical(names(d4), nmsMkDF)) Two8 <- matrix(2^seq(-8, 8)) Two8.3 <- mpfr(Two8, precBits=3) ## formatBin stopifnot( identical(sapply(as(Two8.3, "mpfr")[-c(1:3, 15:17)], function(t83) formatBin(t83, scientific=FALSE)), c("+0b.____100", "+0b.___100", "+0b.__100", "+0b._100", "+0b.100", "+0b1.00","+0b10.0","+0b100.","+0b100_.","+0b100__.","+0b100___."))) ## formatDec --- these must be perfectly aligned on the "." ! formatDec(Two8.3, digits = 3) formatDec(Two8.3, digits = 8) stopifnot( identical(capture.output(formatDec(Two8.3, digits = 3))[2:4], c(" [1,] 0.00391", " [2,] 0.00781", " [3,] 0.0156 ")) , identical(capture.output(formatDec(Two8.3, digits = 8))[c(2:3,8,13,16)], c(" [1,] 0.0039062500", " [2,] 0.0078125000", " [7,] 0.25000000 ", "[12,] 8.0000000 ", "[15,] 64.000000 ")) ) Rmpfr/tests/special-fun-ex.R0000644000176200001440000004117714552770112015463 0ustar liggesusersstopifnot(require("Rmpfr")) (doExtras <- Rmpfr:::doExtras()) options(nwarnings = 50000, width = 99) (do.pdf <- !dev.interactive(orNone = TRUE)) if(do.pdf) { pdf.options(width = 8.5, height = 6) # for all pdf plots pdf("special-fun.pdf") } ## to enhance |rel.Err| plots: {also in ~/R/Pkgs/DPQ/tests/pow-tst.R } drawEps.h <- function(p2 = -(53:51), side = 4, lty=3, lwd=2, col=adjustcolor(2, 1/2)) { abline(h = 2^p2, lty=lty, lwd=lwd, col=col) axis(side, las=2, line=-1, at = 2^p2, labels = as.expression(lapply(p2, function(p) substitute(2^E, list(E=p)))), col.axis = col, col=NA, col.ticks=NA) } mtextVersion <- function(adj = 1, col = 1) { mtext(osVersion, line=1, col=col, adj=adj) mtext(sfsmisc::shortRversion(spaces=FALSE), col=col, adj=adj) } all.eq.finite <- function(x,y, ...) { ## x = 'target' y = 'current' if(any(is.finite(y[!(fx <- is.finite(x))]))) return("current has finite values where target has not") if(any(is.finite(x[!(fy <- is.finite(y))]))) return("target has finite values where current has not") ## now they have finite values at the same locations all.equal(x[fx], y[fy], ...) } n <- 1000 head(x <- mpfr(0:n, 100) / n) stopifnot(exprs = { range(x) == 0:1 all.equal(as.numeric(j0(x)), besselJ(as.numeric(x), 0), tol = 1e-14) all.equal(as.numeric(j1(x)), besselJ(as.numeric(x), 1), tol = 1e-14) all.equal(as.numeric(y0(x)), besselY(as.numeric(x), 0), tol = 1e-14) all.equal(as.numeric(y1(x)), besselY(as.numeric(x), 1), tol = 1e-14) }) ### pnorm() -> erf() : ---------------------------------------------------------- u <- 7*x - 2 stopifnot(all.equal(pnorm(as.numeric(u)), as.numeric(pnorm(u)), tol = 1e-14)) ## systematic random input testing: set.seed(101) if(doExtras) { nSim <- 50 n2 <- 100 } else { nSim <- 10 n2 <- 64 } for(n in 1:nSim) { N <- rpois(1, lambda=n2) N3 <- N %/% 3 x <- c(rnorm(N-N3), 10*rt(N3, df=1.25))# <- some large values m <- rnorm(N, sd = 1/32) s <- rlnorm(N, sd = 1/8) cEps <- .Machine$double.eps for(LOG in c(TRUE,FALSE)) for(L.T in c(TRUE,FALSE)) { p. <- pnorm( x, m=m,sd=s, log.p=LOG, lower.tail=L.T) stopifnot(all.equal(p., pnorm(mpfr(x, precBits= 48), m=m,sd=s, log.p=LOG, lower.tail=L.T), tol = 128 * cEps)) stopifnot(all.equal(p., pnorm(mpfr(x, precBits= 60), m=m,sd=s, log.p=LOG, lower.tail=L.T), tol = 2 * cEps)) } cat(".") };cat("\n") proc.time() ## Jerry Lewis - Aug 2, 2019 ## Contrast the results of pnorm with double and mpfr inputs x <- c(1:9, 5*(2:9), 10*(5:20)) ; x <- c(-rev(x), 0, x) pdL <- pnorm(x, log.p=TRUE) pdU <- pnorm(x, log.p=TRUE, lower.tail=FALSE) stopifnot(exprs = { !is.unsorted(x) 35 %in% x x == -rev(x) # exactly pdL == rev(pdU) # even exactly, currently }) mx <- mpfr(x, precBits = 128) pmL <- pnorm(mx, log.p=TRUE) pmU <- pnorm(mx, log.p=TRUE, lower.tail=FALSE) stopifnot(exprs = { pmL < 0 # not true for 'pdL' which underflows pmL == rev(pmU) # even exactly, currently all.equal(pmL, pdL, tol=4e-16) # 'tol=0' shows 4.46e-17 }) ## some explorations : dlp <- diff(log(-pmL))/diff(x) n <- length(x) x.1 <- (x[-1] + x[-n])/2 plot(x.1, dlp, type="b", ylab = "d/dx log(-pnorm(., log=TRUE))"); mtextVersion() plot(x.1[-1], diff(dlp)/diff(x.1), type="b", ylab = "d^2/dx^2 log(-pnorm(., log=TRUE))") stopifnot(exprs = { -1 < (d2 <- diff(dlp)/diff(x.1)) d2 < 0 diff(d2) < 0 }) x.3 <- x.1[-c(1L,n-1L)] plot(x.3, -diff(d2)/ diff(x.1)[-1], type="o", log="y") ### Riemann's Zeta function: ---------------------------------------------------- ## -- integer arguments -- stopifnot(all(mpfrIs0(zeta(-2*(1:100))))) k.neg <- 2*(-100:0) - 1 Z.neg <- zeta(k.neg) plot(k.neg, abs(as.numeric(Z.neg)), type = "l", log="y") Pi <- Const("pi", 128L) ## confirm published value of Euler's gamma to 100 digits pub.g <- paste("0.5772156649", "0153286060", "6512090082", "4024310421", "5933593992", "3598805767", "2348848677", "2677766467", "0936947063", "2917467495", sep="") ## almost = our.g <- Const("gamma", log2(10) * 100) # 100 digits (ff.g <- .mpfr2str(our.g)) M <- function(x) mpfr(x, 128L) stopifnot(all.equal(zeta( 0), -1/2, tol = 2^-100) , all.equal(zeta(-1), -1/M(12), tol = 2^-100) , all.equal(zeta(-3), 1/M(120), tol = 2^-100) ## positive ones : , all.equal(zeta(2), Pi^2/6, tol = 2^-100) , all.equal(zeta(4), Pi^4/90, tol = 2^-100) , all.equal(zeta(6), Pi^6/945, tol = 2^-100) ) ### Exponential Integral Ei(.) curve(Ei, 0,5, n=5001) if(mpfrVersion() >= "3") { ## only available since MPFR 3.0.0 ### Airy function Ai(.) curve(Ai, -10, 5, n=5001); abline(h=0,v=0, col="gray", lty=3) } ### Utilities hypot(), atan2() : -------------------------------------------------------------- ## ======= TODO! ======== ## beta(), lbeta() ## --------------- ## The simplistic "slow" versions: B <- function(a,b) { a <- as(a, "mpfr"); b <- as(b, "mpfr"); gamma(a)*gamma(b) / gamma(a+b) } lB <- function(a,b) { a <- as(a, "mpfr"); b <- as(b, "mpfr"); lgamma(a)+lgamma(b) - lgamma(a+b) } ## For partly *integer* arguments Bi1 <- function(a,b) 1/(a*chooseMpfr(a+b-1, a)) # a must be integer >= 0 Bi2 <- function(a,b) 1/(b*chooseMpfr(a+b-1, b)) # b must be integer >= 0 x <- 1:10 + 0 ; (b10 <- mpfr(x, 128L)) stopifnot(all.equal( B(1,b10), 1/x), all.equal( B(2,b10), 1/(x*(x+1))), all.equal( beta(1,b10), 1/x), all.equal( beta(2,b10), 1/(x*(x+1))), TRUE) if(do.pdf) { dev.off(); pdf("special-fun-beta.pdf") } x <- -10:10 + 0; X <- mpfr(x, 128L) stopifnot(exprs = { Bi1(1,X) == (B1x <- Bi2(X,1)) Bi1(2,X) == (B2x <- Bi2(X,2)) Bi1(3,X) == (B3x <- Bi2(X,3)) all.equal(B1x, 1/x, tol= 4e-16) all.equal(B2x, 1/(x*(x+1)), tol= 8e-16) all.equal(B3x, 2/(x*(x+1)*(x+2)), tol=16e-16) ## these the "poles" are all odd i.e. result in { +Inf / -Inf / NaN} ## are all "ok" {e.g. 1/(x*(x+1)) gives (-Inf, Inf) for x = -1:0 } all.eq.finite(beta(1,X), 1/x) all.eq.finite(beta(X,2), 1/(x*(x+1))) all.eq.finite(beta(3,X), 2/(x*(x+1)*(x+2)), tol=16e-16) }) ## (a,b) *both* integer, one negative: for(i in (-20):(-1)) { cat(i,":\n") a <- mpfr(i, 99) i1 <- i+1 b. <- seq_len(-i1) Bab <- beta(a, b.) stopifnot(is.nan(beta(a, (i1:0))), is.nan(lbeta(a, (i1:0))), all.equal(Bab, Bi2(a, b.), tol=1e-20), all.equal(lbeta(a, b.), log(abs(Bab)), tol=1e-20), allow.logical0 = TRUE) } ## (a,b) all positive c10 <- b10 + 0.25 for(a in c(0.1, 1, 1.5, 2, 20)) { stopifnot(all.equal( B(a,b10), (bb <- beta(a, b10))), all.equal(lB(a,b10), (lb <- lbeta(a, b10))), all.equal(lb, log(bb)), all.equal( B(a,c10), (bb <- beta(a, c10))), all.equal(lB(a,c10), (lb <- lbeta(a, c10))), all.equal(lb, log(bb)), TRUE) } ## However, the speedup is *not* much (50%) when applied to vectors: stopifnot(validObject(xx <- outer(b10, runif(20))), dim(xx) == c(length(b10), 20), validObject(vx <- as(xx, "mpfr")), class(vx) == "mpfr", is.null(dim(vx))) C1 <- replicate(10, system.time(bb <<- beta(vx, vx+2))) C2 <- replicate(10, system.time(b2 <<- B(vx, vx+2))) summary(1000*C1[1,]) ## 80.3 {cmath-5, 2009} summary(1000*C2[1,]) ## 125.1 { " } stopifnot(all.equal(bb, b2)) ## and for a single number, the speedup is a factor 3: x1 <- vx[1]; x2 <- x1+2 system.time(for(i in 1:100) bb <- beta(x1, x2))# .27 system.time(for(i in 1:100) b2 <- B(x1, x2))# .83 ## a+b is integer <= 0, but a and b are not integer: a <- b <- .5 + -10:10 ab <- data.matrix(expand.grid(a=a, b=b, KEEP.OUT.ATTRS=FALSE)) ab <- mpfr(ab[rowSums(ab) <= 0, ], precBits = 128) stopifnot( beta(ab[,"a"], ab[,"b"]) == 0, lbeta(ab[,"a"], ab[,"b"]) == -Inf) ## was NaN in Rmpfr <= 0.5-2 stopifnot(all.equal(6 * beta(mpfr(1:3,99), -3.), c(-2,1,-2), tol=1e-20)) ## add more checks, notably for b (> 0) above and below the "large_b" in ## ../src/utils.c : bb <- beta(mpfr(1:23, 128), -23) stopifnot(all.equal(bb, Bi1(1:23, -23), tol=1e-7)) # Bi1() does not get high prec for small b ## can be written via rationals: N / D : bn <- c(330, -360, 468, -728, 1365, -3120, 8840, -31824, 151164, -1007760, 10581480, -232792560) bn <- c(rev(bn[-1]), bn) bd <- 24* as.bigz(2 * 3 * 5 * 7 * 11) * 13 * 17 * 19 * 23 stopifnot(all.equal(bb, as(bn/bd,"mpfr"), tol=0)) stopifnot(all.equal(6 * beta(mpfr(1:3, 99), -3.), c(-2,1,-2), tol=1e-20), all.equal( lbeta(mpfr(1:3, 128), -3.), log(mpfr(c( 2,1, 2), 128) / 6), tol=1e-20)) ## add more checks, notably for b (> 0) above and below the "large_b" in ## ../src/utils.c : bb <- beta(mpfr(1:23, 128), -23) stopifnot(all.equal(bb, Bi1(1:23, -23), tol=1e-7)) # Bi1() does not get high prec for small b ## can be written via rationals: N / D : bn <- c(330, -360, 468, -728, 1365, -3120, 8840, -31824, 151164, -1007760, 10581480, -232792560) bn <- c(rev(bn[-1]), bn) bd <- 24* as.bigz(2 * 3 * 5 * 7 * 11) * 13 * 17 * 19 * 23 stopifnot(all.equal(bb, as(bn/bd,"mpfr"), tol=0)) ## 2) add check for 'b' > maximal unsigned int {so C code uses different branch} two <- mpfr(2, 128) for(b in list(mpfr(9, 128), mpfr(5, 128)^10, two^25, two^26, two^100)) { a <- -(b+ (1:7)) stopifnot(a+b == -(1:7), # just ensuring that there was no cancellation is.finite( B <- beta(a,b)), ## was NaN .. is.finite(lB <- lbeta(a,b)), ## ditto all.equal(log(abs(B)), lB), TRUE) } ee <- c(10:145, 5*(30:59), 10*(30:39), 25*(16:30)) b <- mpfr(2, precBits = 10 + max(ee))^ee # enough precision {now "automatic"} stopifnot((b+4)-b == 4, # <==> enough precision above b == (b. <- as(as(b,"bigz"),"mpfr"))) (pp <- getPrec(b.))# shows why b. is not *identical* to b. system.time(Bb <- beta(-b-4, b))# 0.334 sec if(dev.interactive()) plot(ee, asNumeric(log(Bb)), type="o",col=2) lb <- asNumeric(log(Bb)) ## using coef(lm(lb ~ ee)) stopifnot(all.equal(lb, 3.175933 -3.46571851*ee, tol = 1e-5))# 4.254666 e-6 bb <- beta( 1:4, mpfr(2,99)) stopifnot(identical(bb, beta(mpfr(2,99), 1:4)), all.equal((2*bb)*cumsum(1:4), rep(1, 4), tol=1e-20), getPrec(bb) == 128) ##-- The d*() density functions from ../R/special-fun.R | ../man/distr-etc.Rd --- if(do.pdf) { dev.off(); pdf("special-fun-density.pdf") } dx <- 1400+ 0:10 mx <- mpfr(dx, 120) nx <- sort(c(c(-32:32)/2, 50*(-8:8))) xL <- 2^(989+(0:139)/4) # "close" to double.xmax dnbD <- dnbinom(xL, prob=1-1/4096, size=1e307, log=TRUE)# R's own iF <- -(130:140) # index of finite dnbD[] dnbx8 <- dnbinom(xL, prob=1-mpfr(2, 2^ 8)^-12, size=1e307, log=TRUE) dnbx10 <- dnbinom(xL, prob=1-mpfr(2, 2^10)^-12, size=1e307, log=TRUE) dnbx13 <- dnbinom(xL, prob=1-mpfr(2, 2^13)^-12, size=1e307, log=TRUE) stopifnot(exprs = { all.equal(dpois(dx, 1000), dpois(mx, 1000), tol = 3e-13) # 64b Lnx: 7.369e-14 all.equal(dbinom(0:16, 16, pr = 4 / 5), dbinom(0:16, 16, pr = 4/mpfr(5, 128)) -> db, tol = 5e-15)# 64b Lnx: 4.3e-16 all.equal(dnorm( -3:3, m=10, s=1/4), dnorm(mpfr(-3:3, 128), m=10, s=1/4), tol = 1e-15) # 64b Lnx: 6.45e-17 all.equal(dnorm(nx), dnorm(mpfr(nx, 99)), tol = 1e-15) all.equal(dnorm( nx, m = 4, s = 1/4), dnorm(mpfr(nx, 99), m = 4, s = 1/4), tol = 1e-15) all.equal(dnorm( nx, m = -10, s = 1/4, log=TRUE), dnorm(mpfr(nx, 99), m = -10, s = 1/4, log=TRUE), tol = 1e-15) ## t-distrib. : all.equal(dt(nx, df=3), dt(mpfr(nx, 99), df=3), tol = 1e-15) all.equal(dt( nx, df = 0.75), dt(mpfr(nx, 99), df = 0.75), tol = 1e-15) all.equal(dt( nx, df = 2.5, log=TRUE), dt(mpfr(nx, 99), df = 2.5, log=TRUE), tol = 1e-15) ## negative binomial dnbinom(): all.equal(dnbx13, dnbx10, tol = 2^-999) # see 2^-1007, but not 2^-1008 all.equal(dnbx13, dnbx8, tol = 2^-238) # see 2^-239, but not 2^-240 all.equal(dnbx10[iF], dnbD[iF], tol = 6e-16) # R's *is* accurate here (seen 2.9e-16) }) ## plot dt() "error" of R's implementation nx <- seq(-100, 100, by=1/8) dtd <- dt( nx, df= .75) dtM <- dt(mpfr(nx, 256), df= .75) if(doExtras) withAutoprint({ system.time( dtMx <- dt(mpfr(nx, 2048), df= .75) ) # 2.5 sec stopifnot(all.equal(dtMx, dtM, tol = 2^-254)) # almost all of dtM's 256 bits are correct }) relE <- asNumeric(dtd/dtM - 1) plot(relE ~ nx, type="l", col=2); mtextVersion() plot(abs(relE) ~ nx, type="l", col=2, log="y", ylim=c(5e-17, 1.5e-15)) ## ============== even smaller 'df' such that lgamma1p(df) is better than lgamma(1+df) ==== require(sfsmisc)# -> eaxis(); relErrV() u <- sort(outer(10^-(20:1), c(1,2,5))) # *not* "exact" on purpose ## .. unfinished .. exploring *when* dt() would suffer from inaccurate stirlerr() -- would it? nu <- 2^-(70:1) dt10 <- dt( 10, df=nu) dt10M <- dt(mpfr(10, 1024), df=nu) re10 <- asNumeric(relErrV(dt10M, dt10)) plot(re10 ~ nu, type="l", lwd=2, log="x", main = quote(rel.Err( dt(10, df==nu) )), xaxt="n"); eaxis(1, nintLog=20) mtextVersion() abline(h = (-1:1)*2^-53, lty=4, col=adjustcolor("blue", 1/2)) plot(abs(re10) ~ nu, type="l", lwd=2, log="xy", xlab = quote(df == nu), ylab = quote(abs(relE)), main = quote(abs(rel.Err( dt(10, df==nu) ))), xaxt="n", yaxt="n") eaxis(1, nintLog=20); eaxis(2); drawEps.h() x0 <- c(0, 10^(-5:10)) # only >= 0 should be sufficient; x0 <- c(-rev(x0),0,x0) stopifnot(!is.unsorted(nu), # just for plotting .. !is.unsorted(x0)) xnu <- expand.grid(x=x0, df=nu) dt2 <- with(xnu, dt( x, df=df)) dtM2 <- with(xnu, dt(mpfr(x, 512), df=df)) str(relE2 <- `attributes<-`(asNumeric(relErrV(dtM2, dt2)), attr(xnu, "out.attrs"))) ## consistency check that with() etc was fine: stopifnot(identical(re10, unname(relE2[which(x0 == 10), ]))) filled.contour(x=log10(1e-7+x0), y=log10(nu), z = relE2) filled.contour(x=log10(1e-7+x0), y=log10(nu), z = abs(relE2)) ## around nu = 10^-16 is the most critical place (pch <- c(1L:9L, 0L, letters, LETTERS)[1:ncol(relE2)]) matplot(x0+1e-7, relE2, type="b", log="x", main="rel.err{ dt(x, df=df) }") legend("topright", legend = paste0("df=",formatC(nu,wid=3)), ncol=7, bty="n", lwd=1, pch=pch, col=1:6, lty=1:5, cex = 0.8) abline(h = c(-4:4)*2^-53, lty=3, col="gray") matplot(nu, t(relE2), type="b", log="x", main="rel.err{ dt(x, df=df) }") legend("topright", legend = paste0("x=",formatC(x0,wid=3)), ncol=7, bty="n", lwd=1, pch=pch, col=1:6, lty=1:5, cex = 0.8) abline(h = c(-4:4)*2^-53, lty=3, col="gray") matplot(nu, pmax(abs(t(relE2)), 1e-19), type="b", log="xy", axes=FALSE, ylab = quote(abs("rel Err")), ylim = c(7e-17, max(abs(relE2))), main="|rel.err{ dt(x, df=df)}|") eaxis(1, nintLog=22) ; eaxis(2, line=-1/2); drawEps.h() legend("topright", legend = paste0("x=",formatC(x0,wid=3)), ncol=7, bty="n", lwd=1, pch=pch, col=1:6, lty=1:5, cex = 0.8) 1 ## dnbinom() -- has mode as expected, but with huge size, the scales are "off reality" .. ### ..... TODO ! ### dgamma(): ---------------------------------------------------- if(do.pdf) { dev.off(); pdf("special-fun-dgamma.pdf") } xe <- c(-2e5, -1e5, -2e4, -1e4, -2000, -1000, -500, -200, -100, -50, -20, -10) (xe <- c(xe, -8:8, -rev(xe))) two <- mpfr(2, 64) ## For centering at E[.], will use xP(x, shp) : xP <- function(x, d) x - d*(x > d) aEQformat <- function(xy, ...) format(xy, digits = 7, ...) allEQ_0 <- function (target, current, ...) all.equal(target, current, tolerance = 0, formatFUN = aEQformat, ...) stopIfNot <- if("allow.logical0" %in% names(formals(stopifnot))) { # experimental (MM only) stopifnot } else function(exprs, allow.logical0) stopifnot(exprs=exprs) for(shp in c(2^c(-20, -3, -1:1, 4, 10, 50))) { cat("shape = 2^", log2(shp), ":\n-------------\n") d.dg <- dgamma(xP(2 ^ xe, shp), shape=shp) m.dg <- dgamma(xP(two^xe, shp), shape=shp) m.ldg <- dgamma(xP(two^xe, shp), shape=shp, log=TRUE) stopIfNot(exprs = { !is.unsorted(xe) is.finite(m.dg) m.dg >= 0 shp > 1 || all(diff(m.dg) <= 0) shp > 100|| all((m.dg > 0) >= (d.dg > 0)) any(fin.d <- is.finite(d.dg)) m.dg[!fin.d] > 1e300 { cat("all.EQ(, ):", allEQ_0(m.dg[fin.d], d.dg[fin.d]), "\n") shp > 100 || all.equal(m.dg[fin.d], d.dg[fin.d], tol = 1e-13) # 2.063241e-14 } ## compare with log scale : if(any(pos.d <- m.dg > 0)) { cat("all.EQ(log(d), d*(log)):", allEQ_0 (log(m.dg[pos.d]), m.ldg[pos.d]),"\n") all.equal(log(m.dg[pos.d]), m.ldg[pos.d], tol = 1e-14) } }, allow.logical0 = TRUE) } cat('Time elapsed: ', proc.time(),'\n') # "stats" if(!interactive()) warnings() Rmpfr/tests/arith-ex.R0000644000176200001440000002324414533333542014360 0ustar liggesusersrequire("Rmpfr") ## includes ("gmp")# want to check "mixed arithmetic" too __ TODO __ `%=N=%` <- function(x,y) (x == y) | (is.na(x) & is.na(y)) all.EQ <- function(x,y, tolerance = 2^-98, ...) # very small tol. for MPFR all.equal(x, y, tolerance=tolerance, ...) warningI <- function(...) warning(..., immediate. = TRUE) unlist(.Platform) ## Check that we got the "which.*" methods also from "bigq": bcl <- c("ANY", "bigq", "bigz", "mpfr") ##if(packageVersion("gmp") >= "0.5-8") { stopifnot(identical(bcl, sort(unlist(findMethods("which.max")@signatures))), identical(bcl, sort(unlist(findMethods("which.min")@signatures)))) ##} options(warn = 1)# warnings *immediately* (doExtras <- Rmpfr:::doExtras()) eps2 <- 2 * .Machine$double.eps eps8 <- 8 * .Machine$double.eps eps32 <- 32 * .Machine$double.eps ## must take the *larger* of the two precisions: stopifnot(substr(format(mpfr(1, 60)/mpfr(7, 160)), 1,51) == # format() may show more digits "0.1428571428571428571428571428571428571428571428571")# again has extra "2" at end (x <- mpfr(0:7, 100) / 7) ix <- x^-1000 iX <- asNumeric(ix) stopifnot( mpfrIs0(x - x), # badly failed on 64-bit identical(-x, 0-x),# testing "- x" all.equal(ix, (1/x)^1000, tol= 1e-25), is.numeric(iX), iX[1:4] == Inf, # failed previously as we used RNDD (downward rounding) all.equal(log(iX[5:8]), c(559.6157879, 336.4722366, 154.1506798, 0), tol = 1e-9)) ## checking hexadecimal input : stopifnot(mpfr("0xFFFFFFFFFFFFFFFFFFFF", base=16) + 1 == 2^80, ## sign(0) == 0: identical(sign(as(-1:1, "mpfr")), -1:1 + 0)) stopifnot(all.equal(as.numeric(x+ 1L), as.numeric(x)+1L, tol = eps2), as.integer( x [x < 1]) == 0,# was *wrong* {we round()ed; previously "down"!} as.integer((-x)[x < 1]) == 0,# (ditto) (3 * x)/3 <= x, all.equal(as.numeric(x * 2L), as.numeric(x + x), tol = 0)) u <- mpfr(0:17, 128)/17 two <- mpfr(2,100) stopifnot(all.EQ(u ^ two, u ^ 2), identical(u ^ 2, u ^ 2L), all.EQ(two ^ u, 2 ^ u), identical(2 ^ u, 2L ^ u), floor (3*u) == floor (3/17*(0:17)), ceiling(u*5) == ceiling(5/17*(0:17)) ) i7 <- mpfr(0:7, 200)/ 7 i17 <- mpfr(0:17, 300)/17 stopifnot(all.equal(as.numeric(x+1), as.numeric(x)+1), all.equal(round(x,2), round(asNumeric(x), 2), tol=1e-15), all.equal(round(mpfr(1.152, 80), 2), 1.15), # was wrong {as.integer() bug} all.equal(0:7, 7 * round ( i7, 25), tol = 2e-25), all.equal(0:7, 7 * round ( i7, 50), tol = 2e-50), all.equal(0:17, 17 * signif(i17,100), tol = 2e-100), all.equal(0:17, 17 * signif(i17, 20), tol = 2e-20) ) ## When we compute with 100 bits, ## we should compare relative errors with 2^-100 : del <- abs((x+pi)-pi - x) / 2^-100 stopifnot(del <= 4) ## <= 2 already (fd <- format(del, drop0 = TRUE)) stopifnot(all.equal(as.numeric(del), as.numeric(fd), tol = 1e-15)) if(print(Sys.info()[["machine"]]) == "x86_64") stopifnot(fd %in% as.character(c(0:2, c(2,7)/4))) checkPmin <- function(x, nx = as(x, "numeric")) { rx <- if(is(x,"mpfr")) round(x, 25) else x isZ <- is(x, "bigz") || is(nx, "bigz") M.X <- max(x, na.rm=TRUE) m.x <- min(x, na.rm=TRUE) stopifnot(all.equal(x, nx), pmin(x, x, M.X) %=N=% x, x %=N=% pmax(x, m.x, x), all.equal(x, pmin(x, nx, x, M.X)), all.equal(x, pmax(m.x, nx, x, rx, m.x)), if(isZ)TRUE else all.equal(pmin(x, 0.75), pmin(nx, 0.75)), if(isZ)TRUE else all.equal(pmax(x, 0.25), pmax(nx, 0.25))) } x <- mpfr(0:7, 100) / 7 checkPmin(x) nx <- (0:7)/7 (qx <- as.bigq(0:7, 7)) x[c(2,5)] <- NA nx[c(2,5)] <- NA qx[c(2,5)] <- NA Z <- as.bigz(1:7) mZ <- mpfr(Z, 64) stopifnot(Z == mZ, mZ == Z) checkPmin(x, nx) cat("checking pmin(. bigq ): ") ## FIXME checkPmin(x, qx); cat("[Ok]\n") ## print( base::pmin(Z, Z, max(Z)) )# via gmp:: rep.bigz(x, length.out = *) cat("checking pmin(. bigz ) [currently with lots of pmin() and pmax(...) warnings 'incompatible methods]:\n ") checkPmin(Z); cat("[Ok]\n") # via gmp:: all.equal.bigz() stopifnot(all.equal( round(x, 10), round(nx, 10)), all.equal(signif(x, 10), signif(nx, 10))) ## L & x , x & L failed in Rmpfr 0.2* and 0.4-2 stopifnot(identical(L <- x > 0.5, L & x), identical(L, x & L), identical(x > 0, x | L)) ## Summary() methods {including NA stopifnot(exprs = { is.na(min(x)) is.na(max(x)) is.na(range(x)) is.na(sum(x)) is.na(prod(x)) min(x, na.rm=TRUE) == 0 max(x, na.rm=TRUE) == 1 range(x, na.rm=TRUE) == 0:1 all.equal(sum (x, na.rm=TRUE)*7, 2+3+5+6+7, tolerance = 1e-28) # 1.0975e-30 prod(x, na.rm=TRUE) == 0 all.equal(180, prod(x[-1], na.rm=TRUE)*7^4, tol = 1e-15) # 1.579e-16 ## ## all(), any() had memory bug [PROTECT missing, but more, somehow] !all(x) is.na( all(x[-1]) ) any(x) is.na(any(x[c(2,5)])) ## do these *twice* {that triggered R-forge bug #6764 } ! all(x, na.rm=TRUE) any(x, na.rm=TRUE) ## ! all(x, na.rm=TRUE) any(x, na.rm=TRUE) }) ##-------------- Modulo and "integer division" ------------- ## R's ?Arithmetic : ## ## ‘%%’ indicates ‘x mod y’ and ‘%/%’ indicates integer division. It ## is guaranteed that ‘x == (x %% y) + y * ( x %/% y )’ (up to ## rounding error) unless ‘y == 0’ where the result of ‘%%’ is ## ‘NA_integer_’ or ‘NaN’ (depending on the ‘typeof’ of the ## arguments). ## ## and has 'details' about how non-integer 'y' works ## (N <- if(doExtras) 1000 else 200) (todays.seed <- eval(parse(text=Sys.Date())))# so this is reproducible # (and constant within one day) set.seed(todays.seed) mm <- c(-4:4, sample(50, N-9, replace=TRUE)) for(n in seq_len(N)) { cat("."); if(n %% 50 == 0) cat(n,"\n") m <- mm[n] prec <- sample(52:200, 1)# "high precision" ==> can use small tol x <- sample(100, 50) - 20 for(kind in c('int','real')) { if(kind == "real") { m <- jitter(m) x <- jitter(x) tol.1 <- eps32 * pmax(1, 1/abs(m)) EQ <- function(x,y, tol = tol.1) isTRUE(all.equal(x, as.numeric(y), tol=tol)) EQ2 <- function(x,y, tol = tol.1) { ## for the DIV - MOD identity, a small x leads to cancellation all((x %=N=% y) | abs(x - y) < tol*pmax(abs(x), 1)) || isTRUE(all.equal(x, as.numeric(y), tol=tol)) } } else { ## "integer" EQ2 <- EQ <- function(x,y, tol) all(x %=N=% y) } i.m <- mpfr(x, prec) %% mpfr(m, prec) if(!EQ2(x %% m, i.m)) { cat("\n -- m = ",m," (prec = ",prec,")\n") rE <- range(rel.E <- as.numeric(1 - (x %% m)/i.m)) print(cbind(x, 'R.%%' = x %% m, rel.E)) MSG <- if(max(abs(rE)) < 1e-10) warningI else stop MSG(sprintf("not all equal: range(rel.Err.) = [%g, %g]", rE[1],rE[2])) } ## if(m != 0) { ##---Check the x == (x %% m) + m * ( x %/% m ) assertion ------ ## if(EQ2(x, (x %% m) + m*( x %/% m ), tol = 1e-12)) { ## ok for R ## --> also ok for mpfr ? iDm <- mpfr(x, prec) %/% mpfr(m, prec) rhs <- i.m + m*iDm if(!EQ2(x, i.m + m*iDm)) { cat("\n -- m = ",m," (prec = ",prec,")\n") print(cbind(x,' MPFR[ x%%m + m(x %/% m) ]' = as.numeric(rhs), rel.E)) MSG <- if(max(abs(rE)) < 1e-10) warningI else stop MSG(sprintf("Identity(MOD - DIV) not all eq.: range(rel.Err.) = [%g, %g]", rE[1],rE[2])) } } else { cat("\n hmm.. the basic %% <-> %/% assertion 'fails' in *R* :\n") rhs <- (x %% m) + m * ( x %/% m ) rel.E <- (1 - rhs/x) print(cbind(x, 'x%%m + m(x %/% m)' = rhs, rel.E)) } } } } ## mpfr o now implemented, for '%%', too : r <- as.double(i <- -10:20) stopifnot( ## %% ------------------------------------- mpfr(i, prec=99) %% 7 == i %% 7 , ## mpfr(i, prec=99) %% 7 == mpfr(i, prec=99) %% 7L , ## i %% mpfr(27, prec=99) == i %% 27 , ## r %% mpfr(27, prec=99) == r %% 27 , ## %/% ------------------------------------- mpfr(i, prec=99) %/% 7 == i %/% 7 , ## mpfr(i, prec=99) %/% 7 == mpfr(i, prec=99) %/% 7L , ## mpfr(i, prec=99) %/% mpfr(27, prec=99) == i %/% 27 , ## i %/% mpfr(27, prec=99) == i %/% 27 , ## i %/% mpfr(27, prec=99) == r %/% mpfr(27, prec=99) , TRUE ## ) cat('Time elapsed: ', proc.time(),'\n') # "stats" ## Was reproducible BUG in Rmpfr-addition (on Linux, MPFR 4.x.y) -- ## but the bug was Rmpfr, ## in ../src/Ops.c, detecting if *integer*, i.e., long can be used dn <- 1e20 dOO <- 9223372036854775808; formatC(dOO) # "9.2...e18" (r <- dn / (dn + dOO)) # 0.915555 (double prec arithmetic) ## but *so* strange when switching to Rmpfr : addition accidentally *subtract*!! n <- mpfr(dn, precBits = 99) (rM <- n / (n + dOO)) # wrongly gave " 1 'mpfr' .... 99 bits; 1.101605140483951..... stopifnot(exprs = { all.equal(n + dOO, dn + dOO) all.equal(n / (n + dOO), r) }) ## log(., base) : (ten40 <- as.bigz(10)^40) ten40m <- mpfr(ten40) (lt40 <- log(ten40m, 10)) # gave Error in ... : base != exp(1) is not yet implemented ## 'mpfr' .. 133 bits \\ [1] 40 stopifnot(exprs = { grepl("^40[.]000+$", print(format(lt40, digits = 60))) identical(lt40, log10(ten40m)) identical(log(ten40m, 2), log2(ten40m)) inherits(Pi <- Const("pi", 140), "mpfr") all.equal(show(log(ten40m, Pi)), log(ten40m)/log(Pi), tol = 1e-40) }) ###------Standard Statistics Functions -------------------------------------------------------- x <- c(del, 1000) stopifnot(identical(mean(x), mean(x, trim=0))) for(tr in (0:8)/16) stopifnot(all.equal(mean( x, trim = tr), mean(asNumeric(x), trim = tr), tol=1e-15)) cat('Time elapsed: ', proc.time(),'\n') # "stats" Rmpfr/configure.ac0000644000176200001440000000430214127016751013631 0ustar liggesusers# autoconf this file --> configure AC_INIT AC_CONFIG_SRCDIR([Rmpfr]) AC_CONFIG_SRCDIR([DESCRIPTION]) dnl Select an optional include path, from a configure option dnl or from an environment variable >> mpfr_INCLUDE << AC_ARG_WITH([mpfr-include], AS_HELP_STRING([--with-mpfr-include=INCLUDE_PATH],[the location of MPFR header files]), [mpfr_include_path=$withval]) if test -n "$mpfr_include_path" ; then MPFR_CPPFLAGS="-I${mpfr_include_path}" elif test -n "${mpfr_INCLUDE}" ; then MPFR_CPPFLAGS="-I${mpfr_INCLUDE}" fi dnl Ditto for a library path environment variable >> mpfr_LDFLAGS << AC_ARG_WITH([mpfr-lib], AS_HELP_STRING([--with-mpfr-lib=LIB_PATH],[the location of MPFR libraries]), [mpfr_lib_path=$withval]) if test -n "$mpfr_lib_path" ; then MPFR_LDFLAGS="-L$mpfr_lib_path ${LDFLAGS}" elif test -n "${mpfr_LDFLAGS}" ; then MPFR_LDFLAGS="-L${mpfr_LDFLAGS} ${LDFLAGS}" fi dnl Now find the compiler and compiler flags to use : ${R_HOME=`R RHOME`} if test -z "${R_HOME}"; then echo "could not determine R_HOME" exit 1 fi CC=`"${R_HOME}/bin/R" CMD config CC` CFLAGS=`"${R_HOME}/bin/R" CMD config CFLAGS` CPPFLAGS=`"${R_HOME}/bin/R" CMD config CPPFLAGS` LDFLAGS=`"${R_HOME}/bin/R" CMD config LDFLAGS` dnl Setup the compilers AC_PROG_CC AC_PROG_CPP dnl use the include and lib CPPFLAGS="${CPPFLAGS} ${MPFR_CPPFLAGS}" LDFLAGS="${LDFLAGS} ${MPFR_LDFLAGS}" PKG_CPPFLAGS=$CPPFLAGS PKG_CFLAGS=$CFLAGS PKG_LDFLAGS=$LDFLAGS AC_CHECK_HEADER([mpfr.h], , [AC_MSG_ERROR([Header file mpfr.h not found; maybe use --with-mpfr-include=INCLUDE_PATH])]) AC_CHECK_HEADER([gmp.h], , [AC_MSG_ERROR([Header file gmp.h not found; maybe use --with-mpfr-include=INCLUDE_PATH])]) AC_CHECK_LIB(gmp, __gmpz_init, , [AC_MSG_ERROR([GNU MP not found, see README])]) AC_CHECK_LIB(mpfr, mpfr_init, , [AC_MSG_ERROR([MPFR Library not found, see README])]) dnl Our Version check <= 3 -- etc seems to fail nowadays dnl src/Rmpfr_utils.h dnl ~~~~~~~~~~~~~~~~~ AC_CHECK_LIB(mpfr, mpfr_digamma, , [AC_MSG_ERROR([MPFR Library must be at least version 3.0.0, see README])]) AC_SUBST(PKG_CPPFLAGS) AC_SUBST(PKG_CFLAGS) AC_SUBST(PKG_LDFLAGS) AC_CONFIG_FILES(src/Makevars) AC_OUTPUT Rmpfr/src/0000755000176200001440000000000014552770167012145 5ustar liggesusersRmpfr/src/Rmpfr_utils.h0000644000176200001440000001420614371453423014617 0ustar liggesusers#ifndef R_MPFR_MUTILS_H #define R_MPFR_MUTILS_H /* #ifdef __cplusplus */ /* extern "C" { */ /* #endif */ #include #include /* for va_list ..*/ #include /* includes Rconfig.h */ #include #include // previously from : #ifndef GET_SLOT # define GET_SLOT(x, what) R_do_slot(x, what) # define SET_SLOT(x, what, value) R_do_slot_assign(x, what, value) # define MAKE_CLASS(what) R_do_MAKE_CLASS(what) # define NEW_OBJECT(class_def) R_do_new_object(class_def) #endif #include /* must come *after* the above, e.g., for mpfr_out_str() (which needs stdio): */ #include #include #ifdef ENABLE_NLS #include #define _(String) dgettext ("Rmpfr", String) #else #define _(String) (String) #endif #if (MPFR_VERSION < MPFR_VERSION_NUM(3,0,0)) /* define back-compatibility types:*/ # define MPFR_RNDD GMP_RNDD # define MPFR_RNDN GMP_RNDN # define MPFR_RNDU GMP_RNDU # define MPFR_RNDZ GMP_RNDZ // # define MPFR_RNDA GMP_RNDA # define mpfr_exp_t mp_exp_t #endif static R_INLINE mpfr_prec_t max2_prec(mpfr_prec_t x, mpfr_prec_t y) { return (mpfr_prec_t) (x >= y) ? x : y; } /*----------------------------------------*/ #ifdef _in_Rmpfr_init_ /* global */ int R_mpfr_debug_ = 0; #else extern int R_mpfr_debug_; #endif /* A version of Rprintf() .. but only printing when R_mpfr_debug_ is large enough :*/ static R_INLINE void R_mpfr_dbg_printf(int dbg_level, const char *format, ...) { if(R_mpfr_debug_ && R_mpfr_debug_ >= dbg_level) { va_list(ap); Rprintf(".mpfr_debug[%d]: ", R_mpfr_debug_); va_start(ap, format); REvprintf(format, ap); va_end(ap); } } static R_INLINE void R_mpfr_dbg_printf_0(int dbg_level, const char *format, ...) { if(R_mpfr_debug_ && R_mpfr_debug_ >= dbg_level) { va_list(ap); va_start(ap, format); REvprintf(format, ap); va_end(ap); } } /* This is from Matrix/src/Mutils.h : */ static R_INLINE SEXP ALLOC_SLOT(SEXP obj, SEXP nm, SEXPTYPE type, int length) { SEXP val = allocVector(type, length); SET_SLOT(obj, nm, val); return val; } #define N_LIMBS(_PREC_) (int)ceil(((double)_PREC_)/mp_bits_per_limb) static R_INLINE int R_mpfr_nr_limbs(mpfr_t r) { return N_LIMBS(mpfr_get_prec(r)); } // Note: "in theory" we could set precBits > INT_MAX, but currently not in Rmpfr: static R_INLINE void R_mpfr_check_prec(int prec) { if(prec == NA_INTEGER) error("Precision(bit) is NA (probably from coercion)"); if(prec < MPFR_PREC_MIN) error("Precision(bit) = %d < %ld (= MPFR_PREC_MIN)", prec, (long)MPFR_PREC_MIN); /* 2018-01-01 gives a WARNING with clang: Found the following significant warnings: ./Rmpfr_utils.h:89:13: warning: comparison of constant 9223372036854775807 with expression of type 'int' is always false [-Wtautological-constant-out-of-range-compare] ... of course, I don't want a WARN in the CRAN checks, hence disable (for now): if(prec > MPFR_PREC_MAX) error("Precision(bit) = %d > %ld (= MPFR_PREC_MAX)", prec, (long)MPFR_PREC_MAX); */ return; } #define R_mpfr_prec(x) INTEGER(GET_SLOT(x, Rmpfr_precSym))[0] #define MISMATCH_WARN \ if (mismatch) \ warning(_("longer object length is not a multiple of shorter object length")) #define SET_MISMATCH \ if (nx == ny || nx == 1 || ny == 1) mismatch = 0; \ else if (nx > 0 && ny > 0) { \ if (nx > ny) mismatch = nx % ny; \ else mismatch = ny % nx; \ } /* ./convert.c : */ mpfr_rnd_t R_rnd2MP(SEXP rnd_mode); SEXP d2mpfr1 (SEXP x, SEXP prec, SEXP rnd_mode); SEXP d2mpfr1_(double x, int i_prec, mpfr_rnd_t rnd); SEXP d2mpfr1_list(SEXP x, SEXP prec, SEXP rnd_mode); SEXP mpfr2d(SEXP x, SEXP rnd_mode); SEXP mpfr2i(SEXP x, SEXP rnd_mode); SEXP mpfr2str(SEXP x, SEXP digits, SEXP maybe_full, SEXP base); SEXP str2mpfr1_list(SEXP x, SEXP prec, SEXP base, SEXP rnd_mode); SEXP R_mpfr_formatinfo(SEXP x); #ifdef R_had_R_Outputfile_in_API # ifndef WIN32 SEXP print_mpfr (SEXP x, SEXP digits); SEXP print_mpfr1(SEXP x, SEXP digits); # endif #endif SEXP Rmpfr_minus(SEXP x); SEXP Rmpfr_abs(SEXP x); SEXP Math_mpfr(SEXP x, SEXP op); SEXP Arith_mpfr(SEXP x, SEXP y, SEXP op); SEXP Arith_mpfr_i(SEXP x, SEXP y, SEXP op); SEXP Arith_i_mpfr(SEXP x, SEXP y, SEXP op); SEXP Arith_mpfr_d(SEXP x, SEXP y, SEXP op); SEXP Arith_d_mpfr(SEXP x, SEXP y, SEXP op); SEXP Compare_mpfr(SEXP x, SEXP y, SEXP op); SEXP Compare_mpfr_i(SEXP x, SEXP y, SEXP op); SEXP Compare_mpfr_d(SEXP x, SEXP y, SEXP op); SEXP Summary_mpfr(SEXP x, SEXP na_rm, SEXP op); SEXP R_mpfr_sumprod(SEXP x, SEXP y, SEXP minPrec, SEXP alternating); #ifdef __NOT_ANY_MORE__ /* deprecated: */ SEXP exp_mpfr1(SEXP x); SEXP log_mpfr1(SEXP x); #endif void R_asMPFR(SEXP x, mpfr_ptr r); SEXP MPFR_as_R(mpfr_t r); /* ./utils.c */ SEXP R_mpfr_set_debug(SEXP I); SEXP R_mpfr_set_default_prec(SEXP prec); SEXP R_mpfr_get_default_prec(void); int mpfr_erange_int_p(void); SEXP R_mpfr_erange_int_p(void); SEXP R_mpfr_get_erange(SEXP kind); SEXP R_mpfr_set_erange(SEXP kind, SEXP val); SEXP R_mpfr_prec_range(SEXP ind); SEXP R_mpfr_get_version(void); SEXP R_mpfr_get_GMP_numb_bits(void); SEXP R_mpfr_2exp(SEXP x); SEXP R_mpfr_ldexp(SEXP f, SEXP E, SEXP rnd_mode); SEXP R_mpfr_frexp(SEXP x, SEXP rnd_mode); SEXP const_asMpfr(SEXP I, SEXP prec, SEXP rnd_mode); SEXP R_mpfr_is_finite(SEXP x); SEXP R_mpfr_is_finite_A(SEXP x); SEXP R_mpfr_is_infinite(SEXP x);SEXP R_mpfr_is_infinite_A(SEXP x); SEXP R_mpfr_is_integer(SEXP x); SEXP R_mpfr_is_integer_A(SEXP x); SEXP R_mpfr_is_na(SEXP x); SEXP R_mpfr_is_na_A(SEXP x); SEXP R_mpfr_is_zero(SEXP x); SEXP R_mpfr_is_zero_A(SEXP x); SEXP R_mpfr_atan2(SEXP x, SEXP y, SEXP rnd_mode); SEXP R_mpfr_hypot(SEXP x, SEXP y, SEXP rnd_mode); SEXP R_mpfr_beta (SEXP x, SEXP y, SEXP rnd_mode); SEXP R_mpfr_lbeta(SEXP x, SEXP y, SEXP rnd_mode); SEXP R_mpfr_igamma(SEXP a, SEXP x, SEXP rnd_mode); SEXP R_mpfr_jn(SEXP x, SEXP n, SEXP rnd_mode); SEXP R_mpfr_yn(SEXP x, SEXP n, SEXP rnd_mode); SEXP R_mpfr_fac (SEXP n, SEXP prec, SEXP rnd_mode); SEXP R_mpfr_choose(SEXP a, SEXP n, SEXP rnd_mode); SEXP R_mpfr_poch (SEXP a, SEXP n, SEXP rnd_mode); SEXP R_mpfr_round (SEXP x, SEXP prec, SEXP rnd_mode); /* #ifdef __cplusplus */ /* } */ /* #endif */ #endif /* R_MPFR_MUTILS_H_ */ Rmpfr/src/Syms.h0000644000176200001440000000026112443134043013230 0ustar liggesusersSEXP // keep in sync with ./init.c Rmpfr_precSym, Rmpfr_signSym, Rmpfr_expSym, Rmpfr_d_Sym, Rmpfr_Data_Sym, Rmpfr_Dim_Sym, Rmpfr_Dimnames_Sym ; Rmpfr/src/Ops.c0000644000176200001440000006633514533575120013056 0ustar liggesusers/* * MPFR - Multiple Precision Floating-Point Reliable Library * ---- - - - - * * Arithmetic, Math, etc */ #include #include /* imax2() */ #include "Rmpfr_utils.h" extern #include "Syms.h" SEXP Rmpfr_minus(SEXP x) { int n = length(x); SEXP val = PROTECT(duplicate(x)); for(int i=0; i < n; i++) { int sign = asInteger(GET_SLOT(VECTOR_ELT(x,i), Rmpfr_signSym)); SEXP r_i = VECTOR_ELT(val, i); SET_SLOT(r_i, Rmpfr_signSym, ScalarInteger(-sign)); SET_VECTOR_ELT(val, i, r_i); } UNPROTECT(1); return val; } /* Rmpfr_minus() */ SEXP Rmpfr_abs(SEXP x) { int n = length(x); SEXP val = PROTECT(duplicate(x)); for(int i=0; i < n; i++) { SEXP r_i = VECTOR_ELT(val, i); SET_SLOT(r_i, Rmpfr_signSym, ScalarInteger(1)); SET_VECTOR_ELT(val, i, r_i); } UNPROTECT(1); return val; } /* Rmpfr_abs() */ /*------------------------------------------------------------------------*/ SEXP Math_mpfr(SEXP x, SEXP op) { #ifdef using_Data_slot SEXP D = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)); #else # define D x #endif mpfr_prec_t current_prec = mpfr_get_default_prec(); int n = length(D), i_op = asInteger(op), i; SEXP val = PROTECT(allocVector(VECSXP, n)); mpfr_t R_i, cum; Rboolean is_cum = (71 <= i_op && i_op <= 74); mpfr_init(R_i); /* with default precision */ if(is_cum) { // cummax, cumsum, ... mpfr_init(cum); switch(i_op) { case 71: /* cummax */ mpfr_set_inf(cum, -1);/* := -Inf */; break; case 72: /* cummin */ mpfr_set_inf(cum, +1);/* := +Inf */; break; case 73: /* cumprod */ mpfr_set_d(cum, 1., MPFR_RNDZ);/* := 1 */; break; case 74: /* cumsum */ mpfr_set_d(cum, 0., MPFR_RNDZ);/* := 0 */; break; } } for(i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(D, i), R_i); if(is_cum) { /* hence using cum */ mpfr_prec_t i_prec = mpfr_get_prec(R_i); if(current_prec < i_prec) /* increase precision */ { current_prec = i_prec; mpfr_prec_round(cum, i_prec, MPFR_RNDN); } } #define NOT_YET error("Math op. %d not yet implemented", i_op) switch(i_op) { /* Note we assign use R_i as "input and output" ==> *same* precision, even though in some cases the result may need higher precision */ case 0: /* trunc */ mpfr_trunc(R_i, R_i); break; case 1: /* floor */ mpfr_floor(R_i, R_i); break; case 2: /* ceiling*/ mpfr_ceil(R_i, R_i); break; case 3: /* sqrt */ mpfr_sqrt(R_i, R_i, MPFR_RNDN); break; case 4: /* sign */ error("'sign' is dealt with in R. Should not happen, please report"); break; case 10: /* exp */ mpfr_exp(R_i, R_i, MPFR_RNDN); break; case 11: /* expm1 */ mpfr_expm1(R_i, R_i, MPFR_RNDN); break; case 12: /* log1p */ mpfr_log1p(R_i, R_i, MPFR_RNDN); break; case 13: /* log */ mpfr_log (R_i, R_i, MPFR_RNDN); break; case 14: /* log2 */ mpfr_log2 (R_i, R_i, MPFR_RNDN); break; case 15: /* log10 */ mpfr_log10(R_i, R_i, MPFR_RNDN); break; case 20: /* cos */ mpfr_cos (R_i, R_i, MPFR_RNDN); break; case 21: /* sin */ mpfr_sin (R_i, R_i, MPFR_RNDN); break; case 22: /* tan */ mpfr_tan (R_i, R_i, MPFR_RNDN); break; case 23: /* acos */ mpfr_acos (R_i, R_i, MPFR_RNDN); break; case 24: /* asin */ mpfr_asin (R_i, R_i, MPFR_RNDN); break; case 25: /* atan */ mpfr_atan (R_i, R_i, MPFR_RNDN); break; case 30: /* cosh */ mpfr_cosh (R_i, R_i, MPFR_RNDN); break; case 31: /* sinh */ mpfr_sinh (R_i, R_i, MPFR_RNDN); break; case 32: /* tanh */ mpfr_tanh (R_i, R_i, MPFR_RNDN); break; case 33: /* acosh */ mpfr_acosh(R_i, R_i, MPFR_RNDN); break; case 34: /* asinh */ mpfr_asinh(R_i, R_i, MPFR_RNDN); break; case 35: /* atanh */ mpfr_atanh(R_i, R_i, MPFR_RNDN); break; case 40: /* lgamma */ { int sgn[1]; mpfr_lgamma(R_i, sgn, R_i, MPFR_RNDN); break; } case 41: /* gamma */ mpfr_gamma(R_i, R_i, MPFR_RNDN); break; case 42: /* digamma */ #if (MPFR_VERSION < MPFR_VERSION_NUM(3,0,0)) error("digamma() not implemented in oldish MPFR library version '%s'", MPFR_VERSION_STRING); #else mpfr_digamma(R_i, R_i, MPFR_RNDN); break; #endif case 43: /* trigamma */ NOT_YET; break; case 47: /* cospi */ { mpfr_prec_t i_prec = mpfr_get_prec(R_i); mpfr_t tmp; mpfr_init2(tmp, i_prec); mpfr_abs(R_i, R_i, MPFR_RNDN); // R_i := | R_i | mpfr_set_si(tmp, (long) 2, MPFR_RNDN); // tmp := 2 // R_i := R_i mod 2 : mpfr_fmod(R_i, R_i, tmp, MPFR_RNDN); if(mpfr_cmp_d(R_i, 0.5) == 0 || mpfr_cmp_d(R_i, 1.5) == 0) mpfr_set_zero(R_i, +1); else if(mpfr_cmp_si(R_i, (long) 1) == 0) mpfr_set_si(R_i, (long) -1, MPFR_RNDN); else if(mpfr_cmp_si(R_i, (long) 0) == 0) mpfr_set_si(R_i, (long) 1, MPFR_RNDN); else { // otherwise return cos(pi * x): mpfr_const_pi (tmp, MPFR_RNDN); mpfr_mul(R_i, R_i, tmp, MPFR_RNDN); mpfr_cos(R_i, R_i, MPFR_RNDN); } break; } case 48: /* sinpi */ { mpfr_prec_t i_prec = mpfr_get_prec(R_i); mpfr_t tmp; mpfr_init2(tmp, i_prec); mpfr_set_si(tmp, (long) 2, MPFR_RNDN); // tmp := 2 // R_i := R_i mod 2 : mpfr_fmod(R_i, R_i, tmp, MPFR_RNDN); // map (-2,2) --> (-1,1] : if(mpfr_cmp_si(R_i, (long) -1) <= 0) mpfr_add(R_i, R_i, tmp, MPFR_RNDN); else if(mpfr_cmp_si(R_i, (long) 1) > 0) mpfr_sub(R_i, R_i, tmp, MPFR_RNDN); if(mpfr_integer_p(R_i)) // x = 0 or 1 : ==> sin(pi*x) = 0 mpfr_set_zero(R_i, +1); else if(mpfr_cmp_d(R_i, 0.5) == 0) mpfr_set_si(R_i, (long) 1, MPFR_RNDN); else if(mpfr_cmp_d(R_i, -0.5) == 0) mpfr_set_si(R_i, (long) -1, MPFR_RNDN); else { // otherwise return sin(pi * x): mpfr_const_pi (tmp, MPFR_RNDN); mpfr_mul(R_i, R_i, tmp, MPFR_RNDN); mpfr_sin(R_i, R_i, MPFR_RNDN); } break; } case 49: /* tanpi */ { mpfr_prec_t i_prec = mpfr_get_prec(R_i); mpfr_t tmp; mpfr_init2(tmp, i_prec); mpfr_set_si(tmp, (long) 1, MPFR_RNDN); // tmp := 1 // R_i := R_i mod 1 : mpfr_fmod(R_i, R_i, tmp, MPFR_RNDN); // map (-1,1) --> (-1/2, 1/2] : if(mpfr_cmp_d(R_i, (double) -0.5) <= 0) mpfr_add(R_i, R_i, tmp, MPFR_RNDN); else if(mpfr_cmp_d(R_i, (double) 0.5) > 0) mpfr_sub(R_i, R_i, tmp, MPFR_RNDN); if(mpfr_zero_p(R_i)) // x = 0 : ==> tan(pi*x) = 0 mpfr_set_zero(R_i, +1); else if(mpfr_cmp_d(R_i, 0.5) == 0) mpfr_set_si(R_i, (long) 1, MPFR_RNDN); else if(mpfr_cmp_d(R_i, -0.5) == 0) mpfr_set_si(R_i, (long) -1, MPFR_RNDN); else { // otherwise return tan(pi * x): mpfr_const_pi (tmp, MPFR_RNDN); mpfr_mul(R_i, R_i, tmp, MPFR_RNDN); mpfr_tan(R_i, R_i, MPFR_RNDN); } break; } case 71: /* cummax */ mpfr_max(cum, cum, R_i, MPFR_RNDN); break; case 72: /* cummin */ mpfr_min(cum, cum, R_i, MPFR_RNDN); break; case 73: /* cumprod*/ mpfr_mul(cum, cum, R_i, MPFR_RNDN); break; case 74: /* cumsum */ mpfr_add(cum, cum, R_i, MPFR_RNDN); break; /*--- more functions from the mpfr - library but not in R "Math" : ---*/ case 101: mpfr_erf (R_i, R_i, MPFR_RNDN); break; case 102: mpfr_erfc(R_i, R_i, MPFR_RNDN); break; case 104: mpfr_zeta(R_i, R_i, MPFR_RNDN); break; case 106: mpfr_eint(R_i, R_i, MPFR_RNDN); break; case 107: #if (MPFR_VERSION < MPFR_VERSION_NUM(2,4,0)) error("Li2() not implemented in oldish MPFR library version '%s'", MPFR_VERSION_STRING); #else mpfr_li2 (R_i, R_i, MPFR_RNDN); break; #endif case 111: mpfr_j0(R_i, R_i, MPFR_RNDN); break; case 112: mpfr_j1(R_i, R_i, MPFR_RNDN); break; case 113: mpfr_y0(R_i, R_i, MPFR_RNDN); break; case 114: mpfr_y1(R_i, R_i, MPFR_RNDN); break; case 120: #if (MPFR_VERSION < MPFR_VERSION_NUM(3,0,0)) error("Ai() not implemented in oldish MPFR library version '%s'", MPFR_VERSION_STRING); #else mpfr_ai(R_i, R_i, MPFR_RNDN); break; #endif default: error("invalid op code (%d) in Math_mpfr", i_op); } // end{switch()} if(is_cum) SET_VECTOR_ELT(val, i, MPFR_as_R(cum)); else SET_VECTOR_ELT(val, i, MPFR_as_R(R_i)); } mpfr_clear (R_i); if(is_cum) mpfr_clear(cum); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(2); #else UNPROTECT(1); #endif return val; } /* Math_mpfr() */ #undef NOT_YET // %% operator -- do what R does: ~/R/D/r-devel/R/src/main/arithmetic.c // ----- --> it uses %% (only sometimes!) and myfmod(); // .... ok, now checked in ../tests/arith-ex.R // ~~~~~~~~~~~~~~~~~~~ // NB: When using R_mpfr_mod(x, x, y) -- i.e., r == x as pointers, thrashes x static int R_mpfr_mod(mpfr_t r, mpfr_t x, mpfr_t y, mpfr_rnd_t RND) { if(mpfr_nan_p(y) || mpfr_nan_p(x)) { mpfr_set_nan(r); return 0; } int s_y = mpfr_sgn(y);// --> {-1, 0, 1} if(s_y == 0) { // y = 0 |-> NaN : mpfr_set_nan(r); return 0; } int s = mpfr_fmod(r, x, y, RND); if((s_y > 0 && mpfr_sgn(r) < 0) || // as R : (-5) %% 3 |--> 1 (s_y < 0 && mpfr_sgn(r) > 0)) // as R : 5 %% (-3) |--> -1 s += mpfr_add(r, r, y, RND); return s; } SEXP Arith_mpfr(SEXP x, SEXP y, SEXP op) { #ifdef using_Data_slot SEXP xD = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)), yD = PROTECT(GET_SLOT(y, Rmpfr_Data_Sym)); #else # define xD x # define yD y #endif int nx = length(xD), ny = length(yD), i_op = asInteger(op), i, n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; SEXP val = PROTECT(allocVector(VECSXP, n)); mpfr_t x_i, y_i; mpfr_init(x_i); /* with default precision */ mpfr_init(y_i); SET_MISMATCH; for(i=0; i < n; i++) { mpfr_prec_t x_prec, y_prec; R_asMPFR(VECTOR_ELT(xD, i % nx), x_i); x_prec = mpfr_get_prec(x_i); R_asMPFR(VECTOR_ELT(yD, i % ny), y_i); y_prec = mpfr_get_prec(y_i); if(x_prec < y_prec) {/* increase it, since it will store the result */ mpfr_prec_round (x_i, y_prec, MPFR_RNDN); x_prec = y_prec; } switch(i_op) { /* Note we assign use x_i as "input and output" ==> *same* precision, even though in some cases the result may need higher precision */ case 1: /* + */ mpfr_add (x_i, x_i, y_i, MPFR_RNDN); break; case 2: /* - */ mpfr_sub (x_i, x_i, y_i, MPFR_RNDN); break; case 3: /* * */ mpfr_mul (x_i, x_i, y_i, MPFR_RNDN); break; case 4: /* ^ */ mpfr_pow (x_i, x_i, y_i, MPFR_RNDN); break; case 5: /* %% */ R_mpfr_mod(x_i, x_i, y_i, MPFR_RNDN); break; case 6: /* %/% */ { mpfr_t r; mpfr_init(r); if(mpfr_get_prec(r) < x_prec) mpfr_set_prec (r, x_prec); // want to ensure x == (x %% y) + y * ( x %/% y ) // <==> x - (x %% y) == y * ( x %/% y ) // <==> [ x - (x %% y) ] / y == ( x %/% y ) R_mpfr_mod(r, x_i, y_i, MPFR_RNDN);// r := x %% y, mpfr_sub (x_i, x_i, r, MPFR_RNDN); // x~ = x - r = x - (x %% y) mpfr_div (x_i, x_i,y_i,MPFR_RNDN); // x = x~ / y = (x - (x %% y))/y mpfr_clear(r); break; } case 7: /* / */ mpfr_div(x_i, x_i, y_i, MPFR_RNDN); break; default: error("invalid op code (%d) in Arith_mpfr", i_op); } SET_VECTOR_ELT(val, i, MPFR_as_R(x_i)); } MISMATCH_WARN; mpfr_clear (x_i); mpfr_clear (y_i); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(3); #else UNPROTECT(1); #endif return val; } /* Arith_mpfr */ SEXP Arith_mpfr_i(SEXP x, SEXP y, SEXP op) { #ifdef using_Data_slot SEXP xD = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)); #else # define xD x #endif int *yy = INTEGER(y); int nx = length(xD), ny = length(y), i_op = asInteger(op), i, n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; if(TYPEOF(y) != INTSXP) error("Arith[%d](mpfr,i): 'y' is not a \"integer\"", i_op); SEXP val = PROTECT(allocVector(VECSXP, n)); mpfr_t x_i; mpfr_init(x_i); /* with default precision */ SET_MISMATCH; for(i=0; i < n; i++) { int i_ = i % ny; R_asMPFR(VECTOR_ELT(xD, i % nx), x_i); switch(i_op) { /* Note we assign use x_i as "input and output" ==> *same* precision, even though in some cases the result may need higher precision */ case 1: /* + */ mpfr_add_si(x_i, x_i, (long) yy[i_], MPFR_RNDN); break; case 2: /* - */ mpfr_sub_si(x_i, x_i, (long) yy[i_], MPFR_RNDN); break; case 3: /* * */ mpfr_mul_si(x_i, x_i, (long) yy[i_], MPFR_RNDN); break; case 4: /* ^ */ mpfr_pow_si(x_i, x_i, (long) yy[i_], MPFR_RNDN); break; case 5: /* %% */ { mpfr_t yy_i; mpfr_init_set_si(yy_i, (long) yy[i_], MPFR_RNDN); R_mpfr_mod(x_i, x_i, yy_i, MPFR_RNDN); mpfr_clear(yy_i); break; } case 6: /* %/% */ { mpfr_t r, yy_i; mpfr_init(r); mpfr_prec_t x_prec = mpfr_get_prec(x_i); if(mpfr_get_prec(r) < x_prec) mpfr_set_prec (r, x_prec); mpfr_init_set_si(yy_i, (long) yy[i_], MPFR_RNDN); R_mpfr_mod(r, x_i, yy_i, MPFR_RNDN); mpfr_sub (x_i, x_i, r, MPFR_RNDN); // x~ = x - r = x - (x %% y) mpfr_div (x_i, x_i,yy_i,MPFR_RNDN); // x = x~ / y = (x - (x %% y))/y mpfr_clear(r); mpfr_clear(yy_i); break; } case 7: /* / */ mpfr_div_si(x_i, x_i, (long) yy[i_], MPFR_RNDN); break; default: error("invalid op code (%d) in Arith_mpfr", i_op); } SET_VECTOR_ELT(val, i, MPFR_as_R(x_i)); } MISMATCH_WARN; mpfr_clear (x_i); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(2); #else UNPROTECT(1); #endif return val; } /* Arith_mpfr_i */ SEXP Arith_i_mpfr(SEXP x, SEXP y, SEXP op) { #ifdef using_Data_slot SEXP yD = PROTECT(GET_SLOT(y, Rmpfr_Data_Sym)); #else # define yD y #endif int *xx = INTEGER(x); int nx = length(x), ny = length(yD), i_op = asInteger(op), i, n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; if(TYPEOF(x) != INTSXP) error("Arith[%d](i,mpfr): 'x' is not a \"integer\"", i_op); SEXP val = PROTECT(allocVector(VECSXP, n)); mpfr_t y_i; mpfr_init(y_i); /* with default precision */ SET_MISMATCH; for(i=0; i < n; i++) { int i_ = i % nx; R_asMPFR(VECTOR_ELT(yD, i % ny), y_i); switch(i_op) { /* Note we assign use y_i as "input and output" ==> *same* precision, even though in some cases the result may need higher precision */ case 1: /* + */ mpfr_add_si(y_i, y_i, (long) xx[i_], MPFR_RNDN); break; case 2: /* - */ mpfr_si_sub(y_i, (long) xx[i_], y_i, MPFR_RNDN); break; case 3: /* * */ mpfr_mul_si(y_i, y_i, (long) xx[i_], MPFR_RNDN); break; case 4: /* ^ */ { #define R_MPFR_SI_POW(_XXI, _YI) \ long _x = (long) _XXI; \ if(_x >= 0) \ mpfr_ui_pow(_YI, (unsigned long) _x, _YI, MPFR_RNDN); \ else if(mpfr_integer_p(_YI)) { /* ^ */ \ mpfr_ui_pow(_YI, (unsigned long) -_x, _YI, MPFR_RNDN); \ mpfr_neg(_YI, _YI, MPFR_RNDN); \ } \ else /* ^ |-> NaN : */ \ mpfr_set_nan (_YI); \ break R_MPFR_SI_POW(xx[i_], y_i); } case 5: /* %% */ { mpfr_t xx_i, r; mpfr_init_set_si(xx_i, (long) xx[i_], MPFR_RNDN); mpfr_init(r); R_mpfr_mod(r, xx_i, y_i, MPFR_RNDN); mpfr_set(y_i, r, MPFR_RNDN); mpfr_clear(r); mpfr_clear(xx_i); break; } case 6: /* %/% */ { mpfr_t r, xx_i; mpfr_init(r); mpfr_prec_t y_prec = mpfr_get_prec(y_i); if(mpfr_get_prec(r) < y_prec) mpfr_set_prec (r, y_prec); mpfr_init_set_si(xx_i, (long) xx[i_], MPFR_RNDN); R_mpfr_mod(r, xx_i, y_i, MPFR_RNDN); mpfr_sub (xx_i,xx_i, r, MPFR_RNDN); // x~ = x - r = x - (x %% y) mpfr_div (y_i, xx_i,y_i,MPFR_RNDN); // y = x~ / y = (x - (x %% y))/y mpfr_clear(r); mpfr_clear(xx_i); break; } case 7: /* / */ mpfr_si_div(y_i, (long) xx[i_], y_i, MPFR_RNDN); break; default: error("invalid op code (%d) in Arith_mpfr", i_op); } SET_VECTOR_ELT(val, i, MPFR_as_R(y_i)); } MISMATCH_WARN; mpfr_clear (y_i); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(2); #else UNPROTECT(1); #endif return val; } /* Arith_i_mpfr */ SEXP Arith_mpfr_d(SEXP x, SEXP y, SEXP op) { #ifdef using_Data_slot SEXP xD = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)); #else # define xD x #endif double *yy = REAL(y); int nx = length(xD), ny = length(y), i_op = asInteger(op), i, n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; if(TYPEOF(y) != REALSXP) error("Arith[%d](mpfr,d): 'y' is not a \"double\"", i_op); SEXP val = PROTECT(allocVector(VECSXP, n)); mpfr_t x_i, yy_i; mpfr_init(x_i); mpfr_init(yy_i); /* with default precision */ SET_MISMATCH; for(i=0; i < n; i++) { double yi = yy[i % ny]; /* this fails for yi = 'dOO <- 9223372036854775808', see ../tests/arith-ex.R , * (because in double precision 9223372036854775807 == 9223372036854775808 !!): * int y_is_int = (yi == trunc(yi) && LONG_MIN <= yi && yi <= LONG_MAX); ==> use '<' instead of '<=' twice ! */ int y_is_int = (yi == trunc(yi) && LONG_MIN < yi && yi < LONG_MAX); R_asMPFR(VECTOR_ELT(xD, i % nx), x_i); if(y_is_int) { /* can use o routines */ #ifdef DEBUG_Rmpfr REprintf("yi: %.20g, (long)yi: %ld; yi is int. in [L_MIN, L_MAX]=[%ld,%ld]\n", yi, (long)yi, LONG_MIN, LONG_MAX); #endif switch(i_op) { case 1: /* + */ mpfr_add_si(x_i, x_i, (long)yi, MPFR_RNDN); break; case 2: /* - */ mpfr_sub_si(x_i, x_i, (long)yi, MPFR_RNDN); break; case 3: /* * */ mpfr_mul_si(x_i, x_i, (long)yi, MPFR_RNDN); break; case 4: /* ^ */ mpfr_pow_si(x_i, x_i, (long)yi, MPFR_RNDN); break; case 5: /* %% */ { mpfr_set_si(yy_i, (long)yi, MPFR_RNDN); R_mpfr_mod(x_i, x_i, yy_i, MPFR_RNDN); break; } case 6: /* %/% */ { mpfr_t r; mpfr_init(r); mpfr_prec_t x_prec = mpfr_get_prec(x_i); if(mpfr_get_prec(r) < x_prec) mpfr_set_prec (r, x_prec); mpfr_set_si(yy_i, (long) yi, MPFR_RNDN); R_mpfr_mod(r, x_i, yy_i, MPFR_RNDN); mpfr_sub (x_i, x_i, r, MPFR_RNDN); // x~ = x - r = x - (x %% y) mpfr_div (x_i, x_i, yy_i, MPFR_RNDN); // x = x~ / y = (x - (x %% y))/y mpfr_clear(r); break; } case 7: /* / */ mpfr_div_si(x_i, x_i, (long)yi, MPFR_RNDN); break; default: error("invalid op code (%d) in Arith_mpfr_d", i_op); } } else { mpfr_set_d (yy_i, yi, MPFR_RNDD); switch(i_op) { /* Note we assign use x_i as "input and output" ==> *same* precision, even though in some cases the result may need higher precision */ case 1: /* + */ mpfr_add(x_i, x_i, yy_i, MPFR_RNDN); break; case 2: /* - */ mpfr_sub(x_i, x_i, yy_i, MPFR_RNDN); break; case 3: /* * */ mpfr_mul(x_i, x_i, yy_i, MPFR_RNDN); break; case 4: /* ^ */ mpfr_pow(x_i, x_i, yy_i, MPFR_RNDN); break; case 5: /* %% */ R_mpfr_mod(x_i, x_i, yy_i, MPFR_RNDN); break; case 6: /* %/% */ { mpfr_t r; mpfr_init(r); mpfr_prec_t x_prec = mpfr_get_prec(x_i); if(mpfr_get_prec(r) < x_prec) mpfr_set_prec (r, x_prec); R_mpfr_mod(r, x_i, yy_i, MPFR_RNDN); mpfr_sub (x_i, x_i, r, MPFR_RNDN); // x~ = x - r = x - (x %% y) mpfr_div (x_i, x_i, yy_i, MPFR_RNDN); // x = x~ / y = (x - (x %% y))/y mpfr_clear(r); break; } case 7: /* / */ mpfr_div(x_i, x_i, yy_i, MPFR_RNDN); break; default: error("invalid op code (%d) in Arith_mpfr_d", i_op); } } SET_VECTOR_ELT(val, i, MPFR_as_R(x_i)); } MISMATCH_WARN; mpfr_clear (x_i); mpfr_clear (yy_i); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(2); #else UNPROTECT(1); #endif return val; } /* Arith_mpfr_d */ SEXP Arith_d_mpfr(SEXP x, SEXP y, SEXP op) { #ifdef using_Data_slot SEXP yD = PROTECT(GET_SLOT(y, Rmpfr_Data_Sym)); #else # define yD y #endif double *xx = REAL(x); int nx = length(x), ny = length(yD), i_op = asInteger(op), i, n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; if(TYPEOF(x) != REALSXP) error("Arith[%d](d,mpfr): 'x' is not a \"double\"", i_op); SEXP val = PROTECT(allocVector(VECSXP, n)); mpfr_t y_i; mpfr_init(y_i); SET_MISMATCH; for(i=0; i < n; i++) { double xi = xx[i % nx]; int x_is_int = (xi == trunc(xi) && LONG_MIN <= xi && xi <= LONG_MAX); R_asMPFR(VECTOR_ELT(yD, i % ny), y_i); if(x_is_int) { /* can use o routines */ /* REprintf("x[i] (= %g) is int: (long)* = %ld\n", xi, (long)xi); */ switch(i_op) { case 1: /* + */ mpfr_add_si(y_i, y_i, (long)xi, MPFR_RNDN); break; case 2: /* - */ mpfr_si_sub(y_i, (long)xi, y_i, MPFR_RNDN); break; case 3: /* * */ mpfr_mul_si(y_i, y_i, (long)xi, MPFR_RNDN); break; case 4: /* ^ */ { R_MPFR_SI_POW((long)xi, y_i); } case 5: /* %% */ { mpfr_t xx_i, r; mpfr_init_set_si(xx_i, (long)xi, MPFR_RNDN); mpfr_init(r); R_mpfr_mod(r, xx_i, y_i, MPFR_RNDN); mpfr_set(y_i, r, MPFR_RNDN); mpfr_clear(r); mpfr_clear(xx_i); break; } case 6: /* %/% */ { mpfr_t r, xx_i; mpfr_init(r); mpfr_prec_t y_prec = mpfr_get_prec(y_i); if(mpfr_get_prec(r) < y_prec) mpfr_set_prec (r, y_prec); mpfr_init_set_si(xx_i, (long) xi, MPFR_RNDN); R_mpfr_mod(r, xx_i, y_i, MPFR_RNDN); mpfr_sub (xx_i,xx_i, r, MPFR_RNDN); // x~ = x - r = x - (x %% y) mpfr_div (y_i, xx_i, y_i, MPFR_RNDN); // y = x~ / y = (x - (x %% y))/y mpfr_clear(r); mpfr_clear(xx_i); break; } case 7: /* / */ mpfr_si_div(y_i, (long)xi, y_i, MPFR_RNDN); break; default: error("invalid op code (%d) in Arith_d_mpfr", i_op); } } else { mpfr_t xx_i; mpfr_init_set_d (xx_i, xi, MPFR_RNDD); switch(i_op) { /* Note we assign use y_i as "input and output" ==> *same* precision, even though in some cases the result may need higher precision */ case 1: /* + */ mpfr_add(y_i, xx_i, y_i, MPFR_RNDN); break; case 2: /* - */ mpfr_sub(y_i, xx_i, y_i, MPFR_RNDN); break; case 3: /* * */ mpfr_mul(y_i, xx_i, y_i, MPFR_RNDN); break; case 4: /* ^ */ mpfr_pow(y_i, xx_i, y_i, MPFR_RNDN); break; case 5: /* %% */ { mpfr_t r; mpfr_init(r); R_mpfr_mod(r, xx_i, y_i, MPFR_RNDN); mpfr_set(y_i, r, MPFR_RNDN); mpfr_clear(r); break; } case 6: /* %/% */ { mpfr_t r; mpfr_init(r); mpfr_prec_t y_prec = mpfr_get_prec(y_i); if(mpfr_get_prec(r) < y_prec) mpfr_set_prec (r, y_prec); R_mpfr_mod(r, xx_i, y_i, MPFR_RNDN); mpfr_sub (xx_i,xx_i, r, MPFR_RNDN); // x~ = x - r = x - (x %% y) mpfr_div (y_i, xx_i, y_i, MPFR_RNDN); // y = x~ / y = (x - (x %% y))/y mpfr_clear(r); break; } case 7: /* / */ mpfr_div(y_i, xx_i, y_i, MPFR_RNDN); break; default: error("invalid op code (%d) in Arith_d_mpfr", i_op); } mpfr_clear(xx_i); } SET_VECTOR_ELT(val, i, MPFR_as_R(y_i)); } MISMATCH_WARN; mpfr_clear (y_i); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(2); #else UNPROTECT(1); #endif return val; } /* Arith_d_mpfr */ SEXP Compare_mpfr(SEXP x, SEXP y, SEXP op) { #ifdef using_Data_slot SEXP xD = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)), yD = PROTECT(GET_SLOT(y, Rmpfr_Data_Sym)); #else # define xD x # define yD y #endif int nx = length(xD), ny = length(yD), i_op = asInteger(op), i, n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; SEXP val = PROTECT(allocVector(LGLSXP, n)); int *r = LOGICAL(val); mpfr_t x_i, y_i; mpfr_init(x_i); /* with default precision */ mpfr_init(y_i); /* with default precision */ SET_MISMATCH; for(i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(xD, i % nx), x_i); R_asMPFR(VECTOR_ELT(yD, i % ny), y_i); if(mpfr_nan_p(x_i) || mpfr_nan_p(y_i)) { r[i] = NA_LOGICAL; } else { switch(i_op) { case 1: /* == */ r[i] = mpfr_equal_p(x_i, y_i); break; case 2: /* > */ r[i] = mpfr_greater_p(x_i, y_i); break; case 3: /* < */ r[i] = mpfr_less_p(x_i, y_i); break; case 4: /* != */ r[i] = mpfr_lessgreater_p(x_i, y_i); break; case 5: /* <= */ r[i] = mpfr_lessequal_p(x_i, y_i); break; case 6: /* >= */ r[i] = mpfr_greaterequal_p(x_i, y_i); break; default: error("invalid op code (%d) in Compare_mpfr", i_op); } } } MISMATCH_WARN; mpfr_clear (x_i); mpfr_clear (y_i); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(3); #else UNPROTECT(1); #endif return val; } /* Compare_mpfr */ SEXP Compare_mpfr_i(SEXP x, SEXP y, SEXP op) { #ifdef using_Data_slot SEXP xD = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)); #else # define xD x #endif int *yy = INTEGER(y); int nx = length(xD), ny = length(y), i_op = asInteger(op), i, n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; SEXP val = PROTECT(allocVector(LGLSXP, n)); int *r = LOGICAL(val); mpfr_t x_i; mpfr_init(x_i); SET_MISMATCH; for(i=0; i < n; i++) { int yi = yy[i % ny], c; R_asMPFR(VECTOR_ELT(xD, i % nx), x_i); c = mpfr_cmp_si(x_i, (long) yi);/* gives c > or == or < 0 */ if(c == 0 && /* also includes case where an operand is NaN */ (yi == NA_INTEGER || mpfr_nan_p(x_i))) { r[i] = NA_LOGICAL; } else { switch(i_op) { case 1: /* == */ r[i] = (c == 0); break; case 2: /* > */ r[i] = (c > 0); break; case 3: /* < */ r[i] = (c < 0); break; case 4: /* != */ r[i] = (c != 0); break; case 5: /* <= */ r[i] = (c <= 0); break; case 6: /* >= */ r[i] = (c >= 0); break; default: error("invalid op code (%d) in Compare_mpfr_i", i_op); } } } MISMATCH_WARN; mpfr_clear (x_i); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(2); #else UNPROTECT(1); #endif return val; } /* Compare_mpfr_i */ SEXP Compare_mpfr_d(SEXP x, SEXP y, SEXP op) { #ifdef using_Data_slot SEXP xD = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)); #else # define xD x #endif double *yy = REAL(y); int nx = length(xD), ny = length(y), i_op = asInteger(op), i, n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; SEXP val = PROTECT(allocVector(LGLSXP, n)); int *r = LOGICAL(val); mpfr_t x_i; mpfr_init(x_i); SET_MISMATCH; for(i=0; i < n; i++) { double yi = yy[i % ny]; int c; R_asMPFR(VECTOR_ELT(xD, i % nx), x_i); c = mpfr_cmp_d(x_i, yi);/* gives c > or == or < 0 */ if(c == 0 && /* also includes case where an operand is NaN */ (ISNAN(yi) || mpfr_nan_p(x_i))) { r[i] = NA_LOGICAL; } else { switch(i_op) { case 1: /* == */ r[i] = (c == 0); break; case 2: /* > */ r[i] = (c > 0); break; case 3: /* < */ r[i] = (c < 0); break; case 4: /* != */ r[i] = (c != 0); break; case 5: /* <= */ r[i] = (c <= 0); break; case 6: /* >= */ r[i] = (c >= 0); break; default: error("invalid op code (%d) in Compare_mpfr_d", i_op); } } } MISMATCH_WARN; mpfr_clear (x_i); mpfr_free_cache(); #ifdef using_Data_slot UNPROTECT(2); #else UNPROTECT(1); #endif return val; } /* Compare_mpfr_d */ #ifdef __NOT_ANY_MORE__ /* Not really used anymore : */ #define INIT_1_SETUP(_X_, _R_) \ mpfr_t _R_; \ \ mpfr_init2(_R_, R_mpfr_prec(_X_)); \ R_asMPFR(_X_, _R_) #define FINISH_1_RETURN(_R_, val) \ val = PROTECT(MPFR_as_R(_R_)); \ mpfr_clear (_R_); \ mpfr_free_cache(); \ UNPROTECT(1); \ return val SEXP exp_mpfr1(SEXP x) { SEXP val; INIT_1_SETUP(x, r); mpfr_exp(r, r, MPFR_RNDN); /* - - ((result may need higher precision)) .. */ FINISH_1_RETURN(r, val); } SEXP log_mpfr1(SEXP x) { SEXP val; INIT_1_SETUP(x, r); mpfr_log(r, r, MPFR_RNDN); FINISH_1_RETURN(r, val); } /* Unused */ #define INIT_2_SETUP(_X_, _R_, _S_) \ mpfr_t _R_, _S_; \ \ mpfr_init2(_R_, R_mpfr_prec(_X_)); \ /* _S_ should get same precision as _R_ :*/ \ mpfr_init2(_S_, mpfr_get_prec(_R_)); \ R_asMPFR(_X_, _R_) #define FINISH_2_RETURN(_R_, _S_, val) \ val = PROTECT(MPFR_as_R(_R_)); \ mpfr_clear(_R_); mpfr_clear(_S_); \ mpfr_free_cache(); \ UNPROTECT(1); \ return val #endif /* __NOT_ANY_MORE__ */ Rmpfr/src/init.c0000644000176200001440000001107514107223103013233 0ustar liggesusers/* Setup here "copied" from Matrix package */ #include #define _in_Rmpfr_init_ #include "Rmpfr_utils.h" #include "Syms.h" #undef _in_Rmpfr_init_ #define CALLDEF(name, n) {#name, (DL_FUNC) &name, n} static R_CallMethodDef CallEntries[] = { CALLDEF(d2mpfr1, 3), CALLDEF(d2mpfr1_list, 3), #ifdef Have_interface_Rmpfr_gmp CALLDEF(mpz2mpfr1, 3), CALLDEF(mpz2mpfr1_list, 3), #endif #ifdef R_had_R_Outputfile_in_API #ifndef WIN32 /* only works on "unix-alikes" */ CALLDEF(print_mpfr, 2), CALLDEF(print_mpfr1, 2), #endif #endif CALLDEF(mpfr2d, 2), CALLDEF(mpfr2i, 2), CALLDEF(mpfr2str, 4), CALLDEF(R_mpfr_formatinfo, 1), CALLDEF(R_mpfr_2exp, 1), CALLDEF(R_mpfr_frexp, 2), CALLDEF(R_mpfr_ldexp, 3), CALLDEF(str2mpfr1_list, 4), CALLDEF(Rmpfr_minus, 1), CALLDEF(Rmpfr_abs, 1), CALLDEF(Math_mpfr, 2), CALLDEF(Arith_mpfr, 3), CALLDEF(Arith_mpfr_i, 3), CALLDEF(Arith_i_mpfr, 3), CALLDEF(Arith_mpfr_d, 3), CALLDEF(Arith_d_mpfr, 3), CALLDEF(Compare_mpfr, 3), CALLDEF(Compare_mpfr_i, 3), CALLDEF(Compare_mpfr_d, 3), CALLDEF(Summary_mpfr, 3), CALLDEF(R_mpfr_sumprod, 4), CALLDEF(R_mpfr_set_debug, 1), CALLDEF(R_mpfr_set_default_prec, 1), CALLDEF(R_mpfr_get_default_prec, 0), CALLDEF(R_mpfr_prec_range, 1), CALLDEF(R_mpfr_get_erange, 1), CALLDEF(R_mpfr_set_erange, 2), CALLDEF(R_mpfr_erange_int_p, 0), CALLDEF(R_mpfr_get_version, 0), CALLDEF(R_mpfr_get_GMP_numb_bits, 0), CALLDEF(const_asMpfr, 3), CALLDEF(R_mpfr_is_finite, 1), CALLDEF(R_mpfr_is_finite_A, 1), CALLDEF(R_mpfr_is_infinite, 1), CALLDEF(R_mpfr_is_infinite_A, 1), CALLDEF(R_mpfr_is_integer, 1), CALLDEF(R_mpfr_is_integer_A, 1), CALLDEF(R_mpfr_is_na, 1), CALLDEF(R_mpfr_is_na_A, 1), CALLDEF(R_mpfr_is_zero, 1), CALLDEF(R_mpfr_is_zero_A, 1), CALLDEF(R_mpfr_atan2, 3), CALLDEF(R_mpfr_igamma, 3), CALLDEF(R_mpfr_hypot, 3), CALLDEF(R_mpfr_beta, 3), CALLDEF(R_mpfr_lbeta, 3), CALLDEF(R_mpfr_jn, 3), CALLDEF(R_mpfr_yn, 3), CALLDEF(R_mpfr_fac, 3), CALLDEF(R_mpfr_choose, 3), CALLDEF(R_mpfr_poch, 3), CALLDEF(R_mpfr_round, 3), {NULL, NULL, 0} }; void #ifdef HAVE_VISIBILITY_ATTRIBUTE __attribute__ ((visibility ("default"))) #endif R_init_Rmpfr(DllInfo *dll) { R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); R_useDynamicSymbols(dll, FALSE); #define RREGDEF(name) R_RegisterCCallable("Rmpfr", #name, (DL_FUNC) name) RREGDEF(d2mpfr1); RREGDEF(d2mpfr1_list); #ifdef Have_interface_Rmpfr_gmp RREGDEF(mpz2mpfr1); RREGDEF(mpz2mpfr1_list); #endif #ifdef R_had_R_Outputfile_in_API #ifndef WIN32 RREGDEF(print_mpfr); RREGDEF(print_mpfr1); #endif #endif RREGDEF(mpfr2d); RREGDEF(mpfr2i); RREGDEF(mpfr2str); RREGDEF(str2mpfr1_list); RREGDEF(Rmpfr_minus); RREGDEF(Rmpfr_abs); RREGDEF(Math_mpfr); RREGDEF(Arith_mpfr); RREGDEF(Arith_mpfr_i); RREGDEF(Arith_i_mpfr); RREGDEF(Arith_mpfr_d); RREGDEF(Arith_d_mpfr); RREGDEF(Compare_mpfr); RREGDEF(Compare_mpfr_i); RREGDEF(Compare_mpfr_d); RREGDEF(Summary_mpfr); RREGDEF(R_mpfr_sumprod); RREGDEF(R_mpfr_set_debug); RREGDEF(R_mpfr_set_default_prec); RREGDEF(R_mpfr_get_default_prec); RREGDEF(R_mpfr_get_version); RREGDEF(R_mpfr_get_GMP_numb_bits); RREGDEF(const_asMpfr); RREGDEF(R_mpfr_is_finite); RREGDEF(R_mpfr_is_finite_A); RREGDEF(R_mpfr_is_infinite); RREGDEF(R_mpfr_is_infinite_A); RREGDEF(R_mpfr_is_integer); RREGDEF(R_mpfr_is_integer_A); RREGDEF(R_mpfr_is_na); RREGDEF(R_mpfr_is_na_A); RREGDEF(R_mpfr_is_zero); RREGDEF(R_mpfr_is_zero_A); RREGDEF(R_mpfr_jn); RREGDEF(R_mpfr_yn); RREGDEF(R_mpfr_atan2); RREGDEF(R_mpfr_hypot); RREGDEF(R_mpfr_igamma); RREGDEF(R_mpfr_beta); RREGDEF(R_mpfr_lbeta); RREGDEF(R_mpfr_fac); RREGDEF(R_mpfr_choose); RREGDEF(R_mpfr_poch); RREGDEF(R_mpfr_round); /* Sync this with declarations in ./Syms.h : */ Rmpfr_precSym = install("prec"); Rmpfr_signSym = install("sign"); Rmpfr_expSym = install("exp"); Rmpfr_d_Sym = install("d"); Rmpfr_Data_Sym = install(".Data"); Rmpfr_Dim_Sym = install("Dim"); Rmpfr_Dimnames_Sym = install("Dimnames"); /* not suppressable, hence moved to suppressable R startup code: Rprintf("Loading C code of R package 'Rmpfr': GMP using %d bits per limb\n", GMP_NUMB_BITS); */ /* if(GMP_NUMB_BITS != 32) */ /* error("The Rmpfr package currently needs 32-bit limbs"); */ } /* void R_unload_Rmpfr(DllInfo *dll) */ /* { */ /* } */ Rmpfr/src/convert.c0000644000176200001440000006320114532460412013756 0ustar liggesusers/* * MPFR - Multiple Precision Floating-Point Reliable Library * ---- - - - - */ #include /* for imax2() */ #include "Rmpfr_utils.h" extern #include "Syms.h" /*------------------------------------------------------------------------*/ /* NB: int nr_limbs = R_mpfr_nr_limbs(r) [ in MPFR_as_R() ] or * = N_LIMBS(i_prec) [ in d2mpfr1_() ] * R_mpfr_exp_size is sufficient also for enlarged exponent range, as that is still < 2^62 */ #if GMP_NUMB_BITS == 32 # define R_mpfr_nr_ints nr_limbs # define R_mpfr_exp_size 1 #elif GMP_NUMB_BITS == 64 # define R_mpfr_nr_ints (2*nr_limbs) # define R_mpfr_exp_size 2 #else # error "R <-> C Interface *not* implemented for GMP_NUMB_BITS=" ## GMP_NUMB_BITS #endif // Initialize contents (4 slots) of a "mpfr1" R object #define R_mpfr_MPFR_2R_init(_V_, _d_length_) \ SEXP _V_ = PROTECT(NEW_OBJECT(PROTECT(MAKE_CLASS("mpfr1")))); \ SEXP prec_R = PROTECT(ALLOC_SLOT(_V_, Rmpfr_precSym, INTSXP, 1)); \ SEXP sign_R = PROTECT(ALLOC_SLOT(_V_, Rmpfr_signSym, INTSXP, 1)); \ SEXP exp_R = PROTECT(ALLOC_SLOT(_V_, Rmpfr_expSym, INTSXP, R_mpfr_exp_size)); \ SEXP d_R = PROTECT(ALLOC_SLOT(_V_, Rmpfr_d_Sym, INTSXP, _d_length_)); \ /* the integer vector which makes up the mantissa: */ \ int *dd = INTEGER(d_R), \ *ex = INTEGER(exp_R) /* the one for the exponent */ /*------------------------*/ #if GMP_NUMB_BITS == 32 /* ---- easy : a gmp-limb is an int <--> R */ // This is only ok if( mpfr_regular_p(.) ), i.e. not for {0, NaN, Inf}: # define R_mpfr_FILL_DVEC(i) \ R_mpfr_dbg_printf(2,"r..d[i=%d] = 0x%lx\n",i,r->_mpfr_d[i]); \ dd[i] = (int) r->_mpfr_d[i] # define R_mpfr_GET_DVEC(i) \ r->_mpfr_d[i] = (mp_limb_t) dd[i]; \ R_mpfr_dbg_printf(2,"dd[%d] = %10lu -> r..d[i=%d]= 0x%lx\n", \ i, dd[i], i,r->_mpfr_d[i]) // these work on (r, ex[0]) : # define R_mpfr_FILL_EXP ex[0] = (int)r->_mpfr_exp # define R_mpfr_GET_EXP r->_mpfr_exp = (mpfr_exp_t) ex[0] /*------------------------*/ #elif GMP_NUMB_BITS == 64 /* ---- here a gmp-limb is 64-bit (long long): * ==> one limb <---> 2 R int.s : */ # define RIGHT_HALF(_LONG_) ((long long)(_LONG_) & 0x00000000FFFFFFFF) // 1 4 8| 4 8 # define LEFT_SHIFT(_LONG_) (((unsigned long long)(_LONG_)) << 32) // This is only ok if( mpfr_regular_p(.) ), i.e. not for {0, NaN, Inf}: # define R_mpfr_FILL_DVEC(i) \ R_mpfr_dbg_printf(2,"r..d[i=%d] = 0x%lx\n",i,r->_mpfr_d[i]); \ dd[2*i] = (int) RIGHT_HALF(r->_mpfr_d[i]); \ dd[2*i+1]= (int) (r->_mpfr_d[i] >> 32) # define R_mpfr_GET_DVEC(i) \ r->_mpfr_d[i] = (mp_limb_t)(RIGHT_HALF(dd[2*i]) | LEFT_SHIFT(dd[2*i+1])); \ R_mpfr_dbg_printf(2,"dd[%d:%d]= (%10lu,%10lu) -> r..d[i=%d]= 0x%lx\n", \ 2*i,2*i+1, dd[2*i],dd[2*i+1], i,r->_mpfr_d[i]) // these work on (r, ex[0], {ex[1] or ex1}) : # define R_mpfr_FILL_EXP \ R_mpfr_dbg_printf(2,"_exp = 0x%lx\n",r->_mpfr_exp); \ ex[0] = (int) RIGHT_HALF(r->_mpfr_exp); \ ex[1] = (int) (((long long)r->_mpfr_exp) >> 32) # define R_mpfr_GET_EXP \ r->_mpfr_exp = (mpfr_exp_t) (RIGHT_HALF(ex[0]) | LEFT_SHIFT(ex1)); \ R_mpfr_dbg_printf(2,"ex[0:1]= (%10lu,%10lu) -> _exp = 0x%lx\n", \ ex[0],ex1, r->_mpfr_exp) /*------------------------*/ #else # error "will not happen" #endif #define R_mpfr_MPFR_2R_fill \ /* now fill the slots of val */ \ INTEGER(prec_R)[0] = (int)r->_mpfr_prec; \ INTEGER(sign_R)[0] = (int)r->_mpfr_sign; \ R_mpfr_FILL_EXP; \ if(regular_p) { \ /* the full *vector* of limbs : */ \ for(i=0; i < nr_limbs; i++) { \ R_mpfr_FILL_DVEC(i); \ } \ } /* Return an R "mpfr1" object corresponding to mpfr input: */ SEXP MPFR_as_R(mpfr_t r) { int nr_limbs = R_mpfr_nr_limbs(r), regular_p = mpfr_regular_p(r), i; R_mpfr_MPFR_2R_init(val, (regular_p ? R_mpfr_nr_ints : 0)); R_mpfr_MPFR_2R_fill; UNPROTECT(6); return val; } SEXP d2mpfr1_(double x, int i_prec, mpfr_rnd_t rnd) { mpfr_t r; int nr_limbs = N_LIMBS(i_prec), regular_p, i; R_mpfr_check_prec(i_prec); mpfr_init2 (r, (mpfr_prec_t)i_prec); mpfr_set_d (r, x, rnd); regular_p = mpfr_regular_p(r); R_mpfr_MPFR_2R_init(val, (regular_p ? R_mpfr_nr_ints : 0)); R_mpfr_MPFR_2R_fill; /* free space used by the MPFR variables */ mpfr_clear (r); mpfr_free_cache(); /* <- Manual 4.8 "Memory Handling" strongly advises ...*/ UNPROTECT(6); return val; }/* d2mpfr1_ */ /** * Translate an "R rounding mode" into the correct MPFR one * * @param rnd_mode: an R character (string with nchar() == 1). * * @return one of the (currently 4) different MPFR_RND[DNUZ] modes. */ mpfr_rnd_t R_rnd2MP(SEXP rnd_mode) { const char* r_ch = CHAR(asChar(rnd_mode)); switch(r_ch[0]) { case 'D': return MPFR_RNDD; case 'N': return MPFR_RNDN; case 'U': return MPFR_RNDU; case 'Z': return MPFR_RNDZ; case 'A': return MPFR_RNDA; // since MPFR 3.0.0 default: error(_("illegal rounding mode '%s'; must be one of {'D','N','U','Z','A'}"), r_ch); /* Wall: */ return MPFR_RNDN; } } SEXP d2mpfr1(SEXP x, SEXP prec, SEXP rnd_mode) { if(LENGTH(x) != 1) error("length(x) (=%d) is not 1", LENGTH(x)); return d2mpfr1_(asReal(x), asInteger(prec), R_rnd2MP(rnd_mode)); } SEXP d2mpfr1_list(SEXP x, SEXP prec, SEXP rnd_mode) { int nx = LENGTH(x), np = LENGTH(prec), n = (nx == 0 || np == 0) ? 0 : imax2(nx, np), nprot = 1; SEXP val = PROTECT(allocVector(VECSXP, n)); if(nx > 0) { mpfr_rnd_t rnd = R_rnd2MP(rnd_mode); if(!isReal(x)) { PROTECT(x = coerceVector(x, REALSXP)); nprot++; } if(!isInteger(prec)) { PROTECT(prec = coerceVector(prec, INTSXP)); nprot++; } double *dx = REAL(x); int *iprec = INTEGER(prec); for(int i = 0; i < n; i++) { /* FIXME: become more efficient by doing R_mpfr_MPFR_2R_init() only once*/ SET_VECTOR_ELT(val, i, d2mpfr1_(dx[i % nx], iprec[i % np], rnd)); } } UNPROTECT(nprot); return val; } /* -- Function: int mpfr_set_z (mpfr_t ROP, mpz_t OP, mpfr_rnd_t RND) -- Function: int mpfr_set_q (mpfr_t ROP, mpq_t OP, mpfr_rnd_t RND) --> would want functions SEXP mpz2mpfr1_(mpz_t x, int i_prec, mpfr_rnd_t rnd); SEXP mpz2mpfr1 (SEXP x, SEXP prec, SEXP rnd_mode); SEXP mpz2mpfr1_list(SEXP x, SEXP prec, SEXP rnd_mode); {and the same for 'q' instead of 'z'} completely parallel to the d2mpfr*() functions above *BUT* we cannot easily do the [R package gmp C++ code]-part of SEXP -> mpz ! MM - FIXME: still do it .. should not be so hard to "guess" ... horrifically, ... for now, R's ..bigq2mpfr(), ..bigz2mpfr() "simply" go via character strings */ /* From the MPFR (2.3.2, 2008) doc : -- Function: int mpfr_set_str (mpfr_t ROP, const char *S, int BASE, mpfr_rnd_t RND) Set ROP to the value of the whole string S in base BASE, rounded in the direction RND. See the documentation of `mpfr_strtofr' for a detailed description of the valid string formats. This function returns 0 if the entire string up to the final null character is a valid number in base BASE; otherwise it returns -1, and ROP may have changed. */ SEXP str2mpfr1_list(SEXP x, SEXP prec, SEXP base, SEXP rnd_mode) { /* NB: Both x and prec are "recycled" to the longer one if needed */ int ibase = asInteger(base), *iprec, nx = LENGTH(x), np = LENGTH(prec), n = (nx == 0 || np == 0) ? 0 : imax2(nx, np), nprot = 1; SEXP val = PROTECT(allocVector(VECSXP, n)); mpfr_rnd_t rnd = R_rnd2MP(rnd_mode); mpfr_t r_i; mpfr_init(r_i); if(!isString(x)) { PROTECT(x = coerceVector(x, STRSXP)); nprot++; } if(!isInteger(prec)) { PROTECT(prec = coerceVector(prec, INTSXP)); nprot++; } iprec = INTEGER(prec); for(int i = 0; i < n; i++) { int prec_i = iprec[i % np]; R_mpfr_check_prec(prec_i); mpfr_set_prec(r_i, (mpfr_prec_t) prec_i); int ierr = mpfr_set_str(r_i, CHAR(STRING_ELT(x, i % nx)), ibase, rnd); if(ierr) { if (!strcmp("NA", CHAR(STRING_ELT(x, i % nx)))) mpfr_set_nan(r_i); // "NA" <=> "NaN" (which *are* treated well, by mpfr_set_str) else error("str2mpfr1_list(x, *): x[%d] cannot be made into MPFR", i+1); } /* FIXME: become more efficient by doing R_mpfr_MPFR_2R_init() only once*/ SET_VECTOR_ELT(val, i, MPFR_as_R(r_i)); } mpfr_clear (r_i); mpfr_free_cache(); UNPROTECT(nprot); return val; } #undef R_mpfr_MPFR_2R_init #undef R_mpfr_MPFR_2R_fill #ifdef _not_used_ /* This does *not* work: gives *empty* .Data slot [bug in NEW_OBJECT()? ] */ SEXP d2mpfr(SEXP x, SEXP prec) { int i_prec = asInteger(prec), nx = LENGTH(x), np = LENGTH(prec), n = (nx == 0 || np == 0) ? 0 : imax2(nx, np), nprot = 1; SEXP val = PROTECT(NEW_OBJECT(MAKE_CLASS("mpfr"))), lis = ALLOC_SLOT(val, Rmpfr_Data_Sym, VECSXP, n); double *dx; if(!isReal(x)) { PROTECT(x = coerceVector(x, REALSXP)); nprot++; } REprintf("d2mpfr(x, prec): length(x) = %d, prec = %d -> length(lis) = %d\n", nx, i_prec, LENGTH(lis)); dx = REAL(x); for(int i = 0; i < n; i++) { SET_VECTOR_ELT(lis, i, duplicate(d2mpfr1_(dx [i % nx], i_prec [i % np]))); } UNPROTECT(nprot); return val; } #endif /* The inverse of MPFR_as_R() : * From an R "mpfr1" object `x`, create mpfr `r` (with correct prec): */ void R_asMPFR(SEXP x, mpfr_ptr r) { SEXP prec_R = GET_SLOT(x, Rmpfr_precSym); // SEXP sign_R = GET_SLOT(x, Rmpfr_signSym);// only used once SEXP exp_R = GET_SLOT(x, Rmpfr_expSym); SEXP d_R = GET_SLOT(x, Rmpfr_d_Sym); int x_prec = INTEGER(prec_R)[0], nr_limbs = N_LIMBS(x_prec), i; Rboolean regular_x = length(d_R) > 0; int *dd = INTEGER(d_R),/* the vector which makes up the mantissa */ *ex = INTEGER(exp_R), ex1; /* the one for the exponent */ if(regular_x && length(d_R) != R_mpfr_nr_ints) error("nr_limbs(x_prec)= nr_limbs(%d)= %d : length() == %d != R_mpfr_nr_ints == %d", x_prec, nr_limbs, length(d_R), R_mpfr_nr_ints); if(length(exp_R) < R_mpfr_exp_size) { if(length(exp_R) == 0) error("'exp' slot has length 0"); /* else: we got a 32-bit one in a 64-bit system */ ex1 = 0; } else ex1 = ex[1]; mpfr_set_prec(r, (mpfr_prec_t) x_prec); r->_mpfr_sign = (mpfr_sign_t) INTEGER(GET_SLOT(x, Rmpfr_signSym))[0]; R_mpfr_GET_EXP; if(regular_x) /* the full *vector* of limbs : */ for(i=0; i < nr_limbs; i++) { R_mpfr_GET_DVEC(i); } return; } #ifdef R_had_R_Outputfile_in_API #ifndef WIN32 /* This only works on "unix-alikes" ... but we don't really need it */ /* for R_Outputfile : */ #include SEXP print_mpfr1(SEXP x, SEXP digits) { mpfr_t r; Rboolean use_x_digits = INTEGER(digits)[0] == NA_INTEGER; mpfr_init2(r, R_mpfr_prec(x)); R_asMPFR(x, r); /* Rprintf(" * [dbg] after R_asMPFR() ..\n"); */ mpfr_out_str (R_Outputfile, 10, use_x_digits ? 0 : asInteger(digits), r, MPFR_RNDD); /* prints the value of s in base 10, rounded towards -Inf, where the third argument 0 means that the number of printed digits is automatically chosen from the precision of s; */ Rprintf("\n"); mpfr_clear (r); mpfr_free_cache(); /* <- Manual 4.8 "Memory Handling" strongly advises ...*/ return x; } SEXP print_mpfr(SEXP x, SEXP digits) { SEXP D = GET_SLOT(x, Rmpfr_Data_Sym);/* an R list() of length n */ int n = length(D), i; mpfr_t r; Rboolean use_x_digits = INTEGER(digits)[0] == NA_INTEGER; /* #if MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0) */ /* char buf[R_BUFSIZE], *p = buf; */ /* #endif */ mpfr_init(r); /* with default precision */ for(i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(D, i), r); /* #if MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0) */ /* Rprintf */ /* #else /\* requires R_Outputfile from R's Interfaces.h ___Unix-alike only__ *\/ */ mpfr_out_str (R_Outputfile, 10, use_x_digits ? 0 : asInteger(digits), r, MPFR_RNDD); /* #endif */ Rprintf("\n"); } mpfr_clear (r); mpfr_free_cache(); /* <- Manual 4.8 "Memory Handling" strongly advises ...*/ return x; } #endif /* ^^^ Unix-alike only */ #endif /* Convert R "mpfr" object (list of "mpfr1") to R "double" vector : */ SEXP mpfr2d(SEXP x, SEXP rnd_mode) { int n = length(x), i; SEXP val = PROTECT(allocVector(REALSXP, n)); double *r = REAL(val); mpfr_t R_i; mpfr_init(R_i); /* with default precision; set prec in R_asMPFR() */ for(i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(x, i), R_i); r[i] = mpfr_get_d(R_i, R_rnd2MP(rnd_mode)); } mpfr_clear (R_i); mpfr_free_cache(); UNPROTECT(1); return val; } /* Convert R "mpfr" object (list of "mpfr1") to R "integer" vector : */ SEXP mpfr2i(SEXP x, SEXP rnd_mode) { int n = length(x), i; SEXP val = PROTECT(allocVector(INTSXP, n)); int *r = INTEGER(val); mpfr_t R_i; mpfr_init(R_i); /* with default precision; set prec in R_asMPFR() */ for(i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(x, i), R_i); if(!mpfr_fits_sint_p(R_i, R_rnd2MP(rnd_mode))) { warning("NAs introduced by coercion from \"mpfr\" [%d]", i+1); r[i] = NA_INTEGER; } else { long lr = mpfr_get_si(R_i, R_rnd2MP(rnd_mode)); r[i] = (int) lr; } } mpfr_clear (R_i); mpfr_free_cache(); UNPROTECT(1); return val; } /* Get "format info" from R "mpfr" object -- into list with (exp, finite, is.0), * a subset of mpfr2str() [below] : ---> see also R_mpfr_exp() in ./utils.c * */ SEXP R_mpfr_formatinfo(SEXP x) { int n = length(x); static const char *ans_nms[] = {"exp", "finite", "is.0", ""}; SEXP val = PROTECT(mkNamed(VECSXP, ans_nms)), exp, fini, zero; int erange_is_int = mpfr_erange_int_p(); SEXPTYPE exp_SXP = (erange_is_int ? INTSXP : REALSXP); SET_VECTOR_ELT(val, 0, exp = PROTECT(allocVector(exp_SXP,n))); SET_VECTOR_ELT(val, 1, fini= PROTECT(allocVector(LGLSXP, n))); SET_VECTOR_ELT(val, 2, zero= PROTECT(allocVector(LGLSXP, n))); int *is_fin= LOGICAL(fini), *is_0 = LOGICAL(zero); mpfr_t R_i; mpfr_init(R_i); /* with default precision; set prec in R_asMPFR() */ if(erange_is_int) { int *exp_ = INTEGER(exp); #define FOR_I_N_ASSIGN(exp_typ) \ for(int i=0; i < n; i++) { \ R_asMPFR(VECTOR_ELT(x, i), R_i); \ exp_ [i] = (exp_typ) mpfr_get_exp(R_i); \ is_fin[i] = mpfr_number_p(R_i); \ is_0 [i] = mpfr_zero_p(R_i); \ } FOR_I_N_ASSIGN(int) } else {/* 'exp' needs to use "double" as it may not fit into integer, consistent with R_mpfr_get_erange(), or R_mpfr_prec_range() : */ double *exp_ = REAL(exp); FOR_I_N_ASSIGN(double) } mpfr_clear (R_i); mpfr_free_cache(); UNPROTECT(4); return val; } /* Convert R "mpfr" object (list of "mpfr1") to R "character" vector, * using 'digits' (or determinining it): * 1) digits = NULL , maybe_full = FALSE (<==> 'scientific = TRUE') * --------------- -------------~~~~~ ==> set digits <=> getPrec(x) * 2) digits = NULL , maybe_full = TRUE (<=> 'scientific' = NA or FALSE in the calling formatMpfr() * ------------- ----------------- ==> set digits <=> max(getPrec(x), #{"digits left of '.'"}) * 3) digits = , maybe_full = TRUE (<=> 'scientific' = TRUE in the calling formatMpfr() * ------------- -----------------==> set digits <=> max(digit, getPrec(x), #{"digits left of '.'"})) * * Rmpfr:::.mpfr_debug(1) ==> to add debug output here * * mpfr2str() is the workhorse for R level formatMpfr() , called from format() <- print() */ SEXP mpfr2str(SEXP x, SEXP digits, SEXP maybeFull, SEXP base) { int n = length(x), i; int B = asInteger(base); // = base for output int n_dig = isNull(digits) ? 0 : asInteger(digits); if(n_dig < 0) error("'digits' must be NULL or a positive integer"); Rboolean maybe_full = asLogical(maybeFull); if(maybe_full == NA_LOGICAL) // cannot happen when called "regularly" error("'maybe.full' must be TRUE or FALSE"); R_mpfr_dbg_printf(1,"mpfr2str(*, digits=%d, maybeF=%s, base=%d):\n", n_dig, (maybe_full ? "TRUE" : "False"), B); /* int dig_n_max = -1; */ /* SEXP val = PROTECT(allocVector(VECSXP, 4)), */ /* nms, str, exp, fini, zero; */ /* int *i_exp, *is_fin, *is_0; */ char *ch = NULL; /* N_digits == 1 , for base = 2, 4, 8, 16, 32 (base <= 62 !) gives bad abort from MPFR: get_str.c:2306: MPFR assertion failed: m >= 2 || ((((b) & ((b) - 1)) == 0) == 0 && m >= 1) ... Aborted ... (Speicherabzug geschrieben) the MPFR doc (see mpfr_get_str below) *says* N >= 2 is required, but we have used N = 1 for B = 10 a lot in the past ! */ Rboolean base_is_2_power = (B == 2 || B == 4 || B == 8 || B == 16 || B == 32); Rboolean n_dig_1_problem = (n_dig == 1) && base_is_2_power; int N_digits = n_dig_1_problem ? 2 : n_dig; static const char *ans_nms[] = {"str", "exp", "finite", "is.0", ""}; SEXP val = PROTECT(mkNamed(VECSXP, ans_nms)), str, exp, fini, zero; // NB: 'exp' may have to be 'double' instead of 'integer', when erange allows large exponents int erange_is_int = mpfr_erange_int_p(); SEXPTYPE exp_SXP = (erange_is_int ? INTSXP : REALSXP); SET_VECTOR_ELT(val, 0, str = PROTECT(allocVector(STRSXP, n))); SET_VECTOR_ELT(val, 1, exp = PROTECT(allocVector(exp_SXP,n))); SET_VECTOR_ELT(val, 2, fini= PROTECT(allocVector(LGLSXP, n))); SET_VECTOR_ELT(val, 3, zero= PROTECT(allocVector(LGLSXP, n))); // depending on erange_is_int, only need one of d_exp or i_exp (but don't see a more elegant way): double *d_exp; // = REAL(exp); int *i_exp, // = INTEGER(exp), *is_fin= LOGICAL(fini), *is_0 = LOGICAL(zero); double p_fact = (B == 2) ? 1. : log(B) / M_LN2;// <==> P / p_fact == P *log(2)/log(B) int max_nchar = -1; // := max_i { dig_needed[i] } mpfr_t R_i; mpfr_init(R_i); /* with default precision; set prec in R_asMPFR() */ if(erange_is_int) i_exp = INTEGER(exp); else d_exp = REAL(exp); for(i=0; i < n; i++) { mpfr_exp_t exp = (mpfr_exp_t) 0; mpfr_exp_t *exp_ptr = &exp; int nchar_i; Rboolean use_nchar = TRUE; R_asMPFR(VECTOR_ELT(x, i), R_i); int is0 = mpfr_zero_p(R_i); int isFin = mpfr_number_p(R_i); is_0 [i] = is0; is_fin[i] = isFin; if(N_digits) {/* use it as desired precision */ nchar_i = N_digits; R_mpfr_dbg_printf(1,"N_digits: [i=%d]: ... -> dig.n = %d ", i, nchar_i); } else if(!isFin) { nchar_i = 5; // @Inf@ @NaN@ } else if(is0) { nchar_i = 1 + base_is_2_power; } else { /* N_digits = 0 --> string must use "enough" digits */ // MPFR doc on mpfr_get_str(): use 'm + 1' where m = 1+ceil(P * log(2)/log(B)) double P = (double)R_i->_mpfr_prec; if(base_is_2_power) P--; // P := P-1 iff B is a power of 2 double m1 = 1 + ceil(P / p_fact) + 1; double dchar_i = maybe_full ? // want all digits before "." : fmax2(m1, ceil((double)mpfr_get_exp(R_i) / p_fact)) : m1; if(dchar_i > 536870912 /* = 2^29 */) // << somewhat arbitrary but < INT_MAX ~= 2^31-1 error(_(".mpfr2str(): too large 'dchar_i = %g'; please set 'digits = '"), dchar_i); nchar_i = (int) dchar_i; R_mpfr_dbg_printf(1," [i=%d]: prec=%ld, exp2=%ld -> (nchar_i,dig.n)=(%g,%d) ", i, R_i->_mpfr_prec, mpfr_get_exp(R_i), dchar_i, nchar_i); if(nchar_i <= 1 && base_is_2_power) { // have n_dig_problem: R_mpfr_dbg_printf_0(1," base_is_2_power & nchar_i=%d ==> fudge dig_n. := 2"); nchar_i = 2; } use_nchar = FALSE; } if (i == 0) { /* first time */ max_nchar = nchar_i; ch = (char *) R_alloc(imax2(max_nchar + 2, 7), // 7 : '-@Inf@' (+ \0)n_str, sizeof(char)); } else if(!N_digits && nchar_i > max_nchar) { // enlarge : ch = (char *) S_realloc(ch, imax2( nchar_i + 2, 7), imax2(max_nchar + 2, 7), sizeof(char)); max_nchar = nchar_i; } /* char* mpfr_get_str (char *STR, mpfr_exp_t *EXPPTR, int B, * size_t N, mpfr_t OP, mpfr_rnd_t RND) Convert OP to a string of digits in base B, with rounding in the direction RND, where N is either zero (see below) or the number of significant digits output in the string; in the latter case, N must be greater or equal to 2. The base may vary from 2 to 62; ......... ......... ==> MPFR info manual "5.4 Conversion Functions" */ R_mpfr_dbg_printf_0(1," .. max_nchar=%d\n", max_nchar); /* // use nchar_i notably when that is smaller than max_nchar : */ /* mpfr_get_str(ch, exp_ptr, B, (size_t) nchar_i, R_i, MPFR_RNDN); */ /* ---- alternatively, * N = 0 : MPFR finds the number of digits needed : */ mpfr_get_str(ch, exp_ptr, B, (size_t) (maybe_full || use_nchar) ? nchar_i : 0, //========== --- R_i, MPFR_RNDN); SET_STRING_ELT(str, i, mkChar(ch)); if(erange_is_int) i_exp [i] = (int) exp_ptr[0]; else d_exp [i] = (double) exp_ptr[0]; } mpfr_clear (R_i); mpfr_free_cache(); UNPROTECT(5); return val; } /* R ldexpMpfr(f, E) * * return "mpfr" x = f * 2^E where 'f' is "mpfr" and 'E' is "integer". * ------- * "Problem": here, the exponent is limited to +/- 2^31-1 ("ok" with default erange; * but the maximal erange is +- 2^61 which corresponds to *two* 32-bit integers */ SEXP R_mpfr_ldexp(SEXP f, SEXP E, SEXP rnd_mode) { /* NB: Allow *recycling* for (f, E) * -- using 'mismatch' and the MISMATCH macros */ mpfr_rnd_t rnd = R_rnd2MP(rnd_mode); int nprot = 0; if(!isInteger(E)) { PROTECT(E = coerceVector(E, INTSXP)); nprot++; } int *ee = INTEGER(E), nx = length(f), ny = length(E), // instead of 'nf, nE' for MISMATCH macros n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny), mismatch = 0; SEXP val = PROTECT(allocVector(VECSXP, n)); nprot++; mpfr_t x_i; mpfr_init(x_i); /* with default precision; set prec in R_asMPFR() */ SET_MISMATCH; for(int i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(f, i % nx), x_i); mpfr_mul_2si(x_i, x_i, (long) ee[i % ny], rnd); /* -- Function: int mpfr_mul_2si (mpfr_t ROP, mpfr_t OP1, long int OP2, mpfr_rnd_t RND) Set ROP to OP1 times 2 raised to OP2 rounded in the direction RND. Just increases the exponent by OP2 when ROP and OP1 are identical. */ SET_VECTOR_ELT(val, i, MPFR_as_R(x_i)); } MISMATCH_WARN; mpfr_clear (x_i); mpfr_free_cache(); UNPROTECT(nprot); return val; } #ifdef _not_yet_ /* For R functionality: from "mpfr" x, return list(z, E), * z = "bigz", E = "integer" (or integer-valued double) such that x = z * 2^E exactly */ SEXP R_mpfr_get_2exp(SEXP x) { /*-- Function: mpfr_exp_t mpfr_get_z_2exp (mpz_t ROP, mpfr_t OP) Put the scaled significand of OP (regarded as an integer, with the precision of OP) into ROP, and return the exponent EXP (which may be outside the current exponent range) such that OP exactly equals ROP times 2 raised to the power EXP. If OP is zero, the minimal exponent ‘emin’ is returned. If OP is NaN or an infinity, the _erange_ flag is set, ROP is set to 0, and the the minimal exponent ‘emin’ is returned. The returned exponent may be less than the minimal exponent ‘emin’ of MPFR numbers in the current exponent range; in case the exponent is not representable in the ‘mpfr_exp_t’ type, the _erange_ flag is set and the minimal value of the ‘mpfr_exp_t’ type is returned. */ // placeholder -- FIXME ! return R_Nilvalue; } #endif // _not_yet_ // R frexpMpfr(x) |-> list(r, e) SEXP R_mpfr_frexp(SEXP x, SEXP rnd_mode) { mpfr_rnd_t rnd = R_rnd2MP(rnd_mode); // NB: 'exp' may have to be 'double' instead of 'integer', when erange allows large exponents int erange_is_int = mpfr_erange_int_p(); SEXPTYPE exp_SXP = (erange_is_int ? INTSXP : REALSXP); int n = length(x); static const char *ans_nms[] = {"r", "e", ""}; SEXP ans = PROTECT(mkNamed(VECSXP, ans_nms)), r, e; // r: fractional parts; still "mpfr" numbers: SET_VECTOR_ELT(ans, 0, r = PROTECT(duplicate(x))); // e: 2-exponents (integer or double see aboe) SET_VECTOR_ELT(ans, 1, e = PROTECT(allocVector(exp_SXP, n))); int *ei_; double *ed_; if(erange_is_int) ei_ = INTEGER(e); else ed_ = REAL(e); mpfr_t x_i, y_i; mpfr_init(x_i); /* with default precision; set prec in R_asMPFR() */ mpfr_init(y_i); mpfr_exp_t Ex = (mpfr_exp_t)0; // create and initialize "valgrindably" // Rboolean int_ok = TRUE; for(int i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(x, i), x_i); mpfr_set_prec(y_i, mpfr_get_prec(x_i)); int ierr = mpfr_frexp(&Ex, y_i, x_i, rnd); /*-- Function: int mpfr_frexp (mpfr_exp_t *EXP, mpfr_t Y, mpfr_t X, mpfr_rnd_t RND) Set EXP (formally, the value pointed to by EXP) and Y such that 0.5<=abs(Y)<1 and Y times 2 raised to EXP equals X rounded to the precision of Y, using the given rounding mode. If X is zero, then Y is set to a zero of the same sign and EXP is set to 0. If X is NaN or an infinity, then Y is set to the same value and EXP is undefined. */ if(ierr) { #define MPFR_CLEAR mpfr_clear(x_i); mpfr_clear(y_i); mpfr_free_cache() MPFR_CLEAR; error("R_mpfr_frexp(): mpfr_frexp(x[%d]) gave error code %d\n", i+1, ierr); } if(erange_is_int) ei_[i] = (int) Ex; else ed_[i] = (double) Ex; SET_VECTOR_ELT(r, i, MPFR_as_R(y_i)); } MPFR_CLEAR; UNPROTECT(3); return ans; } // TODO : get *exact* as.bigq.mpfr(), i.e, "mpfr" --> "bigq". (R's "bigq" is C 'mpq') // ---- inside the GMP library, have // _________ // -- Function: void mpq_set_f (mpq_t ROP, const mpf_t OP) // ^^^^^^^^^ // Set ROP to the value of OP. // There is no rounding, this conversion is **exact**. /* ---not-yet--- #include */ /* maybe we only need very little of the above, such as #define mpf_t mpfr_t --------------------- ? */ Rmpfr/src/utils.c0000644000176200001440000005354714547502711013457 0ustar liggesusers/* * MPFR - Multiple Precision Floating-Point Reliable Library * ---- - - - - */ #include /* imax2() */ # include //-> void R_CheckUserInterrupt(void); #include "Rmpfr_utils.h" extern #include "Syms.h" //Dbg: #define DEBUG_Rmpfr #ifdef DEBUG_Rmpfr /* ONLY for debugging !! */ # ifndef WIN32 # include # endif # define R_PRT(_X_) mpfr_out_str (R_Outputfile, 10, 0, _X_, MPFR_RNDD) #endif // Currently not in the API (hence "should be" (?) 'static') : int my_mpfr_beta (mpfr_t ROP, mpfr_t X, mpfr_t Y, mpfr_rnd_t RND); int my_mpfr_lbeta(mpfr_t ROP, mpfr_t X, mpfr_t Y, mpfr_rnd_t RND); int my_mpfr_choose(mpfr_t ROP, long n, mpfr_t X, mpfr_rnd_t RND); int my_mpfr_poch (mpfr_t ROP, long n, mpfr_t X, mpfr_rnd_t RND); int my_mpfr_round (mpfr_t ROP, long prec, mpfr_t X, mpfr_rnd_t RND); /* argument order above must match the one of mpfr_jn() etc .. */ /* MM: for debugging, use gcc -I/u/maechler/R/D/r-patched/F19-64-inst/include -I/usr/local/include -fpic -g -O3 -pedantic -Wall --std=gnu99 -DDEBUG_Rmpfr -Wcast-align -Wclobbered -c utils.c -o utils.o */ /*------------------------------------------------------------------------*/ int my_mpfr_beta (mpfr_t R, mpfr_t a, mpfr_t b, mpfr_rnd_t RND) { mpfr_prec_t p_ab = max2_prec(mpfr_get_prec(a), mpfr_get_prec(b)); if(mpfr_get_prec(R) < p_ab) mpfr_prec_round(R, p_ab, RND);// so prec(R) = max( prec(a), prec(b) ) int ans; mpfr_t s; mpfr_init2(s, p_ab); #ifdef DEBUG_Rmpfr R_CheckUserInterrupt(); int cc = 0; #endif /* "FIXME": check each 'ans' below, and return when not ok ... */ ans = mpfr_add(s, a, b, RND); if(mpfr_integer_p(s) && mpfr_sgn(s) <= 0) { // (a + b) is integer <= 0 if(!mpfr_integer_p(a) && !mpfr_integer_p(b)) { // but a,b not integer ==> R = finite / +-Inf = 0 : mpfr_set_zero (R, +1); mpfr_clear (s); return ans; }// else: sum is integer; at least one {a,b} integer ==> both integer int sX = mpfr_sgn(a), sY = mpfr_sgn(b); if(sX * sY < 0) { // one negative, one positive integer // ==> special treatment here : if(sY < 0) // ==> sX > 0; swap the two mpfr_swap(a, b); // now have --- a < 0 < b <= |a| integer ------------------ /* ================ and in this case: B(a,b) = (-1)^b B(1-a-b, b) = (-1)^b B(1-s, b) = (1*2*..*b) / (-s-1)*(-s-2)*...*(-s-b) */ /* where in the 2nd form, both numerator and denominator have exactly * b integer factors. This is attractive {numerically & speed wise} * for 'small' b */ #define b_large 100 #ifdef DEBUG_Rmpfr Rprintf(" my_mpfr_beta(): s = a+b= "); R_PRT(s); Rprintf("\n a = "); R_PRT(a); Rprintf("\n b = "); R_PRT(b); Rprintf("\n"); if(cc++ > 999) { mpfr_set_zero (R, +1); mpfr_clear (s); return ans; } #endif unsigned long b_ = 0;// -Wall Rboolean b_fits_ulong = mpfr_fits_ulong_p(b, RND), small_b = b_fits_ulong && (b_ = mpfr_get_ui(b, RND)) < b_large; if(small_b) { #ifdef DEBUG_Rmpfr Rprintf(" b <= b_large = %d...\n", b_large); #endif //----------------- small b ------------------ // use GMP big integer arithmetic: mpz_t S; mpz_init(S); mpfr_get_z(S, s, RND); // S := s mpz_sub_ui (S, S, (unsigned long) 1); // S = s - 1 = (a+b-1) /* binomial coefficient choose(N, k) requires k a 'long int'; * here, b must fit into a long: */ mpz_bin_ui (S, S, b_); // S = choose(S, b) = choose(a+b-1, b) mpz_mul_ui (S, S, b_); // S = S*b = b * choose(a+b-1, b) // back to mpfr: R = 1 / S = 1 / (b * choose(a+b-1, b)) mpfr_set_ui(s, (unsigned long) 1, RND); mpfr_div_z(R, s, S, RND); mpz_clear(S); } else { // b is "large", use direct B(.,.) formula #ifdef DEBUG_Rmpfr Rprintf(" b > b_large = %d...\n", b_large); #endif // a := (-1)^b : // there is no mpfr_si_pow(a, -1, b, RND); int neg; // := 1 ("TRUE") if (-1)^b = -1, i.e. iff b is odd if(b_fits_ulong) { // (i.e. not very large) neg = (b_ % 2); // 1 iff b_ is odd, 0 otherwise } else { // really large b; as we know it is integer, can still.. // b2 := b / 2 mpfr_t b2; mpfr_init2(b2, p_ab); mpfr_div_2ui(b2, b, 1, RND); neg = !mpfr_integer_p(b2); // b is odd, if b/2 is *not* integer #ifdef DEBUG_Rmpfr Rprintf(" really large b; neg = ('b is odd') = %d\n", neg); #endif } // s' := 1-s = 1-a-b mpfr_ui_sub(s, 1, s, RND); #ifdef DEBUG_Rmpfr Rprintf(" neg = %d\n", neg); Rprintf(" s' = 1-a-b = "); R_PRT(s); Rprintf("\n -> calling B(s',b)\n"); #endif // R := B(1-a-b, b) = B(s', b) if(small_b) { my_mpfr_beta (R, s, b, RND); } else { my_mpfr_lbeta (R, s, b, RND); mpfr_exp(R, R, RND); // correct *if* beta() >= 0 } #ifdef DEBUG_Rmpfr Rprintf(" R' = beta(s',b) = "); R_PRT(R); Rprintf("\n"); #endif // Result = (-1)^b B(1-a-b, b) = +/- s' if(neg) mpfr_neg(R, R, RND); } mpfr_clear(s); return ans; } } ans = mpfr_gamma(s, s, RND); /* s = gamma(a + b) */ #ifdef DEBUG_Rmpfr Rprintf("my_mpfr_beta(): s = gamma(a+b)= "); R_PRT(s); Rprintf("\n a = "); R_PRT(a); Rprintf("\n b = "); R_PRT(b); #endif ans = mpfr_gamma(a, a, RND); ans = mpfr_gamma(b, b, RND); ans = mpfr_mul(b, b, a, RND); /* b' = gamma(a) * gamma(b) */ #ifdef DEBUG_Rmpfr Rprintf("\n G(a) * G(b) = "); R_PRT(b); Rprintf("\n"); #endif ans = mpfr_div(R, b, s, RND); mpfr_clear (s); /* mpfr_free_cache() must be called in the caller !*/ return ans; } int my_mpfr_lbeta(mpfr_t R, mpfr_t a, mpfr_t b, mpfr_rnd_t RND) { mpfr_prec_t p_ab = max2_prec(mpfr_get_prec(a), mpfr_get_prec(b)); if(mpfr_get_prec(R) < p_ab) mpfr_prec_round(R, p_ab, RND);// so prec(R) = max( prec(a), prec(b) ) mpfr_t s; mpfr_init2(s, p_ab); /* "FIXME": check each 'ans' below, and return when not ok ... */ int ans = mpfr_add(s, a, b, RND); if(mpfr_integer_p(s) && mpfr_sgn(s) <= 0) { // (a + b) is integer <= 0 if(!mpfr_integer_p(a) && !mpfr_integer_p(b)) { // but a,b not integer ==> R = ln(finite / +-Inf) = ln(0) = -Inf : mpfr_set_inf (R, -1); mpfr_clear (s); return ans; }// else: sum is integer; at least one integer ==> both integer int sX = mpfr_sgn(a), sY = mpfr_sgn(b); if(sX * sY < 0) { // one negative, one positive integer // ==> special treatment here : if(sY < 0) // ==> sX > 0; swap the two mpfr_swap(a, b); /* now have --- a < 0 < b <= |a| integer ------------------ * ================ * --> see my_mpfr_beta() above */ unsigned long b_ = 0;// -Wall Rboolean b_fits_ulong = mpfr_fits_ulong_p(b, RND), small_b = b_fits_ulong && (b_ = mpfr_get_ui(b, RND)) < b_large; if(small_b) { //----------------- small b ------------------ // use GMP big integer arithmetic: mpz_t S; mpz_init(S); mpfr_get_z(S, s, RND); // S := s mpz_sub_ui (S, S, (unsigned long) 1); // S = s - 1 = (a+b-1) /* binomial coefficient choose(N, k) requires k a 'long int'; * here, b must fit into a long: */ mpz_bin_ui (S, S, b_); // S = choose(S, b) = choose(a+b-1, b) mpz_mul_ui (S, S, b_); // S = S*b = b * choose(a+b-1, b) // back to mpfr: R = log(|1 / S|) = - log(|S|) mpz_abs(S, S); mpfr_set_z(s, S, RND); // s := |S| mpfr_log(R, s, RND); // R := log(s) = log(|S|) mpfr_neg(R, R, RND); // R = -R = -log(|S|) mpz_clear(S); } else { // b is "large", use direct B(.,.) formula // a := (-1)^b -- not needed here, neither 'neg': want log( |.| ) // s' := 1-s = 1-a-b mpfr_ui_sub(s, 1, s, RND); // R := log(|B(1-a-b, b)|) = log(|B(s', b)|) my_mpfr_lbeta (R, s, b, RND); } mpfr_clear(s); return ans; } } ans = mpfr_lngamma(s, s, RND); // s = lngamma(a + b) ans = mpfr_lngamma(a, a, RND); ans = mpfr_lngamma(b, b, RND); ans = mpfr_add (b, b, a, RND); // b' = lngamma(a) + lngamma(b) ans = mpfr_sub (R, b, s, RND); mpfr_clear (s); return ans; } /** Binomial Coefficient -- * all initialization and cleanup is called in the caller * @result R = choose(X, n) */ int my_mpfr_choose (mpfr_t R, long n, mpfr_t X, mpfr_rnd_t RND) { mpfr_prec_t p_X = mpfr_get_prec(X); mpfr_t r, x; mpfr_init2(x, p_X); mpfr_set(x, X, RND); mpfr_init2(r, p_X); if(mpfr_integer_p(X) && n > 0 && mpfr_cmp_si(X, n) >= 0 && mpfr_cmp_si(X, 2*n) < 0) { // integer X, 0 <= X-n < n ; /* ==> choose(X,n) == choose(X, X-n) ; X-n is smaller => faster: do n <--> X-n */ mpfr_sub_si(r, X, n, RND); /* r = X-n */ n = mpfr_get_si(r, RND); } if(n > 0) { mpfr_set(r, X, RND); for(long i=1; i < n; ) { if(!(i % 100000)) R_CheckUserInterrupt(); // for *large* n mpfr_sub_si(x, x, 1L, RND); // x = X - i mpfr_mul (r, r, x, RND); // r := r * x = X(X-1)..(X-i) mpfr_div_si(r, r, ++i, RND); // r := r / (i+1) = X(X-1)..(X-i) / (1*2..*(i+1)) #ifdef DEBUG_Rmpfr Rprintf("my_mpfr_choose(): X (= X_0 - %d)= ", i); R_PRT(x); Rprintf("\n --> r ="); R_PRT(r); Rprintf("\n"); #endif } } else if(n < 0) // ==> result 0 as for R's choose() mpfr_set_zero(r, +1); else // n = 0 mpfr_set_si(r, (long) 1, RND); int ans = mpfr_set(R, r, RND); mpfr_clear (x); mpfr_clear (r); return ans; } /** Pochhammer Symbol -- *rising* factorial x * (x+1) * ... (x+n-1) * all initialization and cleanup is called in the caller */ int my_mpfr_poch (mpfr_t R, long n, mpfr_t X, mpfr_rnd_t RND) { int ans; long i; mpfr_t r, x; mpfr_prec_t p_X = mpfr_get_prec(X); mpfr_init2(x, p_X); mpfr_set(x, X, RND); mpfr_init2(r, p_X); if(n > 0) { mpfr_set(r, X, RND); for(i=1; i < n; i++) { mpfr_add_si(x, x, 1L, RND); // x = X + i mpfr_mul(r, r, x, RND); // r := r * x = X(X+1)..(X+i) #ifdef DEBUG_Rmpfr Rprintf("my_mpfr_poch(): X (= X_0 + %d)= ", i); R_PRT(x); Rprintf("\n --> r ="); R_PRT(r); Rprintf("\n"); #endif } } else // n = 0 mpfr_set_si(r, (long) 1, RND); ans = mpfr_set(R, r, RND); mpfr_clear (x); mpfr_clear (r); return ans; } /** round to (binary) bits, not (decimal) digits */ int my_mpfr_round (mpfr_t R, long prec, mpfr_t X, mpfr_rnd_t RND) { int ans; if(prec < MPFR_PREC_MIN) error("prec = %ld < %ld is too small", prec, (long)MPFR_PREC_MIN); if(prec > MPFR_PREC_MAX) error("prec = %ld > %ld is too large", prec, (long)MPFR_PREC_MAX); mpfr_set(R, X, RND); ans = mpfr_prec_round(R, (mpfr_prec_t) prec, RND); return ans; } /*------------------------------------------------------------------------*/ SEXP R_mpfr_get_version(void) { return mkString(mpfr_get_version()); } SEXP R_mpfr_get_GMP_numb_bits(void) {// for diagnosing return ScalarInteger((int)GMP_NUMB_BITS); } /* Set or get the C-global debugging level -- * currently only used in R_mpfr_dbg_printf() --> ./Rmpfr_utils.h * * Called from R .mpfr_debug(i = NA) */ SEXP R_mpfr_set_debug(SEXP I) { if(LENGTH(I) < 1 || INTEGER(I)[0] == NA_INTEGER) return ScalarInteger(R_mpfr_debug_); /* else : */ int prev = R_mpfr_debug_; R_mpfr_debug_ = asInteger(I); return ScalarInteger(prev); } SEXP R_mpfr_get_default_prec(void) { return ScalarInteger((int) mpfr_get_default_prec()); } SEXP R_mpfr_set_default_prec(SEXP prec) { // return the previous value int prev = (int) mpfr_get_default_prec(); mpfr_set_default_prec((mpfr_prec_t) asInteger(prec)); return ScalarInteger(prev); } // is MPFR's exponent range 'erange' representable as R's (32 bit) integer [INT_MIN not allowed] : int mpfr_erange_int_p(void) { mpfr_exp_t r = mpfr_get_emin(); int i_ok = (INT_MIN < r && r <= INT_MAX); if(i_ok) { r = mpfr_get_emax(); i_ok = (INT_MIN < r && r <= INT_MAX); } return i_ok; } /** R's .mpfr_erange_is_int() - workhorse */ SEXP R_mpfr_erange_int_p(void) { return ScalarLogical(mpfr_erange_int_p()); } /* MUST be sync'ed with ../R/mpfr.R * ~~~~~~~~~~~ and its .mpfr_erange_kinds */ typedef enum { E_min = 1, E_max, min_emin, max_emin, min_emax, max_emax } erange_kind; // Called from R's .mpfr.erange(), now allows 'kind' to be a vector SEXP R_mpfr_get_erange(SEXP kind_) { int k = LENGTH(kind_), nprot = 0; erange_kind *kind; if(TYPEOF(kind_) != INTSXP) { SEXP kk = PROTECT(coerceVector(kind_, INTSXP)); nprot++; kind = (erange_kind *) INTEGER(kk); } else { kind = (erange_kind *) INTEGER(kind_); } mpfr_exp_t *r = (mpfr_exp_t *) R_alloc(k, sizeof(mpfr_exp_t)); Rboolean int_ok = TRUE; for(int j = 0; j < k; j++) { switch(kind[j]) { // keep the 'case' list in sync with 'erange_kind' enum above: case E_min: r[j] = mpfr_get_emin(); if(int_ok && (r[j] <= INT_MIN || r[j] > INT_MAX)) int_ok=FALSE; break; case E_max: r[j] = mpfr_get_emax(); if(int_ok && (r[j] <= INT_MIN || r[j] > INT_MAX)) int_ok=FALSE; break; case min_emin: r[j] = mpfr_get_emin_min(); if(int_ok) int_ok=FALSE; break; case max_emin: r[j] = mpfr_get_emin_max(); if(int_ok) int_ok=FALSE; break; case min_emax: r[j] = mpfr_get_emax_min(); if(int_ok) int_ok=FALSE; break; case max_emax: r[j] = mpfr_get_emax_max(); if(int_ok) int_ok=FALSE; break; default: error("invalid kind[j(=%d)] (code = %ld) in R_mpfr_get_erange()", j, (long)kind[j]); } R_mpfr_dbg_printf(1,"R_mpfr_get_erange(%ld): %ld\n", (long)kind[j], (long)r[j]); } SEXP ans; // int_ok: only now know if we can return integer or need double if(int_ok) { int* R = INTEGER(ans = allocVector(INTSXP, k)); for(int j = 0; j < k; j++) R[j] = (int) r[j]; } else { double* R = REAL(ans = allocVector(REALSXP, k)); for(int j = 0; j < k; j++) R[j] = (double) r[j]; } if(nprot) UNPROTECT(nprot); return ans; } // R's .mpfr_erange_set() -- here, set *one* of Emin and Emax: SEXP R_mpfr_set_erange(SEXP kind_, SEXP val) { erange_kind kind = asInteger(kind_); mpfr_exp_t exp_val; if(isInteger(val)) exp_val = asInteger(val);// assume this is always valid to set else { // we allow larger values from the R side PROTECT(val = coerceVector(val, REALSXP)); exp_val = (mpfr_exp_t) asReal(val); UNPROTECT(1); } int i_err; switch(kind) { case E_min: i_err = mpfr_set_emin(exp_val); break; case E_max: i_err = mpfr_set_emax(exp_val); break; default: error("invalid kind (code = %d) in R_mpfr_set_erange()", kind); } if(i_err) warning("e%s exponent could not be set to %ld (code %d)", (kind == E_min) ? "min" : "max", (long)exp_val, i_err); return ScalarInteger(i_err); } SEXP R_mpfr_prec_range(SEXP ind) { long r = (long) ( (INTEGER(ind)[0] == 1) ? MPFR_PREC_MIN : MPFR_PREC_MAX); R_mpfr_dbg_printf(1,"R_mpfr_prec_range(): %ld\n", r); // in 64 bit, int << long, so go "2nd best": return ScalarReal((double)r); } /** Get the 'base 2 exp slot' -- also in extended erange where it does not fit into integer * Directly called from R's .mpfr2exp(x) */ SEXP R_mpfr_2exp(SEXP x) { int n = length(x); mpfr_t R_i; mpfr_init(R_i); SEXP val; if(mpfr_erange_int_p()) { // integer is ok: 'exp' values won't be too large val = PROTECT(allocVector(INTSXP,n)); int *exp = INTEGER(val); for(int i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(x, i), R_i); exp[i] = (int) mpfr_get_exp(R_i); } } else { val = PROTECT(allocVector(REALSXP,n)); double *exp = REAL(val); for(int i=0; i < n; i++) { R_asMPFR(VECTOR_ELT(x, i), R_i); exp[i] = (double) mpfr_get_exp(R_i); } } mpfr_clear(R_i); mpfr_free_cache(); UNPROTECT(1); return val; } //---------------------------------------------------------------------------- #define INIT_1_SETUP(_X_, _R_) \ mpfr_t _R_; \ \ mpfr_init2(_R_, R_mpfr_prec(_X_)); \ R_asMPFR(_X_, _R_) #define FINISH_1_RETURN(_R_, val) \ val = PROTECT(MPFR_as_R(_R_)); \ mpfr_clear (_R_); \ mpfr_free_cache(); \ UNPROTECT(1); \ return val SEXP const_asMpfr(SEXP I, SEXP prec, SEXP rnd_mode) { SEXP val; mpfr_t r; int i_p = asInteger(prec); R_mpfr_check_prec(i_p); mpfr_init2(r, i_p); switch(asInteger(I)) { case 1: mpfr_const_pi (r, R_rnd2MP(rnd_mode)); break; case 2: mpfr_const_euler (r, R_rnd2MP(rnd_mode)); break; case 3: mpfr_const_catalan(r, R_rnd2MP(rnd_mode)); break; case 4: mpfr_const_log2 (r, R_rnd2MP(rnd_mode)); break; default: error("invalid integer code {const_asMpfr()}"); /* -Wall */ } FINISH_1_RETURN(r, val); } /** For functions <- FUN(x = ) : */ #define R_MPFR_Logic_Function(_FNAME, _MPFR_NAME) \ SEXP _FNAME(SEXP x) { \ SEXP D = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym));/* R list() */ \ int n = length(D), i; \ SEXP val = PROTECT(allocVector(LGLSXP, n)); \ int *r = LOGICAL(val); \ mpfr_t r_i; \ mpfr_init(r_i); \ \ for(i=0; i < n; i++) { \ R_asMPFR(VECTOR_ELT(D, i), r_i); \ r[i] = _MPFR_NAME (r_i); \ } \ \ mpfr_clear (r_i); \ mpfr_free_cache(); \ UNPROTECT(2); \ return val; \ } R_MPFR_Logic_Function(R_mpfr_is_finite, mpfr_number_p) R_MPFR_Logic_Function(R_mpfr_is_infinite, mpfr_inf_p) R_MPFR_Logic_Function(R_mpfr_is_integer, mpfr_integer_p) // is.whole.mpfr() or .mpfr.is.whole(x) R_MPFR_Logic_Function(R_mpfr_is_na, mpfr_nan_p) R_MPFR_Logic_Function(R_mpfr_is_zero, mpfr_zero_p) // mpfrIs0() #define R_MPFRarray_Logic_Function(_FNAME, _MPFR_NAME) \ SEXP _FNAME(SEXP x) { \ SEXP D = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)),/* R list() */ \ dim = PROTECT(GET_SLOT(x, Rmpfr_Dim_Sym)), \ dn = PROTECT(GET_SLOT(x, Rmpfr_Dimnames_Sym)); \ int n = length(D), i; \ SEXP val = PROTECT(allocVector(LGLSXP, n)); \ int *r = LOGICAL(val); \ mpfr_t r_i; \ mpfr_init(r_i); \ \ for(i=0; i < n; i++) { \ R_asMPFR(VECTOR_ELT(D, i), r_i); \ r[i] = _MPFR_NAME (r_i); \ } \ \ mpfr_clear (r_i); \ mpfr_free_cache(); \ setAttrib(val, R_DimSymbol, duplicate(dim)); \ setAttrib(val, R_DimNamesSymbol, duplicate(dn)); \ UNPROTECT(4); \ return val; \ } R_MPFRarray_Logic_Function(R_mpfr_is_finite_A, mpfr_number_p) R_MPFRarray_Logic_Function(R_mpfr_is_infinite_A, mpfr_inf_p) R_MPFRarray_Logic_Function(R_mpfr_is_integer_A, mpfr_integer_p) // is.whole() .. R_MPFRarray_Logic_Function(R_mpfr_is_na_A, mpfr_nan_p) R_MPFRarray_Logic_Function(R_mpfr_is_zero_A, mpfr_zero_p) // mpfrIs0() SEXP R_mpfr_fac (SEXP n_, SEXP prec, SEXP rnd_mode) { int n = length(n_), i, *nn; SEXP n_t, val = PROTECT(allocVector(VECSXP, n)); int nprot = 1; mpfr_rnd_t rnd = R_rnd2MP(rnd_mode); mpfr_t r_i; if(TYPEOF(n_) != INTSXP) { PROTECT(n_t = coerceVector(n_, INTSXP)); nprot++;/* or bail out*/ nn = INTEGER(n_t); } else { nn = INTEGER(n_); } int i_p = asInteger(prec); R_mpfr_check_prec(i_p); mpfr_init2(r_i, i_p); for(i=0; i < n; i++) { // never happens when called from R: if(nn[i] < 0) error("R_mpfr_fac(%d): negative n.", nn[i]); mpfr_fac_ui(r_i, nn[i], rnd); SET_VECTOR_ELT(val, i, MPFR_as_R(r_i)); } mpfr_clear(r_i); mpfr_free_cache(); UNPROTECT(nprot); return val; } /** For functions FUN(x = , y = ) : */ #define R_MPFR_2_Numeric_Function(_FNAME, _MPFR_NAME) \ SEXP _FNAME(SEXP x, SEXP y, SEXP rnd_mode) { \ SEXP xD = PROTECT(GET_SLOT(x, Rmpfr_Data_Sym)); \ SEXP yD = PROTECT(GET_SLOT(y, Rmpfr_Data_Sym)); \ mpfr_rnd_t rnd = R_rnd2MP(rnd_mode); \ int nx = length(xD), ny = length(yD), i, \ n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny); \ SEXP val = PROTECT(allocVector(VECSXP, n)); \ mpfr_t R, x_i, y_i; \ mpfr_init(R); /* with default precision */ \ mpfr_init(x_i); mpfr_init(y_i); \ \ for(i=0; i < n; i++) { \ R_asMPFR(VECTOR_ELT(xD, i % nx), x_i); \ R_asMPFR(VECTOR_ELT(yD, i % ny), y_i); \ mpfr_set_prec(R, max2_prec(mpfr_get_prec(x_i), \ mpfr_get_prec(y_i))); \ _MPFR_NAME(R, x_i, y_i, rnd); \ SET_VECTOR_ELT(val, i, MPFR_as_R(R)); \ } \ \ mpfr_clear(R); mpfr_clear(x_i); mpfr_clear(y_i); \ mpfr_free_cache(); \ UNPROTECT(3); \ return val; \ } R_MPFR_2_Numeric_Function(R_mpfr_atan2, mpfr_atan2) R_MPFR_2_Numeric_Function(R_mpfr_hypot, mpfr_hypot) #if (MPFR_VERSION >= MPFR_VERSION_NUM(3,2,0)) R_MPFR_2_Numeric_Function(R_mpfr_igamma, mpfr_gamma_inc) #else SEXP R_mpfr_igamma(SEXP x, SEXP y, SEXP rnd_mode) { error("mpfr_gamma_inc requires mpfr >= 3.2.0"); return R_NilValue; } #endif R_MPFR_2_Numeric_Function(R_mpfr_beta, my_mpfr_beta) R_MPFR_2_Numeric_Function(R_mpfr_lbeta, my_mpfr_lbeta) /** For functions FUN(x = , y = ) : */ #define R_MPFR_2_Num_Long_Function(_FNAME, _MPFR_NAME) \ SEXP _FNAME(SEXP x, SEXP y, SEXP rnd_mode) { \ SEXP xD, yt, val; \ mpfr_rnd_t rnd = R_rnd2MP(rnd_mode); \ int *yy, n, nx, ny = length(y), i, nprot = 0; \ mpfr_t x_i; \ \ if(TYPEOF(y) != INTSXP) { \ PROTECT(yt = coerceVector(y, INTSXP)); nprot++;/* or bail out*/ \ yy = INTEGER(yt); \ } else { \ yy = INTEGER(y); \ } \ PROTECT(xD = GET_SLOT(x, Rmpfr_Data_Sym)); nprot++; \ nx = length(xD); \ n = (nx == 0 || ny == 0) ? 0 : imax2(nx, ny); \ PROTECT(val = allocVector(VECSXP, n)); nprot++; \ mpfr_init(x_i); /* with default precision; set prec in R_asMPFR() */\ \ for(i=0; i < n; i++) { \ R_asMPFR(VECTOR_ELT(xD, i % nx), x_i); \ _MPFR_NAME(x_i, (long) yy[i % ny], x_i, rnd); \ SET_VECTOR_ELT(val, i, MPFR_as_R(x_i)); \ } \ \ mpfr_clear (x_i); \ mpfr_free_cache(); \ UNPROTECT(nprot); \ return val; \ } R_MPFR_2_Num_Long_Function(R_mpfr_jn, mpfr_jn) R_MPFR_2_Num_Long_Function(R_mpfr_yn, mpfr_yn) R_MPFR_2_Num_Long_Function(R_mpfr_choose, my_mpfr_choose) R_MPFR_2_Num_Long_Function(R_mpfr_poch, my_mpfr_poch) R_MPFR_2_Num_Long_Function(R_mpfr_round, my_mpfr_round) Rmpfr/src/Makevars.win0000644000176200001440000000060111253364553014423 0ustar liggesusers# -*- Makefile -*- # Link with GMP (GNU Multiple Precision) # and with MPFR (Multiple Precision Floating point Reliable) Libraries # # lines below suggested by Uwe Ligges PKG_CPPFLAGS=-I$(LIB_MPFR)/include PKG_LIBS=-L$(LIB_MPFR)/lib -lmpfr -lgmp ## or rather ? # PKG_CPPFLAGS=-I$(LIB_MPFR)/include -I$(LIB_GMP)/include # PKG_LIBS=-L$(LIB_MPFR)/lib -lmpfr -L$(LIB_GMP)/lib -lgmp Rmpfr/src/Summary.c0000644000176200001440000002020114457744436013745 0ustar liggesusers/* * MPFR - Multiple Precision Floating-Point Reliable Library * ---- - - - - * * Arithmetic, Math, etc */ #include #include "Rmpfr_utils.h" extern #include "Syms.h" /*------------------------------------------------------------------------*/ SEXP Summary_mpfr(SEXP x, SEXP na_rm, SEXP op) { enum { MAX = 1, MIN, RANGE, PROD, SUM, ANY = 10, ALL } i_op = asInteger(op); /* MUST be sync'ed with ../R/Summary.R * ~~~~~~~~~~~~~~ where .Summary.codes <- * c("max" = 1, "min" = 2, "range" = 3, "prod" = 4, "sum" = 5, * "any" = 10, "all" = 11) */ mpfr_prec_t current_prec = mpfr_get_default_prec(); int n = length(x), return_list = (i_op < ANY), // return "mpfr1" list; any() | all() return logical remove_na = asLogical(na_rm); SEXP val = R_NilValue; int ans = -1; /*"-Wall"; result only for any() | all() */ mpfr_t R_i, Summ, Sum2; /* for range(), max(), min(), sum(), prod() */ mpfr_init(R_i); /* with default precision; set prec in R_asMPFR() */ if (return_list) mpfr_init(Summ); #define Rmpfr_set(_N_) val = PROTECT(allocVector(VECSXP, _N_)); break switch(i_op) { case MAX: mpfr_set_inf(Summ, -1);/* := -Inf */; Rmpfr_set(1); case MIN: mpfr_set_inf(Summ, +1);/* := +Inf */; Rmpfr_set(1); case RANGE: mpfr_init(Sum2); mpfr_set_inf(Summ, +1);/* := +Inf for min() */ mpfr_set_inf(Sum2, -1);/* := -Inf for max() */ Rmpfr_set(2); case PROD: mpfr_set_d (Summ, 1., MPFR_RNDZ); Rmpfr_set(1); case SUM: mpfr_set_d (Summ, 0., MPFR_RNDZ); Rmpfr_set(1); case ANY: ans = FALSE; break; case ALL: ans = TRUE; break; default: error("invalid op code (%d) in Summary_mpfr", i_op); } Rboolean Fini = FALSE; for(int i=0; i < n && !Fini; i++) { SEXP xi = VECTOR_ELT(x, i); R_asMPFR(xi, R_i); if(mpfr_nan_p(R_i)) { /* handling does not depend on i_op */ /* REprintf("Summary_mpfr(), i=%d : R_i is NA/NaN\n", i); */ if(remove_na) /* skip this NA / NAN entry: */ continue; else { /* result is NA */ /* should not be needed: R_i *is* NaN already : mpfr_set_nan(R_i); */ switch(i_op) { case MAX: case MIN: case PROD: case SUM: SET_VECTOR_ELT(val, 0, xi); break; case RANGE: SET_VECTOR_ELT(val, 0, xi); SET_VECTOR_ELT(val, 1, xi); break; /*---------------------------------------------*/ case ANY: if(ans == FALSE) ans = NA_LOGICAL; break; case ALL: if(ans == TRUE) ans = NA_LOGICAL; break; } } if(return_list) { /* return() *unless* for any()/all() : */ mpfr_free_cache(); UNPROTECT(1); return val; } else continue; /* next i; */ } if(return_list) { /* hence using Summ */ mpfr_prec_t i_prec = mpfr_get_prec(R_i); if(current_prec < i_prec) /* increase precision */ { current_prec = i_prec; mpfr_prec_round(Summ, i_prec, MPFR_RNDN); if(i_op == RANGE) mpfr_prec_round(Sum2, i_prec, MPFR_RNDN); } } switch(i_op) { /* Note we assign use R_i as "input and output" ==> *same* precision, even though in some cases the result may need higher precision */ case MAX: mpfr_max(Summ, Summ, R_i, MPFR_RNDN); break; case MIN: mpfr_min(Summ, Summ, R_i, MPFR_RNDN); break; case RANGE: mpfr_min(Summ, Summ, R_i, MPFR_RNDN); mpfr_max(Sum2, Sum2, R_i, MPFR_RNDN); break; case PROD: mpfr_mul(Summ, Summ, R_i, MPFR_RNDN); break; case SUM: mpfr_add(Summ, Summ, R_i, MPFR_RNDN); break; case ANY: if(!mpfr_zero_p(R_i)) { ans = TRUE ; Fini=TRUE; }; break; case ALL: if( mpfr_zero_p(R_i)) { ans = FALSE; Fini=TRUE; }; break; } } /* for(i .. n) */ #if 0 if(!return_list) /* any() or all() */ REprintf("Summary_mpfr(), at end: ans = %s\n", ans == NA_LOGICAL ? "NA" : (ans ? "TRUE" : "FALSE")); #endif mpfr_clear (R_i); switch(i_op) { case MAX: case MIN: case PROD: case SUM: SET_VECTOR_ELT(val, 0, MPFR_as_R(Summ)); mpfr_clear (Summ); break; case RANGE: SET_VECTOR_ELT(val, 0, MPFR_as_R(Summ)); SET_VECTOR_ELT(val, 1, MPFR_as_R(Sum2)); mpfr_clear (Summ); mpfr_clear (Sum2); break; case ANY: case ALL: /* nothing to be done */ break; } mpfr_free_cache(); if(!return_list) /* any() or all() */ return ScalarLogical(ans); // else UNPROTECT(1); return val; } /* Summary_mpfr() */ /** Compute sum(x * y) == x %*% y for two [mpfr-]vectors of the same length Both x and y can be in {mpfr, double, integer} ! */ SEXP R_mpfr_sumprod(SEXP x, SEXP y, SEXP minPrec, SEXP alternating_) { int n = length(x); if(length(y) != n) error("%d == length(x) != length(y) == %d", n, length(y)); int i_min_prec = asInteger(minPrec), nprot = 1; Rboolean alternating = asLogical(alternating_); // Simplification (FIXME: more efficient -> use 6 cases; s/ M_n / M_d and M_i /) if(isInteger(x)) { PROTECT(x = coerceVector(x, REALSXP)); nprot++; } if(isInteger(y)) { PROTECT(y = coerceVector(y, REALSXP)); nprot++; } if(isReal(x) && isReal(y)) error("R_mpfr_sumprod(x,y, .): either x or y must be \"mpfr\", but both are numeric"); // --> three cases: // M_M: both mpfr, // n_M: x numeric, y mpfr // M_n: x mpfr , y numeric enum { M_M, n_M, M_n } R_case = isReal(x) ? n_M : isReal(y) ? M_n : M_M; Rboolean use_r = alternating && R_case == M_M; mpfr_t Summ, x_i, y_i, r; mpfr_inits(Summ, x_i, y_i, (mpfr_ptr) 0); /* with default precision */ mpfr_set_d(Summ, 0., MPFR_RNDZ); double *xx = NULL, *yy = NULL; if(R_case == n_M) xx = REAL(x); else if(R_case == M_n) yy = REAL(y); mpfr_prec_t min_prec = MPFR_PREC_MIN, xy_prec, S_prec = mpfr_get_prec(Summ); if(i_min_prec != NA_INTEGER && min_prec < i_min_prec) min_prec = (mpfr_prec_t) i_min_prec; if(S_prec < min_prec) { mpfr_prec_round (Summ, min_prec, MPFR_RNDN); S_prec = min_prec; } if(use_r) mpfr_init2(r, S_prec); for(int i=0; i < n; i++) { double xi = 0., yi = 0.; // Wall #define IF_NA_set_and_continue(_NA_COND_) \ if(_NA_COND_) { \ mpfr_set_nan(Summ); \ continue;/* -> "next i" */ \ } switch(R_case) { case M_M : R_asMPFR(VECTOR_ELT(x, i), x_i); R_asMPFR(VECTOR_ELT(y, i), y_i); IF_NA_set_and_continue(mpfr_nan_p(x_i) || mpfr_nan_p(y_i)); xy_prec = max2_prec(mpfr_get_prec(x_i), mpfr_get_prec(y_i)); break; case M_n : R_asMPFR(VECTOR_ELT(x, i), x_i); yi = yy[i]; IF_NA_set_and_continue(mpfr_nan_p(x_i) || ISNA(yi)); xy_prec = max2_prec(mpfr_get_prec(x_i), 53); break; case n_M : xi = xx[i]; R_asMPFR(VECTOR_ELT(y, i), y_i); IF_NA_set_and_continue(ISNA(xi) || mpfr_nan_p(y_i)); xy_prec = max2_prec(53, mpfr_get_prec(y_i)); break; } // switch() if(S_prec < xy_prec) {/* increase it, since it will store the result */ mpfr_prec_round (Summ, xy_prec, MPFR_RNDN); S_prec = xy_prec; if(use_r) mpfr_set_prec(r, S_prec); } if(alternating && (i % 2)) { // Summ := Summ - (x_i * y_i) switch(R_case) { case M_M : /* mpfr_fms (ROP, OP1, OP2, OP3, RND) * Set ROP to (OP1 times OP2) - OP3 rounded in the direction RND. */ mpfr_fms (r, x_i, y_i, Summ, MPFR_RNDN); // r = x_i * y_i - Summ mpfr_neg (Summ, r, MPFR_RNDN); break; case M_n : mpfr_mul_d(x_i, x_i, yi, MPFR_RNDN); mpfr_sub(Summ, Summ, x_i,MPFR_RNDN); break; case n_M : mpfr_mul_d(y_i, y_i, xi, MPFR_RNDN); mpfr_sub(Summ, Summ, y_i,MPFR_RNDN); break; } } else { // Summ := Summ + (x_i * y_i) switch(R_case) { case M_M : /* mpfr_fma (ROP, OP1, OP2, OP3, RND) * Set ROP to (OP1 times OP2) + OP3 rounded in the direction RND. */ mpfr_fma (Summ, x_i, y_i, Summ, MPFR_RNDN); break; case M_n : mpfr_mul_d(x_i, x_i, yi, MPFR_RNDN); mpfr_add(Summ, Summ, x_i,MPFR_RNDN); break; case n_M : mpfr_mul_d(y_i, y_i, xi, MPFR_RNDN); mpfr_add(Summ, Summ, y_i,MPFR_RNDN); break; } } } // for( i ) // val <- list( Summ ) : SEXP val = PROTECT(allocVector(VECSXP, 1)); SET_VECTOR_ELT(val, 0, MPFR_as_R(Summ)); mpfr_clears(Summ, x_i, y_i, (mpfr_ptr) 0); if(use_r) mpfr_clear(r); mpfr_free_cache(); UNPROTECT(nprot); return val; } // R_mpfr_sumprod Rmpfr/src/Makevars.in0000644000176200001440000000140213565172775014247 0ustar liggesusers# -*- Makefile -*- # Link with GMP (GNU Multiple Precision) # and with MPFR (Multiple Precision Floating point Reliable) Libraries # was # PKG_LIBS = -lmpfr -lgmp # # To find things in non-default location, when the user uses something like # R CMD INSTALL --configure-args="--with-mpfr-lib=/*/mpfr-3.1.5/lib --with-mpfr-include=/*/mpfr-3.1.5/include" # then CPPFLAGS and PKG_LDFLAGS should be set from ../configure # PKG_CPPFLAGS=$(CPPFLAGS) #-- "Regularly" -- PKG_CFLAGS=$(CFLAGS) PKG_LIBS=$(PKG_LDFLAGS) -lmpfr -lgmp #--MM-- "Works to get newest" (for me via PKG_CONFIG_PATH & sym.link in /usr/local.nfs/app/pkgconfig) # PKG_CFLAGS = `pkg-config --cflags mpfr` # PKG_LIBS = `pkg-config --libs mpfr` # PKG_LDFLAGS = `pkg-config --libs-only-L mpfr` $(LDFLAGS) Rmpfr/vignettes/0000755000176200001440000000000014552770166013365 5ustar liggesusersRmpfr/vignettes/log1mexp.bib0000644000176200001440000000272112057434374015575 0ustar liggesusers@article{DidAM92, author = {DiDonato, Armido R. and Morris, Jr., Alfred H.}, title = {Algorithm 708: Significant digit computation of the incomplete beta function ratios}, journal = TOMS, year = 1992, volume = 18, number = 3, issn = {0098-3500}, pages = {360--373}, url = {http://doi.acm.org/10.1145/131766.131776}, publisher = {ACM}, address = {New York, NY, USA}, } @InProceedings{ieee04:log1p, author = {IEEE and {Open Group}}, title = {The Open Group Base Specifications Issue 6 --- log1p}, booktitle = {IEEE Std 1003.1, 2004 Edition}, year = 2004, url = {http://pubs.opengroup.org/onlinepubs/009604599/functions/log1p.html} } @comment The version of R, where MM introduced the R_D_LExp() macro in dpq.h: @Manual{R-190, title = {R: A language and environment for statistical computing (Ver.~1.9.0)}, author = {{R Development Core Team}}, organization = {R Foundation for Statistical Computing}, address = {Vienna, Austria}, year = 2004, month = {April}, note = {ISBN 3-900051-00-3}, url = {http://www.R-project.org} } @Manual{MaeM12-Rmpfr-log1mexp, author = {Martin M\"achler}, title = {Accurately Computing $\log(1 - \exp(-\abs{a}))$ -- Assessed by the \pkg{Rmpfr} package}, year = 2012, organization = {R package vignette}, address = {on CRAN}, url={http://cran.R-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf} } Rmpfr/vignettes/Rmpfr-pkg.Rnw0000644000176200001440000006526114361031754015723 0ustar liggesusers%\documentclass[article]{jss} \documentclass[nojss,article]{jss} % ----- for the package-vignette, don't use JSS logo, etc % %__FIXME: use ..\index{} for a good "reference index" about the things we show! % \author{Martin M\"achler \\ ETH Zurich} \title{Arbitrarily Accurate Computation with \R: \\ The \pkg{Rmpfr} Package} % \def\mythanks{a version of this paper, for \pkg{nacopula} 0.4\_4, has been published % in JSS, \url{http://www.jstatsoft.org/v39/i09}.} %% for pretty printing and a nice hypersummary also set: \Plainauthor{Martin M\"achler} %% comma-separated \Plaintitle{Arbitrarily Accurate Computation with R---The Rmpfr Package} % \Shorttitle{} % % The index entry makes it into build/vignette.rds : %\VignetteIndexEntry{Arbitrarily Accurate Computation with R Package Rmpfr} %\VignetteDepends{Rmpfr} %\VignetteDepends{gmp} %\VignetteDepends{Bessel} \SweaveOpts{engine=R,eps=FALSE,pdf=TRUE,width=7,height=4,strip.white=true,keep.source=TRUE} %% an abstract and keywords \Abstract{ The \R\ package \pkg{Rmpfr} allows to use arbitrarily precise numbers instead of \R's double precision numbers in many \R\ computations and functions. %% This is achieved by defining S4 classes of such numbers and vectors, matrices, and arrays thereof, where all arithmetic and mathematical functions work via the (GNU) MPFR C library, where MPFR is acronym for ``\emph{\textbf{M}ultiple \textbf{P}recision \textbf{F}loating-Point \textbf{R}eliably}''. MPFR is Free Software, available under the LGPL license, and itself is built on the free GNU Multiple Precision arithmetic library (GMP). Consequently, by using \pkg{Rmpfr}, you can often call your \R\ function or numerical code with mpfr--numbers instead of simple numbers, and all results will automatically be much more accurate. %% see subsection{Applications} further below: Applications by the package author include testing of Bessel or polylog functions and distribution computations, e.g. for ($\alpha$-)stable distributions and Archimedean Copulas. %% In addition, the \pkg{Rmpfr} has been used on the \code{R-help} or \code{R-devel} mailing list for high-accuracy computations, e.g., in comparison with results from other software, and also in improving existing \R\ functionality, e.g., fixing \R\ bug \href{https://bugs.R-project.org/bugzilla3/show_bug.cgi?id=14491}{\code{PR\#14491}}. } \Keywords{MPFR, Abitrary Precision, Multiple Precision Floating-Point, R} %% at least one keyword must be supplied %% publication information %% NOTE: Typically, this can be left commented and will be filled out by the technical editor %% \Volume{13} %% \Issue{9} %% \Month{September} %% \Year{2004} %% \Submitdate{2004-09-29} %% \Acceptdate{2004-09-29} %% The address of (at least) one author should be given %% in the following format: \Address{ Martin M\"achler\\ Seminar f\"ur Statistik, HG G~16\\ ETH Zurich\\ 8092 Zurich, Switzerland\\ E-mail: \email{maechler@stat.math.ethz.ch}\\ URL: \url{http://stat.ethz.ch/people/maechler} } %% It is also possible to add a telephone and fax number %% before the e-mail in the following format: %% Telephone: +43/1/31336-5053 %% Fax: +43/1/31336-734 %% for those who use Sweave please include the following line (with % symbols): %% MM: this is "substituted" by jss.cls: %% need no \usepackage{Sweave.sty} %% Marius' packages \usepackage[american]{babel}%for American English % \usepackage{microtype}%for character protrusion and font expansion (only with pdflatex) \usepackage{amsmath}%sophisticated mathematical formulas with amstex (includes \text{}) \usepackage{mathtools}%fix amsmath deficiencies \usepackage{amssymb}%sophisticated mathematical symbols with amstex (includes \mathbb{}) % \usepackage{amsthm}%theorem environments % \usepackage{bm}%for bold math symbols: \bm (= bold math) % %NON-STANDARD:\RequirePackage{bbm}%only for indicator functions % \usepackage{enumitem}%for automatic numbering of new enumerate environments % \usepackage[ % format=hang, % % NOT for JSS: labelsep=space, % justification=justified, % singlelinecheck=false%, % % NOT for JSS: labelfont=bf % ]{caption}%for captions % \usepackage{tikz}%sophisticated graphics package % \usepackage{tabularx}%for special table environment (tabularx-table) % \usepackage{booktabs}%for table layout % This is already in jss above -- but withOUT the fontsize=\small part !! \DefineVerbatimEnvironment{Sinput}{Verbatim}{fontsize=\small,fontshape=sl} \DefineVerbatimEnvironment{Soutput}{Verbatim}{fontsize=\small} \DefineVerbatimEnvironment{Scode}{Verbatim}{fontsize=\small,fontshape=sl} % but when submitting, do get rid of too much vertical space between R % input & output, i.e. between Sinput and Soutput: \fvset{listparameters={\setlength{\topsep}{0pt}}}% !! quite an effect! %% % \newcommand*{\R}{\proglang{R}}%{\textsf{R}} \newcommand*{\Arg}[1]{\texttt{\itshape $\langle$#1$\rangle$}} \newcommand*{\eps}{\varepsilon} \newcommand*{\CRANpkg}[1]{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}} %% end of declarations %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \begin{document} %% include your article here, just as usual %% Note that you should use the \pkg{}, \proglang{} and \code{} commands. % \section[About Java]{About \proglang{Java}} %% Note: If there is markup in \(sub)section, then it has to be escape as above. %% Note: These are explained in '?RweaveLatex' : <>= options(SweaveHooks= list(fig=function() par(mar=c(5.1, 4.1, 1.1, 2.1))), width = 75, digits = 7, # <-- here, keep R's default! prompt = "R> ", continue=" ") Sys.setenv(LANGUAGE = "en") if(.Platform$OS.type != "windows") Sys.setlocale("LC_MESSAGES","C") <>= if(nzchar(Sys.getenv("R_MM_PKG_CHECKING"))) print( .libPaths() ) stopifnot(require("sfsmisc")) @ \section[Introduction]{Introduction}% \small~\footnote{\mythanks}} %% - Why did I want this in R : There are situations, notably in researching better numerical algorithms for non-trivial mathematical functions, say the $F$-distribution function, where it is interesting and very useful to be able to rerun computations in \R\ in (potentially much) higher precision. For example, if you are interested in Euler's $e$, the base of natural logarithms, and given, e.g., by $e^x = \exp(x)$, you will look into <>= exp(1) @ which typically uses 7 digits for printing, as \code{getOption("digits")} is 7. To see \R's internal accuracy fully, you can use <>= print(exp(1), digits = 17) @ With \pkg{Rmpfr} you can now simply use ``mpfr -- numbers'' and get more accurate results automatically, here using a \emph{vector} of numbers as is customary in \R: <>= require("Rmpfr") # after having installed the package ... (one <- mpfr(1, 120)) exp(one) @ In combinatorics, number theory or when computing series, you may occasionally want to work with \emph{exact} factorials or binomial coefficients, where e.g. you may need all factorials $k!$, for $k=1,2,\dots,24$ or a full row of Pascal's triangle, i.e., want all $\binom{n}{k}$ for $n=80$. With \R's double precision, and standard printing precision <>= ns <- 1:24 ; factorial(ns) @ the full precision of $24!$ is clearly not printed. However, if you display it with more than its full internal precision, <>= noquote(sprintf("%-30.0f", factorial(24))) @ it is obviously wrong in the last couple of digits as they are known to be \code{0}. However, you can easily get full precision results with \pkg{Rmpfr}, by replacing ``simple'' numbers by mpfr-numbers: <>= ns <- mpfr(1:24, 120) ; factorial(ns) @ Or for the 80-th Pascal triangle row, $\binom{n}{k}$ for $n=80$ and $k=1,\dots,n$, <>= chooseMpfr.all(n = 80) <>= capture.and.write(# <- in package 'sfsmisc': ~/R/Pkgs/sfsmisc/R/misc-goodies.R <> , 5, 2, middle = 4, i.middle = 13) @ %%% "FIXME:" drawback of the above is that it is *integer* arithmetic only ... \paragraph{S4 classes and methods:} % Why they are useful here: S4 allows ``multiple dispatch'' which means that the method that is called for a generic function may not just depend on the first argument of the function (as in S3 or in traditional class-based OOP), but on a \emph{``signature''} of multiple arguments. For example, \texttt{a + b} is the same as \code{`+`(a,b)}, i.e., calling a function with two arguments. ... \subsection{The engine behind: MPFR and GMP} The package \pkg{Rmpfr} interfaces \R\ to the C (GNU) library \begin{quote} MPFR, acronym for ``\emph{\textbf{M}ultiple \textbf{P}recision \textbf{F}loating-Point \textbf{R}eliably}'' \end{quote} MPFR is Free Software, available under the LGPL license, %\nocite{ see \url{http://mpfr.org/} and \cite{FouLHLPZ:2007} and the standard reference to MPFR, \cite{FousseHLPZ-MPFR:2011}. %% MPFR itself is built on and requires the GNU Multiple Precision arithmetic library (GMP), see \url{http://gmplib.org/} and \cite{GMP:2011}. It can be obtained from there, or from your operating system vendor. On some platforms, it is very simple, to install MPFR and GMP, something necessary before \pkg{Rmpfr} can be used. E.g., in Linux distributions Debian, Ubuntu and other Debian derivatives, it is sufficient (for \emph{both} libraries) to simply issue \begin{verbatim} sudo apt-get install libmpfr-dev \end{verbatim} \section{Arithmetic with mpfr-numbers} <>= (0:7) / 7 # k/7, for k= 0..7 printed with R's default precision options(digits= 16) (0:7) / 7 # in full double precision accuracy options(digits= 7) # back to default str(.Machine[c("double.digits","double.eps", "double.neg.eps")], digits=10) 2^-(52:53) @ In other words, the double precision numbers \R\ uses have a 53-bit mantissa, and the two ``computer epsilons'' are $2^{-52}$ and $2^{-53}$, respectively. Less technically, how many decimal digits can double precision numbers work with, $2^{-53} = 10^{-x} \Longleftrightarrow x = 53 \log_{10}(2)$, <>= 53 * log10(2) @ i.e., almost 16 digits. If we want to compute some arithmetic expression with higher precision, this can now easily be achieved, using the \pkg{Rmpfr} package, by defining ``\texttt{mpfr}--numbers'' and then work with these. Starting with simple examples, a more precise version of $k/7$, $k = 0,\dots, 7$ from above: <>= x <- mpfr(0:7, 80)/7 # using 80 bits precision x 7*x 7*x - 0:7 @ which here is even ``perfect'' -- but that's ``luck'' only, and also the case here for ``simple'' double precision numbers, at least on our current platform.\footnote{64-bit Linux, Fedora 13 on a ``AMD Phenom 925'' processor} \subsection[Mathematical Constants, Pi, gamma, ..]{% Mathematical Constants, Pi ($\pi$), gamma, etc} Our \pkg{Rmpfr} package also provides the mathematical constants which MPFR provides, via \code{Const(., \Arg{prec})}, currently the \Sexpr{length(eval(formals(Const)[["name"]]))} constants <>= formals(Const)$name @ are available, where \code{"gamma"} is for Euler's gamma, $\gamma := \lim_{n\to\infty} \sum_{k=1}^n \frac 1 k - \log(n) \approx 0.5777$, and \code{"catalan"} for Catalan's constant (see \url{http://en.wikipedia.org/wiki/Catalan\%27s_constant}). <>= Const("pi") Const("log2") @ where you may note a default precision of 120 digits, a bit more than quadruple precision, but also that 1000 digits of $\pi$ are available instantaneously, <>= system.time(Pi <- Const("pi", 1000 *log2(10))) Pi @ As nice example of using Mpfr arithmetic: On a wintery Sunday, Hans Borchers desired to have an exact $\pi$ constant in \pkg{Rmpfr}, and realized that of course \code{mpfr(pi, 256)} could not be the solution, as \code{pi} is the double precision version of $\pi$ and hence only about 53 bit accurate (and the \code{mpfr()} cannot do magic, recognizing ``symbolic'' $\pi$). As he overlooked the \code{Const("pi", .)} solution above, he implemented the following function that computes pi applying Gauss' spectacular AGM-based (AGM := Arithmetic-Geometric Mean) approach [Borwein and Borwein (1987), \emph{Pi and the AGM}]; I have added a \code{verbose} argument, explicit iteration counting and slightly adapted the style to my own: <>= piMpfr <- function(prec=256, itermax = 100, verbose=TRUE) { m2 <- mpfr(2, prec) # '2' as mpfr number ## -> all derived numbers are mpfr (with precision 'prec') p <- m2 + sqrt(m2) # 2 + sqrt(2) = 3.414.. y <- sqrt(sqrt(m2)) # 2^ {1/4} x <- (y+1/y) / m2 it <- 0L repeat { p.old <- p it <- it+1L p <- p * (1+x) / (1+y) if(verbose) cat(sprintf("it=%2d, pi^ = %s, |.-.|/|.|=%e\n", it, formatMpfr(p, min(50, prec/log2(10))), 1-p.old/p)) if (abs(p-p.old) <= m2^(-prec)) break if(it > itermax) { warning("not converged in", it, "iterations") ; break } ## else s <- sqrt(x) y <- (y*s + 1/s) / (1+y) x <- (s+1/s)/2 } p } piMpfr()# indeed converges *quadratically* fast ## with relative error relErr <- 1 - piMpfr(256, verbose=FALSE) / Const("pi",260) ## in bits : asNumeric(-log2(abs(relErr))) @ \subsection[{seqMpfr()} for sequences:]{\code{seqMpfr()} for sequences:} In \R, arithmetic sequences are constructed by \code{seq()}, the ``sequence'' function, which is not generic, and with its many ways and possible arguments is convenient, but straightforward to automatically generalize for mpfr numbers. Instead, we provide the \code{seqMpfr} function... \subsection[Rounding, {roundMpfr()}, {asNumeric()} etc:]{% Rounding, \code{roundMpfr()}, \code{asNumeric()} etc:} In \R, the \code{round()} and \code{signif()} functions belong to the \code{Math2} group, and we provide \code{"mpfr"}-class methods for them: <>= getGroupMembers("Math2") showMethods("Math2", classes=c("mpfr", "mpfrArray")) @ For consistency reasons, however the resulting numbers keep the same number of precision bits, \code{precBits}: <>= i7 <- 1/mpfr(700, 100) c(i7, round(i7, digits = 6), signif(i7, digits = 6)) @ If you really want to ``truncate'' the precision to less digits or bits, you call \code{roundMpfr()}, <>= roundMpfr(i7, precBits = 30) roundMpfr(i7, precBits = 15) @ Note that 15 bits correspond to approximately $15 \cdot 0.3$, i.e., 4.5 digits, because $1/\log_2(10) \approx 0.30103\dots$. \paragraph{asNumeric():} Often used, e.g., to return to fast (\R-internal) arithmetic, also as alternative to \code{roundMpfr()} is to ``round to double precision'' producing standard \R numbers from ``mpfr'' numbers. We provide the function \code{asNumeric()}, a generic function with methods also for \code{"mpfrArray"} see below and the big integers and big rationals from package \pkg{gmp}, <>= showMethods(asNumeric) @ see, e.g., its use above. \paragraph{Formatting:} For explicit printing or plotting purposes, we provide an \code{"mpfr"} method for \R's \code{format()} function, also as explicit utility function \code{formatMpfr(x, digits)} which provides results to \code{digits} \emph{significant} digits, <>= cbind( sapply(1:7, function(d) format(i7, digits=d)) ) @ There, \code{digits = NULL} is the default where the help has (``always'') promised \emph{The default, \code{NULL}, uses enough digits to represent the full precision, often one or two digits more than you would expect}. However, for large numbers, say $10^{20000}$, e.g., \Sexpr{x <- mpfr(10,80)^20000}, all of \code{formatMpfr(x)}, \code{format(x)}, and \code{print(x)} (including ``auto-printing'' of \code{x}), have shown all digits \emph{before} the decimal point and not at all taken into account the 80-bit precision of \code{x} (which corresponds to only \code{80 / log2(10)} $\approx 24$ decimal digits). This has finally changed in the (typically default) case \code{formatMpfr(*, maybe.full = FALSE)}: <>= x <- mpfr(2, 80) ^ ((1:4)*10000) cbind(x) # -> show() -> print.mpfr() -> formatMpfr(.. , digits = NULL, maybe.full = FALSE) nchar(formatMpfr(x)) nchar(formatMpfr(x, maybe.full = TRUE)) @ \section{``All'' mathematical functions, arbitrarily precise} %% see ../../man/mfpr-class.Rd %% but also .... %% {Math}{\code{signature(x = "mpfr")}: All the S4 ``\texttt{Math}'' group functions are defined, using multiple precision (MPFR) arithmetic, i.e., <>= getGroupMembers("Math") @ % \code{{abs}}, \code{{sign}}, \code{{sqrt}}, % \code{{ceiling}}, \code{{floor}}, \code{{trunc}}, % \code{{cummax}}, \code{{cummin}}, \code{{cumprod}}, % \code{{cumsum}}, \code{{exp}}, \code{{expm1}}, % \code{{log}}, \code{{log10}}, \code{{log2}}, % \code{{log1p}}, \code{{cos}}, \code{{cosh}}, % \code{{sin}}, \code{{sinh}}, \code{{tan}}, % \code{{tanh}}, \code{{acos}}, \code{{acosh}}, % \code{{asin}}, \code{{asinh}}, \code{{atan}}, % \code{{atanh}}, \code{{gamma}}, \code{{lgamma}}, % \code{{digamma}}, and \code{{trigamma}}. where currently, \code{trigamma} is not provided by the MPFR library, and hence not implemented yet. %% cumsum(), cumprod() now work! \code{factorial()} has a \texttt{"mpfr"} method; and in addition, \code{factorialMpfr()} computes ${n!}$ efficiently in arbitrary precision, using the MPFR-internal implementation. This is mathematically (but not numerically) the same as $\Gamma(n+1) = $\code{gamma(n+1)}. Similarly to \code{factorialMpfr()}, but more generally useful,the functions \code{chooseMpfr(a,n)} and \code{pochMpfr(a,n)} compute (generalized!) binomial coefficients $\binom{a}{n}$ and ``the'' Pochhammer symbol or ``rising factorial'' \begin{eqnarray*} a^{(n)} &:=& a(a+1)(a+2)\cdots(a+n-1) \\ &=& \frac{(a+n-1)!}{(a-1)!} = \frac{\Gamma(a+n)}{\Gamma(a)}. \end{eqnarray*} Note that with this definition, \[ \binom{a}{n} \equiv \frac{a^{(n)}}{n!}. \] \section{Arbitrarily precise matrices and arrays} %%% FIXME --> ~/R/Meetings-Kurse-etc/2011-Warwick/1_MM_/Poster/MM-poster.tex The classes \code{"mpfrMatrix"} and \code{"mpfrArray"} correspond to the classical numerical \R\ \code{"matrix"} and \code{"array"} objects, which basically are arrays or vectors of numbers with a dimension \code{dim}, possibly named by \code{dimnames}. As there, they can be constructed by \code{dim(.) <- ..} setting, e.g., <>= head(x <- mpfr(0:7, 64)/7) ; mx <- x dim(mx) <- c(4,2) @ or by the \code{mpfrArray()} constructor, <>= dim(aa <- mpfrArray(1:24, precBits = 80, dim = 2:4)) <>= aa <>= capture.and.write(aa, 11, 4) @ and we can index and multiply such matrices, e.g., <>= mx[ 1:3, ] + c(1,10,100) crossprod(mx) @ and also \code{apply} functions, <>= apply(7 * mx, 2, sum) @ \section{Special mathematical functions} \code{zeta(x)} computes Riemann's Zeta function $\zeta(x)$ important in analytical number theory and related fields. The traditional definition is \begin{equation*} \zeta(x) = \sum_{n=1}^\infty \frac{1}{n^x}. \end{equation*} \code{Ei(x)} computes the \textbf{e}xponential integral, \begin{equation*} \int_{-\infty}^{x} \frac{e^t}{t} \; dt. \end{equation*} <>= curve(Ei, 0, 5, n=2001); abline(h=0,v=0, lty=3) @ \code{Li2(x)}, part of the MPFR C library since version 2.4.0, computes the dilogarithm, \begin{equation*} \mathtt{Li2(x)} = \operatorname{Li}_2(x) := \int_{0}^{x} \frac{-log(1-t)}{t} \; dt, \end{equation*} which is the most prominent ``polylogarithm'' function, where the general polylogarithm is (initially) defined as \begin{equation*} \operatorname{Li}_s(z) = \sum_{k=1}^\infty \frac{z^k}{k^s}, \ \forall s \in \mathbb{C} \ \ \forall |z| < 1, z\in\mathbb{C}, \end{equation*} see \url{http://en.wikipedia.org/wiki/Polylogarithm#Dilogarithm}. Note that the integral definition is valid for all $x\in \mathbb{C}$, and also, $Li_2(1) = \zeta(2) = \pi^2/6$. <>= if(mpfrVersion() >= "2.4.0") ## Li2() is not available in older MPFR versions all.equal(Li2(1), Const("pi", 128)^2/6, tol = 1e-30) @ where we also see that \pkg{Rmpfr} provides \texttt{all.equal()} methods for mpfr-numbers which naturally allow very small tolerances \code{tol}. <>= if(mpfrVersion() >= "2.4.0") curve(Li2, -2, 13, n=2000); abline(h=0,v=0, lty=3) @ \code{erf(x)} is the ``error\footnote{named exactly because of its relation to the normal / Gaussian distribution} function'' and \code{erfc(x)} its \textbf{c}omplement, \code{erfc(x) := 1 - erf(x)}, defined as \begin{equation*} \operatorname{erf}(x) = \frac{2}{\sqrt{\pi}}\int_{0}^x e^{-t^2} dt, \end{equation*} and consequently, both functions simply are reparametrizations of the cumulative normal, $\Phi(x) = \int_{-\infty}^x \phi(t)\;dt = $\code{pnorm(x)} where $\phi$ is the normal density function $\phi(t) := \frac{1}{\sqrt{2\pi}}e^{-t^2}$=\code{dnorm(x)}. Namely, \code{erf(x) = 2*pnorm(sqrt(2)*x)} and \code{erfc(x) = 1 - erf(x) = 2* pnorm(sqrt(2)*x, lower=FALSE)}. <>= curve(erf, -3,3, col = "red", ylim = c(-1,2)) curve(erfc, add = TRUE, col = "blue") abline(h=0, v=0, lty=3); abline(v=c(-1,1), lty=3, lwd=.8, col="gray") legend(-3,1, c("erf(x)", "erfc(x)"), col = c("red","blue"), lty=1) @ \subsection{Applications} The CRAN package \CRANpkg{Bessel} provides asymptotic formulas for Bessel functions also of \emph{fractional} order which do work for \code{mpfr}-vector arguments as well. \section{Integration highly precisely} Sometimes, important functions are defined as integrals of other known functions, e.g., the dilogarithm $\operatorname{Li}_2()$ above. Consequently, we found it desirable to allow numerical integration, using mpfr-numbers, and hence---conceptionally---arbitrarily precisely. \R's \code{integrate()} uses a relatively smart adaptive integration scheme, but based on C code which is not very simply translatable to pure \R, to be used with mpfr numbers. For this reason, our \code{integrateR()} function uses classical Romberg integration \citep{Bauer-1961}. We demonstrate its use, first by looking at a situation where \R's \code{integrate()} can get problems: <>= integrateR(dnorm,0,2000) integrateR(dnorm,0,2000, rel.tol=1e-15) integrateR(dnorm,0,2000, rel.tol=1e-15, verbose=TRUE) @ Now, for situations where numerical integration would not be necessary, as the solution is known analytically, but hence are useful for exploration of high accuracy numerical integration: First, the exponential function $\exp(x) = e^x$ with its well-known $\int \exp(t)\;dt = \exp(x)$, both with standard (double precision) floats, <>= (Ie.d <- integrateR(exp, 0 , 1, rel.tol=1e-15, verbose=TRUE)) @ and then the same, using 200-bit accurate mpfr-numbers: <>= (Ie.m <- integrateR(exp, mpfr(0,200), 1, rel.tol=1e-25, verbose=TRUE)) (I.true <- exp(mpfr(1, 200)) - 1) ## with absolute errors as.numeric(c(I.true - Ie.d$value, I.true - Ie.m$value)) @ Now, for polynomials, where Romberg integration of the appropriate order is exact, mathematically, <>= if(require("polynom")) { x <- polynomial(0:1) p <- (x-2)^4 - 3*(x-3)^2 Fp <- as.function(p) print(pI <- integral(p)) # formally print(Itrue <- predict(pI, 5) - predict(pI, 0)) ## == 20 } else { Fp <- function(x) (x-2)^4 - 3*(x-3)^2 Itrue <- 20 } (Id <- integrateR(Fp, 0, 5)) (Im <- integrateR(Fp, 0, mpfr(5, 256), rel.tol = 1e-70, verbose=TRUE)) ## and the numerical errors, are indeed of the expected size: 256 * log10(2) # - expect ~ 77 digit accuracy for mpfr(*., 256) as.numeric(Itrue - c(Im$value, Id$value)) @ \section{Miscellaneous} For probability and density computations, it is known to be important in many contexts to work on the $\log$--scale, i.e., with log probabilities $\log P(.)$ or log densities $\log f()$. In \R{} itself, we (R Core) had introduced logical optional arguments \code{log} (for density) and \code{log.p} for probability (e.g., \code{pnorm()} and quantile (e.g., \code{qnorm}) functions. As our \code{pnorm()} is based on MPFR's \code{erf()} and \code{erfc()} which currently do \emph{not} have scaled versions, for \code{Rmpfr::pnorm(.., log.p=TRUE)} we do need to compute the logarithm (instead of working on the log scale). On the extreme left tail, \R{} correctly computes <>= pnorm(-1234, log.p=TRUE) @ i.e., \code{-761386.036955} to more digits. However, \code{erf()} and \code{erfc()} do not have a log scale or other scaled versions. Thanks to the large range of exponents compared to double precision numbers it does less quickly underflow to zero, e.g., <>= (p123 <- Rmpfr::pnorm(mpfr(-123, 66), log.p=TRUE)) # is based on (ec123 <- erfc(123 * sqrt(mpfr(0.5, 66+4))) / 2) # 1.95....e-3288 (p333 <- Rmpfr::pnorm(mpfr(-333, 66), log.p=TRUE)) exp(p333) stopifnot(p123 == log(roundMpfr(ec123, 66)), ## '==' as we implemented our pnorm() all.equal(p333, -55451.22709, tol=1e-8)) @ and indeed, the default range for exponent (wrt base 2, not 10) is given by <>= (old_erng <- .mpfr_erange() ) @ which shows the current minimal and maximal base-2 exponents for mpfr-numbers, by ``factory-fresh'' default, the number $-2^{30}$ and $2^{30}$, i.e., $\pm 1073741823$ which is much larger than the corresponding limits for regular double precision numbers, <>= unlist( .Machine[c("double.min.exp", "double.max.exp")] ) @ which are basically $\pm 2^{10}$; note that double arithmetic typically allows subnormal numbers which are even smaller than $2^{-1024}$, also in \R{}, on all usual platforms, <>= 2^(-1022 - 52) @ is equal to $2^{-1074}$ and the really smallest positive double precision number. Now, \emph{if} if the GMP library to which both \R{} package \pkg{gmp} and \pkg{Rmpfr} interface is built ``properly'', i.e., with full 64 bit ``numb''s, we can \emph{extend} the range of mpfr-numbers even further. By how much, we can read off <>= .mpfr_erange(.mpfr_erange_kinds) ## and then set # use very slightly smaller than extreme values: (myERng <- (1-2^-52) * .mpfr_erange(c("min.emin","max.emax"))) .mpfr_erange_set(value = myERng) # and to see what happened: .mpfr_erange() @ If that worked well, this shows \code{-/+ 4.611686e+18}, or actually $\mp 2^{62}$, \code{log2(abs(.mpfr_erange()))} giving \Sexpr{log2(abs(.mpfr_erange()))}. However, currently on Winbuilder this does not extend, notably as the GMP numbs, <>= .mpfr_gmp_numbbits() @ have \emph{not} been 64, there. \section{Conclusion} The \R\ package \pkg{Rmpfr}, available from CRAN since August 2009, provides the possibility to run many computations in R with (arbitrarily) high accuracy, though typically with substantial speed penalty. This is particularly important and useful for checking and exploring the numerical stability and appropriateness of mathematical formulae that are translated to a computer language like \R, often without very careful consideration of the limits of computer arithmetic. \bibliography{Rmpfr,log1mexp} FIXME: \textbf{Index} of all functions mentioned \dots \end{document} Rmpfr/vignettes/log1mexp-note.Rnw0000644000176200001440000006606414355605130016555 0ustar liggesusers\documentclass[article,nojss]{jss}%-- the LONGER version %% NOTA BENE: More definitions --> further down %%%%%%%%%%%% % \author{Martin M\"achler \\ ETH Zurich% \\ April, Oct.\ 2012 {\tiny (\LaTeX'ed \today)}%---- for now } \title{Accurately Computing $\log(1 - \exp(-\abs{a}))$ \\ Assessed by the \pkg{Rmpfr} package} %% for pretty printing and a nice hypersummary also set: \Plainauthor{Martin M\"achler} %% comma-separated \Plaintitle{% Accurately Computing log(1 - exp(.)) -- Assessed by Rmpfr} %\VignetteIndexEntry{Accurately Computing log(1 - exp(.)) -- Assessed by Rmpfr} %\VignetteDepends{Rmpfr} %\VignetteDepends{gmp} %\VignetteDepends{sfsmisc} \SweaveOpts{engine=R,strip.white=true, width=8.5, height=6} \SweaveOpts{pdf=FALSE, eps=FALSE, grdevice = pdfaCrop} % defined in R "<>": ^^^^^^^^ %% an abstract and keywords \Abstract{In this note, we explain how $f(a) = \log(1 - e^{-a}) =\log(1 - \exp(-a))$ can be computed accurately, in a simple and optimal manner, building on the two related auxiliary functions \code{log1p(x)} ($=\log(1+x)$) and \code{expm1(x)} ($=\exp(x)-1 = e^x - 1$). The cutoff, $a_0$, in use in \R{} since % version 1.9.0, April 2004, is shown to be optimal both theoretically and empirically, using \pkg{Rmpfr} high precision arithmetic. As an aside, we also show how to compute $\log\bigl(1 + e^x \bigr)$ accurately and efficiently. } \Keywords{Accuracy, Cancellation Error, R, MPFR, Rmpfr} %% at least one keyword must be supplied %% publication information %% NOTE: Typically, this can be left commented and will be filled out by the technical editor %% \Volume{13} %% \Issue{9} %% \Month{September} %% \Year{2004} %% \Submitdate{2004-09-29} %% \Acceptdate{2004-09-29} %% The address of (at least) one author should be given %% in the following format: \Address{ Martin M\"achler\\ Seminar f\"ur Statistik, HG G~16\\ ETH Zurich\\ 8092 Zurich, Switzerland\\ E-mail: \email{maechler@stat.math.ethz.ch}\\ URL: \url{https://stat.ethz.ch/~maechler} } %% It is also possible to add a telephone and fax number %% before the e-mail in the following format: %% Telephone: +43/1/31336-5053 %% Fax: +43/1/31336-734 %% for those who use Sweave please include the following line (with % symbols): %% MM: this is "substituted" by jss.cls: %% need no \usepackage{Sweave.sty} \usepackage[american]{babel}%for American English \usepackage{amsmath}%sophisticated mathematical formulas with amstex (includes \text{}) \usepackage{mathtools}%fix amsmath deficiencies \usepackage{amssymb}%sophisticated mathematical symbols with amstex (includes \mathbb{}) % \usepackage{amsthm}%theorem environments \usepackage{bm}%for bold math symbols: \bm (= bold math) \usepackage{enumitem}%for automatic numbering of new enumerate environments % This is already in jss above -- but withOUT the fontsize=\small part !! \DefineVerbatimEnvironment{Sinput}{Verbatim}{fontsize=\small,fontshape=sl} \DefineVerbatimEnvironment{Soutput}{Verbatim}{fontsize=\small} \DefineVerbatimEnvironment{Scode}{Verbatim}{fontsize=\small,fontshape=sl} %%~-~-~-~ Make space between Sinput and Soutput smaller: ~-~-~-~~-~-~-~~-~-~-~~-~-~-~~-~-~-~ %%--- Best advice, now from : % http://tex.stackexchange.com/questions/19359/reduce-space-between-sinput-and-soutput \newlength{\FVtopsep} \newlength{\FVpartopsep} \newlength{\FVparskip}% <- added as "no. 3" by MMa (after reading fancyvrb doc) \makeatletter \FV@AddToHook{\FV@ListParameterHook}{\topsep=\FVtopsep\partopsep=\FVpartopsep\parskip=\FVparskip} \makeatother % Control the spacing around the Sinput and Soutput environments by using the lengths % % \FVtopsep % \FVpartopsep % \FVparskip % % Both *topsep act quite similar most of the time, more details % can be found in the fancyvrb documentation on page 46. (MM: ==> I add FVparskip) %To kill all extra spacing between the environments, use {0pt} in all these %MM: When all three(!) are {0pt}, there's a large gap *after* Schunk (nothing in %between) %-- and that (end gap) get's smaller when I set all to {1pt} -- logic?? %___TODO/FIXME: Set of experiments (with smaller Sweave file)___ \setlength{\FVtopsep}{1pt} \setlength{\FVpartopsep}{1pt} \setlength{\FVparskip}{\parskip}% default: \parskip %%~-~-~-~ End {Sweave space handling} ~-~-~-~~-~-~-~~-~-~-~~-~-~-~~-~-~-~~-~-~~-~-~-~~-~-~ %% \setkeys{Gin}{width=\textwidth}% Sweave.sty has {width=0.8\textwidth} \newcommand*{\R}{\proglang{R}}%{\textsf{R}} \newcommand*{\CRANpkg}[1]{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}} \newcommand*{\eps}{\varepsilon} %- \abs{ab} --> | ab | ``absolut Betrag'' \newcommand{\abs}[1] {\left| #1 \right|} % \renewcommand*{\S}{\operatorname*{S}} % \newcommand*{\tS}{\operatorname*{\tilde{S}}} % \newcommand*{\ran}{\operatorname*{ran}} %\newcommand*{\sgn}{\operatorname*{sgn}} \DeclareMathOperator{\sign}{sign} % \renewcommand*{\L}{\mathcal{L}} % \newcommand*{\Li}{\mathcal{L}^{-1}} % \newcommand*{\LS}{\mathcal{LS}} % \newcommand*{\LSi}{\LS^{-1}} \renewcommand*{\O}{\mathcal{O}} % \newcommand*{\Geo}{\operatorname*{Geo}} % \newcommand*{\Exp}{\operatorname*{Exp}} % \newcommand*{\Sibuya}{\operatorname*{Sibuya}} % \newcommand*{\Log}{\operatorname*{Log}} % \newcommand*{\U}{\operatorname*{U}} % \newcommand*{\B}{\operatorname*{B}} % \newcommand*{\NB}{\operatorname*{NB}} % \newcommand*{\N}{\operatorname*{N}} \DeclareMathOperator{\var}{var} \DeclareMathOperator{\Var}{Var} \DeclareMathOperator{\Cov}{Cov} \DeclareMathOperator{\cov}{cov} \DeclareMathOperator{\Cor}{Corr} \DeclareMathOperator{\cor}{corr} % \newcommand*{\Var}{\operatorname*{Var}} % \newcommand*{\Cov}{\operatorname*{Cov}} % \newcommand*{\Cor}{\operatorname*{Cor}} % % \newcommand*{\loglp}{\operatorname*{log1p}} % \newcommand*{\expml}{\operatorname*{expm1}} %% cannot use "1" in latex macro name -- use "l": \newcommand*{\loglp}{\mathrm{log1p}} \newcommand*{\expml}{\mathrm{expm1}} %% journal specific aliases \newcommand*{\setcapwidth}[1]{} %% end of declarations %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \begin{document} %% include your article here, just as usual %% Note that you should use the \pkg{}, \proglang{} and \code{} commands. % \section[About Java]{About \proglang{Java}} %% Note: If there is markup in \(sub)section, then it has to be escape as above. %% %% Note: These are explained in '?RweaveLatex' : <>= ## Our custom graphics device: pdfaCrop <- function(name, width, height, ...) { fn <- paste(name, "pdf", sep = ".") if(FALSE)## debug cat("pdfaCrop: fn = ",fn,"; call:\n\t",deparse(match.call()),"\n") grDevices::pdf(fn, width = width, height = height, onefile=FALSE)# ...) assign(".pdfaCrop.name", fn, envir = globalenv()) } ## This is used automagically : pdfaCrop.off <- function() { dev.off()# for the pdf f <- get(".pdfaCrop.name", envir = globalenv()) ## and now crop that file: pdfcrop <- "pdfcrop" # relying on PATH - fix if needed pdftex <- "pdftex" # relying on PATH - fix if needed system(paste(pdfcrop, "--pdftexcmd", pdftex, f, f, "1>/dev/null 2>&1"), intern=FALSE) } op.orig <- options(width = 75, SweaveHooks= list(fig=function() par(mar=c(5.1, 4.1, 1.1, 2.1))), digits = 5, useFancyQuotes = "TeX", ## for JSS, but otherwise MM does not like it: ## prompt="R> ", continue=" ")# 2 (or 3) blanks: use same length as 'prompt' if((p <- "package:fortunes") %in% search()) try(detach(p, unload=TRUE, char=TRUE)) Sys.setenv(LANGUAGE = "en") if(.Platform$OS.type != "windows") Sys.setlocale("LC_MESSAGES","C") if(getRversion() < "2.15") paste0 <- function(...) paste(..., sep = '') library("sfsmisc")# e.g., for eaxis() library("Rmpfr") .plot.BC <- FALSE # no Box-Cox plot @ %\section[Introduction]{Introduction \small~\footnote{\mythanks}} \section{Introduction: Not log() nor exp(), but log1p() and expm1()} In applied mathematics, it has been known for a very long time that direct computation of $\log(1 + x)$ suffers from severe cancellation (in ``$1 + x$'') whenever $\abs{x} \ll 1$, and for that reason, we have provided \code{log1p(x)} in \R{}, since R version 1.0.0 (released, Feb.~29, 2000). Similarly, \code{log1p()} has been provided by C math libraries and has become part of C language standards around the same time, see, for example, \citet{ieee04:log1p}. Analogously, since \R{}~1.5.0 (April 2002), the function \code{expm1(x)} computes $\exp(x) - 1 = e^x - 1$ accurately also for $\abs{x} \ll 1$, where $e^x \approx 1$ is (partially) cancelled by ``$-\: 1$''. In both cases, a simple solution %approach for small $\abs{x}$ is to use a few terms of the Taylor series, as \begin{align} \label{eq:Taylor-log1p} \loglp(x) &= \log(1 + x) = x - x^2/2 + x^3/3 -+ \dots, \ \mathrm{for}\ \ \abs{x} < 1, %\mathrm{and} \\ \label{eq:Taylor-expm1} \expml(x) &= \exp(x) - 1 = x + x^2/2! + x^3/3! + \dots, \ \mathrm{for}\ \ \abs{x} < 1, \end{align} and $n!$ denotes the factorial. We have found, however, that in some situations, the use of \code{log1p()} and \code{expm1()} may not be sufficient to prevent loss of numerical accuracy. The topic of this note is to analyze the important case of computing $\log\left(1 - e^x \right) = \log(1 - \exp(x))$ for $x < 0$, computations needed in accurate computations of the beta, gamma, exponential, Weibull, t, logistic, geometric and hypergeometric distributions, %% in ~/R/D/r-devel/R/src/nmath/ : %% grep --color -nHEw -e '(R_Log1_Exp|R_D_LExp|R_DT_Log|R_DT_C?log)' *.? %% --> ~/R/Pkgs/Rmpfr/vignettes/log1mexp_grep and % because of the latter, even for the logit link function in logistic regression. For the beta and gamma distributions, see, for example, % e.g., \citet{DidAM92}\footnote{In the Fortran source, file ``\code{708}'', also available as \url{http://www.netlib.org/toms/708}, the function ALNREL() computes log1p() and REXP() computes expm1().}, and further references mentioned in \R{}'s \code{?pgamma} and \code{?pbeta} help pages. For the logistic distribution, $F_L(x) = \frac{e^x}{1+e^x}$, the inverse, aka quantile function is $q_L(p) = \mathrm{logit}(p) := \log \frac{p}{1-p}$. If the argument $p$ is provided on the log scale, $\tilde p := \log p$, hence $\tilde p \le 0$, we need \begin{align} \label{eq:qlogis} \mathtt{qlogis}(\tilde p,\: \mathtt{log.p=TRUE}) = q_L\!\left(e^{\tilde p}\right) = \mathrm{logit}\!\left(e^{\tilde p}\right) % = \log\Bigl(\frac{e^{\tilde p}}{1-e^{\tilde p}}\Bigr) = \log \frac{e^{\tilde p}}{1-e^{\tilde p}} = \tilde p - \log\left(1 - e^{\tilde p} \right), \end{align} and the last term is exactly the topic of this note. \section{log1p() and expm1() for log(1 - exp(x))} Contrary to what one would expect, for computing $\log\left(1 - e^x \right) = \log(1 - \exp(x))$ for $x < 0$, neither \begin{align} \label{eq:f.expm1} \log(1 - \exp(x)) &= \log(-\expml(x)), \ \ \mathrm{nor}\\ \label{eq:f.log1p} \log(1 - \exp(x)) &= \loglp(-\exp(x)), \end{align} are uniformly sufficient for numerical evaluation. %% 1 In (\ref{eq:f.log1p}), when $x$ approaches $0$, $\exp(x)$ approaches $1$ and $\loglp(-\exp(x))$ loses accuracy. %% 2 In (\ref{eq:f.expm1}), when $x$ is large, $\expml(x)$ approaches $-1$ and similarly loses accuracy. Because of this, we will propose to use a function \code{log1mexp(x)} which uses either \code{expm1} (\ref{eq:f.expm1}) or \code{log1p} (\ref{eq:f.log1p}), where appropriate. Already in \R{}~1.9.0 (\cite{R-190}), % (April 2004) % now, both R_Log1_Exp() and --> R_D_LExp(x) := (log_p ? R_Log1_Exp(x) : log1p(-x)) we have defined the macro \verb|R_D_LExp(x)| to provide these two cases %branches automatically\footnote{look for ``log(1-exp(x))'' in \url{http://svn.r-project.org/R/branches/R-1-9-patches/src/nmath/dpq.h}}. % R-1.8.1: pgamma(30,100, lower=FALSE, log=TRUE) gave 0 instead of -... To investigate the accuracy losses empirically, we make use of the \R{} package \CRANpkg{Rmpfr} for arbitrarily accurate numerical computation, and use the following simple functions: <>= library(Rmpfr) t3.l1e <- function(a) { c(def = log(1 - exp(-a)), expm1 = log( -expm1(-a)), log1p = log1p(-exp(-a))) } @ <>= leg <- local({ r <- body(t3.l1e)[[2]]; r[[1]] <- `expression`; eval(r) }) ## will be used below @ <>= ##' The relative Error of log1mexp computations: relE.l1e <- function(a, precBits = 1024) { stopifnot(is.numeric(a), length(a) == 1, precBits > 50) da <- t3.l1e(a) ## double precision a. <- mpfr(a, precBits=precBits) ## high precision *and* using the correct case: mMa <- if(a <= log(2)) log(-expm1(-a.)) else log1p(-exp(-a.)) structure(as.numeric(1 - da/mMa), names = names(da)) } @ <>= <> <> @ where the last one, \code{relE.l1e()} computes the relative error of three different ways to compute $\log(1 - \exp(-a))$ for positive $a$ (instead of computing $\log(1 - \exp(x))$ for negative $x$). %% TODO? "cache = TRUE": --- <>= a.s <- 2^seq(-55, 10, length = 256) ra.s <- t(sapply(a.s, relE.l1e)) <>= <> cbind(a.s, ra.s) # comparison of the three approaches <>= <> capture.and.write(cbind(a.s, ra.s), 8, last = 6) @ This is revealing: Neither method, log1p or expm1, is uniformly good enough. Note that for large $a$, the relative errors evaluate to \code{1}. This is because all three double precision methods give 0, \emph{and} that is the best approximation in double precision (but not in higher \code{mpfr} precision), hence no problem at all, and we can restrict ourselves to smaller $a$ (smaller than about 710, here).% < 709.78271289338403 (lynne 64b) <>= ii <- a.s < 710 a.s <- a.s[ii] ra.s <- ra.s[ii, ] @ What about really small $a$'s? Note here that <>= t3.l1e(1e-20) as.numeric(t3.l1e(mpfr(1e-20, 256))) @ % ## expm1 def log1p % ## -46.0517 -Inf -Inf % as.numeric(): % ## [1] -46.0517 -46.0517 -46.0517 both the default and the \code{log1p} method return \code{-Inf}, so, indeed, the \code{expm1} method is absolutely needed here. Figure~\ref{fig:bigpic} visualizes the relative errors\footnote{% Absolute value of relative errors, $\abs{(\hat{f}(a) - f(a)) / f(a)} = \abs{1 - \hat{f}(a)/f(a)}$, where $f(a) = \mathrm{log1mexp}(a)$ (\ref{eq:log1mexp}) is computed accurately by a 1024 bit \pkg{Rmpfr} computation} of the three methods. Note that the default basically gives the maximum of the two methods' errors, whereas the final \code{log1mexp()} function will have (approximately) minimal error of the two. %% --- Define figure_1 here ------------------------------ <>= par(mar = c(4.1,4.1,0.6,1.6)) cc <- adjustcolor(c(4,1,2),.8, red.f=.7) lt <- c("solid","33","3262") ll <- c(.7, 1.5, 2) @ %% main = "|relative errors| of three methods for log(1 - exp(-a))" <>= matplot(a.s, abs(ra.s), type = "l", log = "xy", col=cc, lty=lt, lwd=ll, xlab = "a", ylab = "", axes=FALSE) legend("top", leg, col=cc, lty=lt, lwd=ll, bty="n") draw.machEps <- function(alpha.f = 1/3, col = adjustcolor("black", alpha.f)) { abline(h = .Machine$double.eps, col=col, lty=3) axis(4, at=.Machine$double.eps, label=quote(epsilon[c]), las=1, col.axis=col) } eaxis(1); eaxis(2); draw.machEps(0.4) @ %% TODO? "cache = TRUE": echo=FALSE: do not show already, but need (a.,ra2) <>= a. <- (1:400)/256 ra <- t(sapply(a., relE.l1e)) ra2 <- ra[,-1] @ \begin{figure}[htb!] \centering % increasing width --> effective LaTeX *height* will decrease <>= <> <> ## draw the zoom-in region into the plot: yl <- range(pmax(1e-18, abs(ra2))) rect(min(a.), yl[1], max(a.), yl[2], col= adjustcolor("black", .05), border="gray", pch = 5) @ \setcapwidth{\textwidth}% \caption[Relative errors of log1mexp() approximations]{% Relative errors$^{*}$ of the default, $\log(1 - e^{-a})$, and the two methods ``\code{expm1}'' $\log(-\expml(-a))$ and ``\code{log1p}'' $\loglp(-\exp(-a))$. Figure~\ref{fig:zoomin-pic} will be a zoom into the gray rectangular region where all three curves are close.} \label{fig:bigpic} \end{figure} In Figure~\ref{fig:zoomin-pic} below, we zoom into the region where all methods have about the same (good) accuracy. The region is the rectangle defined by the ranges of \code{a.} and \code{ra2}: <>= <> @ In addition to zooming in Figure~\ref{fig:bigpic}, we want to smooth the two curves, using a method assuming approximately normal errors. Notice however that neither the original, nor the log-transformed values have approximately symmetric errors, so we use \code{MASS::boxcox()} to determine the ``correct'' power transformation, <>= da <- cbind(a = a., as.data.frame(ra2)) library(MASS) bc1 <- boxcox(abs(expm1) ~ a, data = da, lambda = seq(0,1, by=.01), plotit=.plot.BC) bc2 <- boxcox(abs(log1p) ~ a, data = da, lambda = seq(0,1, by=.01), plotit=.plot.BC) c(with(bc1, x[which.max(y)]), with(bc2, x[which.max(y)]))## optimal powers ## ==> taking ^ (1/3) : s1 <- with(da, smooth.spline(a, abs(expm1)^(1/3), df = 9)) s2 <- with(da, smooth.spline(a, abs(log1p)^(1/3), df = 9)) @ i.e, the optimal boxcox exponent turns out to be close to $\frac 1 3$, which we use for smoothing in a ``zoom--in'' of Figure~\ref{fig:bigpic}. Then, the crossover point of the two curves already suggests that the cutoff, $a_0 = \log 2$ is empirically very close to optimal. <>= matplot(a., abs(ra2), type = "l", log = "y", # ylim = c(-1,1)*1e-12, col=cc[-1], lwd=ll[-1], lty=lt[-1], ylim = yl, xlab = "a", ylab = "", axes=FALSE) legend("topright", leg[-1], col=cc[-1], lwd=ll[-1], lty=lt[-1], bty="n") eaxis(1); eaxis(2); draw.machEps() lines(a., predict(s1)$y ^ 3, col=cc[2], lwd=2) lines(a., predict(s2)$y ^ 3, col=cc[3], lwd=2) @ %% no title here: main = "|relative errors| of two methods for log(1 - exp(-a))") \enlargethispage{5ex} \begin{figure}[hbt!] \centering <>= cl2 <- adjustcolor("slateblue", 1/2)# (adj: lwd=3) # the color for "log(2)" par(mar = c(4.1,4.1,0.6,1.6)) <> abline(v = log(2), col=cl2, lty="9273", lwd=2.5) cl2. <- adjustcolor(cl2, 2) axis(1, at=log(2), label=quote(a[0] == log~2), las=1, col.axis=cl2.,col=cl2, lty="9273", lwd=2.5) ## what system is it ? sysInf <- Sys.info()[c("sysname", "release", "nodename", "machine")] mtext(with(as.list(sysInf), paste0(sysname," ",release,"(",substr(nodename,1,16),") -- ", machine)), side=1, adj=1, line=2.25, cex = 3/4) @ \setcapwidth{\textwidth}% \caption{A ``zoom in'' of Figure~\ref{fig:bigpic} showing the region where the two basic methods, ``\code{expm1}'' and ``\code{log1p}'' switch their optimality with respect to their relative errors. Both have small relative errors in this region, typically below $\eps_c :=$% \code{.Machine\$double.eps} $=2^{-52} \approx 2.22\cdot 10^{-16}$. \ \ The smoothed curves indicate crossover close to $a = a_0 := \log 2$.} \label{fig:zoomin-pic} \end{figure} \paragraph{Why is it very plausible to take $a_0 := \log 2$ as approximately optimal cutoff?} Already from Figure~\ref{fig:zoomin-pic}, empirically, an optimal cutoff $a_0$ is around $0.7$. We propose to compute \begin{align} \label{eq:def-log1mexp} f(a) = \log\left(1 - e^{-a}\right) = \log(1 - \exp(-a)), \ \ a > 0, \end{align} by a new method or function \code{log1mexp(a)}. It needs a cutoff $a_0$ between choosing \code{expm1} for $0 < a \le a_0$ and \code{log1p} for $a > a_0$, i.e., \begin{align} \label{eq:log1mexp} f(a) = \mathrm{log1mexp}(a) := \begin{cases} \log(-\expml(-a)) & 0 < a \le a_0 \ \ ( := \log 2 \approx 0.693) \\ \loglp(-\exp(-a)) & \phantom{0 < {}}a > a_0. \end{cases} \end{align} The mathematical argument for choosing $a_0$ is quite simple, at least informally: In which situations does $1 - e^{-a}$ loose bits (binary digits) \emph{entirely independently} of the computational algorithm? Well, as soon as it ``spends'' bits just to store its closeness to $1$. And that is as soon as $e^{-a} < \frac 1 2 = 2^{-1}$, because then, at least one bit cancels. This however is equivalent to $-a < \log(2^{-1}) = -\log(2)$ or $a > \log 2 =: a_0$. \section{Computation of log(1+exp(x))} Related to $\mathrm{log1mexp}(a)=\log(1 - e^{-a})$ is the log survival function of the logistic distribution % (see above)%: defined F_L $\log(1 - F_L(x)) = \log\frac{1}{1+e^x} = -\log(1 + e^x) = -g(x)$, where \begin{align} \label{eq:def-log1pexp} g(x) := \log(1 + e^x) = \loglp(e^x), \end{align} which has a ``$+"$'' instead of a ``$-$'', compared to $\mathrm{log1mexp}$, and is easier to analyze and compute, its only problem being large $x$'s where $e^x$ % = \exp x$ overflows numerically.\footnote{Indeed, for $x=710$, $ -g(x) = \log(1 - F_L(x)) = $ \code{plogis(710, lower=FALSE, log.p=TRUE)}, underflowed to \code{-Inf} in \R{} versions before 2.15.1 (June 2012) from when on (\ref{eq:log1pexp}) has been used.} As $g(x)= \log(1 + e^x) = \log(e^x(e^{-x} + 1)) = x + \log(1 + e^{-x})$, we see from (\ref{eq:Taylor-log1p}) that \begin{align} \label{eq:log1pexp-asym} g(x) = x + \log(1 + e^{-x}) = % \sim %\asymp %% x + e^{-x}(1 - e^{-x}/2) + \O((e^{-x})^3), x + e^{-x} + \O((e^{-x})^2), \end{align} for $x\to\infty$. Note further, that for $x\to-\infty$, we can simplify $g(x)=\log(1 + e^x)$ to $e^x$. A simple picture quickly reveals how different approximations behave, where we have used \code{uniroot()} to determine the zero crossing, but will use slightly simpler cutoffs $x_0=37$, $x_1$ and $x_2$, in (\ref{eq:log1pexp}) below: %% Notation x_0, x_1, x_2 are related to the 1st, 2nd and 3rd cutoff in equation (10) %% -37 18 33.3 <>= ## Find x0, such that exp(x) =.= g(x) for x < x0 : f0 <- function(x) { x <- exp(x) - log1p(exp(x)) x[x==0] <- -1 ; x } u0 <- uniroot(f0, c(-100, 0), tol=1e-13) str(u0, digits=10) x0 <- u0[["root"]] ## -36.39022698 --- note that ~= \log(\eps_C) all.equal(x0, -52.5 * log(2), tol=1e-13) ## Find x1, such that x + exp(-x) =.= g(x) for x > x1 : f1 <- function(x) { x <- (x + exp(-x)) - log1p(exp(x)) x[x==0] <- -1 ; x } u1 <- uniroot(f1, c(1, 20), tol=1e-13) str(u1, digits=10) x1 <- u1[["root"]] ## 16.408226 ## Find x2, such that x =.= g(x) for x > x2 : f2 <- function(x) { x <- log1p(exp(x)) - x ; x[x==0] <- -1 ; x } u2 <- uniroot(f2, c(5, 50), tol=1e-13) str(u2, digits=10) x2 <- u2[["root"]] ## 33.27835 @ %% but really the above is still ``non sense'': look at <>= par(mfcol= 1:2, mar = c(4.1,4.1,0.6,1.6), mgp = c(1.6, 0.75, 0)) curve(x+exp(-x) - log1p(exp(x)), 15, 25, n=2^11); abline(v=x1, lty=3) curve(log1p(exp(x)) - x, 33.1, 33.5, n=2^10); abline(v=x2, lty=3) @ \medskip Using double precision arithmetic, a fast and accurate computational method is to use \begin{align} \label{eq:log1pexp} \hat{g}(x) = \mathrm{log1pexp}(x) := \begin{cases} \exp(x) & x \le -37 \\ \loglp(\exp(x)) & -37 < x \le x_1 := 18, \\ x + \exp(-x) & x_1 < x \le x_2 := 33.3, \\ x & x > x_2, \end{cases} \end{align} where only the cutoff $x_1 = 18$ is important and the other cutoffs just save computations.\footnote{see % the %\R{} plot \code{curve(log1p(exp(x)) - x, 33.1, 33.5, n=2\^{}10)} above, revealing a somewhat fuzzy cutoff $x_2$.} %%--- Ok, still do a little deeper analysis for the interested R code reader %%--- invisibly mostly (echo=FALSE) here: <>= t4p.l1e <- function(x) { c(def = log(1 + exp(x)), log1p = log1p(exp(x)), ## xlog1p = x + log1p(exp(-x)), xpexp = x + exp(-x), x = x) } leg <- local({ r <- body(t4p.l1e)[[2]]; r[[1]] <- `expression`; eval(r) }) ##' The relative Error of log1pexp computations: relE.pl1e <- function(x, precBits = 1024) { stopifnot(is.numeric(x), length(x) == 1, precBits > 50) dx <- t4p.l1e(x) ## double precision x. <- mpfr(x, precBits=precBits) ## high precision *and* using the correct case: mMx <- if(x < 0) log1p(exp(x.)) else x. + log1p(exp(-x.)) structure(as.numeric(1 - dx/mMx), names = names(dx)) } <>= x.s <- seq(-100, 750, by = 5) # <- the big picture ==> problem for default x.s <- seq( 5, 60, length=512) # <- the zoom in ==> *no* problem for def. rx.s <- t(sapply(x.s, relE.pl1e)) signif(cbind(x.s, rx.s),3) @ \begin{figure}[htb!] \centering %% using "blue" for the default method, *as* in Figure 1 above <>= par(mar = c(4.1,4.1,0.6,1.6), mgp = c(1.6, 0.75, 0)) cc <- adjustcolor(c(4,1,2,3),.8, red.f=.7, blue.f=.8) lt <- c("solid","33","3262","dotdash") ll <- c(.7, 1.5, 2, 2) ym <- 1e-18 yM <- 1e-13 matplot(x.s, pmax(pmin(abs(rx.s),yM),ym), type = "l", log = "y", axes=FALSE, ylim = c(ym,yM), col=cc, lty=lt, lwd=ll, xlab = "x", ylab = "") legend("topright", leg, col=cc, lty=lt, lwd=ll, bty="n") eaxis(1, at=pretty(range(x.s), n =12)); eaxis(2) draw.machEps(0.4) x12 <- c(18, 33.3) abline(v=x12, col=(ct <- adjustcolor("brown", 0.6)), lty=3) axis(1, at=x12, labels=formatC(x12), padj = -3.2, hadj = -.1, tcl = +.8, col=ct, col.axis=ct, col.ticks=ct) @ % increasing width --> effective LaTeX *height* will decrease \setcapwidth{\textwidth}% \caption{Relative errors (via \pkg{Rmpfr}, see footnote of Fig.~\ref{fig:bigpic}) of four different ways to numerically compute $\log\bigl(1 + e^{x}\bigr)$. Vertical bars at $x_1 = 18$ and $x_2 = 33.3$ visualize the (2nd and 3rd) cutpoints of (\ref{eq:log1pexp}).} % Moved into text:|| down Note that the default method is fully accurate on this $x$ range. \label{fig:log1pexp} \end{figure} Figure~\ref{fig:log1pexp} visualizes the relative errors of the careless ``default'', $\log\bigl(1 + e^{x}\bigr)$, its straightforward correction $\loglp\bigl(e^x\bigr)$, the intermediate approximation $x + e^{-x}$, and the large $x$ ($ = x$), i.e., the methods in (\ref{eq:log1pexp}), depicting that the (easy to remember) cutoffs $x_1$ and $x_2$ in (\ref{eq:log1pexp}) are valid. %% moved from figure caption: Note that the default method is fully accurate on this $x$ range and only problematic when $e^x$ begins to overflow, i.e., $x > e_{\mathrm{Max}}$, which is <>= (eMax <- .Machine$double.max.exp * log(2)) exp(eMax * c(1, 1+1e-15)) @ where we see that indeed $e_{\mathrm{Max}} = $\code{eMax} is the maximal exponent without overflow. \section{Conclusion} We have used high precision arithmetic (\R{} package \pkg{Rmpfr}) to empirically verify that computing $f(a) = \log\left(1 - e^{-a}\right)$ is accomplished best via equation (\ref{eq:log1mexp}). In passing, we have also shown that accurate computation of $g(x) = \log(1+e^x)$ can be achieved via (\ref{eq:log1pexp}). % Note that %% FIXME: %% a short version of this note has been published .... %% \cite{....} a version of this note is available as vignette (in \texttt{Sweave}, i.e., with complete \R{} source) from the \pkg{Rmpfr} package vignettes. \subsection*{Session Information} \nopagebreak <>= toLatex(sessionInfo(), locale=FALSE) <>= options(op.orig) @ %\clearpage \bibliography{log1mexp} \end{document} Rmpfr/vignettes/Rmpfr.bib0000644000176200001440000000460012250313503015106 0ustar liggesusers@Manual{MM-Rmpfr_pkg, title = {Rmpfr: R MPFR - Multiple Precision Floating-Point Reliable}, author = {Martin Maechler}, year = 2011, url = {http://rmpfr.r-forge.r-project.org/}, note = {R package version 0.4-2} } @article{FouLHLPZ:2007, author = {Laurent Fousse and Guillaume Hanrot and Vincent Lef\`{e}vre and Patrick P\'{e}lissier and Paul Zimmermann}, title = {MPFR: A multiple-precision binary floating-point library with correct rounding}, year = 2007, journal = {ACM Trans. Math. Softw.}, volume = 33, number = 2, issn = {0098-3500}, pages = 13, url = {http://doi.acm.org/10.1145/1236463.1236468}, acmid = 1236468, publisher = {ACM}, address = {New York, NY, USA}, keywords = {IEEE 754 standard, Multiple-precision arithmetic, correct rounding, elementary function, floating-point arithmetic, portable software}, } @comment not with jss.bst: @comment doi = {http://doi.acm.org/10.1145/1236463.1236468}, @manual{FousseHLPZ-MPFR:2011, author = {Fousse, Laurent and Hanrot, Guillaume and Lef\`{e}vre, Vincent and P\'{e}lissier, Patrick and Zimmermann, Paul}, year = 2011, title = {MPFR: A multiple-precision binary floating-point library with correct rounding}, url = {http://mpfr.org/}, } % Bauer:1961:ARI:366573.366594, @article{Bauer-1961, author = {Bauer, F. L.}, title = {Algorithm 60: Romberg integration}, journal = {Commun. ACM}, year = 1961, volume = 4, issue = 6, month = {June}, issn = {0001-0782}, pages = 255, url = {http://doi.acm.org/10.1145/366573.366594}, doi = {http://doi.acm.org/10.1145/366573.366594}, acmid = 366594, publisher = {ACM}, address = {New York, NY, USA}, } @manual{GMP:2011, author = {Torbjörn Granlund and the GMP development team}, year = 2011, title = {GNU MP - The GNU Multiple Precision Arithmetic Library}, url = {http://gmplib.org/}, } % citation(package="sfsmisc") @Manual{maechler-sfsmisc, title = {sfsmisc: Utilities from Seminar fuer Statistik ETH Zurich}, author = {Martin Maechler}, year = 2012, note = {R package version 1.0-23}, url = {http://CRAN.R-project.org/package=sfsmisc}, } @Manual{maechler-Bessel, title = {Bessel: Bessel -- Bessel Functions Computations and Approximations}, author = {Martin Maechler}, year = 2012, note = {R package version 0.5-4}, url = {http://CRAN.R-project.org/package=Bessel}, } Rmpfr/vignettes/Maechler_useR_2011-abstr.Rnw0000644000176200001440000001227112174274363020346 0ustar liggesusers\documentclass[11pt, a4paper]{article} \usepackage{amsfonts, amsmath, hanging, hyperref, natbib, parskip, times} \usepackage[pdftex]{graphicx} \hypersetup{ colorlinks, linkcolor=blue, urlcolor=blue } \SweaveOpts{eps=FALSE,pdf=TRUE,width=7,height=4,strip.white=true,keep.source=TRUE} %\VignetteIndexEntry{useR-2011-abstract} %\VignetteDepends{Rmpfr} <>= options(SweaveHooks= list(fig=function() par(mar=c(5.1, 4.1, 1.1, 2.1))), width = 75) Sys.setenv(LANGUAGE = "en") if(.Platform$OS.type != "windows") Sys.setlocale("LC_MESSAGES","C") stopifnot(require("Rmpfr")) @ \let\section=\subsubsection \newcommand{\pkg}[1]{{\normalfont\fontseries{b}\selectfont #1}} \let\proglang=\textit \let\code=\texttt \renewcommand{\title}[1]{\begin{center}{\bf \LARGE #1}\end{center}} \newcommand{\affiliations}{\footnotesize} \newcommand{\keywords}{\paragraph{Keywords:}} \setlength{\topmargin}{-15mm} \setlength{\oddsidemargin}{-2mm} \setlength{\textwidth}{165mm} \setlength{\textheight}{250mm} \usepackage{Sweave} \DefineVerbatimEnvironment{Sinput}{Verbatim}{fontsize=\small,fontshape=sl} \DefineVerbatimEnvironment{Soutput}{Verbatim}{fontsize=\small} \DefineVerbatimEnvironment{Scode}{Verbatim}{fontsize=\small,fontshape=sl} % but when submitting, do get rid of too much vertical space between R % input & output, i.e. between Sinput and Soutput: \fvset{listparameters={\setlength{\topsep}{0pt}}}% !! quite an effect! %% % \newcommand*{\R}{\proglang{R}}%{\textsf{R}} \begin{document} \pagestyle{empty} \vspace*{-15ex} \begin{flushleft}\footnotesize Corrected abstract for ``late-breaking poster'' and ``Lightning talk'' to be held at ``UseR! 2011'', U.~Warwick, 16th Aug.~2011%, 17:00--18:00 \\[-1ex]\noindent\rule{\textwidth}{0.5pt}\\ % horizontal line \end{flushleft} \vspace*{+9ex} \title{Arbitrarily Accurate Computation with R: Package 'Rmpfr'} \begin{center} {\bf Martin M\"achler$^{1,2,^\star}$} \end{center} \begin{affiliations} 1. ETH Zurich (Seminar for Statistics), Switzerland \\[-2pt] 2. R Core Development Team \\[-2pt] $^\star$Contact author: \href{mailto:maechler@stat.math.ethz.ch}{maechler@stat.math.ethz.ch} \end{affiliations} \keywords Arbitrary Precision, High Accuracy, Multiple Precision Floating-Point, Rmpfr \vskip 0.8cm % Some suggestions: if you mention a programming language like % \proglang{R}, typeset the language name with the {\tt \textbackslash % proglang\{\}} command. If you mention an \proglang{R} function \code{foo}, % typeset the function name with the with the {\tt\textbackslash code\{\}} % command. If you mention an \proglang{R} package \pkg{fooPkg}, typeset % the package name with the {\tt\textbackslash pkg\{\}} command. % Abstracts should not exceed one page. The page should not be numbered. The \proglang{R}\ package \pkg{Rmpfr} allows to use arbitrarily precise numbers instead of \proglang{R}'s double precision numbers in many \proglang{R}\ computations and functions. This is achieved by defining S4 classes of such numbers and vectors, matrices, and arrays thereof, where all arithmetic and mathematical functions work via the (GNU) MPFR C library, where MPFR is acronym for ``\emph{\textbf{M}ultiple \textbf{P}recision \textbf{F}loating-Point \textbf{R}eliably}''\nocite{FousseHLPZ:2007}. MPFR is Free Software, available under the LGPL license\nocite{FousseHLPZ-MPFR:2011}, and itself is built on the free GNU Multiple Precision arithmetic library (GMP)\nocite{GMP:2011}. Consequently, by using \pkg{Rmpfr}, you can often call your \proglang{R}\ function or numerical code with mpfr--numbers instead of simple numbers, and all results will automatically be much more accurate. <>= options(digits = 17)# to print to full "standard R" precision .N <- function(.) mpfr(., precBits = 200) exp( 1 ) exp(.N(1)) <>= choose ( 200, 99:100 ) chooseMpfr( 200, 99:100 ) @ %% Applications by the package author include testing of Bessel or polylog functions and distribution computations, e.g. for stable distributions. %% In addition, the \pkg{Rmpfr} has been used on the \code{R-help} or \code{R-devel} mailing list for high-accuracy computations, e.g., in comparison with results from commercial software such as Maple, and in private communications with Petr Savicky about fixing \proglang{R} bug \href{https://bugs.R-project.org/bugzilla3/show_bug.cgi?id=14491}{\code{PR\#14491}}. We expect the package to be used in more situations for easy comparison studies about the accuracy of algorithms implemented in \proglang{R}, both for ``standard \proglang{R}'' and extension packages. %% references: \nocite{% MM-Rmpfr_pkg} %\bibliographystyle{chicago}%% how on earth do I get the URLs ??/ \bibliographystyle{jss}%% how on earth do I get the URLs ??/ \bibliography{Rmpfr} %% references can alternatively be entered by hand %\subsubsection*{References} %\begin{hangparas}{.25in}{1} %AuthorA (2007). Title of a web resource, \url{http://url/of/resource/}. %AuthorC (2008a). Article example in proceedings. In \textit{useR! 2008, The R %User Conference, (Dortmund, Germany)}, pp. 31--37. %AuthorC (2008b). Title of an article. \textit{Journal name 6}, 13--17. %\end{hangparas} \end{document} Rmpfr/R/0000755000176200001440000000000014552770135011552 5ustar liggesusersRmpfr/R/special-fun.R0000644000176200001440000006104514547030401014076 0ustar liggesusers## erf(), erfc() erf <- function(x) { if(is.numeric(x)) 2 * pnorm(x * sqrt(2)) - 1 else if(is.mpfr(x)) { # maybe also mpfrMatrix ##new("mpfr", .Call(Math_mpfr, x, .Math.codes[["erf"]])) x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["erf"]]) x } else stop("invalid class(x): ", class(x)) } ## pnorm(x* sqrt(2)) = (1 + erf(x))/2 ##==> pnorm(x.) = (1 + erf(x./sqrt(2)))/2 ## pnorm(x* sqrt(2), lower=FALSE) = erfc(x)/2 ##==> pnorm(x., lower=TRUE) = erfc(x./sqrt(2))/2 erfc <- function(x) { if(is.numeric(x)) 2 * pnorm(x * sqrt(2), lower.tail = FALSE) else if(is.mpfr(x)) { x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["erfc"]]) x } else stop("invalid class(x): ", class(x)) } pnorm <- function (q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE) { if(is.numeric(q) && is.numeric(mean) && is.numeric(sd)) stats__pnorm(q, mean, sd, lower.tail=lower.tail, log.p=log.p) else if((q.mp <- is.mpfr(q)) || is.mpfr(mean) || is.mpfr(sd)) { stopifnot(length(lower.tail) == 1L, length(log.p) == 1L) rr <- q <- ((if(q.mp) q else as(q, "mpfr")) - mean) / sd if(any(neg <- (q < 0))) ## swap those: Phi(-z) = 1 - Phi(z) rr[neg] <- pnorm(-q[neg], lower.tail = !lower.tail, log.p=log.p) if(any(pos <- !neg)) { q <- q[pos] #==> now q >= 0 prec.q <- max(.getPrec(q)) two <- mpfr(2, prec.q + 4L) Irt2 <- sqrt(mpfr(0.5, prec.q + 4L)) # 1 / sqrt(2) rr[pos] <- roundMpfr(precBits = prec.q, if(lower.tail) { if(log.p) { r <- q sml <- q < 0.67448975 if(any(sml)) { eq2 <- erf(q[sml]*Irt2) ## |eq2| < 1/2 <==> |q*Irt2| < 0.47693627620447 ## <==> sml <==> |q| < 0.67448975019608 r[ sml] <- log1p(eq2) - log(two) } if(any(!sml)) { ec2 <- erfc(q[!sml]*Irt2) ## ==> ec2 = 1-eq2 <= 1 - 1/2 = 1/2 r[!sml] <- log1p(-0.5*ec2) } r } else ## !log.p (1 + erf(q*Irt2))/2 } else { ## upper.tail r <- erfc(q*Irt2) / 2 if(log.p) log(r) else r }) } rr } else stop("(q,mean,sd) must be numeric or \"mpfr\"") }#{pnorm} dnorm <- function (x, mean = 0, sd = 1, log = FALSE) { if(is.numeric(x) && is.numeric(mean) && is.numeric(sd)) stats__dnorm(x, mean, sd, log=log) else if((x.mp <- is.mpfr(x)) || is.mpfr(mean) || is.mpfr(sd)) { ## stopifnot(length(log) == 1) prec <- pmax(53, getPrec(x), getPrec(mean), getPrec(sd)) if(!x.mp) x <- mpfr(x, prec) x <- (x - mean) / sd twopi <- 2*Const("pi", prec) ## f(x) = 1/(sigma*sqrt(2pi)) * exp(-1/2 x^2) if(log) ## log( f(x) ) = -[ log(sigma) + log(2pi)/2 + x^2 / 2] -(log(if(is.mpfr(sd)) sd else mpfr(sd, prec)) + (log(twopi) + x*x)/2) else exp(-x^2/2) / (sd*sqrt(twopi)) } else stop("invalid arguments (x,mean,sd)") } ## 'ncp': not yet -- checked in ../tests/special-fun-ex.R dt <- function (x, df, ncp, log = FALSE) { if(is.numeric(x) && is.numeric(df) && (missing(ncp) || is.numeric(ncp))) stats__dt(x, df, ncp, log=log) else if (missing(ncp) || all(ncp == 0)) { stopifnot(length(log) == 1) if((x.mp <- is.mpfr(x)) | (df.mp <- is.mpfr(df)) || missing(ncp) || is.mpfr(ncp)) { prec <- pmax(53L, getPrec(x), getPrec(df), if(missing(ncp)) 0L else getPrec(ncp)) if(! x.mp) x <- mpfr( x, prec) if(!df.mp) df <- mpfr(df, prec) twopi <- 2*Const("pi", prec) ## From Catherine Loader's comment in src/nmath/dt.c (n := df) : ## the following form should be "stable" ["contrary" to the direct formula]: ## ## f_n(x) = sqrt(n/2) / ((n+1)/2) * Gamma((n+3)/2) / Gamma((n+2)/2) ## * (1+x^2/n)^(-n/2) ## / sqrt( 2 pi (1+x^2/n) ) ## ## MM "FIXME": consider pkg 'DPQ's b_chi() and lb_chi() {and old c_nu()} ## --------- for the constant if(log) { log(df/2)/2 - log((df+1)/2) + lgamma((df+3)/2) - lgamma((df+2)/2) + (-df/2)*log1p(x^2/df) - log( twopi*(1+x^2/df) )/2 } else { sqrt(df/2) / ((df+1)/2) * gamma((df+3)/2) / gamma((df+2)/2) * (1+x^2/df)^(-df/2) / sqrt( twopi*(1+x^2/df) ) } } else stop("invalid arguments (x,df,ncp)") } else stop("ncp != 0 not yet implemented") } dpois <- function (x, lambda, log = FALSE, useLog = { ## MPFR overflow: ln2 <- log(2) any(lambda >= -.mpfr_erange("Emin")*ln2) || any(x*log(lambda) >= .mpfr_erange("Emax")*ln2) }) { if(is.numeric(x) && is.numeric(lambda)) ## standard R stats__dpois(x, lambda, log=log) else if((l.mp <- is.mpfr(lambda)) | (x.mp <- is.mpfr(x))) { prec <- pmax(53, getPrec(lambda), getPrec(x)) if(!l.mp) lambda <- mpfr(lambda, prec) if(!x.mp) x <- mpfr(x, prec) if(log || useLog) { ## NB: For large lambda, x ~= lambda this has a *LOT* of cancellation, e.g., for ## -- lambda = 1e100, prec = 256 is *NOT* sufficient !! r <- x + 0*lambda isI <- is.infinite(lambda) # & is.finite(x) # x <= lambda = +Inf r[ isI] <- if(log) -Inf else 0 ## "else" if(any(!isI)) { lambda <- lambda[!isI] x <- x[!isI] r[!isI] <- -lambda + x*log(lambda) - lfactorial(x) } if(log) r else exp(r) } else exp(-lambda) * lambda^x / factorial(x) } else stop("(x,lambda) must be numeric or \"mpfr\"") } dbinom <- function(x, size, prob, log = FALSE, useLog = any(abs(x) > 1e6) || ## MPFR overflow: max(x*log(prob), (size-x)*log1p(-prob)) >= .mpfr_erange("Emax")*log(2)) { if(is.numeric(x) && is.numeric(size) && is.numeric(prob)) ## standard R stats__dbinom(x, size, prob, log=log) else if((s.mp <- is.mpfr(size)) | (p.mp <- is.mpfr(prob)) | (x.mp <- is.mpfr(x))) { stopifnot(is.whole(x)) # R's dbinom() gives NaN's with a warning.. prec <- pmax(53, getPrec(size), getPrec(prob), getPrec(x)) # full prec(x) if(!is.integer(x) && !useLog) { xi <- as.integer(x) # chooseMpfr() needs it if(x.mp) (if(anyNA(xi) || any(xi != x)) stop else message)( "'x' coerced from \"mpfr\" to integer -- necessary for chooseMpfr()") x <- xi } if(!s.mp) size <- mpfr(size, prec) if(!p.mp) prob <- mpfr(prob, prec) ## n:= size, p:= prob, compute P(x) = choose(n, x) p^x (1-p)^(n-x) if(useLog) { # do *not* use chooseMpfr() {which is O(x^2)} lC.nx <- ## lchoose(size, x), but that is *not* yet available for "mpfr" __FIXME?__ lfactorial(size) - (lfactorial(x) + lfactorial(size-x)) } else { C.nx <- chooseMpfr(size, x) lC.nx <- log(C.nx) } if(log || useLog) { r <- lC.nx + x*log(prob) + (size-x)*log1p(-prob) if(log) r else exp(r) } else C.nx * prob^x * (1-prob)^(size-x) } else stop("(x,size, prob) must be numeric or \"mpfr\"") }## {dbinom} dnbinom <- function (x, size, prob, mu, log = FALSE, useLog = any(x > 1e6)) { if(!missing(mu)) { if (!missing(prob)) stop("'prob' and 'mu' both specified") ## Using argument 'mu' instead of 'prob' if (size == Inf) return( dpois(x, lambda=mu, log) ) else prob <- size/(size+mu) # and continue : } if(is.numeric(x) && is.numeric(size) && is.numeric(prob)) { ## standard R if(!missing(mu)) stats__dnbinom(x, size, mu=mu, log=log) else stats__dnbinom(x, size, prob=prob, log=log) } else if((s.mp <- is.mpfr(size)) | (p.mp <- is.mpfr(prob)) | (x.mp <- is.mpfr(x))) { stopifnot(is.whole(x)) # R's dbinom() gives NaN's with a warning.. prec <- pmax(53, getPrec(size), getPrec(prob), getPrec(x)) if(!is.integer(x) && !useLog) { xi <- as.integer(x) # chooseMpfr() needs it if(x.mp) (if(anyNA(xi) || any(xi != x)) stop else message)( "'x' coerced from \"mpfr\" to integer -- necessary for chooseMpfr()") x <- xi } if(!s.mp) size <- mpfr(size, prec) if(!p.mp) prob <- mpfr(prob, prec) if(!x.mp && !is.integer(x)) x <- mpfr(x, prec) ## n:= size, p:= prob, compute P(x) = choose(n+x-1, x) * p^n * (1-p)^x if(!useLog) { C.nx <- chooseMpfr(size+x-1, x) if(log || ## MPFR overflow: max(size*log(prob), x*log1p(-prob)) >= .mpfr_erange("Emax")*log(2)) { r <- log(C.nx) + size*log(prob) + x*log1p(-prob) if(log) r else exp(r) } else C.nx * prob^size * (1-prob)^x } else { # x not integer, typically |x| > .Machine$integer.max (= 2147483647 = 2^31 - 1) ## => x is large but size >= x is even larger ... so everything is large ## FIXME (?) suffering from cancellation (when ?) ! logC.nx <- lgamma(size+x) - lgamma(size) - lgamma(x+1) if(log) logC.nx + size*log(prob) + x*log1p(-prob) else exp(logC.nx + size*log(prob) + x*log1p(-prob)) } } else stop("(x,size, prob | mu) must be numeric or \"mpfr\"") }## {dnbinom} dgamma <- function(x, shape, rate = 1, scale = 1/rate, log = FALSE) { missR <- missing(rate) missS <- missing(scale) if (!missR && !missS) { ## as stats::dgamma() if (abs(rate * scale - 1) < 1e-15) warning("specify 'rate' or 'scale' but not both") else stop("specify 'rate' or 'scale' but not both") } ## and now use 'scale' only if(is.numeric(x) && is.numeric(shape) && is.numeric(scale)) stats__dgamma(x, shape, scale=scale, log=log) else if((sh.mp <- is.mpfr(shape)) | (sc.mp <- is.mpfr(scale)) || is.mpfr(x)) { ## f(x)= 1/(s^a Gamma(a)) x^(a-1) e^-(x/s) ; a=shape, s=scale ## log f(x) = -a*log(s) - lgamma(a) + (a-1)*log(x) - (x/s) if(!sh.mp || !sc.mp) { prec <- pmax(53, getPrec(shape), getPrec(scale), getPrec(x)) if(!sh.mp) shape <- mpfr(shape, prec) else ## !sc.mp : scale <- mpfr(scale, prec) } ## for now, "cheap", relying on "mpfr" arithmetic to be smart ## "TODO": Use C.Loader's formulae via dpois_raw() , bd0() etc ## lgam.sh <- lgamma(shape) ## ldgamma <- function(x, shp, s) -shp*log(s) -lgam.sh + (shp-1)*log(x) - (x/s) ldgamma <- function(x, shp, s) -shp*log(s) -lgamma(shp) + (shp-1)*log(x) - (x/s) if(log) ldgamma(x, shape, scale) else { ## use direct [non - log-scale] formula when applicable ## ok <- lgam.sh < log(2) * Rmpfr:::.mpfr.erange("Emax") & ## finite gamma(shape) := exp(lgam.sh) ## is.finite(xsh1 <- x^(shape-1)) & ## !is.na(r <- xsh1 * exp(-(x/scale)) / (scale^shape * exp(lgam.sh))) ## r[!ok] <- exp(ldgamma(x[!ok], shape[!ok], scale[!ok])) ## r exp(ldgamma(x, shape, scale)) } } else stop("(x, shape, scale) must be numeric or \"mpfr\"") }## {dgamma} ## zeta() zeta <- function(x) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") # keep "mpfrArray" x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["zeta"]]) x } ## "FIXME" -- rather use 'bigq' in gmp and the "sumBin" algorithm from copula! Bernoulli <- function(k, precBits = 128) { ## Purpose: Bernoulli Numbers (in high precision) ## ----------------------------------------------------------- ## Arguments: k: non-negative integer vector ## ----------------------------------------------------------- ## Author: Martin Maechler, Date: 12 Dec 2008, 11:35 stopifnot(all(k >= 0), k == as.integer(k)) r <- - k * zeta(if(is.mpfr(k)) 1 - k else mpfr(1 - k, precBits=precBits)) if(any(k0 <- k == 0)) r[k0] <- mpfr(1, precBits=precBits) r } ## eint() "Exponential integral" Ei <- function(x) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") # keep "mpfrArray" x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["Eint"]]) x } ## Li_2() the dilogarithm Li2 <- function(x) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") # keep "mpfrArray" x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["Li2"]]) x } ### ------------- Bessel: --------- ## j0, j1, jn ## y0, y1, yn j0 <- function(x) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") # keep "mpfrArray" x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["j0"]]) x } j1 <- function(x) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["j1"]]) x } y0 <- function(x) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["y0"]]) x } y1 <- function(x) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["y1"]]) x } Ai <- function(x) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") x@.Data[] <- .Call(Math_mpfr, x, .Math.codes[["Ai"]]) x } jn <- function(n, x, rnd.mode = c('N','D','U','Z','A')) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") x@.Data[] <- .Call(R_mpfr_jn, x, n, match.arg(rnd.mode)) x } yn <- function(n, x, rnd.mode = c('N','D','U','Z','A')) { if(!inherits(x, "mpfr")) x <- as(x, "mpfr") x@.Data[] <- .Call(R_mpfr_yn, x, n, match.arg(rnd.mode)) x } ###-------- 2-argument cases ------- ## We want to automatically construct the methods needed: ## But atan2() as argument list and signature (y, x) ## where beta() and lbeta() have (a,b) --> cannot treat them identically; ## and treat atan2() speparately ## NB: atan2(), beta() and lbeta() all have implicitGeneric()s in methods with no '...' ## == ---> canNOT have 3rd argument : rnd.mode = c('N','D','U','Z','A') ## ---> using "N" instead of match.arg(rnd.mode) setMethod("atan2", signature(y = "mpfr", x = "mpfr"), function(y, x) new("mpfr", .Call(R_mpfr_atan2, y, x, "N"))) setMethod("atan2", signature(y = "mpfr", x = "numeric"), function(y, x) new("mpfr", .Call(R_mpfr_atan2, y, .mpfr(x, 128L), "N"))) setMethod("atan2", signature(y = "numeric", x = "mpfr"), function(y, x) new("mpfr", .Call(R_mpfr_atan2, .mpfr(y, 128L), x, "N"))) setMethod("atan2", signature(y = "mpfr", x = "ANY"), function(y, x) new("mpfr", .Call(R_mpfr_atan2, y, as(x, "mpfr"), "N"))) setMethod("atan2", signature(y = "ANY", x = "mpfr"), function(y, x) new("mpfr", .Call(R_mpfr_atan2, as(y, "mpfr"), x, "N"))) setMethod("atan2", signature(y = "mpfrArray", x = "mpfrArray"), function(y, x) { if(dim(x) != dim(y)) stop("array dimensions differ") x@.Data[] <- .Call(R_mpfr_atan2, y, x, "N") x }) setMethod("atan2", signature(y = "mpfrArray", x = "ANY"), function(y, x) { if(length(y) %% length(x) != 0) stop("length of first argument (array) is not multiple of the second argument's one") y@.Data[] <- .Call(R_mpfr_atan2, y, if(is.numeric(x)) .mpfr(x, 128L) else as(x, "mpfr"), "N") y }) setMethod("atan2", signature(y = "ANY", x = "mpfrArray"), function(y, x) { if(length(x) %% length(y) != 0) stop("length of second argument (array) is not multiple of the first argument's one") x@.Data[] <- .Call(R_mpfr_atan2, if(is.numeric(y)) .mpfr(y, 128L) else as(y, "mpfr"), x, "N") x }) ## Using "macro" {instead of previous aux. function mpfrMath2setMeth.a.b() : for (ff in list(c("beta", "R_mpfr_beta"), c("lbeta", "R_mpfr_lbeta"))) eval(substitute( { setMethod(fname, signature(a = "mpfr", b = "mpfr"), function(a, b) new("mpfr", .Call(Csub, a, b, "N"))) setMethod(fname, signature(a = "mpfr", b = "numeric"), function(a, b) new("mpfr", .Call(Csub, a, .mpfr(b, 128L), "N"))) setMethod(fname, signature(a = "numeric", b = "mpfr"), function(a, b) new("mpfr", .Call(Csub, .mpfr(a, 128L), b, "N"))) setMethod(fname, signature(a = "mpfr", b = "ANY"), function(a, b) new("mpfr", .Call(Csub, a, as(b, "mpfr"), "N"))) setMethod(fname, signature(a = "ANY", b = "mpfr"), function(a, b) new("mpfr", .Call(Csub, as(a, "mpfr"), b, "N"))) setMethod(fname, signature(a = "mpfrArray", b = "mpfrArray"), function(a, b) { if(dim(b) != dim(a)) stop("array dimensions differ") b@.Data[] <- .Call(Csub, a, b, "N") b }) setMethod(fname, signature(a = "mpfrArray", b = "ANY"), function(a, b) { if(length(a) %% length(b) != 0) stop("length of first argument (array) is not multiple of the second argument's one") a@.Data[] <- .Call(Csub, a, if(is.numeric(b)) .mpfr(b, 128L) else as(b, "mpfr"), "N") a }) setMethod(fname, signature(a = "ANY", b = "mpfrArray"), function(a, b) { if(length(b) %% length(a) != 0) stop("length of second argument (array) is not multiple of the first argument's one") b@.Data[] <- .Call(Csub, if(is.numeric(a)) .mpfr(a, 128L) else as(a, "mpfr"), b, "N") b }) }, list(fname = ff[[1]], Csub = as.symbol(ff[[2]])))) ## hypot() hypot <- function(x,y, rnd.mode = c('N','D','U','Z','A')) { if(is(x, "mpfrArray") || is.array(x)) { if(is.array(x)) x <- mpfrArray(x, 128L, dim=dim(x), dimnames(x)) if(is.array(y)) y <- mpfrArray(y, 128L, dim=dim(y), dimnames(y)) if(is(y, "mpfrArray")) { if(dim(x) != dim(y)) stop("array dimensions differ") x@.Data[] <- .Call(R_mpfr_hypot, x, y, match.arg(rnd.mode)) x } else { ## y is not (mpfr)Array if(length(x) %% length(y) != 0) stop("length of first argument (array) is not multiple of the second argument's one") x@.Data[] <- .Call(R_mpfr_hypot, x, as(y, "mpfr"), match.arg(rnd.mode)) x } } else if(is(y, "mpfrArray")) { if(length(y) %% length(x) != 0) stop("length of second argument (array) is not multiple of the first argument's one") y@.Data[] <- .Call(R_mpfr_hypot, as(x, "mpfr"), y, match.arg(rnd.mode)) y } else new("mpfr", .Call(R_mpfr_hypot, as(x, "mpfr"), as(y, "mpfr"), match.arg(rnd.mode))) } ## The Beta(a,b) Cumulative Probabilities are exactly computable for *integer* a,b: pbetaI <- function(q, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE, precBits = NULL, useRational = !log.p && !is.mpfr(q) && is.null(precBits) && int2, rnd.mode = c('N','D','U','Z','A')) { stopifnot(length(shape1) == 1, length(shape2) == 1, (i1 <- is.whole(shape1)) | (i2 <- is.whole(shape2)), shape1 >= 0, shape2 >= 0, length(lower.tail) == 1, length(log.p) == 1, 0 <= q, q <= 1, ncp == 0, is.null(precBits) || (is.numeric(precBits) && is.whole(precBits) && precBits >= 2)) int2 <- i1 && i2 # both integer -> can use rational ### TODO: Also have finite (but non-rational) sum if only *one* is an integer number ### ---- ## Care for too large (a,b) and "integer overflow". ## NB: below have 0:(b - 1) or 0:(a - 1) max.ab <- 2^20 if(is.na(a <- as.integer(shape1)) || (!lower.tail && a > max.ab)) stop("a = shape1 is too large for 'lower.tail=FALSE' and the current algorithm") if(is.na(b <- as.integer(shape2)) || (lower.tail && b > max.ab)) stop("b = shape2 is too large for 'lower.tail=TRUE' and the current algorithm") n <- a + b - 1L if(!useRational) { pr.x <- getPrec(q, bigq. = 256L) if(is.null(precBits)) { aq <- abs(as.numeric(q)) mq <- if(any(po <- aq > 0)) min(aq[po]) else 1 # ==> log = 0 ## -n*log(|x|): such that 1 - |x|^n does not completely cancel precBits <- max(128L, pr.x, -as.numeric(n)*log(mq)) } if(pr.x < precBits || !is.mpfr(q)) q <- mpfr(q, precBits=precBits) mpfr1 <- list(.Call(const_asMpfr, 1, 16L, "N")) # as prototype for vapply() } F <- if(log.p) log else identity ## FIXME: logspace add sum lsum(.) should be more accurate for large n ==> could use larger a,b if(lower.tail) { ## The prob. is P[ X <= x ] = \sum_{k=a}^ n (n \\ k) x^k (1-x)^(n-k) ## but we want to sum from 0 {smallest --> largest} as well: ## P[ X <= x ] = \sum_{k=0}^{b-1} (n \\ k) (1-x)^k x^(n-k) k <- 0:(b - 1L) FUN.x <- function(x) sum(n.choose.k * (1-x)^k * x^(n-k)) } else { ## upper tail ## Prob. P[ X > q ] = 1 - P[X <= q ] = \sum_{k=0}^{a-1} (n \\ k) x^k (1-x)^(n-k) k <- 0:(a - 1L) FUN.x <- function(x) sum(n.choose.k * x^k * (1-x)^(n-k)) } n.choose.k <- chooseZ(n, k) if(useRational) { q <- as.bigq(q) if(length(q) == 1L) FUN.x(q) else c_bigq(lapply(q, FUN.x)) } else { # mpfr roundMpfr(F( ## "vapply() for "mpfr" new("mpfr", vapply(q, FUN.x, mpfr1))), ## reduce the precision, in order to not "claim wrongly": precBits=precBits, match.arg(rnd.mode)) } } ## TODO 1) add (and test) R mpfr version R's bpser() in toms708.c ## 2) compare with bpser() from package DPQ which should have more flexible variant ## ~/R/Pkgs/DPQ/R/beta-fns.R & ~/R/Pkgs/DPQ/src/bpser.c pbeta_ser <- function(q, shape1, shape2, log.p=FALSE) { } ### MPFR version >= 3.2.0 : "https://www.mpfr.org/mpfr-current/mpfr.html#index-mpfr_005fgamma_005finc" ## ## >>> Note: the current implementation of mpfr_gamma_inc is slow for large values of rop or op, ## >>> ==== in which case some internal overflow might also occur. ## ## mpfr_gamma_inc(a,x) =: igamma(a,x) where ## ## igamma(a,x) = "upper" incomplete gamma Γ(a,x) :=: Γ(a) - γ(a,x); ## γ(a,x) = "lower" incomplete gamma γ(a,x) := ₀∫ˣ tᵃâ»Â¹ eâ»áµ— dt, and ## R's pgamma(x, a) :== γ(a,x) / Γ(a) ## ## >>> ../man/igamma.Rd <<< igamma <- function(a,x, rnd.mode = c('N','D','U','Z','A')) { if(mpfrVersion() < "3.2.0") stop("igamma()'s MPFR equivalent needs mpfr version >= 3.2.0, but mpfrVersion()=", mpfrVersion()) if(is(a, "mpfrArray") || is.array(a)) { if(is.array(a)) a <- mpfrArray(a, 128L, dim=dim(a), dimnames(a)) if(is.array(x)) x <- mpfrArray(x, 128L, dim=dim(x), dimnames(x)) if(is(x, "mpfrArray")) { if(dim(a) != dim(x)) stop("array dimensions differ") a@.Data[] <- .Call(R_mpfr_igamma, a, x, match.arg(rnd.mode)) a } else { ## x is not (mpfr)Array if(length(a) %% length(x) != 0) stop("length of first argument (array) is not multiple of the second argument's one") a@.Data[] <- .Call(R_mpfr_igamma, a, as(x, "mpfr"), match.arg(rnd.mode)) a } } else if(is(x, "mpfrArray")) { if(length(x) %% length(a) != 0) stop("length of second argument (array) is not multiple of the first argument's one") x@.Data[] <- .Call(R_mpfr_igamma, as(a, "mpfr"), x, match.arg(rnd.mode)) x } else new("mpfr", .Call(R_mpfr_igamma, as(a, "mpfr"), as(x, "mpfr"), match.arg(rnd.mode))) } ## only as long as we still may have mpfrVersion() < "3.2.0", e.g. in Fedora 30 (2019f) ## mpfrVersion() cannot be called at package build time (underlying C entry point not ready): ## if(mpfrVersion() < "3.2.0") ## dummy .. to pacify "R CMD check" ## R_mpfr_igamma <- quote(dummy) # gives NOTE ‘R_mpfr_igamma’ is of class "name" ## These are identical from package copuula/R/special-func.R -- where MM authored the function also: ## We want to export these, but cannot easily import from copula which "weekly depends" on Rmpfr ##' @title Compute f(a) = log(1 - exp(-a)) stably ##' @param a numeric vector of positive values ##' @param cutoff log(2) is optimal, see Maechler (201x) ..... ##' @return f(a) == log(1 - exp(-a)) == log1p(-exp(-a)) == log(-expm1(-a)) ##' @author Martin Maechler, May 2002 .. Aug. 2011 ##' @references Maechler(2012) ##' Accurately Computing log(1 - exp(-|a|)) Assessed by the Rmpfr package. ##' http://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf ## MM: ~/R/Pkgs/Rmpfr/inst/doc/log1mexp-note.Rnw ##--> ../man/log1mexp.Rd log1mexp <- function(a, cutoff = log(2)) ## << log(2) is optimal >> { if(has.na <- any(ina <- is.na(a))) { y <- a a <- a[ok <- !ina] } if(any(a < 0))## a == 0 --> -Inf (in both cases) warning("'a' >= 0 needed") tst <- a <= cutoff r <- a r[ tst] <- log(-expm1(-a[ tst])) r[!tst] <- log1p(-exp(-a[!tst])) if(has.na) { y[ok] <- r ; y } else r } ##' @title Compute f(x) = log(1 + exp(x)) stably and quickly ##--> ../man/log1mexp.Rd log1pexp <- function(x, c0 = -37, c1 = 18, c2 = 33.3) { if(has.na <- any(ina <- is.na(x))) { y <- x x <- x[ok <- !ina] } r <- exp(x) if(any(i <- c0 < x & (i1 <- x <= c1))) r[i] <- log1p(r[i]) if(any(i <- !i1 & (i2 <- x <= c2))) r[i] <- x[i] + 1/r[i] # 1/exp(x) = exp(-x) if(any(i3 <- !i2)) r[i3] <- x[i3] if(has.na) { y[ok] <- r ; y } else r } Rmpfr/R/zzz.R0000644000176200001440000000247714022105500012520 0ustar liggesusers## Not exported, and only used because CRAN checks must be faster doExtras <- function() { interactive() || nzchar(Sys.getenv("R_Rmpfr_check_extra")) || identical("true", unname(Sys.getenv("R_PKG_CHECKING_doExtras"))) } .onAttach <- function(libname, pkgname) { packageStartupMessage(sprintf("C code of R package 'Rmpfr': GMP using %d bits per limb\n", .mpfr_gmp_numbbits())) } .onLoad <- function(libname, pkgname) { if(mpfrVersion() < "3.0.0") warning("MPFR C library version ", format(mpfrVersion()), " is outdated, and minor functionality will be missing.\n", " Consider installing a newer version of MPFR (e.g., from mpfr.org),\n", " and re-install the R package Rmpfr after that.", call.=FALSE) } if(packageVersion("gmp") < "0.6-1") local({ ## need c_bigz() and c_bigq() already now env <- asNamespace("gmp") getGmp <- function(x) get(x, envir=env, inherits=FALSE) biginteger_c <- getGmp("biginteger_c") bigrational_c <- getGmp("bigrational_c") rm(env, getGmp) c_bigz <<- function(L) .Call(biginteger_c, L) c_bigq <<- function(L) .Call(bigrational_c, L) }) if(getRversion() < "4.0") { ## deparse(.) returning *one* string deparse1 <- function(expr, collapse = " ", width.cutoff = 500L, ...) paste(deparse(expr, width.cutoff, ...), collapse=collapse) } Rmpfr/R/gmp-convert.R0000644000176200001440000000706514552770112014141 0ustar liggesusers#### Conversions bigz <-> mpfr // also bigq <--> mpfr if(packageVersion("gmp") < "0.5.8")## <-> ../NAMESPACE is.matrixZQ <- function(x) !is.null(attr(x, "nrow")) ## The following code is experimental, hence the "." : ### FIXME: we go via character.. which is not really efficient. ## ------ rather "should" use MPFR Functions ## int mpfr_set_z (mpfr_t ROP, mpz_t OP, mpfr_rnd_t RND) ## int mpfr_set_q (mpfr_t ROP, mpq_t OP, mpfr_rnd_t RND) ## ## Set the value of ROP from OP, rounded toward the given direction RND. ## ## Directly in C, we'd need both Rmpfr and gmp's C code (!) ## TODO(?: gmp should "export" its C++ API ( -> inst/include/*.hh ) ## and we should add 'LinkingTo: gmp' to DESCRIPTION and ## then use C++ with "C" { ...} for those parts .bigz2mpfr <- function(x, precB = NULL, rnd.mode = c('N','D','U','Z','A')) { stopifnot(inherits(x, "bigz")) ..bigz2mpfr(x, precB, rnd.mode) } ## Fast, no-checking (and not exported) version: ..bigz2mpfr <- function(x, precB = NULL, rnd.mode = c('N','D','U','Z','A')) ## precB: 4 == log2(16) = log(base) { stopifnot(is.character(rnd.mode <- toupper(rnd.mode))) rnd.mode <- match.arg(rnd.mode) b <- 16L cx <- .as.char.bigz(x, b) if(is.null(precB)) precB <- 4L*nchar(cx) if(is.matrixZQ(x)) new("mpfrMatrix", .Call(str2mpfr1_list, cx, precB, b, rnd.mode), Dim = as.integer(dim(x)))# "bigz" has no dimnames else new("mpfr", .Call(str2mpfr1_list, cx, precB, b, rnd.mode)) } setAs("bigz", "mpfr", function(from) ..bigz2mpfr(from)) ## FIXME: rather should use MPFR -- Function : ## ---- int mpfr_get_z (mpz_t ROP, mpfr_t OP, mpfr_rnd_t RND) ## Convert OP to a `mpz_t', after rounding it with respect to RND. .... ## FIXME(2): should 'gmp' change as.bigz into an S3 generic, so this becomes S3 method? as.bigz.mpfr <- .mpfr2bigz <- function(x, mod=NA) { if(is.null(mod)) mod <- NA_integer_ stopifnot(is.mpfr(x), is.na(mod) || (length(mod) == 1L && is.numeric(mod))) dx <- dim(x) ### FIXME or rather roundMpfr() [or even round "RND" as in mpfr_get_z() above] ?? cx <- format(trunc(x), scientific=FALSE, drop0trailing=TRUE) if(!is.null(dx <- dim(x))) dim(cx) <- dx ## needed?? {should *not* be, as in base R!} ..as.bigz(cx, mod) } setAs("mpfr", "bigz", function(from) .mpfr2bigz(from)) ## Fast, no-checking (and not exported) version: ..bigq2mpfr <- function(x, precB = NULL, rnd.mode = c('N','D','U','Z','A')) { stopifnot(is.character(rnd.mode <- toupper(rnd.mode))) rnd.mode <- match.arg(rnd.mode) N <- numerator(x) D <- denominator(x) if(is.null(precB)) { eN <- frexpZ(N)$exp eD <- frexpZ(D)$exp precB <- pmax(128L, eN + eD + 1L) # precision of result } ..bigz2mpfr(N, precB, rnd.mode) / ..bigz2mpfr(D, precB, rnd.mode) } .bigq2mpfr <- function(x, precB = NULL, rnd.mode = c('N','D','U','Z','A')) { stopifnot(inherits(x, "bigq")) ..bigq2mpfr(x, precB, rnd.mode) } setAs("bigq", "mpfr", function(from) ..bigq2mpfr(from)) ## not exported ##' @title get denominator 'd' of m = n/d ##' @param m an mpfr number vector ##' @return the denominator 'd' (also mpfr vector) ##' @author Martin Maechler getDenom <- function(m) { ## stopifnot(is.mpfr(m)) e <- pmax(0L, -.mpfr2exp(m)) # 2-exponents to multiply with; integer *iff* .... pre <- getPrec(m) mpfr(2, pre)^(e + pre) ## MM: it *seems* that (e + pre -1) works too ? } ## relies on .mpfr2bigz() above {which has TODO s !} .mpfr2bigq <- function(x) { stopifnot(is.mpfr(x)) d <- getDenom(x) as.bigq(.mpfr2bigz(x*d), .mpfr2bigz( d )) } Rmpfr/R/AllClasses.R0000644000176200001440000001534414533333542013726 0ustar liggesusers#### All Class Definitions in package "Rmpfr" ### Historically, we have used /usr/local/app/R/R_local/src/Brobdingnag/R/brob.R ### as partial role image ----------- ## NB: Most MPFR numbers are regular (C: mpfr_regular_p ) ## == ---> then 'd' is well defined. ## If they are not, i.e., it is in {0, NaN, +/- Inf}, then 'exp' shows this ## and 'd' (in mpfr a pointer to the limbs) is *not* used and not defined. ## Since Jan.2018, Rmpfr 0.7-0, we reflect this by using a 0-length 'd' slot long_is_4b <- (.Machine$sizeof.long == 4L) # long = 32 bit, on Windows if(long_is_4b) specExps <- 2:0 - bitwShiftR(-1L, 1L) # -2147483647 -2147483646 -2147483645 (integer) setClass("mpfr1", ## a single Multi-precision float number slots = c(prec = "integer", # precision in bits exp = "integer", # exponent sign= "integer", # signum d = "integer"), # the mantissa as a vector of (32 bit) integers validity = function(object) { gmp.numb <- .mpfr_gmp_numbbits() # 32 or 64 if(length(pr <- object@prec) != 1 || is.na(pr) || pr < 2) "invalid 'prec' slot" else if((lex <- length(ex <- object@exp)) != 2 && gmp.numb == 64) "invalid 'exp' slot for 64-bit gmp.numbbits: must have length 2" else if(lex != 1 && gmp.numb == 32) "invalid 'exp' slot for 32-bit gmp.numbbits: must have length 1" else if(length(sig <- object@sign) != 1 || is.na(sig) || abs(sig) > 1) "'sign' slot not in {-1,1} is invalid" else { nd <- length(d <- object@d) if(nd) { ## "regular" need.d <- ceiling(pr / 32) if((gmp.numb == 32 && nd != need.d) || (gmp.numb == 64 && !any((nd - need.d) == 0:1))) "length('d' slot) does not match 'prec'" else TRUE } else ## not regular: valid if exp slot shows so if(gmp.numb == 64) { ## ex of length 2 if((long_is_4b && ## Windows ((ex[1] == ex[2] && any(ex[1] == specExps)) || ## mpfr 3.1.3, "old" R/Rtools ( -1L == ex[2] && any(ex[1] == specExps))) ## new Rtools (2023) ) || (!long_is_4b && (is.na(ex[2]) && any(ex[[1]] == (1:3)))) ## mpfr 3.1.5, Fedora 26++ ) TRUE else if(.Platform$endian != "little") { message(gettextf("@exp possibly invalid for non-regular number _or_ it seems so on a platform with endian=\"%s\". Please report to maintainer(\"Rmpfr\")", .Platform$endian), domain=NA) TRUE } else sprintf("@exp invalid for non-regular number (64b, le(d) == 0, |long|=%d bytes)", .Machine$sizeof.long) } else { ## gmp.numb == 32: 'exp' slot of length one if(any(ex+2^31 == 1:3)) TRUE else sprintf("@exp invalid for non-regular number (32b, le(d) == 0, |long|=%d bytes)", .Machine$sizeof.long) } } }) setClass("mpfr", ## a *vector* of "mpfr1", i.e., multi-precision float numbers contains = "list", ## of "mpfr1" entries: validity = function(object) { ## should be fast ( ==> not using is(., "mpfr1") ) : if(all(lengths(cls <- lapply(object@.Data, class)) == 1L) && all(unlist(cls) == "mpfr1")) return(TRUE) ## else "Not all components are of class 'mpfr1'" }) setClass("mpfrArray", ## mpfr + "dim" + dimnames contains = "mpfr", slots = c(Dim = "integer", Dimnames = "list"), prototype = prototype(new("mpfr"), Dim= 0L), validity = function(object) { if(length(object) != prod(D <- object@Dim)) "Dimension does not match length()" else if(length(DN <- object@Dimnames) != length(D)) "Dimnames must have same length as 'Dim'" else if(any(hasN <- !vapply(DN, is.null, NA)) && any(lengths(DN[hasN]) != D[hasN])) "length of some 'Dimnames' do not match 'Dim'" else TRUE }) setMethod("initialize", "mpfrArray", function(.Object, ..., Dim, Dimnames) { if(!missing(Dim)) .Object@Dim <- as.integer(Dim) k <- length(.Object@Dim) if(missing(Dimnames)) .Object@Dimnames <- rep(list(NULL), k) else if(length(Dimnames) != k) { message(sprintf("in initialize: length(Dimnames) != k = %d; setting to NULL",k)) .Object@Dimnames <- rep(list(NULL), k) } else .Object@Dimnames <- Dimnames callNextMethod() }) setClass("mpfrMatrix", contains = "mpfrArray", prototype = prototype(new("mpfrArray"), Dim= c(0L,0L), Dimnames = list(NULL, NULL)), validity = function(object) { if(length(object@Dim) != 2L) "'Dim' is not of length 2" else TRUE }) ## "atomic vectors" (-> ?is.atomic ) -- exactly as in "Matrix": ## --------------- setClassUnion("atomicVector", ## "double" is not needed, and not liked by some members = c("logical", "integer", "numeric", "complex", "raw", "character")) ## This is tricky ... ## With the following class, arrays/matrices are covered as ## they are also with "vector" already. *However*, they are ## *not* made into vectors in method dispatch, ## which they would be if we used simply "vector" setClassUnion("array_or_vector", members = c("array", "matrix", "atomicVector")) ## However (FIXME?), the above is too large: "matrix" extends "vector" ## and that has "character", "list", ... ## For this class, we want to define '...' methods for cbind & rbind : ## FIXME(?): "array_or_vector" also contains "character" ## (and even if it wouldn't, a "matrix" could have "character" entries!) setClassUnion("Mnumber", members = c("array_or_vector", # *but* must be numeric-like "mpfr", "mpfrArray", "mpfrMatrix", ## from package 'gmp' : "bigz", "bigq")) if(FALSE) { ## if we did this, then ... {see below} setValidity("Mnumber", function(object) { if(is.numeric(object) || is.logical(object) || is.mpfr(object)) return(TRUE) ## else "Not a valid 'Mnumber' class object" }) ## ...., then, the following would fail (!) validObject( new("character", LETTERS) ) } ###----- Simpler {without 'matrix' -> 'character' ...} ------------------------- ### setClassUnion("numericVector", members = c("logical", "integer", "numeric")) setClassUnion("mNumber", members = c("numericVector", "mpfr", "mpfrArray", "mpfrMatrix", ## from package 'gmp' : "bigz", "bigq")) setValidity("mNumber", function(object) { if(is.numeric(object) || is.logical(object) || is.mpfr(object)) return(TRUE) ## else "Not a valid 'mNumber' class object" }) Rmpfr/R/optimizers.R0000644000176200001440000001334513735036657014116 0ustar liggesusers## From: Hans W Borchers ## To: Martin Maechler ## Subject: optimizeR for Rmpfr ## Date: Sun, 3 Jun 2012 16:58:12 +0200 ## This is from Hans' pracma package, ## /usr/local/app/R/R_local/src/pracma/R/golden_ratio.R ## but there's also fibonacci search, direct1d, .... optimizeR <- function(f, lower, upper, ..., tol = 1e-20, method = c("Brent", "GoldenRatio"), maximum = FALSE, precFactor = 2.0, precBits = -log2(tol) * precFactor, maxiter = 1000, trace = FALSE) { stopifnot(length(lower) == 1, length(upper) == 1, lower <= upper) fun <- match.fun(f) f <- if(maximum) function(x) -fun(x, ...) else function(x) fun(x, ...) a <- if(!is.mpfr(lower)) mpfr(lower, precBits = precBits) else if(.getPrec(lower) < precBits) roundMpfr(lower, precBits) b <- if(!is.mpfr(upper)) mpfr(upper, precBits = precBits) else if(.getPrec(upper) < precBits) roundMpfr(upper, precBits) method <- match.arg(method) n <- 0; convergence <- TRUE ## if(method == "GoldenRatio") { switch(method, "GoldenRatio" = { ## golden ratio phi <- 1 - (sqrt(mpfr(5, precBits = precBits)) - 1)/2 x <- c(a, a + phi*(b-a), b - phi*(b-a), b) y2 <- f(x[2]) y3 <- f(x[3]) while ((d.x <- x[3] - x[2]) > tol) { n <- n + 1 if(trace && n %% trace == 0) message(sprintf("it.:%4d, delta(x) = %12.8g", n, as.numeric(d.x))) if (y3 > y2) { x[2:4] <- c(x[1]+phi*(x[3]-x[1]), x[2:3]) y3 <- y2 y2 <- f(x[2]) } else { x[1:3] <- c(x[2:3], x[4]-phi*(x[4]-x[2])) y2 <- y3 y3 <- f(x[3]) } if (n > maxiter) { warning(sprintf("not converged in %d iterations (d.x = %g)", maxiter, as.numeric(d.x))) convergence <- FALSE break } } xm <- (x[2]+x[3])/2 fxm <- if (abs(f. <- f(xm)) <= tol^2) 0. else f. }, "Brent" = { ##--- Pure R version (for "Rmpfr") of R's fmin() C code. ## The method used is a combination of golden section search and ## successive parabolic interpolation. convergence is never much slower ## than that for a Fibonacci search. If f has a continuous second ## derivative which is positive at the minimum (which is not at ax or ## bx), then convergence is superlinear, and usually of the order of ## about 1.324.... ## The function f is never evaluated at two points closer together ## than eps*abs(fmin)+(tol/3), where eps is the square ## root of 2^-precBits. if f is a unimodal ## function and the computed values of f are always unimodal when ## separated by at least eps*abs(x)+(tol/3), then fmin approximates ## the abcissa of the global minimum of f on the interval ax,bx with ## an error less than 3*eps*abs(fmin)+tol. if f is not unimodal, ## then fmin may approximate a local, but perhaps non-global, minimum to ## the same accuracy. ## This function subprogram is a slightly modified version of the ## Algol 60 procedure localmin given in Richard Brent, Algorithms for ## Minimization without Derivatives, Prentice-Hall, Inc. (1973). ## c is the squared inverse of the golden ratio c <- (3 - sqrt(mpfr(5, precBits = precBits))) / 2 eps <- 2^-precBits tol1 <- 1+eps # the smallest 1.000... > 1 eps <- sqrt(eps) w <- v <- x <- a + c * (b - a) fw <- fv <- fx <- f(x) d <- e <- 0 tol3 <- tol / 3 ## main loop starts here ----------------------------------- repeat { n <- n+1 xm <- (a + b) /2 tol1 <- eps * abs(x) + tol3 t2 <- tol1 * 2 ## check stopping criterion if (abs(x - xm) <= t2 - (d.x <- (b - a)/2)) break if (n > maxiter) { warning(sprintf("not converged in %d iterations (d.x = %g)", maxiter, as.numeric(d.x))) convergence <- FALSE break } p <- q <- r <- 0 if (abs(e) > tol1) { ## fit parabola r <- (x - w) * (fx - fv) q <- (x - v) * (fx - fw) p <- (x - v) * q - (x - w) * r q <- (q - r) * 2 if (q > 0) p <- -p else q <- -q r <- e; e <- d } if(doTr <- (trace && n %% trace == 0)) msg <- sprintf("it.:%4d, x = %-19.12g, delta(x) = %9.5g", n, as.numeric(x), as.numeric(d.x)) if (abs(p) >= abs(q/2 * r) || p <= q * (a - x) || p >= q * (b - x)) { ## a golden-section step e <- (if(x < xm) b else a) - x d <- c * e if(doTr) msg <- paste(msg, "+ Golden-Sect.") } else { ## a parabolic-interpolation step d <- p / q u <- x + d if(doTr) msg <- paste(msg, "+ Parabolic") ## f must not be evaluated too close to ax or bx if (u - a < t2 || b - u < t2) { d <- tol1 if (x >= xm) d <- -d } } if(doTr) message(msg) ## f must not be evaluated too close to x u <- x + if(abs(d) >= tol1) d else if(d > 0) tol1 else -tol1 fu <- f(u) ## update a, b, v, w, and x if (fu <= fx) { if (u < x) b <- x else a <- x v <- w; w <- x; x <- u fv <- fw; fw <- fx; fx <- fu } else { if (u < x) a <- u else b <- u if (fu <= fw || w == x) { v <- w; fv <- fw w <- u; fw <- fu } else if (fu <= fv || v == x || v == w) { v <- u; fv <- fu } } } ## end {repeat} main loop xm <- x; fxm <- fx }, ## end{ "Brent" } stop(sprintf("Method '%s' is not implemented (yet)", method))) c(if(maximum)list(maximum = xm) else list(minimum = xm), list(objective = fxm, iter = n, convergence = convergence, estim.prec = abs(d.x), method=method)) } Rmpfr/R/Consts.R0000644000176200001440000000100112561376373013142 0ustar liggesusersConst <- function(name = c("pi", "gamma", "catalan", "log2"), prec = 120L, rnd.mode = c('N','D','U','Z','A')) { stopifnot(is.numeric(prec)) if(is.na(i <- pmatch(name, eval(formals()$name)))) stop("'name' must be one of ", paste(paste("'",eval(formals()$name),"'",sep=""), collapse=", ")) new("mpfr", list(.Call(const_asMpfr, i, prec, match.arg(rnd.mode)))) } ## fails here; must happen *after* dyn.load, i.e. in ## ./zzz.R : Pi <- Const("pi") Rmpfr/R/Arith.R0000644000176200001440000002600613752265550012751 0ustar liggesusers#### Define mpfr methods for Arith + Compare + Logic group functions #### ====== ======= ===== ### "Math" are done in ./Math.R , "Summary" in ./Summary.R ### ---- ~~~~~~ ------- ~~~~~~~~~ ### NB: Look at /usr/local/app/R/R_local/src/Brobdingnag/R/brob.R ### ----------- ##' return 'x' unless it is NULL where you'd use 'orElse' `%||%` <- function(x, orElse) if(!is.null(x)) x else orElse if(FALSE) { print(getGroupMembers("Ops"))# "Arith" "Compare" "Logic" .Ops.list <- sapply(getGroupMembers("Ops"), getGroupMembers, simplify=FALSE) str(.Ops.list, vec.len = 20) ## $ Arith : chr [1:7] "+" "-" "*" "^" "%%" "%/%" "/" ## $ Compare: chr [1:6] "==" ">" "<" "!=" "<=" ">=" ## $ Logic : chr [1:2] "&" "|" } ## Using "vector" and "array" seperately, rather than "ANY" ## ===> shorter distance in method dispatch calculation : setMethod("Ops", signature(e1 = "mpfr", e2 = "vector"), function(e1, e2) callGeneric(e1, as(e2, "numeric"))) setMethod("Ops", signature(e1 = "vector", e2 = "mpfr"), function(e1, e2) callGeneric(as(e1, "numeric"), e2)) ## These should not trigger anymore (because we have "Arith"/"Compare"/...): setMethod("Ops", signature(e1 = "mpfr", e2 = "array"), function(e1, e2) stop(gettextf("'%s'(mpfr,array) method is not implemented yet", .Generic))) setMethod("Ops", signature(e1 = "array", e2 = "mpfr"), function(e1, e2) stop(gettextf("'%s'(array,mpfr) method is not implemented yet", .Generic))) setMethod("Ops", signature(e1 = "mpfr", e2 = "bigz"), function(e1, e2) callGeneric(e1, .bigz2mpfr(e2))) setMethod("Ops", signature(e1 = "bigz", e2 = "mpfr"), function(e1, e2) callGeneric(.bigz2mpfr(e1), e2)) # ..bigq2mpfr(q, NULL) determines the necessary precision for q : setMethod("Ops", signature(e1 = "mpfr", e2 = "bigq"), function(e1, e2) callGeneric(e1, ..bigq2mpfr(e2, NULL))) setMethod("Ops", signature(e1 = "bigq", e2 = "mpfr"), function(e1, e2) callGeneric(..bigq2mpfr(e1, NULL), e2)) setMethod("Logic", signature(e1 = "mpfr", e2 = "mpfr"), function(e1, e2) callGeneric(as(e1, "numeric"), as(e2, "numeric"))) setMethod("Logic", signature(e1 = "mpfr", e2 = "numeric"), function(e1, e2) callGeneric(as(e1, "numeric"), e2)) setMethod("Logic", signature(e1 = "numeric", e2 = "mpfr"), function(e1, e2) callGeneric(e1, as(e2, "numeric"))) ## FIXME?: probably also need etc ###-- 2) ----------- Arith -------------------------------------------------- ## R version, no longer used: .mpfr_negativeR <- function(x) { xD <- getDataPart(x)# << currently [2011] *faster* than x@Data for(i in seq_along(x)) slot(xD[[i]], "sign", check=FALSE) <- - xD[[i]]@sign setDataPart(x, xD, check=FALSE) ## faster than x@Data <- xD } .mpfr_negative <- function(x) .Call(Rmpfr_minus, x) setMethod("Arith", signature(e1 = "mpfr", e2="missing"), function(e1,e2) { switch(.Generic, "+" = e1, "-" = .mpfr_negative(e1), stop(paste("Unary operator", .Generic, "not defined for \"mpfr\" numbers")) ) } ) .Arith.codes <- c("+" = 1, "-" = 2, "*" = 3, "^" = 4, "%%" = 5, "%/%" =6, "/" = 7) storage.mode(.Arith.codes) <- "integer" setMethod("Arith", signature(e1 = "mpfr", e2 = "mpfr"), function(e1, e2) { new("mpfr", .Call(Arith_mpfr, e1, e2, .Arith.codes[.Generic])) }) setMethod("Arith", signature(e1 = "mpfr", e2 = "integer"), function(e1, e2) { new("mpfr", .Call(Arith_mpfr_i, e1, e2, .Arith.codes[.Generic])) }) setMethod("Arith", signature(e1 = "integer", e2 = "mpfr"), function(e1, e2) { new("mpfr", .Call(Arith_i_mpfr, e1, e2, .Arith.codes[.Generic])) }) setMethod("Arith", signature(e1 = "mpfr", e2 = "numeric"),# not "integer" function(e1, e2) { new("mpfr", .Call(Arith_mpfr_d, e1, e2, .Arith.codes[.Generic])) }) setMethod("Arith", signature(e1 = "numeric", e2 = "mpfr"),# not "integer function(e1, e2) { new("mpfr", .Call(Arith_d_mpfr, e1, e2, .Arith.codes[.Generic])) }) ###-- 3) ----------- Compare -------------------------------------------------- .Compare.codes <- c("==" = 1, ">" = 2, "<" = 3, "!=" = 4, "<=" = 5, ">=" =6) storage.mode(.Compare.codes) <- "integer" ## Define "Reverse" codes such that, e.g., ## .Compare.codes[ .Compare.codesRev[">="] ] |--> "<=" .Compare.codesRev <- .Compare.codes # names() in same order; indices swapped: .Compare.codesRev[] <- .Compare.codes[c(1, 3:2, 4, 6:5)] setMethod("Compare", signature(e1 = "mpfr", e2 = "mpfr"), function(e1, e2) { .Call(Compare_mpfr, e1, e2, .Compare.codes[.Generic]) }) setMethod("Compare", signature(e1 = "mpfr", e2 = "integer"), function(e1, e2) { .Call(Compare_mpfr_i, e1, e2, .Compare.codes[.Generic]) }) setMethod("Compare", signature(e1 = "mpfr", e2 = "numeric"),# not "integer" function(e1, e2) { .Call(Compare_mpfr_d, e1, e2, .Compare.codes[.Generic]) }) setMethod("Compare", signature(e1 = "integer", e2 = "mpfr"), function(e1, e2) { .Call(Compare_mpfr_i, e2, e1, .Compare.codesRev[.Generic]) }) setMethod("Compare", signature(e1 = "numeric", e2 = "mpfr"), function(e1, e2) { .Call(Compare_mpfr_d, e2, e1, .Compare.codesRev[.Generic]) }) ### -------------- mpfrArray ------------------------ .dimCheck <- function(a, b) { da <- dim(a) db <- dim(b) if(length(da) != length(db) || any(da != db)) stop(gettextf("Matrices must have same dimensions in %s", deparse(sys.call(sys.parent()))), call. = FALSE) da } setMethod("Arith", signature(e1 = "mpfrArray", e2 = "mpfrArray"), function(e1, e2) { .dimCheck(e1, e2) ## else: result has identical dimension: e1@.Data[] <- .Call(Arith_mpfr, e1, e2, .Arith.codes[.Generic]) e1 }) setMethod("Arith", signature(e1 = "mpfrArray", e2 = "mpfr"), function(e1, e2) { if(length(e1) %% length(e2) != 0) stop("length of first argument (array) is not multiple of the second argument's one") ## else: result has dimension from array: e1@.Data[] <- .Call(Arith_mpfr, e1, e2, .Arith.codes[.Generic]) e1 }) ## "macro-like encapsulation" -- using .Call(, *) for checks .Arith.num.mpfr <- function(x,y, FUN) { if(is.integer(x)) .Call(Arith_i_mpfr, x,y, .Arith.codes[FUN]) else .Call(Arith_d_mpfr, x,y, .Arith.codes[FUN]) } .Arith.mpfr.num <- function(x,y, FUN) { if(is.integer(y)) .Call(Arith_mpfr_i, x,y, .Arith.codes[FUN]) else .Call(Arith_mpfr_d, x,y, .Arith.codes[FUN]) } .Compare.num.mpfr <- function(x,y, FUN) { if(is.integer(x)) .Call(Compare_mpfr_i, y,x, .Compare.codesRev[FUN]) else .Call(Compare_mpfr_d, y,x, .Compare.codesRev[FUN]) } .Compare.mpfr.num <- function(x,y, FUN) { if(is.integer(y)) .Call(Compare_mpfr_i, x,y, .Compare.codes[FUN]) else .Call(Compare_mpfr_d, x,y, .Compare.codes[FUN]) } setMethod("Arith", signature(e1 = "array", e2 = "mpfr"),# incl "mpfrArray" function(e1, e2) { if(e2Arr <- !is.null(dim(e2))) .dimCheck(e1, e2) else if(length(e1) %% length(e2) != 0) stop("length of first argument (array) is not multiple of the second argument's one") if(e2Arr) { e2@.Data[] <- .Arith.num.mpfr(e1, e2, .Generic) e2 } else { r <- new("mpfrArray") r@Dim <- dim(e1) if(!is.null(dn <- dimnames(e1))) r@Dimnames <- dn r@.Data <- .Arith.num.mpfr(e1, e2, .Generic) r } }) setMethod("Arith", signature(e1 = "mpfr", e2 = "array"),# "mpfr" incl "mpfrArray" function(e1, e2) { if(e1Arr <- !is.null(dim(e1))) .dimCheck(e1, e2) else if(length(e2) %% length(e1) != 0) stop("length of second argument (array) is not multiple of the first argument's one") if(e1Arr) { e1@.Data[] <- .Arith.mpfr.num(e1, e2, .Generic) e1 } else { r <- new("mpfrArray") r@Dim <- dim(e2) if(!is.null(dn <- dimnames(e2))) r@Dimnames <- dn r@.Data <- .Arith.mpfr.num(e1, e2, .Generic) r } }) setMethod("Arith", signature(e1 = "mpfrArray", e2 = "numeric"), function(e1, e2) { if(length(e1) %% length(e2) != 0) stop("length of first argument (array) is not multiple of the second argument's one") e1@.Data[] <- .Arith.mpfr.num(e1, e2, .Generic) e1 }) setMethod("Arith", signature(e1 = "numeric", e2 = "mpfrArray"), function(e1, e2) { if(length(e2) %% length(e1) != 0) stop("length of second argument (array) is not multiple of the first argument's one") e2@.Data[] <- .Arith.num.mpfr(e1, e2, .Generic) e2 }) setMethod("Arith", signature(e1 = "mpfr", e2 = "mpfrArray"), function(e1, e2) { if(length(e2) %% length(e1) != 0) stop("length of second argument (array) is not multiple of the first argument's one") e2@.Data[] <- .Call(Arith_mpfr, e1, e2, .Arith.codes[.Generic]) e2 }) setMethod("Compare", signature(e1 = "mpfrArray", e2 = "mpfr"), function(e1, e2) { if(is.null(dim(e2))) { if(length(e1) %% length(e2) != 0) stop("length of first argument (array) is not multiple of the second argument's one") } else .dimCheck(e1, e2) structure(.Call(Compare_mpfr, e1, e2, .Compare.codes[.Generic]), dim = dim(e1), dimnames = dimnames(e1)) }) setMethod("Compare", signature(e1 = "mpfr", e2 = "mpfrArray"), function(e1, e2) { if(is.null(dim(e1))) { if(length(e2) %% length(e1) != 0) stop("length of second argument (array) is not multiple of the first argument's one") } else .dimCheck(e1, e2) structure(.Call(Compare_mpfr, e1, e2, .Compare.codes[.Generic]), dim = dim(e2), dimnames = dimnames(e2)) }) setMethod("Compare", signature(e1 = "mpfr", e2 = "array"),# "mpfr" incl "mpfrArray" function(e1, e2) { if(is.null(dim(e1))) { if(length(e2) %% length(e1) != 0) stop("length of second argument (array) is not multiple of the first argument's one") } else .dimCheck(e1, e2) structure(.Compare.mpfr.num(e1, e2, .Generic), dim = dim(e2), dimnames = dimnames(e2)) }) setMethod("Compare", signature(e1 = "array", e2 = "mpfr"),# incl "mpfrArray" function(e1, e2) { if(is.null(dim(e2))) { if(length(e1) %% length(e2) != 0) stop("length of first argument (array) is not multiple of the second argument's one") } else .dimCheck(e1, e2) structure(.Compare.num.mpfr(e1, e2, .Generic), dim = dim(e1), dimnames = dimnames(e1)) }) setMethod("Compare", signature(e1 = "mpfrArray", e2 = "numeric"),# incl integer function(e1, e2) { if(length(e1) %% length(e2) != 0) stop("length of first argument (array) is not multiple of the second argument's one") structure(.Compare.mpfr.num(e1, e2, .Generic), dim = dim(e1), dimnames = dimnames(e1)) }) setMethod("Compare", signature(e1 = "numeric", e2 = "mpfrArray"), function(e1, e2) { if(length(e2) %% length(e1) != 0) stop("length of second argument (array) is not multiple of the first argument's one") structure(.Compare.num.mpfr(e1, e2, .Generic), dim = dim(e2), dimnames = dimnames(e2)) }) Rmpfr/R/array.R0000644000176200001440000007701514245753567013036 0ustar liggesusers## From an "mpfr" object make an mpfr(Array|Matrix) : setMethod("dim", "mpfrArray", function(x) x@Dim) setMethod("dimnames", "mpfrArray", function(x) x@Dimnames) ## 2 basic methods to construct "mpfr - arrays" ( mpfrArray | mpfrMatrix ) : ##' "mpfr" --> "mpfrArray" --- basically dim() <- dd mpfr2array <- function(x, dim, dimnames=NULL, check=FALSE) { if(check) stopifnot(extends((clx <- class(x)), "mpfr")) if(is.numeric(dim) && all(dim == (iv <- as.integer(dim)))) { rnk <- length(iv) if(check) { cl <- if(rnk == 2) "mpfrMatrix" else "mpfrArray" if(extends(clx, "mpfrArray")) x <- as(x, "mpfr")# drop 'Dim', 'Dimnames' if(is.null(dimnames)) new(cl, x, Dim = iv) else new(cl, x, Dim = iv, Dimnames = dimnames) } else { ## faster, non-checking r <- setDataPart(new(if(rnk == 2) "mpfrMatrix" else "mpfrArray"), x, check=FALSE) r@Dim <- iv if(!is.null(dimnames)) r@Dimnames <- dimnames ##TODO R >= 2.13.2: ##TODO else if(.hasSlot(x, "Dimnames")) # has "wrong' Dimnames else if(is(x, "mpfrArray")) # has "wrong' Dimnames r@Dimnames <- rep.int(list(NULL), rnk) r } } else if(is.null(dim)) as.vector(x) else stop("invalid dimension specified") } setMethod("dim<-", signature(x = "mpfr", value = "ANY"), function(x, value) mpfr2array(x, value)) mpfrArray <- function(x, precBits, dim = length(x), dimnames = NULL, rnd.mode = c('N','D','U','Z','A')) { if(!is.atomic(x)) stop("'x' must be (coercable to) a numeric vector, possibly consider mpfr2array()") dim <- as.integer(dim) rnd.mode <- toupper(rnd.mode) rnd.mode <- match.arg(rnd.mode) ml <- .Call(d2mpfr1_list, x, precBits, rnd.mode) vl <- prod(dim) if (length(x) != vl) { if (vl > .Machine$integer.max) stop("'dim' specifies too large an array") ml <- rep(ml, length.out = vl) } new(if(length(dim) == 2) "mpfrMatrix" else "mpfrArray", ml, Dim = dim, Dimnames = if(is.null(dimnames)) vector("list", length(dim)) else dimnames) } setAs("array", "mpfr", function(from) mpfr(from, 128L)) setAs("array", "mpfrArray", function(from) mpfr(from, 128L)) setAs("matrix", "mpfrMatrix", function(from) mpfr(from, 128L)) ## and for "base" functions to work: as.array.mpfr <- function(x, ...) { if(is(x, "mpfrArray")) x else ## is(x, "mpfr") : as.array.default(x, ...) } as.matrix.mpfr <- function(x, ...) { if(is(x, "mpfrMatrix")) x else ## is(x, "mpfr") : as.matrix.default(x, ...) } ## matrix is S3 generic from 'gmp' anyway: matrix.mpfr <- function (data = NA, nrow = 1, ncol = 1, byrow = FALSE, ...) { dim(data) <- c(nrow, ncol) if(length(dots <- list(...))) { if(!is.null(dn <- dots$dimnames)) { dimnames(data) <- dn # assign and delete from "dots": dots$dimnames <- NULL } if(nx <- length(dots)) # a simplified Matrix:::chk.s() warning(sprintf(ngettext(nx, "extra argument %s will be disregarded", "extra arguments %s will be disregarded"), sub(")$", '', sub("^list\\(", '', deparse(dots, control=c()))))) } data } setMethod("dimnames<-", signature(x = "mpfrArray", value = "ANY"), function(x, value) { if(!is.list(value)) stop("non-list RHS") if(length(value) != length(x@Dim)) stop("RHS (new dimnames) differs in length from dim(.)") x@Dimnames <- value x }) setMethod("t", "mpfrMatrix", t.mpfrMatrix <- function(x) { d <- x@Dim; n <- d[1]; m <- d[2] ## These are the indices to get the transpose of m {n x m} : ## ind.t <- function(n,m)rep.int(1:n, rep(m,n)) + n*(0:(m-1)) x@Dim <- c(m,n) x@Dimnames <- x@Dimnames[2:1] ## faster than { x@.Data <- x@.Data[rep.int(1:n, rep(m,n)) + n*(0:(m-1))] ; x } : setDataPart(x, getD(x)[rep.int(1:n, rep(m,n)) + n*(0:(m-1))], check=FALSE) }) setMethod("t", "mpfr", t.mpfr <- function(x) { # t() |--> {1 x n} matrix r <- new("mpfrMatrix") r@Dim <- c(1L, length(x)) ## faster than { r@.Data <- x@.Data ; r } : setDataPart(r, getD(x), check=FALSE) }) setMethod("aperm", signature(a="mpfrArray"), aperm.mpfrArray <- function(a, perm, resize=TRUE, ...) { stopifnot(1 <= (k <- length(d <- a@Dim))) if(missing(perm)) perm <- k:1 else stopifnot(length(perm <- as.integer(perm)) == k, 1 <= perm, perm <= k) if(!resize) stop("'resize != TRUE is not (yet) implemented for 'mpfrArray'") a@Dim <- d[perm] a@Dimnames <- a@Dimnames[perm] ii <- c(aperm(array(1:prod(d), dim=d), perm=perm, resize=FALSE)) ## faster than { a@.Data <- a@.Data[ ii ] ; a } : setDataPart(a, getD(a)[ ii ], check=FALSE) }) ## `` drop the dim() part '' : setMethod("as.vector", "mpfrArray", function(x) as(x, "mpfr")) ## a "vector" in *one* sense at least, and "mpfr" does extend "vector": setAs("mpfrArray", "vector", function(from) as(from, "mpfr")) .toNum <- function(from, rnd.mode) { ## <- must have only 'from' if(is.null(dn <- dimnames(from)) || identical(dn, list(NULL,NULL))) ## --> result has NULL dimnames structure(.Call(mpfr2d, from, rnd.mode), dim = dim(from)) else structure(.Call(mpfr2d, from, rnd.mode), dim = dim(from), dimnames = dn) } ## to be used in setAs(), must have only 'from' argument: .toNum1 <- function(from) .toNum(from, rnd.mode="N") toNum <- function(from, rnd.mode = c('N','D','U','Z','A')) { stopifnot(is.character(rnd.mode <- toupper(rnd.mode))) rnd.mode <- match.arg(rnd.mode) .toNum(from, rnd.mode) } setAs("mpfrArray", "array", .toNum1) setAs("mpfrMatrix", "matrix", .toNum1) setAs("mpfrArray", "matrix", function(from) { if(length(dim(from)) != 2) stop("dim(.) != 2 ==> cannot be coerced to 'matrix'") toNum(from) }) print.mpfrArray <- function(x, digits = NULL, drop0trailing = FALSE, right = TRUE, ## ----- ## would like 'drop0... = TRUE', but that's only ok once we have a ## format() allowing to "jointly format a column" max.digits = getOption("Rmpfr.print.max.digits", 999L), exponent.plus = getOption("Rmpfr.print.exponent.plus", TRUE), ...) { stopifnot(is(x, "mpfrArray"), is.null(digits) || digits >= 2) ## digits = NULL --> the inherent precision of x will be used n <- length(x) ch.prec <- if(n >= 1) { rpr <- range(.getPrec(x)) paste("of precision ", rpr[1], if(rpr[1] != rpr[2]) paste("..",rpr[2]), " bits") } cl <- class(x) p0 <- function(...) paste(..., sep="") cat(p0("'",cl,"'"), "of dim(.) = ", p0("(",paste(x@Dim, collapse=", "),")"), ch.prec, "\n") if(n >= 1) { ## FIXME: really need a 'format' method for mpfrArrays ## ----- which properly aligns columns !! ## Build character array fx, and print that ## drop arguments for print.default(*): lFormat <- function(x, na.print, print.gap, max, useSource, ...) formatMpfr(x, digits=digits, max.digits=max.digits, drop0trailing=drop0trailing, exponent.plus=exponent.plus, ...) fx <- lFormat(x, ...) dim(fx) <- dim(x) dimnames(fx) <- dimnames(x) print(fx, ..., right=right, quote = FALSE) } invisible(x) } setMethod(show, "mpfrArray", function(object) print.mpfrArray(object)) ## FIXME : should happen in C, where we could "cut & paste" much of ## ----- do_matprod() and matprod() from ~/R/D/r-devel/R/src/main/array.c ##/* "%*%" (op = 0), crossprod (op = 1) or tcrossprod (op = 2) */ .matmult.R <- function(x,y, op = 0L, fPrec = 1, precBits = fPrec * max(getPrec(x), getPrec(y))) { if(!(is.numeric(x) || is.mpfr(x))) stop("'x' must be numeric or mpfr(Matrix)") sym <- missing(y) if (sym && (op > 0L)) y <- x else if(!(is.numeric(y) || is.mpfr(y))) stop("'y' must be numeric or mpfr(Matrix)") ldx <- length(dx <- dim(x)) ldy <- length(dy <- dim(y)) ## "copy, paste & modify" from do_matprod(): if (ldx != 2 && ldy != 2) { #* x and y non-matrices */ if (op == 0L) { nrx <- 1L; ncx <- length(x) } else { nrx <- length(x); ncx <- 1L } nry <- length(y) ncy <- 1L } else if (ldx != 2) { #* x not a matrix */ nry <- dy[1] ncy <- dy[2] nrx <- ncx <- 0L if (op == 0L) { if (length(x) == nry) { #* x as row vector */ nrx <- 1L ncx <- nry # == length(x) } else if (nry == 1) { #* x as col vector */ nrx <- length(x) ncx <- 1L # == nry } } else if (op == 1L) { #* crossprod if (length(x) == nry) { #* x is a col vector */ nrx <- nry # = length(x) ncx <- 1L } } else { # op == 2L: tcrossprod if (length(x) == ncy) { #* x as row vector */ nrx <- 1L ncx <- ncy # == length(x) } else if (ncy == 1) { #* x as col vector */ nrx <- length(x) ncx <- 1L # == ncy } } } else if (ldy != 2) { #* y not a matrix */ nrx <- dx[1] ncx <- dx[2] nry <- ncy <- 0L if (op == 0L) { if (length(y) == ncx) { #* y as col vector */ nry <- ncx # = length(y) ncy <- 1L } else if (ncx == 1) { #* y as row vector */ nry <- 1L # = ncx ncy <- length(y) } } else if (op == 1L) { #* crossprod if (length(y) == nrx) { #* y is a col vector */ nry <- nrx # = length(y) ncy <- 1L } } else { # op == 2L: tcrossprod y is a col vector nry <- length(y) ncy <- 1L } } else { #* x and y matrices */ nrx <- dx[1] ncx <- dx[2] nry <- dy[1] ncy <- dy[2] } ##* nr[ow](.) and nc[ol](.) are now defined for x and y */ z <- new("mpfrMatrix") z0 <- as(0, "mpfr") if (op == 0L) { ## %*% if (ncx != nry) stop("non-conformable arguments") z@Dim <- c(nrx, ncy) z@.Data <- vector("list", nrx*ncy) if (nrx > 0 && ncx > 0 && nry > 0 && ncy > 0) { j <- 0L:(ncx - 1L) for(i in 1:nrx) { for (k in 0L:(ncy - 1L)) z[i + k * nrx] <- ## sum(x[i + j * nrx] * y[1L+ j + k * nry]) new("mpfr", .Call(R_mpfr_sumprod, # --> ../src/Summary.c x[i + j * nrx], y[1L+ j + k * nry], precBits, alternating=FALSE)) } } else #/* zero-extent operations should return zeroes */ for(i in seq_len(nrx*ncy)) z[i] <- z0 } else if (op == 1L) { ## crossprod() : x' %*% y if (nrx != nry) stop("non-conformable arguments") z@Dim <- c(ncx, ncy) z@.Data <- vector("list", ncx*ncy) if (nrx > 0 && ncx > 0 && nry > 0 && ncy > 0) { j <- 1L:nrx for(i in 0L:(ncx - 1L)) { for (k in 0L:(ncy - 1L)) z[1L +i + k * ncx] <- ## sum(x[j + i * nrx] * y[j + k * nry]) new("mpfr", .Call(R_mpfr_sumprod, x[j + i * nrx], y[j + k * nry], precBits, alternating=FALSE)) } } else for(i in seq_len(ncx*ncy)) z[i] <- z0 } else { ## op == 2L : tcrossprod() : x %*% y' if (ncx != ncy) stop("non-conformable arguments") z@Dim <- c(nrx, nry) z@.Data <- vector("list", nrx*nry) if (nrx > 0 && ncx > 0 && nry > 0 && ncy > 0) for(i in seq_len(nrx)) { j <- 0L:(ncx - 1L) for (k in 0L:(nry - 1L)) z[i + k * nrx] <- ## sum(x[i + j * nrx] * y[1L +k + j * nry]) new("mpfr", .Call(R_mpfr_sumprod, x[i + j * nrx], y[1L +k + j * nry], precBits, alternating=FALSE)) } else for(i in seq_len(nrx*nry)) z[i] <- z0 } z } ## .matmult.R() ## "FIXME"? make working also with "Matrix" class matrices .. ## ---------------------------- ## An 'explicit' %*% function (with >= 2 arguments) : matmult <- function(x,y, ...) .matmult.R(x,y, op = 0L, ...) setMethod("%*%", signature(x = "mpfrMatrix", y = "mpfrMatrix"), function(x,y) .matmult.R(x,y, op= 0L)) setMethod("%*%", signature(x = "mpfrMatrix", y = "mpfr"), function(x,y) .matmult.R(x,y, op= 0L)) setMethod("%*%", signature(x = "mpfr", y = "mpfrMatrix"), function(x,y) .matmult.R(x,y, op= 0L)) setMethod("%*%", signature(x = "mpfr", y = "mpfr"), function(x,y) .matmult.R(x,y, op= 0L)) ## These cover vectors, etc (!) : setMethod("%*%", signature(x = "mpfr", y = "Mnumber"), function(x,y) .matmult.R(x,y, op= 0L)) setMethod("%*%", signature(x = "Mnumber", y = "mpfr"), function(x,y) .matmult.R(x,y, op= 0L)) setMethod("crossprod", signature(x = "mpfrMatrix", y = "mpfrMatrix"), function(x,y, ...) .matmult.R(x,y, op= 1L, ...)) setMethod("crossprod", signature(x = "mpfrMatrix", y = "mpfr"), function(x,y, ...) .matmult.R(x,y, op= 1L, ...)) setMethod("crossprod", signature(x = "mpfr", y = "mpfrMatrix"), function(x,y, ...) .matmult.R(x,y, op= 1L, ...)) setMethod("crossprod", signature(x = "mpfr", y = "mpfr"), function(x,y, ...) .matmult.R(x,y, op= 1L, ...)) setMethod("crossprod", signature(x = "mpfr", y = "Mnumber"), function(x,y, ...) .matmult.R(x,y, op= 1L, ...)) setMethod("crossprod", signature(x = "Mnumber", y = "mpfr"), function(x,y, ...) .matmult.R(x,y, op= 1L, ...)) ## one argument-case: [FIXME: not copying 'x' and using x_i^2 is more efficient] setMethod("crossprod", signature(x = "mpfr", y = "missing"), function(x,y, ...) .matmult.R(x,x, op= 1L, ...)) setMethod("tcrossprod", signature(x = "mpfrMatrix", y = "mpfrMatrix"), function(x,y, ...) .matmult.R(x,y, op= 2L, ...)) setMethod("tcrossprod", signature(x = "mpfrMatrix", y = "mpfr"), function(x,y, ...) .matmult.R(x,y, op= 2L, ...)) setMethod("tcrossprod", signature(x = "mpfr", y = "mpfrMatrix"), function(x,y, ...) .matmult.R(x,y, op= 2L, ...)) setMethod("tcrossprod", signature(x = "mpfr", y = "mpfr"), function(x,y, ...) .matmult.R(x,y, op= 2L, ...)) setMethod("tcrossprod", signature(x = "mpfr", y = "Mnumber"), function(x,y, ...) .matmult.R(x,y, op= 2L, ...)) setMethod("tcrossprod", signature(x = "Mnumber", y = "mpfr"), function(x,y, ...) .matmult.R(x,y, op= 2L, ...)) ## one argument-case: [FIXME: not copying 'x' and using x_i^2 is more efficient] setMethod("tcrossprod", signature(x = "mpfr", y = "missing"), function(x,y, ...) .matmult.R(x,x, op= 2L, ...)) .mpfrA.subset <- function(x,i,j, ..., drop) { nA <- nargs() if(getOption("verbose")) message(sprintf("nargs() == %d mpfrArray indexing ... ", nA)) r <- getD(x) # the data part, a list() if(nA == 2) ## A[i] return(new("mpfr", r[i])) ## else: nA != 2 : nA > 2 - dim(r) <- dim(x) dimnames(r) <- dimnames(x) r <- r[i,j, ..., drop=drop] if(drop && is.null(dim(r))) new("mpfr", r) else { D <- if(is.null(dr <- dim(r))) # ==> drop is FALSE; can this happen? rep.int(1L, length(r)) else dr x@Dim <- D x@Dimnames <- if(is.null(dn <- dimnames(r))) vector("list", length(D)) else dn if(length(D) == 2 && !inherits(x, "mpfrMatrix")) ## low-level "coercion" from mpfrArray to *Matrix : attr(x,"class") <- getClass("mpfrMatrix")@className attributes(r) <- NULL setDataPart(x, r, check=FALSE) } } ## "[" setMethod("[", signature(x = "mpfrArray", i = "ANY", j = "ANY", drop = "ANY"), .mpfrA.subset) ## this signature needs a method here, or it triggers the one for "mpfr" setMethod("[", signature(x = "mpfrArray", i = "ANY", j = "missing", drop = "missing"), .mpfrA.subset) .mA.subAssign <- function(x,i,j,..., value, n.a, isMpfr) { ## n.a :=== nargs() -- in the calling "[<-" method -- r <- getD(x) if(n.a >= 4) { ## A[i,j] / A[i,] / A[,j] but not A[i] ## A[i,j,k] <- v : n.a == 5 dim(r) <- dim(x) dimnames(r) <- dimnames(x) if(!isMpfr) value <- mpfr(value, precBits = pmax(getPrec(value), .getPrec(if(n.a == 4) r[i,j] else r[i,j, ...])) ) vD <- getD(value) if(n.a == 4) { r[i,j] <- vD } else { ## n.a >= 5 r[i, j, ...] <- vD } attributes(r) <- NULL } else if(n.a %in% c(2,3)) { ## A [ i ] <- v // A[] <- v if(!isMpfr) value <- mpfr(value, precBits = pmax(getPrec(value), .getPrec(r[i]))) if(n.a == 3L) r[i] <- value else ## n.a == 2: r[] <- value } else { ## n.a <= 1 stop(sprintf("nargs() == %d mpfrArray[i,j] <- value __ SHOULD NOT HAPPEN!", n.a)) } setDataPart(x, r, check=FALSE) }## .mA.subAssign ## "[<-" : ## ------- ## E.g., for A[1,,2] <- V ## these are to trigger before the ("mpfr", i,j, "mpfr") [ ./mpfr.R ] does for(it in c("ANY", "missing")) for(jt in c("ANY", "missing")) setReplaceMethod("[", signature(x = "mpfrArray", i = it, j = jt, value = "mpfr"), function(x,i,j,..., value) .mA.subAssign(x,i=i,j=j,...,value=value, n.a=nargs(), isMpfr = TRUE)) ## non-"mpfr" value for(it in c("ANY", "missing")) for(jt in c("ANY", "missing")) setReplaceMethod("[", signature(x = "mpfrArray", i = it, j = jt, value = "ANY"), function(x,i,j, ..., value) .mA.subAssign(x,i=i,j=j,...,value=value, n.a=nargs(), isMpfr = FALSE)) rm(it,jt) ## In the Matrix package we have Diagonal() for *constructing* a diagonalMatrix; ## in any case, we do only want to support the diag() case. setMethod("diag", signature(x = "mpfrMatrix"), function(x, nrow, ncol) { n <- min(dim(x)); i <- seq_len(n); x[cbind(i,i)] }) setMethod("diag<-", signature(x = "mpfrMatrix"), function(x, value) { n <- min(dim(x)); i <- seq_len(n); x[cbind(i,i)] <- value; x }) ###----------- setGeneric("cbind", signature = "...")# -> message about override & deparse.level setGeneric("rbind", signature = "...") ## inside such cbind() / rbind() S4 methods, match.call() does *not* work correctly, ## this works *only* for top-level calls : bind_match.call <- function() sys.call(1L) ## so use our "hack" : bind_match.call <- function() { nc <- length(scs <- sys.calls()) # last one is bind_match.call() itself ## want the one call *above* standardGeneric("...") : if(is.symbol(fn <- scs[[nc-1L]][[1L]])) { # e.g. 'cbind' Gcall <- call("standardGeneric", as.character(fn)) # e.g. standardGeneric("cbind") i. <- which(vapply(scs, identical, NA, Gcall)) scs[[if(!length(i.) || i. < 2L) 1L else i. - 1L ]] } else # try "better" match.call() } setMethod("cbind", "Mnumber", function(..., deparse.level = 1) { args <- list(...) if(all(vapply(args, is.atomic, NA))) return( base::cbind(..., deparse.level = deparse.level) ) ## else: at least one is "mpfr(Matrix/Array)" if(any(vapply(args, is.character, NA))) { ## result will be matrix ! isM <- vapply(args, is, NA, class2 = "mpfr") args[isM] <- lapply(args[isM], as, Class = "character") return(do.call(base::cbind, c(args, list(deparse.level=deparse.level)))) } else if(any(vapply(args, is.complex, NA))) { ## result will be matrix; ## in the future ??? stop("cbind(...) of 'complex' and 'mpfr' objects is not implemented") ## give at least warning !! } ## else L <- function(a) if(is.numeric(n <- nrow(a))) n else length(a) W <- function(a) if(is.numeric(n <- ncol(a))) n else 1L ## the number of rows of the result : {for now require integer} NR <- max(lengths <- vapply(args, L, integer(1))) NC <- sum(widths <- vapply(args, W, integer(1))) r <- setDataPart(new("mpfrMatrix"), vector("list", NR*NC)) r@Dim <- as.integer(c(NR, NC)) hasDim <- !vapply(args, function(a) is.null(dim(a)), NA) do.colnames <- deparse.level || any(hasDim) if(do.colnames) { nms <- character(NC) ## help(cbind) has in 'Value' : ## For ‘cbind’ (‘rbind’) the column (row) names are taken from the ## colnames (rownames) of the arguments if these are matrix-like. ## Otherwise from the names of the arguments or where those are not ## supplied and ‘deparse.level > 0’, by deparsing the expressions ## given, for ‘deparse.level = 1’ only if that gives a sensible name ## (a symbol, see is.symbol). nV <- names(widths) # == names(args), possibly NULL hasV <- !is.null(nV) ## argN <- substitute(...)## "fails" here same as match.call() fcall <- bind_match.call() if(!missing(deparse.level)) # must remove: it could be "anywhere" fcall <- fcall[names(fcall) != "deparse.level"] ## cat("fcall: "); str(fcall) ## browser() ## argN <- fcall[-1] # but that makes 1st arg into fn.name! ## vapply(fcall[-1], deparse1, "") ## is what we'd need, incl. *names* ## not ok when called as selectMethod("cbind","mpfr")(x, ....) fcall.ok <- (length(fcall) == 1L + ...length()) ## == 1 + length(args) } j <- 0 prec <- .Machine$double.digits for(ia in seq_along(args)) { w <- widths[ia] a <- args[[ia]] isM <- hasDim[[ia]] # == !is.null(dim(a)) ; true iff matrix-like if(is.mpfr(a)) { prec <- max(prec, .getPrec(a)) } else { ## not "mpfr" a <- mpfr(a, prec) } if((li <- lengths[ia]) != 1 && li != NR) { ## recycle if(isM) stop("number of rows of matrices must match") ## else if(NR %% li) warning("number of rows of result is not a multiple of vector length") a <- a[rep(seq_len(li), length.out = NR)] } ii <- j+ seq_len(w) r[, ii] <- a if(do.colnames) { nms[ii] <- if(isM) colnames(a) %||% "" else { if(hasV && nzchar(n. <- nV[[ia]])) n. else if(fcall.ok) { ## deparsed argument "arg"[[ia]] a <- fcall[[ia+1L]] if(is.symbol(a) || deparse.level == 2) deparse1(a) else "" } else "" } } j <- j + w } if(do.colnames && any(nzchar(nms))) r@Dimnames[[2L]] <- nms r }) setMethod("rbind", "Mnumber", function(..., deparse.level = 1) { args <- list(...) if(all(vapply(args, is.atomic, NA))) return( base::rbind(..., deparse.level = deparse.level) ) ## else: at least one is "mpfr(Matrix/Array)" if(any(vapply(args, is.character, NA))) { ## result will be matrix ! isM <- vapply(args, is, NA, class2 = "mpfr") args[isM] <- lapply(args[isM], as, Class = "character") return(do.call(base::rbind, c(args, list(deparse.level=deparse.level)))) } else if(any(vapply(args, is.complex, NA))) { ## result will be matrix; ## in the future ??? stop("rbind(...) of 'complex' and 'mpfr' objects is not implemented") ## give at least warning !! } ## else L <- function(a) if(is.numeric(n <- nrow(a))) n else 1L W <- function(a) if(is.numeric(n <- ncol(a))) n else length(a) ## the number of rows of the result : {for now require integer} NR <- sum(lengths <- vapply(args, L, integer(1))) NC <- max(widths <- vapply(args, W, integer(1))) r <- setDataPart(new("mpfrMatrix"), vector("list", NR*NC)) r@Dim <- as.integer(c(NR, NC)) hasDim <- !vapply(args, function(a) is.null(dim(a)), NA) do.rownames <- deparse.level || any(hasDim) if(do.rownames) { nms <- character(NR) nV <- names(lengths) # == names(args), possibly NULL hasV <- !is.null(nV) fcall <- bind_match.call() if(!missing(deparse.level)) # must remove: it could be "anywhere" fcall <- fcall[names(fcall) != "deparse.level"] ## not ok when called as selectMethod("cbind","mpfr")(x, ....) fcall.ok <- (length(fcall) == 1L + ...length()) ## == 1 + length(args) } i <- 0 prec <- .Machine$double.digits for(ia in seq_along(args)) { le <- lengths[ia] a <- args[[ia]] isM <- hasDim[[ia]] # == !is.null(dim(a)) ; true iff matrix-like if(is.mpfr(a)) { prec <- max(prec, .getPrec(a)) } else { ## not "mpfr" a <- mpfr(a, prec) } if((wi <- widths[ia]) != 1 && wi != NC) { ## recycle if(isM) stop("number of rows of matrices must match") ## else if(NC %% wi) warning("number of columns of result is not a multiple of vector length") a <- a[rep(seq_len(wi), length.out = NC)] } ii <- i+ seq_len(le) r[ii, ] <- a if(do.rownames) { nms[ii] <- if(isM) rownames(a) %||% "" else { if(hasV && nzchar(n. <- nV[[ia]])) n. else if(fcall.ok) { ## deparsed argument "arg"[[ia]] a <- fcall[[ia+1L]] if(is.symbol(a) || deparse.level == 2) deparse1(a) else "" } else "" } } i <- i + le } if(do.rownames && any(nzchar(nms))) r@Dimnames[[1L]] <- nms r }) unlistMpfr <- function(x, recursive = FALSE, use.names = TRUE) { ## an "unlist(.)" for mpfr contents: if(recursive) stop("'recursive = TRUE' is not implemented (yet).") n <- sum(lengths(x)) ans <- mpfr(numeric(n), precBits=3L)# dummy to fill ans@.Data <- unlist(lapply(x, slot, ".Data"), use.names=use.names) ans } ##-- Original in ~/R/D/r-devel/R/src/library/base/R/apply.R : ## applyMpfr <- function(X, MARGIN, FUN, ...) { FUN <- match.fun(FUN) ## Ensure that X is an array object dl <- length(dim(X)) if(!dl) stop("dim(X) must have a positive length") ##- if(is.object(X)) ##- X <- if(dl == 2L) as.matrix(X) else as.array(X) ## now record dim as coercion can change it ## (e.g. when a data frame contains a matrix). d <- dim(X) dn <- dimnames(X) ds <- seq_len(dl) ## Extract the margins and associated dimnames if (is.character(MARGIN)) { if(is.null(dnn <- names(dn))) # names(NULL) is NULL stop("'X' must have named dimnames") MARGIN <- match(MARGIN, dnn) if (any(is.na(MARGIN))) stop("not all elements of 'MARGIN' are names of dimensions") } s.call <- ds[-MARGIN] s.ans <- ds[MARGIN] d.call <- d[-MARGIN] d.ans <- d[MARGIN] dn.call<- dn[-MARGIN] dn.ans <- dn[MARGIN] ## dimnames(X) <- NULL array <- function(data, dim = length(data), dimnames = NULL) { dim(data) <- dim if(!is.null(dimnames)) dimnames(data) <- dimnames data } ## do the calls d2 <- prod(d.ans) if(d2 == 0L) { ## arrays with some 0 extents: return ``empty result'' trying ## to use proper mode and dimension: ## The following is still a bit `hackish': use non-empty X newX <- array(vector(typeof(X), 1L), dim = c(prod(d.call), 1L)) ans <- forceAndCall(1, FUN, if(length(d.call) < 2L) newX[,1] else array(newX[, 1L], d.call, dn.call), ...) return(if(is.null(ans)) ans else if(length(d.ans) < 2L) ans[1L][-1L] else array(ans, d.ans, dn.ans)) } ## else newX <- aperm(X, c(s.call, s.ans)) dim(newX) <- c(prod(d.call), d2) ans <- vector("list", d2) if(length(d.call) < 2L) {# vector if (length(dn.call)) dimnames(newX) <- c(dn.call, list(NULL)) for(i in 1L:d2) { tmp <- forceAndCall(1, FUN, newX[,i], ...) if(!is.null(tmp)) ans[[i]] <- tmp } } else for(i in 1L:d2) { tmp <- forceAndCall(1, FUN, array(newX[,i], d.call, dn.call), ...) if(!is.null(tmp)) ans[[i]] <- tmp } ## answer dims and dimnames ans.list <- !is(ans[[1L]], "mpfr") ##- is.recursive(ans[[1L]]) l.ans <- length(ans[[1L]]) ans.names <- names(ans[[1L]]) if(!ans.list) ans.list <- any(lengths(ans) != l.ans) if(!ans.list && length(ans.names)) { all.same <- vapply(ans, function(x) identical(names(x), ans.names), NA) if (!all(all.same)) ans.names <- NULL } len.a <- if(ans.list) d2 else length(ans <- unlistMpfr(ans)) if(length(MARGIN) == 1L && len.a == d2) { names(ans) <- if(length(dn.ans[[1L]])) dn.ans[[1L]] # else NULL ans } else if(len.a == d2) array(ans, d.ans, dn.ans) else if(len.a && len.a %% d2 == 0L) { if(is.null(dn.ans)) dn.ans <- vector(mode="list", length(d.ans)) dn1 <- list(ans.names) if(length(dn.call) && !is.null(n1 <- names(dn <- dn.call[1])) && nzchar(n1) && length(ans.names) == length(dn[[1]])) names(dn1) <- n1 dn.ans <- c(dn1, dn.ans) array(ans, c(len.a %/% d2, d.ans), if(!is.null(names(dn.ans)) || !all(vapply(dn.ans, is.null, NA))) dn.ans) } else ans } setGeneric("apply") setMethod ("apply", "mpfrArray", applyMpfr) setMethod("colSums", "mpfrArray", function(x, na.rm = FALSE, dims = 1, ...) { stopifnot((rnk <- length(dim(x))) >= 2, 1 <= dims, dims <= rnk - 1) applyMpfr(x, (dims+1):rnk, sum) }) setMethod("colMeans", "mpfrArray", function(x, na.rm = FALSE, dims = 1, ...) { stopifnot((rnk <- length(dim(x))) >= 2, 1 <= dims, dims <= rnk - 1) applyMpfr(x, (dims+1):rnk, mean) }) setMethod("rowSums", "mpfrArray", function(x, na.rm = FALSE, dims = 1, ...) { stopifnot((rnk <- length(dim(x))) >= 2, 1 <= dims, dims <= rnk - 1) applyMpfr(x, 1:dims, sum) }) setMethod("rowMeans", "mpfrArray", function(x, na.rm = FALSE, dims = 1, ...) { stopifnot((rnk <- length(dim(x))) >= 2, 1 <= dims, dims <= rnk - 1) applyMpfr(x, 1:dims, mean) }) ## Cut'n'paste from ~/R/Pkgs/Matrix/R/Auxiliaries.R {FIXME? load Matrix:::mkDet} mkDet <- function(d, logarithm = TRUE, ldet = sum(log(abs(d))), sig = -1L+2L*as.integer(prod(sign(d)) >= 0)) { # sig: -1 or +1 (not 0 !) modulus <- if (logarithm) ldet else exp(ldet) attr(modulus, "logarithm") <- logarithm val <- list(modulus = modulus, sign = sig) class(val) <- "det" val } ## S3 method instead of S4, as base::determinant is S3 generic determinant.mpfrMatrix <- function(x, logarithm = TRUE, asNumeric = (d[1] > 3), precBits = max(.getPrec(x)), ...) { d <- x@Dim if(d[1] != d[2]) stop("'x' must ba a square matrix") if((n <- d[1]) == 0) determinant(matrix(1,0,0), logarithm=logarithm) else if(n == 1) mkDet(x[1], logarithm=logarithm) else { ## n x n, for n >= 2 if(asNumeric) return(determinant(asNumeric(x), logarithm=logarithm, ...)) ## else use recursive (Care: horribly slow for non-small n!) Det <- function(x, n = dim(x)[1]) { if(n == 1) x[1] else if(n == 2) x[1]*x[4] - x[2]*x[3] else { a <- mpfr(numeric(n), precBits=3L) # dummy to fill n1 <- n-1L for(i in seq_len(n)) { a[i] <- Det(x[-i,-1], n=n1) } ## sum(x[,1] * a), faster : new("mpfr", .Call(R_mpfr_sumprod, x[,1], a, precBits, alternating=TRUE)) } } mkDet(Det(x, n=n), logarithm=logarithm) } } ## Only needed for S4 determinant(), not for S3 one: ## The ``Right Thing'' to do : ## base::det() calls [base::]determinant(); ## our det() should call our determinant() : ## det <- base::det ## environment(det) <- environment()## == asNamespace("Rmpfr") if(FALSE) { ## This will become easy, once we have outer(...) working, basically almost == ## base::.kronecker ~~~~~~~~~ ## ------^--------- setMethod("kronecker", signature(X = "mpfrMatrix", Y = "mpfrMatrix"), function (X, Y, FUN = "*", make.dimnames = FALSE, ...) { ydim <- Y@Dim rprec <- max(.getPrec(X),.getPrec(Y)) xx <- ....... mpfr2array(xx, dim = X@Dim * ydim) }) } scale.mpfrMatrix <- scale.default ## essential, so that colMeans() is using "our" colMeans : environment(scale.mpfrMatrix) <- environment()# = the "Rmpfr" namespace ### norm() - are "lifted" from ~/R/Pkgs/Matrix/R/sparseMatrix.R : ## "FIXME": ideally should be part of the setGenericImplicit("norm",..) setMethod("norm", signature(x = "ANY", type = "missing"), function (x, type, ...) norm(x, type = "O", ...)) setMethod("norm", signature(x = "mpfrMatrix", type = "character"), function(x, type, ...) { type <- toupper(substr(type[1], 1, 1)) switch(type, ## max(, 0) |--> 0 "O" = , "1" = max(colSums(abs(x)), 0), ## One-norm (L_1) "I" = max(rowSums(abs(x)), 0), ## L_Infinity "F" = sqrt(sum(x^2)), ## Frobenius "M" = max(abs(x), 0), ## Maximum modulus of all ## otherwise: stop("invalid 'type'")) }) setMethod("head", signature(x = "mpfrMatrix"), utils::head.matrix) setMethod("tail", signature(x = "mpfrMatrix"), utils::tail.matrix) ## Workaround fact that base::outer() using tcrossprod() does not dispatch (but did on %*% !?!?!?!) environment(outer) <- environment() # and export and document >> ../man/base-copies.Rd Rmpfr/R/Summary.R0000644000176200001440000000714014457744436013345 0ustar liggesusers#### Define mpfr methods for Summary group functions #### ======= ### "Math" are done in ./Math.R , "Ops", "Arith", "Logic", "Compare" in ./Arith.R .Summary.codes <- c("max" = 1, "min" = 2, "range" = 3, "prod" = 4, "sum" = 5, "any" = 10, "all" = 11) storage.mode(.Summary.codes) <- "integer" setMethod("Summary", "mpfr", function(x, ..., na.rm=FALSE) { iop <- .Summary.codes[.Generic] ## --> ../src/Summary.c r <- .Call(Summary_mpfr, if(length(x)) c(x, ...) else x, na.rm, iop) if(iop <= 5) new("mpfr", r) else ## any, all : r }) stats__quantile.default <- stats:::quantile.default setMethod("quantile", "mpfr", stats__quantile.default) ## FIXME: is *slow* *and* uses double precision epsilon internally .Machine$double.epsilon ## ## Not perfect: has the "0%" "25%" "50%" ... names but not as slot ... hmm ... ## 'mpfr' numbers do not have 'names' slot ... (etc) -- but "work" with names ## function(x, ...) { ## if((match("names", names(list(...)), nomatch = 0L)) == 0L) ## stats__quantile.default(x, ..., names=FALSE) ## else ## ... contains 'names = ..' ## stats__quantile.default(x, ...) ## }) setMethod("mean", "mpfr", function(x, trim = 0, na.rm = FALSE, ...) { if(trim == 0) ## based on sum() : sum(x, na.rm=na.rm, ...) / length(x) else { ## cut'n'paste from mean.default() : if (!is.numeric(trim) || length(trim) != 1L || trim < 0) stop("'trim' must be numeric of length one, in [0, 1/2]") if (na.rm) x <- x[!is.na(x)] n <- length(x) if (anyNA(x)) mpfr(NA) else if (trim >= 0.5) quantile(x, probs = 0.5, na.rm = FALSE, names = FALSE) else { lo <- floor(n * trim) + 1 hi <- n + 1 - lo mean(sort(x, partial = unique(c(lo, hi)))[lo:hi], na.rm = FALSE) } } }) setMethod("median", "mpfr", function(x, na.rm=FALSE, ...) quantile(x, probs = 0.5, na.rm=na.rm, names = FALSE)) setMethod("summary", "mpfr", function (object, ..., digits, quantile.type = 7) { ## Should work almost like summary(asNumeric(object, ..., digits=digits)) ## *but* w/o underflow and overflow: nas <- is.na(object) object <- object[!nas] qq <- quantile(object, names=FALSE, type = quantile.type) qq <- c(qq[1L:3L], mean(object), qq[4L:5L]) ## names(qq) <- c("Min.", "1st Qu.", "Median", "Mean", "3rd Qu.", "Max.") if (!missing(digits)) qq <- signif(qq, digits) if(any(nas)) # names() updatingn works for "mpfr" qq <- c(qq, "NA's" = sum(nas)) ## loses names: as(qq, "summaryMpfr") ## workaround : new("summaryMpfr", qq, names = c("Min.", "1st Qu.", "Median", "Mean", "3rd Qu.", "Max.")) }) setClass("summaryMpfr", contains = "mpfr", slots = c(names = "character")) print.summaryMpfr <- function (x, digits=max(3L, getOption("digits") - 3L), ...) { xx <- x names(xx) <- NULL # will be lost anyway if(getRversion() >= "3.5.2") { ## for zapsmall() to work finite <- is.finite(xx) xx[finite] <- zapsmall(xx[finite]) } m <- match("NA's", names(xx), nomatch = 0L) xx <- if(m) c(format(xx[-m], digits = digits), `NA's` = as.character(xx[m])) else format(xx, digits = digits) names(xx) <- names(x) print.table(xx, digits = digits, ...) invisible(x) } setMethod(show, "summaryMpfr", function(object) print.summaryMpfr(object)) ## FIXME: can do this considerably faster in C: [which.max(): loc.(first TRUE)] setMethod("which.max", "mpfr", function(x) which.max(x == max(x))) setMethod("which.min", "mpfr", function(x) which.max(x == min(x))) Rmpfr/R/formatHex.R0000644000176200001440000002502514420454417013632 0ustar liggesusers## sprintf("%+13.13a", x) ## hex digits after the hex point = 13 ## precBits: double precision = 53 = 1 + 13*4 ## conversion from Hex digits to binary sequences of digits HextoBin <- c( "0"="0000", "1"="0001", "2"="0010", "3"="0011", "4"="0100", "5"="0101", "6"="0110", "7"="0111", "8"="1000", "9"="1001", "A"="1010", "B"="1011", "C"="1100", "D"="1101", "E"="1110", "F"="1111", "a"="1010", "b"="1011", "c"="1100", "d"="1101", "e"="1110", "f"="1111") if(FALSE) { ## the code isn't using either of these inverses. BintoHex <- names( HextoBin[1:16]) names(BintoHex) <- HextoBin[1:16] Bintohex <- tolower(BintoHex) } ## RMH mentioned that sprintfMpfr() is "parallel" to formatMpfr() ## and agreed that in principle everything should rather be based on formatMpfr(), hence ## sprintMfpr() should become unneeded (or be *based* on formatMpfr() and renamed as basic formatFOO() ## utility for formatHex() style format -- which differs from what the MPFR lib provides (<--> our .mpfr2str()) ##' @title sprintf("%a", *)-like formatting of mpfr numbers ##' @param x mpfr-number vector ##' @param bits integer (scalar) specifing the desired number of bits ("binary digits") ##' @param style 1-character string specifying ##' @return character vector of same length as \code{x} ##' @author Martin Maechler sprintfMpfr <- function(x, bits, style = "+", expAlign=TRUE, showNeg0 = TRUE) { stopifnot(length(style <- as.character(style)) == 1, nchar(style) == 1, style %in% c("+", " "), length(bits) == 1, bits %% 1 == 0) hexdigits <- 1L + (bits-1L) %/% 4L ## common to both branches ### TODO: For consistency, no longer use sprintf() for bits <= 52 ### ---- currently "fails", e.g., in mpfr(formatBin(mpfr(2, 60))) if(bits > 52) { # <== precBits > 53 neg <- sign(x) == -1 ff <- .mpfr2str(x, hexdigits + 1L, maybe.full=FALSE, ## ???? base = 16) ## need +1 if(!showNeg0) { negzero <- substr(ff$str, 1L, 2L) == "-0" ff$str[negzero] <- substr(ff$str[negzero], 2L, 1000000L) ## force "-0" to "0". neg is already consistent. } isNum <- ff$finite ## ff$finite == is.finite(x) i0 <- ff$is.0 ## == mpfrIs0(x) FirstDigit <- substr(ff$str, 1L, 1L) FirstDigit[neg] <- substr(ff$str[neg], 2L, 2L) BinPlace <- c("0"=0, "1"=0, "2"=1, "3"=1, "4"=2, "5"=2, "6"=2, "7"=2, "8"=3, "9"=3, "a"=3, "b"=3, "c"=3, "d"=3, "e"=3, "f"=3) bitMod4 <- 2^BinPlace[FirstDigit] x[isNum] <- x[isNum] / bitMod4[isNum] ## reduce mantissa by 2^BinPlace ff <- .mpfr2str(x, hexdigits + 1L, base = 16) ## revised input value if(!showNeg0) # force "-0" to "0" ff$str[negzero] <- substr(ff$str[negzero], 2L, 1000000L) ex <- ff$exp ## the *decimal* value of base-2 exp : one too large *unless* x == 0 r <- ff$str # the mantissa, including "-" if negative Ex <- ex - 1L if(any(i0)) Ex[i0] <- ex[i0] if(!all(isNum)) ## "@Inf@", "@NaN@", ... r[!isNum] <- gsub("@", '', r[!isNum], fixed=TRUE) if(any(i <- neg & isNum)) ## r[i] <- sub("^-", "-0x", r[i]) wrongly gives e.g. "-0x.18"; want "-0x1.8" r[i] <- paste0("-0x", substr(r[i], 2L, 2L), ".", substring(r[i], 3L), "p") if(any(i <- !neg & isNum)) r[i] <- paste0(style, "0x", substr(r[i], 1L, 1L), ".", substring(r[i], 2L), "p") ## r[isNum] <- paste0(r[isNum], c("", "+")[1+ (isNum & (Ex >= 0))], 4*Ex) Exp <- 4*Ex Exp[!i0] <- Exp[!i0] + BinPlace[FirstDigit[!i0]] ## increase exponent by BinPlace if (expAlign) { Exp.format <- c("%1.1i", "%2.2i", "%3.3i")[max(1, ceiling(log10(max(abs(Exp[isNum])))))] Exp[isNum] <- sprintf(Exp.format, Exp[isNum]) } r[isNum] <- paste0(r[isNum], ## add "+" for positive exponents: c("", "+")[1+(isNum & (Ex >= 0))][isNum], Exp[isNum]) r } else { ## bits <= 52 nX <- as.character(hexdigits) if(!showNeg0) { negzero <- substr(format(x), 1L, 2L) == "-0" x[negzero] <- 0 } result <- sprintf(paste0("%", style, nX, ".", nX, "a"), x) if(any(pInf <- is.infinite(x) & x > 0)) result[pInf] <- sub("+", " ", result[pInf], fixed=TRUE) result } } ##___ ../man/formatHex.Rd ___ ## ~~~~~~~~~~~~ formatHex <- function(x, precBits = min(getPrec(x)), style = "+", expAlign=TRUE) { if (is.numeric(x)) { precBits <- getPrec(x) x <- mpfr(x, precBits) } precB <- as.integer(precBits) structure(sprintfMpfr(x, bits=precB-1L, style=style, expAlign=expAlign), ##--------- dim = dim(x), dimnames = dimnames(x), base = 16L, precBits = precB, class = c("Ncharacter", "character")) } formatBin <- function(x, precBits = min(getPrec(x)), scientific = TRUE, left.pad = "_", right.pad = left.pad, style = "+", expAlign=TRUE) { H <- formatHex(x, precBits=precBits, style=style, expAlign=expAlign) ## bindigits is number of binary digits after the precision point bindigits <- attr(H, "precBits") - 1L ## hexdigits is the number of hex digits after the precision point hexdigits <- 1L + ((bindigits-1L) %/% 4L)# *must* be correct = #{pure digits between "." and "p"} attributes(H) <- NULL finite <- is.finite(x) H <- H[finite] S <- substr(H, 1L, 1L) # sign A <- substr(H, 4L, 4L) B <- substr(H, 6L, 6L+hexdigits-1L) ## assumes *always* an exponent "p" which is correct pow <- substr(H, 6L+hexdigits+1L, 1000000L) sB <- strsplit(B, "") rsB <- do.call(rbind, sB) hrsB <- HextoBin[rsB] dim(hrsB) <- dim(rsB) hrsBa <- apply(hrsB, 1, paste, collapse="") hrsBb <- substr(hrsBa, 1, bindigits) ## While this is a truncation, ## the mpfr conversion assures that ## only zero characters are truncated. if (!scientific) { powers <- as.integer(pow) Left <- -powers + max(powers, 2-precBits) Right <- powers - min(powers, precBits-1) D <- cbind(S, "0b", strrep(left.pad, Left), A, hrsBb, strrep(right.pad, Right)) D2 <- apply(D, 1, function(x) do.call(paste, list(x, collapse=""))) ilft <- as.integer(max(Left) + min(powers)) + 4L res <- paste0(substr(D2, 1L, ilft ), ".", substr(D2, ilft+1L, 1000000L)) } else { res <- cbind(S, "0b", A, ".", hrsBb, "p", pow) res <- apply(res, 1, function(x) do.call(paste, list(x, collapse=""))) } result <- rep("", length(x)) result[finite] <- res result[!finite] <- as.numeric(x[!finite]) structure(result, dim = dim(x), dimnames = dimnames(x), base = 2L, precBits = precBits, class = c("Ncharacter", "character")) } print.Ncharacter <- function(x, ...) { y <- unclass(x) attr(y,"base") <- NULL attr(y,"precBits") <- NULL myR <- attr(x,"base") != 10L ## formatDec() currently left-aligns [yes, this is a hack] ## print(y, quote=FALSE, right = myR, ...) # protecting against multiple 'quote' and 'right' ## ensuring 'quote=*' and 'right=*' in '...' take precedence : pa <- c(list(...), list(quote=FALSE, right = myR)) do.call(print, c(list(y), pa[unique(names(pa))])) invisible(x) } ## RMH 2017-05-23, ~/R/MM/Pkg-ex/Rmpfr/formatDec-revised2.R : formatDec <- function(x, precBits = min(getPrec(x)), digits=decdigits, nsmall=NULL, scientific=FALSE, style="+", decimalPointAlign = TRUE, ...) { if (is.character(x)) x <- as.numeric(x) if (is.numeric(x)) x <- mpfr(x, precBits) else if (is.complex(x)) stop("complex 'x' are not supported in \"Rmpfr\" (yet)") decdigits <- ceiling(log(2^precBits, 10)) + 1 chx <- format(x, digits=max(digits, decdigits), nsmall=nsmall, scientific=scientific, style=style, ...) if (decimalPointAlign) { fin.x <- is.finite(x) chx[fin.x] <- formatAlign(chx[fin.x], ...) } structure(chx, dim = dim(x), dimnames = dimnames(x), base = 10L, precBits = precBits, class = c("Ncharacter", "character")) } ##' Non exported utility currently only used in formatDec(); ##' NB: '...' here, so we can pass '...' above which may have arguments not for here formatAlign <- function(x, leftpad=" ", rightpad=leftpad, ...) { if(!length(x)) return(x) lr <- strsplit(x, ".", fixed=TRUE) l <- sapply(lr, `[`, 1) ## l left r <- sapply(lr, `[`, 2) ## r right r[is.na(r)] <- "" nl <- nchar(l) nr <- nchar(r) ## substring() vectorizes (with 'nl'): l.blank <- substring(strrep(leftpad, max(nl)), 1L, max(nl) - nl) r.blank <- substring(strrep(rightpad,max(nr)), 1L, max(nr) - nr) paste0(l.blank, l, ".", r, r.blank) } ##' used in mpfr.Ncharacter() mpfr_Bcharacter <- function(x, precBits, scientific = NA, ...) { ## was scanBin() stopifnot(is.numeric(precBits)) if (is.na(scientific)) ## we look for a "p" exponent.. scientific <- any(grepl("p", x, fixed=TRUE)) class(x) <- NULL if (!scientific) { x <- gsub("_", "0", x) ## TODO: chartr(.......) } mpfr(x, base = 2, precBits=precBits, ...) } ## A mpfr() method for "Ncharacter" mpfr.Ncharacter <- function(x, precBits = attr(x, "precBits"), ...) { class(x) <- NULL B <- attr(x, "base") if(B == 2) ## formatBin() gives very special format : mpfr_Bcharacter(x, precBits = precBits, ...) else mpfr(x, base = B, precBits = precBits, ...) } ## was ## mpfr.Dcharacter <- function(x, precBits=attr(x, "bindigits")+1, ...) { ## class(x) <- NULL ## mpfr(gsub(" ", "", x), base = 10, precBits=precBits, ...) ## } `[.Ncharacter` <- ## == base :: `[.listof` function (x, ...) structure(NextMethod("["), class = class(x)) ## more sophisticated; should work for matrix subsetting as with base .. `[.Ncharacter` <- function (x, ...) { ax <- attributes(x) ## and *drop* some ax <- ax[setdiff(names(ax), c("dim", "dimnames", "names"))] if(length(ax)) { r <- NextMethod("[") # may have dim, dimnames | names `attributes<-`(r, c(attributes(r), ax)) } else NextMethod("[") } ## Don't seem to get these to work correctly (at least not easily): ## cbind.Bcharacter <- cbind.Hcharacter <- ## function (...) structure(NextMethod("cbind"), class = class(..1)) ## rbind.Bcharacter <- rbind.Hcharacter <- ## function (...) structure(NextMethod("rbind"), class = class(..1)) ## NB: It *could* make sense to set default stringsAsFactors = FALSE here.. ## but it would *not* be used when called from data.frame() which has its own default as.data.frame.Ncharacter <- function (x, ...) { ## class(x) <- class(x)[class(x) != "Ncharacter"] ## as.data.frame(x, ...) NextMethod("as.data.frame") } Rmpfr/R/hjk.R0000644000176200001440000001147312470611664012455 0ustar liggesusers#### #### h o o k e j e e v e s . R Hooke-Jeeves Minimization Algorithm #### ## From: John C Nash ## To: Martin Maechler , Hans Werner Borchers ## ## Subject: Re: Rmpfr for optimization? Minor success. ## Date: Tue, 5 Jun 2012 12:37:19 -0400 ## Changing to hjk routine was a bit easier to deal with. I found main changes ## were to wrap output with as.numeric() to allow cat() to function. ## I'll get no prizes for tidy code, but it is running an n=2 Chebyquad ## minimization, and seems to be working on an n=6. This may be a good way to ## encourage the sale of cpu power. ## Best, JN hjkMpfr <- function(par, fn, control = list(), ...) { ## Following fails when par is mpfr number JN120605 ## if (!is.numeric(par)) ## stop("Argument 'par' must be a numeric vector.", call. = FALSE) n <- length(par) if (n == 1) stop("For univariate functions use some different method.", call. = FALSE) ##-- Control list handling ---------- cntrl <- list(tol = 1.e-06, maxfeval = Inf, # set to Inf if no limit wanted maximize = FALSE, # set to TRUE for maximization target = Inf, # set to Inf for no restriction info = FALSE) # for printing interim information nmsCo <- match.arg(names(control), choices = names(cntrl), several.ok = TRUE) if (!is.null(names(control))) cntrl[nmsCo] <- control tol <- cntrl$tol; maxfeval <- cntrl$maxfeval maximize <- cntrl$maximize target <- cntrl$target info <- cntrl$info scale <- if (maximize) -1 else 1 fun <- match.fun(fn) f <- function(x) scale * fun(x, ...) ##-- Setting steps and stepsize ----- nsteps <- floor(log2(1/tol)) # number of steps steps <- 2^c(-(0:(nsteps-1))) # decreasing step size dir <- diag(1, n, n) # orthogonal directions x <- par # start point fx <- f(x) # smallest value so far fcount <- 1 # counts number of function calls if (info) cat(sprintf("step nofc %-12s | %20s\n", "fmin", "xpar")) ##-- Start the main loop ------------ ns <- 0 while (ns < nsteps && fcount < maxfeval && abs(fx) < target) { ns <- ns + 1 hjs <- .hjsearch(x, f, steps[ns], dir, fcount, maxfeval, target) x <- hjs$x fx <- hjs$fx ## found <- hjs$found fcount <- fcount + hjs$finc if (info) cat(sprintf("%4d %5d %-12.7g | %-20.15g %-20.15g%s\n", ns, fcount, as.numeric(fx/scale), as.numeric(x[1]), as.numeric(x[2]), if(n > 2)" ....")) } conv <- if (fcount > maxfeval) { warning("Function evaluation limit exceeded -- may not converge.") FALSE } else if (abs(fx) > target) { warning("Function exceeds min/max value -- may not converge.") FALSE } else TRUE fx <- fx / scale # undo scaling list(par = x, value = fx, convergence = conv, feval = fcount, niter = ns) } ## Search with a single scale ----------------------------- .hjsearch <- function(xb, f, h, dir, fcount, maxfeval, target) { xc <- x <- xb finc <- 0 hje <- .hjexplore(xb, xc, f, h, dir) x <- hje$x fx <- hje$fx found <- hje$found finc <- finc + hje$numf ## Pattern move while (found) { d <- x-xb xb <- x xc <- x+d fb <- fx hje <- .hjexplore(xb, xc, f, h, dir, fb) x <- hje$x fx <- hje$fx found <- hje$found finc <- finc + hje$numf if (!found) { # pattern move failed hje <- .hjexplore(xb, xb, f, h, dir, fb) x <- hje$x fx <- hje$fx found <- hje$found finc <- finc + hje$numf } if (fcount + finc > maxfeval || abs(fx) > target) break } list(x = x, fx = fx, found=found, finc=finc) } ## Exploratory move --------------------------------------- .hjexplore <- function(xb, xc, f, h, dir, fbold) { n <- length(xb) x <- xb if (missing(fbold)) { fb <- f(x) numf <- 1 } else { fb <- fbold numf <- 0 } fx <- fb xt <- xc found <- FALSE # do we find a better point ? dirh <- h * dir fbold <- fx for (k in sample.int(n, n)) { # resample orthogonal directions p <- xt + (d. <- dirh[, k]) fp <- f(p) numf <- numf + 1 if (fp >= fb) { p <- xt - d. fp <- f(p) numf <- numf + 1 } if (fp < fb) { found <- TRUE xt <- p fb <- fp } } if(found) { x <- xt fx <- fb } list(x = x, fx = fx, found=found, numf = numf) } Rmpfr/R/unirootR.R0000644000176200001440000003522214411121562013506 0ustar liggesusers### This is a translation of R_zeroin2 in ~/R/D/r-devel/R/src/appl/zeroin.c ### from C to R by John Nash, ### ---> file rootoned/R/zeroin.R of the new (2011-08-18) R-forge package rootoned ### ### Where John Nash calls it zeroin(), I call it unirootR() ##' Simple modification of uniroot() which should work with mpfr-numbers ##' MM: uniroot() is in ~/R/D/r-devel/R/src/library/stats/R/nlm.R ##' unirootR <- function(f, interval, ..., lower = min(interval), upper = max(interval), f.lower = f(lower, ...), f.upper = f(upper, ...), extendInt = c("no", "yes", "downX", "upX"), trace = 0, verbose = as.logical(trace), verbDigits = max(3, min(20, -log10(tol)/2)), tol = .Machine$double.eps^0.25, maxiter = 1000L, check.conv = FALSE, ## Rmpfr-only: warn.no.convergence = !check.conv, epsC = NULL) { if(!missing(interval) && length(interval) != 2L) stop("'interval' must be a vector of length 2") ## For many "quick things", we will use as.numeric(.) but we do *NOT* assume that ## lower and upper are numeric! .N <- as.numeric if(lower >= upper) # (may be mpfr-numbers *outside* double.xmax) stop("lower < upper is not fulfilled") if(is.na(.N(f.lower))) stop("f.lower = f(lower) is NA") if(is.na(.N(f.upper))) stop("f.upper = f(upper) is NA") form <- function(x, digits = verbDigits) format(x, digits=digits, drop0trailing=TRUE) formI <- function(x, di = getOption("digits")) format(x, digits=di, drop0trailing=TRUE) Sig <- switch(match.arg(extendInt), "yes" = NULL, "downX"= -1, "no" = 0, "upX" = 1, stop("invalid 'extendInt'; please report")) ## protect against later 0 * Inf |--> NaN and Inf * -Inf. truncate <- function(x) { ## NA are already excluded; deal with +/- Inf if(is.numeric(x)) pmax.int(pmin(x, .Machine$double.xmax), -.Machine$double.xmax) else if(inherits(x, "mpfr") && is.infinite(x)) # use maximal/minimal mpfr-number instead: sign(x) * mpfr(2, .getPrec(x))^((1 - 2^-52)*.mpfr_erange("Emax")) else x } f.low. <- truncate(f.lower) f.upp. <- truncate(f.upper) doX <- ( is.null(Sig) && f.low. * f.upp. > 0 || is.numeric(Sig) && (Sig*f.low. > 0 || Sig*f.upp. < 0)) if(doX) { ## extend the interval = [lower, upper] if(trace) cat(sprintf("search {extendInt=\"%s\", Sig=%s} in [%s,%s]%s", extendInt, formI(Sig), formI(lower), formI(upper), if(trace >= 2)"\n" else " ... ")) Delta <- function(u) 0.01* pmax(1e-4, abs(u)) ## <-- FIXME? [= R's uniroot() for double] it <- 0L ## Two cases: if(is.null(Sig)) { ## case 1) 'Sig' unspecified --> extend (lower, upper) at the same time delta <- Delta(c(lower,upper)) while(isTRUE(f.lower*f.upper > 0) && any(iF <- is.finite(c(lower,upper)))) { if((it <- it + 1L) > maxiter) stop(gettextf("no sign change found in %d iterations", it-1), domain=NA) if(iF[1]) { ol <- lower; of <- f.lower if(is.na(f.lower <- f(lower <- lower - delta[1], ...))) { lower <- ol; f.lower <- of; delta[1] <- delta[1]/4 } } if(iF[2]) { ol <- upper; of <- f.upper if(is.na(f.upper <- f(upper <- upper + delta[2], ...))) { upper <- ol; f.upper <- of; delta[2] <- delta[2]/4 } } if(trace >= 2) cat(sprintf(" .. modified lower,upper: (%15g,%15g)\n", .N(lower), .N(upper))) delta <- 2 * delta } } else { ## case 2) 'Sig' specified --> typically change only *one* of lower, upper ## make sure we have Sig*f(lower) <= 0 and Sig*f(upper) >= 0: delta <- Delta(lower) while(isTRUE(Sig*f.lower > 0)) { if((it <- it + 1L) > maxiter) stop(gettextf("no sign change found in %d iterations", it-1), domain=NA) f.lower <- f(lower <- lower - delta, ...) if(trace >= 2) cat(sprintf(" .. modified lower: %s, f(.)=%s\n", formI(lower), formI(f.lower))) delta <- 2 * delta } delta <- Delta(upper) while(isTRUE(Sig*f.upper < 0)) { if((it <- it + 1L) > maxiter) stop(gettextf("no sign change found in %d iterations", it-1), domain=NA) f.upper <- f(upper <- upper + delta, ...) if(trace >= 2) cat(sprintf(" .. modified upper: %s, f(.)=%s\n", formI(upper), formI(f.upper))) delta <- 2 * delta } } if(trace && trace < 2) cat(sprintf("extended to [%s, %s] in %d steps\n", formI(lower), formI(upper), it)) } if(!isTRUE(sign(f.lower) * sign(f.upper) <= 0)) stop(if(doX) "did not succeed extending the interval endpoints for f(lower) * f(upper) <= 0" else sprintf("f() values at end points = (%s, %s) not of opposite sign", formI(f.lower), formI(f.upper))) if(is.null(epsC) || is.na(epsC)) { ## determine 'epsC' ``the achievable Machine precision'' ## -- given the class of f.lower, f.upper ff <- f.lower * f.upper if(is.double(ff)) epsC <- .Machine$double.eps else if(is(ff, "mpfr")) epsC <- 2^-min(getPrec(f.lower), getPrec(f.upper)) else { ## another number class -- try to see if getPrec() is defined.. ## if not, there's not much we can do if(is(prec <- tryCatch(min(getPrec(f.lower), getPrec(f.upper)), error = function(e)e), "error")) { warning("no valid getPrec() for the number class(es) ", paste(unique(class(f.lower),class(f.upper)), collapse=", "), ".\n Using double precision .Machine$double.eps.") epsC <- .Machine$double.eps } else { epsC <- 2^-prec message("using epsC = %s ..", format(epsC)) } } } if(tol < epsC / 8) # "8 fudge factor" (otherwise happens too often) warning(sprintf("tol (%g) < epsC (%g) is rarely sensical, and the resulting precision is probably not better than epsC", tol, epsC)) ## Instead of the call to C code, now "do it in R" : ## val <- .Internal(zeroin2(function(arg) as.numeric(f(arg, ...)), ## lower, upper, f.lower, f.upper, ## tol, as.integer(maxiter))) a <- lower # interval[1] b <- upper # interval[2] fa <- f.lower # f(ax, ...) fb <- f.upper # f(bx, ...) if (verbose) cat(sprintf("==> Start zeroin: f(%g)= %g; f(%g)= %g\n", .N(a), .N(fa), .N(b), .N(fb))) c <- a fc <- fa ## First test if we have found a root at an endpoint maxit <- maxiter + 2L # count evaluations as maxiter-maxit converged <- FALSE while(!converged && maxit > 0) { ##---- Main iteration loop ------------------------------ if (verbose) cat("Iteration >>>", maxiter+3L-maxit, "<<< ;") d.prev <- b-a ## Distance from the last but one to the last approximation */ ##double tol.2; ## Actual tolerance */ ##double p; ## Interpolation step is calcu- */ ##double q; ## lated in the form p/q; divi- ## * sion operations is delayed ## * until the last moment */ ##double d.new; ## Step at this iteration */ if(abs(fc) < abs(fb)) { ## Swap data for b to be the smaller if (verbose) cat(sprintf("fc (=%s) smaller than fb\n", form(fa))) a <- b b <- c c <- a ## best approximation fa <- fb fb <- fc fc <- fa } tol.2 <- 2*epsC*abs(b) + tol/2 d.new <- (c-b)/2 # bisection if (verbose) cat("tol.2(epsC,b) = ",.N(tol.2), "; d.new= ",.N(d.new),"\n", sep="") ## converged <- (abs(d.new) <= tol.2 && is.finite(fb)) || fb == 0 converged <- (abs(d.new) <= tol.2) || fb == 0 if(converged) { if (verbose) cat("DONE! -- small d.new or fb=0\n") ## Acceptable approx. is found : val <- list(root=b, froot=fb, rtol = abs(c-b), maxit=maxiter-maxit) } else { ## Decide if the interpolation can be tried */ if( (abs(d.prev) >= tol.2) ## If d.prev was large enough*/ && (abs(fa) > abs(fb)) ) { ## and was in true direction, ## Interpolation may be tried */ ## register double t1,cb,t2; if (verbose) cat("d.prev larger than tol.2 and fa bigger than fb --> ") cb <- c-b if (a == c) { ## If we have only two distinct points, linear interpolation ## can only be applied t1 <- fb/fa p <- cb*t1 q <- 1 - t1 if (verbose) cat("a == c: ") } else { ## Quadric inverse interpolation*/ if (verbose) cat("a != c: ") q <- fa/fc t1 <- fb/fc t2 <- fb/fa p <- t2 * ( cb*q*(q-t1) - (b-a)*(t1-1) ) q <- (q-1) * (t1-1) * (t2-1) } if(p > 0) { ## p was calculated with the */ if (verbose) cat(" p > 0; ") q <- -q ## opposite sign; make p positive */ } else { ## and assign possible minus to */ if (verbose) cat(" p <= 0; ") p <- -p ## q */ } if (p < 0.75*cb*q - abs(tol.2*q)/2 ## If b+p/q falls in [b,c]*/ && p < abs(d.prev*q/2)) { ## and isn't too large */ if (verbose) cat("p satisfies conditions for changing d.new\n") d.new <- p/q ## it is accepted } else if(verbose) cat("\n") ## If p/q is too large, then the ## bisection procedure can reduce [b,c] range to more extent } if( abs(d.new) < tol.2) { ## Adjust the step to be not less than tolerance if (verbose) cat("d.new smaller than tol.2, adjusted to it.\n") d.new <- if(d.new > 0) tol.2 else -tol.2 } a <- b fa <- fb ## Save the previous approx. */ b <- b + d.new fb <- f(b, ...) if (verbose) cat(sprintf("new f(b=%s) = %s;\n", form(b), form(fb))) maxit <- maxit-1 ## Do step to a new approxim. */ if( ((fb > 0) && (fc > 0)) || ((fb < 0) && (fc < 0)) ) { if (verbose) cat(sprintf(" make c:=a=%s to have sign opposite to b: f(c)=%s\n", form(a), form(fa))) ## Adjust c for it to have a sign opposite to that of b */ c <- a fc <- fa } }## else not converged } ## end{ while(maxit > 0) } -------------------------------------------- if(converged) { iter <- val[["maxit"]] if(!is.na(fb) && abs(fb) > 0.5*max(abs(f.lower), abs(f.upper)))# from John Nash: warning("Final function magnitude seems large -- maybe converged to sign-changing 'pole' location?") } else { ## (!converged) : failed! if(check.conv) stop("no convergence in zero finding in ", iter, " iterations") ## else val <- list(root= b, rtol = abs(c-b)) iter <- maxiter if(warn.no.convergence) warning("_NOT_ converged in ", iter, " iterations") } list(root = val[["root"]], f.root = f(val[["root"]], ...), iter = iter, estim.prec = .N(val[["rtol"]]), converged = converged) } ## {unirootR} ### qnorm() via inversion of pnorm() by unirootR() ========================== " qnorm(p) == q <==> pnorm(q) == p " ##====== TODO: Use good i.e. *tight* inequalities for Phi(x) .. which are invertible ## ===== to (still tight) inequalities for Phi^{-1}(x) == qnorm(x) ## ===> get good *start* interval for unirootR() ## qnorm (p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE) qnormI <- function(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE, trace = 0, verbose = as.logical(trace), # <- identical defaults as unirootR() tol, # for "base" = .Machine$double.eps^0.25, but here use getPrec() useMpfr = any(prec > 53), # if true, use mpfr give.full = FALSE, ...) # <- arguments to pass to unirootR() { ## The function whose "zeros" aka "roots" we want to find: zFun <- function(q) pnorm(q, mean=mean, sd=sd, lower.tail=lower.tail, log.p=log.p) - p. if(missing(tol) || !is.finite(tol)) { prec <- max(getPrec(if(missing(mean) && missing(sd)) p else p+(mean+sd))) ## not max(getPrec(c(p, mean, sd))) as it's >= 128 by default tol <- 2^-(prec + 2) # 2^(-prec - 1) gives less accurate } else prec <- as.integer(ceiling(1 - log2(tol))) ## if(verbose) cat(sprintf("prec=%d ==> useMpfr=%s:\n", prec, format(useMpfr))) verbDigs <- if(any(is.vd <- "verbDigits" == ...names())) ...elt(which(is.vd)) else max(3, min(20, -log10(tol)/2)) if(useMpfr) { ## This **IS** important here: old_eranges <- .mpfr_erange() # typically -/+ 2^30 myERng <- (1-2^-52) * .mpfr_erange(c("min.emin","max.emax")) if(!isTRUE(all.equal(myERng, old_eranges))) { .mpfr_erange_set(value = myERng) on.exit( .mpfr_erange_set( , old_eranges) ) } } sgn <- if(lower.tail) -1 else 1 INf <- if(lower.tail) Inf else -Inf ## "start"-interval for unirootR() --- see 'TODO' .. *tight* .. above <<<<<<<< ## Notably for the relevant (p <<< -1, log.p=TRUE) case ! qnInt <- if(log.p) { Pi <- if(useMpfr) Const("pi", prec) else pi function(p) { s2 <- -2*p if(useMpfr && !inherits(s2, "mpfr")) s2 <- mpfr(s2, precBits = prec) xs1 <- s2 - log(2*Pi*s2) if(p < -54) { qn <- sqrt(s2 - log(2*Pi*xs1)); e <- 1e-4 } else if(p <= -15) { qn <- sqrt(s2 - log(2*Pi*xs1) - 1/(2 + xs1)); e <- 1e-3 } else { # p >= -15 qn <- stats__qnorm(asNumeric(p), log.p=TRUE) ## FIXME: not good enough, e.g., for p = mpfr(-1e-5, 128) e <- 1e-2 } qn*(sgn + c(-e,e)) } } else { ## log.p is FALSE Id <- if(useMpfr) function(.) mpfr(., precBits = prec) else identity function(p) { q <- stats__qnorm(asNumeric(p), lower.tail=lower.tail) Id(if(abs(q) < 1e-3) c(-2,2)*1e-3 else c(.99, 1.01) * q) } } ## Deal with prob in {0, 1} which correspond to quantiles -/+ Inf : ## idea from {DPQ}'s .D_0 and .D_1 : .p_1 <- as.integer(!log.p) .p_0 <- if (log.p) -Inf else 0 r <- if(give.full) vector("list", length(p)) else if(useMpfr) mpfr(p, precBits=prec) else p for(ip in seq_along(p)) { p. <- p[ip] if(verbose) cat(sprintf("p. = p[ip=%d] = %s:\n", ip, format(p., digits = verbDigs, drop0trailing=TRUE))) ri <- if (p. == .p_1) INf else if (p. == .p_0) -INf else if(is.na(p.) || p. > .p_1 || p. < .p_0) NaN else { ## zFun() uses p. ur <- unirootR(zFun, interval = qnInt(p.), extendInt = if(lower.tail) "upX" else "downX", trace=trace, verbose=verbose, tol=tol, ...) # verbDigits, maxiter, check.conv, warn.no.convergence, epsC if(give.full) ur else ur$root } if(give.full) r[[ip]] <- ri else r[ip] <- ri } r } Rmpfr/R/integrate-Romberg.R0000644000176200001440000001077212402301607015243 0ustar liggesusers#### Romberg integration in pure R #### =================== ====== so it can be used with Rmpfr ## TODO: Lauren K would like to get return()ed all the intermediate sums as well ## ---- I agree: but only if 'all.sums = TRUE' integrateR <- function(f, lower, upper, ..., ord = NULL, rel.tol = .Machine$double.eps^0.25, abs.tol = rel.tol, max.ord = 19, verbose = FALSE) { stopifnot(length(lower) == 1, length(upper) == 1, is.finite(lower), is.finite(upper)) f <- match.fun(f) ff <- ## if(verbose) function(x) { cat("f(x), x="); str(x) ; f(x, ...) } else function(x) f(x, ...) null.ord <- is.null(ord) ## ord := Romberg order has.tol <- !missing(rel.tol) || !missing(abs.tol)# one of them specified if(chkConv <- (null.ord || has.tol)) { ## will use rel.tol and abs.tol if (abs.tol <= 0 && rel.tol < max(50 * .Machine$double.eps, 5e-29)) stop("invalid tolerance values") ## but need (maximal) order for Bauer's algorithm: } if(null.ord && !has.tol) { ## This is "approximate" (and too large, typically); but if it's ## too small, t[.] will be extended automatically: ord <- ## == max(3, min(25, ceiling(-log2(rel.tol)))) with default rel.tol 13 if(verbose) cat("ord =", ord, "(as no '*.tol' specified)\n") } useOrd <- !null.ord || !has.tol if(useOrd) { stopifnot(ord >= 0) if(verbose) cat(sprintf( " ord = %d; ==> evaluating integrand at %s 2^(ord+1)-2 = %d locations\n", ord, if(chkConv) "up to" else "", 2^(ord+1)-2)) } ### Bauer(1961) "Algorithm 60 -- Romberg Integration" Comm.ACM 4(6), p.255 m <- le <- upper - lower # 'l' ## a "hack", but really improves the result: if(!is.numeric(m)) { if(is(m, "mpfr")) { # should get *same* precision if(is.numeric(lower)) lower <- 0*m+ lower if(is.numeric(upper)) upper <- 0*m+ upper } else { ## other high-precision... if(is.numeric(lower)) lower <- as(lower, class(m)) if(is.numeric(upper)) upper <- as(upper, class(m)) } } t1 <- (ff(lower) + ff(upper))/2 t <- rep(t1, if(useOrd) ord+1 else 10)## <- must work for "mpfr" numbers one <- 1 + 0*t1 # for "mpfr" r. <- t[1]*le n <- 1 # 'n'(Bauer) = 2^n (Romberg Algo) if(verbose) { ## In "mpfr" case, cannot use sprintf("%g"); ## ==> rather use format(.) with higher number of digits prDigs <- max(10, min(50, 2 + ceiling(-log10(rel.tol)))) FORM <- paste0("n=%2d, 2^n=%9.0f | I = %",(5+prDigs), "s, abs.err =%14s\n") } h <- 1L repeat { if(verbose >= 2) { cat("range(le*t[1:h]):\n\t"); print(format(range(le*t[1:h]), digits=15), quote=FALSE) } u <- 0 m <- m/2 # == le/(2*n) ## here, we require f(.) to be vectorized: u <- sum(ff(lower+ seq(1, 2*n-1, by=2)*m)) t[h+1L] <- (u/n + t[h])/2 f. <- one for(j in h:1) { f. <- 4*f. t[j] <- t[j+1] + (t[j+1] - t[j])/ (f. - 1) } r <- t[1]*le aErr <- abs(r - r.) if(verbose) cat(sprintf(FORM, h, 2*n, format(r, digits = prDigs), format(aErr, digits = max(7, getOption("digits"))))) if(chkConv) { ## check if we converged: |r - r.| < min(.,.): *both* tolerances must be satisfied if(converged <- (aErr < min(abs(r)*rel.tol, abs.tol))) break } if((useOrd && h >= ord) || h >= max.ord) break r. <- r n <- 2*n # == 2^h h <- h+1L } if(chkConv && !converged) { relE <- format(aErr/abs(r), digits=getOption("digits")) msg <- paste0("no convergence up to order ", ord, "; last relative change = ", relE, "\n", "Consider setting 'ord = ' (e.g. = ", ord+1,").") warning(msg) } else msg <- "OK" r <- list(value = r, abs.error = aErr, subdivisions = 2*n+1, "message" = msg, call = match.call()) class(r) <- c("integrateR", "integrate") r } ## This is such that print.integrate() calls our format() method ## (and do *not* hide it via S3method() in NAMESPACE): ## print.integrate <- getS3method("print","integrate")# from 'stats' possibly not exported ## environment(print.integrate) <- environment() ## setMethod(show, "integrate", function(object) print.integrate(object)) print.integrateR <- function (x, digits = max(3, getOption("digits")-2), ...) { if(x[["message"]] != "OK") cat("Non-convergence message ", sQuote(x$message), "\n", sep = "") ## The "Ok" message: cat(format(x$value, digits = digits), " with absolute error < ", format(x$abs.error, digits=digits), "\n", sep = "") invisible(x) } setMethod(show, "integrateR", function(object) print.integrateR(object)) Rmpfr/R/as.R0000644000176200001440000003362114552770112012300 0ustar liggesusers#### All coercion methods for the "Rmpfr" classes if(getRversion() < "3.5") { isFALSE <- function (x) is.logical(x) && length(x) == 1L && !is.na(x) && !x isTRUE <- function (x) is.logical(x) && length(x) == 1L && !is.na(x) && x if(getRversion() < "3.3") strrep <- function (x, times) { ## (x, times) must be "recycled" if((lx <- length(x)) < (lt <- length(times))) x <- rep_len(x, lt) else if(lt < lx) times <- rep_len(times, lx) vapply(seq_along(x), function(i) paste(rep.int(x[i], times[i]), collapse = ""), "") } if(getRversion() < "3.2") lengths <- function(x, use.names = TRUE) vapply(x, length, 1L, USE.NAMES = use.names) } ##' fast pre-test (for numeric, bigz, bigq, ..): is.mpfr <- function(x) isS4(x) && is(x, "mpfr") mpfr <- function(x, precBits, ...) UseMethod("mpfr") mpfr.mpfr <- function(x, precBits, rnd.mode = c('N','D','U','Z','A'), ...) roundMpfr(x, precBits=precBits, rnd.mode=rnd.mode) mpfr.bigz <- function(x, precBits, ...) { if(missing(precBits)) precBits <- max(2L, frexpZ(x)$exp) if(getOption("verbose")) warning("mpfr() --> .bigz2mpfr() [not efficiently via character]") ..bigz2mpfr(x, precBits) } mpfr.bigq <- function(x, precBits, ...) { if(missing(precBits)) precBits <- getPrec(x)#-> warning if(getOption("verbose")) warning("mpfr() --> .bigq2mpfr() [not efficiently via character]") ..bigq2mpfr(x, precBits) } mpfr.NULL <- function(x, ...) mpfr(logical(), ...) mpfr.default <- function(x, precBits, base = 10, rnd.mode = c('N','D','U','Z','A'), scientific = NA, ...) { if(is.ch <- is.character(x)) stopifnot(length(base) == 1, 2 <= base, base <= 62) else if(is.raw(x)) { # is.raw() is faster stopifnot(missing(precBits) || precBits >= 2) ## else warning("unrecognized raw 'x'") # <- ?? {see use in ../tests/create.R } ## {but 'raw' is treated below} } else { ## typically the result of Vectorize() or similar on "mpfr" if(is.list(x) && all(lengths(lc <- lapply(x, class)) == 1L) && all(unlist(lc) == "mpfr1")) return(new("mpfr", x)) } if(missing(precBits)) { precBits <- getPrec(x, base = base, doNumeric = FALSE) } stopifnot(precBits >= 2, ## libmpfr exits (after good error message) for precBits == 1 is.character(rnd.mode <- toupper(rnd.mode))) rnd.mode <- match.arg(rnd.mode) ml <- if(is.numeric(x) || is.logical(x) || is.raw(x)) .Call(d2mpfr1_list, x, precBits, rnd.mode) else if(is.ch) .Call(str2mpfr1_list,x, precBits, base, rnd.mode) else stop("invalid 'x'. Must be numeric (logical, raw) or character") if(is.array(x)) { dim <- dim(x) ; dn <- dimnames(x) new(if(length(dim) == 2) "mpfrMatrix" else "mpfrArray", ml, Dim = dim, Dimnames = if(is.null(dn)) vector("list", length(dim)) else dn) } else new("mpfr", ml) } ## mpfr.default() .mpfr <- function(x, precBits) new("mpfr", .Call(d2mpfr1_list, x, precBits, "N")) .mpfr. <- function(x, precBits, rnd.mode) new("mpfr", .Call(d2mpfr1_list, x, precBits, rnd.mode)) ##' to be used in our own low-level R programming .d2mpfr1 <- function(x, precBits) .Call(d2mpfr1, x, precBits, "N") setAs("numeric", "mpfr1", ## use default precision of 128 bits function(from) .Call(d2mpfr1, from, 128L, "N"))# <- round to [N]earest setAs("numeric", "mpfr", function(from) .mpfr(from, 128L)) setAs("integer", "mpfr", function(from) .mpfr(from, 32L)) setAs("raw", "mpfr", function(from) .mpfr(from, 8L)) setAs("logical", "mpfr", function(from) .mpfr(from, 2L)) ## TODO? base=16 for "0x" or "0X" prefix -- but base must have length 1 .. setAs("character", "mpfr", function(from) mpfr(from)) .mpfr2d <- function(from) .Call(mpfr2d, from, rnd.mode="N") .mpfr2i <- function(from) .Call(mpfr2i, from, rnd.mode="N") setAs("mpfr", "numeric", .mpfr2d) setAs("mpfr", "integer", .mpfr2i) setMethod("as.numeric", "mpfr", function(x, rnd.mode="N") .Call(mpfr2d, x, rnd.mode)) ## "Z": round towards [Z]ero -- crucial for as.integer() : setMethod("as.integer", "mpfr", function(x, rnd.mode="Z") .Call(mpfr2i, x, rnd.mode)) ## FIXME (in gmp!!): asNumeric() should get "..." argument setMethod("asNumeric", "mpfr", function(x) .Call(mpfr2d, x, rnd.mode="N")) setMethod("asNumeric", "mpfrArray", function(x) toNum(x, rnd.mode="N")) setAs("mpfr1", "numeric", ## just for user-de-confusion : function(from) { warning("coercing \"mpfr1\" via \"mpfr\" (inefficient)") as(new("mpfr", list(from)), "numeric") }) setAs("mpfr1", "mpfr", function(from) new("mpfr", list(from))) setAs("mpfr", "mpfr1", function(from) { if(length(from) == 1) getD(from)[[1]] else stop("only \"mpfr\" objects of length 1 can be coerced to \"mpfr1\"") }) .mpfr1tolist <- function(x) sapply(.slotNames(x), slot, object=x, simplify=FALSE) .mpfr2list <- function(x, names=FALSE) { if(isTRUE(names)) names <- format(x) x <- lapply(getD(x), .mpfr1tolist) if(is.character(names)) names(x) <- names x } ## Breaks the working of vapply(q, FUN.x) in pbetaI() in ./special-fun.R : ## as.list.mpfr1 <- function(x, ...) .mpfr1tolist(x) ## as.list.mpfr <- function(x, ...) .mpfr2list(x) ## and then mpfrXport <- function(x, names=FALSE) { if(!is.mpfr(x)) stop("argument is not a \"mpfr\" object") structure(class = "mpfrXport", list(gmp.numb.bits = .mpfr_gmp_numbbits(), ## currently unused, but in case: mpfr.version = .mpfrVersion(), Machine = .Machine[grepl("sizeof",names(.Machine))], Sys.info = Sys.info()[c("sysname", "machine")], mpfr = .mpfr2list(x, names=names))) } mpfrImport <- function(mxp) { if(!inherits(mxp, "mpfrXport")) stop("need an \"mpfrXport\" object") nbits <- .mpfr_gmp_numbbits() if(!identical(nbits, mxp$gmp.numb.bits)) stop("GMP bits not matching: 'x' has ", mxp$gmp.numb.bits, "; the loaded 'Rmpfr' package has ", nbits) m1 <- lapply(mxp$mpfr, function(o) do.call(new, c("mpfr1", o))) new("mpfr", m1) } .mpfr2str <- function(x, digits = NULL, maybe.full = !is.null(digits), base = 10L) { ## digits = NULL : use as many digits "as needed" for the precision stopifnot(is.null(digits) || (is.numeric(digits) && length(digits) == 1 && digits >= 0), is.logical(maybe.full), length(maybe.full) == 1L, !is.na(maybe.full), is.numeric(base), length(base) == 1L, base == as.integer(base), 2 <= base, base <= 62) if(!is.null(digits) && digits == 1 && base %in% 2L^(1:5)) { ## MPFR mpfr_get_str(): "N must be >= 2"; we found that N = 1 is ok unless ## for these bases where it aborts (in C). ==> prevent that: digits <- 2L message(gettextf("base = %d, digits = 1 is increased to digits = 2", base)) } .Call(mpfr2str, x, digits, maybe.full, base) # -> ../src/convert.c } ##' very low level version, not exported : ..mpfr2str <- function(x, digits = NULL, maybe.full = !is.null(digits), base = 10L) .Call(mpfr2str, x, digits, maybe.full, base) # -> ../src/convert.c ##' more efficient, just getting the (exp, finite, is0) list, 'exp' wrt base = 2 .mpfr_formatinfo <- function(x) .Call(R_mpfr_formatinfo, x) ##' getting the 'exp' (wrt base = 2) only [also for extended erange!] .mpfr2exp <- function(x) .Call(R_mpfr_2exp, x) ldexpMpfr <- function(f, E, rnd.mode = c('N','D','U','Z','A')) { stopifnot(is.character(rnd.mode <- toupper(rnd.mode))) new("mpfr", .Call(R_mpfr_ldexp, f, E, match.arg(rnd.mode))) } frexpMpfr <- function(x, rnd.mode = c('N','D','U','Z','A')) { stopifnot(is.character(rnd.mode <- toupper(rnd.mode))) .Call(R_mpfr_frexp, x, match.arg(rnd.mode)) } formatMpfr <- function(x, digits = NULL, trim = FALSE, scientific = NA, maybe.full = (!is.null(digits) && is.na(scientific)) || isFALSE(scientific), base = 10, showNeg0 = TRUE, max.digits = Inf, big.mark = "", big.interval = 3L, small.mark = "", small.interval = 5L, decimal.mark = ".", exponent.char = if(base <= 14) "e" else if(base <= 36) "E" else "|e", exponent.plus = TRUE, zero.print = NULL, drop0trailing = FALSE, ...) { ## digits = NULL : use as many digits "as needed" ff <- .mpfr2str(x, digits, maybe.full=maybe.full, base=base) # (checks its args!) ## FIXME/TODO: If have very large numbers, but not high precision, should detect it ## ========== and use maybe.full = FALSE also for the default scientific = NA ## digs.x <- ceiling(.getPrec(x) / log2(base)) stopifnot(length(scientific) == 1L) ### max.digits "doomed": scientific := number, (~= getOption("scipen")) should replace it stopifnot(is.numeric(max.digits), max.digits > 0) if(is.numeric(digits)) stopifnot(digits <= max.digits) isNum <- ff$finite ## ff$finite == is.finite(x) i0 <- ff$is.0 ## == mpfrIs0(x) ex <- ff$exp ## the *decimal* exp (wrt given 'base' !): one too large *unless* x == 0 r <- ff$str r.dig <- nchar(r) # (in both cases, digits NULL or not) ## Note that r.dig[] entries may vary, notably for digits NULL when .getPrec(x) is non-constant if(any(Lrg <- r.dig > max.digits)) { ## now "cut down", e.g. in print() when max.digits < Inf r [Lrg] <- substr(r[Lrg], 1L, max.digits) r.dig[Lrg] <- max.digits } if(any(i0)) { ## sign(x) == -1 "fails" for '-0' hasMinus <- substr(ff$str, 1L,1L) == "-" if(!showNeg0 && any(iN0 <- hasMinus & i0)) { ## get rid of "-" for "negative zero" r[iN0] <- substring(r[iN0], 2) hasMinus[iN0] <- FALSE } Ex <- ex Ex[!i0] <- ex[!i0] - 1L } else { Ex <- ex - 1L hasMinus <- sign(x) == -1 } if(!all(isNum)) ## "@Inf@", "@NaN@", ... r[!isNum] <- gsub("@", '', r[!isNum], fixed=TRUE) ##' (maybe) add decimal point after position k patch <- function(str, k) paste(substr (str, 1L, k), substring(str, k+1L), sep = decimal.mark) ## scipen := penalty for using "scientific", i.e., exponential format scipen <- if(is.na(scientific)) as.numeric(getOption("scipen")) else if(!(is.logical(scientific) || (is.numeric(scientific) && round(scientific) == scientific))) stop("'scientific' must be logical or a whole number") else if(is.logical(scientific)) { if(scientific) -32L else max(Ex) + 64 # << penalize much } else ## is.numeric(scientific) and a whole number scientific ## This very much depends on the desired format. ## if(scientific) --> all get a final "e"; otherwise, we ## adopt the following simple scheme : ### TODO: new argument jointly = (NA | TRUE | FALSE) or just (T | F) ### ---- if(jointly) use scalar ("global") hasE and have things *align* ## 'hasE' is *vector* (along 'x') : hasE <- { if(isTRUE(scientific)) TRUE ## hasE := (wF <= wE + scipen) , where (in R's format.default, which has jointly = TRUE ): ## ~~~~~~~~~~~~~~~~ ## wE = neg + (d > 0) + d + 4 + e (width for E format); d = mxns - 1, mxns = max_i{nsig_i} ## e = #{digits of exponent} -1 (= 1 or 2 in R) ## wF = mxsl + rgt + (rgt != 0); rgt := max_i{ (digits right of ".")_i } ## mxsl := max_i{sleft_i}; sleft_i = sign_i + (digits left of ".")_i else { ## scientific = (FALSE | NA | number) --- for now : if(is.na(scientific)) scientific <- scipen isNum & (Ex < -4 - scipen | Ex > r.dig) } } if(aE <- any(ii <- isNum & hasE)) { ii <- which(ii) i. <- 1L + hasMinus r[ii] <- patch(r[ii], i.[ii]) if(drop0trailing) ## drop 0's only after decimal mark (and drop it, if immediately there) r[ii] <- sub(paste0("\\", decimal.mark, "?0+$"), "", r[ii]) chE <- if(exponent.plus) sprintf("%+.0f", Ex[ii]) # "%..f": also when Ex is outside integer range! else as.character(Ex[ii]) r[ii] <- paste(r[ii], chE, sep = exponent.char) } use.prettyN <- (base <= 14 && (!aE || exponent.char == "e")) if(non.sci <- !all(hasE)) { ## "non-scientific" i.e. without final e[+-]?+ : ii <- isNum & !hasE ## iNeg <- ex <= 0 & ii ## i.e., ex in {0,-1,-2,-3} ## iPos <- ex > 0 & ii ## i.e., ex in {1,2..., digits} iNeg <- Ex < 0 & ii ## i.e., ex in {0,-1,-2,-3} iPos <- Ex >= 0 & ii ## i.e., ex in {1,2..., digits} if(any(eq <- (Ex == r.dig))) { r[eq] <- paste0(r[eq], "0") Ex[eq] <- Ex[eq] + 1L } if(any(iNeg)) { ## "0.00..." : be careful with minus sign if(any(isMin <- hasMinus[iNeg])) { rr <- r[iNeg] rr[isMin] <- substring(rr[isMin], 2) r[iNeg] <- paste0(c("","-")[1+isMin], "0.", strrep("0", -ex[iNeg]), rr) } else { r[iNeg] <- paste0("0.", strrep("0", -ex[iNeg]), r[iNeg]) } } if(any(iPos)) ## "xy.nnnn" : r[iPos] <- patch(r[iPos], (hasMinus + Ex+1L)[iPos]) } if(use.prettyN) r <- prettyNum(r, big.mark = big.mark, big.interval = big.interval, small.mark = small.mark, small.interval = small.interval, decimal.mark = decimal.mark, zero.print = zero.print, drop0trailing = drop0trailing, preserve.width = if (trim) "individual" else "common") else { if(non.sci && drop0trailing) ## drop 0's only *after* (and together with!) decimal mark: r <- sub(paste0(decimal.mark, "0+$"), "", r) if(!missing(big.mark) || !missing(big.interval) || !missing(small.interval) || !missing(small.mark) || !missing(big.interval) || !missing(zero.print)) warning("with base >= 15 or 'exponent.char != \"e\", cannot use prettyNum()") } if(is.null(d <- dim(x))) r else array(r, dim=d, dimnames = dimnames(x)) } setMethod("format", "mpfr", formatMpfr) formatN.mpfr <- function(x, drop0trailing = TRUE, ...) { paste0(formatMpfr(x, drop0trailing=drop0trailing, ...),"_M") } setAs("mpfr", "character", function(from) format(from, digits=NULL, drop0trailing = TRUE)) setAs("character", "mpfr", function(from) mpfr(from)) Rmpfr/R/Math.R0000644000176200001440000003021014547462101012555 0ustar liggesusers#### Define mpfr methods for Math and Math2 group functions #### ====== ===== ### "Arith", "Compare",..., are in ./Arith.R ### ---- ~~~~~~~ if(FALSE) print(getGroupMembers("Math"), width = 85) ## [1] "abs" "sign" "sqrt" "ceiling" "floor" "trunc" "cummax" ## [8] "cummin" "cumprod" "cumsum" "exp" "expm1" "log" "log10" ## [15] "log2" "log1p" "cos" "cosh" "sin" "sinh" "tan" ## [22] "tanh" "acos" "acosh" "asin" "asinh" "atan" "atanh" ## [29] "cospi" "sinpi" "tanpi" "gamma" "lgamma" "digamma" "trigamma" if(FALSE) ## the individual functions dput(getGroupMembers("Math")) ## NOTA BENE: explicitly in {Math} in ## >>>> ../man/mpfr-class.Rd <<<< ## ~~~~~~~~~~~~~~~~~ ## Uniform interface to C: ## ## Pass integer code to call and do the rest in C ## Codes from ~/R/D/r-devel/R/src/main/names.c : .Math.codes <- c( "floor" = 1, "ceiling" = 2, "sqrt" = 3, "sign" = 4, "exp" = 10, "expm1" = 11, "log1p" = 12, "cos" = 20, "sin" = 21, "tan" = 22, "acos" = 23, "asin" = 24, "cosh" = 30, "sinh" = 31, "tanh" = 32, "acosh" = 33, "asinh" = 34, "atanh" = 35, "lgamma" = 40, "gamma" = 41, "digamma" = 42, "trigamma" = 43, ## R >= 3.1.0 : "cospi" = 47, "sinpi" = 48, "tanpi" = 49 ) .Math.gen <- getGroupMembers("Math") ## Those "Math" group generics that are not in the do_math1 table above .Math.codes <- c(.Math.codes, "trunc" = 0, "atan" = 25, # "abs" has own method! "log" = 13, "log2" = 14, "log10" = 15, "cummax" = 71, "cummin" = 72, "cumprod" = 73, "cumsum" = 74, ## These are *NOT* in R's Math group, but 1-argument math functions ## available in the mpfr - library: "erf" = 101, "erfc" = 102, "zeta" = 104, "Eint" = 106, "Li2" = 107, "j0" = 111, "j1" = 112, "y0" = 113, "y1" = 114, "Ai" = 120 # Airy function (new in mpfr 3.0.0) ) storage.mode(.Math.codes) <- "integer" if(FALSE) .Math.gen[!(.Math.gen %in% names(.Math.codes))] ## "abs" -- only one left ## A few ones have a very simple method: ## Note that the 'sign' slot is from the C-internal struct ## and is always +/- 1 , but R's sign(0) |--> 0 .getSign <- function(x) vapply(getD(x), slot, 1L, "sign") .mpfr_sign <- function(x) { r <- numeric(length(x))# all 0 not0 <- !mpfrIs0(x) r[not0] <- .getSign(x[not0]) r } setMethod("sign", "mpfr", .mpfr_sign) ## R version, no longer used: .abs.mpfr <- function(x) { ## FIXME: faster if this happened in a .Call xD <- getDataPart(x) # << currently [2011] *faster* than x@Data for(i in seq_along(x)) slot(xD[[i]], "sign", check=FALSE) <- 1L setDataPart(x, xD, check=FALSE) ## faster than x@.Data <- xD } setMethod("abs", "mpfr", function(x) .Call(Rmpfr_abs, x)) ## Simple methods for "complex" numbers, just so "they work" setMethod("Re", "mpfr", function(z) z) setMethod("Im", "mpfr", function(z) 0*z) setMethod("Conj","mpfr", function(z) z) setMethod("Mod", "mpfr", function(z) abs(z)) setMethod("Arg", "mpfr", function(z) { prec <- .getPrec(z) r <- mpfr(0, prec) neg <- !mpfrIs0(z) & .getSign(z) == -1 r[neg] <- Const("pi", prec = prec[neg]) r }) ## Note that factorial() and lfactorial() automagically work through [l]gamma() ## but for the sake of "exact for integer" setMethod("factorial", "mpfr", function(x) { r <- gamma(x + 1) isi <- .mpfr.is.whole(x) r[isi] <- round(r[isi]) r }) ## The "real" thing is to use the MPFR-internal function: factorialMpfr <- function(n, precBits = max(2, ceiling(lgamma(n+1)/log(2))), rnd.mode = c('N','D','U','Z','A')) { if(!length(n)) return(as(n, "mpfr")) stopifnot(n >= 0) new("mpfr", .Call(R_mpfr_fac, n, precBits, match.arg(rnd.mode))) } ##' Pochhammer rising factorial = Pochhammer(a,n) {1 of 2 definitions!} ##' we use the *rising* factorial for Pochhamer(a,n), i.e., ##' the definition that the GSL and Mathematica use as well. ##' We want to do this well for *integer* n, only the general case is using ##' P(a,x) := Gamma(a+x)/Gamma(x) pochMpfr <- function(a, n, rnd.mode = c('N','D','U','Z','A')) { if(!length(n)) return(a[FALSE]) stopifnot(is.integer(n <- as.integer(n)), n >= 0) if(!is(a, "mpfr")) ## use a high enough default precision (and recycle ..) a <- mpfr(a, precBits = pmax(1,n)*getPrec(a)) else if((ln <- length(n)) != 1 && ln != length(a)) a <- a + 0*n ## a@.Data[] <- .Call(R_mpfr_poch, a, n) ## a setDataPart(a, .Call(R_mpfr_poch, a, n, match.arg(rnd.mode))) } ##' Binomial Coefficient choose(a,n) ##' We want to do this well for *integer* n chooseMpfr <- function(a, n, rnd.mode = c('N','D','U','Z','A')) { if(!length(n)) return(a[FALSE]) stopifnot(is.integer(n <- as.integer(n))) ## if(n < 0) ==> result 0 as for base::choose() if(!is(a, "mpfr")) { ## use high enough default precision lc <- lchoose(a,n) precB <- if(any(iF <- is.finite(lc))) ceiling(max(lc[iF])/log(2)) else 0 ## add n bits for the n multiplications (and recycle {a,n} to same length) a <- mpfr(a, precBits = n + max(2, precB)) } else if((ln <- length(n)) != 1 && ln != length(a)) a <- a + 0*n setDataPart(a, .Call(R_mpfr_choose, a, n, match.arg(rnd.mode))) } ## ------------- => ../src/utils.c chooseMpfr.all <- function(n, precBits=NULL, k0=1, alternating=FALSE) { ## return chooseMpfr(n, k0:n) or (-1)^k * choose... "but smartly" if(length(n) != 1 || !is.numeric(n) || is.na(n) || (n <- as.integer(n)) < 1) stop("n must be integer >= 1") stopifnot(is.numeric(n. <- k0), n. == (k0 <- as.integer(k0)), k0 <= n) sig <- if(alternating) (-1)^(k0:n) else rep.int(1, (n-k0+1)) if(n == 1) return(mpfr(sig, 32)) ## else : n >= 2 n2 <- n %/% 2 # >= 1 prec <- ceiling(lchoose(n,n2)/log(2)) # number of bits needed in result precBxtr <- max(2, n2 + prec) # need more for cumprod(), and division n2. <- mpfr(n2, precBxtr) r <- cumprod(seqMpfr(mpfr(n, precBxtr), n+1-n2., length.out=n2)) / cumprod(seqMpfr(1, n2., length.out=n2)) prec <- max(2,prec) if(is.numeric(precBits) && (pB <- as.integer(round(precBits))) > prec) prec <- pB r <- roundMpfr(r, precBits = prec) ## ii <- c(seq_len(n2-1+(n%%2)), n2:1) if(k0 >= 2) ii <- ii[-seq_len(k0 - 1)] one <- .d2mpfr1(1, precBits=prec) r <- c(if(k0 == 0) one, getD(r)[ii], one) if(alternating) { for(i in seq_along(r)) if(sig[i] == -1) slot(r[[i]], "sign", check=FALSE) <- - 1L } new("mpfr", r) }## {chooseMpfr.all} ## https://en.wikipedia.org/wiki/N%C3%B6rlund%E2%80%93Rice_integral ## also deals with these alternating binomial sums ##' ##' version 1: already using the 'alternating' arg in chooseMpfr.all() sumBinomMpfr.v1 <- function(n, f, n0=0, alternating=TRUE, precBits = 256) { ## Note: n0 = 0, or 1 is typical, and hence chooseMpfr.all() makes sense stopifnot(0 <= n0, n0 <= n, is.function(f)) sum(chooseMpfr.all(n, k0=n0, alternating=alternating) * f(mpfr(n0:n, precBits=precBits))) } ##' version 2: chooseZ()*(-1)^(.) is considerably faster than chooseMpfr.all() sumBinomMpfr.v2 <- function(n, f, n0=0, alternating=TRUE, precBits = 256, f.k = f(mpfr(k, precBits=precBits))) { ## Note: n0 = 0, or 1 is typical.. stopifnot(0 <= n0, n0 <= n, is.function(f) || (is(f.k, "mpfr") && length(f.k) == n-n0+1)) k <- n0:n sum(if(alternating) chooseZ(n, k) * (-1)^(n-k) * f.k else chooseZ(n, k) * f.k) } ## NB: pbetaI() in ./special-fun.R uses a special version.. ## --- if we do this *fast* in C -- do pbetaI() as well. sumBinomMpfr <- sumBinomMpfr.v2 ##' Rounding to binary bits, not decimal digits. Closer to the number ##' representation, this also allows to increase or decrease a number's precBits ##' @title Rounding to binary bits, "mpfr-internally" ##' @param x an mpfr number (vector) ##' @param precBits integer specifying the desired precision in bits. ##' @return an mpfr number as \code{x} but with the new 'precBits' precision ##' @author Martin Maechler roundMpfr <- function(x, precBits, rnd.mode = c('N','D','U','Z','A')) { stopifnot(is(x, "mpfr")) setDataPart(x, .Call(R_mpfr_round, x, precBits, match.arg(rnd.mode))) } ## "log" is still special with its 'base' : ## setMethod("log", signature(x = "mpfr", base = "mpfr"), ## function(x, base) ## setDataPart(x, .Call(Math_mpfr, x, .Math.codes[["log"]])) / log(base) ## ) ## setMethod("log", signature(x = "mpfr", base = "mNumber"), # including "numeric", "bigz", "bigq" ## function(x, base) ## setDataPart(x, .Call(Math_mpfr, x, .Math.codes[["log"]])) / ## log(mpfr(base, getPrec(x))) ## ) ## setMethod("log", signature(x = "mpfr", base = "ANY"), ## function(x, base) { ## if(!missing(base) && base != exp(1)) ## stop("base != exp(1) is not yet implemented") ## setDataPart(x, .Call(Math_mpfr, x, .Math.codes[["log"]])) ## }) setMethod("log", signature(x = "mpfr"), function(x, base = exp(1)) { r <- setDataPart(x, .Call(Math_mpfr, x, .Math.codes[["log"]])) if(!missing(base) && substitute(base) != quote(exp(1))) r / log(mpfr(base, getPrec(x))) else r }) setMethod("Math", signature(x = "mpfr"), function(x) setDataPart(x, .Call(Math_mpfr, x, .Math.codes[[.Generic]]))) setMethod("Math2", signature(x = "mpfr"), function(x, digits) { ## NOTA BENE: vectorized in 'x' if(any(ret.x <- !is.finite(x) | mpfrIs0(x))) { if(any(ok <- !ret.x)) x[ok] <- callGeneric(x[ok], digits=digits) return(x) } if(!missing(digits)) { digits <- as.integer(round(digits)) if(is.na(digits)) return(x + digits) } ## else: default *depends* on the generic ## now: both x and digits are finite pow10 <- function(d) mpfr(rep.int(10., length(d)), precBits = ceiling(log2(10)*as.numeric(d)))^ d rint <- function(x) { ## have x >= 0 here sml.x <- (x < .Machine$integer.max) r <- x if(any(sml.x)) { x.5 <- x[sml.x] + 0.5 ix <- as.integer(x.5) ## implement "round to even" : if(any(doDec <- (abs(x.5 - ix) < 10*.Machine$double.eps & (ix %% 2)))) ix[doDec] <- ix[doDec] - 1L r[sml.x] <- ix } if(!all(sml.x)) { ## large x - no longer care for round to even r[!sml.x] <- floor(x[!sml.x] + 0.5) } r } neg.x <- x < 0 x[neg.x] <- - x[neg.x] sgn <- ifelse(neg.x, -1, +1) switch(.Generic, "round" = { ## following ~/R/D/r-devel/R/src/nmath/fround.c : if(missing(digits) || digits == 0) sgn * rint(x) else if(digits > 0) { p10 <- pow10(digits) intx <- floor(x) sgn * (intx + rint((x-intx) * p10) / p10) } else { ## digits < 0 p10 <- pow10(-digits) sgn * rint(x/p10) * p10 } }, "signif" = { ## following ~/R/D/r-devel/R/src/nmath/fprec.c : if(missing(digits)) digits <- 6L if(digits > max(.getPrec(x)) * log10(2)) return(x) if(digits < 1) digits <- 1L l10 <- log10(x) e10 <- digits - 1L - floor(l10) r <- x pos.e <- (e10 > 0) ##* 10 ^ e, with e >= 1 : exactly representable if(any(pos.e)) { p10 <- pow10(e10[pos.e]) r[pos.e] <- sgn[pos.e]* rint(x[pos.e]*p10) / p10 } if(any(neg.e <- !pos.e)) { p10 <- pow10(-e10[neg.e]) r[neg.e] <- sgn[neg.e]* rint(x[neg.e]/p10) * p10 } r }, stop(gettextf("Non-Math2 group generic '%s' -- should not happen", .Generic))) }) ##---- mpfrArray / mpfrMatrix --- methods ----------------- ## not many needed: "mpfrArray" contain "mpfr", ## i.e., if the above methods are written "general enough", they apply directly setMethod("sign", "mpfrArray", function(x) structure(.mpfr_sign(x), dim = dim(x), dimnames = dimnames(x))) Rmpfr/R/mpfr.R0000644000176200001440000007455314360044651012651 0ustar liggesusers#### All methods for "mpfr" (and "mpfr1") class #### apart from coercions and the group methods setMethod("is.finite", "mpfr", function(x) .Call(R_mpfr_is_finite, x)) setMethod("is.infinite", "mpfr", function(x) .Call(R_mpfr_is_infinite, x)) ## MPFR has only "NaN" ( == "NA" -- hence these two are identical : setMethod("is.na", "mpfr", function(x) .Call(R_mpfr_is_na, x)) setMethod("is.nan", "mpfr", function(x) .Call(R_mpfr_is_na, x)) mpfrIs0 <- function(x) { if(is(x, "mpfrArray")) .Call(R_mpfr_is_zero_A, x) else .Call(R_mpfr_is_zero, x) ## sapply(x, function(.) .@exp == - .Machine$integer.max) } mpfr.is.0 <- function(x) { .Deprecated("mpfrIs0") mpfrIs0(x) } .mpfr.is.whole <- function(x) { if(is(x, "mpfrArray")) .Call(R_mpfr_is_integer_A, x) else .Call(R_mpfr_is_integer, x) } mpfr.is.integer <- function(x) { .Deprecated(".mpfr.is.whole") .mpfr.is.whole(x) } ## is.whole() is now S3 generic, with default method in gmp ## is.whole <- function(x) { ## if(is.integer(x) || is.logical(x)) rep.int(TRUE, length(x)) ## else if(is.numeric(x)) x == floor(x) ## else if(is.complex(x)) x == round(x) ## else if(is(x,"mpfr")) .mpfr.is.whole(x) ## else rep.int(FALSE, length(x)) ## } is.whole.mpfr <- function(x) .mpfr.is.whole(x) ## The above for "mpfrArray" : setMethod("is.finite", "mpfrArray", function(x) .Call(R_mpfr_is_finite_A, x)) setMethod("is.infinite", "mpfrArray", function(x) .Call(R_mpfr_is_infinite_A, x)) ## MPFR has only "NaN" ( == "NA" -- hence these two are identical : setMethod("is.na", "mpfrArray", function(x) .Call(R_mpfr_is_na_A, x)) setMethod("is.nan", "mpfrArray", function(x) .Call(R_mpfr_is_na_A, x)) mpfr_default_prec <- function(prec) { if(missing(prec) || is.null(prec)) .Call(R_mpfr_get_default_prec) else { stopifnot((prec <- as.integer(prec[1])) > 0) .Call(R_mpfr_set_default_prec, prec) } } .mpfr_minPrec <- function() .Call(R_mpfr_prec_range, 1L) .mpfr_maxPrec <- function() .Call(R_mpfr_prec_range, 2L) ## must be sync'ed with enum def. in R_mpfr_get_erange in ../src/utils.c .mpfr_erange_kinds <- c("Emin", "Emax", "min.emin", "max.emin", "min.emax", "max.emax") ## _erange_codes <- seq_along(.mpfr_erange_kinds) .mpfr_erange <- function(kind = c("Emin", "Emax"), names = TRUE) { if(anyNA(ikind <- match(kind, .mpfr_erange_kinds)) || !length(kind)) stop("'kind' must have entries from ", paste(paste0('"', .mpfr_erange_kinds, '"'), collapse=", ")) r <- .Call(R_mpfr_get_erange, ikind) if(names) names(r) <- .mpfr_erange_kinds[ikind] r } ## NB: This now works to set *both* kinds, simultaneously .mpfr_erange_set <- function(kind = c("Emin", "Emax"), value) { kind <- match.arg(kind, several.ok=TRUE) stopifnot(length(kind) == length(value)) ## value can be double, and need be for "64-bit long" invisible(vapply(seq_along(kind), function(j) .Call(R_mpfr_set_erange, match(kind[[j]], c("Emin", "Emax")), value[[j]]), ## returns error codes from MPFR; 0 is good integer(1)) == 0L) } .mpfr_erange_is_int <- function() .Call(R_mpfr_erange_int_p) .mpfr_gmp_numbbits <- function() .Call(R_mpfr_get_GMP_numb_bits) .mpfrVersion <- function() .Call(R_mpfr_get_version) mpfrVersion <- function() numeric_version(sub("^([0-9]+\\.[0-9]+\\.[0-9]+).*","\\1", .mpfrVersion())) print.mpfr1 <- function(x, digits = NULL, drop0trailing = TRUE, ...) { stopifnot(is(x, "mpfr1"), is.null(digits) || digits >= 1) cat("'mpfr1' ", format(as(x, "mpfr"), digits=digits, drop0trailing=drop0trailing), "\n", sep="") invisible(x) } setMethod(show, "mpfr1", function(object) print.mpfr1(object)) if(FALSE) ## no longer -- as R CMD check complains about use of non-API R_Outputfile ## For testing, debugging etc if(.Platform$OS.type != "windows") {## No R_Outputfile (in C) on Windows .print.mpfr <- function(x, digits = NA, ...) { stopifnot(is.mpfr(x), is.na(digits) || digits >= 1) ## digits = NA --> the inherent precision of x will be used if(length(x) >= 1) .Call(print_mpfr, x, as.integer(digits)) invisible(x) } }# non-Windows only ## a faster version of getDataPart(.) - as we *KNOW* we have a list ## !! If ever the internal representation of such S4 objects changes, this can break !! getD <- function(x) { attributes(x) <- NULL; x } getD <- function(x) `attributes<-`(x, NULL) ## Get or Set the C-global 'R_mpfr_debug_' variable: .mpfr_debug <- function(i = NA) .Call(R_mpfr_set_debug, as.integer(i)) ## CAREFUL: keep digits, max.digits, ... defaults in sync with ## print.mpfrArray() in ./array.R print.mpfr <- function(x, digits = NULL, drop0trailing = TRUE, right = TRUE, max.digits = getOption("Rmpfr.print.max.digits", 999L), exponent.plus = getOption("Rmpfr.print.exponent.plus", TRUE), ...) { stopifnot(is.mpfr(x), is.null(digits) || digits >= 1) ## digits = NULL --> the inherent precision of x will be used n <- length(x) ch.prec <- if(n >= 1) { rpr <- range(.getPrec(x)) paste("of precision ", rpr[1], if(rpr[1] != rpr[2]) paste("..",rpr[2]), " bits") } cat(n, "'mpfr'", if(n == 1) "number" else "numbers", ch.prec, "\n") if(n >= 1) { ## drop arguments for print.default(*): lFormat <- function(x, na.print, print.gap, max, useSource, ...) format(x, digits=digits, max.digits=max.digits, drop0trailing=drop0trailing, exponent.plus=exponent.plus, ...) print(lFormat(x, ...), ..., right=right, quote = FALSE) } invisible(x) } setMethod(show, "mpfr", function(object) print.mpfr(object)) ## Proposal by Serguei Sokol in order to make diag() work: if(FALSE)## << MM is in line with our "as.matrix" methods, but is extreme setMethod("is.matrix", "mpfr", function(x) length(dim(x)) == 2L) ## e.g. M0 <- (M <- cbind(mpfr(1.1, 100)^(98:99)))[,FALSE]; diag(M0) ## gives list() instead of length 0 mpfr ## For matrix indexing: matrix i |--> regular i : .mat2ind <- function(i, dim.x, dimnms.x) { ndx <- length(dim.x) if(!is.null(di <- dim(i))) { if(di[2L] == ndx) { ## k-column Matrix subsetting for array of rank k if(is.character(i)) { i <- vapply(seq_along(dim.x), function(j) match(i[,j], dimnms.x[[j]]), seq_len(di[1])) if(any(is.na(i))) stop("character matrix index out of limits") } i <- if(is.numeric(i)) i[,1L] + colSums(t(i[,-1L]-1L)* cumprod(dim.x)[-ndx]) else getD(i) } else { i <- getD(i) } } i } ## "[" which also keeps names ... JMC says that names are not support(ed|able) ## --- for such objects.. .mpfr.subset <- function(x,i,j, ..., drop) { nA <- nargs() if(nA == 2) { ## x[i] etc -- vector case -- to be fast, need C! -- ## i <- .mat2ind(i, dim(x), dimnames(x)) xd <- structure(getD(x)[i], names = names(x)[i]) if(any(iN <- vapply(xd, is.null, NA))) # e.g. i > length(x) xd[iN] <- mpfr(NA, precBits = 2L) ## faster than { x@.Data <- xd ; x }: setDataPart(x, xd, check=FALSE) } else if(nA == 3 && !is.null(d <- dim(x))) { ## matrix indexing(!) ## not keeping dimnames though ... message("nargs() == 3 'mpfr' array indexing ... ") new("mpfr", structure(getD(x)[i,j,...,drop=drop], dim = d)) ## keeping dimnames: maybe try ## D <- getD(x); dim(D) <- d ## if(!is.null(dn <- dimnames(x))) dimnames(D) <- dn ## D <- D[i,,drop=drop] ## new("mpfr", D) } else stop(gettextf("invalid 'mpfr' subsetting (nargs = %d)",nA)) } ## .mpfr.subset() .mpfr.msubset <- function(x,i,j, ..., drop) { nA <- nargs() if(nA == 2) { i <- .mat2ind(i, dim(x), dimnames(x)) xd <- structure(getD(x)[i], names=names(x)[i]) if(any(iN <- vapply(xd, is.null, NA))) # e.g. i > length(x) xd[iN] <- mpfr(NA, precBits = 2L) ## faster than { x@.Data <- xd ; x }: setDataPart(x[i], xd, check=FALSE) } else stop(gettext("invalid 'mpfr' matrix subsetting with a matrix (nargs = %d)",nA)) } ## .mpfr.msubset() ### ---------- FIXME: ./array.R has other "mpfrArray" methods for "[" and "[<-" !!!!!!----------- setMethod("[", signature(x = "mpfr", i = "ANY", j = "missing", drop = "missing"), .mpfr.subset) setMethod("[", signature(x = "mpfrArray", i = "matrix", j = "missing", drop = "missing"), .mpfr.msubset) setMethod("[[", signature(x = "mpfr", i = "ANY"), function(x,i) { if(length(i) > 1L) # give better error message than x@.Data[[i]] would: stop("attempt to select more than one element") xd <- getD(x)[[i]] # also gives error when i is "not ok" ## faster than { x@.Data <- list(xd) ; x } setDataPart(x, list(xd), check=FALSE) }) ## "[<-" : .mpfr.repl <- function(x, i, ..., value, check = TRUE) { if(length(list(...))) ## should no longer happen: stop("extra replacement arguments ", deparse(list(...)), " not dealt with") ## if(!missing(i)) i <- .mat2ind(i, dim(x), dimnames(x)) n <- length(xD <- getD(x)) xD[i] <- value if((nn <- length(xD)) > n+1) ## must "fill" the newly created NULL entries xD[setdiff((n+1):(nn-1), i)] <- mpfr(NA, precBits = 2L) setDataPart(x, xD, check=check) } ## FIXME: Should not need this; rather add .mat2ind to .mpfr.repl() above .mpfr.mrepl <- function(x, i, ..., value, check=TRUE) { if(length(list(...))) ## should no longer happen: stop("extra replacement arguments ", deparse(list(...)), " not dealt with") i <- .mat2ind(i, dim(x), dimnames(x)) n <- length(xD <- getD(x)) xD[i] <- value if((nn <- length(xD)) > n+1) ## must "fill" the newly created NULL entries xD[setdiff((n+1):(nn-1), i)] <- mpfr(NA, precBits = 2L) setDataPart(x, xD, check=check) } ## value = "mpfr" setReplaceMethod("[", signature(x = "mpfr", i = "ANY", j = "missing", value = "mpfr"), function(x, i, j, ..., value) .mpfr.repl(x, i, ..., value=value)) setReplaceMethod("[", signature(x = "mpfrArray", i = "matrix", j = "missing", value = "mpfr"), function(x, i, j, ..., value) .mpfr.mrepl(x, i, ..., value=value)) ## for non-"mpfr", i.e. "ANY" 'value', coerce to mpfr with correct prec: setReplaceMethod("[", signature(x = "mpfr", i = "missing", j = "missing", value = "ANY"), function(x,i,j, ..., value) .mpfr.repl(x, , value = mpfr(value, precBits = pmax(getPrec(value), .getPrec(x))))) setReplaceMethod("[", signature(x = "mpfr", i = "ANY", j = "missing", value = "ANY"), function(x,i,j, ..., value) { if(length(xi <- x[i])) .mpfr.repl(x, i, value = mpfr(value, precBits = pmax(getPrec(value), .getPrec(xi)))) else x # nothing to replace }) setReplaceMethod("[", signature(x = "mpfrArray", i = "matrix", j = "missing", value = "ANY"), function(x,i,j, ..., value) { if(length(xi <- x[i])) .mpfr.mrepl(x, i, value = mpfr(value, precBits = pmax(getPrec(value), .getPrec(xi)))) else x # nothing to replace }) ## I don't see how I could use setMethod("c", ...) ## but this works "magically" when the first argument is an mpfr : ## NB: via as(., "mpfr") it currently makes all doubles to 128 bit prec; ## MM now would prefer something like 55 (just barely enough accurate) c.mpfr <- function(...) new("mpfr", unlist(lapply(list(...), as, Class = "mpfr"), recursive = FALSE)) ## and the same trick can be used to implement a *simplistic* sapplyMpfr <- function(X, FUN, ...) new("mpfr", unlist(lapply(X, FUN, ...), recursive = FALSE)) ##' more carefully, also returing mpfrArray when appropriate: sapplyMpfr <- function(X, FUN, ..., drop_1_ = TRUE) { L <- lapply(X, FUN, ...) if((n <- length(L)) && (!drop_1_ | (ll1 <- (ll <- lengths(L))[1L]) != 1L) && all(ll == ll1)) { if(is.null(d <- dim(L1 <- L[[1L]])) || !all(d == sapply(L, dim))) new("mpfrMatrix", unlist(L, recursive = FALSE), Dim = c(ll1, n), Dimnames = list(names(L1), names(L))) else # L[i] have dim(), all the same ones new("mpfrArray", unlist(L, recursive = FALSE), Dim = c(d,n), Dimnames = c(dimnames(L1), list(names(L)))) } else { new("mpfr", unlist(L, recursive = FALSE)) } } ## duplicated() now works, checked in ../man/mpfr-class.Rd ## sort() works too (but could be made faster via faster ## ------ xtfrm() method ! [ TODO ] ## to have this also work *inside* base function factor(), we need S3 method {AARGH!} unique.mpfr <- function(x, incomparables = FALSE, ...) new("mpfr", unique(getD(x), incomparables, ...)) setMethod("unique", signature(x = "mpfr", incomparables = "ANY"), unique.mpfr) ## This is practically identical to grid's rep.unit : rep.mpfr <- function(x, times = 1, length.out = NA, each = 1, ...) ## Determine an appropriate index, then call subsetting code x[ rep(seq_along(x), times=times, length.out=length.out, each=each) ] setGeneric("pmin", signature = "...")# -> message about override ... setGeneric("pmax", signature = "...") ## Check if we should "dispatch" to base ## should be fast, as it should not slow down "base pmin() / pmax()" ## Semantically: <==> is.atomic(x) && !(is(x, "bigz") || is(x, "bigq")) pm.ok.base <- function(x, cld = getClassDef(class(x))) is.atomic(x) && (!is.object(x) || { !(extends(cld, "bigz") || extends(cld, "bigq")) }) setMethod("pmin", "mNumber", function(..., na.rm = FALSE) { args <- list(...) ## Fast(*) check if "base dispatch" should happen (* "fast" for base cases): ## if((allA <- all(vapply(args, is.atomic, NA))) && ## ((nonO <- !any(is.obj <- vapply(args, is.object, NA))) || ## { ## cld <- lapply(args, function(.) getClassDef(class(.))) ## cld.o <- cld[is.obj] ## all(vapply(cld.o, extends, NA, "bigz") | ## vapply(cld.o, extends, NA, "bigq")) })) if(all(vapply(args, pm.ok.base, NA))) return( base::pmin(..., na.rm = na.rm) ) ## else: at least one is "mpfr(Matrix/Array)", "bigz" or "bigq" ## if(!allA || nonO) cld <- lapply(args, function(.) getClassDef(class(.))) ## else have defined cld above is.m <- vapply(cld, extends, NA, "mpfr") is.q <- vapply(cld, extends, NA, "bigq") is.z <- vapply(cld, extends, NA, "bigz") is.N <- vapply(args, function(x) is.numeric(x) || is.logical(x), NA) if(!any(is.m | is.q | is.z)) # should not be needed -- TODO: "comment out" stop("no \"mpfr\", \"bigz\", or \"bigq\" argument -- wrong method chosen; please report!") N <- max(lenA <- lengths(args)) any.m <- any(is.m) any.q <- any(is.q) ## precision needed -- FIXME: should be *vector* mPrec <- max(unlist(lapply(args[is.m], .getPrec)),# not vapply if(any(vapply(args[!is.m], is.double, NA))) .Machine$double.digits, if(any.q) 128L,# arbitrary as in getPrec() unlist(lapply(args[is.z], function(z) frexpZ(z)$exp))# as in getPrec() ) ## to be the result : ## r <- mpfr(rep.int(Inf, N), precBits = mPrec) ## more efficient (?): start with the first 'mpfr' argument i.frst.m <- which.max(if(any.m) is.m else if(any.q) is.q else is.z) ## ==> r is "mpfr" if there's any, otherwise "bigq", or "bigz" r <- args[[i.frst.m]] if((n.i <- lenA[i.frst.m]) != N) r <- r[rep(seq_len(n.i), length.out = N)] ## modified from ~/R/D/r-devel/R/src/library/base/R/pmax.R has.na <- FALSE ii <- seq_along(lenA) ## = seq_along(args) ii <- ii[ii != i.frst.m] for(i in ii) { x <- args[[i]] if((n.i <- lenA[i]) != N) x <- x[rep(seq_len(n.i), length.out = N)] n.r <- is.na(r); n.x <- is.na(x) ## mpfr() is relatively expensive if(doM <- any.m && !is.m[i] && !is.N[i]) # "bigz", "bigq" ## r is "mpfr" x <- mpfr(x, precBits = mPrec) else if(doQ <- !any.m && !is.q[i] && !is.N[i]) # "bigz" ## r is "bigq" x <- as.bigq(x) if(has.na || (has.na <- any(n.r, n.x))) { r[n.r] <- x[n.r] x[n.x] <- if(!doM && !doQ) as(r[n.x],class(x)) else r[n.x] } change <- r > x change <- which(change & !is.na(change)) r[change] <- x[change] if (has.na && !na.rm) r[n.r | n.x] <- NA } ## wouldn't be ok, e.g for 'bigq' r and args[[1]]: ## mostattributes(r) <- attributes(args[[1L]]) ## instead : if(!is.null(d <- dim(args[[1L]]))) dim(r) <- d r })## end { pmin } setMethod("pmax", "mNumber", function(..., na.rm = FALSE) { args <- list(...) ## Fast(*) check if "base dispatch" should happen (* "fast" for base cases): ## if((allA <- all(vapply(args, is.atomic, NA))) && ## ((nonO <- !any(is.obj <- vapply(args, is.object, NA))) || ## { ## cld <- lapply(args, function(.) getClassDef(class(.))) ## cld.o <- cld[is.obj] ## all(vapply(cld.o, extends, NA, "bigz") | ## vapply(cld.o, extends, NA, "bigq")) })) if(all(vapply(args, pm.ok.base, NA))) return( base::pmax(..., na.rm = na.rm) ) ## else: at least one is "mpfr(Matrix/Array)", "bigz" or "bigq" ## if(!allA || nonO) cld <- lapply(args, function(.) getClassDef(class(.))) ## else have defined cld above is.m <- vapply(cld, extends, NA, "mpfr") is.q <- vapply(cld, extends, NA, "bigq") is.z <- vapply(cld, extends, NA, "bigz") is.N <- vapply(args, function(x) is.numeric(x) || is.logical(x), NA) if(!any(is.m | is.q | is.z)) # should not be needed -- TODO: "comment out" stop("no \"mpfr\", \"bigz\", or \"bigq\" argument -- wrong method chosen; please report!") N <- max(lenA <- lengths(args)) any.m <- any(is.m) any.q <- any(is.q) ## precision needed -- FIXME: should be *vector* mPrec <- max(unlist(lapply(args[is.m], .getPrec)),# not vapply if(any(vapply(args[!is.m], is.double, NA))) .Machine$double.digits, if(any.q) 128L,# arbitrary as in getPrec() unlist(lapply(args[is.z], function(z) frexpZ(z)$exp))# as in getPrec() ) ## to be the result : ## r <- mpfr(rep.int(Inf, N), precBits = mPrec) ## more efficient (?): start with the first 'mpfr' argument i.frst.m <- which.max(if(any.m) is.m else if(any.q) is.q else is.z) ## ==> r is "mpfr" if there's any, otherwise "bigq", or "bigz" r <- args[[i.frst.m]] if((n.i <- lenA[i.frst.m]) != N) r <- r[rep(seq_len(n.i), length.out = N)] ## modified from ~/R/D/r-devel/R/src/library/base/R/pmax.R has.na <- FALSE ii <- seq_along(lenA) ## = seq_along(args) ii <- ii[ii != i.frst.m] for(i in ii) { x <- args[[i]] if((n.i <- lenA[i]) != N) x <- x[rep(seq_len(n.i), length.out = N)] n.r <- is.na(r); n.x <- is.na(x) ## mpfr() is relatively expensive if(doM <- any.m && !is.m[i] && !is.N[i]) # "bigz", "bigq" ## r is "mpfr" x <- mpfr(x, precBits = mPrec) else if(doQ <- !any.m && !is.q[i] && !is.N[i]) # "bigz" ## r is "bigq" x <- as.bigq(x) if(has.na || (has.na <- any(n.r, n.x))) { r[n.r] <- x[n.r] x[n.x] <- if(!doM && !doQ) as(r[n.x],class(x)) else r[n.x] } change <- r < x change <- which(change & !is.na(change)) r[change] <- x[change] if (has.na && !na.rm) r[n.r | n.x] <- NA } ## wouldn't be ok, e.g for 'bigq' r and args[[1]]: ## mostattributes(r) <- attributes(args[[1L]]) ## instead : if(!is.null(d <- dim(args[[1L]]))) dim(r) <- d r })## end { pmax } ### seq() : ## seq.default() and seq.Date() as examples : ## ~/R/D/r-devel/R/src/library/base/R/seq.R and ## ~/R/D/r-devel/R/src/library/base/R/dates.R seqMpfr <- function(from = 1, to = 1, by = ((to - from)/(length.out - 1)), length.out = NULL, along.with = NULL, ...) { if(h.from <- !missing(from)) { lf <- length(from) if(lf != 1) stop("'from' must be of length 1") } if (nargs() == 1L && h.from) { # 'One' if(is.numeric(from) || is.mpfr(from)) { to <- from; from <- mpfr(1, getPrec(from)) } else stop("'from' is neither numeric nor \"mpfr\"") } ## else if (!is(from, "mpfr")) from <- as(from, "mpfr") if(!missing(to)) { if (!is.mpfr(to)) to <- as(to, "mpfr") if (length(to) != 1) stop("'to' must be of length 1") } if (!missing(along.with)) { length.out <- length(along.with) } else if (!is.null(length.out)) { if (length(length.out) != 1) stop("'length.out' must be of length 1") length.out <- asNumeric(ceiling(length.out)) } ## status <- c(!missing(to), !missing(by), !is.null(length.out)) ## if(sum(status) != 2) ## ## stop("exactly two of 'to', 'by' and 'length.out' / 'along.with' must be specified") ## warning("not exactly two of 'to', 'by' and 'length.out' / 'along.with' have been specified") miss.by <- missing(by) if(is.null(length.out)) { if(!is.mpfr(to)) to <- as(to, "mpfr") if(!is.mpfr(from)) from <- as(from, "mpfr")# need it again del <- to - from if(del == 0 && to == 0) return(to) if(miss.by) { by <- mpfr(sign(del), getD(from)[[1]]@prec) } } else if(!miss.by) { # to mpfr and check it if (!is.mpfr(by)) by <- as(by, "mpfr") if (length(by) != 1) stop("'by' must be of length 1") } ## ---- This is cut n paste from seq.default() : ## ---- It should work, since "arithmetic works for mpfr : if(is.null(length.out)) { n <- del/by if(!(length(n) && is.finite(n))) { if(length(by) && by == 0 && length(del) && del == 0) return(from) stop("invalid (to - from)/by in seq(.)") } if(n < 0) stop("wrong sign in 'by' argument") if(n > .Machine$integer.max) stop("'by' argument is much too small") dd <- abs(del)/max(abs(to), abs(from)) if (dd < 100*.Machine$double.eps) return(from) n <- as.integer(n + 1e-7) x <- from + (0:n) * by ## correct for overshot because of fuzz if(by > 0) pmin(x, to) else pmax(x, to) } else if(!is.finite(length.out) || length.out < 0) stop("length must be non-negative number") else if(length.out == 0) as(from,"mpfr")[FALSE] # of same precision ## else if (One) 1:length.out else if(miss.by) { ## if(from == to || length.out < 2) by <- 1 if(length.out < .Machine$integer.max) length.out <- as.integer(length.out) if(missing(to)) to <- as(from,"mpfr") + (length.out - 1) if(missing(from)) from <- to - (length.out - 1) if(length.out > 2) if(from == to) rep.int(as(from,"mpfr"), length.out) else { f <- as(from,"mpfr") as.vector(c(f, f + (1:(length.out - 2)) * by, to)) } else as.vector(c(as(from,"mpfr"), to))[seq_len(length.out)] } else if(missing(to)) as(from,"mpfr") + (0:(as.integer(length.out) - 1L)) * by else if(missing(from)) to - ((as.integer(length.out) - 1L):0) * by else stop("too many arguments") } ## {seqMpfr} if(FALSE) { ##-- --- I don't see *any* way to define seq() {S4} methods ## 1. Currently need a setGeneric() : ## ---- just calling setMethod("seq",...) as below fails directly {signature problem} ## 2. Trying three different variations --- all of them render the ## *default method invalid : ### ---> seq(1, length.out=3) # afterwards fails with " missing 'by' " setGeneric("seq", function(from, to, by, ...) standardGeneric("seq"), useAsDefault = function(from, to, by, ...) base::seq(from, to, by, ...)) setGeneric("seq", function(from, to, by, ...) standardGeneric("seq"), useAsDefault = function(from = 1, to = 1, by = ((to-from)/(length.out-1)), ...) base::seq(from, to, by, ...)) setGeneric("seq", function (from, to, by, length.out, along.with, ...) standardGeneric("seq"), signature = c("from", "to", "by"), useAsDefault = { function(from = 1, to = 1, by = ((to-from)/(length.out-1)), length.out = NULL, along.with = NULL, ...) base::seq(from, to, by, length.out=length.out, along.with=along.with, ...) }) setMethod("seq", c(from = "mpfr", to = "ANY", by = "ANY"), seqMpfr) setMethod("seq", c(from = "ANY", to = "mpfr", by = "ANY"), seqMpfr) setMethod("seq", c(from = "ANY", to = "ANY", by = "mpfr"), seqMpfr) }##--not yet-- defining seq() methods -- as it fails ## the fast mpfr-only version - should *not* return empty, hence the default: .getPrec <- function(x) { if(length(x)) vapply(getD(x), slot, 1L, "prec") else mpfr_default_prec() } ## binary exponents: [1] should be ok also for 64-bit limbs .getExp <- function(x) vapply(getD(x), function(m) m@exp[1L], 1) ##' The *relevant* number of "bit"/"digit" characters in character vector x ##' (i.e. is vectorized) .ncharPrec <- function(x, base) { if((base == 2 && any(i <- tolower(substr(x,1L,2L)) == "0b")) || (base == 16 && any(i <- tolower(substr(x,1L,2L)) == "0x"))) { i <- which(i) x[i] <- substr(x[i], 3L, 1000000L) } nchar(gsub("[-.]", '', x), "bytes") } ## the user version getPrec <- function(x, base = 10, doNumeric = TRUE, is.mpfr = NA, bigq. = 128L) { if(isTRUE(is.mpfr) || is.mpfr(x)) vapply(getD(x), slot, 1L, "prec")# possibly of length 0 else if(is.character(x)) { if (inherits(x, "Ncharacter")) attr(x, "bindigits") + 1L else ceiling(log2(base) * .ncharPrec(x, base)) ## number of digits --> number of bits } else if(is.logical(x)) 2L # even 1 would suffice - but need 2 (in C ?) else if(is.raw(x)) { if(is.object(x)) { ## Now deal with 'bigz' and 'bigq' if(inherits(x,"bigz")) frexpZ(x)$exp else if(inherits(x,"bigq")) { if(missing(bigq.)) { warning("default precision for 'bigq' arbitrarily chosen as ", bigq.) bigq. } else as.integer(bigq.) } else 8L } else 8L } else { if(!doNumeric) stop("must specify 'precBits' for numeric 'x' when 'doNumeric' is false") ## else if(is.integer(x)) 32L else if(is.double(x)) 53L else if(length(x) == 0) mpfr_default_prec() else stop(sprintf("cannot determine 'precBits' for x of type '%s'", typeof(x))) } } toMpfr <- function(x) if(is.atomic(x)) mpfr(x, getPrec(x)) else as(x, "mpfr") ### all.equal() ## TODO ?? <<<<<<<<<<< ## ==== ## 2) instead of as(., "mpfr") use mpfr(., precBits = ) ## 3) make use of 'formatFUN' in all.equal.numeric() to show *less precise* error ## ## Utility, not exported: all.equalNum <- all.equal.numeric ## use *our* mean() method inside all.equal*(): environment(all.equalNum) <- environment() # = getNamespace("Rmpfr") all.equalMpfr <- function(target, current, formatFUN = function(err, what) formatMpfr(err, digits = getOption("digits")), ## smart default tolerance when *both* args are mpfr {getPrec() otherwise} tolerance = 2^-(0.5 * min(mean(.getPrec(target)), mean(.getPrec(current)))), ...) all.equalNum(target, current, tolerance=tolerance, formatFUN=formatFUN, ...) setMethod("all.equal", signature(target = "mpfr", current = "mpfr"), all.equalMpfr) setMethod("all.equal", signature(target = "mpfr", current = "ANY"), function(target, current, ...) all.equalMpfr(target, toMpfr(current), ...)) setMethod("all.equal", signature(target = "ANY", current = "mpfr"), function(target, current, ...) all.equalMpfr(toMpfr(target), current, ...)) ##' This is almost identical to diff.default -- ~/R/D/r-devel/R/src/library/base/R/diff.R ##' But that uses unclass(x) unfortunately diff.mpfr <- function(x, lag = 1L, differences = 1L, ...) { ismat <- is(x, "mpfrArray") ##_ is.matrix(x) xlen <- if(ismat) dim(x)[1L] else length(x) if (length(lag) > 1L || length(differences) > 1L || lag < 1L || differences < 1L) stop("'lag' and 'differences' must be integers >= 1") if (lag * differences >= xlen) return(x[0L]) # empty, but of proper mode i1 <- -seq_len(lag) if (ismat) for (i in seq_len(differences)) x <- x[i1, , drop = FALSE] - x[-nrow(x):-(nrow(x)-lag+1L), , drop = FALSE] else for (i in seq_len(differences)) x <- x[i1] - x[-length(x):-(length(x)-lag+1L)] x } str.mpfr <- function(object, nest.lev, internal = FALSE, give.head = TRUE, digits.d = 12, vec.len = NULL, drop0trailing=TRUE, width = getOption("width"), ...) { ## utils:::str.default() gives "Formal class 'mpfr' [package "Rmpfr"] with 1 slots" cl <- class(object) le <- length(object) if(le == 0) { print(object); return(invisible()) } if(isArr <- is(object, "mpfrArray")) di <- dim(object) r.pr <- range(getPrec(object)) onePr <- r.pr[1] == r.pr[2] if(give.head) cat("Class", " '", paste(cl, collapse = "', '"), "' [package \"", attr(cl, "package"), "\"] of ", if(isArr) paste("dimension", deparse(di, control = NULL)) else paste("length", le), " and precision", if(onePr) paste("", r.pr[1]) else paste0("s ", r.pr[1],"..",r.pr[2]), "\n", sep = "") if(missing(nest.lev)) nest.lev <- 0 cat(paste(rep.int(" ", max(0,nest.lev+1)), collapse= "..")) if(internal) { ## internal structure cat("internally @.Data: ") if(is.null(vec.len)) vec.len <- getOption("str", list(vec.len = 4))$vec.len str(getD(object), nest.lev=nest.lev, give.head=give.head, digits.d=digits.d, vec.len=vec.len, drop0trailing=drop0trailing, width=width, ...) return(invisible()) } ## if object is long, drop the rest which won't be used anyway: max.len <- max(100, width %/% 3 + 1, if(is.numeric(vec.len)) vec.len) if(le > max.len) object <- object[seq_len(max.len)] if(!is.null(digits.d))## reduce digits where precision is smaller: digits.d <- pmin(digits.d, ceiling(log(2)/log(10) * max(.getPrec(object)))) if(is.null(vec.len)) { # use width and precision (and remain simple enough) ff <- formatMpfr(object, digits=digits.d, drop0trailing=drop0trailing, ...) nch <- if(getRversion() >= "3.2.1") nchar(ff, keepNA=FALSE) else nchar(ff) fits <- !any(too.lrg <- cumsum(nch) + length(nch)-1L > width) if(!fits) vec.len <- max(2L, which.max(too.lrg) - 1L) } else fits <- le <= vec.len if(!fits) object <- object[seq_len(vec.len)] cat(formatMpfr(object, digits=digits.d, drop0trailing=drop0trailing, ...), if(fits) "\n" else "...\n") } ## {str.mpfr} Rmpfr/MD50000644000176200001440000001227514553206226011664 0ustar liggesusers0b5984091a73dc9f4f47019c39d8860f *ChangeLog 97671cfc851f70ebe3873e33e8b94b69 *DESCRIPTION 07774b34906a228024c3f42e3e736927 *NAMESPACE 7598e13300dd9cb57a49a151efe9e886 *R/AllClasses.R a9b1cf4ae85149ce3b63dca1fda41645 *R/Arith.R af49ae22a3abb7623dda7f03d3210404 *R/Consts.R 0b59ce51ca091397216461688d2a3e2e *R/Math.R f33439938db1458476c1d0059ab68519 *R/Summary.R 9328dcb3e02ba2059a078c7180cbe938 *R/array.R 0711d049964c6e46a4c7541a1da29989 *R/as.R b19457ebb91e2704210d35b544a57b85 *R/formatHex.R b770d633a592a1674dc18c8da3afbf51 *R/gmp-convert.R db13b4c1aa1fe454796ccd137f47df10 *R/hjk.R 9fa5c27a196f7ed45ab20d42796cff0e *R/integrate-Romberg.R d2b8c1d082bc7ef3e987c7c90efebd20 *R/mpfr.R c03fa36a103dafa851e2ba55a80aa9d1 *R/optimizers.R 9795235e592aa17ccd5a28371d037e47 *R/special-fun.R f42559cfe95d168afeac7a8d53b5dfa5 *R/unirootR.R cdd3f87c191a69a297eace37919cb1b1 *R/zzz.R 9af43e4aadaee883c22b38917ce2dc12 *README.md 2174f2e0b51bfce8f566a7642847ea88 *TODO d7897f55dcc40098efd70fee1d417083 *build/partial.rdb 8b7f783045dc578926a5070d777e4937 *build/vignette.rds 2d92b8ce8343ac4b6029d6a1d03059f7 *cleanup ed70fa826c918fc4369b0e84d016904c *configure f454873d082736b6180bb76ced47a93b *configure.ac 9e1c8d825bd0b9cb799e9dea92c672b7 *demo/00Index da3fe1f9afd8af15f7f8c2291231501c *demo/hjkMpfr.R 730f4ecb0c132d7553fd63aac024b0ae *inst/NEWS.Rd 587b6767ddb29e687006d8dd425e920f *inst/check-tools.R 167db203ff72ac5de5263a7f99f4c399 *inst/doc/Maechler_useR_2011-abstr.R ca4d6c443c917a2b41766aa538ac5987 *inst/doc/Maechler_useR_2011-abstr.Rnw 8725fd00e1a58298c7fff61095dc1746 *inst/doc/Maechler_useR_2011-abstr.pdf 0ca5c84debbabe691d0bb3be74e7c3e3 *inst/doc/Rmpfr-pkg.R e445ed0eb9d6f2cb9b5c22f9c14e6d87 *inst/doc/Rmpfr-pkg.Rnw 186f59a42973652c546d193f29eb9f6b *inst/doc/Rmpfr-pkg.pdf 3291df1b02b765417c0c756cf8a41c7e *inst/doc/log1mexp-note.R 2ee39564c6d2a048c36bdc7ea7e9d8ab *inst/doc/log1mexp-note.Rnw 33892c4474ac08ca5e1897c532762d02 *inst/doc/log1mexp-note.pdf 4969601c85fa6a68b131ff5cbbcda659 *man/Bernoulli.Rd 5d1adcbf216d265846e5542b2212f5fd *man/Bessel_mpfr.Rd e66c83bf74d08c17c71abe49562f440b *man/Mnumber-class.Rd bb52e7424766e0991bbdcfc16c886f4c *man/Rmpfr-package.Rd fd1d85813d46057a45575f90a0ada621 *man/array_or_vector-class.Rd 8d6516d0780e1e48d0168e3bf1700827 *man/asNumeric-methods.Rd 3e6d56e249fb31f49872b9a4f1cf1fe9 *man/atomicVector-class.Rd 19f32c5f9eef2127ad8d109d7716af7a *man/base-copies.Rd 87174bdb2d3b14d4ff7c71ee68ed0a4c *man/bind-methods.Rd 51aafe1d6e1f9f44966c17330ede8caf *man/chooseMpfr.Rd 85b8f680605b1809d46356347d114bb8 *man/distr-etc.Rd 0b6d3ceccb5aa1640d6a3efba0301094 *man/factorialMpfr.Rd 8b0811229b0f62bf40fd1d358f35a4ad *man/formatHex.Rd c9316ba74127d7d1a8e91b68b2698fc4 *man/formatMpfr.Rd de337497be555732ed4924d166445811 *man/fr_ld_expMpfr.Rd 14a086a7b9eef7db4f12f1969c24c0b1 *man/gmp-conversions.Rd a998d1b6dc750347f0728e895ac929ef *man/hjkMpfr.Rd f55782a7f6831b8df45e07a1882f5355 *man/igamma.Rd 24b40df99950fba5e4c18d4058061802 *man/integrateR.Rd 83b62f162e8b73fd4c35e1709ae2db1b *man/is.whole.Rd ae9a6e22a52311b484492e0618994402 *man/log1mexp.Rd b59967ffab6946d1e4808d22a005b967 *man/matmult.Rd e053e23af408c7d9e8f1dc157234f71d *man/mpfr-class.Rd cca26df81309118b1588ca57ae88d967 *man/mpfr-utils.Rd eeb703619c80e415f0d1c87161a37c1a *man/mpfr.Rd ef0d1547ea76b687d4d9ec756cbb39ff *man/mpfrArray.Rd 2e780c7c7a5e9f54883cb259e87575b5 *man/mpfrMatrix-class.Rd 4edd752c39f1bacf6ab5d138fcfd98f2 *man/mpfrMatrix-utils.Rd c8a1a2e8d638e7049dc8f8e93374e99c *man/optimizeR.Rd 370f2ef0723505414a4fa08c77d6308b *man/pbetaI.Rd 92d078f455a67440cc1303e46750a25b *man/pmax.Rd bd69a96bd44202b14949e1e8877da7ae *man/qnormI.Rd 4b8af5895987ec1453fa6c762eae1740 *man/roundMpfr.Rd 8825230c6ea8b5973ddb45618529333b *man/sapplyMpfr.Rd 61d5331094c01c5932265c0e61789b59 *man/seqMpfr.Rd 6c5082f10c6f2cafe3d3d7008cc81e83 *man/special-math.Rd f04ae96d01961265097f8ceb8f9982af *man/str.mpfr.Rd 505caf2cb629038d577fff32882832be *man/sumBinomMpfr.Rd b95164d43f0feee6ef07b93c3a5d3343 *man/unirootR.Rd cc6ceb21c1d138d93b5072132cc49c01 *man/utils.Rd 6fff990d99e1480017be2dceeb6268a3 *src/Makevars.in 8b0bc00798e2d4a494e180fb4c79e7df *src/Makevars.win 1502573a8b2e8bad387b06dc0a745ef2 *src/Ops.c ae616050bfa9d35457d4f4759a31d983 *src/Rmpfr_utils.h 1d32b2911bd1640c603a10a613a04cf0 *src/Summary.c 06cecf8dbebd8a36734d820d1f4336c9 *src/Syms.h 490def29196004e4115bbbf70ec066ec *src/convert.c 2037196bbfd0965135f21a59334759f8 *src/init.c cb74ef812cc0bd176616f3e035491a07 *src/utils.c 06a2b514853355a62cb889d4cfd7c2c1 *tests/arith-ex.R b29415f54cecc2d4ffc1ddc4f4bcec9a *tests/binomial-etc.R ab445fb09abc4b474b016397857a5795 *tests/bit-repr.R 45895957513fa7e6488a017f0a836200 *tests/bit-repr.Rout.save bf11624748a24ba9a160bf67d754b032 *tests/create.R 8bfe461fc1a620e139accc0feaa13cf8 *tests/functionals.R 0c24328b4fe8efb55607f35345a90873 *tests/lowlevel.R a02ae1fa6174fc3d1ba606d7a47186c7 *tests/matrix-ex.R 38d0767009dd47ce8c8f05d45a4e66b0 *tests/special-fun-ex.R f32980cc228ddd92f8d676ac972d6dbc *tests/tstHexBin.R ca4d6c443c917a2b41766aa538ac5987 *vignettes/Maechler_useR_2011-abstr.Rnw e445ed0eb9d6f2cb9b5c22f9c14e6d87 *vignettes/Rmpfr-pkg.Rnw 88c9dc6190d3f167e65563af812f68f0 *vignettes/Rmpfr.bib 2ee39564c6d2a048c36bdc7ea7e9d8ab *vignettes/log1mexp-note.Rnw 30ab044ddacc1d0eca99bfa8a6176f7a *vignettes/log1mexp.bib Rmpfr/inst/0000755000176200001440000000000014552770135012326 5ustar liggesusersRmpfr/inst/doc/0000755000176200001440000000000014552770166013077 5ustar liggesusersRmpfr/inst/doc/log1mexp-note.pdf0000644000176200001440000042445114552770167016304 0ustar liggesusers%PDF-1.5 %¿÷¢þ 1 0 obj << /Type /ObjStm /Length 4187 /Filter /FlateDecode /N 61 /First 501 >> stream xœÕkSÛ¸öûýú¶ÝÙ)²¬—½³·3 ¥ÊJ;û!$x›Ä41-Ý_Ï‘,¿ä‡rwî ,Y²ç}Ž¤„Ɉ š…D’ˆ)¢H¬Ñ„É8"a±”$&a ÂJÆHKx†„‡ÞsÂEeA¸ÂzIxÀSÁô¡‰ˆ”#"öIN€(¦ Qœ+„(‰ï9Q1‡Aa^!|J¢¥†zEt$á½&Qƒ„0ÁG0 ˜H¤bœ‘˜)œ‰•€÷œÄQ `’°„Zs 3˜.dD  ‡:€*˜. TÅ –@&‚>ƒ1,—În2* ÂÂXCôÌôÌ#’€ž‡BCoz1,VBÏ’Á +&9 @•fP`RÁļ2‚é˜ M 31 zV<LÈl=+‰`„ž•‚%ÃB @:æÿúí7BO’|4å#;ÀгÑu²20…‹ï· ¡{P?ˮɋæ“Ý»ü&[’ߦÉtbŒ‚@‡äcH À6°u ¾ã"HcHÛ¾€^—É(O³Åþ(Oȳý_à °¨€ipöKÀ~ ‚Ÿ~.ÚÁxÏŽGÉò-ÍoÈ Ìk¹L¦Pý&ùþ-[NVå|X1$-í¼TñNÃÜÂq17^¼OŠö²˜ß¸X[Ë´¶ž¢?ÓçÔ>]²–ÇuK|ªæ{Ì+¨ÓœX8œd“‡@p¶Ì&wã`pxvLo²U¾/ÓÛœÄ;Rí0hr~wõW2ÎÉ3È_¤ù,yf}Åš \L¦ÕMûN•¶í Œ¦EðÊ™}NŠzü.²}`}ˆð‹‹?Æ‹ñpÜ&óM-¯DÑWXͯ ~Qîew ÐC ´ðH0$``+|7â#²$Û:`ûâéʶÆÂ矎ü-G8â_,².Zíe‹ fX¶ÃKÐU˜Ã¥™VE- ÖHù¢&(ZcZ?êÿïáõgÉ «12È Ô·¯’ôúÆftŸÑ]ºGè =¥CzNGt4I“e²JWôŠŽé8›e ø?Ÿè„&tJ§Ó”N#è5½¡ éo’Még:£sº Í ½¥·ÈC³dšÛÜG¦ ÒlBogw+º¤+šÓüf™$4ÿ–Ñ;zO¿ƒtDÇI?A×ÒƒÙèÕ¡áãYSÇcmȱX{ÎÔòcà«ÓÑZ[-„öINgY=dG@©©ƒØ(@Œ(°øtdmK®˜ø º1€Â|ƒå±­¹½éAÚÁ4µC©ÒΑAõÄæ蓸'R´{o–†åÐ.bTÔã{‡„ˆ{‡ÃãöÙµ¥{*ïÿ½_÷z6~ðÙÖ€G´O_ÒzH_oôš¾¡ÇÆCzKÏŒ—tAßÑKúž~jùKWw³Y’£Û”.Çwóé,¹÷<(3(Mæ“Ñê†& û0ö@r?žæÆŲ^þ}ŸkÖápýUº\‹,àÞ~×úå.Yad2YžL®f¦¹+Ø/LÉfÑQ[%_aÐUz_¹lélâ·»_é7tãèßôïd™õ2až‹Âˆ¹wX1ÜCJ‘º^ªõvézÛ/g‡û{ûn,Õ%@Pkb_€úŽëíÈI#"+J¸t’…KWÚÌ«\2¢ Ðž›é2×a<»1ÆÃEG½vïÜœ«7ä€1^cÇ—À~ÇÀp€ÕjaÃÈ Kø]dß âz¤á{ò,ˆ3Qmò6m®¥—Þš^?Ê7Ü?ž\îºqå–¦œ’ÞpaÛ?Ä6ý‹óQŒFEMⲆ¶[ÃD‰’;j¡<”Lµñ ÚxX ¾x­ÞSD Ž÷Ï/Njâ¨Í5†mC@„¾C¶šþBé‡X¾¡µÜ\8“Hm'b,êj.eLwÁisyà ÂM3ÌÅF„âD°-3Ap“P`èÄ&òÿ1=`ÜÛbM™¿¹L§xA·Þ”ñJ§5K•h£’w ÈÚÑÈ`ƒ€@«–õØáÈ6e®!—¾t©×y>]ží¾9jú—]€r>K¥À„OŸžg×;‰;³ýi aa⣊Ÿo¯*Á·ì³ ÉЪÙ/Ž‘Øt³gcaÊ€9Ûä”pKKò TY@|·«íÀ)Xq׸eš,Müô×­³Ï¾ÐÕ ­ÁuaË–á–‘©Õ`Îtè&çØU”·™ úR [qð(ðÕ§½w—Ÿšá¦® ¸òö»üxeØvAû’_sm!ÈšÚl±D›‰Æu©¤6ãè#a¾nÞÛ‚x½A¿Î8ð@1<Ü¿x×Àõ¶Ûa·ðñû*ÜŽS•ðã8Äéš|Ó#R‡Á‡ŽHðß ÌžÈ‹zvº³§ûo^áØÙ"Û:FÇýX÷ÿaßÀ¿,wj1gK.÷Ø´ztïºÊ]ïý>ýÿÿDªÆoÓ°ÂÀbÍÙ yÓ\±q‡£"Þàb #:ZÓÔ:Ý£# ËÑøs’—§È[O§½e;Éf@/•ùSsž:žÐŒX]ÖÜâ½[L’åjœ-“M¡‚0.c¯íX­• a-Æõö;Ö2OooL>Ì´¡Ï´/? J/pë}àÈgÚ¶{ úö*öiP5iÐKôбÑ%Ãj‰‡U"h£c-XúîuôVÇgï{¯a¤óÑ¢{tË Þ¶£¾p%üd[Ä  û»Ã/Ÿ„· ±}•WÔòG—¯?žºòå}žŒ³5[.z²Áìãm³OõÞx¯RÈî@7çÎ}±6iÓ$ rh"ã·ÿ{æLÃw ×Ez’ÜÛ'ŠßAz}]•®ò*?O'U!¯Ilø¤*\¹‚‘àƒF ë¾&ˆ« b–4Ø?–¥8ö=_¬Ô,ÂÙ·hÐ Û>L}¥rÐ[|¾}[IËñø9üñ\Ä&4! ûÃ#íTZ0·­ªŸ6¾/Á0°êœGXÖ&nÕZ£º¦±íõ¿ÙŽ‰gå0‡OÕ•Ý BܤãáÐ_5S£µ]­þ:½vûÑߺ0`w ­;°”5~®+¤èæØo~Û¦ƒ†²‹õŽkáBñ:Ï 9&Dök·4ª¿Ôƒ?Ën~¤/*ãMÛJÙJ”Eñ oe<å©‹Ò¸Þ5ÁÎ }7¦7è¬æ"ÍÈz3ºe¬Ìz”Œ4#c&îÓ¼á)ézŒ ýÕƒqxƧ3aÊ"†÷t«4Ó¤uO³ºS‚5ê·P Ë{&¸P»–‚×XËk)öþÏͧ™®ñ óTBu 4M<<°Vœ¦%ÅáZsÎj:…”BšY’Ã¥æ‡x\³:)HPÕVš³¾s&Ìžðý§ÖÔ\@kjO3‡ÖòŸ¦Óð¿0ÑO´jeq$Ç0³å)bM$<e­˜§æÝÎîþXpV4endstream endobj 63 0 obj << /Subtype /XML /Type /Metadata /Length 1504 >> stream GPL Ghostscript 9.56.1 Accuracy, Cancellation Error, R, MPFR, Rmpfr 2024-01-20T17:10:31+01:00 2024-01-20T17:10:31+01:00 LaTeX with hyperref Accurately Computing log(1 - exp(.)) � Assessed by RmpfrMartin Mächler endstream endobj 64 0 obj << /Type /ObjStm /Length 2746 /Filter /FlateDecode /N 61 /First 518 >> stream xœÕZ[sÛ¶~?¿ídLÄ…D§Ó9¶×Ií4‘Ò¤§>Ðl±¡H…¤§ç·Ÿ]”(R’)[3DqÙo±ûíBZF´&J¢ò€èp¦àjL‘€®´ '<Ä{Ÿp• ¾Ï4 $ñuhH ˆð±&B! "´kHD($ ‘Üç$dD è$äD*ßÐ'2Pp/ˆ4\’PÅ`¡"ŠsMB˜×ð< J)¸‰2\R èÜà ÞpX“Äøp…þŒ€¥0¸J¸B—Âá Sæ0yÀR|¸Â}¼‡%¸ç ×½sÆaQk|X TsË a.Æ ¬$ 0Øf&…†ˆQûØÖ(MXdèÃ#Π`Ä`<â0?®$`BˆAFIx+˜¢ÆX›éqŽãq¥ „½ u8´Â_ç§`•(d˜àÂÝ4ìß-,”ØNâŒð]{bRÿëûï =‹ {‘¥%¡?¾ûòòúÙÕõ(›Gé8‰Ò’³“‘½[&QNè‹t’MãôŽÐqzšñºâ"΋ò|­´‚;èí¹-&y¼(³µŒ‘¡WQÝÆ÷CBÇË›òëÂú~yu©^Åþ§å¬ ¿ Þ´ë} H¥_»í£AT )å꺮õ)(Áœ° áj›§ŒÐ+º„šQÕ°ºý°ÑÿY\÷䇜jœ x ˆôÇé²h¡Ä¶\)*ƒ]uÀñ»à< ŸÁè°¡Æöòí«_/Ð\gi¶›œ áéà!dÙÛ{z $ ŒHóuдîÿŽow Ö{Â:uý7ØÖú~ï:6ÇêYt-+ãn[,ã xÆ zA_‚Ź3¦ïu“8žÄùd9¯ÊeœLíJû‹ÜD“E3z“G›ØÛ²*å8Ž+~´åªÊÕƒ dI–Âï|Ÿ™f hÐ7?j?-£œÞmüÙÒÛl™ݹËmãí™}]Ìl ìçOÇ[Ž¥qjiºœßؼˆïeP± ‹(·©›ƒ+U3XÀ³)]$Ë‚~¢Ÿ–Yi§7IUÀÝ”X¯,¸#U8Äjº…ý ñ=­]Òr–[KË/¯e:…‘'Ynégú…ÞÓ¯ô/›gt B³ít @sO5Ä5OÇDˆ®‰Ø¿cZÃ÷ˆS‚¿cB½lZžNÊ8K«ªofe¹øŽÒâsêå'‹<ûÓNJ/Ëï@…ït2³ðs²ˆJwWäš:»9]|òfßÂP`ˆ²DWIÇWÎÝ „\xs "t}C­Ï”œÕHOwP\y¡q™''¶•¡¹ŠÓ«Y§iV6ËqŒå*‰ŽÀ…qÙ”!ÔMb¹š,Ž¿iÎB4ï …ö¯.cd^—Áçɦ„ÜoʊȦ½ ˆlÚC,©USÖ˜3¨Ë!& ª2°Ï€7eUܽ+Õk; AÕ€!¨z¤k;£µ‚`ÖJ‚Cy½ÁM.®îÏ°ß&¶pÐ;óÖÓ“g4¿CñùHÖÞ—ÎÒ4B~ÝÙ¾oùpþ|tþÛÓ0[}‹êúˆÓ{¾Å<š×)s‡‘©Çq=%×}Icà;àÇÊ:¼_ux?kÛå °Á·`ú*c³Á}µ“f¸gÖ®óŽiD¼2#ûÁL4äÃ4ÐßBúå?š³]5še yG3†êE`LHe —êv…Ë!ŒûîíºÇøö‹b(íï3èO³v- ' Mû]®mÕ6,#Aó.¦,Ùû<Ý~½¸/—À0q¹9f/·h§/Çä6J ¨>?%Ì[e2ÖƒÐIDøööüÖë]quùêÕùé³×ñüfYŒ£´Øº#xwG4I€ö–m,«Ä]û#„p_4d²þ­Ó{˜ÒðdXj·ê5u8£ê™_'6ñºJ·„ ¼ƒ[úÕÓÀíž1 »Æhî5DAø°Gè©ûËËãñÛg°%Òi”OkÛ÷f¼¡írˆ¶÷¨A8XÛUW¿ZÚîr¡Õï~JðP‹C?R»Çã~pÅýtÖ>BcEŒqTßUûc¾LÊx‘|ݱ3Ü–À°‘C¼ƒýà3wðöØO/©½[÷öê¹Z9Üð K×gÈcø ìæ°öL­Fá9Lã+M‡‡†JGb]YahX—5þµ<ôfôÔâ»xîhhWÔ³+Òa‡ÍX“„!ÙÊt=Ö‘xCKiÜ)æÓ‰Ú•£¨v´c ÅüÆØ©€¶iÄl܉n]–xª;Hðû¥ØI&(ËS„?]Ajux \»¾·—?½>¿Ò>v[àsàឤoº@l4Èj­LŽ¶@UØ ‚4 ·ä´t/í½KGÊf¸û·A£Q»´wH(ôÿH𠜴8š~ëGè÷“{¬,ÚNa¶D¸6}!w¶¶»¼G%UÎàDôA.dg{|°Æ¹ÿ×4Ûƒ»?ÙÔr;ˆ5’g=VnõP6±ÞV{݆K£…Ä?a=¯WgŸÕU×× ¾Vïÿ±¡OêX[’›Ç(ÏÀ<þ4‹½h2w|ÎÏ“ø¿:ß÷ 0'­ñ("ü'/Í0/„Aƒ^Øx> <ü‡–VÂ3¾9îʾ|ùâÚgG‡O—ûÆÓ@"•ñ=ÌÓ×ÆÃl;ÈÄ\i¾ó(NÊì»yd'³Äæÿ.Àˆzx’åÙrö—7yÄYìf£høžïÄ ¶ƒMr/³ɹÀC:œo=Uúßf˜43x]¥=_Ña#ƒ—:ô`¯=€Û-l8€VTÐ6î/¤Ó{óóøöÖ‚QE+Š+ª²8ÍÚ6-Ó`uÔþVÓƒ±ý“#uíp]øÿÞ&ÏSeàšÏ‘†ÂCAw ¶½¿ÿ9\å£endstream endobj 126 0 obj << /Filter /FlateDecode /Length 5420 >> stream xœÅ\KsÉ‘_yÚ9:ìpÀ§i¬…V×»ÊÞ‰ íXöŽ­ñCfÄ:VÚC‹„(Ì €&µ¿wÈffUuWöƒ”FŽqè ]Ï||ùeV5ÿ¶hj±hð_úÿbwÖ,®Îþv&è×Eúïb·øó³§/ÝB¸Z £çoÏb±ÊÔN/œ„A„]œïÎ^UÏ–JÔ6¦º¸¸=´§õöýr¥œßª¯ö»›ÛÓæújù?翃A4ø:ÀÇfq~ ãl—«¦nL0Vêjµ\‰P‡ \õº©»eåki¤‹ý«Ï–çߎfÀ6O°¾_ÂÊËЈê†fSÁ5^Á Ó4µT2wÿ Vd]Ý4®ú67Wes‰bi9m\Ð×^™F„QÆ+Öµó²QyÎ×Ë×KZ´!è8)SÌJz´_¬`ò ¬ÝžQí´vÕ?ø¦uü¬ƒUFUëò {p™Ôטê é¶ ªêuzz·ÎÛ7Lغ©é¤ýrG‹V8ÒÆE(ÞÒg£ªÃrbOÆÖ ì$sÓ^,A!Q}GJKël¯Ö}oؽ1’$"´ -kk´ŠÃ|C]­S¡®°IÜ®ƒ×üÙÿÁt¢z·]çµ æo‚H&åµ ‹•PµÑ> üyÜS€ªóÿ„‘•±©ê¿oãÆh`³›‹¥´uÐ Øwýï8ËÊÀö•KڤśbÔÃfû$+tõÇ‹è,^xë«SŸo+Ù™¦ÎY2½'Φ÷ºzOŠÊ 9ø_m=®Œš>K†\¦ÀJCc+Öò[â* øÜJÔ`šAÓ“çé ô輪þúš›V¿k¯—J‚®­«nÛÃûô„¶õ¿€ûI_¤¿À]>??û3͹¸4û홳4µ—‹Ý™‘²ÿº=ûË,ØIµ°±Ò–`']¨ t4 ;áíªgoŽ§C{qJBqE·•ÃUÖÀÖ}­}#â¿C“ˆtÚ‚ëDµ!mµ9âk—Õuñûþ´Nʵ¸ µÞÂÝRz0+À»pY±Æ÷Ñd¬²`ÃÛvs¦°ª*§Þ/%8Ñ]²iJH]û&3øëx¯°Ó™R²¤rU{gHÈûKkÙìÓáÞ|õ%~D©˜jKQ@àçAèGÐQÁ ØZB 6í¤‚¸b ·@“S>Ú½UhΪ¶WUŽŠv¶–Ò†‡örAèŪêÓ·g1ŽM‰ÛÓ²åÀÊÈV(Lg4*šƒ0ßGªR!í ÝI`å*ÚÎ ž¬•-LXñÖÀ K½->'¿°€š:T—Ë®!¨j@’½bAò¾–¾8øªÙÐH[Êg@a¼¤äÐ`µ"wR <ÐW›>S7lÉÛu|Ô µ¥c_¦.àšû²Ãi³k·é™wÕŽu*?3Ýha*ë´Ä6ÛËò[9ÖNè‰Íì»mŽPy#ÀN€þìûÝ’V ¨r»$¾`uÕrË›lË%Þo¶Bú¸}“èAìt;#¦ÔÓf_>;&ƒWÌà³M¼8C·à÷`¯_Œüƒ!„³lÔ½»ê䮊ŽÞ 0oª_Lá§v@ BvžûIç±Ae„ŒÑï¿)¡)0 ¨û<±G I³yÖõýÍNÄ]NÀÔp›åôBÍ ÇzÑ΄Gv«EŽ'ÝŠkâ$„¹qÎë;Z(ò*R§b$ÖÈê‡ê{ëõTlõåÒlí­F²S6œ[¡Ëù­5¢Œp6 M£Ã `ˆ'S‰µçfÍoÿ“'S›´°6ãËÅ®”Þ¨CèêåLHë|㘆5 ”ÀE„ø„é$¼1hbJÄ­ð öqÄ|ÀöL!êyÜ â™G,Ã…¿B‹IÀö¦l½ì¤IQLC-âÛaÍÑëZ`òò’-æÎ4'üQðÀÕƲþ,ôl0Å(#/Žçâ´§@bZÇ”8 ]jWx8lÑ7ë½ds¾-ÃhŸ2½d4JäÞŒ_½ã&³A‚[Úd#Ú¥°œc=Ñ7G Öa]³¼MRC´ ñ'.*pOàú wU=ãQ¾¡Ïm7ž¨Úãær¤Õ÷ÐS<Ö+ˆ¥c΢ˆšÃ¼Ð&€&Žû4 ÖœI¦y&N4€è|×qÚÇÁÑÚÉ‚´ R<ž”‡èì…²ä¡LS@¡ ø¬Çü;aÅÐéÚXHÐWE»ÈF‘ÇMEÈÝ Ì#€œi¸öºdÅÃICÜ ÷Fí~4±L_+a˜¯s’Ž!÷0à/àHÑ@µ€ÜF$µ©º0tU…Y¬ПqceÏ®‰ZY V'rY°Ç¤ PV æa6³XaJ›Ó‹ß/Á8×ïSYÅ;Ûà7xÁåq²Ž¡ ¾ì¼ò—TA€dCa: (ûh`Æ"³¿ÅßAÂ`Þâz¬µe­ rÀyL+ÕWI<ÚãO#[È]!ä%!ÄÇvÛž¢c1ÃHVV9ö‡®⪗O’”CõÍŸŠ"Ëoâ$ï¦Cª8ÂÛ²S÷å¬hk±¼‘kùëC5§ ³²¬`©LØl1ÖGBKƒp‚µ*eAL=ÐQG ÉËÛ Ü8(A]ýaJõ)Ø ¸ëëÈ ©,§«kÐoüµ¾OU1`¶ºÁ–OrßêÍí)w“™ùÆ‘èq{}ÙšrV_}LU–¡ñ4æÚ« æ9¸ í¾œã* $2‹uÎöÉXÜL±ÉËâ÷MNÀ€èÉÐba0w1ü÷.JÐeò”=»YUíS:†Ýкªç‹³ó}ÕçD–“"+)€1 0…°åF©BÑÂÖí¸ÌŒT˜Ôñ¶0©Ÿ0ó8c3ÌŸß­û>1ê².IEa`(MÕhJz™ÌÚRe³vÔcÎj ›‹ôgBõ/0ˆ„. K= ,\­„LZÚu)ÇçY\HïÞE¨† Š4è–Rb¨é¼øõïÄZP~\ÅÁH1mC5\~Ž1Ðtݨ¦.^< êo©HVýtqdÃÓ*ˆë)¾4DÈÔs™®«Â~£«6±N>ö-Ô¨åÀöß™«>I$ìXh;8Hås:$“°i"˜€n’ñI]6-}ò€ us9‡Š—½©wBh¸´Mò-ˆ¤‘I6Ø›îR¹Ò4U­T. 9\Ñ„êF¡«>IìÒ_Ì8ЕÑÖDnm°“…€!SsË,³kzHTÚ¥!ÆÂrs,Ïp-n:e¬ã’éw¥‚&ûªâXç7Eë:­WT2PÏxè¹hCù¾ñ~øK ׻Ͷ=Ä´¬Áyž,§T·Í×”ÅP¾§¨j¡ú’Î0 âYÊ~ £!±/ש´Þ34Iùʃ&;ksa{ðì0—¿¿JKi| ÷ôar»)%{€Ü‰ý˜†…üjèé4lhzËn.úâ:­8i¹éöp¢‘0Æ™`?Ý&`Ùl5We(ÅóÉ4&Ä®Ó`Ùåå·ÈÖWYaBbúíaŸb tH‡tkµïŠ¸Nlðåع@­3ÕèWœ.§l# *“ëÆIN?Œ÷-£ÛÁ`Ìâ0!apÛÒ‹°PÊÖ"!Qî¯ËÄîr‹QÀÀåÃvÿxíE7fˆ$aUý6ë!ö¾á`™6ô±;Áú•ºÜI:\û4 !,yå¸X.+FþØ!µ0µõ†/F$óÀg@njK™=e—` H¶/ÉÜ1á!òlª9Ê.PŒ8×°¦T†"ºË“J”'‡˜¦ ! žÅ Þñw B%'c‚EG²æ,0E°Ò=n‹ÑfidŽQD]äô`%ó~ÐEWnyõÁôŸåǸ©õÀ©ÙI@ÉèhÒñQÀé+ÏX›hkæ³9å)_ÖÚó™Å—“+Ëü1žÀ4 ¹kD*(yäª >øyÆêjâñnßr~}.oAgh`F›!¦gÕ8mû£PúRºH_Š@—¬0ÏŽ…EÂäÀrŸý4w™ù?‹»"‰Â,eÄ$úLŒåžÃeBŒìéíŒ^]°áq½úZ,Q3½þxR¯B—§POĉõhdÊøht6 ²g@#@%:Ì 34Ö-gùø™Šf£šùH%RäsqHÖ'}º7Ý¥ŸGn#¨&ª¢¹vT°PžÈ3S³…»2«ãGí§ýR‹ÄÆ%Þ° »^%ÿ¯¥ÇÑ]FPôn…ý S‰Ô”¥”%-+:út7´œfßMÃÎIØx…ä?Ó¡?* 1qhc Ueèˆ ?k ÉTÌËÇ˹'V”åU–ÈL-ÝY“_B›1§¡E>-×È ú÷›­ÞÓ-˜†_'ÖŠ'gà+~píóƒfÙ%ÍIÉ¢‰xÃM5U£Q+;(\©Ü ­:~Hû3f¬üà?Ýxi,RûxCò`ØÙó¦h§Â†á¹ˆ·ïhùñ˜ÇÖ1ÏÁËpV§¦˜&—ÊÝñ$iÓôm´e¿²/ìeÞ.÷˜xÑ,8J…·‡;ÇÒüžXMÐR¸Pmâ•j%q2ÚŒ l3Ìn)‹Ä~ubo—i:ÁèEn¸ÝµÛ÷ÿ[&qyN<¥k4qEÓv2C5)<AÙ¼Çë ty`¢ @OLR›UtsœµÊUÌhj¼0º^»Jéž‹7"øk…å^@åå x€þmqê¹ä›>>z/Ýâ Dκ’ÌL~¯èÈÞ=Ê€ŽÃQLr G²5ƒ;ëfy¦<’£„úzd÷¬P—úì[šZ(W®årL¯!æ7/‡`hŸrJo Ð>dL >t¥¬^Ò Ù¹Ö0,¤™˜bïRÿ}—iãëÕL¹ÙÇÐÚ©²¼ÙÇ¢aòĉÀ|HÇV.ÐŒüú„·EÉ€¹ëÁòøbûÔª#âF$º»AwâÂ*wžÚeÿ}«Ë;˜C=v1OøÚØ\¡yüb^õÅ1½a!Ñ÷-àßo"þL¥”_Ëë*^•¸BöýoÖ§ÉÌ}w§€_l㧣7IJZñÓWV€á6¥;ý?„6º³/ÆQ‹4gLBâ/a†'(åfâi÷î„4`±;“ÆaŠÞýòÐëì2d_ xSژѲî}|ßë Ö¦?3"LƒÄSá‹]¡8¸ÕM| ÿÊ|‰ …ï@H‡îÐR³ø&Ùq{¸Xãßfñå©Ÿn©Ÿéµ+æÅuù\\sŸXhAÈþTôs[P>ï:äE¥ê…QÀP &HØͶ}“VÁ£ÄúÚ˜<¶Ø}`,€§&ÔÎé»Óéæ—OŸÞÝÝÕ×ëÓvó¦Þ®žžö»ãÓ´©G±ï9C!@*¸D1!!ÒƤø‡ ÞÞ^_D®Cê¡zöb•°ÍÒ»X¡™eø‡—h|NzFûüEzD â¸{úC-øž*Ðì›ÛÓó­òùh÷ƈŽ”9¾2’ž¿,º>ÿëŸrËø0Ü8> stream xœ­WTTçº=ã”sDDå8‰gÄ`o}Ñ$×D£b%bEc¤ƒ `¡9”™oiJ‘&R‘v,ä!Ñc,ÑÄòò7¹zÉÍ%š„èwðç­Ü„$¦¼ûÞzëqfÖbN™ÿŸýí½¿ýÉÅF&“ Yî¹*,Ä'túKSÞ ö³žr’ù4·'Y ¶r°Uœ~aø@{\>ìÛ!ï e¬æ…†ÍŒÚ½Ä'Ö7n›§ß[Ûwø¬ \2ý¥3_?áþ¤ÉS¦ 3šYÁx1nÌJf5³†Yˬc&2o2˜ùÌÛÌf*³™Æx0‹˜ÅÌf³”™É,g<™·{†g†3jÆ…ÈØ0—[f0cÇ ‘ b&Òm3 &™é–½%»5`Õ€Sr?y³‚Wx)n)ý”÷TÛTÙ­ìm.’ëèiãnS>hñ RÛÕƒUƒç þ»Ý8»Â!‹‡” ùtèkC‹†y;:ìþ°ûì{Ðb÷£|¥ÝEiKŒ¬§ÝAœÌ’Ü;}±á@8G‚!UGL½Oœô{À–™žÑÀÅiUGÍïC5TÁM(7p" Û!,/#ÌæÌtpÂRÕ%⮜¢UÕ™» êà;¨4pä*¦ªÉ>Ä¥]’.]%6‰‘{”£ · Ì‘Ï‘ºD,d¿ö}‡ ˜ï07P0âÿ™³_©e?È? ùÈCË–›oÀ1zôíÁYþ&2Ÿu\>Qõ†@ª~{‹Ý^JdR¤Y-Úb>ÚÊ¥* S£Ë´‡d:™5óEâ@;§àtœõåC´ˆm®z6Ž¨‰àÀ»gàßK„²æSÅ"ü‹Žøƒ7l¤_-ŸœÈ$ˆƒQ:Œe «dj•÷$a¬º(Å´7) B2™LÔÞÓa)Ì(^}) 1è ß¾yæüåÛrÛà6à`Ÿ²ÀœœùÀ•ƒ¹Bƒ¡l9dD sç¯n[\1œÉ~2•Œ!;ˆ/N ЀÈ¢Úh(¤dˆc,'†5ØwSL³ÐÖ‘*}ŽQj¦Þ'.^ëc‚¶ gY¾‹ÌûÏÞƒ€ç¶2údäûÀáÈ'ŸãX ±u cæ¯_¦Õ– 0›å‡·è(lr¹rÁ‹8iì~”]N´²I²´»û{äùQÒ«n÷>¶ñO>ûh%å*þ:™ýÛJÞ¦ëVè +ÏÄ¥,?Þ’3p °/Q¿â8_ËîÊJKQ‹@Wië`R,8¢GÖ\©‘5^Ã=×äÒÔ¨¡-ÂSì[˜µ6wYÞŠÜëî [¿¼°+LH9b4íNé»4„ecA8Û …G„£%§Þ…bp>‡ÃòÑÙŠHë3±"®Ž±ÿe>­8¸Õ‘ï’lp¨ºÃÇ›]¼>,°ÝD↫}Xãøãǧs;)ïZ•ëÝ]7n<K ÕM±„[ñÕ¶?'˜5VÁ°žzhÒH –·_À]Ͼ±å­9sÓ*Ï ¼þƒå«Ÿ¿šÄŽû0ôIÅ-¸# ¦WUvÒ,¥.Q†/¢“\rt‰BêB…ÈúÆ=Æ¿™Ó¢¢·‹(´lƒù´Òã4<×è¿Ðº„WI#-öÕt{¾ÖÍ’ËԥɰOXn‚B(ç0˜í|ó⺚ؤÎò©‹«ª©.m,ÑïÎ,9Pܵ–í¯h¶±ä%2c+‘»#sý“wZOÑðëw€ö[¡]UzÊ4Ī§ÌŠ zÛ×rúoÈÔ~s€’cÀÊ+ŸŠ2馃¸%sP‹:çäüœEvš!´fvÖ²%¥©zHM643'ŒÇÁÊVQµË°Â!ÖÒ;8íÇ,º“UÔÆ%ìÓëg}æ+s5ýÅÇ ô›bu²ÌÙ5P‰râ¢ôѪ*ÌR&×@½‡{V0‰kßiÁµíT˜gã¨>1Žœò€Œø;^°)Ö7ˆÃ6öy=~ÛÊ••i_w.±™JPx|ÇP šÔ°VEíÞ¸))ÁŽ¶}eœU‹nmÇÏ·ºàP üMd“Eº"ÊÊP&—®JcÔ"hH_ø7³“–…6ˆOOO1¦kÈ@r€ Çå9QEƒPð‚ŠÀe={Ǥ&ì MMpÖm òXi‰YfSM>4r–¨Òà(]ও>ïß}÷ÖÉ#J>Y‡2^g;)rß±AÖHÍvÚÈ¥Z²üDHÚc4&¤ úØðÅÓ€#®€“O]0¡#:f_0¤‚Ñ`0jÒÓã÷B$çS¿»²´±àÌ]Âf­% ©³ä…¯§á8œ^‹\6-¹bÒh¦Ÿ·ãÎHÝt§¹¢«ÔõX$¬’!YGô½Çˆ^:žL¹¨£¨}Üû¡ ¢Æˆ´8CŒ1¸]ZU¹ù?Ÿ9à§ÏpˆÊÍ4š Œ“ΙX¬ì}r 1+©œ‹ +÷@Öô p2õv¹jUUæn¨§G7Tõ—>\”lhé­rµBeÄRé‹ŸÕ*±¼ø\ÑÉ6ºdkµ…dôØdyñáËè|îL‰¥IãÍòsŸ(øª·|ÖÇû»¡€üUÚÊ5µç/d•C œŒ³lµö¡°ÒŸÐp;#¥œ‘÷Üíq¤…ße˜Cë‚]´®ål˜¡"½:Íd„h®÷e¶w´•”g4ÅPp"þàXXiïWy &c8W@V¹FºÃB™Ét4³Ø|ÄT V‡­ nˆ««ñu‹½µí„NGþ)šòâð^HÙcLO"–.Ñm¤ Œ1¢Ëy ¾«â(Ï‚ÊýíÍg4>­« VÒ‹î/!ödÔ÷î8 'z\¤™†Îj’¬2·˜šJJꎗ‰ðr¨`6ЕeÞý¶€Q*»ï#'—^•þKÝâߺÀÈ·N3O{‹<ýƒnôU"ô=Û}µÐ’g6²„½IÉ»AÇm«‹;ZÖpø¤Ð—,Èæ:|©óvî® «·¯½»ê1¾ù8ë®#Ï1R«ä¦®ˆ«óÑúêâtoÏTøúå¬w!š×çú¶jvÇÆ€?hËw”îáøo£RÀªT¶š*µ?@5݇+žÀAl3Ô%”EÔÒ|»˜¾íßpö®±Ìå»ü‡4¤Nšª^cœI^È@lÀA*œ•ñŠ—µÇÏîO=Úö/ÐÍžÚ4áºùJ¬s=¥I,ÿgòº‡ ÏÅë4:ƒËV‚ñN¤Ô-µÛ}ƒvúùÖ7¶ÔYš¬ÍžÆÉ7DônFfÙÐëAë¹t7©á¬’Œ¬u_–~qí– ]]_n"Ž¥B†Œ%ý1½žå}º1)YоYº¡i"Õ÷‹oL'²Å ›íÓœõ>–Ò½ëQt¾¡LW_ë9­îOD1ƒhjpì~ÁX 1?e¯¾¬c2åä yy9••ïm¾o ˆîW?ÖüÔ}}Ûq¨ˆKDÜh%J7Å"OºAMoÄ@¢i_FZFâ!ò;¡ýwù¹y9×­}9Â; V?ó'6¿"}ZJíÍd)«”´,oü-ø¹ær ¤ _Z×û)5‚-Ì?\PVŒƒ‰»?7{?¤Ã>1)†&gOT\µ>‘؇ Õʱ¾êQ¿´rZI÷z›({4,©¿ãïÇ´nUðq?=kž¾Ê²ó¹fkßÛ‘¿ötLŸ,:ýÎÅØM‹‚ö{þ²èð2˜ÞžºÜ³¡æäÿb¨¹†²;g/(‹žó*é“Ñ¿¸¡Ï›èOÌ/ÇÈp*åR v#©?W H˜·ŒÈ­S]¬¶Du:²š ¸Þ2¢Ñ²¸Î¬ìmð2:·‹²óèŒ^8\.™1Hí£J×é½ö&í×Ͻԓ§©¨D¡üókíðg´õ1q"ʉË&¯÷–×6”žn . ΚOwd–×yrîü9ëæûj5$„Ä$%Óvç¼[šÍö­™ÐÜ„Ú¿‡Ã[ìÏ +€ k ÿQ ‰R.RÃ;‘_“iU­ºø|ÊÝž‰hˆâ¯W74í9Z}¼ätyRý¦l¡µådw|,pGXHÀŽš°úÕ5ÇLvøÝ9»žGëðÛsømŒLšzNÞÓA¡9AwJÞÇ‹ª¨ ƒúé"¹Èî‹€°ð*(Ð ý¤Š‡ðªcpô€ñ}¶€Ms!ót¸î Ü娯P_9¿fkøN?ÿJÿ3ÕŇ33cXêìWêS Hå’ó“² ÞÂ4tÊò±CŽWpº“tLc¦V?­nüžU?[ÛSqÛ;7qÈhñ3ë@~Ö—#_‘øÔ™Z›4•N,©J~Ebq{ÄÒÈ&·9¯bj„à¤ø(ˆàx>qGUT½À_K´+o<·å½±¯-^«ñ9¹h¨$J21 ÖŒý%y=g°ÔÙž¢ßs~![™e ÐÛ¿½Úëßã¢IÞ«£Sœî`lI"7>bïß®ÿ¬¨ÎW%Ø%äK^9¸õHn¾J´AÙ ÁF±&Ìv ØÚ€í ê SF†Él:˜wÛÖlíæŸE5àŒendstream endobj 128 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1230 >> stream xœU’LSWÇoÐ÷€Š[_šWÍŒ?B 3ât‰Y¦lº Q¢á‡ ¦íÚ¢€ ÈOÛ¾ž÷ÚJ)ˆ-?ËCEœ j™ ²™`·É–eQ³ FYô–]ãöˆûÃÝsssî½É÷œ|ÏGÔJ¤P(t7ešŒ_/_•”Y\Rn((›}Mâ UÎÔ‡VZõÈ|5Ñ=x÷§¹×ÞA³+ÜdÞW\bX¾tBè ”ƒÖ£ÏÐ&¤Cá(EÈÂHJÑkÅmå'ªT•M5¥NRóx0êÅNÔØJñ)ú'ññIU(ïbqtò3¢ Šä%$šè%bVçRÐÝCgh&Âå>ubtÞÔµ÷‰F/wuÍj6KX)áår¦B±L¨2F¢r ZÜ3@𺸇˜<{Öâ%êSÞ Ø+Æ[(†nç=õ5 °¿¾ÎÚ´6)n¦ZAw<´y½~f.HÔ>ÊÀ »¡\¤-ÔwÐf 1E–ʼn¼ûØÁ–² ®fÇ–<›Ù!ÿÿ(vÉVvðr)&ãP%ö&@‡§µ¥íÞó¸?H˜§®­šâ¡¦¶±ÊA3 ³Æ\€>臓ÐÃÏZÝš/—­öáTŸNžiÓx,s'Äbû|Ë}¢Y¸j1™Kb'¾Àêà‹îæF€&_kãÊ7d}• ù0 c0i|AÃ,p¹@ô&lq°LiÔ4ãE¿ž†[ðmš@Ôô~H¾o¼¾#øÀMþ×7ûÛýº®aÛÄöÞ+Ó—†ë{c5 e‡ÙÎê®ÝžQ¥ûLc‰w7Ðk6lZ9Xâ­×3Ý}ÆR(´&€Å[|ª"û`aäЩ·b V>ûÏ'Ká#ŽÉ\½ Á*ÜÇàhžÎžÎêÁÃ@ÿvëú=©qØ8 ?v✷\2n»ÍÑ`ƒ*šQ+¶4áOîQ÷ˆž¤ [ ­XuuÉÇô´|­ä^¾¢Ù¬õ[—pÌÇuKÖ?à?ÞãÓ3 Ôþ>/Üšwk Y†ÍôÉÍDJ–3ºçc±Ìl‰ùÏ™0Šùám˜Þ†¹OF/8 ó A 러Tà/¯ªBÑ1’‘ZÉ·žÖ‡nPÝ¡†Û™—Q½™·ƒ¼ƒ*àÊááý*@•òµ+9£Eƒ‹a²XáBDöWü]U©xTá bgÀiwn¿HæâhÀ7åç`æò( ¢Óé´‹¶ºÖe®>‡¨j‚DHm&Q×{é½»ëÚ€v‹¢Kÿ?al’•}XdávŽJÇ춿>œªZvÙ ‚]àõ—rpa€L¹Iæ&7GîÛ@[]gëï?cåen«Ú1‚'tT•/´® ›<í>ÑÉE¨³LÚpÐF€6ò¨ nA;O·hµ Õ!ô/ê aFendstream endobj 129 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1007 >> stream xœ¥RmL[e~_n)—¶¢KJd÷n“¸%F‰BHÐL‚Ù ›S6§Bì fi±¥´ e-´·oioK[[&…R¤ › t(¶¡b4º?P¦2ÍýåÅ·íÛ9/ºþ2þ8''Ïyòœ“çD9B¨¨ohPv¶>ÑÝ~B£Ò•ï¹ÿHËI½J©Ýê• âÉìO÷ç"…d¢·2?âûîÄŠÛñmw€\¥EÌ®2¥V«1hÛN¶v*;:´cËKz¥ªMýB›º­³[Õ¢Óý líúç[ù‡à)°£¸ü®ö-h“ÐÐ ]‰°8®B ¶çäLSr*ŽÏܤJ¶ýåÔËð½k©w®Qé‘T——Ôÿ@Äì«p:˜‡*5ÈAÛxÿêÄ0b&Îx|C£ñÅØÙØk‰™±ð¢7>©!w“&²“(Éãd{5áÒ«“ø>ŽÅlx(:Œ‚´ßŠì§È²—\"÷~M p…Ðb™)¸ åËß„ßoRøIì‘OéâjµN§VÇuSSñøÔ- éîÊô –&)¼´Ë3Uy5ÑÄüY•gBÆÑQl*ÿC€{’0}@P5"“›ŒÈ`ˆ¢›šG¢h”-Èô»°-‰m¸Ú•‘¨Ì~x»×îÞ>[½aÄ"Ïy9Dw‹m7Àž)[¬ü²‘¾á›¬‹Åo‰°i§øáÆc•/—Ñ<çcFÄ<â½n>ŠEkÌzÝ^/âé6ZZúviN¸”Hm&¨tKê)ù˜5`µ8z,.Æ^W«<ˆ¡æ麅çGß8ˆè²GjÐûü!ÏÏòëßM_@Ëh¡ýJ󛚋­ Ʊò3KúDcÖ Õììéu1Ü‘†gýo"¿|öùõ-+Ì3©â¸K¯Ç¶|PÉ1U‹óˆ””î%»õ}Ìc߸Üúè‹“‡ç«M艄P+$Kqéu¼;f?­r»bÆ™Ž”kˆÆô*†XÂê‹vÕV?ØtbüÝfFózóGšs³WVǹˆÞ¼tO9›}V/o©«ÙI`Gão?þº²¶þöùΧØ„j¡>ÑvË;²mëš_ÉÑ+VÏi_6†ÝŠÔ8 z‡¼(\ê˜Nd33Ù‹dØÂõÛQ_1:äöÔ"V„lƒÈ‹èP bÉQ‘ð½L6)6þýéÂ&9 Ù<}þ¬')!…ý> ‡Íþ~nÀî´3Ù8™ï³rd† qA.5NÎ+x‡ÏáGtÄ °øý¢ÿ/R` &ùtab.&NJ’RFB+“å#™ɤ1/à º}žÁ ™ É ø %íendstream endobj 130 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 293 >> stream xœåþLMMathItalic12-Regular‹øyøM‹ ‹ ¸÷ÐÍÊaB¡÷¬ø––vøWw³Ì÷SÆ÷Á÷ †z‹‰}xuo_`\‹bt°Æª÷žµ­Ñº¯²‹͘9ƒ‹ˆ}Š‰÷û@‡…‚Š†|‡|PxLb‹n‰¥Ÿ¢Ž–”²Ÿ×°÷*”¯‹‘™€–|kƒh‰€¥p³W‹ûûû&û((ÅQϺ¶¬§•Pºz©‹©‹£¯›­™È‹v øC•––÷p ¨ Æ  To ‹ ‹ žŒŽ’ŒŽ™¥Œ ‹ ¥¼w endstream endobj 131 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 714 >> stream xœu‘kHSqÆÿÇmçÌ5¼ìlŽngRa¬ AAtñ¥5­4jeŠvÁœæ0­-×^;ÒªF*¦µ‹9Ê ;Qº[Fäé*j]( ÞPgÔ§¢÷åýôÀïyy†(cÃ0I™Y9e¥¶ÔâÒ= æ›sŠwUî-¨ˆ*æF"h UÞŒ”èÞ&¾ˆ’@¢£*¯Ø™SJH6Ù@2ÈB²Ž°2(É1òYÉ„böcWÜϘ9"¡¹N„©¤G7Œ,æ¡ÞÈ'„[ÐnÀYsßPåö‚ÛNáÇ¢iu*+×­à>Þâ€:¨Rÿ8™nåP'¢Î¡’Ò1óÚ»_5j¾½Â9&ªO¢Óòr·äïõx«<Ïñz_ÇåŽÞÉwzÖÒxSÜOÆÿˆ€„ýʲ?Æ8#o '‡•†{–Î­Û ì«+ç–÷Ð%Q÷>™hßo×+ðŽ‰Ò"ÌɃͨƒêƒ¶B•Çãoëdþ1Ê—°<À|DòuŠðŒpÄp}wïªyÉ…”ff[Ðñ¿ãAiö7c_7ºÅ&p6 µõ5aŸzGwu§×ßvMfÇ eûè“t¨Ç)ïpŠÍF>q„ í5P{ ¡þShȯª(+Ô߯{âh?zË)y\ÈmWóß?uÜí˜4ž2D— tÄú1f¶²Ýâ(ôÈ; ݵdFß× ^¸PÜZvÈ‚LhpUz– ¢ö!¨?Ÿ ¹MôR8Åitª°},|Çòc82Råˆ+6Eßl–®F+Ê/þ}F~(2$·ÖÌ ÚŸQEêÖ¢¼r¡úýR±VÁæBÛzµó+Ë¡Ëÿ þOÝÅ*^J·Ïµ[(Ћkd)^ÄÄÿJª¸#î°å4no;ãf% Θ h”Ë´± Õ€vB—ØÔx¢©Ñå:ÛN«­Ž_oe7endstream endobj 132 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 7891 >> stream xœ­zxWÖöȲ5CÂ2½Cè%¥†ÞM/6¶16Ȗu$¹÷*wÆÆ6Ʀ÷z„$@b ›PrG\ûÿwd`Ù ›Ýÿñøy,fNyÏ{Þs®%”¥%‘H¬—.[íãåè=nìèÕ.®AžŽþâ»}±á•Úg¥ÐÙò@ßa­Öèz4²Û…îù§²›í=Çg®ï¦y~ŸøÏX¸0hQðâÇ%¡NKÃœ—…o_î²bÇJW·Õ;íÜ×x¬õ\çµ~\¯ñš 'õ˜<¥ÿÔiÙÏÝ}ØÌám­#ûŽú`´|ÌØ>œdBQ¨Ô@j%5ˆZE}L ¦VSC(;j(µ†F­¥†Së¨Ôzj$µšC¢6Rs©ÑÔ&j5†ÚL}B}HͧÆR ¨qÔBj5ZLM¤–P“¨¥Ôdj5…ZNM¥¬©dŠ¥©ž”œêEiC)( Ê–êMõ¡¢)Žb¨j'ÕêGu¤¾£.R)/ª åMu¥|¨nTIGI'j eI…Q/%ñ’‡[-KçH÷Z°,´êd¥•}$ûœDŸb3¡ÌO;öèXÑiUgEgc‹.¹]L]Ó»>éÞÍÔ}{÷=ô(°Ö±ØK=‡õü^¾D~ª—K¯{6}lôŠéŠ¿Ù.´Ýjû¥í«Þ†Þú4õÛ÷ð>pøà1Çæî(‡)ý•{ûMè—Ö@ÿ˜¶ œ0ðò Žƒò5 :7è‡ÁNC¸!¯P]WSðh#/l ‘˜{ñaô ˆJWÕaO“•"179="@£NŒÂÎm?*Â68G®Õ2žô/Dk¬xz£E¥A—¥Ó+"+²x´.I¯†$[/;ðå<éÃ5Ø î‰2å8H†,Ñ-«®ÿÇb¤^°âUFkdq¹\µak„Ú^<½üA»‹Av4ÜÞ³!ªÐ½dÌ-Û|–1¿ÑìUÜ_eåI_ËHؤĥ´½ ’§ +² Z¨‚J´”fk~½~úÒÅ쵫9õÎUâ³Ï¬%ÏFWŒ¨‰·FÊ»èì“9ÏmØ&%Z"‡Ó¾ÂÒœ'ÅW/Á—̃ïà^\›…g¹ì¦^åªl+§]“Uá<…¾26Ù>lý«wG÷äK6MÁRFZY>ý‡ºËØ›Oê'¯S–ã»òyë§ âpÙ–äô:%ªD+iÖòY˘…Ê®‚FU!Œ5Jªï¢]w¥‚r—£žC_â.¸Ç,Á=°üב¨êòóSÄrS3äà kƒ‚ì¼7Â6p(õ=è¿ÎC4ÁÉòýU•î…ý°/¨r[å6X. ñ÷úT*ˆ7æ%§_¾»¤¦Ñ(JžéÑ*PÇj¹x<°ß4,f9Þ°CÇÑúÝ瑤u,R¢ÔG&˜0”*Q,]骤$ˆ‰ç6ÎÞÑ°áèH°Å+ð$<oÃÎh2‡–£)O‘1Êöãu<elù¨ ë—WQÁ]¶»P„<åˆñ [Îpt á®Ðì™2ÛÙ¥¤Ù—‹*”0(€f{«9Rs¬Ïó°•h‰s_ v #tRá *‘ûËâ±2t4^F 9U&(„WéÙäëé¶jáÚÖÈT8ȪB–Ž¬v}‹¦’Ž“µÙ¶áh!Þ6<J9ÁQFn¿'`2Ix âîyŽ¢ŸKMëQ«­Æ}Ð8<óýౡéˆCÃÐJåÐ^€¥¡+\7…ø®^5˜!í öÐf=—]€«AÇæí[™9 fˆÙìvîMTGTHvßEW¥B9^'%áLí26ºÚéâÇ$9Ì€¸îñdb®5ï«1*ñ‚w‚k剾‘ƒG˜OP@t”‡ï`æ,oE4êtíî—ß´L\'†®F,TtŽ¿Ï£)Äɾ­hSYa¨šú¡lG<&pžEâhûß%é'Ù“•¨È_6Iå9‚‡^—…\†FCÕš¬d*d>(ȪíÜÛø”¾Ï—$²’$þ-E¼¼òò¾ ÛO „òZÏšms\n‹â…HÊ÷ÑÌ°Á^-LÏNÎnP¢14;ìYKë×ézÐê96$üŸÒHcQEN-GÕ=Ä£ƒ„ú¶:·Þnõ¯@+lØFáwa³ÜlìÁ?+cu†ú[ÐÔ§Aƒ†áÝivõ(È­W"í}ú§¬7˜ë>’›„ÒdìðöPt–¡PaW€9’V‰ÖRõÅBÿbëºÃÈépàav*jC=åpÂkWLŽ{íö Ç »ì…¹p–©¯l¾,RÇyê9]\60¹Z¬üÙ\ ‰ÉÍi’bã’4.ÕNIRÓÕe¡[OU²Ö¯ZýEÃÞ0&݉˜Û{ƒ›óŒ)®g¾ å4¹Ú”X`¢!!L‰t8$d§êtÅÅœ^ú¢âýŽ´¥¤胟}Ap!í~ˆ Šâ…Áf^™Ü*5 D‚BÜUã “ÁÕ`ëYK?4¨v(—Ðسq>‹ñ¦z3Ál¬;÷û£qxh ÷'üâQ»öä0áåx2±#šˆ' Õ7¾©üt·27h¯s60™‘¯Ds覔ÔË$‡’„ï)Uú8Åóhiˆõ¯WI{“ ¾Bß¡îò3þkèÙ^.;£Bñh Š­b¢¿L;Í«ßð$&ˆfùïp wû!¦ázõõK\{¼À£Ýíà?NüÜÖ‹ ÿ"¢J(§ôÙ7¹r^榙 .ä5 Ü Œg9mF ŽÆÇQôŸ_ówZÕ¾$½r|õG¯ŸòÑqœÿþkÚIVeTñ‡y´÷lyÛL››é'ñéG”Ñì><ôïe2Ÿž¸yÁœ)I‡ŽslgôÍ6·z 4ã•x=Æ¢Q§÷W_¨áÆÑ$ª;û¾¡¸¾­Rt¿ïGO×¼öÞ}›«=›NüÚÓÍžUÒ· ¯=Ó¨¦s~¢Õ·‰ÍMpûµÕ„IJ‚…yI±%R…A8ÉÞÚ@˜hPxÒÚì@…¸ä¤$Õ`œ¡À–¨V )¶•MPÄ”I4¾à¬óÒÛzÒ!Eë‰a¤H‹Ò'æ¹23% Ù [ŠÌ²Â}Wtâ#%ßSAF@–k‘eQæ­›‘ådù3!–‚‹©Ÿ]¹Æ&€ ný¢Ý”m[è7Ú­ãØjX®gvÐñœ]• >%>Jv^ÐÎ(% ³¯¯hýåƵ¯²9]èa7#¬¤›óà"×Þ{‰£>Ÿ—™fKMvfWƒˆ«A0FtµAk oPCrbôXœ©†j“r´zHµ­j‚âé@x·;ÚÉYÑ©êl¯ôÐI8Q1 •$æ'¦¼¹–De auú(ähr<5þ]‘eˆ#¢OKÍû5(~Á)*ñ-Û\0ˆQꀾUåsëI”ˆ1†ó¨àáa£uíMä|õ)žh!¤U~Úߎ^å¯V¹'HåÐZ Éµq{ÓÆ‚ÍÀL›¿e‘WIxeuQIeNbÝV²ªþHv-0GÎl¯ÜAoÐ|¢Yê5k§ÿzp`XÕGOü/^9¸÷P1ÇÎqN©r<Ô§ô|Þ·Jüñ19«5w§ý&§ú£§Zî¢ii$„ÒçÞŸ)Àz-§xíÇèZˆfgdœ8ö­Î–§ý4àKÒjØIPHïÕ¦BDÄÆÆ'à+ø¸]ÿÿ,Ź4bZ„KÓâ2£!ÆÖk;Q žt}»Èm6ðæ† ¼uŽ ³a5B.1™]¹Âô5¸7š­ØµgÏ‘òJ¾¡9ÿŽ!f'{iýÀ Öé£uÄl¶_irFtDobxt¢zÙ ÅŒŸã²H–Ól!??³DÇ°¹$Ó”&¶è|EX\öЊgX®Ø²’·¬Þ¼jer0;Uêy]%ü¨QçÏ 2$äæ÷cMÝù/¾ªÈPåFÔÅÅEújVCz&e¨‚&í®dÛ7¬r¾}jD;ZHû]té‰v;ôZ» †e3¶m ‹àÐ5º]º™©¥í‡ ºáB~`ËÆ/ÁöFÓÉaGò oû`O÷µÀ°;ìÁµ< ‘È51ȉ†bÐe4>•Q Á¯Ü¥ÒÉ°œ˜®&+Êaüë–Œ/ ·ÍÂC58Šèãy~2vl»hÚE¹:^ÆÓ¸Ž§>ÛaÆë ³7þY…É^Ë)GcÑ=0 ¼uñ=2ü‘xmA8™KbµÉ‰1C°V¥È˜”•œB*¯²Šÿ‰‡òÜЈ6‰ÂeПùKÀ–½™„ÒŠø” #0•¡!AÑ^ö-®G/6Ÿ9SΡyÂÌÊ‹Çt@â/9â'6²ºÇf‰·þ±T˜€:ɳbAC8QÌyY³˜uö¡IhÊ–™µ®õJ'Ú ¢¿¢êÊ’Â]ŸÏlú îñ!¦pwÜóÙ0‚ÝÞµ¨s–XT™ü›¢êWò«Qì·ÒWÒ÷ô5mçØK8gÔOlñŒ·RHCû–A¢ìê`@D½>U)…Ôÿc‘Jðk› †Œ”l¤5uQèÚ®ËÞZ£ásÒšà3h;ƒè9T=ÉD$t ƒÑ ’é8Ü1Ø3DÇt”!^蜙m&½Üxãð "Õ'©žöKq#² E&õm]âT ‰¶Qé$=è®ìïò4NT‹Í’„¶øŠ ë"”¿é•Â¯4[ð ±'íÝ°­r­øèñ³O‡!Ù¥»k+”‹HQ!¹%„A²*œa›6{ÙmëCÀ]°Ç¯Ysš¡Q®æ@)¿§î$ÔCK$oŸN¬ c̪¢Òª…iÕDR´÷ŸÜAäï°ÅWÙ6“Æ/…‚¸­.”Äû/ž5²|(ÑækË4:-„2mÅÿ"î…tj¢N›¢Fµ=QdÆè´éÀäAz±R8BWÁ¡Ü[€y•¢9æÙ3îÊk„Åëã’Õñɜ۠q ÁyW`£×a¸ ª• PúlíRẇƒÈÏÞ¿ óB×HZ¬\„lå8V–††ß«Ø Ì‹,Üg»²¿ƒ*MS+D™èðBjrAåhIæÅÅx'b'¢îÆà±h>ZŒF¢ Èž”'ÇEøƒ)ŽÄ½¿Gy( ùüî4pÎÍ÷z}€&ÞË0Jå•Ç¤Èdê&oÜQ·î“Éëús˜žîyßü“‰à+$ãqÄÐß>¼ß ù\LRX4ø3!U5ù%åÜÛùgO%ºÈ[׿€û†Èî… û»ÉRPËŸûÀá—ñþE‰C3hÔQß>WêµHeNàXwÌ¡²öù¨U†&@ÿMâ^;•¡Õg””!(‹)³F¾"7ûʆ¥UB˜0L^S»=ÄAíäȱXUçèhê3fþü¿8]*‚•Ñ‘aîàž¹.|ÈŠpmàÌÌ}¶uE=v«>ê؆jn]õ*XNHm$è6â©öiœN êì×*Újñ´Ú˜ÎmµWSóxBmÒ)úO=1ç–¯2;éX̵ðª„] Õ;Jý²ÜÁ™·qîGÖq«Nj.i´Yñ y3§n1Ï©é:}v:`H©;Áï¼äÚJº@‡ož" e;U_ð½`Œóãc¿/"¡ùíØ(T4%†äf¦›~´}ܤ%‰ëÇ委äASVâãâ·þ´Ï™¯.\zı=M,ß"¢ôIü—£u¼¤¡e´¢Œ ©i¶°A*n,Ô¼QÊC“òëÐH(‚JÈJ.M2);!jçì)k6üÉë4œ8Ó o·ØI²óŠR²õUD\¯ç»çáIo§È„~bÕ¼¼òÕ•&âÝ]!ƒ$~Ë Ì¢ ­>1è­”ëç²2.kÑ—ŠÂÓ[ >D//ÓG‰Â³X›¥‚h‰Š!z¹?îªi¶þýu%1 ‹·uõ‚¾têfÿ;³ O åÌb²j´5DLšâ‚xá¨}~žÖú‚Ûî:jp§·í?§ñ€Ú‚;V ÕœÐãßhõ.4îLîŠè‡? Y!g(LØË t0w9ùëÑAä) K#ÃÒ¾'û›¸¹‰æÿö3o}ô·§¿Á#ö•°Í!‚6Ñ+Á!62!~)P/”½|Æ"îÜIxn‹dã¾Á]±ÕìÇÛCa}NseX¥[|2h5\Ùå“gy´ï£iJö2|¼qúšex vW¨DµÀ´¬]p=@Í”Œš¥Â.!¿½øòôé‹OŸ~yñíÛ—/ßæˆqAÕ×É<0¨ uüùB…y ä%¶¢™r¸³ôÖÀÒ;Ug¯Ámæ΄Ó#‡Ì\1ÓÝZ×kŽnHŽ?r%·˜æSAãb’Wù9(½6ïÔøkãµÉ ¯MÐB,£J‡Bn¿ìNã‚á¸ï|o‡m³ ?uSÖ'òFØÃ4ø–xxD9Œýa’ ®ý™ózóBIȉëâYÈ49?TØLŸ§·‚ø\ÛN+OTB‰ÐaŸ—®7¤¥pÙ'¿…ãP±5#¬`‡~;QÕn°"À1`û¿­¤nWŸÿ”agÍÒ Úì>u…ååáîQn [•l©bÒÕÈ1¿ü„X#Oá»—´Ôˆf¥ÈI¸/?p`›[˜¯Ÿ_¡oCI^Vi¸z½Ž˜ú¨$„¹K—)cb84LBjRjöݯQG­ëõß|ÍIa@ÙÝG{+¬[¢Ù}Ú°m3Ûäˆÿ–.رasWN]Ó½áXy‹z§‘‹t{ÏòHcÁ®Ì¦s‡§âž¸¤üp bæý dO!éE å86ÃÆpW¯[I ^ ^çÔùa‡à(bnÕ>Xp–ñ\ÑØ›ÄMážû7k Væ؆™rœ$Ã]!97©˜ñ—¹c'Òl ™ssÒÓnA.‘Î2l‰ÇÃ}ܱÛÆ‚ýÁƒp ‹;FÃ)錓)ey÷÷_@}ÐjE¦¸V+e^·ñ5¦Ñò:ß"??ß0w®©m³.RŸ¶Y`HÕ2Mx¬¼& ÜÛ; ÀÛ»< ¦¦¼¼¦=\¦n’–£¥G‘æ¨X\ÓåР:àÒZ‘µdïGŽÃæñø3c‡~4{L˜Þ¾e —Óè_¾Ê{’ cúÿ²ð7dõãÝß¹yè9¬Þ¾y…îþb뮤ÝPÈœ¿ÜrýÆ¥õs¹Ò6¹|ö¬õÓ&ͽp÷lí¥ïq¨ÛŒêÐC^°ÜÖlGÃã{e+à1W±GL^éCÔ$ïù bÔ92búóñk6…Ùoãœìaƒ{|?Yžon9[ÆyÐ8zàÖUákõ»}¹ý5…|@~P„WÜö…'¾Cr2VôEÊ˧îAæUlÏ‹apŽÀI8TÚXutOn=‘5u; í–¡rñ!Âoá¬<Ãišõ¯q:Râ)Nõ'Ç8¬• ÚäåÁe¾žaþAþ¥U|QE‡æ÷úÃ{ïž ÉÖµ7SˆMsͧÁ'þ·¨wÎfÍúçÕ?°¨þ‚ä?tÄLË‚Ñ•½è á «½" Úi×¢:Y‡„@(ù­×ÑQoJ‘ßdQZRÅyªCµôk*xû—+ˆmmO¦Ñà+@F‹Sæ%bûh!¥±u\„V,*Ûdm2D‰ëCd%cÛžÝß{aWCl` 甬öƽ2º¸¬¬`קkZfÁ6` ‡eÿ¸¹’ôïŠü&OLvRâ²XÌ…gµsÔ" :ù¥€fç7•Ÿ—–•Íé§û,wØ¢Vkµd楜۷ͽëVdvË•8õä§þF»ª“@«KÒÛzä9‘±•€%v•ÿÎ\×øÌÊ]˜%Çîb0ºÿðõÁ/9v{&TAu\\RD,øAXFd¡Zì»ËÖRhÅYI6*’¢´B~­EµYi Iââ(í¶¤ úm“6wïoÄF“Â(iº‹2îJ…m膾IüÆíË­?M+p„0ÇÏiŒÇüÄð1ÌJ×tàýKMS#Єˆ£¿Zç_§‰†8ˆa0w"+úÉ–ËGªC{g Eìã:£ÄŒ ò_j:ðÒ·kÄ·cÜÖŒñ?Eø„ÕΑa\`½cÉF`FãîÿøùJ0õ‘oOŽ €ʉ(Jdp/qôóMŸ–×'úTq]ƒŒÂÜBäf”ñ¯vâ:Z®ñéÜ:w„ÎŒ:½ØÉÓõzÃùΡ³5Eý_°‰Á_endstream endobj 133 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2449 >> stream xœm–{TgÆ'f¥*™F@»mñ²U·‚¶ÞÎzAEQ,{@Ôj¹u#¶ Hƒ ’(N’7á\Ãu¼Ö‚w^z±ÕÝUºKÛ­ô‚[k×Úwèg;ˆžž=§™?rNf¾y¿çy~ï÷FAyzP …Â7|MdjrBÊk3"7o1è¶ ý8HþàA‹ø(ÁÇóä #©Píûùèž1ÔÐglʆåÛ «³´›×Ïšýꔩœ>“¢"¨yÔd*ŠZGM£B¨ÔFj9J½J©(ŽzžRSc)–ò¦FPÏQ¾”Ÿ\Ÿò¤ÅJÅu6åóÊ:å/ž^/y•ÐOÿÉb>fìioÆ;Ò»Èû!¶ŒzìQ?@ˆ?‰n¾Ø‡3û Ïk¤ÇŠL¨ŽkPÏ|utò¬µ1›Røïî:yÅä¥e>)Ù½QCŠ˜x3„òZ¦ØñqþI8 ZKí쳕Ëîz|wôÊG{Öð$ýwõXi “· µ‹M¢bðÎXÑÀ¬†%Yàþ87é¾XÞ"£µjíZØ‹óV˱W`˜¬‚ÅDüÈ\ò2FæÛPPÙPÑÊ‹ 6A¸Sï ÐÖ1@¥e:&‘zĔÔ-oO±h1_tˆp®[÷m>Þal€J(Í/()ù˜àa$Óe Œc¢]®ÁïÃU[“-@l’È.ºDÌ’¿U¸èÌêÀyB‡—a¬ÀýêDZOþ”B"% éà:¬ARÌý}¦é íúÉ<¡0‹> ®._¥¹5·öMûÉd¶ƒÖaŽ×¯~ÚFú3ÈMÒ²¹1.bÖ•:Þþ_šë Ó~'ÄçßœuO|¨”}00\øb{i«'2ðíûýwœ‹ FV_³½©©¦¦‰¦Çì†n¼Ñý„žÙ}‚LOàz–[Š»4xᦒ׆ŠqG‡Ë-`f†¯]8]8&Kü'3|¯,Ñ™ ¬€¸“I©ÝÂ1`¹•WálCÛE–³Î“Õyè}© ÷{HKÉ¢ê6Ò׆»r1éø ¿ZNz¼°–8ÖçhEæ·jE3Ü­±Ñ;#œ'ø#Íp€íLޯߞhŒYÔyŸç<¸‚”FÚÀ/…O†ýuœ¬HLzέ:÷îî»-G¸SºÕ¯>Ÿ¸Ž1C¬V 'Ky|‹ùvúy⹉ŒØ3G_m8|h]cõ®}Y.¾¥ªJýô|Â"Mc[` I {7<V²œ)øaÚíÏ»uÖñܲõÅ-ï¶/ø4dã5WñR`öÖè -ÝÎÝÄ׋†6ócç°¤«O˜òãôƒ¡OPÊ%Ïé&’0%Å0JR5Óåwù‘^'„@4YþÚFf•òßPÑJ_y¹ËD‘x÷i·dUýö~?îôƒô‚ìãn{‚Ui™Ÿ;Ôcí¶"!WØ%ì"ÞÄìOÔXe-´Aq@]ì“{Ì`[fÛÙr›msÊ+.C‰°w+.%’Úú´õï¬Xd@VËÝ/+¬*¯×”Y–ž‘¼©ëí‹wNÑ\%û)Í9ÔÓå¨u<£Ê J´ãDm·J#à ½~\„ôë3²¤» w‚ÿ†q'nÜ-{2Œ˜BTd *'ãøž3uGŽkÖ0Ü ä=!¬ÙÛYî`ÄÆUBæø· nï;¢NÜ}N²¸ Ç•·µv›âD¾rØ S>›<^\E™Û.»‘jÆ`·âýl¿©”ôQÚÊvmy¹Ÿ¼dqf ¬…7RÛOÁ‡ÐÄb/]ç‚ú[ñ8’Ì'&M >D…L NÄÀÓHÕiBð5i¥ËpÜ7õGÕPLÔŽ”¡Ã01fè0¼ ÚhE•¤–C3xNŠP†º?†6¯º ÃÄ œ&÷È„Zhùå.Àœ>îQ©œµq"«¥» îÁYùº]+Æ2¡¢E#•2ܨ‡Òº–ã(mÚñ8:sªÈJv¹|xm»¿TJαb<ødå)¦Y€d>lõ$ØrвԞƒì#çPÅ@>^KŸ/¸ äë6œž½¬¿Aꎨ¸–ÞWJm!lË1‡í4íΛ9r`4>ÿ µéεÃÍÍÍGOç,ú¯›dQ½6cÃñ¼²†CÕíuFwàôåÎëÀþtáÏó—½²|µ†˜I²Ùl·ƒ.@ZAWÍh¿Š jZ’Úþt¶E5ð0ý!Î@¥7Š’Nà5ÜŒºEF6÷6^»ÿb?›Ñ#çã=/¾%·¦±©ºí°¡Z_ÀŸ:ó5”{úZú\ çKÁZÝ´)y,÷¥Éž¥·YÆ›í&;ìd³Ëä.¸Dq1rñÛ¢,º« ö6Ê ´¦HÒ'ïH˜ŠQÈáÔ{÷øg.£¯(é¶+$ªO)]ƹj‘xK¯3 x[–ÍškáÉb¼´xmÁP÷ÎáS´´> stream xœûÿLMRoman5-Regular‹‹ú!ù`‹ ‹ ¸÷`ÊÇÄA"ˆ÷¬ÿÔ’‹·‹·÷·øUwú!·qM‹|‘¦û¡øùƒˆ“s‹y‹ƒ‡‚wû–üáuYU‚Y‹_°ŽµŒ°‹˜‹ÒŠ¹ˆ·`Sw¤ž‘ŽŽ“¿÷ ÷ÕÈû ‘‹ˆ‹‹sR‹n _÷6û6÷›û¯÷!÷Öu¡øCœ÷n–‘¡· õ  To ‹ ‹ ªŽŒŽŒŽ“ŽŒ‘Ç ‹ ŒŽežendstream endobj 135 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2535 >> stream xœ}Vy\T×~Ã0sˆ <†EìhU¢Æ@[mâBˆË¯pCp,ʦÀ (3œaÂ6¬AÙãs‰KŒ5ÚD±Ú$µhMmBHìyöÒŸ}#˜¥i;ï7ÿÜóÞ¹ç|ßù¾{eŒ£#“ÉÜÂE$nÛð|дĭ1ö¥ñ@5ã–*ÀE.ŽÇƲ¹ã¸±u{g cÿy¿’˜”²}GjÚÝÆŒM±Ú-ñ[·­z~æ\_†ù%³” g–1Ë™ÌJf¬f^eÖ0ó˜Ìï˜P&ŒYÄ,ff2îŒã'sf|¤"GfsY¶QvÆ!ΡG>Jþ{ù?S¿QlU|¤ŒPö©'²ÑNN¡NWœÃ¿Å#®å±I 8Iץ˽ï)L!´ô‘"§)v‚O"äîË Æ¡¯¼óvés盦Q¢“©ÎÁQ½@à(W—ÄÑ ´(/ÐIŠg5ÊÓ—Ð ]p¬z–ÞÄ}*ªS¢[®ây]"g“µ¡šÑC.vb‚ ÇÐtfÐDêCÇÜ À—qÖtã©Ç!Õt  å(ÈÜyNUµó5G{,' z2ë´–-°¢X×ÇYwºR@ö »„ø.÷‡¨ô  ic7ôðâXF|€ÛUètŸN^¹5c‚p¥ Ÿ«Ð‹fˆUhº›Ð]¯àbÂ…äh{ûötûâ”o>CµšzxRÿù«BwkàÌ:>§ŒPâ–pþ9Pc4VTtu¿URì{çSwµëcÙ­*;º‚æ¬T蚉®^Ü3âbÑQuzE˪ù›V‡íàQA¸ëô¥‘:bÔôâpp lÌÓñUrµ]¿Ý΄mé--m–.^J¾’Ék‹·‰¾mî×0ûš§_D?ô¦[µoÄ´Ä—Ì.3‡½xjnt$,ßÏwó-À6ÀþzõG¤J3  ‹á“˵%›€ÝFŸ굩6©v§ºKÛ‘ws·-ïF,eƒ!Õ?ùzo6Ÿ_‘»Ýy;ÔTFt°·Ú\¯[xNßTu,þ-¨ŸV|p’ƒ·f2y]øXÀeéÔè,xqDw£:­‰$ ã·'†Ã¥z[¤9¤“p™†¬yæ=»YÂåÚ¬ô»“zíOo¾}&:ï4œ•¡}¦¢Q)©§@íƒNµÈúÚ0.#¿\2Gßx†Çû?‰ì&~§~ÕôÜ:ÆÏ&RÖuLUš8Q5‰§äâMÑ_%CBa ™¼5¤¦EŸ `Èߣ¦,5Q›g%£§J“Bs‰à«C.e)åP>UpÐtЂ/¡è]RQl¾¬«x.϶MÀ%‡qšÍ½0•^œF<Ù ªÏ‚,~±Qú°žÅxòé¼Ëtru-xq½U×ÜÚfé9¬«Òño”´Ë€½aÝ0W½…ÌÓSó^ Y.g*ŽÉ¸ò‘ÐÝSÇsÁ[aí·üqem4¨éZ$*îÈÔÀ¬”ÈMÖ>dð…Š“&~¸Ui&YxA.~â)Ì#tFIey–W”˜ÿ’®õ¤¾H”Êöä¡ `Æ4ïÉH]RÛ£õÔA _#Dè Ø©Û Qà£!_˜%é Ýþ€"óõ”¡õTÄH¾ábRŒðg=l~vD£8ƮϤyN»O'†¬NHßÎã1ò½8cÔCRYSU]YÃr—sœXñ©/NQ%h`yrLÂƵ9ñ0bÎìyÅbÒl=ÞrXt:z¾z¸uª±‰ç¥Þ‘ ÉSª·¶=¥ÈVçgSB %žëÿƒç%Cþ;¢R£âΟÝ`0æšJ‹ë+ÀÊÙÞ°%1A)l¼póüÅ·›yŒך+LÒøH*x<^RèÖåÞ€c+pìó8Ö‹»'¦ “ªb7ìÉ(4dåóÉaQºH`©0àØ9@OTY«ôúr5·<#Ó¶wÜÓ¹è§lI8ÏYèÂW¤RYêsÿY|sY³½S7•]taGð¥'fÛð%º|)÷J{Uë §!?3O‹Šˆ•öò/DŸSj<«¬;Í­y×WŸTÇÙVV/BÓ§O c鸯§à¯ñ…Þ‡UêgqœŠæ*‹:=–#M]]e-€NPD½ŒÚA”KäÚ-ï©B½¸ëv.À2ò݊΀©‘ᱩ|!ÞSr~LðÉŸ¸o,AYÿ‰wÛ-isyZ?’æG67ù©¥þƒÜ?‘FÐ/®;=…EbáÞ¦!öœïüम&ç}EPõj­ÑÑZmt´UÛÛkµöþ ‡/ήpÕˆOc¸=c½xÛSØI¢A_œUIgãfoô¨8Tj~Ï®.XŸ”ɾœ%v©p‹ëÁ¤?KÃédoq­t²ü¬5Ž~ÒGZê”ÔV PwïÒìÊtг{3$ÐÃEwŒûÁí…íöi³â§OÀdíEÅc| wågùÝìøÈO­øþÈy‚ÿ†á¿wâŸ/s0Ù=!hÕêµÉ|ú½@S,L‡ˆuñaRzÂ}Lƒv ýˆ;'.¶×¥Ïùžÿ’Jql¼Ë”§=òd ãwÈí—!NÒZR¡Ö°bal6±ÒÇ¡%‡-ó¦óÅuŠ¿ ÊXý4ˆ†˜Zé~ÒíOÇÓïþW÷ýKV’Y¼§|¡ø`I%†ˆ+½1dhåOW3ÅûÞ%UÆ¢VSm‘*í¾ünžp)]†Ù8J’‡§@ýÄë¤&ç`ß^~NÄH6]S«¬„³ÆwjØ¡ ªÖ>ÓC8!=¡OoÏ“Ó‹â¸NÙñþËýØ/ëq‰Jº³ÌÖ¼qÕÖÚçÙo‚Þ¤Jªž?kêúê°[ëùqë#à–ŽF&U8ýã»èÀûáu¬IÞ²>N¹íYšXíìÕÏÌ]·On\È[†F©fLËŒ˜qêÖ­Ó½ÖZ1·/åhDIã -]1‚>OCŽiµÉ.áØ^ášý–•"¾¯B]qT½$쵨£™m­uÝBt¹ÁÈ7Õt—ö cŒf}nfzºzQhâecI*ä×7@IßL`ðÞ:êjËŽ7û,8´ç¿j©æÃᣓl²£è¶™è&”%>RõÆõÍÖ†çoÓð¬Ë UòWú«Xê¬ÖÜ ƒÃó‹nOæiã†W~|D'º $·‹«–ð»rru c£­º¦Ãm–nž^íVé I» všÓª³Yºõïäö;>o­Ë+8Ļ旖â:ËÁCJÁ•£xgÇå‰.Nàâ .£Ž˜LFcQ±Ñln¿àâ.î óo³ú¢endstream endobj 136 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2038 >> stream xœeTkpç]YF,ÄÃD4MvPIa†Ìth †2å•lL åac[6²±ä‡d[o­V¾ÒêéÕYöú_ ›—CˆM“:LÒ&ÓLR&PJÚL;™1ßšõ4]9éL;ý±ûãû¾¹çÜsϹ,5“H$ϼ‘] -Ý¥-¨(;þòúuûŠOÔTT'¯~Z.0³ÖYËH“BZêågqïr”±ì¯Kÿ˜‘¼Æ‹«4e•j Öª«Nm/¨/.9‘µeÓÆÍ/`Ø^,Û‡­Æ¶aùØvl¶{#±%ØR,CâÀ2Dh,»!±§d¦<–FR÷¥ÞZP.K—‘ É/|fa΢ÁôïSda&Ž_ÇIГÉè‡Rþc´BÞbÚ t#EÔíPå\okéè v92>~¥À-ü£c#¯½|ðu­ž Þ+ì? ‡¡¾È¬k(kÊn´¸\œˆM·]IÞÆTµ´Éð6™+4Ðv-PJ]Ä µÚü„Ëóuq>ÎÇy;Â×Ñþñ¿|øå`‰*û ðtÃ1Ò¢m6‚ ÿípéØ£³hU€Hÿ^‚21á­~´vž>¿á®”7 aù£}S¯ä:Q¤"Ìïk/™gfÑéÊ {þf±ˆµXK›zRH˵–9mGAi4A½Õëôô1ÐKÂ=¸7 m¬šòÁ ]D¿ôw‘auoéuÀŽ–¡Uh5),²äe¿9¤*|—áK€‡ ‘WÑOOokT9Üßç>ÒYš“£êŠI±‹ëeÿÕÅÈ´”ZØ&‰@~·Ï$Á/ðÐ>›éøqµž¨y·èt9àÂbo°òʼnìOÞ9ß™HG„ÖJ«#¯Yi0C€)<0ÌÀ 9 zð‡H ÏÈÁ¾_¨¤•y¯ç¾×ñYìJ’Ä.’ýŸÞ¸xðßG6ÚDj)Öt úÑX?’ÌVðZyz•é¡ ”sYˆa Bül/èà¤t¤ ˜ë69­Y Ô‹CÀHÁ éÁÄvHÚå-Ô€XÅ­fh„ à‰þ¹—ý!Р¶Ñv’tRÍvÜêsøZ€iõ7ÑI†70Jp²fs3Õà j7ku_/ûùƒÃ.Ï%P"… -íPmÑ‚ƒ®"pŠc§[uùânÑ6)¡Ÿ›úÝ›M4¡ß­Ë)¼ŠînãÜöÉ=H L¯ëQÆŒ-zMcM MèΪ{ŽˆX$d«…Uënîú¼íšgz’  «®À0ttœˆ%ˆ ™h«<_8@éÀÙ¨WÝ_ØP x~ÓÍó×D¢£dÿÄå³#IÍm·;íÍTRøM‘bø>*¸æ$}ÑG¥¼íG¦§Ãæ$T™;4¢Š†ÄЈL‡Ðs¾îŽ‡w@é…Nh7TRuÕ ÁØún uäFN¤,·ô-­‘¨žz³E øŠ}‚¼:‡ãºÉ¡™©®!ÀãÃ–Ü ýÎ!“lÈ.-8 vqXµá./×½xOM ñdõ©òÃ×ê.M%îø"T’(šü»[HÞ•4óv‘8ªâÐ&N2zÅ¥ü¶ÇrŸÝo§œN«ÈZ#HÀøfËW!Wô69.ëƒOÝ×ÚïœñN@¿T|a» ~þ’ðÚʉ¬oÑŠ¯fBÄ!ÄÈW¿€B¢Pv­ý.Ú øXº,‰øˆÅ„.þ5_ÕVÞoå$ãÑÇ¢\Wg3䣇; ËÞЭ9IØki³FXŽo—Õ')º–œ’m#u/é׿ J‡héúÖQ&˜€(Þ¡ ÕŸR×¹¤¹psdâ\+1ðAZâòO¢;Š{²¶–ù= '%cßov²ï{Ú#Ó¾P0‹¶ƒº!®;ê0—B#®m5Æ»û¸sÉ]õŸ¤úó=Ž“|rWŠævÊ‘”ÏqùÜ^ðÏ›Ë\e;áÍUÚ}\ôL4W¦ð³5·sîNŒ±-¤«Y%(–²5σ²T®Êà™ Û 1ü´)^US®;^x¶îohÙÝÏ'£Dÿù!!Ï~J[]S¯¬ÕUèÄ‘ç7Þƒ¾¸ç:Ùsõ‘‹€OE6R”h:‡¨¤tÑmìKIgw×ɵy¾9¹¼ø ùü^`•¬%h¢`3s×…ˆ‰²R`T‚1@±/(Â61€³Á û?õÄéAÈê5y箣ˆÂà ¸Éb1Y¼öˆä9Á5'~M6Ê¥)ha7øÃ/>g½/„”¢‚òILØZ‹Þœ‘ ]œuɧªÏ©êª+«ÚN †Âž` Á¸Ý.1sànnzµt¯JEšLóù·y^öOŸ¡EÄ…`FroFŠöËû4jµF£Vwjúú:;ûˆtžtµOë$|άZžìÙf£í4!üã_Ù”AÜ[0O1Ìøc>}ód‹¸V½â¡Xy:«E¹\„CÏŽJø%_È}”ÇNÑÚI4i5%Bà{6D§‡zÇoŸ!›úĤâÝ7¡¿³”)®-uêKHmH‡üö·‰§P9B°V·Óx8ŽÄ÷œÛ!,°¯KT{h2GUž‡ñÝ·öÌ Å{_G‰µhƒ¼Ñæl.÷«ê½vW ºÀÓÜJáé5ÿˆÑINÆ-ž|ŠXœº¿2m¤-†´§8—›a‚îÓWÔ•–iË1ìß›MAÃendstream endobj 137 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 167 >> stream xœcd`ab`dd÷ñõM,É®ÌMÊÏ)6× JM/ÍI,IItwÿ\ò}9k7s7Ë–ï\BÏòŸ`F ^ÆÀÄÈÈ¢ó} ßæš; ßËö05ô‰.)鮕ûóŽ­¶¤»¨xq÷ ùïØf,î^,Ï×8uó„ŸBË7-dÛõ‡[Ž‹9\Ÿ‡³›‡«›‡{ùÄžžÞ©=“&ððtó10­Ú8€endstream endobj 138 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 497 >> stream xœæþLMMathItalic7-Regular‹øÛøM‹ ‹ ¸øKÒÍÉaxBY«f÷¬ÿkª§ø§ÈÜøÏ÷#˜~‹ˆ}Š‡p„[xPa‹q„¡¦œ“¯’¥¡å•°Œ‘”¬‘¥—º‹¡y•{zto…v¬i¥[‹ûûû!û$*ÌFáÁ»ª²³žOÅ¥‹¯‹¤¡ª¡²˜Ä‹û:÷=\ûO„ouwux‚ƒck`‹fg¥ÒÀ¨÷¢³¹Û¾š§‹Ñž?€‡‰„Šˆÿ‡Ñ§µË÷K癧»ì÷êëøÄ÷#˜~‹ˆ}Š†‡vFOWS‹cv¦±¥£æ§÷ŸØ¸¤¬‹‹‹¬‹ }k‚o‹yuœ|¢¢¬žµÃKœcYcjeuy´]©S‹ûKûm~™‹Ž˜Œ˜¤Ùʶ¼‹¬¦y[wY‚iiûijUX‹ˆ‹m‹v™´˜Ž¯‹‘¡zštonsfYÃt¼¹´¨µ¤£VÂy³‹÷È÷§wŸøC••—÷pŸ§ Ó  To ‹ ‹ §ŒŽŒŽ—Œ˜’‘— ‹ ½Üýendstream endobj 139 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 5486 >> stream xœ…XX×Úž¥ÌŽ€Æ‘¢ÿl¢±Ä[°Q"Ø"bCA‘²tØ¥÷C—¾ô¶!¨Ø±ËM²51Æ4IÔ˜h¼×û“îóügÙ¥äÆ›—˜Ý3ç|åýÞïýFDèQ"‘ÈtÃÆAAïÌŸãäéæï.Õ|8) G í¿;"}dbpzÒ$w3È7³±ªq”æµÚ60èКàµRûÐ0‡ð÷H Qû7FØäyÐËÛÉg«¯³ß6ÿ€w,Œ]´xÉ»ÖK—½5cõÛ6»gÍÞ;g®Û¼ù5™ÚL}@m¡¦RNÔ4j+5r¦¶QÛ©™Ôj'eGí¢Þ£æP.Ôj.µ›ZKÍ£ì©÷©u”µr¤Që©ÅÔj µ‘ÚD™Q,5žr£8jeNYP–”5‘2¤FQoPFÔ›Ô Ê„M­¢ÆPc)jeJÙß)*–DKE§õÆéÅêSúúßÜ0\e˜nø‚Λ‰Û–90ÊxÔ>£‰F±F2¾eb=úÑ-cœÇœë6ö«q‹Ç]5aêo6ÞÌËìΪǯßÅ-â²'MHžpÁ<Èü¤Å;QØr©e¢å9KÁê¬VYí·*²úŽŒj‘êŸ*áÍQl~›õ…”•¦Åå¥ä„!£…j‹Ä£ò,ˆbP¢'Ý_c!G¡(%#>%%Å2¨‚IWÖ£–Öä%©û§!,¡ë¦zE ÿ€zT)yIW4¢ ^ ;9lAŸœ ½*g•Ù/jpV›³§…®UŠbx7Ñ¿í<¹b«Od$ϪÛPù~ÞŽŽ‘’íQ™ä4îu¾‚…tÙ]s§Ä ÖÒló‹»G/\* ÚÌãˆâuMšusÖIÈÉ)*øR%º¢†µ¾àþ˜Î}Ž °ÁÜس?Ï=Ðûù˜ñöÜÜ6¶¶ï=ùéæÍÛŸßpœÏ“ °TóTð™ÖüSjxƒ8`!È4[]ðë›»]£ü}xöysF™çŸ,ïWþWË=è.÷“‰mˆÑ/?+±Ÿ0k­ãÚ•ÞÎñwĬٵ«—>¾{Õn?9A®=TC%±? .s°h1ÌÄ–<öܽ\RÛ/¾"Ûƒù#x“ñ¨-x,Öçg òg4ö`KÌH†Ýº«WCÙ»;s­!$%.Âeº Õúx£hOþP³G£b°ÁÔÙ˜ÅãžÎ½ÏÎtÖÕH°Ÿ‹X&EþõH!åtyƒ&ë „ œ“ËÒ¥¶Ž·~||KýàÞéUZ/ Ln0WŸVï!1üCÈìâúÄÚ£Â#x{\ a`.ö@1í¨¶Š¢û.ƃÇæàF³]±ŽDaí¨¦šDª5¥È‡ïEË‚‰Ï[úåÃq$4«w¤ °M20G újô9;_ˆŒ¹ê¸Ö;×GmpæÛÅì—;b=zȳ¯qï²á+(£Ë5Y F2 ÖSš}ëéµg0šÏ ©ˆh@Lmµ¢Iw˜¯æGôR “ˆ»úB¬Â l:lâ‘~¹ïˆÄÍ£& ’à “è×Æbù*gD †Pþ¹ *Uú‚˜r蟘«ñË{¿Ä"0÷ýtŒilkýù›²€à>+:;º1š[%j±5„¤É“3x·7IR½‹–m(²w[ev^ 1„"ÉœÉÜòr’xðßÞö-~kßTdPS_®,ìÌâÑᬬê첬RTˆ˜/.ú¯‘àµéxì.4‹aãí?v|ÙÙ[Ðz–gmükÏe¨¬%Gá•ÿàHë ?Å°¥Ñ^®(iâFöcÝßwÂÔÜ!F0kì .—ÈŸ àbÎ~)$뼟Æãa1Ð0Ãð8]Ö4˜f]¢jQ“ÄvÚêß Éaû¾ Ö5 ã4áx^l¸Ÿf†>‡QÚ„†#É÷0¶5 Ó%•|§9EW?wU`¨ºÌ'˜ûfŽp> YT7ðÓ\þÚZ@¤†Í2&€"õNÈ8E÷ˆ‡Ý^2Œ¾Î~ùÁá+Á„äX©Úfn*a·Ê¬váuÁv™³Vÿ çïaŸØƒ)QÉþ–™tjUbMrÕ\H¶hx=è[i˜ŒÏM@éY"$}7VÊ°ÉÎ^²Lå–JX›†¨J)Ïž<ìÞ¾¿ûÅi°(ΕÀ®ÿä(QõðÎÅuË|þ=ðýœfûŸú`÷qÜ}a>/숕„÷u­sò ÓG Ï÷âÑ#Ôî9­(bçãÉB-§ « ª S*kkÀ¯«Ì.ÞtTŸUƒDíyÓœõüa‡nxˆ+õ8~¨`eå²J ÷Ït–¹Ð}î6•ÏñÏçsŠSªu",´*75: ‰÷èØVâJEßfÅ’ug¾ ‘€ø![®Lù&b‘ÕŽ}¬rÉmÚÏ»7¥È¬Ì¬È¬ôÓ ^l1 xkóËÚ ù㪘¤Å2Ÿ?êÓµ>Â3‡4Ñ8×/Ö’xø nœ`¯!³¡Š„ ýsh<ƒ½yú‘ˆâ²eÙ„b³Q£ ­ ‹äÙÄÕ¿¢.˜ú!˜ÜàÙñY³×IËoŸª“·¾:bИ¨%j»a¢¾–ýò#7Ûѳ+´cL8fìÞÚ³u@KêrìOã·a;Œ±aÇT^A—™»vŸb16Y»ÛÞ·A^­9°,¥(=‡om½­0>;ïå ó>&ñ –fxe8¥É d4XåÏÐlÑó ë¶lÚºaþþUÅgƒ%yyDæ0õ‘ÕÒÐ0™ß‚_¶š0ÿîñM Žð§)bâSRS’ù€ à9²’ cKbK#j|Ð!! CQLLyŒ¢8?/¿€oQ6*ÊPá÷Ò¸ÒØêðvÔ„”ŠºŠêòæZT©kÿ”Jø’»»=½DØ$ÁnmúVÂ+úHòa>ˆA©™±8ÿa‘‹2Pã[˜ÜÊC¦6Žhë†Ëo#P÷urìZ9,¥A / µ±mUÁb•è‘2 XüÁ‰ûmÕ¯ØÈÛ-9̃'H1É×Ҿɉ~\%ŽB¡m•¹yE‡ù¦¶®Ê«$›§í—¯ÙünÐúÑà. ÁkU„ËX» Àôù ¯¥Ðëƒ^¢¬Í.Ý^ó¤}µƒdô¬àÛ8 öa½;¢=\ù2xóéÃG¨)âóRÉ+…3¤2¢±¡º¢¥ÛëòLlEÞ£±+N»ç<û#ˆ~ýLÈh´ØÁé=Çݪ>¡>»•1½×Ïñõ¥u¶šó‹Â…«*Ñ)õâpè pÄßÐ)Š(”„)qבk•’‡ Ûâ >øÂzŒùvTT7óyÐ sÀNu­º2;›œ Cª ö¤ª5Oß4ÏDgkqzÏñšm̓¦ÓÝè ópÉ}lŒMÞ]±ÌéÌ®¯‚yö¶Møúl¬f>Y¦`öøÑ/¼5çœ6ºÙñ컧{.öœûêþ•Ý;$eøgï°Õšg¬zÔª«ÿôøʆMº2YÚ $¤j¨¿¿æ¶9ûŠô&)X_=ëO³&¡¢-½‹+ºNó xÜʳP"òÊ Wäæåå£ ¦>ª:XàW¹†(8 ‚xSpáW~É9os²^¶ýÓ»?Üîùü¤24‚)Óv 0r•³d•˜Š`˜êÃ}Á€ë hôó”úûl n;ÚÐÚÊãkùŒÜyõè©@tC3¯­æPwÐs<µ‰â#içåŠ I©q(–!³©¦¾¤óKçϱQß9Ðöý‘4†÷c½Øõ«‘- ÉǬðg°LìšïQ+»Ÿ[tÕ1ÊŠˆD¯´½ÖWWÏÔôúÖÔ àŠaLÕ…ïÑ-ÇÂœSÑöÑtîÜñÞ"Võ›sh§ëžõñ Š?‰=éŠvj2 ¶3Û8TžœU‚Ç}», GAV?)Š rÉdt8µ:8ïøŸy§cÉîÞV2j6æU Ó‚„ ³Þ¾žÿ" yCð¸Néx#Ï~ßtqØêW/«ÑrfQj¾¤Ay¶àb^óó‹‹Là©ËÑ´Ÿ9€b·å·óbtVqåÉ…fEg3ºÈà¥ý›_++àCµ>¼‚kã½?zŸß~Ǧ'1Ò”ˆ$Yqr^º¬±¨/&zqúA,ÁçËHŒIÊhh†}…Ú§uTÐB~‰NõüÔk W…>à”A(!:%$ðÞ~žñ>DQ3‚Éðöo/ÿ¡<°©N’ž­éÌrÇÅØßZv·ûÙ °½‰ ¯Á“ð8lNôýû0[Â?~{¥Y²¸e®Nûö¸_¿ÿí™Nœ>µe™ÆkÕïSHK—’ŒDl×ñìߧÀ죃–±þ½^쟟Ð΃ÃPGƒú["ˆ¸¥/D“Xtx£8"ja ]‚:¼½‘7¹š‚'‹ãÈ¿Þ¨D“ñ:ywt Ž¦Àdq ùW¢E¿ùÓôáy§:pÌmh€Ÿg³ôH~AVv/Û¸'&.-!=*•ð´¬<º¢íåeÐa¿œäã#wî÷õ:Aé0BAÍþ÷<{ĵÃÐ3ù‚÷é·éaSoÓÿaš¦({ÿZ“y»\³ ¶øÛ]„ƒ¿Oç*eaɲØB”ÿ¶OŽÉD(É2ª<ºº¶ ¼4Ÿ‡o~·/Pd!tØrPߋΫáÉM \å`ÓT0ÇzØ`:!lG¼é%6=0xVàÈÛsx†#6Z¹ÒŒ`LS?¿{çÖÛx:?&¾Xx¯VçÓ*#µ1odàd2 ™!㣊ü,Í+¯:7ßÄ™˜QÔÿ£g†endstream endobj 140 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 238 >> stream xœãÿLMRoman7-Regular‹wø˜ù,‹ ‹ ¸÷HÊÇÄ0p÷¬ÿ9qw§ù§¿æ÷®æø˜÷Ó‹÷~Ú]Ñl¹M³;‹û|‹û¥CC‹ûŸ÷|÷|‹÷ŸÓ0˜‹A‹A~Lw0Guc‹]‹N¦wÝ}Ƌ݋Ջԋך ÚË ´‹Á‹¿jQ›UŒC‹4wŸøCš÷n•”Ÿ¯ Ú  To ‹ ‹ ¥ŒŽ’’«¨ ‹ xÃ^endstream endobj 141 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 208 >> stream xœcd`ab`ddôñ NÌ+64Ð JM/ÍI, JtwÿxøÓ‹µ›‡¹›‡eÇw¡S‚Çù0€cƒ1##KÈ÷5|ÿ™Z¯2,(û~ñÄ÷‡_?ü~ëó¿b¿£¾ßú´òÜ¥î;’ï~3>ú­,÷»õ¯×Ã￱}ø}‘µüÇQï€ß\r¿U¾Ïø®Âöãl€‹<_éÂs¾‡/œ½í×Mn9.–|În®nîͳz€ ·ˆ¦òðtó10"wRàendstream endobj 142 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1081 >> stream xœm’kLSÇïíeô …)®“˜kKœøÈÜ&Ì'ŠfS˜8è”L¨ÔÒÁ°”RD^¶ʽç¶Ú«R"ìË,ºD·dF’Íñ,Ù0›&‹&Î,Ë–-ÄÓæ”± sF̾œG~çœÿŸeâT ˲k +ìUÏØMµõ–ÓµÛ^zËdn¨©°-V×0W5N>4qŸ qߧ`ë*¬zO¬dX6ií¦í¯–VV;¬6Smé”Ýh1/Å6‹¹Êžc1m'M‹%~¢¢´9L‹ÔÊzK­¹ÆôxþÉ‘÷,•c»u)4yœ1Ú†I`Vmf5+÷íÞŸÅ°n¶›Y‰Vf=¬—õ±=L¢r'ǼËÜelLõ‚ê#n5Wʹ¹ïðãäö¦ÈëâÆYÜ:ÃE2êЂOôˆÞ²k¯ß®À]öû®¿ààÐM,@ >€€v€»Åp¤¥M—NI‡(¨hýE*Ã5”lŸ>Þ燠>yAeØÍÑA­V(f¹Èöù?´€“ù8E¥ØÐ:tj¢~¸³W„6à.pº}n¨ÿ¤ê«’oH… •LuB,4¢|:,Šb7tóÎ<àè~½óõ3h¾‚ë¸pŸ¼À¥ûa®Ë!$^Q¸ã¢[„¹n-„$Ùí)£5?Z1Ç= à£~5 êfSÎ=d¦P‹+úñˆÜ›}C w äÿ4ôÓÕßqõþY†–ä†&š­:²Óê6zªøùwÔ YÇ^)Ûc0–׶º$ ÎB“,ù»~.¾Ÿ¦]Þ¡Ÿ¨!ë Ú‡†ô‘6 –å°þi=ÎÍp8»¡|j½ Ëh f;ûÍ6ßÕ)v¸=ݾnýÕcÓYŸÑ«#ÛàeØèJ¯Ûb¢´¢½Ç‹].p+2uô‰=\ÿz°_÷'&Mc>`½ò¶ÐÀ`úe‹b·µ‘iõ ; ñ¬.6­nÇp.|¨{Z¸|E¸BôÅGö0®¢Š,9‰Ø ‘"LÁAÌŃ^/ô,z¤ÚÛDèpé¶îI#}™Ë)ÕN;€²€œ—i3¨e¬òR@°}°Ùß9aNõHA§2Ž÷úå€òîÌ=&òj¸ˆ,DWh#YŠNIDZœì( ×]C#`¯äG%Ùª;o•¤:}l¯v5Q%PÚ¹Ešuxß5Ú8óöÕ{/dB&¯4ÕÉÒ˜îÛø1Y}Ä’Ù%\ÔhÓŽH²M×OÕÄ泥@›øXβ‘HŽbŽ0c¦ —Œ±lc×âùe‹Ñùÿaþ­rü_øןޚ‘Ü/OüR9Ûx îò gÙu –6ߢ£XMj~(þ¢,è“ÁȆžˆ>è•ã'fu q%§5+@“šÄð§Oî•}Þ¾ÁK hRæ!oLÄendstream endobj 143 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 5033 >> stream xœ­XyXSgº?1Jµ‚©¤íœ3:Ž£­zë2n­ÓZeÜE남E6YB@ö}Ï›œl$¬Â*ÙeQq©Å½UkW­#uºNg¹O­ó…9ܧ÷ භ3×;÷ÂÃðäpÞïý-ïïý8Äøq‡Ã™¶eëki©ÑÂE/,ؘ’ëÿã3,ó7é2¹8¾÷YÁ‘ ´mÚ7S/>Iø¿æ­¦­…fÉÌÚ˜½9/vkÜ¡ø„Ä×’vîJÙ“ºhñ’¥+WÍ7á 1‹#¶³‰Äb'±‹ØMì!ž#‰½Ä«Ä|b±ŽXH„¿%ÖˆÄb±”ø5±•XNl#‚ˆ`b:Á'ž&ž!&“ˆ'ˆ©Ä4â9\81ž¨å¼Î9>n鸇ÜÛã#ÇßçMàÉyCÞ$÷MÜ:qxRää•“Æ~÷„sʶ©Ë¦^x²xZÌ´ÛAIÁ±ÁƒÓkù;ž ~ÊýÔàŒU3 g¼7Ú§|7î‹ÝxÑ>¯ï@çÂÐÜ¡ n~± ÄázGŠâ=FF 1èÔ9;8|7$êå(]¢An4æz“ÒU{”:Ê MúF ­ÅPáRÊDkL fðB¡µ¨°ü A¹<»* çˆ,J.ƒ\Y0m ´S-Ъ?¤­Ü4»iùì!Ú†îàú¯ äßÇ|Þ}‰ëûúß©µ :J%ÍÛd¶±´¤ÖY稡+Ïv¡ñ0@ÞÝåÙ·rX®”RŸJjŒ‚ÈɧæÆJ·ášN°›L+å¾YqÊ dåb}®NL¿Âž5hŒZР䎂ʢr{…êDK­[•Õ#(> ¦ò£%5½ïd92{ëAv²$––&é•MlH8ùå14ÏJMùŽóݳc…£q7QÑM®Ï†¼ü?l¿±”}’å³³Ø9³¯lýzñÑ,ô+*´ƒQY³“Ä»öFî2.Þ{«¿q›ÎÑm—N6vyªáàv7ä*Cdy‡x9è¹ûÜ¡ÓC«ù&‹ÉŒN¨A®¤¶¬‰º±£,l ›Ìf±2vÅ_g# …#:|J«QƒJOïeW³Ó6¯rù’óhÖåZ´èG_ÿ⋾|ØúüÒtm2èi»\Œ©Ü2v,vÍÅ$ìm®ÏŽ:ø ;¶/*!IHÉ"‹2£Ý«Óh–7©JQéãŒ%¦„Úªµ×c25ÐMpL?iÃd*R€d/Øœ6{¥ŒnEsìùµ1g@€3ÍEóhv*»/ˈ Ý äÅ ƒ11f}íp»|û ô:_KŽ±“…›ýý«!üEï'^´Ü˹<ô2wh-¾KzLéL%µƒ¥7±K€d§ðR€±Û§ÉFß@ ÷y×íb‘ÚX Ò`PéeN°¹³ÛB¿Dø¥NA‘ tRÐgk¨Üu¹Y«€\Å»„ŒŽf»©—<‡ˆÚÔu"ƒT„6jJГ2XJL·™ªF¡L²A0œÀËW@žÔ• R¨t4ûôp³*I£ZÕ(Çú)„2Úw„W &“½ôS”b23¸£Tç%œÙè³Û¥£y÷¸>‰o*ÿÌ&×áß&Dd‰)ùÙ¸ŠÃÿ¢$íGfê*51½ˆÿ ¬Ð•’D¹>´¤´0·Îí-éð3¥ø÷XoÞA ¯÷c,<‚Þäú~†ñáþjwLaš-ÁÝdMÕõ;õmŠ8•¬S‰@AÊmù5åuEÝ}1Ù‰1χÿ暤ACõ(z°›L½8;k‡õ´˜:m…\x…´8;3-?rÛ@Â;è¹v4¥Ïÿî-#®!ð¢ðÌ’‹\ä³ óTTÞþØW^Rµev(³7Ðï¡þ€A^¹ ³M búE^šk)3XUùVE†"›M»$`/ÿQëïðÖ²FN ADsì™?=ªüq!ÞGÊÿ·K¥ç¹¾Gï6³4”dgî–$ Ó¡¾dôÝ·P—Ùf²#p©JsRÕB•z•íÕæA)ä¦ S©ìi¾ÔüYíuÚQe- ²ÿ°7ja";W3Šœ¹ÄB9¼õÒåÒ§Qˆ$qtzhú'—Ï=ÖØXC¹wwk*  ªjK½îö¢‹£dQ˜±"†8^Λ¾í\ôy¿H9[Áî°[J)ôŒ¯ÍÑd+¼‚*çˆu±Ñzˆ¡c Š‰÷t„¨ÇŽB¾Þ 5êiöÙá.Õa¥j²•'·ìÇ袻 [ß ¤«šžâ‹ëÒ —JΣ‰Ÿr} _ ¿EæffdfJíj›šªIg’±±¦`-ì„Ýòþæ¦ûõ·(k™­ô1{²,' /\^@/õ¡ÿ¨ó#Tœþ¡E—ŠÏ^Bk?åmýo‡ØäYù1YáÉ1¯!î:^hªqõÐÇÑK6³,#° Õ" Ûkl®:͘ !OY±'Þ+>W÷ž÷.e¯°>n½ì³"Hr$ÕiJëÕ—C´7ž.ï]€‹p¼«ñÆëh!œ%¿?fþtëóüs¦]Gµß#u²:Ik¤r»“Ë’±×qÙIì|vβ¾Ð÷[{ªNuÒ®}mÙ-?ä »>—¯JÞºjTû½h¢û8]{©¯¿ ÃÚðh0ª l²\â“1J]jçE`J)AI%˜dv™—þ‚¶ Õ×ß|Ë&p˜œ&('í:«:;C™T"bpÝ)äÊ VºÄX¤ ä別ì·l_ÈmtËÑäp\Á„,·KmVŠÑC 1LÜèƒ2Txë1!Á “Ðì3ÃßwN0í] tÐХdzՎ“G±rv€£Ðæh²ºé4Ñh¶ÉVì}ɇŒR?Óýdní` jÄyç(…K)>2ç3†`£=è?A>Xú3‚ÿè[¢çÿÉG™læ ü„Z¶ÿWe÷ykŠ‹©CìÊ5#€Ü/i·‚Él7Ñ^kQ=”‘UbWl•Åiv†w%½ñàóoþ\;ª=Ô~»w4Dr}‰øV•K¥3*j͂ź| wgôœ­ÿ¶î$Ýz­¿¥\Ðk(‰Ð@&ƒØ%®®¯ñ´ŸŠjÛü(Ò̽°ñ÷húïþRŠEÆ•{Ç8ðÖß^âÝÁ±r¬ÃŽQ[iÿŠ8sæÓìt^èAžÇ~9|9d§oÀà1Àœc¼Ü~êôá"ÉÎC²Hƒ@%7æ)mz{ã1¼8;´Œd j‘Ú$£_3ê °YÊÀ×bâ]þÆœêRƒÕnsù&qðŸÙ™ÃW~Ä“6Œu;ÝŽyÒ6Êú{¢CñÇ9ˆÀÂkúÇÂ+µÕÐè¾ëcù Pèô £QOÍUÉŒr#ä äN(9iV+ôz àô!-ðŠê£ñ¡K’²ùª”m/þ”$Pmt§9ÅN!ä‚Þ¨3hÈQàEô"FžwiÛùMòw:Ú½özºƒ×o3'+n7Á5°“}ñ›g±¿˜Ã†.:¹ì£XG!&»SÙ¼n´âBÈÎjQ’¿S‹½~UTÜñåzÑ‚ª<œŒ{è2${‡‚ùÝ1Õ1ó2ا’ÔT6;.`£ãÜŒRú2ïÕቲ­ŠM¶@•$ Oä2òÒFkI T’ž<§8##'1²;»íAŠoµS7p—Wî#Òj^Zæhsmª ÅâT­ääYnEYmme …;á—ëfo–_ÃI[øˆãÛd)ÅiqHY¦J¨£$GE Q¸ÓãÙ ì\væ²ëß?ÝÝUTDg/—Eh²Ó’±b¡¤"W¥£¨ »Y±²"=/EÛ–wïÛÞú ‚£plžÛVc¤v>plD«Nеçzz±],\®¢õ’€skpdçizügCbbj õ.ê}Lº±s‡ï F9þ¨¼° ¢ª¸ÜÅPÝhÍØÂSØj2»›*›º¯ÜüŸžq¥Y­ÏzÐo/qŽ}6#¸|(á ¾Ý`“JZ™žÊß™šœdª¾¾©Ž©aêh¦ÚÚUp>ñø^7šÕzý>¼KÞ~ù;bËJôØÉ‚“TX¤Ïü——û·Hºã¿{¹Ì–ú* @ïøñZ‰^)ÙIËè$Kw­¹”|å^ãC5ßÏnáîݩˆÌõ@Îáá§ì³Ý,°›› È«‚c”èáà 4ýü‰7fˆîý!¡èyŒJbª¯+n.n£¯¢—GÍø ‚7ÕÆ/Hbçiÿnî…Íu_Ž˜»6óˆ\¨Î¥SWÄÏ•Òa1âjbÎ|ÕŒž³PÁ?¯÷%ò« <©ÉÉ)ÉYeÙG›š¼MÔ膌Â8hÿut¹)ùpTÝ•Þ”á•1ór­)…ZsRi~t‘w?ütð«†õkÒj]e”ü}»;ƒbGWI•Ôx•ŒÜ÷ö:Sv£©,ÿL÷ìÑ6½GSª;% 9SàЗç¹$®,H _Xý«Å¯¼Òú ÚZϸðÌ p)A#3ø[Î2¨zD+¶By0 0 e6›LκhfCâyŒW :µÚ ÄÙïPÇ”‰JÅìð£Q¾¬§Ï2pš>çô§ñ‰yj)=ek9A±“†…ªd•b5T£v¥»—nºúô=ö«‘—gÝ´{P‘uà!·²â ᮯ-WÄxÀÅÄmØiç[q…) ¥Á`ìÿäÝ.¯-¼ÿùe@|MX}n5;w%¹)ÇÕ{û8 lw+[¤-&4èLÊ&³HAF ãgn“)¬ ×ÞGÛÑ”®¢ì/—.Ÿ»ŠE‰]._7†Y‘ٌǣÁÝŠÃ44äÔæ×åy³ð†ˆ&ô¡W]ÎàA·¼—ñ@ô¡ý§.fynÞò\œœ/÷e¢ƒ|¨Ð½ûr˃–ÏárpÓ©Õìä9³–%VÛÚúZú+ä^™¿B½ÉÀh(pH ’’Ó„9š ÷íÏ¿úcÛɼµb»]Igò‚ˆ|  Âåt¯bÀ°*O97<ŒNKz=#" ¢Ñð^·®¸ JÉ2yYæ^CXÞú“aƒØ¹‚¾E.ÇÖd£õÞJ¯ïëNïU®OX·j°ié@§ òÔ8^©ñ/ZSúmÈHØ`Ⱥ#&}ª&=_GE³«^­ë’ ‚xW>d /R#ªFÌúwÍK„šL‘š:ÌN;È®cÉ—Øé‹Cuzµ>9ĤÎ.uØJ‹.ªÐQh¿n¨„ù…ÌxvžÎ¿ÊèÙåZgE±«ÚFµ¡96£l h¸V\ö¨Ý mw¾öøf×bÆÜB–k\_¿¯€_èyö)vŒƒþÜÈZv<šp±§ó„—JŸ™vpgvúþð­˜DIvéÑ“¦¬d‰Êž”'LØÓ'ºüõ½ß>AýÍ,A¡ÐCnºÌ_Å*ØŸ­ƒwKÚÑ3 ýT‘§ûú;@ž.Û56fá!JÃC6qÒgFð ʸÂ÷ˆ«Ò’§Nwç×ó67R£øÕâÊ4*x{RJrJfYNÃ1o“—½bó²ÿVÃAóû¹¨†UóÀ¢v„›€ž½à›€Ô(ª¤ÄdÂ0ØuŒFÎNXÅÎZJ±ãØ)ì.ø9l/Ü⎨Ýн£ï‹íGÿy°Ÿë òEðá‚òJ^ÆÛQì­:_v}n¥c„ûìöá ¬š’HŒFГj‹ÞæB>F³îShÚèE»à¯äX`~%í~ÈÁçærQæ ~³¤.96#Q˜\­¨ª,sY¬TÁo"6ˆ•aù‚ŽÔ3j»MEO ÉÔ£¾ùæp²_45‚-aâUtí2×'B+ø]_¶£Åð1Ù©EO±üµ/`yaÔ¾…QìZXL¦K£§ßúª ýòõüF~Öˆ½á@&GU~t÷}t²åÝöþ9Ï1 »ZS7¯ e[£æÓS²<¾µ.tÄ\æáy&ŸLM¿+-p"N‚ÀÉG üÝQn±B`Aü'”¶žendstream endobj 144 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1022 >> stream xœm‘{L[eÆÏ¡]ý “içªîœedɼlq‹&$²™²M¹Œe€—Q tã~iK7(¥-¥-oïhY[h-vŒ²ÍŒ¡ÌJ4aS75.ÑÌ%jÔhô+ž=ìoß÷Ï'yŸßû<$ÁM"H’Ü’“›+’ž:,ÕŸ®ÊØ}T,‘Õ‹Z×aS´–¹öÚàs€Ïú[·ù^Úê¦'Ö‡×,RäT‰ ¢€È"Ž»‰7ˆlâ1ö$Á%–ÈÚ¤]I1Î3ÀÑÔ“¶Ü!˜¢(~!’ #d"ï.'áã‚_Þ^y5¿¤²¡‘’¯5H UÚQ/-ï~ HãÐ;=&눃òÌùo¾(충õmF-ÍphëŒÚ**U Ð¸zmn«>§oÁ°ÁÈ:¯T%`w9ü«£x#í‘^|oÂOâx'½?&€Ùö†#-…%'Kì¸ë³Çd¡gpÍæA¿pb*ºèzàD9Íþðr)¡~ÄgñGqºÀ®w¨TF]«ŽRSW’jŸkܦÿ»/›ì®¨Ðön l(¤pvu¶ªë{)¯1žˆIažbhfWú§ùw>ùpnÈOû³?3À4„&œ¾¡KÞÀŠñ)Áñìby 2iìƵ÷þ NÒç—fcÓ€VY*}ësºº«Œê Äme ïãÜûƒrì'üõœDuk-=*cÚ@µ:ZX¨¶-²‡¼ ô8Þæ½q1>BŒÀ°òd·±ôHæë Ç}ñ›9çjJŵÕRJ6_¨d¹É<&­i½›³mÀB‡n/ÎÜt%Ð$iW•iëèÓÌ6e¡DTB=´€Ü;Ýq:ã•57JÅe³-s󗯎ù©à‰ié Û¹ˆÓ"ëù®ºˆ&þ‰’k™¸OàÒÚzº==”dOÃe²ÞOð4f€œf§ÙŽŸMLlu›ûŠ¸!Fo§¼ÁØ'§ðÒ¡ÍÒHß ¥ÎEÏC‡¾¯ÏÐE3O?׈Ú×A¨P=}t¢“ÉpGnã#àf£$Wö²Qâðƒ rò|– Rô‡À¥vètƒ®—ÊÜÃpá  ÂŠè—“C^[¦'®û¯[`ßHceoW=´£Æ­Ç6g]Z:Îgv0»Û_\Ù9xß·¿y(Öåçï×]j"xo„œýêÿ<ÎÊ’-/Œº¦¬>z‘„/LóïF-‹0ˆŠÆÞb60¯ìcÞܹœ“ðK÷~õRùØ,xžÉUÆé?\œtu¢½ŠN•'¸ûûqó0/’|+…Jækâo~2ðSFÌf“yÀ4d³{Ì|>ð7Äzõ~endstream endobj 145 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1665 >> stream xœ5T{\S÷¿1$÷£“Ü…‡ìscÕ¹¶Ã5ØuEçíjµ-N+ÒâŠTcÑ$<ó@˜&9!¦AA!I"xA°`Š<|l>6Ýh§¥­-¥µSY—^öq7íü¿Îùœßù|Ï÷{Îáaas0ñvò;y;ó–¿“³K­Ü¹/Œ%ß¿4“(Da½?žßùéÅXè‰v'ǯxù7¯üV÷+†­ÃÒ°_cbŒÄ~†I°H, Óc",›ÇÕÇ°Þy_ÎY1ç ?ߦÌd º„2DÏ:‡LÂ*ªN”å§'}qÛ”?6ÚEf0u_J†•)xfy™F}uÊÆÄõËÖîÙ˜ç.ñš\þãåÇÔ6ª£yì@œ?Ÿ½RªÄ·7_Ï9§t (ÒðÊ¿ oŒövwy(rmŽÍ—óQlíÄᯤì†sÒÿâʬw3Úƒ»|ÉlGvšáÑ<¦;’Æ“¡ÂVØÊRhet ýD[ M··û®XÏ6š`„Í ´ ¼ÉtX:ÐÔëµo¯^=¥w€°ØÐÊÏ2n”À{Ê¿óÀ¦ÇlD´lѾyf¢)FwXíÐWऑû¢«6Ø¡N«íÖ½è;/¸T`‚ª¨¬Òî7sEÎX{¡‰Ë8-FbþSþµ!ìÿ¥yèÅ6fðÿû—"i5¾ÆT×!eñŽêºqÊC³¿î“±ª„-Ÿ½Í–3—+]fkÄ°«áxµA.­Ä áOË(Þk= >ÎÎBoÑ2ú¤L·Xm–ýPwØà„˜z°9lT3ö˜³—q¹É°†R+„h±Uð£Àª“ôÕ"Òßæ3[#é\<Îèà@ à~“e/•™•º?¸†ü0ýÄl-.7êã¨\…°Ûúôrö9t‡Zü¡ØôíôZ<8üMÆ4Šü&Šô3…è ‰Rh,ªLÓÿ¹2Ê€`× Q,š´¡‡>ꌹ|áÒ0|E ¹¿g#(r3+Z-[±ýt•ÓÝÚÐ)%i §NŒþ½ùc ¾®~uɺD6œ'eÅl¤€´ë `Ú·‘ Ä iE|Ôù8ñÁ'¾ùhÍ“íO,ÜO¢ÈSŠ%pwãØ/<·—®Ã'gø$þÂ’E«¶$Ê›Ë|­.ωŽ=Nµ…ê·6AŠ}c•K_Ïß©-“æ)U¦M‡ŠÍ•fÐÚ#pŒêÞîß²XJalÄä©)I®Á\êT³—–’ÃI'UÞ={ J³â%#!Šùzò[êç(Šföq¤ü“ÏQ‚„~ŽIÅ]P£Ñ™ÍÚ Š™Í(P{G6'˜Šl©-5 h¾ÆÈÍÌ]<‰–°v!²3Á³¾§¾0-Á’Lœ,G;&[&›&£È N„÷%ˆxõ1žö~Ùî mÃëuUô"ƾh¨«²„Cpð€4»<]¿[í JG…ÍÈ<¡C‰”íÃK@´Æz¸ÆF9:ÏMÀyð§)>¶«:²AnÞVQœ—¥L…7á­nÕ5‚4XÍv€…OckG~}QÉžŠâoÉ.%-Bÿ¹HŸazø×d—OüÑÔòûH5µa*Šì –!AQÏO²ü×>Hß®¢à®}ôÔ_[úÏu_ô½¹;L‡vƒÈó–o> stream xœXy\W¶®¶¥ªDJÙШSí$î»&ƘDc$jÜã®(ŠÈ¢4²/‚ÐM³U÷énö]öf+Q°\£F“˜hȘ˜É¨#&ј‰1ã-Þe’w 4ËL23ïÑüø£¹uï=ç|çû¾S jð J¡P _¹jMP ×ÞyÓÖøøEh½Bå/G¶ôv÷ìÀA ƒÛFÜ匂‡#Æéü0Jþyæå½›‚‚‡. X¹<Ê+zçÊ}Þ1»^óñ]íç¿fw€6pÖìgæ Ÿë9ØÄI£§þaÚô™£(êIêujµšzƒO­¥&Pë¨õÔj2µ‘šBm¢Q›)wjµ…z…ò S3¨%ÔRjõ*µŒzšZN­¤VQ¯QÎG©(*ŠRSñOí¦†PöT õµ—r¤œ¨á {j LNŠ‹ƒf zK¹@Y7xìàn»‰v‰vWèetãÏüÀž²dH¡ý3öÙöw†&8P7žðt\ìø‘SºÓýa0ìƒáeÃï9owîà¹ÞÛG$¸¤òRu¹ŒrépA®fW›ë9õb·‘è ãÊA""ò%(Eo¸‹ì}vB ŽêeÔ)ùBV,Ä‚199ôÝVëö„û/0±Zæ°µšÙ j‘YcŽ¡²-é–ô¤R£<ú$ž’–` Å-p-„ðZ¦ÍzÚÅj”«ÂzÙ£kvŽÒ%Éá·Å8›3Ü|»]9½ô¦‹Èpë6A(˜D­càs¨ j ¯ñÉß ÓaÇ’¸ Öô5ÍÕâqz;-s);i‹—2Ûô°ŒœÓa)1wB'ä›NY‘Y¦‡v ZÎpÙÿøø…³ù[^çqìo®}œŠFQŠ›EEï~9š)â`tEžDžm¯™ËÀMd6 ¾ØÙªÖ2-¦âPˆƒ”¨ÇCñ‹j<­ÒR2!à rŠKÚÌä";…×``òÀæÈÒ•îEo`›/À)Û–Ï7…ƒ›–é²r@Ãå¤n³ÄÕ@!ä¦g¦g¢IÈOžÅú¬0‚ຈo¹ mÖrV¤¸Iék¤É6Eí tè†RŠF»UÈõ©Ø sãÇàxøƒ‰È qß~‹œø9Ù*ð…7B·mÛå›ÁË~$¤Å$oÖglÍu]o‚3ÐPº»Â˼ ¼XR,¼ADSm¨§¦LŒ©q~ØÊo¸r¥ƒH«BΓþ†í×oŽØéÃ_`¸‡x¢\›ËÉ;4}þÿ¶6󘪆=¢Aw‘«fŽ ¦—>ý¼§OUc_ (aQ0ÃÙ¿Ýpª´eÔ'çfaJC"îÜ!÷œxCDsEg4¦çËžÒ4µj\¹ô½³ЂèP<#Ä¿D€7†ÞjÌlР’/™{yÚ9šTDÏÑi'ñÓQ"Ý`ÉìàÑHšk§ÐL¨Y_„Ç°5tŠ°ë»¢­ ¯Zô¾š¾Æר_À‡k¥ë´£4^>½¥TÔ¶8?¼üð¯®Üjiˆ4LUXçùº—תpÞô€æ¾ÆOþHOXòÍ]€8Rç(f‘Û¤A“™æ\4Ѽ‰1šbuÆ—ÅT”UÖñ$Ö’n9Öµ÷G =ˆªAO‘@¿ëe$Uÿ=ßþ×{ÒmÖwHIÂmhX1€™™šGÎ22ÜÞúëÜ€g²ð¬>`2? ¥?Ê‚3¦mmæ °9¾”Þ†hª*W4t¡ø.¥D£*h‹ªŽ¨Ø}Ð/óå‚ôEùp†­¯h¹¨ÌçB-¼YÉùÀ@f‰æ.s²u)FÐÅóF£Áœ¢-×fì–¹`Ï¢M!šíá¤.CW¡<&'Ñ >ìÓã!n\Èõ“:^È1e考Ä}<‚‰C^†Ù\Ŗeä槧·ìll>N­WÞ'¸P¤5ÉÀ‰he”óß»ƒjÎuˈ¸ƒî aª3Aë™—µ~~¯Â_‹yT‡Æ‰xZĘæú,°¡ ÷ÑM\KãÁŸ…Ÿà¹Aï7^¼¬!À×·Hv-Š†RöóÓRCæ1 B žòsy3³7¯p.¥õ$þòè?WA˜­Á“X^íþµQÍIGá8«¨=ÇšŸ# b@ìUˆ RS%êqC™Œy‡4R9sÈ’w·‰ôNa)á°vZY­¹fÑùiúÊ?£î>TK7[/A+ù\‚fAæ>ˆÊ‰”fˆ ©X«™@a+Öd!„Qk<°B ÁdLÕ?…ÓÕ˜FUB†12ݪA /2;Œá¦íà{ÁÈtb/ôEã1RgÄf Ù Y–Ìh4úL]ÖÕ˜×h–O¦¢"lg%E‹ŠN¤@3n*¥ Þ1äüe‚Öƒ7< þd»æŽUGêÁÌظa£·GÉáPþHjE5ˆl]De€6,Òч¯}qýÖñ»¼9 Þ„*VšÂ4Ây¹ n/}\¯OpÞ‚ö€Ä·|×VSA0DA‚1YHš­êñ¨:%¬`u«-U$¶mÂN"fZ[€¼¾JM¹qÙú|oRâÔópÄT”Ÿ\H'Í­úH6°BØC–ï¶v&ÄeÌÛTøïêt5¡°sZnZÎ}tPý>˜–¦/·B°æ¤å.ûD]~¾9­Ìü˜œmQÈφfÛœ/|‰^è¾B0é)%ßRZÇèa³ŸtñÈ!¬ÛàÙì{Уp3°s{­Ð–ÅTU—”Vµz¦ƒ¦ºª3»Ø®3>Okö0ë S^ p÷ØÞ,§Ÿ÷uðûŸ>USÀs‹¼ÒkýZGÙ.^ÓàEÇUœmòÂÀí[·7¼õޙѴ ~*„T΋u,6‚io„ˆ슞W'e“$ŸO¾ÎÊ*Ï˶W&©ð}Ù.4æ'’lÇô)É+^TÏÿ&)Ûh!8‚¼Ü¼ y½1ÄäI6Y »äõ€Åؾú;¬ROÆC6¿¾Æ)K^-ñµPõ¦zYB­ÂÈ!5+(,®«êluŸŽW—DÕK}B|˜,z-–Js+Ù÷,dY"ôô•­É†|[/#¿~E>ñ[ì°t«pÞg©¿Qû¾¬ašÎ‹Ûß : n?©ŽY[“7„xGìÔnOð© kŠ+³¬>ÛÒæÜ¢†öcE‡I³ «òªÚaY ru K©Ÿ»XºÓ¯;úñqØ/ö™Ù‘È‘iy·ùz‘öf’~Ø«À“¤¥‚àìòŸ´¥–¨ ö²%½è\z=ñº+W+èÇ|€ …øŸºÝ~ úÔ„ÔÄñؠƃQa2á]·ª(“!¬XCj@²Ý%Ƽ`4»Q‡®ŽØ°wérp …˜|ÁÂrßf™k²FVE…‡î‹ ölñ=þnëÛ§*y´Lz!·ª¸ù¢ÅÐëùw½¢C·kk 7Ðö/•ÒKh¨*O‚Œ1É|ø’µ!›€]1ï8šˆf^ë8—ÒÚ¤‰LŠƒ½lHiTUUÙñŇŸÆ#¦ŒÁñêÁ$â5õè‰l~`¨‘m iZC2™€•ñ›ðp"ChÔ 1Ù¹ýýY˜1<þ3­ÇÏÙÕÐ÷‹›Á4nìc ä*ÄzÆfaù/é~Œ„¶hÅr´ ƒ­`E–mrÿœ¯\våƤKMI]zÀpWÿ.x7“’áyb>¹Ó˜IX…‡ÿm<úQ[kY±fÃM¤ë`ÒÂþH–³îðÔn‹öµ¼+CZBZg ´;2NT-¯oO@ ¬öÉ‹Dÿä8 #J Eeop?i®7î7yÀˆ7¯•k|<‚5}/1øG©81O ^Ó ¿¨­¡;«’@Ówˆ qÄUœ²˜{Uh:)·Ò8è¬ÖHùŒ4¿ïa–.ÒÁ­²J4RS ÷å\¿3U®¥%ZÐï…KÅÌLÉ0$I©&~÷¸ÙÆýà;«Ãö3ƒ¦Ëӡ컵wˆ©t˜ö†]¿Ÿ€‘㱇š¥h¤ §ÒÙhzOQ œ‚s^fÖÖÊsOæ@Ž1‡tñM¡lHÉ>[uqIÿØ#¸Ö  ¢óÑûÐ÷ ïöª¤dÕ7cob ñO¶éq ÒœUËp¯YÛNCû(®«NCqOáÌ£|¼½À 1÷oÞÕŒsñ<?Ï㱨|À<Ý¥Ñ<ò§f€õñÎj´òµj”Tí\{:ìjüi4újÃiWn%¥JT%q¢÷^O½Ÿ?\¾«À Ø©îK_ÜTçW´_c4ù–Ø]äW½åîê7ÅzûnùÊ7kÐäôý‰«ÍÑoúVòk߀©„… Ѳ7#ºšÀ­(½0;ß+î'ƒÁ+—>=Ô_ 9z¨ò EHL}¬>3º¢ (§ŒÇË1¥ ‡É³x.‡š ÷Ê«- *5…¥Õ…5ÀöÀäp Rö±ª5 <§ñÜrý¤—;Nå¼wCó]œLÏkpèQKýÓ·ç·§¸Wa‹¿v-kBwi®õ—Ì\ôƸÿ<Ä ú~Ÿ¬j]6Ô%*HÁoÂ}eoÒ-UäÅŃ!Ñħ¬Ô†iIÂô¥‰ å†KÉm‰ïÞÇÊÆ;ÕŸœ…OØoðŸá <¾ò/ÀÐÒÖ·@>Œüý"¬È¹õ>i©u¾°^!ñmïôéð=¹Àþ¥ðf¥GI³Us¶¯Ä£yÌ¢ª,Ù%iÙ–z(öâO’­ëôM¢myˆ(ç[ˆšKÈɆ2H*—§¦ÑHJ†;ƒÇÊùº˜L¨©ìqÚ,eæ7¡ˆÌ1åÔk¥¿©êÂ*ÃÂ+Ãêê*+ë~’|¹ CƤ¼ äƒTFŽØaf¿N–ÛŠŸDëï]o?rÉJ&]â±| ¤åI·Ð”—D Ttl¼!ÿUK! 'þf‘ÒŠ”‚Ý£Ò}Ë\<ù5v-ŠÈÒAœ[‚ ÓÊK(«¬üµ‚ÛãРʲ#WjB.–þÁpü.JÚ¡˜Žõð›äÚ÷¿Pµ=z¥à'ÿºr©½Ý27þ7¡fOË9UFzçmå[¼‚6èÎzš /À–‘ÛXÓ=š«ù?½dHCÔ'o;U¼kñïôçÅÿqéƒr5‰£(êªRzÅ…ÌpÓ2ÃI§›ÉʯZ1ƒøY¢%pNV±}Œ¯ ›ÎhéCÖ[ÐL>=pHx¼Ù5tÿÁ}QÑõ|¡”v¢ÅD`ñ‰«ãc“ K°x ýÍWè9ôäùpß 1S¯a'ÌÌŸ9sskJvy]Ñ¡ºÈrmŠ¦T¾òòÅú“ÀÞoœºdÜ‚ç<6jð ¼E/+o¸›ÄѯFŠR¹ÿùnù¥Ä<•8NÚ”Bf´ÎdŠ3ðøÝ>_;-ªšCî­_ÈGhé Ö‰}I‡+pôX³P&ýÌË¢ @¢í¶Ž¨AŠ{S>GmÈõóú(çbŒxSü¾Ç•ãõ$´­*ôÄœo°ÂcK,¡W´™©3ˆ)¢<'^¹•Ÿœ–B\SŠA³5z[¢™¯<³¶•$¤ ÄV²:HˆÑà†SPû@OÌô‘Y`MËÈ®ké¬<ìCÀÓý´°*ÈSì彋ÜW›ÂºYî$™ÆÌÒÚüCbDqpdÎ{æŸf %ÏYˆžøî&÷xÏMJš‰Ö#J^·!w›ùK×UCZ¼ü£ƒƒƒK‚óóÓ²sy‹Åb&·K²aYàkžDˆ‘KaS2’2s®Œx´ÕåÿóØ@úL‘Òç×êIa– —Ú«Va AÈJØ zö!¶*­"ët~^fƧP@çKOÁ®Ø/Õá¹°ÆMžíðf>Œ4¡±'® 1h­ºß •=Bœt0½¥¦IU*<=‹§âgóãQHƒ)RI¥f…¸V4§Uq¦w¡²wú^Uûù¾‡ôþˆˆ,…|ô]Pe¼}pY4Äñ}?ÐñQQ…é!]XåS;šì¼>ʹ9F#ÇPäèÊ}€6IkTÕÑÕþññ©=o4Mr‚ŒÙïÕïlÓX,V+¤³éÉ™I%`IÊóð,·Ln}±ãÙObÛá]è®iù¢îýŒá;'OEFÒ¹ «#1ýrB(‚{A4²K8 7à \‚OóN•ÞºX܇áBTÉôÜu0VÊ]¾Qø¥³ ÜJ'æþÕ;’¸û&¿†7·%ûyó‘6ïk} 3kŸüïRÊp—)9­ô¿†ˆØŒ=ím<·So%F·0ùŸ§,Ôª BX‘ËkTñ ` ÅŒ\2JPßÞ8ün^ƒ)–¤4¢\r?€öæf”Ó¢}ÏPÞ~𺠇!à`C+ÍòIË0›3ßvpgŠú_Ö$º÷endstream endobj 147 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 4200 >> stream xœ…X T׶­¶¡ºTè²Tô­ª è7NqˆsEÁˆ HP‘y’fj¡Eh”ÛŒÊÜ€ *ƒ"*hÔ$”ˆb;½¿Sž/óónå_þZÿ6Íоäç»z¹Öíº}†}Î>g"Âh!‰,œda²E3\ýä¡;"ußým/ŠZ~w0æb`nÔþ7¦F ý-¡xô5 B÷oöŠ0Yx„]¤}T´|MŒbG¬·£¯Ÿ@ kÐ×ÁÜBwΞ3wÞ‚…‹X:å³é3f~>‹ >!œ b=áJL&¾&þƒØ@¸îÄTƒØHØ›ˆ•Ä baGØ«‰¯ˆ5Ä\Âø‚XKÌ#æNÄ:BJÐÄb,1ž°"&‰‚%LSb$1ŠMX–ÄœaD$Hô¥è̈)#êÅRq²‘µ‘Ú¨ÏØÞ¸Ž\J^’8Hš)åIiMæ›”™†˜>5Ë4{k^1òã‘ #š4êúèF—Y,°h·d,s¥#¥«¥aÒ“´ ½.¦¿¡ŸùxL(l%Tþ/LRˆj…@±ÒÀ4F€xv‰L…Ò”#IyAÀ*‰ IÉ)¡È´¯tü.RB‚«A1EdQ hh”ƒ@NóÊÎ$53Œå 8¤ >åÐr¸A–d5”4™Y-”šÌˆÎߢN¡úÃNÞ™—¾ÒBí8º]8„Jv;T?on_ä¹5.Ø¥{jÓK¼Yr· ûÖY?…:·Ÿà|²°G‚Ém‡+HºîŸwutF¹°(*D²; ß«ÕÝ›ÚÞSyØÍ‹.ia™V,ÁPZÌø#ãS²x=A£×o »"—™ílkkë|ûù³®ïzn~ï4‡ÅP$§óðê@øjþx!AgÈlÞ;dä¹#.,¥ßOÈû ð¾òÿ3pO²~gË®S€‚â7¯¡”[1vŽÃW¶«|¸ÀÞ”Ðc®^íø¶çêê/ ¼wñ¢f-,Å)´ W¦Q†‘Û"œ%Ë@¥¿?P„²!G|5€Bä¤éHŠF¾˜ÉÞ3' 9ä»Å–eda®T‹šÙ°yé’•ko<ùéçnÛ2gV_&7õ'*Õ6k=p²ÿ-¤Ÿd^Jô®¢cY;tÊ Tâb›š@eûzàY¬‹¤pIŸ€*72Dëß“4&ç±}&¤RF1W×'> IhÌ;p”3h8»ž%Ä S¶§}¡«c”Û¶^B÷ôCFÃ?ÿ;ê\2|‚¥ý)êâš‘ôGïºC‚Íô¯M9¨JMIí€_ÝGôV ÇâLÅB‚È ÆjAƇãöÖaÖÐ'>ÁÙÃæ7B_8–üSÆâG©ô÷á r|4/íåa>¯k¢íPÊ€ŽÐú¨"ŸÃ‘Ù3Švä¬)MTuCíO?eÉÕl†¬ý‘ÎÇKèŠ@MHtêž”}¬_Ùf‡+¾R9KæÞu0™;S›ú>¾:íAØD…†N[磹ª`SÊÓ d€ÂµSp³$JÞPT˜[{€=x”ã\\õ¢e€(Wy8Z!…Ó´@{ÃÿFpƒ s,$Æ+ö‡¤³û·øȃµtVq0Ε µ4šûC/²ôí~?KJú!Óµþ#¤$?í ¼õ¸çšV„³®Æ¸ÅnjOa/¡³àÙÿü÷'éŽËö-uõ,¬üñF9£;âÞ±Öì#m,½|gV9(xwh^ó"(Ç%voÐS‚ÒFs„è“#ÂàÜ¦ç ¶T#HxQ•.ö ŸèbŽg‘éðÕjÒñÖ7®60mjÐö$žô¯`UƒƒÇáøt|YTkè¡XH Ù§Lƒ4rØÃ9r+:iœN¦ÕÄ_N>¢¼˜Vì@š2~}¢‚gZ$•Nn‚'Ïø©ŸãU –»‚çúUà¢[µÌü’k•?¨ËÕ…xNgÊJœrä%Ι '@)¨¹ÍWàãñµU ‘,Øtþ/=«Å0Ž£=…âF]lñÊËÂÉ}çû裭“Áò°Š]UÅõ9gÙÚÌR¨§ƒ×qhÉ~4Þ|Fщ6=NoÞ-¸PAU qb¿¼;DƒE7Æli]¼[;Þ…꡹ T{ˇD£ál(‚ÖÆ­úå„¿åÙ`²‡¹¯fÚ¿4®ÂÆúÔlxµ’ÐY#34Û؇Œ\cfz;Ñ Œ{©‡ˆ2ŽˆúðÙKºx8‚õ¯ñ\ýÇí¤B? ÊÙ¿ü†c_ß´¿iaö¡<ɼÀÃ¥ —¨XÖ%òK’"=÷pÒ‹†S;Þ'> æäàXÕoÁ[ZúR,øC£QæÉv¹ŠMQÆí°Ô|ûž'çëÿÇ”¦ƒ,®|¿:]­Ê ªI*TMyyÍIÀ­X‡&ÎE£þ9Ž†ŸÖÿ\4ÔWu˜Hê×£r˜Ñ‚úO=”—ùTºãá%ž6 Yrt ý|*$ÚÛJŽÇ âN²F_À Ýè¶mñr{—OžñÝ·¯ópÓÈtÁ‘¼èâ}˜W,ø¤µ;A—V”ëZÖƒG¯)ØN–W€fH9ü1hÔôI¸ú¿Ncà„öçUœ ´fP>Yöðû–oÀMpbkîò!ÑÍñðpÀUX#œg¾[”Ë{}Înš6<àÞ ÎÉó¢n˜|“a'4^üÈä4yû[õ63\¯TYuaO¡Ø.¸øÛu]g» {—”×:}ç„Q|$äc˜y½{ôö½aþ¬¬4¨ P3VØÎõ?RÅ©â“"@Ø¡‘eì_½cŸPRss†4”þëÚSø)raì*’¾ @rfñ<ƒTïÓçýPðÂa&g_n}ùð—å–[‚Ä›lõ}‚æTblßÄ¿ˆ€ˆ 0¼5vƒ½@©ŽÏHWƒMµ¤çí™H[È#ãC8:}Ù[Ð '5CÓ,m­^ý)búy[­…–ºXH5ƒãÈ Ur g#’sвO¾Ñ  W¨B,-,?”~¸‰¼¨W •Ø²F¸3 ÆËÊ:ôœ´vôpww¼ðž…Ïë ¦û·^‘ÈòÙ¬wïžý-YøJïßDNÈÀŠDc‡ï¿'Gc ÎO†VÛ ô> ’ºÏ8º£Ÿ½øµ…I’ æ$m›¼ÙýY±§Ý0ðÁÉa˜?Ô¥)À®‰Áz£à‡:%C¯‡Ï‡ßá* ÝñèÄéÖòC»X'Q… ôô­.ýÅ•\IŽRˆ` Nwý@ºs„ƒ¤®_ã’U {ÙP;ŸpŸ}Êtù~°“Rì©jmÑ”W²}ŸÏ‘ oülC“‰˜0/·êÎ=!ô$S7 çcÂY$'/ž†FÏW6ïí?SÐlÊ}dÁÒ!“%Kæs´…OCRK¿,¯.9¢IÎMÍæJNªÆ þwíÖyvnÎ>ÁJBžÉ)))@i¥£5 Ÿ-çD¦ñЃ—žz¹ö%x MµÛpÁB4\É€‡N—=5·/ä^5Ô=›ëøÍuôšÍ«wVì:|XS^·¯ 5—m¬áA n¶û{˼}#¹ˆ¸]éžû|÷+téëàciíIòý)»Ž®.ó"l²Îr™9y ##ß ¨3³+4QÑÊ ¹¯\¡%ûä§×íàq[Ìæ¥ÿ©…É8¨…x”¸2¿|ù™{§Ê½Xè ÞÊu\ñãÐ! ýD+ÍÎÎ?À9Þ^ØÅà)»µËì]ùx·É9µ:7_‘q°ßµ¢<"V¶ÇoñÃUÐZ¾}źòc¬úNi;p¡£õÄÁ‚ø™RTýs%–Û6ÀKM ³H—5[–.ö@£’‘)ØJ%€€¦ãê£Ål”cµhÿ뻲ÒÌ PD}»ÖY áÿÆÑÓõ ÿhÓéXz¥¤»ôP<@æÈ|Á—‹ì»·^‰gé[±+6,žðÙ‹¹P ¥/ž½açÂffƒ³—K7Ú9·]:×yæîÝNÏM\!jbÖ8~½˜¥];^¾þí7מ<½ì¼N­œÙ{ÖñÒsZXöH÷7‘0ØÅÀDDÜ™ŒŒ'-ÀNŸÍ†Fíì`ýåœ9x“‡©EYÙYÙ „¢••q•aáŠØ[\ 'bUFCvÁf½ëÆeK<øÞG=—z»np/aÈÓñ¤ì—5ø’¤Ep ¤Åð fšBkBüÃCCüëÚjêXôѾÿ>Zd~W•³¨öZ!ÓåÁ1õ›Ë­Þ÷Þ©QQ6Xc…¯Á wîÝ5 îbüþnÉ4û‚Ý,zCîö~þÇA²à8hâÐ4£¦È"L þ~- ƒoÈÂЬƒÈ)æ÷RLrörg@qRŽ*â Yð+¸«á+Ú[ïvœ8SŸ›¹€Êß[½`ý_³î ãæ€Uà«Âéקw¬|à|+Øœòü›>WD°A+†¿Á+ èÞýzÍëͽK¯EJ–*OŽÏOÉÛËÁñ_œ@,øØÄ8È·ùØlöö MÞ›šT”*'¦¦òÑ•'—Ù‹?–<·t€"ÓÈé"†o«™+þmž¾‘;ƒýk›rsÕê 6U¾Ëocœjß®½@N)‹v•5¼¿t˜BÍÑea–XÄñ4ûƒ=,ê&ý0Mà »É‚f •¾lƒ%ûþÂëŠ0+üß­™ÊØ¢]QªØ¤TÝÿÛäxR¬¢Ë”¥Uy¥Ù,¼ÿ»íb ¹VƒŠA„ßï1Úá8¸n‡Œñd4«Àu¿ qпƒ »¢€A“œÉÒ¥NÐZÃI7þÑÛ{c*²fG%+ àÒÂL5É›jÍXS£ 2s`n ÌÍš‹ó1Yê’ŒææÀ\Jÿ åʪjendstream endobj 148 0 obj << /Filter /FlateDecode /Length 4431 >> stream xœÝ[Ko$IÞ³O q¡–ö@õâ.W¾3—$–ТåÀ`Nc@5vÛîÝ~xºÛ3³ZÁoç‹Ì¬ªÌꪶ=3€@>¸Y‘‘ñü""ûõ¤*Ù¤¢¿øÿruRMnN^Ÿ0ÿé$þ»\M¾)]åØäüú$<Â&–MŒ2¥jr¾:)øôü[¬U2]+TÉ´Åòó«“—Åo¦ë-ÅåtV••r¢R6s?¥×ÒrçŠm½Ÿ§ß-¿ŸÎ„à ¡‹ßnVwÉÒð˜rÒÚb¿X'ïn¦=ÿÃá!+­l9[nn¦3&ÊŠY^\¬y†¥Ïp]òð@ñI8l¦ÙŒœ[fµ-ÞÝùwR;g@˜|öø'àG0T|Ws•m&J!dd§ŽìdôTi´®Ž¿âU¥P\L/¦ƒJ´%s¶Óân—­÷ö*êHÈâé»®ðzÃf”sëu# «\”‘æZs©tº³±¥á¦ÙøEÔxxö:y½":0¾Ê¨æéôÙúÒ[¢€}Wßr‘‹z&Œƒ«É ­Ö^X¿ ’’p‚Ò™*° uI+'3Vj몰ð›!ÁÃ’”©Ä$]³ð+óÍeÉ%wQÅ»bB1ÝJœáœ¶,žEÁdl K„>AÚIÇ=áyT¼(¬3:X‡ã–‰ /-ãÖu °_Èr°ÌE·?$ÅK®“ãr$å*NJT r/ÍS“ã,•iL7´Æ „Z!­(ÞøW—E¸¶¹‹$4ëïêHfùú>µÑ@UU mÙl'yføiØ['Ÿ_¦Ûí›5=n¡ Y,vÃñĉ’5‘àõ€ %¤ã`-4nd‡G7k”w7¬é‰ w|©)~/öm\ímâ`›ö¡=¬6‡{èâóvî“Ä€;¾3šÃ,¢M»‰w©é[•x†´UUšð ,‘L=#œJW™¾¸í¹?Ш.•5Œ= eùD •p¬ôâ)§3ÇXñõu´)%Žõ™Ä‰¹¡°(JÎË¢ÞÞÄ\Ï ”¹Ê&ؾ†öÃ:µðú£:EÄæmì‡Í‡Äl–¶Ÿ¡˜àÅ›ÅÕÁ"3MF“¶ G ¯tL,á9^ì2O¬—ý8 ù8/þ9’ä¡#¦ŽÓbí²Ù+7[Tb¯9U„V)9‚×zñ‡ZŽ=!&Íà w#'ÄvýÀú'¤¸–üdy1¬éÐ\5ÍdL¬¿…¢ƒ’`’egGI­·HL"0/2Îf\CPœMfܕƘ;)íÑ–,…–¬ 3Åtf"3"œ^xüU šóÀ8|“5ø€T>g™AlgÆ?¢ã¡ ÕÇMÍxЖ<ä†Ñ9ñ—çCt8O.E[o±¬E+=汯5ÉD¤S“0D`è3ƒ]TC$ð£!y)ŠÙ3†;ÍR`‘EdlìJI`‡Öýs€=”a~e&ÜŒ3 -VNN4h²*`²+ÁY‚ì)w/‹Æë©0 2Û `Ä’cý?ž~8ÎxX¶„¥¼0~(‹dç<|9v ^ &ÒH¬ …Ö‰¶ 'bÈöÂ)œ‰·ŸËöÃU¶ "hœX§Ù>’¦$Ëgyºï9RR`ŽªÔZ 0„\õT•ªŠÐ‚ž,¦„&çc/äÃù| a÷€Íx%ÞÅÄÌäTÌ3ä ýTØ÷†«üÿ.•se°Ð ÚÉŽø«A©º’À`l"t f’ ”FÄ?h<¢»u‚í¥k(š4ü¶ÞíÔЗ¥äíªiû¸É!|ç í]×<¡W4„Ò鈑M — +ºØ\7Œ^·"ìMº ?lrvËhØl_¢2 )CŒFLf‚ÚÆ!q@ipŒÔ#ew> #=t¬×$7£|2HŽ*ýânÅšµÊ—B¡&dàH›m¤a=¥nV\çŠYóÒ´ J â‹"{ï{AC³Ys.#Fuÿv;Ô²ßÖ[>U>ºÜÐkëô6gM W•?ÞfÝ3 úµîÛPOK¬HKÝåU¤¯ÛlˆR›‘ÛaB%½@ÒbÚ Ž¨‚ì%>HF<í¤ÖJi‰Þ4û›ð4GÚ‰†B o']Z©Ÿ1X1*u(gQ‘{¤·Á}oc–¬ Ø Þã%ñ,¾d,醢œc_ªR·]Á‘0Ìʪkßõ45R­S”µ]ËÑ~—4I¹îÑd¿N°ÿf;¼jC#šÇßѹÉ[lñÅ ÅsV ÃÛõUtD.Š‹Pà"(P™ \…Û3iÏ–‘Z‹~LEž ã²”,ø˜þ7{Ô‡Úi òñÊiÐY¨Í€Ãacz¬#.!yuô81(i}ŽŸ‡æ00¤‡xðH]UÓuÉsBÄJ{ð‘ÊKÆY[®)à09"1â"phÀT2'Tÿm²øßQÖ‹W?»Kú™Žê¿[5¬áàϲEPª Èݹmúcsj=BáÚeY'+‹ëäÍf»"ԣ;}Lm°Dã~41R8m;uŠoó¦g2þåft.¹ê·ÓP4zd>wPœUæó®SÝø„ÐÔnê7ï’²"ÿ¶‡hÃsªõ*E)Ov ¦àé¹>ŽŸÃÁÚ2º‚úW—ŒF:¹ "’­kJ$<Ï5^nÒfy½šЃŽ4™£ K¹O×'‚«üì ´wºEWvý€ìyÑ¢Xå©x»ŽN×5æýâï_ýý›çÇSŒi‡/}žô|8}pQ$šåÁE‘`crüL‘¯Q°¼Úû”æqh×÷næ&¿'[¤·pÃR5˜#à£ýf…z:r ˆôp>|A…7)ºŠc]wø=M”9¢ƒàl˜@äJ—3þ ꆙpÁê%ù³hå#­öÓ…æâéÈ=¼Ý~qãƒ0]\ª´¸Ògü ¨º ütP½I6îÉzusv¥uqÐ:YzÀé,SáÒ`(´2WõdûVõwázµíIä!Ú ŸK@é5Ýj…@C)F 2Ñ:ØHB´7Ÿró6ØN©¼M œjÈ„(32!H‡)Í—†ßÓ\U…¨)\¾×ÀìÁ÷öha‡{©µ÷*íáÑÀl±lîH3ñxëÛ7Mý@g.N;saË|M&²làÕïÍ6“Ù¶, Ÿ_Ũ¥Ùa¹A;" f³‰Üroèf½=˜¶ÅQø¥ /[¡è-dŠÝç1ÉhžÞÐ%£Û^ßœœ û5yf˜Ù.¯húyAfw½ }Fµ BåÀú½(—lÞ¼Wųî»ëûõ%±sQÔ !Ôëºr~T( ¤Mâ7qdpyQ\ÍáçLåoËeËÚ©px/ŠY÷•/ÇfuÀc{¾ŒeOK O›Þ*oʳyèZ¤$I±¹6L€&᳄“f0‚’BXY‘áºÝ?B’ä2•ô§Ÿþ"rÅ‹óÛy|7ÛùVý¦ù‘öùvë[Þ‘7Š” kKÖnñ%¼å>øE4–¾Ž±ÁóFËá™-Ÿ6LÙân;¿ür±ßuÏ$“þŽrdð¿m&œÆvûÍÝâz½Ù_‹]¹¾_ͼA6Ïk8Ìúf̬ýðÙ³îÔì´{}ÈÙ¯;ÎTUE2¸ª»S¦'6·c•ª ›ŽþÕæþÕ²õá÷[ìÈ+ºu9L×{\"EÙòú¬y‘p×íÉ‹ÛÅÍmg²ÝŽ­0>«×WŸu¿ß-Ö7ÝÛ}gNö°Åóûæ]\©u†±úcÝ™^Êýâú¢¨;&¾xÖ}å]Š‡ŽnCÕÖ9WÙ|½x¹›w´zU¶åME‹&0íöÛûËýý–t“ ë—Š«ú g‰v a]¯æ»AŸöß Õ/÷"ëœùàÆIçÜ°2Y7h`¾î ?¯ùôV…Ïu¼oÄu˜Kõ¯Ÿt)ót°Èp(§ººqð‹b¤Æ¨JÖÎ7^>:×öñ£g–.Ôôë#êmö€j¡žº]fd¯á#ÿŠ…›O\3‚wù. é¶póO@Ôi)´øiVôäì$?f‰OÓ,Ìçö »ÕºW|ŸžtÓ½r*jy¶r¤dfHfÉoP¢”\e諤ë#—sÞgo¢=fh”Mïþäóäzˆ ÿ ¿Ö®â= ŸÃñm•b°l³[4+†êϹÑКcÆ•²¬ýY¯ ±%3‡ºýM…‹÷íåãqè!%súq—$˜ôˆ'«÷ß~M†N!+ݯ#â¥Ãñß,Ü_×40ªÒÐ/_Ý㇉`®Œ¿/JAðLV¬”Bú°L÷© W]î†sÿÛnþ©H©X šÓ.ÑHÒ¡€$—p¥“4ž­nCÊ )ä¸(võÝÝÀkZèc»Ð¥D9ˆí/_-ÖWpM{¦XìÓŽQB†(ìv-p:Ã’lØßnçóŽ ˜¥ùÚí|×åŸNôF”Ü5¼lF㥟(úÓØ/´¿IÚ€u¼UíUÓ„5ýxD²l~ÉNÿÚÉ‘S×Eϱý–ÇÑ ©˜}½¾N0>u‡”ŠKxU…ïÛêÚ2*ª݈˜¬N¸ûδŸ½ï’ßq6¥·ƒ“À °ϳìÇçRMèGŽZ†ÐLUÆÒ•G[µW—›}äùŽF^ˆ8<Üþ ÉæG¡Bš5é‹ééKæk´Åzú”^Œ©ã©mÈVpV(“š^•Š ÙÛýþîó³³Ý›u¹%ãUtË™ðèæ[ Êr³½9{q†úrMvqö",©8€.‹Ëiæèµ÷^ÜÕ{¿v·½<[¯êýíÙÕÝëò¶ãÿO'ÿ 7_endstream endobj 149 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2827 >> stream xœÍViTSg¾¯ˆ¨\Sr˧UNÇ­më±êh]ZÅÖqAdßÔ°J@Ö$å’7¹YX-!$È¢a‹ Šh¡jµT´­­£Ck¥Ëé8ŽcÛù.½Ìt¾X·Î9zÎ̯ÉÉœ|ß½ßó=ïó<ï+ ¼<@à¿zÍÆ”¤¨ä`iTrÆœÙ/oŒKI£ÒÝK…|ôϲáH!øx‚W×ï|§û¡I¾×?žpü—&§,OMß“!‹ŠÎŽY—¸s·4iˆ &ëˆõD ±&6!Äfb±œ%Þ$fo+ˆ bñ6±šXC¬%. „ð" "Tðw‹çDÏó^s¼¬Â%ÂE)¢¿Œª"‡F_óŽ÷þxLþ˜ÕX)jö.'Úæävd †£ž39…Ù¢uP`Ñ4ó^ÃB S©³äB.hÕª|þÜÈ÷’´­‘y!:TrE"ÆäÜ™u¦zX¶Lo¸„ü%DüË Õ«uZZ“ ©€w»ØËpȹ¨TÌËDhº&ôýÅcK€“:?4ný);ׄAlt0¤›Pð¾›fgz-·&×l€e»¦úG 5ÀOQh¤—Á¢* ¥#x{Q¸‚€ÖH‘ˆEžW( ¤‹>ˆV ©?T_ï½p !…cù|ɯ»1,¼[èË1Š:n¶CÀÑ.±Mœÿ?ø Àâ™ü/¾54÷_íˆ"ç—ˆÕ …!ÉIá¡ÉÛ bì{e-;on³´—žqm=vÊÞG¡]f‹´E*7¨ãH|Û+¯2çðËNÞóÞ„òņ2½¥Õ©ån~ ï3ŸÀZàƒ[N¡îS¨…µœ$€Ogkù—È|³¯JÏÚÙIHi°,  µ ¥|õR‰´-êÔ à׿žu'¹“Aü´Ð<@¾è÷6D’¿RÎov¢™Žvæ×ùÝX7ðÎ ::èOçÎ )¾?µðï‹`[D†¬¼_BMæ_R©@ô ˜ÕE4Å,IT=âÛ‹EÂ|[ºh*¸ýÑPjÈmù h4³†)“¯?—Å7o)Ä@bMÖa¥ôl í‘ê>s >c¯îå… @ë|¤‰æ›Ð?tÓŸz[ÂM›šÒDb „É"mÈCBñ/þFBª4¼à À¨F±pÚ :SDÍ\ Pnn«G³$Uwú†> À ct2¹&M›Rç€jh¨07¹èÒ…Ã`ã^´ ÐŽ×OxrÐDqééôƒÊŠÔ¦¸’è’ò·+ËÞ7·6¾ È”s´R²° Ro²±“¬wY«Þ] Cž\«Uj˜]Ѽ/„)ƒÕ‰)µ²Æ´õ@¾Cû§\ùò¢­Q1‹€œ©}Ú/u•:£ @§b²e¼DÂäèTå`½¾ÖfÀ¸í6WT—Îhô}Tñ±³ê¡¨C ³P‘­ÎòCo ”×õÔåÖùSKÑOh¼¸´O˜.¢º 7É—ÆÇÅU߬ǑS‚¦ˆ0Gü~ïÉ›¿ý…©ZF&ùR´ƒ?ÉûFÞôè¸R~ñ~…ó„qJ;ý¨ û~} T–Ò“ôY„„”‹Ÿö¸,ÉüŠ¼×Ö¯\ô<0/é!)²}ùpÓ5Ð1y¯Ðéüô‚Ey³ÑL {ádcûys$nW:rœ¨êë?*•Ó ‰K{1¾Â`å†45&w»ô¦f&±tšÛ“]»Úê¶Ã|X¦X¥I²æÔC#ØkLõ† hÞ¡oní.o‚“Л÷ ©Žß¼ŬL¢ìܹEARŠùߥ_è‡Ó ÇIjI Su<Àöí»Aò¯v‹)Å̼E;ÃB!±µäTé{½ƒhùç;ÑYŠï ¨A´vÐó¡‘ÜáEØH[ÃöfŸF—%ØGx™:ò°Nt샊ŒæmŸþÆ(z±:^¾.!ÊQý8¸§_ñš/ü©ÃÜÇ\ ØäÌ(NÒe=—ÕHºÊm:]¬Ô«äüd^' BŽâ2Œ´©Þ609%¼“ ±ú$¶ø üWI"=4"H\/ݳ⠩ d@nu“±Âa¨2ÕçTe@ì)Ð$‘Ø„ª¶„S8mOõµô!àÞ¸.të«À-Ó“in™6ëªó»<ˆ–Æ|ëOqÜJ4G¡(F˨ÃgÉãa3,ÐH ©7£ERq&íݬF¨‡Z«é Iu]*_Ѿ8ÀÙ<‘ÉÏä'þy*"==ÈÇP†Ïö,uË°Çï+œíƾž?{ºûÝÑâûáp‹Û/1·Ë?rÿ}K,¥è”Ù|ÿÈ9 ?žëÓ8|k/h¤Âý¢Ïê„×G‰&µ(,ð~?ñf‰Ó0JŽ›è!®M¨¡Iÿô` ØÂ2 ËÁXb.G?•èE3F®¨´ŠÅ@ïÁ/<Ä^‚v Ûá#hcžpZ¯½‡Åå6¦lÅà%Õ± nÿc×Ýå~RUŠ'å•ÀK3ÚâêC0Xo:Ó2yq&OݘŠDpº[6)VI¨%„‰ÅL¶®¸ ‡¤:ˆíq¡²È¬¸úœCY‡-}–ÃfWŹ¶®ç‘æ3Ð yµá%9PÌd?.e’-Ã3 ßóA‹ wÕLÑæÀ9 „mx0×%;QÞon#Q“È,°vë¸Ûîj‘À qÍàŸšŽã ùÂEäÉÚÈD‹y%Τi·êZàÈùU,‰C®Eß節ªEP+¯õ{·§ójøÕ­=á=[®"áÕÔèñ§¼<¸“ÜT1kU7Åb]†«C£Ij4ÑÍÊfÁ‚‹Ij²BQgÏÌËÛ³K¨‘Zâ³VçÄDªcp ,[.ÿzò @Þ€¼º+¯™[5Ýa$•!iܾ֤㮯ÒK¹NS“Þh¬­©iI9ÌØà;¸>Pù¹ÙUè’Õv¶¸Lոװ:R®U)ŠåLN¹¼ ÊÀnakI~3Oˆµ©êÝYéJyjJ ”€x ªþf¬%)cj07ÙêÊ*;à+Èùƒ6ƒ<12F\²pÛ4x Öu—žÆQµÄr¬Ëu”Å¿ÏŠp7ò‚ü¹ä£ÑŠ~ œ‡ÓÕÀ³¦«y²N–@êDBêö“zš;b}Æ„Uý¯€~Ú|õ‹@|îמ.íD‚Ÿüõ×ôkÿáOÕ!À`Vc²´Óç9O!õ!?Ÿù!”¨‹BépÞñøLO¶ZŠ[t4åwŒ»+66d×'ÁNHOѦkRmi¡êubðþa(íþÍ'÷£–~êW‚‹$Ÿ¦§£•:ƒÖ¬gi0Þ8WQr¥ûˆÁ®Ç±—Ä@ $ÀZC¾÷éJÅÚ¬\y¡ŠŸËûJ®sxœ|*3,cìz½Ao0èK ìyðñ#ˆHjù­endstream endobj 150 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 833 >> stream xœ…’mLSgÇŸÛö>«µA¼¥mÀųù’Æ—‘H²Äˆ`*(ঠƒ€‹"oV|`!¨=ím(³´@l‘qSî¢_Ð1~˜Ltj”#‰¬N›Ç„Ý뾚ì$ÏINž“óÿü@ :"BjîÖµÕe5Y•Õû×~îØ^~p}C¥öcoâE‰‰<Ìz0&óÒÃÅ-º•L´ëíÛQMH>ÙIrÈ:²Pu1°`ºR½ G“æu«e‹ü$”ª iiÒ‹˜2)V–ŸB§e?Ëü›`/”6—Õµ±å<»­­¸ú tÒöxÛ:™÷Ëw]b6u£$£ä *jÁvEpÓsÔ5v4~tWyJêa¾t[Ñn(…úáæÈe Û"#ãƒWàD¾>“æ…óÓ¼¥6*½@A˜deyñ²¸Árjª`h”@‰óÀf£—ö<Ù(ÏT¡nBÜöoøMU¾­™<˜ÇÞ­ˆ_ÐæˆLºwúŠÏÒ;jÚË>: ÃíïšÐt×ÊšnLÁº¨ôÉ·Hü(-EbeuqO> stream xœÔ+þLMMathItalic6-Regular‹ù“ù?‹ ‹ ¸ø9ÒÍÉxLY-ÈT÷¬ÿ¹ê«›ç÷««Êí÷ûíøë÷$‹Š™y}‰„‚ˆn4Dka‹ep¡µž¡”®«÷•² £™š£ž«‹‹©‹¡|hƒn‹|k¥„™¨¨£²ÁP£XIcXx€~¤e¸@‹ûGû h†‚™™Ž‘”Ž¤Üϲ¼‹¼škj‹‚ƒlt.u0†|egia‹…‹o‹tš²˜¬‹“¥w˜womubRÊvºÄ´²ªžŸa»oÄ‹÷ Í÷ ¬ÿNJ‹²øñ²ù“÷•ƒ‘€~ˆ„†^ûY,ûH‹ûx‹‰‹Ž÷ø“¬”ñ‹£—‹¤Ž‰—|sqˆ‹s8ŠFŒt‹qŽt‹…{‹r|˜‹ž¤‹„ ‹‹…‡{ûü‚g‰„@‹t~‹r|˜‹ø¦¥‹ŒŒ’ž•¤Ù÷\‹‘v øC•––÷p « °  To ‹ ‹ ©ŒŒŽšœ•Œ“ ‹ ªÍÑßendstream endobj 152 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 333 >> stream xœB½þLMMathSymbols8-Regular‹‹ùtøe‹ ‹ ·÷¨âÝÙ asteriskmath¦‡,·÷¬ÿ:f÷w¹ùt÷Ž¢u‹}üÓ}u‹tt¡‹™øÓ™¡‹¢ÿBøa÷1‹‘û%Ë÷$Ë•˜‘‹ž‘‰¤hû%(š÷+œˆ¢o‹y‹}|Ž}šû,ûå~”…‹‡‹y{|x˜…•‡÷$Lû$K‡~…‹x…r®÷%î|û0†‡„”t£‹¦‹¡‰œ}÷+÷;¥y‹“‹—›š•³ù§²¡¹ ¹  W/ ‹ ‹ §Ž“Œ‘ŒŒ– ‹ w·‚Èendstream endobj 153 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 6882 >> stream xœ•z xSÕÖö)%‡cA =†žZEDäâ2[+S+`B[¦ÎÒ!I›fj’ÕLMÓthKçR'fD €b…ë@U¼~âpõîãÝøüÿ>I)´þÞïþ4ž½wö^{­w½ë]'õ¢†¡¼¼¼Æ,[¾<5%uuÒÖ”Ìç§?·*:6+ikº036çò¿ý*‚Þ0bè;cŸ¦üÐq_ôü¨ÏG ó£Ó²R3£3âSb“¢§efæˆÿÿ \&w)`{ÀG³½øæØ Ç| {|ÔãqÇŒ[3®aÜ'ÌO|úäò'UOž?|ü¬ñ[ÇkÆïÿÝSA¨s$ßÎ:ù'³½:Ðߣ7¼yC›ØX®³+,SÈ ž¯ãô{åÅIREãè»õœ2A£/Ш õùÚäf¨ægºÁÒfiφX8ðOͤ-OÅB6h“´ÉP#¬©†f²†ÁcÑ:1æhäƒ.ˆÜ6 ³Îp§ß¿\(Üå϶òmbK{:9‰¢÷!YõOQo̓€¥°.>+‡a]SåöÀ`Z éd{Á‚ `Þ¡#ðYQÔÀAô"]á>³»6´HĶþXucïÑÀãPšZøF4Îævôl·ûcÏõ}ŒñX'q¢H§ßO®r¸Ð×Vbä»| š+.sÅ|0¿ö£†ãÇìgW6ÝÄÞÀ` -‡4Ð&k“š  ˜Ýôì»rÑÎA†h6‰àZoùuf+: VoÛ2˜ tŠ!_š½ø”-×&0;ñ>±jÆ°—ÈÎ,½IDèqšòÔ«"û4Nô‰Ó‹”$®G¾ îà¡ ¼¼&K°¯³ŸNEC@xy_ü˜%%bÙ´  WáUØp­òvå7p .ÃñPÙta3…“·9½¾q¡_]Þ|)š'¶vf€”$âꔌgfflƒé°ä·&4¥ =óëo½Àœ9¸yθâ<ƒ´ ºÁTo®Û…Æq¦*sS2䂺P£Ö>/=¥ekÝ:ÀbÀøÑdšŒ_ïÅ¢1€ø©·òkápœîDs¢,\t¥»ö¸Ô®_‰¯GS|½ûv£‚x6ÂÆÜI ;jµ@EôŸqÀ¨î¶ü%VMµ[Ù³Š(ºmëÚz@ÙÈ èõˆeaƒ©g¥sB·ì[¶CŽ+ë«8m¿pü\àUx7Xö’`/úY‚f{ñ“ùëbcƒ¬6-iÈÎÓd*–BU¯ë2 cöA غMõF;WvÜñ^Åq£Íd/¶=pß«N¿]HäjréÈeÕ¼‡øgxÝ@ßæOˆØ¼Z“¹!>0tyšè¬Ö˜æUîûL%ñ•àÑקø~Çzšv1ìÝXœ(Ú@Ë„»6 DséJhîþ?F¬\µlölÿµ+¿®üö¦ë3`Ø!× c"¤ïYN%¤c¹ ­w%£îòÖâÊ^S-1â H¢Ë.XÌá:È,ò§ÕÛtÒnèsƒ©¶ê6gª5‘…q —ª·1ØŸ€:J„ô4{P¹V—S”ÕÝ`®7Õ¿ZÚ‹ìñÀÜ}ˆ˜ìÉšf¨¦Í5ÉÄ òãèN(-µt0°zÙ…ä_ø³“ùƒüp±©Nûæ,XKsC–Y»8ÖÕn!ûâ!=rÃÍs¹©‚¸ÉÃi„ûìM“Œ±“¿«ºö=z8P—QžÝ °«Ê²»Ï‚á准ºV ÔDþògoóyØqÅs³€»¾/ÑI³ÿî–0pMë‹Q_è#è=(A„ÆþÙµf·kun׎õ¬2ÑýŽe¿ô¸ö>5 ?'’9½ùLä+®þ'ö­O²„8¸sˆ£dŸ¹¹§ýðw(M6¤éó yíÐgtçphä:õ¶ú(È<bgkb¥û%¯W~Hu=_¹V³%a:l‚5e×}¾, <èNátÒ¢ô6(…ªâšž·bë[½ïþÝv¨Ï´ˆã]a®p×mâµb>ù‰M5æú8H­D—§XV˜  ô˜¹‰a·ìGJš5ÐIlžE³LÅMà2uäl2,Ÿ-z©ß¿M‚ÙÞ[ô6¬“>{6ö \…[oUöz €ä‡V i»Ð4v'_Ñ.¶´¥˜Hú=t³/Žâ™X/bßy^6« 1pX;-ï ]÷ðü§Õ[p©ôÙ2ÈÙà-û†]šXT5Wè*áJíDñr0%ÉB¨‚ RôM^.BÔ |î˜3d^Y=pxoßÇ„ª%¼!x´þ&ZïÍŸç'Ü£üÐÀdh¡ñËøZ8º&jès²PJ`ÑïØ6ú¾m¯ƒz¨…]P݉‚Ðw\Û=Ê!‡}ŒŽ:½þŽ6~‡6zó—ù§‰3Hy`ð0:WØ‹º j9LOÂGEšµïj¨ÎÊâ  Ož¥U/ë³­GGE‡ûåF&™}p›zh3îå2A¶¿¥ÔÙòøþ[¦Š’¦˜.Š¨ÁU¥y5à€°VÙƒz¹6b¹Çýn,\rú±[øzéÄË[AiQ›ö $®ìÒöÏñØOCA°6¹VÚH®ßZZÒc´×+ŠË Ø?†ƒI ñ"æÖKŸeXÅbűП{à\ɱv† Jª>dØØBX„‰§þ"ÖeI¶æ’…y;"A¸⺬ûJÛƒž6÷Óœ_ڀǠ òÏ´ÁŸ½Âëûѱžˆf qh²h?)q»ÀÇý6ñé¹°ŸšÝ'xîæY‘v_øì§oãÉøYãÓ¸bÚ´¹‡óÍ™%ÑfµYU¦v@9TÚÊ*ÌVÄ"kýqÂ&sï¦yö ´Q?‘|$ ßï²ëŸ®[²eå ÞúWee'~!µ5ºj `/"óGØ–\ò[àI8¸»£•aƒc5zùþûµ³èe1Û½Z6kAàBØx©²·êû\„ó°oµ2Ücœùø z„ÐÛN^Ò»\Pê s’×­V¦B„ÑÉ £t=ackO-¢7þ€ÇN ™$Á£¶Ìþ|""Î~M ó&4^Œkéæ+½wŽÁ©tÕ„~ÚB¾$׺ò\‹¿ZàB>_ù³ÛøÝü ±ýÌ\‚™¹0s³ü%åZnÒ J½ô'šµúlâ BÖ8°þM¤Ù¥ÇÐY9Hã‘4û´í`ùõ ¤ŠL;º¡šª,-îLÍ=ƒ^}ÿ½3è•3Égü*OpI]k‰yÛ§Vº$§ÜÇ%ž›wÉÛ×ögƒ!"ža/ì(“'Ön|^’ÏToq$”åäKó³´Éš8{zIÁìHŽB>ã+Ð# ¼†­øÂÚ£<²i7£(ÙÑð<0‹häƒÚ(#Ž/¬PV˜€˜ëE›ÍV;Ã>¡Ó»2~ _\&ò„}!ÌÒVÔZвËÑh®(.ÞÙ ¶“n»ÉAÒoÄÞDÊGDEÀˆ?Xzœa?ý¾ýèÛÇO@×&åZæÆbuÔì-“`,y«ämSMeGw]KU)\!‡RC{ ™‚lF_´Ühõr·àÞÿ±oG+þ’¶ŽüoZðªIÿ ÿuî‘Ùÿ#4$´k©ËâŠ&Õ«à»o‹-BƒZ(<’H6¨”1y ¶ww`Ê~ÎhÓîRµæÔ”]îiu–¨ørùMìCxwÑ@&or›ž>p ˆ«t·Ø¾N×PíN­•e©·]I)BµÉ‰ ûE²£IÚxº?,ÙËLB¿Î=|åt`^sò2Í~I} ]aªý)rõG?dråÿèϺø-ý%}üº”"wï‚Ô?º§òØÉkø±¹%·!•ø"-«(U›Z“ÕBúÐæO¸»|¿Ï\.áXš#¶ŸOySY·?­$¨f~ ·Ý‘Øm;XzôýC—ù€á¹â$C–]S××4 ®¯ÅÏU^~r\w„ƒPº7¼8O6S±´;äÓ ä½“Û­ù4›$xÄÚ°yÄæ¸Ý [½Ûô¦±ÆXm¬Iìk²0××+0¬¥J+*:º“OIÏ ¾ºåQ餸’Š¾Sp×®Þ˜^ôˆ«˜¸,ý%¾Ì/¾ç© C/¾ûœ>OD0’F¹‘a™bS±±¸„a¶˜³«%¬!ÒóŠRò_ùzN¢eçImý‰ÿþ?º²Ogx¹”DexŽ". ã¯héPª4 {§ x@ÿ[zœCnèE jE_Ü ºŽÔ@ߧÚáN¿f´Ï"ï'NÚ¸‚ü'‚¼Ù“þìñ ÞÞ­$3h-†‰ºû!¤h·Ù@©­_2y z>rÛŒñ´@âAÃç{ÎDÃ…—?{˜¯ñ(ŒX8€´œ©Ž¾ ¶äÇíPv¥×$e(OÍbØm¦lÈ LìOÉzØ$¹Ø>M᦯[ýuJز -áØý•‡ÜeyŠÐXÎå<Èw×þôÊ^²þ—åÂmf9ÑáåÅGFˆ-­éÅJÀ&ëKûn4ƒ37™¬o{·©¾ÓÒ$d­¹©d¿ÙÖ¸·×Ø V¨·š¯æÂ"’½ù‰/ê5ªõÚTÙóœ&V'‹–î­'y¡‰¦(C›Üh°C³Q:õšx§MVELÙ›yB}ÜÝؽv¤ÌöC¯÷= YݹéôW|µ‡7r@U .ˆ˜¹F‘­gX—Ô ÑkS‹Ò«µ•Dy¼i=ºwáÝ9ÜôA|lE^G.B°‘q@lnî6¥ËѦ2XItQ׎ì¿|òýóåŸÕ¡/^Ã#pÿ´Ùò™š˜fE5Ñ‘ÍÕæ£C_®*ix÷xû{DÄk³ìEÅ¢°•AáØ‚Wp •F«“÷=ÊEß> ÷ûÖ¹Þ'VT¢SB[[\ÅØËXr²ÍåÌ-¶w6µF5/7ÇAž'„iµE€Ókbµ ;ñ N½Ýž¸/sEbá&CQ ^ÌiS4±x¢¾Ïëäàjø ~¨k½a´ÚŽXZ*¿æ¬{L•{«öU*nì ¢‡Ô‘ñ<Úàô»Ð[ÜKT×&âýÞŠ‚ÅŽK1§W´ÝÓó~é‰ò«Ë/àa€GÀü‹µ ò:·,-ÆŠ"»ÎÔÓ~‰t±ÌGðv¬*R›,‰KΊIK×ÇêWÉ@›Ò—ôïÒléØ¿´peእ˦Ãv*Ë=hµØ¬¤¿j”Õ¥ªM—ie/|µä?}[y[°’W¢¯Äƪ‚*)©Új­JŸš"•“ú­.U8 ËóHs¶’¤éy™²„,]®^ê’óÊ „ìÝÝÒRUv(Q–”åWIºHÃÖ^Õ\ÝPÙÙ`ªéKmÊÉ?FÐ÷ùÉè“›OšHrÇðMhã=Χ ‘Y;56•Tš`Ë—÷ãsŠ|ƒ^—­I°©ÛŠ,D‚æbJ´|—äåå4Zƒ(" ú‰ç·‹q:ºÐÏ"OPÚhê‘b´J\ýÓŠ ã R™ÕVqH=èùJƒP.”ÚÄ(\Ëér‹2;HzY,¥öÎŽ·kNÁMè V„ÊçÎyãeR’–ÛrÞ³ZJKHÜš]%F‰JÍù¬Ë‹ÐP@¾€è¯k‘w>†œECÏ’æÊ‹_L¬´FLˆ.¸ϋض=‰¨›·  *f­F«Ñó3*³›‰}¤wk³Þyb ±ðQÀÓðÃñ8r;.ü1øŽ»/ú9É1Ò—Ëg¼²ê5…äÃ…NM£µÑXa?ë:ò1Ü€7—æ¿*b—𧈠WùOú)ýï´®*TEYºõVÎSäºÁTKÊ,ª¦ñ¼l!Þ™‹‡èåš„n’µe–Öc¨…¢àK§wÕ¦Š{YàD›~W\jR¸âHLqgAùµÕ§Õ¾ûÄáÒ÷+n¾v]hjFÀ”yò9ÊU=믥1ì•y’à°ü é”ë/ žóƒݪú&í®ZLpÑ kÞ)=Yzìü¡Oá:Þ¨Œ`âñ>±bñ+«g‘ùðY°úd™Ëîtû¾…w—®pQpôâóùóbûÁD[>ä@’¢(J‚£8½ $-Ä»¶s5©lhË^á¹à쳨‡ÐÎ(WÇõ $Žuèñ~¤™ìš*H0U›” Öà…ó¢ó*#z*ÐŒГ¡²Îc‰Õ÷nwëì$M<—œ¼ sÿÝÉW~Ÿ$6ÕúË‚B™*ÿîÊ?s…RTº\G^¡{¥­œ_ùûbÎ^U ž<òüV¹å)q;Z1ùÅ#|>Êý«IxÅgØ_ø ¢˜F¡GÛP(³´LœŽ'ÏÄ>óa>D"Ÿ&4¹MüòÎU¸ÇŸÉÀ“˜‘Š2þµ24¿Ì\F;}\Ã÷ž:â!á#†ï­² ,ufëˆ0¢þ/t‘i†endstream endobj 154 0 obj << /Filter /FlateDecode /Length 3558 >> stream xœÅZYoÉγŸBàa"¶û>6QÀl°^`½ò :Àˆ¢hn†"MR–• ÿ6?$U}Ìt‡’lç°›ì驪®ó«j¾QÂFÿÆÿg«:Zœ¼?a~uÿ›­F¼8yùFIX!Ž:6º¸9 ¯°×’P©FFâ„]¬N.«×õv¿¼O„à°¨«×ÿš¹&N:Y½SB•0Œºª™Ãǵb¢ÚŽß^üØ0“³áHV)`uq}R‰ñÅÏ°E°‘#Ns;&RP¢„M„"VkÜxY]ò³·ã‰âŠP -ˆ`ÌÍ'ÌŒ'’9xÙU“ïnoº ,Ž[8¥á9ŠÄJÒ|rñ ,JÊNqú(eC¬¡rˆ²''sr’¦Ì‚*çìQr*'§ˆæ†…½Œ*P<«±Lóù„rÜÇveNš|#Ï7vjp­tÎHƒÜRõ …ç.I"g}FíÆ!}›œ‘…yïD–XJÁºTdŒá®”ˆç‘ÑD.¨Õ£IË|Œ„?èiíçq/µÅ^t3Å‚xÈVý¸ànþ[(AÑO¤ŸÖ8FZGÞŸC‹VÍ\‰œ“…úyœ1˜’SfP®dÎÉæ˜ùLAÀp‘Ís©œ¾% ùsOÒ®eäuN¶p‰[Ä“ï'?kZ ]„Ì)-‡¤°ÜaôCn´é3F†¬¶óñw9A•­>Œq‹S¦*–ë’sGkñÕx¢d2gªŠË}ž­ã#ˬ¶®#OU­ŠÅ+ëñÄo⪺ΖÏàeÅáð¼jÖ ¶‰gѼZ·tEÉïã&{Å<æ Ð_TwÙ¦ÛìóòÆQNZ ͉:ž9·L¤ó@n¯¿‹\õÞa€™³¦ý u¡º ~ Y)ô,ÿRçßµR+8P“mJKG\bÜ)×QxÒ¾¢cp7-^m©2FËÝry©/uœSb–/t8kƒ†ÚÈ5R‹Ò ŽD.ª‹ P—®É´IÚŠž%ó¹Ü6ódÂqõíõý8'Š3–ìWÈñÒr^F)œíÕ<îÑÇl¹Ë¨Ô¹: Õ®ý¹¬qÕÇå |´øA"]úÏPKµ|Ì€Æ ,•~Ò€ñK0``‘óÙÇMgEZÊu•d‡P´Ðutt!ÌY`ÉÕæf;hJM´Ómªyòà±Þ´žŒ>CŽŠù<}TÞüè9Ø%¤¯¦T.C²t¶gö¾Ù:«øŠ•Þ‘ªs ƒÞ ! Ö9“ë¸ Âö~ì+ ”…$佬r郤۞Ãn—ÅVÏ=®Â嶻ø^ȨM›=/æبƒj·‚S)*Ù¿,/Bk"~¬¾8¢ kãwšÓ.|Ë{­bå}I …{ê!‚ę̈tæ° u!$ª¶ %„ð â¸kõl:&¡kÀYΤ"ü—(àßhn$Ëø³)9Ô 6¸ŽrÀ)ˆ9Â.3¨f‰z±§Ê¸¦<©ùÅîkqú£€8¼À ä£zð›@½C°äåÍó›A<3 }M¸åï›?$ øA†Í§´œNÇ]éhpìô!¹CW@¸q"¹žCo -/‚jþq³bþ«Š¸°kÓÚÖKšðf¿-††EÂç,o‰Î±ëˤޑۻՂnÚ s\<ÚYÚi+h¦cü;tXOß´uÉR ¶oE òøÂÓ=A*s˜ ÀŽŠÐ=ÝžÊ"Å¢bq“û@îÚÍ>RÅÔ—çfLpÊÏtÖ'nbE§1ˆã°Ê' ¬<àãúJlòñç¶ATÍzYtŸƒÍmõ4‚è©xO†*ð1CÒç`¬Ú­ÓgÈ˲ Q}ñ¥×% m™<@9í C°r«J)$ÕKö MQÒ0‚0ïV>Agq= a‹Z°®€ —US¤Í~†üȽ§Ý>¡¬]Tšøìæôs+Á`øv¹(*lß³_]œüx¨j´=>8ípœ2ÈEJñ¥ðb»šHö“éA^‚òœ‘»¬>,ww:pÃe9öX 4ü÷Pê¾xˆ <¢9H#¸®úS†ƒ¶Ðo3|¨/ü½I1š†–ófp9 Q!·~ÞÆŸ©6€<à'=½­oðçÅaèðÁ/f˜yxô󳑴­Ò8x`S5GZáíI;.0Tú¡Ï°ˆæ“²}D½‘ª³ªhbê]‰B½<„(gVyýåH®×v!Ž®eCG~àZ¸ndµª¡ç ý(?— 18êkÝMøìÔáè"ÚêΠ÷Ú?ù{¼HBcmÃXA2º3fhÇ|+pÿd¦‰šÛ¥cö®At^ýêÈ«n;3ÁVd%uI ðv(íkF$“me ®d;6=+¦ ¡öÚG/#ŽõÂg{ù¾ÀôÞ Ї`.ý©…¿A‚v!väa÷PG-´ïÈËôó •ܪmÂæ&ÖwÆÌÏØüS+‚Sù +{hÄÊQ{…½æYdj&¤JI1AþM³ÞÃqÉî,!XpŒ«Ý´ÚšozÓ€{ÿ°™w(÷<>°¬:mNϺ`ôË]NÛuгÙ?œ7ûvAWÍýõ¹ïrÓÂÇÛ !‰ê\¢‡£ÛÚ] jýq¾;ÿö›ïzqô¤'§;„èÍ|1¿½žV§ûõæ4© [Þù"ãß;™~ÆÉ®`Çéíi”¤wk‘Kp½­ïɪž½{µÙuüý¤Ûqsw;Ã@#7›w5¹éΟ©‚½¥Äƒ6¬¯¾ÛíáéºÓ«¦žý­;6K |'uõÁ /ð^ßT_5Ë[èjÞ%Î*gF^ñàù¯¯×wWÍœÌ7»–WTêºÕ¦Ag"j ÕÙÜXfUïϾ[_Í›ó÷wPë¦iRßý—%wÄ‚Ù9å¾, Bâ_,–™Ó»<œ¯Æ\5¤ó{,Ž8õ/‰É2¢CÃðÒ  ñ ÆB^E=Yß?á{>ú•a9tè’3®Ë~¡]Ä:ÅŒ­öEð*C÷{1XCy¯yˆf¬ÂÕL˜¶¯Á Î÷ÅvÑ´o=Ò~—`+Ÿc´X/µ“H¯‚G2]=¤qã¤üoKq±²8$¸³„q–F‚dÕÜ€²Ùvóõ‘Éà yh¤K‡ÛšÒ7„Ù8r¬¾ ;ÊÑš€Ê G‹3B10$ÉÛÏy±„´û•¤t:~É•~ªönëa"€§võf`ød°j;o^ù1Þ8«R%ÁvòVRÜÖ—gööxrW6OîRCÜA¹».fd–ñ ·…|&u¸??š ‹ùÑ"¾æJ´âGjI;ú²ZÂ%*@{­¾xDÁ•"šÄŒ^¸…†Ê‚íUqQâk²µ:T-½WÔE§HSíV1çyXŽír4ÊÁ%!¾ †Ñ|"'ËÔR(9äqÖo)vé,´ì\wƒ†u÷ñ¹ó·"”½°{݃9þtbÁ )@óf´ÂßÎ ü”Vš“ŸŽÌ 7Fçör‚Hà5bX"Œìf-/ßH5²Ø÷KÿËÂ5ú‚Xj],%ß\íÖÍ`Xôh¼ýGuKDÝÅ嶛·Ö»„k˜&a‡.Ìlü5Hì¸c 3y¯%ð÷g$âÌ1ésÔ/QN<’v Ã^ôåD€jrÂ%¼ê_œVáM?è!Âßµà“¿†£š‘˜`¦2T nçÍ€’‘PeS—¸ôˆ–1qW?=E°£-Øß^°Ñ¢Ûò‹.´$m•ª'EMóùgÉÚJ›“ªÒý"¥:†…¹ÚV˜ø;Ò܉·ìЉ†@;ÊŸGtÐÙ€5ÑJY]Ú¸T#Ì@/ô,÷ERÿO÷=nÊ/rˆ§$aZ>åRØ盎šÂráV@Àý»9Tå¶J)Âÿ§xYùa™¦þZé<|D ëdžX] 58óÄ!©¡opò)~­n#?Èô¦Šôž=þ/ŒK’bXcð—E®…$æYä9K¤+¹à ¨|þ\øþDrß“ÍÖA_BA«6Pé®ÃC’õlv·­÷s©%Ãhò*T5.ª´hÉü`D™Öaó2ÝijBpœÙäüoºŸßǸàڎᲕ4X$ ¿ijñãÉ¿ô–™òendstream endobj 155 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1061 >> stream xœ-’}LuÇï(t7¨cºÐÄÜgœÿÿYfœÎI&qÁ07^d€ŽŽµ£Ph{Ç[ß ¥}Êõ Ž–RJéñRƘ°0y™Ë˜c‹›²HDÿ ƸÍdš¨qÉò;8¢‹¿?Ÿ_ò}>Ïóyp,5ÃqüÀÅÅ5-ç‹Zj´õŸ¾™÷Ñ9µA[£ßýQÈn¶li "ua{:ëç×3ïíÇvŸüD ]§>†a‡°w±2ì=¬Ûí‘"±Tì!îHÉOÙ”éeshzß¿)¾| ¦ÐÒZ¼Œou-ÊôaZØ 4¹ã’›¬ÀtöÈ7 ®ïñ8Á=àr0¢jg2ǦvÙò -Àt³]Ü’ÇÓO=3‡uwN&\ ‚!ˆ†¬`ô6SZÖå…zï!6çùzجéq3ÝÍ”Ó,eádmçñE¼ä-¤õx{ýàSù«ÅÕÕê$MÇtíGx]þb$A…H9ÊŠ_x§ÞÑvÊîëê𢽤4]n+fá…C<>ÿ½LàÐA¥¯'`5»´“46\Ô¡ïNć}±¾Š:‰öxÃþ°ªHgˆéÔÛë$}E;V„HˆJ‘óÄ”ïN¯}sse8Bq¥_2—`øP|>:þ¼„øÊW–‹§4¸Ûh•ºº¶©ˆòÖ×®KÙ‰eêÒÝÅϯ±6øV—ÃÕívRã ¯Ä8ø•=äñä´ñ›Lðÿjq;Û¤¡ ¤ì4 ÑåxøVß,5TW’7o€* Ã=ƒÖº.‹Ú :ÜÊOŒ'fËF+OžÿØh&éëgù rKÄì&[ 'ÐÇúü½ÔÔŸßNÍ19FWª«ÅÔ]{±¸L` Xýã¾Ø(Œ<ÍÑ MúúòÓüêååñA’/ºca·Ñ„DŽ?ýkøÈcA7…^yáñ‰þ‰LXÝÊT.œå+«ª4µFÒPÝõ™QÌ ä´Y:'¢Ôù‘SæÒ¶ã j“ßä½ü$Ÿ7mÔÎ}²Ø<ÿ÷:úK„\CÏÒ~•ÇúŸ_M‘swÃ?…VúæáøaÔ5d69¸@è‡-ÃãñYI<þ{ö.*ä…—x|ã™°·P‰äBuÚ®ÙV£Y'muV¯•Ì¾ fŠ/‹¹ywŠ6®òÉiª³´­ÐÎ8,ê7^•V¢ñèÃÁ¡8ŒñÖ°±EÃÔ–eÞDÊû2!d++Å“NÆí’„Ÿ)©±›$áÌòÂ\¥&W©±¥/®-qè¸m×5þãv» ¿-” •[ZeÈÚgépÚ]nR|öÏûÝàPuöÛ¸þ 7 Ñ_ÛoûÃà•Šû q¡€ã8¤‹Ëùô‰ 2=µT§Ø ŠtPdð,Ë=¾°Ÿe# (²0ì?ᬠEendstream endobj 156 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 169 >> stream xœcd`ab`dd÷ñõM,É®ÌMÊÏ)¶Ô JM/ÍI,IItwÿŒù¾„µ›‡¹›‡eûw.¡ ‚gùO 0€#/c`bddÑù¾†ï?³|Ã÷ÊmŒ@ }¢ +º«åþ`«-ë.+×=[þǶ™ ºÈó5NÝ<á§ÐòM Ù¶qmã–ãb×çáìæáêæá^ÒÓÛ7­§wâ„þÞ)<<Ý> stream xœí}M$G’ݺõiö “.‰Kö‚•þ>ØYH ,$" èÐ= »›Íš­êâTÕ Ù:è·ë=3óH³¬,’Í& Ðpºòå wsssóî‘ÚM‡´›ø?û÷Õͳi÷öÙŸž%AwöÏ«›Ýï¿zö_¤È¡O=í¾úæ™^’vkÚ-m9ôÒv_Ý<Û×ç_ýÜV=·´CšWпzýìÅþŸžgð×\ö¯ž_L‡©õ2µ5~øósþ]×Üûþîòáÿîúýó‹R2Š˜÷ÿ|{ó£êe­×uÝ?\½sŸÞ>ÿÃWÿú¸)ÖºÕìúöíó‹TSZóþå>k’¿&χ¬ìÿF{R¦ü9Š´š¯i×ýßɧ:÷¾ üóŇËÿõ™ThÿGcçnV¥T«Î¥U'”×Ë´íäãkë£R÷_³¿§Ò÷Òo¸Ù„ÎùVú¦,iêf£9Ïs^´‘möw^ÖÃ’—qã/¬ÇõÚoÜßwf¢GÎ7-m\í¯½|%žXàGÿ~ùö´ÿå«gÿ…-ëîí=ÇDJõ0÷]ÑCË® e‡Üwy™êaÍ»»7»ÿµ{S®ó4×Ý÷ÿŠÿþø e¢7–Còî‹A¯¥õ€Í°'ÜxwÆš‰,é€ú_©Ë!5 uæˆÌé0 Ê›YfXv7¯@J¤ã»NꇚˆTT÷˜{›U®ªø®t\Õåj"…’Û™H]p¬¹çz(Y9³¡óÒp/-gY9³œ‰w Òl3¯µØ­Ú4n¾±‘LcìæÕY¤¡=„›/&@í´Á¼ü+õksÅ e:dEà•È»i1õc«0¦g¹Õ<-‡‚ê,k7{Íõ#‚òºÜk.°nc«ª•<£}KaÉËàÌíy¯”Í:¨Èa‚¨3^Ù@PûA̵L+o:Ç.7_ræ_󛬊”åPqó¹æC•*/-:LŠÞ‚› 2Ï쀙Õ/+ÿ˜¥R tù Hf·Y§ŽQ¿Ã%íPÅ8+º1±6j®ã W$ÒʱW-‡Yê·"ô4Þ;¡žÊ¡4Ô@[MÂhôj^Û9ò‘löìêSsƒ=“Ûѯ+,ÜR3§è°~á­úPÕg z"¥ZoöÕë¼jUC ˆ²ž-ƒÚió<¡ƒÚT1,RѺáæeíj›<ÕtÀ(œk—G¤µ)è¹´ 0÷Cg)ü‡ŸÑ….0yÕbÑ^Ž—J'f+sB$ÎD0¶¤M9!¶,¬Lmj‰œÐÍô£Šv¯RáÄëQ0B‹xDNþ`”jžŸÑ+‡&”™ö’'F0Öff­ˆàrºQ©,@†E`àÂ$$ÊEpcL!‚9›£¥À©KÆHBœ™Yšš3¯³Œ–‚¶ÉPÍeJ2Z2\Dn]Д¹i E0ÒSa1“ºD.]`´v44f›µRÏeAõˆÀM9ë"c%Ã'ÕuÊôe\UØD`’•gl¹ª–$cŽ`ýOã£`8ØAêRgñö‘€žBdAíHA'«+|…cZÇJnS‘À›ÖdWÑ 'Ü›]*AÍx¼©Kmº£Ã  ñMmÓÀx'† iC[P?Ôgê……H—Á5§lƒ#Ï:À3ëàÈh] 1PêNœÃeZWsQÄ&‰¼“ÞÚÜxw¦cz†$#ïTè2û´ŽÁ¡]Ã`sc€ÃpÒô¼²:ZE9£}×VÄ7-wûÂ5‘ TkÕ2Ú õ¶j(Î 8Lë°rÖbpS ¦Ö1î$²ÁcpŽb"à(³édο"€ÃNˆ7cà­ˆ”ð"plzƒWö S‹+î!ƒ«à⊠0fCšÜª#€—¢·’É,w4p•›/ü—FO–¦‹KAGèm+¿Ñr8æfvV³‚W‰Áˆ¢þK³ƒt¬3òŠåæeÊU?J³Ë„ð!ÓfÎáU&Ó <ªëh-ÌV IŠ¬Ìw‰XT-t*D^”3i}KÂÀ…+µÆ’Î+tEÔ…a_f2ăÎØ JÒ~A¨3mÑàDQß5Îó2w ça¢©-¼ñæ³õ]AåxÂU6•L7ëZÁ9 oE´l˜Hí^cÉJCpåÌbI)§h9+HV¢$mMA˜Ñ ¨ ã\R†ÌˆÈÉæ*¶Mã rí̃EE×Q^Š¦U­Ís‰ ^µ©œOåNe•‰£5„ØE\ð+WÉx-•] ‘z‘‚+‚8þj O\q´°0IαDh&"ŒÇróŠ[$–3Ùè,ÀCFB–øNCxä©0¶Œé™¸WŠiðD:S¥ë(Re’iuêæpˆÃJVÊZ0â8âZc:+¡ °vÂÉ­¬U³Z$µ3É(FƒPÁd"†³BR„—âèDë_,ièöÈ,n–q¼É½‹Õx¦‹fsø¸ ˆóŠdé4Ö ã)(͆ÐR$’u€—1†•«¬ÄpÆÞR- / ",LÉ’žAû‘ª4ÌÕVΊÞˆXŽ[Væ è]Îæ:W„pÄ8:„pÆÞÌÆêUá7G<ÕÉ óäÌØ‹8mÃwEgìÍeŒ…_È)–•Žz1öNmÑ)«Æp êá ½ &×NèáèÖ8lYؘ††Lì…³/–.:¢ê/ÄÊ¥TfâD`$,'8d‰`:bàM˜ŒfÐeUÊ­:¢*VTx'´RæÍ:qŽÀb¬w«^å Êá’àæb¾šÀ“Tgѯ ñÃeB£VEð‡ Ö}zó„øݬI³6d3­/Æ’ 'N+K)Òn¤|’âWÆ~ Öpå.‘—½$4•i #/ÖÁ*r,C§Ü)7 µ/‹ÚŠú@€YÜ;£Z,‚HÞQ1¿Èh™V[® ÏD_VMjÉâá÷+§n"Ì Ù(Dई–X9e¹9DÞÄp£4¹Ê)šÀVø€Œ˜4YTTC´¯*“¢ýДSuŠa_Uizma[š‹:v­ˆà1XH©•+"CoBqÚyO_bv« Å—ŒŒyµL#ƒMnˆ*ôg"X0ÔÁ“ƒ ,‘—f“ϼ£Eý¦…¬b“¶ÔªSkeüçÚcEñj ¤‚œd%Q’ëe™@‘ÿ%æDPQ.Y-™ó“­>%6W,29± XåAALFàÅê±Ùâ$»FUE®âpJs©q=‚>GDC®GàV½Y'É =‚àˆÐë‘n½V¦ßÀ´‚Ðë„ïî¼"•]ÃU<{äKUhº*4kšvèÕ¼»‘?—"I‚p  åúٷϨ×ü˜Þ¹N»UT¤Ùë…у‰þ·ÑS„7Ñ‹>\1z±ãÔ2!EBügÛý÷yýŒ9ê땤ݿµ©uÂÔ' ¶¬êª¡q¨O‚CñêJž‡j¤êj7kª8Ô§*˹ÊÔ'X+éq¨OðMgÙ¡>5®·TÌ1õIzªªf¥êj83“Ÿœ˜üäÚeò“´]khò¬ž¢ò“tySDô'™&¯?¡Ù 6ý ]nBÇПPå¢ò˜ÉO(f£¨üJÒëŸÄ³ea)òÂVÑ `ÈO0Ö¢šÀŸÄèM•ŸÄÄ:MƒbTÝÊ$(ú›zÿ ¦j‹êM‚’a¦Å¬Ý%ÔC‚âŠ_¾ Ô®ˆ*P0ž=X ”d+:^LB(iC¥RJ¦Ó¶Tª"*‰©†% ‚“IPÐ&&©;ŒF Š¹¨(e”H;ZŽJPt‰ÉKP’©x=$(£–Ù$¨‘F%¨ñøqhP2ÊtL™c$“œT‚â ~Cƒ:¿Mƒš(ü Š¹Ø¢“jP0iÖ™sˆPUÊ“Å»‰P’™«Ôñ´5ÄbˆP•9æªjÑ¡Š=â"”d|ZgS¡0pl´þˆ 5ç¡e=-CähÈP2¨’"*CI:"³ÙGÉP²ŽWþ0ªT³àÓ2ÔDùh÷I…ú¤BíþS¡^ì˜"¡±›†Ó˜Ü`®‹šœ2Ù„ÙóÕlþý´+èÓ® O»‚>í ú´+èÓ® ëO»‚>í Ú]Úô×°+HüiWЧ]AŸvý•í ûþJv±ç¿µ+¨²ßËOÊ1IãÏÉ1œ}¥Oë1”´L©#S&M™tvzÌ„q­BŠé1•³¯*C™ªeCqúÕd(ø­ªœ¨ ƒ¶wÓ~† CÑR.R=FžûLª­ˆSûbÏ¥6A†ÅªAf‚×ÎA™PI>7A†=¬Z 2ò4A»ÏÑ=T¦SAFÚÔ¼ #KEw‚ *˜5_‚LeÑsÕ×M9>k‚ÌñÉÙdäAž:® 2ò¢{AFÒ©Ði‚Œ<–PQÕ‘P )Éžkï6=æø¬cè1Î2¦Çˆ\¹èEªÇHG©‹šS›dz¡£zËñ4Ö¹SXy†1f*FšÓÜ ÙD’ßû†hY?µ?‡ûr¶²x¢pñE)ðë©DÛøìÜÝÊÞëÃ÷5!ùE@[Pa>®ª²¯‰ç!å$ †õ¨•œšD7aN³ó‚{ã„b m6Û9Æ}ÚŠqxò´¬É(çJ!Ì—ãaJ& ëÒx’RÏúÔŒrKª§5ËO×ì‰Û&ä“9«ŒwBÐÂœ·+|ùœ§‘¤ ~°Ê…R/˜–%tÔåN|ý¡&þ¨†Dûݤ³ä&£yýfÀ¼®õIûÍ<ó‹#öà o0}wîõúvðõɦ`ó-ÉíÃüoýiÿkÛiÛŸºéÓÆÃ*ÓJï2O}ï¸ñ#vGòÉÃúxb/’êؾÆ„`j9Ëq6 Í¶þ’òØ*Ï6i<©p¹?;Ò< S¥LªižDÑ•;f6Ò¼£~ k]ÜL†m*ç.ûºG擦Tb‰ùÉ1èN‰È1S(1}l‰ê8+‘+‹öû%%ö5ãI¿¬ß-|ö},pùè žôÊükwJû•MXm~ôP95áG”G~ý„[Ï3Öà¿ À³Ãä#†ò¯=Ÿ6à/둲€H|^»¸P-{;ZLN9€õ™Še_òQd’EûF@ 5‘(É€@ZJ˜ô6 VÙ_åHx7ŸÔèç@IºËúÈ1 $9õ$i•³YŽd€#e ~úÜ€@ªºëçH2 øð+”d@ -¢ :’Ä]ÞÍ“ ð¤4MÎ-nŽ@ ñ1tö$i‘íÎŽd€'¡²~# J–­ÙG’Ô¦±m@ ñ¡°OZH‹hïŽd@ ­>•Oáë¾F3À“¸Ó§û®@ õET¨#ÉO9Þ÷ÿ©ˆêHOq„ŒÝ€@šEót$iµÑ‘ ¤ÕI>ù¯¹Å ø ¨Kyo€'a FÌ-2 ¤¼„\}‰ÂrÅ€@j5D’ ¤Yž5;’„QS¼ËÀ“–:¹#m7G ¨cúÛ à]Õ÷ÿ"rý(|Fæí=€@RÉÝ‘ ¤¹D{À“øÔÙGî $nÌñý(k‹q{ŽT¨ú9;ŽÏÂÇJÅs $L¯>’l@ UÙèHRÓsPG’ž”t÷Б4€@j“œ±:’ $nr÷ý(=‡p¼žÄí+%¬× ¤Òn@ Õ8õm€'ñœ©ó³ñ9PJ{‰Ï°¼yHÜ=J2 z {<©r„·ô)õm7 ²làr$©ËG2À“äa¿Ý©ÉvEG2 æBòÒ*»êÉ€@êsˆ#àIܪèýÄ>JŠ“ßÑú¶ À“ø°ÈO’H¥‡¨½D¡;”d@ -9L¦H{ÊÊ]¿þf¤:‡ÕÀÒÜC ߀@âö_íxRŸr˜X7 R²6 øtÖsôs p㫯ÑI΃ùg\HA·sBž#Wœ4fø+YñÇcΰ¦YFÝ@+±üÙ³ ¬’ep,CKvvWÏ2$°šn—u¬66Ð:ÖRd“cXr:"”eˆgÍ<ô!wd $°¸£VžØn,C‹/€éɳ ¬š´7’ýé5ÜÏÀbò˜Ãý ¬5­ž²¦5~Ͻj²}e£âY •Ãæ H`™¯9–ó¾{&Èã]^“’¸ƒëÇ šŽ…b±çgî\ .7\Ïp÷{ŠwöùŽ/³ÛLòóË<ûŒ'”YËÏ,²Îéljþ²Bô™èG¶ýìÔ_ÖG²ÉåGžŒ^p߬”ˆLûƒjyö¹èGvÐÙg£¾Ì¾®ØAgŸŽú"§^>°å?9„> –[Ór M¹ÔíóŸDÞí¿âÚÚþÓc胇徎Ô}É¿hTNLjã­i|Dï>¥@œ›=ΰ¸«ZÞ  Hdñ„Kd)YÍ $b “òH”4Èââ+ˆ}E'—Vç -°ºn§õ¬*;ÿ=«ÚYÏêrÜʳ‰éWZø¯cY¥êžÙ#«Ô±göȪrųªIñ,nsÎ¥HdÍrªÅ³‰¬¥–¥ÈIŠ)'&õûÑã{ùÜ£:¾ž¦É v1˜Qq>«{sNnæ^wnœ¿à›XŠŠ÷¯ÂOv î@±ªg ƒ(`œÂWÛñëÂmòöäCæ1ª¨pÖ»7Ï~ÿ,tÌþÜ2ÓƹÏlï‹ý½zûgÿ¸ož_4JNsÚ§ß=¿à/0ôµí¿ˆ¿ |ùpõ—çyÝ ›oYöpww{wo'œg¸Ê¡#üJ5¸O½Ã2˜ÂyvŸ¦üOü òBÂ…c¾Øß~êéÑOKEæ¼ýè—í'…¿q?ç|©N|¡Åþúá³ç²Í>§Ÿ÷Îiâ›–ø3Î'¿¬Ì·ÍÆ0· ¦àZk4o +np¤áF+ŸŠÄŸh¶âÏ ú'¶zù|´j*ûËw´Dç~¼ÄßV#–zƈ|{^ß?È/wXíûç|=;õV¿î}ìʉoëO9…Ž¸·þ™ÖýoÌ¢%Z¹9ÖlÃ^ò~3Må»OJïø[R.*¦ìµÁU’ˆÝ'¿Ä=·§~)›/ Ë)ÅNŒ·ãÛÐ겓>>~Œ+5íoÒw)|ïzK?æ*¼ËÑWÎvqøîúÛ|½ ú€{ü ó׊÷6?aéÊ· Žßáö¯?øK¿€©ív‹]"mG>ø¤yù:έQOýÒ9 ü*?uþq–]½a{$ô|.:nUÜÞ’ a÷ÐvwOO@çc1_…„„sÇ·–¥*YOVZ±\ÞÂÍ=É—÷bÿýÕõ5ûŽ¯›Zö_cxòSÖJs º,0Œt.ËþûNÐÁ C”ýíù‚çÕ;‰ XÀïnði,‘"Û²{w)|Ûý{éÈ yaY¶! /Rãób†ÕKËþ!øxè”ëË;û]ø”¶"tˆ¾½º}§ßuÄ´ïÿf¼Ýêî9·êë$V ßéÐö—4›þÜ|‹M÷Йä±æy«±”üæ/j€ùä¾÷v;è»QP‹å\ßÞ‡kbAnafÈÿê¿=ûêï_ì/ïïÿììssõÎÝý-»§º¿üN§¬sø)û»[­!ãÚÕÍåCœîß–½/øöîæ’¾U»ô4)3Œ$®éWÿãöá*´ë•‰D#ÎR)‰&ü™¦tÚ…(î$)¸|•k¡Þá«S·eòòþxž¤\†à\½5cë5—טuùŽ_L'Ʋ?sK¾D7/ìZ›Å´ck/î‚óßã>  BW!ú—™¿”`(™p1(.¯ÿü¸‰Ê§ΫøF°œöBª{õÜ)qtRÑa—ÞuNÝhánzp#óä÷ãfhÄû›“$âŽî!_cæzìJ°jA¤º¿µb 2ªæ[zjÚÓ©P^†>4î¿ÿÓ—_þîw_ßþðêö‡—|ι„‘µÏc6GôÓ$q"³h¶®Í^»nzbYøt붠³• ¡ îo^ù„_%ŽLdV1øÖÃߎP³ Ã$ªÃXÇÞzb°m‘#`x¡Ùö›“@ðÀX{„>Ù?÷óttLTLfóðí/þI!Ic¢}}yüû?_ÿ~õõÕ»×/÷òm7ýܾdÞsølà!ððúòáòðÍÝåÍ›—û»Ë,I’Œ(žûG væ¾×W_ß]Þ½)oôSÎׯÒñ6¾rÃU.¿¾©)+³2ý6íÿ«ègG˜•´â0¨\k^_n­)˜Ôn¾>Ú$ðîßüéå~ú, vjû¯ßŽ%áÐw׸Ÿøïá÷ÿüdÓòÏhš$|mM{õ©Ï÷/Ù}ÛÝ—ý/¾ÿöêÕ·‡›K´îýËç`ѼžÉ$W›·¼–ìI‹È£™ë|®ˆ—ÏûÛQÁýíwW21ê=çýw·ß¿Ù–Ã%¹qq¼+߆9–n/ÒŽÝÂWR­Ê”ùìÐâõX©œñq­šþýùçÿx,ùáò߯޽_¶ý¿{ ß([—¯eÿ»ãHšË¹»Ü§ó#X-xôtàýÍíí÷‡ûﮯÞa¨n.DwrCé߬Þþ9þíü¦ÿœ¡~Ÿµ Ú€ø%|”»óm‰iKä®arà¬'uÊg¾± åíw7Ç“ï8xN#=¦å8yl‰ùãªùñ*W~V°¢'“(]Œæ–Ã÷ìaÆ)ð;§¾ÜjàI£IÂé‹kÆh72½3I²|U;¯US×â„”Ì}|<@wÈ¢–lïÅ‘ÕV¡Ò¨ïâ,²k)ïR[ä7?ä଼x ÔŸZš…{n+³¦3Ÿ?_º¬ôÊùÕh-Ó´î V¥Œ 6/˜ãí’a¢oÍZ襘‰µÊ£´h˜ê—º2CNï‡Á-ë»5¿³dùd]¡=Ôˆëß±-ñä$b>YâýæÑúrÜçæ?†Â™¯pc,& Š~Ev}jA.¾úñ ò$¿ÚØv|÷ôÊ*ßxùð9yÈ¥ûò^`wÁ#Š\”|õ­'ʧRÜÍÀXuºp-5†»ÛûûÛMµ |ÌìhStžËmeOQôa’ë€öd (Ãõvªö\þe b^›¸ŠrÀ¥—ß[…Ðî}¹oßú”ÿp?ˆõñÒðì§K†‹45éØÜqÂ/½nÿÓH}£UŠW.MŠ Ábh|ò˜>áßý‹‡Áù@Â_pº‘÷ÿ §Uý\V™¹³æð-§ýÕýÈç×åoü"îê.®Ô/¯eåF‘æ)z\*œ ÍüjQ½HK—E~N\‡s‰Í…ü°v]a[=°±~bÇÚƒ©àK¿Xt¢–U€KÝÞ÷æl†úw×÷Ùñ ±ßÈW=ë½gýöøÅûë«›³å" ½HŸ!™ùûôæ"eu ¾h—ò©æ«ÛëÏ_½zq‘þàZqýýëϯ¯“>¼ÿüúAA÷®Öÿ 7ÒÛÞendstream endobj 158 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2238 >> stream xœ]UiTÙ­²éª9(”e«8Ý dD@„T„Q Zve ‹â6êq‰ëc`$AN7\ ÊâQ;ƒØìÒM+*ŠQ'_‘‡Iª!ù‘Ô©Sç¼w^Ýw¿ûîwIM H’dƒ6¦Ågg­ˆKÏrKJÎNË4L[dãô‘Ü‘ 12!£²Y3Ía¾ÙÛÉMSÃc™¾)#;n{|@BÒúä©ióœ]äó]-Ý,´u˜=Çq­A!D(Ax‘„7á@øË_ÂPDaN°ÄT‚#¦‚$¦3ˆ™ÄDâaL˜“‰%„ñµÀ0~;J¼$¿!+Èw|&ÄN(‘"wÑ}Ñ€èF«vu‹WŠ‰û©P*œÚKý“N£ÏÑ·éw ËüŽqe”šò5HҵmP™«5ž}Û+a¯¨ùbn´¸nÑlóßëÕý-·¤ø_½¼%­UÖÛHY'™ãÅèháÿ-Þ^C^ÓBVçøk¶u±Â>X¡³†Ù`;ð–€rþGl/Ëñä^×{âixJ¨ç\Ç0 °À>Ð Ê ¼]‡@¢Ö@âžVÂ6×ât®ÎS+«²Z³t@‚;ø̇ X&c|PXJb ÓI³öžÛ ;¸W‹°ž´ÈÉ9¬ &Ãä]càm‘*~»Ê¼¹òz—´KØíüÖi|ñ\M³•–+rÿ¸¤<½`Ô––7¯ø›”õÑ ª UO¯±Ûx' yK '{Eüå*nÿÑÃèbÒ¿?u^éAßjÌye'&K³2ö¥]ÅôQùË.v æùÍM‘²lúXòŽ=¾û±ñ®‡SömNA¾Œ}Kðo-5gj¤ÇWžßR‹N£?”ä3Ø|9´éÀÎÌ-Sã¿BŒ2©´¦îZ‰þ¤l °(¯ä$cÊA†rH¨„³øÀq±…Íq6‡0±=Þ¸b•ø 3 $8FØ çãö%M˜yö?]Ÿax%ìÕÿ6~Í>y^÷°µéj’Ÿ1L†¯%ú†üWôë•÷g+ⶆDISëãÎú"†uR èÍk˜gôX¦P¨A!_ÈêF’CéT,Ú¶ ÏÚÁ,7,Èéçë…³\¨ñ¹Znt"õ§ÆËeÚšáúéïëî=C¨1«>®<®lÕi?4ù ž™´7ö¨9TnÕñ‹…gÏTüåB bºC=B,›»Ûº®ó=€gð©ãvçus^¦_¦—°Oa3ôs'¨ëÔÛ{±r§ðp'»èªßÊ\¨¼Ð‚¤¢”늧†„”±y­ƒ¯^m¨v½$c_´\¸RÝ6¦,jÇØú;wìpDª£r*òÎø³êfÅÙ:Ät܉öX½#5q§,k_Êá cÌXñ0·“„.¡þ.ðæ°·¼?wZñ•4n]#v¤á~'‡3)È„_ÅcLAÛsµ$ï.è‘1ÉN "F§‰»©›U¿Õ#æMƒÒê›À9žÑå][Ò…¡›Š7ßXùkj—@ÚzøØ¥ã[<+2aOZ¼¬¢Äpw\hé€5äí7P&€â/s;Áø;5&R$Å)c}¶» ,AØ´Èóöò²¦T!¸Àbè| 3æ½Æ¬"|sD’,|ëß@MèvÂO FwîEMð§`ÿE Ÿ¾Ò76i ý4~Ÿ¼J)2”‘.çY {àƒË°mÞͼ¦ÊaÛ¬9ldÆé•?ƒæ×õJ=>vˆ·à͸g•g®¡V(y§mf.‹±xÙ™ m1Röã¢ø„÷™xúÐ\¢å»W0½+¡aáM);„(âÚïÆzûFÅ.]²¦R­¾[Ù.c?âFºÆP7yH˜Óüà†¾þ†ã÷BD úhÈ2=”½ÕÀB®?W:‘ºìVsÅ_U:¦;4qK=„¸±°³Á–x†Þ¦>©>[W);†ýVØÚ @´îÆn5Sùl®§i™£sp Ü5¢ñ툖A›þ‘HÙÖ-‚½B~‹%X‰ð<„aå0–0u” XGÁbr.Uà¡+A£nˆT“üMPq£9 >‡úxw‹ñn$@‰`çP~ &œÒaë*¼a9Â.QØÃíSA°š„µˆ/àp$(pNP€ðQƒ0¤ ‰ø‰Ô~ÁŠOœµõ'ƒ…°O5É·csnt(’¿HÚøW‚£ôp]/‚’‘dΧ­ŠY¾eÂ3|¤ s`v=BTíËì×Ñ-ÒõÕ!ýãaôæŽ^ãcæÌvŒ†5°æÎЙé–3|ñ)+Lù‰ê6œ„LŒ‘ɤ۹ùyyù?þ˜[Pkb‚LÌ âß&ÄÉgendstream endobj 159 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 593 >> stream xœ-M]HSaþN›ë8OkNY:]¤#„¢ È@¥ÈIh¨›åœ;Ó†.͵Jó¥ceÓ\º¹éüY9qh¤ÎÝB7AziW‹:ÏÍóÇó0D½0 c¨òÔ;­õíÖªŽÖÁá¾V¥¸& ¥òüîù #©¿>œ 8uRþjø½qð›^©°6—»Ù!8 !ìâÑ Eæâ6BfC H&™"ZÂ1½$óß Q“rŠ\'cdŽÈŒ‘I£¨“—±#<¨+eCAR T@—­)%Q”Õš¡Ûë“Ð$1òœœÇÿ‰Y䘆šÔ{D‡?w‹"LzK…iz’oŽùBÞxõºõ€Å€ùqÔ.¯G“áðÒL÷hn­ÛÛÕæ.9{ƒZÔøž¾ŸIØ':ל¬r˜!\á-ò¸´ÿÿ4Vn©ÞÑR~y2ò*>ñëÇ*æ4Ö¡áÜFËÏXõtwgnÒꊴ­•%¨h1Ðü6ª­-óÜñze"(H ‚¤BIžå-4@ýôÓ€„ôKÔ¯ÑÉåÝðÖÖ$ Q$æíC9;r!fów+šÚ/ÁMhvMxÇaxË~š[HûŸ B½Áþ °³Ñ‘pèþ § Ïiz¤qõõAØœí{ríóÒÊê|Ì×2dzúpøö¨/‡§Æ£Óé+)sy]—Ãjj|­`{È1ÙÁæìŒ> stream xœÍ}M$Ç‘åìµO°—Å^IJ¬Üÿvi8  ÌB:¬D@‡ní¢ØÝ$K[ÕÕê*Šäþ®ýIûCÖž=3ˆìÌê.‘’f »,==üÃÌÜÜÞ Ë?î¦Ã¼›ð?ûïËÛgÓî«g|6«tgÿyy»û—ÏŸý·ßä$’CŸú¼ûüËgüʼ %¦”w5×Cy÷ùí³çû__½{¸~sqcaÙÿúÿ½¼åÐSOû¯/¦Ã”c§¾¿y-ôPò÷ï.~ÿù—ÇÌuý˜€ns–G}þêÙ>_|þiR®z -.ck‡ÒËî2æC+ Ÿï¿¿¹¾½¸Ì!&éû3ü3z›åƒOM>…ýw7W_œlõÉÕ'Ÿ.|¶Ùh5ÅýÕw¯ï?û×_üê·¿|q¡s‘OqŠ}w9ϘÄÌ¡ý柬ƒd¾zýæÕ‹ý'woß]õõÃ'«ÑɇÏ/çßäýË»›Ï^¾\ §¶¿ùöÕg77LJï?»yØËþ ~òæÞÔ¯ž}þÛa½¾úîúþÅ~~qñsŸlqaØ_½»úöp{õòë_¾•Ï¬çãîn®ß¼–O¯Ÿ._|ûîõ«ë—/ö÷ò”¿ÿÞ?hûÿ¹,oôö}ö©‡ßYÑ™‡Ílú©Ù<þøð”ÇÇsÿåçÏþ‡hfm»¯îaAAÆÓæ]-?ä]ly>¤¶ ©öƒË»×»ßíÞ<{¾›ó!Ρíât(¢ê»ß‹¢¿zVåÛî[±2™Ùîb—ÿölŽ9RÙå\ë!–Ý­HJ<Ä*OÉùPûîF$5à3iõÏ6B•?ÅFä¹t1÷¾Ë©ÅƒŒV%ý F—çI,9@’¦v˜úNšL‡¤ý$mÐêafQ¨ÞvÒ.²v›¢¬ÉNì;ªþâ¡…]*5 »kh2ñ•MÊ|¨³Œ¤¦ƒ$Õ mE.ßaY®"M¢˜öœT"Éq—'LLgœzÅÔr˜Ë!ª$OÃÎ3d,rÚå"Ë&A"°HòÉ\Tã!$̸áHRÀg2ÜpÈ”ÈN² )It.peÒO¶YçÒ]š„ MuNØ«ÖÑ$úÃ[94l‰x6Î)wݽŒù7í¸Lè0¬?XYðŠ5SAAÀBçCÒ‰´Lúè’¦e]¢|²šèŒ]r;DY)Õhd)“K*‡ÀŽ«ü +.Çñ–¦»‘Z.ÐHº¨NÁ fÛ¹:É3žÞ8à -|TÑ/Õ Ó•9µl±jèâÁe»S>$`Å×±2oûV’]”ÅŠs5•¯2 yh–ãPt€µˆZv(@µÕ©¢c2+™žmxõO¢°%ɰؤ‡ƒLJ Û¶M3NF³>»ÉÁ$ú™{³õks?Ñò>Ë~i¿-´Ã,mÐã—¢ZM¥»$•Ã9¼ÀG‰õ,=·Ñ³XvçªëŸbÖ¢2ëƒD  b­¦ ‡D,»J›$š0ñ[bÙmj¶uèbÙ¹Áú›n—uÌ… Ê~ä<†ÉöVh$b~kÞ&L±óب&Ew¡ãûh#öÂnd[EƒDE;L Ñq=²6Z :”6Aü×ÌÊg²¹„h›ÙEÅÄ<+;È9&ƒ4àü!+n kÓ©GakXr1¬F‰Ø·xÄœºü7¨DÆY òÉœU"ö]` âæ&¶û–UÊ“XRá³dá‚cþ¬ªžUG8s„Mݳ¸Ë ŒIfQE£ØóÍŠˆžC&—u ¡ƒ9uÝÎ*Žs á$[ˆaÃÿÔΨN]±†0l[Cü k?S"ö ÿƒCÈ$bßE×\]'$UcM±†Î¨Cf›Ô%^åhĽÃ—¤‘²HšQ]f„‚C"Z”®XÈgð?Mœb¤D\0åš}šÓÓ€Qã¹Óò¨Æ 2F\½1ÀdaHŒ0cD[^(èð@ò¨lkžKYùøq¶WtLÛ¢\4ÄÄô«墑Öw9‰’žTpƒêK¤ãH$«ÏÕ‰… T†örI–M›¤™·tÜá4P ¨!¶Õ²5²ÿzPáìa?âÄÔ 5ܾôéYB¤,pEaÙ¬E·Äáè1»ŸÌñË΋•' ·b†Ë¬Õ‚Uù³kœ¬þ„ÛÖ±pœS¸±ê1é^£v;Òc ¯zffÛ\¤pÅ“(€¶ˆkœìz5qʶ¾É =¥ìáÁ!ÒLìGN9œR±°Î¨TMMd\Ø:‡ÓxW/2ò‰mºÞo#¢Ze• ‡TÏ]½~¬³ÞÔE²)V‡snÙŽ)‰Bgæ,d׳.oMzUçžTJ:sÒ5«Š‰cÑgDB|VáU].uf¾aÞ•IVÝžŽ Ökr/…ÀG R8`'cƒ%bÇQƒ÷R-ð®îQGDê ΆDml‡h¤,6Këm©1Åj:s\y‘ÐA†ƒ®£•ÌP9TF•±U½«‹òY\aêÃd; mF¨Œ`\OR‰x]/ÉU¶ËÈŠÞN’í^Ç)«kÚcˆ£àuK@mêrÑH³ÐÈ3v„3w˾•y]/ÕBìØKRìÞ»D"–ç9Ø$º„"§báøä\CÞ¢ÂB0>¹jLzT!FU³ oëÍÓ‹âÈ*Ý1nE%AõAfe附«‰&ud¾jFiBÚkÚ3Ê4!_VxS‹³JÄÄu-Äó¨Å&DúðAÈ+´ ‰’¶ÑL—Jº®ò2œ„(£f.$xÔ Ñk†tSÈH5ù%¡fÆ*A"|ò'êlÓSeô“"riT¹4‹·™f3ÖO™4{•QŸ"’ÎÓJþ;óéCÝf¢WWbÍ…OGÞE,ÚV|–Ä´¨VÀ4qFŽA7GîÚ<®¦Ì4ÉMV]QŇm価Ǖ¯æ~% Õc@-RC‘tuÑ¥™êÊ…²iÀÜéÎ!‘ÕKÇÂU oì},œˆ2^j¢ü)ñVÐMªŽPꈚ|eÒ±H|¢³ÞŠT v®ñržmr¼ªjÉlX"«ÆÄNO´|¹íV=«÷$öSx_Ÿgóy I3ÌUœþÄ6¸cCßd%]/ìΚ‘œ?¹ èNzêOY$Ù+x¢„KT4IgjÉöÕË˼oDÉÒ@šßàLSÖô–˜¾¢`ÕÏz H©òÊÞ³4)5¤çÄUU&[$äPƒïaG{ÂM'D¨öä ^;tS~¹Fêy…cU'Ï’4î–v–ã*óð—È#kò¢öƃ&!oÝ-—F| ôY´ÂBT¹”Í^ô¤‰#H¯ìpoGŒôR¦c¢CAŠ¶)¦QLC¥KuCežm«ŠX9ÜÆcmDYK£¢±ò"Ãaþ 1rx¡.;OØ8 ±ÚM;!U°ZSæq•k™²õ@A×äì¹óK¼<À6º®×ž%žªÌÇSz%SÍ2ó … 2½>Ú-*Á}w¬¨œ•ô Ul‡ÇU¥K¬bàpA-wžÊ"ézZA‘¨&pF¸;è©¥¬€SÐF6Æ…¨ ŠS”md!qZáÎ~šX¸ ‚dT¥dŽ#·ÃI4‰H"}íÄ&QÁž2OêO!ÁCae£™žžVˆ0)ÑŒSÖ$šNªÍ늪<”S ê‘g]Eã¿dïg ¶©ªOæÈú0#ÐGõÙ/íÝŽÁ.&Žô0.µ‡ßì„Û<í$ÌJ»[ýgÉ:ÀF›k“›g_?Xø4ߦ‚VñÇkh!YLtøùí³ýtÅ*ÿ´R&%§Ó<ÐJÜ Ó{è%"®Il…^Š‡ ;\ñÿE›³ ™øèÆch¦xûÂ(ÓÍ‘PpÂ͆h€m ÐDrý YR't@³È0™%p@S*> ÐDÄDPä )'g1É͆˜C3@OÝšm²+Ú9@艕O4‹®Î£€&PuU šÈÐ3tD³ºMD³É¾D$ ‰Ûµz4åÖ9ñ¼5DSݦŠ†h¶”Ñ”ÇnhD³UËmD39¬3 Mdã3GBš7®±Cšz#òøƒ M¸|îŒAšÈÈF69iÊn&G Òlr)~ðHSx#\i&f‰m ÒÄQB02û-){7†hBo&>Û@MÜ@9<Ã45yÂ'¦‰DÜÄn ÓÄ•ƒ6å˜fgþ艘&,Ñ$†iä^ôYŽiâžÙØ権Y+ZëGƒšµtÃÒÔ„E2Ïúcƒš9ÔΞj*~ðPsPKþc€š¸ë-å,¨Y[µ‰ÿ-@Í’*q‘§`šjýŽašð¬ê~tL³Ô™wçj"¨&ºò×5›sjÊ芷9 j69Þ‰9ªÙ§L4àT³yàý75ñ‰n¸ÃšðÔX³%‰ÖDNƒã9 kf=Æ(9kâ:6ˆIXsˆ£šHYÒ†ˆjf ´yG5q¦r‘ ÕL=û“Ÿ€j‰,ª©™ZäÇÚº2å°&GãÌkâbÎ?Ö¬ L³†bgÃyLÓni ¦™Ûð¼g0MÐt-ŽiÖèÐãYL›O•y ¦ÙߘfÃ2±4P‡/aî³ &˜6M ÔŒÕ ‡jΓENO5‘xí&ùóQMEü™…6TSĉA†¡š !ãôTT.³_C5s)T¾Õ”ó%ñ[†j³㳨f,žwT³z¦ñoj*ùT3ŠvÃ<j" Ëõ3PG/a±³ &ÎâöPöÃ99¨™ÀðÙjÂmrÍσšr¢U Ps*–i<j&DýlrÔ,Ñ¢§`šH÷rç1M¤û¨èg1M€@„П€iʽĻ1LmÚÓDŽÊ$Ä4厶~ÓŒ–0¦™&^¦©÷C‚‘g1M¥‚PrÓ,Ñ©Ó ˜ ÊS˜¦lDý¥1ÍÚ'3¨§€š-Íæ'΃š ©PÔ,S0Øé  ¦oæfÏ£šf¢‘iT3Ë5Îо³¨&nÌTÑó¨&°L†jÊÑPmo~¬‰CšëþÖLˆóihO5±<â>ÖgÞÀš­YXñ¬™2[Áš¸qX³Ê¬ô=ŠG`͘#]ý#°fœ£¡kkæfÇà€5ὓIŠQä#p̆k–H3`M@3%gaMªªÝÀš€fÊÖWdÊ€5qÊ3óï°æÈ XÓ¶ÇaMÙb'k*¦¾tÀš‘±ß£°f¬ÆixÖÄÖìqXc¶g¬Y‘‡Û T3ãDä;ªYƒ%{ÕÛ›xy¨¦'¹Ô”Ck²~Ô$ŒýP3ñyÔ”sÚ¶ÅAM,«=ë,¨ ÀQ×Å0ÍԺ咟†i6Ë»>Ó ©ò¶;@MlBý¡ ¦¬±y®'€š)çæ@£šy€rgAM}±@³ËO5Á€%‹ fFB›í &.ô&†j†nLPG55¸œ ÄTT)ÇQÍ\ìŒsTSs=DòΣšˆv |$ª)m'vTKAÅ1TS.³öÊÔ‚jÎFÙ°&ô…^ÜaÍ ›$^j°&2xä~œ‡5Kw$ñ,¬™q»ËÚؾ†5e4ÕNšˆŠô’´Àš¸Å¡<kŠ&Î6`‡5MsÇ-'¦Súºó°&²e´àó°&’)ê†~ûï0âÝE=!$Ì,ˆ±;Þ]ÇX×öõT„ñ²8ž…;IÏëg™Ïz:œšDŒA]P<õæî+¾’,'› _ù³ÌöÖò‹ýh³êêQäÄg›Kk²y²®¸åÆ&Ï÷¯/ ¥S­ûïÞÞÎöºôöÁŠ†÷ÁŸ$‡°ÄhÙÇöââBv!NSœý-àãN/‘ “ëïîRüÄ÷¢Ñ¹¬àüöäŠû«ù3‘“I4ôñ™Ìiæz O. "¹Ïÿ¨=»€âxÛ# ¸àô?€6 a‰ZÐñ»ÄIoî†øß¿gXÈ{m†@!$mãyïÑf–6~}m†`isôøÕx–6O·XñJr‰÷@D3³4lÿÅåŠöQþÈËóú ˜–=˜áï䜣ËìÒvµŽÛ ÁÔìý[°z-\°j$w Å•—5uÁºQ(újÊÒÈëF¸œàš0¹`ݨ#²Zµ±¿WM",bÙ>ýký±\tVô‘ÛE°n„—4$¼Z¹`Õ(ð«FC°n„Ì×´Ö]¬áE¶ÚŽ!X5:ÚÆÕ¾®÷ÌÉ1àùídfÃ:Ù ÉÙ•dÓ $ù)­[™dÓ ;![ºje’u+G–V ž´j…„Õ¼~¢KÖ­ÄëgÄnK+—lZÙ¼W­V+ñ4íÈ# ‡»)ŠwÈ¡:OÃ¥â¶"ñ3¾ÛD“ ™žÐxx\Îí”÷½ ¸ã|ç'~qU:dëÉ%ŽÎ8ˆè¦ÿïiOÞ»lñÃGæmq×+ûÇõ*7‡b½ÖÍw.Íù"š}tdÛù¦'¯bùðþ¶¿ÍþžÙŸ5ßÕ*æAÐ[HyA)Xk¿C>ØÆW,­æ¦ðŽK¶­Š“íF«b—æU+@é欕I6­¤²ne’M«¢Œ U£b¡ÓÞÐò†àæÉ qݪÙqÕª1‹·jÕ<¯·nUõþ¹nUíFºö¿Àv×(ØøÕY®ò›ž\²ieY U+“l[õº»KÎù{kuÊß+$º¼K¶­ªçëVÕ ôõÙÕz]²mÅ[þº•ßûW­ënû2Éæ„™²2i–V.Ù´Bj2Çu+“œ;Ó¬Õ©3M©6ó¦%›V‘´ÂU«èDÃu«¢ïu«bWñß¾gÅ«V+»FØßÃÓè¹Ó¸>óš|&ô;‘®þˆz yn&ù1ØʧŸ}ü¤ÓÏ>Ñ ý£V²>ã{ôZNÅ ÝÌÚ›øÞ¹jÌñú”‹FV¬Ô°»±¥†ª>úå PŸ F¯ ;ûËuE…‰½A; ;tf‘ ¯í„ÀŸTW§Bùö´¡B‡’øL*ôRµP†V§BË]ÁŠÆ -‚Ȥ§s¡3Àm>ǸÐ(@ÀZCÎ…ÔÇç:€ç²)îº gä\h$Õ9£QÜ©u{’s¡C÷*7N‡ŒN«Ó¡C7f†Ó¡EâÕ}œgØÔw ½;ÙèÐ@É5u:4úÄrNF‡†?'ýÜéÐ4ŽÇèÐqÊòI‡Ž“!რɺ¾W$;#L³¾“å¶VlhH8mgC¯$ƆÖoñÑƆ†¤°ØÙÐ*±òSƆ†„´WgCcÀ}ÆÖ)÷™ø*$‰¼f/ð4Ùkbƒ ‰†! z,Ž³¡WcCCÖlèգȆV ¹ÄƆ^f5 tŒ–÷v>´‚h$¼O±»ÄøÐZÿŠ=OÅÙÏƇŽ‰yA‡Ž9˜8L¬Ó¡c6r¢Õx*VËlС_‘è5èÐ¥1ÍéÐð‹ö-£Cãb§CG"+:4Òç,Yãtè…9èÐ2Ì™ßòO@(1:tì™ ä CÇnT4gCƒC¾³¡‘!‹u°¡¡“, elhøu€Î†Nd::ÍN¹u*4ðu²ôŒ L®l©Ð!2¤žBvŠµq¡Á ‘ϹÐòâ– gZÃàBs$ñйÐ84¸2Î…V:.%Æ… Hv“¡‘cgõ”A†ŽãéF†F®!úldhHÈEu2tJ^ÙÈÉаp‹‘¡Eb•ÓÒ= ‰×N†^µ164$¡Ó¡!™6th4°øº)ó”ŠÿƒHòZ¢¡-uCˆÆrTH'D§jQÃBˆ®öõBˆnöŽ÷ D§fì D§V"mœhà‹a]çIß—¡ûrN4¨Ö¤*%Ä?n¹S¢38$[+9g²tÁ DB6N‰Î³ñ¸%‘*ßMqJ48aC‰Î²Ô42§Dgžt+Jtö¶ÖB‰Žö¢îB‰oŒBO0‡ '”¸)ô¤Æ´[S¢Ê°c£D#ΔèìÜo§DƒÌHŽ¬S¢3ØàkJ´V„#ÇÎ =!Ú&Ë =À^XçiÔŽŒh›I@5F4t2o­t„Ýš-ê¸áCƒÁòL£Ê“_uœMÄ{CˆÎ~ù„h\¦m™§êô:'DÃËBiŒh¥›ãHw{;ÅRƒ Iß0¢£3¢s Ü©Áˆ†$“alŒhHHÜ3J48f¬©ã”hH¬)Ñp-œ×rHw¶2OöšÎ DCø¯òÞ­øÐ*Еq>4$¤±:z‘8zù–ó¡GÇN‡ÖÁ°‰ñ¡! >ô˜€Ó¡—9šË@‰ó¡½dÇàC/‹ç|hH¨·Ɗ'™|hHMt>ô²MäC«ÀØÏƇ†dÞð¡—Ýv>44‚ UçCCBR¦×xZ´ÆùÐðÙ¤C«€-Œ ­¦Ü CC@â«“¡!É”¯ ­J½!CCbjcC+£Y§àlhHèHœ ­Ö|Rw¹ú“tèÕWH‡Öç°‰Ó¡ÇXŒ A"!ÙèÐcÖΆօ"cÚØÐËzµ·Î†^¬ÉÙЋ ;/£ñgCkß26tö·] A£Ûp:48}F~&Zßbl:4R^T‰A‡ö ¾ƒ šgáth¼†Àœ]& nZ!’Ÿ]&ˬ,tèyôC:4Ò64èkÜgCƒMk«ñT‚…%ƒ ­· ºù§ÄØй¨m£È“è¡õclhpg¹^ΆÆÎ’»îlè»ýŠ ´ ‰ÎN†Õôœ ]²dèbE–¬ÀS)öŠö`B#¶£•9ºTçù/žŠ\Æ„.Íkx9\KNÒ™ÐÍÞLhðÚŒCìLhè *Ä1c0{§ÉŠ´/LèÉKo8Z‹e’¯lLhhfÚ2¡ÑßnE„F¬i¤k#Bƒþ7DhÐ8­«ïT£3)=ÞôLèí}Á„Fö‰,ºÁ„NVñs0¡ñ6ÒÄ6Æ„®)s7G'䬂ñžÉ„†éØÓ mtĺf»J&4 nˆÐ5Ûë4ƒdXÚ¡T“ÝëDhXiÚÖwµ™U¡Œ I7Ú3‰ÐµØ½b¡QmÞHÍN„.Î6&´¤'ŸÚ™Ðe6UQ&4ßP\hÐö§UvZ; Z;Ô5p4$Ù$¼§CB¾³ u¤4fcLicACBJ¶Wv2jÑà@C@Estµ;ÑR×i¬¬Ó" ZÉ$d@;£%áÓ Ð˺:ÚÊØÏ(BI®®³Ÿk‰^`ÊØÏÅî|ƒýŒ,©“'eüK—ö3¼7[ù„ØL‰³Ÿ‹¿Îà%PÛ¼ÒQÒiTóqösõÞ`?ã^×Öìç Š—±³ý\«ÕXØÏÍ—ÊÙÏ}Yím°Ÿ[:.éäï¸ösE¬¿[‘Ÿ%º‰ò3ÒÃ$óù—L«×däçêo;ù¹v+K?ÈϨ˜`üh#?7/Ü<Èϸ«Ò£Œ’NHµéhŒüœA(æj9ùÅ.ɵwò3^ÕáÓüÜY'«é4YåÞ¥¦“8e®º“Ÿ›Ö Ú­ÉÏ„ÛVägЙé ùy¶š„ƒüÜædþÌÉϨ7À™ù–rò³—ˆqî3þÎüŠqŸµÔDîs›}Þ^Ò ~ǨϨJ÷ëÔgH8I§>CBErês³ªÖƒù ß1qæscªPùˆT5ÊiVPê ÌëªF¢â4¾äµñã¨Q›-EîH^«^ïÅ‘2(oðêÊCÕ¶n•Ž¬°>È <ÔŸ"’ëP"E¢Uå•âˆCyÅ_§P‚T¢“å¡-ñ+‡òPo ;3(5Ð ÅÊya£8~ÏÅ ùÀ5àÍ+IÐNÜÍ0>pH7¿Ú‚$JÙ@|ØÂH‰A|`•Z $ƒøÆ­j©o„¬Á:ƒø4³ø  öÓ.ñáG¼Ó!>pQËâõŠî’:T.ƒø QÔs‡ø@Wå ãólêeäPÖõp+µßq1Œoä;—Ÿmñ»ìù©œ¶õ<;<@>d˜ˆ¬:Êýf ¿Qß(Y]o}Í0á¿ç;ýõÙéÅÀÀ½)ú¾/KYi"üŠ‡¬JÉxPÜ’l”løoþ ÷y­(½ª¶AAÉþüöîgúóß½|òP—ßiyÊWÅOηY•oy¯ówO­ç‚›¦ØëoÝÈá¿ü¢Íñ‹›^œhóâætªB²R“˜ôºág§Þìû©hhåzn..ebS û» ¼0˺î¿ZJ ­G¿)µ;Õ9r sò&a¼aú’7`ieq-ëßüÁÅVœ5 å©°äͯ®ß\à¥.q‚ûo¾Û! :¤KT+ýò¥Õw­ü¯’^ìß|qy{›_\ì./w”®Btz8â1ÆMb†«áÈQ€WÃP£#ù×믾¹+×™©ïß½¾¸Ä­ªq~vq™ôý´ý/L:åýOþÖyÂÏÄä&K})«|w»|.3[ºû©ËÓþîKü[Æ“çSÅ_mn¥ êdDSÑÉÓ3ÄÏV9Ž–iîçÚ¿3Ý)‘6«vÿõjøw(ÙÚCÜ»™üW>ù°X·×%F䑶3ßu}÷Æ)Öý·GßYÚ­7éýž!Ÿ÷²/ßÊÈ°E"ܱjwuýÒšÊÞn:ØNí¹‘9Õý«•øþS|©Í²ÿ‰Y,vY<„¾¥»ù¼ÖêhjeÛ5$}köS4¹ÔWää¹DþLü?­ûŠ+›N—±\â½Ï=%’YÕ3;ñôÜÝüÔzíóþþÛ뇗º­¹–ý×øhÃØH9YûØZÂõ;ÿº,ùÛÕb=\ß^Ý\c?DÚþ{v6ÍEÔåÁ»Ž»ª/>mžÅ=Ôý[Ù‰VsK[x¹Ù3ëSÌïáÎzìí=ÝX¾° ¶éàÍÕÃõŸ¨Ð©àKÚq>RÀwwïî—@L ÿrljà:ßöë§^¡«i’Eü`ŽK§a/Ks£[x‰_kSç¶gîȆ´$IØM?ƒ+ºDÒU\ývã®ï탾8~[Mp¾èyHxͤӠ¾_oìõfd"ß[¯-‹µ]b òàíè+ZLb›Ô\  Ö* l^jî'ÔZ9†âŸfVÇ™Zaª¼i©€p¬Þ 8K4¼[7ü™¤[{Ñb´rgãS¿¾zùõõ›×ÿêî›/n^^¿½?Õ=J؆QÆï3L®"ÈaÉ™•i5l0ÆJï;$›ú;›^\µÕ ƒåPr°'WWTeÝÙ9=ÆõĬ³íŠ£ºµD Öäg§zA.ϳ^N ɯ.øŸÎô‚b·Gu¶‹¤­Ÿ¸F^öhû4„®rÛ,ÑÁü«âEt¯­qû>?òkx/jG ÷î”C¡Ý¼âWz좋pca_÷º±bØ¿3û/G_¼×/n£†WçìÁÇ&`óÉ»»ûû;:yÚÆ٬ٗç´ýòÍݽ÷[Õ…ž4M½<^ôÚ—-þ씺©F×ñÜì.~­Î}kàÓi¯e®amàÏaá´DqÚ¨…z‰\RÀŒçs|†qÝß%x!QâõKÀP²úìñw__ ÚaO‡àÓ©Êr´‹`OôV·òk?Ãÿ£“ÏýλImÿöfÝþê›ûÍ÷¿¸YoÓk|­ê—qê]ýoíS<´|tjËfÒê‡fòÁµÖêáåÄZg=ÒñZŸZ_P§V–«{[‰h®Þ¾}wÇe–µúNg]d;ÂXP.Á­XÀfMt)«êíÝÛ‡£¶7¾Îb,ß<ÜýWÑñ€x´îÿYJt3GºíeÐ_ÆMGAØ/nƉ\S‰û«µ¥~¯gåþË•#y‡‹PXâ™ _7ú‡ý3râ1ìð‹-âf5êÿ¸[Û™þ¿huÝßs ðzDG<4¼Üí[us1Ý-DüïD|€—§˜×]!HI`ñ¤q£}ÖŽ¾õBb_O*¿–æ.Pþ,Ñ·j?ª*=âi¢Ì¯ìV Ÿ3Š’¿zw·ÏÖ“sü:M'©¿æ?túÆiUy뢹âÆ.Óœ÷¿Ãºö>iˆ¬êVÂ~½”ïîÞ2Kˆª¯×VpPwöï©oWøîvÝÁf½_¯¬óÔœ.üGYâË€Ÿ‹,Oø婹 Oüþãµ·Ý¡|èõ±sG½ØV…‹-[‡epPvYª;ÀˆµÒ¡49Ú†XÖAÇö!¨‚‡\®[Χb¡Š¿ãò÷w'AF:v=< !ÌÅ®ËS§ˆï¬b¡ùl,d«³™ Þr4ªjÓÜóù @N“_Oðùñ ^*w«Ù,¯÷½¼–ñ!çÉ•\Oþù6Bùî-Õ»à)úpê AÿÙ[^¼X‘çòÑ:#*#Jó¡Žžï~qÙ4€ßuÑ»ØþŸ.N!€ÃP[|Z»•ÇbfH0â¥ûÂq^¢(ÎTÌÄÒÌá}¡a_ 3#RB¤w…âB6®i³ìßZó)Œlˆ0§²!!3ÞÍïÞ½³Kð³>üÞ÷‰”¿Üô¿¹ožÊe€ÖTµ;ða£—‡OOòrÖ_BÃÕ>à7!æÇ£‹•‹?]ÌíCÅjƒ‹ªŽ~iíÙü$ÃïµÏËQ¶}ºR†æ=ññrû:Ï(­¡É}à€„XOüX ' Á+~ú¢¹¶ˆ´=âOš ö‡©>v›çøÛùÌCP !:Ù?è_ý V¯£p€èôé€<0x{Ïw„Ç|Ç?è;òã<€›LyÞÚÏ‹UÒ£­/âq\Ä·ƒFùD$#§Íž^âsÏß]šO½ôhÑK˜Qâ¾zº7¿]ÝnÎ…x_aüÖɹSN“úaõ{4ÂütoîÙÅTótŸ[ëI¥9öqU 6ná§75ÆŠÜ…JöKÇ‹}= 9q°äz:ošÀ© yš³¹Rùìzâš/_”‹´eHØÝ—{£ÑKîYÑž»ùr™Ó YŒ±Kœûc—c0"+úc®½m ]±)îÿ¸Ž!¯ÆZ†ýýµÝÅŽÞl–EÎNèÃýýêÁ{ëG®îÇš¥mªyhúþg—r”ìÿý}%–-{maëÅÕ-à\]Žunýþúa½­WÛ˜_Ãk¼.ÛùjÉ—s¯p´¾—.ÅÇO_?õ·9½â ½œ?æî} ‡øàÝûø ÌúSkžÎ@…Ò™ŽÁœ7|±Ñ›,üø‹íGëõ»B:YW°å-tð•t1~ùJÎÒÍ9‚÷F¼ýúÍÃõ» ¼.ÒÛ»Ù¦5#>ˆMûêõ[¶Ê²/ò×›‡mÓ ‹á}¯ŒëÉðÊJˆÐ_žKï£øØûcˆã‘”Ô±N]¨ñÚú[,ýæ«»w×DôöŸ‘*žõ–lé4¹ mTïæq*ÞÁš›æ®Q4ê½û°ê¬Ëµ´‘¥{0¹:?¹·l\NGøÌ9èþ§Ë·¿Xl„¢¤ï¼ÿÃ{kc·W}rT¯€lÛW‘ß)–ä}iäw :=ÈÍ÷÷Ë(ýI%41ÔUPoËÜÊþG‰Rýj®[]¸âèÕSrä3Ö›;|̯ž}þÏ—]ÕÔ]À«Í¡{ëc/ /·xÍâ}Œ ½ñÇÑ­°E#ÿñÄyÞ$¢^¹•tS×wGßHà¯j ¹ªue¡èo{}ûÓýìÑö‰žïÇëñÒ!ª3øºpñ±C+šÔÌѮ¿üòýÔÛ))|¹$ .S71¸`2÷>Úxi^O|&Gô§AñzOFwS¢Úè7m¶qÍŸ.ðóì ö\Ýœï"˜Fw'Ï÷Ë(¦­Kÿˆ}ZÿãÉ„-¯rã|Z®Â¹Ëù{R±‘}­™zUëÅCœWk1ßË¥«£TÙ›xmµð*´"‰M Pܬ­ÓY! ¶sŸOÞPÎ.ã’Þ?ÆàõËòÏÏ~vÎ/ËÉûÑ1÷£¨ÝúÞã «ßJùÿ]„endstream endobj 161 0 obj << /Filter /FlateDecode /Length 3627 >> stream xœ½[[oÇγžšç ›È0ònç~I¢n ŒqÔ'Ñ(h‰’˜P¤LR¶’¢ýí=g.»3ä’lÕðƒv¹s9×ï\füz@[6 ø/þ=½: ƒ‹ƒ×Ìÿ:ˆN¯;>øë fà—ÖQÇÇça X60Ê´N¨ÁñÕÑÃã_a¬’ùX¡Z¦- ?>;8!O‡Æ[.Èé°¡-UNPeË—›!>KË#Ëñz’›ý>l„à°„&ß-®®³¡ašrÒZ²žÎ³·‹áËã·™`¬µ²£l¶¸6L´”YNF„¥9,ŸÃuËÃòQ`vcMÿ˜–Œ”[fµ%·×þMjç ¬__¾˜þУ D~£¹*6­2’3Žäë©ÖhMÅ¿Ö(†¥Q d4 «J´-s¶×âjUð¶ñzu$$y…ú¦Â¯7ØŒ‚r.½n„aÔEi®57I¥óm 7iãQãaîyö¼Œ"Ú2>jTšÏŸzK`G¿/¶©!ÉVHÍq™†Ý;h`=«uXM´ÃFQŠúAK¼Y×ÓÅØ4²uN’Åy|F³]\€INnƒ €Ã0M®G¤x÷¯YjÃ(o…Uƒ†ƒÊŸ ‹$s#µ ³ÎQzNr²^à3Ú‚@BØUáQÉ.aËzÃÜ05 @&ýw¶fvÚÚ 03©Y”ÎQzâÑÉ8<+½Óɤl•3¢ô³MzZÅ:z&aˆ¦Ш¡‘j, (gó¥$ËÆéglg¨N nÙdkQªB2]…gJÕ–u ¦Aº6°î1CV7¹é¾™¾*‰°ÈÈxæG¶#Û<ûý4Wx4>ØÀIŒõ:¯R¤¼-Lá‹sB+NV¸˜³ÒÀJ§‘R-ÁŽú¹ÓÕz9}µEXxöûw¯¨×†Yx|€°ª¤ã›@«Õ€vË:¤$Ï*zEÜ”VÂÞ­¶ŽzŸ%Ïkê…”¡b7¨l*[.¹‹`¾[_ }¹÷‚ÞDï û!kq‚“EŠNRdäKÓ [º(9løýñÁÏÚ`…o!`ÿý€YæZËÚz¤\A½Ã*é—ÙÁ/;Ãz±gŠê°$Ú",Àu„íì°"càvw¥*;4F‡èâ8z!o9Ä=¾[n¶µN Ø»•Žo=ªE4ˆÙxw†`Aûˆ±ÖΑ=E«H'LËèKÓàf,U–𬸨ÀF‡‹5Ëg 4kÜ>ã·€ÅÒ$;¼¨opÁRrðx挮¨'O|D'o·£yD¤eþV“uã ªh0цäƒÎ>;à ]|å}@ƒŠ›Œ²`å]¼Úa3ÆiÞ¬(¸ÜÝ&ÓÜIYŒÜt´+pKo+öö|Ú< fS²XQKüuÕI!´Útú´a¥Fb¶¨}ž±”D Yþ4ämÜHr9l¤çÒ$7Áñ*üL©†pÒîŸ`ˆ°€Bäð³ÓX.§!:Ê„ñ †Fî¬!㳸ˆãªTÛBhìV—°zÕ•5m³ûЪpåò18•´´"º/ŠÄw¼ÜÌõ<}Ó1×ÃgÐU‘ëu5Ô{–¡ôüNÀT#ã¹g\@ÖÊÂbð{Lk‚ LéÙãÕ4Ϙ!ù’Àô'Ñ×ÍhžýþG>gçÀ–Ÿ³Í$B»–CòIDL}OóÌ·VÆ”¤HtaТF§ë¾`¾xžMÇú’;ðvWT ËÅ«|P±îU˜iÝ+ôO° VŠ«0²‹8Üy6^^Ü…‘€A­è"Þ}@ú‹U"H½8Kȇîiw†A°p‰Ð]†ÁEèGÞ ¹Eiˆ ú>Í(ÇÑäm§3Y0N’`c¹¾Kc_N Ï@·èZPËÖû«Ï¥BD –»›Õ,I1)áÜgI²ËÐÞK‘yÀ> ±êu=]Us_Õj-Ù ÿÕxÉ‹P„¹,Ê.VwR¾8™°¾USœ°h©@°öq’.¥v']õ<Ð v²#>n^¸Iâ>±]7ËÜ­]w•¹`û”mbýSŠî³,Øa©š1Gu1¹V@Á²oÛj¿<ÝØàÁy—D5ÞѸ·púÀÃìj;†àæ»]ÜÊÖXú`ÊæÕâ*¶ÌœLx_pª£‰PXz´o”ÈP½8 ¥ QQùz±"¤Ç€¢Ç0^×Ý»™V•éÝürünüb{Mm»|Ù¬½6ƒm^{}ë5÷0ß,á~G×¾»®x iÃ;;5ïÉæNŠ†UE^¢V»þ1‰ìuÎ ;±®³Àº –•øWbW€•½£سq¼Þ×4‚Óú‚Û®Ö!mµ sª5¸V—ÛWÐg¹ôbY·=ÝjL/KyJtQÑÿœ"“í[Š‰Wå¥V õ‡”¾àÿi±žD(“² ®hÓVÎ-b °|’N7ÔÆÖÅ"K) …é.®ñÌAlZÁ׈6¹Öä£:ÛO‰xX;¢T™*Ïc4‚”n5åUh?ϦyÜú½ÊE¢îw¦jM’Ý™ig³«¥£ZÛ›ßéÞžÆf™8ðììc°^®ÔqÆÙÿ‡°}ï› †•µn ³é€¶Î7Ï{ÕecÕë?)QÔÆÓâðv]œÞú)xÚ`Èë›.ŽFz$ùÍé~8x)ûoü ljïÅ€E‚ÍŽg«D¡-ú>¾¢¤Ôh°í°ž+/>Ù]ÿb=‰Œõ¬ÓdEÆ9—×Á{…À¹¾p0Ôâ¦c<'·Ó«qyB¡ðˆÈo±o[-w•ÄرadöÔõÃxŠ“´¥ :;®§lþãÆÖQvÅÖihŽ‚«¢ñœõDgCËæù¹™O—‹Åz„¦ÿŶª¾OvÎ+­Y°BƒŸeogyUôX&a4;€cT·F±îw@ù?6²òL‚¸½£þ¨ú´ü°Z•­Ô•¾?¶óX¬_ìít6‹œY»%TO˜Qd5›^\sþ×Þ;ðÍ°8Ð3ÛP|ꂘÅ'«zÙZ)–&)’ŠÔ Àó4™ ¤õÌÉø:2x‚ , ÷\ƒMH¦…oBV©¡­ÝJ<·¨Aô/¨a5j)`°¶0Ÿqè‰-GHOh:ãôÈt7ß[8{s®B81&Oç!*à™í£ X·P!)N!36¡ ¤ïQ2<–„\"[°fž[ýÏxi'vû$×WQãšÀF¼’´Æu™E à ‡o‡âÒ‡€Ï?Mçgø¦|ç–>‰/”“ÕÍéeÿi}‰ £]ŽLnñÆ’ä¨=JS¹è>†Éç¤uoã$ËÈ7ýã-Mk1C#S˜ç>?8þ²äàœöÏß4Ùï7óSŒùö(ÿζÉ6oú·ùiúþ|hÔ‰7KZ+¢3@Jä|{r{tD_¦½u±KÃú篫4ýgõåÚl[‡7;$Їó^•†œŽ`oÚÿ¢  Ÿô*Y/fGl%wämSÞ«õr[v3ÀϧÓõêˆÑîž „«Þ ™Û3<éîùtµî­~ÒÊÊφÄÊßœ üJøýK’ 'È“¿…¡ ì£Øü檷Øœ€›sílÍ„²ÏÛ°$§nï’xªª˜£‚»I#x'l©éz²¬Ò6¯û…,«ÎO×íKù«N;§ÿô4cÈUš¬ÖÓ«öz99ýª×{ÁŠS³Ô Pµ¬‚G¯T Þ¶»Û]vGON>C‘~ö2?$•=Ò°R9݈¦iz3œûâ±Dœôöߣ~©ÑÈ_&׫}—üq7\Œg³vòúf<%„“>o€‡V¥WA¾,\~Dxæ#zËGj±1nÂ^ö’?~ñÏïkâÞ¤s0³{s†%‡ý£‡®&ÃDýnxýmÿx›aÙÝxÍêVóÎx=ê>¸:£=7ê¡PžàçƒAùáôPÎJ(ï^AS<rv_ gòÞ¬ä‰Û9¤.’Z€ Æ DZzâ²88ÎÔ`z?Hgw™‡¢ûƒ!]Aê(…dÖêûBº­`ú.dwaz§§ª±í3þp8«VwÀ⛀µ…R¼.‡wF©m´éCOurŽ$>›Þìà°‡^BÊ°E½ Ôð=Pã+' Õão5â…Ke h3Ý/û.\b5ÖÝŽLe•­„}À°_bd•ÊL5°àZ†â‘)ꯡ·–v‡?ÌÏ&“3¬!¹öÆ~Þu— Ígk_¡¬bó塶³¢oÃ`ÕJß$5P56xJqpñT´CªÜOæÎ_õ-®:Ûƒ#kÓ×]TÙ3¬ÿß ©3\,òéI¬2ÈСŠ¾°Eå»Àò–ÜÖQ)²;ÈG´š+»‡%ÛZI»®É³ÊýWÕZO¯¿Wæo÷×7èVþ{1p§ °VÞ/ɳ«øA Ò_ÅHg}1ô3˜kéÏF®ñjøj„zO™§Ó ´·“åѳ§Ïù¾síõf‹]0.ˆÁû[PŽäçþÀÔŸM–Ÿ.†h:Lbߟ¨0d‚ÿ{Á7èYß /n„Ìœc„À¶¬/dIóÃü¼"\ˆ²dWÓyìËÐ\¨°Š±*Yç‹Ê*Ø6dsø>)çÈd¹˜Å^¯xÈ7Að›d®ˆ­= uS-ÃwîËõùñfî¿CÍúNJüvîàLNÞ^Næq¸¿ç/ùC{D¥VÒÁ¾×¢8°eŠb¼‹¨¾ž`|,_/vˆ<ñ’\Ž;Quý"YÆ$pȽ¥Ý¬&gÙ­Ÿþè,åÇendstream endobj 162 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 215 >> stream xœÌ3ÿLMSans9-Regular‹‹øôùJ‹ ‹ ¸÷1ÉÆÃR3Z÷¬ÿ™ã v÷ÏÌ÷“Æìè÷ˆâ‹âùû^÷Ùôñ§ÓÓÝòûßû#ûýJè÷Ï÷4÷RûÏxøJNMûû'÷“÷'÷ÏSCu¡øPœ÷U¡¡Ì ë  To ‹ ‹ ¶›ŽŒŽŒŒŒ•• ‹ i‚TJendstream endobj 163 0 obj << /Filter /FlateDecode /Length 14179 >> stream xœ­}]Gr¥wûiØ·…†m`o[êëÊe` x5f Ì,~LJ¢$ø!“Ôˆãß»?dãdÕíÎsؤ4Ctï鬸U™y2OfEDþëõvN×þ9þÿôåÕvýÍÕ¿^¥‰^ÿ{úòúï]ýÕ¯Z ä웧ëG__í—¤ëÜëy«íz´qöÒ®½¼úòô‹'oÞ=us[J°Ÿ~ñÿžÞä~öêõôíÍvÞZióÓ‹gñÅso©œÞÜüúÑ?ÆϤ±þL†ÙÖâ§}uu7~EJºö³÷ÜQâ¶Öt}[ÚÙzG¡/O?þöÝÍmËí¼…Ý×_ãs=»çS›¿Ñιl›]ߦÛi¿ê/Žb–Oo^¿%Õø?ýìò‡tzõýËÃð–O¥œó°Ò¶4­ÞûùÕ£¿$s_ŸwƒyóOç´µšGiöì6í÷*¦ž¿{öæÁ;{þêݽ!_nȸ¡ç¯ž¿;? RõS†þéþÈ£={ûîùËówož=ýÙåªÁÕÏÅ«Yí9ÇCÕ£‘{^[ð¾AÆÙÒÑŠ¿úÛûv{Ÿï?ÿÍíýçïó—_þ*÷Ï~ýëK‹ÛéÏÿüR"Ý5Òþ0_íòë/|÷äÍãÓ˯Ÿ¾~ñŧô³üù}GzùäÍýc}q_cOŸê9}Ž·sÿ<ûã›»ËN/¿ùîrU‘«¢äç—+§í<Úå«õÓöøæñÍCµ¿ÞõÓïßüîÙãÓûÏž½ÿîñéö}\qü–ŸnïëÅëoRü}z»w?k§Ô>¿¿¿Œ/{§°Ó«/ò¿¤ôøæ¯/ÏÒNO~óâù«øÁß}ñ>}~¿x÷û/Êz·½|ân?¸›‹¡¼Þóû°_ú˜u˜îª¦àk[¾ÎûÜ>vŸù#÷ù÷®~9‡ºè©^×^¶s%YkçCPÙò¹Öë7Ï®ÿùúÕU=×RÆõ1ìÅ#^ÿ6ʈk-F¿nѽÏvý€‹]€üœã{Mç1¿{>·A@9×ë6ÜÎýê9;#휲"Þé¸ë6âîÛŒsgÀÎÑ÷ ñs ¥ ’¶ •!ˆÃpŠ¯;’ÎÆ@>÷@zwÔØD¢…—©çR¹L<ÕPÄ‘~6±<Î#1bøcÉùâ©ú Ät’œ€tÞLOäó(×­Y9—ˆ'êÄ91Š zÌ«üÝa³nçœv$†ú ‰ç„ä- ·Í›lÒ9±Ý@¼3ÏcŒt²SÏv.Ñïj«¨®‰Ä#5E܉Av0bgüÜØp¯°á’p­¢­ö6 -±uE@¿)瑉§ Ë1”€2i“£k™~Ž™ˆÊŒó&–ão™ËÄc‰eŸä^¨ïÊ–ƒø ÷ŠäsJŠxté‚no­Z&½W¤ž»Xn“ßk™>ù½"s°}eEìlñ\Ù‚çyG||)Ó¶Ið¥LK“à+ÏÅ–[ åÇeÊ$øŠÔIð‰±¨0Ò'ÃWdœ³X¶ó5–ÑJwˆ3à“ä Ò·ÉòIçÚÉ“ç+R@t\ ×ÙWV¤{ÔWŠ¡¼ï=¾÷IõµÌÕ×"6©Îf‚ñ³±á±Mª¯HÕÑB1ÜL Oª¯H™T_}6³\g$>9#}r}µ3&×WÄB2â“ëË[» àúRƶÙSV$Í©`¹Êb/Œ”Éõ©“ë«Ùc Q –û¹‹å1¹¾"6¹¾">¹Îˆ³eßЇ ¥ØÉ“ëúLß‘2¹¾–©“ëk™AYp}Eúäújgœ¥HˆœÂH¨2œ·mR3F È“é+êH ×Éôi“éŒDµoy^<>™¾ u”1( B|2}A $È0Vª…‘¤LžL_‘2{ÊŠì¢oEvÑ·"=D¬"&–ÇœV$K,ûäú‚ä© ™óž Æ–CS׫Ë”ÉõµLg.‚µ#TÄÄðT}„„òeÀÁôê1Oç)¦bI‰ž²–)S÷ ≯ MÁE ˆNHÅœ@H<•±™¢2ä+XNF ,§2–¯e*ÄßZ$äDrF2H.ˆ±áï·BüРo é 9!½Dãç¬8Õ 1Q¹®BLd6Cñ63¡‘1Œ{¾#$§2 $§2$'dj?ºj@äb`9!–W‹[ßv;}j¿µLŸÚ •KHË1nô>µýVË©L‡Ê%$>ñE!‘Ä°ä„øNò{$ÔDd'Ô7V¨‰Ì†ÇT~tÑT~„Th\BÚ™ï&ÄH¾;É—26I¾–1,a ñ3 †u®›Â¬$-‘¸qg¤î<_®j“çk™¾ó|)3 p©ŒM¢¯ˆ+ÑmJ¿µŒOéGH‚Ä%$+ÓCKÄ|@e¦öÄÄrÃj–Ð~\Ï¡%„ê!&²XöIuFœj¬„˜ÆH®8T¦ì\_ •+ˆ‹åv`J?B¦ô#Ä r ñIõI›|<_‘$BÚܸcÄù±BJ ±<„é%¤DËŽµìŠ„–`¦a¦—2מ„Lå·6¶.¹ÆBL±Ü„é%ÄÄÆMZº0½D¿bÙ´¯„žÀœ°ØÙ÷ƒ™ÊOи„d¬fWË!(˜é%EMŒ4az E‘ÄrW¦‡¢¦‡¢èrÏ.ÓBiS1­eâo`:#Âô6µßZ¤(ÓCR4nä…+,$EâÞô«2=ôÄàÚ =ÑØlè 0}E’0½gí(89!LÒM ïâo-³‹¿Sá®W ¥zè ¡zßÕßrUè ¡zè ®ÐéD˜>Š2=ô„0=ôwÐE IôµÌ˜D_‘]ü­ˆŸ¹CO4îÙ¡'„ç¶k¿µÌ®ýáß91Äp›4_‘]ú­?5dB/!'6±lØà¤2>i¾” 9!49Qù–CNd¶r"eE„æ!'W†Oñ·éSã®E†²<ÔDªŠ8·;³¼†˜èÎHš,_‘,SB 1‘—‘u*ܵ@›,_‘>Y¾^5„å5¤„Ü‹O…ˈ³á£2’d>¯) Ëkˆ‰lŒÔÉrFx:¨I…_ 5Á,¯¡&*ßs¨‰Â¹Ì@˜å5Ô³¼†šè\_P\¤L–¯EªLç5ï²o-Ó¦À]‘~`ËkÞeߊ¨ì«¡6¶ˆqu…–Üè% Íkh žÍkh‰,–›Ðˆ‹å.4¯eÈ„PCKÔΈ Íkh ¦9gËu×~+’§Æ]‘"<¯¡%ŠXVíÄÅr‘[CKtn‹Ð»wu™Îkh !:J7E„ë¡%„ë!&„ëMµ_ 1‘ÅrW²"doªýjè‰Æµz¢²åЙ-‡žà)ˆ=Å`Ë!(XåÖøT¹Æ (è»J? .†Ç¹+bJvè †*¿:TùÕP¬qÙ¡'èŽGÕ9!ä„=ôDÃCɈ}Ì>ô[®dÇ wÝ™ë+…=!{ !»©ú‹Q²‡¢²›ª? ÎÏn¦dE!dE!óB(ŠÂ–CQð¤DÈŠÂÄrd_‘6ɾ"]ÉîCg†Bö@„ì!)˜ì-4Ë÷¶ípE²½…¦àÞĨÂõª¢‰á.\o¡*²¥¤€‹aª·PLõª‚©Þ *(Bu .Wu%:¤*ûà¥.D›è[ ÎvBJðœÐÇ®ûV¤(ÓG}‹à aúhÊôÐÂô¡Â¯‡˜`Û‡+ÓmS¦‡˜¦›*¿nYn·¢L·ªL7U~ÝTùq±BO°À¡'x×c„ž(b¶ŸÅð¢q1lBô±¹}$#©øC@ +\ Ìô‘Š0}$U#ôDË]–²ã,b„©>’Ê¿‚‚©>BPpS… à÷#ga:fúAab¸²Ê¹ ÑGîBô‘Uü¬âˆü¶ Ï¢­ø©Šj¿z‚y> 'p1\…æ#äDÃ]h>à5Ä·r‚—²@\,»Ð|„œ`š,rGÍBórBzJUõ7ª¨¿Q›ˆÜQ»Ò<ÔDæ4×»sYÇŽ¶)Í[Rš‡”š‡”à{ÙC{š·¦41!4oªüFˆ‰,–]iˆt”®ÊotU~£gѸ£—³˜©2ŸiÊòÞe-;ú–wS–‡š–wÕ}#Ô+Ü5Á@V–‡˜–•}c4¸@¤§„˜àÍÍ1Tù¡Êo ;BLðb¿È!&„ç!&„çVDà«ÊskÊskÊsSí7lˆÆfÊss幫ø"<÷$"wxÖ¾âE67‡«øÞ”è!Xå1±<”ënÊuD’eÛ6‘¹j‚É„Én›Š?ÛTüÙVEæÚÖ„ì¶u!;ËCÈn›É‚Ö6—ýMK“Ý’j? Lv AÁ*×R‘õ¬¥Êd·ÐE w!»¥!"ˆ‰a;  ÒϲJ?ËI4®å,dÂd·\„ì–«Ýr“Õ¬å.û›–‡ˆ‹e²[( ¹V6!»•$d·PLv ,ÿ¬ѹVªÝJ“yÁŠÊ?+*ÿ¬˜] &–]Ènu²#vœÉn!)XèZ-Bv &–«ÝBS4±ÜEèZJöjJö@„ìU µM„.öö…ì-ËÔ`M áz«"tÒÏKZk]¹YÁ€)×CClIázß”ëP ¨þ³^DèZ¯Êõ^•ëP ¨þ³>DèZ7Ùü°î²Ë D¸ªB¸>’]YÖ³6Šr}Tå:RMˆÆB×FWª¡T¦T*Í6ùª<·¤<7ÕfEynânoÖdã¿Ë0Sýg¡(„æÈ%ÁÏd®4÷Miî›ÒÜEšgѹæEYîUYî*ˆ™ÝÛFVvd(ÉÝ”ä®úÏ‘…BÖ¹¾%ÙßôMíÁ£b¸2ÉI(Äp’11¬êÏ7U¾©¯½'õµ÷¤¾ö@ØgÍS–ež§":×Sš{jBsO]hÄÄòëÉÎr‘ ËÁ£\&'a9–¹žÅÕÞs–{VíçYµŸç.*׳~•ÉÀ³ ?Ï.,÷¢®ö^ÄÕÞ‹ºÚa–{)ÂrG6 ®¬Ò„å^º°1M[SÄIJ‰Âõ¢®ö^7¡¹W•~^Uúq¶\‹¬g½V™¼ªôóÚ•çÈF¡€ð¼ª¯½WWž7U~ÞTùySg{oêlDˆÞTùykJôÖ•èm(Ñ›*? &–]‰Þ7Ùûðžø]†÷¬ Âó.ÎöŽdlx¨ìó‘•çCíð§Õ}>šR}t¥ú²÷áÃäU†W®#€”-#‚”-[R®[V®›*?7U~@Xù¹5庩ý›J?7S®›+×Í•ë¾É§»J?÷¬\÷¢\÷*¯2€Ù‘B,w%»«ösWŸ{wg²çmÛä+k¿@Dû"÷ˆÃ} ¬ýhLô‰˜û@Äß>#¢àLô¼%‘~q¾*‰»} ùÌwƒ\bX¤_ —²q±ÓyNÈH¬Ö¹v’h¿@ÄÛ>oyã}‰8[Ή™Hf¦gä hb¹2ÓiÌô@$Òr"&v/eoû@œ™ž·"ê/Qq¶\²ö•"ê/Q4fz ân?˃™ˆDZâÚ[ªøÛ"þöq¶\Yþ ò/ñ·d÷·¿[^Ò•èuÈW%z5^ÊâÚSšÈ¿@’ù(Š"Î•Õ ¿Í¤*Ñ¡'õˆ¸ÚODˆÞL‰ÞDýå­‹ú D\íÉÊô.ê/¢LïU™Þ9Ò2#‡NáúêC‰Þ‡ù(Ä0GZæmH¤e IyŽøQ6 ±,‘– e¹™²¤bÙ…å.žö$e¹g\Ä_ R@Üì3d~&ïÊrÊr7a¹K¤åžÁ— #A&³ 2™åÈÉÓ2d’ÄÍÈ™’".–ÇSgdÈlbY¼ì32d$Òr"Ìr$Íd–#IfgÃ)3Ë‘%“YŽ4™©+âbF"-3Re >ö©2‹VÕ‡T™ÛP„*‹}FªLf9Re1,>ö¹27W„ÞbdäÊbyÍ‘+³òce ´ÌH–É4Â4GúLž,“.’eV±,–É2yBâbY¼ì3’ev±,^öÉ2™çH–Éʆ»ZND¸Þ‹p½«ðC®Ì"?.¾ö¹2…ë]-3’e±ìJö!ÎöÉ2…ì#+ÙGV²¢dG> ®°Ñ”ì£+Ù‘"+"dß1!®d·MÉnªþ-SÈnâm?!»UL-3²e ÙMÜí3²e ÙÍ”ìæJvß”ìHIÁ5æYÉîEÉŽ”bYàÌj*–»’݇’ÝE®»øÛgdˤŒl™¼¸AºÌ€DZfdËܲ"&†ÅÝ>#]fc@å²e²ÎE¶Ì­*Â\GºLTþ![&ë\dËd®#[&íqN„¹Žü™C,‹³}F¶L^Í"[fËh9æ:ògâkŸ‘,“©Žd™y}Y–‘,“g…̽É3MÌŠ¯}FªÌ*7#A–¹2ùŠøÚOÄøÇ‹Ê?¤Êdš#W&ë\äÊÌò[âl?Ë]hŽt™M,‹·}FºL©°ª›©âlŸ‘.“YŽt™U «D¾Ì¤€‹á®,¯CY^MY^]XŽ|\]M‚,'",Gè(F> ªè\¤Ë–·®,oªþ.“ÕÒe6±ìJó.A–é2…æ=)Í»xÚg¤Ëš÷ª4ïMiÞ»Òù(¸ÂúšwSš#t” #vt §ÎH—É27Ë@5²ö“¡ÊÉ2…æC<í3²eŠ™¡³ÁJóaJó!žöÙ2…斔斕斕æHFÁµeUinMiŽdbYµ˦<7׎âªý-Sxîâj?^Ð"¦‰åªDGü¨X_ûœ}(ÓÝ”énÊtWí‡l™¬r‘-“©Žl™LudËdª1±,ÞöÙ2¹· ]¦˜Qé‡l™[WÄÅ°DZf$Ìä‹’DZfäËÌRF|í'âb˜}í3òev1¬Âù2‹_û@\¾ Ñ‘-“‰Žl™¬o‘-“û ²eŠå¬ºˆ‰å&úÙ2›XgûŒl™Y,«ðÂÙ2™éÈ–ÉLG¶Lž-“•²e¦¢ˆ‹eñ¶ÏÈ–ÙŲ„YfdËd‰‹l™¼Ã „™Žü™ÌtdËd¦#[&k\dËäõ,²e&±Ü„é@Xý![æËC™^M™^Eý!Y&«? .e’½e%z+BôV•èHE‘q¹ª+ÑÛ¢#…v¹H—)Dï›z‚Õ~H—ÙÄpU¢w ´œ‹?$ЮwñµÏH—)\ï®\›r}$åz R$+ÕGQªªTªþ/ó@˜>†2}˜2}¨øC¾L6cI‰nIgSí‡t™BtcOûŒt™ÂsëÊsëÊsé‡l™¬q‘-Shî›ÒÜ“Ò\hæâfŸ‘*S8îU9î*ý+S./û‰ð†Reò› ¤ÊdŽ#Wfe@\­2Re2Ǹ\%1–Ù2›Ø'ûŒl™E,‹“ýDx>@þÌ!–ÅÉ>#]&³é2™åH—É,Â,GMf9Òeòƒ& ²ÌÈ–YÄð’#[æ–‘"âbŸ‘-“{ ²eòl€l™Lr¤Ëüp1¬²Ù2›– ËŒt™bF\ì'âbXb,3²e2É‘-“÷6‘-“YŽl™Ìr .–E÷!YfÃâcŸ‘,S:JQÝW‹ûŒL™< S&ÏÈ”É,G¦L¾—*þõq1,1–‰2…åUeeò¶&e Í«+Í:Ê–›Ê>$Êš·¢4o*û€Í›Ê>$Êš7²ÌÈ“YÄ°+Ë:ʆ»øØgäÉäçìYYÞ‹²¼«èCšÌm(B»H“),ïªù&SXÞÅÇ>#OfR€'#$Ζ¬,b™‘'S&„!!–š#tT,‹“}FžL¡ùp¥¹©êª™3y‹<™Âs+ÊsSÙ‡<™Âs'û‰HW1•}È“)T7Wªûby¿[Œ<™ü ˆpy(Ø2BGŲ¸ÙgäÉ®{W®» ?dÎdá‡<™],‹§}FžÌ€ ? Lu$Îäµ,Òdòî&òdJ ±ÌH“™Ä°„XNÄÄ0‡Xf¤Édª#M&Si2y%‹4™Lu <+ O&k?äÉd®#OfËâgŸ‘(ssE\,KˆeF¢L^É"Q&“‰2™ìH”ÉdÂdGêL^É"QfËâhŸ‘(³ˆeUH”¹EL,«úC¢LVH”ÉdG¢L^Ë"Q&ïp1±,!–‰2›XWûŒD™Y,‹«ýD\,«þC¢L^Í"Q&“‰2™ìH”ÉdâbY|í3eJo©c™‘)S̨D¢Ì-+ÂœH”)doIÈÞTÿ!Q&ë\$ʲ·ªdoMÈÞTÿ!Qfædo®do*‘;SÈÞÅÑ>#S¦t•.1–™2…ìø$–9Æ2#QfÃC¹ÞM¹ÞU¶±ÉW>è$#M¦}¨þCšÌ"fÅÏi2…çCýì‘&Sx>†ò|HŒeFžLÞßDžLṩþCæLá¹IeFªÌ*–ÕÓ©2…çÆA–É3‡ r¤QFªL¡¹©D®Ì¤ë\$Ï–{V–{Q–{–»Yf¤ÊÜ’"Âr„ŽŠa–»ÄXf¤Êd–#U&³÷¤Êdù‡T™M,«—=ReòŒ€T™[WÄIJzÙ#UfËêeT™Ls¤Êdša¡‹ä™üSI½ì‘*³Šá&4GªÌ$†õ«ÌçH”ÉÒ‰2™æH”É"™23d9–~H”ÙÅ°zÙ#S&Ó™2³X– ˉ˜X– ËŒL™LsdÊdš#S&Ó™2y>âl¹¨›=2ev±¬â™2³XV?{ ¼ñÜ™ü™2™èÈ”ÉDG¦L–¹È”ÉLG¦Lf:Ë*þ)“e.2e Õ«zÚ#S¦P½ªøC¦L–¹È”)ToêjL™BõV”êM]í‘;“w?,S.Rí‡\™Âô&gMD˜ÞÄÓ¹2…é]¥re²ÈE®L¡¶t‚®º™2…é]=í‘)S˜Þ%Æ2#U¦P½»Ri(ø¡†ÄXf¤Êª# [FŠ¦ˆ‹å¦TêjT™ÒQ†J?¤ÊLE¡º©¯=ReÊœ`Y©nêlT™BuœdÎÚRݺR¹(¸ÆLb,3Re Õ‘‹")"Tw9×(#U¦PÝÕÝ©2å"•@\ʨ·=2eʼàf‰L™LtdÊäõ,&:rg2Ñ‘,³3 a–È•É*¹2™è@\ w&:rev1¼Ÿit¿U„\™LtäÊäž„Õ²g2ב+“U.re6±¬Q–È•™Ä²FYq±¬®öÈ•ÙIJFYŽ¬úÉ2?˜êÈ•ÉTG®Ì&†Uþ!Y¦˜QO{ ÒS²ª?äÊìbX<í‘+“³È•™š"LtdÏd¢#Y&w¦¢žöÈ•YÄ°†XŽ"FÔ͉2‡˜U7{$Êd’#Q&_TÕˈô’ª!–È“É$G¢L)¢NöÈ“™’".Wiˆ%Rer·ir˜QF¦L!yS{ .vTú!UfËêcT™Âò¦Òˆ°¼©=Reòsv ±D¦L!y×KdÊ܆"RD=ì‘)S8ŽÀQ¹jð)Ω2¹*ºzØ#S&ÏȔɺ™2Yá"U&›êaD8>4™2»ÖKdÊ’°"$r˜QF¦L^Ë"S¦°Ü²²‘£lÙÔLjÝ4Ê™2e>0Õ~È”™Å²úئ»†Y"S¦0ÝÕÉ™2yw™2…êÈC!–›RÝå0£ŒL™ÂuW?{dÊ®»j?äÎd•‹L™ÌudÊ”"*ý(“¨þ®~yõ¯W†#ÆñþÊ¿î#æñ[Ñ$ož]ÿóõ«+øFÇ·®Òõ?Æ¿¿½Ú®ÿá*]|¸±š™ðå¾BEC~áÃRwv ¶²—†K¡Rd-…„AÐt÷¥.ÈRjºñö±Þ×YKɽ.w¿”Ú®¿‰Š Â?Çÿž¾¼þ»GWõ+Û®ñÊÞ9¾ŽZ™E®ÓÌ;šëêõ£—W_žR¿¹-˜lS?%›Ÿá7{ÊÛ=žóò¹ÞüúÑ?^ýý£h ´qŽð—wHÃÜêkVÍ¥ê¦Ñs_ªmûaô÷¥.•Ê{žç¥ÔP)¼@,Tê@¨Ôq¯K©åîZ£zoQÏÈ“Ÿ1)`ƒÔ¬ãíÙg[TgEê k§üì6Õû¯u~ý°RÖŸéƒÎ .α„zóLÈ7ŽÍ£ƒ¼¸*›|žE^\}{¶ü;: ÞÁBnÌ°ÇÞß<úíý##6Î÷ÓLc8µý‘ß_vý쎴1ŸÞ÷øtûþñÍõíõ‹×ߤøöì1;iäù·øÓã›û*øå¼Ç«†Iÿ/q“Ú1˜ý:>õ‘žÀ˜iîéy Íg¿rJ9ö+>ý»þJÓPôÁ†¤Š?R“ý¼°¿‹º[ÝTZcýº"3›ûzÑt+ZøuöF‹‘2_­E¦3Ð LÏŸ˜©4`wëYùgfVô˜¯f–ûÀ‰0tï»ãÍଗLÀþJe1gdÏI¹"pŽY­Ì7! ÐgnñØßq,6b<ÊT%»ÿÊZbÌõΊ¸4ñس=.EFÖ&†·*ßþØß)¬ÈFó}ÁàŒîL6î¬Eê™ÙfíµÄž5q-âÒÊðû¤jñ,­¼{a¬%v焵ȞÊpEöÌ5÷‚D¹$*Àž‚pEú\4¯È’!–³­‘›…¾ïoù—KÒÌ ¸™/ðW`HC#¶’8†HÊÒØ7^—kàŒ˜éûô¿ ûq÷+âSO.¼ÙrÙß„¯H•¶F¨"s ‰I,»p Q‡ê/ÝùÇë~|üŠô¹[Û…ÕŒKkãÔ'®œ¶§f[‘ª­Ýºð |\¤oB7ç݉Çc*âîhLE]çÆ!JT31HƒÄ£*Âã*ßÝhÚÞ£3ãèV¹QlÏ?±"I(‡5inœFÄ@×Ö6SÊÁ‹¯ò¤ÍíEFWÄŒenßs9¬ˆÉøŠè¯RIÂ;Dvqƒ#Ž‹X„mmbÙ„yÉ*l9ebo5Ørj<Æ"–*‰aâ!TŠQL<FñÝäÆ{£*&‰a“–@ô³ˆUâq±JΖK“VGÔSQGL=Dq«#~HŠjÔÙpÂ=I£·¿YÛ¼U!âu¤ÍÛІh.ìCè ¶ˆ´áÑq5<Ú"ŠÆØrB?DÈH£Mø‡ðiõQ…v‘VC[b8;aVÄ­pË2Þ"E.üS6”~æÒèž”}žµÑ½*û|×^‘!#.‚<*YFL·:"8˜~ˆ×àVGt·b1Œ—FG˜ÓA<æ"„‚釈 )2¤Í ÁìCì·9b˜}là6ÇŠ„Ûa .–]Æ\D$𘋈ntDð“ã þ©bÒè`ú!P€aL?Dð Ÿ®Òj2äb—CÚ¼íq+R´ÍáCǵ—9~ˆfÚèxÍÑ“6:\Ýø!°ûÁ–{×Vï{àŠ¸¶úHB?¸µK‘ª÷2~ˆa2æÂ÷œéßs¾‚‚ŸÁö €éÚèfÊ>ß´Ñ= û¼(û¼É ¿nÃ&C.|¶3IÚþØm0Ò„}p¿61lÂ>xRs›·ãÀ)2äÂ'š‡\øD»X6isx7¶ ÷£ÄH‘F‡Ÿ2Ó^É›X6¡<Ž¹ÕÛq4ÍŠ”ùaEš´z;™YãV‡pcÃðÒᇨEÆÜvœ³"CZý8äeAÚ¦­Þ²¶zÓýøØJ«ïg±¬€i£÷=ÝöŠdráëR¦1ûàå*mÞ]Ø׎ÃOV$k››¬HÓ6?N-Y×6?%Y‘,c.¼F¥Í­)ÿŽÓDVd÷lXã¤ÉÚèÇ1 +Ò´Õ3>VÄeÌ…_&·úô¹lŒÔ³ÙÝVdýà*Y¨zúq¨ÆŠdnõ~œ—±"]Z>̾éÁȆƒ.VDöuà‹ÈÏÃ$e†4z?N¤Xýü‰ÈÒæpdöõã$‰Ù_k¯ˆ ûàÖÇmÞ V¤J›O=~ˆ:dÌíÇÑ Ò’ð¯Ç2¬Èþ–xEºðoúÈ1àB¿éÿÆezúÁ½M½w¡ßt]Ë.>’ ¹ý8¿`Eö·©+Ò…}ø$f\ÈG1it+J>«ÚèÖ•|&û;ý8 `A<É;=µø*oJ>ïB>7ir8T1ù¦CUa¤ùàÅäGbý1aßt|ÊŒ$aœš¸ÍáÂ$uaßôNâ2y“®G<âÂшÍä&ä›ND‰òÁCˆÛ|úñ3”"m>}ø×˾<<âN϶\³4útËaËpÂ᧨C[6ümÓV‡û ?E“=xÆH£·!Cîôzá¶é{¬üŠdiô®[<Ó]…Ÿ¡mtø¢ð3 Ýâ™~&ln%ü£i«=ò|EL[Ýdgú~°axzH™¦ôƒ× ü? €ƒW Ü1Ø°ïqÜ+Ò´ÍáXÁÏà.m>&:#Yè7="#M†\ ÊC.ÍlŽ‘‰‘<].W¤ ÿp '·:ëdþálNnuœÄÉüù›<èâ”Mtq¦æÆ–áfÈ€îñàpLnu…É­Žƒ/™~8æ’]sibY7yp`%óV[EÁÍŽ£'¹.êÐV¯.üƒSógHò ‹"ÙLÓ=œébصÑ{úádG¦Nm”Fï]ø‡#¥Ñ»kKŒ$ƒ.WäAG)ò ‹“¥Õ‡ qN"Ç J«[QâÕ [¶®Ä bÙ•€ðábË^¤Õ]7ypÌ ´ºçR­8Tù‡;Eè‡ã]Êt¡Nú+bØ¥ÕqŠß` H£ã€¾MÊtitOú† gíñç$ƒ.ÎÑãA§æq›ûq¦ÍŠ˜°Gàq›ã<¦öÛüŠýÅé°¿|íóëíù#þûeÛüâÀ??^û-Ç º~þ#=ø'/?éÁ?}ÑbÁÒæÉo¾×;êoåÞQÿúöú=;ëÿD§ùŸè¬_çñ6ë¨qAÔYÿájHñÃ!èbJ]«s ²žÛ”ñß>uƒQ»K~úææ^qîéôՄ˶ž^¿”ùÍÍ-ÞÆë§ÏpbÓé»å‚7ÏPhk–¬Ûééþ%®ivzþöùëWÇÏÔrzòæù»o—+_Ò•ïž?]¿~~üÚf§'ûÇXqœ¾^.òöÝQ&åÓ“WË_¾:~3náÉÓînÿòýúOÞÍǃ÷œ{ýr}Úõ¢wOÞáù–;zq¹é¢·>÷ë›[¸7§:îî´¤¨¬Ëc–Ó»×—Æ¡|»ÛìÈ1ÐáTŸbÚ¸EÎáåúÑWW§AWÿ«_ÅÄ¿tŠ[än)8mu›…¾Ù qÏÁ{ý2ÚQäñé!CˆÈ~1óþ!3и-†°YäËÓã›xÞ>}qùTN/nbYÔÍ'Ðn¯‘ É‰ªíýwó[í±,Äýà™õ†°o-ýØ Õ1¸¡Ÿ}qØ NâýYÈì(×>)æ>lu¯Uƒax5ô¨ïG?¿:ýíÍÿ¸‚‹˜oýîûýð—ôC%ÿ&¾Ã“>Z˜þn}<`iÿÏÏâ?úX1 ¶†%G›U´?Ü\y~üÉÕ‡Ú{¨[ÀƒT!­%°Oßb\?á¿]Ú Ÿþä¸/þÕ¼ÖÊ€¹[œ¥ÙbøÆÖïñ¬/ö®ƒ'ôèr§Çúôyd䣋1ê'÷áÓŒÖzà™f>ƒbG©?yÈœ±î íÏ¢÷ƒ-Ê¥ö¾ŒþqW5ï/U“¤É†m—ÚþošD¼Bç'ŒžŒ]òíî‹[Th¬›×Y0=ôHš£+/¿qö›Œñ9Ùˈù×{#bë+ÖõK3>\ÿØ 4·K•|¿6»~JÿæÊ*“ÌÜD|£h¢ûþý“ºÃCfð.(á©sXy¨ÎÙê<…¢¤:ÿiý"•íÕþЛÌí¸ƒuŒR>Þ1îf¢Ÿ=dâ',\XóГÌÞuWdé^]F‰÷7·½¦ÿãø$÷CêüóÏ]MRÌÓ~ÛƒU ³á-YÖ*ØoåQgæ CÆË‘ìÇ›¶½+ÝÂ×¹Çôp oÜèöóÆøv‘b—~?B$NÍgímÔÓëUÔ½øýñ‡P ïärø{oƒÚ*öÞ½þï6Öw[̆Ÿî2 Ð%˜% ëòµË|{‹ûˆ›C@ö¼ÿèãD¸g÷zzþ~ÜéôúÍ»P{Ð -‡²: …8T 8ñÒY|]*ÊNÿp?°¼¹Xm׌Q_o/µm§ß~ ÷+Þ^n0äÛ“yר÷ßíŸB]Z²·ì|{¾_œÌ…AÌ“o>¾hâž~,`8w».óЄ1×L -xXý¸¹.>æZíX\ý¯çß|ÿÀ¢aöÂ?äæþµ¹¡VÖ_ÜÇŒçÍc­Å´NOð»ço¿'­ÿüßV&­tz =‹XÉñ qŠYt\®Ó‹hÓ$t*¡‘Ð;ÐaâêyÎÚÒ?ß¼~sù‘XÀ½þz/‡u„vêy}•Þõ„Wm/èÛÛ·‡5·ÓùêcÙ—bAb0o­™ïþk,Þf¤[,eB£=(±;ú ]ÛÏß?®Ÿü É}»”ü2—Û4=¦<¤Áƒƒ¶ì2?;­´ô|¼Ïµ(Œw_Ç{ÜèNÛ¡[‘M¾Û˜åþÓO¿ÓYÇ€öîíÑþ©Æ¸ðæÉóo¾ã@,ÓOïÖ¥íë7?ÜäÙ¢£½Yšz[æ¹”ØÊ@2/ì}à‡ž®Äë7ŸX–¿ÛWå!liÑq±¥ §mÅgcõ¨ç*)ª‚KÉT¾a~Ÿ•Ÿ?Y÷›Q÷˜6~ZÝ?<ëŽf•†8/zïéù>“T,º™a¼€ÿjéíÏ÷Í‚i!ž¬ã4mŒ¼¾kÃ÷Ï_Ê ýpŸÅùC¢ÍToiÜ­¾?{Páms §Žß·O×ýŸ<ÐDýÜ Sô'îæÒ<·÷¦¨Ò?Ø”ÙP°^c¯Ù»ª1 ¾ùf­õ‡* oÊkÿär¹Ëð®ë²Ü?M“£o¾ÕÓpþ'øCv5î4zÑyÝ™9ñ'ìŠCU}»ì¡éÃÝ"Ðjß©|ôÚ—$õ¨ã^vŽr£=;ì!ƒÏþ¼ŽiäXý‘S+^ÖbnÅ©%}N­iûcæVäJ ¦ÞÛ»Ô%|¥-Ÿ>:á¬Üâ½ÂwÏ׎öÍ¥62Ï…OÞÝW“N’óL¶jºƒðäíï¿m}ß”Ãçhp]y¨xy§ò~s§YyhÁÔnõ[’S^>¸|¶”ýÁK¸õ8‚´1 ’Ú~r̺岩óÓ×.'q/^øVî»óLoF$c¬µþÃz3bK‘Î|iܺˬ½oÕPu8‹yËÚqíå»|¿ÅuakŸÕíXþÓë9× (¿‰˜œý9åUæ¼`ô“‰6Ò×Uà‹Ã*úæKÒ¨îaÏ‘è¹ÆÔ¸ïaÇÀ¿Zÿ~™9_`}: Gƒþa[ó¸¥P±S¹à¡{åzþ²ÀÑ«ro1.9ùe`CÝÿ›»Úÿp}9ï£æ-Æö'Ìs5Ëjà7k)1žÌ—û3æ˺ÿVûQ‘Ϲ^v©~Tw±èåJ¹ÅQj£`$ºöv™Ü/#Zômš¥¾¡øíñöÂêñ&o5Ðg¦òËê7W^5½ùSšêf™ÒN?|~y2î&Ú㊘h¬œœïöSuãgßB{öÐÆOF`t$r,b§_¿¿ËôYÂÛæÝÛ7Màc<û,ä×ÍíŒÎÙÒé¿úúÁW Lûëúô~Û|±×O?ìý²öÓå…am—s÷[û‹ÒÆëãíàóL±'5¤+sŽ/¹ ÷ËÜßûöV~bßÎÐÎGßÞ/ ½/ÕOßë.úlßÆœX}'ß¿¼{é«š5*·yŒŽX>½¸ •«åý±1XzåXÎù~ÑËéîñé~ýšÄ×ñóét¿ˆ£=»EÍý)M‹—2?,›r3¬ù‡ùªNJQpfy¹ããù”;GÌPH.>úª?! ~9ÊÆõ©ÝoÛEÛ·ëùº²îëã4—D±R³ínƒùí3T3¢Áb<ÿîÅëw—!q,—⌬:îÞÛ=ýþÍïž=¾s–¸OfxPpœnïyýþÂ䜦ïÐç—QÀ§OÐòõÕù?ÏÝðã֛ψôv¹ƒ'¿™Ú#‹YßØNeo‰=û|(w÷ÀÁ×]¯¾9þfmºÔÝâíë—7s‰ˆ£yOÏ~øvrNí1ª~ýý¿ýÛï/—ÅócŸ|.(·«ÇulËý&¤°ø@s¬Í‡Ô ÁðëÛ¹­òG.…¨àùN±þòêÿš·Žendstream endobj 164 0 obj << /Filter /FlateDecode /Length 8986 >> stream xœí}ÛŽ$É‘õÚ¿ —|ÌÒNæ„ßÝ PÉ].–š•v{Ú‡iBHÖÔôYÕÕ¬ª¹é ôÙ:ÇÌ#Â-;{.䬀§3OZx˜›ÛÍÍ<¢þ²›Žn7ñýßëûÓîÍ‹¿¼p‚îú?×÷»ß¼zññKW€ÛÔÜîÕ/ô·«nWR9¶v¯î_ìëÕ«?6Å‘6¤£Ëä¯>ñÙþ×WôÕ‡ýõÕa:N©…)Uûå«+~ŽÕ·¶<=ߌ¿Ý}wuÁcˆ¼ÿíÃý»T/K-Öº¾};|{sõ‡W¿Îk\8»{xsupá8¹ê÷¯÷n¾Æ×ø|ôzÁþ:Ù³1åãàr‚šž§Ç’0¢Ê‚Yº¤ƒPçi¢êt‰*ä€Ø•ÉE+Ó XIcî,‡,¹LfpTñØrwAº¡+ÑÏ'Í!bOÇ"1&ë¸U"’(AP†½¨êÆ©¢ˆˆ^¡è‹gõÑ‹^3Vü<ñ#ðˆÝe#¿Îê²L2"ty Š‘VL·—ézR¤ˆË$38¡Q4‰« $Yaf>¢¬@ö¾ªÛW{Žˆ\QBbè+GP4Åè·F¼nÊŒ~•tNò•\BØ b…S•˜Z0²MsAü«ŠÆ8CIÉ©:p²®K¥L¿MÞzjíé-¨CâkdŠ þBt\©–Dp¦"€ p®žÎ(Á³KŸÂÌMÀcéæÍô‰<’‡¤Hë¾»õ)A0¿a`:¥  "o÷ù4uœaU|*/<”Ö§Àx™äB–Do¨µ®ZP,µ=É¡C€ån‡•° cY?äïS_£€˜Å\Få¶HgŽ™”_ðÉÝN¯¡§wZpQMŒ,aUJD,f€”¼ZvÔr"¾SObÐÑ~BD¼pÙ Z„2ˆ–ˆ$K‰hÇEšlwA‹Ià€4-­Hš´D4"Ui@œ–ˆÄK‰h´D4 ×Ͱî3ìÐÛ;NÒÑ€d- HO:"UJD# U¢i²Ï&µÍYDêz#ÂrŒa™ilŠ¢•l‘"žAÐr†e˜¿ði¢î’¥x1"ˆ[“å!Ã[~àÀ¢jFàʆŸÂmŸá§8©í„U÷ðQõ}E‚ÔR ReË3 \ΰS¸ß5+Y E#¢…¢)v„-ï,Òδ½4­­He©ÞŒS˜ªA´P4 ^ E¤P4íL™j,gÚ^“Š$k¡hDê™2Ul«LµöBÑŠ4)@9ӥƽ£Y¼æ´P4"Z(¯…¢Aô²ºÔàz­.5D/giR:sq ÑËŒ(U-ËE2¼AüòF¦­¹3eo`y9N“”AF„mÑjÄãâ€Ùû "XñAànÁ"MBù€ ŠË¢X²ü©óDR™aÝÈòƒ(-?Mªâ¸4ü°Ã7%ƒx-ˆ–‹„‰áDZÇg€4Yï ¤XïÂX²ì)¤JV8 5[ï‰Ì#Xï=·ŠÕ'„ëdgôÞ[ç ¤Y}ŠqÌê“Á*|ôÉYç ¤í­X–´ìogd{³YvÇœe‡>C&gc:jcz ìô™%>œ)<&; ;}†åÀVŸYbþ3}lõÙqØê³ì°ÕgÙ©“é@êÑÞ QÌÄôÈ-‹‰é‘ h52Ü&vX†ô†°c±H•q@¢TG$iáh@²VŽF¤HA|@Á‹;ÁVßYÚu–Ÿ–­ÿDÎlŠ›}¨ÖÆä“õŸ˜ƒ?S'îà­¾KY԰Þ²õŸ¬(XuâÉÈ P«N,[÷Éž­U'VA­:å)ž¹ÏìÜ™û”’¦a'ËI—áLXµãÆbƒzÌl÷ŽÙB1A=²3ž,Çl÷‘f¶û,Ǭ ZŽÈÌÀ…í>ÃNáÜ̪°ßg¯b¿Ï°SØï3ì”èÎÔ½Äz¦îqÌÞa,X„ý>Ëû}F^E{©#‚0æ,;cÁ¬Dò™¶W¬¶WvüœEªÝÅÊŽŸa§jÍÈ íÌyÖTÎœgEóöîÅYm¯¥ži;;ÖyVvü ; QÌjSC³ÚÔ\Ÿ¿`¡qg<ƒ´ÛÎmgŽ¶3GÛ™£íÌÑvæh;s´9ÚÎmgŽ¶3GÛ™£íÌÑvæh;s´9ÚÎmgŽ¶3GÛ™£íÌ‘†ŸíÌшlgŽFd;s4 Û™£ŽlgŽVd;s4"Û™£ÙÎÈvæhA¶3G²9ZíÌÑŠlgŽäÿ‡3GŸí¸CCºáa‚U·'z`8,àî¾yÁf‹ßÑɶ‡× ¯‰×ýÒ–ž‘µ/]xZÇ }é¨Ø¸Ú—.lL9m k_ºx×wÊs_º¸æú ¡Þ—.L´ÛÞÓ…=:=ÒÓűåµ[ûÒ…©$ÝØÞ—.Së•ù¹/]&aǾ4,Ìѧ¯}é2…¹]ÜûÒeâ齪÷¥[›ûs_šàÞ/î}é–¦¹;Ü[Ó̤uZskš´JÒ;ÓT:v¦+<‰3é ”LgZ”\;ʽ3MÓЙÏi®b6i¸U^sgš¯+ô\ñ…b%ÝÏß §õÀ^ñ-,[h‡±W|‹4ž¤,×+¾EîÙ‘†¯>õzy¯øîŽhÅ·°Sz}W*¾…Í´^ÍÕŠoquaO+¾ØÐ,ìiÅ·¸•a-ù·2¬%_ð½°§%ßÂd¨—jµä[¤¶¥åS-ùíO®_쯳†µâ[¦67—zÅ·0ÇëˆV| Ëu hÁ·°éª¼^ð…WHZ>™ ¾eŠZ¥Õjoa«W{½Ú‹Ý_îµÓ^í-“[)ÆaI³vè—joc×N+®½ÚÛjîµæ¹ÚÛÊ‚ôjoËy®¨jµ·¥¹ 0W{[ìÕ¹ÚÛÀ±6Ãæj/7"ÁT{9¾¶6æj/Ït¤|+û>»¡Þ[ë h¹—m~mZÌå^ MKĽÚ[µ u·V{kÌÚ^ª½•o¥Ðjj¯öV–ýLµ·²oÛk»j®tjU¯Òj/÷«Z+«½ÔÁ¦õj/=êÔk»ZíåVYD¾T{KZ^íåë¼Ö{¹·„b˽Œa,÷–¹¼Ô{iÔQ˧s½·­H¯÷ÎÅýµÞ ŽóVïÝê½[½·#[½w@¶zïŠlõÞÙê½3²Õ{Wd«÷d«÷®ÀVï]‘­Þ»"[½w@¶zïŠlõÞÙê½ ò²Þ«UÝõ¯—_ú«åˆ£MŠ‡—„ùÞÓ}g-ï*¢cýÐ[‰ù6âe,Ç]”ÇêÈÏ÷xÔr/>ÓÂx¯Žü 5ïyðÌçŽàª×Ág„ƒÿô—Esã_*¢âE^}÷ð†¯‹Æ%~7Ï™—ðL6TNþÂýþõ¾Ó˜ayÞ+ÞiÜ2Ì@Âçjsäï. vJòÙþ投çÚöß¾»úë߿ÏC'Ä÷ŒA×C§ùöÒüàÀ§RÝ|××WW®0ãÀ/ýÎfÔCâqòº;0Ê!»’Á!>÷îÒ øÀSúA.uêÿýÄ£?›xJ¾åNœ¥@¨-3ÇbnÓ•TêϼÞð»g³öäþpù¦~âÑë«Å…a‘OfDä<—ÑÖ×­ÿø·½óÍí1è•êý5í÷ƒsuý!O/P-·<“ºMÇS઩ÚÔ÷÷ ÕŒ Tž%b‰ë3Õ‚ŒT|=»«#ÕŒŒTÍ9Ý–-T32PÏ–Ã@4#œOå° #;3²w\¨fd ’=Tå° #Ÿ‘”l¡š‘‘êl͆U¨~ºçFybnÌg´b£ÿlŸ®^*2uï&|æÓŸ“|F¨Þûö3œó> xHýs û8­41­4iZiÒ0NžÄvÅœ›wƒóÔ S³ üÕ‚p÷-TR± UGFª€]˜Y¸1TÈŠK5T©ørç2ªÊ‚ŒTÜûTg «##«°uÔà©øófæ8#† é]3cÍÈHUCÕÜv¡š‘‘ªÍåëÕà;2Pù)N£…Ê×ñw7Mw’1T%êp¥êÈHÅz3aF UÑÇSªŽŒT1öl~¡š‘‘Š/ˆwÅ8ªŽŒT|jÓ0ß‘†ukoä0#†ªè»×ªŽŒTÒS77œ‘‘Šn#‡¨Â„L3ŒrX‘Ê!Ó £ÄP•¦Õ®•ª##Up}C»P͈¡ªZåY‰iøhhå° #UâŽQ¦ 2Rñaëdä0##Uqú§8Vª1TàÉÈaFF*n಑ÌŒT­ÝŸ­A©#UäCïe”Ä‚ŒTÎë'ÄPõgDªŽŒTÁUë'ÄPÕdýä‚ŒTü[ÆO.ÈHÅgk«kFF*>”nüä‚ŒT,??¹ †Š¾IÌÈHÅvI5gAFªfYog|ŸG¿!Ž>yùë<ºƒ¾_õ˜Óe*>slwÞ Uä雑HC“sê1`&ꈡbq!ªŽŒT…-l/Wª1Të Efªa†?-âQ¡&YÿZL’ -R 9sç!£ÉG¹‚ 8î}ue/;W/&ù3­cÛÐënçG…7}Ôòã¶ú“GÍ?‚×ðãF$þ]$ÿ]$–Öj<öaŒ¥ô7:|z‰¨?j¯€¥Ñ*ôH¤ˆ¥BôŸ,•"†*8yÅ@ÕK7ŽçH¥ˆ¥*²O©J?ë5R5yÄH¥ˆuNþ>Ï@ÕKå¥Ö>Rù~*l¤ r°o¤RÄRé¡ž‘j>æ3P%ßKh UòK m¥Jr`l¤JýÙH…:eC¥ˆuzÓ¹$:b©œô‘F*E,U?û4R)b©xüÂpßK•¤A1R¥~Ðt *úº¤ª#–*K{f¤RÄRUy}¤ªý‘ôÑýOrk êˆ¥òràu¤òýìHÚ™utÄR±Øfˆ°4YÎ|ŽDŠ*9.`dÚKÅ¿ifV±#–ª%­Ç®T-ÍõØ5 º39̈¥‚q†HK“µŒ±T©X‹KÅ 4C¥ˆ¡r[·ÿ|@oÿ³ 1{žéÝXEúöŠ¯ÀÂ6~ÿ<ß+í¿¹‚<'ñýéJ$[Úþ»§þ{kûç‡õó[¡ m?2roïx{iÈGŒCýÛOõU8}F²Ê£Si?®÷I]5Bå×"iä™JÊ÷Ëyã+ŸLlÿ\Çk¡šñnß|ÙHûw6£˜Äaµo¾}âŒú%p*·Fï $¼Á_÷•‡´êë§ùàÇËKVã%-V3òyº–ˆññϧ7= A±^Ê[øRWfi?OÞ"áš“s!«„Në„Ín»GîF­!0°ß”ÎGxäB4>ò²¿Uÿ®ß|ªÖ#œžç–•Ó î—°Žû5p!Y¥:†Ünß·o‡oo.z>>Öò|å‹KkHûb¸³§aÎ|øÑGïf~º4 Ÿ'ÎÕ¬@ä6€î™ï¢epcbp`“¹Ík„¡¾–ÎÜ«!í—¸Ñ6Ðçé,ÐÓr%Òûq “`æµ8÷}³ñá^‡u¨>9¾¸båŸô33ÓYÕ³%~7(ñÝíÓY¨X)é ï– ˆÿÎÎRWwtNyÿOó°=2®æéév ¤o¸oÑì™&ݯPbñ=Ÿ]¥$0ûlFÒÓÝÓC¼Üµ¶`r澄j}âìÂÊ7d’=ÄXfóW1ÿÄ MQÏm4Ål#N²oJl| W…2™ø¼Ø¼—n·¾7?s|ío˜ÍéÍeÛÆ]ËùÉà .¢¥¢çžFó¼ÑGðgLàWýc›èêÅI «}]ÎûS~ßœ§ý•©Ý…¼ÿ|ššøÊÎfâœ]©Ó,äP¬©Ê‚¥2‡À„DÏDvc§_KÞàr~ß plŒ¨6ž4aûYL7òM—ó´ð·gi|¥vŽep¶Ý)ÈÚý÷‡E•ó{aQm¬:Ãf·œzÆHPM^µ¦¼=ï!ìO2Z~ŽÙÚŸxjü@·ù–4¶ãzi‚xŽ õ°ï¸î _|º½;{³»åª ÿÃÏôÁX«7o?äÙŸõN|N Ë8z¬ž}™0(G/[7–ý§ßÜœ¾¾¹¸qAœãr蘮nCUnæöGùɉÿù†¹!x¡òºË‘jæ0ƒñÛ¥”‘ê-ùàSFìá~ŸlÝäúlkµÞ[ÌÂCZ5f[÷³þL|ÖæNFFµ¹X<㉔ÒΓP½x¬õ| eÚ±”Þ¾7æ[XüúöŠâà&ñê$Dï÷’ãþ9Õš!øû½ Ï#KðzŒœÄ3OAFî{„úôF÷;, ùýøyÍ°»ø§·2·ØC¸ýÃã½½MöCe„o¨tªŸ¼xõ_  ÿ ûæŸZ€²=?|‚`õíklnžhôá5í#’$Éyï®Ow7¿úݯ?ùô–SágÊŽØ™V™FdÙBæñú..E¨TߺÊ6«Œ‚šýw³HÉaG?S§ý¿ˆó€o‚¿¹–|>Vë–ßs¿¼2eîÞás“;Ly/î+$Q8¿ËÆ+Ç({,¬ùåxxw}¸»}ûÕ·‡7o¿ºd‡~Ñ­ GGGZyhßדîÇTVm æ£n×Õ®úéùdÛÏOuCªyÿæñïm"g‹ºÖkÏw€§|óx§a2Ã>‚êÖzÑ{Õ›ñ"*¹T?“a~½:cÇxXv»p{÷$k{¦«ÿãRèìAFú›㟻!èÕŸvVaCå|1ÎÑ}ÔäKK$V¹ØHÜW.íq›CZ&½ƒkz0ˆø­âúÛ»%[¸ûÎô©î»®!ž œºwöÀâäÏRÓ§/=Ýß>]÷‹sÂÅŽgö$1Y®þ Í=œ>ÿ¬ç@”}ßt‘œæ‰GãõO÷æê§Qn}Ó©E¸ýlUL­Þ«C‹Ü[Ûž.ûéù¹ç3°Ü믯dééì¿/Ù¼µÙæãìÕ5–/FZ¤¨':ŸÁÖÝÓ•5è/ ÒZ曳àÒvL”ržãÈK¹]áS­Øø1‡ooÞ^ß åâ¡Qü~'giendstream endobj 165 0 obj << /Filter /FlateDecode /Length 1614 >> stream xœ­W;s7îY9ERe2,qˆ÷CUäX±å±œ±Ä¸ˆ•âLRÔ9$>ž¬ùµù)² àdC{’Ø£BÄa±»ØÝïÛÅÛ1£|Ìð/ýŸ­Gl¼½ñðuœþÍÖã‡ÓÑäB+øB=ó|<½Å#|,Œ¢Lé±Õ–z©ÇÓõè9¯Ú®Þ¥”>rþ笆zå¹)eZZÎj;^Q,7AZ¼òŽ\úP_¥Ò’~PÁÆS(6ïuRhH=“äÇÌÞ9è´tp2-¬¡L …ªA‰³2¶«fhz—ä ‚Ö…Š:¯º›Åœ™ZàMªUõR’Ë溻«Ú`˜sLÀA›H~’#DÀäBÈ\ÄQ€I„»(3TU¬•òIæŠÈ«â(¢ ÒËLiv.†Cöµ´ê_) s–×tþû9âòÆ8aÌ;@&cáœÀ(‘_.ž…{NG/FŒêÀíÇiFòƒ4£,Õnl¼¢ÞrdrÓuÛãÉdÞÔ´š­iÓ.'pC”'\rk ÅÖà-£ñOÛ^°’U97v`•† I¯q£UžXèì4«Îô[X¦Hþ¸HÀYÆ4ùy ™"aƒ2Ù’Žû±Ñà*39z¶·¯w´Ù.6K¨mQ³YÕ›nLÏ(ÛûI¨zn@·ª ×·›È“zÓ­WŸ9Á •`£4•Úf˜ãB‡è. ÅHÌ’G½ Í”+;ÄÖªÉûäzwx†‘ÐÒ—"?6í"®ÂÐSf¨µZ'žáò`ϱÐT­î3}#ƒfÃv~Òÿ´d•Ï2›åmµ\¤M@[µ™ãÂ…®´Ø¼«c?ò0u4›õbÓ¥]8{Ý´ñ‚aƒ@Qb†ÔEè9ÚÀgìNa:R¡;;NjЭÂÆ~ ãÜ2B‹€ ·…+ò²Þ") Ú§PÿWÅÁº×ÐQËÊ^†&ê0«&1dƒŸ ‡ó—'‰¢"æÔ1L~a‡e?GÄ-Œ…𨋈 磄œV½ÿ“•öPý¤K³P\-qÌd8ò²Þ£Úý&©Ò‘0¦H§NªÁÀ³ ¼æ–tmÑg¯êc43èËŸß;.KÏ Íð2&æShÏeÌa ü^ËGo¤ Þ|Þá’Qo ýÃ*߉xîîîèø0‡[ ²m›7‹Y‡ ”YþïôaÌ 67écròßåKîl,<–ù@e'ß­êPAÇ'(K ‡§ÇôÙhúýþÇÆ7BGÀ³f\+¾p¤sB¤Æ\÷J.³šîKúŒ$ëzð i“xä³ñ_™L³÷‘òþ=&—ù=ù£¿Ó½Í£¿% 2endstream endobj 166 0 obj << /Type /XRef /Length 188 /Filter /FlateDecode /DecodeParms << /Columns 5 /Predictor 12 >> /W [ 1 3 1 ] /Info 3 0 R /Root 2 0 R /Size 167 /ID [<40b51514f38aa53255252694103d88b6><183909074876c1f1d0c020c336a1b6b5>] >> stream xœcb&F~0ù‰ $À8JÒœüÏ páÍn ù—¶£!O¿Wz yÑ2P˜ DƒH6MÉâ"ëÁl)¯"¹Þ€ÅÀl'Éa‘LÞ Rì$XÄLjHÖ) R„lZ$ˆd¿"EM@¤àa É(8ÄæI‘̳Á¤%Ø„å Rœ*ø À&4€Å™A¤ÚM°$ÁêWƒHËù`•¥`5† ÒbÈ|å°½3»YÓ endstream endobj startxref 141146 %%EOF Rmpfr/inst/doc/Rmpfr-pkg.R0000644000176200001440000002650514552770156015076 0ustar liggesusers### R code from vignette source 'Rmpfr-pkg.Rnw' ################################################### ### code chunk number 1: preliminaries ################################################### options(SweaveHooks= list(fig=function() par(mar=c(5.1, 4.1, 1.1, 2.1))), width = 75, digits = 7, # <-- here, keep R's default! prompt = "R> ", continue=" ") Sys.setenv(LANGUAGE = "en") if(.Platform$OS.type != "windows") Sys.setlocale("LC_MESSAGES","C") ################################################### ### code chunk number 2: diagnose-lib ################################################### if(nzchar(Sys.getenv("R_MM_PKG_CHECKING"))) print( .libPaths() ) stopifnot(require("sfsmisc")) ################################################### ### code chunk number 3: exp-1 ################################################### exp(1) ################################################### ### code chunk number 4: exp-1-dig-17 ################################################### print(exp(1), digits = 17) ################################################### ### code chunk number 5: exp-1-mp ################################################### require("Rmpfr") # after having installed the package ... (one <- mpfr(1, 120)) exp(one) ################################################### ### code chunk number 6: factorial-1 ################################################### ns <- 1:24 ; factorial(ns) ################################################### ### code chunk number 7: factorial-full ################################################### noquote(sprintf("%-30.0f", factorial(24))) ################################################### ### code chunk number 8: factorial-mpfr ################################################### ns <- mpfr(1:24, 120) ; factorial(ns) ################################################### ### code chunk number 9: chooseM-ex-fake (eval = FALSE) ################################################### ## chooseMpfr.all(n = 80) ################################################### ### code chunk number 10: chooseM-run ################################################### capture.and.write(# <- in package 'sfsmisc': ~/R/Pkgs/sfsmisc/R/misc-goodies.R chooseMpfr.all(n = 80) , 5, 2, middle = 4, i.middle = 13) ################################################### ### code chunk number 11: ex1 ################################################### (0:7) / 7 # k/7, for k= 0..7 printed with R's default precision options(digits= 16) (0:7) / 7 # in full double precision accuracy options(digits= 7) # back to default str(.Machine[c("double.digits","double.eps", "double.neg.eps")], digits=10) 2^-(52:53) ################################################### ### code chunk number 12: n-digs ################################################### 53 * log10(2) ################################################### ### code chunk number 13: ex1 ################################################### x <- mpfr(0:7, 80)/7 # using 80 bits precision x 7*x 7*x - 0:7 ################################################### ### code chunk number 14: Const-names ################################################### formals(Const)$name ################################################### ### code chunk number 15: Const-ex ################################################### Const("pi") Const("log2") ################################################### ### code chunk number 16: pi-1000 ################################################### system.time(Pi <- Const("pi", 1000 *log2(10))) Pi ################################################### ### code chunk number 17: pi-fn-Gauss-HB ################################################### piMpfr <- function(prec=256, itermax = 100, verbose=TRUE) { m2 <- mpfr(2, prec) # '2' as mpfr number ## -> all derived numbers are mpfr (with precision 'prec') p <- m2 + sqrt(m2) # 2 + sqrt(2) = 3.414.. y <- sqrt(sqrt(m2)) # 2^ {1/4} x <- (y+1/y) / m2 it <- 0L repeat { p.old <- p it <- it+1L p <- p * (1+x) / (1+y) if(verbose) cat(sprintf("it=%2d, pi^ = %s, |.-.|/|.|=%e\n", it, formatMpfr(p, min(50, prec/log2(10))), 1-p.old/p)) if (abs(p-p.old) <= m2^(-prec)) break if(it > itermax) { warning("not converged in", it, "iterations") ; break } ## else s <- sqrt(x) y <- (y*s + 1/s) / (1+y) x <- (s+1/s)/2 } p } piMpfr()# indeed converges *quadratically* fast ## with relative error relErr <- 1 - piMpfr(256, verbose=FALSE) / Const("pi",260) ## in bits : asNumeric(-log2(abs(relErr))) ################################################### ### code chunk number 18: Math2-def ################################################### getGroupMembers("Math2") showMethods("Math2", classes=c("mpfr", "mpfrArray")) ################################################### ### code chunk number 19: round-ex ################################################### i7 <- 1/mpfr(700, 100) c(i7, round(i7, digits = 6), signif(i7, digits = 6)) ################################################### ### code chunk number 20: roundMpfr-ex ################################################### roundMpfr(i7, precBits = 30) roundMpfr(i7, precBits = 15) ################################################### ### code chunk number 21: asNumeric-meth ################################################### showMethods(asNumeric) ################################################### ### code chunk number 22: format-ex ################################################### cbind( sapply(1:7, function(d) format(i7, digits=d)) ) ################################################### ### code chunk number 23: format-lrg ################################################### x <- mpfr(2, 80) ^ ((1:4)*10000) cbind(x) # -> show() -> print.mpfr() -> formatMpfr(.. , digits = NULL, maybe.full = FALSE) nchar(formatMpfr(x)) nchar(formatMpfr(x, maybe.full = TRUE)) ################################################### ### code chunk number 24: Math-group ################################################### getGroupMembers("Math") ################################################### ### code chunk number 25: Matrix-ex ################################################### head(x <- mpfr(0:7, 64)/7) ; mx <- x dim(mx) <- c(4,2) ################################################### ### code chunk number 26: mpfrArr-ex ################################################### dim(aa <- mpfrArray(1:24, precBits = 80, dim = 2:4)) ################################################### ### code chunk number 27: pr-mpfrArr-fake (eval = FALSE) ################################################### ## aa ################################################### ### code chunk number 28: pr-mpfrArr-do ################################################### capture.and.write(aa, 11, 4) ################################################### ### code chunk number 29: crossprod ################################################### mx[ 1:3, ] + c(1,10,100) crossprod(mx) ################################################### ### code chunk number 30: apply-mat ################################################### apply(7 * mx, 2, sum) ################################################### ### code chunk number 31: Ei-curve ################################################### getOption("SweaveHooks")[["fig"]]() curve(Ei, 0, 5, n=2001); abline(h=0,v=0, lty=3) ################################################### ### code chunk number 32: Li2-1 ################################################### if(mpfrVersion() >= "2.4.0") ## Li2() is not available in older MPFR versions all.equal(Li2(1), Const("pi", 128)^2/6, tol = 1e-30) ################################################### ### code chunk number 33: Li2-curve ################################################### getOption("SweaveHooks")[["fig"]]() if(mpfrVersion() >= "2.4.0") curve(Li2, -2, 13, n=2000); abline(h=0,v=0, lty=3) ################################################### ### code chunk number 34: erf-curves ################################################### getOption("SweaveHooks")[["fig"]]() curve(erf, -3,3, col = "red", ylim = c(-1,2)) curve(erfc, add = TRUE, col = "blue") abline(h=0, v=0, lty=3); abline(v=c(-1,1), lty=3, lwd=.8, col="gray") legend(-3,1, c("erf(x)", "erfc(x)"), col = c("red","blue"), lty=1) ################################################### ### code chunk number 35: integrateR-dnorm ################################################### integrateR(dnorm,0,2000) integrateR(dnorm,0,2000, rel.tol=1e-15) integrateR(dnorm,0,2000, rel.tol=1e-15, verbose=TRUE) ################################################### ### code chunk number 36: integ-exp-double ################################################### (Ie.d <- integrateR(exp, 0 , 1, rel.tol=1e-15, verbose=TRUE)) ################################################### ### code chunk number 37: integ-exp-mpfr ################################################### (Ie.m <- integrateR(exp, mpfr(0,200), 1, rel.tol=1e-25, verbose=TRUE)) (I.true <- exp(mpfr(1, 200)) - 1) ## with absolute errors as.numeric(c(I.true - Ie.d$value, I.true - Ie.m$value)) ################################################### ### code chunk number 38: integ-poly-double ################################################### if(require("polynom")) { x <- polynomial(0:1) p <- (x-2)^4 - 3*(x-3)^2 Fp <- as.function(p) print(pI <- integral(p)) # formally print(Itrue <- predict(pI, 5) - predict(pI, 0)) ## == 20 } else { Fp <- function(x) (x-2)^4 - 3*(x-3)^2 Itrue <- 20 } (Id <- integrateR(Fp, 0, 5)) (Im <- integrateR(Fp, 0, mpfr(5, 256), rel.tol = 1e-70, verbose=TRUE)) ## and the numerical errors, are indeed of the expected size: 256 * log10(2) # - expect ~ 77 digit accuracy for mpfr(*., 256) as.numeric(Itrue - c(Im$value, Id$value)) ################################################### ### code chunk number 39: pnorm-extr ################################################### pnorm(-1234, log.p=TRUE) ################################################### ### code chunk number 40: pnorm-extr ################################################### (p123 <- Rmpfr::pnorm(mpfr(-123, 66), log.p=TRUE)) # is based on (ec123 <- erfc(123 * sqrt(mpfr(0.5, 66+4))) / 2) # 1.95....e-3288 (p333 <- Rmpfr::pnorm(mpfr(-333, 66), log.p=TRUE)) exp(p333) stopifnot(p123 == log(roundMpfr(ec123, 66)), ## '==' as we implemented our pnorm() all.equal(p333, -55451.22709, tol=1e-8)) ################################################### ### code chunk number 41: mpfr-erange ################################################### (old_erng <- .mpfr_erange() ) ################################################### ### code chunk number 42: double-erange ################################################### unlist( .Machine[c("double.min.exp", "double.max.exp")] ) ################################################### ### code chunk number 43: really-min ################################################### 2^(-1022 - 52) ################################################### ### code chunk number 44: mpfr-all-eranges ################################################### .mpfr_erange(.mpfr_erange_kinds) ## and then set # use very slightly smaller than extreme values: (myERng <- (1-2^-52) * .mpfr_erange(c("min.emin","max.emax"))) .mpfr_erange_set(value = myERng) # and to see what happened: .mpfr_erange() ################################################### ### code chunk number 45: GMP-numbs ################################################### .mpfr_gmp_numbbits() Rmpfr/inst/doc/log1mexp-note.R0000644000176200001440000003075614552770166015734 0ustar liggesusers### R code from vignette source 'log1mexp-note.Rnw' ################################################### ### code chunk number 1: preliminaries ################################################### ## Our custom graphics device: pdfaCrop <- function(name, width, height, ...) { fn <- paste(name, "pdf", sep = ".") if(FALSE)## debug cat("pdfaCrop: fn = ",fn,"; call:\n\t",deparse(match.call()),"\n") grDevices::pdf(fn, width = width, height = height, onefile=FALSE)# ...) assign(".pdfaCrop.name", fn, envir = globalenv()) } ## This is used automagically : pdfaCrop.off <- function() { dev.off()# for the pdf f <- get(".pdfaCrop.name", envir = globalenv()) ## and now crop that file: pdfcrop <- "pdfcrop" # relying on PATH - fix if needed pdftex <- "pdftex" # relying on PATH - fix if needed system(paste(pdfcrop, "--pdftexcmd", pdftex, f, f, "1>/dev/null 2>&1"), intern=FALSE) } op.orig <- options(width = 75, SweaveHooks= list(fig=function() par(mar=c(5.1, 4.1, 1.1, 2.1))), digits = 5, useFancyQuotes = "TeX", ## for JSS, but otherwise MM does not like it: ## prompt="R> ", continue=" ")# 2 (or 3) blanks: use same length as 'prompt' if((p <- "package:fortunes") %in% search()) try(detach(p, unload=TRUE, char=TRUE)) Sys.setenv(LANGUAGE = "en") if(.Platform$OS.type != "windows") Sys.setlocale("LC_MESSAGES","C") if(getRversion() < "2.15") paste0 <- function(...) paste(..., sep = '') library("sfsmisc")# e.g., for eaxis() library("Rmpfr") .plot.BC <- FALSE # no Box-Cox plot ################################################### ### code chunk number 2: def-t3 ################################################### library(Rmpfr) t3.l1e <- function(a) { c(def = log(1 - exp(-a)), expm1 = log( -expm1(-a)), log1p = log1p(-exp(-a))) } ################################################### ### code chunk number 3: def-leg ################################################### leg <- local({ r <- body(t3.l1e)[[2]]; r[[1]] <- `expression`; eval(r) }) ## will be used below ################################################### ### code chunk number 4: def-test-2 (eval = FALSE) ################################################### ## ##' The relative Error of log1mexp computations: ## relE.l1e <- function(a, precBits = 1024) { ## stopifnot(is.numeric(a), length(a) == 1, precBits > 50) ## da <- t3.l1e(a) ## double precision ## a. <- mpfr(a, precBits=precBits) ## ## high precision *and* using the correct case: ## mMa <- if(a <= log(2)) log(-expm1(-a.)) else log1p(-exp(-a.)) ## structure(as.numeric(1 - da/mMa), names = names(da)) ## } ################################################### ### code chunk number 5: def-test-funs ################################################### library(Rmpfr) t3.l1e <- function(a) { c(def = log(1 - exp(-a)), expm1 = log( -expm1(-a)), log1p = log1p(-exp(-a))) } ##' The relative Error of log1mexp computations: relE.l1e <- function(a, precBits = 1024) { stopifnot(is.numeric(a), length(a) == 1, precBits > 50) da <- t3.l1e(a) ## double precision a. <- mpfr(a, precBits=precBits) ## high precision *and* using the correct case: mMa <- if(a <= log(2)) log(-expm1(-a.)) else log1p(-exp(-a.)) structure(as.numeric(1 - da/mMa), names = names(da)) } ################################################### ### code chunk number 6: comp-big (eval = FALSE) ################################################### ## a.s <- 2^seq(-55, 10, length = 256) ## ra.s <- t(sapply(a.s, relE.l1e)) ################################################### ### code chunk number 7: bigpic-show (eval = FALSE) ################################################### ## a.s <- 2^seq(-55, 10, length = 256) ## ra.s <- t(sapply(a.s, relE.l1e)) ## cbind(a.s, ra.s) # comparison of the three approaches ################################################### ### code chunk number 8: bigpic-do ################################################### a.s <- 2^seq(-55, 10, length = 256) ra.s <- t(sapply(a.s, relE.l1e)) capture.and.write(cbind(a.s, ra.s), 8, last = 6) ################################################### ### code chunk number 9: drop-large-a ################################################### ii <- a.s < 710 a.s <- a.s[ii] ra.s <- ra.s[ii, ] ################################################### ### code chunk number 10: a.small ################################################### t3.l1e(1e-20) as.numeric(t3.l1e(mpfr(1e-20, 256))) ################################################### ### code chunk number 11: bigpict-setup (eval = FALSE) ################################################### ## par(mar = c(4.1,4.1,0.6,1.6)) ## cc <- adjustcolor(c(4,1,2),.8, red.f=.7) ## lt <- c("solid","33","3262") ## ll <- c(.7, 1.5, 2) ################################################### ### code chunk number 12: bigpict-def (eval = FALSE) ################################################### ## matplot(a.s, abs(ra.s), type = "l", log = "xy", ## col=cc, lty=lt, lwd=ll, xlab = "a", ylab = "", axes=FALSE) ## legend("top", leg, col=cc, lty=lt, lwd=ll, bty="n") ## draw.machEps <- function(alpha.f = 1/3, col = adjustcolor("black", alpha.f)) { ## abline(h = .Machine$double.eps, col=col, lty=3) ## axis(4, at=.Machine$double.eps, label=quote(epsilon[c]), las=1, col.axis=col) ## } ## eaxis(1); eaxis(2); draw.machEps(0.4) ################################################### ### code chunk number 13: zoomin-comp ################################################### a. <- (1:400)/256 ra <- t(sapply(a., relE.l1e)) ra2 <- ra[,-1] ################################################### ### code chunk number 14: bigpict-fig ################################################### getOption("SweaveHooks")[["fig"]]() par(mar = c(4.1,4.1,0.6,1.6)) cc <- adjustcolor(c(4,1,2),.8, red.f=.7) lt <- c("solid","33","3262") ll <- c(.7, 1.5, 2) matplot(a.s, abs(ra.s), type = "l", log = "xy", col=cc, lty=lt, lwd=ll, xlab = "a", ylab = "", axes=FALSE) legend("top", leg, col=cc, lty=lt, lwd=ll, bty="n") draw.machEps <- function(alpha.f = 1/3, col = adjustcolor("black", alpha.f)) { abline(h = .Machine$double.eps, col=col, lty=3) axis(4, at=.Machine$double.eps, label=quote(epsilon[c]), las=1, col.axis=col) } eaxis(1); eaxis(2); draw.machEps(0.4) ## draw the zoom-in region into the plot: yl <- range(pmax(1e-18, abs(ra2))) rect(min(a.), yl[1], max(a.), yl[2], col= adjustcolor("black", .05), border="gray", pch = 5) ################################################### ### code chunk number 15: zoomin-show (eval = FALSE) ################################################### ## a. <- (1:400)/256 ## ra <- t(sapply(a., relE.l1e)) ## ra2 <- ra[,-1] ################################################### ### code chunk number 16: boxcox ################################################### da <- cbind(a = a., as.data.frame(ra2)) library(MASS) bc1 <- boxcox(abs(expm1) ~ a, data = da, lambda = seq(0,1, by=.01), plotit=.plot.BC) bc2 <- boxcox(abs(log1p) ~ a, data = da, lambda = seq(0,1, by=.01), plotit=.plot.BC) c(with(bc1, x[which.max(y)]), with(bc2, x[which.max(y)]))## optimal powers ## ==> taking ^ (1/3) : s1 <- with(da, smooth.spline(a, abs(expm1)^(1/3), df = 9)) s2 <- with(da, smooth.spline(a, abs(log1p)^(1/3), df = 9)) ################################################### ### code chunk number 17: zoom-in-def-1 (eval = FALSE) ################################################### ## matplot(a., abs(ra2), type = "l", log = "y", # ylim = c(-1,1)*1e-12, ## col=cc[-1], lwd=ll[-1], lty=lt[-1], ## ylim = yl, xlab = "a", ylab = "", axes=FALSE) ## legend("topright", leg[-1], col=cc[-1], lwd=ll[-1], lty=lt[-1], bty="n") ## eaxis(1); eaxis(2); draw.machEps() ## lines(a., predict(s1)$y ^ 3, col=cc[2], lwd=2) ## lines(a., predict(s2)$y ^ 3, col=cc[3], lwd=2) ################################################### ### code chunk number 18: zoom-in-fig ################################################### getOption("SweaveHooks")[["fig"]]() cl2 <- adjustcolor("slateblue", 1/2)# (adj: lwd=3) # the color for "log(2)" par(mar = c(4.1,4.1,0.6,1.6)) matplot(a., abs(ra2), type = "l", log = "y", # ylim = c(-1,1)*1e-12, col=cc[-1], lwd=ll[-1], lty=lt[-1], ylim = yl, xlab = "a", ylab = "", axes=FALSE) legend("topright", leg[-1], col=cc[-1], lwd=ll[-1], lty=lt[-1], bty="n") eaxis(1); eaxis(2); draw.machEps() lines(a., predict(s1)$y ^ 3, col=cc[2], lwd=2) lines(a., predict(s2)$y ^ 3, col=cc[3], lwd=2) abline(v = log(2), col=cl2, lty="9273", lwd=2.5) cl2. <- adjustcolor(cl2, 2) axis(1, at=log(2), label=quote(a[0] == log~2), las=1, col.axis=cl2.,col=cl2, lty="9273", lwd=2.5) ## what system is it ? sysInf <- Sys.info()[c("sysname", "release", "nodename", "machine")] mtext(with(as.list(sysInf), paste0(sysname," ",release,"(",substr(nodename,1,16),") -- ", machine)), side=1, adj=1, line=2.25, cex = 3/4) ################################################### ### code chunk number 19: uniroot-x1 ################################################### ## Find x0, such that exp(x) =.= g(x) for x < x0 : f0 <- function(x) { x <- exp(x) - log1p(exp(x)) x[x==0] <- -1 ; x } u0 <- uniroot(f0, c(-100, 0), tol=1e-13) str(u0, digits=10) x0 <- u0[["root"]] ## -36.39022698 --- note that ~= \log(\eps_C) all.equal(x0, -52.5 * log(2), tol=1e-13) ## Find x1, such that x + exp(-x) =.= g(x) for x > x1 : f1 <- function(x) { x <- (x + exp(-x)) - log1p(exp(x)) x[x==0] <- -1 ; x } u1 <- uniroot(f1, c(1, 20), tol=1e-13) str(u1, digits=10) x1 <- u1[["root"]] ## 16.408226 ## Find x2, such that x =.= g(x) for x > x2 : f2 <- function(x) { x <- log1p(exp(x)) - x ; x[x==0] <- -1 ; x } u2 <- uniroot(f2, c(5, 50), tol=1e-13) str(u2, digits=10) x2 <- u2[["root"]] ## 33.27835 ################################################### ### code chunk number 20: log1pexp-plot ################################################### getOption("SweaveHooks")[["fig"]]() par(mfcol= 1:2, mar = c(4.1,4.1,0.6,1.6), mgp = c(1.6, 0.75, 0)) curve(x+exp(-x) - log1p(exp(x)), 15, 25, n=2^11); abline(v=x1, lty=3) curve(log1p(exp(x)) - x, 33.1, 33.5, n=2^10); abline(v=x2, lty=3) ################################################### ### code chunk number 21: def-test-pfuns ################################################### t4p.l1e <- function(x) { c(def = log(1 + exp(x)), log1p = log1p(exp(x)), ## xlog1p = x + log1p(exp(-x)), xpexp = x + exp(-x), x = x) } leg <- local({ r <- body(t4p.l1e)[[2]]; r[[1]] <- `expression`; eval(r) }) ##' The relative Error of log1pexp computations: relE.pl1e <- function(x, precBits = 1024) { stopifnot(is.numeric(x), length(x) == 1, precBits > 50) dx <- t4p.l1e(x) ## double precision x. <- mpfr(x, precBits=precBits) ## high precision *and* using the correct case: mMx <- if(x < 0) log1p(exp(x.)) else x. + log1p(exp(-x.)) structure(as.numeric(1 - dx/mMx), names = names(dx)) } ################################################### ### code chunk number 22: comp-big ################################################### x.s <- seq(-100, 750, by = 5) # <- the big picture ==> problem for default x.s <- seq( 5, 60, length=512) # <- the zoom in ==> *no* problem for def. rx.s <- t(sapply(x.s, relE.pl1e)) signif(cbind(x.s, rx.s),3) ################################################### ### code chunk number 23: bigpict-2-fig ################################################### getOption("SweaveHooks")[["fig"]]() par(mar = c(4.1,4.1,0.6,1.6), mgp = c(1.6, 0.75, 0)) cc <- adjustcolor(c(4,1,2,3),.8, red.f=.7, blue.f=.8) lt <- c("solid","33","3262","dotdash") ll <- c(.7, 1.5, 2, 2) ym <- 1e-18 yM <- 1e-13 matplot(x.s, pmax(pmin(abs(rx.s),yM),ym), type = "l", log = "y", axes=FALSE, ylim = c(ym,yM), col=cc, lty=lt, lwd=ll, xlab = "x", ylab = "") legend("topright", leg, col=cc, lty=lt, lwd=ll, bty="n") eaxis(1, at=pretty(range(x.s), n =12)); eaxis(2) draw.machEps(0.4) x12 <- c(18, 33.3) abline(v=x12, col=(ct <- adjustcolor("brown", 0.6)), lty=3) axis(1, at=x12, labels=formatC(x12), padj = -3.2, hadj = -.1, tcl = +.8, col=ct, col.axis=ct, col.ticks=ct) ################################################### ### code chunk number 24: exp-overflow ################################################### (eMax <- .Machine$double.max.exp * log(2)) exp(eMax * c(1, 1+1e-15)) ################################################### ### code chunk number 25: sessionInfo ################################################### toLatex(sessionInfo(), locale=FALSE) ################################################### ### code chunk number 26: finalizing ################################################### options(op.orig) Rmpfr/inst/doc/Rmpfr-pkg.Rnw0000644000176200001440000006526114361031754015435 0ustar liggesusers%\documentclass[article]{jss} \documentclass[nojss,article]{jss} % ----- for the package-vignette, don't use JSS logo, etc % %__FIXME: use ..\index{} for a good "reference index" about the things we show! % \author{Martin M\"achler \\ ETH Zurich} \title{Arbitrarily Accurate Computation with \R: \\ The \pkg{Rmpfr} Package} % \def\mythanks{a version of this paper, for \pkg{nacopula} 0.4\_4, has been published % in JSS, \url{http://www.jstatsoft.org/v39/i09}.} %% for pretty printing and a nice hypersummary also set: \Plainauthor{Martin M\"achler} %% comma-separated \Plaintitle{Arbitrarily Accurate Computation with R---The Rmpfr Package} % \Shorttitle{} % % The index entry makes it into build/vignette.rds : %\VignetteIndexEntry{Arbitrarily Accurate Computation with R Package Rmpfr} %\VignetteDepends{Rmpfr} %\VignetteDepends{gmp} %\VignetteDepends{Bessel} \SweaveOpts{engine=R,eps=FALSE,pdf=TRUE,width=7,height=4,strip.white=true,keep.source=TRUE} %% an abstract and keywords \Abstract{ The \R\ package \pkg{Rmpfr} allows to use arbitrarily precise numbers instead of \R's double precision numbers in many \R\ computations and functions. %% This is achieved by defining S4 classes of such numbers and vectors, matrices, and arrays thereof, where all arithmetic and mathematical functions work via the (GNU) MPFR C library, where MPFR is acronym for ``\emph{\textbf{M}ultiple \textbf{P}recision \textbf{F}loating-Point \textbf{R}eliably}''. MPFR is Free Software, available under the LGPL license, and itself is built on the free GNU Multiple Precision arithmetic library (GMP). Consequently, by using \pkg{Rmpfr}, you can often call your \R\ function or numerical code with mpfr--numbers instead of simple numbers, and all results will automatically be much more accurate. %% see subsection{Applications} further below: Applications by the package author include testing of Bessel or polylog functions and distribution computations, e.g. for ($\alpha$-)stable distributions and Archimedean Copulas. %% In addition, the \pkg{Rmpfr} has been used on the \code{R-help} or \code{R-devel} mailing list for high-accuracy computations, e.g., in comparison with results from other software, and also in improving existing \R\ functionality, e.g., fixing \R\ bug \href{https://bugs.R-project.org/bugzilla3/show_bug.cgi?id=14491}{\code{PR\#14491}}. } \Keywords{MPFR, Abitrary Precision, Multiple Precision Floating-Point, R} %% at least one keyword must be supplied %% publication information %% NOTE: Typically, this can be left commented and will be filled out by the technical editor %% \Volume{13} %% \Issue{9} %% \Month{September} %% \Year{2004} %% \Submitdate{2004-09-29} %% \Acceptdate{2004-09-29} %% The address of (at least) one author should be given %% in the following format: \Address{ Martin M\"achler\\ Seminar f\"ur Statistik, HG G~16\\ ETH Zurich\\ 8092 Zurich, Switzerland\\ E-mail: \email{maechler@stat.math.ethz.ch}\\ URL: \url{http://stat.ethz.ch/people/maechler} } %% It is also possible to add a telephone and fax number %% before the e-mail in the following format: %% Telephone: +43/1/31336-5053 %% Fax: +43/1/31336-734 %% for those who use Sweave please include the following line (with % symbols): %% MM: this is "substituted" by jss.cls: %% need no \usepackage{Sweave.sty} %% Marius' packages \usepackage[american]{babel}%for American English % \usepackage{microtype}%for character protrusion and font expansion (only with pdflatex) \usepackage{amsmath}%sophisticated mathematical formulas with amstex (includes \text{}) \usepackage{mathtools}%fix amsmath deficiencies \usepackage{amssymb}%sophisticated mathematical symbols with amstex (includes \mathbb{}) % \usepackage{amsthm}%theorem environments % \usepackage{bm}%for bold math symbols: \bm (= bold math) % %NON-STANDARD:\RequirePackage{bbm}%only for indicator functions % \usepackage{enumitem}%for automatic numbering of new enumerate environments % \usepackage[ % format=hang, % % NOT for JSS: labelsep=space, % justification=justified, % singlelinecheck=false%, % % NOT for JSS: labelfont=bf % ]{caption}%for captions % \usepackage{tikz}%sophisticated graphics package % \usepackage{tabularx}%for special table environment (tabularx-table) % \usepackage{booktabs}%for table layout % This is already in jss above -- but withOUT the fontsize=\small part !! \DefineVerbatimEnvironment{Sinput}{Verbatim}{fontsize=\small,fontshape=sl} \DefineVerbatimEnvironment{Soutput}{Verbatim}{fontsize=\small} \DefineVerbatimEnvironment{Scode}{Verbatim}{fontsize=\small,fontshape=sl} % but when submitting, do get rid of too much vertical space between R % input & output, i.e. between Sinput and Soutput: \fvset{listparameters={\setlength{\topsep}{0pt}}}% !! quite an effect! %% % \newcommand*{\R}{\proglang{R}}%{\textsf{R}} \newcommand*{\Arg}[1]{\texttt{\itshape $\langle$#1$\rangle$}} \newcommand*{\eps}{\varepsilon} \newcommand*{\CRANpkg}[1]{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}} %% end of declarations %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \begin{document} %% include your article here, just as usual %% Note that you should use the \pkg{}, \proglang{} and \code{} commands. % \section[About Java]{About \proglang{Java}} %% Note: If there is markup in \(sub)section, then it has to be escape as above. %% Note: These are explained in '?RweaveLatex' : <>= options(SweaveHooks= list(fig=function() par(mar=c(5.1, 4.1, 1.1, 2.1))), width = 75, digits = 7, # <-- here, keep R's default! prompt = "R> ", continue=" ") Sys.setenv(LANGUAGE = "en") if(.Platform$OS.type != "windows") Sys.setlocale("LC_MESSAGES","C") <>= if(nzchar(Sys.getenv("R_MM_PKG_CHECKING"))) print( .libPaths() ) stopifnot(require("sfsmisc")) @ \section[Introduction]{Introduction}% \small~\footnote{\mythanks}} %% - Why did I want this in R : There are situations, notably in researching better numerical algorithms for non-trivial mathematical functions, say the $F$-distribution function, where it is interesting and very useful to be able to rerun computations in \R\ in (potentially much) higher precision. For example, if you are interested in Euler's $e$, the base of natural logarithms, and given, e.g., by $e^x = \exp(x)$, you will look into <>= exp(1) @ which typically uses 7 digits for printing, as \code{getOption("digits")} is 7. To see \R's internal accuracy fully, you can use <>= print(exp(1), digits = 17) @ With \pkg{Rmpfr} you can now simply use ``mpfr -- numbers'' and get more accurate results automatically, here using a \emph{vector} of numbers as is customary in \R: <>= require("Rmpfr") # after having installed the package ... (one <- mpfr(1, 120)) exp(one) @ In combinatorics, number theory or when computing series, you may occasionally want to work with \emph{exact} factorials or binomial coefficients, where e.g. you may need all factorials $k!$, for $k=1,2,\dots,24$ or a full row of Pascal's triangle, i.e., want all $\binom{n}{k}$ for $n=80$. With \R's double precision, and standard printing precision <>= ns <- 1:24 ; factorial(ns) @ the full precision of $24!$ is clearly not printed. However, if you display it with more than its full internal precision, <>= noquote(sprintf("%-30.0f", factorial(24))) @ it is obviously wrong in the last couple of digits as they are known to be \code{0}. However, you can easily get full precision results with \pkg{Rmpfr}, by replacing ``simple'' numbers by mpfr-numbers: <>= ns <- mpfr(1:24, 120) ; factorial(ns) @ Or for the 80-th Pascal triangle row, $\binom{n}{k}$ for $n=80$ and $k=1,\dots,n$, <>= chooseMpfr.all(n = 80) <>= capture.and.write(# <- in package 'sfsmisc': ~/R/Pkgs/sfsmisc/R/misc-goodies.R <> , 5, 2, middle = 4, i.middle = 13) @ %%% "FIXME:" drawback of the above is that it is *integer* arithmetic only ... \paragraph{S4 classes and methods:} % Why they are useful here: S4 allows ``multiple dispatch'' which means that the method that is called for a generic function may not just depend on the first argument of the function (as in S3 or in traditional class-based OOP), but on a \emph{``signature''} of multiple arguments. For example, \texttt{a + b} is the same as \code{`+`(a,b)}, i.e., calling a function with two arguments. ... \subsection{The engine behind: MPFR and GMP} The package \pkg{Rmpfr} interfaces \R\ to the C (GNU) library \begin{quote} MPFR, acronym for ``\emph{\textbf{M}ultiple \textbf{P}recision \textbf{F}loating-Point \textbf{R}eliably}'' \end{quote} MPFR is Free Software, available under the LGPL license, %\nocite{ see \url{http://mpfr.org/} and \cite{FouLHLPZ:2007} and the standard reference to MPFR, \cite{FousseHLPZ-MPFR:2011}. %% MPFR itself is built on and requires the GNU Multiple Precision arithmetic library (GMP), see \url{http://gmplib.org/} and \cite{GMP:2011}. It can be obtained from there, or from your operating system vendor. On some platforms, it is very simple, to install MPFR and GMP, something necessary before \pkg{Rmpfr} can be used. E.g., in Linux distributions Debian, Ubuntu and other Debian derivatives, it is sufficient (for \emph{both} libraries) to simply issue \begin{verbatim} sudo apt-get install libmpfr-dev \end{verbatim} \section{Arithmetic with mpfr-numbers} <>= (0:7) / 7 # k/7, for k= 0..7 printed with R's default precision options(digits= 16) (0:7) / 7 # in full double precision accuracy options(digits= 7) # back to default str(.Machine[c("double.digits","double.eps", "double.neg.eps")], digits=10) 2^-(52:53) @ In other words, the double precision numbers \R\ uses have a 53-bit mantissa, and the two ``computer epsilons'' are $2^{-52}$ and $2^{-53}$, respectively. Less technically, how many decimal digits can double precision numbers work with, $2^{-53} = 10^{-x} \Longleftrightarrow x = 53 \log_{10}(2)$, <>= 53 * log10(2) @ i.e., almost 16 digits. If we want to compute some arithmetic expression with higher precision, this can now easily be achieved, using the \pkg{Rmpfr} package, by defining ``\texttt{mpfr}--numbers'' and then work with these. Starting with simple examples, a more precise version of $k/7$, $k = 0,\dots, 7$ from above: <>= x <- mpfr(0:7, 80)/7 # using 80 bits precision x 7*x 7*x - 0:7 @ which here is even ``perfect'' -- but that's ``luck'' only, and also the case here for ``simple'' double precision numbers, at least on our current platform.\footnote{64-bit Linux, Fedora 13 on a ``AMD Phenom 925'' processor} \subsection[Mathematical Constants, Pi, gamma, ..]{% Mathematical Constants, Pi ($\pi$), gamma, etc} Our \pkg{Rmpfr} package also provides the mathematical constants which MPFR provides, via \code{Const(., \Arg{prec})}, currently the \Sexpr{length(eval(formals(Const)[["name"]]))} constants <>= formals(Const)$name @ are available, where \code{"gamma"} is for Euler's gamma, $\gamma := \lim_{n\to\infty} \sum_{k=1}^n \frac 1 k - \log(n) \approx 0.5777$, and \code{"catalan"} for Catalan's constant (see \url{http://en.wikipedia.org/wiki/Catalan\%27s_constant}). <>= Const("pi") Const("log2") @ where you may note a default precision of 120 digits, a bit more than quadruple precision, but also that 1000 digits of $\pi$ are available instantaneously, <>= system.time(Pi <- Const("pi", 1000 *log2(10))) Pi @ As nice example of using Mpfr arithmetic: On a wintery Sunday, Hans Borchers desired to have an exact $\pi$ constant in \pkg{Rmpfr}, and realized that of course \code{mpfr(pi, 256)} could not be the solution, as \code{pi} is the double precision version of $\pi$ and hence only about 53 bit accurate (and the \code{mpfr()} cannot do magic, recognizing ``symbolic'' $\pi$). As he overlooked the \code{Const("pi", .)} solution above, he implemented the following function that computes pi applying Gauss' spectacular AGM-based (AGM := Arithmetic-Geometric Mean) approach [Borwein and Borwein (1987), \emph{Pi and the AGM}]; I have added a \code{verbose} argument, explicit iteration counting and slightly adapted the style to my own: <>= piMpfr <- function(prec=256, itermax = 100, verbose=TRUE) { m2 <- mpfr(2, prec) # '2' as mpfr number ## -> all derived numbers are mpfr (with precision 'prec') p <- m2 + sqrt(m2) # 2 + sqrt(2) = 3.414.. y <- sqrt(sqrt(m2)) # 2^ {1/4} x <- (y+1/y) / m2 it <- 0L repeat { p.old <- p it <- it+1L p <- p * (1+x) / (1+y) if(verbose) cat(sprintf("it=%2d, pi^ = %s, |.-.|/|.|=%e\n", it, formatMpfr(p, min(50, prec/log2(10))), 1-p.old/p)) if (abs(p-p.old) <= m2^(-prec)) break if(it > itermax) { warning("not converged in", it, "iterations") ; break } ## else s <- sqrt(x) y <- (y*s + 1/s) / (1+y) x <- (s+1/s)/2 } p } piMpfr()# indeed converges *quadratically* fast ## with relative error relErr <- 1 - piMpfr(256, verbose=FALSE) / Const("pi",260) ## in bits : asNumeric(-log2(abs(relErr))) @ \subsection[{seqMpfr()} for sequences:]{\code{seqMpfr()} for sequences:} In \R, arithmetic sequences are constructed by \code{seq()}, the ``sequence'' function, which is not generic, and with its many ways and possible arguments is convenient, but straightforward to automatically generalize for mpfr numbers. Instead, we provide the \code{seqMpfr} function... \subsection[Rounding, {roundMpfr()}, {asNumeric()} etc:]{% Rounding, \code{roundMpfr()}, \code{asNumeric()} etc:} In \R, the \code{round()} and \code{signif()} functions belong to the \code{Math2} group, and we provide \code{"mpfr"}-class methods for them: <>= getGroupMembers("Math2") showMethods("Math2", classes=c("mpfr", "mpfrArray")) @ For consistency reasons, however the resulting numbers keep the same number of precision bits, \code{precBits}: <>= i7 <- 1/mpfr(700, 100) c(i7, round(i7, digits = 6), signif(i7, digits = 6)) @ If you really want to ``truncate'' the precision to less digits or bits, you call \code{roundMpfr()}, <>= roundMpfr(i7, precBits = 30) roundMpfr(i7, precBits = 15) @ Note that 15 bits correspond to approximately $15 \cdot 0.3$, i.e., 4.5 digits, because $1/\log_2(10) \approx 0.30103\dots$. \paragraph{asNumeric():} Often used, e.g., to return to fast (\R-internal) arithmetic, also as alternative to \code{roundMpfr()} is to ``round to double precision'' producing standard \R numbers from ``mpfr'' numbers. We provide the function \code{asNumeric()}, a generic function with methods also for \code{"mpfrArray"} see below and the big integers and big rationals from package \pkg{gmp}, <>= showMethods(asNumeric) @ see, e.g., its use above. \paragraph{Formatting:} For explicit printing or plotting purposes, we provide an \code{"mpfr"} method for \R's \code{format()} function, also as explicit utility function \code{formatMpfr(x, digits)} which provides results to \code{digits} \emph{significant} digits, <>= cbind( sapply(1:7, function(d) format(i7, digits=d)) ) @ There, \code{digits = NULL} is the default where the help has (``always'') promised \emph{The default, \code{NULL}, uses enough digits to represent the full precision, often one or two digits more than you would expect}. However, for large numbers, say $10^{20000}$, e.g., \Sexpr{x <- mpfr(10,80)^20000}, all of \code{formatMpfr(x)}, \code{format(x)}, and \code{print(x)} (including ``auto-printing'' of \code{x}), have shown all digits \emph{before} the decimal point and not at all taken into account the 80-bit precision of \code{x} (which corresponds to only \code{80 / log2(10)} $\approx 24$ decimal digits). This has finally changed in the (typically default) case \code{formatMpfr(*, maybe.full = FALSE)}: <>= x <- mpfr(2, 80) ^ ((1:4)*10000) cbind(x) # -> show() -> print.mpfr() -> formatMpfr(.. , digits = NULL, maybe.full = FALSE) nchar(formatMpfr(x)) nchar(formatMpfr(x, maybe.full = TRUE)) @ \section{``All'' mathematical functions, arbitrarily precise} %% see ../../man/mfpr-class.Rd %% but also .... %% {Math}{\code{signature(x = "mpfr")}: All the S4 ``\texttt{Math}'' group functions are defined, using multiple precision (MPFR) arithmetic, i.e., <>= getGroupMembers("Math") @ % \code{{abs}}, \code{{sign}}, \code{{sqrt}}, % \code{{ceiling}}, \code{{floor}}, \code{{trunc}}, % \code{{cummax}}, \code{{cummin}}, \code{{cumprod}}, % \code{{cumsum}}, \code{{exp}}, \code{{expm1}}, % \code{{log}}, \code{{log10}}, \code{{log2}}, % \code{{log1p}}, \code{{cos}}, \code{{cosh}}, % \code{{sin}}, \code{{sinh}}, \code{{tan}}, % \code{{tanh}}, \code{{acos}}, \code{{acosh}}, % \code{{asin}}, \code{{asinh}}, \code{{atan}}, % \code{{atanh}}, \code{{gamma}}, \code{{lgamma}}, % \code{{digamma}}, and \code{{trigamma}}. where currently, \code{trigamma} is not provided by the MPFR library, and hence not implemented yet. %% cumsum(), cumprod() now work! \code{factorial()} has a \texttt{"mpfr"} method; and in addition, \code{factorialMpfr()} computes ${n!}$ efficiently in arbitrary precision, using the MPFR-internal implementation. This is mathematically (but not numerically) the same as $\Gamma(n+1) = $\code{gamma(n+1)}. Similarly to \code{factorialMpfr()}, but more generally useful,the functions \code{chooseMpfr(a,n)} and \code{pochMpfr(a,n)} compute (generalized!) binomial coefficients $\binom{a}{n}$ and ``the'' Pochhammer symbol or ``rising factorial'' \begin{eqnarray*} a^{(n)} &:=& a(a+1)(a+2)\cdots(a+n-1) \\ &=& \frac{(a+n-1)!}{(a-1)!} = \frac{\Gamma(a+n)}{\Gamma(a)}. \end{eqnarray*} Note that with this definition, \[ \binom{a}{n} \equiv \frac{a^{(n)}}{n!}. \] \section{Arbitrarily precise matrices and arrays} %%% FIXME --> ~/R/Meetings-Kurse-etc/2011-Warwick/1_MM_/Poster/MM-poster.tex The classes \code{"mpfrMatrix"} and \code{"mpfrArray"} correspond to the classical numerical \R\ \code{"matrix"} and \code{"array"} objects, which basically are arrays or vectors of numbers with a dimension \code{dim}, possibly named by \code{dimnames}. As there, they can be constructed by \code{dim(.) <- ..} setting, e.g., <>= head(x <- mpfr(0:7, 64)/7) ; mx <- x dim(mx) <- c(4,2) @ or by the \code{mpfrArray()} constructor, <>= dim(aa <- mpfrArray(1:24, precBits = 80, dim = 2:4)) <>= aa <>= capture.and.write(aa, 11, 4) @ and we can index and multiply such matrices, e.g., <>= mx[ 1:3, ] + c(1,10,100) crossprod(mx) @ and also \code{apply} functions, <>= apply(7 * mx, 2, sum) @ \section{Special mathematical functions} \code{zeta(x)} computes Riemann's Zeta function $\zeta(x)$ important in analytical number theory and related fields. The traditional definition is \begin{equation*} \zeta(x) = \sum_{n=1}^\infty \frac{1}{n^x}. \end{equation*} \code{Ei(x)} computes the \textbf{e}xponential integral, \begin{equation*} \int_{-\infty}^{x} \frac{e^t}{t} \; dt. \end{equation*} <>= curve(Ei, 0, 5, n=2001); abline(h=0,v=0, lty=3) @ \code{Li2(x)}, part of the MPFR C library since version 2.4.0, computes the dilogarithm, \begin{equation*} \mathtt{Li2(x)} = \operatorname{Li}_2(x) := \int_{0}^{x} \frac{-log(1-t)}{t} \; dt, \end{equation*} which is the most prominent ``polylogarithm'' function, where the general polylogarithm is (initially) defined as \begin{equation*} \operatorname{Li}_s(z) = \sum_{k=1}^\infty \frac{z^k}{k^s}, \ \forall s \in \mathbb{C} \ \ \forall |z| < 1, z\in\mathbb{C}, \end{equation*} see \url{http://en.wikipedia.org/wiki/Polylogarithm#Dilogarithm}. Note that the integral definition is valid for all $x\in \mathbb{C}$, and also, $Li_2(1) = \zeta(2) = \pi^2/6$. <>= if(mpfrVersion() >= "2.4.0") ## Li2() is not available in older MPFR versions all.equal(Li2(1), Const("pi", 128)^2/6, tol = 1e-30) @ where we also see that \pkg{Rmpfr} provides \texttt{all.equal()} methods for mpfr-numbers which naturally allow very small tolerances \code{tol}. <>= if(mpfrVersion() >= "2.4.0") curve(Li2, -2, 13, n=2000); abline(h=0,v=0, lty=3) @ \code{erf(x)} is the ``error\footnote{named exactly because of its relation to the normal / Gaussian distribution} function'' and \code{erfc(x)} its \textbf{c}omplement, \code{erfc(x) := 1 - erf(x)}, defined as \begin{equation*} \operatorname{erf}(x) = \frac{2}{\sqrt{\pi}}\int_{0}^x e^{-t^2} dt, \end{equation*} and consequently, both functions simply are reparametrizations of the cumulative normal, $\Phi(x) = \int_{-\infty}^x \phi(t)\;dt = $\code{pnorm(x)} where $\phi$ is the normal density function $\phi(t) := \frac{1}{\sqrt{2\pi}}e^{-t^2}$=\code{dnorm(x)}. Namely, \code{erf(x) = 2*pnorm(sqrt(2)*x)} and \code{erfc(x) = 1 - erf(x) = 2* pnorm(sqrt(2)*x, lower=FALSE)}. <>= curve(erf, -3,3, col = "red", ylim = c(-1,2)) curve(erfc, add = TRUE, col = "blue") abline(h=0, v=0, lty=3); abline(v=c(-1,1), lty=3, lwd=.8, col="gray") legend(-3,1, c("erf(x)", "erfc(x)"), col = c("red","blue"), lty=1) @ \subsection{Applications} The CRAN package \CRANpkg{Bessel} provides asymptotic formulas for Bessel functions also of \emph{fractional} order which do work for \code{mpfr}-vector arguments as well. \section{Integration highly precisely} Sometimes, important functions are defined as integrals of other known functions, e.g., the dilogarithm $\operatorname{Li}_2()$ above. Consequently, we found it desirable to allow numerical integration, using mpfr-numbers, and hence---conceptionally---arbitrarily precisely. \R's \code{integrate()} uses a relatively smart adaptive integration scheme, but based on C code which is not very simply translatable to pure \R, to be used with mpfr numbers. For this reason, our \code{integrateR()} function uses classical Romberg integration \citep{Bauer-1961}. We demonstrate its use, first by looking at a situation where \R's \code{integrate()} can get problems: <>= integrateR(dnorm,0,2000) integrateR(dnorm,0,2000, rel.tol=1e-15) integrateR(dnorm,0,2000, rel.tol=1e-15, verbose=TRUE) @ Now, for situations where numerical integration would not be necessary, as the solution is known analytically, but hence are useful for exploration of high accuracy numerical integration: First, the exponential function $\exp(x) = e^x$ with its well-known $\int \exp(t)\;dt = \exp(x)$, both with standard (double precision) floats, <>= (Ie.d <- integrateR(exp, 0 , 1, rel.tol=1e-15, verbose=TRUE)) @ and then the same, using 200-bit accurate mpfr-numbers: <>= (Ie.m <- integrateR(exp, mpfr(0,200), 1, rel.tol=1e-25, verbose=TRUE)) (I.true <- exp(mpfr(1, 200)) - 1) ## with absolute errors as.numeric(c(I.true - Ie.d$value, I.true - Ie.m$value)) @ Now, for polynomials, where Romberg integration of the appropriate order is exact, mathematically, <>= if(require("polynom")) { x <- polynomial(0:1) p <- (x-2)^4 - 3*(x-3)^2 Fp <- as.function(p) print(pI <- integral(p)) # formally print(Itrue <- predict(pI, 5) - predict(pI, 0)) ## == 20 } else { Fp <- function(x) (x-2)^4 - 3*(x-3)^2 Itrue <- 20 } (Id <- integrateR(Fp, 0, 5)) (Im <- integrateR(Fp, 0, mpfr(5, 256), rel.tol = 1e-70, verbose=TRUE)) ## and the numerical errors, are indeed of the expected size: 256 * log10(2) # - expect ~ 77 digit accuracy for mpfr(*., 256) as.numeric(Itrue - c(Im$value, Id$value)) @ \section{Miscellaneous} For probability and density computations, it is known to be important in many contexts to work on the $\log$--scale, i.e., with log probabilities $\log P(.)$ or log densities $\log f()$. In \R{} itself, we (R Core) had introduced logical optional arguments \code{log} (for density) and \code{log.p} for probability (e.g., \code{pnorm()} and quantile (e.g., \code{qnorm}) functions. As our \code{pnorm()} is based on MPFR's \code{erf()} and \code{erfc()} which currently do \emph{not} have scaled versions, for \code{Rmpfr::pnorm(.., log.p=TRUE)} we do need to compute the logarithm (instead of working on the log scale). On the extreme left tail, \R{} correctly computes <>= pnorm(-1234, log.p=TRUE) @ i.e., \code{-761386.036955} to more digits. However, \code{erf()} and \code{erfc()} do not have a log scale or other scaled versions. Thanks to the large range of exponents compared to double precision numbers it does less quickly underflow to zero, e.g., <>= (p123 <- Rmpfr::pnorm(mpfr(-123, 66), log.p=TRUE)) # is based on (ec123 <- erfc(123 * sqrt(mpfr(0.5, 66+4))) / 2) # 1.95....e-3288 (p333 <- Rmpfr::pnorm(mpfr(-333, 66), log.p=TRUE)) exp(p333) stopifnot(p123 == log(roundMpfr(ec123, 66)), ## '==' as we implemented our pnorm() all.equal(p333, -55451.22709, tol=1e-8)) @ and indeed, the default range for exponent (wrt base 2, not 10) is given by <>= (old_erng <- .mpfr_erange() ) @ which shows the current minimal and maximal base-2 exponents for mpfr-numbers, by ``factory-fresh'' default, the number $-2^{30}$ and $2^{30}$, i.e., $\pm 1073741823$ which is much larger than the corresponding limits for regular double precision numbers, <>= unlist( .Machine[c("double.min.exp", "double.max.exp")] ) @ which are basically $\pm 2^{10}$; note that double arithmetic typically allows subnormal numbers which are even smaller than $2^{-1024}$, also in \R{}, on all usual platforms, <>= 2^(-1022 - 52) @ is equal to $2^{-1074}$ and the really smallest positive double precision number. Now, \emph{if} if the GMP library to which both \R{} package \pkg{gmp} and \pkg{Rmpfr} interface is built ``properly'', i.e., with full 64 bit ``numb''s, we can \emph{extend} the range of mpfr-numbers even further. By how much, we can read off <>= .mpfr_erange(.mpfr_erange_kinds) ## and then set # use very slightly smaller than extreme values: (myERng <- (1-2^-52) * .mpfr_erange(c("min.emin","max.emax"))) .mpfr_erange_set(value = myERng) # and to see what happened: .mpfr_erange() @ If that worked well, this shows \code{-/+ 4.611686e+18}, or actually $\mp 2^{62}$, \code{log2(abs(.mpfr_erange()))} giving \Sexpr{log2(abs(.mpfr_erange()))}. However, currently on Winbuilder this does not extend, notably as the GMP numbs, <>= .mpfr_gmp_numbbits() @ have \emph{not} been 64, there. \section{Conclusion} The \R\ package \pkg{Rmpfr}, available from CRAN since August 2009, provides the possibility to run many computations in R with (arbitrarily) high accuracy, though typically with substantial speed penalty. This is particularly important and useful for checking and exploring the numerical stability and appropriateness of mathematical formulae that are translated to a computer language like \R, often without very careful consideration of the limits of computer arithmetic. \bibliography{Rmpfr,log1mexp} FIXME: \textbf{Index} of all functions mentioned \dots \end{document} Rmpfr/inst/doc/log1mexp-note.Rnw0000644000176200001440000006606414355605130016267 0ustar liggesusers\documentclass[article,nojss]{jss}%-- the LONGER version %% NOTA BENE: More definitions --> further down %%%%%%%%%%%% % \author{Martin M\"achler \\ ETH Zurich% \\ April, Oct.\ 2012 {\tiny (\LaTeX'ed \today)}%---- for now } \title{Accurately Computing $\log(1 - \exp(-\abs{a}))$ \\ Assessed by the \pkg{Rmpfr} package} %% for pretty printing and a nice hypersummary also set: \Plainauthor{Martin M\"achler} %% comma-separated \Plaintitle{% Accurately Computing log(1 - exp(.)) -- Assessed by Rmpfr} %\VignetteIndexEntry{Accurately Computing log(1 - exp(.)) -- Assessed by Rmpfr} %\VignetteDepends{Rmpfr} %\VignetteDepends{gmp} %\VignetteDepends{sfsmisc} \SweaveOpts{engine=R,strip.white=true, width=8.5, height=6} \SweaveOpts{pdf=FALSE, eps=FALSE, grdevice = pdfaCrop} % defined in R "<>": ^^^^^^^^ %% an abstract and keywords \Abstract{In this note, we explain how $f(a) = \log(1 - e^{-a}) =\log(1 - \exp(-a))$ can be computed accurately, in a simple and optimal manner, building on the two related auxiliary functions \code{log1p(x)} ($=\log(1+x)$) and \code{expm1(x)} ($=\exp(x)-1 = e^x - 1$). The cutoff, $a_0$, in use in \R{} since % version 1.9.0, April 2004, is shown to be optimal both theoretically and empirically, using \pkg{Rmpfr} high precision arithmetic. As an aside, we also show how to compute $\log\bigl(1 + e^x \bigr)$ accurately and efficiently. } \Keywords{Accuracy, Cancellation Error, R, MPFR, Rmpfr} %% at least one keyword must be supplied %% publication information %% NOTE: Typically, this can be left commented and will be filled out by the technical editor %% \Volume{13} %% \Issue{9} %% \Month{September} %% \Year{2004} %% \Submitdate{2004-09-29} %% \Acceptdate{2004-09-29} %% The address of (at least) one author should be given %% in the following format: \Address{ Martin M\"achler\\ Seminar f\"ur Statistik, HG G~16\\ ETH Zurich\\ 8092 Zurich, Switzerland\\ E-mail: \email{maechler@stat.math.ethz.ch}\\ URL: \url{https://stat.ethz.ch/~maechler} } %% It is also possible to add a telephone and fax number %% before the e-mail in the following format: %% Telephone: +43/1/31336-5053 %% Fax: +43/1/31336-734 %% for those who use Sweave please include the following line (with % symbols): %% MM: this is "substituted" by jss.cls: %% need no \usepackage{Sweave.sty} \usepackage[american]{babel}%for American English \usepackage{amsmath}%sophisticated mathematical formulas with amstex (includes \text{}) \usepackage{mathtools}%fix amsmath deficiencies \usepackage{amssymb}%sophisticated mathematical symbols with amstex (includes \mathbb{}) % \usepackage{amsthm}%theorem environments \usepackage{bm}%for bold math symbols: \bm (= bold math) \usepackage{enumitem}%for automatic numbering of new enumerate environments % This is already in jss above -- but withOUT the fontsize=\small part !! \DefineVerbatimEnvironment{Sinput}{Verbatim}{fontsize=\small,fontshape=sl} \DefineVerbatimEnvironment{Soutput}{Verbatim}{fontsize=\small} \DefineVerbatimEnvironment{Scode}{Verbatim}{fontsize=\small,fontshape=sl} %%~-~-~-~ Make space between Sinput and Soutput smaller: ~-~-~-~~-~-~-~~-~-~-~~-~-~-~~-~-~-~ %%--- Best advice, now from : % http://tex.stackexchange.com/questions/19359/reduce-space-between-sinput-and-soutput \newlength{\FVtopsep} \newlength{\FVpartopsep} \newlength{\FVparskip}% <- added as "no. 3" by MMa (after reading fancyvrb doc) \makeatletter \FV@AddToHook{\FV@ListParameterHook}{\topsep=\FVtopsep\partopsep=\FVpartopsep\parskip=\FVparskip} \makeatother % Control the spacing around the Sinput and Soutput environments by using the lengths % % \FVtopsep % \FVpartopsep % \FVparskip % % Both *topsep act quite similar most of the time, more details % can be found in the fancyvrb documentation on page 46. (MM: ==> I add FVparskip) %To kill all extra spacing between the environments, use {0pt} in all these %MM: When all three(!) are {0pt}, there's a large gap *after* Schunk (nothing in %between) %-- and that (end gap) get's smaller when I set all to {1pt} -- logic?? %___TODO/FIXME: Set of experiments (with smaller Sweave file)___ \setlength{\FVtopsep}{1pt} \setlength{\FVpartopsep}{1pt} \setlength{\FVparskip}{\parskip}% default: \parskip %%~-~-~-~ End {Sweave space handling} ~-~-~-~~-~-~-~~-~-~-~~-~-~-~~-~-~-~~-~-~~-~-~-~~-~-~ %% \setkeys{Gin}{width=\textwidth}% Sweave.sty has {width=0.8\textwidth} \newcommand*{\R}{\proglang{R}}%{\textsf{R}} \newcommand*{\CRANpkg}[1]{\href{http://CRAN.R-project.org/package=#1}{\pkg{#1}}} \newcommand*{\eps}{\varepsilon} %- \abs{ab} --> | ab | ``absolut Betrag'' \newcommand{\abs}[1] {\left| #1 \right|} % \renewcommand*{\S}{\operatorname*{S}} % \newcommand*{\tS}{\operatorname*{\tilde{S}}} % \newcommand*{\ran}{\operatorname*{ran}} %\newcommand*{\sgn}{\operatorname*{sgn}} \DeclareMathOperator{\sign}{sign} % \renewcommand*{\L}{\mathcal{L}} % \newcommand*{\Li}{\mathcal{L}^{-1}} % \newcommand*{\LS}{\mathcal{LS}} % \newcommand*{\LSi}{\LS^{-1}} \renewcommand*{\O}{\mathcal{O}} % \newcommand*{\Geo}{\operatorname*{Geo}} % \newcommand*{\Exp}{\operatorname*{Exp}} % \newcommand*{\Sibuya}{\operatorname*{Sibuya}} % \newcommand*{\Log}{\operatorname*{Log}} % \newcommand*{\U}{\operatorname*{U}} % \newcommand*{\B}{\operatorname*{B}} % \newcommand*{\NB}{\operatorname*{NB}} % \newcommand*{\N}{\operatorname*{N}} \DeclareMathOperator{\var}{var} \DeclareMathOperator{\Var}{Var} \DeclareMathOperator{\Cov}{Cov} \DeclareMathOperator{\cov}{cov} \DeclareMathOperator{\Cor}{Corr} \DeclareMathOperator{\cor}{corr} % \newcommand*{\Var}{\operatorname*{Var}} % \newcommand*{\Cov}{\operatorname*{Cov}} % \newcommand*{\Cor}{\operatorname*{Cor}} % % \newcommand*{\loglp}{\operatorname*{log1p}} % \newcommand*{\expml}{\operatorname*{expm1}} %% cannot use "1" in latex macro name -- use "l": \newcommand*{\loglp}{\mathrm{log1p}} \newcommand*{\expml}{\mathrm{expm1}} %% journal specific aliases \newcommand*{\setcapwidth}[1]{} %% end of declarations %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \begin{document} %% include your article here, just as usual %% Note that you should use the \pkg{}, \proglang{} and \code{} commands. % \section[About Java]{About \proglang{Java}} %% Note: If there is markup in \(sub)section, then it has to be escape as above. %% %% Note: These are explained in '?RweaveLatex' : <>= ## Our custom graphics device: pdfaCrop <- function(name, width, height, ...) { fn <- paste(name, "pdf", sep = ".") if(FALSE)## debug cat("pdfaCrop: fn = ",fn,"; call:\n\t",deparse(match.call()),"\n") grDevices::pdf(fn, width = width, height = height, onefile=FALSE)# ...) assign(".pdfaCrop.name", fn, envir = globalenv()) } ## This is used automagically : pdfaCrop.off <- function() { dev.off()# for the pdf f <- get(".pdfaCrop.name", envir = globalenv()) ## and now crop that file: pdfcrop <- "pdfcrop" # relying on PATH - fix if needed pdftex <- "pdftex" # relying on PATH - fix if needed system(paste(pdfcrop, "--pdftexcmd", pdftex, f, f, "1>/dev/null 2>&1"), intern=FALSE) } op.orig <- options(width = 75, SweaveHooks= list(fig=function() par(mar=c(5.1, 4.1, 1.1, 2.1))), digits = 5, useFancyQuotes = "TeX", ## for JSS, but otherwise MM does not like it: ## prompt="R> ", continue=" ")# 2 (or 3) blanks: use same length as 'prompt' if((p <- "package:fortunes") %in% search()) try(detach(p, unload=TRUE, char=TRUE)) Sys.setenv(LANGUAGE = "en") if(.Platform$OS.type != "windows") Sys.setlocale("LC_MESSAGES","C") if(getRversion() < "2.15") paste0 <- function(...) paste(..., sep = '') library("sfsmisc")# e.g., for eaxis() library("Rmpfr") .plot.BC <- FALSE # no Box-Cox plot @ %\section[Introduction]{Introduction \small~\footnote{\mythanks}} \section{Introduction: Not log() nor exp(), but log1p() and expm1()} In applied mathematics, it has been known for a very long time that direct computation of $\log(1 + x)$ suffers from severe cancellation (in ``$1 + x$'') whenever $\abs{x} \ll 1$, and for that reason, we have provided \code{log1p(x)} in \R{}, since R version 1.0.0 (released, Feb.~29, 2000). Similarly, \code{log1p()} has been provided by C math libraries and has become part of C language standards around the same time, see, for example, \citet{ieee04:log1p}. Analogously, since \R{}~1.5.0 (April 2002), the function \code{expm1(x)} computes $\exp(x) - 1 = e^x - 1$ accurately also for $\abs{x} \ll 1$, where $e^x \approx 1$ is (partially) cancelled by ``$-\: 1$''. In both cases, a simple solution %approach for small $\abs{x}$ is to use a few terms of the Taylor series, as \begin{align} \label{eq:Taylor-log1p} \loglp(x) &= \log(1 + x) = x - x^2/2 + x^3/3 -+ \dots, \ \mathrm{for}\ \ \abs{x} < 1, %\mathrm{and} \\ \label{eq:Taylor-expm1} \expml(x) &= \exp(x) - 1 = x + x^2/2! + x^3/3! + \dots, \ \mathrm{for}\ \ \abs{x} < 1, \end{align} and $n!$ denotes the factorial. We have found, however, that in some situations, the use of \code{log1p()} and \code{expm1()} may not be sufficient to prevent loss of numerical accuracy. The topic of this note is to analyze the important case of computing $\log\left(1 - e^x \right) = \log(1 - \exp(x))$ for $x < 0$, computations needed in accurate computations of the beta, gamma, exponential, Weibull, t, logistic, geometric and hypergeometric distributions, %% in ~/R/D/r-devel/R/src/nmath/ : %% grep --color -nHEw -e '(R_Log1_Exp|R_D_LExp|R_DT_Log|R_DT_C?log)' *.? %% --> ~/R/Pkgs/Rmpfr/vignettes/log1mexp_grep and % because of the latter, even for the logit link function in logistic regression. For the beta and gamma distributions, see, for example, % e.g., \citet{DidAM92}\footnote{In the Fortran source, file ``\code{708}'', also available as \url{http://www.netlib.org/toms/708}, the function ALNREL() computes log1p() and REXP() computes expm1().}, and further references mentioned in \R{}'s \code{?pgamma} and \code{?pbeta} help pages. For the logistic distribution, $F_L(x) = \frac{e^x}{1+e^x}$, the inverse, aka quantile function is $q_L(p) = \mathrm{logit}(p) := \log \frac{p}{1-p}$. If the argument $p$ is provided on the log scale, $\tilde p := \log p$, hence $\tilde p \le 0$, we need \begin{align} \label{eq:qlogis} \mathtt{qlogis}(\tilde p,\: \mathtt{log.p=TRUE}) = q_L\!\left(e^{\tilde p}\right) = \mathrm{logit}\!\left(e^{\tilde p}\right) % = \log\Bigl(\frac{e^{\tilde p}}{1-e^{\tilde p}}\Bigr) = \log \frac{e^{\tilde p}}{1-e^{\tilde p}} = \tilde p - \log\left(1 - e^{\tilde p} \right), \end{align} and the last term is exactly the topic of this note. \section{log1p() and expm1() for log(1 - exp(x))} Contrary to what one would expect, for computing $\log\left(1 - e^x \right) = \log(1 - \exp(x))$ for $x < 0$, neither \begin{align} \label{eq:f.expm1} \log(1 - \exp(x)) &= \log(-\expml(x)), \ \ \mathrm{nor}\\ \label{eq:f.log1p} \log(1 - \exp(x)) &= \loglp(-\exp(x)), \end{align} are uniformly sufficient for numerical evaluation. %% 1 In (\ref{eq:f.log1p}), when $x$ approaches $0$, $\exp(x)$ approaches $1$ and $\loglp(-\exp(x))$ loses accuracy. %% 2 In (\ref{eq:f.expm1}), when $x$ is large, $\expml(x)$ approaches $-1$ and similarly loses accuracy. Because of this, we will propose to use a function \code{log1mexp(x)} which uses either \code{expm1} (\ref{eq:f.expm1}) or \code{log1p} (\ref{eq:f.log1p}), where appropriate. Already in \R{}~1.9.0 (\cite{R-190}), % (April 2004) % now, both R_Log1_Exp() and --> R_D_LExp(x) := (log_p ? R_Log1_Exp(x) : log1p(-x)) we have defined the macro \verb|R_D_LExp(x)| to provide these two cases %branches automatically\footnote{look for ``log(1-exp(x))'' in \url{http://svn.r-project.org/R/branches/R-1-9-patches/src/nmath/dpq.h}}. % R-1.8.1: pgamma(30,100, lower=FALSE, log=TRUE) gave 0 instead of -... To investigate the accuracy losses empirically, we make use of the \R{} package \CRANpkg{Rmpfr} for arbitrarily accurate numerical computation, and use the following simple functions: <>= library(Rmpfr) t3.l1e <- function(a) { c(def = log(1 - exp(-a)), expm1 = log( -expm1(-a)), log1p = log1p(-exp(-a))) } @ <>= leg <- local({ r <- body(t3.l1e)[[2]]; r[[1]] <- `expression`; eval(r) }) ## will be used below @ <>= ##' The relative Error of log1mexp computations: relE.l1e <- function(a, precBits = 1024) { stopifnot(is.numeric(a), length(a) == 1, precBits > 50) da <- t3.l1e(a) ## double precision a. <- mpfr(a, precBits=precBits) ## high precision *and* using the correct case: mMa <- if(a <= log(2)) log(-expm1(-a.)) else log1p(-exp(-a.)) structure(as.numeric(1 - da/mMa), names = names(da)) } @ <>= <> <> @ where the last one, \code{relE.l1e()} computes the relative error of three different ways to compute $\log(1 - \exp(-a))$ for positive $a$ (instead of computing $\log(1 - \exp(x))$ for negative $x$). %% TODO? "cache = TRUE": --- <>= a.s <- 2^seq(-55, 10, length = 256) ra.s <- t(sapply(a.s, relE.l1e)) <>= <> cbind(a.s, ra.s) # comparison of the three approaches <>= <> capture.and.write(cbind(a.s, ra.s), 8, last = 6) @ This is revealing: Neither method, log1p or expm1, is uniformly good enough. Note that for large $a$, the relative errors evaluate to \code{1}. This is because all three double precision methods give 0, \emph{and} that is the best approximation in double precision (but not in higher \code{mpfr} precision), hence no problem at all, and we can restrict ourselves to smaller $a$ (smaller than about 710, here).% < 709.78271289338403 (lynne 64b) <>= ii <- a.s < 710 a.s <- a.s[ii] ra.s <- ra.s[ii, ] @ What about really small $a$'s? Note here that <>= t3.l1e(1e-20) as.numeric(t3.l1e(mpfr(1e-20, 256))) @ % ## expm1 def log1p % ## -46.0517 -Inf -Inf % as.numeric(): % ## [1] -46.0517 -46.0517 -46.0517 both the default and the \code{log1p} method return \code{-Inf}, so, indeed, the \code{expm1} method is absolutely needed here. Figure~\ref{fig:bigpic} visualizes the relative errors\footnote{% Absolute value of relative errors, $\abs{(\hat{f}(a) - f(a)) / f(a)} = \abs{1 - \hat{f}(a)/f(a)}$, where $f(a) = \mathrm{log1mexp}(a)$ (\ref{eq:log1mexp}) is computed accurately by a 1024 bit \pkg{Rmpfr} computation} of the three methods. Note that the default basically gives the maximum of the two methods' errors, whereas the final \code{log1mexp()} function will have (approximately) minimal error of the two. %% --- Define figure_1 here ------------------------------ <>= par(mar = c(4.1,4.1,0.6,1.6)) cc <- adjustcolor(c(4,1,2),.8, red.f=.7) lt <- c("solid","33","3262") ll <- c(.7, 1.5, 2) @ %% main = "|relative errors| of three methods for log(1 - exp(-a))" <>= matplot(a.s, abs(ra.s), type = "l", log = "xy", col=cc, lty=lt, lwd=ll, xlab = "a", ylab = "", axes=FALSE) legend("top", leg, col=cc, lty=lt, lwd=ll, bty="n") draw.machEps <- function(alpha.f = 1/3, col = adjustcolor("black", alpha.f)) { abline(h = .Machine$double.eps, col=col, lty=3) axis(4, at=.Machine$double.eps, label=quote(epsilon[c]), las=1, col.axis=col) } eaxis(1); eaxis(2); draw.machEps(0.4) @ %% TODO? "cache = TRUE": echo=FALSE: do not show already, but need (a.,ra2) <>= a. <- (1:400)/256 ra <- t(sapply(a., relE.l1e)) ra2 <- ra[,-1] @ \begin{figure}[htb!] \centering % increasing width --> effective LaTeX *height* will decrease <>= <> <> ## draw the zoom-in region into the plot: yl <- range(pmax(1e-18, abs(ra2))) rect(min(a.), yl[1], max(a.), yl[2], col= adjustcolor("black", .05), border="gray", pch = 5) @ \setcapwidth{\textwidth}% \caption[Relative errors of log1mexp() approximations]{% Relative errors$^{*}$ of the default, $\log(1 - e^{-a})$, and the two methods ``\code{expm1}'' $\log(-\expml(-a))$ and ``\code{log1p}'' $\loglp(-\exp(-a))$. Figure~\ref{fig:zoomin-pic} will be a zoom into the gray rectangular region where all three curves are close.} \label{fig:bigpic} \end{figure} In Figure~\ref{fig:zoomin-pic} below, we zoom into the region where all methods have about the same (good) accuracy. The region is the rectangle defined by the ranges of \code{a.} and \code{ra2}: <>= <> @ In addition to zooming in Figure~\ref{fig:bigpic}, we want to smooth the two curves, using a method assuming approximately normal errors. Notice however that neither the original, nor the log-transformed values have approximately symmetric errors, so we use \code{MASS::boxcox()} to determine the ``correct'' power transformation, <>= da <- cbind(a = a., as.data.frame(ra2)) library(MASS) bc1 <- boxcox(abs(expm1) ~ a, data = da, lambda = seq(0,1, by=.01), plotit=.plot.BC) bc2 <- boxcox(abs(log1p) ~ a, data = da, lambda = seq(0,1, by=.01), plotit=.plot.BC) c(with(bc1, x[which.max(y)]), with(bc2, x[which.max(y)]))## optimal powers ## ==> taking ^ (1/3) : s1 <- with(da, smooth.spline(a, abs(expm1)^(1/3), df = 9)) s2 <- with(da, smooth.spline(a, abs(log1p)^(1/3), df = 9)) @ i.e, the optimal boxcox exponent turns out to be close to $\frac 1 3$, which we use for smoothing in a ``zoom--in'' of Figure~\ref{fig:bigpic}. Then, the crossover point of the two curves already suggests that the cutoff, $a_0 = \log 2$ is empirically very close to optimal. <>= matplot(a., abs(ra2), type = "l", log = "y", # ylim = c(-1,1)*1e-12, col=cc[-1], lwd=ll[-1], lty=lt[-1], ylim = yl, xlab = "a", ylab = "", axes=FALSE) legend("topright", leg[-1], col=cc[-1], lwd=ll[-1], lty=lt[-1], bty="n") eaxis(1); eaxis(2); draw.machEps() lines(a., predict(s1)$y ^ 3, col=cc[2], lwd=2) lines(a., predict(s2)$y ^ 3, col=cc[3], lwd=2) @ %% no title here: main = "|relative errors| of two methods for log(1 - exp(-a))") \enlargethispage{5ex} \begin{figure}[hbt!] \centering <>= cl2 <- adjustcolor("slateblue", 1/2)# (adj: lwd=3) # the color for "log(2)" par(mar = c(4.1,4.1,0.6,1.6)) <> abline(v = log(2), col=cl2, lty="9273", lwd=2.5) cl2. <- adjustcolor(cl2, 2) axis(1, at=log(2), label=quote(a[0] == log~2), las=1, col.axis=cl2.,col=cl2, lty="9273", lwd=2.5) ## what system is it ? sysInf <- Sys.info()[c("sysname", "release", "nodename", "machine")] mtext(with(as.list(sysInf), paste0(sysname," ",release,"(",substr(nodename,1,16),") -- ", machine)), side=1, adj=1, line=2.25, cex = 3/4) @ \setcapwidth{\textwidth}% \caption{A ``zoom in'' of Figure~\ref{fig:bigpic} showing the region where the two basic methods, ``\code{expm1}'' and ``\code{log1p}'' switch their optimality with respect to their relative errors. Both have small relative errors in this region, typically below $\eps_c :=$% \code{.Machine\$double.eps} $=2^{-52} \approx 2.22\cdot 10^{-16}$. \ \ The smoothed curves indicate crossover close to $a = a_0 := \log 2$.} \label{fig:zoomin-pic} \end{figure} \paragraph{Why is it very plausible to take $a_0 := \log 2$ as approximately optimal cutoff?} Already from Figure~\ref{fig:zoomin-pic}, empirically, an optimal cutoff $a_0$ is around $0.7$. We propose to compute \begin{align} \label{eq:def-log1mexp} f(a) = \log\left(1 - e^{-a}\right) = \log(1 - \exp(-a)), \ \ a > 0, \end{align} by a new method or function \code{log1mexp(a)}. It needs a cutoff $a_0$ between choosing \code{expm1} for $0 < a \le a_0$ and \code{log1p} for $a > a_0$, i.e., \begin{align} \label{eq:log1mexp} f(a) = \mathrm{log1mexp}(a) := \begin{cases} \log(-\expml(-a)) & 0 < a \le a_0 \ \ ( := \log 2 \approx 0.693) \\ \loglp(-\exp(-a)) & \phantom{0 < {}}a > a_0. \end{cases} \end{align} The mathematical argument for choosing $a_0$ is quite simple, at least informally: In which situations does $1 - e^{-a}$ loose bits (binary digits) \emph{entirely independently} of the computational algorithm? Well, as soon as it ``spends'' bits just to store its closeness to $1$. And that is as soon as $e^{-a} < \frac 1 2 = 2^{-1}$, because then, at least one bit cancels. This however is equivalent to $-a < \log(2^{-1}) = -\log(2)$ or $a > \log 2 =: a_0$. \section{Computation of log(1+exp(x))} Related to $\mathrm{log1mexp}(a)=\log(1 - e^{-a})$ is the log survival function of the logistic distribution % (see above)%: defined F_L $\log(1 - F_L(x)) = \log\frac{1}{1+e^x} = -\log(1 + e^x) = -g(x)$, where \begin{align} \label{eq:def-log1pexp} g(x) := \log(1 + e^x) = \loglp(e^x), \end{align} which has a ``$+"$'' instead of a ``$-$'', compared to $\mathrm{log1mexp}$, and is easier to analyze and compute, its only problem being large $x$'s where $e^x$ % = \exp x$ overflows numerically.\footnote{Indeed, for $x=710$, $ -g(x) = \log(1 - F_L(x)) = $ \code{plogis(710, lower=FALSE, log.p=TRUE)}, underflowed to \code{-Inf} in \R{} versions before 2.15.1 (June 2012) from when on (\ref{eq:log1pexp}) has been used.} As $g(x)= \log(1 + e^x) = \log(e^x(e^{-x} + 1)) = x + \log(1 + e^{-x})$, we see from (\ref{eq:Taylor-log1p}) that \begin{align} \label{eq:log1pexp-asym} g(x) = x + \log(1 + e^{-x}) = % \sim %\asymp %% x + e^{-x}(1 - e^{-x}/2) + \O((e^{-x})^3), x + e^{-x} + \O((e^{-x})^2), \end{align} for $x\to\infty$. Note further, that for $x\to-\infty$, we can simplify $g(x)=\log(1 + e^x)$ to $e^x$. A simple picture quickly reveals how different approximations behave, where we have used \code{uniroot()} to determine the zero crossing, but will use slightly simpler cutoffs $x_0=37$, $x_1$ and $x_2$, in (\ref{eq:log1pexp}) below: %% Notation x_0, x_1, x_2 are related to the 1st, 2nd and 3rd cutoff in equation (10) %% -37 18 33.3 <>= ## Find x0, such that exp(x) =.= g(x) for x < x0 : f0 <- function(x) { x <- exp(x) - log1p(exp(x)) x[x==0] <- -1 ; x } u0 <- uniroot(f0, c(-100, 0), tol=1e-13) str(u0, digits=10) x0 <- u0[["root"]] ## -36.39022698 --- note that ~= \log(\eps_C) all.equal(x0, -52.5 * log(2), tol=1e-13) ## Find x1, such that x + exp(-x) =.= g(x) for x > x1 : f1 <- function(x) { x <- (x + exp(-x)) - log1p(exp(x)) x[x==0] <- -1 ; x } u1 <- uniroot(f1, c(1, 20), tol=1e-13) str(u1, digits=10) x1 <- u1[["root"]] ## 16.408226 ## Find x2, such that x =.= g(x) for x > x2 : f2 <- function(x) { x <- log1p(exp(x)) - x ; x[x==0] <- -1 ; x } u2 <- uniroot(f2, c(5, 50), tol=1e-13) str(u2, digits=10) x2 <- u2[["root"]] ## 33.27835 @ %% but really the above is still ``non sense'': look at <>= par(mfcol= 1:2, mar = c(4.1,4.1,0.6,1.6), mgp = c(1.6, 0.75, 0)) curve(x+exp(-x) - log1p(exp(x)), 15, 25, n=2^11); abline(v=x1, lty=3) curve(log1p(exp(x)) - x, 33.1, 33.5, n=2^10); abline(v=x2, lty=3) @ \medskip Using double precision arithmetic, a fast and accurate computational method is to use \begin{align} \label{eq:log1pexp} \hat{g}(x) = \mathrm{log1pexp}(x) := \begin{cases} \exp(x) & x \le -37 \\ \loglp(\exp(x)) & -37 < x \le x_1 := 18, \\ x + \exp(-x) & x_1 < x \le x_2 := 33.3, \\ x & x > x_2, \end{cases} \end{align} where only the cutoff $x_1 = 18$ is important and the other cutoffs just save computations.\footnote{see % the %\R{} plot \code{curve(log1p(exp(x)) - x, 33.1, 33.5, n=2\^{}10)} above, revealing a somewhat fuzzy cutoff $x_2$.} %%--- Ok, still do a little deeper analysis for the interested R code reader %%--- invisibly mostly (echo=FALSE) here: <>= t4p.l1e <- function(x) { c(def = log(1 + exp(x)), log1p = log1p(exp(x)), ## xlog1p = x + log1p(exp(-x)), xpexp = x + exp(-x), x = x) } leg <- local({ r <- body(t4p.l1e)[[2]]; r[[1]] <- `expression`; eval(r) }) ##' The relative Error of log1pexp computations: relE.pl1e <- function(x, precBits = 1024) { stopifnot(is.numeric(x), length(x) == 1, precBits > 50) dx <- t4p.l1e(x) ## double precision x. <- mpfr(x, precBits=precBits) ## high precision *and* using the correct case: mMx <- if(x < 0) log1p(exp(x.)) else x. + log1p(exp(-x.)) structure(as.numeric(1 - dx/mMx), names = names(dx)) } <>= x.s <- seq(-100, 750, by = 5) # <- the big picture ==> problem for default x.s <- seq( 5, 60, length=512) # <- the zoom in ==> *no* problem for def. rx.s <- t(sapply(x.s, relE.pl1e)) signif(cbind(x.s, rx.s),3) @ \begin{figure}[htb!] \centering %% using "blue" for the default method, *as* in Figure 1 above <>= par(mar = c(4.1,4.1,0.6,1.6), mgp = c(1.6, 0.75, 0)) cc <- adjustcolor(c(4,1,2,3),.8, red.f=.7, blue.f=.8) lt <- c("solid","33","3262","dotdash") ll <- c(.7, 1.5, 2, 2) ym <- 1e-18 yM <- 1e-13 matplot(x.s, pmax(pmin(abs(rx.s),yM),ym), type = "l", log = "y", axes=FALSE, ylim = c(ym,yM), col=cc, lty=lt, lwd=ll, xlab = "x", ylab = "") legend("topright", leg, col=cc, lty=lt, lwd=ll, bty="n") eaxis(1, at=pretty(range(x.s), n =12)); eaxis(2) draw.machEps(0.4) x12 <- c(18, 33.3) abline(v=x12, col=(ct <- adjustcolor("brown", 0.6)), lty=3) axis(1, at=x12, labels=formatC(x12), padj = -3.2, hadj = -.1, tcl = +.8, col=ct, col.axis=ct, col.ticks=ct) @ % increasing width --> effective LaTeX *height* will decrease \setcapwidth{\textwidth}% \caption{Relative errors (via \pkg{Rmpfr}, see footnote of Fig.~\ref{fig:bigpic}) of four different ways to numerically compute $\log\bigl(1 + e^{x}\bigr)$. Vertical bars at $x_1 = 18$ and $x_2 = 33.3$ visualize the (2nd and 3rd) cutpoints of (\ref{eq:log1pexp}).} % Moved into text:|| down Note that the default method is fully accurate on this $x$ range. \label{fig:log1pexp} \end{figure} Figure~\ref{fig:log1pexp} visualizes the relative errors of the careless ``default'', $\log\bigl(1 + e^{x}\bigr)$, its straightforward correction $\loglp\bigl(e^x\bigr)$, the intermediate approximation $x + e^{-x}$, and the large $x$ ($ = x$), i.e., the methods in (\ref{eq:log1pexp}), depicting that the (easy to remember) cutoffs $x_1$ and $x_2$ in (\ref{eq:log1pexp}) are valid. %% moved from figure caption: Note that the default method is fully accurate on this $x$ range and only problematic when $e^x$ begins to overflow, i.e., $x > e_{\mathrm{Max}}$, which is <>= (eMax <- .Machine$double.max.exp * log(2)) exp(eMax * c(1, 1+1e-15)) @ where we see that indeed $e_{\mathrm{Max}} = $\code{eMax} is the maximal exponent without overflow. \section{Conclusion} We have used high precision arithmetic (\R{} package \pkg{Rmpfr}) to empirically verify that computing $f(a) = \log\left(1 - e^{-a}\right)$ is accomplished best via equation (\ref{eq:log1mexp}). In passing, we have also shown that accurate computation of $g(x) = \log(1+e^x)$ can be achieved via (\ref{eq:log1pexp}). % Note that %% FIXME: %% a short version of this note has been published .... %% \cite{....} a version of this note is available as vignette (in \texttt{Sweave}, i.e., with complete \R{} source) from the \pkg{Rmpfr} package vignettes. \subsection*{Session Information} \nopagebreak <>= toLatex(sessionInfo(), locale=FALSE) <>= options(op.orig) @ %\clearpage \bibliography{log1mexp} \end{document} Rmpfr/inst/doc/Rmpfr-pkg.pdf0000644000176200001440000043674014552770167015456 0ustar liggesusers%PDF-1.5 %¿÷¢þ 1 0 obj << /Type /ObjStm /Length 3987 /Filter /FlateDecode /N 58 /First 479 >> stream xœÝ[isÛ8Òþþþ |yk³µá ’[³ÙŠ8ñŒxäÜ[S[´DIÜÈ¢†¤&ÉüúíÆAQ$%ÓGö*EF£§HF¢8‘$Œ"¢H,9Ñ„³X“ðPÇ$"‚‡!‰‰%D(ΉˆA¸ ƒ/y@‚˜Ã'’HÅ _…P_Cë´àwЉҒð˜¨PC#Œ¨8 ¢¥„ÆÑSÐ E ‰ÂÐ$‰ M"¥C"BÅð#"sl'&±V!$ ÔpHH †i“ €D(  {‘8®€zèˆóP/`<†ö U‰RÁp eÁ¸pèBBËAÀ -RCh9ÐÐôƒ‹ å •ÈÅ™ e hYÂ` ôËe„ hYq`©B .ô=AG ZV ^®B`‡‚–Ut¨¹ŠñshY³HG!×ÿýð¡çi•L“*!šÁd ½Hæi n^Þ|[§„Cù2Ÿ“'OÌ'O7Õ"/ȳt6cLNÓœ±PÀ-!Ã2¯¦,żîî Ü ë>V‹4©²|õ,©RòèÙŸ’qÁxÈYÀþÄøûÃ]=èïÑYò&ý@¾dÕ‚,€®¢HgPüSúíK^LË&= ûÖð"ÄÄÑ4jaéC:‘ÞšîØÖÁïL¾r4c]÷Ô37®Évl¡²còãÙvŒƒÛs´šïfŽ¦54*ܘL¹ËÇ:ž…ü<ϧ7±ò¢È§›I ¼|qqF^,ò²*'E¶®HlYdËb«S±ý.ŽÍƒ3îž{Úo~ñºgÕÑkÞj•WHPÀ|­ã|U¥+ÈÃduöð>NË|SL ìàZCÛh-A‘O.Ó Ú¡ÏN€ ôk ÁMºY]Ó_‘2¿.7?EÈoiæ/ð9¡-Ô˜Ñ`µÃHì%\À: Àö‰d‚KAðÝ¡@Ì0…Ã4µ\)惙$Í@1Ï“¨Œhþï]ȱ_jÝ)'(öèÆÁ¡­_¦Ù|á_AÂPÐѧô˜žÐô”žÓ :¦—ô Mh2ÍÒ"-³’^Ñ äË|¿×× Ò”š†èŒÎfe¿¥t EçtAÁK-ÒÍègº¤×tEsš¯Rº¦kTÁe:«lª0-€GËò)ý•þºÉ«tzµ4ü‹­SÐ’–éoÐh™}¥­EšÒêKN7ô ý6uÇùX€Гe2Ggn”äÈS†8È ÿ[z’-S€7¶Y¯’ët¯>Ÿ&È&OWspÀÃó¬,A»ì‚œË*½~‡ø¤©¨ ïŽÏ^žœCG—ɪä¬m7@ÅWOWe¶ÍØZP›vóÎÖ« 2 !˜â¶ÔhІÔØ×ZjÆ ¾3Ït @6j1Ø_·˜ÎÛLïçÅ@žÇáP–_¼~;>yççöYzA_ãt¾Ydž±^w7ç-ÞŒÊ|¾ßrÛ+ÔÔ_"LgÚ˜K‰a଺BG,Á¯f>Zf‚í˜ 1JcÂÀ4€žƒ’£^¯Q-wTÕªˆŽîAa0ÓCK D[ OÏP „ ©_è7< `:²ñóøùÏÎk½ï“ å@ÄVXW‚–05T­Ú™|Ñö2ævŸ¡kmÌ8„@f¦ñö3R„[—gÞá ]À›ÉÚø´¹…ûÒ¶áV8Ó‘!<„ÀVBDFÖøÚÊ;dS¾ÖI†¥Ü|­lk`·#“€0Ì6]‰ºCC |‚~Þ?½à»¾‹¨Và W®ŒB£ÈŸ‡$àolóßé׿ϵ5# #òç¶ãPÆ3úÜ  ∗€8Îs¼¢¯w\,2‡=ÞÒwô=ý@?µPÈU‘L>§•A.mB H{ñÝЯ;2*ãÀ ã ³{7\Kè©*ž(8w@ gïŽÜ‚ÖÛÉ ÏÛ˃A¼–]³ü` ^_ìñª= {ù1p¢h¨•8~:~wúº5߶—Ü{lÅÝC(±k&8 ÝRˆY ‹T܃°÷î7udãÀ$a1çÀJl¨5Oº=O¹7TgÂÁAקˣ/^5ºëL”ò¢th‰Lt¢,ÈhÊcfî^«èE}kd óŽ;*2Ïý5šï¡D¹5ù×—À´Ù± ]=mQ´ˆ 5ø•Íï¥÷\paKoÓØ»÷”Œp ÇùÊDš`­4»?¸›b¿Ò—ÊàŽz ßSûÚY>úɹ‹Æ%½KG3ƒ²–»ØªvõŠÐáõ  ¼ˆƒ=»A¨ªdW;ìØb<–»- Û ²Wb›Êñ˜ËCˆçf—"EOúêòôì#ô|žT Û[$ê•z«1¼«1íPCî¡þÄÊZä KW?TØHÇz´ÞtùcÀæÊE ŽvôÀF‰6ÿÂqM•ˆÝµE[+`6.©L>n”âÈ4ô,#è$è§SqœÂä©[†=' Æ,׋dGætn‚ »NºLËÒÊ¿‹ Zg,1X©@ÎÜWÉ pï }¨dnŠÚ‚~ƒ¸ õ|ðšç‡¯Î|Š櫼_²½6Ö’È®dwa½º_‚››urî{³Fêpë¾|_½n.k|swêï?fÛÂígs! þ{Ÿñµ¥œdÙ$+&›kHcT\~¦I…KI1|`š/AªêÍ ñÏmW5¬üÕæú*-Êl~óü`Ì¿uc¨<ËtT•¼µ±áU}'Æ_M‚I^¤‡‚|÷ÛÇÒ¢ïîqÛìÕË¡Ð}Ÿ»ëX€—GÏ/ߜ¨Ï Dm3 T× ´ã¥áѽæwsXßïÂs@=¹Ê:@-·ë 2˜ùÚ \Øí1‰_Y'Síä|¿[á¸þ*z„ÉíÍ7„éðÝÔ¼dôìÅÑÏo/ì^.“UÕïX¼Ðt,íçÿDzÏ}ô÷ØïZ¹-pº«Ëxø1ßÅÅ[ƒì]NZ;·Jû~hŽÇ½Òâ_ç:^¨»Úüü‘P¶T‹^ÒÙ>¬ÔCmÈ ¸ô©9tIèÛñ©¯ùt‚‡ôlÖ£EU­Ë?Szµ™—£ñãu‘ãa±Q^Ì1ë÷ f7 å"ÿòwxMæÙ_³é_¸ýGsnè(/€knÍÀñcóÂá‚——0<’4ÁCGA8òL"¨‚HŒbs$×£PŽÕvè,[}® ÆCR~DcŽ',3Ç]½O+<ŒêÒ!áÚ§c« sÕ¥â÷gÇ0w~ÉuŒ‡Lý·0>¤Ìp)<#‹©úp™?°åΓÝÿÀ–¼ß­‹O?^|8óÑý~‡qhùPE™ dËu ?õÝδ—Ýîìnþâs»¾³…ûë9SÞØeî·¹5Š»c”™mQVoŠú~”8¼Vößz)s>ᶫ_¸L»ïÈTêvG>7–¸ ³|Õ>ºÄô«ÛB<Þ]· :u7HöàíÁëðïOÇo>½ß®ø¿¾Zf¿nÒ»ï€Ίü‡í€„`#{¼Vgj/?†²ž ^U?zw|v~Ñ:+sþG-þs>taeèA%fÎc4ß»G”nwþéÈ›­,ãy‹HÞ»ƒ¼5öd>½|yâlÃå·ë«|Yö.ÉúóºÜ‹vuøa(€‹Ä]7›¶_ïÛ7¿E•ï{EQsUk 6¥«Ñ—ìs¶FQ1:…oöŠÉêÿEXþ}’¯Ê ÿí•MDzdþ”*¢QÄd­l$0dúaÍÂ÷HÄFŒá¿YAð¡"E è8.®Žc˜ûú®.‹ŽñԞϵÿOøùoñà†¯£qMͧ%D+> øvBõ?$<Ëf3hWhgþfNã4OeÝcø÷<> stream GPL Ghostscript 9.56.1 MPFR, Abitrary Precision, Multiple Precision Floating-Point, R 2024-01-20T17:10:30+01:00 2024-01-20T17:10:30+01:00 LaTeX with hyperref Arbitrarily Accurate Computation with R�The Rmpfr PackageMartin Mächler endstream endobj 61 0 obj << /Type /ObjStm /Length 2609 /Filter /FlateDecode /N 57 /First 475 >> stream xœÕkoÛFòûýŠîK‹ Ü÷«è'ÛñÙhäºr¯I¯èZ¦-^$R!éÄ>$ŠmZQ(Š»Üåìì¼g¸FFŒ$B;bQN£‰5žC8wœK¸ÆQG¸å–À÷ŠˈàÒˉÖ+ˆ‚w˜…—¬"R0èk"5³†H˱îîŽH/à}O”€?LjҀ ,©,ç0QNYâ$Q€:E4g0O- gˆVßY¢µ‚ùŽhã q€:S†xÜ—’ÄÔז4–Ás [àŒx[€ù0d…šVá8 ® 'P³Þ‡­y¡ g p4°ç@Ø0…3@OÂÆ8S€WÐÄŒfÐŒœÁ9Pbqæ—ò‰$4LFlŒÂ.Ëa ¸¼wØÀy¼äB•pDF•-DÂbŸãâHVà.aÅß¾ÿžÐQ>’‚ Jô8\žEñݬéÎÂì**È74̲ôs†#4Nnã$.é"Nîsš…7ñ4œKèITAzíµ&ôtÞ倜¦Iqt”>ßAŒÊ1 “,ø£=çìAz˜0©]„‹ˆÐ÷¿¾z;‡ÅìêqqÎs÷zÝÝÏÃŒÐó"œÇÓQr7àM:ŽóT)Nûñìç7õŠx.vê„éê„ÐÛJá:Jsé„ÏÑ• F¯%Uw%˸ÍÞÏŽÒ.Ë×;ô]ú?Cä·=ú?~½ÇõÒ$FW tH—t°lË(©¡ hôªÿíßzt›Iv“I¶Í¤)?C³ ï!DÃ*.9L]÷4…ªÃ0ÙeX‡rÊôpŠ¾oíg‹m£ŸÆç'£Æi™—;ø&:|C8ˆm"F¼ºl1Ä·ØRuWlA÷ž½Å–'=:Æ&®„Ñá‡êò£—2C28˜;»ÎOš•üN“åº& ŒØé»1ƒƒ8¼öñŽÞ“¥ó-Z!î=} =11‡Ùá¶GoÇ•BôŠéPW.ûâÛµ‰R®!ô1LôÁ²ªÚ]£›8lé±×¤ÜNñB3@þC€QÍžD9xå¡•ânk@—Y:EFýÍ“SÀ)z(J7è]†wQƒÇ„cš[ÃÄ ¶¶oÐ-Ñ<’ˆÕsMDƒƒ€˜±Ö܉-©ŒþöívèØ;\¢7oÇ¿œœ5.hWìô¬Òú-'n‡:qÈ\4ßíÂ_þ{ ´j^óFûÍ5„îèæLüßòb~£lŽ®e1ÆôìÄ´¶qi R°;Û¥öß÷D"Rl(ùk^‡! ”ˆCGË¿²Òò^¨å"=«äl­\-…²ÙK¡ íˆ¬ ÖÀËZ¡&`äM3ë~ÍKš•0au=j饖â†KdjÍÚiÍvÓf‹ šŠ j/*¼TB,æ™÷I 8ú¦¶÷¬älÓ‰ŠNû¹© ù:mÐCµK«:ô%IZ ýöÕ¢lHˆD^îA¢µŸ{ÿîèl4yu/®ïó«0Éw†ÜõnŸtpnËÁ‰¡éŽ2KÙÔM5hGU^ÂrÖ®ëi§µY{yQL³æ­¦È%„ØšµÆ·yg+0F÷Ó ŒËîÊͽxÚ ãºpÕ[Ç­êXàóÖ1îÃv!—‹þ Æ è"³éþôVþ„h<éÑíUÐ.Xý{|ùþ|òj|u4ƚϠ ØÜ…ëyGÍÐËŠ™ ÛˆSªîŠÇ…*ÿdí† $u¡Cõ­\»C‰§(B×$ì™êÔ¨´WrÞÌM‹8MªGßÌŠbù¥Q|Ž?ÄK4KAšÝQìÑËtþ8OïÂ,.f‹¿ŸÄ«ö·¥9J³›(«MX™=—ðÚØ9ƒm íš¢uò60 ßFXºSÌMaM ‘×ìz'V¨¢-}>ùÚŽ°Çð·"~ªlàC6éY‹Ô‡²ÿú¯ä"Û”1°¼i;üÀÜ¥à–#µ;é¡Rbïö äPµ:žŒ.‚Éëe–þÔ T¬e8ýþqåy4¹"qPkñý ,Ð^€*Ieðëw ÿBUê¦ÿ±f|y¨"gûT 6mÎËkÚ ýý²©/áó yÛÏÃCe”ø­á)å—¤‘¬^_’€'Jð9g¶¾»ú^Š×Øâa’ê.ê»Ü6ŠæP‰*çûwUÌÁ,Þ¤qi k+‰Ýpº(qÀâšJc´•Þ¼ÚÃJ*0<#d| QŠñ€A‚atyàb€•jå¿þJjÀ_¯ð×B<ä_ϧ9FÅǼNš€ ÜŽ ¼µ_}+*#ƒêî^¾¡Eˆa€9¤xæÌpˆZ?,ö‹åmV¢¾‡0H«‰¶,Mkr<¯åD ®9(žw‹å<¾ÞSÁU` ÷ÔRBq"¹ð ›V&r`üÿ,¦‹0žéw‹0šÎæQöϼ‹`³ *fÓÙvÕÊC ¤fxþ… ?™Àñ«a‰n)¤üérÑf/{`ñ %ì…-¹ð#‹ô Ób hô§ =rÈkO¤ý'ñím”ááž¼ÜiU)!“=r}¸‡¬üÖÒ: Tž`i1*ëYísFdó Qùå¾>hDÀ³¯Ï •áGç4ég"xP©:JV8BºW„^mq:à6–ñ€8×T= <üÜþlK6¿Ûî^å‡Å~endstream endobj 119 0 obj << /Filter /FlateDecode /Length 4121 >> stream xœ¥[Ko$·¾+—äà[ƒä`N°Ói¾É °1²ÎÃNÖŠ‚Yå0+Íj;niä™ÖjõóCR²‡ìéÑ:6Œ…zºù(V¿úªH·h¹hñ¿ô÷êö¬]Üœ}w&éí"ý¹º]üþâì×ç~!}£¤5‹‹wgÜC.¤’MåÂã_¯·goÄËeÛ´Úxc¼Ø½í†Ýz×õOË•ö¶iM„ïZ§ÄÕÕÃn=lð“ibˆâ‹ííýðºí]j/¥xì†÷Ë_ü„ˆ¥ÚèFãâúLœ//þs$¥á¢J-~ƒ-Vʺ&F½XÄQúrñ~ý¥¬ÆUš{¿ç·´,夷⟭!ñŽž­n}»$g%Ìغò@¯—º”ë«¥[%¾]®ZÔÓ^ßlÀ”Ö*feCcµ‹•Q³:òp_SWçul¡ënèî²:Mýí¿0›ïûMRj°qÑ~¨,ßã`t©k@k4úxqÑ„ .þ#k kñ¯Ö€—-¬º»Z*P«i­xx³üáâì›3 Â,Á»¾< àU Á¶}ÜžY¥?û³¿Ÿt>i±‰N¹Òù”µéÁùÄË·{ð·«!ÙSÝV ¡…†Æ„Vò /Xb+5ØoC ³!À¯¤$_ ¡ÚÆøÖ×.WMo¼òÙÖÉO¢T­­{aàë…äwpà|€2ëë$¨±bË;iVp^#Õ3f…ïZÇq ¾ÏJ0âºa[®©Ô]_Š†¬ç‡x‡Ëc™Ó(û h”R@F‹* ˆ¾þÿUé?8ô Ô$<jDÜ®ÙHßOËuIØ?SÜl´Êʺ*çÜVŽ\Ê›P¿°g’a­|îLµÐA Z¾l\M> Y”ÂHA# @w^¾OÃÇú9í^å|†8Þ•F? ‚9AÑ-z^Tr”×°Dvþ'~‰N\:P5ÚÏ‹¥ÜÉë¹ÑMÖð÷¢!í$̇1,yYœ±H¿Þï«iqÑàœ$qßð³m=TjEexz-øMüq~hŸì±¥qvQ³Aœ†˜a»Û¿€ÖeÁƒŒI-ÚKˉZ¹!ºýÉÙÖ»ÝzûiTHÃûSƪwë¶ôÌ$X ÑññÙþÊDПDÀNSBÔÌ­f½ÝÔ.}•”gÕt9ã3ºÂ3_]üê jèTÜÃo]å"kG[Àoé'[î0Â̦c¬:ÞÕÚbجaÚÚ}›&hauëüÃé›Þ#.Å—ýÇå_hêõõkjè4Ø[¼:ÏòŠ/ò“}÷¶h±ìi™€Œ/°î\ÿ ÑXÞäé¸U1]——0ÊÎ[ÞÀÅÓ-mN4C©Íí,i™ÿ4ãn,qpÕ'> ÔŽpW•¤Øœ n$ } ¯Ý}_|f­Æ^ÏÌ€± %»%¬¼BÁxøl[\qpš^;D‡DÅ«Ùá•1qŒ}a¯íÒ"k˜ï¼»Y½æílïmw7ÌM„9æ U5j§¤ÌómJ…uë·åϧ9žp¤iÁÏ–RŠY J"I:òLe RtÁgAàŠ­D¿DÔ ­R“M‰ð€‰„qÎW@3*ÇÖÐÞä¨F@òh.ø‚Ÿ?,-¡%Ķ®_OÙ Mæ,‡Uœ'ÀeJÓ(î¨Ö6tÄqÇxÖÏt7 Û(¾ú²ÜN_%‡mÐ×8TræJœýÑBCK:>x˜¸lÝ¥—¾™d $¾âpePëúámˆŠá³•'—XQö#Ãb#ˆŠ€i94)ñu9_Ûwj lá©t¯YÊÈ?2eLr~Ÿ¨‚˜8âfq3ÃÀp…„—ˆ¾I@1cä„Ü~‘#Pm€ï*p*¾$Ü„•="65éˆøTb˜•Ðv¯óŠ}•!Ü,g2-ÙšÆ8ù3-˜SÝÜ{”Í‚D°Ç !¹ ¹¶µ9ÖwI`=Ù“µso£&½ûž¿´sžˆt†–fC«îæ‰;`‹·Ï0whЀvìK6Ê>Wó0.ÜàÂ,4ípD}ŠVÛ.íöœÀk4“÷7Òy‡„Ì6LÈ/U“`d¢ÀuNZû3YûCèlD*‡¯m‹ù)Ka˜gò†}"a&£!1§}@FývxÑEfè5 Y93N:dI&M¼ŸÝyq•=v¹n»u•ÌmçH$ËÅ,‹D¹´c¤…Z\2_[ë=eN—éWÆ¡Ûí.—-@S5óªÈèC…dCPžƒ®—¥›ÜF#1“Ãj,Ê8Á*u*¨¡‹³5#ˆ\3ÒŠ p­mJ^½½‘µ¼KCîN¦Ä=A†v¢®§â0Õ­½vOôÖ.† ´rD¡wøÜR‚þûºó$èfåh† ÐÉýÁ‰·ýS¿½ÉM¬(J83Xt*ÛG•pªdà§Ï%I«yë—šéöZÓö†?£yW²ð‘:9 lXã )³RXs¼Ò#$‚ʦ©ƒÑ¼{/E‚~U;Œ']BþŸÌW¸ÚèGf¿º\î‡u™0!ÑW9¡œuL·‹y\Ò!¥Á_îØå1m¯ -5C9I@×£ ùÛž*6õë}“*$¾m¬ŸÕ?á -âM@œžú Û­›,­FåŸÓU‚úáÁ. ÒçèGâv' ½+Ù©w9ïzŸÖNdž èóšÁ¾Ó‚p©wn„Y;uÄ™?±bU–ï#P&Ÿ“.q¾z¿éïgRÛÆØ6goà᜾U ËézézóR¸ã¡ æÅ’v ù䆆 A”éÁñW$Ü,1‡öéSÖŽySþZ¥ü'šÆáÈ÷LU; ÆÒ1Ñÿ(‰z /ÅâÒ ¢ð'Ñ°+G¥šðˆuÖB±ßæ¦:Ñ*m@Õ§)uŠXÀÅìÈn{›Þ/Ø>SfË­¤Ø—U}Ì}é´——~Ì~HZ XÔïñ4Ä8:n,ãÚX9s:WκJ »t²Køpé”ÂÔ ø6Ÿ””L=<,‘Ï4Y<®ûQL½°fß #ïzâjDËÊÍùL:,‹Ô»rºÙ…oBpßa§" NÇ‹àt"¸;}x­æÎ5à‚lõ÷~P‘Î_ŸÿR% ƃ?s$^§NyÔ€gN®µkOÅëJ·-µ\)Û„6¸þe kóôÈ´ŽÐƒ¹Î~öÜvƒ]åø [,¥å$ˆâÕ9ÌPÎü2i”NnéLïé`MîÅǽã6’Á… èüàó=ÜѹlAïe þ¹Ib€=7ªX˜§R ²?igé0jEŽÆ‹Wýv=î'šKƒ”¸ajÝ¥¬I(f´Nœ7ïÁií!Ú´.ŸHçŸÏHûpE€ UHß(ˆYZÆFÙtBi³`jÈWðÙÃ!‡Ø¯×WCQ4­ì»’ÎÑ +¥‘¢èêØš œõç1?¢“„@Ä—±~€í»á¡èTÐNR牜0”ï·™²±8yÃUH>5Äg­'FÜW¿Ö‰Ô‚”Dm¸$)ÃÄW ºBà 9In“ë|ùTYÌ…¼­:ïºÊ…×}ê‡NýÍöPã¾û$ žÂ uÛîòê}­¤òÇ ñ‡Žgà!Æã–Ô€SM¼hB,•‹ô™1€ª!ŠÏ"ßV,|W¼¯:ÏXZU…çtÐ8-µtæ4;—ƒÌÚ„1³(/Ž5£W|•Å†æÜï°´íØzu]¸V™J åâRi %´ùÒMÙŠ‡(—YÙ{8F,ty8ñ¡÷µËlXO­W²z,Ÿò(ÃgÄé¬ÜúC¦œ;c kU˜÷ »2^ S—Ç1ÖFnBï¯Ó\†Î=±Ê§'’ecno°e“±”sÊWŽ[ÁrZ–Tx „Ó ¼ìdÂäöOÞ‡LbÆúÊÛÂ;úü6+ß)ÑÄá2°îJà¹KÑ„ÚK3¿°Wº &n\á#­¥uu"ÿœâR­Ì!ÙOÉñÀt,l#­ª•ªüÄñm֩йNˆ|?óãœòC£¢Õb-߈ßâ&å Síª%´”%²bDØJ&ßš›Ÿˆ˜6‡"Ùå2åGOé*ƒáâ¦.ÕÇyKk0W:¶ ûöðºôøm«<Ä^9Ø”¯}‚îl0i¡ç¿VI1H‰ÍÇûK!?fª-ÀD5æÌ1ÞÈc7®&¨ÆË ‚š¥ªmBôcÖûX2‚.Ý…ò ¯> –Sþt_·« !£åLc&j¥vû|ý# Oís±)ãM7ä‡ë(ÌÁvyxSãaÒ1f“øû‚«p¤õþ ¾RàæÒf¯¸Ù »ÇXt)~qM¢üÔ>I¤jœ3c$I"#mô”HÂù‹e :¯ÆÂ=Ë.'A¼Ü~saÍbªñlTCzRܪø¼¥+BW5뮡ž·<(°‘t›,3תªEĵúQFýCU‹€dL:ÍI:‹þB!È:ñìF«Ý,íÃRåd…"«}F»ËŽ;¥Ü_÷àAÃå¸Í^¤/V®“;rK‹ðߤþ‡nHüglN)OoMóÿìJº>–˜ËïÕq³ÆË43’a©׊¦6T2ž±A cï*K"®Ü‚ã?¦Áð‰g_jgGæ£×EZÑŽwe%!ëÅgÔ>q3#kv›ªvñTª¹Ûÿì0Ô7§¥qSu²Üf<Äë|ãydÚYÕ.¨ƒû;7%ÕùÀHi{=Ÿ ËŸä]™sÞèÿ:»¾¬Qqt¾ÐeÄÕ°=áw°‰½q‹Îñ'òýO5f>Á%wû,´>mš=žgêd¡*\ÌæÆ5Þß´8…Êü?§P=꛳ÿ¦R~±endstream endobj 120 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 5003 >> stream xœ­Xy\W¶®¶é®q£lhÂX-îq7—ã1¢¸àÞ ²/Ò€ ûÖ}h]‘MdiD¶FÅAÔÄÄÝ$êÄ-£Ã¼ ‰“8z /óæÝ’˜åÍË[ýû5U·êÖýÎw¾ó–0f}‰D2ÐqÅê?Wÿ©oM\à»ÃtêO@R_euÆÈÀB f'ÿ¤<`‰žƒQ:ð Æô÷Öÿ€E»ƒìƒv‡, uu ß¾bÇNw'ÏÕ^Îk||ý¦¾5múÛƒgÌœõΠ±o>™0q’À0Ù•Œ3’YŬfœ™1Ìf,³–YÇŒc\˜…Ì"f#³˜™Ä,aìf*³”YÆLcÞg¦3o3ŽÌ æÆ’á™!Œ‚±bBkFÉØ0¶ŒÓ—1g.1ý™Ì@I?fÝcÆÄ0Ï%HnõYÝçÏÒÒH³ñf×dCeûe§ä.ò¬ {Ÿ[À}Ñweß‹æãÌûy÷»ocq·¿¾ÿ½). X;hÄ ƒGþÚr¥åC~-gˆbHôÇŠEŠÿ¶škµÚ*Äz5ü[ºJË€§Å­¡’ÎV+ã–duˆ;¤= 6A Mˆ 'É]/•q{A””!À…«åGôC”ÃM(ÑrF6vB@vJ&èõ©mh¥Ä"ù%2E6Q-¯Öw@TÃ÷P¦åÈULPýr싲2ºt¹±Þd°D)Jp+J¬ùL±ÃÊhùì7n§IŸE+<ç{ :ì#çÿFæÆÊÔìÅtØ¡"ŸÚ«Ùýçp”Žžw°G/–¿‰Ì½¶ËÇ‹‚ç ¤ü×Sü»Ï[QL|­ø†AR…˜ƒR±h;ù;2•Ìœ>‚Xëö‰8g>þ-b‘¥˜„# bØ÷Á)øsa­PÜpâ>„Ú]‡=`=l¢–Nˆb"èŠÁ 5J.¢˜Ü$íŒÆ0EA|ò¾èhˆÒ 1dQ¬Ÿ ïôCΗ<ë|Î ðmÞÍSç/ß~–Õ·û»V’Åú˜LÈ®ô¥*ôgK %D˜¿È¹eié°!±dE܉¾IÞD-Ú#‹Ð\E!%ëŒ8Ê rÆ€ZËçÓ4´°æ‰_b°…IOˆ­“K¨Ïvá Ëw?áÙ•ñ;x®aËBšƒ>‡¾üG«ˆ…µÈe¹Z]|ÊWÀt–Òr¼-¿ÞöÊ'¢TQxWµ1½ë[×Jê(Äi(‘Š_‘u £½ø­;»n–gëÆêetˆ·Ép2âÙ TÖµfœ>£"[ýd^U¸¾ëá Üò•ÐGÿåÔ…;'ÞÙB—’\Ž2W4qçùó³æ‡‰óDVѺþè¦w½ì]÷SÒHåü 2ëפ¹M¨€ûPJ79ßgù±†tœ†}…ýQq{ œs3ì)+34 tCç'šV©0‰JœÖ„ÃhTLjN Œ–u=Q¿èj·SË+ô(‡ã€ÎZ¥‘Ø`Å9öïÛªš°ÒU¾0vÛxa Và9Nƒ²…¹¤?%Œ¤¥‰7à•8´òJ¥¤î:î½.ßD•Z ¡‡Üj¼ÒÖf-Ï^™ -Ü•'P„Ò´%Az!9"ÃÄŒ"H)Q}ÅBú¾x-Äì“¢â’òÝÓ<€ó#ã€X ÇA!U ªòC|*4Ä4+÷Þи8æwñ‡uÉ{€Ó@ÒnaÙ0ˆËK×CþaáHá ϳplÎáà´¡hKwÏ7‘{“Q´4ZRfã´TZóbçuÜ£0²ÁÚaàÄI¯T£Ý(4°=(4Â7ÚVÃØÜ7wœþÐ~(øôDÛïRÿç#ûµ»ymªŸƒS€Ë¬|ªY gSwj³Ftµü%®MØ¿ÉšïÍq¢Íu=»ÌÏßw%\+°GÉHtveuc7›ÄySá¸Oªävv~«ùü-æQ¼a—‰^êÖפiIšØqP¯ÍXÞ@ìæ– ;oësç'–x%þå+^¿ÍŽ¹æÿ²ôÜ7 ÉïȈ3Á(vPN@¥T´¶23±ÍŒ¬‡v ¸Ò1<ôœͺ:ˆ™š­Õ?ƒ&:žA­¶Wkò5â8£¤³BEá÷×F€¸AD÷]læiú ´‰Ñªáä a±Nö¡Q¬u‚]0’Fè›{ "5&%>+#•óÈ*Â`¡iÖn­å›À>é‹»§‡§ÆƒM6RÆáxHù‚äg†˜þµ)†”´ôC8 _)Ó RÒ?“ÈD‰½«\j°¬ à¹™ ;!Ö+Šb`¿à˜ ùP¡/Û¾ð"±s&æ 3]«ÃË++Šê ãíÉ ™¥PÜõƳUÛYò™¶H§ zã‹ÓM͇U¼‹;¨ÿ!´Ê‹2 XEÖc_ÅÄ™á>Ý 'ÿŠLÕ·zâ'r­Þ\ÛJõ³M*8¬G‡N|J† ü}'ØææÃa ûºþ£‰-(,(Ì?ܺî\TÕ>áÅCEµ/Y[au°»ï¦ÍÑ>àî-û‹9“Žl9væP“-Â/ûQ7Ä+FI±Iþ®v‡ÈK›Hô6…Ÿ…ˆHJŠ×%©H_r€ ÁJÙ9S| üÁ )ò—Y\Ñ5*!r¿B¤f«ýH„HˆJÓ'Wæ@g.òó ÖxmnvýøÁÙ[͇ô]ÓrS3.ƒÍ1‰¦B¯; ¹Tô¤åDAô^.2Aˆ Ûµt2p„æð„’Ñ­Ó/h@§ÕêTIIû ˆs­ÙSVTwðÔ¦­%öKhdÉŸ¾™ŒcpjréTÍÆgzi<æ”øœ®ó*ËÊh'v¼0/V1£!q]Ç”$N<Cƒ¯¡ÙìEóšBtºÀÄpm¨.¸Ýjy‰þN·ðßí.=»Ù] …àÿT]2sâ¹d˺^ˆJ‹.›HË:•}”É]T{ËõÏ¡†ŽçPN³£'uEszSööV!kþ}ñ«Ÿ’WdyãkA'[ÙÂmö’ᣧ‘adÄw3ÐæÜ©BC½j=ËÏiÆ—àêáaKòW© (®SU¿VÐnØf¢½d% t®À÷ –&{1ºÚ­ù/ÄŠ}Þ>ˆß«KŠˆß_¦ÙD¥CÛó*<+§º—e•q··œR¹69\E/N™1ŠX’a?LÁñ8þÄ‹Õd´Q¹¾1¹¾¨¶°úX±^B&%åS%YßfªR¯Œl ìùä¤â;â¿M‹§éN £¨o‘W¿Sÿ^¡ÜHúýÀ>¿šoÈÖë´i¾è˜= á¶W‡)®Ík¦–2ÝÅ6¯ÛºË §ÐNÚ¹NŒV 3á™-tM aí讃/¡–Ž—PAo‡yø‹sþöè±³Z3Éd¨° Urœ ³T=žŒl©Æ·ÚoWãžê€˪«_àÂi¬yŽ›Ä‘ŠÒðjWµ›&\#ð–L©ÛŽL["¬yo‰o–[“—jOX¸'•?u‰{Ñ^Žÿ6*8~ÅîÕo8]YŠŽøÎó·¿^U”#l*]Ó ¶AB²:=²ŽJLFr^öÁ–ÀógÊós_|Úê_™¥ªÈ/M-Ð'%P³ÁirÃŽÉ-,ÈÎqŠ-`?]à3˜épãäI¸ñø1ØoQQ‘¨ðô\E”¿8Š(=Î×]¾y*”Ëo~±^Õãsó×{ùs=ùæVwôÆÅ~&×ò­üäìúèw­î6ºR‡aL¤AcÄã¬5ZvǬ/Ú•£5_Øù—vEAlJD˜..B'$lðÕÀrˆ»Ûßw‹0´­5|g¹gÃ’B—LýBÎ{šÂËVÐT3…÷Ÿ½á=ŽýبŽ,¬ô¢ÁR:ÜZ½8¾ÕóÌ]±í÷9OsU¤Zœ¤X£›Næ¤/Öb?9ÎL™íd2q³zMœºõ+iIu–pÏ­ù2¬¶2®dzü‡ä=^so7hÓq.›ØË+7ˆÿT4zUítóñÞáVã[×Xm¨7‰?õ*󌸾í$Ÿ¢ÓÓ¦§RñnVÀ­xJ$edh•rlqÒç˵.tt<ÞL¬‹„ è {:u[«¸$]tŒ ÞT´¡~U¯ó¦ÉÒÚ͹ûUgÖ¾ûYHŽ¶Xs0¢"\8µæ]b6¨*qt¬ ;)¡?Ú+§{•œœ™%dgg,+ûh˃“µžrõÅ “ÃànÒÒ¯i~Ý¡6s<µa¢£"”šÌ‘‡’hY“<%p$p÷»¾&ãÕrôÓ£ŸVf$ãůï±ôBÆÌLÒ‡ë)A`tkÅAF\fòmjS´æ³ÅÏ©î…PˆJÞŸ’˜•Kæ ¯-¿ÏÉÊμ6F6P îΰÛd%rJ“bãµZyŸŒ–‰j–×ýšœü|} ‹-_T7z ú›Ÿ“w°øö'S”üüôXH‚7ø¨èPêºï(½jº#ªr¡ÉÄØ.ÐbbÊ}×ãXO“£SÅRÿ›løŒ² >ë%{e7Ê Þ¯õ’Ûz>ÖüõW£z’¬}Çb6z³ƒÏ^aï#‡¼å0Ö¯Ðl⺛Ëæ?Ð\^GÉý3—Ž‡ÌýœëIÊÿ0¡GéèSŒ—C%¸eR1”¿¡â}¶B >‚åDjê®ÃÔ…òcЖÖpë*&*5‹ëô²Þ»Ñ/£M«QrmÐ ‡HE=ú(\åIš8§}ѱqsa-“å4áû¡ôËë­ðw4öQÙ¸åÖ÷•TÕlò-òMN¶¥×Þ<ÑÜu‹ÜÔ*âGB£ché ·Ù#Îb{ÖŒl¨G-=Ä!Mµ–TøIìsíê±ýFõ„D‰Ùè €ÓAßÉå_—rîr·]"*b6Ûé õ{T+nª@¯@íNm¤.T—¨O‚8Häö¤Áa¡EŽf0bÓV°#ŒfYJÍ&•13¯ *¹Fÿ 7›ïêïï:ùÙZˆ³ïþõ™êGxi93ý–ar™&÷Une‡òã8q[¦K ×¾Htt­”©ñ8‘‰IÕ¾£šVß™ í36+Èð3Ù|†ƒpnƒ·á(nxj‰ÌI 0µ@–Q4[8`Öc2tû¦Xµ€o²¼[Sy¶¼”)…áZcUá™Ô÷€œHš ѵmï–Qζ«aSöæ‚8}’> ¸HˆÞ£"ÍT/¢g铳2„œÜÚæG4L0ñÝE0‚ twÌýÐKÅcÚ6«ø6¦6°ÜÝÏ;|óô»3±ŸÀ›“:žà Õ±Eì¯Áu8Rò§ßÁéRÔŠŸ*®zŸsÞ¶Ë{‡G™Ç©ŠCy‚v®÷ ç­1±:E?&':-÷û‡h#`ŒÕžû#PH gÑü¨‰(<á‘‚ŠíÈ[ó¯(IÜ8lÜ-Ò/t9ÌØ.”³ðIÊÅ£g‹›Zë¯Ðj\›T´3qoìâ<ÊwW14¼ý“ád0™;—ä.’‡´Pùí¦"|²b,̱<èlF¢°ß÷ “Ãmg.|sÆô¾O¦F<†æÕ”Î&ÜÔ©Ty7DêƒRµÙÚ,ÎUîM€Š+…úÓ‚ìÌ´/i{Âá295¼v{}œ36rK[!£,÷`zºp0Ÿ¶>Í€sÑìÒm‡ÊÌ,ЃûñI­äÔ=üøž”îÚQ(yû”ËÑ?9îp?Ln&b³xÞ¸µå+oíˆlC˜=¬§þú™3•þ±ï!õkxGnáêÕÞdØ]ehv@ }ü½—ú’G-[— Å]Š9s‚un»{óÄÉ–r…w aÆ`p±é•RªShàâH)†‰œ¢Ñ»jÇo_77ƒo}½¡ªQ mf¿9Gƒ"½s]¨äz/cÂÄùŠÚ ÚÍþáûbcýÃÅó'23’“!•ËŒÌŠß?j&±YfXs¾¹œ–^ʘ?<·§e'{4¯öÓø0íRÑœÄ* ôa‡ˆš©q1˜Ž §qš¡,'§ûA4{b´  ÈHÂ:G ”Ž7ˆ'Ü‘=dw rT¿\ ª]Š÷QOcáhd8rÅZˆ.!"A[N13’Å`:6l$3ˆ‘EFv=2dê¡èˆ@Ña¯£#àÒ_¶ºOÑÊÔíº 2hE¤¦ÒSùÿÙô.û¿š^ÞŠðb?Åqߣ^î~žî•5Ç+*™‚ò›s=$! zÔá!N‘b\©â²ßù5¯e{jª  H˜5{I\¼V ÝÙ~ð»‡øåI?\Ü.ÉÁ6)^ÁÅŠvÒ6™ý‰x½¤ûü·œû©V¿2n?}7Þ3ý|‡;L‡5_õʆÖjqíÈdüʨD2ò‹24ÏjÈ®…ÐJÁ7:"9žr/®øëQ†£%uç¶~4zŽc„ïZ•kó* %‘‘q^¤¿jôÏ]ÏkŽ–êW¸ã9¿„-KÓyªÈí__íòè´UøÅìÓ€h2 £¸ÉÄëûävͽ‚jmx¹0 2GtÊÄm‡³räFs”ôÌÍÖXô s°èW‘’œ’’¬OÎHϾma– ó?ùC#endstream endobj 121 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 251 >> stream xœðÿLMSans10-Bold‹‹ù!ùJ‹ ‹ ¹÷TÇÄÁR3÷¬ÿ¾È v÷ËÓ÷uáæ÷$‹÷$÷÷,ù!©û>÷¶Êšê±‹÷÷Yûm‹^û„ôg€füêg–°»±•˜®÷›÷÷8û³™s–‹¡‹ÆŸœ‹©û+øfP}Uûû÷u÷÷ ]Iu¡ø^œ÷i§ŽŒÓ ÷  To ‹ ‹ Àž‘‘ŒŒŽŒ‘ŽŒ ‹ ûÝa˜endstream endobj 122 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1362 >> stream xœu”yLTWÆß0ÛGyŒÓ}#¸`´„6m0-‚F"n#Ê2¢‚ìÈ"(;Ã(;È.ÈZFD-¼Vj¬"T­H¢µZ­ iÙj•˜œ!—ÄÎHÿjÓ{sÿ:¹ç»çûò»<0ÆX±r`vtÖ[>Hý¶ÂFé´åÏ·QÆeöETL¬êp¨oøqŠZJùP_R~”µ…ÚJ¹Pž”µÀПP5<–wÊÄÎ$ßdœU*¨®À.ów&7m)à0ÖpR´B9 } ÊãÑžHÐAÎTQ³öè%ƒß|ï³ê©ºï‡á>=æþ”,gçÌ•scNJýJC¥¡ÃÈØ´‚¬Ç_eŒ+µ)r›+KL±—ˆ˜ªö.KE#y$ƒCá§â£‚!hb}è(b6¦ÕC'4)‚Á2hûVk)âÏ¡NÏãÂz¥ÏP„»ÑJÎ,Ò×a¬ Ö<&‚€ÀÔˆÃìe13MÜ3…JqÔCy^2!žûÊC)F©¥j!çîâöØîÓ=@£Ù›_pµ‚X-&Kvûï;ÞÖžÈb­˜±êhþº¹Ïf w;±P˜¿ãuÞ4:s[\¤Î O=Cs9ã­_¦È~ðnÙ 0vk<«ù]Ä´W£úp1„(Èð¼jÜúCîÜbèü …c˜Ô™ÐÖÖÙÐËúk¢©lVv¾êäu¾­åã*d0Þ‘Zy¬+´8¨DY¶« ¾£‡îå×½,Ú~¢€ÍO)È­ú,5)æ-MÊLHË:Å&—E–¨€vs‰±Ûw.ºâ´¢3¬'³?£7sè4xÒÞ)nÜd6·J£M:²ã„'N„ŒÚ⨨e‹ «J‹´½‘— Ú`‘EϽF F;¨ì^ÜÑ…®:i+Zý1 “ræ­~šÊj!'9/'5‡õò9lˆRh9¨@­¨¹8¿u,MÉZ"sv!KÈò¿>E9Z÷½iP8¢µŒì1Gòµ(~i3 diœQÊYkt{†Ã(o ©»(åëíõ³²KGúÜÖ. ""v…ò™ù·½3ãÜÊ7b4}”_®-M!›ž•š Ñô¡îÄ–öΆ‹¬¹^MèÐq ¦btøùT¨.ô¢´ÂG>²È—3&”>Io'kJéJ UU±Œ ­5xoa¤ Yèí¾þP]p[œ"A[ :É™ñYõ„¬)Ò“r³NjØ܃ 1‘ „¬ë™?ª›²¿ÕhÓ†BtþM4óvºùÚíQë™UOÉ–<Ÿ§YÔ­}½†ýºÕ4ç„ÏÅõÐgUõa ž°r‹ãÛ\‘Ÿ>ôŸ%å Òª_%ówò»;DÌø3†6°e³1Z™$ý§¼&DJÎœÇæŜǬ˜™çö=9sWŒÑZh…æïø›v«æ.Ñ7 ÿÙü‘3OgG w±Zü öáoÞ²;ŠM|¹Nn°'(b'­y-b^‘ÿòŸo@%FþCîÊ™ú–œÛö^-ÿ·$4O+×{—b@CY¹ˆ3Cû¬™À/Rb 3,èÒææWÞ>#‘€DJQ›3ºendstream endobj 123 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 8038 >> stream xœÅzXçö÷, ;cWÖ•Eͬ½7ì&k,±‹Ø ‚ô¶ÀR—²l9»Kïué.ˆbï%¶˜cK$š`IbILÌ;øòÏýÞYИoîýîó}ÏŸåáy˜™÷=¿sÎïüΙPÖV”@ °]²t•Ÿ³¯Ã¸Ñ«ÜÜåÞÎüѾ®ØøRÕg…ÐÙú`߉¶è»hr·/ºSVu‡;8ûø8Sµf¶ïº9~sý7Ì ø p~Ђà…òE!¡Îa.K®K÷/s[¾c…»ÇªŽž«½œ¼×ø¬uè5~ÂÄI=&Oé?uÀ´wß›1´û°á­ÍGöõÎæÑ$c¾ÇP}XŠ@-§¦Q©Ô j%õ5˜ZE ¡©¡ÔjjåD §ÖP#¨µÔ:jµžšK¦6Pó¨1ÔFêj,5ŸG- ¨…Ô"jõ!5‘ZLM¢–P“©¥Ôj5•²¥´”˜êII¨^T(eGI)+ÊžR½©>T_Š¥j'ÕêHÝ¥.QөΔÕ…ò¥Þ§ºR×(?ªõ)ÕC h¨µMÊšRP/µVÓ­ …½„ÅBlím}ÛÆÉæ¬h®èZCßa"˜¦Ê:®îø°Smç)³»Œé’ÔuX׸nÝ»%u{Ù}Y÷ƒ=lØšÄÎâã==ïIÖIp/y¯=ví®IÓ¥MÒ_ì½ìÿÑ{mŸ}L}GõMë{õu櫓cXwö´¬‹l­ì«~“ú¥öÕÿÅ€^ÜRßøÉÀgƒèA9ƒj}:Øeð×C Cž Ý5L…jº¶Ä­7s›C-Î½Ì z9D¥*k°w‹41[› Q%Fa×Ö¤Šu®‘N:Æ›þÙˆh™^XVnÔgè ²CÈÎè$­WT ¶÷qÖ›®3~{€Á=QºËEÈÝ´éú«‘F ÌœYi²EVW‘ÛU;qWÝËL¯…@Ðíb# ÷Àì]•ïY´æÀ¦m~K™_iñUÜ_iãM––°A†‹é-JXHVA6FdÍoh¡ÊÐZ\õ˵3—/e:­bqÔgÙX n˜¥-«„-ž½ÌadÉä3vGŸKÑ;h³©zwu³ÞÞLc¡Æ6‚«ÑÞ›Þ«3É!bµÚ%áR,ANZcb$ÙC–)¿ž1Óš9ทQê]HŸ†Â„B?´›¥x*NŒ õÙ<ÈÐX§¡NCVج¯€H7&¥f¢h‡ÇñµQ {ˆ‘‡oã±®5^ç$ u" ¡+&Ô`¶E²&tîñœgvâƒ-2´XßNû ³^½ _0ߎ½ƒ{±­VÞ¥¢¥»¬µ”v×*ßgƒ¼¹¾"q0²¿ßü½ wGßHo˜‚…,Œt¢Cêau‰o<®¼FVŠ›$óÖNÄâ¢MÚÔ*G+h±õÓÆ1 e]9²ŒgT6¡]MBÎ yJPÏ¡/pÜcàXòËHÔuùé ³SÓ$àNò­ò-[}×Ã6ØZì(ð\€:h€S¥*.Þ `¿¼|[ù6X n¼½×¦RrsËh³àÌsΗ°e4Š’d@j´T±:6ì7 €Y†×íFÇÑ ´v÷$h‡‡É Q É&ŒÅ2KçCªR­†˜xvýìuëŽ{¼OÂð6ìŠ&c´ My‚dˆ‘µ'^cF£Lœ½9ªÌöÅU”×d'îÎ o xŠ­g8o•‡²Whñc<ˆÇk©ª­²V×fmD6„ãt:NŽhtú Ôé—'H"›Ú wù`ÊlW·¢}þlT1衈AA´¸çñª£UÇû\¿0Ûð;qíKÁnîw‚§rgQ‘$Pea£ñR’SSEœ”{™šI.OµÏSA(ÛºZ¤Är›2Q*²Ùõ5šJtµÚ·â%è Þ><ŠYÎYDn¿£Ú±÷Ž>CÑÏ„-kQ³­Â}žùöౡéˆEÃÐ ÙÐ^€…aËÝ7„ú¯Z9˜!mAÂí¡-qôLt®ÊÏÛ¿"}Ìà½Ùíü+TG” v7¡¼«B®¯‘´£Ä•Ónã¢+].½GœÃ {ᇠæ³}û«L2¼à pm¼Ñm x)üäAÑQ^þ›€™³¬ѨÓgM_Ünœ¸†‡®ŠgtÞ|ÏŒ¦#û6£ ehd™±LØÒeñ˜à9xÁѾ=¾‹îÓ3½&ËÊPA h’Ò{ë€ÚÓB"B£¡bu–1e"?$·i=ÿŸâ×ø|A¨Í¯¹íÅ•÷ìÄý8Šë!©ö®Ú6Ç}á¶(Yñ<&{‰Œ{á0ì%äBÏÖfÖÉÐZ<ìicóW©ÐX.4¿âHSAYV5K ÕŸç =lF‡+ômvm¾ÕX†–Ù‰ë¹ß¸Ëfýu³"±ÞX{ú샄Ž³'-^5 ²keHwþ1ãSb=G²“PŠH<¼ ŠÎ"4Êó0KÜ*ÐPJ“¡ë_h[s¹ >b'žŠZQO œôÙ“åY½=Í9Í1sa6œcjË÷ÝCVÉÞV— L6$Ê~²$h¢b¢Y:6N­q«tHâš®n =òü*ä²ê€JÕçQŒøºI}'bnïu®3¦¸Ÿ½Æj²uI±ÀDC‚B†¥t8$d&ëõ……¬Á†‚ÂÎuÅ$èCŸ|NâBØý0!eæ[xer³°%%’(Ä] ÝOwB÷Õô}£r‡l1­±8ÎïC¼¡ÖB0ëkÎÿöÀ-bÿ†_¼ªN #!¼ OÆã±3vFñ´êúíòv˲å{]3I‡´\šC7$%L|(HøŽR–¡÷BQ¼- µýå*ñ`oâÁ—è.ê.9¸šžíã¶c!<Èg‘ 4ã|›(ÒMóé7\ÍÈi±ù.®ánbê®U^»Ì¶ö‹f´»-øO;·õ2ÑïóQÅ•Òu†Ìl©Yä¡™MŠ–Ì#ã]J[¢Gã(úïÏùƒDµÆ/H‰Ú_B-‰£ö5P.:sß~NÉ*MJó3Úoön|­>´¨€âSÊ¢ÅûñÐ?Òd>=qã‚9SÔ‡O°âÎè.-Þ×öíMÐŒ—áô ‡F9Py±Šu  ª;û¾¢¸¾ÍBt¯—9€ž®i·Þ˜y‹-ç-›NìÚÓ-–•Ó·Œí–i”ÓÙ~×·ÈžàVû® ‰e„pcÍ‚B.JÈ%sƒHàk}uÁ0‘T}º^— a§U«•ƒqš[£jU6$Ø—7@K¢L ñW½HK¤ÊöFƒ0’¦D³œ™ž”ìÐMizIþþ+úö*H–˜sÍ‚‚–ÙÂGË¢r²¨Æð‹ÖéL ðh£Çáté0T­ÎÒ Ù¾¢ŠÈš5>àÛ¶d=äi3¢“U™>©a“p¢t*JÌQ1íç’ý!üJƒ,M–²Å¿I“£ŒñüÞ )É9?¡:éϸ>IɲÏ#¿ßèkiÁ1sv-Ù/Ѧp3Ê»Äd[}¹^½NÂ8š m–œ t¤Wª”žêƒÉ,ÚDC#4¸×ooXŸ·˜ió7-ò) /¯,(*ÏJ¬Ù¬—UÔͬæèÙíãe;èuš4K|fí \ [±òÝÇ—®Ú{¸ÏqMªp>ܧøBÎ×2üÞq‰X?jîÎ-\jnlBÓRØ6¯ÙR Àl›ÅéíÄ.›„™x…( ÁU¸7š-ݵgÏÑÒrsݾÜü˜ ÐúèÀÖ¢õD…‰ûkÓ¢#zCDlt¢jé 錟â2p)ö››^¤gÄÙþ‚£Í„V–åïútfÃû¸ÇXLáî¸çÓaˆA½«Qç §Âtó+ÂêW‰r+Qì×—·6ž! Ð%(°_ëy)öáÎÆ™4Ä{<ãu×Ðþ°i¯):Q^Œ‚Ã2®NO#ÕÿX%G'“øµÏcZR&Òµt‘ê[¯‰^‘u½ñSBz ð Ôó´Ç[e\O"÷¹Bn0ZN<‡;†lÅ )ÒEÈÌuNÏ´ðHv<(X|èÐID‡¦ü\X¬Hù‰puk—8%h!Ñ>*•¸5‰þ(gÌè4‰j¾h ¯Ø‰Ý¸ÒW…€û…ç½ÐØ›ö­ÛVîÄ/=`8–`ñ“aHtùàîê2Ù"’THb Ð*ÃqÃFŸ-òm}Hp—í ا9 û Þp¾ê`±yOÍ)¨…ÆHó–Ìp²+óº5D}+¹i•¤^¶ôãuA îÀSâsØä/kIã\^\–NFð~ß»J” Eº\]‰F¯ƒ0¦µð_àžO''êuI*nTëcizŒ^— L¤ʸ£t~ξ0Ÿb4ÇÒXÅ]i°xCbœV¯e=9@,¬×]Áõ>Gà Ô1¨Zd2BñS§Ç$ƒÈßÞ¿Ž b¸ëA$,”-Bö+JAÿ)Û Ìó Üg;/ƒ:œ§äå-SËx ´õ¹°Å =” mx$i†>Ä ðh<»é2Cóчh$š€¶°ƒr$¸¿3eìHÜû;”ƒ²ÐO›¾Eçát~ûíM=šøMšI€¬¯<üVˆZZºIêwÔ¬ù`òšþ,¦§{ßÂ7þFî~‰DfÜ1ôwGŽ0æBB.£VDC œZQ•[Tʾ÷{ÊÑ%³mís¸g|ŽŸÛ‰k±æT’'þÃï°øÅ_û—!TâÐ uFÔ×Ïdƒzm’™X±'fQI›øo¡ Ðßôb—´êÜÁ’¼%1%¶h—äf_Ú‰i%§à†Iòcª·‡nU¹8³b¬¬qv6ÊûŒ™?ÿý­&·²Yt¤Â<À;Ûͺ<Ük¸2sŸ®F]QÇ_Žß¬:¾®’]S¹–RÛ z¯¤3TñP’_Ôà·OSÌ£«WoÔGÔ–Èêv×%Þ¶S¤‚Q§T'*!† ÏŽÉË(L-añ;CýýKví.ª,cÛ|CZ™Ìh¦ù‚½[)8sù“ËhÉe!§FË$ðlÑ)E¸§Yº4wû)Ò|}vêÂMôž OÝ’ÂêU Êlï¾ÐfKÿ’ ÓÅ$°«|ª\ö'Ô&œ2¡ÿÔ“snúË2ÕÇc> ¯HØ•P¹£8 Ã<™yëçNñ™|t »ò”æ²®N—šWMØ&K–ª7d¦²Æ¤š“æ—Ý›Ièpû ²’µQ)ðyßqA`\ÿmæ´c½„SÒxÉt>lúÑ[â&-N †ì67©(*˜rE‘ŸŸ"4`í¿³_^¼ü€÷l`ý6ˆˆx&ø/ AkÌ‚º2”ÖŒÒÊ„-³¹u’0¾-F¢0˸$MÊ­A#¡Ê!C[¬%3$RvBÔÖÕ[´Ïø3"Ÿç°Ä‰+=rvóõ˜8;§ )ÓPAĹ<×3Ob^ Nž ø¬yqåË+ ĺ&.8~ÈÁí$£R!1…è­¤kç3Ò.o4óÂÓW ~àK Q¼ð,Ôe(!B£bâpÜUÊÓâÚ·ç•Àˆ¬^çÕsúòéýAa®c-b² ªtUDL¶ÄÉÍÜEóá¶æpZósóër×Qƒ;½.wøŒxoÔ&ܱ ­b¹ÿ¦'ìBãþˆÁ䮈¾ÿ‰òYc¤Ã^]§kà ¥ÊYr‚ÔYžO„–zÄÃÒ6úŸŒ¼Õ6¡ev« i™Lš¯–Â_Ëv½µ®D¦c/O芈 Š×¨´*¼¸5DŠ9ƒ*ÇÒ~U…2¢Ý5óù­˜?ýc^º¡ÈÖ—ÒÔ°dM6äƒ!99qw¥9õUŸòí—p¶Ó?Mª-x´åÔß`¸[Ô·³3·¼1¸þú?\};þ‡„i-¨Ûg²S4É 2q HaIÔ„Æm]HôŽå ›S7ÇÕüøP¼gX,ÄGÈðQZñ9©cJ›™Wêk8e›Óy; Û‰`ö€åAÎAÛwl&)¹êdøGŒxÖ,ѨËìS“_VZ^æå‘°Y&.–Nº:Y#æ瑘`äÍÝ}!@KLh–Iˆ\¸{’óA·y(üòýëŠr2RH-5ôd+`ˆR{%Ì]²TCü®a’ÕÉ™M_¡Ž,ZÓ뿹̂$7 ¤éÁÞ2ÛÆûhö}¿ûvâV3ÛH»?þG,\°cÝÆP¶”&’¥{ÝñÒFÕNé [¼K#My»ÒÎo=2÷Ä}H€‹3ï‘L| øIez l„õáî>Ë7“êº|Ϋr‡á6éÿoV?»Ÿw–šÙ‚°6ðsB+÷nT“X™GÂVÑ"•`µwm¶º ybRGyé—²³RSnB6©ö®"lÇ;à>žXƒícaË¡Cp0ƒ=NÃiãé´SI%9÷\D}Ð*i:?„*fÚ«A|uËhIA@€¿Â“mhݨÔÇg}“õùL'© *õõ òõ- ªª*-­jƒ«¥[™ ñXñ1¤9Æ'×t Ô)º5†Gd,ÞûyýÑp…y8þ측ïΣ0liÜÄfÆÔ–…¯ôäØþ?/üÙüÐô;ý,UÛ7.÷ÀÝoK7ïRï†|æÂÇ×®_^;—-n•HfÏZ;mÒÜ‹Mçª/ß=Ì¢n3*ÃûÀ2~R ?Oq+BP-AkNËx‰¡(<7B!<Òj -¡ŽÞrØbBÝÃoJ.•ÁCäP¶‡÷{ñ}ÔøýÙIbÏ 2aúÓñ«7(¶lc]¶;Ã,÷øn8²¾°¯ñ\ ëEãè›W†;vû³ÒªòÍA¹òŸ¸í O¹ÜEÒlôE^²±%SwŽ ]Ž26ƒ÷%E=ƒ£p ×WÛ“]KÄNÍÎü-Œ˜¡²¼’–lîýÊ5Èï…àÞ !ZÍuý« ðM뿺År!ž‚œþþb#éCª´_8½J“d£ØT}¦!-•¢‹g'Äÿ‘ ŸßF ÛÖÇ"û½hÌ^Á™–Ñ|ûLRQl뢨0 -„\÷½(·Šdx5ù.’mý^Ùö]ŽŒûQ”Ã׶Kn"¿K>ßÿûdç9ƒ}œBŸ·±ÆjÎQR^á«R±:­VÇß@›“Túù¥‹²,>ôLjbR¢rêLÜqyé–ýµåÌ&%ɘ*ûÓÝQ¹}#2Jà¦uYl–£n“>ŽF¥V«4 -TÈž ;‹'&â`æÒ“vǶÑm€©’Ô)÷?EâØãÈ* ᛿>@ô¼êr{üõc?¢ºÎúóÓ†Yÿêñ@GŠ>Ð@ýͱæZ%¥!%þÞŠ@y`qp…¹ ¬„Eó{ýåØ›sm$øÁ¶úFÙÓ\Ët;ääÿëñ6õÆ|{Ö¬p'(ÿiÂ-îDõçÿ¡!mÙhÜûrÔ^ê¸WˆÒ°Q²wÄËQ÷âw~¤Ûrjiº²] p6{ù¬2¶e®F5¢( …0ò_ ®¡£^e"ÿ‰¢ ¬¨ sXTƒªéöÌzý¶7×ñEÑà+@„ÿiˈ¯Mø il¡ãƒÜ^«ÓB?ÜC6"qëÓ{{/ .b]´*?ˆ`<Ë£ KJòv}´ºqöÜi°Xô繒Ј„èåh<}(5ÚE†KþÔN¼AL´ˆdêV½ärÐ>×WŸ›“’‘ɦû-ÛºI¥Òé@mIó¬[·;i–Ú,·˜åNŒzü†Q¿Óî*5èôjƒ½WŽ i*™Xà8Pöï¶ëþ§ïl<¹YìɃÑýÑW‡¾`ÅÛÓ¡*ãâÔ±Š´È|ógÇv"Ž@û2¿ãúø÷Q#\ùbK(´üœ QZ.9‡ VÒž;6… ¡¶–á£øÁÿŸñ£Xú!ª’àÎh´:E™ ö ò“¦LO¡Q¸+¯ -ÒSó“ "Ý[Õrúµ4°Ô“o)ÿÿ vh¸1’E"R©T©YÜÎW Q¨kzjZ&dñÝŒÜÔ"5 šPZ“Û†®Kàvâm/6ÿ8-Ï–Ãœ—1^ógÀ{0+ÉaßÌýï^åËðWÅ~¨¾š|“4S³$¤É^ \9j•ÏØ+Ê?*Ï“öá#¸ WÒN¢N_¦—A \QËp„™°„y5ú@âPnt²5 ÎòyÔþö€åÝ34KÈüüÄàŸñb P¨ø.‰ "ªG1È@ÂòÈ~x¤‚álhÄFTŽ…™mO•¸ß_=RÚ]a'¾ËÝzõúBÁÛ^_HþËë ý,[à*hñ:Ëàö¹ „ây¸È‚öN%›ÈH®[˜–n’:ÝŽ+¶º©YßzÇd`Faf-¦þmšîø7“lÚL(Œ¡›>øöI6Ž©’DhBùyJX§‰†8ˆa0w"úñÆV†ûƉ֘ª!¿Â–ƒoèvÍ€ø6ê´·Pçßç„U®‘ 6¸Ö¹h=0£q¢ÿ—´ô0,>ØÒG²]DD®<+¢ ‘Á½x"£Ÿ}ÛðQim¢_ÛUnâææ#ßÌ“ÈÜñj'¶£õj¿Î sGèÜɤ7ðz+Õ`0^èÜ:ÛRÔÿª=‘[endstream endobj 124 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2784 >> stream xœVyPwîa˜éqšaÄÑnoÄ#`4›DcP£FO<@9Ĉ¢"§ˆ ÎÌFDQ@@@ä”Si(Ñͱ^åjÉE7(Ũèƒ;H—;„X*»¥Žn±üíÒõ´Gñ3}Ãç± ªJ´ÃP+ÿuâ‰ê²Háæ™a”1N?˜þq_DwŒ¬O¨¬®)i=”PhÈäîª1çs­>Ø‹_KO7ìm@†3lêhtJ¼xShi-åØ)ë!à?Ü1åþ|8À“¤Õlíh”~«ê …oœ°XZÙe¥ÝSAV*ž“‹·]„é4ùWHi¹ì)Ø•}¤÷0 ³Hh@¾1û=wìxwl?w¤Í‚’ô6)|™FOâC4Ä-)a ¬Wý½å©4©tbBÖ.€ÌìÝ|'ÊІ¸(B% q°ü®úѹZ§J ÒÔ:¡³†;1F®c çùGÄÇpØN“¯›ÒÝ)ÐûŠ ‹ö3ìWé»/y E÷§ÿFž'Î. ƒÅÑ¡!©á0BO§íep']Y¬ªtÒ{†•k/H\û4«Ñ°oö‡}5ì#q#Ú© ¶@Z¢É˜’ÁEû¬Hð†ð€nퟺ º¾Ð`Øó‹7ã¶õïiÎ]ÂìZȱ%äã©„& qýa ¾…ÿ8„L6ßSêA”KÅZED:³¬­÷zÍÉ_i¶íOe’e´Ó²]ë¤ãG O“~ßÁ‘_;P^Í/§Ù)(³e+SB{i‰#`ïKÇàtE_Õ*äVÃh/`Ÿ÷!PïH7º:t ïJ7 ëô¬ë«hvaõ"Õ²ª`Xö’¸å4;´ MEÆ*ƒÙ±L·;Ý=D S°~ù©&sœ–$ZÅèœbM¦HƒÄ^Ó°¦E…»ïÊᾆ¥ºÄq°º,©> Yg äØŠ¨üÄà’©Z2lñä!ûCj6ñ‘aúuÉ;—7‡§¦Åã×1u8ãÆç—¥_˜UDZ ¢ú·ÑÚhI22ÌÙ©P¹;÷îÚÍ°Q1í'åZÖqã’°±6yh_IfžÙ˜aÜz†µÚX˜XQQX|€#ácÔ+aÖxŽ=5¾9z¾¹f­äQÑÝ[½&t q!ËÛÛÏ]€í”Õ¨€¹|¿fän|õ 7ö[¸:–3á#%Ûùç<ñØñ ™Wtm~‹žªÛ’H8"¥a˱ÉE˜+ºÑì2ÍúÍÏÿpKG‹‚íwQìR·…Õ……Õ‡µµÕ×·ý.驵‰t›ìËN¼Ø)/c ZjÍÄ[žÅdxu¿U9¾uðÓvðü“›]kÉ€2ng {\ ç¼´±t“)-•[¸°Ý;G+2æ£ÑC¼kJbùãË붣,æ¾$µ¥q{“Ë¥æ0+¢gõ"cö£{:g*‚¬ØCó~ih9™’ºqíí_/¤oW|ÿ<*ºøžâ%§°‚ËXË>Œí°Ï´4{ñ/Pö±â%?¹äÍí(øÕ_Ã>éUOžúµ ó\æÍÅ?ò°¬† °he¸c]—nýýºtïøùºÒø_÷çoBÖM*µ­Çz5ᨦ+8°±Iuù±Èâ@À–›"–á,5tDÜ•P¿Xrõ Üe®{—Tª×ä9“‚ª£–×>»$o‡™«?xdw50w,sÖ¥˜ˆf¨ž1M¦4“1ÍJf§ÔÄ\(âØFêˆRZkÜýt0|hô²‡Vðµ9åå৩£áÕÁaQ~ã:磚cQøñÕ'y)S 1™ úÇËð;«ÇKÔ…²Na”ø>]iÌŠŒ3™’·rä—îÙ ¶±ÕÑ–‡/WÔ{/WÔ5…(ðBiÑû¡§ìzÊ1M´ù+I‹íÿ ¨u…! qÏ7KÉP9Ud«:Ë\D¥÷ÁèýíÖ諒ýOâ8´AùÞ½f3d1yi–ô¤àO’9âI<6 ¤o-±ÞûšÐg³;×’Ç¿y€¾SŽÑ"±¿ï:´ÑÝ™´ç7 À¤§R3ÀX¸™Gq®#3€ŒâïGÆ"ON6™ ƒIÍ5ì.l=\XÄI¥z”¡üÆ8¦æ‰ rpeInžR°Ge/ÎÞvq¤ƒ8؃C¯Z‹ÅlÎÜiÎή;çà*Šú/Œ/“endstream endobj 125 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 208 >> stream xœcd`ab`ddôñ NÌ+64Ð JM/ÍI, JtwÿxøÓ‹µ›‡¹›‡eÇw¡S‚Çù0€cƒ1##KÈ÷5|ÿ™Z¯2,(û~ñÄ÷‡_?ü~ëó¿b¿£¾ßú´òÜ¥î;’ï~3>ú­,÷»õ¯×Ã￱}ø}‘µüÇQï€ß\r¿U¾Ïø®Âöãl€‹<_éÂs¾‡/œ½í×Mn9.–|În®nîͳz€ ·ˆ¦òðtó10"wRàendstream endobj 126 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 807 >> stream xœ•‘oHiÆgÜum³³Xn6l¦2®ûRgÝõ!¡ (Š(Š‚ ,F·šææθ™šîÌ<³c»¶VÛjim˜m¨Y`ëjÂGz•AdAÿ>DqÄqp¼c³`³Õ·ìCï×÷}žßó£){EÓ´s㦭¥¿ïõ,/ZZ\zøÀ†£{—ìÏ\¸ Øc“ÅÙpØà°÷(šó4ÿáì{?P™c_¿iËVŠZB-£–S+¨l+‹²Sé¬=¶µ$‘7•5±’B’t$I{’žl6:;È.%&ÁWZaD_ ç„v&‚„‚¹0=ÊüªêSkTI­[Ɉ>xŽ·4¶ ëîâOyì™6t¶úàÜŒ *ôä×ÏÜÔ”ÕÊÇ%²R™õµ" ãRˆÿƒxƒaM‡î²þÕVÊrU#ï['–¯ëfî“ ç‚=ˆÃE²ÇP(*ŠO°[eEĵp[Ï›²X<Æ›$=F®Û2Ë9[ETóæF¦õª¿Ò|Ÿ¾ÈýfœÄ‚ep™Û?õ· £d âêÕ\áÕj ¬á„â•ËÁJÖ“€îõôéènà–Ü ¶9ƒ(Â_çF¤B ód¶Æ¼K?ѽ§êÛẌP$5æsšjòéáϳ¹¾ÚívJGRÀ <öô—P¡’©Å¡`È"ã!×Õ´¶à=‹ÅÐ)äMÙæ~ÒÖ|“¤,mëHmò¾qÍIf™3®®àÍ©i˜ Óãß—º£cP°<8MQâÈ/ YEò Eò³ Ë Ÿ´¸dw­ä>¸¬9ƒyD™ŠWàºÍ<Ÿ@q¦âî²LÅ®nÒ•¤džmòíûŒ‹Ukà¥]G<K­r5~Íg_á>4!„>ï­Íq’ÓùzoY’cþx}o¾ü> !)awäÔ4@㤓ûŸ‰ŽcT_r²\8¾C©ƒÄš4)”ÿ&þ;Ë›¿ûœðVÿ´Ï½ÿÐŽº`fþ"Ѧ(4Kl?óìÖybÌØ©‘òn]cºsÿ™ÉçÚ·•:ràÈ…cfw“Ô5] k£s(ê#ÌÓÌtendstream endobj 127 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 5042 >> stream xœ­XyxSeº?ih8,‚P# è92 ›¸#ˆˆ²•­–"–Ò….éN›¦M³5I³¼Éi–féÞÐ=iKWhYZ+«”ÁFÁmÔ¹wfî™/™Óûx¿´e@¯zqîmŸþ“ç¤çûÞ÷·½/‡Dp8œi7mKOÝ›¶tɢײ÷¦$Å>œ•Åîý‡Ì “¹0y\ï#³¦£Ó¾zæA"ðóäê´ô5Y¯ì_—#ÊÝ»A³1/vSÜæø}[·%mßž’:í¹Yøè¢Å1‡#¶s‰­Ävâqb1Ÿ'^'"ˆÄKÄB"’XC,"v/‹‰µÄoˆWˆuÄRâUâ5b9±žXAß²g…Û·ÈÍñ…œ®<Ëõ}ŒãÛU –¾@K©22lRd(+­³×ÛjéêÝh ’ípïzö0±ŒRKjŽ†ÈÍ–¤Šce›ñ™•v0»ŒF·™ª¼\uÌd=¤)$:±VB¯bOè5†"Ð ¶‚jg…µÊJu¡f·¥Æì¸úÁXÑTZÛ{õ ›¢D›ö°“¤±´,IW"rOcÂѯZÑ35å;ÎwŒ]FÎË\ŸyøÞriû Ëgç°óæžßô1zñÑô8µ¶“Ñ9s…ai;vFí2nŸçýãõˆë=I·Ÿ=ÚÜ ä±Æ=[h\ ‘ãñ/òpПrýýþøÆb£ŠI0Ø• E!µquô¥­å‘ `cX!›ÃÊÙgþ>Q(qPòQüT‘F *½“}¶á Ÿ^~Í9W‡–^GAôЗ_öýÈÛŸ\‘Y$(—ƒ1V]‹}݃Žö$ì]®ÏŠ:ù;¶+:!)’F9³î£Ü¨Ói–7¥JQéâ ‚B µ¹ÈÚ€ÁÔH{¡U‡Ÿ´`09• Ý »ÅZ_\NDó¬ùu1 À—™„æ£4;•}•/ÏŠ^»È­Ê›6ÆȘlô´ÕÖzîÚ)ôÚ· ÷f°“Ò6àúqê=„]„¾¸V†¿à×'õMå¬w$¿’™#¡'⪒ÿE´4[›l&ê"*32½ˆÿ ÌÐÕÒD…NE¤¬D\_é)íÄE 2Hwăú<œsþå\„/“­eê5 Áð¼|%äɬP=ªB•¶€fg·¨’4ªu˜‹ Ì0]= tÑ}pD× d‰—ª$´’÷Ø\Å`*.£Ï#sðǼ‹%ùZ >°^mЂŽÄ_.Æ­2S§P†Ì‡t2ƒ.¯ˆÊ{Y’…AñïrÚZ¬Æ\ë ¼¿»S^Ù¯ë²iƒ$8ðJÅ•¦$\Ÿa¤¿u-:ŽÑ¾ø4šþ×÷(ZʇO_¨Œ)I·$ØàY[3t½¡]ç „ZU(I…%¿¶¢Þy¨/¦ó5vBÌ“¿»(mÔP‡•½J'…ÏÏÍÙjî—Pýf8ŒÛP%s‰²Óó£6&¼‡žè@Súð»¹Á¥˜ HêñýzŒ%ÈÅ·iÍ…)I:RÑÅD©’A®Âe´ç‚ ƒËP£³@ ZЫÒs–é©éÑq;äñ@.|ö$¬EËÿˆ¸?Ç„³H;J;ÁÏÑî©[³Ñœ/¯ôµ7Ñ%ûÝ °‚ÉÂ8Ž¢í¡–&ûa ]¬y¸†GdNàA¹Ög¸È7¦sr0䩨¼7bWm2êÊ­Pnm¤ŽßäU8Æzþ<¯Í/.ndM¾Y™¥auŒc—¯äåÐRåôu޶ˠÕJ@*ˆl‰øþQ© õÜ‘ªßœ-;Íõ Þy·Á£¡¤ÛÅ“€Ì„†ÒÑw¿ºMŒFàP•å¦ªÓTzê%¶·(ô…28=-uQ…‡[ζ|Q7DÛjÌ¥PEOöD/NdçkFùd*-¦lž†?épè2÷+3¤qtæÚÌÕA®L;y¢µ¹¹–ª ?¤©‚v¨©+óTv8Ï`LñEvÉÙÒÓhÂç\ŸÒ7™ß&÷¤egegˬj‹šªÍd„XÓw³ÅìøpÅñ–Aï§ ïSærKÙ}%eenì&—\H{ý¶ýW} P®Ì;…ZzÖuúæY´æs®ÓO¼b…sòcr"„1o)éî)1Ö:Ó=è··½ #'P½4u®Þ6V¬N7ˆp_)ϼ¾~ï:Yÿ{ÏG”µÊ|¿çdLÈ€$[Rý~oz¯®¼Ðæjî/Ûוñ6œžîæ÷š‡:Ñb8AÞkOâúÜ?ßð!Tw¶„ê¤"%>$,ÉrÙ‰ìBvÞʾµW®9ÖE;vµ‹Ú¾ß2v˜¯nzn»Uo7÷  •=tÝÙ¾ãÝØFë"ö‚A­×`p‰O°0ú9Uìàú#«øÝ…T‚Qn•{Øèo¡h#Zt jè­w,›Ñn„ Òª5«EY:Ȧ!žÁçÖÈ@¬(1˜éRƒ³“ãF Ô³üC4ä朸ŽcG*¸Û I•ñTdÜ^ s3œµŽC¶Vº=Z:Ðpꨃri¬âq‘ïøKÿVgÚŽä]b%•sf—- ÈÇÃÙÙ#Èc¹™nød ³ ȦªìØýò]…ûèì%’õ¢çÃ@ ƒý_Úl+©ƒ2²^d‘ee‰’ãz²ûŽ¶t4WPÕÛŽ)êü¦ͬ¦ï°íëá ño¡ öŒø$‘0‰ºŒZ°Û%F¥S :j¾JnP@,PØ¡ô¨I­Ôé¤@ͦ :e Ä žîYwCÐ8ÝkëYÉ5W—´5!m­SYuSWGkß³ö ýOßAïm®2ðØÔäXM —E³$»Èçx)ÀX-ŒÝh¡Ñ#¾î’6‹ý °Š©´Q»uð&{™ØûÁD@Y}«xn0- a(îé Áîu£U MÿëiÀª:#äß}Ëuü¿ø(£ÅôCí<¢N‹ Û‚ÿ«höyj].*ž}võžH ßv˜Áh²iÙÙådÄ‘G…˜åqšíÝI§ný雿Övu\ëMª{or}‰·øf•C¥5”*jõ¢eÚ| ózO4|[”>xñx[/8 W_©hŒ=‰Cr ¡ÖÝq,º}Ãx;ÿí×>C}ü·²€M+}Ž0Àbêýi1-³ÔÒè1ßÐ}c+++ðd4ìÅ—¾/™}UÄW¥l~þÇdÖ •év‰= Ä 3hõòÎð7*·®ÿ+ÿ²Ñ蔈NBHbR€,UÓz@oËŦV¨WëUlÐð†P6ÌW¡)7q`e§ý³'Ö“ Ðé”4:Ü Ý±Oöæ/ê ßç EÂá¯ÍF})pÎ4š«Ð¯|gCË/œfšŒ$ã4VŒ6ÞǨå]BE?ŽÚõŠ÷:;ì½Öº“× ï2G«®yá"Xɾ}æ°Íc×.=ºòÏ£8F6þlöYH¦D¼Cè™o;]2’]^æ 0ºêºOìA‹>¬qs²n sX«wúCø‡bÄ,ÈbNRS"6(øµ@-rq#Ëès¼—†'È7)c4"*I‘J3Š²fsi-T“î<»$++71ê¨ýV7ÚwЊU“ þˆWa#Á Ì$rܸÑ'ÜhÀ3Ý—‡8­_Ì©ð'|É·ê-2™¡H®£ò·§ 1kSu Þz¦–©§™æÃP§{vV¢9‡>…+äµ/±Ó(¶â'°’˜¤Âð˜õOt¶4tçO¡ã"*F¯g@²Fª+”n§»µR“!Ý«Ï Ïßh¾m£úöñA£]žš™½Èy<ü-k³Íd5 ¬&/Tyá/°hŒj# º}{:zèô‘S3Bþ€n|¿CiO⩤ƆzW‹«¾€^´7™ðE§âëö-JbÝ5Ì’–ú¯F ³({¿"M-¦SŸÙ7_¯Å$ÄÕÆ |Ý‚ž(¦B~ÕàKä׸S…ÂaN¹¨Éëõx©Ñ TŽÇ¿¤‘ƒÞB{0ÛP!šÔÝ™Þ,œYØ(6§”™’Êò½ÐM~ô‡Ïo~ݸnu¦A­Í¡ Òà»3㊽gf,2ð̵=îÝ—¹XB§²ü7>Âýú`mѹ5eÚcÒЛ®"Ï!uä@¹ä…Ç—­ZuðÖsãÀ9"ØQ¹>P’6Ïö:85f­Åj4Ùm”ÃYïµ»ÚÃ/ ‰¹ËE3Ñô±x|,ž˜×ø'qýå¾T~3Zg,3>[`ž¤†í¼\l¾š¼-ìºPlZl/ '0ÅÅÀ0”Éd4Úë Ù5ˆd+ïhÕj}!ÎðìÌáÖÂÄBår¬-£“§Ìý'è§मdOQíPB]À“@ŠIéLQ1”bùÇXB3}m¡XØŒ6STyë€t“ÄÊ-´^1r Y ±&¦’¡F ÷f¾IÔÕ»–Š ,XòOØ2Ö*dù³—,2bGëŸÜf¯ÙMÿÍ7ï—ÍO?¬B(ìäë¾F!¸Æ£ êO¾ Q»ŒÚÕwÄw FµŸßÃù÷-cp.Ò@‘ŽRgå¯ïMÁ¿ØiÃØÏ‹r¡@ðúÁ}G;ªê\TE[é`°Ås—ž›óü#ûSÿ}îOol­Þ½6rÏžTJu)¢* Â`WrÒ›ÿ¯»Ôc`rÖ4?4x È>ØY¡NÓÒëY×/ùÒÏ,`¿®"|+D(ü69PðeÌõ÷Oâ×õDÇf%¦ (k**KìvJÿòká2œ×@Kêµµ =ˆ&¡ Úðð/xzTºà6JÇÂŒ8éˆ3#ä&Ê:ÏwKjÒ…É©É™•ùõ­ž–fêèCþIu:²%)E˜’]žÛØêñzè±SS·Qx.ÅŽž]ñEñ½ÙvQ~^¡RI9Ît¼÷ÎI—Óh„b’ÑYÕbœ¸'±D潇ºêÚš§þO ÜH¶¹2²€zìzÓHºùêÌÀÍ»ëöŸØ |€ÞÂãŒÃÔ¡†|ŠUñ*¿ªþ7×y4pDW—µ§bǦSwceÇUv"d±äê8vv•·(xýÝõÔ9Þ+¬?™}\){=™ «üARÚ}XÜöÅa4ýº‘:ƒÞ F»ïÙiàß^Sç)£î¬ŠFsÛªQ#.eá·Hë…wZZ]î(6S¿‹Ü°;V~·¥•h*zM gÙ{‹³èZµ{zÖ _ЙÂ3Bf>ßÏ×Íñ]4Y°²2ü”„*à‰À`Ј CC®* <°êâ*²B&ØçAü¸}‰ü^Mֲߥ°ªRáQP9FyÅkÒ+ný¼=†æ4PçЕ`”¨IpÈSD .Ò™ÿ£,¿FÝ|6—ç<_öqYweÿ@iz¡;v¨"S-ËÏ ÄËê —ÝLy¸Šñgvšó ²p±¿Á7Y,nŒ§«`#°UèA+ÓkŠÄ=· *)´ƒW…Ý„q’wX¨?‡û£l˜’ãö­q ý¦r7Ï=ñô$jâ¸é“'Àä‰0y’›Áž‰;+Š-“'Ãäéñßa|ÆEendstream endobj 128 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 3425 >> stream xœµWipgšn!¬4`ÉD‰”£›@HH†IØ G¨p †€1ƶñ!cY—…u·Zzuß–-Ë’|`|06C æN`™ÉR!d²3;ɲŸœveö&³Ù­­ý·¥*ýª¾ïé÷}®æãÇ<ïéµëÖeIóWK³Š ²çÏ›³1wOEQÖ¾ä_ÏçaFô)ʇÔñ}ÏMÉ{-{¥Mùz*‘Âã &¥M}2«H’Ÿµ'«¸8KR É/PåJ³‚x¦¤tE¹4K±V•“›—¾§`oÑâEo-™”&¦¦Äz"x™ØDl&–Ûˆ9Ävâ=b±’˜O¬"Ök‰uÄóD1…˜Ê3óXž…gåñ,KŒ'Nòžâ};®hÜm¾qü’ñ×S‚e‚Ãmìš0gbÚDÙij“¦Lš7©`Ò©š4aÚÀä*tpòßÇm]Lhc‰91úa8|‘ŸøÍúõÀê€U3”|eáû©2úã¾_Œ®üƒ!òÊ®Þåó?üTE1ŸìnË€ Pä蔕ûÓÁLê‚~›-æ¦j?‹t TÊXmÕô®’U›¤Àˆ•Õúp0âz(›=ØïnŒ}%rÇÜ1W÷ þLç¦ÏºòÞ×HŒžEz‰ZÖ#„ùôÜ5ù6d¹+³íÖñ&D´LŸ¸9>ä™Öíëi<ÃdÚP:ÖÁ)JH…Qô®£™} ­Èu ×ú ®ë(Í`a”4'mÒåX ‹A¬Ò‚BDô ›â B×äšµY@ €O±—8X'„Àë ŸGvÑ·‚ßy+KŒ 1ÓÆj n³ÛŽˆ‹:Š°ƒC –€Nge*Í”l‰Tù&ó‘ÇwÈæ< b$ )ñÂ¥R0³ÚR`IÆaôlî:{rX×ñ°ï Y×ûñ®ï ñÓÐ\!t*5AÉW¦o7Û}dKù;'Œ9aªÔ*¯€ r¿O‹5Ôöôí:ü6'Ê›™¹ä†ºÅDÔÔÂ&²LºKÝ¿¥T7ÓØ ÈxePVV,Û¹q(û6z³¥õ%ï/x.¹,qú@ÎCW’$3€Yoeµ µkÆ–ò eºÐÁ»ÇYKß@)÷Q?D:PÒ hº+ n²VãW±¥Ö|=•Ã-H™“\†Bã…(}G°œë2«@InîÎ=õ·¡1†Œ›|ÄÞÏø æ'f[ÍûYJµF™¾H ÛÙ½£tì«N4ÍsÏÚ)NÞS®®¨`)eWIóN ¹ ÜTîeî¥9§Wߊžp~6L{³À!ˆÇkÚk;CðÖ¸ièá6n+£‹Z%ÎÜ´»²ÈmûO÷œhÇÛ9F·íëêòRõ¯M&‹ÉÊ$ٶȌ!†î¢¬»¡¯åºrŸ0>Bª·˜ªpÚÊò½@æT¶w`}`¤èywSüÞU» ê«Jù>('+ŠæX{¤÷dzuÁ†ü-R µïòf 36rÂ}IMzvŸîxp¹±ȺCú EªUyÜ4ºr]~V&˜0Ce¡FW¬/±¹Â«.ÞW¶7ã„üèåΫnÌëÌò»!$lLoq`™ŒðÚx#O#:Y^Ùi¤ æfrî] çöcšl:k/8Àg]"_§#pÈV/ÔµÀÐÜ,–;RŒš1eA=XjéˆÅg…*0[YVÃ=3Ú!“©Ó_„Nd ÀîÚ/P‘ÈÀç‰yv5•Ð^ñÆP0æ½ÂK¬Ä“t™]½Ådd)éšß( AJ·ÌSR;eX„Jг§Î´4v¶œ?ÕÙùÍ×±p’~-€‘µèªx»¬²ÊAV×*âªh!ïd¼.c&ŸÏîrÛéºcgl^ ºÎ7ôªÐ{v-\®¨œ¿P´rUþF0>ôC¯ÝpSñC­Íí¿¾±¤V©lò/gÐ/š“%ÕcdEyýß| z1ñ»€@•z¶Þ¢¢ VU¤Æá»QG±òõœnŒ½âÿ7öò®ÖcÌHC‹b¼c×PíA~bÙÝ&‰±X &jñ,Ž —è¿lÚÚÂçèAA Ü°Ÿ¨¿Úê: ÕäÑÜÃ+8>÷Ú«Üò™gÿ+šñåƒ µ9„3¸_Ánj· Íþ.ÜdsIAòÆû‚ËŠÕÝIHÚÐÌ»‘oðúkæøÈT᱌øÊYÅ”IÆêʹ'ÈEÒ’1«èË‚wFi嫪y€ØŒÍ\9æðuB˜Œ+ƒŠ²’ŠÜGËŸî=Û¡Ú/ÄQšÍ3Œ®ŠnÿdC*úŸ3VKàŒ³¾ú3wÐWW®'Þv2Ó¬Ë5)hêšZbÝÔ䑧p‚t7¡ XL¢Exsõ îiŠ»ùšh(bµé‹›íÿÂñÄÈ/­1ˆYêAì azPä•BÄmwÙÜôyäHAKh:¢¿Gãé×’ ÷FΞm;×2ñB_|Š}‡ìŽ# þ³àƒ’Éþs"9Àà¿ÜŽ%¦ÇxׯñÑè*!â'ÒmøTð<ô>ĸnj½/¿)Ÿ#Àì™Æ½8ë\úµ³ýý?m³r"³¾`Ö V@¡­Ô×ê 4A-Y£­“TìUfïî’ÿ=~íÖp˜jI<%Üνo*“î«PˆeÊ"%v¤mꓽ-hbóÇtóñ#½y¹ú-†Á¬2'!n52ÌG]#)Âèþ©DR&QT«â­ñVÊ7*ûYUQ®-üíÖGUÅ]?G÷ü{°ìþf±7ꪆ:²oo׶9¹ÜLýX=±×¸¨æû½­Ø ½µ°Wf”™u´¡l'GVîÒ•U‚ŒÜÑ‘?€ÛÆL_2KÈp’êÃ_ ¹ræk~¢ê¿iT¾Lº^Qè¬uÆ5´³3Ä—Ö¶¼h‹´·Ç9nl\vkЂ}Ñd·‚ÕnÙÎês@óÐÃ1…zZ¥w–f-§ rs²sÕß'Þ%µ.]f°”a­k­8ê~¦unæèuóC»K£Œ/öÝ”Ëׇֹ;Ø?TÂj0âj ³h,É•Þ›}²µ¹¦+F5 ç«YøùF„øÑŒÿÃxé˜ÅÐ^Ý`s¹êþËx~FAjýŒMoH‚yb”eµ#TŠ7Íï?Øí¬¥"ÝÁá‡ñ'œ#þ˜@ü‘5r!Œ.{4†l¢þ º=.ˆzŸ–µ€±Šý˜«Ö24bÐx™“À?ˆBF܇€ ø|$[„Ã÷Ž m~ÀC«c|”i^ÞדS(ßW*‰– †œ>?å°Ûmøv<ôýïæ¯/,¤µÚ‡ɈÃ!ðû›h5v<àÝ~ÀG›…-å %%åå%% å-- -ÔäË)e?¨å¼DúH‰0 ÒhdM,ÅýõÇuL®v ÖúôÃSë¦Ð7?,u…À…ÄÜÑôþ£©ò·‡…“ç‹#Iùa.!²n5Ôc²éûhb=šÄjõk1³•™ýöŽtòüchþëÇßåžçDÜ î…ׇßþÛ…kñsŸS¡-‹ú€l;]Cs+{„ –.Õâ­/î»ø¨áö_?UwG pO/Ƀ vU2oRn‹,ñ‡k<ôc#?Ñ›øµÐ¯`M8ø¨fg¿œý’µÍúyηå粯À>ðø{Üì"ü´ÓÕƒC<[7Ï×ÜòÅ¿eTF9]±¬˜#¡ŒÔºŒÞ7Ö â_ú‡œmö=ä µÿå"z¥÷ O0˼% ü²Ä“gxèîq~âbâ5aƒ wGP¹¹#?§,@ôÚ^7uüæˆ9$ØË¥mæÒ²æÔx‹FRQcµzt©êc`ø•‰PŠ ›¥ß«@ o?3` ã7‘úHÔ vS5]r .Áôœ œ$‘@ê„ŽäXÞ¿Apkeh¯<±U†šä¼ã—Ô%~â* á‹-÷8Úÿ ’‹ÕX~ÎʪÌ~©á08aÅÀ='†ÙW£ÉFé‘f‡.“L籺\v›ÃAÙíîGu7zE„Þp¡™èY@Ïœ-¾8:w½cù!ø«Pêm4 ½"ÑŽ7ñ ¼îW5ß%æŠ>7eÀ‚¤Z?Ò&]|D«ŽÝÂ…úãFß ?!\(„nE½Á«ªS¸Ó£‹š+]åõYÝ0„Kš‹&£åÿv*¢Œ'gØxÚ³íÙZ èÊh&hqA=YíŠåe\F%d°*‡Ò«¦¦oá~É­n p/ü©øZy«Ö-ºzãáý°ƒ”(ròÊ$ÁˆŒ2º­63 c6êŽäžï¿8D_Y(4°:&dØ|´ž°'‚_{‚ÓaÈɱÄò@ „Šc‚ØÄáIÔÄñ›JS'@êDH³ÙŸ½¦Ú¶¥¦BêñŸm¥Qendstream endobj 129 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 6405 >> stream xœYXWמ¥ÌŽˆq¤hfk¢ÆJˆPQP,ˆ lô&K[ÊR—zé½÷TìX±,–d­‰IL£i¿/ùϘKžç¿»”%ÊóÏî3wîÜ{Ï9ïyÏ{¥§C‰D¢ ëííüÞÿ¶ƒ›Gˆï^©zpJ2½²ÓG†ºÈPïä”7ŒŒàÚ˜?î³ñêûãC‚Ý‚¼ü=|Ýæ½KQÔ:+ë€+®š¸Zjb¶W¶o}ø~ûˆÜ6ºoòðtðÚâè³Õ×ïݨ ß[´x‰ùÔ÷§YLŸ±tÙ›oYÎvž3w÷Û.ó\ßÙ3Ÿ¢¦R©iÔ&Ê‚šNm¦fˆ’)j&µ…šE9R[©mÔlj;µƒ²¦vR+©·)'j5r¦VSïP6Ô|j õ.µ–²¥RvÔ{Ô"j=µ˜²§6PFÔnŠ¥&R5‰2¦L(SJ—2£ô¨É”>ES¯Q<5Š2 Þ FSK)Cj µœK­ ÆQ–ÔxÊŠš@­'#Ó£)A$Ò™­S¦k¦+Õ=§7W¯C²~:=™§/W0K˜ £œG]40285zìè^ù†Ícø11c¾»flÓ¸êñ&ã{&LŸð‘Ñ[F§Ø)잉ÌDç‰Ñç2¸þI“^Û_3aM2LW›Æ˜Í7»5yÒä“«'?›â=å÷×Ì_‹{íôkÀOáWóî<âÏò‚d%´jò¿Já0Q#lü6ê ‰-*N*ˆÉNÌ AQªLâËÓ}‘?ŠDñnxLµ‰£ÄÔØÄÄ8Íø5 rþ%]Q‡ZZǤö¿ú°˜®¦ï†|ýêP…ä%]Þ€Z$xìà° } >Ò×ì ½JG¥ÑO*pT³'…ü®UŠ"yWˆ¢Ùq|éZ/™ŒgUm¨t?oMGJÉr ¨Dr÷ºj¯`!]BVW?)q…Õ4ÛüâþásJ6ò8ì€X3¯Q=ïmÍ<ÉÀΡJpQ}§‚(•³fóPø€C*盕7jNœG½Ì½ °.Ciy òó­Ge’Æ~ùÁû¦Ñl0è_ë{(yº¸}>¶³ùéàhöÓ¯kì½%Õøçt`Ó{UŠ.« ^¥+x€/æ=ÇzXoÞ›xf˜ : óÃ`ÄÛäróì-­¬ì<ûîæÍ;woØÍç5r¥däñ áS®5ˆxm%%­Au’©8V~ÎÌãªMëjPk‹EIo×;ªix_ÕÇë¤âá1M—Ö/’•$RXGÃ,¸ª_­SŸ8V)ä)EGUp•l)ƒ¥\{ŠFþ©¼â-‹ }ˆ™¿è7˜ o}û[ßµK»-J$™‘-ˆé@ÕUˆËP½_xRœ"‰OMF©ÑRï¦ÝU;ƒ9b¶¶Ãë€|Ã$`¾é{¢ÞK•ðŽ>È ¼N¢d"D©5nÁÏo8»„ûzñìóæÔ·?a£¿é±±îÚ{<¾ 1 úé`%6“欶[½Ìóñþž˜5ºzåÂõûW¬ßÓ:ø‘ *ˆ½áp‘ƒ÷ÁllÊã}C«—Jjúå!Ú+²<?†×aYÚŒÇøÌä?Ҡ߃M1£6 ^†Âé0#ð{¼â–1»® ¹ÔšðÊ`Ä$ÑÁi©Á ›ÖçÛe®KJv?‚˜¦ŒŽjI˜}=ãBæ¥ì éyé(Ѻè¾&.µäœ‡°ãœ„‹t%ªñòDnüÁæ} ÄÓz3æbÿ~6è||ª³¶Z‚}œFÄÿƒXãÂ$ÎÁéý÷­ìn?yz[õùƒ“Ëm<!JpÕ¤«±ê¤j‰ÇïBZ×'Ø*4Œ·ÁUÆâ}(²ãª©äŸ Þ‹ÜÇccp¥Ù.HÝFËPÈ!5.ˆ×[ ¼øþQt”:ÇÔ^lé—ûi}*HhV§=7¿M2‚/àmèªÐ×Æì|!RÍUÅ3ß±.|½#HÌ~ªYëhÑþîµÐ^A ]ªFD I ¬«NÖéß_ýÆðéAåaõˆ©©*kÜÌ[ý'z©‚)Ä\]!ZHä†éÕ¨bò=º¬µJþL™¤Îøó˜ä@ÀÃa-ê—cjÄõaÍ<õJå¡‚RT;ÁN]!E˜>tx”eM4áXô›´€ 3"ƒ=ÒBƒ?+òªBÕÈ´Õ¢ÂvÃ÷&-Ô›ü œSŠÊÀù{pÖ²…\K 籘"ÛÔ¢JI7½ŸÓO£“¢OÅt…_O)ôDq±!)Šý˜OcÒèípN¿{ 8#™dèñj²É5Ü—œu™E™ùÊúÇé%™5L:½½ÊJ(Š¨@E¨e–eÕ\ƒ>“–êWj¢wGitV‘„dB‰©1{ã²3xðßÙúž¾g²ö«Ž¬+mÊïLçQ^zzUFIz1ÊGÌ'ç}WIð깕FìAáÀ ÈÂRd >dÇÖød‰,ÏF~ÃÀ9ººu½îg< ž3 “°xì/3“ÓOêùU0•Ã•tɽ«—n#Ò[Hó§3âºG$jžp…ƒc¡MØÛ‡ÄÇñ±êƒ`ëkáo“Ï!{´*vkì–ÀÐh!’VÇœ9‡¾E—P/ú¸ðTñÕÖ¢Gèêˆ/u,ÚEN¶‚L ±^õÓ·º‚­p‘»öŠü`ùî÷øm³´õùÜ;sD­«ÓÖęРcGdóØÓôÃP Ÿœ £ª¶¬iP®WBŠ†ëR‰)Á‚%÷Ìê ó8øŸ”pÚ=ü`=bÀÜ{òŒPݶ=6sø7 å7úÇã6Û4¤~ ¬._º+®ù]3j¾"S9¨`­*ðJ²jócv<%ä&\­¬uk¬Sš×nž5  #=+wO~{•åâ=åÞ¥2 +¢b#ãCüÌg‰4?†°Îx+´&Ölѯ`"Lüµ÷kžµzu†ŸÝÑ»·æ]Ĭ¦P4JȈB‰(¦„a§ÆÆ–¤Õ 3”•Q’U™z8¸1OïÝí“° ,QK|sDSuQ]VqzÎÁZEbÊk‹š%x-Öå\]·oÝ{úÏÞ̾|âÄù‹Çvmã˜sµÜ3k–åñùmmU|}Y>º‡˜>ÐG‹Óúã¡"âHû÷ 2lø›Z"ÿ—ùÿÓkįѷ*°UíUU‘*ÿƒPùŒk#]Ñ~~i|Bª{D:uá:Ê‹¯åcšƒ«å… ûë­ÎJe—Ù7+a¯™ $ ‡¯þÜlz?$¢±µ0ìï5¡(d¯²C~•>å~M‘‡s½îÖaÒ–À8'—Íóù•à}—fûžžØä<Ì|÷_× krJR¸kÿÔ!‰§Ž@¶>îÅcF ðÌ€ªcçã©B ×RPÒÔTS£·&IÎß´SVDåvÓ˜õ|Á‚C7<ŽÅï;z0wY…E…ÉÞ"·tš9×}放í›Ãg†&V uÀ&2=)Â/ß×±µÈ…P¢®åÒÅkOÙ~$ñA}¶´)ñË°÷̶ïÙ´4À)«q?¿·1ùXZEZyZ…Ï bÇ&É^“SÒ–ÏõSFÞ ¹û¸O«p?R=%¿ºBÒˆveòÝ[kéþ˜öË·hÿ¬Fô-D›ü¹9 ’Ñ„H,ÀyKÏ"t´/ß‚m0Äú#´ô¼jƒÆ‹ñ\}øuà8vZ:îî—;èÍF4ON_П߇Ñø·HÔ KpB7TK,-'=t‹FÏs#ØO¿n»}û6»óÿÃÃ÷-bòhk‹ædšõœÆã¾}çÅ‹oŸÂ8ž·ˆÿ¦_ðhT>“†j©kÚìšD:nÄõÿ)ˤc½Ð£ÕÆl·P¬Q<$©ô¿}Ñø¨CÞÈùɃBö‹–Ô0>Ùgà ÕèC î{„&êã/“E$°FÌv÷uîª-‰°ã±\,Êæšô/Sm«„±a"H"æn4w¾PN«A+KŒ‰IâÝo•¥F¦…¦¢FZ‘TZÙ•søßo1_¬Íë¬aÓ!ì¶.œõà^­¡OOäÃÿ±Bƒ<;:PGÑ`UO!™ÕR•?IÝÁ·‹k.²ÇÓìø«ç~|pü(Ã>»ÞsêÆçf`8ó‹ –¾¿Ø½)¶¼º¶¼©(©8>—/=uºõb}º{áj§Í¶Žˆ7Ä'$&!¹©úÝÏfÃSše†tn¬2n€“ÒèDßƾâ>0Pí'Gð‚ÁšCwv]µméù°é2ºÈÜ·þ‹±ájgïzy•zÃ’Ä‚”L¾µõŽº“ùø¬‡‹_”çÁ‰O 4Õ#Õ!9 !F gþÍÌ1J)¼F‚p¿§—èœpˆÃ2ø•nWäyñtJJ‹Ã2ü»I|4JEaŒw¾¢•‡lLÙ ×µÚ<²êáà›ëVKiÂKý´*a‘RôXi$ê¾àÀý²üglàéªÙǃ(F4ö5´·"ÞG‚+Åá(¸­"+» ol몸B|~ÒÚîƒU—¬Ë»@LÌË%&6—…FùÅ0ÿj5èÁ„çO@w€LA§ôz‰Ð6ºpgÕgüÙvâ÷Ó‚lå€^؇u¶oØç—Àß?zŒ¡²Øì$ò“ˆÂ™ Š°†úªò–n‹³±ùƒ]pèY?çÙ' úù+0$òa‘­ÃJ»ÝÊ0>®.£•0½×Î~òÅ…µVêý B…+JÑ ÕeJÔ‘øK:±,% Æ …È${Y²²‰‡r[áõ^ø Â:Œyw”—6óÙÐ oƒµòjUEFÙaOJØMð¤rT¿ŒS¿Ðž;€¦vW­ª?o<Ù.3?Ä£±á’¥§v~ȳw,C×m²4›ýl!L£§âÍá(ç`ïjͳíÖö'{Î÷œùìáeçí’|„³±Ýbγæ¶=*å•ëß=½¼~ƒ&×¾€Ó"A"Üà2O{åE#òÍt-Æ®&éQ™¡M¨eW¤—3ØöüûŒCÞï…NÔ=\uǘý•ç&‰XW5ëÎ4'n§/óçË»Nòqxü²7ç xä‘Z–•ƒÊ™ºðª@iX„ŸOÅ*¢­LÆ'€¿ìSÎq«ƒ¹Å¶î{§çîñ¦à0’–LÛ|Ù*3²su(,¹ 3oÃâ0©@N\‡'Šámé ˜©†."¬¡¸Ñ% Îî *ˆB¦¾(Ù?-& 1™þ·£ËéB<ž¨HòŽgê;iŽÐ‘xJBˆ /‰¨nÍl.ÊàË`¬þþaüÍ$Øl9õRÓ5Sç-±Î&ˆ`LÐ…‡‚×é×àã&õõuo l;\ßÚÊã«z#O^¹:JÝP·°+8ÔðÏhdà€¸=ù¬¼lG\BR Šf‚ËC«ëŠ:?u¼‹ øNðEÒHÞMŒu¢×­@V((S°Ô—ÁQb—œ}5Qçr² òP-ÓTÛüÊr`bywµzhmAõeüa1Œ­<÷ ºÍàhØÄ9lûCgÎí-``y¿1‡v¸ìZË€¿øVôq´C ó^˜Ú )½0­WÔAHê75Q›p™{x ÇÙÉm³å²#[Ît¾ò€Ùs®"ª<,H!#Å7ü±:9.5 )Lee‘•u¹…Y<4¾Z“U‘rMÏ÷ÿÆÝw¿ºs§û&+«ÎMgÏv^½Ïã>!s•ÄÄÈšNtU´WøbjïW$£'NT6UtU{SðüŽC•Ñy±¹ø(Øšù(Ì-ÎC•¦µ²¢Èø”´x9áýñ‰Ñ HfŠÈÌ|ƒÝLJâ3Ó——UÕjÒiûíG·EB„`Äu¸“Ζh¹;AM;A üNµ«a0W¯Ã›ÀÿNÇx“{êÂÿœ.é$÷ÔKX‚±ÝÊ¡REVxÿÕn0E ‡^ ˜}WV˜›Eºê¼¤ª@¼›à|<úÔ»;ù Ö¶Ô!¦!»*O³Ì‡*]ø®rFï~âyvÛ=Ëž ÄHâ Ù)0Ç¢R¼ˆèåYîX‚'Ï" AQLBNX}3ì!¹—?ðºõœZȇèDÏw=°šT—àϹ¦‘‚ââxO·X/"H©Ù@ÁTxë——ÿi:·¡V’’¡–%Ìv‹°>}Ûâ~÷ÇÀê&‚H¼ OÁã±1éoÖÀXl ¯?ùêr³d „p.{ví½öð«S—Ž<±ÙB}¿¥+ìo•Ç䧦KË×´–uÕ¤(·8U2Y¨y?ǯÌhH¿…šMóQ»·7òŽ÷O·Íä1u]žŸŠÈ4,:ú-)Âzèh‚­p”ÃK>SdÆ#EŠ)^²Ô3¢nû¡RS˜sæØuDÕ÷,7ÕÚ æ¾Þ¿RŸº}ÿ@½6ù÷íÜ_ÍÒFˆ"*:‘Ôä?l‘i%˜†—FTÕä–çððå+›Ü²t„òÔû Ì ¬SêÂO¯^ã*"JäAoØ`£åî]í uaµ~ Eâ“Q~NeæÝÏNIò² ²Q™öÅËY!ñ÷W¿xÙ0Œ±Ö›¥ùg䆗Øt@ï˜oSÈá7í°Á²ev`oÂLÕóû÷n¿…gñcc …•…°¬0«V¨FózŽ†£¡2}¸,']ý“]••chˆ (ê¥ÐYÃendstream endobj 130 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1255 >> stream xœU“klRÇï--ÞY|.ÝdÑ{§5qî‘ùaÉ6?ͺ8g¬UlžT\)¶6¥PJ¡-PZè…Þ.P €­L[,¨Ðg¬Öw6ëÍâ²ømfÎeÙïÝ®‹»,Ë’}>'çÿ;ÿó?(RX€ (úÆþòr‰êÔ—*IKÓWŸ| ’Ê:Z$Ê|EF†ùc_x (œÞX„¬²îÑšûkóE^[‚ +ZÛUÍi!‚T •HR†T#ûQÁ¸ÑH!r݇^/òJyºè‰Õ¯ L“ˆ1ÉI”yý;×ÃÐ¥%¾~‡É`5-xû§’)`Ýý¾DÂ÷¡Ì½®cß‹'wï×H[qÓâññ£ ¥ª»¥½Î(Àú<¤7`sŽypj>r+ ؘ[Ù¡Ðô7êì»dY ¤PíDBåÁnoÊKü´Áòe¡à5°%&&æg§–›Œ©ë*%,_SCè›Á zL4+Ï=¿L¿ÀW¿BŸæø§žÐ[e’(½ñù˜þ°–·G=µC Èb‘ð½_2{!\Eªµ Ä´”>:»o´œ}KòþQ#ÈÒr<¡ [ŒL7Œ …¦Y®il¯ì†vø©¼tÅî¹ v®Ícè>i¨»ÃëÆçÜ‚`7ù­›°«ËL=ÆNèÃÔaãpÆ—y×ho½‚¯Þ¡Ý»8°~Y@âëODÏxí䡞陃ÇÜœlè!F¯âç½òy)î)òTê³Ûç÷Óm1~råƒb|ea¥\ðV‚ xÌn·Ù)ۈ˰  X suöendstream endobj 131 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 7515 >> stream xœ•z|TÕ¶þ aG@JŽCN ŠÒEDé !JI¤„ ÐRH%½M2“i™™•LÉd2é…$¤BQ®'¨0¡) 6¢àõ êU÷án|ï¿ÏÌH|ÞwÿdüöÙgïµ×úÖ·¾µ7ªoÊÍÍmØÒeËâbãVGoMzmò+«BÓ£·&O†'àô}ø‹` ; ì{døøCèÚP4sðWC„çCâ“ã’BwƆG‡NJJ|¢¨å b}ãÞÜ5.~a¢ÄÅIÉ~)©[Ó¶-Mß¾,cÇòа€ðˆU;W¯‰Z½.&ó5É”¬©Ù¯O›>cæÈY£fž3fî¼7Æ¿4!èåM7¿<)äÕÉ5’ZA¢¨ÑÔJ·\j5–ZM£ÖP㩵Ô:jH­§|© Ô›Ô+ÔFê-jD-¤^¥Q‹©×¨%”5•ò§^§¦QK©éÔ2jµœÚDyP›)– ¦ž¡B(15Œò¤8Ê‹r§ž¥úRÞ”ˆNÑÔsÔóÔê)ª?5€šK ¤æQOSoPƒ¨ùÔ`ʇB ¥Vÿ‘4ncÝÎ÷aûÝ}Üe}‡õ=)ò}CKúí·™ËT>Å>u¬ÿŠÌõ~à—O/ÔwPÚàƒ«‡ Ò<ô%9Ÿ±íÏLxæ¦8dجaÇ<‡zæq¹¼VyÉŸuÖì=ËÛ:|üðƒÏÍ}®äùIÏgŒ¸ô‚ø…«/¾ò⃑ G–Œü~Ô”QÒÑ/ŒŽýå˜gƬS>¦c̯c‡}slÆØNÔ:ˆ¯Û?mü‹©n-hÅh…;¯kçk,2£JŸ ØÉWqÚýYyÑ ™ Å¡«¹,H•VªRäh³Õ1õPÌ/tÔ‚±ÉØœ áp蟚NG…C*¨£½Ô1µP!Ì)‡z2‡ÁÃÑz1æhÔ]9l@¶56?ìhÝ“mäKšÄÆæ²!B@’òŸCÞ ^K`ýÎä4†µ·õ¥Û½}éLH Ë ”s„Ä¢žƒh*]âس{¹&´PÄ6Þ/»¹ÿ¤÷i(ŒËYŠS¹ݯíq¼öŠë5Æi]Š Û<~¶ÛÁŽÚ·#ßã Ðq‘=ìãy•—jNŸ²tX¯nº…ÝÁ)tă:F]eÀì¡g=Ìíêe˜Žfîwß`¶¢Cbå¶-~€MïEÁ"4”f;¿†¢eêHf> VlÜð:Y™¥÷£zžfû| ¾Š`Á>• }fsãE‹«ÑÐ7îá¾ |ÜƧà¡)˜ý|"êÂÇýÇjäÁ,.K&ùø,€°ñzéÝÒï?ýø2\Óþ’ÉÂb2o¶¹}oG¿ÙÝùB4WljMÈIÄ•±‰/MOÜ“añïuhBzé·ß»€ùðèæÙ#ò2t™MÐújCÕn4‚Ó—êb ”9*¥&´ ± [«ÖöÆÏÆ`ÿüv~ ÄÀÏ]¥ß ›ãzÕ†. Xè´'Ø÷Ù•ö߈¯‡P|µãtƒ}z‚ (}G4ÃŽ¦PúW°:jÊÆ¿…Ã*©f#ƒ7Û! ¡Ûж½[É[À ¹ý£±Ì¢a¬/õrælÿ…Þó õ¶ù˜õ*Ç•·\<}Áû¼ç+y]°ý’‚Ž¦ºñãùâüIe0j:I—š¡J’-Õù+ÞÖ$æ„€0·é«ó-\Ñië%§óÍzKžù‰ó^³y|jG"{]C«äóñÿD¯é»üû"6£Ro¨Ùéš UhrcXý*GˆûO$ñMÁCnL ñ½§Úëv3ìÃp%ÚHK„³Ö DsèR¨Îþ ?L,_µtÖ,ÿu¥ß•Þ¹eÿ¶ÏuhyCæçÂ{² …éXlGì1Ĩ‡¼é¸´K_I̯ÈMѤJq¸Š2Y„I‡)]†AZÿþI¥,egLSXéVÀ{`ïì—ÞÂ^hœ…£Mµ$cú&çjRÛ¼YÆéc†}«Í­…Ý`lör:ñ q”=À¾Æ~—šÇG"±¾ÂP‘ NÑdÈ–ä$ÁPxÊPÇ°["¹ÍìN6ϤY¦ä–35Hiˆ—ÈpÖ,ÑëÝH¨Àvݦ·aMæËáWÁëÜ~·´ËÍ5ä=Ðr4i7šäÉîâKšË&˜þÝr!î/ŒŽwŠØ#¯IfJ£¼ç‚©ÕØrí~”y™½f¾üq"Ùû¼k9ÔÀ°K¢r«¡Âû*]&©Ù‰}>‹@KN8Âêµ3n}‹Ï!ªW&íï™Ýä¹dvÏáý®×„ÊSøþ¤¡ ·Ðwþ#~ô#RÄOõÄFgàëkÐuQCOŸ“‰™ÀÝŽm¢ÏỦUP ^•$¾å­ÈýÀ5="G²iî§è¤ÍíKô rç¯ðcˆI!cp?:]X‹lº*9NÃ'E:êÕï©).èŠ" ‡äHV²Z¹?¯Let´ïFIäé“ËTCp—’ƒ…¶†çÞÖ—Ô0ytn`~*_Q˜QVhS™¹1¨‹k"–;ÝïÀÂe›»…¯0@¼¼äF¥~ŠæŠ.oÿ †-0¤¾ê˜ÊÌZrüÆ‚ö|s^^U~I^1IËOáh´ô-¼Pƒ¹ ™/3¬l‘ì”ÿ/Þíp¡àT3ÃúD—Óí÷n |G¶Äk’rS¶¦“‰;‚Aá½ "öš¿ÓŽÆº Ù£mÄÃÐF#ùgÚèÉ^åµÝèØNEÓÐ4^tã=OàãqHkÈøä±\ÀÏõŽ½œgsΈ,ÑÒwñxü2ž&ÚN³=¡§ºaÑðÌ]ƒã Ù©EP sœ¸hòš ‰œ÷ÚÝó±Ñ„üÿ6[¦?4iRsSÚÀk/è«ŒuN1ñ¤–È|™ è–óDEÀcáÈ$4€dÒ/Žúñ¯pÛ*Cµ³Ø¦jR„b«r¤Öšå{únzO”·;R+¬ç ?ð‰Ê‰ÓlË‘Gˆ²yÜFðò=|¯¸µüVþ- ÿ›ˆ6Ùðd%Ð C¥…ÉÓ¥ÑÞ+ÕÕ¹„?‡RëRTG³ÏP=9p(EVaûRNÓÖƒŠQó¼Yãéfú~ ÏÑi¼vÌÈH]¦•è ó‹ ©:ƒ¤"Á›=òÂ.HMÏWnݳý8܇‹ˆ3¡L>ˆä1K yœÊ®âçFš†ÜÄƆXP+r´²TEö®M `:¬è,ýÞ|ì(ꇼIf\QžUKvw¹±‘±^Á€}`.™šŠ~6y'~Ò—»?ˆÊÈ.ÇÏù"’YÀz D ×âHW€WÓÛH)ÍŠ‡ƒ¹ôð¬XY¬à±£ÁȪ3©j_ÝíájhE.ŠÔ°îÞzÖQðÏåÑúÍ-xM~¶!© Ô 4(Š”V(†RsQ‰Á„Xdª>MØdÎÃxç:^½êNZ·ßí(ø)åØr®GR†r¸†FÿŽ×Våéõå^¦½É»KG‚\¡ŠTlæ4i"<„âKð_Ï¡|ÿ7>ž˜ªÓh2¼T;kºäÓ»Mú*}i7y]2ÎãŠýŸöÛó’¥ìkÞôw¥lž×Z¶¼°Á‚&Œ„‡¤\›ð»÷8º§¥‘a}ÃUÚ¬ƒëfÑ 1Û¶Z0ó ï· èriWÙ7?î„àÀjùšÇõì×3ÈF¢øÿÙ#Ø¿Ø3êè¹ãíå5ÊÖ,ý.ðZÜ3-êÙ—Ðsð÷žu)þœåÑ??ÔD”éêÁ« Šõ¦ýäØ\ý$‚áÃO?DÏšßŧtc8äšœ´˜õ«åqà~'´ß0è$]MÜlj¯DtÐOxàÄ9ãRð`†mǃR¿‹ÄÞˆƒŽïˆ@Ù„FŠq%]õÒp Î%(Fw# %T´Îža_ôívÔÿ[Ov¿‡_lùp±|Lßœõº|7®—bYò3ÍE=¶WA¯í©ÆÒì’S¨C„õRG¾xÍŽ1-¾q‘”E/]®~GTA]™±ÁeÛRÒØÜ=Iê1ÞG\v7à;Ü€1é?踧)1t3Z*tÚ¤½ý]é]BÔŠuk½,„üÒˆ~§„æEòuÂLÿ-8ûÁ‡hþ‡1z”ž;dÏ´¯#zð°έ´§œs´¨—yNlØÕ¼–ôËu;ö⎢¬¨ÊÍÞ¯À Ÿ¬éÊ-ÖÈ¢´ìÌìduŒ*Â’P ,[¬•eMûÇrô Ÿ~%_›Úå'6íad;j^f!­€lPæKHÜsJä%ú Þr£ò †“…a_Ðhó÷&÷¾__!*‘`lÊm”6ì¶ÖJòòvÕ(-PuVÂf8»“Þ/0$ÖÂΣ…§ö“!g-'Ÿò~ön"'=†±X2kË8‹ß-8¬¯(mi«j(+„«dSªo©i ™æ ˆ#Ýw6îÿöƦ-ÿÛê)ê?¹³)»sÿIðúolœ}Ù h¡íKìF{(!™.ßvWlln4r„;¬B–q`~Op¦,òÍêÝŠÆ´jiÑ•öF[Á¡’o–ÝÂý Æö&gž÷Dz'ºÐÝ + ¦÷ÄU¦ä&+·yOÉüÕ1%Q ûYŒµ.s¯÷hû¤`?3ý*Vl\³r20o:Þ¼B³ßPw`o€"¨;C¯Ý÷@z{ö}OÖÎoéVV#Ÿÿxd¯$9š]üt¯„8öHl³ã×ò5bCCzMñE|rnœ:®"¹ ¾Æ™Žk!/ì‰va[ š-¶|ûŽ¼8â`|Oż n»5ªÍ|´ðäÙc—õÝ+yѺd‹ªÊÕNÖ ÎÕ“%‚"#;&¢-ÐJ*«;L+™.[Òæ÷y"rßÅíQ}žJø%p]À\bH!bÃV‡îÑ¿“_‘_ž_åê-“1çj.ÖX…%%-m1ç2?î’¾½íl–\ªÊÍ.'šŠ `0±<€¿Ñ£1÷vÕ0†½'õíq/QxšC^Žöº"XлKw´;Ýëbã1¡°yÔ£ <“|¿pPÐròŸ@òÍžñdOûð–îFÓ˜AëÐHÔOÔÖY³‘<õÆ“z"íòi§qžxýæ:ŽOK;ÌßHjrŽ3¬†ŠV“gÞÝW Ä}T³1Q¸ SRé’›w®‰X9u¿*bs(çíí#h÷¢5#p \ŒæØ‘ŒäþŸüî¶]Ü›‰WáÒ_ð ¯u°úTÅg] W½CýÍK+ñ½T<øò«÷Áë>üz§ >‡î‘×þ—öÓnꖨÞPxJ/Zæl9Ž†ŸCŠ/ø²j?´ DKÝùûO6¦ÛÆj‚iü >Ï%¯‹šŸµ…¨¸¼6]¹¦=Š÷âÚ\Šï/¯ìƒ#Ë9Ch4í^ ¥í(Ž¯àöu7tn³.œA„'{œ¯pŠÉp8„Ôœ¾ŠÔö)[²#vÈ÷&TD•—Ì°7›ô©îÕc?’ò\¸K>:(òvwý–lB‹9öxWéñ£‡¼wCQ†ÌÎâÒžäÔëy¡´‹L‡ÿcºpš™6tBø¸ñÁbccBž°·Þ´ÏؼMã u†CšÞ««n5Ö Ì`¨+8h0×îïÊoT› µB@Óa!aˆì¨©Z•bƒ:Nò§ ×HB3wH6èwCŠ*7QS«³@½QåÚ]x6§ŽQÝŸô¾ò8ïGhdCƒR=ÐÛ®ºÕÝ ™LË—;¹É+ R¥4púZYª–a홺­:.7¡\]JBöŽéäþ·Îæ&÷â|ÃBñ‡;ÝÑáp1¢ÌÏ·šÚ"%­ŠÐJ1ýç|N+UE´ü˜Úò­.ÃH"ñ±Ɖ‡Ä†úî VMš:ŽÁrúÒID]?qðÊ™³Q…N½Ž©G“feMW…ÕËÊ €êË ùVm±¢ æ½ÓÍ}öÍ’©²…+}Ö`#^ÎÉ*µ&Ëõótç‰V°;Ph½ý,±¢n<òr 1»åœi@s8CƒùȦÆúe†Èp†<¾2·ÐsZU¸:ržÆ)·[¢$-ÊÙ¤ËÅ‹8u¬*Õº¢D6.‡o᧪ƛù&ó cCéwœiŸ¾tÙÒcyµ® »®ó?Bm»òºˆÝD¢É›¯Øz9ìüò¦Ž}íg ß/¾¶ì"~x Ì ’.RGÖdU9ü`lÈ/ɵhôíÍ—¡˜Kp8\¬ŽI‰ˆI‹OІkWæJ@ëbÈ÷h¶ð\’³2gù’¥“a;ø¥5ͤQ1ÔJªˆDH¨£$S¾]‰ò„ŸïH¬äåè[q~™´,“( ¥Z¡Ú›™E4…²PfÍ)Î }û.ˆÎLÈH’D&kÒµ™ÖL²_µÛÊJÀò"iQvYÊ^ÂÍeõå5¥­5ú P6þ9‚֯΄žÙ|FOÈ Œ¯CA ;&¬ojU™ Tâh‚E]F*>ˆÿÅɲuZMª*Ò¬lD92UžŽ)Ѳ^]Ò³ˆ-£Yÿ D¡âB2ž×,Æ 4Ú‹~9ƒÒlCÓPˆä¡UâòŸ—ÿDPÁÊàä´ŠCÊ^Wo5Bm•«£Bp%§IÏMj!éh4ZZ[Wœƒ[Ðê+óÏš3{Å Rè—™Ó>0 HûؘZ–Œ¢äªY3¯,D} DW‰Ü]øèÓúv¾Û_D¬´VLˆÑ· ÷@X“¸m?zQ·nÃ^(‘Ô*µJEöO,M­'ö‘¶¾É||×ûˆ…Ïž„ŸÞ‰ƒ·ãœû¾÷W6}¿"9F:¬ióW½ þs<Ǧª5Õæ—X:ì'>…›ðÎ’ì‚!–þ1áÚãNIkÊÒA;!7Y“¦ÜÊ9iŒ+‰ŠBå4Þ‚—¾…w¥ã>Ú,UdɉÊ"cã)ÔŽü‘ïåó»+òóõ%²À†6Û<®Ú•B Y0Á‘Å×WŸ_XýÕž÷ž-¹õæ ¡ÏæfÍ–¯jßp=ža¯ÎMñ ÈöÉœpcªà9øãvÙ1è 8gÕ¢_‚‹f_X{¤ðLá©Ž}7àx<Ù‰ˆe‹æ¯žIž¯™ «ÏÙ-6û…ïá¼·4g¹ƒÛn¢£n|6ÿ‘Ør4Êœ i-Ë IÁ!œV) Ä»æ C9)ÂhË¿Ÿá<à¬ÔNhg°½åÆEÇ*ô±ø R·Od!î73?†é«SPÒ£~P~êP42qüË ‡ˆ¼´2£ÑdÒ— YOd6$e²ezKh¢8@£ÑÐV´‘ñÿL,_óöª™0¶^,¾VòíÍ3Wà]¨M²¦Öï0¥IßL©NA3:ÑØN4=Õ¯DÅgKñ£ßAcEÇh«ƒ®]ƒ¡t+êWÔžl‘€W4Èc5Òü47ú}ƒ–‚@ýã[¹HoÅc‰ë1x€ǃujMzQF54ƒ¹Ñ`݇q¿þ݃O] ?D÷ KŽv*ðŠüÐP7~ßW\Ð_¡­ŽV†ÕÇ·À~hj&åp=>ÿ÷…0'ÛTäËW ùbóqé=üž½hך{4˼^¦PJ5Ùš¤â”=ãZMíÅŸm¹‚‹©Ý%ð£!7A“© å°({þü칉RL¡Ñ¡XÂ…˜BkT'M«Ù°ÛÐRžJ¢–«Üœ5óȈ–©Â²¾Y¸¯Ó—™ösÈ£òão¬ Aâ5–MûÌ'ÍÇ>8xÁÂüþÐS,_¸ÉO¶Åre·+Ö3ÿNøA\ôIBK(6Ñqê긢ˆã¼v[Z†B¥‘(5™Z‰5£jà·÷+Q_G¥ì@#;¦êð@â3a‚Hë Ì|}ÀŸ߈=!h¥Ô'{^ãêcpŽ³^göžX_!%GM„œ4¥ô!÷çBN•£Q딚´âÌJ’owjÁRa*â½,æL½1¯€Ùððwqñµ]ç7Àؽ@º`OÀ 8GÏ[¯1XϛŊ¤8Hö )ḢM‡v7ùŠQm#]ÄC3iäwI f³ö6Þ½ÇJðVºKâ¨_©ß‹õ•2sN¶ ?u"?kA©Y_éeØaÍ$QÑè2åøðv.G%QhÒ´Ù&Y¡Ä¡\±<_WHÊgµÕ°Û—ÀÎ[nüQÞƒdN˜p‡ïÑYæy«rô/‚ÙV³ñx"™)dþÉ„H2IÑîÐá÷HßÆ6‡}eè¼8¿XU$/À'Q('-Ô™ )ÒÜ$MZ‘¢DìÇáNì'U öyå&•KËHÍ7ä•òÚÎYL%ä<…ë"ŸµâüR•!ÓŠû|•ˆ¼HLËïÛÐôÒ÷EfC~ižYG˜$p æ¶àÂT< ùµ=ù~¼º˜z(¬rþÄ}KÖGŒ«B¢¿ÛubÛUÿ3‰Då¤êZI¡Ò¨Ac±›O“ùgŒ[Gà “3räj­D§ÈO­¦P âÞE…ŽÅ Ÿ(>ñd}xŠëËe…Ú¼äòe­‰%¨ÿy®¸ ¤@_™g06n<üMÎToýÄؘWhjÜ©“«csü´ñ/] ÞÑ‚’ôj™é‰&Í¢²*ïp¸@¶2K¥IõÒåªc~…ceªx©Ÿ:V'WE¶ iÍ+46Z>ɯ?³sgÕ…­µ™ù`†*(«pÞÓδ=%¨ÓuÝ%n"ú<%B{U{?WµÇÌŸosêhCÎ^Q¿'…qm§ÊëÜܹ’|{²F~/q¢‹TñHšejѨr™´¦‰x”ˆ<ëA˜l5"³}È#­TM†H»m´4[M‘g.v@$Î3k-ZŽ&™¥±¨Ë“‰—Ò34é$9ù*ýçbNŸc̨!g®(w‰/Âè×:±Åu „HÂ8RW”¡u Ä[PgÎ_¶!Sš+#ú\“êäˆ@îïW >=†Žm#æÁÛ:Q¿^wiÜçOr¶‰½ÆýžæÄanŽ4xä¤Ë=.?yÔ:þ Oø\©—ƒRã…ßššQØ^ê…¦}Œ^ôo‘´žŠ*÷ztºÛÿ¶à9dçU˜ûÏv¾ú`œ‹ß’!G¢È~¸òÏE\N¦t Mº5£ŠP¨¥Ô\̯|°ˆ³”å3œ¿fDNyNÜŒ–ÏAžD½ ¿Ñ2Øñ»AÑxùØSø%¢þ£g›?³¤Hœ€ÇOÇýçÁ<FýëÐøZ4ö›{×à*œ~)cÉŠø7‹Ð¼"Cmëoð|ÿ¾kâ>ûÃÀûËLyÂc•Á4p ô ¨ÿî†JÞendstream endobj 132 0 obj << /Filter /FlateDecode /Length 2752 >> stream xœµYmo¹n¿úSû ]Š"TÏÚòý%鸮E‹¶~ˆïÃÚ‘5²ä¬äøòïû ÉÝ%¥µ.I¯ ïrÉáÌpøÌ3ã÷3Þˆ§¿ùçõÝŸÝž½?qt–\ßÍþxqö»WBa¤ <ˆÙÅÍYZ"f^ÌœqMPfvqwÆäüâ?˜«l9×ÈÆYéoÎ^³o»«9o¸QNðÀVû®íVëó…R² ^³oçò¼Tìz¾ ‰Aqãû/¼õì¡Ðµû%­Ö1ìOÛ»ûâcšh‚öžíÛýj»ÉYÅWû·ãÔï/þJŠûÊÈ ¯³æìÕ”m®áZÙ÷b¾ÐJ9vQHfËBõ´æ•ŒÊ?¯*nJKçYÉJeîL¿úŸséŽù¬½ŽŽ4’½ko“ VZ+]"Ã,À Ò’Œ…²¼1\Ïæ­Íšüa¾0R7!HÖ-ß?¬ºå%{ýnºg—óüÍ öëñ±½Ù/»þU±·í‡Õ涗¢Øj³Û·ëõòM?ŲýÛ%½À®Ø}{”M–5M–Øû·³‹ßÖš]²í¦_!ûýbüDš^2qÞËÓLH~9‡îÙ¦ð€ß¤•ý"/’‚='9ϳX-Ùæáîj°2¶½·¼ï–׫]Œ3Á § ñdË®Vû]aNè÷z-¾ïU”Øx—+í_þp]0mÕ”)1‚Ï& ÐÂV“ÄŠ(vA—ÊŠþR']Vȶêæ³m÷‘¦‘$z¶qÉã[š,çljå%ëÍTè7qéy_™zÛkåخҤ[U¯É}LÞÃ%Ú>ôì®MÖ# JýáˆøäjÝ®  amŒ˜Â÷ëõ ‚=¦Ýà½6yÝB…}ÿp½M1¥cú“Ïk´…ÿÞ’›hÝ’KQ¥ ÑXx7#ùò‡özŸÐ¼4Hw/ƒi_íe§ÅSµë©`cxÓy&uüÓ±·½Ã¢´†‚­>T8”†©£æWÕ¬úàr´">öt†Qn°OO„`·Ì[WhnxÞ(Øâ(HKq­2ê ¢aØæ©­ÊŒÃÞdåžp'áÃÑÈ CžKKÛ*ˆzWçc­ÎKiߘ`ó±¾›:RK¸ç]¤_•¢Ï£PÄ>`L…Ù‚b’ùÑáo»ÉíqmpêÔö2d?å5û†ðÃÇD%žlÈÈ^N‰ÔÄIxÎø=㪥˜FÃJñXmã‘AÖÄ0yq0š_N"0Ò€Ôr 9RÓÉ©F"ǧÈW1ÚôH¡Sº¯„¨õºŸ®Y·%€ë=f Ç}Ì;‘£!®3uhwÕEh×Ïwy³ Ù!R!ß:¨¶)â¼ þÑÔQžw =²(s€Fq¥ °]gÇhY¤W‰¨ræÅWñ@~–ÄÍ`šãùÈŒE®½jt| ‰šÈi<À`¶ð@(Š”"”ª­pìî™ åÐ4ïçSñá‰[jHâ Õëê‚ gÛÇÞf:œóâ8œ%óà¢&Î.é`·Ã½²sB¤5ÿîÁ:ÆF6w€ÂÒòPÓîZ¢ÝF‰^>(o¼)÷¡ˆÂ–×CÉ`Y™L»åq2Ë¿’Y7ÆNzoò0‹˜Ö=Räþ`J‘»~¦Uš¬6Cì¥õ÷î¤êÿÞ­WÐCÀ5¶®æ‚àV!amŽ2f]D'X^#œñÇ%Áf7>—¬[¼ xèùø˱8¸AÖ`~‰µÓtÕ4RQ/ÂK»ÖüÿÓŸåל÷ÛxÐË©QûÄ\ÝŠqTàÚäQ9IÒm¡„+'"ð¿Î£jE”)™Fõ8ª+éBcÔLŽÚt‰Fôä:ydp |LÁ ¬§U®Ü×°9‹Q_ºÔ)£a%ÞãÖ˯/]±NcTN|[h#M2Ti‘1€+’¡K-4—*Žšê„Õº W—’KŒú¨EÜZ–@ˆr@‰ ¥8!q'E)Îx#Iœ”•[PÈ{HêÉD˜&ÓK #®£Lˆý‡“iE6iûY€ÉžØIJ‹ØEb©¿Ê/.Ý︽8 ”ëJvÛÅ. ICÖ®hé>êö4üTrJôjÈ" ü.ærdPYäÒjᇔì¹8तDI<àé&khŠ²/h]m¾Ú• ¯ÛK|Ìþ@½¿Úg·ãÎÆ*!‹×ìnÛ Ç¦êª­Ýä QæEÀŒÐÙ׸e=r|Ú—KW$‡Ó•;pdW—FqÅ—'£©¦AÜÇMƒÍöýÃv¿¼d»{œôþæ’=ûÍBAÞͳ¡[bKÀ–šú&':'n²ê·éVqáãTÐ<*,ä§\1:;؆À)Æ9$n{•jÓ«myÉvái‰f]å¡[úâS”mò,mÊõ¸ Ê”u»¶—•Z¹åý!© õ¸”t[ã~&V?TÞK\1ÿÞRÓdØ žÝ‰Ba]Û›½«ns*Ó(à{;á©ý6=Ó±51ŠÎ$¶ª¯Àû‡RƒO11Ó8iÃÐlb4òøï¶C…ÿ8`Ã"àÊ#·±.¬a Z£D}‰[¡nS&ÑNM“d.ç|f.ý±QÔîV)T]nv[5söýyÍe°©5öYhWMºjË]%<9LL¶6DÕÚŽ¬w§ÚÇ©ÿÝM^:%^Çú8º>‘Ë«xh±/”Ôö†Ô¦ö”sÔ¬ÃzÝF¾)q';$«t (~±[eÝ’>uzúeo³?Ý„Óî‰øeÝnq5ˆ(”Ï»§ÙUc}‘0ÚØð¹[¾˜Þ °F{›É³ûtîœ;Ö`Ðçý KMë/eÔãDÍÓfc_›šÃ¹ÿ»›åŸß®Éªv}(é8µ¢ÓÃ4ŸTÃDKÜÕ9Ÿ¡Ï ÛÇG‡Ç)ºîâd. 3`åImÎ4qñɽæÃÛd.S‘…ã]¢lùÿ8#G½=¢!‡$¿(B'2ž…¤DIæ:êøÙÈÉy\àTÚÓ'FKË%ä«’H‘ع¢ˆµ;GÂd¤á…x׺˜˜ aabåÒsê;cµv) l$æÊqãä°>ZjÕ˜âÉYÊBs‘;Â…{Ë|É™x;|%œµ±2¥é‘0D*û›Ä䥀ùø™VQ¤a¯Hç‘ðþXØîye ŒáÃÉ@ÐüÈò…u ~ÐaP`¸F‡ÔL×ò~ä7ÿè{^Ä}Â\›4Ýæù"ÒÐØ#ÐÔàr”ÃÍØàJ)!BÙÁT{+ ´uí|ªG…0B]•šTÆÛÿ¹IE½¥M*DžÈMªÓ=*…¡E¡Ôë “ÿO=ªè6ôTGfjSrÿËÚ¼òD›—Zs_Ô &l¦3:oèöguÏóI×͉Ü?ž®ßn·»åß‘švMÉeL9ߌžRÊñü§I9Î% hy"ãŒ`ü}Ÿ?<ïÓ€úNfŠ”¼¤9ö™@Ž7~:W˜õ n55}„¡ AX…Û.!}J.@C'ŽF°—ž~óƒ4iýâ›þÌŸŸýùâì_øû_`¨kÅendstream endobj 133 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2969 >> stream xœÍVkTTåÞ̸UDÝÈÞqŽ²:–fš±LM-¥“wÄ[„\DP‡« ˆÜ†ËÌlæÙsa•Û DI¼š¦¦Qê)Ë•Ç2©\-³²ìÛôqNçD­³Žþè×™5?fíï›ý>ïó¼ïó¾Ê˃’H$¾‹—¬LŒLQF&¤N›úÜʘX•22Å}ä—£~UõGHÁÛ¼½:ÿ2z˜Œ½1ºw åþpA ‰ ’RRUé‘QÑKb–ÇÆm^µU?«¢ü©eÔr*€ZA…P¡Ôjj-5ŸZ@­§^¥¦P ©iT0õ:õw*ZL-¡–R~ÔYêq‡ò¢r$2‰Rò£‡Õó1ÏlÏ^{¤K¤—eY2qX#ý½gø…á#Î ù›wÐ(Ù¨5>¯ fŸþ|p¡u.ñ­tIä8³Kš![9Vm3öê—²üN½52A§)ÌƧ¾e“×Fd…êµJö¶€d¼ÙµÒœæ:¡Ä`üù²d ø9Ð4z§$ ·Û„ °è@dS`• ÍB—¥>¿yL(p‰R—Ú!G£Ï“¯/c›ˆ5¦=\ ÙuÍâJiår+ªWÀ|ظ¤òg–9'¨µÊ `-Ì_ÏmÀö‚p5§U"™€< ®`PCq'·-–2?U~vâœßY0†æ¯Üˆ³Ù»· ,r[ê#òj§8Õ!Mh‹ÂŽ›y<ð0,IÃcUXq}h ßÙCÏ,VhbóC6ć¯OXmß~(ã`ÉK«µÝvÜupï¡.û~8íªªˆªˆ¼ššd{ñ%JåêÎ%AÒÛžý«P¶ÂXb°æ z Ÿ·OÀÞ3±–iéBÝ]¨…µœ$§êðÓt¶žßUnìÂøý(ÏXa´ªÓòr±ÊÖÈ®I€—^Ž§oÆ›q4òÃÓÐR@3ù 'ªMߥ¯v¡É‘se;å×Î/;ÿÆUtðª/3F<Ž”$fö-ìs`݆TUi/Ëøã§ÕR&@«¼MÁŽáç ÄÞçÛK@Ò!¾­Ò€^6ÚŒ™Í¡Ÿ‡FÖe ú¥qéxÔŒA qÕéòì`ªÛÐ6v_÷ñÆnøMߎ¥ Dçº_Í× ·ïš/ó¤8O«07%7F VET!– ÆOý¡¤Œ-¼€Àò#¨† ûá0´ó)è439 ÔÒZ‡¦°å·Nö}V0‚QÏëU¹Úd]be–*¡¾ÌÒäFPxR;ÑìtTàB‹Óåè•ó¥Îg¦Ó— BwÐ…í¤4EÆtç¯Ê Ú³ ¸`(ÿÚXq¹X4AFâá 2òGr'kæ›ONÔñ*ö Ù[¸1 þ:·¸‹°ÿbé¹!-Ôµëˆ ½íRvÈ™àÁÚ ­¶£Ü)„¤L~æAŠ xaÖ‹ËÍn˜÷Ð }}qïÒeÐóY/p)øÙœ9YSÑdàNÀцö÷²¦±wk¯$M”¸v»ä_ôýëåþ _&®¿T P˜]ª¢x½ ¸ç­²U_•¡Màô}Qaæ°]šŠÊôFƒ™3×·C5˜]¬?‰†x#Q¿ vçp&%Þ´˱–]‹ªù2ƒLîcþyÀÔ*» ”·nå>À¿³;Û ‚¥xšˆZÙã¸Í¨zh¶™KÐ×~îËÿ1(x*<¸@"¸K¿s‡.…+Ê#‚çb¬gƒ‘£¨Dor X×UC&ÁÆ»Š!Šã¸¾IÜråªè…oÇk!2+›Lec¹¹nGy*¤Ã¶mšO¬w÷?ŽªA+ßí¬)¯AP“[#ßÝÓq)üÒÚžðž5—ôRRôø2^âQq¢B¨Ð4m$%®YE3éæMQ‚Êo ÌZ˜3—füÕ…ÊcìiYYÛ¶hâ´JkLCúâÑšhÒûóä~µ ùø¡€¼ºw^¶ìÕv‡5ÐL*Ûðæ Xê—B¦}¡AiÊt™› &SMuuKâ¾ nÀgçw~jiËoSÕt´´™+ÈŒôt®®P]”Ëï(Í-‡°[…¯Æ”B—¤Ùšž’—›” 4#¡^„òïM54£çÍõ–¦*gIYCÃ~øvüM—J©È½îx–uÛŽWšg=ÔÙvP ¿NÉ®°Hß_©8â@î‘ro«:ÿ¨­j„.SÅÒzÙ»è)só÷Î8PñˆÍªò'²V÷°½ê7‰âôÝY®ì@’;ò}½Õ½º_|'æuàÍÖvîŒè)eÞÇþ$æûP¬)XÏ…cǃ˜žÂ^h)jÑsŒüøƒÂTŸQ›!%Q—¢MªJÞ-àl09‡Ö+liZí’#O' íÓ÷Õ:Q0™Û©ýq­¢ ©¤H¶«ˆÛ@öf4‰Œý:°ÙuEjÂ3£'%¬ÝÌgûM*¸Cøwˆ´Ä~wGËüAØen¡™XbBµ°«ÒÄ•ë‰'’WÙ¶äàÀ!ïL%jàß‹Zz}™+b1I{¨ á÷,Z¤7ê,Ó•ÓeÅ»ß6Ú $D<Ÿ‰ KÙBd•¾X]”£KÏÌÍ/Ä؇ýLL% íC5òäF·?zçÔSÍ!|ÇoÏÐm”F"4Bƒ¾±ˆ»'±A7Ì1crcú÷mñßR²h?,”—[bÏ ÐÿZá+†öøþ㮸m1†/”†ÿÙ~ï£vú?S§wPâù·wÖÜ!Ý‚ŠE…¹1½6 q›6A›P½­oµæF:_:¤ûÿ8ÿý¶‚$ßÊÑ–›WnúþŸ®-ŒO¸(Q˜jwÔ$T):•.¥"µ\àp?B Ç=ôÌGåT „R‹CæÑ7rü¯U‰ÞÃÁ{x´ FƒÑh°…3ÞÞà-§¨ÿÉáfïendstream endobj 134 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 226 >> stream xœcd`ab`ddôñ NÌ+64ÐõOÊÉ,,M JtwÿLúéÅÚÍÃÜÍò㻽Ð)ÁãüG@€1ˆÁ˜‰‘‘%ýû¾ÿL­W”}¿xâûŒÃŒ¯~/½ó]äó¿b¿E¿ßúδòî¥9w$¼3|ô[¹›ãw+Ûo¿^¬ÙÎ}¿Èú݈í;ïL­q± øÍT¡Âvøû Öï*lß9ºÔ¸pð•.ü0ç{øÂÙ ÙNp=á–ãb Éçáìæáêæá>Ô½}@4µ‡§›Gˆ¼†Yendstream endobj 135 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 833 >> stream xœ…’mLSgÇŸÛö>«µA¼¥mÀųù’Æ—‘H²Äˆ`*(ঠƒ€‹"oV|`!¨=ím(³´@l‘qSî¢_Ð1~˜Ltj”#‰¬N›Ç„Ý뾚ì$ÏINž“óÿü@ :"BjîÖµÕe5Y•Õû×~îØ^~p}C¥öcoâE‰‰<Ìz0&óÒÃÅ-º•L´ëíÛQMH>ÙIrÈ:²Pu1°`ºR½ G“æu«e‹ü$”ª iiÒ‹˜2)V–ŸB§e?Ëü›`/”6—Õµ±å<»­­¸ú tÒöxÛ:™÷Ëw]b6u£$£ä *jÁvEpÓsÔ5v4~tWyJêa¾t[Ñn(…úáæÈe Û"#ãƒWàD¾>“æ…óÓ¼¥6*½@A˜deyñ²¸Árjª`h”@‰óÀf£—ö<Ù(ÏT¡nBÜöoøMU¾­™<˜ÇÞ­ˆ_ÐæˆLºwúŠÏÒ;jÚË>: ÃíïšÐt×ÊšnLÁº¨ôÉ·Hü(-EbeuqO> stream xœ]“{LSwÇïmK½Ö‚í@smñµáD£S'Ñ {è*Œ±F,u´J[°–GöÞÓÛb‘‡ºk☨ÑeAN1$C—E݈8g6$3N͹ôWd—mn‰ÿœœ“oò=ù|sM)dMÓÓ²×®ÕÛJ>´ÛŠÍVã.ó¢…ós‹ å¥z˘ªöY÷ù™8PËA­èfÑ4 &bîkCÓÙÔôUy[M»õ–b³Åh(±e k¹É¤·Iv¶b»Í(UƒE_:Öÿ'l7Zw—ê÷¾Ôþÿv)-ÞaÛf4üïørÆÜ)ŠbfäänÚBÑ)í¢Ý4Gó4ÐZ ½Ôx‰‹RP~j”®‘ÅÉZe£rƒü9O•'uR쳦 vÂÙ=´X4$/²Ñl ˆª1‘,ÁÁ0- §§>­ðžJ`ö9¡ÎåkܺG„ù™L¹Ft˜D®]$QˆeAlå–˜Š¤’OÉäL¢z›P<çv›© @k›‚ ¸qý.Ê0 ù_ð\7^8‚K˜¸ŒIUè|Ô‹êËÑégèhÕˆScQZÞ]½îsUÓGVò&0± %>ßó/ø¦‚÷4É]17YLQ¢°²á&YÏD”KÑ7rS¹›çKu"ã Æ>qÖñ¸¦Öávø¦2a”¾“N½xî~<Ц¿½'&Ý“‹ÏÓ5=›O¬OÛþVf¥¶&ß@NÔ“x;’$ÝP” 0y+ó: •9VÞbßSî0}v¾ä»Ážû¿†µ-OâÙʣ܊Ù]‘nA'¶›]NìcÌaÇá/Â-_jFã"eußgOzhé ^ôI¼ÛgÍXEÆ™*šæ–‘| ø±RÜ/þîHÀÍS ¹!Û1<)YìVâ4x¸/È]rÞ¯üis¤êû¢®å:‰Ç®8–lSÚ€çݼìP+)IŽµÅžÖÕ@#À?!°ŠÃR ²y^ŠÅÜðÑAv\óàQ)‡¡á‡äÑ÷h.m8Ÿ™Gh²5_ë®%¬”£ldf™o&+vÝÞ¬B’³ƒ¥t_ ÃaŽ[ÚmVKuɦóúë˜vøÍ-íìïÃ.á§Ðx ºPs W*§¡"vŸk'WYfg¤ªãH¤í„” }cÅo«8¹‡Æ´~¹¸ˆ%N ø8óö®Ðã2ÛÃú?á7Àö˜j|=r‚«zÃúj‡v‰_CV±™!…Ò•f„jú2ã @H÷ê–Ú~9^]Ñδ`!IÂŒºkn囹sº·Ï­ëÙØ·ük²¸cap6,€7êç”Í-&)9+6åÕ׃KZîôsÍm—¯·Ð>Áø>\ he^y1¬’sì³* xAhôÏCfNÉA´ñÚFŒ‚˜âÊ^Q…©8p'ßFÕ¤¯ € 5@u5'}Qöº "#Y„_LΑ V²ÔIÒ,ƒ˜ê\,—Á[$mLÿcVÐéáÓ森 ‰³›E]ÈëQžQõOЪù»ÔãA­õ„p»à÷ì÷ø¼þÖSj5¨)ê/ìxq°endstream endobj 137 0 obj << /Filter /FlateDecode /Length 3338 >> stream xœ½ZKsǾódßS)”}ð &Vó~¸Ê©JbKIJŠe…¾DT•—­…½»”Ìÿ›Cò/Ò=Ý`!Ç¢²Š\ÌÎt÷tý˜ü8£›Qüÿ¯·gt¶>ûñŒùÑYüw½ýñâìÑ ¡a¤rÔ±ÙÅÍYXÂf\ËŠJ53ÊTN¨ÙÅöì%yV·}³›/„à0¨É³^Ϲ®œt’¼žÓŠ*aud³‚ŽkÅiç¯.þ l˜ÈÙp$«°ºXž1¿ø¦p5s•Ó\㌅ª2f¶€Vk?¯ ?8{¡*.(µ³cH‰á„—ä%¯æ ®¹ª('Ú F­b†IÏ–KJá-£ *#Lsc†[ΩsŽZ¯QÚäÓ³‹ß!Qõ*,#B É„Œq¦¨0N mᬯœ#F[£œeÊ áà½ÀÒ“ t ÐaÊHœË@YŠ9-˜ÖÆQªµ•–¦÷–pǨ Š2[ÐÚ1Îñý(Ÿås]Å™•Æ8Í4®”Îà¾GºÖ‚:WBZ R£=Ý)æJÏô2 vÒÆïv@‰åL£ŒrE>:1^vN"~÷\Ã|–@£rÐVY*†mÿ]ÎÒ0¥&×›ùñç@c–Ô]·êÂKç©wKü@µ’lWýë=@˜W”rC–Ýa¥eVÛ)¨v”&@¸f8G¸²ŠÔ›Í~Α ë2çà@Ô¶~Ø Iîré›ÛÒc ÃÉ2oº|VÝ_{b̘ûÛÇIAÞåãM˜ÎéaŠB d;åd º0‹2Kú×ãÄÁ•/’ØÒ-f¾¹ªÒä›Ce/’vLTJZ”WKË]`Î] ‡®{]X{³)X/Ã42Ýddöm-Õž"PRdíc•Ršj²C2€'~T€Ï[Ò‚ÃtÍ#Å°­`OŒ,ɵx](¢Ùï’@†lë¹×„vä>¥¢X¼ïãl§É'˜uq¥ w[Ê,8Àú&€å5#…jrFIMŠ“QÂ#ëzaÊo²á6ð· £$u»Îq½=àRP»Í$ÞßDn‚`g¢š‘œü±š!]hØ°Ws-(ÇS´¸„¨¤6¤ÙÅgØZîÑ")_ xÈ–M¤oëÂCK΀ƴìˆJ‹«|fuŒºY|óÍólÞåü<¾²†\A"<¨qÑš0]€oÄ@ÊY™}!µª!¤}Ô5ë]ÝßµsE1˜h>žÌÚ˜´!w¤uÁÖ2D9w`®!ÊE$ ƒkÖ-¢ª° A,O 4?¶×Uiœ×Áã9Äñ}(,ì¬ ; …²ù©ÞÆÚQ¦ó¤¡"ÕÈBA.VŒ“ÏÇÇ«IAbáF¤•³„("jˆF+—>¤tõvgÁö¥SZI«x,˜¾ÿü{ÀóùÕåžËêö ùÁY™l†cŠ#oçJã\MêfS_$N.±Úç'‹²eæ×¥ÇGYAˆ£¢Ç*OŸ<ÏV?/˜ÿ+’ÉÉ’¶,¨Òæ °ïV§Ö£á¾¾8ûöŒVÊ·>ÚÓ’2#§N‰02þL l„Xl”×}ûÅ£GÛÛ›¶Ú·ëGhúÀä=}˜ƒ©Km*<êgä_–g¶ƒUäƒíõ¾Íœ`GfžX°‹èÍís³wQ«±…ÔBRí)”õØŸ£È’*!òõ`)™?»?-0c÷_ù‹·GÐ $D·áŠü{<µmš®óU¥…à±s…ü))Áž ÷aÿ@« É°´åäͶ¬5Úm1u7i€_ªyAy©OÙP{]’ 8hPæPäät9¥æ„8\1Sˆ Ç«9* ës}R‘Çêë¡®?hˆWËHWŒÁ/Xá¦$–™§€åÉ’tcã ë/ dÏò£fï‡;¤-I]eUáN.ySð‰äM˜ˆKͱg2úŽ÷‰è;ØćûŽ' ßÉ«à=M©Õ$µÇ†²hýŸÜ —©ô×q©+­uN–CpyˆŸh g6YØþr £B'íjQ ­›|§}?Ë‚4ïT3 Ù`¿N`kÔwü|8i¾/oÀIÞxqCãÄr…A¼ËÖ”ïP.Å|½|xÒ• p# –ÕaúÙdŸ dîMZc4ÉK‚’aáÍ¡¶ ˆåmSD›ƒæ$ÖžÁdm÷að ð,çï;1ÒW›ÿÓ’ÂL¨…ƒàMY^S¬·· ñC« ˆH‚ÁÓoVP„H´÷ðØÇ(”pî€Ý“¶@â渘 Ðñ±ŸûNn}4Z GPcጆ “¤-2Ja¶·¡ ѯÞìoOb'œhµð-7ɤ¯/ËÃm½?$¾1(Á”Ê5öë8îA]Ð}h„ƒúÜ2]ׇ8m¥ïÙü¥V€² ì3í’m6QÆfµW)ö¹[öuÑ”*‚ã’²kÜî·‘õñ•Å¸ø8/ú€Ú‹pXó[,£âM‘·©S á$D÷y”lÇ—ûØ•FT¡xpÍÖ¬Çf@wßõÅÜ‚Wc0ïëñg§Â6ôÅB7l¸EûûrTú¨Ùí}'’*߉,z¦uSÐÚvØ×`¡fjú¸ w¾ã‰ÏPÙ÷¢\h÷i ì¯ÙFþ‚ùNaháPá¯ð ,@ñ¸ÙÄ-8uœS#sT³øÊø@a1fîùѤ†,]wj‡ÝQ ƒôîŽ(¦ø‰skD^×ÕAÒ§š«é ›Ré?×¼;¸òøÅÍ;܉zå%^*` ¢´—Ÿ¬·+Ç:CŠ¢)kÙ…UðVìŸ W­±!÷è(Mbêx{ˆQ ?Å)XÊ Ó¾mN^’”W5]"ÁÈWEç _ßÀñBjòÝU†Ù2{yY¡Öêï"u!°Ç±2ûˆ¬ x´Q±Š¾*^ʘ€»žLrmóvŽŠµxÞÃße碜ÕÅó{Ay~÷îC£î4л<Ôý¶@LS` *se nÕZSwUÖ é«¡ˆÊ›ì‹J ;ÜÀ¤ú.VP–Ûû¼.ö‰}Ê8ŒK÷c‡£ÑÝ ]OÝÜ,œ¬¬ã©çÇb éî–{¼K a«¾íëUŸ.—@É»ØÒìûI‹åêmܶ™Aª„c‹¿Á°h¼ÃËyðt‹ÁÈ° Þ®|å‹ùç]ão^Lˆ>@ÙïˆÁ¦$i»¹`ÞÖwÛðd‡«k ß´Ý8=îÙåßÝa”UL;¿e…ãp™ðû´a¶§_Ô½°‚> stream xœÅZKoÇÎyOÒÁ‡9lê5¸£~?è(€£8A‘eÞD'‘KjÂ}Ð;#Qú÷©êÇL÷ì,MAÖp¶»ºÞõUõü<§›Sü/þ{¹™ÑùÍìçóoçñŸËÍüOç³ç¯™€7•£ŽÍϯga ›[67ÊTN¨ùùfFäâüß°Vè|­â•Ñ–Ÿ_ÍÞoöo´¢JFiº}½oÖŸK!xå¬$ß,8г\ËÅ:A•MXfµ%ï3 ûº[án oy¹ÛÜe?†…ÊIkIWwÍnÒ‚Ü7Ý»aéOçGÆm!¤ã••‘sòzJ6SQ)OÂ-–RCÎ3Êd•±Ž‘´ Qèçu!Àu.é"2Yp TEJ»_-¸­(¬'õ¥W¤â䶾 ,h®57Wsjài,…¦•¢r¾jVë@뻦íKÅá&ÈîŸeå'Âs¢*.(µó%cpŽba×—q™åäj÷þízU]57Mצוi¶éʉ d{jßÍοš¢·ºbœ:àßåĶï71^q¦ÑTºÕ’iOyšÜvuƒ$ÏÒ^Wbc”ƒ¤\õ„@}.Wß  P¾ÑÆÿ¹¼ ŠŸ)q±XLÀïc6Éü†ýt(‰?=šÃöle<"ÔUÚj‘Hþ <_‚o8©É®›pÏf{\åà\Cî½+Q\¿¿òë¥å ñöÖ(æåB°ÙqkCBxx#¹ÊèïÞg›óØ_¯âaࣹÏïó€)¿i}A$Ùz%ÓEFØø·LãiKŒÍŠ$û6iÌäã°VIS†ûH©¬2°,E[~j[ÑF& ¹®ëÀXõCÐ.VÒ‚„_Ã&È‚J,Ë4é‘MDVN‘®iÛÚÛò™³~6\ER`Ò±±½ðý‚kØ(y²4¼ÛyÅ,¹pH¹dbmöIa‰©<ž»±C !@fU:Ú]îQÍz—3ß> ›œÕ¤Þ¯bÊ6–ðh7%ç`VCƒM¸¨85sÒ:Ï,ùU0žÒÙ:]) • šWñIûòJSÁ ÄÞhyö; T­!?†-DbGL±Ôšò;§žƒQ˜´wÁ×%xÂñøéš¡¼ Y®‚ lÑ©‚ 0++Íø€®Œã<–„òLðra¤ßÖµ'÷½mfò¦(îõϘvœÏʃÐÙ…ÐaÜNÅܨ‹xø”^»"ýÒ9å`䔩¯y\Á ‘ú#Y–™¦@)±ZÊxÉá0maJ8ØäåîI «’ Âûœj V„D¦vò¡Þ04·ûÉH‚¦˜A7wç{£ô‡ö^Ú êÙ‚æ¾þGõñâú›ƒZxkò?n!Gž Y£9À¹Q7w×û©dǹÏüQ²/bl–HLÞ`atN/Ç5òé Øæy‹)s ûN¤ìÝߧÜía9 ­÷@=ÄÞ/Ó,ûˆˆÆ8V £GhìÇÌ“ºzß].d&ч½ÀÜ žYxÑ:e ­K'ÿX¬ËKÓ¾m Ø’ÍnŸÈN}´e_”*&2”Aá0b4¹•e@Nƒ{ âaˆTßÉŠÃ*iú®Îøƒ 5Ì1xa¼·ÓUØcü êsB§I‚{j׳ü5"íûº³dxÔ¾¾e_OÊ5šK‘É„ºãP;‚ê¢Zw›ÌŽ1Q (f»øŽm¢5¥AÎ&‘„e Ihw%>ó—?,‡×ç„ž™Óô»&–^,ž›ô· ¿Ç{H¯7Ã/–&JŒ¼³¦0µºÛ¯.C9š-•|ƒ0Z°‘.gä2ü,ý£·«}: M>-x@¤E=·Ly¸XsZbÒPJè 6­tïÊþŸÚ)߈ sÑjz+“Ì Ã9Z9qÕÑÞ¨‚î4UMfN÷È"eÅ@×üt„ª¡Õv‘¨6å„#£åF6_MšùbÛaW á̺lxäãåð¨†G=<š£úpøX½¾—™Ÿ™ÿ›ž2ï=¢§ÿÆã#úŽû¨5/q#-B‡ªpÒBŽcfœ³ UDy˜ ÏdX:ÆË×ÛH[“'w²aGÚëCü85éy9 Š|‘E1˜(º’xðP#Nìžµñ'djï‰JÔm8Œ¨?Œt€¢ÇÈRs?f9˜RzUB+×î îpdé/9ø¨Kh“’<¦¨|»}RŠ!O& ÑÈžNõyÜÜ€ÓL~<¿Œ…‚u› ç€ï|ö€;úH›5É©AC¸:µÎˆôû.-&Yû´ÛÚJ;ÏÈýƒÕ}4@+Äþ„INeœò ¶ªï¿ýlR3o̲X-üÇ(É·Yby‹ÏÚ¨ˆ÷˜‡'G;*¹óäÔËÁ 3 ôÎ^ei%Y7›D6¿ú€ªÃÑìKzÐÆŽÀ¯¯RÀ¿„±IQ¿ea‰ä¹ ¹Š+Áàðß¼àÂW×-À°b¯R˜’b8Ñ@Š×Z¢{Ûųq%—•æ̦¯m^x˜¬‡ôŸÙ˜ð]JVÖ]Îÿu&9Ò Ø–Î7ðÂa+Û¿YÏ~< Jî#Ša?¯ _7ÝNßAçx)f4΄²K¨ƒ!c²/qxáƒyÜ äñö‡æf+©jLÌT²`É"@"‹¶/pÃÁuå½ùãýåR©Ò@‰œMñwa6áeŒ9 zLƒ+ðÑ÷± "ÃÓSaÌ}Ä%ßèÓdÊ—8êïoy·äƒ—ùkfò2ÈÂÖÇ©ÿÕ=º|ãŽ0<» nÇ}Z)ï]€ÛÑ0<:#·¦bäÄ«Qn½7¾ëº»³çÏWÛê¾¹mîVWM]íö7Ïñ¯çQ¼ßsÓþËÛ€CzA ÞÊ«ñKF½í“§?ÿcТ‚ˆA-~ áùºXT=EËã•6“\á…¶éß<“'pämt~œHf€µÜœÐ£|XoçþT†T¢IHA–ö·¹Z.ßâ‡4B2?)ü®Ù†¢„ÅXo$†# «…Õ8áduµÛ×i‡ Làs¸îón€î&-×O¾ùþω'¯Þ­¶~ÄŠ¿rAWO‡_ïª-øº«UÛîöC#ôÃì?¼'~endstream endobj 139 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 569 >> stream xœ.ÑýLMMathSymbols8-Regular‹þOúø–‹ ‹ ·ø”÷ðê arrowrightinfinityradical!1p¦‡ˆ‰,›-„÷¬ÿ:f÷w¹ùt÷Ž¢u‹}üÓ}u‹tt¡‹™øÓ™¡‹¢ÿ&€’v÷…¹÷…wÛvúBwú}÷Ž‹‘‡‘…Œû¬8çu÷Š‘…„‹zƒ……€œ0¿;×Vý­|„€€’šù­?VW;z0€‘…“œ’‹‘Œ‘¡÷Þç÷¬‘Œ‘‹‘ÿ&€±ø ±Ƨú §ú÷l÷;÷û$/G(JGÛŠ‹m£Q·LžT‹û7ûû ûÛû÷òçÏîÌÏ;Œ‹©sÅ_Êx‹÷ß÷÷ oŒ&>C62KÛ÷1°ÇÝõ÷ ‹÷Å%7üwtfO9!û ‹ûQñßðØÓàäË;ûåÿumú ¢˜•~}‡‚€…üUýûûPø„š†…‹‹‹…‹€ƒ$Cƒ‹ƒ‹‹}˜‹‘˸÷füE“{‹”‹‹Ž‘’™øxú?‘–Œ‹‘•³ù§²¡¹ ¹  W/ ‹ ‹ §Ž“Œ‘ŒŒ– ‹ - ñ endstream endobj 140 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1386 >> stream xœU’yPSWÅ_ yy„HI^æ}A¥­ZhÛêP T[ÅZD`Œ¨(›, ‘–Bà ‘ K ˆ@X"+´ ²H)ÕJ«DÜ—a¬ŠÞÐkdž©üÑïþwÏ̹çþ¾Ã"Ì,KðÏö˜¨}Ñkœ· =¹/vîÒ°jV=›É>øf‹9ÅÂ)ÁÈ;CVÄÜX¸º­úô³ÏW¹|… A šx—Ö„ aK0„9Á#ßäN˜ÛˆQV"ë÷yì•ì ö#3³ã;d°|³€ö"À`l6\J`!ÙM¶q‡µ!Œë¤Ð´ˆ}܆<åaf°_œPÜ8¿4P¯K¸! ™A¶«îA§é܇võÖìz6ó—AØ?ã34ƒ¬§lèã´QI*²d‰ßgyB Px‰!Ë m‡¡¢ÜîâàÐ<¢Å‡×±€¡·bþZ·À3ÙåÕMÚV1Ñ2æäÕ?êÎõ¸{íêeë<1/c!¶æÐj™òbíbò¿ ñWµ>÷Cl¨ŽN{¼|¡œ®~aC[Ædä)‚»›ÆÞ¯¹©º ·(ÚI~Ëup™ƒû6Ϻ”ú¦ªš“-‡Ê*™ŽëªJ haýX–ã7ÑûÒRÄQ‘Ò¼-¹‰ùYùN¥Ãq¦‡¼Ù³m©˜>O`Á×!~¾^UýaÌé:ALx5Ku‡Ç$;Mû Ù=žxÆÌ3G6c¬ úÈ5¶QÖˆ KŒ~Ü*(ŠOÏÏOË`ðÈë`Núa ¶Üƒ‘FÈQ…ƒ”ë¡(mßåzDXM"µ‘Ùÿ÷ÌÓãˆÓØ­G¢ñæá+ƒf¢qâÄ„ Ý7nZÂn¢V?Ǽ€Ý)á´“[–Û–ÑŒ=Жf«r r2ÅR%²°µ‘šŒBPé Oã.nÈ*ŠTÇŠ ¶µw~†IqâñÐ €ü1A‰QÁ‘~ð-ln—St¿\•¯°××T6µD—%$ÊØëzÃqÅ´ƒ¼|‚¬ÄóÙ¡½Ñßžh«þ4éüI'½'mèž¹…‰Íò Ì^¿W(eà®úêé =½í¿At)ta{òrÃANEé’k+O–¶þºçœ+ã%ØGâZ$ô~ÂÐûåÝÐWÖùcÛ™SpŸrVŠÀ‚BHÂ’‚À"ZRõÒμËÐJ==?z½§ñHØ ¦:ö€ÿ|±ã·î˜˜"«ÉhS°ÃFͬíÿXˆTÆì:–_¬¨ "ÉpÊi" ´¥WÊ‹J ¯Ö„7ŒtÄ ‡¾€Iì‡ÝÖÚg€äìYèÔ0Ý\@Žµˆwn­D¶Å¥P5¦Ùî!ZØ…Ü»XC³»Ø³jdéâ •ùÇœL©´ ´âY©­‡™éæ4™š`Òjç4sR[kÒ,ß°*W8)þïÔÖóa6z‰3Ep,_™^†ßC¢p´Ð'€Ú‘ZÔÛU^¦TB!U˜«ÎH ðÏÌb°=vˆÁÞ€ù€¥“Ø-þˆ*Ò€æÿ¾Ha2¾ˆT"˜JA¤âN¸ÜN*C‘“ y™9`»f¼ðÇ€Û°^ì/I7õr¨UvIEOoqƒì‘ƒyâ¿%¯ŸåéYí‘î!Û˜†FDðJ>q)è{/`!HœÓbB×å-‡]°IõA÷]_&öC7ÜÓö¸–TOß(©ƒSp%¹ÊEã ^°‘²Œ¯6®×¢˜’¢jÒÀ³`xf¾1|sàó€o¡WÎMa¡² hϾ þ.ÛµÄendstream endobj 141 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1270 >> stream xœ•”[pUÇ÷4év)™r;¦NÝ8Œ"¢ÜJ‡:ÅA¡fÀzÁŠÈ¥CZ"­¦iIÒ&-MsiÈík’-l6m¤Pk[Zp†ˆV¼1–œñÁqDQÅ>ðÂœM7OÒ"Ë{ùöûö¾ËïDÉs(„òŪ*µ±þµ¶ÆÚ&­aÕÊeÛ4û[´j}Ê÷(LWOU$¹ Bþq1ýÒBܹ«çáWçSùÍc—–m¨ªÞ³¯Q­Û_«W×½£1j5oïYú†ýõFµ^ßdÚW«M»2ï3Žæf}“Ys E­%·†VòÐÕi4ZM£Fgllеšµ-½z_CZÛ¢khÕè j-EQõ èmŠ^òTÑ‚’¼æg)äFJOí¡Þ§ÞE^äC€º‘PqÔaâûùON|z:òÃQ`Ä$™]4y•¾|-ú˜° àk³³;–®X,•ÔX=./tAç<¸´æÅŸ­Ìàõû‚Ž´”áƒùBùu•xõÁÙlHÍíˆËo H¥ã«níüÓ¿·Ûp‘91dzVˆn»\’J"SYDE’; ~赟«?gŒ9Z{Œ»ê­v/†Õq·WéòÕæjð0Vøt ±_ü}ã.8?af?1ñËÄr¡‰!ñö龸£°ßÉ;ížv»uoÞ¨Þ /CÍÈæñ½CÛOofÅúË[wÇ8÷ë•‘Ïá"Œ7~[óQÓùúo€¹ñÃw©¤Ny¿3ä´yÛ;|¬k[Õ®Êÿ'2ùý¥ë2>H·k9ÁH#¾’ÁèfV?&ÓÃR%•ò™ÁNfõ CÞ.¿ï¿,BîäDNRuqjŠÕ+ÊÄŸMWÓÒc åÝ´âGqÝ=“ëè0.Æù“¸\š…h-•JKÒsR9^$ÍÇe*¼&›südèxíƒIÏÎó~²‰}Š¶@ÙdýàѼYùõ¯SÓϧ7ç¥D¿,1+ºx«Õã´b“k§)i“Xì>âíqB‘‡°ïèZò‚ÒæðùÀÍ8ƒîž‚g¿<ƒw&7÷Xü>ŠiÁÃq÷T¥’º»#Ðä< |­âÆ8v›ˆçeâùÄšôJn»ÝÍ®‘ ¹Òº põzx Ùí©sÈ•:‡‚ÿ<Áu}PÔ A>(`.±X9s1Ò"éh¡T,‰R1s ì¡8—X8tæ8ÏÏeóeo¬PÌE>(æôð¨›düžBŠ…õ/g•2endstream endobj 142 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 283 >> stream xœïþLMMathItalic12-Regular‹ø½øC‹ ‹ ¸÷uÕÒÏpi‡’÷¬ÿ+o–vøÁ÷ܹø½ø-¡x‹yûÝt‹i‹]ZqnkV‹……‰‘’ŒŽ‘¿Ý¿‹¤‹Äu@r49ûCƒ{‹‰‹…v†”¨“¥µ—›¾‹•³Å÷v÷pûzB‹;}‹û´ žœ‹„špЋዒ‹‘‹Ò å÷˜¬‹«v øC•––÷p ¨ Æ  To ‹ ‹ žŒŽ’ŒŽ™¥Œ ‹ 'máendstream endobj 143 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 611 >> stream xœu_HSaÆ¿£Û:éÁt±À¢s"¨‹$ª‹(/º±aI¬ÿMlI´Ì£GkÚt[¸y\ïQgÊ6çtStËœæ¢è€©RK'&R7^uW}‡¾‚Î쪋žËçâýýÞ‡Bš,DQTþÉòr¾–?tpYcUÍuK¦+"(kJ™˜l`4²²®_)Xܲ2ÑÔ –j„Lè 2¢R¤UÏ SÛ('õ'ò”a"¤ð^MQþ4þ™ÎVºñ´ásÅ[cÅU^àÙÆ9s§ª@à[ë›n´žÝÖmЈ÷²=#Á—Q #’ÐÞáuÞ9’÷«E{Mç¨+‡ ‡‹t¡$âuàà̺|AòNTÏC!Fßñ>¼‹+í4MG}ªÒ½ÅÚ8÷õt¿Ù̪^¡ÛŠ>E)öõle 1,%ͧÁtŽu<´ÆÌ@ d¯¸¡Òîáú¦ýr辈È{À+¶p'HLl/tÚá¸oðy€a4ú.>7&O$g!½‘[žvgtÃ}x0˜Í=kàilUác«†pÓÝåötˆ¬­ÙÊ“, mGᦾ~û4[œ»ýn4ÐuGt<:úèÅ¥§Ç‰èÉ™¢–‰ö‰eÆa æ¤gý¾euú/h{ «_b6Ýéÿ±ŠAÕ–¤!.¡[†7}Éð‡Éû‹¥_]”KH ÚJö˜"Wbõ¬|Y†ä¿˜b0w;³7uSïWf€ž¹SÏå¹üJ™ tIºTN:—ÍÑœå™ÍÀä“+‡¤Lº%¯a€Ñ#ôŽ92iendstream endobj 144 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 327 >> stream xœcd`ab`ddôñ ÊÏMÌ3Ó JM/ÍI, JtwÿX÷S—µ›‡¹›‡eÇ÷ÅBgOð`&C#!afFF–Àãß×ðýgJ–bèÞôcþ¦ÓåŒß—>dþÑ+¶)]¥{Æù»ØW¶wçÊyz«v§ws¤°/í>Û}|9ÇŸ^ö¬î:¹„¶Cý7»áÍîCíPÞ~þáÉ&ÆËß¾OýÀücÝwÑ4¶ÎÚFÏš†–V«îÚnŽßþlßE>¯]öäôª•’+WnÙ×}‰ã»àoÖ+¿¥~‹šéFlk¶dÅÜõ ëVÇË-Úwbã…nŽ/‡m­\bœ\½å7þÎmlìêêΑüáÎÆW¶à‡ó¬ïùS'/`ÛÄu[Ž‹%$Ÿ‡³›‡«›‡{uOoO_O爛ÞÉÇyxºy„«D†endstream endobj 145 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 4089 >> stream xœWy\SW¾¿1{UDä¹×Q±Ö­j«Õ.–j•ŠR©+‚"Y„`ØAQˆ‘%É/a3‚ì ‹¨PPŠ¸´¸L­cËŒ]žUF”V«¥v<—çÍ;QìôÍ´ÓÏ{¹É?7çžó[¾¿ï÷{%”Ý0J"‘ŒYé³Z¥Ø±pæê°¥"Övs<àì]5öà »¶ß±ûœÑÒ1Fw;Q¶Ï”7w¨¢ßŠ]矠HÞºrg°Ï¶Pßðíʨ9s_|iÞ˜ù fÌ|¢&R«(_ê]ʃZC=G­¥¦Rë¨õÔbj#µ„šIùSoQ³¨¥Ô2Ê‹šC-§¼)êÊ™b©±”œr¡’(WjµE9RNÔs$^ÊŽÒHFKâ†I†E »&]cggwÈî½·ý Y-=•Þ͸0‰Ãǯá2Â0røÈ¢‘ƒ‹F9Ž õ‘c‚ã•Ñz§ÑNc6Ž¹ë<ÕÙÓY;þC:L @@‚$ŒwvÑ> 6íµâ¤AÚ-³H»?R@—‘‘‚#ßvK‹ˆ_¤g”tsv 4²×º ôjÃ.ÊÀdÌ5æž@r7T(;§çì5h!Ó=j ÄpJº-û´ƒÝP«ehúÂÞQürømaÙÙõ ÐWV-¾ç"ÐìZ?ˆ½À µ4\‡ZÕ‘xkHÑF˜AËö¨ý=[‹=ÔöJúcSº?ËéÍjXNÎ9a,3œ„“P¤ïÒ1½\ í<ò¦YÓßþ|êâ‡Eþ«8œò‹kÿ1LÒK©­â4³¤ö&j¼)“Ñv9rôÆì” x,óp*Øï¾C£¹y&9„»±[T›7')`#(ÌñGcZô]$Í&8g>^×ù~q#œƒã‘åÛ«?P0$a¼^@3̨ÏZ!ì²:?êA•7]Ù©âa¤”#ççàë6&l á.Òì#<Õ–ßÕ¼Œ þqøÌo!m‰iˆø4 »‹\ùy.Xæõâ+!–#q\j9¡ŒAÑ4;⃆3å-ã?랃)ÞqРD ‰½â¤ûÒÁHtKŽVcÍÁoqe•ìšQÊ?®¤CuêE\¼RddèM4ME¾üTØ ×.Ýàµ$q%i,%Û¤ËoàÅFºÁ˜‚{$»Ý~5aï½[¼¦’̧Fw·” ÊçGWýÕ•õ‡‹Nòú¨ºÀU …O<§(cïቿÐÓ.c‘¡K°–D/Ö4ñh}¼=‡dœžÖéSÒ Ž‰®ØUUQU\Ç‘F–õØ0}B@í‚3šÐ}ˆ²¢IVWöûAZ «P‚ýã~J¯ìYz²¶ì ¤{Çà6Ñ2B$=;«œ¥£Ù}²{‘óy+*UÉæ«#§qsP®ìI¢ÈY†f‚yM æ†$B)µÉÌÈR)ièD©RQ†ÆÊ¡-©&¡jûá°ü7Æä..‚sL}UËmDå/ˆ5r†4È(æ ä—ñwéC`JËÔAZ*§Ói4™ÊJeÞvÛèD,ö‹<S•À7(›Ó;5{i+wØgN†æÅ)°Ç#æÆé4N{@Ÿ—ÌØ·“Çcé] )Ì3ÊJ¹œ¼‚¢ÜÜ–­íZ3AÊèÖO.ódþ§¨©¥ âdArn@ôê“f¡,¹@{kÕ°¶Á<Ïf”õtvZ(¿’ÆŽx¤.ľ¨ Õ#ï®ë÷ðÄó«9cª!“$Q¹»·¿ÐÐP}Þ@Ød‡6v@ì„`ÒrºXW´’ E£ÎÌXñšÛë÷ÓM:#ä»CaAa•m}ˆ.FH6ñ…m¶õWÀ¨k÷ýËݦááW­Ö%‚»’®%JQ õP¯¯·1Vl¶ö€l8X\Z-XêÌuŸOq+Kd€zojœM\ZŒÕ†V²ï‡pTk#M2Q_››Ì(´Eòè*2j~—c¦~‡¼6…GÇqè2ý”.Ÿôðq¿•n:/ly_uÜâDƒ6e¬ NˆÜª\R×´§ 6nÜB3”4´w”4C+‹³(,AF_ˆ´ ƒÆ‹bÊ }Rñ"a*™zÊ쌽€yiˆøÈ‘9…·¹zA® Á°| ”¥ŠþW­•=í V˜Ï ¢Zp.¿±ï†+[+'“Á‹Ô*!T 4¨Œ¤í:ƒ,PgíÍÚ7kÜ°*Î Tàni€ N ±T«…Õ¤¤ÚmP¦+ŒFsÓn±¾ ëwxyƒ{,ì*Òö»ýëþ†q–ä’øØ)Ñ-¡§þØúÁ™j-_-°”¿dt'“wþ™<Ôx»Ö*i¸‰¶ôKÅ7ÐHy¡!èvepñËÖÄø³bá)"³¿8Ñ]tZÛÄ'f%íLLy’ÅRqH¸°´ùEOôž¯G£Lœã‹‡Jé!\Äå_JtqâéE:Bëb%Ýd,¸ÆU ø5Y"¤CúNÿø’Ž»÷•ëÑ„C^û‰·3éhð úpÆxÐÐA4±XÚ†08YËõ´Á€ô§rSs4…à^¹¦Êtp3èí_þ‰ó»³/C1äA\ÂZl‹R¨4C Ò˜ælŠEêpàæ[W]Ù ¹bÓ3ÞÒìߟÁo§3ó»^'\=zÂóXŽÇ<˜‚F~ÚÖZQʯ Ù©rµ#³¥ÝÈ°ÙAÊÍÉÁム¸:¦%¦U÷!‘y]–c•õÇ….hc‰5!…) ‡d›®\˜akJx5ZôÄžh?~Ú•üÌ<Í^mz–žÛî1W·`kM|CD‡¾ZÔ,«Ì…Šï×|C¼‹ÃÌIØ »þðrDŽªx/4NŽ³d&4«¯Ä g [aÀcmG½2‚ ]´P–K|™ýU¸•sË•,t”7‡^˱ç__èûé×”Ÿã¿ü™îAŒ€G"{š{»£­•c'€ºÊD³c™˜²æšÒ2‹«N‘SUwVtQp>6}0@tP.fÈïOîÅ<‡ñ¿9›­¤Ùw²ÛÎBûx¶³ÎBQî!8¡4ô*& ôÞå=\ïpx2ª|*Üweh!¹È?³¡h¨ÙÿâD#~Ù‰¾ þáÊ5ŒÝ•±­?çž’ß°¢¿mD%¿W?퀲墜o!êe=3Ê#áxgååE)͞Ómg^2eàU<Û©ÍXaxJ|:´ ë¶F| ¯‹«ŽŠŠ‹‹ŠªŽ«««®¶¤§)´ekOönB]†"ÿN³W~5Ÿv8‡ô¶(¥~;©!ûk2ða¶¯+›5Øc«Ü†ŸU®¬M ;º:1¸póø%à¯P­Oû0¸ñexü7$nfôßÊXëÿÉÒç ê³÷»Ï”n[úk¥üçâß\úTÃIÕ›„KI”tM*¾åB,à,-±€âYÚ¬7Ær>+^%N.ƒópÚÂ<>H‡jÓfq‘JYcö-8N®>hÔ>Ûì 4ðp@t>D‘w¤âV´”Ȇ.uŸojJ†fV/“Ýÿ-@ÏwÁ€;¢g|A^5è×gÏÞØšiª¬+i¬K¬TfjAŸÅU_½T˜#3–y,Z°Ç+°¿š2Ä»‹ìI°~Ž(4ÑcẼ fçV$ A’h$¹HFÉA-F Erè]Ö3½¢ÿÈ{ŸÂæÚüîI“^÷}#¢2¹¶¶¢¢–cO‰+ÞÎYZΗws½dù¦¨Œ€Ø^®Û¡cØÞ.]¬ö×è÷éAͤî‡CÜ YoóÒx¬W˜_ò´Üž@¾1Ój†æplŎب݊¹ý˃Æô÷ pÏÊŒÆ b©óùÛkÖB¹à!úÓ埜¦×ïÑpøCí•È2ÔWíÉ%(e³ÿD$/>±Ñ´@{Úøå&ý¦ Ç C Ê쟕I¾~m0#×ëõIÎ…]B¯ðCŸ+Ë©I 6ÉѨy÷±$À?%,œCé:)Øìð'·ŠL9™Di35ü¦äÍûû7—íÍÕ+¤ÁÞ]<>A³j'¨‰;Úµ²sòLu-'«Oóð¬0%ø¨ùh…"y1Eo7Åõ0ìi òuùåµEBBit¢*-xö_^@RŽà‰F}ÿ-r".\Ò×K‰sÑ:DIÐ*3Zb–¢pñ†üRL‹"<9::º,úHQQŽ©€3 34Ë£Þ äu:"þ™Lf^zþFÚäòÿyìYùTwÐWæëwŽôÜžÝßH~éý!·×÷{ßve_« Ú"Gì w±ýª ðU* ÎÕœ*?ÞñA”C{VUÃ:9…¦$GÇ”&Y­e¥u> stream xœÅYËnÇÝs•,³#$ª‘8Íz?lË€N qf¥±&9¤:žáŒ¦‡’Ë›ɹUý¨6¥E€DÁ~Tݺ÷Üשê·Ç¼Çœ~º¿ë#~|}ôöHħÇÝŸ‹õñ·gG§¯”Å“*ð ŽÏ®ŽÒq,­®¸6Çθ*(s|¶>zÍ^Ö»}s3›+%ñв—ÿ¾˜I[4{3ã7Ê Øj‰› ­Šíf?ýË•/#I¬1Xêìòˆ™ÙÙ?1D†ãP+-˜k-ŽçÊTÞZôš½úf67RW!HöÇÍM»_°GÛæÑbÖ­ M6]@-áäñÙGgO_3ASMÅ¥`OÖÛ«Ý“N”–ìæv}¾Üõ¢ Û\ËlwË‹¦m6°YpÙWÆá­gç;K A¶ˆ~­×â§n5.™ª„†°PÆ”T^CG­”WÒÃ¥÷Úõ&„C|/uÊúÕæZ~Ê~ëÿïöóÊ%´ž‚6Š Ç()¤ÐÆ gõJLF‰ð•Á°^ðûcÚËØr6§ï´EáNÜ[ÃîfÒÓÒšmnÓÓ`$[×ñ±ðÒXÛ³ Ýì{!α—húÀ.³1ý¢Â[Ϯ⠴÷¬¾70T"ü÷Ýl ¹¥pŠ’¤$.•s\±‹\P‡pTUEüãl­ÞIYW(Ò\ü“Ù\sa®»é˜žë5ñ–­7#J’íó|­oºaÒ³··ù‹|Í]þf[¦{'×Ïw\Éd„§•®3yz’IUðî´ç™»o³k2J©d÷ªÝСz£Ò¨z9ç]Ùò@>Ž3!Úk†hŽ¥ä„A¹.»ÊÈÄ8aDW¿þê×AðòJjÒ׬Žè“>Þ’(ÞönfpÛ¬êóC<ãHx0G©ÝÃSƸetMvh)E&’À–žn`‡`íênæ£M=ȇuVhU©àqQy)ÄýbÛÞµûåºÚ7ëå‚ýØÄäf_Ï'«ñIŸú¾=Þ¡<¥bµÀÃÅŒ~&k–A±@Ñï éqÛRm\SwšŒµj¹ª·íò2 ››J*¬‹ù}="@‹X´L¼æÙµ˜„WÚòÐéA=ä`ð?+¹ð©èkn8¬¹á¿è9"8a)J”3XÉK¹ÆDÅV#Y½•Ü”é¹B^…pŽ[+ÚsOM^zL±V;°g I” ðA‰ ¹Òk/0WÓòZpé¸Àpy¨¢&XL”Õ4V2å½€¾ˆg¬5r $i¸…FJ9o:ˆ5Ò¡^ Ê?M¯0¦@(nAF+LAò‚½p'-º 锓hFŽÃ n•0 :”"a þÃ~¤Ñí„Q€kâAàÄ$"G©òF -±lDú,4‚ FÓHÛ•ED –(Q" ™ %q…¦‰v"Þéåûv³»ˆlõÍCLs—ùêA:Ú6ßê(ÖeÉ`"· ÆhÚ„* <+XS¢Éè"ïMîÅ~ƒçˆÓ´îWOò¡.¼°ŸM±&ïÃøkÀXSŒ›<†.¤…%F5_ê¶"—oB¥¥•½üW뜰æŒ~zߪD¥‘éýtbàžðb…/;Ì!®WÍ¿òûâe6«dç½u\§ü¢A*”{ˆM¤»6äŽp«Åø¸Ý¬ró÷M)'´; pÊ@;›D 9¥»¸Ü6“ rŠ>Ó[ÝÐfÁ§¶?HÜøùœ§jáŸ{dŸ&h÷ÙÍS¿_¤- zN,$œ¼… UÜAzM;ÈwñP†ªËAóù-ŽÅ¾ÀÙÏlq zØá¤@t¤Q—µ||±;Ì0,v‰«»N*⳦ø°ñªÀvˆ ÏŒê¯ïíŠc<¢£Øˆ¦3¢G:ž+7ùtWÇÓ©âiÁ¢·=½$Û%™rGšÌ©0Dy4 Žâ)'‘ƒÀ+RÐéÉ,ÜPptc7V„f÷}]_—Ý”r'nàìÃÇ›ë‚?®Ø¾^w¸À{¿kïÖCÇ3}³*—ÿýdÁÎ¥Òä‘i+0~a{€³ uSóÄ|î06ãc‹-t¶AZ²2—V@-vJäÞæ—aøaAös¯D ±>˜…ëTW(C·ÚeKV=P¥Ñ–°½êÕT‰œƒ„’GS.Ñ9/HSaúT¡žgÒéËQj#ÖY³><g¯*ÀÐÁïµBÒ ,ã°äÇEtA7«U§5ŠñûË‚`D>ã6kôV¡#I#&Z2)Ê\(L//ÈYÛëUž¤¥s…yﻲQÖi$öU°›Õ•ÕÝ=v-ÓØ÷u^´Úö ½RéPg›|®eIä Ƶ¯‹Û\تÞu€í‹¿Òìû—óóü\´½ïWE P3_$ªi¡æËNeæ/Ÿ:¾ˆ’öIâ?ÿ~Yz¢¼£Ñqt•—Ë+&Ò©[ß÷ˆß?ñÜmêÄÚ)c²À ïÅãÐú÷0¯„6~:!¯[1Ñ0(Ü=K™¯ž½`°/fÉž(É­dOg^³Sàaw e1*uÐZ×ȸØ¿¡ògtd™/f&~¿‰ž™,.‚vý?}Õi¡žÅêE³H˜ÃmE*¨q¨µå9óƒ;œ&ªX“</ì¡ûÆðn¹;ß þ&ÚƒV•uÎg³×yªNÕ(lÑÙþ$iOó!ŠzW†å@6€­Òê §›¡î¥ïu*:ñ¤•´ÜþäéwCA•¥2O°'U‡ƒíëþ¸[ßµ(ÆUsý&Š bûH®ºóòÂEÜ«ÓQT¿G‚éLÞÐ>mHó»á`›rÓkèØ:uÉ|Ö‡Þçéùåä—2:¹G˜øT¶m^‚GG­ù±õÕíÍὈ‡®Ï±ãI}•¼²[×ú&kÙó~_$èTûd<ÕîbìùÙ«|G•#òìר¦""Cw"­]·Ù’£ ¹:‰ðÉ¡·ë¨Ö(U±ÇÝ+Àú„0±Þ¢uÊè iÊLNl{Ù"ʵîΟ'¾Ý=~<ê3Ï`¬W«‘r\.wÍ»ååO’׎âÇŽt£Ö^ CSOïmÊλã«Ùzö¤ã5¤Õv„¿,òÙ8¤}»MZË„­jØãñµ/ïMç”NWà›ºª…î¦JBÆõß¡—äü<:æWqª›:Ñÿ0½Ä‚Ý=§w£žšŽ#È„Sé+àTÀñƒvËí²†™.~%u!âw[mV—£s‰ÛAàCk6ûgâ‡Ï96{üt¼DÓ{ö!O‡ÓòÝ]1@6W‹>MGÔ»¨ÉUÛ]s³Ç€GÍþùòòd¾m~C8 …/Ú“ñùÇj^}<ýX}|þÅr±¸yÔ}ÆÄ[3¤}ÿ!ªÙg¯6(0û—éØeX §A52C…AR.œ–ßÎNFmÄ> stream xœ½Z[oÜÆF_õ”<öm¡œPÿvÿ,Ö³ï/O^¾£Þ`K,]Þž„-tfèLK-—³Ëõ RóË-W)­dX+ä—7'ïÑ«æzN0‘\SbQÝ5eS¯æç [#Ы9~†q´˜ŽÐr"MÿÁP£ ºO84eW¹ÝÞHôÃv½K¡´ÂÔ•]½ÝăGŸêînOúËå_à&»¤e؈(9z7u7‰–õ—;Ÿ‚s.ΨJDÇ’ñÈôó.»ÀmzÓy2“€KL´ìwÿmÎ &@Ê…W¤dè×rDPL)¦&gÔÀ”ãQpE°$bV7£TàUwóB2àO¢gîY`kÚÕÿÜ/\Ä÷†"Ž©`Š(-¹T1x&ÚM95œPc©Õ”Kň¢™ç*Ñg\àÏ/?ãÏ…ÁJ0ÍxUæ/L)ÜBÂ]:¹üÃH*ö…RQiáîÄÂB0N„ÕZ2Æ%e„s«,m™L*£„<”ŠcÆ´•¤^ªQøsD‘\«-gܧ5·–BÁª¶‚p¡ ˜Öô„( úåD±Ó¢ˆ¯L¢À} wW%ÌÆbL€’„RêPpf­0’ØÊNÚJþ7¥¢Ê‚θ–ôP*Šµ †©ªôIRÿ'© üüOõGB«Ñx£èÅzwÛ¼ˆg †6÷ëëªée“h{›ÈÙT‹ºõ`F‰$¼ž¤vÒ¢ëºk‡ÞÓ_}þ5µ±ZX!`#'ÚP%GŒ¢ŠG8b6Aª°6dp€wÞKýÝwûg½A0ÊQS­›?Vý‰ª¦Ù6S¶K¶×M¢¢?û5º·^±ÜÕoAËWNag½^ úX5×Û¶ºøñÕOÿx}5ï™ôr¿ó‡í¦í®Ðé®>=Xª w?vÛz³öæn~þÔËöçûuÕÔ‹+T¬¶Kv…Êëö*^ýjî~ç€îÍ;rÌÜ€I‰™4îÓ³p<óÉÁ+Ü>Ä0ÃóŽÂ¤$LacûŒ‡ÚêCP)ÈáÓcÆNZl$R[Hf„pƘ·- 6y]}É<3t_mUX/ΣÐy1R¸®œ y8ëÍÆoP1·Såvá’Ës{Îv”ÛÏœÀÔ{”,±vðüѺJK•®^8Ryô“®|¸?, ÂÊ&YÈJŒªu|Á)šÊ?8ùrêmʧu+Ö@0ƒLÍýá ±.ª` Rº |!¢k_I@G{K´‰p6ñƒ½äj6Š+žªÑ€DݨJò:“}Ó¦%S¯µ m¶ò”Ö‡o£²ˆŠxXD2 µò%ã~Í ¬¨EŸRáÁâ º‹n¢(ªÛx2¥p‚3$upýÎ+´`’c©œßÂ_¸[Ðϲ—] (R/FÙBSgå±Ì‚½GeºÇÔHÈXïÂ'á‹BCn‰P†Ö°ŠE"•Eþ5úäÍO88{(ÈÁ;â(çúSÂõoz¾h7/5\~Û¶uZ鯪xølÙ,Sí÷á,¼%ˆ(|[P÷âŽM½ô$ƒÌ€«G½¤­xW¨óúÁ-G×ýCxîâå!1´ÐµÔË»!Bº´Lß6Ÿ•ÍMÞbxS¦D`î¶}ã£QyŸØ­Û®Ë.7q¹ m’ðV^NÀGæ&a¡)W.º!R£úߣñÌ„A¹ø{‘&Z‘`£žÆªh.žëjíUuh³wˆLóM‹¡UÜ'¹7juay3 ?{ Oü³ /Á(·Ù„Fë›AB·ØãO £)í³¸uZÍóÞÞÁ¥434Oz_9ã©LíqH=+d=Fi8 šP,$SŸêßy¾Z+¶÷››z³<ë¹eY:](ô{4oí#y]i¬4Ñ‘ú,Rd ð#A´/£rô ÆÌ2ûY>ú ÛèÑëá>ô°°¾k2ú6……UWàŠ[çþ²¯ ¡¶{fYYBþ:]fvQz>%=°f¯-×ý]¤:.—Geêå5I¨˜ÕÄ}Áæ&IþP‘ãb®§¬$ æÃBÖ˜ÞÁ®ÖâlºeTÛ×nŠõ½kC¦ò–Ä F$Œµ@Ä…&˜ºª§ÆÏ“¸®õþ9 ½\ûÊF2 4¢„Ø*j}¶Ö˜â“w ÝÔË8â>Ê’9¢ºš'ò!sïwÛ§v?1û™j¨ØÏŸˆxtª™˜*Ž´ãa¸G]WtRÁŒdùÿÔØì=K <ò°äøÏäP÷=?db ‰<ö£&'I9j¾¹yZ‹1(¡ûb—¼9ã>ô#„Ack‰¶ëד®O¡oòÉÌ&©Ê²J¬ÌÛ¢oc'dqÃ!õ“¡?D‹‡[É(šg¼Êq³ÄO+†è®~|:T !ä_óµg}ËÈœ.#2…=TRùuW«Iá ê> stream xœ}U{TS÷¿¼¹(¢æšÁ‘{»éŸ­Øº‚âd`£¼ÔY *¯BÁÈ»Dø†74ò á™ñ˜¨ÈJO±x×ÎÆ¥P§Ieè{ ú ãOf$\Þ Õl/¶D.>!W²ºLÖ7ÙHäOÒ¦Kß8}\0ƒÓ"ÅÏžcçÀs9ôNÄ™Q£Ù–?…â¥hݶ¯1‰mnx–|éñäÉ—„ (—zÈ||}e£ÓSÝúÈß“™›€•ÚÁ¡{óJ Î|’uÒšÝ_mÜvú͆žé‚šåÜg»ÿ'÷8²9±G>Ô÷SÓˆf~âáçwÀ'jb€ùTL¯¿=8hþ„Û¿}9ü8'ê5#ƒ ¢•šûÂùÛd=4½* £k Q×…EîÏãõØñonH4ÒÛgldqr¸8#Q`Òfe²•¬nÜÁüziÈk^/{ËF& ö½$c–†<Ìß™«Çœh/^É;Jû"jOü:8!$Œ¹&¦ïwäVÅ2›%Žb‹÷Á…‹‚ŽœHzZõ`x¢´ K™âèöür šjëŒKS’ s(ƒ“sNt"­•Â?ñÚÆ“å;kŽTÁ ª­£óátIxRS¤®Ï×ÕõvT\ FErn20gšÃ@-èß­òŠlVtkØÎ ¦¼Ï3)Útíâxf膨ØÏC-Ÿ¤0yÕùo)ŠšÝ$NU»¾zk˜þsïåw…d€ª~¤vÜjÇB{c–´w‚|j²Æ&tÏ?Uø^¸ÒÁ fñžÐ“[?PÜÿðjK¡}¢›¡Ž¹»¼±à.î{NrÓŒ4ä)¾l2I]T–Á ¹x4x»Dü&6¤˺Šnè(Õé‹ôºË ‡&è†.å(@XtI¦>‘z(ü(:ûÀ#S*½òžg(¸êÒÜlmÞo¥pR"5Ý•s ò]_ïìýã“n´zYD÷Ìh—¹xì¨@ë;á:‰¤­JО¿¤ÍÈcT¡¯ 1P/úOÝ4!1rjk,(¬dË t…WÙQX=el¨iûx3œÆÞ¡ø¹ÝØqÊ9°´Úð»¯kÙ…úñZNdD¯ ^´åsñJHbx­¸µE¨”P}öyr³´IAØÏ932ídnUHjv¡š‚’ì&5¤uŒ|Úùhegµâ$å|ÿGŸÖß:åÕ:qY|q¶>z';i+&Á¼ºŠŠúÒšIÔ¥«¦fUϾ¸4£{¢8IÏÜJH_ì_ù_zñ™VÙ}¨ŸmõÀ–¾ˆ×üÕý[sß5cƒEd^_hÞŒ^Ò]!a{||ƒF&Y,Ãæw3KÍùû J¬¹Àjõ&q%¼àÆYM!™ÿVNë…›Ø÷rÎêVC PdºržŒqV«š£Ö5ìã9C¬®ªxŽ,ήLªÿ rŸõrÖÇÀÔoõÅWY¾Ò(^VÒ‰[p ¹p’A j¸ëDö´ eÆxMîÅô\F§/ð¿“}ŸBýdcô {ÿ‡ÂÒ¥<]±#–|ãŽÖ é;_´²þˆ‘Ò{qyyÂ`YÊõjzEøÃñ –Âå‹%U˜™ŽEa¦;Ñ&ôÜLuUy \¦ªòj“•û‚˜_*„/(Ç,=ï«G{«‹u$·Ò¼ŠYiªp°‡•à°ÊTY§+ÒétÅ:C©ƒ8HâßÀ¢S„endstream endobj 149 0 obj << /Filter /FlateDecode /Length 3237 >> stream xœµZKoɾëdìPný~qØEØÄÑ"DQÅ,ÉÑ’#KÊïÍIU?fº‡C{7H샇=ÕÕÕõüªÆ?OhÅ&ÿÆÛ3:Yý|Æüê$þ³ØNþpyöí¡a¥rÔ±ÉåíYØÂ&\ËŠJ51ÊTN¨Éåö슼¯÷íz7 ÁaQ“÷ÿ^L¹®œt’ÜMiE•0Œ:²YÂǵb‚ì§/ÿÇ0‘Ñ­RpÔåÍ1ÓË"‰ÊIfR²ÉL¨ÊjTW¤>üð°]î×ÓåU–,æd>}V,³ÚŽfy%™áá´+òç[/«´Ü9Ò.svp9n%܈‘‡ìB‡ev¹ÉÞ\À'*ç)hªUå_™&mƒ|UE©&û‚® Ç('­%ût¼q l§‚ÜfÖ‡6Òç$i×FÔ¢RFí~ˆÚ-TbÀºÒu*™Y¹EA:…ù@¤^¾z3ŸÆí&õ~ÝæVß–[/üO͵æ†tÊÀåФ+Àuâ5[/]h‘ÿXÖM8žIÃyé,w£~Ö¸BŒ\Š’g~ŸU¼XáÐÖåM3kí³_c.Ê•;ÿ *Aw¹ Û)\LÀ@q3tee‰ûC/q¤¸Þlû/¶¹† ²—>Ä ç¹ŠQ=ÌÚB(žÒE°JØ¡BžÙªé œ·äoSHP° ($Õ(ÅÐ^'ŸÖ¹’;zÈbwÙñi݉#O4»S¦n“÷d†„Yu´J—’'Ãof»ø4 ¹ð*¯ƒ”^Û•WÌL)%ÜXþ—Wƒí Ä'˜ºÂȵƒÌ•'5² |i ÿ>àf4Š‰éÌ‹ÅJ×iRí+58ãe`e²:ßBz»ß×Ïç'ÒÊ%= oZbIhðëÚš•î¶ñ.ä¬Täi±¬€äyn¿‰e] x+S¤¦õ*¬cŠµCZ1(«£@ôGØîè.EzVšþÃɾn˼ZOo WðQ3EÕ ¯…ë§z•×™˜žX‘žœ­¤’IÝ«<=ŒâZišÌ^ꎛ8Œí­. þk‡% p€a.pþðûéLqé/y¸kß/Û»ææ0Ï"kÚ{QÏŽ`fÄäòÝÙå×Wäû‡Ý5ô:rÃòœôKsr_/Âí)˜Â›ÅãKƒÉÓ›ó·?üý|úÊ?^¯W?㳧Ð"QÀò¿ºå~#úqÚ™ùtXØ‘ð'GˆÈ0 p¿bAsð¦; i—7I1ÆÀªÝÍD’®SLiŠYÏØUÜ1[FLðÅôÃH-0)y§ƒ$0œÅȺ=DÇ÷bÃ}’Ô1þ„Q$†œ#Ÿ|tP>䞤/’ƒ`•²¶·ëÔi›ý¶nÛúîV¯³Ÿcª0ª2¬Ë½ß‡2ã0/ͤ_²ªéé>«"›à ¼ImÜŽZT'Œ~È„BH±S†™…z MÑY¡h­ÒÆì`]ðØ4m;ŠR_ïò|<÷>¨ZPNiÜXMIæsÓcP¾ð7EžTê£êüQuU®£t‘­Æ2:‚ºe¢ÿ¤p–³.…ÿê¢ãaˆ¤Ø PHÞÏtEgИ yüb¼E^FÁ3hÕ&’[*¿¢•Ô}ӕ˘Ûq—­/rgì~¨Oˆ¤óh;V\ô:Ê}!!›¡c*}*\l]BZôf®} Ì¥i×x•\æÙý?PÏ‚Ó)Çk2´!O}v¾Y¯ ïœHt Ó!ïü˜{Ð:T;h‹òÆ’…zsÅ eNé:J1B)Æ™ÊRî­'PcVgz”B™ŒÄœ ‰7= D>QÈËAÕÃһ/F]½Öý˜ :q4¹&o’`œüðã»w£ò‹Xä“ Upð#@.™ô]âHl†t›m2ؼÁ¼Ç¸‡Qw§¶ï—ñlHÇgã:9¹wsO¢ òiåf€ñ^ԛǰºNÓ4âùð½ßowX¦; ±ï€E³EÍÀºZaƇGAgMÊôÁµ­À!’~/ïð2‚y£Ü,oë‡MÖºµãfÏ!7Ø¢þ“Ž$,Îñ1k}D,ÈM˃ÿE–»æau‡Ï6Œ…¢ã % †##ÿŽ¢B"#Èò><¾Y–ü"=zÊ21/€+Í Ž´"\‡gP&îFu:¤¥§…Ÿ¡¾,JÒܶË]â,H³Kœ!³!ó—±’´¹ù›^–þ.ÖsØ6ñ\ã‘°'Cÿªw‰™&ÏÍC·DÝ•Eê1Ë&¬ï!]¨2K(ü¾2¼G= ²8Q!\¥x_X*ˆSåKùc(‚òCp,2Á'ï·ŽñÁhuh©‡þ`6Y}]ßÔ{lÂüO`ûÙÑÄÑéÑ–?ËëjP'ðs`-ÀÕ÷VzÒÑ ­ô¢™ºàŜŸ1 Çä6‡³øž:¸3žÌlŒAÁ¹I-“¡OOr爓OMÜØy¦ÂÏÎ=½•Áüꡃ³4nMáA ¢>ÞD/ûëpz‘»Ùœ@bç×* óé|êoC,¿°1”^îA‘&¬#’~ì'9Aç„&zgÉŒPB[§ýªð­L£˜ai°zhÏ JØ¡;SDr¯ÝÑâ¥áöL¨>bÑqho$GÌ`Ú1øz#ÐÝÊWB>'ØBÐ*ÀøyÂD;²® tœçÍXeMpòúÓÓ'BCaUÃç娻0Ðæ¡È6’4®ÞÅÀZ/ꢱhfG]3D«Øs^ í|ron?UM®•:^õiT§•á¶GÞA„Áœ—å9@~HÈq\á³gˆ*l©ËöÔ'>Ȫ»(¬âÁÝ€àfOÇÊ1ƒbĬI‚]÷¥á¶¨cYª¶Í:Ÿ!D)&{¾7´2–l•w#X¯ýõ¶ÆÒûn´ÚDãÈ}m"C'!àpÐEæÖmÚ°Žõ±N{]ŠUÿB‘¶þÉé²jÐÑîâXÏg®MÆg1ÈYe.»n¬-0Wv¡½<Ú@JsÙì¿ê«TФë/ùµÀæs~m+­ã}äžnñR‚HVlöûâSã!Z‘Rsê£~HgÇb;Yèl ”ÙAýˆ $7P6Ï£H’ LÝÉoi?Þü¶o6ÍŠCWI»>PÙ"›ÊÓù͘ž SL§c¸D¨% žŸîJÃùÀ-X–Ž"{>­¦!ÓC%¼,,pÛÐI†m€xõÕÑ(¾ßlžãÃÑOS¡Å/xùrði>ì…Rìÿ£‚VÇ_4P2XŸƒûûoÊ’“çûÒ2®½P*¾ÐuEóhÛ´Ñ€P¬EŘàÚ"ëÔÅ0ó„ïàÓÈìè닾ÞÖÏ×Ë z€M?§xÓ¿þþí»¿~wj²dÓ ðõØ— ýR† 5Ç’§äÍœünÖ/o½¼‘ Zë'#œü#mç)r>ýš!.Í¿Qôƒ…‘™ÌSÇéo{~³Áw?µìôÒ¿e1TÛô_"3[Ðä:¯ªtŠR¦û@å¼é_a¿ØQêCÔ¥¡Ž?Ù¤W(óûºÝ¯Ÿ^E±9¦ÚîÞ7ë-ˆ›ßŽaTúÙüœÈÎ.Ð6ôT,ãÚY.b6gTQŸ¸•¢ŠÈuªõÌAþV²B…4>{•æSAÀ¹(@#€ÖRHpê·Fr¾üFÐØÒdŸúÉUbéƒrèÔ%…í´VW”Ô MyÆB‹r¤•Xà·ê¨PÌ1Á¦‚Kxøm—ßÀ:ýò¨ ¿åH; WΆx†âŒÐ ãÐñ »±Þ±“ïw5¸Ü¢ÿç¸bû8¢gyòYþdëÒÿ’—_~øñ»î&ß]žýþþY‡»‹endstream endobj 150 0 obj << /Filter /FlateDecode /Length 3370 >> stream xœ¥Z[s·v^ùd¿w:´^6âw`ݤ3N§ÉL§î$ŽÞ¬<¬)JÚ”K*K:¶úë{.»À”ät<#sÀÁÁ¹|ç‚ýmN+6§ø/ü¿êft~3ûmÆÜÛyøoÕÍ¿»˜}ý– xSÕ´fó‹ë™_Âæ–Í2U-Ôü¢›»¸øæ ÎU¼2ÚÂô‹«Ù;òº¿ UÂ0Z“öÐ7}»¹_,…àUm%y½à@ÏrAV‹%N¬U6>Xfµ% }sXãj oùû®»KýDUKkÉ¡9´»mØH ò±=ÜŽS¹ø'2n³CÖ¼²2pNÞ–Îf**eÍãá^-–RC.Êd°î·‘4£‘Éçmv€ëô¤‹ÀdÆP5*®þqÁmEa>iVNŠ“ÿ47ž͵æÆáj^ƒ¸FK¡i¥¨œ/šÕÚÓzÇ~Y,U°’AÇ' «,Ñ”'O5b±T8a‚0N¥¬š9“•š;NmeŸ/%«8UÌo"*XIÝÏ_ãaèJ+²Ù¼U$ÉH×n×ð§]5÷6Ș’|Ø®P³ûäÕyXK iú÷‰‘áKÉÈ]¿^µé‚u`8·òed™‹J«`¿dAwÖ`AÒòÚé˜G1“ŸµI|­«õ|1?õSInë`foà¬ÞÒr^8ÇŸQÏ/Qp˜›~÷!áâÎsWᮓש'lî2¿r2Ží)XÒôð¾®…{Šç”’\0sò§d`›lMJW£Æ¡Ö™wïÛ”¡›xjKºG™òlöæЦγYM)ÐxêH™Ú½ÇÜEjrIÞüˆÃ€oŒòû·—‹@’JI† ¤[ç²\%NçCÕ/-­êù’‰J!p8m¶U\j$ Suí¤Nœ”©Š[°€‹Í.þ8ñ7t9édp³>üVp÷fݽ_÷ûKr†VtÌœÈJ-°`+¡KœÝ¹0åä¬y¿?ƒƒ2EÉÙ¾½ÙÂ×\ÁÃoýaxX­ÛM»½9ó(Aή7»]£ŒÂÓ¡Ç-ñq•îÓøª¸“ãµñ[…¡¸W<Æ];<Á*|*éJ°t3 ‘,»i@u£Ðâ£WÍU;<;Íúø¢µ¬F‡¬ûãXGç@çTƒc±éž ŒÜœŒ‡¹«xƒÃU(ÓÌ?³‰×' qs>µnÇ°v¼âs‹¾b|‚(-ì\Ýîvûµ—hs¾- ê9HáwCÔ‘ÜÐX?:—w… $C, w»Õí#{‚áæ]1vxiLc‡ 5¶QÀõŸ®Áö¿é‹0êɧ‘ò%z`b:e½¯,êZ×Û à…VLÂBŠzBÊ‘A:jTò¤ äâ)1‡V¸†yæ% ¿¡>fVÖ‘æKQI-­t] { NÈi+í~$È’í¥*&,·sÌ*µ3òEQ{ص0 \½+$¡ "H¨ŸŸÆ÷aV-“†XLˆ Ñö­1A/%‘el]˜úÊ9î­'¡|ß…c‰´!ÑÝm@Tízÿk‚ç}{ÜÕÀyÔf›&3_b/ÊÐÕÇ.•¬Œ2£Š¾~«t¢KUmX=—ØêóÚ‚Xq¬sQq”M*&”˜0CÇªìŠ !£`›e²Ý«oÃvyg‹U õ¸_±ÄŠ¬Óœë<½«¸dö!*¶‚ÄrÌгw"j‚HíÐß=IÕBVrL•ýe'<ɇó ¨µoºŸ'¾(É K)轓r C°þªDÅÿ´°Ótó¸Ñ³¢ Ð1®’ ,™‹ôàC Žµ :ÃC`ª;{7œq0‡ÓgÔO8£|ìŒCJô´3¾ÄIÿ¸˜ý4CwŸœÑù3® µ”z.¬„˜hçÝ Jlô§áÍföóg^½@æ ‰Ð4 Ø ï_>Ã$¦M\ã3 qÉÖT˜eÙ¨J€zØÈtù¬Ìƒ¼whŸ<ÁqRæ“k»Z^O ›JˆT9Òpé?®!êJ™)çŸáOçx;Íï+‡É©*^ó2õ(ØôK|¼wp0ôïÝ!FçeGsõÕþÒÌ_¡©:Ÿæú^Â÷žx/€ 5ǸuÅFuG7tÜÏK¹ xv%4Ã¤Ä Iɼ$ c„ÆÌ#K_À¦ÆrÀx-ÙÉô%Ž ¯ÚG²—%'ŸLcÓÙ×78ñEQWè4GºSõH¢l=AÄiÈ–l e…loý€`±¢Â¹Áú9-ØL|óõó²õCð×¼ž .À±˜³þ“>YóhØ/Ë*”Ëigׂ§f].‚ÌA=¨N/{¼YËñz1½]<ºT&¹”`|PÙ­ÇKÄ®9@Á¾F ‡mj­Ñ«8¬IÓ÷ÍB  lÊ" 0Lˆèžœû]¼_4ÜÁgz¿x1©ø9f–Àr– nš}^'–«6,;é*¾Á“|*ö «xÒy›äÝYoµP¨Ñx…í÷y "¹/nŽ¬ÙÐfÈ+>opíï|:- ³ÞMÛ•n@cÀµ+QøG=,žÉ÷@ÙÅæKÒ«B ,i@Z7¡YÔO{G1W3™/DÌ(ûðñ@.µ*°Ñ'ϺӪYŠØòÿ³–VÃ^ÍIõH¨ôÆï v¡žÁ;÷_¯d²o3B¡²wÊéãcÖ© e—‘äÖWÜØaN+âfPŒW•ï’¸™5/CdNòÞå\UŒW9{7àˬ0ûwßçg“ÖmÞúØõqåuX©N4ï|§ë¤ÀË Ä}àm ’HNHöÀ“Éè¹QyM«Ï:2Åv›ÒÈ Í«¶+&lÆ™ŒŸsî‚ž.éÌË×àclh®‘¶¢ý‡9µ$¶YyœÀUˆü/§¼ðî‹€TCÊWÎß[ ´/š¡ªìØü•k_ïcwôÈÛmdOç1yhÉý8i…ß:Àй·AÒäšws¥œÀWÖH;ô©å†wt¹ç2*þ˜üގСÁ¼$ö—âg:ß,ÃWV’ª*‘¦®“Ìï33<òÖDølARHE0gÌà'ÿháæÏxé«…ÛusuI>Åjd;×裯Ìy<&Z^.¾6x\?Kàm–d¤y)¸KçO¥ †ï> stream xœ½XÍnÛF>@¼y•ŠÛÝÙÿ)ÐE¢9$Ñ¡ˆä#Û‰ SR(±û¼}Î.—â®L9vÔ6dr5;óÍ·C~*å%ó¿ñÿ²)Xù¡øTð°ZÆ˦üeVüøFh\¡Ž9^ήŠN…— %eR•Fê„*gM1'¯êv¿ZO*!5yõÏrš:é$ù8a”)a8säúohÅi'ç³ßÑ ©ðf•BW³‹‚¸Éì/U:ê4h/QIÉËJ(jµöBs2çç“J¢Œ)©³œˆáRFgàKÜP+ÊÙÅìùœ¼ù)Ê; uÝ+¨cÑËŸ5Û«ö維ï&UØ¢ã ÉY4"l®ƒ«fAèbÒ¯(òrRq&Ѹ# Ó~‚ˆi/„q<±Çɶ½\®v«ÍÚ[QŒX†Ê NÞ¯ö»>ç>—¼¸·k!½äA«Å”_ ;õ™Å]1†×p$«^ô`½«Á´/Ö–ãFNüôBŠˆ„ÑëCºçz€Çx_ðíDš¹ùTœ{Ô=f›ê1;òŸï@)8¬öÌÃŃ ª(Æl+¡ÝßKÇaù¬ßŠÜåZOÙ>œ®`k¤j§+2ÊÜQ‰ÌÑç ^.‘`˜$‘n”!Ÿ'`Bó_ú5Œ ›oÙ5¥LY¯…Y­BºH®/S[¯à£Õ¯œ¼ZÒx¯ÎIMnRŠÛ¯¶éí]4Ä Ù¥rË -´'ÈÈ›œ4õ¾]ÅÈ-·ÚöAu7»iÜ—ùôŽ2œ¢œÛ1‚knçgòb:é| Í†Ëå‚ð)gøÇ“N‘ãÀ¦_ùýÜžEÛObD‘0"<–µaÁq$jsΨSÌÖñÁã˜m•Se¸›}ò/ó‚þžšIí2zÏ®NXÆGíŠÜ.£Çf9¤v=þZ>õ´\¶›ÝnÛn.ˆ«Ð!¾8àÿ‡Wzâ¹7’kü„TÀÔeÀ$³\ …³z´Ž[WŒI±x žÞW²j}½Û ¥Lô%2ãqD«·[ä¸0¦å^Ð <^X—¨«„DSLÉ5ãì½¯Ü ·%¸ Ë)4øCÌSÎY6ÊùÄôˆ‘äùÀjÍít A˜Z»›æ1@îK ¼Ãt2ý­oš÷—ínp›âûQØ<DJ/¤‡=Ä8MÉ%RCˆÛ³M%Õ"\E=,¼Ýb©™ïN0˜úoCáúx‰«e\ÕCçB’›õÒ×f7,¤:€c‚ˆ¿/÷õ‚xŽA âJ= &CæٞÐ>;·1ß‚«pB¾Yeß4õúìºë³ ¤ÃÈø.;W÷uo.f SèÜ+'­Í e'wŽß˜¢¼µ¥ÖôÏ:ߥDaW[\êD$>åi£ Á™(s;fFã€(pª™õŒé·… AV˜ØÊ"Ù³Ýc’ÀbЀðB®Ž„g;-ÉÒX_ßíãÀ‚ý¡Á³FL&ó¹ñ¶$Ï'¤&¬riÈûƒç,ëmL:SdÿñÞ€ýlÚ»>>Çt‘g½t'•§Ä–¬ËA›¹¼®÷Ù}2æ=»?"FtxÜacIÙ å³£ ÃȦ€ìÛ:UY1\È\˜îÌØ\Ú9}và ;cAß¡«Õn2Š8ëå{ÒPixÚ©o<Åu <0¾úxžw*Y" ëžþñ`KTÛî)ŸOƒ] )íci4s²ôÖ±ø"àϘ)ì·oëø¥±Ø^S#¢ƒuç@éDaz*"/ùØÞð$À“—ð8å1—Að×YñºÀ:ØòsÁÊßð$d‚"î°ß±/DÙˆ-|€å‡•ëâíÉ×0GŒ¯aÐ&Þ¦²T8ð¯aúd{ÖòL•gŽõL*G•’!£x‚øÁ"¾8¼~I‰ KSVøXƒ³¢ ¢¿®NÒzÄfuߎ®'„N!•‰ƒNª6¸ˆ´‡Ò£8ï xNn#*4½I›+ëÀŽÔ„Èð‡–E²CŽôO¡'§œK>´õu?¼d(vXBaTžÅ„êùn¤ˆA…û·^XE?| EÌÚ§’§>îgTĤ…ßßñ±zs‹§3ÎKHÕàm'Ê|#§]éy¢ ·PΘ'p4¬ Eœ ´DTÀaå+ Ý‚¸*r—<@;xDÙ°`ÂÞºP.ö/Á¼.þ½‘ˆendstream endobj 152 0 obj << /Filter /FlateDecode /Length 16394 >> stream xœ¥½]¯^¹‘šk]%—Î…0só*hm/~Éqz€dŽO€AL:ÊâžÈÝm[©åQËîq~}êùàÖÞíÝ3NÃh½Ï^\‹d«ŠE>äß?¿îÊó ÿó¿z÷ìzþ«gÿ¬}îÿ|õîù¿}õì'_”–Èݾvyþê—ÏT¤<_åùón·ñüÕ»g·r½xõ›|¸ÅÇǺ«µåó¯¾~öóÛ¿ùð‹×Ý5Ú,×¾½ùøáõ‡7oÿðâekõn¯~û7/j¾pÕvûêÅK<¸ÊŠõøÇï¼áÃëß tOdÜþêý»ß>ø£»¯uûøúã›÷ßúCÑnß¿ùøëOþí«¿FÅ×£Vîz·úRÍo_<Õ¶ywõ¾ëiÜ_¼xÙ[›·WÞ|ûæAÕõ™~=zG½›±Î+¾xÔ€_>lé WòQ Ú¸»æ8¥ÿæE]wW>{ý;rÔÛß½þ•ª5¢N½¤îç;»¡Þñ²ÅÈG÷ó—ù¶ášüå‹—£ö»½ëí«ß}øý7_Þ~öæ³/Ë5®ÛõÙ§?Žÿþöóz]åË?Ås=?±o¯ñöÍ·Yøן_ŸýþsÌJ—ÛÛø¼}ù‚ÍúÙ«gÿ Ê—šr—uQÆ]6«î«Ý])•¶K6àù‡ožÿ·çß>wu\ Ÿšø×ùÿߤîþ»g¢-= Ǽ«óù; í®ÏDVÜíþü-~·€ìu׫¸«ÏǼâ.Š€y7Z"%¿=„¬ì ©ËHÏ“õœµÞ…^ÜËÝ w} IMÛëƉô¬y"ÐA¿gÜ$Ûk$«Z€,ÈÊg8wwm!Šz¦^…xcè IiCªô&µ¾qŸ§Ž÷%Ä}ž½Ð¤Œ+än3ˆaÀDz< xSÈ\Bª¤™Öé !ý® Át"s7Rf+„H #{¶°YÃv`dG#z/z¥ Xú6ÚÇV… ÃÈz%¤w!þ ȬBBÂ,Ó¦bä¿¢ ‘ò4›{ ‘lFšÉ&@æcÔB·Ê²¿i%/#;[‘AAllÕƳD&ã Ío¦“'2üæmn k¤•DIJê‰FZID,@,¬Œ.±‘3 Ç…l½9£K 4[£ÞÉèréwW'§™DÀD6{¤™DÀ²ÒOÈ, .áâ€h Þ$O :ã2T#í&â•…nSeÒJ–%D^{d08ŠªÑ·ä™ˆœÞH+YÙÌm%R¯Q=ÒnngZÉÚ„XžRžuybîBüÞÍx@¨s‚¶šÈVmÒln¶*lïF4‰‘·ÚÑ`,!áRÁxˆ&±[5ms–@ÄN+y±€ÓLºl☠ÁY–ïä8%àá™F²m!ž³M#–UPÙ X€4=“Á×\Bd5óŸrq‰xÀf(Eq¦×÷€M³‰ˆˆE¾ØqD†KMD,,q4”Ùš;QˆU k9F¬k˜%N!Ö5¬å¨GÕB U­ e`€t0L?ŒXׂK-D¬k“=0¸¡LŸÊÀ±®Me`€t}¡¦‘Ð×'·Yú:Â26«Ë²%¢ ªÞšÌÀÐ{2Ëü=UáÅ0‘åG£”}yQ!å_öåE…D˜ã$Òõiø#¡Oc-gæ±ðã¡.å_€4õÖVþÈPoínq†&‰p‘­*c)ÀÔ„"%`€4Õx+„´–ë²8§U«\Ì á”"‘Æ ñ ½h"JÀ¡M$èـЋ&2-Î%/šwÙú:sجmKV°î?…èS’˶j,» f•Â­{ƒ¡©ª‹…ïRýe`€H³JQˆ4«`Lj4«`%,ÅšU*·‘f•ª ½¸rež€t«`%ÇÈV•±’ƒ6/;Ô‚•M5ntƒD†^Ü”2Uc,äÙª1rØN¯:$B‹KDV«4¥`vѪCÊÀÙ*XU!âU‡D8´‰Èl,ät!2[¥+Df«`!G€ücé|«—òçf˜¤ªºƒâ ÒUÝ4˜{ Q¡¡ €­êb‡ˆ— †)@šª;¸F@ÄŠ4”ƒbM å`6ôG¥¢X˜óh2bSˆ5 «8¬H¡ +’:lÕ:Š„L‹+Ò[ˆÞ‹Eœ*ÀŠ„LÁbEšÊÁ`rdE¬ڈ5)íc-BÂ¥˜"²\Š›±«WjYÌÁ¨ªN†”!@‘VYÌ8Q¤UÓDi•¥$Ìαu©™+äÛÝ°$ÎZ”ãH„sK"¶H›s¾DTÿÍY~ÚÙ•­ îg†dY½–§Däì â ^JH€›VˆÈÙeD'׆ydR$K˜‚!„û;ˆl—bx70×äJU"JÁQ•>I®­v‡QK8F–K1HdXo*ÖpºéMÆ)@T ~Km*F—iM-ô*ƒ_SaJõ"A"[aJõ"A­U) RšZ‹EéE‚ÊÝãCHs©®0¥N;²Z•ƒ2]jʵqüeq.{²Šœ)DÖ¦bG€ŒMmU‘JõnÑD”‚ÙYX§býƈ Nm¡H¥z ‘¥H¥z ‘­H¥z [uɵ5¯$R%ÎDÕ4ŒTÚ¥Äk"]‘JóNÔD”„Aî@ýŽõý¶šdL¹XK°|Ó„è‰Q¨`“‡^’%•V’`õ¦ Qg!i¶z´«7CˆÕ$ $ì °§´vÔ«7]ˆÕ$ª„‰¾Ð¦´îp§bñF€•$”€b%‰)ÏÖœ»OdI–͹ûÔšKaJsî>‘¢0¥ ›’Š¬è2]ªËµa‡K Ë2lMêœ S4Û ²¦´°5©s+LiÎΧβˆsóù³J’NÍ'Ч´iT×PœÒ¦=P]ÊÀ ås¹Ô”okÎÄ'²-˥ɎKq 2éŠÂ”¶J`ù¦©.ÔåÚÚ¶JìaYî£{*Liû¨–oè—5boE)ÝIöÚÒ<Ò±õËpÃâMAJFÅ…†‚”îŒz"ÊÀ S~­û–vmI²Wû–†X®iŠb”îÁ‰4Å(½Ú·4D+œ-OÀ?«KLÅ(½Ù@´²£`§´‹lÅ(Ý™ñ´EE^­;3žH• »Sã‰t)½Û“´:¤$²]*¤t§ÂYrlØ”áR[’ì氤ݻ¤tg¾+©9¼ß¸’™Ó„têrlÝiî fN1²]j*HáÌ—ÀRÒçQ€~)Héó(@/òk}Zzµ,—£TsŠ+–oºE æ0Féëh–ol{ òrhºCZN"/ZNõ3ÿàå0F—'7 ‹7UˆÆ?y9FÂ¥¦‚-Y RF± 1§Ñ‹£È¯b—@bŽ¹s¦dE;˜# ¹ÐT˜2ªCNðrè׆7;Wðr(ÍáÍÎĆ)£‰Ïª0EËWDšÂe ˆ ù5ì’æèGâs*JýH¼œ.DÀº¤Œq$Žõ 'ÉÊ`y¯®(e ‡`å0LNWÐr¦ o‡® åб o‡®¤åÑk‘•d§Í=89ŒQÆôœƒœœ"Ä#|¹µáüo%'‡È:#|OÅ(ÃÙÞJNŽ p²rˆxwt"E~m8·[ÁÊiFäòAËaŒ‚d·€PˆNæV²r†®cU°rèÖ”õR.‰2œ»­då Q<} +§ ‘tÁÊaˆÅ.´?¢êa…ßÕ²%'§ ‘pÁÉaŒÕAX9ŒQ¢Zº`å¨ÔÉÁ’•S…ÈŸ“•3„È|ƒ•Ã Åm¬S!JtÛoPrèÖ¢Û~“’cDPr£`%@mD$ÀOt…(qÒ© äЭÅðÈí-$ÊðÎè NC”ðÎèJNN"[MN›t’¥àä¨ÔI–‚“#YNùjRrŠeFIÉa£–ÓU ä0B‰å™`§éŽ“%G€ê?Š”8O°q ÄIy‚ŽÃ%¼ º‚ŽC¿ûrhsÖC,ȱ Ìërhs 2Š"”é=Ï|•òžçJ>N"3 >Å?‹Í0ù8ª#sÒqšîoùµYϸœ—„9Ov|)ód'ÉÇ©Bw‘3„¨¿æc›' :e9û—Xº)B¬³S›Ó€Èè‚ŽÃ( àœ~™'ÑØÕé rqˆ„çb ã0J™'©ØUµ8‚ÃÂMbÁaá†È<‚ÛU!ÊœGpàº-!Üî Q”u%rjó$IÆB,¸½¢`)ßL2ßsR$ã4!’È8*å=ÇdÊrìÙ8š_ŠQÖIõ‘ŒãBŠ@Æ¡W[ÞO\ÁÆYFô¥R£¬â1G2Ú¹ªÇÈ8*tòx ãTá÷jg%íÈÅA3Ws®\Ê™¡ZAÆa²NŽnT§_°â«îª]]ÝáÉ8!DÎp€Á úCN¾¬“€‡nm ›K2qŒÈ\‚‰CXq$…µTsúeÅTµy¯“\‡Â\Þ¾[AÅaˆ²N.Tœ&Ä’ê"7c%Ò’êο,oÍ­àâHšËžŽ\6ô$ÊÈÅéBäéÀÅQ©íQ.€}²b¤â!T¤ât!W â0Jٗǹ8¼§¶‚Š3Œh^B*N¢ä¹8hç®KÁÅ¡`±SÝâ6Qœ.ŽJœ¹8]ˆ_£ýi„’Š#@³2qX¦Ÿ1â6QP&ãÔ}²U¤âG0³+NÝNM‘‰,—)f3×zÕ7S»Ó€ÈÔ 1£‰X.KÛÓ° lÁ,‘›ÈSŠ£RóÛxïi%§ Ñ·S˦ì“T"G€f âйí“A"LjG̮ր}l[vRŽ”àê´ª·™€!¢`Dœì"ʈC¤8 'Uœˆ qŠ%€´ØÀ"÷e¤¹Puàç—D4Õ#€7sV2qŒÈ’‘‰B惉SÙ*oÔ¬`â„2qª‰Lœ!DãLœT‚Àš»êW ?ÂÕ\"ÛÏp³C\ZwR9‘ @Åi[ˆ*ŽJMGí¤â‘ ÈÅ !ŠìÀÅ™|Ïr0@.N¢`\œ>„h<‹Cää\ÀÅ)Kˆš…ŒW°ŒÐʶ¸ “0†Y’g¹œ‰g¡~Å{+©8Mˆn4{'ŸÞ’ÈY¥‡Ë83HrqتáQM.N" ôY(D4ª}¬I`ÛšTd2“äâ°Y¦wVrqBˆü½!¢*ƒŽC35+é8Uˆ 9lÖ™ü‘ÃãÀïYrsc{“‘$̨¬dät! ¡xúšÅ!ԢǙ×C'§É?É8úé•’qBˆ”Í'¶âIÙÈÆ©B4ZMèëP¤ªi÷D4\Í'²\*±ÄÙ<@6N¢‰Ø8ôpq&dænq_ÁÔpWaA‡Í:³/°q³Ä<]%q`k`õ‹CÂŒ3Û"‡ = öäã !d¯.!Ö-1J[ ­[¢y±ra% g*E†ä2üæɘeV;9° éäæ™8™åGDá09ŒYæ™'!ǘežåA2rЬ4XŒ`äÐÉVL%#‡ÈYß&÷j ±Dc+f™ã|}Å,‡¾RÉšBüuÕ#Ƕ¤äè·¿=C!Ë\G›Ý !ysËÉÍÊ’¾AdŸocM§ ñÈ[MAËò!PÕä"†|Ü:«Áää‘¥òþùÀ.MwŽ6¶qç »"À}ƒe´jµS?$8Œ¸oöPв¼ºåMÍ<ÔöTÌ"®%‘-·L=ªÞ¨×a3Tì¨e̲Îò*99EÈ6Ò³,3„*÷ˆN!ËÈ”8×™dp7¥­¤xßc"g””œ¢…‚trûòÀâÖ>#Ã¥†‚–}¦¤å Y»8­ç lD45Æ2:¹}& ÜýeÄ@U̲Mq©Ø)Ře›ÑR¹ç €å€]Fôq[‡Vo ìz-.²±Üïp÷nœÀ>X‹¡…,;¬ÇØÞB'ËEBŽ~9µ¡xeû ¤ê-Ý´êñ¶®ìuz¡9/³Ï*w;Q/pSB`»­;¡óh9—ˆõað<ÈDí‹ŸˆV€h`’#`»²2Ø ¬qéµE"Û—ûƒÝçZÎ#ⱡ•¸DÎ.~¯¡±\‚Az`W±¼ŽW®ˆÈåyÅ)¸ÏØ÷º‘¡Àò \Ñ°!ÂÃfˆx‚“à„\^#!¢dV2­”ÒŽL¥eJñúWœé^ 20 lk–ÉtržÈ4ÂM¬‰œµòrŒ¸:‹@›¡Õ¥ÊPð§6¿|v "ÿÛšgwI³ìS—Í“ˆø;ʸF©'%NRN‚f7d4á۰ÚŸjÎ_¡S‘hdu7rrŠed0ZÁ.l~ª!±ßdù[KÂ<-›’mü)åÍ¢TŸµÐœ#BÝjÎeE9;"³RF¶ßÃS`7u½9[”ˆSÌ ™Ÿµ„è‘Jd”³'±1cdøò›Â/µ¼’ÄG$T,íðÆÚæD‘Pý”“HÄ+ é…!úvã9iQ¼Å¯9 @`ª2t§(g»^#-LjzX“î(Ú]I„vq§7k¹ïÐαˆ¸Ó{‘4ÛÔ¾¦Ùh”vߟÇAF8g ìbw‡v’›‰„Ú­¹]”~)¨m$æT!¡F Üû®–²›‰ø.¾Eéõèñ’f¯§ƒÓÓ(½vn'²ýЛpæ³aBç†ôngI³;ÆhžöÔ[šÁµ"jxp‡o>²!ü®CÈò‹—ÄyvZ5ÒKÈVÃ'œlÏ÷™¤7G—~6:7ìÖ·ÊÎ!aGq¨wðäžÆD|ngsäHD¬Kîm´£H«J–£%Y< 2°é¿»÷Ï%2η‡-! kʽ­C¼#S±¹,HP+ð!â¯3¨ p¬¡»Ë½}D·‡„9öùøæi~Aõkx¦"‘)ImR9Œ}qÝ[8Öj$æ1ç¸Ñ££>a_ßHÌ)BÂï!—/ÀSVÀÍÒ½ 0N•ˆ9¼€C©F^Ž‘áGªÂ•0·¶Ù¯Q³à³(ѳ ¥‘œS…¸Ye)`‰}šU¶–yfÕ"ÿ6,5’sˆ”Ó¬Ú°œ½ öœËôF¤F{྿ꔋ›f˜5’sˆØI7X],ó¾¿ZQÀröc4²sXÊ «óH7ã¼¹ ItÊ%7:Æ+sÚ|Ю±UëþÅ[ñÊÜÚ›Ô`èâæöЂù¡@±çA@c¸².ÅSÜTo9¯Ô`5®,sÄ"Û@y®vÔB TëÅ(ŠWV?oÍ¥†Õc•.îl!h$è@ VÉhÔ%2hÆRÀ²|tWËá‚ŸÎô4Ž•&Ä*i®ãK¡ã Xĺ#2°l‡'dç .Û'Ç5è&=ÜöéUì#´q)À<‘[$;§Q€@v õ3df—‡Û÷]3C*°OèAv€8M˜KñÊž§ ëR¼²§›°ŠÜ6=¢Aˆæ>n‘ìœ*ÄÏ‚ r\T½ÅTj€ãr©')ÎD¬Ä‹ÏDŽ,Úè@D½„p¥^¦4tXÊ'ø4t <\=ËÀdMÚÜ’HœîB´RÏrncÕ+/Þ6W4êeêH#=gáÂlÃ'›©eØFvjçE×FrN°Œ(SÏ‚jCiȲžåÓFrN²Œ0sàäh8ã_*å…Ðz\\=Ëžü^æläç ™åôù9!d© •,ç¨gŲŸ£RÞfÝÈÏ)B–Æ ÷©Ï«–Ñ¢žÕÆF~Ž÷zU:¦VÑÜHÏA;«vÞ·ª%¨À/=Òx$9&ÒsX¨Û7€ž‡:\FBâ¬ÞÛž—Þñ–ßVµÊ¨§üé9]ˆüPÕbH ê²7 çP âbA®€õ¤‡´ ]§s:™ÎQÏ [?g Р?‡â<«g´³ùÔßF‚ÚÙ<ýn è¨T?5$:úĪ=Bòl'†!C§ Ù~fK Ú<½Œd5€ã€ÁÐQ¡}:9šäÙ”«h`è dE?Ië:ÊQÀ`Nžˆµ"”©gM©‘¡ƒfª«‰)A÷ÉF†NbEžÝ¥ÆQäIƒG5gŸvCdèP|@‚uÖuZ]d:'²ÏÐ[U…¶CrtÞ)ØHÑÁ#ùFŠÞ2ŽßE1¿E9™:Ä°m$è ‘£ ØE0ÆÑ€M ùH2tX*Î0Û‰8€ Cëô禂q2õ,u4Rtð–ðŒ½¢ÃBqf“äè‘)G!kzÿž DSÞ½‘¤ƒV‘K@ +rI–ác I:hfœ™!I:¬àqx 騔×}á¶ë€ÖM—š&<µZU¸Ù4 †’7y:hÕ<þ­)%AD_ªJÈ@/5æIÓ!â #MÍœ¦´5Ðt°Öéµ–FšZ5½…©¦C÷6ãT°]眧‚­J æ:l ½ˆèÅ­»Ð±Ø éÐÁ­ëTPèDÊéÀÆÅ0"îÀÎ;:c`ª:]I ‚!™w%eêêG½K È† ׎€Ly:hçŠ#™®œ ŠU§3'S×: ç°[Ó,‘ˆBXòtPhŸ9x:Ôí…‚žÜÉF7òtÐÌmL#OgÙêõ « ¸¥o…r2pªN(%S÷ñ:äéñv‘žâU ÁKŸ:?—¿£„ Fäôw”i×ñ0dé9ó@°t íä|Y:ˆ·c4²t†שœL»”@o`éLÇŸ¥Ã×Äé¬Å#Hã¸êÅK)™œ.kc`O§P£÷ã÷ÖzD#K'[É‘î×ò@ŠÀH·æ/%dZñ©" ,87Œ})Íæ’8+ÖÖ6ƒ©o¦ý¢Ÿ¶ÑšëD|pFOÎæA=±¹—8`ª¿ÅüfÀ>hŽE¢Ž¹uòtЪ“ÔMùX©9i:DŽ…ì¯çHäÌŸÈÓA«ªnj¤é QÕËé‰(›"5M§‘&‘¦ƒfVOÈÒA›Äœ&¢ŒL»O+‚§ pŸ<Åu)Ì÷¬:†,4©µS—ª„Lkg––2¾Ù‹H—,Û8]Syà^ÀTiB¢_öED ˜* 1uàÝZó^ÛF¢~L:ˆ:U`¼ô)¬èà·ÙÐD&dëÛMù˜Ö}äh#Q‡ˆïäi ê R}“ý&Q‡oööÒF¢Z…í>jyW>†W†©Æ½KššJáõ“§êtÆj œÜYïJÇÀj€ƒ«ƒ6¸«ÀÔá/Ç^$êðïgA¢Z4Nà ¢ÂØHKe(cIdI–c© 2-¢‰û $xJÀjj4“¨ƒ…·6uŠÙl.5$Ëh6- ê ¹CjÊ0£î†P&¦E8,OŽ­)²&IG?=óIQJ»Ï.‘¤ƒ&Å ëÉÒA“¦7Î5°tàÕ`|§D;—9ëQˆÉýAã«ú.ÞË‘ˆM,X:ˆR`°õÅ< ï2SmÀÓ0mïIÓ!²Î0]<2`ž-ƒ¥4Œ/7²y„i4Íû‰TÉrÕ£‹›‡@ ¶–'ÀÔA”“­D™:hÔòem L¸µ¶âX‰½$Ëu (˜:ˆR`ÅÉïidêØVuЬmNQ‡ŽmŸE u(Ì}–|ÀÔA”Òî“*dê YÛö’D´J—¤)—ÛŽóñR%Î=ÏÇ „kÓÆ“©ƒ*ï}>^HÛ‹~°T œ†c/€z¾]Iq ݤF€»ð¾ û%bà ÔéàéÀ³Å©¤y:DÎÂy:üö²ÈAÕA÷0üŒ21àuÊ£F>SÀaHßHÕ!â{¨:Kzñ6þDð¡r,‰:hSñ™ D86:uæŽDκˆ:ˆRàS4ÌHÔA£ŠOh$êà[Õ‡ë6uàÙèUü x•ËÏðÈ€W)~†"“âˆ:SxG›c àäòIÔpÖ=ÈÓA;«7màé Nßq^˾³ˆR1ð;ág¶ÄÙ¼™¡‘¨ƒoµO‚¨ƒ@¾HóuPAkV(G$GKš‘“ŸºV3àˆdBÉÓpbEÒtÐ&]ëdòNŽ gRíf•4»L„‘p€Uª™;‰:hS׉~<4©Ï#Ì©<Œ}‘-aŽ“µ'O'm@žZ5ꬋY‘€ óˆYÌÃÀƒÉF’§àDyäé ™#´»¬§ƒ@¥ï h ê Psn†ŸÑã:=º«„÷6ió È°K#ÂÀ¥ ¿™_MÄç\5uàÜàä<@ö–<㬃¨ƒ@¥Ç™ª“©@wC4òtЪy4ðtàßàç$<ðt(Îécˆ:Tàù–ßÃã¡žO‘3‰:hÕô¦¾¢üù©CH•<ç ¿HÔA;ç>ß*œ´G_ÞW—÷|áù1ð|š0¨àd~ÉÓá#ã|©ò0È°3$Bëp†nUåÚhàV9©†ä¹Ïª.y:hç.6áàé X{t6åbà§ÑðŽ HÓ!GT‡v¼cu)}Ÿ|"y:hÕÞ6›àéÀ¿ë$NÉÓ!¢s…h:WÆå­Q4 ä,o’¦3€ [hÐtàßà.¥ì é ">Œ¶‘¦S€lG¢¤éd«F9sMÐt¯Œâ#W§?F9K²t˜NßHÒ!2gÄà柀ÿœ~ IÏÿ©6x:pp£˜ZÞÈÓR¯£AšwÀ…êÅÁDbéª>^Èð šÌƒ§ÿªñJžˆ:Wp» 9"'H¢ZÕ¼õ¾¨ö«¬:˜:g3q·ªƒpe4Š×HÕA«š¯k¤ê U-Ι¼/&‘{C°.ɳX„T4´ëî–F¦ªÜO>L„+¾ˆŽh–Aò«¾„­††çËä頙ݼÉžâ¸Tµ@·¤<ª‡âæ})æëˆa7IsT;"òtðmåhˆ–—ˆOpjäé Mãl`ÀÐpqð©Ò%òtˆ8Ûš¢•!Z4 |PP#G‡ÈIc£ÿ6‡ñ4pt(Ëðéñ $D+¸–NÒ%Im ïmdé MáÓdX:pp¸–Î@“(§ùS,4rž S75È°ÓW%>U~4šžQ‘¥À¢F’š¹Ìj é XËg*7°t¬ŒåƒŽX:ðocùüá6uÛ^"gŠB–¾u®ènS×Ù|ªÔ‘,Tp™½ÒÀÒƒO½Œ4 sŸ ÈÔåk‰4 “W¤<ªZ©‹ÌU=£ÛÆÐóý’$·ŽM€ˆ /À‰BÈ• OÞ='€lç«‚®Š øQ¿’ùã€Õ+ÅßHÀn´(p¢z%VoðÛF®;Àsu³u…OÀ}.#$.œe5B’s€è*›Fœ¼¥F9@êÙóEJWOncêb•€»´趓DN&zê’€»Ô¬eêrðsDµÜ¥F4)9 4ãÕ¦î¶Hä,wNm‚¸K™Š©{ ÎQõÓí ˜{Ù¦®L8G3]dpŽÃ¥H†LkïÈmêÐÿ€w”m›:‰?xŸœj¼¸°¼ONU^¼}5àe4AÉAú²ô±µ¿On€„<1NH Bb0XÝ¡:³<à Ý¡:H<à Ý¡:à;HYÕ§7O€ ¸B9[0r›ÀÚÀèÌêˆ8‹j`äÀ›Eœ%42rˆø´¶tsĹ_½‘‘À%Äpö=qDÄpŽsoz‡²œ'w¹t"oÀÉÉJ‘Žƒ6‰fED g89EÔKÏFœûÍè8æòI¢méàÖˆu|ÙÒñª‰x 6"8¹md×Á¥IÑIÆ°NõtÒgø8"ÌQî€ÓTOŒlâT¶¥]y1ÏEª \Ä%ð<ÝeÄpžçÆÑ2|®iSd¼§Ý/¸”Mf•wHñ=ÞÁÜ–ÎtŠÙuÒKãK(tînlKÛ×bžû/'B×:b[“ïð©$DÔÍ »™·­é­sH’çæºÆkhP¹q6ʼnƒFoò$•'Å "|†¼ï6Ák«šäá zç"®F^sn¾j â ,™ç¾©ÆK3XÊ7<5q8w*5òpÐ1³ža¸I…KÄÜÿF"€³••÷% Mçjœ¶tfHL±ŒˆpûSÀòŸ×ðÈ€å?ï»v^ïÙ:M#`çõqøSjÏ›G;—ÏWk$âà=Û‡žµ­c&·žQò†}û™%yî3ïÙåÂϳs4œlî»÷ß•yYçtý†#·á×|ƨ£.Å5`¢»KÑw†o/#¢ÔË*g,œ  žêVmOƒ=V ¼ÅÖÜ. g²ÔI“‚‡ƒ@…×p«‚º9¿„@¯«¢»cճ¢^ì¬×¶êRû|H$ñÀåÅþ6¾ì¨BÌ­uƒ÷Œ©•deìèô#Û…Ön±yé"ÚÆ+^ºCŒ€6§­~¯GÚ{«Ÿ¥†­;FcéŽ"KÒ¾Z¨‘‹ƒ ž¹8¨à8Ë°8³Q¥L‡iàâàãÃìñF*dgÛÑÖŌ뿬 "À/·óÇ™x!³P¯ ›Wœý’¤âàSÓgÞ7RqÐÎs6Z‡*0}YBÛÚ©°Vadº”`j¤â ‚º¹ ÈÔ5܆dApÓEØh.t¶‚€‰×Æ;uôâÉ»Šc#˜©8ΆD2qЪ}RNdâà5ûl ÛÚk›ŽÚ¶ìJðfôÓK,ÜǺô(`04ç /s8×t©³ëŽLœÊuÙÚž¶ïwâØ'D*<^_@S™³Õk나àñ.Ã[[b׳«œT¼¥ÖÓîÍ{8›ù›~é&’ÀÀnF”wÙçÂôN.æÜL¿Ä Œ[ŽàN.šyîåîäâ >¾»ƒŠ£B>ô­ƒŠinÝ ¤pwÚ>7)÷KW"Ä>ž¶“ŠÃBN¥öKd©ØçžÝ*‚UŒ®Ëˆö§ñüS#ÜLÔ“ÿüì?=ûûgÕ>E»F¹È’ƒ‡Wîdß~øæù{þí3=óüûgåù_çÿóìzþïž,¤ãÜS^$>ž¿»ÿÄAð‰?~êa:ÂOë÷>=uOÝŸûyÿÔ=òð) |ó'×ñèBeV.u¡2.ËÞþáÅ«ß|j9ËÜ †Cr‚OüìÍ—·øòžc½0’ÿéºq4ÿ<_‰ˆ+øßæ¿¿þ±ñýGzÒÁáEWôäGÇ÷ä…aåÞÐ<Ý'i§SDûJ—ñ O²XçÝnêÿ¦Þ7÷'_¤V=(Z^t|õuÊö³/[Êï·/0h9GÜ·×>L[¹oï‰ãèÈyûøk>Õ3 Û·oôÌ5öí?üÍüÿûÂ…WÜþÊÏ\ãööÍ/|âÃëðßÊí»7ßòO8©{ݾzñ? š>‚Jýöû°µiÜ~zâÃwoÞë*F»¥Äï®Ïü{ÍÇo{ÿîa3÷àß½ó»Óüzšü 6X¦*·¯~óöý¯^xãG…½ûŒcà‡ò½§-x‰µäžþ4ei=%¨‚=&Urº}yÓ#_‡+ž2fÐ#ÿðÔK°$ŸæàH;Uâ%÷Š–Ûçç_5+àÊæ ‡ ],ÊKÑ'ÆÔvá4~äÉšbƒiÍÑñðÁû ·V¸îùÕÌÈ(çküŸ»š½>Ç6» kPMO‡A›.>C¼÷øÓóAkX mãKlëløÔ§ ïLéÀf±z C“槞ÿúãOŸªøKn“MMx‰}eTuí÷MÔ›¯^` ¯Î~ûõ‹—Ü\ÙëíÍwø7—ú#ƒÆèhÞÞ½ÿYMã‡÷ï«Gfã[|-õ!n÷¥ëíŸÿú›½)ì·xÊTü Õ-ýËí—dŸôoàLÚGX¿OKˇ0¨ö÷¿ñØd~ãƽI¿Š=ÏüJ%°É¾ÎGŸüª×oOgö›[šÖñGzzeCP{ž‡œ3ôWÿþÙ«•cýæεø>¾yýöí`ŽùúÇ*òÿ<øõ͙ÉXYZv=êíµ+€m«? "uŸÍöøIû±úÊPŸÖ0…Â'¿{Úö’ÝøüჂ5üùíª®¬øSFô–:Û“¶Üö»?´ßÈZ¤»ÀI.—Æ’íÈ#ûùŽóÊzâ9×^zûwï®Ò¦=ÙÃîx‰Yú˜w¼ä1ü[®ìïž0¨8]«¬ã¥>/O*l­êÏqHDY?Ö*€Îhi¥qøÅzøuZ¯Œ9oè¯w:f.çêüù¿o¬À4)OcKø•>æêïžÐL­RÑžÃÅ”tºT¤>镱}e5ñàOŸ²ñp÷Îð¶žzÆ+Äg­øŽÝÖw:QëÄ^X8`{ó½~à4ÚÕîÄ¿Â Ó»•¹žz!O™<žjýæ©"E›s WóÇo<’Õ+Ÿ|ã£6ßþõ“Ñ6Dô£uO*–3úýpúi:ed²÷ú'kˆC»—ÊÿQ'>® |XÛOßžöw[j"ýØÇ×´¸¿ùA¸Ì³G»Ÿ‚agôøÃOºŸžTl€•çæªý¯?~üí_üä'ß|{÷ý›¿{óÛo¾~óúîý‡_ý¿~ò7ìþ»?ÿïãâw÷ãò›ù—'Ƕ¸îœk=¬ÄÞ÷ìüå%µUD÷óÛ|ÿñ„é3;ø×=›¸âG§2é€x_R:ÐÇs‚_ÑÕaªô5à ¾f_¾– è}èÞ|ü4=铱‡f=3'4cÜ^¿}óµÿ\÷#÷ÿþçYLºÁOéMåe&g¨üÃS$Æ}”øãºZçêjù#]Ý÷£ÆÓÇ×Û|ïfKVü»÷Ÿ=Yuì‰øx—ûÈqðpêVÿÏ& ˆ&Š\$6•Ý»Èt #óc%þùÓ3(¸¹O^÷Vÿ´·ÞÅùDÓ2ø½vNz¯útˆ –½|øäçO׳q­SÏx0o½;µÜý~çV©à<çêýöÅ_¾x‰ír˜ü¾ùå—·w¿ýå‡ÿú gÙ_2äàW¹ýåçŸü3N»ÿ .8)'{æÏÿüü¹(ñ©lã08üöýGüPüûú÷¯ß¼}ý‹·ßœg#òþÙ÷o¿þæç?ý‡¿A²eËí÷ª¤â:Ò‡ 9XÌ붕9Šî¾ùûß½~û¥j”êñÙ§wÿU–ýøåíÏ~ûæÏ>;Z·R×—/þÿú“øìÓg?¾û©ÆŸê‘òÍËve3ï'þƒ,Wk]ð ¬ÐÏËßžÕÛ«/þËÏžœ b+yŽ¥$ÿËuoð׃ٖ¸}¯lIÛcr4ê¼ÜwbãóØØd4]©òØfàŒê{›ñÅ£ÌÊ/Ì\><Ý&luú4!~<ÅbÕKZËß¿ùúÇæZß=™^!cëغâ~:†U)$]‰w>ðhæ’½Æ:ÕÇ3ó¢ðG–}YêÍý¢w>|èÃKMG<ÎD½»oý/î§S?Hxù«?œãÙíò‘œÑë¿ô’]ø’' \0g2†Îø€™—mûÛ·ïùæíùþ¸Ðyrµ?žd}JìµÛwï๜LãÀ¡ÇÄ­[#?ñ-}f=FÎjñOœñ§ÇÁ¤:™ÿTíÎÖõ‘ Äñ*Òq†åÿ¥ D}yë±?Ãïýêw~ÿ mϽٙ·—õ³O6 ´üQ°ó3Çç·Ÿ×ëJ{òÓcâ2ZøÅÛ7ßæ+~ýùõÙï?¿>»7~o?þáóæo;¿ý¿;kš°endstream endobj 153 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 1207 >> stream xœ5“}LSWÆÏ嶷Wmª¶^;ÅY-™ R¾§nZ7@>¬èäCg¡8Aù0p¢ƒsNÆ©EÙj³E-£Àܢ̉C”D '#@)íªˆd˜àòÞæÜ%»ìüyNÞç}žßû I|EQªmy…™‡Š“3>+Ö%eå*È(š¾öÅ$—÷zH±œÆrÉÍ%’ÇJ˜3ß9÷÷yhú(cŠJöfeç…†…G¼»Jç‚Ð ”ŒŒH‡6¡X‡ H‰ThâÐB4 ]E³Ñ\4©Ä®H‚Q6º€nS>”‘ú†ºCõûlðùÕç9I—Ò•ô}úÉJhPxƒ±,N(sRž1¶ÀÇ/w Ë¡Œq gþ-äíN!ŠQÀ(¶ó¥ö¯ìÊî¾ÃjÕãn¾†j†áŠÌ ʶU°#2UÈ™²“æ¾;pf~šžUm—)øŠ™J î@-›àœTÇ%I"JH’2M¬d+±KÇXé &éÒ FÁ·c§Wf§¢©Ho!$:1:‰ ¾T”ôñ}Tƒ‹æóá5wú^ùõÃu9- uQ˜%Ú"!QDïYZ˜?Ð ¬šµLÙÚ=›0œÒ ó@}¿ÿùÓ¦Ì(«FìRÒñO ¢â­pœÃŽSw5æ®oóµVèM"I¤G «@>ô˜Q«$Ö”wâݵû›×Y_ÙÆžyÂUO<ìÆìÈÃÍ:ÄÈ¢¬oå¢á¼ˆ*ÂÉü|ébcµW^ZÚ-+­*7ÅìÆôO>Ô„ÅÄ=LC¼É%S@Ñ ¬É7Ê®áuCjÕˆÅë„š!FõÚ[(Y«ža#â´¹i°ñ6N°¹½9‰²B>F–a·ˆÈÛÍ£|‡˜é=Í[\œ0‹ùöÑ7]í“oýýàÞŸø/ü¨¸#£1ãæÇãq(ŽÏß·µ(«|÷×Q¬›±´œ«³Õ^núíj;fõ‰Ÿr4Á;Ȫ5{âN’°E|Á´‡’~Þݧä5žXZÕ a”;ÏÜ`^ÝÛ’’`jùç”&œ©J´f]È¿Ó;YXñÒ o¿Èm]S¯Qt]½ÞÚ³æ½ßK|‰ß뉮b©›17U]9ÿƒýVSíÌö7›ô»Žì;ª)>‘z[%;‚(pˆùÍ‘h7D¿ÐòyéÒ¤A2hàHEðL:ã\ýì¢øõ"^#'ø0;……ÒAæVËO:0;þР}gûÖÕMŽÏEÓ¶Dëþšƒ¿ìxVàMûMNA, zE–÷/ÌÔ\ƒT)Üþ^£ê¤¡\\Ñ•D@ ˜„bÖI “DÍ>`ÂÁ/6`ˆÀÞz7hŃ`|Jñ·ÀÎ æÞü¿DÒc$—›u'0„bKÃJP³)Œ›øµ ˜D`žJôáD÷lŠrMÑ<ÅùùMÍL¥‡ÑOÝöÀ  ×¼9ÜfüQavjú–’Õ˜,fI…ƒpNàà Xv襩kivëöºxÌê%ãÍdÉL_ídš„4Hkž×(J.ó5ßC’-ÿ;fpöØ,Ÿåsn[ª«ªªÏžµX­¹Ë•ýchMendstream endobj 154 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 278 >> stream xœ ôþMSBM10‹xùAùT÷ø ‹ ‹ ›÷ÃÀ½C$¼øˆùfx»ù®°®õ®ø-®ù%ù3œ‹›zŠ|‹y‰ˆot‹„‹h‹hšw”X¡`‹{‹û;ûM"û”û“÷I ÷AÀÒ–·Ô¹¨¾½‹™™|‘…„‡ˆ€QI2c2‹û/d÷1÷/÷YÓ÷öÖ÷ B!­Ž‚Ž˜‹œ‹›œhËœ~˜r¥Š“‹‹–‹˜“û÷›ttI5‹ûX‹(šûåCû8À\÷‹÷‹÷Lðäé« 7Ÿ ‹ ‹ ‹ *Dsendstream endobj 155 0 obj << /Filter /FlateDecode /Length 18027 >> stream xœµ}]¯e·‘]ƒ~J‚ ½Ìéúxó›L À1`xŒÝÁ±æA–Ú¶ÝÒ¸Õ¶Çù½ù!©õÁ}÷muk<ÃÐ=«÷æ&Yd±ÈªUüÝÃqOþçÿ~ùæÙñð›g¿{–ˆ>ø?_¾yøÛ—Ï~ôóÒ¹¯c¥‡—¿~¦WÒCîõ~Ôö0Ú¸¯Ò^¾yöËÛß}ñöÝ×ß<QJ°ßþîÿ~ù<÷ûª«Þ~ûü¸­Œt¬ÛëWñcåÞR¹½}þ/ŸIåú™Œb[‹O½üêÙ-¥ç/ÿéÙ_>û{Ô2çrÏë¡Í<ï¥>äu”û1RYé~ô‡·¯þáá›gížÛð£Ê?ÿÿS4ò'ÏR)Ç}¦xy¬ûìo€ä{ªÌtOëá5r¯H¾7#õ>‰”¨·~ÏÚ½÷V€ô{oB&>ÈŒ–©>ȺW# Ÿhs÷1…d|"¨–‘mRîÍHÃ_Ô{ô‘èf"ý^ŒLüȸ#ëÞÑеîIH‹f­ã¸7#ù^¤]p+w>}^´ûÁG*J#ßì@z !ãÞq¯FÖýÈ@¢O„ôã^„Ô]rO÷Ñ€¤]ãNÉRvcØÕ¤î÷vHÛUîƒ]iì¾è“]iî^î!þò±;y„ôѬœv'|¯hV 7‹o tåºÅ7ºr»O#ýÞЬ<öÀÿH|ÜÈ¢@W9öˆ›ºJÚ#nR j"A Hü…f•hº‘&Æ`TŸÎAyb(óÞÄPÌFÖ}¡U1‡^Š‰„ ¶j|Qƒ‘¡ØÕ;1ô(ÐxI-_1ЪÂW;c0v´ªRøDb* U1ðªÚƒ‘m µ¤Æ`¤@cä5ù~ Q­¢qDb‚è^5#>­‘t‰3Æ]™B†ÄãnºÜÕc̳25ÆbB£:M$Iœ1ÊJ’%ÎÞÝ¥5ÆbÂ×;õ‘†ÑHŒ2}=uŒû¶b˜}=Æ"ÅÃlúëKâó H OT0F™žÈùžÑªREߎÁÙЪ1wËcpRœ1¤4Hk¨`ŠC* ¡ˆ)è"ñ>Z安‘IY†2kjRŒLÊÊLMÂÈD#cüHÞ5FfA“bü$#³£I1~Tߘ”e Ÿì‚'e£g¸ÜuhäÚ3¨V*ö@æK¥ÈúcE¥ÄP2*E¤A–D©Q1T£G ¦þŒ¡ ¤»z•ª1€¹«×¨Y{ØÄH Qö#††‡MŒÔ4€h„Ä8Åg ¢\Fh‡dÏ•5‰ ¨EmBÄ€°0.ú1 …~ÌhQŒ‚¦Ž‰‘Û‰Ô»¿#wáã™O$VB´1džÕÁ1r;š2÷È ¹Ð¤»ê·ÈV¼u(0v4|9¬6†n,hì7BW E!`ÐèU¬{½©ƒZ2²9a8i»‘1 šz+Vj 2½ê·ª$Ù`æhP¤=Ðbp4)ÄgAÆঠ±Æ©÷bpãÛ¡i†z&jÊ2äåIŠ…­ Å¢å¯ÆB]Ñ*,hªM w ³wW¨FÊ2¤ãéýáS! w4 «ß ƒ ¹ƒzŠH’,C¯LY¢{Ø·Ð -¢^o1Pá‡:½Åø_hTt~ïB¦Ä_üí%qFWkö4ØkhTh‘1„dLÙ@š…žÄë&iN*"]Ò„ $€KÙº»Å¤8ШµÇy‹YAi†Ú†m±pSšÑÝÏÄ´°—€†u;•ŽtÓÐÙ䳘Ai&˜7~fRšéèV¨-ÇÔÌ@¦Ê1&vk7*&NF¥”vßÄÄ™DöÀn1w Í]â>.T·ŒÝÇ1b• dë÷êߎ°¨b6¡Â™_$(ÍÍU °Žó‘¾‡M¬ã mÊœøD…™¢mÃåRÿöT¶EÔbvu4³x·P— mBKTpÌ®‚6A è™°(‘­¼[«”f,ÀžT-æ[A+C­7õ&€ê©Ùb¾hTÌy©± ’Ò¬œ´@bRš¨–Þê¬=Agë-Ì@´ªƒ6LÊVE%šßêghiwi'Ì ¿5¡{z‚RV³0)Ѭø‚´|‹IIqÆ$—mXìÑ.éæ*ué[·˜£ m{;Ðb’N´)Þ”uÖb’Ršã¡aORš°=UÎÄþ ÈÜ-ˆi›Ñ¦yle2¹$[š¡2)͹í6»¤‰ÿJ¾1;šÓ×bÀDF“Ö¶ãÃÈ¿£ 1}õN˜| Ú*sT²\çx\üd s÷]Lì°8{•ç¾[œp¿F„Ú>z÷#‹¢Ì²þ‰õú5éDzƒ³gØz~¦P”9´—>ڢ̲ìˆtì é6‰CYÞQpÚ–B(ØsÞ*3ô¥™óVd1)Í M$ ` @×ÊÛa5 M¡ušáÞ¢çXœ%ï+e™CÉH„<(ËØ0² 0éžvQUÔ4iK»gN·že_)fáî ‰&„zÈ:ªÈÀô#2P` kW9”Ä™cڹʨ<ÚÓN=u?ÐÎÖlÔ÷Ð*­ÂL7ÂÝF|q­­¡8;…HdHœ1‹›Kž˜)ì5»‡¢9Ъ˜gÚ'õh1ÛPí¡yP®¬UÒÄŒTm¢ *6‹fb]£3ªA"“FgÆlËB–ä“J¦vo‡ä9mtöÆ~{IìØú Q0¤Up«'L U04$Å ÃÙÈ8c¢¸K£+£~fõBï´¼Ù'½SDToÌ{ô-ÄYŽáyÖ£o3ËÙÇ=4 Ï’ÒùV§áY0eŒLʳ¤~¾µ(Ï’ö!@„µƒ!í·BÏÁò,y/“=d˳ä½ÁïƒæY s·+4^*{Qìš…MŠ ^4>K¬Uª L´ K¬:9ìJÈÇ4Rw=t$ä‰CõèäÖ¿ãÆ#grãÈ€%FdPž8]9ü©IyâtÅÀ₇)úD6kN_x8Fü¡_…¢ìÛöï«I”° ÕÂP§ØBàüC¦_‘³³ŒcO©Ð°;q¸¡0bpP”8ʘB’D9öÉÑÀéZ„.Piv–¹7¯#T&ìNœ@T3$ɹçó%LIÂÒS9éÀÏâîØR¡MÑ6M¨:™r U¯Ó¦ r¬QËìB‰S)¶CV'NºKæ\ ËëÖHÌûymXFæ¢Û±Ÿwõ2·? OÞÃv'væ*849ÌNlÍ—_ê”dÍí,f@’Øc7“›lª¥UŽ‚Ъ²-Üÿ³³–¾ .ììî 2‘Jib;ìb7UºŠH§ÙYë>œ…³¦c«¥lD&6®ÚŒŒ˜اj|ŽøvØ–º“c@¡.ô/ÄhÔÔ¡!Ë ã¦ ÜAÔ‘¼…Q)Ø*ê»3¯c_¨ÝhI¢Œ¡ç‘ÖŠD‰³X•ìçoÒœ§ßf6n û<ý-S'ê’÷ÐoKoEßèŒb†Q iNMçM(ÑVÙÒ3Td|5Ðò2{Õý¬]Œ(Û\5)ÚQÎyvg¬$!J8«´hN˜5ÑH¸‡tê7q¼/­ó@Âæ„Ås#&d¹°¢¹œFYÂ+¡}ÆÜ;t8µ¸×8õ•±w"_*ݹÚ1£:ÿªð¢[1½Y†„*XwO¬nų×b  À@ªå½úV5öàO,(&”L—¥iHõöot-2Ô¸ cC%º‰”»QœúK‰å œJPð&Ôf¦³˜¡·fõƒ7±¢~§“d¡·L"ð&&âÐ ^9륵Uü‹Z{ob"²§ØÊô*†¹LL„^Å“Ëìg8±N.ÝÉ…¾‹“K½ð/."ÓƒóòLçqý‹H²:„14îÀÑ¥QàU8¸¬~‚^ŃË] „ƒKÍ ø3Jɇ]`˜­ÊÛ÷ÿâAdosW¥Wq$¹µˆÐ«8pšé>­ô*œf#ô_ œfêls{Ù.ŽÕèU8ÞÔ¿ä8Þt·7ʡ!T†¶dÞ¸7¤ï†6ÚLg ²LàsLhÖyô²:µÆÀ¨GSÏ(cTå^%Ðè¦ägšŠ…EÝŠç¤R­pB&4«6¯ópB6#þø€[qà(U1P÷†o ºÎVµ•„S’c zVí]℃EõCâDTŸá‰ÆÀñ« ™Ñ¦¶pà•ìhSÛkÔåad©gÛ^ÿ5éß8´•)µ¦zL:0é^… s‡÷ƒFÎy¥Há§ähÛ˹DdŠRUÙæÌZ]ÂlÛ ßå@3OŸÐRÐ.y™¾Ë*„ó,$ivk‹ ç%¥Ù½e ÎŲìàŒua!´z¡ ƒÕP†;“âì>ÞÊtg.!]å$z‰,•6Sã·ì« „> "ì°ÌLj>•ºÄ¹[>ÎU…¼°Lijg>$În/p Y?—š‹ÄÙû]Îô.¨j@æÃDšú3Is»Ôò¡ "*·šÏÝþŠ@è\$’T•B‘¬‚Kµ0‡Ü™~Ð*¤êS…ÞE"bfú·]èÀ¸"õ°,}ÄH¶,½!ÎpŒÖõ©Xf…¨Æµ[–È°,‘iYžH£wñ BÆõ[-[˜Hµ0Ï:7¸Ÿ<¸6´Ñ‡q霶,α§G?,γG;7*êu ŒÞöD2>Œ«ôz?åi ÷ayîAÐé^¼Ž“Ðeéú-<ÜTî(wRTì¨ç¢ƒÎE‡‹¥ ƒãzª¾cZšÞ²,MSf˜ © Ȫ狼Hò3T•œ†Kµ™ÍÂôaV¶™r¼“ÎÅëŸp.8ôÒ¢º¢V˜zi% ³hÌ0eòSí²è^$r¨‚0n²tÒô[”ÙUo­iif™+®[I“Ÿ†ß¶$kC#´T‰p³™aýFx@H³,ëÄp‹*†9t!Gðä–.•Î­[†4úEÉ’%Ͷduç¤ é­”hßéª`¢ ƒHö3CâlvÆfMgÚˆgM© áC†ÑTÇe9ËðO l¦, éK¹IšÍ§tFÔìBªŸ™4>Ï•5È¢4a éÛå4›÷fdI³/fI."ª^©²=±ÐK¥Kžpû™!ynó Ód2!Ü¥8 ÅS7¢éûˆòl>hÎt$w!è_¤=3]îí Gµ©S¶'â×\ð’8ëÔ~(ã£g Z]÷Gk*Ó×\…ø¥&Û³ö=$[—4qjªê´Ain«-c˜¥"D*Õ¦ç¶õ2F=ÅYëîœ^$Îm!fÏ‘\RG2+ýÖ8MÏĉIìKò¬qÈiÐÃHD^kÙž‡í—4ŠlÏ-‡Ñ(Ͳî~£K˜Hɧ1´“(S†z K¦gñ™v†W›¦ç6¹3¼Ú‡O³Y$ÍÒý©Yµ‘À0Ðexb¿£oÏ!Y»?3ßÚGÔÝêux#Qw«¼‹ÜGx¬ì}DѶ+'E² Ì›îbš÷yOÕ½H[ã¬é}„XY2=±­a9p˜O#ôkd:̹aZVüù(ÚGdïGr–ûˆÆ}èh6šUÈ0aV5!“ÂÌÝÒ…S; „!I¦çHËp³/#ILÕ;ÃjË-»w†Å&,ïÜJìa¦çÍÊ Ä dyg˜%Ð@¼1L:eÈtÅW!ƈ&§é™í^¤éç¡Rs§4©êæ!i&ûkYÚH¤³÷Ê!Ósø’dz&EBP$LXÌêàR%ÌÔ·èJÓ>bï´2=SµÞ‚?Ÿ¦'zÑŸZ¦÷ë~Ê2ëôŒHy7*æ>MϽëÏtùÑL̵K–Z ‰ Ÿ øô #€¦ç±ö€l‡LO }¼%Éò˜Š‹È  ,±ÕªöÇØ‚jM¦ç±í{hzŽΈèF´0å~<ðHDë@îIûˆ£îÁ׳,Ï'H‘åydÈÒ$Í}Ø’\Àf&+Qp'à2K†çá£Ó7t0˜5žRƒF"Z=iÂrÿ jI8¸°wIÀ ×ê»÷u%ËeÒÁÈS&=2é_°Õ<}&]D x0 ù$Ê^}\CŸv_F–„‰0^¶á6fÙç åÐÅTš p`z‘‚©G“cªØ'‘’Ca–½¤€˜#Ó^R¤S…h¹1Gž)ó£2ˆ9fq\H …Â,{8 v¯‘&ÇTv,rFdLO ÉÈ”<³…3b}(Oì•$9™ò^^þÓ‡ÕH¥í‰ƒJǪF#]Íf dÄÑË”pÎÛù[â5‡ž©œ|œZ±c âè· jšì•Ïˆ+¢“)í³ Äñ­´·²àæÈg8lN›C¦a…Rëö4îCs°—86ÿ.# æ'φTɱ­ìhLŠÍ æ,ýN.ÃnÆä¨ö jNc›özjÎ2â¾Ql =£Ú æp ËCAN0>q&¾ü–<@<´Û4½vÖf?ãÑm×Î0_"o¥D«Ž¶ûFŸ®»cචØËx”=ÖpJ‰6Û„@üTYBÜ7±ÔQ–B2ìf<ö6»bmB<Ö†RkÓ!ᬃVå¾y±Ã}á©8¸dñT\h;œm /Ê…í®™É/íűZVíËSQA:þOÅÉu–Hò3ƒámðʸ{&ýQžwÏ$傈§¢Ø‹l£ „7Ѥ·–hR@¬©m¿N¿‘*öb ÃSqé—þ^~ÜÑc 3ž©f$3RÞ«i„óœHPÝ——AAÅ9X³ì~iˆ1šB’‘)Q„’‰2D¡ÉÑŒD?“×´Ær¿´$ŽÜtÃH£(ìPt‰r Ï „¬!¬i ‡d°søÒÞ…œCInÆQ YòÕZäJr(Š/ƒœ3§õMf¨}‡w² £¹N¹‰´H@S£²Z;<œUýPD‚Ô=CrºÃH•0û^>Gaö½"¶Âành:Ä4ÉF–_ÙË!âë(Ê^=1ši‹ë.¦^GÊ®Î*ò_Œ¬/ùq PT;1Ií~F>E¦öP]Š|Š8`hªK¡‰Ò‘d©.Šh&’ÕYU>ETtU¯R>DU¯’ŽÛq¼QUpÈ=ŸªÙàÉ‘7Á*eêÚe„¸ô.ÄãJ‘ðÝiOˆÈ­ˆÃ«&¿"+;ŽlÔH9tÈŒ÷°’ˆˆG–|G'?Y"ZñÈêr+ò¼HÕo1€Ã¡8ñR$ØŽK*ˆ²¢(¹«" ¯"€Cµ‰% ›UUÕ&& ö8gUm— "IµQÚÃŽ3°¦Ú ù‘²fé[CŽE EÕAü$ 8>§ <„$Õgʵˆ¸¦ú€¹À¹å ¢üH±?1[-H»ó8d“Äv#‡ª3yÐqü§6LùqB8UÑʼnx¨/¹/p¬hÉ(["KfÉ·ˆ¼@žó‹F^Çé¤E³H¢íÎ&Dd(ËBµd`ë·ÃxÖ¢Ä  B^±‰À¹¨ƒ`ZfÌX΃Up[Ù(GðÄè2cÆ:,Æú6!þ”‹}Úy[VÌ„ÓÛì‚ð䜔9BS†AÍÌ.1´W*ˆ{†4H0‰±)GÄš1ˆ¹†á D3&) ¦#Á“41BÀ!M5ëãY~E š2ä2g¥¶úx.Jš1}x]çNqNSŸ bá•þÂï û$ÄÀtΌê ñükIú¸¸‹Ì´!U6^ç X Ãë|·–§SfézI‡Ù< Js8觀Aiý's$RôiÄO:Èз«œŠt¨Ý .¢•£ˆŠU@€a”¡´B¤™:hÕ†¥øx»€Ô“H $ñ;MŸnYéOvž’îR %ÀüDæl­K–}îÁÖ¦ Œ=ØÏ»óŸé¹H]ƒ’ƒ=DWê"Ùoù2ƒ@èd$"¥Å[ì½:oN‡âLßJr-ÂaÛü-zM;œºn—h4D¤ÀÉ¡<Ë²Ý NåY¶y•¾¥#•£šž¹#'àf‰¸Ø™ÿÑŸš(N ý)¹¸Yˆ­Jäf‰nED²)Eò,u·JÄŸ[U(D†ßÊ»U…7DܪzH¢I Ïb/i·ªÒƒÓ‘.Ó­RˆH‡×Þ­ªtq«Òáëw«”툅Uå\D„€›ÕXHßmm‘ˆG`+’fn»Mâ-q›•\Gp‚G RæѼÊ".2É•%âbGR@%8 ¢yNb}ÒnT— ˆ¥lsñžY".‘^^Jk7«+÷"r¦zb) (}I´ÅÎXuÖ(’f»U n둶-§ñSÎZP²¨‹DªK–o$RYÔE"Ò`æp$§ˆ D.Œž¶ ‘Å]ìZ‘ ‘9Ò¶ò”kHñ‡¦Ru%”¼ý”RG¶Qʱ²ª¿x‹D¤ÔÁÁÁ6!6~©ù%Sp H94;Ÿã—,ÚbG¤ŽÖ©,Ú"mîÀÊÁ>’á=Eˆ’/öÃòV6 ’ Ì̦շ`+Ð…hõ+‡ŸòÉ~)‡†ç¡“ýRÄZìEbdE+‡¢”žˆ<‹ˆ_j~«*ùÞÚ&h9ÌØ·”#¥‘{[Û¤("-Ñ–¬æÞ[û(¬l$𘈈¸’™TÄZdÚ:mÄKnú)›¼ä®Ä{Ûr±J¿D6989L¼·Ì.E´E"*¦$åÝ[ÙjƒUù©dÍËq˜woí³…"ÚbG¤ÙtÁÉ÷äd/E¬ÅŽð´á‚åZ¢9.ÇIJß'#£µØ‘„Z¬ˆµHD̉Y;Bã4Á@ÉaòÅé«qJ©Î¾8›mt\CYÎf»©4g_œû°¡4§_œuÇæô‹³ìñØœ~qæ=ÅZ$âñØœ~q¦= }‹m:€­€’Ãì‹ó°‰[Ä[$"·ˆ·Øü›ˆ³/Ž}Ü°c@€“Ãì‹ÃôŸRÄ[$R\²Ü‹H=.½NŽ²/vî`à0ûâ·¾ànl$h-+â-vDQJíò™ÕQZf™|/»¹™(À” €Ôcq±#‚³ûyH=âffÓÇ–žòÒ±ô¦|ˆµôD\ìÈín鉸HÄÒ[ò."êÔÒcžs–y‹LpiቸØWžˆœ‹ˆoµð–¼‹@,¼%òÓKxUÌÅŽ8Y ¯Š¹HDÂ+GÉ4·!‚»q˜L³oC¬œÎVÙûPª˜‹D’K–{9õ›K¦{¡½š| àÀ!åDüDäÄ@@°ƒ*î"-UÜÅŽ0b-¸›I Z ÀÊõ©[8;jëÞ‰UQ™|T;±*ê"”árì%Ô\Up–Ïjƒ˜‹Š ¦iN¥7¶÷1ñi'g²QÛ4A"ß´„È4©e'GݦIu‘ˆLÜŽC­]—72 å`7‰´«Ë%ˇDû³Zœµ:¯Tq»ol "#BǵãÄ9E€ŸáæZ󪨋D—+ÿ¢o‹ "ÿ"Rp`{"Ý£TÔÅŽ`wRq‰x”*Ó0SÐz”6ù¸`y1p½…ˆ*ê"-UÔÅÎØ{5«ÓÅ@ ÒÃødú[rbÐƺŠ¹Øq×Fõ3r1â>Ž©êu¹è¸Ày™iWk;®ÈISˆÜUÌÅ‚Ž@ª˜‹D¤I‘û83c¯ò¤”ªŒó<E\ì`.x.’¸È¼¿ž‹".ñ\œr1‚¡…—ää%ÄsQÜÅî MˆÈÅÄsqÊŲ…‹‘‡€LppàÅ ACõu‘ˆL˜*îb«C& 88ØLÑŠ[røˆœ”ªÜöÜ­UäE"Z1ªÈ‹„·sÉÅD >nÉIl•³‹–&ò"-øMäE&`äal;7}7§±U‡u¸9³ 9\ŒœŒ$Å°MÜEæz–©nÎ c ·äÀÅÍ7j'¨9­ Q;›¸‹Œò1òþ##u3“ØQ@ÜÌ,O> Êˆ¹HÀÍs·3îffù¸™£d£òn¦JM»ä-,›x‹·©EF nc‘#(Y6ñ‰¸‘EF’ ÔHÍ["ÙåÈÃñ¨˜z8‘÷Øm±C¦³M´E"nd•ƒ#Á¬t08\Œ r¹b.vŒ'·SÌE"š›X&[•w;ʉhnbE¢z8|¢41‰¸M.Fpφˑ‹Ñ7EáZ̬æn¨˜‹D¤ƒltÌ%E¿¤€`‚0—ûòÍf s¹/G2–&æ"?"#&±ŒXZÌå¾_Q`±1—û2 ÀÎc2÷¥R lCfå_N¢[šy‹Ì宾r0‚è7\Ìp.÷môÀ*æK¾å°4Ñë¾c£Ø gÖxíaØ3+ÿ2a ÀøgVþéô&¥™¶X§C0J3m‘dEIδE ‡Ë‘‹ÊTË&vO0>Ï,ö¥™¶Xç>‘Á¶Œ²œÊ(Øð1-ÿt“‚="ª<«­l#a}).F^F¨Ù°ÝäEò4‡y«ˆIDĪûn“‚}xg³œ¥t³$—3œœÛA8:`rþéKÌ Ž ˜œ,føÔ‚ˆ¬õnö"V>Yë80I#7#8«ÕÅÐüé^@‰ÈϤºù±ìj¾âìhf!ÒK8•‚ùÉ{ TŽÎ²ˆh¾vóÁ³.G~ƺ/•)>|밆ˑŸˆÆ2Žþ²/IP1<.$ ‘ÜM`ô•|Däf´B„‹®pw1rfI.G~FX2ÍåÈÏDcÙ'¹½*sz‡‰h,wsa5éŒÀ§Ï¼ b¹ùT—C?#Œ¯åb¸m%"K·›ÂèK ‰ÈÓDû1œðëñŠB¯@P\ŒàgO#G#oTô[ò4Ê~$ G#iÞ(],)Zxàe©¾C ¾Š³ÙX’ƒ‡¿³K‘ŸsÏ+ì$»äRäg„ l›¿D*Î.Š³µ-à!?# xkÉ{=,`óÏ›> œ|g+[ÀCŽF ð£v¼L¯$meàʺSÄâUÒôdr2b»`á"–Mªk wÊ›Qw¾//eY§…kê"Oß%/#ö*ž¾òKwï^ˆTÚžØáxúšºXE­%"7#Rxú.ºhöÂeÛ['­Dpô7#š½ˆ 0«¯É,ˆ2HKˆ‹‘Ÿi†‹¡Ç‚ˆŽbAYÖäýb'(˪„0¸H›; lþ4·‘«lD¾ŒóƘ‚€eD zˆÀˆT:M¢ø‘͈ø•ÅËigZCDö¢gº¯«éFähd¢ µ!3vç­°èå# aí!Þƒ£aÀ"Š³T5D#QœÅ´‚¨¦cÑ°FäñÅ-eˆ¿@ƒÚ!W¼ƒGƒZµ ñ—Š<ȹь,ZŸðg•Ÿ'èˆ=£,³3 „°aq^ÿSøÖ«˜GDäÈ"31væé Ad…é«â ¯•xà=C²¯Ó³æm_!p¦gÝÙÓ‹ã‰T#r4â´DûuÄ:ö,D†oyg«ÒZeYŒhB#“ÂÌÎ WÑy$!ÒÖˆ-¾>i©2=³3ØÄ R˜Ø»èë¼ ƒ€ìg·b/\-šÐ’¥õ™ö9Bki~¦±?5ägâê  M}7]¡¿DtTÁ€a4+현ëV¨ms!6™MÛèBD3šêþÖ̺*•] ÐB…ˆkÖo=!n›MÛ+†Po ¯éÛ 'â–¯Cög:;y% 4ùb³‚xu ôX[—-ê0"nù’£Gnùê²?¹[¾ähÄ¢[Ž}Æ¢–OŽÓ÷­ÏÙ„ ¨´>GÔp#j8i¼äk›` Gè’¯m‚d¡K¾vƒˆQ¸2)Iœ‡Ó+_vBD O„Û‰Ã9 Ø%´>íMK…â<œU¸€ÉÒìO-î'˜LIH–£Ñ—ž!•÷›-#ò4qÓEóé8"vÓE"â¦göÇÁòþ–\@\ŸrèÒ¶}ÑD™æ1–Óm’TæmÛ,Q§ Ð<Ÿºmž×¶ižƒÅUŒH§€§Óù–©™<µ„øS•QrY­\¬ˆF4ÑAË9šnŒ“Ž-®L!Òq êÀüô=öD%@Äõ1±ì›9 ¨:(jDþÆbq6îÖ;2ué;Ñ•¤ÙÁ]¤8ç>ÓM‡âœûL‹<ɬ{ñ´„€]™šÃI:¼ZÐ@Ô™F#ò6"ݘV4uZré~+{¯e‚*íµ¦yŒð¢h-7–ˆÖròg‡®ûëFøU"ZËMÕí̘fDÇ2¶ÿδà§N7"#UG äÇ»‹YËD²‘"qç™(dHO!ÙhÕ¼ÄP¶9ˆ9zÉ9ˆŠùÛÝ~)"ò8‘ùfªx/c›o$˜!ú’Xé¼AÑïÈã@ÊLÊsì£Òæ“ë¼ÅF^Í(=²N3¢‰¿Ìe„CNÙ²Í{uøÒ¾B¸€¬ ´œ.«e.#²ïi¢¬Cqö[ ²A7A· ‘LP ÕHö[NôTÀÖ¡8»¯,Èô@yî[)ËRzÛ^vŽÄºÎB#àöt&T;Ágp¿‘÷_ªU™>C"‡‘ª—Ìë-`æPš}û—éŒÈp¨Ñ®ÎhB4úÁÍá[myô#³LP ýË|Fxn5$‘Ï„òlΘQ˜òdêFÏaG·Ý`Ó/uÉe:ci;dÉ™\xU¨D^éo,M4œÂ”1ÌQ*`êè•m| ; …¹S1–e6#Ê%ˆ—”z´Ãoå=Z’0Û¶ñ–éŒLX©¾ÁWuûé2ÐüÒ¶¢—rÖ?ÞZpˆÒ¬û\m‰ÍÀC ¤ˆýÒgzôì—æ½è†Ù}kY¦3‘VZº1¤#.ÀËÛX¶oÌ™¡xÉ«”óI%!R8JBÕ™Ô€œ@<MìÎ <š^Úß™±ÔmŒ,“X ˜ÌXê6Fö‹÷ËVße6#ÃoÉÕˆèözU{Ê’}“î/žýý³ß=½1 ©=Àý‚÷yÿNlpß¾zø‡‡ožAäј‡?>K?ÿÿÓ³ãá'º~8zµM‘vÞÀ…ÇìÁ'¾ÿÔ‰€V¹ô³REï?>u"—§Þ/ÿòÅËSÇÃo¢YÑ*üÏÿùòÍÃß¾|ö£ŸGÿÅò"Ï/-á#¼ë'll8(¢r/ß<ûåíxþ"ÌQ~kÏ_,òþÇ-ÏÿñåOŸýøeô]BÒwìyÁ^Š=æ›a JÚ3¿øÐS¸Ï`>"Ož‚&õú”‘'O™pyêd üâ{µx|êZ¯?¯‹Ð=/ÐO‰Ñmùf±†²^¤ç/ J¯…þ*̱[oÉÖuËßï®-½ 3$FU*º@ëí«?»V[p̨Áá($Sp·yþòŸ«Í[´ù #hð‰Ÿ}?¿ýËçÏñ k†ið¯×ŽSá—Q&èlGÌŽŒ¿¿úØäøž<«oš{"ÏNŽ[ê9I?Ü)1cq|w„²½tJXˆô¹F ÑÚWo}¶öG?ÕryLÄøxxùUˆóëïBpˆ{9ÊíÝoŸcU­±\·WÀÁøÈ·ÿãˆ^··o¿}û(aÖ.¶9o?>‘{5̶ãIÁ è^Yí|Jç‡æóÓæœå!Ø ?é†_Þ~}iÏïù7?×í› þ¥Ú6qIèíÝ×ß~syî?î¾É·/®øW£#Þ—J'‡† Q|ùQY Œ¾éG¿~÷z*cäî+~æ˃¨žÆé·oþùR×ׯ® |óä×7Ï©ûG¾½ûôù‡Z‚£º1ÏÁòؘp쇪¼ý—Ïð7rÛQløÅãŸç`ÔÞŽƒcçî|Š‡j×>¾=©ô ô‚gz±|Á ‹C¥²€ÿt‘ì7OG3Kµ—(úE¡'¬Ý¾øŽ¥ñ®«XL_Ð]7ÜÚëWßþúù ÞIx´Ûç·ÝYOÛ‚¶-é¤÷›‹Mg‹€›‹ŽÄ… Gº}Æ"A€=ç¿Ì™?‚€æžñ"£úç}4pÒ"¼»¡PE#%‘wz"ìbÄb61Ò#ôy,Þ)Ã0ÙCàýšá"ä á ¸á0xñäWïþë‡ÆÝ p"¾Œ®I£‡¹•ZÍ㨘 4,uëDéûo¯óè»'KÁï~ÿý)¦±f™±¨¼þÓsÃ1‰bzߦõíWù!¯tû6–}¹­hì»Ëy»jßÒØß¹¨P ß}m=¨¢ü'|ü‹·¯ð™Îòíí“y~U_¼ý⩾|÷öëÿsýýÅ»¯ŸÃ0¨¡ü¢/p{–äjܾýõnÙ^[O}ƪŒô´1×5êÍs8´Ž’Ÿ ¯ã“À¿Ä†ë±œVnúzsíË3Hg¥·|{óÅkivjÉSâgÏnÿ>Ø_¤ã ïšU_uŒª¯÷æ-8]¡® k”åþüƒ“ÞMÛÚדi{c/°§ÂìyÇ^ìi4ÍÒçmÌ <›·rã“ÿùÃmÚKuôʧ’ö¯§3ö=“ bóÎÅ<ÿP18¸‰™ág¾ú`9Hû…öë™Ï\Ì“GÎçrûço¾}ûæãÖ(ße ë¿ýØ‚úd|haCÔ'zûøx/"à*úbU‚œ»Öï|â±cøøˆÕ3±ýú¸ðdÎýN3¢õÛŸ\~¬Ò¿¾<ò¨’®ð•û‚è‡?k4­ñ¯¦Ù?0É2Œ-UëÉj†ü˜^ ûÙº¥÷†ŠÐ¹^*` 6' îÈÚ õ&¼îU@Hù;ß3xìßm¼Ô´…}^?›£òŸýÐΡÊÇÌøûÞ7ï)œìĬtOÿÕ‡„/b+±g¸ãþÍòCk{ÁÐ%‹Kóÿ—Å=}xqÇñî1þ\…ðÕ+ä•Þ=rÇ/*¯jaÁµ‘‹ÆÜÿ<×=­æXÂcB®˜`Þ'€nÕÒ9ýO“_›€£ß>Ûû|ËcµõÝïÞ¾ûü–?þ7Ý w]O»ØË !kÎî\Êc•ÊãÆ¥ùÛÏŽËÿðø+ÚòúÝŸ>+Ÿ?ÿ¯Þoýá35.}þü쉤ç/=óú_}vŸŸ>¾5ýì“ß¼ýâO«ÕëW¿yõÍWŸCé¬ÈDO~²GÛ'gy“ †í'®ˆðõÊ¡ôv×|úøo¨|rµ¨ Ï¿’ÓÔäüëû§]RÅ?ÿIX•…”à_Cá±cÕõ!y¢E‹ž€'ÄV늘â@¤¨Œè¸ƒŒbƒÈ¢CšÝm‰ t—Ët2‰i\.]rž@Uœ×›$ä  Âì„ZGÂX²äôq ”CÏLƉ¡ ?!ø#¶Á >•,Dù ÑÏ΀´„Üg<±OðóËM¡¢i)¹T‚‡…-ié á„ÜgSÏ †m%^\Ã|f¾ó'Á¢¤lHŠ…Ê!éó—ñF¶ùáúPdß>˜áÖð=ÁÊ –‘7ÌW:+çU†gAùóS4e¤êÚWÖ2Î7#£–¯ÔúožYÚŠ` à¶³ƒ8ßQpwº*^·/ÄŽàÕ€¯ý)xCæ´C˜xëZŠ‚SÞ—·!6èÀQÁy3Ì“Àؙۆ díK'’ãU±¾Cƒû÷Ÿ*Óˆ 1V3ò(‹x à¤bz:ð£c§Aºv¾÷ÌðB^Ó·ï`<k®Üíˆ båÇãx«Öp^qž“dÆI+ã2HoQ0Èα>„Ä s†3Ó Ç^ά¸±ñ.çFìsŒ(~'¯Œà;±&sèfb¯3ÃcØ}¼!à1#aÃÙü9KWŒ2¥¼s£efßfòu'ÆÒ½+Lfžœr‹¦(s…O'rb Œø¿ÃY‡ÈüËcœùmtw+Wwg‡áW™P:9ÁeÂLÐN{ {¢•ÁÙi"`ª2!suÎF0µ²é·ºi“U0|¿Ðˆ¾Ò#ƒAí̈lÒlh‘æ?6ŸS±šÌ|’ );£Œ}\.(³3¦B`úãböR{`îcó³:c>ˆÌ“<2Xì«œèP'2;Opf>m=ƒôiá¾È"â0Z’[8b·‘‡AÄ!Ѥ";2q´W 0ì“ÈrXc…(ˆFÉÇ/ÈÒ¥ÂW.'€<÷WD¾æGd{F™úèO<£‰Ôã«gô\ µ–¾9?‘ÎK`~ñ§N!OÕO!NôéS¹<Å륩õ÷S'r}ÊúåòÔF.O^…}}êD®O5…]žÚÈå©÷Û}é‰ËSǬј¨È;Õ‹=¶/ÊsxÀa¿½È—¿Ã¤¯à-­/ee:ßCÿ™÷Ÿ·ò}åÅž1Âü0œD¿øÐSv¶>Z=OñÆöãê¸ÝÈ“§¬ÿ/O+Âå©®•—§úNYyyʃúòÔe˜Ÿ-ÂÍ©O¾¸‘'O¹Ý—§.=ñ:”‘u+ö·Û¡|‡™Aî·§„ìÚÜy§Ý¶Íéæ\綹yGà¼ÚÜmçVo{`?ÞÅA¼> stream xœµZ[oãÆ~÷ÈS è-£Âbæ~ º6A¤‚Æuѧ¸¶âeW²Š{1Ðßo.$g$Ò–ÒÄû°É™ùÎí;gÎð—­Ø‚úéÿÛí]Ü_ürÁÂÝEúïv»øêúâ‹+&p§rÔ±ÅõÏq[X¶0ÊTN¨Åõö‚0¾¼þ^:YÙŠs÷¯ï.nÈëöÍ’VT è#M×Öm³yZ®„à•³’¼^rLh¹ ·Ë•Ñ2«mùã}6C[wk?ZâŽ"_ï¶ÙÃø¢rÒZÒÕ]³{H iA>6ÝÛñÕ]ÿÕ·…”ŽWVÚˆœ\MÉf**¥ã½p_.WRC®³™É:ƒ—‘´˜ƒWFÛ~Š«B€ŸsI— d@¨ŠÕþÛ’ÛŠâ}RßE*NÞÕ÷‚æZs'1 ÆðTq?ÇJh…n±ÂlVë8—ªXµ\)Š‘”“×›æ6èpïAIGcq²Ò98«8£˜øû‹ë?Ýôº–»  .F[òõÕëü/€t$—9!—¸ ÚûæúâÇ Z©àí3˦–S#RY ¯½!_­÷¹w?Ö›å¸êÙñ=xµ—Ë岶»`0& ùÐÜeÞº>@´FaÖýSá Ý®knÓcÍ ÙµÛaò‚p|ÖCÁ’õf¿íâÌYÔ𢘭rlpüŸÛ¥ÂCgüǯQoÇ—&Z Ÿ7f±b¢‚wÚ8Ï®½+Ý5Lb$£õÜÞÈc»‰¾Ê$oÃcp¡$w¹Rã8C>sP©±Ê»ÄYÌ&Æw}sUø³• ‰fÈöÒ2:<î/{¬>Äå|© Òn…ÂkÐ[{Ÿ»É6 ëí 9©Òð¸}/'õ>éOËe6›j90¬„Ô‘i0‹Æì`WAäU÷<ÃÈwKáíÈn}ßöœmÀrÔ·ÍýÛ,üoeÈc»¾m Å4Âõ) ˆ?'íÎ`o½Xq˜ŠSü=7Á¶¤kúßNàÙ_‚ã©·i‰«@²Ár]ý4®”ŒÎ ¤ óæú}È¢¥4ÊQ„ë‚„s’‘v•`Šó=H:¹Ô[¸CëÃ$N:É—½KÙ #fãù8§¨å³‚ÌvƒReµäyÙ¡k‚ý CG‘sÃ>}VÏn"d ²¢ÄšOÍAYœË9Ò'/fŠ4l*&•ð´€íÀçGÁ[ìÈçûà‡©yϤ, ŠYnB|‚4–TrØ=åÖÞ—yÉs) ÔV§KTí¥ðøè‡ÀNÐdО ™—ì·uëƒÒ¸°#«ó¨¬£­õfó  ‚„Eì,åY=V >¦“”×ýŠ|*ù÷¾2-{?vž…8É]!×O—æGÔç¯Ôû"pïÒ[‚‘XìëqpéÏ1°ŸÏÀ!ì­ª´5ì ì?æY£¬%éA œÁu¬ˆóØÙuþ¾ …ä Ù·OýPØ°)Øcó”V‡!ZŠÌ ¯8âVÿ.õÄ¿Kã¬!Çë2ÀL… ÷NÐïQû}ô3‘sã­ AÒê&xaÁhAJ9 C}"5…}~b ÔøR¹¹ô3“"†½Ô·¦jgd‹ô|æÛ¥õ²w˜¶7Š.k:x g±>?¸T—q[ï2ËP€ïòD2½wP„£ø!á\Í1Žá•Ð|ØFœ¾ÁËËש÷ýHí¥…öiã7¿-9j¿oŠìòoW“«ÝvÙÇßœîGõ4‘€$Ê–9òoJTXù6ßwÅԳͅÉݾä²âàj¥x¥´IÍ…ú¸¾êëŒ~ïe ƒÿO£A_Ø|i˜·òöOšðlÓ—‰výgðPëbí†JÉ3÷Ýh­˜ž9¸mÊÄR)¡É¾K-·0F"ûzSz5ÏDd$§Ëø’°|‡Òî»8U¤é”.|2â*T)ϸq»{×ä^wßD‰ÖõlÈ~áR»Por?HläK:nÙ0šó=ÄÓm® •EÙ{r- a[Ýf5u/vdE· ꧜òW‘Š„1(VÕmŠ.ÈvÿeO3ná+x®ƒ(ªRŠ;¦«¿`GpˆA8RÎÝîÝ^ÒKN)…_e¹Š¹Xcù‰ˆ~&ª™Håá—/sÞìw›÷ÞãxrÛzº CÞ?÷—ŒHpš5ëUSàOE|ÙO¨á"›ªÛm^±õŠ©iI~Cøô÷@ÝßGÑõaݾÙíׯ®¯þñͼ0¯ÆÅØåxÍÿíŸH;8|„ýßñò»ñïr® [j4‚ê‘ZwÙ«Ã맂Fzõi?N0:!Ü÷«5‹Æ lizÉQòY”ò ”šûf“¶1%¥¢Fž†Ò t¹ fD©ÅJ1‹ÒžRÀׄœkg„šÚÓP V)΄yI—ò¥ÐF¦ÇÛ/Û[UœZn5§°Gö9 #Æ n© ©i`‚ŸÌTÊiC}]ÁWòTåùn&ƒoLÓÓÀ´<˜¨Œ3(e%Eè²­ŠqŽ[1 ÌëÍíÈW/›Ó§/åŒõi•)|ƒÃ„œ7 ÌÎãJŸŒÅ¸ñÅ ¤—’%„áB¸Å$´^¤0R0!Çpðç6Çáàf¡*ÆÏ‚ŠŒëÍ«\5ïHÌ/B•F()y•PÍæ‰1³€¼±uÑ) þ§:µ} â0’Ê™6.37c³À8•ö,` Ĭ,öjB1F}Ø ;L‰ \|—¤NŸ‰ Õ0¼µÊ"ÎÙ ¸À!Êk â0CµÍa‰YX–9~žþŒÖ %¹ë¿‹F—Žå“°C• ÉchX 9AX9>y‘G¢¾ð2‡MÅ $×ÃÂNU:Å$`ééx-‚)Cˆ‚¶§ ,Uþ¬£>Kœ¨:VQ+(ÀhgUOcÔ~»uƤÅôÇÍKÑatÆiªåæ5GÀà§2ŒŒš!ÁªypŒ”‡v9:êó&5F)e}šC±³PàDLÊߊ¶a¦TtÿUüÁ©-­Œuƒ?ü°K-U¬äÛ`ÂL¯@yÀÈÆ-n|txᛉ,Îðüv×ÏñŸ=é_oÊ­ç¦_C>{€7ߥœ“<;:*Έ6wI4¥Ž»Ÿ"å@ú;ÅËó ÿƒê6vüQäk¿Kª÷ýbòè˜0¬§ñVÏ{Í…p©µçwѪ·ë»ü´%}õ…3P®Ó‡µœ“ðýÈšbö§®Wyì¥ÔT>*ˆÝ@-Âñøq'<.×¥5œøu‡;B™ðÉN<€?Ø|gï¸c˜l›ÆRuôÕI¸Ïd‰èSÑÀÞ ;/‰ñÚ_sWHÕÜ¿M`‰úÔÈŠ¿§^_r<Á8ï¸0Œ¶Ï® –è%Cø¢ä‡÷ÅVKèÛÉ!«}Û´û.œ¨Ðí>°Bîõ@”gŸÒ§ B‰þL®øÄ%¾•N|ý!AäçaöW~Æ£.{Ƭ©ïúÅ/Ûš†WØ#¤ÆاÉfXå7D¦ï†…r¿Q‡½šœ<«™ëÞÖ©g²Szð·¥Ô.„?“rv~mWIˆe«ìÍ›”‚ÊTêŠÚØÝú´( ÙKÞ£˜Î¼ÇǦaô߇VqèÔæ2žðIj*l°Oø¢„Ӥ߮>øêÁó»VþTµ üfÃá»ðùÇ&En|“=ß?ø³uÆawS|"&œ— òÇÜën9Ûâe|ªÅûùn]ÝeEÏjº-¹þôíj‘ Öqp9VIcg‘Mô+ÕA¯2u+ñÉÿÍCò[endstream endobj 157 0 obj << /Filter /FlateDecode /Length 1647 >> stream xœ½XÛnÛF}×Wq¬\“Ýû%¨ûP \4j¨OaÈ2å°E…’mÿ¶ÒÙåe—2eI©m †¨½Ìœ™9ÃOC“!¶Ÿú{šððnði@Üè°þšæßǃ®™„‘Ø`C†ãÙ ÚB†Tòs1TBņ‰á8¼Co'å:[Œ"Æ( JôößéˆÊØpÃÑÇŽ±`Š`ƒæ)ü0T ÂP9z?þÔª¡V¬ j|;@„ÆÂ*†&6’J»$✠#&b-¥]õ-.G‘ <6†"ráŸé;Ã)ÑzBô·¼ò°–J÷ŒH¬ˆÖ’A´’ÂPíÄ +gr³ŠÓ²¬cîÓrL•Ñîp„سÀ¹~ŒÏ»0é^˜üT˜TS©•¡\B†I„€c,”æ’;”»ÐØ^húthö_.f a.6HdžiaÕ ßƒÇ$œŠH?| 8. [ŽÅLpAL #‡MŸ‡E?NF¿'˜ñhœü+'?‰²§äOˆSj'áÖÃNkT ô%[lD0+£˜oÖi3"H,Ê C?zX¸7¯+iZGM.+qª0G·uâ ­«lÅ5t Îþ0 \vc6 Ý[dÇaZMòz XBjtQOŠ6A\Ù5 R…²E0qWã0«0Žn‚©líeM¦¡’ÎPM9Y7ؤDùÒiù u.‹#ª!¥³îöÜiÐ ø’²$¨sºrõª¶45Av&àÌZC_ÿäÃ(AWiœN‹ü\¶X§wòu‚ÒíÒ‡O¾œ• Â`‘dÔë ÏT¦óx]Ì/IQí4úœ–7Å*½_ÿñ:%£oXMˆŠ‰}ã‰*‰ƒÇ5çÔ‹ŠdÏXT¸ÐšHøRäâ&ÿ%Ê?OTn8e)­Ø!ж(ú²óŒU.£”˜`&ô‘†­ %mz–ªC™$J ±p/lk¢(‘iÄzsÁãUþJS«g·0uýN]Š×å¦ÑŒ ¬LP’º ‘¦þ`\=‚’Ò‰<ò@©‘´=x-ŒôÒÊY à-6ùMZz›3gY¦Ól• kb-—Ãœ¿n²õÊ™«F×;òÞ{ý!§& 'Qn”í&¸ÂÐ΀äˆ)Tf¯qýÑBëžùç£|»ê‹’PâdƒÒ2›&hºã<àG#€oÜ~÷y2ߤN¨f±Ôpc¢Ö<¶}ô*kwä•€}ü!ò2X™ƒG*ÓtH3ª®QĬó™á²òÖÚá·Â‘2,À’–\*X©MMç*:j¯“–Dr´´÷Ω9*æ_C¦YäÙd¾r"È3èKØ¥wiž%‘²"‘×°Be}Àö²Â»F¿¶äÖ1K¸ëÎ"Kô\»•\¹ø®žEî[(•rˆ–e0>—EçWVñ^» ¤åí½“Iá •õ*‚²U­^«îi¶]®½¶“Æa>Ùê×EU³X´ù–gÓ°Ÿ˜Ìç_GÚªg]œÈ¤³YŽù´ÉÊ4A/–Ö»Eþ¢ÉG6èúËÉd2–„6oï“έð0ÕÕ‚ 6€q¿j²ØN*YöïMÐ6¢Éè÷Y4¸GìÜÎ3˜§m™}³ô»CIp½g›ÅÔFH‚–5§¹„.†®|Âèi!ænSk hÎ<ŽYQæÎò=õ³–ÕµO™ÞfS!¨¢­Њgî_»^òÙêU ‹¨}_Fvý÷O£ÊÓ|Õæ¾Æéý›öÙÛ{ë‘éû•9t']_u§Óë?Y•‹á`=ïûˆˆmì&XØv¾õhê|ûú™ï»3¬w…Þ»ÇvN´AØIìô¦¡÷P[¿}_üfp+l“PTgÇ´°€é´z»‡K¹€ÂDĉåN˜à ›¸¯ˆ–¸ðA„Õ6þ.È°‰5Ó;q]wÿòÙ21èç¼xvÔÈ«iù4/™¹„Eä ç½|»!øFÛ’ÏØ󼦮Õ?éïˆ3ÐÊ2ý­øã¼0x\àM³C¯1 Êv²_©zŒlj—­ð×ãÁïðùµµÀ¢endstream endobj 158 0 obj << /Filter /FlateDecode /Length 2790 >> stream xœÅYÝoÛÈ÷{ H¯rû½Ô®EMÑ WC}: F¢Ö’hSrìÜCÿöÎì¹KSW»@qñCDr9;3;ó›ß ïgeAg%þ…ÿ×»³rvsvFÝÝYøo½›ýqyöíåp§°¥¥³åõ™…Î i© Ëål¹;#TÌ—ÿ‚Å\¥‹¥)ã°~¹9û‘|×}š—E)¹¦¥%ͱ«ºfûu¾àœÖòÝœ@Ã8YϸÐP£L~ñHèªco ¸#ÉŸÚÝ]òÐ/”VCŽÕ±i÷a#ÅÉcsü<,ýiùTÜdVZVa¼æäjÊ6]”BX{7_Î5Y&’I¨î·e&ƒZ™(â*3à:µt”Ì4à²(µŒoÿ0g¦(a=©ÖΑ’‘ÛêÆ« ˜RL{!ÌÎ,¸)”±àJÂR;[€4£TÐäó…d¢°–‘7o†ßÕ~ƒ°oÉÈñs=\ìvu׬«mXl©»®íq"U׿ÀI³ßÔõ&Šæ¤½Ž¿i*™“úé®^ë¸1•äÐü\¿s¡t—àŒ¿ž-ßæj3©íÞF­(Ù¶7´\¶šß ÃO¿ñ á¿‡GZÊnš›&®2œ¿~èªõ×AúuÛ Öìî®»y[\ ÏASP&œLΆڂYa£u?ÒŸ‹4„ŸâÊÌ'ÎtìŠêP„ãY‘Çî¡ž4î~÷¥Ú>Ôý™òaão­æÓ:>S ‚Íý«¿)Ëh£!¼’i*ê•AŒžQQp¡˜3U1X§fC—Üú0ÔH(A"%}ƒÉVæàrƒBz²®·Ûj_·ÉM¿C\‹~Æ!jJã÷ø~n¬%xJB*X"Hš‡]ëQK«ªô¢ÙÂÉcªYÐã+¾§RjH“dÑïcŽ)ø9 dŸ<8™^èeŽPp êüïu‰88La@eãÔ™zÙT“Ûô…Öá…£|ÜûåûÇ6Xa$ù4_ ~Š¢ Nœ–¤âí¶;‚P Àò1nƒ)?¸bWXyÚÊ°¤))Œ‘§ãÁ§?†UL§"ƒÈ4–<ºK¡@—[æÒÙ‰5@À+À¢ÏÉÕë€óô/)%¿9…,¥HµÍN =+…Ëá¦ÈžîÇpóÅÆ‹WÌ‹wv:ÌüU•UJ³&“ð2˜ÑN`ÈË,Ü™ÍL(OP\Ë3Â’Z*Â’ñkr1¢`‚Æ:ønJ XÉ)ëËâ*ê& ó)å|o¢áÆcæ ¡ÉŽý¤yŸ´š–¼”Ð }X-Œèõf4ç¾>ìÇÄ€êÌZòYN F@<ËÒlñ‰ÁmÔ™©Ûë$!^¸ºGL~Ô3`!%Äê 6 à8]&Í,u>MyGµ ÷!hŸEjÓ±ƒqÙÍdv)‚d)vó4* î4›l!~Ô°MczE~ j Tà&Ýs—í3 CÈsWsÒضpX‘7¹X˜8VP,èpÎ× #ÄÈ ª¼”è½×™¬*]µÇN®6°2¨]ÜM&- c:*îÕˆè‰ äè"B€™PÉî’xšD“é¢åø3,ZåÖ7b“V ïK¬¸Û·ÝshÊ(æz0dä*ÏÆ!@ïÓHÀ²€ÌZcôl½ÇýÔ‹Õ³pìHA½{To2:L¡¸´)j¹hÆ»Ó&bÛã/ˆò5Ü· ?€Ò¸ÜBñÀÊíLáÏŠ é¼° º Z‡VÖq,…JÔCzp“Fq(²ÜšúÜjÑ·%ÛH9þ…D#_Ù6An]‘ô¿9ùøCòÊ÷WçÓéHK0™Æˆ¨»ëSºÁcÅ9¿˜;ŒB&[¬Oî-§Ð}Ïù˜Âbã#f5 ¥7¨Èéþ²áAÏF\×êŽ/¯emôÍB’†ñôÊïÛã”ÞùŠjg`Þ²/žÖ•ªÃ©*¨Šë´FFŠ.G^]pd‚RJSËDŸcZ@›ÜblûØD* X­!K0¤T¥Š¨4>2UT)v…­Ï»w!x ß¡0é¡ðryõ÷}“1rŽâ…èûäÀî¸t5Ò Øèà¶t3…ý)tÏ.°²ÐE:éD¾‚rG-$%ÇQ÷ïî  «.›:]Øxà ‹t‚!ÇL¹j|ˆ h„Fð ´ƒTnô7}ÖXO†Ýo!ž‘aW"[õ/_¤ÂŽC áÉðßöLMÆq +uîþ§cži»÷idORp>ÆÉœZÕlc9Èù“¶0=6Mò5ø e¹ÓüÔG=ô0àˆ£|M°¤Œvj$ÃtY {”@¢9{>‘ )] C=‘E/',´¢Ü¨Éä"E¯² ­Ž‰e^R¸™÷{ELfLö"ÜoÓ‹ÒyvçH¯»Ò9mÅÉËOùÀû³ï]1>3Œæ‹g>%ÍowÓFP$ϼ¨®qÁÍÿX×’~⿶RÓÞC#¼sî7ëä]†X—!/)(Â&<®ç!ÿÝ…™*4(¡ç¥œ ÝlŒLcxIJLL s _~‚ˆÍгbåW<+Vž~yÒÅcð.SM²sºE¢d‹#}‡Ï‘—K¶ÐÁô— ì@Ö§}C€•‘àðÄ/A>Ë<>[¤£âó&'\ Òž¬Wž}pœÅôšš”ˆ"æ8†ª”Ð`á)Ù³Rç´à<˜iÜl& §°RÒ¸æh•Ï.Ncdsð“w·¥ Vª2PܹrEu³%…]%è!È€8År¿-VõÎpFÕ¥ÕŽŠÉabŠtŸ’ñÈ¡^ÝnûV‰fºç£¾g‡‚ó·ÉªÖcÆ1Uˆ~áÏ#´üÙ*£¥Ii/â"}º²§!?-"+rõc˜[ÿ~1<Ë©šYcµé‹ 'J­æÉeZ{†ÉºI'ë؉ęù'h?âìß(Œú£eDAhœ£çá%á¾8|ª»D Bvõ:DÆÚ©Q'ò©‰ÓÃüãÁ¨J(ÂŒS UIKm»ä{µëõàdÐ1u²ÇúðØ H>Sî»ct=°ž,°åNîÝ üÛáÅðaÃû9q?[À¿zÁ™1ÿgëò•þÆGTX [)gÐX(Êrm_Ú%¯mXýâÐþµUèé@•RHàÀ-à…Jj ¯;é1ɧQ·6£A7V0Ë&šNî> stream xœ­ZIoäÆÎ)t²Ï¹4Æ—j[M³öªl€m ² c$9Hö€#µ$zØ‹Ijfúÿæ‡ä½ZÈ*6[Ò ÄfíoùÞ÷^ñ×EYÐE‰áÿõæ¬\ÜýzFÝÛEøw½Y|qöík®àMaKK·g~]0%ŠRÈ…–º°\..6g—äUÕöõv¹âœÁKE^ý÷zÉTa…ä~Y¥äš––4køa™’”“vùÓÅ?`ÊÓeN+%,uqsF¨\^ür¶‚.V\F)|}I>øI…aÖ’Ö‚ALãZ+Æ(<[Ò-W0«áÒÐl »%3EI© ºÐÛpÒ§®ñ=ƒŸš\ã,¥´¼”†<$}Úv6mݬxÜsXl@"ãºõ¦jâzšTiÓMx/ÙT“Ž–‘·I¿ª kJ+Œ!+æ÷iý–±ÁP£ ù¸‡>ç†ìÒ…²^[”ZÉ•&ý KnSQµñ½$›ýršvjW~"©l¿ñrŽ°Bý(š¯ßvçÐ Àš ÷[/?ªÈ!ȯ4ä‹tê:ÜÃÞP½0ýaå ‰òB Ëÿ<»øú2l1è*®«…â¤KUýår%J ûd …‚Êv‘Ú@Óà lÜvdAnZÁ¢eÀÉ&ÒÑ(’FLÄÜCšÌ 9/8×Á=~ƒÞ1õ SKìÂ|© ]º²RðÇU­qÝx97ÈTp®7ö¼<2]<(€¬6œ.§§°ÏX ¤¨T9]Ì ¦³šÔE&Ÿâ|V@Ì\À‚þô¿}R@—„–škA ãñ,&âKðÜ€/°‡{ßÅJNêÎ={MZ«L¦_?D²tDSµwãð'Ù@ Bå ~´bJ1‡_1.Ðý+gý&í:5÷Ý€T~ÑnïÝ‘óˆ ÞdSóÏ€ë.Àº•¤©75‚çܹ̭ÃX)U©Xø÷’ä+Þ¥‚!„~¥ÌÖÜ¥½RÔƒ˜á€4÷nAÅ8áQ˜CLd‹e(QwõnëGcT:éŠTÊ>TÞÔ˜]X\^9祌FÀyý—åJ2á@ûaÛÔ]Eð„] R¼ª®ïëíúòúŠ¼¸Ù=¼mÖćbýqÿâ< Hšª®éjù“›ƒ\-ãdº]xvOëÇåó¹9æ`2q$õ&³¢%ƒp"µ–ºà—˜ Ï«a´-µôÉp ŽvL*4 €sÓêLeUÓfÛªÂpý¤cKªž@>S8¢ŸG„C(†ÀMRÙõñtbêÊ}h˜˜G­]0ôrÆ8°\°ü:›v“h"t«hXÞ/ ÃûĦRöºAå4ÍΣãŽņîÔ.³Ã·Ž°ø1‘U|2p:›´…|‚g˜—wí`_%HFÌÞûƒø'|̓諃í7S\æyÉ„Va”ž4D;‘˜Ð(Œ3/mh£33T…4Àá"ÉEg›‹¾;¹ &¦sÎ :ëva›4Ãëàµ:IЂËÒ„õ^Ï-Jª´1(†UôÕ”FäNµ›YIÕÉgÜg¸ßçÔr3ª+¸ LÀá«õûIÑ•ý|5àÂ+œU„PJ${+ÅÀ/éO‘¢TR­Wüî9¸C{ô£ë!j’‘Ë_S~èe iä"çMG0x•#ÓsLGÏšöRS:ÏÜb¼û1GÔÕíY±I÷˜Cÿ±×t}$ d?xù®«ûÚû áb˜\ˆÏ‰ýIÒñŒ˜Þ-? GF¬ä Gª ]*îåø£Ï!qS#¦jiô·úö·6˜×‡ƒN+PÚÇQ&aPŠüõÕ¿Ba€Š¥rj«ö:C[Ã~h€Ž2A>AÄq& ìɧçÌr£qNfÒTd—†›9H¡@4ÓA eG‚N˜ê¯ò Žüù]H±‚lI˜°V&M‡ªÜĉî6û£½Mjx#‹ý' Ëth®¸|©×éRyÚ; ÍdÈ,jO8%àeŸRwÒÞ&ÉtHlCSÔ7xˆË0ð™òÌ)RK®›Þ[*WðRûÀ)ýò_ìÓxœR“‡Â¶9|‰i–Â|Zi–o-\%€¬æÜfÙuÆî‘p‰üƒ(៧ۯûØ2|/!8ùIJ>¾ý²ó{q±åƒwAî½[<$ç8GAqâ£-0ÊõÇ~½½™3cÐ)8Ò`MÓ„L`;‘1AšP¢˜¬ ä.nO3²» '‡dðñz Z•ŸÌ¡üf×Á ”XÐyïù ÑÓêO&œC³.ì¦ÌëXÏC:ÓN1*1§¶áª:†|ˆ…ªÁEJ!ð€ÊgOÇy4ÏÇŸÇ8$¢@¦œÄ–©„H§¦mˆ ›ßbŽWlö·í›u[mïÖWÙ¯7ïêíM,$ô¥ä«¯Æç ¬,¤—ëmd1ÀD×ýsR®í¡b^bqç´o_B~G¡þ—K]ûðÓ¿ü룜òO¤„…«Œ°õ7¥]á’%É_ù}²…¢Tµþ†šÐ35ß×Sä¸ni¡/úíÂæ°öË°`Lm¶¹|vç³9‰ ÉÁs™¥Ú‹  ø€UÕÈ߯1 iê»û¾9ŒDÓÓž6ÀúL•hP¤]oÖcóûªyXwðÊx€ccº"›ÃË×Û»±`ð§UÚJWìç•c¶aÛŠ|=RÞܱÂMàÅù‹(ÌWKü›3°A‰°NQ4™LoƒÉaüU¼²@! pºkßùÔ™‹àãmÅ{ÇM ûG+u¼hz•á³òà Àô,À¥–1¯¾ýf,š=)K ÅešÛ2Áñò ÜpøçnÈSÐÇ †"ÿ „”ú¡>y”®3è‹ÈxhžÕzž†Víùg@ðCå¡#/!úŠK~‘ןâlÙBAZènù”U–Kbe†“Êï"žÃO?dþ§šž‰Ço°X.ÊO.•{“„”îÍöaóömÝw§@4YýF=R´0Ã<Ï@1â{Ëd9ÊÍ& 2qö-(l.çµ…¦CúxÄÔ½©ÎV"AÐJœ%”GvžŸ…“Cr. .ó™·. S¤À‹‚ˆf.Ë †?ì¶×ÍCç–€`E“Ù‚?¤>‹À$—”ù¹.f¶ç*`sµ@|®Ôc¥[( lò¹¥o°³¥‚tÄí4÷û|FþN XœD ©ñ«| ó)|Bªº©¦Å*ò‘­´Ûà{éÌý‡×ßý8þê úûü,þĹ#ß å³Ôÿ²[5¬½ùIaeiÝÆñ'ÏËf»!‰|_ŸÄ¹.,]š£d—a~)ó_—U¢êò{çQ@¢aD¨Iá3wºói .Y`pËóÐM’bã&uÅ€á,6ì2]§kôU_gßAta HKÕxAkÁ4ý#°_îˆ >Û¼„ÑVmÝoú‰t–ŸBÖOhEö#Ýc›÷;,]-OjîJ»ì)ÓFV3MÖCé?}õã:JÏ©Oß÷t}P€f κjæ>¹ˆ7Ë‚Š¼(žY×͈wûyxLIFÕôC¡'È:a:®~1%š\{ŠϥΥíër1\S;1)oõ&VϬ¶QDq[Sü§_F¸Ñàk™§žü´$[~Üþôƒÿž…ʧ–Ü—â Ï+¼ï2”¹§>µßéÇDɾvíÑ·º<¦DëðþTý=¯†Ö¸kS26­Ü4A¶°×.'3Ì`?ŒÖ8^ÑÄËW¯ÂÏT0¡0iŠ98fõÒºêOZeÖÐuar*|ø †±©f¾Ý'ƒ¶©Wâ@æ$9¹' ;·Ïu ÙÜ3õ»þÖº%`V(Lj]bm?… ß(!¼Ú…©ñUñ‘åªÙe…ñ lsÝŽ›i2sËÂ×p0|Ù‚lêwCøIŠQ>u¹‰@5¹ÜL«›S¦n–¹GÈ#Ø ƒbF NÐHÒÐiuºõÂ7ÆæßÑLa Ô9ségÁl.’{_o}à —aÖ™§O†è±¿ºk6}ôO:æsMÀ ÒŽöÉÏÆqä_^œýþþlÀšÌendstream endobj 160 0 obj << /Filter /FlateDecode /Length 1960 >> stream xœµXKs·¾ïÉùNÍ“Ò€x?x í²)Ò%SëTÊRÃåœxg—žZ±oÉÈ!Ýf VIT”‹bèFw£¿¯ø©b”W ÿÒÿÕ°`Õíâ§_«ôo5T_-'—\Âê™çÕòfExåxeµ¥^êj9,7õòo°Xš|±vT ë—׋·äl¼ªeZZÎ<駱ûõ/u#¥ Þ)rV Pè„$«ºÁ…Ž;ãÊ™†±:”VðE“¯·Ã}6j¯œ#S;õÛMÚÈHò¾ŸîKÿºüî /½ N¹h9¹<曥L)/fçNëFIiÉ2ÓLºÌô¸b…A­q³ŠË›ÜÓ:YX 5eVÏÒ¯ká(ƒõ¤]…@jA~lo£ F#lTb+®¨TF Ž†; g$ª´9c’%AÈ*g$]´„ƒ1Štc·Yu»Ã—¨³ÌP ŽI”êYéWm<å„߇ÆKø×@,©÷œÈËáa.(£@ÈAšÃŽ^O¾¾¨…Ì·Æó”|Ïbòq]&ϧ=ˆJK -† ËÍxX°Úi"´Æˆzô›“Wo²Pæãoƒq4ž¥ª†Kª1áqGÆo˜…cÆ­¿Y.¾[0ª5Œg¡1 Wwç*hðZ:¹Þö§wÓtzrCÚ®ºoO@šs¥O¤1ÚJŠÿ¼:XðÉ$¦¸ 1ʶ~ ÇÛhœÂ%ùþò<ái*i(~Ê|äúÐHØUì# ÁHÿn dá+PC‹MàZ…™FÈáÜç5œ³‡|ß& ËÙí:¤<$OΟÅ1¦×Ëv“á|ÜN0%½Š¼È– p“‰ü3‡ßÏã¼²äÏ{y;ó—ä_ùúu¿Ûõ%È“<ÊëØ.ÈE<|ü¡†¶÷LädÀ~÷JpëÉ&Y/%HÇÍ¥fŒÙÈL ýùââuSŠ[òüòtvÛâÓPW $'%ŠJ¶žúHýɇœ´IRŽÑ)ã ¾%÷y¤»#U3F·ßÅúg4$ %EÞd?Úñ—¸ ‰áËlb ˜/¼mî#£*-É6q'rã”vqxWE±žuãÜû¾æˆ00Pyü¬•úíxÔ£øcÞ*ƈª˜eó³ÙŸcnîõǾE.ÿ‘KÆ©Ù7/9k7pYQ3†‘sÎkÒnv4Î^´Ó]†Ì³½™ÞçУÔÏ̹c:NýJ–rXSЄ”Çj+Ãg kßÕÏæ†KP€ÅV†Ìü/u €£à­ƒš¬‰r"àðóp¤Ð’* ”Ä<µ8õ!GæLþe$ÿÝSJ€ÆcªØ8r¡‚ðàÌÿÍ…Æ„F4p!ŽÙq.Ä)n"¦eŸÄ…Æ"Ô"ùOä›’ .}âÂ\`hs¼lÒRÙ0 #òЧ…‘¾gßEšdÆBe€'ãnQ=r¦‹ÜYjèïÖ™ @•ëŒ+»&µ)p €ö¬@ð#@‰† hüpļ%«™µ ÙU¿‰ä×ÜïË-,%ÈxHsAøXIï< #·¨¿Š€U )2÷ À÷肸.›–‹c«r§dC~ÓXaBÎm®Á¨£Ì!Çc£ý¹æ(¸Zaóa…ÉÁ9Üߌ™O€ ò ø_¨Ÿ!èÃLÁc‘’ë‡"?йÆ! Y"é!n ±ÒÕa ß-à3Ô‰¢`¦Ó+ŠPˆŽµ8¯€Èz›_ÛJøÄÂhd*Œ& ¯¼_´Ã\Õÿ’Àþí¯‹/¾Íô=Öˆh Ž8Ü×@󆘲˻.}糬åØô +ÈÅC®=Öö×Ù ÌôöNõOó9ƒ!—du¨Š‚ p (ÛWþ¨‹9ÔV¼Ù ÝÔ¯H;ð =– ð:–ý`½Pî7I~Á55ÐC ¨1Eeºî¡ÉyjúKî¨åå1ý|Á™†êྗJЫ¿\|“åðé‘Â|¨ê@‰sD^m®»¿ðPÚš=FloRÙ—–´ëuzgaeuúôÊVm¾=Çu»¹ÿÐG±¢¡‹z$Q¬BTCy€&3ÅÌÄadó;¶â4ZÇg¸úB¨H4ËB ÉÙï×}¸ÚŸmà0¸‚áùbù¨Zíˆð>$ÿØ?²ÜÈbÙÂ9!қ;E5o>|q2<êÃMZïoB1@(y·†o]»©ÿ1´y’¼|—1 7KàkÝlœžMËSjùr–Rä‡üÕfd" Jhi=¡íÕ9æÅì„=¢ïEì’Á¹/ïûé×üìË7£u[²}aÍcš¡íקŸ¸Q¥+é¡&¦»óÐv«»u7þqѧvþÝt÷+]Ý=0ƒHêXÌN?Ã[ |3Þš™Û“Ù'÷Ýö~ÝÌŽí7þnña¶ì£endstream endobj 161 0 obj << /Type /XRef /Length 194 /Filter /FlateDecode /DecodeParms << /Columns 5 /Predictor 12 >> /W [ 1 3 1 ] /Info 3 0 R /Root 2 0 R /Size 162 /ID [<07caf0c364930296c61c73cb43580f30><183909074876c1f1d0c020c336a1b6b5>] >> stream xœcb&F~0ù‰ $À8JR™üÏ ÀqÈfs…ó«÷£áLýVXuÈL…­È3É "ÙÖ‚Hùƒ ’Ç,®"™Á*yA$ß)•"Y@¤ì6°z.ÉýD2Ù€uÍ«a’Œ|! 6/ØL¦É`»Ž‚É@°-¥`õ{Áì… R¢~"ØÌÏ ’£,N¼% ’ýˆt»œUlrÈ.7°{øŒÁæï»Í¬KlÎ'ã\ endstream endobj startxref 146443 %%EOF Rmpfr/inst/doc/Maechler_useR_2011-abstr.pdf0000644000176200001440000007163514552770166020100 0ustar liggesusers%PDF-1.5 %¿÷¢þ 1 0 obj << /Type /ObjStm /Length 2249 /Filter /FlateDecode /N 34 /First 256 >> stream xœÕYisÛ8ý¾¿ß&S)ALÍdÖGlÇ×zä#Ù™JmQ$qB‰ IÙN~ývƒ¤RG—§j·X$âj<ôën‚0âI„”Ä#"ˆ"ÒgÄ'\p—„+%HH„ðጪsN„Ï<¨BDÈ%Š.ó /‰+TH¸G\ •¹"®‚BîÉ|héP/$Ò \"‘ N<!ˆ§|w‰bÄ‘DI©`P¢” 动@âàÄg „ ˆÏ}x‡Äw rKÞœøž‚ÁñÈëºÄ÷á£+‰€\®ï@ýã—_½ÔE4ŒŠ$4z„^Gc"&sûu® =„ò$“·oM“ýE1I3òêg(ÉtTÄéì(*4yuôF0!Œûœ¹ì5ã?1öS]Û\D·ú#yŒ‹ ™@ßY¦GP|®¿>¦Ù07}^¦Ãïuw¥ÃÅ@C'×äd’æE>ÈâyABÇS‡*7‹þ_zP˜oã"јª&p˜.fá0n cþ “ýTO·D žìl–XI”ˆ²²(Ñ‚•0¯ îá0z ܲðÆÑAú=0¸¼Ðs 6¬¢„Øà:Ê ~wOçé"Àð8ö1t†‹[®K–ntýÐë£cU?ÐÁÛ·¶ØµÔQ®Mkzs|~tvòú*žöy/^¥áÅ^O„¾› Òa<£Þ˜!Žã,/'QFD9ø‘.a…•«¦sÕ5@©äÂŒðZràñ°˜t=e¦þÜË…‘š¹úƼðÊoøxÙên>M]?°z q>PN)ßÜ& ÔFy1w= ~`Áð«f„m0…euýPÊe}{Í k¾±ïZÖR²:åÃmÏo3g@Xe8b–ÕÈ?ra›²Ý £ÿå«–÷Ó’œùÉ£À–‚‘šŸêx<©³ ¤H—WtŸÐCzDßÑczBOé{zA/齦=zCo齧è4¢QAût@i’Îà9FtH5ÕÑ`QÀkœEðš £|BõÓ ‰¦tDG1gé˜N(˜´‰žÑ˜~¦ ÒMi:ÓtNçÈòDŠ2•¡œÌ_œéúe‘zØOL…:SÖ1¹2™Ñœæñ-hñ˜Ò} ô‰~¥ßè7¥`æ­ÇžGC“hŒvÜÐñ ¶@¦,Ç€ }* ãD£r‘ÒÀ—«hªwšŽ÷àâÁþl v•‘‹ó ‰¡¼a"½)ôôchËœ¬Ù©ÞÅÉýíYk04ž¶â¤e§°ÿVÏ•¹\*0·Ý UÓÐl¿ÚõJ£P>ß ©›&a½Vó2t£b Eõ^ ÈW†¢JX麴2,`&ܪ¤ñÿƒà?~á¼ÖÌAÈæÀd-spHÏÁ ýòÃXg:s‹ùÈù‘á³Mäy›‹pð‘~m©íă2t9(N“x•Æ®ˆ·ƒ ‰t%ÞÅý¿Ïnþx}xÙ ,ª+fû³<^}X‘N®“ŽWÌ\²ÎˆÒ):R㽶ˆÏÚ‹h²ËED« VОÕÀ+Pû >ðÂ÷M ä%k#ßcÖ¨wÖ>ï õÇ÷wΡ÷Ë÷6Ö® -³æm@Øm#vDX„Þºœ7(Rf—è×gë5] ^ÉÚºåv=ØOaÞF¸‰AGˆ¡Ž_Ÿ\œ^_™î• ±Û†X¹ë{-ˆU×WÝÚËPØ—Ù%Äye›´·m6ÀÂ~aã&®¢ksâq…½hG\ÏnïîNÏ7Ä8’ ´l½çö^¶Ú]­ÅßâÆv9þv™ÙבÿÒÃE—Œ;ƒºfù¬÷ÛX{w`Çùõ¾Åì ¬˜¿Dø{kgÀªñ»DÊh)m׈ò*:ÆØ8ZsŒ£¤ë®äV¯èoVï=.ý²8ðÝõˆTÖ¤]*ùw´°³sd[Ôž~¬Ù [ãÀùíùYïÝ·ÜâÀ.ßé³u:´#Ö@t5;fWîPW:Š¥ë^5l®h¯ÿq5,¿ØîW÷Dh*„Ü7=5O¶ï;ðu^<¿«Í:½;¿:=­¼Lg¥ªü«ŸÄË•kƒˆv ÃE×HG7•e¿ì|.óÍܪF»åê›Új»Ô±Ëí¾›í.mˤ6æ@wºÿP-*Ö°tÑS]ûØ ÐöFüË"JLh>Æÿ‰:³P¢óÜX¢ÙbÚ×Y;n¿«ýv¹¿ÖÐ]½Ã~ZÛYó`à»nË–¹e±3Œm²Ák³a—r¶©=Yˆ5ˆ¡V¾œ³mqèʪ¹¬ÚåáÉéï¿·±]z-ûŠ|íð”ó®Ûîïiè&ërw¿š:¾»¤ÛÈÝ¿®[è 3GÐG÷i?‹ŸuaÔ»J— n»mÓÞü­zÐþWýUyñY |ÙD ‹+¨}‰¶è‚?¥òŠq&™ÖËT;èã­í! Ì ]@“;ªÍm*û,ÞÛvÊmør‘ÌùBïzïëfû<)?½šFqR¤o¦‘Lýâü™FÅÄÑÅä›3˜ülþؤÙPgU„ÏÌÁÉpb6P§0< àï~.|'P”v}ÂåŽÊ Ï5ƒ%Ï.âÙç¥\xrÑYðIQÌó7”öãÜéíͳOœ4ã§oq’D.Í'éã ë ÆñoñðW.eÈ|F’3ãd¡Ç XaÏáÁÌá2|ÁÁ„¦óQf¦ñãrŠÐw\æâ £„"’I‡ <Ï !½—•s<'qÿ™’rÉa„¶Ž§ð¤9Rð]²üe%Í ¤ÙÞdÕð¶uå9ê€zû$ônÓUÞ Ü™r8WÝ$ïAÀËYi&zxà*ê´9”­Ò>ÈVécË4¼Ömñðµn Am• IY×ò;âÇ£x4Òeà)ÞŸx’6ŠÍêÕïÃÕQã²Õsºþ[:ÅßJ&âz¡þÐcáÏŽ—š3À™¼T_œØms¯ÿ®ëŒ£endstream endobj 36 0 obj << /Subtype /XML /Type /Metadata /Length 1387 >> stream GPL Ghostscript 9.56.1 2024-01-20T17:10:30+01:00 2024-01-20T17:10:30+01:00 LaTeX with hyperref endstream endobj 37 0 obj << /Filter /FlateDecode /Length 3388 >> stream xœµYےܶ­rÞö'<±¦4q#å*;–œd×µÞ%Uöú3ÃÝ¡Å!Ç$Ç«õoH•/ÌCòén$G;Ö¥œ”JÒ€@÷éÓþ0Kb>Kðÿµ=If7'?œpz:óÿ­¶³Ï'.Ì,‹mšªÙâúÄ-à³4¥Lì,KlœY>[lO¾eŸ7m[¬úbÍ…²±µ†åË®oóUïŸdŠ]7- t'‰a¯ª¼/æ˶È_”õM˜dØ®éú¢}í'rSO„¾:-o6}íVÐËú¼zñzœÒ7á•bËb|¾)ª (³,ïÇ߯žwÅůýØdL$œ¿~8nð<¿9ûG”ÑùAB{[®^<_ñ´ßŒ£'û›É2}·øëÉ‹“¯Ol;»Í?;IS;mJót¶=ÑR%±Ê†'ÕÉåÏÚÇθ‰×2&VFÏ ×±MRgŸ'í²k´eu4’±'«Õ¾+Œšø¼Ùîö}Þ—M,eÙm9Ü+Ñìâq ÙyDªEc¯^ä7Å(úÁÅvwÝ> +Ó18 ‚ŽiR$fs Ï„Ìf‹5ð,oû²vö¯Õ¦*Z/€Ã­À4 0:VRÛ™Œ­Î¬_Ï£yŠs)¿DN–¨XH S7ù·8™'<ÉÒ#òE,5·:Lä[$ë˜Á˜4HFÎDœq‘Y·ä¸î¡¥qK¦N7p[£5hËÄ©U~ hj@Õì‹Å—£Ú¿Ù·åj3:Ù»,¶e~—:á%ÚºëËUw=àLþSÑVèzx&Îc­Ílqz²ø (dÜüb” 0±ÿŸ‹Hè8h²#ŽxO5+ªf·-êày–³Edpµ¬È·Ñ™Ø¨,ÑakÒ•{_W*–Üp ªŠ³dÆçMÝOXH³|ßošöñèÎkÚcA°<Ó³Q¬4zÛæöO¨5Þæý&.úÍO1Xdñ}Øëç·9ô’7ØV[ð!œ7ÿ” 3YqwѵŒfM»îGA/Y)•ÈxÀhà‚ Ø9pwÙÓ;6c_É…¥ž&VdF¸2»‹RØ‹” ä'ÙÙ¾êË]UŒË¡aÉžV à­¾™Ÿ7eÝ€![ÐÑçá°sÅãT!êÖ'l±)P…Žƒ‹q›Dú‹iÊÁ «D'Þ=ÙÎÓÍ;P·Ì€3³Aç¾4 Þ®À½"óªj"Zá‚Ýv¨ fáCÂ;ï»"¼š< a-à¡d;TT„³¹‚˜惮Y½ß.‹¶óÒ :–5DÇ|$ZÖ\·98©€õŤqšj!ÃUDï!6SlÝì—ÕpzåÚ ±#À䀜"p8™QJ™Îæ\ÆZYá¶Ù浇 èè¹SðÝwXTZaM8øjŒXîä>_ðÑêz_¯è]ì•Æܦ€.Žî‹QÈbSâbé˜~;ËW›ÒQWÆSœ„Q¢#-[’¹½ÖÅG>1!A–]ªð2c«*ïºÂKö†Ã—¬Ûaû%£>éÊß×ð4P)œ r­¦íȃDÀ²À6@ý…{ÄCҔв¼mó;'“õ›¢-šk7ø🸗hÇ÷h³, ¬ xí7ÛÂLË 1·Û€7ßðO¹Ê+ÿî2è>’öQá)&¬âÐiïËÖ&l_Te¾ ¼ïÝ¥†PõR …Öf³ ‘¦3›‹èOÛ¢ðo8»l®{3 Ó¼-.ÝÈ#A®ÊÁ“ȧ5`¾¬rÇr( ‚á¾^í(ÜÁÑ:b?}v~f*€Üª¨;Ø€¨òCHã”c<í#ÄÈE)+û®¨®ÇD„®@¿3¶t'Sl_Vý¸d žá @p×îº~ øÇ(æ½¢ð;ƒ¼à9^¤@§;;¿ŠeQTÙTWü°‡$®zÃÕ2bâÃÌqÙ¾C6MW¦pX´3ÂܪYá¸C-åGtu2¼ÈØ?÷š„Îâ ª¸)š&ÁßÃ#  öéÊ­3¼v⥅$ËŠÃÀèTã¡ÕÇÇÏÛ’^ù: ²åÆ3»ËY’IQ-ÙÖE/†íXdȦ®¼Œ½æAÍð"©«ci”¸úC4×ä¤p©+¶.oJ<½pÿ>ÌÑŒ›«èÓhž&®BÅ|‹~ș¥†EÓW×{¼™±O I¯×y»O2vñÉTÌ”M%VïŸ6þj\ó»yø­œ\±ÃWxŒ‡GÃÝFŸÑ=aÎôŽ"I`å¸;?²{ñrwÅ"Hf`)—úu r9Q9M¦b¸Ä·ü»°B@Mgxi7üUÚ&JócF# êguÅøUô^»óqíǨ”ƒ5CN9ŽåA“”ƒ‚PIðË$¶D5 KåûÝTH-!œfFåyš~ +¡Lbe !A[m€65öX}%p»¡<~²ÛA`2ÒÌ%ùŽ¥ƒ«Ëp0qCM\íêS?&”õªÚ¯‡ ŠõE×»<“fdŽhÁ>+ ͬ‚xÎI È]SÝUÍ—þz¡ Ç .¯Dg벃¬rqêߣæ.ïžË}2—Â¥‡EŒ­0ô55 $„~pB ¾8Æãìh„Û±Vkö—ÚO=æëuÙ»ªU KÍBT푈6º1ï.ï,OÓoò.œ Unc¬çÖøK’º›p7ãÞüiI!Ä„Ôïb¾)ªÝ‘Í!O3’¨ÆŸïPl8´ƒ¨uñ#Øú¾¬9„4l)D-d:6‰¦T£]ãH ®Àu7åÍfžOêþÌ`Åæ—Úƒª # lƒÈDC‡!ˆ¤~®Ãà H<º&<ƒšÈC?ƒÒœfÖãrˆ¬«’"+-HY7fzPPäzèü™+ªÐT¾tc„:Ë!H†¶E¢cbY!Œ¸& ðºO¡|ï'-.<Ò¾žxº‰“v)øæyч~Àû2'd[¬åÊÕ WN*ÉB+t˜/›ý¤CöÑË1‰âo$H»šï(•ùК\™Æþæš_o з¥Pll. ¦&3;¿ø”+eù{5»ÌQ©Qr+¤Æ(n.¡”ËRáëöÌ÷ö|3>• )D§‹ÂiU örW`ã^p_XJí2Ю[&)Qp3SÊp¤Ö0qðwše"a–ËvÜò¯±ƒSöûŠðÖ‘‰>Ì»» RxFئë÷ë²èüˆ‘8Dqþ*ÚU5ÁO®píAöÐz0¾ž¯nªº€}¸fØœ?á¨Ð̹—4c,O> »4é.›©w8Ò ßv†ŒìئPˆkL‚Þ¾é¤.~=n3ñrð!8{ Õ¤4‚”Õ£¢‹‘¹V¥þ²Ân—‹ârNMÍŠzUtGSøÉÇìç©#Uìƒì;løI™> ¿ û2¯ÛNõ½fφw–×ÿþ‘à‡…=œüïu¤-5eé! ãü?Àñ]‰É”{|qîZ‰4/%ºÿ¦DvÝæuíwtŸÓO¨ñÓU(ïqPbc‘ ŸJ°DÎdØ“qÛ­+L#,£øè|×F´¹RCÛ¯ÓÇÕXº:â¾°¡ÿW¾7±£–ÄP¸b%ëÜãÁPÑr2z\ë›&ÔHØF ¡Ghöõz$ÞCôCñ–…)~ I¶Ÿ_œþbbu÷Ü¥¸‹$ Üôýîñ£G˜µÄM{óèli äãSéž`Á©…zSˆXCDw{ÖæuµGç‘ÖõF‘‘ôÉá£\%åȈŠsƒ0;¢.†¦vÚ:¾I—¶÷ø퇘î¾p›AfP>5?ÜÊŒ¹-›'[¸“YÂÀáÜ¡Qâ¦b£„‰W ÒžŒÝHŒ¢æ¾ö)ÂŽa»of—2æXñþpÃñs W3Ž}wt“77@íåò"Gh+HO§òr `ãO5|ÏußÂà–ʵmÎð§+Þncõi– =@ÊÖUt’RPº"C3GÈsÿ[¼ƒyÝTNæ5Ëâ¤ã©È¸OàŽQœ ôN­Êâ(§ƒåðÄ )~Úæî„®o<¦^अßí@$>ò°Û“Äj.Žyåÿ% r(ËMl„t=JZ¢—‡²*ÔnŠð‚Ž¤¸ùÓAir–Äá^OáD¾>ù/˜c0endstream endobj 38 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 6307 >> stream xœ½xiXS×ÚöŽ½w­b%n!b“Z¬­V­U¬uÆ鈃ȤàÀ<ËBF’0-d$ 0aP«¶Ö¶V­vBßÓöÔÚÓ–ö´ksßw½+Ø÷{Ïõþy|¿ÈÎ^ϺŸûyîû†C¸O#8oObê‘œ¬ ôÔ=ék–ÅÆç¸þ< ´úMlà‚n`†{ÛüùƒžÐ:ÎõÞs„ëgÓ¦´Íé[2"ü3·ß–µ={GÎÎܼâ#ùGw‹í‰ÛŸ”’¼?%4õÀò+«^|Û×°èÕÓ^_òyéãeñ±—x™ØG, ‰µÄB"ˆx…&|‰b±Ÿx•%ˆ0b3Nl!–„?±”ˆ$¶oÛˆíÄrb±“x“ø ±’x‹ V»‰ÕÄÂð$xCä^Ä4‡ ‰Dâb:ñ"‘JÌ$<ˆÛD:1‹ø˜MlÆîD,ñ)§€smÚºi£nϸ©Ü{‘û7Ü`î÷d>ùD]¦þ7MÿöLõô§K§ß~6èÙö^3"f<˜¹c¦ÓÃÝC2+xÖç‚Ÿë›4Ûá¹Ê³Å󯼵¼'srç\d¼˜`æÜÜ×çfÌmžû•×.¯*¯»ÞNþf~!ßõ8úò¦ƒ)â]ÛŸQꊈüDEHßcâ `õ²{EvOȇEãoCÊ‹·¸vb1󉨱¢jØDOî£À&™Ì¯„æ%‰àPÀíúÞ®žÇ)p 礴¦¶dTÿ¥fÔRojª§y)'l½'çA÷WÑ&Áô5ó8]Ô#Á_¿’Õr4`ØŸ{ìhvrþÕN@GHBxÒWY¯7ÚÃ$/R×#W¬ ^"Ĩ(ì '§õhýÆ jÙÍ]ö Ÿï^žÐóÉoP½ÞøÍÊÒ™±w_CÏ#î¡íÅ5 ä ÓG >·éïÏܸ-À÷•³¿ p0ànÊÂ\n.©É-çB ÑJt5á†(°ø¥ìÙº;v)@ÓÀÒ¶·Î]ûËßb ~<}ý :¿n“ÿÎT?ÀÁŽ˜¾‘”ot£áÎïà3pá•ÑÜ£‚Žd[ºý/4¾J­×åÃTeëqÍóÞÌyäÅ+2²Ï3Ær=0ºK¯ŒN&Pà€B±OCó^Ã"Šw¨ŽÚX.3ƒ÷h¸œêNjRNÿt‡ ás[¿^}|´ð>¥©ØŸ› óáâLÛåžÓwG6 ¹ElÜÔÓ&ð`!èc¿êã°·¡?#Vææåd–™HÖŸýk›l¤òÐn3i18jëY?À§e’“;'ãJØëTô纆àÿ0æ×q–„/^ù¯Ã€-rÙ†"Ü{ì¥ þÑyãòÍw{¿?€oR„\Úþâô çñ‰$o¾ˆúLm,ÄÔ⥌w2ífÃÉG7 Ï ì?ù@@Ó¬~;*,-P¾ÐGå˜ S(Z¥µ0è:ëéôlz Ƽx8É®c¶¤á7Ï~ ¹£Èóƒ¯^j>;,D˜¸Áù\׈*¬THµÊiö{µ}Å€¬b™R•#J’§€aÊs$·æÞ`”/Ü}x£=iÇvøÆpè$4öáKÿ8îÅËfÃuL:Žˆ˜,ô2 3Èp¸J­/Ò–šA- \J} l2‹Ý%Ù¤úH±D!•‰ÓUQ¸Ì¥ð8éÔéZЇÄ|jÔ.§O%ðe䕋¨»‹l»­RÉf\½¿ˆí¥<à#¼ Ö98ŸŽ¹éÙyŒUk,¯ô cA´i)®Vï’ãÁWÛ¨íZ± \¡aÕ1t®Eg,Rš5R³Æè&[­³3בx8-Û?Bø7ª¨"4'^¶OÄ÷`/;¼þ/÷L`³`ƒ/@É×æKÖâÒºJ¯r•>ÿOJ¿ÿߥo¥€ŸÂEì´Së+¥Vð ÓàBê P+©~O_Ù w°K²Ïó7àš½x¯Ãá-¦Îç*ÈÒÒBuYY1àk€²BQEój 99•™>ï…m î8ú0Rx5©;¯6 ¤ð£“ÓÃS, "Aî‰ÂFÙº-³zSeF‡`ÖÒF9TR]R­²ê²A VQÉ{2¶ Õ¾„{;¿ Ühù\#¢þø¶ôšŒ{èFRã¹9¤F”/ÍJP Íײ4ÂHF¡—‘/Šyµeãå}Â[ÛžÄÂià€³»ºiMw«-W«hØ®egtxZ`Ú ÿðÚâ}ô ¤IS™V#Pj ÕÊؘȂbš÷P¡Ö¨‹æ’òRm)ÍûèºH®n‹yw¤¯i´S 3ç+s?NÒòžöS¼‡?“S# G†a¯óû8¼<îc!b`(>1›ïëi;jQ÷ÕfØ2Õ×ÕJù:W_ÛíÔFÌ‚—+</£ö »ïÏÞ‚B)×Z¿ä`ß®•Z=oÁmønóÙ¬sLyPa>-„OÐ Š×)¦n”T+A8äH/’J9)òT@Kîòjágè)u¶Ä*iTE½s6ìNoMK‹`hˆëGñ*KÏ9zÌç­|×ðØ'ÜíHáR®µQ&_]‚Ë=g§Öh ¬àÎT¹w¬–±J\î9õð©üáZ¥ö‡ÍÄØ#¡„ì(±)(K•ÅÊE¨Ú{!4j¬%V`äƒ:³¾[KÛP˜„ê+Õ+O/€3Ѐw…F«Öªtù:•è€Þbë…sà]ïÖuú6-í"ÝÓ>ÄH¨.µI Ä@¢ÉRd,GǽWÃlñi€…Ìú3züúh Õ[\­pì׋ô"]þ2é½Z‹M¥&`âƒújCW%~j‡„j,5( úÞ»:Õ Õ*`°T7c Q{‹Ö¸Jðõ ÊX3€uôGïºAm•[´Oy%è*ëÝäyù+¸è /Þ)vÏŒX*/’:[mBÜôÑ¢VISNOŒ} —lŠÈvä56Õ;*˪ÊôÂRc™èé–Ž†‘–´ý‚=Zº[¬Š‰ÍÉ“&‚$š0}}ødýèuÏr ª.÷¤O®¿»„ÞÀ+:¥¨0Wž%M/ÌtBz×°ÇÉ8sØÕà`ß´q`û\xÐF¦€¼š”a4†ygØ[Új:Êù6´BBµ•š4@ äòœã)Ey¾,OêðNÌï`µèÛÊ1XG%Fª ÔÈÚ££ÞˆDkR(ÕI%| \h£ÒåUÞfq?ƒ³¾E/Tj*4@Ãùêâ¤RW%XÛŸ}óÑÌû«\2±Ž)ª8,ÉPEÉøi*n¥+¯z@  'k¨”‡IŸCïq8 ¾ gmxì»'0>"OêÞ¦gôÁ¹uȹEîZsàPã‰?¨ŸýùéRÎ`?†›q¬4["N8’ïèäf™®[ȦRà¶ÕúYfo÷¿ª¯ê¿tdŸˆí¦ÎÂÍ.³‰ÒÆØë˜sé.Rû`R×—iJÔÂŨQP§±[€SÚ¦ªÀ‘RÍŵ ƒ’¨Ì[«²¥:Ãkâ„$ÙâTifŽH 4 °BY%Ò‹+Ř$yyYIÇo½ \Â¥ìë–³©IËw‘ë–ÛÊ9qß} .c"·Æga?²l×çúåÒí/z,Š8“P—cH¯Ë¯üæ{ãå­gVG„åņG§oïÐhîgK¡Û©šöAKî÷»´Ç?gþ1æœa¶nÜmbû13ŽÕH.{ç5Ú\…Õèénºm±ÜÕa¸")”9Y Ø .Š‘_Yä`3=¹˜ ¤"? þžÜ¥bâFð3ÍúR°rò ×JâK€6v^‡]}˜üJe¸¦@&æKʼn…axÅ HØÀ¾Êµ¡Ÿ¨4[GïØl×°©È>ù*6U3§öà(¨a§;9-`Þ˜üAÉ@ßQn •_V J¯Âë}ët¤8A¹KÌ/  å:`t¯QyDˆ–Q±æ£øe®ÞŸðµ3±Ú1 Zœ”–’k‡ƒ¡û¾ObGœˆ5ʪrA½#üàæ— G¸ ›lC Ü’`/¯¶Ú|pâ)¶«ñ›$}ªH}ýÙ/_†ÜDÞ·…/]=< .Ò—ûnœÅw Ú“­™5ûpd˜5öÇvL?A0“%X¥Pø¹–ô)ìÈ*¥—#3\¤ òÑ4º‰ÔÀõÜÉ뤭ç6‘MÓh‡î€~Ê%?çKŒ&ÜŒ[¹ Ð&Y¤p2‡ê’’-®`$³QyåG+ð¼uóa_@{µÅ%%Ú¾A©Õ€"º°P#ˆ$0ÍFFkSì‡Ï£%0Ô»µåö7N·ø¶Jk^Š‘’ýeæbl*T…R©=<¼Y?ª¸"Vž¦ ,৪\aY:ÌNØ9¿ŽÃÿ5ìÆB¶šãÕ5_šð>•ˆ¨ššà‹1fº:¶ 5#rWÊFà"š2Îäw¨{]¹ÿΔþÜåŸ{phÖ`ÿ¼™F7)´é‹5p=äÜëþ°_Ð4h< î?¥çïcnvŒŽ4—W—c•è0I£„“™Ø/•a6* Rn—hö1®÷€8V¹MÌŸR‚‰™ÎÄî‰Å :,"/•Ô)@:(PgÈS‘亂7z ~›tGÕl|`·š:**¹ÜZŽK³‹¨‘R«th,›<ím#áqöjçgfóY,ôvÜ›çG9Æ`€ë×ÍξÄX´×?¶š‘B¤sÕ& .õ·Q¡3è§a7* &½þDãPm7 ‡ðRÀ'X¡rA¶ *—Ô‚4¬¢Ú†:ëNúJ]†ŸÅS H¥ Tã‡ÒmTfEj…¬ôóá N?vm}`Xfà~Aþ•Ä–ý ¤Kýè{”º"L”¨‘ð=þéÿ‡ú¹pÀfà|Æ!äj2•éh6ú›7ò†K« Ê´üÂz˜AS£é¢ ‡ˆºRf*ìZÛ¹ÆûÔ°3Ôuŵ.Õ`ÕŸ×âGJEÔù"[~︲ËÕRv-\9¹–k#B«É 9ðŒ}Ôl¼`úƒÖ¬·˜øÈ ãñE;–q¥Tu•¹²²¢N_[‰i^o”$ ]'I•]P()”–vAÙj£Þ)/0³4ûƒËf€OÙÆ»øí#76>ÏȪâ‚d…‡©Høôÿú»þOÁþOoß9ä@ÎÑ8Ar¢$Yì__ä=ð÷žŽ=v%hõºƒKW¯¢m(+gçM½Õ}ßg×9<á©ëï{ñ¾cS`³ Œ&Ñ­É@î.Ø…ÖR¼Ÿïõã$Úñ>ƒÔ$TÃ'.+À~ô+Îí‡ûûÝ®°[™[§®ƒkô¹„þC YÙ‰É ¢^¾¼\'ÐWPŽ‡N§Q%§ÇíBèð´+¾9Y÷Óœ®ï`å7nlÐÄF‘Ê@Ñæ0D¬ß‡H€æ•-o…÷E_̺ýÙs¾ÇQhÎæ/«Ž ¶À×p`"àòfAýÌ£s[0¦Û³õÍýáç N‡MX_ÓnÄDÅ&¤ðwöîY ôgN±<<†f`劜‰Iy©QÙÆ5æ-ã^Kiá­_Ǥfg¥¤6ä´u46´µeHâIV@7XÝ8p>ͤÏLI;q¼µ½ùDk{fsª!÷û>x Ñíýn¿ý œ¢ž()=~  }ìÖ_á³ÎÐT3à˜h;’í{é°îØSÝM]Ùöxº¬L#P—Ph•Fgètö\ìÂ,ûÿài\åÄç,æóY|̦ÈÔ̸ƒþ+|z ^ï«]x2²9g4¹ºÆ{í{éÝ÷²n)>?X¾l¹á¼ÑÖóÉUú—ÀÈGn}h+s÷l[sïéÛÿÑý€Ï8'î‡7ÇœÍl8Ð!/ðþ< %Á¹±i‡yð/Ëü2ö¤¤Æo ÄQa‰´NïL‚Øî é18ó6;sÀ‹76á‡Y—&Ûu=ò€ÏÁÍßõ<¾ò®pdäVËÌ‘åp.š…^õ X¼3Sfk×—W•ë„7¡ž»TÆ朔˜?$$&††¦lÀK›çÐ12|¦åT—€÷a´®7í¬Ïq—¸½ ç Ý(­Bo (®D‹àÑÏY†ò|Ñ:v ã,µe•+ïËŒŧåd:.»sôbݹ®>¡³£ÛÑäJ¡ðÂx¥Sé€'<ƒ{±©¸ÙξÅ|ˆ>%Á.…,¸o† \)³b€_>¢žT•„ Q­Kƒ wýñq•ÂÞ§¡  ±âÍ{½XËåE©£ÓJŽú åC$Ö¶WÕZ‡úÛN'°Ëší—³®·Õ6 †;×oÌŒˆ¦QÄiÖÒÛH¨Õ8 ~õ„Ëú½x1_¡ÿo~ xõÿMQ^L…“Ôç_†>‚¡ïqúa™[?41°ì=ê_ÒŒpxòþ?ˆ¼ç40‚A¾pQ~]a•ðserQYR'Çiv±+FÃ#¨u`KF(|K¦åìŸþ}bÿÿ‹H\-\úC½Åh5|‡¬:GRX”Ÿ/@¾h‘«Zió„g3§é ´H8“†‡—Á‘— $“;…£f,Š~á­·¢‡Ç`Â)èöHè‘ç`C0ÄA¶Mø,˜1Ìx¶ÍPeÒ[fÌ3< â?AAendstream endobj 39 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 3147 >> stream xœV{TT×½>#0çD)5LO…`fëƒ4F“eRcªZ|> D`dœæÉc`ó˜á1<˜ƒêuú5KÅSoPk©­Ô!jµŽÚNýŠŠ¤^¢vP;© Ô.jµ—Š¢Â(†ºFIÈÉ(*‹º'´/Z±H¿èü"ü\þ+ýÏìð_…¢ô{ÌO™Î'Ÿ˜^œ¸xhÉÚ%IK· µA³ ä…-'Aë‚.Áìv/[!LCE]oÂb¬åÜ!j!ÖÌMÈ׊̡HòÒ1u¹ÔƒZ¼]ï´ <á@Ds:ÊCùzSFe9ÒW•T2¸KÏYÁÈ>„ŠoqE@wy¸àétOð€$ËDÁ¥°ø€V8^ÚhB) ž¤QŠÅ|ØÌh¡ÌC+l†64Ì€‹FuõMMŒè®»ÛÓìlÏ9 Áå4Rè‹2+È°ÁC§ÕššÑiêè{±—6EKÕ1 qg-éã"ú^X/Á?¨ãT,…¯ÀËñO¾\ Ë€ýê9Î3Ï?¬¤:‹½Úy¿Š×éâöÅèÞ†Õ°­ã”„`Tpvö‰~Á9Øî7» Ö²1{hd”ej´í̾}±äú†Ôë°'Ç åcâ±4·rp3ã}Ž°$Ãh,@fT\—×ãIp$ 'àçð:œŒe°¯†Ô™wÛ‡/INtw»&Î3/œÒ•ïÑBŠþ·ø ÁíCrПAø2QäßáÖÄã6WI#™Åœ`aD?ÑB-rvÑQµÇ\hšg鳉=úqÄ€ÿïA8H¶|‰ýbÒs÷eIDa5RÕ7:›[\ÝîænÄ\ðDãex©:f¿2Û=R, âbk/y,®àOxÆnB6¿ó>­p¬Ì¡G©óŒÉLÆ$ !¡ÓCGÕZÐûè ¾±þ†ÆÒ"‡¸3§Í܃˜áßI‰èʼnÌþÄ7å9; 9¡%Ü«ý‚Þo@ü•<€XX•G——•P2ÕÙ”ŽÜº<ļ¸sïƧ¤ß&K~«òiÐ&MuôðvéÄý|±oò ]öúFdC •M½†‹Fb>¿6õÙLÚXøiIäqµ 0ý>ïHO¯1¿[Ü¥s¶%1ApÏ0ß nÄ®’{½aÔ+©‡wdr.à»ô®±Ô›Ó£oýþ”XãÐÉ‹JòQ¨ÚØ>*wÒ„ ’YnNì ¾ñXÐð•žkóÔݨŸªqÓI5Ž1æ°TKŸ¯h6 dÑ¢ ¥2ߨ“»Þ–À8FKŸ²4˜yØè çã>¹0è<ULdWââ"‰)ãxÐôÂá ‡å"ƒ^‘õzqš%ßi:emο£»YêCÈÙd©eç XôàjON”ä /I?¤Sh’Uù™•¨ÉÃׯœq¿$vÄwœCc¨Ï9rŠ}‹ã®°9Y:ƒ1ªüÞÑ«§Oÿ®‹²yg…^<?ó›mò²šj£M߆¯rA!±CÞ¯/>­¡Û«Z«lUC•-¤CEå–¬,¬ÂÙ! ¤ÑL›óŽL}®¡oVt£8f®€Fñņ­_Ÿyé­E-èñt¯va]§ÖfFÆP¤/)Wò9‡JªÈà§óR8Á­z"=¼˜`#Ÿ4鳯²8V+R{ìÍ£GrQ¨ÙÒÐXjªk%Õ¶jªcŽk]™Šœ£ré¨òÊÀñæ®.q—Û5:øžãž i?ÝÔÔWKB)¦dš åóôY?îE°Š”£%2ļ|ð>,ÿ¯×.8Û,F»„À„PJõ¡ŽÜaÄœîñœœÚqv^¾æY¼‹? ‡¥w/÷ݹ* ú~Ûßæ|°Þoö5î¿Ù9;”¶”hÿÓKG4™h†á¢ht«­í6ϗƉsY8‘Ë Àvðv™SÏs§¦Q´ÞÁs§÷Ò›ìèÃ)i°Í}Ð+äIºœçæ_&45‡šˆe‹á ={¦Åk›ªŸj –•Öê[È3ÂÝÂG´ôtyc)’2x7|Få”’È^´é¼J"êÇËÿ#ü»‹ýÎó“bë{,*33èu¹ùFV±š÷@lï»Wûû´òV>CKnAô0¼Ü'àVÓlꡬÂd”†²;ò OXú+n2`–ý¡xòȈò¤ÔuìóäÆp¼¯þýó°ôãs'Üà6ØÌÖB`Çè9äCE Y¶‚uM½½ÆÐŒn00}üe¢/µuv8J ÖÒ2“Ø\\aD&&«G;0ìõ¿sjãŽ8mRŽ8/£T†^aö'ðy¹¹A7øò½[–‰â¡ .³V=P;ÞñqßøoÐ]˜µï㟋ñ‡BÑ„†þ ¬µmgæw{õºÄ2+2UùjpßK¿ÞdnD·Q·‚½ˆL‹¾¤œIj{j^²qçÚÌ¥[-éÖvê'u¯ç¤ÊQ’u^ÏeD_÷˜•ÙSû>Ì„`xíþ|wï™Uâ]Ÿëê}oùºG%U“Èkp…Š> &zܧ.>…F o©}Ì/æbYÑmã;=ǔ҃GÃ7HÝã]õŸ["zžú”3³“òuë Ò ‡<ìž”<î;|&Ü\xü Ï„ƒ|&Ô[Œ™«ÿ§u§ÛMºbþQÙI¯Õ·ñe§z¾ìÄ*tûâÄóMŽûÛá„„¤Ý°y™èîl’—-Dz»©Ka$äÝNo‹Ï{¼×9Š& Ã¯áÝÙºSÞZŒ¶Î³õ†Éa&<}þÿþƒø^Rñû"ÅÏíæ¾f‘½®­ÖnorÚ¼ˆùb8yÅîâ´#ù’£Ç2K7W‘×µo¾9|ëƒßƒõ¤ß³=€4>Àã|*ÊêC©Ej$ײxè ›¡ÔßÎý•MÎÈH9ܯèËL^€t–ñ> XrMü—”¹BGeSUm•Çê(%l6øGøG!ÜV­¥¬­Ç|è´âB¥ua›Äúr;šd@H»=_â§Ú5õd E†’2u™Ð{h#*¯57ãXè ù滞Žk ÷á7Ÿæ‰”ñDî× ­ÎB¤˜ÿ¾â˜.óÿ¾¯¬.êD£LÐìÇ•wfA -á¤>®oeÃcŒ %ª”GÁÈ£ÀëÀîìlibD;»ÚëÛÃN¶åFÏ+AfÔ+¬ 'ͨ#¢Y¶ñÃÝíd1#mÚ˜ùÑ£AΚIC®16ómd¡!ï—ç®exö =Hš#æ‘"HUŽ‹¿ÈJåi‡†“gG†ÏLÊO&JিT.?|hHqvrd„¬$JÈŸ¸ã°Aq¿õû8˜éóï£{ÌMÙdô›Jå¡„ãY6ª¶‹k«kP b &ƒ<#å—q’¿ë,faõu`·=nWþý†1ó/5ŒÛÿ°aˆÂñ Ü&6S¥ÊÌ8®:îR½•!ù•*•RáË^XK—é\\Š â\ÂþÅð̸.éwÔÕ;êQ`0Eý/Í5õfendstream endobj 40 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 285 >> stream xœíþCMR8‹‹øqù-÷Z ‹ ‹ ›÷”Ä¿»12OÁøˆø§‹¬ø«¬·Ÿ÷Ú÷Îù¦‰ŒpbcVs,‹j¦‹Á‹Å¦ü•fˆ,hj´Žá‹¸‹¸‹â‹´ˆ½ #¬h,ˆ—°ø§‹Ý÷ïôí¬Àô÷tê÷®÷`›šµ¬›™ÉÄÆ‹æ÷ 'Øûû <02Z²„™ ªš±¿Y‹¨ÔΤ¼‹è»<7#B?û û ûû€‹‰‹rø¨÷GlˆwƒYx…ƒ?‹{‹ûF 7Ÿ ‹ ‹ ‹ }ßrÇendstream endobj 41 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 148 >> stream xœcd`ab`dddsöõõ´±dº‡~ÏþÎÌú=š·›‡¹›‡eöw~¡Ã‚ø÷ 0€£5/##‹Ý¾ï»‡-øîø™ñ»ÿræïþ³D»½jƒ|}Û;:;»Û8š'·Nš~ïÖwÎÓÅÛã3Êó òçåoX> stream xœèÿCMMI6‹‹øÏø€÷\ ‹ ‹ ›÷jÉÆÃstar?‡“øˆù• øMŸÎøŒ÷È÷)‘’Ž‹‹ÆJ”ŸuŸu v‡Ž‡‘‹“’’“‘dÐ~£p¹‹y­÷<Ú™’‹’ˆ•~ƒ&w‡{D~t÷L‰™‰—~‹}‹‰{ŠtûLûX°~ˆ†„‘…–†÷>;yi‹‰q]ylhM‹…ƒ’„“Œ–• 7Ÿ ‹ ‹ ‹ £ [äendstream endobj 43 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 4217 >> stream xœEWtך–P$O-VKÕ„<X:@€4:¡cƒéîÆX6n²,¬^Fºê’«dKî½€1ÅS „^ †— $äe_ÞË’wǹÞrEvÏJçè̹çÎ÷}ÿ÷}—Ízm‹ÍfGmÊÈJ’æÇÌÚtpñ†Y1©éÒµ‰’ð_“ÐT”<üŸÃŸsÁóZͤ7OFÂOßüÇø›XáÏäeÙsòVç¯)Ê“6È“7¦lJM‹Nß“'ÉZ™Åb½ÇÚÌŠfmameMeŲ¦±âXÛXñ¬å¬¬Y¬¬•¬Ù¬U¬9¬Õ¬5¬y¬/XkYóYëX X YY›XYÙ¬q¬÷ð>Y¯±ÒX/ÙëÙ/GÅŽzÄIâüþZÚkÃÜÞjÞ@Ä;‡‰1„ïõ_¯Ím{ƒÿÆwcdcÙc©±·Çí×3^1þÄ„Þ W¡cA&u1oÙÌ—~AŒËèUÝŸÅ\æòÐÑú$Òj’õ" nöGÄ»ô.Pª¾@Çä a/ˆ¢l:›èE µX·ÞHPÐ1"‚•8–CåÜq ­ëƒ/ÏDžÖ¯¢øO™øº 07;MN‘^ïõz¨¸@À$.ÿ¶+䬩x§+§>eý†ÍèÃ)â›0›¶Çi ÍR"*⌵ÜdÀh5ZM3Я¼>øg_ͱ[—_œ9Ý ˆJŸF®6ÐKÈ}h1—ÿTOkßI­ Ú7„^ÜãÝhBÌì»ñ lx˜4MCsм⾿q­eà"yãzÏSð€øzËÀB±ºPp´)-fù©ûÖ‘iÛRó±[Òu~°ùÙ©»äá ½-G^¶š™, F.…‰Ðþ]è3MPËÀl¶rwCP]:zo?æLÍŸiÈÖìQ©¬°ÄÊˆÝ _¨"ð(8HÖ«ªÌµ€€ÀÙð8ÿѾ¾•ëve.ÙB6ÿâð`µYí"‹Ë_d³ æY¬h¶” ýx—–ê\°¬Í^°11z—d; Ê*k:º`Tó Ùxëâ©Ó4Þ¨™÷ƒl8öí~øYà艇íšZÀ \f—Ö«ðš‚€hTµ¶…ä(srɤÄäh*¹8]xfÑöå*e¹Z¤ˆ¨s9€5åZy1Ôr :Î}¥'æçvö°hx²`ÄDñ®ËŒ (Íy†|4~d“P¾Ù`ŒÑã÷vù#¶8䥠x•îš+0_Øm©±Ö€ÃÀcõ™+õ¦š²¨’€Iøªä®½óh+úÄ"º‹ÝÁ ÷ ‚Ÿt©6ɪ"­F`µªC!~IUPbfÖb> ûþ‰‡Q|[ü@ Có¹~ž×ïv•€RPeš¾ÄP ýŸ\>÷ðPá±ÝÉÔ>ª4í¡PgKÚ§%b??)In1O_¬7ÐÚ‹\øIožÒNM\¾+á‹ÌPBoy8>°d{³2÷ÅJŽüD‰Ç §É»™áv?û`5g8~xº@éTä+´¹@¤j‡Ô³ÃŸàMJG±h7ÊYÓ¼ªoy&þ~ηà¸W=tôÜ,ô_ð—]w~TME”YË-NÐNûµ@¤ÆƒÒeÒ´^­–JSÕ{ñB‚åƒ0 Ž?ùŸÇû®4Þ×Áùœ–=þ\O¡k_-[5§àïmlxŠY*ø˜×ô«ÍÖ©ÈC;LFÚª7ŠSâ7îÈÔåé F V`±ÑÄ oj²è¬4­é²ôûž†¨ÆíM?\«<;7PD:£·Ì†%ï ŸÁo¸OxáÑ8ßÇðƒ‘½Cð³GQüx&;ÀöuÊb ³»Ô @õ=ò1ìç.ãÅ 9jÏr‚|ææñ™Õº’J'°ã徇ÿMÛcT醃¨8â°[}&·Å¥Ã|èMyºŒ4ôžP¾ÒäDzUQçݳç`Œg¿K­…?>«JÞÒWüù¦eŽ<È, O+óóÉ(~·jgà²5ÙK´žÔ²˜²ÉŽOœó…ö»Þ‡Å¨ïºí* v¶œ}ç ›Ñ={Žö‘””4¶ÛlN—Ó'ÁÂHph‘Ödå+U…*—Þ¯û•nL5HȈCQè£LøRÈ.µ8Œ&Ú¢7‰1íôÍKÍîÅ«žˆ1§Uf9ß|ÀdZ‹ÚòÊaNí 2s‚‘'0þ~ÿ8“G ”J£É Ï’¨´:@ènO°~Þ—’Ž›Ýî38„› 4­Ù¥ïÎ%¢Ùh=úóªCI×îm‡ž‘²OiÈÇe—©›zê«¿óËÑÇðž ÃR“öƒv Ñ«—åçd(²±¿ ùĹC¿½Bö\ìkë¡_m¬–™pŠÍŸrà¨á(Á%‹›R £ÕF©Å`1XMƒM±pÍCYà ¸®€óîì<ýŪíIhÔJq?Œñ4‡Ÿ›\ºtãz¦ àhãmkãßÞH¦¥&bã•(Kk/·üÜ;H:~èdØxÏ‚.æG^S±ß ŠwÅX©Ç~Sl.0äýá7[ Æ­Z‚bÜá™{ÿŠœÌ}RÑ~E’ñC@|žçmð¸ê\Õ$Ïl®<ÓP}Ù)ÇD3‹ñšo÷p*™)‚r‡ÇV @eÞ ´4°®½€2RJ¹$I–«QJÕz0ƒCãU–i\@H i^MQó5<‰ÓáNÈ"oÁñM÷À)¢%¯>«€RJ•^MP%®Öxt $§}ºM–AB¨|¶.VÂ̳ZÍÀ tÖtã6-¶7º8,‚hMC†Ø-ß@í=üõ7AltŠt' b2ŽÞ}ÚùüÂ%²¹¥§ê0 j+õj“ÅdÖ‘•ÅtD~eq]c(Øpboçfœxï¢ÐÜ™çb<ßúð2‰AìÛÃA6.7Çyèùˆ6–ÑrÑZŠwš®Ó€ 7+r‹™Ö˜•VÚj¶š'BÉŸ”²íáØ߉ûSVš@‰³Á€£™UÂ/GŽrnNa@78ÝW+Â2ÔgÞªe·~ ‹npàï-X-¡ð Ĥu«´WzÛÈ&'œúí!øFÔ›Õ°MAóÐb4}ɹ­î¹yIŒ²áAÇóÁ¡3€UP’¢tI™¶?U¾ ÀA€’CÌã6XTÃFSo2kns:™wßñæ,’¾{ 6ˆÔzÏas8\¤Óms7’ )yAFgαçwþ7߃÷¹Ís·q‹× çuß½ˆrŸÉ@[-´‰4ë,&`À¤jj««jºÓšvîL‘îNg¥ÈödÍ æðþ衇ºaG ›±þÊ ¿)0Tè@.åBÕ^4zäÓÿ¯ÄŸÉ:@™½¤¤ë,ŒÖ,GÀ¿›£­§»›ÏƒKÄ_—žE“ÄÈƃ+·Ü¡2O®‡´ÁâyiØ ÖìÙ—+Q¤è7âyÖÛrœaù¡¤ø,·®¨‰ôžog\>ð8Šÿ_Œ„ùWÁ& Lv½;§ê@I*gÞg³¶×d ä’ÑÉrÈ*¯ººxÚ:|½‡X}cïßaä“Kß^Ýulf½x_i®T•µ åv;°:Ä^K…Õþ?¾ÿñ«G~:h ’§yüßÑú^`Ãñf·:¬%´ßôÛîƒx¹¸-ÉŸ}¼ûе:wÀ_-.ô¶{ñÿÁiÌDAwuþîýê}E¤4I"ÍDª´©ïÅÀ_®“ÿW¿ÙðÈcÇ#“Š£7nZƒ£WgðùJüWýdóOÕƒ ŽèÉiLY·r-z¶ŽabM®-ªÃfƒHÙgz…»NݪÇm¶ÕJ¥h∗ð8»¼£çËþÇ·®tâ^®V™q€Qd,JVí4H€Z” Ït6~‹­æUEüó,{Éa®ùû²@QÿlhÚ+ºÚÚ›±'~Xv½ƒÙ£x½F—µÄà5¹Õ¸‹¨Mù†œ?Œ=»«öGlò\ ”8Ê}`ªðº ŽGC\8‡Ê˜˜ürO ¾>’ºlÚúxô&¥±9óÉp êcAdŸzÀy'ÈÏ4èµ…Bù*Oõ^O‰£ÒSM‡Ãc÷ö›ý|@Û?(’Ñ)4>œÅá–ª§)£lZ%¤¶%@F¤ùe-'º[ž ˆ ™“‚YAVfuasCmmSsACŽ­ óS'{xl¸&7óÑì*óYÈj ÀYš2ROm˧֚°[õG(lJ»$;Ô>\–Ëe¾H2&áyÞ½¶¼­*«Ò¢ n¸maþdÿã;ΰûí©.±”éKŒžb Tîû»Ð§f•Ya*’¯S&K3R6ÆIVbQÌÉ;­pìMH‘vÝcs…îø+nypál "nKÃ^MSfÅ6+ÌB,ÕzLÌx±F¨¯ïÂéÇÄ_ÃC‡àÛN×ì[× »gˆ‹àxNƒ¿êÌÄ"¥¸ÉSêq”¹‚¤ÍasÙìpóPhrE«R Ñ8"N m5Ò:ýËH=­±hI”µõw6ÿõz¸Pc5ÿG?þs.|Ì^…å¬Uëµ´ù`z¡ç¦Þä.q9ýî:¸N›Ó^Ü¢®¼ÆŒ"™A™/Þ™™´k5Uÿ°rTõ›Va½Ï_„©´}«ºÐ¼H)¢ê#Ê JMÁÜtÄ' ÓZU<ñ€wίìîè¿ðôò…ln¥ËDc7 ÖÿÜàé3wOÝ:}¬¥>­ÆdQ›ää¤Ð¥™‹€V”UA5ôk<+vy¸ãà7È È‰< 9ø‹ûE ÉË•d×ç5·Õ×µ´æ5d‘üÛƒ? $ùy™Yuù-áÛmyõ’ðL£„zøÙq8Ò󃚚H4ù&Ã}Å/dÞÀî­O¥5Ò…(JµäYÕ²æÞÖº¯.‰)ßÞíE |è6š\nÒVòïÌìS0×~—ÅI[°U›Ä8Õ­J#& 2µ½ØNð;²|‡bâV°5/%1awaRÖ4b.ϘÉ}ÎSEkâÌEÐ 嬤õFLµJ^l(„ÒèÄ©a§VpAy@*£äÒôöÜãßÝý;ÜÒ+¾ ¯r=mWŸÍN߸D5!Æ‚ÏfÒ¤§ ¸Q™í‡Ñi°q²ÒÂt4% Œ½Ê†Ð+@yŸ0‡7NdVáž ¯vô£7À˜Ñ` þd±þmݾendstream endobj 44 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 620 >> stream xœ…‘KOa†¿¡a€Z„¤2ÝØÆ4èFM q¡ä’‘DÁ¨ ‚ ¥XB[¹´ÐÓ+¶†H)Pb0.@«c 1Fºò¸aÅ7嫉S]¸ô,Îæ$ožç¼Rç!Š¢ÊjÚ;îôöÔ›:jL§¯”Wßmm¯²Ü6æN\§}ïH¦‚ 4꧙‚Òï%Ÿ‹·÷£Ü¨/T×Ö#tCè$¢•0¤F#CyóôاÍIþµDÉQÙ¨3ù›Ê­RæÖÀ=á• q ô_!eK%K° Nî%®§³‹f&6 ¸“£‘Ax‚«g¤—gyÎvÍîhbÍx#žßà! QßT(î÷=Þ4nævÇ­p·c´oÞÉi÷öÙ¥ŒN¢r :ÒÆí¬…—-4é63Û£¢ LðØe6*[ÀµÃÞ®ä·Äó/‡lQxSÁù‰™æ>e·èyF.’¿’l«ï.¹ôfü1ž_çB°ao,8ã pž.–ùÉ7“±TP¯•1Høõ ~®<á>>¤Ât†ÓýOo]ÑóÙDH@8¸ìŸJãܪkÚ=,>³û kvÎ¥‰Á@ÖÜU©ŸðÄHÄ? ìÛ䃺¶ÁfÁh讽g98<ýö_F|T…U&r ®ðXÁî|èìÿËÐ8 \Q^)b~Elb91¹‰ynÙ%?h|3Î4ž„zߟÂnn3/ͤž-¤`‹ýyvœ8Hl®Ô‰«b( ì»å¶«U5·º Ýý­ÃÕnVk•d^ÂM“(Äš"ÐBn—"ôy2ýendstream endobj 45 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 2975 >> stream xœ}WyPS×¾!ÜËAZòÉÃÞ‹Z¨¾*uiµŠ;.ˆ€R…jŸ*(;²„$Nö„°\P@ZÁR+¸`Q±Øjm§VGëtj«U{®s˜7ï$ˆI;oðÇ=çü–ïû~Kx„« Áãñþž˜´9}÷Ê]Éa“£ââÓWmÞ™hûÎä£ð—³^ú‘Jðà׃£G}ï CÞ|êÕ÷aû›¼`WJÚî=雲¶l Û•¸3ijð̱ã>œ37 pÒäM!ˆUÄ8"‚ˆ$Vkˆhâ#bC,"ïKˆPb)ñ±œXI„Þ„€|•x‹`–A¸žÄ(‹x“‡#Åž/Žwße5 ¿«—ë~2˜üœ ¢ÔrKw{IgÓçF#šGüî¾Éýˆûí‘ú‘w=ÞòØáÑåéå9Õ3Ê3Õógî×QܯÀï[R,Þ\ÙI_Áuhä¦ çQ™’ÜB½¼†m¦¡ûä†áµ,ô¥ÌåÕ2Mû Õ u¤ õ»ïk{ýZAÌœYgÌ (J¥k%:lAU_ùêi"~ªW”:P.¾¶¶ýÃð-Y+2CáäZ`Žç¸u—ÕWðŠ-Âh›‘¼»‘‹ÔÓÇ÷umÿli+xt«µµóÒ?û#;g0Èä¸ÕM)Pœ°Æ‘ð}êh(6g×æšö€Lzɼ5“Á´ 5¿€¹$ ¤¾Ç¥G²rjwTzÑ°Y¶8r-σ|+çmås~ÜB!zF>ˆ÷í|ȃãáh(„ì‹äÂJ6 ^Š˜†(Ä‹F‡]ü ’ÿº³Ø ·Àw-ð¶äNœÒ#¸ƒ<ÉL7…\ëÈh'¨¢1ÊÆ U6DuAÍñe§“n1ô‡è Ŭ@ôdq"BV§,YÊÖÁȳŸ.®™=f\ ¢f¬:wçù³Çd‡éÝiñtÁØ+¢©ìü¢½vnÚ¹}‡Ê²}0È«YxÝFPUE±6E¡Ôç0•ø?¾m:üöƒÚ¢úÝ:©ªLèªÊÊ ƒ¤"¯ŠÍ¬Íѧ‚µà£ä:ƒÆþr¬ifέ-Ñì £: â”¯ º–)ʤ ”.6H Uc†Q›HAÓ¶æÎì+~Ðëéî=’YæîK0­ÒÏ5iÌ0æ˜A ÝÞßv«¹URPÏ”KÍ»A‰b§H[¬-ÑJP^®©«º.Rj•Z ¦£ R½$¿¨0£„4KÞTé‡xÓ"æ§Wî®Ëgæ–~]|VÖ =°·® *äБsÖ¿3;òØIµR§Ô3JPm3²W"É.R|fÞfüÀʇG0€ p¤Ê”@-Æ‹òíÓÐHrž£DnRQhiQY1(G‰û®ëfõ¾Næh¥É*èr©¾X®(“1÷„ä¬tdÜ¡6R¯Ô³ç¡™„)Ž±ûO³ñç ÇãâLáVø|㨾DêçA"7*Ãáx ªÂõ¾dYr¨ßƤF«hT:¶ž%ÿ"7|MQXV Å«¬q}W¯>ÛÇ {[d"‹÷#+|†¥šÇÍôùÅá2šÂ1Ú«Ö(îYm™79+/ž)Ëpª´D/5¨ÕJ¥–Øo14úŠ5e³ à\Ù¼E«k’´€1þóƒXrÅé­?ô_9t~3UÞ!ü ,j÷@‡'ê¸~ï tëèIZ^«—Ç„»„0N%uŽX‹#£N }€|Æ@ò”Ӿゞ‚>h*JCKH‰S•‰`‡R0B/H®pº!rÜ(¢lò¶p|K·'Fç:×ÉyZ×Õ¯4 B"䋾YüüÚ€ùDÛdÞgÆŒ$F©\Z"-f"Ö/Hèi+Ïßiîn²²Öî+ÇúAh/Ø—S!iHrE¼H+Ñ*ôXÝF¬îú‡"¬MMÝS^ 3Kñšª§vªžâH:^ºsO†ZJ^¾®¤sƒ oÄ4Í೸m‰ÐØ€›ó{µùÆeV•LþBÕA•Ë®¡ÐxøTx·'â}VpÑcü=3¢ç.tûó¤†Ú2—Ž‰(õ|®žlvB9ÈYøƒ[P,§$Ç µbÜÉøÁt2Ñ©ƒ a*ůçS¹-0vPIÛ ²ðžY8aŸë µ ꃠŠþmN?â¡Œï(Ä þH÷Ô5v35ååc£L/‘—”Ê%ÌÇ;榇:(ôÒ 0(ËY£EØúóÝ ý°7jV)c=+ NÀ-þæF:eIU~UþeWsÅÅ)*Üõ*LUz¹N¢bwè–é·‚`òQÞ‚üpÑ{ŽäîÛ{j S¶ýŽlÑbêoóà9æîg€÷„;¯®o\ˆUä‹ÞDo ŸÀëK~èi¼z‘Ý…„{C—­ Å<ÒNÂt£¾–š“Ÿ¶¯?f´Ð‚€Ÿ¸²Û‘Å$J°-L~.z"Ëì5gï<ÿý·?_e¿Ís0£VÜ×’¡FˆkáZBStšAŸ·Gl’jsØ$j›ÑÝ©Öž à=°üÜL©¨¬¿Òë< ç:Ó‹G³9$œLõžÙ½8(Ìÿ5ú<ãq“m3É ?ènM·yx•êñ iÅÝFPéãÈjH˜õ8h,lǧÀ¦8ÏâÁúÿgÈy÷¹`«f¸3ÿï»Ïë¦zxÁrq÷µµkAë…Ó­[üŽHÝ…U&c—¢ëäMç&}šO_8qð7îOÛ1ÔCÑ×ø’Ó2Ô[T¥èŧNÄnÚ–Ët¦Ø6Ĭëi{°1$•ˆc¨š[Ž™øjxJãm%]fæ,ØãiÎ*DûËKŠKå@Žã–M:m‡¸šª+äà*7Ã' ±}E0ë5Œ¾…„¶¸áaÌn&Ò‘En¹Æ¢ª:“©ÁÈÜëçÇ×ڊ᯶‘xjcÇÛ '|hgÃ$ìS—ašº€Wã»@Rœ#gÂP:9Åv¢ÔàÉ6”D~±íd>™í˜¯·©xäM;r CiŠ"lO!ÆãÏXi4Ôi™Ë0|h;)“•• Ÿl'½øäÊ<,ÂÙ”z °Í)T ô¶î ›…åiÚR5kA£Ñ©Ô"µF¥ +UKµ¨ƈ¸10ƤÓéAŒ÷e™ªL-*ÕÉ5xÍòR™Â&eù£ð÷;6áF8â禢·ÿ÷ ~ÌÝÅ¡ òaž\-W)€X¤%rY©B¤P”Ê@ ©z9ìC1¢Á1(¦P&“‚b1v^ª,U*D*™¶D»¦V¥SÛC¹ßÃç.cóANöÆÕÈMÜ€Üò±Ú„ª˜šÈÊøê4µ § h¼]šp:ej6ùÇ‚+à€ÎâuÛ N7Ua¬õ´sg›J°¯‡¿°Í/(Ä^• öèÌŠå  €(<ö¼Ñ ¹¹m9)¯¬«;ge +œx ºèî¤@~ü%…'ì1Jàx!òBj… g(ç—UVtõÕ Üëìô˜0œ]ÐäÚ„¿€–‡Wů!-ü÷–m›vÈhbMT{[«õØž}ÛíÇ®œ)íðN;Ÿ»Ÿ õÇÔà( ]×^ F.ñ” ÞÎdL”&)’@²¹žYþº<Æ?8¦63¨ïaeoÓµ¶SG[>­³º¿eÝ„Å.ùn6+xïŠíK¶~"NNØš½Ћ¾|rD}X{•i榛ñk6S÷“#‡;ðÀÿ½ ⿹iBÍendstream endobj 46 0 obj << /Filter /FlateDecode /Subtype /Type1C /Length 3211 >> stream xœ}WkTG…‘¶5§{7&Aðƒ Á* ŠoIDŽŠ2<…a@¤x33€03¢®ˆ±€XHø¾ÄÄ"˜Nø‹‰¥Dá@ÐÄh‚!ÆŽ„1–GXã‰-„'1‡°#FöÄ(b">4žÎ'Ú$’ËÃ>Öf5ÓjŸÕ¬£­–zHëÉ‘d©ÌQV${J¹RéáK†7ØøÛ°e[fû½#Òï9‹#ÅQ½‡—¿€Ðοˆ£¹Pëßy¼=q–û;f?|Ùûøá¯Þ/ðð>÷MõT€.HÀ=ƒwpA“- ú©±OLÒÏÌ' 6ŸŒîv<òœßÕÈ{ˆ‚‘/þ¶=l§t‹ö^kwú¬béuàóÓ{o®ëTo—‰ž/ž?èø…s;ï›ûÌÆyEŠŒOMÛ“¬M+ç:Ä®Iæ´‘åÚ¢â’Ô¢xNô…ÏIzZ/ «;Ø0¾Sí.Tçd"ªX£)֤ŗrŸWÄhv 5h]ÔÔYpE’W^ñ_4@ÛàH ³åXÈþ D¹Ì[ï¿]YÇUÆWªÛÓ¾J?¢þ[EWI,Þ=n•_Øô}êϱ…²’4Íž$µ*Ž-£ýâ U¥%…=«“ÑUá§/Å·Œéã«uÊÚí¸mÂu…Ó5é91¥}$¶8¥¼lÜ™«Õí—w„ä³9 …êbD™ösm2zŒA­INNK‰gûO ¿òà`”À»˜á ØÊ éEIý©EÛ¹²!•µ‹¤÷õõÏŸyâ¨V¥MÍÈÌÊHcÃv/ˆ_(ŸOk¾äÀ;eC¼ b"Àìy8‡¾t¤Ã„Åc:,¸U*¹(#-²”’tò•‘‹Æ¯Ù|ê_M6 ¶õ¼²ú{–^Њ®W~ÕH r,ŸÆ€» —òæࢅÄn‘¢³Ø%U’¢+tI[HÃÀ"%'N2/âIðì“Kþ’'Kݮĺíź¥×˜•»²±Ï€•»nhæEIŸ_x¾Yqw<È{zaØOîí8úÌ\´bÛÚø|Ãüó¾û÷\9ºa¢ç£ÞÞá¯VÏþóݶ r&ôx°!Qâ¸I“E'qôó÷Á±µÕX÷%WiدGÅ”V¥IUgîKKcW¯_ºk^)™Óñ ëì€aO¾Û´*ˉ/P—¼@·ŒžmæWÉþ±Ðoyx͇‚#}QÈê/Ô÷rÝw5Þ8º­«ÉFö¼gº†Ñ¨¹îümÊí…™w:1˜wÂK¦÷¾ÇŽ®qöpwqöĦ€«|£¹y<¸ò¡Ö3è\¦!©&â±Ç—“pðÑÎSÅ☿ã»A~¾N‡‹ËØ»/CÍmÞ6/f) äÑ–ôÅ[ëÿ~çëÔƒÚ——MR¼‡…•|R¼N^j¨k­8™™y„½ŽPŽé"kÓ ÷ärÛ | ?CÔ‹WÍ㦛õÖ%v¹˜Q€ÛØúIƒxÈÅI±ÀÏá¼AƒíÈŸÚŸ=›}篜¨¶@±/&Ø"Z©×Š%!ÁrÁEö e…¯Ïü ¶OÌÎOì<–ÀLÈÍUU&²¥S§ˆ”H=› RŽ¾{5kh¥DFæ¼Ò—Å^gÎG’—P}y]}UuÉ1ÄSô;ÂÄFýöFXØDÏÌ‹»ØG½½§NõÆ>ÚÞñüö‹¤¿ÐæBÿ$>ÃÆ‘VÔÉ\Z‘º’Æ•åWÑØS¨B}Pyø‹’ÏûŸ¢‹§ÈÑ|%C —|è×45`Óî€5ì@öpóÚŸ½¡æ<'éÜr6¸Küºf&z;éª_ræYõ¹ ¨…z2ûŽ++fÿO昷z“g ñ0Evçfð²Å«]†^W¿:@qSXÿÛu×ô†L·a#v‰3,Æ¿[ð:ƒ¤{÷ ß3Ë'4‘„ zMДË[ 3±Lû&Ê|×­ócÅÑ1²ûFË3Në,0RAö`$Ä ŒG5ã.¦Bt³Ø<¼ÏðdÑbèz7Ÿ‚9¦Óãh ›kñ(_Ç]†‚¤ÛÞÌ”›Ú…!ýÓ7`$éºk'ªׯ=¶%ŒÛÚeí„‘<ñuա㈪;¶õ3N¼ó‡udÓ†‹¡[c׆±1¶üQôòMhGœbýÀe–@ .­]qi`BFF:J›ªMÕäådç±àtZÚW"r¯“ÖTä‹ËνA¨†wòᘶ§0’gre×.|Ûôã`#ŒGQÕ=ó¡KÀŠ¨õá¬rWr$Š£T•VWPPšÇ–5Óp Q7|B”QSÞç¼çzx»Ï£–Éè6½Gê<4Žá\‰¼pçZÄ+M¹xÈädçdg£æÃ'.£kÔ^7W¯Mˆ cc’âP*•ªQéŠrsŠµìÑÚ‹Æ«ˆº×´ÎSTئ8.65!k-¢âSyhëyä÷ñ/ÿi+VŽoàÔù{sÒ•ªR¥&—$×Äs—£Î'_Ä‘ìù£Þ[š?®~#ÛÑ<ü ›¬ëL3âh/ )M²ìüFךF%¥ý#EŠÊ>'éâ1‘„0ø—ôÙ_'<äÁ³ãÂÃLPÐÌ@ºÅkZ‡»„ä"•.??§ ˜=]qVw QO¾^êöö¢ù.ÁÏ®çÔ…ý¤¨T){J«c¹K[/%\ÁØ>ýÀÚûÑ»Ÿ„«b×p /ñàk,Å)ß: çqÊ…Ád²ö# ºQþMåÙ‹Îw"Ògj3Š2ò²ò¥+Òè eŸúûGo\ÅÍ]²e&)JœÿX´›žÎ§@¼ôz2mAðæBÙ‚`æÐY~YõñSêuûšŸçÌ ¿¹¾kžìä25(;ý I’YFç%¿ñpãé'œfÄ}Ú¬½Yé(sl fS›Ÿ_–ÏÂ,¡LÚÒ7ÜK¦hÙ lœOA&î…¤¸!źK¥G°…Væ»ãÇΠëÔÏî“&¹{Pýéí–~5O¶ÚoœëÏW¯ž<èi »2¯†¥{¼¡œél^±À?`µ·×²Ë­·›¯vrô+±Þúñ·A^sý–y¸û7w´ßøúÑü&1z<œ?i%(àw&[™ˆThqüÒ¨OÖy{nðBJ—›šŸ–¿7;“¦JQO8ÓÒrøÜ®ýÛºPÌŸ v¢«×‡"ñnç¬îïO=âÙôFf×')q‰ Û"6dž#jaP냮µ¶ßú2dÖ.W…² v›Ðƒ@Üeb1Žé6KÏ,ƒèìrµ. MFéiYñ bŒÓ4r?ž-ÌÖ¥jSLóê7óîfsºOªD©…éýH&ˆÑÒ4ÙLEIA‘>‡Ý1Òn2QŒÎJËÂthl *,ÊÖ—AŒÓcó<ÈmàÀ˜¢M#5à`jþÂ[¸#¾^µã$§%OVUž¨¬ ãR¡Ïï0Ï­¯<f‚R°׊¹Ñš=«G]îáZ(p2y¿=ÿzܯ53=†Åþ¾XóØ•´Xo²øêÙŒ«©Ö¤äþË˾ގ;†¡qi9è0¼û@Ç Eé{Ï OUÿ»$üYˆ}=‚É+ÊÎCyöÙTÜv%©Yñûß—ìUge ½Ø}UZm~^i!;hx,eÓs,$À¯ L÷B´­¼DBœÎ:ËD·N‘+°êÜXñ‡ º¡¿Uu®¢¶ÖpFµÊ EÕF½/ZL¹ÉÐâ8ßÈ1 …rÚ„†˜ÚÈsq·Ð Êî £0Óˆ¢äÞÉmÜöŒ\Žäñ_¤àëBendstream endobj 47 0 obj << /Type /XRef /Length 70 /Filter /FlateDecode /DecodeParms << /Columns 4 /Predictor 12 >> /W [ 1 2 1 ] /Info 3 0 R /Root 2 0 R /Size 48 /ID [<0a664ca0295ef40c13f69832df60ed9d>] >> stream xœcb&F~ñ‰ ÈcôÄN»ûL ¬{Îåk’ïR ÁX"Þ‚ !xH0>= options(SweaveHooks= list(fig=function() par(mar=c(5.1, 4.1, 1.1, 2.1))), width = 75) Sys.setenv(LANGUAGE = "en") if(.Platform$OS.type != "windows") Sys.setlocale("LC_MESSAGES","C") stopifnot(require("Rmpfr")) @ \let\section=\subsubsection \newcommand{\pkg}[1]{{\normalfont\fontseries{b}\selectfont #1}} \let\proglang=\textit \let\code=\texttt \renewcommand{\title}[1]{\begin{center}{\bf \LARGE #1}\end{center}} \newcommand{\affiliations}{\footnotesize} \newcommand{\keywords}{\paragraph{Keywords:}} \setlength{\topmargin}{-15mm} \setlength{\oddsidemargin}{-2mm} \setlength{\textwidth}{165mm} \setlength{\textheight}{250mm} \usepackage{Sweave} \DefineVerbatimEnvironment{Sinput}{Verbatim}{fontsize=\small,fontshape=sl} \DefineVerbatimEnvironment{Soutput}{Verbatim}{fontsize=\small} \DefineVerbatimEnvironment{Scode}{Verbatim}{fontsize=\small,fontshape=sl} % but when submitting, do get rid of too much vertical space between R % input & output, i.e. between Sinput and Soutput: \fvset{listparameters={\setlength{\topsep}{0pt}}}% !! quite an effect! %% % \newcommand*{\R}{\proglang{R}}%{\textsf{R}} \begin{document} \pagestyle{empty} \vspace*{-15ex} \begin{flushleft}\footnotesize Corrected abstract for ``late-breaking poster'' and ``Lightning talk'' to be held at ``UseR! 2011'', U.~Warwick, 16th Aug.~2011%, 17:00--18:00 \\[-1ex]\noindent\rule{\textwidth}{0.5pt}\\ % horizontal line \end{flushleft} \vspace*{+9ex} \title{Arbitrarily Accurate Computation with R: Package 'Rmpfr'} \begin{center} {\bf Martin M\"achler$^{1,2,^\star}$} \end{center} \begin{affiliations} 1. ETH Zurich (Seminar for Statistics), Switzerland \\[-2pt] 2. R Core Development Team \\[-2pt] $^\star$Contact author: \href{mailto:maechler@stat.math.ethz.ch}{maechler@stat.math.ethz.ch} \end{affiliations} \keywords Arbitrary Precision, High Accuracy, Multiple Precision Floating-Point, Rmpfr \vskip 0.8cm % Some suggestions: if you mention a programming language like % \proglang{R}, typeset the language name with the {\tt \textbackslash % proglang\{\}} command. If you mention an \proglang{R} function \code{foo}, % typeset the function name with the with the {\tt\textbackslash code\{\}} % command. If you mention an \proglang{R} package \pkg{fooPkg}, typeset % the package name with the {\tt\textbackslash pkg\{\}} command. % Abstracts should not exceed one page. The page should not be numbered. The \proglang{R}\ package \pkg{Rmpfr} allows to use arbitrarily precise numbers instead of \proglang{R}'s double precision numbers in many \proglang{R}\ computations and functions. This is achieved by defining S4 classes of such numbers and vectors, matrices, and arrays thereof, where all arithmetic and mathematical functions work via the (GNU) MPFR C library, where MPFR is acronym for ``\emph{\textbf{M}ultiple \textbf{P}recision \textbf{F}loating-Point \textbf{R}eliably}''\nocite{FousseHLPZ:2007}. MPFR is Free Software, available under the LGPL license\nocite{FousseHLPZ-MPFR:2011}, and itself is built on the free GNU Multiple Precision arithmetic library (GMP)\nocite{GMP:2011}. Consequently, by using \pkg{Rmpfr}, you can often call your \proglang{R}\ function or numerical code with mpfr--numbers instead of simple numbers, and all results will automatically be much more accurate. <>= options(digits = 17)# to print to full "standard R" precision .N <- function(.) mpfr(., precBits = 200) exp( 1 ) exp(.N(1)) <>= choose ( 200, 99:100 ) chooseMpfr( 200, 99:100 ) @ %% Applications by the package author include testing of Bessel or polylog functions and distribution computations, e.g. for stable distributions. %% In addition, the \pkg{Rmpfr} has been used on the \code{R-help} or \code{R-devel} mailing list for high-accuracy computations, e.g., in comparison with results from commercial software such as Maple, and in private communications with Petr Savicky about fixing \proglang{R} bug \href{https://bugs.R-project.org/bugzilla3/show_bug.cgi?id=14491}{\code{PR\#14491}}. We expect the package to be used in more situations for easy comparison studies about the accuracy of algorithms implemented in \proglang{R}, both for ``standard \proglang{R}'' and extension packages. %% references: \nocite{% MM-Rmpfr_pkg} %\bibliographystyle{chicago}%% how on earth do I get the URLs ??/ \bibliographystyle{jss}%% how on earth do I get the URLs ??/ \bibliography{Rmpfr} %% references can alternatively be entered by hand %\subsubsection*{References} %\begin{hangparas}{.25in}{1} %AuthorA (2007). Title of a web resource, \url{http://url/of/resource/}. %AuthorC (2008a). Article example in proceedings. In \textit{useR! 2008, The R %User Conference, (Dortmund, Germany)}, pp. 31--37. %AuthorC (2008b). Title of an article. \textit{Journal name 6}, 13--17. %\end{hangparas} \end{document} Rmpfr/inst/check-tools.R0000644000176200001440000000434414274665772014704 0ustar liggesusers#### Check tools -- notably for Rmpfr #### ================================ ## to be used as ## source(system.file("check-tools.R", package="Rmpfr"), keep.source=FALSE) ## Some of the Matrix package check tools {MM = ~/R/Pkgs/Matrix/inst/test-tools-1.R} ## ~~~~~~~~~~~~~~~~~~~~~~~~~~ assert.EQ <- function(target, current, tol = if(showOnly) 0 else 1e-15, giveRE = FALSE, showOnly = FALSE, ...) { ## Purpose: check equality *and* show non-equality ## ---------------------------------------------------------------------- ## showOnly: if TRUE, return (and hence typically print) all.equal(...) T <- isTRUE(ae <- all.equal(target, current, tolerance = tol, ...)) if(showOnly) return(ae) else if(giveRE && T) { ## don't show if stop() later: ae0 <- if(tol == 0) ae else all.equal(target, current, tolerance = 0, ...) if(!isTRUE(ae0)) writeLines(ae0) } if(!T) stop("all.equal() |-> ", paste(ae, collapse=sprintf("%-19s","\n"))) else if(giveRE) invisible(ae0) } ##' a version with other "useful" defaults (tol, giveRE, check.attr..) assert.EQ. <- function(target, current, tol = if(showOnly) 0 else .Machine$double.eps^0.5, giveRE = TRUE, showOnly = FALSE, ...) { assert.EQ(target, current, tol=tol, giveRE=giveRE, showOnly=showOnly, check.attributes=FALSE, ...) } showSys.time <- function(expr, ...) { ## prepend 'Time' for R CMD Rdiff st <- system.time(expr, ...) writeLines(paste("Time", capture.output(print(st)))) invisible(st) } ### ------- Part I -- do not need 'Rmpfr' `%=N=%` <- function(x,y) (x == y) | (is.na(x) & is.na(y)) all.eq.finite <- function(x,y, ...) { ## x = 'target' y = 'current' if(any(is.finite(y[!(fx <- is.finite(x))]))) return("current has finite values where target has not") if(any(is.finite(x[!(fy <- is.finite(y))]))) return("target has finite values where current has not") ## now they have finite values at the same locations all.equal(x[fx], y[fy], ...) } ### ------- Part II -- do not make sense or work outside of 'Rmpfr' : all.EQ <- function(x,y, tolerance = 2^-98, ...) # very small tol. for MPFR all.equal.finite(x, y, tolerance=tolerance, ...) Rmpfr/inst/NEWS.Rd0000644000176200001440000005655514552770112013404 0ustar liggesusers% Check from R: % news(db = tools:::.build_news_db_from_package_NEWS_Rd("~/R/Pkgs/Rmpfr/inst/NEWS.Rd")) \name{NEWS} \title{Rmpfr News} \encoding{UTF-8} %% -- not yet in tar ball -- %% \item Start vignette about \code{gamma()} inaccuracies and possible %% remedies (is \bold{unfinished}). \section{Changes in version 0.9-5 [2024-01-20, r407]}{ \subsection{NEW FEATURES}{ \itemize{ \item New \code{.mpfr2bigq(m)} transforms -number vectors to big rational aka \code{bigq} ones (from package \CRANpkg{gmp}). \item New low-level utility functions \code{.mpfr2d()} and \code{.mpfr2i()}. } } \subsection{BUG FIXES}{ \itemize{ \item \code{x == y} and other comparisons of two \code{"mpfr"} operands now return \code{NaN} when an operand is \code{NaN} (mpfr numbers are never \code{NA}). \item \code{dbinom(x, *)} and \code{dnbinom(x, *)} now use the precision of \code{x} when it is an (integer valued) \code{"mpfr"} object, and then notice or even error when precision is lost as \code{x} is coerced to integer. \item (erange-related comments in examples) \item \code{chooseMpfr(a, n)} gives \code{0} when \code{n < 0}, as \R's \code{choose()} and when \code{a} is integer valued, may use the equivalent of \code{chooseMpfr(a, a-n)} when \code{a-n < n} to be more accurate and faster. \item \code{.mpfr2bigz(m)} now also works for really large \code{m}. } } } \section{Changes in version 0.9-4 [2023-12-04, r399]}{ \subsection{BUG FIXES}{ \itemize{ \item Fixed Windows-only (long = 32 bit) bug; adapt mpfr1-validity() check. \item allow `.Platform$endian != "little" to 'work' in validity(). \item format ("\%ld" etc) fixes in \file{src/utils.c} \item fix "lost braces" } } } \section{Changes in version 0.9-3 [2023-07-27, r394]}{ \subsection{BUG FIXES}{ \itemize{ \item \code{any()} and \code{all()} no longer damage \R's internal FALSE or TRUE, fixing R-forge Rmpfr bug #6764 by Andrew Manderson. } } } \section{Changes in version 0.9-2 [2023-04-21, r392]}{ \subsection{USER-VISIBLE CHANGES}{ \itemize{ \item \code{formatMpfr()} and hence the \code{format()} method for \code{"mpfr"} etc now uses a \code{scientific = } the same as \pkg{base} \code{format.default()}; accidentally it had the \emph{sign} of the number interpreted differently and failed to use e.g., \code{getOption("scipen")} correctly. } } \subsection{NEW FEATURES}{ \itemize{ \item \code{log(, base=10)} now works. } } \subsection{BUG FIXES}{ \itemize{ \item \code{igamma()}, \code{hypot()}, and \code{atan2()} no longer only return 53 bit (or more generally, mpfr default precision) results. \item New \code{max2_prec()} utility instead of \code{imax2()}, also curing compilation warning. \item Internal (exported) objects are now (somewhat) documented, as eventually required by \R. } } } \section{Changes in version 0.9-1 [2023-01-30, r386]}{ \subsection{BUG FIXES}{ \itemize{ \item \code{ldexpMpfr(f, E)} now returns an \code{"mpfr"} vector (instead of a \code{"mpfr1"}). } } } \section{Changes in version 0.9-0 [2023-01-16, r382]}{ \subsection{NEW FEATURES}{ \itemize{ \item Add the \code{extendInt="*"} option to \code{unirootR()} adopting its addition in base \R \code{uniroot()}. \cr Also add an optional \code{verbDigits} argument only used in case \code{verbose} is true. \item New \code{qnormI()}, the normal quantile function, computed via inversion of (our potentially arbitrarily accurate) \code{pnorm()}, using \code{unirootR()} root finding. \item \code{sapplyMpfr()} gets \code{drop_1_ = TRUE} option, \emph{changing} default behaviour to return an \code{"mpfr"} vector instead of a 1-column \code{"mpfrMatrix"}. } } \subsection{BUG FIXES}{ \itemize{ \item \code{sapplyMpfr()} now gets the correct dimension when it returns an \code{"mpfrMatrix"} (or \code{"*array"}). \item Fix \code{\\eqn{(\\gamma)}{}} - as requested by KH (June 9). \item \code{.mpfr_gmp_numbbits()} is documented now (notably as I see it is only 32 on Winbuilder (!)). } } } \section{Changes in version 0.8-9 [2022-06-02, r363]}{ \subsection{BUG FIXES}{ \itemize{ \item Embarrassing thinko in \code{dpois} (in \code{useLog=TRUE} case) fixed. } } } \section{Changes in version 0.8-8 [2022-06-01, r362]}{ \subsection{NEW FEATURES}{ \itemize{ \item Our \dQuote{mpfr-ized} \code{all.equal()} is now based on hidden \code{all.equalMpfr()} which uses a smart default \code{tolerance} for all methods, and shows much less digits if there are differences (compatibly to \code{all.equal.numeric()}). } } \subsection{BUG FIXES}{ \itemize{ \item Our \code{dpois(x, lambda, *)} now works \R-compatibly for \code{lambda=+Inf} giving 0 or \code{-Inf} when \code{log=TRUE}. \item \code{formatMpfr(x, scientific=FALSE)} now \dQuote{works}. % tweaking default of 'maybe.full': true also if(isFALSE(scientific)) } } \subsection{Misc}{ \itemize{ \item \file{man/*.Rd}: get rid of some \code{\\} escapes (needed in past; wrong now) } } } \section{Changes in version 0.8-7 [2021-10-27, r353]}{ \subsection{BUG FIXES}{ \itemize{ \item In \file{Ops.c}'s \code{R_mpfr_mod()}, no longer allocate but never use nor free \code{rr} - fixing YAL (yet another leak). } } } \section{Changes in version 0.8-6 [2021-10-08, r351]}{ \subsection{BUG FIXES}{ \itemize{ \item In \file{convert.c}'s \code{R_mpfr_frexp()}, do \code{mpfr_clear(*)}, fixing a valgrind-detectable leak. \item additionally use single mpfr_exp_t and its pointer (and assign to R allocated vector inside main loop, fixing a valgrind "unitialized value" case. } } } \section{Changes in version 0.8-5 [2021-10-05, r349]}{ \subsection{NEW FEATURES}{ \itemize{ \item New mpfr-ized \code{dt(x, df, ..)}; noncentrality \code{ncp} not yet supported. \item New arithmetic functions \code{frexpMpfr()} and \code{ldexpMpfr()}, corresponding to C's (and CRAN package \CRANpkg{DPQ}'s) \code{ldexp()} and \code{frexp()} functions. \item \code{sapplyMpfr()} now also returns \code{"mpfrMatrix"} or \code{"mpfrArray"} when appropriate. } } \subsection{BUG FIXES}{ \itemize{ \item Improved \code{`[.Ncharacter`} method for \code{formatHex()} etc. } } \subsection{Misc}{ \itemize{ \item No longer include \file{Rdefines.h} as it is somewhat deprecated. \item update both \file{configure\{,.ac\}} (for \command{autoconf 2.71}). } } } \section{Changes in version 0.8-4 [2021-03-24, r341]}{ \subsection{NEW FEATURES}{ \itemize{ \item \code{dpois(x, *)} now also gets an explicit optional argument \code{useLog} instead of just switching to log-scale by the same test as defines \code{useLog}'s default. \item The default method of \code{mpfr(r)} now also works when \code{r} is a \code{list} of \code{"mpfr1"} objects, e.g., resulting from \code{Vectorize(.)} or similar applied to mpfr-vectors. } } \subsection{BUG FIXES}{ \itemize{ \item fixed problem detected by clang-UBSAN testing in \file{src/Ops.c} (from arithmetic bug fix in 0.8-3). % ../tests/arith-ex.Rout_clang-UBSAN } } } \section{Changes in version 0.8-3 [2021-03-22, r340]}{ \subsection{NEW FEATURES}{ \itemize{ \item \code{dnbinom(x, *)} and \code{dbinom(x, *)} now also work when \code{x} is too large to be coerced to \code{integer} \emph{and} they get a new optional argument \code{useLog} (with a smart default) in order to choose log-scale computation also for \code{log=FALSE}. } } \subsection{BUG FIXES}{ \itemize{ \item For arithmetic (\code{`+`}, \code{`*`}, etc), the check to see if a numeric can be validly coerced to a long has been amended such that 9223372036854775808 is no longer accidentally coerced into \emph{negative}. \item \code{dpois(x, lambda)} now works via log-scale in case \code{exp(-lambda)} or \code{lambda^x} would under- or overflow even for mpfr-numnbers. Analogously, \code{dbinom()} and \code{dnbinom()} work via log-scale in case even mpfr-arithmetic would overflow. } } } \section{Changes in version 0.8-2 [2020-11-10, r337]}{ \subsection{NEW FEATURES}{ \itemize{ \item The workhorse for all matrix multiplication (\code{\%*\%}, \code{crossprod()}, and \code{tcrossprod()}), i.e., \code{.matmult.R(x, y, *)} (not exported), gets new optional arguments \code{fPrec = 1} and \code{precBits}, which defaults to the maximum of \code{getPrec(x)} and \code{getPrec(y)}. To get correct \code{crossprod()} and tcrossprod() generics (with a formal \code{\dots} argument), need a new \CRANpkg{gmp} release, as we get these two generics from \pkg{gmp}. \item \code{matmult(x,y)} is identical to \code{x \%*\% y}, but \code{matmult()} has further optional arguments \code{fPrec} and \code{precBits}, see above. \item New \code{is.mpfr(x)} function; simple, with fast pre-test. \item In \code{pbetaI(q, ..)}, when \code{q} is a bigrational, i.e., of class \code{"bigq"} (package \CRANpkg{gmp}), the computations are \emph{exact} now, using big rational arithmetic. \item New \code{dnbinom()} function (with corresponding new \code{\link{conflicts}()} with the \pkg{stats} package base \R function), providing an \code{"mpfr"}-number version of the negative binomial probabilities. \item \code{.mpfr_erange_set()} now can set \emph{both} exponent range limits simultaneously, and now returns invisibly \code{TRUE} if the change succeeded. \item New \code{log1mexp()} and \code{log1pexp()}, as "from" \CRANpkg{copula}, notably as the vignette has been here, and authored by me. } } \subsection{BUG FIXES}{ \itemize{ \item \code{mpfr(mm)} (and similar) now works for \code{"bigq"} or \code{"bigz"} matrices, thanks to a report by Jerry Lewis. \item Arithmetic and other \code{"\link{Ops}"} between \code{"mpfr"} and \code{"bigq"} aka bigrational numbers, now use the \dQuote{inherent} precision of the bigrational. \item \code{chooseMpfr(a, n)} and similar now \dQuote{work} when \code{n} is of length zero \emph{and} when an experimental version of \code{stopifnot(*, allow.logical0=FALSE)} is used. \item Our \code{cbind()} and \code{rbind()} methods with \code{signature = "mNumber"} now keep and construct column and row names as the corresponding base functions, obeying \code{deparse.level}. \item Fixed "not-yet"-as-cran \file{NOTE} \emph{Undeclared packages \pkg{dfoptim}, \pkg{pracma} in Rd xrefs}. } } } \section{Changes in version 0.8-1 [2020-01-14, r323]}{ \subsection{BUG FIXES}{ \itemize{ \item Provide dummy C function in the case MPFR library is older than 3.2.0, thanks to Brian Ripley. Should work around check \code{NOTE}s. } } } \section{Changes in version 0.8-0 [2019-12-05, r321]}{ \subsection{USER-VISIBLE CHANGES}{ \itemize{ \item Formatting incl \code{print()}ing by default uses a \code{"+"} after the exponential character (\code{"e"} by default). } } \subsection{NEW FEATURES}{ \itemize{ \item Provide new low-level utilities \code{.mpfr_formatinfo()}, \code{.mpfr2exp()}, and \code{.mpfr_erange_is_int()}. \item Renamed low-level utility functions to use \code{_} instead of \code{.} keeping initial \code{"."}, e.g., \code{.mpfr.gmp.numbbits()} to \code{.mpfr_gmp_numbbits()}. \item \code{formatMpfr()} gets a new optional \code{decimal.plus = TRUE} which adds a \code{"+"} before positive exponents when in exponential (aka \dQuote{scientific}) representation. The \code{mpfr} and \code{mpfrArray} \code{print()} methods get a corresponding \code{decimal.plus} argument with a default that can be set by \code{options(Rmpfr.print.decimal.plus = *)} to allow strict back compatibility where needed. \item For MPFR (C library) version >= 3.2.0 (not by default in Fedora 30!), provide the \emph{incomplete} gamma function \code{igamma(a,x)} which is closely related to \code{pgamma(x,a)}, see help page.% and DO % provide an MPFR pgamma() version, too % ==> then even MPFR pchisq() with *non*centrality maybe! \item Now also export S3 method of \code{unique()} for \code{"mpfr"}, such that \pkg{base} \code{factor()} \dQuote{works}.% -> ../man/mpfr-class.Rd } } \subsection{BUG FIXES}{ \itemize{ \item \code{formatMpfr()} and hence all \code{print()}ing suffered from an integer overflow bug with very large (base 2) exponents. \item \code{.mpfr2str(x, *)} is no longer dependent on the \emph{order} of the elements in \code{x}; consequently \code{format()} and \code{print()} may use less digits in case the precision decreases along \code{x}. \item adapt to new C compiler default behavior \code{-fno-common}, using \code{extern #include } in most \file{*.c} files. } } } \section{Changes in version 0.7-3 [2019-08-06, r305]}{ \subsection{USER-VISIBLE CHANGES}{ \itemize{ \item Decreased the default for \code{max.digits} to 999. } } \subsection{NEW FEATURES}{ \itemize{ \item Provide \code{dgamma(x, shape)} version, e.g., for small shape parameter where most of the mass is on very small \code{x} not representable as double precision numbers. \item Low-level formatting function \code{.mpfr2str()} --- called by \code{format()} and hence \code{print()} methods for \code{"mpfr"} objects --- now finally obeys its \code{maybe.full} argument when it is \code{FALSE}, internally in C's \code{mpfr2str()}. } } \subsection{BUG FIXES}{ \itemize{ \item \code{pnorm(, log.p=TRUE)} no longer underflows much too early, thanks to reports by Jerry Lewis. \item \code{print.mpfrArray()} now also uses a finite \code{max.digits} default, preventing, e.g., \code{cbind(x, y)} to use too many digits. } } } \section{Changes in version 0.7-2 [2019-01-18, r299]}{ \subsection{BUG FIXES}{ \itemize{ \item \code{str()} no longer calls \code{formatMpfr(x, digits, *)} with a \code{digits} \emph{vector} of the same length as \code{x} (which never worked correctly). \item \code{seqMpfr(1, length.out=8)} now works correctly. } } \subsection{NEW FEATURES}{ \itemize{ \item \code{unirootR()} gets an option to \emph{not} warn on non-convergence. \item Provide a \code{summary()} method for \code{"mpfr"} numbers closely modeled after \code{summary.default} for numeric. \item \code{mpfr(NULL)} now works, returning \code{mpfr(logical())}. \item a simple \code{sapplyMpfr()} function, showing how to work around the fact that \code{sapply()} does typically not work with \code{"mpfr"} numbers. } } } \section{Changes in version 0.7-1 [2018-07-24, r291]}{ \subsection{BUG FIXES}{ \itemize{ \item \code{formatMpfr()} for large low-precision numbers now uses scientific representation, fixing the bug RMH was reporting March 17 already. \item \code{outer()} is \dQuote{imported} from base, so it behaves as an \pkg{Rmpfr} function which dispatches e.g., when calling \code{\link{tcrossprod}()}. } } } \section{Changes in version 0.7-0 [2018-01-12, r284]}{ \subsection{NEW FEATURES}{ \itemize{ \item \code{.mpfr2list()} and \code{mpfrXport()} gain an option \code{names} (for nicer output). \item \code{formatMpfr()} and the \code{print()} method get a new option \code{max.digits} with default \code{9999} for the print methods, to limit the number of digits printed for high precision numbers. } } \subsection{BUG FIXES}{ \itemize{ \item For non-\dQuote{regular} mpfr numbers, the \code{d} slot in the \code{"mpfr1"} representation is now empty instead of \dQuote{random}. This also eliminates valgrind warnings about uninitialized values in C. } } } \section{Changes in version 0.6-2 [2017-05-29, r264], never on CRAN}{ \subsection{NEW FEATURES}{ \itemize{ \item The S3 classes \code{"Hcharacter"} and \code{"Bcharacter"} resulting from \code{formatHex()} and \code{formatBin()} now \dQuote{inherit from} \code{"character"} formally. \item They also got a \code{`[`} method, so subsetting should work, including for \code{array}s of these. \item The \code{"mpfr"} method of \code{str()} gains option \code{internal}. } } \subsection{BUG FIXES}{ \itemize{ \item when \code{print()}ing mpfr numbers, the result no longer sometimes loses the last digit. \item \code{dnorm()} now works correctly with mpfr numbers; similarly \code{dbinom()} and \code{dpois()} should work in all cases, now. \item in \file{NAMESPACE}, also \code{exportMethods(apply)}, so \pkg{SNscan} works. \item \code{print(formatHex(..))}, \code{formatBin()} and \code{formatDec()} now look better and are more correct; the first two get a new option \code{expAlign} indicating to use the same number of digits for exponents (in \dQuote{scientific} cases). Notably, \code{mpfr(formatBin(mpx))} works for more \code{mpx} objects (of class \code{"mpfr"}). \item \code{format(mpfr(3,7), digits = 1, base = 2)} no longer crashes (from inside MPFR). \item \code{formatDec(mpfr(NA, 7))} now works. \item For non-\dQuote{regular} mpfr numbers, the \code{d} slot in the \code{"mpfr1"} representation is now empty instead of \dQuote{random}. This also eliminates valgrind warnings about uninitialized values in C. } } } \section{Changes in version 0.6-1 [2016-11-15, r249]}{ \subsection{NEW FEATURES}{ \itemize{ \item \code{head()} and \code{tail()} methods for \code{"mpfrMatrix"}. } } \subsection{BUG FIXES}{ \itemize{ \item C-level \code{mpfr2str()} no longer calls S_realloc() with wrong "old size" (thanks to Bill Dunlap). \item \code{c()} now also works when its result is a length-0 \code{"mpfr"} object. } } } \section{Changes in version 0.6-0 [2015-12-04, r237]}{ \subsection{NEW FEATURES}{ \itemize{ \item \code{mpfr()} now is S3 generic with several methods, notably a \code{"mpfr"} method allowing to change precision or rounding mode. \item \code{mpfr()}, \code{formatMpfr()}, etc, now work with bases from 2 to 62 (using digits, upper and lower case ASCII letters, \code{62 == 10 + 2*26} characters), as this has been in MPFR since version 3.0.0 (see \code{\link{mpfrVersion}}), which is hence (implicitly) required for \code{base} greater than 36. \item \code{formatMpfr()} gets a new argument \code{base = 10} and can be used to produce in other bases, notably binary (\code{base = 2}) or hexadecimal (\code{base = 16}). \item \code{str(, ....)} is now based on \code{formatMpfr()} and nicely shows numbers also out of the double precision range. Further, it now chooses a smart default for optional argument \code{vec.len}. \item \code{matrix(mp, ..)} now also works when \code{mp} is of class \code{"mpfr"}. \item new matrix \code{norm()} for several \code{kind}s. \item new functions \code{formatHex()} and \code{formatBin()} thanks to Rich Heiberger. \item \code{mpfr(x)} also works as \emph{inverse} of \code{formatBin} and \code{formatHex}. \item \code{roundMpfr()} and mathematical functions such as \code{jn}, or \code{chooseMpfr()} get new optional argument \code{rnd.mode} passed to the corresponding MPFR function. \item \code{median(x)}, \code{mean(x, trim)} for \code{trim > 0} now work fine for \code{"mpfr"} x, and \code{quantile(x, *)} no longer needs \code{names=FALSE} to avoid a warning. } } \subsection{BUG FIXES}{ \itemize{ \item \code{pnorm(.)}, \code{j0()} and similar special functions now preserve \code{mpfrMatrix} and \code{mpfrArray} classes. \item similarly, \code{is.finite()} etc keep the \code{dim()}ensionality for \code{"mpfrArray"} arguments. \item \code{mpfr("0xabc", base=16)} and \code{mpfr("0b101", base=2)} and corresponding \code{getPrec()} now give the correct precBits instead of too many. \item \code{str(<0-length mpfr>)} now works correctly. } } } \section{Changes in version 0.5-7 [2014-11-27, r205]}{ \subsection{NEW FEATURES}{ \itemize{ \item . } } \subsection{BUG FIXES}{ \itemize{ \item \code{as.integer()} now rounds \dQuote{to zero} as for regular \R numbers (it accidentally did round \dQuote{to nearest} previously). } } } \section{Changes in version 0.5-6 [2014-09-05, r203]}{ \subsection{NEW FEATURES}{ \itemize{ \item experimental \code{mpfrImport()}, \code{mpfrXport()} utilities -- as we found cases, where save() \code{"mpfr"} objects were \emph{not} portable between different platforms. \item \code{as(*,"mpfr")} now also supports rounding mode \code{"A"} (\dQuote{\bold{A}way from zero}). \item Several hidden low level utilities also get a \code{rnd.mode} option. } } \subsection{BUG FIXES}{ \itemize{ \item . } } } \section{Changes in version 0.5-5 [2014-06-19, r190]}{ \subsection{NEW FEATURES}{ \itemize{ \item The result of \code{integrateR()} now prints even if a warning happened. \item \code{pbetaI(x, a,b)}, the arbitrarily accurate \code{pbeta()} computation for \emph{integer} \eqn{a} and \eqn{b}, now works for larger \eqn{(a,b)}. \item Newly providing \code{mpfr}-versions of \code{dbinom()}, \code{dpois()}, and \code{dnorm()}. \item New utility functions \code{mpfr_default_prec()}, \code{.mpfr.minPrec()}, etc, to get, check, set default exponent ranges and precision. \item New \code{sinpi()}, \code{cospi()} etc, notably for \R >= 3.0.1. } } %% \subsection{BUG FIXES}{ %% \itemize{ %% \item . %% } %% } } \section{Changes in version 0.5-4 [2013-10-22, r173]}{ \subsection{NEW FEATURES}{ \itemize{ \item . } } \subsection{BUG FIXES}{ \itemize{ \item . } } } %% The first CRAN release \section{Changes in version 0.1-5 [2009-08-06]}{ \subsection{NEW FEATURES}{ \itemize{ \item First CRAN release on 'Publication:' 2009-08-14 20:24:02 \item new \code{pmin()} and \code{pmax()}, improving \code{seqMpfr()}. \item new \code{"Math"} and \code{"Math2"} group methods, notably for \code{round()} and \code{signif()}. \item \code{as(. , "integer")} now works (via C \code{mpfr2i}). } } \subsection{More details for old versions up to Feb. 2015:}{ \itemize{ \item See file \file{ChangeLog} %% ../ChangeLog <<< } } } Rmpfr/cleanup0000755000176200001440000000010114552770167012723 0ustar liggesusers#! /bin/sh rm -f src/Makevars # as we create it from Makevars.in Rmpfr/configure0000755000176200001440000040502114552770167013267 0ustar liggesusers#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69. # # # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then _as_can_reexec=no; export _as_can_reexec; # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 as_fn_exit 255 fi # We don't want this to propagate to other subprocesses. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, $0: including any error possibly output before this $0: message. Then install a modern shell, or manually run $0: the script under such a shell if you do have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall # in an infinite loop. This has already happened in practice. _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME= PACKAGE_TARNAME= PACKAGE_VERSION= PACKAGE_STRING= PACKAGE_BUGREPORT= PACKAGE_URL= ac_unique_file="Rmpfr" ac_unique_file="DESCRIPTION" # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif #ifdef HAVE_STRING_H # if !defined STDC_HEADERS && defined HAVE_MEMORY_H # include # endif # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_subst_vars='LTLIBOBJS LIBOBJS PKG_LDFLAGS PKG_CFLAGS PKG_CPPFLAGS EGREP GREP CPP OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir runstatedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking with_mpfr_include with_mpfr_lib ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir= verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' runstatedir='${localstatedir}/run' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -runstatedir | --runstatedir | --runstatedi | --runstated \ | --runstate | --runstat | --runsta | --runst | --runs \ | --run | --ru | --r) ac_prev=runstatedir ;; -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ | --run=* | --ru=* | --r=*) runstatedir=$ac_optarg ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir runstatedir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF \`configure' configures this package to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/PACKAGE] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF _ACEOF fi if test -n "$ac_init_help"; then cat <<\_ACEOF Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-mpfr-include=INCLUDE_PATH the location of MPFR header files --with-mpfr-lib=LIB_PATH the location of MPFR libraries Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to the package provider. _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested configure. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF configure generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists, giving a warning if it cannot be compiled using # the include files in INCLUDES and setting the cache variable VAR # accordingly. ac_fn_c_check_header_mongrel () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if eval \${$3+:} false; then : { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by $as_me, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu # Check whether --with-mpfr-include was given. if test "${with_mpfr_include+set}" = set; then : withval=$with_mpfr_include; mpfr_include_path=$withval fi if test -n "$mpfr_include_path" ; then MPFR_CPPFLAGS="-I${mpfr_include_path}" elif test -n "${mpfr_INCLUDE}" ; then MPFR_CPPFLAGS="-I${mpfr_INCLUDE}" fi # Check whether --with-mpfr-lib was given. if test "${with_mpfr_lib+set}" = set; then : withval=$with_mpfr_lib; mpfr_lib_path=$withval fi if test -n "$mpfr_lib_path" ; then MPFR_LDFLAGS="-L$mpfr_lib_path ${LDFLAGS}" elif test -n "${mpfr_LDFLAGS}" ; then MPFR_LDFLAGS="-L${mpfr_LDFLAGS} ${LDFLAGS}" fi : ${R_HOME=`R RHOME`} if test -z "${R_HOME}"; then echo "could not determine R_HOME" exit 1 fi CC=`"${R_HOME}/bin/R" CMD config CC` CFLAGS=`"${R_HOME}/bin/R" CMD config CFLAGS` CPPFLAGS=`"${R_HOME}/bin/R" CMD config CPPFLAGS` LDFLAGS=`"${R_HOME}/bin/R" CMD config LDFLAGS` ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include struct stat; /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu CPPFLAGS="${CPPFLAGS} ${MPFR_CPPFLAGS}" LDFLAGS="${LDFLAGS} ${MPFR_LDFLAGS}" PKG_CPPFLAGS=$CPPFLAGS PKG_CFLAGS=$CFLAGS PKG_LDFLAGS=$LDFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_GREP" || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 $as_echo "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_EGREP" || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 $as_echo "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "memchr" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "free" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then : : else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if ((' ' & 0x0FF) == 0x020) # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #else # define ISLOWER(c) \ (('a' <= (c) && (c) <= 'i') \ || ('j' <= (c) && (c) <= 'r') \ || ('s' <= (c) && (c) <= 'z')) # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) #endif #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi # On IRIX 5.3, sys/types and inttypes.h are conflicting. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ inttypes.h stdint.h unistd.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done ac_fn_c_check_header_mongrel "$LINENO" "mpfr.h" "ac_cv_header_mpfr_h" "$ac_includes_default" if test "x$ac_cv_header_mpfr_h" = xyes; then : else as_fn_error $? "Header file mpfr.h not found; maybe use --with-mpfr-include=INCLUDE_PATH" "$LINENO" 5 fi ac_fn_c_check_header_mongrel "$LINENO" "gmp.h" "ac_cv_header_gmp_h" "$ac_includes_default" if test "x$ac_cv_header_gmp_h" = xyes; then : else as_fn_error $? "Header file gmp.h not found; maybe use --with-mpfr-include=INCLUDE_PATH" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __gmpz_init in -lgmp" >&5 $as_echo_n "checking for __gmpz_init in -lgmp... " >&6; } if ${ac_cv_lib_gmp___gmpz_init+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lgmp $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char __gmpz_init (); int main () { return __gmpz_init (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_gmp___gmpz_init=yes else ac_cv_lib_gmp___gmpz_init=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gmp___gmpz_init" >&5 $as_echo "$ac_cv_lib_gmp___gmpz_init" >&6; } if test "x$ac_cv_lib_gmp___gmpz_init" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBGMP 1 _ACEOF LIBS="-lgmp $LIBS" else as_fn_error $? "GNU MP not found, see README" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpfr_init in -lmpfr" >&5 $as_echo_n "checking for mpfr_init in -lmpfr... " >&6; } if ${ac_cv_lib_mpfr_mpfr_init+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lmpfr $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char mpfr_init (); int main () { return mpfr_init (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_mpfr_mpfr_init=yes else ac_cv_lib_mpfr_mpfr_init=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpfr_mpfr_init" >&5 $as_echo "$ac_cv_lib_mpfr_mpfr_init" >&6; } if test "x$ac_cv_lib_mpfr_mpfr_init" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBMPFR 1 _ACEOF LIBS="-lmpfr $LIBS" else as_fn_error $? "MPFR Library not found, see README" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpfr_digamma in -lmpfr" >&5 $as_echo_n "checking for mpfr_digamma in -lmpfr... " >&6; } if ${ac_cv_lib_mpfr_mpfr_digamma+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lmpfr $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char mpfr_digamma (); int main () { return mpfr_digamma (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_mpfr_mpfr_digamma=yes else ac_cv_lib_mpfr_mpfr_digamma=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpfr_mpfr_digamma" >&5 $as_echo "$ac_cv_lib_mpfr_mpfr_digamma" >&6; } if test "x$ac_cv_lib_mpfr_mpfr_digamma" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBMPFR 1 _ACEOF LIBS="-lmpfr $LIBS" else as_fn_error $? "MPFR Library must be at least version 3.0.0, see README" "$LINENO" 5 fi ac_config_files="$ac_config_files src/Makevars" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' # Transform confdefs.h into DEFS. # Protect against shell expansion while executing Makefile rules. # Protect against Makefile macro expansion. # # If the first sed substitution is executed (which looks for macros that # take arguments), then branch to the quote section. Otherwise, # look for a macro that doesn't take arguments. ac_script=' :mline /\\$/{ N s,\\\n,, b mline } t clear :clear s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g t quote s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g t quote b any :quote s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g s/\[/\\&/g s/\]/\\&/g s/\$/$$/g H :any ${ g s/^\n// s/\n/ /g p } ' DEFS=`sed -n "$ac_script" confdefs.h` ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by $as_me, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE Configuration files: $config_files Report bugs to the package provider." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ config.status configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --he | --h | --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "src/Makevars") CONFIG_FILES="$CONFIG_FILES src/Makevars" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" eval set X " :F $CONFIG_FILES " shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi