octave绘制分形几何

Octave 可以使用递归函数来绘制分形几何，例如绘制科赫曲线。以下是一个简单的 Octave 代码，用于绘制科赫曲线。

function koch(n)
  if n == 0
    x = [0, 1];
    y = [0, 0];
    plot(x, y);
  else
    x = [0, 1/3, 1/2, 2/3, 1];
    y = [0, 0, sqrt(3)/6, 0, 0];
    plot(x, y);
    hold on;
    for i = 1:4
      [x_new, y_new] = koch_sub(x(i), x(i+1), y(i), y(i+1));
      plot(x_new, y_new);
    end
    hold off;
  end
end

function [x_new, y_new] = koch_sub(x1, x2, y1, y2)
  x_new = [x1, (2*x1 + x2)/3, (x1 + x2)/2 + (y2 - y1)*sqrt(3)/6, (2*x2 + x1)/3, x2];
  y_new = [y1, (2*y1 + y2)/3, (y1 + y2)/2 - (x2 - x1)*sqrt(3)/6, (2*y2 + y1)/3, y2];
end

调用 `koch(n)` 函数，其中 n 表示科赫曲线的阶数。例如，调用 `koch(3)` 函数，将绘制科赫曲线的第三阶。

相关问题

利用octave绘制其它分形图形-花草树木

### 回答1：
绘制花草树木的分形图形可以使用L-system方法，L-system是一种基于字符串替换的方法，用于生成自相似的形状。以下是使用octave绘制分形花草树木的步骤：

1.定义L-system规则

首先，我们需要定义L-system规则。这里我们使用以下规则：

- A → B[+A][-A]，表示从A开始，向前移动1个单位，转向右侧，绘制B，然后向左转，绘制A的左子代，向右转，绘制A的右子代。
- B → BB，表示将B替换为两个B。

2.生成L-system字符串

接下来，我们使用octave生成指定迭代次数的L-system字符串。例如，我们可以使用以下代码生成迭代2次的字符串：

n = 2;
axiom = 'A';
rules = {'A', 'B[+A][-A]', 'B', 'BB'};
lsystem = axiom;
for i = 1:n
    lsystem = strrep(lsystem, rules{1}, rules{2});
    lsystem = strrep(lsystem, rules{3}, rules{4});
end
disp(lsystem);

输出结果为：`B[+B[+B][-B]][-B[+B][-B]]`

3.解析L-system字符串

接下来，我们需要解析L-system字符串，并根据规则绘制花草树木。我们可以使用以下代码实现：

n = 2;
axiom = 'A';
rules = {'A', 'B[+A][-A]', 'B', 'BB'};
lsystem = axiom;
for i = 1:n
    lsystem = strrep(lsystem, rules{1}, rules{2});
    lsystem = strrep(lsystem, rules{3}, rules{4});
end
disp(lsystem);

angle = 25;
step = 10;
stack = [];
pos = [0, 0];
dir = [0, -1];
for i = 1:length(lsystem)
    switch lsystem(i)
        case 'F'
            pos = pos + step * dir;
            plot([pos(1) pos(1)-step*dir(1)], [pos(2) pos(2)-step*dir(2)], 'k');
        case '+'
            dir = [dir(1)*cosd(angle) - dir(2)*sind(angle), dir(1)*sind(angle) + dir(2)*cosd(angle)];
        case '-'
            dir = [dir(1)*cosd(-angle) - dir(2)*sind(-angle), dir(1)*sind(-angle) + dir(2)*cosd(-angle)];
        case '['
            stack = [stack; pos dir];
        case ']'
            last = stack(end, :);
            pos = last(1:2);
            dir = last(3:4);
            stack = stack(1:end-1, :);
    end
end

这段代码将生成迭代2次的花草树木分形图形，使用plot函数绘制线条。其中，F表示向前移动一定距离，+表示向右转一定角度，-表示向左转一定角度，[表示保存当前位置和方向，]表示回到最近的[位置，并将方向恢复为之前的方向。

4.调整参数

最后，我们可以调整angle和step参数来改变分形图形的形状。例如，我们可以将angle设为30，step设为5，生成迭代3次的花草树木分形图形：

n = 3;
axiom = 'A';
rules = {'A', 'B[+A][-A]', 'B', 'BB'};
lsystem = axiom;
for i = 1:n
    lsystem = strrep(lsystem, rules{1}, rules{2});
    lsystem = strrep(lsystem, rules{3}, rules{4});
end
disp(lsystem);

angle = 30;
step = 5;
stack = [];
pos = [0, 0];
dir = [0, -1];
for i = 1:length(lsystem)
    switch lsystem(i)
        case 'F'
            pos = pos + step * dir;
            plot([pos(1) pos(1)-step*dir(1)], [pos(2) pos(2)-step*dir(2)], 'k');
        case '+'
            dir = [dir(1)*cosd(angle) - dir(2)*sind(angle), dir(1)*sind(angle) + dir(2)*cosd(angle)];
        case '-'
            dir = [dir(1)*cosd(-angle) - dir(2)*sind(-angle), dir(1)*sind(-angle) + dir(2)*cosd(-angle)];
        case '['
            stack = [stack; pos dir];
        case ']'
            last = stack(end, :);
            pos = last(1:2);
            dir = last(3:4);
            stack = stack(1:end-1, :);
    end
end

运行以上代码，将生成迭代3次的花草树木分形图形。

### 回答2：
要利用Octave绘制花草树木的分形图形，可以使用L-系统（L-system）来生成这些形状。L-系统是一种形式语法系统，它可以通过迭代规则生成自相似的结构。

首先，我们需要定义一些规则来生成花草树木的形状。以下是一个例子：

1. 定义“F”为向前移动一定距离的指令
2. 定义“+”为顺时针旋转的指令
3. 定义“-”为逆时针旋转的指令
4. 定义“[”为保存当前状态的指令
5. 定义“]”为恢复到之前保存的状态的指令
6. 定义“X”为删除的指令（即不绘制线段）

接下来，我们可以创建一个递归函数，该函数将根据这些规则以及一些参数绘制出花草树木的形状。以下是一个例子：

function drawTree(length, angle, generations, axiom)
    if generations == 0
        return;
    endif
    
    nextGeneration = '';
    for i = 1:length(axiom)
        currentChar = axiom(i);
        
        if currentChar == 'X'
            nextGeneration = [nextGeneration, currentChar];
        elseif currentChar == 'F'
            line([0, 0], [0, length]);
            translate([0, length]);
        elseif currentChar == '+'
            rotate(angle);
        elseif currentChar == '-'
            rotate(-angle);
        elseif currentChar == '['
            saveState();
        elseif currentChar == ']'
            restoreState();
        endif
    endfor
    
    drawTree(length * 0.6, angle, generations - 1, nextGeneration);
endfunction

通过调用这个函数，我们可以绘制出花草树木的分形图形。例如，以下是一个绘制二叉树的示例：

clf;
hold on;
drawTree(100, pi/4, 9, 'X');

使用这些规则和参数，您可以根据自己的需要绘制出各种不同形状的花草树木分形图。调整绘制函数中的参数以及规则定义，您可以创建出独特的花草树木图形。

### 回答3：
利用Octave绘制花草树木分形图形可以通过递归的方式实现。以下是一种常见的方法：

首先，我们需要确定绘制花草树木所需的参数，如树的高度、分支角度、分支长度和分支的减小比例等。

接下来，我们可以定义一个递归函数，用于在每个分支的末端绘制一个更小分支。该函数可能接受参数，如当前分支的起点坐标、当前分支的角度、当前分支的长度等。

在递归函数中，我们可以绘制当前分支，并计算出下一个分支的起点坐标、角度和长度。然后，我们可以调用递归函数，并将下一个分支的信息作为参数传入，以绘制更小的分支。

我们可以通过迭代调用递归函数，绘制出一个完整的花草树木形状。

在Octave中，我们可以使用plot函数进行绘图。我们可以定义一个函数来实现花草树木的绘制，然后在主程序中调用该函数。

最后，我们可以调整绘图窗口的大小、添加坐标轴和标题等元素，以美化我们的花草树木分形图形。

通过上述步骤，我们可以在Octave中使用递归函数和plot函数来绘制花草树木分形图形。这种方法允许我们根据定义的参数来创建不同形状的花草树木，并在绘图窗口中进行显示。

利用octave程序绘制其它两种分形图形，除了koch曲线、sierpinski三角形

好的，我可以帮你回答这个问题。以下是两个常见的分形图形，你可以用Octave程序绘制它们：

1. Barnsley fern（巴恩斯利蕨）

Barnsley fern是一种类似于蕨类植物的分形图形，它由四个不同的变换组成。下面是一个简单的Octave程序，用于绘制Barnsley fern：

% 绘制Barnsley fern

% 定义初始点
x = 0;
y = 0;

% 定义四个变换
f1 = @(x, y) [0, 0; 0, 0.16] * [x; y];
f2 = @(x, y) [0.85, 0.04; -0.04, 0.85] * [x; y] + [0; 1.6];
f3 = @(x, y) [0.2, -0.26; 0.23, 0.22] * [x; y] + [0; 1.6];
f4 = @(x, y) [-0.15, 0.28; 0.26, 0.24] * [x; y] + [0; 0.44];

% 定义每个变换的概率
p = [0.01, 0.85, 0.07, 0.07];

% 绘制Barnsley fern
for i = 1:100000
    % 随机选择一个变换
    r = rand();
    if r < p(1)
        xy = f1(x, y);
    elseif r < p(1) + p(2)
        xy = f2(x, y);
    elseif r < p(1) + p(2) + p(3)
        xy = f3(x, y);
    else
        xy = f4(x, y);
    end
    % 绘制点
    plot(xy(1), xy(2), '.', 'MarkerSize', 1, 'Color', [0, 0.6, 0]);
    % 更新坐标
    x = xy(1);
    y = xy(2);
end

% 设置坐标轴范围
axis([-3, 3, 0, 10]);

2. Mandelbrot set（曼德博集合）

Mandelbrot set是一种复数集合，它由一系列复平面上的点组成。下面是一个简单的Octave程序，用于绘制Mandelbrot set：

% 绘制Mandelbrot set

% 定义绘图范围
xmin = -2;
xmax = 1;
ymin = -1.5;
ymax = 1.5;

% 定义绘图参数
maxiter = 100;
eps = 1e-6;

% 定义网格
nx = 1000;
ny = 1000;
x = linspace(xmin, xmax, nx);
y = linspace(ymin, ymax, ny);

% 初始化绘图矩阵
M = zeros(ny, nx);

% 计算Mandelbrot set
for i = 1:nx
    for j = 1:ny
        c = x(i) + 1i * y(j);
        z = 0;
        for k = 1:maxiter
            z = z^2 + c;
            if abs(z) > 2
                M(j, i) = k;
                break;
            end
        end
    end
end

% 绘制Mandelbrot set
imagesc(x, y, M);
set(gca, 'YDir', 'normal');
colormap(hot);
axis equal;

希望这些程序能够帮到你！