Combinator Contraptions

[XKnight]

This is my first attempt at a computer in factorio. It's 256, 5 by 7 displays arranged in a 16 by 16 grid and it can type, by placing copper plates in the "keyboard", do very basic maths and algebra and has some basic memory. Was hoping to put in a game next (chess??) and any advice would be appreciated.

Computer in Factroio.png

Sorry for harsh truth, but I think you should completely destroy your CPU and start building it from the very beginning.
Fortunately, Factorio is not Minecraft, and you really don't need to put thousands kilometers of wires/redstones to build something with combinators. Here we have a lot more possibilities, but not all of them are obvious. Instead of building something huge you can try to create something smart, this will be much more interesting and you will recieve a good experience.

I admire your persistence and patience, but you've chosen the wrong path. The best what you can do is to go back and try again.

[piriform]

This is my first attempt at a computer in factorio. It's 256, 5 by 7 displays arranged in a 16 by 16 grid and it can type, by placing copper plates in the "keyboard", do very basic maths and algebra and has some basic memory. Was hoping to put in a game next (chess??) and any advice would be appreciated.

So you are building a computer - Great!
And you published your 1st attempt- Even Better! ( I wish more people would- Hopefully we can all learn what works well and what does not)
Are you looking for specific feedback or just proud that the darn thing works?

PS AFAIK the smallest chess program has about 1/4K of instructions, but that's X86 code
the piece position evaluation loops more than 4000 times per move at say 20 instruction/loop. How much time do you have?

[piriform]

Dr. Walrus encoding/decoding method led me to create a mux circuit in which a value of a specific signal can be selected from several (many) signals, via numeric address (1..N).
EDIT ------
XKnight kindly provided a more complete description of requirements (in lieu of the above vagueness). In summary, the circuit selects one of multiple input signals via number (address) and outputs a value of that (selected) signal.
I should probably add the following:
- The address range is 1..N where N is the number of selectable input signals, however successive addresses need not be consecutive (ex. the following address sequence should be valid 1,4,5,10 ,1,12.. etc).
-Delay of several (< 6) ticks between successive addresses is acceptable.
--------

This is what the mux looks like

mux.jpg (33.12 KiB) Viewed 10029 times

The leftmost constant contains interval separated signals (to be muxed) . i.e. if the interval is 10M then 1st signal will have a value of 10M second 20M etc.
These values are added to the input signals that come in via red wire into an adder with setting Each+0:Each, and adder above that inverts (i.e. each*-1:each) the signals and the intervals.
Address (blue) comes in via green wire (on the left), is multiplied by the interval (i.e. 10M) in the bottom adder, then fed into decider (Each> blue: Each) and the two arithmetic conbinators ( Each+0:Each, Each-Blue:Green). Address is also incremented and inverted (i.e. Blue+1 *-1:Blue) by the adder below the constant and then fed to a decider (Each<Blue:Each).
The outputs of the two deciders are summed then fed into a final adder that normalizes the result (Each-Blue: Green).

While this circuit works, the biggest problem I have with it is the speed. Unfortunately I need a 1 tick solution and this circuit can only do 3. I don't think a 1 tick solution is possible but would love to be proven wrong.

blueprint string

Code: Select all

H4sIAAAAAAAA/8VW246bMBD9lciPrVlxCXvR1pV6+4pVhbzG2bUENjKm2gjx7zVOIAFysUnSPprMmcycmTkzqVhkguBskaCacsUUoyWqa45zigCWTL3nVDHi
EZG/Mo6VkAAWotR2gqP6A3kxXCMvuIsbmDJJifkeQiI43zy0txcQgN+oljTVns2frBOWomUD9173kDBJKqbaR9A08E1SygeAuNGfX0B4yFk4gmtLHUPKtiHs
MkH1islSJSV74zhDtVoXOtM/TKoKZwBuEt/86FFM3oFxVCrMlc4TioJKbJIEnwAUlSoqF19tXFtyU0pYSuVRZv3ZxAb7XIQHqXwYmRzl9WlsOOR1m8QMUkva
+rFCvGYVNWXICyxbohD4MoN77aBYJ0RUXCUrKfKEce0AASVb97vCWHR9NLs2Yz4P1CYIbYsT+NdtdPea7I2D51QSk/ZgHnKasir3aKYplJr7QmR0pDWPd0Zt
/JZ450E4rCnB2GYvom7uT4ifCcg6nnuL4k91bMUyRWWryjbEfjONrntcdwdkPKUf2g20gn7voWEHDS2hP3po1EEjS+jPHrrsoEtL6K8eGnfQ2G2QvV1DXaSy
wYkpjQd77ulfLCp/fzA/X7anbFiMuilwJfHRcig7bqe2N1n8/cbpF78/f/NvnDnpSugodA+XqkafsBGOXjccr5VZLWAjiuOLxu4MDAeDF51ulP91yXy94SVz
fqW6btRocg4664TV2XTmYg0GlV2eOpHG+nCgvW4iyWMJuaqCWHDt21I9YezosE2ZOzNT12HugmXWE9dARkxI9Vba4Ckitf2zpKqSfJE8U57+BcLXSCglDwAA

[XKnight]

While this circuit works, the biggest problem I have with it is the speed. Unfortunately I need a 1 tick solution and this circuit can only do 3. I don't think a 1 tick solution is possible but would love to be proven wrong.

I recommend you to use some pattern when you are asking for help with combinators... Like this:

MY TASK 2

Input:
- ~150 different signals in input
- each signal has unique value (I don't know, maybe this information will help you)
- each value is less than 1M (this value may be reduced/increased by your demand; it is preferable to increase this value)

Expected output:
- each signal should be presented in output without others during 1 tick
- whole process should take exactly N ticks (where N is the amount of signals in input) + fixed amount of ticks (you may use any number here; it is preferable to decrease this value)
- output sequence doesn't matter, but each signal should be presented in output once
- gaps between output signals are forbidden

Main focus: reduce "fixed amount of ticks", amount of combinators

Example:
0 tick: input A 10, B 30, C 20, D 50, E 40, F 60
1 tick:
2 tick:
3 tick:
4 tick: output A 10
5 tick: output B 30
6 tick: output C 20
7 tick: output D 50
8 tick: output E 40
9 tick: output F 60

Signal delayer challenge

Task: delay input signal for X ticks (X may be set by user)

Expected result: the same as X series-connected arithmetic combinators (input: Each + 0; output: Each)

Example of delay 3
Tick: Input signal/Output signal
1: 10/empty
2: 20/empty
3: 30/empty
4: 40/10
5: 50/20
6: 60/30
7: 70/40
8: empty/50
9: empty/60
10: empty/70

Main focus: amount of combinators

Because it is not so easy to understand what is needed when you already present your solution. Also, given solution may knock off from the right way.

You task looks like:

Task

Input:
- N signals on the red wire; each signal has its own range: first signal - 0..10M, second - 10M..20M, third - 20M...30M, and so on;
- blue signal on the green wire; range - 1..N;

Output:
- value of the K-th signal where K is the "blue" value.

Example:
Input: 123 "A" , 10000246 "B", 20000500 "C", 2 "Blue"
Output: 10000246 "B"

Main focus: as fast as possible; 1 tick is desired.

Am I right?

[piriform]

Am I right?

Yes, of course! Your (re)statement of the problem is correct, and I should have started with a formal problem statement ( my fault).

[Dr. Walrus]

This is my first attempt at a computer in factorio. It's 256, 5 by 7 displays arranged in a 16 by 16 grid and it can type, by placing copper plates in the "keyboard", do very basic maths and algebra and has some basic memory. Was hoping to put in a game next (chess??) and any advice would be appreciated.

Awesome work. You should post your own forum topic and maybe post a blueprint string or download link so we could see a more in depth view of your computer in action. While I think chess is definitely possible, it's a big step up from snake or tetris which other guys have made in the past. At least with chess the game doesn't move on its own so you wouldn't have to optimize your computer for speed. You could take 100 game ticks for the computer to calculate a move without hindering the players ability to play.

Dr. Walrus encoding/decoding method led me to create a mux circuit in which a value of a specific signal can be selected from several (many) signals, via numeric address (1..N).

Could you post a blueprint string of your contraption so far so I could see how it works. And I agree with XKnight, with the wording you have now it's a little difficult to to understand what you are trying to accomplish.

My guess is:
Tick 1: Input A = (54 Wooden Chest, 22 Iron Chest, 22 Steel Chest, 10 Smart Chest), Input B = (1 Signal Blue)
Tick 2: Output = (54 Wooden Chest) <-- First signal type in order if Wooden Chest corresponds to 1, Iron Chest to 2, Steel chest to 3, etc.

or is it like this:
Tick 1: Input A = (54 Wooden Chest, 22 Iron Chest, 22 Steel Chest, 10 Smart Chest), Input B = (3 Signal Blue)
Tick 2: Output = (22 Signal Blue) <-- Value of third signal type in order if Wooden Chest corresponds to 1, Iron Chest to 2, Steel chest to 3, etc.

Doing this in 1 tick is might be tricky, 2 ticks seems very doable because I think the encoder part of my encoder/decoder combo does something pretty similar in the first 2 ticks it receives the signal.

*EDIT* I was writing this post when you replied to XKnight's question.

[XKnight]

Task

Input:
- N signals on the red wire; each signal has its own range: first signal - 0..10M, second - 10M..20M, third - 20M...30M, and so on;
- blue signal on the green wire; range - 1..N;

Output:
- value of the K-th signal where K is the "blue" value.

Example:
Input: 123 "A" , 10000246 "B", 20000500 "C", 2 "Blue"
Output: 10000246 "B"

Main focus: as fast as possible; 1 tick is desired.

2 ticks are really simple:

1.png (45.78 KiB) Viewed 9942 times

Also, second "Blue*10M" combinator may be removed if input red wire can be modified.

By the way, it looks like this task can be completed in 1 tick only when "Blue" has 10M, 20M, 30M values (instead of 1,2,3).
Probably better results will be achieved when input system will be included in task.

[piriform]

Nice, clean design, but I have to apologize for wasting your and everybody's time (again).
I read your spec (on a remote monitor) and saw this
Input: 123 "A" , 0000246 "B", 0000500 "C", 2 "Blu
instead of
Input: 123 "A" , 10000246 "B", 20000500 "C", 2 "Blu
i.e. I thought you had zero padded B & C values. So DR. Walrus question

or is it like this:
Tick 1: Input A = (54 Wooden Chest, 22 Iron Chest, 22 Steel Chest, 10 Smart Chest), Input B = (3 Signal Blue)
Tick 2: Output = (22 Signal Blue) <-- Value of third signal type in order if Wooden Chest corresponds to 1, Iron Chest to 2, Steel chest to 3, etc.

is actually what I intended (Duh!).

The intended application for this is a computer input port which will collect external factory signals (i.e. ores, plates, products etc). Conventional translate,select technique requires 2 combinators per signal which can quickly add up. This method would allow signal collection at a lower cost.
In this particular application I don't have any leeway in timing. It's 1 tick or nothing, so I'm falling back to plan B which involves issuing successive addresses and reading the previous (already derived signal value). Given a fixed signals list this will entail 1 extra read instruction ( "preset") and does not appear too expensive. By using this method , actual mux delay will not matter provided the timing between successive reads is greater than that of a mux.

Even though this is a specific application for a multiplexer, I do think that this type of a circuit (and a corresponding demultiplexer) will find other uses. Once again, thanks for all the help and apologies for lack of clarity.

[XKnight]

Ok, next time you will write requirements by yourself

Here is the solution for your renewed task:

1.png (167.68 KiB) Viewed 9910 times

Details

2.png (30.11 KiB) Viewed 9905 times

Tests

Input: 123 "A", 234 "B", 345 "C", 456 "D", 567 "E", 678 "F", 1 "Blue"
Output: 123 "A"

Input: 123 "A", 234 "B", 345 "C", 456 "D", 567 "E", 678 "F", 2 "Blue"
Output: 234 "B"

Input: 123 "A", 234 "B", 345 "C", 456 "D", 567 "E", 678 "F", 3 "Blue"
Output: 345 "C"

Blueprint

Code: Select all

H4sIAAAAAAAA/7WV7Y6jIBSGb6XhN04Ev7aZsMl+3sRkYxykMySKBnEzjfHeFxTZdrftUN31V6u874FznnMom13V0KLa5WRgQnHFWUeGQRQ1I4A2olOFUAFt
6mcuCtVIANum06saQYY3EkQPCTySAD0kI9SrBaPmk3Z4Agj8IMOLZEyvnK2POS8JhpRL2nNl/qBRP/DAK8WkCdvxF1FUZFDHVof/yaXqiwrAeTfzx+ATMKF6
oQjCEeSiZG/aB3ppPzstjmKrxZ7aL04bxYnVRp7ar04bJ6nVxp7ab06bpJnVJp7a706bZh+sNjUptwUuGeUlk1fri11xSy7n2poCXii0ZOVZmXUU+HfxTb3h
E8CXFNHEgvYuubW2uyPDgctO5T4HZgV9nc48g0tC/bNuC2mORsBHAJtetf2dXu0xn5KYH2RT51xoAwKU7Bk4SWXNSt7XAat0ZiSnQdtU7DyZ8Tu98mdCzjoF
j+NJMN/GDP37Mtnal8+VScjSIq4x/WEL0LLje2HLLsIW34At/Yewdcz4eClcjn4zSf4jk+9igm5TcpNIM3Ov4IM3jXWM9/E+zfA+WT/dF4v1Q95ZRKtnvbPA
q0e+s0CrJ7+zCN0F4Gdx1tAYxdnkslxfCN01j2bSsC9pm6fRCU6hfdB6nBYLvB6nxWIDTotFvB6nxSJZj9NikW7CaXEJT3EaIacTFYN9Ca/eHDqoLQW8jqB2
fJRM9VLs8kcmyl+u4TQQ7QoAAA==

[piriform]

I don't have time to test it right now but it looks Really Good.

I think that this approach will be very useful. Off the top of my head I can think of the following apps
1. Input port
2. Your memory "compactification" scheme reader
3. A big one- Lookup Tables - fix the inputs in a constant and select arbitrary values in a sequence -alphabet anyone?
4.couple of these , a binary decoder, a bit of glue (and a lot of lights) and you have a very nice status display

Thanks again

[Killavirus]

This thread scares me, Not only do I have no idea whats going on I know one day I am going to test this out, My addiction is bad enough as is, WTF is going to happen to me on the day that I start to understand and use these !!!

[terror_gnom]

Hi,
first: Nice thread and very helpfull people I like it

I like to build some kind of logistic network with trains. For this purpose I need to find the biggest and smallest amount for each Item. (smallest is easy because max > 0, min < 0 so its just a matter of changing the sign)
My first thought was: Pretty easy, just do if each > each output each itemcount, but that clearly doesnt work

I want to build it scalable for up to 1023 signals (I dont like the 0 in factorio^^).
To preserve the address of the signal, I code the address in the 10 least significant bits of each item, so dont change these

So to sum it up:
each value per Item is unique (even with the same itemcount, the address in the 10 lsb will make them distinguishable)
there will be a max > 0 (and min < 0)

Question: Is there a way to build it without building a comperator for each Item?

task

for simplifying reasons I just take 2 Items, it will be all Items in game!

Input:
Red: x1 iron and x2 copper from source A
Green: y1 iron and y2 copper from source B

Output:
if x1 > x2; x1; else x2
if y1 > y2; y1; else y2

Focus: not using a comperator per Itemtype! Scalability, latency < computational efford <= 30-60 ticks (after I got the result, I need to update the memory and the next cycle needs to work with the updated value)

example:
1: input x1=120 iron, x2=50 copper, y1=12 iron y2=650 copper
2:
3:
4:
5: output: 120 iron, 650 copper
6: update memory (not part of the task)
7: input x1=1120 iron, x2=510 copper, y1=1232 iron y2=610 copper
8:
9:
10:
11: output: 1232 iron 610 copper

A thought that came at the moment: Maybe some kind of sorting algorithm with a second, sorted memorystack. It needs to handle 2 different update-cycles though (1024 ticks/update from the train stations and 30-60 ticks/update from the controller). I need to think about that... probably its way to slow and doesnt save any combinators :/

[XKnight]

task

for simplifying reasons I just take 2 Items, it will be all Items in game!

Input:
Red: x1 iron and x2 copper from source A
Green: y1 iron and y2 copper from source B

Output:
if x1 > x2; x1; else x2
if y1 > y2; y1; else y2

Focus: not using a comperator per Itemtype! Scalability, latency < computational efford <= 30-60 ticks (after I got the result, I need to update the memory and the next cycle needs to work with the updated value)

example:
1: input x1=120 iron, x2=50 copper, y1=12 iron y2=650 copper
2:
3:
4:
5: output: 120 iron, 650 copper
6: update memory (not part of the task)
7: input x1=1120 iron, x2=510 copper, y1=1232 iron y2=610 copper
8:
9:
10:
11: output: 1232 iron 610 copper

Solution:

2.png (217.64 KiB) Viewed 8817 times

Tested with:
Input: 120 "0", 50 "1"; 12 "0" 650 "1" Output: 120 "0", 650 "1"
Input: 1120 "0", 510 "1"; 1232 "0" 610 "1" Output: 1232 "0", 610 "1"

Details

1.png (48.49 KiB) Viewed 8817 times

Blueprint

Code: Select all

H4sIAAAAAAAA/92W32+bMBDH/5XIj5vpwAvZosr7R6oJefalPQlsZMzUCOV/nyFZGiAkHqgPa56CfD7f93M/dMqsciNFvsp4A9qhQ6h402hRACfS6MoJ7SJp
il+ohTOW0NJU3spo3rzyaP2Q0j2Pkof0QL21BtkeeQ9PJCE/eWNBeW+d432GijMq0coaXfuRHPyP7jB3YNtHK3zWIueN25f+8d9oXS1yQo+xHA+jmLQP1drx
hMUUtYJX74cG3U3Od9O/V1kbwUmtsOheCnAop/Wys1qF9ii21RSgvA3y7Ws95ECfCLt27evAkD5bAH3T5NClQuEpnjdZvNmhrVwWwgqEfOlwHSvAi6amBCs6
xeQToaZ2Zf0vvi5IK5CowE5iTmZT7tUX6yFP75Mc3J7OSjo07CM/6VvCO/Z/i1LYFg4nP2bw9g7KfdbVe7azpshQewecOFsDmVH28eJ8XIe+DW2FgAQOTd6l
FeLLTvi8rBMC4Cdz2Q/mwuT4YVdRrqc7KYlnTa++k810dH3/4/b6L9O4npvG0ayZgv3tnUCxS1BfloEqQGFdRJB71dbTKk0OfU6bbqOIQxeKzahUzm+Fbi9s
6q2AWbVkfZm9vWwWrS8spAjvzIN+v36/UZSjWXFl1IznyYfYYIJAD3lt70/mbfiO86EXmANF2UXbnBqJ3moEb/9owdVWr7JH0OoPTO2AY/kMAAA=

[terror_gnom]

thanks for the quick answer, I like the idea would have never thougth about testing the difference against zero.

Another question I probably know the answer (NO!):

My brother (2nd semester software engineering) told me, the comparison of the memory blocks can be handled in at least n log n steps, with the build in parallelisation of factorio its down to log n (so with 1024 cells 10 ticks). is there a possibility to utilize the parallelisation further?

[DaveMcW]

You would have to explain the exact task you are trying to accomplish in log(n) ticks. But for some tasks, you can use 1024 combinators to sort everything in one tick.

[terror_gnom]

I have 2^10 memory cells and want to find the biggest stored value (my own logik tells me, that you need at least 10 comparisons)

[DaveMcW]

Simply ( ) build a million >= operators, count each row of the 1024x1024 table, and select the row that scored a perfect 1024. In theory it is possible, in practice maybe parallelization isn't the best answer.

https://en.wikipedia.org/wiki/Space–time tradeoff

[DaveMcW]

Here is a contraption that identifies a mystery signal and returns its unique ID.

signal.jpg (380.7 KiB) Viewed 8701 times

[terror_gnom]

Is Dr. Walrus still with us, so he can probably add all those nice little helpers to to first post? Probably someone is looking for it and doesnt like to check every page in this topic

Next task (I did already solve it via bruteforce, but I´m sure here will be postet a way more elegant solution )

task Itemfilter

Input:
2 signals A and B

Output:
each signal that is !=0 in both signals with count of A

Example:
A = 120 iron, -1234 copper, 4 miningdrills, 10 blue, 9 raw fish
B = 1 miningdrill, 50 blue, 12 copper, 80 coal
expected output: 4 miningdrills, -1234 copper, 10 blue

*edit* Can you tell me, what tool you use for the schematic? I like to use them for my build. If you just build it ingame, it gets incredibly confusing and after 2 days you have no clue how it works or even what it does^^

[XKnight]

task Itemfilter

Input:
2 signals A and B

Output:
each signal that is !=0 in both signals with count of A

Example:
A = 120 iron, -1234 copper, 4 miningdrills, 10 blue, 9 raw fish
B = 1 miningdrill, 50 blue, 12 copper, 80 coal
expected output: 4 miningdrills, -1234 copper, 10 blue

After reading your task I was a little bit angry, because I thought that people have forgotten how to think using their own head.
But later I calmed down and found this task quite interesting...

Obvious solution which definitely you should have to implement by yourself:
- transform each signal to 1 using (Each > -GG, Output: Each, 1)
- collect these values from A and B, check whether they are equal to 2
- multiply these signals with G
- calculate sum "A + dummy constant -G + multiplied value" and check is it bigger than 0
(some adjustments are needed if you want to work with negative values).
This solution requires 4 ticks and 5 combinators + 3 dummy combinators to propagate A to the last step.

Non-obvious solution:

2.png (182.3 KiB) Viewed 8639 times

Tested with:
Input A: 120 "A", -1234 "B", 4 "C", 10 "D", 9 "E"
Input B: "1" C, 50 "D", 12 "B", 80 "F"
Output: 10 "D", 4 "C", -1234 "B"

Details

1.png (46.5 KiB) Viewed 8639 times

Blueprint

Code: Select all

H4sIAAAAAAAA/+VW246bMBD9lciPlVkFcwlo60q9/sSqQtRMdi2BjRxTbYTy7zUJuRCWyGaVqlJ5S8ycGc6ZOZ5CLkrJ8nKR0RaE5prDhratyCugiEmx0bnQ
HpPVLy5yLRXCtdyYt6Sg7Sv1gocIb6nnP0Q7bN4WwLojg/CEfPSTtgoKg7YH3ma8oAQzrljDdffD35kHr3mpQXVJN/xZ5CVt9bY2yX9zpZu8RPhQy+HQ+4y6
RI3Q1CdLzEUBrwYHW8V+OcWGJA3TOF7GpIcglhBfzxB9ZGAZ+e1c+LHu0DL0+yk07SOjjrhepAIYL0BNa+SfFCq4OgjU6WChlhEIPysAMfg3utYQPyHyVngw
FttkLXiftC+ctmuuNjqzYQJy9rIn49CX1CN+uAqTIA4T82dV56r7foo+ISwbXTeOqPU22/OcrZWsMi4MAEVaNYAc+Caz6R4MR9eR56PYlvN4iHEPzv3l8flr
nNsa0dLWh0Y97OpDZyPw+5mMnY0gOhrBytnA/KNxJZahP06hyTFr6moiyzlNHQ76OL3i/Q17uboiLqMT28b/r8xmlizBNMvRtA2Zq2uO9w9BVjcg7+JYE4b1
8Y66VVDwpvKgNDoozrxaljBULnQzrLGvO5sjmcplccXPX9MuhmbutjaCcN/WRhDua9sIwn19G0FEzu49gogvOiFXXL9UoE3D3TRyMscxrNe+sUkMJ/pc5fvW
ECxrMKPcfQH6MGOW3Ygjc3mLp502vR7qmVvdP8ToDnO2r6ntpx1PXmSGin6c8S0VDOajAt0oscgeQRR/AO6TxbayDgAA

You can use any diagramming software to clearly describe your builds (most popular apps).
Personally, I am using yEd for my designs, this app is free, cross-platform, and has a nice automatic layout feature.