When I say self-similar fractal, I don't mean a fractal that is *finitely* detailed I mean a *infinitely* Detailed SVG (that is, when you zoom in, you don't find any limits for the fractal). Is this possible? For example, could you build an infinitely detailed version of the Serpinski triangle in SVG?

# Tag: fractal

## tracing – & # 39; How to set the color of the fractal on three roots & # 39;

I'm trying to create the attraction basin of the Newton method, the following code works for fractals but I can't set fractal colors for three roots,

How to configure these colors for three roots. I use the Mathica11 version. Please notify.

```
f(z_) := z^3 - 1;
df(z_) := 3*z^2;
Do(rootf(k) = N(Exp(2*(k - 1)*Pi*I/3)), {k, 1, 3});
rootPosition =
Compile({{z, _Complex}}, Which(Abs(z - rootf(1)) < 10.0^(-3), 3,
Abs(z - rootf(2)) < 10.0^(-3), 2,
Abs(z - rootf(3)) < 10.0^(-3), 1,
True, 0), {{rootf(_), _Complex}});
iterNewton = Compile({{z, _Complex}}, z - f(z)/df(z));
iterColorAlgorithm(iterMethod_, x_, y_, lim_) :=
Block({z, ct, r}, z = x + y I; ct = 0; r = rootPosition(z);
While((r == 0) && (ct < lim), ++ct; z = iterMethod(z);
r = rootPosition(z));
If(Head(r) == Which, r = 0);
Return(N(r + ct/(lim + 0.001))));
limIterations = 25;
xxMin = -3;
xxMax = 3;
yyMin = -3;
yyMax = 3;
colorLevel = Compile({{p, _Real}}, 0.4*FractionalPart(4*p));
fractalColor(p_) :=
Block({pp = colorLevel(p)}, Switch(IntegerPart(4*p),
3, CMYKColor(0.6 + pp, 0., 0., 2*pp),
2, CMYKColor(0., 0.6 + pp, 0., 2*pp),
1, CMYKColor(0., 0., 0.6 + pp, 2*pp),
0, CMYKColor(0., 0., 0., 1.)));
plotColorFractal(iterMethod_, points_) :=
DensityPlot(
iterColorAlgorithm(iterMethod, x, y, limIterations), {x, xxMin,
xxMax}, {y, yyMin, yyMax}, PlotRange -> {0, 4},
PlotPoints -> points, Mesh -> False,
ColorFunction -> fractalColor);
plotColorFractal(iterNewton, 256)
```

## fractal analysis: fine details of the Mandelbrot set

I have a question regarding some of the finer details in the Mandelbrot set. I've been watching some of the videos with very deep zoom on YouTube of the Mandelbrot Set. They are fascinating, and one of the best things is how many of the deep "wells" will end up in a small copy of the mandelbrot set, in the center, often surrounded by concentric circles. I have noticed that as one approaches the end of these zooms, the concentric circles seem to become more tense and dense, until one reaches the copy of the Mandelbrot set at the end, surrounded by extremely tight concentric rings that are so tight as to be indistinguishable. They seem almost infinitely packed. My question is, are there examples of videos of people who approach this finer detail? I'm curious to know if there is any structure at those extreme levels of packaging in detail. Thank you.

## java – Make a quick viewer of Mandelbrot Fractal

I am making a Mandelbrot set viewer in JavaFX. It takes a while, like maybe 5 seconds to finish. Here is my code:

```
package sample;
import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;
import javafx.stage.Stage;
public class Main extends Application {
private static int MAX_ITER = 80;
private static double w = 10*100;
private static double h = 2*Math.PI*100;
static double RE_START = -2;
static double RE_END = 1;
static double IM_START = -1;
static double IM_END = 1;
public static int mandelbrot(Complex c) {
Complex z = new Complex(0,0);
int n = 0;
while (Complex.abs(z).isLessThanOrEqual(2) && n < MAX_ITER) {
z = Complex.add(Complex.multiply(z,z),c);
n++;
}
return n;
}
public void start(Stage primaryStage) {
Group root = new Group();
primaryStage.setTitle("Mandelbrot Viewer");
primaryStage.setScene(new Scene(root, w, h));
primaryStage.show();
Canvas canvas = new Canvas();
GraphicsContext gc = canvas.getGraphicsContext2D();
canvas.setWidth(w);
canvas.setHeight(h);
canvas.relocate(0, 0);
root.getChildren().add(canvas);
update(gc);
}
private static void update(GraphicsContext gc) {
for (int x = 0; x < w; x++) {
for (int y = 0; y < h; y++) {
Complex c = new Complex(RE_START + (x / w) * (RE_END - RE_START),
IM_START + (y / h) * (IM_END - IM_START));
int m = mandelbrot(c);
int hue = 360 * m / MAX_ITER;
System.out.println(hue);
int saturation = 255;
int value = 0;
if (m < MAX_ITER) {
value = 255;
}
gc.setFill(Color.hsb(hue, saturation/255d, value/255d));
gc.fillRect(x, y, 1, 1);
}
}
}
public static void main(String() args) {
launch(args);
}
static class Complex {
double r;
double i;
Complex(double r, double i) {
this.r = r;
this.i = i;
}
static public Complex abs(Complex c) {
return new Complex(Math.abs(c.r), Math.abs(c.i));
}
public boolean isLessThanOrEqual(double n) {
if (r <= n || i <= n) {
return true;
}
return false;
}
static public Complex add(Complex c1, Complex c2) {
return new Complex(c1.r + c2.r, c1.i + c2.i);
}
static public Complex multiply(Complex c1, Complex c2) {
return new Complex((c1.r*c2.r)-(c1.i*c2.i), (c1.r*c2.i)+(c1.i*c2.r));
}
public String toString() {
return (r + ", " + i);
}
}
}
```

Eventually I want it to be able to move and approach the mandelbrot set with at least 10 fps. How could I do it faster? Should I try switching from JavaFX to AWT or something? Should I try using the GPU? If so, what would be the easiest way to do it? (because I really don't want to spend much time on this project)

## The analysis of pdes. What is the geometrical or dynamic meaning of a global attractor with an infinite fractal dimension?

In Efendiev-Ôtani's article: infinite size attractors for parabolic equations with p-Laplacian in heterogeneous medium (Ann.I. H. Poincaré, AN 28,2011), we obtain that the fractal dimension of the global attractor is infinite. However, no geometric or dynamic consequences are obtained.

Original publication:

https://www.researchgate.net/post/What_is_the_geometric_or_dynamic_meaning_of_a_global_attractor_with_an_infinite_fractal_dimension

## Using KochCurve to create a fractal.

I'm having trouble creating a Koch curve using the function `KochCurve`

in math. What I want to create is something like this.

However, with what I finish, using this code:

```
Graphics[KochCurve[2, {0, Pi/2, -Pi/2, -Pi/2, Pi/2}]]
```

It is this

As can be seen, the problem is that the triangles in the curve must be square. How can I solve this problem?

## gn.general topology – Fractal plane continuum with order $ omega $?

*Continuous* It means compact and connected.

The order $ ord (x) $ from a point $ x $ on a continuum $ X $ It is defined as the least ordinal. $ alpha $ such that $ X $ has a neighborhood base of open sets in $ x $ with no more than $ alpha $ it points its limits.

The triangle of Sierpinski has three points of order. $ 2 $, undoubtedly many points of order. $ 4 $ (the vertices of the other triangles), and all other points are of order $ 3 $.

The Sierpinski carpet has order $ mathfrak c = | mathbb R | $ In each of its points.

I'm looking for something to go between the Sierpinski triangle and the Sierpinski carpet.

**Question.** Is there a continuous fractal plane that has order? $ omega $ in each of your points?

*Fractal* it can be interpreted here as "self-similar" or "simple recursive construction".

## Prime numbers: proper description of a sequence with specified fractal property

I have a sequence A with the fractal pattern in which the innermost values x, where length (x) = length (A) / 2, has sum (x) = sum (A) / 2. It is also a fractal pattern , so that for the sequence x with the fractal pattern that the innermost values y, where length (y) = length (x) / 2, has sum (y) = sum (x) / 2. This continues as long as the length of the most internal values is divisible by 2. Example:

```
A = 31,18,37,24,27,46,33,36,23, -6, -3,16,19,38,41,12, -1,2, -11,8,11, -2 17,4
x = 33.36,23, -6, -3,16,19,38,41,12, -1,2
y = -6, -3,16,19,38,41
A (length) = 24
A (sum) = 420
x (length) = 12
x (sum) = 210
y (length) = 6
and (sum) = 105
```

What is a concise way to describe this property? Thank you!

## How to create this fractal zoom doge?

I would like to learn how to recreate this fractal in Mathematica and do others in the same style: