1 /*
2 Copyright (C) 2011-2021 Michele Martone <michelemartone _AT_ users.sourceforge.net>
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 3 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 /*
19 * This obsolete wishlist. Patches are welcome!:
20 * adapt to when octave_idx_type is 64 bit long
21 * rsb_file_vec_save (1.1)
22 * all *.m files shall go to inst/
23 * switch to using bootstrap.sh (instead autogen.sh) and configure.ac with environment variables, so it can be called from pkg install sparsersb-1.0.4.tar.gz
24 * produce ../doc/sparsersb.txi; can use get_help_text
25 * put to ./devel/ what is not to be distributed
26 * make or configure should fail on missing library (actually it does not)
27 * spfind in order to update easily and quickly nonzeroes
28 * need A(IA,JA,VA)=nVA
29 * shall add "load"; implicit filename based is confusing
30 * shall rename "load"/"save" to "loadMatrixMarket"/... or something explicit
31 * save/load capability (in own, rsb format)
32 * should not rely on string_value().c_str() --- stack corruption danger!
33 * ("get","RSB_IO_WANT_...") is not yet available
34 * (.) is incomplete. it is needed by trace()
35 * (:,:) , (:,p): test with octave's bicg, bicgstab, cgs, ...
36 * hints about how to influence caching blocking policy
37 * compound_binary_op
38 * for thorough testing, see Octave's test/build_sparse_tests.sh
39 * sparsersb(rsbmat,"benchmark")
40 * sparsersb(rsbmat,"test")
41 * minimize data copies
42 * subsref, dotref, subsasgn are incomplete: need error messages there
43 * in full_value(), bool arg is ignored
44 * symmetry support is incomplete (scarcely defined)
45 * document semantics of update and access operators
46 * define more operators (e.g.: scaling) for 'complex'
47 * create a single error macro for constructors
48 * often missing array lenghts/type checks
49 * may define as map (see is_map) so that "a.type = ..." can work
50 * is_struct, find_nonzero_elem_idx are undefined
51 * are octave_triangular_conv, default_numeric_conversion_function ok ?
52 * error reporting is insufficient
53 * update to symmetric be forbidden or rather trigger a conversion ?
54 * after file read, return various structural info
55 * norm computation
56 * reformat code for readability
57 * warnings about incomplete complex implementation may be overzealous.
58 * need matrix exponentiation through conversion to octave format.
59 * Note: although librsb has been optimized for performance, sparsersb is not.
60 * Note: there are dangerous casts to rsb_coo_idx_t in subsasgn: for 64-bit octave_idx_type.
61 * adopt a higher C++ level when possible
62
63 * Developer notes:
64 http://www.gnu.org/software/octave/doc/interpreter/index.html
65 http://www.gnu.org/software/octave/doc/interpreter/Oct_002dFiles.html#Oct_002dFiles
66 http://octave.sourceforge.net/developers.html
67 */
68
69 #define RSBOI_WANT_PRINT_PCT_OCTAVE_STYLE 1
70
71 #include <octave/oct.h>
72 #define RSBOI_USE_PATCH_OCT44 (OCTAVE_MAJOR_VERSION>=5) || ( (OCTAVE_MAJOR_VERSION==4) && (OCTAVE_MINOR_VERSION>=4))
73 #if RSBOI_USE_PATCH_OCT44
74 #include <octave/variables.h>
75 #include <octave/interpreter.h>
76 #include <octave/mach-info.h>
77 #endif /* RSBOI_USE_PATCH_OCT44 */
78 #include <octave/ov-re-mat.h>
79 #include <octave/ov-re-sparse.h>
80 #include <octave/ov-bool-sparse.h> /* RSBOI_WANT_SPMTX_SUBSREF || RSBOI_WANT_SPMTX_SUBSASGN */
81 #include <octave/ov-scalar.h>
82 #include <octave/ov-complex.h>
83 #include <octave/ops.h>
84 #include <octave/ov-typeinfo.h>
85 #if RSBOI_WANT_PRINT_PCT_OCTAVE_STYLE
86 #include <iomanip> // std::setprecision
87 #endif
88 #include <rsb.h>
89
90 #if RSBOI_USE_PATCH_OCT44
91 /* transitional macros, new style */
92 #define RSBOI_TRY_BLK try
93 #define RSBOI_CATCH_BLK catch (octave::execution_exception& e) { goto err; }
94 #define RSBOI_IF_ERR(STMT)
95 #define RSBOI_IF_NERR(STMT) STMT
96 #define RSBOI_IF_NERR_STATE()
97 /* transitional macros, old style */
98 #else /* RSBOI_USE_PATCH_OCT44 */
99 #define RSBOI_IF_ERR(STMT) if ( error_state) STMT
100 #define RSBOI_IF_NERR(STMT) if (! error_state) STMT
101 #define RSBOI_IF_NERR_STATE() if (! error_state)
102 #endif /* RSBOI_USE_PATCH_OCT44 */
103
104 //#define RSBOI_VERBOSE_CONFIG 1 /* poor man's trace facility */
105 #ifdef RSBOI_VERBOSE_CONFIG /* poor man's trace facility */
106 #if (RSBOI_VERBOSE_CONFIG>0)
107 #define RSBOI_VERBOSE RSBOI_VERBOSE_CONFIG
108 #endif
109 #endif
110
111 #define RSBOI_USE_PATCH_38143 ( defined(OCTAVE_MAJOR_VERSION) && (OCTAVE_MAJOR_VERSION>=4) ) /* See http://savannah.gnu.org/bugs/?48335#comment5 */
112
113 #if 0
114 #define RSBOI_WARN( MSG ) \
115 octave_stdout << "Warning in "<<__func__<<"(), in file "<<__FILE__<<" at line "<<__LINE__<<":\n" << MSG;
116 #define RSBOI_FIXME( MSG ) RSBOI_WARN( MSG )/* new */
117 #else
118 #define RSBOI_WARN( MSG )
119 #endif
120 #define RSBOI_TODO( MSG ) RSBOI_WARN( MSG )/* new */
121 #define RSBOI_FIXME( MSG ) RSBOI_WARN( "FIXME: " MSG )/* new */
122
123 #define RSBOI_PRINTF( ... ) printf( __VA_ARGS__ )
124 #if RSBOI_VERBOSE
125 //printf("In file %20s (in %s) at line %10d:\n",__FILE__,__func__,__LINE__),
126 #define RSBOI_DEBUG_NOTICE( ... ) \
127 printf("In %s(), in file %s at line %10d:\n",__func__,__FILE__,__LINE__), \
128 printf( __VA_ARGS__ )
129 #if 0
130 #define RSBOI_ERROR( ... ) \
131 printf("In %s(), in file %s at line %10d:\n",__func__,__FILE__,__LINE__), \
132 printf( __VA_ARGS__ )
133 #else
134 #define RSBOI_ERROR( MSG ) \
135 octave_stdout << "In "<<__func__<<"(), in file "<<__FILE__<<" at line "<<__LINE__<<":\n"<<MSG
136 #endif
137 #define RSBOI_DUMP RSBOI_PRINTF
138 #else
139 #define RSBOI_DUMP( ... )
140 #define RSBOI_DEBUG_NOTICE( ... )
141 #define RSBOI_ERROR( ... )
142 #endif
143 #define RSBOI_EERROR( MSG ) \
144 octave_stdout << "In "<<__func__<<"(), in file "<<__FILE__<<" at line "<<__LINE__<<":\n"
145 #define RSBOI_TYPECODE RSB_NUMERICAL_TYPE_DOUBLE
146 #define RSBOI_RB RSB_DEFAULT_ROW_BLOCKING
147 #define RSBOI_CB RSB_DEFAULT_COL_BLOCKING
148 //#define RSBOI_RF RSB_FLAG_DEFAULT_STORAGE_FLAGS
149 #define RSBOI_RF RSB_FLAG_DEFAULT_RSB_MATRIX_FLAGS
150 #define RSBOI_DCF RSB_FLAG_DUPLICATES_SUM
151 #define RSBOI_NF RSB_FLAG_NOFLAGS
152 //#define RSBOI_EXPF RSB_FLAG_NOFLAGS
153 #define RSBOI_EXPF RSB_FLAG_IDENTICAL_FLAGS
154 #define RSBOI_T double
155 #undef RSB_FULLY_IMPLEMENTED
156 #define RSBOI_DESTROY(OM) {rsb_mtx_free(OM);(OM)=RSBOI_NULL;}
157 #define RSBOI_SOME_ERROR(ERRVAL) (ERRVAL)!=RSB_ERR_NO_ERROR
158 #define RSBOI_0_ERROR error
159 #define RSBOI_0_BADINVOERRMSG "invoking this function in the wrong way!\n"
160 #define RSBOI_0_ALLERRMSG "error allocating matrix!\n"
161 #define RSBOI_0_NOCOERRMSG "compiled without complex type support!\n"
162 #define RSBOI_0_NOTERRMSG "matrix is not triangular!\n"
163 #define RSBOI_0_ICSERRMSG "compiled with incomplete complex type support!\n"
164 #define RSBOI_0_EMERRMSG "data structure is corrupt (unexpected NULL matrix pointer)!\n"
165 #define RSBOI_0_ZODERRMG "are you trying to backsolve a matrix with zeros on the diagonal?\n" // sparsersb([0,0,0;1,0,0;1,1,1])\[1;1;1]
166 #define RSBOI_0_UNFFEMSG "unfinished feature\n"
167 #define RSBOI_0_INCFERRMSG "incomplete function!\n"
168 #define RSBOI_0_INMISMMSG "Index sizes of Octave differs from that of RSB:" " a conversion is needed, but yet unsupported in this version."
169 #define RSBOI_0_UNCFEMSG "complex support is yet incomplete\n"
170 #define RSBOI_0_NEEDERR "an error condition needs to be handled, here!\n"
171 #define RSBOI_0_UNCBERR "matrix NOT correctly built!\n"
172 #define RSBOI_0_ALERRMSG "error allocating an rsb matrix!\n"
173 #define RSBOI_0_WTRANSMSG "invalid transposition character!\n"
174 #define RSBOI_0_FATALNBMSG "fatal error! matrix NOT built!\n"
175 #define RSBOI_0_ASSERRMSG "assignment is still unsupported on 'sparse_rsb' matrices"
176 #define RSBOI_0_NSQERRMSG "matrix is not square"
177 #define RSBOI_0_NIYERRMSG "not implemented yet in sparsersb"
178 #define RSBOI_0_INTERRMSG "internal sparsersb error: this might be a bug -- please contact and tell us about this!"
179 #define RSBOI_0_INTERRMSGSTMT(STMT) {error ("%s", RSBOI_0_INTERRMSG);STMT;}
180 //#define RSBOI_0_INTERRMSGSTMT(STMT) STMT;
181 #define RSBOI_D_EMPTY_MSG ""
182 #define RSBOI_O_MISSIMPERRMSG "implementation missing here\n"
183 #define RSBOI_O_NPMSERR "providing non positive matrix size is not allowed!"
184 #define RSBOI_0_EMCHECK(M) if(!(M))RSBOI_0_ERROR(RSBOI_0_EMERRMSG);
185 #define RSBOI_FNSS(S) #S
186 #ifndef RSB_SPARSERSB_LABEL
187 #define RSB_SPARSERSB_LABEL sparsersb
188 #endif /* RSB_SPARSERSB_LABEL */
189 //#define RSBOI_FNS RSBOI_FNSS(RSB_SPARSERSB_LABEL)
190 #define RSBOI_FSTR "Recursive Sparse Blocks"
191 #define RSBOI_FNS "sparsersb"
192 #define RSBOI_LIS "?"
193
194 #define RSBIO_DEFAULT_CORE_MATRIX Matrix (0,0)
195 /* FIXME : octave_idx_type vs rsb_coo_idx_t */
196 #define RSBIO_NULL_STATEMENT_FOR_COMPILER_HAPPINESS {(void)1;}
197 #define RSBOI_OV_STRIDE 1
198 #define RSBOI_ZERO 0.0
199 //#define RSB_OI_DMTXORDER RSB_FLAG_WANT_ROW_MAJOR_ORDER
200 #define RSB_OI_DMTXORDER RSB_FLAG_WANT_COLUMN_MAJOR_ORDER /* for dense matrices (multivectors) */
201 #define RSB_OI_TYPEINFO_STRING "rsb sparse matrix"
202 #define RSB_OI_TYPEINFO_TYPE "double"
203
204 #ifdef RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX
205 #define RSBOI_WANT_DOUBLE_COMPLEX 1
206 #define ORSB_RSB_TYPE_FLAG(OBJ) (((OBJ).iscomplex())?RSB_NUMERICAL_TYPE_DOUBLE:RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX)
207 #else
208 #define RSBOI_WANT_DOUBLE_COMPLEX 0
209 #define ORSB_RSB_TYPE_FLAG(OBJ) RSB_NUMERICAL_TYPE_DOUBLE
210 #endif
211
212 #define RSBOI_USE_CXX11 ( defined(__cplusplus) && (__cplusplus>=201103L) )
213 #if defined(RSBOI_USE_CXX11)
214 #define RSBOI_NULL nullptr
215 #else /* RSBOI_USE_CXX11 */
216 #define RSBOI_NULL NULL
217 #endif /* RSBOI_USE_CXX11 */
218 #define RSBOI_INFOBUF 256
219 #define RSBOI_WANT_SYMMETRY 1
220 #define RSBOI_WANT_PRINT_DETAIL 0
221 #define RSBOI_WANT_PRINT_COMPLEX_OR_REAL 0
222 #define RSBOI_WANT_SUBSREF 1
223 #define RSBOI_WANT_HEAVY_DEBUG 0
224 #define RSBOI_WANT_VECLOAD_INSTEAD_MTX 1
225 #define RSBOI_WANT_MTX_LOAD 1
226 #define RSBOI_WANT_MTX_SAVE 1
227 #define RSBOI_WANT_POW 1
228 #define RSBOI_WANT_QSI 1 /* query string interface */
229 #define RSBOI_WANT_RESHAPE 1
230 #define RSBOI_WANT_SPMTX_SUBSREF 0 /* not yet there: need to accumulate in sparse */
231 #define RSBOI_WANT_SPMTX_SUBSASGN 1
232 #define RSBOI_WANT_OS_1D_IDX_ACCESS 1 /* Octave-style 1D index access */
233 #define RSBOI_WANT_EXPAND_SYMM 1 /* Expand symmetry when converting to sparse */
234 //#define RSBOI_PERROR(E) rsb_perror(E)
235 #define RSBOI_PERROR(E) if(RSBOI_SOME_ERROR(E)) rsboi_strerr(E)
236 #ifdef RSB_TRANSPOSITION_INVALID
237 #define RSBOI_INVALID_TRANS_CHAR RSB_TRANSPOSITION_INVALID /* since librsb-1.2.0.10 */
238 #else /* RSB_TRANSPOSITION_INVALID */
239 #define RSBOI_INVALID_TRANS_CHAR '?'
240 #endif /* RSB_TRANSPOSITION_INVALID */
241 #ifdef RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX
242 #include <octave/ov-cx-mat.h>
243 #include <octave/ov-cx-sparse.h>
244 #endif
245
246 #ifndef RSBOI_RSB_MATRIX_SOLVE
247 #define RSBOI_RSB_MATRIX_SOLVE(V1,V2) RSBOI_0_ERROR(RSBOI_0_NOTERRMSG) /* any solution routine shall attached here */
248 #endif
249
250 #if 1
251 extern "C" { rsb_err_t rsb_dump_postscript_from_mtx_t(const struct rsb_mtx_t *mtxAp, rsb_blk_idx_t br, rsb_blk_idx_t bc, int width, int height, rsb_bool_t all_nnz); }
252 extern "C" {
253 rsb_err_t rsb_dump_postscript_recursion_from_mtx_t(const struct rsb_mtx_t *mtxAp, rsb_blk_idx_t br, rsb_blk_idx_t bc, int width, int height, rsb_flags_t flags, rsb_bool_t want_blocks, rsb_bool_t z_dump , rsb_bool_t want_nonzeros ); }
254 #endif
255
256 #if RSBOI_WANT_HEAVY_DEBUG
257 extern "C" {
258 rsb_bool_t rsb_is_correctly_built_rcsr_matrix(const struct rsb_mtx_t *mtxAp); // forward declaration
259 }
260 #endif
261 #if !RSBOI_WANT_OS_1D_IDX_ACCESS
262 #if defined(RSB_LIBRSB_VER) && (RSB_LIBRSB_VER>=10100)
263 extern "C" {
264 #if (RSB_LIBRSB_VER<=10200)
265 int rsb_do_get_nnz_element(struct rsb_mtx_t *,void*,void*,void*,int);
266 #elif (RSB_LIBRSB_VER>=10300)
267 int rsb__do_get_nnz_element(struct rsb_mtx_t *,void*,void*,void*,int);
268 #define rsb_do_get_nnz_element rsb__do_get_nnz_element
269 #endif
270 }
271 #endif
272 #endif /* !RSBOI_WANT_OS_1D_IDX_ACCESS */
273 #if RSBOI_WANT_DOUBLE_COMPLEX
274 #define RSBOI_BINOP_PREVAILING_TYPE(V1,V2) (((V1).iscomplex()||(V2).iscomplex())?RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX:RSB_NUMERICAL_TYPE_DOUBLE)
275 #else
276 #define RSBOI_BINOP_PREVAILING_TYPE(V1,V2) RSBOI_TYPECODE
277 #endif
278 #if defined(RSB_LIBRSB_VER) && (RSB_LIBRSB_VER>=10100)
279 #define RSBOI_10100_DOCH \
280 "@deftypefnx {Loadable Function} " RSBOI_FNS " (@var{S},\"render\", @var{FILENAME}[, @var{rWidth}[, @var{rHeight}]])\n"\
281 "@deftypefnx {Loadable Function} {[@var{O} =]} " RSBOI_FNS " (@var{S},\"autotune\"[, @var{transA}[, @var{NRHS}[, @var{MAXR}[, @var{TMAX}[, @var{TN}[, @var{SF}]]]]]])\n"\
282
283 /* #define RSBOI_10100_DOC "If @var{S} is a " RSBOI_FNS " matrix and one of the \"render\",\"renderb\",\"renders\" keywords ... */
284 #define RSBOI_10100_DOC \
285 \
286 "If @var{S} is a @code{" RSBOI_FNS "} matrix and the @code{\"render\"} keyword is specified, and @var{FILENAME} is a string, @var{A} will be rendered as an Encapsulated Postscript file @var{FILENAME}. Optionally, width and height can be specified in @code{@var{rWidth}, @var{rHeight}}. Defaults are 512.\n"\
287 "\n"\
288 \
289 "If @var{S} is a @code{" RSBOI_FNS "} matrix and the @code{\"autotune\"} keyword is specified, autotuning of the matrix will take place, with SpMV and autotuning parameters. Parameters following the @code{\"autotune\"} string are optional. Parameter @var{transA} specifies whether to tune for untransposed (@code{\"N\"}) or transposed (@code{\"T\"}) or conjugated transposed (@code{\"C\"}); @var{NRHS} the number of right hand sides; @var{MAXR} the number of tuning rounds; @var{TMAX} the threads to use. If giving an output argument @var{O}, that will be assigned to the autotuned matrix, and the input one @var{A} will remain unchanged. See librsb documentation for @code{rsb_tune_spmm} to learn more.\n"
290 #else
291 #define RSBOI_10100_DOC ""
292 #define RSBOI_10100_DOCH ""
293 #endif
294
295 #define RSBOI_VERSION 100009 /* e.g. 100009 means 1.0.9 */
296
297 #if defined(USE_64_BIT_IDX_T) || defined(OCTAVE_ENABLE_64) || defined(RSBOI_DETECTED_LONG_IDX) /* 4.1.0+ / 4.0.3 / any */
298 #define RSBOI_O64_R32 1
299 #else /* USE_64_BIT_IDX_T */
300 #define RSBOI_O64_R32 0
301 #endif /* USE_64_BIT_IDX_T */
302
303 #define RSBOI_SIZEMAX RSB_MAX_MATRIX_DIM /* Upper limit to librsb matrix dimension. */
304
rsboi_idxv_overflow(const idx_vector & IM,const idx_vector & JM)305 static rsb_err_t rsboi_idxv_overflow( const idx_vector & IM, const idx_vector & JM)
306 {
307 rsb_err_t errval = RSB_ERR_NO_ERROR;
308
309 if( IM.extent(0) > RSBOI_SIZEMAX || JM.extent(0) > RSBOI_SIZEMAX )
310 errval = RSB_ERR_LIMITS;
311
312 return errval;
313 }
314
315 #if RSBOI_O64_R32
rsboi_idx_overflow(rsb_err_t * errvalp,octave_idx_type idx1,octave_idx_type idx2=0,octave_idx_type idx3=0)316 static rsb_err_t rsboi_idx_overflow( rsb_err_t *errvalp, octave_idx_type idx1, octave_idx_type idx2=0, octave_idx_type idx3=0)
317 {
318 rsb_err_t errval = RSB_ERR_NO_ERROR;
319
320 if( idx1 > RSBOI_SIZEMAX || idx2 > RSBOI_SIZEMAX || idx3 > RSBOI_SIZEMAX )
321 errval = RSB_ERR_LIMITS;
322 if( errvalp )
323 *errvalp = errval;
324
325 return errval;
326 }
327
rsboi_oi2ri(octave_idx_type * IP,rsb_nnz_idx_t nnz)328 static void rsboi_oi2ri( octave_idx_type * IP, rsb_nnz_idx_t nnz)
329 {
330 // octave_idx_type -> rsb_coo_idx_t
331 rsb_coo_idx_t * RP = (rsb_coo_idx_t *) IP;
332
333 const octave_idx_type * OP = (const octave_idx_type*) IP;
334 rsb_nnz_idx_t nzi;
335
336 for(nzi=0;nzi<nnz;++nzi)
337 RP[nzi] = OP[nzi];
338 }
339
rsboi_ri2oi(rsb_coo_idx_t * IP,rsb_nnz_idx_t nnz)340 static void rsboi_ri2oi( rsb_coo_idx_t * IP, rsb_nnz_idx_t nnz)
341 {
342 // rsb_coo_idx_t -> octave_idx_type
343 const rsb_coo_idx_t * RP = (const rsb_coo_idx_t *) IP;
344
345 octave_idx_type * OP = (octave_idx_type*) IP;
346 rsb_nnz_idx_t nzi;
347
348 for(nzi=0;nzi<nnz;++nzi)
349 OP[nnz-(nzi+1)]=RP[nnz-(nzi+1)];
350 }
351
rsboi_mtx_get_coo(const struct rsb_mtx_t * mtxAp,void * VA,octave_idx_type * IA,octave_idx_type * JA,rsb_flags_t flags)352 static rsb_err_t rsboi_mtx_get_coo(const struct rsb_mtx_t *mtxAp, void * VA, octave_idx_type * IA, octave_idx_type * JA, rsb_flags_t flags )
353 {
354 // assumes tacitly that rsboi_idx_overflow(IA[i],JA[i])==false for i in 0..nnzA-1.
355 rsb_err_t errval = RSB_ERR_NO_ERROR;
356
357 errval = rsb_mtx_get_coo(mtxAp, VA, (rsb_coo_idx_t *)IA, (rsb_coo_idx_t*)JA, flags );
358 rsb_nnz_idx_t nnzA = 0;
359 rsb_mtx_get_info(mtxAp,RSB_MIF_MATRIX_NNZ__TO__RSB_NNZ_INDEX_T,&nnzA); // FIXME: make this a member and use nnz()
360 rsboi_ri2oi((rsb_coo_idx_t *)IA,nnzA);
361 rsboi_ri2oi((rsb_coo_idx_t *)JA,nnzA);
362
363 return errval;
364 }
365
rsboi_mtx_alloc_from_csc_const(const void * VA,octave_idx_type * IA,octave_idx_type * CP,rsb_nnz_idx_t nnzA,rsb_type_t typecode,rsb_coo_idx_t nrA,rsb_coo_idx_t ncA,rsb_blk_idx_t brA,rsb_blk_idx_t bcA,rsb_flags_t flagsA,rsb_err_t * errvalp)366 static struct rsb_mtx_t *rsboi_mtx_alloc_from_csc_const(const void *VA, /*const*/ octave_idx_type * IA, /*const*/ octave_idx_type * CP, rsb_nnz_idx_t nnzA, rsb_type_t typecode, rsb_coo_idx_t nrA, rsb_coo_idx_t ncA, rsb_blk_idx_t brA, rsb_blk_idx_t bcA, rsb_flags_t flagsA, rsb_err_t *errvalp)
367 {
368 struct rsb_mtx_t *mtxAp = RSBOI_NULL;
369
370 if( RSBOI_SOME_ERROR(rsboi_idx_overflow(errvalp,nrA,ncA,nnzA) ) )
371 goto ret;
372 rsboi_oi2ri(IA,nnzA);
373 rsboi_oi2ri(CP,ncA+1);
374 mtxAp = rsb_mtx_alloc_from_csc_const(VA, (rsb_coo_idx_t *)IA, (rsb_coo_idx_t *)CP, nnzA, typecode, nrA, ncA, brA, bcA, flagsA, errvalp);
375 rsboi_ri2oi((rsb_coo_idx_t *)IA,nnzA);
376 rsboi_ri2oi((rsb_coo_idx_t *)CP,ncA+1);
377 ret:
378 return mtxAp;
379 }
380
rsboi_mtx_alloc_from_coo_const(const void * VA,octave_idx_type * IA,octave_idx_type * JA,rsb_nnz_idx_t nnzA,rsb_type_t typecode,rsb_coo_idx_t nrA,rsb_coo_idx_t ncA,rsb_blk_idx_t brA,rsb_blk_idx_t bcA,rsb_flags_t flagsA,rsb_err_t * errvalp)381 static struct rsb_mtx_t *rsboi_mtx_alloc_from_coo_const(const void *VA, /*const*/ octave_idx_type * IA, /*const*/ octave_idx_type * JA, rsb_nnz_idx_t nnzA, rsb_type_t typecode, rsb_coo_idx_t nrA, rsb_coo_idx_t ncA, rsb_blk_idx_t brA, rsb_blk_idx_t bcA, rsb_flags_t flagsA, rsb_err_t *errvalp)
382 {
383 struct rsb_mtx_t *mtxAp = RSBOI_NULL;
384
385 if( RSBOI_SOME_ERROR(rsboi_idx_overflow(errvalp,nrA,ncA,nnzA) ) )
386 goto ret;
387 rsboi_oi2ri(IA,nnzA);
388 rsboi_oi2ri(JA,nnzA);
389 mtxAp = rsb_mtx_alloc_from_coo_const(VA, (rsb_coo_idx_t *)IA, (rsb_coo_idx_t *)JA, nnzA, typecode, nrA, ncA, brA, bcA, flagsA, errvalp);
390 rsboi_ri2oi((rsb_coo_idx_t *)IA,nnzA);
391 rsboi_ri2oi((rsb_coo_idx_t *)JA,nnzA);
392 ret:
393 return mtxAp;
394 }
395 #else /* RSBOI_O64_R32 */
rsboi_mtx_get_coo(const struct rsb_mtx_t * mtxAp,void * VA,octave_idx_type * IA,octave_idx_type * JA,rsb_flags_t flags)396 static rsb_err_t rsboi_mtx_get_coo(const struct rsb_mtx_t *mtxAp, void * VA, octave_idx_type * IA, octave_idx_type * JA, rsb_flags_t flags )
397 {
398 rsb_err_t errval = RSB_ERR_NO_ERROR;
399 errval = rsb_mtx_get_coo(mtxAp, VA, IA, JA, flags );
400 return errval;
401 }
402
rsboi_mtx_alloc_from_csc_const(const void * VA,const octave_idx_type * IA,const octave_idx_type * CP,rsb_nnz_idx_t nnzA,rsb_type_t typecode,rsb_coo_idx_t nrA,rsb_coo_idx_t ncA,rsb_blk_idx_t brA,rsb_blk_idx_t bcA,rsb_flags_t flagsA,rsb_err_t * errvalp)403 static struct rsb_mtx_t *rsboi_mtx_alloc_from_csc_const(const void *VA, const octave_idx_type * IA, const octave_idx_type * CP, rsb_nnz_idx_t nnzA, rsb_type_t typecode, rsb_coo_idx_t nrA, rsb_coo_idx_t ncA, rsb_blk_idx_t brA, rsb_blk_idx_t bcA, rsb_flags_t flagsA, rsb_err_t *errvalp)
404 {
405 struct rsb_mtx_t *mtxAp = RSBOI_NULL;
406 mtxAp = rsb_mtx_alloc_from_csc_const(VA, IA, CP, nnzA, typecode, nrA, ncA, brA, bcA, flagsA, errvalp);
407 return mtxAp;
408 }
409
rsboi_mtx_alloc_from_coo_const(const void * VA,const octave_idx_type * IA,const octave_idx_type * JA,rsb_nnz_idx_t nnzA,rsb_type_t typecode,rsb_coo_idx_t nrA,rsb_coo_idx_t ncA,rsb_blk_idx_t brA,rsb_blk_idx_t bcA,rsb_flags_t flagsA,rsb_err_t * errvalp)410 static struct rsb_mtx_t *rsboi_mtx_alloc_from_coo_const(const void *VA, const octave_idx_type * IA, const octave_idx_type * JA, rsb_nnz_idx_t nnzA, rsb_type_t typecode, rsb_coo_idx_t nrA, rsb_coo_idx_t ncA, rsb_blk_idx_t brA, rsb_blk_idx_t bcA, rsb_flags_t flagsA, rsb_err_t *errvalp)
411 {
412 struct rsb_mtx_t *mtxAp = RSBOI_NULL;
413 mtxAp = rsb_mtx_alloc_from_coo_const(VA, IA, JA, nnzA, typecode, nrA, ncA, brA, bcA, flagsA, errvalp);
414 return mtxAp;
415 }
416 #endif /* RSBOI_O64_R32 */
417
rsboi_errstr(rsb_err_t errval)418 static std::string rsboi_errstr(rsb_err_t errval)
419 {
420 const int errstrlen = 128;
421 char errstr[errstrlen];
422
423 rsb_strerror_r(errval,errstr,errstrlen);
424 return errstr;
425 }
426
rsboi_strerr(rsb_err_t errval)427 static void rsboi_strerr(rsb_err_t errval)
428 {
429 const std::string errstr = rsboi_errstr(errval);
430
431 octave_stdout<<"librsb error:"<<errstr<<"\n";
432 }
433
rsboi_error(rsb_err_t errval)434 static void rsboi_error(rsb_err_t errval)
435 {
436 // may invoke this from RSBOI_ERROR
437 if(RSBOI_SOME_ERROR(errval))
438 {
439 const std::string errstr = "librsb error: " + rsboi_errstr(errval);
440 error ( "%s", errstr.c_str() );
441 }
442 }
443
RSBOI_ERRMSG(const std::string & errmsg)444 static void RSBOI_ERRMSG(const std::string & errmsg)
445 {
446 octave_stdout << "sparsersb error: " << errmsg << "\n";
447 }
448
449 struct rsboi_coo_matrix_t //** helper struct with non-owning pointers */
450 {
451 octave_idx_type * IA, * JA; /** row and columns indices */
452 octave_idx_type nrA,ncA; /** matrix rows, columns */
453 octave_idx_type nnzA; /** matrix (declared) nonzeros */
454 RSBOI_T * VA; /** values of data elements */
455 rsb_type_t typecode; /** as specified in the RSB_NUMERICAL_TYPE_* preprocessor symbols in types.h */
456 };
457
458 static const RSBOI_T rsboi_pone[] = {+1.0,0.0};
459 static const RSBOI_T rsboi_mone[] = {-1.0,0.0};
460 static const RSBOI_T rsboi_zero[] = { 0.0,0.0}; /* two elements, as shall work also with complex */
461
462 static octave_base_value *default_numeric_conversion_function (const octave_base_value& a);
463
sparsersb_tester(void)464 static bool sparsersb_tester(void)
465 {
466 #if (RSBOI_VERSION < 100002)
467 if(sizeof(octave_idx_type)!=sizeof(rsb_coo_idx_t))
468 {
469 RSBOI_ERRMSG(RSBOI_0_INMISMMSG);
470 goto err;
471 }
472 #else /* RSBOI_VERSION */
473 if(sizeof(octave_idx_type)< sizeof(rsb_coo_idx_t))
474 {
475 RSBOI_ERRMSG(RSBOI_0_INMISMMSG);
476 goto err;
477 }
478 #endif /* RSBOI_VERSION */
479 RSBOI_WARN(RSBOI_0_INCFERRMSG);
480 return true;
481 err:
482 return false;
483 }
484
485 static bool rsboi_sparse_rsb_loaded = false;
486
487 class octave_sparsersb_mtx : public octave_sparse_matrix
488 {
489 private:
490 public:
491 struct rsb_mtx_t *mtxAp;
492 public:
octave_sparsersb_mtx(void)493 octave_sparsersb_mtx (void) : octave_sparse_matrix(RSBIO_DEFAULT_CORE_MATRIX)
494 {
495 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
496 this->mtxAp = RSBOI_NULL;
497 }
498
octave_sparsersb_mtx(const octave_sparse_matrix & sm)499 octave_sparsersb_mtx (const octave_sparse_matrix &sm) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX)
500 {
501 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
502 }
503
504 #if RSBOI_WANT_MTX_LOAD
octave_sparsersb_mtx(const std::string & mtxfilename,rsb_type_t typecode=RSBOI_TYPECODE)505 octave_sparsersb_mtx (const std::string &mtxfilename, rsb_type_t typecode = RSBOI_TYPECODE) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX)
506 {
507 rsb_err_t errval = RSB_ERR_NO_ERROR;
508
509 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
510 if(!(this->mtxAp = rsb_file_mtx_load(mtxfilename.c_str(),RSBOI_RF,typecode,&errval)))
511 #if RSBOI_WANT_VECLOAD_INSTEAD_MTX
512 /* no problem */;
513 #else
514 RSBOI_ERRMSG(RSBOI_0_ALERRMSG);
515 RSBOI_PERROR(errval);
516 if(!this->mtxAp)
517 RSBOI_0_ERROR(RSBOI_0_ALLERRMSG);
518 #endif
519 }
520 #endif
521
522 //void alloc_rsb_mtx_from_coo_copy(const idx_vector &IM, const idx_vector &JM, const void * SMp, octave_idx_type nrA, octave_idx_type ncA, bool iscomplex=false, rsb_flags_t eflags=RSBOI_DCF)
alloc_rsb_mtx_from_coo_copy(idx_vector & IM,idx_vector & JM,const void * SMp,octave_idx_type nrA,octave_idx_type ncA,bool iscomplex=false,rsb_flags_t eflags=RSBOI_DCF)523 void alloc_rsb_mtx_from_coo_copy(idx_vector & IM, idx_vector & JM, const void * SMp, octave_idx_type nrA, octave_idx_type ncA, bool iscomplex=false, rsb_flags_t eflags=RSBOI_DCF)
524 {
525 const octave_idx_type nnzA = IM.length();
526 rsb_err_t errval = RSB_ERR_NO_ERROR;
527 #if RSBOI_WANT_DOUBLE_COMPLEX
528 const rsb_type_t typecode = iscomplex?RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX:RSB_NUMERICAL_TYPE_DOUBLE;
529 #else /* RSBOI_WANT_DOUBLE_COMPLEX */
530 const rsb_type_t typecode = RSBOI_TYPECODE;
531 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
532 const octave_idx_type *IA = RSBOI_NULL,*JA = RSBOI_NULL;
533 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
534 #if RSBOI_WANT_SYMMETRY
535 /* shall verify if any symmetry is present */
536 #endif
537
538 IA = (const octave_idx_type*)IM.raw();
539 JA = (const octave_idx_type*)JM.raw();
540
541 //RSB_DO_FLAG_ADD(eflags,rsb_util_determine_uplo_flags(IA,JA,nnzA));
542
543 if( (nrA==0 || ncA==0) && RSBOI_SOME_ERROR(errval=rsboi_idxv_overflow( IM, JM )))
544 goto err;
545
546 if(!(this->mtxAp = rsboi_mtx_alloc_from_coo_const(SMp,(octave_idx_type*)IA,(octave_idx_type*)JA,nnzA,typecode,nrA,ncA,RSBOI_RB,RSBOI_CB,RSBOI_RF|eflags ,&errval)))
547 RSBOI_ERRMSG(RSBOI_0_ALERRMSG);
548 err:
549 RSBOI_PERROR(errval);
550 if(!this->mtxAp)
551 RSBOI_0_ERROR(RSBOI_0_ALLERRMSG);
552 }
553
554 #if RSBOI_WANT_DOUBLE_COMPLEX
octave_sparsersb_mtx(idx_vector & IM,idx_vector & JM,const ComplexMatrix & SM,octave_idx_type nrA,octave_idx_type ncA,rsb_flags_t eflags)555 octave_sparsersb_mtx (idx_vector &IM, idx_vector &JM, const ComplexMatrix &SM,
556 octave_idx_type nrA, octave_idx_type ncA, rsb_flags_t eflags) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX)
557 {
558 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
559 this->alloc_rsb_mtx_from_coo_copy(IM,JM,SM.data(),nrA,ncA,true,eflags);
560 }
561 #endif
562
octave_sparsersb_mtx(idx_vector & IM,idx_vector & JM,const Matrix & SM,octave_idx_type nrA,octave_idx_type ncA,rsb_flags_t eflags)563 octave_sparsersb_mtx (idx_vector &IM, idx_vector &JM, const Matrix &SM,
564 octave_idx_type nrA, octave_idx_type ncA, rsb_flags_t eflags) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX)
565 {
566 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
567 this->alloc_rsb_mtx_from_coo_copy(IM,JM,SM.data(),nrA,ncA,false,eflags);
568 }
569
alloc_rsb_mtx_from_csc_copy(const SparseMatrix & sm)570 void alloc_rsb_mtx_from_csc_copy(const SparseMatrix &sm)
571 {
572 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
573 const octave_idx_type nrA = sm.rows ();
574 const octave_idx_type ncA = sm.cols ();
575 const rsb_nnz_idx_t nnzA = sm.nnz();
576 rsb_err_t errval = RSB_ERR_NO_ERROR;
577 rsb_flags_t eflags = RSBOI_RF;
578 const rsb_type_t typecode = RSB_NUMERICAL_TYPE_DOUBLE;
579
580 #if RSBOI_WANT_SYMMETRY
581 if(sm.issymmetric())
582 RSB_DO_FLAG_ADD(eflags,RSB_FLAG_LOWER_SYMMETRIC|RSB_FLAG_TRIANGULAR);
583 // It would be wise to have an isdiag() check and remove symmetry in that case.
584 #endif
585 if(!(this->mtxAp = rsboi_mtx_alloc_from_csc_const(sm.data(),sm.ridx(),sm.cidx(), nnzA,typecode, nrA, ncA, RSBOI_RB, RSBOI_CB, eflags,&errval)))
586 RSBOI_ERRMSG(RSBOI_0_ALLERRMSG);
587 RSBOI_PERROR(errval);
588 if(!this->mtxAp)
589 RSBOI_0_ERROR(RSBOI_0_ALLERRMSG);
590 }
591
octave_sparsersb_mtx(const Matrix & m)592 octave_sparsersb_mtx (const Matrix &m) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX)
593 {
594 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
595 SparseMatrix sm(m);
596 this->alloc_rsb_mtx_from_csc_copy(sm);
597 }
598
599 #if RSBOI_WANT_DOUBLE_COMPLEX
alloc_rsb_mtx_from_csc_copy(const SparseComplexMatrix & sm)600 void alloc_rsb_mtx_from_csc_copy(const SparseComplexMatrix &sm)
601 {
602 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
603 const octave_idx_type nrA = sm.rows ();
604 const octave_idx_type ncA = sm.cols ();
605 const octave_idx_type nnzA = sm.nnz ();
606 rsb_err_t errval = RSB_ERR_NO_ERROR;
607 rsb_flags_t eflags = RSBOI_RF;
608 const rsb_type_t typecode = RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX;
609
610 #if RSBOI_WANT_SYMMETRY
611 if(sm.ishermitian())
612 {
613 // It would be nice to have SparseComplexMatrix::isdiag() or SparseComplexMatrix::issymmetric() at our disposal here..
614 bool is_sym = false;
615
616 if(sm.issquare() && sm.nnz() <= sm.rows())
617 {
618 SparseComplexMatrix d = sm.diag();
619 if(!d.all_elements_are_real() && d.nnz() == sm.nnz())
620 is_sym = true; // diagoanl matrix with non-real on diagonal
621 }
622 if(is_sym)
623 RSB_DO_FLAG_ADD(eflags,RSB_FLAG_LOWER_SYMMETRIC|RSB_FLAG_TRIANGULAR);
624 else
625 RSB_DO_FLAG_ADD(eflags,RSB_FLAG_LOWER_HERMITIAN|RSB_FLAG_TRIANGULAR);
626 }
627 #endif
628 if(!(this->mtxAp = rsboi_mtx_alloc_from_csc_const(sm.data(),sm.ridx(),sm.cidx(), nnzA,typecode, nrA, ncA, RSBOI_RB, RSBOI_CB, eflags,&errval)))
629 RSBOI_ERRMSG(RSBOI_0_ALLERRMSG);
630 RSBOI_PERROR(errval);
631 if(!this->mtxAp)
632 RSBOI_0_ERROR(RSBOI_0_ALLERRMSG);
633 }
634
octave_sparsersb_mtx(const ComplexMatrix & cm)635 octave_sparsersb_mtx (const ComplexMatrix &cm) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX)
636 {
637 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
638 this->alloc_rsb_mtx_from_csc_copy(SparseComplexMatrix(cm));
639 }
640
octave_sparsersb_mtx(const SparseComplexMatrix & sm,rsb_type_t typecode=RSBOI_TYPECODE)641 octave_sparsersb_mtx (const SparseComplexMatrix &sm, rsb_type_t typecode = RSBOI_TYPECODE) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX)
642 {
643 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
644 this->alloc_rsb_mtx_from_csc_copy(sm);
645 }
646 #endif
647
octave_sparsersb_mtx(const SparseMatrix & sm,rsb_type_t typecode=RSBOI_TYPECODE)648 octave_sparsersb_mtx (const SparseMatrix &sm, rsb_type_t typecode = RSBOI_TYPECODE) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX)
649 {
650 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
651 this->alloc_rsb_mtx_from_csc_copy(sm);
652 }
653
octave_sparsersb_mtx(struct rsb_mtx_t * mtxBp)654 octave_sparsersb_mtx (struct rsb_mtx_t *mtxBp) : octave_sparse_matrix (RSBIO_DEFAULT_CORE_MATRIX), mtxAp(mtxBp)
655 {
656 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
657 if(!this->mtxAp)
658 RSBOI_0_ERROR(RSBOI_0_ALLERRMSG);
659 }
660
octave_sparsersb_mtx(const octave_sparsersb_mtx & T)661 octave_sparsersb_mtx (const octave_sparsersb_mtx& T) :
662 octave_sparse_matrix (T) {
663 rsb_err_t errval = RSB_ERR_NO_ERROR;
664 struct rsb_mtx_t *mtxBp = RSBOI_NULL;
665
666 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
667 errval = rsb_mtx_clone(&mtxBp,RSB_NUMERICAL_TYPE_SAME_TYPE,RSB_TRANSPOSITION_N,RSBOI_NULL,T.mtxAp,RSBOI_EXPF);
668 RSBOI_PERROR(errval);
669 this->mtxAp = mtxBp;
670 };
length(void) const671 octave_idx_type length (void) const { return this->nnz(); }
nelem(void) const672 octave_idx_type nelem (void) const { return this->nnz(); }
numel(void) const673 octave_idx_type numel (void) const { RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG); return this->nnz(); }
nnz(void) const674 octave_idx_type nnz (void) const { rsb_nnz_idx_t nnzA = 0; RSBOI_0_EMCHECK(this->mtxAp); rsb_mtx_get_info(this->mtxAp,RSB_MIF_MATRIX_NNZ__TO__RSB_NNZ_INDEX_T,&nnzA); return nnzA;}
dims(void) const675 dim_vector dims (void) const { RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG); return (dim_vector(this->rows(),this->cols())); }
dim1(void) const676 octave_idx_type dim1 (void) const { return this->rows(); }
dim2(void) const677 octave_idx_type dim2 (void) const { return this->cols(); }
rows(void) const678 octave_idx_type rows (void) const { rsb_coo_idx_t Anr=0; RSBOI_0_EMCHECK(this->mtxAp); rsb_mtx_get_info(this->mtxAp,RSB_MIF_MATRIX_ROWS__TO__RSB_COO_INDEX_T,&Anr); return Anr;}
cols(void) const679 octave_idx_type cols (void) const { rsb_coo_idx_t Anc=0; RSBOI_0_EMCHECK(this->mtxAp); rsb_mtx_get_info(this->mtxAp,RSB_MIF_MATRIX_COLS__TO__RSB_COO_INDEX_T,&Anc); return Anc;}
rsbflags(void) const680 rsb_flags_t rsbflags(void) const { rsb_flags_t Aflags=0; RSBOI_0_EMCHECK(this->mtxAp); rsb_mtx_get_info(this->mtxAp,RSB_MIF_MATRIX_FLAGS__TO__RSB_FLAGS_T,&Aflags); return Aflags;}
rsbtype(void) const681 rsb_type_t rsbtype(void) const { rsb_type_t Atype=0; RSBOI_0_EMCHECK(this->mtxAp); rsb_mtx_get_info(this->mtxAp,RSB_MIF_MATRIX_TYPECODE__TO__RSB_TYPE_T,&Atype); return Atype;}
682 //octave_idx_type rows (void) const { RSBOI_0_EMCHECK(this->mtxAp);return this->mtxAp->nrA; }
683 //octave_idx_type cols (void) const { RSBOI_0_EMCHECK(this->mtxAp);return this->mtxAp->ncA; }
columns(void) const684 octave_idx_type columns (void) const { return this->cols(); }
nzmax(void) const685 octave_idx_type nzmax (void) const { return this->nnz(); }
capacity(void) const686 octave_idx_type capacity (void) const { return this->nnz(); }
byte_size(void) const687 size_t byte_size (void) const { RSBOI_0_EMCHECK(this->mtxAp);size_t so=0;rsb_mtx_get_info(this->mtxAp,RSB_MIF_TOTAL_SIZE__TO__SIZE_T,&so);return so; }
688
~octave_sparsersb_mtx(void)689 virtual ~octave_sparsersb_mtx (void)
690 {
691 RSBOI_DEBUG_NOTICE("destroying librsb matrix %p\n",this->mtxAp);
692 RSBOI_DESTROY(this->mtxAp);
693 }
694
clone(void) const695 virtual octave_base_value *clone (void) const
696 {
697 RSBOI_DEBUG_NOTICE("cloning librsb matrix %p\n",this->mtxAp);
698 return new octave_sparsersb_mtx (*this);
699 }
700
empty_clone(void) const701 virtual octave_base_value *empty_clone (void) const
702 {
703 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
704 return new octave_sparsersb_mtx ();
705 }
706
sparse_matrix_value(bool=false) const707 virtual SparseMatrix sparse_matrix_value(bool = false)const
708 {
709 struct rsboi_coo_matrix_t rcm;
710 rsb_err_t errval = RSB_ERR_NO_ERROR;
711 rsb_nnz_idx_t nzi;
712 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
713 RSBOI_0_EMCHECK(this->mtxAp);
714 const rsb_nnz_idx_t nnzA = this->nnz();
715 #if RSBOI_WANT_EXPAND_SYMM
716 const rsb_nnz_idx_t e = (is__symmetric() || is__hermitian()) ? 2 : 1;
717 rsb_nnz_idx_t nze = 0;
718 #else
719 const rsb_nnz_idx_t e = 1;
720 const rsb_nnz_idx_t nze = 0;
721 #endif
722 Array<octave_idx_type> IA( dim_vector(1,nnzA*e) );
723 Array<octave_idx_type> JA( dim_vector(1,nnzA*e) );
724 Array<RSBOI_T> VA( dim_vector(1,nnzA*e) );
725
726 rcm.IA = (octave_idx_type*)IA.data();
727 rcm.JA = (octave_idx_type*)JA.data();
728 if(!this->is_real_type())
729 {
730 Array<Complex> VAC( dim_vector(1,nnzA*e) );
731 RSBOI_T* VAp = ((RSBOI_T*)VA.data());
732 rcm.VA = (RSBOI_T*)VAC.data();
733
734 errval = rsboi_mtx_get_coo(this->mtxAp,rcm.VA,rcm.IA,rcm.JA,RSB_FLAG_C_INDICES_INTERFACE);
735 for(nzi=0;nzi<nnzA;++nzi)
736 VAp[nzi]=rcm.VA[2*nzi];
737 }
738 else
739 {
740 rcm.VA = (RSBOI_T*)VA.data();
741 errval = rsboi_mtx_get_coo(this->mtxAp,rcm.VA,rcm.IA,rcm.JA,RSB_FLAG_C_INDICES_INTERFACE);
742 }
743 RSBOI_PERROR(errval);
744
745 #if RSBOI_WANT_EXPAND_SYMM
746 if(e==2)
747 {
748 for(nzi=0;nzi<nnzA;++nzi)
749 if ( rcm.IA [nzi] != rcm.JA[nzi] )
750 {
751 rcm.VA[nnzA+nze]=rcm.VA[nzi];
752 rcm.JA [nnzA+nze] = rcm.IA[nzi];
753 rcm.IA [nnzA+nze] = rcm.JA[nzi];
754 nze++;
755 }
756 }
757
758 VA.resize1(nnzA + nze);
759 IA.resize1(nnzA + nze);
760 JA.resize1(nnzA + nze);
761 #endif
762 rcm.nrA = this->rows();
763 rcm.ncA = this->cols();
764
765 return SparseMatrix(VA,IA,JA,rcm.nrA,rcm.ncA);
766 }
767
matrix_value(bool=false) const768 virtual Matrix matrix_value(bool = false)const
769 {
770 RSBOI_FIXME("inefficient!");
771 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
772 const Matrix cm = this->sparse_matrix_value().matrix_value();
773 return cm;
774 }
775
full_sym_real_value(void) const776 virtual Matrix full_sym_real_value(void)const
777 {
778 // Conversion to full, with symmetry expansion.
779 RSBOI_FIXME("inefficient (see transpose)!");
780 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
781
782 const octave_idx_type rn = this->rows(), cn = this->cols();
783 Matrix v2(rn,cn,RSBOI_ZERO);
784 rsb_err_t errval = RSB_ERR_NO_ERROR;
785
786 errval |= rsb_mtx_add_to_dense(&rsboi_pone,this->mtxAp,rn,rn,cn,RSB_BOOL_TRUE,(RSBOI_T*)v2.data());
787 rsboi_error(errval);
788 for(int i = 0; i<rn; ++i)
789 v2(i,i) = RSBOI_ZERO;
790 v2 = v2.transpose();
791 errval |= rsb_mtx_add_to_dense(&rsboi_pone,this->mtxAp,rn,rn,cn,RSB_BOOL_TRUE,(RSBOI_T*)v2.data());
792 if(RSBOI_SOME_ERROR(errval))
793 RSBOI_0_ERROR(RSBOI_0_NOCOERRMSG);
794 return v2;
795 }
796
full_sym_cplx_value(void) const797 virtual ComplexMatrix full_sym_cplx_value(void)const
798 {
799 // Conversion to full, with symmetry expansion.
800 RSBOI_FIXME("inefficient (see transpose)!");
801 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
802 const octave_idx_type rn = this->rows(), cn = this->cols();
803 ComplexMatrix v2(rn,cn,RSBOI_ZERO);
804 rsb_err_t errval = RSB_ERR_NO_ERROR;
805
806 errval |= rsb_mtx_add_to_dense(&rsboi_pone,this->mtxAp,rn,rn,cn,RSB_BOOL_TRUE,(RSBOI_T*)v2.data());
807 rsboi_error(errval);
808 for(int i = 0; i<rn; ++i)
809 v2(i,i) = RSBOI_ZERO;
810 v2 = v2.transpose();
811 errval |= rsb_mtx_add_to_dense(&rsboi_pone,this->mtxAp,rn,rn,cn,RSB_BOOL_TRUE,(RSBOI_T*)v2.data());
812 if(RSBOI_SOME_ERROR(errval))
813 RSBOI_0_ERROR(RSBOI_0_NOCOERRMSG);
814 return v2;
815 }
816
full_value(void) const817 virtual octave_value full_value(void)const
818 {
819 RSBOI_FIXME("inefficient!");
820 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
821
822 if(is__symmetric() || is__hermitian())
823 {
824 if(this->is_real_type())
825 return this->full_sym_real_value();
826 else
827 return this->full_sym_cplx_value();
828 }
829 else
830 {
831 if(this->is_real_type())
832 return this->matrix_value();
833 else
834 return this->complex_matrix_value();
835 }
836 }
837
838 #if RSBOI_WANT_DOUBLE_COMPLEX
complex_matrix_value(bool=false) const839 virtual ComplexMatrix complex_matrix_value(bool = false)const
840 {
841 RSBOI_FIXME("inefficient!");
842 const octave_sparse_complex_matrix ocm = this->sparse_complex_matrix_value();
843 const ComplexMatrix cm = ocm.complex_matrix_value();
844 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
845 return cm;
846 }
847
sparse_complex_matrix_value(bool=false) const848 virtual SparseComplexMatrix sparse_complex_matrix_value(bool = false)const
849 {
850 struct rsboi_coo_matrix_t rcm;
851 rsb_err_t errval = RSB_ERR_NO_ERROR;
852 rsb_nnz_idx_t nzi;
853 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
854 RSBOI_0_EMCHECK(this->mtxAp);
855 const rsb_nnz_idx_t nnzA = this->nnz();
856 #if RSBOI_WANT_EXPAND_SYMM
857 const rsb_nnz_idx_t e = (is__symmetric() || is__hermitian()) ? 2 : 1;
858 rsb_nnz_idx_t nze = 0;
859 #else
860 const rsb_nnz_idx_t e = 1;
861 const rsb_nnz_idx_t nze = 0;
862 #endif
863 Array<octave_idx_type> IA( dim_vector(1,nnzA*e) );
864 Array<octave_idx_type> JA( dim_vector(1,nnzA*e) );
865 Array<Complex> VA( dim_vector(1,nnzA*e) );
866 RSBOI_T* VAp = ((RSBOI_T*)VA.data());
867
868 rcm.IA = (octave_idx_type*)IA.data();
869 rcm.JA = (octave_idx_type*)JA.data();
870 rcm.VA = VAp;
871 errval = rsboi_mtx_get_coo(this->mtxAp,rcm.VA,rcm.IA,rcm.JA,RSB_FLAG_C_INDICES_INTERFACE);
872 RSBOI_PERROR(errval);
873
874 if(this->is_real_type())
875 for(nzi=0;nzi<nnzA;++nzi)
876 VAp[2*(nnzA-1-nzi)+0]=VAp[(nnzA-1-nzi)+0],
877 VAp[2*(nnzA-1-nzi)+1]=0;
878 #if RSBOI_WANT_EXPAND_SYMM
879 if(e==2)
880 {
881 for(nzi=0;nzi<nnzA;++nzi)
882 if ( rcm.IA [nzi] != rcm.JA[nzi] )
883 {
884 if(this->is_real_type())
885 rcm.VA[nnzA+nze]=rcm.VA[nzi];
886 else
887 {
888 if(is__hermitian())
889 ((Complex*)rcm.VA)[nnzA+nze]=conj(((Complex*)rcm.VA)[nzi]);
890 else
891 ((Complex*)rcm.VA)[nnzA+nze]= (((Complex*)rcm.VA)[nzi]);
892 }
893 rcm.JA [nnzA+nze] = rcm.IA[nzi];
894 rcm.IA [nnzA+nze] = rcm.JA[nzi];
895 nze++;
896 }
897 }
898
899 VA.resize1(nnzA + nze);
900 IA.resize1(nnzA + nze);
901 JA.resize1(nnzA + nze);
902 #endif
903 rcm.nrA = this->rows();
904 rcm.ncA = this->cols();
905
906 return SparseComplexMatrix(VA,IA,JA,rcm.nrA,rcm.ncA);
907 }
908 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
909
910 //octave_value::assign_op, int, int, octave_value (&)(const octave_base_value&, const octave_base_value&)
911 //octave_value::assign_op, int, int, octave_value (&)
912 //octave_value assign_op (const octave_base_value&, const octave_base_value&) {}
913 // octave_value::assign_op octave_value::binary_op_to_assign_op (binary_op op) { assign_op retval; return retval; }
914
915 #if RSBOI_WANT_SUBSREF
916
do_index_op_subsparse(const idx_vector & i) const917 octave_value do_index_op_subsparse(const idx_vector & i) const
918 {
919 // Convert to Octave's sparse and reconvert.
920 // check with
921 // octave --eval "nnz(sparse((toeplitz(sparsersb([0,1,2,3]))-toeplitz(sparse([0,1,2,3])))))==0"
922 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
923 octave_value retval;
924
925 if(is_real_type())
926 retval = new octave_sparsersb_mtx ( SparseMatrix(sparse_matrix_value().index(i)) );
927 else
928 retval = new octave_sparsersb_mtx ( SparseComplexMatrix(sparse_complex_matrix_value().index(i)) );
929 return retval;
930 }
931
do_index_op(const octave_value_list & idx,bool resize_ok=false)932 octave_value do_index_op(const octave_value_list& idx, bool resize_ok = false)
933 {
934 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
935 rsb_err_t errval = RSB_ERR_NO_ERROR;
936 octave_value retval;
937
938 //if (type.length () == 1)
939 {
940 const octave_idx_type n_idx = idx.length ();
941 if (n_idx == 0 )
942 retval = clone();
943 else
944 if (n_idx == 1 )
945 {
946 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
947 #if RSBOI_WANT_SPMTX_SUBSREF
948 const octave_value_list ovl = idx;
949 if(ovl(0).issparse())
950 {
951 SparseBoolMatrix sm = SparseBoolMatrix (ovl(0).sparse_matrix_value());
952 const octave_idx_type * ir = sm.mex_get_ir ();
953 const octave_idx_type * jc = sm.mex_get_jc ();
954 const octave_idx_type nr = sm.rows ();
955 const octave_idx_type nc = sm.cols ();
956 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
957
958 for (octave_idx_type j = 0; j < nc; j++)
959 {
960 std::cout << jc[j] << ".." << jc[j+1] << "\n";
961 for (octave_idx_type i = jc[j]; i < jc[j+1]; i++)
962 {
963 std::cout << ir[i] << " " << j << "\n";
964 }
965 }
966 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
967 retval = octave_value(this->clone()); // matches but .. heavy ?!
968 }
969 else
970 #endif /* RSBOI_WANT_SPMTX_SUBSREF */
971 {
972 const idx_vector i = idx (0).index_vector ();
973 #if defined(RSB_LIBRSB_VER) && (RSB_LIBRSB_VER< 10100)
974 const octave_idx_type ii = i(0);
975 RSBOI_ERRMSG("You are using a very old and limited version of librsb: no support for this kind of access\n");
976 #elif defined(RSB_LIBRSB_VER) && (RSB_LIBRSB_VER>=10100)
977 #if RSBOI_WANT_RESHAPE
978 if( i.is_colon() )
979 {
980 retval = this->reshape(dim_vector (this->rows()*this->cols(),1));
981 goto err;
982 }
983 if( i.is_range() )
984 {
985 if(is_real_type())
986 retval = new octave_sparsersb_mtx ( SparseMatrix(sparse_matrix_value().index(i)) );
987 else
988 retval = new octave_sparsersb_mtx ( SparseComplexMatrix(sparse_complex_matrix_value().index(i)) );
989 goto err;
990 }
991 #endif /* RSBOI_WANT_RESHAPE */
992 RSBOI_DEBUG_NOTICE("i.length () = %d\n",i.length());
993 if(i.length()>1)
994 {
995 retval = do_index_op_subsparse(i);
996 goto err;
997 }
998 #if RSBOI_WANT_OS_1D_IDX_ACCESS
999 const rsb_coo_idx_t jj = (i(0) / rows());
1000 const rsb_coo_idx_t ii = (i(0) % rows());
1001 RSBOI_DEBUG_NOTICE("get_element (%d,%d)\n",ii,ii);
1002 if(is_real_type())
1003 {
1004 RSBOI_T rv;
1005 //errval = rsb_do_get_nnz_element(this->mtxAp,&rv,RSBOI_NULL,RSBOI_NULL,ii);
1006 errval = rsb_mtx_get_values(this->mtxAp,&rv,&ii,&jj,1,RSBOI_NF);
1007 retval = rv;
1008 }
1009 else
1010 {
1011 Complex rv { RSBOI_ZERO, RSBOI_ZERO };
1012 //errval = rsb_do_get_nnz_element(this->mtxAp,&rv,RSBOI_NULL,RSBOI_NULL,ii);
1013 errval = rsb_mtx_get_values(this->mtxAp,&rv,&ii,&jj,1,RSBOI_NF);
1014 retval = rv;
1015 }
1016 if(RSBOI_SOME_ERROR(errval))
1017 {
1018 if(ii>=this->rows() || ii<0 || jj>=this->cols() || jj<0)
1019 error ("trying accessing element %ld,%ld: index out of bounds !",(long int)ii+1,(long int)jj+1);
1020 else
1021 ; /* likely a zero */
1022 }
1023 #endif /* RSBOI_WANT_OS_1D_IDX_ACCESS */
1024 #endif
1025 }
1026 }
1027 else
1028 if (n_idx == 2 )
1029 {
1030 RSBOI_TRY_BLK
1031 {
1032 const idx_vector i = idx (0).index_vector ();
1033 RSBOI_IF_NERR_STATE()
1034 {
1035 #if RSBOI_WANT_SYMMETRY
1036 /* Will expand (:,:) but won't access empty-triangle nonzeros. */
1037 #endif
1038 #if RSBOI_WANT_RESHAPE
1039 if( idx(0).index_vector ().is_colon() || idx(1).index_vector ().is_colon() )
1040 {
1041 if(is_real_type())
1042 {
1043 octave_sparse_matrix osm (sparse_matrix_value());
1044 retval = osm.do_index_op(idx);
1045 }
1046 else
1047 {
1048 octave_sparse_complex_matrix osm (sparse_complex_matrix_value());
1049 retval = osm.do_index_op(idx);
1050 }
1051 goto err;
1052 }
1053 #endif /* RSBOI_WANT_RESHAPE */
1054 if(is_real_type())
1055 {
1056 const idx_vector j = idx (1).index_vector ();
1057 RSBOI_T rv;
1058 rsb_coo_idx_t ii = -1, jj = -1;
1059 ii = i(0); jj = j(0);
1060 RSBOI_DEBUG_NOTICE("get_elements (%d %d)\n",ii,jj);
1061 errval = rsb_mtx_get_values(this->mtxAp,&rv,&ii,&jj,1,RSBOI_NF);
1062 retval = rv;
1063 RSBOI_IF_NERR(;)
1064 }
1065 else
1066 {
1067 const idx_vector j = idx (1).index_vector ();
1068 Complex rv;
1069 rsb_coo_idx_t ii =-1, jj = -1;
1070 ii = i(0); jj = j(0);
1071 RSBOI_DEBUG_NOTICE("get_elements (%d %d) complex\n",ii,jj);
1072 errval = rsb_mtx_get_values(this->mtxAp,&rv,&ii,&jj,1,RSBOI_NF);
1073 retval = rv;
1074 RSBOI_IF_NERR(;)
1075 }
1076 }
1077 }
1078 RSBOI_CATCH_BLK
1079 }
1080 }
1081 err:
1082 return retval;
1083 }
1084
1085 #if RSBOI_WANT_RESHAPE
reshape(const dim_vector & new_dims) const1086 octave_value reshape (const dim_vector& new_dims) const
1087 {
1088 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1089 RSBOI_WARN(RSBOI_0_UNFFEMSG);
1090 octave_value retval;
1091
1092 if(is_real_type())
1093 retval = new octave_sparsersb_mtx ( sparse_matrix_value().reshape(new_dims) );
1094 else
1095 retval = new octave_sparsersb_mtx ( sparse_complex_matrix_value().reshape(new_dims) );
1096 return retval;
1097 }
1098 #endif /* RSBOI_WANT_RESHAPE */
1099
subsref(const std::string & type,const std::list<octave_value_list> & idx)1100 octave_value subsref (const std::string &type, const std::list<octave_value_list>& idx)
1101 {
1102 octave_value retval;
1103 const int skip = 1;
1104 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1105
1106 RSBOI_TRY_BLK
1107 {
1108 switch (type[0])
1109 {
1110 case '(':
1111 retval = do_index_op(idx.front());
1112 break;
1113
1114 case '.':
1115 RSBOI_DEBUG_NOTICE("UNFINISHED\n");
1116 break;
1117
1118 case '{':
1119 error ("%s cannot be indexed with %c", type_name().c_str(), type[0]);
1120 break;
1121
1122 default:
1123 panic_impossible ();
1124 }
1125 }
1126 RSBOI_CATCH_BLK
1127 RSBOI_IF_NERR(
1128 retval = retval.next_subsref (type, idx, skip);
1129 )
1130 err:
1131 return retval;
1132 } /* subsref */
1133 #else /* RSBOI_WANT_SUBSREF */
1134 /* FIXME: need an alternative, bogus implementation of subsref */
1135 #endif /* RSBOI_WANT_SUBSREF */
1136
dotref(const octave_value_list & idx)1137 octave_value_list dotref (const octave_value_list& idx)
1138 {
1139 octave_value_list retval;
1140
1141 const std::string nm = idx(0).string_value ();
1142 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1143
1144 /* if (nm == "type")
1145 if (isupper ())
1146 retval = octave_value ("Upper");
1147 else
1148 retval = octave_value ("Lower");
1149 else*/
1150 error ("%s can indexed with .%s",
1151 type_name().c_str(), nm.c_str());
1152
1153 return retval;
1154 }
1155
is_map(void) const1156 bool is_map (void) const { return true; }
issparse(void) const1157 bool issparse(void) const { RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);return true; }
is_real_type(void) const1158 bool is_real_type (void) const { RSBOI_0_EMCHECK(this->mtxAp); RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);return this->rsbtype()==RSB_NUMERICAL_TYPE_DOUBLE?true:false; }
is_diagonal(void) const1159 bool is_diagonal (void) const { RSBOI_0_EMCHECK(this->mtxAp); RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);return RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_DIAGONAL)?true:false; }/* FIXME: new: not sure whether this is ever called */
is_lower_triangular(void) const1160 bool is_lower_triangular (void) const { RSBOI_0_EMCHECK(this->mtxAp); RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);return RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_LOWER_TRIANGULAR)?true:false; }/* FIXME: new: not sure whether this is ever called */
is_upper_triangular(void) const1161 bool is_upper_triangular (void) const { RSBOI_0_EMCHECK(this->mtxAp); RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);return RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_UPPER_TRIANGULAR)?true:false; }/* FIXME: new: not sure whether this is ever called */
iscomplex(void) const1162 bool iscomplex (void) const { RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG); return !is_real_type(); }
isreal(void) const1163 bool isreal (void) const { RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG); return is_real_type(); }
is_bool_type(void) const1164 bool is_bool_type (void) const { return false; }
isinteger(void) const1165 bool isinteger (void) const { return false; }
is_square(void) const1166 bool is_square (void) const { return this->rows()==this->cols(); }
is_empty(void) const1167 bool is_empty (void) const { return false; }
is__symmetric(void) const1168 bool is__symmetric (void) const { if(RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_SYMMETRIC))return true; return false; }
is__hermitian(void) const1169 bool is__hermitian (void) const { if(RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_HERMITIAN))return true; return false; }
get_symmetry(void) const1170 std::string get_symmetry (void) const { return (RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_SYMMETRIC)?"S": (RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_HERMITIAN)?"H":"U")); }
is__triangular(void) const1171 bool is__triangular (void) const
1172 {
1173 rsb_bool_t retval = RSB_BOOL_FALSE;
1174 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1175
1176 if(!this->mtxAp)
1177 retval = RSB_BOOL_FALSE;
1178 else
1179 #if RSBOI_WANT_SYMMETRY
1180 if( (!RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_SYMMETRIC)) || RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_DIAGONAL) )
1181 #endif
1182 retval = RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_TRIANGULAR)?RSB_BOOL_TRUE:RSB_BOOL_FALSE;
1183 return retval;
1184 }
1185 // int is_struct (void) const { return false; }
1186
save_ascii(std::ostream & os)1187 bool save_ascii (std::ostream& os)
1188 {
1189 error ("%s", "save_ascii() " RSBOI_0_NIYERRMSG);
1190 return false;
1191 }
load_ascii(std::istream & is)1192 bool load_ascii (std::istream& is)
1193 {
1194 error ("%s", "load_ascii() " RSBOI_0_NIYERRMSG);
1195 return false;
1196 }
save_binary(std::ostream & os,bool & save_as_floats)1197 bool save_binary (std::ostream& os, bool& save_as_floats)
1198 {
1199 error ("%s", "save_binary() " RSBOI_0_NIYERRMSG);
1200 return false;
1201 }
1202 #if RSBOI_USE_PATCH_OCT44
load_binary(std::istream & is,bool swap,octave::mach_info::float_format fmt)1203 bool load_binary (std::istream& is, bool swap, octave::mach_info::float_format fmt)
1204 #else /* RSBOI_USE_PATCH_OCT44 */
1205 // would break on octave6
1206 bool load_binary (std::istream& is, bool swap, oct_mach_info::float_format fmt)
1207 #endif /* RSBOI_USE_PATCH_OCT44 */
1208 {
1209 error ("%s", "load_binary() " RSBOI_0_NIYERRMSG);
1210 return false;
1211 }
subsasgn(const std::string & type,const std::list<octave_value_list> & idx,const octave_value & rhs)1212 octave_value subsasgn (const std::string& type, const std::list<octave_value_list>& idx, const octave_value& rhs)
1213 {
1214 octave_value retval;
1215 #if 0
1216 rsb_err_t errval = RSB_ERR_NO_ERROR;
1217 #endif
1218 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1219
1220 switch (type[0])
1221 {
1222
1223 case '(':
1224 {
1225 if (type.length () == 1)
1226 {
1227 //retval = numeric_assign (type, idx, rhs);
1228 //RSBOI_DEBUG_NOTICE("UNFINISHED\n");
1229 const octave_idx_type n_idx = idx.front().length ();
1230 switch (n_idx)
1231 {
1232 case 0:
1233 retval = matrix;
1234 RSBOI_DEBUG_NOTICE("UNFINISHED\n");
1235 break;
1236 case 1:
1237 {
1238 #if RSBOI_WANT_SPMTX_SUBSASGN
1239 {
1240 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1241 const octave_value_list ovl = idx.front();
1242 if(ovl(0).issparse() && ovl(0).isreal() && rhs.isreal())
1243 {
1244 const SparseBoolMatrix sm = SparseBoolMatrix (ovl(0).sparse_matrix_value());
1245 const octave_idx_type * ir = sm.mex_get_ir ();
1246 const octave_idx_type * jc = sm.mex_get_jc ();
1247 const octave_idx_type nc = sm.cols ();
1248 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1249 const RSBOI_T rv = rhs.double_value();
1250
1251 for (octave_idx_type j = 0; j < nc; j++)
1252 {
1253 for (octave_idx_type i = jc[j]; i < jc[j+1]; i++)
1254 {
1255 rsb_err_t errval = RSB_ERR_NO_ERROR;
1256 const rsb_coo_idx_t ii = static_cast<rsb_coo_idx_t>(ir[i]); // Note: potentioally dangerous casts, if types are different and matrix huge.
1257 const rsb_coo_idx_t jj = static_cast<rsb_coo_idx_t>(j);
1258
1259 errval = rsb_mtx_set_values(this->mtxAp,&rv,&ii,&jj,1,RSBOI_NF);
1260 if(RSBOI_SOME_ERROR(errval))
1261 error ("%s", "FIXME: Incomplete: Can only accept already existing indices.");
1262 }
1263 }
1264 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1265 retval = octave_value(this->clone());
1266 }
1267 else
1268 error ("%s", "FIXME: Incomplete: no complex sparse-sparse update for the moment.");
1269 }
1270 #else /* RSBOI_WANT_SPMTX_SUBSASGN */
1271 RSBOI_DEBUG_NOTICE("UNFINISHED\n");
1272 idx_vector i = idx.front()(0).index_vector ();
1273 // ...
1274 RSBOI_IF_NERR(
1275 ;//retval = octave_value (matrix.index (i, resize_ok));
1276 )
1277 #endif /* RSBOI_WANT_SPMTX_SUBSASGN */
1278 }
1279 break;
1280 default:
1281 {
1282 if (n_idx == 2 )
1283 {
1284 idx_vector i = idx.front() (0).index_vector ();
1285 idx_vector j = idx.front() (1).index_vector ();
1286 #if 0
1287 // for op_el_div_eq and op_el_mul_eq
1288 std :: cout << "ic2 " << i.is_colon() << "\n" ;
1289 if( i.is_colon() && !j.is_colon() )
1290 {
1291 ComplexMatrix cm = rhs.complex_matrix_value();
1292 std :: cout << " : , .\n";
1293 errval=rsb_mtx_upd_values(this->mtxAp,RSB_ELOPF_SCALE_ROWS,cm.data());
1294 }
1295 if(!i.is_colon() && j.is_colon() )
1296 {
1297 std :: cout << " . , :\n";
1298 }
1299 if( i.is_colon() && j.is_colon() )
1300 {
1301 std :: cout << " : , :\n";
1302 }
1303 #endif
1304 RSBOI_IF_NERR_STATE()
1305 {
1306 if(is_real_type())
1307 {
1308 rsb_err_t errval = RSB_ERR_NO_ERROR;
1309 rsb_coo_idx_t ii = -1, jj = -1;
1310 RSBOI_T rv = rhs.double_value();
1311 ii = i(0); jj = j(0);
1312 RSBOI_DEBUG_NOTICE("update elements (%d %d)\n",ii,jj);
1313 #if RSBOI_WANT_SYMMETRY
1314 /* FIXME: and now ? */
1315 #endif
1316 errval = rsb_mtx_set_values(this->mtxAp,&rv,&ii,&jj,1,RSBOI_NF);
1317 RSBOI_PERROR(errval);
1318 /* FIXME: I am unsure, here */
1319 //retval=rhs.double_value(); // this does not match octavej
1320 //retval=octave_value(this);
1321 retval = octave_value(this->clone()); // matches but .. heavy ?!
1322 RSBOI_IF_NERR(
1323 ;//retval = octave_value (matrix.index (i, j, resize_ok));
1324 )
1325 }
1326 else
1327 {
1328 rsb_err_t errval = RSB_ERR_NO_ERROR;
1329 rsb_coo_idx_t ii = -1, jj = -1;
1330 Complex rv = rhs.complex_value();
1331 ii = i(0); jj = j(0);
1332 RSBOI_DEBUG_NOTICE("update elements (%d %d) complex\n",ii,jj);
1333 #if RSBOI_WANT_SYMMETRY
1334 /* FIXME: and now ? */
1335 #endif
1336 errval = rsb_mtx_set_values(this->mtxAp,&rv,&ii,&jj,1,RSBOI_NF);
1337 RSBOI_PERROR(errval);
1338 /* FIXME: I am unsure, here */
1339 //retval=rhs.double_value(); // this does not match octavej
1340 //retval=octave_value(this);
1341 retval = octave_value(this->clone()); // matches but .. heavy ?!
1342 RSBOI_IF_NERR(
1343 ;//retval = octave_value (matrix.index (i, j, resize_ok));
1344 )
1345 }
1346 // class octave_map;
1347 // retval = octave_map();
1348 // RSBOI_DEBUG_NOTICE("UNFINISHED: set %d %d <- %lg\n",ii,jj,rhs.double_value());
1349 }
1350 }
1351 }
1352 break;
1353 }
1354 }
1355 else if (type.length () == 2)
1356 {
1357 std::list<octave_value_list>::const_iterator p =
1358 idx.begin ();
1359 octave_value_list key_idx = *++p;
1360
1361 std::string key = key_idx(0).string_value ();
1362 RSBOI_DEBUG_NOTICE("UNFINISHED\n");
1363
1364 if (key == "type")
1365 error ("%s", "use 'sparse_rsb' to set type");
1366 else
1367 error ("%s can indexed with .%s",
1368 type_name().c_str(), key.c_str());
1369 }
1370 else
1371 error ("in indexed assignment of %s, illegal assignment",
1372 type_name().c_str ());
1373 }
1374 break;
1375 case '.':
1376 {
1377 octave_value_list key_idx = idx.front ();
1378 std::string key = key_idx(0).string_value ();
1379 RSBOI_DEBUG_NOTICE("UNFINISHED\n");
1380
1381 if (key == "type")
1382 error ("%s", "use 'sparse_rsb' to set matrix type");
1383 else
1384 error ("%s can indexed with .%s",
1385 type_name().c_str(), key.c_str());
1386 }
1387 break;
1388
1389 case '{':
1390 RSBOI_DEBUG_NOTICE("UNFINISHED\n");
1391 error ("%s cannot be indexed with %c",
1392 type_name().c_str (), type[0]);
1393 break;
1394
1395 default:
1396 panic_impossible ();
1397 }
1398 return retval;
1399 } /* subsasgn */
1400
try_narrowing_conversion(void)1401 octave_base_value *try_narrowing_conversion (void)
1402 {
1403 octave_base_value *retval = 0;
1404 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1405 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
1406 return retval;
1407 }
1408
1409 /*
1410 type_conv_fcn numeric_conversion_function (void) const
1411 {
1412 }
1413 */
1414
numeric_conversion_function(void) const1415 type_conv_info numeric_conversion_function (void) const
1416 {
1417 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1418 return default_numeric_conversion_function;
1419 }
1420
get_info_string()1421 std::string get_info_string()
1422 {
1423 char ss[RSBOI_INFOBUF];
1424 rsb_mtx_get_info_str(this->mtxAp,"RSB_MIF_MATRIX_INFO__TO__CHAR_P",ss,RSBOI_INFOBUF);
1425 return ss;
1426 }
1427
1428 #if defined(OCTAVE_MAJOR_VERSION) && (OCTAVE_MAJOR_VERSION>=4)
print(std::ostream & os,bool pr_as_read_syntax=false)1429 void print (std::ostream& os, bool pr_as_read_syntax = false)
1430 #else /* OCTAVE_MAJOR_VERSION */
1431 void print (std::ostream& os, bool pr_as_read_syntax = false) const
1432 #endif /* OCTAVE_MAJOR_VERSION */
1433 {
1434 RSBOI_FIXME("what to do with pr_as_read_syntax ?");
1435 struct rsboi_coo_matrix_t rcm;
1436 rsb_err_t errval = RSB_ERR_NO_ERROR;
1437 rsb_nnz_idx_t nnzA = this->nnz(),nzi;
1438 bool ic = this->is_real_type()?false:true;
1439 Array<octave_idx_type> IA( dim_vector(1,nnzA) );
1440 Array<octave_idx_type> JA( dim_vector(1,nnzA) );
1441 Array<RSBOI_T> VA( dim_vector(1,(ic?2:1)*nnzA) );
1442 std::string c = ic ? "complex" : "real";
1443 #if RSBOI_WANT_PRINT_DETAIL
1444 char ss[RSBOI_INFOBUF];
1445 rsb_mtx_get_info_str(this->mtxAp,"RSB_MIF_MATRIX_INFO__TO__CHAR_P",ss,RSBOI_INFOBUF);
1446 #endif
1447 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1448 rcm.VA = (RSBOI_T*)VA.data();
1449 rcm.IA = (octave_idx_type*)IA.data();
1450 rcm.JA = (octave_idx_type*)JA.data();
1451 #if RSBOI_WANT_SYMMETRY
1452 /* No expansion: we merely mention symmetry. */
1453 #endif
1454
1455 if(! (rcm.VA && rcm.IA && rcm.JA) )
1456 // NOTE: might rather want an error () here.
1457 nnzA = 0;
1458 else
1459 errval = rsboi_mtx_get_coo(this->mtxAp,rcm.VA,rcm.IA,rcm.JA,RSB_FLAG_C_INDICES_INTERFACE);
1460 if(RSBOI_SOME_ERROR(errval))
1461 {
1462 RSBOI_PERROR(errval);
1463 return;
1464 }
1465 rcm.nrA = this->rows();
1466 rcm.ncA = this->cols();
1467 double pct = 100.0*(((RSBOI_T)nnzA)/((RSBOI_T)rcm.nrA))/rcm.ncA;
1468 octave_stdout<<RSBOI_FSTR<< " (rows = "<<rcm.nrA<<
1469 ", cols = "<<rcm.ncA<<
1470 ", nnz = "<<nnzA
1471 #if RSBOI_WANT_SYMMETRY
1472 << ", symm = "<<
1473 (RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_SYMMETRIC)?"S":
1474 (RSB_DO_FLAG_HAS(this->rsbflags(),RSB_FLAG_HERMITIAN)?"H":"U"))
1475 // NOTE: need a mechanism to print out these flags from rsb itself
1476 #endif
1477 ;
1478 #if RSBOI_WANT_PRINT_PCT_OCTAVE_STYLE
1479 /* straight from Octave's src/ov-base-sparse.cc */
1480 if (nnzA > 0)
1481 {
1482 int prec = 2;
1483 if (pct == 100) prec = 3; else { if (pct > 99.9) prec = 4; else if (pct > 99) prec = 3; if (pct > 99.99) pct = 99.99; }
1484 octave_stdout << " [" << std::setprecision (prec) << pct << "%]";
1485 }
1486 #else
1487 octave_stdout << " ["<<pct<< "%]";
1488 #endif
1489
1490 octave_stdout <<
1491 #if RSBOI_WANT_PRINT_COMPLEX_OR_REAL
1492 ", "<<c<<
1493 #endif
1494 ")\n";
1495 #if RSBOI_WANT_PRINT_DETAIL
1496 octave_stdout<< "{{"<< ss <<"}}\n";
1497 #else
1498 octave_stdout<< "\n";
1499 #endif
1500 if(ic)
1501 for(nzi=0;nzi<nnzA;++nzi)
1502 octave_stdout<<" ("<<1+IA(nzi)<<", "<<1+JA(nzi)<<") -> "<<((RSBOI_T*)rcm.VA)[2*nzi+0]<<" + " <<((RSBOI_T*)rcm.VA)[2*nzi+1]<<"i\n";
1503 else
1504 for(nzi=0;nzi<nnzA;++nzi)
1505 octave_stdout<<" ("<<1+IA(nzi)<<", "<<1+JA(nzi)<<") -> "<<((RSBOI_T*)rcm.VA)[nzi]<<"\n";
1506 newline(os);
1507 RSBIO_NULL_STATEMENT_FOR_COMPILER_HAPPINESS
1508 }
1509
diag(octave_idx_type k) const1510 octave_value diag (octave_idx_type k) const
1511 {
1512 octave_value retval;
1513 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1514 RSBOI_0_EMCHECK(this->mtxAp);
1515
1516 if(k!=0)
1517 {
1518 error ("%s", "only main diagonal extraction is supported !");
1519 }
1520 if(this->is_square())
1521 {
1522 rsb_err_t errval = RSB_ERR_NO_ERROR;
1523 //RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1524 if(this->is_real_type())
1525 {
1526 Matrix DA(this->rows(),1);
1527 errval = rsb_mtx_get_vec(this->mtxAp,(RSBOI_T*)DA.data(),RSB_EXTF_DIAG);
1528 retval = (DA);
1529 }
1530 else
1531 {
1532 ComplexMatrix DA(this->rows(),1);
1533 errval = rsb_mtx_get_vec(this->mtxAp,(RSBOI_T*)DA.data(),RSB_EXTF_DIAG);
1534 retval = (DA);
1535 }
1536 RSBOI_PERROR(errval);
1537 }
1538 else
1539 {
1540 error ("%s", RSBOI_0_NSQERRMSG);
1541 }
1542 return retval;
1543 }
1544
rsboi_get_scaled_copy_inv(const RSBOI_T alpha) const1545 octave_value rsboi_get_scaled_copy_inv(const RSBOI_T alpha)const
1546 {
1547 const RSBOI_T one = 1.0;
1548 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1549 return rsboi_get_scaled_copy(one/alpha);
1550 }
1551
1552 #if RSBOI_WANT_DOUBLE_COMPLEX
rsboi_get_scaled_copy_inv(const Complex alpha) const1553 octave_value rsboi_get_scaled_copy_inv(const Complex alpha)const
1554 {
1555 const Complex one = 1.0;
1556 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1557 return rsboi_get_scaled_copy(one/alpha);
1558 }
1559 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
1560
rsboi_get_scaled_copy(const RSBOI_T alpha,rsb_trans_t transA=RSB_TRANSPOSITION_N) const1561 octave_value rsboi_get_scaled_copy(const RSBOI_T alpha, rsb_trans_t transA=RSB_TRANSPOSITION_N)const
1562 {
1563 rsb_err_t errval = RSB_ERR_NO_ERROR;
1564 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1565 struct rsb_mtx_t *mtxBp = RSBOI_NULL;
1566
1567 if(is_real_type())
1568 {
1569 errval = rsb_mtx_clone(&mtxBp,RSB_NUMERICAL_TYPE_SAME_TYPE,transA, &alpha,this->mtxAp,RSBOI_EXPF);
1570 }
1571 else
1572 #if RSBOI_WANT_DOUBLE_COMPLEX
1573 {
1574 Complex calpha;calpha+=alpha;
1575 errval = rsb_mtx_clone(&mtxBp,RSB_NUMERICAL_TYPE_SAME_TYPE,transA,&calpha,this->mtxAp,RSBOI_EXPF);
1576 }
1577 #else /* RSBOI_WANT_DOUBLE_COMPLEX */
1578 {RSBOI_0_ERROR(RSBOI_0_NOCOERRMSG);}
1579 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
1580 RSBOI_PERROR(errval);
1581 return new octave_sparsersb_mtx( mtxBp );
1582 }
1583
1584 #if RSBOI_WANT_DOUBLE_COMPLEX
rsboi_get_scaled_copy(const Complex alpha) const1585 octave_value rsboi_get_scaled_copy(const Complex alpha)const
1586 {
1587 rsb_err_t errval = RSB_ERR_NO_ERROR;
1588 octave_sparsersb_mtx *m = RSBOI_NULL;
1589 struct rsb_mtx_t *mtxBp = RSBOI_NULL;
1590
1591 if(is_real_type())
1592 {
1593 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1594 errval = rsb_mtx_clone(&mtxBp,RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX,RSB_TRANSPOSITION_N,&rsboi_pone,this->mtxAp,RSBOI_EXPF);
1595 rsboi_error(errval);
1596 errval = rsb_mtx_upd_values(mtxBp,RSB_ELOPF_MUL,&alpha);
1597 }
1598 else
1599 {
1600 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1601 errval = rsb_mtx_clone(&mtxBp,RSB_NUMERICAL_TYPE_SAME_TYPE,RSB_TRANSPOSITION_N,&alpha,this->mtxAp,RSBOI_EXPF);
1602 }
1603 rsboi_error(errval);
1604 m = new octave_sparsersb_mtx( mtxBp );
1605 if(!m)
1606 error ("%s", "copying matrix failed!");
1607 return m;
1608 }
1609 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
1610
scale_rows(const octave_matrix & v2,bool want_div=false)1611 octave_value scale_rows(const octave_matrix&v2, bool want_div=false)
1612 {
1613 rsb_err_t errval = RSB_ERR_NO_ERROR;
1614 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1615
1616 if(this->is_real_type())
1617 {
1618 const Matrix rm = want_div?1.0/v2.matrix_value ():v2.matrix_value ();
1619 const octave_idx_type b_nc = rm.cols ();
1620 const octave_idx_type b_nr = rm.rows ();
1621 //octave_idx_type ldb = b_nr;
1622 const octave_idx_type ldc = this->columns();
1623 const octave_idx_type nrhs = b_nc;
1624 Matrix retval(ldc,nrhs,RSBOI_ZERO);
1625 if(this->rows()!=b_nr) { error ("%s", "matrices dimensions do not match!\n"); return Matrix(); }
1626 errval = rsb_mtx_upd_values(this->mtxAp,RSB_ELOPF_SCALE_ROWS,rm.data());
1627 RSBOI_PERROR(errval);
1628 return retval;
1629 }
1630 else
1631 {
1632 const ComplexMatrix cm = want_div?1.0/v2.complex_matrix_value ():v2.complex_matrix_value ();
1633 const octave_idx_type b_nc = cm.cols ();
1634 const octave_idx_type b_nr = cm.rows ();
1635 //const octave_idx_type ldb = b_nr;
1636 const octave_idx_type ldc = this->columns();
1637 const octave_idx_type nrhs = b_nc;
1638 ComplexMatrix retval(ldc,nrhs,RSBOI_ZERO);
1639 if(this->rows()!=b_nr) { error ("%s", "matrices dimensions do not match!\n"); return ComplexMatrix(); }
1640 errval = rsb_mtx_upd_values(this->mtxAp,RSB_ELOPF_SCALE_ROWS,cm.data());
1641 RSBOI_PERROR(errval);
1642 return retval;
1643 }
1644 }
1645
rsboi_spmm(const octave_matrix & v2) const1646 octave_value rsboi_spmm(const octave_matrix&v2)const
1647 {
1648 rsb_err_t errval = RSB_ERR_NO_ERROR;
1649 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1650 rsb_trans_t transA = RSB_TRANSPOSITION_N;
1651
1652 if(this->is_real_type())
1653 {
1654 const Matrix b = v2.matrix_value ();
1655 const octave_idx_type b_nc = b.cols ();
1656 const octave_idx_type b_nr = b.rows ();
1657 const octave_idx_type ldb = b_nr;
1658 const octave_idx_type ldc = this->rows();
1659 const octave_idx_type nrhs = b_nc;
1660 Matrix retval(ldc,nrhs,RSBOI_ZERO);
1661
1662 if (this->columns()!=b_nr) { error ("%s", "matrix columns count does not match operand rows!\n"); return Matrix(); }
1663 errval = rsb_spmm(transA,&rsboi_pone,this->mtxAp,nrhs,RSB_OI_DMTXORDER,(RSBOI_T*)b.data(),ldb,&rsboi_pone,(RSBOI_T*)retval.data(),ldc);
1664 RSBOI_PERROR(errval);
1665 return retval;
1666 }
1667 else
1668 {
1669 const ComplexMatrix b = v2.complex_matrix_value ();
1670 const octave_idx_type b_nc = b.cols ();
1671 const octave_idx_type b_nr = b.rows ();
1672 const octave_idx_type ldb = b_nr;
1673 const octave_idx_type ldc = this->rows();
1674 const octave_idx_type nrhs = b_nc;
1675 ComplexMatrix retval(ldc,nrhs,RSBOI_ZERO);
1676
1677 if(this->columns()!=b_nr) { error ("%s", "matrix columns count does not match operand rows!\n"); return Matrix(); }
1678 errval = rsb_spmm(transA,&rsboi_pone,this->mtxAp,nrhs,RSB_OI_DMTXORDER,(RSBOI_T*)b.data(),ldb,&rsboi_pone,(RSBOI_T*)retval.data(),ldc);
1679 RSBOI_PERROR(errval);
1680 return retval;
1681 }
1682 }
1683
rsboi_spmtm(const octave_matrix & v2) const1684 octave_value rsboi_spmtm(const octave_matrix&v2)const
1685 {
1686 rsb_err_t errval = RSB_ERR_NO_ERROR;
1687 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1688 rsb_trans_t transA = RSB_TRANSPOSITION_T;
1689
1690 if(this->is_real_type())
1691 {
1692 const Matrix b = v2.matrix_value ();
1693 const octave_idx_type b_nc = b.cols ();
1694 const octave_idx_type b_nr = b.rows ();
1695 const octave_idx_type ldb = b_nr;
1696 const octave_idx_type ldc = this->columns();
1697 const octave_idx_type nrhs = b_nc;
1698 Matrix retval(ldc,nrhs,RSBOI_ZERO);
1699
1700 if(this->rows() !=b_nr) { error ("%s", "matrix rows count does not match operand rows!\n"); return Matrix(); }
1701 errval = rsb_spmm(transA,&rsboi_pone,this->mtxAp,nrhs,RSB_OI_DMTXORDER,(RSBOI_T*)b.data(),ldb,&rsboi_pone,(RSBOI_T*)retval.data(),ldc);
1702 RSBOI_PERROR(errval);
1703 return retval;
1704 }
1705 else
1706 {
1707 const ComplexMatrix b = v2.complex_matrix_value ();
1708 const octave_idx_type b_nc = b.cols ();
1709 const octave_idx_type b_nr = b.rows ();
1710 const octave_idx_type ldb = b_nr;
1711 const octave_idx_type ldc = this->columns();
1712 const octave_idx_type nrhs = b_nc;
1713 ComplexMatrix retval(ldc,nrhs,RSBOI_ZERO);
1714
1715 if(this->rows() !=b_nr) { error ("%s", "matrix rows count does not match operand rows!\n"); return Matrix(); }
1716 errval = rsb_spmm(transA,&rsboi_pone,this->mtxAp,nrhs,RSB_OI_DMTXORDER,(RSBOI_T*)b.data(),ldb,&rsboi_pone,(RSBOI_T*)retval.data(),ldc);
1717 RSBOI_PERROR(errval);
1718 return retval;
1719 }
1720 }
1721
rsboi_spmhm(const octave_matrix & v2) const1722 octave_value rsboi_spmhm(const octave_matrix&v2)const
1723 {
1724 rsb_err_t errval = RSB_ERR_NO_ERROR;
1725 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1726 rsb_trans_t transA = RSB_TRANSPOSITION_C;
1727
1728 if(this->is_real_type())
1729 {
1730 const Matrix b = v2.matrix_value ();
1731 const octave_idx_type b_nc = b.cols ();
1732 const octave_idx_type b_nr = b.rows ();
1733 const octave_idx_type ldb = b_nr;
1734 const octave_idx_type ldc = this->columns();
1735 const octave_idx_type nrhs = b_nc;
1736 Matrix retval(ldc,nrhs,RSBOI_ZERO);
1737
1738 if(this->rows() !=b_nr) { error ("%s", "matrix rows count does not match operand rows!\n"); return Matrix(); }
1739 errval = rsb_spmm(transA,&rsboi_pone,this->mtxAp,nrhs,RSB_OI_DMTXORDER,(RSBOI_T*)b.data(),ldb,&rsboi_pone,(RSBOI_T*)retval.data(),ldc);
1740 RSBOI_PERROR(errval);
1741 return retval;
1742 }
1743 else
1744 {
1745 const ComplexMatrix b = v2.complex_matrix_value ();
1746 const octave_idx_type b_nc = b.cols ();
1747 const octave_idx_type b_nr = b.rows ();
1748 const octave_idx_type ldb = b_nr;
1749 const octave_idx_type ldc = this->columns();
1750 const octave_idx_type nrhs = b_nc;
1751 ComplexMatrix retval(ldc,nrhs,RSBOI_ZERO);
1752
1753 if(this->rows() !=b_nr) { error ("%s", "matrix rows count does not match operand rows!\n"); return Matrix(); }
1754 errval = rsb_spmm(transA,&rsboi_pone,this->mtxAp,nrhs,RSB_OI_DMTXORDER,(RSBOI_T*)b.data(),ldb,&rsboi_pone,(RSBOI_T*)retval.data(),ldc);
1755 RSBOI_PERROR(errval);
1756 return retval;
1757 }
1758 }
1759
1760 #if RSBOI_WANT_DOUBLE_COMPLEX
rsboi_spmm(const octave_complex_matrix & v2) const1761 octave_value rsboi_spmm(const octave_complex_matrix&v2)const
1762 {
1763
1764 // TODO: to avoid e.g. v2.complex_matrix_value, one may use: dim_vector dv = v2.dims(); ... dv(ndims) ...
1765
1766 rsb_err_t errval = RSB_ERR_NO_ERROR;
1767 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1768 const rsb_trans_t transA = RSB_TRANSPOSITION_N;
1769 struct rsb_mtx_t *mtxCp = RSBOI_NULL;
1770 const ComplexMatrix b = v2.complex_matrix_value ();
1771 const octave_idx_type b_nc = b.cols ();
1772 const octave_idx_type b_nr = b.rows ();
1773 const octave_idx_type ldb = b_nr;
1774 const octave_idx_type ldc = this->rows();
1775 const octave_idx_type nrhs = b_nc;
1776 ComplexMatrix retval(ldc,nrhs,RSBOI_ZERO); // zeroing is in principle unnecessary (we zero in rsb_spmm), but otherwise data may not be allocated.
1777 RSBOI_T* Cp =(RSBOI_T*)retval.data();
1778 const RSBOI_T* Bp =(RSBOI_T*)b.data();
1779
1780 if(this->is_real_type())
1781 {
1782 errval = rsb_mtx_clone(&mtxCp,RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX,RSB_TRANSPOSITION_N,RSBOI_NULL,this->mtxAp,RSBOI_EXPF);
1783 }
1784 else{
1785 mtxCp = this->mtxAp;
1786 }
1787 if(RSBOI_SOME_ERROR(errval))
1788 goto err;
1789
1790 if(this->columns()!=b_nr) { error ("%s", "matrix columns count does not match operand rows!\n"); return Matrix(); }
1791
1792 errval = rsb_spmm(transA,&rsboi_pone,mtxCp,nrhs,RSB_OI_DMTXORDER,Bp,ldb,&rsboi_pone,Cp,ldc);
1793
1794 if(this->is_real_type())
1795 RSBOI_DESTROY(mtxCp);
1796 err:
1797 RSBOI_PERROR(errval);
1798 return retval;
1799 }
1800
rsboi_spmtm(const octave_complex_matrix & v2) const1801 octave_value rsboi_spmtm(const octave_complex_matrix&v2)const
1802 {
1803
1804 // TODO: to avoid e.g. v2.complex_matrix_value, one may use: dim_vector dv = v2.dims(); ... dv(ndims) ...
1805
1806 rsb_err_t errval = RSB_ERR_NO_ERROR;
1807 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1808 const rsb_trans_t transA = RSB_TRANSPOSITION_T;
1809 struct rsb_mtx_t *mtxCp = RSBOI_NULL;
1810 const ComplexMatrix b = v2.complex_matrix_value ();
1811 const octave_idx_type b_nc = b.cols ();
1812 const octave_idx_type b_nr = b.rows ();
1813 const octave_idx_type ldb = b_nr;
1814 const octave_idx_type ldc = this->columns();
1815 const octave_idx_type nrhs = b_nc;
1816 ComplexMatrix retval(ldc,nrhs,RSBOI_ZERO); // zeroing is in principle unnecessary (we zero in rsb_spmm), but otherwise data may not be allocated.
1817 RSBOI_T* Cp =(RSBOI_T*)retval.data();
1818 const RSBOI_T* Bp =(RSBOI_T*)b.data();
1819
1820 if(this->is_real_type())
1821 errval = rsb_mtx_clone(&mtxCp,RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX,RSB_TRANSPOSITION_N,RSBOI_NULL,this->mtxAp,RSBOI_EXPF);
1822 else
1823 mtxCp = this->mtxAp;
1824 if(RSBOI_SOME_ERROR(errval))
1825 goto err;
1826
1827 if(this->rows() !=b_nr) { error ("%s", "matrix rows count does not match operand rows!\n"); return Matrix(); }
1828
1829 errval = rsb_spmm(transA,&rsboi_pone,mtxCp,nrhs,RSB_OI_DMTXORDER,Bp,ldb,&rsboi_pone,Cp,ldc);
1830
1831 if(this->is_real_type())
1832 RSBOI_DESTROY(mtxCp);
1833 err:
1834 RSBOI_PERROR(errval);
1835 return retval;
1836 }
1837
rsboi_spmhm(const octave_complex_matrix & v2) const1838 octave_value rsboi_spmhm(const octave_complex_matrix&v2)const
1839 {
1840
1841 // TODO: to avoid e.g. v2.complex_matrix_value, one may use: dim_vector dv = v2.dims(); ... dv(ndims) ...
1842
1843 rsb_err_t errval = RSB_ERR_NO_ERROR;
1844 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1845 const rsb_trans_t transA = RSB_TRANSPOSITION_C;
1846 struct rsb_mtx_t *mtxCp = RSBOI_NULL;
1847 const ComplexMatrix b = v2.complex_matrix_value ();
1848 const octave_idx_type b_nc = b.cols ();
1849 const octave_idx_type b_nr = b.rows ();
1850 const octave_idx_type ldb = b_nr;
1851 const octave_idx_type ldc = this->columns();
1852 const octave_idx_type nrhs = b_nc;
1853 ComplexMatrix retval(ldc,nrhs,RSBOI_ZERO); // zeroing is in principle unnecessary (we zero in rsb_spmm), but otherwise data may not be allocated.
1854 RSBOI_T* Cp =(RSBOI_T*)retval.data();
1855 const RSBOI_T* Bp =(RSBOI_T*)b.data();
1856
1857 if(this->is_real_type())
1858 errval = rsb_mtx_clone(&mtxCp,RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX,RSB_TRANSPOSITION_N,RSBOI_NULL,this->mtxAp,RSBOI_EXPF);
1859 else
1860 mtxCp = this->mtxAp;
1861 if(RSBOI_SOME_ERROR(errval))
1862 goto err;
1863
1864 if(this->rows() !=b_nr) { error ("%s", "matrix rows count does not match operand rows!\n"); return Matrix(); }
1865
1866 errval = rsb_spmm(transA,&rsboi_pone,mtxCp,nrhs,RSB_OI_DMTXORDER,Bp,ldb,&rsboi_pone,Cp,ldc);
1867
1868 if(this->is_real_type())
1869 RSBOI_DESTROY(mtxCp);
1870 err:
1871 RSBOI_PERROR(errval);
1872 return retval;
1873 }
1874 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
1875
rsboi_spmsp(const octave_sparsersb_mtx & v2) const1876 octave_value rsboi_spmsp(const octave_sparsersb_mtx&v2)const
1877 {
1878 rsb_err_t errval = RSB_ERR_NO_ERROR;
1879 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1880 octave_sparsersb_mtx*sm = new octave_sparsersb_mtx();
1881 octave_value retval = sm;
1882
1883 #if RSBOI_WANT_SYMMETRY
1884 /* NOTE: no expansion */
1885 #endif
1886 /* NOTE: what if they are not both of the same type ? it would be nice to have a conversion.. */
1887 sm->mtxAp = rsb_spmsp(RSBOI_BINOP_PREVAILING_TYPE(*this,v2),RSB_TRANSPOSITION_N,&rsboi_pone,this->mtxAp,RSB_TRANSPOSITION_N,&rsboi_pone,v2.mtxAp,&errval);
1888 RSBOI_PERROR(errval);
1889 if(!sm->mtxAp)
1890 RSBOI_0_ERROR(RSBOI_0_ALLERRMSG);
1891 return retval;
1892 }
1893
rsboi_sppsp(const RSBOI_T * betap,const octave_sparsersb_mtx & v2) const1894 octave_value rsboi_sppsp(const RSBOI_T*betap, const octave_sparsersb_mtx&v2)const
1895 {
1896 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1897 octave_sparsersb_mtx*sm = new octave_sparsersb_mtx();
1898 octave_value retval = sm;
1899 rsb_err_t errval = RSB_ERR_NO_ERROR;
1900
1901 RSBOI_FIXME("");
1902 #if RSBOI_WANT_SYMMETRY
1903 /* NOTE: no expansion */
1904 #endif
1905
1906 if ( RSB_LIBRSB_VER < 10201 && ( RSBOI_BINOP_PREVAILING_TYPE(*this,v2) != this->rsbtype() ) )
1907 {
1908 /* Way around a bug fixed in librsb-1.2.0.9 */
1909 struct rsb_mtx_t *mtxCp = RSBOI_NULL;
1910 errval = rsb_mtx_clone(&mtxCp,RSBOI_BINOP_PREVAILING_TYPE(*this,v2),RSB_TRANSPOSITION_N,RSBOI_NULL,this->mtxAp,RSBOI_EXPF);
1911 if(RSBOI_SOME_ERROR(errval))
1912 goto err;
1913 RSBOI_PERROR(errval);
1914 sm->mtxAp = rsb_sppsp(RSBOI_BINOP_PREVAILING_TYPE(*this,v2),RSB_TRANSPOSITION_N,&rsboi_pone,mtxCp,RSB_TRANSPOSITION_N,betap,v2.mtxAp,&errval);
1915 RSBOI_DESTROY(mtxCp);
1916 }
1917 else
1918 sm->mtxAp = rsb_sppsp(RSBOI_BINOP_PREVAILING_TYPE(*this,v2),RSB_TRANSPOSITION_N,&rsboi_pone,this->mtxAp,RSB_TRANSPOSITION_N,betap,v2.mtxAp,&errval);
1919 RSBOI_PERROR(errval);
1920 err:
1921 if(!sm->mtxAp)
1922 RSBOI_0_ERROR(RSBOI_0_ALLERRMSG);
1923 return retval;
1924 }
1925
1926 #if RSBOI_WANT_DOUBLE_COMPLEX
cp_ubop(enum rsb_elopf_t opf,Complex z) const1927 octave_value cp_ubop(enum rsb_elopf_t opf, Complex z)const
1928 {
1929 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1930 rsb_err_t errval = RSB_ERR_NO_ERROR;
1931 octave_sparsersb_mtx *m = new octave_sparsersb_mtx(*this);
1932
1933 if( is_real_type ())
1934 {
1935 struct rsb_mtx_t *mtxCp = RSBOI_NULL;
1936 errval = rsb_mtx_clone(&mtxCp,RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX,RSB_TRANSPOSITION_N,RSBOI_NULL,this->mtxAp,RSBOI_EXPF);
1937 if(RSBOI_SOME_ERROR(errval))
1938 goto err;
1939 errval = rsb_mtx_upd_values(mtxCp,opf,&z);
1940 rsboi_error(errval);
1941 RSBOI_DESTROY(m->mtxAp);
1942 m->mtxAp = mtxCp;
1943 }
1944 else
1945 errval = rsb_mtx_upd_values(m->mtxAp,opf,&z);
1946 rsboi_error(errval);
1947 err:
1948 return m;
1949 }
1950 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
1951
cp_ubop(enum rsb_elopf_t opf,void * alphap=RSBOI_NULL) const1952 octave_value cp_ubop(enum rsb_elopf_t opf, void*alphap=RSBOI_NULL)const
1953 {
1954 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1955 rsb_err_t errval = RSB_ERR_NO_ERROR;
1956 octave_sparsersb_mtx *m = new octave_sparsersb_mtx(*this);
1957
1958 if(!m)return m;
1959 errval = rsb_mtx_upd_values(m->mtxAp,opf,alphap);
1960 rsboi_error(errval);
1961 return m;
1962 }
1963
1964 private:
1965 public:
1966 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
1967 };/* end of class octave_sparsersb_mtx definition */
1968
1969 #if 0
1970 octave_value_list find_nonzero_elem_idx (const class octave_sparsersb_mtx & nda, int nargout, octave_idx_type n_to_find, int direction)
1971 {
1972 // useless
1973 octave_value retval;
1974 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1975 return retval;
1976 }
1977 #endif
1978
1979 #if defined(RSBOI_USE_PATCH_38143)
1980 #define RSBOI_CAST_CONV_ARG(ARGT) /* Seems like in 4.1.0+ CAST_CONV_ARG is not there. */ \
1981 ARGT v = dynamic_cast< ARGT > (a)
1982 #define RSBOI_CAST_UNOP_ARG(ARGT) /* Seems like in 4.1.0+ CAST_UNOP_ARG is not there. */ \
1983 RSBOI_CAST_CONV_ARG(ARGT)
1984 #define RSB_CAST_BINOP_ARGS(ARGT_V1, ARGT_V2); /* Seems like in 4.1.0+ CAST_BINOP_ARGS is not there. */ \
1985 ARGT_V1 v1 = dynamic_cast< ARGT_V1 > (a1); \
1986 ARGT_V2 v2 = dynamic_cast< ARGT_V2 > (a2);
1987 #else /* RSBOI_USE_PATCH_38143 */
1988 #define RSBOI_CAST_CONV_ARG CAST_CONV_ARG
1989 #define RSBOI_CAST_UNOP_ARG CAST_UNOP_ARG
1990 #define RSB_CAST_BINOP_ARGS CAST_BINOP_ARGS
1991 #endif /* RSBOI_USE_PATCH_38143 */
1992
default_numeric_conversion_function(const octave_base_value & a)1993 static octave_base_value *default_numeric_conversion_function (const octave_base_value& a)
1994 {
1995 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
1996 RSBOI_CAST_CONV_ARG (const octave_sparsersb_mtx&);
1997 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
1998 RSBOI_WARN(RSBOI_0_UNFFEMSG);
1999 if(v.is_real_type())
2000 return new octave_sparse_matrix (v.sparse_matrix_value());
2001 else
2002 return new octave_sparse_complex_matrix (v.sparse_complex_matrix_value());
2003 }
2004
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_sparsersb_mtx,RSB_OI_TYPEINFO_STRING,RSB_OI_TYPEINFO_TYPE)2005 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (octave_sparsersb_mtx,
2006 RSB_OI_TYPEINFO_STRING,
2007 RSB_OI_TYPEINFO_TYPE)
2008
2009 DEFCONV (octave_triangular_conv, octave_sparsersb_mtx, matrix)
2010 {
2011 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2012 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2013 RSBOI_CAST_CONV_ARG (const octave_sparsersb_mtx&);
2014 return new octave_sparse_matrix (v.matrix_value ());
2015 }
2016
2017 #if 0
2018 DEFCONV (octave_sparse_rsb_to_octave_sparse_conv, sparse_rsb_mtx, sparse_matrix)
2019 {
2020 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2021 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2022 RSBOI_CAST_CONV_ARG (const octave_sparsersb_mtx&);
2023 return new octave_sparse_matrix (v.matrix_value ());
2024 }
2025 #endif
2026
DEFUNOP(uplus,sparse_rsb_mtx)2027 DEFUNOP (uplus, sparse_rsb_mtx)
2028 {
2029 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2030 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2031 RSBOI_CAST_UNOP_ARG (const octave_sparsersb_mtx&);
2032 return new octave_sparsersb_mtx (v);
2033 }
2034
2035 #if 0
2036 DEFUNOP (op_incr, sparse_rsb_mtx)
2037 {
2038 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2039 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2040 RSBOI_CAST_UNOP_ARG (const octave_sparsersb_mtx&);
2041 const octave_idx_type rn = v.mtxAp->nrA,cn = v.mtxAp->ncA;
2042 Matrix v2(rn,cn);
2043 octave_value retval = v2;
2044 rsb_err_t errval = RSB_ERR_NO_ERROR;
2045 errval|=rsb_mtx_add_to_dense(&rsboi_pone,v.mtxAp,rn,rn,cn,RSB_BOOL_TRUE,(RSBOI_T*)v2.data());
2046 //v = octave_ma(idx, v2.matrix_value());
2047 return v2;
2048 }
2049
2050 DEFUNOP (op_decr, sparse_rsb_mtx)
2051 {
2052 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2053 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2054 RSBOI_CAST_UNOP_ARG (const octave_sparsersb_mtx&);
2055 const octave_idx_type rn = v.mtxAp->nrA, cn = v.mtxAp->ncA;
2056 Matrix v2(rn,cn);
2057 octave_value retval = v2;
2058 rsb_err_t errval = RSB_ERR_NO_ERROR;
2059 errval|=rsb_mtx_add_to_dense(&rsboi_pone,v.mtxAp,rn,rn,cn,RSB_BOOL_TRUE,(RSBOI_T*)v2.data());
2060 //v = octave_ma(idx, v2.matrix_value());
2061 return v2;
2062 }
2063 #endif
2064
DEFUNOP(uminus,sparse_rsb_mtx)2065 DEFUNOP (uminus, sparse_rsb_mtx)
2066 {
2067 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2068 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2069 RSBOI_CAST_UNOP_ARG (const octave_sparsersb_mtx&);
2070 return v.cp_ubop(RSB_ELOPF_NEG);
2071 }
2072
DEFUNOP(transpose,sparse_rsb_mtx)2073 DEFUNOP (transpose, sparse_rsb_mtx)
2074 {
2075 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2076 RSBOI_CAST_UNOP_ARG (const octave_sparsersb_mtx&);
2077 return v.rsboi_get_scaled_copy(rsboi_pone[0],RSB_TRANSPOSITION_T);
2078 }
2079
DEFUNOP(htranspose,sparse_rsb_mtx)2080 DEFUNOP (htranspose, sparse_rsb_mtx)
2081 {
2082 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2083 RSBOI_CAST_UNOP_ARG (const octave_sparsersb_mtx&);
2084 return v.rsboi_get_scaled_copy(rsboi_pone[0],RSB_TRANSPOSITION_C);
2085 }
2086
rsboi_spsm(const octave_sparsersb_mtx & v1,const octave_matrix & v2,rsb_trans_t transA)2087 octave_value rsboi_spsm(const octave_sparsersb_mtx&v1, const octave_matrix&v2, rsb_trans_t transA)
2088 {
2089 rsb_err_t errval = RSB_ERR_NO_ERROR;
2090 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2091
2092 if(v1.iscomplex())
2093 {
2094 ComplexMatrix retval = v2.complex_matrix_value();
2095 const octave_idx_type b_nc = retval.cols ();
2096 const octave_idx_type b_nr = retval.rows ();
2097 const octave_idx_type ldb = b_nr;
2098 const octave_idx_type ldc = v1.rows();
2099 const octave_idx_type nrhs = b_nc;
2100 const octave_idx_type nels = retval.rows()*retval.cols();
2101 errval = rsb_spsm(transA,&rsboi_pone,v1.mtxAp,nrhs,RSB_OI_DMTXORDER,&rsboi_zero,(const RSBOI_T*)retval.data(),ldb,(RSBOI_T*)retval.data(),ldc);
2102 if(RSBOI_SOME_ERROR(errval))
2103 {
2104 RSBOI_PERROR(errval);
2105 if(errval == RSB_ERR_INVALID_NUMERICAL_DATA)
2106 error ("%s", RSBOI_0_ZODERRMG);
2107 for(octave_idx_type i=0;i<nels;++i)
2108 retval(i)=octave_NaN;
2109 }
2110 return retval;
2111 }
2112 else
2113 {
2114 Matrix retval = v2.matrix_value();
2115 const octave_idx_type b_nc = retval.cols ();
2116 const octave_idx_type b_nr = retval.rows ();
2117 const octave_idx_type ldb = b_nr;
2118 const octave_idx_type ldc = v1.rows();
2119 const octave_idx_type nrhs = b_nc;
2120 const octave_idx_type nels = retval.rows()*retval.cols();
2121
2122 errval = rsb_spsm(transA,&rsboi_pone,v1.mtxAp,nrhs,RSB_OI_DMTXORDER,&rsboi_zero,(const RSBOI_T*)retval.data(),ldb,(RSBOI_T*)retval.data(),ldc);
2123
2124 if(RSBOI_SOME_ERROR(errval))
2125 {
2126 RSBOI_PERROR(errval);
2127 if(errval == RSB_ERR_INVALID_NUMERICAL_DATA)
2128 error ("%s", RSBOI_0_ZODERRMG);
2129 for(octave_idx_type i=0;i<nels;++i)
2130 retval(i)=octave_NaN;
2131 }
2132 return retval;
2133 }
2134 }
2135
2136 #if RSBOI_WANT_DOUBLE_COMPLEX
rsboi_spsm(const octave_sparsersb_mtx & v1,const octave_complex_matrix & v2,rsb_trans_t transA)2137 octave_value rsboi_spsm(const octave_sparsersb_mtx&v1, const octave_complex_matrix&v2, rsb_trans_t transA)
2138 {
2139 rsb_err_t errval = RSB_ERR_NO_ERROR;
2140 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2141 ComplexMatrix retval = v2.complex_matrix_value();
2142 const octave_idx_type b_nc = retval.cols ();
2143 const octave_idx_type b_nr = retval.rows ();
2144 const octave_idx_type ldb = b_nr;
2145 const octave_idx_type ldc = v1.rows();
2146 const octave_idx_type nrhs = b_nc;
2147 const octave_idx_type nels = retval.rows()*retval.cols();
2148 struct rsb_mtx_t *mtxCp = RSBOI_NULL;
2149
2150 if(v1.is_real_type())
2151 errval = rsb_mtx_clone(&mtxCp,RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX,RSB_TRANSPOSITION_N,RSBOI_NULL,v1.mtxAp,RSBOI_EXPF);
2152 else
2153 mtxCp = v1.mtxAp;
2154 if(RSBOI_SOME_ERROR(errval))
2155 goto err;
2156
2157 errval = rsb_spsm(transA,&rsboi_pone,mtxCp,nrhs,RSB_OI_DMTXORDER,&rsboi_zero,(const RSBOI_T*)retval.data(),ldb,(RSBOI_T*)retval.data(),ldc);
2158
2159 if(RSBOI_SOME_ERROR(errval))
2160 {
2161 RSBOI_PERROR(errval);
2162 if(errval == RSB_ERR_INVALID_NUMERICAL_DATA)
2163 error ("%s", RSBOI_0_ZODERRMG);
2164 for(octave_idx_type i=0;i<nels;++i)
2165 retval(i)=octave_NaN;
2166 }
2167 if(v1.is_real_type())
2168 RSBOI_DESTROY(mtxCp);
2169 err:
2170 RSBOI_PERROR(errval);
2171 return retval;
2172 }
2173 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2174
DEFBINOP(ldiv,sparse_rsb_mtx,matrix)2175 DEFBINOP(ldiv, sparse_rsb_mtx, matrix)
2176 {
2177 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2178 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_matrix&);
2179
2180 if(v1.is__triangular())
2181 return rsboi_spsm(v1,v2,RSB_TRANSPOSITION_N);
2182
2183 if(v1.iscomplex() || v2.iscomplex())
2184 return (v1.sparse_complex_matrix_value()).solve(v2.sparse_complex_matrix_value());
2185 else
2186 return (v1.sparse_matrix_value()).solve(v2.matrix_value());
2187 //RSBOI_RSB_MATRIX_SOLVE(v1,v2);
2188 }
2189
DEFBINOP(trans_ldiv,sparse_rsb_mtx,matrix)2190 DEFBINOP(trans_ldiv, sparse_rsb_mtx, matrix)
2191 {
2192 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2193 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_matrix&);
2194
2195 if(v1.is__triangular())
2196 return rsboi_spsm(v1,v2,RSB_TRANSPOSITION_T);
2197
2198 if(v1.iscomplex() || v2.iscomplex())
2199 return (v1.sparse_complex_matrix_value().transpose()).solve(v2.sparse_complex_matrix_value());
2200 else
2201 return (v1.sparse_matrix_value().transpose()).solve(v2.matrix_value());
2202 //RSBOI_RSB_MATRIX_SOLVE(v1,v2);
2203 }
2204
2205 #if RSBOI_WANT_DOUBLE_COMPLEX
DEFBINOP(c_ldiv,sparse_rsb_mtx,matrix)2206 DEFBINOP(c_ldiv, sparse_rsb_mtx, matrix)
2207 {
2208 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2209 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_complex_matrix&);
2210
2211 if(v1.is__triangular())
2212 return rsboi_spsm(v1,v2,RSB_TRANSPOSITION_N);
2213
2214 if(v1.iscomplex() || v2.iscomplex())
2215 return (v1.sparse_complex_matrix_value()).solve(v2.sparse_complex_matrix_value());
2216 else
2217 return (v1.sparse_matrix_value()).solve(v2.matrix_value());
2218 //RSBOI_RSB_MATRIX_SOLVE(v1,v2);
2219 }
2220
DEFBINOP(trans_c_ldiv,sparse_rsb_mtx,matrix)2221 DEFBINOP(trans_c_ldiv, sparse_rsb_mtx, matrix)
2222 {
2223 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2224 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_complex_matrix&);
2225 if(v1.is__triangular())
2226 return rsboi_spsm(v1,v2,RSB_TRANSPOSITION_T);
2227
2228 if(v1.iscomplex() || v2.iscomplex())
2229 return (v1.sparse_complex_matrix_value().transpose()).solve(v2.sparse_complex_matrix_value());
2230 else
2231 return (v1.sparse_matrix_value().transpose()).solve(v2.matrix_value());
2232 //RSBOI_RSB_MATRIX_SOLVE(v1,v2);
2233 }
2234 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2235
DEFBINOP(el_div,sparse_rsb_mtx,matrix)2236 DEFBINOP(el_div, sparse_rsb_mtx, matrix)
2237 {
2238 Matrix retval;
2239 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2240 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2241 return retval;
2242 }
2243
DEFBINOP(el_ldiv,sparse_rsb_mtx,matrix)2244 DEFBINOP(el_ldiv, sparse_rsb_mtx, matrix)
2245 {
2246 Matrix retval;
2247 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2248 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2249 return retval;
2250 }
2251
DEFBINOP(div,sparse_rsb_mtx,matrix)2252 DEFBINOP(div, sparse_rsb_mtx, matrix)
2253 {
2254 Matrix retval;
2255 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2256 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2257 return retval;
2258 }
2259
2260 #if RSBOI_WANT_DOUBLE_COMPLEX
DEFBINOP(rsb_c_div,sparse_rsb_mtx,complex)2261 DEFBINOP(rsb_c_div, sparse_rsb_mtx, complex)
2262 {
2263 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_complex&);
2264 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2265 return v1.rsboi_get_scaled_copy_inv(v2.complex_value());
2266 }
2267 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2268
DEFBINOP(rsb_s_div,sparse_rsb_mtx,scalar)2269 DEFBINOP(rsb_s_div, sparse_rsb_mtx, scalar)
2270 {
2271 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_scalar&);
2272 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2273 return v1.rsboi_get_scaled_copy_inv(v2.scalar_value());
2274 }
2275
DEFBINOP(rsb_s_mul,sparse_rsb_mtx,scalar)2276 DEFBINOP(rsb_s_mul, sparse_rsb_mtx, scalar)
2277 {
2278 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_scalar&);
2279 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2280 return v1.rsboi_get_scaled_copy(v2.scalar_value());
2281 }
2282
DEFBINOP(s_rsb_mul,scalar,sparse_rsb_mtx)2283 DEFBINOP(s_rsb_mul, scalar, sparse_rsb_mtx)
2284 {
2285 RSB_CAST_BINOP_ARGS (const octave_scalar&, const octave_sparsersb_mtx &);
2286 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2287 return v2.rsboi_get_scaled_copy(v1.scalar_value());
2288 }
2289
2290 #if RSBOI_WANT_DOUBLE_COMPLEX
DEFBINOP(rsb_c_mul,sparse_rsb_mtx,complex)2291 DEFBINOP(rsb_c_mul, sparse_rsb_mtx, complex)
2292 {
2293 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_complex&);
2294 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2295 return v1.rsboi_get_scaled_copy(v2.complex_value());
2296 }
2297
DEFBINOP(c_rsb_mul,complex,sparse_rsb_mtx)2298 DEFBINOP(c_rsb_mul, complex, sparse_rsb_mtx)
2299 {
2300 RSB_CAST_BINOP_ARGS (const octave_complex&, const octave_sparsersb_mtx &);
2301 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2302 return v2.rsboi_get_scaled_copy(v1.complex_value());
2303 }
2304 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2305
2306 #if RSBOI_WANT_POW
DEFBINOP(rsb_s_pow,sparse_rsb_mtx,scalar)2307 DEFBINOP(rsb_s_pow, sparse_rsb_mtx, scalar) // ^
2308 {
2309 RSBOI_FIXME("This is elemental exponentiation!");
2310 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_scalar&);
2311 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2312 RSBOI_T alpha = v2.scalar_value();
2313 return v1.cp_ubop(RSB_ELOPF_POW,&alpha);
2314 }
2315 #endif /* RSBOI_WANT_POW */
2316
DEFASSIGNOP(assign,sparse_rsb_mtx,sparse_rsb_mtx)2317 DEFASSIGNOP (assign, sparse_rsb_mtx, sparse_rsb_mtx)
2318 {
2319 rsb_err_t errval = RSB_ERR_NO_ERROR;
2320 RSBOI_FIXME("I dunno how to trigger this!");
2321 RSB_CAST_BINOP_ARGS (octave_sparsersb_mtx &, const octave_sparsersb_mtx&);
2322 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2323 //rsb_assign(v1.mtxAp, v2.mtxAp);
2324 errval = rsb_mtx_clone(&v1.mtxAp,RSB_NUMERICAL_TYPE_SAME_TYPE,RSB_TRANSPOSITION_N,RSBOI_NULL,v2.mtxAp,RSBOI_EXPF);
2325 RSBOI_PERROR(errval);
2326 return octave_value();
2327 }
2328
DEFASSIGNOP(assignm,sparse_rsb_mtx,matrix)2329 DEFASSIGNOP (assignm, sparse_rsb_mtx, matrix)
2330 {
2331 RSB_CAST_BINOP_ARGS (octave_sparsersb_mtx &, const octave_matrix&);
2332 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2333 RSBOI_DESTROY(v1.mtxAp);
2334 octave_value retval;
2335 //v1.assign(idx, v2.matrix_value());
2336 #if RSBOI_USE_PATCH_OCT44
2337 v1.assign(idx, v2.sparse_matrix_value());
2338 #else /* RSBOI_USE_PATCH_OCT44 */
2339 // would break on octave6 (assignment deleted)
2340 v1 = (idx, v2.matrix_value());
2341 #endif /* RSBOI_USE_PATCH_OCT44 */
2342 //retval = v1;
2343 retval = v2.matrix_value();
2344 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2345 return retval;
2346 }
2347
2348 #if 0
2349 DEFASSIGNOP(rsb_op_mul_eq_s, sparse_rsb_mtx, scalar)
2350 {
2351 RSB_CAST_BINOP_ARGS (octave_sparsersb_mtx &, const octave_scalar&);
2352 octave_value retval;
2353 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2354 RSBOI_PERROR(v1.rsboi_scale(v2.scalar_value()));
2355 retval = v1.matrix_value();
2356 return retval;
2357 }
2358
2359 rsb_err_t rsboi_scale(RSBOI_T alpha)
2360 {
2361 rsb_err_t errval = RSB_ERR_NO_ERROR;
2362 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2363 //errval = rsb_elemental_scale(this->mtxAp,&alpha);
2364 errval = rsb_elemental_op(this->mtxAp,RSB_ELOPF_MUL,&alpha);
2365 RSBOI_PERROR(errval);
2366 return errval;
2367 }
2368
2369 rsb_err_t rsboi_scale(Complex alpha)
2370 {
2371 rsb_err_t errval = RSB_ERR_NO_ERROR;
2372 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2373 //errval = rsb_elemental_scale(this->mtxAp,&alpha);
2374 errval = rsb_elemental_op(this->mtxAp,RSB_ELOPF_MUL,&alpha);
2375 RSBOI_PERROR(errval);
2376 return errval;
2377 }
2378
2379 DEFASSIGNOP(rsb_op_div_eq_s, sparse_rsb_mtx, scalar)
2380 {
2381 RSB_CAST_BINOP_ARGS (octave_sparsersb_mtx &, const octave_scalar&);
2382 octave_value retval;
2383 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2384 RSBOI_PERROR(v1.rsboi_scale_inv(v2.scalar_value()));
2385 retval = v1.matrix_value();
2386 return retval;
2387 }
2388
2389 rsb_err_t rsboi_scale_inv(RSBOI_T alpha)
2390 {
2391 rsb_err_t errval = RSB_ERR_NO_ERROR;
2392 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2393 //errval = rsb_elemental_scale_inv(this->mtxAp,&alpha);
2394 errval = rsb_elemental_op(this->mtxAp,RSB_ELOPF_DIV,&alpha);
2395 RSBOI_PERROR(errval);
2396 return errval;
2397 }
2398
2399 rsb_err_t rsboi_scale_inv(Complex alpha)
2400 {
2401 rsb_err_t errval = RSB_ERR_NO_ERROR;
2402 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2403 //errval = rsb_elemental_scale_inv(this->mtxAp,&alpha);
2404 errval = rsb_elemental_op(this->mtxAp,RSB_ELOPF_DIV,&alpha);
2405 RSBOI_PERROR(errval);
2406 return errval;
2407 }
2408 #endif
2409
DEFBINOP(rsb_el_mul_s,sparse_rsb_mtx,scalar)2410 DEFBINOP(rsb_el_mul_s, sparse_rsb_mtx, scalar)
2411 {
2412 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_scalar&);
2413 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2414 return v1.rsboi_get_scaled_copy(v2.scalar_value());
2415 }
2416
2417 #if RSBOI_WANT_DOUBLE_COMPLEX
DEFBINOP(rsb_el_mul_c,sparse_rsb_mtx,complex)2418 DEFBINOP(rsb_el_mul_c, sparse_rsb_mtx, complex)
2419 {
2420 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_complex&);
2421 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2422 return v1.rsboi_get_scaled_copy(v2.complex_value());
2423 }
2424 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2425
DEFBINOP(rsb_el_div_s,sparse_rsb_mtx,scalar)2426 DEFBINOP(rsb_el_div_s, sparse_rsb_mtx, scalar)
2427 {
2428 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_scalar&);
2429 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2430 return v1.rsboi_get_scaled_copy_inv(v2.scalar_value());
2431 }
2432
2433 #if RSBOI_WANT_DOUBLE_COMPLEX
DEFBINOP(rsb_el_div_c,sparse_rsb_mtx,complex)2434 DEFBINOP(rsb_el_div_c, sparse_rsb_mtx, complex)
2435 {
2436 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_complex&);
2437 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2438 return v1.rsboi_get_scaled_copy_inv(v2.complex_value());
2439 }
2440 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2441
2442 #if RSBOI_WANT_DOUBLE_COMPLEX
2443 #if 0
2444 DEFASSIGNOP(rsb_op_el_div_eq, sparse_rsb_mtx, scalar)
2445 {
2446 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_scalar&);
2447 std::cout << "rsb_op_el_div_eq!\n";
2448 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2449 return v1.rsboi_get_scaled_copy_inv(v2.complex_value());
2450 }
2451 #endif
2452
DEFASSIGNOP(rsb_op_el_mul_eq_sc,sparse_rsb_mtx,matrix)2453 DEFASSIGNOP(rsb_op_el_mul_eq_sc, sparse_rsb_mtx, matrix)
2454 {
2455 //rsb_err_t errval = RSB_ERR_NO_ERROR;
2456 RSB_CAST_BINOP_ARGS (octave_sparsersb_mtx &, const octave_matrix&);
2457 return v1.scale_rows(v2,false);
2458 }
2459
DEFASSIGNOP(rsb_op_el_div_eq_sc,sparse_rsb_mtx,matrix)2460 DEFASSIGNOP(rsb_op_el_div_eq_sc, sparse_rsb_mtx, matrix)
2461 {
2462 //rsb_err_t errval = RSB_ERR_NO_ERROR;
2463 RSB_CAST_BINOP_ARGS (octave_sparsersb_mtx &, const octave_matrix&);
2464 return v1.scale_rows(v2,true);
2465 }
2466 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2467
DEFBINOP(el_pow,sparse_rsb_mtx,scalar)2468 DEFBINOP(el_pow, sparse_rsb_mtx, scalar)
2469 {
2470 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_scalar&);
2471 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2472 RSBOI_T alpha [] = {v2.scalar_value(),0};
2473 return v1.cp_ubop(RSB_ELOPF_POW,&alpha);
2474 }
2475
2476 #if RSBOI_WANT_DOUBLE_COMPLEX
DEFBINOP(el_pow_c,sparse_rsb_mtx,complex)2477 DEFBINOP(el_pow_c, sparse_rsb_mtx, complex)
2478 {
2479 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx &, const octave_complex&);
2480 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2481 Complex alpha = v2.complex_value();
2482 return v1.cp_ubop(RSB_ELOPF_POW,alpha);
2483 }
2484 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2485
2486 #ifdef RSB_FULLY_IMPLEMENTED
DEFASSIGNOP(assigns,sparse_rsb_mtx,scalar)2487 DEFASSIGNOP (assigns, sparse_rsb_mtx, scalar)
2488 {
2489 RSB_CAST_BINOP_ARGS (octave_sparsersb_mtx &, const octave_scalar&);
2490 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2491 v1.assign(idx, v2.matrix_value());
2492 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2493 return octave_value();
2494 }
2495 #endif
2496
DEFBINOP(op_sub,sparse_rsb_mtx,sparse_rsb_mtx)2497 DEFBINOP(op_sub, sparse_rsb_mtx, sparse_rsb_mtx)
2498 {
2499 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2500 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_sparsersb_mtx&);
2501 return v1.rsboi_sppsp(&rsboi_mone[0],v2);
2502 }
2503
DEFBINOP(op_add,sparse_rsb_mtx,sparse_rsb_mtx)2504 DEFBINOP(op_add, sparse_rsb_mtx, sparse_rsb_mtx)
2505 {
2506 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2507 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_sparsersb_mtx&);
2508 return v1.rsboi_sppsp(&rsboi_pone[0],v2);
2509 }
2510
DEFBINOP(op_spmul,sparse_rsb_mtx,sparse_rsb_mtx)2511 DEFBINOP(op_spmul, sparse_rsb_mtx, sparse_rsb_mtx)
2512 {
2513 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2514 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_sparsersb_mtx&);
2515 return v1.rsboi_spmsp(v2);
2516 }
2517
DEFBINOP(op_mul,sparse_rsb_mtx,matrix)2518 DEFBINOP(op_mul, sparse_rsb_mtx, matrix)
2519 {
2520 // "*" operator
2521 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2522 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_matrix&);
2523 //return v1.rsboi_spmm(v2, false);
2524 return v1.rsboi_spmm(v2);
2525 }
2526
DEFBINOP(op_trans_mul,sparse_rsb_mtx,matrix)2527 DEFBINOP(op_trans_mul, sparse_rsb_mtx, matrix)
2528 {
2529 // ".'*" operator
2530 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2531 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_matrix&);
2532 //return v1.rsboi_spmm(v2, true);
2533 return v1.rsboi_spmtm(v2);
2534 }
2535
DEFBINOP(op_herm_mul,sparse_rsb_mtx,matrix)2536 DEFBINOP(op_herm_mul, sparse_rsb_mtx, matrix)
2537 {
2538 // "'*" operator
2539 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2540 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_matrix&);
2541 //return v1.rsboi_spmm(v2, true);
2542 return v1.rsboi_spmhm(v2);
2543 }
2544
2545 #if RSBOI_WANT_DOUBLE_COMPLEX
DEFBINOP(op_c_mul,sparse_rsb_mtx,matrix)2546 DEFBINOP(op_c_mul, sparse_rsb_mtx, matrix)
2547 {
2548 // "*" operator
2549 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2550 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_complex_matrix&);
2551 //return v1.rsboi_spmm(v2, false);
2552 return v1.rsboi_spmm(v2);
2553 }
2554
DEFBINOP(op_c_trans_mul,sparse_rsb_mtx,matrix)2555 DEFBINOP(op_c_trans_mul, sparse_rsb_mtx, matrix)
2556 {
2557 // ".'*" operator
2558 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2559 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_complex_matrix&);
2560 //return v1.rsboi_spmm(v2, true);
2561 return v1.rsboi_spmtm(v2);
2562 }
2563
DEFBINOP(op_c_herm_mul,sparse_rsb_mtx,matrix)2564 DEFBINOP(op_c_herm_mul, sparse_rsb_mtx, matrix)
2565 {
2566 // "'*" operator
2567 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2568 RSB_CAST_BINOP_ARGS (const octave_sparsersb_mtx&, const octave_complex_matrix&);
2569 //return v1.rsboi_spmm(v2, true);
2570 return v1.rsboi_spmhm(v2);
2571 }
2572 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2573
2574 #if RSBOI_USE_PATCH_OCT44
2575 #define RSBOI_INSTALL_BINOP(op, t1, t2, f) { \
2576 octave::type_info& type_info = octave::__get_type_info__ ("");\
2577 type_info.register_binary_op(octave_value::op, t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_binop_, f)); }
2578
2579 #define RSBOI_INSTALL_ASSIGNOP(op, t1, t2, f) { \
2580 octave::type_info& type_info = octave::__get_type_info__ ("");\
2581 type_info.register_assign_op(octave_value::op, t1::static_type_id (), t2::static_type_id (), CONCAT2 (oct_assignop_, f)); }
2582
2583 #define RSBOI_INSTALL_UNOP(op, t1, f) { \
2584 octave::type_info& type_info = octave::__get_type_info__ ("");\
2585 type_info.register_unary_op(octave_value::op, t1::static_type_id (), CONCAT2 (oct_unop_, f)); }
2586 #else /* RSBOI_USE_PATCH_OCT44 */
2587 // deprecated; need a wrapper using octave::typeinfo::register_binary_op
2588 #define RSBOI_INSTALL_BINOP INSTALL_BINOP
2589
2590 // deprecated; need a wrapper using octave::typeinfo::register_assign_op
2591 #define RSBOI_INSTALL_ASSIGNOP INSTALL_ASSIGNOP
2592
2593 // deprecated; need a wrapper using octave::typeinfo::register_unary_op
2594 #define RSBOI_INSTALL_UNOP INSTALL_UNOP
2595 #endif /* RSBOI_USE_PATCH_OCT44 */
2596
install_sparsersb_ops(void)2597 static void install_sparsersb_ops (void)
2598 {
2599 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2600 #ifdef RSB_FULLY_IMPLEMENTED
2601 /* boolean pattern-based not */
2602 RSBOI_INSTALL_UNOP (op_not, octave_sparsersb_mtx, op_not);
2603 /* to-dense operations */
2604 RSBOI_INSTALL_ASSIGNOP (op_asn_eq, octave_sparsersb_mtx, octave_scalar, assigns);
2605 /* ? */
2606 RSBOI_INSTALL_UNOP (op_uplus, octave_sparsersb_mtx, uplus);
2607 /* elemental comparison, evaluate to sparse or dense boolean matrices */
2608 RSBOI_INSTALL_BINOP (op_eq, octave_sparsersb_mtx, , );
2609 RSBOI_INSTALL_BINOP (op_le, octave_sparsersb_mtx, , );
2610 RSBOI_INSTALL_BINOP (op_lt, octave_sparsersb_mtx, , );
2611 RSBOI_INSTALL_BINOP (op_ge, octave_sparsersb_mtx, , );
2612 RSBOI_INSTALL_BINOP (op_gt, octave_sparsersb_mtx, , );
2613 RSBOI_INSTALL_BINOP (op_ne, octave_sparsersb_mtx, , );
2614 /* pure elemental; scalar and sparse arguments ?! */
2615 // ?
2616 RSBOI_INSTALL_BINOP (op_el_ldiv, octave_sparsersb_mtx, , );
2617 RSBOI_INSTALL_BINOP (op_el_ldiv_eq, octave_sparsersb_mtx, , ); // errval = rsb_mtx_upd_values(this->mtxAp,RSB_ELOPF_SCALE_ROWS,cm.data());
2618 RSBOI_INSTALL_BINOP (op_el_mul_eq, octave_sparsersb_mtx, , ); // diagonal subst ??
2619 RSBOI_INSTALL_BINOP (op_el_and, octave_sparsersb_mtx, , );
2620 RSBOI_INSTALL_BINOP (op_el_or, octave_sparsersb_mtx, , );
2621 /* shift operations: they may be left out from the implementation */
2622 RSBOI_INSTALL_BINOP (op_lshift, octave_sparsersb_mtx, , );
2623 RSBOI_INSTALL_BINOP (op_rshift, octave_sparsersb_mtx, , );
2624 #endif
2625 // RSBOI_INSTALL_ASSIGNOP (op_el_div_eq, octave_sparsersb_mtx, octave_matrix, rsb_op_el_div_eq_sc); // errval = rsb_mtx_upd_values(this->mtxAp,RSB_ELOPF_SCALE_ROWS,cm.data());
2626 // RSBOI_INSTALL_ASSIGNOP (op_el_mul_eq, octave_sparsersb_mtx, octave_matrix, rsb_op_el_mul_eq_sc);
2627 //INSTALL_WIDENOP (octave_sparsersb_mtx, octave_sparse_matrix,octave_sparse_rsb_to_octave_sparse_conv);/* a DEFCONV .. */
2628 //INSTALL_ASSIGNCONV (octave_sparsersb_mtx, octave_sparse_matrix,octave_sparse_matrix);/* .. */
2629 // no need for the following: need a good conversion function, though
2630 //RSBOI_INSTALL_UNOP (op_incr, octave_sparsersb_mtx, op_incr);
2631 //RSBOI_INSTALL_UNOP (op_decr, octave_sparsersb_mtx, op_decr);
2632 RSBOI_INSTALL_BINOP (op_el_mul, octave_sparsersb_mtx, octave_scalar, rsb_el_mul_s);
2633 #if RSBOI_WANT_DOUBLE_COMPLEX
2634 RSBOI_INSTALL_BINOP (op_el_mul, octave_sparsersb_mtx, octave_complex, rsb_el_mul_c);
2635 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2636 // RSBOI_INSTALL_ASSIGNOP (op_mul_eq, octave_sparsersb_mtx, octave_scalar, rsb_op_mul_eq_s); // 20110313 not effective
2637 // RSBOI_INSTALL_ASSIGNOP (op_div_eq, octave_sparsersb_mtx, octave_scalar, rsb_op_div_eq_s); // 20110313 not effective
2638 RSBOI_INSTALL_BINOP (op_el_div, octave_sparsersb_mtx, octave_scalar, rsb_el_div_s);
2639 #if RSBOI_WANT_DOUBLE_COMPLEX
2640 RSBOI_INSTALL_BINOP (op_el_div, octave_sparsersb_mtx, octave_complex, rsb_el_div_c);
2641 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2642 RSBOI_INSTALL_BINOP (op_el_pow, octave_sparsersb_mtx, octave_scalar, el_pow);
2643 RSBOI_INSTALL_BINOP (op_el_pow, octave_sparsersb_mtx, octave_complex, el_pow_c);
2644 RSBOI_INSTALL_UNOP (op_uminus, octave_sparsersb_mtx, uminus);
2645 RSBOI_INSTALL_BINOP (op_ldiv, octave_sparsersb_mtx, octave_matrix, ldiv);
2646 RSBOI_INSTALL_BINOP (op_el_ldiv, octave_sparsersb_mtx, octave_matrix, el_ldiv);
2647 RSBOI_INSTALL_BINOP (op_div, octave_sparsersb_mtx, octave_matrix, div);
2648 RSBOI_INSTALL_BINOP (op_div, octave_sparsersb_mtx, octave_scalar, rsb_s_div);
2649 #if RSBOI_WANT_DOUBLE_COMPLEX
2650 RSBOI_INSTALL_BINOP (op_div, octave_sparsersb_mtx, octave_complex, rsb_c_div);
2651 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2652 RSBOI_INSTALL_BINOP (op_mul, octave_sparsersb_mtx, octave_scalar, rsb_s_mul);
2653 RSBOI_INSTALL_BINOP (op_mul, octave_scalar, octave_sparsersb_mtx, s_rsb_mul);
2654 #if RSBOI_WANT_DOUBLE_COMPLEX
2655 RSBOI_INSTALL_BINOP (op_mul, octave_sparsersb_mtx, octave_complex, rsb_c_mul);
2656 RSBOI_INSTALL_BINOP (op_mul, octave_complex, octave_sparsersb_mtx, c_rsb_mul);
2657 RSBOI_INSTALL_BINOP (op_mul, octave_sparsersb_mtx, octave_complex_matrix, op_c_mul);
2658 RSBOI_INSTALL_BINOP (op_trans_mul, octave_sparsersb_mtx, octave_complex_matrix, op_c_trans_mul);
2659 RSBOI_INSTALL_BINOP (op_herm_mul, octave_sparsersb_mtx, octave_complex_matrix, op_c_herm_mul);
2660 RSBOI_INSTALL_BINOP (op_ldiv, octave_sparsersb_mtx, octave_complex_matrix, c_ldiv);
2661 RSBOI_INSTALL_BINOP (op_trans_ldiv, octave_sparsersb_mtx, octave_complex_matrix, trans_c_ldiv);
2662 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2663 #if RSBOI_WANT_POW
2664 RSBOI_INSTALL_BINOP (op_pow, octave_sparsersb_mtx, octave_scalar, rsb_s_pow);
2665 #endif /* RSBOI_WANT_POW */
2666 RSBOI_INSTALL_BINOP (op_el_div, octave_sparsersb_mtx, octave_matrix, el_div);
2667 RSBOI_INSTALL_UNOP (op_transpose, octave_sparsersb_mtx, transpose);
2668 RSBOI_INSTALL_UNOP (op_hermitian, octave_sparsersb_mtx, htranspose);
2669 RSBOI_INSTALL_ASSIGNOP (op_asn_eq, octave_sparsersb_mtx, octave_sparse_matrix, assign);
2670 RSBOI_INSTALL_ASSIGNOP (op_asn_eq, octave_sparsersb_mtx, octave_matrix, assignm);
2671 RSBOI_INSTALL_BINOP (op_mul, octave_sparsersb_mtx, octave_matrix, op_mul);
2672 //RSBOI_INSTALL_BINOP (op_pow, octave_sparsersb_mtx, octave_matrix, op_pow);
2673 RSBOI_INSTALL_BINOP (op_sub, octave_sparsersb_mtx, octave_sparsersb_mtx, op_sub);
2674 RSBOI_INSTALL_BINOP (op_add, octave_sparsersb_mtx, octave_sparsersb_mtx, op_add);
2675 //RSBOI_INSTALL_BINOP (op_trans_add, octave_sparsersb_mtx, octave_sparsersb_mtx, op_trans_add);
2676 RSBOI_INSTALL_BINOP (op_mul, octave_sparsersb_mtx, octave_sparsersb_mtx, op_spmul);
2677 RSBOI_INSTALL_BINOP (op_trans_mul, octave_sparsersb_mtx, octave_matrix, op_trans_mul);
2678 RSBOI_INSTALL_BINOP (op_herm_mul, octave_sparsersb_mtx, octave_matrix, op_herm_mul);
2679 RSBOI_INSTALL_BINOP (op_trans_ldiv, octave_sparsersb_mtx, octave_matrix, trans_ldiv);
2680 //RSBOI_INSTALL_BINOP (op_mul_trans, octave_sparsersb_mtx, octave_matrix, op_mul_trans);
2681 //RSBOI_INSTALL_BINOP (op_mul_trans, octave_sparsersb_mtx, octave_matrix, op_mul_trans);
2682 //RSBOI_INSTALL_BINOP (op_herm_mul, octave_sparsersb_mtx, octave_matrix, op_herm_mul);
2683 //RSBOI_INSTALL_BINOP (op_mul_herm, octave_sparsersb_mtx, octave_matrix, op_mul_herm);
2684 //RSBOI_INSTALL_BINOP (op_el_not_and, octave_sparsersb_mtx, octave_matrix, op_el_not_and);
2685 //RSBOI_INSTALL_BINOP (op_el_not_or , octave_sparsersb_mtx, octave_matrix, op_el_not_or );
2686 //RSBOI_INSTALL_BINOP (op_el_and_not, octave_sparsersb_mtx, octave_matrix, op_el_and_not);
2687 //RSBOI_INSTALL_BINOP (op_el_or _not, octave_sparsersb_mtx, octave_matrix, op_el_or _not);
2688 }
2689
install_sparse_rsb(void)2690 static void install_sparse_rsb (void)
2691 {
2692 static bool rsboi_initialized = false;
2693
2694 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2695
2696 if(!rsboi_initialized)
2697 {
2698 rsb_err_t errval = RSB_ERR_NO_ERROR;
2699
2700 if(sparsersb_tester() == false)
2701 {
2702 goto err;
2703 }
2704 errval = rsb_lib_init(RSB_NULL_INIT_OPTIONS);
2705 if(RSBOI_SOME_ERROR(errval))
2706 {
2707 RSBOI_PERROR(errval);
2708 goto err;
2709 }
2710 rsboi_initialized = true;
2711 }
2712 else
2713 ;/* already initialized */
2714
2715 if (!rsboi_sparse_rsb_loaded)
2716 {
2717 octave_sparsersb_mtx::register_type ();
2718 install_sparsersb_ops ();
2719 rsboi_sparse_rsb_loaded = true;
2720
2721 #if RSBOI_USE_PATCH_OCT44
2722 octave::interpreter::the_interpreter()->mlock();
2723 #else /* RSBOI_USE_PATCH_OCT44 */
2724 mlock();
2725 #endif /* RSBOI_USE_PATCH_OCT44 */
2726 }
2727 return;
2728 err:
2729 RSBIO_NULL_STATEMENT_FOR_COMPILER_HAPPINESS
2730 } /* install_sparse_rsb */
2731
2732 DEFUN_DLD (RSB_SPARSERSB_LABEL, args, nargout,
2733 "-*- texinfo -*-\n\
2734 @deftypefn {Loadable Function} {@var{S} =} " RSBOI_FNS " (@var{A})\n\
2735 @deftypefnx {Loadable Function} {@var{S} =} " RSBOI_FNS " (@var{I}, @var{J}, @var{SV}, @var{M}, @var{N})\n\
2736 @deftypefnx {Loadable Function} {@var{S} =} " RSBOI_FNS " (@var{I}, @var{J}, @var{SV}, @var{M}, @var{N}, @var{NZMAX})\n\
2737 @deftypefnx {Loadable Function} {@var{S} =} " RSBOI_FNS " (@var{I}, @var{J}, @var{SV})\n\
2738 @deftypefnx {Loadable Function} {@var{S} =} " RSBOI_FNS " (@var{M}, @var{N})\n\
2739 @deftypefnx {Loadable Function} {@var{S} =} " RSBOI_FNS " (@var{I}, @var{J}, @var{SV}, @var{M}, @var{N}, \"unique\")\n\
2740 @deftypefnx {Loadable Function} " RSBOI_FNS " (\"set\", @var{OPN}, @var{OPV})\n\
2741 @deftypefnx {Loadable Function} {@var{v} =} " RSBOI_FNS " (@var{S}, \"get\", @var{MIF})\n\
2742 @deftypefnx {Loadable Function} {@var{v} =} " RSBOI_FNS " (@var{S}, @var{QS})\n\
2743 @deftypefnx {Loadable Function} " RSBOI_FNS " (@var{A},\"save\",@var{MTXFILENAME})\n\
2744 @deftypefnx {Loadable Function} {[@var{S}[, @var{nrows}[, @var{NCOLS}[, @var{NNZ}[, @var{REPINFO}[, @var{FIELD}[, @var{SYMMETRY}]]]]]]] =} " RSBOI_FNS " (@var{MTXFILENAME}[, @var{MTXTYPESTRING}])\n\
2745 " RSBOI_10100_DOCH ""\
2746 \
2747 "\n"\
2748 "Create or manipulate sparse matrices using the RSB format provided by librsb, almost as you do with @code{sparse}.\n"\
2749 "\n"\
2750 "If @var{A} is a @code{full} matrix, convert it to a sparse matrix representation,\n\
2751 removing all zero values.\n"\
2752 "If @var{A} is a @code{sparse} matrix, convert it to a sparse matrix representation.\n"\
2753 "\n\
2754 Given the integer index vectors @var{I} and @var{J}, and a 1-by-@code{nnz}\n\
2755 vector of real or complex values @var{SV}, construct the sparse matrix\n\
2756 @code{S(@var{I}(@var{K}),@var{J}(@var{K})) = @var{SV}(@var{K})} with overall\n\
2757 dimensions @var{M} and @var{N}. \n\
2758 \nThe argument\n\
2759 @code{@var{NZMAX}} is ignored but accepted for compatibility with @sc{Matlab} and @code{sparse}.\n\
2760 \n\
2761 If @var{M} or @var{N} are not specified their values are derived from the\n\
2762 maximum index in the vectors @var{I} and @var{J} as given by\n\
2763 @code{@var{M} = max (@var{I})}, @code{@var{N} = max (@var{J})}.\n\
2764 \n\
2765 \
2766 Can load a matrix from a Matrix Market matrix file named @var{MTXFILENAME}. \
2767 The optional argument @var{MTXTYPESTRING} can specify either real (@code{\"D\"}) or complex (@code{\"Z\"}) type. \
2768 Default is real.\n"\
2769 "In the case @var{MTXFILENAME} is @code{\"" RSBOI_LIS "\"}, a string listing the available numerical types with BLAS-style characters will be returned. If the file turns out to contain a Matrix Market dense vector, this will be loaded.\n"\
2770 \
2771 \
2772 "\n\
2773 \
2774 If @code{\"save\"} is specified, saves the sparse matrix as a Matrix Market matrix file named @var{MTXFILENAME}.\n"\
2775 "\n\
2776 \
2777 @strong{Note}: if multiple values are specified with the same\n\
2778 @var{I}, @var{J} indices, the corresponding values in @var{SV} will\n\
2779 be added.\n\
2780 \n\
2781 The following are all equivalent:\n\
2782 \n\
2783 @example\n\
2784 @group\n\
2785 S = " RSBOI_FNS " (I, J, SV, M, N)\n\
2786 S = " RSBOI_FNS " (I, J, SV, M, N, \"summation\")\n\
2787 S = " RSBOI_FNS " (I, J, SV, M, N, \"sum\")\n"\
2788 /*"S = " RSBOI_FNS " (I, J, SV, \"summation\")\n"*/\
2789 /*"S = " RSBOI_FNS " (I, J, SV, \"sum\")\n"*/\
2790 "@end group\n\
2791 @end example\n\
2792 \n\
2793 \
2794 If the optional @code{\"unique\"} keyword is specified instead, then if more than two values are specified for the\n\
2795 same @var{I}, @var{J} indices, only the last value will be used.\n\
2796 \n\
2797 \
2798 If the optional @code{\"symmetric\"} or @code{\"sym\"} keyword follows, then the input will be considered as the tringle of a symmetric matrix.\n\
2799 If the optional @code{\"hermitian\"} or @code{\"her\"} keyword follows, then the input will be considered as the tringle of a hermitian matrix.\n\
2800 If the optional @code{\"general\"} or @code{\"gen\"} keyword follows, then no symmetry hint is being given.\n\
2801 \n\
2802 @code{" RSBOI_FNS " (@var{M}, @var{N})} will create an empty @var{M}-by-@var{N} sparse\n\
2803 matrix and is equivalent to @code{" RSBOI_FNS " ([], [], [], @var{M}, @var{N})}.\n\
2804 \n\
2805 \
2806 \n\
2807 \
2808 If @var{M} or @var{N} are not specified, then @code{@var{M} = max (@var{I})}, @code{@var{N} = max (@var{J})}.\n\
2809 \n\
2810 \
2811 If @var{OPN} is a string representing a valid librsb option name and @var{OPV} is a string representing a valid librsb option value, these will be passed to the @code{rsb_lib_set_opt_str()} function.\n\
2812 \n\
2813 \
2814 If @var{MIF} is a string specifying a valid librsb matrix info string (valid for librsb's @code{rsb_mtx_get_info_from_string()}), then the corresponding value will be returned for matrix @code{@var{S}}, in string @code{@var{V}}. If @var{MIF} is the an empty string (@code{\"\"}), matrix structure information will be returned. As of librsb-1.2, this is debug or internal information. E.g. for @code{\"RSB_MIF_LEAVES_COUNT__TO__RSB_BLK_INDEX_T\"}, a string with the count of internal RSB blocks will be returned.\n\
2815 \n"\
2816 \
2817 /*"If @var{S} is a " RSBOI_FNS " matrix and @var{QS} is a string, @var{QS} will be interpreted as a query string about matrix @var{S}. String @code{@var{V}} will be returned. See librsb's @code{rsb_mtx_get_info_str()}.\n\
2818 @strong{Note}: this feature is still incomplete, and whatever the value of @var{QS}, a general information string will be returned.\n"*/\
2819 \
2820 "If @var{S} is a @code{" RSBOI_FNS "} matrix and @var{QS} is a string, @var{QS} shall be interpreted as a query string about matrix @var{S}. String @code{@var{V}} will be returned with query results. \n @strong{Note}: this feature is to be completed and its syntax reserved for future use. In this version, whatever the value of @var{QS}, a general matrix information string will be returned (like @code{" RSBOI_FNS "(@var{S},\"get\",\"RSB_MIF_LEAVES_COUNT__TO__RSB_BLK_INDEX_T\")} ).\n"\
2821 "\n"\
2822 /*If any of @var{SV}, @var{I} or @var{J} are scalars, they are expanded\n\
2823 to have a common size.\n*/
2824 RSBOI_10100_DOC ""\
2825 "\n\
2826 Long (64 bit) index support is partial: if Octave has been configured for 64 bit indices, @code{" RSBOI_FNS "} will correctly handle and convert matrices/indices that would fit in a 32 bit indices setup, failing on 'larger' ones. \n\
2827 \n\
2828 @strong{Note}: @code{" RSBOI_FNS "} variables behave just as @code{full} or @code{sparse} variables for @strong{most} operators.\n\
2829 But interaction of binary sparse matrix -- sparse matrix operators involving @strong{symmetric} @code{" RSBOI_FNS "} matrices is not complete and may give unexpected results.\n\
2830 \n\
2831 @strong{Note}: \
2832 Multiplication of a @code{" RSBOI_FNS "} variable by a @code{sparse} one (or the other way round) will expand @code{" RSBOI_FNS "}'s symmetry because of conversion to @code{sparse}.\n\
2833 Multiplication of two @code{" RSBOI_FNS "} variables will not undergo any conversion or symmetry expansion (which might come as unexpected).\n\
2834 \n\
2835 @strong{Note}: \
2836 Summation of a @code{" RSBOI_FNS "} variable with a @code{sparse} one (or the other way round) will expand @code{" RSBOI_FNS "}'s symmetry because of conversion to @code{sparse}.\n\
2837 Summation of two @code{" RSBOI_FNS "} variables will not undergo any conversion or symmetry expansion (which might come as unexpected).\n\
2838 \n\
2839 @strong{Note}: \
2840 Accessing a symmetric or hermitian @code{" RSBOI_FNS "} variable at indices falling in the empty triangle will return a zero.\n\
2841 Accessing via (:,:) will imply symmetry/hermitianness expansion and conversion to @code{sparse}.\n\
2842 \n\
2843 @seealso{sparse, full, nnz, rows, columns, tril, triu, istril, istriu, issparse, iscomplex, isreal, issymmetric, ishermitian}\n\
2844 @end deftypefn")
2845 {
2846 int nargin = args.length ();
2847 octave_value_list retval;
2848 octave_sparsersb_mtx*osmp = RSBOI_NULL;
2849 bool ic0 = nargin>0?(args(0).iscomplex()):false;
2850 bool ic3 = nargin>2?(args(2).iscomplex()):false;
2851 bool isr = (nargin>0 && args(0).type_name()==RSB_OI_TYPEINFO_STRING);
2852
2853 RSBOI_DEBUG_NOTICE("in sparsersb()\n");
2854
2855 if(ic0)
2856 {
2857 RSBOI_WARN(RSBOI_O_MISSIMPERRMSG);
2858 }
2859
2860 if(isr)
2861 osmp = ((octave_sparsersb_mtx*)(args(0).internal_rep()));
2862
2863 if(ic3 || ic0)
2864 #if RSBOI_WANT_DOUBLE_COMPLEX
2865 RSBOI_WARN(RSBOI_0_UNCFEMSG);
2866 #else /* RSBOI_WANT_DOUBLE_COMPLEX */
2867 RSBOI_0_ERROR(RSBOI_0_NOCOERRMSG);
2868 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
2869 install_sparse_rsb();
2870 if( nargin == 3 && args(0).is_string() && args(0).string_value()=="set" && args(1).is_string() && args(2).is_string())
2871 {
2872 // sparsersb ("set", OPN, OPV)
2873 const auto os = args(1).string_value();
2874 const auto vs = args(2).string_value();
2875 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2876 const rsb_err_t errval = rsb_lib_set_opt_str(os.c_str(),vs.c_str());
2877 if(RSBOI_SOME_ERROR(errval))
2878 {
2879 error ("failed setting option %s to %s (error %d)!",os.c_str(),vs.c_str(),errval);
2880 goto err;
2881 }
2882 goto ret;
2883 }
2884
2885 if( nargin >= 2 && args(0).is_string() && args(0).string_value()=="set" /* && args(1).is_string() */ )
2886 {
2887 // sparsersb ("set", XXX)
2888 error ("%s", "did you intend to set librsb options ? use the correct syntax then ! (third argument missing)"); goto errp;
2889 }
2890
2891 if( nargin == 2 && args(0).is_string() && args(0).string_value()=="get" && args(1).is_string() )
2892 {
2893 // sparsersb ("get", XXX)
2894 /* FIXME: unfinished feature ! */
2895 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
2896 error ("%s", "getting library options still unimplemented!");
2897 goto errp;
2898 }
2899
2900 #if defined(RSB_LIBRSB_VER) && (RSB_LIBRSB_VER>=10100)
2901 if (nargin >= 2 && isr && args(1).is_string() && args(1).string_value()=="autotune")
2902 {
2903 // sparsersb (S,"autotune"[, TRANSA, NRHS, MAXR, TMAX, TN, SF])
2904 rsb_err_t errval = RSB_ERR_NO_ERROR;
2905 /* these are user settable */
2906 rsb_coo_idx_t nrhs = 0;
2907 rsb_int_t maxr = 1;
2908 rsb_time_t tmax = 2.0;
2909 rsb_int_t tn = 0;
2910 rsb_real_t sf = 1.0;
2911 rsb_trans_t transA = RSB_TRANSPOSITION_N;
2912 /* the following may also be user settable in the future */
2913 const void *alphap = RSBOI_NULL;
2914 const void *betap = RSBOI_NULL;
2915 /* these not */
2916 rsb_flags_t order = RSB_OI_DMTXORDER;
2917 const void * Bp = RSBOI_NULL;
2918 rsb_nnz_idx_t ldB = 0;
2919 rsb_nnz_idx_t ldC = 0;
2920 void * Cp = RSBOI_NULL;
2921
2922 if (nargin > 2) transA = RSB_CHAR_AS_TRANSPOSITION(args(2).string_value()[0]);
2923 if (transA == RSBOI_INVALID_TRANS_CHAR)
2924 {
2925 RSBOI_0_ERROR(RSBOI_0_WTRANSMSG);
2926 goto ret;
2927 }
2928 if (nargin > 3) nrhs = args(3).scalar_value();
2929 if (nargin > 4) maxr = args(4).scalar_value();
2930 if (nargin > 5) tmax = args(5).scalar_value();
2931 if (nargin > 6) tn = args(6).scalar_value();
2932 if (nargin > 7) sf = args(7).scalar_value();
2933
2934 // ...
2935 if(!osmp || !osmp->mtxAp)
2936 RSBOI_0_INTERRMSGSTMT(goto ret)
2937 if(nargout)
2938 {
2939 struct rsb_mtx_t *mtxAp = RSBOI_NULL;
2940 errval = rsb_mtx_clone(&mtxAp,RSB_NUMERICAL_TYPE_SAME_TYPE,RSB_TRANSPOSITION_N,RSBOI_NULL,osmp->mtxAp,RSBOI_EXPF);
2941 rsboi_error(errval);
2942 errval = rsb_tune_spmm(&mtxAp,&sf,&tn,maxr,tmax,transA,alphap,RSBOI_NULL,nrhs,order,Bp,ldB,betap,Cp,ldC);
2943 rsboi_error(errval);
2944 retval.append(new octave_sparsersb_mtx(mtxAp));
2945 }
2946 else
2947 errval = rsb_tune_spmm(&osmp->mtxAp,&sf,&tn,maxr,tmax,transA,alphap,RSBOI_NULL/*osmp->mtxAp*/,nrhs,order,Bp,ldB,betap,Cp,ldC);
2948 rsboi_error(errval);
2949 goto ret;
2950 }
2951 #endif
2952
2953
2954 #if defined(RSB_LIBRSB_VER) && (RSB_LIBRSB_VER>=10100)
2955 if (nargin >= 3 && isr
2956 && args(1).is_string() && args(1).string_value().substr(0,6)=="render"
2957 && args(2).is_string())
2958 {
2959 // sparsersb (S,"render", FILENAME[, RWIDTH, RHEIGHT])
2960 rsb_err_t errval = RSB_ERR_NO_ERROR;
2961 std::string rmf = args(2).string_value();
2962 rsb_coo_idx_t pmWidth = 512, pmHeight = 512; /* Care to update the documentation when changing these. */
2963 rsb_flags_t marf = RSB_MARF_EPS;
2964 /* may tell the user to supply a sparsersb matrix in case input is not 'sparse' */
2965
2966 if (nargin > 3) pmWidth = args(3).scalar_value();
2967 if (nargin > 4) pmHeight = args(4).scalar_value();
2968
2969 if(!osmp || !osmp->mtxAp)
2970 RSBOI_0_INTERRMSGSTMT(goto ret)
2971
2972 if( args(1).string_value() == "renders")
2973 marf = RSB_MARF_EPS_S;
2974 if( args(1).string_value() == "renderb")
2975 marf = RSB_MARF_EPS_B;
2976 errval = rsb_mtx_rndr(rmf.c_str(),osmp->mtxAp,pmWidth,pmHeight,marf);
2977 if(RSBOI_SOME_ERROR(errval))
2978 {
2979 retval.append(std::string("Error returned from rsb_mtx_rndr()"));
2980 rsboi_error(errval);
2981 }
2982 goto ret;
2983 }
2984 #endif
2985 #if RSBOI_WANT_MTX_SAVE
2986 if (nargin == 3 && isr
2987 && args(1).is_string() && args(1).string_value()=="save"
2988 && args(2).is_string())
2989 {
2990 // sparsersb (A,"save",MTXFILENAME)
2991 rsb_err_t errval = RSB_ERR_NO_ERROR;
2992 errval = rsb_file_mtx_save(osmp->mtxAp,args(2).string_value().c_str());
2993 rsboi_error(errval);
2994 goto ret;
2995 }
2996 #endif
2997 if (nargin == 3 && isr
2998 && args(1).is_string() && args(1).string_value()=="get"
2999 && args(2).is_string())
3000 {
3001 // sparsersb (S, "get", MIF)
3002 // For any version of lirsb, you can get valid values with e.g.:
3003 // grep RSB_MIF path-to/rsb.h | sed 's/^[, ]*//g;s/\([A-Z_]\+\).*<\(.\+\)(.*$/\1: \2/g;s/$/;/g'
3004 rsb_err_t errval = RSB_ERR_NO_ERROR;
3005 char is[RSBOI_INFOBUF];
3006 char ss[RSBOI_INFOBUF];
3007
3008 if(!osmp || !osmp->mtxAp)
3009 RSBOI_0_INTERRMSGSTMT(goto ret)
3010
3011 if(strlen(args(2).string_value().c_str())==0)
3012 strncpy(is,"RSB_MIF_MATRIX_INFO__TO__CHAR_P",sizeof(is));
3013 else
3014 strncpy(is,args(2).string_value().c_str(),sizeof(is));
3015 errval = rsb_mtx_get_info_str(osmp->mtxAp,is,ss,RSBOI_INFOBUF);
3016
3017 if(!RSBOI_SOME_ERROR(errval))
3018 {
3019 retval.append(octave_value(ss));
3020 goto ret;
3021 }
3022 if(RSBOI_SOME_ERROR(errval))
3023 {
3024 retval.append(std::string("Error returned from rsb_mtx_get_info_from_string()"));
3025 }
3026 goto ret;
3027 }
3028
3029 if ( nargin >= 3 && isr && args(1).is_string() && args(1).string_value()=="get" /* && args(1).is_string() */ )
3030 {
3031 // sparsersb (S, "get", MIF, XXX)
3032 error ("%s", "did you intend to get matrices information ? use the correct syntax then !");
3033 goto errp;
3034 }
3035
3036 if ( nargin == 1 || nargin == 2 )
3037 {
3038 rsb_type_t typecode = RSBOI_TYPECODE;
3039 if (nargin >= 2)/* FIXME: this is weird ! */
3040 #if RSBOI_WANT_DOUBLE_COMPLEX
3041 typecode = RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX;
3042 #else /* RSBOI_WANT_DOUBLE_COMPLEX */
3043 RSBOI_0_ERROR(RSBOI_0_NOCOERRMSG);
3044 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
3045
3046 if (nargin == 2 && isr && args(1).is_string())
3047 #if RSBOI_WANT_QSI
3048 {
3049 // sparsersb (S, QS)
3050 char ss[RSBOI_INFOBUF];
3051 rsb_err_t errval = RSB_ERR_NO_ERROR;
3052
3053 if(!osmp || !osmp->mtxAp)
3054 RSBOI_0_INTERRMSGSTMT(goto ret)
3055 errval = rsb_mtx_get_info_str(osmp->mtxAp,"RSB_MIF_MATRIX_INFO__TO__CHAR_P",ss,RSBOI_INFOBUF);
3056 if(!RSBOI_SOME_ERROR(errval))
3057 retval.append(ss);
3058 /* TODO, FIXME: to add interpretation (we are ignoring args(1) !): this is to be extended. */
3059 RSBOI_WARN(RSBOI_0_UNFFEMSG);/* FIXME: this is yet unfinished */
3060 // octave_stdout << "Matrix information (in the future, supplementary information may be returned, as more inquiry functionality will be implemented):\n" << ss << "\n";
3061 /* FIXME: shall not print out, but rather return the info as a string*/
3062 //retval.append("place info string here !\n");
3063 goto ret;
3064 }
3065 #else /* RSBOI_WANT_QSI */
3066 {
3067 // sparsersb (S, QS)
3068 error ("%s", "invocation error !");
3069 goto errp;
3070 }
3071 #endif /* RSBOI_WANT_QSI */
3072 else
3073 if(args(0).issparse())
3074 {
3075 // sparsersb (sparse(...), ...)
3076 if( isr )
3077 {
3078 RSBOI_WARN(RSBOI_0_UNFFEMSG);
3079 retval.append(osmp = (octave_sparsersb_mtx*)(args(0).get_rep()).clone());
3080 }
3081 else
3082 {
3083 if(!ic0)
3084 {
3085 const SparseMatrix m = args(0).sparse_matrix_value();
3086 RSBOI_IF_ERR( goto err;)
3087 retval.append(osmp = new octave_sparsersb_mtx(m,typecode));
3088 }
3089 #if RSBOI_WANT_DOUBLE_COMPLEX
3090 else
3091 {
3092 const SparseComplexMatrix m = args(0).sparse_complex_matrix_value();
3093 RSBOI_IF_ERR( goto err;)
3094 retval.append(osmp = new octave_sparsersb_mtx(m,typecode));
3095 }
3096 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
3097 }
3098 }
3099 else
3100 if(args(0).is_string())
3101 {
3102 RSBOI_TRY_BLK
3103 {
3104 // sparsersb (MTXFILENAME)
3105 const std::string mtxfilename = args(0).string_value();
3106 RSBOI_IF_ERR( goto err;)
3107 if(mtxfilename == RSBOI_LIS)
3108 {
3109 //retval.append(RSB_NUMERICAL_TYPE_PREPROCESSOR_SYMBOLS);
3110 #if RSBOI_WANT_DOUBLE_COMPLEX
3111 retval.append("D Z");
3112 #else /* RSBOI_WANT_DOUBLE_COMPLEX */
3113 retval.append("D");
3114 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
3115 goto ret;
3116 }
3117 else
3118 {
3119 // [S, NROWS, NCOLS, NNZ, REPINFO, FIELD, SYMMETRY] = sparsersb (MTXFILENAME)
3120 rsb_type_t typecode = RSBOI_TYPECODE;
3121 RSBOI_WARN(RSBOI_0_UNFFEMSG);
3122 RSBOI_WARN("shall set the type, here");
3123 if(nargin>1 && args(1).is_string())
3124 {
3125 const std::string mtxtypestring = args(1).string_value();
3126 if(mtxtypestring == "complex" || mtxtypestring == "Z")
3127 #if RSBOI_WANT_DOUBLE_COMPLEX
3128 typecode = RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX;
3129 #else
3130 RSBOI_0_ERROR(RSBOI_0_NOCOERRMSG);
3131 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
3132 if(mtxtypestring == "real" || mtxtypestring=="D")
3133 typecode = RSB_NUMERICAL_TYPE_DOUBLE;
3134 }
3135 #if RSBOI_WANT_MTX_LOAD
3136 osmp = new octave_sparsersb_mtx(mtxfilename,typecode);
3137 #else /* RSBOI_WANT_DOUBLE_COMPLEX */
3138 goto ret; /* TODO: need error message here */
3139 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
3140 if(osmp->mtxAp)
3141 retval.append(osmp);
3142 else
3143 delete osmp;
3144 #if RSBOI_WANT_VECLOAD_INSTEAD_MTX
3145 if(!osmp->mtxAp)
3146 {
3147 rsb_nnz_idx_t n = 0;
3148 rsb_file_vec_load(mtxfilename.c_str(),typecode,RSBOI_NULL,&n);
3149 if(n<1)
3150 {
3151 // error ("%s", "are you sure you passed a valid Matrix Market vector file ?");
3152 goto err;
3153 }
3154
3155 if(typecode == RSB_NUMERICAL_TYPE_DOUBLE)
3156 {
3157 Matrix retvec(n,1,RSBOI_ZERO);
3158 rsb_file_vec_load(mtxfilename.c_str(),typecode,(RSBOI_T*)retvec.data(),&n);
3159 retval.append(retvec);
3160 }
3161 #if RSBOI_WANT_DOUBLE_COMPLEX
3162 else
3163 if(typecode == RSB_NUMERICAL_TYPE_DOUBLE_COMPLEX)
3164 {
3165 ComplexMatrix retvec(n,1,RSBOI_ZERO);
3166 rsb_file_vec_load(mtxfilename.c_str(),typecode,(RSBOI_T*)retvec.data(),&n);
3167 retval.append(retvec);
3168 }
3169 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
3170 goto ret;
3171 }
3172 #endif
3173 if(nargout) nargout--;
3174 if(nargout) retval.append(osmp->rows()),--nargout;
3175 if(nargout) retval.append(osmp->cols()),--nargout;
3176 if(nargout) retval.append(osmp->nnz()),--nargout;
3177 if(nargout) retval.append(osmp->get_info_string()),--nargout;
3178 if(nargout) retval.append((!osmp->iscomplex())?"real":"complex"),--nargout;
3179 if(nargout) retval.append(osmp->get_symmetry()),--nargout;
3180 }
3181 }
3182 RSBOI_CATCH_BLK
3183 }
3184 else
3185 {
3186 RSBOI_TRY_BLK
3187 {
3188 if (nargin == 2 && args(0).is_scalar_type() && args(1).is_scalar_type() )
3189 {
3190 // sparsersb (M, N)
3191 const SparseMatrix m = args(0).sparse_matrix_value();
3192 retval.append(osmp = new octave_sparsersb_mtx(SparseMatrix(args(0).scalar_value(),args(1).scalar_value())));
3193 }
3194 else
3195 {
3196 // sparsersb (A, XXX)
3197 if(!ic0)
3198 {
3199 Matrix m = args(0).matrix_value();
3200 RSBOI_IF_ERR( goto err;)
3201 retval.append(osmp = new octave_sparsersb_mtx(m));
3202 }
3203 #if RSBOI_WANT_DOUBLE_COMPLEX
3204 else
3205 {
3206 ComplexMatrix m = args(0).complex_matrix_value();
3207 RSBOI_IF_ERR( goto err;)
3208 retval.append(osmp = new octave_sparsersb_mtx(m));
3209 }
3210 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
3211 if(nargin >= 2)
3212 { error ("%s", "when initializing from a single matrix, no need for second argument !"); goto errp; }
3213 }
3214 }
3215 RSBOI_CATCH_BLK
3216 }
3217 }
3218 else
3219 if (nargin >= 3 && nargin <= 7 && !(args(0).is_string() || args(1).is_string() || args(2).is_string() ) )
3220 {
3221 // sparsersb (I, J, SV, M, N, "unique")
3222 rsb_flags_t eflags = RSBOI_DCF;
3223 rsb_flags_t sflags = RSB_FLAG_NOFLAGS;
3224 octave_idx_type nrA = 0, ncA = 0;
3225 int sai = 0; // string argument index
3226
3227 if (nargin > 3)
3228 {
3229 if ( nargin < 5)
3230 {
3231 if(nargin == 4 && args(3).is_string())
3232 goto checked;
3233 RSBOI_EERROR(RSBOI_0_BADINVOERRMSG);
3234 goto errp;
3235 }
3236 /* FIXME: integer_type should be also supported here: shouldn't it ?*/
3237 if( (!args(3).is_scalar_type()) || (!args(4).is_scalar_type()))
3238 {
3239 RSBOI_EERROR(RSBOI_0_BADINVOERRMSG);
3240 goto errp;
3241 }
3242 if( nargin > 5 && ((!args(5).is_string()) && (!args(5).is_scalar_type())))
3243 {
3244 RSBOI_EERROR(RSBOI_0_BADINVOERRMSG);
3245 goto errp;
3246 }
3247 }
3248 checked:
3249 if (nargin >= 5 )
3250 {
3251 nrA = args(3).scalar_value();/* FIXME: need index value here! */
3252 ncA = args(4).scalar_value();
3253 if(nrA<=0 || ncA<=0)
3254 {
3255 RSBOI_EERROR(RSBOI_O_NPMSERR);
3256 goto errp;
3257 }
3258 }
3259
3260 if (nargin >= 6 && args(5).is_string())
3261 sai = 5;
3262 else
3263 if (nargin == 4 && args(3).is_string())
3264 sai = 3;
3265 for(;sai>0 && sai<nargin;++sai)
3266 {
3267 std::string vv = args(sai).string_value();
3268
3269 if ( vv == "summation" || vv == "sum" )
3270 eflags = RSB_FLAG_DUPLICATES_SUM;
3271 else
3272 if ( vv == "unique" )
3273 eflags = RSB_FLAG_DUPLICATES_KEEP_LAST;
3274 #if RSBOI_WANT_SYMMETRY
3275 else
3276 if ( vv == "symmetric" || vv == "sym" )
3277 sflags = RSB_FLAG_SYMMETRIC;
3278 else
3279 if ( vv == "hermitian" || vv == "her" )
3280 sflags = RSB_FLAG_HERMITIAN;
3281 else
3282 if ( vv == "general" || vv == "gen" )
3283 ;
3284 #endif /* RSBOI_WANT_SYMMETRY */
3285 else
3286 {
3287 vv = "'" + vv;
3288 vv+="' is not a recognized keyword (unlike 'summation', 'unique', 'symmetric', 'hermitian', 'general')!";
3289 error ("%s",vv.c_str());
3290 goto errp;
3291 }
3292 }
3293 RSB_DO_FLAG_ADD(eflags,sflags);
3294 if (nargin >= 6 && args(5).isinteger())
3295 {
3296 /* we ignore this value for MATLAB compatibility */
3297 }
3298
3299 RSBOI_IF_ERR( goto err;)
3300
3301 if(!ic3)
3302 {
3303 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
3304 idx_vector iv = args(0).index_vector ();
3305 idx_vector jv = args(1).index_vector ();
3306 retval.append(osmp = new octave_sparsersb_mtx( iv, jv, args(2).matrix_value(),nrA,ncA,eflags ));
3307 }
3308 #if RSBOI_WANT_DOUBLE_COMPLEX
3309 else
3310 {
3311 RSBOI_DEBUG_NOTICE(RSBOI_D_EMPTY_MSG);
3312 idx_vector iv = args(0).index_vector ();
3313 idx_vector jv = args(1).index_vector ();
3314 retval.append(osmp = new octave_sparsersb_mtx( iv, jv, args(2).complex_matrix_value(),nrA,ncA,eflags ));
3315 }
3316 #endif /* RSBOI_WANT_DOUBLE_COMPLEX */
3317 }
3318 else
3319 goto errp;
3320 if(!osmp)
3321 {
3322 RSBOI_WARN(RSBOI_0_NEEDERR);
3323 RSBOI_DEBUG_NOTICE(RSBOI_0_FATALNBMSG);
3324 }
3325 #if RSBOI_WANT_HEAVY_DEBUG
3326 if(!rsb_is_correctly_built_rcsr_matrix(osmp->mtxAp)) // function non in rsb.h's API
3327 {
3328 RSBOI_WARN(RSBOI_0_NEEDERR);
3329 RSBOI_DEBUG_NOTICE(RSBOI_0_UNCBERR);
3330 }
3331 #endif
3332 goto err;
3333 errp:
3334 print_usage ();
3335 err:
3336 ret:
3337 return retval;
3338 }
3339 /*
3340 %!test
3341 %! assert( 0==nnz(sparsersb(3,3) .- sparse(3,3)) )
3342 %!test
3343 %! assert( 0==nnz(sparsersb([],[],[],3,3 ) .- sparse([],[],[],3,3 )) )
3344 %!test
3345 %! assert( 0==nnz(sparsersb([],[],[],3,3,123) .- sparse([],[],[],3,3,321)) )
3346 %!test
3347 %! s=sparsersb([2]);
3348 %! assert(s==2);
3349 %! assert(s!=1)
3350 %!test
3351 %! s=sparsersb([1,2],[1,1],[11,21],2,2 );
3352 %! assert(nnz(s)==2)
3353 %!test
3354 %! s=sparsersb([1,2],[1,1],[11,21],2,2,-1 );
3355 %! assert(nnz(s)==2)
3356 %!test
3357 %! s=sparsersb([1,2],[1,1],[11,21] );
3358 %! assert(nnz(s)==2)
3359 %!test
3360 %! s=sparsersb(10,10 );
3361 %! assert(nnz(s)==0)
3362 %!test
3363 %! s=sparsersb([1,1],[1,1],[11,21] );
3364 %! assert(nnz(s)==1)
3365 %! assert(s(1,1)==32)
3366 %!test
3367 %! s=sparsersb([1,1],[1,1],[11,21],2,2,"unique");
3368 %! assert(nnz(s)==1),
3369 %! assert(s(1,1)==21)
3370 %!test
3371 %! sparsersb("set","RSB_IO_WANT_VERBOSE_TUNING","1");
3372 %!test
3373 %! sparsersb("set","RSB_IO_WANT_VERBOSE_TUNING","0");
3374 %!test
3375 %! wvt=0;
3376 %! try
3377 %! sparsersb("set","...")
3378 %! wvt=1;
3379 %! end_try_catch
3380 %! assert(wvt==0)
3381 %!test
3382 %! sparsersb("set","FIXME: WE UNFORTUNATELY STILL SILENTLY IGNORE ERRORS HERE (NO RETURN VALUE)","1");
3383 %!test
3384 %! wvt=-1;
3385 %! try
3386 %! wvt=sparsersb("get","RSB_IO_WANT_VERBOSE_TUNING")
3387 %! assert(wvt==0 || wvt ==1)
3388 %! end_try_catch
3389 %! assert(wvt==-1)
3390 %!test
3391 %! s=sparsersb([1]);
3392 %! assert(sparsersb(s,"get","RSB_MIF_LEAVES_COUNT__TO__RSB_BLK_INDEX_T")=="1")
3393 %!test
3394 %! s=sparsersb([1]);
3395 %! assert(str2num(sparsersb(s,"get","RSB_MIF_LEAVES_COUNT__TO__RSB_BLK_INDEX_T"))==1)
3396 %!test
3397 %! s=sparsersb([1]);
3398 %! assert(str2num(sparsersb(s,"get","RSB_MIF_INDEX_STORAGE_IN_BYTES__TO__SIZE_T"))>1)
3399 %!test
3400 %! s=sparsersb([1]);
3401 %! assert(str2num(sparsersb(s,"get","RSB_MIF_INDEX_STORAGE_IN_BYTES_PER_NNZ__TO__RSB_REAL_T"))>1)
3402 %!test
3403 %! s=sparsersb([1]);
3404 %! assert(str2num(sparsersb(1*s,"get","RSB_MIF_MATRIX_TYPECODE__TO__RSB_TYPE_T"))==68) # D
3405 %!test
3406 %! s=sparsersb([1]);
3407 %! assert(str2num(sparsersb(i*s,"get","RSB_MIF_MATRIX_TYPECODE__TO__RSB_TYPE_T"))==90) # Z
3408 %!test
3409 %! s=sparsersb([1,1],[1,1],[11,21],2,2,"unique");
3410 %! assert(str2num(sparsersb(s,"get","RSB_MIF_LEAVES_COUNT__TO__RSB_BLK_INDEX_T"))>0)
3411 %!test
3412 %! s=sparsersb([1]);
3413 %! v=1;
3414 %! assert(strfind(sparsersb(sparsersb([1]),"get","WRONG SPEC STRING"),"Error")==1)
3415 %!test
3416 %! assert(sparsersb(sparsersb([11,0;21,22]),"get","RSB_MIF_TOTAL_SIZE__TO__SIZE_T")>1)
3417 %!test
3418 %! assert(length(sparsersb(sparsersb([11,0;21,22]),"RSB_MIF_TOTAL_SIZE__TO__SIZE_T"))>1)
3419 %!test
3420 %! s=sparsersb([11,0;21,22]);
3421 %! assert(sparsersb(s,"RSB_MIF_TOTAL_SIZE__TO__SIZE_T") == sparsersb(s,"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))
3422 %!test
3423 %! s=sparsersb([1]);
3424 %! sparsersb(sparsersb([11,0;21,22]),"save","sparsersb_temporary_matrix_file.mtx")
3425 %!test
3426 %! [S, NROWS, NCOLS, NNZ, REPINFO, FIELD, SYMMETRY] = sparsersb("sparsersb_temporary_matrix_file.mtx" );
3427 %! assert(NROWS==2)
3428 %! assert(NCOLS==2)
3429 %! assert(NNZ==3)
3430 %! assert(FIELD=="real");
3431 %! assert(SYMMETRY=='U');
3432 %!test
3433 %! [S, NROWS, NCOLS, NNZ, REPINFO, FIELD, SYMMETRY] = sparsersb("sparsersb_temporary_matrix_file.mtx", "Z");
3434 %! assert(NROWS==2);
3435 %! assert(NCOLS==2);
3436 %! assert(NNZ==3);
3437 %! assert(FIELD=="complex");
3438 %! assert(SYMMETRY=='U');
3439 %!test
3440 %! [S, NROWS, NCOLS, NNZ, REPINFO, FIELD] = sparsersb("sparsersb_temporary_matrix_file.mtx", "D");
3441 %! assert(NROWS==2);
3442 %! assert(NCOLS==2);
3443 %! assert(NNZ==3);
3444 %! assert(FIELD=="real");
3445 %!test
3446 %! [S, NROWS, NCOLS, NNZ, REPINFO] = sparsersb("sparsersb_temporary_matrix_file.mtx", "D");
3447 %! assert(NROWS==2);
3448 %! assert(NCOLS==2);
3449 %! assert(NNZ==3);
3450 %!test
3451 %! [S, NROWS, NCOLS] = sparsersb("sparsersb_temporary_matrix_file.mtx", "D");
3452 %! assert(NROWS==2);
3453 %! assert(NCOLS==2);
3454 %!test
3455 %! [S, NROWS] = sparsersb("sparsersb_temporary_matrix_file.mtx", "D");
3456 %! assert(NROWS==2);
3457 %!test
3458 %! rrm=sparsersb(sprand(1000,1000,0.001));
3459 %! sparsersb(rrm,"render", "sparsersb_temporary_render.eps" ,1024); # will use defaults for rWidth
3460 %!test
3461 %! rrm=sparsersb(sprand(1000,1000,0.001));
3462 %! sparsersb(rrm,"render", "sparsersb_temporary_render.eps" ,1024,1024);
3463 %! # sparsersb(rrm,"renderb", "sparsersb_temporary_renderb.eps"); sparsersb(rrm,"renders", "sparsersb_temporary_renders.eps"); # FIXME
3464 %!test
3465 %! a=sparsersb(sprand(100,100,0.4));
3466 %! sparsersb(a,"autotune");
3467 %!test
3468 %! a=sparsersb(sprand(100,100,0.4));
3469 %! o=sparsersb(a,"AUTOTUNE");
3470 %! v=0;
3471 %! try
3472 %! assert(o==a)
3473 %! v=1
3474 %! end_try_catch
3475 %! assert(v==0)
3476 %! assert(length(o)>10)
3477 %!test
3478 %! a=sparsersb(sprand(100,100,0.4));
3479 %! o=sparsersb(a,"autotune");
3480 %! assert(o==a)
3481 %!test
3482 %! a=sparsersb(sprand(100,100,0.4));
3483 %! nrhs=2;
3484 %! o=sparsersb(a,"autotune","n",nrhs);
3485 %! assert(o==a)
3486 %!test
3487 %! a=1*sparsersb(sprand(100,100,0.4));
3488 %! nrhs=2;
3489 %! o=sparsersb(a,"autotune","c",nrhs);
3490 %! assert(o==a)
3491 %!test
3492 %! a=i*sparsersb(sprand(100,100,0.4));
3493 %! nrhs=2;
3494 %! o=sparsersb(a,"autotune","c",nrhs);
3495 %! assert(o==a)
3496 %!test
3497 %! a=sparsersb(sprand(100,100,0.4));
3498 %! nrhs=1;
3499 %! maxr=1;
3500 %! o=sparsersb(a,"autotune","N",nrhs,maxr);
3501 %! assert(o==a)
3502 %!test
3503 %! a=sparsersb(sprand(100,100,0.4));
3504 %! nrhs=1;
3505 %! maxr=1;
3506 %! tmax=1;
3507 %! o=sparsersb(a,"autotune","n",nrhs,maxr,tmax);
3508 %! assert(o==a)
3509 %!test
3510 %! a=sparsersb(sprand(100,100,0.4));
3511 %! nrhs=1;
3512 %! maxr=1;
3513 %! tmax=1;
3514 %! tn=1;
3515 %! o=sparsersb(a,"autotune","n",nrhs,maxr,tmax,tn);
3516 %! assert(o==a)
3517 %!test
3518 %! a=sparsersb(sprand(100,100,0.4));
3519 %! nrhs=1;
3520 %! maxr=1;
3521 %! tmax=1;
3522 %! tn=1;
3523 %! sf=1;
3524 %! o=sparsersb(a,"autotune","n",nrhs,maxr,tmax,tn,sf);
3525 %! assert(o==a)
3526 %!test
3527 %! a=sparsersb(sprand(100,100,0.4));
3528 %! nrhs=1;
3529 %! maxr=1;
3530 %! tmax=1;
3531 %! tn=2;
3532 %! sf=1;
3533 %! if getenv ("OMP_NUM_THREADS") != "1" ;
3534 %! o=sparsersb(a,"autotune","n",nrhs,maxr,tmax,tn,sf);
3535 %! assert(o==a)
3536 %! end
3537 %!test
3538 %! a=sparsersb(sprand(100,100,0.4));
3539 %! nrhs=20;
3540 %! maxr=1;
3541 %! tmax=1;
3542 %! tn=1;
3543 %! o=sparsersb(a,"autotune","t",nrhs,maxr,tmax,tn);
3544 %! assert(o==a)
3545 %!test
3546 %! a=sparsersb(sprand(100,100,0.4));
3547 %! nrhs=20;
3548 %! maxr=1;
3549 %! tmax=1;
3550 %! tn=1;
3551 %! sf=1;
3552 %! o=sparsersb(a,"autotune","n",nrhs,maxr,tmax,tn,sf);
3553 %! assert(o==a)
3554 %!test
3555 %! a=sparsersb(sprand(100,100,0.4));
3556 %! nrhs=20;
3557 %! maxr=1;
3558 %! tmax=1;
3559 %! tn=0;
3560 %! sf=1;
3561 %! o=sparsersb(a,"autotune","n",nrhs,maxr,tmax,tn,sf);
3562 %! assert(o==a)
3563 %!test
3564 %! a=sparsersb(sprand(100,100,0.4));
3565 %! nrhs=20;
3566 %! maxr=0;
3567 %! tmax=0;
3568 %! tn=0;
3569 %! sf=1;
3570 %! o=sparsersb(a,"autotune","n",nrhs,maxr,tmax,tn,sf);
3571 %! assert(o==a)
3572 %!test
3573 %! a=sparsersb(sprand(100,100,0.4));
3574 %! nrhs=1;
3575 %! maxr=0;
3576 %! tmax=0;
3577 %! tn=0;
3578 %! sf=1;
3579 %! wvt=0;
3580 %! try
3581 %! o=sparsersb(a,"autotune","?",nrhs,maxr,tmax,tn,sf);
3582 %! wvt=1;
3583 %! end_try_catch
3584 %! assert(wvt==0)
3585 %! # assert(o==a) # o undefined
3586 %!test
3587 %! assert( nnz(sparse((toeplitz(sparsersb([0,1,2,3]))-toeplitz(sparse([0,1,2,3])))))==0 );
3588 %!test
3589 %! assert( prod(sparsersb([11,12,13;21,22,23])(:) - [11,21,12,22,13,23]')==0);
3590 %!test
3591 %! A = sprand(4,4,.5);
3592 %! assert(prod(reshape(sparsersb(A),[8,2]) - reshape(sparse(A),[8,2]))==0);
3593 %!test
3594 %! assert(sparsersb([-1,1,2])() == sparsersb([-1,1,2]));
3595 %!test
3596 %! % symmetry expansion
3597 %! A=sparsersb([1+i,0,1;0,1,0;1,0,1]);
3598 %! assert(nnz(A)==4 && nnz(full(A))==5);
3599 %!test
3600 %! % 1-D indexing access is meant to be like in sparse
3601 %! A=sparsersb([1+i,0,1;0,1,0;1,0,1]);
3602 %! assert(A(1)==(1+i) && A(3)==1 && sparse(A)(3)==1)
3603 %! A=sparsersb([1+i,0,1;0,1,0;1,0,1]);
3604 %! assert(A(1)==(1+i) && A(2)==0 && sparse(A)(2)==0)
3605 %!test
3606 %! A=sparsersb([1+i,0,1;0,1,0;1,0,1]);
3607 %! assert(0==A(2:5)-sparsersb([1,1],[2,4],[1+0i,1+0i],1,4))
3608 %!test
3609 %! assert( nnz(sparse([2,1;1,2])) == 4 && nnz(sparsersb([2,1;1,2])) == 3 ) # symmetry
3610 %! assert( nnz(sparse([2,0;1,2])) == 3 && nnz(sparsersb([2,0;1,2])) == 3 ) # no symmetry
3611 %!test
3612 %! assert( (sparse([2,0;1,2]) \ [1;1]) == (sparsersb([2,0;1,2]) \ [1;1]) )
3613 %! assert( (sparse([2,0;0,2]) \ [1;1]) == (sparsersb([2,0;0,2]) \ [1;1]) )
3614 %!test
3615 %! assert( (sparse([2,0;1,2]) * [1;1]) == (sparsersb([2,0;1,2]) * [1;1]) )
3616 %! assert( (sparse([2,0;0,2]) * [1;1]) == (sparsersb([2,0;0,2]) * [1;1]) )
3617 %!test
3618 %! % no symmetry expansion and no conversion:
3619 %! assert ( ( sparsersb([1,1;1,1])*sparsersb([1,1;1,1] )) == ( sparse([1,0;1,1])*sparse([1,0;1,1]) ) )
3620 %!test
3621 %! % symmetry expansion and sparsersb->sparse conversion:
3622 %! assert ( ( sparsersb([1,1;1,1])*sparse ([1,1;1,1] )) == ( sparse([1,1;1,1])*sparse([1,1;1,1]) ) )
3623 %!test
3624 %! % symmetry expansion and sparsersb->sparse conversion:
3625 %! assert ( ( sparse ([1,1;1,1])*sparsersb([1,1;1,1] )) == ( sparse([1,1;1,1])*sparse([1,1;1,1]) ) )
3626 %!test
3627 %! % no symmetry expansion and no conversion:
3628 %! assert ( ( sparsersb([1,1;1,1])+sparsersb([1,1;1,1] )) == ( sparse([1,0;1,1])+sparse([1,0;1,1]) ) )
3629 %!test
3630 %! % symmetry expansion and sparsersb->sparse conversion:
3631 %! assert ( ( sparsersb([1,1;1,1])+sparse ([1,1;1,1] )) == ( sparse([1,1;1,1])+sparse([1,1;1,1]) ) )
3632 %!test
3633 %! % symmetry expansion and sparsersb->sparse conversion:
3634 %! assert ( ( sparse ([1,1;1,1])+sparsersb([1,1;1,1] )) == ( sparse([1,1;1,1])+sparse([1,1;1,1]) ) )
3635 %!test
3636 %! % symmetry specification: general
3637 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1,1],"general") == sparse([1,0;1,1]) )
3638 %!test
3639 %! % symmetry specification: symmetric
3640 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1,1],"symmetric") == sparse([1,1;1,1]) )
3641 %!test
3642 %! % symmetry specification: symmetric, and conversion and (:,:) access
3643 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"symmetric") == sparse([1,1+i;1+i,1]) )
3644 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"symmetric") == sparsersb([1,2,2],[1,1,2],[1,1+i,1],"symmetric")(:,:) )
3645 %!test
3646 %! % symmetry specification: hermitian, and conversion and (:,:) access
3647 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1,1],"hermitian") == sparse([1,1;1,1]) )
3648 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1,1],"hermitian") == sparsersb([1,2,2],[1,1,2],[1,1,1],"hermitian")(:,:) )
3649 %!test
3650 %! % symmetry specification: hermitian, and conversion and (:,:) access
3651 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"hermitian") == sparse([1,1-i;1+i,1]) )
3652 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"hermitian") == sparsersb([1,2,2],[1,1,2],[1,1+i,1],"hermitian")(:,:) )
3653 %!test
3654 %! % symmetry or hermitianness: no empty triangle access
3655 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"symmetric")(1,2) == 0 )
3656 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"hermitian")(1,2) == 0 )
3657 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"general")(1,2) == 0 )
3658 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"symmetric")(2,1) != 0 )
3659 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"hermitian")(2,1) != 0 )
3660 %! assert ( sparsersb([1,2,2],[1,1,2],[1,1+i,1],"general")(2,1) != 0 )
3661 %!test
3662 %! % symmetry expansion
3663 %! assert ( nnz(sparse(sparsersb([1 ,1;1,1])) - sparse([1 ,1;1,1])) == 0 )
3664 %! assert ( nnz(sparse(sparsersb([1+i,1;1,1])) - sparse([1+i,1;1,1])) == 0 )
3665 %! % hermitianness expansion
3666 %! assert ( nnz(sparsersb([1,1+i;1-i,1]) - sparse([1,1+i;1-i,1])) == 0 )
3667 %! % no symmetric complex expansion
3668 %! assert ( nnz(sparsersb([1,1+i;1+i,1]) - sparse([1,1+i;1-i,1])) == 1 )
3669 %!test
3670 %! assert( (sparse([2, 0; 1, 2])(:,:)) == (sparsersb([2, 0; 1, 2])(:,:)) )
3671 %! assert( (sparse([2, 0; i, 2])(:,:)) == (sparsersb([2, 0; i, 2])(:,:)) )
3672 %!test
3673 %! assert( (sparse([2, 0; 1, 2])(2,:)) == (sparsersb([2, 0; 1, 2])(2,:)) )
3674 %! assert( (sparse([2, 0; i, 2])(2,:)) == (sparsersb([2, 0; i, 2])(2,:)) )
3675 %!test
3676 %! assert( (sparse([2, 0; 1, 2])(:,2)) == (sparsersb([2, 0; 1, 2])(:,2)) )
3677 %! assert( (sparse([2, 0; i, 2])(:,2)) == (sparsersb([2, 0; i, 2])(:,2)) )
3678 %!test
3679 %! assert( (sparse([2,0;1,2]) * [1;1]) == (sparsersb([2,0;1,2]) * [1;1]) )
3680 %! assert( (sparse([2,0;0,2]) * [1;1]) == (sparsersb([2,0;0,2]) * [1;1]) )
3681 %!test
3682 %! assert( (sparse([2,0;1,2]) * [i;1]) == (sparsersb([2,0;1,2]) * [i;1]) )
3683 %! assert( (sparse([2,0;0,2]) * [i;1]) == (sparsersb([2,0;0,2]) * [i;1]) )
3684 %!test
3685 %! assert( (sparse([2,0;1,2])'* [1;1]) == (sparsersb([2,0;1,2])'* [1;1]) )
3686 %! assert( (sparse([2,0;0,2])'* [1;1]) == (sparsersb([2,0;0,2])'* [1;1]) )
3687 %!test
3688 %! assert( (sparse([2,0;1,2])'* [i;1]) == (sparsersb([2,0;1,2])'* [i;1]) )
3689 %! assert( (sparse([2,0;0,2])'* [i;1]) == (sparsersb([2,0;0,2])'* [i;1]) )
3690 %!test
3691 %! assert( (sparse([2,0;1,2]).'* [1;1]) == (sparsersb([2,0;1,2]).'* [1;1]) )
3692 %! assert( (sparse([2,0;0,2]).'* [1;1]) == (sparsersb([2,0;0,2]).'* [1;1]) )
3693 %!test
3694 %! assert( (sparse([2,0;1,2]).'* [i;1]) == (sparsersb([2,0;1,2]).'* [i;1]) )
3695 %! assert( (sparse([2,0;0,2]).'* [i;1]) == (sparsersb([2,0;0,2]).'* [i;1]) )
3696 %!test
3697 %! assert( (sparse([2,0;1,2]) * 1 ) == (sparsersb([2,0;1,2]) * 1 ) )
3698 %! assert( (sparse([2,0;0,2]) * 1 ) == (sparsersb([2,0;0,2]) * 1 ) )
3699 %!test
3700 %! assert( (sparse([2,0;1,2]) * i ) == (sparsersb([2,0;1,2]) * i ) )
3701 %! assert( (sparse([2,0;0,2]) * i ) == (sparsersb([2,0;0,2]) * i ) )
3702 %!test
3703 %! assert( (sparse([2,0;1,2]).* 1 ) == (sparsersb([2,0;1,2]).* 1 ) )
3704 %! assert( (sparse([2,0;0,2]).* 1 ) == (sparsersb([2,0;0,2]).* 1 ) )
3705 %!test
3706 %! assert( (sparse([2,0;1,2]).* i ) == (sparsersb([2,0;1,2]).* i ) )
3707 %! assert( (sparse([2,0;0,2]).* i ) == (sparsersb([2,0;0,2]).* i ) )
3708 %!test
3709 %! assert( ( sparse([2,0;1,2]) + 1*sparse([2,0;1,2]) ) == (sparsersb([2,0;1,2]) + 1*sparsersb([2,0;1,2]) ) )
3710 %!test
3711 %! assert( ( sparse([2,0;0,2]) + 1*sparse([2,0;0,2]) ) == (sparsersb([2,0;0,2]) + 1*sparsersb([2,0;0,2]) ) )
3712 %!test
3713 %! assert( ( sparse([2,0;1,2]) + i*sparse([2,0;1,2]) ) == (sparsersb([2,0;1,2]) + i*sparsersb([2,0;1,2]) ) )
3714 %!test
3715 %! assert( ( sparse([2,0;0,2]) + i*sparse([2,0;0,2]) ) == (sparsersb([2,0;0,2]) + i*sparsersb([2,0;0,2]) ) )
3716 %!test
3717 %! assert( (sparse([ 1 + 1i,0;0, 1 + 1i]).'* [1,2;1,2]) == (sparsersb([ 1 + 1i,0;0, 1 + 1i]).'* [1,2;1,2]) )
3718 */
3719
3720
3721 /* GENERATED TEST LINES BEGIN */ /*
3722
3723 %% tests for a 1 x 1 matrix, density 10%, real
3724 %!test
3725 %! A = [0,;]; assert ( (sparsersb (A)) == (sparse (A)));
3726 %!test
3727 %! A = [0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
3728 %!test
3729 %! A = [0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
3730 %!test
3731 %! A = [0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
3732 %!test
3733 %! A = [0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
3734 %!test
3735 %! A = [0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
3736 %!test
3737 %! A = [0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
3738 %!test
3739 %! A = [0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
3740 %!test
3741 %! A = [0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
3742 %!test
3743 %! A = [0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
3744 %!test
3745 %! A = [0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
3746 %!test
3747 %! A = [0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
3748 %!test
3749 %! A = [0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
3750 %!test
3751 %! A = [0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
3752 %!test
3753 %! A = [0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
3754 %!test
3755 %! A = [0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
3756 %!test
3757 %! A = [0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
3758 %!test
3759 %! A = [0,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
3760 %!test
3761 %! A = [0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
3762 %!test
3763 %! A = [0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
3764 %!test
3765 %! A = [0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
3766 %!test
3767 %! A = [0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
3768 %!test
3769 %! A = [0,;]; assert (sparsersb (A)*i == sparse (A)*i);
3770 %!test
3771 %! A = [0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
3772 %!test
3773 %! A = [0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
3774 %!test
3775 %! A = [0,;]; assert (reshape (sparsersb (A), 1, 1) == reshape (sparse (A), 1, 1));
3776
3777 %% tests for a 1 x 1 matrix, density 10%, complex
3778 %!test
3779 %! A = [0,;]; assert ( (sparsersb (A)) == (sparse (A)));
3780 %!test
3781 %! A = [0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
3782 %!test
3783 %! A = [0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
3784 %!test
3785 %! A = [0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
3786 %!test
3787 %! A = [0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
3788 %!test
3789 %! A = [0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
3790 %!test
3791 %! A = [0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
3792 %!test
3793 %! A = [0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
3794 %!test
3795 %! A = [0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
3796 %!test
3797 %! A = [0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
3798 %!test
3799 %! A = [0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
3800 %!test
3801 %! A = [0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
3802 %!test
3803 %! A = [0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
3804 %!test
3805 %! A = [0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
3806 %!test
3807 %! A = [0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
3808 %!test
3809 %! A = [0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
3810 %!test
3811 %! A = [0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
3812 %!test
3813 %! A = [0,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
3814 %!test
3815 %! A = [0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
3816 %!test
3817 %! A = [0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
3818 %!test
3819 %! A = [0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
3820 %!test
3821 %! A = [0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
3822 %!test
3823 %! A = [0,;]; assert (sparsersb (A)*i == sparse (A)*i);
3824 %!test
3825 %! A = [0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
3826 %!test
3827 %! A = [0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
3828 %!test
3829 %! A = [0,;]; assert (reshape (sparsersb (A), 1, 1) == reshape (sparse (A), 1, 1));
3830
3831 %% tests for a 1 x 3 matrix, density 10%, real
3832 %!test
3833 %! A = [0,0,0,;]; assert ( (sparsersb (A)) == (sparse (A)));
3834 %!test
3835 %! A = [0,0,0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
3836 %!test
3837 %! A = [0,0,0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
3838 %!test
3839 %! A = [0,0,0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
3840 %!test
3841 %! A = [0,0,0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
3842 %!test
3843 %! A = [0,0,0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
3844 %!test
3845 %! A = [0,0,0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
3846 %!test
3847 %! A = [0,0,0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
3848 %!test
3849 %! A = [0,0,0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
3850 %!test
3851 %! A = [0,0,0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
3852 %!test
3853 %! A = [0,0,0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
3854 %!test
3855 %! A = [0,0,0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
3856 %!test
3857 %! A = [0,0,0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
3858 %!test
3859 %! A = [0,0,0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
3860 %!test
3861 %! A = [0,0,0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
3862 %!test
3863 %! A = [0,0,0,;]; assert (sparsersb (A)(1,3) == sparse (A)(1,3));
3864 %!test
3865 %! A = [0,0,0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
3866 %!test
3867 %! A = [0,0,0,;]; assert (sparsersb (A)(3) == sparse (A)(3));
3868 %!test
3869 %! A = [0,0,0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
3870 %!test
3871 %! A = [0,0,0,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
3872 %!test
3873 %! A = [0,0,0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
3874 %!test
3875 %! A = [0,0,0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
3876 %!test
3877 %! A = [0,0,0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
3878 %!test
3879 %! A = [0,0,0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
3880 %!test
3881 %! A = [0,0,0,;]; assert (sparsersb (A)*i == sparse (A)*i);
3882 %!test
3883 %! A = [0,0,0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
3884 %!test
3885 %! A = [0,0,0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
3886 %!test
3887 %! A = [0,0,0,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
3888 %!test
3889 %! A = [0,0,0,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
3890
3891 %% tests for a 1 x 3 matrix, density 10%, complex
3892 %!test
3893 %! A = [0,0,0,;]; assert ( (sparsersb (A)) == (sparse (A)));
3894 %!test
3895 %! A = [0,0,0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
3896 %!test
3897 %! A = [0,0,0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
3898 %!test
3899 %! A = [0,0,0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
3900 %!test
3901 %! A = [0,0,0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
3902 %!test
3903 %! A = [0,0,0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
3904 %!test
3905 %! A = [0,0,0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
3906 %!test
3907 %! A = [0,0,0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
3908 %!test
3909 %! A = [0,0,0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
3910 %!test
3911 %! A = [0,0,0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
3912 %!test
3913 %! A = [0,0,0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
3914 %!test
3915 %! A = [0,0,0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
3916 %!test
3917 %! A = [0,0,0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
3918 %!test
3919 %! A = [0,0,0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
3920 %!test
3921 %! A = [0,0,0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
3922 %!test
3923 %! A = [0,0,0,;]; assert (sparsersb (A)(1,3) == sparse (A)(1,3));
3924 %!test
3925 %! A = [0,0,0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
3926 %!test
3927 %! A = [0,0,0,;]; assert (sparsersb (A)(3) == sparse (A)(3));
3928 %!test
3929 %! A = [0,0,0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
3930 %!test
3931 %! A = [0,0,0,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
3932 %!test
3933 %! A = [0,0,0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
3934 %!test
3935 %! A = [0,0,0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
3936 %!test
3937 %! A = [0,0,0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
3938 %!test
3939 %! A = [0,0,0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
3940 %!test
3941 %! A = [0,0,0,;]; assert (sparsersb (A)*i == sparse (A)*i);
3942 %!test
3943 %! A = [0,0,0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
3944 %!test
3945 %! A = [0,0,0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
3946 %!test
3947 %! A = [0,0,0,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
3948 %!test
3949 %! A = [0,0,0,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
3950
3951 %% tests for a 3 x 1 matrix, density 10%, real
3952 %!test
3953 %! A = [0,;0,;0,;]; assert ( (sparsersb (A)) == (sparse (A)));
3954 %!test
3955 %! A = [0,;0,;0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
3956 %!test
3957 %! A = [0,;0,;0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
3958 %!test
3959 %! A = [0,;0,;0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
3960 %!test
3961 %! A = [0,;0,;0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
3962 %!test
3963 %! A = [0,;0,;0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
3964 %!test
3965 %! A = [0,;0,;0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
3966 %!test
3967 %! A = [0,;0,;0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
3968 %!test
3969 %! A = [0,;0,;0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
3970 %!test
3971 %! A = [0,;0,;0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
3972 %!test
3973 %! A = [0,;0,;0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
3974 %!test
3975 %! A = [0,;0,;0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
3976 %!test
3977 %! A = [0,;0,;0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
3978 %!test
3979 %! A = [0,;0,;0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
3980 %!test
3981 %! A = [0,;0,;0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
3982 %!test
3983 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3) == sparse (A)(3));
3984 %!test
3985 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3,1) == sparse (A)(3,1));
3986 %!test
3987 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
3988 %!test
3989 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
3990 %!test
3991 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
3992 %!test
3993 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
3994 %!test
3995 %! A = [0,;0,;0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
3996 %!test
3997 %! A = [0,;0,;0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
3998 %!test
3999 %! A = [0,;0,;0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4000 %!test
4001 %! A = [0,;0,;0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4002 %!test
4003 %! A = [0,;0,;0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4004 %!test
4005 %! A = [0,;0,;0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4006 %!test
4007 %! A = [0,;0,;0,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4008 %!test
4009 %! A = [0,;0,;0,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4010
4011 %% tests for a 3 x 1 matrix, density 10%, complex
4012 %!test
4013 %! A = [0,;0,;0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4014 %!test
4015 %! A = [0,;0,;0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4016 %!test
4017 %! A = [0,;0,;0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4018 %!test
4019 %! A = [0,;0,;0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4020 %!test
4021 %! A = [0,;0,;0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4022 %!test
4023 %! A = [0,;0,;0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4024 %!test
4025 %! A = [0,;0,;0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4026 %!test
4027 %! A = [0,;0,;0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4028 %!test
4029 %! A = [0,;0,;0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4030 %!test
4031 %! A = [0,;0,;0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4032 %!test
4033 %! A = [0,;0,;0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4034 %!test
4035 %! A = [0,;0,;0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4036 %!test
4037 %! A = [0,;0,;0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4038 %!test
4039 %! A = [0,;0,;0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4040 %!test
4041 %! A = [0,;0,;0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4042 %!test
4043 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4044 %!test
4045 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3,1) == sparse (A)(3,1));
4046 %!test
4047 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4048 %!test
4049 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4050 %!test
4051 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4052 %!test
4053 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4054 %!test
4055 %! A = [0,;0,;0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4056 %!test
4057 %! A = [0,;0,;0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4058 %!test
4059 %! A = [0,;0,;0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4060 %!test
4061 %! A = [0,;0,;0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4062 %!test
4063 %! A = [0,;0,;0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4064 %!test
4065 %! A = [0,;0,;0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4066 %!test
4067 %! A = [0,;0,;0,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4068 %!test
4069 %! A = [0,;0,;0,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4070
4071 %% tests for a 3 x 3 matrix, density 10%, real
4072 %!test
4073 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4074 %!test
4075 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4076 %!test
4077 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4078 %!test
4079 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4080 %!test
4081 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4082 %!test
4083 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4084 %!test
4085 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4086 %!test
4087 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4088 %!test
4089 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4090 %!test
4091 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4092 %!test
4093 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4094 %!test
4095 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4096 %!test
4097 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4098 %!test
4099 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4100 %!test
4101 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4102 %!test
4103 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)(3,3) == sparse (A)(3,3));
4104 %!test
4105 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4106 %!test
4107 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)(9) == sparse (A)(9));
4108 %!test
4109 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4110 %!test
4111 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
4112 %!test
4113 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4114 %!test
4115 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4116 %!test
4117 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4118 %!test
4119 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4120 %!test
4121 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4122 %!test
4123 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4124 %!test
4125 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4126 %!test
4127 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (reshape (sparsersb (A), 1, 9) == reshape (sparse (A), 1, 9));
4128 %!test
4129 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (reshape (sparsersb (A), 3, 3) == reshape (sparse (A), 3, 3));
4130 %!test
4131 %! A = [0,0,0,;0,0,0,;0,3,0,;]; assert (reshape (sparsersb (A), 9, 1) == reshape (sparse (A), 9, 1));
4132
4133 %% tests for a 3 x 3 matrix, density 10%, complex
4134 %!test
4135 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4136 %!test
4137 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4138 %!test
4139 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4140 %!test
4141 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4142 %!test
4143 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4144 %!test
4145 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4146 %!test
4147 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4148 %!test
4149 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4150 %!test
4151 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4152 %!test
4153 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4154 %!test
4155 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4156 %!test
4157 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4158 %!test
4159 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4160 %!test
4161 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4162 %!test
4163 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4164 %!test
4165 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)(3,3) == sparse (A)(3,3));
4166 %!test
4167 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4168 %!test
4169 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)(9) == sparse (A)(9));
4170 %!test
4171 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4172 %!test
4173 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
4174 %!test
4175 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4176 %!test
4177 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4178 %!test
4179 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4180 %!test
4181 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4182 %!test
4183 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4184 %!test
4185 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4186 %!test
4187 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4188 %!test
4189 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (reshape (sparsersb (A), 1, 9) == reshape (sparse (A), 1, 9));
4190 %!test
4191 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (reshape (sparsersb (A), 3, 3) == reshape (sparse (A), 3, 3));
4192 %!test
4193 %! A = [0,0,0,;0,0,0,;0,0,0,;]; assert (reshape (sparsersb (A), 9, 1) == reshape (sparse (A), 9, 1));
4194
4195 %% tests for a 1 x 1 matrix, density 20%, real
4196 %!test
4197 %! A = [0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4198 %!test
4199 %! A = [0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4200 %!test
4201 %! A = [0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4202 %!test
4203 %! A = [0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4204 %!test
4205 %! A = [0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4206 %!test
4207 %! A = [0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4208 %!test
4209 %! A = [0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4210 %!test
4211 %! A = [0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4212 %!test
4213 %! A = [0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4214 %!test
4215 %! A = [0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4216 %!test
4217 %! A = [0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4218 %!test
4219 %! A = [0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4220 %!test
4221 %! A = [0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4222 %!test
4223 %! A = [0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4224 %!test
4225 %! A = [0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4226 %!test
4227 %! A = [0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
4228 %!test
4229 %! A = [0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4230 %!test
4231 %! A = [0,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4232 %!test
4233 %! A = [0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4234 %!test
4235 %! A = [0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4236 %!test
4237 %! A = [0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4238 %!test
4239 %! A = [0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4240 %!test
4241 %! A = [0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4242 %!test
4243 %! A = [0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4244 %!test
4245 %! A = [0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4246 %!test
4247 %! A = [0,;]; assert (reshape (sparsersb (A), 1, 1) == reshape (sparse (A), 1, 1));
4248
4249 %% tests for a 1 x 1 matrix, density 20%, complex
4250 %!test
4251 %! A = [0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4252 %!test
4253 %! A = [0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4254 %!test
4255 %! A = [0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4256 %!test
4257 %! A = [0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4258 %!test
4259 %! A = [0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4260 %!test
4261 %! A = [0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4262 %!test
4263 %! A = [0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4264 %!test
4265 %! A = [0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4266 %!test
4267 %! A = [0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4268 %!test
4269 %! A = [0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4270 %!test
4271 %! A = [0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4272 %!test
4273 %! A = [0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4274 %!test
4275 %! A = [0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4276 %!test
4277 %! A = [0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4278 %!test
4279 %! A = [0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4280 %!test
4281 %! A = [0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
4282 %!test
4283 %! A = [0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4284 %!test
4285 %! A = [0,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4286 %!test
4287 %! A = [0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4288 %!test
4289 %! A = [0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4290 %!test
4291 %! A = [0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4292 %!test
4293 %! A = [0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4294 %!test
4295 %! A = [0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4296 %!test
4297 %! A = [0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4298 %!test
4299 %! A = [0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4300 %!test
4301 %! A = [0,;]; assert (reshape (sparsersb (A), 1, 1) == reshape (sparse (A), 1, 1));
4302
4303 %% tests for a 1 x 3 matrix, density 20%, real
4304 %!test
4305 %! A = [22,0,0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4306 %!test
4307 %! A = [22,0,0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4308 %!test
4309 %! A = [22,0,0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4310 %!test
4311 %! A = [22,0,0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4312 %!test
4313 %! A = [22,0,0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4314 %!test
4315 %! A = [22,0,0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4316 %!test
4317 %! A = [22,0,0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4318 %!test
4319 %! A = [22,0,0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4320 %!test
4321 %! A = [22,0,0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4322 %!test
4323 %! A = [22,0,0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4324 %!test
4325 %! A = [22,0,0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4326 %!test
4327 %! A = [22,0,0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4328 %!test
4329 %! A = [22,0,0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4330 %!test
4331 %! A = [22,0,0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4332 %!test
4333 %! A = [22,0,0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4334 %!test
4335 %! A = [22,0,0,;]; assert (sparsersb (A)(1,3) == sparse (A)(1,3));
4336 %!test
4337 %! A = [22,0,0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
4338 %!test
4339 %! A = [22,0,0,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4340 %!test
4341 %! A = [22,0,0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4342 %!test
4343 %! A = [22,0,0,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
4344 %!test
4345 %! A = [22,0,0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4346 %!test
4347 %! A = [22,0,0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4348 %!test
4349 %! A = [22,0,0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4350 %!test
4351 %! A = [22,0,0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4352 %!test
4353 %! A = [22,0,0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4354 %!test
4355 %! A = [22,0,0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4356 %!test
4357 %! A = [22,0,0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4358 %!test
4359 %! A = [22,0,0,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4360 %!test
4361 %! A = [22,0,0,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4362
4363 %% tests for a 1 x 3 matrix, density 20%, complex
4364 %!test
4365 %! A = [0,0,0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4366 %!test
4367 %! A = [0,0,0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4368 %!test
4369 %! A = [0,0,0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4370 %!test
4371 %! A = [0,0,0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4372 %!test
4373 %! A = [0,0,0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4374 %!test
4375 %! A = [0,0,0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4376 %!test
4377 %! A = [0,0,0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4378 %!test
4379 %! A = [0,0,0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4380 %!test
4381 %! A = [0,0,0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4382 %!test
4383 %! A = [0,0,0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4384 %!test
4385 %! A = [0,0,0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4386 %!test
4387 %! A = [0,0,0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4388 %!test
4389 %! A = [0,0,0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4390 %!test
4391 %! A = [0,0,0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4392 %!test
4393 %! A = [0,0,0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4394 %!test
4395 %! A = [0,0,0,;]; assert (sparsersb (A)(1,3) == sparse (A)(1,3));
4396 %!test
4397 %! A = [0,0,0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
4398 %!test
4399 %! A = [0,0,0,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4400 %!test
4401 %! A = [0,0,0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4402 %!test
4403 %! A = [0,0,0,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
4404 %!test
4405 %! A = [0,0,0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4406 %!test
4407 %! A = [0,0,0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4408 %!test
4409 %! A = [0,0,0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4410 %!test
4411 %! A = [0,0,0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4412 %!test
4413 %! A = [0,0,0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4414 %!test
4415 %! A = [0,0,0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4416 %!test
4417 %! A = [0,0,0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4418 %!test
4419 %! A = [0,0,0,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4420 %!test
4421 %! A = [0,0,0,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4422
4423 %% tests for a 3 x 1 matrix, density 20%, real
4424 %!test
4425 %! A = [0,;0,;68,;]; assert ( (sparsersb (A)) == (sparse (A)));
4426 %!test
4427 %! A = [0,;0,;68,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4428 %!test
4429 %! A = [0,;0,;68,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4430 %!test
4431 %! A = [0,;0,;68,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4432 %!test
4433 %! A = [0,;0,;68,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4434 %!test
4435 %! A = [0,;0,;68,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4436 %!test
4437 %! A = [0,;0,;68,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4438 %!test
4439 %! A = [0,;0,;68,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4440 %!test
4441 %! A = [0,;0,;68,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4442 %!test
4443 %! A = [0,;0,;68,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4444 %!test
4445 %! A = [0,;0,;68,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4446 %!test
4447 %! A = [0,;0,;68,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4448 %!test
4449 %! A = [0,;0,;68,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4450 %!test
4451 %! A = [0,;0,;68,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4452 %!test
4453 %! A = [0,;0,;68,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4454 %!test
4455 %! A = [0,;0,;68,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4456 %!test
4457 %! A = [0,;0,;68,;]; assert (sparsersb (A)(3,1) == sparse (A)(3,1));
4458 %!test
4459 %! A = [0,;0,;68,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4460 %!test
4461 %! A = [0,;0,;68,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4462 %!test
4463 %! A = [0,;0,;68,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4464 %!test
4465 %! A = [0,;0,;68,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4466 %!test
4467 %! A = [0,;0,;68,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4468 %!test
4469 %! A = [0,;0,;68,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4470 %!test
4471 %! A = [0,;0,;68,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4472 %!test
4473 %! A = [0,;0,;68,;]; assert (sparsersb (A)*i == sparse (A)*i);
4474 %!test
4475 %! A = [0,;0,;68,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4476 %!test
4477 %! A = [0,;0,;68,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4478 %!test
4479 %! A = [0,;0,;68,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4480 %!test
4481 %! A = [0,;0,;68,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4482
4483 %% tests for a 3 x 1 matrix, density 20%, complex
4484 %!test
4485 %! A = [0,;0,;0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4486 %!test
4487 %! A = [0,;0,;0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4488 %!test
4489 %! A = [0,;0,;0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4490 %!test
4491 %! A = [0,;0,;0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4492 %!test
4493 %! A = [0,;0,;0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4494 %!test
4495 %! A = [0,;0,;0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4496 %!test
4497 %! A = [0,;0,;0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4498 %!test
4499 %! A = [0,;0,;0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4500 %!test
4501 %! A = [0,;0,;0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4502 %!test
4503 %! A = [0,;0,;0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4504 %!test
4505 %! A = [0,;0,;0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4506 %!test
4507 %! A = [0,;0,;0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4508 %!test
4509 %! A = [0,;0,;0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4510 %!test
4511 %! A = [0,;0,;0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4512 %!test
4513 %! A = [0,;0,;0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4514 %!test
4515 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4516 %!test
4517 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3,1) == sparse (A)(3,1));
4518 %!test
4519 %! A = [0,;0,;0,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4520 %!test
4521 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4522 %!test
4523 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4524 %!test
4525 %! A = [0,;0,;0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4526 %!test
4527 %! A = [0,;0,;0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4528 %!test
4529 %! A = [0,;0,;0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4530 %!test
4531 %! A = [0,;0,;0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4532 %!test
4533 %! A = [0,;0,;0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4534 %!test
4535 %! A = [0,;0,;0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4536 %!test
4537 %! A = [0,;0,;0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4538 %!test
4539 %! A = [0,;0,;0,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4540 %!test
4541 %! A = [0,;0,;0,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4542
4543 %% tests for a 3 x 3 matrix, density 20%, real
4544 %!test
4545 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert ( (sparsersb (A)) == (sparse (A)));
4546 %!test
4547 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4548 %!test
4549 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4550 %!test
4551 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4552 %!test
4553 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4554 %!test
4555 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4556 %!test
4557 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4558 %!test
4559 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4560 %!test
4561 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4562 %!test
4563 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4564 %!test
4565 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4566 %!test
4567 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4568 %!test
4569 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4570 %!test
4571 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4572 %!test
4573 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4574 %!test
4575 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)(3,3) == sparse (A)(3,3));
4576 %!test
4577 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4578 %!test
4579 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)(9) == sparse (A)(9));
4580 %!test
4581 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4582 %!test
4583 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
4584 %!test
4585 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4586 %!test
4587 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4588 %!test
4589 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4590 %!test
4591 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4592 %!test
4593 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A)*i == sparse (A)*i);
4594 %!test
4595 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4596 %!test
4597 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4598 %!test
4599 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (reshape (sparsersb (A), 1, 9) == reshape (sparse (A), 1, 9));
4600 %!test
4601 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (reshape (sparsersb (A), 3, 3) == reshape (sparse (A), 3, 3));
4602 %!test
4603 %! A = [0,0,0,;3,0,0,;0,0,42,;]; assert (reshape (sparsersb (A), 9, 1) == reshape (sparse (A), 9, 1));
4604
4605 %% tests for a 3 x 3 matrix, density 20%, complex
4606 %!test
4607 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4608 %!test
4609 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4610 %!test
4611 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4612 %!test
4613 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4614 %!test
4615 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4616 %!test
4617 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4618 %!test
4619 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4620 %!test
4621 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4622 %!test
4623 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4624 %!test
4625 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4626 %!test
4627 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4628 %!test
4629 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4630 %!test
4631 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4632 %!test
4633 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4634 %!test
4635 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4636 %!test
4637 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)(3,3) == sparse (A)(3,3));
4638 %!test
4639 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4640 %!test
4641 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)(9) == sparse (A)(9));
4642 %!test
4643 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4644 %!test
4645 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
4646 %!test
4647 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4648 %!test
4649 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4650 %!test
4651 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4652 %!test
4653 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4654 %!test
4655 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4656 %!test
4657 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4658 %!test
4659 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4660 %!test
4661 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (reshape (sparsersb (A), 1, 9) == reshape (sparse (A), 1, 9));
4662 %!test
4663 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (reshape (sparsersb (A), 3, 3) == reshape (sparse (A), 3, 3));
4664 %!test
4665 %! A = [0+20*i,0,0,;51,0,0,;0,0,0,;]; assert (reshape (sparsersb (A), 9, 1) == reshape (sparse (A), 9, 1));
4666
4667 %% tests for a 1 x 1 matrix, density 50%, real
4668 %!test
4669 %! A = [54,;]; assert ( (sparsersb (A)) == (sparse (A)));
4670 %!test
4671 %! A = [54,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4672 %!test
4673 %! A = [54,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4674 %!test
4675 %! A = [54,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4676 %!test
4677 %! A = [54,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4678 %!test
4679 %! A = [54,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4680 %!test
4681 %! A = [54,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4682 %!test
4683 %! A = [54,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4684 %!test
4685 %! A = [54,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4686 %!test
4687 %! A = [54,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4688 %!test
4689 %! A = [54,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4690 %!test
4691 %! A = [54,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4692 %!test
4693 %! A = [54,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4694 %!test
4695 %! A = [54,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4696 %!test
4697 %! A = [54,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4698 %!test
4699 %! A = [54,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
4700 %!test
4701 %! A = [54,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4702 %!test
4703 %! A = [54,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4704 %!test
4705 %! A = [54,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4706 %!test
4707 %! A = [54,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4708 %!test
4709 %! A = [54,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4710 %!test
4711 %! A = [54,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4712 %!test
4713 %! A = [54,;]; assert (sparsersb (A)*i == sparse (A)*i);
4714 %!test
4715 %! A = [54,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4716 %!test
4717 %! A = [54,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4718 %!test
4719 %! A = [54,;]; assert (reshape (sparsersb (A), 1, 1) == reshape (sparse (A), 1, 1));
4720
4721 %% tests for a 1 x 1 matrix, density 50%, complex
4722 %!test
4723 %! A = [0,;]; assert ( (sparsersb (A)) == (sparse (A)));
4724 %!test
4725 %! A = [0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4726 %!test
4727 %! A = [0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4728 %!test
4729 %! A = [0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4730 %!test
4731 %! A = [0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4732 %!test
4733 %! A = [0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4734 %!test
4735 %! A = [0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4736 %!test
4737 %! A = [0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4738 %!test
4739 %! A = [0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4740 %!test
4741 %! A = [0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4742 %!test
4743 %! A = [0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4744 %!test
4745 %! A = [0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4746 %!test
4747 %! A = [0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4748 %!test
4749 %! A = [0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4750 %!test
4751 %! A = [0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4752 %!test
4753 %! A = [0,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
4754 %!test
4755 %! A = [0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4756 %!test
4757 %! A = [0,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4758 %!test
4759 %! A = [0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4760 %!test
4761 %! A = [0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4762 %!test
4763 %! A = [0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4764 %!test
4765 %! A = [0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4766 %!test
4767 %! A = [0,;]; assert (sparsersb (A)*i == sparse (A)*i);
4768 %!test
4769 %! A = [0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4770 %!test
4771 %! A = [0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4772 %!test
4773 %! A = [0,;]; assert (reshape (sparsersb (A), 1, 1) == reshape (sparse (A), 1, 1));
4774
4775 %% tests for a 1 x 3 matrix, density 50%, real
4776 %!test
4777 %! A = [81,0,1,;]; assert ( (sparsersb (A)) == (sparse (A)));
4778 %!test
4779 %! A = [81,0,1,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4780 %!test
4781 %! A = [81,0,1,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4782 %!test
4783 %! A = [81,0,1,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4784 %!test
4785 %! A = [81,0,1,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4786 %!test
4787 %! A = [81,0,1,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4788 %!test
4789 %! A = [81,0,1,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4790 %!test
4791 %! A = [81,0,1,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4792 %!test
4793 %! A = [81,0,1,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4794 %!test
4795 %! A = [81,0,1,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4796 %!test
4797 %! A = [81,0,1,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4798 %!test
4799 %! A = [81,0,1,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4800 %!test
4801 %! A = [81,0,1,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4802 %!test
4803 %! A = [81,0,1,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4804 %!test
4805 %! A = [81,0,1,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4806 %!test
4807 %! A = [81,0,1,;]; assert (sparsersb (A)(1,3) == sparse (A)(1,3));
4808 %!test
4809 %! A = [81,0,1,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
4810 %!test
4811 %! A = [81,0,1,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4812 %!test
4813 %! A = [81,0,1,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4814 %!test
4815 %! A = [81,0,1,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
4816 %!test
4817 %! A = [81,0,1,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4818 %!test
4819 %! A = [81,0,1,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4820 %!test
4821 %! A = [81,0,1,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4822 %!test
4823 %! A = [81,0,1,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4824 %!test
4825 %! A = [81,0,1,;]; assert (sparsersb (A)*i == sparse (A)*i);
4826 %!test
4827 %! A = [81,0,1,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4828 %!test
4829 %! A = [81,0,1,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4830 %!test
4831 %! A = [81,0,1,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4832 %!test
4833 %! A = [81,0,1,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4834
4835 %% tests for a 1 x 3 matrix, density 50%, complex
4836 %!test
4837 %! A = [0,0+16*i,70,;]; assert ( (sparsersb (A)) == (sparse (A)));
4838 %!test
4839 %! A = [0,0+16*i,70,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4840 %!test
4841 %! A = [0,0+16*i,70,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4842 %!test
4843 %! A = [0,0+16*i,70,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4844 %!test
4845 %! A = [0,0+16*i,70,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4846 %!test
4847 %! A = [0,0+16*i,70,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4848 %!test
4849 %! A = [0,0+16*i,70,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4850 %!test
4851 %! A = [0,0+16*i,70,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4852 %!test
4853 %! A = [0,0+16*i,70,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4854 %!test
4855 %! A = [0,0+16*i,70,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4856 %!test
4857 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4858 %!test
4859 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4860 %!test
4861 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4862 %!test
4863 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4864 %!test
4865 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4866 %!test
4867 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)(1,3) == sparse (A)(1,3));
4868 %!test
4869 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
4870 %!test
4871 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4872 %!test
4873 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4874 %!test
4875 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
4876 %!test
4877 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4878 %!test
4879 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4880 %!test
4881 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4882 %!test
4883 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4884 %!test
4885 %! A = [0,0+16*i,70,;]; assert (sparsersb (A)*i == sparse (A)*i);
4886 %!test
4887 %! A = [0,0+16*i,70,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4888 %!test
4889 %! A = [0,0+16*i,70,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4890 %!test
4891 %! A = [0,0+16*i,70,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4892 %!test
4893 %! A = [0,0+16*i,70,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4894
4895 %% tests for a 3 x 1 matrix, density 50%, real
4896 %!test
4897 %! A = [0,;10,;9,;]; assert ( (sparsersb (A)) == (sparse (A)));
4898 %!test
4899 %! A = [0,;10,;9,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4900 %!test
4901 %! A = [0,;10,;9,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4902 %!test
4903 %! A = [0,;10,;9,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4904 %!test
4905 %! A = [0,;10,;9,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4906 %!test
4907 %! A = [0,;10,;9,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4908 %!test
4909 %! A = [0,;10,;9,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4910 %!test
4911 %! A = [0,;10,;9,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4912 %!test
4913 %! A = [0,;10,;9,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4914 %!test
4915 %! A = [0,;10,;9,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4916 %!test
4917 %! A = [0,;10,;9,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4918 %!test
4919 %! A = [0,;10,;9,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4920 %!test
4921 %! A = [0,;10,;9,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4922 %!test
4923 %! A = [0,;10,;9,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4924 %!test
4925 %! A = [0,;10,;9,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4926 %!test
4927 %! A = [0,;10,;9,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4928 %!test
4929 %! A = [0,;10,;9,;]; assert (sparsersb (A)(3,1) == sparse (A)(3,1));
4930 %!test
4931 %! A = [0,;10,;9,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4932 %!test
4933 %! A = [0,;10,;9,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4934 %!test
4935 %! A = [0,;10,;9,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4936 %!test
4937 %! A = [0,;10,;9,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4938 %!test
4939 %! A = [0,;10,;9,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
4940 %!test
4941 %! A = [0,;10,;9,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
4942 %!test
4943 %! A = [0,;10,;9,;]; assert (sparsersb (A)*1 == sparse (A)*1);
4944 %!test
4945 %! A = [0,;10,;9,;]; assert (sparsersb (A)*i == sparse (A)*i);
4946 %!test
4947 %! A = [0,;10,;9,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
4948 %!test
4949 %! A = [0,;10,;9,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
4950 %!test
4951 %! A = [0,;10,;9,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
4952 %!test
4953 %! A = [0,;10,;9,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
4954
4955 %% tests for a 3 x 1 matrix, density 50%, complex
4956 %!test
4957 %! A = [0,;0,;60+73*i,;]; assert ( (sparsersb (A)) == (sparse (A)));
4958 %!test
4959 %! A = [0,;0,;60+73*i,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
4960 %!test
4961 %! A = [0,;0,;60+73*i,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
4962 %!test
4963 %! A = [0,;0,;60+73*i,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
4964 %!test
4965 %! A = [0,;0,;60+73*i,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
4966 %!test
4967 %! A = [0,;0,;60+73*i,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
4968 %!test
4969 %! A = [0,;0,;60+73*i,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
4970 %!test
4971 %! A = [0,;0,;60+73*i,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
4972 %!test
4973 %! A = [0,;0,;60+73*i,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
4974 %!test
4975 %! A = [0,;0,;60+73*i,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
4976 %!test
4977 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
4978 %!test
4979 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
4980 %!test
4981 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)( ) == sparse (A)( ));
4982 %!test
4983 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)(1) == sparse (A)(1));
4984 %!test
4985 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
4986 %!test
4987 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)(3) == sparse (A)(3));
4988 %!test
4989 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)(3,1) == sparse (A)(3,1));
4990 %!test
4991 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
4992 %!test
4993 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)(:) == sparse (A)(:));
4994 %!test
4995 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
4996 %!test
4997 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
4998 %!test
4999 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5000 %!test
5001 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5002 %!test
5003 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5004 %!test
5005 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A)*i == sparse (A)*i);
5006 %!test
5007 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5008 %!test
5009 %! A = [0,;0,;60+73*i,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5010 %!test
5011 %! A = [0,;0,;60+73*i,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
5012 %!test
5013 %! A = [0,;0,;60+73*i,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
5014
5015 %% tests for a 3 x 3 matrix, density 50%, real
5016 %!test
5017 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert ( (sparsersb (A)) == (sparse (A)));
5018 %!test
5019 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5020 %!test
5021 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5022 %!test
5023 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5024 %!test
5025 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5026 %!test
5027 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5028 %!test
5029 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5030 %!test
5031 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5032 %!test
5033 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5034 %!test
5035 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5036 %!test
5037 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5038 %!test
5039 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5040 %!test
5041 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5042 %!test
5043 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5044 %!test
5045 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5046 %!test
5047 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)(3,3) == sparse (A)(3,3));
5048 %!test
5049 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
5050 %!test
5051 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)(9) == sparse (A)(9));
5052 %!test
5053 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5054 %!test
5055 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
5056 %!test
5057 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5058 %!test
5059 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5060 %!test
5061 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5062 %!test
5063 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5064 %!test
5065 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A)*i == sparse (A)*i);
5066 %!test
5067 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5068 %!test
5069 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5070 %!test
5071 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (reshape (sparsersb (A), 1, 9) == reshape (sparse (A), 1, 9));
5072 %!test
5073 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (reshape (sparsersb (A), 3, 3) == reshape (sparse (A), 3, 3));
5074 %!test
5075 %! A = [58,0,70,;5,62,0,;0,0,86,;]; assert (reshape (sparsersb (A), 9, 1) == reshape (sparse (A), 9, 1));
5076
5077 %% tests for a 3 x 3 matrix, density 50%, complex
5078 %!test
5079 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert ( (sparsersb (A)) == (sparse (A)));
5080 %!test
5081 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5082 %!test
5083 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5084 %!test
5085 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5086 %!test
5087 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5088 %!test
5089 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5090 %!test
5091 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5092 %!test
5093 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5094 %!test
5095 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5096 %!test
5097 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5098 %!test
5099 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5100 %!test
5101 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5102 %!test
5103 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5104 %!test
5105 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5106 %!test
5107 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5108 %!test
5109 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)(3,3) == sparse (A)(3,3));
5110 %!test
5111 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
5112 %!test
5113 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)(9) == sparse (A)(9));
5114 %!test
5115 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5116 %!test
5117 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
5118 %!test
5119 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5120 %!test
5121 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5122 %!test
5123 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5124 %!test
5125 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5126 %!test
5127 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A)*i == sparse (A)*i);
5128 %!test
5129 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5130 %!test
5131 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5132 %!test
5133 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (reshape (sparsersb (A), 1, 9) == reshape (sparse (A), 1, 9));
5134 %!test
5135 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (reshape (sparsersb (A), 3, 3) == reshape (sparse (A), 3, 3));
5136 %!test
5137 %! A = [0+64*i,23+36*i,0,;0,0,0,;8,0,0,;]; assert (reshape (sparsersb (A), 9, 1) == reshape (sparse (A), 9, 1));
5138
5139 %% tests for a 1 x 1 matrix, density 100%, real
5140 %!test
5141 %! A = [21,;]; assert ( (sparsersb (A)) == (sparse (A)));
5142 %!test
5143 %! A = [21,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5144 %!test
5145 %! A = [21,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5146 %!test
5147 %! A = [21,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5148 %!test
5149 %! A = [21,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5150 %!test
5151 %! A = [21,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5152 %!test
5153 %! A = [21,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5154 %!test
5155 %! A = [21,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5156 %!test
5157 %! A = [21,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5158 %!test
5159 %! A = [21,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5160 %!test
5161 %! A = [21,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5162 %!test
5163 %! A = [21,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5164 %!test
5165 %! A = [21,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5166 %!test
5167 %! A = [21,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5168 %!test
5169 %! A = [21,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5170 %!test
5171 %! A = [21,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
5172 %!test
5173 %! A = [21,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5174 %!test
5175 %! A = [21,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
5176 %!test
5177 %! A = [21,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5178 %!test
5179 %! A = [21,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5180 %!test
5181 %! A = [21,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5182 %!test
5183 %! A = [21,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5184 %!test
5185 %! A = [21,;]; assert (sparsersb (A)*i == sparse (A)*i);
5186 %!test
5187 %! A = [21,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5188 %!test
5189 %! A = [21,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5190 %!test
5191 %! A = [21,;]; assert (reshape (sparsersb (A), 1, 1) == reshape (sparse (A), 1, 1));
5192
5193 %% tests for a 1 x 1 matrix, density 100%, complex
5194 %!test
5195 %! A = [94+61*i,;]; assert ( (sparsersb (A)) == (sparse (A)));
5196 %!test
5197 %! A = [94+61*i,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5198 %!test
5199 %! A = [94+61*i,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5200 %!test
5201 %! A = [94+61*i,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5202 %!test
5203 %! A = [94+61*i,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5204 %!test
5205 %! A = [94+61*i,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5206 %!test
5207 %! A = [94+61*i,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5208 %!test
5209 %! A = [94+61*i,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5210 %!test
5211 %! A = [94+61*i,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5212 %!test
5213 %! A = [94+61*i,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5214 %!test
5215 %! A = [94+61*i,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5216 %!test
5217 %! A = [94+61*i,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5218 %!test
5219 %! A = [94+61*i,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5220 %!test
5221 %! A = [94+61*i,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5222 %!test
5223 %! A = [94+61*i,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5224 %!test
5225 %! A = [94+61*i,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
5226 %!test
5227 %! A = [94+61*i,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5228 %!test
5229 %! A = [94+61*i,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
5230 %!test
5231 %! A = [94+61*i,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5232 %!test
5233 %! A = [94+61*i,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5234 %!test
5235 %! A = [94+61*i,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5236 %!test
5237 %! A = [94+61*i,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5238 %!test
5239 %! A = [94+61*i,;]; assert (sparsersb (A)*i == sparse (A)*i);
5240 %!test
5241 %! A = [94+61*i,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5242 %!test
5243 %! A = [94+61*i,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5244 %!test
5245 %! A = [94+61*i,;]; assert (reshape (sparsersb (A), 1, 1) == reshape (sparse (A), 1, 1));
5246
5247 %% tests for a 1 x 3 matrix, density 100%, real
5248 %!test
5249 %! A = [38,64,99,;]; assert ( (sparsersb (A)) == (sparse (A)));
5250 %!test
5251 %! A = [38,64,99,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5252 %!test
5253 %! A = [38,64,99,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5254 %!test
5255 %! A = [38,64,99,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5256 %!test
5257 %! A = [38,64,99,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5258 %!test
5259 %! A = [38,64,99,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5260 %!test
5261 %! A = [38,64,99,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5262 %!test
5263 %! A = [38,64,99,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5264 %!test
5265 %! A = [38,64,99,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5266 %!test
5267 %! A = [38,64,99,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5268 %!test
5269 %! A = [38,64,99,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5270 %!test
5271 %! A = [38,64,99,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5272 %!test
5273 %! A = [38,64,99,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5274 %!test
5275 %! A = [38,64,99,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5276 %!test
5277 %! A = [38,64,99,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5278 %!test
5279 %! A = [38,64,99,;]; assert (sparsersb (A)(1,3) == sparse (A)(1,3));
5280 %!test
5281 %! A = [38,64,99,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
5282 %!test
5283 %! A = [38,64,99,;]; assert (sparsersb (A)(3) == sparse (A)(3));
5284 %!test
5285 %! A = [38,64,99,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5286 %!test
5287 %! A = [38,64,99,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
5288 %!test
5289 %! A = [38,64,99,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5290 %!test
5291 %! A = [38,64,99,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5292 %!test
5293 %! A = [38,64,99,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5294 %!test
5295 %! A = [38,64,99,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5296 %!test
5297 %! A = [38,64,99,;]; assert (sparsersb (A)*i == sparse (A)*i);
5298 %!test
5299 %! A = [38,64,99,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5300 %!test
5301 %! A = [38,64,99,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5302 %!test
5303 %! A = [38,64,99,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
5304 %!test
5305 %! A = [38,64,99,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
5306
5307 %% tests for a 1 x 3 matrix, density 100%, complex
5308 %!test
5309 %! A = [0+32*i,84+27*i,78,;]; assert ( (sparsersb (A)) == (sparse (A)));
5310 %!test
5311 %! A = [0+32*i,84+27*i,78,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5312 %!test
5313 %! A = [0+32*i,84+27*i,78,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5314 %!test
5315 %! A = [0+32*i,84+27*i,78,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5316 %!test
5317 %! A = [0+32*i,84+27*i,78,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5318 %!test
5319 %! A = [0+32*i,84+27*i,78,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5320 %!test
5321 %! A = [0+32*i,84+27*i,78,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5322 %!test
5323 %! A = [0+32*i,84+27*i,78,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5324 %!test
5325 %! A = [0+32*i,84+27*i,78,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5326 %!test
5327 %! A = [0+32*i,84+27*i,78,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5328 %!test
5329 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5330 %!test
5331 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5332 %!test
5333 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5334 %!test
5335 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5336 %!test
5337 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5338 %!test
5339 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)(1,3) == sparse (A)(1,3));
5340 %!test
5341 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)(1,:) == sparse (A)(1,:));
5342 %!test
5343 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)(3) == sparse (A)(3));
5344 %!test
5345 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5346 %!test
5347 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
5348 %!test
5349 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5350 %!test
5351 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5352 %!test
5353 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5354 %!test
5355 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5356 %!test
5357 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A)*i == sparse (A)*i);
5358 %!test
5359 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5360 %!test
5361 %! A = [0+32*i,84+27*i,78,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5362 %!test
5363 %! A = [0+32*i,84+27*i,78,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
5364 %!test
5365 %! A = [0+32*i,84+27*i,78,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
5366
5367 %% tests for a 3 x 1 matrix, density 100%, real
5368 %!test
5369 %! A = [31,;40,;66,;]; assert ( (sparsersb (A)) == (sparse (A)));
5370 %!test
5371 %! A = [31,;40,;66,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5372 %!test
5373 %! A = [31,;40,;66,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5374 %!test
5375 %! A = [31,;40,;66,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5376 %!test
5377 %! A = [31,;40,;66,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5378 %!test
5379 %! A = [31,;40,;66,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5380 %!test
5381 %! A = [31,;40,;66,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5382 %!test
5383 %! A = [31,;40,;66,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5384 %!test
5385 %! A = [31,;40,;66,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5386 %!test
5387 %! A = [31,;40,;66,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5388 %!test
5389 %! A = [31,;40,;66,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5390 %!test
5391 %! A = [31,;40,;66,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5392 %!test
5393 %! A = [31,;40,;66,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5394 %!test
5395 %! A = [31,;40,;66,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5396 %!test
5397 %! A = [31,;40,;66,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5398 %!test
5399 %! A = [31,;40,;66,;]; assert (sparsersb (A)(3) == sparse (A)(3));
5400 %!test
5401 %! A = [31,;40,;66,;]; assert (sparsersb (A)(3,1) == sparse (A)(3,1));
5402 %!test
5403 %! A = [31,;40,;66,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
5404 %!test
5405 %! A = [31,;40,;66,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5406 %!test
5407 %! A = [31,;40,;66,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
5408 %!test
5409 %! A = [31,;40,;66,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5410 %!test
5411 %! A = [31,;40,;66,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5412 %!test
5413 %! A = [31,;40,;66,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5414 %!test
5415 %! A = [31,;40,;66,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5416 %!test
5417 %! A = [31,;40,;66,;]; assert (sparsersb (A)*i == sparse (A)*i);
5418 %!test
5419 %! A = [31,;40,;66,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5420 %!test
5421 %! A = [31,;40,;66,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5422 %!test
5423 %! A = [31,;40,;66,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
5424 %!test
5425 %! A = [31,;40,;66,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
5426
5427 %% tests for a 3 x 1 matrix, density 100%, complex
5428 %!test
5429 %! A = [0+90*i,;25+58*i,;26,;]; assert ( (sparsersb (A)) == (sparse (A)));
5430 %!test
5431 %! A = [0+90*i,;25+58*i,;26,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5432 %!test
5433 %! A = [0+90*i,;25+58*i,;26,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5434 %!test
5435 %! A = [0+90*i,;25+58*i,;26,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5436 %!test
5437 %! A = [0+90*i,;25+58*i,;26,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5438 %!test
5439 %! A = [0+90*i,;25+58*i,;26,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5440 %!test
5441 %! A = [0+90*i,;25+58*i,;26,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5442 %!test
5443 %! A = [0+90*i,;25+58*i,;26,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5444 %!test
5445 %! A = [0+90*i,;25+58*i,;26,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5446 %!test
5447 %! A = [0+90*i,;25+58*i,;26,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5448 %!test
5449 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5450 %!test
5451 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5452 %!test
5453 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5454 %!test
5455 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5456 %!test
5457 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5458 %!test
5459 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)(3) == sparse (A)(3));
5460 %!test
5461 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)(3,1) == sparse (A)(3,1));
5462 %!test
5463 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
5464 %!test
5465 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5466 %!test
5467 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)(:,1) == sparse (A)(:,1));
5468 %!test
5469 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5470 %!test
5471 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5472 %!test
5473 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5474 %!test
5475 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5476 %!test
5477 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A)*i == sparse (A)*i);
5478 %!test
5479 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5480 %!test
5481 %! A = [0+90*i,;25+58*i,;26,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5482 %!test
5483 %! A = [0+90*i,;25+58*i,;26,;]; assert (reshape (sparsersb (A), 1, 3) == reshape (sparse (A), 1, 3));
5484 %!test
5485 %! A = [0+90*i,;25+58*i,;26,;]; assert (reshape (sparsersb (A), 3, 1) == reshape (sparse (A), 3, 1));
5486
5487 %% tests for a 3 x 3 matrix, density 100%, real
5488 %!test
5489 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert ( (sparsersb (A)) == (sparse (A)));
5490 %!test
5491 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5492 %!test
5493 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5494 %!test
5495 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5496 %!test
5497 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5498 %!test
5499 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5500 %!test
5501 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5502 %!test
5503 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5504 %!test
5505 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5506 %!test
5507 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5508 %!test
5509 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5510 %!test
5511 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5512 %!test
5513 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5514 %!test
5515 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5516 %!test
5517 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5518 %!test
5519 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)(3,3) == sparse (A)(3,3));
5520 %!test
5521 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
5522 %!test
5523 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)(9) == sparse (A)(9));
5524 %!test
5525 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5526 %!test
5527 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
5528 %!test
5529 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5530 %!test
5531 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5532 %!test
5533 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5534 %!test
5535 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5536 %!test
5537 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A)*i == sparse (A)*i);
5538 %!test
5539 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5540 %!test
5541 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5542 %!test
5543 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (reshape (sparsersb (A), 1, 9) == reshape (sparse (A), 1, 9));
5544 %!test
5545 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (reshape (sparsersb (A), 3, 3) == reshape (sparse (A), 3, 3));
5546 %!test
5547 %! A = [86,42,100,;1,53,72,;6,97,38,;]; assert (reshape (sparsersb (A), 9, 1) == reshape (sparse (A), 9, 1));
5548
5549 %% tests for a 3 x 3 matrix, density 100%, complex
5550 %!test
5551 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert ( (sparsersb (A)) == (sparse (A)));
5552 %!test
5553 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (istril (sparsersb (A)) == istril (sparse (A)));
5554 %!test
5555 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (istriu (sparsersb (A)) == istriu (sparse (A)));
5556 %!test
5557 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (isreal (sparsersb (A)) == isreal (sparse (A)));
5558 %!test
5559 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (iscomplex (sparsersb (A)) == iscomplex (sparse (A)));
5560 %!test
5561 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (issymmetric (sparsersb (A)) == issymmetric (sparse (A)));
5562 %!test
5563 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (ishermitian (sparsersb (A)) == ishermitian (sparse (A)));
5564 %!test
5565 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (nnz (sparsersb (A)) == nnz (sparse (A)));
5566 %!test
5567 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (rows (sparsersb (A)) == rows (sparse (A)));
5568 %!test
5569 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (columns (sparsersb (A)) == columns (sparse (A)));
5570 %!test
5571 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)'*(1*ones(size(A,1))) == sparse (A)'*(1*ones(size(A,1))));
5572 %!test
5573 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)'*(i*ones(size(A,1))) == sparse (A)'*(i*ones(size(A,1))));
5574 %!test
5575 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)( ) == sparse (A)( ));
5576 %!test
5577 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)(1) == sparse (A)(1));
5578 %!test
5579 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)(1,1) == sparse (A)(1,1));
5580 %!test
5581 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)(3,3) == sparse (A)(3,3));
5582 %!test
5583 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)(3,:) == sparse (A)(3,:));
5584 %!test
5585 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)(9) == sparse (A)(9));
5586 %!test
5587 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)(:) == sparse (A)(:));
5588 %!test
5589 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)(:,3) == sparse (A)(:,3));
5590 %!test
5591 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)(:,:) == sparse (A)(:,:));
5592 %!test
5593 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)*(1*ones(size(A,2))) == sparse (A)*(1*ones(size(A,2))));
5594 %!test
5595 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)*(i*ones(size(A,2))) == sparse (A)*(i*ones(size(A,2))));
5596 %!test
5597 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)*1 == sparse (A)*1);
5598 %!test
5599 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A)*i == sparse (A)*i);
5600 %!test
5601 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A).'*(1*ones(size(A,1))) == sparse (A).'*(1*ones(size(A,1))));
5602 %!test
5603 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (sparsersb (A).'*(i*ones(size(A,1))) == sparse (A).'*(i*ones(size(A,1))));
5604 %!test
5605 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (reshape (sparsersb (A), 1, 9) == reshape (sparse (A), 1, 9));
5606 %!test
5607 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (reshape (sparsersb (A), 3, 3) == reshape (sparse (A), 3, 3));
5608 %!test
5609 %! A = [88,95,43,;0+76*i,26+64*i,0,;0+61*i,45+54*i,0+15*i,;]; assert (reshape (sparsersb (A), 9, 1) == reshape (sparse (A), 9, 1));
5610 %% Generated with rand state 42 .
5611 */ /* GENERATED TEST LINES END */
5612
5613 /*
5614 %% tests for different operators multiplications
5615
5616 %!test % REAL/REAL
5617 %! A = sprandn(1e3,1e3,1/1e3); Arsb = sparsersb(A); v = randn(1e3,1);
5618 %! assert(A*v,Arsb*v,1e-14);
5619 %! assert(A.'*v,Arsb.'*v,1e-14);
5620 %! assert(A'*v,Arsb'*v,1e-14);
5621
5622 %!test % REAL/COMPLEX
5623 %! A = sprandn(1e6,1e6,1/1e6); Arsb = sparsersb(A); v = 1i*randn(1e6,1) + randn(1e6,1);
5624 %! assert(A*v,Arsb*v,1e-14);
5625 %! assert(A.'*v,Arsb.'*v,1e-14);
5626 %! assert(A'*v,Arsb'*v,1e-14);
5627
5628 %!test % COMPLEX/REAL
5629 %! A = 1i*sprandn(1e3,1e3,1/1e3) + sprandn(1e3,1e3,1/1e3); Arsb = sparsersb(A); v = randn(1e3,1);
5630 %! assert(A*v,Arsb*v,1e-14);
5631 %! assert(A.'*v,Arsb.'*v,1e-14);
5632 %! assert(A'*v,Arsb'*v,1e-14);
5633
5634 %!test % COMPLEX/COMPLEX
5635 %! A = 1i*sprandn(1e3,1e3,1/1e3) + sprandn(1e3,1e3,1/1e3); Arsb = sparsersb(A); v = 1i*randn(1e3,1) + randn(1e3,1);
5636 %! assert(A*v,Arsb*v,1e-14);
5637 %! assert(A.'*v,Arsb.'*v,1e-14);
5638 %! assert(A'*v,Arsb'*v,1e-14);
5639
5640 */
5641
5642 /*
5643 %!demo
5644 %! disp("'sparsersb' behaves pretty like 'sparse':")
5645 %! R=(rand(3)>.6)
5646 %! A_octave=sparse(R)
5647 %! A_librsb=sparsersb(R)
5648
5649 %!demo
5650 %! disp("The interface of 'sparsersb' is almost like the one of 'sparse'")
5651 %! disp("Create a 1x1 matrix:")
5652 %! sparsersb([2])
5653 %! disp("Create a 2x1 matrix:")
5654 %! sparsersb([1,2],[1,1],[11,21])
5655 %! disp("Create a 2x2 matrix:")
5656 %! sparsersb([1,2],[1,1],[11,21],2,2)
5657 %! disp("Create a 2x2 lower triangular matrix:")
5658 %! sparsersb([1,2,2 ],[1,1,2 ],[11,21, 22],2,2)
5659
5660 %!demo
5661 %! disp("'sparsersb' has an option to handle duplicates.")
5662 %! disp("Create a 2x2 lower triangular matrix (last element summed by default):")
5663 %! sparsersb([1,2,2,2],[1,1,2,2],[11,21,11,11],2,2)
5664 %! disp("Create a 2x2 lower triangular matrix (last two elements summed explicitly):")
5665 %! sparsersb([1,2,2,2],[1,1,2,2],[11,21,11,11],2,2,"sum")
5666 %! disp("Create a 2x2 lower triangular matrix (last element ignored, explicitly):")
5667 %! sparsersb([1,2,2,2],[1,1,2,2],[11,21,11,11],2,2,"unique")
5668
5669 %!demo
5670 %! disp("'sparsersb' support symmetric and hermitian matrices:\n")
5671 %! disp("2x2 lower tringular:")
5672 %! sparsersb([1,2,2 ],[1,1,2 ],[11,21 , 22],2,2,"general")
5673 %! disp("2x2 symmetric (only lower triangle stored):")
5674 %! sparsersb([1,2,2 ],[1,1,2 ],[11,21 , 22],2,2,"symmetric")
5675 %! disp("2x2 hermitian (only lower triangle stored):")
5676 %! sparsersb([1,2,2 ],[1,1,2 ],[11,21i, 22],2,2,"hermitian")
5677
5678 %!demo
5679 %! disp("Any 'sparse' or 'dense' matrix can be converted to 'sparsersb':")
5680 %! d=sparsersb( [1,2;3,4] )
5681 %! f=sparsersb( full ([1,2;3,4]))
5682 %! s=sparsersb(sparse([1,2;3,4]))
5683
5684 %!demo
5685 %! disp("'sparsersb' detects symmetry:")
5686 %! d=sparsersb( [1,2;2,1] )
5687 %! s=sparsersb(sparse([1,2;2,1]))
5688
5689 %!demo
5690 %! disp("'sparsersb' detects hermitianness:")
5691 %! d=sparsersb( [1,i;-i,1] )
5692 %! s=sparsersb(sparse([1,i;-i,1]))
5693
5694 %!demo
5695 %! disp("The most important use of 'sparsersb' is for multiplying sparse matrices...\n")
5696 %! a=sparsersb( [1,2;3,4] )
5697 %! disp("...by dense matrices or vectors:\n")
5698 %! x=[1,2;1,2]
5699 %!
5700 %! disp("Untransposed sparse matrix-vector multiplication:")
5701 %! a*x
5702 %!
5703 %! disp("Transposed sparse matrix-vector multiplication:")
5704 %! a'*x
5705
5706 %!demo
5707 %! d=sparsersb( [1,2;3,4] );
5708 %! s=sparsersb(sparse([1,2;3,4]));
5709 %!
5710 %! disp("Many sparse-sparse matrix operators work on 'sparsersb'\n")
5711 %! disp("'+' operator:")
5712 %! s+d
5713 %! disp("'.+' operator:")
5714 %! s.+d
5715 %! disp("'-' operator:")
5716 %! s-d
5717 %! disp("'.-' operator:")
5718 %! s.-d
5719 %! disp("'*' operator:")
5720 %! s*d
5721 %! disp("'.*' operator:")
5722 %! s.*d
5723 %! disp("'/' operator:")
5724 %! s/d
5725 %! disp("'./' operator:")
5726 %! s./d
5727 %! disp("'\\' operator:")
5728 %! s\[1;1]
5729 %! disp("And others. Not all operators are native: certain use a conversion; see the printout.\n")
5730
5731 %!demo
5732 %! o=sparse( [1,2;3,4] );
5733 %! s=sparsersb([1,2;3,4] );
5734 %!
5735 %! disp("Most of these operators hide a conversion; see the printout:\n")
5736 %!
5737 %! s(:,:)
5738 %! o(:,:)
5739 %!
5740 %! s(:,2)
5741 %! o(:,2)
5742 %!
5743 %! s(2,:)
5744 %! o(2,:)
5745 %!
5746 %! s(:)
5747 %! o(:)
5748
5749 %!demo
5750 %! disp("On large matrices 'sparsersb' may be faster than 'sparse' in sparse matrix-vector multiplication.")
5751 %! disp("In addition to that, 'sparsersb' has an 'empirical online auto-tuning' functionality.")
5752 %! disp("It means you run the autotuning on a specific input, and just after, the multiplication might be faster.")
5753 %! disp("See this case with two different right hand sides (NRHS) count.\n")
5754 %! M=100000;
5755 %! N=100000;
5756 %! P=100 / M;
5757 %! s=sparse(sprand(M,N,P));
5758 %!
5759 %! for NRHSc = {1,7}
5760 %! r=sparsersb(s); # repeat tuning from 'vanilla' matrix
5761 %! assert(nnz(s)==nnz(r))
5762 %! NRHS=cell2mat(NRHSc);
5763 %!
5764 %! x=ones(M,NRHS);
5765 %! printf("Here, a %.2e x %.2e matrix with %.2e nonzeroes, %d NRHS.\n",M,N,nnz(s),NRHS)
5766 %! tic();
5767 %! sc=0;
5768 %! while(toc()<3)
5769 %! s*x;
5770 %! sc=sc+1;
5771 %! endwhile
5772 %! st=toc()/sc;
5773 %! printf("Each multiplication with 'sparse' took %.1es.\n",st);
5774 %!
5775 %! tic();
5776 %! rc=0;
5777 %! while(toc()<3)
5778 %! r*x;
5779 %! rc=rc+1;
5780 %! endwhile
5781 %! rt=toc()/rc;
5782 %! ut=rt; # untuned time
5783 %! printf("Each multiplication with 'sparsersb' took %.3es, this is %.4g%% of the time taken by 'sparse'.\n",rt,100*rt/st);
5784 %!
5785 %! nsb=str2num(sparsersb(r,"get","RSB_MIF_LEAVES_COUNT__TO__RSB_BLK_INDEX_T"));
5786 %! tic;
5787 %! r=sparsersb(r,"autotune","n",NRHS);
5788 %! at_t=toc;
5789 %! nnb=str2num(sparsersb(r,"get","RSB_MIF_LEAVES_COUNT__TO__RSB_BLK_INDEX_T"));
5790 %! printf ("Autotuning for %d NRHS took %.2es (%d -> %d RSB blocks).\n", NRHS, at_t, nsb, nnb);
5791 %! tic();
5792 %! rc=0;
5793 %! while(toc()<3)
5794 %! r*x;
5795 %! rc=rc+1;
5796 %! endwhile
5797 %! rt=toc()/rc;
5798 %! printf("After tuning, each 'sparsersb' multiplication took %.3es.\n",rt);
5799 %! printf("This is %.4g%% of the time taken by 'sparse' (%.2fx speedup).\n",100*rt/st,st/rt);
5800 %! if ut > rt;
5801 %! printf ("Autotuning brought a %.2fx speedup over original RSB structure.\n", ut/rt);
5802 %! printf ("Time spent in autotuning can be amortized in %.1d iterations.\n", at_t/(ut-rt) );
5803 %! else
5804 %! printf ("RSB autotuning brought no further speedup for NRHS=%d.\n",NRHS);
5805 %! endif
5806 %! disp("")
5807 %! endfor
5808
5809 %!demo
5810 %! disp("'sparsersb' can render sparse matrices into Encapsulated Postscript files showing the RSB blocks layout.")
5811 %! rm = sparsersb(sprand(100000,100000,.0001));
5812 %! sparsersb(rm,'render','sptest.eps')
5813 %! disp("You can open sptest.eps now.")
5814 %%!demo
5815 */
5816