Bitbanging 1D Reversible Automata

1. assets

   1 40 0 -

   

   played around with a few colorization convolution kernels based on density and thought they turned out nicely:

   

2. SaaSHub

   www.saashub.com featured

   SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

   

3. opensource

   2 2 0 7.5 Python

   

   i wrote something similar a real long time ago, but it was a pig, super slow. So i upgraded to winpro or whatever and had copilot figure out what was slowing it down, and it was a simple fix, and i fleshed out the UI a bit. I forget where i first saw the rules, but when i went and fixed it up i used the wolframalpha reference[0]

   Adjust the screen rez. i am not a software developer and i put stuff on github as additional backups.

   [0]https://mathworld.wolfram.com/ElementaryCellularAutomaton.ht...

   my code: https://github.com/genewitch/opensource/blob/master/elementa... it uses pygame you can do python -m venv cellular; scripts\activate.[bat|ps1|sh]; pip install pygame; python elementalautomata.py

   i was going to do a version similar in godot but i got distracted by ipv6 routing.

4. ternary-logic-optimization

   3 1 2 3.4 Python

   Optimal calculation of fixed ternary boolean functions

   

   The author wonders:

   > In theory at least, the compiler can see that rule only has 256 values and create a reduced version of ca1d_rule_apply for each value. Whether it actually does is not of much practical concern when the rendering code is the bottle neck. However it’s interesting to see if the compiler can deduce the best solution or whether anything trips it up.

   The compiler is unlikely to get the optimal result here. The core of this is finding the best instruction sequence for a ternary boolean operation encoded in 8 bits; it's the same job needed for emulating the AVX512F "vpternlog" instruction. This can always be done in at most 5 instructions (or 4 if you have andnot/ornot/xornot), but it's not straightforward to do this. Here is some code that calculates optimal instruction sequences (by letting z3 do the heavy lifting): https://github.com/falk-hueffner/ternary-logic-optimization

5. rust-playground

   4 95 1,285 9.4 Rust

   The Rust Playground

   

   Writing a quick program that checks all possible combinations of R and R^-1 (https://play.rust-lang.org/?version=stable&mode=debug&editio...) we find the following inverse pairs:

      0x33 <-> 0x33

Suggest a related project