What happened here ?

[Imagyx]

Rendering a (standard) mandelbrot  z³+c at

x=-0.21503933310043449486596189329777
y=-0.85808989184676964080155071478152
zoomX=5.8355677314933246347596131660324E-32
zoomY=3.8518598887744717061119558851698E-32

where I hit the DoubleDouble limit, I calculated the julia for a point somewhere in the middle.
What I got, when zooming into (from right to left in the attached image) the julia was weird. There are "pixels" at resolution 10e-4 which don't look normal.
See for yourself.
What is that ?

[SamTiba]

i guess you reached the limit
around e-16 is the limit for normal doubles, multiply that by 2 and you have the limits four doubledoubles

[TheRedshiftRider]

That seems to be an issue with the rendering limit.
What software are you using? Have you tried different applications for the same location? Or considered using other rendering methods like perturbation?

[Imagyx]

That can't be the case here.
The limit should be around e-16 as mentioned and is in fact for this application that I wrote myself in Java.
The series attached to my post goes only as far as 10-4.
And if you look at the first (deepest image) in the series, the "pixels" are not rectangles.
And I'm not doing anything like a rotation for example, it's only plain 2d.

For going deeper I already wrote a perturbation series program as well, but that's not needed here, because I'm not zooming that deep
and a certain Java implementation allows me to use DoubleDoubles extending to e-32, which is enought for my purpose.

[claude]

I think you need more precision. There is a near-periodic orbit such that the z value gets pushed away slowly from 0 each period, but the other values in the orbit are large (because |c| is large), and adding small values to large values loses information.  z^3 means that 1e-10 becomes 1e-30, close to the limit of double-double (and 1e-4 becomes 1e-12, closer to the limit of double).  I attach a couple of images calculated with different precision, notice the shapes are different, as well as the pixelation in the center.  Here is the code:

Code:

#include <complex>
#include <cstdio>
#include <qd/qd_real.h>

typedef qd_real R;
typedef std::complex<R> C;

int main()
{
  C c(R("-0.21503933310043449486596189329777"), R("-0.85808989184676964080155071478152"));
  R r("1e-10");
  int s = 1024;
  unsigned char pgm[s * s];
  #pragma omp parallel for
  for (int j = 0; j < s; ++j)
    for (int i = 0; i < s; ++i)
    {
      C z(r * ((i - s/2) + 0.5) / (s/2), r * ((j - s/2) + 0.5) / (s/2));
      pgm[j * s + i] = 0;
      for (int k = 0; k < 65536; ++k)
      {
        z = z * z * z + c;
        if (std::norm(z) > 16)
        {
          pgm[j * s + i] = k;
          break;
        }
      }
    }
  std::printf("P5\n%d %d\n255\n", s, s);
  std::fwrite(pgm, s * s, 1, stdout);
  return 0;
}

[Imagyx]

Thanks Claude.
This makes a lot of sense to me. I didn't think about how the exponent changes precision need as well.
I'll look at some higher exponents to see if it gets worse earlier in the zoom and recalculate my last image with arbitrary precision.
Good to be reminded of some numerics basics