toss | Dead simple LAN file transfers from the command line

Here is the a solution taking the list of url to webpages of interest, collecting the moves from each table and creating a dataframe with the "1s".
Then combining the individual tables into the final answer

(This may not be precisely correct, but I think it captures what happens.)

In your first example, set -e sets the option in a command that is lexically in the scope of an if statement, and so even though it is set, it is ignored. (You can confirm it is set by running echo $- inside to-be-sourced.sh. Note, too, that . itself has a 0 exit status, which you can confirm by replacing true with an echo statement; it's not that it fails but the failure is ignored.)

In your second example, -e sets the errexit option in a new process, which knows nothing about the if statement and therefore it is not ignored.

ANTLR will always create a KEY token for the input foo. No matter if the input is mu = foo, then too will there be 2 KEY tokens created (with an OP token in between).

This is simply how ANTLR's lexer works. The lexer is not "driven" by the parser. It doesn't matter if the parser is trying to match a VALUE token, the input foo will always be a KEY token.

These are the 2 rules by which the lexer creates tokens:

1. create the longest possible match
2. if there are 2 or more lexer rules than match the same characters, let the one defined first "win"

Because of rule 2, you can see why KEY will be created for foo and not a VALUE.

To fix this, do something like this:

First of all, the method used to measure the timings is very imprecise. The current methods introduce a huge bias that is probably bigger than the measure itself. Indeed, clock is not very precise on many platforms (about 1 ms on my machine and often not better than 1 us on almost all platforms). Moreover, the imprecision is strongly amplified by the 10,000,000 iterations. If you want to measure the loop precisely, you need to move the clock call outside the loop (and if possible use a more accurate measurement function).

Still, the main problem is that the function result is unused and the Java JIT can see that and partially optimize that. GCC cannot because of the math function standard behaviour (errno cause a side effect not available in the Java code). You can disable the use of errno using the command-line flag -fno-math-errno. With that GCC can now totally optimize the function (ie. remove the function call) and the resulting time is much smaller. However, the benchmark is flawed and you probably do not want to measure that. If you want to write a correct benchmark, you need to read the computed value. For example, you can compute a checksum, at least to check the results are correct/equivalent.

Replace if toss != acceptables: by if toss not in acceptables:

You say you're giving the background subtractor some pure background initially.

When you're done with that and in the "running" phase, call apply() specifically with learningRate = 0. That ensures the model won't be updated.

You have the right idea that another variable is needed. The most simple way would be to just have a variable for each number of wins and update it where you're printing who wins. For example

[Note: I'm am a former maintainer of Exporter]

I believe you've confused exporting with inheritance. That's easy to do, Perl doesn't draw a line between "function" and "method", they're just sub.

tl;dr You don't need to export, that's just how inheritance works, there is a work around.

Exporting lets you call a function from outside of a package without fully qualifying it. It would let you call Foo::hello as just hello. Exporting lets Perl know that hello really means hello in package Foo.

But these are method calls, and you call them on a class or object. my $foo = Foo->new; $foo->hello. No exporting required. Foo->new calls new in Foo and returns a Foo object. $foo->hello knows to look for the method foo in the ancestry of $foo's class. You don't need to use exporter in a class, that's what "Do not export method names" means.

Exporting is a deliberate act which copies symbols around. Inheritance is all or nothing. If you inherit from a class you get all its methods (subs). This is a consequence of inheritance, and there are many other alternatives to inheritance such as composition.

In other OO languages you could declare the method private and it would not be inherited. Perl doesn't have that. Normally you just live with this by convention as you have, put an underscore in front of the method name, don't document it, and if somebody uses it that's their problem. And that's usually fine.

But you can make truly private methods with anonymous subs and lexical variables.

As n. 1.8e9-where's-my-share m. correctly pointed out, You are calling TossCoin() twice. This is your modified code that fixes the problem: