# core.bitop

This module contains a collection of bit-level operations.
License:
Boost License 1.0
Authors:
Don Clugston, Sean Kelly, Walter Bright, Alex Rønne Petersen
Source:

pure nothrow @safe int bsf(size_t v);
  Scans the bits in v starting with bit 0, looking for the first set bit.
  Returns:
  The bit number of the first bit set. The return value is undefined if v is zero.
  Example:

       import core.bitop;

       int main()
       {
           assert(bsf(0x21) == 0);
           return 0;
       }

  Example:
pure nothrow @safe int bsr(size_t v);
  Scans the bits in v from the most significant bit to the least significant bit, looking for the first set bit.
  Returns:
  The bit number of the first bit set. The return value is undefined if v is zero.
  Example:

       import core.bitop;

       int main()
       {
           assert(bsr(0x21) == 5);
           return 0;
       }

  Example:
pure nothrow @system int bt(in uint* p, size_t bitnum);
  Tests the bit. (No longer an intrisic - the compiler recognizes the patterns in the body.)
  Example:

      size_t[2] array;
      array[0] = 2;
      array[1] = 256;
      assert(bt(array.ptr, 1));
      assert(array[0] == 2);
      assert(array[1] == 256);

pure nothrow @safe int btc(uint* p, size_t bitnum);
  Tests and complements the bit.
pure nothrow @safe int btr(uint* p, size_t bitnum);
  Tests and resets (sets to 0) the bit.
pure nothrow @safe int bts(uint* p, size_t bitnum);
  Tests and sets the bit.
  Params:

  uint* p | a non-NULL pointer to an array of size_ts.

  index

  a bit number, starting with bit 0 of p[0], and progressing. It addresses bits like the expression:

      p[index / (size_t.sizeof*8)] & (1 << (index & ((size_t.sizeof*8) - 1)))

  Returns:
  A non-zero value if the bit was set, and a zero if it was clear.
  Example:

      import std.stdio;
      import core.bitop;

      int main()
      {
          size_t array[2];

          array[0] = 2;
          array[1] = 0x100;

          assert(btc(array, 35) == 0);
          assert(array[0] == 2);
          assert(array[1] == 0x108);

          assert(btc(array, 35));
          assert(array[0] == 2);
          assert(array[1] == 0x100);

          assert(bts(array, 35) == 0);
          assert(array[0] == 2);
          assert(array[1] == 0x108);

          assert(btr(array, 35));
          assert(array[0] == 2);
          assert(array[1] == 0x100);

          assert(bt(array, 1));
          assert(array[0] == 2);
          assert(array[1] == 0x100);

          return 0;
      }

  Example:
pure nothrow @safe uint bswap(uint v);
  Swaps bytes in a 4 byte uint end-to-end, i.e. byte 0 becomes byte 3, byte 1 becomes byte 2, byte 2 becomes byte 1, byte 3 becomes byte 0.
nothrow @system ubyte inp(uint port_address);
nothrow @system ushort inpw(uint port_address);
nothrow @system uint inpl(uint port_address);
  Reads I/O port at port_address.
nothrow @system ubyte outp(uint port_address, ubyte value);
nothrow @system ushort outpw(uint port_address, ushort value);
nothrow @system uint outpl(uint port_address, uint value);
  Writes and returns value to I/O port at port_address.
pure nothrow @safe int popcnt(uint x);
  Calculates the number of set bits in a 32-bit integer.
  Example:
pure nothrow @trusted uint bitswap(uint x);
  Reverses the order of bits in a 32-bit integer.
  Example:

Page generated by Ddoc. Copyright Don Clugston 2005 - 2013.