bitstring 1.0.0

data/CONTRIBUTORS.txt

@@ -0,0 +1,5 @@
+CONTRIBUTORS:
+-------------
+
+* Rodent of Unusual Size <The.Rodent.of.Unusual.Size@GMail.Com> (Ken Coar)
+  Initial creator and maintainer.

data/Changelog.txt

@@ -0,0 +1,20 @@
+-*- mode: change-log; mode: auto-fill; -*-
+
+1.0.0	2010-02-04 Initial release as a Ruby gem
+
+0.1.0 
+	o Added population() and select().
+	o Added the example fragments.
+	o Added mask() and each().
+	o Added the [start,length]= handling. (FREQ #27742)
+	o Fixed a problem with the reporting of the BadDigit internal
+	  exception.
+	o Added an 'Examples' section to each method header.  (Not very
+	  many filled in yet, though.)
+	o Normalised data checking and made Array/BitString/Integer/String
+	  acceptable in more places (like the bitwise operators).
+
+0.1.0 2010-01-27 Initial import
+-------------------------------
+	Still lots to do, but at least we're in a state suitable
+	to check in to the repository..

data/LICENCE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/NOTICE.txt

@@ -0,0 +1,5 @@
+BitString Ruby package
+Copyright © 2010 Ken Coar
+
+This file MUST contain attributions for any third-party
+inclusions or contributions.

data/README.txt

@@ -0,0 +1,63 @@
+BitString - 'Arrays' of bits for Ruby
+=====================================
+
+* http://rubyforge.org/projects/bitstring/ - project page
+* http://bitstring.rubyforge.org/rdoc/     - RDoc documentation
+
+DESCRIPTION:
+------------
+
+BitString is a Ruby class for providing access to lists of bits in
+an 'Array'-like manner.  Direct addressing, subranging, masking,
+e cetera.
+
+
+FEATURES:
+---------
+
+* Many of the features of the Array class are available for BitString.
+
+
+PROBLEMS:
+---------
+
+* None known.
+
+
+SYNOPSIS:
+---------
+
+  require 'bitstring'
+  bs = BitString.new('100101001')
+  bs = BitString.new('100101001', 9)
+
+REQUIREMENTS:
+-------------
+
+* Gem 'versionomy'
+
+
+INSTALL:
+--------
+
+BitString is installed using the canonical method:
+
+  sudo gem install bitstring
+
+
+LICENSE:
+--------
+
+Copyright © 2010 Ken Coar
+
+Licensed under the Apache License, Version 2.0 (the "License"); you
+may not use this file except in compliance with the License. You may
+obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing
+permissions and limitations under the License.

data/doc/classes/BitString.html

@@ -0,0 +1,2479 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html 
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Class: BitString</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+  <meta http-equiv="Content-Script-Type" content="text/javascript" />
+  <link rel="stylesheet" href=".././rdoc-style.css" type="text/css" media="screen" />
+  <script type="text/javascript">
+  // <![CDATA[
+
+  function popupCode( url ) {
+    window.open(url, "Code", "resizable=yes,scrollbars=yes,toolbar=no,status=no,height=150,width=400")
+  }
+
+  function toggleCode( id ) {
+    if ( document.getElementById )
+      elem = document.getElementById( id );
+    else if ( document.all )
+      elem = eval( "document.all." + id );
+    else
+      return false;
+
+    elemStyle = elem.style;
+    
+    if ( elemStyle.display != "block" ) {
+      elemStyle.display = "block"
+    } else {
+      elemStyle.display = "none"
+    }
+
+    return true;
+  }
+  
+  // Make codeblocks hidden by default
+  document.writeln( "<style type=\"text/css\">div.method-source-code { display: none }</style>" )
+  
+  // ]]>
+  </script>
+
+</head>
+<body>
+
+
+
+    <div id="classHeader">
+        <table class="header-table">
+        <tr class="top-aligned-row">
+          <td><strong>Class</strong></td>
+          <td class="class-name-in-header">BitString</td>
+        </tr>
+        <tr class="top-aligned-row">
+            <td><strong>In:</strong></td>
+            <td>
+                <a href="../files/lib/bitstring_rb.html">
+                lib/bitstring.rb
+                </a>
+        <br />
+                <a href="../files/lib/bitstring/operators_rb.html">
+                lib/bitstring/operators.rb
+                </a>
+        <br />
+            </td>
+        </tr>
+
+        <tr class="top-aligned-row">
+            <td><strong>Parent:</strong></td>
+            <td>
+                Object
+            </td>
+        </tr>
+        </table>
+    </div>
+  <!-- banner header -->
+
+  <div id="bodyContent">
+
+
+
+  <div id="contextContent">
+
+
+
+   </div>
+
+    <div id="method-list">
+      <h3 class="section-bar">Methods</h3>
+
+      <div class="name-list">
+      <a href="#M000026">&amp;</a>&nbsp;&nbsp;
+      <a href="#M000027">&lt;&lt;</a>&nbsp;&nbsp;
+      <a href="#M000034">==</a>&nbsp;&nbsp;
+      <a href="#M000028">&gt;&gt;</a>&nbsp;&nbsp;
+      <a href="#M000029">[]</a>&nbsp;&nbsp;
+      <a href="#M000030">[]=</a>&nbsp;&nbsp;
+      <a href="#M000031">^</a>&nbsp;&nbsp;
+      <a href="#M000002">bounded?</a>&nbsp;&nbsp;
+      <a href="#M000003">clear</a>&nbsp;&nbsp;
+      <a href="#M000004">clear!</a>&nbsp;&nbsp;
+      <a href="#M000005">each</a>&nbsp;&nbsp;
+      <a href="#M000006">from_i</a>&nbsp;&nbsp;
+      <a href="#M000007">grow</a>&nbsp;&nbsp;
+      <a href="#M000008">grow!</a>&nbsp;&nbsp;
+      <a href="#M000009">length</a>&nbsp;&nbsp;
+      <a href="#M000010">lsb</a>&nbsp;&nbsp;
+      <a href="#M000012">mask</a>&nbsp;&nbsp;
+      <a href="#M000011">mask</a>&nbsp;&nbsp;
+      <a href="#M000013">msb</a>&nbsp;&nbsp;
+      <a href="#M000001">new</a>&nbsp;&nbsp;
+      <a href="#M000014">population</a>&nbsp;&nbsp;
+      <a href="#M000015">resize</a>&nbsp;&nbsp;
+      <a href="#M000016">resize!</a>&nbsp;&nbsp;
+      <a href="#M000017">rotate</a>&nbsp;&nbsp;
+      <a href="#M000018">rotate!</a>&nbsp;&nbsp;
+      <a href="#M000019">select</a>&nbsp;&nbsp;
+      <a href="#M000020">shrink</a>&nbsp;&nbsp;
+      <a href="#M000021">shrink!</a>&nbsp;&nbsp;
+      <a href="#M000022">slice</a>&nbsp;&nbsp;
+      <a href="#M000023">slice!</a>&nbsp;&nbsp;
+      <a href="#M000024">to_i</a>&nbsp;&nbsp;
+      <a href="#M000025">to_s</a>&nbsp;&nbsp;
+      <a href="#M000032">|</a>&nbsp;&nbsp;
+      <a href="#M000033">~</a>&nbsp;&nbsp;
+      </div>
+    </div>
+
+  </div>
+
+
+    <!-- if includes -->
+    <div id="includes">
+      <h3 class="section-bar">Included Modules</h3>
+
+      <div id="includes-list">
+        <span class="include-name">Enumerable</span>
+      </div>
+    </div>
+
+    <div id="section">
+
+
+    <div id="constants-list">
+      <h3 class="section-bar">Constants</h3>
+
+      <div class="name-list">
+        <table summary="Constants">
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">Version</td>
+          <td>=</td>
+          <td class="context-item-value">Versionomy.parse('0.1.0a2')</td>
+          <td width="3em">&nbsp;</td>
+          <td class="context-item-desc">
+Versionomy object for the class, recording the current version.
+
+</td>
+        </tr>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">VERSION</td>
+          <td>=</td>
+          <td class="context-item-value">Version.to_s</td>
+          <td width="3em">&nbsp;</td>
+          <td class="context-item-desc">
+Version number as a simple readable string.
+
+</td>
+        </tr>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">LOW_END</td>
+          <td>=</td>
+          <td class="context-item-value">:low</td>
+          <td width="3em">&nbsp;</td>
+          <td class="context-item-desc">
+Identifer specifying the least significant (low) end of the bitstring (used
+by <em><a href="BitString.html#M000007">grow</a></em>, <em><a
+href="BitString.html#M000020">shrink</a></em>, and <em><a
+href="BitString.html#M000011">mask</a></em>).
+
+</td>
+        </tr>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">HIGH_END</td>
+          <td>=</td>
+          <td class="context-item-value">:high</td>
+          <td width="3em">&nbsp;</td>
+          <td class="context-item-desc">
+Identifer specifying the most significant (high) end of the bitstring (used
+by <em><a href="BitString.html#M000007">grow</a></em>, <em><a
+href="BitString.html#M000020">shrink</a></em>, and <em><a
+href="BitString.html#M000011">mask</a></em>).
+
+</td>
+        </tr>
+        </table>
+      </div>
+    </div>
+
+
+
+    <div id="attribute-list">
+      <h3 class="section-bar">Attributes</h3>
+
+      <div class="name-list">
+        <table>
+        <tr class="top-aligned-row context-row">
+          <td class="context-item-name">bounded</td>
+          <td class="context-item-value">&nbsp;[R]&nbsp;</td>
+          <td class="context-item-desc">
+<em>Boolean</em>. Whether or not the bitstring is bounded and limited to a
+specific <a href="BitString.html#M000009">length</a>. Read-only; set at
+object creation.
+
+</td>
+        </tr>
+        </table>
+      </div>
+    </div>
+      
+
+
+    <!-- if method_list -->
+    <div id="methods">
+      <h3 class="section-bar">Public Class methods</h3>
+
+      <div id="method-M000012" class="method-detail">
+        <a name="M000012"></a>
+
+        <div class="method-heading">
+          <a href="#M000012" class="method-signature">
+          <span class="method-name">BitString.mask<i>(bitcount)</i> => <i>Integer</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Class method to return an integer value with the specified number of bits
+(starting at position 0) all set to 1.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bitcount</em></dt><dd><em>Integer</em>. Number of bits to set in the <a
+href="BitString.html#M000011">mask</a>.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ BitString.mask(5).to_s(2)
+ =&gt; &quot;11111&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000012-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000012-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 908</span>
+908:   <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mask</span>(<span class="ruby-identifier">bits</span>=<span class="ruby-value">1</span>)
+909:     <span class="ruby-identifier">new</span>.<span class="ruby-identifier">_raise</span>(<span class="ruby-constant">NoDeficitBits</span>) <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>)
+910:     <span class="ruby-identifier">vMask</span> = <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">bits</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+911:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000001" class="method-detail">
+        <a name="M000001"></a>
+
+        <div class="method-heading">
+          <a href="#M000001" class="method-signature">
+          <span class="method-name">new<i>([val], [bitcount])</i> => <i>BitString</i><br />
+new<i>(length) {|index| block }</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Create a <a href="BitString.html#M000001">new</a> <em><a
+href="BitString.html">BitString</a></em> object. By default, it will be
+unbounded and all bits <a href="BitString.html#M000003">clear</a>.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>val</em></dt><dd><em>Array</em>, <em>Integer</em>, <em>String</em>, or <em><a
+href="BitString.html">BitString</a></em>. Initial value for the bitstring.
+If a <em>String</em>, the value must contain only &#8216;0&#8217; and
+&#8216;1&#8217; characters; if an <em>Array</em>, all elements must be 0 or
+1. Default 0.
+
+</dd>
+<dt><em>bitcount</em></dt><dd><em>Integer</em>. Optional <a href="BitString.html#M000009">length</a>
+(number of bits) for a bounded bitstring.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(4095)
+ bs.to_s
+ =&gt; &quot;111111111111&quot;
+ bs.bounded?
+ =&gt; false
+
+ bs = BitString.new('110000010111', 12)
+ bs.bounded?
+ =&gt; true
+ bs.to_i
+ =&gt; 3095
+
+ bs = BitString.new(12) { |pos| pos % 2 }
+ bs.to_s
+ =&gt; &quot;101010101010&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>RangeError</tt></dt><dd><em>val</em> is a string, but contains non-binary digits.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000001-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000001-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 289</span>
+289:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args_p</span>, <span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+290:     <span class="ruby-comment cmt">#</span>
+291:     <span class="ruby-comment cmt"># Two constructor scenarios:</span>
+292:     <span class="ruby-comment cmt">#</span>
+293:     <span class="ruby-comment cmt"># 1. With a block and an optional length (defaults to 1)</span>
+294:     <span class="ruby-comment cmt"># 2. No block, and with value and length both optional.</span>
+295:     <span class="ruby-comment cmt">#</span>
+296:     <span class="ruby-comment cmt"># We don't do any type-checking on the arguments until later.</span>
+297:     <span class="ruby-comment cmt">#</span>
+298:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">block</span>.<span class="ruby-identifier">nil?</span>)
+299:       <span class="ruby-comment cmt">#</span>
+300:       <span class="ruby-comment cmt"># We got a block; set up the constraints.  Bitstrings constructed</span>
+301:       <span class="ruby-comment cmt"># this way are bounded.</span>
+302:       <span class="ruby-comment cmt">#</span>
+303:       <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">args_p</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">2</span>)
+304:         <span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value str">'only bitstring length '</span> <span class="ruby-operator">+</span>
+305:                                 <span class="ruby-value str">'may be specified with a block'</span>)
+306:       <span class="ruby-keyword kw">end</span>
+307:       <span class="ruby-ivar">@bounded</span> = <span class="ruby-keyword kw">true</span>
+308:       <span class="ruby-ivar">@length</span> = <span class="ruby-identifier">args_p</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">args_p</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">:</span> <span class="ruby-value">1</span>
+309:     <span class="ruby-keyword kw">else</span>
+310:       <span class="ruby-comment cmt">#</span>
+311:       <span class="ruby-comment cmt"># Get value and possibly length from the argument list.</span>
+312:       <span class="ruby-comment cmt">#</span>
+313:       <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">args_p</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">3</span>)
+314:         <span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value str">'wrong number of arguments '</span> <span class="ruby-operator">+</span>
+315:                                 <span class="ruby-value str">'(must be 2 or fewer)'</span>)
+316:       <span class="ruby-keyword kw">end</span>
+317:       <span class="ruby-identifier">val</span> = <span class="ruby-identifier">args_p</span>[<span class="ruby-value">0</span>] <span class="ruby-operator">||</span> <span class="ruby-value">0</span>
+318:       <span class="ruby-ivar">@length</span> = <span class="ruby-identifier">args_p</span>[<span class="ruby-value">1</span>] <span class="ruby-keyword kw">if</span> (<span class="ruby-ivar">@bounded</span> = <span class="ruby-operator">!</span> <span class="ruby-identifier">args_p</span>[<span class="ruby-value">1</span>].<span class="ruby-identifier">nil?</span>)
+319:     <span class="ruby-keyword kw">end</span>
+320:     <span class="ruby-comment cmt">#</span>
+321:     <span class="ruby-comment cmt"># Now do some validation on the arguments.</span>
+322:     <span class="ruby-comment cmt">#</span>
+323:     <span class="ruby-keyword kw">if</span> (<span class="ruby-ivar">@bounded</span>)
+324:       <span class="ruby-keyword kw">unless</span> ((<span class="ruby-ivar">@length</span> = <span class="ruby-ivar">@length</span>.<span class="ruby-identifier">to_i</span>) <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>)
+325:         <span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value str">'bitstring length must be greater than 0'</span>)
+326:       <span class="ruby-keyword kw">end</span>
+327:     <span class="ruby-keyword kw">end</span>
+328:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">block</span>.<span class="ruby-identifier">nil?</span>)
+329:       <span class="ruby-comment cmt">#</span>
+330:       <span class="ruby-comment cmt"># We weren't passed a block, so get the info directly from the argument</span>
+331:       <span class="ruby-comment cmt"># list.</span>
+332:       <span class="ruby-comment cmt">#</span>
+333:       <span class="ruby-ivar">@value</span> = <span class="ruby-identifier">_arg2int</span>(<span class="ruby-identifier">val</span>)
+334:     <span class="ruby-keyword kw">else</span>      
+335:       <span class="ruby-comment cmt">#</span>
+336:       <span class="ruby-comment cmt"># We were passed a block, so invoke it for each bit position to</span>
+337:       <span class="ruby-comment cmt"># determine that bit's value from the LSB of the result.</span>
+338:       <span class="ruby-comment cmt">#</span>
+339:       <span class="ruby-ivar">@value</span> = <span class="ruby-value">0</span>
+340:       <span class="ruby-ivar">@length</span>.<span class="ruby-identifier">times</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span> <span class="ruby-keyword kw">self</span>[<span class="ruby-identifier">i</span>] = <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">i</span>).<span class="ruby-identifier">to_i</span> <span class="ruby-operator">&amp;</span> <span class="ruby-value">1</span> }
+341:     <span class="ruby-keyword kw">end</span>
+342:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <h3 class="section-bar">Public Instance methods</h3>
+
+      <div id="method-M000026" class="method-detail">
+        <a name="M000026"></a>
+
+        <div class="method-heading">
+          <a href="#M000026" class="method-signature">
+          <span class="method-name">bitstring <i>& value</i> => <i>BitString</i><br />
+bitstring.&<i>(value)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Perform a bitwise AND on the entire bitstring, returning a <a
+href="BitString.html#M000001">new</a> <em><a
+href="BitString.html">BitString</a></em> object. The <a
+href="BitString.html#M000001">new</a> bitstring will have the same
+boundedness as the original.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>value</em></dt><dd><em><a href="BitString.html">BitString</a></em>, <em>Integer</em>, or
+<em>String</em>. Value to AND with the bitstring.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('111111111')
+ nbs = bs &amp; '111100011'
+ nbs.to_s
+ =&gt; &quot;111100011&quot;
+
+ bs = BitString.new('10101010101', 11)
+ nbs = bs &amp; '11110001111'
+ nbs.to_s
+ =&gt; &quot;10100000101&quot;
+ nbs = bs &amp; '00001110000'
+ nbs.to_s
+ =&gt; &quot;00001010000&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000026-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000026-source">
+<pre>
+    <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 91</span>
+91:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">&amp;</span>(<span class="ruby-identifier">val</span>)
+92:     <span class="ruby-identifier">val</span> = <span class="ruby-identifier">_arg2int</span>(<span class="ruby-identifier">val</span>)
+93:     <span class="ruby-identifier">vMask</span> = <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mask</span>
+94:     <span class="ruby-identifier">newval</span> = (<span class="ruby-ivar">@value</span> <span class="ruby-operator">&amp;</span> <span class="ruby-identifier">val</span>) <span class="ruby-operator">&amp;</span> <span class="ruby-identifier">vMask</span>
+95:     <span class="ruby-identifier">bounded?</span> <span class="ruby-value">? </span><span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">newval</span>, <span class="ruby-ivar">@length</span>) <span class="ruby-operator">:</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">newval</span>)
+96:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000027" class="method-detail">
+        <a name="M000027"></a>
+
+        <div class="method-heading">
+          <a href="#M000027" class="method-signature">
+          <span class="method-name">bitstring <i>&lt;&lt; bitcount</i> => <i>BitString</i><br />
+bitstring.&lt;&lt;<i>(bitcount)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Perform a left-shift on the bitstring, returning a <a
+href="BitString.html#M000001">new</a> <em><a
+href="BitString.html">BitString</a></em> containing the shifted value. If
+the bitstring is bounded, bits shifted off the high end are lost.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bitcount</em></dt><dd><em>Integer</em>. Number of positions by which to left-shift.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('1100111')
+ nbs = bs &lt;&lt; 2
+ nbs.to_s
+ =&gt; &quot;110011100&quot;
+
+ bs = BitString.new('00010001', 8)
+ nbs = bs &lt;&lt; 2
+ nbs.to_s
+ =&gt; &quot;01000100&quot;
+ nbs = bs &lt;&lt; 4
+ nbs.to_s
+ =&gt; &quot;00010000&quot;   # High bits shifted off and lost
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000027-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000027-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 129</span>
+129:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">&lt;&lt;</span>(<span class="ruby-identifier">bits</span>)
+130:     <span class="ruby-identifier">value</span> = <span class="ruby-ivar">@value</span> <span class="ruby-operator">*</span> (<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">bits</span>.<span class="ruby-identifier">to_i</span>)
+131:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bounded?</span>)
+132:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span> <span class="ruby-operator">&amp;</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mask</span>, <span class="ruby-ivar">@length</span>)
+133:     <span class="ruby-keyword kw">else</span>
+134:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>)
+135:     <span class="ruby-keyword kw">end</span>
+136:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000034" class="method-detail">
+        <a name="M000034"></a>
+
+        <div class="method-heading">
+          <a href="#M000034" class="method-signature">
+          <span class="method-name">bitstring == <i>compstring</i> => <i>Boolean</i><br />
+bitstring.==<i>(compstring)</i> => <i>Boolean</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Perform an equality check against another bitstring or representation of
+one. The value and the boundedness must both match to be considered equal.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>compstring</em></dt><dd><em>Array</em>, <em><a href="BitString.html">BitString</a></em>,
+<em>Integer</em>, or <em>String</em>. Bitstring (or something representing
+one) against which to compare.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs1 = BitString.new('111111111')
+ bs2 = BitString.new('111111111', 9)
+ bs1 == bs2
+ =&gt; false     # Boundedness doesn't match
+
+ bs1 = BitString.new('111111111')
+ bs2 = BitString.new('111111111')
+ bs1 == bs2
+ =&gt; true      # Values and boundedness match
+
+ bs1 = BitString.new('111111111')
+ bs1 == '111111111'
+ =&gt; true      # When converted to an unbounded bitstring, it matches
+
+ bs1 = BitString.new('111111111')
+ bs1 == '0000000111111111'
+ =&gt; true      # When converted to an unbounded bitstring, it matches
+
+ bs1 = BitString.new('111111111')
+ bs1 == 511
+ =&gt; true      # When converted to an unbounded bitstring, it matches
+
+ bs1 = BitString.new('111111111', 9)
+ bs1 == '1000111111111'
+ =&gt; false     # When converted to a bounded bitstring (because bs1 is),
+              # lengths and values don't match
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000034-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000034-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 487</span>
+487:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">==</span>(<span class="ruby-identifier">value</span>)
+488:     <span class="ruby-comment cmt">#</span>
+489:     <span class="ruby-comment cmt"># Bitstring/bitstring comparison</span>
+490:     <span class="ruby-comment cmt">#</span>
+491:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">class</span> <span class="ruby-operator">==</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>)
+492:       <span class="ruby-identifier">value</span> = <span class="ruby-identifier">_arg2int</span>(<span class="ruby-identifier">value</span>)
+493:       <span class="ruby-keyword kw">if</span> (<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">bounded?</span>)
+494:         <span class="ruby-identifier">bits</span> = [<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">length</span>, <span class="ruby-identifier">value</span>.<span class="ruby-identifier">to_s</span>(<span class="ruby-value">2</span>).<span class="ruby-identifier">length</span>].<span class="ruby-identifier">max</span>
+495:         <span class="ruby-identifier">value</span> = <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>, <span class="ruby-identifier">bits</span>)
+496:       <span class="ruby-keyword kw">else</span>
+497:         <span class="ruby-identifier">value</span> = <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>)
+498:       <span class="ruby-keyword kw">end</span>
+499:     <span class="ruby-keyword kw">end</span>
+500:     ((<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">class</span>) <span class="ruby-operator">&amp;&amp;</span>
+501:      (<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">bounded?</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">bounded?</span>) <span class="ruby-operator">&amp;&amp;</span>
+502:      (<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">length</span>) <span class="ruby-operator">&amp;&amp;</span>
+503:      (<span class="ruby-ivar">@value</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">value</span>.<span class="ruby-identifier">to_i</span>))
+504:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000028" class="method-detail">
+        <a name="M000028"></a>
+
+        <div class="method-heading">
+          <a href="#M000028" class="method-signature">
+          <span class="method-name">bitstring &gt;&gt; <i>bitcount</i> => <i>BitString</i><br />
+bitstring.&gt;&gt;<i>(bitcount)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Right-shift the bitstring (toward the low end) by the specified number of
+bits. Bits shifted off the end are lost; <a
+href="BitString.html#M000001">new</a> bits shifted in at the high end are
+0.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bitcount</em></dt><dd><em>Integer</em>. Number of positions to right-shift by.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('1100111')
+ nbs = bs &gt;&gt; 2
+ nbs.to_s
+ =&gt; &quot;11001&quot;
+
+ bs = BitString.new('00010001', 8)
+ nbs = bs &gt;&gt; 2
+ nbs.to_s
+ =&gt; &quot;00000100&quot;
+ nbs = bs &gt;&gt; 4
+ nbs.to_s
+ =&gt; &quot;00000001&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000028-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000028-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 169</span>
+169:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">&gt;&gt;</span>(<span class="ruby-identifier">bits</span>)
+170:     <span class="ruby-identifier">value</span> = <span class="ruby-ivar">@value</span> <span class="ruby-operator">/</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">bits</span>.<span class="ruby-identifier">to_i</span>
+171:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bounded?</span>)
+172:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>, <span class="ruby-ivar">@length</span>)
+173:     <span class="ruby-keyword kw">else</span>
+174:       <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>)
+175:     <span class="ruby-keyword kw">end</span>
+176:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000029" class="method-detail">
+        <a name="M000029"></a>
+
+        <div class="method-heading">
+          <a href="#M000029" class="method-signature">
+          <span class="method-name">bitstring<i>[index]</i> => <i>Integer</i><br />
+bitstring<i>[start, length]</i> => <i>BitString</i><br />
+bitstring<i>[range]</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Extract a particular substring from the bitstring. If we&#8216;re given a
+single index, we return an integer; if a range, we return a <a
+href="BitString.html#M000001">new</a> <a
+href="BitString.html">BitString</a>.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>index</em></dt><dd><em>Integer</em>. Single bit position.
+
+</dd>
+<dt><em>start</em></dt><dd><em>Integer</em>. Start position of subset.
+
+</dd>
+<dt><em><a href="BitString.html#M000009">length</a></em></dt><dd><em>Integer</em>. Length of subset.
+
+</dd>
+<dt><em>range</em></dt><dd><em>Range</em>. Subset specified as a range.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('110010110')
+ bs[0]
+ =&gt; 0
+ bs[1]
+ =&gt; 1
+ bs[0..1].to_s       # Multi-bit indexing returns a bitsring
+ =&gt; &quot;10&quot;
+ bs[0,9].to_s
+ =&gt; &quot;110010110&quot;
+ bs[100..102].to_s   # Can index 'way past the end for unbounded bitstrings
+ =&gt; &quot;000&quot;
+
+ bs = BitString.new('110010110', 9)
+ bs[100..102].to_s   #
+ =&gt; exception: &quot;IndexError: index out of range&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd>If <a href="BitString.html#M000009">length</a> specified with a range.
+
+</dd>
+<dt><tt>IndexError</tt></dt><dd>If bitstring is bounded and the substring is illegal.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000029-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000029-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 217</span>
+217:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">[]</span>(<span class="ruby-identifier">pos_p</span>, <span class="ruby-identifier">length_p</span>=<span class="ruby-keyword kw">nil</span>)
+218:     <span class="ruby-comment cmt">#</span>
+219:     <span class="ruby-comment cmt"># Turn a position/length into a range.</span>
+220:     <span class="ruby-comment cmt">#</span>
+221:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">pos_p</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">Integer</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">length_p</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">Integer</span>))
+222:       <span class="ruby-identifier">pos_p</span> = <span class="ruby-constant">Range</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">pos_p</span>, <span class="ruby-identifier">pos_p</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">length_p</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)
+223:       <span class="ruby-identifier">length_p</span> = <span class="ruby-keyword kw">nil</span>
+224:     <span class="ruby-keyword kw">end</span>
+225:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">pos_p</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">Range</span>))
+226:       <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">length_p</span>.<span class="ruby-identifier">nil?</span>)
+227:         <span class="ruby-identifier">raise</span> <span class="ruby-constant">ArgumentError</span>.<span class="ruby-identifier">new</span>(<span class="ruby-value str">'length not allowed with range'</span>)
+228:       <span class="ruby-keyword kw">end</span>
+229:       <span class="ruby-identifier">pos_a</span> = <span class="ruby-identifier">pos_p</span>.<span class="ruby-identifier">to_a</span>
+230:       <span class="ruby-identifier">pos_a</span>.<span class="ruby-identifier">reverse!</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">pos_a</span>.<span class="ruby-identifier">first</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">pos_a</span>.<span class="ruby-identifier">last</span>)
+231:       <span class="ruby-identifier">r</span> = <span class="ruby-identifier">pos_a</span>.<span class="ruby-identifier">collect</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">pos</span><span class="ruby-operator">|</span> <span class="ruby-keyword kw">self</span>[<span class="ruby-identifier">pos</span>].<span class="ruby-identifier">to_s</span> }
+232:       <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">r</span>.<span class="ruby-identifier">join</span>(<span class="ruby-value str">''</span>), <span class="ruby-identifier">r</span>.<span class="ruby-identifier">length</span>)
+233:     <span class="ruby-keyword kw">end</span>
+234:     <span class="ruby-identifier">pos</span> = <span class="ruby-identifier">pos_p</span>.<span class="ruby-identifier">to_i</span>
+235:     <span class="ruby-comment cmt">#</span>
+236:     <span class="ruby-comment cmt"># Blow an error if we were given an index out of range.</span>
+237:     <span class="ruby-comment cmt">#</span>
+238:     <span class="ruby-keyword kw">unless</span> ((<span class="ruby-identifier">pos</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-value">0</span>) <span class="ruby-operator">&amp;&amp;</span>
+239:             ((<span class="ruby-operator">!</span> <span class="ruby-identifier">bounded?</span>) <span class="ruby-operator">||</span> <span class="ruby-identifier">pos</span>.<span class="ruby-identifier">between?</span>(<span class="ruby-value">0</span>, <span class="ruby-ivar">@length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)))
+240:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">OuttasightIndex</span>, <span class="ruby-identifier">pos</span>)
+241:     <span class="ruby-keyword kw">end</span>
+242:     (<span class="ruby-ivar">@value</span> <span class="ruby-operator">&amp;</span> (<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">pos</span>)) <span class="ruby-operator">/</span> (<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">pos</span>)
+243:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000030" class="method-detail">
+        <a name="M000030"></a>
+
+        <div class="method-heading">
+          <a href="#M000030" class="method-signature">
+          <span class="method-name">bitstring[<i>pos</i>] = <i>value</i>   => <i>value</i><br />
+bitstring[<i>start, length</i>] = <i>value</i>   => <i>value</i><br />
+bitstring[<i>range</i>] = <i>value</i>   => <i>value</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Set a bit or range of bits with a single operation.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>value</em></dt><dd><em>Array</em>, <em><a href="BitString.html">BitString</a></em>,
+<em>Integer</em>, or <em>String</em>. Value (treated as a stream of bits)
+used to set the bitstring.
+
+</dd>
+<dt><em>pos</em></dt><dd><em>Integer</em>. Single bit position to alter.
+
+</dd>
+<dt><em>start</em></dt><dd><em>Integer</em>. First bit position in substring.
+
+</dd>
+<dt><em><a href="BitString.html#M000009">length</a></em></dt><dd><em>Integer</em>. Number of bits in substring.
+
+</dd>
+<dt><em>range</em></dt><dd><em>Range</em>. Range of bits (<em>e.g.</em>, 5..10) to affect.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('110010110')
+ bs[0] = 1
+ =&gt; 1
+ bs.to_s
+ =&gt; &quot;110010111&quot;
+ bs[1] = 0
+ =&gt; 0
+ bs.to_s
+ =&gt; &quot;110010101&quot;
+ bs[0..3] = 14       # Multi-bit indexing set a bitsring
+ =&gt; &quot;14&quot;
+ bs.to_s
+ =&gt; &quot;110011110&quot;
+ bs[12..14] = 5
+ =&gt; 5
+ bs.to_s
+ =&gt; &quot;101000110011110&quot; # Can index past the end for unbounded bitstrings
+
+ bs = BitString.new('110010110', 9)
+ bs[1,3] = 4095       # 111111111111, but gets truncated to low 3 bits
+ bs.to_s
+ =&gt; &quot;110011110&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd>Both range and <a href="BitString.html#M000009">length</a> specified, or
+value cannot be interpreted as an integer.
+
+</dd>
+<dt><tt>IndexError</tt></dt><dd>Non-integer or negative index, or beyond the end of the bitstring.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000030-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000030-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 290</span>
+290:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">[]=</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args_p</span>)
+291:     <span class="ruby-identifier">low</span> = <span class="ruby-identifier">high</span> = <span class="ruby-identifier">width</span> = <span class="ruby-keyword kw">nil</span>
+292:     <span class="ruby-identifier">args</span> = <span class="ruby-identifier">args_p</span>
+293:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">args</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">==</span> <span class="ruby-value">2</span>)
+294:       <span class="ruby-comment cmt">#</span>
+295:       <span class="ruby-comment cmt"># [pos]= or [range]=</span>
+296:       <span class="ruby-comment cmt">#</span>
+297:       <span class="ruby-keyword kw">if</span> ((<span class="ruby-identifier">r</span> = <span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>]).<span class="ruby-identifier">class</span>.<span class="ruby-identifier">eql?</span>(<span class="ruby-constant">Range</span>))
+298:         <span class="ruby-comment cmt">#</span>
+299:         <span class="ruby-comment cmt"># Convert into a [start,length] format to reuse that stream.</span>
+300:         <span class="ruby-comment cmt">#</span>
+301:         (<span class="ruby-identifier">start</span>, <span class="ruby-identifier">stop</span>) = [<span class="ruby-identifier">r</span>.<span class="ruby-identifier">first</span>, <span class="ruby-identifier">r</span>.<span class="ruby-identifier">last</span>].<span class="ruby-identifier">sort</span>
+302:         <span class="ruby-identifier">width</span> = <span class="ruby-identifier">stop</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">start</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span>
+303:         <span class="ruby-identifier">args</span> = [<span class="ruby-identifier">start</span>, <span class="ruby-identifier">width</span>, <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>]]
+304:       <span class="ruby-keyword kw">else</span>
+305:         <span class="ruby-identifier">args</span> = [<span class="ruby-identifier">args</span>[<span class="ruby-value">0</span>], <span class="ruby-value">1</span>, <span class="ruby-identifier">args</span>[<span class="ruby-value">1</span>]]
+306:       <span class="ruby-keyword kw">end</span>
+307:     <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">args_p</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">!=</span> <span class="ruby-value">3</span>)
+308:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">WrongNargs</span>, <span class="ruby-identifier">args_p</span>.<span class="ruby-identifier">length</span>, <span class="ruby-value">3</span>)
+309:     <span class="ruby-keyword kw">end</span>
+310:     <span class="ruby-comment cmt">#</span>
+311:     <span class="ruby-comment cmt"># Special cases of args have now been normalised to [start,length,value].</span>
+312:     <span class="ruby-comment cmt"># Make sure the values are acceptable.</span>
+313:     <span class="ruby-comment cmt">#</span>
+314:     (<span class="ruby-identifier">start</span>, <span class="ruby-identifier">nBits</span>, <span class="ruby-identifier">value</span>) = <span class="ruby-identifier">args</span>
+315:     <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">BogoIndex</span>, <span class="ruby-identifier">start</span>) <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">start</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-identifier">:to_i</span>))
+316:     <span class="ruby-identifier">start</span> = <span class="ruby-identifier">start</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">start</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">Integer</span>))
+317:     <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">BogoIndex</span>, <span class="ruby-identifier">nBits</span>) <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">nBits</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-identifier">:to_i</span>))
+318:     <span class="ruby-identifier">nBits</span> = <span class="ruby-identifier">length</span>.<span class="ruby-identifier">to_i</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">nBits</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">Integer</span>))
+319:     <span class="ruby-identifier">highpos</span> = <span class="ruby-identifier">start</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">nBits</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+320:     <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">OuttasightIndex</span>, <span class="ruby-identifier">highpos</span>) <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bounded?</span> <span class="ruby-operator">&amp;&amp;</span> (<span class="ruby-identifier">highpos</span> <span class="ruby-operator">&gt;</span> <span class="ruby-ivar">@length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>))
+321:     <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">BitsRInts</span>, <span class="ruby-identifier">value</span>) <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">value</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-identifier">:to_i</span>))
+322:     <span class="ruby-identifier">value</span> = <span class="ruby-identifier">_arg2int</span>(<span class="ruby-identifier">value</span>)
+323:     <span class="ruby-comment cmt">#</span>
+324:     <span class="ruby-comment cmt"># All the checking is done, let's do this thing.</span>
+325:     <span class="ruby-comment cmt">#</span>
+326:     <span class="ruby-identifier">vMask</span> = <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">nBits</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+327:     <span class="ruby-identifier">fvalue</span> = (<span class="ruby-identifier">value</span> <span class="ruby-operator">&amp;=</span> <span class="ruby-identifier">vMask</span>)
+328:     <span class="ruby-identifier">vMask</span> <span class="ruby-operator">*=</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">start</span>
+329:     <span class="ruby-identifier">value</span> <span class="ruby-operator">*=</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">start</span>
+330: 
+331:     <span class="ruby-identifier">highpos</span> = <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">length</span>
+332:     <span class="ruby-identifier">bValue</span> = <span class="ruby-ivar">@value</span> <span class="ruby-operator">&amp;</span> ((<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">highpos</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>) <span class="ruby-operator">&amp;</span> <span class="ruby-operator">~</span><span class="ruby-identifier">vMask</span>)
+333:     <span class="ruby-ivar">@value</span> = <span class="ruby-identifier">bValue</span> <span class="ruby-operator">|</span> <span class="ruby-identifier">value</span>
+334:     <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">fvalue</span>
+335:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000031" class="method-detail">
+        <a name="M000031"></a>
+
+        <div class="method-heading">
+          <a href="#M000031" class="method-signature">
+          <span class="method-name">bitstring <i>^ value</i> => <i>BitString</i><br />
+bitstring.^<i>(value)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Perform a bitwise exclusive OR (XOR) and return a copy of the result.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>value</em></dt><dd><em>Array</em>, <em><a href="BitString.html">BitString</a></em>,
+<em>Integer</em>, or <em>String</em>. Value treated as a bitstream and
+exclusively ORed with the bitstring.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('110010110', 9)
+ nbs = bs ^ '001101001'
+ nbs.to_s
+ =&gt; &quot;111111111&quot;
+ nbs = bs ^ bs.mask   # Equivalent to 'nbs =  ~ bs'
+ nbs.to_s
+ =&gt; &quot;001101001&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000031-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000031-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 362</span>
+362:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">^</span>(<span class="ruby-identifier">value</span>)
+363:     <span class="ruby-identifier">value</span> = <span class="ruby-identifier">_arg2int</span>(<span class="ruby-identifier">value</span>)
+364:     <span class="ruby-identifier">value</span> <span class="ruby-operator">&amp;=</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mask</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bounded?</span>)
+365:     <span class="ruby-identifier">bs</span> = <span class="ruby-identifier">dup</span>
+366:     <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">from_i</span>(<span class="ruby-identifier">value</span> <span class="ruby-operator">^</span> <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">to_i</span>)
+367:     <span class="ruby-identifier">bs</span>
+368:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000002" class="method-detail">
+        <a name="M000002"></a>
+
+        <div class="method-heading">
+          <a href="#M000002" class="method-signature">
+          <span class="method-name">bitstring.bounded?()<br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return a Boolean indicating whether the bitstring has a fixed <a
+href="BitString.html#M000009">length</a> (is bounded) or not.
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(3095)
+ bs.bounded?
+ =&gt; false
+
+ bs = BitString.new(3095, 12)
+ bs.bounded?
+ =&gt; true
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000002-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000002-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 565</span>
+565:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">bounded?</span>()
+566:     <span class="ruby-ivar">@bounded</span>
+567:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000003" class="method-detail">
+        <a name="M000003"></a>
+
+        <div class="method-heading">
+          <a href="#M000003" class="method-signature">
+          <span class="method-name">bitstring.clear<i>()</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return a duplicate of the current bitstring &#8212; with all bits cleared.
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(3095)
+ nbs = bs.clear
+ bs.to_s
+ =&gt; &quot;110000010111&quot;
+ nbs.to_s
+ =&gt; &quot;0&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000003-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000003-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 591</span>
+591:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">clear</span>()
+592:     <span class="ruby-identifier">bs</span> = <span class="ruby-identifier">dup</span>
+593:     <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">from_i</span>(<span class="ruby-value">0</span>)
+594:     <span class="ruby-identifier">bs</span>
+595:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000004" class="method-detail">
+        <a name="M000004"></a>
+
+        <div class="method-heading">
+          <a href="#M000004" class="method-signature">
+          <span class="method-name">bitstring.clear!<i>()</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Clear all the bits in the bitstring.
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(3095, 12)
+ bs.to_s
+ =&gt; &quot;110000010111&quot;
+ bs.clear!
+ bs.to_s
+ =&gt; &quot;000000000000&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000004-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000004-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 619</span>
+619:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">clear!</span>()
+620:     <span class="ruby-ivar">@value</span> = <span class="ruby-value">0</span>
+621:     <span class="ruby-keyword kw">self</span>
+622:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000005" class="method-detail">
+        <a name="M000005"></a>
+
+        <div class="method-heading">
+          <a href="#M000005" class="method-signature">
+          <span class="method-name">bitstring.<i>each</i> { |<i>bitval</i>| <i>block</i> } => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Execute a block for <a href="BitString.html#M000005">each</a> bit in the
+bitstring.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>block</em></dt><dd><em>Proc</em>. Block to be called for <a
+href="BitString.html#M000005">each</a> bit in the string. The block is
+passed the bit value.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('100101')
+ bs.each { |bitval| puts bitval }
+ 1
+ 0
+ 1
+ 0
+ 0
+ 1
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000005-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000005-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 648</span>
+648:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">each</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+649:     <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">length</span>.<span class="ruby-identifier">times</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">bit</span><span class="ruby-operator">|</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-keyword kw">self</span>[<span class="ruby-identifier">bit</span>]) }
+650:     <span class="ruby-keyword kw">self</span>
+651:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000006" class="method-detail">
+        <a name="M000006"></a>
+
+        <div class="method-heading">
+          <a href="#M000006" class="method-signature">
+          <span class="method-name">bitstring.from_i<i>(newval)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Treat the bitstring as an Integer and store its entire value at once.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>newval</em></dt><dd><em>Integer</em>. Value from which bits will be copied to the bitstring.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(0, 12)
+ bs.to_s
+ =&gt; &quot;000000000000&quot;
+ bs.from_i(3095)
+ bs.to_s
+ =&gt; &quot;110000010111&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000006-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000006-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 676</span>
+676:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">from_i</span>(<span class="ruby-identifier">newval</span>)
+677:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">newval</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-identifier">:to_i</span>))
+678:       <span class="ruby-identifier">what</span> = <span class="ruby-identifier">newval</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-identifier">:to_s</span>) <span class="ruby-operator">?</span> <span class="ruby-identifier">newval</span>.<span class="ruby-identifier">to_s</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">newval</span>.<span class="ruby-identifier">inspect</span>
+679:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">UnInterable</span>, <span class="ruby-identifier">newval</span>)
+680:     <span class="ruby-keyword kw">end</span>
+681:     <span class="ruby-identifier">newval</span> = <span class="ruby-identifier">newval</span>.<span class="ruby-identifier">to_i</span>
+682:     <span class="ruby-identifier">newval</span> <span class="ruby-operator">&amp;=</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-ivar">@length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bounded?</span>)
+683:     <span class="ruby-ivar">@value</span> = <span class="ruby-identifier">newval</span>
+684:     <span class="ruby-keyword kw">self</span>
+685:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000007" class="method-detail">
+        <a name="M000007"></a>
+
+        <div class="method-heading">
+          <a href="#M000007" class="method-signature">
+          <span class="method-name">bitstring.grow<i>(bits, [defval], [direction])</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return a <a href="BitString.html#M000001">new</a> bitstring based on the
+current one, grown (made longer) in one direction (toward the least
+significant bits) or the other. Growing an unbounded string toward the high
+end is a no-op.
+</p>
+<p>
+Bits added are set to <em>defval</em> (default 0).
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bits</em></dt><dd><em>Integer</em>. Number of bits to add.
+
+</dd>
+<dt><em>defval</em></dt><dd><em>Integer</em>. Value to which added bits should be set.
+
+</dd>
+<dt><em>direction</em></dt><dd><em>Constant</em>. Either <tt>BitString::HIGH_END</tt> (the default) or
+<tt>BitString::LOW_END&lt;/t&gt;. Indicates whether bits are added at the
+least or most significant end. Growing with
+&lt;tt&gt;BitString::LOW_END</tt> results in the bitstring being shifted
+left.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString(5, 3)
+ bs.to_s
+ =&gt; &quot;101&quot;
+ nbs = bs.grow(3)
+ nbs.to_s
+ =&gt; &quot;000101&quot;
+ nbs = bs.grow(3, 1)
+ nbs.to_s
+ =&gt; &quot;111101&quot;
+ nbs = bs.grow(3, 0, BitString::LOW_END)
+ nbs.to_s
+ =&gt; &quot;101000&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd><em>bits</em> isn&#8216;t an integer, <em>defval</em> can&#8216;t be
+reduced to a binary value, or <em>direction</em> isn&#8216;t one of the
+defined values.
+
+</dd>
+<dt><tt>IndexError</tt></dt><dd><em>bits</em> is negative or meaningless.
+
+</dd>
+<dt><tt>RuntimeError</tt></dt><dd>Can&#8216;t <a href="BitString.html#M000007">grow</a> an unbounded string
+at the high end.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000007-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000007-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 723</span>
+723:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">grow</span>(<span class="ruby-identifier">bits</span>=<span class="ruby-value">1</span>, <span class="ruby-identifier">defval</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">direction</span>=<span class="ruby-constant">HIGH_END</span>)
+724:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bits</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">Integer</span>))
+725:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">BitsRInts</span>)
+726:     <span class="ruby-keyword kw">end</span>
+727:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">defval</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-identifier">:to_i</span>))
+728:       <span class="ruby-identifier">what</span> = <span class="ruby-identifier">defval</span>.<span class="ruby-identifier">respond_to?</span>(<span class="ruby-identifier">:to_s</span>) <span class="ruby-operator">?</span> <span class="ruby-identifier">defval</span>.<span class="ruby-identifier">to_s</span> <span class="ruby-operator">:</span> <span class="ruby-identifier">defval</span>.<span class="ruby-identifier">inspect</span>
+729:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">UnInterable</span>, <span class="ruby-identifier">defval</span>)
+730:     <span class="ruby-keyword kw">end</span>
+731:     <span class="ruby-keyword kw">unless</span> ([<span class="ruby-constant">HIGH_END</span>, <span class="ruby-constant">LOW_END</span>].<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">direction</span>))
+732:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">NeedGPS</span>)
+733:     <span class="ruby-keyword kw">end</span>
+734:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-value">0</span>)
+735:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">NoDeficitBits</span>)
+736:     <span class="ruby-keyword kw">end</span>
+737:     <span class="ruby-keyword kw">unless</span> ((<span class="ruby-identifier">direction</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LOW_END</span>) <span class="ruby-operator">||</span> <span class="ruby-identifier">bounded?</span>)
+738:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">UnboundedNonsense</span>)
+739:     <span class="ruby-keyword kw">end</span>
+740:     <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">dup</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>)
+741: 
+742:     <span class="ruby-identifier">value</span> = <span class="ruby-ivar">@value</span>
+743:     <span class="ruby-identifier">vMask</span> = <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">bits</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+744:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">direction</span> <span class="ruby-operator">==</span> <span class="ruby-constant">HIGH_END</span>)
+745:       <span class="ruby-identifier">vMask</span> <span class="ruby-operator">*=</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-ivar">@length</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bounded?</span>)
+746:     <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">direction</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LOW_END</span>)
+747:       <span class="ruby-identifier">value</span> <span class="ruby-operator">*=</span> (<span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">bits</span>)
+748:     <span class="ruby-keyword kw">end</span>
+749:     <span class="ruby-identifier">value</span> <span class="ruby-operator">|=</span> <span class="ruby-identifier">vMask</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">defval</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span>)
+750:     <span class="ruby-identifier">bounded?</span> <span class="ruby-value">? </span><span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>, <span class="ruby-ivar">@length</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">bits</span>) <span class="ruby-operator">:</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>)
+751:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000008" class="method-detail">
+        <a name="M000008"></a>
+
+        <div class="method-heading">
+          <a href="#M000008" class="method-signature">
+          <span class="method-name">bitstring.grow!<i>(bits, [defval], [direction])</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+As <a href="BitString.html#M000007">grow</a>, except that the current
+bitstring is changed rather than a <a href="BitString.html#M000001">new</a>
+one returned.
+</p>
+<p>
+Bits added are set to <em>defval</em> (default 0).
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bits</em></dt><dd><em>Integer</em> Number of bits to add.
+
+</dd>
+<dt><em>defval</em></dt><dd><em>Integer</em> Value to which added bits should be set.
+
+</dd>
+<dt><em>direction</em></dt><dd><em>Constant</em>. Either <tt>BitString::HIGH_END</tt> (the default) or
+<tt>BitString::LOW_END</tt>. Indicates whether bits are added at the least
+or most significant end. Growing with <tt>BitString::LOW_END</tt> results
+in the bitstring being shifted left.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(5, 3)
+ bs.to_s
+ =&gt; &quot;101&quot;
+ bs.grow!(3)
+ bs.to_s
+ =&gt; &quot;000101&quot;
+ bs.grow!(3, 1, BitString::LOW_END)
+ bs.to_s
+ =&gt; &quot;000101111&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd><em>bits</em> isn&#8216;t an integer, <em>defval</em> can&#8216;t be
+reduced to a binary value, or <em>direction</em> isn&#8216;t one of the
+defined values.
+
+</dd>
+<dt><tt>IndexError</tt></dt><dd><em>bits</em> is negative or meaningless.
+
+</dd>
+<dt><tt>RuntimeError</tt></dt><dd>Can&#8216;t <a href="BitString.html#M000007">grow</a> an unbounded string
+at the high end.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000008-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000008-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 785</span>
+785:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">grow!</span>(<span class="ruby-identifier">bits</span>=<span class="ruby-value">1</span>, <span class="ruby-identifier">defval</span>=<span class="ruby-value">0</span>, <span class="ruby-identifier">direction</span>=<span class="ruby-constant">HIGH_END</span>)
+786:     <span class="ruby-identifier">bs</span> = <span class="ruby-identifier">grow</span>(<span class="ruby-identifier">bits</span>, <span class="ruby-identifier">defval</span>, <span class="ruby-identifier">direction</span>)
+787:     <span class="ruby-ivar">@length</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">length</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bs</span>.<span class="ruby-identifier">bounded?</span>)
+788:     <span class="ruby-ivar">@value</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">to_i</span>
+789:     <span class="ruby-keyword kw">self</span>
+790:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000009" class="method-detail">
+        <a name="M000009"></a>
+
+        <div class="method-heading">
+          <a href="#M000009" class="method-signature">
+          <span class="method-name">bitstring.length()<br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return the <a href="BitString.html#M000009">length</a> of the bitstring. If
+it&#8216;s bounded, the fixed size is returned, otherwise the number of
+significant binary digits.
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('101', 3)
+ bs.length
+ =&gt; 3
+
+ bs = BitString.new('00101', 5)
+ bs.length
+ =&gt; 5
+
+ bs = BitString.new('00101')
+ bs.length
+ =&gt; 3
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000009-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000009-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 820</span>
+820:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">length</span>()
+821:     <span class="ruby-identifier">bounded?</span> <span class="ruby-value">? </span><span class="ruby-ivar">@length</span> <span class="ruby-operator">:</span> <span class="ruby-ivar">@value</span>.<span class="ruby-identifier">to_s</span>(<span class="ruby-value">2</span>).<span class="ruby-identifier">length</span>
+822:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000010" class="method-detail">
+        <a name="M000010"></a>
+
+        <div class="method-heading">
+          <a href="#M000010" class="method-signature">
+          <span class="method-name">bitstring.lsb()<br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return the value of the least significant (low) bit.
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('101')
+ bs.lsb
+ =&gt; 1
+
+ bs = BitString.new('010')
+ bs.lsb
+ =&gt; 0
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000010-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000010-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 847</span>
+847:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">lsb</span>()
+848:     <span class="ruby-keyword kw">self</span>[<span class="ruby-value">0</span>]
+849:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000011" class="method-detail">
+        <a name="M000011"></a>
+
+        <div class="method-heading">
+          <a href="#M000011" class="method-signature">
+          <span class="method-name">bitstring.mask<i>([bitcount], [direction])</i> => <i>Integer</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return an integer with bits set to <a
+href="BitString.html#M000011">mask</a> the specified portion of the
+bitstring.
+</p>
+<p>
+If you want to create a <a href="BitString.html#M000011">mask</a> wider
+than the bitstring, use the class method <em><a
+href="BitString.html#M000011">BitString.mask</a>()</em> instead.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bitcount</em></dt><dd><em>Integer</em>. Number of bits to set in the <a
+href="BitString.html#M000011">mask</a>.
+
+</dd>
+<dt><em>direction</em></dt><dd><em>Constant</em>. <tt>BitString::HIGH_END</tt> (the default) or
+<tt>BitString::LOW_END</tt>. Specifies the end of the bitstring from which
+the <a href="BitString.html#M000011">mask</a> starts.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(0, 12)
+ bs.mask.to_s(2)
+ =&gt; &quot;111111111111&quot;
+ bs.mask(5).to_s(2)
+ =&gt; &quot;111110000000&quot;
+ bs.mask(5, BitString::LOW_END).to_s(2)
+ =&gt; &quot;11111&quot;
+ BitString.new(bs.mask(5, BitString::LOW_END), 12).to_s
+ =&gt; &quot;000000011111&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>IndexError</tt></dt><dd>Raised if <em>bitcount</em> is negative or grater than the bitstring <a
+href="BitString.html#M000009">length</a>.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000011-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000011-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 881</span>
+881:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">mask</span>(<span class="ruby-identifier">bits</span>=<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">length</span>, <span class="ruby-identifier">direction</span>=<span class="ruby-constant">HIGH_END</span>)
+882:     <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">OuttasightIndex</span>, <span class="ruby-identifier">bits</span>) <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">&gt;</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">length</span>)
+883:     <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">NoDeficitBits</span>) <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>)
+884:     <span class="ruby-identifier">vMask</span> = <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">bits</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+885:     <span class="ruby-identifier">vMask</span> <span class="ruby-operator">*=</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span>(<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">bits</span>) <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">direction</span> <span class="ruby-operator">==</span> <span class="ruby-constant">HIGH_END</span>)
+886:     <span class="ruby-identifier">vMask</span>
+887:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000013" class="method-detail">
+        <a name="M000013"></a>
+
+        <div class="method-heading">
+          <a href="#M000013" class="method-signature">
+          <span class="method-name">bitstring.msb()<br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return the value of the most significant (high) bit. Only meaningful for
+bounded bitstrings.
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('0101')
+ bs.msb
+ =&gt; 1                      # Leading zeroes stripped in unbouded bitstrings
+
+ bs = BitString.new('0101', 4)
+ bs.msb
+ =&gt; 0
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>RuntimeError</tt></dt><dd>There is no &#8216;MSB&#8217; for an unbounded bitstring.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000013-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000013-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 937</span>
+937:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">msb</span>()
+938:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bounded?</span>)
+939:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">UnboundedNonsense</span>,
+940:              <span class="ruby-value str">'most significant bit only applies to bounded bitstrings'</span>)
+941:     <span class="ruby-keyword kw">end</span>
+942:     <span class="ruby-keyword kw">self</span>[<span class="ruby-ivar">@length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>]
+943:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000014" class="method-detail">
+        <a name="M000014"></a>
+
+        <div class="method-heading">
+          <a href="#M000014" class="method-signature">
+          <span class="method-name">bitstring.population<i>(testval)</i> => <i>Integer</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return the number of bits in the bitstring that are either set (1) or <a
+href="BitString.html#M000003">clear</a> (0). Leading zeroes on unbounded
+bitstrings are ignored.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>testval</em></dt><dd><em>Array</em>, <em><a href="BitString.html">BitString</a></em>,
+<em>Integer</em>, or <em>String</em> whose low bit is used for the test.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('0001111001010')
+ bs.population(0)
+ =&gt; 4
+ bs.population(1)
+ =&gt; 6
+
+ bs = BitString.new('0001111001010', 13)
+ bs.population(0)
+ =&gt; 7
+ bs.population(1)
+ =&gt; 6
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd>The argument cannot be reduced to a binary digit.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000014-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000014-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring.rb, line 973</span>
+973:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">population</span>(<span class="ruby-identifier">val</span>)
+974:     <span class="ruby-identifier">val</span> = <span class="ruby-identifier">_arg2int</span>(<span class="ruby-identifier">val</span>) <span class="ruby-operator">&amp;</span> <span class="ruby-value">1</span>
+975:     <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">select</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">bval</span><span class="ruby-operator">|</span> <span class="ruby-identifier">bval</span> <span class="ruby-operator">==</span> <span class="ruby-identifier">val</span> }.<span class="ruby-identifier">length</span>
+976:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000015" class="method-detail">
+        <a name="M000015"></a>
+
+        <div class="method-heading">
+          <a href="#M000015" class="method-signature">
+          <span class="method-name">bitstring.resize<i>(bits)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return a copy of the bitstring resized to the specified number of bits,
+resulting in truncation or growth. Bits are added to, or removed from, the
+high (more significant) end. Resizing an unbounded bitstring makes it
+bounded.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bits</em></dt><dd>Width of the resulting bitstring.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('101')
+ bs.bounded?
+ =&gt; false
+ nbs = bs.resize(5)
+ nbs.bounded?
+ =&gt; true
+ nbs.length
+ =&gt; 5
+ nbs.to_s
+ =&gt; &quot;00101&quot;
+ nbs = bs.resize(7)
+ nbs.to_s
+ =&gt; &quot;0000101&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>IndexError</tt></dt><dd><em>bits</em> is negative or meaningless.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000015-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000015-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1010</span>
+1010:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">resize</span>(<span class="ruby-identifier">bits</span>)
+1011:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bits</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">Integer</span>))
+1012:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">BitsRInts</span>)
+1013:     <span class="ruby-keyword kw">end</span>
+1014:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>)
+1015:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">NoDeficitBits</span>)
+1016:     <span class="ruby-keyword kw">end</span>
+1017:     <span class="ruby-identifier">value</span> = <span class="ruby-ivar">@value</span>
+1018:     <span class="ruby-identifier">length</span> = <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">length</span>
+1019:     <span class="ruby-identifier">bs</span> = <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>, <span class="ruby-identifier">length</span>)
+1020:     <span class="ruby-identifier">diffbits</span> = <span class="ruby-identifier">bits</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">length</span>
+1021:     <span class="ruby-identifier">diffbits</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span> <span class="ruby-operator">?</span> <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">shrink!</span>(<span class="ruby-operator">-</span><span class="ruby-identifier">diffbits</span>) <span class="ruby-operator">:</span> <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">grow!</span>(<span class="ruby-identifier">diffbits</span>)
+1022:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000016" class="method-detail">
+        <a name="M000016"></a>
+
+        <div class="method-heading">
+          <a href="#M000016" class="method-signature">
+          <span class="method-name">bitstring.resize!<i>(bits)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+As <a href="BitString.html#M000015">resize</a> except it&#8216;s the
+current bitstring that gets resized.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bits</em></dt><dd>Width of the resulting bitstring.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('101')
+ bs.bounded?
+ =&gt; false
+ bs.resize!(5)
+ bs.bounded?
+ =&gt; true
+ bs.length
+ =&gt; 5
+ bs.to_s
+ =&gt; &quot;00101&quot;
+ bs.resize!(7)
+ bs.to_s
+ =&gt; &quot;0000101&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>IndexError</tt></dt><dd><em>bits</em> is negative or meaningless.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000016-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000016-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1053</span>
+1053:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">resize!</span>(<span class="ruby-identifier">bits</span>)
+1054:     <span class="ruby-identifier">bs</span> = <span class="ruby-identifier">resize</span>(<span class="ruby-identifier">bits</span>)
+1055:     <span class="ruby-ivar">@bounded</span> = <span class="ruby-keyword kw">true</span>
+1056:     <span class="ruby-ivar">@length</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">length</span>
+1057:     <span class="ruby-ivar">@value</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">to_i</span>
+1058:     <span class="ruby-keyword kw">self</span>
+1059:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000017" class="method-detail">
+        <a name="M000017"></a>
+
+        <div class="method-heading">
+          <a href="#M000017" class="method-signature">
+          <span class="method-name">bistring.rotate<i>(bits)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Rotate the bitstring, taking bits from one end and shifting them in at the
+other. Only makes sense with bounded strings.
+</p>
+<p>
+A negative value rotates left; a positive one rotates to the right.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bits</em></dt><dd><em>Integer</em>. Number of positions to <a
+href="BitString.html#M000017">rotate</a> left (negative) or right
+(positive). Bits rotated off one end are rotated in on the other.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('000000011111', 12)
+ bs.rotate(3).to_s
+ =&gt; &quot;000011111000&quot;
+ bs.rotate(-4).to_s
+ =&gt; &quot;100000001111&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>RuntimeError</tt></dt><dd>Can&#8216;t <a href="BitString.html#M000017">rotate</a> an unbounded
+bitstring.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000017-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000017-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1085</span>
+1085:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">rotate</span>(<span class="ruby-identifier">bits_p</span>)
+1086:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bounded?</span>)
+1087:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">UnboundedNonsense</span>,
+1088:              <span class="ruby-value str">'rotation only applies to bounded bitstrings'</span>)
+1089:     <span class="ruby-keyword kw">end</span>
+1090: 
+1091:     <span class="ruby-identifier">value</span> = <span class="ruby-ivar">@value</span>
+1092:     <span class="ruby-identifier">length</span> = <span class="ruby-ivar">@length</span>
+1093:     <span class="ruby-identifier">bits</span> = <span class="ruby-identifier">bits_p</span>.<span class="ruby-identifier">to_i</span>.<span class="ruby-identifier">abs</span> <span class="ruby-operator">%</span> <span class="ruby-identifier">length</span>
+1094:     <span class="ruby-identifier">vMask</span> = (<span class="ruby-identifier">mult</span> = <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">bits</span>) <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+1095:     <span class="ruby-identifier">ldiff</span> = <span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">bits</span>
+1096:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bits_p</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>)
+1097:       <span class="ruby-comment cmt">#</span>
+1098:       <span class="ruby-comment cmt"># Rotate right (toward the LSB)</span>
+1099:       <span class="ruby-comment cmt">#</span>
+1100:       <span class="ruby-identifier">residue</span> = <span class="ruby-identifier">value</span> <span class="ruby-operator">&amp;</span> <span class="ruby-identifier">vMask</span>
+1101:       <span class="ruby-identifier">value</span> <span class="ruby-operator">/=</span> <span class="ruby-identifier">mult</span>
+1102:       <span class="ruby-identifier">value</span> <span class="ruby-operator">|=</span> <span class="ruby-identifier">residue</span> <span class="ruby-operator">*</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">ldiff</span>
+1103:     <span class="ruby-keyword kw">elsif</span> (<span class="ruby-identifier">bits_p</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>)
+1104:       <span class="ruby-comment cmt">#</span>
+1105:       <span class="ruby-comment cmt"># Rotate left (toward the MSB)</span>
+1106:       <span class="ruby-comment cmt">#</span>
+1107:       <span class="ruby-identifier">vMask</span> <span class="ruby-operator">*=</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">ldiff</span>
+1108:       <span class="ruby-identifier">residue</span> = <span class="ruby-identifier">value</span> <span class="ruby-operator">&amp;</span> <span class="ruby-identifier">vMask</span>
+1109:       <span class="ruby-identifier">value</span> = ((<span class="ruby-identifier">value</span> <span class="ruby-operator">&amp;</span> <span class="ruby-operator">~</span><span class="ruby-identifier">vMask</span>) <span class="ruby-operator">*</span> <span class="ruby-identifier">mult</span>) <span class="ruby-operator">|</span> (<span class="ruby-identifier">residue</span> <span class="ruby-operator">/</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">ldiff</span>)
+1110:     <span class="ruby-keyword kw">end</span>
+1111:     <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>, <span class="ruby-ivar">@length</span>)
+1112:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000018" class="method-detail">
+        <a name="M000018"></a>
+
+        <div class="method-heading">
+          <a href="#M000018" class="method-signature">
+          <span class="method-name">bitstring.rotate!<i>(bits)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Same as <a href="BitString.html#M000017">rotate</a> except that the result
+is stored back into the current object.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bits</em></dt><dd><em>Integer</em>. Number of positions to <a
+href="BitString.html#M000017">rotate</a> left (negative) or right
+(positive). Bits rotated off one end are rotated in on the other.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('000000011111', 12)
+ bs.rotate!(3)
+ bs.to_s
+ =&gt; &quot;000011111000&quot;
+ bs.rotate!(-4)
+ bs.to_s
+ =&gt; &quot;100000001111&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000018-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000018-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1138</span>
+1138:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">rotate!</span>(<span class="ruby-identifier">bits_p</span>)
+1139:     <span class="ruby-ivar">@value</span> = <span class="ruby-identifier">rotate</span>(<span class="ruby-identifier">bits_p</span>).<span class="ruby-identifier">to_i</span>
+1140:     <span class="ruby-keyword kw">self</span>
+1141:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000019" class="method-detail">
+        <a name="M000019"></a>
+
+        <div class="method-heading">
+          <a href="#M000019" class="method-signature">
+          <span class="method-name">bitstring.select { <i>|bit| block</i> } => <i>Array</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Iterate through all the bits, invoking the specified block with the value
+of <a href="BitString.html#M000005">each</a> in turn. If the block returns
+a true value, the bit value is added to the result array.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bit</em></dt><dd><em>Integer</em>. The value (0 or 1) of the current bit.
+
+</dd>
+<dt><em>block</em></dt><dd><em>Proc</em>. The block of code to execute.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('11001110001')
+ bs.select { |bit| bit == 1}
+ =&gt; [1, 1, 1, 1, 1, 1]
+
+ bs = BitString.new('0011001110001')
+ bs.select { |bit| bit == 0}
+ =&gt; [0, 0, 0, 0, 0]      # because unbounded leadings zeroes are dropped
+
+ bs = BitString.new('0011001110001', 13)
+ bs.select { |bit| bit == 0}
+ =&gt; [0, 0, 0, 0, 0, 0, 0]
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000019-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000019-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1173</span>
+1173:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">select</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+1174:     <span class="ruby-identifier">result</span> = []
+1175:     <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">val</span><span class="ruby-operator">|</span>
+1176:       <span class="ruby-identifier">result</span>.<span class="ruby-identifier">push</span>(<span class="ruby-identifier">val</span>) <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">val</span>))
+1177:     <span class="ruby-keyword kw">end</span>
+1178:     <span class="ruby-identifier">result</span>
+1179:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000020" class="method-detail">
+        <a name="M000020"></a>
+
+        <div class="method-heading">
+          <a href="#M000020" class="method-signature">
+          <span class="method-name">bitstring.shrink<i>(bits, [direction])</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Shrink the bitstring (make it shorter) by truncating bits from one end or
+the other. Shrinking to fewer than 1 bits raises an exception.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bits</em></dt><dd><em>Integer</em>. Number of bits to truncate.
+
+</dd>
+<dt><em>direction</em></dt><dd><em>Constant</em>. Either <tt>BitString::HIGH_END</tt> (the default) or
+<tt>BitString::LOW_END</tt>.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(3095)      # 110000010111
+ nbs = bs.shrink(5)
+ nbs.to_s
+ =&gt; &quot;10111&quot;                    # Unbounded leading zeroes aren't significant
+ nbs = nbs.shrink(2, BitString::LOW_END)
+ nbs.to_s
+ =&gt; &quot;101&quot;
+
+ bs = BitString.new(3095, 12)  # 110000010111
+ nbs = bs.shrink(5)
+ nbs.to_s
+ =&gt; &quot;0010111&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd><em>bitcount</em> isn&#8216;t an integer or <em>direction</em> isn&#8216;t
+one of the defined values.
+
+</dd>
+<dt><tt>IndexError</tt></dt><dd><em>bits</em> is negative or meaningless.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000020-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000020-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1213</span>
+1213:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">shrink</span>(<span class="ruby-identifier">bits</span>=<span class="ruby-value">1</span>, <span class="ruby-identifier">direction</span>=<span class="ruby-constant">HIGH_END</span>)
+1214:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bits</span>.<span class="ruby-identifier">kind_of?</span>(<span class="ruby-constant">Integer</span>))
+1215:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">BitsRInts</span>)
+1216:     <span class="ruby-keyword kw">end</span>
+1217:     <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-value">0</span>)
+1218:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">NoDeficitBits</span>)
+1219:     <span class="ruby-keyword kw">end</span>
+1220:     <span class="ruby-keyword kw">unless</span> ([<span class="ruby-constant">HIGH_END</span>, <span class="ruby-constant">LOW_END</span>].<span class="ruby-identifier">include?</span>(<span class="ruby-identifier">direction</span>))
+1221:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">NeedGPS</span>)
+1222:     <span class="ruby-keyword kw">end</span>
+1223:     <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">dup</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>)
+1224: 
+1225:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bounded?</span> <span class="ruby-operator">&amp;&amp;</span> (<span class="ruby-identifier">bits</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-ivar">@length</span>))
+1226:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">RuntimeError</span>, <span class="ruby-value str">'shrink count greater than bitstring size'</span>)
+1227:     <span class="ruby-keyword kw">end</span>
+1228:     <span class="ruby-identifier">value</span> = <span class="ruby-ivar">@value</span>
+1229:     <span class="ruby-identifier">length</span> = <span class="ruby-identifier">bounded?</span> <span class="ruby-value">? </span><span class="ruby-ivar">@length</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">bits</span> <span class="ruby-operator">:</span> <span class="ruby-keyword kw">nil</span>
+1230:     <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">direction</span> <span class="ruby-operator">==</span> <span class="ruby-constant">LOW_END</span>)
+1231:       <span class="ruby-identifier">value</span> <span class="ruby-operator">/=</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">bits</span>
+1232:     <span class="ruby-keyword kw">else</span>
+1233:       <span class="ruby-identifier">_raise</span>(<span class="ruby-constant">UnboundedNonsense</span>) <span class="ruby-keyword kw">unless</span> (<span class="ruby-identifier">bounded?</span>)
+1234:       <span class="ruby-identifier">value</span> <span class="ruby-operator">&amp;=</span> <span class="ruby-value">2</span><span class="ruby-operator">**</span><span class="ruby-identifier">length</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+1235:     <span class="ruby-keyword kw">end</span>
+1236:     <span class="ruby-identifier">bounded?</span> <span class="ruby-value">? </span><span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>, <span class="ruby-identifier">length</span>) <span class="ruby-operator">:</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">value</span>)
+1237:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000021" class="method-detail">
+        <a name="M000021"></a>
+
+        <div class="method-heading">
+          <a href="#M000021" class="method-signature">
+          <span class="method-name">bitstring.shrink!<i>(bits, [direction])</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+As <a href="BitString.html#M000020">shrink</a> except that the current
+bitstring is modified rather than a copy being made and altered.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>bits</em></dt><dd><em>Integer</em>. Number of bits to truncate.
+
+</dd>
+<dt><em>direction</em></dt><dd><em>Constant</em>. <tt>BitString::HIGH_END</tt> (the default) or
+<tt>BitString::LOW_END</tt>.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(3095)      # 110000010111
+ bs.shrink!(5)
+ bs.to_s
+ =&gt; &quot;10111&quot;                    # Unbounded leading zeroes aren't significant
+ bs.shrink!(2, BitString::LOW_END)
+ bs.to_s
+ =&gt; &quot;101&quot;
+
+ bs = BitString.new(3095, 12)  # 110000010111
+ bs.shrink!(5)
+ bs.to_s
+ =&gt; &quot;0010111&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd><em>bitcount</em> isn&#8216;t an integer or <em>direction</em> isn&#8216;t
+one of the defined values.
+
+</dd>
+<dt><tt>IndexError</tt></dt><dd><em>bits</em> is negative or meaningless.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000021-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000021-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1270</span>
+1270:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">shrink!</span>(<span class="ruby-identifier">bits</span>=<span class="ruby-value">1</span>, <span class="ruby-identifier">direction</span>=<span class="ruby-constant">HIGH_END</span>)
+1271:     <span class="ruby-identifier">bs</span> = <span class="ruby-identifier">shrink</span>(<span class="ruby-identifier">bits</span>, <span class="ruby-identifier">direction</span>)
+1272:     <span class="ruby-ivar">@length</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">length</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bs</span>.<span class="ruby-identifier">bounded?</span>)
+1273:     <span class="ruby-ivar">@value</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">to_i</span>
+1274:     <span class="ruby-keyword kw">self</span>
+1275:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000022" class="method-detail">
+        <a name="M000022"></a>
+
+        <div class="method-heading">
+          <a href="#M000022" class="method-signature">
+          <span class="method-name">bitstring.slice<i>(index)</i> => <i>Integer</i><br />
+bitstring.slice<i>(start, length)</i> => <i>BitString</i><br />
+bitstring.slice<i>(range)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Extract a subset from the bitstring. See the description of the <tt>[]</tt>
+method.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>index</em></dt><dd><em>Integer</em>. Single bit position.
+
+</dd>
+<dt><em>start</em></dt><dd><em>Integer</em>. Start position of subset.
+
+</dd>
+<dt><em><a href="BitString.html#M000009">length</a></em></dt><dd><em>Integer</em>. Length of subset.
+
+</dd>
+<dt><em>range</em></dt><dd><em>Range</em>. Subset specified as a range.
+
+</dd>
+</dl>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd>If <a href="BitString.html#M000009">length</a> specified with a range.
+
+</dd>
+<dt><tt>IndexError</tt></dt><dd>If bounded bitstring and substring is illegal.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000022-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000022-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1298</span>
+1298:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">slice</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
+1299:     <span class="ruby-keyword kw">self</span>[<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>]
+1300:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000023" class="method-detail">
+        <a name="M000023"></a>
+
+        <div class="method-heading">
+          <a href="#M000023" class="method-signature">
+          <span class="method-name">bitstring.slice!<i>(index)</i> => <i>Integer</i><br />
+bitstring.slice!<i>(start, length)</i> => <i>BitString</i><br />
+bitstring.slice!<i>(range)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Select the specified bits from the bitstring, and remake it using only
+those bits. If bounded, the size will be adjusted to match the number of
+bits selected. This is an alternative way to change the size and value of
+an existing bitstring (see the <a
+href="BitString.html#M000008">grow!</a>(), <a
+href="BitString.html#M000021">shrink!</a>(), and <a
+href="BitString.html#M000016">resize!</a>() methods.)
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>index</em></dt><dd><em>Integer</em>. Single bit position.
+
+</dd>
+<dt><em>start</em></dt><dd><em>Integer</em>. Start position of subset.
+
+</dd>
+<dt><em><a href="BitString.html#M000009">length</a></em></dt><dd><em>Integer</em>. Length of subset.
+
+</dd>
+<dt><em>range</em></dt><dd><em>Range</em>. Subset specified as a range.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(3095, 12)
+ bs.to_s
+ =&gt; &quot;110000010111&quot;
+ bs.slice!(4..10)
+ bs.to_s
+ =&gt; &quot;1000001&quot;
+</pre>
+<h3>Exceptions</h3>
+<dl>
+<dt><tt>ArgumentError</tt></dt><dd>If <a href="BitString.html#M000009">length</a> specified with a range.
+
+</dd>
+<dt><tt>IndexError</tt></dt><dd>If bounded bitstring and substring is illegal.
+
+</dd>
+</dl>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000023-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000023-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1334</span>
+1334:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">slice!</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
+1335:     <span class="ruby-identifier">bs</span> = <span class="ruby-keyword kw">self</span>[<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>]
+1336:     <span class="ruby-ivar">@value</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">to_i</span>
+1337:     <span class="ruby-ivar">@bounded</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">bounded?</span>
+1338:     <span class="ruby-ivar">@length</span> = <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">length</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bs</span>.<span class="ruby-identifier">bounded?</span>)
+1339:     <span class="ruby-keyword kw">self</span>
+1340:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000024" class="method-detail">
+        <a name="M000024"></a>
+
+        <div class="method-heading">
+          <a href="#M000024" class="method-signature">
+          <span class="method-name">bitstring.to_i<i>()</i> => <i>Integer</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return the full value of the bitstring represented as an integer.
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('110000010111')
+ bs.to_i
+ =&gt; 3095
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000024-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000024-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1361</span>
+1361:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_i</span>()
+1362:     <span class="ruby-ivar">@value</span>.<span class="ruby-identifier">to_i</span>
+1363:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000025" class="method-detail">
+        <a name="M000025"></a>
+
+        <div class="method-heading">
+          <a href="#M000025" class="method-signature">
+          <span class="method-name">bitstring.to_s<i>()</i> => <i>String</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Return the bitlist as a <em>String</em> object consisting of
+&#8216;0&#8217; and &#8216;1&#8217; characters. If the bitstring is
+bounded, the <em>String</em> will be zero-filled on the left (high end).
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new(3095)
+ bs.to_s
+ =&gt; &quot;110000010111&quot;
+
+ bs = BitString.new(3095, 14)
+ bs.to_s
+ =&gt; &quot;00110000010111&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000025-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000025-source">
+<pre>
+      <span class="ruby-comment cmt"># File lib/bitstring.rb, line 1390</span>
+1390:   <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_s</span>()
+1391:     <span class="ruby-identifier">_zfill</span>(<span class="ruby-ivar">@value</span>, <span class="ruby-ivar">@length</span>)
+1392:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000032" class="method-detail">
+        <a name="M000032"></a>
+
+        <div class="method-heading">
+          <a href="#M000032" class="method-signature">
+          <span class="method-name">bitstring <i>| value</i> => <i>BitString</i><br />
+bitstring.|<i>(value)</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Perform a bitwise inclusive OR with the current bitstring and return a
+bitstring containing the result.
+</p>
+<h3>Arguments</h3>
+<dl>
+<dt><em>value</em></dt><dd><em>Array</em>, <em><a href="BitString.html">BitString</a></em>,
+<em>Integer</em>, or <em>String</em>. Value treated as a bitstream and
+inclusively ORed with the bitstring.
+
+</dd>
+</dl>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('110010110')
+ nbs = bs | '11000000000000000'
+ nbs.to_s                        # Bits cab be ORed in anywhere in an
+ =&gt; &quot;11000000110010110&quot;          # unbouded string
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000032-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000032-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 392</span>
+392:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">|</span>(<span class="ruby-identifier">value</span>)
+393:     <span class="ruby-identifier">value</span> = <span class="ruby-identifier">_arg2int</span>(<span class="ruby-identifier">value</span>)
+394:     <span class="ruby-identifier">value</span> <span class="ruby-operator">&amp;=</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mask</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">bounded?</span>)
+395:     <span class="ruby-identifier">bs</span> = <span class="ruby-identifier">dup</span>
+396:     <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">from_i</span>(<span class="ruby-identifier">value</span> <span class="ruby-operator">|</span> <span class="ruby-identifier">bs</span>.<span class="ruby-identifier">to_i</span>)
+397:     <span class="ruby-identifier">bs</span>
+398:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+      <div id="method-M000033" class="method-detail">
+        <a name="M000033"></a>
+
+        <div class="method-heading">
+          <a href="#M000033" class="method-signature">
+          <span class="method-name"><i>~</i> bitstring => <i>BitString</i><br />
+bitstring.~<i>()</i> => <i>BitString</i><br />
+</span>
+          </a>
+        </div>
+      
+        <div class="method-description">
+          <h3>Description</h3>
+<p>
+Perform a one&#8216;s complement on the current bitstring and return the
+result in a <a href="BitString.html#M000001">new</a> one.
+</p>
+<h3>Arguments</h3>
+<p>
+<em>None</em>.
+</p>
+<h3>Examples</h3>
+<pre>
+ bs = BitString.new('110010110')
+ nbs = ~ bs
+ nbs.to_s
+ =&gt; &quot;1101001&quot;                 # Leading zeroes stripped when unbounded
+
+ bs = BitString.new('110010110', 9)
+ nbs = ~ bs
+ nbs.to_s
+ =&gt; &quot;001101001&quot;
+
+ bs = BitString.new('111111111')
+ nbs = ~ bs
+ nbs.to_s
+ =&gt; &quot;0&quot;
+
+ bs = BitString.new('111111111', 9)
+ nbs = ~ bs
+ nbs.to_s
+ =&gt; &quot;000000000&quot;
+</pre>
+<h3>Exceptions</h3>
+<p>
+<em>None</em>.
+</p>
+          <p><a class="source-toggle" href="#"
+            onclick="toggleCode('M000033-source');return false;">[Source]</a></p>
+          <div class="method-source-code" id="M000033-source">
+<pre>
+     <span class="ruby-comment cmt"># File lib/bitstring/operators.rb, line 437</span>
+437:   <span class="ruby-keyword kw">def</span> <span class="ruby-operator">~</span>()
+438:     <span class="ruby-identifier">newval</span> = (<span class="ruby-operator">~</span> <span class="ruby-ivar">@value</span>) <span class="ruby-operator">&amp;</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">mask</span>
+439:     <span class="ruby-identifier">bounded?</span> <span class="ruby-value">? </span><span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">newval</span>, <span class="ruby-ivar">@length</span>) <span class="ruby-operator">:</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">newval</span>)
+440:   <span class="ruby-keyword kw">end</span>
+</pre>
+          </div>
+        </div>
+      </div>
+
+
+    </div>
+
+
+  </div>
+
+
+<div id="validator-badges">
+  <p><small><a href="http://validator.w3.org/check/referer">[Validate]</a></small></p>
+</div>
+
+</body>
+</html>