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

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

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

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

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

How to do it...

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

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

#include <iostream>
#include <algorithm>
#include <iterator>
#include <complex>
#include <numeric>
#include <vector>

using namespace std;

曼德尔布罗特集合和之前的等式，都是对复数进行操作。所以，我们需要使用类型别名，使用cmplx来代表std::complex，并特化为double类型：
```
   using cmplx = complex<double>;
```
我们将使用大约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;
    };
}
```
现在需要在一个维度上进行坐标变换，不过曼德尔布罗特集合使用的是二维坐标系。为了能将(x, y)坐标系统转换成另一个，我们需要将x-scaler和y-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)};
    };
}
```
将坐标转换到正确的维度上后，就可以来实现曼德尔布罗特方程。现在不管怎么打印输出，一心只关注于实现方程即可。循环中，对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;
}
```

那么现在我们就来实现主函数。在主函数中我们会定义缩放函数对象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)
    ));

为了可以在一维上迭代器整个图形，需要完成另一个转换函数，用于将二维图像进行降维操作。其会根据我们所设置的字符宽度进行计算。其会将一维上的长度进行折断，然后进行多行显示，通过使用scale函数对坐标进行变换，然后返回复数坐标：
```
    auto i_to_xy ([=](int i) { return scale(i % w, i / w); });
```
我们将图像的二维坐标(int，int类型)转换为一维坐标(int类型)，再将坐标转换成曼德尔布罗特结合坐标(cmplx类型)。让我们将所有功能放入一个函数，我们将使用一组调用链：
```
    auto to_iteration_count ([=](int i) {
        return mandelbrot_iterations(i_to_xy(i));
    });
```
现在我们可以来设置所有数据。假设我们的结果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);
```
现在有一个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;
    });
```
通过对输入范围使用std::accumulate，我们将二元打印函数和ostream_iterator相结合，我们需要在屏幕上刷新计算出的曼德尔布罗特集合：
```
    accumulate(begin(v), end(v), ostream_iterator<char>{cout},
              binfunc);
}
```
编译并运行程序，就可以看到如下的输出，其看起来和墙上的海报很像吧！

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开始的调用链，从scale到mandelbrot_iterations。下面的图像就能展示我们的转换步骤：

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

Previous计算两个vector的误差和 Next实现分割算法

Last updated 3 years ago