kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-29 16:23:09 +00:00
Code Issues Releases Wiki Activity

Use templetize enum operations for Depth

Browse source 
Instead of hardcoded ones.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2010-08-18 15:58:22 +01:00
parent 4f96f420a3
commit 80bee85d5f
3 changed files with 27 additions and 16 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/depth.h
View file

@ -34,18 +34,4 @@ enum Depth {
}; };
////
//// Inline functions
////
inline void operator+= (Depth &d1, Depth d2) { d1 = Depth(int(d1) + int(d2)); }
inline void operator*= (Depth &d, int i) { d = Depth(int(d) * i); }
inline void operator/= (Depth &d, int i) { d = Depth(int(d) / i); }
inline Depth operator+ (Depth d1, Depth d2) { return Depth(int(d1) + int(d2)); }
inline Depth operator- (Depth d1, Depth d2) { return Depth(int(d1) - int(d2)); }
inline Depth operator* (int i, Depth d) { return Depth(int(d) * i); }
inline Depth operator/ (Depth d, int i) { return Depth(int(d) / i); }
#endif // !defined(DEPTH_H_INCLUDED) #endif // !defined(DEPTH_H_INCLUDED)

4
src/evaluate.cpp
View file

@ -1075,9 +1075,9 @@ namespace {
Value eg = eg_value(v); Value eg = eg_value(v);
ScaleFactor f = sf[eg > Value(0) ? WHITE : BLACK]; ScaleFactor f = sf[eg > Value(0) ? WHITE : BLACK];
Value ev = Value((eg * f) / SCALE_FACTOR_NORMAL); Value ev = Value((eg * int(f)) / SCALE_FACTOR_NORMAL);
int result = (mg_value(v) * ph + ev * (128 - ph)) / 128; int result = (mg_value(v) * int(ph) + ev * int(128 - ph)) / 128;
return Value(result & ~(GrainSize - 1)); return Value(result & ~(GrainSize - 1));
} }

25
src/types.h
View file

@ -109,4 +109,29 @@ inline void __cpuid(int CPUInfo[4], int)
} }
#endif #endif
// Templetized enum operations, we avoid to repeat the same inlines for each
// different enum.
template<typename T>
inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); }
template<typename T>
inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); }
template<typename T>
inline T operator* (int i, const T d) { return T(int(d) * i); }
template<typename T>
inline T operator/ (const T d, int i) { return T(int(d) / i); }
template<typename T>
inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; }
template<typename T>
inline void operator*= (T& d, int i) { d = T(int(d) * i); }
template<typename T>
inline void operator/= (T &d, int i) { d = T(int(d) / i); }
#endif // !defined(TYPES_H_INCLUDED) #endif // !defined(TYPES_H_INCLUDED)