Instead of hardcoded ones.
No functional change.
Signed-off-by: Marco Costalba <mcostalba@gmail.com>
};
-////
-//// 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)
Value eg = eg_value(v);
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));
}
}
#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)