小编Man*_*ete的帖子

当我在C中交换指针时,我一直在努力理解不同的行为.如果我想交换两个int指针,那么我可以做

void intSwap (int *pa, int *pb){
    int temp = *pa;
    *pa = *pb;
    *pb = temp;
}

但是,如果我想交换两个char指针,我需要做类似的事情

void charSwap(char** a, char** b){
    char *temp = *a;
    *a = *b;
    *b = temp;
}

因为如果我这样做

void charSwap(char* a, char* b){
    char temp = *a;
    *a = *b;
    *b = temp;
}

编译器抱怨表达式*a =*b,因为它无法更改值.如果我想交换两个strings(即char* s1= "Hello"; char* s2="Bye";)如何做到这一点？

你能给我一点帮助吗？我想真正了解它是如何工作的,所以在获得正确答案之前我不需要经历反复试验.我希望它对许多其他人有用.

我一直在尝试使用SciPy进行2D矩阵的卷积,而Numpy却失败了.对于SciPy我试过,sepfir2d和scipy.signal.convolve和Convolve2D for Numpy.在Matlab for Python中是否有像conv2这样的简单函数？

这是一个例子:

 A= [ 5     4     5     4;
      3     2     3     2;
      5     4     5     4;
      3     2     3     2 ]

我想把它卷入其中 [0.707 0.707]

而来自Matlab的conv2的结果是

3.5350    6.3630    6.3630    6.3630    2.8280
2.1210    3.5350    3.5350    3.5350    1.4140
3.5350    6.3630    6.3630    6.3630    2.8280
2.1210    3.5350    3.5350    3.5350    1.4140

有些函数用Python来计算这个输出吗？我将感激回应.

FSPB_main.cpp

int main(int args, char* argv[]){    
    .......   

   float *d_a;   
   cudaMalloc( (void**)&d_a, 5*sizeof(float) );

}

$ nvcc -L/usr/local/cuda/lib -lcutil -lcudpp -lcuda -lcudart -c -o FSPB_main.o FSPB_main.cpp

FSPB_main.cpp:在函数'int main(int,char**)'中:FSPB_main.cpp:167:45:错误:'cudaMalloc'未在此范围内声明

这个错误是什么意思？它只是一个cudaMalloc并且它假设为编译器支持吗？

像cudaMalloc这样的函数可以用在.cpp文件中吗？我是否需要为来自CUDA的任何内容创建.cu文件？

我有一个Windows HPC Server在后端运行一些节点.我想使用后端的多个节点运行Parallel R. 我认为Parallel R可能在Windows上使用SNOW,但对它不太确定.我的问题是,我是否还需要在后端节点上安装R？假设我想使用两个节点,每个节点32个核心:

cl <- makeCluster(c(rep("COMP01",32),rep("COMP02",32)),type="SOCK")

现在,它只是挂起.

我还需要做什么？后端节点是否需要运行某种sshd以便能够相互通信？

我是C#中状态模式实现的新手,你能否提供一些关于如何实现它的信息.

我正在使用状态模式在C#中重构状态机.目前我的状态机包含5个状态,只能通过状态前进或后退,即从状态1开始,你需要进入状态2,3和4,最后到达状态5.

我能够继续前进

       mainclass.State = new NextSate();

每次你想要前进时都会创建一个新状态,但是,一旦创建了所有状态和/或你想要后退,我需要进入相同的状态,而不仅仅是新状态.我怎样才能做到这一点？有没有更好的方法来做到这一点？

我知道使用1D数组时的动态分配,但是如何在使用2D数组时完成？

myKernel<<<blocks, threads,sizeofSharedMemoryinBytes>>>();
         ....

__global__ void myKernerl(){
 __shared__ float sData[][];
     .....
}

假设我要分配2D共享内存数组:

__shared__ float sData[32][32];

怎么能动态完成？将会:

myKernel<<< blocks, threads, sizeof(float)*32*32 >>>();

我想将double数组映射到现有的MatrixXd结构.到目前为止,我已经设法将Eigen矩阵映射到一个简单的数组,但我找不到回来的方法.

void foo(MatrixXd matrix, int n){

 double arrayd = new double[n*n];
 // map the input matrix to an array
 Map<MatrixXd>(arrayd, n, n) = matrix;  

  //do something with the array 
             .......
// map array back to the existing matrix

}

我有一个较低的三角形MatrixXd,我想将其较低的值复制到上面,因为它将成为一个对称矩阵.我该怎么做？

到目前为止我已经完成了:

 MatrixXd m(n,n); 
 .....
 //do something with m
 for(j=0; j < n; j++)
       {
         for(i=0; i<j; i++)
           {
             m(i,j) = m(j,i);

           }
       }

有最快的方法吗？我在考虑一些能够将下三角矩阵"复制"到鞋面的内部方法.说我有这个矩阵,我们称之为m:

1 2 3
4 5 6
7 8 9

我需要获得的m是:

1 4 7
4 5 8
7 8 9

我也知道你可以让矩阵的上部或下部做一些事情:

MatrixXd m1(n,n);
 m1 = m.triangularView<Eigen::Upper>();
cout << m1 <<endl;

1 2 3
0 5 6
0 0 9

但我还不能得到我想要的东西......

我知道这已经讨论过,并且有多个答案.例如,请参阅if和switch语句的函数数组的性能,但是我想得到一些其他的想法.

我有一个带有大量switch声明的函数.这是26 case,每个都有"左"或"右"选项.此函数根据两个给定参数(plane和direction)返回指针:

double* getPointer(int plane, int direction) {
  switch (plane)
  {
  case 0:
    if (direction == 0)
      return  p_YZ_L; // Left
    else if (dir == 1)
      return p_YZ_R;  //Right
    else {
      return 0;
    }

    break;
    ...
  case 25:
    ...
  }
}

同

planes -> [0-25]
direction -> [0,1] 

我一直在考虑一系列功能,但这也可能很乏味,我不确定它是否是最好的选择.我还不清楚如何正确地做到这一点.有任何想法吗？

我试图了解可以在源代码中完成哪些缓存或其他优化以更快地获得此循环.我认为它是相当缓存友好的,但是,是否有任何专家可以挤出更多性能调整此代码？

DO K = 1, NZ 
    DO J = 1, NY
        DO I = 1, NX

             SIDEBACK  = STEN(I-1,J-1,K-1) + STEN(I-1,J,K-1) + STEN(I-1,J+1,K-1) + &
                         STEN(I  ,J-1,K-1) + STEN(I  ,J,K-1) + STEN(I  ,J+1,K-1) + &
                         STEN(I+1,J-1,K-1) + STEN(I+1,J,K-1) + STEN(I+1,J+1,K-1) 

             SIDEOWN   = STEN(I-1,J-1,K)   + STEN(I-1,J,K)   + STEN(I-1,J+1,K) + &
                         STEN(I  ,J-1,K)   + STEN(I  ,J,K)   + STEN(I  ,J+1,K) + &
                         STEN(I+1,J-1,K)   + STEN(I+1,J,K)   + STEN(I+1,J+1,K)

             SIDEFRONT = STEN(I-1,J-1,K+1) + STEN(I-1,J,K+1) + STEN(I-1,J+1,K+1) + &
                         STEN(I  ,J-1,K+1) + STEN(I  ,J,K+1) + STEN(I …