CRAN Package Check Results for Package spam

Last updated on 2014-09-17 23:48:01.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.0-1 7.89 88.15 96.04 NOTE
r-devel-linux-x86_64-debian-gcc 1.0-1 7.50 86.76 94.26 NOTE
r-devel-linux-x86_64-fedora-clang 1.0-1 192.40 NOTE
r-devel-linux-x86_64-fedora-gcc 1.0-1 181.57 NOTE
r-devel-osx-x86_64-clang 1.0-1 152.77 NOTE
r-devel-windows-ix86+x86_64 1.0-1 25.00 175.00 200.00 NOTE
r-patched-linux-x86_64 1.0-1 7.76 92.28 100.03 NOTE
r-patched-solaris-sparc 1.0-1 1094.60 NOTE
r-patched-solaris-x86 1.0-1 244.50 NOTE
r-release-linux-ix86 1.0-1 10.07 105.71 115.78 NOTE
r-release-linux-x86_64 1.0-1 7.77 92.67 100.44 NOTE
r-release-osx-x86_64-mavericks 1.0-1 NOTE
r-release-osx-x86_64-snowleopard 1.0-1 OK
r-release-windows-ix86+x86_64 1.0-1 25.00 196.00 221.00 NOTE
r-oldrel-windows-ix86+x86_64 1.0-1 24.00 197.00 221.00 NOTE

Check Details

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

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 may be disabled in future versions of R.
Flavor: r-patched-linux-x86_64

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.
Flavors: r-patched-solaris-sparc, r-patched-solaris-x86, r-release-osx-x86_64-mavericks

Version: 1.0-1
Check: dependencies in R code
Result: NOTE
    Missing or unexported objects:
     ‘spam::germany’ ‘spam::germany.info’ ‘spam::germany.poly’
    See the information on DESCRIPTION files in the chapter ‘Creating R
    packages’ of the ‘Writing R Extensions’ manual.
Flavors: r-release-linux-ix86, r-release-linux-x86_64, r-release-windows-ix86+x86_64, r-oldrel-windows-ix86+x86_64