Update all julia code to V1.0 (#389)

* adding changes to update all julia code to V1.0

* adding more points to graham.jl

Author: leios

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/cooley_tukey.md

@@ -70,17 +70,17 @@ 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="cpp" %}
 [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: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,7 +115,7 @@ 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="cpp" %}
@@ -125,7 +125,7 @@ In the end, the code looks like:
 {% sample lang="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.

contents/gaussian_elimination/code/julia/gaussian_elimination.jl

@@ -10,7 +10,7 @@ function gaussian_elimination(A::Array{Float64,2})
     for col = 1:(cols-1)
 
         # Step 1: finding the maximum element for each column
-        max_index = indmax(abs.(A[row:end,col])) + row-1
+        max_index = argmax(abs.(A[row:end,col])) + row-1
 
         # Check to make sure matrix is good!
         if (A[max_index, col] == 0)
@@ -50,7 +50,7 @@ function back_substitution(A::Array{Float64,2})
     cols = size(A,2)
 
     # Creating the solution Vector
-    soln = Vector{Float64}(rows)
+    soln = zeros(rows)
 
     for i = rows:-1:1
         sum = 0.0

contents/gaussian_elimination/gaussian_elimination.md

@@ -420,7 +420,7 @@ In code, this involves keeping a rolling sum of all the values we substitute in
 
 {% method %}
 {% sample lang="jl" %}
-[import:47-67, lang:"julia"](code/julia/gaussian_elimination.jl)
+[import:47-64, lang:"julia"](code/julia/gaussian_elimination.jl)
 {% sample lang="c" %}
 [import:50-62, lang:"c_cpp"](code/c/gaussian_elimination.c)
 {% sample lang="rs" %}

contents/graham_scan/code/julia/graham.jl

@@ -1,4 +1,4 @@
-type Point
+struct Point
     x::Float64
     y::Float64
 end
@@ -14,8 +14,8 @@ function graham_scan(points::Vector{Point})
     sort!(points, by = item -> item.y)
 
     # Sort all other points according to angle with that point
-    other_points = sort(points[2:end], by = item -> atan2(item.y - points[1].y,
-                                                          item.x - points[1].x))
+    other_points = sort(points[2:end], by = item -> atan(item.y - points[1].y,
+                                                         item.x - points[1].x))
 
     # Place points sorted by angle back into points vector
     for i in 1:length(other_points)
@@ -46,7 +46,11 @@ end
 
 function main()
     # This hull is just a simple test so we know what the output should be
-    points = [Point(2,1.9), Point(1, 1), Point(2, 4), Point(3, 1), Point(2, 0)]
+    points = [
+        Point(-5.,2), Point(5,7), Point(-6,-12), Point(-14,-14), Point(9,9),
+        Point(-1,-1), Point(-10,11), Point(-6,15), Point(-6,-8), Point(15,-9),
+        Point(7,-7), Point(-2,-9), Point(6,-5), Point(0,14), Point(2,8)
+    ]
     hull = graham_scan(points)
     println(hull)
 end

contents/split-operator_method/code/julia/split_op.jl

@@ -6,6 +6,8 @@
 #
 #------------------------------------------------------------------------------#
 
+using FFTW
+
 struct Param
     xmax::Float64
     res::Int64
@@ -37,17 +39,17 @@ mutable struct Operators
     K::Vector{Complex{Float64}}
     wfc::Vector{Complex{Float64}}
 
-    Operators(res) = new(Vector{Complex{Float64}}(res),
-                         Vector{Complex{Float64}}(res),
-                         Vector{Complex{Float64}}(res),
-                         Vector{Complex{Float64}}(res))
+    Operators(res) = new(zeros(res),
+                         zeros(res),
+                         zeros(res),
+                         zeros(res))
 end
 
 # Function to initialize the wfc and potential
 function init(par::Param, voffset::Float64, wfcoffset::Float64)
     opr = Operators(length(par.x))
-    opr.V = 0.5 * (par.x - voffset).^2
-    opr.wfc = exp.(-(par.x - wfcoffset).^2/2)
+    opr.V = 0.5 * (par.x .- voffset).^2
+    opr.wfc = exp.(-(par.x .- wfcoffset).^2/2)
     if (par.im_time)
         opr.K = exp.(-0.5*par.k.^2*par.dt)
         opr.R = exp.(-0.5*opr.V*par.dt)
@@ -93,7 +95,8 @@ function split_op(par::Param, opr::Operators)
         # Outputting data to file. Plotting can also be done in a similar way
         # This is set to output exactly 100 files, no matter how many timesteps
         if ((i-1) % div(par.timesteps, 100) == 0)
-            outfile = open("output" *string(lpad(i-1, 5, 0))* ".dat","w")
+            outfile = open("output" * string(lpad(string(i-1), 5, string(0)))
+                                    * ".dat","w")
 
             # Outputting for gnuplot. Any plotter will do.
             for j = 1:length(density)

contents/split-operator_method/split-operator_method.md

@@ -98,7 +98,7 @@ Regardless, we first need to set all the initial parameters, including the initi
 
 {% method %}
 {% sample lang="jl" %}
-[import:9-32, lang:"julia"](code/julia/split_op.jl)
+[import:11-34, lang:"julia"](code/julia/split_op.jl)
 {% sample lang="c" %}
 [import:10-20, lang:"c_cpp"](code/c/split_op.c)
 [import:51-72, lang:"c_cpp"](code/c/split_op.c)
@@ -115,7 +115,7 @@ Afterwards, we turn them into operators:
 
 {% method %}
 {% sample lang="jl" %}
-[import:34-60, lang:"julia"](code/julia/split_op.jl)
+[import:36-62, lang:"julia"](code/julia/split_op.jl)
 {% sample lang="c" %}
 [import:22-28, lang:"c_cpp"](code/c/split_op.c)
 [import:74-95, lang:"c_cpp"](code/c/split_op.c)
@@ -133,7 +133,7 @@ The final step is to do the iteration, itself.
 
 {% method %}
 {% sample lang="jl" %}
-[import:63-109, lang:"julia"](code/julia/split_op.jl)
+[import:65-112, lang:"julia"](code/julia/split_op.jl)
 {% sample lang="c" %}
 [import:97-145, lang:"c_cpp"](code/c/split_op.c)
 {% sample lang="py" %}

contents/stable_marriage_problem/code/julia/stable_marriage.jl

@@ -1,4 +1,4 @@
-# Submitted by Gustorn
+using Random
 
 const mnames = ["A", "B", "C", "D"]
 const wnames = ["E", "F", "G", "H"]

contents/tree_traversal/code/julia/Tree.jl

@@ -43,7 +43,7 @@ function DFS_recursive_inorder_btree(n::Node)
 end
 
 function DFS_stack(n::Node)
-    s = Stack(Node)
+    s = Stack{Node}()
     push!(s, n)
 
     while(length(s) > 0)
@@ -56,7 +56,7 @@ function DFS_stack(n::Node)
 end
 
 function BFS_queue(n::Node)
-    q = Queue(Node)
+    q = Queue{Node}()
     enqueue!(q, n)
 
     while(length(q) > 0)