Go Decimal Package, स्थायी-शुद्धता वाले दशमलव संख्या की गणना में परिशुद्धता हानि समस्या का समाधान।

1. परिचय

Go Decimal पुस्तकालय Go भाषा में अनिश्चित दशमलव स्थिरांक दशमलवों को संभालने के लिए एक शक्तिशाली उपकरण है। यह योग, घटाव, गुणा, और भाग के लिए समर्थन प्रदान करता है बिना पुनर्नयन के। साथ ही, यह डेटाबेस/SQL सेरियलाइजेशन/डीसीरियलाइजेशन, तथा JSON/XML सीरियलाइजेशन/डीसीरियलाइजेशन जैसी विशेषताएँ भी प्रदान करता है।

2. स्थापना

Go Decimal पुस्तकालय को स्थापित करने के लिए, आप निम्नलिखित कमांड का उपयोग कर सकते हैं:

go get github.com/shopspring/decimal

कृपया ध्यान दें कि दशमलव पुस्तकालय को Go संस्करण >=1.7 की आवश्यकता है।

3. मौलिक उपयोग

Go प्रोग्राम में Decimal पुस्तकालय का उपयोग करने के लिए, "github.com/shopspring/decimal" पैकेज को आयात करें। यहां एक सरल उदाहरण कोड है जो मौलिक उपयोग को दर्शाता है:

package main

import (
	"fmt"
	"github.com/shopspring/decimal"
)

func main() {
	price, err := decimal.NewFromString("136.02")
	if err != nil {
		panic(err)
	}

	quantity := decimal.NewFromInt(3)

	fee, _ := decimal.NewFromString(".035")
	taxRate, _ := decimal.NewFromString(".08875")

	subtotal := price.Mul(quantity)
	preTax := subtotal.Mul(fee).Add(decimal.NewFromFloat(1))
	total := preTax.Mul(taxRate).Add(decimal.NewFromFloat(1))

fmt.Println("उप-योग-धन:", subtotal)                  // Subtotal: 408.06
fmt.Println("प्री-कर:", preTax)                     // Pre-tax: 422.3421
fmt.Println("कर:", total.Sub(preTax))            // Taxes: 37.482861375
fmt.Println("कुल:", total)                         // Total: 459.824961375
fmt.Println("कर दर:", total.Sub(preTax).Div(preTax)) // Tax rate: 0.08875
}

4. दशमलव चर परिपत्रक बनाना

दशमलव पुस्तकालय दशमलव चर बनाने के लिए विभिन्न विधियों प्रदान करती है। निम्नलिखित API समर्थित हैं:

• decimal.NewFromBigInt(value *big.Int, exp int32) Decimal
• decimal.NewFromFloat(value float64) Decimal
• decimal.NewFromFloat32(value float32) Decimal
• decimal.NewFromFloatWithExponent(value float64, exp int32) Decimal
• decimal.NewFromFormattedString(value string, replRegexp *regexp.Regexp) (Decimal, error)
• decimal.NewFromInt(value int64) Decimal
• decimal.NewFromInt32(value int32) Decimal
• decimal.NewFromString(value string) (Decimal, error)
• decimal.RequireFromString(value string) Decimal

5. अंकगणितीय कार्य

Go Decimal पुस्तकालय द्वारा कई अंकगणितीय कार्य प्राप्त किए जा सकते हैं जो दशमलव चरों पर किया जा सकता है। यहां कुछ समर्थित कार्य हैं:

• Add(d2 Decimal) Decimal: दो दशमलव मानों को जोड़ता है और परिणाम लौटाता है।
• Sub(d2 Decimal) Decimal: एक दशमलव मान से दूसरे को घटाता है और परिणाम लौटाता है।
• Div(d2 Decimal) Decimal: एक दशमलव मान को दूसरे से विभाजित करता है और परिणाम लौटाता है।
• DivRound(d2 Decimal, precision int32) Decimal: एक दशमलव मान को दूसरे से विभाजित करता है और निर्दिष्ट परिप्रेक्ष्य संगति के साथ परिणाम लौटाता है।
• Mod(d2 Decimal) Decimal: दो दशमलव मानों को विभाजित करने पर शेष (शेष) की गणना करता है और परिणाम लौटाता है।
• Mul(d2 Decimal) Decimal: दो दशमलव मानों को गुणा करता है और परिणाम लौटाता है।

आप इन कार्यों का उपयोग दशमलव मानों पर सामान्य अंकगणितीय गणनाओं को करने के लिए कर सकते हैं। यहां एक उदाहरण है जो इन कार्यों का उपयोग करते हुए दिखाता है:

price, _ := decimal.NewFromString("136.02")
quantity := decimal.NewFromInt(3)

subtotal := price.Mul(quantity)
tax := subtotal.Mul(decimal.NewFromFloat(0.08875))

total := subtotal.Add(tax)

fmt.Println("उप-योग-धन:", subtotal) // Subtotal: 408.06
fmt.Println("कर:", tax)           // Tax: 36.244985
fmt.Println("कुल:", total)       // Total: 444.304985

6. गोलमाल कार्य

गोलमाल दशमलव पुस्तकालय एक कई गोलमाल कार्य प्रदान करती है जो एक निर्दिष्ट सटीकता तक गोलीय मूल्यों को गोल करने के लिए इस्तेमाल किए जा सकते हैं। यहां कुछ उपलब्ध गोल करने के कार्य हैं:

• Round(places int32) Decimal: दशमलव को निर्दिष्ट संख्या के दशमलव स्थानों तक गोल करता है।
• RoundBank(places int32) Decimal: दशमलव को बैंकर गोलियों का उपयोग करके निर्दिष्ट संख्या के दशमलव स्थानों तक गोल करता है।
• RoundCash(interval uint8) Decimal: दशमलव को निर्दिष्ट इंटरवल, जैसे 5 सेंट्स, 10 सेंट्स, 25 सेंट्स, 50 सेंट्स, या 1 डॉलर,के लिए गोल करता है।
• RoundCeil(places int32) Decimal: दशमलव को सकारात्मक अनंतता की ओर गोल करता है।
• RoundDown(places int32) Decimal: दशमलव को शून्य की ओर गोल करता है।
• RoundFloor(places int32) Decimal: दशमलव को नकारात्मक अनंतता की ओर गोल करता है।
• RoundUp(places int32) Decimal: दशमलव को शून्य से दूर करता है।

6.1. गोल

गोल दशमलव को निर्दिष्ट संख्या के दशमलव स्थानों तक गोल करता है। यदि स्थान < 0, तो यह पाँचवीं श्रेणी को सटीकता तक गोल करेगा।

NewFromFloat(5.45).Round(1).String() // Output: "5.5"
NewFromFloat(545).Round(-1).String() // Output: "550"

6.2. गोलबैंक

गोलबैंक दशमलव को स्थान दशमलव की ओर गोल करता है। यदि गोलियों की सबसे निकटतम दो दो संख्याओं के बीच दूरी समान है, तो गोली हुई मूल्य जोड़ी गई संख्या का आदान रखती है।

यदि स्थान < 0 है, तो पूर्णांक भाग को निकटतम 10^(-स्थान) तक गोलेगा।

NewFromFloat(5.45).RoundBank(1).String() // Output: "5.4"
NewFromFloat(545).RoundBank(-1).String() // Output: "540"
NewFromFloat(5.46).RoundBank(1).String() // Output: "5.5"
NewFromFloat(546).RoundBank(-1).String() // Output: "550"
NewFromFloat(5.55).RoundBank(1).String() // Output: "5.6"
NewFromFloat(555).RoundBank(-1).String() // Output: "560"

6.3. गोलकैश

गोलकैश (जिसे कैश/पैसा/आइरिश गोलियों के रूप में भी जाना जाता है) दशमलव को विशेष अंतरालों तक गोल करता है। किसी कैश लेन-देन के देय राशि को सबसे छोटे मुद्रा इकाई के सटीकांक के निकटतम अनुपात के पास गोल किया जाएगा। उपलब्ध अंतराल हैं: 5, 10, 25, 50, और 100; किसी अन्य संख्या से अपवाद होगा।

  5:   5 cents rounding 3.43 => 3.45
 10:  10 cents rounding 3.45 => 3.50 (5 is rounded up)
 25:  25 cents rounding 3.41 => 3.50
 50:  50 cents rounding 3.75 => 4.00
100: 100 cents rounding 3.50 => 4.00

6.4. गोलसील

गोलसील दशमलव को सकारात्मक अनंतता की ओर गोल करता है।

NewFromFloat(545).RoundCeil(-2).String()   // Output: "600"
NewFromFloat(500).RoundCeil(-2).String()   // Output: "500"
NewFromFloat(1.1001).RoundCeil(2).String() // Output: "1.11"
NewFromFloat(-1.454).RoundCeil(1).String() // Output: "-1.5"

6.5. गोलडाउन

गोलडाउन दशमलव को शून्य की ओर गोल करता है।

NewFromFloat(545).RoundDown(-2).String()   // Output: "500"
NewFromFloat(-500).RoundDown(-2).String()   // Output: "-500"
NewFromFloat(1.1001).RoundDown(2).String() // Output: "1.1"
NewFromFloat(-1.454).RoundDown(1).String() // Output: "-1.5"

6.6. RoundFloor

RoundFloor दशमलव को नकारात्मक अनंतता की दिशा में गोल करता है।

NewFromFloat(545).RoundFloor(-2).String()   // Output: "500"
NewFromFloat(-500).RoundFloor(-2).String()   // Output: "-500"
NewFromFloat(1.1001).RoundFloor(2).String() // Output: "1.1"
NewFromFloat(-1.454).RoundFloor(1).String() // Output: "-1.4"

6.7. RoundUp

RoundUp दशमलव को शून्य से दूर गोल करता है।

NewFromFloat(545).RoundUp(-2).String()   // Output: "600"
NewFromFloat(500).RoundUp(-2).String()   // Output: "500"
NewFromFloat(1.1001).RoundUp(2).String() // Output: "1.11"
NewFromFloat(-1.454).RoundUp(1).String() // Output: "-1.4"

7. दशमलव प्रकार को स्ट्रिंग में परिवर्तित करें

Go दशमलव पुस्तकालय स्ट्रिंग प्रस्तुतियों को दशमलव मूल्यों से स्ट्रिंग प्रस्तुतियों में परिवर्तित करने के लिए विधियां प्रदान करती है। यहां कुछ उपलब्ध विधियां हैं:

• String(): string: निश्चित दशमलव बिंदु के साथ दशमलव संख्या की स्ट्रिंग प्रस्तुति लौटाता है।
• StringFixed(places int32) string: निर्दिष्ट दशमलव स्थानों के साथ गोली गई स्ट्रिंग प्रस्तुति लौटाता है।
• StringFixedBank(places int32) string: निर्दिष्ट दशमलव स्थानों के साथ गोली गई (बैंकर की गोली) स्ट्रिंग प्रस्तुति लौटाता है।

आप अपनी आवश्यकतानुसार उपयुक्त विधि चुन सकते हैं। नीचे एक उदाहरण है दशमलव संख्या को स्ट्रिंग में परिवर्तित करने का:

d := decimal.NewFromFloat(5.45)
str := d.String()

fmt.Println("दशमलव संख्या की स्ट्रिंग प्रस्तुति:", str) // दशमलव संख्या की स्ट्रिंग प्रस्तुति: 5.45

// StringFixed उदाहरण
NewFromFloat(0).StringFixed(2) // Output: "0.00"
NewFromFloat(0).StringFixed(0) // Output: "0"
NewFromFloat(5.45).StringFixed(0) // Output: "5"
NewFromFloat(5.45).StringFixed(1) // Output: "5.5"
NewFromFloat(5.45).StringFixed(2) // Output: "5.45"
NewFromFloat(5.45).StringFixed(3) // Output: "5.450"
NewFromFloat(545).StringFixed(-1) // Output: "550"

// StringFixedBank उदाहरण
NewFromFloat(0).StringFixedBank(2) // Output: "0.00"
NewFromFloat(0).StringFixedBank(0) // Output: "0"
NewFromFloat(5.45).StringFixedBank(0) // Output: "5"
NewFromFloat(5.45).StringFixedBank(1) // Output: "5.4"
NewFromFloat(5.45).StringFixedBank(2) // Output: "5.45"
NewFromFloat(5.45).StringFixedBank(3) // Output: "5.450"
NewFromFloat(545).StringFixedBank(-1) // Output: "540"

8. सामान्य प्रश्न

प्रश्न: सीधे float64 क्यों नहीं इस्तेमाल करें? उत्तर: float64 सचमुच संख्याओं को जैसे 0.1 के प्रतिनिधित्व करने में सक्षम नहीं है, जो छोटी गलतियों की ओर ले जा सकता है। वित्तीय गणनाओं से जुड़े स्थितियों में, ये गलतियाँ समय के साथ जमा हो सकती हैं और महत्वपूर्ण मुद्दे उत्पन्न कर सकती हैं।

प्रश्न: सीधे big.Rat क्यों नहीं इस्तेमाल करें? उत्तर: हालांकि big.Rat संख्या को प्रत्यक्षता से प्रतिनिधित्व कर सकता है, लेकिन यह मुद्रा को प्रतिनिधित्व करने के लिए उपयुक्त नहीं है। दशमलव संख्याएँ वित्तीय गणनाओं के लिए बेहतर होती हैं क्योंकि वे सूचित प्रतिश्रुध्धता के बिना दशमलव अंशों को सटीक रूप से प्रतिनिधित्व कर सकती हैं।

प्रश्न: API big.Int के समान क्यों नहीं है? उत्तर: दशमलव पुस्तकालय का API प्रदर्शनशीलता और सहीता को प्राथमिकता देता है। हालांकि big.Int का API प्रदर्शन के कारण मेमोरी आरक्षण को कम करता है, लेकिन यह जटिल और त्रुटिपूर्ण कोड का कारण बन सकता है। दशमलव पुस्तकालय का API सरल और समझने में आसान होने के लिए डिज़ाइन किया गया है।