read 1k * 1k data

[a]

To solve the 100k * 100k data, I finally adopt the file read method and use
malloc. The system somehow knows to use virtual memory.

Now I first test 1k * 1k data but something uninterpretable happens again.

The data file starts with:

42.106983132 85.931514337 98.155213938 23.685776453 76.827067592
....

when I print out the array storing the file content:

0.000000 k: 1020 r: 0.000000 k: 1021 r: 0.000000 k: 1022 r: 0.000000 k: 1023
r: 0.000000 k: 1024 r: 42.106983 k: 1025 r: 85.931514 k:

one can see the first line reading nothing (k as index and r as array
content)

I use the function fscanf to read the file:

#define SIZE 1024

double *r;
int i = 0;

r = (double *)malloc(SIZE * SIZE * sizeof(double));
while(!feof(file) && i<SIZE * SIZE) {
fscanf(file, "%lf", &r[i]);
i++;

// if (i < 30 ) return;
}
for (k=0; k<SIZE*SIZE; k++) {
// if (kSIZE * SIZE - 10 )
if (k< 2048 )
printf("k: %d r: %lf ",k, r[k]);
}
and indeed if (i < 30) return does not stop the file reading loop and i need
to add i < SIZE * SIZE to stop infinite reading. Anybody knows what's
happening?

Furthermore, when I use scanf, fscanf etc to search in Google, it returns
not so helpful example results. I'd also appreciate your suggestions on
searching help on web. Thanks a lot!!

[Eric Sosman]

a wrote:

To solve the 100k * 100k data, I finally adopt the file read method and use
malloc. The system somehow knows to use virtual memory.

Now I first test 1k * 1k data but something uninterpretable happens again.

The data file starts with:

42.106983132 85.931514337 98.155213938 23.685776453 76.827067592
...

when I print out the array storing the file content:

0.000000 k: 1020 r: 0.000000 k: 1021 r: 0.000000 k: 1022 r: 0.000000 k: 1023
r: 0.000000 k: 1024 r: 42.106983 k: 1025 r: 85.931514 k:

one can see the first line reading nothing (k as index and r as array
content)

I use the function fscanf to read the file:

#define SIZE 1024

double *r;
int i = 0;

r = (double *)malloc(SIZE * SIZE * sizeof(double));
while(!feof(file) && i<SIZE * SIZE) {

This mistake is the subject of Question 12.2 in the
comp.lang.c Frequently Asked Questions (FAQ) list,
<http://www.c-faq.com/>.

fscanf(file, "%lf", &r[i]);

Do you have any reason to believe that this worked?
Question 12.19 doesn't address this issue directly, but
has a few hints about it.

i++;

// if (i < 30 ) return;
}
for (k=0; k<SIZE*SIZE; k++) {
// if (kSIZE * SIZE - 10 )
if (k< 2048 )
printf("k: %d r: %lf ",k, r[k]);

This mistake is the subject of Question 12.9.

--
Eric Sosman
es*****@ieee-dot-org.invalid

[Malcolm McLean]

"a" <[e-mail] in message

To solve the 100k * 100k data, I finally adopt the file read method and
use malloc. The system somehow knows to use virtual memory.

Now I first test 1k * 1k data but something uninterpretable happens again.

The data file starts with:

42.106983132 85.931514337 98.155213938 23.685776453
76.827067592 ...

when I print out the array storing the file content:

0.000000 k: 1020 r: 0.000000 k: 1021 r: 0.000000 k: 1022 r: 0.000000 k:
1023 r: 0.000000 k: 1024 r: 42.106983 k: 1025 r: 85.931514 k:

one can see the first line reading nothing (k as index and r as array
content)

I use the function fscanf to read the file:

#define SIZE 1024

double *r;
int i = 0;

r = (double *)malloc(SIZE * SIZE * sizeof(double));
while(!feof(file) && i<SIZE * SIZE) {
fscanf(file, "%lf", &r[i]);
i++;

// if (i < 30 ) return;
}
for (k=0; k<SIZE*SIZE; k++) {
// if (kSIZE * SIZE - 10 )
if (k< 2048 )
printf("k: %d r: %lf ",k, r[k]);
}
and indeed if (i < 30) return does not stop the file reading loop and i
need to add i < SIZE * SIZE to stop infinite reading. Anybody knows what's
happening?

Furthermore, when I use scanf, fscanf etc to search in Google, it returns
not so helpful example results. I'd also appreciate your suggestions on
searching help on web. Thanks a lot!!

This looks OK to me.
Try putting in a test after malloc() to make sure you actually have the
memory.
Also put a newline on the end of your diagnostic printf().
Then
1) post the code where you open the file
2) try echoing the file characters back to stdout to make sure the file is
being read correctly. You will need to use fgetc().
3) Try reading to a temporary double and printing back to make sure sfcanf()
is converting the information properly.
--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[Old Wolf]

On Nov 26, 5:24 am, Ben Pfaff <[e-mail]:

"a" <[e-mail]:

#define SIZE 1024

double *r;
int i = 0;

r = (double *)malloc(SIZE * SIZE * sizeof(double));

The most likely result of this size calculation is 8388608. Are
you on a system where `int' can hold this value? `int' may have
a maximum value as small as 32767.

sizeof(double) gives a size_t, so the int that is SIZE*SIZE
= 1048576 will be promoted to size_t for the multiplication.

[CBFalconer]

Old Wolf wrote:

Ben Pfaff <[e-mail]:

>"a" <[e-mail]:

>>#define SIZE 1024

>>double *r;
int i = 0;

>> r = (double *)malloc(SIZE * SIZE * sizeof(double));

The most likely result of this size calculation is 8388608. Are
you on a system where `int' can hold this value? `int' may have
a maximum value as small as 32767.

sizeof(double) gives a size_t, so the int that is SIZE*SIZE
= 1048576 will be promoted to size_t for the multiplication.

No cast needed. However the SIZE * SIZE calculation may be
performed before multiplication by sizeof(double), and that
preliminary may overflow (ints do not have to extend past 32767)
and cause un (or implementation) defined behavior.

--
Chuck F (cbfalconer at maineline dot net)
<http://cbfalconer.home.att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[Charlie Gordon]

"CBFalconer" <cb********@yahoo.coma écrit dans le message de news:
47***************@yahoo.com...

Old Wolf wrote:

>Ben Pfaff <[e-mail]:

>>"a" <[e-mail]:

#define SIZE 1024

double *r;
int i = 0;

r = (double *)malloc(SIZE * SIZE * sizeof(double));

The most likely result of this size calculation is 8388608. Are
you on a system where `int' can hold this value? `int' may have
a maximum value as small as 32767.

sizeof(double) gives a size_t, so the int that is SIZE*SIZE
= 1048576 will be promoted to size_t for the multiplication.

No cast needed. However the SIZE * SIZE calculation may be
performed before multiplication by sizeof(double), and that
preliminary may overflow (ints do not have to extend past 32767)
and cause un (or implementation) defined behavior.

More precisely: SIZE * SIZE shall be performed before multiplication by
sizeof(double) because multiplication is left to right associative. If
MAX_INT is 32767, SIZE * SIZE will overflow, even if size_t happens to be a
larger type.

--
Chqrlie.

[Charlie Gordon]

"Old Wolf" <ol*****@inspire.net.nza écrit dans le message de news:
05**********************************...oglegroups.com...

On Nov 26, 5:24 am, Ben Pfaff <[e-mail]:

>"a" <[e-mail]:

#define SIZE 1024

double *r;
int i = 0;

r = (double *)malloc(SIZE * SIZE * sizeof(double));

The most likely result of this size calculation is 8388608. Are
you on a system where `int' can hold this value? `int' may have
a maximum value as small as 32767.

sizeof(double) gives a size_t, so the int that is SIZE*SIZE
= 1048576 will be promoted to size_t for the multiplication.

Almost true: the int that is SIZE * SIZE may have overflowed, then the
result will be promoted to size_t before multiplication by sizeof(double).
Unless size_t is a type smaller than int, in which case the whole expression
is evaluated as int and is signed (!).

--
Chqrlie.

[santosh]

In article <47***********************@news.free.fr>, Charlie Gordon
<ne**@chqrlie.orgwrote on Monday 26 Nov 2007 2:32 pm:

"CBFalconer" <cb********@yahoo.coma écrit dans le message de news:
47***************@yahoo.com...

>Old Wolf wrote:

>>Ben Pfaff <[e-mail]:
"a" <[e-mail]:

#define SIZE 1024

double *r;
int i = 0;

r = (double *)malloc(SIZE * SIZE * sizeof(double));

The most likely result of this size calculation is 8388608. Are
you on a system where `int' can hold this value? `int' may have
a maximum value as small as 32767.

sizeof(double) gives a size_t, so the int that is SIZE*SIZE
= 1048576 will be promoted to size_t for the multiplication.

No cast needed. However the SIZE * SIZE calculation may be
performed before multiplication by sizeof(double), and that
preliminary may overflow (ints do not have to extend past 32767)
and cause un (or implementation) defined behavior.

More precisely: SIZE * SIZE shall be performed before multiplication
by sizeof(double) because multiplication is left to right associative.
If MAX_INT is 32767, SIZE * SIZE will overflow, even if size_t happens
to be a larger type.

Couldn't a smart compiler note that the final value must be of type
size_t and hence perform all operations with that type, thus avoiding
the potential int overflow?

[Charlie Gordon]

"santosh" <sa*********@gmail.coma écrit dans le message de news:
fi**********@aioe.org...

In article <47***********************@news.free.fr>, Charlie Gordon
<ne**@chqrlie.orgwrote on Monday 26 Nov 2007 2:32 pm:

>"CBFalconer" <cb********@yahoo.coma écrit dans le message de news:
47***************@yahoo.com...

>>Old Wolf wrote:
Ben Pfaff <[e-mail]:
"a" <[e-mail]:
>
>#define SIZE 1024
>
>double *r;
>int i = 0;
>
> r = (double *)malloc(SIZE * SIZE * sizeof(double));
>
The most likely result of this size calculation is 8388608. Are
you on a system where `int' can hold this value? `int' may have
a maximum value as small as 32767.

sizeof(double) gives a size_t, so the int that is SIZE*SIZE
= 1048576 will be promoted to size_t for the multiplication.

No cast needed. However the SIZE * SIZE calculation may be
performed before multiplication by sizeof(double), and that
preliminary may overflow (ints do not have to extend past 32767)
and cause un (or implementation) defined behavior.

More precisely: SIZE * SIZE shall be performed before multiplication
by sizeof(double) because multiplication is left to right associative.
If MAX_INT is 32767, SIZE * SIZE will overflow, even if size_t happens
to be a larger type.

Couldn't a smart compiler note that the final value must be of type
size_t and hence perform all operations with that type, thus avoiding
the potential int overflow?

It would not be smart, it would be non conforming.
A smart compiler will detect the overflow in the constant expression and
report it to the programmer with a warning. That is if the programmer is
smart enough to ask for such reports ;-)

--
Chqrlie.

[Ben Pfaff]

"Charlie Gordon" <ne**@chqrlie.orgwrites:

>>>>>"a" <[e-mail]:
>>#define SIZE 1024
>>
>>double *r;
>>int i = 0;
>>
>> r = (double *)malloc(SIZE * SIZE * sizeof(double));

"santosh" <sa*********@gmail.coma écrit dans le message de news:
fi**********@aioe.org...

>Couldn't a smart compiler note that the final value must be of type
size_t and hence perform all operations with that type, thus avoiding
the potential int overflow?

It would not be smart, it would be non conforming.

Not true: SIZE * SIZE is the product of two `int's. If it
overflows, then behavior is undefined. Thus, the compiler can do
whatever it likes in that case, including evaluate the expression
as type size_t.
--
"You call this a *C* question? What the hell are you smoking?" --Kaz

[Malcolm McLean]

"Ben Pfaff" <bl*@cs.stanford.eduwrote in message

Not true: SIZE * SIZE is the product of two `int's. If it
overflows, then behavior is undefined. Thus, the compiler can do
whatever it likes in that case, including evaluate the expression
as type size_t.

Whilst if all operands are size_t the behaviour is defined. Therefore the
program cannot print out an error message. However this is a hollow victory
indeed, because the overflow will not do what you want.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[CBFalconer]

Charlie Gordon wrote:

"Old Wolf" <ol*****@inspire.net.nza écrit:

>Ben Pfaff <[e-mail]:

>>"a" <[e-mail]:

#define SIZE 1024

double *r;
int i = 0;

r = (double *)malloc(SIZE * SIZE * sizeof(double));

The most likely result of this size calculation is 8388608. Are
you on a system where `int' can hold this value? `int' may have
a maximum value as small as 32767.

sizeof(double) gives a size_t, so the int that is SIZE*SIZE
= 1048576 will be promoted to size_t for the multiplication.

Almost true: the int that is SIZE * SIZE may have overflowed, then
the result will be promoted to size_t before multiplication by
sizeof(double). Unless size_t is a type smaller than int, in which
case the whole expression is evaluated as int and is signed (!).

No. Once the int overflow occurs things are undefined.

--
Chuck F (cbfalconer at maineline dot net)
<http://cbfalconer.home.att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com