CRAN Package Check Results for Package spam

Last updated on 2015-07-02 11:48:43.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.0-1 7.34 71.50 78.84 NOTE
r-devel-linux-x86_64-debian-gcc 1.0-1 6.80 68.26 75.07 NOTE
r-devel-linux-x86_64-fedora-clang 1.0-1 153.30 NOTE
r-devel-linux-x86_64-fedora-gcc 1.0-1 146.63 NOTE
r-devel-osx-x86_64-clang 1.0-1 123.79 NOTE
r-devel-windows-ix86+x86_64 1.0-1 25.00 153.00 178.00 NOTE
r-patched-linux-x86_64 1.0-1 6.67 69.58 76.25 NOTE
r-patched-solaris-sparc 1.0-1 943.30 NOTE
r-patched-solaris-x86 1.0-1 198.20 NOTE
r-release-linux-x86_64 1.0-1 6.73 70.16 76.89 NOTE
r-release-osx-x86_64-mavericks 1.0-1 NOTE
r-release-windows-ix86+x86_64 1.0-1 27.00 167.00 194.00 NOTE
r-oldrel-windows-ix86+x86_64 1.0-1 34.00 296.00 330.00 NOTE

Check Details

Version: 1.0-1
Check: dependencies in R code
Result: NOTE
    'library' or 'require' call to ‘Matrix’ in package code.
     Please use :: or requireNamespace() instead.
     See section 'Suggested packages' in the 'Writing R Extensions' manual.
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-osx-x86_64-clang, r-devel-windows-ix86+x86_64, r-patched-linux-x86_64, r-patched-solaris-sparc, r-patched-solaris-x86, r-release-linux-x86_64, r-release-osx-x86_64-mavericks, r-release-windows-ix86+x86_64, r-oldrel-windows-ix86+x86_64

Version: 1.0-1
Check: S3 generic/method consistency
Result: NOTE
    Found the following apparent S3 methods exported but not registered:
     all.equal.spam all.equal.spam as.matrix.csr.spam as.matrix.spam
     as.vector.spam chol.spam determinant.spam
     determinant.spam.chol.NgPeyton diff.spam dim<-.spam head.spam
     image.spam isSymmetric.spam plot.spam print.spam
     print.spam.chol.NgPeyton solve.spam subset.rows.spam subset.spam
     summary.spam summary.spam.chol.NgPeyton t.spam tail.spam
     update.spam.chol.NgPeyton
    See section ‘Registering S3 methods’ in the ‘Writing R Extensions’
    manual.
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-osx-x86_64-clang, r-patched-linux-x86_64, r-patched-solaris-sparc, r-patched-solaris-x86, r-release-linux-x86_64

Version: 1.0-1
Check: foreign function calls
Result: NOTE
    Calls with DUP:
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amuxmat", nrow, yrow, ycol, as.double(y), y = vector("double",
     nrow * ycol), as.double(x@entries), x@colindices, x@rowpointers,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("transpose", n = dimx[1], m = dimx[2], a = as.double(x@entries),
     ja = x@colindices, ia = x@rowpointers, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     dimx[2] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = dimx[1], entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = nrow, entries = as.double(x@entries),
     colindices = xcolindices, rowpointers = x@rowpointers, res = vector("double",
     nrow * nrow), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("transpose", n = x@Dim[2], m = x@Dim[1], a = as.double(x@x),
     ja = x@i + 1L, ia = x@p + 1L, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     x@Dim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = dimx[1], ncol = dimx[2], x = as.double(x),
     dimx[1], entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", dimx[1] + 1), eps = as.double(eps),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("subass", nrow, ncol, as.double(x@entries), x@colindices,
     x@rowpointers, b = as.vector(value[ord], "double"), bj = as.vector(rw[,
     2], "integer"), bi = bia, entries = vector("double",
     nzmax), colindices = vector("integer", nzmax), rowpointers = vector("integer",
     nrow + 1), nzmax = nzmax, NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("backsolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotbacksolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@invpivot, r@pivot,
     r@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamback", m = m, p, sol = vector("double", m * p),
     x = as.vector(x, "double"), al = as.double(r@entries), jal = r@colindices,
     ial = r@rowpointers, DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("getbwd", A@dimension[1], A@entries, A@colindices, A@rowpointers,
     low = integer(1), upp = integer(1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("cbind", Xdim[2], Xdim[1], Ydim[2], XYlen, args[[1]]@entries,
     args[[1]]@colindices, args[[1]]@rowpointers, args[[2]]@entries,
     args[[2]]@colindices, args[[2]]@rowpointers, entries = vector("double",
     XYlen), colindices = vector("integer", XYlen), rowpointers = vector("integer",
     Xdim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cholstepwise", nrow = nrow, nnzA = nnzA, d = as.double(x@entries),
     jd = x@colindices, id = x@rowpointers, doperm = doperm, invp = vector("integer",
     nrow), perm = pivot, nnzlindx = vector("integer", 1),
     nnzcolindices = as.integer(nnzcolindices), lindx = vector("integer",
     nnzcolindices), xlindx = vector("integer", nrow + 1),
     nsuper = vector("integer", 1), nnzR = as.integer(nnzR), lnz = vector("double",
     nnzR), xlnz = vector("integer", nrow + 1), snode = vector("integer",
     nrow), xsuper = vector("integer", nrow + 1), cachesize = as.integer(cache),
     ierr = 0L, NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cholstepwise", nrow = nrow, nnzA = as.integer(x@rowpointers[nrow +
     1] - 1), d = as.double(x@entries), jd = x@colindices, id = x@rowpointers,
     doperm = doperm, invp = vector("integer", nrow), perm = pivot,
     nnzlindx = vector("integer", 1), nnzcolindices = as.integer(nnzcolindices),
     lindx = vector("integer", nnzcolindices), xlindx = vector("integer",
     nrow + 1), nsuper = vector("integer", 1), nnzR = as.integer(nnzR),
     lnz = vector("double", nnzR), xlnz = vector("integer", nrow +
     1), snode = vector("integer", nrow), xsuper = vector("integer",
     nrow + 1), cachesize = as.integer(cache), ierr = 0L,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("backsolves", m = nrow, as.integer(length(x@supernodes) -
     1), nrow, x@colindices, x@colpointers, as.double(x@entries),
     x@rowpointers, x@invpivot, x@pivot, x@supernodes, vector("double",
     nrow), sol = vector("double", nrow * nrow), y, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("circulant", n, len, as.double(x), as.integer(ind),
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", n + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("colmeans", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], x@dimension[2],
     as.logical(.Spam$structurebased), cm = vector("double", x@dimension[2]),
     vector("integer", x@dimension[2]), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("colsums", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], cs = vector("double",
     x@dimension[2]), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("notzero", x@colindices, x@rowpointers, nrow, ncol,
     as.integer(nnz), as.integer(nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cholstepwise", nrow = nrow, nnzA = as.integer(x@rowpointers[nrow +
     1] - 1), d = as.double(x@entries), jd = x@colindices, id = x@rowpointers,
     doperm = doperm, invp = vector("integer", nrow), perm = pivot,
     nnzlindx = vector("integer", 1), nnzcolindices = as.integer(nnzcolindices),
     lindx = vector("integer", nnzcolindices), xlindx = vector("integer",
     nrow + 1), nsuper = vector("integer", 1), nnzR = as.integer(nnzR),
     lnz = vector("double", nnzR), xlnz = vector("integer", nrow +
     1), snode = vector("integer", nrow), xsuper = vector("integer",
     nrow + 1), cachesize = as.integer(cache), ierr = 0L,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cholstepwise", nrow = nrow, nnzA = as.integer(x@rowpointers[nrow +
     1] - 1), d = as.double(x@entries), jd = x@colindices, id = x@rowpointers,
     doperm = doperm, invp = vector("integer", nrow), perm = pivot,
     nnzlindx = vector("integer", 1), nnzcolindices = as.integer(nnzcolindices),
     lindx = vector("integer", nnzcolindices), xlindx = vector("integer",
     nrow + 1), nsuper = vector("integer", 1), nnzR = as.integer(nnzR),
     lnz = vector("double", nnzR), xlnz = vector("integer", nrow +
     1), snode = vector("integer", nrow), xsuper = vector("integer",
     nrow + 1), cachesize = as.integer(cache), ierr = 0L,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getdiag", a = as.double(x@entries), colindices = x@colindices,
     rowpointers = x@rowpointers, len = len, diag = vector("double",
     len), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("forwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotforwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@invpivot, l@pivot,
     l@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamforward", m = m, p, sol = vector("double", m *
     p), x = as.vector(x, "double"), al = as.double(l@entries),
     jal = l@colindices, ial = l@rowpointers, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("kroneckermult", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, entries = vector("double",
     kronlen), colindices = vector("integer", kronlen), rowpointers = vector("integer",
     Xdim[1] * Ydim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("kronecker", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, ent1 = vector("double", kronlen),
     ent2 = vector("double", kronlen), colindices = vector("integer",
     kronlen), rowpointers = vector("integer", Xdim[1] * Ydim[1] +
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("closestdist", nd, as.double(x), n1, as.double(y), n2,
     part, as.double(p[1]), method, as.double(abs(delta[1])),
     colindices = vector("integer", nnz), rowpointers = vector("integer",
     n1 + 1), entries = vector("double", nnz), nnz = as.integer(nnz),
     iflag = as.integer(0), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("reducedim", oldra = as.double(x@entries), oldja = x@colindices,
     oldia = x@rowpointers, eps = .Spam$eps, as.integer(min(value[1],
     dimx[1])), as.integer(value[2]), nz = 1L, entries = vector("double",
     length(x@entries)), colindices = vector("integer", length(x@entries)),
     rowpointers = vector("integer", last), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), P, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), Q, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("dperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), P, Q,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("transpose", n = nc, m = nr, a = vals, ja = ind, ia = ptr,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nr + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = nr, ncol = nc, x = x, nr, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     nr + 1), eps = spam.options("eps"), NAOK = TRUE, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("rowmeans", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], x@dimension[2],
     as.logical(.Spam$structurebased), rm = vector("double", x@dimension[1]),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rowsums", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], rs = vector("double",
     x@dimension[1]), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("backsolves", m = nrow, nsuper, p, a@colindices, a@colpointers,
     as.double(a@entries), a@rowpointers, a@invpivot, a@pivot,
     a@supernodes, vector("double", nrow), sol = vector("double",
     nrow * p), as.vector(b, "double"), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran(ifelse(toupper(.Spam$listmethod == "PE"), "triplet3csr",
     "triplet2csr"), nrow = nrow, ncol = ncol, nz = nz, as.double(x[[elenr]]),
     ir, jc, entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), eps,
     NAOK = TRUE, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = dimx[1], ncol = dimx[2], x = as.double(x),
     dimx[1], entries = vector("double", lenx), colindices = vector("integer",
     lenx), rowpointers = vector("integer", dimx[1] + 1),
     eps = as.double(eps), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("aplbdg", nrow, ncol, A@colindices, A@rowpointers, B@colindices,
     B@rowpointers, vector("integer", nrow), nnz = vector("integer",
     1), vector("integer", ncol), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("aplsb1", nrow, ncol, as.double(A@entries), A@colindices,
     A@rowpointers, as.double(s), as.double(B@entries), B@colindices,
     B@rowpointers, entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", nrow + 1), as.integer(nzmax +
     1), ierr = vector("integer", 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("aemub", e1row, e1col, as.double(e1@entries), e1@colindices,
     e1@rowpointers, as.double(e2@entries), e2@colindices, e2@rowpointers,
     entries = vector("double", nnzmax), colindices = vector("integer",
     nnzmax), rowpointers = vector("integer", e1row + 1),
     integer(e1col), double(e1col), as.integer(nnzmax), ierr = vector("integer",
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow, entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow, entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getallelem", nir, as.integer(i), as.integer(j), as.double(x@entries),
     as.integer(x@colindices), as.integer(x@rowpointers), iadd = vector("integer",
     nir), allelem = vector("double", nir), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getlines", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), ni, as.integer(i), newnz = nz,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", ni + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = ni, entries = z$entries, colindices = z$colindices,
     rowpointers = z$rowpointers, res = vector("double", prod(ni,
     ncol)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getallelem", nir, as.integer(ir), as.integer(jr), as.double(x@entries),
     as.integer(x@colindices), as.integer(x@rowpointers), integer(nir),
     allelem = vector("double", nir), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("submat", nrow, job = 1L, i1 = as.integer(rw[1]), i2 = as.integer(rw[nrw]),
     j1 = as.integer(cl[1]), j2 = as.integer(cl[ncl]), as.double(x@entries),
     x@colindices, x@rowpointers, nr = 0L, nc = 0L, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     nrw + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getblock", as.double(x@entries), x@colindices, x@rowpointers,
     nr = nrw, as.integer(rw), nc = ncl, as.integer(cl), nz = nz,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrw + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = z$nr, entries = z$entries[1:nz],
     colindices = z$colindices[1:nz], rowpointers = z$rowpointers[1:(z$nr +
     1)], res = vector("double", prod(z$nr, z$nc)), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("transpose", n = dimx[1], m = dimx[2], a = as.double(x@entries),
     ja = x@colindices, ia = x@rowpointers, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     dimx[2] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("toeplitz", n, len, as.double(fullx), as.integer(ind),
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", n + 1), nnz = as.integer(1),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amuxmat", nrow, yrow, ycol, as.double(y), y = vector("double",
     nrow * ycol), as.double(x@entries), x@colindices, x@rowpointers,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("aemub", e1row, e1col, as.double(e1@entries), e1@colindices,
     e1@rowpointers, as.double(e2@entries), e2@colindices, e2@rowpointers,
     entries = vector("double", nnzmax), colindices = vector("integer",
     nnzmax), rowpointers = vector("integer", e1row + 1),
     integer(e1col), double(e1col), as.integer(nnzmax), ierr = vector("integer",
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = dimx[1], entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = nrow, entries = as.double(x@entries),
     colindices = xcolindices, rowpointers = x@rowpointers, res = vector("double",
     nrow * nrow), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = dimx[1], ncol = dimx[2], x = as.double(x),
     dimx[1], entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", dimx[1] + 1), eps = as.double(eps),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("backsolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotbacksolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@invpivot, r@pivot,
     r@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamback", m = m, p, sol = vector("double", m * p),
     x = as.vector(x, "double"), al = as.double(r@entries), jal = r@colindices,
     ial = r@rowpointers, DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("backsolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotbacksolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@invpivot, r@pivot,
     r@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamback", m = m, p, sol = vector("double", m * p),
     x = as.vector(x, "double"), al = as.double(r@entries), jal = r@colindices,
     ial = r@rowpointers, DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = dimx[1], entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = nrow, entries = as.double(x@entries),
     colindices = xcolindices, rowpointers = x@rowpointers, res = vector("double",
     nrow * nrow), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cbind", Xdim[2], Xdim[1], Ydim[2], XYlen, args[[1]]@entries,
     args[[1]]@colindices, args[[1]]@rowpointers, args[[2]]@entries,
     args[[2]]@colindices, args[[2]]@rowpointers, entries = vector("double",
     XYlen), colindices = vector("integer", XYlen), rowpointers = vector("integer",
     Xdim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("backsolves", m = nrow, as.integer(length(x@supernodes) -
     1), nrow, x@colindices, x@colpointers, as.double(x@entries),
     x@rowpointers, x@invpivot, x@pivot, x@supernodes, vector("double",
     nrow), sol = vector("double", nrow * nrow), y, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("backsolves", m = nrow, as.integer(length(x@supernodes) -
     1), nrow, x@colindices, x@colpointers, as.double(x@entries),
     x@rowpointers, x@invpivot, x@pivot, x@supernodes, vector("double",
     nrow), sol = vector("double", nrow * nrow), y, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("colmeans", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], x@dimension[2],
     as.logical(.Spam$structurebased), cm = vector("double", x@dimension[2]),
     vector("integer", x@dimension[2]), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("colsums", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], cs = vector("double",
     x@dimension[2]), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getdiag", a = as.double(x@entries), colindices = x@colindices,
     rowpointers = x@rowpointers, len = len, diag = vector("double",
     len), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("forwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotforwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@invpivot, l@pivot,
     l@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamforward", m = m, p, sol = vector("double", m *
     p), x = as.vector(x, "double"), al = as.double(l@entries),
     jal = l@colindices, ial = l@rowpointers, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("forwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotforwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@invpivot, l@pivot,
     l@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamforward", m = m, p, sol = vector("double", m *
     p), x = as.vector(x, "double"), al = as.double(l@entries),
     jal = l@colindices, ial = l@rowpointers, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("kroneckermult", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, entries = vector("double",
     kronlen), colindices = vector("integer", kronlen), rowpointers = vector("integer",
     Xdim[1] * Ydim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("kronecker", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, ent1 = vector("double", kronlen),
     ent2 = vector("double", kronlen), colindices = vector("integer",
     kronlen), rowpointers = vector("integer", Xdim[1] * Ydim[1] +
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("kroneckermult", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, entries = vector("double",
     kronlen), colindices = vector("integer", kronlen), rowpointers = vector("integer",
     Xdim[1] * Ydim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("kronecker", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, ent1 = vector("double", kronlen),
     ent2 = vector("double", kronlen), colindices = vector("integer",
     kronlen), rowpointers = vector("integer", Xdim[1] * Ydim[1] +
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("kroneckermult", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, entries = vector("double",
     kronlen), colindices = vector("integer", kronlen), rowpointers = vector("integer",
     Xdim[1] * Ydim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("kronecker", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, ent1 = vector("double", kronlen),
     ent2 = vector("double", kronlen), colindices = vector("integer",
     kronlen), rowpointers = vector("integer", Xdim[1] * Ydim[1] +
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("reducedim", oldra = as.double(x@entries), oldja = x@colindices,
     oldia = x@rowpointers, eps = .Spam$eps, as.integer(min(value[1],
     dimx[1])), as.integer(value[2]), nz = 1L, entries = vector("double",
     length(x@entries)), colindices = vector("integer", length(x@entries)),
     rowpointers = vector("integer", last), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), P, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), Q, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("dperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), P, Q,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rowmeans", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], x@dimension[2],
     as.logical(.Spam$structurebased), rm = vector("double", x@dimension[1]),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rowsums", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], rs = vector("double",
     x@dimension[1]), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran(ifelse(toupper(.Spam$listmethod == "PE"), "triplet3csr",
     "triplet2csr"), nrow = nrow, ncol = ncol, nz = nz, as.double(x[[elenr]]),
     ir, jc, entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), eps,
     NAOK = TRUE, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = dimx[1], ncol = dimx[2], x = as.double(x),
     dimx[1], entries = vector("double", lenx), colindices = vector("integer",
     lenx), rowpointers = vector("integer", dimx[1] + 1),
     eps = as.double(eps), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("transpose", n = dimx[1], m = dimx[2], a = as.double(x@entries),
     ja = x@colindices, ia = x@rowpointers, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     dimx[2] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
    DUP is no longer supported and will be ignored.
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-osx-x86_64-clang, r-devel-windows-ix86+x86_64, r-patched-linux-x86_64, r-patched-solaris-sparc, r-patched-solaris-x86, r-release-linux-x86_64, r-release-osx-x86_64-mavericks, r-release-windows-ix86+x86_64

Version: 1.0-1
Check: R code for possible problems
Result: NOTE
    .spam.diagaddmat: no visible global function definition for ‘new’
    .spam.matmul: no visible global function definition for ‘new’
    .spam.matmul: no visible global function definition for ‘slot<-’
    as.dgCMatrix.spam: no visible global function definition for ‘new’
    as.dgCMatrix.spam: no visible global function definition for ‘slot<-’
    as.dgRMatrix.spam: no visible global function definition for ‘new’
    as.dgRMatrix.spam: no visible global function definition for ‘slot<-’
    as.matrix.csr.spam: no visible global function definition for ‘new’
    as.matrix.csr.spam: no visible global function definition for ‘slot<-’
    as.matrix.spam.chol.NgPeyton: no visible global function definition for
     ‘new’
    as.spam.chol.NgPeyton: no visible global function definition for ‘new’
    as.spam.chol.NgPeyton: no visible global function definition for
     ‘slot<-’
    as.spam.dgCMatrix: no visible global function definition for ‘is’
    as.spam.dgCMatrix: no visible global function definition for ‘new’
    as.spam.dgCMatrix: no visible global function definition for ‘slot<-’
    as.spam.dgRMatrix: no visible global function definition for ‘is’
    as.spam.dgRMatrix: no visible global function definition for ‘new’
    as.spam.dgRMatrix: no visible global function definition for ‘slot<-’
    as.spam.dist: no visible global function definition for ‘new’
    as.spam.dist: no visible global function definition for ‘slot<-’
    as.spam.matrix: no visible global function definition for ‘new’
    as.spam.matrix: no visible global function definition for ‘slot<-’
    as.spam.matrix.csr: no visible global function definition for ‘new’
    as.spam.matrix.csr: no visible global function definition for ‘slot<-’
    as.spam.numeric: no visible global function definition for ‘new’
    as.spam.numeric: no visible global function definition for ‘slot<-’
    as.spam.spam: no visible global function definition for ‘new’
    as.spam.spam: no visible global function definition for ‘slot<-’
    assign.spam: no visible global function definition for ‘new’
    assign.spam: no visible global function definition for ‘slot<-’
    backsolve.spam: no visible global function definition for ‘is’
    cbind.spam: no visible global function definition for ‘new’
    cbind.spam: no visible global function definition for ‘slot<-’
    chol.spam: no visible global function definition for ‘new’
    chol.spam: no visible global function definition for ‘slot<-’
    chol2inv.spam: no visible global function definition for ‘is’
    circulant.spam: no visible global function definition for ‘new’
    circulant.spam: no visible global function definition for ‘slot<-’
    complement.spam: no visible global function definition for ‘new’
    complement.spam: no visible global function definition for ‘slot<-’
    diag.spam: no visible global function definition for ‘new’
    diag.spam: no visible global function definition for ‘slot<-’
    diag.spam<-: no visible global function definition for ‘new’
    diag.spam<-: no visible global function definition for ‘slot<-’
    diag<-.spam: no visible global function definition for ‘new’
    diag<-.spam: no visible global function definition for ‘slot<-’
    display.spam: no visible global function definition for ‘image.default’
    display.spam: no visible global function definition for ‘axis’
    display.spam: no visible global function definition for ‘box’
    forwardsolve.spam: no visible global function definition for ‘is’
    germany.plot: no visible global function definition for ‘par’
    germany.plot: no visible global function definition for ‘polygon’
    germany.plot: no visible global function definition for ‘text’
    grid_zoom: no visible global function definition for ‘runif’
    image.spam: no visible global function definition for ‘heat.colors’
    image.spam: no visible global function definition for ‘image.default’
    image.spam: no visible global function definition for ‘points’
    image.spam: no visible global function definition for ‘box’
    is.spam: no visible global function definition for ‘is’
    kronecker.spam: no visible global function definition for ‘new’
    kronecker.spam: no visible global function definition for ‘slot<-’
    logical_Summary: no visible global function definition for
     ‘callGeneric’
    lower.tri.spam: no visible global function definition for ‘new’
    map.landkreis: no visible global function definition for ‘gray’
    map.landkreis: no visible global function definition for ‘polygon’
    mle: no visible global function definition for ‘optim’
    mle.nomean: no visible global function definition for ‘optim’
    mle.nomean.spam: no visible global function definition for ‘is’
    mle.nomean.spam: no visible global function definition for ‘optim’
    mle.spam: no visible global function definition for ‘is’
    mle.spam: no visible global function definition for ‘optim’
    nearest.dist: no visible global function definition for ‘new’
    nearest.dist: no visible global function definition for ‘slot<-’
    neg2loglikelihood.spam: no visible global function definition for ‘is’
    pad<-.spam: no visible global function definition for ‘new’
    pad<-.spam: no visible global function definition for ‘slot<-’
    permutation.spam: no visible global function definition for ‘new’
    permutation.spam: no visible global function definition for ‘slot<-’
    rbind.spam: no visible global function definition for ‘new’
    read.HB: no visible global function definition for ‘new’
    read.HB: no visible global function definition for ‘slot<-’
    read.MM: no visible global function definition for ‘new’
    read.MM: no visible global function definition for ‘slot<-’
    rmvnorm.canonical: no visible global function definition for ‘is’
    rmvnorm.canonical: no visible global function definition for ‘rnorm’
    rmvnorm.canonical.const: no visible global function definition for ‘is’
    rmvnorm.canonical.const: no visible global function definition for
     ‘rnorm’
    rmvnorm.const: no visible global function definition for ‘is’
    rmvnorm.const: no visible global function definition for ‘rnorm’
    rmvnorm.prec: no visible global function definition for ‘is’
    rmvnorm.prec: no visible global function definition for ‘rnorm’
    rmvnorm.prec.const: no visible global function definition for ‘is’
    rmvnorm.prec.const: no visible global function definition for ‘rnorm’
    rmvnorm.spam: no visible global function definition for ‘is’
    rmvnorm.spam: no visible global function definition for ‘rnorm’
    solve.spam: no visible global function definition for ‘is’
    spam.history: no visible global function definition for ‘help’
    spam.list: no visible global function definition for ‘new’
    spam.list: no visible global function definition for ‘slot<-’
    spam.numeric: no visible global function definition for ‘new’
    spam.numeric: no visible global function definition for ‘slot<-’
    spam_Arith: no visible global function definition for ‘callGeneric’
    spam_Arith_spamvector: no visible global function definition for
     ‘callGeneric’
    spam_Arith_vectorspam: no visible global function definition for
     ‘callGeneric’
    spam_Compare: no visible global function definition for ‘callGeneric’
    spam_Compare_spamvector: no visible global function definition for
     ‘callGeneric’
    spam_Compare_vectorspam: no visible global function definition for
     ‘callGeneric’
    spam_Logic_spamvector: no visible global function definition for
     ‘callGeneric’
    spam_Logic_vectorspam: no visible global function definition for
     ‘callGeneric’
    spam_Math: no visible global function definition for ‘callGeneric’
    spam_add: no visible global function definition for ‘new’
    spam_add: no visible global function definition for ‘slot<-’
    spam_mult: no visible global function definition for ‘new’
    subset.rows.spam: no visible global function definition for ‘new’
    subset.rows.spam: no visible global function definition for ‘slot<-’
    subset.spam: no visible global function definition for ‘new’
    subset.spam: no visible global function definition for ‘slot<-’
    t.spam: no visible global function definition for ‘new’
    t.spam: no visible global function definition for ‘slot<-’
    todo: no visible global function definition for ‘help’
    toeplitz.spam: no visible global function definition for ‘new’
    toeplitz.spam: no visible global function definition for ‘slot<-’
    update.spam.chol.NgPeyton: no visible global function definition for
     ‘slot<-’
    upper.tri.spam: no visible global function definition for ‘new’
    var.spam: no visible global function definition for ‘var’
    !,spam: no visible global function definition for ‘callGeneric’
    %*%,matrix-spam: no visible global function definition for ‘new’
    %*%,matrix-spam: no visible global function definition for ‘slot<-’
    %*%,numeric-spam: no visible global function definition for ‘new’
    %*%,numeric-spam: no visible global function definition for ‘slot<-’
    %*%,spam-numeric: no visible global function definition for ‘new’
    %*%,spam-numeric: no visible global function definition for ‘slot<-’
    %*%,spam-spam: no visible global function definition for ‘new’
    %*%,spam-spam: no visible global function definition for ‘slot<-’
    *,spam-spam: no visible global function definition for ‘new’
    Arith,spam-spam: no visible global function definition for
     ‘callGeneric’
    Arith,spam-vector: no visible global function definition for
     ‘callGeneric’
    Arith,vector-spam: no visible global function definition for
     ‘callGeneric’
    Compare,spam-spam: no visible global function definition for
     ‘callGeneric’
    Compare,spam-vector: no visible global function definition for
     ‘callGeneric’
    Compare,vector-spam: no visible global function definition for
     ‘callGeneric’
    Logic,spam-vector: no visible global function definition for
     ‘callGeneric’
    Logic,vector-spam: no visible global function definition for
     ‘callGeneric’
    Math2,spam: no visible global function definition for ‘callGeneric’
    Math,spam: no visible global function definition for ‘callGeneric’
    Summary,spam: no visible global function definition for ‘callGeneric’
    [,spam-spam-missing-ANY: no visible global function definition for
     ‘new’
    acos,spam: no visible global function definition for ‘callGeneric’
    acosh,spam: no visible global function definition for ‘callGeneric’
    all,spam: no visible global function definition for ‘callGeneric’
    any,spam: no visible global function definition for ‘callGeneric’
    as.matrix,spam.chol.NgPeyton: no visible global function definition for
     ‘new’
    as.spam,dist: no visible global function definition for ‘new’
    as.spam,dist: no visible global function definition for ‘slot<-’
    as.spam,matrix: no visible global function definition for ‘new’
    as.spam,matrix: no visible global function definition for ‘slot<-’
    as.spam,numeric: no visible global function definition for ‘new’
    as.spam,numeric: no visible global function definition for ‘slot<-’
    as.spam,spam: no visible global function definition for ‘new’
    as.spam,spam: no visible global function definition for ‘slot<-’
    as.spam,spam.chol.NgPeyton: no visible global function definition for
     ‘new’
    as.spam,spam.chol.NgPeyton: no visible global function definition for
     ‘slot<-’
    backsolve,spam: no visible global function definition for ‘is’
    backsolve,spam.chol.NgPeyton: no visible global function definition for
     ‘is’
    c,spam.chol.NgPeyton: no visible global function definition for ‘new’
    cbind,spam: no visible global function definition for ‘new’
    cbind,spam: no visible global function definition for ‘slot<-’
    chol2inv,spam: no visible global function definition for ‘is’
    chol2inv,spam.chol.NgPeyton: no visible global function definition for
     ‘is’
    cos,spam: no visible global function definition for ‘callGeneric’
    cosh,spam: no visible global function definition for ‘callGeneric’
    cummax,spam: no visible global function definition for ‘callGeneric’
    cummin,spam: no visible global function definition for ‘callGeneric’
    cumprod,spam: no visible global function definition for ‘callGeneric’
    cumsum,spam: no visible global function definition for ‘callGeneric’
    diag<-,spam: no visible global function definition for ‘new’
    diag<-,spam: no visible global function definition for ‘slot<-’
    digamma,spam: no visible global function definition for ‘callGeneric’
    exp,spam: no visible global function definition for ‘callGeneric’
    forwardsolve,spam: no visible global function definition for ‘is’
    forwardsolve,spam.chol.NgPeyton: no visible global function definition
     for ‘is’
    gamma,spam: no visible global function definition for ‘callGeneric’
    kronecker,ANY-spam: no visible global function definition for ‘new’
    kronecker,ANY-spam: no visible global function definition for ‘slot<-’
    kronecker,spam-ANY: no visible global function definition for ‘new’
    kronecker,spam-ANY: no visible global function definition for ‘slot<-’
    kronecker,spam-spam: no visible global function definition for ‘new’
    kronecker,spam-spam: no visible global function definition for ‘slot<-’
    lgamma,spam: no visible global function definition for ‘callGeneric’
    log10,spam: no visible global function definition for ‘callGeneric’
    log2,spam: no visible global function definition for ‘callGeneric’
    log,spam: no visible global function definition for ‘callGeneric’
    lower.tri,spam: no visible global function definition for ‘new’
    pad<-,spam: no visible global function definition for ‘new’
    pad<-,spam: no visible global function definition for ‘slot<-’
    permutation,spam: no visible global function definition for ‘new’
    permutation,spam: no visible global function definition for ‘slot<-’
    rbind,spam: no visible global function definition for ‘new’
    spam,list: no visible global function definition for ‘new’
    spam,list: no visible global function definition for ‘slot<-’
    spam,numeric: no visible global function definition for ‘new’
    spam,numeric: no visible global function definition for ‘slot<-’
    t,spam: no visible global function definition for ‘new’
    t,spam: no visible global function definition for ‘slot<-’
    trigamma,spam: no visible global function definition for ‘callGeneric’
    upper.tri,spam: no visible global function definition for ‘new’
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-ix86+x86_64

Version: 1.0-1
Check: R code for possible problems
Result: NOTE
    .spam.diagaddmat: no visible global function definition for ‘new’
    .spam.matmul: no visible global function definition for ‘new’
    .spam.matmul: no visible global function definition for ‘slot<-’
    as.dgCMatrix.spam: no visible global function definition for ‘new’
    as.dgCMatrix.spam: no visible global function definition for ‘slot<-’
    as.dgRMatrix.spam: no visible global function definition for ‘new’
    as.dgRMatrix.spam: no visible global function definition for ‘slot<-’
    as.matrix.csr.spam: no visible global function definition for ‘new’
    as.matrix.csr.spam: no visible global function definition for ‘slot<-’
    as.matrix.spam.chol.NgPeyton: no visible global function definition for
     ‘new’
    as.spam.chol.NgPeyton: no visible global function definition for ‘new’
    as.spam.chol.NgPeyton: no visible global function definition for
     ‘slot<-’
    as.spam.dgCMatrix: no visible global function definition for ‘is’
    as.spam.dgCMatrix: no visible global function definition for ‘new’
    as.spam.dgCMatrix: no visible global function definition for ‘slot<-’
    as.spam.dgRMatrix: no visible global function definition for ‘is’
    as.spam.dgRMatrix: no visible global function definition for ‘new’
    as.spam.dgRMatrix: no visible global function definition for ‘slot<-’
    as.spam.dist: no visible global function definition for ‘new’
    as.spam.dist: no visible global function definition for ‘slot<-’
    as.spam.matrix: no visible global function definition for ‘new’
    as.spam.matrix: no visible global function definition for ‘slot<-’
    as.spam.matrix.csr: no visible global function definition for ‘new’
    as.spam.matrix.csr: no visible global function definition for ‘slot<-’
    as.spam.numeric: no visible global function definition for ‘new’
    as.spam.numeric: no visible global function definition for ‘slot<-’
    as.spam.spam: no visible global function definition for ‘new’
    as.spam.spam: no visible global function definition for ‘slot<-’
    assign.spam: no visible global function definition for ‘new’
    assign.spam: no visible global function definition for ‘slot<-’
    backsolve.spam: no visible global function definition for ‘is’
    cbind.spam: no visible global function definition for ‘new’
    cbind.spam: no visible global function definition for ‘slot<-’
    chol.spam: no visible global function definition for ‘new’
    chol.spam: no visible global function definition for ‘slot<-’
    chol2inv.spam: no visible global function definition for ‘is’
    circulant.spam: no visible global function definition for ‘new’
    circulant.spam: no visible global function definition for ‘slot<-’
    complement.spam: no visible global function definition for ‘new’
    complement.spam: no visible global function definition for ‘slot<-’
    diag.spam: no visible global function definition for ‘new’
    diag.spam: no visible global function definition for ‘slot<-’
    diag.spam<-: no visible global function definition for ‘new’
    diag.spam<-: no visible global function definition for ‘slot<-’
    diag<-.spam: no visible global function definition for ‘new’
    diag<-.spam: no visible global function definition for ‘slot<-’
    display.spam: no visible global function definition for ‘image.default’
    display.spam: no visible global function definition for ‘axis’
    display.spam: no visible global function definition for ‘box’
    forwardsolve.spam: no visible global function definition for ‘is’
    germany.plot: no visible global function definition for ‘par’
    germany.plot: no visible global function definition for ‘polygon’
    germany.plot: no visible global function definition for ‘text’
    grid_zoom: no visible global function definition for ‘runif’
    image.spam: no visible global function definition for ‘heat.colors’
    image.spam: no visible global function definition for ‘image.default’
    image.spam: no visible global function definition for ‘points’
    image.spam: no visible global function definition for ‘box’
    is.spam: no visible global function definition for ‘is’
    kronecker.spam: no visible global function definition for ‘new’
    kronecker.spam: no visible global function definition for ‘slot<-’
    logical_Summary: no visible global function definition for
     ‘callGeneric’
    lower.tri.spam: no visible global function definition for ‘new’
    map.landkreis: no visible global function definition for ‘gray’
    map.landkreis: no visible global function definition for ‘polygon’
    mle: no visible global function definition for ‘optim’
    mle.nomean: no visible global function definition for ‘optim’
    mle.nomean.spam: no visible global function definition for ‘is’
    mle.nomean.spam: no visible global function definition for ‘optim’
    mle.spam: no visible global function definition for ‘is’
    mle.spam: no visible global function definition for ‘optim’
    nearest.dist: no visible global function definition for ‘new’
    nearest.dist: no visible global function definition for ‘slot<-’
    neg2loglikelihood.spam: no visible global function definition for ‘is’
    pad<-.spam: no visible global function definition for ‘new’
    pad<-.spam: no visible global function definition for ‘slot<-’
    permutation.spam: no visible global function definition for ‘new’
    permutation.spam: no visible global function definition for ‘slot<-’
    rbind.spam: no visible global function definition for ‘new’
    read.HB: no visible global function definition for ‘new’
    read.HB: no visible global function definition for ‘slot<-’
    read.MM: no visible global function definition for ‘new’
    read.MM: no visible global function definition for ‘slot<-’
    rmvnorm.canonical: no visible global function definition for ‘is’
    rmvnorm.canonical: no visible global function definition for ‘rnorm’
    rmvnorm.canonical.const: no visible global function definition for ‘is’
    rmvnorm.canonical.const: no visible global function definition for
     ‘rnorm’
    rmvnorm.const: no visible global function definition for ‘is’
    rmvnorm.const: no visible global function definition for ‘rnorm’
    rmvnorm.prec: no visible global function definition for ‘is’
    rmvnorm.prec: no visible global function definition for ‘rnorm’
    rmvnorm.prec.const: no visible global function definition for ‘is’
    rmvnorm.prec.const: no visible global function definition for ‘rnorm’
    rmvnorm.spam: no visible global function definition for ‘is’
    rmvnorm.spam: no visible global function definition for ‘rnorm’
    solve.spam: no visible global function definition for ‘is’
    spam.history: no visible global function definition for ‘help’
    spam.list: no visible global function definition for ‘new’
    spam.list: no visible global function definition for ‘slot<-’
    spam.numeric: no visible global function definition for ‘new’
    spam.numeric: no visible global function definition for ‘slot<-’
    spam_Arith: no visible global function definition for ‘callGeneric’
    spam_Arith_spamvector: no visible global function definition for
     ‘callGeneric’
    spam_Arith_vectorspam: no visible global function definition for
     ‘callGeneric’
    spam_Compare: no visible global function definition for ‘callGeneric’
    spam_Compare_spamvector: no visible global function definition for
     ‘callGeneric’
    spam_Compare_vectorspam: no visible global function definition for
     ‘callGeneric’
    spam_Logic_spamvector: no visible global function definition for
     ‘callGeneric’
    spam_Logic_vectorspam: no visible global function definition for
     ‘callGeneric’
    spam_Math: no visible global function definition for ‘callGeneric’
    spam_add: no visible global function definition for ‘new’
    spam_add: no visible global function definition for ‘slot<-’
    spam_mult: no visible global function definition for ‘new’
    subset.rows.spam: no visible global function definition for ‘new’
    subset.rows.spam: no visible global function definition for ‘slot<-’
    subset.spam: no visible global function definition for ‘new’
    subset.spam: no visible global function definition for ‘slot<-’
    t.spam: no visible global function definition for ‘new’
    t.spam: no visible global function definition for ‘slot<-’
    todo: no visible global function definition for ‘help’
    toeplitz.spam: no visible global function definition for ‘new’
    toeplitz.spam: no visible global function definition for ‘slot<-’
    update.spam.chol.NgPeyton: no visible global function definition for
     ‘slot<-’
    upper.tri.spam: no visible global function definition for ‘new’
    var.spam: no visible global function definition for ‘var’
    !,spam: no visible global function definition for ‘callGeneric’
    %*%,matrix-spam: no visible global function definition for ‘new’
    %*%,matrix-spam: no visible global function definition for ‘slot<-’
    %*%,numeric-spam: no visible global function definition for ‘new’
    %*%,numeric-spam: no visible global function definition for ‘slot<-’
    %*%,spam-numeric: no visible global function definition for ‘new’
    %*%,spam-numeric: no visible global function definition for ‘slot<-’
    %*%,spam-spam: no visible global function definition for ‘new’
    %*%,spam-spam: no visible global function definition for ‘slot<-’
    *,spam-spam: no visible global function definition for ‘new’
    Arith,spam-spam: no visible global function definition for
     ‘callGeneric’
    Arith,spam-vector: no visible global function definition for
     ‘callGeneric’
    Arith,vector-spam: no visible global function definition for
     ‘callGeneric’
    Compare,spam-spam: no visible global function definition for
     ‘callGeneric’
    Compare,spam-vector: no visible global function definition for
     ‘callGeneric’
    Compare,vector-spam: no visible global function definition for
     ‘callGeneric’
    Logic,spam-vector: no visible global function definition for
     ‘callGeneric’
    Logic,vector-spam: no visible global function definition for
     ‘callGeneric’
    Math2,spam: no visible global function definition for ‘callGeneric’
    Math,spam: no visible global function definition for ‘callGeneric’
    Summary,spam: no visible global function definition for ‘callGeneric’
    [,spam-spam-missing-ANY: no visible global function definition for
     ‘new’
    acos,spam: no visible global function definition for ‘callGeneric’
    acosh,spam: no visible global function definition for ‘callGeneric’
    all,spam: no visible global function definition for ‘callGeneric’
    any,spam: no visible global function definition for ‘callGeneric’
    as.matrix,spam.chol.NgPeyton: no visible global function definition for
     ‘new’
    as.spam,dist: no visible global function definition for ‘new’
    as.spam,dist: no visible global function definition for ‘slot<-’
    as.spam,matrix: no visible global function definition for ‘new’
    as.spam,matrix: no visible global function definition for ‘slot<-’
    as.spam,numeric: no visible global function definition for ‘new’
    as.spam,numeric: no visible global function definition for ‘slot<-’
    as.spam,spam: no visible global function definition for ‘new’
    as.spam,spam: no visible global function definition for ‘slot<-’
    as.spam,spam.chol.NgPeyton: no visible global function definition for
     ‘new’
    as.spam,spam.chol.NgPeyton: no visible global function definition for
     ‘slot<-’
    backsolve,spam: no visible global function definition for ‘is’
    backsolve,spam.chol.NgPeyton: no visible global function definition for
     ‘is’
    c,spam.chol.NgPeyton: no visible global function definition for ‘new’
    cbind,spam: no visible global function definition for ‘new’
    cbind,spam: no visible global function definition for ‘slot<-’
    chol2inv,spam: no visible global function definition for ‘is’
    chol2inv,spam.chol.NgPeyton: no visible global function definition for
     ‘is’
    cos,spam: no visible global function definition for ‘callGeneric’
    cosh,spam: no visible global function definition for ‘callGeneric’
    cummax,spam: no visible global function definition for ‘callGeneric’
    cummin,spam: no visible global function definition for ‘callGeneric’
    cumprod,spam: no visible global function definition for ‘callGeneric’
    cumsum,spam: no visible global function definition for ‘callGeneric’
    diag<-,spam: no visible global function definition for ‘new’
    diag<-,spam: no visible global function definition for ‘slot<-’
    digamma,spam: no visible global function definition for ‘callGeneric’
    exp,spam: no visible global function definition for ‘callGeneric’
    forwardsolve,spam: no visible global function definition for ‘is’
    forwardsolve,spam.chol.NgPeyton: no visible global function definition
     for ‘is’
    gamma,spam: no visible global function definition for ‘callGeneric’
    kronecker,ANY-spam: no visible global function definition for ‘new’
    kronecker,ANY-spam: no visible global function definition for ‘slot<-’
    kronecker,spam-ANY: no visible global function definition for ‘new’
    kronecker,spam-ANY: no visible global function definition for ‘slot<-’
    kronecker,spam-spam: no visible global function definition for ‘new’
    kronecker,spam-spam: no visible global function definition for ‘slot<-’
    lgamma,spam: no visible global function definition for ‘callGeneric’
    log10,spam: no visible global function definition for ‘callGeneric’
    log2,spam: no visible global function definition for ‘callGeneric’
    log,spam: no visible global function definition for ‘callGeneric’
    lower.tri,spam: no visible global function definition for ‘new’
    pad<-,spam: no visible global function definition for ‘new’
    pad<-,spam: no visible global function definition for ‘slot<-’
    permutation,spam: no visible global function definition for ‘new’
    permutation,spam: no visible global function definition for ‘slot<-’
    rbind,spam: no visible global function definition for ‘new’
    spam,list: no visible global function definition for ‘new’
    spam,list: no visible global function definition for ‘slot<-’
    spam,numeric: no visible global function definition for ‘new’
    spam,numeric: no visible global function definition for ‘slot<-’
    t,spam: no visible global function definition for ‘new’
    t,spam: no visible global function definition for ‘slot<-’
    trigamma,spam: no visible global function definition for ‘callGeneric’
    upper.tri,spam: no visible global function definition for ‘new’
    Undefined global functions or variables:
     axis box callGeneric gray heat.colors help image.default is new optim
     par points polygon rnorm runif slot<- text var
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 1.0-1
Check: foreign function calls
Result: NOTE
    Calls with DUP != TRUE:
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amuxmat", nrow, yrow, ycol, as.double(y), y = vector("double",
     nrow * ycol), as.double(x@entries), x@colindices, x@rowpointers,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("transpose", n = dimx[1], m = dimx[2], a = as.double(x@entries),
     ja = x@colindices, ia = x@rowpointers, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     dimx[2] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = dimx[1], entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = nrow, entries = as.double(x@entries),
     colindices = xcolindices, rowpointers = x@rowpointers, res = vector("double",
     nrow * nrow), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("transpose", n = x@Dim[2], m = x@Dim[1], a = as.double(x@x),
     ja = x@i + 1L, ia = x@p + 1L, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     x@Dim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = dimx[1], ncol = dimx[2], x = as.double(x),
     dimx[1], entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", dimx[1] + 1), eps = as.double(eps),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("subass", nrow, ncol, as.double(x@entries), x@colindices,
     x@rowpointers, b = as.vector(value[ord], "double"), bj = as.vector(rw[,
     2], "integer"), bi = bia, entries = vector("double",
     nzmax), colindices = vector("integer", nzmax), rowpointers = vector("integer",
     nrow + 1), nzmax = nzmax, NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("backsolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotbacksolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@invpivot, r@pivot,
     r@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamback", m = m, p, sol = vector("double", m * p),
     x = as.vector(x, "double"), al = as.double(r@entries), jal = r@colindices,
     ial = r@rowpointers, DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("getbwd", A@dimension[1], A@entries, A@colindices, A@rowpointers,
     low = integer(1), upp = integer(1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("cbind", Xdim[2], Xdim[1], Ydim[2], XYlen, args[[1]]@entries,
     args[[1]]@colindices, args[[1]]@rowpointers, args[[2]]@entries,
     args[[2]]@colindices, args[[2]]@rowpointers, entries = vector("double",
     XYlen), colindices = vector("integer", XYlen), rowpointers = vector("integer",
     Xdim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cholstepwise", nrow = nrow, nnzA = nnzA, d = as.double(x@entries),
     jd = x@colindices, id = x@rowpointers, doperm = doperm, invp = vector("integer",
     nrow), perm = pivot, nnzlindx = vector("integer", 1),
     nnzcolindices = as.integer(nnzcolindices), lindx = vector("integer",
     nnzcolindices), xlindx = vector("integer", nrow + 1),
     nsuper = vector("integer", 1), nnzR = as.integer(nnzR), lnz = vector("double",
     nnzR), xlnz = vector("integer", nrow + 1), snode = vector("integer",
     nrow), xsuper = vector("integer", nrow + 1), cachesize = as.integer(cache),
     ierr = 0L, NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cholstepwise", nrow = nrow, nnzA = as.integer(x@rowpointers[nrow +
     1] - 1), d = as.double(x@entries), jd = x@colindices, id = x@rowpointers,
     doperm = doperm, invp = vector("integer", nrow), perm = pivot,
     nnzlindx = vector("integer", 1), nnzcolindices = as.integer(nnzcolindices),
     lindx = vector("integer", nnzcolindices), xlindx = vector("integer",
     nrow + 1), nsuper = vector("integer", 1), nnzR = as.integer(nnzR),
     lnz = vector("double", nnzR), xlnz = vector("integer", nrow +
     1), snode = vector("integer", nrow), xsuper = vector("integer",
     nrow + 1), cachesize = as.integer(cache), ierr = 0L,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("backsolves", m = nrow, as.integer(length(x@supernodes) -
     1), nrow, x@colindices, x@colpointers, as.double(x@entries),
     x@rowpointers, x@invpivot, x@pivot, x@supernodes, vector("double",
     nrow), sol = vector("double", nrow * nrow), y, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("circulant", n, len, as.double(x), as.integer(ind),
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", n + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("colmeans", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], x@dimension[2],
     as.logical(.Spam$structurebased), cm = vector("double", x@dimension[2]),
     vector("integer", x@dimension[2]), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("colsums", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], cs = vector("double",
     x@dimension[2]), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("notzero", x@colindices, x@rowpointers, nrow, ncol,
     as.integer(nnz), as.integer(nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cholstepwise", nrow = nrow, nnzA = as.integer(x@rowpointers[nrow +
     1] - 1), d = as.double(x@entries), jd = x@colindices, id = x@rowpointers,
     doperm = doperm, invp = vector("integer", nrow), perm = pivot,
     nnzlindx = vector("integer", 1), nnzcolindices = as.integer(nnzcolindices),
     lindx = vector("integer", nnzcolindices), xlindx = vector("integer",
     nrow + 1), nsuper = vector("integer", 1), nnzR = as.integer(nnzR),
     lnz = vector("double", nnzR), xlnz = vector("integer", nrow +
     1), snode = vector("integer", nrow), xsuper = vector("integer",
     nrow + 1), cachesize = as.integer(cache), ierr = 0L,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cholstepwise", nrow = nrow, nnzA = as.integer(x@rowpointers[nrow +
     1] - 1), d = as.double(x@entries), jd = x@colindices, id = x@rowpointers,
     doperm = doperm, invp = vector("integer", nrow), perm = pivot,
     nnzlindx = vector("integer", 1), nnzcolindices = as.integer(nnzcolindices),
     lindx = vector("integer", nnzcolindices), xlindx = vector("integer",
     nrow + 1), nsuper = vector("integer", 1), nnzR = as.integer(nnzR),
     lnz = vector("double", nnzR), xlnz = vector("integer", nrow +
     1), snode = vector("integer", nrow), xsuper = vector("integer",
     nrow + 1), cachesize = as.integer(cache), ierr = 0L,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getdiag", a = as.double(x@entries), colindices = x@colindices,
     rowpointers = x@rowpointers, len = len, diag = vector("double",
     len), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("forwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotforwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@invpivot, l@pivot,
     l@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamforward", m = m, p, sol = vector("double", m *
     p), x = as.vector(x, "double"), al = as.double(l@entries),
     jal = l@colindices, ial = l@rowpointers, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("kroneckermult", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, entries = vector("double",
     kronlen), colindices = vector("integer", kronlen), rowpointers = vector("integer",
     Xdim[1] * Ydim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("kronecker", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, ent1 = vector("double", kronlen),
     ent2 = vector("double", kronlen), colindices = vector("integer",
     kronlen), rowpointers = vector("integer", Xdim[1] * Ydim[1] +
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("closestdist", nd, as.double(x), n1, as.double(y), n2,
     part, as.double(p[1]), method, as.double(abs(delta[1])),
     colindices = vector("integer", nnz), rowpointers = vector("integer",
     n1 + 1), entries = vector("double", nnz), nnz = as.integer(nnz),
     iflag = as.integer(0), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("reducedim", oldra = as.double(x@entries), oldja = x@colindices,
     oldia = x@rowpointers, eps = .Spam$eps, as.integer(min(value[1],
     dimx[1])), as.integer(value[2]), nz = 1L, entries = vector("double",
     length(x@entries)), colindices = vector("integer", length(x@entries)),
     rowpointers = vector("integer", last), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), P, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), Q, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("dperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), P, Q,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("transpose", n = nc, m = nr, a = vals, ja = ind, ia = ptr,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nr + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = nr, ncol = nc, x = x, nr, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     nr + 1), eps = spam.options("eps"), NAOK = TRUE, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("rowmeans", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], x@dimension[2],
     as.logical(.Spam$structurebased), rm = vector("double", x@dimension[1]),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rowsums", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], rs = vector("double",
     x@dimension[1]), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("backsolves", m = nrow, nsuper, p, a@colindices, a@colpointers,
     as.double(a@entries), a@rowpointers, a@invpivot, a@pivot,
     a@supernodes, vector("double", nrow), sol = vector("double",
     nrow * p), as.vector(b, "double"), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran(ifelse(toupper(.Spam$listmethod == "PE"), "triplet3csr",
     "triplet2csr"), nrow = nrow, ncol = ncol, nz = nz, as.double(x[[elenr]]),
     ir, jc, entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), eps,
     NAOK = TRUE, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = dimx[1], ncol = dimx[2], x = as.double(x),
     dimx[1], entries = vector("double", lenx), colindices = vector("integer",
     lenx), rowpointers = vector("integer", dimx[1] + 1),
     eps = as.double(eps), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("aplbdg", nrow, ncol, A@colindices, A@rowpointers, B@colindices,
     B@rowpointers, vector("integer", nrow), nnz = vector("integer",
     1), vector("integer", ncol), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("aplsb1", nrow, ncol, as.double(A@entries), A@colindices,
     A@rowpointers, as.double(s), as.double(B@entries), B@colindices,
     B@rowpointers, entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", nrow + 1), as.integer(nzmax +
     1), ierr = vector("integer", 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("aemub", e1row, e1col, as.double(e1@entries), e1@colindices,
     e1@rowpointers, as.double(e2@entries), e2@colindices, e2@rowpointers,
     entries = vector("double", nnzmax), colindices = vector("integer",
     nnzmax), rowpointers = vector("integer", e1row + 1),
     integer(e1col), double(e1col), as.integer(nnzmax), ierr = vector("integer",
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow, entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow, entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getallelem", nir, as.integer(i), as.integer(j), as.double(x@entries),
     as.integer(x@colindices), as.integer(x@rowpointers), iadd = vector("integer",
     nir), allelem = vector("double", nir), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getlines", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), ni, as.integer(i), newnz = nz,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", ni + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = ni, entries = z$entries, colindices = z$colindices,
     rowpointers = z$rowpointers, res = vector("double", prod(ni,
     ncol)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getallelem", nir, as.integer(ir), as.integer(jr), as.double(x@entries),
     as.integer(x@colindices), as.integer(x@rowpointers), integer(nir),
     allelem = vector("double", nir), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("submat", nrow, job = 1L, i1 = as.integer(rw[1]), i2 = as.integer(rw[nrw]),
     j1 = as.integer(cl[1]), j2 = as.integer(cl[ncl]), as.double(x@entries),
     x@colindices, x@rowpointers, nr = 0L, nc = 0L, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     nrw + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getblock", as.double(x@entries), x@colindices, x@rowpointers,
     nr = nrw, as.integer(rw), nc = ncl, as.integer(cl), nz = nz,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrw + 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = z$nr, entries = z$entries[1:nz],
     colindices = z$colindices[1:nz], rowpointers = z$rowpointers[1:(z$nr +
     1)], res = vector("double", prod(z$nr, z$nc)), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("transpose", n = dimx[1], m = dimx[2], a = as.double(x@entries),
     ja = x@colindices, ia = x@rowpointers, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     dimx[2] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("toeplitz", n, len, as.double(fullx), as.integer(ind),
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", n + 1), nnz = as.integer(1),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amuxmat", nrow, yrow, ycol, as.double(y), y = vector("double",
     nrow * ycol), as.double(x@entries), x@colindices, x@rowpointers,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(x), y = vector("double", nrow),
     as.double(y@entries), y@colindices, y@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amux", nrow, as.double(y), y = vector("double", nrow),
     as.double(x@entries), x@colindices, x@rowpointers, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amubdg", xn, xm, yl, x@colindices, x@rowpointers, y@colindices,
     y@rowpointers, integer(xn), nz = vector("integer", 1), integer(yl),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("amub", xn, yl, 1L, as.double(x@entries), x@colindices,
     x@rowpointers, as.double(y@entries), y@colindices, y@rowpointers,
     entries = vector("double", nzmax), colindices = vector("integer",
     nzmax), rowpointers = vector("integer", xn + 1), as.integer(nzmax),
     integer(yl), ierr = vector("integer", 1), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("aemub", e1row, e1col, as.double(e1@entries), e1@colindices,
     e1@rowpointers, as.double(e2@entries), e2@colindices, e2@rowpointers,
     entries = vector("double", nnzmax), colindices = vector("integer",
     nnzmax), rowpointers = vector("integer", e1row + 1),
     integer(e1col), double(e1col), as.integer(nnzmax), ierr = vector("integer",
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = dimx[1], entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = nrow, entries = as.double(x@entries),
     colindices = xcolindices, rowpointers = x@rowpointers, res = vector("double",
     nrow * nrow), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = dimx[1], ncol = dimx[2], x = as.double(x),
     dimx[1], entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", dimx[1] + 1), eps = as.double(eps),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("backsolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotbacksolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@invpivot, r@pivot,
     r@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamback", m = m, p, sol = vector("double", m * p),
     x = as.vector(x, "double"), al = as.double(r@entries), jal = r@colindices,
     ial = r@rowpointers, DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("backsolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotbacksolve", m, nsuper, p, r@colindices, r@colpointers,
     as.double(r@entries), r@rowpointers, r@invpivot, r@pivot,
     r@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamback", m = m, p, sol = vector("double", m * p),
     x = as.vector(x, "double"), al = as.double(r@entries), jal = r@colindices,
     ial = r@rowpointers, DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = dimx[1], entries = as.double(x@entries),
     colindices = x@colindices, rowpointers = x@rowpointers, res = vector("double",
     prod(dimx)), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("calcja", nrow, nsuper, x@supernodes, x@colindices,
     x@colpointers, x@rowpointers, xja = vector("integer", nnzR),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamcsrdns", nrow = nrow, entries = as.double(x@entries),
     colindices = xcolindices, rowpointers = x@rowpointers, res = vector("double",
     nrow * nrow), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cbind", Xdim[2], Xdim[1], Ydim[2], XYlen, args[[1]]@entries,
     args[[1]]@colindices, args[[1]]@rowpointers, args[[2]]@entries,
     args[[2]]@colindices, args[[2]]@rowpointers, entries = vector("double",
     XYlen), colindices = vector("integer", XYlen), rowpointers = vector("integer",
     Xdim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("backsolves", m = nrow, as.integer(length(x@supernodes) -
     1), nrow, x@colindices, x@colpointers, as.double(x@entries),
     x@rowpointers, x@invpivot, x@pivot, x@supernodes, vector("double",
     nrow), sol = vector("double", nrow * nrow), y, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("backsolves", m = nrow, as.integer(length(x@supernodes) -
     1), nrow, x@colindices, x@colpointers, as.double(x@entries),
     x@rowpointers, x@invpivot, x@pivot, x@supernodes, vector("double",
     nrow), sol = vector("double", nrow * nrow), y, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("colmeans", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], x@dimension[2],
     as.logical(.Spam$structurebased), cm = vector("double", x@dimension[2]),
     vector("integer", x@dimension[2]), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("colsums", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], cs = vector("double",
     x@dimension[2]), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("getdiag", a = as.double(x@entries), colindices = x@colindices,
     rowpointers = x@rowpointers, len = len, diag = vector("double",
     len), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("forwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotforwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@invpivot, l@pivot,
     l@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamforward", m = m, p, sol = vector("double", m *
     p), x = as.vector(x, "double"), al = as.double(l@entries),
     jal = l@colindices, ial = l@rowpointers, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("forwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@supernodes, sol = vector("double",
     m * p), DUP = DUPFALSE, NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("pivotforwardsolve", m, nsuper, p, l@colindices, l@colpointers,
     as.double(l@entries), l@rowpointers, l@invpivot, l@pivot,
     l@supernodes, vector("double", m), sol = vector("double",
     m * p), as.double(x), DUP = DUPFALSE, NAOK = .Spam$NAOK,
     PACKAGE = "spam")
     .Fortran("spamforward", m = m, p, sol = vector("double", m *
     p), x = as.vector(x, "double"), al = as.double(l@entries),
     jal = l@colindices, ial = l@rowpointers, DUP = DUPFALSE,
     NAOK = .Spam$NAOK, PACKAGE = "spam")
     .Fortran("kroneckermult", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, entries = vector("double",
     kronlen), colindices = vector("integer", kronlen), rowpointers = vector("integer",
     Xdim[1] * Ydim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("kronecker", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, ent1 = vector("double", kronlen),
     ent2 = vector("double", kronlen), colindices = vector("integer",
     kronlen), rowpointers = vector("integer", Xdim[1] * Ydim[1] +
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("kroneckermult", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, entries = vector("double",
     kronlen), colindices = vector("integer", kronlen), rowpointers = vector("integer",
     Xdim[1] * Ydim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("kronecker", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, ent1 = vector("double", kronlen),
     ent2 = vector("double", kronlen), colindices = vector("integer",
     kronlen), rowpointers = vector("integer", Xdim[1] * Ydim[1] +
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("kroneckermult", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, entries = vector("double",
     kronlen), colindices = vector("integer", kronlen), rowpointers = vector("integer",
     Xdim[1] * Ydim[1] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("kronecker", Xdim[1], Xentries, Xcol, Xrow, Ydim[1],
     Ydim[2], Yentries, Ycol, Yrow, ent1 = vector("double", kronlen),
     ent2 = vector("double", kronlen), colindices = vector("integer",
     kronlen), rowpointers = vector("integer", Xdim[1] * Ydim[1] +
     1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("reducedim", oldra = as.double(x@entries), oldja = x@colindices,
     oldia = x@rowpointers, eps = .Spam$eps, as.integer(min(value[1],
     dimx[1])), as.integer(value[2]), nz = 1L, entries = vector("double",
     length(x@entries)), colindices = vector("integer", length(x@entries)),
     rowpointers = vector("integer", last), NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), P, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("cperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), Q, NAOK = .Spam$NAOK,
     DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("dperm", nrow, A@entries, A@colindices, A@rowpointers,
     entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), P, Q,
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rowmeans", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], x@dimension[2],
     as.logical(.Spam$structurebased), rm = vector("double", x@dimension[1]),
     NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("rowsums", as.double(x@entries), as.integer(x@colindices),
     as.integer(x@rowpointers), x@dimension[1], rs = vector("double",
     x@dimension[1]), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran(ifelse(toupper(.Spam$listmethod == "PE"), "triplet3csr",
     "triplet2csr"), nrow = nrow, ncol = ncol, nz = nz, as.double(x[[elenr]]),
     ir, jc, entries = vector("double", nz), colindices = vector("integer",
     nz), rowpointers = vector("integer", nrow + 1), eps,
     NAOK = TRUE, DUP = DUPFALSE, PACKAGE = "spam")
     .Fortran("spamdnscsr", nrow = dimx[1], ncol = dimx[2], x = as.double(x),
     dimx[1], entries = vector("double", lenx), colindices = vector("integer",
     lenx), rowpointers = vector("integer", dimx[1] + 1),
     eps = as.double(eps), NAOK = .Spam$NAOK, DUP = DUPFALSE,
     PACKAGE = "spam")
     .Fortran("transpose", n = dimx[1], m = dimx[2], a = as.double(x@entries),
     ja = x@colindices, ia = x@rowpointers, entries = vector("double",
     nz), colindices = vector("integer", nz), rowpointers = vector("integer",
     dimx[2] + 1), NAOK = .Spam$NAOK, DUP = DUPFALSE, PACKAGE = "spam")
    DUP = FALSE is deprecated and will be disabled in future versions of R.
Flavor: r-oldrel-windows-ix86+x86_64