lib/core/fixed_ints.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # This file is free software, which comes along with NIT.  This software is
   4 # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
   5 # without  even  the implied warranty of  MERCHANTABILITY or  FITNESS FOR A
   6 # PARTICULAR PURPOSE.  You can modify it is you want,  provided this header
   7 # is kept unaltered, and a notification of the changes is added.
   8 # You  are  allowed  to  redistribute it and sell it, alone or is a part of
   9 # another product.
  10
  11 # Basic integers of fixed-precision
  12 #
  13 # All classes defined here have C-equivalents and the semantics of their
  14 # operations are the same as C's
  15 #
  16 # * Int8 => int8_t
  17 # * Int16 => int16_t
  18 # * UInt16 => uint16_t
  19 # * Int32 => int32_t
  20 # * UInt32 => uint32_t
  21 #
  22 # NOTE: No UInt8 is provided as Byte is the same
  23 # SEE: kernel::Byte
  24 #
  25 # HOW TO USE:
  26 # All classes can be instanciated via a literal rule.
  27 # Namely, a suffix to append after the literal integer.
  28 #
  29 # * Int8 => i8
  30 # * Byte => u8
  31 # * Int16 => i16
  32 # * UInt16 => u16
  33 # * Int32 => i32
  34 # * UInt32 => u32
  35 module fixed_ints
  36
  37 import kernel
  38
  39 in "C" `{
  40 #include <inttypes.h>
  41 `}
  42
  43 redef class Numeric
  44
  45         # The Int8 equivalent of `self`
  46         #
  47         #     assert (-1).to_i8 == 0xFFFFi8
  48         #     assert (1.9).to_i8 == 1i8
  49         fun to_i8: Int8 do return self.to_i.to_i8
  50
  51         # The Int16 equivalent of `self`
  52         #
  53         #     assert (-1).to_i16 == 0xFFFFi16
  54         #     assert (1.9).to_i16 == 1i16
  55         fun to_i16: Int16 do return self.to_i.to_i16
  56
  57         # The UInt16 equivalent of `self`
  58         #
  59         #     assert (-1).to_u16 == 0xFFFFu16
  60         #     assert (1.9).to_u16 == 1u16
  61         fun to_u16: UInt16 do return self.to_i.to_u16
  62
  63         # The Int32 equivalent of `self`
  64         #
  65         #     assert (-1).to_i32 == 0xFFFFFFFFi32
  66         #     assert (1.9).to_i32 == 1i32
  67         fun to_i32: Int32 do return self.to_i.to_i32
  68
  69         # The UInt32 equivalent of `self`
  70         #
  71         #     assert (-1).to_u32 == 0xFFFFFFFFu32
  72         #     assert (1.9).to_u32 == 1u32
  73         fun to_u32: UInt32 do return self.to_i.to_u32
  74
  75 end
  76
  77 redef class Float
  78         redef fun to_i8 is intern
  79         redef fun to_i16 is intern
  80         redef fun to_u16 is intern
  81         redef fun to_i32 is intern
  82         redef fun to_u32 is intern
  83 end
  84
  85 redef class Byte
  86         redef fun to_i8 is intern
  87         redef fun to_i16 is intern
  88         redef fun to_u16 is intern
  89         redef fun to_i32 is intern
  90         redef fun to_u32 is intern
  91 end
  92
  93 redef class Int
  94         redef fun to_i8 is intern
  95         redef fun to_i16 is intern
  96         redef fun to_u16 is intern
  97         redef fun to_i32 is intern
  98         redef fun to_u32 is intern
  99 end
 100
 101 # Native 8-bit signed integer.
 102 # Same as a C `int8_t`
 103 universal Int8
 104         super Discrete
 105         super Numeric
 106
 107         redef type OTHER: Int8
 108
 109         redef fun successor(i) do return self + i.to_i8
 110         redef fun predecessor(i) do return self - i.to_i8
 111
 112         redef fun object_id is intern
 113         redef fun hash do return self.to_i
 114         redef fun ==(i) is intern
 115         redef fun !=(i) is intern
 116         redef fun output is intern
 117
 118         redef fun <=(i) is intern
 119         redef fun <(i) is intern
 120         redef fun >=(i) is intern
 121         redef fun >(i) is intern
 122         redef fun +(i) is intern
 123
 124         #     assert -1i8 == 0xFFi8
 125         #     assert -0i8 == 0x00i8
 126         redef fun - is intern
 127         redef fun -(i) is intern
 128         redef fun *(i) is intern
 129         redef fun /(i) is intern
 130
 131         # Modulo of `self` with `i`.
 132         #
 133         # Returns the remainder of division of `self` by `i`.
 134         #
 135         #     assert 5i8 % 2i8          == 1i8
 136         #     assert 10i8 % 2i8         == 0i8
 137         fun %(i: Int8): Int8 is intern
 138
 139         redef fun zero do return 0.to_i8
 140         redef fun value_of(val) do return val.to_i8
 141
 142         # `i` bits shift to the left
 143         #
 144         #     assert 5i8 << 1    == 10i8
 145         fun <<(i: Int): Int8 is intern
 146
 147         # `i` bits shift to the right
 148         #
 149         #     assert 5i8 >> 1    == 2i8
 150         fun >>(i: Int): Int8 is intern
 151
 152         redef fun to_i is intern
 153         redef fun to_f is intern
 154         redef fun to_b is intern
 155         redef fun to_i8 do return self
 156         redef fun to_i16 is intern
 157         redef fun to_u16 is intern
 158         redef fun to_i32 is intern
 159         redef fun to_u32 is intern
 160
 161         # Returns `self` as a Char according to its ASCII value.
 162         fun ascii: Char `{ return (uint32_t)self; `}
 163
 164         redef fun distance(i) do return (self - i).to_i
 165
 166         redef fun <=>(other)
 167         do
 168                 if self < other then
 169                         return -1
 170                 else if other < self then
 171                         return 1
 172                 else
 173                         return 0
 174                 end
 175         end
 176
 177         redef fun is_between(c, d)
 178         do
 179                 if self < c or d < self then
 180                         return false
 181                 else
 182                         return true
 183                 end
 184         end
 185
 186         redef fun max(other)
 187         do
 188                 if self < other then
 189                         return other
 190                 else
 191                         return self
 192                 end
 193         end
 194
 195         redef fun min(c)
 196         do
 197                 if c < self then
 198                         return c
 199                 else
 200                         return self
 201                 end
 202         end
 203
 204         # Returns the result of a binary AND operation on `self` and `i`
 205         #
 206         #     assert 0x10i8 & 0x01i8 == 0i8
 207         fun &(i: Int8): Int8 is intern
 208
 209         # Returns the result of a binary OR operation on `self` and `i`
 210         #
 211         #     assert 0x10i8 | 0x01i8 == 0x11i8
 212         fun |(i: Int8): Int8 is intern
 213
 214         # Returns the result of a binary XOR operation on `self` and `i`
 215         #
 216         #     assert 0x101i8 ^ 0x110i8 == 0x11i8
 217         fun ^(i: Int8): Int8 is intern
 218
 219         # Returns the 1's complement of `self`
 220         #
 221         #     assert ~0x2Fi8 == 0xD0i8
 222         fun ~: Int8 is intern
 223 end
 224
 225 # Native 16-bit signed integer.
 226 # Same as a C `int16_t`
 227 universal Int16
 228         super Discrete
 229         super Numeric
 230
 231         redef type OTHER: Int16
 232
 233         redef fun successor(i) do return self + i.to_i16
 234         redef fun predecessor(i) do return self - i.to_i16
 235
 236         redef fun object_id is intern
 237         redef fun hash do return self.to_i
 238         redef fun ==(i) is intern
 239         redef fun !=(i) is intern
 240         redef fun output is intern
 241
 242         redef fun <=(i) is intern
 243         redef fun <(i) is intern
 244         redef fun >=(i) is intern
 245         redef fun >(i) is intern
 246         redef fun +(i) is intern
 247
 248         #     assert -1i16 == 0xFFFFi16
 249         #     assert -0i16 == 0i16
 250         redef fun - is intern
 251         redef fun -(i) is intern
 252         redef fun *(i) is intern
 253         redef fun /(i) is intern
 254
 255         # Returns `self` as a Char according to its ASCII value.
 256         fun ascii: Char `{ return (uint32_t)self; `}
 257
 258         # Modulo of `self` with `i`.
 259         #
 260         # Returns the remainder of division of `self` by `i`.
 261         #
 262         #     assert 5i16 % 2i16        == 1i16
 263         #     assert 10i16 % 2i16       == 0i16
 264         fun %(i: Int16): Int16 is intern
 265
 266         redef fun zero do return 0.to_i16
 267         redef fun value_of(val) do return val.to_i16
 268
 269         # `i` bits shift to the left
 270         #
 271         #     assert 5i16 << 1 == 10i16
 272         fun <<(i: Int): Int16 is intern
 273
 274         # `i` bits shift to the right
 275         #
 276         #     assert 5i16 >> 1 == 2i16
 277         fun >>(i: Int): Int16 is intern
 278
 279         redef fun to_i is intern
 280         redef fun to_f is intern
 281         redef fun to_b is intern
 282         redef fun to_i8 is intern
 283         redef fun to_i16 do return self
 284         redef fun to_u16 is intern
 285         redef fun to_i32 is intern
 286         redef fun to_u32 is intern
 287
 288         redef fun distance(i) do return (self - i).to_i
 289
 290         redef fun <=>(other)
 291         do
 292                 if self < other then
 293                         return -1
 294                 else if other < self then
 295                         return 1
 296                 else
 297                         return 0
 298                 end
 299         end
 300
 301         redef fun is_between(c, d)
 302         do
 303                 if self < c or d < self then
 304                         return false
 305                 else
 306                         return true
 307                 end
 308         end
 309
 310         redef fun max(other)
 311         do
 312                 if self < other then
 313                         return other
 314                 else
 315                         return self
 316                 end
 317         end
 318
 319         redef fun min(c)
 320         do
 321                 if c < self then
 322                         return c
 323                 else
 324                         return self
 325                 end
 326         end
 327
 328         # Returns the result of a binary AND operation on `self` and `i`
 329         #
 330         #     assert 0x10i16 & 0x01i16 == 0i16
 331         fun &(i: Int16): Int16 is intern
 332
 333         # Returns the result of a binary OR operation on `self` and `i`
 334         #
 335         #     assert 0x10i16 | 0x01i16 == 0x11i16
 336         fun |(i: Int16): Int16 is intern
 337
 338         # Returns the result of a binary XOR operation on `self` and `i`
 339         #
 340         #     assert 0x101i16 ^ 0x110i16 == 0x11i16
 341         fun ^(i: Int16): Int16 is intern
 342
 343         # Returns the 1's complement of `self`
 344         #
 345         #     assert ~0x2Fi16 == 0xFFD0i16
 346         fun ~: Int16 is intern
 347 end
 348
 349 # Native 16-bit unsigned integer.
 350 # Same as a C `uint16_t`
 351 universal UInt16
 352         super Discrete
 353         super Numeric
 354
 355         redef type OTHER: UInt16
 356
 357         redef fun successor(i) do return self + i.to_u16
 358         redef fun predecessor(i) do return self - i.to_u16
 359
 360         redef fun object_id is intern
 361         redef fun hash do return self.to_i
 362         redef fun ==(i) is intern
 363         redef fun !=(i) is intern
 364         redef fun output is intern
 365
 366         redef fun <=(i) is intern
 367         redef fun <(i) is intern
 368         redef fun >=(i) is intern
 369         redef fun >(i) is intern
 370         redef fun +(i) is intern
 371
 372         #     assert -1u16 == 0xFFFFu16
 373         #     assert -0u16 == 0u16
 374         redef fun - is intern
 375         redef fun -(i) is intern
 376         redef fun *(i) is intern
 377         redef fun /(i) is intern
 378
 379         # Modulo of `self` with `i`.
 380         #
 381         # Returns the remainder of division of `self` by `i`.
 382         #
 383         #     assert 5u16 % 2u16        == 1u16
 384         #     assert 10u16 % 2u16       == 0u16
 385         fun %(i: UInt16): UInt16 is intern
 386
 387         redef fun zero do return 0.to_u16
 388         redef fun value_of(val) do return val.to_u16
 389
 390         # Returns `self` as a Char according to its ASCII value.
 391         fun ascii: Char `{ return (uint32_t)self; `}
 392
 393         # `i` bits shift to the left
 394         #
 395         #     assert 5u16 << 1    == 10u16
 396         fun <<(i: Int): UInt16 is intern
 397
 398         # `i` bits shift to the right
 399         #
 400         #     assert 5u16 >> 1    == 2u16
 401         fun >>(i: Int): UInt16 is intern
 402
 403         redef fun to_i is intern
 404         redef fun to_f is intern
 405         redef fun to_b is intern
 406         redef fun to_i8 is intern
 407         redef fun to_i16 is intern
 408         redef fun to_u16 do return self
 409         redef fun to_i32 is intern
 410         redef fun to_u32 is intern
 411
 412         redef fun distance(i) do return (self - i).to_i
 413
 414         redef fun <=>(other)
 415         do
 416                 if self < other then
 417                         return -1
 418                 else if other < self then
 419                         return 1
 420                 else
 421                         return 0
 422                 end
 423         end
 424
 425         redef fun is_between(c, d)
 426         do
 427                 if self < c or d < self then
 428                         return false
 429                 else
 430                         return true
 431                 end
 432         end
 433
 434         redef fun max(other)
 435         do
 436                 if self < other then
 437                         return other
 438                 else
 439                         return self
 440                 end
 441         end
 442
 443         redef fun min(c)
 444         do
 445                 if c < self then
 446                         return c
 447                 else
 448                         return self
 449                 end
 450         end
 451
 452         # Returns the result of a binary AND operation on `self` and `i`
 453         #
 454         #     assert 0x10u16 & 0x01u16 == 0u16
 455         fun &(i: UInt16): UInt16 is intern
 456
 457         # Returns the result of a binary OR operation on `self` and `i`
 458         #
 459         #     assert 0x10u16 | 0x01u16 == 0x11u16
 460         fun |(i: UInt16): UInt16 is intern
 461
 462         # Returns the result of a binary XOR operation on `self` and `i`
 463         #
 464         #     assert 0x101u16 ^ 0x110u16 == 0x11u16
 465         fun ^(i: UInt16): UInt16 is intern
 466
 467         # Returns the 1's complement of `self`
 468         #
 469         #     assert ~0x2Fu16 == 0xFFD0u16
 470         fun ~: UInt16 is intern
 471 end
 472
 473 # Native 32-bit signed integer.
 474 # Same as a C `int32_t`
 475 universal Int32
 476         super Discrete
 477         super Numeric
 478
 479         redef type OTHER: Int32
 480
 481         redef fun successor(i) do return self + i.to_i32
 482         redef fun predecessor(i) do return self - i.to_i32
 483
 484         redef fun object_id is intern
 485         redef fun hash do return self.to_i
 486         redef fun ==(i) is intern
 487         redef fun !=(i) is intern
 488         redef fun output is intern
 489
 490         redef fun <=(i) is intern
 491         redef fun <(i) is intern
 492         redef fun >=(i) is intern
 493         redef fun >(i) is intern
 494         redef fun +(i) is intern
 495
 496         #     assert -1i32 == 0xFFFFFFFFi32
 497         #     assert -0i32 == 0x00i32
 498         redef fun - is intern
 499         redef fun -(i) is intern
 500         redef fun *(i) is intern
 501         redef fun /(i) is intern
 502
 503         # Returns `self` as a Char according to its ASCII value.
 504         fun ascii: Char `{ return (uint32_t)self; `}
 505
 506         # Modulo of `self` with `i`.
 507         #
 508         # Returns the remainder of division of `self` by `i`.
 509         #
 510         #     assert 5i32 % 2i32                == 1i32
 511         #     assert 10i32 % 2i32               == 0i32
 512         fun %(i: Int32): Int32 is intern
 513
 514         redef fun zero do return 0.to_i32
 515         redef fun value_of(val) do return val.to_i32
 516
 517         # `i` bits shift to the left
 518         #
 519         #     assert 5i32 << 1    == 10i32
 520         fun <<(i: Int): Int32 is intern
 521
 522         # `i` bits shift to the right
 523         #
 524         #     assert 5i32 >> 1    == 2i32
 525         fun >>(i: Int): Int32 is intern
 526
 527         redef fun to_i is intern
 528         redef fun to_f is intern
 529         redef fun to_b is intern
 530         redef fun to_i8 is intern
 531         redef fun to_i16 is intern
 532         redef fun to_u16 is intern
 533         redef fun to_i32 do return self
 534         redef fun to_u32 is intern
 535
 536         redef fun distance(i) do return (self - i).to_i
 537
 538         redef fun <=>(other)
 539         do
 540                 if self < other then
 541                         return -1
 542                 else if other < self then
 543                         return 1
 544                 else
 545                         return 0
 546                 end
 547         end
 548
 549         redef fun is_between(c, d)
 550         do
 551                 if self < c or d < self then
 552                         return false
 553                 else
 554                         return true
 555                 end
 556         end
 557
 558         redef fun max(other)
 559         do
 560                 if self < other then
 561                         return other
 562                 else
 563                         return self
 564                 end
 565         end
 566
 567         redef fun min(c)
 568         do
 569                 if c < self then
 570                         return c
 571                 else
 572                         return self
 573                 end
 574         end
 575
 576         # Returns the result of a binary AND operation on `self` and `i`
 577         #
 578         #     assert 0x10i32 & 0x01i32 == 0i32
 579         fun &(i: Int32): Int32 is intern
 580
 581         # Returns the result of a binary OR operation on `self` and `i`
 582         #
 583         #     assert 0x10i32 | 0x01i32 == 0x11i32
 584         fun |(i: Int32): Int32 is intern
 585
 586         # Returns the result of a binary XOR operation on `self` and `i`
 587         #
 588         #     assert 0x101i32 ^ 0x110i32 == 0x11i32
 589         fun ^(i: Int32): Int32 is intern
 590
 591         # Returns the 1's complement of `self`
 592         #
 593         #     assert ~0x2Fi32 == 0xFFFFFFD0i32
 594         fun ~: Int32 is intern
 595 end
 596
 597 # Native 32-bit unsigned integer.
 598 # Same as a C `uint32_t`
 599 universal UInt32
 600         super Discrete
 601         super Numeric
 602
 603         redef type OTHER: UInt32
 604
 605         redef fun successor(i) do return self + i.to_u32
 606         redef fun predecessor(i) do return self - i.to_u32
 607
 608         redef fun object_id is intern
 609         redef fun hash do return self.to_i
 610         redef fun ==(i) is intern
 611         redef fun !=(i) is intern
 612         redef fun output is intern
 613
 614         redef fun <=(i) is intern
 615         redef fun <(i) is intern
 616         redef fun >=(i) is intern
 617         redef fun >(i) is intern
 618         redef fun +(i) is intern
 619
 620         #     assert -1u32 == 0xFFFFFFFFu32
 621         #     assert -0u32 == 0x00u32
 622         redef fun - is intern
 623         redef fun -(i) is intern
 624         redef fun *(i) is intern
 625         redef fun /(i) is intern
 626
 627         # Returns `self` as a Char according to its ASCII value.
 628         fun ascii: Char `{ return (uint32_t)self; `}
 629
 630         # Modulo of `self` with `i`.
 631         #
 632         # Returns the remainder of division of `self` by `i`.
 633         #
 634         #     assert 5u32 % 2u32                == 1u32
 635         #     assert 10u32 % 2u32               == 0u32
 636         fun %(i: UInt32): UInt32 is intern
 637
 638         redef fun zero do return 0.to_u32
 639         redef fun value_of(val) do return val.to_u32
 640
 641         # `i` bits shift to the left
 642         #
 643         #     assert 5u32 << 1    == 10u32
 644         fun <<(i: Int): UInt32 is intern
 645
 646         # `i` bits shift to the right
 647         #
 648         #     assert 5u32 >> 1    == 2u32
 649         fun >>(i: Int): UInt32 is intern
 650
 651         redef fun to_i is intern
 652         redef fun to_f is intern
 653         redef fun to_b is intern
 654         redef fun to_i8 is intern
 655         redef fun to_i16 is intern
 656         redef fun to_u16 is intern
 657         redef fun to_i32 is intern
 658         redef fun to_u32 do return self
 659
 660         redef fun distance(i) do return (self - i).to_i
 661
 662         redef fun <=>(other)
 663         do
 664                 if self < other then
 665                         return -1
 666                 else if other < self then
 667                         return 1
 668                 else
 669                         return 0
 670                 end
 671         end
 672
 673         redef fun is_between(c, d)
 674         do
 675                 if self < c or d < self then
 676                         return false
 677                 else
 678                         return true
 679                 end
 680         end
 681
 682         redef fun max(other)
 683         do
 684                 if self < other then
 685                         return other
 686                 else
 687                         return self
 688                 end
 689         end
 690
 691         redef fun min(c)
 692         do
 693                 if c < self then
 694                         return c
 695                 else
 696                         return self
 697                 end
 698         end
 699
 700         # Returns the result of a binary AND operation on `self` and `i`
 701         #
 702         #     assert 0x10u32 & 0x01u32 == 0u32
 703         fun &(i: UInt32): UInt32 is intern
 704
 705         # Returns the result of a binary OR operation on `self` and `i`
 706         #
 707         #     assert 0x10u32 | 0x01u32 == 0x11u32
 708         fun |(i: UInt32): UInt32 is intern
 709
 710         # Returns the result of a binary XOR operation on `self` and `i`
 711         #
 712         #     assert 0x101u32 ^ 0x110u32 == 0x11u32
 713         fun ^(i: UInt32): UInt32 is intern
 714
 715         # Returns the 1's complement of `self`
 716         #
 717         #     assert ~0x2Fu32 == 0xFFFFFFD0u32
 718         fun ~: UInt32 is intern
 719 end