juliadynamics / fractaldimensions.jl

Estimating the fractal dimension of timeseries or multidimensional datasets

JuliaDynamics

This repository serves the following purposes:

• Contains the source code for the JuliaDynamics website in the src and build folders.
• Hosts the website via GitHub-pages and Jekyll.
• Contains tutorials for all packages of JuliaDynamics in the tutorials folder.
• Contains video resources for all packages of JuliaDynamics in the videos folder.

---

The website was modeled after the website of QuantumOptics.jl and most code that builds the site was re-used from the repository of QuantumOptics.jl (with permission).

---

To build locally do follow the instructions from here: https://jekyllrb.com/docs/

(install Jekyll and then do bundle exec jekyll serve which serves by default to http://localhost:4000)

fractaldimensions.jl's Issues

fractal method for color images

I was looking forward to applying generalized_dim to images, but the consistency difficulties inherent in binarization, e.g., Influence of binarization methods ..., are driving my colleague and I to make our initial forays with a new, indeed "novel" method that promises improved results by using all the information in a color image to find its fractal index, A single-scale fractal feature for classification of color images.

The authors have made their code available in Python, with which I can say at best that I'm familiar with some small fraction of. After not having programmed for a few decades, I've spent the last couple of years learning Julia, which I love, but I am light years away from being expert. Hence, I make this request that you consider porting the code of the Arce, Pierce, Velcsov paper into the Fractal Dimensions package.

I have played with their method (learning about FixedPointNumbers.N0f8 arithmetic), and I did reproduce their amazing result on the Sierpinski carpet, but if in the process of exploring the code, you discover scientific objections to this new method, I would very much like to hear them! Their Python code and the images on which they worked can be found at https://github.com/wsarce/Single-Scale-Fractal-Feature.

If I can assist, please let me know how. Thank you.

-- dfc

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Fractal dimension from extreme value theory fitting

Recently it has become rather fancy in the literature to compute a flavor of the local fractal dimension using a fit based on extreme value theory. Davide Faranda, which is the main authority on the method, has shared the following two resources:

For a paper describing the method and how to extract it from data: https://www.nature.com/articles/srep41278 . What we want is the "Methods" section, and "Instanteneous dimension" and "persistence" subsections. Some clarification for the paper: ζ is the state space vector (which, for the paper, is the whole spatial field at a given time). So for us ζ is just an element of an input Dataset.

And a simple code to compute it in Matlab: https://fr.mathworks.com/matlabcentral/fileexchange/95768-attractor-local-dimension-and-local-persistence-computation

pdist2 in the Matlab code is pairwise Euclidean distance. It means that from the given point ζ (in matlab this is this weird x(j,:)) we compute the distance to all other points in the data. Oddly, the matlab code does not skip the point itself, meaning that you always (and wrongly) have a 0 distance. The matlab code also doesnt include the theiler window, which I would assume would make the estimates bad. In any case, translating the Matlab code to Julia is trivial. I am wondering whether we could do any optimizations to the code so that we can skip computing pairs all the time...?

Computing fractal dimension in supertransient systems directly, rapidly and reliably

I just found this paper by Nusse et al: https://iopscience.iop.org/article/10.1209/epl/i2006-10407-y

They discuss an algorithm called traddle Grid Dimension Algorithm (SGDA) which can be applied to dynamical systems having one-dimensionally unstable stable sets such as basin boundaries. They demonstrate that the SGDA is superior to applying the Box-Counting Algorithm by utilizing straddle pairs for the end points of the boxes.

The paper also describes an implementation strategy.

Slope estimation using distribution of all possible slopes

A recent publication showed an alternative way to automate extracting a slope from a curve y(x). The reference is:

Deshmukh et al., Toward automated extraction and characterization of scaling regions
in dynamical systems, Chaos 31, 123102 (2021).

this method is very promising and should be implemented here. In v1.5 (#18 ) we added an extendable interface for adding new methods of extracting the slope of a linear scaling region of the curve y(x). We've also added a placeholder type for this new method.

Now someone has to read the paper in more detail and add the method here via a PR!

Also cc'ing the first author of the paper that has implemented the method in Python: @vrd1243

(Python implementation: https://github.com/vrd1243/scaling_regions_ensemble )

Add methods from LinearSegmentation.jl package into our slope fit

the package https://github.com/stelmo/LinearSegmentation.jl has three methods to fit linear segments, one of which is similar identical to our default method. Now that we have a nice interface for different ways to find the "slope" we can add these methods here as well. cc @stelmo