गो में एक फ्लोट64 को इंट में बदलें

Question

गो में एक फ्लोट64 को इंट में कैसे परिवर्तित करता है? मुझे पता है कि strconvपैकेज का उपयोग किसी भी चीज को स्ट्रिंग से या में बदलने के लिए किया जा सकता है, लेकिन डेटा प्रकारों के बीच नहीं जहां कोई स्ट्रिंग नहीं है। मुझे पता है कि मैं किसी fmt.Sprintfभी चीज को स्ट्रिंग में बदलने के लिए उपयोग कर सकता हूं , और फिर strconvयह उस डेटा प्रकार पर है जिसकी मुझे आवश्यकता है, लेकिन यह अतिरिक्त रूपांतरण थोड़ा अनाड़ी लगता है - क्या ऐसा करने का एक बेहतर तरीका है?

Comments

int(Round(f))एक intat64 के लिए एक सेट करने के लिए। Stackoverflow.com/a/62753031/12817546 देखें । float64(i)एक intat64 के लिए एक सेट करने के लिए। Stackoverflow.com/a/62737936/12817546 देखें ।

— टॉम जे

Answer 1

package main
import "fmt"
func main() {
  var x float64 = 5.7
  var y int = int(x)
  fmt.Println(y)  // outputs "5"
}

Comments

@ डेविड ग्रेसन, तो क्या यह रूपांतरण मैथ.फ्लोर (x) के समान है या क्या यह .7 को ड्रॉप करता है जिस तरह से फ्लोट64 इसे मेमोरी में बचाता है?

— डेविड लार्सन

GoD से @DavidLarsen कल्पना करें: "जब एक फ्लोटिंग-पॉइंट नंबर को पूर्णांक में परिवर्तित किया जाता है, तो अंश को छोड़ दिया जाता है (शून्य की ओर झुकाव)"। ( गो स्पेक )

— kvu787

ऐसी जातियों को गो में एक समस्या है जो अप्रत्याशित हो सकती है (कम से कम यदि आप जावा से आते हैं): "सभी गैर-स्थिर रूपांतरण में फ़्लोटिंग-पॉइंट या जटिल मान शामिल होते हैं, यदि परिणाम प्रकार मान का प्रतिनिधित्व नहीं कर सकता है लेकिन परिणाम सफल होता है लेकिन परिणाम मूल्य कार्यान्वयन-निर्भर है। " ( golang.org/ref/spec#Conversions )। इसलिए यदि आप एक अनन्तता के रूप में प्रभावी रूप से एक बहुत बड़े मूल्य का उपयोग करते हैं, और आप इसे एक इंट में परिवर्तित करते हैं, तो परिणाम अपरिभाषित है (जावा के विपरीत, जहां यह पूर्णांक प्रकार का अधिकतम मूल्य है)।

— जान

Answer 2

बस एक इंट में घुसने से फ्लोट ट्रंच हो जाता है, जो यदि आपके सिस्टम आंतरिक रूप से 2.0 को 1.9999999999 के रूप में प्रस्तुत करता है, तो आपको वह नहीं मिलेगा जो आप उम्मीद करते हैं। विभिन्न प्रिंटफ रूपांतरण इससे निपटते हैं और रूपांतरण करते समय संख्या को ठीक से गोल करते हैं। इसलिए अधिक सटीक मूल्य प्राप्त करने के लिए, रूपांतरण पहले से भी अधिक जटिल है, जिसकी आप उम्मीद कर सकते हैं:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    floats := []float64{1.9999, 2.0001, 2.0}
    for _, f := range floats {
        t := int(f)
        s := fmt.Sprintf("%.0f", f)
        if i, err := strconv.Atoi(s); err == nil {
            fmt.Println(f, t, i)
        } else {
            fmt.Println(f, t, err)
        }
    }
}

खेल के मैदान पर कोड

Answer 3

अगर इसकी बस फ्लोट64 से इंट तक, यह काम करना चाहिए

package main

import (
    "fmt"
)

func main() {
    nf := []float64{-1.9999, -2.0001, -2.0, 0, 1.9999, 2.0001, 2.0}

    //round
    fmt.Printf("Round : ")
    for _, f := range nf {
        fmt.Printf("%d ", round(f))
    }
    fmt.Printf("\n")

    //rounddown ie. math.floor
    fmt.Printf("RoundD: ")
    for _, f := range nf {
        fmt.Printf("%d ", roundD(f))
    }
    fmt.Printf("\n")

    //roundup ie. math.ceil
    fmt.Printf("RoundU: ")
    for _, f := range nf {
        fmt.Printf("%d ", roundU(f)) 
    }
    fmt.Printf("\n")

}

func roundU(val float64) int {
    if val > 0 { return int(val+1.0) }
    return int(val)
}

func roundD(val float64) int {
    if val < 0 { return int(val-1.0) }
    return int(val)
}

func round(val float64) int {
    if val < 0 { return int(val-0.5) }
    return int(val+0.5)
}

आउटपुट:

Round : -2 -2 -2 0 2 2 2 
RoundD: -2 -3 -3 0 1 2 2 
RoundU: -1 -2 -2 0 2 3 3 

यहाँ खेल के मैदान में कोड है - https://play.golang.org/p/HmFfM6Grqh

Comments

गो के पास एक गोल फ़ंक्शन है जो आप उस राउंड को निकटतम पूर्णांक तक उपयोग कर सकते हैं: math.Round (-64.99) आउटपुट -65।

— आनन्दमंद

Answer 4

प्रकार डेटा को a में int()कनवर्ट करने के लिए आप फ़ंक्शन का उपयोग कर सकते हैं । इसी तरह आप उपयोग कर सकते हैंfloat64intfloat64()

उदाहरण:

func check(n int) bool { 
    // count the number of digits 
    var l int = countDigit(n)
    var dup int = n 
    var sum int = 0 

    // calculates the sum of digits 
    // raised to power 
    for dup > 0 { 
        **sum += int(math.Pow(float64(dup % 10), float64(l)))** 
        dup /= 10 
    } 

    return n == sum
} 

Answer 5

सही गोलाई वांछित है।

इसलिए math.Round () आपका क्विक (!) दोस्त है। Fmt.Sprintf और strconv.Atois () के साथ दृष्टिकोण 2 फ्लोट64 मानों के मैट्रिक्स के साथ मेरे परीक्षणों के अनुसार परिमाण धीमे के 2 क्रम थे जो कि सही ढंग से गोल अंतर मान बनने के लिए थे।

package main
import (
    "fmt"
    "math"
)
func main() {
    var x float64 = 5.51
    var y float64 = 5.50
    var z float64 = 5.49
    fmt.Println(int(math.Round(x)))  // outputs "6"
    fmt.Println(int(math.Round(y)))  // outputs "6"
    fmt.Println(int(math.Round(z)))  // outputs "5"
}

math.Round () एक फ्लोट64 मान लौटाता है, लेकिन int () के साथ लागू होने के बाद, मुझे अब तक कोई बेमेल नहीं मिला।