# Boost Numeric Conversion Library

Types
Example(s)

## `enumeration int_float_mixture_enum`

```namespace boost { namespace numeric {

enum int_float_mixture_enum
{
integral_to_integral
,integral_to_float
,float_to_integral
,float_to_float
} ;

} } // namespace boost::numeric
```

## `enumeration sign_mixture_enum`

```namespace boost { namespace numeric {

enum sign_mixture_enum
{
unsigned_to_unsigned
,signed_to_signed
,signed_to_unsigned
,unsigned_to_signed
} ;

} } // namespace boost::numeric```

## `enumeration udt_builtin_mixture_enum`

```namespace boost { namespace numeric {

enum udt_builtin_mixture_enum
{
builtin_to_builtin
,builtin_to_udt
,udt_to_builtin
,udt_to_udt
} ;

} } // namespace boost::numeric```

## `template class int_float_mixture<>`

```namespace boost { namespace numeric {

template <class T, class S>
struct int_float_mixture : mpl::integral_c<int_float_mixture_enum, impl-def-value> {} ;

} } // namespace boost::numeric
```

Classifying `S` and `T` as either `integral` or `float`, this MPL's Integral Constant indicates the combination of these attributes.
Its `::value` is of enumeration type `boost::numeric::int_float_mixture_enum`

## `template class sign_mixture<>`

```namespace boost { namespace numeric {

template <class T, class S>
struct sign_mixture : mpl::integral_c<sign_mixture_enum, impl-def-value> {} ;

} } // namespace boost::numeric
```

Classifying `S` and `T` as either `signed` or `unsigned`, this MPL's Integral Constant indicates the combination of these attributes.
Its `::value` is of enumeration type `boost::numeric::sign_mixture_enum`

## `template class udt_builtin_mixture<>`

```namespace boost { namespace numeric {

template <class T, class S>
struct udt_builtin_mixture : mpl::integral_c<udt_builtin__mixture_enum, impl-def-value> {} ;

} } // namespace boost::numeric
```

Classifying `S` and `T` as either `user-defined` or `builtin`, this MPL's Integral Constant indicates the combination of these attributes.
Its `::value` is of enumeration type `boost::numeric::udt_builtin_mixture_enum`

## `template class is_subranged<>`

```namespace boost { namespace numeric {

template <class T, class S>
struct is_subranged : mpl::bool_<impl-def-value> {} ;

} } // namespace boost::numeric
```

Indicates if the range of the target type T is a subset of the range of the source type S. That is: if there are some source values which fall out of the Target type's range.
It is a boolean MPL's Integral Constant..
It does not indicate if a particular conversion is effectively out of range; it indicates that some conversion might be out of range because not all the source values are representable as Target type.

## `template class conversion_traits<>`

```namespace boost { namespace numeric {

template <class T, class S>
struct conversion_traits
{
mpl::integral_c<int_float_mixture_enum  , ...> int_float_mixture ;
mpl::integral_c<sign_mixture_enum       , ...> sign_mixture;
mpl::integral_c<udt_builtin_mixture_enum, ...> udt_builtin_mixture ;

mpl::bool_<...> subranged ;
mpl::bool_<...> trivial ;

typedef T target_type   ;
typedef S source_type   ;
typedef ... argument_type ;
typedef ... result_type   ;
typedef ... supertype     ;
typedef ... subtype       ;
} ;

} } // namespace numeric, namespace boost
```

This traits class indicates some properties of a numeric conversion direction: from a source type `S` to a target type `T`. It does not indicate the properties of a specific conversion, but of the conversion direction. See Definitions for details.

The traits class provides the following MPL's Integral Constants of enumeration type. They express the combination of certain attributes of the Source and Target types (thus they are call mixture):

 `int_float_mixture` Same as given by the traits class `int_float_mixture` `sign_mixture` Same as given by the traits class `sign_mixture` `udt_builtin_mixture` Same as given by the traits class `udt_builtin_mixture`

The traits class provides the following MPL's Integral Constants of boolean type which indicates indirectly the relation between the Source and Target ranges (see Definitions for details).

 ` subranged` Same as given by `is_subranged` ` trivial` Indicates if both Source and Target, without cv-qualifications, are the same type. Its `::value` is of boolean type.

The traits class provides the following types. They are the Source and Target types classified and qualified for different purposes.

 `target_type` The template parameter `T` without cv-qualifications `source_type` The template parameter `S` without cv-qualifications `argument_type` This type is either `source_type` or ```source_type const&```. It represents the optimal argument type for the converter member functions. If `S` is a built-in type, this is `source_type`, otherwise, this is `source_type const&`. `result_type` This type is either `target_type` or ```target_type const&``` It represents the return type of the converter member functions. If `T==S`, it is `target_type const&`, otherwise, it is `target_type`. `supertype` If the conversion is `subranged`, it is `source_type`, otherwise, it is `target_type` `subtype` If the conversion is `subranged`, it is `target_type`, otherwise, it is `source_type`

## Examples

```#include <cassert>
#include <typeinfo>
#include <boost/numeric/conversion/conversion_traits.hpp>

int main()
{

// A trivial conversion.
typedef boost::numeric::conversion_traits<short,short> Short2Short_Traits ;
assert ( Short2Short_Traits::trivial::value ) ;

// A subranged conversion.
typedef boost::numeric::conversion_traits<double,unsigned int> UInt2Double_Traits ;
assert (  UInt2Double_Traits::int_float_mixture::value == boost::numeric::integral_to_float ) ;
assert (  UInt2Double_Traits::sign_mixture::value == boost::numeric::unsigned_to_signed ) ;
assert ( !UInt2Double_Traits::subranged::value ) ;
assert ( typeid(UInt2Double_Traits::supertype) == typeid(double) ) ;
assert ( typeid(UInt2Double_Traits::subtype) == typeid(unsigned int) ) ;

// A doubly subranged conversion.
assert ( (boost::numeric::conversion_traits<short, unsigned short>::subranged::value) );
assert ( (boost::numeric::conversion_traits<unsigned short, short>::subranged::value) );

return 0;
}
```

Revised 23 November 2006