Combinator cookbook 2.0

[gGeorg]

This stack size computation is truly great.

I prefer word genius. Well, I did it myself.

I developed a multi wagon supply train loading and unloading station,

Could you post it to other thread ?
I will add my Supply train station, so we could compare other ideas, at work.

[coffee-factorio]

Multi combinator setups

Now to some more complex setups with 2 and more combinators.

Memory cell

Store an arbitrary signal composition.
One combinator passes the incoming signals if the set condition is true, the other one passes the output via loopback as long as the set condition is false. Both combined create a memory cell: either the first combinator sends the outgoing signal or the second one.
The given example stores the incoming signal on red while S<>0 on green and holds it as memory while S=0.

This is quite the convoluted little monster but it is the result of studying this example and doing some reading on Wikipedia.
I was having a signal issue with controlling a circuit for vending machine creation (everyone's favorite past time nowadays, the creation of a single machine unit that will spit out everything).

For a flat dependency object this is trivial. For one that isn't you need 2 sets of stars to align: objects in good sorted (which the game thankfully provides) and smooth data flow with memory. You also need a few circuit conditions which I have rigged up to a train and infinite chests which let me obfuscate the really fun jobs of workspace cleanup, because the data flow part was rough.

Of course I do this because I like space platforms, and while I can't rain down cargo pods on arbitrary objects like I should be able to (the biters want bioflux and banana) I can make everything that doesn't take unobtanium like rare earth metals and common stones basically infinite. I also made a mechanically intensive priority queue which I think I can improve dramatically.

Wikipedia noted that you can have a master slave memory cell and that got me excited! You basically just have to have one memory cell feed into another. I then have an enable condition control one part of the cell, and a master condition control the other. The enable driven cell can performs reads whenever it sees an enable, in the example provided it is on a 2 tick period that repeats every 1/6th of a second.

This turned out to be the part that was easy to solve but required practical testing, just using a constant combinator destablizes the memory output and you get a machine that doesn't know what it is doing (and inventory flying everywhere) when recipes need to change.

The hard part was figuring out the various conditions when to raise the master flag that is on a constant combinator - the reset flag is raised at the end of the job. So the slave just grabs whatever input it sees, which could be say, a yellow inserter, when it is enabled by the timer so it has something solid. The master then decides whether or not to pass that information on to based on what it knows - and if it is holding a value it continues to broadcast it.

Done properly a machine will start building red inserters while it can from an assembly line of components, but when it runs out of a logistic item it flips around and begins making those. Once it is done, because the game has things in a sorted order it will restock its supply of a dependent item to the maximum value.

Screenshot 2025-03-16 210022.jpg (38.22 KiB) Viewed 828 times

0eNrtWF9r4zgQ/ypCz3JJnDhNArtwHPuwDwtHr7AP3RIUexxra0s+SU7PlHz3HclumqTetjalLdzRPihjzf/fjEa6o+u8glILaenyjiZgYi1KK5SkS/qNGwuamJxvgaSabwqQlqiUcFJAoXRNYsjzM8qoiJU0dHl1R43YSJ47WZIXgEISiEUCOohVsRaSW6XpDhlkAv/S5Xh3zSgKFVZAw+9/1CtZFWvQuIHdy3EaLJf2UBCjpTKisfaOorxgHp1FjNa4Gs/PIlSEbFarfLWGjG8F8uBGA7HjMcdrVH5vFaOpyNH1U6qtS2fKVmhboZN72xqng29I+Qc/oANIlEoXfhMaXHLtDV7ST55QuXCj8zu2Fx8OVHrRWymjHH3eooyU5wbQip2z4yTyIXsigx2Bn+4Dv/hN2Fs5K/yWiH0CDn+h36nQxq4eUPRsyBtlHho+XI8cP5S4kmBvlb7xmjUkbQgY3WgA9MXqCnwweppx0ZjxKOSOAKuWmcuEuuirypaVPS2XZzTAFnRtMyE3TtUjN5zhey+atLq8Yp5yXmPMjwv7j8P6JTbjWNUyr0mm8sSQhFuO5a4K/AKk1IAJrExT6+Rr6qlF0xr2ySPCEKksyrUMWdRPLCvjd+a4k2w5dhkiLMm4IRnkyakgA/ZYmBdUlWgLGGQ0rQirPJeS4MWQdd1hJO2A86QnnMN3gfNxlo8A9fl1sPMEKv7mKdia/Cl0XGGqgs8+rBhHQxpBJAVI1jy+6YzwtGeEJ+/ZMD5Mj+it+QO3lb+02mLCEl+SF8f1PGIEDSVf7huF5sJAwkitKuwBNSm5uYeZ6YRXNPg8On9DeH3pqNv/MLy4fDVwfc9AInwQTVfCQvHJ8wW3QsO1wxT+5O4gwcNMkhFprG2OMmRxgGzYUHPD1IWx2eAW9g4YO5h5/sfXB29e54ObV/SGwLo8BlY4OC0tQst65W8dKzdMroREQQd3jt/k4dINhQfTaaq0T0ncjiW3AolQ4KoNeLNDKZIruTkjlxkmCf9v3VTrEoQXV3mDw62ENrk/MDt8ncMPup9rlO5M23zw0Dh7y6GRx5kLOF5lUU5/vqdruKOKTlS9rOMMnlBaK1+mpPMqu+j7iPCQx+nrPyK0pqR48QmENKBxT787fDQ6fjdoJTr8B3j8YRMbLvhFTxKtwldRMnlGSQGJqIoAcoyxFnFQqhx6PnmMnMZuaIxHg4/8d+zM49HgckJJLgx9NT/dyp01bqhytlyNWej+rtlVyMZsxiZ+FbJpSwtZ1K4mSHNfJ7ivWU0PVlPkdfsipM09Dfn2tJCds6lfTVods722c/yKiXWf57hceBYktFQ01o2C6OPD2yejeBEyPtHRLFxMF4toNh7Nw/l8t/sFI69GFQ==

Copy blueprint

And about that operations stack.

I realized I could do it in ten minutes.

Screenshot 2025-03-16 210339.jpg (45.96 KiB) Viewed 828 times

Also that you can count inputs with a single decider combinator. The alternative option is to use an advanced circuit.

Anyways -> with a table of priorities and a table of quantities and an inventory (a combinator pretending to be a space platform).
Get the count of all items. When an item is greater than a quantity, output negative 1 (I think they just changed the circuit to output a constant).
When the stack index p matches the priority in the table, output the item associated with that index.

0eNrVWEuO2zgQvQrBNW1YsuTYBjpAkFUwi8kgDczCMQRaKreIliiFpJwYDR1gDjIXm5NMUbL8a6YjK5NBAi1M8VOvqt5jleAnuskqKJWQhi6fqIgLqely9US1eJA8s3OS50CXNBG6zPh+VHIJGa0ZFTKBL3Tp1cy1G2KRgBrFRb4RkptCnR3x6zWjII0wAlq05mUfySrfgEKbrLNj/TFcmnNDjJaFxrOFtIBob7SYjUNG9zjygnGIQHjMqCKLNpDyncAzuFFDbM/oyzGCd4EwuhWZAXU9e3BlAxzNIvqnimfoLU4proBatLzkqvFtSe+aicrmc2pT08V8tMM1YhQiwZCyDP1oIupt0z+zOT2lSVU6hZsMefUaH8yVZRVUlICOlSjbtNIPhsePpMWxiFcEnaJxEO3g55KdRKg2/3QZuLk6WI1wLRFH1s7fkKGtUNpEJ+mZfWk92gllMAn06GK7Y4T0pVaEyD3a6X/uPa0dWbywEkkwnwv12HipIKHLLc80MPqgADBKoyqoreiLypSVub5hPR1/BmLNHjEaxNpS6uDrpJTLa+ygyu9xlWwqcjhelSMvdu1GVrjcm1TIhzbJ7WWny8lVxl831SNuEXpbbPT9LBfB8OIy/YmKSzD5AdUlnPxX5WU2ebG+/FHxrv47KAoHlhf/Jygv17odeusPZafcR01Go60q8khINNTd9a9n9609QZrNevxRfpT3qdAkLrTRJCQrYSC/e57ZNeEyIf5hnSc7LmNAIQkVV8KsiYup2UCmpr9gI3Ay/M9ff1N24UGvZvDNBuKs7T9KSueld+S9IKz7FIhuPg00ZC11JIc45VLofEz+TEGiiPbEKojgGoZC4EsMkGic0yQrHoQ2IiafqsJwnCIxRkOK7bY5ou2ZJuaxS2yvhnQxl9K6TtKlqeQxjNCg2RYqH2GACosoGo8fqauDzG/tICdv+lao/7+feJOJFRhHrB10krvoMC8CfudX7cvg02+AD+hPUxfi14X/jvCccLJqlXB3pZi02qxdgl30F2zQSWTRKKTnt857pz69SX/ccBDu725cb0C8r27BvXfj+gPivQn3gxt3yGf1Tbhv3bhBf9zpINw3btywP643CPc32nS5z1gf7VVfecxjPvPWbOXj74wFzWiKj50LcHV2GPksZD6OQhYc9s1wbo5zaM/2FlsUj391MLrDYtL4G878RbBYhDNvMvfn87r+F00cwXQ=

Copy blueprint

That was pretty fun but I thought to myself: "Well can you do better?" An obvious disadvantage is that if things are done out of order, as they often are, the stack priority breaks. Say you use rare beacons you just built.

Screenshot 2025-03-16 211216.jpg (58.65 KiB) Viewed 828 times

0eNrdWN2OozYUfhXL1yQCEjIJ0vaulfaqO+1UVTUdIQMnwRqwWWNmJxrxAH2L3vTF+iQ9hglMUu8U2Km2qrgxxj7f+fnOZ4snGuc1lIoLTcMnmkKVKF5qLgUN6Xc816CIrDWp+EGwvCJ7JQuiMyC4RSquj0SzOAecYppk7AGIkJrEAILENW5f/ipuMnypIIdEEyZSEivJ0oRVurWT8UMGOO7tdUgDULcTHSKJLGIumJZqSR3KEykqGt4+0W6HcV+wAtDvlFdlzo6LkgnIaYNrRQqPNPSaO4eC0Fxz6La2L8dI1EUMChc4JxPGuGZCLwZQxCxlxbvcPFG0t/A8bxk49GiG/jJAJNynlcyjGDAZGJFZWXX+V+djRD+55dB9m+nL2WdfYmBoFuE/1ixHd3FKMQXUoBUlU61zIX3XTtSmkF7j9Hb83g6mHJTkKcaUm5y2IY226b+wuRrypOoqg0mGVs0dPpgrUyNQ0TnnftQsuScdjkG8qNAQTQoJT0H9U4Hcs/KkXHUFoOHaXqxnsxF+S3lftpdvWKI9V5WOBt7pY2lceuBKYxZo72O3YoH1ywwNsfhoZ/q+s0z++dvv9MJUJEB/kuq+dVVBSsM99io49KCwEWmoVQ2N4T52clnry64Z6cU4kKaxVG3gS9fNcnTZViPLJkvABHUU6jDaJJlBVLDHzr1nIYhOzU1D1+bt2rELicVP92pE/5vaFdD3d88l820ik5g46oyLQ8eKPooLinzTal7SIYy2iLUbdk2QDFsKgy8QUu8/JKRr919Q0sB9KynduK9q6XXNToedpUabuVLq/X+k9A/qnHnwdyXtdONZ41rFa76K+iayPEZt2SNzNYq4QFsnjz5PgRtzg2qP1OEeVUCSMcGrYkl+NnczlADCNRQEv6H/BB4TgLTCuYrk8sArzRPysZaa4RRJMAQi9/t2S2X2tHEubRS7mqWkNn5d6FJVsgQWaFHvpSoWGKHCjkTryb1Vj7ZT9eiFO+5Iun+Fa57rGl4xxHqAnp0v9epVwC+8DxrwcyF7FW3OTdEW3+e5/p6wgjBy29X+3QVHsjq+s3F0N56jwyG1azkx8oj9YKWkkdPRwO4s4B/swN6ErtzOAv7eDuxPAN7NAn5vB15NAN68JfCsq+Rb1DiYALyeBfyLHXgzATiYBXxjB76a08dXU4Cv7cDbOX08CfgnO/BuTjtNAv7WCuy7cwTkDSL2vTntNDliPHI+4WlvzrFbz/HNc+fc+o7nbJxVO1rh4+EoaOfMaIOrtrgO95p7kTnO+/9qDs1ZjF6G9MPpJ9d1DbU5+R7wuGy9Djb+br3bBRvMmL/dNs1fjo2Qxw==

Copy blueprint

So this last one uses a select switch. The main difference from the previous priority mapping blueprint is that select is not being done on the basis of "most available" but rather "what I'd like done first". It also outputs the internal priority assigned - which might not be preferable overall. This can be fixed by reading anything and outputting 1 of anything on a trivial circuit. This lets you break the predefined game order, which can be important with quality targeting systems: what do you like more, crushers or asteroid collectors? Or do you have spacious cargo? This ought to let you choose. My original design took... many individual circuits to do this.

But with a simple modification it selects the item with the highest priority with a count that is less than that of a monitored inventory.

It's been some time. So if I've missed my mark, I did try and do a check to make sure these are novel. They definitely use circuits that have been done.

[mmmPI]

I have searched on the forum but didn't found a 2.0 blueprint for a trigger Schmitt so i'm posting it here, it was made from this one : viewtopic.php?p=189046#p189046

snip.png (36.41 KiB) Viewed 629 times

0eNq9Vs2O2jAQfpXIx8pZQYCsiLQ99Fwu294oikwyBKuOnToObIryAH2QvlifpGNTEhYFFrbtkgP+mflm5vM3TnZkKSooNJeGRDuSQploXhiuJIkIsLL2jPIKplkOBjT/DoQSnihZkmi+IyXPJBPWUaIBetgdw6TxE5UvuWRGadKgh0zhiUTDhvb4MM3NGuF50u8VNAtKQBpuOOzDukkdyypfgkZYeoAqcyaEL1heYJqFKvm+kB2xwcPp3YSSmkR+MB7dTTAAZmu0EvES1mzDMShaJlwnFTcxSLYUkJLI6Apou4wuaYu64ro0cVeQqQubxYZrU+FKl5az8JmszZrLjOxDO6JINLCT3FJsy47Ie9I0lqeTIoMWLYeUV7kPAhKjkbRCCegp937wvNwezBG9fAaXOQzOMNhhdWyVr6ALWLK2VJVgYa73e7ROqgAkdC/jd2iiKlNUrwh+nHMswWyV/uqK0Z02Mg2AcVZMlND0Ht6YXmqQyzQPzkoViWm57cbYH4d2s+kLbNvT1RcJpOQbbmAFuCiVzp3RM5U+uIXKCjgY4K9Z4IN5FoLVoOPn94hmMoMvcuY/eg/eR7UF7X1A35T0UDW5kapjmb89VbMbqZq8RNWMPXkbhldyHzdhGz6FhKegr6fmXLP+ATrp1OPZ/M0ad7a/GI+o+/XjJ3mpB13btU1oO/I09HV9uzhcEqevtiurTVRRx+6c45VWecwlYh3QF73Xwv2tWg/+n9aDVusrUfG0K3PL0PQ2mYdW5bSFHp2DFjxbG19x8Vfw47Pw1RLfj/Yl+4+b1B1tSaxktly7j5L5kAb2WdC5/Q/pGEcjOsTRyI0COna7I/wP3Wjidoc4wjm9xzXE4wZyjNB9lFEi2BJQiOSz5lmGV+enZJ1zYzz8nPD2GizRaoPn6bKbhMF0PJ1OwtFgPB0ETfMbyshYew==

Copy blueprint

Uses a upper bound and a range to then define the lower bound.
From a set of different fluid as input on the constant combinator, can be arbitrary.
Lit the lamp when a fluid is at the upper bound.
Untill it drop under the lower bound.
Or turn off the lamp if no fluid is available.

[SuperBananaBomb]

Alternative way to "Include only filtered items".

0eNrdmN1u0zAUx18l8g03btV8dU2lXYzBJCQEEgJuSlW5yelqkdjBcTaqKQ/AW/BsPAnH6damVbvNU4AM5aKJP37n+J9zjp3ekHlaQq640GR8Q3gsRUHGkxtS8EvBUtMmWAZkTEyPZkL3YpnNuWBaKlJRwkUC38nYraaUgNBcc1gD6ofVTJTZHBQOoPeBKMllgXOlMBYNb9QPKVnhTdAP0UzCFcTr/oAahFYync1hya44zsdJxbq/2L1HR+48pGTBUw1qv/XWrUJLAejIt5Kl6Di2CKkylMCYy3KmakfH5LRuKI1ebkU3IG8D4kqKnlSWLK/B8hta5Tkoe5rfoKFeepUb2iIteUI28GuGathxgwY3PMaNVZlAT/LUjh022MNj7JRfLrU9u9d8VScb+BVXuqwn3gVBHfW9Mzv6SQM+ehD+0g4+asCjB+HndvComuJVGRN7+bqN5wRinmAQ3peunrtO1vCRyXrLnGFfwjdp23zCFF1wVejZthA9sHRg8dJUpJ21/vrxk9Ad0kyAvpbqa21RQULGC5YWQMmlAkCPtSoBKVhC0Jujc8yozZQaUJkKKEudl3q/gj7S8ccZwZdF8pStUL0EiljxfK00OVNzrhVTK2fNLRymwJHCmXAN2SkSe9f4Yqb9L+KiLoROAgsuasEdXmxH1gY3Y9/XS8LedAteKJntUR29ZLq2iAOkkysoMKJw2iHmZ4abzmGLTiLFC+1kTKOH9PZJACSOls4cHLdPDkSr/9TdZfind5fWSu/eZtNq6XV3N59WS697tMQE20RABOZBisIqHvdymcKBGnPSfGkHeOFTg2D0l4LgWAG4aEvRoaUCUVcUeNOWAid2CniDrijwti0FRpYKuF1R4GNbCkSWCnhdUeB1Wwq4A0sJ/K5I8KE1CSw/OL3wv6uFrmcpwbArErxrTQLLg+H2jPGvJThvTYLAUoLRM90SB8clsDwZep05F31qLQosj4Z+Zw5Gr1qTwPJs6LvP/FwwpcR8UhtjE5e61KPulE48/PWpV98FeHlTHGe+whGy/S+Ykit0s15sOPSiIIrCoT8IooFXVb8BP1V30w==

Copy blueprint

[Tertius]

I updated the images in the top post to include combinator settings as well. I guess that's better than having to look inside the blueprints. I also added a few new contraptions that came up in this thread.

[Hares]

I updated the images in the top post to include combinator settings as well. I guess that's better than having to look inside the blueprints. I also added a few new contraptions that came up in this thread.

I wish (

again

) the forum engine to be Discourse so I could like the post above.

Also

And that my message is not deleted by pressing Ctrl+Enter (ref: 125699: Pressing Ctrl+Enter while typing a post can sometimes lose it)

[coffee-factorio]

Find the minimum/maximum of 2 inputs

For finding the minimum, the first combinator outputs all signals from green wire whose values are lower than or equal to the corresponding signals on red wire.
The other combinator outputs all signals from red wire whose values are lower than the corresponding signals on green wire.
The combined output represents the minimum values of both inputs.

The maximum works the same, just the conditions reversed.
2 min.png

Minimum:

0eNrVV91u2jAUfpXI107V/LERqRfbrnaxXfWOImSSQ7GW2JntwFCVB9h77Mn2JDtOQkhpWgJqpVVIYIzPd77z98U8kGVWQqG4MCR+IDyRQpN49kA0vxcss3uC5UBikkLCU1BuIvMlF8xIRSpKuEjhF4m9ig6ZcF1kbOcWTEDWO+1Xc0pAGG44NN7qL7uFKPMlKISjewjLxzBh+m4pKaRGWymsL8SLAv8qomRHYncaXUXoKOUKkuZESC2IUTJbLGHNNhwR0Ew3v+vHa6Syj4iSFc8MqOPdlhhXUrhSAbL5WbIM2eOmkCrHDFiPecFUzTYmN/VGaTNc52mfhV6QRYGZPRvN76EFlJhdYdFWWclT0oFvGQZxHm7Qww073A1XpqztWuSm3u6n88CjHnh0Evzz5cwnJ8G/nAd+Xc3xVVkXR/16KOXAlAy0675Zw5HN2qIu8LeUd23b/4YtuuJKm8VhCE8EDyxZ25nE5kec8+367hYCzFaqHzUtBSmJjSqBknsFgFGtWKbh2NVTm/pYZ2QRKisUsjRFaY5VaSTLMcSeKWpwuQgF/7UI+a8qQt57FCE3fEsVun5LFXKjZ2UovFCGgncsQ4/S9Pf3H3JKmQZU5qQyDYrGayvToPxhmYm9Q2HWU9CJ4kVTIXK75to5lNdpuTgsy5zGk3ZWSuYzbiC/qUHdLVZ4vl1LDc6G4bUPTytwMrkFtFcO2C50zJoJfAMEVwp0Yasr7jtMKRpEpNzg3YlbPCzRQo3n01k/w2YkiV5Yd6Ih0lCAtCXgKLzcgsZB0TVezgXPy3zvUa6cJVJ3uLBkr8jAUEWHAuJgYv0ynBLFE7eQGQxMVeh1jwF8IAyN6YQOX5BffKR49Yza+/mIHvtGhvx+GO83OPI7pAZ27HI4PJzGUftKbFfTc44/jeTj+EjCyzL4ndQTblvLhjfzqEd96s3pDN9p2K58GlC/XYXtKrSvdhXhHqLYXkXowz8tSjaYtppmNPGn4XSKH8E0mARV9Q/gO5hH

Copy blueprint
Maximum:

0eNrdV91u2jAUfpXI105V8kMhUid1u95dLyZRhExyKNYSO7MdKKryAHuQvdieZMcJhEDTElArbRMXdRyf7/t8zndi95nM0wJyxYUh0TPhsRSaRJNnovmjYKmdEywDEpEEYp6AcmOZzblgRipSUsJFAk8kGpS0K4TrPGUbN2cC0tZqr5xSAsJww6Fmqx42M1Fkc1AIR3cQVo9hwrRpKcmlxlgpLBfihb53FVKyIZE7Gl2FSJRwBXG9IqAWxCiZzuawZCuOCBim6/f6cIxSdjuiZMFTA+p4diuMKylcqQDV/ChYiupxUkiVYQYsY5YzVamNyG01UdgMV3naZaG1yTzHzJ6N5rXQfErMJrdoi7TgCWnA1ww3cR6u38INGtwVV6ao4rbIdb3du/PAwxZ4eBL88+XKhyfBv5wHfl1O8VdaiiO/epf7dfhX+9V7V78O/kW/usFHGvb6Iw3rhq861qdvfNc7DLuz601Pu25RZ/gu4Y1x209o0gVX2sz2x8aJ3QOLl/YUQfsjzvlxB2n6ROgB/0yAWUv1vdKpICGRUQVQ8qgAcJsLlmo45n4ZUy1rgixCac86WZi8MMcHa0/ZfYS9UuXgwioP/5cq//7562SdO2p2ss6dJXjvOneaCctM7KUKs56AjhXP6wqR+yXXzr68zlaLw9LUqZm0s1Aym3AD2W0F6q6xwtP1UmpwVgzvgbhagYPv7DfYMUsmHEQC+8lxjMQJQAalQOe2xOKxAZaihkXdNeiDuMfFEiNUf1FN9NuSTsto7e5B1FJqEZBsJTgKL72gsV90hZexJ54V2Y5TLpw5ine4sHKvSEdvhbT7mtvRVn5z2gdVY9lbdg9j3JGunh725/WOeLta2PZKBvt7Qz9pX4m1Ij1n+cud3PTfSXBZBr918o72y/D8xAZM8TOneOzmMoUO9mDQsIfIbhvdWssmbDKgA+rTwZROPOrhyMMRPtOgmsNnHNVzgf1tRyOcQxTrVVSx/w+MkhUWoqIOh944GI/xjz/2h35Z/gF2BKBR

Copy blueprint

This is not exactly the minimum or the maximum. This emits the lower of two signal of each signal. And I think I have to be a little careful in saying that. So it is a lowest or highest filter as I'd phrase it and I see some value in that. Knowing which inventory has the most or least of a part seems like it has good value.

Here's the issue.

I need to find the maximum or minimum value of an inventory. As in one. If use two lines, it will output all the same because they are all >= to one another. If I select any signal from that line it's order appears to be arbitary.

The selector function takes a signal and returns it at its maximum value.
And boy.

I have twelve space ships running 27kt and each one wants a standardized legendary components line.
Each strategy I use to get to legendary, I am not using legendary then it jams. And that prevents such joyful upcycles as "cliff explosives in -> calcite out" or just "make a bulk inserter".

Below is the blueprint for a garbage arm that can deliver the most of an offending part based on count into the void of space where, for practical purposes, it must go. Only limited things can feasibly be broken to down and not into a reliable material stream off a platform.

0eNq1l9tu2zgQhl+F4GVBB9bJJ6ALbO970xZogSYwaGlsc0ORKkk5EQK9e4eS7SiJbCutFzAQioefH4czw8kTXckSCiOUo4snKlKtLF38fKJWbBSXvk/xHOiCZsIWklejgiuQtGZUqAwe6SKoWc9sr+O4cqNU5yuhuNOmsyas7xgF5YQT0G7XfFRLVeYrMCjK+rdltNAWV2nl90KlUTK+SRitfCu4SXCLTBhI2xlByJoT+bmuKrzcThhXci+012/JR//S2p/jFUY4GCOeXQXjay9GNBxjfhWMT70Y8XCMyf94KclwjOlVMD73YkyeMSAVGZiuq/ex7EnGfSQI4oyWyxVs+U6gAK7ayy5xLGukrO/tfmHcrIWxbvkcfheOwlXltkJtfCxa8FrD18JjIfFQiFx74Lzgpjnrgv5DvX3eiXJO7tABy70IVxn1OUOXrijd6ww1+ND1Hd4k9T6Dds3ApkYU7SXQ71tQxG2BWJB4M5CRW5rzx1tKWhWCRGAJAjCc4pqpayEdGOI0fnF3mCjWRDgicO4OBzkuLJW7Id+22IU/lNUG/ApFYvKBxAnRa5y2ETskuMcM6b8t8krwmxZaoechx6p0pNIlyXlFFCCgRgZDpN6I1DNkgJs/CLcltkDX8cjcIrIU94C78tLpnEvZsqa4+6oUMsOdjU7vweNLfUtvCO1x9ik7l9h7vD05Rt4bf5/1u7ttx+3LNt7z4Z1htLX3697BfsboL5yAx8JBpU3eTH7heR+bjtK/heF4jN6C/tJjjdnwDJRcJQP96M1A8+O0VSnvR0JZMGifs6+TfyBeYsT915EKk5YC4xnc8mh3Z0qoT93DnkUYrUYb4Gb0sIXGKJet7kO7tPB6o7dlwfjZMk2Y6oFZ9+2xT2VdXQBytTmh3YOyfWOJ+aBF2xcyy0Mw0MW474KC4I/D5i3wtcPmL67rGCTxtKn+DlXdUbQxFwqLdLT3o3fqxmFHNxoEa/C5OBfPUdKRjIeiXlIdTzuqySBQKER6RjKYd88+GQp6SXXWPf50EGipUC1vEudp2K7sbCjsEOVZ17WeU92aW9dNde8SjccdzU4y4dmOqxSyP/PWqOsDnZg/jXrBq6KuBwThAEEJG1AZN9U5i7bv2Yn654uvHizPC6w61kbnWBf8x/Mcy4x1iUUDtxbylaywmlDgawTM2A+YnHxW+TlhAUNrRncMmyGbsrBpRWzOAmzhEI7j7w4XCQe5f7GO/3UyimVS8z4vkkk4j+dz/BPNo0lU178B0IjfOg==

Copy blueprint

[Nidan]

Tertius' setup gives the pairwise minima min(Each[red], Each[green]), the selector combinator min(all input signals). Calling both operations minimum is perfectly fine. You just need to be precise and indicate which of them is meant, if there's risk of confusion.

[Hares]

Tertius' setup gives the pairwise minima min(Each[red], Each[green]), the selector combinator min(all input signals). Calling both operations minimum is perfectly fine. You just need to be precise and indicate which of them is meant, if there's risk of confusion.

Happens when you are working with matrices and/or arrays. More proper way is to say it's per-element operation. IIRC, MATLAB has dot-operators for describing per-element ones. I.e. `a .* b` is a dotproduct oh wait it's not. `a .* b` is a new vector where all elements are products of respective elements from a and b.

[Tertius]

I need to find the maximum or minimum value of an inventory. As in one. If use two lines, it will output all the same because they are all >= to one another. If I select any signal from that line it's order appears to be arbitary.

The selector function takes a signal and returns it at its maximum value.
And boy.

Sorry, but I struggle to understand what you wrote. I don't get what you mean with "As in one", "If use two lines", "and boy".
From the blueprint you posted, it seems you want to get the single highest signal from an input, but only if it is greater than some threshold.

What you posted does work this way, but it's coincidence. You used the ANY wildcard on both the condition and on the output as well. This will only output the intended signal, if you feed a single signal on input. Otherwise the ANY on output will pick one from the input, not necessarily the intended one. By coincidence it will not pick your "Fire" signal you chose for the threshold, because as virtual signal it has a lower position in the hardcoded game signal order, so it's guaranteed that it's never being picked as long as there are also item signals present. [note to self: add an explanation of signal order to the cookbook]

The proper solution is to first filter eligible signals from the source, in your case all signals greater than the threshold. A decider, with condition EACH > threshold and EACH as output. You can feed this output directly to the inserter as filter.

You can also have individual thresholds for each item. Use the "Limit filtered items" blueprint from the cookbook. In case there are arbitrary other items on the wire you need to ignore, add a second condition to the decider as shown in the "Include only filtered items" blueprint to limit the output to just the items configured via constant combinator.

Now the inserter will move anything that's above the threshold eventually. Not necessarily the largest amount first, but eventually. Keep in mind the other items will be moved as well, as soon as the current item vanishes from the filter because it went below the threshold. If you always must move the largest amount first, you can feed this to a selector combinator to pick the largest signal only, then feed this to the inserter.

[coffee-factorio]

So I think where I need to start is:

Hares' is the smarter of all of us

Because in one, he's got it. It'd doing pairwise minimum.
I want to stand on as that does as advertised and it does as it should from a logical point of view, but there's a problem that demands some kind of cookbook entry that the selector -> max count handles well.

I've run into a bit of a spot. This is complicated.

Here's what signaling looks like:

Fact 1:
When we generate a signal we generate a pair (key, value).
As a set these pairs are broadcast on a line so you get (k, v) , (k_1, v_1), (k_2, v_2). Based on the sum of all values on that line.

Fact 2:
The key values are based on where the item appears in the games tables, the first cell on the first table is the first key. Then quality is applied then the next key is item to the right of that.

As an Excercise to verify fact 2, get an automall to run chemical plants prior to telephone poles.

Fact 3: If you select any signal from a set of signals that that are true, any signal will be returned in the order given by Fact 2.

Fact 4: A select combinator returns the top or bottom value of a list of (k, v), sorted based on the (v_i <= v_i + 1)

I did not arrive at my solution by coincidence: I will now cherry pick the most horrible example of how any > thresh hold goes wrong when used with monitoring quality.

You have a distribution of 5 each of 4 parts in a chemical lab. Any pipe > thresh hold goes; it's a logistic item - the rest are components. On 3 states that occur with the same frequency. For any quality of pipe. So three stacks of parts fill up to thresh hold then pull till just under it. Pipes are added in an equal distribution, so when any of those parts occur simultaneously with pipes, you pull pipes. The belt advances while the pull occurs on a sushi belt, so it's possible for 5 steel to throw out more than 5 pipes as it escape the belt when the pull occurs, then arrives with 5 pipes. In your own time you may try a not sushi belt. Think before you do. And think about the implications of doing that in a chest, although the tested use case was on a space platform.

All are relevant to build a chemical plant. With stacking 5 items can occur in a cell 8 deep in 4 high stacks. And given fact 2, if you have a pile of high quality pipes, but banal steel, that happens to hit an arbitrary threshhold on cells that can hold 8 of 1 to 4 values given at random. Pipes high quality are the first choice to remove. And it's down to luck that doesn't happen.

You can, in your own time, prove that a sushi belt removing parts is equivalent to a Turing machine. If you arrive at a FSM, remember that a circular belt means an instruction can reoccur. Which is equivalent to telling a belt to move backwards to an instruction. And jamming is it halting when it should continue. Any > thresh hold is the equivalent of a turing machine that removes one set of several instructions if it sees any one of four accepting states. Since if no pipes after a limit do not reach the assembler on a mis-constructed line and pull inserters before assemblers can put parts inside to finish labs; that throws out pipes prior to them reaching the assembler. This machine has a passable chance of out running the computer simulating it. To make it the virtual machine that kills any perfect logic, you need to deliberately sabotage the line in a way such that it jams before it completes a parts order (I think you need to read assembly machine contents and then kill the input belt). However, the hypothetical case of inappropriately redistributing parts is bad here. In Bulk inserters you can throw out a 1 in 32 fast inserter in the same way. But two of those lines go at speed 15 and two go at speed 1.

As it is a Turing machine, "select max" gets around a lot of issues because it stops, counts the most, then throws out the most. So the even distribution that offends randomly is unpacked randomly at least. If you fix input on a perfectly linked circular list that the inserter sees that'd cause it to run infinite, but in practice that'd be hard to do.

You can also tool to meet the problem at its level by modifying the contents with parts that you'd otherwise throw out but after a delay. And recognize "hostile instruction sets".

Like biolabs. Think about unloading with belts alone (chests can help) the parts distribution with either any beats thresh hold or max select on jam.