Show more

...and results are in: it doesn't work as an animation at all, frames are seemingly unconnected. I guess pasting a different prefix onto an angled internal address does not do anything useful structurally, even though it happened to give valid addresses in this instance.

Show thread

working on another fractal animation, this time a julia morph orbiting in the hairs of an island. no clue yet if it will turn out any good...

current progress:
- found the angled internal address for one exemplar by tracing a ray outwards in mandelbrot-perturbator-gtk
- found a pattern for the external angles of the prefix, by tracing a few more rays outwards (much shallower) and comparing the binary strings
- wrote some haskell to combine the prefixes with the suffix of the examplar address, and compute one of the corresponding external angle pairs
- now tracing the rays to end-points in parallel:

```
cat rays.txt | parallel -k m-exray-in 100 "{}" 8 $((2 * 8 * 1378)) | tee -a endpoints.txt
```

- a total of 256 rays on 16 threads, ETA about 1h30 wall-clock (plus the 20mins done already)

mildly stroboscopic animation 

Playing with colour cycling again, this time with OpenGL GLSL colouring algorithms (for colouring based on distance estimate (black filaments) and iteration count (white and red bands).

Software: KF, plus a bash script to update the ColorOffset field in the palette, plus ImageMagick and gifsicle.

In the process was reminded of old idea to make ColorOffset fractional instead of integer for more flexibility. Also old feature requests to have colour cycling in-program.

Magic number for this fractal is 30, the red bands are spaced that many iterations apart making the colours synchronize with the shapes.

New kf-2.15.3 release: mathr.co.uk/kf/kf.html#downloa

Full change log: mathr.co.uk/kf/manual.html#kf-

Highlights:
- rescaled iterations for faster deep zooms, including for hybrids
- rescaled series approximation for faster power 2 Mandelbrot set
- lower level code for much faster reference calculations for hybrids
- various GUI improvements
- single precision support
- "reuse reference" and "auto solve glitches" can be used together

Known issues:
- some "deep needle" locations can be slower with rescaled iterations (workaround: disable them in the new number types dialog)
- single precision can sometimes cause undetected glitches (so it is disabled by default, be careful when enabling)

fixed KF's SIMD speed regression, as I predicted it was a really silly typo:

```
while pixels left
{
collect a pixel into vector, increment counter
if counter == vector size
{
do SIMD iterations with vector
counter = 0
}
// there should have been a } here
for k = 0 .. counter
do regular iterations with leftover pixels
} // this } should have been 2 lines up...
```

That means for e.g. vector size 4, regular iterations for the pixels in the vector were done 3 + 2 + 1 = 6 times followed by the 4-vector iterations 1 time, when it should have been doing only the 4-vector iterations (the left over pixels should only have regular iterations a few times, at the end of the image).

Observed symptom: increasing SIMD vector size increased runtime substantially, when it should have decreased it (up to a point, the sweet spot seems to be 4-vectors, before fixing this bug the perturbation iterations for a test location took 14.3s vs 5.6s after, bot unchanged at 8.1s without SIMD; wall-clock times).

mathr.co.uk/kf/kf.html I refreshed the KF website (made it less narrow, added quick start, deleted a bunch of stuff like changelogs and download links for old versions, deleted youtube links and added diode.zone links for the videos, ...)

mathr.co.uk/kf/manual.html I also uploaded the work-in-progress of the manual, with new (long) table of contents etc. Might have been a bit premature as it documents kf-2.15.3 which is not yet released (last thing I need to figure out and fix is why SIMD got so slow, probably a typo somewhere...)

mathr.co.uk/kf/kf.html#kf-2.15
Another KF bugfix release: I forgot to include the generated code for Newton-Raphson zooming of built-in formulas; and I also fixed another stride issue (seems Microsoft documentation states 4-byte alignment while I was using 2-byte alignment for some reason...)

Show thread

This is not the big 2.15.3 release I've been working on - I discovered some severe speed regressions that I need to fix first.

I think the main slowdown is in the floatexp type that I made more robust/correct, as well as templated for single precision.

Single precision with a 32bit exponent had some bugs where values would get tiny/huge instead of infinite/0 when the exponent overflowed or underflowed, the same bug exists with the original code but triggering it with a 64bit exponent is much less likely...

Show thread

New bugfix release: mathr.co.uk/kf/kf.html#kf-2.15

- fix SIMD implementation of sgn() (test location by FractalAlex)
- fix opengl pack alignment for non-multiple-of-4 width bitmaps
- fix palette From Image not updating number of colours (reported by Microfractal)
- fix palette From Image to use maximum of width and height
- add PNG to supported images for palette From Image (reported by Microfractal)
- fix argmin|z| glitch correction for OpenCL
- report detailed timing information in command line mode
- update dependencies
- boost to 1.76.0
- tiff to 4.3.0
- openexr to 2.5.6
- glfw to 3.3.4

claude boosted

Sonic Electronics
– Female Noise Composers

Thursday 20 May online streaming, 20:00H

With Nicola Woodham – Cerpintxt – senter-your-name – Alice Karveli – Jenny Pickett – Alexandra Cardenas

iklectikoffsite.org/sonic-elec

IKLECTIK YT channel: youtu.be/wJ5auavGr7M

IKLECTIK FB PAGE: facebook.com/IKLECTIK

IKLECTIK TWITCH channel: twitch.tv/iklectik

Please support the artists! If you can donate, please do it at the following link:

buytickets.at/iklectik/526371*

This morning I sped up the reference orbit calculations for hybrid formulas in KF by a large constant factor (around 7-8x in one test with perpendicular burning ship, from 3.33 seconds to 0.43 seconds - the built in formula is still slightly ahead at 0.38 seconds).

I suspect this remaining ~10% difference will narrow at deeper zooms than the e11 of the test location, as the time for the higher precision maths will rise while the time for the surrounding hybrid interpreter logic overhead will stay the same.

Instead of using a templated complex class around a Boost wrapper for MPFR arbitrary precision floats, I went low level and implemented it all in terms of mpfr_add, mpfr_sub, mpfr_mul etc. So "A = B * C" with complex variables becomes 4 muls 1 sub 1 add.

This lets me float out the memory allocation for all the temporary variables outside the inner loops, which provides a large speedup.

The source code is much longer, however, and much less easy to understand.

claude boosted

hello all! we are organizing an event for noise music DIY electronics live coding hardware hacking in June in London back in the venue space, contact laura@netzzz.net

Also worked on the transformation dialog, moved the "Auto Skew (Escape)" feature there from the old Newton zoom dialog.

I made it display the difference between the old transformation and new transformation, as trying to display the total transformation in an editable way was getting too confusing for me. (The difference is needed to warp the image without recalculating the pixels, the total is needed for recalculating the pixels at which point the warping transformation should be reset to identity.)

I also made it so the number entry boxes have spin buttons so that editing is easier (in fact you can get live results from the edit boxes, rather than having to edit without being able to see the results before clicking OK).

Show thread

Rewrote the Newton-Raphson zooming dialog for KF, and added absolute zooming for minibrots and atom domains (the old mode is relative between current zoom and minibrot size, which works very well in practice, but just occasionally the other ways are useful too). Also added a geometric size factor as well as the exponential size power / folding.

claude boosted

What to do about the Examine Zoom Sequence feature of (a explorer)?

It's probably no longer necessary now that Reuse Reference (which saves computation time at the expense of memory) can be used together with Auto Solve Glitches (which is needed for correct images)?

It used to be (in the distant past) that zoom out sequences were full of glitches and you'd have to scroll through and correct them later, but the code rotted and there are loads of bugs (it doesn't support iteration data in EXR, only KFB, it doesn't write out corrected PNGs etc, only JPEGs, minimizing the window can corrupt the whole zoom sequence, ...).

There is also a poll here:
fractalforums.org/kalles-frakt

I added a "disable texture resize" option to KF, which means you can access actual texture image pixels in OpenGL, which makes the "legendary colour palette" technique much easier (no need to convert the image to a linear palette in text format first).

colouring algorithm code:
```
vec3 colour()
{
if (getInterior()) return KFP_InteriorColor;
int w = textureSize(KFP_Texture, 0).x;
int h = textureSize(KFP_Texture, 0).y;
int N = to_int(floor(div(getN(), KFP_IterDiv)));
N += int(KFP_ColorOffset) * w * h / 1024;
int i = N % w;
int j = (N / w) % h;
return texelFetch(KFP_Texture, ivec2(i, j), 0).rgb;
}
```
(if you try this in latest released KF you will probably be disappointed, as the texture image is resized to match the output image size)

Show more
post.lurk.org

Welcome to post.lurk.org, an instance for discussions around cultural freedom, experimental, new media art, net and computational culture, and things like that.