| ... | ... | @@ -108,6 +108,20 @@ pub struct OutStream { |
| 108 | 108 | return amt_printed; |
| 109 | 109 | } |
| 110 | 110 | |
| 111 | pub fn print_f64(os: &OutStream, x: f64) -> %isize { |
| 112 | if (os.index + max_f64_digits >= os.buffer.len) { |
| 113 | %return os.flush(); |
| 114 | } |
| 115 | const amt_printed = buf_print_f64(os.buffer[os.index...], x, 4); |
| 116 | os.index += amt_printed; |
| 117 | |
| 118 | if (!os.buffered) { |
| 119 | %return os.flush(); |
| 120 | } |
| 121 | |
| 122 | return amt_printed; |
| 123 | } |
| 124 | |
| 111 | 125 | pub fn flush(os: &OutStream) -> %void { |
| 112 | 126 | const amt_written = write(os.fd, os.buffer.ptr, os.index); |
| 113 | 127 | os.index = 0; |
| ... | ... | @@ -229,6 +243,124 @@ pub fn buf_print_u64(out_buf: []u8, x: u64) -> isize { |
| 229 | 243 | return len; |
| 230 | 244 | } |
| 231 | 245 | |
| 246 | pub fn buf_print_f64(out_buf: []u8, x: f64, decimals: isize) -> isize { |
| 247 | var decs = decimals; |
| 248 | if (decs >= max_u64_base10_digits) { |
| 249 | decs = max_u64_base10_digits - 1; |
| 250 | } |
| 251 | |
| 252 | if (x == f64_get_pos_inf()) { |
| 253 | const buf2 = "+Inf"; |
| 254 | @memcpy(&out_buf[0], &buf2[0], buf2.len); |
| 255 | return 4; |
| 256 | } else if (x == f64_get_neg_inf()) { |
| 257 | const buf2 = "-Inf"; |
| 258 | @memcpy(&out_buf[0], &buf2[0], buf2.len); |
| 259 | return 4; |
| 260 | } else if (f64_is_nan(x)) { |
| 261 | const buf2 = "NaN"; |
| 262 | @memcpy(&out_buf[0], &buf2[0], buf2.len); |
| 263 | return 3; |
| 264 | } |
| 265 | |
| 266 | var buf: [max_f64_digits]u8 = undefined; |
| 267 | |
| 268 | var len: isize = 0; |
| 269 | |
| 270 | // 1 sign bit |
| 271 | // 11 exponent bits |
| 272 | // 52 significand bits (+ 1 implicit always non-zero bit) |
| 273 | |
| 274 | const bits = f64_to_bits(x); |
| 275 | if (bits & (1 << 63) != 0) { |
| 276 | buf[0] = '-'; |
| 277 | len += 1; |
| 278 | } |
| 279 | |
| 280 | const rexponent: i64 = i64((bits >> 52) & ((1 << 11) - 1)); |
| 281 | const exponent = rexponent - 1023 - 52; |
| 282 | |
| 283 | if (rexponent == 0) { |
| 284 | buf[len] = '0'; |
| 285 | len += 1; |
| 286 | @memcpy(&out_buf[0], &buf[0], len); |
| 287 | return len; |
| 288 | } |
| 289 | |
| 290 | const sig = (bits & ((1 << 52) - 1)) | (1 << 52); |
| 291 | |
| 292 | if (exponent >= 0) { |
| 293 | // number is an integer |
| 294 | |
| 295 | if (exponent >= 11) { |
| 296 | // use XeX form |
| 297 | |
| 298 | // TODO support printing large floats |
| 299 | //len += buf_print_u64(buf[len...], sig << 10); |
| 300 | const str = "LARGEF64"; |
| 301 | @memcpy(&buf[len], &str[0], str.len); |
| 302 | len += str.len; |
| 303 | } else { |
| 304 | // use typical form |
| 305 | |
| 306 | len += buf_print_u64(buf[len...], sig << u64(exponent)); |
| 307 | buf[len] = '.'; |
| 308 | len += 1; |
| 309 | |
| 310 | var i: isize = 0; |
| 311 | while (i < decs) { |
| 312 | buf[len] = '0'; |
| 313 | len += 1; |
| 314 | i += 1; |
| 315 | } |
| 316 | } |
| 317 | } else { |
| 318 | // number is not an integer |
| 319 | |
| 320 | // print out whole part |
| 321 | len += buf_print_u64(buf[len...], sig >> u64(-exponent)); |
| 322 | buf[len] = '.'; |
| 323 | len += 1; |
| 324 | |
| 325 | // print out fractional part |
| 326 | // dec_num holds: fractional part * 10 ^ decs |
| 327 | var dec_num: u64 = 0; |
| 328 | |
| 329 | var a: isize = 1; |
| 330 | var i: isize = 0; |
| 331 | while (i < decs) { |
| 332 | a *= 10; |
| 333 | i += 1; |
| 334 | } |
| 335 | |
| 336 | // create a mask: 1's for the fractional part, 0's for whole part |
| 337 | var masked_sig = sig & ((1 << u64(-exponent)) - 1); |
| 338 | i = -1; |
| 339 | while (i >= exponent) { |
| 340 | var bit_set = ((1 << u64(i-exponent)) & masked_sig) != 0; |
| 341 | |
| 342 | if (bit_set) { |
| 343 | dec_num += usize(a) >> usize(-i); |
| 344 | } |
| 345 | |
| 346 | i -= 1; |
| 347 | } |
| 348 | |
| 349 | len += decs; |
| 350 | |
| 351 | i = len - 1; |
| 352 | while (i >= len - decs) { |
| 353 | buf[i] = '0' + u8(dec_num % 10); |
| 354 | dec_num /= 10; |
| 355 | i -= 1; |
| 356 | } |
| 357 | } |
| 358 | |
| 359 | @memcpy(&out_buf[0], &buf[0], len); |
| 360 | |
| 361 | len |
| 362 | } |
| 363 | |
| 232 | 364 | fn min_isize(x: isize, y: isize) -> isize { |
| 233 | 365 | if (x < y) x else y |
| 234 | 366 | } |
MovingtoMars <liam@bumblebee.net.nz> 2016-01-29 20:55:38+13:00