गो में एक इंट प्रकार के लिए अधिकतम मूल्य


132

unsignedपूर्णांक प्रकार के लिए प्रतिनिधित्व योग्य अधिकतम मूल्य कैसे निर्दिष्ट करता है ?

मैं यह जानना चाहूंगा minकि नीचे दिए गए लूप में कैसे इनिशियलाइज़ किया जाए कि कुछ स्ट्रक्चर से मिनट और अधिकतम लंबाई की गणना करें।

var minLen uint = ???
var maxLen uint = 0
for _, thing := range sliceOfThings {
  if minLen > thing.n { minLen = thing.n }
  if maxLen < thing.n { maxLen = thing.n }
}
if minLen > maxLen {
  // If there are no values, clamp min at 0 so that min <= max.
  minLen = 0
}

ताकि पहली बार तुलना के माध्यम से, minLen >= n


2
देखिए यह एक स्निपेट golang.org/doc/effective_go.html#printingint(^uint(0) >> 1) // largest int से निकाला गया
विक्टर

जवाबों:


218

https://groups.google.com/group/golang-nuts/msg/71c307e4d73024ce?pli=1

जर्मन भाग:

चूंकि पूर्णांक प्रकार दो के पूरक अंकगणित का उपयोग करते हैं, आप न्यूनतम / अधिकतम स्थिर मानों के लिए intऔर uint। उदाहरण के लिए,

const MaxUint = ^uint(0) 
const MinUint = 0 
const MaxInt = int(MaxUint >> 1) 
const MinInt = -MaxInt - 1

@ CarelZA की टिप्पणी के अनुसार:

uint8  : 0 to 255 
uint16 : 0 to 65535 
uint32 : 0 to 4294967295 
uint64 : 0 to 18446744073709551615 
int8   : -128 to 127 
int16  : -32768 to 32767 
int32  : -2147483648 to 2147483647 
int64  : -9223372036854775808 to 9223372036854775807

66
में उपलब्ध लोगों का उपयोग करें math: golang.org/pkg/math/#pkg-constants , आप math.MaxInt32सबसे अधिक संभावना चाहते हैं ।
चार्ल्स एल।

7
क्या कोई ठीक से समझा सकता है कि क्या ^ uint (0) और ^ uint (0) >> 1 करते हैं?
अरिजून

16
@Arijoon, ^ का अर्थ अभिव्यक्ति में बिट्स को उल्टा करना है जैसे: uint (0) = 0000 ... 0000 (बिलकुल लक्ष्य संरचना के आधार पर 32 या 64 शून्य बिट्स) तो ^ इकाई (0) == 1111 ... 1111 जो हमें अहस्ताक्षरित पूर्णांक (सभी वाले) के लिए अधिकतम मूल्य देता है। अब जब आप हस्ताक्षर किए गए पूर्णांक के बारे में बात कर रहे हैं तो पहले (सबसे महत्वपूर्ण) बिट का उपयोग हस्ताक्षर को संग्रहीत करने के लिए किया जाता है इसलिए हस्ताक्षर किए गए अधिकतम अधिकतम मूल्य पर - हमें सभी बिट्स को दाईं ओर स्थानांतरित करने की आवश्यकता है जो हमें ^ uint (0) >> 1 = = 0111 ... 1111। जो अधिकतम सकारात्मक पूर्णांक देता है।
निनाज़ॉय

4
@CharlesL। के बारे में क्या सिर्फ int प्रकार?
user960567

1
मुझे पता है कि यह कुछ समय हो गया है, लेकिन बस अगर कोई आज यहां आता है और @ user960567 का प्रश्न-टिप्पणी देखता है: intप्रकार 32 बिट सिस्टम पर 32 बिट्स और 64 बिट सिस्टम पर 64 बिट लंबा है। देखें यहाँ
क्राइस्टोफ हारम-एनस्किंक

73

भौतिक प्रकार की सीमाओं के लिए https://golang.org/ref/spec#Numeric_types

आपके पैकेज में अधिकतम मान गणित पैकेज में परिभाषित किए गए हैं: math.MaxUint32

बाहर देखो क्योंकि वहाँ कोई अतिप्रवाह नहीं है - पिछले अधिकतम कारण रैपराउंड को बढ़ाता है।


2
धन्यवाद। मैं वास्तव में उपयोग कर रहा हूं uint, नहीं uint32lenऔर capउपयोग intनहीं int32तो मैं करने के लिए उपयोग कुछ है कि सभी आर्किटेक्चर पर उन के आकार से मेल खाता है चाहता हूँ। math/const.goके एक गुच्छा को परिभाषित करता है, Max<type>लेकिन uintया तो `int के लिए कोई नहीं ।
माइक सैमुअल

मैं इसे uint32 या Unit64 में बदल दूंगा ताकि यह सुनिश्चित हो सके कि यह आर्किटेक्चर में पोर्टेबल है। मैं वह सब कुछ धार्मिक रूप से करता हूं। मैं आर्किटेक्चर के बीच नरक पोर्टिंग सी के वर्षों से रहा हूं और मैं कह सकता हूं कि "स्पष्ट होना" बाद में काफी मदद करेगा।
हटा दिया गया

धन्यवाद। मेरे कोड की जाँच है uint(len(...)) < thing.minLenलेकिन मुझे नहीं पता कि क्या uint64(int)है और परिभाषित व्यवहार रहेगा।
माइक सैमुअल

1
यदि आप नहीं जानते हैं तो ऊपर दिए गए लिंक को पढ़ें ... विशेष रूप से golang.org/doc/go_spec.html#Conversions । "संख्यात्मक प्रकारों के बीच रूपांतरण" की सावधानीपूर्वक परिभाषा है।
अंचल शेफ़र-कोहेन

29

मैं mathअधिकतम मूल्य और न्यूनतम मूल्य प्राप्त करने के लिए पैकेज का उपयोग करूंगा :

func printMinMaxValue() {
    // integer max
    fmt.Printf("max int64 = %+v\n", math.MaxInt64)
    fmt.Printf("max int32 = %+v\n", math.MaxInt32)
    fmt.Printf("max int16 = %+v\n", math.MaxInt16)

    // integer min
    fmt.Printf("min int64 = %+v\n", math.MinInt64)
    fmt.Printf("min int32 = %+v\n", math.MinInt32)

    fmt.Printf("max flloat64= %+v\n", math.MaxFloat64)
    fmt.Printf("max float32= %+v\n", math.MaxFloat32)

    // etc you can see more int the `math`package
}

ऊपुत:

max int64 = 9223372036854775807
max int32 = 2147483647
max int16 = 32767
min int64 = -9223372036854775808
min int32 = -2147483648
max flloat64= 1.7976931348623157e+308
max float32= 3.4028234663852886e+38

1
यह कोड काम नहीं करता है। दो int64अतिप्रवाह int, जो कि अगर आप स्ट्रिंग प्रक्षेप से पहले स्पष्ट रूप से स्थिरांक टाइप नहीं करते हैं तो क्या होता है। int64(math.MaxInt64)इसके बजाय प्रयोग करें , देखें stackoverflow.com/questions/16474594/…
domoarigato

3
लेकिन अन्यथा, स्वीकार किए जाते हैं की तुलना में एक बेहतर जवाब है। :)
डोमोइरगेटो

यदि आप 32-बिट शब्द आकार वाली मशीन पर int64 का उपयोग करते हैं तो क्या होगा? C में, कंपाइलर INT_MIN तय करता है
segue_segway

12

मैंने मूल रूप से चर्चा के धागे से लिए गए कोड का उपयोग किया था जो @nmichaels ने अपने उत्तर में उपयोग किया था। अब मैं थोड़ी अलग गणना का उपयोग करता हूं। यदि कुछ और @Arijoon के समान क्वेरी है, तो मैंने कुछ टिप्पणियां शामिल की हैं

const (
    MinUint uint = 0                 // binary: all zeroes

    // Perform a bitwise NOT to change every bit from 0 to 1
    MaxUint      = ^MinUint          // binary: all ones

    // Shift the binary number to the right (i.e. divide by two)
    // to change the high bit to 0
    MaxInt       = int(MaxUint >> 1) // binary: all ones except high bit

    // Perform another bitwise NOT to change the high bit to 1 and
    // all other bits to 0
    MinInt       = ^MaxInt           // binary: all zeroes except high bit
)

अंतिम दो चरण काम करते हैं क्योंकि दो के पूरक अंकगणित में कैसे सकारात्मक और नकारात्मक संख्याओं का प्रतिनिधित्व किया जाता है। न्यूमेरिक प्रकारों पर गो लैंग्वेज स्पेसिफिकेशन सेक्शन , संबंधित विकिपीडिया लेख के पाठक को संदर्भित करता है । मैंने वह नहीं पढ़ा है, लेकिन मैंने चार्ल्स पेटज़ोल्ड की पुस्तक कोड से दो के पूरक के बारे में सीखा , जो कंप्यूटर और कोडिंग के मूल सिद्धांतों के लिए एक बहुत ही सुलभ परिचय है।

मैंने ऊपर कोड (छोटी टिप्पणियों के अधिकांश) को थोड़ा पूर्णांक गणित पैकेज में डाल दिया ।


9

त्वरित सारांश:

import "math/bits"
const (
    MaxUint uint = (1 << bits.UintSize) - 1
    MaxInt int = (1 << bits.UintSize) / 2 - 1
    MinInt int = (1 << bits.UintSize) / -2
)

पृष्ठभूमि:

जैसा कि मैं जानता हूँ कि आप जानते हैं कि uintटाइप uint32या तो एक ही आकार का होता हैuint64 आप जिस प्लेटफॉर्म पर हैं, उसके आधार पर । आमतौर पर, इनमें से अनसिक्योर्ड संस्करण का उपयोग केवल तभी किया जाता है, जब अधिकतम मूल्य के करीब आने का कोई जोखिम नहीं होता है, क्योंकि बिना आकार के विनिर्देश के संस्करण प्लेटफ़ॉर्म के आधार पर "देशी" प्रकार का उपयोग कर सकते हैं, जो तेज़ हो जाता है।

ध्यान दें कि यह "तेज" हो जाता है क्योंकि गैर-देशी प्रकार का उपयोग करने के लिए कभी-कभी प्रोसेसर द्वारा प्रदर्शन करने के लिए अतिरिक्त गणित और सीमा-जाँच की आवश्यकता होती है, ताकि बड़े या छोटे पूर्णांक का अनुकरण किया जा सके। इसे ध्यान में रखते हुए, ध्यान रखें कि प्रोसेसर (या कंपाइलर का अनुकूलित कोड) का प्रदर्शन लगभग हमेशा अपने स्वयं के सीमा-जाँच कोड को जोड़ने से बेहतर होने वाला है, इसलिए यदि इसके खेलने में कोई जोखिम है, तो यह हो सकता है केवल निश्चित आकार के संस्करण का उपयोग करने की समझ, और अनुकूलित अनुकरण को उस से किसी भी नतीजे को संभालने दें।

इसके साथ ही कहा गया है, अभी भी कुछ स्थितियाँ ऐसी हैं जहाँ यह जानना उपयोगी है कि आप किसके साथ काम कर रहे हैं।

पैकेज " गणित / बिट्स " का आकार uintबिट्स में होता है। अधिकतम मूल्य निर्धारित करने के लिए, शिफ्ट करें1 उस बिट्स, माइनस 1 से ।(1 << bits.UintSize) - 1

ध्यान दें कि जब अधिकतम मूल्य की गणना करते हैं uint, तो आपको आम तौर पर इसे uint(या बड़े) चर में स्पष्ट रूप से डालने की आवश्यकता होगी , अन्यथा कंपाइलर विफल हो सकता है, क्योंकि यह उस गणना को एक हस्ताक्षरित int(जहां, जैसा करना चाहिए) असाइन करने का प्रयास करने में डिफ़ॉल्ट होगा जाहिर है, यह फिट नहीं होगा), इसलिए:

const MaxUint uint = (1 << bits.UintSize) - 1

यह आपके सवाल का सीधा जवाब है, लेकिन कुछ ऐसे संबंधित गणना भी हैं, जिनमें आपकी रुचि हो सकती है।

युक्ति के अनुसार , uintऔर intहमेशा एक ही आकार के होते हैं।

uint या तो 32 या 64 बिट्स

int के समान आकार uint

तो हम इस स्थिरांक का उपयोग अधिकतम मूल्य निर्धारित करने के लिए कर सकते हैं int, उसी उत्तर को ले कर और 2फिर घटाकर1 । अर्थात:(1 << bits.UintSize) / 2 - 1

और के न्यूनतम मूल्य int, 1कि कई बिट्स द्वारा स्थानांतरण करके और परिणाम को विभाजित करके -2। अर्थात:(1 << bits.UintSize) / -2

संक्षेप में:

MaxUint: (1 << bits.UintSize) - 1

MaxInt: (1 << bits.UintSize) / 2 - 1

MinInt: (1 << bits.UintSize) / -2

पूर्ण उदाहरण (नीचे जैसा होना चाहिए)

package main

import "fmt"
import "math"
import "math/bits"

func main() {
    var mi32 int64 = math.MinInt32
    var mi64 int64 = math.MinInt64

    var i32 uint64 = math.MaxInt32
    var ui32 uint64 = math.MaxUint32
    var i64 uint64 = math.MaxInt64
    var ui64 uint64 = math.MaxUint64
    var ui uint64 = (1 << bits.UintSize) - 1
    var i uint64 = (1 << bits.UintSize) / 2 - 1
    var mi int64 = (1 << bits.UintSize) / -2

    fmt.Printf(" MinInt32: %d\n", mi32)
    fmt.Printf(" MaxInt32:  %d\n", i32)
    fmt.Printf("MaxUint32:  %d\n", ui32)
    fmt.Printf(" MinInt64: %d\n", mi64)
    fmt.Printf(" MaxInt64:  %d\n", i64)
    fmt.Printf("MaxUint64:  %d\n", ui64)
    fmt.Printf("  MaxUint:  %d\n", ui)
    fmt.Printf("   MinInt: %d\n", mi)
    fmt.Printf("   MaxInt:  %d\n", i)
}

धन्यवाद। देशी अंकशास्त्र के बारे में आपके विवरण अच्छी तरह से बताए गए हैं, और मैं गणित / बिट्स से अनजान था।
माइक शमूएल

या तो 32 या 64 बिट्स, यूंट के समान आकार। यदि एक के पास एक चिन्ह है और दूसरे में नहीं है तो ये एक ही आकार के कैसे हो सकते हैं?
थीमीडेल्स

उनका समान आकार है, उनके पास समान / न्यूनतम मूल्य नहीं हैं। उस आकार में बिट्स में से एक साइन बिट है। ( /2हिस्सा वही है जो विचार से उस बिट को हटा देता है जब int64 के लिए मिनट / अधिकतम के आकार की गणना करता है)
विल पामर


4

इस समस्या को हल करने का एक तरीका यह है कि हम स्वयं मानों से शुरुआती बिंदु प्राप्त करें:

var minLen, maxLen uint
if len(sliceOfThings) > 0 {
  minLen = sliceOfThings[0].minLen
  maxLen = sliceOfThings[0].maxLen
  for _, thing := range sliceOfThings[1:] {
    if minLen > thing.minLen { minLen = thing.minLen }
    if maxLen < thing.maxLen { maxLen = thing.maxLen }
  }
}

1

एक हल्के पैकेज में उन्हें (साथ ही अन्य इंट प्रकार सीमाएं और कुछ व्यापक रूप से उपयोग किए जाने वाले पूर्णांक कार्य शामिल हैं):

import (
    "fmt"
    "<Full URL>/go-imath/ix"
    "<Full URL>/go-imath/ux"
)
...
fmt.Println(ix.Minimal) // Output: -2147483648 (32-bit) or -9223372036854775808 (64-bit)
fmt.Println(ix.Maximal) // Output: 2147483647 or 9223372036854775807
fmt.Println(ux.Minimal) // Output: 0
fmt.Println(ux.Maximal) // Output: 4294967295 or 18446744073709551615

0
MaxInt8   = 1<<7 - 1
MinInt8   = -1 << 7
MaxInt16  = 1<<15 - 1
MinInt16  = -1 << 15
MaxInt32  = 1<<31 - 1
MinInt32  = -1 << 31
MaxInt64  = 1<<63 - 1
MinInt64  = -1 << 63
MaxUint8  = 1<<8 - 1
MaxUint16 = 1<<16 - 1
MaxUint32 = 1<<32 - 1
MaxUint64 = 1<<64 - 1
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.