Circuits/dynamic mall: Get the 10 (largest) signals from a list of signals

[Tertius]

I'm looking for a general handling of "return n signals from an arbitrary number of signals".
I don't care if these are the n largest signals or the n smallest signals or whatever sorting it is - just n out of an arbitrary number of signals with random values. The n largest would be fine, but this isn't a requirement. Just not more than n.

If this is possible with a small and constant number of combinators I would use it, otherwise I need to find a different approach and not use such functionality at all.
I also want a direct result, not the result of a loop over all items, since this would create an unknown and possibly huge amount of latency.

A possible solution for n=10 would be to build 10 selector combinators and each one picks the 0th, the 1th, the 2nd ... the 9th largest signal, and all signals are added again to get all 10 largest signals. However, this hardcodes the number of combinators, and it requires quite many combinators. Is there a smaller solution? Some kind of array slice functionality? Keep in mind the input signals and their values are stable but random.


This is for creating a mall with dynamic recipes including dependent ingredients. I want it to build a given amount of different items in parallel, but need to limit to for example not more than 5 or may be 10 different items, otherwise all machines could be occupied with building the requests and no machine is left for building the dependent ingredients, so nothing is being built at all.

My idea is to have list of (up to) n items to build. And I have a list of m assembling machines, for example 30. Each assembling machine gets a selector combinator that picks the 0th, 1th, ... 29th item from the list of items to build.
The initial list will contain up to n items all with value=1. These are set as recipe in the first n assembling machines.
Now the ingredients are read from the machines. They are normalized to value=1 and all items already present in the initial list removed, as well as bulk items manufactured elsewhere (plates, green/red/blue chips etc.).
The values in the initial list is increased by 1 (EACH+1), and the normalized+filtered ingredients added. This is the new list of items to build. This way the sorting is kept stable, so the recipes already set don't change, and just new items are added at the end of the list.
Now more assembling machines get a recipe from their corresponding selector combinator.
And their recipes are also being read, processed and the list of items to build extended.
And so on, until there are no more dependent items are added.

This must be running on a timer that runs from 0...3600 or 0..7200 (one or 2 minutes). On tick 0, the list of items is reset and initially set again with the currently requested items, so recipes are being flushed whose item demand has been satisfied. Then the machines will build their stuff for 1 or 2 minutes, then it's reset again. The first few ticks are also needed to perform the EACH+1 in the correct moment when the next tier of ingredients are added to the list.

[Lochar]

The new selector combinator can pull this. Mode of Operation: Select Input. It'll give you the highest one item in the feed on Index 0, then the second highest on Index 1, and down the line.

So if you want the top 10, you'll need 10 combinators.

[Stargateur]

no you would just need to use index 9

[Tertius]

That's unfortunately a solution I already mentioned in the OP - I'm searching for a smaller solution, with less combinators, and may be even where the amount of signals to get is variable and not hardcoded to the number of combinators.

[Lochar]

no you would just need to use index 9

Index 9 just outputs the 10th item in the list. Not items 1-10.

[Lochar]

That's unfortunately a solution I already mentioned in the OP - I'm searching for a smaller solution, with less combinators, and may be even where the amount of signals to get is variable and not hardcoded to the number of combinators.

Arbitrary is extremely hard to match with less combinators. You could try to do something with selector index, dump onto a memory cell and remove that from input X times, and then output that memory cell. Resetting the memory cell would probably require wiring everything up to a power switch to power reset the cell.

[SupplyDepoo]

I can think of a way that would work for 1 to 15 inputs (dynamically) as long as the inputs are less than 32768 (using half of the bits to unique each signal so that a decider combinator can do each < N where N is the output of one selector combinator with index 1-15). It could also be unlimited but without the ability to sort by the input value.

Either way would probably be around ten or slightly more combinators, so you might as well go with the simpler approach of 10 selector combinators, unless you really need the dynamic limit.

Arbitrary is extremely hard to match with less combinators. You could try to do something with selector index, dump onto a memory cell and remove that from input X times, and then output that memory cell. Resetting the memory cell would probably require wiring everything up to a power switch to power reset the cell.

That sounds like it would have delay and not be continuously updating based on the inputs at every game tick. Unless the logic is duplicated enough times so that it could process each tick in parallel, but this is probably going to be more than 10 combinators too. Good idea though.

I don't think de-powering would clear the memory cell, but now that we can add multiple conditions to decider combinators you could have a reset signal that stops the feedback loop.

[Lochar]

Yeah, I'd assume it would be X ticks behind without duplication. You're paying for your gains somewhere.

[Stargateur]

no you would just need to use index 9

Index 9 just outputs the 10th item in the list. Not items 1-10.

ahhhhhh

That's unfortunately a solution I already mentioned in the OP - I'm searching for a smaller solution, with less combinators, and may be even where the amount of signals to get is variable and not hardcoded to the number of combinators.

ooooo, I'm not gonna lie I didn't read everything haha

well easy, use a selector as I said to get the 10th items in the list, use arithmetic to abstract the signal, then use the value to set in a compactor to get all signal >= to this value, bim top 10 signals.

Code: Select all

0eNqlll1u2zAMx++ix0EpYltKYgN72N53gqAwHIdthdqSJ8vpgsAH2D12sp1klPJhNTCqCnuTKfFH8k+J8InsmgE6LaQhxYmIWsmeFNsT6cWzrBprk1ULpCCVFualBSPqRa3anZCVUZqMlAi5h1+kSEY647WHWuxBz7uk4yMlII0wAs5R3cexlEO7A41MeuW0sBdDu4AGaqMxhU41QCjpVI/OStqINodN+sApOZJikSTLBz7anO6Y6Y3ZO5p6l9wMMpuQWCNBhYxWTbmDl+og0AXPqQ50dXa6UBF0XpRthZSnqunhUndpNTaVFTyfSzCjH0s+kyILpzixbPy98+/txpPQvSmnxpljZ2MfhDYDWia13IkFVPWLbWEPFuPVgr3yZfiCnmow3RDB/kHGcU4RRj+4TjNy8LAcF9CdFv7X9n+liSnbJtl2lXYVFeTv7z94yg9fSjBvSr+6NDXsSWH0gDfqWQPIy/0a7XM6a37/hj+Z+eeCzPaI35jXKxFo0vRSlzm+1Pk2oZS35kxrLO06dKxKjQF9bw0UnKDlJ25gBWiUSrfu0LsmfHWGwd1tW/B1aAXhaRw89eBZEJ7FwTMPzoJwFgdnHpwH4TwOzj34KghfxcFXHnwdhK/j4GsPvgnCN3HwjQfPg/A8Dp578GQZpH+LfEVLHx9+pN8j8QmOJjuccAq+Ce3+KLYJTSmj7JFuU5pQThO3YjSjKa4yu+dW7LKLvsJAi+Tpv4iSAw4YN7v4Ks1ZnnPGM87SzTj+A9M3EzE=

dynamic N signal

Code: Select all

0eNrFllGOmzAQhu/ix8pZBWNIQOpD+95eIFohAt6NVbCpMdlGEQfoPXqynqRjhyxuhOJYfeibsWc+zz/jGXFG+2ZgneJCo/yMeCVFj/LdGfX8VZSN2RNly1COzIkuhV5Vst1zUWqp0IgRFzX7gfJoxAs+peL60DLNq2UvMj5jxITmmrPLtfbjVIih3TMFWHxFtazmQ7tiDau0Al4nG4Yw6mQPzlKYS00YW/KUYHRC+SqK1k/JaMK6YZJ3Zm9pUrnBLSDjGQkyTSK0kk2xZ4fyyMEF7GTHVHlxmqgAuiyKtgTKS9n0bNJdzHnSp84EcuRKD7AzR2YtVl/RuKQgxvcTvKCB+jXMrAKOa+vfm4MXrnr9eNCsrA6mxj0zmOL6bmwx3Tx9AE856G4IYH8xCVnICH03rFnFa+YraeJPxwS6yYX7tfvX1ITINkG2Xamsohz9/vkLrNzrC8H0m1TfbJiK1SjXaoAn96oYE9MDHE2/XXJ+2+UPRv7YJYs1SvC9UXK379YZtPJymSCV78WZ1yDtOphMlhrN1O2ut/Uw+g4HoAA2hVStNfqrCB/txmDedgail2WnobLJ/5Qdhcm2Y/86zL1wEgYnDjz2wuMweOzAqRdOw+DUgSdeeBIGTxx46oWnYfDUgW+88E0YfOPAt174Ngy+deCZF56FtvcMj9Ze+qfALlq7eH+Tfg7ER9NwguH/xpX909pFmGCK6TPeERzhFEd2RXCCiV1RHNtVbKzsik52QOGatXDH/OuI0RFGjZ1iSUoymmUJTeKEku04/gHqBHPF

[SupplyDepoo]

well easy, use a selector as I said to get the 10th items in the list, use arithmetic to abstract the signal, then use the value to set in a compactor to get all signal >= to this value, bim top 10 signals.

Only if those signals have unique values, otherwise >= will select more than 10 signals.

[Stargateur]

well easy, use a selector as I said to get the 10th items in the list, use arithmetic to abstract the signal, then use the value to set in a compactor to get all signal >= to this value, bim top 10 signals.

Only if those signals have unique values, otherwise >= will select more than 10 signals.

MmM, I don't think there is simple solution to this problem then. But my solution unless you really need exactly N should be "good enough".

[Tertius]

well easy, use a selector as I said to get the 10th items in the list, use arithmetic to abstract the signal, then use the value to set in a compactor to get all signal >= to this value, bim top 10 signals.

Nice idea. This kind of direct solution is what I was searching for. If the flaw with the non-unique values is a problem, is yet to be seen. Not necessarily a problem for my use case.

[jdrexler75]

Only if those signals have unique values, otherwise >= will select more than 10 signals.

They don't all need unique values. But the "10 largest signals" selection is undefined if #10 and #11 have the same value. No amount of combinators will fix that... without adding a second-level sorting order.

But yeah, depending on use-case, "less or equal to #10" (may return more up to all signals) or "less than #11" (may return fewer to no signals) are both easily achievable with this solution and may do the trick. Getting exactly ten signals will be hard, when you consider edge cases like "all signals have the same value". Which ones should it even pick‽

[Stargateur]

There is another problem if there is less than N signal, no signals will be outputted. Thus I think add a `or M == 0` to the decider combinator should solve this

[SupplyDepoo]

Getting exactly ten signals will be hard, when you consider edge cases like "all signals have the same value". Which ones should it even pick‽

My idea was to have a constant combinator that gives each possible signal a unique value, then that is added to the input (on the lower 15 bits), fed through a selector, then through a decider with >= and then back to the input values, thanks to the ability to select which input wire colour to use on combinators.

[Khagan]

well easy, use a selector as I said to get the 10th items in the list, use arithmetic to abstract the signal, then use the value to set in a compactor to get all signal >= to this value, bim top 10 signals.

Or instead of subtracting the 10th value pulled out by the selector, use a decider to pass through only those that are greater than it. If there are fewer values, the selector will return a null value and the test will automatically be just 'greater than 0'.

[PssX]

There is another problem if there is less than N signal, no signals will be outputted. Thus I think add a `or M == 0` to the decider combinator should solve this

Or use Selector's "Count Inputs" mode to set a max value for N.

[Mitch456]

I have a question for the selector combinators. Could not find anything useful to start learning with.
I followed an older guide with a ton of decider combinators to illustrate my science in the network with colors and display.
However I'd like to improve that, maybe with less combinators and also that the display shows the order descending from most items to least. I tried the blueprint from stargateur but I don't know how to connect the wires to the displays. It shows random numbers I managed to display one item, in another build also orange and blue science (with more selector combinators) but instead of continuing with the other sciences it jumped back to the first science.

Factorio Screenshot 2024.jpg (738.18 KiB) Viewed 159 times

My blueprint is

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

Copy blueprint