| Home | Libraries | People | FAQ | More

#### Index

A B C D E F G H I L M N O P R S T V X Z

A

  - a

    - Introduction

    - Mixed Precision Arithmetic

    - Variable Precision Arithmetic

    - Variable-Precision Newton Evaluation

  - abs

    - number

  - acosh

    - Backend Requirements

    - number

  - add

    - Generic Integer Operations

    - Mixed Precision Arithmetic

    - number

    - TODO

  - arg

    - number

  - asinh

    - Backend Requirements

    - number

  - assign

    - number

  - atan2

    - number

  - atanh

    - Backend Requirements

    - number

B

  - Backend Requirements

    - acosh

    - asinh

    - atanh

    - cbrt

    - changesign

    - copysign

    - erf

    - erfc

    - expm1

    - lgamma

    - llrint

    - log1p

    - lrint

    - nextafter

    - nexttoward

    - sign

    - signbit

    - tgamma

  - Bit Operations

    - BOOST_MP_ASSERT

    - r

  - bits

    - Input Output

    - Rounding Rules for Conversions

    - std::numeric_limits<> constants

  - bit_flip

    - Generic Integer Operations

    - number

  - bit_set

    - Generic Integer Operations

    - Importing and Exporting Data to and from cpp_int and cpp_bin_float

    - number

  - bit_test

    - Generic Integer Operations

    - number

  - bit_unset

    - Generic Integer Operations

    - number

  - BOOST_MP_ASSERT

    - Bit Operations

    - Importing and Exporting Data to and from cpp_int and cpp_bin_float

    - std :: numeric_limits <> functions

  - BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL

    - Literal Types and constexpr Support

  - BOOST_MP_MIN_EXPONENT_DIGITS

    - Input Output

  - BOOST_MP_USE_FLOAT128

    - complex128

    - float128

  - BOOST_MP_USE_QUAD

    - complex128

    - float128

C

  - Calculating an Integral

    - cos

    - operator

  - cbrt

    - Backend Requirements

    - number

  - ceil

    - number

  - changesign

    - Backend Requirements

    - number

  - compare

    - number

  - complex128

    - BOOST_MP_USE_FLOAT128

    - BOOST_MP_USE_QUAD

  - complex_adaptor

    - complex_adaptor

    - Forward Declarations

  - component_type

    - number

  - Compulsory Requirements on the Backend type.

    - eval_modulus

  - conj

    - number

  - Constructing and Interconverting Between Number Types

    - i

  - convert_to

    - number

  - copysign

    - Backend Requirements

    - number

  - cos

    - Calculating an Integral

    - number

  - cpp_bin_float

    - cpp_bin_float

    - Forward Declarations

    - History

    - log

    - value

  - cpp_dec_float

    - log

    - TODO

  - cpp_double_fp_backend

  - cpp_int

    - cpp_int_backend

  - cpp_int_backend

    - cpp_int

    - Forward Declarations

  - cpp_rational

    - denominator

    - numerator

D

  - data

    - float128

    - gmp_float

    - gmp_int

    - gmp_rational

    - Literal Types and constexpr Support

    - mpc_complex

    - mpfi_float

    - mpfr_float

  - debug_adaptor

    - debug_adaptor

    - Forward Declarations

  - default_precision

    - number

  - Defining a Special Function

    - type

    - v

  - denominator

    - cpp_rational

    - gmp_rational

    - number

    - tommath_rational

  - digits10

    - std::numeric_limits<> constants

  - divide_qr

    - Generic Integer Operations

    - number

  - down

    - std::numeric_limits<> constants

E

  - e

    - Mixed Precision Arithmetic

  - empty

    - mpfi_float

  - erf

    - Backend Requirements

    - number

  - erfc

    - Backend Requirements

    - number

  - eval_add

    - Optional Requirements on the Backend Type

  - eval_bitwise_and

    - Optional Requirements on the Backend Type

  - eval_bitwise_or

    - Optional Requirements on the Backend Type

  - eval_bitwise_xor

    - Optional Requirements on the Backend Type

  - eval_divide

    - Optional Requirements on the Backend Type

  - eval_eq

    - Optional Requirements on the Backend Type

  - eval_gcd

    - Optional Requirements on the Backend Type

  - eval_get_sign

    - Optional Requirements on the Backend Type

  - eval_gt

    - Optional Requirements on the Backend Type

  - eval_increment

    - Optional Requirements on the Backend Type

  - eval_lcm

    - Optional Requirements on the Backend Type

  - eval_lt

    - Optional Requirements on the Backend Type

  - eval_modulus

    - Compulsory Requirements on the Backend type.

    - Optional Requirements on the Backend Type

  - eval_multiply

    - Optional Requirements on the Backend Type

  - eval_multiply_add

    - Optional Requirements on the Backend Type

  - eval_multiply_subtract

    - Optional Requirements on the Backend Type

  - eval_nearbyint

    - Optional Requirements on the Backend Type

  - eval_round

    - Optional Requirements on the Backend Type

  - eval_scalbn

    - Optional Requirements on the Backend Type

  - eval_subtract

    - Optional Requirements on the Backend Type

  - exp

    - number

    - Variable-Precision Newton Evaluation

  - expm1

    - Backend Requirements

    - number

  - export_bits

    - Importing and Exporting Data to and from cpp_int and cpp_bin_float

  - expression

    - Introduction

  - expression_template_default

    - Forward Declarations

    - number

F

  - f

    - Importing and Exporting Data to and from cpp_int and cpp_bin_float

    - Variable-Precision Newton Evaluation

  - FAQ

    - precision

  - float128

    - BOOST_MP_USE_FLOAT128

    - BOOST_MP_USE_QUAD

    - data

    - float128_backend

    - log

    - of

    - type

  - float128_backend

    - float128

    - Forward Declarations

  - floor

    - number

  - fma

    - number

  - Forward Declarations

    - complex_adaptor

    - cpp_bin_float

    - cpp_int_backend

    - debug_adaptor

    - expression_template_default

    - float128_backend

    - gmp_float

    - gmp_int

    - gmp_rational

    - is_number

    - logged_adaptor

    - log_postfix_event

    - log_prefix_event

    - mpc_complex_backend

    - mpfi_float_backend

    - mpfr_float_backend

    - number

    - rational_adaptor

    - tommath_int

  - fpclassify

    - number

  - frexp

    - number

G

  - gcd

    - number

  - Generic Integer Operations

    - add

    - bit_flip

    - bit_set

    - bit_test

    - bit_unset

    - divide_qr

    - integer_modulus

    - lsb

    - miller_rabin_test

    - msb

    - multiply

    - powm

    - precision

    - sqrt

    - subtract

    - the

  - gmp_float

    - data

    - Forward Declarations

    - gmp_float

    - log

    - zero

  - gmp_int

    - data

    - Forward Declarations

    - gmp_int

    - zero

  - gmp_rational

    - data

    - denominator

    - Forward Declarations

    - gmp_rational

    - numerator

    - zero

H

  - half

    - Variable-Precision Newton Evaluation

  - Hash Function Support

    - operator

  - History

    - cpp_bin_float

    - ilogb

    - sqrt

I

  - i

    - Constructing and Interconverting Between Number Types

    - Mixed Precision Arithmetic

    - Variable Precision Arithmetic

  - if

    - Primality Testing

  - ilogb

    - History

    - number

  - imag

    - number

  - Importing and Exporting Data to and from cpp_int and cpp_bin_float

    - bit_set

    - BOOST_MP_ASSERT

    - export_bits

    - f

    - result

  - in

    - mpfi_float

  - infinity

    - std :: numeric_limits <> functions

    - std::numeric_limits<> constants

  - Input Output

    - bits

    - BOOST_MP_MIN_EXPONENT_DIGITS

  - integer_modulus

    - Generic Integer Operations

    - number

  - Internal Support Code

    - is_explicitly_convertible

    - is_lossy_conversion

    - is_restricted_conversion

    - is_signed_number

    - is_unsigned_number

  - Introduction

    - a

    - expression

    - precision

    - result

  - iround

    - number

  - isfinite

    - number

  - isgreater

    - number

  - isgreaterequal

    - number

  - isinf

    - number

  - isless

    - number

  - islessequal

    - number

  - islessgreater

    - number

  - isnan

    - number

  - isnormal

    - number

  - isunordered

    - number

  - is_equivalent_number_type

    - Mixed Precision Arithmetic

  - is_explicitly_convertible

    - Internal Support Code

  - is_lossy_conversion

    - Internal Support Code

  - is_number

    - Forward Declarations

    - number

  - is_number_expression

    - number

  - is_restricted_conversion

    - Internal Support Code

  - is_signed_number

    - Internal Support Code

  - is_unsigned_number

    - Internal Support Code

  - itrunc

    - number

L

  - ldexp

    - number

  - lgamma

    - Backend Requirements

    - number

  - Literal Types and constexpr Support

    - BOOST_MP_DEFINE_SIZED_CPP_INT_LITERAL

    - data

    - operator

  - llrint

    - Backend Requirements

    - number

  - llround

    - number

  - lltrunc

    - number

  - log

    - cpp_bin_float

    - cpp_dec_float

    - float128

    - gmp_float

    - mpfi_float

    - mpfr_float

    - number

  - log1p

    - Backend Requirements

    - number

  - logged_adaptor

    - Forward Declarations

    - logged_adaptor

    - log_postfix_event

    - log_prefix_event

    - the

  - log_postfix_event

    - Forward Declarations

    - logged_adaptor

  - log_prefix_event

    - Forward Declarations

    - logged_adaptor

  - lrint

    - Backend Requirements

    - number

  - lround

    - number

  - lsb

    - Generic Integer Operations

    - number

  - ltrunc

    - number

M

  - miller_rabin_test

    - Generic Integer Operations

    - number

    - Primality Testing

  - Mixed Precision Arithmetic

    - a

    - add

    - e

    - i

    - is_equivalent_number_type

    - multiply

    - subtract

    - type

  - modf

    - number

  - mpc_complex

    - data

    - mpc_complex_backend

    - zero

  - mpc_complex_backend

    - Forward Declarations

    - mpc_complex

  - mpfi_float

    - data

    - empty

    - in

    - log

    - mpfi_float_backend

    - overlap

    - proper_subset

    - singleton

    - subset

    - zero

    - zero_in

  - mpfi_float_backend

    - Forward Declarations

    - mpfi_float

  - mpfr_float

    - data

    - log

    - mpfr_float_backend

    - zero

  - mpfr_float_backend

    - Forward Declarations

    - mpfr_float

    - mpfr_float_backend

  - msb

    - Generic Integer Operations

    - number

  - multiply

    - Generic Integer Operations

    - Mixed Precision Arithmetic

    - number

N

  - nextafter

    - Backend Requirements

    - number

  - nexttoward

    - Backend Requirements

    - number

  - norm

    - number

  - number

    - abs

    - acosh

    - add

    - arg

    - asinh

    - assign

    - atan2

    - atanh

    - bit_flip

    - bit_set

    - bit_test

    - bit_unset

    - cbrt

    - ceil

    - changesign

    - compare

    - component_type

    - conj

    - convert_to

    - copysign

    - cos

    - default_precision

    - denominator

    - divide_qr

    - erf

    - erfc

    - exp

    - expm1

    - expression_template_default

    - floor

    - fma

    - Forward Declarations

    - fpclassify

    - frexp

    - gcd

    - ilogb

    - imag

    - integer_modulus

    - iround

    - isfinite

    - isgreater

    - isgreaterequal

    - isinf

    - isless

    - islessequal

    - islessgreater

    - isnan

    - isnormal

    - isunordered

    - is_number

    - is_number_expression

    - itrunc

    - ldexp

    - lgamma

    - llrint

    - llround

    - lltrunc

    - log

    - log1p

    - lrint

    - lround

    - lsb

    - ltrunc

    - miller_rabin_test

    - modf

    - msb

    - multiply

    - nextafter

    - nexttoward

    - norm

    - number

    - number_category

    - numerator

    - polar

    - pow

    - powm

    - precision

    - proj

    - real

    - remainder

    - remquo

    - round

    - scalar

    - sign

    - signbit

    - sqrt

    - subtract

    - swap

    - tgamma

    - the

    - to_string

    - trunc

    - type

    - value

  - number_category

    - number

  - numerator

    - cpp_rational

    - gmp_rational

    - number

    - tommath_rational

O

  - of

    - float128

    - Optional Requirements on the Backend Type

    - Variable Precision Arithmetic

  - operator

    - Calculating an Integral

    - Hash Function Support

    - Literal Types and constexpr Support

  - Optional Requirements on the Backend Type

    - eval_add

    - eval_bitwise_and

    - eval_bitwise_or

    - eval_bitwise_xor

    - eval_divide

    - eval_eq

    - eval_gcd

    - eval_get_sign

    - eval_gt

    - eval_increment

    - eval_lcm

    - eval_lt

    - eval_modulus

    - eval_multiply

    - eval_multiply_add

    - eval_multiply_subtract

    - eval_nearbyint

    - eval_round

    - eval_scalbn

    - eval_subtract

    - of

  - overlap

    - mpfi_float

P

  - polar

    - number

  - pow

    - number

  - powm

    - Generic Integer Operations

    - number

  - precision

    - FAQ

    - Generic Integer Operations

    - Introduction

    - number

  - Primality Testing

    - if

    - miller_rabin_test

  - proj

    - number

  - proper_subset

    - mpfi_float

R

  - r

    - Bit Operations

  - rational_adaptor

    - Forward Declarations

  - real

    - number

  - remainder

    - number

  - remquo

    - number

  - result

    - Importing and Exporting Data to and from cpp_int and cpp_bin_float

    - Introduction

  - round

    - number

  - Rounding Rules for Conversions

    - bits

S

  - scalar

    - number

  - scoped

    - Variable Precision Arithmetic

  - scoped_opts

    - Variable Precision Arithmetic

  - sign

    - Backend Requirements

    - number

  - signbit

    - Backend Requirements

    - number

  - singleton

    - mpfi_float

  - sp

    - Variable-Precision Newton Evaluation

  - sqrt

    - Generic Integer Operations

    - History

    - number

    - std :: numeric_limits <> functions

  - std :: numeric_limits <> functions

    - BOOST_MP_ASSERT

    - infinity

    - sqrt

    - value

  - std::numeric_limits<> constants

    - bits

    - digits10

    - down

    - infinity

    - type

    - zero

  - subset

    - mpfi_float

  - subtract

    - Generic Integer Operations

    - Mixed Precision Arithmetic

    - number

  - swap

    - number

T

  - temporary

    - TODO

  - tgamma

    - Backend Requirements

    - number

  - the

    - Generic Integer Operations

    - logged_adaptor

    - number

  - TODO

    - add

    - cpp_dec_float

    - temporary

  - tommath_int

    - Forward Declarations

    - tom_int

  - tommath_rational

    - denominator

    - numerator

    - zero

  - tom_int

    - tommath_int

    - zero

  - to_string

    - number

  - trunc

    - number

  - type

    - Defining a Special Function

    - float128

    - Mixed Precision Arithmetic

    - number

    - std::numeric_limits<> constants

V

  - v

    - Defining a Special Function

    - Variable Precision Arithmetic

  - value

    - cpp_bin_float

    - number

    - std :: numeric_limits <> functions

  - Variable Precision Arithmetic

    - a

    - i

    - of

    - scoped

    - scoped_opts

    - v

  - Variable-Precision Newton Evaluation

    - a

    - exp

    - f

    - half

    - sp

    - x

X

  - x

    - Variable-Precision Newton Evaluation

Z

  - zero

    - gmp_float

    - gmp_int

    - gmp_rational

    - mpc_complex

    - mpfi_float

    - mpfr_float

    - std::numeric_limits<> constants

    - tommath_rational

    - tom_int

  - zero_in

    - mpfi_float