Index: tab/tabinterp.c
===================================================================
--- tab/tabinterp.c	(revision 54067)
+++ tab/tabinterp.c	(working copy)
@@ -810,7 +810,7 @@
 	linear_interpolate(chp, times);
 
     if (chp->c_periodic
-	&& !ZERO(chp->c_ival[0] - chp->c_ival[chp->c_ilen-1]))
+	&& !EQUAL(chp->c_ival[0], chp->c_ival[chp->c_ilen-1]))
     {
 	bu_log("spline(%s): endpoints don't match, replacing final data value\n", chp->c_itag);
 	chp->c_ival[chp->c_ilen-1] = chp->c_ival[0];
Index: util/pl-ps.c
===================================================================
--- util/pl-ps.c	(revision 54067)
+++ util/pl-ps.c	(working copy)
@@ -216,7 +216,7 @@
      * without a move command in between.  We
      * really need a better solution. - XXX
      */
-    if (ZERO(lastx - x) && ZERO(lasty - y)) { /* lastx == x && lasty == y */
+    if (EQUAL(lastx, x) && EQUAL(lasty, y)) { /* lastx == x && lasty == y */
 	printf("DFntM (%s) show\n", str);
 
     } else {
Index: util/loop.c
===================================================================
--- util/loop.c	(revision 54067)
+++ util/loop.c	(working copy)
@@ -93,7 +93,7 @@
     for (i = 1; i < argc; i++) {
 	double dval = atof(argv[i]);
 	long int ival = strtol(argv[i],NULL,0);
-	if (!ZERO(dval - (double)ival)) {
+	if (!EQUAL(dval, (double)ival)) {
 	    status = REAL;
 	    break;
 	}
Index: util/pixbackgnd.c
===================================================================
--- util/pixbackgnd.c	(revision 54067)
+++ util/pixbackgnd.c	(working copy)
@@ -73,19 +73,19 @@
     v = ((v > b) ? v : b);
     x = ((r < g) ? r : g);
     x = ((x < b) ? x : b);
-    if (!ZERO(v - x)) { /* v != x */
+    if (!EQUAL(v, x)) { /* v != x */
 	dif = (double)(v - x);
-	if (!ZERO(r - v)) /* r != v */
-	    if (ZERO(g - v)) /* g == v */
-		if (!ZERO(b - x)) /* b != x */
+	if (!EQUAL(r, v)) /* r != v */
+	    if (EQUAL(g, v)) /* g == v */
+		if (!EQUAL(b, x)) /* b != x */
 		    h = (double)(42.5 * (3. - (double)(v-b) / dif));
 		else
 		    h = (double)(42.5 * (1. + (double)(v-r) / dif));
-	    else if (!ZERO(r - x)) /* r != x */
+	    else if (!EQUAL(r, x)) /* r != x */
 		h = (double)(42.5 * (5. - (double)(v-r) / dif));
 	    else
 		h = (double)(42.5 * (3. + (double)(v-g) / dif));
-	else if (!ZERO(g - x)) /* g != x */
+	else if (!EQUAL(g, x)) /* g != x */
 	    h = (double)(42.5 * (1. - (double)(v-g) / dif));
 	else
 	    h = (double)(42.5 * (5. + (double)(v-b) / dif));
Index: util/pixborder.c
===================================================================
--- util/pixborder.c	(revision 54067)
+++ util/pixborder.c	(working copy)
@@ -179,11 +179,11 @@
     if (ZERO(*sat))
 	*hue = ACHROMATIC;
     else {
-	if (ZERO(red - max)) /* red == max */
+	if (EQUAL(red, max)) /* red == max */
 	    *hue = (grn - blu) / delta;
-	else if (ZERO(grn - max)) /* grn == max */
+	else if (EQUAL(grn, max)) /* grn == max */
 	    *hue = 2.0 + (blu - red) / delta;
-	else if (ZERO(blu - max)) /* blu == max */
+	else if (EQUAL(blu, max)) /* blu == max */
 	    *hue = 4.0 + (red - grn) / delta;
 
 	/*
@@ -214,7 +214,7 @@
     val = hsv[VAL];
 
     if (ZERO(sat)) {
-	if (ZERO(hue - ACHROMATIC)) { /* hue == ACHROMATIC */
+	if (EQUAL(hue, ACHROMATIC)) { /* hue == ACHROMATIC */
 	    VSETALL(float_rgb, val);
 	} else {
 	    (void) fprintf(stderr, "Illegal HSV (%g, %g, %g)\n",
@@ -222,7 +222,7 @@
 	    return 0;
 	}
     } else {
-	if (ZERO(hue - 360.0)) /* hue == 360.0 */
+	if (EQUAL(hue, 360.0)) /* hue == 360.0 */
 	    hue = 0.0;
 	hue /= 60.0;
 	hue_int = floor((double) hue);
Index: libtclcad/tclcad_obj.c
===================================================================
--- libtclcad/tclcad_obj.c	(revision 54067)
+++ libtclcad/tclcad_obj.c	(working copy)
@@ -12908,7 +12908,7 @@
 
 	    FOR_ALL_SOLIDS(sp, &gdlp->gdl_headSolid) {
 		/* already drawn above */
-		if (ZERO(sp->s_transparency - 1.0))
+		if (EQUAL(sp->s_transparency, 1.0))
 		    continue;
 
 		if (line_style != sp->s_soldash) {
Index: libged/ps.c
===================================================================
--- libged/ps.c	(revision 54067)
+++ libged/ps.c	(working copy)
@@ -247,7 +247,7 @@
 	VSET(l, -1.0, -1.0, -1.0);
 	VSET(h, 1.0, 1.0, 200.0);
 
-	if (ZERO(gedp->ged_gvp->gv_eye_pos[Z] - 1.0)) {
+	if (EQUAL(gedp->ged_gvp->gv_eye_pos[Z], 1.0)) {
 	    /* This way works, with reasonable Z-clipping */
 	    ged_persp_mat(perspective_mat, gedp->ged_gvp->gv_perspective,
 			  (fastf_t)1.0f, (fastf_t)0.01f, (fastf_t)1.0e10f, (fastf_t)1.0f);
Index: libged/bot_dump.c
===================================================================
--- libged/bot_dump.c	(revision 54067)
+++ libged/bot_dump.c	(working copy)
@@ -126,7 +126,7 @@
 	if (gomp->r == red &&
 	    gomp->g == green &&
 	    gomp->b == blue &&
-	    ZERO(gomp->a - transparency)) {
+	    EQUAL(gomp->a, transparency)) {
 	    return gomp;
 	}
     }
Index: libged/red.c
===================================================================
--- libged/red.c	(revision 54067)
+++ libged/red.c	(working copy)
@@ -83,7 +83,7 @@
     for (k = 0; k < 16; k++) {
 	sprintf(buf, "%g", matrix[k]);
 	tmp = atof(buf);
-	if (ZERO(tmp - matrix[k]))
+	if (EQUAL(tmp, matrix[k]))
 	    fprintf(fp, " %g", matrix[k]);
 	else
 	    fprintf(fp, " %.12e", matrix[k]);
Index: libged/gqa.c
===================================================================
--- libged/gqa.c	(revision 54067)
+++ libged/gqa.c	(working copy)
@@ -1628,7 +1628,7 @@
 	}
     }
 
-    if (!ZERO(newGridSpacing - gridSpacing)) {
+    if (!EQUAL(newGridSpacing, gridSpacing)) {
 	bu_vls_printf(_ged_current_gedp->ged_result_str, "Grid spacing %g %s is does not allow %g samples per axis\n",
 		      gridSpacing / units[LINE]->val, units[LINE]->name, Samples_per_model_axis - 1);
 
@@ -1641,7 +1641,7 @@
     /* if the vol/weight tolerances are not set, pick something */
     if (analysis_flags & ANALYSIS_VOLUME) {
 	char *name = "volume.pl";
-	if (ZERO(volume_tolerance - 1.0)) {
+	if (EQUAL(volume_tolerance, 1.0)) {
 	    volume_tolerance = span[X] * span[Y] * span[Z] * 0.001;
 	    bu_vls_printf(_ged_current_gedp->ged_result_str, "setting volume tolerance to %g %s\n",
 			  volume_tolerance / units[VOL]->val, units[VOL]->name);
@@ -1653,7 +1653,7 @@
 	    }
     }
     if (analysis_flags & ANALYSIS_WEIGHT) {
-	if (ZERO(weight_tolerance - 1.0)) {
+	if (EQUAL(weight_tolerance, 1.0)) {
 	    double max_den = 0.0;
 	    int i;
 	    for (i = 0; i < num_densities; i++) {
Index: libged/get_comb.c
===================================================================
--- libged/get_comb.c	(revision 54067)
+++ libged/get_comb.c	(working copy)
@@ -180,7 +180,7 @@
     for (k = 0; k < 16; k++) {
 	sprintf(buf, "%g", matrix[k]);
 	tmp = atof(buf);
-	if (ZERO(tmp - matrix[k]))
+	if (EQUAL(tmp, matrix[k]))
 	    bu_vls_printf(vls, " %g", matrix[k]);
 	else
 	    bu_vls_printf(vls, " %.12e", matrix[k]);
Index: libged/tire.c
===================================================================
--- libged/tire.c	(revision 54067)
+++ libged/tire.c	(working copy)
@@ -1211,7 +1211,7 @@
     VSET(height, 0, dytred, 0);
     bu_vls_sprintf(&str, "InnerSolid%s.s", suffix);
     mk_rcc(file, bu_vls_addr(&str), vertex, height, ztire-dztred);
-    if (!ZERO(dytred/2 - dyhub/2)) {
+    if (!EQUAL(dytred/2, dyhub/2)) {
 	VSET(normal, 0, 1, 0);
 	bu_vls_sprintf(&str, "LeftCone%s.s", suffix);
 	mk_cone(file, bu_vls_addr(&str), vertex, normal, dytred / 2 - dyhub / 2,
@@ -1230,14 +1230,14 @@
     bu_vls_sprintf(&str, "InnerSolid%s.s", suffix);
     (void)mk_addmember(bu_vls_addr(&str), &innersolid.l, NULL, WMOP_UNION);
     if ((dytred / 2 - dyhub / 2) > 0 &&
-	!ZERO(dytred / 2 - dyhub / 2)) {
+	!EQUAL(dytred / 2, dyhub / 2)) {
 	bu_vls_sprintf(&str, "LeftCone%s.s", suffix);
 	(void)mk_addmember(bu_vls_addr(&str), &innersolid.l, NULL, WMOP_SUBTRACT);
 	bu_vls_sprintf(&str, "RightCone%s.s", suffix);
 	(void)mk_addmember(bu_vls_addr(&str), &innersolid.l, NULL, WMOP_SUBTRACT);
     }
     if ((dytred / 2 - dyhub / 2) < 0 &&
-	!ZERO(dytred / 2 - dyhub / 2)) {
+	!EQUAL(dytred / 2, dyhub / 2)) {
 	bu_vls_sprintf(&str, "LeftCone%s.s", suffix);
 	(void)mk_addmember(bu_vls_addr(&str), &innersolid.l, NULL, WMOP_UNION);
 	bu_vls_sprintf(&str, "RightCone%s.s", suffix);
Index: libged/bigE.c
===================================================================
--- libged/bigE.c	(revision 54067)
+++ libged/bigE.c	(working copy)
@@ -463,8 +463,8 @@
 		    continue;
 		}
 
-		if (ZERO(a->seg_in.hit_dist - b->seg_in.hit_dist)
-		    && ZERO(a->seg_out.hit_dist - b->seg_out.hit_dist))
+		if (EQUAL(a->seg_in.hit_dist, b->seg_in.hit_dist)
+		    && EQUAL(a->seg_out.hit_dist, b->seg_out.hit_dist))
 		{
 		    a->seg_stp = ON_SURF;
 		    tmp = b;
@@ -474,7 +474,7 @@
 			continue;;
 		}
 
-		if (ZERO(a->seg_out.hit_dist - b->seg_out.hit_dist))
+		if (EQUAL(a->seg_out.hit_dist, b->seg_out.hit_dist))
 		    a->seg_out.hit_dist = b->seg_in.hit_dist;
 		else if (a->seg_out.hit_dist < b->seg_out.hit_dist) {
 		    if (b->seg_in.hit_dist > a->seg_in.hit_dist)
@@ -486,7 +486,7 @@
 			RT_FREE_SEG(tmp, dgcdp->ap->a_resource);
 			break;
 		    }
-		} else if (ZERO(a->seg_in.hit_dist - b->seg_in.hit_dist)) {
+		} else if (EQUAL(a->seg_in.hit_dist, b->seg_in.hit_dist)) {
 		    fastf_t tmp_dist;
 
 		    tmp_dist = a->seg_out.hit_dist;
@@ -508,8 +508,8 @@
 		    continue;
 		}
 
-		if (ZERO(b->seg_in.hit_dist - a->seg_in.hit_dist)
-		    && ZERO(b->seg_out.hit_dist - a->seg_out.hit_dist))
+		if (EQUAL(b->seg_in.hit_dist, a->seg_in.hit_dist)
+		    && EQUAL(b->seg_out.hit_dist, a->seg_out.hit_dist))
 		{
 		    b->seg_stp = ON_SURF;
 		    tmp = a;
@@ -519,7 +519,7 @@
 		    break;
 		}
 
-		if (ZERO(b->seg_out.hit_dist - a->seg_out.hit_dist)) {
+		if (EQUAL(b->seg_out.hit_dist, a->seg_out.hit_dist)) {
 		    tmp = b;
 		    b = BU_LIST_PNEXT(seg, &b->l);
 		    BU_LIST_DEQUEUE(&tmp->l);
@@ -534,7 +534,7 @@
 			RT_FREE_SEG(tmp, dgcdp->ap->a_resource);
 			continue;
 		    }
-		} else if (ZERO(b->seg_in.hit_dist - a->seg_in.hit_dist)) {
+		} else if (EQUAL(b->seg_in.hit_dist, a->seg_in.hit_dist)) {
 		    b->seg_in.hit_dist = a->seg_out.hit_dist;
 		} else {
 		    RT_GET_SEG(tmp, dgcdp->ap->a_resource);
@@ -559,8 +559,8 @@
 	    bu_log("\tfound overlapping ON_INT segs:\n");
 #endif
 
-	    if (ZERO(a->seg_in.hit_dist - b->seg_in.hit_dist)
-		&& ZERO(a->seg_out.hit_dist - b->seg_out.hit_dist))
+	    if (EQUAL(a->seg_in.hit_dist, b->seg_in.hit_dist)
+		&& EQUAL(a->seg_out.hit_dist, b->seg_out.hit_dist))
 	    {
 #ifdef debug
 		bu_log("Promoting A, eliminating B\n");
@@ -572,7 +572,7 @@
 		break;
 	    }
 
-	    if (ZERO(a->seg_out.hit_dist - b->seg_out.hit_dist)) {
+	    if (EQUAL(a->seg_out.hit_dist, b->seg_out.hit_dist)) {
 		b->seg_stp = ON_SURF;
 		a->seg_out.hit_dist = b->seg_in.hit_dist;
 
@@ -601,7 +601,7 @@
 #endif
 		}
 	    } else {
-		if (ZERO(a->seg_in.hit_dist - b->seg_in.hit_dist)) {
+		if (EQUAL(a->seg_in.hit_dist, b->seg_in.hit_dist)) {
 		    fastf_t tmp_dist;
 
 		    tmp_dist = a->seg_out.hit_dist;
Index: libged/inside.c
===================================================================
--- libged/inside.c	(revision 54067)
+++ libged/inside.c	(working copy)
@@ -548,7 +548,7 @@
 	    else
 		ratio = ratio2;
 
-	    if (ZERO(ratio1 - ratio) && ratio1 < 1.0) /* c vector must go to zero */
+	    if (EQUAL(ratio1, ratio) && ratio1 < 1.0) /* c vector must go to zero */
 		new_mag_c = SQRT_SMALL_FASTF;
 	    else if (ratio1 > ratio && ratio < 1.0) {
 		/* vector d will go to zero, but vector c will not */
@@ -561,7 +561,7 @@
 	    } else /* just change c vector length by delta */
 		new_mag_c -= delta_ac;
 
-	    if (ZERO(ratio2 - ratio) && ratio2 < 1.0) /* vector d must go to zero */
+	    if (EQUAL(ratio2, ratio) && ratio2 < 1.0) /* vector d must go to zero */
 		new_mag_d = SQRT_SMALL_FASTF;
 	    else if (ratio2 > ratio && ratio < 1.0) {
 		/* calculate vector length at new top vertex */
@@ -595,7 +595,7 @@
 	    else
 		ratio = ratio2;
 
-	    if (ZERO(ratio1 - ratio) && ratio1 < 1.0) /* vector a must go to zero */
+	    if (EQUAL(ratio1, ratio) && ratio1 < 1.0) /* vector a must go to zero */
 		new_mag_a = SQRT_SMALL_FASTF;
 	    else if (ratio1 > ratio && ratio < 1.0) {
 		/* calculate length of vector a if it were at new base location */
@@ -606,7 +606,7 @@
 	    } else /* just subtract delta */
 		new_mag_a -= delta_ac;
 
-	    if (ZERO(ratio2 - ratio) && ratio2 < 1.0) /* vector b must go to zero */
+	    if (EQUAL(ratio2, ratio) && ratio2 < 1.0) /* vector b must go to zero */
 		new_mag_b = SQRT_SMALL_FASTF;
 	    else if (ratio2 > ratio && ratio < 1.0) {
 		/* Calculate length of b if it were at new base vector */
Index: libged/png.c
===================================================================
--- libged/png.c	(revision 54067)
+++ libged/png.c	(working copy)
@@ -292,7 +292,7 @@
 	VSET(l, -1.0, -1.0, -1.0);
 	VSET(h, 1.0, 1.0, 200.0);
 
-	if (ZERO(gedp->ged_gvp->gv_eye_pos[Z] - 1.0)) {
+	if (EQUAL(gedp->ged_gvp->gv_eye_pos[Z], 1.0)) {
 	    /* This way works, with reasonable Z-clipping */
 	    ged_persp_mat(perspective_mat, gedp->ged_gvp->gv_perspective,
 			  (fastf_t)1.0f, (fastf_t)0.01f, (fastf_t)1.0e10f, (fastf_t)1.0f);
Index: libbn/tabdata.c
===================================================================
--- libbn/tabdata.c	(revision 54067)
+++ libbn/tabdata.c	(working copy)
@@ -1228,7 +1228,7 @@
 	    break;
 	}
 	/* Both have remaining elements, take lower one */
-	if (ZERO(a->x[i] - b->x[j]))  {
+	if (EQUAL(a->x[i], b->x[j]))  {
 	    newtab->x[k++] = a->x[i++];
 	    j++;		/* compress out duplicate */
 	    continue;
Index: libbn/mat.c
===================================================================
--- libbn/mat.c	(revision 54067)
+++ libbn/mat.c	(working copy)
@@ -297,7 +297,7 @@
 {
     register fastf_t inv;
 
-    if (ZERO(h[3] - 1.0)) {
+    if (EQUAL(h[3], 1.0)) {
 	VMOVE(v, h);
     } else {
 	if (ZERO(h[W])) {
@@ -450,17 +450,17 @@
      * result in errors when some codes try to convert this back to
      * azimuth and elevation.  do_frame() uses this technique!!!
      */
-    if (ZERO(alpha_in - 180.0))
+    if (EQUAL(alpha_in, 180.0))
 	salpha = 0.0;
     else
 	salpha = sin(alpha);
 
-    if (ZERO(beta_in - 180.0))
+    if (EQUAL(beta_in, 180.0))
 	sbeta = 0.0;
     else
 	sbeta = sin(beta);
 
-    if (ZERO(ggamma_in - 180.0))
+    if (EQUAL(ggamma_in, 180.0))
 	sgamma = 0.0;
     else
 	sgamma = sin(ggamma);
Index: lgt/ir.c
===================================================================
--- lgt/ir.c	(revision 54067)
+++ lgt/ir.c	(working copy)
@@ -275,7 +275,7 @@
     int	h = (int) hue;	/* integral part	*/
     int	f = (int)(256.0 * (hue - (fastf_t)h));
     /* fractional part * 256	*/
-    if ( ZERO(t - ABSOLUTE_ZERO) )
+    if ( EQUAL(t, ABSOLUTE_ZERO) )
 	rgb[RED] = rgb[GRN] = rgb[BLU] = 0;
     else
 	switch ( h )
Index: lgt/do_options.c
===================================================================
--- lgt/do_options.c	(revision 54067)
+++ lgt/do_options.c	(working copy)
@@ -3398,7 +3398,7 @@
 	(void) fprintf(run_fp,	" -o%s", fb_file);
     if (ir_offset)
 	(void) fprintf(run_fp, " -d\"%d %d\"", ir_mapx, ir_mapy);
-    if (!ZERO(rel_perspective - 0.25))
+    if (!EQUAL(rel_perspective, 0.25))
 	(void) fprintf(run_fp, " -p%g", rel_perspective);
     if (ir_mapping) /* MUST precede -I option. */
 	(void) fprintf(run_fp, " -s%d", ir_mapping);
Index: lgt/reflect.c
===================================================================
--- lgt/reflect.c	(revision 54067)
+++ lgt/reflect.c	(working copy)
@@ -415,8 +415,8 @@
 	assert(a.a_miss == ag.a_miss);
 	assert(a.a_overlap == ag.a_overlap);
 	assert(a.a_rt_i == ag.a_rt_i);
-	assert(ZERO(a.a_rbeam - ag.a_rbeam));
-	assert(ZERO(a.a_diverge - ag.a_diverge));
+	assert(EQUAL(a.a_rbeam, ag.a_rbeam));
+	assert(EQUAL(a.a_diverge, ag.a_diverge));
 	a.a_x = grid_x_org;
 	a.a_y = com;
 	a.a_onehit = false;
@@ -1082,7 +1082,7 @@
     if (entry->refrac_index < 0.001)
 	entry->refrac_index = 1.0;
 
-    if (ZERO(entry->refrac_index - RI_AIR)) {
+    if (EQUAL(entry->refrac_index, RI_AIR)) {
 	/* No refraction necessary. */
 	struct partition *pt_headp = pp->pt_back;
 	if (RT_G_DEBUG & DEBUG_REFRACT)
@@ -1454,7 +1454,7 @@
 	    break;
 	}
     }
-    if (!ZERO(ap->a_diverge - 1.0)) {
+    if (!EQUAL(ap->a_diverge, 1.0)) {
 	/* Light source is obstructed, object shadowed. */
 	if (RT_G_DEBUG & DEBUG_SHADOW)
 	    bu_log("Lgt source obstructed, object shadowed\n");
Index: fb/cell-fb.c
===================================================================
--- fb/cell-fb.c	(revision 54067)
+++ fb/cell-fb.c	(working copy)
@@ -361,7 +361,7 @@
 	return;
     }
     val = (cv.v_scalar - dom_min) * dom_cvt;
-    if ((boolean_flag && !ZERO(cv.v_scalar - bool_val))
+    if ((boolean_flag && !EQUAL(cv.v_scalar, bool_val))
 	|| (val < SMALL_FASTF) || (val > 10.0))
     {
 	COPYRGB(rgb, BACKGROUND);
@@ -455,9 +455,9 @@
 	int x0, x1;
 
 	/* Whenever Y changes, write out row of cells. */
-	if (!ZERO(lasty - gp->c_y)) {
+	if (!EQUAL(lasty, gp->c_y)) {
 	    /* If first time, nothing to write out. */
-	    if (!ZERO(lasty - INFINITY)) {
+	    if (!EQUAL(lasty, INFINITY)) {
 		if (debug_flag & CFB_DBG_GRID)
 		    bu_log("%g = V2SCRY(%g)\n", V2SCRY(lasty), lasty);
 		y_0 = V2SCRY(lasty);
@@ -476,7 +476,7 @@
 	    }
 
 	    /* Draw grid line between rows of cells. */
-	    if (grid_flag && !ZERO(lasty - INFINITY)) {
+	    if (grid_flag && !EQUAL(lasty, INFINITY)) {
 		if (fb_write(fbiop, 0, y_0, buf, fb_width) == -1) {
 		    bu_log("Couldn't write to <%d, %d>\n", 0, y_0);
 		    (void) fb_close(fbiop);
Index: fb/polar-fb.c
===================================================================
--- fb/polar-fb.c	(revision 54067)
+++ fb/polar-fb.c	(working copy)
@@ -158,7 +158,7 @@
 	if ((theta < 0.0) || (npf_index(theta / Deg2Rad) * Quantum > 360)) {
 	    (void) fprintf(stderr,
 			   "Fatal:  Theta out of range: %g %s\n",
-			   theta / convert, (ZERO(convert - 1.0)) ? "radians" : "degrees");
+			   theta / convert, (EQUAL(convert, 1.0)) ? "radians" : "degrees");
 	    Warnings = 2;
 	}
 	if ((rho < 0.0) || (rho > 1.0)) {
Index: libdm/dm_obj.c
===================================================================
--- libdm/dm_obj.c	(revision 54067)
+++ libdm/dm_obj.c	(working copy)
@@ -1359,7 +1359,7 @@
 	/* Second, draw transparent stuff */
 	FOR_ALL_SOLIDS(sp, hsp) {
 	    /* already drawn above */
-	    if (ZERO(sp->s_transparency - 1.0))
+	    if (EQUAL(sp->s_transparency, 1.0))
 		continue;
 
 	    if (linestyle != sp->s_soldash) {
Index: libpc/pcVariable.h
===================================================================
--- libpc/pcVariable.h	(revision 54067)
+++ libpc/pcVariable.h	(working copy)
@@ -436,7 +436,7 @@
 {
     if (i!=Interv.end()) {
 	typename std::list<Interval<T> >::iterator j = i;j++;
-	if (ZERO(j->getStep() - i->getStep())) {
+	if (EQUAL(j->getStep(), i->getStep())) {
 	    /* If interval is not inside the present one */
 	    if (j->getHigh() > i->getHigh())
 		i->setHigh(j->getHigh());
@@ -680,13 +680,13 @@
 	std::cout << std::endl;
 
 	for (l = 0; l < minmax.size()/2; ++l) {
-	    if (!ZERO(minmax[2*l] - minmax[2*l+1])) /* TODO: needs proper tolerancing */
+	    if (!EQUAL(minmax[2*l], minmax[2*l+1])) /* TODO: needs proper tolerancing */
 		std::cout << "to" << "\t";
 	}
 	std::cout << std::endl;
 
 	for (l = 0; l < minmax.size()/2; ++l) {
-	    if (!ZERO(minmax[2*l] - minmax[2*l+1])) /* TODO: needs proper tolerancing */
+	    if (!EQUAL(minmax[2*l], minmax[2*l+1])) /* TODO: needs proper tolerancing */
 		std::cout << minmax[2*l+1] << "\t";
 	}
 
Index: libbu/units.c
===================================================================
--- libbu/units.c	(revision 54067)
+++ libbu/units.c	(working copy)
@@ -260,7 +260,7 @@
     for (tp=bu_units_length_tab; tp->name[0]; tp++) {
 	fastf_t diff, bigger;
 
-	if (ZERO(mm - tp->val))
+	if (EQUAL(mm, tp->val))
 	    return tp->name;
 
 	/* Check for near-miss */
@@ -293,7 +293,7 @@
     BU_GET(vlsp, struct bu_vls);
     bu_vls_init(vlsp);
     for (tp=bu_units_length_tab; tp->name[0]; tp++) {
-	if (ZERO(prev_val - tp->val))
+	if (EQUAL(prev_val, tp->val))
 	    continue;
 
 	bu_vls_printf(vlsp, "%s, ", tp->name);
@@ -327,7 +327,7 @@
 	    continue;
 
 	/* break early on perfect match */
-	if (ZERO(mm - tp->val))
+	if (EQUAL(mm, tp->val))
 	    return tp->name;
 
 	/* Check for nearness */
Index: libbu/color.c
===================================================================
--- libbu/color.c	(revision 54067)
+++ libbu/color.c	(working copy)
@@ -97,11 +97,11 @@
     if (NEAR_ZERO(*sat, SMALL_FASTF)) {
 	*hue = ACHROMATIC;
     } else {
-	if (NEAR_ZERO(red - max, SMALL_FASTF)) /* red == max */
+	if (EQUAL(red, max))
 	    *hue = (grn - blu) / delta;
-	else if (NEAR_ZERO(grn - max, SMALL_FASTF)) /* grn == max */
+	else if (EQUAL(grn, max))
 	    *hue = 2.0 + (blu - red) / delta;
-	else if (NEAR_ZERO(blu - max, SMALL_FASTF)) /* blu == max */
+	else if (EQUAL(blu, max))
 	    *hue = 4.0 + (red - grn) / delta;
 
 	/*
@@ -126,10 +126,10 @@
     sat = hsv[SAT];
     val = hsv[VAL];
 
-    if ((((hue < 0.0) || (hue > 360.0)) && (!NEAR_ZERO(hue - ACHROMATIC, SMALL_FASTF))) /* hue != ACHROMATIC */
+    if ((((hue < 0.0) || (hue > 360.0)) && (!EQUAL(hue, ACHROMATIC)))
 	|| (sat < 0.0) || (sat > 1.0)
 	|| (val < 0.0) || (val > 1.0)
-	|| ((NEAR_ZERO(hue - ACHROMATIC, SMALL_FASTF)) && (sat > 0.0))) /* hue == ACHROMATIC */
+	|| ((EQUAL(hue, ACHROMATIC)) && (sat > 0.0)))
     {
 	bu_log("bu_hsv_to_rgb: Illegal HSV (%g, %g, %g)\n",
 	       V3ARGS(hsv));
@@ -140,7 +140,7 @@
     if (NEAR_ZERO(sat, SMALL_FASTF)) {
 	VSETALL(float_rgb, val);
     } else {
-	if (NEAR_ZERO(hue - 360.0, SMALL_FASTF))
+	if (EQUAL(hue, 360.0))
 	    hue = 0.0;
 	hue /= 60.0;
 	hue_int = floor((double) hue);
Index: conv/raw/Bot.cpp
===================================================================
--- conv/raw/Bot.cpp	(revision 54067)
+++ conv/raw/Bot.cpp	(working copy)
@@ -50,9 +50,9 @@
 
     // search for duplicate vertex
     for(size_t i = 0; i < (m_vertices.size() / 3); ++i) {
-	if (NEAR_ZERO(m_vertices[i * 3] - point[X], SMALL_FASTF) &&
-	    NEAR_ZERO(m_vertices[i * 3 + 1] - point[Y], SMALL_FASTF) &&
-	    NEAR_ZERO(m_vertices[i * 3 + 2] - point[Z], SMALL_FASTF)) {
+	if (EQUAL(m_vertices[i * 3], point[X]) &&
+	    EQUAL(m_vertices[i * 3 + 1], point[Y]) &&
+	    EQUAL(m_vertices[i * 3 + 2], point[Z])) {
 	    ret = i;
 	    break;
 	}
Index: conv/proe-g.c
===================================================================
--- conv/proe-g.c	(revision 54067)
+++ conv/proe-g.c	(working copy)
@@ -380,7 +380,7 @@
 		bn_mat_print(brlcad_name, wmem->wm_mat);
 		bu_log("\tscale = %g, conv_factor = %g\n", scale, conv_factor);
 	    }
-	    if (!ZERO(scale - 1.0)) {
+	    if (!EQUAL(scale, 1.0)) {
 		inv_scale = 1.0/scale;
 		for (j=0; j<3; j++)
 		    HSCALE(&wmem->wm_mat[j*4], &wmem->wm_mat[j*4], inv_scale)
Index: conv/comgeom/mat.c
===================================================================
--- conv/comgeom/mat.c	(revision 54067)
+++ conv/comgeom/mat.c	(working copy)
@@ -338,7 +338,7 @@
 {
     static float inv;
 
-    if (ZERO(h[3] - 1.0)) {
+    if (EQUAL(h[3], 1.0)) {
 	*v++ = *h++;
 	*v++ = *h++;
 	*v   = *h;
Index: conv/iges/g-iges.c
===================================================================
--- conv/iges/g-iges.c	(revision 54067)
+++ conv/iges/g-iges.c	(working copy)
@@ -692,7 +692,7 @@
 		/* write a solid instance entity for this member
 		   with a pointer to the new matrix */
 
-		if (!NEAR_ZERO(tp->tr_l.tl_mat[15] - 1.0, tol.dist)) {
+		if (!NEAR_EQUAL(tp->tr_l.tl_mat[15], 1.0, tol.dist)) {
 		    /* scale factor is not 1.0, IGES can't handle it.
 		       go ahead and write the solid instance anyway,
 		       but warn the user twice */
Index: conv/iges/extrudcon.c
===================================================================
--- conv/iges/extrudcon.c	(revision 54067)
+++ conv/iges/extrudcon.c	(working copy)
@@ -100,7 +100,7 @@
 
     /* Check for closure */
 
-    if (!ZERO(start[X] - stop[X]) || !ZERO(start[Y] - stop[Y])) {
+    if (!EQUAL(start[X], stop[X]) || !EQUAL(start[Y], stop[Y])) {
 	bu_log("Conic arc for extrusion is not closed:\n");
 	bu_log("\textrusion entity D%07d (%s)\n", dir[entityno]->direct ,
 	       dir[entityno]->name);
Index: conv/iges/extrudcirc.c
===================================================================
--- conv/iges/extrudcirc.c	(revision 54067)
+++ conv/iges/extrudcirc.c	(working copy)
@@ -53,7 +53,7 @@
 
     /* Check for closure */
 
-    if (!ZERO(x_1 - x_2) || !ZERO(y_1 - y_2)) {
+    if (!EQUAL(x_1, x_2) || !EQUAL(y_1, y_2)) {
 	bu_log("Circular arc for extrusion is not closed:\n");
 	bu_log("\textrusion entity D%07d (%s)\n", dir[entityno]->direct ,
 	       dir[entityno]->name);
Index: conv/iges/revolve.c
===================================================================
--- conv/iges/revolve.c	(revision 54067)
+++ conv/iges/revolve.c	(working copy)
@@ -333,7 +333,7 @@
 		VJOIN1(pts[i+4], pts[i], (hmax-hmin), adir);
 	    }
 	}
-	if (!ZERO(fract - 0.5)) {
+	if (!EQUAL(fract, 0.5)) {
 	    /* Calculate direction to end of revolve */
 	    VSCALE(enddir, startdir, cos(theta));
 	    VJOIN1(enddir, enddir, sin(theta), pdir);
Index: gtools/g_diff.c
===================================================================
--- gtools/g_diff.c	(revision 54067)
+++ gtools/g_diff.c	(working copy)
@@ -275,7 +275,7 @@
 	    a = atof(str1);
 	    b = atof(str2);
 
-	    if (!ZERO(a - b)) {
+	    if (!EQUAL(a, b)) {
 		return 1;
 	    }
 	} else {
@@ -1057,7 +1057,7 @@
     }
 
     /* and units */
-    if (!ZERO(dbip1->dbi_local2base - dbip2->dbi_local2base)) {
+    if (!EQUAL(dbip1->dbi_local2base, dbip2->dbi_local2base)) {
 	different = 1;
 	if (mode == HUMAN) {
 	    printf("Units changed from %s to %s\n", bu_units_string(dbip1->dbi_local2base), bu_units_string(dbip2->dbi_local2base));
Index: mged/clone.c
===================================================================
--- mged/clone.c	(revision 54067)
+++ mged/clone.c	(working copy)
@@ -954,7 +954,7 @@
 	}
 	totlen += links[(i-arg)/2].pct;
     }
-    if (!ZERO(totlen - 1.0))
+    if (!EQUAL(totlen, 1.0))
 	fprintf(stdout, "ERROR\n");
 
     /* Read in knots from specified file *************/
Index: librt/primitives/bspline/nurb_tess.c
===================================================================
--- librt/primitives/bspline/nurb_tess.c	(revision 54067)
+++ librt/primitives/bspline/nurb_tess.c	(working copy)
@@ -206,7 +206,7 @@
 	    final_t = t;
     }
 
-    if (ZERO(final_t - MAX_FASTF))
+    if (EQUAL(final_t, MAX_FASTF))
 	return -1.0;
     else
 	return final_t/2.0;
Index: librt/primitives/bspline/nurb_bezier.c
===================================================================
--- librt/primitives/bspline/nurb_bezier.c	(revision 54067)
+++ librt/primitives/bspline/nurb_bezier.c	(working copy)
@@ -120,7 +120,7 @@
     knot_max = crv->k.knots[crv->k.k_size-1];
 
     for (i=1; i<crv->k.k_size-1; i++) {
-	if (!ZERO(crv->k.knots[i] - knot_min) && !ZERO(crv->k.knots[i] - knot_max)) {
+	if (!EQUAL(crv->k.knots[i], knot_min) && !EQUAL(crv->k.knots[i], knot_max)) {
 	    bezier = 0;
 	    break;
 	}
@@ -158,13 +158,13 @@
 
 	split = MAX_FASTF;
 	for (i=1; i<crv_copy->k.k_size-1; i++) {
-	    if (!ZERO(crv_copy->k.knots[i] - knot_min) && !ZERO(crv_copy->k.knots[i] - knot_max)) {
+	    if (!EQUAL(crv_copy->k.knots[i], knot_min) && !EQUAL(crv_copy->k.knots[i], knot_max)) {
 		split = crv_copy->k.knots[i];
 		break;
 	    }
 	}
 
-	if (ZERO(split - MAX_FASTF)) {
+	if (EQUAL(split, MAX_FASTF)) {
 	    done = 1;
 	    BU_LIST_APPEND(clist, &crv_copy->l);
 	    break;
Index: librt/primitives/bspline/nurb_eval.c
===================================================================
--- librt/primitives/bspline/nurb_eval.c	(revision 54067)
+++ librt/primitives/bspline/nurb_eval.c	(working copy)
@@ -176,7 +176,7 @@
 
 	k2 =  k_vec->knots[ (j) ];
 
-	if (!ZERO(k1 - k2)) {
+	if (!EQUAL(k1, k2)) {
 	    for (i= 0; i < coords; i++) {
 		*((crv + ((j) * coords)) + i) =
 		    ((k1 - param) *
Index: librt/primitives/bspline/nurb_split.c
===================================================================
--- librt/primitives/bspline/nurb_split.c	(revision 54067)
+++ librt/primitives/bspline/nurb_split.c	(working copy)
@@ -69,7 +69,7 @@
 	value = srf->u.knots[(srf->u.k_size -1)/2];
 
 	for (i = 0; i < srf->u.k_size; i++)
-	    if (ZERO(value - srf->u.knots[i])) {
+	    if (EQUAL(value, srf->u.knots[i])) {
 		k_index = i;
 		break;
 	    }
@@ -150,7 +150,7 @@
 	value = srf->v.knots[(srf->v.k_size -1)/2];
 
 	for (i = 0; i < srf->v.k_size; i++)
-	    if (ZERO(value - srf->v.knots[i])) {
+	    if (EQUAL(value, srf->v.knots[i])) {
 		k_index = i;
 		break;
 	    }
@@ -275,7 +275,7 @@
 	value = crv->k.knots[(crv->k.k_size -1)/2];
 
     for (i = 0; i < crv->k.k_size; i++)
-	if (ZERO(value - crv->k.knots[i])) {
+	if (EQUAL(value, crv->k.knots[i])) {
 	    k_index = i;
 	    break;
 	}
Index: librt/primitives/bspline/nurb_norm.c
===================================================================
--- librt/primitives/bspline/nurb_norm.c	(revision 54067)
+++ librt/primitives/bspline/nurb_norm.c	(working copy)
@@ -61,9 +61,9 @@
 		&& u < srf->u.knots[i+1]) {
 		p = srf->u.knots[i];
 
-		if (ZERO(u - p))
+		if (EQUAL(u, p))
 		    p = srf->u.knots[i+1];
-		if (ZERO(u - p) && i > 1)
+		if (EQUAL(u, p) && i > 1)
 		    p = srf->u.knots[i-1];
 	    }
 	}
@@ -75,9 +75,9 @@
 	    if (srf->v.knots[i] < v
 		&& !ZERO(srf->v.knots[i+1])) {
 		p = srf->v.knots[i];
-		if (ZERO(v - p))
+		if (EQUAL(v, p))
 		    p = srf->v.knots[i+1];
-		if (ZERO(v - p) && i > 1)
+		if (EQUAL(v, p) && i > 1)
 		    p = srf->v.knots[i-1];
 	    }
 	}
@@ -118,9 +118,9 @@
 		&& u < srf->u.knots[i+1]) {
 		p = srf->u.knots[i];
 
-		if (ZERO(u - p))
+		if (EQUAL(u, p))
 		    p = srf->u.knots[i+1];
-		if (ZERO(u - p) && i > 1)
+		if (EQUAL(u, p) && i > 1)
 		    p = srf->u.knots[i-1];
 	    }
 	}
@@ -172,9 +172,9 @@
 		&& v < srf->v.knots[i+1]) {
 		p = srf->v.knots[i];
 
-		if (ZERO(v - p))
+		if (EQUAL(v, p))
 		    p = srf->v.knots[i+1];
-		if (ZERO(v - p) && i > 1)
+		if (EQUAL(v, p) && i > 1)
 		    p = srf->v.knots[i-1];
 	    }
 	}
Index: librt/primitives/bspline/nurb_knot.c
===================================================================
--- librt/primitives/bspline/nurb_knot.c	(revision 54067)
+++ librt/primitives/bspline/nurb_knot.c	(working copy)
@@ -185,7 +185,7 @@
     register int i;
 
     for (i = 0; i < kv->k_size; i++) {
-	if (ZERO(val - kv->knots[i]))
+	if (EQUAL(val, kv->knots[i]))
 	    kv_num++;
     }
 
@@ -293,9 +293,9 @@
 	    return - 1;
     }
 
-    if (ZERO(k_value - kv->knots[ kv->k_size - order + 1]))
+    if (EQUAL(k_value, kv->knots[ kv->k_size - order + 1]))
 	k_index = kv->k_size - order - 1;
-    else if (ZERO(k_value - kv->knots[ order - 1]))
+    else if (EQUAL(k_value, kv->knots[ order - 1]))
 	k_index = order - 1;
     else {
 	k_index = 0;
Index: librt/primitives/bspline/nurb_trim.c
===================================================================
--- librt/primitives/bspline/nurb_trim.c	(revision 54067)
+++ librt/primitives/bspline/nurb_trim.c	(working copy)
@@ -564,7 +564,7 @@
 		continue;
 	    if (uv1[0] <= u && uv2[0] <= u)
 		continue;
-	    if (ZERO(uv1[0] - uv2[0])) {
+	    if (EQUAL(uv1[0], uv2[0])) {
 		if ((uv1[1] <= v && uv2[1] >= v) ||
 		    (uv2[1] <= v && uv1[1] >= v))
 		    crossings++;
Index: librt/primitives/nmg/nmg_mk.c
===================================================================
--- librt/primitives/nmg/nmg_mk.c	(revision 54067)
+++ librt/primitives/nmg/nmg_mk.c	(working copy)
@@ -2270,15 +2270,15 @@
      * at least distance tolerance.
      */
     thickening = 0.5 * tol->dist;
-    if (NEAR_ZERO(lg->max_pt[X] - lg->min_pt[X], tol->dist)) {
+    if (NEAR_EQUAL(lg->max_pt[X], lg->min_pt[X], tol->dist)) {
 	lg->min_pt[X] -= thickening;
 	lg->max_pt[X] += thickening;
     }
-    if (NEAR_ZERO(lg->max_pt[Y] - lg->min_pt[Y], tol->dist)) {
+    if (NEAR_EQUAL(lg->max_pt[Y], lg->min_pt[Y], tol->dist)) {
 	lg->min_pt[Y] -= thickening;
 	lg->max_pt[Y] += thickening;
     }
-    if (NEAR_ZERO(lg->max_pt[Z] - lg->min_pt[Z], tol->dist)) {
+    if (NEAR_EQUAL(lg->max_pt[Z], lg->min_pt[Z], tol->dist)) {
 	lg->min_pt[Z] -= thickening;
 	lg->max_pt[Z] += thickening;
     }
Index: librt/primitives/nmg/nmg_rt_isect.c
===================================================================
--- librt/primitives/nmg/nmg_rt_isect.c	(revision 54067)
+++ librt/primitives/nmg/nmg_rt_isect.c	(working copy)
@@ -2496,7 +2496,7 @@
 		       nmg_rt_inout_str(a_hit->in_out));
 	    plus_hit = a_hit;
 	    *hari_kari = 0;
-	} else if (ZERO(a_hit->hit.hit_dist - plus_hit->hit.hit_dist)) {
+	} else if (EQUAL(a_hit->hit.hit_dist, plus_hit->hit.hit_dist)) {
 	    *hari_kari = 1;
 	}
     }
@@ -2587,7 +2587,7 @@
 		       nmg_rt_inout_str(a_hit->in_out));
 	    minus_hit = a_hit;
 	    *hari_kari = 0;
-	} else if (ZERO(a_hit->hit.hit_dist - minus_hit->hit.hit_dist)) {
+	} else if (EQUAL(a_hit->hit.hit_dist, minus_hit->hit.hit_dist)) {
 	    *hari_kari = 1;
 	}
     }
Index: librt/primitives/nmg/nmg_pt_fu.c
===================================================================
--- librt/primitives/nmg/nmg_pt_fu.c	(revision 54067)
+++ librt/primitives/nmg/nmg_pt_fu.c	(working copy)
@@ -701,7 +701,7 @@
 	 * Insert edge_info struct here in list
 	 */
 	if (ved->dist < ei_p->ved_p->dist
-	    || (ZERO(ved->dist - ei_p->ved_p->dist)
+	    || (EQUAL(ved->dist, ei_p->ved_p->dist)
 		&& ei_p->ved_p->magic_p == ved->magic_p))
 	{
 	    break;
Index: librt/primitives/nmg/nmg.c
===================================================================
--- librt/primitives/nmg/nmg.c	(revision 54067)
+++ librt/primitives/nmg/nmg.c	(working copy)
@@ -857,7 +857,7 @@
     cp = rt_nmg_fastf_p;
     *(uint32_t *)&cp[0] = htonl(DISK_DOUBLE_ARRAY_MAGIC);
     *(uint32_t *)&cp[4] = htonl(count);
-    if (pt_type == 0 || ZERO(scale - 1.0)) {
+    if (pt_type == 0 || EQUAL(scale, 1.0)) {
 	scanp = (double *)bu_malloc(count * sizeof(double), "scanp");
 	/* convert fastf_t to double */
 	for (i=0; i<count; i++) {
Index: librt/primitives/nmg/nmg_inter.c
===================================================================
--- librt/primitives/nmg/nmg_inter.c	(revision 54067)
+++ librt/primitives/nmg/nmg_inter.c	(working copy)
@@ -1472,7 +1472,7 @@
 	    ret = ISECT_SHARED_V;
 	    goto topo;
 	}
-	if (ZERO(dist[1] - 1.0)) {
+	if (EQUAL(dist[1], 1.0)) {
 	    if (rt_g.NMG_debug & DEBUG_POLYSECT)
 		bu_log("\tsecond point of eu2 matches vu1a\n");
 	    nmg_jv(vu1a->v_p, vu2b->v_p);
@@ -1489,7 +1489,7 @@
 	goto topo;
     }
 
-    if (ZERO(dist[0] - 1.0)) {
+    if (EQUAL(dist[0], 1.0)) {
 	/* Second point of eu1 is on eu2, by geometry */
 	if (rt_g.NMG_debug & DEBUG_POLYSECT)
 	    bu_log("\tvu=x%x vu1b is intersect point\n", vu1b);
@@ -1511,7 +1511,7 @@
 	    ret = ISECT_SHARED_V;
 	    goto topo;
 	}
-	if (ZERO(dist[1] - 1.0)) {
+	if (EQUAL(dist[1], 1.0)) {
 	    if (rt_g.NMG_debug & DEBUG_POLYSECT)
 		bu_log("\tsecond point of eu2 matches vu1b\n");
 	    nmg_jv(vu1b->v_p, vu2b->v_p);
@@ -1539,7 +1539,7 @@
 	    nmg_enlist_vu(is, vu2a, 0, MAX_FASTF);
 	    ret = ISECT_SHARED_V;		/* eu1 was not broken */
 	    goto topo;
-	} else if (ZERO(dist[1] - 1.0)) {
+	} else if (EQUAL(dist[1], 1.0)) {
 	    nmg_enlist_vu(is, vu2b, 0, MAX_FASTF);
 	    ret = ISECT_SHARED_V;		/* eu1 was not broken */
 	    goto topo;
@@ -1580,7 +1580,7 @@
 	nmg_enlist_vu(is, vu2a, vu, MAX_FASTF);
 	ret |= ISECT_SPLIT1;
 	goto topo;
-    } else if (ZERO(dist[1] - 1.0)) {
+    } else if (EQUAL(dist[1], 1.0)) {
 	if (rt_g.NMG_debug & DEBUG_POLYSECT)
 	    bu_log("\t\tintersect point is vu2b\n");
 	vu = nmg_ebreaker(vu2b->v_p, eu1, &is->tol)->vu_p;
@@ -3105,7 +3105,7 @@
 	    bu_bomb("vu1a does not match calculated point\n");
 	nmg_enlist_vu(is, vu1a, 0, MAX_FASTF);
 	ret = 0;
-    } else if (status == 2 || ZERO(dist[1] - 1.0)) {
+    } else if (status == 2 || EQUAL(dist[1], 1.0)) {
 	if (rt_g.NMG_debug & DEBUG_POLYSECT)
 	    bu_log("\t\tintersect point is vu1b\n");
 	if (!bn_pt3_pt3_equal(hit_pt, vu1b->v_p->vg_p->coord, &(is->tol)))
@@ -3729,14 +3729,14 @@
 	    eu1->eumate_p->vu_p->v_p == eu2->eumate_p->vu_p->v_p)
 	    return;
 
-	if (ZERO(dist[0]) || ZERO(dist[0] - 1.0))
+	if (ZERO(dist[0]) || EQUAL(dist[0], 1.0))
 	    return;
 
 	if (ZERO(dist[1])) {
 	    bu_ptbl_ins_unique(inters, (long *)eu2->vu_p->v_p);
 	    return;
 	}
-	if (ZERO(dist[1] - 1.0)) {
+	if (EQUAL(dist[1], 1.0)) {
 	    bu_ptbl_ins_unique(inters, (long *)eu2->eumate_p->vu_p->v_p);
 	    return;
 	}
@@ -5820,7 +5820,7 @@
 		    hit_vu = eu1->vu_p;
 		    hitv = hit_vu->v_p;
 		    VMOVE(hit_pt, hitv->vg_p->coord);
-		} else if (ZERO(dist[hit_no] - len_vt1)) {
+		} else if (EQUAL(dist[hit_no], len_vt1)) {
 		    hit_vu = eu1->eumate_p->vu_p;
 		    hitv = hit_vu->v_p;
 		    VMOVE(hit_pt, hitv->vg_p->coord);
@@ -6125,9 +6125,9 @@
 	increasing =  (-1);
 	start = 1;
 	for (j=2; j<=face_count; j++) {
-	    if (ZERO(angle[j]) || ZERO(angle[j] - bn_twopi))
+	    if (ZERO(angle[j]) || EQUAL(angle[j], bn_twopi))
 		continue;
-	    if (ZERO(angle[j] - angle[j-1]))
+	    if (EQUAL(angle[j], angle[j-1]))
 		continue;
 	    else if (angle[j] > angle[j-1]) {
 		start = j;
@@ -7172,7 +7172,7 @@
 	    /* Hit is at vu2a */
 	    nmg_jv(vu1a->v_p, vu2a->v_p);
 	    return;
-	} else if (ZERO(dist[1] - 1.0)) {
+	} else if (EQUAL(dist[1], 1.0)) {
 	    /* Hit is at vu2b */
 	    nmg_jv(vu1a->v_p, vu2b->v_p);
 	    return;
@@ -7180,13 +7180,13 @@
 	/* Break eu2 on vu1a */
 	nmg_ebreaker(vu1a->v_p, eu2, &is->tol);
 	return;
-    } else if (ZERO(dist[0] - 1.0)) {
+    } else if (EQUAL(dist[0], 1.0)) {
 	/* Hit is at vu1b */
 	if (ZERO(dist[1])) {
 	    /* Hit is at vu2a */
 	    nmg_jv(vu1b->v_p, vu2a->v_p);
 	    return;
-	} else if (ZERO(dist[1] - 1.0)) {
+	} else if (EQUAL(dist[1], 1.0)) {
 	    /* Hit is at vu2b */
 	    nmg_jv(vu1b->v_p, vu2b->v_p);
 	    return;
@@ -7202,7 +7202,7 @@
 	    /* Hit is at vu2a */
 	    nmg_ebreaker(vu2a->v_p, eu1, &is->tol);
 	    return;
-	} else if (ZERO(dist[1] - 1.0)) {
+	} else if (EQUAL(dist[1], 1.0)) {
 	    /* Hit is at vu2b */
 	    nmg_ebreaker(vu2b->v_p, eu1, &is->tol);
 	    return;
@@ -7765,7 +7765,7 @@
 	     * that the current distance is compared against
 	     */
 	    avg_dist = tot_dist / cnt;
-	    if (NEAR_ZERO(dist - avg_dist, tol->dist)) {
+	    if (NEAR_EQUAL(dist, avg_dist, tol->dist)) {
 	    } else {
 		/* not parallel */
 		parallel = 0;
@@ -7796,7 +7796,7 @@
 		 * that the current distance is compared against
 		 */
 		avg_dist = tot_dist / cnt;
-		if (!NEAR_ZERO(dist - avg_dist, tol->dist)) {
+		if (!NEAR_EQUAL(dist, avg_dist, tol->dist)) {
 		    /* not parallel */
 		    parallel = 0;
 		    break;
Index: librt/primitives/nmg/nmg_tri.c
===================================================================
--- librt/primitives/nmg/nmg_tri.c	(revision 54067)
+++ librt/primitives/nmg/nmg_tri.c	(working copy)
@@ -4109,7 +4109,7 @@
 			    on_vertex = 1;
 			}
 
-			if (NEAR_ZERO(line2_dist - vec2_mag, tol->dist)) {
+			if (NEAR_EQUAL(line2_dist, vec2_mag, tol->dist)) {
 			    /* true when hit is on 2st vertex of edgeuse */
 			    VSUB2(x_dir, line2_pt2, line1_pt1);
 			    VCROSS(y_dir, N, x_dir);
@@ -4181,7 +4181,7 @@
 	} /* end of while-loop */
 
 	if (hit_cnt != 0) {
-	    if (NEAR_ZERO((hit_cnt/2.0) - floor(hit_cnt/2.0), SMALL_FASTF)) {
+	    if (EQUAL((hit_cnt/2.0), floor(hit_cnt/2.0))) {
 		/* true when hit_cnt is even */
 		bu_log("nmg_classify_pt_loop_new(): hit_cnt = %d %f %f EVEN\n",
 			hit_cnt, (hit_cnt/2.0), floor(hit_cnt/2.0));
Index: librt/primitives/nmg/nmg_fcut.c
===================================================================
--- librt/primitives/nmg/nmg_fcut.c	(revision 54067)
+++ librt/primitives/nmg/nmg_fcut.c	(working copy)
@@ -276,7 +276,7 @@
 	    if (tmag < -dist_tol) continue;
 	    if (tmag > dist_tol) continue;
 	    /* Nearly equal at same vertex */
-	    if (!ZERO(mag[i] - mag[j])
+	    if (!EQUAL(mag[i], mag[j])
 		&& vu[i]->v_p == vu[j]->v_p)
 	    {
 		bu_log("ptbl_vsort: forcing vu=x%x & vu=x%x mag equal\n", vu[i], vu[j]);
@@ -289,7 +289,7 @@
 	for (j=i+1; j < b->end; ++j) {
 
 	    if (mag[i] < mag[j]) continue;
-	    if (ZERO(mag[i] - mag[j])) {
+	    if (EQUAL(mag[i], mag[j])) {
 		if (vu[i]->v_p < vu[j]->v_p) continue;
 		if (vu[i]->v_p == vu[j]->v_p) {
 		    if (vu[i] < vu[j]) continue;
@@ -499,7 +499,7 @@
 	    /* Assuming NMG_E_ASSESSMENT_LEFT */
 	    ang = bn_twopi - RADIAN_TWEEK;
 	}
-    } else if (ZERO(ang - bn_pi)) {
+    } else if (EQUAL(ang, bn_pi)) {
 	if (this_ass == NMG_E_ASSESSMENT_RIGHT) {
 	    ang = bn_pi - RADIAN_TWEEK;
 	} else {
@@ -2044,7 +2044,7 @@
     BN_CK_TOL(rs->tol);
     if (rs->eg_p) NMG_CK_EDGE_G_LSEG(rs->eg_p);
 
-    if (cur == rs->nvu-1 || !ZERO(mag[cur+1] - mag[cur])) {
+    if (cur == rs->nvu-1 || !EQUAL(mag[cur+1], mag[cur])) {
 	/* Single vertexuse at this dist */
 	if (rt_g.NMG_debug&DEBUG_FCUT)
 	    bu_log("nmg_face_next_vu_interval() fu=x%x, single vertexuse at index %d\n", rs->fu1, cur);
@@ -2061,7 +2061,7 @@
     v = rs->vu[cur]->v_p;
     for (j = cur+1; j < rs->nvu; j++) {
 	/* If distance along the ray changes, start a new interval */
-	if (!ZERO(mag[j] - mag[cur])) break;
+	if (!EQUAL(mag[j], mag[cur])) break;
     }
 
     /* vu Interval runs from [cur] to [j-1] inclusive */
Index: librt/primitives/nmg/nmg_fuse.c
===================================================================
--- librt/primitives/nmg/nmg_fuse.c	(revision 54067)
+++ librt/primitives/nmg/nmg_fuse.c	(working copy)
@@ -526,11 +526,11 @@
 	 * component.
 	 */
 	for (i=1; i<srf->s_size[0]*srf->s_size[1]; i++) {
-	    if (!ZERO(srf->ctl_points[i*coords+X] - srf->ctl_points[X]))
+	    if (!EQUAL(srf->ctl_points[i*coords+X], srf->ctl_points[X]))
 		x_same = 0;
-	    if (!ZERO(srf->ctl_points[i*coords+Y] - srf->ctl_points[Y]))
+	    if (!EQUAL(srf->ctl_points[i*coords+Y], srf->ctl_points[Y]))
 		y_same = 0;
-	    if (!ZERO(srf->ctl_points[i*coords+Z] - srf->ctl_points[Z]))
+	    if (!EQUAL(srf->ctl_points[i*coords+Z], srf->ctl_points[Z]))
 		z_same = 0;
 
 	    if (!x_same && !y_same && !z_same)
@@ -2174,7 +2174,7 @@
 	}
 
 	/* angle decreases, is it going from max to min?? */
-	if (ZERO(rad->ang - amin) && ZERO(cur_value - amax)) {
+	if (EQUAL(rad->ang, amin) && EQUAL(cur_value, amax)) {
 	    /* O.K., just went from max to min */
 	    cur_value = rad->ang;
 	    continue;
@@ -2276,12 +2276,12 @@
 
 	    non_wire_edges++;
 
-	    if ((rad->ang < amin) || (ZERO(rad->ang - amin))) {
+	    if ((rad->ang < amin) || (EQUAL(rad->ang, amin))) {
 		amin = rad->ang;
 		rmin = rad;
 	    }
 
-	    if ((rad->ang > amax) || (ZERO(rad->ang - amax))) {
+	    if ((rad->ang > amax) || (EQUAL(rad->ang, amax))) {
 		amax = rad->ang;
 		rmax = rad;
 	    }
@@ -2341,7 +2341,7 @@
 	    next = BU_LIST_PNEXT_CIRC(nmg_radial, next);
 	} while (next->fu == (struct faceuse *)NULL);
 
-	if ((next->ang > amax) || (ZERO(next->ang - amax))) {
+	if ((next->ang > amax) || (EQUAL(next->ang, amax))) {
 	    rmax = next;		/* a repeated max */
 	    if (rmax == first)	/* we have gone all the way around (All angles are same) */
 		break;
@@ -2356,7 +2356,7 @@
 	while ((next = BU_LIST_PPREV_CIRC(nmg_radial, rmin))->fu == (struct faceuse *)NULL)
 	    rmin = next;
 	next = BU_LIST_PPREV_CIRC(nmg_radial, rmin);
-	if ((next->ang < amin) || (ZERO(next->ang - amin))) {
+	if ((next->ang < amin) || (EQUAL(next->ang, amin))) {
 	    rmin = next;		/* a repeated min */
 	    if (rmin == first) {
 		/* all the way round again (All angles are same) */
@@ -3098,7 +3098,7 @@
 	}
 
 	end_same = BU_LIST_PNEXT_CIRC(nmg_radial, &start_same->l);
-	while ((ZERO(end_same->ang - start_same->ang) && !ZERO(end_same - start_same))
+	while ((EQUAL(end_same->ang, start_same->ang) && !EQUAL(end_same, start_same))
 	       || !end_same->fu)
 	    end_same = BU_LIST_PNEXT_CIRC(nmg_radial, &end_same->l);
 	end_same = BU_LIST_PPREV_CIRC(nmg_radial, &end_same->l);
Index: librt/primitives/bot/bot.c
===================================================================
--- librt/primitives/bot/bot.c	(revision 54067)
+++ librt/primitives/bot/bot.c	(working copy)
@@ -3002,7 +3002,7 @@
 	    max_xval = (&bot->vertices[i*3])[X];
 
 	/* sanity to make sure our book-keeping doesn't go haywire */
-	if (ZERO((&bot->vertices[i*3])[X] - deleted[X])) {
+	if (EQUAL((&bot->vertices[i*3])[X], deleted[X])) {
 	    bu_log("WARNING: Unable to fuse due to vertex with infinite value (idx=%ld)\n", i);
 	    return 0;
 	}
@@ -3021,8 +3021,8 @@
     if (min_xval < (fastf_t)LONG_MIN) {
 	min_xval = (fastf_t)LONG_MIN;
     }
-    if (ZERO(max_xval - min_xval)) {
-	if (ZERO(max_xval - (fastf_t)LONG_MAX)) {
+    if (EQUAL(max_xval, min_xval)) {
+	if (EQUAL(max_xval, (fastf_t)LONG_MAX)) {
 	    max_xval += VDIVIDE_TOL;
 	} else {
 	    min_xval -= VDIVIDE_TOL;
@@ -3191,7 +3191,7 @@
 		case RT_BOT_PLATE:
 		case RT_BOT_PLATE_NOCOS:
 		    /* check the face thickness and face mode */
-		    if (!ZERO(bot->thickness[i] - bot->thickness[j]) ||
+		    if (!EQUAL(bot->thickness[i], bot->thickness[j]) ||
 			(BU_BITTEST(bot->face_mode, i)?1:0) != (BU_BITTEST(bot->face_mode, j)?1:0))
 			break;
 		case RT_BOT_SOLID:
Index: librt/primitives/bot/g_bot_include.c
===================================================================
--- librt/primitives/bot/g_bot_include.c	(revision 54067)
+++ librt/primitives/bot/g_bot_include.c	(working copy)
@@ -527,7 +527,7 @@
 	 * we left.
 	 */
 	for (i = 0; i < nhits; i++) {
-	    if (ZERO(hits[i].hit_dist - rm_dist)) {
+	    if (EQUAL(hits[i].hit_dist, rm_dist)) {
 		for (j = i; j < nhits - 1; j++)
 		    hits[j] = hits[j+1];
 		nhits--;
Index: librt/primitives/dsp/dsp.c
===================================================================
--- librt/primitives/dsp/dsp.c	(revision 54067)
+++ librt/primitives/dsp/dsp.c	(working copy)
@@ -3000,7 +3000,7 @@
 	bu_log("interpolated %g %g %g  dot:%g\n", V3ARGS(N), dot);
 
     if ((ZERO(hitp->hit_vpriv[Z]) && dot > 0.0)/* in-hit needs fix */ ||
-	(ZERO(hitp->hit_vpriv[Z] - 1.0) && dot < 0.0)/* out-hit needs fix */) {
+	(EQUAL(hitp->hit_vpriv[Z], 1.0) && dot < 0.0)/* out-hit needs fix */) {
 	/* bring the normal back to being perpendicular to the ray to
 	 * avoid "flipped normal" warnings
 	 */
Index: librt/primitives/brep/brep.cpp
===================================================================
--- librt/primitives/brep/brep.cpp	(revision 54067)
+++ librt/primitives/brep/brep.cpp	(working copy)
@@ -524,7 +524,7 @@
 
     bool operator==(const brep_hit& h)
     {
-	return NEAR_ZERO(dist - h.dist, BREP_SAME_POINT_TOLERANCE);
+	return NEAR_EQUAL(dist, h.dist, BREP_SAME_POINT_TOLERANCE);
     }
 
     bool operator<(const brep_hit& h)
Index: librt/primitives/ebm/ebm.c
===================================================================
--- librt/primitives/ebm/ebm.c	(revision 54067)
+++ librt/primitives/ebm/ebm.c	(working copy)
@@ -349,10 +349,10 @@
     if (RT_G_DEBUG&DEBUG_EBM)bu_log("t[Y] = %g, delta[Y] = %g\n", t[Y], delta[Y]);
 
     /* Find face of entry into first cell -- max initial t value */
-    if (ZERO(t[X] - INFINITY)) {
+    if (EQUAL(t[X], INFINITY)) {
 	in_index = Y;
 	t0 = t[Y];
-    } else if (ZERO(t[Y] - INFINITY)) {
+    } else if (EQUAL(t[Y], INFINITY)) {
 	in_index = X;
 	t0 = t[X];
     } else if (t[X] >= t[Y]) {
Index: librt/primitives/metaball/metaball.c
===================================================================
--- librt/primitives/metaball/metaball.c	(revision 54067)
+++ librt/primitives/metaball/metaball.c	(working copy)
@@ -117,7 +117,7 @@
 		max[i] = mbpt->coord[i];
 	}
     /* return -1 if no points are defined. */
-    if (ZERO(min[X] - INFINITY) || min[X] > INFINITY)
+    if (EQUAL(min[X], INFINITY) || min[X] > INFINITY)
 	return -1;
 
     /* compute the center of the generated box, call that the center */
Index: librt/primitives/revolve/revolve.c
===================================================================
--- librt/primitives/revolve/revolve.c	(revision 54067)
+++ librt/primitives/revolve/revolve.c	(working copy)
@@ -125,9 +125,9 @@
 	if (endcount[i] % 2 != 0) {
 	    /* add 'i' to list, insertion sort by vert[i][Y] */
 	    for (k=j; k>0; k--) {
-		if ((ZERO(rip->skt->verts[i][Y] - rip->skt->verts[endcount[k-1]][Y])
+		if ((EQUAL(rip->skt->verts[i][Y], rip->skt->verts[endcount[k-1]][Y])
 		     && rip->skt->verts[i][X] > rip->skt->verts[endcount[k-1]][X])
-		    || (!ZERO(rip->skt->verts[i][Y] - rip->skt->verts[endcount[k-1]][Y])
+		    || (!EQUAL(rip->skt->verts[i][Y], rip->skt->verts[endcount[k-1]][Y])
 			&& rip->skt->verts[i][Y] < rip->skt->verts[endcount[k-1]][Y])) {
 		    endcount[k] = endcount[k-1];
 		} else {
@@ -274,9 +274,9 @@
 	if (endcount[i] % 2 != 0) {
 	    /* add 'i' to list, insertion sort by vert[i][Y] */
 	    for (k=j; k>0; k--) {
-		if ((ZERO(rip->skt->verts[i][Y] - rip->skt->verts[endcount[k-1]][Y])
+		if ((EQUAL(rip->skt->verts[i][Y], rip->skt->verts[endcount[k-1]][Y])
 		     && rip->skt->verts[i][X] > rip->skt->verts[endcount[k-1]][X])
-		    || (!ZERO(rip->skt->verts[i][Y] - rip->skt->verts[endcount[k-1]][Y])
+		    || (!EQUAL(rip->skt->verts[i][Y], rip->skt->verts[endcount[k-1]][Y])
 			&& rip->skt->verts[i][Y] < rip->skt->verts[endcount[k-1]][Y])) {
 		    endcount[k] = endcount[k-1];
 		} else {
@@ -961,7 +961,7 @@
 	    break;
 	}
 
-	if (ZERO(hits[in]->hit_dist - hits[out]->hit_dist)) {
+	if (EQUAL(hits[in]->hit_dist, hits[out]->hit_dist)) {
 	    hits[in] = NULL;
 	    hits[out] = NULL;
 	    continue;
@@ -1343,9 +1343,9 @@
 	if (endcount[i] % 2 != 0) {
 	    /* add 'i' to list, insertion sort by vert[i][Y] */
 	    for (k=j; k>0; k--) {
-		if ((ZERO(verts[i][Y] - verts[endcount[k-1]][Y])
+		if ((EQUAL(verts[i][Y], verts[endcount[k-1]][Y])
 		     && verts[i][X] > verts[endcount[k-1]][X])
-		    || (!ZERO(verts[i][Y] - verts[endcount[k-1]][Y])
+		    || (!EQUAL(verts[i][Y], verts[endcount[k-1]][Y])
 			&& verts[i][Y] < verts[endcount[k-1]][Y])) {
 		    endcount[k] = endcount[k-1];
 		} else {
@@ -1366,7 +1366,7 @@
 	curve_to_vlist(vhead, ttol, rip->v3d, ucir[i], uz, rip->skt, crv);
 	for (j=0; j<nadd; j++) {
 	    if (j+1 < nadd &&
-		ZERO(verts[endcount[j]][Y] - verts[endcount[j+1]][Y])) {
+		EQUAL(verts[endcount[j]][Y], verts[endcount[j+1]][Y])) {
 		VJOIN1(add, rip->v3d, verts[endcount[j]][Y], rip->axis3d);
 		VJOIN1(add2, add, verts[endcount[j]][X], ucir[i]);
 		VJOIN1(add3, add, verts[endcount[j+1]][X], ucir[i]);
@@ -1385,7 +1385,7 @@
 	curve_to_vlist(vhead, ttol, rip->v3d, rEnd, uz, rip->skt, crv);
 	for (j=0; j<nadd; j++) {
 	    if (j+1 < nadd &&
-		ZERO(verts[endcount[j]][Y] - verts[endcount[j+1]][Y])) {
+		EQUAL(verts[endcount[j]][Y], verts[endcount[j+1]][Y])) {
 		VJOIN1(add, rip->v3d, verts[endcount[j]][Y], rip->axis3d);
 		VJOIN1(add2, add, verts[endcount[j]][X], rEnd);
 		VJOIN1(add3, add, verts[endcount[j+1]][X], rEnd);
@@ -1400,7 +1400,7 @@
 	    }
 	}
 	for (j=0; j<nadd; j+=2) {
-	    if (!ZERO(verts[endcount[j]][Y] - verts[endcount[j+1]][Y])) {
+	    if (!EQUAL(verts[endcount[j]][Y], verts[endcount[j+1]][Y])) {
 		VJOIN1(add, rip->v3d, verts[endcount[j]][Y], rip->axis3d);
 		VJOIN1(add2, rip->v3d, verts[endcount[j+1]][Y], rip->axis3d);
 		RT_ADD_VLIST(vhead, add, BN_VLIST_LINE_MOVE);
Index: librt/comb/db_comb.c
===================================================================
--- librt/comb/db_comb.c	(revision 54067)
+++ librt/comb/db_comb.c	(working copy)
@@ -69,9 +69,9 @@
 
     if (!matp) return 0;
 
-    if (!ZERO(matp[0] - 1.0)
-	|| !ZERO(matp[5] - 1.0)
-	|| !ZERO(matp[10] - 1.0))
+    if (!EQUAL(matp[0], 1.0)
+	|| !EQUAL(matp[5], 1.0)
+	|| !EQUAL(matp[10], 1.0))
     {
 	status |= STAT_ROT;
     }
Index: librt/bool.c
===================================================================
--- librt/bool.c	(revision 54067)
+++ librt/bool.c	(working copy)
@@ -812,7 +812,7 @@
 	goto out;
     }
     if (d >= INFINITY) {
-	if (ZERO(a - b)) {
+	if (EQUAL(a, b)) {
 	    ret = 0;
 	    goto out;
 	}
Index: librt/oslo_calc.c
===================================================================
--- librt/oslo_calc.c	(revision 54067)
+++ librt/oslo_calc.c	(working copy)
@@ -107,7 +107,7 @@
 
 	i = j + 1;
 
-	while (ZERO(t_p[i] - tau_p[muprim]) && i < (j + order)) {
+	while (EQUAL(t_p[i], tau_p[muprim]) && i < (j + order)) {
 	    i++;
 	    muprim--;
 	}
@@ -115,7 +115,7 @@
 	ih = muprim + 1;
 
 	for (v = 0, p = 1; p < order; p++) {
-	    if (ZERO(t_p[j + p] - tau_p[ih]))
+	    if (EQUAL(t_p[j + p], tau_p[ih]))
 		ih++;
 	    else
 		newknots[++v - 1] = t_p[j + p];
Index: liboptical/refract.c
===================================================================
--- liboptical/refract.c	(revision 54067)
+++ liboptical/refract.c	(working copy)
@@ -477,7 +477,7 @@
      * through a glass armor plate. :-)
      */
     if (NEAR_ZERO(pp->pt_inhit->hit_dist, AIR_GAP_TOL)
-	&& ZERO(ap->a_refrac_index - swp->sw_refrac_index))
+	&& EQUAL(ap->a_refrac_index, swp->sw_refrac_index))
     {
 	transmit += reflect;
 	reflect = 0;
@@ -537,7 +537,7 @@
 	if (pp->pt_inhit->hit_dist > AIR_GAP_TOL)
 	    sub_ap.a_refrac_index = RI_AIR;
 
-	if (!ZERO(sub_ap.a_refrac_index - swp->sw_refrac_index)
+	if (!EQUAL(sub_ap.a_refrac_index, swp->sw_refrac_index)
 	    && !rr_refract(incident_dir,		/* input direction */
 			   swp->sw_hit.hit_normal,	/* exit normal */
 			   sub_ap.a_refrac_index,	/* current RI */
@@ -654,7 +654,7 @@
 	 * Calculate refraction at exit point.
 	 * Use "look ahead" RI value from rr_hit.
 	 */
-	if (!ZERO(sub_ap.a_refrac_index - swp->sw_refrac_index)
+	if (!EQUAL(sub_ap.a_refrac_index, swp->sw_refrac_index)
 	    && !rr_refract(incident_dir,		/* input direction */
 			   sub_ap.a_vvec,		/* exit normal */
 			   swp->sw_refrac_index,	/* current RI */
Index: external/Unigraphics/ug-g.c
===================================================================
--- external/Unigraphics/ug-g.c	(revision 54067)
+++ external/Unigraphics/ug-g.c	(working copy)
@@ -2778,7 +2778,7 @@
 	}
 	VSCALE( height, dir, tmp_ht );
 	radius4 = radius3 - round_rad * cos( angle );
-	if ( ZERO(radius2 - round_rad) ) {
+	if ( EQUAL(radius2, round_rad) ) {
 	    /* bottom is spherical */
 	    point_t center;
 
Index: external/ProEngineer/proe-brl.c
===================================================================
--- external/ProEngineer/proe-brl.c	(revision 54067)
+++ external/ProEngineer/proe-brl.c	(working copy)
@@ -3137,12 +3137,12 @@
 	error_increment = 0;
 	angle_increment = 0;
     } else {
-	if (ZERO((max_error - min_error)))
+	if (EQUAL((max_error, min_error)))
 	    error_increment = 0;
 	else
 	    error_increment = (max_error - min_error) / (double)max_to_min_steps;
 
-	if (ZERO((max_angle_cntrl - min_angle_cntrl)))
+	if (EQUAL((max_angle_cntrl, min_angle_cntrl)))
 	    angle_increment = 0;
 	else
 	    angle_increment = (max_angle_cntrl - min_angle_cntrl) / (double)max_to_min_steps;
Index: anim/anim_fly.c
===================================================================
--- anim/anim_fly.c	(revision 54067)
+++ anim/anim_fly.c	(working copy)
@@ -134,7 +134,7 @@
     *p_pch = xyz2pch(vel);
     *p_rll = bank(accel, vel);
 
-    if (ZERO(fabs(*p_pch) - 90.0)) /* don't change yaw if velocity vertical */
+    if (EQUAL(fabs(*p_pch), 90.0)) /* don't change yaw if velocity vertical */
 	*p_yaw = last_yaw;
 
     /* avoid sudden yaw changes in vertical loops */
Index: rt/viewweight.c
===================================================================
--- rt/viewweight.c	(revision 54067)
+++ rt/viewweight.c	(working copy)
@@ -351,22 +351,22 @@
      * for mass. Once it does, this section should be
      * reorganized.*/
 
-    if (ZERO(dbp->dbi_local2base - 304.8)) {
+    if (EQUAL(dbp->dbi_local2base, 304.8)) {
 	/* Feet */
 	bu_strlcpy(units, "grams", sizeof(units));
-    } else if (ZERO(dbp->dbi_local2base - 25.4)) {
+    } else if (EQUAL(dbp->dbi_local2base, 25.4)) {
 	/* inches */
 	conversion = 0.002204623;  /* lbs./gram */
 	bu_strlcpy(units, "lbs.", sizeof(units));
-    } else if (ZERO(dbp->dbi_local2base - 1.0)) {
+    } else if (EQUAL(dbp->dbi_local2base, 1.0)) {
 	/* mm */
 	conversion = 0.001;  /* kg/gram */
 	bu_strlcpy(units, "kg", sizeof(units));
-    } else if (ZERO(dbp->dbi_local2base - 1000.0)) {
+    } else if (EQUAL(dbp->dbi_local2base, 1000.0)) {
 	/* km */
 	conversion = 0.001;  /* kg/gram */
 	bu_strlcpy(units, "kg", sizeof(units));
-    } else if (ZERO(dbp->dbi_local2base - 0.1)) {
+    } else if (EQUAL(dbp->dbi_local2base, 0.1)) {
 	/* cm */
 	bu_strlcpy(units, "grams", sizeof(units));
     } else {
Index: rt/viewarea.c
===================================================================
--- rt/viewarea.c	(revision 54067)
+++ rt/viewarea.c	(working copy)
@@ -653,17 +653,17 @@
  */
 static double
 set_factor() {
-if (ZERO(units - 1.0))
+if (EQUAL(units, 1.0))
 	return bu_units_conversion("m");
-    else if (ZERO(units - 10.0))
+    else if (EQUAL(units, 10.0))
 	return bu_units_conversion("m");
-    else if (ZERO(units - 100.0))
+    else if (EQUAL(units, 100.0))
 	return bu_units_conversion("m");
-    else if (ZERO(units - 1000.0))
+    else if (EQUAL(units, 1000.0))
 	return bu_units_conversion("km");
-    else if (ZERO(units - 25.4))
+    else if (EQUAL(units, 25.4))
 	return bu_units_conversion("ft");
-    else if (ZERO(units - 304.8))
+    else if (EQUAL(units, 304.8))
 	return bu_units_conversion("yd");
     else
 	return bu_units_conversion("mm");
