Changelog

Unreleased

Bug Fixes

• Polynomial interpolation: Fixed the polynomial univariate method, which returned wrong values when its window held more than four points. The divided differences were computed in place and read values that had already been overwritten. This defect was introduced in 2026.2.0.

• Multigrid convergence: Fixed fill.multigrid, whose coarse-grid correction did not match the fine problem: each V-cycle removed only about 15 % of the error, and large grids did not converge. The restriction now uses 9-point full weighting, and the number of cycles no longer grows with the grid size: a 720 × 360 grid converges in 12 cycles (2.8 s → 182 ms).

• Periodic LOESS: fill.loess ignored is_periodic: the neighbors across the seam got a zero weight. Results only change at the seam and at the reflected edges.

• T-digest: The size of TDigest is now bounded by its compression. Below the median, the centroids never merged, so the digest grew with the number of values, and computing it over a whole array was quadratic (470 ms → 6 ms for 81,000 values). The quantiles of weighted data, which were computed from the number of samples instead of the total weight, are fixed, as is the merge of two digests, which dropped the values not yet merged.

• Pickled RTree3D: Pickling RTree3D now preserves its coordinate system and distance: a Cartesian tree was restored as a geodetic one, with the WGS84 spheroid. States saved by earlier versions are still accepted.

• EquatorCoordinates: orbit.EquatorCoordinates.undefined creates its NaT with an explicit unit, as the generic unit is deprecated by NumPy.

New Features

• Geodesic distances in RTree3D: Added the distance option to RTree3D. With distance="geodesic" and a spheroid, the tree still searches its nodes with straight-line ECEF distances, but ranks the neighbors by geodesic distance on the spheroid and returns geodesic distances: it finds the same neighbors as the geographic RTree, at the same distances, about 10 times faster. The default, "euclidean", keeps the previous behavior.

Performance

• Python extension: The extension is no longer compiled with -Os in release builds, which disabled the vectorization and inlining of the Eigen kernels.

• Fill methods: The LOESS window weights are computed once per thread (2.7 to 3.6 times faster), and Gauss-Seidel only sweeps the unknown cells.

• Interpolation: Windowed, bilinear and bicubic interpolations no longer copy the window arrays or allocate memory for each point, nearest and IDW interpolations share the corner distances across layers, and periodic axis lookups avoid integer divisions.

• R-tree: k-NN searches no longer use the incremental query, and the query points of a batch are searched in spatial order.

• Statistics: T-digest quantiles are computed in a single pass, Binning1D uses a dedicated update when no weights are given, Cartesian linear binning weights are computed in closed form, and strided arrays are iterated with incremental offsets.

• Geometry: Point-in-polygon tests are filtered with the envelope of the container.

• Geohash: geohash.encode and geohash.transform are faster. When zooming out, transform now returns each code once, in ascending order.

• Date utilities: datetime64 values are split with a resolution known at compile time.

• Benchmarks: Added a benchmarks package, run with python -m benchmarks, covering 180 cases in nine families. Results can be saved and compared with a previous run.

Build System

• Precompiled header: The Python extension is compiled with a precompiled header holding the Boost.Geometry, Eigen and nanobind headers, which accounted for about half of the compilation time. It can be disabled with the PYINTERP_USE_PCH CMake option.

• Geographic overlay operations: The bindings of the geographic difference, intersection and union are instantiated in one translation unit per strategy, so that the slowest files of the build are compiled in parallel.

• Continuous integration: Compilations are cached with ccache in the coverage, Linux and macOS jobs, and the timeout of the Linux jobs is raised to 30 minutes.

• Missing include: Added the nanobind string header missing from the geohash bindings (cxx/src/pybind/geohash/string.cpp).

Dependencies

• pocketfft: Updated the vendored submodule to the latest commit.

Documentation

• RTree3D: Documented the geodesic mode of RTree3D and its differences with the geographic RTree, which evaluates geodesic distances to its nodes and queries 20 to 25 times slower than RTree3D with a spheroid.

2026.10.0

Bug Fixes

• Crossover nearest vertex indices (#41): Fixed geometry.satellite.find_crossovers, which could return index1 and index2 values that were not those of the vertices nearest to the crossover point. The golden-section search used to locate them worked on truncated integer indices: when its two probes collapsed onto the same vertex, the half of the interval holding the nearest vertex was discarded. The indices could be off by several vertices and, with a tight predicate, a valid crossover could be rejected. The crossover location itself was not affected. All the vertices are now examined by default, as geodetic.calculate_crossover did in 2025.11.0.

• Geohash ``where`` (#40): Fixed three defects of geohash.where:

  • The codes were read with a length equal to the number of columns of the array instead of the size of its items, so the keys returned were truncated or straddled neighboring codes, and arrays with more than 12 columns were rejected. This regression was introduced in 2026.2.0.

  • A code occurring exactly twice was reported with the bounds of its first occurrence only. The bounds now cover all the occurrences of a code, whether they are adjacent or not; isolated occurrences were previously ignored.

  • The function is exported again from pyinterp.geohash; since 2026.2.0 it was only reachable as pyinterp.core.geohash.where.

  Arrays that are not C-contiguous, such as transposed arrays, are now accepted.

New Features

• Faster nearest vertex search for crossovers: Added the assume_unimodal option to geometry.satellite.find_crossovers. When set, the nearest vertices are located with a bisection search instead of an exhaustive scan, which makes the whole call about 8 % faster on the Cartesian plane and about 20 % faster with geodetic calculations. It requires the distance to the crossover point to be strictly unimodal along each track, which holds for clean half-orbits but not for tracks holding duplicated vertices or covering more than a half-orbit.

2026.7.0

This release overhauls version resolution across the build, refreshes the vendored dependencies, and improves the documentation around Dask-backed binning.

Build System

• Unified version resolution: Added a CMake-based version resolution mechanism (cmake/PyinterpVersion.cmake) that derives the project version consistently for both the Python and C++ components. A VERSION.txt file (expandable by git archive) and a companion scripts/resolve_version.py mirror the same logic in Python, keeping setup.py and setuptools_scm in sync. CMakeLists.txt now conditionally builds the Python bindings and tests. Stale conda meta.yaml/conda_build_config.yaml files were removed and the CI environment configurations moved under .github/environments.

• Include directories: Dropped the PRIVATE keyword from include_directories in CMakeLists.txt for broader CMake compatibility.

Dependencies

• nanobind: Updated the vendored submodule to v2.13.0.

• pocketfft: Updated the vendored submodule to the latest commit.

Examples & Documentation

• Expanded the Dask usage notes in the binning example (examples/stats/ex_binning.py) with additional statistics, and updated the migration guide to reflect the changes to the Binning and Dask integration APIs.

• Geometry examples now use the constrained figure layout for clearer visualizations.

2026.6.0

Bug Fixes

• Periodic axis interpolation across the 0/360 seam: Fixed the geometric interpolators (bivariate, trivariate and quadrivariate with the bilinear, nearest and idw methods) so that points falling in the wrap-around cell of a periodic axis are interpolated correctly. The upper bracketing node was read with its raw coordinate (e.g. 0 instead of 360), collapsing the interpolation weight across the seam: values stayed pinned to the lower node and then jumped discontinuously at the period boundary. The upper node coordinate is now normalised relative to the lower node, restoring a smooth, monotonic interpolation across the boundary. The windowed interpolators (bicubic and the spline family) were unaffected.

2026.4.0

This release adds satellite ground-track decomposition, ships official PyPI wheels for the first time, and refreshes the supported Python matrix.

New Features

• Satellite Track Decomposition: Added decomposition algorithms in geometry.satellite that segment a satellite ground track into ascending and descending passes, with new DecompositionOption and related enums to control the algorithm. An accompanying example (examples/orbit/ex_decompose_track.py) demonstrates typical usage.

• Pairwise Distances: Added the for_each_point_pairwise_distance algorithm to compute pairwise distances between points in both the geometry.cartesian and geometry.geographic algorithm submodules.

Examples & Documentation

• 2D and 3D map examples now use set_global() instead of set_extent() for clearer global visualizations.

Packaging & Distribution

• PyPI Wheels: pyinterp is now distributed as binary wheels on PyPI in addition to conda-forge. Linux x86_64/aarch64 (manylinux_2_28), macOS arm64 (deployment target 13.4), and Windows x86_64 are built via cibuildwheel.

• Free-Threaded Python: A free-threaded CPython 3.14 wheel (cp314t) is now produced alongside the GIL-enabled build.

• Cross-Compilation Support: setup.py and the CMake configuration honour a host Python executable and propagate cross-compilation hints, enabling reliable builds in restricted toolchain environments (e.g. conda-build sysroots).

Supported Python Versions

• Dropped: Python 3.11.

• Supported: CPython 3.12, 3.13, 3.14, and 3.14 free-threaded.

Build System

• C++ Standard Library: Replaced std::jthread with std::thread plus explicit join() in the parallel-for utility for compatibility with Apple libc++ availability gating.

• Boost ≥ 1.90: CMake now enforces a minimum Boost version of 1.90 with improved detection logic and clearer error reporting.

• CMake Minimum Version: Bumped CMake minimum required version and updated Python target handling for nanobind compatibility.

• Compiler Checks: Added an explicit IEC 559 (IEEE 754) compliance check and additional cross-compilation-aware compiler probes.

• Windows: Worked around a constexpr/MSVC issue in the area_km2 helper using the __CONSTEXPR macro.

• Packaging: Added MANIFEST.in and ensured pyinterp/_version.py is included in source distributions.

Continuous Integration

• Reworked the release workflows to build and publish wheels via cibuildwheel and the source distribution via pypa/build.

• Pre-release tags (X.Y.Z<suffix>) are routed to TestPyPI; plain X.Y.Z tags publish to PyPI. Both use OIDC trusted publishing.

2026.2.0

This release represents a major architectural rewrite of pyinterp with significant breaking changes. Please refer to the Migration Guide guide for detailed upgrade instructions.

Architecture & Framework

• Binding Framework Migration: Migrated from pybind11 to nanobind for Python bindings, providing improved performance and reduced binary size.

• C++ Directory Restructuring: Reorganized C++ source code with new directory structure (cxx/src/pybind/ for bindings, cxx/src/library/ for core implementations).

• Namespace Reorganization: Refactored C++ namespaces from pyinterp::detail::* to organized modules: pyinterp::math::, pyinterp::geometry::, pyinterp::config::, and pyinterp::pybind::.

• Modern C++ Features: Adopted C++20/C++23 features including concepts, constexpr, std::format, std::ranges, three-way comparison operator (<=>), and [[nodiscard]] attributes.

New Configuration System

• Type-Safe Configuration Objects: Introduced a new config module with builder-pattern configuration objects replacing keyword arguments.

• Configuration Submodules: Added config.fill, config.geometric, config.rtree, and config.windowed for domain-specific configurations.

• Fluent API: Configuration objects support method chaining with .with_max_iterations(), .with_epsilon(), .with_num_threads(), etc.

Geometry Module

• Module Restructuring: Replaced the geodetic module with a unified geometry module supporting multiple coordinate systems.

• Geographic Coordinates: The geometry.geographic submodule replaces the former geodetic module with all geodetic operations.

• Cartesian Coordinates: Added new geometry.cartesian submodule for Cartesian coordinate system operations.

• Satellite Operations: Added new geometry.satellite submodule with satellite-specific algorithms (rotation, swath transforms).

• Algorithm Submodules: Geometric algorithms are now organized in algorithms submodules for each coordinate system (40+ algorithms available).

Math & Interpolation

• Math Module Reorganization: New math namespace with organized submodules for interpolation, statistics, FFT, and DCT operations.

• Interpolation Architecture: Redesigned interpolation system with clear separation into univariate, bivariate, and geometric interpolation.

• Interpolation Caching: Added caching layer for improved interpolation performance.

• Window Functions: Added window function support for localized interpolation.

New Features

• T-Digest: Added TDigest class for streaming quantile estimation with typed variants (TDigestFloat32, TDigestFloat64).

• Dask Integration: Added dask module with distributed computation support for binning1d(), binning2d(), descriptive_statistics(), histogram2d(), and tdigest().

• Regular Grid Interpolator: New regular_grid_interpolator module with string-based method selection ("bilinear", "bicubic", "nearest", "akima", etc.) and configuration object support.

• Typed Class Variants: Added Float32/Float64 typed variants for Binning1D, Binning2D, Histogram2D, RTree3D, and TDigest.

• Enhanced Pickle Support: Added proper pickle serialization for Grid objects via GridHolder.

• Parallel Processing: Added parallel-for utilities for multi-threaded operations.

Xarray Backend

• Simplified API: The backends.xarray module has been significantly simplified with automatic detection of geodetic and temporal axes using CF conventions.

• Automatic Axis Detection: Longitude/latitude axes are automatically detected from CF-compliant units attributes; temporal axes are detected from datetime64 dtypes.

• Removed Parameters: The increasing_axes and geodetic parameters have been removed from RegularGridInterpolator; axis detection is now automatic.

• Unified Method Parameter: The bicubic() method is removed; use the method="bicubic" parameter in the interpolation call instead.

• Simplified Keyword Arguments: The bicubic_kwargs parameter is removed; bicubic options are now passed directly as keyword arguments.

Breaking Changes - Removed Modules

The following Python modules have been removed and their functionality relocated:

• pyinterp.geodetic → Use pyinterp.geometry.geographic

• pyinterp.statistics → Use pyinterp.DescriptiveStatistics

• pyinterp.interpolator → Use pyinterp.regular_grid_interpolator

• pyinterp.grid → Use pyinterp.Grid (with aliases Grid2D, Grid3D, Grid4D)

• pyinterp.histogram2d → Use pyinterp.Histogram2D

• pyinterp.period → Use pyinterp.period (re-exported from core)

• pyinterp.binning → Use pyinterp.Binning1D, pyinterp.Binning2D

• pyinterp.interface → Removed

Breaking Changes - Removed Classes & Functions

• AxisInt64 → Use TemporalAxis for datetime axes

• RadialBasisFunction enum → Use config.rtree.RBFKernel

• WindowFunction enum → Use config.rtree.WindowKernel

• GeoHash (top-level) → Use pyinterp.geohash.GeoHash

• Orbit classes (EquatorCoordinates, Orbit, Pass, Swath) → Removed

• Orbit functions (calculate_orbit, calculate_pass, calculate_swath) → Removed

• bicubic() function → Use regular_grid_interpolator.bivariate()

• interpolate1d() function → Use regular_grid_interpolator.univariate()

• __version__, __date__ attributes → Removed

Breaking Changes - API Changes

• orbit.interpolate(): Parameter wgs renamed to coordinates, default half_window_size changed from 10 to 3.

• Axis class: Parameter is_circle replaced with period, property is_circle renamed to is_periodic.

• Enum Values: All enum values now use UPPERCASE (e.g., FirstGuess.ZERO, RBFKernel.GAUSSIAN).

• Fill Functions: Now use configuration objects instead of keyword arguments.

• RTree Methods: Now use configuration objects instead of keyword arguments.

Build System & Tooling

• Platform-Specific Conda Files: Added separate conda environment files for each platform (conda/linux.yml, conda/win.yml, conda/osx.yml).

• Updated CI Workflows: Enhanced GitHub Actions workflows for testing and coverage.

• Test Suite Reorganization: Tests reorganized into categorical subdirectories (tests/config/, tests/geometry/, tests/math/, etc.).

2025.11.0

• Deprecated the universal_kriging method in favor of the more versatile kriging method, which now supports both simple and universal kriging. Updated the documentation accordingly.

• Refactored the RBF class to improve epsilon handling, enhance interpolation matrix computation, and optimize the distance calculation method.

• Enabled builds on Linux ARM64 architectures.

• Replaced the Olson, D.K. algorithm with the Vermeille, H. algorithm for geodetic to ECEF conversions, improving numerical stability and accuracy.

• Optimized the “spline not a knot” fitting model by using Eigen::SparseLU for solving linear systems, resulting in better performance.

• Adopted ruff for code formatting and linting, and improved code typing with more precise type hints and annotations.

• Updated pre-commit hooks to their latest versions in .pre-commit-config.yaml.

• Upgraded the Eigen library to v5.0.0 to gain performance improvements and improvements and new features.

• Added Eigen as a git submodule to ensure consistent builds across different environments.

• Reorganized the source directory structure to clearly separate C++ and Python code, improving maintainability.

2025.8.1

• [Fix] Refactored BMI2-related functions to use _pdep_u64 and _pext_u64 directly, removed custom assembly implementations, fixed a typo in have_bim2 (renamed to have_bmi2), and added missing include headers for better compatibility and maintainability.

2025.8.0

• Update subproject commit for pybind11 to v3.0.0

• Update copyright year in LICENSE and specify license type in setup.py

• Refactor nearest function to compare absolute distances directly, improving clarity and consistency in logic (#32).

2025.3.0

• Introduced a new fitting model, “c_spline_not_a_knot”, for spline interpolation.

• Upgraded the C++ standard to C++20.

• Updated the pre-commit hooks in .pre-commit-config.yaml to their latest versions.

• Increased the minimum required CMake version to 3.10.

• Addressed tidy warnings.

2024.11.0

• #27: Introduced a new feature to the RTree object to handle Cartesian coordinates, bypassing the LLA/ECEF conversion .

• Introduced GitHub Actions CI workflow for coverage and testing across Linux, macOS, and Windows.

• Added new dependencies to conda/environment.yml: boost-cpp, cmake, coverage, dask, eigen, gtest, lcov, pytest-cov, setuptools, and xarray.

• Added CMake policy CMP0167 in CMakeLists.txt.

• Updated pre-commit hooks to newer versions in .pre-commit-config.yaml.

• Modified CMakeLists.txt to adjust BLAS libraries configuration.

• Updated README.rst badges to use GitHub Actions instead of Azure DevOps.

• Renamed conda environment from RTD to pyinterp in conda/environment.yml.

• Deleted Azure Pipelines configuration (azure-pipelines.yml).

• Removed docformatter pre-commit hook from .pre-commit-config.yaml.

2024.6.0

• Fix compatibility with Numpy 2.0.0

• Minor bug fixes.

2024.3.0

• Enhance the performance of the spline/bicubic interpolation: - The bicubic interpolation is now 40% faster. - The cubic spline interpolation is now 30% faster.

2024.2.0

• Fix equator point selection in orbit.py

• Fix skewing of first pass in calculate_orbit() function

• Add support for Grid2DUInt8 interpolation

• Swap min_corner and max_corner in geodetic box constructor if necessary

2024.1.0

• Fix issues in the test suite.

• Fix linter warnings.

2023.11.0

• Add intersection method to LineString class

• RegularGridInterpolator does not handle interpolator keywords.

2023.10.2

• Fix issues with Python 3.12

2023.10.1

• Fill time series by linear interpolation.

• Fill unknown positions by linear interpolation.

2023.10.0

• Period list management.

• Documentation fixes.

• Geohash box must be within [-180, 180[.

• Fix a bug in the calculation of the orbit from the ephemeris.

2023.5.0

• If MKL is not wanted, use the default BLAS implementation available. On MacOS this is Accelerate. On Linux this is OpenBLAS or a Generic BLAS implementation.

2023.2.1

• Cleanup module dependencies.

• If MKL is not found, use the default BLAS implementation if available.

2023.2.0

• Looking for multiple crossovers.

• Calculate intersection between polygon and linestring.

• Added few utility methods for polygons.

• Calculate the closest point on a linestring.

• Added Universal Krige interpolation for unstructured grids.

2023.1.0

• Add a method to simplify a line string.

• Minor fixes.

• Bug fixes with Python and the Global Interpreters Lock.

• Update pybind11 to v2.10.3

2022.10.1

• Add an option to calculate the 1D binning to limit the upper and lower range of bins used.

• Add missing prerequisites for pip install.

• Documentation fixes.

2022.10.0

• issues #13: Extract coordinates of the K nearest neighbors of a point.

• issues #12: Only the X-axis can be circular.

• Pure geodetic RTree.

• Bug fixes.

• Documentation fixes.

2022.9.1

• Orbit interpolation improvement.

2022.9.0

• Improves the accuracy of swath calculation.

• Improves TemporalAxis performance.

• Fixes bugs in the documentation.

• Python interface files are not installed properly.

0.16.0 (4 August 2022)

• Using Red-Black Gauss-Seidel.

• Refactor loess functions for 3D/4D grids.

• Bicubic interpolation failed on singleton axis (#11)

• Fill Grid4D with Loess filter (#10)

0.15.2 (5 July 2022)

• Disable assembly code on OSX/ARM64.

• Publish AxisInt64.

• Crossover point calculation is not accessible.

0.15.1 (6 June 2022)

• Calculate crossovers in a Cartesian plane.

• Fix a bug in the documentation.

0.15.0 (5 June 2022)

• Geodetic RTree

• Added support for PyPy and Pyston.

• Removal of NetCDF4 dependency.

• Orbit interpolation.

• Intersection search using WGS/Spherical coordinates.

0.14.0 (12 April 2022)

• Add a Gaussian filter function to window functions.

• Select GeoHash contained in a multi-polygon.

• Construct Geodetic objects from GeoJSON.

• Addition of geodetic algorithms.

• Implement the shallow copy operation.

• Fixes lint/compiler warnings.

• Refactor RTree class.

• Refactor Crossovers/Linestrings class.

• Update the building system.

0.13.0 (11 March 2022)

• One-dimensional binning.

• Update pybind11 to v2.9.1

• Fixes minor issues and documentation.

• Refactoring the API documentation.

• Automatic standardization of longitude when encoding GeoHash.

• Fixes lint warnings.

0.12.0 (2 February 2022)

• Extract test data into auxiliary files.

• Install pre-commit hooks.

• Upload automatically the package on pypi.

• Calculate crossovers between line string.

0.11.0 (3 January 2022)

• Change of the text representations of the grids.

• Change of the text representations of the axes.

• Display of dates in case of error in the time axes.

• Bug fix: If the step is negative in an axis, it’s impossible to detect that the values are evenly spaced.

0.10.0 (17 December 2021)

• Refactor regular grid interpolators.

• Enhanced test coverage.

• Using structured binding declaration.

• Refactor GeoHash module

• Deleting GeoHash indexes and storage (we’re using pyarrow for this now)

0.9.4 (1 December 2021)

• Correction of a spelling mistake for a keyword.

0.9.3 (22 November 2021)

• Compilation fails on Windows with Python 3.10

• Warnings from matplotlib are removed.

• Use ravel instead of flatten for numpy arrays.

0.9.2 (11 November 2021)

• Add boxcar windowed function.

• Add support for Python 3.10

• Use ravel instead of flatten for numpy arrays.

0.9.1 (30 October 2021)

• Add arguments for windowed functions.

0.9.0 (22 October 2021)

• Smoothing of an unstructured interpolated mesh with a window function.

0.8.1 (3 October 2021)

• Handling interpolation of a mask.

• Generates stubs for the core modules.

0.8.0 (30 August 2021)

• Calculates univariate statistics.

• Binning using streaming histogram to evaluate quantiles.

• Refactoring of the tests to include them in the distribution.

• Using unordered_map instead of maps to optimize geohash queries.

• Store the geohash index on fs mapping.

• Timedelta64 is also temporal axes.

0.7.1 (25 April 2021)

• find_index does not handle circles.

0.7.0 (23 April 2021)

• Within functionality flipped for IDW.

• Checks if the coordinates are covered by a polygon.

• Calculates distance between geodetic objects.

0.6.1 (6 March 2021)

• An axis can be constructed from constant values.

0.6.0 (5 March 2021)

• Added utilities for numpy dates.

• Modification of the documentation.

0.5.1 (24 January 2021)

• Fixed a bug in TemporalAxis.

0.5.0 (1 January 2021)

• Bicubic interpolation.

• Corrections of various problems.

• Modification of the geohash interface.

• Optimization of temporal axes.

0.4.0 (22 September 2020)

• Indexing data with geohash.

• Parallelize the calculation of Binning with dask.

0.3.2 (13 May 2020)

• Release GIL during RTree insertion or packing.

0.3.1 (17 April 2020)

• Fixed a bug in Loess filter.

0.3.0 (15 April 2020)

• Selection of interpolation methods for the third and fourth axes.

• Fixed a bug on 4D interpolation with the xarray backend.

0.2.0 (16 February 2020)

• Publish the “Axis.find_indexes” method.

• The Loess filter can process both undefined and defined data.

• Updating documentation.

0.1.1 (17 January 2020)

• Use of MKL in the Conda package.

0.1.0 (4 January 2020)

• Simplification of interpolations with Xarray.

• Support for numpy datetime64.

• Added 4D interpolation.

0.0.8 (7 December 2019)

• Added interpolation by RBF in RTree.

• Improvement of RTree class performance.

0.0.7 (13 November 2019)

• Addition of binned bivariate statistics.

• Addition of bicubic interpolation in 3D space.

• Improved generations of the C++ extension.

• Analysis of test coverage.

• Minor bug fixes.

0.0.6 (4 October 2019)

• Improvement of axis performance.

• Fixed performance problems with bilinear, bicubic and trivariate interpolations.

• Handling of time axes in the xarray backend.

• Access to main objects from the main module.

0.0.5 (19 September 2019)

• Use of the conda-forge channel.

0.0.4 (16 September 2019)

• Simplification of the Xarray backend.

• Merging of the conda-forge recipe.

• Fix documentation issues.

0.0.3 (29 July, 2019)

• Optimization of memory management.

• Improving bicubic interpolation performance.

• Addition of methods to fill undefined values to solve interpolation problems near the coasts.

• Major redesign to separate grid management from interpolation routines.

0.0.2 (12 July, 2019)

• Handle bound error on structured grid interpolation.

0.0.1 (8 July, 2019)

• Initial release.