Merge branch 'master' into euclid_asm

Author: Gathros

.travis.yml

@@ -0,0 +1,26 @@
+dist: trusty
+sudo: false
+
+language: node_js
+node_js:
+  - "4"
+
+install:
+  - npm install gitbook-cli -g
+  - gitbook install
+
+before_script:
+  - mkdir -p "${TRAVIS_BUILD_DIR}"/build
+
+script:
+  - env | sort
+  - gitbook build . "${TRAVIS_BUILD_DIR}"/build
+
+after_success:
+    - |
+    if [[ "${TRAVIS_BRANCH}" == master && "${TRAVIS_PULL_REQUEST}" == false ]]; then
+        # Commits to master that are not pull requests, that is, only
+        # actual addition of code to master, should deploy the book to
+        # the site.
+        bash "${TRAVIS_BUILD_DIR}"/tools/deploy/update_site_travis.bash
+    fi

CONTRIBUTORS.md

@@ -58,6 +58,11 @@ Michal Hanajik
 <br>
 Bendik Samseth
 <br>
+mukundan314
+<br>
 Trashtalk
 <br>
 Cyrus Burt
+<br>
+Patrik Tesarik
+<br>

README.md

@@ -15,7 +15,7 @@ and live coded on Twitch: https://www.twitch.tv/simuleios.
 If you would like to communicate more directly, please feel free to go to our discord: https://discord.gg/Pr2E9S6.
 
 
-Note that the this project is essentially a book about algorithms collaboratively written by an online community.
+Note that this project is essentially a book about algorithms collaboratively written by an online community.
 Fortunately, there are a lot of algorithms out there, which means that there is a lot of content material available.
 Unfortunately, this means that we will probably never cover every algorithm ever created and instead need to focus on what the community sees as useful and necessary.
 That said, we'll still cover a few algorithms for fun that have very little, if any practical purpose.

book.json

@@ -139,6 +139,10 @@
         {
           "lang": "x64",
           "name": "X86-64 Assembly"
+        },
+        {
+          "lang": "f90",
+          "name": "Fortran90"
         }
       ]
     }

contents/bogo_sort/bogo_sort.md

@@ -14,7 +14,7 @@ In code, it looks something like this:
 
 {% method %}
 {% sample lang="jl" %}
-[import:10-14, lang:"julia"](code/julia/bogo.jl)
+[import:12-16, lang:"julia"](code/julia/bogo.jl)
 {% sample lang="cs" %}
 [import:9-15, lang:"csharp"](code/csharp/BogoSort.cs)
 {% sample lang="clj" %}
@@ -36,7 +36,7 @@ In code, it looks something like this:
 {% sample lang="rs" %}
 [import:16-20, lang:"rust"](code/rust/bogosort.rs)
 {% sample lang="swift" %}
-[import:25-31, lang:"swift"](code/swift/bogosort.swift)
+[import:13-19, lang:"swift"](code/swift/bogosort.swift)
 {% sample lang="php" %}
 [import:11-16, lang:"php"](code/php/bogo_sort.php)
 {% sample lang="nim" %}

contents/bogo_sort/code/c++/bogosort.cpp

@@ -24,7 +24,7 @@ void print_range(std::ostream& os, Iter const first, Iter const last) {
 
   if (first != last) {
     os << *first;
-    std::for_each(first + 1, last, [&os] (double d) { os << ", " << *it; });
+    std::for_each(first + 1, last, [&os] (double d) { os << ", " << d; });
   }
 
   os << "}\n";

contents/bogo_sort/code/julia/bogo.jl

@@ -1,6 +1,8 @@
+using Random
+
 function is_sorted(a::Vector{Float64})
     for i = 1:length(a)-1
-        if (a[i+1] > a[i])
+        if (a[i] > a[i + 1])
             return false
         end
     end
@@ -14,7 +16,7 @@ function bogo_sort(a::Vector{Float64})
 end
 
 function main()
-    a = [1., 3, 2,4]
+    a = [1, 3, 2, 4]
     bogo_sort(a)
     println(a)
 end

contents/bogo_sort/code/swift/bogosort.swift

@@ -6,27 +6,15 @@ func isSorted(inputArray: [Int]) -> Bool {
             return false
         }
     }
-    
-    return true
-}
-
-func shuffle(inputArray: inout [Int]) -> [Int] {
-    var shuffledArray = [Int]()
 
-    for _ in 0..<inputArray.count {
-        let rand = Int(arc4random_uniform(UInt32(inputArray.count)))
-        shuffledArray.append(inputArray[rand])
-        inputArray.remove(at: rand)
-    }
-    
-    return shuffledArray
+    return true
 }
 
 func bogoSort(sortArray: inout [Int]) -> [Int] {
     while(!isSorted(inputArray: sortArray)) {
-        sortArray = shuffle(inputArray: &sortArray)
+        sortArray.shuffle()
     }
-    
+
     return sortArray
 }
 

contents/bubble_sort/bubble_sort.md

@@ -48,6 +48,8 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 [import:3-28, lang:"lisp"](code/lisp/bubble_sort.lisp)
 {% sample lang="nim" %}
 [import:5-9, lang:"nim"](code/nim/bubble_sort.nim)
+{% sample lang="f90" %}
+[import:19-40, lang:"fortran"](code/fortran/bubble.f90)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.
@@ -101,6 +103,8 @@ Trust me, there are plenty of more complicated algorithms that do precisely the
 [import, lang:"lisp"](code/lisp/bubble_sort.lisp)
 {% sample lang="nim" %}
 [import, lang:"nim"](code/nim/bubble_sort.nim)
+{% sample lang="f90" %}
+[import, lang:"fortran"](code/fortran/bubble.f90)
 {% endmethod %}
 
 <script>

contents/bubble_sort/code/fortran/bubble.f90

@@ -0,0 +1,42 @@
+PROGRAM main
+
+    IMPLICIT NONE
+    REAL(8), DIMENSION(10) :: A
+
+    A = (/ 1d0, 3d0, 2d0, 4d0, 5d0, 10d0, 50d0, 7d0, 1.5d0, 0.3d0 /)
+
+    WRITE(*,*) 'Input vector'
+    WRITE(*,'( F6.2 )') A
+    WRITE(*,*) ' '
+
+    CALL bubblesort(A)
+
+    WRITE(*,*) 'Output vector'
+    WRITE(*,'(F6.2)') A
+
+CONTAINS
+
+SUBROUTINE bubblesort(array)
+
+    IMPLICIT NONE
+    INTEGER                              :: array_length, i, j, n
+    REAL(8)                              :: tmp
+    REAL(8), DIMENSION(:), INTENT(INOUT) :: array
+
+    array_length = size(array)
+    n = array_length
+    
+    DO i=1, n
+        DO j=1, n-1
+            IF ( array(j) > array(j+1) ) THEN
+
+                tmp        = array(j+1)
+                array(j+1) = array(j)
+                array(j)   = tmp
+                                
+            END IF
+        END DO
+    END DO
+END SUBROUTINE bubblesort
+    
+END PROGRAM main 

contents/cooley_tukey/code/clojure/fft.clj

@@ -0,0 +1,80 @@
+(ns fft.core
+  (:require [complex.core :as c]))
+;; complex is a jar for complex numbers
+;; https://github.com/alanforr/complex
+;; add [complex "0.1.11"] to :dependencies in your project.clj
+;; and run lein repl or lein deps in the terminal
+(defn matrix-mult
+  "take a matrix m and a vector v which length is number of columns
+  ,return a vector of applying dot-product between v and each row of
+  m. the returned vector's length is the number of rows of m"
+  [m v]
+  (mapv (comp (partial apply c/+)
+              (partial map c/* v))
+        m))
+(defn dft
+  "take a vector of real numbers and return a vector of frequency
+  space"
+  [vx]
+  (let [len (count vx)]
+     (matrix-mult
+      (partition len
+                 (for [n (range len)
+                       k (range len)]
+                   ;; expresion below is
+                   ;; e^(n*k*2*pi*(1/len)*(-i))
+                   (c/exp (c/* n k
+                               2 Math/PI
+                               (/ len)
+                               (c/complex 0 -1)))))
+      vx)))
+(defn fft [vx]
+  (let [len (count vx)]
+    (if (= len 1)
+      vx
+      ;;else
+      (let [;; take values of vx in the even indices
+            even-indices (keep-indexed #(if (even? %1) %2) vx)
+            ;; take values in the odd indices
+            odd-indices (keep-indexed #(if (odd? %1) %2) vx)
+            ;; recursion
+            even-fft (fft even-indices)
+            odd-fft (fft odd-indices)
+            ;; make a sequence of e^(-2pi*i*k/N) where N is the length
+            ;; vx and k range from 0 to N/2
+            omegas-half (map
+                         (comp c/exp
+                               (partial c/*
+                                        (/ len)
+                                        2 Math/PI
+                                        (c/complex 0 -1)))
+                         (range 0 (quot len 2)))
+            ;; take the negative of the first sequence because
+            ;; e^(-2pi*i*(k+N/2)/N=-e^(-2pi*i*k/N) where k ranges from
+            ;; 0 to N/2 
+            omegas-2half (map c/- omegas-half)
+            mult-add (partial map #(c/+ %3 (c/* %1 %2)))]
+        (concat (mult-add omegas-half odd-fft even-fft)
+                (mult-add omegas-2half odd-fft even-fft))))))
+(defn -main [& args]
+    (let [vx [0 1 2 3]
+          len (count vx)
+          ;; calculate the next power of 2 after len
+          ;; the reason behind this is to fill them with zeros for fft
+          next-len (->>
+                    [len 2]
+                    (map #(Math/log %))
+                    (apply /)
+                    Math/ceil
+                    (Math/pow 2)
+                    int)
+          ;; add zeros at the end of vx
+          complete-vx (into vx (repeat (- next-len len) 0))
+          fft-cvx (fft complete-vx)
+          dft-cvx (dft complete-vx)
+          diffv (mapv c/- fft-cvx dft-cvx)]
+    (println "vx:" vx)
+    (println "complete-vx:" complete-vx)
+    (println "result from fft:" (map c/stringify fft-cvx))
+    (println "result from dft:" (map c/stringify dft-cvx))
+    (println "difference: " (map c/stringify diffv))))

contents/cooley_tukey/code/julia/fft.jl

@@ -1,3 +1,5 @@
+using FFTW
+
 #simple DFT function
 function DFT(x)
     N = length(x)
@@ -24,8 +26,8 @@ function cooley_tukey(x)
     n = 0:N-1
     half = div(N,2)
     factor = exp.(-2im*pi*n/N)
-    return vcat(x_odd + x_even .* factor[1:half],
-                x_odd - x_even .* factor[1:half])
+    return vcat(x_odd .+ x_even .* factor[1:half],
+                x_odd .- x_even .* factor[1:half])
 
 end
 
@@ -37,7 +39,7 @@ function bitreverse(a::Array)
 
     bit_indices = []
     for i = 1:length(indices)
-        push!(bit_indices, bits(indices[i]))
+        push!(bit_indices, bitstring(indices[i]))
     end
 
     # Now stripping the unnecessary numbers
@@ -50,11 +52,11 @@ function bitreverse(a::Array)
         bit_indices[i] = reverse(bit_indices[i])
     end
 
-    #replacing indices
+    # Replacing indices
     for i = 1:length(indices)
         indices[i] = 0
         for j = 1:digits
-            indices[i] += 2^(j-1) * parse(string(bit_indices[i][end-j]))
+            indices[i] += 2^(j-1) * parse(Int, string(bit_indices[i][end-j]))
         end
        indices[i] += 1
     end

contents/cooley_tukey/code/python/fft.py

@@ -2,6 +2,14 @@
 from cmath import exp, pi
 from math import log2
 
+def dft(X):
+    N = len(X)
+    temp = [0]*N
+    for i in range(N):
+        for k in range(N):
+            temp[i] += X[k] * exp(-2.0j*pi*i*k/N)
+    return temp
+
 def cooley_tukey(X):
 	N = len(X)
 	if N <= 1:
@@ -47,5 +55,7 @@ def iterative_cooley_tukey(X):
 
 Y = cooley_tukey(X)
 Z = iterative_cooley_tukey(X)
+T = dft(X)
 
 print(all(abs([Y[i] - Z[i] for i in range(64)][j]) < 1 for j in range(64)))
+print(all(abs([Y[i] - T[i] for i in range(64)][j]) < 1 for j in range(64)))

contents/cooley_tukey/cooley_tukey.md

@@ -70,17 +70,19 @@ For some reason, though, putting code to this transformation really helped me fi
 
 {% method %}
 {% sample lang="jl" %}
-[import:2-11, lang:"julia"](code/julia/fft.jl)
+[import:4-13, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
 [import:8-19, lang:"c_cpp"](code/c/fft.c)
+{% sample lang="clj" %}
+[import:15-30, lang:"clojure"](code/clojure/fft.clj)
 {% sample lang="cpp" %}
-[import:2-11, lang:"julia"](code/julia/fft.jl)
+[import:23-33, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
-[import:2-11, lang:"julia"](code/julia/fft.jl)
+[import:4-13, lang:"julia"](code/julia/fft.jl)
 {% sample lang="py" %}
-[import:2-11, lang:"julia"](code/julia/fft.jl)
+[import:5-11, lang:"python"](code/python/fft.py)
 {% sample lang="scratch" %}
-[import:2-11, lang:"julia"](code/julia/fft.jl)
+[import:4-13, lang:"julia"](code/julia/fft.jl)
 {% endmethod %}
 
 In this function, we define `n` to be a set of integers from $$0 \rightarrow N-1$$ and arrange them to be a column.
@@ -115,17 +117,19 @@ With recursion, we can reduce the complexity to $$\sim \mathcal{O}(n \log n)$$,
 In the end, the code looks like:
 {% method %}
 {% sample lang="jl" %}
-[import:14-31, lang:"julia"](code/julia/fft.jl)
+[import:16-32, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
 [import:20-39, lang:"c_cpp"](code/c/fft.c)
+{% sample lang="clj" %}
+[import:31-58, lang:"clojure"](code/clojure/fft.clj)
 {% sample lang="cpp" %}
-[import:35-66, lang:"c_cpp"](code/c++/fft.cpp)
+[import:36-66, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
 [import:6-19, lang:"haskell"](code/haskell/fft.hs)
 {% sample lang="py" %}
-[import:5-16, lang:"python"](code/python/fft.py)
+[import:13-24, lang:"python"](code/python/fft.py)
 {% sample lang="scratch" %}
-[import:14-31, lang:"julia"](code/julia/fft.jl)
+[import:16-32, lang:"julia"](code/julia/fft.jl)
 {% endmethod %}
 
 As a side note, we are enforcing that the array must be a power of 2 for the operation to work.
@@ -222,6 +226,8 @@ Note: I implemented this in Julia because the code seems more straightforward in
 [import, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
 [import, lang:"c_cpp"](code/c/fft.c)
+{% sample lang="clj" %}
+[import, lang:"clojure"](code/clojure/fft.clj)
 {% sample lang="cpp" %}
 [import, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}