each time more interesting...

Julia sets of swirl just with a scale and swirl additionaly rotated by z*c. Fun to explore. It was a formula for gravitational waves.

https://www.fractalforums.com/fractal-programs/problems-with-implementing-budhabrot-in-uf/msg55233/#msg55233
https://www.fractalforums.com/mandelbrot-and-julia-set/swirlbrot/
https://www.fractalforums.com/new-theories-and-research/swirlbox/

Swirl with scale


Swirl alsou with Z*C (in complex numbers this is additional rotation and scaling)

I guess some phisical process could look like that.


Next in TODO list is Orgform formulas of Fractint. Not all of them works in UF, throught. But there are lot of them and some have some merit. In Fractint there are even 3D formulas for mandelbrot set.

The original version is called "Cubic":

initialisation:
;Lee H. Skinner
  t=#pixel
  t3=3*t
  t2=t*t
  a=(t2+1)/t3
  b=2*a*a*a+(t2-2)/t3
  aa3=a*a*3
  z=-a

iteration loop:
  z=(z*z*z)-aa3*z+b

This could be rewriten in deoptimised form:

initialisation for the parameter space:
C= #pixel
Z= -C/3 - 1/(C*3)
Initialisation for Julia set:
Z= #pixel
C= @julia_seed


iteration loop:
z = z^3 -z*c^2/3 - 2*z/3 - z/(3*c^2) + 2*c^3/27 + 15*c/27 - 12/(27*c) + 2/ (27*c^3)

Suprisingly enought I had writen this equation on the 1st try without any error. I have no idea about math behind this, or else this transformation could be expanded to power 2. Is it something geometrical/topological? This formula was found in many formula files (maybe becouse of interesting shape but alsou zooms are OK) including ik.ufm under the name CBAP. What is CBAP anyway?

Julia sets - pretty uninteresting, just a version of power 3.
dual bailout version ( convergent and divergent ) - unremarkable. (pic2)
Abs version - very interesting. (pic3)

p.s.
Search for a fractal gives
https://web.archive.org/web/20120123105029/http://klippan.seths.se/ik/CubTut/cubictut.html
and

The sub-modules, all dealing with cubics, are divided
into two groups. In the first group I have replaced the standard formula, z -> p(z)
= z^3 - 3a^2 z + b with some other variants used by the great mathematicians.
....

The second group. Other methods of displaying 2D images of the standard-
formula:

1) CBAP and 2) CCAP: These variants of cubics occur in some of the applications
of Ferguson. He has obtained the formulas from a Professor Holger Jaenisch who,
I suspect has obtained them from the very big mathematicians on the field of
iteration of cubic polynomials. The reason for this assumption is that I've seen
details of both in a slide series from Art Matrix in the early nineties. In one of the
scenes in the two hours video-show "MANDELBROT SETS and JULIA SETS"
from the above company, there is a deep zoom sequence in CBAP. Asking
Ferguson for the source code of these variants, he displayed the CBAP code along
with some of his images on abpf. Later he sent this and the below formulas to me
by email (thanks Steve!). The quasi-code runs as:

....
In the cubic case there are two complex parameters, “a” and “b”, i e there are the axis a_real, a_imag, b_real, and b_imag.
That means that the cubic parameter space is a four dimensional hyper space!!!
....
The last picture (figure 7) is a two-dimensional slice from cubic parameter space

...
That part of cubic parameter space for which one critical point has an orbits that escapes to infinity and the other critical point has a bounded orbit, i e that belongs to either M+ or M- but not both,
is called B-locus (I guess B stands for boundary).

So this is 2D representation of mathematical object from higher dimensions, I guess.

This could be rewriten in deoptimised form:

iteration loop:
z = z^3 -z*c^2/3 - 2*z/3 - z/(3*c^2) + 2*c^3/27 + 15*c/27 - 12/(27*c) + 2/ (27*c^3)[/code]

Interesting c-transformation. I especially like the large hole-y, multiply connected sets ("normal_dualbailout", left).

I experiemnted a bit and encountered a set that surprised me: c=0.8+0.32*i using your expanded form, using a full abs computed in the 2-square.
w = |Re(z)| + i*|Im(z)|;
z_new = w^3+(-1.171000435988902133+0.13898454221165271183i)*w+(0.033436348763786892524+0.30713923580606311559i)

It shows a 2-cycle (yellow, upper left image); red are the immediate and attraction basins; black is escaping, nothing special there.  What surprised me was the gray area. It is bounded, but does not converge to this cycle or forms a different one.

So I was wondering: Is this just a numerical effect (50,000 maxit, double precision) and it will enter a cycle?
Or an obvious implementation problem (I coded the routine twice from scratch)?
Is this a common behaviour with abs()-treated functions? The set seems to be multiply connected (there are some black (=escaping) slits in the red region). Maybe the gray area is just a very large not-yet-escaped part?

I checked the orbit of a point from the red region (upper right), which shows the expected trajectory of an iteration circling into a 2-cycle. A buddha-style heatmap only depicted one hot spot at the periodic point (not shown).

Looking at the orbit of one pixel from the gray area, however turned out differently (lower left). Two large extended spots, and a heatmap of how often a pixel was hit in the orbit showed a more smeared-out behaviour  (lower right), so as if the orbit jumps around there, slowly drifting outwards (to the blue cold region) but not converging to anything.

Usually, bounded area in the polynomial case for me means interior of a Fatou component of the filled-in Julia set. Or does the abs-version have Julia set boundaries with buried area-bearing components?

Richard's 11th. This is not very pretentious formula, but it was the most easy to reiplement from bunch of fractint's orgform picked formulas of visual merit.

This iteration of FRACTINT.FRM was first released with Fractint 19.0
{ These are the original "Richard" types sent by Jm Collard-Richard. Their
  generalizations are tacked on to the end of the "Jm" list below, but
  we felt we should keep these around for historical reasons.}
...
Richard11{; Jm Collard-Richard
  z=pixel:
   z=1/sinh(1/(z*z))
    |z|<=50
  }

Richard10 and Richard11 had nice flowery shapes (simmilar to e^z or z^z fractals). I treated them as julia set of (0,0). Richard11 had better parameter space and more variation on julia set shapes. (Richard10 is the same but using sin.) The flowers probably coresponds to minibrots.
These must be initialised with  Z= pixel or else first iteration is Z₁ = 1/0 + C.

Mandelbrot set/ parameter space:
C= pixel
Z= pixelJulia set:
Z=pixel
C=julia_seediteration loop:
Z=1/sinh(1/(Z*Z)) + C

{ ; first order gamma function from Prof. Jm
  ; "It's pretty long to generate even on a 486-33 comp but there's a lot
  ; of corners to zoom in and zoom and zoom...beautiful pictures "

This must had been a very advanced machine;)

Definitely something worth checking out.

Keep up the great search!

I called it Minkowski becouse it looks like minkowski space (split complex) mandelbrot set stitched with mandelbrot or like julia and minkowski julia combined.

newton_elliptics_4    ; Morgan L. Owens <*****@nznet.gen.nz>
                         ; Tue, 14 Jan 2003 19:54:33

I heavily optimised the code as financist consider that and did structural reforms. There was a variable generating only ugliness, throwing it out and makeing it in single line allowed mutch compact equation. Alsou made it in the format mandelbrot/ parameter space <-> julia set.

initialisation:

IF "Mandelbrot type"
  z = pixel
  c = pixel
ELSE ;julia set
  z=pixel
  c=@julia
ENDIF

Cx = real(C)
Cy = imag(C)
iteration loop:
oldZ = z
X = real(Z)
Y = imag(Z)

;formula
  newX=  @A*X - X^3 - 2*Y^2  + Cx
  newY=  @A*Y - 3*Y*X^2      + Cy

;make complex
  Z= newX + flip(newY)Default A = 2 generates nice julia sets, A = 1 have parameter space with embeded mandelbrot sets.

; modifications
IF (@function=="None")
ELSEIF (@function=="Abs")
z=abs(z)
ELSEIF (@function=="Conj")
z=conj(z)
ELSEIF (@function=="Square")
z= sqr(z)
ENDIF
This formula is magic with abs.

bailout:
Newton
  |Z - oldZ| > @bailout
Mandelbrot")
  |Z| < 1/@bailout
Dual
  |Z| < 1/@bailout && |Z - oldZ| > @bailout

Newton bailout conditions reveal slightly more but it works with mandelbrot bailout too. Some color methods work better with one or another bailout. "Twin lamps" here was the best method.

newton_elliptics_4   { ; Morgan L. Owens <*****@nznet.gen.nz>
                         ; Tue, 14 Jan 2003 19:54:33
  x=real(pixel)
  y=imag(pixel)
  A=real(p1)
  B=imag(p1)
  phi=tan(real(p2))
  t=imag(p2)
  z=x+flip(y)
  :
  oz=z
  x=real(z)
  y=imag(z)
  d=2*y*phi-(3*sqr(x)+A)
  f=(sqr(x)+A)*x+B-sqr(y)
  g=phi*x+t-y
  nx=x-f+2*y*g
  ny=y-phi*f+(3*x^2+A)*g
  z=nx+flip(ny)
  |z-oz|>0.0001
}

I found a quite a popular at the time ducky like fractal from Fractint. It was called "Liar 4". What a name! There were other liars, 2, 3 but they were uninteresting. Alsou modifications called "Chaotic Dualist" and "Zeppo". Search for this formula led me to the publication on philosophy (!) and chaos theory.

1.
This formula is very mutch ducky/kaliset like but it was implemented well before colour methods which build up colour values as a summ of consequitive iterations (1/2 + 1/3 + 1/4 ->  sum <1) like Lyapunov, Exponent Smoothing, (Mega) Discrete Lagrangian Descriptors, twin lamps, wave trichrome (FE orbits) working great for Ducky fractals when used as inside colouring.

2.
This formula is absolutely bailout dependant. bailout 1 is different from 3 and different from 30. But alsou escaping areas of image depends on modulus function (of Lp spaces). I used pnorm p=1 , p=2 and p=4 and it gave different patterns. 

I treated Liar4 as a julia set of (0,0) thus with + C I got  parameter space /mandelbrot set <-> julia set. (Zeppo had it, too) And alsou I tried number of different transformations aplied to it. Scaling by complex number before a + C gave the best results.


float realScale = real(@scale)
float imagScale = imag(@scale)
initial conditions:
M set / parameter space z=0 C = pixel
Julia set z = pixel C = julia seed
Formula (my enchanced version):
  tempZ_x  =  1 - abs(Z_y - Z_x )
  tempZ_y  =  1 - abs(1 - Z_x - Z_y )

; complex scaling + C
Z_x =  tempZ_x*realScale -  tempZ_y*imagScale  + C_x
Z_y =  tempZ_y*realScale +  tempZ_x*imagScale  + C_y
 

;make complex Z (for color methods)
Z = Z_x + flip(Z_y)

This could alsou be written as complex Ultra Fractal equation:
z =( 1 - abs(Z_y - Z_x ) + flip(1 - abs(1 - Z_x - Z_y ) ) )*@scale + C

bailout:
I used bailout value = 3, Fractint's version had bailout = 1. For more ducks like behaviour bailout could be increased.
Escaping areas very mutch depends on how modulus is calculated
;p = 1, cool world of squares:
  abs(Z_x) + abs(Z_y) < @bailout

;p = 2, normal:
 cabs(z) < @bailout ; or (Z_x^2 +   Z_y^2)^0.5    < @bailout

;p = 4, supershapes:
 (Z_x^4 +   Z_y^4)^0.25   < @bailout

; or generalised for p
 ( abs(Z_x)^@p + abs(Z_y)^@p )^(1/@p) < @bailout


{--- CHUCK EBBERT & JON HORNER -------------------------------------------}

comment {
  Chaotic Liar formulas for FRACTINT. These formulas reproduce some of the
  pictures in the paper 'Pattern and Chaos: New Images in the Semantics of
  Paradox' by Gary Mar and Patrick Grim of the Department of Philosophy,
  SUNY at Stony Brook. "...what is being graphed within the unit square is
  simply information regarding the semantic behavior for different inputs
  of a pair of English sentences:"
  }

Liar1 { ; by Chuck Ebbert.
  ; X: X is as true as Y
  ; Y: Y is as true as X is false
  ; Calculate new x and y values simultaneously.
  ; y(n+1)=abs((1-x(n) )-y(n) ), x(n+1)=1-abs(y(n)-x(n) )
  z = pixel:
   z = 1 - abs(imag(z)-real(z) ) + flip(1 - abs(1-real(z)-imag(z) ) )
    |z| <= 1
  }

Liar3 { ; by Chuck Ebbert.
  ; X: X is true to P1 times the extent that Y is true
  ; Y: Y is true to the extent that X is false.
  ; Sequential reasoning.  P1 usually 0 to 1.  P1=1 is Liar2 formula.
  ; x(n+1) = 1 - abs(p1*y(n)-x(n) );
  ; y(n+1) = 1 - abs((1-x(n+1) )-y(n) );
  z = pixel:
   x = 1 - abs(imag(z)*real(p1)-real(z) )
   z = flip(1 - abs(1-real(x)-imag(z) ) ) + real(x)
    |z| <= 1
  }

Liar4[float=y] { ; by Chuck Ebbert.
  ; X: X is as true as (p1+1) times Y
  ; Y: Y is as true as X is false
  ; Calculate new x and y values simultaneously.
  ; Real part of p1 changes probability.  Use floating point.
  ; y(n+1)=abs((1-x(n) )-y(n) ), x(n+1)=1-abs(y(n)-x(n) )
  z = pixel, p = p1 + 1:
   z = 1-abs(imag(z)*p-real(z))+flip(1-abs(1-real(z)-imag(z)))
    |z| <= 1
  }

F'Liar1 { ; Generalization by Jon Horner of Chuck Ebbert formula.
  ; X: X is as true as Y
  ; Y: Y is as true as X is false
  ; Calculate new x and y values simultaneously.
  ; y(n+1)=abs((1-x(n) )-y(n) ), x(n+1)=1-abs(y(n)-x(n) )
  z = pixel:
   z = 1 - abs(imag(z)-real(z) ) + flip(1 - abs(1-real(z)-imag(z) ) )
    fn1(abs(z))<p1
  }

The original source call this function Dualist. (But I didn't read it whole.)

https://www.semanticscholar.org/paper/Pattern-and-chaos%3A-New-images-in-the-semantics-of-Mar-Grim/c14bbaa0cf8a198c6069eec278eea39ca0490374
or
http://www.pgrim.org/articles/patternandchaos.pdf

p=2 bailout with value =1 and julia set (0,0) gives figure 29 of publication.

(3D: This image is copy url from semanticscholar)

DOI:10.2307/2215637Corpus ID: 10847722
Pattern and chaos: New images in the semantics of paradox
G. Mar, P. Grim
Philosophy
Noûs, Vol. 25, No. 5 (Dec., 1991),

Quote

The paradox of the Liar and its kin are well known as recalcitrant puzzles, perennially resistant to perennial attempts at solution. There is also a tradition, however, in which such paradoxes are treated as more than mere puzzles: a tradition running at least from Russell (1903) through Godel (1931) and Tarski (1935) to Kripke (1975), Herzberger (1982), Gupta (1982), and Barwise and Etchemendy (1987). In such approaches, patterns of paradox are respectfully treated as possible keys to a better understanding of incompleteness phenomena and semantics in general. Our work here is intended as a part of this latter tradition.

......

8. FRACTALS IN THE SEMANTICS OF PARADOX
Here we finally want to offer another way of graphing the behavior
of the Dualist functions sketched in terms of attractors immediately
above. Though we consider the results that follow to be intriguingly
beautiful, we cannot at this point claim to understand fully the semantic
lessons they may have to teach.

.....


These images clearly exhibit an intricate fractal character, or
self-similarity under magnification. 23 Nonetheless what is being
graphed within the unit square is simply information regarding the
semantic behavior for different inputs of a pair of English sentences:
X": X" is true to the extent that Y" is true
Y": Y" is true to the extent that X" is false

....

The existence of such fractal images within an infinite-valued
semantic analysis of paradoxical sentences seems to offer beauty and
an intriguing promise of some deep truths. Nonetheless at present
we cannot say precisely what they may have to tell us about truth
and paradox.
 

It's not a sentences in english it is a philosophical paradox. https://en.wikipedia.org/wiki/Liar_paradox  I did not expected so mutch dept from this formula with a stupid name "liar4". All the pictures below are julia sets.

Some philosopher from Crete said that all the cretans are liars. Does this mean that he laid that all cretans are liars?

2 ancient philosophers had died seeking solution for this logical paradox. One made a wow, that he will not eat untill he will found a solution. And he eventualy starwed to death. Another one had poor health and had a lot of unsleeped nights seeking the solution leading to his demise.