Python: long (complex) double

Add long double and long double complex types in Python bindings.

bindings/Python/py11types.h

@@ -43,7 +43,7 @@ struct MPI4PY_Comm
     ADIOS2_FOREACH_PRIMITIVE_STDTYPE_1ARG(MACRO)
 
 #define ADIOS2_FOREACH_NUMPY_ATTRIBUTE_TYPE_1ARG(MACRO)                        \
-    ADIOS2_FOREACH_ATTRIBUTE_PRIMITIVE_STDTYPE_1ARG(MACRO)
+    ADIOS2_FOREACH_PRIMITIVE_STDTYPE_1ARG(MACRO)
 
 } // end namespace py11
 } // end namespace adios2

testing/adios2/bindings/python/TestBPReadMultisteps.py

@@ -63,12 +63,21 @@ def check_name(name, name_list):
 
 varR32 = ioWriter.DefineVariable(
     "varR32", data.R32, shape, start, count, adios2.ConstantDims)
-
 varR64 = ioWriter.DefineVariable(
     "varR64", data.R64, shape, start, count, adios2.ConstantDims)
+varR128 = ioWriter.DefineVariable(
+    "varR128", data.R128, shape, start, count, adios2.ConstantDims)
+
+varC32 = ioWriter.DefineVariable(
+    "varC32", data.C32, shape, start, count, adios2.ConstantDims)
+varC64 = ioWriter.DefineVariable(
+    "varC64", data.C64, shape, start, count, adios2.ConstantDims)
+varC128 = ioWriter.DefineVariable(
+    "varC128", data.C128, shape, start, count, adios2.ConstantDims)
 
 attString = ioWriter.DefineAttribute("attrString", ["hello attribute"])
 attI8 = ioWriter.DefineAttribute("attrI8", data.I8)
+attC64 = ioWriter.DefineAttribute("attrC64", data.C64)
 
 # ADIOS Engine
 writer = ioWriter.Open("npTypes.bp", adios2.Mode.Write)
@@ -85,6 +94,10 @@ def check_name(name, name_list):
     npu64 = np.full((Nx), i, dtype=np.uint64)
     npr32 = np.full((Nx), i, dtype=np.float32)
     npr64 = np.full((Nx), i, dtype=np.float64)
+    npr128 = np.full((Nx), i, dtype=np.float128)
+    npc32 = np.full((Nx), i, dtype=np.csingle)
+    npc64 = np.full((Nx), i, dtype=np.cdouble)
+    npc128 = np.full((Nx), i, dtype=np.clongdouble)
 
     writer.BeginStep()
     writer.Put(varI8, npi8)
@@ -99,6 +112,11 @@ def check_name(name, name_list):
 
     writer.Put(varR32, npr32)
     writer.Put(varR64, npr64)
+    writer.Put(varR128, npr128)
+
+    writer.Put(varC32, npc32)
+    writer.Put(varC64, npc64)
+    writer.Put(varC128, npc128)
     writer.EndStep()
 
 writer.Close()
@@ -110,6 +128,7 @@ def check_name(name, name_list):
 
 attrString = ioReader.InquireAttribute("attrString")
 attrI8 = ioReader.InquireAttribute("attrI8")
+attrC64 = ioReader.InquireAttribute("attrC64")
 
 varI8 = ioReader.InquireVariable("varI8")
 varI16 = ioReader.InquireVariable("varI16")
@@ -121,9 +140,14 @@ def check_name(name, name_list):
 varU64 = ioReader.InquireVariable("varU64")
 varR32 = ioReader.InquireVariable("varR32")
 varR64 = ioReader.InquireVariable("varR64")
+varR128 = ioReader.InquireVariable("varR128")
+varC32 = ioReader.InquireVariable("varC32")
+varC64 = ioReader.InquireVariable("varC64")
+varC128 = ioReader.InquireVariable("varC128")
 
 check_object(attrString, "attrString")
 check_object(attrString, "attrI8")
+check_object(attrString, "attrC64")
 
 check_object(varI8, "varI8")
 check_object(varI16, "varI16")
@@ -135,12 +159,17 @@ def check_name(name, name_list):
 check_object(varU64, "varU64")
 check_object(varR32, "varR32")
 check_object(varR64, "varR64")
+check_object(varR128, "varR128")
+check_object(varC32, "varCR32")
+check_object(varC64, "varC64")
+check_object(varC128, "varC128")
 
 
-attr_names = ["attrString", "attrI8"]
+attr_names = ["attrString", "attrI8", "attrC64"]
 var_names = ["varStr", "varI8", "varI16", "varI32", "varI64",
              "varU8", "varU16", "varU32", "varU64",
-                      "varR32", "varR64"]
+                      "varR32", "varR64", "varR128",
+                      "varC32", "varC64", "varC128"]
 
 attributesInfo = ioReader.AvailableAttributes()
 for name, info in attributesInfo.items():
@@ -221,6 +250,30 @@ def check_name(name, name_list):
     inR64 = np.zeros((3, size * Nx), dtype=np.float64)
     reader.Get(varR64, inR64)
 
+if varR128 is not None:
+    varR128.SetSelection([[0], [size * Nx]])
+    varR128.SetStepSelection([0, 3])
+    inR128 = np.zeros((3, size * Nx), dtype=np.float128)
+    reader.Get(varR128, inR128)
+
+if varC32 is not None:
+    varC32.SetSelection([[0], [size * Nx]])
+    varC32.SetStepSelection([0, 3])
+    inC32 = np.zeros((3, size * Nx), dtype=np.csingle)
+    reader.Get(varC32, inC32)
+
+if varC64 is not None:
+    varC64.SetSelection([[0], [size * Nx]])
+    varC64.SetStepSelection([0, 3])
+    inC64 = np.zeros((3, size * Nx), dtype=np.cdouble)
+    reader.Get(varC64, inC64)
+
+if varC128 is not None:
+    varC128.SetSelection([[0], [size * Nx]])
+    varC128.SetStepSelection([0, 3])
+    inC128 = np.zeros((3, size * Nx), dtype=np.clongdouble)
+    reader.Get(varC128, inC128)
+
 reader.PerformGets()
 
 for i in range(0, 3):
@@ -255,6 +308,18 @@ def check_name(name, name_list):
         if(inR64[i][j] != i):
             raise ValueError('failed reading R64')
 
+        if(inR128[i][j] != i):
+            raise ValueError('failed reading R128')
+
+        if(inC32[i][j] != i):
+            raise ValueError('failed reading C32')
+
+        if(inC64[i][j] != i):
+            raise ValueError('failed reading C64')
+
+        if(inC128[i][j] != i):
+            raise ValueError('failed reading C128')
+
 
 # here tests reader data
 reader.Close()

testing/adios2/bindings/python/TestBPWriteReadTypes.py

@@ -39,10 +39,13 @@ def check_array(np1, np2, hint):
 
 # list of tested attributes and variables
 attr_names = ["attrString", "attrI8", "attrI16", "attrI32", "attrI64",
-              "attrU8", "attrU16", "attrU32", "attrU64", "attrR32", "attrR64"]
+              "attrU8", "attrU16", "attrU32", "attrU64",
+              "attrR32", "attrR64", "attrR128",
+              "attrC32", "attrC64", "attrC128"]
 var_names = ["varStr", "varI8", "varI16", "varI32", "varI64",
              "varU8", "varU16", "varU32", "varU64",
-                      "varR32", "varR64"]
+                      "varR32", "varR64", "varR128",
+                      "varC32", "varC64", "varC128"]
 
 # Start ADIOS
 adios = adios2.ADIOS(comm)
@@ -78,9 +81,17 @@ def check_array(np1, np2, hint):
 
 varR32 = ioWriter.DefineVariable(
     "varR32", data.R32, shape, start, count, adios2.ConstantDims)
-
 varR64 = ioWriter.DefineVariable(
     "varR64", data.R64, shape, start, count, adios2.ConstantDims)
+varR128 = ioWriter.DefineVariable(
+    "varR128", data.R128, shape, start, count, adios2.ConstantDims)
+
+varC32 = ioWriter.DefineVariable(
+    "varC32", data.C32, shape, start, count, adios2.ConstantDims)
+varC64 = ioWriter.DefineVariable(
+    "varC64", data.C64, shape, start, count, adios2.ConstantDims)
+varC128 = ioWriter.DefineVariable(
+    "varC128", data.C128, shape, start, count, adios2.ConstantDims)
 
 attString = ioWriter.DefineAttribute("attrString", ["one", "two", "three"])
 attI8 = ioWriter.DefineAttribute("attrI8", data.I8)
@@ -93,6 +104,10 @@ def check_array(np1, np2, hint):
 attU64 = ioWriter.DefineAttribute("attrU64", data.U64)
 attR32 = ioWriter.DefineAttribute("attrR32", data.R32)
 attR64 = ioWriter.DefineAttribute("attrR64", data.R64)
+attR128 = ioWriter.DefineAttribute("attrR128", data.R128)
+attC32 = ioWriter.DefineAttribute("attrC32", data.C32)
+attC64 = ioWriter.DefineAttribute("attrC64", data.C64)
+attC128 = ioWriter.DefineAttribute("attrC128", data.C128)
 
 ioWriter.SetEngine("BPFile")
 ioParams = {}
@@ -138,6 +153,11 @@ def check_array(np1, np2, hint):
 
     writer.Put(varR32, data.R32)
     writer.Put(varR64, data.R64)
+    writer.Put(varR128, data.R128)
+
+    writer.Put(varC32, data.C32)
+    writer.Put(varC64, data.C64)
+    writer.Put(varC128, data.C128)
     writer.EndStep()
 
 writer.Close()
@@ -158,6 +178,10 @@ def check_array(np1, np2, hint):
 attrU64 = ioReader.InquireAttribute("attrU64")
 attrR32 = ioReader.InquireAttribute("attrR32")
 attrR64 = ioReader.InquireAttribute("attrR64")
+attrR128 = ioReader.InquireAttribute("attrR128")
+attrC32 = ioReader.InquireAttribute("attrC32")
+attrC64 = ioReader.InquireAttribute("attrC64")
+attrC128 = ioReader.InquireAttribute("attrC128")
 
 check_object(attrString, "attrString")
 check_object(attrI8, "attrI8")
@@ -170,6 +194,10 @@ def check_array(np1, np2, hint):
 check_object(attrU64, "attrU64")
 check_object(attrR32, "attrR32")
 check_object(attrR64, "attrR64")
+check_object(attrR128, "attrR128")
+check_object(attrC32, "attrC32")
+check_object(attrC64, "attrC64")
+check_object(attrC128, "attrC128")
 
 attrStringData = attrString.DataString()
 if(attrStringData[0] != "one"):
@@ -189,6 +217,10 @@ def check_array(np1, np2, hint):
 attrU64Data = attrU64.Data()
 attrR32Data = attrR32.Data()
 attrR64Data = attrR64.Data()
+attrR128Data = attrR128.Data()
+attrC32Data = attrC32.Data()
+attrC64Data = attrC64.Data()
+attrC128Data = attrC128.Data()
 
 check_array(attrI8Data, data.I8, 'I8')
 check_array(attrI16Data, data.I16, 'I16')
@@ -200,6 +232,10 @@ def check_array(np1, np2, hint):
 check_array(attrU64Data, data.U64, 'U64')
 check_array(attrR32Data, data.R32, 'R32')
 check_array(attrR64Data, data.R64, 'R64')
+check_array(attrR128Data, data.R128, 'R128')
+check_array(attrC32Data, data.C32, 'C32')
+check_array(attrC64Data, data.C64, 'C64')
+check_array(attrC128Data, data.C128, 'C128')
 
 attributesInfo = ioReader.AvailableAttributes()
 for name, info in attributesInfo.items():
@@ -221,6 +257,10 @@ def check_array(np1, np2, hint):
 varU64 = ioReader.InquireVariable("varU64")
 varR32 = ioReader.InquireVariable("varR32")
 varR64 = ioReader.InquireVariable("varR64")
+varR128 = ioReader.InquireVariable("varR128")
+varC32 = ioReader.InquireVariable("varC32")
+varC64 = ioReader.InquireVariable("varC64")
+varC128 = ioReader.InquireVariable("varC128")
 
 check_object(varStr, "varStr")
 check_object(varI8, "varI8")
@@ -233,6 +273,10 @@ def check_array(np1, np2, hint):
 check_object(varU64, "varU64")
 check_object(varR32, "varR32")
 check_object(varR64, "varR64")
+check_object(varR128, "varR128")
+check_object(varC32, "varC32")
+check_object(varC64, "varC64")
+check_object(varC128, "varC128")
 
 variablesInfo = ioReader.AvailableVariables()
 for name, info in variablesInfo.items():

testing/adios2/bindings/python/TestBPWriteReadTypes_nompi.py

@@ -42,10 +42,17 @@
 
 varR32 = bpIO.DefineVariable(
     "varR32", data.R32, [], [], [data.R32.size], adios2.ConstantDims)
-
 varR64 = bpIO.DefineVariable(
     "varR64", data.R64, [], [], [data.R64.size], adios2.ConstantDims)
+varR128 = bpIO.DefineVariable(
+    "varR128", data.R128, [], [], [data.R128.size], adios2.ConstantDims)
 
+varC32 = bpIO.DefineVariable(
+    "varC32", data.C32, [], [], [data.C32.size], adios2.ConstantDims)
+varC64 = bpIO.DefineVariable(
+    "varC64", data.C64, [], [], [data.C64.size], adios2.ConstantDims)
+varC128 = bpIO.DefineVariable(
+    "varC128", data.C128, [], [], [data.C128.size], adios2.ConstantDims)
 
 # ADIOS Engine
 bpFileWriter = bpIO.Open("npTypes.bp", adios2.Mode.Write)
@@ -62,5 +69,10 @@
 
 bpFileWriter.Put(varR32, data.R32)
 bpFileWriter.Put(varR64, data.R64)
+bpFileWriter.Put(varR128, data.R128)
+
+bpFileWriter.Put(varC32, data.C32)
+bpFileWriter.Put(varC64, data.C64)
+bpFileWriter.Put(varC128, data.C128)
 
 bpFileWriter.Close()