--- a/oct-py-types.cc	Mon Aug 15 16:14:38 2016 -0700
+++ b/oct-py-types.cc	Mon Aug 15 21:53:16 2016 -0700
@@ -37,6 +37,100 @@
 namespace pytave
 {
 
+PyObject *
+make_py_bool (bool value)
+{
+  if (value)
+    Py_RETURN_TRUE;
+  else
+    Py_RETURN_FALSE;
+}
+
+PyObject *
+make_py_complex (std::complex<double> value)
+{
+  Py_complex& py_complex_value = reinterpret_cast<Py_complex&> (value);
+  return PyComplex_FromCComplex (py_complex_value);
+}
+
+PyObject *
+make_py_float (double value)
+{
+  return PyFloat_FromDouble (value);
+}
+
+inline PyObject *
+make_py_int (int32_t value)
+{
+#if PY_VERSION_HEX >= 0x03000000
+  return PyLong_FromLong (value);
+#else
+  return PyInt_FromLong (value);
+#endif
+}
+
+inline PyObject *
+make_py_int (uint32_t value)
+{
+  return PyLong_FromUnsignedLong (value);
+}
+
+inline PyObject *
+make_py_int (int64_t value)
+{
+#if (defined (HAVE_LONG_LONG) && (SIZEOF_LONG_LONG > SIZEOF_LONG))
+  return PyLong_FromLongLong (value);
+#else
+  return PyLong_FromLong (value);
+#endif
+}
+
+inline PyObject *
+make_py_int (uint64_t value)
+{
+#if (defined (HAVE_LONG_LONG) && (SIZEOF_LONG_LONG > SIZEOF_LONG))
+  return PyLong_FromUnsignedLongLong (value);
+#else
+  return PyLong_FromUnsignedLong (value);
+#endif
+}
+
+PyObject *
+make_py_numeric_value (const octave_value& value)
+{
+  if (value.is_scalar_type ())
+    {
+      if (value.is_bool_type ())
+        return make_py_bool (value.bool_value ());
+
+      else if (value.is_int8_type ())
+        return make_py_int (value.int8_scalar_value ().value ());
+      else if (value.is_int16_type ())
+        return make_py_int (value.int16_scalar_value ().value ());
+      else if (value.is_int32_type ())
+        return make_py_int (value.int32_scalar_value ().value ());
+      else if (value.is_int64_type ())
+        return make_py_int (value.int64_scalar_value ().value ());
+
+      else if (value.is_uint8_type ())
+        return make_py_int (value.uint8_scalar_value ().value ());
+      else if (value.is_uint16_type ())
+        return make_py_int (value.uint16_scalar_value ().value ());
+      else if (value.is_uint32_type ())
+        return make_py_int (value.uint32_scalar_value ().value ());
+      else if (value.is_uint64_type ())
+        return make_py_int (value.uint64_scalar_value ().value ());
+
+      else if (value.is_complex_type ())
+        return make_py_complex (value.complex_value ());
+      else if (value.is_float_type ())
+        return make_py_float (value.double_value ());
+    }
+
+  throw value_convert_exception ("unhandled scalar type");
+  return 0;
+}
+
 inline PyObject *
 wrap_octvalue_to_pyobj (const octave_value& value)
 {

--- a/oct-py-types.h	Mon Aug 15 16:14:38 2016 -0700
+++ b/oct-py-types.h	Mon Aug 15 21:53:16 2016 -0700
@@ -24,23 +24,49 @@
 #define pytave_oct_py_types_h 1
 
 #include <Python.h>
+#include <complex>
 #include <string>
 
 class Cell;
 class octave_scalar_map;
+class octave_value;
 
 namespace pytave
 {
 
 PyObject *
+make_py_bool (bool value);
+
+PyObject *
+make_py_complex (std::complex<double> value);
+
+PyObject *
+make_py_float (double value);
+
+PyObject *
 make_py_dict (const octave_scalar_map& map);
 
 int64_t
 extract_py_int64 (PyObject *obj);
 
 PyObject *
+make_py_int (int32_t value);
+
+PyObject *
+make_py_int (uint32_t value);
+
+PyObject *
+make_py_int (int64_t value);
+
+PyObject *
+make_py_int (uint64_t value);
+
+PyObject *
 make_py_list (const Cell& cell);
 
+PyObject *
+make_py_numeric_value (const octave_value& value);
+
 std::string
 extract_py_str (PyObject *obj);
 

--- a/octave_to_python.cc	Mon Aug 15 16:14:38 2016 -0700
+++ b/octave_to_python.cc	Mon Aug 15 21:53:16 2016 -0700
@@ -157,81 +157,6 @@
     py_object = object (handle<PyObject> ((PyObject *)pyarr));
   }
 
-  inline PyObject *
-  python_integer_value (int32_t value)
-  {
-#if PY_VERSION_HEX >= 0x03000000
-    return PyLong_FromLong (value);
-#else
-    return PyInt_FromLong (value);
-#endif
-  }
-
-  inline PyObject *
-  python_integer_value (uint32_t value)
-  {
-    return PyLong_FromUnsignedLong (value);
-  }
-
-  inline PyObject *
-  python_integer_value (int64_t value)
-  {
-#if (defined (HAVE_LONG_LONG) && (SIZEOF_LONG_LONG > SIZEOF_LONG))
-    return PyLong_FromLongLong (value);
-#else
-    return PyLong_FromLong (value);
-#endif
-  }
-
-  inline PyObject *
-  python_integer_value (uint64_t value)
-  {
-#if (defined (HAVE_LONG_LONG) && (SIZEOF_LONG_LONG > SIZEOF_LONG))
-    return PyLong_FromUnsignedLongLong (value);
-#else
-    return PyLong_FromUnsignedLong (value);
-#endif
-  }
-
-  static void
-  octscalar_to_pyobject (boost::python::object& py_object,
-                         const octave_value& arg)
-  {
-    PyObject *obj = 0;
-
-    if (arg.is_complex_type ())
-      obj = PyComplex_FromDoubles (arg.real ().double_value (),
-                                   arg.imag ().double_value ());
-    else if (arg.is_float_type ())
-      obj = PyFloat_FromDouble (arg.double_value ());
-
-    else if (arg.is_int8_type ())
-      obj = python_integer_value (arg.int8_scalar_value ().value ());
-    else if (arg.is_int16_type ())
-      obj = python_integer_value (arg.int16_scalar_value ().value ());
-    else if (arg.is_int32_type ())
-      obj = python_integer_value (arg.int32_scalar_value ().value ());
-    else if (arg.is_int64_type ())
-      obj = python_integer_value (arg.int64_scalar_value ().value ());
-
-    else if (arg.is_uint8_type ())
-      obj = python_integer_value (arg.uint8_scalar_value ().value ());
-    else if (arg.is_uint16_type ())
-      obj = python_integer_value (arg.uint16_scalar_value ().value ());
-    else if (arg.is_uint32_type ())
-      obj = python_integer_value (arg.uint32_scalar_value ().value ());
-    else if (arg.is_uint64_type ())
-      obj = python_integer_value (arg.uint64_scalar_value ().value ());
-
-    else if (arg.is_bool_type ())
-      obj = PyBool_FromLong (arg.bool_value ());
-
-    if (obj)
-      py_object = object (handle<PyObject> (obj));
-    else
-      throw value_convert_exception ("unhandled scalar type");
-  }
-
   void octvalue_to_pyobj (boost::python::object& py_object,
                           const octave_value& octvalue)
   {
@@ -244,7 +169,10 @@
         py_object = object (handle<PyObject> (obj));
       }
     else if (octvalue.is_scalar_type ())
-      octscalar_to_pyobject (py_object, octvalue);
+      {
+        PyObject *obj = make_py_numeric_value (octvalue);
+        py_object = object (handle<PyObject> (obj));
+      }
     else if (octvalue.is_cell ())
       {
         PyObject *obj = make_py_list (octvalue.cell_value ());