Minimalist signal filtering device

[mmmPI]

Based on the wiki article about multiplier : https://wiki.factorio.com/Tutorial:Comb ... s.2FArrays

I have looked at this circuit to try and understand it and i think it can be made with less combinators but maybe i'm missing something.

The original contraption doesn't seem to properly restitute the value of a filtered signal when its value is around 2147483647 in instead show -1 , -2, and my version does the same have i done mistake somewhere ?

multiplier.png (83.59 KiB) Viewed 8431 times

0eNrll9uOmzAQhl+lmssKttgcw6tU24jD7MYSGGRM1Cji3TuASkNispCtVivtDZJPv8fzzYzNGdKixVoJqSE+g8gq2UD88wyNeJVJ0ffpU40Qg9BYggUyKftWooQ+lKhFZmdVmQqZ6EpBZ4GQOf6GmHXPFqDUQgscBYfGaS/bMkVFE96QsqCuGlpdyd4GUvR3jgUniG3GHP7k01a5UJiNM7gFZLlWVbFP8ZAcBSnQsn/SexrOB7mmH3gRqtH7mzMehdIt9Uy2jTNsTLJDf7gGe5leq9FJ7zHat6pRJaMV8ItWVq2u283aXTecQI4HGmxk/edVIcpL/4kcYrd7pul8cdwjLaGyVuihyWk66d8g4JMpfw90H0AUPvkTAmdAYHL6iyg0qoUoWvKCC4Na2zuVXUSRtUEjMGrwTRqhUWN0uImPwvyWjjVrh3MaQ2aswcYWsLnvwcb+Lzbnwl3+g9iYUWMbNteo4T4cPsGk4T0cPpx5oRe5gedMYv6WOOKLgcLWBYr3nhLLvnaJ5W+UWHZdYuc5718Tmg9H6wq0vx0g/3wA7SuCPz6GoOESvAc0WGAQTKaUmIu2tLGg7RWBqKsCTQh80y25zmZ/XVyEjye2s9t9mcQ219S7URCtq6zR44n5iQDYbE7g+8ckZrgtMY2PWboZh/+R+OL3xYIiSbGYbPs2vmio/0jvmtHTEd3JO07XMneDyOm6P+44Z/Y=

Copy blueprint



The math it does is : -1/2 [a²+b² -[a+b]²]

the red wire is used to make a+b before squaring them in the combinator the result is turned negative and summed with the other 2 combinators that does a² and b² this sum is then divided by -2.

It comes from the identity (a+b)²=a²+2ab+b² which is turned into 2ab= (a+b)²-a²-b² or ab=[(a+b)²-a²-b²]/2 or again ab= -1/2 * [a²+b² -[a+b]²] if you mutiply both numerator and denominator by -1.

Code: Select all

 (a+b)²  =   a²+2ab+b²
  2ab    =  (a+b)²-a²-b²
  ab     =  [(a+b)²-a²-b²]/2
  ab     =  -1/2 * [a²+b² -[a+b]²]

What is the purpose

i'm not quite sure yet, i've read that some user consider it very useful to filter signal for example, one constant holds the value iron=4 copper=9 coal=12 green circuit=8, and the other constant, you input only coal =1 and iron=1, and the resulting operation will be a filtering of only the value coal=12 and iron=4 at the end.

You can also use it to multiply a and b

[gGeorg]

filtered signal when its value is around 2147483647 in instead show -1 , -2, and my version does the same have i done mistake somewhere ?

It is overflow feature. It is there since von Neuman made first machines.
32 bits: maximum representable value 232 − 1 = 4,294,967,295
https://en.wikipedia.org/wiki/Integer_overflow


Purpose of filtering
is obvious when you try to make a load-unload service train. e.g. a train supplying defence wall, or a build train.
Imagine a situation your train has 20 different products, but you want to unload only those which are missing in the local logistic network. On top you want to quick loading process by stack inserters with "set_stack" feature. Ring a bell ?

Simplification is nice, I have to check it, if it realy works as intended. Perhaps, I could use it for my trains.

[mmmPI]

It is overflow feature. It is there since von Neuman made first machines.
32 bits: maximum representable value 232 − 1 = 4,294,967,295
https://en.wikipedia.org/wiki/Integer_overflow

I know about that ( thanks to factorio) but i'm wondering if it's normal than the wiki machine is 'failing' at filtering signals whose value are triggering an overflow.

There is no blueprint on the wiki for that machine, i tried to reproduce it and then make a machine with similar functionnality as my reproduction. My machine seem to have similar output table than the one in the wiki, including the same overflow, but maybe it is because i did a mistake in copying the wiki's machine and then make a faulty machine of my own .

Purpose of filtering
is obvious when you try to make a load-unload service train. e.g. a train supplying defence wall, or a build train.
Imagine a situation your train has 20 different products, but you want to unload only those which are missing in the local logistic network. On top you want to quick loading process by stack inserters with "set_stack" feature. Ring a bell ?

Simplification is nice, I have to check it, if it realy works as intended. Perhaps, I could use it for my trains.

I think what you describe can be achieved with less complex combinators circuitry this feels like requiring a tank to kill a rat or a cannon to kill a fly, i don't know what the appropriate comparaison in other langage x)

Also I'm not sure my "simplification" is more simple when you try to use the contraption in practice since both constant are wired with both color of wire. but i hope it works as intended i just tested sets of random value by hand with extreme cases but i wasn't quite sure what to test else x).

[gGeorg]

i'm wondering if it's normal than the wiki machine is 'failing' at filtering signals whose value are triggering an overflow.

I understand combinators as raw_math_code_machines so they behave properly. Overflow is inevitable behaviour of numerical machines. Try any clock from wiki, it "suffer" this feature too. Definitely not bug but feature of all devices we have now, include wash machine in your kitchen.

I think what you describe can be achieved with less complex combinators circuitry this feels like requiring a tank to kill a rat or a cannon to kill a fly, i don't know what the appropriate comparaison in other langage x)

Well, if you think so then try to make it. I have burned 50+ hours on such train station. It is not as easy as it appears.

[mmmPI]

I understand combinators as raw_math_code_machines so they behave properly. Overflow is inevitable behaviour of numerical machines. Try any clock from wiki, it "suffer" this feature too. Definitely not bug but feature of all devices we have now, include wash machine in your kitchen.

I'm attempting to teach myself those with the help of the internet, and i am my own wash machine too

i'm often not too sure what i'm doing like maybe in intermediate step of calculus the overflow will make my machine only function with a certain range of value for "a" or "b" due to using a certain math formula instead of another.

which could or not make it impossible/unreliable to use. ( i can't tell since i don't understand the purpose of my creation it's an attempt at replicating something i discovered on the wiki ).

Well, if you think so then try to make it. I have burned 50+ hours on such train station. It is not as easy as it appears.

I'm not saying it's easy, it took me more than 200 hours on the demo to understand the rail signal system before i decided to buy the game back in version 12

but since then i've spent much much hours in the game say steam (in the middle of the 4 digit number) not counting the time i learn things from youtube and the forum

I don't have to start from nothing, i think in memory i have designs where you can set the value of required item in a constant combinator. Then you substract the value of the logistic network using a wire between a robotport "read logistic content" and arithmetic combinator *-1 and you feed the result for the inserters as "set filter".

It's not very precise and flexible given the restricted amount of filter per inserter at the same time but it does the job with enough time and if the train can supply enough material. You need to be careful on the schedule condition and size of chests.

You can use the overflow method to encode the value in the constant combinator as very high number and addition the quantity in the logistic network so that everything overflow to a negative number except the quantity that are not high enough in the logistic network It removes 1 combinator of the 2. ( this was a time someone explained me how to use overflow on this forum ).

If there are more complicated method using the multiplier as filter to offer more possibility/less constraint i maybe avoiding it in my subconscient because of lazyness and knowing 1 method already so i just go with what i know for most circuits, the times i do something different/new is more like puzzle game, logic exercise because i enjoy doing those .

[SoShootMe]

Based on the wiki article about multiplier : https://wiki.factorio.com/Tutorial:Comb ... s.2FArrays

I have looked at this circuit to try and understand it and i think it can be made with less combinators but maybe i'm missing something.

The original computes "red * green" while yours needs both red and green wires from two outputs.

Your version has an incorrect output for one tick whenever the input changes, because the "each*-1" combinator changes one tick later than the "each^2" combinators.

For both, I think the maximum value of a signal guaranteed to avoid overflow is floor(sqrt(2^31 - 1) / 2) = 23170. I'm not sure if the final output is the same in all cases where that isn't true.

[mmmPI]

1)The original computes "red * green" while yours needs both red and green wires from two outputs.

2)Your version has an incorrect output for one tick whenever the input changes, because the "each*-1" combinator changes one tick later than the "each^2" combinators.

3)For both, I think the maximum value of a signal guaranteed to avoid overflow is floor(sqrt(2^31 - 1) / 2) = 23170. I'm not sure if the final output is the same in all cases where that isn't true.

1) i understand this could be quite a limitation, or to restore the same functionnality as the one on the wiki some additionnal combinator would be required and then it means this version doesn't relly require less combinator. I'm not sure how it is supposed to be implemented in-game and if it would matter for all/some purposes.

2) This i had not thought about that's the kind of thing that could make the usage unreliable without additionnal dummy combinator to propagate the signal. I think it can be just 1, i will test in game and update some day .

3) i have tested cases where it overflows and give the same results, but i'm not sure if the final output is the same for all cases either, i think the math required are function analisis and derivatives which i dislike/ are not intuitive to me.

thanks you for your review

[Nidan]

1) i understand this could be quite a limitation, or to restore the same functionnality as the one on the wiki some additionnal combinator would be required and then it means this version doesn't relly require less combinator. I'm not sure how it is supposed to be implemented in-game and if it would matter for all/some purposes.

2) This i had not thought about that's the kind of thing that could make the usage unreliable without additionnal dummy combinator to propagate the signal. I think it can be just 1, i will test in game and update some day .

3) i have tested cases where it overflows and give the same results, but i'm not sure if the final output is the same for all cases either, i think the math required are function analisis and derivatives which i dislike/ are not intuitive to me.

thanks you for your review

1) This can be fixed by rewiring the constant combinators. One to top and bottom; the other to middle and bottom, using the other color
2) 1 delay combinator will do, correct. However there is a 5 combinator version for pairwise multiplication: (a^2 + b^2) / -2 + (a+b)^2 / 2. (No pictures as I'm not on a PC currently)
3) Main problem is that all combinator math is done modulus 2^32, i.e. results are truncated to 32 bits. I doubt function analysis as tought in school will help you here.

[Tertius]

If you just want to filter something, you don't always need an a*b multiplication. This is a generic solution, but you seldom need generic solutions.

In my experience, if you add and substract values from each other to get some result, at some point during the calculation your desired values are either all positive or all negative, and the undesired values have the opposite sign. At this point link a decider combinator with a EACH >0 or EACH <0 condition to get the desired values only.

If there is really the situation that you have line a with a bunch of signals, and you have line b with a different bunch of signals, and you want to get all signals from a where there is a non null value in b, I would use a custom hack. Slightly generic, but not fully.
Multiply the desired values (b) with some constant, so they are above a threshold. Add a. The desired values are now above the threshold, the not desired values below. This can be filtered, then revert the adding of the desired values.

There are the following realistic restrictions:
- all signals in a and b are positive
- no signal in a exceeds a maximum value. maximum^2 must not exceed 2^31, i. e. 46340. However, this restriction applies to the generic multiplying version as well.

1. #1 arithmetic: multiply b with 46340
2. add a to the output from #1. This makes all not desired values from a < 46340
3. #2 decider: From the sum, select EACH >= 46340
4. #3 arithmetic: multiply the output of #1 with -1
5. add the output from #2 to the output from #3 to revert the addition and get the actual numbers again.

Pro: works perfectly for all values from 0..4630, latency 2 ticks.
Contra: values must be positive and not exceed 46340.

1.png (43 KiB) Viewed 8350 times

0eNrNV22OmzAQvUrkX20Fq0D4SPjX/uglqhUyMOxaawwyJm264gA9SC/Wk3QwuyxJzAbSXan5Eclgv3kzb+Y5eSQJb6CSTCgSPRKWlqIm0bdHUrM7QXn3TB0qIBFhCgpiEUGLbtXtU1QoOy2LhAmqSklaizCRwQ8SOa11ESGDlGUgzQCuEWDPpGrwyYDR77Cd0clNe2sREIopBn0menGIRVMkIJHbcBo4pEqy1AYB8u5gYw1A5jQFDFCVNSKUoouOqLYThBY5IDF/i7EyJvGofu1aJGnyHGRcs5+I6qyHT5fDSXD3hXqTYAE1hiFa6PfRgqA1oGxelcEAtw1ungF3Nz4mgOeULHmcwD3dMzyEO3PGMf8J9adK/5lotKZrH2ek/62Jt7eYt3fC+7jwi7M47kAmS2FXnCqYSMKaMQZVhT18CuK67oVWPoapS84yO2+Aj0A2nj/q6hkgCoCf57MeQLwZIJUss0ZX2K5TBiIFu6Lpw5jWgOfPweO0VjhiCZUjDM/H8RhwAuwWLabota07NKf7upMAYjzELMOwuJfJtGFKL3WvGZrNf81pTCO36zstdGZ22hNsjO8yNvDOmaxVPHt+gKb3fWH6gcDaBLo2SLaiUpONyJ9fv/Fk2aiquQq7OsS68nEuyyJmAmFIpGQD7UThJWSnZd8dl93tfNaoj6fldCdggpFUWr71Ga5RzuAlu4JyTO7ZvKuSGw07dJ+940nRmXn68/iE13twx+wtPfjLEg/eXu/BT7zf34PdsX/+gw07y0zY6J8jJnP8s2543kgjhzl2+R2Dy84s5fFVMPLKqz03GHtuOOm5l0d/ynF3AwMqmbovoCNxobncha31gvw2vltDBxOf2W+J/dT/OovIp6u9d4G9bl91zfM7b8J8T+10Sqtu31KxhhvyvxHLdt5bKWORz6/C+dL19wnKp2c2Gv39sginCY59RL5q/1zRVXJYJasPe6wjprtyPuKePRprX/Ot44U7N/S27ibYrtv2L6mGnro=

Copy blueprint

combinator settings

#1:

2.png (41.26 KiB) Viewed 8350 times

#2:

3.png (50.6 KiB) Viewed 8350 times

#3:

4.png (38.28 KiB) Viewed 8350 times

Here is also another, completely different approach - a logic/binary approach with bit operations that allows values up to 2^31-1.

Select the desired values (b) as 1. Shift them 31 bits to the left (the leftmost bit in the combinator registers). This will appear as value -2147483647. Add the existing values (a). Now we have all values from a, and the leftmost bit is set to 1 for all values from b. So select all negative values, because these are the ones that have the leftmost bit set, which acts as filter bit. Then clear the leftmost bit by substracting the value we still have from the 2nd step.

1. #1 decider: create 0/1 from b for <>0 values
2. #2 arithmetic: shift left 31 bits to have a 1 in the leftmost bit for all nonzero values from b
3. add a to the output of #2.
4. #3 decider: filter values <0 from the result of 3., which are the values with the leftmost bit set
5. substract the leftmost bit. This is what we have as output from #2.

Pro: supports arbitrary values in b and positive values up to 2^31-1 in a
Contra: if a value in b changes from zero to nonzero or from nonzero to zero, the output becomes -2^31 for that value for one tick after 3 ticks. Can be avoided with an additional combinator, if necessary.

b.png (48.25 KiB) Viewed 8350 times

0eNrNl1GOmzAQhq8SuS+tBKvgkEBQX9qHXqJaIQPDrlVjkDFp0xUH6C16tp6kY8gSkjW7JLuVykMkwP49nvnnM3kgiWigUlxqEj0QnpayJtHXB1LzO8mEeab3FZCIcA0FcYhkhbkz4zST2k3LIuGS6VKR1iFcZvCDRF7rvKiQQcozUHYBahXYcaUbfDJo9CNcOpq5am8dAlJzzaHfSXezj2VTJKAwtmE2CEi14qkLEtTd3sUcgMpZCrhAVdaoUEqzOqq63mbjkD0GFoS4VsYVTu1eU4ckTZ6Dimv+E1W95XCZPZwtTo+hNwkmsNOwrBas+9XCoLWorJ4tg0Uu3NwcBLfezRo3gPO0KkWcwD3bcZyEI3MucP8T1Z9K/SfSqTXGPt6o/re2uP2L4/ZfG/ep57gqpVsJpmEibGeG8asKXXsuQil9wbynMnUpeObmDYiRyMpfj3w8Q0QDiKf7WQ4i/gyRSpVZ05nZrVMOMgW3Yum3cViD3nqOnmC1xqZKmDoJqr8GqQ1apKun7DupNoKe+blTAHLcuTzDlXEsV2nDdXfbGczisPVzeLH12aGrt6vOXqd9bTPbQTbGdxkf4s65qnU8u2mApfd9bvouINHS3BQVU12gEfmIc8pGV81VqtU+7tIe56osYi5RhkRaNdBOpFxBdp5w46JxxqnhqrU0fldJOlm6zahOE8rWWm6OGyyYwP094roqhRXRAR1osXqkxVXumoooeAV3/bfl7udLuBu+grv+P+MuHTPzFej1LgOvlZmjSOYws25E3ihrDHMQ+R0XVwaQ6hT/Izhey1mXnoM2mAStpeu38zC7vRCzIT1x03+D2T+/fr89aHMm6ktIGx75OYPDUyUx4w5hMsX1fQHGHC+cftsLy3JUfpvK1GBk4mOBVthIJTZ5/2GM5+D1B2F7tevpswV5+iXiXHCo4OCujaPR/y6HCJYgCSLypUPqgi2S/SJZvN9hvjEti3f0Aw7aIWz74oSeH2xp4Id0tQmXbfsX7QSdLg==

Copy blueprint

combinator settings

#1:

b1.png (43.97 KiB) Viewed 8350 times

#2:

b2.png (43.38 KiB) Viewed 8350 times

#3:

b3.png (51.74 KiB) Viewed 8350 times

ps. if I had a wish granted to me, I wish 64-bit integer arithmetic in Factorio.

[DaveMcW]

Here is also another, completely different approach - a logic/binary approach with bit operations that allows values up to 2^31-1.

You can avoid the binary explanation by multiplying 1 * -2147483648.

You still need to explain the overflow magic: -4294967296 overflows to 0.

[gGeorg]

1. #1 arithmetic: multiply b with 46340


Pro: works perfectly for all values from 0..4630, latency 2 ticks.
Contra: values must be positive and not exceed 46340.

Instead of multiply/divide you could add/subtract value of half of range (e.g. 2^31/2 = 1 073 741 824),
then your working range is 0 ..1 073 741 823

That trick with bit shift is even better, because of double working range.

[Tertius]

Instead of multiply/divide you could add/subtract value of half of range (e.g. 2^31/2 = 1 073 741 824),
then your working range is 0 ..1 073 741 823

Of course. Dunno why I didn't come up with adding instead of multiplying in the first place. However, the maximum cannot be 1 073 741 823, because not only a + b must be < 2147483648 but actually the sum of every a + (b + constant) must be < 2147483648, otherwise the intermediate value used for comparing is interpreted as negative. So the maximum value for each a and b as well as the value to add is floor(2147483648 / 3) = 715827882.

This is a blueprint changed accordingly:

0eNrNl1uOmzAUhrcS+akXGAXCLby126hGyMBhxioYZEzadJQFdCHdWFfSY8gQSMwE0lRqHiKR2P+5/MefkxcS5w1UgnFJwhfCkpLXJPzyQmr2xGmuPpP7CkhImISCGITTQj2pdZJyaSZlETNOZSnIwSCMp/CdhNbBuKqQQsJSEHoBWyuwY0I2+Emv0a0wrcHOzeHRIMAlkwy6StqHfcSbIgaBufW7IYdECpaYwEE87U3sAYiMJoABqrJGhZKr6KhqWp5vkD0m5gYYK2UCt7Zf2waJmywDEdXsB6pa6/6lajgLbp9Sb2JsYKuhiea7XTTPO2hUNm/aoJELvIdXwe2DiwXgPinKPIrhme4YbsKVGcux/gn3p1r/ibRqjRofa+D/oy5vZ3Hezlne48YvrmI8gUyU3KxyKmGiCGPGMagqnOFzEdu2r4zyWKYuc5aaWQP5QGTjuIOpniEiAfLLeta9iDNDpBJl2rQdNuuEAU/ArGjydZhWr+fO0ctpLfGIxVQMNHzLDWw/CE5d8nBiWkN552+tFC319iQA+PAgsxRD41omkobJ9rGdN83AuW/RRnfstt20+dbMaTvKRvhdyvq8MyZqGc0+Q0CT56453aEY9QcTrqhoEw7J75+/cHfZyKq5Sb/aR60DUSbKImIcZUgoRQOHieYLSM9bvx233la81XrktJbaEzLewK7WwvWFrtZS71RdQXMs7hXiVZlrwe3brww5ujqzTndePv7tLFaZ3ZPFn5ewOLidxce8/z2LLzHxF0y2lhFZC9MB1ufAtG7yrBHaHOaw8xsGF4qcYnQvWGt/4ztWYG8G9Lwfif1JEl+HwRSHt30WVDD5XIBK5Mq42QuH7aR8HxrXoGQiLZRLHLDut1tIPt5M5AXQDd5k6eVtOIHkc8hO+aXWLTWsvzv/G8NMa+zUh7s7pW3y5QU537rulkH72rMbDv6cGSSnMXIgPFJ1RVfxfhWv3u2wj1juynq/2tm4bIfE7doeWI6/tX0HSeEF68PhD7u9piU=

Copy blueprint

With this modification I prefer this variant, because the range is big enough without the glitch of one tick with -2^31. However, if you use the result for chest or inserter filtering, this is irrelevant. On the other hand, you will probably not need to handle more than 715827882 items in a chest or in some network.

Edit/Addition:
Ok, not adding but substracting is the final solution. If you substract 2147483648, you have the "full" half range for the intermediate values, because a and b are > 0 as requirement. Then a+b must be < 2147483648 resp. a+(b-2147483648) < 0, which is true for a, b in 0..1 073741823, so you have this as range.
So the changed steps:
1. Arithmetic #1: EACH + -2147483648 (you cannot do - 2147483648, because the GUI changes this to 2147483647)
3. Decider #2 condition: EACH < 0

0eNrNV9uOmzAU/JXIT73AKphrUF/a36hWyMBh11owyJi06Yp/7zFkE5JAAlEqNQ+RSOzxnDPjOck7ifMGKsmFIuE74UkpahL+fCc1fxEs15+pXQUkJFxBQQwiWKGf9DrFhDKTsoi5YKqUpDUIFyn8JqHVGjcRUkh4CnIcgI4CbLlUDX5ywOhXmNZgp90+GwSE4opDX0n3sItEU8QgkdthN+SQKMkTEwTIl52JPQCZsQTwgKqsEaEU+nRENS3PN8gOibkBnpVyiVu7r6lB4ibLQEY1/4Oo1vrw0jWcHU6P1JsYG9hhjJzmu/1pnteOoNhXZRiBC7ynD8DNk4sF4D4lyzyK4ZVtOW7ClRnPsf4J9ada/510aI22jzXQ/3mMt7OYt3PG+7Txi6s4dSCXpTCrnCmYKMKYcQ2qCj18DkIpvWHlU5i6zHlqZg3kAxDbcQeungGiAPLLetYHEGcGSCXLtOk6bNYJB5GAWbHkbUjrgOfOwctZrfCKxUyekPJt37ECegTzZoCxdMuQUWomXCYNV9cRfTRh5xHRW6bWuJZ+e5EAYpgNPMVqcG0P2z12Fh7xsHstwMZu8qY3sG/NNPAeNsLvUn7gnXFZq2j2tQSWvPbd6e8ZCdf6oaiY7IiG5BvuKRtVNXehVruoa3yUybKIuEAYEirZQDvRcgnpecM3pw2nOrhHlXE6IekEjDcQqRNufYE7KqR3rK5gORb3MQ2qMh+dAD79CKO9ljPrdOfx8e8Pdc3skaH+Y0moB/eH+p73vw9133ID6gcBfUS4W8uifTSVB/NhTirXTZ41cpTDnBD+hYdLHcHyZMDcmcKzI306gG+nwVT8bo7DQHL1WoBmcsNvdKHbjsiPCeEaNEx0zGKTWo7vBLbn4OUp0WP978CQfL07lBfkbnA1Ti/H4EQqn+fslGJ63VLJDkPz/5HMOlXqy8OVGm3y5YycL10/aFC+7vqGgz96BslZjFEQ7oN1xVbxbhWvPm2xj1juyvq82tq4bIuh27c9QMduKJqW2l6wbtu/r9S9Rg==

Copy blueprint

[gGeorg]

not only a + b must be < 2147483648 but actually the sum of every a + (b + constant) must be < 2147483648, otherwise the intermediate value used for comparing is interpreted as negative. So the maximum value for each a and b as well as the value to add is floor(2147483648 / 3) = 715827882.

Or you can normalize (b) index signal so the range is [ half_of_signed_byte ( - 1) ] , for a cost of a combinator.

0eNrNV12OmzAYvIsfW1hhAiHhoVJ7jWqFDHzsWjU2MmbbdMUBepBerCepMVlCEpOFbPqThygQPJ7vm/HYPKOUNVBJyhWKnxHNBK9R/PkZ1fSBE9bdU7sKUIyoghI5iJOyuwIGmZI0c4GDfNi5ejzIgmSAWgdRnsM3FOPWeRWnbtJaEUUFHw3023sHAVdUUejZmItdwpsyBamRbeMdVImamp96Ng3j+t7KQTsUh9667bicoPgzqrGB4gHUQTmVeqj5W8OlTVGATGr6XaNib/hYJl8Nk3ctV4QrNxNlSjlRQtqmxcFduJ94exfqqfU4JQVLUngkT1QP0k8WlGnmEwo+UakafefQPPOE+xEZtKazAB6pd29rWrCYt3/C+7hli6s49g+VgrsVIwominjdgpmoKpBnIL7vjww5w8mC0dwtGmAjkFUQDiCrOSAKgJ3X4w0gwQyQSoq8MR1264wCz8CtSPZlTGvAC+fgMVIrvThSIkcYEQ43frTZHLq0nlOgZgJTtLAXraIAb/wDP+xpGxqX8N40dQeNu68HCcDH6UBzXY9+lsqsocpcGhNbXBwOhHLIaK7lv2xiL+otjPFMC+9hE/1fTgfeBZW1SmYvTCDZY9+efqWNOhR0d8uKSMM4Rr9+/NTDRaOq5qoJql1iREgKKcqEcg2DYiUbaCe6LyE/7f32uPcmxa0iBUZTfwJmPdLLaOid4Vo1XR+qKwnTxb2EeiWYPci9l2TayzqzznAen+j6hO8y85YJ/2lJwm+uT/g97z+f8Ofh84akx8ty3hrRo80imHXsYUUjrRzmJPJXPbns8lge7TaW/FzfMN+jv5vvlpWH8bx43w58iKTqsYSuvFdM7C208AH5NiFfQweTWLJed0to3/an3Bi9vzro2+s77V+M7PNddyL5T7N8SsDuuaUKDnv0f6Ogi4+Ve3dz5axN3r5BuqnNDOOFJya8f0vqNrV/eWLyTg5KH25/TCoIq5eckzYXBdnaVoheTyZn49HruoOe9Bbat3SDg2jrR0Gw8oJ10La/AbSbSyQ=

Copy blueprint

[mmmPI]

1) This can be fixed by rewiring the constant combinators. One to top and bottom; the other to middle and bottom, using the other color
2) 1 delay combinator will do, correct. However there is a 5 combinator version for pairwise multiplication: (a^2 + b^2) / -2 + (a+b)^2 / 2. (No pictures as I'm not on a PC currently)

1) I updated the wiring and added the dummy combinator where i thought it fit to avoid the 1 tick wrong value during transition. It look like this :

6combinators filter and mutiplier

6 combinators.png (176.51 KiB) Viewed 8242 times

0eNrlmF1vmzAUhv8K8mUHHeYrkLtNu9xNbzd1ER8nqSUwyJhqUcR/nw1Z4lKnxayLKjUXkZzYD8fn9bFffEBZ2UHDCOVofUAFtDkjDSc1RWv0rYbWSm8yK0+plYHVtVBY25pZW1JyEGN2Vkt2NC1bC9mI5DVt0frnAY0/Sh7fNyBAhEMletC0kq2UEf5QASe5k9dVRmjKa4Z6QaAF/EZr3NsaxiNhvBO/nDBjDydSRnr9vY2AcsIJjKEMjf2GdlUGTKBPo2WwPKVcDcFGTd2ScfIHJCOJ49vQRnu0dgL3NhQPEsM4q8tNBg/pIxFjRMcxGxemfinsL2igdTLvWJn6fS9nPwnbMww7cf9X2D+UsMOFimEtwzNi+FqGb75yjozoxAiMGCuF4eDgRAmNKHcKxcPBKoj9KDjDIiPYdwWWuMfPibUyYu0YAFVXqorCZrIzKBSS7505omzHNUohl8u4lTQsv8bnK4VMCqGQ6EtY3hE+NIea0RSN/8qGoykb/0nRFISN8QwFqCuhM3gj/i7IKfgtYS3fzE4NpPmDzE0LErP5W+TDc+sGWHrckH+JkXXHm86Y3V9IsBRlkt5YyaVsJ8/TbSNvrjrehBbOEy9YLh7+MOJp8+/9m3z+VD69PqG5PuF7Ky73qT6frqOPJsEv6RFN5XuqLnbn6RWZ67V6b3o5k4L6fB3BQjPB8KUtbbXYe/rJ25q4rybeM17sPd86bP9C2Es9H17oPVXP5y30nnfaOILFRs9b6DynBs/Bb2PvnGCOvdO4D3+eP0gW+wM//sjm7nl67dkm+8Vdz52nm+y30Di8H+FkkajK3VznIErMDqJwnjPA5zuRCgrSVQ6UIhwmZGnqEnSCaA6meTOIdCGJFTjcD62VqygblWkGIo8oss6L43jbdLx+Ep0exRkyroRYvDUnnnhx9vwodvv+D+krXPA=

Copy blueprint

2) I think i managed to make the 5 combinators version from your formula it look like this:

5combinators filter and multiplier

5 combinators.png (163.27 KiB) Viewed 8242 times

0eNrlmEtv2zAMx7+KoeMQd5H8TG4bdtyl1w1d4AfTCvALshysCPzdR9leoqZOEwkZVqA5BJAl/Uzyb9K09iQtOmgEryRZ70kObSZ4I3ldkTX5VkPrJJ9SJ0sqJwWnayF3trVwtryQgHsenZY/VknROmRBeFZXLVn/3JPxouLJ5wYQxCWUuKJKSjVKBJdPJUieuVldprxKZC1Ij4Qqh99kTfvFDGPHhezwygEzrnADbSfrHxYEKsklh9GUYfC8qboyBYHoC0YsSFO3fHR/TxSRsgV5JmvXZ3cB3ijnArJxHifQYynqYpPCU7LjuB83HcEbnM4HWKsmtly0cnO1X5BkT8q1FhRGsVqZKJXwvnUDIplE+oU76042nTG77wcPqtGhwUaq/gTkeuw4jkIV2EcBUJ3O+P0DYpjaNzuvosRF1nE5DCku75W+J8Iwc2H8dy7M55sLMxtg+jLA7IIe8evlc3p4B8v++ve2GsvoLpj0oIMecwqMZeNMjTgXki9koHUqwlSrEQ9zZvumZq9OzL78GFk58UNzIrAsdHSWwYwY3izDM2KEGiM8MHwjRqQxXJXJEyUwotxrFKwHkR97oX+EhUaw7xpstZx+B1ZkxBozT3tudRQ1k11V4yPJY0fOmOq2hYJq6aPG0XWFOrAuDN7qtoXhq0lhCK0Lw2T2PyoM3hknbBOSWhYGPSGZZWG4n7XDt85CZlkWTrPPpbfJPde/JvdmuqcLmUeX16VeZN28evGHaV6tmtTYTKBzTVNs3cS+H4Hc/9PFRmZdLDtd/lKw1RmBVgdLS8h5V7pQoHUCVWrqAub0CV+/va5z6Mo+Wz1atkkdffAv0jefkGgu/vgROxxFrLVTjwUpkhTQRhI4x7i308nGdNSBq3b4bh+jHGOruWLYbTIvjJd9/wcku9H5

Copy blueprint

If you just want to filter something, you don't always need an a*b multiplication. This is a generic solution, but you seldom need generic solutions.

I would use a custom hack. Slightly generic, but not fully.

There are the following realistic restrictions:
- all signals in a and b are positive
- no signal in a exceeds a maximum value. maximum^2 must not exceed 2^31, i. e. 46340. However, this restriction applies to the generic multiplying version as well.

Pro: works perfectly for all values from 0..4630, latency 2 ticks.
Contra: values must be positive and not exceed 46340.

Thanks you ! I'm not going into the details of the build but few points ,

1)it does differs from the wiki and my original version for the negative value. (which i started testing after you mention it)
2)if the value exceed 46340 sometimes it appears to still function as a filter but not as a multiplier its not exactly as you say i think.

I called it the 3 combinators version and standardize it with the 6 and 5 version using only green wire when possible adding red only when necessary and using the same set of inputs as the other to make it easier to compare the outputs for various test value.

3combinator signal filter

3 combinators.png (153.48 KiB) Viewed 8242 times

0eNrNl8+OmzAQxl8l8rGCVTB/Qri151722mqFCMxuLIFBxkSNIh6gD9IX65N0DCm4CWxilJWaQySD/ePzjOcbOJFd3kAlGJckOhGWlrwm0fcTqdkbT3J1TR4rIBFhEgpiEZ4UapQIJvcFSJbaaVnsGE9kKUhrEcYz+EEip7UmGAcmZINXBkw/w3a1lbR9sQhwySSDXko3OMa8KXYgED2sVmJlwqUuwSJVWePakqvnKp63fvItciSR7dEnHx+Ey6Qo83gH++TAcA1OfGW5BDGz9TnZn0lHa1TsHG3rL63a/YVsaiqbXsjOmIC0n0EfuIlv2ib8hflzJhnU/AxcMVwjRqAxgoHhGTE2GsN2vIHiG1GeNQp1vI0XuoE3wgIj2FcNtl2ffwNrY8R6EwBcP7c6yjFLu4BMI7l05GAR94XG+yNbK5qj/vrna2XNMlyKc5lIGya7YVdBEyXkDgIySFkG4kYFhef6Wd9ZP2dqjPcyNsh+ZaKW8d1BgSTd91HpqxzPX9DFGLVWiei0RuT3z1+4smxk1SxiV8e4C3v8KsoiZhwxJJKigXYm7ipXF1Hf/Bv1zngn09Nnk86mz9NypcbhFXgynd6wvQIy1hQ25KhaYEupyhwmEuqPlrj+6+SLDticIn9xa3G3j20tX0xaS7C4tZxlf1BrcWc2sdTSnYWtRbd0urC1PE/q8Bb7OF3YWC7923Ye4962d49733aROe/e3Hh1nDilpmd0BD/GwWtQmPjKyMsK0MY7JeTTYhc3MOpg9N+Ju9fNc8bGw/syFZpnKvzfMqWq4mPTNBnh6476bt+c7EqYve5TK9K+zCySJztA0cRdjZlY9UJXvTfjpAM6dB/2EF85txTfOqkbhOu2/QPdoqii

Copy blueprint

Here is also another, completely different approach - a logic/binary approach with bit operations that allows values up to 2^31-1.

Pro: supports arbitrary values in b and positive values up to 2^31-1 in a
Contra: if a value in b changes from zero to nonzero or from nonzero to zero, the output becomes -2^31 for that value for one tick after 3 ticks. Can be avoided with an additional combinator, if necessary.

This one i expected to be possible since it was mentionned in the other thread that the multiplier was made obsolete due to the introduction of bit operations. I think with your explanation i understand how it functions and added the 4rth combinator because there was no 4 combinator version yet !

This kind of operation i can only watch other people use and think it's cool, it's not coming to me naturally as a tool to solve problems yet

It's using the same test input as the others again to make it easy to spot the differences in output.

4combinators signal filter

4 combinators.png (144.08 KiB) Viewed 8242 times

0eNrNl0GOmzAYha8SeVsYBeNAQNm0625m22qECPyZWAKDjIkaRRygt+jZepLaMAVPAgpGaTVZRALsz89+/zPmgvZZDSWnTKDwgmhSsAqF3y+ooq8sztQ9cS4BhYgKyJGFWJyrq5hTccxB0MROinxPWSwKjhoLUZbCDxQ6jTXCOFEuanmnx3QtbKL1xM2LhYAJKih0UtqLc8TqfA9covveSqyImdAlWKgsKtm3YGpcxcP4aWOhMwpt4jxt5ECym+BFFu3hGJ+o7CMbHmgmgE9MfUr2Z9TSarV2jjb1l0bN/ko2NpVN/pXsb5rszULHnFEGNmK4owzXiOFpDK9nECOGrzFsh/SUjRHlWaNgh/hk63pkgHlGsK8aLFi//XqWb8R65QBMr1Qd5ZjZziHVSC4eODK2XY0ySFQZV4rmqL9ufC3INEXhVralPKmpaC/bzIyExl2cdXf72NB8Mck6WZz1R8t2J2QvzZizMOt6xvDCrD+P6iCLg4UXJv06ULbzmDjZZE6cVJ+rMG3mhWnTD59CQlPgd4rSf1eSKeWdlHbhxgr0jRrJZyntRR8or0Q0e0kgTo7dmnTBQeFaXeRlzFudIfr985fsVdSirBdxy3PULnh04EUeUSYxKDzEWQXN/CUnrT94cn/z5lni3TlQ3brirg1dGcCPMaYChYkGf1xZ/kUJ0p5WBtrtFtvTmLxCrqoeD46M+HX7vrHGqf4843xz49yPZtz6vW+f/o9t3qRtcw4KeMKPrdne1psRfKy9bff4nU3w2mRju7VnIij3jPOvQda7x8GEkUE/vRxSWuc2ZFI1l+kqiwzGrBzOTsHfs9OiM2hXWnK67ZduqH0YWyiL9yC9QGQ1lNWqW/9Vdy6TjU7ydNbV0Fae/wMsPwGw623XTfMHdsMurw==

Copy blueprint


For easier comparaison i also remade the original from the wiki as a blueprint with the same set of inputs but without changing the wiring.

7combinators signal filter and multiplier

7 combinators.png (117.05 KiB) Viewed 8242 times

0eNrlWMty2yAU/RWGZSqlBiHJ1q6PZTfZtk09epCYqQQahNJmPPr3guXKsio3Qnl5Jl54BgOHe8/hwjFbmOQ1LSXjCkZbmNEqlaxUTHAYwc+CViC+SEAac5BQUFc0AzdCghuWK6rn3IKK3fI4r8B3/kmUzHRLUQC1oeAX+8kA4yCPFQV4gRF0IEsFr2D0bQvbeWZJdV9SvRZTtNAjeFyYViyZ2hRUsdRNRZEwHishYaMReEZ/wwg1zgjGHZOq1r90MO0IN+zNxM21AylXTDHahrJr3K95XSRUauhutglWxVz1Q3BgKSrW8rOFJpJgdek78B5GLsGXvl4oY5Km7QjsGBAlRb5O6Ca+YxpBT2vpO0HEqSQ+mCRSURuhUI+I68ZwMUgCWyYRopdJ4msvCX+mmmgUA1theKMYnhVG0MMIOgxivzP3GC4iHYpvhXLVQ8GIhGTpBeQAFliBfemBrRb7T4cVWmHdSkp5f9/2oZCd7JJmPSQPH3B0Se86OG+3bGXQkPkyc3olznRL05IymdZM7Zq7+hkpIO+Bo2ikhMi+gLyJBXQAXuvujHWh3zBZqfVkYmicbgwzFTUw678FDyNNtSipjPen+Ts9U9SqrK2xm0fR60B8YrA/TQsyXwv8lrXwhvQ6R927m7Ct0MHE1WAkWtioitA0WX17WcNzkxUfy/rjFWTFD4iF/ytWME2rwFqr5eLctHLJsVjvX0Is30aM8AT7YRdGQTNWFy7N9dJSS1CKnI6RP7RzE6MNHtha+N9sxuJdzrfQ6Dnd50cbC72ab6GfNQnvRBJzrSuaaaH71hXPtNBXo3GQ2X4VzzTQQ5/qoqdxqS6Z4lJH7+CJPtWc9nPNETqbkxkdn8wXT34yT6X40V4VofmuBr1lV0NsLsrhRXRSDTzft5yNGq9hW4Yefopv0f8mdo94Ue9J0YF5nFAdIgzBgfZq/2y4f0fUo+70NdiSvEQkXOGQLLEXLBdN8wdjn/bb

Copy blueprint



Now i need more time to process the other feedback where i can read -2147483648 and 2^31/2 = 1 073 741 824 and the "overflow magic" it is becoming seemingly more and more complex as you reduce the number of combinators

thanks you for sharing

[mrvn]

Ok, not adding but substracting is the final solution. If you substract 2147483648, you have the "full" half range for the intermediate values, because a and b are > 0 as requirement. Then a+b must be < 2147483648 resp. a+(b-2147483648) < 0, which is true for a, b in 0..1 073741823, so you have this as range.
So the changed steps:
1. Arithmetic #1: EACH + -2147483648 (you cannot do - 2147483648, because the GUI changes this to 2147483647)
3. Decider #2 condition: EACH < 0

If your range is 0 .. 1_073_741_823 then you could adjust your constant and shift the range to -536_870_912 .. 536_870_911. Would need an extra combinator at the end to shift the result back to negative numbers. Still better than the multiplicating version with it's range of +-46k.

It would be great if you could add both constructs (full positive range and adjusted for negatives) with your explanation to the wiki.

[mmmPI]

This one i expected to be possible since it was mentionned in the other thread that the multiplier was made obsolete due to the introduction of bit operations. I think with your explanation i understand how it functions and added the 4rth combinator because there was no 4 combinator version yet !

Here is also another, completely different approach - a logic/binary approach with bit operations that allows values up to 2^31-1.

You can avoid the binary explanation by multiplying 1 * -2147483648.

You still need to explain the overflow magic: -4294967296 overflows to 0.

I mixed up several things here, what Tertius made is a not a multiplier (supposed to be used a signal filter in practice), it a signal filter for practical use ( which doesn't act as multiplier though), which can be done without the bit operation and instead multiplying the different 1 value from combinator 1 by *-2147483648 inside combinator 2, the overflow magic mentionned by DaveMcW is allowing the sum of 2 number close to -2147483648 to overflow to value close to 0 at the last step ( 5). [if i'm understanding correctly]

What i expected to be possible is a multiplier less complex than the one in the wiki that is using seven combinators, my corrected version uses 6 but the version made with Nidan's formula uses only 5.

However none of those uses bit operation which may even reduce that number further. ( it wouldn't be "just" a signal filter but the more generic logic "a*b")

but then i named the topic "signal filtering device" which is not a good title it could have also been "multiplier". or maybe as I'm interested in both "multiplier and other signal filtering device"

[Tertius]

The "overflow magic" in my example happens when 1 << 31 = -2147483648 = binary 1000 0000 0000 0000 0000 0000 0000 0000 is added to a value with binary 1xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx.
You do (this is binary, only 0 or 1. 1+1 is 10):

Code: Select all

  1xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
+ 1000 0000 0000 0000 0000 0000 0000 0000
-----------------------------------------
1 0xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx

becomes due to overflow:
  0xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx

The leftmost 1+1 become 10, and because we don't have a 33th bit to the left, the leftmost 1 ist lost and we simply get 0xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx, which is the original value from a.

If you want to design something that depends on the bit-representation of the values, you need to think in binary values. And you need to know the representation of negative numbers (two's-complement) and why this is used. And if you cannot think in binary (I cannot, too many digits), you need to write all the 32 bits in 0 and 1 on paper and use the paper for thinking.

[mmmPI]

The "overflow magic" in my example happens when 1 << 31 = -2147483648 = binary 1000 0000 0000 0000 0000 0000 0000 0000 is added to a value with binary 1xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx.
You do (this is binary, only 0 or 1. 1+1 is 10):

I figured this out that's where you can multiply by -2147483648 instead of doing the bit shifting, it has the same consequences. the output will be the same in binary.

i think this is a particular case since all initial value are exactly 1. It wouldn't be the case if some of the b value were =10 for example, then 10<<31 = 0, and the filter is broken. (same with 10*-2147483648=0 )

This is where it differs from a multiplier which would requires the value from b to be not only 1 if i'm following this correctly. some data is lost before the bit shifting to make all b value =1, because otherwise you can't use <<31.

It it is more intuitive to me to call it overflow when it happens due to an operation that result in a very large number rather than when you do 1<<31 which for me is still a bit mysterious since it require thinking about the binary form of the number and i'm not used to it. Where for the large number it's easier for me to picture the numbers written on a cylinder of paper and starting over after a large number.

still 10*-2147483648=0 is not intuitive none of that is x).

[mmmPI]

If you want to design something that depends on the bit-representation of the values, you need to think in binary values. And you need to know the representation of negative numbers (two's-complement) and why this is used. And if you cannot think in binary (I cannot, too many digits), you need to write all the 32 bits in 0 and 1 on paper and use the paper for thinking.

on a joke side : I think i have an idea to replace paper by 32 or 64 lamps. Also i would need a contraption that convert my base 10 number into binary. this way less writing :d

i have seen couple basic explanation on two's complement, but haven't used much because either no purpose for me personnaly for what i've been doing or maybe when i could use it i didn't recognize it.

It would be the number that is represented by the opposite of the 32 lamps in my idea i think, if a number is represented with 32 lamps on or off, then you imagine the lamp that are on are instead off and vice versa. or you just plug in a unary not gate as pictured on the wiki to every lamp

[Tertius]

i think this is a particular case since all initial value are exactly 1. It wouldn't be the case if some of the b value were =10 for example, then 10<<31 = 0, and the filter is broken. (same with 10*-2147483648=0 )

To understand, write down the binary representation of a result, i. e. 1 * 2147483648 and 10 * 2147483648.

1 * 2147483648 is 2147483648, which is binary 1000 0000 0000 0000 0000 0000 0000 0000 (32 bit)

10 * 2147483648 is 21474836480, which is binary 101 0000 0000 0000 0000 0000 0000 0000 0000 (35 bit).
Since the combinator cannot store bits 33-35, these bits are lost ("overflow") and what remains are the rightmost 32 bit: 0000 0000 0000 0000 0000 0000 0000 0000, which happens to be all 0, which is 0 in decimal.

For converting to binary notification, I recommend the Windows 10 calculator app. It has a "Programmer" mode, where you can very easily enter and convert decimal and binary values and always see their binary representation. Unfortunatly it is 64-bit, so you need to take only the rightmost 32 bit.