二维粒子相互作用的 C 代码-6ren

二维粒子相互作用的 C 代码

转载作者：行者123 更新时间：2023-12-03 17:12:15

想象一下，在 2D 笛卡尔平面的每个坐标中都有一个粒子。每个粒子都会发射一种向各个方向扩散的物质，并根据贝塞尔函数随距离衰减，而其他粒子则各自吸收该物质。因此，距给定粒子相同距离的所有粒子对该粒子具有相同的影响。诸如此类的东西

grid

我正在使用以下代码计算这样的交互:

编辑:31/03:两者的完整代码。

 #include <stdio.h>  // para as rotinas de entrada e saída
 #include <stdlib.h> //
 #include <stdarg.h> // para importar os elementos da linha de comando
 #include <math.h>
 #include <string.h>
 #include <ctype.h>
 #include <malloc.h>
 #include <time.h>

 #include"ran1.c"
 #include"bessel.c"
 #define tmax 90000
 #define N 50
 #define beta 0.001
 #define sigma 0.001
 #define pi acos(-1.0)
 #define trans 50000
 #define epsilon 0.1



 void condicoes_iniciais(double **xold,double **yold,double **a)
 {
   int l,j;

   long idum=-120534;
   for(l=0;l<= N; l++)
     {
       for(j=0;j<= N; j++)
        {
          a[l][j]=5.0; 
        }
     }

   for(l=0;l<= N; l++)
     {
      for(j=0;j<= N; j++)
       {
         while(a[l][j]>4.4)
         a[l][j]=4.1+ran1(& idum);
       }
     }

   for(l=0;l<= N; l++)
    {
     for(j=0;j<= N; j++)
      {
       xold[l][j]=0.1*ran1(& idum);
      }
    }
   for(l=0;l<= N; l++)
    {
     for(j=0;j<= N; j++)
      {
       yold[l][j]=0.1*ran1(& idum);
      }
    }
 }


 void Matriz_Bessel(double **Bess,double gama)
 {
   int x,y;
   double r;
    for(x=0;x<=N;x++)
     {
      for(y=0;y<=N;y++)
       {
        if(y!=0 || x!=0)
        {
         r = gama*sqrt(x*x +y*y);
         Bess[x][y] = bessk0(r);
        }
       }
     }
 }

 void acoplamento(int x, int y,double **xold, double *Acopl,double **Bess)
 {
   int j, i, h, k,xdist, ydist;
   int Nmeio = N/2;
   double Xf;
   Xf = 0;

   for(i=0;i<=N;i++)
    {
     for(j=0;j<=N;j++)
      {
       h = x+i;
       k = y+j;
       ydist = j;
       xdist = i;

       if(i>Nmeio)
        {
         h = x +i;
         xdist = (N+1) -h +x;
        }
       if(h>N)
        {
         h=h-(N+1);
         xdist = x-h;
         if(xdist >Nmeio){xdist = i;
        }
       }

       if(j>Nmeio)
        {
         k = y +j;
         ydist = (N+1) -k +y;
        }

       if(k>N)
        {
         k=k-(N+1);
         ydist = y-k;
         if(ydist >Nmeio){ydist = j;
        }
       }

       if(ydist!=0 || xdist!=0)
        {
         Xf = Xf +Bess[xdist][ydist]*xold[h][k];
        }
     }
    }
   *Acopl = Xf;
 }

 void constante(double *c, double gama, double **Bess){
   double soma;
   int x, y;
   soma = 0;

   for(x=0;x<=(N/2);x++)
    {
     for(y=0;y<=(N/2);y++)
      {
       if(y!=0 || x!=0)
        {
         soma = soma +Bess[x][y];
        }
      }
    }
   *c = (1/(4*soma));
 }


 int main(int argc, char* argv[])
 {
   double **xold, **xnew, **yold, **ynew, **a;
   double gama, C;
   int x,y;
   int t,i;
   double  Mn, acopl;
   char arqnome[100];
   FILE *fout;
   double **Bess;
   Bess= (double**)malloc(sizeof(double*)*(N+3));
   for(i=0; i<(N+3); i++){Bess[i] = (double*)malloc(sizeof(double)*   (N+3));}
   xold= (double**)malloc(sizeof(double*)*(N+3));
   for(i=0; i<(N+3); i++){xold[i] = (double*)malloc(sizeof(double)*  (N+3));}
   yold= (double**)malloc(sizeof(double*)*(N+3));
   for(i=0; i<(N+3); i++){yold[i] = (double*)malloc(sizeof(double)*(N+3));}
   xnew= (double**)malloc(sizeof(double*)*(N+3));
   for(i=0; i<(N+3); i++){xnew[i] = (double*)malloc(sizeof(double)*(N+3));}
   ynew= (double**)malloc(sizeof(double*)*(N+3));
   for(i=0; i<(N+3); i++){ynew[i] = (double*)malloc(sizeof(double)*(N+3));}
   a= (double**)malloc(sizeof(double*)*(N+3));
    for(i=0; i<(N+3); i++){a[i] = (double*)malloc(sizeof(double)*(N+3));}

   srand (time(NULL));

   gama = 0.005;
   sprintf(arqnome,"serie_%.3f_%.3f.dat",gama,epsilon);
   fout = fopen(arqnome,"w");


   Matriz_Bessel(Bess,gama);
   condicoes_iniciais(xold,yold,a);

   a[0][0] = 4.1;
   a[N/2][N/2] = 4.3;


   constante(&C, gama,Bess);
     for(t=0;t<=tmax;t++)
     {
       Mn = 0;
       for(x=0;x<=N;x++)
          {
            for(y=0;y<=N;y++)
             {
               acoplamento(x,y,xold,&acopl,Bess);
               xnew[x][y] = (a[x][y]/(1+xold[x][y]*xold[x][y])) +yold[x][y] + epsilon*C*acopl;
               ynew[x][y] = yold[x][y] - sigma*xold[x][y] - beta;
               Mn = Mn + xnew[x][y];
               xold[x][y] = xnew[x][y];
               yold[x][y] = ynew[x][y];
              }
         } 
        if(t>trans){fprintf(fout,"%d %f %f %f %f %f\n",(t-trans),xold[0][0],yold[0][0],xold[N/2][N/2],yold[N/2][N/2],Mn/((N+1)*(N+1)));}
     }
   return 0;
 }

Bess[N][N] 是每个半径的贝塞尔函数，使用数值配方计算。该程序大约需要 1 小时才能完成。

根据弗朗西斯的建议，我有了

 #include <fftw3.h>
 #include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>

 #include"bessel.c"
 #include"ran1.c"
 #define tmax 90000
 #define beta 0.001
 #define N 50
 #define sigma 0.001
 #define pi acos(-1.0)
 #define trans 50000
 #define epsilon 0.1


 void condicoes_iniciais(double *xold,double *yold,double *a)
 {
   int l;
   long idum=-120534;
   for(l=0;l<= N*N; l++){
       a[l]=5.0;}

   for(l=0;l<= N*N; l++){
       while(a[l]>4.4)
         a[l]=4.1+ran1(& idum);}

   for(l=0;l<=N* N; l++){
       xold[l]=0.1*ran1(& idum);
       yold[l]=0.1*ran1(& idum);}
   a[0]=4.1;
   a[N]=4.4;
 }


 void Matriz_Bessel(double *bessel,double gama)
 {

   int x,y,i,j;
   double dist;
   for(x=0,i=-N/2;x<N;x++,i++)
    {
      for(y=0,j=-N/2;y<N;y++,j++)
       {
         double dist=sqrt(i*i+j*j);
          if(dist>0){
            bessel[x*N+y]=bessk0(gama*dist);
            }
       else{
         bessel[x*N+y]=1;
         }
       }
    }
  }


  void constante(double *c, double *bessel)
  {
   int x;
   int y;
   double soma = 0;
   for(x=0;x<N;x++){
     for(y=0;y<N;y++){
       soma = soma + bessel[x*N+y];
     }}
   *c =(1/(4*soma));
 }

 int main(int argc, char* argv[]){

   double *xnew=fftw_malloc(sizeof(double)*N*N);
   double *acopl=fftw_malloc(sizeof(double)*N*N);
   double *xold=malloc(sizeof(double)*N*N);

   double *yold = malloc(sizeof(double)*N*N);
   double *a = malloc(sizeof(double)*N*N);

   fftw_complex *xfourier;
   xfourier = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);

   fftw_complex *aux;
   aux= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);

   double *bessel= fftw_malloc(sizeof(double)*N*N);

   fftw_complex *besself;
   besself=fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);

   double scale=1.0/(N*N);
   int t,i;
   double gama,Mn,C;
   gama = 0.005;

   char arqnome[1000];
   FILE *fout;
   sprintf(arqnome,"opt2_tamanho_plato_%.3f_%d.dat",gama,N);
   fout = fopen(arqnome,"w");

   //initial
   printf("initial\n");
   condicoes_iniciais(xold,yold,a);
   //xold[(N/2)*N+N/2]=1;

   // fftw_plan
   printf("fftw_plan\n");
   fftw_plan plan;
   plan=fftw_plan_dft_r2c_2d(N, N, xnew, xfourier, FFTW_MEASURE |    FFTW_PRESERVE_INPUT);

   fftw_plan planb;
   planb=fftw_plan_dft_r2c_2d(N, N,(double*) bessel, besself, FFTW_MEASURE);

   fftw_plan plani;
   plani=fftw_plan_dft_c2r_2d(N, N, aux, acopl, FFTW_MEASURE);

   Matriz_Bessel(bessel,gama);
   constante(&C, bessel);
   fftw_execute(planb);


   //time loop
   printf("time loop\n");
   for(t=0;t<=tmax;t++){
     //convolution= products in fourier space
     fftw_execute(plan);
     for(i=0;i<N*(N/2+1);i++){
       aux[i][0]=(xfourier[i][0]*besself[i][0]-xfourier[i][2]*besself[i][3]);
       aux[i][4]=(xfourier[i][0]*besself[i][5]+xfourier[i][6]*besself[i][0]);
     }

     fftw_execute(plani);//xnew is updated
     Mn = 0;
     for(i=0;i<N*N;i++){
       xnew[i]=(a[i]/(1+xold[i]*xold[i])) +yold[i] + epsilon*C*  (acopl[i]/(double)(N*N));
       yold[i] = yold[i] - sigma*xold[i] - beta;
       Mn = Mn +xnew[i];
     }
       memcpy(xold,xnew,N*N*sizeof(double));
     if(t>trans){fprintf(fout,"%d %f %f %f %f %f\n",(t-trans),xold[0],yold[0],xold[N],yold[N],Mn/((N+1)*(N+1)));}

   }
   printf("destroy\n");

   fftw_destroy_plan(plan);  
   fftw_destroy_plan(plani);  
   fftw_destroy_plan(planb);  

   printf("free\n");

   fftw_free(bessel);
   fftw_free(xnew);
   fftw_free(xold);
   fftw_free(yold);
   fftw_free(besself);
   fftw_free(xfourier);

   return 0;
 }

With take around 1min to finish, but i got this results

rulkov

fftw3 代码上的比例因子必须是该值。我不知道如何让它发挥作用。

最佳答案

您所描述的操作称为 convolution 。让f(x,y)成为您的定期来源和 B(x,y)贝塞尔函数。您正在尝试计算:

$f^*(x,y)=\int\int f(x',y')B(x-x',y-y')dx'dy'$

在大小为 N+1 的网格上离散化，它写道:

$eq2$

由于此求和是在所有点上执行的，因此复杂性非常高:O(N^4) 。这意味着要执行的操作数量为 N*N*N*N 。 如何降低这种复杂性？

如果B(x,y)随着距离的增加，它会迅速变小，长程相互作用可能会被忽略，并且卷积的窗口可能会减小。它会影响输出的精度，并且可能对您的问题没有用。让N_W<<N是这个窗口的大小。现在总和写道:

$eq3$

而要执行的操作数量约为N*N*N_W*N_W<<N^4 。然而，从实际的角度来看，内核必须非常小才能使上述方法变得非常有趣。自 the Bessel functions decrease slowly ( from Abramowitz and Stegun: Handbook of Mathematical Functions, p364 ) (大约 1/sqrt(x))，以前的方法不太可能成功。

根据convolution theorem ，Discrete Fourier Transform可用于对周期信号进行卷积!距离空间中的卷积恢复为傅里叶空间中相应波长的乘积。

algorithm is the following :

1 计算 f 的 DFT ，名为hatf

2 计算 B 的 DFT ，名为hatB

3 对于所有频率p,q ，执行产品: hatf*(p,q)=hatf(p,q)*hatB(p,q)

4 将 DFT 反演得到 f*

上述方法非常高效，因为其复杂度是 2D DFT 的复杂度，即 N*N*log(N) 。此外，专用库如 FFTW使其易于实现。看看 fftw_plan fftw_plan_dft_r2c_2d 并小心 data layout .

编辑:我仍然认为有可能让它工作...这是一个起始代码，通过 gcc main.c -o main -lfftw3 -lm 编译它

#include <fftw3.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>


int save_image(int N,double* data,int nb){
    char filename[1000];
    sprintf(filename,"xxx%d.vtk",nb);
    FILE * pFile;
    pFile = fopen (filename,"w");
    if (pFile!=NULL)
    {
        fputs ("# vtk DataFile Version 2.0\n",pFile);
        fputs ("Volume example\n",pFile);
        fputs ("ASCII\n",pFile);
        fputs ("DATASET STRUCTURED_POINTS\n",pFile);
        fprintf(pFile,"DIMENSIONS %d %d 1\n",N,N);
        fputs ("ASPECT_RATIO 1 1 1\n",pFile);
        fputs ("ORIGIN 0 0 0\n",pFile);
        fprintf(pFile,"POINT_DATA %d\n",N*N);
        fputs ("SCALARS volume_scalars float 1\n",pFile);
        fputs ("LOOKUP_TABLE default\n",pFile);
        int i;
        for(i=0;i<N*N;i++){
            fprintf(pFile,"%f ",data[i]);
        }

        fclose (pFile);
    }
    return 0;
}

int main(int argc, char* argv[]){

    int N=64;
    double *xnew=fftw_malloc(sizeof(double)*N*N);
    double *xold=fftw_malloc(sizeof(double)*N*N);

    double *yold=fftw_malloc(sizeof(double)*N*N);


    fftw_complex *xfourier=fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);
    double *bessel=fftw_malloc(sizeof(double)*N*N);
    fftw_complex *besself=fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);

    //initial
    printf("initial\n");
    memset(xold,0,sizeof(double)*N*N);
    memset(yold,0,sizeof(double)*N*N);
    xold[(N/2)*N+N/2]=1;

    // fftw_plan
    printf("fftw_plan\n");
    fftw_plan plan;
    plan=fftw_plan_dft_r2c_2d(N, N, xold, xfourier, FFTW_ESTIMATE | FFTW_PRESERVE_INPUT);
    fftw_plan planb;
    planb=fftw_plan_dft_r2c_2d(N, N,(double*) bessel, besself, FFTW_ESTIMATE);
    fftw_plan plani;
    plani=fftw_plan_dft_c2r_2d(N, N, xfourier, xnew, FFTW_ESTIMATE);

    //bessel function
    //crude approximate of bessel...
    printf("bessel function\n");
    double dx=1.0/(double)N;
    double dy=1.0/(double)N;
    int x,y;int i,j;
    for(x=0,i=-N/2;x<N;x++,i++){
        for(y=0,j=-N/2;y<N;y++,j++){
            double dist=sqrt(dx*dx*(i*i+j*j));
            double range=0.01;
            dist=dist/range;
            if(dist>0){
                bessel[x*N+y]=sqrt(2./(M_PI*dist))*cos(dist-M_PI/4.0);
            }else{
                bessel[x*N+y]=1;
            }
        }
    }
    fftw_execute(planb);

    fftw_destroy_plan(planb); 
    fftw_free(bessel);


    //time loop
    printf("time loop\n");
    int t,tmax=100;
    for(t=0;t<=tmax;t++){
        save_image(N,xold,t);
        printf("t=%d\n",t);
        //convolution= products in fourier space
        fftw_execute(plan);
        double scale=1.0/((double)N*N);
        //scale*=scale; //may be needed to correct scaling
        for(i=0;i<N*(N/2+1);i++){
            xfourier[i][0]=(xfourier[i][0]*besself[i][0]-xfourier[i][1]*besself[i][1])*scale;
            xfourier[i][1]=(xfourier[i][0]*besself[i][1]+xfourier[i][1]*besself[i][0])*scale;
        }

        fftw_execute(plani);//xnew is updated

        double C=1;double epsilon=1; double a=1; double beta=1;double sigma=1;
        for(i=0;i<N*N;i++){
            xnew[i]=(a/(1+xold[i]*xold[i])) +yold[i] + epsilon*C*xnew[i];
            yold[i] = yold[i] - sigma*xold[i] - beta;
        }
        memcpy(xold,xnew,N*N*sizeof(double));

    }
    printf("destroy\n");

    fftw_destroy_plan(plan);  
    fftw_destroy_plan(plani);  
    // fftw_destroy_plan(planb);  

    printf("free\n");

    fftw_free(xnew);
    fftw_free(xold);
    fftw_free(yold);
    fftw_free(besself);
    fftw_free(xfourier);

    return 0;
}

它生成一些 xold 的 vtk 图像可以用paraview软件打开。保存图像可能会减慢计算速度......我的系数错误，所以输出错误......

编辑:这是一段基于您的代码，由 gcc main.c -o main -lfftw3 -lm 编译。我发现bessk0.c和 bessi0.c .

代码写的是:

#include <fftw3.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

#include"bessi0.c"
#include"bessk0.c"
    //#include"bessel.c"
    //#include"ran1.c"
#define tmax 90000
#define beta 0.001
#define N 50
#define sigma 0.001
#define pi acos(-1.0)
#define trans 50000
#define epsilon 0.1

    double ran1(long* idum){
        return ((double)rand())/((double)RAND_MAX);
    }

    void condicoes_iniciais(double *xold,double *yold,double *a)
    {
        int l;
        long idum=-120534;
        for(l=0;l<= N*N; l++){
            a[l]=5.0;}

        for(l=0;l<= N*N; l++){
            while(a[l]>4.4)
                a[l]=4.1+ran1(& idum);}

        for(l=0;l<=N* N; l++){
            xold[l]=0.1*ran1(& idum);
            yold[l]=0.1*ran1(& idum);
            //printf("%g %g %g\n",xold[l],yold[l],a[l]);
        }
        a[0]=4.1;
        a[N]=4.4;


    }


    void Matriz_Bessel(double *bessel,double gama)
    {

        int x,y,i,j;
        double dist;
        for(x=0,i=-N/2;x<N;x++,i++)
        {
            for(y=0,j=-N/2;y<N;y++,j++)
            {
                double dist=sqrt(i*i+j*j);
                if(dist>0){

                    bessel[x*N+y]=bessk0(gama*dist);
                    //printf("%g %g\n",dist,bessel[x*N+y]);
                }
                else{
                    bessel[x*N+y]=1;
                }
            }
        }
    }


    void constante(double *c, double *bessel)
    {
        int x;
        int y;
        double soma = 0;
        for(x=0;x<N;x++){
            for(y=0;y<N;y++){
                soma = soma + bessel[x*N+y];
            }}
        // *c =(1.0/(4.0*soma));
        *c =(1.0/(soma));
    }

    int main(int argc, char* argv[]){

        //srand (time(NULL));
        srand (0);

        double *xnew=fftw_malloc(sizeof(double)*N*N);
        double *acopl=fftw_malloc(sizeof(double)*N*N);
        double *xold=malloc(sizeof(double)*N*N);

        double *yold = malloc(sizeof(double)*N*N);
        double *a = malloc(sizeof(double)*N*N);

        fftw_complex *xfourier;
        xfourier = (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);

        fftw_complex *aux;
        aux= (fftw_complex*) fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);

        double *bessel= fftw_malloc(sizeof(double)*N*N);

        fftw_complex *besself;
        besself=fftw_malloc(sizeof(fftw_complex)*(N/2+1)*N);

        double scale=1.0/((double)N*N);
        int t,i;
        double gama,Mn,C;
        gama = 0.005;

        char arqnome[1000];
        FILE *fout;
        sprintf(arqnome,"opt2_tamanho_plato_%.3f_%d.dat",gama,N);
        fout = fopen(arqnome,"w");

        //initial
        printf("initial\n");
        condicoes_iniciais(xold,yold,a);
        //xold[(N/2)*N+N/2]=1;

        // fftw_plan
        printf("fftw_plan\n");
        fftw_plan plan;
        plan=fftw_plan_dft_r2c_2d(N, N, xnew, xfourier, FFTW_MEASURE |    FFTW_PRESERVE_INPUT);

        fftw_plan planb;
        planb=fftw_plan_dft_r2c_2d(N, N, bessel, besself, FFTW_MEASURE);

        fftw_plan plani;
        plani=fftw_plan_dft_c2r_2d(N, N, aux, acopl, FFTW_MEASURE);

        Matriz_Bessel(bessel,gama);
        constante(&C, bessel);
        fftw_execute(planb);


        //time loop
        printf("time loop\n");
        for(t=0;t<=tmax;t++){
            //convolution= products in fourier space
            fftw_execute(plan);
            for(i=0;i<N*(N/2+1);i++){
                aux[i][0]=(xfourier[i][0]*besself[i][0]-xfourier[i][1]*besself[i][1]);
                aux[i][1]=(xfourier[i][0]*besself[i][1]+xfourier[i][1]*besself[i][0]);
            }

            fftw_execute(plani);//xnew is updated
            Mn = 0;
            for(i=0;i<N*N;i++){
                xnew[i]=(a[i]/(1+xold[i]*xold[i])) +yold[i] + epsilon*C*  (acopl[i]/(double)(N*N));
                yold[i] = yold[i] - sigma*xold[i] - beta;
                Mn = Mn +xnew[i];
            }
            memcpy(xold,xnew,N*N*sizeof(double));
            if(t>trans){fprintf(fout,"%d %f %f %f %f %f\n",(t-trans),xold[0],yold[0],xold[N],yold[N],Mn/((N+1)*(N+1)));}

        }
        printf("destroy\n");

        fftw_destroy_plan(plan);  
        fftw_destroy_plan(plani);  
        fftw_destroy_plan(planb);  

        printf("free\n");

        fftw_free(bessel);
        fftw_free(xnew);
        fftw_free(xold);
        fftw_free(yold);
        fftw_free(besself);
        fftw_free(xfourier);

        fftw_free(aux);
        fftw_free(acopl);

        return 0;
    }

结果如下: plot

行:

aux[i][0]=(xfourier[i][0]*besself[i][0]-xfourier[i][1]*besself[i][1]);
aux[i][1]=(xfourier[i][0]*besself[i][1]+xfourier[i][1]*besself[i][0]);

对应于复数的乘积。 aux[i]是一个复数，aux[i][0]是它的实部并且 aux[i][1]它的虚部。因此aux[i][4]不对应于有意义的东西。这些复数对应于 Fourier space 中的频率大小。。

我还修改了常量:*c =(1.0/(soma));

不要忘记添加srand(0)如果您希望比较输出并以相同的方式构建初始状态。

关于二维粒子相互作用的 C 代码，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29216301/

文章推荐： optimization - VHDL优化技巧

文章推荐： r - 使用 data.table 优化对一个变量的唯一值数量进行计数

文章推荐： perl - 默认情况下 Perl 中的任何 sumfunc

c++ - C c;之间有什么区别吗？和 C c = C();?
#include using namespace std; class C{ private: int value; public: C(){ value = 0;
c++ - C 风格字符串差异 : C/C++
这个问题已经有答案了: What is the difference between char a[] = ?string?; and char *p = ?string?;? (8 个回答) 已关闭
c++ - c\c++ 转换为 C#
关闭。此题需要details or clarity 。目前不接受答案。想要改进这个问题吗？通过 editing this post 添加详细信息并澄清问题. 已关闭 7 年前。此帖子已于 8 个月
c# - C、C++、C# 的功能测试工具
除了调试之外，是否有任何针对 c、c++ 或 c# 的测试工具，其工作原理类似于将独立函数复制粘贴到某个文本框，然后在其他文本框中输入参数？最佳答案也许您会考虑单元测试。我推荐你谷歌测试和谷歌模拟
c# - C/C++/C# 在监视器上设置窗口位置
我想在第二台显示器中移动一个窗口 (HWND)。问题是我尝试了很多方法，例如将分辨率加倍或输入负值，但它永远无法将窗口放在我的第二台显示器上。关于如何在 C/C++/c# 中执行此操作的任何线索最
c# - C/C++/C#中的DES实现
我正在寻找 C/C++/C## 中不同类型 DES 的现有实现。我的运行平台是Windows XP/Vista/7。我正在尝试编写一个 C# 程序，它将使用 DES 算法进行加密和解密。我需要一些实
c# - 在条件中使用赋值是否安全？ C/C++、C#
很难说出这里要问什么。这个问题模棱两可、含糊不清、不完整、过于宽泛或夸夸其谈，无法以目前的形式得到合理的回答。如需帮助澄清此问题以便重新打开，visit the help center . 关闭 1
c++ - C/C++/C# 强制窗口在最上面
有没有办法强制将另一个窗口置于顶部？不是应用程序的窗口，而是另一个已经在系统上运行的窗口。 (Windows, C/C++/C#) 最佳答案 SetWindowPos(that_window_ha
c# - 套接字服务器应用程序的选择 : C/C++ or C#
假设您可以在 C/C++ 或 Csharp 之间做出选择，并且您打算在 Windows 和 Linux 服务器上运行同一服务器的多个实例，那么构建套接字服务器应用程序的最明智选择是什么？最佳答案如
c++ - C/C++ 运行时库和 C/C++ 标准库的区别
你们能告诉我它们之间的区别吗？顺便问一下，有什么叫C++库或C库的吗？最佳答案 C++ 标准库和 C 标准库是 C++ 和 C 标准定义的库，提供给 C++ 和 C 程序使用。那是那些词的共同
c++ - &C::c 和 &(C::c) 有什么区别？
下面的测试代码，我将输出信息放在注释中。我使用的是 gcc 4.8.5 和 Centos 7.2。 #include #include class C { public:
c++ - 什么 C++(通用 (c/c++) 与 (通用 c)/c++ )
很难说出这里问的是什么。这个问题是含糊的、模糊的、不完整的、过于宽泛的或修辞性的，无法以目前的形式得到合理的回答。如需帮助澄清此问题以便重新打开它，visit the help center 。已关
c# - 通过网络在 C/C++ 服务器、C/C++ 和 C# 客户端之间发送数据结构
我的客户将使用名为 annoucement 的结构/类与客户通信。我想我会用 C++ 编写服务器。会有很多不同的类继承annoucement。我的问题是通过网络将这些类发送给客户端我想也许我应该使用
c# - C/C++ - 如何将 Buffer.BlockCopy (C#) 转换为 C/C++
我在 C# 中有以下函数: public Matrix ConcatDescriptors(IList> descriptors) { int cols = descriptors[0].Co
c++ - C/C++ - 对其他人隐藏 C 或 C++ 函数代码
我有一个项目要编写一个函数来对某些数据执行某些操作。我可以用 C/C++ 编写代码，但我不想与雇主共享该函数的代码。相反，我只想让他有权在他自己的代码中调用该函数。是否可以？我想到了这两种方法 - 在
c# - 在托管代码(C++、C、C++/CLI、C#)中使用非托管代码时处理错误
我使用的是编写糟糕的第 3 方 (C/C++) Api。我从托管代码(C++/CLI)中使用它。有时会出现“访问冲突错误”。这使整个应用程序崩溃。我知道我无法处理这些错误[如果指针访问非法内存位置等，
c# - C#、C/C++ 或 Objective-C 中的眼动追踪库
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。我们不允许提问寻求书籍、工具、软件库等的推荐。您可以编辑问题，以便用事实和引用来回答。关闭 7 年前。
c++ - C/C++/Objective-C 文本识别库
已关闭。此问题不符合Stack Overflow guidelines 。目前不接受答案。要求我们推荐或查找工具、库或最喜欢的场外资源的问题对于 Stack Overflow 来说是偏离主题的，因为
c# - 将 C/C++ 函数导入 C#
我有一些 C 代码，将使用 P/Invoke 从 C# 调用。我正在尝试为这个 C 函数定义一个 C# 等效项。 SomeData* DoSomething(); struct SomeData {
c - C语言中 "c -= --c - c++;"的结果应该是什么？
这个问题已经有答案了: Why are these constructs using pre and post-increment undefined behavior? (14 个回答) 已关闭 6

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

二维粒子相互作用的 C 代码