SCM

SCM Repository

[matrix] Diff of /pkg/TODO
ViewVC logotype

Diff of /pkg/TODO

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1887, Thu Jun 7 09:04:34 2007 UTC revision 2115, Sat Feb 23 09:23:17 2008 UTC
# Line 1  Line 1 
1  Check for DimNames propagation in coercion and other operations.  - Check for DimNames propagation in coercion and other operations.
 ------  
 - rcond methods for sparseMatrix classes  
2    
3  - Report the problem in the Linux ldexp manual page.  The second and  - Report the problem in the Linux ldexp manual page.  The second and
4    third calls in the Synopsis should be to ldexpf and ldexpl.    third calls in the Synopsis should be to ldexpf and ldexpl.
5    
 - [,] indexing: for sparse "works", but not yet for negative indices!  
   
 - consider moving alloc3Darray from ./src/Mutils.c to  
   $(RSRC)/src/base/array.c  
 ------  
6  - provide methods for "dspMatrix" and "dppMatrix"!  - provide methods for "dspMatrix" and "dppMatrix"!
7    
8  - implement (more) methods for supporting "packed" (symmetric / triangular)  - implement (more) methods for supporting "packed" (symmetric / triangular)
# Line 18  Line 11 
11    
12    (have some dtr* <-> dtp*)    (have some dtr* <-> dtp*)
13    
 -----  
   
14  - combine the C functions for multiplication by special forms and  - combine the C functions for multiplication by special forms and
15    solution wrt special forms by using a 'right' argument and a    solution wrt special forms by using a 'right' argument and a
16    'classed' argument.    'classed' argument.
17     [done with dgeMatrix_matrix_mm();  not yet for other classes;     [done with dgeMatrix_matrix_mm();  not yet for other classes;
18      and for _crossprod()]      and for _crossprod()]
19    
 - add more comprehensive examples / tests for Schur decomposition  
   
 - arithmetic for sparse matrices:  
              <sparseMatrix>  o  <same-dim-sparseMatrix>  
   should return a sparse matrix  for at least "+" and "*" , also %%,  
   and "/" and "%/%" at least when the RHS is non-zero a scalar.  
   Challenge: nice implementation (``common non-0''; but Tsparse* is not uniq).  
   
20  -----  -----
21    
22  - "Math2" , "Math", "Arith":  - "Math2" , "Math", "Arith":
# Line 52  Line 35 
35    for all  "dsparse*" -> "lsparse*" and vice versa.    for all  "dsparse*" -> "lsparse*" and vice versa.
36    How can one do this {in a documented way} ?    How can one do this {in a documented way} ?
37    
38    - Think of constructing  setAs(...) calls automatically in order to
39      basically enable all ``sensible'' as(fromMatrix, toMatrix)  calls,
40      possibly using canCoerce(.)
41    
42    - setAs(<Mcl>,  "[dln]Matrix") for <Mcl> in {Matrix or denseMatrix + sparseMatrix}
43    
44    - When we have a packed matrix, it's a waste to go through "full" to "sparse":
45      ==> implement
46            setAs("dspMatrix", "sparseMatrix")
47            setAs("dppMatrix", "sparseMatrix")
48            setAs("dtpMatrix", "sparseMatrix")
49      and the same for "lsp" , "ltp"  and  "nsp" , "ntp" !
50    
51  - tcrossprod(x, y) : do provide methods for y != NULL  - tcrossprod(x, y) : do provide methods for y != NULL
52    calling Lapack's DGEMM for "dense"    calling Lapack's DGEMM for "dense"
53    [2005-12-xx: done for dgeMatrix at least]    [2005-12-xx: done for dgeMatrix at least]
# Line 61  Line 57 
57    str(H6 <- as(h6, "dspMatrix"))       # has lost factor    str(H6 <- as(h6, "dspMatrix"))       # has lost factor
58    ## and the same in a similar situation involving  "dpo", "dpp"    ## and the same in a similar situation involving  "dpo", "dpp"
59    
 - Things like  M[upper.tri(M)] are not really most useful for  sparse  
   matrices.  --> provide generic functions  
   upperTriMatrix(), lowerTriMatrix()  both with argument  'diag = TRUE'  
   (which can be set to FALSE of course) which are used to extract a  
   triangle from an arbitrary sparse matrix and  return a  "dtCMatrix".  
   
60  - Factorizations: LU done; also Schur()  for  *sparse*  Matrices.  - Factorizations: LU done; also Schur()  for  *sparse*  Matrices.
61    
 - band(), triu(), tril() for *all* including "matrix", not just sparse matrices  
   
62  - is.na() method for all our matrices [ ==> which(*, arr.ind=TRUE) might work ]  - is.na() method for all our matrices [ ==> which(*, arr.ind=TRUE) might work ]
63    
 - When we have a packed matrix, it's a waste to go through "full" to "sparse":  
   ==> implement  
         setAs("dspMatrix", "sparseMatrix")  
         setAs("dppMatrix", "sparseMatrix")  
         setAs("dtpMatrix", "sparseMatrix")  
   and the same for "lsp" , "ltp"  and  "nsp" , "ntp" !  
   
64  - use  .Call(Csparse_drop, M, tol) in more places,  - use  .Call(Csparse_drop, M, tol) in more places,
65    both with 'tol = 0.' to drop "values that happen to be 0" and for    both with 'tol = 0.' to drop "values that happen to be 0" and for
66    zapsmall() methods for Csparse*    zapsmall() methods for Csparse*
# Line 92  Line 73 
73  - chol() and determinant() should ``work'': proper result or "good" error  - chol() and determinant() should ``work'': proper result or "good" error
74    message.    message.
75    
 - Think of constructing  setAs(...) calls automatically in order to  
   basically enable all ``sensible'' as(fromMatrix, toMatrix)  calls,  
   possibly using canCoerce(.)  
   
76  - make sure *all* group methods have (maybe "bail-out") setMethod for "Matrix".  - make sure *all* group methods have (maybe "bail-out") setMethod for "Matrix".
77    e.g. zapsmall(<pMatrix>) fails "badly"    e.g. zapsmall(<pMatrix>) fails "badly"
78    
 - speedup: pass class definition to non0ind() [check all calls ..]  
   
79  - sum(): implement methods which work for *all* our matrices.  - sum(): implement methods which work for *all* our matrices.
80    
81  - Implement  expand(.) for the Cholesky() results  - Implement  expand(.) for the Cholesky() results
82    "dCHMsimpl" and  "dCHMsuper"  -- currently have no *decent* way to get at    "dCHMsimpl" and  "dCHMsuper"  -- currently have no *decent* way to get at
83    the matrix factors of the corresponding matrix factorization !!    the matrix factors of the corresponding matrix factorization !!
84    
85  - rbind(<sparse>, <dense>) does not work  (e.g. <dgC>, <dge>)  - rbind2(<sparse>, <dense>) does not work  (e.g. <dgC>, <dge>)
   
 - setAs(<Mcl>,  "[dln]Matrix" )  for <Mcl> in {Matrix or denseMatrix + sparseMatrix}  
   
 - Tell users about the possibility to disable the "S4-generic but somewhat slow"  
   cbind/rbind, e.g. via  
   
   setHook(packageEvent("Matrix", "onLoad"),  
           function(...) methods:::bind_activation(FALSE))  
   
 - ensure that  M[0], M[FALSE], M[1:2]  works as for traditional Matrices  
   
 - make sure  M[FALSE, FALSE]  works for all Matrices  
   {e.g. fails for M <- Diagonal(4)}  
86    
87  - <sparse> %*% <dense>  {also in crossprod/tcrossprod}  currently always  - <sparse> %*% <dense>  {also in crossprod/tcrossprod}  currently always
88    returns <dense>, since --> Csparse_dense_prod --> cholmod_sdmult    returns <dense>, since --> Csparse_dense_prod --> cholmod_sdmult
# Line 133  Line 95 
95    --> R/diagMatrix.R ('FIXME')    --> R/diagMatrix.R ('FIXME')
96    but also R/Ops.R  to ensure  sp-sym. + sp-sym. |-> sp-sym.  etc    but also R/Ops.R  to ensure  sp-sym. + sp-sym. |-> sp-sym.  etc
97    
98  - For a square sparse matrix 'b' {typically dgCMatrix or dgTMatrix},  - Diagonal(n) %*% A ---  too slow!! --> ~/R/MM/Pkg-ex/Matrix/diag-Tamas-ex.R
   we'd want a function  "Mat_plus_t_Mat" <- function(b) {....}  
   which computes the symmetric sparse matrix   b + t(b)  
   in way that never works with size-doubled vectors from  b@i etc..  
99    
100  - ! <symmetricMatrix>  loses symmetry, both for dense and sparse matrices.  - ! <symmetricMatrix>  loses symmetry, both for dense and sparse matrices.
101    !M  where M is "sparseMatrix", currently always gives dense. This only    !M  where M is "sparseMatrix", currently always gives dense. This only
102    makes sense when M is ``really sparse''.    makes sense when M is ``really sparse''.
103    
104  - column names of sparse matrices are not printed;  - msy <- as(matrix(c(2:1,1:2),2), "dsyMatrix"); str(msy)
105    we now "mention" them (if they are non-empty).  
106    Option:    shows that the Cholesky factorization is computed ``too quickly''.
107          build show( <sparseMatrix>) on a function, possibly    Can be a big pain for largish matrices, when it is unneeded.
108          print.sparseMatrix(), which gets an argument such as  
109          'col.names.show  = FALSE' which is documented and can be set to TRUE  - example(Cholesky, echo=FALSE) ; cm <- chol(mtm); str(cm); str(mtm)
110    
111  - 'arules' needs fast colSums() and rowSums() - for ngCMatrix;    shows that chol() does not seems to make use of an already
112    do it for "nMatrix" and "lMatrix" and return *integer*    present factorization and rather uses one with more '0' in x slot.
113    
114    - diag(m) <- val    currently automatically works via  m[cbind(i,i)] <- val
115      This (`[<-` method) is now "smart" for diagonalMatrix, but needs also to
116      be for triangularMatrix, and probably also "dense*general*Matrix" since the
117      above currently goes via "matrix" and back instead of using the 'x' slot
118      directly; in particular, the triangular* "class property" is lost!
119    
120    - image(M, ..): Think about an optional smart option which keeps
121       "0 |-> transparent" and allows colors to differentiate negative and
122       positive entries.
123    
124    - examples for solve( Cholesky(.), b, system = c("A", "LDLt"....))
125      probably rather in man/CHMfactor-class.Rd than man/Cholesky.Rd
126    
127    - tr(A %*% B) {and even  tr(A %*% B %*% C) ...} are also needed
128      frequently in some computations {conditional normal distr. ...}.
129      Since this can be done faster than by
130        sum(diag(A %*% B))  even for traditional matrices, e.g.
131                   sum(A * t(B)) or {even faster for "full" mat}
132                   crossprod(as.vector(A), as.vector(B))
133      and even more so for, e.g.  <sparse> %*% <dense>
134      {used in Soeren's 'gR' computations},
135      we should also provide a generic and methods.
136    
137    - qr.R(qr(x)) may differ for the "same" matrix, depending on it being
138      sparse or dense:
139        "qr.R(<sparse>) may differ from qr.R(<dense>) because of permutations"
140    
141      This is not really acceptable and currently influences  rcond() as well.
142    
143    - chol() and qr() generic:  currently have *two* arguments, and give the msg
144    
145      >  New generic for "chol" does not agree with implicit generic from package
146      >  "base"; a new generic will be assigned with package "Matrix"
147    
148      (and ditto for "qr")
149    
150      It was mentioned by an R-core member that he thought it did not make
151      sense to also dispatch on 'tol' or 'pivot' ...  --> maybe change that..
152    
153    - eigen() should become generic, and get a method at least for diagonal,
154      but also for symmetric -> dsyMatrix  [LAPACK dsyev() uses UPLO !],
155      but also simply for dgeMatrix (without going via tradition matrices).
156      What about Sparse?  There's fill-in, but it may still be sensible, e.g.
157      mlist <- list(1, 2:3, diag(x=5:3), 27, cbind(1,3:6), 100:101)
158      ee <- eigen(tcrossprod(bdiag(lapply(mlist, as.matrix))))
159      Matrix( signif(ee$vectors, 3) )
160    
161    - facmul() has no single method defined;  it looks like a good idea though
162      (instead of the infamous qr.qy, qr.qty,.... functions)
163    
164    - symmpart() and skewpart()  for *sparse* matrices still use (x +/- t(x))/2
165      and could be made more efficient.
166      Consider going via  asTuniq() or something very close to
167      .Arith.Csparse() in R/Ops.R
168    
169    - many setAs(*, "[dl]..Matrix") are still needed, as long as e.g.
170      replCmat() uses as_CspClass() and drop0(.) which itself call
171      as_CspClass() quite a bit.  --> try to replace these by
172      as(*, "CsparseMatrix"); forceSymmetric, etc.

Legend:
Removed from v.1887  
changed lines
  Added in v.2115

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