Julia Kernel Example¶

This notebook demonstrates using the Julia kernel (IJulia) for high-performance scientific computing.

Kernel Information¶

This notebook uses the Julia kernel. To use this kernel, you need to:

using Pkg
Pkg.add("IJulia")

In [ ]:

# Display Julia version and information
println("Julia version: ", VERSION)
println("Julia platform: ", Sys.MACHINE)
versioninfo()

# Display Julia version and information println("Julia version: ", VERSION) println("Julia platform: ", Sys.MACHINE) versioninfo()

Julia Features¶

Julia is excellent for:

• High-Performance Scientific Computing
• Numerical Analysis
• Machine Learning
• Parallel Computing
• Mathematical Optimization

In [ ]:

# Example: Julia's type system and multiple dispatch
struct ProgrammingLanguage
    name::String
    category::String
    year_created::Int
    performance_score::Float64
end

# Define methods for the type
age(lang::ProgrammingLanguage) = year(now()) - lang.year_created

function Base.show(io::IO, lang::ProgrammingLanguage)
    print(io, "$(lang.name) ($(lang.category)) - Created $(lang.year_created), Performance: $(lang.performance_score)/10")
end

# Create language instances
languages = [
    ProgrammingLanguage("Julia", "Scientific", 2012, 9.5),
    ProgrammingLanguage("Python", "General", 1991, 7.0),
    ProgrammingLanguage("R", "Statistical", 1993, 6.0),
    ProgrammingLanguage("Ruby", "General", 1995, 5.0)
]

println("Programming Languages:")
for lang in languages
    println(lang, " ($(age(lang)) years old)")
end

# Example: Julia's type system and multiple dispatch struct ProgrammingLanguage name::String category::String year_created::Int performance_score::Float64 end # Define methods for the type age(lang::ProgrammingLanguage) = year(now()) - lang.year_created function Base.show(io::IO, lang::ProgrammingLanguage) print(io, "$(lang.name) ($(lang.category)) - Created $(lang.year_created), Performance: $(lang.performance_score)/10") end # Create language instances languages = [ ProgrammingLanguage("Julia", "Scientific", 2012, 9.5), ProgrammingLanguage("Python", "General", 1991, 7.0), ProgrammingLanguage("R", "Statistical", 1993, 6.0), ProgrammingLanguage("Ruby", "General", 1995, 5.0) ] println("Programming Languages:") for lang in languages println(lang, " ($(age(lang)) years old)") end

In [ ]:

# Example: Julia's performance with arrays
using LinearAlgebra
using Statistics

# Vector operations
n = 1000000
x = rand(n)
y = rand(n)

# Timing a computation
@time begin
    z = 2.0 * x + 3.0 * y
    result = sum(z)
end

println("\nResult: ", result)
println("Mean of z: ", mean(z))

# Example: Julia's performance with arrays using LinearAlgebra using Statistics # Vector operations n = 1000000 x = rand(n) y = rand(n) # Timing a computation @time begin z = 2.0 * x + 3.0 * y result = sum(z) end println("\nResult: ", result) println("Mean of z: ", mean(z))

Julia's Mathematical Capabilities¶

In [ ]:

# Example: Matrix operations
A = [1 2 3; 4 5 6; 7 8 9]
B = rand(3, 3)

println("Matrix A:")
display(A)
println("\nMatrix B:")
display(B)

# Matrix operations
C = A * B
println("\nA * B:")
display(C)

# Eigenvalues
eigenvals_A = eigvals(A)
println("\nEigenvalues of A: ", eigenvals_A)

# Example: Matrix operations A = [1 2 3; 4 5 6; 7 8 9] B = rand(3, 3) println("Matrix A:") display(A) println("\nMatrix B:") display(B) # Matrix operations C = A * B println("\nA * B:") display(C) # Eigenvalues eigenvals_A = eigvals(A) println("\nEigenvalues of A: ", eigenvals_A)

In [ ]:

# Example: Numerical optimization
# Find minimum of a function
f(x) = (x - 3)^2 + 2

# Plot the function
using Plots
x_range = -2:0.1:8
y_values = f.(x_range)

plot(x_range, y_values, 
     label="f(x) = (x-3)² + 2",
     xlabel="x",
     ylabel="f(x)",
     title="Function Optimization",
     linewidth=2)

# Mark the minimum
scatter!([3], [2], label="Minimum", markersize=8, color=:red)

# Example: Numerical optimization # Find minimum of a function f(x) = (x - 3)^2 + 2 # Plot the function using Plots x_range = -2:0.1:8 y_values = f.(x_range) plot(x_range, y_values, label="f(x) = (x-3)² + 2", xlabel="x", ylabel="f(x)", title="Function Optimization", linewidth=2) # Mark the minimum scatter!([3], [2], label="Minimum", markersize=8, color=:red)

Parallel Computing in Julia¶

In [ ]:

# Example: Parallel computing with threads
using Base.Threads

println("Number of threads: ", nthreads())

# Parallel sum
function parallel_sum(arr)
    chunks = Iterators.partition(arr, length(arr) ÷ nthreads())
    tasks = map(chunks) do chunk
        @spawn sum(chunk)
    end
    sum(fetch.(tasks))
end

# Test with large array
test_array = rand(10_000_000)

# Serial version
@time serial_result = sum(test_array)

# Parallel version
@time parallel_result = parallel_sum(test_array)

println("\nResults match: ", isapprox(serial_result, parallel_result))

# Example: Parallel computing with threads using Base.Threads println("Number of threads: ", nthreads()) # Parallel sum function parallel_sum(arr) chunks = Iterators.partition(arr, length(arr) ÷ nthreads()) tasks = map(chunks) do chunk @spawn sum(chunk) end sum(fetch.(tasks)) end # Test with large array test_array = rand(10_000_000) # Serial version @time serial_result = sum(test_array) # Parallel version @time parallel_result = parallel_sum(test_array) println("\nResults match: ", isapprox(serial_result, parallel_result))

In [ ]:

# Example: Broadcasting and vectorization
# Julia's dot syntax for broadcasting
x = 1:10
y = rand(10)

# Element-wise operations
z = @. sin(x) + cos(y) * 2

println("x: ", collect(x))
println("y: ", round.(y, digits=2))
println("z: ", round.(z, digits=2))

# Custom broadcasting
custom_func(a, b) = a^2 + sqrt(abs(b))
result = custom_func.(x, y)
println("\nCustom function results: ", round.(result, digits=2))

# Example: Broadcasting and vectorization # Julia's dot syntax for broadcasting x = 1:10 y = rand(10) # Element-wise operations z = @. sin(x) + cos(y) * 2 println("x: ", collect(x)) println("y: ", round.(y, digits=2)) println("z: ", round.(z, digits=2)) # Custom broadcasting custom_func(a, b) = a^2 + sqrt(abs(b)) result = custom_func.(x, y) println("\nCustom function results: ", round.(result, digits=2))

Julia Package Management¶

In [ ]:

# Example: Package management (commented out to avoid installation)
# using Pkg
# Pkg.add("DataFrames")
# Pkg.add("Plots")
# Pkg.add("DifferentialEquations")
# Pkg.add("Flux")  # Machine Learning

println("Julia Package Management:")
println("- Use 'using Pkg' to access package manager")
println("- Pkg.add(\"PackageName\") to install")
println("- Pkg.update() to update all packages")
println("- Pkg.status() to see installed packages")

println("\nPopular Julia packages:")
println("- DataFrames.jl: Data manipulation")
println("- Plots.jl: Visualization")
println("- DifferentialEquations.jl: Solving ODEs/PDEs")
println("- Flux.jl: Machine learning")
println("- JuMP.jl: Mathematical optimization")

# Example: Package management (commented out to avoid installation) # using Pkg # Pkg.add("DataFrames") # Pkg.add("Plots") # Pkg.add("DifferentialEquations") # Pkg.add("Flux") # Machine Learning println("Julia Package Management:") println("- Use 'using Pkg' to access package manager") println("- Pkg.add(\"PackageName\") to install") println("- Pkg.update() to update all packages") println("- Pkg.status() to see installed packages") println("\nPopular Julia packages:") println("- DataFrames.jl: Data manipulation") println("- Plots.jl: Visualization") println("- DifferentialEquations.jl: Solving ODEs/PDEs") println("- Flux.jl: Machine learning") println("- JuMP.jl: Mathematical optimization")

In [ ]:

# Example: Metaprogramming in Julia
# Generate code at compile time
macro create_polynomial(n)
    terms = [:($(i) * x^$(i-1)) for i in 1:n]
    return :(x -> +($(terms...)))
end

# Create a polynomial function
poly = @create_polynomial(4)

println("Generated polynomial at x=2: ", poly(2))
println("This evaluates: 1 + 2x + 3x² + 4x³ at x=2")
println("Result: 1 + 2(2) + 3(4) + 4(8) = 1 + 4 + 12 + 32 = 49")

# Example: Metaprogramming in Julia # Generate code at compile time macro create_polynomial(n) terms = [:($(i) * x^$(i-1)) for i in 1:n] return :(x -> +($(terms...))) end # Create a polynomial function poly = @create_polynomial(4) println("Generated polynomial at x=2: ", poly(2)) println("This evaluates: 1 + 2x + 3x² + 4x³ at x=2") println("Result: 1 + 2(2) + 3(4) + 4(8) = 1 + 4 + 12 + 32 = 49")

Summary¶

The Julia kernel (IJulia) provides:

• High-performance computing capabilities
• Dynamic typing with performance of static languages
• Excellent mathematical and scientific libraries
• Built-in parallel computing support
• Metaprogramming and code generation

Julia in Jupyter is ideal for:

• Scientific computing and simulations
• Numerical analysis and optimization
• Machine learning research
• High-performance data processing
• Mathematical modeling