Talk:Fibonacci sequence: Difference between revisions
→Fibonacci n-Step Numbers: Thanks for the inspiration Gerard. |
m →Fibonacci n-Step Numbers: reply in kind about Fibonacci sequences. |
||
Line 146:
:Gerard, I hope you like [[Fibonacci n-step number sequences]] and thanks for the inspiration! --[[User:Paddy3118|Paddy3118]] 21:59, 24 May 2012 (UTC)
:: Hells-Bells, ahhh likes all kinds!! I have a handy-dandy, slicer-dicer, one-size-fits-all Swiss Army knife calculater (written in REXX), and among many other things, it has around a thousand different sequences, not the least of which are the Fibonacci-type sequences and other ilk. And don't even get me started on the numerous prime/prime-ish sequences. It's got more of 'em then ya can shake a stick at. -- [[User:Gerard Schildberger|Gerard Schildberger]] 22:11, 24 May 2012 (UTC)
::: As an aside, to quote someone long ago: the one language all programmers know is profanity. -- [[User:Gerard Schildberger|Gerard Schildberger]] 22:11, 24 May 2012 (UTC)
|
Revision as of 22:11, 24 May 2012
The task states
Solutions can be iterative or recursive (though recursive solutions are generally considered too slow and are mostly used as an exercise in recursion).
while the parenthetical comment is true, I'm wondering what to make of it. Is there any application of FIbonacci numbers where "computation time" is actually an issue? Do we care about computation time at all? If we do, I'd use neither an iterative nor a recursive approach but an analytic solution through phi (I added that to IDL, I see from a glance that at least the D solution has one of these as well).
I guess my question is: if we care about speed, why demand that the solution be iterative or recursive? Or, more generally, if performance is a concern, why demand any particular approach at all -- since the "best" approach for any one task is bound to be different for different languages. (Something with decent tail recursion might have recursive solutions faster than iterative ones and what-have-you).
And yet other way 'round: does performance matter here on RC? Almost all code samples I've ever contributed would have to be changed if I cared about speed of execution -- I've been trying to optimize for clarity of exposition instead. Is there some kind of guideline / a practical consensus / an ongoing discussion about this somewhere?Sgeier 14:16, 7 April 2008 (MDT)
- I strongly doubt that the analytic version is actually faster than fast solutions using integer arithmetic (manipulating expression trees should be more expensive than manipulating integers). However, a fast solution wouldn't use the recursion formula directly, but use the fact that
/1 1\ n /F<sub>n+1</sub> F<sub>n</sub> \ ( ) = ( ) \1 0/ \F<sub>n</sub> F<sub>n-1</sub>/
- together with a fast exponentiation algorithm to calculate Fn in O(log n) time (in comparison, the naive iterative solution has O(n) time).
- According to the general question if clarity or performance should be more important: I'd say clarity always wins over "programming tricks" performance (e.g. in C and C++ always use n/2 instead of n>>1 if your goal is to calculate the half of an integer), however algorithmic performance should be considered, if it doesn't conflict with the goals of the task (e.g. if the goal of a task is to explicitly show how to write a recursive function, replacing it with a faster iterative version obviously isn't a good idea). However, clarity is important, so the algorithmic performance should be weighted against it (also, the complexity of an algorithm shouldn't get too high IMHO; if you want to present complicated algorithms, there are other sites like literateprograms for that). Of course ultimately it's always the task which sets the rules. --Ce 15:21, 7 April 2008 (MDT)
negative n errors
The task description contains: "Support for negative n errors is optional." Negative n isn't an error; while conventionally only the definition for positive n is given, the Fibonaccy sequence is actually defined for arbitrary n. You can rewrite the recursion formula Fn+1=Fn+Fn-1 as Fn-1=Fn+1-Fn and thus extend the recursive definition to negative values. This results in
If the word "errors" is removed from the description, it becomes reasonable. --Ce 14:40, 7 April 2008 (MDT)
- I've now fixed that. --Ce 08:35, 14 October 2008 (UTC)
Clarified?
In the task page there is the note "This task has been clarified. Its programming examples are in need of review...". I am not sure what exactly has been clarified, but at least the value of fibonacci(0) seems to be wrong in many language examples.
Should the language examples that have been fixed be marked somehow so that we will know when all the examples have been corrected? (Or perhaps mark all examples and then remove the mark when it has been checked.) --PauliKL 15:14, 14 April 2009 (UTC)
- I just tried to fix what I could figure out based on that definition. Some of the iterative examples may still be partially wrong, but I think I got a lot of the recursive examples. --Mwn3d 18:17, 14 April 2009 (UTC)
Rules abuse!
Take a look at the third example under BASIC, Iterative. I stretched the meaning of generate and just predetermined all the numbers that can be handled by my chosen data type (LONG; 32-bit signed, without support for Fn where n < 0) and dumped them into an array. Bam! Almost instant results! :-) -- Eriksiers 20:48, 7 August 2009 (UTC)
- I don't think this (or other types of memoized solutions) violates the rules. It's a neat idea if your language uses a finite integer type. --Mwn3d 20:50, 7 August 2009 (UTC)
- I was thinking more along the lines of the IOCCC award, "Worst Abuse of the Rules" -- the one given to the guy who turned in the empty source file and called it the world's smallest quine.
- Anyway... what I posted can be applied to pretty much any data type, given time, space, and interest... although I wouldn't want to use it for, say, the limits of an 80-bit float. -- Eriksiers 20:56, 7 August 2009 (UTC)
Alternative
Fibonacci sequence can also be calculated using this formula.
Size of the floating-point type (float, double, long double etc..) will limit how high n can be calulated.
--Spekkio 11:27, 25 November 2011 (UTC)
- Thanks. Prompted by the above, I read this.
Optional credits
I would've like to see an optional credit solution for allowing the specification of the starting (two) numbers.
This would've allowed the examples to also generate the Lucas numbers.
series name | initial starting numbers |
---|---|
Fibonacci | 0, 1 |
Lucas | 2, 1 |
Another possibility would allow the specifiction of how many (previous) values to be summed.
series name | number of values to add |
---|---|
Fibonacci | 2 |
tribonacci | 3 |
tetranacci | 4 |
pentanacci | 5 |
hexanacci | 6 |
heptanacci | 7 |
octanacci | 8 |
nonanacci | 9 |
dodecanacci | 10 |
There may be more named Fibonacci numbers in this series of series. -- Gerard Schildberger 20:15, 24 May 2012 (UTC)
- There seems to be enough in your proposal for a new task maybe called "Fibonacci-like sequences generator" in which the starting numbers/numbers of past numbers to sum to form the next, could be set.
- It would also be good to maybe confirm some of the Lucas/Fibonacci identities mentioned in the Lucas wp article. --Paddy3118 20:33, 24 May 2012 (UTC)
Fibonacci n-Step Numbers
The name is from Mathworld. I doodled the following: <lang python>>>> def fiblike(start): addnum = len(start) def fibber(n): try: return fibber.memo[n] except: ans = sum(fibber(i) for i in range(n-addnum, n)) fibber.memo.append(ans) return ans fibber.memo = start[:] return fibber
>>> f = fiblike([1,1]) >>> [f(i) for i in range(10)] [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] >>> l = fiblike([2,1]) >>> [l(i) for i in range(10)] [2, 1, 3, 4, 7, 11, 18, 29, 47, 76] >>> f3= fiblike([1,1,2]) >>> [f3(i) for i in range(10)] [1, 1, 2, 4, 7, 13, 24, 44, 81, 149] >>> f4 = fiblike([1,1,2,4]) >>> [f4(i) for i in range(10)] [1, 1, 2, 4, 8, 15, 29, 56, 108, 208] >>> f5 = fiblike([1,1,2,4,8]) >>> [f5(i) for i in range(10)] [1, 1, 2, 4, 8, 16, 31, 61, 120, 236] >>> f6 = fiblike([1,1,2,4,8,16]) >>> [f6(i) for i in range(10)] [1, 1, 2, 4, 8, 16, 32, 63, 125, 248] >>> f7 = fiblike([1,1,2,4,8,16,32]) >>> [f7(i) for i in range(10)] [1, 1, 2, 4, 8, 16, 32, 64, 127, 253] >>> </lang>
I will try and write a task, although I have flu so it could be interesting! --Paddy3118 21:12, 24 May 2012 (UTC)
- Gerard, I hope you like Fibonacci n-step number sequences and thanks for the inspiration! --Paddy3118 21:59, 24 May 2012 (UTC)
- Hells-Bells, ahhh likes all kinds!! I have a handy-dandy, slicer-dicer, one-size-fits-all Swiss Army knife calculater (written in REXX), and among many other things, it has around a thousand different sequences, not the least of which are the Fibonacci-type sequences and other ilk. And don't even get me started on the numerous prime/prime-ish sequences. It's got more of 'em then ya can shake a stick at. -- Gerard Schildberger 22:11, 24 May 2012 (UTC)
- As an aside, to quote someone long ago: the one language all programmers know is profanity. -- Gerard Schildberger 22:11, 24 May 2012 (UTC)