Warning, file /sdk/codevis/project_tests/bjg_wrong_cmake/groups/bjg/test/bj.m.220207.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).
0001 #include <bjgb_dealercount.h> 0002 #include <bjgb_rank.h> 0003 #include <bjgb_rules.h> 0004 #include <bjgb_shoe.h> 0005 #include <bjgb_shoeutil.h> 0006 #include <bjgb_state.h> 0007 #include <bjgb_types.h> 0008 0009 #include <bjgc_dealertable.h> 0010 #include <bjgc_dealertableutil.h> 0011 #include <bjgc_playertable.h> 0012 #include <bjgc_playertableutil.h> 0013 0014 #include <cassert> 0015 #include <iomanip> 0016 #include <iostream> 0017 0018 typedef bjgb::Types::Double Double; // shorthand 0019 0020 // Blackjack 2021: John Lakos 0021 const int k_RICHNESS = +0; 0022 // 0023 // This is a program that calculates blackjack odds for any given hand 0024 // combination of dealer and player based on a set of parameterized rules 0025 // and a specific initial state of the shoe. 0026 // 0027 // Question 1: what's the expected value of hitting a 16 versus standing? 0028 // 0029 // UNADJUSTED (dealer must stand on soft 17): 0030 // Stand: A 2 3 4 5 6 7 8 9 T 0031 // 16: -76.94 -29.28 -25.23 -21.11 -16.72 -15.37 -47.54 -51.05 -54.31 -57.58 0032 // Hit: 0033 // 16: -66.57 -47.1 -46.38 -45.63 -44.95 -43.09 -41.48 -45.84 -50.93 -57.52 0034 // ADJUSTED (dealer must stand on soft 17): 0035 // Stand: A 2 3 4 5 6 7 8 9 T 0036 // 16: -66.7 -29.28 -25.23 -21.11 -16.72 -15.37 -47.54 -51.05 -54.31 -54.04 0037 // Hit: 0038 // 16: -51.71 -47.1 -46.38 -45.63 -44.95 -43.09 -41.48 -45.84 -50.93 -53.98 0039 // 0040 // UNADJUSTED (dealer must hit on soft 17): 0041 // Stand: A 2 3 4 5 6 7 8 9 T 0042 // 16: -72.22 -28.65 -24.66 -20.58 -16.47 -12.11 -47.54 -51.05 -54.31 -57.58 0043 // Hit: 0044 // 16: -68.3 -47.33 -46.58 -45.82 -45.04 -44.29 -41.48 -45.84 -50.93 -57.52 0045 // ADJUSTED (dealer must hit on soft 17): 0046 // Stand: A 2 3 4 5 6 7 8 9 T 0047 // 16: -59.87 -28.65 -24.66 -20.58 -16.47 -12.11 -47.54 -51.05 -54.31 -54.04 0048 // Hit: 0049 // 16: -54.21 -47.33 -46.58 -45.82 -45.04 -44.29 -41.48 -45.84 -50.93 -53.98 0050 // 0051 // Look at only the top row for Surrender and only the bottom two rows for hit 0052 // v. split, double, etc. Note that either pair of rows could be used to 0053 // evaluate 'hit' versus 'stand' as no additional money/odds are involved, and 0054 // the comparative values are either scaled or not by the same !BJ prob. 0055 // 0056 // Question 2: what's the expected value of hitting a 12 versus standing? 0057 // 0058 // UNADJUSTED (dealer must stand on soft 17): 0059 // Stand: A 2 3 4 5 6 7 8 9 T 0060 // 12: -76.94 -29.28 -25.23 -21.11 -16.72 -15.37 -47.54 -51.05 -54.31 -57.58 0061 // Hit: 0062 // 12: -59.48 -25.34 -23.37 -21.35 -19.33 -17.05 -25.34 -30.78 -36.88 -44.47 0063 // ADJUSTED (dealer must stand on soft 17): 0064 // Stand: A 2 3 4 5 6 7 8 9 T 0065 // 12: -66.7 -29.28 -25.23 -21.11 -16.72 -15.37 -47.54 -51.05 -54.31 -54.04 0066 // Hit: 0067 // 12: -41.47 -25.34 -23.37 -21.35 -19.33 -17.05 -25.34 -30.78 -36.88 -39.84 0068 // 0069 // UNADJUSTED (dealer must hit on soft 17): 0070 // Stand: A 2 3 4 5 6 7 8 9 T 0071 // 12: -72.22 -28.65 -24.66 -20.58 -16.47 -12.11 -47.54 -51.05 -54.31 -57.58 0072 // Hit: 0073 // 12: -59.75 -25.38 -23.4 -21.38 -19.34 -17.24 -25.34 -30.78 -36.88 -44.47 0074 // ADJUSTED (dealer must hit on soft 17): 0075 // Stand: A 2 3 4 5 6 7 8 9 T 0076 // 12: -59.87 -28.65 -24.66 -20.58 -16.47 -12.11 -47.54 -51.05 -54.31 -54.04 0077 // Hit: 0078 // 12: -41.86 -25.38 -23.4 -21.38 -19.34 -17.24 -25.34 -30.78 -36.88 -39.84 0079 // 0080 // Question 3: what's the expected value of hitting a 13 versus standing? 0081 // 0082 // UNADJUSTED (dealer must stand on soft 17): 0083 // Stand: A 2 3 4 5 6 7 8 9 T 0084 // 13: -76.94 -29.28 -25.23 -21.11 -16.72 -15.37 -47.54 -51.05 -54.31 -57.58 0085 // Hit: 0086 // 13: -61.25 -30.78 -29.12 -27.42 -25.73 -23.56 -29.37 -34.55 -40.39 -47.73 0087 // ADJUSTED (dealer must stand on soft 17): 0088 // Stand: A 2 3 4 5 6 7 8 9 T 0089 // 13: -66.7 -29.28 -25.23 -21.11 -16.72 -15.37 -47.54 -51.05 -54.31 -54.04 0090 // Hit: 0091 // 13: -44.03 -30.78 -29.12 -27.42 -25.73 -23.56 -29.37 -34.55 -40.39 -43.38 0092 // 0093 // UNADJUSTED (dealer must hit on soft 17): 0094 // Stand: A 2 3 4 5 6 7 8 9 T 0095 // 13: -72.22 -28.65 -24.66 -20.58 -16.47 -12.11 -47.54 -51.05 -54.31 -57.58 0096 // Hit: 0097 // 13: -61.89 -30.86 -29.2 -27.49 -25.77 -24 -29.37 -34.55 -40.39 -47.73 0098 // ADJUSTED (dealer must hit on soft 17): 0099 // Stand: A 2 3 4 5 6 7 8 9 T 0100 // 13: -59.87 -28.65 -24.66 -20.58 -16.47 -12.11 -47.54 -51.05 -54.31 -54.04 0101 // Hit: 0102 // 13: -44.95 -30.86 -29.2 -27.49 -25.77 -24 -29.37 -34.55 -40.39 -43.38 0103 // 0104 // ----------------------------------------------------------- 0105 // DEALER ODDS: https://www.blackjackonline.com/strategy/odds/ 1 deck? 0106 // ----------------------------------------------------------- 0107 // Dealer's odds of winding up with various hands. (Dealer Stands on S17) 0108 // 0109 // Internet Calculation Simulation 0110 // OV - 28.36% 0.281593 (5+ digits) 0111 // BJ – 4.82% 0.0473373 " 0112 // 21 – 7.36% 0.0727307 " 0113 // 20 – 17.58% 0.180252 " 0114 // 19 – 13.48% 0.133464 " 0115 // 18 – 13.81% 0.139497 " 0116 // 17 – 14.58% 0.145126 " 0117 // 0118 // S ZR: 0.145126 0.139497 0.133464 0.180252 0.0727307 0.0473373 0.281593 0119 // H ZR: 0.13326 0.141507 0.135474 0.182262 0.0747406 0.0473373 0.285419 0120 // ---------------------------------------------------------------- 0121 // Dealers Odds: hands = 100000000000, HIT_S17 = 0, 1, rseed = 10 - 39 0122 // 0.133261% 0.141507% 0.135475% 0.182261% 0.0747397% 0.0473367% 0.28542% 0123 // 17 18 19 20 21 BJ OVER 0124 //__________ __________ __________ __________ __________ __________ __________ 0125 // 0.145124% 0.1395 % 0.133462% 0.180253% 0.0727316% 0.0473368% 0.281592% 0126 // 0.145127% 0.139497% 0.133465% 0.180252% 0.0727302% 0.047337 % 0.281592% 0127 // 0.145126% 0.139497% 0.133465% 0.180252% 0.0727297% 0.047338 % 0.281592% 0128 // 0.145125% 0.139499% 0.133464% 0.180252% 0.0727293% 0.047337 % 0.281593% 0129 // 0.145125% 0.139498% 0.133467% 0.180254% 0.072729 % 0.0473367% 0.281592% 0130 // 0.145127% 0.139498% 0.133463% 0.180253% 0.0727303% 0.0473383% 0.28159 % 0131 // 0.145126% 0.139496% 0.133466% 0.180252% 0.0727303% 0.0473379% 0.281592% 0132 // 0.145127% 0.139498% 0.133463% 0.180254% 0.0727302% 0.0473372% 0.28159 % 0133 // 0.145124% 0.139496% 0.133465% 0.180253% 0.0727302% 0.0473373% 0.281594% 0134 // 0.145125% 0.139496% 0.133463% 0.180254% 0.0727298% 0.0473358% 0.281596% 0135 // 0136 // 0.133259% 0.141507% 0.135475% 0.182263% 0.074741 % 0.0473361% 0.285419% 0137 // 0.133263% 0.141508% 0.135474% 0.182259% 0.0747405% 0.0473364% 0.28542 % 0138 // 0.133259% 0.141508% 0.135474% 0.18226 % 0.0747414% 0.0473379% 0.285419% 0139 // 0.13326 % 0.141506% 0.135473% 0.182263% 0.0747399% 0.0473369% 0.285421% 0140 // 0.13326 % 0.141507% 0.135475% 0.182262% 0.0747407% 0.0473384% 0.285417% 0141 // 0.133262% 0.141508% 0.135472% 0.182264% 0.0747403% 0.0473369% 0.285417% 0142 // 0.133259% 0.141508% 0.135476% 0.182262% 0.0747413% 0.0473368% 0.285417% 0143 // 0.13326 % 0.141507% 0.135472% 0.182263% 0.0747413% 0.0473362% 0.28542 % 0144 // 0.133262% 0.141504% 0.135475% 0.182262% 0.0747401% 0.0473384% 0.285418% 0145 // 0146 // ---------------------------------------------------------------- 0147 // 0148 // Dealer vs. Player Odds 0149 // 0150 // Odds of the dealer busting based on their up card: 0151 // 0152 // Internet Calculation Simulation 0153 // 2 – 35.30% 0.353608 0154 // 3 – 37.56% 0.373875 0155 // 4 – 40.28% 0.394468 0156 // 5 – 42.89% 0.416404 0157 // 6 – 42.08% 0.42315 0158 // 7 – 25.99% 0.262312 0159 // 8 – 23.86% 0.244741 0160 // 9 – 23.34% 0.228425 0161 // T – 21.43% 0.212109 0162 // A – 11.65% 0.115286 0163 // 0164 // T: 0.111424 0.111424 0.111424 0.342194 0.0345013 0.0769231 0.212109 0165 // 9: 0.119995 0.119995 0.350765 0.119995 0.0608238 0 0.228425 0166 // 8: 0.128567 0.359336 0.128567 0.0693949 0.0693949 0 0.244741 0167 // 7: 0.368566 0.137797 0.0786254 0.0786254 0.0740737 0 0.262312 0168 // 6: 0.165438 0.106267 0.106267 0.101715 0.0971633 0 0.42315 0169 // 5: 0.122251 0.122251 0.1177 0.113148 0.108246 0 0.416404 0170 // 4: 0.13049 0.125938 0.121386 0.116485 0.111233 0 0.394468 0171 // 3: 0.135034 0.130482 0.125581 0.120329 0.1147 0 0.373875 0172 // 2: 0.139809 0.134907 0.129655 0.124026 0.117993 0 0.353608 0173 // 1: 0.130789 0.130789 0.130789 0.130789 0.0538658 0.307692 0.115286 0174 0175 // --------------------------------------------------------------- 0176 // Array size/mapping for all possible hands 0177 0178 // With zero cards there are 1 hands: 0 0179 // " one " " " 10 hands: S1, 2-9, TN 0180 // " two " " " 27 " S2-S10, 4-20, BJ 0181 // " three+ " " " 30 " S1-S11, 4-21, OVER 0182 // A dealer can have any of 35 " S1-S11, TN, 2-21, BJ, OVER 0183 // Before any cards are drawn 36 " S1-S11, TN, 2-21, BJ, OVER, 0 0184 // Dealer can stand on only 7 values: c17-c21, cBJ, cOVER 0185 0186 // A player: a 4 or two 2s so we need AA, 22, 44, 66, 88, and TT as hands 0187 0188 // probability table: 0189 // 0 1 2 3 4 5 6 0190 // c17 c18 c19 c20 c21 cbj cov 0191 // 53 pair(10) --> 53 0192 // 52 pair( 9) 0193 // 51 pair( 8) 0194 // 50 pair( 7) 0195 // 49 pair( 6) 0196 // 48 pair( 5) 0197 // 47 pair( 4) 0198 // 46 pair( 3) 0199 // 45 pair( 2) 0200 // 44 pair( 1) --> 44 0201 // --------- 0202 // 43 e_HOV --> 43 0203 // 42 hard(21) --> 42 0204 // 41 hard(20) 0205 // 40 hard(19) 0206 // 39 hard(18) 0207 // 38 hard(17) 0208 // 37 hard(16) 0209 // 36 hard(15) 0210 // 35 hard(14) 0211 // 34 hard(13) 0212 // 33 hard(12) 0213 // 32 hard(11) 0214 // 31 hard(10) 0215 // 30 hard( 9) 0216 // 29 hard( 8) 0217 // 28 hard( 7) 0218 // 27 hard( 6) 0219 // 26 hard( 5) 0220 // 25 hard( 4) 0221 // 24 hard( 3) 0222 // 23 hard( 2) --> 23 0223 // -------- 0224 // 22 unus(10) --> 22 [also 'e_H_T'] 0225 // 21 unus( 9) 0226 // 20 unus( 8) 0227 // 19 unus( 7) 0228 // 18 unus( 6) 0229 // 17 unus( 5) 0230 // 16 unus( 4) 0231 // 15 unus( 3) 0232 // 14 unus( 2) 0233 // 13 unus(1) --> 13 0234 // 12 e_HZR --> 12 0235 // -------- 0236 // 11 e_SBJ --> 11 0237 // 10 soft(11) --> 10 0238 // 9 soft(10) 0239 // 8 soft( 9) 0240 // 7 soft( 8) 0241 // 6 soft( 7) 0242 // 5 soft( 6) 0243 // 4 soft( 5) 0244 // 3 soft( 4) 0245 // 2 soft( 3) 0246 // 1 soft( 2) 0247 // 0 soft( 1) --> 0 0248 0249 //=========================================================================== 0250 // For all strategy, unless a player can lose double on a blackjack, we need 0251 // to divide the A and 10 card rows by the probability of not getting 0252 // a blackjack: 1 / [ 1 - P(BJ) ]. In particular, when using the dealer's 0253 // table to calculate the stand values that will be supplied to the 1-hit 0254 // or player's strategy, the probability of getting a BJ has to be zeroed 0255 // for a single TEN or ACE, and all other probabilities in that row 0256 // (including OV) scaled accordingly. 0257 // 0258 // TBD: I need to review this issue to make triply sure of what I am saying. 0259 //=========================================================================== 0260 0261 void test1() 0262 { 0263 std::cout << "test1\n\n"; 0264 assert(0 == bjgb::State::soft(1)); 0265 assert(10 == bjgb::State::soft(11)); 0266 assert(11 == bjgb::State::e_SBJ); 0267 assert(12 == bjgb::State::e_HZR); 0268 assert(22 == bjgb::State::e_H_T); 0269 assert(23 == bjgb::State::hard(2)); 0270 assert(24 == bjgb::State::hard(3)); 0271 assert(25 == bjgb::State::hard(4)); 0272 0273 assert(41 == bjgb::State::hard(20)); 0274 assert(42 == bjgb::State::hard(21)); 0275 assert(43 == bjgb::State::e_HOV); 0276 0277 assert(13 == bjgb::State::unus(1)); 0278 assert(14 == bjgb::State::unus(2)); 0279 assert(22 == bjgb::State::unus(10)); 0280 0281 assert(44 == bjgb::State::pair(1)); 0282 assert(53 == bjgb::State::pair(10)); 0283 } 0284 0285 void test2() 0286 { 0287 std::cout << "test2\n\n"; 0288 0289 bjgb::Shoe d; 0290 assert(bjgb::ShoeUtil::isUnused(d)); 0291 assert(0 == bjgb::ShoeUtil::tenRichness(d)); 0292 std::cout << d << '\n'; 0293 0294 bjgb::Shoe shoe2(2); 0295 assert(bjgb::ShoeUtil::isUnused(shoe2)); 0296 assert(0 == bjgb::ShoeUtil::tenRichness(shoe2)); 0297 std::cout << shoe2 << '\n'; 0298 0299 using namespace bjgb::RankLiterals; 0300 0301 shoe2.setNumCardsOfRank(1_R, 9); 0302 assert(!bjgb::ShoeUtil::isUnused(shoe2)); 0303 assert(0 > bjgb::ShoeUtil::tenRichness(shoe2)); 0304 std::cout << shoe2 << '\n'; 0305 0306 shoe2.setNumCardsOfRank(2_R, 7); 0307 assert(!bjgb::ShoeUtil::isUnused(shoe2)); 0308 assert(0 == bjgb::ShoeUtil::tenRichness(shoe2)); 0309 std::cout << shoe2 << '\n'; 0310 0311 shoe2.setNumCardsOfRank(3_R, 7); 0312 assert(!bjgb::ShoeUtil::isUnused(shoe2)); 0313 assert(0 < bjgb::ShoeUtil::tenRichness(shoe2)); 0314 std::cout << shoe2 << '\n'; 0315 0316 std::cout << "d.p( 5) = " << d.prob(5) << '\n'; 0317 std::cout << "d.p( 6) = " << d.prob(6) << '\n'; 0318 std::cout << "d.p( 7) = " << d.prob(7) << '\n'; 0319 std::cout << "d.p( 8) = " << d.prob(8) << '\n'; 0320 std::cout << "d.p( 9) = " << d.prob(9) << '\n'; 0321 std::cout << "d.p(10) = " << d.prob(10) << '\n'; 0322 std::cout << "d.p( 1) = " << d.prob(1) << '\n'; 0323 std::cout << "d.p( 2) = " << d.prob(2) << '\n'; 0324 std::cout << "d.p( 3) = " << d.prob(3) << '\n'; 0325 std::cout << "d.p( 4) = " << d.prob(4) << '\n'; 0326 0327 bjgb::Shoe dm2; 0328 bjgb::ShoeUtil::setTenRichness(&dm2, -2); 0329 bjgb::Shoe dm1; 0330 bjgb::ShoeUtil::setTenRichness(&dm1, -1); 0331 bjgb::Shoe dp0; 0332 bjgb::ShoeUtil::setTenRichness(&dp0, +0); 0333 bjgb::Shoe dp1; 0334 bjgb::ShoeUtil::setTenRichness(&dp1, +1); 0335 bjgb::Shoe dp2; 0336 bjgb::ShoeUtil::setTenRichness(&dp2, +2); 0337 0338 std::cout << "Richness at -2: " << bjgb::ShoeUtil::tenRichness(dm2) << '\n' << dm2 << '\n'; 0339 std::cout << "Richness at -1: " << bjgb::ShoeUtil::tenRichness(dm1) << '\n' << dm1 << '\n'; 0340 std::cout << "Richness at +0: " << bjgb::ShoeUtil::tenRichness(dp0) << '\n' << dp0 << '\n'; 0341 std::cout << "Richness at +1: " << bjgb::ShoeUtil::tenRichness(dp1) << '\n' << dp1 << '\n'; 0342 std::cout << "Richness at +2: " << bjgb::ShoeUtil::tenRichness(dp2) << '\n' << dp2 << '\n'; 0343 0344 assert(!bjgb::ShoeUtil::isUnused(dm2)); 0345 assert(-2 == bjgb::ShoeUtil::tenRichness(dm2)); 0346 0347 assert(!bjgb::ShoeUtil::isUnused(dm1)); 0348 assert(-1 == bjgb::ShoeUtil::tenRichness(dm1)); 0349 0350 assert(!bjgb::ShoeUtil::isUnused(dp0)); 0351 assert(0 == bjgb::ShoeUtil::tenRichness(dp0)); 0352 0353 assert(!bjgb::ShoeUtil::isUnused(dp1)); 0354 assert(1 == bjgb::ShoeUtil::tenRichness(dp1)); 0355 0356 assert(!bjgb::ShoeUtil::isUnused(dp2)); 0357 assert(2 == bjgb::ShoeUtil::tenRichness(dp2)); 0358 0359 bjgb::Rules rules; 0360 } 0361 0362 void test3() 0363 { 0364 std::cout << "test3\n\n"; 0365 0366 bjgb::Rules rules; 0367 } 0368 0369 int main(void) 0370 { 0371 std::cout << "Hello Black Jack February 2022\n\n"; 0372 test1(); 0373 test2(); 0374 test3(); 0375 std::cout << "(testing done)\n\n"; 0376 0377 bjgb::Shoe d(8); 0378 0379 // ================ 0380 // shoe 10-richness 0381 // ================ 0382 0383 std::cout << "SETTING DECK RICHNESS TO " << k_RICHNESS << std::endl; 0384 0385 std::cout << d << '\n'; 0386 0387 bjgb::ShoeUtil::setTenRichness(&d, k_RICHNESS); 0388 0389 std::cout << d << '\n'; 0390 0391 bjgb::Rules rules; 0392 std::cout << rules << '\n'; 0393 0394 bjgc::DealerTable dtab; 0395 dtab.reset(); 0396 0397 // std::cout << dtab << '\n'; 0398 bjgc::DealerTableUtil::populate(&dtab, d, rules.dealerStandsOnSoft17()); 0399 0400 std::cout << "===============================================\n"; 0401 std::cout << "=============== UNadjusted dtab ===============\n"; 0402 std::cout << "===============================================\n"; 0403 std::cout << dtab << '\n'; 0404 0405 // check soft 17 values. 0406 0407 if (rules.dealerStandsOnSoft17()) { 0408 std::cout << "must stand on all 17" << '\n'; 0409 0410 assert(1.0 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(17))); 0411 assert(0.0 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(18))); 0412 assert(0.0 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(19))); 0413 assert(0.0 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(20))); 0414 assert(0.0 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(21))); 0415 } else { 0416 std::cout << "must hit on soft 17" << '\n'; 0417 const Double s7c17 = d.prob(5) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(17)) 0418 + d.prob(6) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(17)) 0419 + d.prob(7) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(17)) 0420 + d.prob(8) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(17)) 0421 + d.prob(9) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(17)) 0422 + d.prob(10) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(17)); 0423 0424 std::cout << s7c17 << " == " << dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(17)) << '\n'; 0425 assert(s7c17 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(17))); 0426 0427 const Double s7c18 = d.prob(5) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(18)) 0428 + d.prob(6) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(18)) 0429 + d.prob(7) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(18)) 0430 + d.prob(8) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(18)) 0431 + d.prob(9) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(18)) 0432 + d.prob(10) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(18)) 0433 + d.prob(1) * dtab.prob(bjgb::State::soft(8), bjgb::DealerCount::fini(18)); 0434 0435 std::cout << s7c18 << " == " << dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(18)) << '\n'; 0436 assert(s7c18 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(18))); 0437 0438 const Double s7c19 = d.prob(5) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(19)) 0439 + d.prob(6) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(19)) 0440 + d.prob(7) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(19)) 0441 + d.prob(8) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(19)) 0442 + d.prob(9) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(19)) 0443 + d.prob(10) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(19)) 0444 + d.prob(2) * dtab.prob(bjgb::State::soft(9), bjgb::DealerCount::fini(19)); 0445 0446 std::cout << s7c19 << " == " << dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(19)) << '\n'; 0447 assert(s7c19 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(19))); 0448 0449 const Double s7c20 = d.prob(5) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(20)) 0450 + d.prob(6) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(20)) 0451 + d.prob(7) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(20)) 0452 + d.prob(8) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(20)) 0453 + d.prob(9) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(20)) 0454 + d.prob(10) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(20)) 0455 + d.prob(3) * dtab.prob(bjgb::State::soft(10), bjgb::DealerCount::fini(20)); 0456 0457 std::cout << s7c20 << " == " << dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(20)) << '\n'; 0458 assert(s7c20 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(20))); 0459 0460 const Double s7c21 = d.prob(5) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(21)) 0461 + d.prob(6) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(21)) 0462 + d.prob(7) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(21)) 0463 + d.prob(8) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(21)) 0464 + d.prob(9) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(21)) 0465 + d.prob(10) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(21)) 0466 + d.prob(4) * dtab.prob(bjgb::State::soft(11), bjgb::DealerCount::fini(21)); 0467 0468 std::cout << s7c21 << " == " << dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(21)) << '\n'; 0469 assert(s7c21 == dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(21))); 0470 } 0471 0472 std::cout << "s6c17" << '\n'; 0473 0474 const Double s6c17 = d.prob(6) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(17)) 0475 + d.prob(7) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(17)) 0476 + d.prob(8) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(17)) 0477 + d.prob(9) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(17)) 0478 + d.prob(10) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(17)) 0479 + d.prob(1) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(17)) 0480 + d.prob(2) * dtab.prob(bjgb::State::soft(8), bjgb::DealerCount::fini(17)); 0481 0482 std::cout << s6c17 << " == " << dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(17)) << '\n'; 0483 assert(s6c17 == dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(17))); 0484 0485 const Double s6c18 = d.prob(6) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(18)) 0486 + d.prob(7) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(18)) 0487 + d.prob(8) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(18)) 0488 + d.prob(9) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(18)) 0489 + d.prob(10) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(18)) 0490 + d.prob(1) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(18)) 0491 + d.prob(2) * dtab.prob(bjgb::State::soft(8), bjgb::DealerCount::fini(18)); 0492 0493 std::cout << s6c18 << " == " << dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(18)) << '\n'; 0494 assert(s6c18 == dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(18))); 0495 0496 const Double s6c21 = d.prob(6) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(21)) 0497 + d.prob(7) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(21)) 0498 + d.prob(8) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(21)) 0499 + d.prob(9) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(21)) 0500 + d.prob(10) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(21)) 0501 + d.prob(1) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(21)) 0502 + d.prob(4) * dtab.prob(bjgb::State::soft(11), bjgb::DealerCount::fini(21)); 0503 0504 std::cout << s6c21 << " == " << dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(21)) << '\n'; 0505 assert(s6c21 == dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(21))); 0506 0507 std::cout << "s2c17" << '\n'; 0508 const Double s2c17 = d.prob(10) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(17)) 0509 + d.prob(1) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(17)) 0510 + d.prob(2) * dtab.prob(bjgb::State::soft(4), bjgb::DealerCount::fini(17)) 0511 + d.prob(3) * dtab.prob(bjgb::State::soft(5), bjgb::DealerCount::fini(17)) 0512 + d.prob(4) * dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(17)) 0513 + d.prob(5) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(17)); 0514 0515 std::cout << s2c17 << " == " << dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(17)) << '\n'; 0516 assert(s2c17 == dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(17))); 0517 0518 const Double s2c18 = d.prob(10) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(18)) 0519 + d.prob(1) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(18)) 0520 + d.prob(2) * dtab.prob(bjgb::State::soft(4), bjgb::DealerCount::fini(18)) 0521 + d.prob(3) * dtab.prob(bjgb::State::soft(5), bjgb::DealerCount::fini(18)) 0522 + d.prob(4) * dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(18)) 0523 + d.prob(5) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(18)) 0524 + d.prob(6) * dtab.prob(bjgb::State::soft(8), bjgb::DealerCount::fini(18)); 0525 0526 std::cout << s2c18 << " == " << dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(18)) << '\n'; 0527 assert(s2c18 == dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(18))); 0528 0529 const Double s2c21 = d.prob(10) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(21)) 0530 + d.prob(1) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(21)) 0531 + d.prob(2) * dtab.prob(bjgb::State::soft(4), bjgb::DealerCount::fini(21)) 0532 + d.prob(3) * dtab.prob(bjgb::State::soft(5), bjgb::DealerCount::fini(21)) 0533 + d.prob(4) * dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(21)) 0534 + d.prob(5) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(21)) 0535 + d.prob(9) * dtab.prob(bjgb::State::soft(11), bjgb::DealerCount::fini(21)); 0536 0537 std::cout << s2c21 << " == " << dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(21)) << '\n'; 0538 assert(s2c21 == dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(21))); 0539 0540 // starting with an Ace: 0541 0542 std::cout << "s1c17" << '\n'; 0543 const Double s1c17 = d.prob(1) * dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(17)) 0544 + d.prob(2) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(17)) 0545 + d.prob(3) * dtab.prob(bjgb::State::soft(4), bjgb::DealerCount::fini(17)) 0546 + d.prob(4) * dtab.prob(bjgb::State::soft(5), bjgb::DealerCount::fini(17)) 0547 + d.prob(5) * dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(17)) 0548 + d.prob(6) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(17)); 0549 0550 std::cout << s1c17 << " == " << dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(17)) << '\n'; 0551 assert(s1c17 == dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(17))); 0552 0553 const Double s1c18 = d.prob(1) * dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(18)) 0554 + d.prob(2) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(18)) 0555 + d.prob(3) * dtab.prob(bjgb::State::soft(4), bjgb::DealerCount::fini(18)) 0556 + d.prob(4) * dtab.prob(bjgb::State::soft(5), bjgb::DealerCount::fini(18)) 0557 + d.prob(5) * dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(18)) 0558 + d.prob(6) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(18)) 0559 + d.prob(7) * dtab.prob(bjgb::State::soft(8), bjgb::DealerCount::fini(18)); 0560 0561 std::cout << s1c18 << " == " << dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(18)) << '\n'; 0562 assert(s1c18 == dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(18))); 0563 0564 const Double s1c19 = d.prob(1) * dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(19)) 0565 + d.prob(2) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(19)) 0566 + d.prob(3) * dtab.prob(bjgb::State::soft(4), bjgb::DealerCount::fini(19)) 0567 + d.prob(4) * dtab.prob(bjgb::State::soft(5), bjgb::DealerCount::fini(19)) 0568 + d.prob(5) * dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(19)) 0569 + d.prob(6) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(19)) 0570 + d.prob(8) * dtab.prob(bjgb::State::soft(9), bjgb::DealerCount::fini(19)); 0571 0572 std::cout << s1c19 << " == " << dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(19)) << '\n'; 0573 assert(s1c19 == dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(19))); 0574 0575 const Double s1c20 = d.prob(1) * dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(20)) 0576 + d.prob(2) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(20)) 0577 + d.prob(3) * dtab.prob(bjgb::State::soft(4), bjgb::DealerCount::fini(20)) 0578 + d.prob(4) * dtab.prob(bjgb::State::soft(5), bjgb::DealerCount::fini(20)) 0579 + d.prob(5) * dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(20)) 0580 + d.prob(6) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(20)) 0581 + d.prob(9) * dtab.prob(bjgb::State::soft(10), bjgb::DealerCount::fini(20)); 0582 0583 std::cout << s1c20 << " == " << dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(20)) << '\n'; 0584 assert(s1c20 == dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(20))); 0585 0586 const Double s1c21 = d.prob(1) * dtab.prob(bjgb::State::soft(2), bjgb::DealerCount::fini(21)) 0587 + d.prob(2) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(21)) 0588 + d.prob(3) * dtab.prob(bjgb::State::soft(4), bjgb::DealerCount::fini(21)) 0589 + d.prob(4) * dtab.prob(bjgb::State::soft(5), bjgb::DealerCount::fini(21)) 0590 + d.prob(5) * dtab.prob(bjgb::State::soft(6), bjgb::DealerCount::fini(21)) 0591 + d.prob(6) * dtab.prob(bjgb::State::soft(7), bjgb::DealerCount::fini(21)) 0592 + d.prob(10) * dtab.prob(bjgb::State::e_SBJ, bjgb::DealerCount::fini(21)); 0593 0594 std::cout << s1c21 << " == " << dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(21)) << '\n'; 0595 assert(s1c21 == dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(21))); 0596 0597 const Double s1cbj = d.prob(10) * dtab.prob(bjgb::State::e_SBJ, bjgb::DealerCount::e_CBJ); 0598 0599 std::cout << s1cbj << " == " << dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::e_CBJ) << '\n'; 0600 assert(s1cbj == dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::e_CBJ)); 0601 0602 // ======================== 0603 // Now deal with 10-2, T, 0 0604 // ======================== 0605 0606 std::cout << "h10c17" << '\n'; 0607 const Double h10c17 = d.prob(1) * dtab.prob(bjgb::State::soft(11), bjgb::DealerCount::fini(17)) 0608 + d.prob(2) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(17)) 0609 + d.prob(3) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(17)) 0610 + d.prob(4) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(17)) 0611 + d.prob(5) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(17)) 0612 + d.prob(6) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(17)) 0613 + d.prob(7) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(17)) 0614 + d.prob(8) * dtab.prob(bjgb::State::hard(18), bjgb::DealerCount::fini(17)) 0615 + d.prob(9) * dtab.prob(bjgb::State::hard(19), bjgb::DealerCount::fini(17)) 0616 + d.prob(10) * dtab.prob(bjgb::State::hard(20), bjgb::DealerCount::fini(17)); 0617 0618 std::cout << h10c17 << " == " << dtab.prob(bjgb::State::hard(10), bjgb::DealerCount::fini(17)) << '\n'; 0619 assert(h10c17 == dtab.prob(bjgb::State::hard(10), bjgb::DealerCount::fini(17))); 0620 0621 std::cout << "h10c21" << '\n'; 0622 const Double h10c21 = d.prob(1) * dtab.prob(bjgb::State::soft(11), bjgb::DealerCount::fini(21)) 0623 + d.prob(2) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(21)) 0624 + d.prob(3) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(21)) 0625 + d.prob(4) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(21)) 0626 + d.prob(5) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(21)) 0627 + d.prob(6) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(21)) 0628 + d.prob(7) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(21)) 0629 + d.prob(8) * dtab.prob(bjgb::State::hard(18), bjgb::DealerCount::fini(21)) 0630 + d.prob(9) * dtab.prob(bjgb::State::hard(19), bjgb::DealerCount::fini(21)) 0631 + d.prob(10) * dtab.prob(bjgb::State::hard(20), bjgb::DealerCount::fini(21)); 0632 0633 std::cout << h10c21 << " == " << dtab.prob(bjgb::State::hard(10), bjgb::DealerCount::fini(21)) << '\n'; 0634 assert(h10c21 == dtab.prob(bjgb::State::hard(10), bjgb::DealerCount::fini(21))); 0635 0636 std::cout << "h2c17" << '\n'; 0637 const Double h2c17 = d.prob(1) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(17)) 0638 + d.prob(2) * dtab.prob(bjgb::State::hard(4), bjgb::DealerCount::fini(17)) 0639 + d.prob(3) * dtab.prob(bjgb::State::hard(5), bjgb::DealerCount::fini(17)) 0640 + d.prob(4) * dtab.prob(bjgb::State::hard(6), bjgb::DealerCount::fini(17)) 0641 + d.prob(5) * dtab.prob(bjgb::State::hard(7), bjgb::DealerCount::fini(17)) 0642 + d.prob(6) * dtab.prob(bjgb::State::hard(8), bjgb::DealerCount::fini(17)) 0643 + d.prob(7) * dtab.prob(bjgb::State::hard(9), bjgb::DealerCount::fini(17)) 0644 + d.prob(8) * dtab.prob(bjgb::State::hard(10), bjgb::DealerCount::fini(17)) 0645 + d.prob(9) * dtab.prob(bjgb::State::hard(11), bjgb::DealerCount::fini(17)) 0646 + d.prob(10) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(17)); 0647 0648 std::cout << h2c17 << " == " << dtab.prob(bjgb::State::hard(2), bjgb::DealerCount::fini(17)) << '\n'; 0649 assert(h2c17 == dtab.prob(bjgb::State::hard(2), bjgb::DealerCount::fini(17))); 0650 0651 std::cout << "h2c21" << '\n'; 0652 const Double h2c21 = d.prob(1) * dtab.prob(bjgb::State::soft(3), bjgb::DealerCount::fini(21)) 0653 + d.prob(2) * dtab.prob(bjgb::State::hard(4), bjgb::DealerCount::fini(21)) 0654 + d.prob(3) * dtab.prob(bjgb::State::hard(5), bjgb::DealerCount::fini(21)) 0655 + d.prob(4) * dtab.prob(bjgb::State::hard(6), bjgb::DealerCount::fini(21)) 0656 + d.prob(5) * dtab.prob(bjgb::State::hard(7), bjgb::DealerCount::fini(21)) 0657 + d.prob(6) * dtab.prob(bjgb::State::hard(8), bjgb::DealerCount::fini(21)) 0658 + d.prob(7) * dtab.prob(bjgb::State::hard(9), bjgb::DealerCount::fini(21)) 0659 + d.prob(8) * dtab.prob(bjgb::State::hard(10), bjgb::DealerCount::fini(21)) 0660 + d.prob(9) * dtab.prob(bjgb::State::hard(11), bjgb::DealerCount::fini(21)) 0661 + d.prob(10) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(21)); 0662 0663 std::cout << h2c21 << " == " << dtab.prob(bjgb::State::hard(2), bjgb::DealerCount::fini(21)) << '\n'; 0664 assert(h2c21 == dtab.prob(bjgb::State::hard(2), bjgb::DealerCount::fini(21))); 0665 0666 // TEN 0667 0668 std::cout << "htnc17" << '\n'; 0669 const Double htnc17 = d.prob(1) * dtab.prob(bjgb::State::e_SBJ, bjgb::DealerCount::fini(17)) 0670 + d.prob(2) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(17)) 0671 + d.prob(3) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(17)) 0672 + d.prob(4) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(17)) 0673 + d.prob(5) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(17)) 0674 + d.prob(6) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(17)) 0675 + d.prob(7) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(17)) 0676 + d.prob(8) * dtab.prob(bjgb::State::hard(18), bjgb::DealerCount::fini(17)) 0677 + d.prob(9) * dtab.prob(bjgb::State::hard(19), bjgb::DealerCount::fini(17)) 0678 + d.prob(10) * dtab.prob(bjgb::State::hard(20), bjgb::DealerCount::fini(17)); 0679 0680 std::cout << htnc17 << " == " << dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::fini(17)) << '\n'; 0681 assert(htnc17 == dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::fini(17))); 0682 0683 std::cout << "htnc21" << '\n'; 0684 const Double htnc21 = d.prob(1) * dtab.prob(bjgb::State::e_SBJ, bjgb::DealerCount::fini(21)) 0685 + d.prob(2) * dtab.prob(bjgb::State::hard(12), bjgb::DealerCount::fini(21)) 0686 + d.prob(3) * dtab.prob(bjgb::State::hard(13), bjgb::DealerCount::fini(21)) 0687 + d.prob(4) * dtab.prob(bjgb::State::hard(14), bjgb::DealerCount::fini(21)) 0688 + d.prob(5) * dtab.prob(bjgb::State::hard(15), bjgb::DealerCount::fini(21)) 0689 + d.prob(6) * dtab.prob(bjgb::State::hard(16), bjgb::DealerCount::fini(21)) 0690 + d.prob(7) * dtab.prob(bjgb::State::hard(17), bjgb::DealerCount::fini(21)) 0691 + d.prob(8) * dtab.prob(bjgb::State::hard(18), bjgb::DealerCount::fini(21)) 0692 + d.prob(9) * dtab.prob(bjgb::State::hard(19), bjgb::DealerCount::fini(21)) 0693 + d.prob(10) * dtab.prob(bjgb::State::hard(20), bjgb::DealerCount::fini(21)); 0694 0695 std::cout << htnc21 << " == " << dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::fini(21)) << '\n'; 0696 assert(htnc21 == dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::fini(21))); 0697 0698 std::cout << "htncbj" << '\n'; 0699 const Double htncbj = d.prob(1) * dtab.prob(bjgb::State::e_SBJ, bjgb::DealerCount::e_CBJ); 0700 0701 std::cout << htncbj << " == " << dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::e_CBJ) << '\n'; 0702 assert(htncbj == dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::e_CBJ)); 0703 0704 // ZERO 0705 0706 std::cout << "hzrc17" << '\n'; 0707 const Double hzrc17 = d.prob(1) * dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(17)) 0708 + d.prob(2) * dtab.prob(bjgb::State::hard(2), bjgb::DealerCount::fini(17)) 0709 + d.prob(3) * dtab.prob(bjgb::State::hard(3), bjgb::DealerCount::fini(17)) 0710 + d.prob(4) * dtab.prob(bjgb::State::hard(4), bjgb::DealerCount::fini(17)) 0711 + d.prob(5) * dtab.prob(bjgb::State::hard(5), bjgb::DealerCount::fini(17)) 0712 + d.prob(6) * dtab.prob(bjgb::State::hard(6), bjgb::DealerCount::fini(17)) 0713 + d.prob(7) * dtab.prob(bjgb::State::hard(7), bjgb::DealerCount::fini(17)) 0714 + d.prob(8) * dtab.prob(bjgb::State::hard(8), bjgb::DealerCount::fini(17)) 0715 + d.prob(9) * dtab.prob(bjgb::State::hard(9), bjgb::DealerCount::fini(17)) 0716 + d.prob(10) * dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::fini(17)); 0717 0718 std::cout << hzrc17 << " == " << dtab.prob(bjgb::State::e_HZR, bjgb::DealerCount::fini(17)) << '\n'; 0719 assert(hzrc17 == dtab.prob(bjgb::State::e_HZR, bjgb::DealerCount::fini(17))); 0720 0721 std::cout << "hzrc20" << '\n'; 0722 const Double hzrc20 = d.prob(1) * dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(20)) 0723 + d.prob(2) * dtab.prob(bjgb::State::hard(2), bjgb::DealerCount::fini(20)) 0724 + d.prob(3) * dtab.prob(bjgb::State::hard(3), bjgb::DealerCount::fini(20)) 0725 + d.prob(4) * dtab.prob(bjgb::State::hard(4), bjgb::DealerCount::fini(20)) 0726 + d.prob(5) * dtab.prob(bjgb::State::hard(5), bjgb::DealerCount::fini(20)) 0727 + d.prob(6) * dtab.prob(bjgb::State::hard(6), bjgb::DealerCount::fini(20)) 0728 + d.prob(7) * dtab.prob(bjgb::State::hard(7), bjgb::DealerCount::fini(20)) 0729 + d.prob(8) * dtab.prob(bjgb::State::hard(8), bjgb::DealerCount::fini(20)) 0730 + d.prob(9) * dtab.prob(bjgb::State::hard(9), bjgb::DealerCount::fini(20)) 0731 + d.prob(10) * dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::fini(20)); 0732 0733 std::cout << hzrc20 << " == " << dtab.prob(bjgb::State::e_HZR, bjgb::DealerCount::fini(20)) << '\n'; 0734 assert(hzrc20 == dtab.prob(bjgb::State::e_HZR, bjgb::DealerCount::fini(20))); 0735 0736 std::cout << "hzrc21" << '\n'; 0737 const Double hzrc21 = d.prob(1) * dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::fini(21)) 0738 + d.prob(2) * dtab.prob(bjgb::State::hard(2), bjgb::DealerCount::fini(21)) 0739 + d.prob(3) * dtab.prob(bjgb::State::hard(3), bjgb::DealerCount::fini(21)) 0740 + d.prob(4) * dtab.prob(bjgb::State::hard(4), bjgb::DealerCount::fini(21)) 0741 + d.prob(5) * dtab.prob(bjgb::State::hard(5), bjgb::DealerCount::fini(21)) 0742 + d.prob(6) * dtab.prob(bjgb::State::hard(6), bjgb::DealerCount::fini(21)) 0743 + d.prob(7) * dtab.prob(bjgb::State::hard(7), bjgb::DealerCount::fini(21)) 0744 + d.prob(8) * dtab.prob(bjgb::State::hard(8), bjgb::DealerCount::fini(21)) 0745 + d.prob(9) * dtab.prob(bjgb::State::hard(9), bjgb::DealerCount::fini(21)) 0746 + d.prob(10) * dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::fini(21)); 0747 0748 std::cout << hzrc21 << " == " << dtab.prob(bjgb::State::e_HZR, bjgb::DealerCount::fini(21)) << '\n'; 0749 assert(hzrc21 == dtab.prob(bjgb::State::e_HZR, bjgb::DealerCount::fini(21))); 0750 0751 std::cout << "hzrcbj" << '\n'; 0752 const Double hzrcbj = d.prob(1) * dtab.prob(bjgb::State::soft(1), bjgb::DealerCount::e_CBJ) 0753 + d.prob(10) * dtab.prob(bjgb::State::e_H_T, bjgb::DealerCount::e_CBJ); 0754 0755 std::cout << hzrcbj << " == " << dtab.prob(bjgb::State::e_HZR, bjgb::DealerCount::e_CBJ) << '\n'; 0756 assert(hzrcbj == dtab.prob(bjgb::State::e_HZR, bjgb::DealerCount::e_CBJ)); 0757 0758 // MAKE SURE that: unus(1), unus(2) ... unus(9), unus(10) 0759 // match: soft(1), hard(2) ... hard(9), e_H_T 0760 0761 std::cout << "verify that rows are copied properly" << '\n'; 0762 0763 for (int k = 17; k <= 23; ++k) { 0764 int ci = k <= 21 ? bjgb::DealerCount::fini(k) : k <= 22 ? bjgb::DealerCount::e_CBJ : bjgb::DealerCount::e_COV; 0765 0766 // std::cout << "k, ci: \t" << k << "\t" << ci << std:endl; 0767 0768 for (int j = 1; j <= 10; ++j) { 0769 int hi = 1 == j ? bjgb::State::soft(1) : 10 == j ? bjgb::State::e_H_T : bjgb::State::hard(j); 0770 0771 // std::cout << "\t\tj, hi: \t" << j << "\t" << hi << std::endl; 0772 0773 assert(dtab.prob(bjgb::State::unus(j), ci) == dtab.prob(hi, ci)); 0774 } 0775 } 0776 0777 // ----------------------------------------------------------------- 0778 // Let's test to see if we add up with bjgc::PlayerTableUtil::eStand 0779 // ----------------------------------------------------------------- 0780 0781 // std::cout << "============ bjgc::PlayerTableUtil::eStand ==========" 0782 // << std::endl; 0783 0784 // std::cout << "u = 1, v = 21" << std::setprecision(20) 0785 // << bjgc::PlayerTableUtil::eStand(dtab, 1, 21) 0786 // << std::endl; 0787 const Double esv_1_21 = dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::e_COV) 0788 + dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::fini(17)) 0789 + dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::fini(18)) 0790 + dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::fini(19)) 0791 + dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::fini(20)) 0792 - dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::e_CBJ); 0793 // std::cout << " expected = " << std::setprecision(20) << esv_1_21 0794 // << std::endl; 0795 assert(esv_1_21 == bjgc::PlayerTableUtil::eStand(dtab, 1, 21)); 0796 0797 // std::cout << "u = 2, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 2, 21) 0798 // << std::endl; 0799 const Double esv_2_21 = dtab.prob(bjgb::State::unus(2), bjgb::DealerCount::e_COV) 0800 + dtab.prob(bjgb::State::unus(2), bjgb::DealerCount::fini(17)) 0801 + dtab.prob(bjgb::State::unus(2), bjgb::DealerCount::fini(18)) 0802 + dtab.prob(bjgb::State::unus(2), bjgb::DealerCount::fini(19)) 0803 + dtab.prob(bjgb::State::unus(2), bjgb::DealerCount::fini(20)) 0804 - dtab.prob(bjgb::State::unus(2), bjgb::DealerCount::e_CBJ); 0805 0806 // std::cout << " expected = " << esv_2_21 << std::endl; 0807 assert(esv_2_21 == bjgc::PlayerTableUtil::eStand(dtab, 2, 21)); 0808 0809 std::cout << "u = 3, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 3, 21) << std::endl; 0810 std::cout << "u = 4, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 4, 21) << std::endl; 0811 std::cout << "u = 5, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 5, 21) << std::endl; 0812 std::cout << "u = 6, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 6, 21) << std::endl; 0813 std::cout << "u = 7, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 7, 21) << std::endl; 0814 std::cout << "u = 8, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 8, 21) << std::endl; 0815 std::cout << "u = 9, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 9, 21) << std::endl; 0816 0817 // std::cout << "u = T, v = 21" << bjgc::PlayerTableUtil::eStand(dtab, 10, 21) 0818 // << std::endl; 0819 const Double esv_T_21 = dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::e_COV) 0820 + dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(17)) 0821 + dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(18)) 0822 + dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(19)) 0823 + dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(20)) 0824 - dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::e_CBJ); 0825 0826 // std::cout << " expected = " << esv_T_21 << std::endl; 0827 assert(esv_T_21 == bjgc::PlayerTableUtil::eStand(dtab, 10, 21)); 0828 0829 // std::cout << "u = 5, v = 18" << bjgc::PlayerTableUtil::eStand(dtab, 5, 18) 0830 // << std::endl; 0831 const Double esv_5_18 = dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::e_COV) 0832 + dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(17)) 0833 // dtab.prob(bjgb::State::unus( 5), 0834 // bjgb::DealerCount::fini(18)) 0835 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(19)) 0836 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(20)) 0837 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(21)) 0838 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::e_CBJ); 0839 0840 // std::cout << " expected = " << esv_5_18 << std::endl; 0841 assert(esv_5_18 == bjgc::PlayerTableUtil::eStand(dtab, 5, 18)); 0842 0843 // std::cout << "u = 5, v = 17" << bjgc::PlayerTableUtil::eStand(dtab, 5, 17) 0844 // << std::endl; 0845 const Double esv_5_17 = dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::e_COV) 0846 // dtab.prob(bjgb::State::unus( 5), 0847 // bjgb::DealerCount::fini(17)) 0848 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(18)) 0849 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(19)) 0850 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(20)) 0851 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(21)) 0852 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::e_CBJ); 0853 0854 // std::cout << " expected = " << esv_5_17 << std::endl; 0855 assert(esv_5_17 == bjgc::PlayerTableUtil::eStand(dtab, 5, 17)); 0856 0857 // std::cout << "u = 5, v = 16" << bjgc::PlayerTableUtil::eStand(dtab, 5, 16) 0858 // << std::endl; 0859 const Double esv_5_16 = dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::e_COV) 0860 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(17)) 0861 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(18)) 0862 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(19)) 0863 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(20)) 0864 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::fini(21)) 0865 - dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::e_CBJ); 0866 0867 // std::cout << " expected = " << esv_5_16 << std::endl; 0868 assert(esv_5_16 == bjgc::PlayerTableUtil::eStand(dtab, 5, 16)); 0869 assert(esv_5_16 == bjgc::PlayerTableUtil::eStand(dtab, 5, 15)); 0870 assert(esv_5_16 == bjgc::PlayerTableUtil::eStand(dtab, 5, 15)); 0871 assert(esv_5_16 == bjgc::PlayerTableUtil::eStand(dtab, 5, 5)); 0872 assert(esv_5_16 == bjgc::PlayerTableUtil::eStand(dtab, 5, 4)); 0873 0874 #if 0 0875 std::cout << "============ bjgc::PlayerTableUtil::eStand ==========" 0876 << std::endl; 0877 0878 for (int i = 1; i <= 10; ++i) { 0879 std::cout << '\n' << i << ": " << std::endl; 0880 0881 for (int j = 14; j <= 21; ++j) { 0882 std::cout << '\n' << j << ": "; 0883 std::cout << bjgc::PlayerTableUtil::eStand(dtab, i, j) << " "; 0884 } 0885 0886 std::cout << std::endl; 0887 } 0888 #endif 0889 0890 // ----------------------------------- 0891 // Now we move on to the player stand. 0892 // ----------------------------------- 0893 0894 bjgc::PlayerTable pstab; 0895 pstab.reset(); 0896 bjgc::PlayerTableUtil::populatePstab(&pstab, dtab, d, rules); 0897 0898 std::cout << "======================================================\n"; 0899 std::cout << "================== Unadjusted pstab ==================\n"; 0900 std::cout << "======================================================\n"; 0901 std::cout << pstab << '\n'; 0902 0903 // some more testing is needed, but looks right. :) 0904 0905 // ----------------------------------------------------------------- 0906 // void DealerTableUtil::adjustForBj(bjgc::DealerTable *dst, 0907 // const bjgc::DealerTable& src); 0908 // ----------------------------------------------------------------- 0909 0910 std::cout << "===============================================\n"; 0911 std::cout << "================ Adjusted dtab2 ===============\n"; 0912 std::cout << "===============================================\n"; 0913 0914 bjgc::DealerTable dtab2; 0915 bjgc::DealerTableUtil::adjustForBj(&dtab2, dtab); 0916 std::cout << dtab2 << '\n'; 0917 0918 Double v_T_BJ = dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::e_CBJ); 0919 Double v_T_NBJ = 1 - v_T_BJ; 0920 Double v_T_21 = dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(21)); 0921 Double v_T_20 = dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(20)); 0922 Double v_T_17 = dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(17)); 0923 Double v_T_OV = dtab.prob(bjgb::State::unus(10), bjgb::DealerCount::e_COV); 0924 0925 assert(0.0 == dtab2.prob(bjgb::State::unus(10), bjgb::DealerCount::e_CBJ)); 0926 assert(v_T_21 / v_T_NBJ == dtab2.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(21))); 0927 assert(v_T_20 / v_T_NBJ == dtab2.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(20))); 0928 assert(v_T_17 / v_T_NBJ == dtab2.prob(bjgb::State::unus(10), bjgb::DealerCount::fini(17))); 0929 assert(v_T_OV / v_T_NBJ == dtab2.prob(bjgb::State::unus(10), bjgb::DealerCount::e_COV)); 0930 0931 assert(dtab.prob(bjgb::State::unus(9), bjgb::DealerCount::fini(18)) 0932 == dtab2.prob(bjgb::State::unus(9), bjgb::DealerCount::fini(18))); 0933 assert(dtab.prob(bjgb::State::unus(2), bjgb::DealerCount::fini(20)) 0934 == dtab2.prob(bjgb::State::unus(2), bjgb::DealerCount::fini(20))); 0935 assert(dtab.prob(bjgb::State::unus(5), bjgb::DealerCount::e_COV) 0936 == dtab2.prob(bjgb::State::unus(5), bjgb::DealerCount::e_COV)); 0937 0938 Double v_A_BJ = dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::e_CBJ); 0939 Double v_A_NBJ = 1 - v_A_BJ; 0940 Double v_A_21 = dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::fini(21)); 0941 Double v_A_18 = dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::fini(18)); 0942 Double v_A_OV = dtab.prob(bjgb::State::unus(1), bjgb::DealerCount::e_COV); 0943 0944 assert(0.0 == dtab2.prob(bjgb::State::unus(1), bjgb::DealerCount::e_CBJ)); 0945 assert(v_A_21 / v_A_NBJ == dtab2.prob(bjgb::State::unus(1), bjgb::DealerCount::fini(21))); 0946 assert(v_A_18 / v_A_NBJ == dtab2.prob(bjgb::State::unus(1), bjgb::DealerCount::fini(18))); 0947 assert(v_A_OV / v_A_NBJ == dtab2.prob(bjgb::State::unus(1), bjgb::DealerCount::e_COV)); 0948 0949 std::cout << "===============================================\n"; 0950 std::cout << "================ Adjusted pstab2 ==============\n"; 0951 std::cout << "===============================================\n"; 0952 0953 bjgc::PlayerTable pstab2; 0954 pstab2.reset(); 0955 bjgc::PlayerTableUtil::populatePstab(&pstab2, dtab2, d, rules); 0956 std::cout << pstab2 << '\n'; 0957 0958 assert(pstab2.exp(bjgb::State::hard(16), 10) > pstab.exp(bjgb::State::hard(16), 10)); 0959 assert(pstab2.exp(bjgb::State::hard(16), 9) == pstab.exp(bjgb::State::hard(16), 9)); 0960 assert(pstab2.exp(bjgb::State::hard(16), 2) == pstab.exp(bjgb::State::hard(16), 2)); 0961 assert(pstab2.exp(bjgb::State::hard(16), 1) > pstab.exp(bjgb::State::hard(16), 1)); 0962 0963 // ---------------------------------------------- 0964 // Let's test to see we add up with set and clear 0965 // ---------------------------------------------- 0966 { 0967 std::cout << "\ntest set and clear" 0968 "\n==================" 0969 "\n"; 0970 0971 bjgc::PlayerTable a, b; 0972 0973 a.reset(); 0974 b.reset(); 0975 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), b, bjgb::State::hard(4))); 0976 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), a, bjgb::State::hard(5))); 0977 0978 a.exp(bjgb::State::hard(5), 9) = .1; // change a[5], 9 0979 assert(!bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), b, bjgb::State::hard(4))); 0980 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), a, bjgb::State::hard(5))); 0981 0982 b.exp(bjgb::State::hard(5), 9) = .1; // change b[5], 9 0983 assert(!bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), b, bjgb::State::hard(4))); 0984 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), a, bjgb::State::hard(5))); 0985 0986 b.exp(bjgb::State::hard(4), 9) = .1; // change b[4], 9 0987 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), b, bjgb::State::hard(4))); 0988 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), a, bjgb::State::hard(5))); 0989 0990 b.exp(bjgb::State::hard(5), 10) = .2; // change b[5], 10 0991 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), b, bjgb::State::hard(4))); 0992 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), a, bjgb::State::hard(5))); 0993 0994 bjgc::PlayerTableUtil::copyPlayerRow(&a, bjgb::State::hard(4), b, bjgb::State::hard(4)); 0995 bjgc::PlayerTableUtil::copyPlayerRow(&a, bjgb::State::hard(6), b, bjgb::State::hard(6)); 0996 0997 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), b, bjgb::State::hard(4))); 0998 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), a, bjgb::State::hard(5))); 0999 1000 b.exp(bjgb::State::hard(4), 10) = .2; // change b[4], 10 1001 assert(!bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), b, bjgb::State::hard(4))); 1002 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), a, bjgb::State::hard(5))); 1003 1004 bjgc::PlayerTableUtil::copyPlayerRow(&a, bjgb::State::hard(5), b, bjgb::State::hard(5)); 1005 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), b, bjgb::State::hard(4))); 1006 assert(bjgc::PlayerTableUtil::isSamePlayerRow(a, bjgb::State::hard(5), a, bjgb::State::hard(5))); 1007 } 1008 1009 // ----------------------------------------------- 1010 // Let's test to see if bjgb::Types::isValid works 1011 // ----------------------------------------------- 1012 1013 std::cout << "\n=========================" 1014 "\n=========================" 1015 "\ntest bjgb::Types::isValid" 1016 "\n=========================" 1017 "\n=========================" 1018 "\n"; 1019 { 1020 bjgc::PlayerTable t; 1021 t.reset(); 1022 std::cout << "entry[h(2), u(1)] = " << t.exp(bjgb::State::hard(2), 1) << std::endl; 1023 assert(!bjgb::Types::isValid(t.exp(bjgb::State::hard(2), 1))); 1024 t.exp(bjgb::State::hard(2), 1) = -2.00; 1025 assert(bjgb::Types::isValid(t.exp(bjgb::State::hard(2), 1))); 1026 t.exp(bjgb::State::hard(2), 1) = 2.00; 1027 assert(bjgb::Types::isValid(t.exp(bjgb::State::hard(2), 1))); 1028 } 1029 1030 // ---------------------------------------------------------------- 1031 // Let's test to see if we add up with bjgc::PlayerTableUtil::eHit1 1032 // ---------------------------------------------------------------- 1033 1034 std::cout << "\n======================================" 1035 "\nLet's test to see we add up with eHit1" 1036 "\n======================================" 1037 "\n\n"; 1038 1039 /* 1040 Double bjgc::PlayerTableUtil::eHit1(const bjgc::PlayerTable pst, 1041 int uc, int hv, bool sf, 1042 const bjgb::Shoe& d) 1043 // Return the expected value of a player's hand, given the player table 1044 // for standing on any two-card value, 'pst', the dealer's up card, 'uc', 1045 // the *minimum* value of the hand, 'hv', whether it's a soft count, 'sf', 1046 // and the current shoe. Note that column values are deliberately summed 1047 // in a canonical order for numerical consistency: A, 2, ..., 9, T. 1048 */ 1049 1050 // depends on blackjack rules :) In UK you can lose double the bet. :) 1051 std::cout << "dtab2.hc(z(10), cbj()) = " << dtab2.prob(bjgb::State::unus(10), bjgb::DealerCount::e_CBJ) << '\n'; 1052 std::cout << " rules.canLoseDouble() = " << rules.playerCanLoseDouble() << '\n'; 1053 1054 assert((0.0 == dtab2.prob(bjgb::State::unus(10), bjgb::DealerCount::e_CBJ)) == !rules.playerCanLoseDouble()); 1055 1056 std::cout << "1 hit: hard 16, TEN:" << std::flush; 1057 { 1058 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(17), 10) 1059 + d.prob(2) * pstab2.exp(bjgb::State::hard(18), 10) + d.prob(3) * pstab2.exp(bjgb::State::hard(19), 10) 1060 + d.prob(4) * pstab2.exp(bjgb::State::hard(20), 10) + d.prob(5) * pstab2.exp(bjgb::State::hard(21), 10) 1061 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 10) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 10) 1062 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 10) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 10) 1063 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 10); 1064 std::cout << " exp = " << expected << std::flush; 1065 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 10, 16, 0, d); 1066 std::cout << " act = " << actual << std::endl; 1067 assert(expected == actual); 1068 } 1069 1070 std::cout << "1 hit: hard 16, NINE:" << std::flush; 1071 { 1072 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(17), 9) 1073 + d.prob(2) * pstab2.exp(bjgb::State::hard(18), 9) + d.prob(3) * pstab2.exp(bjgb::State::hard(19), 9) 1074 + d.prob(4) * pstab2.exp(bjgb::State::hard(20), 9) + d.prob(5) * pstab2.exp(bjgb::State::hard(21), 9) 1075 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 9) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 9) 1076 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 9) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 9) 1077 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 9); 1078 std::cout << " exp = " << expected << std::flush; 1079 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 9, 16, 0, d); 1080 std::cout << " act = " << actual << std::endl; 1081 assert(expected == actual); 1082 } 1083 1084 std::cout << "1 hit: hard 16, TWO:" << std::flush; 1085 { 1086 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(17), 2) 1087 + d.prob(2) * pstab2.exp(bjgb::State::hard(18), 2) + d.prob(3) * pstab2.exp(bjgb::State::hard(19), 2) 1088 + d.prob(4) * pstab2.exp(bjgb::State::hard(20), 2) + d.prob(5) * pstab2.exp(bjgb::State::hard(21), 2) 1089 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 2) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 2) 1090 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 2) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 2) 1091 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 2); 1092 std::cout << " exp = " << expected << std::flush; 1093 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 2, 16, 0, d); 1094 std::cout << " act = " << actual << std::endl; 1095 assert(expected == actual); 1096 } 1097 1098 std::cout << "1 hit: hard 16, ACE:" << std::flush; 1099 { 1100 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(17), 1) 1101 + d.prob(2) * pstab2.exp(bjgb::State::hard(18), 1) + d.prob(3) * pstab2.exp(bjgb::State::hard(19), 1) 1102 + d.prob(4) * pstab2.exp(bjgb::State::hard(20), 1) + d.prob(5) * pstab2.exp(bjgb::State::hard(21), 1) 1103 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 1) 1104 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 1) 1105 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 1); 1106 std::cout << " exp = " << expected << std::flush; 1107 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 1, 16, 0, d); 1108 std::cout << " act = " << actual << std::endl; 1109 assert(expected == actual); 1110 } 1111 1112 std::cout << "1 hit: hard 17, TEN:" << std::flush; 1113 { 1114 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(18), 10) 1115 + d.prob(2) * pstab2.exp(bjgb::State::hard(19), 10) + d.prob(3) * pstab2.exp(bjgb::State::hard(20), 10) 1116 + d.prob(4) * pstab2.exp(bjgb::State::hard(21), 10) + d.prob(5) * pstab2.exp(bjgb::State::e_HOV, 10) 1117 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 10) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 10) 1118 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 10) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 10) 1119 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 10); 1120 std::cout << " exp = " << expected << std::flush; 1121 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 10, 17, 0, d); 1122 std::cout << " act = " << actual << std::endl; 1123 assert(expected == actual); 1124 } 1125 1126 std::cout << "1 hit: hard 17, NINE:" << std::flush; 1127 { 1128 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(18), 9) 1129 + d.prob(2) * pstab2.exp(bjgb::State::hard(19), 9) + d.prob(3) * pstab2.exp(bjgb::State::hard(20), 9) 1130 + d.prob(4) * pstab2.exp(bjgb::State::hard(21), 9) + d.prob(5) * pstab2.exp(bjgb::State::e_HOV, 9) 1131 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 9) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 9) 1132 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 9) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 9) 1133 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 9); 1134 std::cout << " exp = " << expected << std::flush; 1135 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 9, 17, 0, d); 1136 std::cout << " act = " << actual << std::endl; 1137 assert(expected == actual); 1138 } 1139 1140 std::cout << "1 hit: hard 17, TWO:" << std::flush; 1141 { 1142 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(18), 2) 1143 + d.prob(2) * pstab2.exp(bjgb::State::hard(19), 2) + d.prob(3) * pstab2.exp(bjgb::State::hard(20), 2) 1144 + d.prob(4) * pstab2.exp(bjgb::State::hard(21), 2) + d.prob(5) * pstab2.exp(bjgb::State::e_HOV, 2) 1145 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 2) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 2) 1146 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 2) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 2) 1147 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 2); 1148 std::cout << " exp = " << expected << std::flush; 1149 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 2, 17, 0, d); 1150 std::cout << " act = " << actual << std::endl; 1151 assert(expected == actual); 1152 } 1153 1154 std::cout << "1 hit: hard 17, ACE:" << std::flush; 1155 { 1156 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(18), 1) 1157 + d.prob(2) * pstab2.exp(bjgb::State::hard(19), 1) + d.prob(3) * pstab2.exp(bjgb::State::hard(20), 1) 1158 + d.prob(4) * pstab2.exp(bjgb::State::hard(21), 1) + d.prob(5) * pstab2.exp(bjgb::State::e_HOV, 1) 1159 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 1) 1160 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 1) 1161 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 1); 1162 std::cout << " exp = " << expected << std::flush; 1163 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 1, 17, 0, d); 1164 std::cout << " act = " << actual << std::endl; 1165 assert(expected == actual); 1166 } 1167 1168 std::cout << "1 hit: hard 20, ACE:" << std::flush; 1169 { 1170 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(21), 1) 1171 + d.prob(2) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(3) * pstab2.exp(bjgb::State::e_HOV, 1) 1172 + d.prob(4) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(5) * pstab2.exp(bjgb::State::e_HOV, 1) 1173 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 1) 1174 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 1) 1175 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 1); 1176 std::cout << " exp = " << expected << std::flush; 1177 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 1, 20, 0, d); 1178 std::cout << " act = " << actual << std::endl; 1179 assert(expected == actual); 1180 } 1181 1182 std::cout << "1 hit: hard 21, ACE:" << std::flush; 1183 { 1184 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::e_HOV, 1) 1185 + d.prob(2) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(3) * pstab2.exp(bjgb::State::e_HOV, 1) 1186 + d.prob(4) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(5) * pstab2.exp(bjgb::State::e_HOV, 1) 1187 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 1) 1188 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 1) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 1) 1189 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 1); 1190 std::cout << " exp = " << expected << std::flush; 1191 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 1, 21, 0, d); 1192 std::cout << " act = " << actual << std::endl; 1193 assert(expected == actual); 1194 1195 assert(expected > -1.000'000'000'000'000'000'1L); 1196 // assert(expected < -0.999'999'999'999'999'999'9L); 1197 assert(expected < -0.999'999'999'999'999'999'8L); 1198 } 1199 1200 std::cout << "1 hit: hard 21, TEN:" << std::flush; 1201 { 1202 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::e_HOV, 10) 1203 + d.prob(2) * pstab2.exp(bjgb::State::e_HOV, 10) + d.prob(3) * pstab2.exp(bjgb::State::e_HOV, 10) 1204 + d.prob(4) * pstab2.exp(bjgb::State::e_HOV, 10) + d.prob(5) * pstab2.exp(bjgb::State::e_HOV, 10) 1205 + d.prob(6) * pstab2.exp(bjgb::State::e_HOV, 10) + d.prob(7) * pstab2.exp(bjgb::State::e_HOV, 10) 1206 + d.prob(8) * pstab2.exp(bjgb::State::e_HOV, 10) + d.prob(9) * pstab2.exp(bjgb::State::e_HOV, 10) 1207 + d.prob(10) * pstab2.exp(bjgb::State::e_HOV, 10); 1208 std::cout << " exp = " << expected << std::flush; 1209 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 10, 21, 0, d); 1210 std::cout << " act = " << actual << std::endl; 1211 assert(expected == actual); 1212 1213 assert(expected > -1.000'000'000'000'000'000'1L); 1214 // assert(expected < -0.999'999'999'999'999'999'9L); 1215 assert(expected < -0.999'999'999'999'999'999'8L); 1216 } 1217 1218 std::cout << "1 hit: hard 4, 5:" << std::flush; 1219 { 1220 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(5), 5) 1221 + d.prob(2) * pstab2.exp(bjgb::State::hard(6), 5) + d.prob(3) * pstab2.exp(bjgb::State::hard(7), 5) 1222 + d.prob(4) * pstab2.exp(bjgb::State::hard(8), 5) + d.prob(5) * pstab2.exp(bjgb::State::hard(9), 5) 1223 + d.prob(6) * pstab2.exp(bjgb::State::hard(10), 5) + d.prob(7) * pstab2.exp(bjgb::State::hard(11), 5) 1224 + d.prob(8) * pstab2.exp(bjgb::State::hard(12), 5) + d.prob(9) * pstab2.exp(bjgb::State::hard(13), 5) 1225 + d.prob(10) * pstab2.exp(bjgb::State::hard(14), 5); 1226 std::cout << " exp = " << expected << std::flush; 1227 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 5, 4, 0, d); 1228 std::cout << " act = " << actual << std::endl; 1229 assert(expected == actual); 1230 } 1231 1232 std::cout << "1 hit: soft 2, 10:" << std::flush; 1233 { 1234 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::soft(3), 10) 1235 + d.prob(2) * pstab2.exp(bjgb::State::soft(4), 10) + d.prob(3) * pstab2.exp(bjgb::State::soft(5), 10) 1236 + d.prob(4) * pstab2.exp(bjgb::State::soft(6), 10) + d.prob(5) * pstab2.exp(bjgb::State::soft(7), 10) 1237 + d.prob(6) * pstab2.exp(bjgb::State::soft(8), 10) + d.prob(7) * pstab2.exp(bjgb::State::soft(9), 10) 1238 + d.prob(8) * pstab2.exp(bjgb::State::soft(10), 10) + d.prob(9) * pstab2.exp(bjgb::State::soft(11), 10) 1239 + d.prob(10) * pstab2.exp(bjgb::State::hard(12), 10); 1240 std::cout << " exp = " << expected << std::flush; 1241 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 10, 2, 1, d); 1242 std::cout << " act = " << actual << std::endl; 1243 assert(expected == actual); 1244 } 1245 1246 std::cout << "1 hit: soft 11, A:" << std::flush; 1247 { 1248 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::hard(12), 1) 1249 + d.prob(2) * pstab2.exp(bjgb::State::hard(13), 1) + d.prob(3) * pstab2.exp(bjgb::State::hard(14), 1) 1250 + d.prob(4) * pstab2.exp(bjgb::State::hard(15), 1) + d.prob(5) * pstab2.exp(bjgb::State::hard(16), 1) 1251 + d.prob(6) * pstab2.exp(bjgb::State::hard(17), 1) + d.prob(7) * pstab2.exp(bjgb::State::hard(18), 1) 1252 + d.prob(8) * pstab2.exp(bjgb::State::hard(19), 1) + d.prob(9) * pstab2.exp(bjgb::State::hard(20), 1) 1253 + d.prob(10) * pstab2.exp(bjgb::State::hard(21), 1); 1254 std::cout << " exp = " << expected << std::flush; 1255 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 1, 11, 1, d); 1256 std::cout << " act = " << actual << std::endl; 1257 assert(expected == actual); 1258 } 1259 1260 std::cout << "1 hit: soft 7, 3:" << std::flush; 1261 { 1262 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::soft(8), 3) 1263 + d.prob(2) * pstab2.exp(bjgb::State::soft(9), 3) + d.prob(3) * pstab2.exp(bjgb::State::soft(10), 3) 1264 + d.prob(4) * pstab2.exp(bjgb::State::soft(11), 3) + d.prob(5) * pstab2.exp(bjgb::State::hard(12), 3) 1265 + d.prob(6) * pstab2.exp(bjgb::State::hard(13), 3) + d.prob(7) * pstab2.exp(bjgb::State::hard(14), 3) 1266 + d.prob(8) * pstab2.exp(bjgb::State::hard(15), 3) + d.prob(9) * pstab2.exp(bjgb::State::hard(16), 3) 1267 + d.prob(10) * pstab2.exp(bjgb::State::hard(17), 3); 1268 std::cout << " exp = " << expected << std::flush; 1269 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 3, 7, 1, d); 1270 std::cout << " act = " << actual << std::endl; 1271 assert(expected == actual); 1272 } 1273 1274 std::cout << "1 hit: hard 7, 10:" << std::flush; 1275 { 1276 const Double expected = d.prob(1) * pstab2.exp(bjgb::State::soft(8), 10) 1277 + d.prob(2) * pstab2.exp(bjgb::State::hard(9), 10) + d.prob(3) * pstab2.exp(bjgb::State::hard(10), 10) 1278 + d.prob(4) * pstab2.exp(bjgb::State::hard(11), 10) + d.prob(5) * pstab2.exp(bjgb::State::hard(12), 10) 1279 + d.prob(6) * pstab2.exp(bjgb::State::hard(13), 10) + d.prob(7) * pstab2.exp(bjgb::State::hard(14), 10) 1280 + d.prob(8) * pstab2.exp(bjgb::State::hard(15), 10) + d.prob(9) * pstab2.exp(bjgb::State::hard(16), 10) 1281 + d.prob(10) * pstab2.exp(bjgb::State::hard(17), 10); 1282 std::cout << " exp = " << expected << std::flush; 1283 const Double actual = bjgc::PlayerTableUtil::eHit1(pstab2, 10, 7, 0, d); 1284 std::cout << " act = " << actual << std::endl; 1285 assert(expected == actual); 1286 } 1287 1288 // ------------------------------------------------------- 1289 // Now let's look at player agrees to take exactly one hit 1290 // ------------------------------------------------------- 1291 1292 std::cout << "===============================================\n"; 1293 std::cout << "====*****====== unadjusted p1tab =====*****====\n"; 1294 std::cout << "===============================================\n"; 1295 1296 bjgc::PlayerTable p1tab; 1297 p1tab.reset(); 1298 bjgc::PlayerTableUtil::populateP1tab(&p1tab, pstab, d, rules); 1299 std::cout << p1tab << '\n'; 1300 1301 std::cout << "===============================================\n"; 1302 std::cout << "=============== Adjusted p1tab2 ===============\n"; 1303 std::cout << "===============================================\n"; 1304 1305 bjgc::PlayerTable p1tab2; 1306 p1tab2.reset(); 1307 bjgc::PlayerTableUtil::populateP1tab(&p1tab2, pstab2, d, rules); 1308 std::cout << p1tab2 << '\n'; 1309 1310 // ---------------------------------------------- 1311 // Let's start to look at one column of the table 1312 // ---------------------------------------------- 1313 1314 std::cout << "\n======================================" 1315 "\nLet's test to see if we add up with " 1316 "bjgc::PlayerTableUtil::eHitN" 1317 "\n======================================" 1318 "\n\n"; 1319 std::cout << "HELLO #0" << std::endl; 1320 1321 { 1322 bjgc::PlayerTable t; 1323 t.reset(); 1324 int cd = 10; 1325 bjgc::PlayerTable& q = pstab; 1326 1327 std::cout << "one or more hits: hard 21, " << cd << ": " << std::flush; 1328 { 1329 const Double expected = d.prob(1) * q.exp(bjgb::State::e_HOV, cd) 1330 + d.prob(2) * q.exp(bjgb::State::e_HOV, cd) + d.prob(3) * q.exp(bjgb::State::e_HOV, cd) 1331 + d.prob(4) * q.exp(bjgb::State::e_HOV, cd) + d.prob(5) * q.exp(bjgb::State::e_HOV, cd) 1332 + d.prob(6) * q.exp(bjgb::State::e_HOV, cd) + d.prob(7) * q.exp(bjgb::State::e_HOV, cd) 1333 + d.prob(8) * q.exp(bjgb::State::e_HOV, cd) + d.prob(9) * q.exp(bjgb::State::e_HOV, cd) 1334 + d.prob(10) * q.exp(bjgb::State::e_HOV, cd); 1335 std::cout << " exp = " << expected << std::flush; 1336 const Double actual = bjgc::PlayerTableUtil::eHitN(t, pstab, cd, 21, 0, d); 1337 std::cout << " act = " << actual << std::endl; 1338 assert(expected == actual); 1339 t.exp(21, cd) = actual; 1340 } 1341 1342 std::cout << "HELLO #1" << std::endl; 1343 1344 #if 0 1345 std::cout << "one or more hits: hard 20, " <<cd<< ": " << std::flush; 1346 { 1347 const Double expected = 1348 d.prob( 1) * t.exp(bjgb::State::hard(21), cd) 1349 + d.prob( 2) * q.exp(bjgb::State::e_HOV, cd) 1350 + d.prob( 3) * q.exp(bjgb::State::e_HOV, cd) 1351 + d.prob( 4) * q.exp(bjgb::State::e_HOV, cd) 1352 + d.prob( 5) * q.exp(bjgb::State::e_HOV, cd) 1353 + d.prob( 6) * q.exp(bjgb::State::e_HOV, cd) 1354 + d.prob( 7) * q.exp(bjgb::State::e_HOV, cd) 1355 + d.prob( 8) * q.exp(bjgb::State::e_HOV, cd) 1356 + d.prob( 9) * q.exp(bjgb::State::e_HOV, cd) 1357 + d.prob(10) * q.exp(bjgb::State::e_HOV, cd); 1358 std::cout << " exp = " << expected << std::flush; 1359 const Double actual = 1360 bjgc::PlayerTableUtil::eHitN(t, pstab, cd, 20, 0, d); 1361 std::cout << " act = " << actual << std::endl; 1362 assert(expected == actual); 1363 t.exp(20, cd) = actual; 1364 } 1365 #endif 1366 } 1367 1368 // ------------------------------------------- 1369 // Now let's look at player who decided to hit 1370 // ------------------------------------------- 1371 1372 std::cout << "===============================================\n"; 1373 std::cout << "====*****====== Unadjusted phtab =====*****====\n"; 1374 std::cout << "===============================================\n"; 1375 1376 bjgc::PlayerTable phtab; 1377 phtab.reset(); 1378 assert(!bjgb::Types::isValid(phtab.exp(bjgb::State::soft(11), 5))); 1379 bjgc::PlayerTableUtil::populatePhtab(&phtab, pstab, d, rules); 1380 assert(bjgb::Types::isValid(phtab.exp(bjgb::State::soft(11), 5))); 1381 std::cout << phtab << '\n'; 1382 1383 std::cout << "===============================================\n"; 1384 std::cout << "=============== Adjusted phtab2 ===============\n"; 1385 std::cout << "===============================================\n"; 1386 1387 bjgc::PlayerTable phtab2; 1388 phtab2.reset(); 1389 bjgc::PlayerTableUtil::populatePhtab(&phtab2, pstab2, d, rules); 1390 std::cout << phtab2 << '\n'; 1391 1392 // ------------------------------------------------------------- 1393 // Let's test to see we add up with bjgc::PlayerTableUtil::eHitN 1394 // ------------------------------------------------------------- 1395 1396 std::cout << "\n======================================================" 1397 "\nLet's test to see we add up with " 1398 "bjgc::PlayerTableUtil::eHitN with just pstab" 1399 "\n======================================================" 1400 "\n\n"; 1401 1402 // We are testing each dealer card from 1 to 10. 1403 1404 for (int cd = 1; cd <= 10; ++cd) { 1405 bjgc::PlayerTable& t = phtab2; 1406 bjgc::PlayerTable& q = pstab2; 1407 1408 std::cout << "\n\t=================" 1409 << "\n\t**** cd = " << cd << "\n\t=================" 1410 << "\n"; 1411 1412 assert(!bjgb::Types::isValid(t.exp(bjgb::State::e_HOV, cd))); 1413 // 43 e_HOV - NA 1414 assert(!bjgb::Types::isValid(t.exp(bjgb::State::e_HZR, cd))); 1415 // 12 e_HZR - NA 1416 1417 std::cout << "1+ hits -- hard 21, " << cd << ": " << std::flush; 1418 { 1419 const Double expected = d.prob(1) * q.exp(bjgb::State::e_HOV, cd) 1420 + d.prob(2) * q.exp(bjgb::State::e_HOV, cd) + d.prob(3) * q.exp(bjgb::State::e_HOV, cd) 1421 + d.prob(4) * q.exp(bjgb::State::e_HOV, cd) + d.prob(5) * q.exp(bjgb::State::e_HOV, cd) 1422 + d.prob(6) * q.exp(bjgb::State::e_HOV, cd) + d.prob(7) * q.exp(bjgb::State::e_HOV, cd) 1423 + d.prob(8) * q.exp(bjgb::State::e_HOV, cd) + d.prob(9) * q.exp(bjgb::State::e_HOV, cd) 1424 + d.prob(10) * q.exp(bjgb::State::e_HOV, cd); 1425 std::cout << " exp = " << expected << std::flush; 1426 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 21, 0, d); 1427 std::cout << " act = " << actual << std::endl; 1428 assert(expected == actual); 1429 assert(expected == t.exp(bjgb::State::hard(21), cd)); 1430 // 42 hard(21) 1431 } 1432 1433 std::cout << "1+ hits -- hard 20, " << cd << ": " << std::flush; 1434 { 1435 const Double expected = d.prob(1) * q.exp(bjgb::State::hard(21), cd) 1436 + d.prob(2) * q.exp(bjgb::State::e_HOV, cd) + d.prob(3) * q.exp(bjgb::State::e_HOV, cd) 1437 + d.prob(4) * q.exp(bjgb::State::e_HOV, cd) + d.prob(5) * q.exp(bjgb::State::e_HOV, cd) 1438 + d.prob(6) * q.exp(bjgb::State::e_HOV, cd) + d.prob(7) * q.exp(bjgb::State::e_HOV, cd) 1439 + d.prob(8) * q.exp(bjgb::State::e_HOV, cd) + d.prob(9) * q.exp(bjgb::State::e_HOV, cd) 1440 + d.prob(10) * q.exp(bjgb::State::e_HOV, cd); 1441 std::cout << " exp = " << expected << std::flush; 1442 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 20, 0, d); 1443 std::cout << " act = " << actual << std::endl; 1444 assert(expected == actual); 1445 assert(expected == t.exp(bjgb::State::hard(20), cd)); 1446 // 41 hard(20) 1447 assert(expected == t.exp(bjgb::State::pair(10), cd)); 1448 // 53 pair(10) 1449 } 1450 1451 std::cout << "1+ hits -- hard 19, " << cd << ": " << std::flush; 1452 { 1453 const Double expected = d.prob(1) * q.exp(bjgb::State::hard(20), cd) 1454 + d.prob(2) * q.exp(bjgb::State::hard(21), cd) + d.prob(3) * q.exp(bjgb::State::e_HOV, cd) 1455 + d.prob(4) * q.exp(bjgb::State::e_HOV, cd) + d.prob(5) * q.exp(bjgb::State::e_HOV, cd) 1456 + d.prob(6) * q.exp(bjgb::State::e_HOV, cd) + d.prob(7) * q.exp(bjgb::State::e_HOV, cd) 1457 + d.prob(8) * q.exp(bjgb::State::e_HOV, cd) + d.prob(9) * q.exp(bjgb::State::e_HOV, cd) 1458 + d.prob(10) * q.exp(bjgb::State::e_HOV, cd); 1459 std::cout << " exp = " << expected << std::flush; 1460 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 19, 0, d); 1461 std::cout << " act = " << actual << std::endl; 1462 assert(expected == actual); 1463 assert(expected == t.exp(bjgb::State::hard(19), cd)); 1464 // 40 hard(19) 1465 } 1466 // ------------------------------------------------------------------ 1467 1468 std::cout << "\n==========================================================" 1469 "\nLet's test to see we add up with " 1470 "bjgc::PlayerTableUtil::eHitN with tstab an pstab" 1471 "\n==========================================================" 1472 "\n\n"; 1473 1474 std::cout << "1+h-h21, " << cd << ": " << std::flush; 1475 { 1476 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1477 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1478 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1479 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1480 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1481 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1482 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1483 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1484 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1485 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1486 std::cout << " exp = " << expected << std::flush; 1487 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 21, 0, d); 1488 std::cout << " act = " << actual << std::endl; 1489 assert(expected == actual); 1490 assert(expected == t.exp(bjgb::State::hard(21), cd)); 1491 // duplicate 42 hard(21) 1492 } 1493 // std::cout << std::setprecision(20); 1494 1495 std::cout << "1+h-h20, " << cd << ": " << std::flush; 1496 { 1497 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1498 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1499 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1500 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1501 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1502 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1503 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1504 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1505 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1506 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1507 std::cout << " exp = " << expected << std::flush; 1508 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 20, 0, d); 1509 std::cout << " act = " << actual << std::endl; 1510 assert(expected == actual); 1511 assert(expected == t.exp(bjgb::State::hard(20), cd)); 1512 // duplicate 41 hard(20) 1513 } 1514 1515 std::cout << "1+h-h19, " << cd << ": " << std::flush; 1516 { 1517 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1518 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1519 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1520 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1521 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1522 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1523 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1524 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1525 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1526 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1527 std::cout << " exp = " << expected << std::flush; 1528 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 19, 0, d); 1529 std::cout << " act = " << actual << std::endl; 1530 assert(expected == actual); 1531 assert(expected == t.exp(bjgb::State::hard(19), cd)); 1532 // duplicate 40 hard(19) 1533 } 1534 1535 std::cout << "1+h-h18, " << cd << ": " << std::flush; 1536 { 1537 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1538 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1539 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1540 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1541 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1542 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1543 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1544 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1545 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1546 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1547 std::cout << " exp = " << expected << std::flush; 1548 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 18, 0, d); 1549 std::cout << " act = " << actual << std::endl; 1550 assert(expected == actual); 1551 assert(expected == t.exp(bjgb::State::hard(18), cd)); 1552 // 39 hard(18) 1553 assert(expected == t.exp(bjgb::State::pair(9), cd)); 1554 // 52 pair(9) 1555 } 1556 1557 std::cout << "1+h-h17, " << cd << ": " << std::flush; 1558 { 1559 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1560 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1561 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1562 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1563 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1564 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1565 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1566 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1567 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1568 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1569 std::cout << " exp = " << expected << std::flush; 1570 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 17, 0, d); 1571 std::cout << " act = " << actual << std::endl; 1572 assert(expected == actual); 1573 assert(expected == t.exp(bjgb::State::hard(17), cd)); 1574 // 38 hard(17) 1575 } 1576 1577 std::cout << "1+h-h16, " << cd << ": " << std::flush; 1578 { 1579 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1580 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1581 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1582 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1583 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1584 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1585 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1586 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1587 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1588 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1589 std::cout << " exp = " << expected << std::flush; 1590 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 16, 0, d); 1591 std::cout << " act = " << actual << std::endl; 1592 assert(expected == actual); 1593 assert(expected == t.exp(bjgb::State::hard(16), cd)); 1594 // 37 hard(16) 1595 assert(expected == t.exp(bjgb::State::pair(8), cd)); 1596 // 51 pair(8) 1597 } 1598 1599 std::cout << "1+h-h15, " << cd << ": " << std::flush; 1600 { 1601 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1602 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1603 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1604 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1605 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1606 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1607 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1608 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1609 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1610 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1611 std::cout << " exp = " << expected << std::flush; 1612 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 15, 0, d); 1613 std::cout << " act = " << actual << std::endl; 1614 assert(expected == actual); 1615 assert(expected == t.exp(bjgb::State::hard(15), cd)); 1616 // 36 hard(15) 1617 } 1618 1619 std::cout << "1+h-h14, " << cd << ": " << std::flush; 1620 { 1621 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1622 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1623 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1624 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1625 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1626 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1627 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1628 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1629 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1630 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1631 std::cout << " exp = " << expected << std::flush; 1632 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 14, 0, d); 1633 std::cout << " act = " << actual << std::endl; 1634 assert(expected == actual); 1635 assert(expected == t.exp(bjgb::State::hard(14), cd)); 1636 // 35 hard(14) 1637 assert(expected == t.exp(bjgb::State::pair(7), cd)); 1638 // 50 pair(7) 1639 } 1640 1641 std::cout << "1+h-h13, " << cd << ": " << std::flush; 1642 { 1643 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1644 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1645 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1646 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1647 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1648 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1649 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1650 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1651 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q) 1652 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1653 std::cout << " exp = " << expected << std::flush; 1654 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 13, 0, d); 1655 std::cout << " act = " << actual << std::endl; 1656 assert(expected == actual); 1657 assert(expected == t.exp(bjgb::State::hard(13), cd)); 1658 // 34 hard(13) 1659 } 1660 1661 std::cout << "1+h-h12, " << cd << ": " << std::flush; 1662 { 1663 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1664 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1665 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1666 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1667 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1668 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1669 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1670 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1671 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q) 1672 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::e_HOV, cd, t, q); 1673 std::cout << " exp = " << expected << std::flush; 1674 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 12, 0, d); 1675 std::cout << " act = " << actual << std::endl; 1676 assert(expected == actual); 1677 assert(expected == t.exp(bjgb::State::hard(12), cd)); 1678 // 33 hard(12) 1679 assert(expected == t.exp(bjgb::State::pair(6), cd)); 1680 // 49 pair(6) 1681 } 1682 1683 std::cout << "1+h-h11, " << cd << ": " << std::flush; 1684 { 1685 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1686 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1687 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1688 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1689 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1690 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1691 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1692 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1693 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1694 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q); 1695 std::cout << " exp = " << expected << std::flush; 1696 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 11, 0, d); 1697 std::cout << " act = " << actual << std::endl; 1698 assert(expected == actual); 1699 assert(expected == t.exp(bjgb::State::hard(11), cd)); 1700 // 32 hard(11) 1701 } 1702 1703 std::cout << "============================================================\n"; 1704 1705 std::cout << "1+h-sbj, " << cd << ": " << std::flush; 1706 { 1707 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1708 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1709 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1710 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1711 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1712 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1713 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1714 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1715 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1716 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q); 1717 std::cout << " exp = " << expected << std::flush; 1718 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 11, true, d); 1719 std::cout << " act = " << actual << std::endl; 1720 assert(expected == actual); 1721 } 1722 1723 std::cout << "1+h-s11, " << cd << ": " << std::flush; 1724 { 1725 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1726 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1727 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1728 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1729 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1730 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1731 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1732 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1733 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q) 1734 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(21), cd, t, q); 1735 std::cout << " exp = " << expected << std::flush; 1736 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 11, true, d); 1737 std::cout << " act = " << actual << std::endl; 1738 assert(expected == actual); 1739 assert(expected == t.exp(bjgb::State::soft(11), cd)); 1740 // 10 soft(11) 1741 assert(expected == t.exp(bjgb::State::e_SBJ, cd)); // 11 e_SBJ 1742 } 1743 1744 std::cout << "1+h-s10, " << cd << ": " << std::flush; 1745 { 1746 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1747 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1748 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1749 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1750 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1751 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1752 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1753 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1754 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1755 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q); 1756 std::cout << " exp = " << expected << std::flush; 1757 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 10, true, d); 1758 std::cout << " act = " << actual << std::endl; 1759 assert(expected == actual); 1760 assert(expected == t.exp(bjgb::State::soft(10), cd)); // 9 soft(10) 1761 } 1762 1763 std::cout << "1+h-s9, " << cd << ": " << std::flush; 1764 { 1765 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1766 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1767 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1768 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1769 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1770 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1771 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1772 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1773 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1774 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q); 1775 std::cout << " exp = " << expected << std::flush; 1776 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 9, true, d); 1777 std::cout << " act = " << actual << std::endl; 1778 assert(expected == actual); 1779 assert(expected == t.exp(bjgb::State::soft(9), cd)); // 8 soft(9) 1780 } 1781 1782 std::cout << "1+h-s8, " << cd << ": " << std::flush; 1783 { 1784 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1785 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1786 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1787 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1788 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1789 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1790 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1791 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1792 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1793 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q); 1794 std::cout << " exp = " << expected << std::flush; 1795 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 8, true, d); 1796 std::cout << " act = " << actual << std::endl; 1797 assert(expected == actual); 1798 assert(expected == t.exp(bjgb::State::soft(8), cd)); // 7 soft(8) 1799 } 1800 1801 std::cout << "1+h-s7, " << cd << ": " << std::flush; 1802 { 1803 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(8), cd, t, q) 1804 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1805 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1806 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1807 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1808 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1809 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1810 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1811 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1812 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q); 1813 std::cout << " exp = " << expected << std::flush; 1814 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 7, true, d); 1815 std::cout << " act = " << actual << std::endl; 1816 assert(expected == actual); 1817 assert(expected == t.exp(bjgb::State::soft(7), cd)); // 6 soft(7) 1818 } 1819 1820 std::cout << "1+h-s6, " << cd << ": " << std::flush; 1821 { 1822 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(7), cd, t, q) 1823 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(8), cd, t, q) 1824 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1825 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1826 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1827 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1828 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1829 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1830 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1831 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q); 1832 std::cout << " exp = " << expected << std::flush; 1833 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 6, true, d); 1834 std::cout << " act = " << actual << std::endl; 1835 assert(expected == actual); 1836 assert(expected == t.exp(bjgb::State::soft(6), cd)); // 5 soft(6) 1837 } 1838 1839 std::cout << "1+h-s5, " << cd << ": " << std::flush; 1840 { 1841 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(6), cd, t, q) 1842 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(7), cd, t, q) 1843 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(8), cd, t, q) 1844 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1845 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1846 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1847 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1848 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1849 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1850 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q); 1851 std::cout << " exp = " << expected << std::flush; 1852 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 5, true, d); 1853 std::cout << " act = " << actual << std::endl; 1854 assert(expected == actual); 1855 assert(expected == t.exp(bjgb::State::soft(5), cd)); // 4 soft(5) 1856 } 1857 1858 std::cout << "1+h-s4, " << cd << ": " << std::flush; 1859 { 1860 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(5), cd, t, q) 1861 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(6), cd, t, q) 1862 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(7), cd, t, q) 1863 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(8), cd, t, q) 1864 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1865 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1866 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1867 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1868 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1869 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q); 1870 std::cout << " exp = " << expected << std::flush; 1871 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 4, true, d); 1872 std::cout << " act = " << actual << std::endl; 1873 assert(expected == actual); 1874 assert(expected == t.exp(bjgb::State::soft(4), cd)); // 3 soft(4) 1875 } 1876 1877 std::cout << "1+h-s3, " << cd << ": " << std::flush; 1878 { 1879 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(4), cd, t, q) 1880 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(5), cd, t, q) 1881 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(6), cd, t, q) 1882 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(7), cd, t, q) 1883 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(8), cd, t, q) 1884 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1885 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1886 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1887 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1888 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q); 1889 std::cout << " exp = " << expected << std::flush; 1890 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 3, true, d); 1891 std::cout << " act = " << actual << std::endl; 1892 assert(expected == actual); 1893 assert(expected == t.exp(bjgb::State::soft(3), cd)); // 2 soft(3) 1894 } 1895 1896 std::cout << "1+h-s2, " << cd << ": " << std::flush; 1897 { 1898 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(3), cd, t, q) 1899 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(4), cd, t, q) 1900 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(5), cd, t, q) 1901 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(6), cd, t, q) 1902 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(7), cd, t, q) 1903 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(8), cd, t, q) 1904 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1905 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1906 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1907 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q); 1908 std::cout << " exp = " << expected << std::flush; 1909 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 2, true, d); 1910 std::cout << " act = " << actual << std::endl; 1911 assert(expected == actual); 1912 assert(expected == t.exp(bjgb::State::soft(2), cd)); // 1 soft(2) 1913 assert(expected == t.exp(bjgb::State::pair(1), cd)); // 44 pair(1) 1914 } 1915 1916 std::cout << "1+h-s1, " << cd << ": " << std::flush; 1917 { 1918 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(2), cd, t, q) 1919 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(3), cd, t, q) 1920 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(4), cd, t, q) 1921 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(5), cd, t, q) 1922 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(6), cd, t, q) 1923 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(7), cd, t, q) 1924 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(8), cd, t, q) 1925 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1926 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1927 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q); 1928 std::cout << " exp = " << expected << std::flush; 1929 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 1, true, d); 1930 std::cout << " act = " << actual << std::endl; 1931 assert(expected == actual); 1932 assert(expected == t.exp(bjgb::State::soft(1), cd)); // 0 soft(1) 1933 assert(expected == t.exp(bjgb::State::unus(1), cd)); // 13 unus(1) 1934 } 1935 1936 std::cout << "============================================================\n"; 1937 1938 std::cout << "1+h-h10, " << cd << ": " << std::flush; 1939 { 1940 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(11), cd, t, q) 1941 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1942 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1943 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1944 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1945 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1946 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1947 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1948 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q) 1949 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(20), cd, t, q); 1950 std::cout << " exp = " << expected << std::flush; 1951 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 10, 0, d); 1952 std::cout << " act = " << actual << std::endl; 1953 assert(expected == actual); 1954 assert(expected == t.exp(bjgb::State::hard(10), cd)); 1955 // 31 hard(10) 1956 assert(expected == t.exp(bjgb::State::e_H_T, cd)); 1957 // 22 unus(10) 1958 assert(expected == t.exp(bjgb::State::pair(5), cd)); 1959 // 48 pair(5) 1960 } 1961 1962 std::cout << "1+h-h9, " << cd << ": " << std::flush; 1963 { 1964 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(10), cd, t, q) 1965 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(11), cd, t, q) 1966 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1967 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1968 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1969 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1970 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1971 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1972 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q) 1973 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(19), cd, t, q); 1974 std::cout << " exp = " << expected << std::flush; 1975 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 9, 0, d); 1976 std::cout << " act = " << actual << std::endl; 1977 assert(expected == actual); 1978 assert(expected == t.exp(bjgb::State::hard(9), cd)); // 30 hard(9) 1979 assert(expected == t.exp(bjgb::State::unus(9), cd)); // 21 unus(9) 1980 } 1981 1982 std::cout << "1+h-h8, " << cd << ": " << std::flush; 1983 { 1984 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(9), cd, t, q) 1985 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(10), cd, t, q) 1986 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(11), cd, t, q) 1987 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 1988 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 1989 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 1990 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 1991 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 1992 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q) 1993 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(18), cd, t, q); 1994 std::cout << " exp = " << expected << std::flush; 1995 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 8, 0, d); 1996 std::cout << " act = " << actual << std::endl; 1997 assert(expected == actual); 1998 assert(expected == t.exp(bjgb::State::hard(8), cd)); // 29 hard(8) 1999 assert(expected == t.exp(bjgb::State::unus(8), cd)); // 20 unus(8) 2000 assert(expected == t.exp(bjgb::State::pair(4), cd)); // 47 pair(4) 2001 } 2002 2003 std::cout << "1+h-h7, " << cd << ": " << std::flush; 2004 { 2005 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(8), cd, t, q) 2006 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(9), cd, t, q) 2007 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(10), cd, t, q) 2008 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(11), cd, t, q) 2009 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 2010 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 2011 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 2012 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 2013 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q) 2014 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(17), cd, t, q); 2015 std::cout << " exp = " << expected << std::flush; 2016 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 7, 0, d); 2017 std::cout << " act = " << actual << std::endl; 2018 assert(expected == actual); 2019 assert(expected == t.exp(bjgb::State::hard(7), cd)); // 28 hard(7) 2020 assert(expected == t.exp(bjgb::State::unus(7), cd)); // 19 unus(7) 2021 } 2022 2023 std::cout << "1+h-h6, " << cd << ": " << std::flush; 2024 { 2025 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(7), cd, t, q) 2026 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(8), cd, t, q) 2027 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(9), cd, t, q) 2028 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(10), cd, t, q) 2029 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(11), cd, t, q) 2030 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 2031 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 2032 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 2033 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q) 2034 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(16), cd, t, q); 2035 std::cout << " exp = " << expected << std::flush; 2036 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 6, 0, d); 2037 std::cout << " act = " << actual << std::endl; 2038 assert(expected == actual); 2039 assert(expected == t.exp(bjgb::State::hard(6), cd)); // 27 hard(6) 2040 assert(expected == t.exp(bjgb::State::unus(6), cd)); // 18 unus(6) 2041 assert(expected == t.exp(bjgb::State::pair(3), cd)); // 46 pair(3) 2042 } 2043 2044 std::cout << "1+h-h5, " << cd << ": " << std::flush; 2045 { 2046 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(6), cd, t, q) 2047 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(7), cd, t, q) 2048 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(8), cd, t, q) 2049 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(9), cd, t, q) 2050 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(10), cd, t, q) 2051 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(11), cd, t, q) 2052 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 2053 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 2054 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q) 2055 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(15), cd, t, q); 2056 std::cout << " exp = " << expected << std::flush; 2057 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 5, 0, d); 2058 std::cout << " act = " << actual << std::endl; 2059 assert(expected == actual); 2060 assert(expected == t.exp(bjgb::State::hard(5), cd)); // 26 hard(5) 2061 assert(expected == t.exp(bjgb::State::unus(5), cd)); // 17 unus(5) 2062 } 2063 2064 std::cout << "1+h-h4, " << cd << ": " << std::flush; 2065 { 2066 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(5), cd, t, q) 2067 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(6), cd, t, q) 2068 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(7), cd, t, q) 2069 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(8), cd, t, q) 2070 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(9), cd, t, q) 2071 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(10), cd, t, q) 2072 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(11), cd, t, q) 2073 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 2074 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q) 2075 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(14), cd, t, q); 2076 std::cout << " exp = " << expected << std::flush; 2077 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 4, 0, d); 2078 std::cout << " act = " << actual << std::endl; 2079 assert(expected == actual); 2080 assert(expected == t.exp(bjgb::State::hard(4), cd)); // 25 hard(4) 2081 assert(expected == t.exp(bjgb::State::unus(4), cd)); // 16 unus(4) 2082 assert(expected == t.exp(bjgb::State::pair(2), cd)); // 45 pair(2) 2083 } 2084 2085 std::cout << "1+h-h3, " << cd << ": " << std::flush; 2086 { 2087 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(4), cd, t, q) 2088 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(5), cd, t, q) 2089 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(6), cd, t, q) 2090 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(7), cd, t, q) 2091 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(8), cd, t, q) 2092 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(9), cd, t, q) 2093 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(10), cd, t, q) 2094 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(11), cd, t, q) 2095 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q) 2096 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(13), cd, t, q); 2097 std::cout << " exp = " << expected << std::flush; 2098 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 3, 0, d); 2099 std::cout << " act = " << actual << std::endl; 2100 assert(expected == actual); 2101 assert(expected == t.exp(bjgb::State::hard(3), cd)); // 24 hard(3) 2102 assert(expected == t.exp(bjgb::State::unus(3), cd)); // 15 unus(3) 2103 } 2104 2105 std::cout << "1+h-h2, " << cd << ": " << std::flush; 2106 { 2107 const Double expected = d.prob(1) * bjgc::PlayerTableUtil::mx(bjgb::State::soft(3), cd, t, q) 2108 + d.prob(2) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(4), cd, t, q) 2109 + d.prob(3) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(5), cd, t, q) 2110 + d.prob(4) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(6), cd, t, q) 2111 + d.prob(5) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(7), cd, t, q) 2112 + d.prob(6) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(8), cd, t, q) 2113 + d.prob(7) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(9), cd, t, q) 2114 + d.prob(8) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(10), cd, t, q) 2115 + d.prob(9) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(11), cd, t, q) 2116 + d.prob(10) * bjgc::PlayerTableUtil::mx(bjgb::State::hard(12), cd, t, q); 2117 std::cout << " exp = " << expected << std::flush; 2118 const Double actual = bjgc::PlayerTableUtil::eHitN(t, q, cd, 2, 0, d); 2119 std::cout << " act = " << actual << std::endl; 2120 assert(expected == actual); 2121 assert(expected == t.exp(bjgb::State::hard(2), cd)); // 23 hard(2) 2122 assert(expected == t.exp(bjgb::State::unus(2), cd)); // 14 unus(2) 2123 } 2124 2125 } // end cd loop 2126 2127 std::cout << "\n\n"; 2128 std::cout << "===============================================\n"; 2129 std::cout << "============= ON TO DOUBLE TABLE ==============\n"; 2130 std::cout << "===============================================\n"; 2131 2132 std::cout << rules << std::endl; 2133 2134 // Note that we will use the adjusted tables UNLESS it is possible 2135 // to play the hand and then lose more than an even bet to a natural 2136 // blackjack. 2137 2138 std::cout << "===============================================\n"; 2139 std::cout << "=============== Unadjusted pdtab ==============\n"; 2140 std::cout << "===============================================\n"; 2141 2142 bjgc::PlayerTable pdtab; 2143 pdtab.reset(); 2144 bjgc::PlayerTableUtil::populatePdtab(&pdtab, p1tab); 2145 std::cout << pdtab << '\n'; 2146 2147 std::cout << "===============================================\n"; 2148 std::cout << "================ Adjusted pdtab2 ==============\n"; 2149 std::cout << "===============================================\n"; 2150 2151 bjgc::PlayerTable pdtab2; 2152 pdtab2.reset(); 2153 bjgc::PlayerTableUtil::populatePdtab(&pdtab2, p1tab2); 2154 std::cout << pdtab2 << '\n'; 2155 2156 assert(2 * p1tab2.exp(bjgb::State::e_SBJ, 1) == pdtab2.exp(bjgb::State::e_SBJ, 1)); 2157 assert(2 * p1tab2.exp(bjgb::State::e_SBJ, 10) == pdtab2.exp(bjgb::State::e_SBJ, 10)); 2158 2159 assert(2 * p1tab2.exp(bjgb::State::soft(11), 1) == pdtab2.exp(bjgb::State::soft(11), 1)); 2160 assert(2 * p1tab2.exp(bjgb::State::soft(11), 10) == pdtab2.exp(bjgb::State::soft(11), 10)); 2161 2162 assert(2 * p1tab2.exp(bjgb::State::soft(2), 1) == pdtab2.exp(bjgb::State::soft(2), 1)); 2163 assert(2 * p1tab2.exp(bjgb::State::soft(2), 10) == pdtab2.exp(bjgb::State::soft(2), 10)); 2164 2165 assert(2 * p1tab2.exp(bjgb::State::hard(20), 1) == pdtab2.exp(bjgb::State::hard(20), 1)); 2166 assert(2 * p1tab2.exp(bjgb::State::hard(20), 10) == pdtab2.exp(bjgb::State::hard(20), 10)); 2167 2168 assert(2 * p1tab2.exp(bjgb::State::hard(4), 1) == pdtab2.exp(bjgb::State::hard(4), 1)); 2169 assert(2 * p1tab2.exp(bjgb::State::hard(4), 10) == pdtab2.exp(bjgb::State::hard(4), 10)); 2170 2171 std::cout << "===============================================\n"; 2172 std::cout << "=============== Unadjusted pxtab ==============\n"; 2173 std::cout << "===============================================\n"; 2174 2175 // pxtab is pdtab augmented with split information. 2176 2177 bjgc::PlayerTable pxtab; 2178 pxtab.reset(); 2179 bjgc::PlayerTableUtil::populatePxtab(&pxtab, pdtab, phtab, p1tab, pstab, d, rules); 2180 std::cout << pxtab << '\n'; 2181 2182 std::cout << "===============================================\n"; 2183 std::cout << "================ adjusted pxtab2 ==============\n"; 2184 std::cout << "===============================================\n"; 2185 2186 bjgc::PlayerTable pxtab2; 2187 pxtab2.reset(); 2188 bjgc::PlayerTableUtil::populatePxtab(&pxtab2, pdtab2, phtab2, p1tab2, pstab2, d, rules); 2189 std::cout << pxtab2 << '\n'; 2190 2191 std::cout << "\n=====================================================" 2192 "\nLet's start with really simple tests on just 1 split." 2193 "\n=====================================================" 2194 "\n\n"; 2195 2196 // Double bjgc::PlayerTableUtil::eSplit(const bjgc::PlayerTable& pdt, 2197 // const bjgc::PlayerTable& pht, 2198 // const bjgc::PlayerTable& p1t, 2199 // const bjgc::PlayerTable& pst, 2200 // int uc, int hv, int n, 2201 // const bjgb::Shoe& d, 2202 // const bjgb::Rules& rules) 2203 2204 // for (int cd = 1; cd <= 10; ++cd) 2205 int cd = 6; 2206 { 2207 std::cout << "\n\t=================" 2208 << "\n\t**** cd = " << cd << "\n\t=================" 2209 << "\n"; 2210 2211 bjgc::PlayerTable& dt = pdtab2; 2212 bjgc::PlayerTable& ht = phtab2; 2213 bjgc::PlayerTable& ot = p1tab2; 2214 bjgc::PlayerTable& st = pstab2; 2215 2216 Double max2val99 = -99e99; 2217 2218 std::cout << "two 9's against a " << cd << ", maxHands = 2\n"; 2219 { 2220 int sp = 9; 2221 Double exp = d.prob(1) * bjgc::PlayerTableUtil::mx3(bjgb::State::soft(sp + 1), cd, dt, ht, st) 2222 + d.prob(2) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 2), cd, dt, ht, st) 2223 + d.prob(3) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 3), cd, dt, ht, st) 2224 + d.prob(4) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 4), cd, dt, ht, st) 2225 + d.prob(5) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 5), cd, dt, ht, st) 2226 + d.prob(6) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 6), cd, dt, ht, st) 2227 + d.prob(7) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 7), cd, dt, ht, st) 2228 + d.prob(8) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 8), cd, dt, ht, st) 2229 + d.prob(9) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 9), cd, dt, ht, st) 2230 + d.prob(10) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 10), cd, dt, ht, st); 2231 exp *= 2; 2232 std::cout << " exp = " << exp << std::flush; 2233 const Double act = bjgc::PlayerTableUtil::eSplit(dt, ht, ot, st, cd, 2 * sp, 1, d, rules); 2234 std::cout << " act = " << act << std::endl; 2235 assert(exp == act); 2236 max2val99 = exp; 2237 } 2238 2239 Double max3val99 = -99e99; 2240 2241 std::cout << "two 9's against a " << cd << ", maxHands = 3\n"; 2242 { 2243 int sp = 9; 2244 Double exp = d.prob(1) * bjgc::PlayerTableUtil::mx3(bjgb::State::soft(sp + 1), cd, dt, ht, st) 2245 + d.prob(2) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 2), cd, dt, ht, st) 2246 + d.prob(3) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 3), cd, dt, ht, st) 2247 + d.prob(4) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 4), cd, dt, ht, st) 2248 + d.prob(5) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 5), cd, dt, ht, st) 2249 + d.prob(6) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 6), cd, dt, ht, st) 2250 + d.prob(7) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 7), cd, dt, ht, st) 2251 + d.prob(8) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 8), cd, dt, ht, st) 2252 + d.prob(9) * max2val99 2253 + d.prob(10) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 10), cd, dt, ht, st); 2254 exp *= 2; 2255 std::cout << " exp = " << exp << std::flush; 2256 const Double act = bjgc::PlayerTableUtil::eSplit(dt, ht, ot, st, cd, 2 * sp, 2, d, rules); 2257 std::cout << " act = " << act << std::endl; 2258 assert(exp == act); 2259 max3val99 = exp; 2260 } 2261 2262 Double max4val99 = -99e99; 2263 2264 std::cout << "two 9's against a " << cd << ", maxHands = 4\n"; 2265 { 2266 int sp = 9; 2267 Double exp = d.prob(1) * bjgc::PlayerTableUtil::mx3(bjgb::State::soft(sp + 1), cd, dt, ht, st) 2268 + d.prob(2) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 2), cd, dt, ht, st) 2269 + d.prob(3) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 3), cd, dt, ht, st) 2270 + d.prob(4) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 4), cd, dt, ht, st) 2271 + d.prob(5) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 5), cd, dt, ht, st) 2272 + d.prob(6) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 6), cd, dt, ht, st) 2273 + d.prob(7) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 7), cd, dt, ht, st) 2274 + d.prob(8) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 8), cd, dt, ht, st) 2275 + d.prob(9) * max3val99 2276 + d.prob(10) * bjgc::PlayerTableUtil::mx3(bjgb::State::hard(sp + 10), cd, dt, ht, st); 2277 exp *= 2; 2278 std::cout << " exp = " << exp << std::flush; 2279 const Double act = bjgc::PlayerTableUtil::eSplit(dt, ht, ot, st, cd, 2 * sp, 3, d, rules); 2280 std::cout << " act = " << act << std::endl; 2281 assert(exp == act); 2282 max4val99 = exp; 2283 } 2284 2285 Double max2valAA = -99e99; 2286 2287 std::cout << "two A's against a " << cd << ", maxHands = 2\n"; 2288 { 2289 // ASSUMES 1 card to a split ace! 2290 2291 int sp = 1; 2292 Double exp = d.prob(1) * st.exp(bjgb::State::soft(sp + 1), cd) 2293 + d.prob(2) * st.exp(bjgb::State::soft(sp + 2), cd) + d.prob(3) * st.exp(bjgb::State::soft(sp + 3), cd) 2294 + d.prob(4) * st.exp(bjgb::State::soft(sp + 4), cd) + d.prob(5) * st.exp(bjgb::State::soft(sp + 5), cd) 2295 + d.prob(6) * st.exp(bjgb::State::soft(sp + 6), cd) + d.prob(7) * st.exp(bjgb::State::soft(sp + 7), cd) 2296 + d.prob(8) * st.exp(bjgb::State::soft(sp + 8), cd) + d.prob(9) * st.exp(bjgb::State::soft(sp + 9), cd) 2297 + d.prob(10) * st.exp(bjgb::State::soft(sp + 10), cd); 2298 exp *= 2; 2299 std::cout << " exp = " << exp << std::flush; 2300 Double ex2 = 2 * ot.exp(bjgb::State::unus(1), cd); 2301 std::cout << " ex2 = " << ex2 << std::flush; 2302 2303 const Double act = bjgc::PlayerTableUtil::eSplit(dt, ht, ot, st, cd, 2 * sp, 1, d, rules); 2304 std::cout << " act = " << act << std::endl; 2305 assert(exp == act); 2306 assert(ex2 == act); 2307 max2valAA = exp; 2308 } 2309 2310 Double max3valAA = -99e99; 2311 2312 std::cout << "two A's against a " << cd << ", maxHands = 3\n"; 2313 { 2314 // ASSUMES 1 card to a split ace! 2315 2316 int sp = 1; 2317 Double exp = d.prob(1) * max2valAA + d.prob(2) * st.exp(bjgb::State::soft(sp + 2), cd) 2318 + d.prob(3) * st.exp(bjgb::State::soft(sp + 3), cd) + d.prob(4) * st.exp(bjgb::State::soft(sp + 4), cd) 2319 + d.prob(5) * st.exp(bjgb::State::soft(sp + 5), cd) + d.prob(6) * st.exp(bjgb::State::soft(sp + 6), cd) 2320 + d.prob(7) * st.exp(bjgb::State::soft(sp + 7), cd) + d.prob(8) * st.exp(bjgb::State::soft(sp + 8), cd) 2321 + d.prob(9) * st.exp(bjgb::State::soft(sp + 9), cd) 2322 + d.prob(10) * st.exp(bjgb::State::soft(sp + 10), cd); 2323 exp *= 2; 2324 std::cout << " exp = " << exp << std::flush; 2325 2326 const Double act = bjgc::PlayerTableUtil::eSplit(dt, ht, ot, st, cd, 2 * sp, 2, d, rules); 2327 std::cout << " act = " << act << std::endl; 2328 assert(exp == act); 2329 max3valAA = exp; 2330 } 2331 } 2332 2333 // void bjgc::PlayerTableUtil::populatePlayerTable( 2334 // bjgc::PlayerTable *pt, 2335 // const bjgc::PlayerTable& pxt, 2336 // const bjgc::PlayerTable& pht, 2337 // const bjgc::PlayerTable& pst) 2338 2339 // Strategy is affected by knowing Dealer doesn't have blackjack. 2340 // Expected value of game play is therefore affected by overall strategy. 2341 // I. The dealer does not have an ACE or a TEN. In this case the 2342 // adjusted values and the regular values are the same. 2343 // II. Dealer has a: 2344 // 1 ACE 2345 // d.prob(10) 2346 // e_CBJ ? 0 : -1 2347 // 1 - d.prob(10) 2348 // whatever the hand says 2349 // 2. TEN 2350 // d.prob(1) 2351 // e_CBJ ? 0 : -1 2352 // 1 - d.prob(1) 2353 // whatever the hand says 2354 // 2355 // The player table is the probability of winning given a two card hand. 2356 // You can always stick, so the base line is the stick strategy. If 2357 // hitting is an improvement, then you hit. If doubling is then an 2358 // improvement, then you double. Finally if the hand is splittable, 2359 // we do that instead of the regular entry. But there's a catch: The 2360 // way we play against a TEN or an ACE has to be adjusted. For example, 2361 // if the dealer has an ace, then roughly 4/13 times the player will 2362 // a 10 and player will tie with a blackjack and expect -1 otherwise. 2363 // Roughly 9/13 times the player will win according to the adjusted table. 2364 // So we don't need the regular table UNLESS a player can lose more 2365 // on a double, then we just use the that table straight. 2366 2367 std::cout << "===============================================\n"; 2368 std::cout << "=============== Unadjusted ptab ===============\n"; 2369 std::cout << "===============================================\n"; 2370 2371 // pxtab is pdtab augmented with split information. 2372 2373 bjgc::PlayerTable ptab; 2374 ptab.reset(); 2375 bjgc::PlayerTableUtil::populatePlayerTable(&ptab, pxtab, phtab, pstab, rules); 2376 std::cout << ptab << '\n'; 2377 assert(ptab.exp(bjgb::State::hard(20), 8) == pstab.exp(bjgb::State::hard(20), 8)); 2378 2379 std::cout << "pstab.hd(h( 4), u( 8)) = " << pstab.exp(bjgb::State::hard(4), 8) << "\n"; 2380 2381 std::cout << "phtab.hd(h( 4), u( 8)) = " << phtab.exp(bjgb::State::hard(4), 8) << "\n"; 2382 2383 std::cout << "p1tab.hd(h( 4), u( 8)) = " << p1tab.exp(bjgb::State::hard(4), 8) << "\n"; 2384 2385 std::cout << "pdtab.hd(h( 4), u( 8)) = " << pdtab.exp(bjgb::State::hard(4), 8) << "\n"; 2386 2387 std::cout << " ptab.hd(h( 4), u( 8)) = " << ptab.exp(bjgb::State::hard(4), 8) << "\n"; 2388 2389 assert(ptab.exp(bjgb::State::hard(4), 10) == phtab.exp(bjgb::State::hard(4), 10)); 2390 2391 std::cout << "pstab.hd(h(11), u( 8)) = " << pstab.exp(bjgb::State::hard(11), 8) << "\n"; 2392 2393 std::cout << "phtab.hd(h(11), u( 8)) = " << phtab.exp(bjgb::State::hard(11), 8) << "\n"; 2394 2395 std::cout << "p1tab.hd(h(11), u( 8)) = " << p1tab.exp(bjgb::State::hard(11), 8) << "\n"; 2396 2397 std::cout << "pdtab.hd(h(11), u( 8)) = " << pdtab.exp(bjgb::State::hard(11), 8) << "\n"; 2398 2399 std::cout << " ptab.hd(h(11), u( 8)) = " << ptab.exp(bjgb::State::hard(11), 8) << "\n"; 2400 2401 assert(ptab.exp(bjgb::State::hard(11), 8) == pxtab.exp(bjgb::State::hard(11), 8)); 2402 2403 assert(ptab.exp(bjgb::State::soft(10), 5) == pstab.exp(bjgb::State::soft(10), 5)); 2404 // assert(ptab.exp(bjgb::State::soft(3), 5) 2405 // == phtab.exp(bjgb::State::soft(3), 5)); // EVEN 2406 assert(ptab.exp(bjgb::State::soft(8), 5) == pxtab.exp(bjgb::State::soft(8), 5)); 2407 2408 assert(ptab.exp(bjgb::State::e_SBJ, 10) == pstab.exp(bjgb::State::e_SBJ, 10)); 2409 assert(ptab.exp(bjgb::State::e_SBJ, 6) == pstab.exp(bjgb::State::e_SBJ, 6)); 2410 assert(ptab.exp(bjgb::State::e_SBJ, 1) == pstab.exp(bjgb::State::e_SBJ, 1)); 2411 2412 assert(ptab.exp(bjgb::State::pair(1), 10) == pxtab.exp(bjgb::State::pair(1), 10)); 2413 assert(ptab.exp(bjgb::State::pair(5), 9) == pxtab.exp(bjgb::State::pair(5), 9)); 2414 assert(ptab.exp(bjgb::State::pair(10), 1) == pxtab.exp(bjgb::State::pair(10), 1)); 2415 2416 std::cout << "===============================================\n"; 2417 std::cout << "================ adjusted ptab2 ===============\n"; 2418 std::cout << "===============================================\n"; 2419 2420 bjgc::PlayerTable ptab2; 2421 ptab2.reset(); 2422 bjgc::PlayerTableUtil::populatePlayerTable(&ptab2, pxtab2, phtab2, pstab2, rules); 2423 std::cout << ptab2 << '\n'; 2424 2425 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 2426 // THESE TESTS ARE DESIGNED SPECIFICALLY TO CHECK CLOSE HANDS: 2427 // ___________________________________________________________ 2428 2429 std::cout << "\nrichness = " << bjgb::ShoeUtil::tenRichness(d) << std::endl; 2430 2431 if (0 != bjgb::ShoeUtil::tenRichness(d)) { 2432 std::cout << "\t=====================\n" 2433 "\tSKIPPING CLOSE COUNTS\n" 2434 "\t=====================\n"; 2435 } else { 2436 // HARD COUNTS 2437 2438 // double 2439 assert(ptab2.exp(bjgb::State::hard(11), 10) == pdtab2.exp(bjgb::State::hard(11), 10)); 2440 2441 std::cout << "pstab2.hd(h(11), u( 1)) = " << pstab2.exp(bjgb::State::hard(11), 1) << "\n"; 2442 2443 std::cout << "phtab2.hd(h(11), u( 1)) = " << phtab2.exp(bjgb::State::hard(11), 1) << "\n"; 2444 2445 std::cout << "p1tab2.hd(h(11), u( 1)) = " << p1tab2.exp(bjgb::State::hard(11), 1) << "\n"; 2446 2447 std::cout << "pdtab2.hd(h(11), u( 1)) = " << pdtab2.exp(bjgb::State::hard(11), 1) << "\n"; 2448 2449 std::cout << " ptab2.hd(h(11), u( 1)) = " << ptab2.exp(bjgb::State::hard(11), 1) << "\n"; 2450 2451 if (rules.dealerStandsOnSoft17()) { 2452 assert(ptab2.exp(bjgb::State::hard(11), 1) == phtab2.exp(bjgb::State::hard(11), 1)); // EVEN 2453 } else { 2454 assert(ptab2.exp(bjgb::State::hard(11), 1) == pdtab2.exp(bjgb::State::hard(11), 1)); 2455 } 2456 2457 assert(ptab2.exp(bjgb::State::hard(10), 2) == pdtab2.exp(bjgb::State::hard(10), 2)); 2458 assert(ptab2.exp(bjgb::State::hard(10), 9) == pdtab2.exp(bjgb::State::hard(10), 9)); 2459 assert(ptab2.exp(bjgb::State::hard(9), 6) == pdtab2.exp(bjgb::State::hard(9), 6)); 2460 2461 std::cout << "pstab2.hd(h( 9), u( 4)) = " << pstab2.exp(bjgb::State::hard(9), 4) << "\n"; 2462 2463 std::cout << "phtab2.hd(h( 9), u( 4)) = " << phtab2.exp(bjgb::State::hard(9), 4) << "\n"; 2464 2465 std::cout << "p1tab2.hd(h( 9), u( 4)) = " << p1tab2.exp(bjgb::State::hard(9), 4) << "\n"; 2466 2467 std::cout << "pdtab2.hd(h( 9), u( 4)) = " << pdtab2.exp(bjgb::State::hard(9), 4) << "\n"; 2468 2469 std::cout << " ptab2.hd(h( 9), u( 4)) = " << ptab2.exp(bjgb::State::hard(9), 4) << "\n"; 2470 2471 assert(ptab2.exp(bjgb::State::hard(9), 4) == pdtab2.exp(bjgb::State::hard(9), 4)); 2472 2473 std::cout << "pstab2.hd(h( 9), u( 3)) = " << pstab2.exp(bjgb::State::hard(9), 3) << "\n"; 2474 2475 std::cout << "phtab2.hd(h( 9), u( 3)) = " << phtab2.exp(bjgb::State::hard(9), 3) << "\n"; 2476 2477 std::cout << "p1tab2.hd(h( 9), u( 3)) = " << p1tab2.exp(bjgb::State::hard(9), 3) << "\n"; 2478 2479 std::cout << "pdtab2.hd(h( 9), u( 3)) = " << pdtab2.exp(bjgb::State::hard(9), 3) << "\n"; 2480 2481 std::cout << " ptab2.hd(h( 9), u( 3)) = " << ptab2.exp(bjgb::State::hard(9), 3) << "\n"; 2482 2483 assert(ptab2.exp(bjgb::State::hard(9), 3) == pdtab2.exp(bjgb::State::hard(9), 3)); 2484 2485 // hit 2486 assert(ptab2.exp(bjgb::State::hard(16), 10) == phtab2.exp(bjgb::State::hard(16), 10)); // EVEN 2487 assert(ptab2.exp(bjgb::State::hard(10), 10) == phtab2.exp(bjgb::State::hard(10), 10)); 2488 assert(ptab2.exp(bjgb::State::hard(9), 9) == phtab2.exp(bjgb::State::hard(9), 9)); 2489 assert(ptab2.exp(bjgb::State::hard(12), 2) == phtab2.exp(bjgb::State::hard(12), 2)); // EVEN 2490 assert(ptab2.exp(bjgb::State::hard(12), 3) == phtab2.exp(bjgb::State::hard(12), 3)); // EVEN 2491 assert(ptab2.exp(bjgb::State::hard(9), 2) == phtab2.exp(bjgb::State::hard(9), 2)); 2492 2493 // stand 2494 assert(ptab2.exp(bjgb::State::hard(17), 10) == pstab2.exp(bjgb::State::hard(17), 10)); 2495 assert(ptab2.exp(bjgb::State::hard(12), 4) == pstab2.exp(bjgb::State::hard(12), 4)); 2496 assert(ptab2.exp(bjgb::State::hard(13), 2) == pstab2.exp(bjgb::State::hard(13), 2)); 2497 2498 // SOFT COUNTS 2499 2500 // double 2501 assert(ptab2.exp(bjgb::State::soft(8), 6) == pdtab2.exp(bjgb::State::soft(8), 6)); 2502 assert(ptab2.exp(bjgb::State::soft(8), 3) == pdtab2.exp(bjgb::State::soft(8), 3)); 2503 assert(ptab2.exp(bjgb::State::soft(7), 4) == pdtab2.exp(bjgb::State::soft(7), 4)); 2504 2505 // hit 2506 assert(ptab2.exp(bjgb::State::soft(3), 4) == phtab2.exp(bjgb::State::soft(3), 4)); 2507 assert(ptab2.exp(bjgb::State::soft(2), 5) == phtab2.exp(bjgb::State::soft(2), 5)); 2508 assert(ptab2.exp(bjgb::State::soft(8), 10) == phtab2.exp(bjgb::State::soft(8), 10)); 2509 assert(ptab2.exp(bjgb::State::soft(8), 9) == phtab2.exp(bjgb::State::soft(8), 9)); 2510 assert(ptab2.exp(bjgb::State::soft(7), 1) == phtab2.exp(bjgb::State::soft(7), 1)); 2511 2512 // stick 2513 assert(ptab2.exp(bjgb::State::soft(8), 8) == pstab2.exp(bjgb::State::soft(8), 8)); 2514 assert(ptab2.exp(bjgb::State::soft(8), 7) == pstab2.exp(bjgb::State::soft(8), 7)); 2515 2516 std::cout << "pstab2.hd(s( 8), u( 2)) = " << pstab2.exp(bjgb::State::soft(8), 2) << "\n"; 2517 2518 std::cout << "phtab2.hd(s( 8), u( 2)) = " << phtab2.exp(bjgb::State::soft(8), 2) << "\n"; 2519 2520 std::cout << "p1tab2.hd(s( 8), u( 2)) = " << p1tab2.exp(bjgb::State::soft(8), 2) << "\n"; 2521 2522 std::cout << "pdtab2.hd(s( 8), u( 2)) = " << pdtab2.exp(bjgb::State::soft(8), 2) << "\n"; 2523 2524 std::cout << " ptab2.hd(s( 8), u( 2)) = " << ptab2.exp(bjgb::State::soft(8), 2) << "\n"; 2525 2526 if (rules.dealerStandsOnSoft17()) { 2527 assert(ptab2.exp(bjgb::State::soft(8), 2) == pstab2.exp(bjgb::State::soft(8), 2)); 2528 } else { 2529 assert(ptab2.exp(bjgb::State::soft(8), 2) == pdtab2.exp(bjgb::State::soft(8), 2)); 2530 } 2531 2532 } // end close counts 2533 2534 // Call function to calculate odds of winning 2535 2536 std::cout << "\t===================\n" 2537 "\tEXPECTED DECK VALUE\n" 2538 "\t===================\n"; 2539 2540 Double eVal = bjgc::PlayerTableUtil::evalShoeImp(d, ptab, ptab2, rules); 2541 2542 std::cout << "\teVal = " << eVal << "\n"; 2543 2544 // start interpreter ? 2545 }