Optimize numerical calculation logic

Model/GradeResult/Entity/Enums/Accuracy.cs

@@ -6,14 +6,35 @@ public enum Accuracy
 {
     [Description("强制保留两位小数，向下取整(ZDZ1)")]
     ForceTwoDecimals = 1,
+    
     [Description("强制保留一位小数，向下取整(ZD1)")]
     ForceOneDecimal = 2,
+    
     [Description("将数值舍入到最近的 0.5 倍数(ZD5)")]
     HalfStepRounding = 3,
+    
     [Description("将数值舍入到最近的 5 的整数倍(Z5)")]
     MultipleOfFive = 4,
+    
     [Description("将数值舍入到最近的0.2倍数(ZD2)")] 
     DecimalTwoStepRounding = 5,
+    
     [Description("强制向下取整为整数(Floor)")] 
-    IntegerFloor = 6
+    IntegerFloor = 6,
+    
+    [Description("将数值乘以100后向下取整，并保留一位小数(P100)")]
+    Multiply100FloorOneDecimal = 7,
+    
+    [Description("将数值乘以100后向下取整，并保留两位小数(P100_2)")]
+    Multiply100FloorTwoDecimals = 8,
+    
+    [Description("将数值乘以10后向下取整，并保留一位小数(A10)")]
+    Multiply10FloorOneDecimal = 9,
+    [Description("将数值乘以100后向下取整为整数(M100Floor)")]
+    Multiply100FloorToInteger = 10,
+    [Description("将数值乘以100后舍入到最近的0.5倍数(M100Half)")]
+    Multiply100HalfStepRounding = 11,
+    [Description("将数值乘以100后舍入到最近的5的倍数(M100Z5)")]
+    Multiply100MultipleOfFive = 13,
+
 }

Model/GradeResult/Helper/DoubleDataFormatHelper.cs

@@ -43,6 +43,42 @@ public static class DoubleDataFormatHelper
         return (Math.Floor(value * 10000) / 100).ToString("f2");
     }
     
+    public static double RoundFiveDownSixUp(double value)
+    {
+        // 提取整数部分
+        double integerPart = Math.Truncate(value);
+        // 提取小数部分
+        double fractionalPart = value - integerPart;
+
+        // 判断小数部分是否大于 0.5
+        return fractionalPart > 0.5 ? integerPart + 1 : integerPart;
+    }
+    public static double RoundToPointTwo(double value)
+    {
+        // 转换到10倍精度空间处理
+        double scaled = value * 10;
+        double remainder = scaled % 2; // 求模得到余数
+    
+        // 核心舍入规则：余数>=1.5时进位
+        return remainder >= 1.5 ?  (scaled - remainder + 2) / 10 : (scaled - remainder) / 10; 
+    }
+    
+    /// <summary>
+    /// 直接值(角度，直径)用的小数格式化
+    /// </summary>
+    /// <param name="value"></param>
+    /// <returns></returns>
+    [Log]
+    public static  string FormatDouble_A(double value)
+    {
+        return (Math.Floor(value * 10) / 10).ToString(DigitsFormat);
+    }
+    [Log]
+    public static  string FormatDouble_A2(double value)
+    {
+        return (Math.Floor(value * 100) / 100).ToString("f2");
+    }
+    
     /// <summary>
     /// 百分比用的小数格式化
     /// </summary>
@@ -102,7 +138,7 @@ public static class DoubleDataFormatHelper
     /// <param name="value"></param>
     /// <returns></returns>
     [Log]
-    public static  string FormatDouble(object? value, Accuracy accuracy)
+    public static string FormatDouble(object? value, Accuracy accuracy)
     {
         string result = "";
 
@@ -123,75 +159,60 @@ public static class DoubleDataFormatHelper
                     result = (Math.Floor(dvalue * 10) / 10).ToString("f1");
                     break;
                 case Accuracy.HalfStepRounding:
-                    result = (RoundFiveDownSixUp(dvalue * 2) / 2).ToString("f1");
+                    result = (Math.Round(dvalue * 2) / 2).ToString("f1");
                     break;
                 case Accuracy.MultipleOfFive:
-                    result = (RoundFiveDownSixUp(dvalue / 5) * 5).ToString();
+                    result = (Math.Round(dvalue / 5) * 5).ToString();
                     break;
                 case Accuracy.DecimalTwoStepRounding:
-                    result = RoundToPointTwo(dvalue).ToString("f1"); // 保留1位小数
+                    result = (Math.Round(dvalue * 5) / 5).ToString("f1");
                     break;
                 case Accuracy.IntegerFloor:
-                    result = Math.Floor(dvalue).ToString("F1"); // 直接取整
+                    result = Math.Floor(dvalue).ToString();
+                    break;
+                case Accuracy.Multiply100FloorOneDecimal:
+                    result = (Math.Floor(dvalue * 1000) / 10).ToString("f1");
+                    break;
+                case Accuracy.Multiply100FloorTwoDecimals:
+                    result = (Math.Floor(dvalue * 10000) / 100).ToString("f2");
+                    break;
+                case Accuracy.Multiply10FloorOneDecimal:
+                    result = (Math.Floor(dvalue * 10) / 10).ToString("f1");
+                    break;
+                case Accuracy.Multiply100HalfStepRounding:
+                    result = (Math.Round(dvalue * 100 * 2) / 2).ToString("f1");
+                    break;
+                case Accuracy.Multiply100MultipleOfFive:
+                    result = (Math.Round(dvalue * 100 / 5) * 5).ToString();
                     break;
             }
         }
         else
         {
-            //工厂模式不量化
+            // 工厂模式简化处理
             switch (accuracy)
             {
                 case Accuracy.ForceTwoDecimals:
+                case Accuracy.Multiply100FloorTwoDecimals:
                     result = (Math.Floor(dvalue * 100) / 100).ToString("f2");
                     break;
-                case Accuracy.HalfStepRounding:
                 case Accuracy.ForceOneDecimal:
+                case Accuracy.HalfStepRounding:
                 case Accuracy.DecimalTwoStepRounding:
-                case Accuracy.IntegerFloor:
+                case Accuracy.Multiply100FloorOneDecimal:
-                case Accuracy.MultipleOfFive:
+                case Accuracy.Multiply10FloorOneDecimal:
                     result = (Math.Floor(dvalue * 10) / 10).ToString("f1");
                     break;
+                case Accuracy.MultipleOfFive:
+                case Accuracy.IntegerFloor:
+                    result = Math.Floor(dvalue).ToString("f0");
+                    break;
             }
         }
         return result;
     }
     
     [Log]
-    public static double RoundFiveDownSixUp(double value)
-    {
-        // 提取整数部分
-        double integerPart = Math.Truncate(value);
-        // 提取小数部分
-        double fractionalPart = value - integerPart;
-
-        // 判断小数部分是否大于 0.5
-        return fractionalPart > 0.5 ? integerPart + 1 : integerPart;
-    }
-    public static double RoundToPointTwo(double value)
-    {
-        // 转换到10倍精度空间处理
-        double scaled = value * 10;
-        double remainder = scaled % 2; // 求模得到余数
-    
-        // 核心舍入规则：余数>=1.5时进位
-        return remainder >= 1.5 ?  (scaled - remainder + 2) / 10 : (scaled - remainder) / 10; 
-    }
-    
-    /// <summary>
-    /// 直接值(角度，直径)用的小数格式化
-    /// </summary>
-    /// <param name="value"></param>
-    /// <returns></returns>
-    [Log]
-    public static  string FormatDouble_A(double value)
-    {
-        return (Math.Floor(value * 10) / 10).ToString(DigitsFormat);
-    }
-    [Log]
-    public static  string FormatDouble_A2(double value)
-    {
-        return (Math.Floor(value * 100) / 100).ToString("f2");
-    }
     public static Accuracy ToAccuracy(this string value)
     {
         if (string.IsNullOrEmpty(value))