使用C语言的GNU科学库进行线性拟合

Question

I have two arrays of 64-bit integers (one for the x and one for the y values) I want to fit with a straight line starting from the origin. They both have length num .

I made a previous parsing of the two arrays so that they're both starting when they're zero, so I have to shift one of the two arrays, according to the value of result , either by pos1 or by pos2 .

Now, as I said, the arrays are 64-bit integer-sized, so I cast them as double. But whenever I call the following piece of code, the program crashes. c1 , cov11 and sumsq are defined outside as pointers to doubles.

if(result > 0)  
gsl_fit_mul((double *) array1 + pos2, 1,(double *) array2, 1, (num - pos2 - 1) * sizeof(uint64_t), c1, cov11, sumsq);
else
gsl_fit_mul((double *) array1, 1, (double *) array2 + pos1, 1, (num - pos2 - 1) * sizeof(uint64_t), c1, cov11, sumsq);

I tried reading the documentation , but it's actully not so clear, and I think the problem is in the call to the arrays.

Thank you in advance.

---

EDIT: I changed approach. I wrote this function

void findFit(uint64_t *array1, uint64_t *array2, uint64_t num, double c1){
    double *array1_parallel = malloc(num * sizeof(double)), *array2_parallel = malloc(num * sizeof(double));

    for(uint64_t i = 0; i < num; i++){
        array1_parallel[i] = (double) array1[i];
        array2_parallel[i] = (double) array2[i];
    }

    double *cov11, *sumsq;

    gsl_fit_mul(array1_parallel, 1, array2_parallel, 1, num, &c1, cov11, sumsq);

    free(array2_parallel);
    free(array1_parallel);

    return;
}

passing to it the already shifted and parsed arrays, but it's still not working...

Answer 1

Casting in C can be confusing. You're not casting the individual values, you're casting the pointer to those values. Which isn't what you want.

So, you're telling gsl_fit_mul() - "here's an array of doubles, not the array of ints that the compiler thinks it is." But they really are ints, so that's not going to work.

You need to create a second array of doubles and cast each of the ints to convert your ints into doubles.

so:

double* double_array1, *double_array2;
size_t i;

double_array1 = malloc(sizeof(double)*num);
double_array2 = malloc(sizeof(double)*num);
for (i=0; i < num; ++i) {
    double_array1[i] = array1[i];
    double_array2[i] = array2[i];
}


...
gsl_fit_mul(double_array1 + ..., double_array2, ...)
...
free(double_array1);
free(double_array2);

(Be sure to call free() on those arrays after you're done. If you know a maximum value for num at compile time, those arrays can be declared statically and you don't need to malloc/free them).

Also, I don't know this library at all, but I doubt that the 'n' parameter should be the size in bytes of the input arrays (which is what you're getting when you multiply by sizeof(uint64_t)). Just pass in the number of elements (num - minus your offsetting magic).