आइए कहते हैं कि मेरे पास 3.4679 का मान है और 3.46 चाहते हैं, मैं दो दशमलव स्थानों पर कैसे घूम सकता हूं जो बिना गोल किए?
मैंने निम्नलिखित कोशिश की है, लेकिन तीनों ने मुझे 3.47 दिए:
void Main()
{
Console.Write(Math.Round(3.4679, 2,MidpointRounding.ToEven));
Console.Write(Math.Round(3.4679, 2,MidpointRounding.AwayFromZero));
Console.Write(Math.Round(3.4679, 2));
}यह 3.46 देता है, लेकिन अभी कुछ गंदा लगता है:
void Main()
{
Console.Write(Math.Round(3.46799999999 -.005 , 2));
}जवाबों:
value = Math.Truncate(100 * value) / 100;इस बात से सावधान रहें कि इन जैसे अंशों को फ्लोटिंग पॉइंट में सही ढंग से दर्शाया नहीं जा सकता है।
C # में दशमलव को छोटा करने के वास्तविक-विश्व उपयोग के लिए एक पूर्ण कार्य करना अधिक उपयोगी होगा। यदि आप चाहते हैं तो इसे दशमलव विस्तार विधि में परिवर्तित किया जा सकता है:
public decimal TruncateDecimal(decimal value, int precision)
{
decimal step = (decimal)Math.Pow(10, precision);
decimal tmp = Math.Truncate(step * value);
return tmp / step;
}यदि आपको VB.NET की आवश्यकता है तो यह प्रयास करें:
Function TruncateDecimal(value As Decimal, precision As Integer) As Decimal
Dim stepper As Decimal = Math.Pow(10, precision)
Dim tmp As Decimal = Math.Truncate(stepper * value)
Return tmp / stepper
End Functionफिर इसे इस तरह उपयोग करें:
decimal result = TruncateDecimal(0.275, 2);या
Dim result As Decimal = TruncateDecimal(0.275, 2)मापांक ऑपरेटर का उपयोग करें:
var fourPlaces = 0.5485M;
var twoPlaces = fourPlaces - (fourPlaces % 0.01M);परिणाम: 0.54
0.5400... डी। नेस्टरोव द्वारा जवाब का उत्पादन अपेक्षित था 0.54।
$"{0.54m:C}"उत्पादन करता है "$0.54"और हां, $"{0.5400m:C}"उत्पादन करता है "$0.54"।
यूनिवर्सल और फास्ट विधि (बिना Math.Pow()/ गुणा) के लिए System.Decimal:
decimal Truncate(decimal d, byte decimals)
{
decimal r = Math.Round(d, decimals);
if (d > 0 && r > d)
{
return r - new decimal(1, 0, 0, false, decimals);
}
else if (d < 0 && r < d)
{
return r + new decimal(1, 0, 0, false, decimals);
}
return r;
}अन्य उदाहरणों के साथ एक मुद्दा यह है कि वे इसे विभाजित करने से पहले इनपुट मूल्य को गुणा करते हैं। यहां एक किनारे का मामला है जिसे आप पहले, एक किनारे के मामले में गुणा करके दशमलव को ओवरफ्लो कर सकते हैं, लेकिन कुछ मैं भर आया हूं। यह भिन्न रूप से आंशिक भाग से निपटने के लिए सुरक्षित है:
public static decimal TruncateDecimal(this decimal value, int decimalPlaces)
{
decimal integralValue = Math.Truncate(value);
decimal fraction = value - integralValue;
decimal factor = (decimal)Math.Pow(10, decimalPlaces);
decimal truncatedFraction = Math.Truncate(fraction * factor) / factor;
decimal result = integralValue + truncatedFraction;
return result;
}मैं दशमलव संख्या के लिए समाधान छोड़ दूंगा।
यहाँ दशमलव के कुछ समाधान अतिप्रवाह के लिए प्रवण हैं (यदि हम एक बहुत बड़ी दशमलव संख्या पास करते हैं और विधि इसे गुणा करने की कोशिश करेगी)।
टिम लॉयड का समाधान अतिप्रवाह से सुरक्षित है लेकिन यह बहुत तेज़ नहीं है।
निम्नलिखित समाधान लगभग 2 गुना तेज है और इसमें अतिप्रवाह की समस्या नहीं है:
public static class DecimalExtensions
{
public static decimal TruncateEx(this decimal value, int decimalPlaces)
{
if (decimalPlaces < 0)
throw new ArgumentException("decimalPlaces must be greater than or equal to 0.");
var modifier = Convert.ToDecimal(0.5 / Math.Pow(10, decimalPlaces));
return Math.Round(value >= 0 ? value - modifier : value + modifier, decimalPlaces);
}
}
[Test]
public void FastDecimalTruncateTest()
{
Assert.AreEqual(-1.12m, -1.129m. TruncateEx(2));
Assert.AreEqual(-1.12m, -1.120m. TruncateEx(2));
Assert.AreEqual(-1.12m, -1.125m. TruncateEx(2));
Assert.AreEqual(-1.12m, -1.1255m.TruncateEx(2));
Assert.AreEqual(-1.12m, -1.1254m.TruncateEx(2));
Assert.AreEqual(0m, 0.0001m.TruncateEx(3));
Assert.AreEqual(0m, -0.0001m.TruncateEx(3));
Assert.AreEqual(0m, -0.0000m.TruncateEx(3));
Assert.AreEqual(0m, 0.0000m.TruncateEx(3));
Assert.AreEqual(1.1m, 1.12m. TruncateEx(1));
Assert.AreEqual(1.1m, 1.15m. TruncateEx(1));
Assert.AreEqual(1.1m, 1.19m. TruncateEx(1));
Assert.AreEqual(1.1m, 1.111m. TruncateEx(1));
Assert.AreEqual(1.1m, 1.199m. TruncateEx(1));
Assert.AreEqual(1.2m, 1.2m. TruncateEx(1));
Assert.AreEqual(0.1m, 0.14m. TruncateEx(1));
Assert.AreEqual(0, -0.05m. TruncateEx(1));
Assert.AreEqual(0, -0.049m. TruncateEx(1));
Assert.AreEqual(0, -0.051m. TruncateEx(1));
Assert.AreEqual(-0.1m, -0.14m. TruncateEx(1));
Assert.AreEqual(-0.1m, -0.15m. TruncateEx(1));
Assert.AreEqual(-0.1m, -0.16m. TruncateEx(1));
Assert.AreEqual(-0.1m, -0.19m. TruncateEx(1));
Assert.AreEqual(-0.1m, -0.199m. TruncateEx(1));
Assert.AreEqual(-0.1m, -0.101m. TruncateEx(1));
Assert.AreEqual(0m, -0.099m. TruncateEx(1));
Assert.AreEqual(0m, -0.001m. TruncateEx(1));
Assert.AreEqual(1m, 1.99m. TruncateEx(0));
Assert.AreEqual(1m, 1.01m. TruncateEx(0));
Assert.AreEqual(-1m, -1.99m. TruncateEx(0));
Assert.AreEqual(-1m, -1.01m. TruncateEx(0));
}Truncateतरीके को .net मूल लोगों के साथ मिलकर बनाया जाएगा, जिससे उपयोगकर्ता को एक सहज अनुभव मिलेगा।
Assert.AreEqual(1.1m, 1.12m.TruncateEx(1));इसके कारण विफल रहता है। यदि आप Math.Round कॉल में "सामान्य" गोलाई (AwayFromZero) को निर्दिष्ट करते हैं, तो Assert.AreEqual(0m, 0m.TruncateEx(1));विफल हो जाता है
MidpointRounding.AwayFromZeroऔर विशेष रूप से मान को संभालने के लिए विशेष रूप से कोड 0.
यह एक पुराना सवाल है, लेकिन कई खिलाड़ी बड़ी संख्या में अच्छा प्रदर्शन नहीं कर पाते हैं। मुझे लगता है कि डी। नेस्टरोव का उत्तर सबसे अच्छा है: मजबूत, सरल और तेज। मैं सिर्फ अपने दो सेंट जोड़ना चाहता हूं। मैंने दशमलव के साथ खेला और स्रोत कोड भी देखा । से public Decimal (int lo, int mid, int hi, bool isNegative, byte scale) निर्माता प्रलेखन ।
दशमलव संख्या के द्विआधारी प्रतिनिधित्व में 1-बिट संकेत, 96-बिट पूर्णांक संख्या और पूर्णांक संख्या को विभाजित करने के लिए उपयोग किया जाने वाला स्केलिंग कारक होता है और यह निर्दिष्ट करता है कि इसका कौन सा भाग दशमलव अंश है। स्केलिंग फैक्टर अनुमानित संख्या 10 है जो एक एक्सपोनेंट से 0 से 28 तक है।
यह जानकर, मेरा पहला दृष्टिकोण एक और बनाना था decimalजिसका पैमाना उन दशमलवों से मेल खाता है जिन्हें मैं त्यागना चाहता था, फिर इसे काटकर अंत में वांछित पैमाने के साथ एक दशमलव बनाएं।
private const int ScaleMask = 0x00FF0000;
public static Decimal Truncate(decimal target, byte decimalPlaces)
{
var bits = Decimal.GetBits(target);
var scale = (byte)((bits[3] & (ScaleMask)) >> 16);
if (scale <= decimalPlaces)
return target;
var temporalDecimal = new Decimal(bits[0], bits[1], bits[2], target < 0, (byte)(scale - decimalPlaces));
temporalDecimal = Math.Truncate(temporalDecimal);
bits = Decimal.GetBits(temporalDecimal);
return new Decimal(bits[0], bits[1], bits[2], target < 0, decimalPlaces);
}यह विधि डी। नेस्टरोव की तुलना में तेज़ नहीं है और यह अधिक जटिल है, इसलिए मैंने थोड़ा और अधिक खेला। मेरा अनुमान है कि एक परिचित बनाने decimalऔर दो बार बिट्स को पुनर्प्राप्त करने से यह धीमा हो रहा है। अपने दूसरे प्रयास में, मैंने Decimal.GetBits (Decimal d) विधि द्वारा वापस लौटाए गए घटकों में हेरफेर किया । विचार 10 से घटकों को आवश्यकतानुसार विभाजित करने और पैमाने को कम करने का है। कोड Decimal.InternalRoundFromZero (Ref Decimal d, int दशमलव) पद्धति पर आधारित (भारी) है ।
private const Int32 MaxInt32Scale = 9;
private const int ScaleMask = 0x00FF0000;
private const int SignMask = unchecked((int)0x80000000);
// Fast access for 10^n where n is 0-9
private static UInt32[] Powers10 = new UInt32[] {
1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000
};
public static Decimal Truncate(decimal target, byte decimalPlaces)
{
var bits = Decimal.GetBits(target);
int lo = bits[0];
int mid = bits[1];
int hi = bits[2];
int flags = bits[3];
var scale = (byte)((flags & (ScaleMask)) >> 16);
int scaleDifference = scale - decimalPlaces;
if (scaleDifference <= 0)
return target;
// Divide the value by 10^scaleDifference
UInt32 lastDivisor;
do
{
Int32 diffChunk = (scaleDifference > MaxInt32Scale) ? MaxInt32Scale : scaleDifference;
lastDivisor = Powers10[diffChunk];
InternalDivRemUInt32(ref lo, ref mid, ref hi, lastDivisor);
scaleDifference -= diffChunk;
} while (scaleDifference > 0);
return new Decimal(lo, mid, hi, (flags & SignMask)!=0, decimalPlaces);
}
private static UInt32 InternalDivRemUInt32(ref int lo, ref int mid, ref int hi, UInt32 divisor)
{
UInt32 remainder = 0;
UInt64 n;
if (hi != 0)
{
n = ((UInt32)hi);
hi = (Int32)((UInt32)(n / divisor));
remainder = (UInt32)(n % divisor);
}
if (mid != 0 || remainder != 0)
{
n = ((UInt64)remainder << 32) | (UInt32)mid;
mid = (Int32)((UInt32)(n / divisor));
remainder = (UInt32)(n % divisor);
}
if (lo != 0 || remainder != 0)
{
n = ((UInt64)remainder << 32) | (UInt32)lo;
lo = (Int32)((UInt32)(n / divisor));
remainder = (UInt32)(n % divisor);
}
return remainder;
}मैंने कठोर प्रदर्शन परीक्षण नहीं किए हैं, लेकिन MacOS Sierra 10.12.6, 3,06 GHz Intel Core i3 प्रोसेसर और लक्ष्यीकरण .NetCore 2.1 पर यह विधि D. Nesterov's की तुलना में बहुत तेज़ प्रतीत होती है (क्योंकि मैं नंबर नहीं दूंगा। , जैसा कि मैंने उल्लेख किया है, मेरे परीक्षण कठोर नहीं हैं)। यह इस पर निर्भर करता है कि प्रदर्शन कोड लाभ जटिलता के लिए भुगतान करते हैं या नहीं, इसका मूल्यांकन करने के लिए इसे कौन लागू करता है।
यदि आप प्रदर्शन के बारे में बहुत अधिक चिंता नहीं करते हैं और आपका अंतिम परिणाम एक स्ट्रिंग हो सकता है, तो निम्नलिखित दृष्टिकोण अस्थायी सटीक मुद्दों के लिए लचीला होगा:
string Truncate(double value, int precision)
{
if (precision < 0)
{
throw new ArgumentOutOfRangeException("Precision cannot be less than zero");
}
string result = value.ToString();
int dot = result.IndexOf('.');
if (dot < 0)
{
return result;
}
int newLength = dot + precision + 1;
if (newLength == dot + 1)
{
newLength--;
}
if (newLength > result.Length)
{
newLength = result.Length;
}
return result.Substring(0, newLength);
}यहां TRUNC फ़ंक्शन का मेरा कार्यान्वयन है
private static object Tranc(List<Expression.Expression> p)
{
var target = (decimal)p[0].Evaluate();
// check if formula contains only one argument
var digits = p.Count > 1
? (decimal) p[1].Evaluate()
: 0;
return Math.Truncate((double)target * Math.Pow(10, (int)digits)) / Math.Pow(10, (int)digits);
}इस बारे में क्या?
Function TruncateDecimal2(MyValue As Decimal) As Decimal
Try
Return Math.Truncate(100 * MyValue) / 100
Catch ex As Exception
Return Math.Round(MyValue, 2)
End Try
End Functionउपरोक्त समाधानों के अलावा, एक और तरीका है जिसे हम प्राप्त कर सकते हैं।
decimal val=23.5678m,finalValue;
//take the decimal part
int decimalPos = val.ToString().IndexOf('.');
string decimalPart = val.ToString().Substring(decimalPosition+1,val.ToString().Length);
//will result.56
string wholePart=val.ToString().Substring(0,decimalPos-1);
//concantinate and parse for decimal.
string truncatedValue=wholePart+decimalPart;//"23.56"
bool isDecimal=Decimal.tryParse(truncatedValue,out finalValue);//finalValue=23.56कुछ शर्तों के तहत यह पर्याप्त हो सकता है।
मेरे पास उप-अंक = 0.0099999999999999999999999999M का एक दशमलव मान है
जो प्रारूप में जाता है । उप-वर्ग: 0.010000 | के माध्यम से string.Format("{0:N6}", SubCent );और कई अन्य स्वरूपण विकल्प।
मेरी आवश्यकता उप-मूल्य को गोल करने के लिए नहीं थी, लेकिन हर अंक को लॉग न करें।
निम्नलिखित मेरी आवश्यकता को पूरा किया:
string.Format("SubCent:{0}|",
SubCent.ToString("N10", CultureInfo.InvariantCulture).Substring(0, 9));जो स्ट्रिंग लौटाता है: | उप-सहायक: 0.0099999 |
एक पूर्णांक भाग वाले मान को समायोजित करने के लिए निम्नलिखित एक शुरुआत है।
tmpValFmt = 567890.0099999933999229999999M.ToString("0.0000000000000000000000000000");
decPt = tmpValFmt.LastIndexOf(".");
if (decPt < 0) decPt = 0;
valFmt4 = string.Format("{0}", tmpValFmt.Substring(0, decPt + 9));जो स्ट्रिंग लौटाता है:
valFmt4 = "567890.00999999"मैं एक स्ट्रिंग चर में दशमलव के बाद मूल्य को कम करने के लिए इस फ़ंक्शन का उपयोग कर रहा हूं
public static string TruncateFunction(string value)
{
if (string.IsNullOrEmpty(value)) return "";
else
{
string[] split = value.Split('.');
if (split.Length > 0)
{
string predecimal = split[0];
string postdecimal = split[1];
postdecimal = postdecimal.Length > 6 ? postdecimal.Substring(0, 6) : postdecimal;
return predecimal + "." + postdecimal;
}
else return value;
}
}यह जो मैंने किया है:
c1 = a1 - b1;
d1 = Math.Ceiling(c1 * 100) / 100;दशमलव के ऊपर या नीचे गोल किए बिना दो इनपुट संख्याओं को घटाना। क्योंकि दूसरे उपाय मेरे काम नहीं आते। पता नहीं कि यह दूसरों के लिए काम करेगा, मैं इसे साझा करना चाहता हूं :) आशा है कि यह उन लोगों के लिए काम करता है जो मेरी जैसी समस्या का समाधान खोज रहे हैं। धन्यवाद
पुनश्च: मैं एक शुरुआत कर रहा हूँ ताकि इस पर कुछ इंगित करने के लिए स्वतंत्र महसूस हो। : D यह अच्छा है यदि आप वास्तव में पैसे के साथ काम कर रहे हैं, तो सेंट ठीक है? इसमें केवल 2 दशमलव स्थान हैं और इसे गोल करना एक नहीं है।
public static void ReminderDigints(decimal? number, out decimal? Value, out decimal? Reminder)
{
Reminder = null;
Value = null;
if (number.HasValue)
{
Value = Math.Floor(number.Value);
Reminder = (number - Math.Truncate(number.Value));
}
}
decimal? number= 50.55m;
ReminderDigints(number, out decimal? Value, out decimal? Reminder);public static decimal TruncateDecimalPlaces(this decimal value, int precision)
{
try
{
step = (decimal)Math.Pow(10, precision);
decimal tmp = Math.Truncate(step * value);
return tmp / step;
}
catch (OverflowException)
{
step = (decimal)Math.Pow(10, -1 * precision);
return value - (value % step);
}
}वास्तव में आप 3.4679 से 3.46 चाहते हैं। यह केवल वर्णों का प्रतिनिधित्व है। इसके अलावा गणित के कार्य से कोई लेना-देना नहीं है। इस कार्य को करने का इरादा नहीं है। बस निम्नलिखित कोड का उपयोग करें।
Dim str1 As String
str1=""
str1 ="3.4679"
Dim substring As String = str1.Substring(0, 3)
' Write the results to the screen.
Console.WriteLine("Substring: {0}", substring)
Or
Please use the following code.
Public function result(ByVal x1 As Double) As String
Dim i as Int32
i=0
Dim y as String
y = ""
For Each ch as Char In x1.ToString
If i>3 then
Exit For
Else
y + y +ch
End if
i=i+1
Next
return y
End Functionउपरोक्त कोड को किसी भी संख्या के लिए संशोधित किया जा सकता है। निम्नलिखित कोड को एक बटन क्लिक घटना में डालें
Dim str As String
str= result(3.4679)
MsgBox("The number is " & str)