Skip to content
This repository has been archived by the owner on Jan 27, 2021. It is now read-only.

Latest commit

 

History

History
157 lines (114 loc) · 7.78 KB

chapter6-5-chinese.md

File metadata and controls

157 lines (114 loc) · 7.78 KB

使用ASCII字符曼德尔布罗特集合

1975年,数学家贝诺曼德尔布罗特(Benoit Mandelbrot)创造了一个术语——分形。分形是一个数学图像或者集合,这个术语中包含了很多有趣的数学特性,不过最后看起来分形更像是艺术品。分形图像看起来是无限重复的缩小。其中最为众人所知的分形是曼德尔布罗特(Mandelbrot)集合,其集合看起来就像下图一样:

曼德尔布罗特集合可以通过迭代下面的等式得到:

zc变量都是复数。曼德尔布罗特集合包含等式所覆盖所有让方程收敛的c值,也就是海报彩色的部分。有些值收敛的早,有些值收敛的晚,这里用不同的颜色对这些值进行描述,所以我们能在海报中看到各种不同的颜色。对于那些不收敛的值,我们则直接将其所在区域直接涂黑。

使用STL的std::complex类,且不使用循环来实现上面的等式。这并不是炫技,只是为了让大家更容易理解STL相关特性的使用方式。

How to do it...

本节,我们将打印类似墙上海报的图,不过是使用ASCII字符将图像打印在终端上:

  1. 包含必要的头文件并声明所使用的命名空间:

    #include <iostream>
    #include <algorithm>
    #include <iterator>
    #include <complex>
    #include <numeric>
    #include <vector>
    
    using namespace std;
  2. 曼德尔布罗特集合和之前的等式,都是对复数进行操作。所以,我们需要使用类型别名,使用cmplx来代表std::complex,并特化为double类型:

      using cmplx = complex<double>;
  3. 我们将使用大约20行的代码来完成一个ASCII组成的曼德尔布罗特集合图像,不过我们会将逻辑逐步实现,最后将所有结果进行组合。第一步就是实现一个函数,用于将整型坐标缩放为浮点坐标。这也就是我们如何在屏幕上特定的位置上打印相应的字符。我们想要的是曼德尔布罗特集合中复数的坐标,就需要实现一个函数,用于将对应的坐标转换成相应的几何图形。用一个Lambda表达式来构建这些变量,并将其返回。该函数能将int类型的函数转换成一个double类型的函数:

    static auto scaler(int min_from, int max_from,
    double min_to, double max_to)
    {
        const int w_from {max_from - min_from};
        const double w_to {max_to - min_to};
        const int mid_from {(max_from - min_from) / 2 + min_from};
        const double mid_to {(max_to - min_to) / 2.0 + min_to};
        
        return [=] (int from) {
       		return double(from - mid_from) / w_from * w_to + mid_to;
        };
    }
  4. 现在需要在一个维度上进行坐标变换,不过曼德尔布罗特集合使用的是二维坐标系。为了能将(x, y)坐标系统转换成另一个,我们需要将x-scalery-scaler相结合,并且构建一个cmplx实例作为输出:

    template <typename A, typename B>
    static auto scaled_cmplx(A scaler_x, B scaler_y)
    {
        return [=](int x, int y) {
        	return cmplx{scaler_x(x), scaler_y(y)};
        };
    }
  5. 将坐标转换到正确的维度上后,就可以来实现曼德尔布罗特方程。现在不管怎么打印输出,一心只关注于实现方程即可。循环中,对z进行平方,然后加上c,知道abs的值小于2。对于一些坐标来说,其值永远不可能比2小,所以当循环次数达到max_iterations时,我们就决定放弃。最后,将会返回那些abs值收敛的迭代次数:

    static auto mandelbrot_iterations(cmplx c)
    {
        cmplx z {};
        size_t iterations {0};
        const size_t max_iterations {1000};
        while (abs(z) < 2 && iterations < max_iterations) {
            ++iterations;
            z = pow(z, 2) + c;
        }
        return iterations;
    }
  6. 那么现在我们就来实现主函数。在主函数中我们会定义缩放函数对象scale,用于对坐标值进行多维变换:

    int main()
    {
        const size_t w {100};
        const size_t h {40};
        
        auto scale (scaled_cmplx(
            scaler(0, w, -2.0, 1.0),
            scaler(0, h, -1.0, 1.0)
        ));
  7. 为了可以在一维上迭代器整个图形,需要完成另一个转换函数,用于将二维图像进行降维操作。其会根据我们所设置的字符宽度进行计算。其会将一维上的长度进行折断,然后进行多行显示,通过使用scale函数对坐标进行变换,然后返回复数坐标:

    	auto i_to_xy ([=](int i) { return scale(i % w, i / w); });
  8. 我们将图像的二维坐标(int,int类型)转换为一维坐标(int类型),再将坐标转换成曼德尔布罗特结合坐标(cmplx类型)。让我们将所有功能放入一个函数,我们将使用一组调用链:

    	auto to_iteration_count ([=](int i) {
    		return mandelbrot_iterations(i_to_xy(i));
    	});
  9. 现在我们可以来设置所有数据。假设我们的结果ASCII图像的字符宽度为w,高度为h。这样就能将结果存储在一个长度为w * h数组中。我们使用std::iota将数值范围进行填充。这些数字可以用来作为转换的输入源 ,我们将变换过程包装在to_iteration_count中:

        vector<int> v (w * h);
        iota(begin(v), end(v), 0);
        transform(begin(v), end(v), begin(v), to_iteration_count);
  10. 现在有一个v数组,其使用一维坐标进行初始化,不过后来会被曼德尔布罗特迭代计数所覆盖。因此,我们就可以对图像进行打印。可以将终端窗口设置为w个字符宽度,这样我们就不需要打印换行符。不过,可能会有对std::accumulate有一种创造性的误用。std::accumulate使用二元函数对处理范围进行缩小。我们可以对其提供一个二元函数,其能接受一个输出迭代器(并且我们将在下一步进行终端打印),并使用范围内的单个值进行计算。如果相应值的迭代次数大于50次时,我们会打印*字符到屏幕上。否则,会打印空字符在屏幕上。在每行结束时(因为计数器变量n可被W均匀地分割),我们会打印一个换行符:

        auto binfunc ([w, n{0}] (auto output_it, int x) mutable {
        	*++output_it = (x > 50 ? '*' : ' ');
        	if (++n % w == 0) { ++output_it = '\n'; }
        	return output_it;
        });
  11. 通过对输入范围使用std::accumulate,我们将二元打印函数和ostream_iterator相结合,我们需要在屏幕上刷新计算出的曼德尔布罗特集合:

    	accumulate(begin(v), end(v), ostream_iterator<char>{cout},
    			  binfunc);
    }
  12. 编译并运行程序,就可以看到如下的输出,其看起来和墙上的海报很像吧!

How it works...

整个计算过程都使用std::transform对一维数组进行处理:

vector<int> v (w * h);
iota(begin(v), end(v), 0);
transform(begin(v), end(v), begin(v), to_iteration_count);

所以,会发生什么呢?我们为什么要这么做?to_iteration_count函数是基于从i_to_xy开始的调用链,从scalemandelbrot_iterations。下面的图像就能展示我们的转换步骤:

这样,我们就可以使用一维数组作为输入,并且获得曼德尔布罗特方程的迭代次数(使用一维坐标表示的二维坐标上的值)。三个互不相关的转换是件好事。这样代码就可以独立的进行测试,这样就不用互相牵制了。同样,这样更容易进行正确性测试,并寻找并修复bug。