
Buongiorno!

RobboLito 0.085 arrives with RobboBases.

* RobboTotalBase

First the RobboLito system must be built.

$ make ## acknowledge HAS_POPCNT when possible

For the building of your 2s and 3s:
$ mkdir RobboTotalBase
$ mkdir RobboTotalBase/3
$ ./RobboBuild --mem --recurse P

And then 4s and 5s
$ mkdir RobboTotalBase/4
$ ./RobboBuild --recurse --mem PP Pp
$ mkdir RobboTotalBase/5
$ ./RobboBuild --recurse --mem PPP PPp

This last can take about 10-20 hours, and fit in 1GB of memory in the build.
The ending disk usage will be around 3.5GB.

So too the 6s, but not for 4-tuples and their inductions can be built.
If the --mem option is not present, the build goes by disk. The dated
tests have not assumed pawns with 6s, so be warned!

$ mkdir RobboTotalBase/6
$ ./RobboBuild QQqq
$ ./RobboBuild RNnn

These will take many hours. If you have enough, the --mem option will help.
Adding compression to disk builds was too hairy with meeting and beating
the Revolution deadline, but should see the future.

* Compression

RobboTotalBase uses by design 64K blocks of RLE+BWT+MTF+Huffman-compressed DTC
data, with wins just having one bit. This compares to other schemes in the end.

      Full Size   RobboSize  Index      Total PerCent
3s:      410382      37176+    272      37448   9.1%
4s:   157440864   15885237+  10780   15935813  10.1%
5s: 37429189056 3659510583+2289088 3661799671   9.8% (3.41GB)

The Nalimov takes 7.2GB for 5s, but they are DTM. For DTC, they are still
4.5GB, largely for the RobboEdge in its one-sided nature. The FEG are 5.6GB
with DTM, and should compare the RobboScheme if outfitted with DTC.

For 6s, a superstructural indexing scheme can be added for the future, and with
some attempt for a compatability to the current to exist.

* RobboTripleBases

These are other compressed bases, that yield only result information, but
can be accessed faster. Similar are ShredderBases and ScorpioBases. You
might propose a comparison, but I cannot avail.

The TripleBases are loaded at startup, just once. Their space is 3.5MB for 4s,
and 645MB for 5s. This last can be reduced to 500MB by a switch that computes
the TripleBase differently, but has slower access. There is no capacity to
use a TripleBase for 6s, until a later release.

On disk storage, compressing the TripleBases finds its form, but more brains
are needed to extend the method.

The building of a TripleBase depends on the TotalBase, and can also recurse.
But a warning, the piece order is important, and the superior choices I found
are in with included scripts. Build time wanders around 2-3 hours for your 5s.

$ mkdir RobboTripleBase
$ mkdir RobboTripleBase/2
$ mkdir RobboTripleBase/3
$ mkdir RobboTripleBase/4
$ mkdir RobboTripleBase/5
$ sh triple3.sh
$ sh triple4.sh
$ sh triple5.sh

* In Use

RobboLito on startup will load all found TripleBases, and access indices
for the TotalBases. Then the TripleBase gets used in search, until a root
position for TotalBases is attained, when a switch occurs. Enjoy!

* Limits

RobboLito keeps all the RobboTotalBase files open, and can overflow a
system or shell limit.
