boost-react-native-bundle

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> <title>Projects</title> <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css"> <meta name="generator" content="DocBook XSL Stylesheets V1.74.0"> <link rel="home" href="../index.html" title="Chapter 1. Boost.Icl"> <link rel="up" href="../index.html" title="Chapter 1. Boost.Icl"> <link rel="prev" href="examples/custom_interval.html" title="Custom interval"> <link rel="next" href="concepts.html" title="Concepts"> </head> <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> <table cellpadding="2" width="100%"><tr> <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> <td align="center"><a href="../../../../../index.html">Home</a></td> <td align="center"><a href="../../../../libraries.htm">Libraries</a></td> <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> <td align="center"><a href="../../../../../more/index.htm">More</a></td> </tr></table> <hr> <div class="spirit-nav"> <a accesskey="p" href="examples/custom_interval.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concepts.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a> </div> <div class="section boost_icl_projects" lang="en"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="boost_icl.projects"></a><a class="link" href="projects.html" title="Projects">Projects</a> </h2></div></div></div> <div class="toc"><dl><dt><a href="projects.html#boost_icl.projects.large_bitset">Large Bitset</a></dt></dl></div> Projects are examples on the usage of interval containers that go beyond small toy snippets of code. The code presented here addresses more serious applications that approach the quality of real world programming. At the same time it aims to guide the reader more deeply into various aspects of the library. In order not to overburden the reader with implementation details, the code in projects tries to be minimal. It has a focus on the main aspects of the projects and is not intended to be complete and mature like the library code itself. Cause it's minimal, project code lives in <code class="computeroutput">namespace mini</code>. <div class="section boost_icl_projects_large_bitset" lang="en"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_icl.projects.large_bitset"></a><a class="link" href="projects.html#boost_icl.projects.large_bitset" title="Large Bitset">Large Bitset</a> </h3></div></div></div> <div class="toc"><dl> <dt><a href="projects.html#boost_icl.projects.large_bitset.using_large_bitset">Using large_bitset</a></dt> <dt><a href="projects.html#boost_icl.projects.large_bitset.the_interval_bitmap">The interval_bitmap</a></dt> <dt><a href="projects.html#boost_icl.projects.large_bitset.a_class_implementation_for_the_bitset_type">A class implementation for the bitset type</a></dt> <dt><a href="projects.html#boost_icl.projects.large_bitset.implementation_of_a_large_bitset">Implementation of a large bitset</a></dt> </dl></div> Bitsets are just sets. Sets of unsigned integrals, to be more precise. The prefix bit usually only indicates, that the representation of those sets is organized in a compressed form that exploits the fact, that we can switch on an off single bits in machine words. Bitsets are therefore known to be very small and thus efficient. The efficiency of bitsets is usually coupled to the precondition that the range of values of elements is relatively small, like [0..32) or [0..64), values that can be typically represented in single or a small number of machine words. If we wanted to represent a set containing two values {1, 1000000}, we would be much better off using other sets like e.g. an <code class="computeroutput">std::set</code>. Bitsets compress well, if elements spread over narrow ranges only. Interval sets compress well, if many elements are clustered over intervals. They can span large sets very efficiently then. In project Large Bitset we want to combine the bit compression and the interval compression to achieve a set implementation, that is capable of spanning large chunks of contiguous elements using intervals and also to represent more narrow nests of varying bit sequences using bitset compression. As we will see, this can be achieved using only a small amount of code because most of the properties we need are provided by an <code class="computeroutput"><a class="link" href="../boost/icl/interval_map.html" title="Class template interval_map">interval_map</a></code> of <code class="computeroutput">bitsets</code>: <pre class="programlisting">typedef interval_map<IntegralT, SomeBitSet<N>, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> IntervalBitmap; </pre> Such an <code class="computeroutput">IntervalBitmap</code> represents <code class="computeroutput">k*N</code> bits for every segment. <pre class="programlisting">[a, a+k)->'1111....1111' // N bits associated: Represents a total of k*N bits. </pre> For the interval <code class="computeroutput">[a, a+k)</code> above all bits are set. But we can also have individual nests or clusters of bitsequences. <pre class="programlisting">[b, b+1)->'01001011...1' [b+1,b+2)->'11010001...0' . . . </pre> and we can span intervals of equal bit sequences that represent periodic patterns. <pre class="programlisting">[c,d)->'010101....01' // Every second bit is set in range [c,d) [d,e)->'001100..0011' // Every two bits alterate in range [d,e) [e,f)->'bit-sequence' // 'bit-sequence' reoccurs every N bits in range [e,f) </pre> An <code class="computeroutput">IntervalBitmap</code> can represent <code class="computeroutput">N*(2^M)</code> elements, if <code class="computeroutput">M</code> is the number of bits of the integral type <code class="computeroutput">IntegralT</code>. Unlike bitsets, that usually represent unsigned integral numbers, large_bitset may range over negative numbers as well. There are fields where such large bitsets implementations are needed. E.g. for the compact representation of large file allocation tables. What remains to be done for project Large Bitset is to code a wrapper <code class="computeroutput">class large_bitset</code> around <code class="computeroutput">IntervalBitmap</code> so that <code class="computeroutput">large_bitset</code> looks and feels like a usual set class. <div class="section boost_icl_projects_large_bitset_using_large_bitset" lang="en"> <div class="titlepage"><div><div><h4 class="title"> <a name="boost_icl.projects.large_bitset.using_large_bitset"></a><a class="link" href="projects.html#boost_icl.projects.large_bitset.using_large_bitset" title="Using large_bitset">Using large_bitset</a> </h4></div></div></div> To quicken your appetite for a look at the implementation here are a few use cases first. Within the examples that follow, we will use <code class="computeroutput">nat</code><code class="literal">k</code> for unsigned integrals and <code class="computeroutput">bits</code><code class="literal">k</code> for bitsets containing <code class="literal">k</code> bits. Let's start large. In the first example . . . <pre class="programlisting">void test_large() { const nat64 much = 0xffffffffffffffffull; large_bitset<> venti; // ... the largest, I can think of ;) venti += discrete_interval<nat64>(0, much); cout << "----- Test function test_large() -----------------------------------------------\n"; cout << "We have just turned on the awesome amount of 18,446,744,073,709,551,616 bits ;-)\n"; venti.show_segments(); </pre> . . . we are testing the limits. First we set all bits and then we switch off the very last bit. <pre class="programlisting"> cout << "---- Let's swich off the very last bit -----------------------------------------\n"; venti -= much; venti.show_segments(); cout << "---- Venti is plenty ... let's do something small: A tall ----------------------\n\n"; } </pre> Program output (a little beautified): <pre class="programlisting">----- Test function test_large() ----------------------------------------------- We have just turned on the awesome amount of 18,446,744,073,709,551,616 bits ;-) [ 0, 288230376151711744) -> 1111111111111111111111111111111111111111111111111111111111111111 ---- Let's swich off the very last bit ----------------------------------------- [ 0, 288230376151711743) -> 1111111111111111111111111111111111111111111111111111111111111111 [288230376151711743, 288230376151711744) -> 1111111111111111111111111111111111111111111111111111111111111110 ---- Venti is plenty ... let's do something small: A tall ---------------------- </pre> More readable is a smaller version of <code class="computeroutput">large_bitset</code>. In function <code class="computeroutput">test_small()</code> we apply a few more operations . . . <pre class="programlisting">void test_small() { large_bitset<nat32, bits8> tall; // small is tall ... // ... because even this 'small' large_bitset // can represent up to 2^32 == 4,294,967,296 bits. cout << "----- Test function test_small() -----------\n"; cout << "-- Switch on all bits in range [0,64] ------\n"; tall += discrete_interval<nat>(0, 64); tall.show_segments(); cout << "--------------------------------------------\n"; cout << "-- Turn off bits: 25,27,28 -----------------\n"; (((tall -= 25) -= 27) -= 28) ; tall.show_segments(); cout << "--------------------------------------------\n"; cout << "-- Flip bits in range [24,30) --------------\n"; tall ^= discrete_interval<nat>::right_open(24,30); tall.show_segments(); cout << "--------------------------------------------\n"; cout << "-- Remove the first 10 bits ----------------\n"; tall -= discrete_interval<nat>::right_open(0,10); tall.show_segments(); cout << "-- Remove even bits in range [0,72) --------\n"; int bit; for(bit=0; bit<72; bit++) if(!(bit%2)) tall -= bit; tall.show_segments(); cout << "-- Set odd bits in range [0,72) --------\n"; for(bit=0; bit<72; bit++) if(bit%2) tall += bit; tall.show_segments(); cout << "--------------------------------------------\n\n"; } </pre> . . . producing this output: <pre class="programlisting">----- Test function test_small() ----------- -- Switch on all bits in range [0,64] ------ [0,8)->11111111 [8,9)->10000000 -------------------------------------------- -- Turn off bits: 25,27,28 ----------------- [0,3)->11111111 [3,4)->10100111 [4,8)->11111111 [8,9)->10000000 -------------------------------------------- -- Flip bits in range [24,30) -------------- [0,3)->11111111 [3,4)->01011011 [4,8)->11111111 [8,9)->10000000 -------------------------------------------- -- Remove the first 10 bits ---------------- [1,2)->00111111 [2,3)->11111111 [3,4)->01011011 [4,8)->11111111 [8,9)->10000000 -- Remove even bits in range [0,72) -------- [1,2)->00010101 [2,3)->01010101 [3,4)->01010001 [4,8)->01010101 -- Set odd bits in range [0,72) -------- [0,9)->01010101 -------------------------------------------- </pre> Finally, we present a little picturesque example, that demonstrates that <code class="computeroutput">large_bitset</code> can also serve as a self compressing bitmap, that we can 'paint' with. <pre class="programlisting">void test_picturesque() { typedef large_bitset<nat, bits8> Bit8Set; Bit8Set square, stare; square += discrete_interval<nat>(0,8); for(int i=1; i<5; i++) { square += 8*i; square += 8*i+7; } square += discrete_interval<nat>(41,47); cout << "----- Test function test_picturesque() -----\n"; cout << "-------- empty face: " << square.interval_count() << " intervals -----\n"; square.show_matrix(" *"); stare += 18; stare += 21; stare += discrete_interval<nat>(34,38); cout << "-------- compressed smile: " << stare.interval_count() << " intervals -----\n"; stare.show_matrix(" *"); cout << "-------- staring bitset: " << (square + stare).interval_count() << " intervals -----\n"; (square + stare).show_matrix(" *"); cout << "--------------------------------------------\n"; } </pre> Note that we have two <code class="computeroutput">large_bitsets</code> for the outline and the interior. Both parts are compressed but we can compose both by <code class="computeroutput">operator +</code>, because the right positions are provided. This is the program output: <pre class="programlisting">----- Test function test_picturesque() ----- -------- empty face: 3 intervals ----- ******** * * * * * * * * ****** -------- compressed smile: 2 intervals ----- * * **** -------- staring bitset: 6 intervals ----- ******** * * * * * * * * * **** * ****** -------------------------------------------- </pre> So, may be you are curious how this class template is coded on top of <code class="computeroutput"><a class="link" href="../boost/icl/interval_map.html" title="Class template interval_map">interval_map</a></code> using only about 250 lines of code. This is shown in the sections that follow. </div> <div class="section boost_icl_projects_large_bitset_the_interval_bitmap" lang="en"> <div class="titlepage"><div><div><h4 class="title"> <a name="boost_icl.projects.large_bitset.the_interval_bitmap"></a><a class="link" href="projects.html#boost_icl.projects.large_bitset.the_interval_bitmap" title="The interval_bitmap">The interval_bitmap</a> </h4></div></div></div> To begin, let's look at the basic data type again, that will be providing the major functionality: <pre class="programlisting">typedef interval_map<DomainT, BitSetT, partial_absorber, std::less, inplace_bit_add, inplace_bit_and> IntervalBitmap; </pre> <code class="computeroutput">DomainT</code> is supposed to be an integral type, the bitset type <code class="computeroutput">BitSetT</code> will be a wrapper class around an unsigned integral type. <code class="computeroutput">BitSetT</code> has to implement bitwise operators that will be called by the functors <code class="computeroutput">inplace_bit_add<BitSetT></code> and <code class="computeroutput">inplace_bit_and<BitSetT></code>. The type trait of interval_map is <code class="computeroutput">partial_absorber</code>, which means that it is partial and that empty <code class="computeroutput">BitSetTs</code> are not stored in the map. This is desired and keeps the <code class="computeroutput">interval_map</code> minimal, storing only bitsets, that contain at least one bit switched on. Functor template <code class="computeroutput">inplace_bit_add</code> for parameter <code class="computeroutput">Combine</code> indicates that we do not expect <code class="computeroutput">operator +=</code> as addition but the bitwise operator <code class="computeroutput">|=</code>. For template parameter <code class="computeroutput">Section</code> which is instaniated by <code class="computeroutput">inplace_bit_and</code> we expect the bitwise <code class="computeroutput">&=</code> operator. </div> <div class="section boost_icl_projects_large_bitset_a_class_implementation_for_the_bitset_type" lang="en"> <div class="titlepage"><div><div><h4 class="title"> <a name="boost_icl.projects.large_bitset.a_class_implementation_for_the_bitset_type"></a><a class="link" href="projects.html#boost_icl.projects.large_bitset.a_class_implementation_for_the_bitset_type" title="A class implementation for the bitset type">A class implementation for the bitset type</a> </h4></div></div></div> The code of the project is enclosed in a <code class="computeroutput">namespace mini</code>. The name indicates, that the implementation is a minimal example implementation. The name of the bitset class will be <code class="computeroutput">bits</code> or <code class="computeroutput">mini::bits</code> if qualified. To be used as a codomain parameter of class template <code class="computeroutput"><a class="link" href="../boost/icl/interval_map.html" title="Class template interval_map">interval_map</a></code>, <code class="computeroutput">mini::bits</code> has to implement all the functions that are required for a codomain_type in general, which are the default constructor <code class="computeroutput">bits()</code> and an equality <code class="computeroutput">operator==</code>. Moreover <code class="computeroutput">mini::bits</code> has to implement operators required by the instantiations for parameter <code class="computeroutput">Combine</code> and <code class="computeroutput">Section</code> which are <code class="computeroutput">inplace_bit_add</code> and <code class="computeroutput">inplace_bit_and</code>. From functors <code class="computeroutput">inplace_bit_add</code> and <code class="computeroutput">inplace_bit_and</code> there are inverse functors <code class="computeroutput">inplace_bit_subtract</code> and <code class="computeroutput">inplace_bit_xor</code>. Those functors use operators <code class="computeroutput">|= &= ^=</code> and <code class="computeroutput">~</code>. Finally if we want to apply lexicographical and subset comparison on large_bitset, we also need an <code class="computeroutput">operator <</code>. All the operators that we need can be implemented for <code class="computeroutput">mini::bits</code> on a few lines: <pre class="programlisting">template<class NaturalT> class bits { public: typedef NaturalT word_type; static const int digits = std::numeric_limits<NaturalT>::digits; static const word_type w1 = static_cast<NaturalT>(1) ; bits():_bits(){} explicit bits(word_type value):_bits(value){} word_type word()const{ return _bits; } bits& <span class="k