int.fz

# This file is part of the Fuzion language implementation.
#
# The Fuzion language implementation is free software: you can redistribute it
# and/or modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation, version 3 of the License.
#
# The Fuzion language implementation is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
# License for more details.
#
# You should have received a copy of the GNU General Public License along with The
# Fuzion language implementation.  If not, see <https://www.gnu.org/licenses/>.


# -----------------------------------------------------------------------
#
#  Tokiwa Software GmbH, Germany
#
#  Source code of Fuzion standard library feature int
#
#  Author: Michael Lill (michael.lill@tokiwa.software)
#
# -----------------------------------------------------------------------

# int -- signed integer values of arbitrary size
#
module:public int (public s num.sign, public n uint) : has_interval
is

  # normalize the sign => no minus zero
  ns := if n = uint.zero then num.plus else s

  public thiz => int ns n

  name String =>
    "int"

  public fixed type.zero int =>
    int num.plus uint.zero

  public fixed type.one int =>
    int num.plus uint.one


  fixed redef prefix - int =>
    match ns
      num.plus => int num.minus n
      num.minus => int num.plus n


  # add this int to other
  public fixed infix +  (other int) int =>
    if ns = other.ns
      int ns n+other.n
    else
      match ns
        num.plus => thiz - (-other)
        num.minus => other - (-thiz)


  # subtract other from this int
  public fixed infix - (other int) int =>
    match other.ns
      num.plus =>
        match ns
          num.plus =>
            if n ≥ other.n
              int num.plus (n - other.n)
            else
              int num.minus (other.n - n)
          num.minus => -(-int.this + other)
      # minus, minus => plus
      num.minus => int.this + -other


  # the sign of the result of the
  # multiplication or division of thiz and other
  private result_sign_mul_div(other int) num.sign =>
    if ns = other.ns then num.plus else num.minus


  # multiply this int by other
  public fixed infix *  (other int) int =>
    int (result_sign_mul_div other) n*other.n


  # divide this int by other
  public fixed infix /  (other int) int
  pre other != int.zero
  =>
    s num.sign := result_sign_mul_div other
    int s n/other.n


  # modulo, returns the remainder of the
  # division of this int by other
  public fixed infix %  (other int) int =>
    int ns n%other.n


  # exponentation operator:
  # this int to the power of other
  public fixed infix ** (other int) int
  pre other ≥ int.zero
  =>
    match s
      num.plus => int num.plus (n ** other.n)
      num.minus =>
        s num.sign := if other %% (int 2) then num.plus else num.minus
        int s (n ** other.n)


  # all operations are allowed for all ints
  # except for division where we need to
  # check for division by zero

  public fixed prefix -! bool => true
  public fixed infix +! (other int) bool => true
  public fixed infix -! (other int) bool => true
  public fixed infix *! (other int) bool => true
  public fixed infix /! (other int) bool =>
    other != int.zero
  public fixed infix %! (other int) bool => true

  public fixed infix **!(other int) bool =>
    other ≥ int.zero  # 0 and 1 ** -other would be okay but we disallow nonetheless

  public fixed infix **?(other int) num_option int =>
    match other.ns
      num.plus => thiz ** other
      num.minus => nil # 0 and 1 ** -other would be okay but we disallow nonetheless

  public fixed infix **^(other int) int =>
    match other.ns
      num.plus => thiz ** other
      num.minus => panic "negativ exponent is not allowed." # 0 or 1 ** -other would be okay but we disallow nonetheless

  # equality: are these two ints equal?
  #
  fixed type.equality(a, b int) bool =>
    (a.ns = b.ns) & (a.n = b.n)

  # total order
  #
  fixed type.lteq(a, b int) bool =>
    match a.ns
      num.plus =>
        match b.ns
          num.plus => a.n ≤ b.n
          num.minus => false
      num.minus =>
        match b.ns
          num.plus => true
          num.minus => b.n ≤ a.n

  public redef as_string String =>
    s.as_string + n.as_string


  # this int as an i32
  public as_i32 i32 =>
    n.as_i32


  # this int as an i64
  public as_i64 i64 =>
    n.as_i64


  # this int as an u8
  public as_u8 u8
  # NYI pre int.this >= 0
  =>
      n.as_u8


  # this int as an u32
  public as_u32 u32
  # NYI pre int.this >= 0
  =>
      n.as_u32


  # this int as an u64
  public as_u64 u64
  # NYI pre int.this >= 0
  =>
    n.as_u64


  # this int as an uint
  public as_uint uint
  # NYI pre int.this >= 0
  =>
    n


  # helper feature to init int via an i64
  type.from_i64(val i64) int =>
    s num.sign := if val < (i64 0) then num.minus else num.plus
    n u64 := if val = i64.min
               i64.max.as_u64 + 1
             else if val < (i64 0)
               (-val).as_u64
             else val.as_u64
    int s (uint n)


  # helper feature to init int via a u64
  public type.from_u64(val u64) int =>
    int num.plus (uint val)


  # helper feature to init int via an i32
  public type.from_i32(val i32) int =>
    from_i64 val.as_i64



# shorthand to create an int via an i64
public int (val i64) int =>
  int.from_i64 val