SCM

SCM Repository

[matrix] Annotation of /pkg/R/lmer.R
ViewVC logotype

Annotation of /pkg/R/lmer.R

Parent Directory Parent Directory | Revision Log Revision Log


Revision 571 - (view) (download)
Original Path: branches/trunk-lme4/R/lmer.R

1 : bates 446 contr.SAS <- function(n, contrasts = TRUE)
2 :     {
3 : bates 449 contr.treatment(n, if (is.numeric(n) && length(n) == 1) n else length(n), contrasts)
4 : bates 446 }
5 :    
6 : bates 435 lmerControl <- # Control parameters for lmer
7 :     function(maxIter = 50,
8 :     msMaxIter = 50,
9 :     tolerance = sqrt((.Machine$double.eps)),
10 :     niterEM = 20,
11 :     msTol = sqrt(.Machine$double.eps),
12 :     msVerbose = getOption("verbose"),
13 :     PQLmaxIt = 20,
14 :     .relStep = (.Machine$double.eps)^(1/3),
15 :     EMverbose = getOption("verbose"),
16 :     analyticGradient = TRUE,
17 :     analyticHessian=FALSE)
18 :     {
19 :     list(maxIter = maxIter,
20 :     msMaxIter = msMaxIter,
21 :     tolerance = tolerance,
22 :     niterEM = niterEM,
23 :     msTol = msTol,
24 :     msVerbose = msVerbose,
25 :     PQLmaxIt = PQLmaxIt,
26 :     .relStep = .relStep,
27 :     EMverbose=EMverbose,
28 :     analyticHessian=analyticHessian,
29 :     analyticGradient=analyticGradient)
30 :     }
31 :    
32 :     setMethod("lmer", signature(formula = "formula"),
33 :     function(formula, data,
34 :     method = c("REML", "ML"),
35 :     control = list(),
36 :     subset, weights, na.action, offset,
37 :     model = TRUE, x = FALSE, y = FALSE, ...)
38 :     {
39 :     # match and check parameters
40 : bates 449 REML <- match.arg(method) == "REML"
41 : bates 435 controlvals <- do.call("lmerControl", control)
42 : bates 449 controlvals$REML <- REML
43 : bates 435 if (length(formula) < 3) stop("formula must be a two-sided formula")
44 : bates 449
45 :     mf <- match.call() # create the model frame as frm
46 : bates 435 m <- match(c("data", "subset", "weights", "na.action", "offset"),
47 :     names(mf), 0)
48 :     mf <- mf[c(1, m)]
49 :     mf[[1]] <- as.name("model.frame")
50 :     frame.form <- subbars(formula)
51 :     environment(frame.form) <- environment(formula)
52 :     mf$formula <- frame.form
53 :     mf$drop.unused.levels <- TRUE
54 :     frm <- eval(mf, parent.frame())
55 : bates 449
56 : bates 435 ## grouping factors and model matrices for random effects
57 :     bars <- findbars(formula[[3]])
58 :     random <-
59 :     lapply(bars,
60 :     function(x) list(model.matrix(eval(substitute(~term,
61 :     list(term=x[[2]]))),
62 :     frm),
63 : bates 452 eval(substitute(as.factor(fac)[,drop = TRUE],
64 : bates 435 list(fac = x[[3]])), frm)))
65 :     names(random) <- unlist(lapply(bars, function(x) deparse(x[[3]])))
66 : bates 449
67 : bates 435 ## order factor list by decreasing number of levels
68 : bates 449 nlev <- sapply(random, function(x) length(levels(x[[2]])))
69 : bates 452 if (any(diff(nlev) > 0)) {
70 : bates 449 random <- random[rev(order(nlev))]
71 : bates 435 }
72 : bates 452 fixed.form <- nobars(formula)
73 :     if (!inherits(fixed.form, "formula")) fixed.form <- ~ 1 # default formula
74 : bates 571 Xmat <- model.matrix(fixed.form, frm)
75 : bates 435 mmats <- c(lapply(random, "[[", 1),
76 : bates 571 .fixed = list(cbind(Xmat, .response = model.response(frm))))
77 :     ## FIXME: Use Xfrm and Xmat to get the terms and assign
78 :     ## slots, pass them to lmer_create, then destroy them
79 : bates 435 obj <- .Call("lmer_create", lapply(random, "[[", 2), mmats, PACKAGE = "Matrix")
80 : bates 571 obj@terms <- attr(model.frame(fixed.form, data), "terms")
81 :     obj@assign <- attr(Xmat, "assign")
82 : bates 446 obj@call <- match.call()
83 : bates 449 obj@REML <- REML
84 : bates 571 rm(Xmat)
85 : bates 435 .Call("lmer_initial", obj, PACKAGE="Matrix")
86 :     .Call("lmer_ECMEsteps", obj,
87 :     controlvals$niterEM,
88 :     controlvals$REML,
89 :     controlvals$EMverbose,
90 :     PACKAGE = "Matrix")
91 :     LMEoptimize(obj) <- controlvals
92 : bates 449 #fitted <- .Call("ssclme_fitted", obj, facs, mmats, TRUE, PACKAGE = "Matrix")
93 :     #residuals <- mmats$.Xy[,".response"] - fitted
94 :     #if (as.logical(x)[1]) x <- mmats else x = list()
95 : bates 435 #rm(mmats)
96 :     obj
97 :     })
98 :    
99 : bates 413 setReplaceMethod("LMEoptimize", signature(x="lmer", value="list"),
100 : bates 316 function(x, value)
101 :     {
102 :     if (value$msMaxIter < 1) return(x)
103 :     st <- ccoef(x) # starting values
104 :     nc <- x@nc
105 :     nc <- nc[1:(length(nc) - 2)]
106 :     constr <- unlist(lapply(nc, function(k) 1:((k*(k+1))/2) <= k))
107 :     fn <- function(pars) {
108 :     ccoef(x) <- pars
109 :     deviance(x, REML = value$REML)
110 :     }
111 : bates 380 gr <- if (value$analyticGradient)
112 :     function(pars) {
113 : bates 468 if (!identical(TRUE,all.equal(pars, ccoef(x)))) ccoef(x) <- pars
114 : bates 457 grad <- gradient(x, REML = value$REML, unconst = TRUE)
115 : bates 380 grad[constr] <- -grad[constr]/pars[constr]
116 :     grad
117 :     } else NULL
118 : bates 316 optimRes <- optim(st, fn, gr,
119 :     method = "L-BFGS-B",
120 :     lower = ifelse(constr, 1e-10, -Inf),
121 : bates 362 control = list(maxit = value$msMaxIter,
122 : bates 411 trace = as.integer(value$msVerbose)))
123 : bates 316 if (optimRes$convergence != 0) {
124 :     warning(paste("optim returned message",optimRes$message,"\n"))
125 :     }
126 : bates 411 ccoef(x) <- optimRes$par
127 : bates 316 return(x)
128 :     })
129 :    
130 : bates 413 setMethod("ranef", signature(object = "lmer"),
131 : bates 316 function(object, ...) {
132 : bates 413 .Call("lmer_ranef", object, PACKAGE = "Matrix")
133 : bates 316 })
134 :    
135 : bates 413 setMethod("fixef", signature(object = "lmer"),
136 : bates 316 function(object, ...) {
137 : bates 550 val <- .Call("lmer_fixef", object, PACKAGE = "Matrix")
138 : bates 316 val[-length(val)]
139 :     })
140 :    
141 : bates 413 setMethod("VarCorr", signature(x = "lmer"),
142 : bates 316 function(x, REML = TRUE, useScale = TRUE, ...) {
143 : bates 550 val <- .Call("lmer_variances", x, PACKAGE = "Matrix")
144 : bates 316 for (i in seq(along = val)) {
145 :     dimnames(val[[i]]) = list(x@cnames[[i]], x@cnames[[i]])
146 :     val[[i]] = as(as(val[[i]], "pdmatrix"), "corrmatrix")
147 :     }
148 :     new("VarCorr",
149 : bates 449 scale = .Call("lmer_sigma", x, REML, PACKAGE = "Matrix"),
150 : bates 316 reSumry = val,
151 :     useScale = useScale)
152 :     })
153 :    
154 : bates 413 setMethod("gradient", signature(x = "lmer"),
155 : bates 316 function(x, REML, unconst, ...)
156 : bates 449 .Call("lmer_gradient", x, REML, unconst, PACKAGE = "Matrix"))
157 : bates 316
158 : bates 449 setMethod("summary", signature(object = "lmer"),
159 :     function(object, ...)
160 :     new("summary.lmer", object, useScale = TRUE, showCorrelation = TRUE))
161 : bates 316
162 : bates 449 setMethod("show", signature(object = "lmer"),
163 :     function(object)
164 : bates 550 show(new("summary.lmer", object, useScale = TRUE,
165 :     showCorrelation = FALSE))
166 : bates 449 )
167 :    
168 :     setMethod("show", "summary.lmer",
169 : bates 316 function(object) {
170 :     fcoef <- fixef(object)
171 : bates 449 useScale <- object@useScale
172 :     corF <- as(as(vcov(object, useScale = useScale), "pdmatrix"),
173 : bates 316 "corrmatrix")
174 :     DF <- getFixDF(object)
175 :     coefs <- cbind(fcoef, corF@stdDev, DF)
176 :     nc <- object@nc
177 :     dimnames(coefs) <-
178 :     list(names(fcoef), c("Estimate", "Std. Error", "DF"))
179 : bates 449 digits <- max(3, getOption("digits") - 2)
180 :     REML <- length(object@REML) > 0 && object@REML[1]
181 :     llik <- logLik(object)
182 :     dev <- object@deviance
183 :    
184 :     rdig <- 5
185 :     cat("Linear mixed-effects model fit by ")
186 :     cat(ifelse(object@REML, "REML\n", "maximum likelihood\n") )
187 :     if (!is.null(object@call$formula)) {
188 :     cat("Formula:", deparse(object@call$formula),"\n")
189 :     }
190 :     if (!is.null(object@call$data)) {
191 :     cat(" Data:", deparse(object@call$data), "\n")
192 :     }
193 :     if (!is.null(object@call$subset)) {
194 :     cat(" Subset:",
195 :     deparse(asOneSidedFormula(object@call$subset)[[2]]),"\n")
196 :     }
197 :     print(data.frame(AIC = AIC(llik), BIC = BIC(llik),
198 :     logLik = c(llik),
199 :     MLdeviance = dev["ML"],
200 :     REMLdeviance = dev["REML"],
201 :     row.names = ""))
202 :     cat("Random effects:\n")
203 :     show(VarCorr(object))
204 :     ngrps <- lapply(object@flist, function(x) length(levels(x)))
205 :     cat(sprintf("# of obs: %d, groups: ", object@nc[length(object@nc)]))
206 :     cat(paste(paste(names(ngrps), ngrps, sep = ", "), collapse = "; "))
207 :     cat("\n")
208 :     if (!useScale)
209 :     cat("\nEstimated scale (compare to 1) ",
210 :     .Call("lmer_sigma", object, object@REML, PACKAGE = "Matrix"),
211 :     "\n")
212 :     if (nrow(coefs) > 0) {
213 :     if (useScale) {
214 :     stat <- coefs[,1]/coefs[,2]
215 :     pval <- 2*pt(abs(stat), coefs[,3], lower = FALSE)
216 :     nms <- colnames(coefs)
217 :     coefs <- cbind(coefs, stat, pval)
218 :     colnames(coefs) <- c(nms, "t value", "Pr(>|t|)")
219 :     } else {
220 :     coefs <- coefs[, 1:2, drop = FALSE]
221 :     stat <- coefs[,1]/coefs[,2]
222 :     pval <- 2*pnorm(abs(stat), lower = FALSE)
223 :     nms <- colnames(coefs)
224 :     coefs <- cbind(coefs, stat, pval)
225 :     colnames(coefs) <- c(nms, "z value", "Pr(>|z|)")
226 :     }
227 :     cat("\nFixed effects:\n")
228 :     printCoefmat(coefs, tst.ind = 4, zap.ind = 3)
229 :     if (length(object@showCorrelation) > 0 && object@showCorrelation[1]) {
230 :     rn <- rownames(coefs)
231 :     dimnames(corF) <- list(
232 :     abbreviate(rn, minlen=11),
233 :     abbreviate(rn, minlen=6))
234 :     if (!is.null(corF)) {
235 :     p <- NCOL(corF)
236 :     if (p > 1) {
237 :     cat("\nCorrelation of Fixed Effects:\n")
238 :     corF <- format(round(corF, 3), nsmall = 3)
239 :     corF[!lower.tri(corF)] <- ""
240 :     print(corF[-1, -p, drop=FALSE], quote = FALSE)
241 :     }
242 :     }
243 :     }
244 :     }
245 :     invisible(object)
246 : bates 316 })
247 :    
248 :     ## calculates degrees of freedom for fixed effects Wald tests
249 :     ## This is a placeholder. The answers are generally wrong. It will
250 :     ## be very tricky to decide what a 'right' answer should be with
251 :     ## crossed random effects.
252 :    
253 : bates 413 setMethod("getFixDF", signature(object="lmer"),
254 : bates 316 function(object, ...)
255 :     {
256 :     nc <- object@nc[-seq(along = object@Omega)]
257 :     p <- nc[1] - 1
258 :     n <- nc[2]
259 :     rep(n-p, p)
260 :     })
261 :    
262 : bates 446 setMethod("logLik", signature(object="lmer"),
263 :     function(object, REML = object@REML, ...) {
264 :     val <- -deviance(object, REML = REML)/2
265 :     nc <- object@nc[-seq(a = object@Omega)]
266 :     attr(val, "nall") <- attr(val, "nobs") <- nc[2]
267 :     attr(val, "df") <- nc[1] + length(coef(object))
268 :     attr(val, "REML") <- REML
269 :     class(val) <- "logLik"
270 :     val
271 :     })
272 :    
273 :     setMethod("anova", signature(object = "lmer"),
274 :     function(object, ...)
275 :     {
276 :     mCall <- match.call(expand.dots = TRUE)
277 :     dots <- list(...)
278 :     modp <- logical(0)
279 :     if (length(dots))
280 :     modp <- sapply(dots, inherits, "lmer") | sapply(dots, inherits, "lm")
281 :     if (any(modp)) { # multiple models - form table
282 :     opts <- dots[!modp]
283 :     mods <- c(list(object), dots[modp])
284 :     names(mods) <- sapply(as.list(mCall)[c(FALSE, TRUE, modp)], as.character)
285 :     mods <- mods[order(sapply(lapply(mods, logLik, REML = FALSE), attr, "df"))]
286 :     calls <- lapply(mods, slot, "call")
287 :     data <- lapply(calls, "[[", "data")
288 :     if (any(data != data[[1]])) stop("all models must be fit to the same data object")
289 :     header <- paste("Data:", data[[1]])
290 :     subset <- lapply(calls, "[[", "subset")
291 :     if (any(subset != subset[[1]])) stop("all models must use the same subset")
292 :     if (!is.null(subset[[1]]))
293 :     header <-
294 :     c(header, paste("Subset", deparse(subset[[1]]), sep = ": "))
295 :     llks <- lapply(mods, logLik, REML = FALSE)
296 :     Df <- sapply(llks, attr, "df")
297 :     llk <- unlist(llks)
298 :     chisq <- 2 * pmax(0, c(NA, diff(llk)))
299 :     dfChisq <- c(NA, diff(Df))
300 :     val <- data.frame(Df = Df,
301 :     AIC = sapply(llks, AIC),
302 :     BIC = sapply(llks, BIC),
303 :     logLik = llk,
304 :     "Chisq" = chisq,
305 :     "Chi Df" = dfChisq,
306 :     "Pr(>Chisq)" = pchisq(chisq, dfChisq, lower = FALSE),
307 :     check.names = FALSE)
308 :     class(val) <- c("anova", class(val))
309 :     attr(val, "heading") <-
310 :     c(header, "", "Models:",
311 :     paste(names(mods),
312 :     unlist(lapply(lapply(calls, "[[", "formula"), deparse)),
313 :     sep = ": "),"")
314 :     return(val)
315 :     } else {
316 : bates 571 foo <- object
317 :     foo@status["factored"] <- FALSE
318 :     .Call("lmer_factor", foo, PACKAGE="Matrix")
319 :     dfr <- getFixDF(foo)
320 :     rcol <- ncol(foo@RXX)
321 :     ss <- foo@RXX[ , rcol]^2
322 :     ssr <- ss[[rcol]]
323 :     ss <- ss[seq(along = dfr)]
324 :     names(ss) <- object@cnames[[".fixed"]][seq(along = dfr)]
325 :     asgn <- foo@assign
326 :     terms <- foo@terms
327 :     nmeffects <- attr(terms, "term.labels")
328 :     if ("(Intercept)" %in% names(ss))
329 :     nmeffects <- c("(Intercept)", nmeffects)
330 :     ss <- unlist(lapply(split(ss, asgn), sum))
331 :     df <- unlist(lapply(split(asgn, asgn), length))
332 :     dfr <- unlist(lapply(split(dfr, asgn), function(x) x[1]))
333 :     ms <- ss/df
334 :     f <- ms/(ssr/dfr)
335 :     P <- pf(f, df, dfr, lower.tail = FALSE)
336 :     table <- data.frame(df, ss, ms, dfr, f, P)
337 :     dimnames(table) <-
338 :     list(nmeffects,
339 :     c("Df", "Sum Sq", "Mean Sq", "Denom", "F value", "Pr(>F)"))
340 :     if ("(Intercept)" %in% nmeffects) table <- table[-1,]
341 :     attr(table, "heading") <- "Analysis of Variance Table"
342 :     class(table) <- c("anova", "data.frame")
343 :     table
344 : bates 446 }
345 : bates 316 })
346 : bates 446
347 :     setMethod("update", signature(object = "lmer"),
348 :     function(object, formula., ..., evaluate = TRUE)
349 :     {
350 :     call <- object@call
351 :     if (is.null(call))
352 :     stop("need an object with call component")
353 :     extras <- match.call(expand.dots = FALSE)$...
354 :     if (!missing(formula.))
355 :     call$formula <- update.formula(formula(object), formula.)
356 :     if (length(extras) > 0) {
357 :     existing <- !is.na(match(names(extras), names(call)))
358 :     for (a in names(extras)[existing]) call[[a]] <- extras[[a]]
359 :     if (any(!existing)) {
360 :     call <- c(as.list(call), extras[!existing])
361 :     call <- as.call(call)
362 :     }
363 :     }
364 :     if (evaluate)
365 :     eval(call, parent.frame())
366 :     else call
367 :     })
368 :    
369 :    
370 :     setMethod("confint", signature(object = "lmer"),
371 :     function (object, parm, level = 0.95, ...)
372 :     {
373 :     cf <- fixef(object)
374 :     pnames <- names(cf)
375 :     if (missing(parm))
376 :     parm <- seq(along = pnames)
377 :     else if (is.character(parm))
378 :     parm <- match(parm, pnames, nomatch = 0)
379 :     a <- (1 - level)/2
380 :     a <- c(a, 1 - a)
381 :     pct <- paste(round(100 * a, 1), "%")
382 :     ci <- array(NA, dim = c(length(parm), 2),
383 :     dimnames = list(pnames[parm], pct))
384 :     ses <- sqrt(diag(vcov(object)))[parm]
385 : bates 449 ci[] <- cf[parm] + ses * t(outer(a, getFixDF(object)[parm], qt))
386 : bates 446 ci
387 :     })
388 :    
389 : bates 449 setReplaceMethod("coef", signature(object = "lmer", value = "numeric"),
390 :     function(object, unconst = FALSE, ..., value)
391 :     .Call("lmer_coefGets", object, as.double(value),
392 :     unconst, PACKAGE = "Matrix"))
393 : bates 446
394 : bates 449 setMethod("coef", signature(object = "lmer"),
395 :     function(object, unconst = FALSE, ...) {
396 :     .Call("lmer_coef", object, unconst, PACKAGE = "Matrix")
397 :     })
398 : bates 446
399 : bates 449 setMethod("deviance", "lmer",
400 :     function(object, REML = NULL, ...) {
401 :     .Call("lmer_factor", object, PACKAGE = "Matrix")
402 :     if (is.null(REML))
403 :     REML <- if (length(oR <- object@REML)) oR else FALSE
404 :     object@deviance[[ifelse(REML, "REML", "ML")]]
405 :     })
406 : bates 446
407 : bates 449 setMethod("chol", signature(x = "lmer"),
408 :     function(x, pivot = FALSE, LINPACK = pivot) {
409 :     x@status["factored"] <- FALSE # force a decomposition
410 :     .Call("lmer_factor", x, PACKAGE = "Matrix")
411 :     })
412 :    
413 :     setMethod("solve", signature(a = "lmer", b = "missing"),
414 :     function(a, b, ...)
415 : bates 562 .Call("lmer_invert", a, PACKAGE = "Matrix")
416 : bates 449 )
417 :    
418 :     setMethod("formula", "lmer", function(x, ...) x@call$formula)
419 :    
420 :     setMethod("vcov", signature(object = "lmer"),
421 :     function(object, REML = object@REML, useScale = TRUE,...) {
422 :     sc <- .Call("lmer_sigma", object, REML, PACKAGE = "Matrix")
423 :     rr <- object@RXX
424 :     nms <- object@cnames[[".fixed"]]
425 :     dimnames(rr) <- list(nms, nms)
426 :     nr <- nrow(rr)
427 :     rr <- rr[-nr, -nr, drop = FALSE]
428 :     rr <- rr %*% t(rr)
429 :     if (useScale) {
430 :     rr = sc^2 * rr
431 :     }
432 :     rr
433 :     })
434 :    
435 : bates 545 Lind <- function(i,j) {
436 :     if (i < j) stop(paste("Index i=", i,"must be >= index j=", j))
437 :     ((i - 1) * i)/2 + j
438 :     }
439 :    
440 :     Dhalf <- function(from) {
441 :     D <- from@D
442 :     nf <- length(D)
443 :     Gp <- from@Gp
444 :     res <- array(0, rep(Gp[nf+1],2))
445 :     for (i in 1:nf) {
446 :     DD <- D[[i]]
447 :     dd <- dim(DD)
448 :     for (k in 1:dd[3]) {
449 :     mm <- array(DD[ , , k], dd[1:2])
450 :     base <- Gp[i] + (k - 1)*dd[1]
451 :     res[cbind(c(base + row(mm)), c(base + col(mm)))] <- c(mm)
452 :     }
453 :     }
454 :     res
455 :     }
456 : bates 550
457 :     ## Extract the L matrix
458 :     setAs("lmer", "dtTMatrix",
459 :     function(from)
460 :     {
461 :     ## force a refactorization if the factors have been inverted
462 :     if (from@status["inverted"]) from@status["factored"] <- FALSE
463 :     .Call("lmer_factor", from, PACKAGE = "Matrix")
464 :     L <- lapply(from@L, as, "dgTMatrix")
465 :     nf <- length(from@D)
466 :     Gp <- from@Gp
467 :     nL <- Gp[nf + 1]
468 : bates 562 Li <- integer(0)
469 :     Lj <- integer(0)
470 :     Lx <- double(0)
471 : bates 550 for (i in 1:nf) {
472 :     for (j in 1:i) {
473 :     Lij <- L[[Lind(i, j)]]
474 : bates 562 Li <- c(Li, Lij@i + Gp[i])
475 :     Lj <- c(Lj, Lij@j + Gp[j])
476 :     Lx <- c(Lx, Lij@x)
477 : bates 550 }
478 :     }
479 : bates 562 new("dtTMatrix", Dim = as.integer(c(nL, nL)), i = Li, j = Lj, x = Lx,
480 : bates 550 uplo = "L", diag = "U")
481 :     })
482 : bates 562
483 :     ## Extract the ZZX matrix
484 :     setAs("lmer", "dsTMatrix",
485 :     function(from)
486 :     {
487 :     .Call("lmer_inflate", from, PACKAGE = "Matrix")
488 :     ZZpO <- lapply(from@ZZpO, as, "dgTMatrix")
489 :     ZZ <- lapply(from@ZtZ, as, "dgTMatrix")
490 :     nf <- length(ZZpO)
491 :     Gp <- from@Gp
492 :     nZ <- Gp[nf + 1]
493 :     Zi <- integer(0)
494 :     Zj <- integer(0)
495 :     Zx <- double(0)
496 :     for (i in 1:nf) {
497 :     ZZpOi <- ZZpO[[i]]
498 :     Zi <- c(Zi, ZZpOi@i + Gp[i])
499 :     Zj <- c(Zj, ZZpOi@j + Gp[i])
500 :     Zx <- c(Zx, ZZpOi@x)
501 :     if (i > 1) {
502 :     for (j in 1:(i-1)) {
503 :     ZZij <- ZZ[[Lind(i, j)]]
504 :     ## off-diagonal blocks are transposed
505 :     Zi <- c(Zi, ZZij@j + Gp[j])
506 :     Zj <- c(Zj, ZZij@i + Gp[i])
507 :     Zx <- c(Zx, ZZij@x)
508 :     }
509 :     }
510 :     }
511 :     new("dsTMatrix", Dim = as.integer(c(nZ, nZ)), i = Zi, j = Zj, x = Zx,
512 :     uplo = "U")
513 :     })

root@r-forge.r-project.org
ViewVC Help
Powered by ViewVC 1.0.0  
Thanks to:
Vienna University of Economics and Business Powered By FusionForge