二维粒子相互作用的 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代码 -> 汇编]代码 void node::Check( data & _data1, vector& _data2) { -> push ebp -> mov ebp,esp ->
c# - 在当前表单(代码)的上下文中从字符串动态运行 C# 代码
我需要在当前表单(代码)的上下文中运行文本文件中的代码。其中一项要求是让代码创建新控件并将其添加到当前窗体。例如，在Form1.cs中: using System.Windows.Forms; ..
c# - c++代码(malloc方法)到c#代码
我有此 C++ 代码并将其转换为 C# (.net Framework 4) 代码。有没有人给我一些关于 malloc、free 和 sprintf 方法的提示？ int monate = ee; d
C 代码，简单的 Web 服务器(代码 OK)
我的网络服务器代码有问题 #include #include #include #include #include #include #include int
html - 将特定列表元素置于斜体的 CSS 代码(不更改 html 代码)
给定以下 html 代码，将列表中的第三个元素(即“美丽”一词)以斜体显示的 CSS 代码是什么？当然，我可以给这个元素一个 id 或一个 class，但 html 代码必须保持不变。谢谢
javascript - 是否有一些库可用于 IQR 代码(不是 QR 代码)？
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。我们不允许提问寻求书籍、工具、软件库等的推荐。您可以编辑问题，以便用事实和引用来回答。关闭 7 年前。
macros - 在 Inno Setup [代码] 部分将宏扩展为 Pascal 代码
我试图制作一个宏来避免重复代码和注释。我试过这个: #define GrowOnPage(any Page, any Component) Component.Width := Page.Surfa
c# - 我正在尝试将我的旧 c++ 代码 "translate"转换为 c# 代码
我正在尝试将我的旧 C++ 代码“翻译”成头条新闻所暗示的 C# 代码。问题是我是 C# 中的新手，并不是所有的东西都像 C++ 中那样。在 C++ 中这些解决方案运行良好，但在 C# 中只是不能。我
r - 让 Visual Studio 代码(自动)格式化 R 代码
在 Windows 10 上工作，R 语言的格式化程序似乎没有在 Visual Studio Code 中完成它的工作。我试过R support for Visual Studio Code和 R-T
dynamic - 是否可以在 Python 脚本中生成和执行 Python 代码？ [动态 Python 代码]
我正在处理一些报告(计数)，我必须获取不同参数的计数。非常简单但乏味。一个参数的示例查询: qCountsEmployee = ( "select count(*) from %s wher
ios - 随机和偶然的网络错误(NSURLErrorDomain 代码=-1001 和 NSURLErrorDomain 代码=-1005)
最近几天我尝试从 d00m 调试网络错误。我开始用尽想法/线索，我希望其他 SO 用户拥有可能有用的宝贵经验。我希望能够提供所有相关信息，但我个人无法控制服务器环境。整个事情始于用户注意到我们应用程
javascript - visual studio 代码 intellisense 不适用于 dojo amd 代码
我有一个 app.js 文件，其中包含如下 dojo amd 模式代码: require(["dojo/dom", ..], function(dom){ dom.byId('someId').i
cuda - 'code=sm_X' 是否仅嵌入二进制(cubin)代码，或 PTX 代码，或两者？
我对“-gencode”语句中的“code=sm_X”选项有点困惑。一个例子:NVCC 编译器选项有什么作用 -gencode arch=compute_13,code=sm_13 嵌入库中？只有
javascript - 在 Javascript 下拉列表中添加 HTML 代码，Javascript 不评估 HTML 代码
我为我的表格使用 X-editable 框架。但是我有一些问题。 $(document).ready(function() { $('.access').editable({
python - 在 linux 中运行 flask/python 代码？基本 flask 代码
我一直在通过本教程学习 flask/python http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-wo
vim - G 代码 M 代码 VI 和 EMACS 的 CNC 语法
我想将 Vim 和 EMACS 用于 CNC、G 代码和 M 代码。 Vim 或 EMACS 是否有任何语法或模式来处理这种类型的代码？最佳答案一些快速搜索使我找到了 this vim 和 thi
iphone - 寻找关于将 Pre-Storyboard 代码 (XCode4) 移动到 Storyboard 代码 (XCode5) 的教程
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。想改进这个问题？更新问题，使其成为 on-topic对于堆栈溢出。 7年前关闭。 Improve this
vim - 如何让 Vim 理解 *.md 文件包含 Markdown 代码，而不是 Modula-2 代码？
这个问题在这里已经有了答案: Enabling markdown highlighting in Vim (5 个回答) 6年前关闭。当我在 Vim 中编辑包含 Markdown 代码的 READM
ios - 错误域=AVFoundationErrorDomain 代码=-11800 "The operation could not be completed"{错误域=NSOSStatusErrorDomain 代码=-16976 "(null)"}
我正在 Swift3 iOS 中开发视频应用程序。基本上我必须将视频 Assets 和音频与淡入淡出效果合并为一个并将其保存到 iPhone 画廊。为此，我使用以下方法: private func d
jenkins - 无法通过 Jenkins 管道作业的 jenkinsfile 中的 Groovy 代码(或 java 代码)创建文件
pipeline { agent any stages { stage('Build') { steps { e

行者123

个人简介

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

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

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