Fibonacci.js overhaul (TheAlgorithms#1049)

Author: Rudxain

Maths/Fibonacci.js

@@ -1,51 +1,67 @@
-constlist=[]
-
-constFibonacciIterative=(nth)=>{
-constsequence=[]
-
-if(nth>=1)sequence.push(1)
-if(nth>=2)sequence.push(1)
-
-for(leti=2;i<nth;i++){
-sequence.push(sequence[i-1]+sequence[i-2])
+// https://en.wikipedia.org/wiki/Generalizations_of_Fibonacci_numbers#Extension_to_negative_integers
+constFibonacciIterative=(num)=>{
+constisNeg=num<0
+if(isNeg)num*=-1
+constsequence=[0]
+
+if(num>=1)sequence.push(1)
+if(num>=2)sequence.push(isNeg ? -1 : 1)
+
+for(leti=2;i<num;i++){
+sequence.push(
+isNeg ? sequence[i-1]-sequence[i] : sequence[i]+sequence[i-1]
+)
 }
 
 returnsequence
 }
 
-constFibonacciRecursive=(number)=>{
+constFibonacciGenerator=function*(neg){
+leta=0
+letb=1
+yielda
+while(true){
+yieldb;
+[a,b]=neg ? [b,a-b] : [b,a+b]
+}
+}
+
+constlist=[]
+constFibonacciRecursive=(num)=>{
+constisNeg=num<0
+if(isNeg)num*=-1
 return(()=>{
 switch(list.length){
 case0:
-list.push(1)
-returnFibonacciRecursive(number)
+list.push(0)
+returnFibonacciRecursive(num)
 case1:
 list.push(1)
-returnFibonacciRecursive(number)
-casenumber:
+returnFibonacciRecursive(num)
+casenum+1:
 returnlist
 default:
-list.push(list[list.length-1]+list[list.length-2])
-returnFibonacciRecursive(number)
+list.push(list.at(-1)+list.at(-2))
+returnFibonacciRecursive(num)
 }
-})()
+})().map((fib,i)=>fib*(isNeg ? (-1)**(i+1) : 1))
 }
 
 constdict=newMap()
-
 constFibonacciRecursiveDP=(stairs)=>{
-if(stairs<=0)return0
-if(stairs===1)return1
+constisNeg=stairs<0
+if(isNeg)stairs*=-1
+
+if(stairs<=1)returnstairs
 
 // Memoize stair count
-if(dict.has(stairs))returndict.get(stairs)
+if(dict.has(stairs))return(isNeg ? (-1)**(stairs+1) : 1)*dict.get(stairs)
 
-constres=
-FibonacciRecursiveDP(stairs-1)+FibonacciRecursiveDP(stairs-2)
+constres=FibonacciRecursiveDP(stairs-1)+FibonacciRecursiveDP(stairs-2)
 
 dict.set(stairs,res)
 
-returnres
+return(isNeg ? (-1)**(stairs+1) : 1)*res
 }
 
 // Algorithms
@@ -59,12 +75,16 @@ const FibonacciRecursiveDP = (stairs) =>{
 // a function of the number of input bits
 // @Satzyakiz
 
-constFibonacciDpWithoutRecursion=(number)=>{
-consttable=[]
+constFibonacciDpWithoutRecursion=(num)=>{
+constisNeg=num<0
+if(isNeg)num*=-1
+consttable=[0]
 table.push(1)
-table.push(1)
-for(leti=2;i<number;++i){
-table.push(table[i-1]+table[i-2])
+table.push(isNeg ? -1 : 1)
+for(leti=2;i<num;++i){
+table.push(
+isNeg ? table[i-1]-table[i] : table[i]+table[i-1]
+)
 }
 returntable
 }
@@ -76,24 +96,31 @@ const copyMatrix = (A) =>{
 }
 
 constIdentity=(size)=>{
+constisBigInt=typeofsize==='bigint'
+constZERO=isBigInt ? 0n : 0
+constONE=isBigInt ? 1n : 1
+size=Number(size)
 constI=Array(size).fill(null).map(()=>Array(size).fill())
 returnI.map((row,rowIdx)=>row.map((_col,colIdx)=>{
-returnrowIdx===colIdx ? 1 : 0
+returnrowIdx===colIdx ? ONE : ZERO
 }))
 }
 
 // A of size (l x m) and B of size (m x n)
-// product C will be of size (l x n)
+// product C will be of size (l x n).
+// both matrices must have same-type numeric values
+// either both BigInt or both Number
 constmatrixMultiply=(A,B)=>{
 A=copyMatrix(A)
 B=copyMatrix(B)
+constisBigInt=typeofA[0][0]==='bigint'
 constl=A.length
 constm=B.length
 constn=B[0].length// Assuming non-empty matrices
 constC=Array(l).fill(null).map(()=>Array(n).fill())
 for(leti=0;i<l;i++){
 for(letj=0;j<n;j++){
-C[i][j]=0
+C[i][j]=isBigInt ? 0n : 0
 for(letk=0;k<m;k++){
 C[i][j]+=A[i][k]*B[k][j]
 }
@@ -110,18 +137,25 @@ const matrixMultiply = (A, B) =>{
 // A is a square matrix
 constmatrixExpo=(A,n)=>{
 A=copyMatrix(A)
+constisBigInt=typeofn==='bigint'
+constZERO=isBigInt ? 0n : 0
+constTWO=isBigInt ? 2n : 2
 
 // Just like Binary exponentiation mentioned in ./BinaryExponentiationIterative.js
-letresult=Identity(A.length)// Identity matrix
-while(n>0){
-if(n%2!==0)result=matrixMultiply(result,A)
-n=Math.floor(n/2)
-if(n>0)A=matrixMultiply(A,A)
+letresult=Identity((isBigInt ? BigInt : Number)(A.length))// Identity matrix
+while(n>ZERO){
+if(n%TWO!==ZERO)result=matrixMultiply(result,A)
+n/=TWO
+if(!isBigInt)n=Math.floor(n)
+if(n>ZERO)A=matrixMultiply(A,A)
 }
 returnresult
 }
 
-constFibonacciMatrixExpo=(n)=>{
+constFibonacciMatrixExpo=(num)=>{
+constisBigInt=typeofnum==='bigint'
+constZERO=isBigInt ? 0n : 0
+constONE=isBigInt ? 1n : 1
 // F(0) = 0, F(1) = 1
 // F(n) = F(n-1) + F(n-2)
 // Consider below matrix multiplication:
@@ -134,23 +168,28 @@ const FibonacciMatrixExpo = (n) =>{
 // or F(n, n-1) = A * A * F(n-2, n-3)
 // or F(n, n-1) = pow(A, n-1) * F(1, 0)
 
-if(n===0)return0
+if(num===ZERO)returnnum
+
+constisNeg=num<0
+if(isNeg)num*=-ONE
 
 constA=[
-[1,1],
-[1,0]
+[ONE,ONE],
+[ONE,ZERO]
 ]
-constpoweredA=matrixExpo(A,n-1)// A raised to the power n-1
+
+constpoweredA=matrixExpo(A,num-ONE)// A raised to the power n-1
 letF=[
-[1],
-[0]
+[ONE],
+[ZERO]
 ]
 F=matrixMultiply(poweredA,F)
-returnF[0][0]
+returnF[0][0]*(isNeg ? (-ONE)**(num+ONE) : ONE)
 }
 
 export{FibonacciDpWithoutRecursion}
 export{FibonacciIterative}
+export{FibonacciGenerator}
 export{FibonacciRecursive}
 export{FibonacciRecursiveDP}
 export{FibonacciMatrixExpo}

Maths/test/Fibonacci.test.js

@@ -2,30 +2,61 @@ import{
 FibonacciDpWithoutRecursion,
 FibonacciRecursiveDP,
 FibonacciIterative,
+FibonacciGenerator,
 FibonacciRecursive,
 FibonacciMatrixExpo
 }from'../Fibonacci'
 
 describe('Fibonacci',()=>{
 it('should return an array of numbers for FibonacciIterative',()=>{
-expect(FibonacciIterative(5)).toEqual(
-expect.arrayContaining([1,1,2,3,5])
+expect(FibonacciIterative(6)).toEqual(
+expect.arrayContaining([0,1,1,2,3,5,8])
+)
+expect(FibonacciIterative(-6)).toEqual(
+expect.arrayContaining([0,1,-1,2,-3,5,-8])
 )
 })
 
+it('should return number for FibonacciGenerator',()=>{
+constpositive=FibonacciGenerator()
+expect(positive.next().value).toBe(0)
+expect(positive.next().value).toBe(1)
+expect(positive.next().value).toBe(1)
+expect(positive.next().value).toBe(2)
+expect(positive.next().value).toBe(3)
+expect(positive.next().value).toBe(5)
+expect(positive.next().value).toBe(8)
+
+constnegative=FibonacciGenerator(true)
+expect(negative.next().value).toBe(0)
+expect(negative.next().value).toBe(1)
+expect(negative.next().value).toBe(-1)
+expect(negative.next().value).toBe(2)
+expect(negative.next().value).toBe(-3)
+expect(negative.next().value).toBe(5)
+expect(negative.next().value).toBe(-8)
+})
+
 it('should return an array of numbers for FibonacciRecursive',()=>{
-expect(FibonacciRecursive(5)).toEqual(
-expect.arrayContaining([1,1,2,3,5])
+expect(FibonacciRecursive(6)).toEqual(
+expect.arrayContaining([0,1,1,2,3,5,8])
+)
+expect(FibonacciRecursive(-6)).toEqual(
+expect.arrayContaining([-0,1,-1,2,-3,5,-8])
 )
 })
 
 it('should return number for FibonacciRecursiveDP',()=>{
-expect(FibonacciRecursiveDP(5)).toBe(5)
+expect(FibonacciRecursiveDP(6)).toBe(8)
+expect(FibonacciRecursiveDP(-6)).toBe(-8)
 })
 
 it('should return an array of numbers for FibonacciDpWithoutRecursion',()=>{
-expect(FibonacciDpWithoutRecursion(5)).toEqual(
-expect.arrayContaining([1,1,2,3,5])
+expect(FibonacciDpWithoutRecursion(6)).toEqual(
+expect.arrayContaining([0,1,1,2,3,5,8])
+)
+expect(FibonacciDpWithoutRecursion(-6)).toEqual(
+expect.arrayContaining([0,1,-1,2,-3,5,-8])
 )
 })
 
@@ -36,5 +67,32 @@ describe('Fibonacci', () =>{
 expect(FibonacciMatrixExpo(3)).toBe(2)
 expect(FibonacciMatrixExpo(4)).toBe(3)
 expect(FibonacciMatrixExpo(5)).toBe(5)
+expect(FibonacciMatrixExpo(6)).toBe(8)
+
+expect(FibonacciMatrixExpo(-0)).toBe(-0)
+expect(FibonacciMatrixExpo(-1)).toBe(1)
+expect(FibonacciMatrixExpo(-2)).toBe(-1)
+expect(FibonacciMatrixExpo(-3)).toBe(2)
+expect(FibonacciMatrixExpo(-4)).toBe(-3)
+expect(FibonacciMatrixExpo(-5)).toBe(5)
+expect(FibonacciMatrixExpo(-6)).toBe(-8)
+})
+
+it('should return bigint for FibonacciMatrixExpo',()=>{
+expect(FibonacciMatrixExpo(0n)).toBe(0n)
+expect(FibonacciMatrixExpo(1n)).toBe(1n)
+expect(FibonacciMatrixExpo(2n)).toBe(1n)
+expect(FibonacciMatrixExpo(3n)).toBe(2n)
+expect(FibonacciMatrixExpo(4n)).toBe(3n)
+expect(FibonacciMatrixExpo(5n)).toBe(5n)
+expect(FibonacciMatrixExpo(6n)).toBe(8n)
+
+expect(FibonacciMatrixExpo(-0n)).toBe(0n)
+expect(FibonacciMatrixExpo(-1n)).toBe(1n)
+expect(FibonacciMatrixExpo(-2n)).toBe(-1n)
+expect(FibonacciMatrixExpo(-3n)).toBe(2n)
+expect(FibonacciMatrixExpo(-4n)).toBe(-3n)
+expect(FibonacciMatrixExpo(-5n)).toBe(5n)
+expect(FibonacciMatrixExpo(-6n)).toBe(-8n)
 })
 })