blob: 9469d44bf6cf3ec4b7be89128b52a7f8b7f97866 (
plain)
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
module Main (main) where
import Data.Bits
import Numeric.Natural (Natural)
main :: IO ()
main = do
p "andNatural" andNatural
p "bitNatural" bitNatural
p "minusNatural" minusNatural
p "naturalFromInteger" naturalFromInteger
p "naturalToInteger" naturalToInteger
p "negateNatural" negateNatural
p "orNatural" orNatural
p "plusNatural" plusNatural
p "popCountNatural" popCountNatural
p "divModNatural" divModNatural
p "divNatural" divNatural
p "modNatural" modNatural
p "quotNatural" quotNatural
p "quotRemNatural" quotRemNatural
p "remNatural" remNatural
p "gcdNatural" gcdNatural
p "lcmNatural" lcmNatural
p "shiftLNatural" shiftLNatural
p "shiftRNatural" shiftRNatural
p "signumNaturalP" signumNaturalP
p "signumNaturalZ" signumNaturalZ
p "testBitNaturalT" testBitNaturalT
p "testBitNaturalF" testBitNaturalF
p "timesNatural" timesNatural
p "wordToNatural" wordToNatural
p "naturalToWord" naturalToWord
p "intToNatural" intToNatural
p "naturalToInt" naturalToInt
p "doubleFromNatural" doubleFromNatural
p "floatFromNatural" floatFromNatural
p "xorNatural" xorNatural
p "eqNatural" eqNatural
p "neqNatural" neqNatural
p "leNatural" leNatural
p "ltNatural" ltNatural
p "geNatural" geNatural
p "gtNatural" gtNatural
p "compareNatural" compareNatural
where p :: Show a => String -> a -> IO ()
p str x = putStrLn (str ++ ": " ++ show x)
-- Bit arithmetic
andNatural :: Natural
andNatural = 100052 .&. 140053
xorNatural :: Natural
xorNatural = 100071 `xor` 140072
bitNatural :: Natural
bitNatural = bit 4
orNatural :: Natural
orNatural = 100058 .|. 140059
shiftLNatural :: Natural
shiftLNatural = 100065 `shiftL` 4
shiftRNatural :: Natural
shiftRNatural = 100066 `shiftR` 4
popCountNatural :: Int
popCountNatural = popCount (100098 :: Natural)
testBitNaturalT :: Bool
testBitNaturalT = testBit (100068 :: Natural) 2
testBitNaturalF :: Bool
testBitNaturalF = testBit (100069 :: Natural) 1
-----------------------------------------------
-- Arithmetic
plusNatural :: Natural
plusNatural = 100060 + 100061
timesNatural :: Natural
timesNatural = 100070 * 6832
minusNatural :: Natural
minusNatural = 100999 - 100010
negateNatural :: Natural
negateNatural = negate 0
signumNaturalP :: Natural
signumNaturalP = signum 100067
signumNaturalZ :: Natural
signumNaturalZ = signum 0
------------------------
-- Quotients and remainders
quotRemNatural :: (Natural, Natural)
quotRemNatural = 100063 `quotRem` 123
divModNatural :: (Natural, Natural)
divModNatural = 100060 `divMod` 456
quotNatural :: Natural
quotNatural = 100062 `quot` 156
remNatural :: Natural
remNatural = 100064 `rem` 156
divNatural :: Natural
divNatural = 100286 `div` 156
modNatural :: Natural
modNatural = 100086 `mod` 156
gcdNatural :: Natural
gcdNatural = 100048 `gcd` 150072
lcmNatural :: Natural
lcmNatural = 100050 `lcm` 100060
--------------------------------
-- Conversions
naturalFromInteger :: Natural
naturalFromInteger = fromInteger 100054 + 100055
naturalToInteger :: Integer
naturalToInteger = toInteger (100056 :: Natural) + 100057
-- Same story as the @Integer@ case: for the conversion functions, we can't
-- just check that e.g. 100065 is in the resulting core, because it will be
-- regardless of whether the rules fire or not. So we add something to the
-- number being converted, and thus rely on the addition rule for the
-- end-result type also firing.
wordToNatural :: Natural
wordToNatural = fromIntegral (100072 :: Word) + 100073
naturalToWord :: Word
naturalToWord = 100075 + fromIntegral (100074 :: Natural)
intToNatural :: Natural
intToNatural = fromIntegral (100076 :: Int) + 100077
naturalToInt :: Int
naturalToInt = fromIntegral (100078 :: Natural) + 100079
doubleFromNatural :: Double
doubleFromNatural = 100095.0 + realToFrac (100094 :: Natural)
floatFromNatural :: Float
floatFromNatural = 100097.0 + realToFrac (100096 :: Natural)
---------------------------------------------------
-- Ordering and Equality
eqNatural, neqNatural, leNatural, ltNatural, geNatural, gtNatural :: Bool
eqNatural = (100080 :: Natural) == 100081
neqNatural = (100082 :: Natural) /= 100083
leNatural = (100084 :: Natural) <= 100085
ltNatural = (100086 :: Natural) < 100087
geNatural = (100088 :: Natural) >= 100089
gtNatural = (100090 :: Natural) > 100091
compareNatural :: Ordering
compareNatural = compare (100092 :: Natural) 100093
|
