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         redef fun distance(i) do return (self - i).to_i
 162
 163         redef fun <=>(other)
 164         do
 165                 if self < other then
 166                         return -1
 167                 else if other < self then
 168                         return 1
 169                 else
 170                         return 0
 171                 end
 172         end
 173
 174         redef fun is_between(c, d)
 175         do
 176                 if self < c or d < self then
 177                         return false
 178                 else
 179                         return true
 180                 end
 181         end
 182
 183         redef fun max(other)
 184         do
 185                 if self < other then
 186                         return other
 187                 else
 188                         return self
 189                 end
 190         end
 191
 192         redef fun min(c)
 193         do
 194                 if c < self then
 195                         return c
 196                 else
 197                         return self
 198                 end
 199         end
 200
 201         # Returns the result of a binary AND operation on `self` and `i`
 202         #
 203         #     assert 0x10i8 & 0x01i8 == 0i8
 204         fun &(i: Int8): Int8 is intern
 205
 206         # Returns the result of a binary OR operation on `self` and `i`
 207         #
 208         #     assert 0x10i8 | 0x01i8 == 0x11i8
 209         fun |(i: Int8): Int8 is intern
 210
 211         # Returns the result of a binary XOR operation on `self` and `i`
 212         #
 213         #     assert 0x101i8 ^ 0x110i8 == 0x11i8
 214         fun ^(i: Int8): Int8 is intern
 215
 216         # Returns the 1's complement of `self`
 217         #
 218         #     assert ~0x2Fi8 == 0xD0i8
 219         fun ~: Int8 is intern
 220 end
 221
 222 # Native 16-bit signed integer.
 223 # Same as a C `int16_t`
 224 universal Int16
 225         super Discrete
 226         super Numeric
 227
 228         redef type OTHER: Int16
 229
 230         redef fun successor(i) do return self + i.to_i16
 231         redef fun predecessor(i) do return self - i.to_i16
 232
 233         redef fun object_id is intern
 234         redef fun hash do return self.to_i
 235         redef fun ==(i) is intern
 236         redef fun !=(i) is intern
 237         redef fun output is intern
 238
 239         redef fun <=(i) is intern
 240         redef fun <(i) is intern
 241         redef fun >=(i) is intern
 242         redef fun >(i) is intern
 243         redef fun +(i) is intern
 244
 245         #     assert -1i16 == 0xFFFFi16
 246         #     assert -0i16 == 0i16
 247         redef fun - is intern
 248         redef fun -(i) is intern
 249         redef fun *(i) is intern
 250         redef fun /(i) is intern
 251
 252         # Modulo of `self` with `i`.
 253         #
 254         # Returns the remainder of division of `self` by `i`.
 255         #
 256         #     assert 5i16 % 2i16        == 1i16
 257         #     assert 10i16 % 2i16       == 0i16
 258         fun %(i: Int16): Int16 is intern
 259
 260         redef fun zero do return 0.to_i16
 261         redef fun value_of(val) do return val.to_i16
 262
 263         # `i` bits shift to the left
 264         #
 265         #     assert 5i16 << 1 == 10i16
 266         fun <<(i: Int): Int16 is intern
 267
 268         # `i` bits shift to the right
 269         #
 270         #     assert 5i16 >> 1 == 2i16
 271         fun >>(i: Int): Int16 is intern
 272
 273         redef fun to_i is intern
 274         redef fun to_f is intern
 275         redef fun to_b is intern
 276         redef fun to_i8 is intern
 277         redef fun to_i16 do return self
 278         redef fun to_u16 is intern
 279         redef fun to_i32 is intern
 280         redef fun to_u32 is intern
 281
 282         redef fun distance(i) do return (self - i).to_i
 283
 284         redef fun <=>(other)
 285         do
 286                 if self < other then
 287                         return -1
 288                 else if other < self then
 289                         return 1
 290                 else
 291                         return 0
 292                 end
 293         end
 294
 295         redef fun is_between(c, d)
 296         do
 297                 if self < c or d < self then
 298                         return false
 299                 else
 300                         return true
 301                 end
 302         end
 303
 304         redef fun max(other)
 305         do
 306                 if self < other then
 307                         return other
 308                 else
 309                         return self
 310                 end
 311         end
 312
 313         redef fun min(c)
 314         do
 315                 if c < self then
 316                         return c
 317                 else
 318                         return self
 319                 end
 320         end
 321
 322         # Returns the result of a binary AND operation on `self` and `i`
 323         #
 324         #     assert 0x10i16 & 0x01i16 == 0i16
 325         fun &(i: Int16): Int16 is intern
 326
 327         # Returns the result of a binary OR operation on `self` and `i`
 328         #
 329         #     assert 0x10i16 | 0x01i16 == 0x11i16
 330         fun |(i: Int16): Int16 is intern
 331
 332         # Returns the result of a binary XOR operation on `self` and `i`
 333         #
 334         #     assert 0x101i16 ^ 0x110i16 == 0x11i16
 335         fun ^(i: Int16): Int16 is intern
 336
 337         # Returns the 1's complement of `self`
 338         #
 339         #     assert ~0x2Fi16 == 0xFFD0i16
 340         fun ~: Int16 is intern
 341 end
 342
 343 # Native 16-bit unsigned integer.
 344 # Same as a C `uint16_t`
 345 universal UInt16
 346         super Discrete
 347         super Numeric
 348
 349         redef type OTHER: UInt16
 350
 351         redef fun successor(i) do return self + i.to_u16
 352         redef fun predecessor(i) do return self - i.to_u16
 353
 354         redef fun object_id is intern
 355         redef fun hash do return self.to_i
 356         redef fun ==(i) is intern
 357         redef fun !=(i) is intern
 358         redef fun output is intern
 359
 360         redef fun <=(i) is intern
 361         redef fun <(i) is intern
 362         redef fun >=(i) is intern
 363         redef fun >(i) is intern
 364         redef fun +(i) is intern
 365
 366         #     assert -1u16 == 0xFFFFu16
 367         #     assert -0u16 == 0u16
 368         redef fun - is intern
 369         redef fun -(i) is intern
 370         redef fun *(i) is intern
 371         redef fun /(i) is intern
 372
 373         # Modulo of `self` with `i`.
 374         #
 375         # Returns the remainder of division of `self` by `i`.
 376         #
 377         #     assert 5u16 % 2u16        == 1u16
 378         #     assert 10u16 % 2u16       == 0u16
 379         fun %(i: UInt16): UInt16 is intern
 380
 381         redef fun zero do return 0.to_u16
 382         redef fun value_of(val) do return val.to_u16
 383
 384         # `i` bits shift to the left
 385         #
 386         #     assert 5u16 << 1    == 10u16
 387         fun <<(i: Int): UInt16 is intern
 388
 389         # `i` bits shift to the right
 390         #
 391         #     assert 5u16 >> 1    == 2u16
 392         fun >>(i: Int): UInt16 is intern
 393
 394         redef fun to_i is intern
 395         redef fun to_f is intern
 396         redef fun to_b is intern
 397         redef fun to_i8 is intern
 398         redef fun to_i16 is intern
 399         redef fun to_u16 do return self
 400         redef fun to_i32 is intern
 401         redef fun to_u32 is intern
 402
 403         redef fun distance(i) do return (self - i).to_i
 404
 405         redef fun <=>(other)
 406         do
 407                 if self < other then
 408                         return -1
 409                 else if other < self then
 410                         return 1
 411                 else
 412                         return 0
 413                 end
 414         end
 415
 416         redef fun is_between(c, d)
 417         do
 418                 if self < c or d < self then
 419                         return false
 420                 else
 421                         return true
 422                 end
 423         end
 424
 425         redef fun max(other)
 426         do
 427                 if self < other then
 428                         return other
 429                 else
 430                         return self
 431                 end
 432         end
 433
 434         redef fun min(c)
 435         do
 436                 if c < self then
 437                         return c
 438                 else
 439                         return self
 440                 end
 441         end
 442
 443         # Returns the result of a binary AND operation on `self` and `i`
 444         #
 445         #     assert 0x10u16 & 0x01u16 == 0u16
 446         fun &(i: UInt16): UInt16 is intern
 447
 448         # Returns the result of a binary OR operation on `self` and `i`
 449         #
 450         #     assert 0x10u16 | 0x01u16 == 0x11u16
 451         fun |(i: UInt16): UInt16 is intern
 452
 453         # Returns the result of a binary XOR operation on `self` and `i`
 454         #
 455         #     assert 0x101u16 ^ 0x110u16 == 0x11u16
 456         fun ^(i: UInt16): UInt16 is intern
 457
 458         # Returns the 1's complement of `self`
 459         #
 460         #     assert ~0x2Fu16 == 0xFFD0u16
 461         fun ~: UInt16 is intern
 462 end
 463
 464 # Native 32-bit signed integer.
 465 # Same as a C `int32_t`
 466 universal Int32
 467         super Discrete
 468         super Numeric
 469
 470         redef type OTHER: Int32
 471
 472         redef fun successor(i) do return self + i.to_i32
 473         redef fun predecessor(i) do return self - i.to_i32
 474
 475         redef fun object_id is intern
 476         redef fun hash do return self.to_i
 477         redef fun ==(i) is intern
 478         redef fun !=(i) is intern
 479         redef fun output is intern
 480
 481         redef fun <=(i) is intern
 482         redef fun <(i) is intern
 483         redef fun >=(i) is intern
 484         redef fun >(i) is intern
 485         redef fun +(i) is intern
 486
 487         #     assert -1i32 == 0xFFFFFFFFi32
 488         #     assert -0i32 == 0x00i32
 489         redef fun - is intern
 490         redef fun -(i) is intern
 491         redef fun *(i) is intern
 492         redef fun /(i) is intern
 493
 494         # Modulo of `self` with `i`.
 495         #
 496         # Returns the remainder of division of `self` by `i`.
 497         #
 498         #     assert 5i32 % 2i32                == 1i32
 499         #     assert 10i32 % 2i32               == 0i32
 500         fun %(i: Int32): Int32 is intern
 501
 502         redef fun zero do return 0.to_i32
 503         redef fun value_of(val) do return val.to_i32
 504
 505         # `i` bits shift to the left
 506         #
 507         #     assert 5i32 << 1    == 10i32
 508         fun <<(i: Int): Int32 is intern
 509
 510         # `i` bits shift to the right
 511         #
 512         #     assert 5i32 >> 1    == 2i32
 513         fun >>(i: Int): Int32 is intern
 514
 515         redef fun to_i is intern
 516         redef fun to_f is intern
 517         redef fun to_b is intern
 518         redef fun to_i8 is intern
 519         redef fun to_i16 is intern
 520         redef fun to_u16 is intern
 521         redef fun to_i32 do return self
 522         redef fun to_u32 is intern
 523
 524         redef fun distance(i) do return (self - i).to_i
 525
 526         redef fun <=>(other)
 527         do
 528                 if self < other then
 529                         return -1
 530                 else if other < self then
 531                         return 1
 532                 else
 533                         return 0
 534                 end
 535         end
 536
 537         redef fun is_between(c, d)
 538         do
 539                 if self < c or d < self then
 540                         return false
 541                 else
 542                         return true
 543                 end
 544         end
 545
 546         redef fun max(other)
 547         do
 548                 if self < other then
 549                         return other
 550                 else
 551                         return self
 552                 end
 553         end
 554
 555         redef fun min(c)
 556         do
 557                 if c < self then
 558                         return c
 559                 else
 560                         return self
 561                 end
 562         end
 563
 564         # Returns the result of a binary AND operation on `self` and `i`
 565         #
 566         #     assert 0x10i32 & 0x01i32 == 0i32
 567         fun &(i: Int32): Int32 is intern
 568
 569         # Returns the result of a binary OR operation on `self` and `i`
 570         #
 571         #     assert 0x10i32 | 0x01i32 == 0x11i32
 572         fun |(i: Int32): Int32 is intern
 573
 574         # Returns the result of a binary XOR operation on `self` and `i`
 575         #
 576         #     assert 0x101i32 ^ 0x110i32 == 0x11i32
 577         fun ^(i: Int32): Int32 is intern
 578
 579         # Returns the 1's complement of `self`
 580         #
 581         #     assert ~0x2Fi32 == 0xFFFFFFD0i32
 582         fun ~: Int32 is intern
 583 end
 584
 585 # Native 32-bit unsigned integer.
 586 # Same as a C `uint32_t`
 587 universal UInt32
 588         super Discrete
 589         super Numeric
 590
 591         redef type OTHER: UInt32
 592
 593         redef fun successor(i) do return self + i.to_u32
 594         redef fun predecessor(i) do return self - i.to_u32
 595
 596         redef fun object_id is intern
 597         redef fun hash do return self.to_i
 598         redef fun ==(i) is intern
 599         redef fun !=(i) is intern
 600         redef fun output is intern
 601
 602         redef fun <=(i) is intern
 603         redef fun <(i) is intern
 604         redef fun >=(i) is intern
 605         redef fun >(i) is intern
 606         redef fun +(i) is intern
 607
 608         #     assert -1u32 == 0xFFFFFFFFu32
 609         #     assert -0u32 == 0x00u32
 610         redef fun - is intern
 611         redef fun -(i) is intern
 612         redef fun *(i) is intern
 613         redef fun /(i) is intern
 614
 615         # Modulo of `self` with `i`.
 616         #
 617         # Returns the remainder of division of `self` by `i`.
 618         #
 619         #     assert 5u32 % 2u32                == 1u32
 620         #     assert 10u32 % 2u32               == 0u32
 621         fun %(i: UInt32): UInt32 is intern
 622
 623         redef fun zero do return 0.to_u32
 624         redef fun value_of(val) do return val.to_u32
 625
 626         # `i` bits shift to the left
 627         #
 628         #     assert 5u32 << 1    == 10u32
 629         fun <<(i: Int): UInt32 is intern
 630
 631         # `i` bits shift to the right
 632         #
 633         #     assert 5u32 >> 1    == 2u32
 634         fun >>(i: Int): UInt32 is intern
 635
 636         redef fun to_i is intern
 637         redef fun to_f is intern
 638         redef fun to_b is intern
 639         redef fun to_i8 is intern
 640         redef fun to_i16 is intern
 641         redef fun to_u16 is intern
 642         redef fun to_i32 is intern
 643         redef fun to_u32 do return self
 644
 645         redef fun distance(i) do return (self - i).to_i
 646
 647         redef fun <=>(other)
 648         do
 649                 if self < other then
 650                         return -1
 651                 else if other < self then
 652                         return 1
 653                 else
 654                         return 0
 655                 end
 656         end
 657
 658         redef fun is_between(c, d)
 659         do
 660                 if self < c or d < self then
 661                         return false
 662                 else
 663                         return true
 664                 end
 665         end
 666
 667         redef fun max(other)
 668         do
 669                 if self < other then
 670                         return other
 671                 else
 672                         return self
 673                 end
 674         end
 675
 676         redef fun min(c)
 677         do
 678                 if c < self then
 679                         return c
 680                 else
 681                         return self
 682                 end
 683         end
 684
 685         # Returns the result of a binary AND operation on `self` and `i`
 686         #
 687         #     assert 0x10u32 & 0x01u32 == 0u32
 688         fun &(i: UInt32): UInt32 is intern
 689
 690         # Returns the result of a binary OR operation on `self` and `i`
 691         #
 692         #     assert 0x10u32 | 0x01u32 == 0x11u32
 693         fun |(i: UInt32): UInt32 is intern
 694
 695         # Returns the result of a binary XOR operation on `self` and `i`
 696         #
 697         #     assert 0x101u32 ^ 0x110u32 == 0x11u32
 698         fun ^(i: UInt32): UInt32 is intern
 699
 700         # Returns the 1's complement of `self`
 701         #
 702         #     assert ~0x2Fu32 == 0xFFFFFFD0u32
 703         fun ~: UInt32 is intern
 704 end