Python 复数与分形

我正在尝试将这里的代码改编成C，但遇到了一些问题。我使用的是C99的复杂类型

我基本上已经尝试了几种不同的方法，但都不起作用。在每一个像素上，它每次都会进行最大迭代，因此图像显示为纯色

在C语言中，类型的工作方式是否有一些根本性的错误，看起来应该是这样的，我非常准确地重建了算法

    //newt.c

#include <stdio.h>
#include <stdlib.h> 
#include <complex.h>
#include <float.h>
#include <math.h> 

complex f(complex z); 


const int WIDTH = 512, HEIGHT = 512; 

const double SCALED_X_MAX = 1.0;
const double SCALED_X_MIN = -1.0;
const double SCALED_Y_MAX = 1.0;
const double SCALED_Y_MIN = -1.0;



const int MAX_ITERATIONS = 20;
const int EPSILON = 1e-3;

int main(int argc, char **argv) { 
    const double SCALED_WIDTH = SCALED_X_MAX - SCALED_X_MIN ;
    const double SCALED_HEIGHT = SCALED_Y_MAX - SCALED_Y_MIN ; 

    FILE * image = fopen("newton.ppm", "w") ; 
    fprintf(image, "P3\n");
    fprintf(image, "%d %d\n" , WIDTH , HEIGHT ) ; 
    fprintf(image, "%d\n", 255) ; 
    for ( int y = 0 ; y < HEIGHT ; ++y) { 
        double zy = y * (SCALED_HEIGHT)/(HEIGHT-1) + SCALED_Y_MIN;
        for ( int x = 0 ; x < WIDTH ; ++x ) { 
            double zx = x * (SCALED_WIDTH)/(WIDTH-1) + SCALED_X_MIN; 
            complex z = zx + zy*I;
            int iteration = 0;
            while(iteration < MAX_ITERATIONS ) { 
//                complex h=sqrt(DBL_EPSILON) + sqrt(DBL_EPSILON)*I;
                double h=1e-6;
/*
                complex zph = z + h;
                complex dz = zph - z;
                complex slope = (f(zph) - f(z))/dz; 
*/              
                complex volatile dz = (f(z + (h+h*I))  - f(z)) / (h+I*h) ;
                complex z0 = z - f(z) / dz; 
                //fprintf(stdout,"%f \n", cabs(z0 - z ));
                if ( cabs(z0 - z) < EPSILON){
                    break; 
                }
                z = z0;
                iteration++;
            }
            if (iteration != MAX_ITERATIONS) fprintf(stdout, "%d " , iteration ); 
            fprintf(image,"%3d %3d %3d ", iteration % 4 * 64 , 
                                       iteration % 8 * 32 , 
                                       iteration % 16 * 16);
        }
       fprintf(image, "\n") ; 
    }
    fclose(image) ; 

    exit(0); 

}
complex f(complex z ) { 
    return cpow(z,3)-1.0 ;
}

//newt.c
#包括
#包括
#包括
#包括
#包括
复f（复z）；
常数int宽度=512，高度=512；
常数双标度_X_MAX=1.0；
常数双标度_X_MIN=-1.0；
常数双刻度_Y_MAX=1.0；
常数双标度_Y_MIN=-1.0；
const int MAX_迭代次数=20；
常数intε=1e-3；
intmain（intargc，字符**argv）{
常数双刻度宽度=刻度宽度X最大值-刻度宽度X最小值；
常数双刻度高度=刻度高度最大值-刻度高度最小值；
文件*image=fopen（“newton.ppm”，“w”）；
fprintf（图像，“P3\n”）；
fprintf（图像，“%d%d\n”，宽度和高度）；
fprintf（图像，“%d\n”，255）；
对于（int y=0；y

在检查了复杂的数学之后，没有发现任何问题，我注意到您的错误只是因为行中的整数除法

zy = y * (SCALED_HEIGHT)/(HEIGHT-1) + SCALED_Y_MIN;

const int EPSILON = 1e-3;

zx也是如此。因为（SCALED_HEIGHT）和（HEIGHT-1）都是整数，所以不能得到所需的浮点结果。尝试使用：

zy = y * SCALED_HEIGHT * 1.0/(HEIGHT-1) + SCALED_Y_MIN;

zx也是如此

编辑：对不起，上面的内容有误。您的缩放高度实际上是两倍，因此上面的值实际上是正常的。真正的问题就在这条线上

zy = y * (SCALED_HEIGHT)/(HEIGHT-1) + SCALED_Y_MIN;

const int EPSILON = 1e-3;

---

这实际上总是返回零，因为它是一个整数。您需要将EPSILON设置为浮点类型。

您可以将中间结果与Python版本进行比较，找出它们的偏差。是的，我一分钟前注意到了这一点，并更正了它。谢谢。：）好的，很好！您发现了实际的bug:）