एफ # के स्थिर प्रकार पैरामीटर और एन्कोडिंग न्यूमेरिक स्थिरांक का उपयोग

Question

मैं एफ # में लाइब्रेरी लिख रहा हूं जो कुछ बिटवाई ऑपरेशंस प्रदान करता है, और मैं यह सुनिश्चित करना चाहता हूं कि जितना संभव हो सके मेरे कई कार्य inline स्थिर प्रकार पैरामीटर के साथ बाइंडिंग दें (यह अनुमति देता है मुझे एक समारोह लिखने और int16, int32, और शायद bignum के लिए थोड़ा ओवरहेड के साथ उपयोग करने के लिए इसका उपयोग करें)। यह मार्ग निश्चित रूप से किसी बिंदु पर काम करने में विफल रहेगा। कहा पुस्तकालय द्वारा प्रदान की गई कुछ कार्यक्षमता कुछ हद तक जटिल है।

¹ नोट: मुझे इनलाइन को उजागर करने के मुद्दों के बारे में पता है, जो सार्वजनिक इंटरफ़ेस के माध्यम से बाइंडिंग करते हैं।

हालांकि, मैं इसे दूर तक पहुंचने के लिए इसे दूर तक ले जाना चाहता हूं। अभी, मैं इस फ़ॉर्म में population count एल्गोरिदम लिखने की कोशिश कर रहा हूं, और मुझे एक समस्या का सामना करना पड़ रहा है। मुझे यकीन नहीं है कि मास्क को एन्कोड कैसे करें, उदा। 0x3333..., जो इन एल्गोरिदम में दिखाई देते हैं। मैं कुछ अतिरिक्त बिट ट्रिकरी का उपयोग कर शिफ्ट स्थिरांक और इसी तरह के आसपास मिल सकता है।

क्या कोई चाल है जिसका उपयोग मैं कर सकता हूं, चाहे एफ # के प्रकार के अनुमान और स्थिर प्रकार पैरामीटर के माध्यम से, या बिट-ट्विडलिंग के माध्यम से, जिस तरह से मैं चाहता हूं एल्गोरिदम लिखने के लिए? क्या कोई तरीका है कि मैं स्थिर रूप से जेनेरिक फ़ंक्शन में स्थिरांक के इन प्रकारों को एन्कोड कर सकता हूं?

एक और अस्पष्ट प्रश्न: क्या कुछ विशिष्ट चीजें हैं जिन पर मैं स्थिर प्रकार के मानकों को अपने पूर्ण रूप से उपयोग करने के लिए भरोसा कर सकता हूं, खासकर संख्याओं के संदर्भ में? उदाहरण के लिए, मैं GenericOne और GenericZero का भारी उपयोग करता हूं। क्या इस तरह की और चीजें हैं, कि मैं याद कर सकता हूं?

Answer 1

सबसे पहले, GenericOne और GenericZero के बदसूरत उपयोगों से बचने के लिए आप numeric literals का उपयोग कर सकते हैं। यहाँ एक संक्षिप्त उदाहरण है:

module NumericLiteralG = begin 
    let inline FromZero() = LanguagePrimitives.GenericZero 
    let inline FromOne() = LanguagePrimitives.GenericOne 
    let inline FromInt32 (n:int) = 
     let one : ^a = FromOne() 
     let zero : ^a = FromZero() 
     let n_incr = if n > 0 then 1 else -1 
     let g_incr = if n > 0 then one else (zero - one) 
     let rec loop i g = 
      if i = n then g 
      else loop (i + n_incr) (g + g_incr) 
     loop 0 zero 
end 

// Usage 
let inline ten() = 10G 
ten() + 1 
ten() + 2L 

दूसरा, एफ # सामान्य हेक्सा सांख्यिक शाब्दिक समर्थन करने के लिए प्रतीत नहीं होता।

let inline shift x = 
    let ``0x33333333G`` = 858993459G 
    ((x >>> 2) &&& ``0x33333333G``) + (x &&& ``0x33333333G``) 

// Usage 
shift 20 
shift 20L 
shift 20uy 

सांख्यिक शाब्दिक के बारे में इतने पर कुछ अच्छा सवाल कर रहे हैं: एक चाल डबल बैकटिक उपयोग करने के लिए इतना है कि आप सांकेतिक नाम है है। मैं कुछ संदर्भों देने के मामले में आपको लगता है कि मार्ग जाना:

• F# Static Member Type Constraints
• Complete, efficient NumericLiteral module implementation
• How to write a function for generic numbers?

संसाधनों के बारे में