Bitwise Operations
==================

bitand
------
**Syntax** ::

  bitand(x,y)
  bitand(x,y,assumedType)

**Description**

Performs the logical AND operation on each pair of corresponding bits
of ``x`` and ``y.`` If ``x`` or ``y`` is an array, then it will
perform the logical AND operation of each pair of elements.

- The function expects that the length of all input arrays to be
  equal. It will expand any scalar inputs to the appropriately
  sized array before performing ``bitand`` of each element.
- If ``assumedType`` is not provided, Grackle will implicitly convert real
  inputs to 64bit unsigned integers before computing the logical AND
  operation.
- If ``assumedType`` is provided, it identifies the type for the
  inputs ``x`` and ``y`` as either fixed width signed or fixed width
  unsigned integers. It must have the form ``'intN'`` or ``'uintN'``
  where ``N`` is a positive integer.

bitcmp
------
**Syntax** ::

  bitcmp(x)
  bitcmp(x,assumedType)

**Description**

Performs the bitwise complement of the operand. The input may be
singular or an array of numerical or logical values. If ``x`` is an
array, it computes ``bitcmp`` for each element in ``x``.

- If ``assumedType`` is not provided, Grackle will implicitly convert real
  inputs to 64bit unsigned integers before computing the complement.
- If ``assumedType`` is provided, it identifies the type for the input
  ``x`` as either a fixed width signed or fixed width unsigned
  integer. It must have the form ``'intN'`` or ``'uintN'`` where ``N``
  is a positive integer.

bitor
-----
**Syntax** ::

  bitor(x,y)
  bitor(x,y,assumedType)

**Description**

Performs the logical OR operation on each pair of corresponding bits
of ``x`` and ``y.`` If ``x`` or ``y`` is an array, then it will
perform the logical OR operation of each pair of elements.

- The function expects that the length of all input arrays to be
  equal. It will expand any scalar inputs to the appropriately
  sized array before performing ``bitor`` of each element.
- If ``assumedType`` is not provided, Grackle will implicitly convert real
  inputs to 64bit unsigned integers before computing the logical OR
  operation.
- If ``assumedType`` is provided, it identifies the type for the
  inputs ``x`` and ``y`` as either fixed width signed or fixed width
  unsigned integers. It must have the form ``'intN'`` or ``'uintN'``
  where ``N`` is a positive integer.


bitget
------
**Syntax** ::

  bitget(x,bitPosition)
  bitget(x,bitPosition,assumedType)

**Description**

Returns the bit value of ``x`` at location ``bitPosition.`` The
``bitPosition`` must be a positive integer between 1 and the number of
bits in the integer class of ``x``. The ``bitPosition`` may be an
integer array, in which case, this function returns the bit values of
``x`` and each location identified in the array ``bitPosition.``

- If ``x`` is an array, it returns the bit value at position
  ``bitPosition`` for each element in ``x``. If ``bitPosition`` is an
  array, its length must agree with the length of ``x``.
- If ``assumedType`` is not provided, Grackle will implicitly convert real
  inputs to 64bit unsigned integers before retrieving any bit values.
- If ``assumedType`` is provided, it identifies the type for the input
  ``x`` as either a fixed width signed or fixed width unsigned
  integer. It must have the form ``'intN'`` or ``'uintN'`` where ``N``
  is a positive integer.

bitset
------
**Syntax** ::

  bitset(x,bitPosition,val)
  bitset(x,bitPosition,val,assumedType)

**Description**

Returns ``x`` with the bit at location ``bitPosition`` set to ``val.``
If ``x`` is an array, it returns an array where each element of ``x``
has the ``bitPosition`` set to ``val.`` The ``bitPosition`` must be a
positive integer between 1 and the number of bits in the integer class
of ``x.``

- The operand ``bitPosition`` may also be an integer array. Note that
  ``val`` may be a scalar or numeric array, however, ``val`` will be
  converted to logical array before it is used to set bits in ``x.``
- The function expects that the length of all input arrays to be
  equal. It will expand any scalar inputs to the appropriately
  sized array before performing ``bitset`` of each element.
- If ``assumedType`` is not provided, Grackle will implicitly convert real
  inputs to 64bit unsigned integers before setting any bits.
- If ``assumedType`` is provided, it identifies the type for the input
  ``x`` as either a fixed width signed or fixed width unsigned
  integer. It must have the form ``'intN'`` or ``'uintN'`` where ``N``
  is a positive integer.

bitshift
--------
**Syntax** ::

  bitshift(x,n)
  bitshift(x,n,assumedType)

**Description**

When ``n`` is positive integer, return ``x`` shifted to the left by
``n`` bits. This is equivalent to multiplying ``x`` by ``2^n``. When
``n`` is negative, return ``x`` shifted to the right by ``n``
bits. This is equivalent to dividing by ``2^n`` and rounding to the
nearest integer less than or equal to the result. Any overflow bits
are truncated.

- When ``x`` is real, Grackle will convert the operand to an unsigned
  64bit integer before performing the shift operation. Negative real
  values for ``x`` are not permitted.
- If ``assumedType`` is not provided, Grackle will implicitly convert real
  inputs to 64bit unsigned integers before shifting any bits.
- If ``assumedType`` is provided, it identifies the type for the input
  ``x`` as either a fixed width signed or fixed width unsigned
  integer. It must have the form ``'intN'`` or ``'uintN'`` where ``N``
  is a positive integer.

bitxor
------
**Syntax** ::

  bitxor(x,y)
  bitxor(x,y,assumedType)

**Description**

Performs the logical exclusive OR operation on each pair of
corresponding bits of the operands. If ``x`` or ``y`` is an array,
then it will perform the logical XOR operation of each pair of
elements.

- The function expects that the length of all input arrays to be
  equal. It will expand any scalar inputs to the appropriately
  sized array before performing ``bitxor`` of each element.
- If ``assumedType`` is not provided, Grackle will implicitly convert real
  inputs to 64bit unsigned integers before computing the logical XOR
  operation.
- If ``assumedType`` is provided, it identifies the type for the
  inputs ``x`` and ``y`` as either fixed width signed or fixed width
  unsigned integers. It must have the form ``'intN'`` or ``'uintN'``
  where ``N`` is a positive integer.