diff --git a/include/xlnt/workbook/calculation_properties.hpp b/include/xlnt/workbook/calculation_properties.hpp
index 1b269a41..cd2e34ea 100644
--- a/include/xlnt/workbook/calculation_properties.hpp
+++ b/include/xlnt/workbook/calculation_properties.hpp
@@ -38,12 +38,12 @@ public:
     /// If this is older than the version of the Excel calculation engine opening
     /// the workbook, cell values will be recalculated.
     /// </summary>
-    std::size_t calc_id;
+    std::size_t calc_id = 0;
 
     /// <summary>
     /// If this is true, concurrent calculation will be enabled for the workbook.
     /// </summary>
-    bool concurrent_calc;
+    bool concurrent_calc = false;
 };
 
 inline bool operator==(const calculation_properties &lhs, const calculation_properties &rhs)
diff --git a/source/detail/default_case.hpp b/source/detail/default_case.hpp
index 0f484bf0..70074e24 100644
--- a/source/detail/default_case.hpp
+++ b/source/detail/default_case.hpp
@@ -28,7 +28,7 @@
 #define EXCEPT_ON_UNHANDLED_SWITCH_CASE
 
 #ifdef EXCEPT_ON_UNHANDLED_SWITCH_CASE
-#define default_case(default_value) throw xlnt::unhandled_switch_case();
+#define default_case(default_value) throw xlnt::unhandled_switch_case()
 #else
-#define default_case(default_value) return default_value;
+#define default_case(default_value) return default_value
 #endif
diff --git a/source/detail/implementations/workbook_impl.hpp b/source/detail/implementations/workbook_impl.hpp
index cab2d6c9..92a64a82 100644
--- a/source/detail/implementations/workbook_impl.hpp
+++ b/source/detail/implementations/workbook_impl.hpp
@@ -144,9 +144,9 @@ struct workbook_impl
     struct file_version_t
     {
         std::string app_name;
-        std::size_t last_edited;
-        std::size_t lowest_edited;
-        std::size_t rup_build;
+        std::size_t last_edited = 0;
+        std::size_t lowest_edited = 0;
+        std::size_t rup_build = 0;
 
         bool operator==(const file_version_t& rhs) const
         {
diff --git a/source/detail/serialization/xlsx_consumer.cpp b/source/detail/serialization/xlsx_consumer.cpp
index 4b21eacf..7ac2d5f5 100644
--- a/source/detail/serialization/xlsx_consumer.cpp
+++ b/source/detail/serialization/xlsx_consumer.cpp
@@ -245,10 +245,7 @@ xlnt::detail::Cell parse_cell(xlnt::row_t row_arg, xml::parser *parser)
         }
         }
         // Prevents unhandled exceptions from being triggered.
-        for (auto &attr : parser->attribute_map())
-        {
-            (void)attr;
-        }
+        parser->attribute_map();
     }
     return c;
 }
diff --git a/source/detail/serialization/xlsx_producer.cpp b/source/detail/serialization/xlsx_producer.cpp
index db8279af..105fb218 100644
--- a/source/detail/serialization/xlsx_producer.cpp
+++ b/source/detail/serialization/xlsx_producer.cpp
@@ -836,7 +836,7 @@ void xlsx_producer::write_rich_text(const std::string &ns, const xlnt::rich_text
                 if (run.second.get().has_size())
                 {
                     write_start_element(ns, "sz");
-                    write_attribute("val", run.second.get().size());
+                    write_attribute<double>("val", run.second.get().size());
                     write_end_element(ns, "sz");
                 }
 
@@ -1024,7 +1024,7 @@ void xlsx_producer::write_font(const font &f)
     if (f.has_size())
     {
         write_start_element(xmlns, "sz");
-        write_attribute("val", f.size());
+        write_attribute<double>("val", f.size());
         write_end_element(xmlns, "sz");
     }
 
@@ -1098,33 +1098,33 @@ void xlsx_producer::write_fill(const fill &f)
 
         if (gradient.degree() != 0.)
         {
-            write_attribute("degree", gradient.degree());
+            write_attribute<double>("degree", gradient.degree());
         }
 
         if (gradient.left() != 0.)
         {
-            write_attribute("left", gradient.left());
+            write_attribute<double>("left", gradient.left());
         }
 
         if (gradient.right() != 0.)
         {
-            write_attribute("right", gradient.right());
+            write_attribute<double>("right", gradient.right());
         }
 
         if (gradient.top() != 0.)
         {
-            write_attribute("top", gradient.top());
+            write_attribute<double>("top", gradient.top());
         }
 
         if (gradient.bottom() != 0.)
         {
-            write_attribute("bottom", gradient.bottom());
+            write_attribute<double>("bottom", gradient.bottom());
         }
 
         for (const auto &stop : gradient.stops())
         {
             write_start_element(xmlns, "stop");
-            write_attribute("position", stop.first);
+            write_attribute<double>("position", stop.first);
             write_start_element(xmlns, "color");
             write_color(stop.second);
             write_end_element(xmlns, "color");
@@ -2376,21 +2376,21 @@ void xlsx_producer::write_worksheet(const relationship &rel)
 
     if (format_properties.base_col_width.is_set())
     {
-        write_attribute("baseColWidth",
+        write_attribute<double>("baseColWidth",
             format_properties.base_col_width.get());
     }
     if (format_properties.default_column_width.is_set())
     {
-        write_attribute("defaultColWidth",
+        write_attribute<double>("defaultColWidth",
             format_properties.default_column_width.get());
     }
 
-    write_attribute("defaultRowHeight",
+    write_attribute<double>("defaultRowHeight",
         format_properties.default_row_height);
 
     if (format_properties.dy_descent.is_set())
     {
-        write_attribute(xml::qname(xmlns_x14ac, "dyDescent"),
+        write_attribute<double>(xml::qname(xmlns_x14ac, "dyDescent"),
             format_properties.dy_descent.get());
     }
 
@@ -2543,7 +2543,7 @@ void xlsx_producer::write_worksheet(const relationship &rel)
 
             if (props.dy_descent.is_set())
             {
-                write_attribute(xml::qname(xmlns_x14ac, "dyDescent"), props.dy_descent.get());
+                write_attribute<double>(xml::qname(xmlns_x14ac, "dyDescent"), props.dy_descent.get());
             }
         }
 
@@ -2813,12 +2813,12 @@ void xlsx_producer::write_worksheet(const relationship &rel)
     {
         write_start_element(xmlns, "pageMargins");
 
-        write_attribute("left", ws.page_margins().left());
-        write_attribute("right", ws.page_margins().right());
-        write_attribute("top", ws.page_margins().top());
-        write_attribute("bottom", ws.page_margins().bottom());
-        write_attribute("header", ws.page_margins().header());
-        write_attribute("footer", ws.page_margins().footer());
+        write_attribute<double>("left", ws.page_margins().left());
+        write_attribute<double>("right", ws.page_margins().right());
+        write_attribute<double>("top", ws.page_margins().top());
+        write_attribute<double>("bottom", ws.page_margins().bottom());
+        write_attribute<double>("header", ws.page_margins().header());
+        write_attribute<double>("footer", ws.page_margins().footer());
 
         write_end_element(xmlns, "pageMargins");
     }
diff --git a/source/detail/serialization/xlsx_producer.hpp b/source/detail/serialization/xlsx_producer.hpp
index 80afdf01..d49bcab1 100644
--- a/source/detail/serialization/xlsx_producer.hpp
+++ b/source/detail/serialization/xlsx_producer.hpp
@@ -178,11 +178,18 @@ private:
         current_part_serializer_->attribute(name, value);
     }
 
+    template <typename Floating, std::enable_if_t<std::is_floating_point<Floating>::value, bool> = true>
     void write_attribute(const std::string &name, double value)
     {
         current_part_serializer_->attribute(name, converter_.serialise(value));
     }
 
+    template <typename Integer, std::enable_if_t<std::is_integral<Integer>::value, bool> = true>
+    void write_attribute(const std::string &name, Integer value)
+    {
+        current_part_serializer_->attribute(name, std::to_string(value));
+    }
+
     // qname attribute name
     // not integer or float type
     template <typename T, typename = typename std::enable_if<!std::is_convertible<T, double>::value>::type>
@@ -191,11 +198,18 @@ private:
         current_part_serializer_->attribute(name, value);
     }
 
+    template <typename Floating, std::enable_if_t<std::is_floating_point<Floating>::value, bool> = true>
     void write_attribute(const xml::qname &name, double value)
     {
         current_part_serializer_->attribute(name, converter_.serialise(value));
     }
 
+    template <typename Integer, std::enable_if_t<std::is_integral<Integer>::value, bool> = true>
+    void write_attribute(const xml::qname &name, Integer value)
+    {
+        current_part_serializer_->attribute(name, std::to_string(value));
+    }
+
 
     template <typename T>
     void write_characters(T characters, bool preserve_whitespace = false)
diff --git a/source/utils/time.cpp b/source/utils/time.cpp
index d2bbe25c..a76f70f1 100644
--- a/source/utils/time.cpp
+++ b/source/utils/time.cpp
@@ -117,9 +117,8 @@ double time::to_number() const
     microseconds += static_cast<std::uint64_t>(minute * 1e6 * 60);
     auto microseconds_per_hour = static_cast<std::uint64_t>(1e6) * 60 * 60;
     microseconds += static_cast<std::uint64_t>(hour) * microseconds_per_hour;
-    auto number = microseconds / (24.0 * microseconds_per_hour);
-    auto hundred_billion = static_cast<std::uint64_t>(1e9) * 100;
-    number = std::floor(number * hundred_billion + 0.5) / hundred_billion;
+    auto number = static_cast<double>(microseconds) / (24.0 * static_cast<double>(microseconds_per_hour));
+    number = std::floor(number * 100e9 + 0.5) / 100e9;
 
     return number;
 }
diff --git a/source/utils/timedelta.cpp b/source/utils/timedelta.cpp
index 16b4a4f2..43ebd473 100644
--- a/source/utils/timedelta.cpp
+++ b/source/utils/timedelta.cpp
@@ -44,9 +44,8 @@ double timedelta::to_number() const
     total_microseconds += static_cast<std::uint64_t>(minutes * 1e6 * 60);
     auto microseconds_per_hour = static_cast<std::uint64_t>(1e6) * 60 * 60;
     total_microseconds += static_cast<std::uint64_t>(hours) * microseconds_per_hour;
-    auto number = total_microseconds / (24.0 * microseconds_per_hour);
-    auto hundred_billion = static_cast<std::uint64_t>(1e9) * 100;
-    number = std::floor(number * hundred_billion + 0.5) / hundred_billion;
+    auto number = static_cast<double>(total_microseconds) / (24.0 * static_cast<double>(microseconds_per_hour));
+    number = std::floor(number * 100e9 + 0.5) / 100e9;
     number += days;
 
     return number;
diff --git a/third-party/miniz/miniz.c b/third-party/miniz/miniz.c
index 9ded4c75..f408fdfd 100644
--- a/third-party/miniz/miniz.c
+++ b/third-party/miniz/miniz.c
@@ -3076,7 +3076,7 @@ static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream)
 #define MZ_DELETE_FILE remove
 
 #else
-#pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.")
+//#pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.")
 #ifndef MINIZ_NO_TIME
 #include <utime.h>
 #endif