|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Linq;
|
|
|
using System.Text;
|
|
|
|
|
|
|
|
|
namespace Mesnac.Action.Feeding
|
|
|
{
|
|
|
// 摘要:
|
|
|
// 过程能力控制类
|
|
|
public class SixSigmaHelper
|
|
|
{
|
|
|
public static double d2 = 1.128;
|
|
|
public static double d3 = 1.693;
|
|
|
public static double d4 = 2.059;
|
|
|
public static double d5 = 2.326;
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 求和
|
|
|
/// </summary>
|
|
|
/// <param name="originalData">原始数据数组</param>
|
|
|
/// <returns></returns>
|
|
|
public static double GetSumValue(Double[] originalData)
|
|
|
{
|
|
|
Double sum = 0.0;
|
|
|
for (int i = 0; i < originalData.Length; i++)
|
|
|
{
|
|
|
sum = sum + originalData[i];
|
|
|
}
|
|
|
return DoubleFormat(sum);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 求平均数
|
|
|
/// </summary>
|
|
|
/// <param name="originalData">原始数据数组</param>
|
|
|
/// <returns></returns>
|
|
|
public static Double GetAverageValue(Double[] originalData)
|
|
|
{
|
|
|
Double sum = 0.0;
|
|
|
Double ave = 0.0;
|
|
|
for (int i = 0; i < originalData.Length; i++)
|
|
|
{
|
|
|
sum = sum + originalData[i];
|
|
|
}
|
|
|
ave = sum / originalData.Length;
|
|
|
return DoubleFormat(ave);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 按指定精度求平均值
|
|
|
/// </summary>
|
|
|
/// <param name="digits">精度，即保留的小数位数</param>
|
|
|
/// <param name="originalData"原始数据></param>
|
|
|
/// <returns></returns>
|
|
|
public static Double GetAverageValue(int digits, Double[] originalData)
|
|
|
{
|
|
|
Double sum = 0.0;
|
|
|
Double ave = 0.0;
|
|
|
for (int i = 0; i < originalData.Length; i++)
|
|
|
{
|
|
|
sum = sum + originalData[i];
|
|
|
}
|
|
|
ave = sum / originalData.Length;
|
|
|
return DoubleFormat(digits, ave);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取整体平均值：先分组，计算组内平均值，然后计算整体平均值
|
|
|
/// </summary>
|
|
|
/// <param name="digits">精度，小数位数</param>
|
|
|
/// <param name="groupSize">组大小</param>
|
|
|
/// <param name="originalData"> 原始数据</param>
|
|
|
/// <returns></returns>
|
|
|
public static Double GetTotalAveByGroup(int digits, int groupSize, Double[] originalData)
|
|
|
{
|
|
|
Double[] groupAve = GetGroupAve(digits, groupSize, originalData);
|
|
|
return SixSigmaHelper.GetAverageValue(digits, groupAve);
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取子组平均数，以数组形式返回
|
|
|
/// </summary>
|
|
|
/// <param name="digits">精度，小数位数</param>
|
|
|
/// <param name="groupSize">组大小</param>
|
|
|
/// <param name="originalData">原始数据</param>
|
|
|
/// <returns>返回子组平均值</returns>
|
|
|
public static Double[] GetGroupAve(int digits, int groupSize, Double[] originalData)
|
|
|
{
|
|
|
Double groupNum = Math.Ceiling(Convert.ToDouble(originalData.Length / groupSize));
|
|
|
Double[] groupAve = new Double[Convert.ToInt32(groupNum)];
|
|
|
for (int i = 0; i < Convert.ToInt32(groupNum); i++)
|
|
|
{
|
|
|
int index = i * groupSize;
|
|
|
Double[] temp = new Double[groupSize];
|
|
|
for (int j = 0; j < groupSize; j++)
|
|
|
{
|
|
|
temp[j] = originalData[index + j];
|
|
|
}
|
|
|
groupAve[i] = SixSigmaHelper.GetAverageValue(digits, temp);
|
|
|
}
|
|
|
return groupAve;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 求整体标准差
|
|
|
/// </summary>
|
|
|
/// <param name="originalData">原始数据</param>
|
|
|
/// <returns>返回标准差</returns>
|
|
|
public static Double GetTotalStdDev(Double[] originalData)
|
|
|
{
|
|
|
Double ave = 0.0;
|
|
|
Double stdDev = 0.0;
|
|
|
if (originalData.Length == 1 && originalData[0] == 0.0)
|
|
|
{
|
|
|
return stdDev = 0.0;
|
|
|
}
|
|
|
ave = GetAverageValue(originalData);
|
|
|
for (int i = 0; i < originalData.Length; i++)
|
|
|
{
|
|
|
stdDev = (Double)(stdDev + Math.Pow((originalData[i] - ave), 2));
|
|
|
}
|
|
|
stdDev = (Double)Math.Sqrt(stdDev / (originalData.Length - 1));
|
|
|
return DoubleFormat(stdDev);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 按指定精度获取标准差
|
|
|
/// </summary>
|
|
|
/// <param name="digits">精度，即小数位数</param>
|
|
|
/// <param name="originalData">原始数据</param>
|
|
|
/// <returns>返回标准差</returns>
|
|
|
public static Double GetStdDev(int digits, Double[] originalData)
|
|
|
{
|
|
|
Double ave = 0.0;
|
|
|
Double stdDev = 0.0;
|
|
|
ave = GetAverageValue(originalData);
|
|
|
for (int i = 0; i < originalData.Length; i++)
|
|
|
{
|
|
|
stdDev = (Double)(stdDev + Math.Pow((originalData[i] - ave), 2));
|
|
|
}
|
|
|
stdDev = (Double)Math.Sqrt(stdDev / (originalData.Length - 1));
|
|
|
return DoubleFormat(digits, stdDev);
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 求移动极差均值
|
|
|
/// </summary>
|
|
|
/// <param name="size">子组容量</param>
|
|
|
/// <param name="originalData">原始数据</param>
|
|
|
/// <returns>返回移动极差均值</returns>
|
|
|
public static Double GetMoveRangeMean(int size, Double[] originalData)
|
|
|
{
|
|
|
Double moveSum = 0.0;
|
|
|
Double moveAve = 0.0;
|
|
|
Double[] range = new Double[originalData.Length - (size - 1)];
|
|
|
for (int i = (size - 1); i < originalData.Length; i++)
|
|
|
{
|
|
|
Double[] temp = new Double[size];
|
|
|
int count = size;
|
|
|
int idx = 0;
|
|
|
do
|
|
|
{
|
|
|
temp[idx] = originalData[i - (count - 1)];
|
|
|
idx++;
|
|
|
count--;
|
|
|
} while ((count > 0));
|
|
|
range[i - (size - 1)] = (Double)Math.Abs(GetArrMax(temp) - GetArrMin(temp));
|
|
|
}
|
|
|
for (int i = 0; i < range.Length; i++)
|
|
|
{
|
|
|
moveSum = moveSum + range[i];
|
|
|
}
|
|
|
moveAve = moveSum / range.Length;
|
|
|
return DoubleFormat(moveAve);
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 求组内标准差
|
|
|
/// </summary>
|
|
|
/// <param name="size">子组容量</param>
|
|
|
/// <param name="originalData">原始数据</param>
|
|
|
/// <returns>返回组内标准差</returns>
|
|
|
public static Double GetInGroupStdDev(int size, Double[] originalData)
|
|
|
{
|
|
|
Double gourpStdDev = 0.0;
|
|
|
Double moveAve = GetMoveRangeMean(size, originalData);
|
|
|
switch (size)
|
|
|
{
|
|
|
case 2:
|
|
|
gourpStdDev = (Double)(moveAve / d2);
|
|
|
break;
|
|
|
case 3:
|
|
|
gourpStdDev = (Double)(moveAve / d3);
|
|
|
break;
|
|
|
case 4:
|
|
|
gourpStdDev = (Double)(moveAve / d4);
|
|
|
break;
|
|
|
case 5:
|
|
|
gourpStdDev = (Double)(moveAve / d5);
|
|
|
break;
|
|
|
default:
|
|
|
gourpStdDev = (Double)(moveAve / d2);
|
|
|
break;
|
|
|
}
|
|
|
return DoubleFormat(gourpStdDev);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取整体正态分布曲线数组值
|
|
|
/// </summary>
|
|
|
/// <param name="target">望目</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回整体正态分布曲线数组值</returns>
|
|
|
public static Dictionary<String, Object> GetNormalDistribution(Double target, Double[] original)
|
|
|
{
|
|
|
Dictionary<String, Object> json = new Dictionary<String, Object>();
|
|
|
Double sigma = GetTotalStdDev(original);
|
|
|
Double lcl = DoubleFormat(target - 3 * sigma);
|
|
|
Double ucl = DoubleFormat(target + 3 * sigma);
|
|
|
int idx = 10;
|
|
|
Double plus = 0.0;
|
|
|
plus = ((double)((int)(ucl - lcl + 1))) / 10;
|
|
|
Double[] categories = new Double[idx];
|
|
|
Double[] values = new Double[idx];
|
|
|
categories[0] = lcl;
|
|
|
for (int i = 1; i < idx; i++)
|
|
|
{
|
|
|
categories[i] = DoubleFormat(categories[i - 1] + plus);
|
|
|
}
|
|
|
for (int i = 0; i < idx; i++)
|
|
|
{
|
|
|
values[i] = 0.0;
|
|
|
}
|
|
|
for (int i = 1; i < categories.Length; i++)
|
|
|
{
|
|
|
values[i] = DoubleFormat(1
|
|
|
/ ((Math.Sqrt(2 * Math.PI) * GetTotalStdDev(original)))
|
|
|
* Math.Pow(
|
|
|
Math.E,
|
|
|
-Math.Pow((categories[i] - GetAverageValue(original)), 2)
|
|
|
/ (2 * Math
|
|
|
.Pow(GetTotalStdDev(original), 2))));
|
|
|
}
|
|
|
json.Add("categories", categories);
|
|
|
json.Add("values", values);
|
|
|
return json;
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取组内正态分布曲线数组值
|
|
|
/// </summary>
|
|
|
/// <param name="target">望目</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回组内正态分布曲线数组值</returns>
|
|
|
public static Dictionary<String, Object> GetInGroupNormalDistribution(Double target, Double[] original)
|
|
|
{
|
|
|
Dictionary<String, Object> json = new Dictionary<String, Object>();
|
|
|
Double sigma = GetTotalStdDev(original);
|
|
|
Double lcl = DoubleFormat(target - 3 * sigma);
|
|
|
Double ucl = DoubleFormat(target + 3 * sigma);
|
|
|
int idx = 10;
|
|
|
Double plus = 0.0;
|
|
|
plus = ((double)((int)(ucl - lcl + 1))) / 10;
|
|
|
Double[] categories = new Double[idx];
|
|
|
Double[] values = new Double[idx];
|
|
|
Double inGroupStdDev = GetInGroupStdDev(2, original);
|
|
|
Double ave = GetAverageValue(original);
|
|
|
categories[0] = lcl;
|
|
|
for (int i = 1; i < idx; i++)
|
|
|
{
|
|
|
categories[i] = DoubleFormat(categories[i - 1] + plus);
|
|
|
}
|
|
|
for (int i = 0; i < idx; i++)
|
|
|
{
|
|
|
values[i] = 0.000000;
|
|
|
}
|
|
|
for (int i = 1; i < categories.Length; i++)
|
|
|
{
|
|
|
values[i] = DoubleFormat(1
|
|
|
/ ((Math.Sqrt(2 * Math.PI) * inGroupStdDev))
|
|
|
* Math.Pow(
|
|
|
Math.E,
|
|
|
-Math.Pow((categories[i] - ave), 2)
|
|
|
/ (2 * Math.Pow(inGroupStdDev, 2))));
|
|
|
}
|
|
|
json.Add("categories", categories);
|
|
|
json.Add("values", values);
|
|
|
return json;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取数据分布情况
|
|
|
/// </summary>
|
|
|
/// <param name="target">望目</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回数据分布情况</returns>
|
|
|
public static Dictionary<String, Object> GetDataDistribution(Double target, Double[] original)
|
|
|
{
|
|
|
Dictionary<String, Object> json = new Dictionary<String, Object>();
|
|
|
Double sigma = GetTotalStdDev(original);
|
|
|
Double lcl = DoubleFormat(target - 3 * sigma);
|
|
|
Double ucl = DoubleFormat(target + 3 * sigma);
|
|
|
int idx = 10;
|
|
|
Double plus = 0.0;
|
|
|
plus = ((double)((int)(ucl - lcl + 1))) / 10;
|
|
|
Double[] categories = new Double[idx];
|
|
|
Double[] values = new Double[idx];
|
|
|
String[] test = new String[idx];
|
|
|
categories[0] = lcl;
|
|
|
for (int i = 1; i < idx; i++)
|
|
|
{
|
|
|
categories[i] = DoubleFormat(categories[i - 1] + plus);
|
|
|
}
|
|
|
for (int i = 0; i < idx; i++)
|
|
|
{
|
|
|
values[i] = 0.0;
|
|
|
test[i] = "";
|
|
|
}
|
|
|
for (int i = 0; i < original.Length; i++)
|
|
|
{
|
|
|
for (int j = 0; j < categories.Length; j++)
|
|
|
{
|
|
|
if (categories[j] - 0.5 < original[i] && original[i] <= categories[j] + 0.5)
|
|
|
{
|
|
|
values[j] += 1;
|
|
|
test[j] += original[i] + ",";
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
for (int i = 0; i < idx; i++)
|
|
|
{
|
|
|
values[i] = values[i] / 100;
|
|
|
}
|
|
|
json.Add("categories", categories);
|
|
|
json.Add("values", values);
|
|
|
return json;
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 无偏移过程能力指数
|
|
|
/// </summary>
|
|
|
/// <param name="upperT">公差上限</param>
|
|
|
/// <param name="lowerT">公差下限</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回无偏移过程能力指数</returns>
|
|
|
public static Double GetPP(Double upperT, Double lowerT, Double[] original)
|
|
|
{
|
|
|
Double pp = new Double();
|
|
|
Double sigma = GetTotalStdDev(original);
|
|
|
pp = (upperT - lowerT) / (6 * sigma);
|
|
|
return DoubleFormat(pp);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 无偏移下单限过程能力指数
|
|
|
/// </summary>
|
|
|
/// <param name="lowerT">公差下限</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回无偏移下单限过程能力指数</returns>
|
|
|
public static Double GetPPL(Double lowerT, Double[] original)
|
|
|
{
|
|
|
Double ppl = new Double();
|
|
|
Double sigma = GetTotalStdDev(original);
|
|
|
Double ave = GetAverageValue(original);
|
|
|
ppl = (ave - lowerT) / (3 * sigma);
|
|
|
return DoubleFormat(ppl);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 无偏移上单限过程能力指数
|
|
|
/// </summary>
|
|
|
/// <param name="upperT">公差上限</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回无偏移上单限过程能力指数</returns>
|
|
|
public static Double GetPPU(Double upperT, Double[] original)
|
|
|
{
|
|
|
Double ppl = new Double();
|
|
|
Double sigma = GetTotalStdDev(original);
|
|
|
Double ave = GetAverageValue(original);
|
|
|
ppl = (upperT - ave) / (3 * sigma);
|
|
|
return DoubleFormat(ppl);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 有偏移过程能力指数
|
|
|
/// </summary>
|
|
|
/// <param name="upperT">公差上限</param>
|
|
|
/// <param name="lowerT">公差下限</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回有偏移过程能力指数</returns>
|
|
|
public static Double getPPK(Double upperT, Double lowerT, Double[] original)
|
|
|
{
|
|
|
Double ppl = GetPPL(lowerT, original);
|
|
|
Double ppu = GetPPU(upperT, original);
|
|
|
return DoubleFormat(ppl > ppu ? ppu : ppl);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 无偏移短期过程能力指数
|
|
|
/// </summary>
|
|
|
/// <param name="upperT">公差上限</param>
|
|
|
/// <param name="lowerT">公差下限</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回无偏移短期过程能力指数</returns>
|
|
|
public static Double GetInGroupCP(Double upperT, Double lowerT, Double[] original)
|
|
|
{
|
|
|
Double cp = new Double();
|
|
|
Double sigma = GetInGroupStdDev(2, original);
|
|
|
if (sigma == 0)
|
|
|
{
|
|
|
cp = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cp = (upperT - lowerT) / (6 * sigma);
|
|
|
}
|
|
|
|
|
|
return DoubleFormat(cp);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 无偏移下单限短期过程能力指数
|
|
|
/// </summary>
|
|
|
/// <param name="lowerT">公差下限</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回无偏移下单限短期过程能力指数</returns>
|
|
|
public static Double GetInGroupCPL(Double lowerT, Double[] original)
|
|
|
{
|
|
|
Double cpl = new Double();
|
|
|
Double sigma = GetInGroupStdDev(2, original);
|
|
|
if (sigma == 0)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Double ave = GetAverageValue(original);
|
|
|
cpl = (ave - lowerT) / (3 * sigma);
|
|
|
return DoubleFormat(cpl);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 无偏移上单限短期过程能力指数
|
|
|
/// </summary>
|
|
|
/// <param name="upperT">公差上限</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>反回无偏移上单限短期过程能力指数</returns>
|
|
|
public static Double GetInGroupCPU(Double upperT, Double[] original)
|
|
|
{
|
|
|
Double cpu = new Double();
|
|
|
Double sigma = GetInGroupStdDev(2, original);
|
|
|
if (sigma == 0)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Double ave = GetAverageValue(original);
|
|
|
cpu = (upperT - ave) / (3 * sigma);
|
|
|
return DoubleFormat(cpu);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 有偏移短期过程能力指数
|
|
|
/// </summary>
|
|
|
/// <param name="upperT">公差上限</param>
|
|
|
/// <param name="lowerT">公差下限</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回有偏移短期过程能力指数</returns>
|
|
|
public static Double GetInGroupCPK(Double upperT, Double lowerT, Double[] original)
|
|
|
{
|
|
|
Double cpl = GetInGroupCPL(lowerT, original);
|
|
|
Double cpu = GetInGroupCPU(upperT, original);
|
|
|
return DoubleFormat(cpl > cpu ? cpu : cpl);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 自然上限
|
|
|
/// </summary>
|
|
|
/// <param name="target">望目</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回自然上限</returns>
|
|
|
public static Double GetUCL(Double target, Double[] original)
|
|
|
{
|
|
|
Double sigma = GetTotalStdDev(original);
|
|
|
return DoubleFormat(target + 3 * sigma);
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 自然下限
|
|
|
/// </summary>
|
|
|
/// <param name="target">望目</param>
|
|
|
/// <param name="original">原始数据</param>
|
|
|
/// <returns>返回自然下限</returns>
|
|
|
public static Double GetLCL(Double target, Double[] original)
|
|
|
{
|
|
|
Double sigma = GetTotalStdDev(original);
|
|
|
return DoubleFormat(target - 3 * sigma);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 最小值
|
|
|
/// </summary>
|
|
|
/// <param name="array">原始数据数组</param>
|
|
|
/// <returns>返回最小值</returns>
|
|
|
public static Double GetArrMin(Double[] array)
|
|
|
{
|
|
|
Double min = array[0];
|
|
|
for (int i = 0; i < array.Length; i++)
|
|
|
{
|
|
|
if (min > array[i])
|
|
|
min = array[i];
|
|
|
}
|
|
|
return min;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 最大值
|
|
|
/// </summary>
|
|
|
/// <param name="array">原始数据数组</param>
|
|
|
/// <returns>返回最大值</returns>
|
|
|
public static Double GetArrMax(Double[] array)
|
|
|
{
|
|
|
Double max = array[0];
|
|
|
for (int i = 0; i < array.Length; i++)
|
|
|
{
|
|
|
if (max < array[i])
|
|
|
max = array[i];
|
|
|
}
|
|
|
return max;
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 数据格式化，默认保留5位小数
|
|
|
/// </summary>
|
|
|
/// <param name="d">要格式化的数据</param>
|
|
|
/// <returns>返回格式化后的数据</returns>
|
|
|
public static Double DoubleFormat(Double d)
|
|
|
{
|
|
|
double result = 0.0;
|
|
|
if (double.TryParse(d.ToString(), out result))
|
|
|
{
|
|
|
Decimal b = new Decimal(d);
|
|
|
Double formatD = Convert.ToDouble(Math.Round(b, 5));
|
|
|
//b.setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
|
|
|
return formatD;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return 0.0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 按指定精度进行数据格式化
|
|
|
/// </summary>
|
|
|
/// <param name="digits">精度，小数位数</param>
|
|
|
/// <param name="d">要格式化的数据</param>
|
|
|
/// <returns>返回格式化后的数据</returns>
|
|
|
public static Double DoubleFormat(int digits, Double d)
|
|
|
{
|
|
|
double result = 0.0;
|
|
|
if (double.TryParse(d.ToString(), out result))
|
|
|
{
|
|
|
Decimal b = new Decimal(d);
|
|
|
Double formatD = Convert.ToDouble(Math.Round(b, digits));
|
|
|
//Double formatD = b.setScale(digits, BigDecimal.ROUND_HALF_UP).doubleValue();
|
|
|
return formatD;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return 0.0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|