diff --git a/src/EnergyPlus/AirLoopHVACDOAS.cc b/src/EnergyPlus/AirLoopHVACDOAS.cc
index 4efa2ffc108..40f255f0887 100644
--- a/src/EnergyPlus/AirLoopHVACDOAS.cc
+++ b/src/EnergyPlus/AirLoopHVACDOAS.cc
@@ -1158,8 +1158,7 @@ namespace AirLoopHVACDOAS {
                     ++loop.ConveCount;
                     ShowWarningError(state, std::format("Convergence limit is above 1.0e-6 for unit={}", loop.Name));
                     ShowContinueErrorTimeStamp(
-                        state,
-                        EnergyPlus::format("The max difference of node temperatures between AirLoopDOAS outlet and OA mixer inlet ={:.6R}", maxDiff));
+                        state, std::format("The max difference of node temperatures between AirLoopDOAS outlet and OA mixer inlet ={:.6f}", maxDiff));
                 } else {
                     ++loop.ConveCount;
                     ShowRecurringWarningErrorAtEnd(
diff --git a/src/EnergyPlus/Autosizing/Base.cc b/src/EnergyPlus/Autosizing/Base.cc
index 615f02d4a1f..57b6d1283db 100644
--- a/src/EnergyPlus/Autosizing/Base.cc
+++ b/src/EnergyPlus/Autosizing/Base.cc
@@ -313,7 +313,11 @@ void BaseSizer::reportSizerOutput(EnergyPlusData &state,
 
     static constexpr std::string_view Format_990(
         "! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n");
-    static constexpr std::string_view Format_991(" Component Sizing Information, {}, {}, {}, {:.5R}\n");
+    static constexpr std::string_view Format_991(" Component Sizing Information, {}, {}, {}, {:#.7G}\n");
+    static constexpr std::string_view Format_991_HumRat(" Component Sizing Information, {}, {}, {}, {:.3E}\n");
+    auto const sizingFormat = [](std::string_view description) {
+        return description.find("Humidity Ratio") != std::string_view::npos ? Format_991_HumRat : Format_991;
+    };
 
     // to do, make this a parameter. Unfortunately this function is used in MANY
     // places so it involves touching most of E+
@@ -322,12 +326,12 @@ void BaseSizer::reportSizerOutput(EnergyPlusData &state,
         state.dataEnvrn->oneTimeCompRptHeaderFlag = false;
     }
 
-    print(state.files.eio, Format_991, CompType, CompName, VarDesc, VarValue);
+    print(state.files.eio, sizingFormat(VarDesc), CompType, CompName, VarDesc, VarValue);
     // add to tabular output reports
     OutputReportPredefined::AddCompSizeTableEntry(state, CompType, CompName, VarDesc, VarValue);
 
     if (present(UsrDesc) && present(UsrValue)) {
-        print(state.files.eio, Format_991, CompType, CompName, UsrDesc(), UsrValue());
+        print(state.files.eio, sizingFormat(UsrDesc()), CompType, CompName, UsrDesc(), UsrValue());
         OutputReportPredefined::AddCompSizeTableEntry(state, CompType, CompName, UsrDesc(), UsrValue);
     } else if (present(UsrDesc) || present(UsrValue)) {
         ShowFatalError(state, "ReportSizingOutput: (Developer Error) - called with user-specified description or value but not both.");
diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletHumRatSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletHumRatSizing.cc
index 153b4490b37..911b176540b 100644
--- a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletHumRatSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletHumRatSizing.cc
@@ -102,10 +102,10 @@ Real64 CoolingWaterDesAirOutletHumRatSizer::size(EnergyPlusData &state, Real64 _
                 this->callingRoutine + ":" + " Coil=\"" + this->compName + "\", Cooling Coil has leaving humidity ratio > entering humidity ratio.";
             this->addErrorMessage(msg);
             ShowWarningError(state, msg);
-            msg = EnergyPlus::format("    Wair,in =  {:.6R} [kgWater/kgDryAir]", this->dataDesInletAirHumRat);
+            msg = std::format("    Wair,in =  {:.3E} [kgWater/kgDryAir]", this->dataDesInletAirHumRat);
             this->addErrorMessage(msg);
             ShowContinueError(state, msg);
-            msg = EnergyPlus::format("    Wair,out = {:.6R} [kgWater/kgDryAir]", this->autoSizedValue);
+            msg = std::format("    Wair,out = {:.3E} [kgWater/kgDryAir]", this->autoSizedValue);
             this->addErrorMessage(msg);
             ShowContinueError(state, msg);
             if (this->dataDesInletAirHumRat > 0.016) {
@@ -116,7 +116,7 @@ Real64 CoolingWaterDesAirOutletHumRatSizer::size(EnergyPlusData &state, Real64 _
             msg = "....coil leaving humidity ratio will be reset to:";
             this->addErrorMessage(msg);
             ShowContinueError(state, msg);
-            msg = EnergyPlus::format("    Wair,out = {:.6R} [kgWater/kgDryAir]", this->autoSizedValue);
+            msg = std::format("    Wair,out = {:.3E} [kgWater/kgDryAir]", this->autoSizedValue);
             this->addErrorMessage(msg);
             ShowContinueError(state, msg);
         }
@@ -132,24 +132,24 @@ Real64 CoolingWaterDesAirOutletHumRatSizer::size(EnergyPlusData &state, Real64 _
                                   "temperature > design air entering humidity ratio.";
                 this->addErrorMessage(msg);
                 ShowWarningError(state, msg);
-                msg = EnergyPlus::format("    Wair,in =  {:.6R} [kgWater/kgDryAir]", this->dataDesInletAirHumRat);
+                msg = std::format("    Wair,in =  {:.3E} [kgWater/kgDryAir]", this->dataDesInletAirHumRat);
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
-                msg = EnergyPlus::format("    Wair,out = {:.6R} [kgWater/kgDryAir]", this->autoSizedValue);
+                msg = std::format("    Wair,out = {:.3E} [kgWater/kgDryAir]", this->autoSizedValue);
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
-                msg = EnergyPlus::format("    Inlet chilled water temperature = {:.3R} [C]", this->dataDesInletWaterTemp);
+                msg = std::format("    Inlet chilled water temperature = {:.3f} [C]", this->dataDesInletWaterTemp);
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
-                msg = EnergyPlus::format("    Minimum humidity ratio at saturation for inlet chilled water temperature = {:.6R} [kgWater/kgDryAir]",
-                                         desHumRatAtWaterInTemp);
+                msg = std::format("    Minimum humidity ratio at saturation for inlet chilled water temperature = {:.3E} [kgWater/kgDryAir]",
+                                  desHumRatAtWaterInTemp);
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
                 this->autoSizedValue = this->dataDesInletAirHumRat;
                 msg = "....coil leaving humidity ratio will be reset to:";
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
-                msg = EnergyPlus::format("    Wair,out = {:.6R} [kgWater/kgDryAir]", this->autoSizedValue);
+                msg = std::format("    Wair,out = {:.3E} [kgWater/kgDryAir]", this->autoSizedValue);
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
             }
diff --git a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc
index 2e90f0938e9..d47af44f57b 100644
--- a/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc
+++ b/src/EnergyPlus/Autosizing/CoolingWaterDesAirOutletTempSizing.cc
@@ -97,17 +97,17 @@ Real64 CoolingWaterDesAirOutletTempSizer::size(EnergyPlusData &state, Real64 _or
                                   "\", Cooling Coil has leaving air temperature < entering water temperature.";
                 this->addErrorMessage(msg);
                 ShowWarningError(state, msg);
-                msg = EnergyPlus::format("    Tair,out  =  {:.3R}", this->autoSizedValue);
+                msg = std::format("    Tair,out  =  {:.3f}", this->autoSizedValue);
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
-                msg = EnergyPlus::format("    Twater,in = {:.3R}", this->dataDesInletWaterTemp);
+                msg = std::format("    Twater,in = {:.3f}", this->dataDesInletWaterTemp);
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
                 this->autoSizedValue = this->dataDesInletWaterTemp + 0.5;
                 msg = "....coil leaving air temperature will be reset to:";
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
-                msg = EnergyPlus::format("    Tair,out = {:.3R}", this->autoSizedValue);
+                msg = std::format("    Tair,out = {:.3f}", this->autoSizedValue);
                 this->addErrorMessage(msg);
                 ShowContinueError(state, msg);
             }
@@ -156,14 +156,14 @@ Real64 CoolingWaterDesAirOutletTempSizer::size(EnergyPlusData &state, Real64 _or
                                   "\", Cooling Coil has leaving air temperature < entering water temperature.";
                 this->addErrorMessage(msg);
                 ShowWarningError(state, msg);
-                msg = EnergyPlus::format("    Tair,out  =  {:.3R}", this->autoSizedValue);
+                msg = std::format("    Tair,out  =  {:.3f}", this->autoSizedValue);
                 ShowContinueError(state, msg);
-                msg = EnergyPlus::format("    Twater,in = {:.3R}", this->dataDesInletWaterTemp);
+                msg = std::format("    Twater,in = {:.3f}", this->dataDesInletWaterTemp);
                 ShowContinueError(state, msg);
                 this->autoSizedValue = this->dataDesInletWaterTemp + 0.5;
                 msg = "....coil leaving air temperature will be reset to:";
                 ShowContinueError(state, msg);
-                msg = EnergyPlus::format("    Tair,out = {:.3R}", this->autoSizedValue);
+                msg = std::format("    Tair,out = {:.3f}", this->autoSizedValue);
                 ShowContinueError(state, msg);
             }
         }
diff --git a/src/EnergyPlus/BaseboardRadiator.cc b/src/EnergyPlus/BaseboardRadiator.cc
index 1e7141d2519..56d3d20bb10 100644
--- a/src/EnergyPlus/BaseboardRadiator.cc
+++ b/src/EnergyPlus/BaseboardRadiator.cc
@@ -685,12 +685,11 @@ namespace BaseboardRadiator {
                                         std::format(
                                             "SizeBaseboard: Potential issue with equipment sizing for ZoneHVAC:Baseboard:Convective:Water=\"{}\".",
                                             this->EquipID));
+                                    ShowContinueError(
+                                        state, std::format("User-Specified Maximum Water Flow Rate of {:.5f} [m3/s]", WaterVolFlowRateMaxUser));
                                     ShowContinueError(
                                         state,
-                                        EnergyPlus::format("User-Specified Maximum Water Flow Rate of {:.5R} [m3/s]", WaterVolFlowRateMaxUser));
-                                    ShowContinueError(state,
-                                                      EnergyPlus::format("differs from Design Size Maximum Water Flow Rate of {:.5R} [m3/s]",
-                                                                         WaterVolFlowRateMaxDes));
+                                        std::format("differs from Design Size Maximum Water Flow Rate of {:.5f} [m3/s]", WaterVolFlowRateMaxDes));
                                     ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                     ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                                 }
@@ -831,9 +830,9 @@ namespace BaseboardRadiator {
                                     ShowContinueError(
                                         state,
                                         std::format("Design UA set equal to design coil load for {}=\"{}\"", cCMO_BBRadiator_Water, this->EquipID));
-                                    ShowContinueError(state, EnergyPlus::format("Design coil load used during sizing = {:.5R} W.", DesCoilLoad));
-                                    ShowContinueError(
-                                        state, EnergyPlus::format("Inlet water temperature used during sizing = {:.5R} C.", this->WaterInletTemp));
+                                    ShowContinueError(state, std::format("Design coil load used during sizing = {:.5f} W.", DesCoilLoad));
+                                    ShowContinueError(state,
+                                                      std::format("Inlet water temperature used during sizing = {:.5f} C.", this->WaterInletTemp));
                                 }
                             }
                         } else { // baseboard design load is less than output at UA = 0.001 * design load so set UA to minimum value
@@ -847,9 +846,8 @@ namespace BaseboardRadiator {
                                                   std::format("Design UA set equal to 0.001 * design coil load for {}=\"{}\"",
                                                               cCMO_BBRadiator_Water,
                                                               this->EquipID));
-                                ShowContinueError(state, EnergyPlus::format("Design coil load used during sizing = {:.5R} W.", DesCoilLoad));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("Inlet water temperature used during sizing = {:.5R} C.", this->WaterInletTemp));
+                                ShowContinueError(state, std::format("Design coil load used during sizing = {:.5f} W.", DesCoilLoad));
+                                ShowContinueError(state, std::format("Inlet water temperature used during sizing = {:.5f} C.", this->WaterInletTemp));
                             }
                         }
 
@@ -879,9 +877,9 @@ namespace BaseboardRadiator {
                                         std::format(
                                             "SizeBaseboard: Potential issue with equipment sizing for ZoneHVAC:Baseboard:Convective:Water=\"{}\".",
                                             this->EquipID));
-                                    ShowContinueError(state, EnergyPlus::format("User-Specified U-Factor Times Area Value of {:.2R} [W/K]", UAUser));
-                                    ShowContinueError(
-                                        state, EnergyPlus::format("differs from Design Size U-Factor Times Area Value of {:.2R} [W/K]", UADes));
+                                    ShowContinueError(state, std::format("User-Specified U-Factor Times Area Value of {:.2f} [W/K]", UAUser));
+                                    ShowContinueError(state,
+                                                      std::format("differs from Design Size U-Factor Times Area Value of {:.2f} [W/K]", UADes));
                                     ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                     ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                                 }
diff --git a/src/EnergyPlus/BoilerSteam.cc b/src/EnergyPlus/BoilerSteam.cc
index 146891c381e..c5d9ce728f0 100644
--- a/src/EnergyPlus/BoilerSteam.cc
+++ b/src/EnergyPlus/BoilerSteam.cc
@@ -226,14 +226,13 @@ namespace BoilerSteam {
 
                 if (thisBoiler.MinPartLoadRat < 0.0) {
                     ShowSevereError(state, EnergyPlus::format("{}{}=\"{}\",", RoutineName, state.dataIPShortCut->cCurrentModuleObject, boilerName));
-                    ShowContinueError(state, EnergyPlus::format("Invalid {}={:.3R}", "Minimum Part Load Ratio", thisBoiler.MinPartLoadRat));
+                    ShowContinueError(state, std::format("Invalid {}={:.3f}", "Minimum Part Load Ratio", thisBoiler.MinPartLoadRat));
                     ErrorsFound = true;
                 }
 
                 if (thisBoiler.TempUpLimitBoilerOut == 0.0) {
                     ShowSevereError(state, EnergyPlus::format("{}{}=\"{}\",", RoutineName, state.dataIPShortCut->cCurrentModuleObject, boilerName));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("Invalid {}={:.3R}", "Design Outlet Steam Temperature", thisBoiler.TempUpLimitBoilerOut));
+                    ShowContinueError(state, std::format("Invalid {}={:.3f}", "Design Outlet Steam Temperature", thisBoiler.TempUpLimitBoilerOut));
                     ErrorsFound = true;
                 }
                 thisBoiler.BoilerInletNodeNum = Node::GetOnlySingleNode(state,
@@ -570,9 +569,8 @@ namespace BoilerSteam {
                             if (state.dataGlobal->DisplayExtraWarnings) {
                                 if ((std::abs(tmpNomCap - NomCapUser) / NomCapUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state, EnergyPlus::format("SizePump: Potential issue with equipment sizing for {}", this->Name));
-                                    ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Capacity of {:.2R} [W]", NomCapUser));
-                                    ShowContinueError(state,
-                                                      EnergyPlus::format("differs from Design Size Nominal Capacity of {:.2R} [W]", tmpNomCap));
+                                    ShowContinueError(state, std::format("User-Specified Nominal Capacity of {:.2f} [W]", NomCapUser));
+                                    ShowContinueError(state, std::format("differs from Design Size Nominal Capacity of {:.2f} [W]", tmpNomCap));
                                     ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                     ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                                 }
@@ -664,8 +662,8 @@ namespace BoilerSteam {
                 ShowSevereError(
                     state, EnergyPlus::format("Boiler:Steam=\"{}\", Saturation Pressure is greater than Maximum Operating Pressure,", this->Name));
                 ShowContinueError(state, "Lower Input Temperature");
-                ShowContinueError(state, EnergyPlus::format("Steam temperature=[{:.2R}] C", this->BoilerOutletTemp));
-                ShowContinueError(state, EnergyPlus::format("Refrigerant Saturation Pressure =[{:.0R}] Pa", this->BoilerPressCheck));
+                ShowContinueError(state, std::format("Steam temperature=[{:.2f}] C", this->BoilerOutletTemp));
+                ShowContinueError(state, std::format("Refrigerant Saturation Pressure =[{:.0f}] Pa", this->BoilerPressCheck));
             }
             ShowRecurringSevereErrorAtEnd(state,
                                           "Boiler:Steam=\"" + this->Name +
diff --git a/src/EnergyPlus/Boilers.cc b/src/EnergyPlus/Boilers.cc
index 61c084673d1..10be849d220 100644
--- a/src/EnergyPlus/Boilers.cc
+++ b/src/EnergyPlus/Boilers.cc
@@ -217,7 +217,7 @@ void GetBoilerInput(EnergyPlusData &state)
         thisBoiler.NomCap = inputProcessor->getRealFieldValue(boilerFields, boilerSchemaProps, "nominal_capacity");
         if (thisBoiler.NomCap == 0.0) {
             ShowSevereError(state, EnergyPlus::format("{}{}=\"{}\",", RoutineName, s_ipsc->cCurrentModuleObject, boilerName));
-            ShowContinueError(state, EnergyPlus::format("Invalid {}={:.2R}", "Nominal Capacity", thisBoiler.NomCap));
+            ShowContinueError(state, std::format("Invalid {}={:.2f}", "Nominal Capacity", thisBoiler.NomCap));
             ShowContinueError(state, "...Nominal Capacity must be greater than 0.0");
             ErrorsFound = true;
         }
@@ -228,7 +228,7 @@ void GetBoilerInput(EnergyPlusData &state)
         thisBoiler.NomEffic = inputProcessor->getRealFieldValue(boilerFields, boilerSchemaProps, "nominal_thermal_efficiency");
         if (thisBoiler.NomEffic == 0.0) {
             ShowSevereError(state, EnergyPlus::format("{}{}=\"{}\",", RoutineName, s_ipsc->cCurrentModuleObject, boilerName));
-            ShowContinueError(state, EnergyPlus::format("Invalid {}={:.3R}", "Nominal Thermal Efficiency", thisBoiler.NomEffic));
+            ShowContinueError(state, std::format("Invalid {}={:.3f}", "Nominal Thermal Efficiency", thisBoiler.NomEffic));
             ShowContinueError(state, "...Nominal Thermal Efficiency must be greater than 0.0");
             ErrorsFound = true;
         } else if (thisBoiler.NomEffic > 1.0) {
@@ -661,8 +661,8 @@ void BoilerSpecs::SizeBoiler(EnergyPlusData &state)
                         if (state.dataGlobal->DisplayExtraWarnings) {
                             if ((std::abs(tmpNomCap - NomCapUser) / NomCapUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeBoilerHotWater: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Capacity of {:.2R} [W]", NomCapUser));
-                                ShowContinueError(state, EnergyPlus::format("differs from Design Size Nominal Capacity of {:.2R} [W]", tmpNomCap));
+                                ShowContinueError(state, std::format("User-Specified Nominal Capacity of {:.2f} [W]", NomCapUser));
+                                ShowContinueError(state, std::format("differs from Design Size Nominal Capacity of {:.2f} [W]", tmpNomCap));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -715,11 +715,9 @@ void BoilerSpecs::SizeBoiler(EnergyPlusData &state)
                         if (state.dataGlobal->DisplayExtraWarnings) {
                             if ((std::abs(tmpBoilerVolFlowRate - VolFlowRateUser) / VolFlowRateUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeBoilerHotWater: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("User-Specified Design Water Flow Rate of {:.2R} [m3/s]", VolFlowRateUser));
+                                ShowContinueError(state, std::format("User-Specified Design Water Flow Rate of {:.2f} [m3/s]", VolFlowRateUser));
                                 ShowContinueError(
-                                    state,
-                                    EnergyPlus::format("differs from Design Size Design Water Flow Rate of {:.2R} [m3/s]", tmpBoilerVolFlowRate));
+                                    state, std::format("differs from Design Size Design Water Flow Rate of {:.2f} [m3/s]", tmpBoilerVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
diff --git a/src/EnergyPlus/CTElectricGenerator.cc b/src/EnergyPlus/CTElectricGenerator.cc
index 11ce62bf83b..0dd520ab1be 100644
--- a/src/EnergyPlus/CTElectricGenerator.cc
+++ b/src/EnergyPlus/CTElectricGenerator.cc
@@ -209,7 +209,7 @@ namespace CTElectricGenerator {
                 state.dataCTElectricGenerator->CTGenerator(genNum).RatedPowerOutput =
                     inputProcessor->getRealFieldValue(generatorFields, objectSchemaProps, "rated_power_output");
                 if (state.dataCTElectricGenerator->CTGenerator(genNum).RatedPowerOutput == 0.0) {
-                    ShowSevereError(state, EnergyPlus::format("Invalid {}={:.2R}", "rated_power_output", 0.0));
+                    ShowSevereError(state, std::format("Invalid {}={:.2f}", "rated_power_output", 0.0));
                     ShowContinueError(state, EnergyPlus::format("Entered in {}={}", state.dataIPShortCut->cCurrentModuleObject, generatorName));
                     ErrorsFound = true;
                 }
diff --git a/src/EnergyPlus/ChilledCeilingPanelSimple.cc b/src/EnergyPlus/ChilledCeilingPanelSimple.cc
index 825e2df65f9..4e7c0b6a431 100644
--- a/src/EnergyPlus/ChilledCeilingPanelSimple.cc
+++ b/src/EnergyPlus/ChilledCeilingPanelSimple.cc
@@ -331,7 +331,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                                 cCMO_CoolingPanel_Simple,
                                                 s_ipsc->cAlphaArgs(1),
                                                 s_ipsc->cNumericFieldNames(1)));
-            ShowContinueError(state, EnergyPlus::format("...reset to maximum value=[{:.2R}].", MaxWaterTempAvg));
+            ShowContinueError(state, std::format("...reset to maximum value=[{:.2f}].", MaxWaterTempAvg));
             thisCP.RatedWaterTemp = MaxWaterTempAvg;
         } else if (thisCP.RatedWaterTemp < MinWaterTempAvg - 0.001) {
             ShowWarningError(state,
@@ -340,7 +340,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                                 cCMO_CoolingPanel_Simple,
                                                 s_ipsc->cAlphaArgs(1),
                                                 s_ipsc->cNumericFieldNames(1)));
-            ShowContinueError(state, EnergyPlus::format("...reset to minimum value=[{:.2R}].", MinWaterTempAvg));
+            ShowContinueError(state, std::format("...reset to minimum value=[{:.2f}].", MinWaterTempAvg));
             thisCP.RatedWaterTemp = MinWaterTempAvg;
         }
 
@@ -352,7 +352,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                                 cCMO_CoolingPanel_Simple,
                                                 s_ipsc->cAlphaArgs(1),
                                                 s_ipsc->cNumericFieldNames(2)));
-            ShowContinueError(state, EnergyPlus::format("...reset to maximum value=[{:.2R}].", MaxWaterTempAvg));
+            ShowContinueError(state, std::format("...reset to maximum value=[{:.2f}].", MaxWaterTempAvg));
             thisCP.RatedZoneAirTemp = MaxWaterTempAvg;
         } else if (thisCP.RatedZoneAirTemp < MinWaterTempAvg - 0.001) {
             ShowWarningError(state,
@@ -361,7 +361,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                                 cCMO_CoolingPanel_Simple,
                                                 s_ipsc->cAlphaArgs(1),
                                                 s_ipsc->cNumericFieldNames(2)));
-            ShowContinueError(state, EnergyPlus::format("...reset to minimum value=[{:.2R}].", MinWaterTempAvg));
+            ShowContinueError(state, std::format("...reset to minimum value=[{:.2f}].", MinWaterTempAvg));
             thisCP.RatedZoneAirTemp = MinWaterTempAvg;
         }
 
@@ -373,7 +373,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                                 cCMO_CoolingPanel_Simple,
                                                 s_ipsc->cAlphaArgs(1),
                                                 s_ipsc->cNumericFieldNames(2)));
-            ShowContinueError(state, EnergyPlus::format("...reset to a default value=[{:.1R}].", WaterMassFlowDefault));
+            ShowContinueError(state, std::format("...reset to a default value=[{:.1f}].", WaterMassFlowDefault));
             thisCP.RatedWaterFlowRate = WaterMassFlowDefault;
         }
 
@@ -444,7 +444,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                          cCMO_CoolingPanel_Simple,
                                          s_ipsc->cAlphaArgs(1),
                                          s_ipsc->cNumericFieldNames(7)));
-            ShowContinueError(state, EnergyPlus::format("...reset to minimum value=[{:.2R}].", MinWaterFlowRate));
+            ShowContinueError(state, std::format("...reset to minimum value=[{:.2f}].", MinWaterFlowRate));
             thisCP.WaterVolFlowRateMax = MinWaterFlowRate;
         } else if (thisCP.WaterVolFlowRateMax > MaxWaterFlowRate) {
             ShowWarningError(state,
@@ -453,7 +453,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                          cCMO_CoolingPanel_Simple,
                                          s_ipsc->cAlphaArgs(1),
                                          s_ipsc->cNumericFieldNames(7)));
-            ShowContinueError(state, EnergyPlus::format("...reset to maximum value=[{:.2R}].", MaxWaterFlowRate));
+            ShowContinueError(state, std::format("...reset to maximum value=[{:.2f}].", MaxWaterFlowRate));
             thisCP.WaterVolFlowRateMax = MaxWaterFlowRate;
         }
 
@@ -514,7 +514,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                          cCMO_CoolingPanel_Simple,
                                          s_ipsc->cAlphaArgs(1),
                                          s_ipsc->cNumericFieldNames(10)));
-            ShowContinueError(state, EnergyPlus::format("...reset to minimum value=[{:.2R}].", MinFraction));
+            ShowContinueError(state, std::format("...reset to minimum value=[{:.2f}].", MinFraction));
             thisCP.FracRadiant = MinFraction;
         }
         if (thisCP.FracRadiant > MaxFraction) {
@@ -524,7 +524,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                          cCMO_CoolingPanel_Simple,
                                          s_ipsc->cAlphaArgs(1),
                                          s_ipsc->cNumericFieldNames(10)));
-            ShowContinueError(state, EnergyPlus::format("...reset to maximum value=[{:.2R}].", MaxFraction));
+            ShowContinueError(state, std::format("...reset to maximum value=[{:.2f}].", MaxFraction));
             thisCP.FracRadiant = MaxFraction;
         }
 
@@ -549,7 +549,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                          cCMO_CoolingPanel_Simple,
                                          s_ipsc->cAlphaArgs(1),
                                          s_ipsc->cNumericFieldNames(11)));
-            ShowContinueError(state, EnergyPlus::format("...reset to minimum value=[{:.3R}].", MinFraction));
+            ShowContinueError(state, std::format("...reset to minimum value=[{:.3f}].", MinFraction));
             thisCP.FracDistribPerson = MinFraction;
         }
         if (thisCP.FracDistribPerson > MaxFraction) {
@@ -559,7 +559,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                          cCMO_CoolingPanel_Simple,
                                          s_ipsc->cAlphaArgs(1),
                                          s_ipsc->cNumericFieldNames(11)));
-            ShowContinueError(state, EnergyPlus::format("...reset to maximum value=[{:.3R}].", MaxFraction));
+            ShowContinueError(state, std::format("...reset to maximum value=[{:.3f}].", MaxFraction));
             thisCP.FracDistribPerson = MaxFraction;
         }
 
@@ -611,7 +611,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                              cCMO_CoolingPanel_Simple,
                                              s_ipsc->cAlphaArgs(1),
                                              s_ipsc->cNumericFieldNames(SurfNum + 8)));
-                ShowContinueError(state, EnergyPlus::format("...reset to maximum value=[{:.2R}].", MaxFraction));
+                ShowContinueError(state, std::format("...reset to maximum value=[{:.2f}].", MaxFraction));
                 thisCP.TotSurfToDistrib = MaxFraction;
             }
             if (thisCP.FracDistribToSurf(SurfNum) < MinFraction) {
@@ -621,7 +621,7 @@ void GetCoolingPanelInput(EnergyPlusData &state)
                                              cCMO_CoolingPanel_Simple,
                                              s_ipsc->cAlphaArgs(1),
                                              s_ipsc->cNumericFieldNames(SurfNum + 8)));
-                ShowContinueError(state, EnergyPlus::format("...reset to maximum value=[{:.2R}].", MinFraction));
+                ShowContinueError(state, std::format("...reset to maximum value=[{:.2f}].", MinFraction));
                 thisCP.TotSurfToDistrib = MinFraction;
             }
             if (thisCP.SurfacePtr(SurfNum) != 0) {
@@ -1043,11 +1043,9 @@ void SizeCoolingPanel(EnergyPlusData &state, int const CoolingPanelNum)
                                         std::format("SizeCoolingPanel: Potential issue with equipment sizing for "
                                                     "ZoneHVAC:CoolingPanel:RadiantConvective:Water = \"{}\".",
                                                     thisCP.Name));
-                            ShowContinueError(state,
-                                              EnergyPlus::format("User-Specified Maximum Cool Water Flow of {:.5R} [m3/s]", WaterVolFlowMaxCoolUser));
+                            ShowContinueError(state, std::format("User-Specified Maximum Cool Water Flow of {:.5f} [m3/s]", WaterVolFlowMaxCoolUser));
                             ShowContinueError(
-                                state,
-                                EnergyPlus::format("differs from Design Size Maximum Cool Water Flow of {:.5R} [m3/s]", WaterVolFlowMaxCoolDes));
+                                state, std::format("differs from Design Size Maximum Cool Water Flow of {:.5f} [m3/s]", WaterVolFlowMaxCoolDes));
                             ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                             ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                         }
@@ -1239,13 +1237,12 @@ void CoolingPanelParams::CalcCoolingPanel(EnergyPlusData &state, int const Cooli
                                                    cCMO_CoolingPanel_Simple,
                                                    this->Name));
                     ShowContinueError(state, "Flow to the simple cooling panel will be shut-off to avoid condensation");
-                    ShowContinueError(state, EnergyPlus::format("Water inlet temperature = {:.2R}", waterInletTemp));
-                    ShowContinueError(
-                        state, EnergyPlus::format("Zone dew-point temperature + safety delta T= {:.2R}", DewPointTemp + this->CondDewPtDeltaT));
+                    ShowContinueError(state, std::format("Water inlet temperature = {:.2f}", waterInletTemp));
+                    ShowContinueError(state,
+                                      std::format("Zone dew-point temperature + safety delta T= {:.2f}", DewPointTemp + this->CondDewPtDeltaT));
                     ShowContinueErrorTimeStamp(state, "");
                     ShowContinueError(
-                        state,
-                        EnergyPlus::format("Note that a {:.4R} C safety was chosen in the input for the shut-off criteria", this->CondDewPtDeltaT));
+                        state, std::format("Note that a {:.4f} C safety was chosen in the input for the shut-off criteria", this->CondDewPtDeltaT));
                 }
                 ShowRecurringWarningErrorAtEnd(state,
                                                cCMO_CoolingPanel_Simple + " [" + this->Name + "] condensation shut-off occurrence continues.",
@@ -1592,16 +1589,16 @@ void DistributeCoolingPanelRadGains(EnergyPlusData &state)
                 if (ThisSurfIntensity > DataHeatBalFanSys::MaxRadHeatFlux) {
                     ShowSevereError(state, "DistributeCoolingPanelRadGains:  excessive thermal radiation heat flux intensity detected");
                     ShowContinueError(state, std::format("Surface = {}", ThisSurf.Name));
-                    ShowContinueError(state, EnergyPlus::format("Surface area = {:.3R} [m2]", ThisSurf.Area));
+                    ShowContinueError(state, std::format("Surface area = {:.3f} [m2]", ThisSurf.Area));
                     ShowContinueError(state, std::format("Occurs in {} = {}", cCMO_CoolingPanel_Simple, thisCP.Name));
-                    ShowContinueError(state, EnergyPlus::format("Radiation intensity = {:.2R} [W/m2]", ThisSurfIntensity));
+                    ShowContinueError(state, std::format("Radiation intensity = {:.2f} [W/m2]", ThisSurfIntensity));
                     ShowContinueError(state, std::format("Assign a larger surface area or more surfaces in {}", cCMO_CoolingPanel_Simple));
                     ShowFatalError(state, "DistributeCoolingPanelRadGains:  excessive thermal radiation heat flux intensity detected");
                 }
             } else {
                 ShowSevereError(state, "DistributeCoolingPanelRadGains:  surface not large enough to receive thermal radiation heat flux");
                 ShowContinueError(state, std::format("Surface = {}", ThisSurf.Name));
-                ShowContinueError(state, EnergyPlus::format("Surface area = {:.3R} [m2]", ThisSurf.Area));
+                ShowContinueError(state, std::format("Surface area = {:.3f} [m2]", ThisSurf.Area));
                 ShowContinueError(state, std::format("Occurs in {} = {}", cCMO_CoolingPanel_Simple, thisCP.Name));
                 ShowContinueError(state, std::format("Assign a larger surface area or more surfaces in {}", cCMO_CoolingPanel_Simple));
                 ShowFatalError(state, "DistributeCoolingPanelRadGains:  surface not large enough to receive thermal radiation heat flux");
diff --git a/src/EnergyPlus/ChillerAbsorption.cc b/src/EnergyPlus/ChillerAbsorption.cc
index 3eb434a7f98..b281fc0eb55 100644
--- a/src/EnergyPlus/ChillerAbsorption.cc
+++ b/src/EnergyPlus/ChillerAbsorption.cc
@@ -284,8 +284,8 @@ void GetBLASTAbsorberInput(EnergyPlusData &state)
             thisChiller.NomPumpPowerWasAutoSized = true;
         }
         if (state.dataIPShortCut->rNumericArgs(1) == 0.0) {
-            ShowSevereError(
-                state, EnergyPlus::format("Invalid {}={:.2R}", state.dataIPShortCut->cNumericFieldNames(1), state.dataIPShortCut->rNumericArgs(1)));
+            ShowSevereError(state,
+                            std::format("Invalid {}={:.2f}", state.dataIPShortCut->cNumericFieldNames(1), state.dataIPShortCut->rNumericArgs(1)));
             ShowContinueError(
                 state, EnergyPlus::format("Entered in {}={}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
             ErrorsFound = true;
@@ -474,8 +474,8 @@ void GetBLASTAbsorberInput(EnergyPlusData &state)
         }
 
         if (thisChiller.GeneratorVolFlowRate == 0.0 && thisChiller.GenHeatSourceType == Node::FluidType::Water) {
-            ShowSevereError(
-                state, EnergyPlus::format("Invalid {}={:.2R}", state.dataIPShortCut->cNumericFieldNames(16), state.dataIPShortCut->rNumericArgs(16)));
+            ShowSevereError(state,
+                            std::format("Invalid {}={:.2f}", state.dataIPShortCut->cNumericFieldNames(16), state.dataIPShortCut->rNumericArgs(16)));
             ShowContinueError(
                 state, EnergyPlus::format("Entered in {}={}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
             ShowContinueError(state, "...Generator water flow rate must be greater than 0 when absorber generator fluid type is hot water.");
@@ -977,8 +977,8 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                             if ((std::abs(tmpNomCap - NomCapUser) / NomCapUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state,
                                             EnergyPlus::format("SizeChillerAbsorption: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Capacity of {:.2R} [W]", NomCapUser));
-                                ShowContinueError(state, EnergyPlus::format("differs from Design Size Nominal Capacity of {:.2R} [W]", tmpNomCap));
+                                ShowContinueError(state, std::format("User-Specified Nominal Capacity of {:.2f} [W]", NomCapUser));
+                                ShowContinueError(state, std::format("differs from Design Size Nominal Capacity of {:.2f} [W]", tmpNomCap));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1028,9 +1028,8 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                     if (state.dataGlobal->DisplayExtraWarnings) {
                         if ((std::abs(tmpNomPumpPower - NomPumpPowerUser) / NomPumpPowerUser) > state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(state, std::format("SizeChillerAbsorption: Potential issue with equipment sizing for {}", this->Name));
-                            ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Pumping Power of {:.2R} [W]", NomPumpPowerUser));
-                            ShowContinueError(state,
-                                              EnergyPlus::format("differs from Design Size Nominal Pumping Power of {:.2R} [W]", tmpNomPumpPower));
+                            ShowContinueError(state, std::format("User-Specified Nominal Pumping Power of {:.2f} [W]", NomPumpPowerUser));
+                            ShowContinueError(state, std::format("differs from Design Size Nominal Pumping Power of {:.2f} [W]", tmpNomPumpPower));
                             ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                             ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                         }
@@ -1079,11 +1078,11 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                             if ((std::abs(tmpEvapVolFlowRate - EvapVolFlowRateUser) / EvapVolFlowRateUser) >
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeChillerAbsorption: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(
-                                    state, EnergyPlus::format("User-Specified Design Chilled Water Flow Rate of {:.5R} [m3/s]", EvapVolFlowRateUser));
                                 ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Chilled Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpEvapVolFlowRate));
+                                                  std::format("User-Specified Design Chilled Water Flow Rate of {:.5f} [m3/s]", EvapVolFlowRateUser));
+                                ShowContinueError(
+                                    state,
+                                    std::format("differs from Design Size Design Chilled Water Flow Rate of {:.5f} [m3/s]", tmpEvapVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1152,12 +1151,11 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                             if ((std::abs(tmpCondVolFlowRate - CondVolFlowRateUser) / CondVolFlowRateUser) >
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeChillerAbsorption: Potential issue with equipment sizing for {}", this->Name));
+                                ShowContinueError(
+                                    state, std::format("User-Specified Design Condenser Water Flow Rate of {:.5f} [m3/s]", CondVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("User-Specified Design Condenser Water Flow Rate of {:.5R} [m3/s]", CondVolFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Condenser Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpCondVolFlowRate));
+                                    std::format("differs from Design Size Design Condenser Water Flow Rate of {:.5f} [m3/s]", tmpCondVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1228,12 +1226,11 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                                         ShowMessage(state,
                                                     std::format("SizeChillerAbsorption: Potential issue with equipment sizing for {}", this->Name));
                                         ShowContinueError(state,
-                                                          EnergyPlus::format("User-Specified Design Generator Fluid Flow Rate of {:.5R} [m3/s]",
-                                                                             GeneratorVolFlowRateUser));
-                                        ShowContinueError(
-                                            state,
-                                            EnergyPlus::format("differs from Design Size Design Generator Fluid Flow Rate of {:.5R} [m3/s]",
-                                                               tmpGeneratorVolFlowRate));
+                                                          std::format("User-Specified Design Generator Fluid Flow Rate of {:.5f} [m3/s]",
+                                                                      GeneratorVolFlowRateUser));
+                                        ShowContinueError(state,
+                                                          std::format("differs from Design Size Design Generator Fluid Flow Rate of {:.5f} [m3/s]",
+                                                                      tmpGeneratorVolFlowRate));
                                         ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                         ShowContinueError(state,
                                                           "Verify that the value entered is intended and is consistent with other components.");
@@ -1295,12 +1292,11 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                                         ShowMessage(state,
                                                     std::format("SizeChillerAbsorption: Potential issue with equipment sizing for {}", this->Name));
                                         ShowContinueError(state,
-                                                          EnergyPlus::format("User-Specified Design Generator Fluid Flow Rate of {:.5R} [m3/s]",
-                                                                             GeneratorVolFlowRateUser));
-                                        ShowContinueError(
-                                            state,
-                                            EnergyPlus::format("differs from Design Size Design Generator Fluid Flow Rate of {:.5R} [m3/s]",
-                                                               tmpGeneratorVolFlowRate));
+                                                          std::format("User-Specified Design Generator Fluid Flow Rate of {:.5f} [m3/s]",
+                                                                      GeneratorVolFlowRateUser));
+                                        ShowContinueError(state,
+                                                          std::format("differs from Design Size Design Generator Fluid Flow Rate of {:.5f} [m3/s]",
+                                                                      tmpGeneratorVolFlowRate));
                                         ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                         ShowContinueError(state,
                                                           "Verify that the value entered is intended and is consistent with other components.");
diff --git a/src/EnergyPlus/ChillerElectricASHRAE205.cc b/src/EnergyPlus/ChillerElectricASHRAE205.cc
index 30a5eda6921..4ed2f1db023 100644
--- a/src/EnergyPlus/ChillerElectricASHRAE205.cc
+++ b/src/EnergyPlus/ChillerElectricASHRAE205.cc
@@ -188,7 +188,7 @@ void getChillerASHRAE205Input(EnergyPlusData &state)
         //        if (thisChiller.RefCap == 0.0) {
         //            ShowSevereError(
         //                state, format("{}{}=\"{}\"",std::string{RoutineName},state.dataIPShortCut->cCurrentModuleObject,thisChiller.Name);
-        //            ShowContinueError(state, format("Invalid {}={:.2R}", "Rated Capacity", thisChiller.RefCap));
+        //            ShowContinueError(state, format("Invalid {}={:.2f}", "Rated Capacity", thisChiller.RefCap));
         //            ErrorsFound = true;
         //        }
 
@@ -738,13 +738,12 @@ void ASHRAE205ChillerSpecs::size([[maybe_unused]] EnergyPlusData &state)
                             if ((std::abs(tmpEvapVolFlowRate - EvapVolFlowRateUser) / EvapVolFlowRateUser) >
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, EnergyPlus::format("{}: Potential issue with equipment sizing for {}", RoutineName, this->Name));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("User-Specified Chilled Water Maximum Requested Flow Rate of {:.5R} [m3/s]",
-                                                                     EvapVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("differs from Design Size Chilled Water Maximum Requested Flow Rate of {:.5R} [m3/s]",
-                                                       tmpEvapVolFlowRate));
+                                    std::format("User-Specified Chilled Water Maximum Requested Flow Rate of {:.5f} [m3/s]", EvapVolFlowRateUser));
+                                ShowContinueError(state,
+                                                  std::format("differs from Design Size Chilled Water Maximum Requested Flow Rate of {:.5f} [m3/s]",
+                                                              tmpEvapVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -810,12 +809,10 @@ void ASHRAE205ChillerSpecs::size([[maybe_unused]] EnergyPlusData &state)
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("{}: Potential issue with equipment sizing for {}", RoutineName, this->Name));
                                 ShowContinueError(
-                                    state,
-                                    EnergyPlus::format("User-Specified Condenser Maximum Requested Flow Rate of {:.5R} [m3/s]", CondVolFlowRateUser));
-                                ShowContinueError(
-                                    state,
-                                    EnergyPlus::format("differs from Design Size Condenser Maximum Requested Flow Rate of {:.5R} [m3/s]",
-                                                       tmpCondVolFlowRate));
+                                    state, std::format("User-Specified Condenser Maximum Requested Flow Rate of {:.5f} [m3/s]", CondVolFlowRateUser));
+                                ShowContinueError(state,
+                                                  std::format("differs from Design Size Condenser Maximum Requested Flow Rate of {:.5f} [m3/s]",
+                                                              tmpCondVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -905,8 +902,8 @@ void ASHRAE205ChillerSpecs::size([[maybe_unused]] EnergyPlusData &state)
                         if (state.dataGlobal->DisplayExtraWarnings) {
                             if ((std::abs(tmpNomCap - RefCapUser) / RefCapUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("{}: Potential issue with equipment sizing for {}", RoutineName, this->Name));
-                                ShowContinueError(state, EnergyPlus::format("User-Specified Rated Capacity of {:.2R} [W]", RefCapUser));
-                                ShowContinueError(state, EnergyPlus::format("differs from Design Size Rated Capacity of {:.2R} [W]", tmpNomCap));
+                                ShowContinueError(state, std::format("User-Specified Rated Capacity of {:.2f} [W]", RefCapUser));
+                                ShowContinueError(state, std::format("differs from Design Size Rated Capacity of {:.2f} [W]", tmpNomCap));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
diff --git a/src/EnergyPlus/ChillerElectricEIR.cc b/src/EnergyPlus/ChillerElectricEIR.cc
index 19b973b46f5..ceae2819f56 100644
--- a/src/EnergyPlus/ChillerElectricEIR.cc
+++ b/src/EnergyPlus/ChillerElectricEIR.cc
@@ -451,13 +451,13 @@ void GetElectricEIRChillerInput(EnergyPlusData &state)
         }
         if (s_ipsc->rNumericArgs(1) == 0.0) {
             ShowSevereError(state, EnergyPlus::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("Invalid {}={:.2R}", s_ipsc->cNumericFieldNames(1), s_ipsc->rNumericArgs(1)));
+            ShowContinueError(state, std::format("Invalid {}={:.2f}", s_ipsc->cNumericFieldNames(1), s_ipsc->rNumericArgs(1)));
             ErrorsFound = true;
         }
         thisChiller.RefCOP = s_ipsc->rNumericArgs(2);
         if (s_ipsc->rNumericArgs(2) == 0.0) {
             ShowSevereError(state, EnergyPlus::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("Invalid {}={:.2R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, std::format("Invalid {}={:.2f}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
             ErrorsFound = true;
         }
         thisChiller.TempRefEvapOut = s_ipsc->rNumericArgs(3);
@@ -483,18 +483,18 @@ void GetElectricEIRChillerInput(EnergyPlusData &state)
         if (thisChiller.MinPartLoadRat > thisChiller.MaxPartLoadRat) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
             ShowContinueError(state,
-                              EnergyPlus::format("{} [{:.3R}] > {} [{:.3R}]",
-                                                 s_ipsc->cNumericFieldNames(7),
-                                                 s_ipsc->rNumericArgs(7),
-                                                 s_ipsc->cNumericFieldNames(8),
-                                                 s_ipsc->rNumericArgs(8)));
+                              std::format("{} [{:.3f}] > {} [{:.3f}]",
+                                          s_ipsc->cNumericFieldNames(7),
+                                          s_ipsc->rNumericArgs(7),
+                                          s_ipsc->cNumericFieldNames(8),
+                                          s_ipsc->rNumericArgs(8)));
             ShowContinueError(state, "Minimum part load ratio must be less than or equal to the maximum part load ratio ");
             ErrorsFound = true;
         }
 
         if (thisChiller.MinUnloadRat < thisChiller.MinPartLoadRat || thisChiller.MinUnloadRat > thisChiller.MaxPartLoadRat) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("{} = {:.3R}", s_ipsc->cNumericFieldNames(10), s_ipsc->rNumericArgs(10)));
+            ShowContinueError(state, std::format("{} = {:.3f}", s_ipsc->cNumericFieldNames(10), s_ipsc->rNumericArgs(10)));
             ShowContinueError(
                 state, std::format("{} must be greater than or equal to the {}", s_ipsc->cNumericFieldNames(10), s_ipsc->cNumericFieldNames(7)));
             ShowContinueError(state,
@@ -504,7 +504,7 @@ void GetElectricEIRChillerInput(EnergyPlusData &state)
 
         if (thisChiller.OptPartLoadRat < thisChiller.MinPartLoadRat || thisChiller.OptPartLoadRat > thisChiller.MaxPartLoadRat) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("{} = {:.3R}", s_ipsc->cNumericFieldNames(9), s_ipsc->rNumericArgs(9)));
+            ShowContinueError(state, std::format("{} = {:.3f}", s_ipsc->cNumericFieldNames(9), s_ipsc->rNumericArgs(9)));
             ShowContinueError(
                 state, std::format("{} must be greater than or equal to the {}", s_ipsc->cNumericFieldNames(9), s_ipsc->cNumericFieldNames(7)));
             ShowContinueError(state,
@@ -517,7 +517,7 @@ void GetElectricEIRChillerInput(EnergyPlusData &state)
 
         if (thisChiller.CompPowerToCondenserFrac < 0.0 || thisChiller.CompPowerToCondenserFrac > 1.0) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("{} = {:.3R}", s_ipsc->cNumericFieldNames(12), s_ipsc->rNumericArgs(12)));
+            ShowContinueError(state, std::format("{} = {:.3f}", s_ipsc->cNumericFieldNames(12), s_ipsc->rNumericArgs(12)));
             ShowContinueError(state, std::format("{} must be greater than or equal to zero", s_ipsc->cNumericFieldNames(12)));
             ShowContinueError(state, std::format("{} must be less than or equal to one", s_ipsc->cNumericFieldNames(12)));
             ErrorsFound = true;
@@ -1409,12 +1409,11 @@ void ElectricEIRChillerSpecs::size(EnergyPlusData &state)
                             if ((std::abs(tmpEvapVolFlowRate - EvapVolFlowRateUser) / EvapVolFlowRateUser) >
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeChillerElectricEIR: Potential issue with equipment sizing for {}", this->Name));
+                                ShowContinueError(
+                                    state, std::format("User-Specified Reference Chilled Water Flow Rate of {:.5f} [m3/s]", EvapVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("User-Specified Reference Chilled Water Flow Rate of {:.5R} [m3/s]", EvapVolFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Reference Chilled Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpEvapVolFlowRate));
+                                    std::format("differs from Design Size Reference Chilled Water Flow Rate of {:.5f} [m3/s]", tmpEvapVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1470,8 +1469,8 @@ void ElectricEIRChillerSpecs::size(EnergyPlusData &state)
                         if (state.dataGlobal->DisplayExtraWarnings) {
                             if ((std::abs(tmpNomCap - RefCapUser) / RefCapUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeChillerElectricEIR: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state, EnergyPlus::format("User-Specified Reference Capacity of {:.2R} [W]", RefCapUser));
-                                ShowContinueError(state, EnergyPlus::format("differs from Design Size Reference Capacity of {:.2R} [W]", tmpNomCap));
+                                ShowContinueError(state, std::format("User-Specified Reference Capacity of {:.2f} [W]", RefCapUser));
+                                ShowContinueError(state, std::format("differs from Design Size Reference Capacity of {:.2f} [W]", tmpNomCap));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1534,12 +1533,11 @@ void ElectricEIRChillerSpecs::size(EnergyPlusData &state)
                             if ((std::abs(tmpCondVolFlowRate - CondVolFlowRateUser) / CondVolFlowRateUser) >
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeChillerElectricEIR: Potential issue with equipment sizing for {}", this->Name));
+                                ShowContinueError(
+                                    state, std::format("User-Specified Reference Condenser Fluid Flow Rate of {:.5f} [m3/s]", CondVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("User-Specified Reference Condenser Fluid Flow Rate of {:.5R} [m3/s]", CondVolFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Reference Condenser Fluid Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpCondVolFlowRate));
+                                    std::format("differs from Design Size Reference Condenser Fluid Flow Rate of {:.5f} [m3/s]", tmpCondVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1640,12 +1638,11 @@ void ElectricEIRChillerSpecs::size(EnergyPlusData &state)
                         if ((std::abs(tempHeatRecVolFlowRate - nomHeatRecVolFlowRateUser) / nomHeatRecVolFlowRateUser) >
                             state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(state, std::format("SizeChillerElectricEIR: Potential issue with equipment sizing for {}", this->Name));
+                            ShowContinueError(
+                                state, std::format("User-Specified Heat Recovery Water Flow Rate of {:.5f} [m3/s]", nomHeatRecVolFlowRateUser));
                             ShowContinueError(
                                 state,
-                                EnergyPlus::format("User-Specified Heat Recovery Water Flow Rate of {:.5R} [m3/s]", nomHeatRecVolFlowRateUser));
-                            ShowContinueError(state,
-                                              EnergyPlus::format("differs from Design Size Heat Recovery Water Flow Rate of {:.5R} [m3/s]",
-                                                                 tempHeatRecVolFlowRate));
+                                std::format("differs from Design Size Heat Recovery Water Flow Rate of {:.5f} [m3/s]", tempHeatRecVolFlowRate));
                             ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                             ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                         }
@@ -1986,13 +1983,12 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b
         if (this->ChillerCapFTError < 1 && this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerCapFTError;
             ShowWarningError(state, std::format("CHILLER:ELECTRIC:EIR \"{}\":", this->Name));
-            ShowContinueError(
-                state, EnergyPlus::format(" Chiller Capacity as a Function of Temperature curve output is negative ({:.3R}).", this->ChillerCapFT));
-            ShowContinueError(
-                state,
-                EnergyPlus::format(" Negative value occurs using an Evaporator Outlet Temp of {:.1R} and a Condenser Inlet Temp of {:.1R}.",
-                                   EvapOutletTempSetPoint,
-                                   condInletTemp));
+            ShowContinueError(state,
+                              std::format(" Chiller Capacity as a Function of Temperature curve output is negative ({:.3f}).", this->ChillerCapFT));
+            ShowContinueError(state,
+                              std::format(" Negative value occurs using an Evaporator Outlet Temp of {:.1f} and a Condenser Inlet Temp of {:.1f}.",
+                                          EvapOutletTempSetPoint,
+                                          condInletTemp));
             ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation.");
         } else if (this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerCapFTError;
@@ -2259,13 +2255,11 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b
         if (this->ChillerEIRFTError < 1 && this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerEIRFTError;
             ShowWarningError(state, std::format("CHILLER:ELECTRIC:EIR \"{}\":", this->Name));
+            ShowContinueError(state, std::format(" Chiller EIR as a Function of Temperature curve output is negative ({:.3f}).", this->ChillerEIRFT));
             ShowContinueError(state,
-                              EnergyPlus::format(" Chiller EIR as a Function of Temperature curve output is negative ({:.3R}).", this->ChillerEIRFT));
-            ShowContinueError(
-                state,
-                EnergyPlus::format(" Negative value occurs using an Evaporator Outlet Temp of {:.1R} and a Condenser Inlet Temp of {:.1R}.",
-                                   this->EvapOutletTemp,
-                                   condInletTemp));
+                              std::format(" Negative value occurs using an Evaporator Outlet Temp of {:.1f} and a Condenser Inlet Temp of {:.1f}.",
+                                          this->EvapOutletTemp,
+                                          condInletTemp));
             ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation.");
         } else if (this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerEIRFTError;
@@ -2284,9 +2278,8 @@ void ElectricEIRChillerSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, b
         if (this->ChillerEIRFPLRError < 1 && this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerEIRFPLRError;
             ShowWarningError(state, std::format("CHILLER:ELECTRIC:EIR \"{}\":", this->Name));
-            ShowContinueError(state,
-                              EnergyPlus::format(" Chiller EIR as a function of PLR curve output is negative ({:.3R}).", this->ChillerEIRFPLR));
-            ShowContinueError(state, EnergyPlus::format(" Negative value occurs using a part-load ratio of {:.3R}.", PartLoadRat));
+            ShowContinueError(state, std::format(" Chiller EIR as a function of PLR curve output is negative ({:.3f}).", this->ChillerEIRFPLR));
+            ShowContinueError(state, std::format(" Negative value occurs using a part-load ratio of {:.3f}.", PartLoadRat));
             ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation.");
         } else if (this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerEIRFPLRError;
diff --git a/src/EnergyPlus/ChillerExhaustAbsorption.cc b/src/EnergyPlus/ChillerExhaustAbsorption.cc
index 0fac70c7596..29541e212c6 100644
--- a/src/EnergyPlus/ChillerExhaustAbsorption.cc
+++ b/src/EnergyPlus/ChillerExhaustAbsorption.cc
@@ -1122,8 +1122,8 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("SizeChillerHeaterAbsorptionDoubleEffect: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Capacity of {:.2R} [W]", NomCapUser));
-                                ShowContinueError(state, EnergyPlus::format("differs from Design Size Nominal Capacity of {:.2R} [W]", tmpNomCap));
+                                ShowContinueError(state, std::format("User-Specified Nominal Capacity of {:.2f} [W]", NomCapUser));
+                                ShowContinueError(state, std::format("differs from Design Size Nominal Capacity of {:.2f} [W]", tmpNomCap));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1197,11 +1197,11 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("SizeChillerAbsorptionDoubleEffect: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(
-                                    state, EnergyPlus::format("User-Specified Design Chilled Water Flow Rate of {:.5R} [m3/s]", EvapVolFlowRateUser));
                                 ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Chilled Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpEvapVolFlowRate));
+                                                  std::format("User-Specified Design Chilled Water Flow Rate of {:.5f} [m3/s]", EvapVolFlowRateUser));
+                                ShowContinueError(
+                                    state,
+                                    std::format("differs from Design Size Design Chilled Water Flow Rate of {:.5f} [m3/s]", tmpEvapVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1280,11 +1280,11 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("SizeChillerHeaterAbsorptionDoubleEffect: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(
-                                    state, EnergyPlus::format("User-Specified Design Hot Water Flow Rate of {:.5R} [m3/s]", HeatRecVolFlowRateUser));
                                 ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Hot Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpHeatRecVolFlowRate));
+                                                  std::format("User-Specified Design Hot Water Flow Rate of {:.5f} [m3/s]", HeatRecVolFlowRateUser));
+                                ShowContinueError(
+                                    state,
+                                    std::format("differs from Design Size Design Hot Water Flow Rate of {:.5f} [m3/s]", tmpHeatRecVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1366,12 +1366,11 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("SizeChillerAbsorptionDoubleEffect: Potential issue with equipment sizing for {}", this->Name));
+                                ShowContinueError(
+                                    state, std::format("User-Specified Design Condenser Water Flow Rate of {:.5f} [m3/s]", CondVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("User-Specified Design Condenser Water Flow Rate of {:.5R} [m3/s]", CondVolFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Condenser Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpCondVolFlowRate));
+                                    std::format("differs from Design Size Design Condenser Water Flow Rate of {:.5f} [m3/s]", tmpCondVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
diff --git a/src/EnergyPlus/ChillerGasAbsorption.cc b/src/EnergyPlus/ChillerGasAbsorption.cc
index d684d02fab5..c53459258f8 100644
--- a/src/EnergyPlus/ChillerGasAbsorption.cc
+++ b/src/EnergyPlus/ChillerGasAbsorption.cc
@@ -1120,8 +1120,8 @@ void GasAbsorberSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("SizeChillerHeaterAbsorptionDirectFired: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Capacity of {:.2R} [W]", NomCapUser));
-                                ShowContinueError(state, EnergyPlus::format("differs from Design Size Nominal Capacity of {:.2R} [W]", tmpNomCap));
+                                ShowContinueError(state, std::format("User-Specified Nominal Capacity of {:.2f} [W]", NomCapUser));
+                                ShowContinueError(state, std::format("differs from Design Size Nominal Capacity of {:.2f} [W]", tmpNomCap));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1193,11 +1193,11 @@ void GasAbsorberSpecs::size(EnergyPlusData &state)
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(
                                     state, std::format("SizeChillerAbsorptionDirectFired: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(
-                                    state, EnergyPlus::format("User-Specified Design Chilled Water Flow Rate of {:.5R} [m3/s]", EvapVolFlowRateUser));
                                 ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Chilled Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpEvapVolFlowRate));
+                                                  std::format("User-Specified Design Chilled Water Flow Rate of {:.5f} [m3/s]", EvapVolFlowRateUser));
+                                ShowContinueError(
+                                    state,
+                                    std::format("differs from Design Size Design Chilled Water Flow Rate of {:.5f} [m3/s]", tmpEvapVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1276,11 +1276,11 @@ void GasAbsorberSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("SizeChillerHeaterAbsorptionDirectFired: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(
-                                    state, EnergyPlus::format("User-Specified Design Hot Water Flow Rate of {:.5R} [m3/s]", HeatRecVolFlowRateUser));
                                 ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Hot Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpHeatRecVolFlowRate));
+                                                  std::format("User-Specified Design Hot Water Flow Rate of {:.5f} [m3/s]", HeatRecVolFlowRateUser));
+                                ShowContinueError(
+                                    state,
+                                    std::format("differs from Design Size Design Hot Water Flow Rate of {:.5f} [m3/s]", tmpHeatRecVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1362,12 +1362,11 @@ void GasAbsorberSpecs::size(EnergyPlusData &state)
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(
                                     state, std::format("SizeChillerAbsorptionDirectFired: Potential issue with equipment sizing for {}", this->Name));
+                                ShowContinueError(
+                                    state, std::format("User-Specified Design Condenser Water Flow Rate of {:.5f} [m3/s]", CondVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("User-Specified Design Condenser Water Flow Rate of {:.5R} [m3/s]", CondVolFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Condenser Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpCondVolFlowRate));
+                                    std::format("differs from Design Size Design Condenser Water Flow Rate of {:.5f} [m3/s]", tmpCondVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
diff --git a/src/EnergyPlus/ChillerIndirectAbsorption.cc b/src/EnergyPlus/ChillerIndirectAbsorption.cc
index ef3efa888bb..e3b6816f1ab 100644
--- a/src/EnergyPlus/ChillerIndirectAbsorption.cc
+++ b/src/EnergyPlus/ChillerIndirectAbsorption.cc
@@ -274,8 +274,8 @@ void GetIndirectAbsorberInput(EnergyPlusData &state)
             thisChiller.NomPumpPowerWasAutoSized = true;
         }
         if (state.dataIPShortCut->rNumericArgs(1) == 0.0) {
-            ShowSevereError(
-                state, EnergyPlus::format("Invalid {}={:.2R}", state.dataIPShortCut->cNumericFieldNames(1), state.dataIPShortCut->rNumericArgs(1)));
+            ShowSevereError(state,
+                            std::format("Invalid {}={:.2f}", state.dataIPShortCut->cNumericFieldNames(1), state.dataIPShortCut->rNumericArgs(1)));
             ShowContinueError(
                 state, EnergyPlus::format("Entered in {}={}", state.dataIPShortCut->cCurrentModuleObject, state.dataIPShortCut->cAlphaArgs(1)));
             ErrorsFound = true;
@@ -1092,8 +1092,8 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     EnergyPlus::format("SizeChillerAbsorptionIndirect: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Capacity of {:.2R} [W]", NomCapUser));
-                                ShowContinueError(state, EnergyPlus::format("differs from Design Size Nominal Capacity of {:.2R} [W]", tmpNomCap));
+                                ShowContinueError(state, std::format("User-Specified Nominal Capacity of {:.2f} [W]", NomCapUser));
+                                ShowContinueError(state, std::format("differs from Design Size Nominal Capacity of {:.2f} [W]", tmpNomCap));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1149,9 +1149,8 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                         if ((std::abs(tmpNomPumpPower - NomPumpPowerUser) / NomPumpPowerUser) > state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(
                                 state, EnergyPlus::format("SizeChillerAbsorptionIndirect: Potential issue with equipment sizing for {}", this->Name));
-                            ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Pumping Power of {:.2R} [W]", NomPumpPowerUser));
-                            ShowContinueError(state,
-                                              EnergyPlus::format("differs from Design Size Nominal Pumping Power of {:.2R} [W]", tmpNomPumpPower));
+                            ShowContinueError(state, std::format("User-Specified Nominal Pumping Power of {:.2f} [W]", NomPumpPowerUser));
+                            ShowContinueError(state, std::format("differs from Design Size Nominal Pumping Power of {:.2f} [W]", tmpNomPumpPower));
                             ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                             ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                         }
@@ -1203,11 +1202,11 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state,
                                             std::format("SizeChillerElectricIndirect: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(
-                                    state, EnergyPlus::format("User-Specified Design Chilled Water Flow Rate of {:.5R} [m3/s]", EvapVolFlowRateUser));
                                 ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Chilled Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpEvapVolFlowRate));
+                                                  std::format("User-Specified Design Chilled Water Flow Rate of {:.5f} [m3/s]", EvapVolFlowRateUser));
+                                ShowContinueError(
+                                    state,
+                                    std::format("differs from Design Size Design Chilled Water Flow Rate of {:.5f} [m3/s]", tmpEvapVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1290,12 +1289,11 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state,
                                             std::format("SizeChillerAbsorptionIndirect: Potential issue with equipment sizing for {}", this->Name));
+                                ShowContinueError(
+                                    state, std::format("User-Specified Design Condenser Water Flow Rate of {:.5f} [m3/s]", CondVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("User-Specified Design Condenser Water Flow Rate of {:.5R} [m3/s]", CondVolFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Condenser Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpCondVolFlowRate));
+                                    std::format("differs from Design Size Design Condenser Water Flow Rate of {:.5f} [m3/s]", tmpCondVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1382,12 +1380,11 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                                             state,
                                             std::format("SizeChillerAbsorptionIndirect: Potential issue with equipment sizing for {}", this->Name));
                                         ShowContinueError(state,
-                                                          EnergyPlus::format("User-Specified Design Generator Fluid Flow Rate of {:.5R} [m3/s]",
-                                                                             GeneratorVolFlowRateUser));
-                                        ShowContinueError(
-                                            state,
-                                            EnergyPlus::format("differs from Design Size Design Generator Fluid Flow Rate of {:.5R} [m3/s]",
-                                                               tmpGeneratorVolFlowRate));
+                                                          std::format("User-Specified Design Generator Fluid Flow Rate of {:.5f} [m3/s]",
+                                                                      GeneratorVolFlowRateUser));
+                                        ShowContinueError(state,
+                                                          std::format("differs from Design Size Design Generator Fluid Flow Rate of {:.5f} [m3/s]",
+                                                                      tmpGeneratorVolFlowRate));
                                         ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                         ShowContinueError(state,
                                                           "Verify that the value entered is intended and is consistent with other components.");
@@ -1457,12 +1454,11 @@ void IndirectAbsorberSpecs::sizeChiller(EnergyPlusData &state)
                                             state,
                                             std::format("SizeChillerAbsorptionIndirect: Potential issue with equipment sizing for {}", this->Name));
                                         ShowContinueError(state,
-                                                          EnergyPlus::format("User-Specified Design Generator Fluid Flow Rate of {:.5R} [m3/s]",
-                                                                             GeneratorVolFlowRateUser));
-                                        ShowContinueError(
-                                            state,
-                                            EnergyPlus::format("differs from Design Size Design Generator Fluid Flow Rate of {:.5R} [m3/s]",
-                                                               tmpGeneratorVolFlowRate));
+                                                          std::format("User-Specified Design Generator Fluid Flow Rate of {:.5f} [m3/s]",
+                                                                      GeneratorVolFlowRateUser));
+                                        ShowContinueError(state,
+                                                          std::format("differs from Design Size Design Generator Fluid Flow Rate of {:.5f} [m3/s]",
+                                                                      tmpGeneratorVolFlowRate));
                                         ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                         ShowContinueError(state,
                                                           "Verify that the value entered is intended and is consistent with other components.");
@@ -1639,11 +1635,11 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 MyLoad, bool
             if (this->MinCondInletTempCtr < 1) {
                 ++this->MinCondInletTempCtr;
                 ShowWarningError(state, std::format("Chiller:Absorption:Indirect \"{}\"", this->Name));
-                ShowContinueError(
-                    state, EnergyPlus::format("...Entering condenser water temperature below specified minimum ({:.3R} C).", this->MinCondInletTemp));
                 ShowContinueError(state,
-                                  EnergyPlus::format("...Entering condenser water temperature = {:.3R} C.",
-                                                     state.dataLoopNodes->Node(this->CondInletNodeNum).Temp));
+                                  std::format("...Entering condenser water temperature below specified minimum ({:.3f} C).", this->MinCondInletTemp));
+                ShowContinueError(
+                    state,
+                    std::format("...Entering condenser water temperature = {:.3f} C.", state.dataLoopNodes->Node(this->CondInletNodeNum).Temp));
                 ShowContinueErrorTimeStamp(state, "...simulation continues.");
             } else {
                 ShowRecurringWarningErrorAtEnd(state,
@@ -1662,12 +1658,12 @@ void IndirectAbsorberSpecs::calculate(EnergyPlusData &state, Real64 MyLoad, bool
                 if (this->MinGenInletTempCtr < 1) {
                     ++this->MinGenInletTempCtr;
                     ShowWarningError(state, std::format("Chiller:Absorption:Indirect \"{}\"", this->Name));
+                    ShowContinueError(
+                        state,
+                        std::format("...Entering generator fluid temperature below specified minimum ({:.3f} C).", this->MinGeneratorInletTemp));
                     ShowContinueError(state,
-                                      EnergyPlus::format("...Entering generator fluid temperature below specified minimum ({:.3R} C).",
-                                                         this->MinGeneratorInletTemp));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("...Entering generator fluid temperature = {:.3R} C.",
-                                                         state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp));
+                                      std::format("...Entering generator fluid temperature = {:.3f} C.",
+                                                  state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp));
                     ShowContinueErrorTimeStamp(state, "...simulation continues.");
                 } else {
                     ShowRecurringWarningErrorAtEnd(state,
diff --git a/src/EnergyPlus/ChillerReformulatedEIR.cc b/src/EnergyPlus/ChillerReformulatedEIR.cc
index e67a381343e..29d7bd2e258 100644
--- a/src/EnergyPlus/ChillerReformulatedEIR.cc
+++ b/src/EnergyPlus/ChillerReformulatedEIR.cc
@@ -406,14 +406,14 @@ void GetElecReformEIRChillerInput(EnergyPlusData &state)
         }
         if (s_ipsc->rNumericArgs(1) == 0.0) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("Invalid {}={:.2R}", s_ipsc->cNumericFieldNames(1), s_ipsc->rNumericArgs(1)));
+            ShowContinueError(state, std::format("Invalid {}={:.2f}", s_ipsc->cNumericFieldNames(1), s_ipsc->rNumericArgs(1)));
             ErrorsFound = true;
         }
 
         thisChiller.RefCOP = s_ipsc->rNumericArgs(2);
         if (s_ipsc->rNumericArgs(2) == 0.0) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("Invalid {}={:.2R}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
+            ShowContinueError(state, std::format("Invalid {}={:.2f}", s_ipsc->cNumericFieldNames(2), s_ipsc->rNumericArgs(2)));
             ErrorsFound = true;
         }
 
@@ -422,11 +422,11 @@ void GetElecReformEIRChillerInput(EnergyPlusData &state)
         if (thisChiller.TempRefEvapOut >= thisChiller.TempRefCondOut) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
             ShowContinueError(state,
-                              EnergyPlus::format("{} [{:.2R}] >= {} [{:.2R}]",
-                                                 s_ipsc->cNumericFieldNames(3),
-                                                 s_ipsc->rNumericArgs(3),
-                                                 s_ipsc->cNumericFieldNames(4),
-                                                 s_ipsc->rNumericArgs(4)));
+                              std::format("{} [{:.2f}] >= {} [{:.2f}]",
+                                          s_ipsc->cNumericFieldNames(3),
+                                          s_ipsc->rNumericArgs(3),
+                                          s_ipsc->cNumericFieldNames(4),
+                                          s_ipsc->rNumericArgs(4)));
             ShowContinueError(state, "Reference Leaving Chilled Water Temperature must be less than Reference Leaving Condenser Water Temperature ");
             ErrorsFound = true;
         }
@@ -451,18 +451,18 @@ void GetElecReformEIRChillerInput(EnergyPlusData &state)
         if (thisChiller.MinPartLoadRat > thisChiller.MaxPartLoadRat) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
             ShowContinueError(state,
-                              EnergyPlus::format("{} [{:.3R}] > {} [{:.3R}]",
-                                                 s_ipsc->cNumericFieldNames(7),
-                                                 s_ipsc->rNumericArgs(7),
-                                                 s_ipsc->cNumericFieldNames(8),
-                                                 s_ipsc->rNumericArgs(8)));
+                              std::format("{} [{:.3f}] > {} [{:.3f}]",
+                                          s_ipsc->cNumericFieldNames(7),
+                                          s_ipsc->rNumericArgs(7),
+                                          s_ipsc->cNumericFieldNames(8),
+                                          s_ipsc->rNumericArgs(8)));
             ShowContinueError(state, "Minimum part load ratio must be less than or equal to the maximum part load ratio ");
             ErrorsFound = true;
         }
 
         if (thisChiller.MinUnloadRat < thisChiller.MinPartLoadRat || thisChiller.MinUnloadRat > thisChiller.MaxPartLoadRat) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("{} = {:.3R}", s_ipsc->cNumericFieldNames(10), s_ipsc->rNumericArgs(10)));
+            ShowContinueError(state, std::format("{} = {:.3f}", s_ipsc->cNumericFieldNames(10), s_ipsc->rNumericArgs(10)));
             ShowContinueError(
                 state, std::format("{} must be greater than or equal to the {}", s_ipsc->cNumericFieldNames(10), s_ipsc->cNumericFieldNames(7)));
             ShowContinueError(state,
@@ -472,7 +472,7 @@ void GetElecReformEIRChillerInput(EnergyPlusData &state)
 
         if (thisChiller.OptPartLoadRat < thisChiller.MinPartLoadRat || thisChiller.OptPartLoadRat > thisChiller.MaxPartLoadRat) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("{} = {:.3R}", s_ipsc->cNumericFieldNames(9), s_ipsc->rNumericArgs(9)));
+            ShowContinueError(state, std::format("{} = {:.3f}", s_ipsc->cNumericFieldNames(9), s_ipsc->rNumericArgs(9)));
             ShowContinueError(
                 state, std::format("{} must be greater than or equal to the {}", s_ipsc->cNumericFieldNames(9), s_ipsc->cNumericFieldNames(7)));
             ShowContinueError(state,
@@ -484,7 +484,7 @@ void GetElecReformEIRChillerInput(EnergyPlusData &state)
 
         if (thisChiller.CompPowerToCondenserFrac < 0.0 || thisChiller.CompPowerToCondenserFrac > 1.0) {
             ShowSevereError(state, std::format("{}{}=\"{}\"", RoutineName, s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state, EnergyPlus::format("{} = {:.3R}", s_ipsc->cNumericFieldNames(11), s_ipsc->rNumericArgs(11)));
+            ShowContinueError(state, std::format("{} = {:.3f}", s_ipsc->cNumericFieldNames(11), s_ipsc->rNumericArgs(11)));
             ShowContinueError(state, std::format("{} must be greater than or equal to zero", s_ipsc->cNumericFieldNames(11)));
             ShowContinueError(state, std::format("{} must be less than or equal to one", s_ipsc->cNumericFieldNames(11)));
             ErrorsFound = true;
@@ -1165,12 +1165,11 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("SizeChillerElectricReformulatedEIR: Potential issue with equipment sizing for {}", this->Name));
+                                ShowContinueError(
+                                    state, std::format("User-Specified Reference Chilled Water Flow Rate of {:.5f} [m3/s]", EvapVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("User-Specified Reference Chilled Water Flow Rate of {:.5R} [m3/s]", EvapVolFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Reference Chilled Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpEvapVolFlowRate));
+                                    std::format("differs from Design Size Reference Chilled Water Flow Rate of {:.5f} [m3/s]", tmpEvapVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1242,8 +1241,8 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("Size:ChillerElectricReformulatedEIR: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state, EnergyPlus::format("User-Specified Reference Capacity of {:.2R} [W]", RefCapUser));
-                                ShowContinueError(state, EnergyPlus::format("differs from Design Size Reference Capacity of {:.2R} [W]", tmpNomCap));
+                                ShowContinueError(state, std::format("User-Specified Reference Capacity of {:.2f} [W]", RefCapUser));
+                                ShowContinueError(state, std::format("differs from Design Size Reference Capacity of {:.2f} [W]", tmpNomCap));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1312,12 +1311,11 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state)
                                 ShowMessage(
                                     state,
                                     std::format("Size:ChillerElectricReformulatedEIR: Potential issue with equipment sizing for {}", this->Name));
+                                ShowContinueError(
+                                    state, std::format("User-Specified Reference Condenser Water Flow Rate of {:.5f} [m3/s]", CondVolFlowRateUser));
                                 ShowContinueError(
                                     state,
-                                    EnergyPlus::format("User-Specified Reference Condenser Water Flow Rate of {:.5R} [m3/s]", CondVolFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Reference Condenser Water Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpCondVolFlowRate));
+                                    std::format("differs from Design Size Reference Condenser Water Flow Rate of {:.5f} [m3/s]", tmpCondVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -1406,11 +1404,11 @@ void ReformulatedEIRChillerSpecs::size(EnergyPlusData &state)
                                     state,
                                     std::format("Size:ChillerElectricReformulatedEIR: Potential issue with equipment sizing for {}", this->Name));
                                 ShowContinueError(state,
-                                                  EnergyPlus::format("User-Specified Design Heat Recovery Fluid Flow Rate of {:.5R} [m3/s]",
-                                                                     DesignHeatRecVolFlowRateUser));
+                                                  std::format("User-Specified Design Heat Recovery Fluid Flow Rate of {:.5f} [m3/s]",
+                                                              DesignHeatRecVolFlowRateUser));
                                 ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Size Design Heat Recovery Fluid Flow Rate of {:.5R} [m3/s]",
-                                                                     tmpHeatRecVolFlowRate));
+                                                  std::format("differs from Design Size Design Heat Recovery Fluid Flow Rate of {:.5f} [m3/s]",
+                                                              tmpHeatRecVolFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -2760,13 +2758,12 @@ void ReformulatedEIRChillerSpecs::checkMinMaxCurveBoundaries(EnergyPlusData &sta
         if (this->ChillerCapFTError < 1 && this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerCapFTError;
             ShowWarningError(state, std::format("CHILLER:ELECTRIC:REFORMULATEDEIR \"{}\":", this->Name));
-            ShowContinueError(
-                state, EnergyPlus::format(" Chiller Capacity as a Function of Temperature curve output is negative ({:.3R}).", this->ChillerCapFT));
-            ShowContinueError(
-                state,
-                EnergyPlus::format(" Negative value occurs using an Evaporator Leaving Temp of {:.1R} and a Condenser Leaving Temp of {:.1R}.",
-                                   EvapOutletTempSetPoint,
-                                   this->CondOutletTemp));
+            ShowContinueError(state,
+                              std::format(" Chiller Capacity as a Function of Temperature curve output is negative ({:.3f}).", this->ChillerCapFT));
+            ShowContinueError(state,
+                              std::format(" Negative value occurs using an Evaporator Leaving Temp of {:.1f} and a Condenser Leaving Temp of {:.1f}.",
+                                          EvapOutletTempSetPoint,
+                                          this->CondOutletTemp));
             ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation.");
         } else if (this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerCapFTError;
@@ -2786,13 +2783,11 @@ void ReformulatedEIRChillerSpecs::checkMinMaxCurveBoundaries(EnergyPlusData &sta
             ++this->ChillerEIRFTError;
             ShowWarningError(state, std::format("CHILLER:ELECTRIC:REFORMULATEDEIR \"{}\":", this->Name));
             ShowContinueError(
-                state,
-                EnergyPlus::format(" Reformulated Chiller EIR as a Function of Temperature curve output is negative ({:.3R}).", this->ChillerEIRFT));
-            ShowContinueError(
-                state,
-                EnergyPlus::format(" Negative value occurs using an Evaporator Leaving Temp of {:.1R} and a Condenser Leaving Temp of {:.1R}.",
-                                   this->EvapOutletTemp,
-                                   this->CondOutletTemp));
+                state, std::format(" Reformulated Chiller EIR as a Function of Temperature curve output is negative ({:.3f}).", this->ChillerEIRFT));
+            ShowContinueError(state,
+                              std::format(" Negative value occurs using an Evaporator Leaving Temp of {:.1f} and a Condenser Leaving Temp of {:.1f}.",
+                                          this->EvapOutletTemp,
+                                          this->CondOutletTemp));
             ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation.");
         } else if (this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerEIRFTError;
@@ -2835,14 +2830,13 @@ void ReformulatedEIRChillerSpecs::checkMinMaxCurveBoundaries(EnergyPlusData &sta
         if (this->ChillerEIRFPLRError < 1 && this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerEIRFPLRError;
             ShowWarningError(state, std::format("CHILLER:ELECTRIC:REFORMULATEDEIR \"{}\":", this->Name));
-            ShowContinueError(
-                state,
-                EnergyPlus::format(" Chiller EIR as a function of PLR and condenser water temperature curve output is negative ({:.3R}).",
-                                   this->ChillerEIRFPLR));
             ShowContinueError(state,
-                              EnergyPlus::format(" Negative value occurs using a part-load ratio of {:.3R} and a Condenser Leaving Temp of {:.1R} C.",
-                                                 this->ChillerPartLoadRatio,
-                                                 this->CondOutletTemp));
+                              std::format(" Chiller EIR as a function of PLR and condenser water temperature curve output is negative ({:.3f}).",
+                                          this->ChillerEIRFPLR));
+            ShowContinueError(state,
+                              std::format(" Negative value occurs using a part-load ratio of {:.3f} and a Condenser Leaving Temp of {:.1f} C.",
+                                          this->ChillerPartLoadRatio,
+                                          this->CondOutletTemp));
             ShowContinueErrorTimeStamp(state, " Resetting curve output to zero and continuing simulation.");
         } else if (this->CWPlantLoc.side->FlowLock != DataPlant::FlowLock::Unlocked && !state.dataGlobal->WarmupFlag) {
             ++this->ChillerEIRFPLRError;
diff --git a/src/EnergyPlus/Coils/CoilCoolingDXCurveFitSpeed.cc b/src/EnergyPlus/Coils/CoilCoolingDXCurveFitSpeed.cc
index 3214b8b0a59..e71dcba42c5 100644
--- a/src/EnergyPlus/Coils/CoilCoolingDXCurveFitSpeed.cc
+++ b/src/EnergyPlus/Coils/CoilCoolingDXCurveFitSpeed.cc
@@ -639,20 +639,19 @@ Real64 CoilCoolingDXCurveFitSpeed::CalcBypassFactor(EnergyPlus::EnergyPlusData &
         ShowContinueError(state, "capacity, increase the rated air volume flow rate, or reduce the rated sensible heat ratio for this coil.");
         ShowContinueError(state, "If autosizing, it is recommended that all three of these values be autosized.");
         ShowContinueError(state, "...Inputs used for calculating cooling coil bypass factor.");
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Temperature     = {:.2R} C", tdb));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Temperature    = {:.2R} C", outtdb));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Humidity Ratio  = {:.6R} kgWater/kgDryAir", w));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Humidity Ratio = {:.6R} kgWater/kgDryAir", outw));
-        ShowContinueError(state, EnergyPlus::format("...Total Cooling Capacity used in calculation = {:.2R} W", q));
-        ShowContinueError(state, EnergyPlus::format("...Air Mass Flow Rate used in calculation     = {:.6R} kg/s", airMassFlowRate));
-        ShowContinueError(state, EnergyPlus::format("...Air Volume Flow Rate used in calculation   = {:.6R} m3/s", this->evap_air_flow_rate));
+        ShowContinueError(state, std::format("...Inlet Air Temperature     = {:.2f} C", tdb));
+        ShowContinueError(state, std::format("...Outlet Air Temperature    = {:.2f} C", outtdb));
+        ShowContinueError(state, std::format("...Inlet Air Humidity Ratio  = {:.3E} kgWater/kgDryAir", w));
+        ShowContinueError(state, std::format("...Outlet Air Humidity Ratio = {:.3E} kgWater/kgDryAir", outw));
+        ShowContinueError(state, std::format("...Total Cooling Capacity used in calculation = {:.2f} W", q));
+        ShowContinueError(state, std::format("...Air Mass Flow Rate used in calculation     = {:.6f} kg/s", airMassFlowRate));
+        ShowContinueError(state, std::format("...Air Volume Flow Rate used in calculation   = {:.6f} m3/s", this->evap_air_flow_rate));
         if (q > 0.0) {
             if (((this->minRatedVolFlowPerRatedTotCap - this->evap_air_flow_rate / q) > SmallDifferenceTest) ||
                 ((this->evap_air_flow_rate / q - this->maxRatedVolFlowPerRatedTotCap) > SmallDifferenceTest)) {
-                ShowContinueError(
-                    state,
-                    EnergyPlus::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7R} m3/s/W",
-                                       this->evap_air_flow_rate / q));
+                ShowContinueError(state,
+                                  std::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7f} m3/s/W",
+                                              this->evap_air_flow_rate / q));
             }
         }
         Real64 outletAirTempSat = Psychrometrics::PsyTsatFnHPb(state, outh, outp, RoutineName);
@@ -663,8 +662,8 @@ Real64 CoilCoolingDXCurveFitSpeed::CalcBypassFactor(EnergyPlus::EnergyPlusData &
             ShowWarningError(state,
                              std::string{RoutineName} + object_name + " \"" + name +
                                  "\", SHR adjusted to achieve valid outlet air properties and the simulation continues.");
-            ShowContinueError(state, EnergyPlus::format("Initial SHR = {:.5R}", this->grossRatedSHR));
-            ShowContinueError(state, EnergyPlus::format("Adjusted SHR = {:.5R}", adjustedSHR));
+            ShowContinueError(state, std::format("Initial SHR = {:.5f}", this->grossRatedSHR));
+            ShowContinueError(state, std::format("Adjusted SHR = {:.5f}", adjustedSHR));
         }
     }
 
@@ -680,21 +679,20 @@ Real64 CoilCoolingDXCurveFitSpeed::CalcBypassFactor(EnergyPlus::EnergyPlusData &
     if (slopeAtConds <= 0.0) {
         ShowSevereError(state, this->object_name + " \"" + this->name + "\"");
         ShowContinueError(state, "...Invalid slope or outlet air condition when calculating cooling coil bypass factor.");
-        ShowContinueError(state, EnergyPlus::format("...Slope = {:.8R}", slopeAtConds));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Temperature     = {:.2R} C", tdb));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Temperature    = {:.2R} C", outtdb));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Humidity Ratio  = {:.6R} kgWater/kgDryAir", w));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Humidity Ratio = {:.6R} kgWater/kgDryAir", outw));
-        ShowContinueError(state, EnergyPlus::format("...Total Cooling Capacity used in calculation = {:.2R} W", q));
-        ShowContinueError(state, EnergyPlus::format("...Air Mass Flow Rate used in calculation     = {:.6R} kg/s", airMassFlowRate));
-        ShowContinueError(state, EnergyPlus::format("...Air Volume Flow Rate used in calculation   = {:.6R} m3/s", this->evap_air_flow_rate));
+        ShowContinueError(state, std::format("...Slope = {:.8f}", slopeAtConds));
+        ShowContinueError(state, std::format("...Inlet Air Temperature     = {:.2f} C", tdb));
+        ShowContinueError(state, std::format("...Outlet Air Temperature    = {:.2f} C", outtdb));
+        ShowContinueError(state, std::format("...Inlet Air Humidity Ratio  = {:.3E} kgWater/kgDryAir", w));
+        ShowContinueError(state, std::format("...Outlet Air Humidity Ratio = {:.3E} kgWater/kgDryAir", outw));
+        ShowContinueError(state, std::format("...Total Cooling Capacity used in calculation = {:.2f} W", q));
+        ShowContinueError(state, std::format("...Air Mass Flow Rate used in calculation     = {:.6f} kg/s", airMassFlowRate));
+        ShowContinueError(state, std::format("...Air Volume Flow Rate used in calculation   = {:.6f} m3/s", this->evap_air_flow_rate));
         if (q > 0.0) {
             if (((this->minRatedVolFlowPerRatedTotCap - this->evap_air_flow_rate / q) > SmallDifferenceTest) ||
                 ((this->evap_air_flow_rate / q - this->maxRatedVolFlowPerRatedTotCap) > SmallDifferenceTest)) {
-                ShowContinueError(
-                    state,
-                    EnergyPlus::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7R} m3/s/W",
-                                       this->evap_air_flow_rate / q));
+                ShowContinueError(state,
+                                  std::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7f} m3/s/W",
+                                              this->evap_air_flow_rate / q));
             }
         }
         ShowFatalError(state, "Errors found in calculating coil bypass factors");
@@ -739,8 +737,7 @@ Real64 CoilCoolingDXCurveFitSpeed::CalcBypassFactor(EnergyPlus::EnergyPlusData &
         ShowSevereError(state,
                         std::string{RoutineName} + object_name + " \"" + name +
                             "\" -- coil bypass factor calculation did not converge after max iterations.");
-        ShowContinueError(state,
-                          EnergyPlus::format("The RatedSHR of [{:.3R}], entered by the user or autosized (see *.eio file),", this->grossRatedSHR));
+        ShowContinueError(state, std::format("The RatedSHR of [{:.3f}], entered by the user or autosized (see *.eio file),", this->grossRatedSHR));
         ShowContinueError(state, "may be causing this. The line defined by the coil rated inlet air conditions");
         ShowContinueError(state, "(26.7C drybulb and 19.4C wetbulb) and the RatedSHR (i.e., slope of the line) must intersect");
         ShowContinueError(state, "the saturation curve of the psychrometric chart. If the RatedSHR is too low, then this");
diff --git a/src/EnergyPlus/CondenserLoopTowers.cc b/src/EnergyPlus/CondenserLoopTowers.cc
index 62db2c0af17..2414d1de0ce 100644
--- a/src/EnergyPlus/CondenserLoopTowers.cc
+++ b/src/EnergyPlus/CondenserLoopTowers.cc
@@ -3494,9 +3494,8 @@ namespace CondenserLoopTowers {
                             if (state.dataGlobal->DisplayExtraWarnings) {
                                 if ((std::abs(tmpNomTowerCap - NomCapUser) / NomCapUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state, std::format("SizeVSMerkelTower: Potential issue with equipment sizing for {}", this->Name));
-                                    ShowContinueError(state, EnergyPlus::format("User-Specified Nominal Capacity of {:.2R} [W]", NomCapUser));
-                                    ShowContinueError(state,
-                                                      EnergyPlus::format("differs from Design Size Nominal Capacity of {:.2R} [W]", tmpNomTowerCap));
+                                    ShowContinueError(state, std::format("User-Specified Nominal Capacity of {:.2f} [W]", NomCapUser));
+                                    ShowContinueError(state, std::format("differs from Design Size Nominal Capacity of {:.2f} [W]", tmpNomTowerCap));
                                     ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                     ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                                 }
@@ -3540,11 +3539,11 @@ namespace CondenserLoopTowers {
                             if (state.dataGlobal->DisplayExtraWarnings) {
                                 if ((std::abs(tmpTowerFreeConvNomCap - NomCapUser) / NomCapUser) > state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state, std::format("SizeVSMerkelTower: Potential issue with equipment sizing for {}", this->Name));
-                                    ShowContinueError(
-                                        state, EnergyPlus::format("User-Specified Free Convection Nominal Capacity of {:.2R} [W]", NomCapUser));
                                     ShowContinueError(state,
-                                                      EnergyPlus::format("differs from Design Size Free Convection Nominal Capacity of {:.2R} [W]",
-                                                                         tmpTowerFreeConvNomCap));
+                                                      std::format("User-Specified Free Convection Nominal Capacity of {:.2f} [W]", NomCapUser));
+                                    ShowContinueError(state,
+                                                      std::format("differs from Design Size Free Convection Nominal Capacity of {:.2f} [W]",
+                                                                  tmpTowerFreeConvNomCap));
                                     ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                     ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                                 }
@@ -3592,10 +3591,10 @@ namespace CondenserLoopTowers {
                                 if ((std::abs(tmpDesignWaterFlowRate - NomDesWaterFlowUser) / NomDesWaterFlowUser) >
                                     state.dataSize->AutoVsHardSizingThreshold) {
                                     ShowMessage(state, std::format("SizeVSMerkelTower: Potential issue with equipment sizing for {}", this->Name));
-                                    ShowContinueError(
-                                        state, EnergyPlus::format("User-Specified Design Water Flow Rate of {:.2R} [m3/s]", NomDesWaterFlowUser));
-                                    ShowContinueError(
-                                        state, EnergyPlus::format("differs from Design Water Flow Rate of {:.2R} [m3/s]", tmpDesignWaterFlowRate));
+                                    ShowContinueError(state,
+                                                      std::format("User-Specified Design Water Flow Rate of {:.2f} [m3/s]", NomDesWaterFlowUser));
+                                    ShowContinueError(state,
+                                                      std::format("differs from Design Water Flow Rate of {:.2f} [m3/s]", tmpDesignWaterFlowRate));
                                     ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                     ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                                 }
@@ -3645,10 +3644,8 @@ namespace CondenserLoopTowers {
                             if ((std::abs(tmpDesignAirFlowRate - DesignAirFlowRateUser) / DesignAirFlowRateUser) >
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeVSMerkelTower: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("User-Specified Design Air Flow Rate of {:.2R} [m3/s]", DesignAirFlowRateUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Air Flow Rate of {:.2R} [m3/s]", tmpDesignAirFlowRate));
+                                ShowContinueError(state, std::format("User-Specified Design Air Flow Rate of {:.2f} [m3/s]", DesignAirFlowRateUser));
+                                ShowContinueError(state, std::format("differs from Design Air Flow Rate of {:.2f} [m3/s]", tmpDesignAirFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -3691,12 +3688,12 @@ namespace CondenserLoopTowers {
                             if ((std::abs(tmpFreeConvAirFlowRate - FreeConvAirFlowUser) / FreeConvAirFlowUser) >
                                 state.dataSize->AutoVsHardSizingThreshold) {
                                 ShowMessage(state, std::format("SizeVSMerkelTower: Potential issue with equipment sizing for {}", this->Name));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("User-Specified Design Free Convection Regime Air Flow Rate of {:.2R} [m3/s]",
-                                                                     FreeConvAirFlowUser));
-                                ShowContinueError(state,
-                                                  EnergyPlus::format("differs from Design Free Convection Regime Air Flow Rate of {:.2R} [m3/s]",
-                                                                     tmpFreeConvAirFlowRate));
+                                ShowContinueError(
+                                    state,
+                                    std::format("User-Specified Design Free Convection Regime Air Flow Rate of {:.2f} [m3/s]", FreeConvAirFlowUser));
+                                ShowContinueError(
+                                    state,
+                                    std::format("differs from Design Free Convection Regime Air Flow Rate of {:.2f} [m3/s]", tmpFreeConvAirFlowRate));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -4311,8 +4308,8 @@ namespace CondenserLoopTowers {
                         if ((std::abs(tmpHighSpeedFanPower - HighSpeedFanPowerUser) / HighSpeedFanPowerUser) >
                             state.dataSize->AutoVsHardSizingThreshold) {
                             ShowMessage(state, std::format("SizeVSMerkelTower: Potential issue with equipment sizing for {}", this->Name));
-                            ShowContinueError(state, EnergyPlus::format("User-Specified Design Fan Power of {:.2R} [W]", HighSpeedFanPowerUser));
-                            ShowContinueError(state, EnergyPlus::format("differs from Design Fan Power of {:.2R} [W]", tmpHighSpeedFanPower));
+                            ShowContinueError(state, std::format("User-Specified Design Fan Power of {:.2f} [W]", HighSpeedFanPowerUser));
+                            ShowContinueError(state, std::format("differs from Design Fan Power of {:.2f} [W]", tmpHighSpeedFanPower));
                             ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                             ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                         }
@@ -5458,9 +5455,9 @@ namespace CondenserLoopTowers {
                                                      cCoolingTower_VariableSpeedMerkel,
                                                      this->Name));
                         ShowContinueError(state,
-                                          EnergyPlus::format("Estimated air flow ratio  = {:.4R}",
-                                                             (std::abs(MyLoad) - MinSpeedFanQdot) / (FullSpeedFanQdot - MinSpeedFanQdot)));
-                        ShowContinueError(state, EnergyPlus::format("Calculated air flow ratio = {:.4R}", this->airFlowRateRatio));
+                                          std::format("Estimated air flow ratio  = {:.4f}",
+                                                      (std::abs(MyLoad) - MinSpeedFanQdot) / (FullSpeedFanQdot - MinSpeedFanQdot)));
+                        ShowContinueError(state, std::format("Calculated air flow ratio = {:.4f}", this->airFlowRateRatio));
                         ShowContinueErrorTimeStamp(state,
                                                    "The calculated air flow ratio will be used and the simulation continues. Occurrence info:");
                     }
@@ -5481,7 +5478,7 @@ namespace CondenserLoopTowers {
                                          std::format("{} - solver failed calculating variable speed fan ratio for unit = {}",
                                                      cCoolingTower_VariableSpeedMerkel,
                                                      this->Name));
-                        ShowContinueError(state, EnergyPlus::format("Estimated air flow ratio  = {:.4R}", this->airFlowRateRatio));
+                        ShowContinueError(state, std::format("Estimated air flow ratio  = {:.4f}", this->airFlowRateRatio));
                         ShowContinueErrorTimeStamp(state, "The estimated air flow ratio will be used and the simulation continues. Occurrence info:");
                     }
                     ShowRecurringWarningErrorAtEnd(
@@ -5894,9 +5891,9 @@ namespace CondenserLoopTowers {
 
         //   check boundaries of independent variables and post warnings to individual buffers to print at end of time step
         if (Twb < this->MinInletAirWBTemp || Twb > this->MaxInletAirWBTemp) {
-            OutputChar = EnergyPlus::format("{:.2R}", Twb);
-            OutputCharLo = EnergyPlus::format("{:.2R}", this->MinInletAirWBTemp);
-            OutputCharHi = EnergyPlus::format("{:.2R}", this->MaxInletAirWBTemp);
+            OutputChar = std::format("{:.2f}", Twb);
+            OutputCharLo = std::format("{:.2f}", this->MinInletAirWBTemp);
+            OutputCharHi = std::format("{:.2f}", this->MaxInletAirWBTemp);
             if (Twb < this->MinInletAirWBTemp) {
                 TwbCapped = this->MinInletAirWBTemp;
             }
@@ -5912,7 +5909,7 @@ namespace CondenserLoopTowers {
                 this->TwbBuffer2 = " ...Valid range = " + OutputCharLo + " to " + OutputCharHi +
                                    ". Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
                                    General::CreateSysTimeIntervalString(state);
-                TrimValue = EnergyPlus::format("{:.6R}", TwbCapped);
+                TrimValue = std::format("{:.6f}", TwbCapped);
                 this->TwbBuffer3 = " ...Inlet air wet-bulb temperature passed to the model = " + TrimValue;
                 this->TwbLast = Twb;
             } else {
@@ -5923,9 +5920,9 @@ namespace CondenserLoopTowers {
         }
 
         if (Tr < this->MinRangeTemp || Tr > this->MaxRangeTemp) {
-            OutputChar = EnergyPlus::format("{:.2R}", Tr);
-            OutputCharLo = EnergyPlus::format("{:.2R}", this->MinRangeTemp);
-            OutputCharHi = EnergyPlus::format("{:.2R}", this->MaxRangeTemp);
+            OutputChar = std::format("{:.2f}", Tr);
+            OutputCharLo = std::format("{:.2f}", this->MinRangeTemp);
+            OutputCharHi = std::format("{:.2f}", this->MaxRangeTemp);
             if (Tr < this->MinRangeTemp) {
                 TrCapped = this->MinRangeTemp;
             }
@@ -5941,7 +5938,7 @@ namespace CondenserLoopTowers {
                 this->TrBuffer2 = " ...Valid range = " + OutputCharLo + " to " + OutputCharHi +
                                   ". Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
                                   General::CreateSysTimeIntervalString(state);
-                TrimValue = EnergyPlus::format("{:.5R}", Tr);
+                TrimValue = std::format("{:.5f}", Tr);
                 this->TrBuffer3 = " ...Tower range temperature passed to the model = " + TrimValue;
                 this->TrLast = Tr;
             } else {
@@ -5952,9 +5949,9 @@ namespace CondenserLoopTowers {
         }
 
         if (Ta < this->MinApproachTemp || Ta > this->MaxApproachTemp) {
-            OutputChar = EnergyPlus::format("{:.2R}", Ta);
-            OutputCharLo = EnergyPlus::format("{:.2R}", this->MinApproachTemp);
-            OutputCharHi = EnergyPlus::format("{:.2R}", this->MaxApproachTemp);
+            OutputChar = std::format("{:.2f}", Ta);
+            OutputCharLo = std::format("{:.2f}", this->MinApproachTemp);
+            OutputCharHi = std::format("{:.2f}", this->MaxApproachTemp);
             if (Ta < this->MinApproachTemp) {
                 TaCapped = this->MinApproachTemp;
             }
@@ -5970,7 +5967,7 @@ namespace CondenserLoopTowers {
                 this->TaBuffer2 = " ...Valid range = " + OutputCharLo + " to " + OutputCharHi +
                                   ". Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
                                   General::CreateSysTimeIntervalString(state);
-                TrimValue = EnergyPlus::format("{:.5R}", Ta);
+                TrimValue = std::format("{:.5f}", Ta);
                 this->TaBuffer3 = " ...Tower approach temperature passed to the model = " + TrimValue;
                 this->TaLast = Ta;
             } else {
@@ -5986,9 +5983,9 @@ namespace CondenserLoopTowers {
             this->PrintWFRRMessage = false;
         } else {
             if (WaterFlowRateRatio < this->MinWaterFlowRatio || WaterFlowRateRatio > this->MaxWaterFlowRatio) {
-                OutputChar = EnergyPlus::format("{:.2R}", WaterFlowRateRatio);
-                OutputCharLo = EnergyPlus::format("{:.2R}", this->MinWaterFlowRatio);
-                OutputCharHi = EnergyPlus::format("{:.2R}", this->MaxWaterFlowRatio);
+                OutputChar = std::format("{:.2f}", WaterFlowRateRatio);
+                OutputCharLo = std::format("{:.2f}", this->MinWaterFlowRatio);
+                OutputCharHi = std::format("{:.2f}", this->MaxWaterFlowRatio);
                 if (WaterFlowRateRatio < this->MinWaterFlowRatio) {
                     WaterFlowRateRatioCapped = this->MinWaterFlowRatio;
                 }
@@ -6004,7 +6001,7 @@ namespace CondenserLoopTowers {
                     this->WFRRBuffer2 = " ...Valid range = " + OutputCharLo + " to " + OutputCharHi +
                                         ". Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
                                         General::CreateSysTimeIntervalString(state);
-                    TrimValue = EnergyPlus::format("{:.5R}", WaterFlowRateRatioCapped);
+                    TrimValue = std::format("{:.5f}", WaterFlowRateRatioCapped);
                     this->WFRRBuffer3 = " ...Water flow rate ratio passed to the model = " + TrimValue;
                     this->WaterFlowRateRatioLast = WaterFlowRateRatio;
                 } else {
diff --git a/src/EnergyPlus/Construction.cc b/src/EnergyPlus/Construction.cc
index 97ea29c232d..80f178ab59e 100644
--- a/src/EnergyPlus/Construction.cc
+++ b/src/EnergyPlus/Construction.cc
@@ -235,19 +235,17 @@ void ConstructionProps::calculateTransferFunction(EnergyPlusData &state, bool &E
                         ShowContinueError(
                             state,
                             EnergyPlus::format("High conductivity Material layers are not well supported for internal source constructions, "
-                                               "material conductivity = {:.3R} [W/m-K]",
+                                               "material conductivity = {:.3f} [W/m-K]",
                                                thisMaterial->Conductivity));
-                        ShowContinueError(state, EnergyPlus::format("Material thermal diffusivity = {:.3R} [m2/s]", Alpha));
+                        ShowContinueError(state, std::format("Material thermal diffusivity = {:.3f} [m2/s]", Alpha));
                         ShowContinueError(
-                            state,
-                            EnergyPlus::format("Material with this thermal diffusivity should have thickness > {:.5R} [m]", ThicknessThreshold));
+                            state, std::format("Material with this thermal diffusivity should have thickness > {:.5f} [m]", ThicknessThreshold));
                         if (thisMaterial->Thickness < DataHeatBalance::ThinMaterialLayerThreshold) {
                             ShowContinueError(
-                                state,
-                                EnergyPlus::format("Material may be too thin to be modeled well, thickness = {:.5R} [m]", thisMaterial->Thickness));
+                                state, std::format("Material may be too thin to be modeled well, thickness = {:.5f} [m]", thisMaterial->Thickness));
                             ShowContinueError(state,
-                                              EnergyPlus::format("Material with this thermal diffusivity should have thickness > {:.5R} [m]",
-                                                                 DataHeatBalance::ThinMaterialLayerThreshold));
+                                              std::format("Material with this thermal diffusivity should have thickness > {:.5f} [m]",
+                                                          DataHeatBalance::ThinMaterialLayerThreshold));
                         }
                         thisMaterial->WarnedForHighDiffusivity = true;
                     }
@@ -280,7 +278,7 @@ void ConstructionProps::calculateTransferFunction(EnergyPlusData &state, bool &E
 
                 ShowSevereError(
                     state, EnergyPlus::format("InitConductionTransferFunctions: Material={}R Value below lowest allowed value", thisMaterial->Name));
-                ShowContinueError(state, EnergyPlus::format("Lowest allowed value=[{:.3R}], Material R Value=[{:.3R}].", RValueLowLimit, lr(Layer)));
+                ShowContinueError(state, std::format("Lowest allowed value=[{:.3f}], Material R Value=[{:.3f}].", RValueLowLimit, lr(Layer)));
                 ErrorsFound = true;
 
             } else { // A valid user defined R-value is available.
diff --git a/src/EnergyPlus/ConvectionCoefficients.cc b/src/EnergyPlus/ConvectionCoefficients.cc
index 9fe1d26804c..9aff645dba2 100644
--- a/src/EnergyPlus/ConvectionCoefficients.cc
+++ b/src/EnergyPlus/ConvectionCoefficients.cc
@@ -1082,15 +1082,15 @@ void GetUserConvCoeffs(EnergyPlusData &state)
                     if (Numbers(NumField) < state.dataHeatBal->LowHConvLimit || Numbers(NumField) > state.dataHeatBal->HighHConvLimit) {
                         ShowSevereError(state, std::format("{}{}=\"{}, out of range value", RoutineName, CurrentModuleObject, Alphas(1)));
                         ShowContinueError(state,
-                                          EnergyPlus::format("{}={}, {}=[{:.5R}].",
-                                                             ipsc->cAlphaFieldNames(Ptr),
-                                                             Alphas(Ptr),
-                                                             ipsc->cNumericFieldNames(NumField),
-                                                             Numbers(NumField)));
+                                          std::format("{}={}, {}=[{:.5f}].",
+                                                      ipsc->cAlphaFieldNames(Ptr),
+                                                      Alphas(Ptr),
+                                                      ipsc->cNumericFieldNames(NumField),
+                                                      Numbers(NumField)));
                         ShowContinueError(state,
-                                          EnergyPlus::format("Out-of-range from low/high limits=[>={:.9R}, <={:.1R}].",
-                                                             state.dataHeatBal->LowHConvLimit,
-                                                             state.dataHeatBal->HighHConvLimit));
+                                          std::format("Out-of-range from low/high limits=[>={:.9f}, <={:.1f}].",
+                                                      state.dataHeatBal->LowHConvLimit,
+                                                      state.dataHeatBal->HighHConvLimit));
                         ShowContinueError(state, "Limits are set (or default) in HeatBalanceAlgorithm object.");
                         ErrorsFound = true;
                     }
@@ -3018,7 +3018,7 @@ void SetupAdaptiveConvStaticMetaData(EnergyPlusData &state)
             }
 
             static constexpr std::string_view Format_901(
-                "Surface Convection Parameters,{},{},{:.2R},{:.2R},{:.2R},{},{:.2R},{:.2R},{:.2R},{:.2R},{},{},{}\n");
+                "Surface Convection Parameters,{},{},{:.2f},{:.2f},{:.2f},{},{:.2f},{:.2f},{:.2f},{:.3G},{},{},{}\n");
 
             // This reporting rubric (using numbers instead of strings, using negative numbers for "built-in" coefficients) is stupid,
             // but we are maintaining compatibility here
@@ -3058,7 +3058,7 @@ void SetupAdaptiveConvStaticMetaData(EnergyPlusData &state)
             static constexpr std::string_view Format_8000 =
                 "! <Building Convection Parameters:{} Facade>, Perimeter, Height, Xmin, Xmax, Ymin, Ymax, Zmin, Zmax \n";
             static constexpr std::string_view Format_8001 =
-                "Building Convection Parameters:{} Facade, {:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R}\n";
+                "Building Convection Parameters:{} Facade, {:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f}\n";
 
             for (int c8 = 0; c8 < (int)DataSurfaces::Compass8::Num; ++c8) {
 
@@ -3082,7 +3082,7 @@ void SetupAdaptiveConvStaticMetaData(EnergyPlusData &state)
             static constexpr std::string_view Format_8800(
                 "! <Building Convection Parameters:Roof>, Area [m2], Perimeter [m], Height [m], Tilt [deg], Azimuth [deg]\n");
             print(state.files.eio, Format_8800); // header for roof
-            static constexpr std::string_view Format_8801("Building Convection Parameters:Roof,{:.2R},{:.2R},{:.2R},{:.2R},{:.2R}\n");
+            static constexpr std::string_view Format_8801("Building Convection Parameters:Roof,{:.2f},{:.2f},{:.2f},{:.2f},{:.2f}\n");
             print(state.files.eio,
                   Format_8801,
                   geoSummaryRoof.Area,
@@ -6214,7 +6214,7 @@ Real64 CalcMitchell(EnergyPlusData &state, Real64 const WindAtZ, Real64 const Le
     }
     if (state.dataConvect->CalcMitchellErrorIDX == 0) {
         ShowSevereMessage(state, "CalcMitchell: Convection model not evaluated (bad length scale)");
-        ShowContinueError(state, EnergyPlus::format("Value for effective length scale = {:.5R}", LengthScale));
+        ShowContinueError(state, std::format("Value for effective length scale = {:.5f}", LengthScale));
         ShowContinueError(state, std::format("Occurs for surface named = {}", state.dataSurface->Surface(SurfNum).Name));
         ShowContinueError(state, "Convection surface heat transfer coefficient set to 9.999 [W/m2-K] and the simulation continues");
     }
@@ -6274,7 +6274,7 @@ Real64 CalcBlockenWindward(EnergyPlusData &state,
     }
     if (state.dataConvect->CalcBlockenWindwardErrorIDX == 0) {
         ShowSevereMessage(state, "CalcBlockenWindward: Convection model wind angle calculation suspect (developer issue)");
-        ShowContinueError(state, EnergyPlus::format("Value for theta angle = {:.5R}", Theta));
+        ShowContinueError(state, std::format("Value for theta angle = {:.5f}", Theta));
         ShowContinueError(state, std::format("Occurs for surface named = {}", state.dataSurface->Surface(SurfNum).Name));
         ShowContinueError(state, "Convection model uses EmmelVertical correlation and the simulation continues");
     }
@@ -6415,7 +6415,7 @@ Real64 CalcClearRoof(EnergyPlusData &state,
     if (state.dataSurface->Surface(SurfNum).ExtBoundCond != DataSurfaces::OtherSideCondModeledExt) {
         if (state.dataConvect->CalcClearRoofErrorIDX == 0) {
             ShowSevereMessage(state, "CalcClearRoof: Convection model not evaluated (bad value for distance to roof edge)");
-            ShowContinueError(state, EnergyPlus::format("Value for distance to roof edge ={:.3R}", x));
+            ShowContinueError(state, std::format("Value for distance to roof edge ={:.3f}", x));
             ShowContinueError(state, std::format("Occurs for surface named = {}", state.dataSurface->Surface(SurfNum).Name));
             ShowContinueError(state, "Convection surface heat transfer coefficient set to 9.999 [W/m2-K] and the simulation continues");
         }
diff --git a/src/EnergyPlus/CurveManager.cc b/src/EnergyPlus/CurveManager.cc
index c23887bb8e8..1382775379e 100644
--- a/src/EnergyPlus/CurveManager.cc
+++ b/src/EnergyPlus/CurveManager.cc
@@ -773,21 +773,21 @@ namespace Curve {
             if (Numbers(7) > Numbers(8)) { // error
                 ShowSevereError(state, EnergyPlus::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(7),
-                                                     Numbers(7),
-                                                     state.dataIPShortCut->cNumericFieldNames(8),
-                                                     Numbers(8)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(7),
+                                              Numbers(7),
+                                              state.dataIPShortCut->cNumericFieldNames(8),
+                                              Numbers(8)));
                 ErrorsFound = true;
             }
             if (Numbers(9) > Numbers(10)) { // error
                 ShowSevereError(state, EnergyPlus::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(9),
-                                                     Numbers(9),
-                                                     state.dataIPShortCut->cNumericFieldNames(10),
-                                                     Numbers(10)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(9),
+                                              Numbers(9),
+                                              state.dataIPShortCut->cNumericFieldNames(10),
+                                              Numbers(10)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -846,11 +846,11 @@ namespace Curve {
             if (Numbers(13) > Numbers(14)) { // error
                 ShowSevereError(state, EnergyPlus::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(13),
-                                                     Numbers(13),
-                                                     state.dataIPShortCut->cNumericFieldNames(14),
-                                                     Numbers(14)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(13),
+                                              Numbers(13),
+                                              state.dataIPShortCut->cNumericFieldNames(14),
+                                              Numbers(14)));
                 ErrorsFound = true;
             }
 
@@ -859,11 +859,11 @@ namespace Curve {
             if (Numbers(15) > Numbers(16)) { // error
                 ShowSevereError(state, EnergyPlus::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(15),
-                                                     Numbers(15),
-                                                     state.dataIPShortCut->cNumericFieldNames(16),
-                                                     Numbers(16)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(15),
+                                              Numbers(15),
+                                              state.dataIPShortCut->cNumericFieldNames(16),
+                                              Numbers(16)));
                 ErrorsFound = true;
             }
 
@@ -872,11 +872,11 @@ namespace Curve {
             if (Numbers(17) > Numbers(18)) { // error
                 ShowSevereError(state, EnergyPlus::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(17),
-                                                     Numbers(17),
-                                                     state.dataIPShortCut->cNumericFieldNames(18),
-                                                     Numbers(18)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(17),
+                                              Numbers(17),
+                                              state.dataIPShortCut->cNumericFieldNames(18),
+                                              Numbers(18)));
                 ErrorsFound = true;
             }
 
@@ -958,11 +958,11 @@ namespace Curve {
             if (Numbers(5) > Numbers(6)) { // error
                 ShowSevereError(state, EnergyPlus::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(5),
-                                                     Numbers(5),
-                                                     state.dataIPShortCut->cNumericFieldNames(6),
-                                                     Numbers(6)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(5),
+                                              Numbers(5),
+                                              state.dataIPShortCut->cNumericFieldNames(6),
+                                              Numbers(6)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -1021,11 +1021,11 @@ namespace Curve {
             if (Numbers(6) > Numbers(7)) { // error
                 ShowSevereError(state, EnergyPlus::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(6),
-                                                     Numbers(6),
-                                                     state.dataIPShortCut->cNumericFieldNames(7),
-                                                     Numbers(7)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(6),
+                                              Numbers(6),
+                                              state.dataIPShortCut->cNumericFieldNames(7),
+                                              Numbers(7)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -1084,11 +1084,11 @@ namespace Curve {
             if (Numbers(4) > Numbers(5)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(4),
-                                                     Numbers(4),
-                                                     state.dataIPShortCut->cNumericFieldNames(5),
-                                                     Numbers(5)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(4),
+                                              Numbers(4),
+                                              state.dataIPShortCut->cNumericFieldNames(5),
+                                              Numbers(5)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -1148,21 +1148,21 @@ namespace Curve {
             if (Numbers(7) > Numbers(8)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(7),
-                                                     Numbers(7),
-                                                     state.dataIPShortCut->cNumericFieldNames(8),
-                                                     Numbers(8)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(7),
+                                              Numbers(7),
+                                              state.dataIPShortCut->cNumericFieldNames(8),
+                                              Numbers(8)));
                 ErrorsFound = true;
             }
             if (Numbers(9) > Numbers(10)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(9),
-                                                     Numbers(9),
-                                                     state.dataIPShortCut->cNumericFieldNames(10),
-                                                     Numbers(10)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(9),
+                                              Numbers(9),
+                                              state.dataIPShortCut->cNumericFieldNames(10),
+                                              Numbers(10)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -1227,21 +1227,21 @@ namespace Curve {
             if (Numbers(7) > Numbers(8)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(7),
-                                                     Numbers(7),
-                                                     state.dataIPShortCut->cNumericFieldNames(8),
-                                                     Numbers(8)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(7),
+                                              Numbers(7),
+                                              state.dataIPShortCut->cNumericFieldNames(8),
+                                              Numbers(8)));
                 ErrorsFound = true;
             }
             if (Numbers(9) > Numbers(10)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(9),
-                                                     Numbers(9),
-                                                     state.dataIPShortCut->cNumericFieldNames(10),
-                                                     Numbers(10)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(9),
+                                              Numbers(9),
+                                              state.dataIPShortCut->cNumericFieldNames(10),
+                                              Numbers(10)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -1304,11 +1304,11 @@ namespace Curve {
             if (Numbers(3) > Numbers(4)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(3),
-                                                     Numbers(3),
-                                                     state.dataIPShortCut->cNumericFieldNames(4),
-                                                     Numbers(4)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(3),
+                                              Numbers(3),
+                                              state.dataIPShortCut->cNumericFieldNames(4),
+                                              Numbers(4)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -1368,21 +1368,21 @@ namespace Curve {
             if (Numbers(11) > Numbers(12)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(11),
-                                                     Numbers(11),
-                                                     state.dataIPShortCut->cNumericFieldNames(12),
-                                                     Numbers(12)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(11),
+                                              Numbers(11),
+                                              state.dataIPShortCut->cNumericFieldNames(12),
+                                              Numbers(12)));
                 ErrorsFound = true;
             }
             if (Numbers(13) > Numbers(14)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(13),
-                                                     Numbers(13),
-                                                     state.dataIPShortCut->cNumericFieldNames(14),
-                                                     Numbers(14)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(13),
+                                              Numbers(13),
+                                              state.dataIPShortCut->cNumericFieldNames(14),
+                                              Numbers(14)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -1473,31 +1473,31 @@ namespace Curve {
             if (Numbers(28) > Numbers(29)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(28),
-                                                     Numbers(28),
-                                                     state.dataIPShortCut->cNumericFieldNames(29),
-                                                     Numbers(29)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(28),
+                                              Numbers(28),
+                                              state.dataIPShortCut->cNumericFieldNames(29),
+                                              Numbers(29)));
                 ErrorsFound = true;
             }
             if (Numbers(30) > Numbers(31)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(30),
-                                                     Numbers(30),
-                                                     state.dataIPShortCut->cNumericFieldNames(31),
-                                                     Numbers(31)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(30),
+                                              Numbers(30),
+                                              state.dataIPShortCut->cNumericFieldNames(31),
+                                              Numbers(31)));
                 ErrorsFound = true;
             }
             if (Numbers(32) > Numbers(33)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(32),
-                                                     Numbers(32),
-                                                     state.dataIPShortCut->cNumericFieldNames(33),
-                                                     Numbers(33)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(32),
+                                              Numbers(32),
+                                              state.dataIPShortCut->cNumericFieldNames(33),
+                                              Numbers(33)));
                 ErrorsFound = true;
             }
             if (NumAlphas >= 2) {
@@ -1577,11 +1577,11 @@ namespace Curve {
                 if (Numbers(MinIndex) > Numbers(MaxIndex)) { // error
                     ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                     ShowContinueError(state,
-                                      EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                         state.dataIPShortCut->cNumericFieldNames(MinIndex),
-                                                         Numbers(MinIndex),
-                                                         state.dataIPShortCut->cNumericFieldNames(MaxIndex),
-                                                         Numbers(MaxIndex)));
+                                      std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                                  state.dataIPShortCut->cNumericFieldNames(MinIndex),
+                                                  Numbers(MinIndex),
+                                                  state.dataIPShortCut->cNumericFieldNames(MaxIndex),
+                                                  Numbers(MaxIndex)));
                     ErrorsFound = true;
                 }
                 int InputTypeIndex = i + 1;
@@ -1655,11 +1655,11 @@ namespace Curve {
                 if (Numbers(MinIndex) > Numbers(MaxIndex)) { // error
                     ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                     ShowContinueError(state,
-                                      EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                         state.dataIPShortCut->cNumericFieldNames(MinIndex),
-                                                         Numbers(MinIndex),
-                                                         state.dataIPShortCut->cNumericFieldNames(MaxIndex),
-                                                         Numbers(MaxIndex)));
+                                      std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                                  state.dataIPShortCut->cNumericFieldNames(MinIndex),
+                                                  Numbers(MinIndex),
+                                                  state.dataIPShortCut->cNumericFieldNames(MaxIndex),
+                                                  Numbers(MaxIndex)));
                     ErrorsFound = true;
                 }
                 int InputTypeIndex = i + 1;
@@ -1712,11 +1712,11 @@ namespace Curve {
             if (Numbers(4) > Numbers(5)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(4),
-                                                     Numbers(4),
-                                                     state.dataIPShortCut->cNumericFieldNames(5),
-                                                     Numbers(5)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(4),
+                                              Numbers(4),
+                                              state.dataIPShortCut->cNumericFieldNames(5),
+                                              Numbers(5)));
                 ErrorsFound = true;
             }
 
@@ -1786,21 +1786,21 @@ namespace Curve {
             if (Numbers(5) > Numbers(6)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(5),
-                                                     Numbers(5),
-                                                     state.dataIPShortCut->cNumericFieldNames(6),
-                                                     Numbers(6)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(5),
+                                              Numbers(5),
+                                              state.dataIPShortCut->cNumericFieldNames(6),
+                                              Numbers(6)));
                 ErrorsFound = true;
             }
             if (Numbers(7) > Numbers(8)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(7),
-                                                     Numbers(7),
-                                                     state.dataIPShortCut->cNumericFieldNames(8),
-                                                     Numbers(8)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(7),
+                                              Numbers(7),
+                                              state.dataIPShortCut->cNumericFieldNames(8),
+                                              Numbers(8)));
                 ErrorsFound = true;
             }
 
@@ -1850,11 +1850,11 @@ namespace Curve {
             if (Numbers(5) > Numbers(6)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(5),
-                                                     Numbers(5),
-                                                     state.dataIPShortCut->cNumericFieldNames(6),
-                                                     Numbers(6)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(5),
+                                              Numbers(5),
+                                              state.dataIPShortCut->cNumericFieldNames(6),
+                                              Numbers(6)));
                 ErrorsFound = true;
             }
 
@@ -1914,11 +1914,11 @@ namespace Curve {
             if (Numbers(6) > Numbers(7)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(6),
-                                                     Numbers(6),
-                                                     state.dataIPShortCut->cNumericFieldNames(7),
-                                                     Numbers(7)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(6),
+                                              Numbers(6),
+                                              state.dataIPShortCut->cNumericFieldNames(7),
+                                              Numbers(7)));
                 ErrorsFound = true;
             }
 
@@ -1978,11 +1978,11 @@ namespace Curve {
             if (Numbers(4) > Numbers(5)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(4),
-                                                     Numbers(4),
-                                                     state.dataIPShortCut->cNumericFieldNames(5),
-                                                     Numbers(5)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(4),
+                                              Numbers(4),
+                                              state.dataIPShortCut->cNumericFieldNames(5),
+                                              Numbers(5)));
                 ErrorsFound = true;
             }
 
@@ -2042,11 +2042,11 @@ namespace Curve {
             if (Numbers(4) > Numbers(5)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(4),
-                                                     Numbers(4),
-                                                     state.dataIPShortCut->cNumericFieldNames(5),
-                                                     Numbers(5)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(4),
+                                              Numbers(4),
+                                              state.dataIPShortCut->cNumericFieldNames(5),
+                                              Numbers(5)));
                 ErrorsFound = true;
             }
 
@@ -2106,11 +2106,11 @@ namespace Curve {
             if (Numbers(4) > Numbers(5)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(4),
-                                                     Numbers(4),
-                                                     state.dataIPShortCut->cNumericFieldNames(5),
-                                                     Numbers(5)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(4),
+                                              Numbers(4),
+                                              state.dataIPShortCut->cNumericFieldNames(5),
+                                              Numbers(5)));
                 ErrorsFound = true;
             }
 
@@ -2161,11 +2161,11 @@ namespace Curve {
             if (Numbers(6) > Numbers(7)) { // error
                 ShowSevereError(state, std::format("GetCurveInput: For {}: ", CurrentModuleObject));
                 ShowContinueError(state,
-                                  EnergyPlus::format("{} [{:.2R}] > {} [{:.2R}]",
-                                                     state.dataIPShortCut->cNumericFieldNames(6),
-                                                     Numbers(6),
-                                                     state.dataIPShortCut->cNumericFieldNames(7),
-                                                     Numbers(7)));
+                                  std::format("{} [{:.2f}] > {} [{:.2f}]",
+                                              state.dataIPShortCut->cNumericFieldNames(6),
+                                              Numbers(6),
+                                              state.dataIPShortCut->cNumericFieldNames(7),
+                                              Numbers(7)));
                 ErrorsFound = true;
             }
 
@@ -2235,11 +2235,11 @@ namespace Curve {
                                               "a higher wind direction value.");
                             ShowContinueError(state, "Wind direction values must be entered in ascending order.");
                             ShowContinueError(state,
-                                              EnergyPlus::format("{} = {:.2R} {} = {:.2R}",
-                                                                 state.dataIPShortCut->cNumericFieldNames(j),
-                                                                 windDirs[j - 2],
-                                                                 state.dataIPShortCut->cNumericFieldNames[j + 1],
-                                                                 windDirs[j - 1]));
+                                              std::format("{} = {:.2f} {} = {:.2f}",
+                                                          state.dataIPShortCut->cNumericFieldNames(j),
+                                                          windDirs[j - 2],
+                                                          state.dataIPShortCut->cNumericFieldNames[j + 1],
+                                                          windDirs[j - 1]));
                             ErrorsFound = true;
                         }
                     }
@@ -2247,7 +2247,7 @@ namespace Curve {
                 // Check that the first table value is zero
                 if (dirMin != 0.0) {
                     ShowSevereError(state, std::format("GetCurveInput: An {} object ", CurrentModuleObject));
-                    ShowContinueError(state, EnergyPlus::format("has a nonzero minimum value of {:.2R}", dirMin));
+                    ShowContinueError(state, std::format("has a nonzero minimum value of {:.2f}", dirMin));
                     ShowContinueError(state, "Wind direction values must begin at zero.");
                     ErrorsFound = true;
                 }
@@ -3607,8 +3607,8 @@ namespace Curve {
         }
         if (!state.dataCurveManager->FrictionFactorErrorHasOccurred) {
             ShowSevereError(state, "Plant Pressure System: Error in moody friction factor calculation");
-            ShowContinueError(
-                state, EnergyPlus::format("Current Conditions: Roughness Ratio={:.7R}; Reynolds Number={:.1R}", RoughnessRatio, ReynoldsNumber));
+            ShowContinueError(state,
+                              std::format("Current Conditions: Roughness Ratio={:.7f}; Reynolds Number={:.1f}", RoughnessRatio, ReynoldsNumber));
             ShowContinueError(state, "These conditions resulted in an unhandled numeric issue.");
             ShowContinueError(state, "Please contact EnergyPlus support/development team to raise an alert about this issue");
             ShowContinueError(state, "This issue will occur only one time.  The friction factor has been reset to 0.04 for calculations");
diff --git a/src/EnergyPlus/DElightManagerF.cc b/src/EnergyPlus/DElightManagerF.cc
index eac978bae65..8dd2e699fb7 100644
--- a/src/EnergyPlus/DElightManagerF.cc
+++ b/src/EnergyPlus/DElightManagerF.cc
@@ -616,24 +616,22 @@ namespace DElightManagerF {
                                     ShowSevereError(
                                         state,
                                         EnergyPlus::format("DElightInputGenerator:Reference point X Value outside Zone Min/Max X, Zone={}", zn.Name));
-                                    ShowContinueError(
-                                        state,
-                                        EnergyPlus::format("...X Reference Point= {:.2R}, Zone Minimum X= {:.2R}, Zone Maximum X= {:.2R}",
-                                                           thisZone.MinimumX,
-                                                           RefPt_WCS_Coord.x,
-                                                           thisZone.MaximumX));
+                                    ShowContinueError(state,
+                                                      std::format("...X Reference Point= {:.2f}, Zone Minimum X= {:.2f}, Zone Maximum X= {:.2f}",
+                                                                  thisZone.MinimumX,
+                                                                  RefPt_WCS_Coord.x,
+                                                                  thisZone.MaximumX));
                                     ErrorsFound = true;
                                 }
                                 if (RefPt_WCS_Coord.y < thisZone.MinimumY || RefPt_WCS_Coord.y > thisZone.MaximumY) {
                                     ShowSevereError(
                                         state,
                                         EnergyPlus::format("DElightInputGenerator:Reference point Y Value outside Zone Min/Max Y, Zone={}", zn.Name));
-                                    ShowContinueError(
-                                        state,
-                                        EnergyPlus::format("...Y Reference Point= {:.2R}, Zone Minimum Y= {:.2R}, Zone Maximum Y= {:.2R}",
-                                                           thisZone.MinimumY,
-                                                           RefPt_WCS_Coord.y,
-                                                           thisZone.MaximumY));
+                                    ShowContinueError(state,
+                                                      std::format("...Y Reference Point= {:.2f}, Zone Minimum Y= {:.2f}, Zone Maximum Y= {:.2f}",
+                                                                  thisZone.MinimumY,
+                                                                  RefPt_WCS_Coord.y,
+                                                                  thisZone.MaximumY));
                                     ErrorsFound = true;
                                 }
                                 if (RefPt_WCS_Coord.z < state.dataHeatBal->Zone(izone).MinimumZ || RefPt_WCS_Coord.z > thisZone.MaximumZ) {
@@ -641,12 +639,11 @@ namespace DElightManagerF {
                                         state,
                                         EnergyPlus::format("DElightInputGenerator:Reference point Z Value outside Zone Min/Max Z, Zone={}",
                                                            thisZone.Name));
-                                    ShowContinueError(
-                                        state,
-                                        EnergyPlus::format("...Z Reference Point= {:.2R}, Zone Minimum Z= {:.2R}, Zone Maximum Z= {:.2R}",
-                                                           thisZone.MinimumZ,
-                                                           RefPt_WCS_Coord.z,
-                                                           thisZone.MaximumZ));
+                                    ShowContinueError(state,
+                                                      std::format("...Z Reference Point= {:.2f}, Zone Minimum Z= {:.2f}, Zone Maximum Z= {:.2f}",
+                                                                  thisZone.MinimumZ,
+                                                                  RefPt_WCS_Coord.z,
+                                                                  thisZone.MaximumZ));
                                     ErrorsFound = true;
                                 }
 
diff --git a/src/EnergyPlus/DXCoils.cc b/src/EnergyPlus/DXCoils.cc
index 985068b658c..969aa39ee56 100644
--- a/src/EnergyPlus/DXCoils.cc
+++ b/src/EnergyPlus/DXCoils.cc
@@ -7862,11 +7862,10 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                             std::format("SizeDxCoil: Potential issue with equipment sizing for {} {}",
                                                         HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                         thisDXCoil.Name));
+                                ShowContinueError(state,
+                                                  std::format("User-Specified Secondary Coil Air Flow Rate of {:.5f} [m3/s]", SecCoilAirFlowUser));
                                 ShowContinueError(
-                                    state, EnergyPlus::format("User-Specified Secondary Coil Air Flow Rate of {:.5R} [m3/s]", SecCoilAirFlowUser));
-                                ShowContinueError(
-                                    state,
-                                    EnergyPlus::format("differs from Design Size Secondary Coil Air Flow Rate of {:.5R} [m3/s]", SecCoilAirFlowDes));
+                                    state, std::format("differs from Design Size Secondary Coil Air Flow Rate of {:.5f} [m3/s]", SecCoilAirFlowDes));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -7974,8 +7973,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                         std::format("SizeDXCoil: {} {}, Evaporative Condenser low speed air flow must be less than or equal to high speed air flow.",
                                     HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                     thisDXCoil.Name));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("Instead, {:.2R} > {:.2R}", thisDXCoil.EvapCondAirFlow2, thisDXCoil.EvapCondAirFlow(Mode)));
+                    ShowContinueError(state, std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.EvapCondAirFlow2, thisDXCoil.EvapCondAirFlow(Mode)));
                     ShowFatalError(state, "Preceding conditions cause termination.");
                 }
 
@@ -7986,10 +7984,9 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                             "SizeDXCoil: {} {}, Evaporative Condenser low speed pump power must be less than or equal to high speed pump power.",
                             HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                             thisDXCoil.Name));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("Instead, {:.2R} > {:.2R}",
-                                                         thisDXCoil.EvapCondPumpElecNomPower2,
-                                                         thisDXCoil.EvapCondPumpElecNomPower(Mode)));
+                    ShowContinueError(
+                        state,
+                        std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.EvapCondPumpElecNomPower2, thisDXCoil.EvapCondPumpElecNomPower(Mode)));
                     ShowFatalError(state, "Preceding conditions cause termination.");
                 }
 
@@ -8000,7 +7997,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                     "Cooling Capacity, High Speed.",
                                     HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                     thisDXCoil.Name));
-                    ShowContinueError(state, EnergyPlus::format("Instead, {:.2R} > {:.2R}", thisDXCoil.RatedTotCap2, thisDXCoil.RatedTotCap(Mode)));
+                    ShowContinueError(state, std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.RatedTotCap2, thisDXCoil.RatedTotCap(Mode)));
                     ShowFatalError(state, "Preceding conditions cause termination.");
                 }
 
@@ -8011,8 +8008,8 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                     "Flow Rate, high speed.",
                                     HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                     thisDXCoil.Name));
-                    ShowContinueError(
-                        state, EnergyPlus::format("Instead, {:.2R} > {:.2R}", thisDXCoil.RatedAirVolFlowRate2, thisDXCoil.RatedAirVolFlowRate(Mode)));
+                    ShowContinueError(state,
+                                      std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.RatedAirVolFlowRate2, thisDXCoil.RatedAirVolFlowRate(Mode)));
                     ShowFatalError(state, "Preceding conditions cause termination.");
                 }
             }
@@ -8135,10 +8132,9 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                 thisDXCoil.Name,
                                 Mode,
                                 Mode + 1));
-                ShowContinueError(state,
-                                  EnergyPlus::format("Instead, {:.2R} > {:.2R}",
-                                                     thisDXCoil.MSRatedAirVolFlowRate(Mode),
-                                                     thisDXCoil.MSRatedAirVolFlowRate(Mode + 1)));
+                ShowContinueError(
+                    state,
+                    std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.MSRatedAirVolFlowRate(Mode), thisDXCoil.MSRatedAirVolFlowRate(Mode + 1)));
                 ShowFatalError(state, "Preceding conditions cause termination.");
             }
         }
@@ -8227,8 +8223,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                              thisDXCoil.Name,
                                              Mode,
                                              Mode + 1));
-                ShowContinueError(state,
-                                  EnergyPlus::format("Instead, {:.2R} > {:.2R}", thisDXCoil.MSRatedTotCap(Mode), thisDXCoil.MSRatedTotCap(Mode + 1)));
+                ShowContinueError(state, std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.MSRatedTotCap(Mode), thisDXCoil.MSRatedTotCap(Mode + 1)));
                 ShowFatalError(state, "Preceding conditions cause termination.");
             }
         }
@@ -8310,12 +8305,11 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                         std::format("SizeDxCoil: Potential issue with equipment sizing for {} {}",
                                                     HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                     thisDXCoil.Name));
+                            ShowContinueError(
+                                state, std::format("User-Specified Evaporative Condenser Air Flow Rate of {:.5f} [m3/s]", MSEvapCondAirFlowUser));
                             ShowContinueError(
                                 state,
-                                EnergyPlus::format("User-Specified Evaporative Condenser Air Flow Rate of {:.5R} [m3/s]", MSEvapCondAirFlowUser));
-                            ShowContinueError(state,
-                                              EnergyPlus::format("differs from Design Size Evaporative Condenser Air Flow Rate of {:.5R} [m3/s]",
-                                                                 MSEvapCondAirFlowDes));
+                                std::format("differs from Design Size Evaporative Condenser Air Flow Rate of {:.5f} [m3/s]", MSEvapCondAirFlowDes));
                             ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                             ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                         }
@@ -8335,8 +8329,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                              Mode,
                                              Mode + 1));
                 ShowContinueError(
-                    state,
-                    EnergyPlus::format("Instead, {:.2R} > {:.2R}", thisDXCoil.MSEvapCondAirFlow(Mode), thisDXCoil.MSEvapCondAirFlow(Mode + 1)));
+                    state, std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.MSEvapCondAirFlow(Mode), thisDXCoil.MSEvapCondAirFlow(Mode + 1)));
                 ShowFatalError(state, "Preceding conditions cause termination.");
             }
         }
@@ -8381,12 +8374,11 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                                     HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                     thisDXCoil.Name));
                             ShowContinueError(state,
-                                              EnergyPlus::format("User-Specified Evaporative Condenser Pump Rated Power Consumption of {:.2R} [W]",
-                                                                 MSEvapCondPumpElecNomPowerUser));
-                            ShowContinueError(
-                                state,
-                                EnergyPlus::format("differs from Design Size Evaporative Condenser Pump Rated Power Consumption of {:.2R} [W]",
-                                                   MSEvapCondPumpElecNomPowerDes));
+                                              std::format("User-Specified Evaporative Condenser Pump Rated Power Consumption of {:.2f} [W]",
+                                                          MSEvapCondPumpElecNomPowerUser));
+                            ShowContinueError(state,
+                                              std::format("differs from Design Size Evaporative Condenser Pump Rated Power Consumption of {:.2f} [W]",
+                                                          MSEvapCondPumpElecNomPowerDes));
                             ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                             ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                         }
@@ -8406,9 +8398,9 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                              Mode,
                                              Mode + 1));
                 ShowContinueError(state,
-                                  EnergyPlus::format("Instead, {:.2R} > {:.2R}",
-                                                     thisDXCoil.MSEvapCondPumpElecNomPower(Mode),
-                                                     thisDXCoil.MSEvapCondPumpElecNomPower(Mode + 1)));
+                                  std::format("Instead, {:.2f} > {:.2f}",
+                                              thisDXCoil.MSEvapCondPumpElecNomPower(Mode),
+                                              thisDXCoil.MSEvapCondPumpElecNomPower(Mode + 1)));
                 ShowFatalError(state, "Preceding conditions cause termination.");
             }
         }
@@ -8486,10 +8478,9 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                 thisDXCoil.Name,
                                 Mode,
                                 Mode + 1));
-                ShowContinueError(state,
-                                  EnergyPlus::format("Instead, {:.2R} > {:.2R}",
-                                                     thisDXCoil.MSRatedAirVolFlowRate(Mode),
-                                                     thisDXCoil.MSRatedAirVolFlowRate(Mode + 1)));
+                ShowContinueError(
+                    state,
+                    std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.MSRatedAirVolFlowRate(Mode), thisDXCoil.MSRatedAirVolFlowRate(Mode + 1)));
                 ShowFatalError(state, "Preceding conditions cause termination.");
             }
         }
@@ -8525,11 +8516,10 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                             std::format("SizeDxCoil: Potential issue with equipment sizing for {} {}",
                                                         HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                         thisDXCoil.Name));
+                                ShowContinueError(state,
+                                                  std::format("User-Specified Secondary Coil Air Flow Rate of {:.5f} [m3/s]", SecCoilAirFlowUser));
                                 ShowContinueError(
-                                    state, EnergyPlus::format("User-Specified Secondary Coil Air Flow Rate of {:.5R} [m3/s]", SecCoilAirFlowUser));
-                                ShowContinueError(
-                                    state,
-                                    EnergyPlus::format("differs from Design Size Secondary Coil Air Flow Rate of {:.5R} [m3/s]", SecCoilAirFlowDes));
+                                    state, std::format("differs from Design Size Secondary Coil Air Flow Rate of {:.5f} [m3/s]", SecCoilAirFlowDes));
                                 ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                                 ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                             }
@@ -8629,8 +8619,7 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                              thisDXCoil.Name,
                                              Mode,
                                              Mode + 1));
-                ShowContinueError(state,
-                                  EnergyPlus::format("Instead, {:.2R} > {:.2R}", thisDXCoil.MSRatedTotCap(Mode), thisDXCoil.MSRatedTotCap(Mode + 1)));
+                ShowContinueError(state, std::format("Instead, {:.2f} > {:.2f}", thisDXCoil.MSRatedTotCap(Mode), thisDXCoil.MSRatedTotCap(Mode + 1)));
                 ShowFatalError(state, "Preceding conditions cause termination.");
             }
         }
@@ -8669,10 +8658,9 @@ void SizeDXCoil(EnergyPlusData &state, int const DXCoilNum)
                                            std::format("SizeDxCoil: Potential issue with equipment sizing for {} {}",
                                                        HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                        thisDXCoil.Name));
+                        ShowContinueError(state, std::format("User-Specified Resistive Defrost Heater Capacity of {:.2f}[W]", DefrostCapacityUser));
                         ShowContinueError(state,
-                                          EnergyPlus::format("User-Specified Resistive Defrost Heater Capacity of {:.2R}[W]", DefrostCapacityUser));
-                        ShowContinueError(
-                            state, EnergyPlus::format("differs from Design Size Resistive Defrost Heater Capacity of {:.2R}[W]", DefrostCapacityDes));
+                                          std::format("differs from Design Size Resistive Defrost Heater Capacity of {:.2f}[W]", DefrostCapacityDes));
                         ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
                         ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
                     }
@@ -9587,16 +9575,16 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 ShowWarningMessage(
                     state,
                     EnergyPlus::format(
-                        "{}{}=\"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at {:.3R} m3/s/W.",
+                        "{}{}=\"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at {:.3f} m3/s/W.",
                         RoutineName,
                         HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                         thisDXCoil.Name,
                         VolFlowperRatedTotCap));
                 ShowContinueErrorTimeStamp(state, "");
                 ShowContinueError(state,
-                                  EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}]",
-                                                     HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                                     HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
+                                  std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}]",
+                                              HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                              HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
                 ShowContinueError(state, "Possible causes include inconsistent air flow rates in system components,");
                 ShowContinueError(state, "or variable air volume [VAV] system using incorrect coil type.");
             }
@@ -9617,16 +9605,16 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 ShowWarningMessage(
                     state,
                     EnergyPlus::format(
-                        "{}{}=\"{}\" - Air volume flow rate per watt of rated total water heating capacity is out of range at {:.2R} m3/s/W.",
+                        "{}{}=\"{}\" - Air volume flow rate per watt of rated total water heating capacity is out of range at {:.2f} m3/s/W.",
                         RoutineName,
                         HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                         thisDXCoil.Name,
                         VolFlowperRatedTotCap));
                 ShowContinueErrorTimeStamp(state, "");
                 ShowContinueError(state,
-                                  EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}]",
-                                                     HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                                     HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
+                                  std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}]",
+                                              HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                              HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
                 ShowContinueError(state,
                                   "Possible causes may be that the parent object is calling for an actual supply air flow rate that is much "
                                   "higher or lower than the DX coil rated supply air flow rate.");
@@ -9664,7 +9652,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 thisDXCoil.LowTempLast = OutdoorDryBulb;
                 if (thisDXCoil.LowAmbErrIndex == 0) {
                     thisDXCoil.LowAmbBuffer1 = EnergyPlus::format(
-                        "{} \"{}\" - Air-cooled condenser inlet dry-bulb temperature below 0 C. Outdoor dry-bulb temperature = {:.2R}",
+                        "{} \"{}\" - Air-cooled condenser inlet dry-bulb temperature below 0 C. Outdoor dry-bulb temperature = {:.2f}",
                         HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                         thisDXCoil.Name,
                         OutdoorDryBulb);
@@ -9678,7 +9666,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                 thisDXCoil.LowTempLast = OutdoorWetBulb;
                 if (thisDXCoil.LowAmbErrIndex == 0) {
                     thisDXCoil.LowAmbBuffer1 = EnergyPlus::format(
-                        "{} \"{}\" - Evap-cooled condenser inlet wet-bulb temperature below 10 C. Outdoor wet-bulb temperature = {:.2R}",
+                        "{} \"{}\" - Evap-cooled condenser inlet wet-bulb temperature below 10 C. Outdoor wet-bulb temperature = {:.2f}",
                         HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                         thisDXCoil.Name,
                         OutdoorWetBulb);
@@ -9872,8 +9860,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                     ShowWarningMessage(
                         state,
                         std::format("{}{}=\"{}\", runtime fraction", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
-                    ShowWarningMessage(state,
-                                       EnergyPlus::format("The runtime fraction exceeded 1.0. [{:.4R}].", thisDXCoil.CoolingCoilRuntimeFraction));
+                    ShowWarningMessage(state, std::format("The runtime fraction exceeded 1.0. [{:.4f}].", thisDXCoil.CoolingCoilRuntimeFraction));
                     ShowContinueError(state, "Runtime fraction reset to 1 and the simulation will continue.");
                     ShowContinueError(
                         state,
@@ -9883,8 +9870,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
                     ShowWarningMessage(
                         state,
                         std::format("{}{}=\"{}\", runtime fraction", RoutineName, HVAC::coilTypeNames[(int)thisDXCoil.coilType], thisDXCoil.Name));
-                    ShowWarningMessage(state,
-                                       EnergyPlus::format("The runtime fraction exceeded 1.0. [{:.4R}].", thisDXCoil.CoolingCoilRuntimeFraction));
+                    ShowWarningMessage(state, std::format("The runtime fraction exceeded 1.0. [{:.4f}].", thisDXCoil.CoolingCoilRuntimeFraction));
                     ShowContinueError(state, "Runtime fraction reset to 1 and the simulation will continue.");
                     ShowContinueError(
                         state,
@@ -9964,7 +9950,7 @@ void CalcDoe2DXCoil(EnergyPlusData &state,
             if (thisDXCoil.LowOutletTempIndex == 0) {
                 thisDXCoil.FullLoadInletAirTempLast = InletAirDryBulbTemp;
                 thisDXCoil.LowOutTempBuffer1 = EnergyPlus::format("{} \"{}\" - Full load outlet air dry-bulb temperature < 2C. This indicates the "
-                                                                  "possibility of coil frost/freeze. Outlet temperature = {:.2R} C.",
+                                                                  "possibility of coil frost/freeze. Outlet temperature = {:.2f} C.",
                                                                   HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                                   thisDXCoil.Name,
                                                                   FullLoadOutAirTemp);
@@ -10633,31 +10619,31 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             if (thisDXCoil.ErrIndex1 == 0) {
                 ShowWarningMessage(
                     state,
-                    EnergyPlus::format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at {:.3R} m3/s/W.",
-                                       HVAC::coilTypeNames[(int)thisDXCoil.coilType],
-                                       thisDXCoil.Name,
-                                       VolFlowperRatedTotCap));
+                    std::format("{} \"{}\" - Air volume flow rate per watt of rated total cooling capacity is out of range at {:.3f} m3/s/W.",
+                                HVAC::coilTypeNames[(int)thisDXCoil.coilType],
+                                thisDXCoil.Name,
+                                VolFlowperRatedTotCap));
                 ShowContinueErrorTimeStamp(state, "");
                 ShowContinueError(state,
-                                  EnergyPlus::format("...Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}]",
-                                                     HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                                     HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
+                                  std::format("...Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}]",
+                                              HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                              HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
                 ShowContinueError(state, "...Possible causes include inconsistent air flow rates in system components,");
                 ShowContinueError(state, "...or mixing manual inputs with autosize inputs. Also check the following values and calculations.");
                 ShowContinueError(state, "...Volume Flow Rate per Rated Total Capacity = Volume Flow Rate / Rated Total Capacity");
                 ShowContinueError(state, "...Volume Flow Rate = Air Mass Flow Rate / Air Density");
                 ShowContinueError(state, "...Data used for calculations:");
-                ShowContinueError(state, EnergyPlus::format("...Rated Total Capacity = {:.2R} W.", thisDXCoil.RatedTotCap(Mode)));
+                ShowContinueError(state, std::format("...Rated Total Capacity = {:.2f} W.", thisDXCoil.RatedTotCap(Mode)));
                 ShowContinueError(state, "...Volume Flow Rate = Air Mass Flow Rate / Air Density");
-                ShowContinueError(state, EnergyPlus::format("...Volume Flow Rate   = {:.8R} m3/s.", AirVolumeFlowRate));
-                ShowContinueError(state, EnergyPlus::format("...Air Mass Flow Rate = {:.8R} kg/s.", AirMassFlow));
+                ShowContinueError(state, std::format("...Volume Flow Rate   = {:.8f} m3/s.", AirVolumeFlowRate));
+                ShowContinueError(state, std::format("...Air Mass Flow Rate = {:.8f} kg/s.", AirMassFlow));
                 ShowContinueError(state,
-                                  EnergyPlus::format("...Air Density        = {:.8R} kg/m3.",
-                                                     PsyRhoAirFnPbTdbW(state, OutdoorPressure, InletAirDryBulbTemp, InletAirHumRat)));
+                                  std::format("...Air Density        = {:.8f} kg/m3.",
+                                              PsyRhoAirFnPbTdbW(state, OutdoorPressure, InletAirDryBulbTemp, InletAirHumRat)));
                 ShowContinueError(state, "...Data used for air density calculation:");
-                ShowContinueError(state, EnergyPlus::format("...Outdoor Air Pressure     = {:.3R} Pa.", OutdoorPressure));
-                ShowContinueError(state, EnergyPlus::format("...Inlet Air Dry-Bulb Temp  = {:.3R} C.", InletAirDryBulbTemp));
-                ShowContinueError(state, EnergyPlus::format("...Inlet Air Humidity Ratio = {:.8R} kgWater/kgDryAir.", InletAirHumRat));
+                ShowContinueError(state, std::format("...Outdoor Air Pressure     = {:.3f} Pa.", OutdoorPressure));
+                ShowContinueError(state, std::format("...Inlet Air Dry-Bulb Temp  = {:.3f} C.", InletAirDryBulbTemp));
+                ShowContinueError(state, std::format("...Inlet Air Humidity Ratio = {:.3E} kgWater/kgDryAir.", InletAirHumRat));
             }
             ShowRecurringWarningErrorAtEnd(
                 state,
@@ -10689,12 +10675,11 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             thisDXCoil.PrintLowAmbMessage = true;
             thisDXCoil.LowTempLast = OutdoorDryBulb;
             if (thisDXCoil.LowAmbErrIndex == 0) {
-                thisDXCoil.LowAmbBuffer1 =
-                    EnergyPlus::format("{} \"{}\" - Condenser inlet temperature below {:.2R} C. Condenser inlet temperature = {:.2R}",
-                                       HVAC::coilTypeNames[(int)thisDXCoil.coilType],
-                                       thisDXCoil.Name,
-                                       thisDXCoil.MinOATCompressor,
-                                       OutdoorDryBulb);
+                thisDXCoil.LowAmbBuffer1 = std::format("{} \"{}\" - Condenser inlet temperature below {:.2f} C. Condenser inlet temperature = {:.2f}",
+                                                       HVAC::coilTypeNames[(int)thisDXCoil.coilType],
+                                                       thisDXCoil.Name,
+                                                       thisDXCoil.MinOATCompressor,
+                                                       OutdoorDryBulb);
                 thisDXCoil.LowAmbBuffer2 = " ... Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
                                            CreateSysTimeIntervalString(state);
             }
@@ -10705,12 +10690,11 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             thisDXCoil.PrintHighAmbMessage = true;
             thisDXCoil.HighTempLast = OutdoorDryBulb;
             if (thisDXCoil.HighAmbErrIndex == 0) {
-                thisDXCoil.HighAmbBuffer1 =
-                    EnergyPlus::format("{} \"{}\" - Condenser inlet temperature above {:.2R} C. Condenser temperature = {:.2R}",
-                                       HVAC::coilTypeNames[(int)thisDXCoil.coilType],
-                                       thisDXCoil.Name,
-                                       thisDXCoil.MaxOATCompressor,
-                                       OutdoorDryBulb);
+                thisDXCoil.HighAmbBuffer1 = std::format("{} \"{}\" - Condenser inlet temperature above {:.2f} C. Condenser temperature = {:.2f}",
+                                                        HVAC::coilTypeNames[(int)thisDXCoil.coilType],
+                                                        thisDXCoil.Name,
+                                                        thisDXCoil.MaxOATCompressor,
+                                                        OutdoorDryBulb);
                 thisDXCoil.HighAmbBuffer2 = " ... Occurrence info = " + state.dataEnvrn->EnvironmentName + ", " + state.dataEnvrn->CurMnDy + ' ' +
                                             CreateSysTimeIntervalString(state);
             }
@@ -10841,7 +10825,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
                 ShowWarningMessage(
                     state,
                     EnergyPlus::format(
-                        "The PLF curve value for the DX cooling coil {} ={:.3R} for part-load ratio ={:.3R}", thisDXCoil.Name, PLF, PartLoadRatio));
+                        "The PLF curve value for the DX cooling coil {} ={:.3f} for part-load ratio ={:.3f}", thisDXCoil.Name, PLF, PartLoadRatio));
                 ShowContinueErrorTimeStamp(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and simulation is continuing.");
                 ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Cooling:DX:SingleSpeed].");
             }
@@ -10855,9 +10839,9 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
         if (thisDXCoil.CoolingCoilRuntimeFraction > 1.0 && std::abs(thisDXCoil.CoolingCoilRuntimeFraction - 1.0) > 0.001) {
             if (thisDXCoil.ErrIndex3 == 0) {
                 ShowWarningMessage(state,
-                                   EnergyPlus::format("The runtime fraction for DX cooling coil {} exceeded 1.0. [{:.4R}].",
-                                                      thisDXCoil.Name,
-                                                      thisDXCoil.CoolingCoilRuntimeFraction));
+                                   std::format("The runtime fraction for DX cooling coil {} exceeded 1.0. [{:.4f}].",
+                                               thisDXCoil.Name,
+                                               thisDXCoil.CoolingCoilRuntimeFraction));
                 ShowContinueError(state, "Runtime fraction reset to 1 and the simulation will continue.");
                 ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Cooling:DX:SingleSpeed].");
                 ShowContinueErrorTimeStamp(state, "");
@@ -10911,7 +10895,7 @@ void CalcVRFCoolingCoil(EnergyPlusData &state,
             if (thisDXCoil.LowOutletTempIndex == 0) {
                 thisDXCoil.FullLoadInletAirTempLast = InletAirDryBulbTemp;
                 thisDXCoil.LowOutTempBuffer1 = EnergyPlus::format("{} \"{}\" - Full load outlet air dry-bulb temperature < 2C. This indicates the "
-                                                                  "possibility of coil frost/freeze. Outlet temperature = {:.2R} C.",
+                                                                  "possibility of coil frost/freeze. Outlet temperature = {:.2f} C.",
                                                                   HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                                   thisDXCoil.Name,
                                                                   FullLoadOutAirTemp);
@@ -11221,15 +11205,15 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
             if (thisDXCoil.ErrIndex1 == 0) {
                 ShowWarningMessage(
                     state,
-                    EnergyPlus::format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range at {:.3R} m3/s/W.",
-                                       HVAC::coilTypeNames[(int)thisDXCoil.coilType],
-                                       thisDXCoil.Name,
-                                       VolFlowperRatedTotCap));
+                    std::format("{} \"{}\" - Air volume flow rate per watt of rated total heating capacity is out of range at {:.3f} m3/s/W.",
+                                HVAC::coilTypeNames[(int)thisDXCoil.coilType],
+                                thisDXCoil.Name,
+                                VolFlowperRatedTotCap));
                 ShowContinueErrorTimeStamp(state, "");
                 ShowContinueError(state,
-                                  EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}]",
-                                                     HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                                     HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
+                                  std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}]",
+                                              HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                              HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]));
                 ShowContinueError(state, "Possible causes include inconsistent air flow rates in system components or");
                 ShowContinueError(state, "inconsistent supply air fan operation modes in coil and unitary system objects.");
             }
@@ -11283,8 +11267,8 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
 
         if (TotCapTempModFac < 0.0) {
             if (thisDXCoil.CAPFTErrIndex == 0) {
-                ShowWarningMessage(
-                    state, EnergyPlus::format("The TotCapTempModFac curve value for DX heating coil {} ={:.2R}", thisDXCoil.Name, TotCapTempModFac));
+                ShowWarningMessage(state,
+                                   std::format("The TotCapTempModFac curve value for DX heating coil {} ={:.2f}", thisDXCoil.Name, TotCapTempModFac));
                 ShowContinueError(state,
                                   "TotCapTempModFac curve value must be > 0. TotCapTempModFac curve value has been reset to 0.0 and "
                                   "simulation is continuing.");
@@ -11427,8 +11411,8 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
 
         if (EIRTempModFac < 0.0) {
             if (thisDXCoil.EIRFTErrIndex == 0) {
-                ShowWarningMessage(
-                    state, EnergyPlus::format("The EIRTempModFac curve value for DX heating coil {} ={:.2R}", thisDXCoil.Name, EIRTempModFac));
+                ShowWarningMessage(state,
+                                   std::format("The EIRTempModFac curve value for DX heating coil {} ={:.2f}", thisDXCoil.Name, EIRTempModFac));
                 ShowContinueError(
                     state, "EIRTempModFac curve value must be > 0.  EIRTempModFac curve value has been reset to 0.0 and simulation is continuing.");
                 ShowContinueError(state,
@@ -11462,7 +11446,7 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
                 ShowWarningMessage(
                     state,
                     EnergyPlus::format(
-                        "The PLF curve value for DX heating coil {} ={:.2R} for part-load ratio ={:.2R}", thisDXCoil.Name, PLF, PLRHeating));
+                        "The PLF curve value for DX heating coil {} ={:.2f} for part-load ratio ={:.2f}", thisDXCoil.Name, PLF, PLRHeating));
                 ShowContinueError(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and simulation is continuing.");
                 ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:DX:SingleSpeed].");
                 ShowContinueErrorTimeStamp(state, "");
@@ -11475,9 +11459,9 @@ void CalcDXHeatingCoil(EnergyPlusData &state,
         if (thisDXCoil.HeatingCoilRuntimeFraction > 1.0 && std::abs(thisDXCoil.HeatingCoilRuntimeFraction - 1.0) > 0.001) {
             if (thisDXCoil.ErrIndex4 == 0) {
                 ShowWarningMessage(state,
-                                   EnergyPlus::format("The runtime fraction for DX heating coil {} exceeded 1.0. [{:.4R}].",
-                                                      thisDXCoil.Name,
-                                                      thisDXCoil.HeatingCoilRuntimeFraction));
+                                   std::format("The runtime fraction for DX heating coil {} exceeded 1.0. [{:.4f}].",
+                                               thisDXCoil.Name,
+                                               thisDXCoil.HeatingCoilRuntimeFraction));
                 ShowContinueError(state, "Runtime fraction is set to 1.0 and the simulation continues...");
                 ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:DX:SingleSpeed].");
                 ShowContinueErrorTimeStamp(state, "");
@@ -12235,18 +12219,18 @@ Real64 CalcCBF(EnergyPlusData &state,
     if (OutletAirTemp < OutletAirDPTemp) {
         ShowSevereError(state, std::format("For object = {}, name = \"{}\"", UnitType, UnitName));
         ShowContinueError(state, "Calculated outlet air temperature is lower than the dew point temperature at the same humidity ratio.");
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Temperature                      = {:.2R} C", InletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Temperature                     = {:.2R} C", OutletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Dew Point Temperature                      = {:.2R} C", OutletAirDPTemp));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Humidity Ratio                   = {:.6R} kgWater/kgDryAir", InletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Humidity Ratio                  = {:.6R} kgWater/kgDryAir", OutletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Dew Point Humidity Ratio                   = {:.6R} kgWater/kgDryAir", OutletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Enthalpy                         = {:.2R} J/kg", InletAirEnthalpy));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Enthalpy                        = {:.2R} J/kg", OutletAirEnthalpy));
-        ShowContinueError(state, EnergyPlus::format("...Total Cooling Capacity used in calculation = {:.2R} W", TotCap));
-        ShowContinueError(state, EnergyPlus::format("...Air Mass Flow Rate used in calculation     = {:.6R} kg/s", AirMassFlowRate));
-        ShowContinueError(state, EnergyPlus::format("...Air Volume Flow Rate used in calculation   = {:.6R} m3/s", AirVolFlowRate));
-        ShowContinueError(state, EnergyPlus::format("...Sensible Heat Ratio                        = {:.2R}", SHR));
+        ShowContinueError(state, std::format("...Inlet Air Temperature                      = {:.2f} C", InletAirTemp));
+        ShowContinueError(state, std::format("...Outlet Air Temperature                     = {:.2f} C", OutletAirTemp));
+        ShowContinueError(state, std::format("...Dew Point Temperature                      = {:.2f} C", OutletAirDPTemp));
+        ShowContinueError(state, std::format("...Inlet Air Humidity Ratio                   = {:.3E} kgWater/kgDryAir", InletAirHumRat));
+        ShowContinueError(state, std::format("...Outlet Air Humidity Ratio                  = {:.3E} kgWater/kgDryAir", OutletAirHumRat));
+        ShowContinueError(state, std::format("...Dew Point Humidity Ratio                   = {:.3E} kgWater/kgDryAir", OutletAirHumRat));
+        ShowContinueError(state, std::format("...Inlet Air Enthalpy                         = {:.2f} J/kg", InletAirEnthalpy));
+        ShowContinueError(state, std::format("...Outlet Air Enthalpy                        = {:.2f} J/kg", OutletAirEnthalpy));
+        ShowContinueError(state, std::format("...Total Cooling Capacity used in calculation = {:.2f} W", TotCap));
+        ShowContinueError(state, std::format("...Air Mass Flow Rate used in calculation     = {:.6f} kg/s", AirMassFlowRate));
+        ShowContinueError(state, std::format("...Air Volume Flow Rate used in calculation   = {:.6f} m3/s", AirVolFlowRate));
+        ShowContinueError(state, std::format("...Sensible Heat Ratio                        = {:.2f}", SHR));
         ShowContinueError(state, "Check coil design sensible heat ratio, total gross rated capacity, and air flow inputs.");
     }
 
@@ -12261,20 +12245,19 @@ Real64 CalcCBF(EnergyPlusData &state,
         ShowContinueError(state, "capacity, increase the rated air volume flow rate, or reduce the rated sensible heat ratio for this coil.");
         ShowContinueError(state, "If autosizing, it is recommended that all three of these values be autosized.");
         ShowContinueError(state, "...Inputs used for calculating cooling coil bypass factor.");
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Temperature     = {:.2R} C", InletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Temperature    = {:.2R} C", OutletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Humidity Ratio  = {:.6R} kgWater/kgDryAir", InletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Humidity Ratio = {:.6R} kgWater/kgDryAir", OutletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Total Cooling Capacity used in calculation = {:.2R} W", TotCap));
-        ShowContinueError(state, EnergyPlus::format("...Air Mass Flow Rate used in calculation     = {:.6R} kg/s", AirMassFlowRate));
-        ShowContinueError(state, EnergyPlus::format("...Air Volume Flow Rate used in calculation   = {:.6R} m3/s", AirVolFlowRate));
+        ShowContinueError(state, std::format("...Inlet Air Temperature     = {:.2f} C", InletAirTemp));
+        ShowContinueError(state, std::format("...Outlet Air Temperature    = {:.2f} C", OutletAirTemp));
+        ShowContinueError(state, std::format("...Inlet Air Humidity Ratio  = {:.3E} kgWater/kgDryAir", InletAirHumRat));
+        ShowContinueError(state, std::format("...Outlet Air Humidity Ratio = {:.3E} kgWater/kgDryAir", OutletAirHumRat));
+        ShowContinueError(state, std::format("...Total Cooling Capacity used in calculation = {:.2f} W", TotCap));
+        ShowContinueError(state, std::format("...Air Mass Flow Rate used in calculation     = {:.6f} kg/s", AirMassFlowRate));
+        ShowContinueError(state, std::format("...Air Volume Flow Rate used in calculation   = {:.6f} m3/s", AirVolFlowRate));
         if (TotCap > 0.0) {
             if (((HVAC::MinRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT] - AirVolFlowRate / TotCap) > SmallDifferenceTest) ||
                 ((AirVolFlowRate / TotCap - HVAC::MaxRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]) > SmallDifferenceTest)) {
-                ShowContinueError(
-                    state,
-                    EnergyPlus::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7R} m3/s/W",
-                                       AirVolFlowRate / TotCap));
+                ShowContinueError(state,
+                                  std::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7f} m3/s/W",
+                                              AirVolFlowRate / TotCap));
             }
         }
         ShowContinueErrorTimeStamp(state, "");
@@ -12286,8 +12269,8 @@ Real64 CalcCBF(EnergyPlusData &state,
             HTinHumRatOut = PsyHFnTdbW(InletAirTemp, OutletAirHumRat);
             adjustedSHR = (HTinHumRatOut - OutletAirEnthalpy) / DeltaH;
             ShowContinueError(state, "CalcCBF: SHR adjusted to achieve valid outlet air properties and the simulation continues.");
-            ShowContinueError(state, EnergyPlus::format("CalcCBF: initial SHR = {:.5R}", SHR));
-            ShowContinueError(state, EnergyPlus::format("CalcCBF: adjusted SHR = {:.5R}", adjustedSHR));
+            ShowContinueError(state, std::format("CalcCBF: initial SHR = {:.5f}", SHR));
+            ShowContinueError(state, std::format("CalcCBF: adjusted SHR = {:.5f}", adjustedSHR));
         }
     }
     DeltaT = InletAirTemp - OutletAirTemp;
@@ -12299,20 +12282,19 @@ Real64 CalcCBF(EnergyPlusData &state,
         ShowContinueError(state, "capacity, rated air volume flow rate, or rated sensible heat ratio for this coil.");
         ShowContinueError(state, "If autosizing, it is recommended that all three of these values be autosized.");
         ShowContinueError(state, "...Inputs used for calculating cooling coil bypass factor.");
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Temperature     = {:.2R} C", InletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Temperature    = {:.2R} C", OutletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Humidity Ratio  = {:.6R} kgWater/kgDryAir", InletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Humidity Ratio = {:.6R} kgWater/kgDryAir", OutletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Total Cooling Capacity used in calculation = {:.2R} W", TotCap));
-        ShowContinueError(state, EnergyPlus::format("...Air Mass Flow Rate used in calculation     = {:.6R} kg/s", AirMassFlowRate));
-        ShowContinueError(state, EnergyPlus::format("...Air Volume Flow Rate used in calculation   = {:.6R} m3/s", AirVolFlowRate));
+        ShowContinueError(state, std::format("...Inlet Air Temperature     = {:.2f} C", InletAirTemp));
+        ShowContinueError(state, std::format("...Outlet Air Temperature    = {:.2f} C", OutletAirTemp));
+        ShowContinueError(state, std::format("...Inlet Air Humidity Ratio  = {:.3E} kgWater/kgDryAir", InletAirHumRat));
+        ShowContinueError(state, std::format("...Outlet Air Humidity Ratio = {:.3E} kgWater/kgDryAir", OutletAirHumRat));
+        ShowContinueError(state, std::format("...Total Cooling Capacity used in calculation = {:.2f} W", TotCap));
+        ShowContinueError(state, std::format("...Air Mass Flow Rate used in calculation     = {:.6f} kg/s", AirMassFlowRate));
+        ShowContinueError(state, std::format("...Air Volume Flow Rate used in calculation   = {:.6f} m3/s", AirVolFlowRate));
         if (TotCap > 0.0) {
             if (((HVAC::MinRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT] - AirVolFlowRate / TotCap) > SmallDifferenceTest) ||
                 ((AirVolFlowRate / TotCap - HVAC::MaxRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]) > SmallDifferenceTest)) {
-                ShowContinueError(
-                    state,
-                    EnergyPlus::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7R} m3/s/W",
-                                       AirVolFlowRate / TotCap));
+                ShowContinueError(state,
+                                  std::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7f} m3/s/W",
+                                              AirVolFlowRate / TotCap));
             }
         }
         ShowContinueErrorTimeStamp(state, "");
@@ -12329,21 +12311,20 @@ Real64 CalcCBF(EnergyPlusData &state,
         //   outlet air humidity ratio can't be less than zero.
         ShowSevereError(state, std::format("{} \"{}\"", UnitType, UnitName));
         ShowContinueError(state, "...Invalid slope or outlet air condition when calculating cooling coil bypass factor.");
-        ShowContinueError(state, EnergyPlus::format("...Slope = {:.8R}", SlopeAtConds));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Temperature     = {:.2R} C", InletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Temperature    = {:.2R} C", OutletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Inlet Air Humidity Ratio  = {:.6R} kgWater/kgDryAir", InletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Outlet Air Humidity Ratio = {:.6R} kgWater/kgDryAir", OutletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Total Cooling Capacity used in calculation = {:.2R} W", TotCap));
-        ShowContinueError(state, EnergyPlus::format("...Air Mass Flow Rate used in calculation     = {:.6R} kg/s", AirMassFlowRate));
-        ShowContinueError(state, EnergyPlus::format("...Air Volume Flow Rate used in calculation   = {:.6R} m3/s", AirVolFlowRate));
+        ShowContinueError(state, std::format("...Slope = {:.8f}", SlopeAtConds));
+        ShowContinueError(state, std::format("...Inlet Air Temperature     = {:.2f} C", InletAirTemp));
+        ShowContinueError(state, std::format("...Outlet Air Temperature    = {:.2f} C", OutletAirTemp));
+        ShowContinueError(state, std::format("...Inlet Air Humidity Ratio  = {:.3E} kgWater/kgDryAir", InletAirHumRat));
+        ShowContinueError(state, std::format("...Outlet Air Humidity Ratio = {:.3E} kgWater/kgDryAir", OutletAirHumRat));
+        ShowContinueError(state, std::format("...Total Cooling Capacity used in calculation = {:.2f} W", TotCap));
+        ShowContinueError(state, std::format("...Air Mass Flow Rate used in calculation     = {:.6f} kg/s", AirMassFlowRate));
+        ShowContinueError(state, std::format("...Air Volume Flow Rate used in calculation   = {:.6f} m3/s", AirVolFlowRate));
         if (TotCap > 0.0) {
             if (((HVAC::MinRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT] - AirVolFlowRate / TotCap) > SmallDifferenceTest) ||
                 ((AirVolFlowRate / TotCap - HVAC::MaxRatedVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT]) > SmallDifferenceTest)) {
-                ShowContinueError(
-                    state,
-                    EnergyPlus::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7R} m3/s/W",
-                                       AirVolFlowRate / TotCap));
+                ShowContinueError(state,
+                                  std::format("...Air Volume Flow Rate per Watt of Rated Cooling Capacity is also out of bounds at = {:.7f} m3/s/W",
+                                              AirVolFlowRate / TotCap));
             }
         }
         ShowContinueErrorTimeStamp(state, "");
@@ -12403,7 +12384,7 @@ Real64 CalcCBF(EnergyPlusData &state,
         if (Iter > IterMax && PrintFlag) {
             ShowSevereError(state,
                             std::format("{} \"{}\" -- coil bypass factor calculation did not converge after max iterations.", UnitType, UnitName));
-            ShowContinueError(state, EnergyPlus::format("The RatedSHR of [{:.3R}], entered by the user or autosized (see *.eio file),", SHR));
+            ShowContinueError(state, std::format("The RatedSHR of [{:.3f}], entered by the user or autosized (see *.eio file),", SHR));
             ShowContinueError(state, "may be causing this. The line defined by the coil rated inlet air conditions");
             ShowContinueError(state, "(26.7C drybulb and 19.4C wetbulb) and the RatedSHR (i.e., slope of the line) must intersect");
             ShowContinueError(state, "the saturation curve of the psychrometric chart. If the RatedSHR is too low, then this");
@@ -12494,17 +12475,16 @@ Real64 ValidateADP(EnergyPlusData &state,
     if (shrADPMax > 1.0) {
         ShowWarningError(state, std::format("ValidateADP: Sensible heat ratio (SHR) calculation error for {} \"{} ", UnitType, UnitName));
         ShowContinueError(state, "The maximum design SHR calculated based on the design total cooling capacity and flow rate is greater than 1.0.");
-        ShowContinueError(state, EnergyPlus::format("...Total Cooling Capacity                  = {:.2R} W", TotCap));
-        ShowContinueError(state, EnergyPlus::format("...Mass Flow Rate                          = {:.6R} kg/s", AirMassFlow));
-        ShowContinueError(state, EnergyPlus::format("...Volumetric Flow Rate                    = {:.6R} m3/s", AirVolFlowRate));
-        ShowContinueError(state, EnergyPlus::format("...Coil Inlet Temperature                  = {:.2R} C", RatedInletAirTemp));
-        ShowContinueError(state, EnergyPlus::format("...Coil Inlet Humidity Ratio               = {:.6R} kgWater/kgDryAir", RatedInletAirHumRat));
-        ShowContinueError(state, EnergyPlus::format("...Coil Inlet Enthalpy                     = {:.6R} J/kg", InletAirEnthalpy));
-        ShowContinueError(state, EnergyPlus::format("...Coil Apparatus Dew Point Temperature     = {:.2R} C", tempADPMax));
-        ShowContinueError(state, EnergyPlus::format("...Coil Apparatus Dew Point Humidity Ratio  = {:.6R} kgWater/kgDryAir", humRatADP));
+        ShowContinueError(state, std::format("...Total Cooling Capacity                  = {:.2f} W", TotCap));
+        ShowContinueError(state, std::format("...Mass Flow Rate                          = {:.6f} kg/s", AirMassFlow));
+        ShowContinueError(state, std::format("...Volumetric Flow Rate                    = {:.6f} m3/s", AirVolFlowRate));
+        ShowContinueError(state, std::format("...Coil Inlet Temperature                  = {:.2f} C", RatedInletAirTemp));
+        ShowContinueError(state, std::format("...Coil Inlet Humidity Ratio               = {:.3E} kgWater/kgDryAir", RatedInletAirHumRat));
+        ShowContinueError(state, std::format("...Coil Inlet Enthalpy                     = {:.6f} J/kg", InletAirEnthalpy));
+        ShowContinueError(state, std::format("...Coil Apparatus Dew Point Temperature     = {:.2f} C", tempADPMax));
+        ShowContinueError(state, std::format("...Coil Apparatus Dew Point Humidity Ratio  = {:.3E} kgWater/kgDryAir", humRatADP));
         ShowContinueError(
-            state,
-            EnergyPlus::format("...Coil Enthalpy at Inlet Temperature and Apparatus Dew Point Humidity Ratio  = {:.2R} C", enthalpyTempinHumRatADP));
+            state, std::format("...Coil Enthalpy at Inlet Temperature and Apparatus Dew Point Humidity Ratio  = {:.3E} C", enthalpyTempinHumRatADP));
         ShowContinueError(state, "The maximum design SHR is assumed to be 1.0.");
     }
     shrADPMax = min(1.0, shrADPMax);
@@ -13021,19 +13001,18 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
             ShowContinueErrorTimeStamp(state, "");
             ShowContinueError(
                 state,
-                EnergyPlus::format("AirMassFlow={:.3R},CycRatio={:.3R},SpeedNum={:.0R}, MSHPMassFlowRateLow={:.3R}, MSHPMassFlowRateHigh={:.3R}",
-                                   AirMassFlow,
-                                   double(SpeedNum),
-                                   CycRatio,
-                                   MSHPMassFlowRateLow,
-                                   MSHPMassFlowRateHigh));
+                std::format("AirMassFlow={:.3f},CycRatio={:.3f},SpeedNum={:.0f}, MSHPMassFlowRateLow={:.3f}, MSHPMassFlowRateHigh={:.3f}",
+                            AirMassFlow,
+                            double(SpeedNum),
+                            CycRatio,
+                            MSHPMassFlowRateLow,
+                            MSHPMassFlowRateHigh));
             ShowFatalError(state, "Preceding condition(s) causes termination.");
         } else {
             ShowContinueError(state, "When AirMassFlow > 0.0 and CycRatio > 0.0, then MSHPMassFlowRateHigh must also be > 0.0");
             ShowContinueErrorTimeStamp(state, "");
             ShowContinueError(
-                state,
-                EnergyPlus::format("AirMassFlow={:.3R},CycRatio={:.3R}, MSHPMassFlowRateHigh={:.3R}", AirMassFlow, CycRatio, MSHPMassFlowRateHigh));
+                state, std::format("AirMassFlow={:.3f},CycRatio={:.3f}, MSHPMassFlowRateHigh={:.3f}", AirMassFlow, CycRatio, MSHPMassFlowRateHigh));
             ShowFatalError(state, "Preceding condition(s) causes termination.");
         }
     } else if (CycRatio > 1.0 || SpeedRatio > 1.0) {
@@ -13043,7 +13022,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                                     thisDXCoil.Name));
         ShowContinueError(state, "CycRatio and SpeedRatio must be between 0.0 and 1.0");
         ShowContinueErrorTimeStamp(state, "");
-        ShowContinueError(state, EnergyPlus::format("CycRatio={:.1R}, SpeedRatio = {:.1R}", CycRatio, SpeedRatio));
+        ShowContinueError(state, std::format("CycRatio={:.1f}, SpeedRatio = {:.1f}", CycRatio, SpeedRatio));
         ShowFatalError(state, "Preceding condition(s) causes termination.");
     }
 
@@ -13097,10 +13076,10 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                     ShowContinueErrorTimeStamp(state, "");
                     ShowContinueError(
                         state,
-                        EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}] Current value is {:.3R} m3/s/W",
-                                           HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           VolFlowperRatedTotCap));
+                        std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}] Current value is {:.3f} m3/s/W",
+                                    HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    VolFlowperRatedTotCap));
                     ShowContinueError(state, "Possible causes include inconsistent air flow rates in system components or");
                     ShowContinueError(state, "inconsistent supply air fan operation modes in coil and unitary system objects.");
                 }
@@ -13134,10 +13113,10 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                     ShowContinueErrorTimeStamp(state, "");
                     ShowContinueError(
                         state,
-                        EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}] Current value is {:.3R} m3/s/W",
-                                           HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           VolFlowperRatedTotCap));
+                        std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}] Current value is {:.3f} m3/s/W",
+                                    HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    VolFlowperRatedTotCap));
                     ShowContinueError(state, "Possible causes include inconsistent air flow rates in system components or");
                     ShowContinueError(state, "inconsistent supply air fan operation modes in coil and unitary system objects.");
                 }
@@ -13447,10 +13426,10 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
                     ShowContinueErrorTimeStamp(state, "");
                     ShowContinueError(
                         state,
-                        EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}] Current value is {:.3R} m3/s/W",
-                                           HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           VolFlowperRatedTotCap));
+                        std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}] Current value is {:.3f} m3/s/W",
+                                    HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    HVAC::MaxCoolVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    VolFlowperRatedTotCap));
                     ShowContinueError(state, "Possible causes include inconsistent air flow rates in system components or");
                     ShowContinueError(state, "inconsistent supply air fan operation modes in coil and unitary system objects.");
                 }
@@ -13519,8 +13498,7 @@ void CalcMultiSpeedDXCoilCooling(EnergyPlusData &state,
             if (fanOp == HVAC::FanOp::Cycling && CycRatio == 1.0 && PLF != 1.0) {
                 if (thisDXCoil.PLFErrIndex == 0) {
                     ShowWarningMessage(
-                        state,
-                        EnergyPlus::format("The PLF curve value for DX cooling coil {} ={:.2R} for part-load ratio = 1", thisDXCoil.Name, PLF));
+                        state, std::format("The PLF curve value for DX cooling coil {} ={:.2f} for part-load ratio = 1", thisDXCoil.Name, PLF));
                     ShowContinueError(state, "PLF curve value must be = 1.0 and has been reset to 1.0. Simulation is continuing.");
                     ShowContinueErrorTimeStamp(state, "");
                 }
@@ -13854,19 +13832,18 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
             ShowContinueErrorTimeStamp(state, "");
             ShowContinueError(
                 state,
-                EnergyPlus::format("AirMassFlow={:.3R},CycRatio={:.3R},SpeedNum={:.0R}, MSHPMassFlowRateLow={:.3R}, MSHPMassFlowRateHigh={:.3R}",
-                                   AirMassFlow,
-                                   double(SpeedNum),
-                                   CycRatio,
-                                   MSHPMassFlowRateLow,
-                                   MSHPMassFlowRateHigh));
+                std::format("AirMassFlow={:.3f},CycRatio={:.3f},SpeedNum={:.0f}, MSHPMassFlowRateLow={:.3f}, MSHPMassFlowRateHigh={:.3f}",
+                            AirMassFlow,
+                            double(SpeedNum),
+                            CycRatio,
+                            MSHPMassFlowRateLow,
+                            MSHPMassFlowRateHigh));
             ShowFatalError(state, "Preceding condition(s) causes termination.");
         } else {
             ShowContinueError(state, "When AirMassFlow > 0.0 and CycRatio > 0.0, then MSHPMassFlowRateHigh must also be > 0.0");
             ShowContinueErrorTimeStamp(state, "");
             ShowContinueError(
-                state,
-                EnergyPlus::format("AirMassFlow={:.3R},CycRatio={:.3R}, MSHPMassFlowRateHigh={:.3R}", AirMassFlow, CycRatio, MSHPMassFlowRateHigh));
+                state, std::format("AirMassFlow={:.3f},CycRatio={:.3f}, MSHPMassFlowRateHigh={:.3f}", AirMassFlow, CycRatio, MSHPMassFlowRateHigh));
             ShowFatalError(state, "Preceding condition(s) causes termination.");
         }
     } else if (CycRatio > 1.0 || SpeedRatio > 1.0) {
@@ -13876,7 +13853,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                                     thisDXCoil.Name));
         ShowContinueError(state, "CycRatio and SpeedRatio must be between 0.0 and 1.0");
         ShowContinueErrorTimeStamp(state, "");
-        ShowContinueError(state, EnergyPlus::format("CycRatio={:.1R}, SpeedRatio = {:.1R}", CycRatio, SpeedRatio));
+        ShowContinueError(state, std::format("CycRatio={:.1f}, SpeedRatio = {:.1f}", CycRatio, SpeedRatio));
         ShowFatalError(state, "Preceding condition(s) causes termination.");
     }
 
@@ -13959,10 +13936,10 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                     ShowContinueErrorTimeStamp(state, "");
                     ShowContinueError(
                         state,
-                        EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}] Current value is {:.3R} m3/s/W",
-                                           HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           VolFlowperRatedTotCap));
+                        std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}] Current value is {:.3f} m3/s/W",
+                                    HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    VolFlowperRatedTotCap));
                     ShowContinueError(state, "Possible causes include inconsistent air flow rates in system components or");
                     ShowContinueError(state, "inconsistent supply air fan operation modes in coil and unitary system objects.");
                 }
@@ -13995,10 +13972,10 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                     ShowContinueErrorTimeStamp(state, "");
                     ShowContinueError(
                         state,
-                        EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}] Current value is {:.3R} m3/s/W",
-                                           HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           VolFlowperRatedTotCap));
+                        std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}] Current value is {:.3f} m3/s/W",
+                                    HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    VolFlowperRatedTotCap));
                     ShowContinueError(state, "Possible causes include inconsistent air flow rates in system components or");
                     ShowContinueError(state, "inconsistent supply air fan operation modes in coil and unitary system objects.");
                 }
@@ -14143,10 +14120,10 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                 if (thisDXCoil.PLRErrIndex == 0) {
                     ShowWarningMessage(
                         state,
-                        EnergyPlus::format("The PLF curve value at high speed for DX multispeed heating coil {} ={:.2R} for part-load ratio ={:.2R}",
-                                           thisDXCoil.Name,
-                                           PLF,
-                                           PLRHeating));
+                        std::format("The PLF curve value at high speed for DX multispeed heating coil {} ={:.2f} for part-load ratio ={:.2f}",
+                                    thisDXCoil.Name,
+                                    PLF,
+                                    PLRHeating));
                     ShowContinueError(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and simulation is continuing.");
                     ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:DX:MultiSpeed].");
                     ShowContinueErrorTimeStamp(state, "");
@@ -14158,11 +14135,10 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
             thisDXCoil.HeatingCoilRuntimeFraction = (PLRHeating / PLF);
             if (thisDXCoil.HeatingCoilRuntimeFraction > 1.0 && std::abs(thisDXCoil.HeatingCoilRuntimeFraction - 1.0) > 0.001) {
                 if (thisDXCoil.ErrIndex4 == 0) {
-                    ShowWarningMessage(
-                        state,
-                        EnergyPlus::format("The runtime fraction at high speed for DX multispeed heating coil {} exceeded 1.0. [{:.4R}].",
-                                           thisDXCoil.Name,
-                                           thisDXCoil.HeatingCoilRuntimeFraction));
+                    ShowWarningMessage(state,
+                                       std::format("The runtime fraction at high speed for DX multispeed heating coil {} exceeded 1.0. [{:.4f}].",
+                                                   thisDXCoil.Name,
+                                                   thisDXCoil.HeatingCoilRuntimeFraction));
                     ShowContinueError(state, "Runtime fraction is set to 1.0 and the simulation continues...");
                     ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:DX:SingleSpeed].");
                     ShowContinueErrorTimeStamp(state, "");
@@ -14278,10 +14254,10 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                     ShowContinueErrorTimeStamp(state, "");
                     ShowContinueError(
                         state,
-                        EnergyPlus::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3R}--{:.3R}] Current value is {:.3R} m3/s/W",
-                                           HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
-                                           VolFlowperRatedTotCap));
+                        std::format("Expected range for VolumeFlowPerRatedTotalCapacity=[{:.3f}--{:.3f}] Current value is {:.3f} m3/s/W",
+                                    HVAC::MinOperVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    HVAC::MaxHeatVolFlowPerRatedTotCap[(int)state.dataHVACGlobal->DXCT],
+                                    VolFlowperRatedTotCap));
                     ShowContinueError(state, "Possible causes include inconsistent air flow rates in system components or");
                     ShowContinueError(state, "inconsistent supply air fan operation modes in coil and unitary system objects.");
                 }
@@ -14417,8 +14393,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
             if (fanOp == HVAC::FanOp::Cycling && CycRatio == 1.0 && PLF != 1.0) {
                 if (thisDXCoil.PLFErrIndex == 0) {
                     ShowWarningMessage(
-                        state,
-                        EnergyPlus::format("The PLF curve value for DX heating coil {} ={:.2R} for part-load ratio = 1", thisDXCoil.Name, PLF));
+                        state, std::format("The PLF curve value for DX heating coil {} ={:.2f} for part-load ratio = 1", thisDXCoil.Name, PLF));
                     ShowContinueError(state, "PLF curve value must be = 1.0 and has been reset to 1.0. Simulation is continuing.");
                     ShowContinueErrorTimeStamp(state, "");
                 }
@@ -14432,7 +14407,7 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
                     ShowWarningMessage(
                         state,
                         EnergyPlus::format(
-                            "The PLF curve value for DX heating coil {} ={:.2R} for part-load ratio ={:.2R}", thisDXCoil.Name, PLF, PLRHeating));
+                            "The PLF curve value for DX heating coil {} ={:.2f} for part-load ratio ={:.2f}", thisDXCoil.Name, PLF, PLRHeating));
                     ShowContinueError(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and simulation is continuing.");
                     ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:DX:SingleSpeed].");
                     ShowContinueErrorTimeStamp(state, "");
@@ -14445,9 +14420,9 @@ void CalcMultiSpeedDXCoilHeating(EnergyPlusData &state,
             if (thisDXCoil.HeatingCoilRuntimeFraction > 1.0 && std::abs(thisDXCoil.HeatingCoilRuntimeFraction - 1.0) > 0.001) {
                 if (thisDXCoil.ErrIndex4 == 0) {
                     ShowWarningMessage(state,
-                                       EnergyPlus::format("The runtime fraction for DX heating coil {} exceeded 1.0. [{:.4R}].",
-                                                          thisDXCoil.Name,
-                                                          thisDXCoil.HeatingCoilRuntimeFraction));
+                                       std::format("The runtime fraction for DX heating coil {} exceeded 1.0. [{:.4f}].",
+                                                   thisDXCoil.Name,
+                                                   thisDXCoil.HeatingCoilRuntimeFraction));
                     ShowContinueError(state, "Runtime fraction is set to 1.0 and the simulation continues...");
                     ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:DX:SingleSpeed].");
                     ShowContinueErrorTimeStamp(state, "");
@@ -14818,7 +14793,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
 
     static constexpr std::string_view Format_891{
         " VAV DX Cooling Coil Standard Rating Information, "
-        "{},{},{},{},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.2R},{:.4R},{:.4R},{:.4R},{:.4R},\n"};
+        "{},{},{},{},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.2f},{:.4f},{:.4f},{:.4f},{:.4f},\n"};
 
     auto &thisDXCoil = state.dataDXCoils->DXCoil(DXCoilNum);
 
@@ -15332,7 +15307,7 @@ void CalcTwoSpeedDXCoilStandardRating(EnergyPlusData &state, int const DXCoilNum
         print(state.files.eio, "{}\n", Format_994);
         state.dataHVACGlobal->StandardRatingsMyCoolOneTimeFlag = false;
     }
-    static constexpr std::string_view Format_995(" DX Cooling Coil Standard Rating Information, {}, {}, {:.1R}, {}, {}, {}, {}, {}\n");
+    static constexpr std::string_view Format_995(" DX Cooling Coil Standard Rating Information, {}, {}, {:.1f}, {}, {}, {}, {}, {}\n");
     print(state.files.eio,
           Format_995,
           "Coil:Cooling:DX:TwoSpeed",
@@ -17287,7 +17262,7 @@ void CalcVRFCoolingCoil_FluidTCtrl(EnergyPlusData &state,
                 ShowWarningMessage(
                     state,
                     EnergyPlus::format(
-                        "The PLF curve value for the DX cooling coil {} ={:.3R} for part-load ratio ={:.3R}", thisDXCoil.Name, PLF, PartLoadRatio));
+                        "The PLF curve value for the DX cooling coil {} ={:.3f} for part-load ratio ={:.3f}", thisDXCoil.Name, PLF, PartLoadRatio));
                 ShowContinueErrorTimeStamp(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and simulation is continuing.");
                 ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Cooling:DX:SingleSpeed].");
             }
@@ -17301,9 +17276,9 @@ void CalcVRFCoolingCoil_FluidTCtrl(EnergyPlusData &state,
         if (thisDXCoil.CoolingCoilRuntimeFraction > 1.0 && std::abs(thisDXCoil.CoolingCoilRuntimeFraction - 1.0) > 0.001) {
             if (thisDXCoil.ErrIndex3 == 0) {
                 ShowWarningMessage(state,
-                                   EnergyPlus::format("The runtime fraction for DX cooling coil {} exceeded 1.0. [{:.4R}].",
-                                                      thisDXCoil.Name,
-                                                      thisDXCoil.CoolingCoilRuntimeFraction));
+                                   std::format("The runtime fraction for DX cooling coil {} exceeded 1.0. [{:.4f}].",
+                                               thisDXCoil.Name,
+                                               thisDXCoil.CoolingCoilRuntimeFraction));
                 ShowContinueError(state, "Runtime fraction reset to 1 and the simulation will continue.");
                 ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Cooling:DX:SingleSpeed].");
                 ShowContinueErrorTimeStamp(state, "");
@@ -17343,7 +17318,7 @@ void CalcVRFCoolingCoil_FluidTCtrl(EnergyPlusData &state,
             if (thisDXCoil.LowOutletTempIndex == 0) {
                 thisDXCoil.FullLoadInletAirTempLast = InletAirDryBulbTemp;
                 thisDXCoil.LowOutTempBuffer1 = EnergyPlus::format("{} \"{}\" - Full load outlet air dry-bulb temperature < 2C. This indicates the "
-                                                                  "possibility of coil frost/freeze. Outlet temperature = {:.2R} C.",
+                                                                  "possibility of coil frost/freeze. Outlet temperature = {:.2f} C.",
                                                                   HVAC::coilTypeNames[(int)thisDXCoil.coilType],
                                                                   thisDXCoil.Name,
                                                                   OutletAirTemp);
@@ -17624,7 +17599,7 @@ void CalcVRFHeatingCoil_FluidTCtrl(EnergyPlusData &state,
                 ShowWarningMessage(
                     state,
                     EnergyPlus::format(
-                        "The PLF curve value for DX heating coil {} ={:.2R} for part-load ratio ={:.2R}", thisDXCoil.Name, PLF, PLRHeating));
+                        "The PLF curve value for DX heating coil {} ={:.2f} for part-load ratio ={:.2f}", thisDXCoil.Name, PLF, PLRHeating));
                 ShowContinueError(state, "PLF curve values must be >= 0.7. PLF has been reset to 0.7 and simulation is continuing.");
                 ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:DX:SingleSpeed].");
                 ShowContinueErrorTimeStamp(state, "");
@@ -17637,9 +17612,9 @@ void CalcVRFHeatingCoil_FluidTCtrl(EnergyPlusData &state,
         if (thisDXCoil.HeatingCoilRuntimeFraction > 1.0 && std::abs(thisDXCoil.HeatingCoilRuntimeFraction - 1.0) > 0.001) {
             if (thisDXCoil.ErrIndex4 == 0) {
                 ShowWarningMessage(state,
-                                   EnergyPlus::format("The runtime fraction for DX heating coil {} exceeded 1.0. [{:.4R}].",
-                                                      thisDXCoil.Name,
-                                                      thisDXCoil.HeatingCoilRuntimeFraction));
+                                   std::format("The runtime fraction for DX heating coil {} exceeded 1.0. [{:.4f}].",
+                                               thisDXCoil.Name,
+                                               thisDXCoil.HeatingCoilRuntimeFraction));
                 ShowContinueError(state, "Runtime fraction is set to 1.0 and the simulation continues...");
                 ShowContinueError(state, "Check the IO reference manual for PLF curve guidance [Coil:Heating:DX:SingleSpeed].");
                 ShowContinueErrorTimeStamp(state, "");
diff --git a/src/EnergyPlus/DXFEarClipping.cc b/src/EnergyPlus/DXFEarClipping.cc
index 1fbc12e937e..b51145c8ed0 100644
--- a/src/EnergyPlus/DXFEarClipping.cc
+++ b/src/EnergyPlus/DXFEarClipping.cc
@@ -250,11 +250,11 @@ namespace DXFEarClipping {
                     ShowMessage(state, EnergyPlus::format(" surface={} class={}", surfname, DataSurfaces::cSurfaceClass(surfclass)));
 
                     for (int j = 1; j <= nsides; ++j) {
-                        ShowMessage(state, EnergyPlus::format(" side={} ({:.1R},{:.1R},{:.1R})", j, polygon(j).x, polygon(j).y, polygon(j).z));
+                        ShowMessage(state, std::format(" side={} ({:.1f},{:.1f},{:.1f})", j, polygon(j).x, polygon(j).y, polygon(j).z));
                     }
                     ShowMessage(state, EnergyPlus::format(" number of triangles found={:12}", ncount));
                     for (int j = 1; j <= nrangles; ++j) {
-                        ShowMessage(state, EnergyPlus::format(" r angle={} vert={} deg={:.1R}", j, r_angles(j), rangles(j) * Constant::RadToDeg));
+                        ShowMessage(state, std::format(" r angle={} vert={} deg={:.1f}", j, r_angles(j), rangles(j) * Constant::RadToDeg));
                     }
                 }
                 break; // while loop
diff --git a/src/EnergyPlus/DataEnvironment.cc b/src/EnergyPlus/DataEnvironment.cc
index 6c530cd44de..7a943278c74 100644
--- a/src/EnergyPlus/DataEnvironment.cc
+++ b/src/EnergyPlus/DataEnvironment.cc
@@ -109,7 +109,7 @@ Real64 OutDryBulbTempAt(EnergyPlusData &state, Real64 const Z) // Height above g
 
     if (LocalOutDryBulbTemp < -100.0) {
         ShowSevereError(state, "OutDryBulbTempAt: outdoor drybulb temperature < -100 C");
-        ShowContinueError(state, EnergyPlus::format("...check heights, this height=[{:.0R}].", Z));
+        ShowContinueError(state, std::format("...check heights, this height=[{:.0f}].", Z));
         ShowFatalError(state, "Program terminates due to preceding condition(s).");
     }
 
@@ -152,7 +152,7 @@ Real64 OutWetBulbTempAt(EnergyPlusData &state, Real64 const Z) // Height above g
 
     if (LocalOutWetBulbTemp < -100.0) {
         ShowSevereError(state, "OutWetBulbTempAt: outdoor wetbulb temperature < -100 C");
-        ShowContinueError(state, EnergyPlus::format("...check heights, this height=[{:.0R}].", Z));
+        ShowContinueError(state, std::format("...check heights, this height=[{:.0f}].", Z));
         ShowFatalError(state, "Program terminates due to preceding condition(s).");
     }
 
@@ -238,7 +238,7 @@ void SetOutBulbTempAt_error(EnergyPlusData &state, std::string const &Settings,
     // Using/Aliasing
 
     ShowSevereError(state, EnergyPlus::format("SetOutBulbTempAt: {} Outdoor Temperatures < -100 C", Settings));
-    ShowContinueError(state, EnergyPlus::format("...check {} Heights - Maximum {} Height=[{:.0R}].", Settings, Settings, max_height));
+    ShowContinueError(state, std::format("...check {} Heights - Maximum {} Height=[{:.0f}].", Settings, Settings, max_height));
     if (max_height >= 20000.0) {
         ShowContinueError(state, "...according to your maximum Z height, your building is somewhere in the Stratosphere.");
         ShowContinueError(state, EnergyPlus::format("...look at {} Name= {}", Settings, SettingsName));
diff --git a/src/EnergyPlus/DataSizing.cc b/src/EnergyPlus/DataSizing.cc
index 3d965c654fa..cb8f5b27f55 100644
--- a/src/EnergyPlus/DataSizing.cc
+++ b/src/EnergyPlus/DataSizing.cc
@@ -1241,7 +1241,7 @@ OARequirementsData::calcOAFlowRate(EnergyPlusData &state,
                                         state,
                                         EnergyPlus::format(
                                             "For System Outdoor Air Method = ProportionalControlBasedOnOccupancySchedule, maximum target "
-                                            "CO2 concentration ({:.2R}), is not greater than minimum target CO2 concentration ({:.2R}).",
+                                            "CO2 concentration ({:.2f}), is not greater than minimum target CO2 concentration ({:.2f}).",
                                             ZoneMaxCO2,
                                             ZoneMinCO2));
                                     ShowContinueError(state,
@@ -1268,7 +1268,7 @@ OARequirementsData::calcOAFlowRate(EnergyPlusData &state,
                                         state,
                                         EnergyPlus::format(
                                             "For System Outdoor Air Method = ProportionalControlBasedOnDesignOccupancy, maximum target "
-                                            "CO2 concentration ({:.2R}), is not greater than minimum target CO2 concentration ({:.2R}).",
+                                            "CO2 concentration ({:.2f}), is not greater than minimum target CO2 concentration ({:.2f}).",
                                             ZoneMaxCO2,
                                             ZoneMinCO2));
                                     ShowContinueError(state,
diff --git a/src/EnergyPlus/DataSurfaceLists.cc b/src/EnergyPlus/DataSurfaceLists.cc
index 8744806d4c7..8ed2fc17c8c 100644
--- a/src/EnergyPlus/DataSurfaceLists.cc
+++ b/src/EnergyPlus/DataSurfaceLists.cc
@@ -188,9 +188,9 @@ void GetSurfaceListsInputs(EnergyPlusData &state)
                                                            SurfList(Item).SurfName(SurfNum),
                                                            SurfList(Item).Name));
                         ShowContinueError(state,
-                                          EnergyPlus::format("Flow fraction of {:.6R} is less than minimum criteria = {:.6R}",
-                                                             SurfList(Item).SurfFlowFrac(SurfNum),
-                                                             SurfListMinFlowFrac));
+                                          std::format("Flow fraction of {:.6f} is less than minimum criteria = {:.6f}",
+                                                      SurfList(Item).SurfFlowFrac(SurfNum),
+                                                      SurfListMinFlowFrac));
                         ShowContinueError(state,
                                           "Zero or extremely low flow fractions are not allowed. Remove this surface from the surface group or "
                                           "combine small surfaces together.");
diff --git a/src/EnergyPlus/DaylightingDevices.cc b/src/EnergyPlus/DaylightingDevices.cc
index 68d55908662..f8b13e7cf15 100644
--- a/src/EnergyPlus/DaylightingDevices.cc
+++ b/src/EnergyPlus/DaylightingDevices.cc
@@ -406,7 +406,7 @@ namespace Dayltg {
                     state.dataDaylightingDevices->ShelfReported = true;
                 }
                 print(state.files.eio,
-                      "Shelf Details,{},{:.2R},{},{:.2R},{:.2R}\n",
+                      "Shelf Details,{},{:.2f},{},{:.2f},{:.2f}\n",
                       state.dataDaylightingDevicesData->Shelf(ShelfNum).Name,
                       state.dataDaylightingDevicesData->Shelf(ShelfNum).ViewFactor,
                       state.dataSurface->Surface(WinSurf).Name,
@@ -589,10 +589,9 @@ namespace Dayltg {
                                                            ipsc->cAlphaArgs(1),
                                                            ipsc->cAlphaArgs(3),
                                                            state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).Name));
-                        ShowContinueError(
-                            state,
-                            EnergyPlus::format("Diffuse solar transmittance of construction [{:.4R}] too small for calculations.",
-                                               state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TransDiff));
+                        ShowContinueError(state,
+                                          std::format("Diffuse solar transmittance of construction [{:.4f}] too small for calculations.",
+                                                      state.dataConstruction->Construct(state.dataSurface->Surface(SurfNum).Construction).TransDiff));
                         state.dataDaylightingDevices->GetTDDInputErrorsFound = true;
                     }
 
@@ -607,21 +606,19 @@ namespace Dayltg {
                                             EnergyPlus::format("{} = {}:  Dome and diffuser areas are significantly different (>10%).",
                                                                cCurrentModuleObject,
                                                                ipsc->cAlphaArgs(1)));
-                            ShowContinueError(
-                                state,
-                                EnergyPlus::format("...Diffuser Area=[{:.4R}]; Dome Area=[{:.4R}].",
-                                                   state.dataSurface->Surface(SurfNum).Area,
-                                                   state.dataSurface->Surface(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome).Area));
+                            ShowContinueError(state,
+                                              std::format("...Diffuser Area=[{:.4f}]; Dome Area=[{:.4f}].",
+                                                          state.dataSurface->Surface(SurfNum).Area,
+                                                          state.dataSurface->Surface(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome).Area));
                             state.dataDaylightingDevices->GetTDDInputErrorsFound = true;
                         } else {
                             ShowWarningError(state,
                                              EnergyPlus::format(
                                                  "{} = {}:  Dome and diffuser areas differ by > .1 m2.", cCurrentModuleObject, ipsc->cAlphaArgs(1)));
-                            ShowContinueError(
-                                state,
-                                EnergyPlus::format("...Diffuser Area=[{:.4R}]; Dome Area=[{:.4R}].",
-                                                   state.dataSurface->Surface(SurfNum).Area,
-                                                   state.dataSurface->Surface(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome).Area));
+                            ShowContinueError(state,
+                                              std::format("...Diffuser Area=[{:.4f}]; Dome Area=[{:.4f}].",
+                                                          state.dataSurface->Surface(SurfNum).Area,
+                                                          state.dataSurface->Surface(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome).Area));
                         }
                     }
 
@@ -689,21 +686,19 @@ namespace Dayltg {
                                         std::format("{} = {}:  Pipe and dome/diffuser areas are significantly different (>10%).",
                                                     cCurrentModuleObject,
                                                     ipsc->cAlphaArgs(1)));
-                        ShowContinueError(
-                            state,
-                            EnergyPlus::format("...Pipe Area=[{:.4R}]; Dome/Diffuser Area=[{:.4R}].",
-                                               PipeArea,
-                                               state.dataSurface->Surface(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome).Area));
+                        ShowContinueError(state,
+                                          std::format("...Pipe Area=[{:.4f}]; Dome/Diffuser Area=[{:.4f}].",
+                                                      PipeArea,
+                                                      state.dataSurface->Surface(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome).Area));
                         state.dataDaylightingDevices->GetTDDInputErrorsFound = true;
                     } else {
                         ShowWarningError(
                             state,
                             std::format("{} = {}:  Pipe and dome/diffuser areas differ by > .1 m2.", cCurrentModuleObject, ipsc->cAlphaArgs(1)));
-                        ShowContinueError(
-                            state,
-                            EnergyPlus::format("...Pipe Area=[{:.4R}]; Dome/Diffuser Area=[{:.4R}].",
-                                               PipeArea,
-                                               state.dataSurface->Surface(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome).Area));
+                        ShowContinueError(state,
+                                          std::format("...Pipe Area=[{:.4f}]; Dome/Diffuser Area=[{:.4f}].",
+                                                      PipeArea,
+                                                      state.dataSurface->Surface(state.dataDaylightingDevicesData->TDDPipe(PipeNum).Dome).Area));
                     }
                 }
 
@@ -1715,9 +1710,9 @@ namespace Dayltg {
         // Now correct the view factors based on the location of the shelf with respect to the window
         ShowWarningError(
             state,
-            EnergyPlus::format("DaylightingDevice:Shelf = {}:  Window view factor to shelf [{:.2R}] results in a sum of view factors greater than 1.",
-                               state.dataDaylightingDevicesData->Shelf(ShelfNum).Name,
-                               state.dataDaylightingDevicesData->Shelf(ShelfNum).ViewFactor));
+            std::format("DaylightingDevice:Shelf = {}:  Window view factor to shelf [{:.2f}] results in a sum of view factors greater than 1.",
+                        state.dataDaylightingDevicesData->Shelf(ShelfNum).Name,
+                        state.dataDaylightingDevicesData->Shelf(ShelfNum).ViewFactor));
         if (zWinMin >= zShelfMax) { // Shelf is fully below window, reduce view to ground first based on view to shelf
             ShowContinueError(
                 state,
diff --git a/src/EnergyPlus/DaylightingManager.cc b/src/EnergyPlus/DaylightingManager.cc
index fd59eff02b4..b30859573b3 100644
--- a/src/EnergyPlus/DaylightingManager.cc
+++ b/src/EnergyPlus/DaylightingManager.cc
@@ -545,7 +545,7 @@ void CalcDayltgCoefficients(EnergyPlusData &state)
                     for (int refPtNum = 1; refPtNum <= thisDayltgCtrl.TotalDaylRefPoints; ++refPtNum) {
                         Real64 DaylFac = thisDayltgCtrl.daylFac[12](windowCounter, refPtNum)[iWinCover_Bare][iLum_Illum].sky[iSky];
                         print(state.files.eio,
-                              " Sky Daylight Factors,{},{},{},{},{},{},{:.4R}\n",
+                              " Sky Daylight Factors,{},{},{},{},{},{},{:.4f}\n",
                               skyTypeStrings[iSky],
                               state.dataEnvrn->CurMnDy,
                               thisDayltgCtrl.Name,
@@ -653,7 +653,7 @@ void CalcDayltgCoefficients(EnergyPlusData &state)
 
                             // write daylight factors - 4 sky types for each daylight ref point
                             print(state.files.dfs,
-                                  "{},{},{:.5R},{:.5R},{:.5R},{:.5R}\n",
+                                  "{},{},{:.5f},{:.5f},{:.5f},{:.5f}\n",
                                   IHR,
                                   dl->DaylRefPt(thisDayltgCtrl.refPts(refPtNum).num).Name,
                                   illums.sky[(int)SkyType::Clear],
@@ -1640,7 +1640,7 @@ void FigureDayltgCoeffsAtPointsSetupForWindow(EnergyPlusData &state,
                         dl->daylightControl(daylightCtrlNum).Name,
                         iRefPoint,
                         surf.Name));
-                ShowContinueError(state, EnergyPlus::format("Distance=[{:.5R}]. This is too close; check position of reference point.", ALF));
+                ShowContinueError(state, std::format("Distance=[{:.5f}]. This is too close; check position of reference point.", ALF));
                 ShowFatalError(state, "Program terminates due to preceding condition.");
             }
         } else if (ALF < 0.1524 && extWinType == ExtWinType::AdjZone) {
@@ -1652,13 +1652,12 @@ void FigureDayltgCoeffsAtPointsSetupForWindow(EnergyPlusData &state,
                                        dl->daylightControl(daylightCtrlNum).Name,
                                        surf.Name,
                                        state.dataHeatBal->Zone(surf.Zone).Name));
-                ShowContinueError(
-                    state,
-                    EnergyPlus::format("Distance=[{:.1R} m] to ref point=[{:.1R},{:.1R},{:.1R}], Inaccuracy in Daylighting Calcs may result.",
-                                       ALF,
-                                       RREF.x,
-                                       RREF.y,
-                                       RREF.z));
+                ShowContinueError(state,
+                                  std::format("Distance=[{:.1f} m] to ref point=[{:.1f},{:.1f},{:.1f}], Inaccuracy in Daylighting Calcs may result.",
+                                              ALF,
+                                              RREF.x,
+                                              RREF.y,
+                                              RREF.z));
                 dl->RefErrIndex(iRefPoint, IWin) = 1;
             }
         }
@@ -1675,7 +1674,7 @@ void FigureDayltgCoeffsAtPointsSetupForWindow(EnergyPlusData &state,
                 ShowContinueError(
                     state,
                     EnergyPlus::format(
-                        "Distance=[{:.1R} m] map point=[{:.1R},{:.1R},{:.1R}], Inaccuracy in Map Calcs may result.", ALF, RREF.x, RREF.y, RREF.z));
+                        "Distance=[{:.1f} m] map point=[{:.1f},{:.1f},{:.1f}], Inaccuracy in Map Calcs may result.", ALF, RREF.x, RREF.y, RREF.z));
                 dl->MapErrIndex(iRefPoint, IWin) = 1;
             }
         }
@@ -4206,11 +4205,11 @@ void GetInputIlluminanceMap(EnergyPlusData &state, bool &ErrorsFound)
             if (s_ipsc->rNumericArgs(2) > s_ipsc->rNumericArgs(3)) {
                 ShowSevereError(state, std::format("{}=\"{}\", invalid entry.", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                 ShowContinueError(state,
-                                  EnergyPlus::format("...{} {:.2R} must be <= {} {:.2R}.",
-                                                     s_ipsc->cNumericFieldNames(2),
-                                                     s_ipsc->rNumericArgs(2),
-                                                     s_ipsc->cNumericFieldNames(3),
-                                                     s_ipsc->rNumericArgs(3)));
+                                  std::format("...{} {:.2f} must be <= {} {:.2f}.",
+                                              s_ipsc->cNumericFieldNames(2),
+                                              s_ipsc->rNumericArgs(2),
+                                              s_ipsc->cNumericFieldNames(3),
+                                              s_ipsc->rNumericArgs(3)));
                 ErrorsFound = true;
             }
             illumMap.Xnum = s_ipsc->rNumericArgs(4);
@@ -4221,11 +4220,11 @@ void GetInputIlluminanceMap(EnergyPlusData &state, bool &ErrorsFound)
             if (s_ipsc->rNumericArgs(5) > s_ipsc->rNumericArgs(6)) {
                 ShowSevereError(state, std::format("{}=\"{}\", invalid entry.", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaArgs(1)));
                 ShowContinueError(state,
-                                  EnergyPlus::format("...{} {:.2R} must be <= {} {:.2R}.",
-                                                     s_ipsc->cNumericFieldNames(5),
-                                                     s_ipsc->rNumericArgs(5),
-                                                     s_ipsc->cNumericFieldNames(6),
-                                                     s_ipsc->rNumericArgs(6)));
+                                  std::format("...{} {:.2f} must be <= {} {:.2f}.",
+                                              s_ipsc->cNumericFieldNames(5),
+                                              s_ipsc->rNumericArgs(5),
+                                              s_ipsc->cNumericFieldNames(6),
+                                              s_ipsc->rNumericArgs(6)));
                 ErrorsFound = true;
             }
             illumMap.Ynum = s_ipsc->rNumericArgs(7);
@@ -4400,42 +4399,42 @@ void GetInputIlluminanceMap(EnergyPlusData &state, bool &ErrorsFound)
                         state,
                         std::format("GetInputIlluminanceMap: Reference Map point #[{}], X Value outside Zone Min/Max X, Zone={}", iRefPt, zone.Name));
                     ShowContinueError(state,
-                                      EnergyPlus::format("...X Reference Point= {:.2R}, Zone Minimum X= {:.2R}, Zone Maximum X= {:.2R}",
-                                                         refPt.absCoords.x,
-                                                         zone.MinimumX,
-                                                         zone.MaximumX));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("...X Reference Distance Outside MinimumX= {:.4R} m.",
-                                                         (refPt.absCoords.x < zone.MinimumX) ? (zone.MinimumX - refPt.absCoords.x)
-                                                                                             : (refPt.absCoords.x - zone.MaximumX)));
+                                      std::format("...X Reference Point= {:.2f}, Zone Minimum X= {:.2f}, Zone Maximum X= {:.2f}",
+                                                  refPt.absCoords.x,
+                                                  zone.MinimumX,
+                                                  zone.MaximumX));
+                    ShowContinueError(
+                        state,
+                        std::format("...X Reference Distance Outside MinimumX= {:.4f} m.",
+                                    (refPt.absCoords.x < zone.MinimumX) ? (zone.MinimumX - refPt.absCoords.x) : (refPt.absCoords.x - zone.MaximumX)));
                 }
                 if (refPt.absCoords.y < zone.MinimumY || refPt.absCoords.y > zone.MaximumY) {
                     ShowWarningError(
                         state,
                         std::format("GetInputIlluminanceMap: Reference Map point #[{}], Y Value outside Zone Min/Max Y, Zone={}", iRefPt, zone.Name));
                     ShowContinueError(state,
-                                      EnergyPlus::format("...Y Reference Point= {:.2R}, Zone Minimum Y= {:.2R}, Zone Maximum Y= {:.2R}",
-                                                         refPt.absCoords.y,
-                                                         zone.MinimumY,
-                                                         zone.MaximumY));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("...Y Reference Distance Outside MinimumY= {:.4R} m.",
-                                                         (refPt.absCoords.y < zone.MinimumY) ? (zone.MinimumY - refPt.absCoords.y)
-                                                                                             : (refPt.absCoords.y - zone.MaximumY)));
+                                      std::format("...Y Reference Point= {:.2f}, Zone Minimum Y= {:.2f}, Zone Maximum Y= {:.2f}",
+                                                  refPt.absCoords.y,
+                                                  zone.MinimumY,
+                                                  zone.MaximumY));
+                    ShowContinueError(
+                        state,
+                        std::format("...Y Reference Distance Outside MinimumY= {:.4f} m.",
+                                    (refPt.absCoords.y < zone.MinimumY) ? (zone.MinimumY - refPt.absCoords.y) : (refPt.absCoords.y - zone.MaximumY)));
                 }
                 if (refPt.absCoords.z < zone.MinimumZ || refPt.absCoords.z > zone.MaximumZ) {
                     ShowWarningError(
                         state,
                         std::format("GetInputIlluminanceMap: Reference Map point #[{}], Z Value outside Zone Min/Max Z, Zone={}", iRefPt, zone.Name));
                     ShowContinueError(state,
-                                      EnergyPlus::format("...Z Reference Point= {:.2R}, Zone Minimum Z= {:.2R}, Zone Maximum Z= {:.2R}",
-                                                         refPt.absCoords.z,
-                                                         zone.MinimumZ,
-                                                         zone.MaximumZ));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("...Z Reference Distance Outside MinimumZ= {:.4R} m.",
-                                                         (refPt.absCoords.z < zone.MinimumZ) ? (zone.MinimumZ - refPt.absCoords.z)
-                                                                                             : (refPt.absCoords.z - zone.MaximumZ)));
+                                      std::format("...Z Reference Point= {:.2f}, Zone Minimum Z= {:.2f}, Zone Maximum Z= {:.2f}",
+                                                  refPt.absCoords.z,
+                                                  zone.MinimumZ,
+                                                  zone.MaximumZ));
+                    ShowContinueError(
+                        state,
+                        std::format("...Z Reference Distance Outside MinimumZ= {:.4f} m.",
+                                    (refPt.absCoords.z < zone.MinimumZ) ? (zone.MinimumZ - refPt.absCoords.z) : (refPt.absCoords.z - zone.MaximumZ)));
                 }
             } // for (X)
         } // for (Y)
@@ -4466,7 +4465,7 @@ void GetInputIlluminanceMap(EnergyPlusData &state, bool &ErrorsFound)
     }
     for (auto const &illumMap : dl->illumMaps) {
         print(state.files.eio,
-              "Daylighting:Illuminance Maps:Detail,{},{},{:.2R},{:.2R},{:.2R},{},{:.2R},{:.2R},{:.2R},{},{:.2R}\n",
+              "Daylighting:Illuminance Maps:Detail,{},{},{:.2f},{:.2f},{:.2f},{},{:.2f},{:.2f},{:.2f},{},{:.2f}\n",
               illumMap.Name,
               state.dataHeatBal->Zone(illumMap.zoneIndex).Name,
               illumMap.Xmin,
@@ -4753,17 +4752,17 @@ void GetDaylightingControls(EnergyPlusData &state, bool &ErrorsFound)
         if ((1.0 - sumFracs) > FractionTolerance) {
             ShowWarningError(state, "GetDaylightingControls: Fraction of zone or space controlled by the Daylighting reference points is < 1.0.");
             ShowContinueError(state,
-                              EnergyPlus::format("..discovered in {}=\"{}\", only {:.3R} of the zone or space is controlled.",
-                                                 s_ipsc->cCurrentModuleObject,
-                                                 daylightControl.Name,
-                                                 sumFracs));
+                              std::format("..discovered in {}=\"{}\", only {:.3f} of the zone or space is controlled.",
+                                          s_ipsc->cCurrentModuleObject,
+                                          daylightControl.Name,
+                                          sumFracs));
         } else if ((sumFracs - 1.0) > FractionTolerance) {
             ShowSevereError(state, "GetDaylightingControls: Fraction of zone or space controlled by the Daylighting reference points is > 1.0.");
             ShowContinueError(state,
-                              EnergyPlus::format("..discovered in {}=\"{}\", trying to control {:.3R} of the zone or space.",
-                                                 s_ipsc->cCurrentModuleObject,
-                                                 daylightControl.Name,
-                                                 sumFracs));
+                              std::format("..discovered in {}=\"{}\", trying to control {:.3f} of the zone or space.",
+                                          s_ipsc->cCurrentModuleObject,
+                                          daylightControl.Name,
+                                          sumFracs));
             ErrorsFound = true;
         }
 
@@ -4871,42 +4870,42 @@ void GeometryTransformForDaylighting(EnergyPlusData &state)
                 ShowWarningError(state,
                                  std::format("GeometryTransformForDaylighting: Reference point X Value outside Zone Min/Max X, Zone={}", zone.Name));
                 ShowContinueError(state,
-                                  EnergyPlus::format("...X Reference Point= {:.2R}, Zone Minimum X= {:.2R}, Zone Maximum X= {:.2R}",
-                                                     refPt.absCoords.x,
-                                                     zone.MinimumX,
-                                                     zone.MaximumX));
-                ShowContinueError(state,
-                                  EnergyPlus::format("...X Reference Distance Outside MinimumX= {:.4R} m.",
-                                                     (refPt.absCoords.x < zone.MinimumX) ? (zone.MinimumX - refPt.absCoords.x)
-                                                                                         : (refPt.absCoords.x - zone.MaximumX)));
+                                  std::format("...X Reference Point= {:.2f}, Zone Minimum X= {:.2f}, Zone Maximum X= {:.2f}",
+                                              refPt.absCoords.x,
+                                              zone.MinimumX,
+                                              zone.MaximumX));
+                ShowContinueError(
+                    state,
+                    std::format("...X Reference Distance Outside MinimumX= {:.4f} m.",
+                                (refPt.absCoords.x < zone.MinimumX) ? (zone.MinimumX - refPt.absCoords.x) : (refPt.absCoords.x - zone.MaximumX)));
             }
             if (refPt.absCoords.y < zone.MinimumY || refPt.absCoords.y > zone.MaximumY) {
                 refPt.inBounds = false;
                 ShowWarningError(state,
                                  std::format("GeometryTransformForDaylighting: Reference point Y Value outside Zone Min/Max Y, Zone={}", zone.Name));
                 ShowContinueError(state,
-                                  EnergyPlus::format("...Y Reference Point= {:.2R}, Zone Minimum Y= {:.2R}, Zone Maximum Y= {:.2R}",
-                                                     refPt.absCoords.x,
-                                                     zone.MinimumY,
-                                                     zone.MaximumY));
-                ShowContinueError(state,
-                                  EnergyPlus::format("...Y Reference Distance Outside MinimumY= {:.4R} m.",
-                                                     (refPt.absCoords.y < zone.MinimumY) ? (zone.MinimumY - refPt.absCoords.y)
-                                                                                         : (refPt.absCoords.y - zone.MaximumY)));
+                                  std::format("...Y Reference Point= {:.2f}, Zone Minimum Y= {:.2f}, Zone Maximum Y= {:.2f}",
+                                              refPt.absCoords.x,
+                                              zone.MinimumY,
+                                              zone.MaximumY));
+                ShowContinueError(
+                    state,
+                    std::format("...Y Reference Distance Outside MinimumY= {:.4f} m.",
+                                (refPt.absCoords.y < zone.MinimumY) ? (zone.MinimumY - refPt.absCoords.y) : (refPt.absCoords.y - zone.MaximumY)));
             }
             if (refPt.absCoords.z < zone.MinimumZ || refPt.absCoords.z > zone.MaximumZ) {
                 refPt.inBounds = false;
                 ShowWarningError(state,
                                  std::format("GeometryTransformForDaylighting: Reference point Z Value outside Zone Min/Max Z, Zone={}", zone.Name));
                 ShowContinueError(state,
-                                  EnergyPlus::format("...Z Reference Point= {:.2R}, Zone Minimum Z= {:.2R}, Zone Maximum Z= {:.2R}",
-                                                     refPt.absCoords.z,
-                                                     zone.MinimumZ,
-                                                     zone.MaximumZ));
-                ShowContinueError(state,
-                                  EnergyPlus::format("...Z Reference Distance Outside MinimumZ= {:.4R} m.",
-                                                     (refPt.absCoords.z < zone.MinimumZ) ? (zone.MinimumZ - refPt.absCoords.z)
-                                                                                         : (refPt.absCoords.z - zone.MaximumZ)));
+                                  std::format("...Z Reference Point= {:.2f}, Zone Minimum Z= {:.2f}, Zone Maximum Z= {:.2f}",
+                                              refPt.absCoords.z,
+                                              zone.MinimumZ,
+                                              zone.MaximumZ));
+                ShowContinueError(
+                    state,
+                    std::format("...Z Reference Distance Outside MinimumZ= {:.4f} m.",
+                                (refPt.absCoords.z < zone.MinimumZ) ? (zone.MinimumZ - refPt.absCoords.z) : (refPt.absCoords.z - zone.MaximumZ)));
             }
         } // for (refPt)
     } // for (daylightCtrl)
@@ -5138,8 +5137,7 @@ void GetLightWellData(EnergyPlusData &state, bool &ErrorsFound) // If errors fou
             ShowSevereError(
                 state,
                 std::format("{}: invalid {}=\"{}\" - Areas.", s_ipsc->cCurrentModuleObject, s_ipsc->cAlphaFieldNames(1), s_ipsc->cAlphaArgs(1)));
-            ShowContinueError(state,
-                              EnergyPlus::format("has Area of Bottom of Well={:.1R} that is less than window area={:.1R}", surf.Area, AreaWell));
+            ShowContinueError(state, std::format("has Area of Bottom of Well={:.1f} that is less than window area={:.1f}", surf.Area, AreaWell));
         }
 
         if (HeightWell >= 0.0 && PerimWell > 0.0 && AreaWell > 0.0) {
@@ -9176,7 +9174,7 @@ void ReportIllumMap(EnergyPlusData &state, int const MapNum)
 
         dl->SavedMnDy(MapNum) = state.dataEnvrn->CurMnDyHr.substr(0, 5);
 
-        illumMap.Name = EnergyPlus::format("{} at {:.2R}m", illumMap.Name, illumMap.Z);
+        illumMap.Name = std::format("{} at {:.2f}m", illumMap.Name, illumMap.Z);
     }
     if (dl->SavedMnDy(MapNum) != state.dataEnvrn->CurMnDyHr.substr(0, 5)) {
         dl->EnvrnPrint(MapNum) = true;
@@ -9193,8 +9191,7 @@ void ReportIllumMap(EnergyPlusData &state, int const MapNum)
         for (int R = 1; R <= thisDayltgCtrl.TotalDaylRefPoints; ++R) {
             ++rCount;
             auto const &refPt = thisDayltgCtrl.refPts(R);
-            illumMap.pointsHeader +=
-                EnergyPlus::format(" RefPt{}=({:.2R}:{:.2R}:{:.2R}),", rCount, refPt.absCoords.x, refPt.absCoords.y, refPt.absCoords.z);
+            illumMap.pointsHeader += std::format(" RefPt{}=({:.2f}:{:.2f}:{:.2f}),", rCount, refPt.absCoords.x, refPt.absCoords.y, refPt.absCoords.z);
         }
     }
 
@@ -9220,7 +9217,7 @@ void ReportIllumMap(EnergyPlusData &state, int const MapNum)
             int RefPt = 1;
             for (int X = 1; X <= illumMap.Xnum; ++X) {
                 const std::string AddXorYString =
-                    EnergyPlus::format("{}({:.2R};{:.2R})=", dl->MapColSep, illumMap.refPts(RefPt).absCoords.x, illumMap.refPts(RefPt).absCoords.y);
+                    std::format("{}({:.2f};{:.2f})=", dl->MapColSep, illumMap.refPts(RefPt).absCoords.x, illumMap.refPts(RefPt).absCoords.y);
                 if (illumMap.HeaderXLineLengthNeeded) {
                     linelen += int(len(AddXorYString));
                 }
@@ -9245,7 +9242,7 @@ void ReportIllumMap(EnergyPlusData &state, int const MapNum)
             // Write Y scale prefix and illuminance values
             RefPt = 1;
             for (int Y = 1; Y <= illumMap.Ynum; ++Y) {
-                mapLine = EnergyPlus::format("({:.2R};{:.2R})=", illumMap.refPts(RefPt).absCoords.x, illumMap.refPts(RefPt).absCoords.y);
+                mapLine = std::format("({:.2f};{:.2f})=", illumMap.refPts(RefPt).absCoords.x, illumMap.refPts(RefPt).absCoords.y);
                 for (int R = RefPt; R <= RefPt + illumMap.Xnum - 1; ++R) {
                     int IllumOut = nint(illumMap.refPts(R).lumsHr[iLum_Illum]);
                     std::string String = fmt::to_string(IllumOut);
diff --git a/src/EnergyPlus/DemandManager.cc b/src/EnergyPlus/DemandManager.cc
index 363d7d3f001..8fcf09acc60 100644
--- a/src/EnergyPlus/DemandManager.cc
+++ b/src/EnergyPlus/DemandManager.cc
@@ -968,7 +968,7 @@ void GetDemandManagerInput(EnergyPlusData &state)
                 ShowContinueError(
                     state,
                     EnergyPlus::format(
-                        "{} [{:.2R}] > {} [{:.2R}]", s_ipsc->cNumericFieldNames(2), NumArray(2), s_ipsc->cNumericFieldNames(3), NumArray(3)));
+                        "{} [{:.2f}] > {} [{:.2f}]", s_ipsc->cNumericFieldNames(2), NumArray(2), s_ipsc->cNumericFieldNames(3), NumArray(3)));
                 ShowContinueError(state,
                                   EnergyPlus::format("{} cannot be greater than {}", s_ipsc->cNumericFieldNames(2), s_ipsc->cNumericFieldNames(3)));
                 ErrorsFound = true;
diff --git a/src/EnergyPlus/DesiccantDehumidifiers.cc b/src/EnergyPlus/DesiccantDehumidifiers.cc
index cae66d11393..4e93619ca6b 100644
--- a/src/EnergyPlus/DesiccantDehumidifiers.cc
+++ b/src/EnergyPlus/DesiccantDehumidifiers.cc
@@ -595,14 +595,12 @@ namespace DesiccantDehumidifiers {
                 }
                 if (desicDehum.NomProcAirVel > 4.064) {
                     ShowWarningError(state, std::format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("{} > 4.064 m/s.; Value in input={:.3R}", cNumericFields(3), desicDehum.NomProcAirVel));
+                    ShowContinueError(state, std::format("{} > 4.064 m/s.; Value in input={:.3f}", cNumericFields(3), desicDehum.NomProcAirVel));
                     ShowContinueError(state, "DEFAULT performance curves not valid outside 2.032 to 4.064 m/s (400 to 800 fpm).");
                 }
                 if (desicDehum.NomProcAirVel < 2.032) {
                     ShowWarningError(state, std::format("{} = {}", CurrentModuleObject, Alphas(1)));
-                    ShowContinueError(state,
-                                      EnergyPlus::format("{} < 2.032 m/s.; Value in input={:.3R}", cNumericFields(3), desicDehum.NomProcAirVel));
+                    ShowContinueError(state, std::format("{} < 2.032 m/s.; Value in input={:.3f}", cNumericFields(3), desicDehum.NomProcAirVel));
                     ShowContinueError(state, "DEFAULT performance curves not valid outside 2.032 to 4.064 m/s (400 to 800 fpm).");
                 }
                 // Validate regen fan type, for default curves, can only variable volume
@@ -861,8 +859,7 @@ namespace DesiccantDehumidifiers {
                     if (RegenCoilControlNodeNum > 0) {
                         ShowSevereError(state, std::format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                         ShowContinueError(
-                            state,
-                            EnergyPlus::format("{} is specified as {:.3R} C in this object.", cNumericFields(1), desicDehum.RegenSetPointTemp));
+                            state, std::format("{} is specified as {:.3f} C in this object.", cNumericFields(1), desicDehum.RegenSetPointTemp));
                         ShowContinueError(state, " Do not specify a coil temperature setpoint node name in the regeneration air heater object.");
                         ShowContinueError(state, std::format("...{} = {}", cAlphaFields(9), Alphas(9)));
                         ShowContinueError(state, std::format("...{} = {}", cAlphaFields(10), desicDehum.RegenCoilName));
@@ -1008,8 +1005,7 @@ namespace DesiccantDehumidifiers {
                     if (RegenCoilControlNodeNum > 0) {
                         ShowSevereError(state, std::format("{} \"{}\"", desicDehum.DehumType, desicDehum.Name));
                         ShowContinueError(
-                            state,
-                            EnergyPlus::format("{} is specified as {:.3R} C in this object.", cNumericFields(1), desicDehum.RegenSetPointTemp));
+                            state, std::format("{} is specified as {:.3f} C in this object.", cNumericFields(1), desicDehum.RegenSetPointTemp));
                         ShowContinueError(state, " Do not specify a coil temperature setpoint node name in the regeneration air heater object.");
                         ShowContinueError(state, std::format("...{} = {}", cAlphaFields(9), Alphas(9)));
                         ShowContinueError(state, std::format("...{} = {}", cAlphaFields(10), desicDehum.RegenCoilName));
@@ -3029,8 +3025,8 @@ namespace DesiccantDehumidifiers {
                                                            desicDehum.Name));
                             ShowContinueErrorTimeStamp(state, "");
                             ShowContinueError(state, "...Bad hot water maximum flow rate limits");
-                            ShowContinueError(state, EnergyPlus::format("...Given minimum water flow rate={:.3R} kg/s", MinWaterFlow));
-                            ShowContinueError(state, EnergyPlus::format("...Given maximum water flow rate={:.3R} kg/s", MaxHotWaterFlow));
+                            ShowContinueError(state, std::format("...Given minimum water flow rate={:.3f} kg/s", MinWaterFlow));
+                            ShowContinueError(state, std::format("...Given maximum water flow rate={:.3f} kg/s", MaxHotWaterFlow));
                         }
                         ShowRecurringWarningErrorAtEnd(state,
                                                        "CalcNonDXHeatingCoils: Hot water coil control failed (flow limits) for " +
diff --git a/src/EnergyPlus/DualDuct.cc b/src/EnergyPlus/DualDuct.cc
index 4d0bad68342..37d18a062d7 100644
--- a/src/EnergyPlus/DualDuct.cc
+++ b/src/EnergyPlus/DualDuct.cc
@@ -678,11 +678,11 @@ namespace DualDuct {
                         } else {
                             if (thisDD.MaxAirVolFlowRate < thisDD.DesignOAFlowRate) {
                                 ShowSevereError(state,
-                                                EnergyPlus::format("The value {:.5R} in {}is lower than the outdoor air requirement.",
-                                                                   thisDD.MaxAirVolFlowRate,
-                                                                   cNumericFields(1)));
+                                                std::format("The value {:.5f} in {}is lower than the outdoor air requirement.",
+                                                            thisDD.MaxAirVolFlowRate,
+                                                            cNumericFields(1)));
                                 ShowContinueError(state, EnergyPlus::format("Occurs in {} = {}", cCMO_DDVarVolOA, thisDD.Name));
-                                ShowContinueError(state, EnergyPlus::format("The design outdoor air requirement is {:.5R}", thisDD.DesignOAFlowRate));
+                                ShowContinueError(state, std::format("The design outdoor air requirement is {:.5f}", thisDD.DesignOAFlowRate));
                                 ErrorsFound = true;
                             }
                         }
diff --git a/tst/EnergyPlus/unit/Autosizing/All_Simple_Sizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/All_Simple_Sizing.unit.cc
index 5bc3987fd8d..a3c06fa77f2 100644
--- a/tst/EnergyPlus/unit/Autosizing/All_Simple_Sizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/All_Simple_Sizing.unit.cc
@@ -346,7 +346,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Zone Cooling Sensible Load [W], 3007.50000\n");
+                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Zone Cooling Sensible Load [W], 3007.500\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
     state->dataSize->ZoneSizingInput.allocate(1);
@@ -417,7 +417,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Zone Cooling Sensible Load [W], 0.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Zone Cooling Sensible Load [W], 0.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -434,7 +434,7 @@ TEST_F(AutoSizingFixture, ZoneCoolingLoadSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Zone Cooling Sensible Load [W], 2880.00000\n");
+        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Zone Cooling Sensible Load [W], 2880.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
@@ -480,7 +480,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Zone Heating Sensible Load [W], 3007.50000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Zone Heating Sensible Load [W], 3007.500\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
     state->dataSize->ZoneSizingInput.allocate(1);
@@ -550,7 +550,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Zone Heating Sensible Load [W], 0.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Zone Heating Sensible Load [W], 0.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -567,7 +567,7 @@ TEST_F(AutoSizingFixture, ZoneHeatingLoadSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Zone Heating Sensible Load [W], 2880.00000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Zone Heating Sensible Load [W], 2880.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
@@ -717,7 +717,7 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(
-        " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Minimum Supply Air Temperature in Cooling Mode [C], 7.58525\n");
+        " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Minimum Supply Air Temperature in Cooling Mode [C], 7.585251\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -732,9 +732,9 @@ TEST_F(AutoSizingFixture, ASHRAEMinSATCoolingSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(
-        " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Minimum Supply Air Temperature in Cooling Mode [C], 7.58525\n"
+        " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Minimum Supply Air Temperature in Cooling Mode [C], 7.585251\n"
         " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Minimum Supply Air Temperature in Cooling Mode [C], "
-        "9.00000\n");
+        "9.000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
@@ -941,7 +941,7 @@ TEST_F(AutoSizingFixture, DesiccantDehumidifierBFPerfDataFaceVelocitySizingGaunt
 
     std::string eiooutput = std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
                                         " Component Sizing Information, " +
-                                        std::string{compType} + ", MyDesiccantHX, User-Specified Nominal Air Face Velocity [m/s], 4.50000\n");
+                                        std::string{compType} + ", MyDesiccantHX, User-Specified Nominal Air Face Velocity [m/s], 4.500000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
     state->dataSize->ZoneSizingInput.allocate(1);
@@ -1025,7 +1025,7 @@ TEST_F(AutoSizingFixture, DesiccantDehumidifierBFPerfDataFaceVelocitySizingGaunt
 
     // <Component Sizing Information> header already reported above (and flag set false). Only HX sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, " + std::string{compType} +
-                            ", MyDesiccantHX, Design Size Nominal Air Face Velocity [m/s], 4.30797\n");
+                            ", MyDesiccantHX, Design Size Nominal Air Face Velocity [m/s], 4.307971\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -1040,9 +1040,9 @@ TEST_F(AutoSizingFixture, DesiccantDehumidifierBFPerfDataFaceVelocitySizingGaunt
     sizer.autoSizedValue = 0.0; // reset for next test
     // <Component Sizing Information> header already reported above (and flag set false). Only HX sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, " + std::string{compType} +
-                            ", MyDesiccantHX, Design Size Nominal Air Face Velocity [m/s], 4.30797\n"
+                            ", MyDesiccantHX, Design Size Nominal Air Face Velocity [m/s], 4.307971\n"
                             " Component Sizing Information, " +
-                            std::string{compType} + ", MyDesiccantHX, User-Specified Nominal Air Face Velocity [m/s], 3.20000\n");
+                            std::string{compType} + ", MyDesiccantHX, User-Specified Nominal Air Face Velocity [m/s], 3.200000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
@@ -1351,7 +1351,7 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletHumRatSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n Component Sizing "
-                    "Information, Coil:Heating:Water, MyWaterCoil, Design Size Rated Inlet Air Humidity Ratio, 8.00000E-003\n");
+                    "Information, Coil:Heating:Water, MyWaterCoil, Design Size Rated Inlet Air Humidity Ratio, 8.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -1379,8 +1379,8 @@ TEST_F(AutoSizingFixture, HeatingCoilDesAirInletHumRatSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Rated Inlet Air Humidity Ratio, 4.00000E-003\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Inlet Air Humidity Ratio, 9.00000E-003\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Rated Inlet Air Humidity Ratio, 4.000E-03\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Inlet Air Humidity Ratio, 9.000E-03\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingAirFlowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingAirFlowSizing.unit.cc
index 45e7083b21f..e8e9355b5bc 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingAirFlowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingAirFlowSizing.unit.cc
@@ -104,7 +104,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Cooling Supply Air Flow Rate [m3/s], 5.00000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Cooling Supply Air Flow Rate [m3/s], 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -149,7 +149,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
 
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Cooling Supply Air Flow Rate [m3/s], 1.60000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Cooling Supply Air Flow Rate [m3/s], 1.600000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -698,7 +698,7 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Cooling Supply Air Flow Rate [m3/s], 1.33000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Cooling Supply Air Flow Rate [m3/s], 1.330000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -928,8 +928,8 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Cooling Supply Air Flow Rate [m3/s], 5.80000\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Cooling Supply Air Flow Rate [m3/s], 2.00000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Cooling Supply Air Flow Rate [m3/s], 5.800000\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Cooling Supply Air Flow Rate [m3/s], 2.000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // Test 56 - Air Loop Equipment, CurDuctType = RAB, hard-sized air flow rate
@@ -954,8 +954,8 @@ TEST_F(AutoSizingFixture, CoolingAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Cooling Supply Air Flow Rate [m3/s], 3.50000\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Cooling Supply Air Flow Rate [m3/s], 2.20000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Cooling Supply Air Flow Rate [m3/s], 3.500000\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Cooling Supply Air Flow Rate [m3/s], 2.200000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // Test 57 - Air Loop Equipment, no sizing run, hard-sized air flow rate
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingCapacitySizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingCapacitySizing.unit.cc
index 61334d9fa3d..9536cf2df78 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingCapacitySizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingCapacitySizing.unit.cc
@@ -140,7 +140,7 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
 
     // eio header reported in fan sizing
     std::string eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Cooling Design Capacity [W], 5125.30000\n");
+        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Cooling Design Capacity [W], 5125.300\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -282,9 +282,8 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     EXPECT_FALSE(errorsFound);
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Cooling Design Capacity [W], 3500.00000\n"
-                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Cooling Design Capacity [W], 5500.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Cooling Design Capacity [W], 3500.000\n"
+                            " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Cooling Design Capacity [W], 5500.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
     eiooutput = "";
 
@@ -535,9 +534,8 @@ TEST_F(AutoSizingFixture, CoolingCapacitySizingGauntlet)
     EXPECT_FALSE(errorsFound);
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Cooling Design Capacity [W], 5634.11835\n"
-                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Cooling Design Capacity [W], 4200.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Cooling Design Capacity [W], 5634.118\n"
+                            " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Cooling Design Capacity [W], 4200.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // Test 22 - OA Equipment, DOAS Air loop with no fan heat for cooling capacity
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingSHRSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingSHRSizing.unit.cc
index dc4bb3c660c..1f41d189e90 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingSHRSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingSHRSizing.unit.cc
@@ -116,7 +116,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
 
     std::string eiooutput = std::string(
         "! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-        " Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, User-Specified Gross Rated Sensible Heat Ratio, 0.85000\n");
+        " Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, User-Specified Gross Rated Sensible Heat Ratio, 0.8500000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -140,7 +140,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     sizedValue = 0.0;
 
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, Design Size Gross Rated Sensible Heat Ratio, 0.77617\n");
+        std::string(" Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, Design Size Gross Rated Sensible Heat Ratio, 0.7761670\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -206,7 +206,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
     sizedValue = 0.0;
 
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, Design Size Gross Rated Sensible Heat Ratio, 0.63146\n");
+        std::string(" Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, Design Size Gross Rated Sensible Heat Ratio, 0.6314622\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -291,7 +291,7 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, Design Size Gross Rated Sensible Heat Ratio, 0.77617\n");
+        std::string(" Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, Design Size Gross Rated Sensible Heat Ratio, 0.7761670\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -351,8 +351,8 @@ TEST_F(AutoSizingFixture, CoolingSHRSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(
-        " Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, Design Size Gross Rated Sensible Heat Ratio, 0.67508\n"
-        " Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, User-Specified Gross Rated Sensible Heat Ratio, 0.52000\n");
+        " Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, Design Size Gross Rated Sensible Heat Ratio, 0.6750832\n"
+        " Component Sizing Information, Coil:Cooling:DX:SingleSpeed, MyDXCoil, User-Specified Gross Rated Sensible Heat Ratio, 0.5200000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletHumRatSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletHumRatSizing.unit.cc
index 9a4ea6d2238..81933257561 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletHumRatSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirInletHumRatSizing.unit.cc
@@ -105,7 +105,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
 
     eiooutput = std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
                             " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 9.00000E-003\n");
+                            "[kgWater/kgDryAir], 9.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -142,7 +142,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
     EXPECT_NEAR(0.008, sizedValue, 0.0001);
 
     eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 8.00000E-003\n");
+                            "[kgWater/kgDryAir], 8.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -274,7 +274,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 1.05000E-002\n");
+                            "[kgWater/kgDryAir], 1.050E-02\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -369,9 +369,9 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirInletHumRatSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 3.60000E-003\n"
+                            "[kgWater/kgDryAir], 3.600E-03\n"
                             " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 6.65000E-003\n");
+                            "[kgWater/kgDryAir], 6.650E-03\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletHumRatSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletHumRatSizing.unit.cc
index 63eb912e275..3d89a40870c 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletHumRatSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesAirOutletHumRatSizing.unit.cc
@@ -105,7 +105,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
 
     eiooutput = std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
                             " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Outlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 6.00000E-003\n");
+                            "[kgWater/kgDryAir], 6.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -137,7 +137,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
     EXPECT_NEAR(0.008, sizedValue, 0.0001);
 
     eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Outlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 8.00000E-003\n");
+                            "[kgWater/kgDryAir], 8.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -244,7 +244,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Outlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 9.00000E-003\n");
+                            "[kgWater/kgDryAir], 9.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -337,9 +337,9 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Outlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 3.60000E-003\n"
+                            "[kgWater/kgDryAir], 3.600E-03\n"
                             " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Outlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 6.65000E-003\n");
+                            "[kgWater/kgDryAir], 6.650E-03\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // reset eio stream
@@ -364,7 +364,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesAirOutletHumRatSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Outlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 3.00000E-003\n");
+                            "[kgWater/kgDryAir], 3.000E-03\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // Test 17 - Repeat w/ dry coil and high water temp, Outdoor Air System Equipment with DOAS system, autosized humidity ratio
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesWaterInletTempSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesWaterInletTempSizing.unit.cc
index eb537b07dbf..50620369a95 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesWaterInletTempSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterDesWaterInletTempSizing.unit.cc
@@ -98,7 +98,7 @@ TEST_F(AutoSizingFixture, CoolingWaterDesWaterInletTempSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Inlet Water Temperature [C], 5.00000\n");
+                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Inlet Water Temperature [C], 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterNumofTubesPerRowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterNumofTubesPerRowSizing.unit.cc
index d06e09c1f0e..b74a37f2dfa 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterNumofTubesPerRowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterNumofTubesPerRowSizing.unit.cc
@@ -97,7 +97,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Number of Tubes per Row, 5.00000\n");
+                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Number of Tubes per Row, 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -183,7 +183,7 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Number of Tubes per Row, 4.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Number of Tubes per Row, 4.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -238,8 +238,8 @@ TEST_F(AutoSizingFixture, CoolingWaterNumofTubesPerRowSizingGauntlet)
     EXPECT_FALSE(errorsFound);
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Number of Tubes per Row, 4.00000\n"
-                            " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Number of Tubes per Row, 5.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Number of Tubes per Row, 4.000000\n"
+                            " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Number of Tubes per Row, 5.000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc
index bf67e5eb05d..3f4cb2be921 100644
--- a/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/CoolingWaterflowSizing.unit.cc
@@ -119,7 +119,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Water Flow Rate [m3/s], 5.00000\n");
+                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Water Flow Rate [m3/s], 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -155,7 +155,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
     sizedValue = 0.0;
 
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Water Flow Rate [m3/s], 1.49018E-004\n");
+        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Water Flow Rate [m3/s], 0.0001490183\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -316,7 +316,7 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Water Flow Rate [m3/s], 2.38237E-004\n");
+        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Water Flow Rate [m3/s], 0.0002382369\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -346,8 +346,8 @@ TEST_F(AutoSizingFixture, CoolingWaterflowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Water Flow Rate [m3/s], 4.76474E-004\n"
-                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Water Flow Rate [m3/s], 2.00000E-004\n");
+        std::string(" Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, Design Size Design Water Flow Rate [m3/s], 0.0004764739\n"
+                    " Component Sizing Information, Coil:Cooling:Water, MyWaterCoil, User-Specified Design Water Flow Rate [m3/s], 0.0002000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // call the clearState
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingAirFlowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingAirFlowSizing.unit.cc
index 0d910612778..32dcef1d6f5 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingAirFlowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingAirFlowSizing.unit.cc
@@ -104,7 +104,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Supply Air Flow Rate [m3/s], 5.00000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Supply Air Flow Rate [m3/s], 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -148,7 +148,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
 
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Supply Air Flow Rate [m3/s], 1.60000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Supply Air Flow Rate [m3/s], 1.600000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -697,7 +697,7 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Supply Air Flow Rate [m3/s], 1.33000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Supply Air Flow Rate [m3/s], 1.330000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -928,8 +928,8 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Supply Air Flow Rate [m3/s], 5.40000\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Supply Air Flow Rate [m3/s], 2.00000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Supply Air Flow Rate [m3/s], 5.400000\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Supply Air Flow Rate [m3/s], 2.000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // Test 56 - Air Loop Equipment, CurDuctType = RAB, hard-sized air flow rate
@@ -954,8 +954,8 @@ TEST_F(AutoSizingFixture, HeatingAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Supply Air Flow Rate [m3/s], 3.50000\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Supply Air Flow Rate [m3/s], 2.20000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Supply Air Flow Rate [m3/s], 3.500000\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Supply Air Flow Rate [m3/s], 2.200000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // Test 57 - Air Loop Equipment, no sizing run, hard-sized air flow rate
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingAirflowUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingAirflowUASizing.unit.cc
index 4cca2694ff6..86bedfd215e 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingAirflowUASizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingAirflowUASizing.unit.cc
@@ -126,7 +126,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Coil Airflow for UA [m3/s], 5.00000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Coil Airflow for UA [m3/s], 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -157,7 +157,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
     EXPECT_NEAR(1.2, state->dataEnvrn->StdRhoAir, 0.01);
 
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Coil Airflow for UA [m3/s], 0.00000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Coil Airflow for UA [m3/s], 0.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -321,7 +321,7 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Coil Airflow for UA [m3/s], 6.00000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Coil Airflow for UA [m3/s], 6.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -462,8 +462,8 @@ TEST_F(AutoSizingFixture, HeatingAirflowUASizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Coil Airflow for UA [m3/s], 3.00000\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Coil Airflow for UA [m3/s], 5.00000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Coil Airflow for UA [m3/s], 3.000000\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Coil Airflow for UA [m3/s], 5.000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingCapacitySizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingCapacitySizing.unit.cc
index e6b9fc3cf08..92adbd5e7ab 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingCapacitySizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingCapacitySizing.unit.cc
@@ -138,7 +138,7 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     state->dataSize->ZoneEqSizing(1).DesignSizeFromParent = false;
 
     std::string eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Capacity [W], 5125.30000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Capacity [W], 5125.300\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -374,8 +374,8 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     EXPECT_FALSE(errorsFound);
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Capacity [W], 6229.25822\n"
-                            " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Capacity [W], 5500.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Capacity [W], 6229.258\n"
+                            " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Capacity [W], 5500.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
     eiooutput = "";
 
@@ -831,8 +831,8 @@ TEST_F(AutoSizingFixture, HeatingCapacitySizingGauntlet)
     EXPECT_FALSE(errorsFound);
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Capacity [W], 6632.06669\n"
-                            " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Capacity [W], 4200.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Heating Capacity [W], 6632.067\n"
+                            " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Heating Capacity [W], 4200.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletHumRatSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletHumRatSizing.unit.cc
index 63beb037e65..dc938903532 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletHumRatSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletHumRatSizing.unit.cc
@@ -105,7 +105,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
 
     eiooutput = std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
                             " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 9.00000E-003\n");
+                            "[kgWater/kgDryAir], 9.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -152,7 +152,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
     EXPECT_NEAR(0.008, sizedValue, 0.0001);
 
     eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 8.00000E-003\n");
+                            "[kgWater/kgDryAir], 8.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -350,7 +350,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 6.00000E-003\n");
+                            "[kgWater/kgDryAir], 6.000E-03\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -445,9 +445,9 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletHumRatSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 3.60000E-003\n"
+                            "[kgWater/kgDryAir], 3.600E-03\n"
                             " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Design Inlet Air Humidity Ratio "
-                            "[kgWater/kgDryAir], 6.65000E-003\n");
+                            "[kgWater/kgDryAir], 6.650E-03\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletTempSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletTempSizing.unit.cc
index 409f8dab39b..2dd9ae5dc51 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletTempSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesAirInletTempSizing.unit.cc
@@ -104,7 +104,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Inlet Air Temperature [C], 5.00000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Inlet Air Temperature [C], 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -397,7 +397,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesAirInletTempSizingGauntlet)
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
         std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Rated Inlet Air Temperature [C], 12.00000\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Inlet Air Temperature [C], 5.00000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Inlet Air Temperature [C], 5.000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc
index 2042e8461c5..05c05e7f415 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilLoadUsedForUASizing.unit.cc
@@ -105,7 +105,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     std::string eiooutput = std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
                                         " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Water Heating Design Coil "
-                                        "Load for UA Sizing [W], 5125.30000\n");
+                                        "Load for UA Sizing [W], 5125.300\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -275,9 +275,9 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(
-        " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Water Heating Design Coil Load for UA Sizing [W], 2024.55160\n"
+        " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Water Heating Design Coil Load for UA Sizing [W], 2024.552\n"
         " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Water Heating Design Coil Load for UA Sizing [W], "
-        "1500.00000\n");
+        "1500.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // reset eio stream
@@ -338,7 +338,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Water Heating Design Coil Load for UA "
-                            "Sizing [W], 14469.96369\n");
+                            "Sizing [W], 14469.96\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -364,7 +364,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Water Heating Design Coil Load for UA "
-                            "Sizing [W], 18087.45461\n");
+                            "Sizing [W], 18087.45\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // reset eio stream
@@ -473,9 +473,9 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilLoadUsedForUASizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(
-        " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Water Heating Design Coil Load for UA Sizing [W], 5064.48729\n"
+        " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Water Heating Design Coil Load for UA Sizing [W], 5064.487\n"
         " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Water Heating Design Coil Load for UA Sizing [W], "
-        "7000.00000\n");
+        "7000.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.unit.cc
index 970c3b024a2..2b6479a6d86 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterDesCoilWaterVolFlowUsedForUASizing.unit.cc
@@ -97,7 +97,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
 
     std::string eiooutput = std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
                                         " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Design Water Volume Flow "
-                                        "Rate Used for UA Sizing [m3/s], 5.00000E-004\n");
+                                        "Rate Used for UA Sizing [m3/s], 0.0005000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -205,7 +205,7 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Design Water Volume Flow "
-                            "Rate Used for UA Sizing [m3/s], 4.00000E-004\n");
+                            "Rate Used for UA Sizing [m3/s], 0.0004000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -261,9 +261,9 @@ TEST_F(AutoSizingFixture, HeatingWaterDesCoilWaterVolFlowUsedForUASizingGauntlet
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Design Water Volume Flow "
-                            "Rate Used for UA Sizing [m3/s], 4.00000E-004\n"
+                            "Rate Used for UA Sizing [m3/s], 0.0004000000\n"
                             " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Design Water Volume Flow "
-                            "Rate Used for UA Sizing [m3/s], 5.00000E-004\n");
+                            "Rate Used for UA Sizing [m3/s], 0.0005000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc
index 843b9986815..a0a0a37a582 100644
--- a/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/HeatingWaterflowSizing.unit.cc
@@ -152,7 +152,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Maximum Water Flow Rate [m3/s], 5.00000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Maximum Water Flow Rate [m3/s], 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -188,7 +188,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
     EXPECT_NEAR(1.2, state->dataEnvrn->StdRhoAir, 0.01);
 
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Maximum Water Flow Rate [m3/s], 5.00000E-003\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Maximum Water Flow Rate [m3/s], 0.005000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -367,7 +367,7 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Maximum Water Flow Rate [m3/s], 1.21516E-004\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Maximum Water Flow Rate [m3/s], 0.0001215158\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -397,8 +397,8 @@ TEST_F(AutoSizingFixture, HeatingWaterflowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Maximum Water Flow Rate [m3/s], 1.21516E-004\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Maximum Water Flow Rate [m3/s], 2.00000E-004\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Maximum Water Flow Rate [m3/s], 0.0001215158\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Maximum Water Flow Rate [m3/s], 0.0002000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }
 
diff --git a/tst/EnergyPlus/unit/Autosizing/SystemAirFlowSizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/SystemAirFlowSizing.unit.cc
index 5ee6a6744d2..1f36557f9ac 100644
--- a/tst/EnergyPlus/unit/Autosizing/SystemAirFlowSizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/SystemAirFlowSizing.unit.cc
@@ -101,7 +101,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Supply Air Maximum Flow Rate [m3/s], 5.00000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Supply Air Maximum Flow Rate [m3/s], 5.000000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -145,7 +145,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
     sizer.autoSizedValue = 0.0; // reset for next test
 
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Supply Air Maximum Flow Rate [m3/s], 1.60000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Supply Air Maximum Flow Rate [m3/s], 1.600000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -694,7 +694,7 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Supply Air Maximum Flow Rate [m3/s], 1.33000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Supply Air Maximum Flow Rate [m3/s], 1.330000\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -935,8 +935,8 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Supply Air Maximum Flow Rate [m3/s], 5.00000\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Supply Air Maximum Flow Rate [m3/s], 2.00000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Supply Air Maximum Flow Rate [m3/s], 5.000000\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Supply Air Maximum Flow Rate [m3/s], 2.000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // Test 57 - Air Loop HX Equipment, CurDuctType = RAB, hard-sized air flow rate
@@ -961,8 +961,8 @@ TEST_F(AutoSizingFixture, SystemAirFlowSizingGauntlet)
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
-        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Supply Air Maximum Flow Rate [m3/s], 3.50000\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Supply Air Maximum Flow Rate [m3/s], 2.20000\n");
+        std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Supply Air Maximum Flow Rate [m3/s], 3.500000\n"
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Supply Air Maximum Flow Rate [m3/s], 2.200000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // Test 58 - DOAS fan air flow rate autosizing
diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc
index 6d9f08917f6..57ace580d24 100644
--- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCapacitySizing.unit.cc
@@ -105,7 +105,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
 
     std::string eiooutput =
         std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Capacity [W], 5125.30000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Capacity [W], 5125.300\n");
 
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
@@ -272,8 +272,8 @@ TEST_F(AutoSizingFixture, WaterHeatingCapacitySizingGauntlet)
     EXPECT_FALSE(errorsFound);
 
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
-    eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Rated Capacity [W], 1012.27580\n"
-                            " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Capacity [W], 1500.00000\n");
+    eiooutput = std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size Rated Capacity [W], 1012.276\n"
+                            " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified Rated Capacity [W], 1500.000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 
     // AIRLOOP Equipment not supported
diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc
index 7504fcbb5f4..46241f118fa 100644
--- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc
+++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc
@@ -327,7 +327,7 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet)
     // <Component Sizing Information> header already reported above (and flag set false). Only coil sizing information reported here.
     eiooutput =
         std::string(" Component Sizing Information, Coil:Heating:Water, MyWaterCoil, Design Size U-Factor Times Area Value [W/K], 98.35096\n"
-                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified U-Factor Times Area Value [W/K], 5.00000\n");
+                    " Component Sizing Information, Coil:Heating:Water, MyWaterCoil, User-Specified U-Factor Times Area Value [W/K], 5.000000\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
     // How to compare these sizing strings if they have some tolerance on them?
     // Maybe not use the optimizing SolveRoot on sizing routines?  Stick to RegulaFalsi?
diff --git a/tst/EnergyPlus/unit/DXCoils.unit.cc b/tst/EnergyPlus/unit/DXCoils.unit.cc
index c3870862a9a..cfdcbf42251 100644
--- a/tst/EnergyPlus/unit/DXCoils.unit.cc
+++ b/tst/EnergyPlus/unit/DXCoils.unit.cc
@@ -5021,16 +5021,16 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoilsAutoSizingOutput)
     EXPECT_NEAR(16365.95, state->dataDXCoils->DXCoil(1).MSRatedTotCap(1), 0.01);
     // Check EIO reporting
     std::string clg_coil_eio_output = R"EIO(! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 1.75000
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.87500
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Gross Rated Total Cooling Capacity [W], 32731.91226
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Gross Rated Total Cooling Capacity [W], 16365.95613
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Rated Sensible Heat Ratio, 0.80369
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Rated Sensible Heat Ratio, 0.80369
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Evaporative Condenser Air Flow Rate [m3/s], 1.86572
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Evaporative Condenser Air Flow Rate [m3/s], 3.73144
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 1.750000
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.8750000
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Gross Rated Total Cooling Capacity [W], 32731.91
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Gross Rated Total Cooling Capacity [W], 16365.96
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Rated Sensible Heat Ratio, 0.8036948
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Rated Sensible Heat Ratio, 0.8036948
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Evaporative Condenser Air Flow Rate [m3/s], 1.865719
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Evaporative Condenser Air Flow Rate [m3/s], 3.731438
  Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 1 Rated Evaporative Condenser Pump Power Consumption [W], 69.81717
- Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Rated Evaporative Condenser Pump Power Consumption [W], 139.63434
+ Component Sizing Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, Design Size Speed 2 Rated Evaporative Condenser Pump Power Consumption [W], 139.6343
 ! <DX Cooling Coil Standard Rating Information>, Component Type, Component Name, Standard Rating (Net) Cooling Capacity {W}, Standard Rating Net COP {W/W}, EER {Btu/W-h}, SEER User {Btu/W-h}, SEER Standard {Btu/W-h}, IEER {Btu/W-h}
  DX Cooling Coil Standard Rating Information, Coil:Cooling:DX:MultiSpeed, ASHP CLG COIL, 31065.3, 3.95, 13.47, 16.52, 16.03, 0
 ! <DX Cooling Coil AHRI 2023 Standard Rating Information>, Component Type, Component Name, Standard Rating (Net) Cooling Capacity {W}, Standard Rating Net COP2 {W/W}, EER2 {Btu/W-h}, SEER2 User {Btu/W-h}, SEER2 Standard {Btu/W-h}, IEER 2022 {Btu/W-h}
@@ -5052,11 +5052,11 @@ TEST_F(EnergyPlusFixture, TestMultiSpeedCoilsAutoSizingOutput)
     EXPECT_NEAR(16365.95, state->dataDXCoils->DXCoil(2).MSRatedTotCap(1), 0.01);
     // Check EIO reporting
     const std::string htg_coil_eio_output =
-        R"EIO( Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 1.75000
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.87500
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Gross Rated Heating Capacity [W], 32731.91226
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Gross Rated Heating Capacity [W], 16365.95613
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.00000
+        R"EIO( Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 1.750000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.8750000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Gross Rated Heating Capacity [W], 32731.91
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Gross Rated Heating Capacity [W], 16365.96
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.000000
 ! <DX Heating Coil Standard Rating Information>, Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF {Btu/W-h}, Region Number
  DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 34415.4, 20666.4, 6.56, 4
 ! <DX Heating Coil AHRI 2023 Standard Rating Information>, Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF2 {Btu/W-h}, Region Number
@@ -7513,11 +7513,11 @@ TEST_F(EnergyPlusFixture, MultiSpeedDXHeatingCoilsHSPF2Test)
 
     // Check EIO reporting
     const std::string htg_coil_eio_output = R"EIO(! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 0.58000
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.29000
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Gross Rated Heating Capacity [W], 14402.78123
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Gross Rated Heating Capacity [W], 7201.39061
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.00000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 0.5800000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.2900000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Gross Rated Heating Capacity [W], 14402.78
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Gross Rated Heating Capacity [W], 7201.391
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.000000
 ! <DX Heating Coil Standard Rating Information>, Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF {Btu/W-h}, Region Number
  DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 14996.6, 8946.7, 8.12, 4
 ! <DX Heating Coil AHRI 2023 Standard Rating Information>, Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF2 {Btu/W-h}, Region Number
@@ -7775,11 +7775,11 @@ TEST_F(EnergyPlusFixture, MultiSpeedDXHeatingCoilsHSPF2Test1)
 
     // Check EIO reporting
     const std::string htg_coil_eio_output = R"EIO(! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 0.58000
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.29000
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Gross Rated Heating Capacity [W], 14402.78123
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Gross Rated Heating Capacity [W], 7201.39061
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.00000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 0.5800000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.2900000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Gross Rated Heating Capacity [W], 14402.78
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Gross Rated Heating Capacity [W], 7201.391
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.000000
 ! <DX Heating Coil Standard Rating Information>, Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF {Btu/W-h}, Region Number
  DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 14996.6, 8946.7, 8.12, 4
 ! <DX Heating Coil AHRI 2023 Standard Rating Information>, Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF2 {Btu/W-h}, Region Number
@@ -8037,11 +8037,11 @@ TEST_F(EnergyPlusFixture, MultiSpeedDXHeatingCoilsHSPF2Test2)
 
     // Check EIO reporting
     const std::string htg_coil_eio_output = R"EIO(! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 0.58000
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.29000
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Gross Rated Heating Capacity [W], 14402.78123
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Gross Rated Heating Capacity [W], 7201.39061
- Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.00000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Rated Air Flow Rate [m3/s], 0.5800000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Rated Air Flow Rate [m3/s], 0.2900000
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 2 Gross Rated Heating Capacity [W], 14402.78
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Speed 1 Gross Rated Heating Capacity [W], 7201.391
+ Component Sizing Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, Design Size Resistive Defrost Heater Capacity, 0.000000
 ! <DX Heating Coil Standard Rating Information>, Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF {Btu/W-h}, Region Number
  DX Heating Coil Standard Rating Information, Coil:Heating:DX:MultiSpeed, ASHP HTG COIL, 14996.6, 8946.7, 8.57, 4
 ! <DX Heating Coil AHRI 2023 Standard Rating Information>, Component Type, Component Name, High Temperature Heating (net) Rating Capacity {W}, Low Temperature Heating (net) Rating Capacity {W}, HSPF2 {Btu/W-h}, Region Number
diff --git a/tst/EnergyPlus/unit/Fans.unit.cc b/tst/EnergyPlus/unit/Fans.unit.cc
index d2f5fda7581..f4244b3f798 100644
--- a/tst/EnergyPlus/unit/Fans.unit.cc
+++ b/tst/EnergyPlus/unit/Fans.unit.cc
@@ -94,8 +94,8 @@ TEST_F(EnergyPlusFixture, Fans_FanSizing)
     EXPECT_NEAR(1.0352, fan1->designPointFEI, 0.0001);
 
     std::string eiooutput = std::string("! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n"
-                                        " Component Sizing Information, Fan:OnOff, Test Fan, Design Size Maximum Flow Rate [m3/s], 1.00635\n"
-                                        " Component Sizing Information, Fan:OnOff, Test Fan, Design Electric Power Consumption [W], 1257.93750\n");
+                                        " Component Sizing Information, Fan:OnOff, Test Fan, Design Size Maximum Flow Rate [m3/s], 1.006350\n"
+                                        " Component Sizing Information, Fan:OnOff, Test Fan, Design Electric Power Consumption [W], 1257.938\n");
     EXPECT_TRUE(compare_eio_stream(eiooutput, true));
 }