blops

Bitwise operators, applied to BitArrays.

import gleeunit/should
import blops

// bitwise or
blops.bor(<<0b10101010>>, <<0b10111011>>)
|> should.equal(<<0b10111011>>)
// bitwise and
blops.band(<<0b10101010>>, <<0b10111011>>)
|> should.equal(<<0b10101010>>)
// bitwise xor (not equal)
blops.bneq(<<0b10101010>>, <<0b10111011>>)
|> should.equal(<<0b00010001>>)
// bitwise reverse implication 
blops.brevi(<<0b10101010>>, <<0b10111011>>)
|> should.equal(<<0b11101110>>)

Binary Operators

All the binary operators here come in three flavors:

truncating: The return value is the length of the shorter of the two operands; they’ll return as soon as they reach the end of one bit array. These functions have the shortest version of each set of names (e.g., band() for safe bitwise-and).
extending: The return value is the length of the longer of the two operands; they will behave as if the end of the shorter operand has been padded with zeros to the length of the longer. These function names end in an “x” (e.g., bandx() for extending bitwise-and).
fallible: These will fail with an error if the lengths of their operands differ. These function names end with “_try” (e.g., band_try() for fallible bitwise-and).

Unary Operator

There is also one unary operator: unary negation, bnot().

Values

band

</>

pub fn band(a: BitArray, b: BitArray) -> BitArray

bitwise and

band_try

</>

pub fn band_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

bandx

</>

pub fn bandx(a: BitArray, b: BitArray) -> BitArray

beq

</>

pub fn beq(a: BitArray, b: BitArray) -> BitArray

bitwise equal

beq_try

</>

pub fn beq_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

beqx

</>

pub fn beqx(a: BitArray, b: BitArray) -> BitArray

bimpl

</>

pub fn bimpl(a: BitArray, b: BitArray) -> BitArray

bitwise implication (if-then)

bimpl_try

</>

pub fn bimpl_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

bimplx

</>

pub fn bimplx(a: BitArray, b: BitArray) -> BitArray

bnand

</>

pub fn bnand(a: BitArray, b: BitArray) -> BitArray

bitwise not-and (nand)

bnand_try

</>

pub fn bnand_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

bnandx

</>

pub fn bnandx(a: BitArray, b: BitArray) -> BitArray

bneq

</>

pub fn bneq(a: BitArray, b: BitArray) -> BitArray

bitwise not-equal (xor)

bneq_try

</>

pub fn bneq_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

bneqx

</>

pub fn bneqx(a: BitArray, b: BitArray) -> BitArray

bnimpl

</>

pub fn bnimpl(a: BitArray, b: BitArray) -> BitArray

bitwise not-implies

bnimpl_try

</>

pub fn bnimpl_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

bnimplx

</>

pub fn bnimplx(a: BitArray, b: BitArray) -> BitArray

bnor

</>

pub fn bnor(a: BitArray, b: BitArray) -> BitArray

bitwise not-or (nor, neither)

bnor_try

</>

pub fn bnor_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

bnorx

</>

pub fn bnorx(a: BitArray, b: BitArray) -> BitArray

bnot

</>

pub fn bnot(a: BitArray) -> BitArray

Unary bitwise negation.

bnrevi

</>

pub fn bnrevi(a: BitArray, b: BitArray) -> BitArray

bitwise not-reverse-implies

bnrevi_try

</>

pub fn bnrevi_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

bnrevix

</>

pub fn bnrevix(a: BitArray, b: BitArray) -> BitArray

bor

</>

pub fn bor(a: BitArray, b: BitArray) -> BitArray

bitwise or

bor_try

</>

pub fn bor_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

borx

</>

pub fn borx(a: BitArray, b: BitArray) -> BitArray

brevi

</>

pub fn brevi(a: BitArray, b: BitArray) -> BitArray

bitwise reverse implication (only-if, when)

brevi_try

</>

pub fn brevi_try(
  a: BitArray,
  b: BitArray,
) -> Result(BitArray, errors.LengthMismatch)

brevix

</>

pub fn brevix(a: BitArray, b: BitArray) -> BitArray