Boost logo

Boost :

From: Matt Calabrese (rivorus_at_[hidden])
Date: 2005-09-03 00:20:43

On 9/2/05, Paul Mensonides <pmenso57_at_[hidden]> wrote:

> The problem is that there isn't any arbitrary precision arithmetic support
> in
> the pp-lib. If there was, you could do better than that for syntax:
> BOOST_BINARY_INT( 1100 0011 1010 )

You are under the mistaken impression that the resultant number would have
to be a decimal literal and rely on Boost.Preprocessor functionality for
arithmetic computations. Storing the number as a hex literal makes things
much easier, since each nibble is just a hex digit. All you do is convert
each nibble to hex then concatenate them all together. The fact that the
literal is in hex, it has the downside that it would be more difficult to
use with Boost.Preprocessor operations, but then again, the template form
couldn't do that either. Even still, if you really wanted to use it with
Boost.Preprocessor macros, the time could be taken to make an implementation
which results in a small decimal literal. Here is a fully functional
BOOST_BINARY_INT implementation I put together describing what I mean:

Example usage would be BOOST_BINARY_INT( (1100)(0101) ) to represent the hex
literal 0xC5

It works exactly as I described and can be used at preprocessing time
(though again, note that it is a hex literal). I do not immediately see how
to implement it allowing the syntax you describe (where your nibbles are
simply separated by spaces rather than using a Boost.Preprocessor sequence),
so if you could, please enlighten me as I know you must be more experienced
with the preprocessor (I love Boost.Preprocessor by the way).

Note that compared to the template version, this implementation actually
works at preprocessor time, is even shorter and arguably more elegant in
implementation, you can easily append integer suffixes at the end, it
doesn't allow obvious mistakes such as passing a decimal value of 65, and
since it doesn't deal with complex language features such as templates you
have less to worry about concerning portability. As well, if you wish to use
the number as an MPL style integer constant, all you have to do is pass the
resultant value as an argument to an integer constant template.

As a side note, I noticed while making this that BOOST_PP_SEQ_CAT fails on
sequences of size 1. While obviously no concatenations occur with a sequence
of this size, logically the result should just be the single element, so I
consider this an error in Boost.Preprocessor (any disagreements on that?). I
had to make a workaround to account for a single nibble, here, though the
resultant code is still under 60 lines.

Also note that I only allowed values which are 4 binary digits long. This
was just a design choice as I believe it would be confusing having nibbles
in the middle that have under 4 digits. Of course, I could always make a
special case that only the first nibble is allowed to be under 4 binary
digits if the desire for that functionality exists.

-Matt Calabrese

Boost list run by bdawes at, gregod at, cpdaniel at, john at