blosc2 3.7.2__tar.gz → 3.9.0__tar.gz

{blosc2-3.7.2 → blosc2-3.9.0}/.pre-commit-config.yaml

@@ -7,7 +7,7 @@ ci:
 default_stages: [pre-commit, pre-push]
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: check-yaml
       - id: end-of-file-fixer
@@ -16,7 +16,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.7
+    rev: v0.13.0
     hooks:
       - id: ruff-check
         args: ["--fix", "--show-fixes"]

{blosc2-3.7.2 → blosc2-3.9.0}/ANNOUNCE.rst

@@ -1,15 +1,23 @@
-Announcing Python-Blosc2 3.7.2
+Announcing Python-Blosc2 3.8.0
 ==============================
 
-This is a maintenance release where:
+This is a minor version release where we have aimed to make the first steps
+towards complying fully with the array-api standard:
 
-✅ We have updated the Blosc2 C library to 2.21.1, which fixes a regression
-  in the build system detected in Fedora and Gentoo.
-✅ We reverted signature of ``TreeStore.__init__(()`` for making benchmarks
-  to get back to normal performance.
+✅ C-Blosc2 internal library updated to latest 2.21.3.
+
+✅ numexpr version requirement pushed to 2.3.0 to incorporate
+``round``, ``sign``, ``signbit``, ``copysign``, ``nextafter``, ``hypot``,
+``maximum``, ``minimum``, ``trunc``, ``log2``, ``//`` and bitwise AND/OR/XOR/NOT.
+
+✅ Enhanced linear algebra via ``tensordot``, extended ``matmul``, ``vecdot``, ``diagonal``,
+``outer``, as well as ``broadcast_to`` and ``meshgrid``.
+
+✅ Roughly 60 attributes and methods for the ``NDArray`` class, as well as functions, have
+been added to increase compliance with the array-api standard, with ufuncs now very well supported.
+
+✅ A subtle bug which caused ``arr = blosc2.expand_dims(arr)`` to fail has been fixed.
 
-Check our new blog post about ``TreeStore`` usage and performance at:
-https://www.blosc.org/posts/new-treestore-blosc2
 
 You can think of Python-Blosc2 3.x as an extension of NumPy/numexpr that:
 

{blosc2-3.7.2 → blosc2-3.9.0}/CMakeLists.txt

@@ -50,7 +50,7 @@ else()
     include(FetchContent)
     FetchContent_Declare(blosc2
         GIT_REPOSITORY https://github.com/Blosc/c-blosc2
-        GIT_TAG 96bce728dcdbf41fd86f142ebef9e513f87a7afb  # v2.21.1
+        GIT_TAG 0c853a639ba97997e33e29db9eed202459ebc6f0  # v2.21.3
     )
     FetchContent_MakeAvailable(blosc2)
     include_directories("${blosc2_SOURCE_DIR}/include")

{blosc2-3.7.2 → blosc2-3.9.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.2
 Name: blosc2
-Version: 3.7.2
+Version: 3.9.0
 Summary: A fast & compressed ndarray library with a flexible compute engine.
 Author-Email: Blosc Development Team <blosc@blosc.org>
 Maintainer-Email: Blosc Development Team <blosc@blosc.org>
 License: BSD-3-Clause
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 6 - Mature
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
@@ -26,7 +26,7 @@ Requires-Dist: numpy>=1.26
 Requires-Dist: ndindex
 Requires-Dist: msgpack
 Requires-Dist: platformdirs
-Requires-Dist: numexpr; platform_machine != "wasm32"
+Requires-Dist: numexpr>=2.13.0; platform_machine != "wasm32"
 Requires-Dist: py-cpuinfo; platform_machine != "wasm32"
 Requires-Dist: requests
 Provides-Extra: dev
@@ -177,8 +177,8 @@ In addition, other people have participated to the project in different
 aspects:
 
 - Jan Sellner, contributed the mmap support for NDArray/SChunk objects.
-- Dimitri Papadopoulos, contributed a large bunch of improvements to the
-  in many aspects of the project.  His attention to detail is remarkable.
+- Dimitri Papadopoulos, contributed a large bunch of improvements to
+  many aspects of the project.  His attention to detail is remarkable.
 - And many others that have contributed with bug reports, suggestions and
   improvements.
 

{blosc2-3.7.2 → blosc2-3.9.0}/README.rst

@@ -115,8 +115,8 @@ In addition, other people have participated to the project in different
 aspects:
 
 - Jan Sellner, contributed the mmap support for NDArray/SChunk objects.
-- Dimitri Papadopoulos, contributed a large bunch of improvements to the
-  in many aspects of the project.  His attention to detail is remarkable.
+- Dimitri Papadopoulos, contributed a large bunch of improvements to
+  many aspects of the project.  His attention to detail is remarkable.
 - And many others that have contributed with bug reports, suggestions and
   improvements.
 

{blosc2-3.7.2 → blosc2-3.9.0}/README_DEVELOPERS.md

@@ -70,3 +70,13 @@ We are using Sphinx for documentation.  You can build the documentation by execu
 [You may need to install the `pandoc` package first: https://pandoc.org/installing.html]
 
 You will find the documentation in the `../html` directory.
+
+## Array API tests compatibility
+
+You can test array API compatibility with the `array-api-tests` module.
+Use the `tests/array-api-xfails.txt` to skip the tests that are not supported
+and run pytest from the `array-api-tests` source dir like this:
+
+``` bash
+ARRAY_API_TESTS_MODULE=blosc2 pytest array_api_tests --xfails-file ${BLOSC2_DIR}/tests/array-api-xfails.txt -xs
+```

{blosc2-3.7.2 → blosc2-3.9.0}/RELEASE_NOTES.md

@@ -1,5 +1,47 @@
 # Release notes
 
+## Changes from 3.9.0 to 3.9.1
+
+XXX version-specific blurb XXX
+
+## Changes from 3.8.0 to 3.9.0
+Most changes come from PR #467 relating to array-api compliance.
+
+* C-Blosc2 internal library updated to latest 2.21.3, increasing MAX_DIMS from 8 to 16
+
+* numexpr version requirement pushed to 2.13.0 to incorporate
+``round``, ``sign``, ``signbit``, ``copysign``, ``nextafter``, ``hypot``,
+``maximum``, ``minimum``, ``trunc``, ``log2`` functions, as well as allow
+integer outputs for certain functions when integr arguments are passed.
+We also add floor division (``//``) and full dual bitwise (logical) AND, OR, XOR, NOT
+support for integer (bool) arrays.
+
+* Extended linear algebra functionality, offering generalised matrix multiplication
+for arrays of arbitrary dimension via ``tensordot`` and an improved ``matmul``. In addition,
+introduced ``vecdot``, ``diagonal`` and ``outer``, as well as useful indexing and associated functions such as ``take``, ``take_along_axis``, ``meshgrid`` and ``broadcast_to``.
+
+* Added many ufuncs and methods (around 60) to ``NDArray`` to bring the library into further alignment with the array-api. Introduced a chunkwise lazyudf paradigm which is very powerful in order to implement ``clip`` and ``logaddexp``.
+
+* Fixed a subtle but important bug for ``expand_dims`` (PR #479, PR #483) relating to reference counting for views.
+
+## Changes from 3.7.2 to 3.8.0
+
+* C-Blosc2 internal library updated to latest 2.21.2.
+
+* numexpr version requirement pushed to 2.12.1 to incorporate
+``isnan``, ``isfinite``, ``isinf`` functions.
+
+* Indexing is now supported extensively and reasonably optimally for slices
+with negative steps and general boolean arrays, with both get/setitem having
+equal functionality. In PR #459 we extended the 1D fast path to general N-D,
+with consequent speedups. In PR # we allowed fancy indexing and general slicing
+with negative steps for set and getitem, with a memory-optimised path for setitem.
+
+* Various attributes and methods for the ``NDArray`` class, as well as functions, have
+been added to increase compliance with the array-api standard. In addition,
+linspace and arange functions have been made more numerically stable and now strictly
+comply even with difficult floating-point edge cases.
+
 ## Changes from 3.7.1 to 3.7.2
 
 * C-Blosc2 internal library updated to latest 2.21.1.

blosc2-3.9.0/ROADMAP-TO-4.0.md

@@ -0,0 +1,23 @@
+List of desired features for a 4.0 release
+------------------------------------------
+
+* First and foremost, we would like to have at least of basic implementation of the [array API](https://data-apis.org/array-api).  This will require a lot of low-level work on the basic NDArray container to make indexing to work as close as the standard.
+
+* Have a completely specified format for the `TreeStore` and `DictStore`.  The format should allow to have containers either in memory or on disk.  Also, it should allow a sparse or contiguous storage.  The user will be able to specify these properties by following the same conventions than for NDArray objects (alas, `urlpath` and `contiguous` params).
+
+    * New `.save()` and `.to_cframe()` methods should be implemented to convert from in-memory representations to on disk and vice-versa.
+    * The format for `TreeStore` and `DictStore` will initially be defined at Python level, and documented only in the Python-Blosc2 repository.  An implementation in the C library is desirable, but not mandatory at this time.
+
+* A new `Table` object should be implemented based on the `TreeStore` class (a subclass?), with a label ('table'?) in metalayers indicating that the contents of the tree can be interpreted as regular table.  As `TreeStore` is hierarchical, a subtree can also be interpreted as a `Table` if there a label in the metalayer of the subtree (or group in HDF5 parlance); that can lead to tables than can have different subtables embedded.  It is not clear yet if should impose the same number of rows for all the columns.
+
+The constructor for the `Table` object should take some parameters to specify properties:
+
+    * `columnar`: True or False. If True, every column will be stored in a different NDArray object.  If False, the columns will be stored in the same NDArray object, with a compound dtype.  In principle, one should be able to create tables that are hybrid between column and row wise, but at this point it is not clear what is the best way to do that.
+
+`Table` should support at least these methods:
+
+    * `.__getitem__()` and `.__setitem__()` so that values can be get and set.
+    * `.append()` for appending (multi-) rows of data for all columns in one go.
+    * `.__iter__()` for easy and fast iteration over rows.
+    * `.where()`: an iterator for queying with conditions that are evaluated with the internal compute engine.
+    * `.index()` for indexing a column and getting better performance in queries (desirable, but optional for 4.0).

{blosc2-3.7.2 → blosc2-3.9.0}/doc/conf.py

@@ -1,9 +1,22 @@
 # -- Path setup --------------------------------------------------------------
+import inspect
 import os
 import sys
 
+import numpy as np
+
 import blosc2
 
+
+def genbody(f, func_list, lib="blosc2"):
+    for func in func_list:
+        f.write(f"    {func}\n")
+
+    f.write("\n\n\n")
+    for func in func_list:
+        f.write(f".. autofunction:: {lib}.{func}\n\n")
+
+
 sys.path.insert(0, os.path.abspath(os.path.dirname(blosc2.__file__)))
 
 project = "Python-Blosc2"
@@ -69,6 +82,120 @@ exclude_patterns = ["_build", ".DS_Store", "**.ipynb_checkpoints"]
 html_show_sourcelink = False
 
 autosummary_generate_overwrite = False
+autosummary_generate = True
+
+# GENERATE ufuncs.rst
+blosc2_ufuncs = []
+for name, obj in vars(np).items():
+    if isinstance(obj, np.ufunc) and hasattr(blosc2, name):
+        blosc2_ufuncs.append(name)
+
+with open("reference/ufuncs.rst", "w") as f:
+    f.write(
+        """Universal Functions (`ufuncs`)
+------------------------------
+
+The following elementwise functions can be used for computing with any of :ref:`NDArray <NDArray>`, :ref:`C2Array <C2Array>`, :ref:`NDField <NDField>` and :ref:`LazyExpr <LazyExpr>`.
+
+Their result is always a :ref:`LazyExpr` instance, which can be evaluated (with ``compute`` or ``__getitem__``) to get the actual values of the computation.
+
+Note: The functions ``conj``, ``real``, ``imag``, ``contains``, ``where`` are not technically ufuncs.
+
+.. currentmodule:: blosc2
+
+.. autosummary::
+
+"""
+    )
+    genbody(f, blosc2_ufuncs)
+
+# GENERATE additional_funcs.rst
+blosc2_addfuncs = sorted(["conj", "real", "imag", "contains", "where", "clip", "round"])
+blosc2_dtypefuncs = sorted(["astype", "can_cast", "result_type", "isdtype"])
+
+with open("reference/additional_funcs.rst", "w") as f:
+    f.write(
+        """Additional Functions and Type Utilities
+=======================================
+
+Functions
+---------
+
+The following functions can also be used for computing with any of :ref:`NDArray <NDArray>`, :ref:`C2Array <C2Array>`, :ref:`NDField <NDField>` and :ref:`LazyExpr <LazyExpr>`.
+
+Their result is typically a :ref:`LazyExpr` instance, which can be evaluated (with ``compute`` or ``__getitem__``) to get the actual values of the computation.
+
+.. currentmodule:: blosc2
+
+.. autosummary::
+
+"""
+    )
+    genbody(f, blosc2_addfuncs)
+    f.write(
+        """Type Utilities
+--------------
+
+The following functions are useful for working with datatypes.
+
+.. currentmodule:: blosc2
+
+.. autosummary::
+
+"""
+    )
+    genbody(f, blosc2_dtypefuncs)
+
+# GENERATE index_funcs.rst
+blosc2_indexfuncs = sorted(
+    [
+        "count_nonzero",
+        "squeeze",
+        "expand_dims",
+        "sort",
+        "take",
+        "take_along_axis",
+        "broadcast_to",
+        "meshgrid",
+        "indices",
+    ]
+)
+
+with open("reference/index_funcs.rst", "w") as f:
+    f.write(
+        """Indexing Functions and Utilities
+=======================================
+
+The following functions are useful for performing indexing and oter associated operations.
+
+.. currentmodule:: blosc2
+
+.. autosummary::
+
+"""
+    )
+    genbody(f, blosc2_indexfuncs)
+
+# GENERATE linear_algebra.rst
+linalg_funcs = [
+    name
+    for name, obj in vars(blosc2.linalg).items()
+    if (inspect.isfunction(obj) and getattr(obj, "__doc__", None))
+]
+
+with open("reference/linalg.rst", "w") as f:
+    f.write(
+        """Linear Algebra
+-----------------
+The following functions can be used for computing linear algebra operations with :ref:`NDArray <NDArray>`.
+
+.. currentmodule:: blosc2.linalg
+
+.. autosummary::
+
+"""
+    )
+    genbody(f, linalg_funcs, "blosc2.linalg")
 
 hidden = "_ignore_multiple_size"
 
@@ -81,7 +208,6 @@ def linkcode_resolve(domain, info):
 
     import importlib
     import inspect
-    import os
 
     # Modify this to point to your package
     module_name = info["module"]

{blosc2-3.7.2 → blosc2-3.9.0}/doc/getting_started/tutorials/08.schunk-slicing_and_beyond.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# Slicing, extending and serializing with SChunks\n",
     "\n",
-    "The usual way to store generic binary data in python-blosc2 is through a `SChunk` (super-chunk) object, where the data is split into chunks of the same size, which we studied in the last tutorial. We saw how to retrieve, update or append data in the form of chunks. In fact, one can work with the individual multi-byte items composing the data (and not the bytes directly), using native SChunk methods - such operations will be the subject of this tutorial. We will use NumPy arrays as data sources, but everything we're going to do woul work equally well with any Python object supporting the [Buffer Protocol](https://docs.python.org/3/c-api/buffer.html).\n",
+    "The usual way to store generic binary data in python-blosc2 is through a `SChunk` (super-chunk) object, where the data is split into chunks of the same size, which we studied in the last tutorial. We saw how to retrieve, update or append data in the form of chunks. In fact, one can work with the individual multi-byte items composing the data (and not the bytes directly), using native SChunk methods - such operations will be the subject of this tutorial. We will use NumPy arrays as data sources, but everything we're going to do would work equally well with any Python object supporting the [Buffer Protocol](https://docs.python.org/3/c-api/buffer.html).\n",
     "\n",
     "First, we create our own `SChunk` instance; this time, let's fill it with data upon creation."
    ]
@@ -93,7 +93,7 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": "As you can see, the data is returned as a bytes object. If we want to get a more meaningful container instead, we can use `get_slice`. This method requires an initailised buffer into which to load the bytes, and one may pass any Python object (supporting the Buffer Protocol) as the `out` param to fill it with the data.  In this case we will use a NumPy array container."
+   "source": "As you can see, the data is returned as a bytes object. If we want to get a more meaningful container instead, we can use `get_slice`. This method requires an initialised buffer into which to load the bytes, and one may pass any Python object (supporting the Buffer Protocol) as the `out` param to fill it with the data.  In this case we will use a NumPy array container."
   },
   {
    "cell_type": "code",

{blosc2-3.7.2 → blosc2-3.9.0}/doc/python-blosc2.rst

@@ -6,7 +6,7 @@
 
     <p style="text-align: center; color: black; background-color: rgba(230, 169, 9, 0.65);">
         <a href="https://github.com/Blosc/python-blosc2/blob/main/RELEASE_NOTES.md"
-           style="font-size: 1.5em;">Version 3.7.1 released on 2025-08-17!</a>
+           style="font-size: 1.5em;">Version 3.8.0 released on 2025-09-11!</a>
         <span style="display: inline-block; width: 20px;"></span>
         <span style="font-family: monospace;">pip install blosc2 -U</span>
     </p>
@@ -36,7 +36,7 @@
                 <h3 style="margin-top: 10px; margin-bottom: 15px;">Top-Notch Compression</h3>
             </div>
 
-        `Combine advanced codecs and filters <https://blosc.org/docs/LEAPS-INNOV_WP7_D74_v1.pdf>`_ for efficient `lossless <https://www.blosc.org/posts/bytedelta-enhance-compression-toolset/>`_ and `lossy <https://www.blosc.org/posts/blosc2-lossy-compression/>`_ compression to reduce storage space while maintaining high performance.
+        `Combine advanced codecs and filters <https://www.blosc.org/docs/2025-EuroSciPy-Blosc2.pdf>`_ for efficient `lossless <https://www.blosc.org/posts/bytedelta-enhance-compression-toolset/>`_ and `lossy <https://www.blosc.org/posts/blosc2-lossy-compression/>`_ compression to reduce storage space while maintaining high performance.
 
     .. grid-item-card::
         :class-card: intro-card text-center no-border
@@ -48,7 +48,7 @@
                 <h3 style="margin-top: 10px; margin-bottom: 15px;">Full-Fledged NDArrays</h3>
             </div>
 
-        `NDArray objects <https://www.blosc.org/python-blosc2/getting_started/tutorials/01.ndarray-basics.html>`_ enable efficient storage and manipulation of arbitrarily large N-dimensional datasets, following the `Array API <https://data-apis.org/array-api/latest/>`_ standard, with an additional `C-API <https://www.blosc.org/posts/blosc2-ndim-intro/>`_ available.
+        `NDArray objects <https://www.blosc.org/python-blosc2/getting_started/tutorials/01.ndarray-basics.html>`_ enable efficient storage and manipulation of arbitrarily large N-dimensional datasets, following the `Array API <https://data-apis.org/array-api/latest/>`_ standard, with an additional `C API <https://www.blosc.org/posts/blosc2-ndim-intro/>`_.
 
     .. grid-item-card::
         :class-card: intro-card text-center no-border
@@ -60,7 +60,7 @@
                 <h3 style="margin-top: 10px; margin-bottom: 15px;">Compute Engine Inside</h3>
             </div>
 
-        Combines compression with high-speed computation of complex `mathematical expressions <https://ironarray.io/blog/blosc2-eval-expressions>`_ and `reductions <https://www.blosc.org/posts/ndim-reductions/>`_, while maintaining compatibility with NumPy.
+        Combines compression with high-speed computation of complex `mathematical expressions <https://ironarray.io/blog/blosc2-eval-expressions>`_ and `reductions <https://www.blosc.org/python-blosc2/getting_started/tutorials/04.reductions.html>`_, while maintaining compatibility with NumPy.
 
     .. grid-item-card::
         :class-card: intro-card text-center no-border
@@ -68,11 +68,11 @@
         .. raw:: html
 
             <div style="text-align: center;">
-                <i class="fas fa-th" style="font-size: 2em; color: #007acc; margin-bottom: 10px;"></i>
-                <h3 style="margin-top: 10px; margin-bottom: 15px;">Sparse Data Mastery</h3>
+                <i class="fas fa-sitemap" style="font-size: 2em; color: #007acc; margin-bottom: 10px;"></i>
+                <h3 style="margin-top: 10px; margin-bottom: 15px;">Hierarchical Structures</h3>
             </div>
 
-        Efficiently store and manipulate sparse data with `compact sparse constructs <https://www.blosc.org/docs/Exploring-MilkyWay-SciPy2023.pdf>`_ for optimized `performance <https://www.blosc.org/docs/Exploring-MilkyWay-SciPy2023-paper.pdf>`_.
+        Efficiently store data hierarchically with the `TreeStore class <https://www.blosc.org/python-blosc2/reference/tree_store.html#blosc2.TreeStore>`_ for convenience and optimized `performance <https://www.blosc.org/posts/new-treestore-blosc2/>`_.
 
     .. grid-item-card::
         :class-card: intro-card text-center no-border
@@ -84,7 +84,7 @@
                 <h3 style="margin-top: 10px; margin-bottom: 15px;">Flexible Storage</h3>
             </div>
 
-        Access data from anywhere: read/write in `memory or disk <https://github.com/Blosc/python-blosc2/blob/main/doc/getting_started/tutorials/01.ndarray-basics.ipynb>`_, stream from `the network <https://www.blosc.org/python-blosc2/reference/c2array.html>`_, or use `memory-mapped files <https://www.blosc.org/python-blosc2/reference/storage.html#blosc2.Storage.params.mmap_mode>`_ for high-performance I/O.
+        Access data from anywhere: read/write in `memory or disk <https://www.blosc.org/docs/Exploring-MilkyWay-SciPy2023-paper.pdf>`_, stream from `the network <https://www.blosc.org/python-blosc2/reference/c2array.html>`_, or use `memory-mapped files <https://www.blosc.org/python-blosc2/reference/storage.html#blosc2.Storage.params.mmap_mode>`_ for high-performance I/O.
 
     .. grid-item-card::
         :class-card: intro-card text-center no-border

blosc2-3.9.0/doc/reference/additional_funcs.rst

@@ -0,0 +1,61 @@
+Additional Functions and Type Utilities
+=======================================
+
+Functions
+---------
+
+The following functions can also be used for computing with any of :ref:`NDArray <NDArray>`, :ref:`C2Array <C2Array>`, :ref:`NDField <NDField>` and :ref:`LazyExpr <LazyExpr>`.
+
+Their result is typically a :ref:`LazyExpr` instance, which can be evaluated (with ``compute`` or ``__getitem__``) to get the actual values of the computation.
+
+.. currentmodule:: blosc2
+
+.. autosummary::
+
+    clip
+    conj
+    contains
+    imag
+    real
+    round
+    where
+
+
+
+.. autofunction:: blosc2.clip
+
+.. autofunction:: blosc2.conj
+
+.. autofunction:: blosc2.contains
+
+.. autofunction:: blosc2.imag
+
+.. autofunction:: blosc2.real
+
+.. autofunction:: blosc2.round
+
+.. autofunction:: blosc2.where
+
+Type Utilities
+--------------
+
+The following functions are useful for working with datatypes.
+
+.. currentmodule:: blosc2
+
+.. autosummary::
+
+    astype
+    can_cast
+    isdtype
+    result_type
+
+
+
+.. autofunction:: blosc2.astype
+
+.. autofunction:: blosc2.can_cast
+
+.. autofunction:: blosc2.isdtype
+
+.. autofunction:: blosc2.result_type

{blosc2-3.7.2 → blosc2-3.9.0}/doc/reference/array_operations.rst

@@ -4,6 +4,8 @@ Operations with arrays
 .. toctree::
     :maxdepth: 1
 
-    lazy_functions
+    ufuncs
     reduction_functions
-    linear_algebra
+    linalg
+    additional_funcs
+    index_funcs

blosc2-3.9.0/doc/reference/index_funcs.rst

@@ -0,0 +1,38 @@
+Indexing Functions and Utilities
+=======================================
+
+The following functions are useful for performing indexing and oter associated operations.
+
+.. currentmodule:: blosc2
+
+.. autosummary::
+
+    broadcast_to
+    count_nonzero
+    expand_dims
+    indices
+    meshgrid
+    sort
+    squeeze
+    take
+    take_along_axis
+
+
+
+.. autofunction:: blosc2.broadcast_to
+
+.. autofunction:: blosc2.count_nonzero
+
+.. autofunction:: blosc2.expand_dims
+
+.. autofunction:: blosc2.indices
+
+.. autofunction:: blosc2.meshgrid
+
+.. autofunction:: blosc2.sort
+
+.. autofunction:: blosc2.squeeze
+
+.. autofunction:: blosc2.take
+
+.. autofunction:: blosc2.take_along_axis

blosc2-3.9.0/doc/reference/linalg.rst

@@ -0,0 +1,34 @@
+Linear Algebra
+-----------------
+The following functions can be used for computing linear algebra operations with :ref:`NDArray <NDArray>`.
+
+.. currentmodule:: blosc2.linalg
+
+.. autosummary::
+
+    matmul
+    tensordot
+    vecdot
+    permute_dims
+    transpose
+    matrix_transpose
+    diagonal
+    outer
+
+
+
+.. autofunction:: blosc2.linalg.matmul
+
+.. autofunction:: blosc2.linalg.tensordot
+
+.. autofunction:: blosc2.linalg.vecdot
+
+.. autofunction:: blosc2.linalg.permute_dims
+
+.. autofunction:: blosc2.linalg.transpose
+
+.. autofunction:: blosc2.linalg.matrix_transpose
+
+.. autofunction:: blosc2.linalg.diagonal
+
+.. autofunction:: blosc2.linalg.outer