--- /dev/null
+# This file is part of NIT ( http://www.nitlanguage.org ).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Multi precision integer and rational number using gmp lib
+module gmp
+
+private import native_gmp
+
+redef class Numeric
+
+ # The BigInt equivalent of `self`
+ fun to_bi: BigInt do return self.to_i.to_bi
+
+ # The Ratio equivalent of `self`
+ fun to_r: Ratio do return self.to_f.to_r
+
+end
+
+redef class Text
+
+ # Is `self` a well-formed BigInt (i.e. parsable via `to_bi`)
+ #
+ # assert "123".is_bi
+ # assert "-123".is_bi
+ # assert not "0b1011".is_bi
+ # assert not "123u8".is_bi
+ # assert not "Not a BigInt".is_bi
+ fun is_bi: Bool do
+ var pre = prefix("-")
+ if pre != null then
+ return pre.text_after.is_dec
+ else
+ return is_dec
+ end
+ end
+
+ # Is `self` a well-formed Ratio (i.e. parsable via `to_r`)
+ #
+ # assert "123".is_r
+ # assert "-123".is_r
+ # assert "1/2".is_r
+ # assert "-1/2".is_r
+ # assert not "-1/-2".is_r
+ # assert not "0b1011".is_r
+ # assert not "123u8".is_r
+ # assert not "Not an Ratio".is_r
+ fun is_r: Bool do
+ var frac = split_once_on('/')
+ if frac.length == 2 then
+ return frac[0].is_bi and frac[1].is_dec
+ else
+ return is_bi
+ end
+ end
+
+ # If `self` contains a BigInt, return the corresponding BigInt
+ #
+ # assert("123".to_bi == 123.to_bi)
+ # assert("-123".to_bi == -123.to_bi)
+ fun to_bi: BigInt do
+ assert is_bi
+ var tmp = new NativeMPZ
+ tmp.set_str(self.to_cstring, 10i32)
+ return new BigInt(tmp)
+ end
+
+ # If `self` contains a Ratio, return the corresponding Ratio
+ #
+ # assert("123".to_r == 123.to_r)
+ # assert("-123".to_r == -123.to_r)
+ # assert("1/2".to_r == 0.5.to_r)
+ # assert("-1/2".to_r == -0.5.to_r)
+ fun to_r: Ratio do
+ assert is_r
+ var tmp = new NativeMPQ
+ tmp.set_str self.to_cstring
+ return new Ratio(tmp)
+ end
+end
+
+redef class Float
+ redef fun to_bi do
+ var tmp = new NativeMPZ
+ tmp.set_d self
+ return new BigInt(tmp)
+ end
+
+ redef fun to_r do
+ var tmp = new NativeMPQ
+ tmp.set_d self
+ return new Ratio(tmp)
+ end
+end
+
+redef class Int
+ redef fun to_bi do
+ var tmp = new NativeMPZ
+ tmp.set_si self
+ return new BigInt(tmp)
+ end
+
+ redef fun to_r do
+ var tmp = new NativeMPQ
+ tmp.set_si(self, 1)
+ return new Ratio(tmp)
+ end
+end
+
+# Multi precision Integer numbers.
+class BigInt
+ super Discrete
+ super Numeric
+ super FinalizableOnce
+
+ redef type OTHER: BigInt
+
+ private var val: NativeMPZ
+
+ redef fun successor(i) do return self + i.to_bi
+ redef fun predecessor(i) do return self - i.to_bi
+
+ redef fun hash do return self.to_i
+
+ redef fun <=>(i) do
+ var res = val.cmp(i.val)
+ if (res) < 0 then
+ return -1
+ else if (res) > 0 then
+ return 1
+ else
+ return 0
+ end
+ end
+
+ redef fun ==(i) do return i isa BigInt and (self <=> i) == 0
+ redef fun <=(i) do return (self <=> i) <= 0
+ redef fun <(i) do return (self <=> i) < 0
+ redef fun >=(i) do return (self <=> i) >= 0
+ redef fun >(i) do return (self <=> i) > 0
+
+
+ # assert(2.to_bi + 2.to_bi == 4.to_bi)
+ redef fun +(i) do
+ var res = new NativeMPZ
+ val.add(res, i.val)
+ return new BigInt(res)
+ end
+
+ # assert(-(2.to_bi) == (-2).to_bi)
+ redef fun - do
+ var res = new NativeMPZ
+ val.neg res
+ return new BigInt(res)
+ end
+
+ # assert(2.to_bi - 2.to_bi == 0.to_bi)
+ redef fun -(i) do
+ var res = new NativeMPZ
+ val.sub(res, i.val)
+ return new BigInt(res)
+ end
+
+ # assert(2.to_bi * 2.to_bi == 4.to_bi)
+ redef fun *(i) do
+ var res = new NativeMPZ
+ val.mul(res, i.val)
+ return new BigInt(res)
+ end
+
+ # assert(3.to_bi / 2.to_bi == 1.to_bi)
+ redef fun /(i) do
+ var res = new NativeMPZ
+ val.tdiv_q(res, i.val)
+ return new BigInt(res)
+ end
+
+ # Modulo of `self` with `i`.
+ #
+ # Finds the remainder of the division of `self` by `i`.
+ #
+ # assert(5.to_bi % 2.to_bi == 1.to_bi)
+ fun %(i: BigInt): BigInt do
+ var res = new NativeMPZ
+ val.mod(res, i.val)
+ return new BigInt(res)
+ end
+
+ # Returns `self` raised to the power of `e`.
+ #
+ # assert(3.to_bi ** 2 == 9.to_bi)
+ fun **(e: Int): BigInt do
+ var res = new NativeMPZ
+ var pow = new UInt64
+ pow.set_si e
+ val.pow_ui(res, pow)
+ pow.free
+ return new BigInt(res)
+ end
+
+ # The absolute value of `self`.
+ #
+ # assert((-3).to_bi.abs == 3.to_bi)
+ fun abs: BigInt do
+ var res = new NativeMPZ
+ val.abs res
+ return new BigInt(res)
+ end
+
+ # Returns the greatest common divisor of `self` and `i`
+ #
+ # assert(15.to_bi.gcd(10.to_bi) == 5.to_bi)
+ fun gcd(i: BigInt): BigInt do
+ var res = new NativeMPZ
+ val.gcd(res, i.val)
+ return new BigInt(res)
+ end
+
+ # Determine if `self` is a prime number.
+ # Return 2 if `self` is prime, return 1 if `self` is probably prime and
+ # return 0 if `self` is definitely not a prime number.
+ #
+ # This function begins by trying some divisions with small number to find if
+ # there is other factors then `self` and one. After that, it uses the
+ # Miller-Rabin probabilistic primality tests. The probability of a non-prime
+ # being identified as probably prime with that test is less than
+ # `4^(-reps)`. It is recommended to use a `reps` value between 15 and 50.
+ #
+ # assert((0x10001).to_bi.probab_prime(15) == 2)
+ fun probab_prime(reps: Int): Int do
+ return val.probab_prime_p(reps.to_i32)
+ end
+
+ # Return the next prime number greater than `self`.
+ # This fonction uses a probabilistic algorithm.
+ #
+ # assert(11.to_bi.next_prime == 13.to_bi)
+ fun next_prime: BigInt do
+ var res = new NativeMPZ
+ val.nextprime res
+ return new BigInt(res)
+ end
+
+ # assert(11.to_bi.zero == 0.to_bi)
+ redef fun zero do return new BigInt(new NativeMPZ)
+
+ # assert(11.to_bi.value_of(4) == 4.to_bi)
+ redef fun value_of(i) do return i.to_bi
+
+ # assert(11.to_bi.to_i == 11)
+ redef fun to_i do return val.get_si
+
+ # assert(11.to_bi.to_f == 11.0)
+ redef fun to_f do return val.get_d
+
+ # assert(11.to_bi.to_s == "11")
+ redef fun to_s do
+ var cstr = val.get_str(10.to_i32)
+ var str = cstr.to_s
+ cstr.free
+ return str
+ end
+
+ redef fun to_bi do return self
+
+ # assert(123.to_bi.to_r == 123.to_r)
+ redef fun to_r do
+ var tmp = new NativeMPQ
+ tmp.set_z val
+ return new Ratio(tmp)
+ end
+
+ # assert(3.to_bi.distance(6.to_bi) == -3)
+ redef fun distance(i) do return (self - i).to_i
+
+ redef fun finalize_once do val.finalize
+end
+
+# Multi precision Rational numbers.
+#
+# assert((0.2 + 0.1) == 0.30000000000000004)
+# assert(("1/5".to_r + "1/10".to_r) == "3/10".to_r)
+class Ratio
+ super Numeric
+ super FinalizableOnce
+
+ redef type OTHER: Ratio
+
+ private var val: NativeMPQ
+
+ redef fun hash do return self.to_i
+
+ redef fun <=>(r) do
+ var res = val.cmp(r.val)
+ if (res) < 0 then
+ return -1
+ else if (res) > 0 then
+ return 1
+ else
+ return 0
+ end
+ end
+
+ redef fun ==(r) do return r isa Ratio and (self <=> r) == 0
+ redef fun <=(r) do return (self <=> r) <= 0
+ redef fun <(r) do return (self <=> r) < 0
+ redef fun >=(r) do return (self <=> r) >= 0
+ redef fun >(r) do return (self <=> r) > 0
+
+ # assert("3/2".to_r + "5/2".to_r == 4.to_r)
+ redef fun +(r) do
+ var res = new NativeMPQ
+ val.add(res, r.val)
+ return new Ratio(res)
+ end
+
+ # assert( -("1/2".to_r) == ("-1/2").to_r)
+ redef fun - do
+ var res = new NativeMPQ
+ val.neg res
+ return new Ratio(res)
+ end
+
+ # assert("5/2".to_r - "3/2".to_r == 1.to_r)
+ redef fun -(r) do
+ var res = new NativeMPQ
+ val.sub(res, r.val)
+ return new Ratio(res)
+ end
+
+ # assert("3/2".to_r * 2.to_r == 3.to_r)
+ redef fun *(r) do
+ var res = new NativeMPQ
+ val.mul(res, r.val)
+ return new Ratio(res)
+ end
+
+ # assert(3.to_r / 2.to_r == "3/2".to_r)
+ redef fun /(r) do
+ var res = new NativeMPQ
+ val.div(res, r.val)
+ return new Ratio(res)
+ end
+
+ # The absolute value of `self`.
+ #
+ # assert((-3.to_r).abs == 3.to_r)
+ # assert(3.to_r.abs == 3.to_r)
+ fun abs: Ratio do
+ var res = new NativeMPQ
+ val.abs res
+ return new Ratio(res)
+ end
+
+ # assert((3.to_r).zero == 0.to_r)
+ redef fun zero do return new Ratio(new NativeMPQ)
+
+ # assert((3.to_r).value_of(2) == 2.to_r)
+ redef fun value_of(n) do return n.to_r
+
+ # assert("7/2".to_r.to_i == 3)
+ redef fun to_i do
+ var res = new NativeMPZ
+ val.numref.tdiv_q(res, val.denref)
+ return res.get_si
+ end
+
+ # assert(3.to_r.to_f == 3.0)
+ redef fun to_f do return val.get_d
+
+ # assert(3.to_r.to_s == "3")
+ redef fun to_s do
+ var cstr = val.get_str(10i32)
+ var str = cstr.to_s
+ cstr.free
+ return str
+ end
+
+ # assert("7/2".to_r.to_bi == 3.to_bi)
+ redef fun to_bi do
+ var res = new NativeMPZ
+ val.numref.tdiv_q(res, val.denref)
+ return new BigInt(res)
+ end
+
+ redef fun to_r do return self
+
+ redef fun finalize_once do val.finalize
+end
nitlanguage / nit.git / commitdiff