[Commit-gnuradio] [gnuradio] 08/28: basic: working add/mult const blocks, block magic2 for static make

[git]

This is an automated email from the git hooks/post-receive script.

nwest pushed a commit to annotated tag gr_basic_work
in repository gnuradio.

commit de6be4f1b15c7a399446c5582d0b0f3b786312cc
Author: Josh Blum <address@hidden>
Date:   Wed Nov 9 10:48:09 2011 -0800

    basic: working add/mult const blocks, block magic2 for static make
---
 gnuradio-core/src/lib/swig/gnuradio.i            |  1 +
 gnuradio-core/src/lib/swig/gr_swig_block_magic.i | 26 ++++++++++++
 gr-basic/include/gr_basic_add.h                  |  9 ++--
 gr-basic/include/gr_basic_add_const.h            | 32 ++++++++-------
 gr-basic/include/gr_basic_divide.h               | 10 ++---
 gr-basic/include/gr_basic_multiply.h             | 10 ++---
 gr-basic/include/gr_basic_multiply_const.h       | 32 ++++++++-------
 gr-basic/include/gr_basic_subtract.h             | 10 ++---
 gr-basic/lib/gr_basic_add.cc                     | 32 +++++++--------
 gr-basic/lib/gr_basic_add_const.cc               | 51 ++++++++++++++---------
 gr-basic/lib/gr_basic_divide.cc                  | 30 +++++++-------
 gr-basic/lib/gr_basic_multiply.cc                | 34 ++++++++--------
 gr-basic/lib/gr_basic_multiply_const.cc          | 52 +++++++++++++++---------
 gr-basic/lib/gr_basic_subtract.cc                | 30 +++++++-------
 gr-basic/swig/basic_ops.i                        | 36 ++++++++--------
 15 files changed, 219 insertions(+), 176 deletions(-)

diff --git a/gnuradio-core/src/lib/swig/gnuradio.i 
b/gnuradio-core/src/lib/swig/gnuradio.i
index e365aea..b2fb46a 100644
--- a/gnuradio-core/src/lib/swig/gnuradio.i
+++ b/gnuradio-core/src/lib/swig/gnuradio.i
@@ -96,6 +96,7 @@ namespace std {
   %template()    vector<int>;
   %template()    vector<float>;
   %template()    vector<double>;
+  %template()    vector<std::complex<double> >;
   // %template()         std::complex<float>;
 
   %template()    vector< std::complex<float> >;
diff --git a/gnuradio-core/src/lib/swig/gr_swig_block_magic.i 
b/gnuradio-core/src/lib/swig/gr_swig_block_magic.i
index a080c2b..7eae9c1 100644
--- a/gnuradio-core/src/lib/swig/gr_swig_block_magic.i
+++ b/gnuradio-core/src/lib/swig/gr_swig_block_magic.i
@@ -20,6 +20,32 @@
  * Boston, MA 02110-1301, USA.
  */
 
+//----------------------------------------------------------------------
+//-- GR_SWIG_BLOCK_MAGIC2
+//----------------------------------------------------------------------
+%define GR_SWIG_BLOCK_MAGIC2(PKG, BASE_NAME)
+_GR_SWIG_BLOCK_MAGIC2_HELPER(PKG, BASE_NAME, PKG ## _ ## BASE_NAME)
+%enddef
+
+#ifdef SWIGPYTHON
+%define _GR_SWIG_BLOCK_MAGIC2_HELPER(PKG, BASE_NAME, FULL_NAME)
+%template(FULL_NAME ## _sptr) boost::shared_ptr<FULL_NAME>;
+%pythoncode %{
+FULL_NAME ## _sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % 
(self.name(), self.unique_id ())
+BASE_NAME = FULL_NAME.make
+%}
+%enddef
+#endif
+
+//ignore base classes commonly inherited by gr blocks
+%ignore gr_sync_block;
+%ignore gr_sync_decimator;
+%ignore gr_sync_interpolator;
+%ignore gr_hier_block2;
+
+//----------------------------------------------------------------------
+//-- GR_SWIG_BLOCK_MAGIC
+//----------------------------------------------------------------------
 %define GR_SWIG_BLOCK_MAGIC(PKG, BASE_NAME)
 _GR_SWIG_BLOCK_MAGIC_HELPER(PKG, BASE_NAME, PKG ## _ ## BASE_NAME)
 %enddef
diff --git a/gr-basic/include/gr_basic_add.h b/gr-basic/include/gr_basic_add.h
index f9007ff..f9d83a1 100644
--- a/gr-basic/include/gr_basic_add.h
+++ b/gr-basic/include/gr_basic_add.h
@@ -25,13 +25,10 @@
 #include <gr_sync_block.h>
 #include <gr_basic_op_types.h>
 
-class GR_BASIC_API basic_add : virtual public gr_sync_block{
+class GR_BASIC_API gr_basic_add : virtual public gr_sync_block{
 public:
-    typedef boost::shared_ptr<basic_add> sptr;
+    typedef boost::shared_ptr<gr_basic_add> sptr;
+    static sptr make(op_type type, const size_t vlen = 1);
 };
 
-GR_BASIC_API basic_add::sptr basic_make_add(
-    op_type type, const size_t vlen = 1
-);
-
 #endif /* INCLUDED_GR_BASIC_ADD_H */
diff --git a/gr-basic/include/gr_basic_add_const.h 
b/gr-basic/include/gr_basic_add_const.h
index 0cd0263..1de3503 100644
--- a/gr-basic/include/gr_basic_add_const.h
+++ b/gr-basic/include/gr_basic_add_const.h
@@ -26,25 +26,29 @@
 #include <gr_basic_op_types.h>
 #include <complex>
 
-class GR_BASIC_API basic_add_const : virtual public gr_sync_block{
+class GR_BASIC_API gr_basic_add_const : virtual public gr_sync_block{
 public:
-    typedef boost::shared_ptr<basic_add_const> sptr;
+    typedef boost::shared_ptr<gr_basic_add_const> sptr;
 
-    /*!
-     * Set the value to be added.
-     * This is a double vector to cover all possible types.
-     */
-    virtual void set_value(const std::vector<double> &val) = 0;
+    static sptr make(op_type type, const size_t vlen = 1);
 
-    //! Convenience operator to set when vlen == 1
-    void set_value(const double val){
-        return this->set_value(std::vector<double>(1, val));
+    //! Set the value from any vector type
+    template <typename type> void set_value(const std::vector<type> &val){
+        std::vector<std::complex<double> > new_val;
+        for (size_t i = 0; i < val.size(); i++){
+            new_val.push_back(std::complex<double>(val[i]));
+        }
+        return this->_set_value(new_val);
     }
 
-};
+    //! Set the value when vlen == 1
+    template <typename type> void set_value(const type &val){
+        return this->set_value(std::vector<type>(1, val));
+    }
 
-GR_BASIC_API basic_add_const::sptr basic_make_add_const(
-    op_type type, const size_t vlen = 1
-);
+private:
+    virtual void _set_value(const std::vector<std::complex<double> > &val) = 0;
+
+};
 
 #endif /* INCLUDED_GR_BASIC_ADD_CONST_H */
diff --git a/gr-basic/include/gr_basic_divide.h 
b/gr-basic/include/gr_basic_divide.h
index 100271a..42ef98d 100644
--- a/gr-basic/include/gr_basic_divide.h
+++ b/gr-basic/include/gr_basic_divide.h
@@ -25,13 +25,11 @@
 #include <gr_sync_block.h>
 #include <gr_basic_op_types.h>
 
-class GR_BASIC_API basic_divide : virtual public gr_sync_block{
+class GR_BASIC_API gr_basic_divide : virtual public gr_sync_block{
 public:
-    typedef boost::shared_ptr<basic_divide> sptr;
-};
+    typedef boost::shared_ptr<gr_basic_divide> sptr;
 
-GR_BASIC_API basic_divide::sptr basic_make_divide(
-    op_type type, const size_t vlen = 1
-);
+    static sptr make(op_type type, const size_t vlen = 1);
+};
 
 #endif /* INCLUDED_GR_BASIC_DIVIDE_H */
diff --git a/gr-basic/include/gr_basic_multiply.h 
b/gr-basic/include/gr_basic_multiply.h
index ceb0e80..04fbaae 100644
--- a/gr-basic/include/gr_basic_multiply.h
+++ b/gr-basic/include/gr_basic_multiply.h
@@ -25,13 +25,11 @@
 #include <gr_sync_block.h>
 #include <gr_basic_op_types.h>
 
-class GR_BASIC_API basic_multiply : virtual public gr_sync_block{
+class GR_BASIC_API gr_basic_multiply : virtual public gr_sync_block{
 public:
-    typedef boost::shared_ptr<basic_multiply> sptr;
-};
+    typedef boost::shared_ptr<gr_basic_multiply> sptr;
 
-GR_BASIC_API basic_multiply::sptr basic_make_multiply(
-    op_type type, const size_t vlen = 1
-);
+    static sptr make(op_type type, const size_t vlen = 1);
+};
 
 #endif /* INCLUDED_GR_BASIC_MULTIPLY_H */
diff --git a/gr-basic/include/gr_basic_multiply_const.h 
b/gr-basic/include/gr_basic_multiply_const.h
index 10fe6f2..92f5340 100644
--- a/gr-basic/include/gr_basic_multiply_const.h
+++ b/gr-basic/include/gr_basic_multiply_const.h
@@ -26,25 +26,29 @@
 #include <gr_basic_op_types.h>
 #include <complex>
 
-class GR_BASIC_API basic_multiply_const : virtual public gr_sync_block{
+class GR_BASIC_API gr_basic_multiply_const : virtual public gr_sync_block{
 public:
-    typedef boost::shared_ptr<basic_multiply_const> sptr;
+    typedef boost::shared_ptr<gr_basic_multiply_const> sptr;
 
-    /*!
-     * Set the value to be multiplied.
-     * This is a double vector to cover all possible types.
-     */
-    virtual void set_value(const std::vector<double> &val) = 0;
+    static sptr make(op_type type, const size_t vlen = 1);
 
-    //! Convenience operator to set when vlen == 1
-    void set_value(const double val){
-        return this->set_value(std::vector<double>(1, val));
+    //! Set the value from any vector type
+    template <typename type> void set_value(const std::vector<type> &val){
+        std::vector<std::complex<double> > new_val;
+        for (size_t i = 0; i < val.size(); i++){
+            new_val.push_back(std::complex<double>(val[i]));
+        }
+        return this->_set_value(new_val);
     }
 
-};
+    //! Set the value when vlen == 1
+    template <typename type> void set_value(const type &val){
+        return this->set_value(std::vector<type>(1, val));
+    }
 
-GR_BASIC_API basic_multiply_const::sptr basic_make_multiply_const(
-    op_type type, const size_t vlen = 1
-);
+private:
+    virtual void _set_value(const std::vector<std::complex<double> > &val) = 0;
+
+};
 
 #endif /* INCLUDED_GR_BASIC_MULTIPLY_CONST_H */
diff --git a/gr-basic/include/gr_basic_subtract.h 
b/gr-basic/include/gr_basic_subtract.h
index a4ef405..cbfbd53 100644
--- a/gr-basic/include/gr_basic_subtract.h
+++ b/gr-basic/include/gr_basic_subtract.h
@@ -25,13 +25,11 @@
 #include <gr_sync_block.h>
 #include <gr_basic_op_types.h>
 
-class GR_BASIC_API basic_subtract : virtual public gr_sync_block{
+class GR_BASIC_API gr_basic_subtract : virtual public gr_sync_block{
 public:
-    typedef boost::shared_ptr<basic_subtract> sptr;
-};
+    typedef boost::shared_ptr<gr_basic_subtract> sptr;
 
-GR_BASIC_API basic_subtract::sptr basic_make_subtract(
-    op_type type, const size_t vlen = 1
-);
+    static sptr make(op_type type, const size_t vlen = 1);
+};
 
 #endif /* INCLUDED_GR_BASIC_SUBTRACT_H */
diff --git a/gr-basic/lib/gr_basic_add.cc b/gr-basic/lib/gr_basic_add.cc
index 5adb2d2..9451999 100644
--- a/gr-basic/lib/gr_basic_add.cc
+++ b/gr-basic/lib/gr_basic_add.cc
@@ -28,7 +28,7 @@
 /***********************************************************************
  * Adder implementation with float32 - calls volk
  **********************************************************************/
-class gr_basic_add_f32 : public basic_add{
+class gr_basic_add_f32 : public gr_basic_add{
 public:
     gr_basic_add_f32(const size_t vlen):
         gr_sync_block(
@@ -68,7 +68,7 @@ private:
  * Generic adder implementation
  **********************************************************************/
 template <typename type>
-class gr_basic_add_generic : public basic_add{
+class gr_basic_add_generic : public gr_basic_add{
 public:
     gr_basic_add_generic(const size_t vlen):
         gr_sync_block(
@@ -108,27 +108,25 @@ private:
 /***********************************************************************
  * Adder factory function
  **********************************************************************/
-basic_add::sptr basic_make_add(
-    op_type type, const size_t vlen
-){
+gr_basic_add::sptr gr_basic_add::make(op_type type, const size_t vlen){
     switch(type){
-    case OP_FC64: return basic_add::sptr(new 
gr_basic_add_generic<double>(2*vlen));
-    case OP_F64: return basic_add::sptr(new 
gr_basic_add_generic<double>(vlen));
+    case OP_FC64: return sptr(new gr_basic_add_generic<double>(2*vlen));
+    case OP_F64: return sptr(new gr_basic_add_generic<double>(vlen));
 
-    case OP_FC32: return basic_add::sptr(new gr_basic_add_f32(2*vlen));
-    case OP_F32: return basic_add::sptr(new gr_basic_add_f32(vlen));
+    case OP_FC32: return sptr(new gr_basic_add_f32(2*vlen));
+    case OP_F32: return sptr(new gr_basic_add_f32(vlen));
 
-    case OP_SC64: return basic_add::sptr(new 
gr_basic_add_generic<int64_t>(2*vlen));
-    case OP_S64: return basic_add::sptr(new 
gr_basic_add_generic<int64_t>(vlen));
+    case OP_SC64: return sptr(new gr_basic_add_generic<int64_t>(2*vlen));
+    case OP_S64: return sptr(new gr_basic_add_generic<int64_t>(vlen));
 
-    case OP_SC32: return basic_add::sptr(new 
gr_basic_add_generic<int32_t>(2*vlen));
-    case OP_S32: return basic_add::sptr(new 
gr_basic_add_generic<int32_t>(vlen));
+    case OP_SC32: return sptr(new gr_basic_add_generic<int32_t>(2*vlen));
+    case OP_S32: return sptr(new gr_basic_add_generic<int32_t>(vlen));
 
-    case OP_SC16: return basic_add::sptr(new 
gr_basic_add_generic<int16_t>(2*vlen));
-    case OP_S16: return basic_add::sptr(new 
gr_basic_add_generic<int16_t>(vlen));
+    case OP_SC16: return sptr(new gr_basic_add_generic<int16_t>(2*vlen));
+    case OP_S16: return sptr(new gr_basic_add_generic<int16_t>(vlen));
 
-    case OP_SC8: return basic_add::sptr(new 
gr_basic_add_generic<int8_t>(2*vlen));
-    case OP_S8: return basic_add::sptr(new gr_basic_add_generic<int8_t>(vlen));
+    case OP_SC8: return sptr(new gr_basic_add_generic<int8_t>(2*vlen));
+    case OP_S8: return sptr(new gr_basic_add_generic<int8_t>(vlen));
 
     default: throw std::invalid_argument("basic_make_add got unknown add 
type");
     }
diff --git a/gr-basic/lib/gr_basic_add_const.cc 
b/gr-basic/lib/gr_basic_add_const.cc
index 05e4f0f..69729ce 100644
--- a/gr-basic/lib/gr_basic_add_const.cc
+++ b/gr-basic/lib/gr_basic_add_const.cc
@@ -26,10 +26,21 @@
 #include <volk/volk.h>
 
 /***********************************************************************
+ * Helper routines for conversion
+ **********************************************************************/
+template <typename type> void conv(const std::complex<double> &in, 
std::complex<type> &out){
+    out = std::complex<type>(in);
+}
+
+template <typename type> void conv(const std::complex<double> &in, type &out){
+    out = type(in.real());
+}
+
+/***********************************************************************
  * Generic add const implementation
  **********************************************************************/
 template <typename type>
-class gr_basic_add_const_generic : public basic_add_const{
+class gr_basic_add_const_generic : public gr_basic_add_const{
 public:
     gr_basic_add_const_generic(const size_t vlen):
         gr_sync_block(
@@ -39,7 +50,7 @@ public:
         ),
         _vlen(vlen)
     {
-        //NOP
+        _val.resize(_vlen);
     }
 
     int work(
@@ -68,10 +79,12 @@ public:
         return noutput_items;
     }
 
-    void set_value(const std::vector<double> &val){
-        _val.resize(val.size());
+    void _set_value(const std::vector<std::complex<double> > &val){
+        if (val.size() != _vlen){
+            throw std::invalid_argument("set_value called with the wrong 
length");
+        }
         for (size_t i = 0; i < val.size(); i++){
-            _val[i] = type(val[i]);
+            conv(val[i], _val[i]);
         }
     }
 
@@ -83,27 +96,25 @@ private:
 /***********************************************************************
  * Adder factory function
  **********************************************************************/
-basic_add_const::sptr basic_make_add_const(
-    op_type type, const size_t vlen
-){
+gr_basic_add_const::sptr gr_basic_add_const::make(op_type type, const size_t 
vlen){
     switch(type){
-    case OP_FC64: return basic_add_const::sptr(new 
gr_basic_add_const_generic<double>(2*vlen));
-    case OP_F64: return basic_add_const::sptr(new 
gr_basic_add_const_generic<double>(vlen));
+    case OP_FC64: return sptr(new 
gr_basic_add_const_generic<std::complex<double> >(vlen));
+    case OP_F64: return sptr(new gr_basic_add_const_generic<double>(vlen));
 
-    case OP_FC32: return basic_add_const::sptr(new 
gr_basic_add_const_generic<float>(2*vlen));
-    case OP_F32: return basic_add_const::sptr(new 
gr_basic_add_const_generic<float>(vlen));
+    case OP_FC32: return sptr(new 
gr_basic_add_const_generic<std::complex<float> >(vlen));
+    case OP_F32: return sptr(new gr_basic_add_const_generic<float>(vlen));
 
-    case OP_SC64: return basic_add_const::sptr(new 
gr_basic_add_const_generic<int64_t>(2*vlen));
-    case OP_S64: return basic_add_const::sptr(new 
gr_basic_add_const_generic<int64_t>(vlen));
+    case OP_SC64: return sptr(new 
gr_basic_add_const_generic<std::complex<int64_t> >(vlen));
+    case OP_S64: return sptr(new gr_basic_add_const_generic<int64_t>(vlen));
 
-    case OP_SC32: return basic_add_const::sptr(new 
gr_basic_add_const_generic<int32_t>(2*vlen));
-    case OP_S32: return basic_add_const::sptr(new 
gr_basic_add_const_generic<int32_t>(vlen));
+    case OP_SC32: return sptr(new 
gr_basic_add_const_generic<std::complex<int32_t> >(vlen));
+    case OP_S32: return sptr(new gr_basic_add_const_generic<int32_t>(vlen));
 
-    case OP_SC16: return basic_add_const::sptr(new 
gr_basic_add_const_generic<int16_t>(2*vlen));
-    case OP_S16: return basic_add_const::sptr(new 
gr_basic_add_const_generic<int16_t>(vlen));
+    case OP_SC16: return sptr(new 
gr_basic_add_const_generic<std::complex<int16_t> >(vlen));
+    case OP_S16: return sptr(new gr_basic_add_const_generic<int16_t>(vlen));
 
-    case OP_SC8: return basic_add_const::sptr(new 
gr_basic_add_const_generic<int8_t>(2*vlen));
-    case OP_S8: return basic_add_const::sptr(new 
gr_basic_add_const_generic<int8_t>(vlen));
+    case OP_SC8: return sptr(new 
gr_basic_add_const_generic<std::complex<int8_t> >(vlen));
+    case OP_S8: return sptr(new gr_basic_add_const_generic<int8_t>(vlen));
 
     default: throw std::invalid_argument("basic_make_add got unknown add 
type");
     }
diff --git a/gr-basic/lib/gr_basic_divide.cc b/gr-basic/lib/gr_basic_divide.cc
index a1cde8d..d59795a 100644
--- a/gr-basic/lib/gr_basic_divide.cc
+++ b/gr-basic/lib/gr_basic_divide.cc
@@ -29,7 +29,7 @@
  * Generic divideer implementation
  **********************************************************************/
 template <typename type>
-class gr_basic_divide_generic : public basic_divide{
+class gr_basic_divide_generic : public gr_basic_divide{
 public:
     gr_basic_divide_generic(const size_t vlen):
         gr_sync_block(
@@ -69,27 +69,25 @@ private:
 /***********************************************************************
  * Adder factory function
  **********************************************************************/
-basic_divide::sptr basic_make_divide(
-    op_type type, const size_t vlen
-){
+gr_basic_divide::sptr gr_basic_divide::make(op_type type, const size_t vlen){
     switch(type){
-    case OP_FC64: return basic_divide::sptr(new 
gr_basic_divide_generic<std::complex<double> >(vlen));
-    case OP_F64: return basic_divide::sptr(new 
gr_basic_divide_generic<double>(vlen));
+    case OP_FC64: return sptr(new gr_basic_divide_generic<std::complex<double> 
>(vlen));
+    case OP_F64: return sptr(new gr_basic_divide_generic<double>(vlen));
 
-    case OP_FC32: return basic_divide::sptr(new 
gr_basic_divide_generic<std::complex<float> >(vlen));
-    case OP_F32: return basic_divide::sptr(new 
gr_basic_divide_generic<float>(vlen));
+    case OP_FC32: return sptr(new gr_basic_divide_generic<std::complex<float> 
>(vlen));
+    case OP_F32: return sptr(new gr_basic_divide_generic<float>(vlen));
 
-    case OP_SC64: return basic_divide::sptr(new 
gr_basic_divide_generic<std::complex<int64_t> >(vlen));
-    case OP_S64: return basic_divide::sptr(new 
gr_basic_divide_generic<int64_t>(vlen));
+    case OP_SC64: return sptr(new 
gr_basic_divide_generic<std::complex<int64_t> >(vlen));
+    case OP_S64: return sptr(new gr_basic_divide_generic<int64_t>(vlen));
 
-    case OP_SC32: return basic_divide::sptr(new 
gr_basic_divide_generic<std::complex<int32_t> >(vlen));
-    case OP_S32: return basic_divide::sptr(new 
gr_basic_divide_generic<int32_t>(vlen));
+    case OP_SC32: return sptr(new 
gr_basic_divide_generic<std::complex<int32_t> >(vlen));
+    case OP_S32: return sptr(new gr_basic_divide_generic<int32_t>(vlen));
 
-    case OP_SC16: return basic_divide::sptr(new 
gr_basic_divide_generic<std::complex<int16_t> >(vlen));
-    case OP_S16: return basic_divide::sptr(new 
gr_basic_divide_generic<int16_t>(vlen));
+    case OP_SC16: return sptr(new 
gr_basic_divide_generic<std::complex<int16_t> >(vlen));
+    case OP_S16: return sptr(new gr_basic_divide_generic<int16_t>(vlen));
 
-    case OP_SC8: return basic_divide::sptr(new 
gr_basic_divide_generic<std::complex<int8_t> >(vlen));
-    case OP_S8: return basic_divide::sptr(new 
gr_basic_divide_generic<int8_t>(vlen));
+    case OP_SC8: return sptr(new gr_basic_divide_generic<std::complex<int8_t> 
>(vlen));
+    case OP_S8: return sptr(new gr_basic_divide_generic<int8_t>(vlen));
 
     default: throw std::invalid_argument("basic_make_divide got unknown divide 
type");
     }
diff --git a/gr-basic/lib/gr_basic_multiply.cc 
b/gr-basic/lib/gr_basic_multiply.cc
index d6033a7..185d3cb 100644
--- a/gr-basic/lib/gr_basic_multiply.cc
+++ b/gr-basic/lib/gr_basic_multiply.cc
@@ -28,7 +28,7 @@
 /***********************************************************************
  * Multiplier implementation with complex float32 - calls volk
  **********************************************************************/
-class gr_basic_multiply_fc32 : public basic_multiply{
+class gr_basic_multiply_fc32 : public gr_basic_multiply{
 public:
     gr_basic_multiply_fc32(const size_t vlen):
         gr_sync_block(
@@ -67,7 +67,7 @@ private:
 /***********************************************************************
  * Multiplier implementation with float32 - calls volk
  **********************************************************************/
-class gr_basic_multiply_f32 : public basic_multiply{
+class gr_basic_multiply_f32 : public gr_basic_multiply{
 public:
     gr_basic_multiply_f32(const size_t vlen):
         gr_sync_block(
@@ -107,7 +107,7 @@ private:
  * Generic multiplyer implementation
  **********************************************************************/
 template <typename type>
-class gr_basic_multiply_generic : public basic_multiply{
+class gr_basic_multiply_generic : public gr_basic_multiply{
 public:
     gr_basic_multiply_generic(const size_t vlen):
         gr_sync_block(
@@ -147,27 +147,25 @@ private:
 /***********************************************************************
  * Adder factory function
  **********************************************************************/
-basic_multiply::sptr basic_make_multiply(
-    op_type type, const size_t vlen
-){
+gr_basic_multiply::sptr gr_basic_multiply::make(op_type type, const size_t 
vlen){
     switch(type){
-    case OP_FC64: return basic_multiply::sptr(new 
gr_basic_multiply_generic<std::complex<double> >(vlen));
-    case OP_F64: return basic_multiply::sptr(new 
gr_basic_multiply_generic<double>(vlen));
+    case OP_FC64: return sptr(new 
gr_basic_multiply_generic<std::complex<double> >(vlen));
+    case OP_F64: return sptr(new gr_basic_multiply_generic<double>(vlen));
 
-    case OP_FC32: return basic_multiply::sptr(new 
gr_basic_multiply_fc32(vlen));
-    case OP_F32: return basic_multiply::sptr(new gr_basic_multiply_f32(vlen));
+    case OP_FC32: return sptr(new gr_basic_multiply_fc32(vlen));
+    case OP_F32: return sptr(new gr_basic_multiply_f32(vlen));
 
-    case OP_SC64: return basic_multiply::sptr(new 
gr_basic_multiply_generic<std::complex<int64_t> >(vlen));
-    case OP_S64: return basic_multiply::sptr(new 
gr_basic_multiply_generic<int64_t>(vlen));
+    case OP_SC64: return sptr(new 
gr_basic_multiply_generic<std::complex<int64_t> >(vlen));
+    case OP_S64: return sptr(new gr_basic_multiply_generic<int64_t>(vlen));
 
-    case OP_SC32: return basic_multiply::sptr(new 
gr_basic_multiply_generic<std::complex<int32_t> >(vlen));
-    case OP_S32: return basic_multiply::sptr(new 
gr_basic_multiply_generic<int32_t>(vlen));
+    case OP_SC32: return sptr(new 
gr_basic_multiply_generic<std::complex<int32_t> >(vlen));
+    case OP_S32: return sptr(new gr_basic_multiply_generic<int32_t>(vlen));
 
-    case OP_SC16: return basic_multiply::sptr(new 
gr_basic_multiply_generic<std::complex<int16_t> >(vlen));
-    case OP_S16: return basic_multiply::sptr(new 
gr_basic_multiply_generic<int16_t>(vlen));
+    case OP_SC16: return sptr(new 
gr_basic_multiply_generic<std::complex<int16_t> >(vlen));
+    case OP_S16: return sptr(new gr_basic_multiply_generic<int16_t>(vlen));
 
-    case OP_SC8: return basic_multiply::sptr(new 
gr_basic_multiply_generic<std::complex<int8_t> >(vlen));
-    case OP_S8: return basic_multiply::sptr(new 
gr_basic_multiply_generic<int8_t>(vlen));
+    case OP_SC8: return sptr(new 
gr_basic_multiply_generic<std::complex<int8_t> >(vlen));
+    case OP_S8: return sptr(new gr_basic_multiply_generic<int8_t>(vlen));
 
     default: throw std::invalid_argument("basic_make_multiply got unknown 
multiply type");
     }
diff --git a/gr-basic/lib/gr_basic_multiply_const.cc 
b/gr-basic/lib/gr_basic_multiply_const.cc
index 8ade8a0..048675f 100644
--- a/gr-basic/lib/gr_basic_multiply_const.cc
+++ b/gr-basic/lib/gr_basic_multiply_const.cc
@@ -26,10 +26,21 @@
 #include <volk/volk.h>
 
 /***********************************************************************
+ * Helper routines for conversion
+ **********************************************************************/
+template <typename type> void conv(const std::complex<double> &in, 
std::complex<type> &out){
+    out = std::complex<type>(in);
+}
+
+template <typename type> void conv(const std::complex<double> &in, type &out){
+    out = type(in.real());
+}
+
+/***********************************************************************
  * Generic multiply const implementation
  **********************************************************************/
 template <typename type>
-class gr_basic_multiply_const_generic : public basic_multiply_const{
+class gr_basic_multiply_const_generic : public gr_basic_multiply_const{
 public:
     gr_basic_multiply_const_generic(const size_t vlen):
         gr_sync_block(
@@ -39,7 +50,7 @@ public:
         ),
         _vlen(vlen)
     {
-        //NOP
+        _val.resize(_vlen);
     }
 
     int work(
@@ -68,10 +79,12 @@ public:
         return noutput_items;
     }
 
-    void set_value(const std::vector<double> &val){
-        _val.resize(val.size());
+    void _set_value(const std::vector<std::complex<double> > &val){
+        if (val.size() != _vlen){
+            throw std::invalid_argument("set_value called with the wrong 
length");
+        }
         for (size_t i = 0; i < val.size(); i++){
-            _val[i] = type(val[i]);
+            conv(val[i], _val[i]);
         }
     }
 
@@ -83,28 +96,27 @@ private:
 /***********************************************************************
  * Adder factory function
  **********************************************************************/
-basic_multiply_const::sptr basic_make_multiply_const(
-    op_type type, const size_t vlen
-){
+gr_basic_multiply_const::sptr gr_basic_multiply_const::make(op_type type, 
const size_t vlen){
     switch(type){
-    case OP_FC64: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<double>(2*vlen));
-    case OP_F64: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<double>(vlen));
+    case OP_FC64: return sptr(new 
gr_basic_multiply_const_generic<std::complex<double> >(vlen));
+    case OP_F64: return sptr(new 
gr_basic_multiply_const_generic<double>(vlen));
 
-    case OP_FC32: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<float>(2*vlen));
-    case OP_F32: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<float>(vlen));
+    case OP_FC32: return sptr(new 
gr_basic_multiply_const_generic<std::complex<float> >(vlen));
+    case OP_F32: return sptr(new gr_basic_multiply_const_generic<float>(vlen));
 
-    case OP_SC64: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<int64_t>(2*vlen));
-    case OP_S64: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<int64_t>(vlen));
+    case OP_SC64: return sptr(new 
gr_basic_multiply_const_generic<std::complex<int64_t> >(vlen));
+    case OP_S64: return sptr(new 
gr_basic_multiply_const_generic<int64_t>(vlen));
 
-    case OP_SC32: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<int32_t>(2*vlen));
-    case OP_S32: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<int32_t>(vlen));
+    case OP_SC32: return sptr(new 
gr_basic_multiply_const_generic<std::complex<int32_t> >(vlen));
+    case OP_S32: return sptr(new 
gr_basic_multiply_const_generic<int32_t>(vlen));
 
-    case OP_SC16: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<int16_t>(2*vlen));
-    case OP_S16: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<int16_t>(vlen));
+    case OP_SC16: return sptr(new 
gr_basic_multiply_const_generic<std::complex<int16_t> >(vlen));
+    case OP_S16: return sptr(new 
gr_basic_multiply_const_generic<int16_t>(vlen));
 
-    case OP_SC8: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<int8_t>(2*vlen));
-    case OP_S8: return basic_multiply_const::sptr(new 
gr_basic_multiply_const_generic<int8_t>(vlen));
+    case OP_SC8: return sptr(new 
gr_basic_multiply_const_generic<std::complex<int8_t> >(vlen));
+    case OP_S8: return sptr(new gr_basic_multiply_const_generic<int8_t>(vlen));
 
     default: throw std::invalid_argument("basic_make_multiply got unknown 
multiply type");
     }
 }
+
diff --git a/gr-basic/lib/gr_basic_subtract.cc 
b/gr-basic/lib/gr_basic_subtract.cc
index 6d268e0..1371431 100644
--- a/gr-basic/lib/gr_basic_subtract.cc
+++ b/gr-basic/lib/gr_basic_subtract.cc
@@ -29,7 +29,7 @@
  * Generic subtracter implementation
  **********************************************************************/
 template <typename type>
-class gr_basic_subtract_generic : public basic_subtract{
+class gr_basic_subtract_generic : public gr_basic_subtract{
 public:
     gr_basic_subtract_generic(const size_t vlen):
         gr_sync_block(
@@ -69,27 +69,25 @@ private:
 /***********************************************************************
  * Adder factory function
  **********************************************************************/
-basic_subtract::sptr basic_make_subtract(
-    op_type type, const size_t vlen
-){
+gr_basic_subtract::sptr gr_basic_subtract::make(op_type type, const size_t 
vlen){
     switch(type){
-    case OP_FC64: return basic_subtract::sptr(new 
gr_basic_subtract_generic<double>(2*vlen));
-    case OP_F64: return basic_subtract::sptr(new 
gr_basic_subtract_generic<double>(vlen));
+    case OP_FC64: return sptr(new gr_basic_subtract_generic<double>(2*vlen));
+    case OP_F64: return sptr(new gr_basic_subtract_generic<double>(vlen));
 
-    case OP_FC32: return basic_subtract::sptr(new 
gr_basic_subtract_generic<float>(2*vlen));
-    case OP_F32: return basic_subtract::sptr(new 
gr_basic_subtract_generic<float>(vlen));
+    case OP_FC32: return sptr(new gr_basic_subtract_generic<float>(2*vlen));
+    case OP_F32: return sptr(new gr_basic_subtract_generic<float>(vlen));
 
-    case OP_SC64: return basic_subtract::sptr(new 
gr_basic_subtract_generic<int64_t>(2*vlen));
-    case OP_S64: return basic_subtract::sptr(new 
gr_basic_subtract_generic<int64_t>(vlen));
+    case OP_SC64: return sptr(new gr_basic_subtract_generic<int64_t>(2*vlen));
+    case OP_S64: return sptr(new gr_basic_subtract_generic<int64_t>(vlen));
 
-    case OP_SC32: return basic_subtract::sptr(new 
gr_basic_subtract_generic<int32_t>(2*vlen));
-    case OP_S32: return basic_subtract::sptr(new 
gr_basic_subtract_generic<int32_t>(vlen));
+    case OP_SC32: return sptr(new gr_basic_subtract_generic<int32_t>(2*vlen));
+    case OP_S32: return sptr(new gr_basic_subtract_generic<int32_t>(vlen));
 
-    case OP_SC16: return basic_subtract::sptr(new 
gr_basic_subtract_generic<int16_t>(2*vlen));
-    case OP_S16: return basic_subtract::sptr(new 
gr_basic_subtract_generic<int16_t>(vlen));
+    case OP_SC16: return sptr(new gr_basic_subtract_generic<int16_t>(2*vlen));
+    case OP_S16: return sptr(new gr_basic_subtract_generic<int16_t>(vlen));
 
-    case OP_SC8: return basic_subtract::sptr(new 
gr_basic_subtract_generic<int8_t>(2*vlen));
-    case OP_S8: return basic_subtract::sptr(new 
gr_basic_subtract_generic<int8_t>(vlen));
+    case OP_SC8: return sptr(new gr_basic_subtract_generic<int8_t>(2*vlen));
+    case OP_S8: return sptr(new gr_basic_subtract_generic<int8_t>(vlen));
 
     default: throw std::invalid_argument("basic_make_subtract got unknown 
subtract type");
     }
diff --git a/gr-basic/swig/basic_ops.i b/gr-basic/swig/basic_ops.i
index 2487136..21c7abc 100644
--- a/gr-basic/swig/basic_ops.i
+++ b/gr-basic/swig/basic_ops.i
@@ -31,28 +31,30 @@
 #include <gr_basic_subtract.h>
 %}
 
+%include <gr_basic_add.h>
+%include <gr_basic_add_const.h>
+%include <gr_basic_divide.h>
+%include <gr_basic_multiply.h>
+%include <gr_basic_multiply_const.h>
+%include <gr_basic_subtract.h>
+
 ////////////////////////////////////////////////////////////////////////
 // import types
 ////////////////////////////////////////////////////////////////////////
 %include <gr_basic_op_types.h>
 
 ////////////////////////////////////////////////////////////////////////
-// block magic
+// template foo
 ////////////////////////////////////////////////////////////////////////
-GR_SWIG_BLOCK_MAGIC(basic,add)
-%include <gr_basic_add.h>
-
-GR_SWIG_BLOCK_MAGIC(basic,add_const)
-%include <gr_basic_add_const.h>
+%template(set_value) gr_basic_add_const::set_value<std::complex<double> >;
+%template(set_value) gr_basic_multiply_const::set_value<std::complex<double> >;
 
-GR_SWIG_BLOCK_MAGIC(basic,divide)
-%include <gr_basic_divide.h>
-
-GR_SWIG_BLOCK_MAGIC(basic,multiply)
-%include <gr_basic_multiply.h>
-
-GR_SWIG_BLOCK_MAGIC(basic,multiply_const)
-%include <gr_basic_multiply_const.h>
-
-GR_SWIG_BLOCK_MAGIC(basic,subtract)
-%include <gr_basic_subtract.h>
+////////////////////////////////////////////////////////////////////////
+// block magic
+////////////////////////////////////////////////////////////////////////
+GR_SWIG_BLOCK_MAGIC2(gr_basic,add)
+GR_SWIG_BLOCK_MAGIC2(gr_basic,add_const)
+GR_SWIG_BLOCK_MAGIC2(gr_basic,divide)
+GR_SWIG_BLOCK_MAGIC2(gr_basic,multiply)
+GR_SWIG_BLOCK_MAGIC2(gr_basic,multiply_const)
+GR_SWIG_BLOCK_MAGIC2(gr_basic,subtract)