# [Tutor] Defining "bit" type

Vicent vginer at gmail.com
Thu Jan 29 08:01:00 CET 2009

```On Tue, Jan 27, 2009 at 14:26, Ricardo Aráoz <ricaraoz at gmail.com> wrote:

>
> "Vicent" <vginer at gmail.com> <vginer at gmail.com> wrote
>
> Anyway, I am working with Python 2.5.4, and I am interested in defining a
> new type called "bit" (if possible), which represents a number that can
> only
> take values 0 or 1 —that's what we would call a "binary variable", in a
> Mathematical Programming context.
>
>  The python manual is usually a good thing to read :
>
>
> 3.4.1 Bit-string Operations on Integer Types
>
> Plain and long integer types support additional operations that make sense
> only for bit-strings. Negative numbers are treated as their 2's complement
> value (for long integers, this assumes a sufficiently large number of bits
> that no overflow occurs during the operation).
>
> The priorities of the binary bit-wise operations are all lower than the
> numeric operations and higher than the comparisons; the unary operation "~"
> has the same priority as the other unary numeric operations ("+" and "-").
>
>
> This table lists the bit-string operations sorted in ascending priority
> (operations in the same box have the same priority):
>
>   Operation Result Notes  x | y bitwise *or* of x and y
>   x ^ y bitwise *exclusive or* of x and y
>   x & y bitwise *and* of x and y
>   x << n x shifted left by n bits (1), (2)  x >> n x shifted right by nbits (1),
> (3)  ~x the bits of x inverted
>
> Notes:
>  *(1)* Negative shift counts are illegal and cause a ValueError to be
> raised. *(2)* A left shift by n bits is equivalent to multiplication by pow(2,
> n) without overflow check. *(3)* A right shift by n bits is equivalent to
> division by pow(2, n) without overflow check.
>

Ricardo,

Thank you. I think I already read this, but I didn't realize that it could
be useful for me.

I mean, I was looking for a class that stores only 0-1 values and that is
1-bit-sized, in order to save memory and/or disk space. That's why I thought
that "bool" type would be OK for me, but maybe I could also consider
integers (or translating those data into integers), because of those
operations that are already implemented and that you have just showed me.
Anyway, I think similar operators already exist for single "bool" data.

That approach you suggest would be useful in case I wanted to manage with
strings of 0's and 1's (which could be possible).

Thank you!

--
Vicent
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/tutor/attachments/20090129/6decceac/attachment.htm>
```