diff --git a/modcc/expression.hpp b/modcc/expression.hpp
index 4d131b44c81c5f2aeddcb2ddab4abe8f8d4ae74f..50c5c1b1c34aac5ed63f0d937e94de93e59fc255 100644
--- a/modcc/expression.hpp
+++ b/modcc/expression.hpp
@@ -330,11 +330,11 @@ public:
         : Expression(loc), value_(std::stold(value))
     {}
 
-    NumberExpression(Location loc, long double value)
+    NumberExpression(Location loc, double value)
         : Expression(loc), value_(value)
     {}
 
-    virtual long double value() const {return value_;};
+    virtual double value() const {return value_;};
 
     std::string to_string() const override {
         return purple(pprintf("%", value_));
@@ -350,7 +350,7 @@ public:
 
     void accept(Visitor *v) override;
 private:
-    long double value_;
+    double value_;
 };
 
 // an integral number
@@ -361,7 +361,7 @@ public:
     {}
 
     IntegerExpression(Location loc, long long integer)
-        : NumberExpression(loc, static_cast<long double>(integer)), integer_(integer)
+        : NumberExpression(loc, static_cast<double>(integer)), integer_(integer)
     {}
 
     long long integer_value() const {return integer_;}
diff --git a/modcc/symdiff.cpp b/modcc/symdiff.cpp
index 03b3d4f20448b086032ca912421afa37c7f57009..ef5e3222f937a7dbfdfa93e3c9738c5a93db7945 100644
--- a/modcc/symdiff.cpp
+++ b/modcc/symdiff.cpp
@@ -262,7 +262,7 @@ private:
     std::string id_;
 };
 
-long double expr_value(Expression* e) {
+double expr_value(Expression* e) {
     return e && e->is_number()? e->is_number()->value(): NAN;
 }
 
@@ -273,7 +273,7 @@ private:
     static bool is_number(Expression* e) { return e && e->is_number(); }
     static bool is_number(const expression_ptr& e) { return is_number(e.get()); }
 
-    void as_number(Location loc, long double v) {
+    void as_number(Location loc, double v) {
         result_ = make_expression<NumberExpression>(loc, v);
     }
 
@@ -293,7 +293,7 @@ public:
         result_ = nullptr;
     }
 
-    long double value() const { return expr_value(result_); }
+    double value() const { return expr_value(result_); }
 
     bool is_number() const { return is_number(result_); }
 
diff --git a/modcc/symdiff.hpp b/modcc/symdiff.hpp
index 31c7150150e5b2dd47c48e8ae9372cb22848d7d6..9e8192150d88e670f0d321b49949755ac534c7ba 100644
--- a/modcc/symdiff.hpp
+++ b/modcc/symdiff.hpp
@@ -25,7 +25,7 @@ bool involves_identifier(Expression* e, const identifier_set& ids);
 expression_ptr constant_simplify(Expression* e);
 
 // Extract value of expression that is a NumberExpression, or else return NAN.
-long double expr_value(Expression* e);
+double expr_value(Expression* e);
 
 // Test if expression is a NumberExpression with value zero.
 inline bool is_zero(Expression* e) {
@@ -57,11 +57,11 @@ inline expression_ptr constant_simplify(const expression_ptr& e) {
     return constant_simplify(e.get());
 }
 
-inline long double expr_value(const expression_ptr& e) {
+inline double expr_value(const expression_ptr& e) {
     return expr_value(e.get());
 }
 
-inline long double is_zero(const expression_ptr& e) {
+inline double is_zero(const expression_ptr& e) {
     return is_zero(e.get());
 }
 
diff --git a/test/unit-modcc/test_parser.cpp b/test/unit-modcc/test_parser.cpp
index 10952756306fb90b3866f55cd9f4e89399c2ccfa..2bead45ea7b835db0260cbc586b1690c9bf51c01 100644
--- a/test/unit-modcc/test_parser.cpp
+++ b/test/unit-modcc/test_parser.cpp
@@ -580,7 +580,7 @@ TEST(Parser, parse_conserve) {
     }
 }
 
-long double eval(Expression *e) {
+double eval(Expression *e) {
     if (auto n = e->is_number()) {
         return n->value();
     }
@@ -606,7 +606,7 @@ long double eval(Expression *e) {
             default:;
         }
     }
-    return std::numeric_limits<long double>::quiet_NaN();
+    return std::numeric_limits<double>::quiet_NaN();
 }
 
 // test parsing of expressions for correctness
@@ -654,12 +654,6 @@ TEST(Parser, parse_binop) {
     for (const auto& test_case: tests) {
         std::unique_ptr<Expression> e;
         EXPECT_TRUE(check_parse(e, &Parser::parse_expression, test_case.first));
-
-        // A loose tolerance of 1e-10 is required here because the eval()
-        // function uses long double for intermediate results (like constant
-        // folding in modparser).  For expressions with transcendental
-        // operations this can see relatively large divergence between the
-        // double and long double results.
         EXPECT_NEAR(eval(e.get()), test_case.second, 1e-10);
     }
 }