@@ -4921,8 +4921,11 @@ def test_lines_with_colors(fig_test, fig_ref, data):
                                         colors=expect_color, linewidth=5)
 
 
-@image_comparison(['step_linestyle', 'step_linestyle'], remove_text=True)
+@image_comparison(['step_linestyle', 'step_linestyle'], remove_text=True,
+                  tol=0.2)
 def test_step_linestyle():
+    # Tolerance caused by reordering of floating-point operations
+    # Remove when regenerating the images
     x = y = np.arange(10)
 
     # First illustrate basic pyplot interface, using defaults where possible.
 
@@ -101,8 +101,10 @@ def test_invalid_line_data():
         line.set_ydata(0)
 
 
-@image_comparison(['line_dashes'], remove_text=True)
+@image_comparison(['line_dashes'], remove_text=True, tol=0.002)
 def test_line_dashes():
+    # Tolerance introduced after reordering of floating-point operations
+    # Remove when regenerating the images
     fig, ax = plt.subplots()
 
     ax.plot(range(10), linestyle=(0, (3, 3)), lw=5)
 
@@ -745,7 +745,7 @@ inline void RendererAgg::draw_text_image(GCAgg &gc, ImageArray &image, int x, in
 
         agg::trans_affine mtx;
         mtx *= agg::trans_affine_translation(0, -image.dim(0));
-        mtx *= agg::trans_affine_rotation(-angle * agg::pi / 180.0);
+        mtx *= agg::trans_affine_rotation(-angle * (agg::pi / 180.0));
         mtx *= agg::trans_affine_translation(x, y);
 
         agg::path_storage rect;
@@ -773,8 +773,10 @@ inline void RendererAgg::draw_text_image(GCAgg &gc, ImageArray &image, int x, in
     } else {
         agg::rect_i fig, text;
 
+        int deltay = y - image.dim(0);
+
         fig.init(0, 0, width, height);
-        text.init(x, y - image.dim(0), x + image.dim(1), y);
+        text.init(x, deltay, x + image.dim(1), y);
         text.clip(fig);
 
         if (gc.cliprect.x1 != 0.0 || gc.cliprect.y1 != 0.0 || gc.cliprect.x2 != 0.0 || gc.cliprect.y2 != 0.0) {
@@ -788,9 +790,11 @@ inline void RendererAgg::draw_text_image(GCAgg &gc, ImageArray &image, int x, in
         }
 
         if (text.x2 > text.x1) {
+            int deltax = text.x2 - text.x1;
+            int deltax2 = text.x1 - x;
             for (int yi = text.y1; yi < text.y2; ++yi) {
-                pixFmt.blend_solid_hspan(text.x1, yi, (text.x2 - text.x1), gc.color,
-                                         &image(yi - (y - image.dim(0)), text.x1 - x));
+                pixFmt.blend_solid_hspan(text.x1, yi, deltax, gc.color,
+                                         &image(yi - deltay, deltax2));
             }
         }
     }
@@ -945,6 +949,7 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
     facepair_t face;
     face.first = Nfacecolors != 0;
     agg::trans_affine trans;
+    bool do_clip = !face.first && !gc.has_hatchpath();
 
     for (int i = 0; i < (int)N; ++i) {
         typename PathGenerator::path_iterator path = path_generator(i);
@@ -992,8 +997,6 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
             }
         }
 
-        bool do_clip = !face.first && !gc.has_hatchpath();
-
         if (check_snap) {
             gc.isaa = antialiaseds(i % Naa);
 
 
@@ -52,18 +52,19 @@ class Dashes
     template <class T>
     void dash_to_stroke(T &stroke, double dpi, bool isaa)
     {
+        double scaleddpi = dpi / 72.0;
         for (dash_t::const_iterator i = dashes.begin(); i != dashes.end(); ++i) {
             double val0 = i->first;
             double val1 = i->second;
-            val0 = val0 * dpi / 72.0;
-            val1 = val1 * dpi / 72.0;
+            val0 = val0 * scaleddpi;
+            val1 = val1 * scaleddpi;
             if (!isaa) {
                 val0 = (int)val0 + 0.5;
                 val1 = (int)val1 + 0.5;
             }
             stroke.add_dash(val0, val1);
         }
-        stroke.dash_start(get_dash_offset() * dpi / 72.0);
+        stroke.dash_start(get_dash_offset() * scaleddpi);
     }
 };
 
 
@@ -236,8 +236,8 @@ ft_outline_move_to(FT_Vector const* to, void* user)
             *(d->vertices++) = 0;
             *(d->codes++) = CLOSEPOLY;
         }
-        *(d->vertices++) = to->x / 64.;
-        *(d->vertices++) = to->y / 64.;
+        *(d->vertices++) = to->x * (1. / 64.);
+        *(d->vertices++) = to->y * (1. / 64.);
         *(d->codes++) = MOVETO;
     }
     d->index += d->index ? 2 : 1;
@@ -249,8 +249,8 @@ ft_outline_line_to(FT_Vector const* to, void* user)
 {
     ft_outline_decomposer* d = reinterpret_cast<ft_outline_decomposer*>(user);
     if (d->codes) {
-        *(d->vertices++) = to->x / 64.;
-        *(d->vertices++) = to->y / 64.;
+        *(d->vertices++) = to->x * (1. / 64.);
+        *(d->vertices++) = to->y * (1. / 64.);
         *(d->codes++) = LINETO;
     }
     d->index++;
@@ -262,10 +262,10 @@ ft_outline_conic_to(FT_Vector const* control, FT_Vector const* to, void* user)
 {
     ft_outline_decomposer* d = reinterpret_cast<ft_outline_decomposer*>(user);
     if (d->codes) {
-        *(d->vertices++) = control->x / 64.;
-        *(d->vertices++) = control->y / 64.;
-        *(d->vertices++) = to->x / 64.;
-        *(d->vertices++) = to->y / 64.;
+        *(d->vertices++) = control->x * (1. / 64.);
+        *(d->vertices++) = control->y * (1. / 64.);
+        *(d->vertices++) = to->x * (1. / 64.);
+        *(d->vertices++) = to->y * (1. / 64.);
         *(d->codes++) = CURVE3;
         *(d->codes++) = CURVE3;
     }
@@ -279,12 +279,12 @@ ft_outline_cubic_to(
 {
     ft_outline_decomposer* d = reinterpret_cast<ft_outline_decomposer*>(user);
     if (d->codes) {
-        *(d->vertices++) = c1->x / 64.;
-        *(d->vertices++) = c1->y / 64.;
-        *(d->vertices++) = c2->x / 64.;
-        *(d->vertices++) = c2->y / 64.;
-        *(d->vertices++) = to->x / 64.;
-        *(d->vertices++) = to->y / 64.;
+        *(d->vertices++) = c1->x * (1. / 64.);
+        *(d->vertices++) = c1->y * (1. / 64.);
+        *(d->vertices++) = c2->x * (1. / 64.);
+        *(d->vertices++) = c2->y * (1. / 64.);
+        *(d->vertices++) = to->x * (1. / 64.);
+        *(d->vertices++) = to->y * (1. / 64.);
         *(d->codes++) = CURVE4;
         *(d->codes++) = CURVE4;
         *(d->codes++) = CURVE4;
@@ -485,13 +485,16 @@ void FT2Font::set_text(
 {
     FT_Matrix matrix; /* transformation matrix */
 
-    angle = angle / 360.0 * 2 * M_PI;
+    angle = angle * (2 * M_PI / 360.0);
 
     // this computes width and height in subpixels so we have to multiply by 64
-    matrix.xx = (FT_Fixed)(cos(angle) * 0x10000L);
-    matrix.xy = (FT_Fixed)(-sin(angle) * 0x10000L);
-    matrix.yx = (FT_Fixed)(sin(angle) * 0x10000L);
-    matrix.yy = (FT_Fixed)(cos(angle) * 0x10000L);
+    double cosangle = cos(angle) * 0x10000L;
+    double sinangle = sin(angle) * 0x10000L;
+
+    matrix.xx = (FT_Fixed)cosangle;
+    matrix.xy = (FT_Fixed)-sinangle;
+    matrix.yx = (FT_Fixed)sinangle;
+    matrix.yy = (FT_Fixed)cosangle;
 
     clear();
 
@@ -762,8 +765,8 @@ void FT2Font::draw_glyphs_to_bitmap(bool antialiased)
         // now, draw to our target surface (convert position)
 
         // bitmap left and top in pixel, string bbox in subpixel
-        FT_Int x = (FT_Int)(bitmap->left - (bbox.xMin / 64.));
-        FT_Int y = (FT_Int)((bbox.yMax / 64.) - bitmap->top + 1);
+        FT_Int x = (FT_Int)(bitmap->left - (bbox.xMin * (1. / 64.)));
+        FT_Int y = (FT_Int)((bbox.yMax * (1. / 64.)) - bitmap->top + 1);
 
         image.draw_bitmap(&bitmap->bitmap, x, y);
     }
@@ -782,8 +785,8 @@ void FT2Font::get_xys(bool antialiased, std::vector<double> &xys)
         FT_BitmapGlyph bitmap = (FT_BitmapGlyph)glyphs[n];
 
         // bitmap left and top in pixel, string bbox in subpixel
-        FT_Int x = (FT_Int)(bitmap->left - bbox.xMin / 64.);
-        FT_Int y = (FT_Int)(bbox.yMax / 64. - bitmap->top + 1);
+        FT_Int x = (FT_Int)(bitmap->left - bbox.xMin * (1. / 64.));
+        FT_Int y = (FT_Int)(bbox.yMax * (1. / 64.) - bitmap->top + 1);
         // make sure the index is non-neg
         x = x < 0 ? 0 : x;
         y = y < 0 ? 0 : y;
Original file line number	Diff line number	Diff line change
`@@ -52,18 +52,19 @@ class Dashes`
`52`	`52`	`template <class T>`
`53`	`53`	`void dash_to_stroke(T &stroke, double dpi, bool isaa)`
`54`	`54`	`{`
	`55`	`+ double scaleddpi = dpi / 72.0;`
`55`	`56`	`for (dash_t::const_iterator i = dashes.begin(); i != dashes.end(); ++i) {`
`56`	`57`	`double val0 = i->first;`
`57`	`58`	`double val1 = i->second;`
`58`		`- val0 = val0 * dpi / 72.0;`
`59`		`- val1 = val1 * dpi / 72.0;`
	`59`	`+ val0 = val0 * scaleddpi;`
	`60`	`+ val1 = val1 * scaleddpi;`
`60`	`61`	`if (!isaa) {`
`61`	`62`	`val0 = (int)val0 + 0.5;`
`62`	`63`	`val1 = (int)val1 + 0.5;`
`63`	`64`	`}`
`64`	`65`	`stroke.add_dash(val0, val1);`
`65`	`66`	`}`
`66`		`- stroke.dash_start(get_dash_offset() * dpi / 72.0);`
	`67`	`+ stroke.dash_start(get_dash_offset() * scaleddpi);`
`67`	`68`	`}`
`68`	`69`	`};`
`69`	`70`