Freecell Solver’s News File

Avoid packaging /.tidyall.d ( https://github.com/shlomif/fc-solve/issues/99 ) Thanks to @krop .

Renames to "global_instance" and clean-ups.

Add experimental functions in FC_SOLVE_INSTANCE_PARAMS_QUERYING .

Fewer compile-time / lint-time warnings .

Convert some regular expressions from \d to [0-9] .

Workaround an ldd regression: https://github.com/shlomif/fc-solve/issues/87 .

OpenCL deal finder cleanups.

Made the tests suite pass on more CMake options' configurations.

Cleanups.

Fixed the Windows binaries builds on GitHub Actions.

Avoid the need of pyperl in the OpenCL code.

Silence some compiler warnings.

Ignore the FCS_SINGLE_HARD_THREAD and FCS_DISABLE_MULTI_NEXT_INSTS options while removing complexity from the source code.

Better rinutils bootstrap shim.

Add an experimental OpenCL-optimised MS FreeCell deal finder in board_gen/find-freecell-deal-index-julia-opencl.py (it uses C instead of Julia).

CMakeLists.txt cleanups.

Fixed broken links.

Use with for open calls in Python code: https://stackoverflow.com/questions/3012488/what-is-the-python-with-statement-designed-for

Fix run time errors in board_gen/transpose-freecell-board.py .

Convert some integer types to uint_fast32_t.

Add the --should-skip-tests and --custom-tests-suite flags to run-tests.pl. This allow for fuzz-testing builds.

Add t/lib/FC_Solve/DeltaStater/FccFingerPrint.pm which is a prototype for a more compact representation of zero-freecells deals.

Fix the cmake build when using cmake -S src -B build followed by cmake --build build. (Reported at https://github.com/shlomif/fc-solve/issues/47 - thanks to @antonio-rojas .)

Update freecell-solver.spec.in to pass on Fedora 33 and to use the %cmake* macros.

Fix a minor bug where the initial position could be traversed twice.

Add the FCS_HARD_CODE_STATE_DEPTH_FIELD compile time option.

Code cleanups.

Add the "=all()" moves order specifier.

Add the FCS_ZERO_FREECELLS_MODE compile macro.

Update the compile time CMake descriptions for optimizing runtimes on more modern CPUs.

Remove support for the secondary hash value.

Fix the installation of the documents, and make sure that README.win32.txt only gets installed on MS Windows. ( https://github.com/shlomif/fc-solve/pull/37 )

Convert the CMake build system to use GNUInstallDirs .

Extract a deal integer type.

Avoid compiler warnings and check for some dependencies.

Keep a clone of rinutils v0.2.0 in the source directory to avoid a build time dependency. The build process shall still use the system one if it is found. (Requested by the maintainer of the Debian package.)

Add the unrecognized command line flags API methods (for use by the online interface).

Some cleanups and fixes.

Add board_gen/make_multi_boards.c (not installed by default).

Add get_board__setup_string() and get_board_l__without_setup() (optimization).

Convert fcs_game_limit to uint16_t (optimization).

Refactorings and cleanups.

Require rinutils to be installed.

Install the depth/dbm fc-solvers by default (hopefully for real this time). https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/messages/1626

Fix and test the threaded solvers on Windows (which are using pthreads).

Fix the fc_solve_stack_compare_for_canonize() optimization and enable it globally.

Generate .msi Windows packages.

Deprecate MAX_NUM_DECKS being not equal to 1.

Extracted https://pypi.org/project/freecell-solver/ - Python bindings to libfreecell-solver.

Speed improvements.

Code cleanups.

Avoid some CMake warnings and other cleanups.

Convert the C tests to use https://cmocka.org/ instead of libtap, due to a more portable API, more features and easier packaging.

Fixed freecell-solver.spec.in and now testing it on Fedora Linux using Docker on Travis-CI.

Add the --rebuild flag to run-tests.pl .

Install the depth/dbm fc-solvers by default. They have been "experimental" for too long. https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/messages/1626

There is a compile time option to use libapr's hash table as a backend for the DBM solvers. This is faster but consumes more RAM. https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/messages/1632

Extracted some common headers into the "rinutils" library which can be used by other projects.

Bug fix: the board generation programs now avoid dealing out of range deals.

Cache the CI valgrind/digest/verify test results for optimising test runs.

Optimise the RAM consumption of summarizing_solver.c for sequences. https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/messages/1626

Add support for xxHash v0.7.0’s xxh3 hash function for extra speed. https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/messages/1627 .

Many small cleanups and refactorings.

Fix some bugs and regressions regarding handling of -l ve and -l sp detected by using an old kpat with the new libfreecell-solver.

Convert the C tests to use https://github.com/shlomif/libtap/tree/cmake .

Better "void * user" recycling.

Code cleanups.

Fix several bugs related to freecell_solver_user_limit_iterations_long() , --max-iters, etc. Some of them could make the library consume many more resources than specified and so may have SECURITY implications. ( https://bugs.kde.org/show_bug.cgi?id=405187 .)

Added freecell_solver_user_soft_limit_iterations_long() and FCS_STATE_SOFT_SUSPEND_PROCESS to the API.

Add a new FCS_DEAL_ONLY_UP_TO_2G compile-time option.

Fix more GCC and clang warnings, and other cleanups.

Extract most of the python board generation logic into https://pypi.org/project/pysol-cards/ . Added support for dealing https://en.wikipedia.org/wiki/Golf_(patience) and other games.

Add "--max-num-states" to the dbm solvers.

Better portability to macOS.

Fixes for google densehash.

Cleanups and optimisations.

Breaking change: made the userland headers fcs_user.h, fcs_cl.h, etc. includable only as #include <freecell-solver/fcs_cl.h>. The API and ABI should otherwise remain the same.

Add the gen-multiple-pysol-layouts executable to generate several numbered deals as separate files.

Added the experimental fc-solve-multi solver to solve several files in one go (not installed by default).

Rename the AsciiDoc documents from *.txt to \*.asciidoc, in order to please GitHub/etc. ; updated them and fixed some formatting.

New --iter-output-step command-line flag.

New --hint-on-intractable command-line flag and functionality.

Add -DFCS_MAX_RANK=…​ compile time option to set the maximal rank below 13.

Add the -DFCS_BREAK_BACKWARD_COMPAT_2=1 compile-time option which improves performance but breaks bug-to-bug backward compatibility.

Add the -DFCS_UNSAFE=1 option.

Converted the python-based testing scripts from TAP.Simple to pycotap.

Other speedups and refactorings.

Convert the code in board_gen/ from the GPL to the MIT/Expat licence.

Convert the hash function to xxHash ( https://cyan4973.github.io/xxHash/ ) for improved performance.

Eliminate several GCC warnings and other cleanups and speedups.

Add a new -l looking-glass command line preset, which provides improved speed.

Add some programs to find the deal index of a card layout.

Remove "freecell-solver-config" - one should use pkg-config instead.

Many small optimizations and cleanups.

Fix the compilation and tests when __int128 is not available (e.g: on x86-32 systems).

Fix a double-free error in certain conditions. Thanks to Theodore Pringle. See: https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/messages/1554

Add a new j move of moving cards from freecells to empty columns and immediately putting cards on top.

Add a new -l cookie-monster command line preset based on it which sports improved speed.

Fixed a bug with a potential hang with two identically-depthed -dto2 flags: https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/messages/1549

Fix dealing of high indexed (above 2G) deals on some 32-bit and/or MS Windows platforms.

Fix a problem where the fc-pro-range-solver ignored game parameters such as --freecells-num 0. (Thanks to Larry).

Enable building an MS Windows 32-bit installer using AppVeyor. This will facilitate releasing them along with the source.

Some more minor cleanups and optimizations.

Add some new compile-time options that may make the runtime faster, but may remove or break functionality.

Convert the python-based automated tests to use cffi, which is more modern and recommended, instead of ctypes.

Many code cleanups, refactorings, and optimizations.

Fix a crash when doing fc-solve -g [non-existent-game] (with tests): https://github.com/shlomif/fc-solve/issues/11 .

Mention the final parameter name (instead of just saying "(null)") when it accepts a non-given argument: https://github.com/shlomif/fc-solve/issues/12 .

Remove DEBUG_STATES - it was slow and not really helpful and caused bloat.

Implement condition variables instead of usleep in the depth_dbm_solver . https://github.com/shlomif/fc-solve/issues/8 . It now also supports processing batches of items from the queue in a single transaction.

Got a test suite to pass on MS-Windows / AppVeyor: https://ci.appveyor.com/project/shlomif/fc-solve .

Many large and small code cleanups and refactorings.

Fix for building the package in certain conditions (originally created for the Mageia Linux package).

Got the production code and tests to pass on ARM Linux. Previously fc-solve just hanged there.

Fix the tests and depth_dbm_fc_solver on 32-bit platforms.

Apply the large Freecell Pro seeds deals generation to the board generators and range solvers.

Option to use __int128 instead of libGMP for the DBM solvers - a significant speed-up, see http://fc-solve.shlomifish.org/charts/dbm-solver-__int128-optimisation/ .

Revise some awkward phrasing in the README .

Many small and larger cleanups.

Add the -l one-big-family, or -l obf for short, preset which improves the average performance for solving Freecell deals.

Add the transpose-freecell-board.py utility to transpose a board from having stacks-in-columns to a stacks-in-lines format acceptable by fc-solve.

Fix a bug where using a flare-based scan while incrementally increasing the iterations limit could have created a situation where one scan gets all the iterations.

Remove make-gnome-freecell-board (GNOME Freecell was discontinued) and make-aisleriot-freecell-board (as AisleRiot no longer has numbered deals).

Fix some crashes that were found using American Fuzzy Lop, caused due to misuse of the command line arguments or the input board format.

Fix a major regression bug in the depth_dbm_fc_solve and possibly related solvers that prevented it from making progress.

Some optimisations for improving general performance on all presets.

Many code cleanups and refactorings.

New command-line preset -l conspiracy-theory or -l ct for short that is faster than -l as on average.

Bug fix: some error messages are not emitted to STDERR instead of STDOUT. Furthermore, the exit code on some failures is now non-zero.

Bug fix: flares names in the flares plan is now their exact strings instead of any possible beginning of them.

Add a compile-time option to not compile the FC-Pro moves count (used primarily for determining the shortest flares). It is -DFCS_WITHOUT_FC_PRO_MOVES_COUNT=1 .

Bug fix: properly clean-up solution_moves on recycle.

Bug fix: fix the output of the Freecell’s dashes in non-parsable output.

Add a compile-time option (-DFCS_BREAK_BACKWARD_COMPAT_1) to break some backward compatibility, such as old functions, cards with "10" instead of "T", trailing whitespace in output, and the non-"-p" output of states. This makes the binaries smaller and faster but may break some existing functionality. Enabling it is not recommended.

Freecell Solver now uses Travis-CI to build and test the code in several configurations on each commit. This is part of the so-called “Continuous Integration” practice.

Added support for clang to the PGO (= profile-guided-optimizations) scripts.

Moved away or deleted many scripts and other cruft.

Remove FCS_STATE_STORAGE_INDIRECT - it was old and slow and the hash lookup or a balanced binary tree should be used instead.

Remove the experimental flipping support and made the default for cards not to be flippable at all. (The code did not build with it enabled anyway.)

Many small and large cleanups, optimizations and refactorings - hopefully without breaking backward-compatibility.

Correct tarball release - 4.0.1 should not be used.

Fix the tests for the new Games-Solitaire-Verify (0.1601).

Apply a patch from Mageia to prevent underlinking during build. Thanks!

Disable linking to the gperftools’ tcmalloc library if the test suite is enabled due to https://github.com/gperftools/gperftools/issues/758 .

Integrate the scans of Tom Holroyd’s patsolve, for a faster atomic moves-based solver. See the --method patsolve, --patsolve-x-param and --patsolve-y-param options in the USAGE.txt file.

Add the -dto2 / --depth-tests-order2 flag to provide a corrected version of the depth-tests-order feature without the depth string and comma being prefixed to the tests order due to an oversight.

Convert the Python code (tests + board generation) to Python 3, because it seems that Python 2 is going away. To run it, we require the "random2" module from PyPI : https://pypi.python.org/pypi/random2 .

Many small cleanups and optimisations.

Source tarball is now “.tar.xz”.

Remove the documents (e.g: README, COPYING, AUTHORS), which have duplicates with a .txt extension from the source distribution, to save space. They are still being copied to their location in the BINARY_DIR where cmake is invoked from.

Fix a division/modulo by zero problem that yielded a floating-point exception, as reported by the Mayhem team to the Debian bug tracker: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=715914 . Thanks!

Fix board_gen/pi-make-microsoft-freecell-board board_gen/make-aisleriot-freecell-board and
board_gen/make-gnome-freecell-board from crashing if only a single "-t" flag is given. A crash was reported by the Mayhem team to the Debian bug tracker: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=716097 . Thanks!

Fix the automated tests, so they will support the new versions of Games::Solitaire::Verify[http://fc-solve.shlomifish.org/verify-code/] .

Remove make_microsoft_freecell_board.c - it is not useful and pi-make-microsoft-freecell-board or make_pysol_freecell_board.py should be used instead.

Fix the build process for version 4.9.x of the GCC compiler.

Add the pseudo-DFS solver in pseudo_dfs_atomic_moves_solver.c , which is another attempt at solving hard two freecell deals. It runs, but generates a very large stack with the deal in question (MS #384243 ).

The summarize-fc-solve script now accepts some game parameters followed by a double-dash ("--"), followed by preset parameters for the solver.

Various fixes for warnings and errors for the build process, while using CMake-3.0.0-rc3 (what will become CMake-3.0.0).

Some cleanups, refactorings, modernisations, and minor optimisations.

This release is dedicated to the memory of Adrian Ettlinger (see https://en.wikipedia.org/wiki/Adrian_Ettlinger ) who passed away on 23 October 2013, who was a good Internet friend of the primary maintainer of Freecell Solver (= Shlomi Fish), and who contributed a great deal to Freecell Solver and to Freecell research and programming in general (among other life achievements, and contributions). You can find an obituary of Mr. Ettlinger by Shlomi Fish here: https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/messages/1379 and the video-editing preset (see below) was named in honor of his previous work in pioneering non-linear video editing.

Handle board/layout inputs without a trailing newline character on the last line properly (thanks to someone who reported it via E-mail with respect to the JavaScript-based solver).

Add the -l video-editing or -l ve flare-based preset for shorter solutions (on average).

The distribution now contains the sources for the so-called split-fcc-solver, which was originally conceived as an attempt to determine whether the Windows Freecell deal No. 384,243 is solvable with two freecells or not. The attempt failed because the split-FCC-solver generated large intermediate outputs, but it may prove of some utility in the future (while being experimental).

Made sure unknown options which have a prefix that is a recognised option (e.g: --resetjunk vs. --reset), will be reported as such instead of processed as the prefix automagically.

Fix the Win32 NSIS package, so it will build, run and process the presets.

The JavaScript-based solver now accepts arbitrary fc-solve command line parameters, so it can solve any of the supported variants of Solitaire.

Fix the build and silenced some warnings on MinGW/GCC/Win32.

Major speedups to the Simple Simon code - including order of complexity ones where a lookup is now O(1) instead of O(num_cards). The Simple Simon code was in general heavily refactored and cleaned up.

Some bugs in the Simple Simon algorithms were fixed, slightly modifying the outputted solutions.

Add missing BuildRequires to the RPM .spec .

Add the qualified-seed-improved preset.

Fix the run-time display of the iteration count during pkill -USR1 fc-solve.

Some minor refactorings and optimisations.

Fix "make install" - there were some problems with the generation of the man pages.

Fix the RPM .spec building.

Add a JavaScript port that uses Emscripten ( https://github.com/kripken/emscripten ) to compile the C code into JavaScript. See Makefile.to-javascript.mak and the contents of The /fc-solve/site/wml directory of the repository.

Convert the CMake build system to the common cmake/Shlomif_Common.cmake file, which will facilitate cross-project maintenance. It is included inside the archive.

Added a --help flag for the summarize-fc-solve executable.

Got the test suite and the dbm_fc_solver and the depth_dbm_fc_solver to run properly on 32-bit architectures.

The default rpm spec now runs the test suite.

Add const annotations and moved declarations to where they are first assigned.

Add the -l micro-finance-improved preset (or -l mfi for short), which somewhat improves the length of the solutions of the micro-finance preset.

Add the --flares-choice option, which determines how the winning flare is chosen.

Add the --flares-iters-factor option (or -fif for short), which specifies a factor to multiply the flares quotas.

Add the -l qualified-seed preset (or -l qs for short), which somewhat improves the length of the solutions of the -l micro-finance-improved preset.

The individual flares are now recycled and their memory is reused when they are no longer needed. This is a RAM optimisation, which is applicable only for flares-based presets.

Fix the build on Windows with DWIM Perl and its Mingw32 (strndup() was missing).

Got the tests to pass with cmake -DFCS_WITHOUT_DEPTH_FIELD=1 by making the library behave the same as without it. This also affected the behaviour of ./fc-solve -l mo with attempting to solve Baker’s Dozen deals.

On UNIX platforms, fc-solve now exits gracefully with the message “Iterations count exceeded.”, upon receiving a SIGABRT signal. Can be triggered by executing pkill -ABRT fc-solve.

The game states’ input routines now accept regular columns that start with a leading colon (":"). As a result, one can input the states as output from the solver with the -p and -t flags directly there.

Added a 6th BeFS weight (see the -asw flag) of the inverse of the number of cards not above parents. Using ./freecell-solver-range-parallel-solve 1 32000 1 -p -t -sam --method a-star -to 0123467589 -asw 1,0,0,0,0,1 -sp r:tf -mi 100000 appears to be interesting.

Allow test groups inside the -to and -dto flags to be ordered using the =asw(…) function and its parameters, based on the BeFS (Best-first search) weights calculation.

Added the -l amateur-star (or -l as for short) preset, based on the =asw(…) ordering that is the fastest preset yet.

Added the -l micro-finance (or -l mf for short) preset, based on the 6th BeFS weight.

Implement a Prune for games whose columns cannot be filled by any card (such as Baker’s Dozen), where moving the last card on a column to a different column is pointless. For more information, see https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/topics/1121 .

In dbm_fc_solver and depth_dbm_fc_solver, implement the “DeBondt” encoding method for Freecell and Baker’s Dozen, which allows for an even more compact representation of the encoded states.

The libfreecell-solver code is now 64-bit-enabled and many of the limits were converted to allow for 64-bit systems.

Dropped support for Microsoft Visual C++ (CL.EXE) and other compilers that don’t support C99/gnu99.

Add scripts/convert-dbm-fc-solver-solution-to-fc-solve-solution.pl to convert a solution output of the dbm_fc_solver to one compatible with fc-solve.

Add the --show-exceeded-limits / -sel flag that removes some ambiguity in the output.

Fix invoking the solver with --set-pruning r:tf in conjunction with -opt.

Add the -l three-eighty preset.

Many dbm_solver.c improvements including the implementations of kaztree and libavl2-derived backends, several major reductions of the memory consumption, and many code cleanups and bug fixes.

Add support for building and testing the distribution in an out-of-tree build (e.g: mkdir build ; cd build ; cmake -DFCS_WITH_SUITE=1 .. ; make ; make test ).

A new experimental fcc_solver.c which aims to reduce memory consumption in exhaustive scans even further.

Removed many #ifdefs from the code by creating common abstractions.

Eliminate many GCC warnings with certain GCC compile flags.

Convert the references to the web-site and repository away from berlios.de, as it was announced it will become offline.

Bug fix: correct the handling of foundations with values 0 (e.g: H-0, S-0 ).

Bug fix: made the -mi/--max-iters flag global for all instances. Previously, it affected only the last one.

Add an experimental delta_states.c implementation and dbm_solver.c that uses it to drive a Freecell Solver scan with an on-disk database (currently Google LevelDB and Berkeley DB are supported). So far it seems that with a limited cache size, this does not scale too well.

Add the experimental pruner-main.c (not installed by default).

Add support for generating "all_in_a_row" deals to make_pysol_freecll_board.py .

Many small optimizations and cleanups.

Fix the crashes when using --trim-max-stored-states.

Add a man page generated by AsciiDoc instead of the token man page that was present previously.

The number of states in the collection is now preserved if the verdict was unsolved.

Add a --solutions-directory argument to test_multi_parallel.c .

Fix the rpm spec - %{version} instead of %{PACKAGE_VERSION} .

Add scripts/parallel-range-solver-total to solve a range of deals in parallel by splitting them into chunks.

Add -DFCS_BUILD_DOCS= to CMake to avoid building documentation.

Add a way to dump the valid outputs in t/t/lib/Games/Solitaire/FC_Solve/CheckResults.pm to files.

Add an environment flag to filter out the valgrind test when running make test.

Many refactorings.

Now installing the fcs_dllexport.h header file. It is needed for use of libfreecell-solver in third-party programs, so previously including fcs_user.h did not work.

Add the --tracemem compile-time option for tracing the amount of RAM and time used by Freecell Solver as a function of the iterations count.

Bug fix for incrementally increasing the limits.

Add a modified version of kazlib’s balanced binary search tree to the distribution so one will be available built-in. It can be used for both the states' storage and for the --rcs LRU cache.

Revamped the various range solvers, while extracting common functionality into header files, functions and macros.

Some relatively minor optimisations and code cleanups.

Compiling without card flipping on by default now (finally it makes the code a little faster instead of slower.)

Added the --set-pruning / -sp flag to turn on pruning. This sets the Horne play prune of moving cards that can no longer be used to build other cards upon to the foundations.

New preset -l enlightened-ostrich / -l eo based on it, which is significantly faster than -l foss-nessy. Amadiro, who helped me with the Black Hole Solitaire solver picked the name.

New preset -l maliciously-obscure / -l mo for short solutions.

There’s now an option to set a different hard-coded freecells' num at compile-time.

Add an experimental flag of "--trim-max-stored-states". Currently may crash the solver. (See the Known_Bugs.txt file).

Added support for -fwhole-program and static linking the Freecell Solver executables. This yielded another speed boost.

Forward ported the Google Dense Hash / Google Sparse Hash support for the positions and columns.

Forward ported COMPACT_STATES.

Add the --ms / -M flags to make_pysol_freecell_board.py to generate MS Deals even for the higher numbers (> 32,000 which are not used for that in PySol and PySol FC).

Add a compile-time option to use RCS-like states storage: http://fc-solve.shlomifish.org/to-do.html#rcs_state_storage - this conserves a lot of RAM.

Add a flag to get rid of visited_iter.

Add FCS_WITHOUT_DEPTH_FIELD to get rid of depth if fcs_state_extra_info_t.

Convert num_active_children to an unsigned short.

Forward ported the FCS_STATE_STORAGE_LIBAVL2_TREE to the new fc-solve and the FCS_RCS_STATES. It seems to scale much better for FCS_RCS_STATES than FCS_STATE_STORAGE_INTERNAL_HASH.

Converted the allocation of the BrFS queue items to alloc.{c,h} . This wastes less memory.

Implement FCS_WITHOUT_LOCS_FIELDS . This removes the fc_locs / stack_locs from the extra_info’s to conserve more space. It also makes solving faster.

Reduced the size of num_moves in move_stack_t.

Add support for the internal compact moves to the Tatzer script.

Added /trunk/fc-solve/scripts/automatic-build-for-982-2fc-solving/Makefile which automatically builds and runs fc-solve for solving the two-freecell MS deal No. 982.

Updated the cmake configuration to use lib${LIB_SUFFIX} so it can be built on some 64-bit systems.

Many small optimisations.

Add the --depth-tests-order (or -dto for short) flag that allows varying the tests' order based on the depth. This gives way for interesting (and faster) searches.

Add the the-iglu-cabal , foss-nessy and tea-for-two presets. The latter is optimized for two freecell deals.

Fixed a bug where when specifying the --max-iters flag it did not yield an FCS_STATE_SUSPEND_PROCESS return code.

Fix a crash when using a --prelude with a soft thread with a NULL name.

Add support for Google’s Dense Hash for the states' storage and the stacks storage. It does not perform as well as our own custom hash.

Internals: defined a boolean data type fcs_bool_t with two constants TRUE and FALSE , so it can be semantically different.

Some optimizations.

Implement the flares API (see USAGE.txt), which allows running several alternative scans and then picking up the one with the shortest solution.

Add the -l children-playing-ball and -l sentient-pearls presets that optimize on solution length (based on flares).

Add scripts/tag-fc-solve-release.bash to tag using svn.

Updated the CMake version in the build-on-win32.pl script.

Add scripts/stat-analysis-2.pl which is a faster version of the script for statistical analysis of the solution length.

Refactored the split_cmd_line.c module.

Renamed many "a_star" and "A*" occurrences in the code to "BeFS", because what was thought to be the A* scan was actually Best-First-Search.

Convert the soft-DFS tests' order to a list-of-lists-of-tests, and no longer recalculating the tests_list on any recycling.

Add the -o / --output flag to fc-solve to output to a file.

Now installing the new executables ( freecell-solver-fc-pro-range-solve , freecell-solver-multi-thread-solve , freecell-solver-range-parallel-solve , etc.) by default.

Bug fix: added a missing break after a case in cmd_line.c.

Fixed the Makefile’s "pdfs" target.

Converted many char * data types in the interface to freecell_solver_string_t, which can be const char *. The default is const char *.

pqueue.h was converted to the MIT/Expat license, with the permission of its author. Freecell Solver is now fully MIT/Expat.

Fixed a Best-First-Search recycling memory leak that was reported by valgrind.

Bug fix: now continuing a solution if a is_a_complete_scan thread terminates with the scans synergy set to dead-end-marks. This was done to avoid states reported as falsely unsolvable such as MS 254,076 with -l by.

Added a forking range solver - not installed by default. See: https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/topics/1038 . Sometimes it yields somewhat better performance.

Disabled tcmalloc in debug mode because it messes things up.

Various internals cleanups and optimizations.

make_pysol_freecell_board.py now has support for "Black Hole" dealing. See: http://www.shlomifish.org/open-source/projects/black-hole-solitaire-solver/ .

Added the "Scan:" header to indicate the current scan / soft-thread when using the -s -i flags.

Security: Fixed a string overflow bug in cmd_line.c with the -asw weights. As a result of this problem, Freecell Solver can write several NUL characters (\0) to after the string specifying the command line argument.

Fixed an off-by-1 iterations count report when a board was found to be solvable.

iter_handler is now applied globally across all instances.

Add the -l blue-yonder / -l by preset that is extra fast at solving the Microsoft 32,00 based on running the optimization algorithm:

Added a compile-time option to reduce the size of the internal move token structs. This may make memory consumption smaller, but definitely makes Freecell Solver run slower, so it is off by default.

Made sure that one can build Freecell Solver outside the source directory without needing AsciiDoc. (That was a major build-system problem).

Add a missing newline at the end of one of the lines of the help.

Add the "-F"/"--pysolfc" flag to board_gen/make_pysol_freecell_board.py for generating PySolFC deals.

Converted the README / USAGE / NEWS etc. files to AsciiDoc . The sources are in .txt and they are copied to their non-.txt files. The PDF build is still a bit broken due to a strange CMake problem.

Simplified the test suite and benchmarking process. (Thanks to LECA Dimitri (Pythack) for the inspiration).

Many documents were otherwise enhanced with examples and other enhancements.

Inlined the hash comparison and several other functions in the code. This made the code a little faster.

Clarified the documentation for broken versions of CMake (cmake-2.6.2) like the one that ships with some versions of Ubuntu.

Fixed the tests for a valgrind regression.

Added generation and installation of a libfreecell-solver.pc pkg-config file.

Added the preset "toons-for-twenty-somethings".

Re-implemented the missing --next-instance/-ni flag.

Added the "-l the-last-mohican"/"-l tlm" theme for Simple Simon that can solve more boards.

Now can rpmbuild -tb a tar.bz2.

Added information on running the test suite to the "HACKING" file.

Added a Python ctypes example under examples/ .

Added support for Sun Studio to Makefile.gnu. the -fast flag yields worse results than gcc.

Fixed some typos in the --help and the "USAGE" files.

Some internal changes:

Added a "#define BUILDING_DLL 1" so fcs_dllexport.h will work fine on Microsoft Visual C++.

Normalised the DLLEXPORT modifiers.

Some fixes to the CMake build system:

Moved the declaration of the strncasecmp(a,b,c) macro for WIN32 systems to before its first use.

All of this was done to fix many build/compilation problems.

Added meaningful heading comments to the *.c and *.h files where they were absent.

Many small memory/speed optimisations.

Removed a lot of unnecessary code and merged a lot of code. Used: scripts/find-ids.rb for finding uncommonly occurring identifiers.

Converted many macros to inline functions.

Now calculating the bit-width of the int data type in the CMake version. There’s a fallback logic for it in config.h.

Extracted empty_two_cols_from_new_state() in freecell.c.

Restored the max_depth functionality. Currently not working very well.

Now supporting inline on non-GCC compilers using CMake.

Made many functions that were used only once or twice inline.

Added the --iters-update-on option to the threaded range solver.

Fixed some CMake bugs (especially wrong compiler flags to check).

Optionally link with Google’s tcmalloc, which yields better performance (especially for the multi-threaded solver).

Added the support for DLLEXPORT to not export fc_solve_* from the DLL. This reduces the size of the .so / .dll considerably.

Got rid of using preset.c for FCS_FREECELL_ONLY.

Added the presets "gooey-unknown-thing", "sand-stone" and "slick-rock" to minimize the resultant solutions' length.

The Freecell Solver states storage and columns storage can now be made to use any of the trees provided by libavl2 ( http://www.stanford.edu/~blp/avl/ ) . The results seem to be somewhat slower than libJudy and much slower than our own custom hash.

Fixed the auto-moves calculation in fc_pro_iface.c .

Now one can exclude the Simple Simon-related move routines and logic from the binaries during compilation. See "FCS_DISABLE_SIMPLE_SIMON" in the CMake configuration.

Added scripts/measure-binaries-sizes.rb to measure the sizes of the binaries in various configurations.

Merged Makefile.icc , Makefile.tendra , Makefile.tcc , Makefile.pcc and Makefile.lcc into Makefile.gnu. Which compiler can be specified using the Makefile.gnu COMPILER variable.

Added the threaded_range_solver "--worker-step $N" argument.

Fixed many warnings reported by the Intel C++ compiler (icc)

Re-organized the code - renamed many files, moved declarations and definitions to different files, and did a lot of overhaul.

Got rid of FCS_DEBUG_MOVES - it was never used and became obnoxious.

Added scripts/verify-simple-simon-range.pl and scripts/simple-simon-stats-analysis.pl .

Added a regression test for verifying the validity of a Simple Simon solution.

Fixed Makefile.gnu to propagate CFLAGS to CREATE_SHARED.

Implemented FCS_WITHOUT_CARD_FLIPPING to exclude a lot of card flipping code at build time. It is disabled by default because strangely it seems to make the execution speed worse.

Added a fix to an off-by-one-error in alloc.h that caused a segfault on x86-64. (Thanks to Ido Kanner).

Several cleanups, refactoring and optimizations - especially to the freecell.c file.

Converted more move functions to positions_by_rank.

Changed the hash function from Bob Jenkins’s to perl 5’s and inlined it. These were substantial optimizations.

Unified many macros in state.h instead of having duplicate definitions for every state type. Verified that the alternative state types ( COMPACT_STATES and DEBUG_STATES) build correctly.

Added the optional -Werror=implicit-function-declarations flag to the compiler.

Added tests for some Simple Simon boards.

Created an fcs_cards_column_t type and converted the internals to use it.

Added the threaded range solver - freecell-solver-multi-thread-solve . It performs better than the serial one on my machine. It is built only if pthreads (POSIX threads) is found.

Add the HACKING file with some information on benchmarking.

Renamed the configuration script to "Tatzer" so people who are used to Autoconf’s "./configure ; make ; make install" won’t use it.

Got rid of all the max_num_$something in the dynamically-growing arrays because num_$something is enough to tell where the limit is and grow it if necessary. There’s now a lot of bit-fiddling logic to grow the dynamically-growing arrays when necessary.

Added support for adding the gcc -fomit-frame-pointer and -march=$CPU_ARCH flags.

Added the following makefiles for alternative Linux compilers:

Added scripts/fcs-win32-create-package.pl that provides some guidance in creating a package under Windows.

Now Freecell Solver can be compiled with gcc-2.95 (again). It was needed to test it with this old gcc version.

Some fixes to CMakeLists.txt.

fcs_hash.c: now the secondary hash value calculation is optional and should be enabled explicitly. Without it, Freecell Solver is faster:

Surgically removed fcs_hash.c’s "optimizing_for_cache" which made a small speed improvement.

Made t/Makefile generated by CMake, so the tests can be run from the packages source distribution. (Previously t/Makefile was excluded, and since it was not generated, was not available).

Eliminated BUILD_TYPE=release warnings.

Optimized fc_solve_sfs_move_freecell_cards_on_top_of_stacks() . This involved a lot of refactoring and re-structuring of the internals. Now Freecell Solver is significantly faster.

Fixed the testing targets and the building of the rpm from the tar.gz archive.

Many code cleanups and internal changes. Reduced the size of the library considerably.

Added Makefile.llvm to build LLVM bitcodes from the Freecell Solver sources. So far, they seem significantly slower than the native code compiled using gcc-4.3.2.

Implemented "cmake -DCMAKE_BUILD_TYPE=profile" . Can be activated using "./configure --profile"

Now build (but not installing) freecell-solver-fc-pro-range-solve , which runs a range of MS-Freecell / Freecell Pro boards using the solver and outputs the number of FCS moves, the number of FC-Pro moves, and the FC-Pro moves in standard notation.

Fixed some bugs (crashes, leaks, etc.) when running -opt on a range of boards (or recycling instances with -opt in general).

Some CMake / Build system cleanups and improvements. Among them, trimmed the distribution from unnecessary files.

Various improvements to the CMake build process:

Fixed the rpmbuild -tb process on Mandriva Linux Cooker (and possibly other systems).

Removed some old, unnecessary and/or no-longer-working files.

Converted the package from the Public Domain to the MIT/Expat Licence ( http://en.wikipedia.org/wiki/MIT_License ). This change was done due to the many problems with licensing source code under the public domain:

Updated the "NEWS" file (this file) with all the previous versions up to 0.4 (the first release after the first initial release).

Many fixes to the Win32 NSIS Package creation process of CMake/CPack . The NSIS package is now built and installed properly.

Fixed a bug with the recycling logic of the optimization thread.

Fixed the --prefix flag in ./configure to be treated as a string instead of a boolean.

Fixed the running of the executables under a specified PREFIX ( http://www.cmake.org/Wiki/CMake_RPATH_handling )

Minor changes to "README", "INSTALL" and "USAGE".

Added the FCS_FREECELL_ONLY compile-time flag to hard-code the settings for Freecell and thus allow faster run-time. On a Pentium 4-2.4GHz machine running Mandriva Linux Cooker, this allows one to solve the Microsoft 32,000 in 194.56353 seconds ( 164 deals / second ) instead of 228.84 seconds for the generic version ( 140 deals / second ).

Fixed using libredblack ( http://libredblack.sourceforge.net/ ) for states and stacks storage. (Compile-time options)

Added an option to use libJudy ( http://judy.sourceforge.net/ ) for states and stacks storage. Yields better performance than libredblack, but worse than the internal hash.

Added the -Wall by default for gcc in CMake.

Added the boards target to generate 24.board and 1941.board.

Updated the TODO file.

Added previous NEWS items for previous versions (in this file).

Now documenting the --version flag in USAGE.

Added an experimental ./configure convenience script (written in Perl) to run CMake using some configuration options. NOTE: Please don’t use it to build packages.

Added "scripts/time-fcs.pl" to help time a freecell-solver-range-parallel-solve dump.

Got rid of the hard_dfs() scan. It is still accepted as an argument, but is now using the soft_dfs() routines instead.

Many internal refactorings, cleanups tweaks and fine-tunings.

Moved away change_ver.sh to scripts/old/change_ver.sh - it does not seem to be used any longer.

Made sure the indexes of the iterations when the "-s -i" flags are specified are consecutive. Previously, they were much more inconsistent.

(Internals) Split ptr_state_with_locations_t into ptr_state_t (the key) and ptr_state_extra_info_t (the value). Not all code inside the #ifdef’s (like the libavl / libredblack code) was ported to use it instead.

Fixed the compilation with profiling information in Makefile.gnu (should be of concern only to developers).

Optimized move_stack_cards_to_different_stacks, yielding a substantial speed increase.

Converted the identifiers from starting with freecell_solver_ to starting with fc_solve_ , which is shorter and saner.

Made sure the effect of the "--sequence-move unlimited" option is not dependent on other options, so the sequence move will always be unlimited. (Thanks to larrysan for reporting this bug).

Fixed run-tests.pl (and as a result also ctest -V and make test) to run properly after a raw unpacking.

A New Configuration and build system based on CMake ( http://www.cmake.org/ ) which results in faster configurations and builds, and a much reduced archive size.

There’s a new suite of automated tests. See the file README for details how to run them.

There’s a new --version flag that prints the version of the library.

A speed optimization to the command line processing based on a radix-tree.

Many bug-fixes since 2.8.0. (Released as 2.8.x).

Better documentation and help screens. See:

A preset system - see the "-l" flag in USAGE.

An option to read parameters from files. See "--read-from-file" in USAGE.

Finally, it is now possible to run one instance of the solver after the other in case the other one has returned a negative verdict. This is useful for example to run an atomic moves preset after a meta-moves one, as the latter cannot guarantee an accurate false verdict.

Atomic moves and some atomic moves presets have been added. Solving using atomic moves guarantees that there will be no false negatives, but is slower than the Meta-moves-based presets. (At least for now). It also yields less interesting solutions.

There is now a "--prelude" switch (see USAGE) that allows running a static order of quotas at the beginning of the scan for the participating soft threads. It makes constructing faster solving presets easier, especially after utilising this code:

The PySol "Fan" game preset was added to make_pysol_freecell_board.py and to Freecell Solver itself. Note that the game is played with 18 columns/stacks , so Freecell Solver will usually need to be recompiled.

Several other command line options:

The internal code has undergone several speed boosts that made Freecell Solver much faster. Now the INDIRECT_STACK_STATES is a bit faster than COMPACT_STATES.

Updated the TODO list.

Now several scans are to operate on the same states' collection. This is done using a mechanism called "soft threads", which is switched in user-land and does not require system multi-threading. In the file "USAGE" see:

fcs_cl.h was included in the RPM .spec.

Freecell Solver’s version is now kept in the file ver.txt

Added manual pages symbolic links for the following command-line board generators:

Moved more declarations of functions to header files (ending with .h)

Added some compiler-optional inline annotations for functions.

The identifiers of the library are now all residing under freecell_solver_

New flag:

The package can now be built as an RPM for Red Hat Linux and compatible systems by running rpmbuild -ta on the archive.

Several speed-ups.

Added some presets for the PySol games "Beleaguered Castle", "Citadel" and "Streets and Alleys".

Re-factoring of the scans code to make it simpler.

Added many functions to the external API.

fc-solve now uses it, so it is fully loosely-coupled with the library it is linked against.

Added a randomized DFS scan (with a user-defined seed).

Win32 Makefile can now generate a working DLL.

A new build and configuration process based on the GNU Autotools (Autoconf, Automake and libtool). This allows portably build shared and static libraries and stuff like that.

The GNOME AisleRiot board-generation program can generate the boards of the more Solitaire variants which are supported by Freecell Solver.

Freecell Solver now has a solution optimization scan. Check it out by adding the "-opt" flag.

Many comments were added to the code, and you are welcome to go over it and see if you understand everything that goes on there. If you don’t, contact me and I’ll add some more comments.

Several speed optimizations were done in the internal hash, so I think it should run at least a little faster.

Many fixes for bugs and memory leaks.

A Soft-DFS scan - Depth-First Search that does not use procedural recursion was introduced.

A New Best-first Search Scan (called A* in the code and documentation) was introduced.

A New Breadth-First-Search (BFS or BrFS) scan was introduced. It’s not very practical.

Several moves were improved or added, so it can solve more layouts.

A more robust command-line argument handling, so less segfaults can be expected if it’s improperly used.

Added support for solving more game types.

Can be compiled so it will be less memory intensive (INDIRECT_STACK_STATES).

There’s an API for use by third-party developers. It supports suspending a solution process and resuming it from its last position.

Several random bug-fixes.

Support was added for several Solitaire variants besides Freecell, such as Forecell, Seahaven Towers and Eight Off.

It now can emits the moves themselves, instead of just the intermediate solutions.

Several bug-fixes.

Some bug-fixes.

Support for a variable number of freecells, columns, and cards per column.

Board generators for Microsoft Freecell, Freecell Pro and PySol.

An option to use the balanced binary tree implementations of libavl ( http://adtinfo.org/ ), glib ( http://en.wikipedia.org/wiki/GLib ), or libredblack ( http://libredblack.sourceforge.net/ ). Using them makes Freecell Solver about 33% faster.

Support for using "T" instead of "10" in board input/output.

Improved Documentation.

An extra movement that allows Freecell Solver to solve some boards which it could not solve previously.

The order of the stacks and freecells is preserved throughout the solutions.

There is now an option to limit to a certain number of iterations (so Freecell Solver will stop before it consumes too much memory)

Specify the order of the moves that will be tested. Usually, a test order can be found that will solve a given board really quickly.

Three major code optimizations. Freecell Solver now runs much faster.

Freecell Solver is now able to start solving from a non-initial board.