jt
2021-06-10 5d0d028456874576560552f5a5c4e8b801786f11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
 
namespace HH.WMS.Utils
{
    public class ZMath
    {
 
        public static decimal calcRound(decimal adTargetVal, int anDigits)
        {
            double dbTargetVal = Convert.ToDouble(adTargetVal);
            double decReturn = calcRound(dbTargetVal, anDigits);
            return Convert.ToDecimal(decReturn);
        }
 
        /// <summary>
        ///    四舍五入处理
        /// </summary>
        /// <param name="adTargetVal">处理对象值</param>
        /// <param name="anDigits">处理对象位数(负数时直接去位数)</param>
        /// <returns>处理结果数值</returns>
        public static double calcRound(double adTargetVal, int anDigits)
        {
 
            double dRet = adTargetVal;
 
            try
            {
                // 先转换成整数再进行计算
                dRet = dRet * System.Math.Pow(10, (double)anDigits);
 
                // 四舍五入处理
                dRet = dRet + (0.5 * System.Math.Sign(dRet));
 
                if (dRet >= 0)
                {
                    dRet = System.Math.Floor(dRet);
                }
                else
                {
                    dRet = System.Math.Ceiling(dRet);
                }
 
                // 还原回小数
                dRet = dRet / System.Math.Pow(10, (double)anDigits);
            }
            catch
            {
                dRet = 0;
            }
 
            return dRet;
        }
 
        /// <summary>
        ///    小数上进一处理
        /// </summary>
        /// <param name="adTargetVal">处理对象值</param>
        /// <param name="anDigits">处理对象位数(负数时直接去尾数)</param>
        /// <returns>处理结果数值</returns>
        public static double calcRoundUp(double adTargetVal, int anDigits)
        {
 
            double dRet = adTargetVal;
 
            try
            {
                // 先转换成整数再进行计算
                dRet = dRet * System.Math.Pow(10, (double)anDigits);
 
                // 小数上进一
                if (dRet >= 0)
                {
                    dRet = System.Math.Ceiling(dRet);
                }
                else
                {
                    dRet = System.Math.Floor(dRet);              // 负数直接去尾数取整
                }
 
                // 还原回小数
                dRet = dRet / System.Math.Pow(10, (double)anDigits);
            }
            catch
            {
                dRet = 0;
            }
 
            return dRet;
 
        }
 
        /// <summary>
        ///    小数直接舍去处理
        /// </summary>
        /// <param name="adTargetVal">处理对象值</param>
        /// <param name="anDigits">处理对象位数(负数时要上进一取整)</param>
        /// <returns>处理结果数值</returns>
        public static double calcRoundDown(double adTargetVal, int anDigits)
        {
 
            double dRet = adTargetVal;
 
            try
            {
                // 先转换成整数再进行计算
                dRet = dRet * System.Math.Pow(10, (double)anDigits);
 
                // 直接去尾数取整
                if (dRet >= 0)
                {
                    dRet = System.Math.Floor(dRet);
                }
                else
                {
                    dRet = System.Math.Ceiling(dRet);     // 负数要上进一取整
                }
 
                // 还原回小数
                dRet = dRet / System.Math.Pow(10, (double)anDigits);
            }
            catch
            {
                dRet = 0;
            }
 
            return dRet;
 
        }
    }
}