Using GSL lib functions on data in a struct C - c

Question

Many GSl functions take arguments as doubles or arrays of doubles. However much of my data is nested in arrays of structs instead. Say like arrays of:
struct A
{
double a;
int b;
};
I could write a wrapper that copies the data into an array of pure doubles or ints. But I was interested in something more elegant to get around this.

Answer 1

Not the answer you want. But since you cant change the GSL interface, if you are looking for performance, I think your best solution is probably to chose data structures that matches the job from the start. So maybe something like a struct containing arrays of doubles.
If both the GSL interface and your original data structure is out of your control, then your only option is probably going to be the wrapper that you are thinking about.
If the library functions that you are using could take a 'stride' argument, you could possibly look into structure packing and padding. (But that still wouldn't convert your ints to doubles.)

Answer 2

"...much of my data is nested in arrays of structs instead. ... I
could write a wrapper that copies the data into an array of pure
doubles or ints. But I was interested in something more elegant to get
around this."
There is no need to write a wrapper to copy the data into an an array of pure double or int. The fact that you have an array-of-struct already provides convenient direct access to every stored value. With an array-of-struct accessing each individual struct within the array is a simple matter of indexing the struct you want, e.g. array[n] where n is the wanted element within the array.
In your example array[n].a provides direct access to the double value in member a and array[n].b provides direct access to the int member b for each of the valid index within your array.
A short example of this indexing for direct access to each member of each struct within the array may help. The following initializes array with five struct with the double and int values shown. The int values are then incremented by 1 within the loop before each member of each struct is output, e.g.
#include <stdio.h>
typedef struct A { /* struct A (with a typedef for convenience) */
double a;
int b;
} A;
int main (void) {
/* array of struct A */
A array[] = {{1.1, 1}, {2.2, 2}, {3.3, 3}, {4.4, 4}, {5.5, 5}};
size_t nelem = sizeof array / sizeof *array; /* no. elements */
for (size_t i = 0; i < nelem; i++) {
array[i].b++; /* increment int/output stored values */
printf ("array[%zu]: {%3.1f, %d}\n", i, array[i].a, array[i].b);
}
}
Example Use/Output
Note how the integer value stored within each struc in the array-of-struct is incremented by 1 before the values in each struct with the array is directly used as the parameter being output by printf:
$ ./bin/arraystruct
array[0]: {1.1, 2}
array[1]: {2.2, 3}
array[2]: {3.3, 4}
array[3]: {4.4, 5}
array[4]: {5.5, 6}
Your access of each member regardless how you want to use it would be the same. Look things over and let me know if you have further questions.