Simple Swift Fibonacci Program Crashing (Project Euler 2)

Fibonacci in swift playground

The issue is that Int can only store 64bit numbers (on 64bit platforms) and Fibonacci 95 is bigger than the maximum number that can be stored on 64bits.

Fibonacci 95 is 31 940 434 634 990 099 905, while the biggest number Int64 can hold is 2^63-1 = 9 223 372 036 854 775 807.

You can use Decimal for storing larger numbers than what Int can hold Decimal.greatestFiniteMagnitude is 3.4028236692093865e+165.

However, Swift doesn't have a built-in type for storing arbitrarily large numbers, so if you want to do that you'll either need to use a 3rd party library or implement an appropriate data type yourself.

using for loop for fibonacci series to print values it will print up to 47 values above that it shows error

Fib(47) is 2,971,215,073.

2,971,215,073 is larger than 2³¹ - 1 ... which is the largest 32 bit signed integer.

Hence your calculation is overflowing. (In a lot of programming languages, you wouldn't have gotten an error. You would have just gotten the wrong answer.)

How i find the fibonacci series for number 100.

You can't use simple integer arithmetic. You will need to use the Swift equivalent of Java's BigInteger class.

• BigInteger equivalent in Swift?

Fibonacci Calculator stack overflows at 93nd number in Swift

The 93rd Fibonacci number is 12,200,160,415,121,876,738 which is more than 2⁶³ − 1, so it can't be represented as an Int anyway.

If you really want to support a number that big, you should use a BigInteger library.

Sum of Fibonacci term using Functional Swift

There is a filter() function which takes a sequence as an argument:

func filter<S : SequenceType>(source: S, includeElement: (S.Generator.Element) -> Bool) -> [S.Generator.Element]

but since the return value is an array, this is not suited if you want
to work with an "infinite" sequence. But with

lazy(FibonacciSequence()).filter ( { $0 % 2 == 0 })

you get an "infinite" sequence of the even Fibonacci numbers. You cannot
call the .takeWhile() method of ExSwift on that sequence because
.takeWhile() is only defined for struct SequenceOf and not for
general sequences. But

TakeWhileSequence(
    lazy(FibonacciSequence()).filter ( { $0 % 2 == 0 }),
    { $0 < 4_000_000 }
)

works and gives the sequence of all even Fibonacci numbers less than
4,000,000. Then

let sum = reduce(TakeWhileSequence(
    lazy(FibonacciSequence()).filter ( { $0 % 2 == 0 }),
    { $0 < 4_000_000 }), 0, +)

gives the intended result and computes only the "necessary"
Fibonacci numbers.

Note that there is no actual need to memoize the Fibonacci numbers
here because they are accessed sequentially. Also (as @Matteo
already noticed), all Fibonacci numbers are integers. So you could
define the sequence more simply as

struct FibonacciSequence : SequenceType {

    func generate() -> GeneratorOf<Int> {
        var current = 1
        var next = 1
        return GeneratorOf<Int>() {
            let result = current
            current = next
            next += result
            return result
        };
    }
}

and the above computation does still work.

UIint64 data overflow issue

.. whose values do not exceed four million

means that c must not be greater than 4 million.

Replace

for _ in 0..<4000000 {

with

while c < 4000000 {

Now the numeric type can even be UInt32 /p>

Why is Swift 2.0 app throwing EXC_BAD_INSTRUCTION when I use for-in loop?

Because there is an integer overflow. The sum is getting too large. Swift intentionally crashes your program when that happens, unlike other languages where you get a garbage result.

You can get a bit further by using Int64 for the type of the variables, but not much.

BTW. Re-read the Euler Problem statement again carefully. Your program is not calculating what the Euler Problem #2 is asking for.

Why is Swift 2.0 app throwing EXC_BAD_INSTRUCTION when I use for-in loop?

Because there is an integer overflow. The sum is getting too large. Swift intentionally crashes your program when that happens, unlike other languages where you get a garbage result.

You can get a bit further by using Int64 for the type of the variables, but not much.

BTW. Re-read the Euler Problem statement again carefully. Your program is not calculating what the Euler Problem #2 is asking for.

---

Related Topics