F#
मापन की इकाई

टिप्पणियों

गणना में निरंतर इकाइयों को सुनिश्चित करना

माप की इकाइयां अतिरिक्त प्रकार के एनोटेशन हैं जिन्हें फ्लोट या पूर्णांक में जोड़ा जा सकता है। उनका उपयोग संकलन समय पर सत्यापित करने के लिए किया जा सकता है कि गणना इकाइयों का लगातार उपयोग कर रही है।

एनोटेशन को परिभाषित करने के लिए:

[<Measure>] type m // meters
[<Measure>] type s // seconds
[<Measure>] type accel = m/s^2 // acceleration defined as meters per second squared

एक बार परिभाषित होने के बाद, एनोटेशन का उपयोग यह सत्यापित करने के लिए किया जा सकता है कि अपेक्षित प्रकार में एक अभिव्यक्ति परिणाम है।

// Compile-time checking that this function will return meters, since (m/s^2) * (s^2) -> m
// Therefore we know units were used properly in the calculation.
let freeFallDistance (time:float<s>) : float<m> = 
    0.5 * 9.8<accel> * (time*time)    

// It is also made explicit at the call site, so we know that the parameter passed should be in seconds
let dist:float<m> = freeFallDistance 3.0<s>
printfn "%f" dist

इकाइयों के बीच बातचीत

[<Measure>] type m // meters
[<Measure>] type cm // centimeters

// Conversion factor
let cmInM = 100<cm/m>

let distanceInM = 1<m>
let distanceInCM = distanceInM * cmInM // 100<cm>

// Conversion function
let cmToM (x : int<cm>) = x / 100<cm/m>
let mToCm (x : int<m>) = x * 100<cm/m>

cmToM 100<cm> // 1<m>
mToCm 1<m> // 100<cm>

ध्यान दें कि F # कंपाइलर को पता नहीं है कि 1<m> 100<cm> बराबर है। जहां तक इसकी परवाह है, इकाइयां अलग-अलग प्रकार की हैं। आप मीटर से किलोग्राम में बदलने के लिए समान फ़ंक्शन लिख सकते हैं, और संकलक देखभाल नहीं करेगा।

[<Measure>] type kg

// Valid code, invalid physics
let kgToM x = x / 100<kg/m>

माप की इकाइयों को अन्य इकाइयों के गुणकों जैसे कि परिभाषित करना संभव नहीं है

// Invalid code
[<Measure>] type m = 100<cm>

हालांकि, इकाइयों को "प्रति चीज़" परिभाषित करने के लिए, उदाहरण के लिए, हर्ट्ज़, आवृत्ति को मापना, बस "प्रति सेकंड" है, काफी सरल है।

// Valid code
[<Measure>] type s
[<Measure>] type Hz = /s

1 / 1<s> = 1 <Hz> // Evaluates to true

[<Measure>] type N = kg m/s // Newtons, measuring force. Note lack of multiplication sign.

// Usage
let mass = 1<kg>
let distance = 1<m>
let time = 1<s>

let force = mass * distance / time // Evaluates to 1<kg m/s>
force = 1<N> // Evaluates to true

यूनिटों को संरक्षित या सेट करने के लिए LanguagePrimatics का उपयोग करना

जब कोई फ़ंक्शन निचले स्तर के संचालन के कारण स्वचालित रूप से इकाइयों को संरक्षित नहीं करता है, तो LanguagePrimitives मॉड्यूल का उपयोग उन प्राथमिकताओं पर इकाइयों को सेट करने के लिए किया जा सकता है जो उनका समर्थन करते हैं:

/// This cast preserves units, while changing the underlying type
let inline castDoubleToSingle (x : float<'u>) : float32<'u> =
    LanguagePrimitives.Float32WithMeasure (float32 x)

डबल-सटीक फ़्लोटिंग-पॉइंट मान के लिए माप की इकाइयों को असाइन करने के लिए, सही इकाइयों के साथ बस एक गुणा करें:

[<Measure>]
type USD

let toMoneyImprecise (amount : float) =
   amount * 1.<USD>

यूनिट-कम मान के लिए माप की इकाइयों को असाइन करने के लिए, जो कि System.Double नहीं है, उदाहरण के लिए, किसी अन्य भाषा में लिखी गई लाइब्रेरी से पहुंचना, रूपांतरण का उपयोग करें:

open LanguagePrimitives

let toMoney amount =
   amount |> DecimalWithMeasure<'u>

यहाँ एफ # इंटरेक्टिव द्वारा सूचित प्रकार हैं:

val toMoney : amount:decimal -> decimal<'u>
val toMoneyImprecise : amount:float -> float<USD>

यूनिट-ऑफ-माप प्रकार पैरामीटर

[<Measure>] प्रकार का उपयोग उन मापदंडों को घोषित करने के लिए किया जा सकता है जो माप की इकाइयों के संबंध में सामान्य हैं।

type CylinderSize<[<Measure>] 'u> =
    { Radius : float<'u>
      Height : float<'u> }

परीक्षण का उपयोग:

open Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols

/// This has type CylinderSize<m>.
let testCylinder =
    { Radius = 14.<m>
      Height =  1.<m> }

अनुकूलता बनाए रखने के लिए मानकीकृत इकाई प्रकारों का उपयोग करें

उदाहरण के लिए, SI इकाइयों के प्रकारों को Microsoft.FSharp.Data.UnitSystems.SI #Sharp.Data.UnitSystems.SI में F # कोर लाइब्रेरी में मानकीकृत किया गया है। उनका उपयोग करने के लिए उपयुक्त उप-नामस्थान, UnitNames या UnitSymbols । या, यदि केवल कुछ SI इकाइयों की आवश्यकता होती है, तो उन्हें प्रकार के उपनामों के साथ आयात किया जा सकता है:

/// Seconds, the SI unit of time. Type abbreviation for the Microsoft standardized type.
type [<Measure>] s = Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols.s

कुछ उपयोगकर्ता निम्नलिखित कार्य करते हैं, जो कि जब भी कोई परिभाषा पहले से उपलब्ध नहीं होती है , तो नहीं किया जाना चाहिए :

/// Seconds, the SI unit of time
type [<Measure>] s // DO NOT DO THIS! THIS IS AN EXAMPLE TO EXPLAIN A PROBLEM.

अंतर स्पष्ट हो जाता है जब मानक एसआई प्रकार को संदर्भित करने वाले अन्य कोड के साथ इंटरफेस होता है। कोड जो मानक इकाइयों को संदर्भित करता है वह संगत है, जबकि कोड जो अपने स्वयं के प्रकार को परिभाषित करता है वह किसी भी कोड के साथ असंगत है इसकी विशिष्ट परिभाषा का उपयोग नहीं करता है।

इसलिए, एसआई इकाइयों के लिए हमेशा मानक प्रकारों का उपयोग करें। इससे कोई फर्क नहीं पड़ता कि आप UnitNames या UnitSymbols को संदर्भित करते हैं, क्योंकि उन दोनों के भीतर समान नाम समान प्रकार को संदर्भित करते हैं:

open Microsoft.FSharp.Data.UnitSystems.SI

/// This is valid, since both versions refer to the same authoritative type.
let validSubtraction = 1.<UnitSymbols.s> - 0.5<UnitNames.second>