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 645, Tue Mar 15 00:51:42 2005 UTC revision 2005, Wed Jul 18 14:46:20 2007 UTC
# Line 1  Line 1 
1    Check for DimNames propagation in coercion and other operations.
2    ------
3    - rcond methods for sparseMatrix classes
4    
5  - Report the problem in the Linux ldexp manual page.  The second and  - Report the problem in the Linux ldexp manual page.  The second and
6    third calls in the Synopsis should be to ldexpf and ldexpl.    third calls in the Synopsis should be to ldexpf and ldexpl.
7    
8  - [,] indexing  - [,] indexing: for sparse "works", but not yet for negative indices!
   
 - group generics: "Arith" (partly done),  
   but also "Compare", "Math" etc;  
   see ?Math  and the examples in ?SetGeneric  
   
 - methods for rbind and cbind where they make sense  
9    
10  - consider moving alloc3Darray from ./src/Mutils.c to  - consider moving alloc3Darray from ./src/Mutils.c to
11    $(RSRC)/src/base/array.c    $(RSRC)/src/base/array.c
12    ------
13    - provide methods for "dspMatrix" and "dppMatrix"!
14    
15  - data/ : names 'mm' and even more 'y' are  ``too short''.  - implement (more) methods for supporting "packed" (symmetric / triangular)
16          If we really want to keep them, don't use "LazyData"    matrices; particularly something like pack() and unpack()  [to/from our
17          (such that one needs  data(*) explicitly);    classes from/to "numeric"] --- have already man/unpack.Rd but no method yet!
         But MM would rather want something like  ex.mm and ex.y  
18    
19  -  slot "factors" maybe should move up to "Matrix"    (have some dtr* <-> dtp*)
20    
21  -------  -----
22    
23  We have a (at least one) basic problem :  - combine the C functions for multiplication by special forms and
24     Currently the show() method fail sometime after coercion:    solution wrt special forms by using a 'right' argument and a
25     e.g. 'sy' show()s wrongly, even though it "str()" fine :    'classed' argument.
26       [done with dgeMatrix_matrix_mm();  not yet for other classes;
27        and for _crossprod()]
28    
29        (po <- crossprod(Matrix(0:3, 2))) # ok  - add more comprehensive examples / tests for Schur decomposition
       (ge <- as(po, "dgeMatrix")) # ok  
       (sy <- as(po, "dsyMatrix")) # BAD  
       str(sy) # looks fine  
30    
31    or  - arithmetic for sparse matrices:
32        example(expand) # -> ex$L and ex$U look bad, however               <sparseMatrix>  o  <same-dim-sparseMatrix>
33        as(ex$L, "dgeMatrix") # `works'    should return a sparse matrix  for at least "+" and "*" , also %%,
34      and "/" and "%/%" at least when the RHS is non-zero a scalar.
35      Challenge: nice implementation (``common non-0''; but Tsparse* is not uniq).
36    
37    {Of course, we don't need a workaround but must understand  -----
    and solve the problem}  
38    
39  ---  - "Math2" , "Math", "Arith":
40       keep triangular and symmetric Matrices when appropriate:
41       particularly desirable for  "Math2": round(), signif()
42    
43  - provide methods for "dspMatrix" and "dppMatrix"!  - "d" <-> "l" coercion for all "[TCR]" sparse matrices is really trivial:
44      "d" -> "l" : drops the 'x' slot
45      "l" -> "d" : construct an 'x' slot of all '1'
46      We currently have many of these conversions explicitly, e.g.
47       setAs("dsTMatrix", "lsTMatrix",
48          function(from) new("lsTMatrix", i = from@i, j = from@j, uplo = from@uplo,
49                             Dim = from@Dim, Dimnames = from@Dimnames))
50      but I would rather want to automatically construct all these coercion
51      methods at once by a ``method constructor'', i.e.,
52      for all  "dsparse*" -> "lsparse*" and vice versa.
53      How can one do this {in a documented way} ?
54    
55  - implement (more) methods for supporting "packed" (symmetric / triangular)  - tcrossprod(x, y) : do provide methods for y != NULL
56    matrices; particularly something like pack() and unpack()  [to/from our    calling Lapack's DGEMM for "dense"
57    classes from/to "numeric"] --- have already man/unpack.Rd but no method yet!    [2005-12-xx: done for dgeMatrix at least]
58    
59  - implement diagonal Matrix class  "ddiMatrix" etc  - BUGlet:  Shouldn't lose factorization here:
60    using constructor function Diagonal() or Diag().    h6 <- Hilbert(6); chol(h6) ; str(h6) # has factor
61      str(H6 <- as(h6, "dspMatrix"))       # has lost factor
62      ## and the same in a similar situation involving  "dpo", "dpp"
63    
64  ---  - Things like  M[upper.tri(M)] are not really most useful for  sparse
65      matrices.  --> provide generic functions
66      upperTriMatrix(), lowerTriMatrix()  both with argument  'diag = TRUE'
67      (which can be set to FALSE of course) which are used to extract a
68      triangle from an arbitrary sparse matrix and  return a  "dtCMatrix".
69    
70  - create a class of permutation matrices for use in expand.  The  - Factorizations: LU done; also Schur()  for  *sparse*  Matrices.
   current expand method for the LU factorization is not complete  
   because it does not provide the permutation.  
71    
72  - combine the C functions for multiplication by special forms and  - band(), triu(), tril() for *all* including "matrix", not just sparse matrices
73    solution wrt special forms by using a 'right' argument and a  
74    'classed' argument.  - is.na() method for all our matrices [ ==> which(*, arr.ind=TRUE) might work ]
75    
76    - When we have a packed matrix, it's a waste to go through "full" to "sparse":
77      ==> implement
78            setAs("dspMatrix", "sparseMatrix")
79            setAs("dppMatrix", "sparseMatrix")
80            setAs("dtpMatrix", "sparseMatrix")
81      and the same for "lsp" , "ltp"  and  "nsp" , "ntp" !
82    
83    - use  .Call(Csparse_drop, M, tol) in more places,
84      both with 'tol = 0.' to drop "values that happen to be 0" and for
85      zapsmall() methods for Csparse*
86    
87    - implement .Call(Csparse_scale, ....) interfacing to cholmod_scale()
88      in src/CHOLMOD/Include/cholmod_matrixops.h : for another function
89      specifically for multiplying a cholmod_sparse object by a diagonal matrix.
90      Use it in %*% and [t]crossprod methods.
91    
92    - chol() and determinant() should ``work'': proper result or "good" error
93      message.
94    
95    - Think of constructing  setAs(...) calls automatically in order to
96      basically enable all ``sensible'' as(fromMatrix, toMatrix)  calls,
97      possibly using canCoerce(.)
98    
99    - make sure *all* group methods have (maybe "bail-out") setMethod for "Matrix".
100      e.g. zapsmall(<pMatrix>) fails "badly"
101    
102    - speedup: pass class definition to non0ind() [check all calls ..]
103    
104    - sum(): implement methods which work for *all* our matrices.
105    
106    - Implement  expand(.) for the Cholesky() results
107      "dCHMsimpl" and  "dCHMsuper"  -- currently have no *decent* way to get at
108      the matrix factors of the corresponding matrix factorization !!
109    
110    - rbind(<sparse>, <dense>) does not work  (e.g. <dgC>, <dge>)
111    
112    - setAs(<Mcl>,  "[dln]Matrix" )  for <Mcl> in {Matrix or denseMatrix + sparseMatrix}
113    
114    - Tell users about the possibility to disable the "S4-generic but somewhat slow"
115      cbind/rbind, e.g. via
116    
117      setHook(packageEvent("Matrix", "onLoad"),
118              function(...) methods:::bind_activation(FALSE))
119    
120    - ensure that  M[0], M[FALSE], M[1:2]  works as for traditional Matrices
121    
122    - make sure  M[FALSE, FALSE]  works for all Matrices
123      {e.g. fails for M <- Diagonal(4)}
124    
125    - <sparse> %*% <dense>  {also in crossprod/tcrossprod}  currently always
126      returns <dense>, since --> Csparse_dense_prod --> cholmod_sdmult
127      and that does only return dense.
128      When the sparse matrix is very sparse, i.e. has many rows with only zero
129      entries, it would make much sense to return sparse.
130    
131    - sparse-symmetric + diagonal should stay sparse-symmetric
132      (only stays sparse): Matrix(0, 4, 4) + Diagonal(4, 1:4)
133      --> R/diagMatrix.R ('FIXME')
134      but also R/Ops.R  to ensure  sp-sym. + sp-sym. |-> sp-sym.  etc
135    
136    - For a square sparse matrix 'b' {typically dgCMatrix or dgTMatrix},
137      we'd want a function  "Mat_plus_t_Mat" <- function(b) {....}
138      which computes the symmetric sparse matrix   b + t(b)
139      in way that never works with size-doubled vectors from  b@i etc..
140    
141    - ! <symmetricMatrix>  loses symmetry, both for dense and sparse matrices.
142      !M  where M is "sparseMatrix", currently always gives dense. This only
143      makes sense when M is ``really sparse''.
144    
145    - log1p(<sparseMatrix>) "should" give <dsparseMatrix>
146      Pretty surely, this would happen automagically, if "log1p" became part of
147      "Math" group generic ---> which is the case from R 2.6.0 on
148    
149    - msy <- as(matrix(c(2:1,1:2),2), "dsyMatrix"); str(msy)
150    
151      shows that the Cholesky factorization is computed ``too quickly''.
152      Can be a big pain for largish matrices, when it is unneeded.
153    
154    - diag(m) <- val    currently automatically works via  m[cbind(i,i)] <- val
155      However,
156      we need methods for 'diag<-' at least for diagonalMatrix,
157      triangularMatrix, and probably also "dense*general*Matrix" since the
158      above currently goes via "matrix" and back instead of using the 'x' slot
159      directly.

Legend:
Removed from v.645  
changed lines
  Added in v.2005

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