24 #if defined (HAVE_CONFIG_H)
52 (*current_liboctave_error_handler)
53 (
"svd: U not computed because type == svd::sigma_only");
63 (*current_liboctave_error_handler)
64 (
"svd: V not computed because type == svd::sigma_only");
72 #define GESVD_REAL_STEP(f, F) \
73 F77_XFCN (f, F, (F77_CONST_CHAR_ARG2 (&jobu, 1), \
74 F77_CONST_CHAR_ARG2 (&jobv, 1), \
75 m, n, tmp_data, m1, s_vec, u, m1, vt, \
76 nrow_vt1, work.data (), lwork, info \
77 F77_CHAR_ARG_LEN (1) \
78 F77_CHAR_ARG_LEN (1)))
80 #define GESVD_COMPLEX_STEP(f, F, CMPLX_ARG) \
81 F77_XFCN (f, F, (F77_CONST_CHAR_ARG2 (&jobu, 1), \
82 F77_CONST_CHAR_ARG2 (&jobv, 1), \
83 m, n, CMPLX_ARG (tmp_data), \
84 m1, s_vec, CMPLX_ARG (u), m1, \
85 CMPLX_ARG (vt), nrow_vt1, \
86 CMPLX_ARG (work.data ()), \
87 lwork, rwork.data (), info \
88 F77_CHAR_ARG_LEN (1) \
89 F77_CHAR_ARG_LEN (1)))
96 double* s_vec,
double*
u,
double* vt,
103 work.reserve (lwork);
120 work.reserve (lwork);
132 std::vector<Complex>& work,
135 std::vector<double> rwork (5 *
std::max (m, n));
139 lwork = work[0].real ();
140 work.reserve (lwork);
153 std::vector<FloatComplex>& work,
156 std::vector<float> rwork (5 *
std::max (m, n));
160 lwork = work[0].real ();
161 work.reserve (lwork);
166 #undef GESVD_REAL_STEP
167 #undef GESVD_COMPLEX_STEP
172 #define GESDD_REAL_STEP(f, F) \
173 F77_XFCN (f, F, (F77_CONST_CHAR_ARG2 (&jobz, 1), \
174 m, n, tmp_data, m1, s_vec, u, m1, vt, nrow_vt1, \
175 work.data (), lwork, iwork, info \
176 F77_CHAR_ARG_LEN (1)))
178 #define GESDD_COMPLEX_STEP(f, F, CMPLX_ARG) \
179 F77_XFCN (f, F, (F77_CONST_CHAR_ARG2 (&jobz, 1), m, n, \
180 CMPLX_ARG (tmp_data), m1, \
181 s_vec, CMPLX_ARG (u), m1, \
182 CMPLX_ARG (vt), nrow_vt1, \
183 CMPLX_ARG (work.data ()), lwork, \
184 rwork.data (), iwork, info \
185 F77_CHAR_ARG_LEN (1)))
192 double* s_vec,
double*
u,
200 work.reserve (lwork);
210 float* s_vec,
float*
u,
218 work.reserve (lwork);
240 lrwork = 5*min_mn*min_mn + 5*min_mn;
242 std::vector<double> rwork (lrwork);
246 lwork = work[0].real ();
247 work.reserve (lwork);
260 std::vector<FloatComplex>& work,
271 lrwork = min_mn *
std::max (5*min_mn+7, 2*max_mn+2*min_mn+1);
272 std::vector<float> rwork (lrwork);
276 lwork = work[0].real ();
277 work.reserve (lwork);
282 #undef GESDD_REAL_STEP
283 #undef GESDD_COMPLEX_STEP
289 : m_type (type), m_driver (driver), left_sm (), sigma (), right_sm ()
296 if (m == 0 || n == 0)
325 P* tmp_data = atmp.fortran_vec ();
341 ncol_u = nrow_vt = nrow_s = ncol_s = min_mn;
355 ncol_u = nrow_vt = 1;
362 if (! (jobu ==
'N' || jobu ==
'O'))
367 sigma.resize (nrow_s, ncol_s);
370 if (! (jobv ==
'N' || jobv ==
'O'))
379 std::vector<P> work (1);
383 static_cast<octave_idx_type> (1));
386 gesvd (jobu, jobv, m, n, tmp_data, m1, s_vec, u, vt, nrow_vt1,
390 assert (jobu == jobv);
393 std::vector<octave_idx_type> iwork (8 *
std::min (m, n));
395 gesdd (jobz, m, n, tmp_data, m1, s_vec, u, vt, nrow_vt1,
396 work, lwork, iwork.data (), info);
401 if (! (jobv ==
'N' || jobv ==
'O'))
Octave interface to the compression and uncompression libraries.
#define F77_DBLE_CMPLX_ARG(x)
void gesvd(char &jobu, char &jobv, octave_idx_type m, octave_idx_type n, P *tmp_data, octave_idx_type m1, DM_P *s_vec, P *u, P *vt, octave_idx_type nrow_vt1, std::vector< P > &work, octave_idx_type &lwork, octave_idx_type &info)
#define GESDD_COMPLEX_STEP(f, F, CMPLX_ARG)
T left_singular_matrix(void) const
#define GESVD_COMPLEX_STEP(f, F, CMPLX_ARG)
T right_singular_matrix(void) const
calling an anonymous function involves an overhead quite comparable to the overhead of an m file function Passing a handle to a built in function is because the interpreter is not involved in the internal loop For a
T::real_diag_matrix_type DM_T
nd deftypefn *octave_map m
void gesdd(char &jobz, octave_idx_type m, octave_idx_type n, P *tmp_data, octave_idx_type m1, DM_P *s_vec, P *u, P *vt, octave_idx_type nrow_vt1, std::vector< P > &work, octave_idx_type &lwork, octave_idx_type *iwork, octave_idx_type &info)
#define GESDD_REAL_STEP(f, F)
charNDArray max(char d, const charNDArray &m)
octave_idx_type rows(void) const
=val(i)}if ode{val(i)}occurs in table i
#define GESVD_REAL_STEP(f, F)
std::complex< float > FloatComplex
std::complex< double > Complex
charNDArray min(char d, const charNDArray &m)