add support for windows (#231)

Author: jkotan

setup.py

@@ -79,10 +79,21 @@ def read(fname):
     if hdf5_hl_path:
         # use when h5cpp compiled with --as-needed
         nexus_config.add_link_library('hdf5_hl')
-        nexus_config.add_library_directory(
-            # '/usr/lib/x86_64-linux-gnu/hdf5/serial/'
-            hdf5_hl_path
-        )
+        if hdf5_hl_path != '__SYS__':
+            nexus_config.add_library_directory(
+                # '/usr/lib/x86_64-linux-gnu/hdf5/serial/'
+                hdf5_hl_path
+            )
+
+    hdf5_path = os.environ.get('HDF5_LOCAL_PATH')
+    if hdf5_path:
+        # use when h5cpp compiled with --as-needed
+        nexus_config.add_link_library('hdf5')
+        if hdf5_path != '__SYS__':
+            nexus_config.add_library_directory(
+                # '/usr/lib/x86_64-linux-gnu/hdf5/serial/'
+                hdf5_path
+            )
 
     h5cpp_path = os.environ.get('H5CPP_LOCAL_PATH')
     if h5cpp_path:

src/cpp/h5cpp/numpy/array_factory.cpp

@@ -56,7 +56,11 @@ int get_type_number(const hdf5::datatype::Datatype &datatype)
   // else if(datatype == create<std::complex<float16_t>>())    return NPY_COMPLEX32;
   else if(datatype == create<std::complex<float>>())    return NPY_COMPLEX64;
   else if(datatype == create<std::complex<double>>())   return NPY_COMPLEX128;
+#ifdef NPY_COMPLEX256
   else if(datatype == create<std::complex<long double>>()) return NPY_COMPLEX256;
+#else
+  else if(datatype == create<std::complex<long double>>()) return NPY_COMPLEX128;
+#endif
   else if(datatype.get_class() == Class::String)
   {
     String string_type = datatype;

src/cpp/h5cpp/numpy/hdf5_support.hpp

@@ -87,7 +87,9 @@ template<> class TypeTrait<numpy::ArrayAdapter>
 	// case NPY_COMPLEX32: return hdf5::datatype::create<std::complex<float16_t>>();
         case NPY_COMPLEX64: return hdf5::datatype::create<std::complex<float>>();
         case NPY_COMPLEX128: return hdf5::datatype::create<std::complex<double>>();
+#ifdef NPY_COMPLEX256
         case NPY_COMPLEX256: return hdf5::datatype::create<std::complex<long double>>();
+#endif
         case NPY_BOOL: return hdf5::datatype::create<bool>();
 #if PY_MAJOR_VERSION >= 3
         case NPY_UNICODE:

test/data_generator.py

@@ -82,9 +82,13 @@ def __init__(self, dt, s):
               "float128": type_desc(np.dtype("float128"), np.float128),
               "complex32": type_desc(np.dtype("complex64"), np.complex64),
               "complex64": type_desc(np.dtype("complex128"), np.complex128),
-              "complex128": type_desc(np.dtype("complex256"), np.complex256),
               "bool": type_desc(np.dtype("bool"), np.bool_)}
 
+if hasattr(np, "complex256"):
+    _type_desc["complex128"] = type_desc(np.dtype("complex256"), np.complex256)
+else:
+    _type_desc["complex128"] = type_desc(np.dtype("complex256"), np.complex128)
+
 
 if sys.version_info[0] >= 3:
     _typecodes += "unicode"

test/h5cpp_tests/datatype_tests/predefined_type_test.py

@@ -24,10 +24,17 @@
 #
 from __future__ import print_function
 import unittest
+import numpy
 from pninexus import h5cpp
 from pninexus.h5cpp.datatype import Float, String, Datatype, Integer, Enum
 
 
+if hasattr(numpy, "complex256"):
+    LINUX = True
+else:
+    LINUX = False
+
+
 class PredefinedTypeTests(unittest.TestCase):
 
     enum_types = (Datatype, Enum)
@@ -586,6 +593,8 @@ def testFloat128(self):
         dtype.norm = norm
 
         ebias = dtype.ebias
+        if not LINUX:
+            dtype.size = 8
         sz = dtype.size
         self.assertTrue(dtype.ebias in [2 * sz * sz * sz - 1,
                                         4 * sz * sz * sz - 1])
@@ -881,16 +890,23 @@ def testComplex256(self):
 
         dtype = h5cpp.datatype.Compound(h5cpp.datatype.kComplex256)
         self.assertTrue(isinstance(dtype, self.float_types))
-        self.assertEqual(dtype.size, 32)
+        if LINUX:
+            self.assertEqual(dtype.size, 32)
+        else:
+            self.assertEqual(dtype.size, 16)
         self.assertEqual(dtype.number_of_fields, 2)
         self.assertEqual(dtype.field_name(0), "real")
         self.assertEqual(dtype.field_name(1), "imag")
         self.assertEqual(dtype.field_index("real"), 0)
         self.assertEqual(dtype.field_index("imag"), 1)
         self.assertEqual(dtype.field_offset("real"), 0)
         self.assertEqual(dtype.field_offset(0), 0)
-        self.assertEqual(dtype.field_offset("imag"), 16)
-        self.assertEqual(dtype.field_offset(1), 16)
+        if LINUX:
+            self.assertEqual(dtype.field_offset("imag"), 16)
+            self.assertEqual(dtype.field_offset(1), 16)
+        else:
+            self.assertEqual(dtype.field_offset("imag"), 8)
+            self.assertEqual(dtype.field_offset(1), 8)
         self.assertEqual(dtype.field_class("real"),
                          h5cpp._datatype.Class.FLOAT)
         self.assertEqual(dtype.field_class("imag"),
@@ -903,8 +919,12 @@ def testComplex256(self):
         real = dtype[0]
         imag = dtype[1]
 
-        self.assertTrue(real.precision in [80, 128])
-        self.assertTrue(imag.precision in [80, 128])
+        if LINUX:
+            self.assertTrue(real.precision in [80, 128])
+            self.assertTrue(imag.precision in [80, 128])
+        else:
+            self.assertTrue(real.precision in [64])
+            self.assertTrue(imag.precision in [64])
         self.assertEqual(real.offset, 0)
         self.assertEqual(imag.offset, 0)
         self.assertTrue(real.order in [h5cpp.datatype.Order.LE,
@@ -927,8 +947,12 @@ def testComplex256(self):
             h5cpp.datatype.Norm.NONE, h5cpp.datatype.Norm.IMPLIED])
         # self.assertEqual(real.ebias, 16383)
         # self.assertEqual(imag.ebias, 16383)
-        self.assertEqual(real.size, 16)
-        self.assertEqual(imag.size, 16)
+        if LINUX:
+            self.assertEqual(real.size, 16)
+            self.assertEqual(imag.size, 16)
+        else:
+            self.assertEqual(real.size, 8)
+            self.assertEqual(imag.size, 8)
 
         fields = real.fields
         self.assertEqual(len(fields), 5)

test/io_test_utils.py

@@ -47,6 +47,10 @@
            "float128": numpy.float128,
            "complex32": numpy.complex64,
            "complex64": numpy.complex128,
-           "complex128": numpy.complex256,
            "string": numpy.str_,
            "bool": numpy.bool_}
+
+if hasattr(numpy, "complex256"):
+    scalars["complex128"] = numpy.complex256
+else:
+    scalars["complex128"] = numpy.complex128