Returning double * in function argument - c++

Question

Countless GSL functions return their result as a pointer in their first argument. For instance
int gsl_matrix_get_col (gsl_vector * v, const gsl_matrix * m, size_t j)
My programming level is very low, but I was told such things were impossible with local variables (deleted on end of function), but possible with pointers, as long as they were declared and allocated correctly by the caller function. I find it very strange, such fundamental difference should exist between pointers and normal variables, but I tried to use this storing of results in variables for a simple GSL programme, where I want a function (fetch_eigenvalue()) to output two things. And I fail. My programme is the following:
#include <math.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_blas.h>
/* Parameters */
#define N 3
int CREATE_MATRIX_AND_VECTOR(gsl_matrix *m, gsl_vector *v);
double fetch_eigenvalue(gsl_matrix *M, gsl_vector *v, double *rescos);
int main()
{
gsl_matrix *unit_matrix = gsl_matrix_calloc(N, N); //soon to be unity
gsl_vector *v = gsl_vector_calloc(N); //soon to be unit x vector
double *outcos = (double*)malloc(sizeof(double) );
printf("**********************************************\n");
CREATE_MATRIX_AND_VECTOR(unit_matrix, v);
fetch_eigenvalue(unit_matrix, v, outcos);
printf("==IN MAIN: outcos = %e\n", *outcos);
free((void *)outcos);
gsl_vector_free(v);
gsl_matrix_free(unit_matrix);
printf("**********************************************\n");
return(0);
}
int CREATE_MATRIX_AND_VECTOR(gsl_matrix * m, gsl_vector *v)
{
int i;
for (i = 0; i < N; i++)
{
gsl_matrix_set(m, i, i, 1.0);
}
gsl_vector_set(v, 0, 1.0);
return(0);
}
double fetch_eigenvalue(gsl_matrix *M, gsl_vector *v, double *rescos) //fetches eigenvalue, if Mv is parallel to v within accuracy gvaccu
//rescos is the cosine of the angle between Mv and v
{
int i,lv;
double v0, v1, cos;
double result;
double vnorm, pnorm;
double rdot;
lv = v->size;
double gvaccu = 1e-10;
gsl_vector *prod = gsl_vector_calloc(lv);
gsl_matrix_get_row(prod, M, 0);
if(gsl_blas_dnrm2(prod)==0.0)
{
result = 0.0;
}
else
{
gsl_blas_dgemv( CblasNoTrans,1.0, M, v, 0.0, prod);
gsl_blas_ddot(prod, v, &rdot);
pnorm = gsl_blas_dnrm2(prod);
vnorm = gsl_blas_dnrm2(v);
cos = rdot/pnorm/vnorm;
cos = fabs(cos);
rescos = &cos;
if(fabs(cos -1.0) > gvaccu)
{
result = -1.0;
}
else
{
v0 = gsl_vector_get(v,0);
v1 = gsl_vector_get(prod,0);
result = v1/v0;
}
}
printf("==IN FETCH_EV: COS = %e\n", cos);//print cheat!!
printf("==IN FETCH_EV: RESCOS = %e\n", *rescos);//print cheat!!
gsl_vector_free(prod);
return(result);
}
I run it and get the following output:
ludi#ludi-M17xR4:~/Desktop/Healpix_3.20$ g++ -o wrong_output wrong_output.c -L. -L/sw/lib -I/sw/include -lgsl -lblas && ./wrong_output
**********************************************
==IN FETCH_EV: COS = 1.000000e+00
==IN FETCH_EV: RESCOS = 1.000000e+00
==IN MAIN: outcos = 0.000000e+00
**********************************************
ludi#ludi-M17xR4:~/Desktop/Healpix_3.20$
So, the caller main() knows nothing about what happened inside fetch_eigenvalue(), eventhough I used a pointer. What am I doing wrong? I have the feeling, that I have misunderstood something very essential.

Answer 1

I sum up what you do with the parameter rescos in your fetch_eigenvalue function:
double fetch_eigenvalue(gsl_matrix *M, gsl_vector *v, double *rescos)
{
double cos;
// some code
rescos = &cos;
// some code
return(result);
}
Here you're not modifying the double value pointed by rescos, you're modifying the varaible rescos itself, which is a copy of the variable outcos used in your main.
What you want to do in fetch_eigenvalue is copying the value of cos into the variable pointed by rescos:
double fetch_eigenvalue(gsl_matrix *M, gsl_vector *v, double *rescos)
{
double cos;
// some code
*rescos = cos;
// some code
return(result);
}
EDIT: As stated by the other answers, it's better to avoid malloc when you can, and here you can:
double outcos;
fetch_eigenvalue(unit_matrix, v, &outcos);

Answer 2

I suspect that this is because the statement rescos = &cos; saves into rescos the address of the local variable cos. However, the scope of this variable is only local so that you can not then use it in the main(). I guess what you want to do is to:
change rescos = &cos; to *rescos = cos; in the fetch_eigenvalue function so that the value of cos is stored at the address pointed to by rescos
use merely double outcos; in the main() function, i.e., don't use pointer
call fetch_eigenvalue as fetch_eigenvalue(unit_matrix, v, &outcos);

Answer 3

I don't know anything about GSL, but it appears to be a library that uses C-style interface. To set values from a function, they use pointers. You don't seem to know how to use such an API yet, so here's some hints.
The statements
double *outcos = (double*)malloc(sizeof(double) );
...
fetch_eigenvalue(unit_matrix, v, outcos);
is not how you want to use such an API. Instead, you just define a double variable, and use the address of operator in the call:
double outcos;
...
fetch_eigenvalue(unit_matrix, v, &outcos);
Also, in your method, to assign a value, use don't use
cos = fabs(cos);
rescos = &cos;
but
cos = fabs(cos);
*rescos = cos;
to assign the value to the variable pointed to, not to the pointer.
Hope this helps.