Optimize this please?

[Daniel T.]

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;
dst[1] |= src[1] >2;
dst[2] |= src[1] << 6;
dst[2] |= src[2] >3;
dst[3] |= src[2] << 5;
dst[3] |= src[3] >4;
dst[4] |= src[3] << 4;
dst[4] |= src[4] >5;
dst[5] |= src[4] << 3;
dst[5] |= src[5] >6;
dst[6] |= src[5] << 2;
dst[6] |= src[6] >7;
dst[7] |= src[6] << 1;
dst[7] |= src[7] >8;
dst[8] |= src[7];
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

--
To send me email, put "sheltie" in the subject.

[Victor Bazarov]

Daniel T. wrote:

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;
dst[1] |= src[1] >2;
dst[2] |= src[1] << 6;
dst[2] |= src[2] >3;
dst[3] |= src[2] << 5;
dst[3] |= src[3] >4;
dst[4] |= src[3] << 4;
dst[4] |= src[4] >5;
dst[5] |= src[4] << 3;
dst[5] |= src[5] >6;
dst[6] |= src[5] << 2;
dst[6] |= src[6] >7;
dst[7] |= src[6] << 1;
dst[7] |= src[7] >8;
dst[8] |= src[7];
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

Replace all but the last semicolon in the body of this function
with *commas*. Here, I saved you 19 semicolons (if I can count).
Now, where are _your_ notes to compare?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Ron Natalie]

Daniel T. wrote:

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;

>
I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

Why? Did someone put a quota on semicolons?
You can replace every semicolon except for the last with a comma
if you like. If there is some goal here other than reducing the
number of semicolons, then you'll have to tell us what you really
want to do before we can make an intelligent answer.

[Daniel T.]

Ron Natalie <ro*@spamcop.netwrote:

Daniel T. wrote:

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

Why? Did someone put a quota on semicolons?
You can replace every semicolon except for the last with a comma
if you like. If there is some goal here other than reducing the
number of semicolons, then you'll have to tell us what you really
want to do before we can make an intelligent answer.

I'm looking for the loop. I can almost see one in the code but I can't
quite find it.

--
To send me email, put "sheltie" in the subject.

[Victor Bazarov]

Daniel T. wrote:

Ron Natalie <ro*@spamcop.netwrote:

>Daniel T. wrote:

>>typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;

>>>
I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can
get it and we can compare notes.

Why? Did someone put a quota on semicolons?
You can replace every semicolon except for the last with a comma
if you like. If there is some goal here other than reducing the
number of semicolons, then you'll have to tell us what you really
want to do before we can make an intelligent answer.

I'm looking for the loop.

Don't. Unrolled code is almost always faster than any loops.

[..]

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Mike Wahler]

"Daniel T." <da******@earthlink.netwrote in message
news:da****************************@news.west.eart hlink.net...

Ron Natalie <ro*@spamcop.netwrote:

>Daniel T. wrote:

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;

>
I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

Why? Did someone put a quota on semicolons?
You can replace every semicolon except for the last with a comma
if you like. If there is some goal here other than reducing the
number of semicolons, then you'll have to tell us what you really
want to do before we can make an intelligent answer.

I'm looking for the loop. I can almost see one in the code but I can't
quite find it.

Why do you feel that a loop will be any more
efficient than what you already have? All that
I think it might do is reduce the length of your
source; but is that really so important?

-Mike

[Daniel T.]

In article <da****************************@news.west.earthlin k.net>,
"Daniel T." <da******@earthlink.netwrote:

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;
dst[1] |= src[1] >2;
dst[2] |= src[1] << 6;
dst[2] |= src[2] >3;
dst[3] |= src[2] << 5;
dst[3] |= src[3] >4;
dst[4] |= src[3] << 4;
dst[4] |= src[4] >5;
dst[5] |= src[4] << 3;
dst[5] |= src[5] >6;
dst[6] |= src[5] << 2;
dst[6] |= src[6] >7;
dst[7] |= src[6] << 1;
dst[7] |= src[7] >8;
dst[8] |= src[7];
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

Here is what I have so far:

void packBits( u8* dst, const u16* src )
{
for ( unsigned i = 0; i < 8; ++i )
{
dst[i] |= src[i] >(i + 1);
dst[i + 1] |= src[i] << (7 - i);
}
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

--
To send me email, put "sheltie" in the subject.

[Victor Bazarov]

Daniel T. wrote:

In article <da****************************@news.west.earthlin k.net>,
"Daniel T." <da******@earthlink.netwrote:

>typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;
dst[1] |= src[1] >2;
dst[2] |= src[1] << 6;
dst[2] |= src[2] >3;
dst[3] |= src[2] << 5;
dst[3] |= src[3] >4;
dst[4] |= src[3] << 4;
dst[4] |= src[4] >5;
dst[5] |= src[4] << 3;
dst[5] |= src[5] >6;
dst[6] |= src[5] << 2;
dst[6] |= src[6] >7;
dst[7] |= src[6] << 1;
dst[7] |= src[7] >8;
dst[8] |= src[7];
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can
get it and we can compare notes.

Here is what I have so far:

void packBits( u8* dst, const u16* src )
{
for ( unsigned i = 0; i < 8; ++i )
{
dst[i] |= src[i] >(i + 1);
dst[i + 1] |= src[i] << (7 - i);
}
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

Why isn't it good enough? You could make the shift values also part
of the loop, thus making it

for (unsigned i = 0, sl = 1, sr = 7; i < 8; ++i, ++sl, --sr)
{
dst[i] |= src[i] >sr;
dst[i+1] |= src[i] << sl;
}
...

But is it better? What is it you're trying to accomplish? Speed?
Readability? Maintainability?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[kwikius]

Daniel T. wrote:

In article <da****************************@news.west.earthlin k.net>,
"Daniel T." <da******@earthlink.netwrote:

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;
dst[1] |= src[1] >2;
dst[2] |= src[1] << 6;
dst[2] |= src[2] >3;
dst[3] |= src[2] << 5;
dst[3] |= src[3] >4;
dst[4] |= src[3] << 4;
dst[4] |= src[4] >5;
dst[5] |= src[4] << 3;
dst[5] |= src[5] >6;
dst[6] |= src[5] << 2;
dst[6] |= src[6] >7;
dst[7] |= src[6] << 1;
dst[7] |= src[7] >8;
dst[8] |= src[7];
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

Here is what I have so far:

void packBits( u8* dst, const u16* src )
{
for ( unsigned i = 0; i < 8; ++i )
{
dst[i] |= src[i] >(i + 1);
dst[i + 1] |= src[i] << (7 - i);
}
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

To unroll the loop use a recursive functor with specialistaions for
those that dont fit:
(Not tested) e.g:
template <int N>
struct functor;

// end condition
template <>
struct functor<0>{
void operator()( u8* dst, const u16* src)
{
dst[0] |= src[i] >( 1);
dst[1] |= src[0] << (7 );
}
};
// main case
template <int I>
struct functor{
void operator()( u8* dst, const u16* src)
{
functor<I-1f_prev;
f_prev(dst,src); // call the rest
dst[i] |= src[i] >(I + 1);
dst[I + 1] |= src[i] << (7 - I);
}
};
// required explicit specialisations for functors<9to functor<11>
not shown

int main()
{
functor<11f; // useage
f (dst, src);
}

[Victor Bazarov]

kwikius wrote:

[..]
template <int N>
struct functor;

// end condition
template <>
struct functor<0>{
void operator()( u8* dst, const u16* src)
{
dst[0] |= src[i] >( 1);

^^^^^^
I believe 'src[0]' is meant here.

dst[1] |= src[0] << (7 );
}
};
[..]

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Alf P. Steinbach]

* Daniel T.:

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;
dst[1] |= src[1] >2;
dst[2] |= src[1] << 6;
dst[2] |= src[2] >3;
dst[3] |= src[2] << 5;
dst[3] |= src[3] >4;
dst[4] |= src[3] << 4;
dst[4] |= src[4] >5;
dst[5] |= src[4] << 3;
dst[5] |= src[5] >6;
dst[6] |= src[5] << 2;
dst[6] |= src[6] >7;
dst[7] |= src[6] << 1;
dst[7] |= src[7] >8;
dst[8] |= src[7];
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

I'd use a single bitblt-call, using the system's hardware, if efficiency
is a great concern (src seems to be a 9x9 monochrome bitmap).

Single most important technical lesson learned from early Smalltalk: we
need hardware supported bitblt.

Conspiciously lacking in C++ standard library: bitblt.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[kwikius]

Victor Bazarov wrote:

kwikius wrote:

[..]
template <int N>
struct functor;

// end condition
template <>
struct functor<0>{
void operator()( u8* dst, const u16* src)
{
dst[0] |= src[i] >( 1);

^^^^^^
I believe 'src[0]' is meant here.

Sure. make the functions const and probably the args * const too AFAICS
for good style.
I'm sure VC8 would make a nice job optimising it and probably gcc too.

Let me know if it works. ;-)
regards
Andy Little

[Alf P. Steinbach]

* Alf P. Steinbach:

* Daniel T.:

>typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;
dst[1] |= src[1] >2;
dst[2] |= src[1] << 6;
dst[2] |= src[2] >3;
dst[3] |= src[2] << 5;
dst[3] |= src[3] >4;
dst[4] |= src[3] << 4;
dst[4] |= src[4] >5;
dst[5] |= src[4] << 3;
dst[5] |= src[5] >6;
dst[6] |= src[5] << 2;
dst[6] |= src[6] >7;
dst[7] |= src[6] << 1;
dst[7] |= src[7] >8;
dst[8] |= src[7];
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

I'd use a single bitblt-call, using the system's hardware, if efficiency
is a great concern (src seems to be a 9x9 monochrome bitmap).

Single most important technical lesson learned from early Smalltalk: we
need hardware supported bitblt.

Conspiciously lacking in C++ standard library: bitblt.

Except -- just after hitting "Send" it occurred to me that the usual
bitblt doesn't solve this particular packing problem, probably.

Well.

Sorry.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[kwikius]

Alf P. Steinbach wrote:

* Daniel T.:

typedef unsigned short u16; // may be different on your machine
typedef unsigned char u8; // may be different on your machine

// assume dst is zero initialized upon entry
void packBits( u8* dst, const u16* src )
{
dst[0] |= src[0] >1;
dst[1] |= src[0] << 7;
dst[1] |= src[1] >2;
dst[2] |= src[1] << 6;
dst[2] |= src[2] >3;
dst[3] |= src[2] << 5;
dst[3] |= src[3] >4;
dst[4] |= src[3] << 4;
dst[4] |= src[4] >5;
dst[5] |= src[4] << 3;
dst[5] |= src[5] >6;
dst[6] |= src[5] << 2;
dst[6] |= src[6] >7;
dst[7] |= src[6] << 1;
dst[7] |= src[7] >8;
dst[8] |= src[7];
dst[9] |= src[8] >1;
dst[10] |= src[8] << 7;
dst[10] |= src[9] >2;
dst[11] |= src[9] << 6;
}

I want to duplicate the above function using as few semicolons as
possible. If you want to take up the puzzle, see how small you can get
it and we can compare notes.

I'd use a single bitblt-call, using the system's hardware, if efficiency
is a great concern (src seems to be a 9x9 monochrome bitmap).

If its a constant bitmap, as all the above integers are constants then
I reckon you could in fact do the whole thing at compile time using
Fusion

http://spirit.sourceforge.net/dl_mor...tml/index.html

regards
Andy Little