Haskell Language => अंकगणित

परिचय

हास्केल में, सभी अभिव्यक्तियों (जिसमें संख्यात्मक स्थिरांक और उन पर काम करने वाले कार्य शामिल हैं) में एक निर्णायक प्रकार होता है। संकलित समय में, टाइप-चेकर एक प्रकार के अभिव्यक्ति को प्राथमिक कार्यों के प्रकार से संक्रमित करता है जो इसे रचना करता है। चूंकि डेटा डिफ़ॉल्ट रूप से अपरिवर्तनीय है, इसलिए कोई "टाइप कास्टिंग" ऑपरेशन नहीं हैं, लेकिन ऐसे फ़ंक्शन हैं जो डेटा की प्रतिलिपि बनाते हैं और कारण के भीतर प्रकारों को सामान्य या विशेषज्ञ करते हैं।

टिप्पणियों

संख्यात्मक टाइपक्रेसी पदानुक्रम

संख्यात्मक सांख्यिक पदानुक्रम के मूल में Num बैठता है। इसकी विशेषता संचालन और कुछ सामान्य उदाहरण नीचे दिखाए गए हैं (जो डिफ़ॉल्ट रूप से लोड किए गए हैं जो Data.Complex अधिक हैं Data.Complex ):

λ> :i Num
class Num a where
  (+) :: a -> a -> a
  (-) :: a -> a -> a
  (*) :: a -> a -> a
  negate :: a -> a
  abs :: a -> a
  signum :: a -> a
  fromInteger :: Integer -> a
  {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}
      -- Defined in ‘GHC.Num’
instance RealFloat a => Num (Complex a) -- Defined in ‘Data.Complex’
instance Num Word -- Defined in ‘GHC.Num’
instance Num Integer -- Defined in ‘GHC.Num’
instance Num Int -- Defined in ‘GHC.Num’
instance Num Float -- Defined in ‘GHC.Float’
instance Num Double -- Defined in ‘GHC.Float’

हमने पहले ही Fractional वर्ग को देखा है, जिसके लिए Num आवश्यकता होती है और "डिवीजन" (/) और एक नंबर के पारस्परिक का विचार प्रस्तुत करता है:

λ> :i Fractional
class Num a => Fractional a where
  (/) :: a -> a -> a
  recip :: a -> a
  fromRational :: Rational -> a
  {-# MINIMAL fromRational, (recip | (/)) #-}
      -- Defined in ‘GHC.Real’
instance RealFloat a => Fractional (Complex a) -- Defined in ‘Data.Complex’
instance Fractional Float -- Defined in ‘GHC.Float’
instance Fractional Double -- Defined in ‘GHC.Float’

Real वर्ग मॉडल .. असली संख्या। इसके लिए Num और Ord आवश्यकता होती है, इसलिए यह एक ऑर्डर किए गए संख्यात्मक क्षेत्र को मॉडल करता है। एक प्रतिरूप के रूप में, कॉम्प्लेक्स नंबर एक ऑर्डर किए गए फ़ील्ड नहीं हैं (अर्थात वे एक प्राकृतिक ऑर्डरिंग संबंध के अधिकारी नहीं हैं):

λ> :i Real
class (Num a, Ord a) => Real a where
  toRational :: a -> Rational
  {-# MINIMAL toRational #-}
      -- Defined in ‘GHC.Real’
instance Real Word -- Defined in ‘GHC.Real’
instance Real Integer -- Defined in ‘GHC.Real’
instance Real Int -- Defined in ‘GHC.Real’
instance Real Float -- Defined in ‘GHC.Float’
instance Real Double -- Defined in ‘GHC.Float’

RealFrac गोल संख्याओं का प्रतिनिधित्व करता है

λ> :i RealFrac
class (Real a, Fractional a) => RealFrac a where
  properFraction :: Integral b => a -> (b, a)
  truncate :: Integral b => a -> b
  round :: Integral b => a -> b
  ceiling :: Integral b => a -> b
  floor :: Integral b => a -> b
  {-# MINIMAL properFraction #-}
      -- Defined in ‘GHC.Real’
instance RealFrac Float -- Defined in ‘GHC.Float’
instance RealFrac Double -- Defined in ‘GHC.Float’

Floating (जिसका अर्थ है Fractional ) स्थिरांक और परिचालनों का प्रतिनिधित्व करता है, जिसमें परिमित दशमलव विस्तार नहीं हो सकता है।

λ> :i Floating
class Fractional a => Floating a where
  pi :: a
  exp :: a -> a
  log :: a -> a
  sqrt :: a -> a
  (**) :: a -> a -> a
  logBase :: a -> a -> a
  sin :: a -> a
  cos :: a -> a
  tan :: a -> a
  asin :: a -> a
  acos :: a -> a
  atan :: a -> a
  sinh :: a -> a
  cosh :: a -> a
  tanh :: a -> a
  asinh :: a -> a
  acosh :: a -> a
  atanh :: a -> a
  GHC.Float.log1p :: a -> a
  GHC.Float.expm1 :: a -> a
  GHC.Float.log1pexp :: a -> a
  GHC.Float.log1mexp :: a -> a
  {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh,
              asinh, acosh, atanh #-}
      -- Defined in ‘GHC.Float’
instance RealFloat a => Floating (Complex a) -- Defined in ‘Data.Complex’
instance Floating Float -- Defined in ‘GHC.Float’
instance Floating Double -- Defined in ‘GHC.Float’

सावधानी: जबकि भाव जैसे कि sqrt . negate :: Floating a => a -> a पूरी तरह से मान्य हैं, वे NaN (" NaN -ए-नंबर") लौटा सकते हैं, जो एक इच्छित व्यवहार नहीं हो सकता है। ऐसे मामलों में, हम कॉम्प्लेक्स फील्ड (बाद में दिखाए गए) पर काम करना चाहते हैं।

मूल उदाहरण

λ> :t 1
1 :: Num t => t

λ> :t pi
pi :: Floating a => a

ऊपर के उदाहरणों में, टाइप-चेकर दोनों स्थिरांक के लिए एक ठोस प्रकार के बजाय एक प्रकार- वर्ग को संक्रमित करता है। हास्केल में, Num वर्ग सबसे सामान्य संख्यात्मक है (क्योंकि यह पूर्णांक और वास्तविक को शामिल करता है), लेकिन pi को एक अधिक विशिष्ट वर्ग से संबंधित होना चाहिए, क्योंकि इसमें एक नॉनजेरो फ्रैक्शनल हिस्सा है।

list0 :: [Integer]
list0 = [1, 2, 3]

list1 :: [Double]
list1 = [1, 2, pi]

ऊपर दिए गए ठोस प्रकार GHC द्वारा अनुमान लगाए गए थे। ऊपर list0 :: Num a => [a] और भी सामान्य प्रकार जैसे list0 :: Num a => [a] काम किया होगा, लेकिन संरक्षित करने के लिए भी कठिन होगा (जैसे कि यदि कोई व्यक्ति Num s की सूची पर Double साझा करता है)।

`कटौती नहीं कर सकता (भिन्नात्मक Int) ...`

शीर्षक में त्रुटि संदेश एक सामान्य शुरुआत गलती है। आइए देखें कि यह कैसे उठता है और इसे कैसे ठीक किया जाए।

मान लें कि हमें संख्याओं की सूची के औसत मूल्य की गणना करने की आवश्यकता है; निम्नलिखित घोषणा यह करने के लिए प्रतीत होता है, लेकिन यह संकलन नहीं होगा:

averageOfList ll = sum ll / length ll

समस्या विभाजन (/) फ़ंक्शन के साथ है: इसका हस्ताक्षर है (/) :: Fractional a => a -> a -> a , लेकिन हर के ऊपर मामले में ( length :: Foldable t => ta -> Int द्वारा दिया गया length :: Foldable t => ta -> Int ) प्रकार का है Int (और Int से संबंधित नहीं है Fractional इसलिए त्रुटि संदेश वर्ग)।

हम त्रुटि संदेश को fromIntegral :: (Num b, Integral a) => a -> b । कोई यह देख सकता है कि यह फ़ंक्शन किसी भी Integral प्रकार के मूल्यों को स्वीकार करता है और Num वर्ग में संबंधित रिटर्न देता है:

averageOfList' :: (Foldable t, Fractional a) => t a -> a
averageOfList' ll = sum ll / fromIntegral (length ll)

कार्य उदाहरण

(+) का प्रकार क्या है?

λ> :t (+)
(+) :: Num a => a -> a -> a

sqrt का प्रकार क्या है?

λ> :t sqrt
sqrt :: Floating a => a -> a

sqrt . fromIntegral का प्रकार क्या है sqrt . fromIntegral ?

sqrt . fromIntegral :: (Integral a, Floating c) => a -> c

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

Haskell Language
अंकगणित

खोज…