Do I really have to use an array?

[mike3]

Hi.

I can't believe I may have to use an array here.

I've got this bignum package I was making in C++ for a fractal
generator, and tried an approach that was suggested to me here a while
back, about using a "stack of vectors" instead of a static array.

Anyway, I put the suggestion into effect, and it seems the routine
that uses the stack of vectors (an in-place multiplication routine) is
real slow -- too slow for my liking. The out-of-place multiplication
is like twice as fast. What gives? Do I really have to use an evil
array on the stack? (in my code it would be something like "Digit
tmpBuf[2*MAX_PRECISION]".) I don't think so since it was said the
stack-of-vectors approach can be at least as fast as the array.

You can get the relevant code snippets here if you need to see them:
http://www.mediafire.com/?51qszh1cv2j

[mike3]

On Feb 5, 7:27 am, "Ralph D. Ungermann" <[e-mail]>
wrote:
<snip>

for ( std::size_t i = myLength; i--; )
{
//...

}

So that actually stops after "i" goes to 0?

[James Kanze]

On Feb 5, 3:27 pm, "Ralph D. Ungermann" <[e-mail]>
wrote:

mike3 wrote:

I was using int instead of std::size_t becuase loops like
this, which are used in several routines, do not work:

std::size_t myLength(myVect or.size());

for(std::size_t i(myLength-1);i>=0;i--)
{
... do something ...
}
Or is there a way to still use std::size_t without these
conversions???

for ( std::size_t i = myLength; i--; )
{
//...
}

Nice obfuscation.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Andrew Koenig]

"Alf P. Steinbach" <al***@start.no wrote in message
news:13******** *****@corp.supe rnews.com...

If you want the range myLenght-1 downto 0, inclusive, consider just

for( size_t i = myLength-1; i != size_t(-1); --i )

Cheers, & hth.,

I have to say that this example is too clever for my taste. I'd rather
write:

for (size_t i = myLength; i != 0; ) {
--i;

// whatever

}

One reason for my preference is that this technique works for bidirectional
iterators too:

for (list<T>::itera tor it = myList.end(); it != myList.begin(); ) {
--it;

// whatever

}

whereas the "myLength-1" technique doesn't.

[Richard Herring]

In message
<f1************ *************** *******@j78g200 0hsd.googlegrou ps.com>,
James Kanze <ja*********@gm ail.comwrites

>On Feb 5, 3:27 pm, "Ralph D. Ungermann" <[e-mail]>
wrote:

>mike3 wrote:

I was using int instead of std::size_t becuase loops like
this, which are used in several routines, do not work:

std::size_t myLength(myVect or.size());

for(std::size_t i(myLength-1);i>=0;i--)
{
... do something ...
}
Or is there a way to still use std::size_t without these
conversions???

>for ( std::size_t i = myLength; i--; )
{
//...
}

Nice obfuscation.

That's another word for "idiom", isn't it? Guaranteed termination, loop
invariant exists throughout the block, ... what more do you want?

(And it doesn't use break ;-)

--
Richard Herring

[James Kanze]

On Feb 6, 6:34 pm, Richard Herring <ju**@[127.0.0.1]wrote:

In message
<f12082d8-8b8f-46c1-9505-e4e852687...@j7 8g2000hsd.googl egroups.com>,
James Kanze <james.ka...@gm ail.comwrites

for ( std::size_t i = myLength; i--; )
{
//...
}

Nice obfuscation.

That's another word for "idiom", isn't it? Guaranteed
termination, loop invariant exists throughout the block, ...
what more do you want?

Readability.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Richard Herring]

In message
<86************ *************** *******@e4g2000 hsg.googlegroup s.com>,
James Kanze <ja*********@gm ail.comwrites

>On Feb 6, 6:34 pm, Richard Herring <ju**@[127.0.0.1]wrote:

>In message
<f12082d8-8b8f-46c1-9505-e4e852687...@j7 8g2000hsd.googl egroups.com>,
James Kanze <james.ka...@gm ail.comwrites

>for ( std::size_t i = myLength; i--; )
{
//...
}

>Nice obfuscation.

>That's another word for "idiom", isn't it? Guaranteed
termination, loop invariant exists throughout the block, ...
what more do you want?

Readability.

If it's an idiom, you don't need to read it. Whether it's an idiom is
ultimately a question of style guides and/or familiarity. If you want to
say that all reverse-indexing (as opposed to hiding the reversal inside
reverse iterators) is inherently unidiomatic, I wouldn't argue.

--
Richard Herring

[Ralph D. Ungermann]

James Kanze wrote:

On Feb 5, 3:27 pm, "Ralph D. Ungermann" <[e-mail]>
wrote:

>for ( std::size_t i = myLength; i--; )

Nice obfuscation.

The postfix `trick' is uncommon, but not unknown. After a first
irritation, one ought to get it -- and remember, if repeated.

Though the decrement is more correctly placed at the beginning of the
loop, this does neither enhance readability nor safety (IMHO).

I've seen too much code, where each loop has been handcrafted: mixing
int and size_t, cast both ways, decrementing i on-the-fly at the first
occurrance in the loop body, and worse. You'll agree, that this causes
much more obfuscation.

So I use my way, whenever I have to: using uncommon syntax for uncommon
loops.

But as you mention it, I'm willing to change my style to:

for ( std::size_t i = myLength; i--; /*backward*/ )
-- ralph

[Richard Herring]

In message <fo**********@m urphy.mediascap e.de>, Ralph D. Ungermann
<us****@mloge-ungermann.dewri tes

>James Kanze wrote:

>On Feb 5, 3:27 pm, "Ralph D. Ungermann" <[e-mail]>
wrote:

>>for ( std::size_t i = myLength; i--; )

Nice obfuscation.

The postfix `trick' is uncommon, but not unknown. After a first
irritation, one ought to get it -- and remember, if repeated.

Though the decrement is more correctly placed at the beginning of the
loop, this does neither enhance readability nor safety (IMHO).

I've seen too much code, where each loop has been handcrafted: mixing
int and size_t, cast both ways, decrementing i on-the-fly at the first
occurrance in the loop body, and worse. You'll agree, that this causes
much more obfuscation.

So I use my way, whenever I have to: using uncommon syntax for uncommon
loops.

But as you mention it, I'm willing to change my style to:

for ( std::size_t i = myLength; i--; /*backward*/ )

I was happy with this until yesterday, when a colleague pointed out that
the equivalent for iterators:

for (iterator i=container.end (); i-- != container.begin (); )
{
//...
}

doesn't work if the container is empty, whereas this is fine:

for (iterator i=container.end (); i != container.begin (); )
{
--i;
//...
}
--
Richard Herring