1 // SPDX-License-Identifier: Apache-2.0
2 //
3 // Copyright 2008-2016 Conrad Sanderson (http://conradsanderson.id.au)
4 // Copyright 2008-2016 National ICT Australia (NICTA)
5 //
6 // Licensed under the Apache License, Version 2.0 (the "License");
7 // you may not use this file except in compliance with the License.
8 // You may obtain a copy of the License at
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 // ------------------------------------------------------------------------
17
18
19 //! \addtogroup fn_conv_to
20 //! @{
21
22
23
24 //! conversion from Armadillo Base and BaseCube objects to scalars
25 //! NOTE: use as_scalar() instead; this functionality is kept only for compatibility with old user code
26 template<typename out_eT>
27 class conv_to
28 {
29 public:
30
31 template<typename in_eT, typename T1>
32 inline static out_eT from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
33
34 template<typename in_eT, typename T1>
35 inline static out_eT from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
36
37 template<typename in_eT, typename T1>
38 inline static out_eT from(const BaseCube<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
39
40 template<typename in_eT, typename T1>
41 inline static out_eT from(const BaseCube<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
42 };
43
44
45
46 template<typename out_eT>
47 template<typename in_eT, typename T1>
48 arma_warn_unused
49 inline
50 out_eT
from(const Base<in_eT,T1> & in,const typename arma_not_cx<in_eT>::result * junk)51 conv_to<out_eT>::from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk)
52 {
53 arma_extra_debug_sigprint();
54 arma_ignore(junk);
55
56 arma_type_check(( is_supported_elem_type<out_eT>::value == false ));
57
58 const Proxy<T1> P(in.get_ref());
59
60 arma_debug_check( (P.get_n_elem() != 1), "conv_to(): given object doesn't have exactly one element" );
61
62 return out_eT(Proxy<T1>::use_at ? P.at(0,0) : P[0]);
63 }
64
65
66
67 template<typename out_eT>
68 template<typename in_eT, typename T1>
69 arma_warn_unused
70 inline
71 out_eT
from(const Base<in_eT,T1> & in,const typename arma_cx_only<in_eT>::result * junk)72 conv_to<out_eT>::from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk)
73 {
74 arma_extra_debug_sigprint();
75 arma_ignore(junk);
76
77 arma_type_check(( is_supported_elem_type<out_eT>::value == false ));
78
79 const Proxy<T1> P(in.get_ref());
80
81 arma_debug_check( (P.get_n_elem() != 1), "conv_to(): given object doesn't have exactly one element" );
82
83 out_eT out;
84
85 arrayops::convert_cx_scalar(out, (Proxy<T1>::use_at ? P.at(0,0) : P[0]));
86
87 return out;
88 }
89
90
91
92 template<typename out_eT>
93 template<typename in_eT, typename T1>
94 arma_warn_unused
95 inline
96 out_eT
from(const BaseCube<in_eT,T1> & in,const typename arma_not_cx<in_eT>::result * junk)97 conv_to<out_eT>::from(const BaseCube<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk)
98 {
99 arma_extra_debug_sigprint();
100 arma_ignore(junk);
101
102 arma_type_check(( is_supported_elem_type<out_eT>::value == false ));
103
104 const ProxyCube<T1> P(in.get_ref());
105
106 arma_debug_check( (P.get_n_elem() != 1), "conv_to(): given object doesn't have exactly one element" );
107
108 return out_eT(ProxyCube<T1>::use_at ? P.at(0,0,0) : P[0]);
109 }
110
111
112
113 template<typename out_eT>
114 template<typename in_eT, typename T1>
115 arma_warn_unused
116 inline
117 out_eT
from(const BaseCube<in_eT,T1> & in,const typename arma_cx_only<in_eT>::result * junk)118 conv_to<out_eT>::from(const BaseCube<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk)
119 {
120 arma_extra_debug_sigprint();
121 arma_ignore(junk);
122
123 arma_type_check(( is_supported_elem_type<out_eT>::value == false ));
124
125 const ProxyCube<T1> P(in.get_ref());
126
127 arma_debug_check( (P.get_n_elem() != 1), "conv_to(): given object doesn't have exactly one element" );
128
129 out_eT out;
130
131 arrayops::convert_cx_scalar(out, (ProxyCube<T1>::use_at ? P.at(0,0,0) : P[0]));
132
133 return out;
134 }
135
136
137
138 //! conversion to Armadillo matrices from Armadillo Base objects, as well as from std::vector
139 template<typename out_eT>
140 class conv_to< Mat<out_eT> >
141 {
142 public:
143
144 template<typename in_eT, typename T1>
145 inline static Mat<out_eT> from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
146
147 template<typename in_eT, typename T1>
148 inline static Mat<out_eT> from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
149
150 template<typename T1>
151 inline static Mat<out_eT> from(const SpBase<out_eT, T1>& in);
152
153
154
155 template<typename in_eT>
156 inline static Mat<out_eT> from(const std::vector<in_eT>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
157
158 template<typename in_eT>
159 inline static Mat<out_eT> from(const std::vector<in_eT>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
160 };
161
162
163
164 template<typename out_eT>
165 template<typename in_eT, typename T1>
166 arma_warn_unused
167 inline
168 Mat<out_eT>
from(const Base<in_eT,T1> & in,const typename arma_not_cx<in_eT>::result * junk)169 conv_to< Mat<out_eT> >::from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk)
170 {
171 arma_extra_debug_sigprint();
172 arma_ignore(junk);
173
174 const quasi_unwrap<T1> tmp(in.get_ref());
175 const Mat<in_eT>& X = tmp.M;
176
177 Mat<out_eT> out(X.n_rows, X.n_cols, arma_nozeros_indicator());
178
179 arrayops::convert( out.memptr(), X.memptr(), X.n_elem );
180
181 return out;
182 }
183
184
185
186 template<typename out_eT>
187 template<typename in_eT, typename T1>
188 arma_warn_unused
189 inline
190 Mat<out_eT>
from(const Base<in_eT,T1> & in,const typename arma_cx_only<in_eT>::result * junk)191 conv_to< Mat<out_eT> >::from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk)
192 {
193 arma_extra_debug_sigprint();
194 arma_ignore(junk);
195
196 const quasi_unwrap<T1> tmp(in.get_ref());
197 const Mat<in_eT>& X = tmp.M;
198
199 Mat<out_eT> out(X.n_rows, X.n_cols, arma_nozeros_indicator());
200
201 arrayops::convert_cx( out.memptr(), X.memptr(), X.n_elem );
202
203 return out;
204 }
205
206
207
208 template<typename out_eT>
209 template<typename T1>
210 arma_warn_unused
211 inline
212 Mat<out_eT>
from(const SpBase<out_eT,T1> & in)213 conv_to< Mat<out_eT> >::from(const SpBase<out_eT, T1>& in)
214 {
215 arma_extra_debug_sigprint();
216
217 return Mat<out_eT>(in.get_ref());
218 }
219
220
221
222 template<typename out_eT>
223 template<typename in_eT>
224 arma_warn_unused
225 inline
226 Mat<out_eT>
from(const std::vector<in_eT> & in,const typename arma_not_cx<in_eT>::result * junk)227 conv_to< Mat<out_eT> >::from(const std::vector<in_eT>& in, const typename arma_not_cx<in_eT>::result* junk)
228 {
229 arma_extra_debug_sigprint();
230 arma_ignore(junk);
231
232 const uword N = uword( in.size() );
233
234 Mat<out_eT> out(N, 1, arma_nozeros_indicator());
235
236 if(N > 0)
237 {
238 arrayops::convert( out.memptr(), &(in[0]), N );
239 }
240
241 return out;
242 }
243
244
245
246 template<typename out_eT>
247 template<typename in_eT>
248 arma_warn_unused
249 inline
250 Mat<out_eT>
from(const std::vector<in_eT> & in,const typename arma_cx_only<in_eT>::result * junk)251 conv_to< Mat<out_eT> >::from(const std::vector<in_eT>& in, const typename arma_cx_only<in_eT>::result* junk)
252 {
253 arma_extra_debug_sigprint();
254 arma_ignore(junk);
255
256 const uword N = uword( in.size() );
257
258 Mat<out_eT> out(N, 1, arma_nozeros_indicator());
259
260 if(N > 0)
261 {
262 arrayops::convert_cx( out.memptr(), &(in[0]), N );
263 }
264
265 return out;
266 }
267
268
269
270 //! conversion to Armadillo row vectors from Armadillo Base objects, as well as from std::vector
271 template<typename out_eT>
272 class conv_to< Row<out_eT> >
273 {
274 public:
275
276 template<typename in_eT, typename T1>
277 inline static Row<out_eT> from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
278
279 template<typename in_eT, typename T1>
280 inline static Row<out_eT> from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
281
282
283
284 template<typename in_eT>
285 inline static Row<out_eT> from(const std::vector<in_eT>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
286
287 template<typename in_eT>
288 inline static Row<out_eT> from(const std::vector<in_eT>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
289 };
290
291
292
293 template<typename out_eT>
294 template<typename in_eT, typename T1>
295 arma_warn_unused
296 inline
297 Row<out_eT>
from(const Base<in_eT,T1> & in,const typename arma_not_cx<in_eT>::result * junk)298 conv_to< Row<out_eT> >::from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk)
299 {
300 arma_extra_debug_sigprint();
301 arma_ignore(junk);
302
303 const quasi_unwrap<T1> tmp(in.get_ref());
304 const Mat<in_eT>& X = tmp.M;
305
306 arma_debug_check( ( (X.is_vec() == false) && (X.is_empty() == false) ), "conv_to(): given object can't be interpreted as a vector" );
307
308 Row<out_eT> out(X.n_elem, arma_nozeros_indicator());
309
310 arrayops::convert( out.memptr(), X.memptr(), X.n_elem );
311
312 return out;
313 }
314
315
316
317 template<typename out_eT>
318 template<typename in_eT, typename T1>
319 arma_warn_unused
320 inline
321 Row<out_eT>
from(const Base<in_eT,T1> & in,const typename arma_cx_only<in_eT>::result * junk)322 conv_to< Row<out_eT> >::from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk)
323 {
324 arma_extra_debug_sigprint();
325 arma_ignore(junk);
326
327 const quasi_unwrap<T1> tmp(in.get_ref());
328 const Mat<in_eT>& X = tmp.M;
329
330 arma_debug_check( ( (X.is_vec() == false) && (X.is_empty() == false) ), "conv_to(): given object can't be interpreted as a vector" );
331
332 Row<out_eT> out(X.n_rows, X.n_cols, arma_nozeros_indicator());
333
334 arrayops::convert_cx( out.memptr(), X.memptr(), X.n_elem );
335
336 return out;
337 }
338
339
340
341 template<typename out_eT>
342 template<typename in_eT>
343 arma_warn_unused
344 inline
345 Row<out_eT>
from(const std::vector<in_eT> & in,const typename arma_not_cx<in_eT>::result * junk)346 conv_to< Row<out_eT> >::from(const std::vector<in_eT>& in, const typename arma_not_cx<in_eT>::result* junk)
347 {
348 arma_extra_debug_sigprint();
349 arma_ignore(junk);
350
351 const uword N = uword( in.size() );
352
353 Row<out_eT> out(N, arma_nozeros_indicator());
354
355 if(N > 0)
356 {
357 arrayops::convert( out.memptr(), &(in[0]), N );
358 }
359
360 return out;
361 }
362
363
364
365 template<typename out_eT>
366 template<typename in_eT>
367 arma_warn_unused
368 inline
369 Row<out_eT>
from(const std::vector<in_eT> & in,const typename arma_cx_only<in_eT>::result * junk)370 conv_to< Row<out_eT> >::from(const std::vector<in_eT>& in, const typename arma_cx_only<in_eT>::result* junk)
371 {
372 arma_extra_debug_sigprint();
373 arma_ignore(junk);
374
375 const uword N = uword( in.size() );
376
377 Row<out_eT> out(N, arma_nozeros_indicator());
378
379 if(N > 0)
380 {
381 arrayops::convert_cx( out.memptr(), &(in[0]), N );
382 }
383
384 return out;
385 }
386
387
388
389 //! conversion to Armadillo column vectors from Armadillo Base objects, as well as from std::vector
390 template<typename out_eT>
391 class conv_to< Col<out_eT> >
392 {
393 public:
394
395 template<typename in_eT, typename T1>
396 inline static Col<out_eT> from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
397
398 template<typename in_eT, typename T1>
399 inline static Col<out_eT> from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
400
401
402
403 template<typename in_eT>
404 inline static Col<out_eT> from(const std::vector<in_eT>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
405
406 template<typename in_eT>
407 inline static Col<out_eT> from(const std::vector<in_eT>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
408 };
409
410
411
412 template<typename out_eT>
413 template<typename in_eT, typename T1>
414 arma_warn_unused
415 inline
416 Col<out_eT>
from(const Base<in_eT,T1> & in,const typename arma_not_cx<in_eT>::result * junk)417 conv_to< Col<out_eT> >::from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk)
418 {
419 arma_extra_debug_sigprint();
420 arma_ignore(junk);
421
422 const quasi_unwrap<T1> tmp(in.get_ref());
423 const Mat<in_eT>& X = tmp.M;
424
425 arma_debug_check( ( (X.is_vec() == false) && (X.is_empty() == false) ), "conv_to(): given object can't be interpreted as a vector" );
426
427 Col<out_eT> out(X.n_elem, arma_nozeros_indicator());
428
429 arrayops::convert( out.memptr(), X.memptr(), X.n_elem );
430
431 return out;
432 }
433
434
435
436 template<typename out_eT>
437 template<typename in_eT, typename T1>
438 arma_warn_unused
439 inline
440 Col<out_eT>
from(const Base<in_eT,T1> & in,const typename arma_cx_only<in_eT>::result * junk)441 conv_to< Col<out_eT> >::from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk)
442 {
443 arma_extra_debug_sigprint();
444 arma_ignore(junk);
445
446 const quasi_unwrap<T1> tmp(in.get_ref());
447 const Mat<in_eT>& X = tmp.M;
448
449 arma_debug_check( ( (X.is_vec() == false) && (X.is_empty() == false) ), "conv_to(): given object can't be interpreted as a vector" );
450
451 Col<out_eT> out(X.n_rows, X.n_cols, arma_nozeros_indicator());
452
453 arrayops::convert_cx( out.memptr(), X.memptr(), X.n_elem );
454
455 return out;
456 }
457
458
459
460 template<typename out_eT>
461 template<typename in_eT>
462 arma_warn_unused
463 inline
464 Col<out_eT>
from(const std::vector<in_eT> & in,const typename arma_not_cx<in_eT>::result * junk)465 conv_to< Col<out_eT> >::from(const std::vector<in_eT>& in, const typename arma_not_cx<in_eT>::result* junk)
466 {
467 arma_extra_debug_sigprint();
468 arma_ignore(junk);
469
470 const uword N = uword( in.size() );
471
472 Col<out_eT> out(N, arma_nozeros_indicator());
473
474 if(N > 0)
475 {
476 arrayops::convert( out.memptr(), &(in[0]), N );
477 }
478
479 return out;
480 }
481
482
483
484 template<typename out_eT>
485 template<typename in_eT>
486 arma_warn_unused
487 inline
488 Col<out_eT>
from(const std::vector<in_eT> & in,const typename arma_cx_only<in_eT>::result * junk)489 conv_to< Col<out_eT> >::from(const std::vector<in_eT>& in, const typename arma_cx_only<in_eT>::result* junk)
490 {
491 arma_extra_debug_sigprint();
492 arma_ignore(junk);
493
494 const uword N = uword( in.size() );
495
496 Col<out_eT> out(N, arma_nozeros_indicator());
497
498 if(N > 0)
499 {
500 arrayops::convert_cx( out.memptr(), &(in[0]), N );
501 }
502
503 return out;
504 }
505
506
507
508 //! convert between SpMat types
509 template<typename out_eT>
510 class conv_to< SpMat<out_eT> >
511 {
512 public:
513
514 template<typename in_eT, typename T1>
515 inline static SpMat<out_eT> from(const SpBase<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
516
517 template<typename in_eT, typename T1>
518 inline static SpMat<out_eT> from(const SpBase<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
519
520 template<typename T1>
521 inline static SpMat<out_eT> from(const Base<out_eT, T1>& in);
522 };
523
524
525
526 template<typename out_eT>
527 template<typename in_eT, typename T1>
528 arma_warn_unused
529 inline
530 SpMat<out_eT>
from(const SpBase<in_eT,T1> & in,const typename arma_not_cx<in_eT>::result * junk)531 conv_to< SpMat<out_eT> >::from(const SpBase<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk)
532 {
533 arma_extra_debug_sigprint();
534 arma_ignore(junk);
535
536 const unwrap_spmat<T1> tmp(in.get_ref());
537 const SpMat<in_eT>& X = tmp.M;
538
539 SpMat<out_eT> out(arma_layout_indicator(), X);
540
541 arrayops::convert( access::rwp(out.values), X.values, X.n_nonzero );
542
543 out.remove_zeros();
544
545 return out;
546 }
547
548
549
550 template<typename out_eT>
551 template<typename in_eT, typename T1>
552 arma_warn_unused
553 inline
554 SpMat<out_eT>
from(const SpBase<in_eT,T1> & in,const typename arma_cx_only<in_eT>::result * junk)555 conv_to< SpMat<out_eT> >::from(const SpBase<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk)
556 {
557 arma_extra_debug_sigprint();
558 arma_ignore(junk);
559
560 const unwrap_spmat<T1> tmp(in.get_ref());
561 const SpMat<in_eT>& X = tmp.M;
562
563 SpMat<out_eT> out(arma_layout_indicator(), X);
564
565 arrayops::convert_cx( access::rwp(out.values), X.values, X.n_nonzero );
566
567 out.remove_zeros();
568
569 return out;
570 }
571
572
573
574 template<typename out_eT>
575 template<typename T1>
576 arma_warn_unused
577 inline
578 SpMat<out_eT>
from(const Base<out_eT,T1> & in)579 conv_to< SpMat<out_eT> >::from(const Base<out_eT, T1>& in)
580 {
581 arma_extra_debug_sigprint();
582
583 return SpMat<out_eT>(in.get_ref());
584 }
585
586
587
588 //! conversion to Armadillo cubes from Armadillo BaseCube objects
589 template<typename out_eT>
590 class conv_to< Cube<out_eT> >
591 {
592 public:
593
594 template<typename in_eT, typename T1>
595 inline static Cube<out_eT> from(const BaseCube<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
596
597 template<typename in_eT, typename T1>
598 inline static Cube<out_eT> from(const BaseCube<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
599 };
600
601
602
603 template<typename out_eT>
604 template<typename in_eT, typename T1>
605 arma_warn_unused
606 inline
607 Cube<out_eT>
from(const BaseCube<in_eT,T1> & in,const typename arma_not_cx<in_eT>::result * junk)608 conv_to< Cube<out_eT> >::from(const BaseCube<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk)
609 {
610 arma_extra_debug_sigprint();
611 arma_ignore(junk);
612
613 const unwrap_cube<T1> tmp( in.get_ref() );
614 const Cube<in_eT>& X = tmp.M;
615
616 Cube<out_eT> out(X.n_rows, X.n_cols, X.n_slices, arma_nozeros_indicator());
617
618 arrayops::convert( out.memptr(), X.memptr(), X.n_elem );
619
620 return out;
621 }
622
623
624
625 template<typename out_eT>
626 template<typename in_eT, typename T1>
627 arma_warn_unused
628 inline
629 Cube<out_eT>
from(const BaseCube<in_eT,T1> & in,const typename arma_cx_only<in_eT>::result * junk)630 conv_to< Cube<out_eT> >::from(const BaseCube<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk)
631 {
632 arma_extra_debug_sigprint();
633 arma_ignore(junk);
634
635 const unwrap_cube<T1> tmp( in.get_ref() );
636 const Cube<in_eT>& X = tmp.M;
637
638 Cube<out_eT> out(X.n_rows, X.n_cols, X.n_slices, arma_nozeros_indicator());
639
640 arrayops::convert_cx( out.memptr(), X.memptr(), X.n_elem );
641
642 return out;
643 }
644
645
646
647 //! conversion to std::vector from Armadillo Base objects
648 template<typename out_eT>
649 class conv_to< std::vector<out_eT> >
650 {
651 public:
652
653 template<typename in_eT, typename T1>
654 inline static std::vector<out_eT> from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk = nullptr);
655
656 template<typename in_eT, typename T1>
657 inline static std::vector<out_eT> from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk = nullptr);
658 };
659
660
661
662 template<typename out_eT>
663 template<typename in_eT, typename T1>
664 arma_warn_unused
665 inline
666 std::vector<out_eT>
from(const Base<in_eT,T1> & in,const typename arma_not_cx<in_eT>::result * junk)667 conv_to< std::vector<out_eT> >::from(const Base<in_eT, T1>& in, const typename arma_not_cx<in_eT>::result* junk)
668 {
669 arma_extra_debug_sigprint();
670 arma_ignore(junk);
671
672 const quasi_unwrap<T1> tmp(in.get_ref());
673 const Mat<in_eT>& X = tmp.M;
674
675 arma_debug_check( ( (X.is_vec() == false) && (X.is_empty() == false) ), "conv_to(): given object can't be interpreted as a vector" );
676
677 const uword N = X.n_elem;
678
679 std::vector<out_eT> out(N);
680
681 if(N > 0)
682 {
683 arrayops::convert( &(out[0]), X.memptr(), N );
684 }
685
686 return out;
687 }
688
689
690
691 template<typename out_eT>
692 template<typename in_eT, typename T1>
693 arma_warn_unused
694 inline
695 std::vector<out_eT>
from(const Base<in_eT,T1> & in,const typename arma_cx_only<in_eT>::result * junk)696 conv_to< std::vector<out_eT> >::from(const Base<in_eT, T1>& in, const typename arma_cx_only<in_eT>::result* junk)
697 {
698 arma_extra_debug_sigprint();
699 arma_ignore(junk);
700
701 const quasi_unwrap<T1> tmp(in.get_ref());
702 const Mat<in_eT>& X = tmp.M;
703
704 arma_debug_check( ( (X.is_vec() == false) && (X.is_empty() == false) ), "conv_to(): given object can't be interpreted as a vector" );
705
706 const uword N = X.n_elem;
707
708 std::vector<out_eT> out(N);
709
710 if(N > 0)
711 {
712 arrayops::convert_cx( &(out[0]), X.memptr(), N );
713 }
714
715 return out;
716 }
717
718
719
720 //! @}
721