set double array to 0.0

[Carson]

Hi ,

Is there a very efficient way to set a double array to 0 ?
(I have tried memset, but the result doesn't look correct.)

Carson

[Tom St Denis]

Carson wrote:

Hi ,

Is there a very efficient way to set a double array to 0 ?
(I have tried memset, but the result doesn't look correct.)

Um try something along these lines

double myarray[SIZE], tmp;

tmp = 0.0;
memcpy(myarray, &tmp, sizeof(double)) ;
memcpy(myarray+ 1, &tmp, sizeof(double)) ;
memcpy(myarray+ 2, myarray, sizeof(double)* 2);
memcpy(myarray+ 4, myarray, sizeof(double)* 4);
memcpy(myarray+ 8, myarray, sizeof(double)* 8);
memcpy(myarray+ 16, myarray, sizeof(double)* 16);
.... until you cover SIZE

Tom

[Christian Bau]

In article <Gw************ ***@newssvr14.n ews.prodigy.com >,
"Carson" <ca****@ieee.or g> wrote:

Hi ,

Is there a very efficient way to set a double array to 0 ?
(I have tried memset, but the result doesn't look correct.)

Use a "for" loop. Works every time.

[Wei Zhou]

Carson wrote:

Hi ,

Is there a very efficient way to set a double array to 0 ?
(I have tried memset, but the result doesn't look correct.)

Carson

In my computer that's correct!

[SM Ryan]

"Carson" <ca****@ieee.or g> wrote:
# Hi ,
#
# Is there a very efficient way to set a double array to 0 ?
# (I have tried memset, but the result doesn't look correct.)

Most CPUs nowadays allow all zero bits as a real zero. Did you give memset
the right length?
double r[N];
memset(r,0,N*si zeof(double));

There's a trick you can play with some implementations of memcpy.

Otherwise you have to set with some kind loop.
--
SM Ryan http://www.rawbw.com/~wyrmwif/
A bunch of savages in this town.

[CBFalconer]

Carson wrote:

Is there a very efficient way to set a double array to 0 ?
(I have tried memset, but the result doesn't look correct.)

No, not and have the results meet the standards. Tou need
something like:

for (i = 0; i < size; i++) array[i] = 0.0;

--
Chuck F (cb********@yah oo.com) (cb********@wor ldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net> USE worldnet address!

[Jack Klein]

On Sun, 15 Aug 2004 22:33:10 GMT, "Carson" <ca****@ieee.or g> wrote in
comp.lang.c:

Hi ,

Is there a very efficient way to set a double array to 0 ?
(I have tried memset, but the result doesn't look correct.)

Carson

If you are defining the array, you can merely do this:

double d [SIZE] = { 0 };

....and this will initialize each and every member to 0.0.

On the other hand, if you have a malloc'ed array, or you have an array
that has unknown data in it that needs to be cleared to 0.0, a for
loop is probably best if the array is small. If it is very large,
this might be faster:

d [0] = 0; /* or 0.0, if you prefer */
memmove(d + 1, d, sizeof(double) * (SIZE - 1));

Using memmove() instead of memcpy() guarantees defined behavior even
though the source and destination areas overlap.

You would need to run timing tests on your particular
compiler/hardware combination to find out at what array size, if any,
the memmove() version becomes faster and by how much.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Keith Thompson]

"Carson" <ca****@ieee.or g> writes:

Is there a very efficient way to set a double array to 0 ?
(I have tried memset, but the result doesn't look correct.)

If you called memset with the right arguments, I would expect you to
see 0.0 in all entries on almost all systems. (Did you remember to
multiply the length by sizeof(double)? ) But the standard doesn't
guarantee that 0.0 is represented as all-bits-zero, so using memset
isn't strictly portable.

Probably the best solution is the simplest:

for (i = 0; i < LEN; i ++) {
arr[i] = 0.0;
}

See whether that's fast enough before you try something more
complicated.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[S.Tobias]

Jack Klein <ja*******@spam cop.net> wrote:

d [0] = 0; /* or 0.0, if you prefer */
memmove(d + 1, d, sizeof(double) * (SIZE - 1));

IMHO it won't work, unless I'm missing something very obvious.
(Values d[1], d[2]... are undetermined, and are copied
into positions d+2, d+3...)

--
Stan Tobias
sed 's/[A-Z]//g' to email

[Thomas Matthews]

Tom St Denis wrote:

Carson wrote:

Hi ,

Is there a very efficient way to set a double array to 0 ?
(I have tried memset, but the result doesn't look correct.)

Um try something along these lines

double myarray[SIZE], tmp;

tmp = 0.0;
memcpy(myarray, &tmp, sizeof(double)) ;
memcpy(myarray+ 1, &tmp, sizeof(double)) ;
memcpy(myarray+ 2, myarray, sizeof(double)* 2);
memcpy(myarray+ 4, myarray, sizeof(double)* 4);
memcpy(myarray+ 8, myarray, sizeof(double)* 8);
memcpy(myarray+ 16, myarray, sizeof(double)* 16);
... until you cover SIZE

Tom

I believe that a simple "for" loop would be much
easier to understand and probably more efficient
{since the function call overhead is removed).

unsigned int i;
for (i = 0; i < SIZE; ++i)
{
myarray[i] = 0.0;
}
--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.l earn.c-c++ faq:
http://www.comeaucomputing.com/learn/faq/
Other sites:
http://www.josuttis.com -- C++ STL Library book