PyPartMC 2.0.8__tar.gz → 2.1.0__tar.gz

{pypartmc-2.0.8 → pypartmc-2.1.0}/CMakeLists.txt

@@ -293,7 +293,7 @@ function(scoped_sundials_setup_config)
 
   file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/sundials)
   execute_process(
-    COMMAND ${PYTHON_EXECUTABLE} "-c" "import sys; print(''.join([line for line in sys.stdin if line.startswith('set(PACKAGE_VERSION_')]))"
+    COMMAND ${Python_EXECUTABLE} "-c" "import sys; print(''.join([line for line in sys.stdin if line.startswith('set(PACKAGE_VERSION_')]))"
     INPUT_FILE ${CMAKE_SOURCE_DIR}/gitmodules/sundials/CMakeLists.txt
     OUTPUT_FILE ${CMAKE_BINARY_DIR}/sundials/CMakeLists.txt
   )
@@ -339,7 +339,7 @@ target_include_directories(camplib PRIVATE
 )
 file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/include/camp)
 execute_process(
-  COMMAND ${PYTHON_EXECUTABLE} "-c" "import sys; print(''.join([line.replace(')','').replace('set(','#define ').replace('PACKAGE_', 'CAMP_') for line in sys.stdin if line.startswith('set(PACKAGE_VERSION')]))"
+  COMMAND ${Python_EXECUTABLE} "-c" "import sys; print(''.join([line.replace(')','').replace('set(','#define ').replace('PACKAGE_', 'CAMP_') for line in sys.stdin if line.startswith('set(PACKAGE_VERSION')]))"
   INPUT_FILE ${CMAKE_SOURCE_DIR}/gitmodules/camp/CMakeLists.txt
   OUTPUT_FILE ${CMAKE_BINARY_DIR}/include/camp/version.h
 )
@@ -366,7 +366,7 @@ endif()
 
 foreach(file ${hdf5_GENERATED_HEADERS})
   execute_process(
-    COMMAND ${PYTHON_EXECUTABLE} "-c" "import re;open(1,'wb').write(re.sub(b'\\r',b'',open(0,'rb').read()))"
+    COMMAND ${Python_EXECUTABLE} "-c" "import re;open(1,'wb').write(re.sub(b'\\r',b'',open(0,'rb').read()))"
     INPUT_FILE ${CMAKE_SOURCE_DIR}/${file}
     OUTPUT_FILE ${CMAKE_BINARY_DIR}/${file}
   )
@@ -391,7 +391,7 @@ string(CONCAT cmd
 )
 include(CheckFunctionExists)
 execute_process(
-  COMMAND ${PYTHON_EXECUTABLE} "-c" "${cmd}"
+  COMMAND ${Python_EXECUTABLE} "-c" "${cmd}"
   INPUT_FILE ${CMAKE_SOURCE_DIR}/gitmodules/netcdf-c/CMakeLists.txt
   OUTPUT_FILE ${CMAKE_BINARY_DIR}/netcdf/CMakeLists.txt
 )
@@ -511,15 +511,21 @@ add_dependencies(partmclib ${SUNDIALS_items})
 string(CONCAT 
   cmd
   "import sys;"
+  "print('#pragma once');"
   "print(''.join([line if line.startswith('#') else f'#define {line.split()[3]} {line.split()[5]}\\n' for line in sys.stdin if 'parameter ::' in line or line.startswith('#')]))"
 )
 include(CheckFunctionExists)
 foreach(file aero_data;gas_data;output)
   execute_process(
-    COMMAND ${PYTHON_EXECUTABLE} "-c" "${cmd}"
+    COMMAND ${Python_EXECUTABLE} "-c" "${cmd}"
     INPUT_FILE ${CMAKE_SOURCE_DIR}/gitmodules/partmc/src/${file}.F90
     OUTPUT_FILE ${CMAKE_BINARY_DIR}/include/${file}_parameters.hpp
   )
+
+  _install(
+    FILES ${CMAKE_BINARY_DIR}/include/${file}_parameters.hpp
+    DESTINATION PyPartMC/include/
+  )
 endforeach()
 
 target_include_directories(partmclib PRIVATE 
@@ -546,7 +552,13 @@ endif()
 find_package(nanobind CONFIG REQUIRED)
 
 add_subdirectory(gitmodules/nanobind)
-nanobind_add_module(_PyPartMC STABLE_ABI ${PyPartMC_sources})
+if(APPLE)
+    set(PYPARTMC_MODULE_TYPE SHARED)
+else()
+    set(PYPARTMC_MODULE_TYPE MODULE)
+endif()
+
+nanobind_add_module(_PyPartMC ${PYPARTMC_MODULE_TYPE} STABLE_ABI ${PyPartMC_sources})
 add_dependencies(_PyPartMC partmclib)
 set(PYPARTMC_INCLUDE_DIRS 
   "${CMAKE_BINARY_DIR}/include;"
@@ -627,3 +639,85 @@ foreach(file ${PyPartMC_headers})
 endforeach()
 
 _install(TARGETS _PyPartMC LIBRARY DESTINATION PyPartMC)
+
+# for C++ users who wish to link against the PyPartMC shared library
+set_target_properties(_PyPartMC PROPERTIES CXX_VISIBILITY_PRESET default C_VISIBILITY_PRESET default)
+
+set_target_properties(_PyPartMC PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
+if(WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    target_link_options(_PyPartMC PRIVATE -Wl,--export-all-symbols)
+endif()
+
+_install(
+    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src/
+    DESTINATION PyPartMC/include/PyPartMC
+    FILES_MATCHING PATTERN "*.hpp"
+)
+
+_install(
+    DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src/
+    DESTINATION PyPartMC/include/PyPartMC
+    FILES_MATCHING PATTERN "*.hpp"
+)
+
+_install(
+  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/gitmodules/json/include/nlohmann
+  DESTINATION PyPartMC/include
+)
+
+_install(
+  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/gitmodules/span/include/tcb
+  DESTINATION PyPartMC/include
+)
+
+_install(
+  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/gitmodules/string_view-standalone/include/bpstd
+  DESTINATION PyPartMC/include
+)
+
+_install(
+  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/gitmodules/optional/include/tl
+  DESTINATION PyPartMC/include
+)
+
+_install(
+  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/gitmodules/nanobind_json/include/nanobind_json
+  DESTINATION PyPartMC/include
+)
+
+_install(TARGETS partmclib
+      ARCHIVE DESTINATION PyPartMC/lib
+)
+
+ execute_process(
+    WORKING_DIRECTORY  ${CMAKE_CURRENT_SOURCE_DIR}/src/PyPartMC
+    COMMAND ${Python_EXECUTABLE} 
+    "-c" 
+    "from __generate_si import __generate_si;\nsi=__generate_si(); print('#pragma once\\nstruct si {' + '\\n'.join([f'static constexpr auto {unit}={getattr(si, unit)};' for unit in dir(si) if type(getattr(si, unit)) == float]) + '};')"
+    OUTPUT_FILE ${CMAKE_BINARY_DIR}/si.hpp
+  )
+
+_install(
+  FILES ${CMAKE_BINARY_DIR}/si.hpp
+  DESTINATION PyPartMC/include/PyPartMC
+)
+
+file(GLOB ALL_HPP_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp")
+
+file(WRITE ${CMAKE_BINARY_DIR}/PyPartMC.hpp "#pragma once\n")
+
+foreach(HPP_FILE IN LISTS ALL_HPP_FILES)
+    get_filename_component(FILENAME ${HPP_FILE} NAME)
+    file(APPEND ${CMAKE_BINARY_DIR}/PyPartMC.hpp "#include <PyPartMC/${FILENAME}>\n")
+endforeach()
+
+_install(
+  FILES ${CMAKE_BINARY_DIR}/PyPartMC.hpp
+  DESTINATION PyPartMC/include/
+)
+
+_install(
+  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src/PyPartMC/cmake
+  DESTINATION PyPartMC
+)

{pypartmc-2.0.8 → pypartmc-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPartMC
-Version: 2.0.8
+Version: 2.1.0
 Summary: Python interface to PartMC
 Author-Email: "https://github.com/open-atmos/PyPartMC/graphs/contributors" <nriemer@illinois.edu>
 License-Expression: GPL-3.0
@@ -38,7 +38,7 @@ Additionally, the ability to easily package examples, simple simulations, and re
   instructors, and students, with nominal software and hardware requirements.
 
 Documentation of PyPartMC is hosted at https://open-atmos.github.io/PyPartMC.
-PyPartMC is implemented in C++ and it also constitutes a C++ API to the PartMC Fortran internals.
+PyPartMC is implemented in C++ and it also constitutes a C++ API to the PartMC Fortran internals (C++ example below).
 The Python API can facilitate using PartMC from other environments - see, e.g., Julia and Matlab examples below.
 
 For an outline of the project, rationale, architecture, and features, refer to: [D'Aquino et al., 2024 (SoftwareX)](https://doi.org/10.1016/j.softx.2023.101613) (please cite if PyPartMC is used in your research).
@@ -202,7 +202,94 @@ aero_state.dist_sample(aero_dist)
 print(np.dot(aero_state.masses(), aero_state.num_concs), "# kg/m3")
 ```
 
+#### C++
+
+```cpp
+#include <iostream>
+#include <memory>
+#include <numeric>
+
+#include "PyPartMC.hpp"
+#include "PyPartMC/si.hpp"
+
+int main() {
+    auto aero_data = std::make_shared<AeroData>(nlohmann::json({
+        { {"OC", {1000.0 * si::kg / (si::m * si::m * si::m), 0.0, 1e-3 * si::kg / si::mol, 0.001, 0.0, 0.0}} },
+        { {"BC", {1800.0 * si::kg / (si::m * si::m * si::m), 0.0, 1e-3 * si::kg / si::mol, 0.0,   0.0, 0.0}} }
+    }));
+
+    auto aero_dist = AeroDist(
+        aero_data, 
+        nlohmann::ordered_json::array({
+            nlohmann::ordered_json::object({
+                {"cooking", {
+                    {"mass_frac", nlohmann::ordered_json::array({ nlohmann::ordered_json::object({{"OC", {1.0}}}) }) }, 
+                    {"diam_type", "geometric"},
+                    {"mode_type", "log_normal"},
+                    {"num_conc", 3200.0 / (si::cm * si::cm * si::cm)},
+                    {"geom_mean_diam", 8.64 * si::nm},
+                    {"log10_geom_std_dev", 0.28}
+                }},
+                {"diesel", {
+                    {"mass_frac", nlohmann::ordered_json::array({ nlohmann::ordered_json::object({{"OC", {0.3}}}), nlohmann::ordered_json::object({{"BC", {0.7}}}) }) }, 
+                    {"diam_type", "geometric"},
+                    {"mode_type", "log_normal"},
+                    {"num_conc", 2900.0 / (si::cm * si::cm * si::cm)},
+                    {"geom_mean_diam", 50.0 * si::nm},
+                    {"log10_geom_std_dev", 0.24}
+                }}
+            })
+        })
+    );
+
+    int n_part = 100;
+    auto aero_state = AeroState(aero_data, n_part, "nummass_source");
+    
+    AeroState::dist_sample(aero_state, aero_dist, 1.0, 0.0, true, true);
+
+    auto masses = AeroState::masses(aero_state, {}, {});
+    auto num_concs = AeroState::num_concs(aero_state);
+
+    double total_mass = std::inner_product(
+        std::begin(num_concs), std::end(num_concs), 
+        std::begin(masses), 
+        0.0
+    );
+    
+    std::cout << std::scientific << total_mass << " # kg/m3\n";
+
+    return 0;
+}
+```
+
+What can be compiled using CMake with following CMakeLists.txt:
+
+```cmake
+cmake_minimum_required(VERSION 3.22)
+project(AeroSimulation LANGUAGES CXX)
+
+enable_testing()
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(Python 3.8 REQUIRED COMPONENTS Interpreter)
+execute_process(
+    COMMAND ${Python_EXECUTABLE} -c "import PyPartMC, pathlib; print(pathlib.Path(PyPartMC.cmake_dir()).as_posix())"
+    OUTPUT_VARIABLE PYPARTMC_CMAKE_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+set(PyPartMC_DIR "${PYPARTMC_CMAKE_DIR}")
+
+find_package(PyPartMC REQUIRED)
+
+add_executable(my_test test.cpp)
+target_link_libraries(my_test PRIVATE PyPartMC::PyPartMC)
+pypartmc_setup_runtime(my_test)
+
+add_test(NAME maketest COMMAND my_test)
+```
+
 #### Julia (using [PyCall.jl](https://github.com/JuliaPy/PyCall.jl))
+
 ```Julia
 using Pkg
 Pkg.add("PyCall")

{pypartmc-2.0.8 → pypartmc-2.1.0}/README.md

@@ -12,7 +12,7 @@ Additionally, the ability to easily package examples, simple simulations, and re
   instructors, and students, with nominal software and hardware requirements.
 
 Documentation of PyPartMC is hosted at https://open-atmos.github.io/PyPartMC.
-PyPartMC is implemented in C++ and it also constitutes a C++ API to the PartMC Fortran internals.
+PyPartMC is implemented in C++ and it also constitutes a C++ API to the PartMC Fortran internals (C++ example below).
 The Python API can facilitate using PartMC from other environments - see, e.g., Julia and Matlab examples below.
 
 For an outline of the project, rationale, architecture, and features, refer to: [D'Aquino et al., 2024 (SoftwareX)](https://doi.org/10.1016/j.softx.2023.101613) (please cite if PyPartMC is used in your research).
@@ -176,7 +176,94 @@ aero_state.dist_sample(aero_dist)
 print(np.dot(aero_state.masses(), aero_state.num_concs), "# kg/m3")
 ```
 
+#### C++
+
+```cpp
+#include <iostream>
+#include <memory>
+#include <numeric>
+
+#include "PyPartMC.hpp"
+#include "PyPartMC/si.hpp"
+
+int main() {
+    auto aero_data = std::make_shared<AeroData>(nlohmann::json({
+        { {"OC", {1000.0 * si::kg / (si::m * si::m * si::m), 0.0, 1e-3 * si::kg / si::mol, 0.001, 0.0, 0.0}} },
+        { {"BC", {1800.0 * si::kg / (si::m * si::m * si::m), 0.0, 1e-3 * si::kg / si::mol, 0.0,   0.0, 0.0}} }
+    }));
+
+    auto aero_dist = AeroDist(
+        aero_data, 
+        nlohmann::ordered_json::array({
+            nlohmann::ordered_json::object({
+                {"cooking", {
+                    {"mass_frac", nlohmann::ordered_json::array({ nlohmann::ordered_json::object({{"OC", {1.0}}}) }) }, 
+                    {"diam_type", "geometric"},
+                    {"mode_type", "log_normal"},
+                    {"num_conc", 3200.0 / (si::cm * si::cm * si::cm)},
+                    {"geom_mean_diam", 8.64 * si::nm},
+                    {"log10_geom_std_dev", 0.28}
+                }},
+                {"diesel", {
+                    {"mass_frac", nlohmann::ordered_json::array({ nlohmann::ordered_json::object({{"OC", {0.3}}}), nlohmann::ordered_json::object({{"BC", {0.7}}}) }) }, 
+                    {"diam_type", "geometric"},
+                    {"mode_type", "log_normal"},
+                    {"num_conc", 2900.0 / (si::cm * si::cm * si::cm)},
+                    {"geom_mean_diam", 50.0 * si::nm},
+                    {"log10_geom_std_dev", 0.24}
+                }}
+            })
+        })
+    );
+
+    int n_part = 100;
+    auto aero_state = AeroState(aero_data, n_part, "nummass_source");
+    
+    AeroState::dist_sample(aero_state, aero_dist, 1.0, 0.0, true, true);
+
+    auto masses = AeroState::masses(aero_state, {}, {});
+    auto num_concs = AeroState::num_concs(aero_state);
+
+    double total_mass = std::inner_product(
+        std::begin(num_concs), std::end(num_concs), 
+        std::begin(masses), 
+        0.0
+    );
+    
+    std::cout << std::scientific << total_mass << " # kg/m3\n";
+
+    return 0;
+}
+```
+
+What can be compiled using CMake with following CMakeLists.txt:
+
+```cmake
+cmake_minimum_required(VERSION 3.22)
+project(AeroSimulation LANGUAGES CXX)
+
+enable_testing()
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(Python 3.8 REQUIRED COMPONENTS Interpreter)
+execute_process(
+    COMMAND ${Python_EXECUTABLE} -c "import PyPartMC, pathlib; print(pathlib.Path(PyPartMC.cmake_dir()).as_posix())"
+    OUTPUT_VARIABLE PYPARTMC_CMAKE_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+set(PyPartMC_DIR "${PYPARTMC_CMAKE_DIR}")
+
+find_package(PyPartMC REQUIRED)
+
+add_executable(my_test test.cpp)
+target_link_libraries(my_test PRIVATE PyPartMC::PyPartMC)
+pypartmc_setup_runtime(my_test)
+
+add_test(NAME maketest COMMAND my_test)
+```
+
 #### Julia (using [PyCall.jl](https://github.com/JuliaPy/PyCall.jl))
+
 ```Julia
 using Pkg
 Pkg.add("PyCall")

{pypartmc-2.0.8 → pypartmc-2.1.0}/gitmodules/nanobind/.github/workflows/ci.yml

@@ -108,7 +108,7 @@ jobs:
         python3 -m pytest
 
   free-threaded:
-    name: "Python 3.14-dev / ubuntu.latest [free-threaded]"
+    name: "Python 3.14t / ubuntu-latest [free-threaded]"
     runs-on: ubuntu-latest
 
     steps:
@@ -116,10 +116,10 @@ jobs:
       with:
         submodules: true
 
-    - uses: deadsnakes/action@v3.1.0
+    - name: Setup Python 3.14t (free-threaded)
+      uses: actions/setup-python@v5
       with:
-        python-version: 3.14-dev
-        nogil: true
+        python-version: '3.14t'
 
     - name: Install the latest CMake
       uses: lukka/get-cmake@latest

{pypartmc-2.0.8 → pypartmc-2.1.0}/gitmodules/nanobind/CMakeLists.txt

@@ -64,9 +64,6 @@ endif()
 # Installation rules
 # ---------------------------------------------------------------------------
 if(NB_CREATE_INSTALL_RULES AND NOT CMAKE_SKIP_INSTALL_RULES)
-  # Silence warning in GNUInstallDirs due to no enabled languages
-  set(CMAKE_INSTALL_LIBDIR "")
-  include(GNUInstallDirs)
   set(NB_INSTALL_DATADIR "nanobind"
     CACHE PATH "Installation path for read-only architecture-independent nanobind data files")
 

{pypartmc-2.0.8 → pypartmc-2.1.0}/gitmodules/nanobind/cmake/darwin-ld-cpython.sym

@@ -122,6 +122,7 @@
 -U _PyDict_Type
 -U _PyDict_Update
 -U _PyDict_Values
+-U _PyFrozenDict_Type
 -U _PyEllipsis_Type
 -U _PyEnum_Type
 -U _PyErr_BadArgument

{pypartmc-2.0.8 → pypartmc-2.1.0}/gitmodules/nanobind/docs/api_extra.rst

@@ -735,7 +735,7 @@ section <ndarrays>`.
 
    .. _ndarray_dynamic_constructor:
 
-   .. cpp:function:: ndarray(VoidPtr data, const std::initializer_list<size_t> shape = { }, handle owner = { }, std::initializer_list<int64_t> strides = { }, dlpack::dtype dtype = nanobind::dtype<Scalar>(), int32_t device_type = DeviceType, int32_t device_id = 0, char order = Order)
+   .. cpp:function:: ndarray(VoidPtr data, const std::initializer_list<size_t> shape = { }, handle owner = { }, std::initializer_list<int64_t> strides = { }, dlpack::dtype dtype = nanobind::dtype<Scalar>(), int32_t device_type = DeviceType, int32_t device_id = 0, char order = Order, uint64_t byte_offset = 0)
 
       Create an array wrapping an existing memory allocation.
 
@@ -796,6 +796,11 @@ section <ndarrays>`.
         implementation uses the order specified as an ndarray template
         argument, or C-style order as a fallback.
 
+      - `byte_offset` specifies the DLPack ``DLTensor::byte_offset`` field in
+        bytes. This is useful when `data` is an opaque device handle pointing to
+        the start of an allocation, while the logical array begins later in the
+        allocation.
+
       Both ``strides`` and ``shape`` will be copied by the constructor, hence
       the targets of these initializer lists do not need to remain valid
       following the constructor call.
@@ -805,7 +810,7 @@ section <ndarrays>`.
          The Python *global interpreter lock* (GIL) must be held when calling
          this function.
 
-   .. cpp:function:: ndarray(VoidPtr data, size_t ndim, const size_t * shape, handle owner, const int64_t * strides = nullptr, dlpack::dtype dtype = nanobind::dtype<Scalar>(), int device_type = DeviceType, int device_id = 0, char order = Order)
+   .. cpp:function:: ndarray(VoidPtr data, size_t ndim, const size_t * shape, handle owner, const int64_t * strides = nullptr, dlpack::dtype dtype = nanobind::dtype<Scalar>(), int device_type = DeviceType, int device_id = 0, char order = Order, uint64_t byte_offset = 0)
 
       Alternative form of the above constructor, which accepts the `shape`
       and `strides` arguments using pointers instead of initializer lists.
@@ -879,6 +884,16 @@ section <ndarrays>`.
       Return a pointer to the array data.
       If :cpp:var:`ReadOnly` is true, a pointer-to-const is returned.
 
+   .. cpp:function:: void * data_handle() const
+
+      Return the raw DLPack ``DLTensor::data`` field without applying the byte
+      offset. For non-CPU devices, this may be an opaque device handle such as
+      an ``id<MTLBuffer>`` for :cpp:class:`device::metal <device::metal>`.
+
+   .. cpp:function:: uint64_t byte_offset() const
+
+      Return the DLPack ``DLTensor::byte_offset`` value in bytes.
+
    .. cpp:function:: template <typename... Args2> auto& operator()(Args2... indices)
 
       Return a reference to the element stored at the provided index/indices.

{pypartmc-2.0.8 → pypartmc-2.1.0}/gitmodules/nanobind/docs/changelog.rst

@@ -21,7 +21,9 @@ Unreleased
 - The implicit :cpp:func:`.none() <arg::none>` annotation now also applies to
   ``std::nullptr_t`` and ``std::monostate``-typed arguments
 
-Version 2.12.0 (Feb 25, 2025)
+- Added ndarray ``dtype_code`` enumeration ``Bcomplex`` for complex bfloat16.
+
+Version 2.12.0 (Feb 25, 2026)
 -----------------------------
 
 - Added :cpp:class:`nb::memoryview` that wraps the Python ``memoryview`` type.

{pypartmc-2.0.8 → pypartmc-2.1.0}/gitmodules/nanobind/docs/ndarray.rst

@@ -541,12 +541,12 @@ Nonstandard arithmetic types
 ----------------------------
 
 Low or extended-precision arithmetic types (e.g., ``int128``, ``float16``,
-``bfloat16``) are sometimes used but don't have standardized C++ equivalents.
+``bfloat16``) are sometimes used, though they are not standardized in C++17.
 If you wish to exchange arrays based on such types, you must register a partial
 overload of ``nanobind::detail::dtype_traits`` to inform nanobind about it.
 
 You are expressively allowed to create partial overloads of this class despite
-it being in the ``nanobind::detail`` namespace.
+its being in the ``nanobind::detail`` namespace.
 
 For example, the following snippet makes ``_Float16`` (half-precision type that
 is natively supported on some hardware) available by providing
@@ -561,12 +561,36 @@ is natively supported on some hardware) available by providing
            static constexpr dlpack::dtype value {
                (uint8_t) dlpack::dtype_code::Float, // type code
                16, // size in bits
-               1   // lanes (simd), usually set to 1
+               1   // lanes (simd), usually always set to 1
            };
            static constexpr auto name = const_name("float16");
        };
    }
 
+For complex numbers, nanobind assumes the ``T`` in ``std::complex<T>`` is an
+IEEE floating-point type.  Thus, above, it is not also necessary to specialize
+``dtype_traits<std::complex<_Float16>>``.
+
+To use ``bfloat16`` complex numbers, specialize ``dtype_traits`` for both the
+real and complex C++ types:
+
+.. code-block:: cpp
+
+   namespace nanobind::detail {
+   template<> struct dtype_traits<__bf16> {
+       static constexpr dlpack::dtype value{
+               /*code=*/static_cast<uint8_t>(dlpack::dtype_code::Bfloat),
+               /*bits=*/16, /*lanes=*/1};
+       static constexpr auto name = const_name("bfloat16");
+   };
+   template<> struct dtype_traits<std::complex<__bf16>> {
+       static constexpr dlpack::dtype value{
+               /*code=*/static_cast<uint8_t>(dlpack::dtype_code::Bcomplex),
+               /*bits=*/32, /*lanes=*/1};
+       static constexpr auto name = const_name("bcomplex32");
+   };
+   }  // namespace nanobind::detail
+
 .. _ndarray-views:
 
 Fast array views

{pypartmc-2.0.8 → pypartmc-2.1.0}/gitmodules/nanobind/include/nanobind/nb_lib.h

@@ -487,7 +487,7 @@ NB_CORE ndarray_handle *ndarray_create(void *data, size_t ndim,
                                        const int64_t *strides,
                                        dlpack::dtype dtype, bool ro,
                                        int device, int device_id,
-                                       char order);
+                                       char order, uint64_t byte_offset);
 
 /// Increase the reference count of the given ndarray object; returns a pointer
 /// to the underlying DLTensor

{pypartmc-2.0.8 → pypartmc-2.1.0}/gitmodules/nanobind/include/nanobind/ndarray.h

@@ -27,7 +27,8 @@ enum class dtype_code : uint8_t {
     Float8_E4M3FN = 10, Float8_E4M3FNUZ = 11, Float8_E5M2 = 12,
     Float8_E5M2FNUZ = 13, Float8_E8M0FNU = 14,
     Float6_E2M3FN = 15, Float6_E3M2FN = 16,
-    Float4_E2M1FN = 17
+    Float4_E2M1FN = 17,
+    Bcomplex = 18
 };
 
 struct device {
@@ -353,11 +354,12 @@ public:
             dlpack::dtype dtype = nanobind::dtype<Scalar>(),
             int device_type = DeviceType,
             int device_id = 0,
-            char order = Order) {
+            char order = Order,
+            uint64_t byte_offset = 0) {
 
         m_handle = detail::ndarray_create(
             (void *) data, ndim, shape, owner.ptr(), strides, dtype,
-            ReadOnly, device_type, device_id, order);
+            ReadOnly, device_type, device_id, order, byte_offset);
 
         m_dltensor = *detail::ndarray_inc_ref(m_handle);
     }
@@ -369,7 +371,8 @@ public:
             dlpack::dtype dtype = nanobind::dtype<Scalar>(),
             int device_type = DeviceType,
             int device_id = 0,
-            char order = Order) {
+            char order = Order,
+            uint64_t byte_offset = 0) {
 
         size_t shape_size = shape.size();
 
@@ -392,7 +395,7 @@ public:
         m_handle = detail::ndarray_create(
             (void *) data, shape_size, shape_ptr, owner.ptr(),
             (strides.size() == 0) ? nullptr : strides.begin(), dtype,
-            ReadOnly, device_type, device_id, order);
+            ReadOnly, device_type, device_id, order, byte_offset);
 
         m_dltensor = *detail::ndarray_inc_ref(m_handle);
     }
@@ -436,6 +439,8 @@ public:
     bool is_valid() const { return m_handle != nullptr; }
     int device_type() const { return (int) m_dltensor.device.device_type; }
     int device_id() const { return (int) m_dltensor.device.device_id; }
+    void *data_handle() const { return m_dltensor.data; }
+    uint64_t byte_offset() const { return m_dltensor.byte_offset; }
     detail::ndarray_handle *handle() const { return m_handle; }
 
     size_t size() const {
@@ -456,7 +461,7 @@ public:
     template <typename... Args2>
     NB_INLINE auto& operator()(Args2... indices) const {
         return *(Scalar *) ((uint8_t *) m_dltensor.data +
-                            byte_offset(indices...));
+                            compute_byte_offset(indices...));
     }
 
     template <typename... Args2> NB_INLINE auto view() const {
@@ -492,7 +497,7 @@ public:
 
 private:
     template <typename... Args2>
-    NB_INLINE int64_t byte_offset(Args2... indices) const {
+    NB_INLINE int64_t compute_byte_offset(Args2... indices) const {
         constexpr bool has_scalar = !std::is_void_v<Scalar>,
                        has_shape  = Config::N != -1;