-
Notifications
You must be signed in to change notification settings - Fork 2
/
2048.cpp
2668 lines (2418 loc) · 100 KB
/
2048.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//============================================================================
// Name : moporgic/TDL2048+ - 2048.cpp
// Author : Hung Guei @ moporgic
// Version : beta
// Description : The Most Efficient TD Learning Framework for 2048
//============================================================================
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <vector>
#include <functional>
#include <memory>
#include <map>
#include <cmath>
#include <ctime>
#include <tuple>
#include <string>
#include <numeric>
#include <limits>
#include <cctype>
#include <iterator>
#include <sstream>
#include <iomanip>
#include <list>
#include <random>
#include <thread>
#include <future>
#if defined(__linux__)
#include <sys/wait.h>
#include <unistd.h>
#endif
#include "moporgic/type.h"
#include "moporgic/util.h"
#include "moporgic/math.h"
#include "moporgic/shm.h"
#include "board.h"
namespace moporgic {
auto what = R"(
moporgic/TDL2048+ - The Most Efficient TD Learning Framework for 2048
Networks:
-n, --network [TOKEN]... specify the n-tuple network, default: 4x6patt
TOKEN is either an ALIAS or a custom PATTERN, where
ALIAS can be 4x6patt, 8x6patt, mono, num, ...
PATTERN specifies cell locations using hex digits
Recipes:
-t, --optimize [OPT]... issue a recipe to optimize the network
-e, --evaluate [OPT]... issue a recipe to evaluate the network
OPT begins with execution setting LOOP[xUNIT][:WIN],
followed by a list of options KEY[=VALUE]..., where
KEY can be mode, alpha, lambda, step, search, ...
-tt MODE set default recipe mode for -t
-et MODE set default recipe mode for -e
Parameters:
-a, --alpha ALPHA set the learning rate, default: 0.1 (1.0 enables TC)
-l, --lambda LAMBDA set the TD-lambda, default: 0 (disabled)
-N, --step STEP set the n-step, default: 1 or 5 if TD-lambda is on
-b, --block BLOCK set the minimal learning block, default: disabled
-@, --stage THRES set the multi-stage thresholds, default: disabled
-h, --shift THRES set the tile-downgrading threshold, default is 65536
-d, --depth DEPTH [OPT] enable the search with specified layers: 2p, 3p, ...
-c, --cache SIZE enable the TT with specified size: 1G, 2G, ...
-u, --unit UNIT set the statistic display interval, default: 1000
-w, --win TILE set the winning threshold, default: 2048
-%, --info set whether to show the summary, default: auto
Input/Output:
-i, --input [FILE]... specify inputs, support .w and .c files
-o, --output [FILE]... specify outputs, support .w, .c, and .x files
-io [FILE]... alias for -i [FILE]... -o [FILE]...
Miscellaneous:
-s, --seed [SEED] set the seed for the pseudo-random number
-p, --parallel [THREAD] enable lock-free parallelism for all recipes
-x, --options [OPT]... specify other options as KEY[=VALUE]
-#, --comment [TEXT]... specify command line comments
-v, --version display program build revision and quit
-?, --help display this message and quit
Report bugs and comments to "Hung Guei" <[email protected]>.
Please refer to https://moporgic.info/2048 for more details.
)";
typedef float numeric;
class weight {
public:
inline weight() : name(), length(0), raw(nullptr) {}
inline weight(const weight& w) = default;
inline ~weight() {}
typedef std::string sign_t;
typedef moporgic::numeric numeric;
struct structure {
numeric value;
static constexpr u32 code = to_hash("structure");
inline constexpr structure() : value(0) {}
inline constexpr structure(const structure& s) = default;
inline constexpr operator numeric&() { return value; }
inline constexpr operator const numeric&() const { return value; }
inline constexpr structure& operator =(const structure& s) = default;
inline constexpr numeric& operator =(numeric v) { return value = v; }
inline constexpr numeric& operator +=(numeric delta) { return value += delta; }
declare_comparators_with(const numeric&, value, v, inline constexpr);
};
struct coherence : structure {
numeric accum, updvu;
static constexpr u32 code = to_hash("coherence");
static constexpr numeric cinit = std::numeric_limits<numeric>::min();
inline constexpr coherence() : structure(), accum(cinit), updvu(cinit) {}
inline constexpr coherence(const coherence& c) = default;
inline constexpr coherence& operator =(const coherence& c) = default;
inline constexpr numeric& operator =(numeric v) {
accum = updvu = cinit;
return value = v;
}
inline constexpr numeric& operator +=(numeric delta) {
value += delta * (std::abs(accum) / updvu);
accum += delta;
updvu += std::abs(delta);
return value;
}
template<size_t i> struct unit : std::array<numeric, 3> {
constexpr inline operator numeric&() { return operator [](i); }
constexpr inline operator const numeric&() const { return operator [](i); }
constexpr inline numeric& operator =(numeric v) { return (operator [](i) = v); }
declare_comparators_with(const numeric&, operator [](i), v, constexpr inline);
};
};
typedef structure segment;
static u32& type() { static u32 code = segment::code; return code; }
static u32& type(u32 code) { return type() = code; }
inline sign_t sign() const { return name; }
inline size_t size() const { return length; }
constexpr inline segment& operator [](size_t i) { return pointer_cast<segment>(raw)[i]; }
template<typename type = segment> constexpr inline type& at(size_t i) { return pointer_cast<type>(raw)[i]; }
template<typename type = segment> constexpr inline type* data(size_t i = 0) const { return pointer_cast<type>(raw) + i; }
template<typename type = segment> constexpr inline clip<type> value() const { return { data<type>(0), data<type>(length) }; }
inline operator bool() const { return raw; }
declare_comparators(const weight&, sign(), inline);
friend std::ostream& operator <<(std::ostream& out, const weight& w) {
u32 code = 4;
write_cast<u8>(out, code);
switch (code) {
default:
case 4: [&]() {
try { // write sign as 32-bit integer if possible
size_t idx = 0;
u32 sign = std::stoul(w.sign(), &idx, 16);
if (idx != w.sign().size()) throw std::invalid_argument("unresolved");
write_cast<u32>(out, sign);
write_cast<u16>(out, w.sign().size()); // note: legacy serial 4 stores u16(0)
write_cast<u16>(out, 0);
} catch (std::logic_error&) { // otherwise, write it as string
out.write(w.sign().append(8, ' ').c_str(), 8);
}
auto write_unit = [](std::ostream& out, auto data) {
write_cast<numeric>(out, data.begin(), data.end());
};
switch (weight::type()) { // write value table
default:
case structure::code:
write_cast<u16>(out, sizeof(numeric));
write_cast<u64>(out, w.size());
write_unit(out, w.value<structure>());
break;
case coherence::code: // also write coherence tables if enabled
write_cast<u16>(out, sizeof(numeric));
write_cast<u64>(out, w.size());
write_unit(out, w.value<coherence::unit<0>>());
write_cast<u16>(out, sizeof(numeric));
write_cast<u64>(out, w.size() + w.size());
write_unit(out, w.value<coherence::unit<1>>());
write_unit(out, w.value<coherence::unit<2>>());
break;
}
// reserved for additional fields
write_cast<u16>(out, 0);
}(); break;
}
return out;
}
friend std::istream& operator >>(std::istream& in, weight& w) {
u32 code = 4;
read_cast<u8>(in, code);
switch (code) {
default:
case 4: [&]() {
// read name (raw), block size, length, and value table
in.read(const_cast<char*>(w.name.assign(8, ' ').data()), 8);
auto read_unit = [blkz = read<u16>(in)](std::istream& in, auto data) {
switch (blkz) { // binaries may typedef different numeric
case 2: read_cast<f16>(in, data.begin(), data.end()); break;
case 4: read_cast<f32>(in, data.begin(), data.end()); break;
case 8: read_cast<f64>(in, data.begin(), data.end()); break;
}
};
w.raw = weight::alloc(w.length = read<u64>(in));
switch (weight::type()) {
default:
case structure::code:
read_unit(in, w.value<structure>());
break;
case coherence::code:
read_unit(in, w.value<coherence::unit<0>>());
// also try loading coherence parameters
if (read<u16>(in) == 0 && in.seekg(-2, std::ios::cur)) break;
in.ignore(8);
read_unit(in, w.value<coherence::unit<1>>());
read_unit(in, w.value<coherence::unit<2>>());
// fix legacy coherence::cinit == 0
for (coherence& c : w.value<coherence>())
if (c.updvu == 0) c = numeric(c);
break;
}
// skip unrecognized fields
for (u32 blkz; (blkz = read<u16>(in)); in.ignore(blkz * read<u64>(in)));
// finalize name and display width
if (raw_cast<u16>(w.name[6]) == 0) { // name is serialized as integer
u32 sign = raw_cast<u32>(w.name[0]);
u32 width = raw_cast<u16>(w.name[4]);
if (width == 0) width = math::lg64(w.length) >> 2;
if (width < format("%x", sign).size()) width = 8;
w.name = format(format("%%0%ux", width), sign);
} else { // name is serialized as string
w.name = w.name.substr(0, w.name.find(' '));
}
}(); break;
}
return in;
}
static list<weight> save(std::ostream& out, std::string opt = {}) {
u32 code = 0;
write_cast<u8>(out, code);
list<weight> res;
switch (code) {
case 0: [&]() {
std::vector<u32> idxes = idx_select(opt);
write_cast<u32>(out, idxes.size());
for (u32 idx : idxes) out << wghts()[idx], res.push_back(wghts()[idx]);
}(); break;
}
return res;
}
static list<weight> load(std::istream& in, std::string opt = {}) {
u32 code = 0;
read_cast<u8>(in, code);
list<weight> res;
switch (code) {
case 0: [&]() {
weight::container buf;
for (u32 num = read<u32>(in); num; num--)
in >> buf.emplace_back();
for (u32 idx : idx_select(opt + format("[0:%u]", u32(buf.size()))))
wghts().push_back(buf[idx]), res.push_back(buf[idx]);
for (weight w : buf)
if (!weight(w.sign())) free(w.data());
}(); break;
}
return res;
}
private:
static std::vector<u32> idx_select(std::string opt = {}) {
std::vector<u32> idxes;
std::stringstream tokens((opt += "[]").substr(0, opt.find(']')).substr(opt.find('[') + 1));
for (std::string token; std::getline(tokens, token, ',');) { // idx,idx-lim,idx:len
u32 i = -1u, n = -1u; char x = '.';
std::stringstream(token) >> i >> x >> n;
if (i != -1u) idxes.push_back(i);
if (x == ':' && n != -1u) x = '-', n = i + n - 1;
if (x == '-' && n != -1u) while (++i <= n) idxes.push_back(i);
}
if (idxes.empty()) {
idxes.resize(wghts().size());
std::iota(idxes.begin(), idxes.end(), 0);
}
return idxes;
}
public:
class container : public list<weight> {
public:
constexpr container() noexcept : list<weight>() {}
container(const clip<weight>& w) : list<weight>(w) {}
public:
weight& make(sign_t sign, size_t size) { return list<weight>::emplace_back(weight(sign, size)); }
weight erase(sign_t sign) { auto it = find(sign); auto w = *it; free(it->data()); list<weight>::erase(it); return w; }
weight* find(sign_t sign) const { return std::find_if(begin(), end(), [=](const weight& w) { return w.sign() == sign; }); }
weight& at(sign_t sign) const { auto it = find(sign); if (it != end()) return *it; throw std::out_of_range("weight::at"); }
weight& operator[](sign_t sign) const { return (*find(sign)); }
weight operator()(sign_t sign) const { auto it = find(sign); return it != end() ? *it : ({ weight w; w.name = sign; w; }); }
};
static inline weight::container& wghts() { static container w; return w; }
static inline weight& make(sign_t sign, size_t size, container& src = wghts()) { return src.make(sign, size); }
static inline size_t erase(sign_t sign, container& src = wghts()) { return src.erase(sign); }
inline weight(sign_t sign, const container& src = wghts()) : weight(src(sign)) {}
private:
inline weight(sign_t sign, size_t size) : name(sign), length(size), raw(alloc(size)) {}
static inline structure* alloc(size_t size) {
switch (weight::type()) {
default:
case structure::code: return shm::enable<segment>() ? shm::alloc<structure>(size) : new structure[size]();
case coherence::code: return shm::enable<segment>() ? shm::alloc<coherence>(size) : new coherence[size]();
}
}
static inline void free(structure* v) { shm::enable<segment>() ? shm::free<structure>(v) : delete[] v; }
sign_t name;
size_t length;
structure* raw;
};
class indexer {
public:
inline indexer() : name(), map(nullptr) {}
inline indexer(const indexer& i) = default;
inline ~indexer() {}
typedef std::string sign_t;
typedef u64(*mapper)(const board&);
inline sign_t sign() const { return name; }
constexpr inline mapper index() const { return map; }
constexpr inline u64 operator ()(const board& b) const { return (*map)(b); }
inline operator bool() const { return map; }
declare_comparators(const indexer&, sign(), inline);
class container : public list<indexer> {
public:
constexpr container() noexcept : list<indexer>() {}
container(const clip<indexer>& i) : list<indexer>(i) {}
public:
indexer& make(sign_t sign, mapper map) { return list<indexer>::emplace_back(indexer(sign, map)); }
indexer erase(sign_t sign) { auto it = find(sign); auto x = *it; list<indexer>::erase(it); return x; }
indexer* find(sign_t sign) const { return std::find_if(begin(), end(), [=](const indexer& i) { return i.sign() == sign; }); }
indexer& at(sign_t sign) const { auto it = find(sign); if (it != end()) return *it; throw std::out_of_range("indexer::at"); }
indexer& operator[](sign_t sign) const { return (*find(sign)); }
indexer operator()(sign_t sign) const { auto it = find(sign); return it != end() ? *it : ({ indexer x; x.name = sign; x; }); }
};
static inline indexer::container& idxrs() { static container i; return i; }
static inline indexer& make(sign_t sign, mapper map, container& src = idxrs()) { return src.make(sign, map); }
static inline size_t erase(sign_t sign, container& src = idxrs()) { return src.erase(sign); }
inline indexer(sign_t sign, const container& src = idxrs()) : indexer(src(sign)) {}
private:
inline indexer(sign_t sign, mapper map) : name(sign), map(map) {}
sign_t name;
mapper map;
};
class feature {
public:
inline feature() : name(), raw(), map() {}
inline feature(const feature& t) = default;
inline ~feature() {}
typedef std::string sign_t;
inline sign_t sign() const { return name; }
constexpr inline weight::segment& operator [](const board& b) { return raw[map(b)]; }
constexpr inline weight::segment& operator [](u64 idx) { return raw[idx]; }
template<typename type = weight::segment> constexpr inline type& at(const board& b) { return raw.at<type>(map(b)); }
template<typename type = weight::segment> constexpr inline type& at(u64 idx) { return raw.at<type>(idx); }
constexpr inline u64 operator ()(const board& b) const { return map(b); }
inline indexer index() const { return map; }
inline weight value() const { return raw; }
inline operator bool() const { return map && raw; }
declare_comparators(const feature&, sign(), inline);
class container : public list<feature> {
public:
constexpr container() noexcept : list<feature>() {}
container(const clip<feature>& f) : list<feature>(f) {}
public:
feature& make(sign_t wgt, sign_t idx) { return list<feature>::emplace_back(feature(weight(wgt), indexer(idx))); }
feature& make(sign_t sign) { return make(sign.substr(0, sign.find(':')), sign.substr(sign.find(':') + 1)); }
feature erase(sign_t wgt, sign_t idx) { return erase(wgt + ':' + idx); }
feature erase(sign_t sign) { auto it = find(sign); auto f = *it; list<feature>::erase(it); return f; }
feature* find(sign_t wgt, sign_t idx) const { return find(wgt + ':' + idx); }
feature* find(sign_t sign) const { return std::find_if(begin(), end(), [=](const feature& f) { return f.sign() == sign; }); }
feature& at(sign_t wgt, sign_t idx) const { return at(wgt + ':' + idx); }
feature& at(sign_t sign) const { auto it = find(sign); if (it != end()) return *it; throw std::out_of_range("feature::at"); }
feature& operator[](sign_t sign) const { return (*find(sign)); }
feature operator()(sign_t wgt, sign_t idx) const { return operator()(wgt + ':' + idx); }
feature operator()(sign_t sign) const { auto it = find(sign); return it != end() ? *it : ({ feature f; f.name = sign; f; }); }
};
static inline feature::container& feats() { static container f; return f; }
static inline feature& make(sign_t wgt, sign_t idx, container& src = feats()) { return src.make(wgt, idx); }
static inline size_t erase(sign_t wgt, sign_t idx, container& src = feats()) { return src.erase(wgt, idx); }
inline feature(sign_t wgt, sign_t idx, const container& src = feats()) : feature(src(wgt, idx)) {}
private:
inline feature(const weight& value, const indexer& index) : name(value.sign() + ':' + index.sign()), raw(value), map(index) {}
sign_t name;
weight raw;
indexer map;
};
class cache {
public:
class block {
public:
class access {
public:
constexpr access(u64 sign, u32 hold, block& blk) : sign(sign), info(0), blk(blk) {
block shot = blk;
bool safe = (shot.sign() == sign) & (shot.hold() >= hold);
u32 hits = std::min(shot.hits() + 1, 65535);
raw_cast<f32, 0>(info) = shot.esti();
raw_cast<u16, 2>(info) = hold;
raw_cast<u16, 3>(info) = safe ? hits : 0;
}
constexpr access(access&& acc) = default;
constexpr access(const access&) = delete;
constexpr access& operator =(const access&) = delete;
constexpr operator bool() const { return raw_cast<u16, 3>(info); }
constexpr numeric fetch() const { return raw_cast<f32, 0>(info); }
constexpr numeric store(numeric esti) {
raw_cast<f32, 0>(info) = esti;
raw_cast<u16, 3>(info) = std::min(raw_cast<u16, 3>(info) + 1, 65535);
blk = block(sign, info);
return esti;
}
private:
u64 sign;
u64 info; // f32 esti; u16 hold; u16 hits;
block& blk;
};
constexpr block(const block& e) = default;
constexpr block(u64 sign = 0, u64 info = 0) : hash(sign ^ info), info(info) {}
constexpr access operator()(u64 x, u32 n) { return access(x, n, *this); }
constexpr u64 sign() const { return hash ^ info; }
constexpr f32 esti() const { return raw_cast<f32, 0>(info); }
constexpr u16 hold() const { return raw_cast<u16, 2>(info); }
constexpr u16 hits() const { return raw_cast<u16, 3>(info); }
private:
u64 hash;
u64 info; // f32 esti; u16 hold; u16 hits;
};
constexpr cache() : cached(&initial), length(1), mask(0), nmap{} {}
constexpr inline size_t size() const { return length; }
constexpr inline block& operator[] (size_t i) { return cached[i]; }
constexpr inline const block& operator[] (size_t i) const { return cached[i]; }
constexpr inline block::access operator() (const board& b, u32 n) {
u64 x = ({ board x(b); x.isomin64(); x; });
return (*this)[indexof(x, n)](x, n);
}
constexpr inline size_t indexof(u64 x, u32 n) const {
return (math::fmix64(x) ^ nmap[n >> 1]) & mask;
}
friend std::ostream& operator <<(std::ostream& out, const cache& c) {
u32 code = 4;
write_cast<byte>(out, code);
switch (code) {
default:
case 4: [&]() {
// reserved for header
write_cast<u16>(out, 0);
write_cast<u64>(out, 0);
// write blocks
write_cast<u16>(out, sizeof(block));
write_cast<u64>(out, c.size());
write<block>(out, c.cached, c.cached + c.size());
// write depth-map (nmap)
write_cast<u16>(out, sizeof(u64));
write_cast<u64>(out, c.nmap.size());
write_cast<u64>(out, c.nmap.begin(), c.nmap.end());
// reserved for fields
write_cast<u16>(out, 0);
}(); break;
}
return out;
}
friend std::istream& operator >>(std::istream& in, cache& c) {
u32 code = 0;
read_cast<byte>(in, code);
switch (code) {
default:
case 4: [&]() {
// ignore unused header
in.ignore(read<u16>(in) * read<u64>(in));
// read blocks (block size is ignored)
c.init(read<u64>(in.ignore(2)));
read<block>(in, c.cached, c.cached + c.size());
// read depth-map (nmap)
u32 blkz = read<u16>(in);
size_t nmnum = read<u64>(in);
read_cast<u64>(in, c.nmap.begin(), c.nmap.begin() + std::min(c.nmap.size(), nmnum));
if (nmnum > c.nmap.size()) in.ignore(sizeof(u64) * (nmnum - c.nmap.size()));
// ignore unrecognized fields
while ((blkz = read<u16>(in)) != 0) in.ignore(blkz * read<u64>(in));
}(); break;
}
return in;
}
static list<cache> save(std::ostream& out, std::string opt = {}) {
u32 code = 0;
write_cast<byte>(out, code);
list<cache> res;
switch (code) {
case 0:
out << instance(), res.push_back(instance());
break;
}
return res;
}
static list<cache> load(std::istream& in, std::string opt = {}) {
u32 code = 0;
read_cast<byte>(in, code);
list<cache> res;
switch (code) {
case 0:
in >> instance(), res.push_back(instance());
break;
}
return res;
}
static inline block::access find(const board& b, u32 n) { return instance()(b, n); }
static inline cache& make(size_t len, bool peek = false) { return instance().init(std::max(len, size_t(1)), peek); }
static inline cache& refresh() { return instance().reset(); }
static inline cache& instance() { static cache tp; return tp; }
private:
static inline block* alloc(size_t len) { return shm::enable<block>() ? shm::alloc<block>(len) : new block[len](); }
static inline void free(block* alloc) { shm::enable<block>() ? shm::free<block>(alloc) : delete[] alloc; }
cache& init(size_t len, bool peek = false) {
length = (1ull << (math::lg64(len)));
mask = length - 1;
if (cached != &initial) free(cached);
cached = length > 1 ? alloc(length) : &initial;
for (size_t i = 0; i < nmap.size(); i++)
nmap[i] = peek ? 0 : math::fmix64(i);
return *this;
}
cache& reset() {
std::fill_n(cached, length, block{});
return *this;
}
private:
block* cached;
block initial;
size_t length;
size_t mask;
std::array<size_t, 16> nmap;
};
namespace index {
template<u32... patt>
inline constexpr u32 order() {
if (sizeof...(patt) > 8 || sizeof...(patt) == 0) return -1;
constexpr u32 x[] = { patt... };
for (u32 i = 1; i < sizeof...(patt); i++) if (x[i] <= x[i - 1]) return 0; // unordered
#if defined(__BMI2__) && !defined(PREFER_LEGACY_INDEXPT_ORDER)
for (u32 i = 1; i < sizeof...(patt); i++) if (x[i] != x[i - 1] + 1) return 1; // ordered
#else
for (u32 i = 1; i < sizeof...(patt); i++) if (x[i] != x[i - 1] + 1) return 0; // ordered (fall back)
#endif
return 2; // strictly ordered
}
template<u32... patt>
inline constexpr typename std::enable_if<order<patt...>() == 0, u64>::type indexpt(const board& b) {
u32 index = 0, n = 0;
for (u32 p : { patt... }) index += b.at(p) << (n++ << 2);
return index;
}
#if defined(__BMI2__) && !defined(PREFER_LEGACY_INDEXPT_ORDER)
template<u32... patt>
inline constexpr typename std::enable_if<order<patt...>() == 1, u64>::type indexpt(const board& b) {
u64 mask = 0;
for (u64 p : { patt... }) mask |= 0xfull << (p << 2);
return math::pext64(b, mask);
}
#elif !defined(PREFER_LEGACY_INDEXPT_ORDER) // specialize common ordered patterns when BMI2 is unavailable
template<> u64 indexpt<0x0,0x1,0x4,0x5>(const board& b) { return ((u64(b)) & 0x00ff) | ((u64(b) >> 8) & 0xff00); }
template<> u64 indexpt<0x1,0x2,0x5,0x6>(const board& b) { return ((u64(b) >> 4) & 0x00ff) | ((u64(b) >> 12) & 0xff00); }
template<> u64 indexpt<0x5,0x6,0x9,0xa>(const board& b) { return ((u64(b) >> 20) & 0x00ff) | ((u64(b) >> 28) & 0xff00); }
template<> u64 indexpt<0x0,0x1,0x2,0x4,0x5>(const board& b) { return ((u64(b)) & 0x00fff) | (((u64(b)) >> 4) & 0xff000); }
template<> u64 indexpt<0x4,0x5,0x6,0x8,0x9>(const board& b) { return ((u64(b) >> 16) & 0x00fff) | ((u64(b) >> 20) & 0xff000); }
template<> u64 indexpt<0x0,0x1,0x2,0x3,0x5>(const board& b) { return ((u64(b)) & 0x0ffff) | ((u64(b) >> 4) & 0xf0000); }
template<> u64 indexpt<0x4,0x5,0x6,0x7,0x9>(const board& b) { return ((u64(b) >> 16) & 0x0ffff) | ((u64(b) >> 20) & 0xf0000); }
template<> u64 indexpt<0x0,0x1,0x2,0x4,0x5,0x6>(const board& b) { return ((u64(b)) & 0x000fff) | (((u64(b)) >> 4) & 0xfff000); }
template<> u64 indexpt<0x4,0x5,0x6,0x8,0x9,0xa>(const board& b) { return ((u64(b) >> 16) & 0x000fff) | ((u64(b) >> 20) & 0xfff000); }
template<> u64 indexpt<0x2,0x3,0x4,0x5,0x6,0x9>(const board& b) { return ((u64(b) >> 8) & 0x0fffff) | ((u64(b) >> 16) & 0xf00000); }
template<> u64 indexpt<0x0,0x1,0x2,0x5,0x9,0xa>(const board& b) { return ((u64(b)) & 0x000fff) | ((u64(b) >> 8) & 0x00f000) | ((u64(b) >> 20) & 0xff0000); }
template<> u64 indexpt<0x1,0x3,0x4,0x5,0x6,0x7>(const board& b) { return ((u64(b) >> 4) & 0x00000f) | ((u64(b) >> 8) & 0xfffff0); }
template<> u64 indexpt<0x0,0x1,0x4,0x8,0x9,0xa>(const board& b) { return ((u64(b)) & 0x0000ff) | ((u64(b) >> 8) & 0x000f00) | ((u64(b) >> 20) & 0xfff000); }
#endif
template<u32 p, u32... x>
inline constexpr typename std::enable_if<order<p, x...>() == 2, u64>::type indexpt(const board& b) {
return u32(u64(b) >> (p << 2)) & u32((1ull << ((sizeof...(x) + 1) << 2)) - 1);
}
u64 indexptv(const board& b, const std::vector<u32>& p) {
u64 index = 0;
for (size_t i = 0; i < p.size(); i++)
index += b.at(p[i]) << (i << 2);
return index;
}
u64 indexmerge(const board& b) { // 16-bit
u32 hori = 0, vert = 0;
hori |= b.qrow(0).merge << 0;
hori |= b.qrow(1).merge << 2;
hori |= b.qrow(2).merge << 4;
hori |= b.qrow(3).merge << 6;
vert |= b.qcol(0).merge << 0;
vert |= b.qcol(1).merge << 2;
vert |= b.qcol(2).merge << 4;
vert |= b.qcol(3).merge << 6;
return hori | (vert << 8);
}
u64 indexnum(const board& b) { // 24-bit
hex num = b.numof();
u64 index = 0;
index |= (num[0] + num[1] + num[2] + num[3]) << 0; // 0+2+4+8, 4-bit
index |= (num[4] + num[5] + num[6]) << 4; // 16+32+64, 4-bit
index |= (num[7] + num[8]) << 8; // 128+256, 4-bit
index |= std::min(u32(num[9] + num[10]), 7u) << 12; // 512+1024, 3-bit
index |= std::min(u32(num[11]), 3u) << 15; // 2048~16384, 2-bit ea.
index |= std::min(u32(num[12]), 3u) << 17;
index |= std::min(u32(num[13]), 3u) << 19;
index |= std::min(u32(num[14]), 3u) << 21;
index |= std::min(u32(num[15]), 1u) << 23; // 32768, 1-bit
return index;
}
u64 indexnumlt(const board& b) { // 24-bit
hex num = b.numof();
u64 index = 0;
index |= std::min(u32(num[8]), 7u) << 0; // 256, 3-bit
index |= std::min(u32(num[9]), 7u) << 3; // 512, 3-bit
index |= std::min(u32(num[10]), 7u) << 6; // 1024, 3-bit
index |= std::min(u32(num[11]), 7u) << 9; // 2048, 3-bit
index |= std::min(u32(num[12]), 7u) << 12; // 4096, 3-bit
index |= std::min(u32(num[13]), 7u) << 15; // 8192, 3-bit
index |= std::min(u32(num[14]), 7u) << 18; // 16384, 3-bit
index |= std::min(u32(num[15]), 7u) << 21; // 32768, 3-bit
return index;
}
u64 indexnumst(const board& b) { // 24-bit
hex num = b.numof();
u64 index = 0;
index |= std::min(u32(num[0]), 7u) << 0; // 0, 3-bit
index |= std::min(u32(num[1]), 7u) << 3; // 2, 3-bit
index |= std::min(u32(num[2]), 7u) << 6; // 4, 3-bit
index |= std::min(u32(num[3]), 7u) << 9; // 8, 3-bit
index |= std::min(u32(num[4]), 7u) << 12; // 16, 3-bit
index |= std::min(u32(num[5]), 7u) << 15; // 32, 3-bit
index |= std::min(u32(num[6]), 7u) << 18; // 64, 3-bit
index |= std::min(u32(num[7]), 7u) << 21; // 128, 3-bit
return index;
}
template<u32 p0, u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6, u32 p7>
u64 indexmono(const board& b) { // 24-bit
u32 h0 = (b.at(p0)) | (b.at(p1) << 4) | (b.at(p2) << 8) | (b.at(p3) << 12);
u32 h1 = (b.at(p4)) | (b.at(p5) << 4) | (b.at(p6) << 8) | (b.at(p7) << 12);
return (board::cache::load(h0).mono) | (board::cache::load(h1).mono << 12);
}
template<u32 tile, u32 isomorphic>
u64 indexmask(const board& b) { // 16-bit
board k = b;
k.isom(isomorphic);
return k.mask(tile);
}
template<u32 isomorphic>
u64 indexmax(const board& b) { // 16-bit
board k = b;
k.isom(isomorphic);
return k.mask(k.max());
}
struct adapter {
typedef moporgic::list<indexer::mapper> adapter_list;
typedef moporgic::list<std::function<u64(const board&)>> indexer_list;
static inline adapter_list& wlist() { static adapter_list w; return w; }
static inline indexer_list& hlist() { static indexer_list h; return h; }
inline operator indexer::mapper() const { return wlist().front(); }
inline adapter(std::function<u64(const board&)> hdr) { hlist().push_back(hdr); }
inline ~adapter() { wlist().pop_front(); }
template<u32 idx>
static u64 adapt(const board& b) { return hlist()[idx](b); }
template<u32 idx, u32 lim>
static void make() { make_wrappers<idx, lim>(); }
template<u32 idx, u32 lim>
struct make_wrappers {
make_wrappers() { wlist().push_back(adapter::adapt<idx>); }
~make_wrappers() { make_wrappers<idx + 1, lim>(); }
};
template<u32 lim>
struct make_wrappers<lim, lim> {};
};
struct make {
make(indexer::sign_t sign, indexer::mapper func) {
if (!indexer(sign)) indexer::make(sign, func);
else if (indexer(sign).index() != func) std::exit(127);
}
template<u32... patt>
struct indexpt {
indexpt(bool iso = true) { isomorphic<0>(iso); }
template<u32 i> static typename std::enable_if<(i != 8), void>::type isomorphic(bool iso) {
constexpr board x = isoindex(i);
make(vtos({x.at(patt)...}), index::indexpt<x.at(patt)...>);
if (iso) isomorphic<i + 1>(iso);
}
template<u32 i> static typename std::enable_if<(i == 8), void>::type isomorphic(bool iso) {}
static constexpr board isoindex(u32 i) {
board x = 0xfedcba9876543210ull;
x.isom((i & 4) + (8 - i) % 4);
return x;
}
static std::string vtos(const std::initializer_list<u32>& v) {
std::string name;
for (u32 i : v) name += char((i < 10) ? ('0' + i) : ('a' + i - 10));
return name;
}
};
};
__attribute__((constructor)) void init() {
make::indexpt<0x0,0x1,0x2,0x3,0x4,0x5>(); // 012345!
make::indexpt<0x4,0x5,0x6,0x7,0x8,0x9>(); // 456789!
make::indexpt<0x0,0x1,0x2,0x4,0x5,0x6>(); // 012456!
make::indexpt<0x4,0x5,0x6,0x8,0x9,0xa>(); // 45689a!
make::indexpt<0x8,0x9,0xa,0xb,0xc,0xd>(); // 89abcd!
make::indexpt<0x2,0x3,0x4,0x5,0x6,0x9>(); // 234569!
make::indexpt<0x0,0x1,0x2,0x5,0x9,0xa>(); // 01259a!
make::indexpt<0x3,0x4,0x5,0x6,0x7,0x8>(); // 345678!
make::indexpt<0x1,0x3,0x4,0x5,0x6,0x7>(); // 134567!
make::indexpt<0x0,0x1,0x4,0x8,0x9,0xa>(); // 01489a!
make::indexpt<0x0,0x1,0x2,0x3,0x4>(); // 01234!
make::indexpt<0x4,0x5,0x6,0x7,0x8>(); // 45678!
make::indexpt<0x0,0x1,0x2,0x4,0x5>(); // 01245!
make::indexpt<0x4,0x5,0x6,0x8,0x9>(); // 45689!
make::indexpt<0x0,0x1,0x2,0x3,0x5>(); // 01235!
make::indexpt<0x4,0x5,0x6,0x7,0x9>(); // 45679!
make::indexpt<0x8,0x9,0xa,0xb,0xc>(false); // 89abc
make::indexpt<0x8,0x9,0xa,0xc,0xd>(false); // 89acd
make::indexpt<0x8,0x9,0xa,0xb,0xd>(false); // 89abd
make::indexpt<0x1,0x2,0x3,0x5,0x6>(false); // 12356
make::indexpt<0x5,0x6,0x7,0x9,0xa>(false); // 5679a
make::indexpt<0x9,0xa,0xb,0xd,0xe>(false); // 9abde
make::indexpt<0x0,0x1,0x2,0x3>(); // 0123!
make::indexpt<0x4,0x5,0x6,0x7>(); // 4567!
make::indexpt<0x0,0x1,0x4,0x5>(); // 0145!
make::indexpt<0x1,0x2,0x5,0x6>(); // 1256!
make::indexpt<0x5,0x6,0x9,0xa>(); // 569a!
make::indexpt<0x8,0x9,0xa,0xb>(false); // 89ab
make::indexpt<0xc,0xd,0xe,0xf>(false); // cdef
make::indexpt<0x0,0x4,0x8,0xc>(false); // 048c
make::indexpt<0x1,0x5,0x9,0xd>(false); // 159d
make::indexpt<0x2,0x6,0xa,0xe>(false); // 26ae
make::indexpt<0x3,0x7,0xb,0xf>(false); // 37bf
make::indexpt<0x0,0x1,0x2,0x4>(false); // 0124
make::indexpt<0x1,0x2,0x3,0x5>(false); // 1235
make::indexpt<0x4,0x5,0x6,0x8>(false); // 4568
make::indexpt<0x5,0x6,0x7,0x9>(false); // 5679
make::indexpt<0x8,0x9,0xa,0xc>(false); // 89ac
make::indexpt<0x9,0xa,0xb,0xd>(false); // 9abd
make::indexpt<0x0,0x1,0x2,0x5>(false); // 0125
make::indexpt<0x4,0x5,0x6,0x9>(false); // 4569
make::indexpt<0x8,0x9,0xa,0xd>(false); // 89ad
make::indexpt<0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7>(); // 01234567!
make::indexpt<0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb>(); // 456789ab!
make::indexpt<0x0,0x1,0x2,0x4,0x5,0x6,0x8,0x9>(); // 01245689!
make::indexpt<0x0,0x1,0x2,0x3,0x4,0x5,0x8,0xc>(); // 0123458c!
make::indexpt<0x0,0x1,0x2,0x3,0x4,0x5,0x6>(); // 0123456!
make::indexpt<0x4,0x5,0x6,0x7,0x8,0x9,0xa>(); // 456789a!
make::indexpt<0x8,0x9,0xa,0xb,0xc,0xd,0xe>(); // 89abcde!
make::indexpt<0x0,0x1,0x2,0x3,0x4,0x5,0x8>(); // 0123458!
make::indexpt<0x4,0x5,0x6,0x7,0x8,0x9,0xc>(); // 456789c!
make("merge", indexmerge);
make("num", indexnum);
make("num@lt", indexnumlt);
make("num@st", indexnumst);
make("m@0123", indexmono<0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7>);
make("m@37bf", indexmono<0x3,0x7,0xb,0xf,0x2,0x6,0xa,0xe>);
make("m@fedc", indexmono<0xf,0xe,0xd,0xc,0xb,0xa,0x9,0x8>);
make("m@c840", indexmono<0xc,0x8,0x4,0x0,0xd,0x9,0x5,0x1>);
make("m@3210", indexmono<0x3,0x2,0x1,0x0,0x7,0x6,0x5,0x4>);
make("m@fb73", indexmono<0xf,0xb,0x7,0x3,0xe,0xa,0x6,0x2>);
make("m@cdef", indexmono<0xc,0xd,0xe,0xf,0x8,0x9,0xa,0xb>);
make("m@048c", indexmono<0x0,0x4,0x8,0xc,0x1,0x5,0x9,0xd>);
make("m@4567", indexmono<0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb>);
make("m@26ae", indexmono<0x2,0x6,0xa,0xe,0x1,0x5,0x9,0xd>);
make("m@ba98", indexmono<0xb,0xa,0x9,0x8,0x7,0x6,0x5,0x4>);
make("m@d951", indexmono<0xd,0x9,0x5,0x1,0xe,0xa,0x6,0x2>);
make("m@7654", indexmono<0x7,0x6,0x5,0x4,0xb,0xa,0x9,0x8>);
make("m@ea62", indexmono<0xe,0xa,0x6,0x2,0xd,0x9,0x5,0x1>);
make("m@89ab", indexmono<0x8,0x9,0xa,0xb,0x4,0x5,0x6,0x7>);
make("m@159d", indexmono<0x1,0x5,0x9,0xd,0x2,0x6,0xa,0xe>);
make("max#0", indexmax<0>);
make("max#1", indexmax<1>);
make("max#2", indexmax<2>);
make("max#3", indexmax<3>);
make("max#4", indexmax<4>);
make("max#5", indexmax<5>);
make("max#6", indexmax<6>);
make("max#7", indexmax<7>);
adapter::make<0, 256>();
}
} // namespace utils
namespace utils {
class options {
public:
options() {}
options(const options& opts) : opts(opts.opts) {}
typedef std::list<std::string> list;
class opinion {
friend class option;
public:
opinion() = delete;
opinion(const opinion& i) = default;
opinion(std::string& token) : token(token) {}
operator std::string() const { return value(); }
operator numeric() const { return std::stod(value()); }
std::string label() const { return token.substr(0, token.find('=')); }
std::string value() const { return token.find('=') != std::string::npos ? token.substr(token.find('=') + 1) : ""; }
std::string value(const std::string& def) const { auto val = value(); return val.size() ? val : def; }
numeric value(numeric def) const { try { return numeric(*this); } catch (std::invalid_argument&) {} return def; }
std::string operator +(const std::string& val) { return value() + val; }
friend std::string operator +(const std::string& val, const opinion& opi) { return val + opi.value(); }
friend std::ostream& operator <<(std::ostream& out, const opinion& i) { return out << i.value(); }
opinion& operator =(const opinion& opi) { return operator =(opi.value()); }
opinion& operator =(const numeric& val) { return operator =(ntos(val)); }
opinion& operator =(const std::string& val) { token = label() + (val.size() ? ("=" + val) : ""); return (*this); }
opinion& operator +=(const std::string& val) { return operator =(value() + val); }
opinion& operator =(const list& vec) { return operator =(vtos(vec)); }
opinion& operator +=(const list& vec) { return operator =(value() + vtos(vec)); }
opinion& operator <<(const std::string& val) { return operator =(value(val)); }
bool operator ==(const std::string& val) const { return value() == val; }
bool operator !=(const std::string& val) const { return value() != val; }
bool operator ()(const std::string& val) const { return value().find(val) != std::string::npos; }
static bool comp(std::string token, std::string label) { return opinion(token).label() == label; }
private:
std::string& token;
};
class option : public list {
friend class options;
public:
option(const list& opt = {}) : list(opt) {}
operator std::string() const { return value(); }
operator numeric() const { return std::stod(value()); }
std::string value() const { return vtos(*this); }
std::string value(const std::string& def) const { auto val = value(); return val.size() ? val : def; }
numeric value(numeric def) const { try { return numeric(*this); } catch (std::invalid_argument&) {} return def; }
std::string operator +(const std::string& val) { return value() + val; }
friend std::string operator +(const std::string& val, const option& opt) { return val + opt.value(); }
friend std::ostream& operator <<(std::ostream& out, const option& opt) { return out << opt.value(); }
option& operator =(const numeric& val) { return operator =(ntos(val)); }
option& operator =(const std::string& val) { clear(); return operator +=(val); }
option& operator +=(const std::string& val) { push_back(val); return *this; }
option& operator =(const list& vec) { clear(); return operator +=(vec); }
option& operator +=(const list& vec) { insert(end(), vec.begin(), vec.end()); return *this; }
option& operator <<(const std::string& val) { return operator =(value(val)); }
bool operator ==(const std::string& val) const { return value() == val; }
bool operator !=(const std::string& val) const { return value() != val; }
bool operator ()(const std::string& ext) const {
return std::find_if(cbegin(), cend(), std::bind(opinion::comp, std::placeholders::_1, ext)) != cend();
}
bool operator ()(const std::string& ext, const std::string& val) const {
return operator ()(ext) && const_cast<option&>(*this)[ext](val);
}
opinion operator [](const std::string& ext) {
auto pos = std::find_if(begin(), end(), std::bind(opinion::comp, std::placeholders::_1, ext));
return (pos != end()) ? opinion(*pos) : operator +=(ext)[ext];
}
std::string find(const std::string& ext, const std::string& val = {}) const {
return operator() (ext) ? const_cast<option&>(*this)[ext] : val;
}
};
bool operator ()(const std::string& opt) const {
return opts.find(opt) != opts.end();
}
bool operator ()(const std::string& opt, const std::string& ext) const {
return operator ()(opt) && const_cast<options&>(*this)[opt](ext);
}
bool operator ()(const std::string& opt, const std::string& ext, const std::string& val) const {
return operator ()(opt, ext) && const_cast<options&>(*this)[opt][ext](val);
}
option& operator [](const std::string& opt) {
if (opts.find(opt) == opts.end()) opts[opt] = option();
return opts[opt];
}
std::string find(const std::string& opt, const std::string& val = {}) const {
return operator()(opt) ? const_cast<options&>(*this)[opt] : val;
}
private:
std::map<std::string, option> opts;
static std::string vtos(const list& vec) {
std::string str = std::accumulate(vec.cbegin(), vec.cend(), std::string(),
[](const std::string& r, const std::string& v){ return r + v + " "; });
if (str.size()) str.pop_back();
return str;
}
static std::string ntos(const numeric& num) {
std::string val = std::to_string(num);
if (val.find('.') != std::string::npos) {
while (val.back() == '0') val.pop_back();
if (val.back() == '.') val.pop_back();
}
return val;
}
};
struct stage {
clip<feature> feats;
u32 thres;
constexpr inline operator clip<feature>&() { return feats; }
constexpr inline operator const clip<feature>&() const { return feats; }
constexpr inline operator u32() const { return thres; }
declare_comparators(const stage&, thres, constexpr inline);
declare_extern_comparators_with(const stage&, u32, lv.thres, rv, constexpr inline friend);
declare_extern_comparators_with(u32, const stage&, lv, rv.thres, constexpr inline friend);
static list<stage> parse(std::string res) { // e.g., 4 stages: 0,16384,32768,49152
res.append(res.empty() ? "0," : ",");
size_t N = std::count(res.begin(), res.end(), ',');
list<stage> multi(N + 1);
clip<feature> feats = feature::feats();
for (size_t i = 0, n = feats.size() / N, z; i < N; res.erase(0, z + 1), i++){
multi[i] = { feats.subc(n * i, n), u32(std::stoul(res, &z, 10)) };
}
multi[N].thres = 65536;
return multi;
}
};
void init_logging(utils::options::option files) {
static std::ofstream logofs;
for (std::string file : files) {
std::string path = file.substr(file.find('|') + 1);
// std::string opt = path != file ? file.substr(0, file.find('|')) : "";
char type = path[path.find_last_of(".") + 1];
if (logofs.is_open() || (type != 'x' && type != 'l')) continue; // .x and .log are suffix for log files
logofs.open(path, std::ios::out | std::ios::app);
}
if (!logofs.is_open()) return;
static moporgic::teestream tee(std::cout, logofs);
static moporgic::redirector redirect(std::cout, tee);
}