I need a Guinea pig with version 10.2. Who's willing?

@Guesswhoitis. fire away

@Jacob, can you do RepeatedTiming[RudinShapiro[Range[1*^4]];]?

{0.076, Null}

@Guesswhoitis Let me see what that is :P

Okay, then try rs[n_] := 1 - 2 ThueMorse[BitAnd[n, Quotient[n, 2]]];RepeatedTiming[rs[Range[1*^4]];]

Okidokie

{0.24, Null}

Hmm, interesting. Can you do a second run to see which one's faster?

RepeatedTiming[rs[Range[1*^4]];]
RepeatedTiming[Total@RudinShapiro[Range[1*^4]]]
(* {0.249,Null}*)
(* {0.082,180}*)

Hmm, okay. Thanks for the help @Jacob!

@Guesswhoitis. anytime :)

P.S. note that I put a Total in there. Shouldn't matter though

Yes, it should be a bit slower, and yet it's still faster… :)

indeed :)

The function I gave is supposed to be equivalent. So, ThueMorse[] is a bit slow…

Ok let's test that then :P

Hmm, on second thought, what if you make rs Listable?

Hmm I wouldn't think that would help, but ill check

SetAttributes[rs2, Listable]
rs2[n_] := 1 - 2 ThueMorse[BitAnd[n, Quotient[n, 2]]];
RepeatedTiming[rs2[Range[1*^4]];]
(* {0.27,Null}*)

mm

wait does even change anything

Ok I changed the definition to rs3[n_Integer]:= ... and then I get the same timing

Ah, so still slow… okay. Thanks again!

No problem :)

I'll do a last test with preprocessed data

To test ThueMorse

Yeah it is indeed ThueMorse that takes most time:

list = Range[1*^4];
preprocessed = BitAnd[list, Quotient[list, 2]];
RepeatedTiming[ThueMorse@preprocessed] // First
(* 0.235 *)

Unfortunately, I don't know how to express ThueMorse[] in terms of RudinShapiro[]. Oh well. :)

My guess is that ThueMorse has no special code for machine integers, as opposed to RudinShapiro, see the following

mm = 10^(10^3);
RudinShapiro[mm] // RepeatedTiming // First
ThueMorse[mm] // RepeatedTiming // First
(* 0.00013 *)
(* 0.000040 *)

Oh, so ThueMorse[] is now the faster one? Huh…

It shouldn't be too hard to make a LibraryLink function to deal with the machine integer case

Hmm

@Jacob, I believe in that case, Oleksandr already has something.

I seem to recall he wrote a LL function for the Hamming weight. Modulo 2, you have ThueMorse[].

Ok, nice :)

It seems that DigitCount base 2 is faster than ThueMorse for any input

brb

Really… and Mr. Wizard was complaining that DigitCount[] is slow… :)

Hehe, well the timing is still comparable to ThueMorse for integer digits, so still slower than RudinShapiro

Heh. Thanks for the extra mile. :)

Again, anytime :)

Would someone please try to pin down which specific versions are affected by this?:

@Mr.Wizard don't see any crash w/ Windows 10.2

"You can only perform 30 searches within a 60 second window, please wait a moment and try again." -- Hmm. I did 17 (according to my history) with minor variations, improbably within 60 seconds. It did take some seconds to figure out another variation on the search terms and examine the results.

It's annoying that all plot markers are drawn after all lines have been drawn, in ListPlot, leading to weird results like

ListPlot[{{1, 2, 3}, {0.5, 2.05, 4}},
 PlotMarkers -> {{\[FilledSquare], 30}, {\[FilledCircle], 18}},
 PlotStyle -> Thickness[.01], Joined -> True]

@Szabolcs If they were drawn before, wouldn't that be weirder?

Oh "after all lines". I see. I suppose the purpose might be to ensure that the plot markers are always visible and can't be obstructed by lines

@Pickett That's pretty awesome! I like it!

@Searke I mean that the current order is line1, line2, line3, marker1, maker2, marker3. I think it should be line1, maker1, line2, marker2, line3, marker3

@ArnoudBuzing There's also this if you'd like to chime in there

Yes. I misunderstood at first.

If I had to quess, I would think this was intentional.

The PlotMarkers are the most import part to be visible.

Although this does make the plot markers look separate from the lines, which isn't as smooth looking