1.0.1 (December 15, 2023)

This patch release primarily addresses minor bug fixes and is needed to update
the zfpy Python wheels.

Added

• A new build macro, BUILD_TESTING_FULL, specifies that all unit tests be
  built; BUILD_TESTING produces a smaller subset of tests. Full tests and
  documentation are now included in releases.

Fixed

• #169: libm dependency is not always correctly detected.
• #171: ptrdiff_t is not always imported in Cython.
• #176: cfp API is not exposed via CMake configuration file.
• #177: Full test suite is not included in release.
• #181: rpath is not set correctly in executables.
• #204: Array strides are not passed by value in zFORp.
• #220: Errors reported with scikit-build when building zfpy.

1.0.0 (August 1, 2022)

This release is not ABI compatible with prior releases due to numerous changes
to function signatures and data structures like zfp_field. However, few of
the API changes, other than to the cfp C API for compressed arrays, should
impact existing code. Note that numerous header files have been renamed or
moved relative to prior versions.

Added

• zfp::const_array: read-only variable-rate array that supports
  fixed-precision, fixed-accuracy, and reversible modes.
• Compressed-array classes for 4D data.
• const versions of array references, pointers, and iterators.
• A more complete API for pointers and iterators.
• cfp support for proxy references and pointers, iterators, and
  (de)serialization.
• Support for pointers and iterators into array views.
• zfp::array::size_bytes() allows querying the size of different components
  of an array object (e.g., payload, cache, index, metadata, ...).
• Templated C++ wrappers around the low-level C API.
• A generic codec for storing blocks of uncompressed scalars in zfp's
  C++ arrays.
• Additional functions for querying zfp_field and zfp_stream structs.
• zfp_config: struct that encapsulates compression mode and parameters.
• Rounding modes for reducing bias in compression errors.
• New examples: array, iteratorC, and ppm.

Changed

• Headers from array/, cfp/include/, and include/ have been renamed
  and reorganized into a common include/ directory.
  • The libzfp API is now confined to zfp.h, zfp.hpp, and zfp.mod
    for C, C++, and Fortran bindings, respectively. These all appear in
    the top-level include/ directory upon installation.
  • C++ headers now use a .hpp suffix; C headers use a .h suffix.
  • C++ headers like array/zfparray.h have been renamed zfp/array.hpp.
  • C headers like cfp/include/cfparrays.h have been renamed zfp/array.h.
• size_t and ptrdiff_t replace uint and int for array sizes and
  strides in the array classes and C/Fortran APIs.
• zfp_bool replaces int as Boolean type in the C API.
• bitstream_offset and bitstream_size replace size_t to ensure support
  for 64-bit offsets into and lengths of bit streams. Consequently, the
  bitstream API has changed accordingly.
• All array and view iterators are now random-access iterators.
• Array inspectors now return const_reference rather than a scalar
  type like float to allow obtaining a const_pointer to an element
  of an immutable array.
• zfp::array::compressed_data() now returns void* instead of uchar*.
• The array (de)serialization API has been revised, resulting in new
  zfp::array::header and zfp::exception classes with new exception
  messages.
• The array codec class is now responsible for all details regarding
  compression.
• The compressed-array C++ implementation has been completely refactored to
  make it more modular, extensible, and reusable across array types.
• Array block shapes are now computed on the fly rather than stored.
• The cfp C API now wraps array objects in structs.
• The zfpy Python API now supports the more general memoryview over
  bytes objects for decompression.
• The zFORp Fortran module name is now zfp instead of zforp_module.
• Some command-line options for the diffusion example have changed.
• CMake 3.9 or later is now required for CMake builds.

Removed

• zfp::array::get_header() has been replaced with a zfp::array::header
  constructor that accepts an array object.
• ZFP_VERSION_RELEASE is no longer defined (use ZFP_VERSION_PATCH).

Fixed

• #66: make install overwrites googletest.
• #84: Incorrect order of parameters in CUDA memset().
• #86: C++ compiler warns when __STDC_VERSION__ is undefined.
• #87: CXXFLAGS is misspelled in cfp/src/Makefile.
• #98: zfp_stream_maximum_size() underestimates size in reversible mode.
• #99: Incorrect private_view reads due to missing writeback.
• #109: Unused CPython array is incompatible with PyPy.
• #112: PGI compiler bug causes issues with memory alignment.
• #119: All-subnormal blocks may cause floating-point overflow.
• #121: CUDA bit offsets are limited to 32 bits.
• #122: make install does not install zfp command-line utility.
• #125: OpenMP bit offsets are limited to 32 bits.
• #126: make install does not install Fortran module.
• #127: Reversible mode reports incorrect compressed block size.
• #150: cmocka tests do not build on macOS.
• #154: Thread safety is broken in private_view and private_const_view.
• ZFP_MAX_BITS is off by one.
• diffusionC, iteratorC are not being built with gmake.

0.5.5 (May 5, 2019)

• Added support for reversible (lossless) compression of floating-point and
  integer data.

• Added methods for serializing and deserializing zfp's compressed arrays.

• Added Python bindings for compressing NumPy arrays.

• Added Fortran bindings to zfp's high-level C API.

• Change:

  • The default compressed-array cache size is now a function of the total
    number of array elements, irrespective of array shape.

• Bug fixes:

  • Incorrect handling of execution policy in zfp utility.
  • Incorrect handling of decompression via header in zfp utility.
  • Incorrect cleanup of device memory in CUDA decompress.
  • Tests for failing mallocs.
  • CMake installation of CFP when built.
  • zfp_write_header and zfp_field_metadata now fail if array dimensions
    are too large to fit in header.

0.5.4 (October 1, 2018)

• Added support for CUDA fixed-rate compression and decompression.

• Added views into compressed arrays for thread safety, nested array
  indexing, slicing, and array subsetting.

• Added C language bindings for compressed arrays.

• Added support for compressing and decompressing 4D data.

• Changes:

  • Execution policy now applies to both compression and decompression.
  • Compressed array accessors now return Scalar type instead of
    const Scalar& to avoid stale references to evicted cache lines.

• Bug fixes:

  • Handling of negative strides.
  • Command line tool handling of arrays with more than 2^32 elements.
  • bitstream C++ compatibility.
  • Respect minimum cache size request.

0.5.3 (March 28, 2018)

• Added support for OpenMP multithreaded compression (but not decompression).

• Added options for OpenMP execution to zfp command-line tool.

• Changed return value of zfp_decompress to indicate the number of compressed
  bytes processed so far (now returns same value as zfp_compress on success).

• Added compressed array support for copy construction and assignment via
  deep copies.

• Added virtual destructors to enable inheritance from zfp arrays.

0.5.2 (September 28, 2017)

• Added iterators and proxy objects for pointers and references.

• Added example illustrating how to use iterators and pointers.

• Modified diffusion example to optionally use iterators.

• Moved internal headers under array to array/zfp.

• Modified 64-bit integer typedefs to avoid the C89 non-compliant long long
  and allow for user-supplied types and literal suffixes.

• Renamed compile-time macros that did not have a ZFP prefix.

• Fixed issue with setting stream word type via CMake.

• Rewrote documentation in reStructuredText and added complete
  documentation of all public functions, classes, types, and macros.
  Removed ASCII documentation.