- mp++ now works with the Intel compiler
(#224,
tested with
`icpc (ICC) 19.1.0.166`

). This includes also support for`real128`

(with a couple of minor limitations). - The interoperability of
`real128`

with`long double`

has been improved: it is now supported also on Clang (since version 7) and it does not require mp++ to be configured with the`MPPP_WITH_MPFR`

option any more (#222). - mp++ now officially supports the ARM (
`aarch64`

) and PowerPC (`ppc64le`

) architectures, which have been added to the continuous integration setup (#219).

- For consistency with C++20, mp++’s concepts now use snake case notation. The concept hierarchy has also been simplified and streamlined (#228).
**BREAKING**: the global precision setting mechanism has been removed from`real`

. As a result, the API and behaviour of the`real`

class have undergone a few backwards-incompatible changes (#227).- The documentation is now using sphinx exclusively, doxygen is not involved any more (#227, #225, #223, #221).
- Various internal simplifications and improvements
to
`real128`

(#221).

- Implement
`real`

primitives for exact multiplication/division by powers of 2 (#216). - mp++ can now optionally use Arb
to provide various additional special functions for
`real`

(#215). - Implement squaring for
`real`

(#215). `integer`

and`rational`

can now interact with`std::complex`

(#214).- mp++’s multiprecision classes now support pretty-printing in the xeus-cling notebook (#213).
- Implement user-defined literals for
`rational`

,`real128`

and`real`

(#213).

- The
`real`

dilogarithm functions now return NaN if the argument is not less than 1. - Move more
`real`

functions from the header into the compiled library (#216). - The GCC quadmath library is now a private dependency of the mp++ library (#215).
- The
`real128`

string representation has been changed to use the`g`

format specifier (#213).

- Update the internal copy of Catch to the latest version, 2.11.1 (#210).
- mp++’s public headers do not include
the
`quadmath.h`

header any more. This change greatly improves mp++’s compatibility with Clang when the`MPPP_WITH_QUADMATH`

option is active (#206). - Continue moving code into the compiled library (#204, #206).
- Enable the C++20 concept declaration syntax if GCC >= 9 is being used (#203).

- Expose the hyperbolic functions from the MPFR API
for
`real`

(#184). - Add the possibility of generating Unicode MSVC solutions (#183).
- Finish exposing all the trigonometric functions from the MPFR API
for
`real`

(#180). - Add the possibility to build mp++ as a static library (#176).
- Add CircleCI to the continuous integration pipeline (#173).
- Implement the logarithm/exponential functions for
`real`

(#172).

- When compiled with MPFR version 4 or later, mp++ now ensures that thread-local and global caches are freed separately at thread exit and program shutdown (#182).
- Update the internal copy of Catch to the latest version, 2.7.2 (#181).
- The MPFR cleanup function
`mpfr_free_cache()`

is now called at the end of every thread which creates at least one`real`

object (#180). - Implement a specialised version of the
`swap()`

primitive for`integer`

and`rational`

(#174). - Improve the implementation of the less than/greater than operators for
`integer`

. Together with the`swap()`

improvements, this change leads to a ~9% decrease in runtime for the`integer1_sort_signed`

benchmark (#174). - Continue moving code from the headers into the compiled library (#170, #172).

- The
`type_name()`

function is now part of the public API (#169). `integer`

and`rational`

now respect the format flags in output streams (#161).

- mp++ does not depend on the DbgHelp library on Windows any more (#169).
**BREAKING**: mp++ has now a compiled component. In order to use mp++, you will now have to both include the mp++ headers**and**link to the mp++ library (#169).- Various improvements to the benchmarks (#166).
**BREAKING**: the input stream operators have been removed from all classes (#161).

- Initialising a
`real`

with an invalid`real_kind`

enum value now raises an exception, rather than initialising to NaN (#153). - Switch to the sphinx material design theme for the documentation (#153).
- Update the internal copy of Catch to the latest version, 2.4.0 (#152).
- Various improvements to the GCD implementation for
`integer`

(#150). - The addition/subtraction operators of
`integer`

now use the low-level`add_ui()`

,`add_si()`

,`sub_ui()`

and`sub_si()`

primitives when the other argument is a C++ integral (#147). - Various documentation additions, improvements and fixes (#146, #148, #149, #153, #155).
**BREAKING**: replace the`integer_nbits_init`

tag structure with the strongly-typed`mppp::integer_bitcnt_t`

enum (#145).- Ensure that
`real128`

is trivially copyable (#144).

- Add a target in the build system to compile and run the benchmarks (#135).
- Extend the
`add_ui()`

and`sub_ui()`

functions to work on all unsigned C++ integral types, and introduce corresponding`add_si()`

and`sub_si()`

functions for signed C++ integral types (#131). - Initial version of the rational tutorial (#130).
- The demangler is now aware of cv-qualifiers and references (#129).

- The
`mppp::string_type`

concept is now satisfied by cv qualified types as well (#127). - Add a leading
`mppp::`

to the names of mp++’s classes in the pybind11 custom type casters (#120). This should be only a cosmetic change. - Update the internal copy of Catch to the latest version, 2.1.1 (#120).
- Small tweaks/improvements to the build system and to the docs (#118, #120, #121, #124, #126).

- Add a function to check if a
`real`

is equal to one (#117). - The pybind11 integration utilities now automatically translate mp++ exceptions into appropriate Python exceptions (#115).
- Expose various internal type traits in the public API (#114).
- Add an implementation of the binomial coefficient for rational top arguments (#113).

- When C++ concepts are enabled, various functions now use automatically-deduced return types to simplify the implementation and improve the generated documentation (#114).
- In the CMake config-file package produced by the installation process, ensure that the installed package version is considered compatible with any other version with the same major version number (#113).

- Implement the initial version of the binary serialisation API (#110).
- Add builds based on MSVC 2017 in Appveyor (#110).
- Extend the
`mppp::CppInteroperable`

concept to include all C++ integral types (#104). - Add left bit shift benchmarks for
`integer`

(#103). - Implement division without remainder (
`tdiv_q()`

) and exact division with positive divisor (`divexact_gcd()`

) for`integer`

(#103). - Implement the
`trunc()`

and`integer_p()`

primitives for`real`

(#102). - Implement the
`free_integer_caches()`

function to manually free the caches used internally by`integer`

(#98).

- Update copyright date (#110).
- Various updates to the documentation and to the benchmarks (#107, #108).
- Add an internal demangling utility to improve the quality of the error messages (#105).
- Various performance improvements for
`integer`

division, fused multiply-add, left bit shift, addition and multiplication (#103, #106, #108). - Improve the detection of the availability of the
`thread_local`

keyword on recent Xcode versions (#99).

- Implement additional
`get()`

conversion functions for`real128`

(#96). - Implement the increment and decrement operators for
`rational`

(#95). - Implement support for
`__int128_t`

and`__uint128_t`

(#90). - Implement the bitwise logic operators for
`integer`

(#86). - Initial implementation of the pybind11 integration utilities (#81).
- Implement the
`frexp()`

primitive for`real128`

(#81). - Implement the
`get/set_z_2exp()`

primitives for`real`

(#77). - Implement construction with preallocated storage for
`integer`

(#74). - Implement construction from an array of limbs for
`integer`

(#73).

- Various additions to the tutorial (#97).
**BREAKING**: the imported target created by the installation process has been renamed from`Mp++`

to`mp++`

(#94).- Take advantage of
`std::gcd()`

on C++17 (#93). - Update the benchmark results for
`integer`

(#91). - Add division benchmarks for
`integer`

(#91). - A few performance tweaks for
`integer`

(#91). - Simplifications in the bit shifting primitives for
`integer`

(#85). - Split an
`integer`

test in two parts to curb memory usage during compilation (#80). - Use bit counting intrinsics in MSVC (#79).
- Update the internal copy of Catch to the latest version, 2.0.1 (#76).
- Improve the performance of generic assignment for
`integer`

(#74). - Improve construction from C++ integrals for
`integer`

(#74).

- Implement the
`real`

class (#40). - Add non-throwing GMP-style conversion functions (#59, #61).
- Implement move constructors and move assignment operators from
`mpz_t`

and`mpq_t`

for`integer`

and`rational`

(#57). - Implement a cache for the allocation of limbs arrays in small
`integer`

objects (#55). - Implement the
`real128`

class (#31). - Implement the
`sub_ui()`

primitive for`integer`

(#37). - Add a CI build testing against the latest unstable GMP branch (#34).
- Add assignment operators from
`std::string_view`

for`integer`

and`rational`

(#32). - Add the possibility of constructing non-canonical
`rational`

objects from numerator/denominator pairs (#28).

- Use the sphinx bootstrap theme for the html documentation (#71).
- Various simplifications in the
`rational`

API (#66). - Introduce a
`string_type`

concept and use it to reduce the number of overloads in the constructors/assignment operators from string (#63, #64). - The
`integer`

functions accepting the return value as a parameter will now demote a return value with dynamic storage to static storage if the other arguments all have static storage (#58). - The free functions for
`integer`

and`rational`

now return a reference to the return value, rather than`void`

(#56). - Performance improvements and code simplifications for
`integer`

division (#55). - Minor improvements in the static checks for the expected layouts of
`mpz_t`

and`mpq_t`

(#53, #42). - Enable additional compiler warning flags in debug builds for GCC (#52).
**BREAKING**: various improvements/changes to the bit shifting functions for`integer`

, and the exception raised by the bit shifting operators is not any more`std::domain_error`

, it is now`std::overflow_error`

(#48).- Various updates to the benchmarks (#39).
- Use various C++17 standard library bits if available, and improve general C++17 compatibility (#31, #37).
- Update the internal copy of Catch to the latest version, 1.9.7 (#36).
- Bump up the minimum required CMake version to 3.3 (#31).
- Performance improvements and simplifications in the
`rational`

constructors and assignment operators (#28, #32).

- Fixes/improvements in the support for
`long double`

(#50, #54). - Fix the compilation of the tests on Clang 5 (#43).
- Fix too lax constraints in the implementation of in-place operators for
`integer`

and`rational`

(#41). - Fix the PDF build of the documentation (#39).
- Fix a few missing
`inline`

specifiers (#38, #41). - Fix C++ version detection on MSVC (#36).
- Fix missing tests for
`rational`

hashing (#29). - Fix some MSVC warnings when compiling the tests in release mode (#28).
- Various minor documentation fixes.

- Expand CI to include GCC 7 in C++17 mode (#27).
- Improve testing coverage (#25).
- Various extensions to the benchmark suite (#25).
- Various performance improvements in
`integer`

thanks to the reduction of the number of branches in the implementation of basic arithmetic for the 1/2-limb specialisations (#25). - Update the internal copy of Catch to the latest version, 1.9.6 (#24).
- Performance improvements for
`mppp::integer::size()`

(#23). - Performance improvements for the construction/conversion of
`integer`

from/to C++ integrals (#23). - Make sure the MPFR cleanup routine is automatically called on shutdown (#22).
- Performance improvements for
`mppp::integer::nbits()`

on GCC and Clang (#17).

- Implement the multiprecision
`rational`

class (#14). - Implement fast assignment functions to zero and plus/minus one for
`integer`

. - Add assignment operators from string for
`integer`

. - Implement the
`submul()`

primitive for`integer`

. - Implement the assignment operator from
`mpz_t`

in`integer`

, and use it in various function in order to avoid the creation of a temporary.

- Various small documentation fixes.

- Provide a CMake config-file package as part of the install process.
- Implement the missing in-place modulo operator with C++ integrals on the left.
- Experimental support for C++ concepts.
- Support the
`clang-cl`

compiler on Windows. - Add input stream operator.
- Add in-place arithmetic operators with interoperable types on the left-hand side.
- Add convenience overloads for the computation of the binomial coefficient.
- Add convenience overloads for
`pow()`

. - Add functions to test if an integer is equal to -1.
- Add a static member to
`integer`

storing the static size.

- Split out the library in multiple files.
- Rename the
`mp_integer`

class to`integer`

. - Various improvements to the documentation.
- Rework the library interface to use regular functions rather than
`inline friend`

functions. - Change the license to MPL2.
- Remove the allocation cache.
- Remove the custom namespace option.

- Fix operators example in the documentation.