about summary refs log tree commit diff stats
path: root/409print-float-hex.mu
blob: 043576b63e4120d5cdc70e8829583cc0df3cd705 (plain) (blame)
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
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
# quick-n-dirty way to print out floats in hex
# https://www.exploringbinary.com/hexadecimal-floating-point-constants

# example:
#   0.5 = 0x3f000000 = 0011| 1111 | 0000 | 0000 | 0000 | 0000 | 0000 | 0000
#                    = 0 | 01111110 | 00000000000000000000000
#                      +   exponent   mantissa
#                    = 0 | 00000000000000000000000 | 01111110
#                          mantissa                  exponent
#                    = 0 | 000000000000000000000000 | 01111110
#                          zero-pad mantissa          exponent
#                   =   +1.000000                   P -01
fn test-print-float-hex-normal {
  var screen-on-stack: screen
  var screen/esi: (addr screen) <- address screen-on-stack
  initialize-screen screen, 5, 0x20  # 32 columns should be more than enough
  # 0.5
  var half/xmm0: float <- rational 1, 2
  print-float-hex screen, half
  check-screen-row screen, 1, "1.000000P-01 ", "F - test-print-float-hex-normal 0.5"
  # 0.25
  clear-screen screen
  var quarter/xmm0: float <- rational 1, 4
  print-float-hex screen, quarter
  check-screen-row screen, 1, "1.000000P-02 ", "F - test-print-float-hex-normal 0.25"
  # 0.75
  clear-screen screen
  var three-quarters/xmm0: float <- rational 3, 4
  print-float-hex screen, three-quarters
  check-screen-row screen, 1, "1.800000P-01 ", "F - test-print-float-hex-normal 0.75"
  # 0.1
  clear-screen screen
  var tenth/xmm0: float <- rational 1, 0xa
  print-float-hex screen, tenth
  check-screen-row screen, 1, "1.99999aP-04 ", "F - test-print-float-hex-normal 0.1"
}

fn test-print-float-hex-integer {
  var screen-on-stack: screen
  var screen/esi: (addr screen) <- address screen-on-stack
  initialize-screen screen, 5, 0x20  # 32 columns should be more than enough
  # 1
  var one-f/xmm0: float <- rational 1, 1
  print-float-hex screen, one-f
  check-screen-row screen, 1, "1.000000P00 ", "F - test-print-float-hex-integer 1"
  # 2
  clear-screen screen
  var two-f/xmm0: float <- rational 2, 1
  print-float-hex screen, two-f
  check-screen-row screen, 1, "1.000000P01 ", "F - test-print-float-hex-integer 2"
  # 10
  clear-screen screen
  var ten-f/xmm0: float <- rational 0xa, 1
  print-float-hex screen, ten-f
  check-screen-row screen, 1, "1.400000P03 ", "F - test-print-float-hex-integer 10"
  # -10
  clear-screen screen
  var minus-ten-f/xmm0: float <- rational -0xa, 1
  print-float-hex screen, minus-ten-f
  check-screen-row screen, 1, "-1.400000P03 ", "F - test-print-float-hex-integer -10"
}

fn test-print-float-hex-zero {
  var screen-on-stack: screen
  var screen/esi: (addr screen) <- address screen-on-stack
  initialize-screen screen, 5, 0x20  # 32 columns should be more than enough
  var zero: float
  print-float-hex screen, zero
  check-screen-row screen, 1, "0 ", "F - test-print-float-hex-zero"
}

fn test-print-float-hex-negative-zero {
  var screen-on-stack: screen
  var screen/esi: (addr screen) <- address screen-on-stack
  initialize-screen screen, 5, 0x20  # 32 columns should be more than enough
  var n: int
  copy-to n, 0x80000000
  var negative-zero/xmm0: float <- reinterpret n
  print-float-hex screen, negative-zero
  check-screen-row screen, 1, "-0 ", "F - test-print-float-hex-negative-zero"
}

fn test-print-float-hex-infinity {
  var screen-on-stack: screen
  var screen/esi: (addr screen) <- address screen-on-stack
  initialize-screen screen, 5, 0x20  # 32 columns should be more than enough
  var n: int
  #          0|11111111|00000000000000000000000
  #          0111|1111|1000|0000|0000|0000|0000|0000
  copy-to n, 0x7f800000
  var infinity/xmm0: float <- reinterpret n
  print-float-hex screen, infinity
  check-screen-row screen, 1, "Inf ", "F - test-print-float-hex-infinity"
}

fn test-print-float-hex-negative-infinity {
  var screen-on-stack: screen
  var screen/esi: (addr screen) <- address screen-on-stack
  initialize-screen screen, 5, 0x20  # 32 columns should be more than enough
  var n: int
  copy-to n, 0xff800000
  var negative-infinity/xmm0: float <- reinterpret n
  print-float-hex screen, negative-infinity
  check-screen-row screen, 1, "-Inf ", "F - test-print-float-hex-negative-infinity"
}

fn test-print-float-hex-not-a-number {
  var screen-on-stack: screen
  var screen/esi: (addr screen) <- address screen-on-stack
  initialize-screen screen, 5, 0x20  # 32 columns should be more than enough
  var n: int
  copy-to n, 0xffffffff  # exponent must be all 1's, and mantissa must be non-zero
  var negative-infinity/xmm0: float <- reinterpret n
  print-float-hex screen, negative-infinity
  check-screen-row screen, 1, "NaN ", "F - test-print-float-hex-not-a-number"
}

fn print-float-hex screen: (addr screen), n: float {
  # - special names
  var bits/eax: int <- reinterpret n
  compare bits, 0
  {
    break-if-!=
    print-string screen, "0"
    return
  }
  compare bits, 0x80000000
  {
    break-if-!=
    print-string screen, "-0"
    return
  }
  compare bits, 0x7f800000
  {
    break-if-!=
    print-string screen, "Inf"
    return
  }
  compare bits, 0xff800000
  {
    break-if-!=
    print-string screen, "-Inf"
    return
  }
  var exponent/ecx: int <- copy bits
  exponent <- shift-right 0x17  # 23 bits of mantissa
  exponent <- and 0xff
  exponent <- subtract 0x7f
  compare exponent, 0x80
  {
    break-if-!=
    print-string screen, "NaN"
    return
  }
  # - regular numbers
  var sign/edx: int <- copy bits
  sign <- shift-right 0x1f
  {
    compare sign, 1
    break-if-!=
    print-string screen, "-"
  }
  $print-float-hex:leading-digit: {
    # check for subnormal numbers
    compare exponent, -0x7f
    {
      break-if-!=
      print-string screen, "0."
      exponent <- increment
      break $print-float-hex:leading-digit
    }
    # normal numbers
    print-string screen, "1."
  }
  var mantissa/ebx: int <- copy bits
  mantissa <- and 0x7fffff
  mantissa <- shift-left 1  # pad to whole nibbles
  print-int32-hex-bits screen, mantissa, 0x18
  # print exponent
  print-string screen, "P"
  compare exponent, 0
  {
    break-if->=
    print-string screen, "-"
  }
  var exp-magnitude/eax: int <- abs exponent
  print-int32-hex-bits screen, exp-magnitude, 8
}

#? fn main -> _/ebx: int {
#?   run-tests
#? #?   test-print-float-hex-negative-zero
#? #?   print-int32-hex 0, 0
#? #?   test-print-float-hex-normal
#?   return 0
#? }