Signal Compression or Encapsulation

[Aricitic]

TL;DR

Enable some way to "compress" or "encapsulate" multiple signals into one... with the ability to "extract" them again later.

What?

Add the ability to take multiple signals, such as a list of ingredients, and compress them into one signal --> but specifically one that can allow us to extract these signals again at a later time/operation.

Why?

Currently, to enumerate the ingredients of a recipe, a player must have the building that makes that recipe be able to receive a signal for the result of the recipe AND transmit the ingredients.
Ok, fair enough, but what if I want to enumerate the ingredients for each ingredient or at different quality levels? How do I "capture" one while requesting another? If it's the levels of quality, this is simple, you send the results through a Selector Combinator with "Quality transfer" "desired quality" and "Each" as the 'target signal'... and you do this for each quality you want (up to five times)...
But how to enumerate the sub-ingredients? I've tried using an S-R (or R-S) Latch, but it catches ALL signals. I've tried this many different ways and many different times.

So. Instead if we could take a set of signals and encapsulate them into "one" signal (similar to the "each" or "anything" or "everything" signal); then transmit that, to be broken down into its components again later, we wouldn't have this issue.

And that isn't the only use case. Any time a person needs to transmit anything, everything, or each... or any set of signals, without interfering with other signals on the same circuit, they either have to create a "MASSIVE" external circuit or simply "not" do it. Needless to say, trying to catch an "each" in a latch is extremely difficult.

Of note:

This will reduce complexity. I do not ask that it be provided freely. As with my last suggestion (in which I forgot to mention this key point) I am perfectly happy for this to be locked behind a technology. That isn't a problem.

What may be a problem is people claiming that *because* this reduces complexity it *shouldn't* be added, *period*. To which I respond: Unlill Wube takes away logistics (bots) outright, this is a non-argument. Heck, Korvax Enrichment simplified things for players by providing a source of otherwise rare U235.

Final thoughts: Use case? Sure: Space Platforms.
Need I say more? Yes? Ok: Space Platforms are expensive to produce and ship into space so the room to build things in space is at a premium until you are fairly efficient and technologically sufficient. Until then the ability to tell one machine to produce anything you need depending on what you have available, and to do this with as few combinators as possible, is EXTREMELY important.
Need I say more?

[Aricitic]

A somewhat more simple solution for the issue with recipes would be to simply add a signal for each "thing" that can be crafted. Just... some way to distinguish between an "ingredient" vs a "recipe" within the signal(s) it/them self/ves...

[Tertius]

As far as I see this request, you want an assembler in read recipe mode output a value, and this value contains an encoded list of all ingredients, including the ingredients required to make the ingredients?
This is not feasible, or not a complete solution, because there exist multiple recipes for several items, and you're unable to give the assembler the info which of these recipes to pick. There are also recipes an assembler cannot process but some other production building. How far do you want to descend the dependence tree? Down to the ore, water and crude oil? Such a result isn't practical. Or down to the plates? What if you have extra production lines for the green, red and blue chips?

And if you "extract" the encoded value with some new functionality, you need the same circuit complexity to process the result you need if you get the info in the first place.

As far as I see it, it's only practical to handle the recipe at hand. Not any dependent recipe.
You start with a list of items to craft.
You process the items one after the other.
To process the item at hand, you load it as recipe into an assembler and read the ingredients.
Then you process the ingredients, filter your individual factory has already in stock, or you want to acquire from elsewhere, and get the ingredients you need to craft.
You add these ingredients to the items to craft, in case they aren't there already.
Then you process the list of items again.
If you added no new item to the list of items to craft, you finished descended the dependency tree.
Now you process the list of items to craft, ordered by "most recently added".
So you feed the most recently added item as recipe to the assembler and let it craft the thing. It can be crafted, because it had no unavailable ingredients.
Then the next. It can also be crafted, because any dependent ingredient was more recently added, so it was crafted before.
And so on up to the first item added.

It seems you want the game engine provide some magical device that does this for you. I guess that will not happen, since there are many external dependencies: the factory-specific info which item is available and by what means, and which recipes to use, and what to do if there is simply no means to currently craft some dependent ingredient.

The algorithm I outlined can be implemented with not too many combinators. The central combinator is a memory cell that is a counter that counts the ticks since each item was added. Each item enters with value 1 and is increased by 1 every tick. The item with the lowest value is the most recently added item. The list of items is ordered, and the ordering is stable, since every entry is increased every tick.
A second memory cell is required. It also contains all items to craft, but as value it counts the amount to create, so you know when to change the recipe for the item currently being crafted and the next recipe can be crafted.

However, what do you want to do if the stock changes unexpectedly? What if some dependent item you just crafted is taken away by some random means?

All this is so complex, the player factories so different, you cannot build it into one magical device given by the game engine. You need to handle all this with your own circuit setup. Keep in mind game engine mechanics need to be universal. Not specific to your imagined factory setup.

[Aricitic]

As far as I see this request, you want an assembler in read recipe mode output a value, and this value contains an encoded list of all ingredients, including the ingredients required to make the ingredients?
This is not feasible, or not a complete solution, because there exist multiple recipes for several items, and you're unable to give the assembler the info which of these recipes to pick. There are also recipes an assembler cannot process but some other production building. How far do you want to descend the dependence tree? Down to the ore, water and crude oil? Such a result isn't practical. Or down to the plates? What if you have extra production lines for the green, red and blue chips?

And if you "extract" the encoded value with some new functionality, you need the same circuit complexity to process the result you need if you get the info in the first place.

As far as I see it, it's only practical to handle the recipe at hand. Not any dependent recipe.
You start with a list of items to craft.
You process the items one after the other.
To process the item at hand, you load it as recipe into an assembler and read the ingredients.
Then you process the ingredients, filter your individual factory has already in stock, or you want to acquire from elsewhere, and get the ingredients you need to craft.
You add these ingredients to the items to craft, in case they aren't there already.
Then you process the list of items again.
If you added no new item to the list of items to craft, you finished descended the dependency tree.
Now you process the list of items to craft, ordered by "most recently added".
So you feed the most recently added item as recipe to the assembler and let it craft the thing. It can be crafted, because it had no unavailable ingredients.
Then the next. It can also be crafted, because any dependent ingredient was more recently added, so it was crafted before.
And so on up to the first item added.

It seems you want the game engine provide some magical device that does this for you. I guess that will not happen, since there are many external dependencies: the factory-specific info which item is available and by what means, and which recipes to use, and what to do if there is simply no means to currently craft some dependent ingredient.

The algorithm I outlined can be implemented with not too many combinators. The central combinator is a memory cell that is a counter that counts the ticks since each item was added. Each item enters with value 1 and is increased by 1 every tick. The item with the lowest value is the most recently added item. The list of items is ordered, and the ordering is stable, since every entry is increased every tick.
A second memory cell is required. It also contains all items to craft, but as value it counts the amount to create, so you know when to change the recipe for the item currently being crafted and the next recipe can be crafted.

However, what do you want to do if the stock changes unexpectedly? What if some dependent item you just crafted is taken away by some random means?

All this is so complex, the player factories so different, you cannot build it into one magical device given by the game engine. You need to handle all this with your own circuit setup. Keep in mind game engine mechanics need to be universal. Not specific to your imagined factory setup.

First, I must apologize, I'm not feeling too well and am therefore not thinking too well. (yes, I use "big words" when feeling unwell... it's a curse -- and that's not a joke)
Second, you misunderstood the premise of my request so I'm going to respond under that assumption -- which is actually good because it forces me to reevaluate how I initially phrased my request and its explination.

I don't want a recursive encapsulation, which is what seems to be your interpretation. Heck, if I could use logistic groups or a constant combinator to predefine these myself, that would be perfectly acceptable. Or, if I could find a sufficient way to store captured signals - and those alone - that would be sufficient, and would allow me to utilize what you are suggesting for what I want.

I also don't want to have to recursively extract the sub-ingredients *each time* I need to get them. I want a simple, one-time, request to get the ingredients. Again, my initial response to my request would be sufficient to do this -- i.e. circuit signals that indicate a recipe itself for each craftable item/building('s item). These exist for some things like coal, but not others like circuits.

Additionally, if I could do a simple, one-time set of signals into, say, signal "A", and then convert it back into those signals, without using more than three Combinators, that would ALSO be acceptable, but I cannot. I've tried -- so, either I'm too stupid to figure it out, or it's just not possible for what I want: *EACH* -> *A* -> *(original) EACH* == not possible.

TL;DR

TL;DR: What I don't want: Factorio to automatically make any sub-ingredients for me without any input. That's unnecessary for me. What I *DO* want: to be able to store and utilize a list of signals dynamically without interfering with other signals: i.e. *iron* *electric circuit* -> *A* without interfering with *Iron* or *electric circuit*'s original signal(s).

-- Use-case --
SImilar to what you thought, I DO want to use this to do automated crafting, even *WITH* subcomponents, but I'm more interested in seeing if the Logistics Network *HAS* those subcomponents than initially crafting them. I.E. I have a chest with Common, Uncommon, Rare (etc) versions of those components and want to see if I have *enough* of each to start the crafting. Currently, this is N+ comparisons for A+ Comparators where "N" is the number of ingredients and "A" is the number of qualities I want to compare.
Additionally, I don't want to have a literal "bank" of Comparators for literally every list of ingredients of any item in the game that can be crafted. I would like to capture, once and only once, the ingredients I need to simply pass a simple check of whether I have them or not. I'm absolutely fine with the requirement of having a Selector Comparator for each quality I want to test, that's not a problem and is understandable. It outputs only one quality for any input. But there is currently no way to create a latch that catches, and keeps, the exact number of required items without changing the number, or list of items... (that I know of).


Ah, ok, I'm going to stop now. As I said, I don't feel well, which is making me not think well, and, apparently, not see well. So... sorry if I misunderstood (or misread) your post... or was offensive in any way. And, thank you for your help.

[Tertius]

I would like to capture, once and only once, the ingredients I need to simply pass a simple check of whether I have them or not.

With all qualities. Something like this? It inputs one item (here: green circuit) and outputs all qualities of this item with enough quality ingredients in stock.

12-19-2024, 00-26-08.png (253.68 KiB) Viewed 740 times

0eNrlWc1u4zYQfhWB11KB9ZdEBnLqEyx66CE1BFqiE2IlUiUpZ43AD7Bv0UtfbJ+kQ8qyLEeJRW2T3aKXhB6S38x8Q84M7We0LhtaS8Y1Wj4jlguu0PL+GSn2wElpZJxUFC0RUYpW65LxB78i+SPj1I/QHiPGC/oFLYM9HtlU0JwVVPq5qNaMEy3kyZZwv8KIcs00o61S+2GX8aZaUwmYuMMxZmnC9SkQRrVQsFdwo9DgxVcJRju09KM4uUpAUcEkzdsVMTYgWooyW9NHsmWAANtUO6+GYzClcwujDSs1lefSo2F1bfwj65KCRX82pAQPYIILWQEVRmtVE2ktXqI7K2gM2eHCMNZRcQRkUnC/Lol2hAtO4aIjnNKUlnPwksV+NTRwHg8NBw0VROB1VU5ETMALhqZHc02XRNK31LiYfRHr1OJ4rsW0ZvkbWqLIxeQLYG7n7QLY2WlL5hJQ0gfKCyJ3b+lyIWEKoAnear83sGcJrIcfSYQv81fQZa/FefYKwvH0dYDNYK5gx0R2+gno2zCpdNbnZr2rjUlbJnVjc0AXO7vC/9Wk6C7hwmE0WVo0um70eWWYBlTvMktUtpGiyhgHILTckFLRYcm4jPYKy/3pG61RL3mO+joRWKbHK4POgH9mjNKyoRhJSgqw/0HSgoEJqpXvzUS7DNESAgYHieV+zmTeMI262ezsLoz4Efd+SKYfK6oNzlsH5vrVA/NKueuBz46M4xmhwK6JLpRMgHHfJ+D6ktZS5KPufLnjnJqdcaqfhPxs/YEYdWGDeFF+PHFDk1/uscuOm2yARw9d4na1b10j9R43m26p3Gm4Fg/tzTxJZ9++/o1m0Dk7NwxNmRSF8ct/7RSHaPEzxOE8w14ifoSNLnw0O+givEDvFY3RwI9G48YtGuHPGY0Xhd45PB8cCWC2JDvgpaAql6w+ZNbfH1lJvfuDLr9VcXfQ9NvKY8qzgF4NhdPbEngJKs9Uae+eaVrdgUr/CWKywp4Snn6kXuuTtxFlKZ6UFdmCfvUHn6CsJeoUCIS1FFuIaeGtd+0M/JFef2yuxkrlrdvLMEiPFT9K3/tleCHCnxzfdcNu1Ql8wlspHHbxTvAX3jTR8EXjBH3huRAP3wpO0NOeCK919GkPbps9MbGln3zsTjujVgXCh0FWkS/HbGO9d0pyY+4EC0d/ou/x5xAEX0vC1YbK3rPDTPtE6Jxqk103pUQjczrd408mgXabIS9q4xPY4dpkjtIWOLfqx/xzO/Vt9069el/pFsM+/JfZffg4R+F8jtIf+5z5MIqiee3SZH5+QLv07etf6D/T/RwaEkk1YbxrgAQ/b3+8oqGebjugUoh6TfLPnpmZ1va0Pda/0PUE8fwrdfM/uVKJ428GQd8ZftRvBqPfEjm1hC7fzKua5NR+s7kBYH8DGEVLvqtSjAg4u6Xd3RvvkIL+Ra4AEqJl3QVna2G/rT3PavEwAkaPuVvGnfsABzjGwQrfhzAKcWRHEU4Pshhf4xBGEcxCLxPZoREbYQwLE7swARlcntgOI9hjhPAXRpEdwXRk94AA39jpm154A0IYmqW3IE2tMDXChV0K/2BtYsUwBoPDdmxMhnHcjmNjg5Vbc1tA8w8HxiLw26Qd4K3/SQ4jyIjKkpVch2mcpkmchrfX8WK//wc6qGmS

Copy blueprint

On the left, the flow starts. It first iterates over all qualities with the counter C and applies the qualities to the item to inspect one after the other.
The qualified item is given as recipe and the ingredients read back. The ingredients are subtracted from the stock (the constant combinator on the top), and if everything is still positive, there are enough ingredients available.
The combinator on the next to last column is collecting the items that pass the test during one full clock iteration from 0 to 4.
And the 2 combinators on the last column is a memory cell that stores the collected items when C=4, which is the moment all qualities were iterated over.

The 3 +0 combinators behind the quality transfer combinator are for latency compensation, so the correct quality recipe item is available at the same tick as ingredients are checked for availability.

If you transfer the quality to the ingredients instead of transferring it to the recipe item, you can get rid of these 3 combinators, but it's technically not a correct solution, because it gives wrong results if balancing changes take place that require a different amount of ingredients for different qualities. Unlikely as game update, but could happen.

If you want to process a list of recipes instead of just one, you need another counting loop that iterates over this list, switching from item to item every 5 ticks instead of every tick. You need to change the "set" condition for the final memory cell to the additional counter variable instead of the current C, because you want to set the memory cell the moment all items with all qualities were processed completely. This outer loop is probably 2 additional combinators, one for the counter itself and one for a selector combinator to pick the corresponding item.

[Aricitic]

I would like to capture, once and only once, the ingredients I need to simply pass a simple check of whether I have them or not.

With all qualities. Something like this? It inputs one item (here: green circuit) and outputs all qualities of this item with enough quality ingredients in stock.

12-19-2024, 00-26-08.png

0eNrlWc1u4zYQfhWB11KB9ZdEBnLqEyx66CE1BFqiE2IlUiUpZ43AD7Bv0UtfbJ+kQ8qyLEeJRW2T3aKXhB6S38x8Q84M7We0LhtaS8Y1Wj4jlguu0PL+GSn2wElpZJxUFC0RUYpW65LxB78i+SPj1I/QHiPGC/oFLYM9HtlU0JwVVPq5qNaMEy3kyZZwv8KIcs00o61S+2GX8aZaUwmYuMMxZmnC9SkQRrVQsFdwo9DgxVcJRju09KM4uUpAUcEkzdsVMTYgWooyW9NHsmWAANtUO6+GYzClcwujDSs1lefSo2F1bfwj65KCRX82pAQPYIILWQEVRmtVE2ktXqI7K2gM2eHCMNZRcQRkUnC/Lol2hAtO4aIjnNKUlnPwksV+NTRwHg8NBw0VROB1VU5ETMALhqZHc02XRNK31LiYfRHr1OJ4rsW0ZvkbWqLIxeQLYG7n7QLY2WlL5hJQ0gfKCyJ3b+lyIWEKoAnear83sGcJrIcfSYQv81fQZa/FefYKwvH0dYDNYK5gx0R2+gno2zCpdNbnZr2rjUlbJnVjc0AXO7vC/9Wk6C7hwmE0WVo0um70eWWYBlTvMktUtpGiyhgHILTckFLRYcm4jPYKy/3pG61RL3mO+joRWKbHK4POgH9mjNKyoRhJSgqw/0HSgoEJqpXvzUS7DNESAgYHieV+zmTeMI262ezsLoz4Efd+SKYfK6oNzlsH5vrVA/NKueuBz46M4xmhwK6JLpRMgHHfJ+D6ktZS5KPufLnjnJqdcaqfhPxs/YEYdWGDeFF+PHFDk1/uscuOm2yARw9d4na1b10j9R43m26p3Gm4Fg/tzTxJZ9++/o1m0Dk7NwxNmRSF8ct/7RSHaPEzxOE8w14ifoSNLnw0O+givEDvFY3RwI9G48YtGuHPGY0Xhd45PB8cCWC2JDvgpaAql6w+ZNbfH1lJvfuDLr9VcXfQ9NvKY8qzgF4NhdPbEngJKs9Uae+eaVrdgUr/CWKywp4Snn6kXuuTtxFlKZ6UFdmCfvUHn6CsJeoUCIS1FFuIaeGtd+0M/JFef2yuxkrlrdvLMEiPFT9K3/tleCHCnxzfdcNu1Ql8wlspHHbxTvAX3jTR8EXjBH3huRAP3wpO0NOeCK919GkPbps9MbGln3zsTjujVgXCh0FWkS/HbGO9d0pyY+4EC0d/ou/x5xAEX0vC1YbK3rPDTPtE6Jxqk103pUQjczrd408mgXabIS9q4xPY4dpkjtIWOLfqx/xzO/Vt9069el/pFsM+/JfZffg4R+F8jtIf+5z5MIqiee3SZH5+QLv07etf6D/T/RwaEkk1YbxrgAQ/b3+8oqGebjugUoh6TfLPnpmZ1va0Pda/0PUE8fwrdfM/uVKJ428GQd8ZftRvBqPfEjm1hC7fzKua5NR+s7kBYH8DGEVLvqtSjAg4u6Xd3RvvkIL+Ra4AEqJl3QVna2G/rT3PavEwAkaPuVvGnfsABzjGwQrfhzAKcWRHEU4Pshhf4xBGEcxCLxPZoREbYQwLE7swARlcntgOI9hjhPAXRpEdwXRk94AA39jpm154A0IYmqW3IE2tMDXChV0K/2BtYsUwBoPDdmxMhnHcjmNjg5Vbc1tA8w8HxiLw26Qd4K3/SQ4jyIjKkpVch2mcpkmchrfX8WK//wc6qGmS

Copy blueprint

On the left, the flow starts. It first iterates over all qualities with the counter C and applies the qualities to the item to inspect one after the other.
The qualified item is given as recipe and the ingredients read back. The ingredients are subtracted from the stock (the constant combinator on the top), and if everything is still positive, there are enough ingredients available.
The combinator on the next to last column is collecting the items that pass the test during one full clock iteration from 0 to 4.
And the 2 combinators on the last column is a memory cell that stores the collected items when C=4, which is the moment all qualities were iterated over.

The 3 +0 combinators behind the quality transfer combinator are for latency compensation, so the correct quality recipe item is available at the same tick as ingredients are checked for availability.

If you transfer the quality to the ingredients instead of transferring it to the recipe item, you can get rid of these 3 combinators, but it's technically not a correct solution, because it gives wrong results if balancing changes take place that require a different amount of ingredients for different qualities. Unlikely as game update, but could happen.

If you want to process a list of recipes instead of just one, you need another counting loop that iterates over this list, switching from item to item every 5 ticks instead of every tick. You need to change the "set" condition for the final memory cell to the additional counter variable instead of the current C, because you want to set the memory cell the moment all items with all qualities were processed completely. This outer loop is probably 2 additional combinators, one for the counter itself and one for a selector combinator to pick the corresponding item.

Well, that's a heck of a lot smaller than what I had setup... Can't say I'm surprised though...

I'm not able to input the blueprint at the moment, so let me ask what I hope is a simple question: how on earth did you get it to "store" the information without endlessly increasing the count? That's the main problem I always had. A latch would always endlessly count up, or wouldn't store it...

[Tertius]

This is the memory cell:

combinator_16229000_416x224.png (46.96 KiB) Viewed 673 times

0eNrdmd1u2jAUx18l8rWDmi++JC62anebJm0X08QQCokBq8bObAeGqjzA3mLPtifZccJHykqpUVBpb5A5Tn7n5J/zTw7tPZqwnGSSco3694gmgivUH94jRWc8ZibG4wVBfWR2dMy1m4jFhPJYC4kKjChPyS/U94oRRoRrqimpAOWX9ZjniwmRcAB+CoRRJhScK7jJCLyw24owWqO+G3TDVgSJUipJUh0RYgPRUrDxhMzjJQUCnKaqffVwDaVsa8RoSpkm8jC6KUxpwQmU8jOPGZQOES7kAkQw6RZZLMtS+2hQBnKjmFfgHcjfgagU3BXSkuXXWEFNrSwj0p4W1Gigl15nhjZlOU3RDr6KQQ07bljjRse4icxT4grK7NhRjd0+xmZ0Ntf2bLd+qzo7+JJKnZcnbpug7Hv3nR29U4N3T8Lf28G7NXjvJPzWDt4zxo3BLEtgTGOmSDEqCpPxwMD++QaOrtjAjTq4YQtfzMMXNfFlXXxZG79qHx8x7r4RU5LQFDrxKd9Gnu1rd0Mdw15Kd/6tfwOvTqlUerwfKk5c/FczWjy41L+//yD8ADPmRK+EvCvTSZJuHl8YzSQhUK6WOSnM003kOsv14VhzogKyJHKt55TPTCn/pTLwXabqsWnkBzlZvAYxUqISSbNKOPRtThlxhptcbpVisL3WkUOVUwKdLFbKWcYwkilnKsXCGVJNFgNI6a7gRoywo4Sj58SprsmZCsbESpUhyiHS+sGfkawSqg6CYCbFEm5k6kzW1Q58SGffKy30SHOF578Vgku/FU72mOWod8xg0ZkGC67KYIM3ba9Nx0uiY8q3DhP80F9OmhNHVxZjQmSTOLlzzM7zfFWZuAFbtfd6QVeCXAx6RNLEzQQjj/RUZ28rH7rqEWLH0qi9PdF7YaN+aMqo3fMfVi+twaemNOjZaRB516PB56Y08G4sRbh5g43gWf5FJgquR4TvjYlg+as28q9HhC+NiRBYihBdjwi3jYlgOcnWX7kvLcLHxkSILEVov8EpwWtbitB99Z0AU7wZck2yoYc97GNvhMtVUK4CiETYL1cBrAJYhbtYBMdVMfjEbTgDeGauhmT7/y5gBCO/KkWJ2n4v7PWisOd32+FNUfwDI3E5hw==

Copy blueprint

The top combinator passes the incoming signal while S<>0 (or while whatever set condition you define is true) to the output.
The bottom combinator has the output looped back to the input and passes the signal while S=0 (or while whatever set condition you define is false).
So there is always exactly one combinator outputting the signal: either the top or the bottom but never none and never both. The bottom actually stores the signals, while the top keeps it for the set operation.
This 2 combinator memory cell variant became possible with 2.0 because of the distinct handling of red and green wire.

12-20-2024, 10-22-10.png (279.91 KiB) Viewed 670 times

[Aricitic]

Ok, I think I see what I was doing wrong with my setup(s). I always did "If 'each' - blah, blah - -> return 'each'". It never occurred to me that I could simply return everything. I "believed" I had tried to do something similar, but it wouldn't allow me to pass out an argument I hadn't taken in, i.e. each -> each, anything -> anything, etc -> etc.

Thank you for the information.


(however, I still think some form of encapsulation would be useful, and I had other examples, which a "smart" person would have written down... I, uh... did not... I'll reply with them if/when I think of them again.)

[eugenekay]

You could implement Code Division Multiple Access over a set of Combinators (implementing Walsh codes and Matrix multiplication would be fuuuun!) if you need to have Simultaneous overlapping signals on one Wire; or possibly Time Division Multiple Access using several Decider Combinators and a “Clock signal” to indicate which channel is currently active.

[Aricitic]

You could implement Code Division Multiple Access over a set of Combinators (implementing Walsh codes and Matrix multiplication would be fuuuun!) if you need to have Simultaneous overlapping signals on one Wire; or possibly Time Division Multiple Access using several Decider Combinators and a “Clock signal” to indicate which channel is currently active.

Oh. I'm aware of Bit Manipulation. I vaguely recall that the Arithmetic Combinator has this already, I'd check but Factorio is updating (and I restarted recently and haven't gotten that technology yet... /cry).

Honestly, for almost any problem, Factorio already has a solution. The request is less about "Here is a problem with no solution..." and more about "Here is a solution that is easier and more compact than already exists."

For example: Say you want to count how many asteroid chunks are on a belt or in the Space Platform inventory. Currently, you require 2 to 4 arithmetic combinators to count the combinations - A+B = C and C+D = E (plus one for each other thing needed to count, say ammo, etc), where A, B, and D are asteroid chunks and C and E are alternative signals. But this ONLY gives you the grand total, not the sum of each asteroid, so if you need that AS WELL, you have to have a new signal for that (which, honestly, is easy, so it is a "bad example" but it 'provides' my point).

Ok, how about this instead, you need to know how many asteroid chunks you have in total, but for each quality (since these react and process differently to one another and per quality level). Same as above, but much more than 4 combinators and the signals get mixed much more easily.
Yes, you could certainly shove them all into "A", "B", "C" (etc) and be done with it... but then you have to remember what these signals are... <- THIS could be resolved by allowing signals: "Greater than," "Less than" (etc) as separate signals. And that WOULD BE a solution to what I'm asking for... Point in fact, actually, this already exists for many things, including inserters AND splitters. You can actually just state "quality 'is greater than common'" for a splitter.

EDIT: Ok, about 10+ days later I realized you weren't talking about "Bit Manipulation" and now I feel stupid (again)... I'll check into those, but I still feel that there is a need to have tunnels for this kind of stuff. Like: If a processor can do it IRL why can't a thing the size of a person do it in game?

[Muche]

My usual solution for summing arbitrary number of signals is one constant combinator listing all signals of interest with value 1, then one arithmetic combinator with Each[R-storage] * Each[G-constantcombinator] -> A.
Outputting Each instead of A works as a signal filter.
Yes, setting all quality levels of interested signals is tedious, but can utilize logistic sections/groups now, so needs to be done only once.

[Aricitic]

My usual solution for summing arbitrary number of signals is one constant combinator listing all signals of interest with value 1, then one arithmetic combinator with Each[R-storage] * Each[G-constantcombinator] -> A.
Outputting Each instead of A works as a signal filter.
Yes, setting all quality levels of interested signals is tedious, but can utilize logistic sections/groups now, so needs to be done only once.

I need to better understand this, if you'd be so kind.

My current goal with signal compression would, as previously stated, be easily resolved with a signal for each type of recipe. If we had some way of distinguishing between recipe and ingredient then I would have to find a new reason for this to be relevant.

What you are suggesting, if I understand it correctly -- which I may not be since I stayed home sick and it's late -- is unambiguous. What I need is ambiguous. I need something that could yield a result for anything, not just for what I specifically list.

No. I'm not trying to make a machine that crafts anything for me with no work -- I could ask for a mod for that... but a machine that I can place and specify, once, what I want it to craft, then it tells Requester or Buffer chests to collect the ingredients for the unlocked qualities.

-- Again, restarted and am still not to any other planet yet, so focusing on that for now, therefore I don't have any examples of what I *had* been doing as of now.

[Muche]

Here is a blueprint with assortment of circuits. Maybe some of them will be of use for you

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

Copy blueprint

[Aricitic]

Here is a blueprint with assortment of circuits. Maybe some of them will be of use for you

0eNrtXd1v47gR/1cWBvpylbcW9R20BTZpH+6tKO7hgG1gyDZtqydLrj6SzS3yv3dIxpYsK7JI2lb2PHfAekJRo+FwyB85JIffR7O4pNssSorR3fdRNE+TfHT39fsoj1ZJGLO0JNzQ0d0ozHO6mcVRshpvwvk6SujYGr0aoyhZ0G+jO/PVaHkppzGdF2k2nqebWZSEQNbeIa3vLKJ8G4cv422Y0LiW25LKbb8+GiOaFFERUVEi/sfLNCk3M5qBwEY7C2O0TXN4K03YV4CT63x2jNELiGvbnx34wiLKoFA8g2+MQGNFlsbTGV2HTxGUD97ahhmwLmgmvgxZFnuOyyjLi2lVjuJly4R4irKiDNnnd6rjOcZRskxZsVjFFCGrJXMymbC/N+wrTKF3o7+OXplydL7zjz4fMbiB9OA2ObtARE8g8+wCWXoCkbMLZOsJZJ1dIEdPIPvsArl6AjlnF8jTE8g9u0C+nkDe2QUK9ATyL9Ix6kgU6Eu0Wqd50eiMGhL9rUUigX8Vt+dyRsdxukrH+Tac0zFgYLFMsw17taDfgOvon1mWZp+i5aec0uTzf5J/xZBxncYLmn2CrJ/2OBf9HvLCvD7Cy2H8HL7k03ydPo/uiqykrMAN9CW90df9cOh7fvB96PGNa2LvwxH2Dgu9D0fQOyzyPhwh77DA+3AEvMPi7sMR7g4Luw9HsDss6j4coe6woPtwBLrDYu7DWScjl4Fc8qNBrtUbcr2PBrnnR9z705+4JuDeNwF3WLy9b+LtsHB734TbYdH2vom2w4LtfRNsh8Xa+ybWDgu1902oHRZp75tIOyzQ3p9z4nEZnDV/NJy1e+Os/7Fw9gIw+6W7Lq+Msl+6R3BXBtkv3S6cK2NsQxp7WIhtSOMMi7ANadxhAbYhjTcsvjak8YeF14Y0wbDo+uWMk4zLgOvkRwNXZy/GrhD1peUjiPUme4h1mhBrt0NsLp7nhzSA7W6h2wC9x3sIrlJPGoMx+h88YLq8GyWgMJ6poX6WUApjYaXfLZQbpwdyktzr7C3jtENGln2dv22cXmSR5j9hNlPXkFKt8FGQ1LeJaXu2b7k2dLyb8Nv0KBnkenx9bbFdd//xMIuKNTSAaH7Cet8bHpqk3XgrxtN9T5ErdBW/ssYM1g88+r9Ew/mavZduaSaa9d3oT5ArLYttWcjzqcs8TWjxnGa/8cJkdDG6W4ZxTo3RKoMuZtddHIp8/A7LtX+FM3htrSmv7xDes4YcwofJS7GOklV3n/53CZSpOPbukX1pq3aHsuqdYZ3DsH9SMOxfT1t1i4WetOqWltBq1cFeHr4rK4N6ognNVi/QC4I9LgGjW2or2OEnCDIrl0uagSC/07dOWPzX8jE22JHeX+Xh/ircX4X7q3B/Fe6vwv1VuL9KY55sqmxvdhF+EX4RfhF+EX4RfhF+deCXKGy28nCzFW62ws1WuNkKN1vhZivcbNUPaC2Fg0QeHiTCg0R4kAgPEuFBIjxIhAeJpDHXVpjcuji5xcktTm5xcouTW5zc4uS2H9A6CpNbFye3OLnFyS1ObnFyi5NbnNxKY66rcHzXw+O7eHwXj+/i8V08vovHd/H4bge6egro6iK6IroiuiK6IroiuiK6dqCrrxxhwMMIA1eNMGAGylXlYlVdtarIRCEahHej0SCIqaAs91aVRaQ7ATJUJ9CInXGgs3ob/7NaXIz2lmcp68e7Cf1UG7HaLlo61o4jaz11ycUnRsYbMd2E33adKA+3VC9zq7SOorTehaU1W6V1JSONdazAnzvS2JtcUZYmfIBJJaNnHcbN2pdyC+rT5Ve12LygNNZlVxk4MMpZ65+FmTq7mgWW8bLU4FS3Dv6SIh+vpq80kdZUrxBo3eZSJsB+A2Z6NoOR5HjaZCQZnjYaSYadZiPJq8NwJDl1mU4vVo+HlaBiPFmY0fMZjgS300Yjwey0wUgw6zQWCT4dhiLBpctITrJ5PNSRioHQbTQ/n4FIcDttIBLMThuIBLNOA5Hg02EgEly6DOQkm8fDYqkYSExXNFmE2cv5rESW5WlTkeV42l5kOXYajSyzDsuRZdVlPv14vRctldRYlzMYgPOx9PvxCb1WJr7cKN4n0k4J3VF8kYVJvk2zYjyjcXGOkXwJCdkqgywLTZ61lrGF96EQ5xjKR0lOMy1eVWuI02Q1XoeQvBjr860axhKa7RkYeofd34qG2fh5TanGjMFvdoDzcBZrTLGaUUHThPlYomxeRhqWUwv/uaGLqNyM9zFHt6mOuLXAZrNodTaupL2zUWVXNZxttNWRyz5gNC7SsWjYGiyrxrMtN1sNRlVrycJIw6Jrm0KgM4ySMUCJjlz+gVzjNzebOr+g1tvAC2kRPel4XKqWMQ+zVTp+Dlc6tlbzuC/jMlpo8yO14q4iPnrJ0lmqA03WIQpnJYdJbba1xhHmOdTKeJulT9GCdYprmuuwdurjmixcUW2OVWvJ4a14HIc6ja82OnrPNa7K2T/hplXlG5wYiqmOUd5fnlPlWIOYNIp18N8i9blFCCiYrKJEx79aG5KlMYwmdMtataFwPi83ZaxZG1XDScp5zMY7GQ3nejyrprOmYTHWg1TLO+RGv81h/LjSqmW/UctFmc30qrklVvsmSiIY7C6yKNaocLtqLulyma/TDHpNrXGAbR4MKP4bzn/TYEaOCw7T3UTEpldlWltHzHO6mcVMkZtwvoZKGpsajO0uxkSDsdPF2NJgXLUl6NqgbS6BIZ+hqzKsmhMg5Caah9yBkmhApV2b4sB8PouW5Uqn9mvjt3CmMemcHHQcrEKK9FlrGlsDGugkdUZtDjmcabJhm0YzdGotZvEUJnOYXmvPCZ3aeC1L5xSGbKDDMtHiWTUUAa26/Ny2SzLOwdirDdNfWMH56He8ZFtaLrnsxz0ZHU4m5fU/zrjT16S8EMhZt7qclJcC6bdtBhbXpQmlRZ4d305FKC377Di36kGCY81jcl70qzlNTjKWrDdTArFlVGH3ZyuxhmI6/dnKOthrXpbzDjFqXpeTjGVrz+/PWqb2gv5sZdYdJ/3ZSq9WmRcaxxHSn7FsD2/1Zy2z/m/3ZytTexIjZc0FqUDhSo0Ar9TAKzXwSg28UgOv1MArNfBKDY3DbZbKhZI+wi/CL8Ivwi/CL8Ivwq8O/JoKQb8DDPqNQb8x6DcG/cag3xj0G4N+9wNaohD0O8Cg3xj0G4N+Y9BvDPqNQb8x6Lc05qrcIukj5iLmIuYi5iLmIuYi5kpjrsotkj46lNGhjA5ldCijQxkdyuhQ7ge0jsKdGwHeuYF3buCdG3jnBt65gXdu4J0bHeiqcl+kj+iK6IroiuiK6Iroiujaga6e8jVJAV6TdNVrkiz1y8d8rKrrVlWgcElTcKOXNNkq13/5t6osU/nGJv8Wbmyy1W/8Cm5CP5biHVH+he+IIq3Sqt6/FVxYWqtVWkfa9rwP0ja1MPqni2F0C96exOgWXG9vCe6puDbNqwvMBlS3X1ZQTKESWQDVN+kzGi6mwBqEi0CEfD/W2GV7LyiSeD5tCTPUVpre9777Vo9i/OFg05frSGpK8nuNM+rtIQuTRbphNciJabldhAUFGwB9PjGdWZPW+/tqcTQXUPc8ynaXjI6kjG9MGx1H/a+v0rX7S8OxFLw+7joDwU+W0/ZlygNFTZcZqC5KgNG+6ctxeyfKVC3KaC8t184ADa3lQ8eCqqJ/PqnodxRnyscHcUyMD4LxQTA+CMYHwfggGB8E44NoeOodogC/E4RfhF+EX4RfhF+EX4RfHfi15E9TfZTZL56mwtNUeJoKT1PhaSo8TfXxgdaWDxXyYdzMGCoEQ4VgqBAMFYKhQjBUyI+EuY4C5k4QcxFzEXMRcxFzEXMRc6Ux11VwKE/QoYwOZXQoo0MZHcroUEaHcj+g9eQDiHwMhzIGEMEAIhhABAOIYAARDCDyYdHVV0DXCaIroiuiK6IroiuiK6JrB7oGqjGfjmewGPPpojGf3IlyVU2wqq5bVaZ8xKkhPEIfInSGSxSUNblVZVmq4aeu3wkMEX7KtZX1Y96Efhy1gFf9rUcx4JXdKq2rKK15YWmdVmmrdYBdzu7IL/LL7rl4nh/S0LFxAblDYBnF++6uSj05sjZGVRyoBEafPFNjLMsSSjHyZh3Wnj9R/Cp3mUh9mJi2Z/uWy6JRQfVMj5JBrvbgMq6vcLqd4Ol2PN2Op9vxdDuebsfT7Xi6XcPP5AYKBwAIHgDAAwB4AAAPAOABADwAgAcAZDHXmygcACB4AAAPAOABADwAgAcA8AAAHgDoB7SmwhZFglsUcYsiblHELYq4RRG3KOIWxQ50Jcr73gjue7vqvjfPUtjKRW50K5envlWJ3MJWJU91qxK58OYft1VaV/5uvn0TsHo1gI94Nd9flPup9jrvfZTaCyrt3cwtc57kLXM1JRHpW+YkWkTrbXNe7yVff3KDden39s5X90LeknpMyQsVzeuYeus1sj6RFHZyHWHNVmF7D9J8couGZ8tfdHpL6nFULzq9rKm37h/3JfeP1wz+osK23u7s979h17lFw5O9Yde5ZF3KXIbaWtn9B0fedSsbFwlwkQAXCXCRABcJcJHgx1kkCFQvXe85OLjEpes/H3Vm0p57nTva3zkoF5iyjszaCIVc1ZH5822vtgRE2RvoXN0bGFjKLhLn6i6SwFZ2PjlXdz4FjvIk17n6JDdwld0HztXdB4GnPOV0Pt6UM/AV1lbcm/EvBCrLFbejHr5RVHq94pb0Yyq41W9JP0TBr35L+rEU3L9/VP3AtOYZ0JPJ/tU0CPv/0fjKfi1Owb+GzSn413ANGyjHMIEy3ygz4KQLjz2eEf41fJ7Rh8e2wx/7jLPLn8MsnBimYG+yb5qOoEktndNv+e1aHk6L77DHhim+xJKYJJz2K6k4bfk7GrhaIk/AaMJpMhHpZE87It0UecietkW6DTyJKBb7MWxL0EweW8hJ2LdsX9DsW5bgYzH+1ptqzVo6p8W77LFhCaWzH8MSemCPDcvjMrAkVi5Oe1UZOe1OdjTIIMpocXlMQQcinexpUS57IvKQPS10xYrH8ph72jEsRjM9uEIPrJYNT8hgg20YvrOjuR44HyYb0Pxd/l1RX/BjGYGQmSUZzoTLAD82S+c0048jdOIw23CErhyrls5pYRvsseEIvbEfwxF1wR4bjvguS2K64nRQ6Y3THtnRkEfox2U6cYVOXFOkkz0tmoZLRB6yp4UtubzNiEbDfgxP6MdlOglMQXN5AvEu+64nys5+DE/UC/thsjGeHuPvCdk8S9BkT4vvem5VL0CDnkW5PE+ks7pgjw3/LT0QNEv3J4w2BW1WeQQtyuJbguZ5bFHvnHZqeTgtZPA9QfM8rLyB0L/PyhsI+2RVvksPuA2Isgta1C8rhhGIdhewvioQ/FmSEdg7GtJFP8CSjMDZ0ZBrIiqbpRmBu6PZA1EbLI197Y1mD0TxIY39wb4NnWdU0A10t7O4pNssSti0Ig5nACZ3o3+HySLdfIKpSbSln0Lojl/yKIcMT4AVHCAclwR2EDgO4ItFYIL8f2mrux8=

Copy blueprint

Sorry for the extremely late reply, but I finally got around to importing that blueprint. Um, I can vaguely see what it's supposed to do, but would you be so kind as to explain?

[Khazul]

I have long thought that ingredients and results of a recipe should be handled by a combinator. It would actually be a good extra function on the selector combinator along with an ingredient ordered means of indexing (ingredient by index and result by index) as the current indexing is based on the amount which makes it impossible to match fluids to machine inputs/outputs automatically. Also there is no current way to read additional results.

Would such a combinator solve your problem?

[Muche]

Here is a blueprint with assortment of circuits. Maybe some of them will be of use for you

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

Copy blueprint

Sorry for the extremely late reply, but I finally got around to importing that blueprint. Um, I can vaguely see what it's supposed to do, but would you be so kind as to explain?

Under the AM3 there are two ways how to isolate a signal - indexed by the value, and indexed by the signalID.
To the right is similar indexing, this time the index is not static, but dynamic based on signal I (+timer to cycle its value).
To the left is isolating a subset of signals, based on constant combinator.
On the top left it's getting a sum of values of the same subset of signals.
And on the very left it's just display of signal values, for debugging/demo purposes.

[Aricitic]

Under the AM3 there are two ways how to isolate a signal - indexed by the value, and indexed by the signalID.
To the right is similar indexing, this time the index is not static, but dynamic based on signal I (+timer to cycle its value).
To the left is isolating a subset of signals, based on constant combinator.
On the top left it's getting a sum of values of the same subset of signals.
And on the very left it's just display of signal values, for debugging/demo purposes.

Ok, thank you for the explanation. I'll take a closer look into it, should be useful for what I'm trying to do.