Small formatting improvements

Changes some C style casts to C++ style, and fixes some incorrect comments and variable names.

closes #4845

No functional change

diff --git a/src/bitboard.h b/src/bitboard.h
index 24f6deca8402d0636f5253cc48347d18e790be62..7dbd5329be82abe8caaf5f07b163f8e4234b3a40 100644 (file)
--- a/src/bitboard.h
+++ b/src/bitboard.h
@@ -298,7 +298,7 @@ inline Square lsb(Bitboard b) {
 
     unsigned long idx;
     _BitScanForward64(&idx, b);
-    return (Square) idx;
+    return Square(idx);
 
     #else  // MSVC, WIN32
     unsigned long idx;
@@ -332,7 +332,7 @@ inline Square msb(Bitboard b) {
 
     unsigned long idx;
     _BitScanReverse64(&idx, b);
-    return (Square) idx;
+    return Square(idx);
 
     #else  // MSVC, WIN32
 

diff --git a/src/nnue/evaluate_nnue.cpp b/src/nnue/evaluate_nnue.cpp
index ea53a5102fa1eef9799c657b2114b26542e9b19d..e29d3c17b1738f17d8796f3fd7571277626d39d2 100644 (file)
--- a/src/nnue/evaluate_nnue.cpp
+++ b/src/nnue/evaluate_nnue.cpp
@@ -116,7 +116,7 @@ static bool read_header(std::istream& stream, std::uint32_t* hashValue, std::str
 static bool write_header(std::ostream& stream, std::uint32_t hashValue, const std::string& desc) {
     write_little_endian<std::uint32_t>(stream, Version);
     write_little_endian<std::uint32_t>(stream, hashValue);
-    write_little_endian<std::uint32_t>(stream, (std::uint32_t) desc.size());
+    write_little_endian<std::uint32_t>(stream, std::uint32_t(desc.size()));
     stream.write(&desc[0], desc.size());
     return !stream.fail();
 }

diff --git a/src/nnue/layers/sqr_clipped_relu.h b/src/nnue/layers/sqr_clipped_relu.h
index 987de892f3d52f0780fbae05f1b457802c39b64e..f8e2d497ac0b0b826bd955e2b5bfd986373fcaa8 100644 (file)
--- a/src/nnue/layers/sqr_clipped_relu.h
+++ b/src/nnue/layers/sqr_clipped_relu.h
@@ -93,7 +93,7 @@ class SqrClippedReLU {
             output[i] = static_cast<OutputType>(
               // Really should be /127 but we need to make it fast so we right shift
               // by an extra 7 bits instead. Needs to be accounted for in the trainer.
-              std::min(127ll, ((long long) input[i] * input[i]) >> (2 * WeightScaleBits + 7)));
+              std::min(127ll, ((long long) (input[i]) * input[i]) >> (2 * WeightScaleBits + 7)));
         }
     }
 };

diff --git a/src/nnue/nnue_common.h b/src/nnue/nnue_common.h
index cf90850126b55b90e3ddd646d656066c44fddc11..f9cd7fbb5973928d9a1edb1f89111e2a0a3263a8 100644 (file)
--- a/src/nnue/nnue_common.h
+++ b/src/nnue/nnue_common.h
@@ -130,11 +130,11 @@ inline void write_little_endian(std::ostream& stream, IntType value) {
         {
             for (; i + 1 < sizeof(IntType); ++i)
             {
-                u[i] = (std::uint8_t) v;
+                u[i] = std::uint8_t(v);
                 v >>= 8;
             }
         }
-        u[i] = (std::uint8_t) v;
+        u[i] = std::uint8_t(v);
 
         stream.write(reinterpret_cast<char*>(u), sizeof(IntType));
     }

diff --git a/src/search.cpp b/src/search.cpp
index d5416e407599d03e9c46b56b64297f6de5be57c7..4b390713d8d3c721d720c79497c2a556cd63b0ea 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -279,9 +279,9 @@ void MainThread::search() {
 // consumed, the user stops the search, or the maximum search depth is reached.
 void Thread::search() {
 
-    // Allocate stack with extra size to allow access from (ss-7) to (ss+2):
-    // (ss-7) is needed for update_continuation_histories(ss-1) which accesses (ss-6),
-    // (ss+2) is needed for initialization of statScore and killers.
+    // Allocate stack with extra size to allow access from (ss - 7) to (ss + 2):
+    // (ss - 7) is needed for update_continuation_histories(ss - 1) which accesses (ss - 6),
+    // (ss + 2) is needed for initialization of cutOffCnt and killers.
     Stack       stack[MAX_PLY + 10], *ss = stack + 7;
     Move        pv[MAX_PLY + 1];
     Value       alpha, beta, delta;
@@ -363,13 +363,13 @@ void Thread::search() {
             selDepth = 0;
 
             // Reset aspiration window starting size
-            Value prev = rootMoves[pvIdx].averageScore;
-            delta      = Value(10) + int(prev) * prev / 17470;
-            alpha      = std::max(prev - delta, -VALUE_INFINITE);
-            beta       = std::min(prev + delta, VALUE_INFINITE);
+            Value avg = rootMoves[pvIdx].averageScore;
+            delta     = Value(10) + int(avg) * avg / 17470;
+            alpha     = std::max(avg - delta, -VALUE_INFINITE);
+            beta      = std::min(avg + delta, VALUE_INFINITE);
 
-            // Adjust optimism based on root move's previousScore (~4 Elo)
-            int opt       = 113 * prev / (std::abs(prev) + 109);
+            // Adjust optimism based on root move's averageScore (~4 Elo)
+            int opt       = 113 * avg / (std::abs(avg) + 109);
             optimism[us]  = Value(opt);
             optimism[~us] = -optimism[us];
 
@@ -582,7 +582,7 @@ Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, boo
                                                         : value_draw(pos.this_thread());
 
         // Step 3. Mate distance pruning. Even if we mate at the next move our score
-        // would be at best mate_in(ss->ply+1), but if alpha is already bigger because
+        // would be at best mate_in(ss->ply + 1), but if alpha is already bigger because
         // a shorter mate was found upward in the tree then there is no need to search
         // because we will never beat the current alpha. Same logic but with reversed
         // signs apply also in the opposite condition of being mated instead of giving