(ns Integer
  "Elixir Integer module — integer operations.

   In CljElixir: (Integer/to-string 255 16), (Integer/digits 123), etc.")

(defn to-string
  "Converts integer to string, optionally in a given base.
   (Integer/to-string 123) ;=> \"123\"
   (Integer/to-string 255 16) ;=> \"FF\""
  ([integer])
  ([integer base]))

(defn to-charlist
  "Converts integer to charlist.
   (Integer/to-charlist 123) ;=> '123'"
  ([integer])
  ([integer base]))

(defn parse
  "Parses a string into an integer. Returns {integer rest} or :error.
   (Integer/parse \"123abc\") ;=> {123 \"abc\"}
   (Integer/parse \"FF\" 16) ;=> {255 \"\"}
   (Integer/parse \"nope\") ;=> :error"
  ([string])
  ([string base]))

(defn digits
  "Returns the digits of `integer` as a list.
   (Integer/digits 123) ;=> [1 2 3]
   (Integer/digits 255 16) ;=> [15 15]"
  ([integer])
  ([integer base]))

(defn undigits
  "Converts a list of digits back to an integer.
   (Integer/undigits [1 2 3]) ;=> 123
   (Integer/undigits [15 15] 16) ;=> 255"
  ([digits])
  ([digits base]))

(defn pow
  "Returns `base` raised to `exponent` (integer exponentiation).
   (Integer/pow 2 10) ;=> 1024"
  [base exponent])

(defn gcd
  "Returns the greatest common divisor.
   (Integer/gcd 12 8) ;=> 4"
  [integer1 integer2])

(defn mod
  "Computes modulo (always non-negative for positive divisor).
   (Integer/mod 10 3) ;=> 1
   (Integer/mod -5 3) ;=> 1  (differs from rem)"
  [dividend divisor])

(defn floor-div
  "Integer division rounded towards negative infinity.
   (Integer/floor-div 10 3) ;=> 3
   (Integer/floor-div -5 3) ;=> -2"
  [dividend divisor])

(defn is-odd
  "Returns true if `integer` is odd. Allowed in guards.
   (Integer/is-odd 3) ;=> true"
  [integer])

(defn is-even
  "Returns true if `integer` is even. Allowed in guards.
   (Integer/is-even 4) ;=> true"
  [integer])

(defn extended-gcd
  "Returns {gcd, s, t} such that gcd = s*a + t*b (Bezout's identity).
   (Integer/extended-gcd 12 8) ;=> {4 1 -1}"
  [a b])

(defn to-string-padded
  "Converts integer to string with zero-padding."
  [integer width])