Question

代码行： gsl_blas_daxpy(-a,&gsl_matrix_column(D, q).vector,y); 导致错误

错误C2102：'＆amp;'需要l值

，现在问题是我无法控制GSL功能所以我不知道如何解决这个问题（删除“&”不起作用）

之后我得到了

错误C2198：'gsl_blas_daxpy'：调用
的参数太少

我正在使用Visual Studio 2010。

GSL_EXPORT int  gsl_blas_daxpy (double alpha,
                                const gsl_vector * X,
                                gsl_vector * Y);


#include <stdio.h>
#include <math.h>
#include <time.h>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_blas.h>

#define M (10) // Number of columns in dictionary */
#define N ((int)(M/2)) // Number of rows in dictionary */
int K = 0.07*M; //Number of non-zero elements in signal - the sparsity 
int P=1; //number of signals
double epsilon = 1.0e-7; // Residual error 
int numOfIterations = N; /* Max num of iterations - same as num of elements in signal */

double sign(double x){return (x>=0) - (x<0);} // Sign function 

int main(int argc, char** argv)
{
int n, m, k, iter, q;
double normi, normf, tmp , norm=sqrt(N), htime;
gsl_matrix *D;  // A random dictionary used for encoding the sparse signal  NxM
gsl_vector *x;  // Sparse info signal (encoder input) MxP
gsl_vector *z;  // Evaluated Sparse info signal (decoder output)  MxP
gsl_vector *r;  // Residual error vector MxP
gsl_vector *y;  // Sparse representation of signal (encoder output) NxP
gsl_vector_view v;
clock_t start; //for measuring performance

printf("\nDictionary is:NxM=%dx%d,and the signal sparsity is K=%d", N, M, K);


srand(time(NULL)); //Initialize srand
start =clock(); //Initialize  clock

/* Initiallize D as a Bernoulli random dictionary */
D = gsl_matrix_alloc (N, M);
for(m=0; m<M; m++)
    {
    for(n=0; n<N; n++)
     {
        tmp=sign(2.0*rand()/(double)RAND_MAX-1.0)/norm;
        gsl_matrix_set (D, n, m, tmp);    //D[n,m]=tmp
     }
   }

/* Create a random K-sparse info signal */
x = gsl_vector_alloc(M);
for(k=0; k<K; k++)
 {
    gsl_vector_set(x, rand()%M, 2.0*rand()/(float)RAND_MAX - 1.0); //put random values at k random positions
 }

/* Allocate memory for solution (evaluated signal) */
z = gsl_vector_calloc(M); 

/* Allocate memory for residual vector */
r = gsl_vector_calloc(M);

/* Allocate memory for the encoded signal vector (its representation) */
y = gsl_vector_alloc(N);

htime=((double)clock()-start)/CLOCKS_PER_SEC;
printf("\nTime data allocation: %f", htime);

/* Encoding the signal (x to y) */
start = clock();
gsl_blas_dgemv(CblasNoTrans, 1, D, x, 0, y); // y = Dx
htime=((double)clock()-start)/CLOCKS_PER_SEC;
printf("\nTime for encoding: %f", htime);

/* Decoding the signal */
start = clock();
normi = gsl_blas_dnrm2(y); // ||y|| (L2 norm)
epsilon = sqrt(epsilon * normi); 
normf = normi;
iter = 0;

/*iterate till the computational error is small enough*/
while(normf > epsilon && iter < numOfIterations)
    {
        gsl_blas_dgemv(CblasTrans, 1, D, y, 0, r); // r=D'*y
        q = gsl_blas_idamax(r); //index of max element in residual vector
        tmp = gsl_vector_get(r, q); //the  max element in r
        gsl_vector_set(z, q, gsl_vector_get(z, q)+tmp); // z[q]=z[q]+ tmp
        v=gsl_matrix_column(D, q); // choose the dictrionary's atom (coloum) with the index of largest element in r
        gsl_blas_daxpy(-tmp,&v.vector,y); // y = y-tmp*v
        normf = gsl_blas_dnrm2(y); // ||y|| (L2 norm)
        iter++;
    }

htime = ((double)clock()-start)/CLOCKS_PER_SEC;
printf("\nTime for decoding: %f", htime);
tmp = 100.0*(normf*normf)/(normi*normi); // the error at end of algorithm
printf("\nComputation residual error: %f",tmp);

/* Check the solution (evaluated signal) against the original signal */
printf("\nSolution (first column),Reference (second column):");
getchar(); // wait for pressing a key
for(m=0; m<M; m++)
    {   
        printf("\n%.3f\t%.3f", gsl_vector_get(x, m),gsl_vector_get(z, m));
    }

normi = gsl_blas_dnrm2(x);
gsl_blas_daxpy(-1.0, x, z); // z = z-x
normf = gsl_blas_dnrm2(z); // ||z|| (L2 norm)
tmp = 100.0*(normf*normf)/(normi*normi); //final error
printf("\nSolution residual error: %f\n",tmp);

/* Memory clean up and shutdown*/
gsl_vector_free(y); gsl_vector_free(r);
gsl_vector_free(z); gsl_vector_free(x);
gsl_matrix_free(D);
getchar();
return EXIT_SUCCESS;
}

Answer 1

gsl_matrix_column(D, q).vector是R值。你不能拿它的地址。您需要一个L值，所以首先将它分配给一个命名变量，然后将该变量的地址传递给该函数。

Answer 2

    gsl_vector_view c=gsl_matrix_column(D, q);
    gsl_blas_daxpy(-a,&c.vector,y);

我认为，引入时间变量会导致您将指针传递给函数。

编辑：嗯，试图理解这个问题，我想知道函数的期望：

int gsl_blas_daxpy (double alpha, const gsl_vector * x, gsl_vector * y)

和

gsl_vector_view gsl_matrix_column (gsl_matrix * m, size_t j)

有些explanation：

矢量视图可以传递给任何带矢量的子程序参数就像直接分配的矢量一样，使用＆安培; view.vector

和example：

   for (j = 0; j < 10; j++)
     {
       gsl_vector_view column = gsl_matrix_column (m, j);
       double d;

       d = gsl_blas_dnrm2 (&column.vector);

       printf ("matrix column %d, norm = %g\n", j, d);
     }

Answer 3

如果你为gsl_matrix_column的返回值建立一个更永久的家，（这个特定的）问题就会消失。

这是一些简化的代码，说明了如何在可寻址插槽中捕获返回值：

struct _foo {
  int i;
};

struct _foo bar () {
  struct _foo result = { 5 };
  return result;
}

/* won't compile; 'lvalue required as unary & operand */
void qux () {
  int *j = &bar().i;
}

/* compiles OK */
void qal () {
  struct _foo result = bar();
  int* j = &result.i;
}

Answer 4

现在我们还有另一个问题：

这里有另一个答案：

您是否知道int K= 0.7是K=0 ??

#define M (10) // Number of columns in dictionary */
int K = 0.07*M; //Number of non-zero elements in signal - the sparsity

alloc不会初始化向量x。 x将包含垃圾值，而不是0。你的意思是x = gsl_vector_calloc(M); with c吗？它会将x设置为0。

/* Create a random K-sparse info signal */
x = gsl_vector_alloc(M);
for(k=0; k<K; k++)      // K=0, for get skiped and x not modified.
 {
    gsl_vector_set(x, rand()%M, 2.0*rand()/(float)RAND_MAX - 1.0); //put random values at k random positions
 }

（在这里你将获得最多K个随机值，但可能最少）

错误C2102：'＆amp;'需要l值

4 个答案: