mirror of
https://github.com/HChaZZY/Stockfish.git
synced 2025-12-24 19:16:49 +08:00
82f7d507ea
Change the operators of the Option type in uci.h to accept floating
point numbers in double precision on input as the numerical type for
the "spin" values of the UCI protocol.
The output of Stockfish after the "uci" command is unaffected.
This change is compatible with all the existing GUI (as they will
continue sending integers that we can interpret as doubles in SF),
and allows us to pass double parameters to Stockfish in the console
via the "setoption" command. This will be useful if we implement
another tuner as an alternative for SPSA.
Closes https://github.com/official-stockfish/Stockfish/pull/1556
No functional change.
---------------------
A example of the new functionality in action in the branch `tune_float2'`:
876c322d0f
I have added the following lines in ucioptions.cpp:
```C++
void on_pi(const Option& o)
{
double x = Options["PI"]; // or double x = o;
std::cerr << "received value is x = " << x << std::endl;
}
...
o["PI"] << Option(3.1415926, -10000000, 10000000, on_pi);
```
Then I can change the value of Pi in Stockfish via the command line, and
check that Stockfish understands a floating point:
````
> ./stockfish
> setoption name PI value 2.7182818284
received value is x = 2.71828
````
On output, the default value of Pi is truncated to 3 (to remain compatible
with the UCI protocol and GUIs):
````
> uci
[...]
option name SyzygyProbeLimit type spin default 6 min 0 max 6
option name PI type spin default 3 min -10000000 max 10000000
uciok
````
83 lines
2.4 KiB
C++
83 lines
2.4 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
|
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
|
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef UCI_H_INCLUDED
|
|
#define UCI_H_INCLUDED
|
|
|
|
#include <map>
|
|
#include <string>
|
|
|
|
#include "types.h"
|
|
|
|
class Position;
|
|
|
|
namespace UCI {
|
|
|
|
class Option;
|
|
|
|
/// Custom comparator because UCI options should be case insensitive
|
|
struct CaseInsensitiveLess {
|
|
bool operator() (const std::string&, const std::string&) const;
|
|
};
|
|
|
|
/// Our options container is actually a std::map
|
|
typedef std::map<std::string, Option, CaseInsensitiveLess> OptionsMap;
|
|
|
|
/// Option class implements an option as defined by UCI protocol
|
|
class Option {
|
|
|
|
typedef void (*OnChange)(const Option&);
|
|
|
|
public:
|
|
Option(OnChange = nullptr);
|
|
Option(bool v, OnChange = nullptr);
|
|
Option(const char* v, OnChange = nullptr);
|
|
Option(double v, int minv, int maxv, OnChange = nullptr);
|
|
Option(const char* v, const char *cur, OnChange = nullptr);
|
|
|
|
Option& operator=(const std::string&);
|
|
void operator<<(const Option&);
|
|
operator double() const;
|
|
operator std::string() const;
|
|
bool operator==(const char*);
|
|
|
|
private:
|
|
friend std::ostream& operator<<(std::ostream&, const OptionsMap&);
|
|
|
|
std::string defaultValue, currentValue, type;
|
|
int min, max;
|
|
size_t idx;
|
|
OnChange on_change;
|
|
};
|
|
|
|
void init(OptionsMap&);
|
|
void loop(int argc, char* argv[]);
|
|
std::string value(Value v);
|
|
std::string square(Square s);
|
|
std::string move(Move m, bool chess960);
|
|
std::string pv(const Position& pos, Depth depth, Value alpha, Value beta);
|
|
Move to_move(const Position& pos, std::string& str);
|
|
|
|
} // namespace UCI
|
|
|
|
extern UCI::OptionsMap Options;
|
|
|
|
#endif // #ifndef UCI_H_INCLUDED
|