selfatari_cousin(): Suggest counter-captures

When looking for alternatives of a self-atari move, aside of the
other liberty also look if we can counter-capture an opponent's
group.

This improves handling of some false-eyeish corner situations,
where we will more often capture the falsifying opponent stones
rather than connecting the pseudo-false eye (which can be fatal
to the status of the group).

Moggy eyefillrate: Revert from 40 back to 60

With less than 50%, Pachi starts to massively misplay the concerned
corner situations.  I think measurements are way too noisy for
eyefillrate since the feature is very rarely applied.  Perhaps we
could get away fine with just pitching this at 100.

t-unit/sar.t: Add eye falsification selfatari testcase

Selfatari: Allow capture-from-within moves

Moggy init: Also don't set nakaderate twice... sigh

Moggy init: Also don't set nlibrate twice

Moggy init: Rearrange rates initialization by their default value

Moggy init: Do not set lcapturerate twice

Moggy ladderrate: Add a note about obsolescence

Playout: New per-engine setboard_randomok setting

This is for a side-branch experiment where we generate some per-playout
settings for the Moggy playout policy.

Twiddle several Moggy playout policy parameters based on CLOP

These are CLOP experiments with pachi-29a24, single-threaded (i7-3770),
15x15 against GNUGo level 10; patterns were not used (?).
The number after [%] is |eigenvalue|.

abstime 500s            1000s           2000s           4000s
nakade  61% 3.39        80% 3.29        53% 7.62        66% 7.92
eyefill 54% 0.52        84% 0.61        49% 0.38        32% 2.45
nlib    29% 0.02        20% 0.09        22% 0.10        27% 0.28
ko      71% 0.08        63% 0.27        60% 0.33        48% 0.57
uElo SD 35              26              22              39      (smaller is more confident)

Just for your interest, mean winrate during tuning:
komi    -35.5           -40.5           -50.5           -50.5   (to give GNUGo an advantage)
Elo     140             164             84              101

Nota bene:
- 4000s S.D. single-threaded translates just to 500s S.D. (8 minutes)
  8-threaded, which is still faster than a regular KGS blitz.
- In general, 500s and 4000s values are unfortunately of low confidence,
  this Elo spread is more than influence of most of the parameters.

Parameter analysis:
- nakade: let's go with the rough mean of 60%, which seems to hold.
- eyefill: we see a clear downward trend; let's go with 40%, more
  tuning needed.
- nlib: we see about constant 25% optimum, but the feature is not
  very interesting in general.
- ko: steady decrease, but 40% may hit closer to home in realistic
  KGS setting.

Overally, after 500 games, the performance changes as follows (komi -55):

-Elo uElo +Elo (+-1SD)
361  377  392  prior=pattern=80,playout=moggy:nakaderate=20:nlibrate=20:korate=20:eyefillrate=60
396  411  427  prior=pattern=160,playout=moggy:nakaderate=20:nlibrate=20:korate=20:eyefillrate=60
384  399  414  prior=pattern=160,playout=moggy:nakaderate=20:nlibrate=25:korate=40:eyefillrate=60
404  420  435  prior=pattern=160,playout=moggy:nakaderate=60:nlibrate=25:korate=40:eyefillrate=40

Not too conclusive, unfortuinately, but it seems we should have a slight
improvement.

UCT pattern prior: Raise default from 80 to 160

After 500 games with single threaded (i7 HT) -t =4000, there is 44-40+22
Elo improvement here; let's optimize more for realistic scenarios for
our users even though on big cluster, 80 may be a better default.

Moggy nakaderate: 20 -> default, i.e. much more often

Based on recent tuning; ongoing tweaks.

Moggy nakade_check(): Call _after_ x-lib checks, not before

After 3000-games test, there is still no statistically significant
information about it being better or worse than previously, but it sure
makes more sense so let's do it.

autotest-show: Add support for Elo display

UCT debug_after: Extra printouts

UCT dumpthres: Convert from something weird to true fraction of #root.playouts

UCT debug_after: New aid to combine regular thinking + debugging simulation dump

Fix build in packaging systems like portage or debian

We now allow custom LIBS, LDFLAGS settings akin to custom CFLAGS
environment settings by using SYS_* for our overridable internal flags.

Pointed out by Guillaume BINET, solution proposed by Stanisław Halik.

neighbor_count_at(): Fix S_NONE warning

Pointed out by Eugene Lovelace.

is_border_ladder() shortage of libs test: Properly test for potential self-atari condition

TODO: GNUGo cross-pollination?

TODO: Game analysis features

TODO: is_private() hack

TODO: Revamp, elaborate on things

Consider a tree during which we drop komi as untrustworthy - don't resign or reuse it

In late endgame, raising a komi by 1pt can fatally destroy the tree.

Problem discovered in KGS pachi-Marknguyen on 2013-12-13.

sgf2gtp.py: Default SZ to 19

pattern_rate_moves(): Add a debug print listing all patterns considered

PATTERN_SPEC_MATCH_DEFAULT: Disable PF_CAPTURE_COUNTSTONES as it was not used for generating stock pattern files

Using non-matching pattern files and patternspecs is rather fatal as
common situations will not generate matching patterns anymore. A symptom
of that was kindly reported by Martin Miller.

add arm-linux-androideabi v16 instructions

overriding {c,ld}flags eg when crossing android

uct_progress_text(): Typo fix (add missing space)

underflow less by s/floating_t/double/

show color information for easy twogtp regress test

network.c: Add missing netinet/in.h include (by Stanisław Halik)

Moggy 3x3 cut keima pattern: Adjust to cover cutting hane-nobi shapes and bamboo joints too

Inspired by pachi vs. Aya in the September KGS slow tournament.

UCB1AMAF vloss_sqrt: Enable, tested to fix high-threading tree deformations

Moggy: Bump selfatarirate to 95.

UCB1AMAF: vloss_sqrt to re-normalize virtual loss for better many-threads performance

Rescale virtual loss value to square root of #threads. This mitigates
the number of virtual losses added in case of a large amount of
threads; it seems that with linear virtual losses, overly diverse
exploration caused by this may cause a wrong mean value computed
for the parent node.

Off by default for now.

Rewrite virtual loss support

Instead of directly manipulating the u stats, track the number
of parallel descents separately and use during node evaluation.
Also, manipulate the counter atomically.

On highly parallel machines, the amount of inconsistency introduced by
virtual loss was just too huge - mostly, there would be a tendency of
"forgetting" the virtual loss addition, but performing the removal,
therefore swinging the results off balance, an effect that would be
self-reinforcing (a funny consequence of how the search works) and
cause the tree to quickly deteriorate into very long, not particulary
wise branches.

The change makes virtual loss support reliable (though I did not test
*too* rigorously if it still works so well, game performance wise)
and doesn't seem to introduce any noticeable performance degradation.

Merge branch 'master' of ssh://repo.or.cz/srv/git/pachi

play_random_game(): Don't enforce minimum gamelen (10)

This intereferes with extremely long tree branches, triggering an
assertion failure wrt. amafmap->gamelen.

Stop pondering on kgs-game_over so that we don't waste CPU when waiting for the next game

uct_search_result(): Resign if only pass is feasible but it won't win the game

Reported by Martin Mueller. This change needs careful testing for
unintended consequences, in case Pachi starts resigning at weird
times...

UCT banner: Allow + instead of space, because kgsGtp is braindamaged

Moggy pat3_gammas: Tuned default values

Merge branch 'moggy3patgamma'

mq_gamma_pick(): Fix case of zero total

Moggy test_pattern3_here(): Disable spurious debug print

Moggy eyefixrate: Set to 100 after brief tuning

Moggy, Pattern3: Add support for assigning gamma values to 3x3 patterns (by default all gammas are still 1.0)

Pattern3: Store pattern index in the top six bits of the hash table

mq.h: Add mq_gamma_{add,pick} routines for dealing with gamma probdists

Moggy eye fix: Fill falsifying move when approach liberty has been filled

Inspired by the Zen-Ishida Densei-sen game.

uct_playout(): Add comment warning about the result number mess, I got caught up in it myself again

uct_playout(): Add playout# to UCT walk debug print

Moggy joseki_check(): Do not suggest invalid joseki moves (on hash collisions)

README (test opponent): +pondering=0, pass_all_alive

Moggy mq_tagged_choose: Debug print with probability distribution

Moggy fullchoose: Do not match features with zero rate

Moggy fullchoose: Fix global atari matching

tools/sgf2gtp.py: Graceful handling of SGFs without black/white setup

Dynkomi linear: Do not call adjusting linear_permove() from linear_persim()

The adjustment is not persistent if not called over permove API. This
caused the endless streams of dynkomi messages in some yose situations.

Dynkomi linear: Factor out linear_simple() from linear_permove()

Thread managers: Raise spawned/joined worker prints debug level to reduce noise at -d 4

sgf2gtp.py: Include setup stones

This is useful if you want to export a position for processing by the
engine: simply save the position from the GUI and run this modified
sgf2gtp script on it.

sgf2gtp.py: Convert tabs to four spaces, as is the Python custom

network.c: SO_REUSEADDR value shall be an int (found by Farmer Lu)

Merge branch 'pachi-10-satsugen'

uct_progress_json(): Remove extra curly braces around choice value

Pachi Retsugen-devel 10.99

Pachi Satsugen 10.00

Distributed mode: no time limit by default on slaves, control on master only

Change default time settings from -t =80000 to -t 15

This loses a semi-nice property that Pachi will by default have
the same strength on any computer, but on the other hand it will
make Pachi adjust its strength based on the computer without playing
needlessly fast or taking way too long time per move. This should be
more user friendly. Suggested by Jean-Loup.

UCT pondering: Enable by default

UCT max_maintime_ratio: Raise back to 2.0

Based on empirical observation during a 9x9 tournament.

2.0 is still dramatic decrease from the previous default 3.0 and should
avoid most troublesome situations, but my gut feeling is that Pachi is
just playing way too fast now. It's not based on hard data, but neither
was the reduction to 1.5, IIRC.

UCT virtual_loss: Revert default change

It seems all our virtual_loss tuning was bogus due to a mistake
in the option setting code - all tests were in fact done with
virtual_loss zero.

High virtual_loss has catastrophic effect on gameplay - it transforms
the tree to long narrow corridors with high difference between black
and white node values. I'm not 100% sure about the cause even though
I spent quite long time trying to debug this, but I think it's because
the noise introduced by updates lost due to conflicts is just too high.

Moreover, with virtual_loss raising with number of threads, both the
noise rate and noise magnitude goes up, amplifying the effect.

UCT virtual_loss: Allow setting virtual_loss to arbitrary values

uct_leaf_node(): Fix node value debug print

fbook_init(): Remove bogus comment

New parameter defaults, obtained by tuning on large configurations

Kept default debug_level=3 and pondering=0 but for optimal results
use: -d 0 pondering=1

chat_init(): Fix problematic ptrdiff_t format string handling

Introduced in commit 2e8729f.

Ammend to static inline, for no gcc warning.

GCC: -Wextra warning: ‘static’ is not at beginning of declaration.

Change type of mercymin to 'int' to avoid gcc sign-compare warning.

Win32 gcc compiler warning fix. Added util.h prototype for stpcpy().

Fix stack overflows and crashes when reading very long ladders

UCT initial_extra_komi: Way to seed adaptive dynkomi, also preserve it across state resets

This means that unexpected opponent move (promotion failure) will not reset the dynamic komi. This is fairly important esp. for the maximize_score option.

UCT spawn_thread_manager(): Make sure each thread gets 1M stack

middle_ladder_walk(): Use alloca() for board copy allocation

This should somewhat reduce stack usage which seems to give us some trouble with deep ladders.

README: Mention large-scale board patterns

README: Update strength estimates

README Greedy Pachi: Mention xkomi/extra komi messages

uct_progress_text(): komi -> xkomi

UCT adaptive dynkomi: Less verbose

UCT: Introduce 'maximize_score' preset that turns on adaptive dynkomi, val_scale and allow_losing_pass.

RULES_PASS_STONES -> RULES_SIMING, also count handicap stones as points

RULES_PASS_STONES: Correctly support undo

Preserve rules over board_clear()

Add support for RULES_PASS_STONES - player hands a stone to the opponent on pass

Requested by Robert Jasiek for the 13x13 EGC2012 tournament.