Создайте более быструю функцию Фибоначчи для n> 100 в MATLAB / octave

у меня есть функция, которая сообщает мне N-е число в последовательности Фибоначчи. Проблема становится очень медленным, когда пытаются найти большие числа в последовательности Фибоначчи, кто-нибудь знает как я могу это исправить?

function f = rtfib(n)
 if (n==1)
     f= 1;
 elseif (n == 2)
     f = 2;
 else
     f =rtfib(n-1) + rtfib(n-2);   
 end

Результаты

tic; rtfib(20), toc
ans =  10946
Elapsed time is 0.134947 seconds.

tic; rtfib(30), toc
ans =  1346269
Elapsed time is 16.6724 seconds.

Я даже не могу получить значение после 5 минут делать rtfib(100)

PS: я использую октаву 3.8.1

7 ответов


если времени очень важно (не программирования):

function f = fib(n)
if (n == 1)
   f = 1;
elseif (n == 2)
   f = 2;
else
   fOld = 2;
   fOlder = 1;
   for i = 3 : n
     f = fOld + fOlder;
     fOlder = fOld;
     fOld = f;
   end
end
end

tic;fib(40);toc; ans = 165580141; Elapsed time is 0.000086 seconds.

вы даже можете использовать uint64. n = 92 это максимум, что вы можете получить от uint64:

tic;fib(92);toc; ans = 12200160415121876738; Elapsed time is 0.001409 seconds.

потому что

fib(93) = 19740274219868223167 > intmax('uint64') = 18446744073709551615

редактировать

для получения fib(n) до n = 183, возможно используйте два uint64 как одно число,

С специальной функцией для суммирование,

function [] = fib(n)
fL = uint64(0);
fH = uint64(0);
MaxNum = uint64(1e19);
if (n == 1)
   fL = 1;
elseif (n == 2)
   fL = 2;
else   
   fOldH = uint64(0);
   fOlderH = uint64(0);
   fOldL = uint64(2);
   fOlderL = uint64(1);
   for i = 3 : n
      [fL q] = LongSum (fOldL , fOlderL , MaxNum);
      fH = fOldH + fOlderH + q;
      fOlderL = fOldL;
      fOlderH = fOldH;
      fOldL = fL;
      fOldH = fH;
   end
 end
 sprintf('%u',fH,fL)
 end

LongSum - это:

function [s q] = LongSum (a, b, MaxNum)
if a + b >= MaxNum
   q = 1;
   if a >= MaxNum
      s = a - MaxNum;
      s = s + b;
   elseif b >= MaxNum
      s = b - MaxNum;
      s = s + a;
   else
      s = MaxNum - a;
      s = b - s;
   end
else
   q = 0;
   s = a + b;
end

Примечание некоторые осложнения в LongSum может показаться ненужным, но это не так!

(все дело во внутреннем if это то, чего я хотел избежать s = a + b - MaxNum в одной команде, потому что она может переполниться и сохранить нерелевантное число в s)

результаты

tic;fib(159);toc; Elapsed time is 0.009631 seconds.

ans = 1226132595394188293000174702095995

tic;fib(183);toc; прошедшее время 0,009735 секунды.

fib (183) = 127127879743834334146972278486287885163

, вы должны быть осторожны, о sprintf.

я также сделал это с тремя uint64, и я мог бы встать,

tic;fib(274);toc; прошедшее время составляет 0.032249 секунд.

ans = 1324695516964754142521850507284930515811378128425638237225

(это довольно почти тот же код, но я мог бы поделиться им, если вам интересно).

Примечание у нас fib(1) = 1 , fib(2) = 2согласно вопросу, пока он более общий с fib(1) = 1 , fib(2) = 1, первые 300 fibs перечислены здесь (спасибо @Rick T).


похоже, что серия fibonaacci следует за golden ratio, как говорилось в некоторых деталях here.

была направлена в этот файл MATLAB-код обмена


если у вас есть доступ к символическому Math Toolbox в MATLAB, вы всегда можете просто вызов функция Фибоначчи от MuPAD:

>> fib = @(n) evalin(symengine, ['numlib::fibonacci(' num2str(n) ')'])
>> fib(274)
ans =
818706854228831001753880637535093596811413714795418360007

Это довольно быстро:

>> timeit(@() fib(274))
ans =
    0.0011

плюс вы можете пойти на столько больших чисел, сколько хотите (ограничено только тем, сколько у вас есть ОЗУ!), он все еще пылает быстро:

% see if you can beat that!
>> tic
>> x = fib(100000);
>> toc               % Elapsed time is 0.004621 seconds.

% result has more than 20 thousand digits!
>> length(char(x))   % 20899

вот полное значение fib(100000): http://pastebin.com/f6KPGKBg


для достижения больших чисел вы можете использовать символьные вычисления. Следующие работы в Matlab R2010b.

syms x y %// declare variables
z = x + y;  %// define formula
xval = '0'; %// initiallize x, y values
yval = '1'; 
for n = 2:300
    zval = subs(z, [x y], {xval yval}); %// update z value
    disp(['Iteration ' num2str(n) ':'])
    disp(zval)
    xval = yval; %// shift values
    yval = zval;
end

одной из проблем производительности является использование рекурсивного решения. Переход к итерационному методу избавит вас от аргумента, передаваемого для каждого вызова функции. Как отметил Оливье,это уменьшит сложность до линейной.

вы также можете посмотреть здесь. По-видимому, есть формула, которая вычисляет n-й член последовательности Фибоначчи. Я протестировал его для 50-го элемента. для более высоких значений n это не очень точная.


вы можете сделать это в O (log n) время с матричным возведением в степень:

X = [0 1
     1 1]

X^n даст вам N-е число Фибоначчи в правом нижнем углу; X^n можно представить как произведение нескольких матриц X^(2^i), Так, например, X^11 будет X^1 * X^2 * X^8, i


реализация быстрого вычисления Фибоначчи в Python может быть следующей. Я знаю, что это Python не MATLAB / Octave, однако это может быть полезно.

в основном, а не вызывать одну и ту же функцию Фибоначчи снова и снова с помощью O(2n), мы сохраняем последовательность Фибоначчи в списке / массиве с O (n):

#!/usr/bin/env python3.5

class Fib:
    def __init__(self,n):
        self.n=n
        self.fibList=[None]*(self.n+1)
        self.populateFibList()
    def populateFibList(self):
        for i in range(len(self.fibList)):
            if i==0:
                self.fibList[i]=0
            if i==1:
                self.fibList[i]=1
            if i>1:
                self.fibList[i]=self.fibList[i-1]+self.fibList[i-2]
    def getFib(self):
        print('Fibonacci sequence up to ', self.n, ' is:')
        for i in range(len(self.fibList)):
            print(i, ' : ', self.fibList[i])
        return self.fibList[self.n]

def isNonnegativeInt(value):
    try:
        if int(value)>=0:#throws an exception if non-convertible to int: returns False
            return True
        else:
            return False
    except:
        return False

n=input('Please enter a non-negative integer: ')

while isNonnegativeInt(n)==False:
    n=input('A non-negative integer is needed: ')

n=int(n) # convert string to int

print('We are using ', n, 'based on what you entered')

print('Fibonacci result is ', Fib(n).getFib())

выход n=12 будет так:

enter image description here

Я тестировал во время выполнения n=100, 300, 1000 и код очень быстрый,мне даже не нужно ждать вывода.