unexpected result

[abotaha]

Hi everybody
i tried to run a simple code to find the mean value of an array using gsl library with eclipse. but i got "0" as a result. i would appreciate any help or advices.
the code is below with header file.

The code is

#include <iostream>
#include <cstdlib>
#include <ctime> // used for other parts of code
#include <cmath> // used fr other part of code
#include <gsl/gsl_statistics_double.h>
using namespace std;

double foo(double *data)
{
size_t data_size = sizeof(data)/sizeof(data[0]);
return gsl_stats_mean(data, 1, data_size);
}

int main()
{
double k;
double mod_data[] = {4.88,3.56,3.81,4.01,2.5,3.71,4.8,5.2};
k=foo(mod_data);
cout<<k<<endl;
system("pause");
return 0;
}

[jdragyn]

Without knowing anyting about gsl, I can tell you that

size_t data_size = sizeof(data)/sizeof(data[0]);

will not give you what you are expecting.

#include <iostream>
using namespace std;

void foo(double *data)
{
  cout << "sizeof(data) in foo(): " <<  sizeof(data) << "\n"
       << "sizeof(data[0]) in foo(): " << sizeof(data[0]) << endl;
}

int main()
{
  double mod_data[] = {4.88,3.56,3.81,4.01,2.5,3.71,4.8,5.2};
  cout << "sizeof(mod_data) in main(): " << sizeof(mod_data) << endl;
  foo(mod_data);
  return 0;
}

In main(), sizeof(mod_data) gives you the size, in bytes, of mod_data. In foo(), sizeof(data) gives you the size of a pointer, while sizeof(data[0]) gives you the size of that element.

sizeof() doesn't know anything about the array outside of the scope in which the array was defined, so you'll need to calculate the size of mod_data before hand and send it to foo() along with the array.

[abotaha]

thank you very much for the replay.
actually what i want to do is to find out length of the vector or array automatically, but i can not do that and i tried many ways to find that like read file in c++ but it is still not clear for me.
could you please give me advices or simple example to do that......

thanks in advance

[Elysia]

You cannot find out the length of arrays automatically.
You will need to either pass in size or use a container such as std::vector.

[jdragyn]

int main() {
  double mod_data[] = {4.88,3.56,3.81,4.01,2.5,3.71,4.8,5.2};
  size_t data_size = sizeof(mod_data)/sizeof(mod_data[0]);
  return 0;
}

Here, data_size will be what you expect because sizeof(mod_data) was used in the same block that mod_data[] was defined, so sizeof() knows enough about it. You could then follow it up with a call to

double k = foo(mod_data, data_size);

if you change the foo() function appropriately to take the data_size as a parameter instead of trying to calculate it. Assuming you are using the gsl function properly, k would then be what you expect. The point was that using sizeof() to calculate the size of an array defined in a different block won't work. (Remember, a block is enclosed in { and } ).

Since this is C++, you should look at using std::vector<double> for your mod_data type. This would allow you to pass only the mod_data to a function and get its size with

mod_data.size()

[m37h0d]

You cannot find out the length of arrays automatically.
You will need to either pass in size or use a container such as std::vector.

or create a template function where the size of the static array is a template parameter.

[Elysia]

Ah, that is a good idea.
Something like this then:

#include <iostream>
#include <cstdlib>
#include <ctime> // used for other parts of code
#include <cmath> // used fr other part of code
#include <gsl/gsl_statistics_double.h>
using namespace std;

template<typename T, int N> double foo(T data[N])
{
    size_t data_size = sizeof(data); // N elements
    return gsl_stats_mean(data, 1, data_size);
}

int main()
{
    double k;
    double mod_data[] = {4.88,3.56,3.81,4.01,2.5,3.71,4.8,5.2};
    k=foo(mod_data);
    cout<<k<<endl;
    system("pause");
    return 0;
}

[Ronix]

I don't think you can pass the array directly, as it would decay to a pointer, and you would lose the static size. You need to pass the array by reference:

#include <iostream>
#include <gsl/gsl_statistics_double.h>

template<size_t N>
double foo(double (&data)[N]) {
   return (gsl_stats_mean(data, 1, N));
}

int main() 
{
   double data[] = { 4.88, 3.56, 3.81, 4.01, 2.5, 3.71, 4.8, 5.2 };
   double k = foo(data);
   std::cout << k << std::endl;
   std::cin.get();
}

[Elysia]

Hmm.I cannot be sure of the why right now, but a mix of the two works fine:

#include <iostream>

template<typename T, size_t N>
double foo(T (&data)[N])
{
	std::cout << "Size: " << sizeof(data) << std::endl;
	return 0.0;
}

int main()
{
    double k;
    double mod_data[] = {4.88,3.56,3.81,4.01,2.5,3.71,4.8,5.2};
    k=foo(mod_data);
    return 0;
}

Output: Size: 64
Of course, it works without the T, as well.

[Ronix]

I didn't include T in the template because gsl_stats_mean takes a const double* as its first parameter, so passing any other type would produce a compiler error anyway.

[Elysia]

No doubt. I'm just putting it there to show the possibility.

[abotaha]

Thank you very much guys, all these information are good and useful.
i am now find out way to calculate the length of a vector by reading data file as follow:

#include <iostream>
#include <fstream>
#include <gsl/gsl_vector.h>
#define MAX 200
double x, data,ff[MAX];
FILE * input = fopen("example.dat", "r");
int i = 0,j;
while (fscanf (input, "%lf", &data) != EOF) ++i;
cout<<i;
fclose(input);
gsl_vector* v = gsl_vector_alloc(i);
FILE * input2 = fopen("buff.dat", "r");
gsl_vector_fscanf(input2,v);
fclose(input2);
for(j=0;j<i;j++)
{
ff[j]=gsl_vector_get(v,j);
cout<<"ff[ "<<j<<" ]= "<<ff[j]<<endl;
}
system("pause");
return 0;
}

i would appreciate if be some of you try to improve the code .
Thanks

[iMalc]

Thank you very much guys, all these information are good and useful.
i am now find out way to calculate the length of a vector by reading data file as follow:

i would appreciate if be some of you try to improve the code .
Thanks

int main()
{
}

There ... vastly improved! Now it actually compiles!

Other than that, we don't write your code for you, we just help you to get it right on your own.

[abotaha]

yes iMalc....thank you fo your comments.
I am now trying to find way how to read and print a matrix from data file without knowing its dimension, but it seems to me very difficult. Is there any way please to do that. ...
thanks.

[KenJackson]

There's a problem here:

double x, data,ff[MAX];
FILE * input = fopen("example.dat", "r");
int i = 0,j;
while (fscanf (input, "%lf", &data) != EOF) ++i;

The same double pointer is being passed to fscanf() in every loop. So it is overwriting the previous value leaving only the last one read. Maybe you meant something like this:

while (i < MAX  &&  fscanf(input, "%lf", &ff[i++]))
    ;

fscanf() returns the number of items scanned, not EOF, so it will keep looping until it's doesn't read a value, or i equals MAX.

As for reading unknown data, I always fread() it into a big buffer of char or unsigned char and examine each byte and convert the appropriate substrings with strtol() or strtod().