1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
-- |
-- Module: Math.NumberTheory.Utils.FromIntegral
-- Copyright: (c) 2017 Andrew Lelechenko
-- Licence: MIT
-- Maintainer: Andrew Lelechenko <andrew.lelechenko@gmail.com>
--
-- Monomorphic `fromIntegral`.
--
{-# LANGUAGE CPP #-}
module Math.NumberTheory.Utils.FromIntegral
( wordToInt
, wordToInteger
, intToWord
, intToInt8
, intToInt64
, int8ToInt64
, intToWord8
, intToWord64
, int8ToInt
, int64ToInt
, word8ToInt
, word64ToInt
, intToInteger
, int16ToInteger
, int64ToInteger
, word64ToInteger
, naturalToInteger
, integerToNatural
, integerToWord
, integerToWord64
, integerToInt
, integerToInt64
, intToNatural
, naturalToInt
, intToDouble
, fromIntegral'
) where
import Data.Int
import Data.Word
import Numeric.Natural
wordToInt :: Word -> Int
wordToInt = fromIntegral
{-# INLINE wordToInt #-}
wordToInteger :: Word -> Integer
wordToInteger = fromIntegral
{-# INLINE wordToInteger #-}
intToWord :: Int -> Word
intToWord = fromIntegral
{-# INLINE intToWord #-}
intToInt8 :: Int -> Int8
intToInt8 = fromIntegral
{-# INLINE intToInt8 #-}
intToInt64 :: Int -> Int64
intToInt64 = fromIntegral
{-# INLINE intToInt64 #-}
int8ToInt64 :: Int8 -> Int64
int8ToInt64 = fromIntegral
{-# INLINE int8ToInt64 #-}
intToWord8 :: Int -> Word8
intToWord8 = fromIntegral
{-# INLINE intToWord8 #-}
intToWord64 :: Int -> Word64
intToWord64 = fromIntegral
{-# INLINE intToWord64 #-}
int8ToInt :: Int8 -> Int
int8ToInt = fromIntegral
{-# INLINE int8ToInt #-}
int64ToInt :: Int64 -> Int
int64ToInt = fromIntegral
{-# INLINE int64ToInt #-}
word8ToInt :: Word8 -> Int
word8ToInt = fromIntegral
{-# INLINE word8ToInt #-}
word64ToInt :: Word64 -> Int
word64ToInt = fromIntegral
{-# INLINE word64ToInt #-}
intToInteger :: Int -> Integer
intToInteger = fromIntegral
{-# INLINE intToInteger #-}
int16ToInteger :: Int16 -> Integer
int16ToInteger = fromIntegral
{-# INLINE int16ToInteger #-}
int64ToInteger :: Int64 -> Integer
int64ToInteger = fromIntegral
{-# INLINE int64ToInteger #-}
word64ToInteger :: Word64 -> Integer
word64ToInteger = fromIntegral
{-# INLINE word64ToInteger #-}
naturalToInteger :: Natural -> Integer
naturalToInteger = fromIntegral
{-# INLINE naturalToInteger #-}
integerToNatural :: Integer -> Natural
integerToNatural = fromIntegral'
{-# INLINE integerToNatural #-}
integerToWord :: Integer -> Word
integerToWord = fromIntegral
{-# INLINE integerToWord #-}
integerToWord64 :: Integer -> Word64
integerToWord64 = fromIntegral
{-# INLINE integerToWord64 #-}
integerToInt :: Integer -> Int
integerToInt = fromIntegral
{-# INLINE integerToInt #-}
integerToInt64 :: Integer -> Int64
integerToInt64 = fromIntegral
{-# INLINE integerToInt64 #-}
intToNatural :: Int -> Natural
intToNatural = fromIntegral
{-# INLINE intToNatural #-}
naturalToInt :: Natural -> Int
naturalToInt = fromIntegral
{-# INLINE naturalToInt #-}
intToDouble :: Int -> Double
intToDouble = fromIntegral
{-# INLINE intToDouble #-}
fromIntegral' :: (Integral a, Num b) => a -> b
#if __GLASGOW_HASKELL__ == 900 && __GLASGOW_HASKELL_PATCHLEVEL1__ == 1
-- Cannot use fromIntegral because of https://gitlab.haskell.org/ghc/ghc/-/issues/19411
fromIntegral' = fromInteger . toInteger
#else
fromIntegral' = fromIntegral
#endif
{-# INLINE fromIntegral' #-}
|
