Fx gx h

Like gaussian integer can run into problems without even zooming when using single precision, and also formulas that use exp or trig functions, they will start exceeding single precision limits with bailouts even below 10000.I will add a little example of what I did and how it works later.//edit:Here's a bit more info on my program. It's on GitHub, so anyone can check it out, currently I am calling it GPUtopia: nowhere near complete, there are tons of bugs and very few features, but the part that handles formulas is already quite versatile.Here is an example of what a UF formula looks like vs. one in GPUtopia:```` trignarls_simple_x3 {init: z = #pixel float func stream_func_gradient_X(const float xold, const float yold) float a = 1. / sqrt(3.) float f = sin(2. * a * xold) float g = sin(a * xold + yold) float h = sin(a * xold - yold) float gy = cos(a * xold + yold) float hy = -cos(a * xold - yold) return f*gy*h + f*g*hy endfunc float func stream_func_gradient_Y(const float xold, const float yold) float a = 1. / sqrt(3.) float f = sin(2. * a * xold) float g = sin(a * xold + yold) float h = sin(a * xold - yold) float fx = 2. * a * cos(2. * a * xold) float gx = a * cos(a * xold + yold) float hx = a * cos(a * xold - yold) return -(fx*g*h + f*gx*h + f*g*hx) endfunc niter = 0loop: float xold = real(z) float yold = imag(z) x = xold + @c1 * stream_func_gradient_X(@f1 * xold, @f1 * yold) + \ @c2 * stream_func_gradient_X(@f2 * xold, @f2 * yold) + \ @c3 * stream_func_gradient_X(@f3 * xold, @f3 * yold) y = yold + @c1 * stream_func_gradient_Y(@f1 * xold,

- yold); return f*gy*h + f*g*hy;}real stream_func_gradient_Y(const real xold, const real yold){ real a = 1. / sqrt(3.); real f = sin(2. * a * xold); real g = sin(a * xold + yold); real h = sin(a * xold - yold); real fx = 2. * a * cos(2. * a * xold); real gx = a * cos(a * xold + yold); real hx = a * cos(a * xold - yold); return -(fx*g*h + f*gx*h + f*g*hx);}Likewise with coloring algorithms. So there is some resemblance, especially in the way it is broken up into different parts. The program then incorporates each part into a larger OpenCL kernel that is used to calculate the fractal on the GPU. Here's a comparison of UF's result and GPUtopia's result. It's not perfect, there is an offset of about a pixel in my program and the gradient isn't quite interpolated the same way.Left: UF took 50 seconds on a 3900XRight: GPUtopia took 5 seconds on a 7900 XTX (89 samples per pixel)Admittedly not a fair comparison. The GPU is much newer than the CPU. I used normal AA with UF, I don't know how many samples that takes per pixel. And most importantly, UF can do about a million things that GPUtopia can't. BTW, just like last time, credit goes to Lycium for taching me a lot of stuff, especially anti aliasing I have added double precision and it works. But it's much slower because consumer GPUs have their fp64 performance massively nerfed. Single precision problems are visible anywhere from about 1000x to 50000x magnification, double takes you much deeper obviously, but it still is extremely limiting for exploration.As I mentioned elsewhere, there are many UF fractals that don't use much zooming, but even simple stuff like high bailouts with CAs

- yold); return -(fx*g*h + f*gx*h + f*g*hx);}````Likewise with coloring algorithms. So there is some resemblance, especially in the way it is broken up into different parts. The program then incorporates each part into a larger OpenCL kernel that is used to calculate the fractal on the GPU. Here's a comparison of UF's result and GPUtopia's result. It's not perfect, there is an offset of about a pixel in my program and the gradient isn't quite interpolated the same way.Left: UF took 50 seconds on a 3900XRight: GPUtopia took 5 seconds on a 7900 XTX (89 samples per pixel)Admittedly not a fair comparison. The GPU is much newer than the CPU. I used normal AA with UF, I don't know how many samples that takes per pixel. And most importantly, UF can do about a million things that GPUtopia can't. :DBTW, just like last time, credit goes to Lycium for taching me a lot of stuff, especially anti aliasing :) edited Feb 6 at 10:13 pm

* xold + yold) float hx = a * cos(a * xold - yold) return -(fx*g*h + f*gx*h + f*g*hx) endfunc niter = 0loop: float xold = real(z) float yold = imag(z) x = xold + @c1 * stream_func_gradient_X(@f1 * xold, @f1 * yold) + \ @c2 * stream_func_gradient_X(@f2 * xold, @f2 * yold) + \ @c3 * stream_func_gradient_X(@f3 * xold, @f3 * yold) y = yold + @c1 * stream_func_gradient_Y(@f1 * xold, @f1 * yold) + \ @c2 * stream_func_gradient_Y(@f2 * xold, @f2 * yold) + \ @c3 * stream_func_gradient_Y(@f3 * xold, @f3 * yold) z = x + (0, 1)* yniter = niter + 1bailout:|z|@baildefault:title="Trignarls"maxiter=50center=(0., 0.)magn=2periodicity=0param bailcaption="Bailout"default=10000000.0endparamfloat param c1 default = 0.1endparamfloat param f1 default = 1.endparamfloat param c2 default = 0.1endparamfloat param f2 default = 2.endparamfloat param c3 default = 0.1endparamfloat param f3 default = 3.endparam}GPUtopia:__parameters: float parameter c1 = 0.1f; float parameter f1 = 1.f float parameter c2 = 0.1f; float parameter f2 = 2.f; float parameter c3 = 0.1f; float parameter f3 = 3.f;__init://=====| fractal formula init real2 z = z0;__loop://=========| fractal formula loop z += (real2)( @c1 * stream_func_gradient_X(@f1 * z.x, @f1 * z.y) + @c2 * stream_func_gradient_X(@f2 * z.x, @f2 * z.y) + @c3 * stream_func_gradient_X(@f3 * z.x, @f3 * z.y), @c1 * stream_func_gradient_Y(@f1 * z.x, @f1 * z.y) + @c2 * stream_func_gradient_Y(@f2 * z.x, @f2 * z.y) + @c3 * stream_func_gradient_Y(@f3 * z.x, @f3 * z.y));__bailout://=| factal bailout function // must always define bool bailedout!!! bool bailedout = (dot(z, z) > bailout*bailout);__functions:real stream_func_gradient_X(const real xold, const real yold){ real a = 1. / sqrt(3.); real f = sin(2. * a * xold); real g = sin(a * xold + yold); real h = sin(a * xold - yold); real gy = cos(a * xold + yold); real hy = -cos(a * xold