Add tasks for all the new languages

Task/Fast-Fourier-transform/Crystal/fast-fourier-transform.crystal

@@ -0,0 +1,8 @@
+def fft(x : Array(Float64)) : Array(Complex)
+  return [x[0].to_c] if x.size <= 1
+  even = fft(Array.new(x.size / 2) { |k| x[2 * k] })
+  odd = fft(Array.new(x.size / 2) { |k| x[2 * k + 1] })
+  c = Array.new(x.size / 2) { |k| Complex.new(0, -2 * Math::PI * k / x.size).exp }
+  codd = Array.new(x.size / 2) { |k| c[k] * odd[k] }
+  return Array.new(x.size / 2) { |k| even[k] + codd[k] } + Array.new(x.size / 2) { |k| even[k] - codd[k] }
+end

Task/Fast-Fourier-transform/ERRE/fast-fourier-transform.erre

@@ -0,0 +1,99 @@
+PROGRAM FFT
+
+CONST CNT=8
+
+!$DYNAMIC
+DIM REL[0],IMG[0],CMP[0],V[0]
+
+BEGIN
+   SIG=INT(LOG(CNT)/LOG(2)+0.9999)
+   REAL1=2^SIG
+
+   REAL=REAL1-1
+   REAL2=INT(REAL1/2)
+   REAL4=INT(REAL1/4)
+   REAL3=REAL4+REAL2
+
+!$DIM REL[REAL1],IMG[REAL1],CMP[REAL3]
+
+FOR I=0 TO CNT-1 DO
+   READ(REL[I],IMG[I])
+END FOR
+
+DATA(1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0)
+
+SIG2=INT(SIG/2)
+SIG1=SIG-SIG2
+CNT1=2^SIG1
+CNT2=2^SIG2
+
+!$DIM V[CNT1-1]
+V[0]=0
+DV=1
+PTR=CNT1
+
+FOR J=1 TO SIG1 DO
+  HLFPTR=INT(PTR/2)
+  PT=CNT1-HLFPTR
+  FOR I=HLFPTR TO PT STEP PTR DO
+    V[I]=V[I-HLFPTR]+DV
+  END FOR
+  DV=2*DV
+  PTR=HLFPTR
+END FOR
+
+K=2*π/REAL1
+
+FOR X=0 TO REAL4 DO
+   CMP[X]=COS(K*X)
+   CMP[REAL2-X]=-CMP[X]
+   CMP[REAL2+X]=-CMP[X]
+END FOR
+
+PRINT("FFT: BIT REVERSAL")
+
+FOR I=0 TO CNT1-1 DO
+  IP=I*CNT2
+  FOR J=0 TO CNT2-1 DO
+    H=IP+J
+    G=V[J]*CNT2+V[I]
+    IF G>H THEN
+       SWAP(REL[G],REL[H])
+       SWAP(IMG[G],IMG[H])
+    END IF
+  END FOR
+END FOR
+
+T=1
+FOR STAGE=1 TO SIG DO
+  PRINT("STAGE:";STAGE)
+  D=INT(REAL2/T)
+  FOR II=0 TO T-1 DO
+     L=D*II
+     LS=L+REAL4
+     FOR I=0 TO D-1 DO
+       A=2*I*T+II
+       B=A+T
+       F1=REL[A]
+       F2=IMG[A]
+       CNT1=CMP[L]*REL[B]
+       CNT2=CMP[LS]*IMG[B]
+       CNT3=CMP[LS]*REL[B]
+       CNT4=CMP[L]*IMG[B]
+       REL[A]=F1+CNT1-CNT2
+       IMG[A]=F2+CNT3+CNT4
+       REL[B]=F1-CNT1+CNT2
+       IMG[B]=F2-CNT3-CNT4
+     END FOR
+  END FOR
+  T=2*T
+END FOR
+
+PRINT("NUM REAL     IMAG")
+FOR I=0 TO REAL DO
+    IF ABS(REL[I])<1E-5 THEN REL[I]=0 END IF
+    IF ABS(IMG[I])<1E-5 THEN IMG[I]=0 END IF
+    PRINT(I;"";)
+    WRITE("##.###### ##.######";REL[I];IMG[I])
+END FOR
+END PROGRAM

Task/Fast-Fourier-transform/EchoLisp/fast-fourier-transform.echolisp

@@ -0,0 +1,17 @@
+(define -∏*2 (complex 0 (* -2 PI)))
+
+(define (fft xs N)
+	(if (<= N 1) xs
+	(let* [
+		(N/2 (/ N 2))
+		(even (fft (for/vector ([i (in-range 0 N 2)]) [xs i]) N/2))
+		(odd  (fft (for/vector ([i (in-range 1 N 2)]) [xs i]) N/2))
+		]
+	(for ((k N/2)) (vector*= odd k  (exp (/ (* -∏*2 k) N ))))
+	(vector-append (vector-map + even odd) (vector-map - even odd)))))
+	
+(define data #( 1 1 1 1  0 0 0 0 ))
+
+(fft data 8)
+    → #( 4+0i 1-2.414213562373095i 0+0i 1-0.4142135623730949i
+       0+0i 1+0.4142135623730949i 0+0i 1+2.414213562373095i)

Task/Fast-Fourier-transform/Idris/fast-fourier-transform.idris

@@ -0,0 +1,31 @@
+module Main
+
+import Data.Complex
+
+
+concatPair : List (a, a) -> List (a)
+concatPair xs with (unzip xs)
+  | (xs1, xs2) = xs1 ++ xs2
+
+fft' : List (Complex Double) -> Nat -> Nat -> List (Complex Double)
+fft' (x::xs) (S Z) _ = [x]
+fft' xs n s = concatPair $ map (\(x1,x2,k) =>
+                let eTerm = ((cis (-2 * pi * ((cast k) - 1) / (cast n))) * x2) in
+                  (x1 + eTerm, x1 - eTerm)) $ zip3 left right [1..n `div` 2]
+
+             where
+                  left : List (Complex Double)
+                  right : List (Complex Double)
+                  left  = fft' (xs) (n `div` 2) (2 * s)
+                  right = fft' (drop s xs) (n `div` 2) (2 * s)
+
+
+-- Recursive Cooley-Tukey with radix-2 DIT case
+-- assumes no of points provided are a power of 2
+fft : List (Complex Double) -> List (Complex Double)
+fft [] = []
+fft xs = fft' xs (length xs) 1
+
+
+main : IO()
+main = traverse_ printLn $ fft [1,1,1,1,0,0,0,0]

Task/Fast-Fourier-transform/Nim/fast-fourier-transform.nim

@@ -0,0 +1,26 @@
+import math, complex, strutils
+
+proc toComplex(x: float): TComplex = result.re = x
+proc toComplex(x: TComplex): TComplex = x
+
+# Works with floats and complex numbers as input
+proc fft[T](x: openarray[T]): seq[TComplex] =
+  let n = x.len
+  result = newSeq[TComplex]()
+  if n <= 1:
+    for v in x: result.add toComplex(v)
+    return
+  var evens, odds = newSeq[T]()
+  for i, v in x:
+    if i mod 2 == 0: evens.add v
+    else: odds.add v
+  var (even, odd) = (fft(evens), fft(odds))
+
+  for k in 0 .. < n div 2:
+    result.add(even[k] + exp((0.0, -2*pi*float(k)/float(n))) * odd[k])
+
+  for k in 0 .. < n div 2:
+    result.add(even[k] - exp((0.0, -2*pi*float(k)/float(n))) * odd[k])
+
+for i in fft(@[1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]):
+  echo formatFloat(abs(i), ffDecimal, 3)

Task/Fast-Fourier-transform/SequenceL/fast-fourier-transform.sequencel

@@ -0,0 +1,18 @@
+import <Utilities/Complex.sl>;
+import <Utilities/Math.sl>;
+import <Utilities/Sequence.sl>;
+
+fft(x(1)) :=
+    let
+        n := size(x);
+
+        top := fft(x[range(1,n-1,2)]);
+        bottom := fft(x[range(2,n,2)]);
+
+        d[i] := makeComplex(cos(2.0*pi*i/n), -sin(2.0*pi*i/n)) foreach i within 0...(n / 2 - 1);
+
+        z := complexMultiply(d, bottom);
+    in
+        x when n <= 1
+    else
+        complexAdd(top,z) ++ complexSubtract(top,z);

Task/Fast-Fourier-transform/Sidef/fast-fourier-transform.sidef

@@ -0,0 +1,16 @@
+func fft(arr) {
+    arr.len == 1 && return arr
+
+    var evn = fft([arr[^arr -> grep { .is_even }]])
+    var odd = fft([arr[^arr -> grep { .is_odd  }]])
+    var twd = (Num.tau.i / arr.len)
+
+    ^odd -> map {|n| odd[n] *= ::exp(twd * n)}
+    (evn »+« odd) + (evn »-« odd)
+}
+
+var cycles = 3
+var sequence = 0..15
+var wave = sequence.map {|n| ::sin(n * Num.tau / sequence.len * cycles) }
+say "wave:#{wave.map{|w| '%6.3f' % w }.join(' ')}"
+say "fft: #{fft(wave).map { '%6.3f' % .abs }.join(' ')}"

Task/Fast-Fourier-transform/jq/fast-fourier-transform-1.jq

@@ -0,0 +1,23 @@
+# multiplication of real or complex numbers
+def cmult(x; y):
+    if (x|type) == "number" then
+       if  (y|type) == "number" then [ x*y, 0 ]
+       else [x * y[0], x * y[1]]
+       end
+    elif (y|type) == "number" then cmult(y;x)
+    else [ x[0] * y[0] - x[1] * y[1],  x[0] * y[1] + x[1] * y[0]]
+    end;
+
+def cplus(x; y):
+    if (x|type) == "number" then
+       if  (y|type) == "number" then [ x+y, 0 ]
+       else [ x + y[0], y[1]]
+       end
+    elif (y|type) == "number" then cplus(y;x)
+    else [ x[0] + y[0], x[1] + y[1] ]
+    end;
+
+def cminus(x; y): cplus(x; cmult(-1; y));
+
+# e(ix) = cos(x) + i sin(x)
+def expi(x): [ (x|cos), (x|sin) ];

Task/Fast-Fourier-transform/jq/fast-fourier-transform-2.jq

@@ -0,0 +1,9 @@
+def fft:
+  length as $N
+  | if $N <= 1 then .
+    else   ( [ .[ range(0; $N; 2) ] ] | fft) as $even
+         | ( [ .[ range(1; $N; 2) ] ] | fft) as $odd
+         | (1|atan * 4) as $pi
+         | [ range(0; $N/2) | cplus($even[.];  cmult( expi(-2*$pi*./$N); $odd[.] )) ] +
+           [ range(0; $N/2) | cminus($even[.]; cmult( expi(-2*$pi*./$N); $odd[.] )) ]
+    end;

Task/Fast-Fourier-transform/jq/fast-fourier-transform-3.jq

@@ -0,0 +1 @@
+[1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0] | fft