These are two abbreviated versions of a patch I'm working on.

As far as I can tell, these two patches do the exact same thing. In both patches, after the right inlet is set, changing the left inlet will either a) send 1's to the object boxes when the inlets are different, or send 0's to the object boxes and then trigger the bangs when the inlets are the same.

Some questions I have:

1. Am I overlooking anything? Are they really exactly the same (in terms of function)?

2. [sel] and [sel 0] apparently work the same if the right inlet is avoided. Is there a good reason to use one and not the other?

3. Which of the two (if any) is cheaper processor-wise, or which of the two is faster (and why)?

4. Is there an even better way to do this?

5. I'm working on Windows XP and I tried using [cputime] but either I don't really know how to use it, or it doesn't work the way I expect it to. I guess what confuses me is that the right inlet is hot, not cold... anyway, any clarification will be appreciated.

This part of the patch will have to fire thousands of times very fast, so speed is definitely a priority. Thanks very much in advance -- this forum is great!

http://www.pdpatchrepo.info/hurleur/which-is-faster.pd

Ignoring the superfluous objects, according to your definition of use, both are identical in function.

Since you are comparing only two fixed values, 1 and 0, the use of [sel 0 1] would probably be preferred, with the parameters initialised and fixed.

The first patch would appear to be less efficient than the second as it contains an extra [!=] comparison. This is redundant, again only because you are selecting one of only two values, 1 or 0,
which the select already does for you.

You can improve this patch by using multiple float outlets from the trigger [t f f f], one to each spigot. As it stands the patch execution order is unpredictable and may cause problems. Study a little more about triggers to understand why you use them to obtain signals in a certain order.

You can't really get CPU metrics using just this patch. Until you instantiate many of them and heavily load the processor you will not see any useful measurements above the baseline. Make it into an abstraction and see how well 100 of one kind compare to 100 of the other. [nqpoly] can help you with this. I don't think you will see much difference and I think you could assume the difference is negligable here. Nice to see a programmer being mindful of efficiency so early in the game.

obiwannabe,

thanks so much. I tried your suggestion, and using "exponential" copy-and-paste (if you know what I mean), compared 256 instances of one to 256 instances of the other (in the original expanded version). In case you're curious, you were right, the speed difference is negligible.

The reason I have 3 connections coming out of 1 outlet is because the order doesn't matter there ... they all go to cold inlets of objects which are later banged on the hot side by the bangs on the left.

I've decided to use the patch on the left, because it's less cluttered with connection lines.

Thanks for your help!