libs/multiprecision/test/skeleton_backend.hpp
/////////////////////////////////////////////////////////////// // Copyright 2020 John Maddock. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt #ifndef BOOST_MATH_SKELETON_BACKEND_HPP #define BOOST_MATH_SKELETON_BACKEND_HPP #include <boost/multiprecision/number.hpp> #include <boost/container_hash/hash.hpp> namespace boost { namespace multiprecision { namespace backends { /* This header defines one type - skeleton_backend - which declares the minimal interface to qualify as a backend for class number. In addition you'll find optional interfaces declared commented out - you can enable these or not as needed. The process of writing a new backend for class number then reduces to a search and replace to change the name of this class to something meaningful, followed by "filling in the blanks" of each of the methods. NOTE: all of the methods shown below are simple declarations, be sure to make them inline, constexpr and/or noexcept as appropriate - as these annotations propogate upwards to operations on number<>'s. If the backend is to be itself a template, thn you will have rather more editing to do to add all the "template<...>" prefixes to the functions. */ struct skeleton_backend { // // Each backend need to declare 3 type lists which declare the types // with which this can interoperate. These lists must at least contain // the widest type in each category - so "long long" must be the final // type in the signed_types list for example. Any narrower types if not // present in the list will get promoted to the next wider type that is // in the list whenever mixed arithmetic involving that type is encountered. // typedef std::tuple</*signed char, short, int, long,*/ long long> signed_types; typedef std::tuple</* unsigned char, unsigned short, unsigned, unsigned long,*/ unsigned long long> unsigned_types; typedef std::tuple</*float, double,*/ long double> float_types; // // This typedef is only required if this is a floating point type, it is the type // which holds the exponent: // typedef int exponent_type; // We must have a default constructor: skeleton_backend(); skeleton_backend(const skeleton_backend& o); skeleton_backend(skeleton_backend&& o); // Optional constructors, we can make this type slightly more efficient // by providing constructors from any type we can handle natively. // These will also cause number<> to be implicitly constructible // from these types unless we make such constructors explicit. // // skeleton_backend(int o); // If there's an efficient initialisation from int for example. // // In the absense of converting constructors, operator= takes the strain. // In addition to the usual suspects, there must be one operator= for each type // listed in signed_types, unsigned_types, and float_types plus a string constructor. // skeleton_backend& operator=(const skeleton_backend& o); skeleton_backend& operator=(skeleton_backend&& o); skeleton_backend& operator=(unsigned long long i); skeleton_backend& operator=(long long i); skeleton_backend& operator=(long double i); skeleton_backend& operator=(const char* s); void swap(skeleton_backend& o); std::string str(std::streamsize digits, std::ios_base::fmtflags f) const; void negate(); int compare(const skeleton_backend& o) const; // // Comparison with arithmetic types, default just constructs a temporary: // template <class A> typename std::enable_if<boost::multiprecision::detail::is_arithmetic<A>::value, int>::type compare(A i) const { skeleton_backend t; t = i; // Note: construct directly from i if supported. return compare(t); } }; // // Required non-members: // void eval_add(skeleton_backend& a, const skeleton_backend& b); void eval_subtract(skeleton_backend& a, const skeleton_backend& b); void eval_multiply(skeleton_backend& a, const skeleton_backend& b); void eval_divide(skeleton_backend& a, const skeleton_backend& b); // // Required only for integer types: // void eval_modulus(skeleton_backend& a, const skeleton_backend& b); void eval_bitwise_and(skeleton_backend& a, const skeleton_backend& b); void eval_bitwise_or(skeleton_backend& a, const skeleton_backend& b); void eval_bitwise_xor(skeleton_backend& a, const skeleton_backend& b); void eval_complement(skeleton_backend& a, const skeleton_backend& b); void eval_left_shift(skeleton_backend& a, unsigned shift); void eval_right_shift(skeleton_backend& a, unsigned shift); // // Conversions: must include at least unsigned long long, long long and long double. // Everything else is entirely optional: // void eval_convert_to(unsigned long long* result, const skeleton_backend& backend); void eval_convert_to(long long* result, const skeleton_backend& backend); void eval_convert_to(long double* result, const skeleton_backend& backend); //void eval_convert_to(unsigned long* result, const skeleton_backend& backend); //void eval_convert_to(unsigned* result, const skeleton_backend& backend); //void eval_convert_to(unsigned short* result, const skeleton_backend& backend); //void eval_convert_to(unsigned char* result, const skeleton_backend& backend); //void eval_convert_to(char* result, const skeleton_backend& backend); //void eval_convert_to(long* result, const skeleton_backend& backend); //void eval_convert_to(int* result, const skeleton_backend& backend); //void eval_convert_to(short* result, const skeleton_backend& backend); //void eval_convert_to(signed char* result, const skeleton_backend& backend); //void eval_convert_to(double* result, const skeleton_backend& backend); //void eval_convert_to(float* result, const skeleton_backend& backend); // // Operations which are required *only* if we have a floating point type: // void eval_frexp(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type* p_exponent); void eval_frexp(skeleton_backend& result, const skeleton_backend& arg, int* p_exponent); // throws a runtime_error if the exponent is too large for an int void eval_ldexp(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type exponent); void eval_ldexp(skeleton_backend& result, const skeleton_backend& arg, int exponent); void eval_floor(skeleton_backend& result, const skeleton_backend& arg); void eval_ceil(skeleton_backend& result, const skeleton_backend& arg); void eval_sqrt(skeleton_backend& result, const skeleton_backend& arg); // // Operations defined *only* if we have a complex number type, type // skeleton_real_type is assumed to be the real number type matching // this type. // void eval_conj(skeleton_backend& result, const skeleton_backend& arg); void eval_proj(skeleton_backend& result, const skeleton_backend& arg); //void eval_real(skeleton_real_type& result, const skeleton_backend& arg); //void eval_set_real(skeleton_real_type& result, const skeleton_backend& arg); //void eval_imag(skeleton_real_type& result, const skeleton_backend& arg); //void eval_set_real(skeleton_type& result, const skeleton_real_type& arg); //void eval_set_imag(skeleton_type& result, const skeleton_real_type& arg); // // Hashing support, not strictly required, but it is used in our tests: // std::size_t hash_value(const skeleton_backend& arg); // // We're now into strictly optional requirements, everything that follows is // nice to have, but can be synthesised from the operators above if required. // Typically these operations are here to improve performance and reduce the // number of temporaries created. // // assign_components: required number types with 2 seperate components (rationals and complex numbers). // Type skeleton_component_type is whatever the corresponding backend type for the components is: // //void assign_conponents(skeleton_backend& result, skeleton_component_type const& a, skeleton_component_type const& b); // // Again for arithmetic types, overload for whatever arithmetic types are directly supported: // //void assign_conponents(skeleton_backend& result, double a, double b); // // Optional comparison operators: // #if 0 bool eval_is_zero(const skeleton_backend& arg); int eval_get_sign(const skeleton_backend& arg); bool eval_eq(const skeleton_backend& a, const skeleton_backend& b); bool eval_eq(const skeleton_backend& a, unsigned long long b); bool eval_eq(const skeleton_backend& a, unsigned long b); bool eval_eq(const skeleton_backend& a, unsigned b); bool eval_eq(const skeleton_backend& a, unsigned short b); bool eval_eq(const skeleton_backend& a, unsigned char b); bool eval_eq(const skeleton_backend& a, long long b); bool eval_eq(const skeleton_backend& a, long b); bool eval_eq(const skeleton_backend& a, int b); bool eval_eq(const skeleton_backend& a, short b); bool eval_eq(const skeleton_backend& a, signed char b); bool eval_eq(const skeleton_backend& a, char b); bool eval_eq(const skeleton_backend& a, long double b); bool eval_eq(const skeleton_backend& a, double b); bool eval_eq(const skeleton_backend& a, float b); bool eval_eq(unsigned long long a, const skeleton_backend& b); bool eval_eq(unsigned long a, const skeleton_backend& b); bool eval_eq(unsigned a, const skeleton_backend& b); bool eval_eq(unsigned short a, const skeleton_backend& b); bool eval_eq(unsigned char a, const skeleton_backend& b); bool eval_eq(long long a, const skeleton_backend& b); bool eval_eq(long a, const skeleton_backend& b); bool eval_eq(int a, const skeleton_backend& b); bool eval_eq(short a, const skeleton_backend& b); bool eval_eq(signed char a, const skeleton_backend& b); bool eval_eq(char a, const skeleton_backend& b); bool eval_eq(long double a, const skeleton_backend& b); bool eval_eq(double a, const skeleton_backend& b); bool eval_eq(float a, const skeleton_backend& b); bool eval_lt(const skeleton_backend& a, const skeleton_backend& b); bool eval_lt(const skeleton_backend& a, unsigned long long b); bool eval_lt(const skeleton_backend& a, unsigned long b); bool eval_lt(const skeleton_backend& a, unsigned b); bool eval_lt(const skeleton_backend& a, unsigned short b); bool eval_lt(const skeleton_backend& a, unsigned char b); bool eval_lt(const skeleton_backend& a, long long b); bool eval_lt(const skeleton_backend& a, long b); bool eval_lt(const skeleton_backend& a, int b); bool eval_lt(const skeleton_backend& a, short b); bool eval_lt(const skeleton_backend& a, signed char b); bool eval_lt(const skeleton_backend& a, char b); bool eval_lt(const skeleton_backend& a, long double b); bool eval_lt(const skeleton_backend& a, double b); bool eval_lt(const skeleton_backend& a, float b); bool eval_lt(unsigned long long a, const skeleton_backend& b); bool eval_lt(unsigned long a, const skeleton_backend& b); bool eval_lt(unsigned a, const skeleton_backend& b); bool eval_lt(unsigned short a, const skeleton_backend& b); bool eval_lt(unsigned char a, const skeleton_backend& b); bool eval_lt(long long a, const skeleton_backend& b); bool eval_lt(long a, const skeleton_backend& b); bool eval_lt(int a, const skeleton_backend& b); bool eval_lt(short a, const skeleton_backend& b); bool eval_lt(signed char a, const skeleton_backend& b); bool eval_lt(char a, const skeleton_backend& b); bool eval_lt(long double a, const skeleton_backend& b); bool eval_lt(double a, const skeleton_backend& b); bool eval_lt(float a, const skeleton_backend& b); bool eval_gt(const skeleton_backend& a, const skeleton_backend& b); bool eval_gt(const skeleton_backend& a, unsigned long long b); bool eval_gt(const skeleton_backend& a, unsigned long b); bool eval_gt(const skeleton_backend& a, unsigned b); bool eval_gt(const skeleton_backend& a, unsigned short b); bool eval_gt(const skeleton_backend& a, unsigned char b); bool eval_gt(const skeleton_backend& a, long long b); bool eval_gt(const skeleton_backend& a, long b); bool eval_gt(const skeleton_backend& a, int b); bool eval_gt(const skeleton_backend& a, short b); bool eval_gt(const skeleton_backend& a, signed char b); bool eval_gt(const skeleton_backend& a, char b); bool eval_gt(const skeleton_backend& a, long double b); bool eval_gt(const skeleton_backend& a, double b); bool eval_gt(const skeleton_backend& a, float b); bool eval_gt(unsigned long long a, const skeleton_backend& b); bool eval_gt(unsigned long a, const skeleton_backend& b); bool eval_gt(unsigned a, const skeleton_backend& b); bool eval_gt(unsigned short a, const skeleton_backend& b); bool eval_gt(unsigned char a, const skeleton_backend& b); bool eval_gt(long long a, const skeleton_backend& b); bool eval_gt(long a, const skeleton_backend& b); bool eval_gt(int a, const skeleton_backend& b); bool eval_gt(short a, const skeleton_backend& b); bool eval_gt(signed char a, const skeleton_backend& b); bool eval_gt(char a, const skeleton_backend& b); bool eval_gt(long double a, const skeleton_backend& b); bool eval_gt(double a, const skeleton_backend& b); bool eval_gt(float a, const skeleton_backend& b); #endif // // Arithmetic operations, starting with addition: // #if 0 void eval_add(skeleton_backend& result, unsigned long long arg); void eval_add(skeleton_backend& result, unsigned long arg); void eval_add(skeleton_backend& result, unsigned arg); void eval_add(skeleton_backend& result, unsigned short arg); void eval_add(skeleton_backend& result, unsigned char arg); void eval_add(skeleton_backend& result, char arg); void eval_add(skeleton_backend& result, long long arg); void eval_add(skeleton_backend& result, long arg); void eval_add(skeleton_backend& result, int arg); void eval_add(skeleton_backend& result, short arg); void eval_add(skeleton_backend& result, signed char arg); void eval_add(skeleton_backend& result, long double arg); void eval_add(skeleton_backend& result, double arg); void eval_add(skeleton_backend& result, float arg); void eval_add(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_add(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_add(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_add(skeleton_backend& result, const skeleton_backend& a, long b); void eval_add(skeleton_backend& result, const skeleton_backend& a, int b); void eval_add(skeleton_backend& result, const skeleton_backend& a, short b); void eval_add(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_add(skeleton_backend& result, const skeleton_backend& a, char b); void eval_add(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_add(skeleton_backend& result, const skeleton_backend& a, double b); void eval_add(skeleton_backend& result, const skeleton_backend& a, float b); void eval_add(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_add(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_add(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_add(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_add(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_add(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_add(skeleton_backend& result, long b, const skeleton_backend& a); void eval_add(skeleton_backend& result, int b, const skeleton_backend& a); void eval_add(skeleton_backend& result, short b, const skeleton_backend& a); void eval_add(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_add(skeleton_backend& result, char b, const skeleton_backend& a); void eval_add(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_add(skeleton_backend& result, double b, const skeleton_backend& a); void eval_add(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // Subtraction: // #if 0 void eval_subtract(skeleton_backend& result, unsigned long long arg); void eval_subtract(skeleton_backend& result, unsigned long arg); void eval_subtract(skeleton_backend& result, unsigned arg); void eval_subtract(skeleton_backend& result, unsigned short arg); void eval_subtract(skeleton_backend& result, unsigned char arg); void eval_subtract(skeleton_backend& result, char arg); void eval_subtract(skeleton_backend& result, long long arg); void eval_subtract(skeleton_backend& result, long arg); void eval_subtract(skeleton_backend& result, int arg); void eval_subtract(skeleton_backend& result, short arg); void eval_subtract(skeleton_backend& result, signed char arg); void eval_subtract(skeleton_backend& result, long double arg); void eval_subtract(skeleton_backend& result, double arg); void eval_subtract(skeleton_backend& result, float arg); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, int b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, short b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, char b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, double b); void eval_subtract(skeleton_backend& result, const skeleton_backend& a, float b); void eval_subtract(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, long b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, int b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, short b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, char b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, double b, const skeleton_backend& a); void eval_subtract(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // Multiplication: // #if 0 void eval_multiply(skeleton_backend& result, unsigned long long arg); void eval_multiply(skeleton_backend& result, unsigned long arg); void eval_multiply(skeleton_backend& result, unsigned arg); void eval_multiply(skeleton_backend& result, unsigned short arg); void eval_multiply(skeleton_backend& result, unsigned char arg); void eval_multiply(skeleton_backend& result, char arg); void eval_multiply(skeleton_backend& result, long long arg); void eval_multiply(skeleton_backend& result, long arg); void eval_multiply(skeleton_backend& result, int arg); void eval_multiply(skeleton_backend& result, short arg); void eval_multiply(skeleton_backend& result, signed char arg); void eval_multiply(skeleton_backend& result, long double arg); void eval_multiply(skeleton_backend& result, double arg); void eval_multiply(skeleton_backend& result, float arg); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, int b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, short b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, char b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, double b); void eval_multiply(skeleton_backend& result, const skeleton_backend& a, float b); void eval_multiply(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, long b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, int b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, short b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, char b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, double b, const skeleton_backend& a); void eval_multiply(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // Division: // #if 0 void eval_divide(skeleton_backend& result, unsigned long long arg); void eval_divide(skeleton_backend& result, unsigned long arg); void eval_divide(skeleton_backend& result, unsigned arg); void eval_divide(skeleton_backend& result, unsigned short arg); void eval_divide(skeleton_backend& result, unsigned char arg); void eval_divide(skeleton_backend& result, char arg); void eval_divide(skeleton_backend& result, long long arg); void eval_divide(skeleton_backend& result, long arg); void eval_divide(skeleton_backend& result, int arg); void eval_divide(skeleton_backend& result, short arg); void eval_divide(skeleton_backend& result, signed char arg); void eval_divide(skeleton_backend& result, long double arg); void eval_divide(skeleton_backend& result, double arg); void eval_divide(skeleton_backend& result, float arg); void eval_divide(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, long b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, int b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, short b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, char b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, double b); void eval_divide(skeleton_backend& result, const skeleton_backend& a, float b); void eval_divide(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, long b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, int b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, short b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, char b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, double b, const skeleton_backend& a); void eval_divide(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // Multiply and add/subtract as one: // #if 0 void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, int b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, short b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, char b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, double b); void eval_multiply_add(skeleton_backend& result, const skeleton_backend& a, float b); void eval_multiply_add(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, long b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, int b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, short b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, char b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, double b, const skeleton_backend& a); void eval_multiply_add(skeleton_backend& result, float b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, int b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, short b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, char b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, double b); void eval_multiply_subtract(skeleton_backend& result, const skeleton_backend& a, float b); void eval_multiply_subtract(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, long b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, int b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, short b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, char b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, double b, const skeleton_backend& a); void eval_multiply_subtract(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // Increment and decrement: // //void eval_increment(skeleton_backend& arg); //void eval_decrement(skeleton_backend& arg); // // abs/fabs: // // void eval_abs(skeleton_backend& result, const skeleton_backend& arg); // void eval_fabs(skeleton_backend& result, const skeleton_backend& arg); // // // Now operations on Integer types, starting with modulus: // #if 0 void eval_modulus(skeleton_backend& result, unsigned long long arg); void eval_modulus(skeleton_backend& result, unsigned long arg); void eval_modulus(skeleton_backend& result, unsigned arg); void eval_modulus(skeleton_backend& result, unsigned short arg); void eval_modulus(skeleton_backend& result, unsigned char arg); void eval_modulus(skeleton_backend& result, char arg); void eval_modulus(skeleton_backend& result, long long arg); void eval_modulus(skeleton_backend& result, long arg); void eval_modulus(skeleton_backend& result, int arg); void eval_modulus(skeleton_backend& result, short arg); void eval_modulus(skeleton_backend& result, signed char arg); void eval_modulus(skeleton_backend& result, long double arg); void eval_modulus(skeleton_backend& result, double arg); void eval_modulus(skeleton_backend& result, float arg); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, int b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, short b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, char b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, double b); void eval_modulus(skeleton_backend& result, const skeleton_backend& a, float b); void eval_modulus(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, long b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, int b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, short b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, char b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, double b, const skeleton_backend& a); void eval_modulus(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // bitwise AND: // #if 0 void eval_bitwise_and(skeleton_backend& result, unsigned long long arg); void eval_bitwise_and(skeleton_backend& result, unsigned long arg); void eval_bitwise_and(skeleton_backend& result, unsigned arg); void eval_bitwise_and(skeleton_backend& result, unsigned short arg); void eval_bitwise_and(skeleton_backend& result, unsigned char arg); void eval_bitwise_and(skeleton_backend& result, char arg); void eval_bitwise_and(skeleton_backend& result, long long arg); void eval_bitwise_and(skeleton_backend& result, long arg); void eval_bitwise_and(skeleton_backend& result, int arg); void eval_bitwise_and(skeleton_backend& result, short arg); void eval_bitwise_and(skeleton_backend& result, signed char arg); void eval_bitwise_and(skeleton_backend& result, long double arg); void eval_bitwise_and(skeleton_backend& result, double arg); void eval_bitwise_and(skeleton_backend& result, float arg); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, int b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, short b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, char b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, double b); void eval_bitwise_and(skeleton_backend& result, const skeleton_backend& a, float b); void eval_bitwise_and(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, long b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, int b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, short b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, char b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, double b, const skeleton_backend& a); void eval_bitwise_and(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // bitwise OR: // #if 0 void eval_bitwise_or(skeleton_backend& result, unsigned long long arg); void eval_bitwise_or(skeleton_backend& result, unsigned long arg); void eval_bitwise_or(skeleton_backend& result, unsigned arg); void eval_bitwise_or(skeleton_backend& result, unsigned short arg); void eval_bitwise_or(skeleton_backend& result, unsigned char arg); void eval_bitwise_or(skeleton_backend& result, char arg); void eval_bitwise_or(skeleton_backend& result, long long arg); void eval_bitwise_or(skeleton_backend& result, long arg); void eval_bitwise_or(skeleton_backend& result, int arg); void eval_bitwise_or(skeleton_backend& result, short arg); void eval_bitwise_or(skeleton_backend& result, signed char arg); void eval_bitwise_or(skeleton_backend& result, long double arg); void eval_bitwise_or(skeleton_backend& result, double arg); void eval_bitwise_or(skeleton_backend& result, float arg); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, int b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, short b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, char b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, double b); void eval_bitwise_or(skeleton_backend& result, const skeleton_backend& a, float b); void eval_bitwise_or(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, long b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, int b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, short b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, char b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, double b, const skeleton_backend& a); void eval_bitwise_or(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // bitwise XOR: // #if 0 void eval_bitwise_xor(skeleton_backend& result, unsigned long long arg); void eval_bitwise_xor(skeleton_backend& result, unsigned long arg); void eval_bitwise_xor(skeleton_backend& result, unsigned arg); void eval_bitwise_xor(skeleton_backend& result, unsigned short arg); void eval_bitwise_xor(skeleton_backend& result, unsigned char arg); void eval_bitwise_xor(skeleton_backend& result, char arg); void eval_bitwise_xor(skeleton_backend& result, long long arg); void eval_bitwise_xor(skeleton_backend& result, long arg); void eval_bitwise_xor(skeleton_backend& result, int arg); void eval_bitwise_xor(skeleton_backend& result, short arg); void eval_bitwise_xor(skeleton_backend& result, signed char arg); void eval_bitwise_xor(skeleton_backend& result, long double arg); void eval_bitwise_xor(skeleton_backend& result, double arg); void eval_bitwise_xor(skeleton_backend& result, float arg); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, int b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, short b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, char b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, double b); void eval_bitwise_xor(skeleton_backend& result, const skeleton_backend& a, float b); void eval_bitwise_xor(skeleton_backend& result, unsigned long long b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, unsigned long b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, unsigned b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, unsigned short b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, unsigned char b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, long long b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, long b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, int b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, short b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, signed char b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, char b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, long double b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, double b, const skeleton_backend& a); void eval_bitwise_xor(skeleton_backend& result, float b, const skeleton_backend& a); #endif // // left and right shift: // //void eval_left_shift(skeleton_backend& result, const skeleton_backend& arg, std::size_t shift); //void eval_right_shift(skeleton_backend& result, const skeleton_backend& arg, std::size_t shift); // // Quotient and remainder: // // void eval_qr(const skeleton_backend& numerator, const skeleton_backend& denominator, skeleton_backend& quotient, skeleteon_backend& remainder); // // Misc integer ops: // // unsigned long long eval_integer_modulus(const skeleton_backend& arg, unsigned long long modulus); // unsigned long eval_integer_modulus(const skeleton_backend& arg, unsigned long modulus); // unsigned eval_integer_modulus(const skeleton_backend& arg, unsigned modulus); // unsigned short eval_integer_modulus(const skeleton_backend& arg, unsigned short modulus); // unsigned char eval_integer_modulus(const skeleton_backend& arg, unsigned char modulus); // // std::size_t eval_lsb(const skeleton_backend& arg); // std::size_t eval_msb(const skeleton_backend& arg); // bool eval_bit_test(const skeleton_backend& arg, std::size_t bit); // void eval_bit_set(const skeleton_backend& arg, std::size_t bit); // void eval_bit_unset(const skeleton_backend& arg, std::size_t bit); // void eval_bit_flip(const skeleton_backend& arg, std::size_t bit); // // GCD/LCD: // #if 0 void eval_gcd(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, long b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, int b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, short b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_gcd(skeleton_backend& result, const skeleton_backend& a, char b); void eval_gcd(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, unsigned long a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, unsigned a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, unsigned short a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, unsigned char a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, long long a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, long a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, int a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, short a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, signed char a, const skeleton_backend& b); void eval_gcd(skeleton_backend& result, char a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, long b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, int b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, short b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_lcm(skeleton_backend& result, const skeleton_backend& a, char b); void eval_lcm(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, unsigned long a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, unsigned a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, unsigned short a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, unsigned char a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, long long a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, long a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, int a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, short a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, signed char a, const skeleton_backend& b); void eval_lcm(skeleton_backend& result, char a, const skeleton_backend& b); #endif // // Modular exponentiation: // #if 0 void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, const skeleton_backend& c); // a^b % c void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned long long c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned long c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned short c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, unsigned char c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, long long c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, long c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, int c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, short c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, signed char c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned short b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned char b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, long long b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, long b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, int b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, short b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, signed char b, const skeleton_backend& c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, unsigned long long c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned long b, unsigned long c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned b, unsigned c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned short b, unsigned short c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, unsigned char b, unsigned char c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, long long b, long long c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, long b, long c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, int b, int c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, short b, short c); void eval_powm(skeleton_backend& result, const skeleton_backend& a, signed char b, signed char c); #endif // // Integer sqrt: // // void eval_integer_sqrt(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend& remainder); /********************************************************************************************* FLOATING POINT FUNCTIONS ***********************************************************************************************/ #if 0 int eval_fpclassify(const skeleton_backend& arg); void eval_trunc(skeleton_backend& result, const skeleton_backend& arg); void eval_round(skeleton_backend& result, const skeleton_backend& arg); void eval_exp(skeleton_backend& result, const skeleton_backend& arg); void eval_exp2(skeleton_backend& result, const skeleton_backend& arg); void eval_log(skeleton_backend& result, const skeleton_backend& arg); void eval_log10(skeleton_backend& result, const skeleton_backend& arg); void eval_sin(skeleton_backend& result, const skeleton_backend& arg); void eval_cos(skeleton_backend& result, const skeleton_backend& arg); void eval_tan(skeleton_backend& result, const skeleton_backend& arg); void eval_asin(skeleton_backend& result, const skeleton_backend& arg); void eval_acos(skeleton_backend& result, const skeleton_backend& arg); void eval_atan(skeleton_backend& result, const skeleton_backend& arg); void eval_sinh(skeleton_backend& result, const skeleton_backend& arg); void eval_cosh(skeleton_backend& result, const skeleton_backend& arg); void eval_tanh(skeleton_backend& result, const skeleton_backend& arg); void eval_asinh(skeleton_backend& result, const skeleton_backend& arg); void eval_acosh(skeleton_backend& result, const skeleton_backend& arg); void eval_atanh(skeleton_backend& result, const skeleton_backend& arg); void eval_fmod(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_modf(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_pow(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_atan2(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_scalbn(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type e); void eval_scalbln(skeleton_backend& result, const skeleton_backend& arg, skeleton_backend::exponent_type e); skeleton_type::exponent_type eval_ilogb(const skeleton_backend& arg); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned long long b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned long b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned short b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, unsigned char b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long long b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, int b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, short b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, signed char b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, long double b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, double b, int* p_n); void eval_remquo(skeleton_backend& result, const skeleton_backend& a, float b, int* p_n); void eval_remquo(skeleton_backend& result, unsigned long long a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, unsigned long a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, unsigned a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, unsigned short a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, unsigned char a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, long long a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, long a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, int a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, short a, const skeleton_backend& b, int* p_n); void eval_remquo(skeleton_backend& result, signed char a, const skeleton_backend& b, int* p_n); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, int b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, short b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, double b); void eval_remainder(skeleton_backend& result, const skeleton_backend& a, float b); void eval_remainder(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, unsigned long a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, unsigned a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, unsigned short a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, unsigned char a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, long long a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, long a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, int a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, short a, const skeleton_backend& b); void eval_remainder(skeleton_backend& result, signed char a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, int b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, short b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, double b); void eval_fdim(skeleton_backend& result, const skeleton_backend& a, float b); void eval_fdim(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, unsigned long a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, unsigned a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, unsigned short a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, unsigned char a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, long long a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, long a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, int a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, short a, const skeleton_backend& b); void eval_fdim(skeleton_backend& result, signed char a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, int b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, short b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, double b); void eval_fmax(skeleton_backend& result, const skeleton_backend& a, float b); void eval_fmax(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, unsigned long a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, unsigned a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, unsigned short a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, unsigned char a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, long long a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, long a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, int a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, short a, const skeleton_backend& b); void eval_fmax(skeleton_backend& result, signed char a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, int b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, short b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, double b); void eval_fmin(skeleton_backend& result, const skeleton_backend& a, float b); void eval_fmin(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, unsigned long a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, unsigned a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, unsigned short a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, unsigned char a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, long long a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, long a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, int a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, short a, const skeleton_backend& b); void eval_fmin(skeleton_backend& result, signed char a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned long long b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned long b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned short b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, unsigned char b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long long b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, int b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, short b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, signed char b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, long double b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, double b); void eval_hypot(skeleton_backend& result, const skeleton_backend& a, float b); void eval_hypot(skeleton_backend& result, unsigned long long a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, unsigned long a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, unsigned a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, unsigned short a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, unsigned char a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, long long a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, long a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, int a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, short a, const skeleton_backend& b); void eval_hypot(skeleton_backend& result, signed char a, const skeleton_backend& b); void eval_logb(skeleton_backend& result, const skeleton_backend& arg); void eval_nearbtint(skeleton_backend& result, const skeleton_backend& arg); void eval_rint(skeleton_backend& result, const skeleton_backend& arg); void eval_log2(skeleton_backend& result, const skeleton_backend& arg); #endif } // namespace backends // // Import the backend into this namespace: // using boost::multiprecision::backends::skeleton_backend; // // Typedef whatever number's make use of this backend: // typedef number<skeleton_backend, et_off> skeleton_number; // // Define a category for this number type, one of: // // number_kind_integer // number_kind_floating_point // number_kind_rational // number_kind_fixed_point // number_kind_complex // template<> struct number_category<skeleton_backend > : public std::integral_constant<int, number_kind_floating_point> {}; // // These 2 traits classes are required for complex types only: // /* template <expression_template_option ExpressionTemplates> struct component_type<number<skeleton_backend, ExpressionTemplates> > { typedef number<skeleton_real_type, ExpressionTemplates> type; }; template <expression_template_option ExpressionTemplates> struct complex_result_from_scalar<number<skeleton_real_type, ExpressionTemplates> > { typedef number<skeleton_backend, ExpressionTemplates> type; }; */ /************************************************************** OVERLOADABLE FUNCTIONS - FLOATING POINT TYPES ONLY ****************************************************************/ #if 0 template <boost::multiprecision::expression_template_option ExpressionTemplates> int sign(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> int signbit(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> changesign(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> copysign(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> cbrt(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> erf(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> erfc(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> expm1(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> log1p(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> tgamma(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> lgamma(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> long lrint(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> long long llrint(const number<skeleton_backend, ExpressionTemplates>& arg); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> nextafter(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b); template <boost::multiprecision::expression_template_option ExpressionTemplates> number<skeleton_backend, ExpressionTemplates> nexttoward(const number<skeleton_backend, ExpressionTemplates>& a, const number<skeleton_backend, ExpressionTemplates>& b); #endif }} // namespace boost::multiprecision /********************************************************************************** FLOATING POINT ONLY Nice to have stuff for better integration with Boost.Math. ***********************************************************************************/ namespace boost { namespace math { namespace tools { #if 0 template <> int digits<boost::multiprecision::number<boost::multiprecision::skeleton_number> >(); template <> boost::multiprecision::mpfr_float max_value<boost::multiprecision::skeleton_number>(); template <> boost::multiprecision::mpfr_float min_value<boost::multiprecision::skeleton_number>(); #endif } // namespace tools namespace constants { namespace detail { #if 0 template <boost::multiprecision::expression_template_option ExpressionTemplates> struct constant_pi<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> > { typedef boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> result_type; // // Fixed N-digit precision, return reference to internal/cached object: // template <int N> static inline const result_type& get(const std::integral_constant<int, N>&); // // Variable precision, returns fresh result each time (unless precision is unchanged from last call): // static inline const result_type get(const std::integral_constant<int, 0>&); }; // // Plus any other constants supported natively by this type.... // #endif } // namespace detail } // namespace constants }} // namespace boost::math namespace std { template <boost::multiprecision::expression_template_option ExpressionTemplates> class numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> > { typedef boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> number_type; public: static constexpr bool is_specialized = true; static number_type(min)(); static number_type(max)(); static number_type lowest(); static constexpr int digits = 0; static constexpr int digits10 = 0; static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static number_type epsilon(); static number_type round_error(); static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static number_type infinity(); static number_type quiet_NaN(); static number_type signaling_NaN(); static number_type denorm_min(); static constexpr bool is_iec559 = false; static constexpr bool is_bounded = false; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::digits; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::digits10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_digits10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_signed; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_integer; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_exact; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::radix; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::min_exponent; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::min_exponent10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_exponent; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr int numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::max_exponent10; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_infinity; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_quiet_NaN; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_signaling_NaN; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_denorm_style numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_denorm; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::has_denorm_loss; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_iec559; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_bounded; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::is_modulo; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::traps; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr bool numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::tinyness_before; template <boost::multiprecision::expression_template_option ExpressionTemplates> constexpr float_round_style numeric_limits<boost::multiprecision::number<boost::multiprecision::skeleton_backend, ExpressionTemplates> >::round_style; } // namespace std #endif