versioninfo()

println("Hello Julia")

?println

a = 3
typeof(a)

a = "a string"
typeof(a)

a = 1e-7
typeof(a)

1 == true

0 == false

!true

a = -1
if a>0 
    println("positive")
elseif a<0
    println("negative")
else
    println("zero")
end

if 1>0 
    println("true")
end

function sphere_vol(r)
    return 4/3*pi*r^3
end

function sphere_vol(r)
    4/3*pi*r^3
end

r = 5
#print("sphere radius=%f, vol=%0.3f\n", r, sphere_vol(r))
@printf "sphere radius=%f, vol=%0.3f\n" r sphere_vol(r)

f(x) = sin(1 / x)
f(1/pi)

quad_root(a,b,c) = ((-b + sqrt(b^2-4a*c))/2a, (-b - sqrt(b^2-4a*c))/2a)

soln = quad_root(2,4,1)

soln[1]

soln[end]

randn(3)

map(x -> sin(1 / x), randn(3))      # function without a name, apply a function on the elements of an array

function f(x, y=2, z=3; a=1, b=.1, c=2)       # default values, named arguments
    return exp(cos(a * x + b))
end

f(1,2,3, c=-5)

s = "3.1415"
fval = float(s) 
println(5fval)

i = parse(Float64,s)

c = 'α'
println(c, ", ascii value = ", Int(c))

str = "This is a string"
show(str[10:13])

a = "welcome"
b = "julia"
c = 101
println("$a to $b in $c")

println("1 + 2 = $(1+2)")

@printf "%d %.1f" c 1.1*c

a = "welcome"
b = "julia"
println(a * b) # string concatenation

a^3

s = "The quick brown fox jumps over the brown dog α,β,γ "
r = search(s, "brown")

r = replace(s, "brown", "red")

r = search(s, r"b[\w]*n")

r = strip(s)

r = split("welcome, to, julia", [',', ' '], keep=false)

?split

a = [1 2 3]

a = [1,2,3]

a = [1;2;3]

A = [1 2; 3 4]

a = Int64[]
push!(a, 4)
push!(a, 5)
push!(a,6)
# show(tmp); println()
show(a)

a = [ [1,2,3], [1,2] ]

a = (Array{Int64, 1})[]  # Array of Arrays
push!(a, [1,2,3])
push!(a, [4,5])

a = [[1,2,3], [4,5]]

a = [1 2 3]
A = repmat(a, 3, 2)

a = ["Hi Im element # $(i+2*(j-1))" for i=1:2, j=1:3]

a[:,2]

a[end,:]

a[1:1,:]

push!([1,2,3], 4, 5, 6)

append!([1,2,3], [4,5,6])

prepend!([3], [1,2])

insert!([1,2,3,4],2,10)

deleteat!([1,2,3,4],2:3)

function foo(arg::Int)
    arg_local = arg
    arg_local = 2
    return (arg_local)
end

arg = 10
out = foo(arg)
(out, arg)

function foo!(arg::Array)
    arg_local = arg
    arg_local[1] = 2
    return (arg_local)
end

arg = [10 20]
out = foo!(arg)
(out, arg)

A = ones(3)

A = ones(3,3)

B = A
A[2,2] = -1
B

B = copy(A)
A[2,2] = 100
B

x = "foo", "bar"
typeof(x)

x = ("foo", "bar")
word1, word2 = x        # unpacking
show(word1); println()
show(word2)

x = ("foo", "bar")
x[1]

x = ["foo" "bar"]
x[1] = "xxx"
show(x)

d = Dict{Any,Any}(2=>"two", 1=>"one", 4=>"four", 3=>"three")

# alternatively,
d = Dict(2=>"two", 1=>"one", 4=>"four", 3=>"three")

show(keys(d)); println()
show(values(d))

for k in sort(collect(keys(d)))
    if(k == 1 || k == 4) continue
    end
    print(k, ": ", d[k], ", ")
end

show(d[3]); println()
d[3] = "not three"
show(d[3])

d[0] = "zero"

show(d)
2 in keys(d)

"one" in values(d)

animals = ["dog", "cat", "bird"];   # semicolon suppresses output

plurals = [animal * "s" for animal in animals]

a = [i+j for i=1:2, j=1:3]

Dict("$i" => i for i in 1:3)

d = Dict(i => @sprintf("str%d", i) for i=1:10)

for i in 1:5   # iteration over a range 1:5, "for i = 1:5" also works
    print(i, ", ")
end

for i in collect(1:5)   # iteration over an array
    print(i, ", ")
end

collect(1:2:10)

a = collect(1:2:10)
while !isempty(a)
    print(pop!(a), ", ")
end

countries = ("Japan", "Korea", "China")
cities = ("Tokyo", "Seoul", "Beijing")
for (country, city) in zip(countries, cities)     # zip()
    println("The capital of $country is $city")
end

countries = ("Japan", "Korea", "China")
cities = ("Tokyo", "Seoul", "Beijing")
for (i, country) in enumerate(countries)          # same as above, but with index
    city = cities[i]
    println("The capital of $country is $city")
end

type Person
    name::String
    age::Float64
    children::Array{String, 1}
    
    # constructor
    Person(name::String, age) = new(name, age, [])
    Person(name::String, age, children) = new(name, age, children)
end

p1 = Person("Julia", 4)
p2 = Person("Steve", 42, ["Anna", "Bob"])
show(p1); println()
show(p2)

people = Person[]
push!(people, Person("Steve", 42))

fname = "benchmarks.csv"

open(fname, "r") do f
    for line in eachline(f)
        print(line)
    end
end

using DataFrames
df = readtable("benchmarks.csv", names=[:language, :benchmark, :time]) # use of quoted (unevaluated) symbol

benchmarks = readtable("benchmarks.csv", names=[:language, :benchmark, :time])
cdata = benchmarks[benchmarks[:language].== "c", :]
show(cdata) println("")
benchmarks = join(benchmarks, cdata, on=:benchmark)
show(benchmarks)
benchmarks[:time]./= benchmarks[:time_1]
benchmarks = benchmarks[benchmarks[:language] .== "c", :]

benchmarks

using Gadfly # ggplot2 style plots

p = plot(benchmarks,
    x = :language,
    y = :time,
    color = :benchmark,
    Scale.y_log10,
    Guide.ylabel(nothing),
    Guide.xlabel(nothing),
    Theme(
        default_point_size = 1mm,
        guide_title_position = :left,
        colorkey_swatch_shape = :circle,
        minor_label_font = "Georgia",
        major_label_font = "Georgia",
    ),
)
draw(SVG(8inch,8inch/golden), p)

import PyPlot # Julia interface to Matplotlib, a powerful python plotting library

x = linspace(0,2*pi,1000); y = sin(3*x + 4*cos(2*x));
PyPlot.plot(x, y, color="red", linewidth=2.0, linestyle="--")
PyPlot.title("A sinusoidally modulated sinusoid")

Pkg.available()

Pkg.add("Calculus")
Pkg.update()

using Calculus

derivative(x -> sin(x), 1.0)

import Calculus

Calculus.derivative(x -> sin(x), 1.0)

using Images
using ImageMagick
using QuartzImageIO

const ϕ = golden

function foo(z)
  c = (φ-2)+(φ-1)im
  max = 80
  for n = 1:max
    abs(z) ≥ 2 && return n-1
    z = z^2 + c
  end
  return max
end

foo(x, y) = foo(x + y*im)

foo_grid(n) =
  broadcast(foo,
            linspace(-0.5, 1, n)',
            linspace(-1, 0.5, n))

convert(Image, foo_grid(500) * (1/80))

nheads = @time @parallel (+) for i=1:100_000_000
    rand(Int)
end

f(x) = x*x

code_llvm(f, (Float64,))

code_native(f, (Float64,))

A = rand(3,2)
B = randn(2,5)

AB = A*B

size(AB)

A = rand(3,2)
b = rand(2,1)

Ab = A*b

b'*b

dot(b,b)

(b'*b).*A

dot(b,b)*A

A = randn(3,2)
B = randn(3,2)

A .< B
A .== B
A .!= B
A ./ B
A + B
!(A .<= B) # boolean not
~(A .<= B) # bitwise not
float(0b01 $ 0b10)  # bitwise xor
float("3.4")

min(A,B)

minimum(A)

square(x) = x^2

@vectorize_1arg Number square

methods(square)

square(rand(3,4))

A = randn(3,1) .>= 0
B = randn(3,1) .>= 0

[A B (A & B)] # bitwise and

a = rand(Bool)
b = rand(Bool)
[a b (a && b)]

A = rand(5,5)
A[A .< .5] = 0
countnz(A) # not constant time operator
A = sparse(A)
#countnz(A) #works, but not recommended
nnz(A) # constant time operation
A = spzeros(3,3)
A = spones(A) # same structure as the input, but nonzero elem => 1.0
A = speye(Int8, 3,2)
A = spdiagm([1 2 3], [-1 0 1])
full(A)
A = sprand(3,4,0.8)

@printf "%d %f" 3 (2.4*.1)

@time for i=1:100_000_000
    rand(Bool)
end