Factorio Forums

kingarthur wrote:i had not read your post at the time i replied as yours wasnt showing yet. i didnt intend to copy what you had said already

guitarmanmike wrote:It is top to bottom in the sense that the algorithm evaluates the operations sequentially top down and the result gets passed to the next operator.

If you think of it as an algorithm which would operate on an arbitrary array of operands it kinds of makes sense to call it top down.

Operands ops = [
B1
B2
B3
B4
]

(* is AND, + is OR)
Operations opts = [
*
+
*
]

int i =0
bool res = ops (B1)
for opt : opts

res = (if opt is +) res + ops[++i] : res * ops[++i]

end

return res (zero is false ,1 or higher is true)


There is probably a more elegant way to choose the operation to perform but I think it gets the point across.

Jupiter wrote:For any devs reading this: if this is how it actually works then there is an obvious optimization to be made here: evaluate everything from bottom to top. This gives you 'lazy evaluation' meaning that, if you encounter an OR that is true, you don't have to evaluate the rest of the list. And if you encounter an AND that is false you can stop also.

siggboy wrote:

Jupiter wrote:For any devs reading this: if this is how it actually works then there is an obvious optimization to be made here: evaluate everything from bottom to top. This gives you 'lazy evaluation' meaning that, if you encounter an OR that is true, you don't have to evaluate the rest of the list. And if you encounter an AND that is false you can stop also.

Yes, after we've figured it out I assumed this is what actually happens, and that Rseding91 actually meant "it accumulates from the bottom up" (instead of top-down). Because that would make a lot of sense with the "right-to-left parenthesizing" that happens right now.

Although I wouldn't call for making the optimization that Jupiter suggests. My plea is to rip this out and replace it with a boolean evaluation where AND takes precedence over OR; what we've learned in school (well, university maybe).

(But I understand now why it currently behaves as it does -- it's obviously easier to implement than proper boolean evaluation.)

Jupiter wrote: For example:
(A OR B) AND (C OR D)

Is impossible to formulate with how the system presumably works now.

Jupiter wrote: For any devs reading this: if this is how it actually works then there is an obvious optimization to be made here: evaluate everything from bottom to top. This gives you 'lazy evaluation' meaning that, if you encounter an OR that is true, you don't have to evaluate the rest of the list. And if you encounter an AND that is false you can stop also.
With a 1000 trains in a map this might actually gain you extra performance.

int i = ops.length -1
bool res = ops[i]
bool quit = false


while i>0

    quit = (res && (opt[i-1] is +)) or (!res && (opt[i-1] is *))

    if quit
         return res
     else
         res = (if opt[i-1] is +) res + ops[i--] : res * ops[i--]
end

return res