Convert a lot of floating-point constants to single precision

For reasons now lost to history, Puzzles generally uses single-precision
floating point.  However, C floating-point constants are by default
double-precision, and if they're then operated on along with a
single-precision variable the value of the variable gets promoted to
double precision, then the operation gets done, and then often the
result gets converted back to single precision again.

This is obviously silly, so I've used Clang's "-Wdouble-promotion" to
find instances of this and mark the constants as single-precision as
well.  This is a bit awkward for PI, which ends up with a cast.  Maybe
there should be a PIF, or maybe PI should just be single-precision.

This doesn't eliminate all warnings from -Wdouble-promotion.  Some of
the others might merit fixing but adding explicit casts to double just
to shut the compiler up would be going too far, I feel.

1 files changed, 4 insertions, 4 deletions

diff --git a/drawing.c b/drawing.c
index 3584936..5fb8a31 100644
--- a/drawing.c
+++ b/drawing.c
@@ -90,8 +90,8 @@ void draw_line(drawing *dr, int x1, int y1, int x2, int y2, int colour)
 void draw_thick_line(drawing *dr, float thickness,
 		     float x1, float y1, float x2, float y2, int colour)
 {
-    if (thickness < 1.0)
-        thickness = 1.0;
+    if (thickness < 1.0F)
+        thickness = 1.0F;
     if (dr->api->draw_thick_line) {
 	dr->api->draw_thick_line(dr->handle, thickness,
 				 x1, y1, x2, y2, colour);
@@ -101,8 +101,8 @@ void draw_thick_line(drawing *dr, float thickness,
 	 * polygon rendering uses integer coordinates.
 	 */
 	float len = sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
-	float tvhatx = (x2 - x1)/len * (thickness/2 - 0.2);
-	float tvhaty = (y2 - y1)/len * (thickness/2 - 0.2);
+	float tvhatx = (x2 - x1)/len * (thickness/2 - 0.2F);
+	float tvhaty = (y2 - y1)/len * (thickness/2 - 0.2F);
 	int p[8];
 
 	p[0] = x1 - tvhaty;