Even Parity

[nick.stefanov]

I am trying to compute an even parity bit for a variable of type
char[]. Are there any C++, C# examples on how to first compute the bit
and then check it. Thank you very much ahead of time.

Nick

[Victor Bazarov]

ni***********@gmail.com wrote:

I am trying to compute an even parity bit for a variable of type
char[]. Are there any C++, C# examples on how to first compute the
bit and then check it. Thank you very much ahead of time.

If there are examples, they would be on the 'Net, don't you think?
Have you tried looking for them there? Besides, what does C# have
to do with this newsgroup?

[roberts.noah]

[e-mail] wrote:

I am trying to compute an even parity bit for a variable of type
char[]. Are there any C++, C# examples on how to first compute the bit
and then check it. Thank you very much ahead of time.

Try the >> operator.

[Rolf Magnus]

ni***********@gmail.com wrote:

I am trying to compute an even parity bit for a variable of type
char[]. Are there any C++, C# examples on how to first compute the bit
and then check it. Thank you very much ahead of time.

This should give you an idea of how to do it:

#include <iostream>
#include <limits>

int main()
{
unsigned char x = 0x36;

for (int i = 0; i < std::numeric_limits<unsigned char>::digits; ++i)
{
bool bit = x & (1 << i);
std::cout << "bit " << i << " is " << bit << '\n';
}
}

[n2xssvv g02gfr12930]

ni***********@gmail.com wrote:

I am trying to compute an even parity bit for a variable of type
char[]. Are there any C++, C# examples on how to first compute the bit
and then check it. Thank you very much ahead of time.

Nick

This code will return true if an even parity bit is required

bool ParityBit(char inp)
{
bool Parity = false;
for (;inp;inp &= (inp-1))
{
Parity ^= true;
}
return Parity;
}
Note by setting Parity to true to begin with will result in
returning true for odd parity.

JB

[red floyd]

Victor Bazarov wrote:

ni***********@gmail.com wrote:

I am trying to compute an even parity bit for a variable of type
char[]. Are there any C++, C# examples on how to first compute the
bit and then check it. Thank you very much ahead of time.

If there are examples, they would be on the 'Net, don't you think?
Have you tried looking for them there? Besides, what does C# have
to do with this newsgroup?

Actually, it's probably cheapest just to use a lookup table with 256
entries.

[Victor Bazarov]

red floyd wrote:

Victor Bazarov wrote:

ni***********@gmail.com wrote:

I am trying to compute an even parity bit for a variable of type
char[]. Are there any C++, C# examples on how to first compute the
bit and then check it. Thank you very much ahead of time.

If there are examples, they would be on the 'Net, don't you think?
Have you tried looking for them there? Besides, what does C# have
to do with this newsgroup?

Actually, it's probably cheapest just to use a lookup table with 256
entries.

256 entries in a table for "a variable of type char[]"? How do you
figure?

V

[red floyd]

Victor Bazarov wrote:

red floyd wrote:

Actually, it's probably cheapest just to use a lookup table with 256
entries.

256 entries in a table for "a variable of type char[]"? How do you
figure?

V

I meant it was faster to use a lookup than to use the shifting
methods mentioned above.

#include <algorithm>

struct parity
{
unsigned char operator()(unsigned char c) const
{
static const unsigned char parity_table[] = {
// FILL THIS IN
};
return parity_table[c];
}
};

unsigned char get_parity(unsigned char buf[], int len)
{
return std::accumulate(buf, buf+len, 0, parity());
}

[Victor Bazarov]

red floyd wrote:

Victor Bazarov wrote:

red floyd wrote:

Actually, it's probably cheapest just to use a lookup table with 256
entries.
256 entries in a table for "a variable of type char[]"? How do you
figure?

V

I meant it was faster to use a lookup than to use the shifting
methods mentioned above.

And I meant to point out that you'd assumed the OP was asking about the
unsigned char type, on a system that has CHAR_BITS == 8. The OP did no
such thing judging from the post alone.
#include <algorithm>

struct parity
{
unsigned char operator()(unsigned char c) const
{
static const unsigned char parity_table[] = {
// FILL THIS IN
How do you "FILL THIS IN"? A bunch of #ifdef's? What if the size of the
'unsigned char' is 16 bits? What if it's 32 bits? Please do not rush to
reply.
};
return parity_table[c];
}
};

unsigned char get_parity(unsigned char buf[], int len)
{
return std::accumulate(buf, buf+len, 0, parity());
}

V

[red floyd]

Victor Bazarov wrote:

And I meant to point out that you'd assumed the OP was asking about the
unsigned char type, on a system that has CHAR_BITS == 8. The OP did no
such thing judging from the post alone.

Good point about CHAR_BITS. I stand corrected. However, when
generating parity, the size of the data item being paritized(?) is
known, and depending on size, a lookup table can definitely be more
efficient *and* simpler.

[roberts.noah]

red floyd wrote:

Victor Bazarov wrote:

And I meant to point out that you'd assumed the OP was asking about the
unsigned char type, on a system that has CHAR_BITS == 8. The OP did no
such thing judging from the post alone.

Good point about CHAR_BITS. I stand corrected. However, when
generating parity, the size of the data item being paritized(?) is
known, and depending on size, a lookup table can definitely be more
efficient *and* simpler.

A combination of both is even better in many cases. For example, you
have a 63 bit data item you want to do a parity or a parity check on.
2^63 is big, 2^8 is not overly so. So, bit shift by 8 and do a lookup.
Tally the results... Rather similar to the "first bit" algorithm
often used in bitboard chess programs.

[nick.stefanov]

Thank you very much for all of your input.