BigInteger equivalent in Swift?

Question

Is there an equivalent to Java's BigInteger class in Swift? I am tying to do large calculations in Swift with positive integers larger than UInt64's maximum number. What is the best way to handle these numbers?

Answer 1

You can use the NSDecimalNumber class from Cocoa. It is not infinite precision, but it can represent 38 decimal digits of precision, which may be enough for what you need.

Answer 2

I wrote library that allows you to work with big integers in Swift. In similar manner like Java's BigInteger. There are also operator overloads to make work more convenient. Example:

let a = BigInteger("111111111111111111111111111111111111111111111110000000001")!
let b = 999_999_999
let c = a + b // 111111111111111111111111111111111111111111111111000000000

https://github.com/kirsteins/BigInteger

Answer 3

I found a prototype of BigInt in the official Swift repository: https://github.com/apple/swift/blob/master/test/Prototypes/BigInt.swift

You can probably just copy it into your project and use it. Maybe some day it will be added to the standard library.

Answer 4

I have written a big integer and big double implementation for swift, that doesn't require any additional library. Just copy it into your project. It supports whole Numbers (BInt) and Fractions (BDouble) with most of the common math operators like addition, subtraction, multiplication, exponentiation, modulus and division. Some optimized math functions like factorial or gcd are also implemented.

Here are some code examples:

// Create a new number:
let num = BInt(232)
print(num) // prints "232"

// You can also use Strings to create a number:
let veryBig = BInt("-827846184963421874362418746238453267452971345218746328715380000000000")

// Every standard math operator works well, even with normal Integers
// Visit the github page for more informations
let v0 = (BInt(5) + BInt(4)) - BInt(3)
let v1 = veryBig * 1000
let v2 = vergBig ^ num
let v3 = (veryBig ^ 50000) / (BInt(2) ^ 900) + 1
let v4 = gcd(abs(veryBig), num)

// BDouble is very similar, you can find a detailed description on Github
let fraction = BDouble("27", over: "31")
print(fraction) // prints "27/31"

You can use it freely without giving me credit, and please contribute if you want.

You can find it here: https://github.com/mkrd/Swift-Big-Integer

Answer 5

Here it is.

https://github.com/dankogai/swift-pons

Actually BigInt is just a part of it. In addition to BigInt you get:

• generic Rational that takes form Int8 to BigInt as numerator and denominator
• generic Complex that takes either integers (gaussian integers) or real number types not only Double and Float but also Rational.
• Purely swift. Runs not only on OS X, iOS and tvOS but also Linux. Works happily in Playground.

But the best of all, it is protocol-oriented so you can extend whole integer like:

import PONS

func fib<T:POInteger>(n:T)->T { // with a little better algorithm
    if n < T(2) { return n }
    var (a, b) = (T(0), T(1))
    for _ in 2...n {
        (a, b) = (b, a+b)
    }
    return b
}

let F11 = fib(11 as Int8)
let F13 = fib(13 as UInt8)
let F23 = fib(23 as Int16)
let F24 = fib(24 as UInt16)
let F46 = fib(46 as Int32)
let F47 = fib(47 as UInt32)
let F92 = fib(92 as Int64)
let F93 = fib(93 as UInt64)
let F666 = fib(666 as BigInt)

Dan the Number Generator

Answer 6

I'm also working on a BigNumber library with which you can do some big number calculations. Actually the library is based on the GNU Multiple Precision (GMP) library and I wrote an Objective-C / Swift wrapper. Currently big integer mathematics, including a lot of operator overloading, is possible. A code example goes like:

var err : NSError?
var bi1 = BigInt(nr: 12468642135797531)
var bi2 = BigInt(nr: "12345678901011121314151617181920", error: &err)
var res = bi1 * bi2
println("Multiply 2 BigInts: bi1 * bi2 = \(res.toString())")

which results in:

Multiply 2 BigInts: bi1 * bi2 = 153933852140173822960829726365674325601913839520

You can find the library at: https://github.com/githotto/osxgmp