Col_meat.hpp
Go to the documentation of this file.
1 // Copyright (C) 2008-2011 NICTA (www.nicta.com.au)
2 // Copyright (C) 2008-2011 Conrad Sanderson
3 //
4 // This file is part of the Armadillo C++ library.
5 // It is provided without any warranty of fitness
6 // for any purpose. You can redistribute this file
7 // and/or modify it under the terms of the GNU
8 // Lesser General Public License (LGPL) as published
9 // by the Free Software Foundation, either version 3
10 // of the License or (at your option) any later version.
11 // (see http://www.opensource.org/licenses for more info)
12 
13 
16 
17 
19 template<typename eT>
20 inline
22  : Mat<eT>(0, 1)
23  {
25 
27  }
28 
29 
30 
31 template<typename eT>
32 inline
34  : Mat<eT>(X.n_elem, 1)
35  {
37 
39 
40  arrayops::copy((*this).memptr(), X.memptr(), X.n_elem);
41  }
42 
43 
44 
46 template<typename eT>
47 inline
48 Col<eT>::Col(const uword in_n_elem)
49  : Mat<eT>(in_n_elem, 1)
50  {
52 
54  }
55 
56 
57 
58 template<typename eT>
59 inline
60 Col<eT>::Col(const uword in_n_rows, const uword in_n_cols)
61  {
63 
65 
66  Mat<eT>::init_warm(in_n_rows, in_n_cols);
67  }
68 
69 
70 
72 template<typename eT>
73 inline
74 Col<eT>::Col(const char* text)
75  {
77 
79 
80  Mat<eT>::operator=(text);
81 
83 
85  }
86 
87 
88 
90 template<typename eT>
91 inline
92 const Col<eT>&
93 Col<eT>::operator=(const char* text)
94  {
96 
98 
99  Mat<eT>::operator=(text);
100 
102 
104 
105  return *this;
106  }
107 
108 
109 
111 template<typename eT>
112 inline
113 Col<eT>::Col(const std::string& text)
114  {
116 
118 
119  Mat<eT>::operator=(text);
120 
122 
124  }
125 
126 
127 
129 template<typename eT>
130 inline
131 const Col<eT>&
132 Col<eT>::operator=(const std::string& text)
133  {
135 
137 
138  Mat<eT>::operator=(text);
139 
141 
143 
144  return *this;
145  }
146 
147 
148 
149 #if defined(ARMA_USE_CXX11)
150 
151 template<typename eT>
152 inline
153 Col<eT>::Col(const std::initializer_list<eT>& list)
154  {
156 
158 
159  Mat<eT>::operator=(list);
160 
162 
164  }
165 
166 
167 
168 template<typename eT>
169 inline
170 const Col<eT>&
171 Col<eT>::operator=(const std::initializer_list<eT>& list)
172  {
174 
176 
177  Mat<eT>::operator=(list);
178 
180 
182 
183  return *this;
184  }
185 
186 #endif
187 
188 
189 
190 template<typename eT>
191 inline
192 const Col<eT>&
193 Col<eT>::operator=(const eT val)
194  {
196 
197  Mat<eT>::operator=(val);
198 
199  return *this;
200  }
201 
202 
203 
204 template<typename eT>
205 template<typename T1>
206 inline
208  {
210 
212 
214  }
215 
216 
217 
218 template<typename eT>
219 template<typename T1>
220 inline
221 const Col<eT>&
223  {
225 
227 
228  return *this;
229  }
230 
231 
232 
234 template<typename eT>
235 inline
236 Col<eT>::Col(eT* aux_mem, const uword aux_length, const bool copy_aux_mem, const bool strict)
237  : Mat<eT>(aux_mem, aux_length, 1, copy_aux_mem, strict)
238  {
240 
242  }
243 
244 
245 
247 template<typename eT>
248 inline
249 Col<eT>::Col(const eT* aux_mem, const uword aux_length)
250  : Mat<eT>(aux_mem, aux_length, 1)
251  {
253 
255  }
256 
257 
258 
259 template<typename eT>
260 template<typename T1, typename T2>
261 inline
263  (
264  const Base<typename Col<eT>::pod_type, T1>& A,
265  const Base<typename Col<eT>::pod_type, T2>& B
266  )
267  {
269 
271 
272  Mat<eT>::init(A,B);
273  }
274 
275 
276 
277 template<typename eT>
278 template<typename T1>
279 inline
281  {
283 
285 
287  }
288 
289 
290 
291 template<typename eT>
292 template<typename T1>
293 inline
294 const Col<eT>&
296  {
298 
300 
301  return *this;
302  }
303 
304 
305 
306 template<typename eT>
307 inline
309  {
311 
313 
315  }
316 
317 
318 
319 template<typename eT>
320 inline
321 const Col<eT>&
323  {
325 
327 
328  return *this;
329  }
330 
331 
332 
333 template<typename eT>
334 inline
336 Col<eT>::operator<<(const eT val)
337  {
338  return mat_injector< Col<eT> >(*this, val);
339  }
340 
341 
342 
343 template<typename eT>
345 eT&
346 Col<eT>::row(const uword row_num)
347  {
348  arma_debug_check( (row_num >= Mat<eT>::n_rows), "Col::row(): out of bounds" );
349 
350  return access::rw(Mat<eT>::mem[row_num]);
351  }
352 
353 
354 
355 template<typename eT>
357 eT
358 Col<eT>::row(const uword row_num) const
359  {
360  arma_debug_check( (row_num >= Mat<eT>::n_rows), "Col::row(): out of bounds" );
361 
362  return Mat<eT>::mem[row_num];
363  }
364 
365 
366 
367 template<typename eT>
370 Col<eT>::rows(const uword in_row1, const uword in_row2)
371  {
373 
374  arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::rows(): indices out of bounds or incorrectly used");
375 
376  const uword subview_n_rows = in_row2 - in_row1 + 1;
377 
378  return subview_col<eT>(*this, 0, in_row1, subview_n_rows);
379  }
380 
381 
382 
383 template<typename eT>
385 const subview_col<eT>
386 Col<eT>::rows(const uword in_row1, const uword in_row2) const
387  {
389 
390  arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::rows(): indices out of bounds or incorrectly used");
391 
392  const uword subview_n_rows = in_row2 - in_row1 + 1;
393 
394  return subview_col<eT>(*this, 0, in_row1, subview_n_rows);
395  }
396 
397 
398 
399 template<typename eT>
402 Col<eT>::subvec(const uword in_row1, const uword in_row2)
403  {
405 
406  arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::subvec(): indices out of bounds or incorrectly used");
407 
408  const uword subview_n_rows = in_row2 - in_row1 + 1;
409 
410  return subview_col<eT>(*this, 0, in_row1, subview_n_rows);
411  }
412 
413 
414 
415 template<typename eT>
417 const subview_col<eT>
418 Col<eT>::subvec(const uword in_row1, const uword in_row2) const
419  {
421 
422  arma_debug_check( ( (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows) ), "Col::subvec(): indices out of bounds or incorrectly used");
423 
424  const uword subview_n_rows = in_row2 - in_row1 + 1;
425 
426  return subview_col<eT>(*this, 0, in_row1, subview_n_rows);
427  }
428 
429 
430 
431 template<typename eT>
434 Col<eT>::subvec(const span& row_span)
435  {
437 
438  const bool row_all = row_span.whole;
439 
440  const uword local_n_rows = Mat<eT>::n_rows;
441 
442  const uword in_row1 = row_all ? 0 : row_span.a;
443  const uword in_row2 = row_span.b;
444  const uword subvec_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1;
445 
446  arma_debug_check( ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ), "Col::subvec(): indices out of bounds or incorrectly used");
447 
448  return subview_col<eT>(*this, 0, in_row1, subvec_n_rows);
449  }
450 
451 
452 
453 template<typename eT>
455 const subview_col<eT>
456 Col<eT>::subvec(const span& row_span) const
457  {
459 
460  const bool row_all = row_span.whole;
461 
462  const uword local_n_rows = Mat<eT>::n_rows;
463 
464  const uword in_row1 = row_all ? 0 : row_span.a;
465  const uword in_row2 = row_span.b;
466  const uword subvec_n_rows = row_all ? local_n_rows : in_row2 - in_row1 + 1;
467 
468  arma_debug_check( ( row_all ? false : ((in_row1 > in_row2) || (in_row2 >= local_n_rows)) ), "Col::subvec(): indices out of bounds or incorrectly used");
469 
470  return subview_col<eT>(*this, 0, in_row1, subvec_n_rows);
471  }
472 
473 
474 
475 // template<typename eT>
476 // arma_inline
477 // subview_col<eT>
478 // Col<eT>::operator()(const span& row_span)
479 // {
480 // arma_extra_debug_sigprint();
481 //
482 // return subvec(row_span);
483 // }
484 //
485 //
486 //
487 // template<typename eT>
488 // arma_inline
489 // const subview_col<eT>
490 // Col<eT>::operator()(const span& row_span) const
491 // {
492 // arma_extra_debug_sigprint();
493 //
494 // return subvec(row_span);
495 // }
496 
497 
498 
500 template<typename eT>
501 inline
502 void
503 Col<eT>::shed_row(const uword row_num)
504  {
506 
507  arma_debug_check( row_num >= Mat<eT>::n_rows, "Col::shed_row(): out of bounds");
508 
509  shed_rows(row_num, row_num);
510  }
511 
512 
513 
515 template<typename eT>
516 inline
517 void
518 Col<eT>::shed_rows(const uword in_row1, const uword in_row2)
519  {
521 
523  (
524  (in_row1 > in_row2) || (in_row2 >= Mat<eT>::n_rows),
525  "Col::shed_rows(): indices out of bounds or incorrectly used"
526  );
527 
528  const uword n_keep_front = in_row1;
529  const uword n_keep_back = Mat<eT>::n_rows - (in_row2 + 1);
530 
531  Col<eT> X(n_keep_front + n_keep_back);
532 
533  eT* X_mem = X.memptr();
534  const eT* t_mem = (*this).memptr();
535 
536  if(n_keep_front > 0)
537  {
538  arrayops::copy( X_mem, t_mem, n_keep_front );
539  }
540 
541  if(n_keep_back > 0)
542  {
543  arrayops::copy( &(X_mem[n_keep_front]), &(t_mem[in_row2+1]), n_keep_back);
544  }
545 
547  }
548 
549 
550 
553 template<typename eT>
554 inline
555 void
556 Col<eT>::insert_rows(const uword row_num, const uword N, const bool set_to_zero)
557  {
559 
560  const uword t_n_rows = Mat<eT>::n_rows;
561 
562  const uword A_n_rows = row_num;
563  const uword B_n_rows = t_n_rows - row_num;
564 
565  // insertion at row_num == n_rows is in effect an append operation
566  arma_debug_check( (row_num > t_n_rows), "Col::insert_rows(): out of bounds");
567 
568  if(N > 0)
569  {
570  Col<eT> out(t_n_rows + N);
571 
572  eT* out_mem = out.memptr();
573  const eT* t_mem = (*this).memptr();
574 
575  if(A_n_rows > 0)
576  {
577  arrayops::copy( out_mem, t_mem, A_n_rows );
578  }
579 
580  if(B_n_rows > 0)
581  {
582  arrayops::copy( &(out_mem[row_num + N]), &(t_mem[row_num]), B_n_rows );
583  }
584 
585  if(set_to_zero == true)
586  {
587  arrayops::inplace_set( &(out_mem[row_num]), eT(0), N );
588  }
589 
590  Mat<eT>::steal_mem(out);
591  }
592  }
593 
594 
595 
598 template<typename eT>
599 template<typename T1>
600 inline
601 void
602 Col<eT>::insert_rows(const uword row_num, const Base<eT,T1>& X)
603  {
605 
606  Mat<eT>::insert_rows(row_num, X);
607  }
608 
609 
610 
611 template<typename eT>
612 inline
613 typename Col<eT>::row_iterator
614 Col<eT>::begin_row(const uword row_num)
615  {
617 
618  arma_debug_check( (row_num >= Mat<eT>::n_rows), "begin_row(): index out of bounds");
619 
620  return Mat<eT>::memptr() + row_num;
621  }
622 
623 
624 
625 template<typename eT>
626 inline
628 Col<eT>::begin_row(const uword row_num) const
629  {
631 
632  arma_debug_check( (row_num >= Mat<eT>::n_rows), "begin_row(): index out of bounds");
633 
634  return Mat<eT>::memptr() + row_num;
635  }
636 
637 
638 
639 template<typename eT>
640 inline
641 typename Col<eT>::row_iterator
642 Col<eT>::end_row(const uword row_num)
643  {
645 
646  arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds");
647 
648  return Mat<eT>::memptr() + row_num + 1;
649  }
650 
651 
652 
653 template<typename eT>
654 inline
656 Col<eT>::end_row(const uword row_num) const
657  {
659 
660  arma_debug_check( (row_num >= Mat<eT>::n_rows), "end_row(): index out of bounds");
661 
662  return Mat<eT>::memptr() + row_num + 1;
663  }
664 
665 
666 
667 template<typename eT>
668 template<uword fixed_n_elem>
670 void
672  {
674 
675  access::rw(Mat<eT>::n_rows) = fixed_n_elem;
677  access::rw(Mat<eT>::n_elem) = fixed_n_elem;
680  access::rw(Mat<eT>::mem) = (use_extra) ? mem_local_extra : Mat<eT>::mem_local;
681  }
682 
683 
684 
685 template<typename eT>
686 template<uword fixed_n_elem>
688 void
690  {
692 
693  access::rw(Mat<eT>::n_cols) = fixed_n_elem;
695  }
696 
697 
698 
699 template<typename eT>
700 template<uword fixed_n_elem>
703  {
705 
706  mem_setup();
707  }
708 
709 
710 
711 template<typename eT>
712 template<uword fixed_n_elem>
715  {
717 
718  mem_setup();
719 
720  eT* dest = (use_extra) ? mem_local_extra : Mat<eT>::mem_local;
721 
722  arrayops::copy( dest, X.mem, fixed_n_elem );
723  }
724 
725 
726 
727 template<typename eT>
728 template<uword fixed_n_elem>
729 inline
731  {
733 
734  mem_setup();
735 
737  }
738 
739 
740 
741 template<typename eT>
742 template<uword fixed_n_elem>
743 template<typename T1>
744 inline
746  {
748 
749  mem_setup();
750 
752  }
753 
754 
755 
756 template<typename eT>
757 template<uword fixed_n_elem>
758 template<typename T1, typename T2>
759 inline
761  {
763 
764  mem_setup();
765 
766  Col<eT>::init(A,B);
767  }
768 
769 
770 
771 template<typename eT>
772 template<uword fixed_n_elem>
773 inline
774 Col<eT>::fixed<fixed_n_elem>::fixed(eT* aux_mem, const bool copy_aux_mem)
775  {
777 
778  access::rw(Mat<eT>::n_rows) = fixed_n_elem;
780  access::rw(Mat<eT>::n_elem) = fixed_n_elem;
783 
784  if(copy_aux_mem == true)
785  {
786  eT* dest = (use_extra) ? mem_local_extra : Mat<eT>::mem_local;
787 
788  access::rw(Mat<eT>::mem) = dest;
789 
790  arrayops::copy( dest, aux_mem, fixed_n_elem );
791  }
792  else
793  {
794  access::rw(Mat<eT>::mem) = aux_mem;
795  }
796  }
797 
798 
799 
800 template<typename eT>
801 template<uword fixed_n_elem>
802 inline
804  {
806 
807  mem_setup();
808 
809  arrayops::copy( const_cast<eT*>(Mat<eT>::mem), aux_mem, fixed_n_elem );
810  }
811 
812 
813 
817 template<typename eT>
818 template<uword fixed_n_elem>
819 inline
821  {
823 
824  mem_setup();
825 
826  change_to_row();
827 
828  Col<eT>::operator=(text);
829  }
830 
831 
832 
836 template<typename eT>
837 template<uword fixed_n_elem>
838 inline
839 Col<eT>::fixed<fixed_n_elem>::fixed(const std::string& text)
840  {
842 
843  mem_setup();
844 
845  change_to_row();
846 
847  Col<eT>::operator=(text);
848  }
849 
850 
851 
852 template<typename eT>
853 template<uword fixed_n_elem>
854 template<typename T1>
855 const Col<eT>&
857  {
859 
861 
862  return *this;
863  }
864 
865 
866 
867 template<typename eT>
868 template<uword fixed_n_elem>
869 const Col<eT>&
871  {
873 
874  Col<eT>::operator=(val);
875 
876  return *this;
877  }
878 
879 
880 
881 template<typename eT>
882 template<uword fixed_n_elem>
883 const Col<eT>&
885  {
887 
888  change_to_row();
889 
890  Col<eT>::operator=(text);
891 
892  return *this;
893  }
894 
895 
896 
897 template<typename eT>
898 template<uword fixed_n_elem>
899 const Col<eT>&
901  {
903 
904  change_to_row();
905 
906  Col<eT>::operator=(text);
907 
908  return *this;
909  }
910 
911 
912 
913 template<typename eT>
914 template<uword fixed_n_elem>
915 const Col<eT>&
917  {
919 
921 
922  return *this;
923  }
924 
925 
926 
927 template<typename eT>
928 template<uword fixed_n_elem>
929 inline
931 Col<eT>::fixed<fixed_n_elem>::operator()(const uword row_num, const span& col_span)
932  {
934 
935  return Mat<eT>::operator()(row_num, col_span);
936  }
937 
938 
939 
940 template<typename eT>
941 template<uword fixed_n_elem>
942 inline
943 const subview_row<eT>
944 Col<eT>::fixed<fixed_n_elem>::operator()(const uword row_num, const span& col_span) const
945  {
947 
948  return Mat<eT>::operator()(row_num, col_span);
949  }
950 
951 
952 
953 template<typename eT>
954 template<uword fixed_n_elem>
955 inline
957 Col<eT>::fixed<fixed_n_elem>::operator()(const span& row_span, const uword col_num)
958  {
960 
961  return Mat<eT>::operator()(row_span, col_num);
962  }
963 
964 
965 
966 template<typename eT>
967 template<uword fixed_n_elem>
968 inline
969 const subview_col<eT>
970 Col<eT>::fixed<fixed_n_elem>::operator()(const span& row_span, const uword col_num) const
971  {
973 
974  return Mat<eT>::operator()(row_span, col_num);
975  }
976 
977 
978 
979 template<typename eT>
980 template<uword fixed_n_elem>
981 inline
983 Col<eT>::fixed<fixed_n_elem>::operator()(const span& row_span, const span& col_span)
984  {
986 
987  return Mat<eT>::operator()(row_span, col_span);
988  }
989 
990 
991 
992 template<typename eT>
993 template<uword fixed_n_elem>
994 inline
995 const subview<eT>
996 Col<eT>::fixed<fixed_n_elem>::operator()(const span& row_span, const span& col_span) const
997  {
999 
1000  return Mat<eT>::operator()(row_span, col_span);
1001  }
1002 
1003 
1004 
1005 template<typename eT>
1006 template<uword fixed_n_elem>
1009 eT&
1011  {
1012  return access::rw( Mat<eT>::mem[i] );
1013  }
1014 
1015 
1016 
1017 template<typename eT>
1018 template<uword fixed_n_elem>
1021 eT
1023  {
1024  return ( Mat<eT>::mem[i] );
1025  }
1026 
1027 
1028 
1029 template<typename eT>
1030 template<uword fixed_n_elem>
1033 eT&
1035  {
1036  return access::rw( Mat<eT>::mem[i] );
1037  }
1038 
1039 
1040 
1041 template<typename eT>
1042 template<uword fixed_n_elem>
1045 eT
1047  {
1048  return ( Mat<eT>::mem[i] );
1049  }
1050 
1051 
1052 
1053 template<typename eT>
1054 template<uword fixed_n_elem>
1057 eT&
1059  {
1060  arma_debug_check( (i >= fixed_n_elem), "Col::fixed::operator(): out of bounds");
1061 
1062  return access::rw( Mat<eT>::mem[i] );
1063  }
1064 
1065 
1066 
1067 template<typename eT>
1068 template<uword fixed_n_elem>
1071 eT
1073  {
1074  arma_debug_check( (i >= fixed_n_elem), "Col::fixed::operator(): out of bounds");
1075 
1076  return ( Mat<eT>::mem[i] );
1077  }
1078 
1079 
1080 
1081 template<typename eT>
1082 template<uword fixed_n_elem>
1085 eT&
1086 Col<eT>::fixed<fixed_n_elem>::at(const uword in_row, const uword in_col)
1087  {
1088  return access::rw( Mat<eT>::mem[in_row] );
1089  }
1090 
1091 
1092 
1093 template<typename eT>
1094 template<uword fixed_n_elem>
1097 eT
1098 Col<eT>::fixed<fixed_n_elem>::at(const uword in_row, const uword in_col) const
1099  {
1100  return ( Mat<eT>::mem[in_row] );
1101  }
1102 
1103 
1104 
1105 template<typename eT>
1106 template<uword fixed_n_elem>
1109 eT&
1111  {
1112  arma_debug_check( ((in_row >= fixed_n_elem) || (in_col >= 1)), "Col::fixed::operator(): out of bounds" );
1113 
1114  return access::rw( Mat<eT>::mem[in_row] );
1115  }
1116 
1117 
1118 
1119 template<typename eT>
1120 template<uword fixed_n_elem>
1123 eT
1124 Col<eT>::fixed<fixed_n_elem>::operator() (const uword in_row, const uword in_col) const
1125  {
1126  arma_debug_check( ((in_row >= fixed_n_elem) || (in_col >= 1)), "Col::fixed::operator(): out of bounds" );
1127 
1128  return ( Mat<eT>::mem[in_row] );
1129  }
1130 
1131 
1132 
1133 template<typename eT>
1134 template<uword fixed_n_elem>
1135 arma_hot
1136 inline
1137 const Col<eT>&
1139  {
1141 
1142  arrayops::inplace_set( const_cast<eT*>(Mat<eT>::mem), val, fixed_n_elem );
1143 
1144  return *this;
1145  }
1146 
1147 
1148 
1149 template<typename eT>
1150 template<uword fixed_n_elem>
1151 arma_hot
1152 inline
1153 const Col<eT>&
1155  {
1157 
1158  arrayops::inplace_set( const_cast<eT*>(Mat<eT>::mem), eT(0), fixed_n_elem );
1159 
1160  return *this;
1161  }
1162 
1163 
1164 
1165 template<typename eT>
1166 template<uword fixed_n_elem>
1167 arma_hot
1168 inline
1169 const Col<eT>&
1171  {
1173 
1174  arrayops::inplace_set( const_cast<eT*>(Mat<eT>::mem), eT(1), fixed_n_elem );
1175 
1176  return *this;
1177  }
1178 
1179 
1180 
1181 #ifdef ARMA_EXTRA_COL_MEAT
1182  #include ARMA_INCFILE_WRAP(ARMA_EXTRA_COL_MEAT)
1183 #endif
1184 
1185 
1186 
eT * row_iterator
Definition: Col_bones.hpp:87
uword b
Definition: span.hpp:40
arma_inline arma_warn_unused eT * memptr()
returns a pointer to array of eTs used by the matrix
Definition: Mat_meat.hpp:4024
bool whole
Definition: span.hpp:41
arma_hot static arma_inline void copy(eT *dest, const eT *src, const uword n_elem)
arma_inline const derived & get_ref() const
Definition: Base_meat.hpp:22
void steal_mem(Mat &X)
Definition: Mat_meat.hpp:630
Definition: span.hpp:35
void init_warm(uword in_rows, uword in_cols)
internal matrix construction; if the requested size is small enough, memory from the stack is used...
Definition: Mat_meat.hpp:126
mat_injector< Col > operator<<(const eT val)
Definition: Col_meat.hpp:336
const uword n_elem
number of elements in the matrix (read-only)
Definition: Mat_bones.hpp:31
const Col & operator=(const char *text)
construct a column vector from specified text
Definition: Col_meat.hpp:93
arma_inline eT & row(const uword row_num)
Definition: Col_meat.hpp:346
void insert_rows(const uword row_num, const uword N, const bool set_to_zero=true)
Definition: Mat_meat.hpp:2488
u32 uword
Definition: typedef.hpp:85
Col()
construct an empty column vector
Definition: Col_meat.hpp:21
arma_inline subview_col< eT > rows(const uword in_row1, const uword in_row2)
Definition: Col_meat.hpp:370
Class for column vectors (matrices with only one column)
Definition: Col_bones.hpp:20
void init(const std::string &text)
internal function to create the matrix from a textual description
Definition: Mat_meat.hpp:318
static arma_inline T1 & rw(const T1 &x)
internal function to allow modification of data declared as read-only
Definition: access.hpp:23
#define arma_debug_check
Definition: debug.hpp:1084
const Mat & ones()
Definition: Mat_meat.hpp:4371
uword a
Definition: span.hpp:39
static arma_hot void inplace_set(eT *dest, const eT val, const uword n_elem)
arma_inline arma_warn_unused eT & at(const uword i)
linear element accessor (treats the matrix as a vector); no bounds check.
Definition: Mat_meat.hpp:3692
subview_row< eT > operator()(const uword row_num, const span &col_span)
Definition: Mat_meat.hpp:1821
#define arma_extra_debug_sigprint_this
Definition: debug.hpp:1117
arma_inline arma_warn_unused eT & operator[](const uword i)
linear element accessor (treats the matrix as a vector); no bounds check.
Definition: Mat_meat.hpp:3668
const Mat & operator=(const char *text)
create the matrix from a textual description
Definition: Mat_meat.hpp:272
get_pod_type< eT >::result pod_type
Definition: Col_bones.hpp:25
void insert_rows(const uword row_num, const uword N, const bool set_to_zero=true)
Definition: Col_meat.hpp:556
row_iterator begin_row(const uword row_num)
Definition: Col_meat.hpp:614
#define arma_extra_debug_sigprint
Definition: debug.hpp:1116
Analog of the Base class, intended for cubes.
#define arma_warn_unused
arma_inline subview_col< eT > subvec(const uword in_row1, const uword in_row2)
Definition: Col_meat.hpp:402
Dense matrix class.
#define arma_inline
const Mat & zeros()
Definition: Mat_meat.hpp:4331
arma_aligned const eT *const mem
pointer to the memory used by the matrix (memory is read-only)
Definition: Mat_bones.hpp:40
void shed_row(const uword row_num)
remove specified row
Definition: Col_meat.hpp:503
const eT * const_row_iterator
Definition: Col_bones.hpp:88
#define arma_hot
void shed_rows(const uword in_row1, const uword in_row2)
remove specified rows
Definition: Col_meat.hpp:518
arma_hot const Mat & fill(const eT val)
fill the matrix with the specified value
Definition: Mat_meat.hpp:4317
row_iterator end_row(const uword row_num)
Definition: Col_meat.hpp:642


armadillo_matrix
Author(s):
autogenerated on Fri Apr 16 2021 02:31:56