Estoy escribiendo una calculadora mandelbrot con la ayuda de gpu.js y hasta ahora, todo funciona perfectamente bien. El único problema al que me enfrento es que la GPU solo quiere calcular flotadores de 32 bits. O al menos esto es lo que me dicen los documentos oficiales.
Pero al hacer el mismo cálculo con python y numba , que también se ejecuta en la misma GPU, es mucho más preciso al renderizar el fractal de mandelbrot.
Con Python, puedo obtener casi alrededor 1e-15 mientras que en Javascript, la imagen se vuelve borrosa alrededor 1e-7 .

Núcleo de Python:

 @cuda.jit(device=True) def mandel(x, y, max_iters): c = complex(x, y) z = 0.0j for i in range(max_iters): z = z * z + c if (z.real * z.real + z.imag * z.imag) >= 4: return i return max_iters

Núcleo Javascript:

 const recalculateMandelbrot = gpu.createKernel(function(x_start, x_end, y_start, y_end, iters){ let c_re = x_start + (x_end - x_start) * this.thread.x / 1024; let c_im = y_start + (y_end - y_start) * this.thread.y / 1024; let z_re = 0, z_im = 0; let z_re_prev = 0; for(let i = 0; i < iters; i++) { z_re_prev = z_re; z_re = z_re * z_re - z_im * z_im + c_re; z_im = z_re_prev * z_im + z_re_prev * z_im + c_im; if ((z_re * z_re + z_im * z_im) >= 4) { return i; } } return iters; }).setOutput([1024, 1024]).setPrecision('single');

Los algoritmos son iguales entre sí, excepto que en Python, puedo usar su tipo complex incorporado.

Así que pensé en usar BigDecimal, donde puedo lograr una precisión arbitraria (para poder acercarme tanto como quiera), pero no sé cómo agregar esto a mi gpu-kernel.

Actualizar:

La razón por la que Python funciona de manera más precisa es porque el tipo complex consta de dos flotadores de 64 bits. Entonces, la razón por la cual JavaScript es un cálculo menos preciso es por el propio JavaScript.
Entonces, mi pregunta ahora se centra en cómo agregar big.js a mi gpu-kernel.