3 * Copyright 2006 Free Software Foundation, Inc.
5 * This file is part of GNU Radio
7 * GNU Radio is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3, or (at your option)
12 * GNU Radio is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with GNU Radio; see the file COPYING. If not, write to
19 * the Free Software Foundation, Inc., 51 Franklin Street,
20 * Boston, MA 02110-1301, USA.
30 ////////////////////////////////////////////////////////////////////////////
32 ////////////////////////////////////////////////////////////////////////////
37 return dynamic_cast<pmt_u8vector*>(x.get());
41 pmt_u8vector::pmt_u8vector(size_t k, uint8_t fill)
44 for (size_t i = 0; i < k; i++)
48 pmt_u8vector::pmt_u8vector(size_t k, const uint8_t *data)
51 for (size_t i = 0; i < k; i++)
56 pmt_u8vector::ref(size_t k) const
59 throw pmt_out_of_range("pmt_u8vector_ref", pmt_from_long(k));
64 pmt_u8vector::set(size_t k, uint8_t x)
67 throw pmt_out_of_range("pmt_u8vector_set", pmt_from_long(k));
72 pmt_u8vector::elements(size_t &len)
79 pmt_u8vector::writable_elements(size_t &len)
86 pmt_u8vector::uniform_elements(size_t &len)
88 len = length() * sizeof(uint8_t);
93 pmt_u8vector::uniform_writable_elements(size_t &len)
95 len = length() * sizeof(uint8_t);
100 pmt_is_u8vector(pmt_t obj)
102 return obj->is_u8vector();
106 pmt_make_u8vector(size_t k, uint8_t fill)
108 return pmt_t(new pmt_u8vector(k, fill));
112 pmt_init_u8vector(size_t k, const uint8_t *data)
114 return pmt_t(new pmt_u8vector(k, data));
118 pmt_u8vector_ref(pmt_t vector, size_t k)
120 if (!vector->is_u8vector())
121 throw pmt_wrong_type("pmt_u8vector_ref", vector);
122 return _u8vector(vector)->ref(k);
126 pmt_u8vector_set(pmt_t vector, size_t k, uint8_t obj)
128 if (!vector->is_u8vector())
129 throw pmt_wrong_type("pmt_u8vector_set", vector);
130 _u8vector(vector)->set(k, obj);
134 pmt_u8vector_elements(pmt_t vector, size_t &len)
136 if (!vector->is_u8vector())
137 throw pmt_wrong_type("pmt_u8vector_elements", vector);
138 return _u8vector(vector)->elements(len);
142 pmt_u8vector_writable_elements(pmt_t vector, size_t &len)
144 if (!vector->is_u8vector())
145 throw pmt_wrong_type("pmt_u8vector_writable_elements", vector);
146 return _u8vector(vector)->writable_elements(len);
148 ////////////////////////////////////////////////////////////////////////////
150 ////////////////////////////////////////////////////////////////////////////
152 static pmt_s8vector *
155 return dynamic_cast<pmt_s8vector*>(x.get());
159 pmt_s8vector::pmt_s8vector(size_t k, int8_t fill)
162 for (size_t i = 0; i < k; i++)
166 pmt_s8vector::pmt_s8vector(size_t k, const int8_t *data)
169 for (size_t i = 0; i < k; i++)
174 pmt_s8vector::ref(size_t k) const
177 throw pmt_out_of_range("pmt_s8vector_ref", pmt_from_long(k));
182 pmt_s8vector::set(size_t k, int8_t x)
185 throw pmt_out_of_range("pmt_s8vector_set", pmt_from_long(k));
190 pmt_s8vector::elements(size_t &len)
197 pmt_s8vector::writable_elements(size_t &len)
204 pmt_s8vector::uniform_elements(size_t &len)
206 len = length() * sizeof(int8_t);
211 pmt_s8vector::uniform_writable_elements(size_t &len)
213 len = length() * sizeof(int8_t);
218 pmt_is_s8vector(pmt_t obj)
220 return obj->is_s8vector();
224 pmt_make_s8vector(size_t k, int8_t fill)
226 return pmt_t(new pmt_s8vector(k, fill));
230 pmt_init_s8vector(size_t k, const int8_t *data)
232 return pmt_t(new pmt_s8vector(k, data));
236 pmt_s8vector_ref(pmt_t vector, size_t k)
238 if (!vector->is_s8vector())
239 throw pmt_wrong_type("pmt_s8vector_ref", vector);
240 return _s8vector(vector)->ref(k);
244 pmt_s8vector_set(pmt_t vector, size_t k, int8_t obj)
246 if (!vector->is_s8vector())
247 throw pmt_wrong_type("pmt_s8vector_set", vector);
248 _s8vector(vector)->set(k, obj);
252 pmt_s8vector_elements(pmt_t vector, size_t &len)
254 if (!vector->is_s8vector())
255 throw pmt_wrong_type("pmt_s8vector_elements", vector);
256 return _s8vector(vector)->elements(len);
260 pmt_s8vector_writable_elements(pmt_t vector, size_t &len)
262 if (!vector->is_s8vector())
263 throw pmt_wrong_type("pmt_s8vector_writable_elements", vector);
264 return _s8vector(vector)->writable_elements(len);
266 ////////////////////////////////////////////////////////////////////////////
268 ////////////////////////////////////////////////////////////////////////////
270 static pmt_u16vector *
273 return dynamic_cast<pmt_u16vector*>(x.get());
277 pmt_u16vector::pmt_u16vector(size_t k, uint16_t fill)
280 for (size_t i = 0; i < k; i++)
284 pmt_u16vector::pmt_u16vector(size_t k, const uint16_t *data)
287 for (size_t i = 0; i < k; i++)
292 pmt_u16vector::ref(size_t k) const
295 throw pmt_out_of_range("pmt_u16vector_ref", pmt_from_long(k));
300 pmt_u16vector::set(size_t k, uint16_t x)
303 throw pmt_out_of_range("pmt_u16vector_set", pmt_from_long(k));
308 pmt_u16vector::elements(size_t &len)
315 pmt_u16vector::writable_elements(size_t &len)
322 pmt_u16vector::uniform_elements(size_t &len)
324 len = length() * sizeof(uint16_t);
329 pmt_u16vector::uniform_writable_elements(size_t &len)
331 len = length() * sizeof(uint16_t);
336 pmt_is_u16vector(pmt_t obj)
338 return obj->is_u16vector();
342 pmt_make_u16vector(size_t k, uint16_t fill)
344 return pmt_t(new pmt_u16vector(k, fill));
348 pmt_init_u16vector(size_t k, const uint16_t *data)
350 return pmt_t(new pmt_u16vector(k, data));
354 pmt_u16vector_ref(pmt_t vector, size_t k)
356 if (!vector->is_u16vector())
357 throw pmt_wrong_type("pmt_u16vector_ref", vector);
358 return _u16vector(vector)->ref(k);
362 pmt_u16vector_set(pmt_t vector, size_t k, uint16_t obj)
364 if (!vector->is_u16vector())
365 throw pmt_wrong_type("pmt_u16vector_set", vector);
366 _u16vector(vector)->set(k, obj);
370 pmt_u16vector_elements(pmt_t vector, size_t &len)
372 if (!vector->is_u16vector())
373 throw pmt_wrong_type("pmt_u16vector_elements", vector);
374 return _u16vector(vector)->elements(len);
378 pmt_u16vector_writable_elements(pmt_t vector, size_t &len)
380 if (!vector->is_u16vector())
381 throw pmt_wrong_type("pmt_u16vector_writable_elements", vector);
382 return _u16vector(vector)->writable_elements(len);
384 ////////////////////////////////////////////////////////////////////////////
386 ////////////////////////////////////////////////////////////////////////////
388 static pmt_s16vector *
391 return dynamic_cast<pmt_s16vector*>(x.get());
395 pmt_s16vector::pmt_s16vector(size_t k, int16_t fill)
398 for (size_t i = 0; i < k; i++)
402 pmt_s16vector::pmt_s16vector(size_t k, const int16_t *data)
405 for (size_t i = 0; i < k; i++)
410 pmt_s16vector::ref(size_t k) const
413 throw pmt_out_of_range("pmt_s16vector_ref", pmt_from_long(k));
418 pmt_s16vector::set(size_t k, int16_t x)
421 throw pmt_out_of_range("pmt_s16vector_set", pmt_from_long(k));
426 pmt_s16vector::elements(size_t &len)
433 pmt_s16vector::writable_elements(size_t &len)
440 pmt_s16vector::uniform_elements(size_t &len)
442 len = length() * sizeof(int16_t);
447 pmt_s16vector::uniform_writable_elements(size_t &len)
449 len = length() * sizeof(int16_t);
454 pmt_is_s16vector(pmt_t obj)
456 return obj->is_s16vector();
460 pmt_make_s16vector(size_t k, int16_t fill)
462 return pmt_t(new pmt_s16vector(k, fill));
466 pmt_init_s16vector(size_t k, const int16_t *data)
468 return pmt_t(new pmt_s16vector(k, data));
472 pmt_s16vector_ref(pmt_t vector, size_t k)
474 if (!vector->is_s16vector())
475 throw pmt_wrong_type("pmt_s16vector_ref", vector);
476 return _s16vector(vector)->ref(k);
480 pmt_s16vector_set(pmt_t vector, size_t k, int16_t obj)
482 if (!vector->is_s16vector())
483 throw pmt_wrong_type("pmt_s16vector_set", vector);
484 _s16vector(vector)->set(k, obj);
488 pmt_s16vector_elements(pmt_t vector, size_t &len)
490 if (!vector->is_s16vector())
491 throw pmt_wrong_type("pmt_s16vector_elements", vector);
492 return _s16vector(vector)->elements(len);
496 pmt_s16vector_writable_elements(pmt_t vector, size_t &len)
498 if (!vector->is_s16vector())
499 throw pmt_wrong_type("pmt_s16vector_writable_elements", vector);
500 return _s16vector(vector)->writable_elements(len);
502 ////////////////////////////////////////////////////////////////////////////
504 ////////////////////////////////////////////////////////////////////////////
506 static pmt_u32vector *
509 return dynamic_cast<pmt_u32vector*>(x.get());
513 pmt_u32vector::pmt_u32vector(size_t k, uint32_t fill)
516 for (size_t i = 0; i < k; i++)
520 pmt_u32vector::pmt_u32vector(size_t k, const uint32_t *data)
523 for (size_t i = 0; i < k; i++)
528 pmt_u32vector::ref(size_t k) const
531 throw pmt_out_of_range("pmt_u32vector_ref", pmt_from_long(k));
536 pmt_u32vector::set(size_t k, uint32_t x)
539 throw pmt_out_of_range("pmt_u32vector_set", pmt_from_long(k));
544 pmt_u32vector::elements(size_t &len)
551 pmt_u32vector::writable_elements(size_t &len)
558 pmt_u32vector::uniform_elements(size_t &len)
560 len = length() * sizeof(uint32_t);
565 pmt_u32vector::uniform_writable_elements(size_t &len)
567 len = length() * sizeof(uint32_t);
572 pmt_is_u32vector(pmt_t obj)
574 return obj->is_u32vector();
578 pmt_make_u32vector(size_t k, uint32_t fill)
580 return pmt_t(new pmt_u32vector(k, fill));
584 pmt_init_u32vector(size_t k, const uint32_t *data)
586 return pmt_t(new pmt_u32vector(k, data));
590 pmt_u32vector_ref(pmt_t vector, size_t k)
592 if (!vector->is_u32vector())
593 throw pmt_wrong_type("pmt_u32vector_ref", vector);
594 return _u32vector(vector)->ref(k);
598 pmt_u32vector_set(pmt_t vector, size_t k, uint32_t obj)
600 if (!vector->is_u32vector())
601 throw pmt_wrong_type("pmt_u32vector_set", vector);
602 _u32vector(vector)->set(k, obj);
606 pmt_u32vector_elements(pmt_t vector, size_t &len)
608 if (!vector->is_u32vector())
609 throw pmt_wrong_type("pmt_u32vector_elements", vector);
610 return _u32vector(vector)->elements(len);
614 pmt_u32vector_writable_elements(pmt_t vector, size_t &len)
616 if (!vector->is_u32vector())
617 throw pmt_wrong_type("pmt_u32vector_writable_elements", vector);
618 return _u32vector(vector)->writable_elements(len);
620 ////////////////////////////////////////////////////////////////////////////
622 ////////////////////////////////////////////////////////////////////////////
624 static pmt_s32vector *
627 return dynamic_cast<pmt_s32vector*>(x.get());
631 pmt_s32vector::pmt_s32vector(size_t k, int32_t fill)
634 for (size_t i = 0; i < k; i++)
638 pmt_s32vector::pmt_s32vector(size_t k, const int32_t *data)
641 for (size_t i = 0; i < k; i++)
646 pmt_s32vector::ref(size_t k) const
649 throw pmt_out_of_range("pmt_s32vector_ref", pmt_from_long(k));
654 pmt_s32vector::set(size_t k, int32_t x)
657 throw pmt_out_of_range("pmt_s32vector_set", pmt_from_long(k));
662 pmt_s32vector::elements(size_t &len)
669 pmt_s32vector::writable_elements(size_t &len)
676 pmt_s32vector::uniform_elements(size_t &len)
678 len = length() * sizeof(int32_t);
683 pmt_s32vector::uniform_writable_elements(size_t &len)
685 len = length() * sizeof(int32_t);
690 pmt_is_s32vector(pmt_t obj)
692 return obj->is_s32vector();
696 pmt_make_s32vector(size_t k, int32_t fill)
698 return pmt_t(new pmt_s32vector(k, fill));
702 pmt_init_s32vector(size_t k, const int32_t *data)
704 return pmt_t(new pmt_s32vector(k, data));
708 pmt_s32vector_ref(pmt_t vector, size_t k)
710 if (!vector->is_s32vector())
711 throw pmt_wrong_type("pmt_s32vector_ref", vector);
712 return _s32vector(vector)->ref(k);
716 pmt_s32vector_set(pmt_t vector, size_t k, int32_t obj)
718 if (!vector->is_s32vector())
719 throw pmt_wrong_type("pmt_s32vector_set", vector);
720 _s32vector(vector)->set(k, obj);
724 pmt_s32vector_elements(pmt_t vector, size_t &len)
726 if (!vector->is_s32vector())
727 throw pmt_wrong_type("pmt_s32vector_elements", vector);
728 return _s32vector(vector)->elements(len);
732 pmt_s32vector_writable_elements(pmt_t vector, size_t &len)
734 if (!vector->is_s32vector())
735 throw pmt_wrong_type("pmt_s32vector_writable_elements", vector);
736 return _s32vector(vector)->writable_elements(len);
738 ////////////////////////////////////////////////////////////////////////////
740 ////////////////////////////////////////////////////////////////////////////
742 static pmt_u64vector *
745 return dynamic_cast<pmt_u64vector*>(x.get());
749 pmt_u64vector::pmt_u64vector(size_t k, uint64_t fill)
752 for (size_t i = 0; i < k; i++)
756 pmt_u64vector::pmt_u64vector(size_t k, const uint64_t *data)
759 for (size_t i = 0; i < k; i++)
764 pmt_u64vector::ref(size_t k) const
767 throw pmt_out_of_range("pmt_u64vector_ref", pmt_from_long(k));
772 pmt_u64vector::set(size_t k, uint64_t x)
775 throw pmt_out_of_range("pmt_u64vector_set", pmt_from_long(k));
780 pmt_u64vector::elements(size_t &len)
787 pmt_u64vector::writable_elements(size_t &len)
794 pmt_u64vector::uniform_elements(size_t &len)
796 len = length() * sizeof(uint64_t);
801 pmt_u64vector::uniform_writable_elements(size_t &len)
803 len = length() * sizeof(uint64_t);
808 pmt_is_u64vector(pmt_t obj)
810 return obj->is_u64vector();
814 pmt_make_u64vector(size_t k, uint64_t fill)
816 return pmt_t(new pmt_u64vector(k, fill));
820 pmt_init_u64vector(size_t k, const uint64_t *data)
822 return pmt_t(new pmt_u64vector(k, data));
826 pmt_u64vector_ref(pmt_t vector, size_t k)
828 if (!vector->is_u64vector())
829 throw pmt_wrong_type("pmt_u64vector_ref", vector);
830 return _u64vector(vector)->ref(k);
834 pmt_u64vector_set(pmt_t vector, size_t k, uint64_t obj)
836 if (!vector->is_u64vector())
837 throw pmt_wrong_type("pmt_u64vector_set", vector);
838 _u64vector(vector)->set(k, obj);
842 pmt_u64vector_elements(pmt_t vector, size_t &len)
844 if (!vector->is_u64vector())
845 throw pmt_wrong_type("pmt_u64vector_elements", vector);
846 return _u64vector(vector)->elements(len);
850 pmt_u64vector_writable_elements(pmt_t vector, size_t &len)
852 if (!vector->is_u64vector())
853 throw pmt_wrong_type("pmt_u64vector_writable_elements", vector);
854 return _u64vector(vector)->writable_elements(len);
856 ////////////////////////////////////////////////////////////////////////////
858 ////////////////////////////////////////////////////////////////////////////
860 static pmt_s64vector *
863 return dynamic_cast<pmt_s64vector*>(x.get());
867 pmt_s64vector::pmt_s64vector(size_t k, int64_t fill)
870 for (size_t i = 0; i < k; i++)
874 pmt_s64vector::pmt_s64vector(size_t k, const int64_t *data)
877 for (size_t i = 0; i < k; i++)
882 pmt_s64vector::ref(size_t k) const
885 throw pmt_out_of_range("pmt_s64vector_ref", pmt_from_long(k));
890 pmt_s64vector::set(size_t k, int64_t x)
893 throw pmt_out_of_range("pmt_s64vector_set", pmt_from_long(k));
898 pmt_s64vector::elements(size_t &len)
905 pmt_s64vector::writable_elements(size_t &len)
912 pmt_s64vector::uniform_elements(size_t &len)
914 len = length() * sizeof(int64_t);
919 pmt_s64vector::uniform_writable_elements(size_t &len)
921 len = length() * sizeof(int64_t);
926 pmt_is_s64vector(pmt_t obj)
928 return obj->is_s64vector();
932 pmt_make_s64vector(size_t k, int64_t fill)
934 return pmt_t(new pmt_s64vector(k, fill));
938 pmt_init_s64vector(size_t k, const int64_t *data)
940 return pmt_t(new pmt_s64vector(k, data));
944 pmt_s64vector_ref(pmt_t vector, size_t k)
946 if (!vector->is_s64vector())
947 throw pmt_wrong_type("pmt_s64vector_ref", vector);
948 return _s64vector(vector)->ref(k);
952 pmt_s64vector_set(pmt_t vector, size_t k, int64_t obj)
954 if (!vector->is_s64vector())
955 throw pmt_wrong_type("pmt_s64vector_set", vector);
956 _s64vector(vector)->set(k, obj);
960 pmt_s64vector_elements(pmt_t vector, size_t &len)
962 if (!vector->is_s64vector())
963 throw pmt_wrong_type("pmt_s64vector_elements", vector);
964 return _s64vector(vector)->elements(len);
968 pmt_s64vector_writable_elements(pmt_t vector, size_t &len)
970 if (!vector->is_s64vector())
971 throw pmt_wrong_type("pmt_s64vector_writable_elements", vector);
972 return _s64vector(vector)->writable_elements(len);
974 ////////////////////////////////////////////////////////////////////////////
976 ////////////////////////////////////////////////////////////////////////////
978 static pmt_f32vector *
981 return dynamic_cast<pmt_f32vector*>(x.get());
985 pmt_f32vector::pmt_f32vector(size_t k, float fill)
988 for (size_t i = 0; i < k; i++)
992 pmt_f32vector::pmt_f32vector(size_t k, const float *data)
995 for (size_t i = 0; i < k; i++)
1000 pmt_f32vector::ref(size_t k) const
1003 throw pmt_out_of_range("pmt_f32vector_ref", pmt_from_long(k));
1008 pmt_f32vector::set(size_t k, float x)
1011 throw pmt_out_of_range("pmt_f32vector_set", pmt_from_long(k));
1016 pmt_f32vector::elements(size_t &len)
1023 pmt_f32vector::writable_elements(size_t &len)
1030 pmt_f32vector::uniform_elements(size_t &len)
1032 len = length() * sizeof(float);
1037 pmt_f32vector::uniform_writable_elements(size_t &len)
1039 len = length() * sizeof(float);
1044 pmt_is_f32vector(pmt_t obj)
1046 return obj->is_f32vector();
1050 pmt_make_f32vector(size_t k, float fill)
1052 return pmt_t(new pmt_f32vector(k, fill));
1056 pmt_init_f32vector(size_t k, const float *data)
1058 return pmt_t(new pmt_f32vector(k, data));
1062 pmt_f32vector_ref(pmt_t vector, size_t k)
1064 if (!vector->is_f32vector())
1065 throw pmt_wrong_type("pmt_f32vector_ref", vector);
1066 return _f32vector(vector)->ref(k);
1070 pmt_f32vector_set(pmt_t vector, size_t k, float obj)
1072 if (!vector->is_f32vector())
1073 throw pmt_wrong_type("pmt_f32vector_set", vector);
1074 _f32vector(vector)->set(k, obj);
1078 pmt_f32vector_elements(pmt_t vector, size_t &len)
1080 if (!vector->is_f32vector())
1081 throw pmt_wrong_type("pmt_f32vector_elements", vector);
1082 return _f32vector(vector)->elements(len);
1086 pmt_f32vector_writable_elements(pmt_t vector, size_t &len)
1088 if (!vector->is_f32vector())
1089 throw pmt_wrong_type("pmt_f32vector_writable_elements", vector);
1090 return _f32vector(vector)->writable_elements(len);
1092 ////////////////////////////////////////////////////////////////////////////
1094 ////////////////////////////////////////////////////////////////////////////
1096 static pmt_f64vector *
1099 return dynamic_cast<pmt_f64vector*>(x.get());
1103 pmt_f64vector::pmt_f64vector(size_t k, double fill)
1106 for (size_t i = 0; i < k; i++)
1110 pmt_f64vector::pmt_f64vector(size_t k, const double *data)
1113 for (size_t i = 0; i < k; i++)
1118 pmt_f64vector::ref(size_t k) const
1121 throw pmt_out_of_range("pmt_f64vector_ref", pmt_from_long(k));
1126 pmt_f64vector::set(size_t k, double x)
1129 throw pmt_out_of_range("pmt_f64vector_set", pmt_from_long(k));
1134 pmt_f64vector::elements(size_t &len)
1141 pmt_f64vector::writable_elements(size_t &len)
1148 pmt_f64vector::uniform_elements(size_t &len)
1150 len = length() * sizeof(double);
1155 pmt_f64vector::uniform_writable_elements(size_t &len)
1157 len = length() * sizeof(double);
1162 pmt_is_f64vector(pmt_t obj)
1164 return obj->is_f64vector();
1168 pmt_make_f64vector(size_t k, double fill)
1170 return pmt_t(new pmt_f64vector(k, fill));
1174 pmt_init_f64vector(size_t k, const double *data)
1176 return pmt_t(new pmt_f64vector(k, data));
1180 pmt_f64vector_ref(pmt_t vector, size_t k)
1182 if (!vector->is_f64vector())
1183 throw pmt_wrong_type("pmt_f64vector_ref", vector);
1184 return _f64vector(vector)->ref(k);
1188 pmt_f64vector_set(pmt_t vector, size_t k, double obj)
1190 if (!vector->is_f64vector())
1191 throw pmt_wrong_type("pmt_f64vector_set", vector);
1192 _f64vector(vector)->set(k, obj);
1196 pmt_f64vector_elements(pmt_t vector, size_t &len)
1198 if (!vector->is_f64vector())
1199 throw pmt_wrong_type("pmt_f64vector_elements", vector);
1200 return _f64vector(vector)->elements(len);
1204 pmt_f64vector_writable_elements(pmt_t vector, size_t &len)
1206 if (!vector->is_f64vector())
1207 throw pmt_wrong_type("pmt_f64vector_writable_elements", vector);
1208 return _f64vector(vector)->writable_elements(len);
1210 ////////////////////////////////////////////////////////////////////////////
1212 ////////////////////////////////////////////////////////////////////////////
1214 static pmt_c32vector *
1217 return dynamic_cast<pmt_c32vector*>(x.get());
1221 pmt_c32vector::pmt_c32vector(size_t k, std::complex<float> fill)
1224 for (size_t i = 0; i < k; i++)
1228 pmt_c32vector::pmt_c32vector(size_t k, const std::complex<float> *data)
1231 for (size_t i = 0; i < k; i++)
1236 pmt_c32vector::ref(size_t k) const
1239 throw pmt_out_of_range("pmt_c32vector_ref", pmt_from_long(k));
1244 pmt_c32vector::set(size_t k, std::complex<float> x)
1247 throw pmt_out_of_range("pmt_c32vector_set", pmt_from_long(k));
1251 const std::complex<float> *
1252 pmt_c32vector::elements(size_t &len)
1258 std::complex<float> *
1259 pmt_c32vector::writable_elements(size_t &len)
1266 pmt_c32vector::uniform_elements(size_t &len)
1268 len = length() * sizeof(std::complex<float>);
1273 pmt_c32vector::uniform_writable_elements(size_t &len)
1275 len = length() * sizeof(std::complex<float>);
1280 pmt_is_c32vector(pmt_t obj)
1282 return obj->is_c32vector();
1286 pmt_make_c32vector(size_t k, std::complex<float> fill)
1288 return pmt_t(new pmt_c32vector(k, fill));
1292 pmt_init_c32vector(size_t k, const std::complex<float> *data)
1294 return pmt_t(new pmt_c32vector(k, data));
1298 pmt_c32vector_ref(pmt_t vector, size_t k)
1300 if (!vector->is_c32vector())
1301 throw pmt_wrong_type("pmt_c32vector_ref", vector);
1302 return _c32vector(vector)->ref(k);
1306 pmt_c32vector_set(pmt_t vector, size_t k, std::complex<float> obj)
1308 if (!vector->is_c32vector())
1309 throw pmt_wrong_type("pmt_c32vector_set", vector);
1310 _c32vector(vector)->set(k, obj);
1313 const std::complex<float> *
1314 pmt_c32vector_elements(pmt_t vector, size_t &len)
1316 if (!vector->is_c32vector())
1317 throw pmt_wrong_type("pmt_c32vector_elements", vector);
1318 return _c32vector(vector)->elements(len);
1321 std::complex<float> *
1322 pmt_c32vector_writable_elements(pmt_t vector, size_t &len)
1324 if (!vector->is_c32vector())
1325 throw pmt_wrong_type("pmt_c32vector_writable_elements", vector);
1326 return _c32vector(vector)->writable_elements(len);
1328 ////////////////////////////////////////////////////////////////////////////
1330 ////////////////////////////////////////////////////////////////////////////
1332 static pmt_c64vector *
1335 return dynamic_cast<pmt_c64vector*>(x.get());
1339 pmt_c64vector::pmt_c64vector(size_t k, std::complex<double> fill)
1342 for (size_t i = 0; i < k; i++)
1346 pmt_c64vector::pmt_c64vector(size_t k, const std::complex<double> *data)
1349 for (size_t i = 0; i < k; i++)
1353 std::complex<double>
1354 pmt_c64vector::ref(size_t k) const
1357 throw pmt_out_of_range("pmt_c64vector_ref", pmt_from_long(k));
1362 pmt_c64vector::set(size_t k, std::complex<double> x)
1365 throw pmt_out_of_range("pmt_c64vector_set", pmt_from_long(k));
1369 const std::complex<double> *
1370 pmt_c64vector::elements(size_t &len)
1376 std::complex<double> *
1377 pmt_c64vector::writable_elements(size_t &len)
1384 pmt_c64vector::uniform_elements(size_t &len)
1386 len = length() * sizeof(std::complex<double>);
1391 pmt_c64vector::uniform_writable_elements(size_t &len)
1393 len = length() * sizeof(std::complex<double>);
1398 pmt_is_c64vector(pmt_t obj)
1400 return obj->is_c64vector();
1404 pmt_make_c64vector(size_t k, std::complex<double> fill)
1406 return pmt_t(new pmt_c64vector(k, fill));
1410 pmt_init_c64vector(size_t k, const std::complex<double> *data)
1412 return pmt_t(new pmt_c64vector(k, data));
1415 std::complex<double>
1416 pmt_c64vector_ref(pmt_t vector, size_t k)
1418 if (!vector->is_c64vector())
1419 throw pmt_wrong_type("pmt_c64vector_ref", vector);
1420 return _c64vector(vector)->ref(k);
1424 pmt_c64vector_set(pmt_t vector, size_t k, std::complex<double> obj)
1426 if (!vector->is_c64vector())
1427 throw pmt_wrong_type("pmt_c64vector_set", vector);
1428 _c64vector(vector)->set(k, obj);
1431 const std::complex<double> *
1432 pmt_c64vector_elements(pmt_t vector, size_t &len)
1434 if (!vector->is_c64vector())
1435 throw pmt_wrong_type("pmt_c64vector_elements", vector);
1436 return _c64vector(vector)->elements(len);
1439 std::complex<double> *
1440 pmt_c64vector_writable_elements(pmt_t vector, size_t &len)
1442 if (!vector->is_c64vector())
1443 throw pmt_wrong_type("pmt_c64vector_writable_elements", vector);
1444 return _c64vector(vector)->writable_elements(len);