Multisignal Memory Unit with individual signal manipulation

[Redruin]

Recently I have decided to embark on creating a programming interface with combinators, and the need for memory became naturally apparent. I originally was using this design here, but the unit would reset every signal whenever the set signal was on, meaning that if you only wanted to change one signal at a time you were out of luck. A way to deal with this is to use addressable memory (a la https://factorioprints.com/view/-LajOSCOyWMA45ORfdD8) but this adds the added complexity of keeping track of an address for specific values, and it means that if you want to change signals independently of one another you can only store one signal on each memory cell. This quickly causes memory to balloon, which is a shame considering the impressive amount of data you can store along a single wire. I'm pretty sure there are other encoding tricks as well, but I am not familiar with them, and only needed a "simple" device with the functionality I needed.

Hence, I designed this circuit here with the goal of allowing the modification of individual signals in a memory block in one single unit. It's not perfect by any means, this is the first contraption I've truly "made" with combinators, and it has a number of problems that I'm hoping the community might be able to fix where I cannot.

0eNrtm81u4zYQgF/F4LGVFyIpyZKxLdD2nF6KRQ+LwJAtOiGgH4Oi0hqBHqBv0Wfrk5S07NiWKIuk48S7Tg5GbJEjaj5yODMcPYN5WpEVozkH02eQkHLB6IrTIgdT8AcvGClHv4/hKCNZwdajkj7kcVqO/qL8cRTnI9GNsGW8ICNejBZFzlmRjki8eNy2FA0S+pRUcZquPwEHUNGmBNOvz6C5Lu/J1ysibvZEGRftRKM8zuQPTYvxHahFvzwhf4MprB3Lnsio55eDnljZk3KS7bslZEETwsaLIpvTPBZqOxDg1fcOIDmnnJLm2Tdf1rO8yuaEiafa3z4TihqncbYSsldFSRsQz0CK8T/5DliL5uIfIX2r7dmcPMZPVNxRNFtQtqgon4lryUvfJWUln2k/O82XBWjklzyW08KVX7JVzDYPNgX//fMvqJsWOVnI25RSLpQfD4yQ/PAhaQKmYty7kcmvsL6va6nVlh7QfijVXNx78wBdPURbLYgR5IQ+PM6Likm9QvdeIRS/CI2ZmLQZ4XRxyKkr32vkBxstJ5Q1j7gZnkrne7F7tZcWeperRuq9JFLMbK/+sZgfxYqweLsqfxBdi4qvKmPhfdAYSdrIUHjMDAlmDkA9rT09wJ4ti8lNs8BtFM7RZQi72t+iUq5GVXsVLd+YVnBlK+fisNT6HeBzeilBV24XSsETPW6BMbdot7NMjrl5t7TKoN+7jFStNU3e5JSP0CURmpHYynwdDP0b/s/W+peCVmsxvirnsyUrshnNhRgw5awi5/gQbSMYGsHTdEhCI3g+vEp4n68A3sRwhwr0+ESmls53b87SaSv4xHLR3Hig2wpkSCpGwwSTVZESBQ1vRyPYRTQ6hnrAEmDUu4HKS3U7bEAORqrAAUIz0711VUNN5+dVVn83VoOt1f+TzYR6ImzNH2n+YGkDdCKEFrSuj9TD0DNzhpGxM+zYhK5wH7vuWAy4yrupH7XnS6CeL0uacsIMcydJwRuE1XZuWOVRfjmQ4VpmVH5VjgMbyfjtUIYr/45zLLScSQUu47QkBn5fpIkY2yIOL4l4bwI6jPVUolwWKNRUimdmJF8ijeiG/VvFJAwGrJpvEkIirAnPtwxOPuCdgtfeQian2SIjtrpxJwwsY5foI3b5eiqybOOLTsM3pKvraZulFfZhzy3TVeg7GjC7wUXMbmiZBkdQ05H4bsPWAV7IKAuk7eNEtrzc2+GlMmYdPG77BzjAMzIM5jSJItfsxHUL8jpPXM8IaZBhiiMwM0M3luI4kXhCA14Cdo28BF28yPokCMEryY8i6E28EAdeeGzBfnyTQ3BstP9ruubIvCQhvDYs77KfDKX+Jka0kCYtz/qQ4aZptfV7mkaTmVep37gKwcfX5iz32bA38poxMj0Mdc47lkOBrcOM35jZzrm4ROVII7s+L+s6eEpiEN/0LrGJ2bGdh3b2DZsc26GBRArGfeMLbQ7iEHpfL9W9Ui8VhmYxdL9TC3F7Ax6Yvig4Lzx3TlXFDd2s85yTvukWWda9ac+4i1uv8TuZL2hUVaAZxWDX7ogJ4fqbC0v3UpVLvTnGM9r7B4638VBKBWkWi2Jod5b0QUkR/g8sHKjrsCFNhw0jy8IdMw8ADuX/OjZ8IOLDfv/m5A4cxAylYDrXPUXtUM8rB6aVAi8OldfeQXpCRrtKh94tD3tmA/bx8YDfopjBeYWyF7OSFalBddHKGYUVvYEu9g0Z+BdicKw83xLBn68OYAwP6n3wxkIaJGaFziU1+dbW9OCVNwek8ZyIwYC7KuV0+9LaXfOy25ecyhbCCS+bSr5QBPIRmqAIYYiDuv4fz7rnrg==

Copy blueprint

Pros:

• Can handle up to N-1 unique signals (where N is the total number of circuit network signals available)
• Can handle the full range of numeric values, from INT_MAX to INT_MIN inclusive [-2147483648, 2147483647]
• Can change not just one, but groups of selected signals to any value in batches
• No need to handle extra signals for addresses, each signal's type is it's address
• Simple interface; simply set the filter signal and the value you want and you're done
• Builtin two-mode system: By changing the filter, you can toggle between setting and summing the signal in memory

Cons:

• Inconsistent timings make using it with other non-clocked circuitry nigh impossible

How to use it

The circuit has two inputs:

• Filter: on the right green wire
• Input: on the right red wire

And a single output on the left-hand power pole. The filter (green) wire expects all signals sent to it to be either zero or one, where the input (red) wire can handle values of any size. The green wire also expects a set signal (info signal in provided blueprint) that actually toggles the reset trigger. This signal could be on its own wire, but since it's a reserved signal you can simply piggy-back it along the filter wire. Just make sure to not set the info signal to any value other than zero along the input wire, lest you store the reset memory flag inside the memory unit.

In order to set a value or values, simply set the signal(s) you wish to change to 1 along with the set signal in the filter wire and their desired values along the red wire:



Changes will be immediate, and will persist when the set flag is cleared:



To clear a signal(s), simply set it in the filter but leave its input signal empty:



Perhaps unexpectedly, the filter wire does not filter the input values, meaning that any extra values in the input wire will be summed with the current memory values:



However, this bug can actually be considered a feature. It allows the user to now *change* the value by an amount every time the memory sets, for easy incrementing, decrementing and accumulation:



This way you can actually take advantage of both techniques with the same circuit. In this case it might make more sense to consider the filter wire a "reset" wire, indicating what signals should be reset to zero in the current set cycle.

If you want to wipe the memory or initialize it to a certain state manually, you can use the two constant combinators located in the middle of the build. Set the values you want in the bottom one and toggle the top one on and off to reset. Just remember to turn off both constant combinators when the unit is running, or you may get incorrect outputs.

How it works

There are two copies of the 3 combinator memory cells. The bottom-most one stores the actual current values, while the one above it stores a copy of the "old" data. Their set signals are opposite, meaning that while one reads input the other is closed, and vice-versa. This stops the infinite feedback loop you would normally get when feeding the output of the memory cell back into the input.
The Filter is designed as described here; the reason it is so complex is because it filters both positive and negative values. If you only deal with either positive or negative values exclusively, this setup can be changed to a far simpler 3 combinator design found here.
The filter outputs the specified signals from the filter wire, which are then multiplied by -1 and combined with the "old" memory signal. This effectively returns all the filtered signals to zero, which is then added to the red input wire, summing their new values. Their final input back into the first memory cell is guarded by the third and final set flag to prevent writing to memory when the set flag is triggered.

Problems:
By my measurements, the machine takes 3 ticks to reset its memory (set/reset pulse) and 7 ticks to change its filter (modifying green wire) for a potential fastest turnaround of 7 ticks. This isn't ideal not only because of no one-pulse compatibility, but also because having different pulses at different lengths results in different behavior:

1. if the pulsed inputs are less than 3 ticks, the memory is completely wiped
2. if the pulsed inputs are less than 7 ticks, all the values on the input wire are summed to memory regardless of the filter contents

Since the filter part takes up the majority of the time to run, I made a different version that's more compact without the filtering apparatus. This design requires only 3 ticks to execute, though it still a not quite ideal. In this one all values are set as deltas, so if you want to change a number to a specific value, you have to calculate the difference between the current value elsewhere, which can make things more complicated. I think I can work around this though, so if theres any way to get this down to 1 tick pulses I'm all ears.

0eNrtWVtvmzAU/ivIT9tEKwyES6Q9bJMm7aF729NURQScxhIYZEy6qOK/z8ZNQhMTbKp22bo+VApwjs8537l8th/AMm9QRTFhYP4AMlSnFFcMlwTMwQ0qSrq1GoKZdY/Z2iKltcI5Q9RKqiqhCWvqa+sbqRpmbRKup7YSiqy6KQqUSQm2RlbaUIrI/hNMrEIqvl8jYtWIXQMb4LQkNZj/fAA1viNJLqxh2wpxMzaYsoY/sQFJCvFAfnF1A1ouRzL0C8xha0+UdI0kf/QkPaUkZqg4iAmvWELYVVoWS0wSVtKeBr+9tQEPDWYYSee7H9sFaYolotytvaKE8nAWiOG0r8oGVVljCdcD4Bpnrg223DTvesaXyTBFqXzLn3NbGC3zxRKtkw3m0lzkoHbBX2edqlq8WGFas4V2XFCSroVjNRJqFju3wfyKu1BWiOeKzKkPXLRsGE8ZU+Vt27lApEedkVD8oyjrhw5n0llM0wYz+VMA1Xs9e/oatrdctSt03VGEyLE2xedtT+MOK3cqVu6bxgrOjsHao6H6Wg8LzxgL/8KweHEodFLdHakMfyD8/sGUIsm5JTlfnXIIqjJHiuCH17N++LXN9c7XOezSg9uC8N16WTZU9FgIbxUWz/YWZyjFGaJaletrZsujzuelCiarEsjoHHKEW9kNYrEO+DglSTaIbtkakzupu9pyKxvCFitaFgssZjuYM9ogk5I+LtIjWKKTLLPV+EKjPu6a9nH7XDINtZbg7GxXNJZdbp8kS6BOFsmwDLnQITmax8zYEyMeXFwvxIKrJK+RSX1BzdEXTo3J7CVjkpVsICQmjO9TT4czkTV+VtrhGen40tfhiL+nNFIDY0WpxnoAR1O5TagJ8D/AbZQVFI9MqGEqqkGVhtCKp6IVvB20FOENj8FxRsALzOZPpIeeWNaEi/hmlfbWuEgwQkZCbTJyvjg1OymEU7lxaMaN/ZFsPgmEqyDLvg09FV2GruHEj5968eoT/9aI9gyC5xmC5+zcjgfB09oSH0EVK/c1tusosfKnjoP4lcfBrqu8xGZY6m6fx35H9zEGw9sdyrFpW9Hoz7Z/50Lbf2TGv4a7f3AkGY3khv88YmefO888WcwbWX0w14Kp52TRpbSGqxfvDSq8HBN0dZlBaFb4e2IQt38d0ztoVRa53MQa4DFSje5I+TmaCEVmCAX/ERqi2ecBOd3nDnFyXxO52JCv7oib7xw3Ol8N5bTjF965By6TDpvAullyg7vFh9qxD0/YoJK2u9AwDLse48Mdf72Q40rNFGs7deJGdt676LZBnixRLm64m5xhaZP1eNv9Q9x2v/teWl87x97zrzkvqeXxfgT9MHZDN3Y96AVt+xvdm6/3

Copy blueprint

It would also be acceptable to have an output delay as long as the input produces the correct output; meaning the input could be pulsed and then some ticks later the correct output arrives. I figured that I would submit this design to the forums to see if anyone had any suggestions or fixes. I have the sneaking suspicion that I've made this whole thing far more complex than it needs to be...