Julia untuk Scientific Computing: Multiple Dispatch, Type System, dan High Performance

# Single dispatch (seperti di Python/Java)
# obj.method(args) -> method dipilih berdasarkan tipe obj

# Multiple dispatch di Julia
# f(args...) -> method dipilih berdasarkan tipe SEMUA args

# Contoh: operasi overlap antara shapes
abstract type Shape end
struct Circle <: Shape
    radius::Float64
end
struct Rectangle <: Shape
    width::Float64
    height::Float64
end
struct Line <: Shape
    length::Float64
end

# Method dispatch berdasarkan kedua argumen
overlap(a::Circle, b::Circle) = "Circle-Circle overlap"
overlap(a::Rectangle, b::Rectangle) = "Rect-Rect overlap"
overlap(a::Circle, b::Rectangle) = "Circle-Rect overlap"
overlap(a::Rectangle, b::Circle) = "Rect-Circle overlap"
overlap(a::Shape, b::Shape) = "Generic shape overlap"

# Julia otomatis memilih method yang paling spesifik!
c = Circle(5.0)
r = Rectangle(3.0, 4.0)

println(overlap(c, r))  # "Circle-Rect overlap"
println(overlap(r, c))  # "Rect-Circle overlap"
println(overlap(c, c))  # "Circle-Circle overlap"

# Lihat semua methods
methods(overlap)

# Scientific example: vector operations
struct Vector2D
    x::Float64
    y::Float64
end

struct Vector3D
    x::Float64
    y::Float64
    z::Float64
end

# Dot product dispatch
dot(a::Vector2D, b::Vector2D) = a.x * b.x + a.y * b.y
dot(a::Vector3D, b::Vector3D) = a.x * b.x + a.y * b.y + a.z * b.z

# Cross product hanya untuk 3D
cross(a::Vector3D, b::Vector3D) = Vector3D(
    a.y * b.z - a.z * b.y,
    a.z * b.x - a.x * b.z,
    a.x * b.y - a.y * b.x
)

# Operations on different numeric types
operate(a::Int, b::Int) = "int-int: $(a + b)"
operate(a::Float64, b::Float64) = "float-float: $(a + b)"
operate(a::Int, b::Float64) = "int-float: $(Float64(a) + b)"
operate(a::String, b::String) = "string-string: $a$b"

# Data pipeline dengan multiple dispatch
abstract type DataSource end
struct CSVSource <: DataSource
    path::String
end
struct JSONSource <: DataSource
    path::String
end
struct DatabaseSource <: DataSource
    connection_string::String
    query::String
end

abstract type Transform end
struct Normalize <: Transform end
struct Filter <: Transform
    predicate::Function
end
struct Aggregate <: Transform
    func::Function
end

# Load berdasarkan tipe data source
load(source::CSVSource) = println("Loading CSV from $(source.path)")
load(source::JSONSource) = println("Loading JSON from $(source.path)")
load(source::DatabaseSource) = println("Querying: $(source.query)")

# Apply transform berdasarkan kombinasi source + transform
apply(source::CSVSource, t::Normalize) = println("Normalize CSV data")
apply(source::CSVSource, t::Filter) = println("Filter CSV data")
apply(source::JSONSource, t::Normalize) = println("Normalize JSON data")
apply(::DataSource, ::Transform) = println("Generic transform")

# Pipeline function
function pipeline(source::DataSource, transforms::Transform...)
    load(source)
    for t in transforms
        apply(source, t)
    end
end

# Usage
src = CSVSource("data.csv")
pipeline(src, Normalize(), Filter(x -> x > 0))

using LinearAlgebra

# Array creation
v = [1, 2, 3, 4, 5]
m = [1 2 3; 4 5 6; 7 8 9]   # 3x3 matrix

# Special matrices
zeros(3, 3)
ones(2, 4)
I(3)         # 3x3 identity matrix
rand(3, 3)   # random 3x3
randn(3, 3)  # random normal

# Array operations
v .+ 1         # element-wise addition
v .* 2         # element-wise multiplication
v .^ 2         # element-wise power

# Matrix operations
A = [1 2; 3 4]
B = [5 6; 7 8]
A * B          # matrix multiplication
A .* B         # element-wise multiplication
A'             # transpose
inv(A)         # inverse
det(A)         # determinant
eigvals(A)     # eigenvalues
eigvecs(A)     # eigenvectors

# Solving linear systems Ax = b
A = [1 2; 3 4]
b = [5, 6]
x = A \ b      # solve Ax = b

# Broadcasting
f(x) = x^2 + 2x + 1
f.(v)          # apply f to each element

# Slicing
m = reshape(1:20, 4, 5)
m[2, 3]        # element at row 2, col 3
m[:, 1]        # first column
m[1:2, :]      # first two rows

# Generator expressions (lazy evaluation)
s = sum(x^2 for x in 1:1000)

using Plots

# Basic line plot
x = 0:0.1:2π
y = sin.(x)
plot(x, y, title="Sinus", xlabel="x", ylabel="sin(x)", label="sin(x)")

# Multiple plots
plot(x, [sin.(x) cos.(x)], label=["sin(x)" "cos(x)"],
     title="Trigonometric Functions")

# Scatter plot
scatter(randn(100), randn(100), title="Random Scatter",
        xlabel="x", ylabel="y", markersize=3)

# Histogram
histogram(randn(10000), bins=50, title="Normal Distribution",
          label="samples", normalize=:pdf)

# Surface plot
x = range(-3, 3, length=100)
y = range(-3, 3, length=100)
z = [exp(-(x^2 + y^2)) for x in x, y in y]
surface(x, y, z, title="Gaussian 2D")

# Subplots
p1 = plot(x, sin.(x), title="sin")
p2 = plot(x, cos.(x), title="cos")
p3 = plot(x, tan.(x), title="tan", ylim=(-5, 5))
p4 = scatter(randn(100), randn(100), title="scatter")
plot(p1, p2, p3, p4, layout=(2, 2), size=(800, 600))

# Save plot
savefig("my_plot.png")
savefig("my_plot.pdf")

# Jalankan dengan: julia -p 4 (4 worker processes)
# Atau:
using Distributed
addprocs(4)

# @distributed - parallel for loop
@distributed for i in 1:100
    # Setiap iterasi berjalan di worker berbeda
    sum(sin.(randn(10000)))
end

# pmap - parallel map
using Distributed
results = pmap(x -> x^2, 1:100)

# @spawn - kirim task ke worker
result = @spawnat 2 heavy_computation()

# Shared arrays
using SharedArrays
shared = SharedArray{Float64}(1000)
@distributed for i in 1:1000
    shared[i] = sin(i * 0.01)
end

# Multi-threading (lebih ringan dari multi-process)
# Jalankan: julia --threads=4
using Base.Threads

# Thread-safe counter
counter = Atomic{Int}(0)
@threads for i in 1:10000
    atomic_add!(counter, 1)
end
println("Counter: $(counter[])")

# Parallel reduction
function parallel_sum(arr)
    results = zeros(nthreads())
    @threads for i in eachindex(arr)
        results[threadid()] += arr[i]
    end
    return sum(results)
end

# Channel-based communication
ch = Channel{Int}(32)
@async begin
    for i in 1:10
        put!(ch, i^2)
    end
    close(ch)
end
for val in ch
    println("Received: $val")
end

# 1. Avoid global variables (atau gunakan const)
const N = 10000  # const = type-stable global

# 2. Type stability - pastikan compiler tahu tipe
function good_sum(v)
    total = zero(eltype(v))  # type-stable
    for x in v
        total += x
    end
    return total
end

# 3. Pre-allocate arrays
function bad_example(n)
    result = Float64[]  # growing array
    for i in 1:n
        push!(result, sin(i))  # allocation setiap iterasi
    end
    return result
end

function good_example(n)
    result = Vector{Float64}(undef, n)  # pre-allocate
    for i in 1:n
        result[i] = sin(i)  # in-place
    end
    return result
end

# 4. Use views instead of copies
function process_matrix(A)
    @views for i in 1:size(A, 2)
        col = A[:, i]  # creates a copy
        col_view = @view A[:, i]  # creates a view (no copy)
    end
end

# 5. Benchmarking
using BenchmarkTools
@btime sin(1.0)
@benchmark sin(1.0)

# 6. Profiling
using Profile
@profile for i in 1:100000; sin(i); end
Profile.print()

# 7. In-place operations
function inplace_operations()
    A = rand(1000, 1000)
    B = rand(1000, 1000)

    # Bad: creates new array
    C = A + B

    # Good: in-place
    C = similar(A)
    C .= A .+ B  # broadcasts in-place

    # Matrix operations
    mul!(C, A, B)  # in-place matrix multiply
end

# 8. Static arrays untuk ukuran kecil
using StaticArrays
const Vec3 = SVector{3, Float64}
const Mat3 = SMatrix{3, 3, Float64}

v = Vec3(1.0, 2.0, 3.0)  # stack-allocated, sangat cepat

# Julia code adalah data (AST - Abstract Syntax Tree)
expr = :(x + y)           # Quote
dump(expr)                 # Lihat struktur AST

# Macros - code generation saat compile time
macro sayhello(name)
    return :(println("Hello, $($name)!"))
end

@sayhello "World"    # Hello, World!

# Macro untuk benchmarking
macro mytime(ex)
    return quote
        local t0 = time()
        local val = $ex
        local t1 = time()
        println("Elapsed: $(t1 - t0) seconds")
        val
    end
end

@mytime sleep(0.1)

# Macro untuk validasi
macro assert_positive(ex)
    return quote
        local val = $ex
        @assert val > 0 "Expected positive, got $val"
        val
    end
end

result = @assert_positive sqrt(144)

# Generated functions
@generated function describe(x)
    if x <: Integer
        return :(println("Integer: $x"))
    elseif x <: AbstractFloat
        return :(println("Float: $x"))
    elseif x <: AbstractString
        return :(println("String: $x"))
    else
        return :(println("Unknown type: $x"))
    end
end

# Domain-specific language (DSL)
macro df(ex)
    # Parse dataframe operations
    # e.g., @df users select(:name, :age) filter(:age > 18)
end