1

    
    
    2021-11-17T01:55:02.247Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      一般我們會在函式的引數上加上參數，這樣可以讓函式去推論引數的型別，這樣有多種用途，其中之一當然是增進效能。
1
2
3
4
5
julia> foo(a::T) where {T} = zero(T)
foo (generic function with 1 method)

julia> foo(5)
0
那我們有沒有辦法對回傳值的型別做參數化呢？
有的，可以這樣做。
1
2
3
4
5
julia> (foo(a::T)::T) where {T} = zero(T)
foo (generic function with 1 method)

julia> foo(5)
0
一般要標記回傳值的型別，要寫在整個 function signature 的後面，也就是
1
foo(a)::Int
如果要將他標記為參數，那就需要寫成
1
(foo(a)::T) where {T}
這樣就寫出來啦！！
]]>
    
    https://yuehhua.github.io/blog/2021/10/14/parametric-return-type/
    
    2021-10-14T01:30:50.000Z
    

      一般我們會在函式的引數上加上參數，這樣可以讓函式去推論引數的型別，這樣有多種用途，其中之一當然是增進效能。


    
    
    2021-10-14T01:46:28.843Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      有鑑於 Debugger.jl 的說明文件有點難懂，就自己來寫一篇教學。
Debugger.jl 是在 Julia 上，由官方開發及維護的除錯器（debugger），debugger 如同其他語言的 debugger 一樣，可以預先設定斷點（breakpoint）、在丟出例外（exception）時停下來、逐行執行及檢查變數等等功能。這篇文章會示範最基礎的 debugger 的用法。
安裝 Debugger
安裝 Julia 套件都是差不多的方式，切換到套件模式，並且 add PACKAGE。
1
]add Debugger
等他跑好就把 Debugger 安裝好了。
在 REPL 執行 Debugger
基本上，Debugger 是一種直譯器，所以比較好的執行環境是在 REPL 中。
當然在 VS code 也有內建，但是我個人嘗試過，他跑得蠻慢的，不知道為什麼。= ="
所以以下的示範都是在 REPL 上。
逐行執行
為了示範，所以就先定義兩個函式。
1
2
3
4
5
6
7
8
9
10
11
julia> using Debugger

julia> function foo(x, y)
           z = x + 2
           y = y*(y + z)
           return y
       end
foo (generic function with 1 method)

julia> bar(x) = foo(x, 5)
bar (generic function with 1 method)
逐步執行
Debugger 都會有個進入點，進入點需要在前面標記 @enter，後面可以接著一個表示式。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
julia> @enter bar(3)
In bar(x) at REPL[2]:1
>1  bar(x) = foo(x, 5)

About to run: (foo)(3, 5)
1|debug> s
In foo(x, y) at REPL[1]:1
 1  function foo(x, y)
>2      z = x + 2
 3      y = y*(y + z)
 4      return y
 5  end

About to run: _J3
1|debug> s
In +(x, y) at int.jl:87
>87  (+)(x::T, y::T) where {T<:BitInteger} = add_int(x, y)

About to run: (Core.Intrinsics.add_int)(3, 2)
以上進入了 bar(3) 這個函式呼叫。剛進入的時候，他會停在函式呼叫的第一步：(foo)(3, 5)。
接著，他會進入除錯（debug）模式，在這個模式下，就可以藉由指令來操作這個 debugger。
如果輸入 s，他會逐步執行程式碼，所以可以看到他進入到 foo 函式中，並且指標指到第二行的 z = x + 2。
如果再輸入一次 s，讓他執行下一步，這時候加法就會被執行，所以就會進到 (Core.Intrinsics.add_int)(3, 2) 的執行。
逐行執行
如果我們希望他可以逐行執行，可以用 n。
1
2
3
4
5
6
7
8
9
10
11
12
julia> @enter bar(3)
In bar(x) at REPL[2]:1
>1  bar(x) = foo(x, 5)

About to run: (foo)(3, 5)
1|debug> n
In bar(x) at REPL[2]:1
>1  bar(x) = foo(x, 5)

About to run: return %J1
1|debug> n
50
如果輸入 n 之後，debugger 會直接計算該行的計算結果，foo(x, 5) 就會被執行，並回傳 50。
執行到丟出例外
比較實用的是讓他執行直到一個例外被拋出。這時我們需要修改一下函式：
1
2
3
4
5
6
function foo(x, y)
    z = x + 2
    throw(ErrorException("This is an error."))
    y = y*(y + z)
    return y
end
在第二行中插入一條拋出 ErrorException 例外的表示式。
要執行到直到丟出例外，並且停下，有幾種方法。
在除錯模式，例外前插入斷點法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
julia> @enter bar(3)
In bar(x) at REPL[2]:1
>1  bar(x) = foo(x, 5)

About to run: (foo)(3, 5)
1|debug> bp on throw
Breaking on throw
1|debug> c
Breaking for error:
ERROR: This is an error.
Stacktrace:
 [1] foo(x::Int64, y::Int64)
   @ Main REPL[10]:3
 [2] bar(x::Int64)
   @ Main REPL[2]:1

In foo(x, y) at REPL[10]:1
 1  function foo(x, y)
 2      z = x + 2
>3      throw(ErrorException("This is an error."))
 4      y = y*(y + z)
 5      return y
 6  end

About to run: (throw)(ErrorException("This is an error."))
一樣是利用 @enter 來製造進入點，接著利用 bp on throw 來設定斷點，他的意思是在拋出例外時設定斷點。
相對，這個斷點是可以關閉的，用 bp off throw。
接著，可以輸入 c 讓程式持續執行，最後他就會停在斷點處。
在 REPL 模式，例外前插入斷點法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
julia> break_on(:error)

julia> @run bar(3)
Breaking for error:
ERROR: This is an error.
Stacktrace:
 [1] foo(x::Int64, y::Int64)
   @ Main REPL[10]:3
 [2] bar(x::Int64)
   @ Main REPL[2]:1

In foo(x, y) at REPL[10]:1
 1  function foo(x, y)
 2      z = x + 2
>3      throw(ErrorException("This is an error."))
 4      y = y*(y + z)
 5      return y
 6      end

About to run: (throw)(ErrorException("This is an error."))
跟前面的想法差不多，只是這次是在 REPL 下操作。
這次就不用急著進入除錯模式，可以直接在 REPL 下設定在拋出例外前的斷點，可以用 break_on(:error)。
@run 這個 macro 就等同於 @enter + c，所以他會執行直到斷點發生。
查看變數的值
我們停在斷點之後可以做什麼事情呢？除錯就是要在執行環境中去檢查執行時期的變數是不是符合預期。
這時候我們可以把 backtrace 給列出來。
1
2
3
4
5
6
7
1|debug> bt
[1] foo(x, y) at REPL[10]:3
  | x::Int64 = 3
  | y::Int64 = 5
  | z::Int64 = 5
[2] bar(x) at REPL[2]:1
  | x::Int64 = 3
輸入 bt 可以列出停在目前的斷點，在 foo 及 bar 函式中存有的區域變數以及他的值有哪些。
我們可以發現我們首先呼叫 bar，bar 會去呼叫 foo。我們知道函式呼叫會在堆疊（stack）中，推入一個新的呼叫框（frame），呼叫框中包含著函式呼叫的引數（arguments）、區域變數等等資訊。
foo 的呼叫會在整個堆疊的最上面，也就是第一個 frame，所以看到他標示 [1]，而 bar 的呼叫就是位於第二個 frame。
叫出指定 frame 中的變數
我們可以叫出指定的 frame 的區域變數，只要在除錯模式中輸入 fr [i::Int]，i 則是指定第幾個 frame。
1
2
3
4
5
1|debug> fr 1
[1] foo(x, y) at REPL[10]:1
  | x::Int64 = 3
  | y::Int64 = 5
  | z::Int64 = 5
我們就可以看到在這個階段第一個 frame 的 x、y 跟 z 變數的值各是多少。
我們可以再試試看第二個 frame 的內容。
1
2
3
1|debug> fr 2
[2] bar(x) at REPL[2]:1
  | x::Int64 = 3
切換目前的 frame
剛進入斷點的話，我們都會是位於第一個 frame 中。有時候我們會想要知道在其他 frame 的狀況，這時候我們就需要切換 frame 的位置。
這時候只要輸入 f [i::Int] 就可以切換不同的 frame，例如，想要切換到第二個 frame 就可以輸入 f 2。
1
2
3
4
5
6
1|debug> f 2
In bar(x) at REPL[2]:1
>1  bar(x) = foo(x, 5)

About to run: (foo)(3, 5)
2|debug> 
還可以發現在除錯模式的 prompt 2|debug>，最開頭的數字改變了，一開始是 1，後來變成 2。
這就表示目前所在第幾個 frame。
切換成 Julia REPL 模式
在除錯模式輸入 `（鍵盤左上），就可以切換到 Julia REPL 模式，並且存取變數。
1
2
3
4
5
6
7
8
9
10
1|debug> fr 2
[2] bar(x) at REPL[2]:1
  | x::Int64 = 3
1|debug> f 2
In bar(x) at REPL[2]:1
>1  bar(x) = foo(x, 5)

About to run: (foo)(3, 5)
2|julia> x
3
切換之後，你會看到 2|debug> 切換成 2|julia，並且可以直接存取該變數 x。如果要切換回除錯模式，只要按 backspace 鍵，把 ` 刪除即可。
1
2
2|julia> x
3
也可以對該變數做運算。
1
2
2|julia> x + 2
5
但是沒辦法存新的變數。
1
2
3
4
5
6
7
8
2|julia> y = x + 2
5

2|julia> y
ERROR: UndefVarError: y not defined
Stacktrace:
 [1] top-level scope
   @ none:1
結論
我們有了這些工具跟方法，可以讓我們在不同的 frame 之間做跳躍，去看在上層或是下層的 frame 中變數的數值各是多少。
同時，也可以測試你自己寫的函式是否正常執行。
我們就可以用這些方法來除錯程式碼。
]]>
    
    https://yuehhua.github.io/blog/2021/05/25/how-to-use-julia-debugger/
    
    2021-05-25T08:27:28.000Z
    

      有鑑於 Debugger.jl 的說明文件有點難懂，就自己來寫一篇教學。

Debugger.jl 是在 Julia 上，由官方開發及維護的除錯器（debugger），debugger 如同其他語言的 debugger 一樣，可以預先設定斷點（breakpoint）、在丟出例外（exception）時停下來、逐行執行及檢查變數等等功能。這篇文章會示範最基礎的 debugger 的用法。
]]>
    
    
    2021-05-25T08:27:27.785Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      基本上，我們知道 Julia 的命名空間的概念不是很強，命名空間的概念是由模組（module）所建構的。
介紹模組前先要介紹幾個比較基本的語法：using、import 跟 include。
基本語法
using
using 是用在一般要載入一個套件的時候用的。像是要使用標準函式庫（stdlib）中的 LinearAlgebra 的時候，會這樣做
1
using LinearAlgebra
如此一來，你就可以使用像是
1
tr
或是
1
LinearAlgebra.tr
然而，像是 LinearAlgebra.tr 這樣由 [module].[function] 構成的，則是去呼叫 [module] 底下的 [function]。像是 tr 則是由 LinearAlgebra 模組，藉由 using LinearAlgebra 語法，匯出（export）到我們載入的空間。
例如，
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
julia> tr
ERROR: UndefVarError: tr not defined

julia> Main.tr
ERROR: UndefVarError: tr not defined
Stacktrace:
 [1] top-level scope
   @ REPL[2]:1

julia> using LinearAlgebra

julia> tr
tr (generic function with 7 methods)

julia> Main.tr
tr (generic function with 7 methods)
基本上，無論是由腳本（script）執行或是 REPL 執行，我們所在的是在 Main 這個模組下，可以用 parentmodule(Base) 測試。
import
如果要重複定義同名的函式，會被視為是要延伸（extend）該函式的定義，幫該函式新增更多的方法（method）。我們先來看看 string 這個函式。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
julia> parentmodule(string)
Base

julia> methods(string)
# 20 methods for generic function "string":
[1] string() in Base at strings/basic.jl:221
[2] string(x::T) where T<:Union{Float16, Float32, Float64} in Base.Ryu at ryu/Ryu.jl:121
[3] string(f::Printf.Spec{T}; modifier) where T in Printf at /usr/share/julia/stdlib/v1.6/Printf/src/Printf.jl:35
[4] string(u::Base.UUID) in Base at uuid.jl:86
[5] string(a::Symbol) in Base at strings/io.jl:176
[6] string(a::String) in Base at strings/substring.jl:177
[7] string(t::Dates.Time) in Dates at /usr/share/julia/stdlib/v1.6/Dates/src/io.jl:44
[8] string(hash::Base.SHA1) in Base at loading.jl:106
[9] string(b::Bool) in Base at intfuncs.jl:779
[10] string(a::SubString{String}) in Base at strings/substring.jl:178
[11] string(a::Union{Char, SubString{String}, String}...) in Base at strings/substring.jl:208
[12] string(s::AbstractString) in Base at strings/basic.jl:222
[13] string(b::BigFloat) in Base.MPFR at mpfr.jl:999
[14] string(id::LibGit2.GitShortHash) in LibGit2 at /usr/share/julia/stdlib/v1.6/LibGit2/src/oid.jl:181
[15] string(f::Random.DSFMT.GF2X) in Random.DSFMT at /usr/share/julia/stdlib/v1.6/Random/src/DSFMT.jl:108
[16] string(x::Dates.CompoundPeriod) in Dates at /usr/share/julia/stdlib/v1.6/Dates/src/periods.jl:337
[17] string(n::BigInt; base, pad) in Base.GMP at gmp.jl:682
[18] string(n::Integer; base, pad) in Base at intfuncs.jl:760
[19] string(mode::Pkg.GitTools.GitMode) in Pkg.GitTools at /usr/share/julia/stdlib/v1.6/Pkg/src/GitTools.jl:171
[20] string(xs...) in Base at strings/io.jl:174
例如，想要延伸 string 這個函式的定義，我們先得從 Base 模組匯入所有關於 string 的方法，以便延伸方法。所以需要
1
import Base: string
如此會把 Base 裡頭關於 string 的定義都匯出，如此一來，就可以定義新的方法。
1
2
3
4
5
6
7
julia> struct Foo end

julia> string(::Foo) = "foo"
string (generic function with 21 methods)

julia> string(Foo())
"foo"
include
include 則是對於檔案的操作，它可以將其他檔案中的程式碼包含（include）進來。例如有個 a.jl 這個檔案，其內容有：
1
2
3
println("a.jl file is included.")

foo(x) = x
這時候可以在另一個檔案 main.jl 中寫：
1
2
3
include("a.jl")

println(foo(5))
執行 main.jl 之後，會看到：
1
2
a.jl file is included.
5
代表在包含 a.jl 檔案的過程中，裡頭的程式碼都會被執行過，所以會看到 a.jl file is included.，並且可以使用 foo 函式，則代表 foo 函式的定義一併被帶到 main.jl 當中。
這就是 include 的作用了。
模組
一個模組是由以下的程式碼定義的
1
2
3
4
5
6
7
8
9
module Foo

export foo

foo(x) = x
foo(x::String) = "!!" * x * "!!"
bar(x::String) = "bar: " * x

end
模組中可以定義型別或是函式等等程式碼，而模組中所定義的型別或是函式能不能自動地匯出，主要是由 export 語法指定。
export 會匯出那些被指定的型別或是函式，會在有 using Foo 的作用域可以見到 foo，並且可以使用，但是沒有匯出的，像是 bar 就沒辦法直接使用，但是還是可以藉由 Foo.bar 來使用它。
命名空間
從以上的例子，我們不難發現，Foo 模組形成了一個命名空間（namespace），這個命名空間所定義的變數、函式或是型別等等程式元素，都有自己的識別子（identifier），也就是命名是唯一的。然而，Julia 模組中的 export 會自動把該模組中的特定識別子匯出到 Main 這個命名空間中，所以可以在 Main 裡直接使用 foo，而沒有匯出的則需要使用 Foo.bar 來使用它。
在 Julia 是沒有硬性的命名空間的，命名空間則是由模組名稱所組成的，例如像先前介紹的 LinearAlgebra 就是由 LinearAlgebra 模組構成。
套件
套件跟模組的概念是不一樣的。套件包含了一系列定義的型別或是函式，最重要的是，套件的資料夾中含有 Project.toml 來對套件進行管理。
而且模組是沒有辦法被 using 或是 import 的，要 ]add PACKAGE 才行。
套件主要會有一個主模組，其中可以包含其他子模組，變得有點像資料夾結構的樣子。
一個套件要可以被其他套件加為相依套件的話，則需要該套件有 git 版本控制。
例子
這邊我分別做了 A 跟 B 兩個套件，並且讓 B 有加 A 為其相依套件。
在 A 中有（src/A.jl）
1
2
3
4
5
6
7
8
9
module A

export foo

foo(x) = x
foo(x::String) = "!!" * x * "!!"
bar(x::String) = "bar: " * x

end
在 B 中有（src/B.jl）
1
2
3
4
5
6
7
module B

using A

foo(::Number) = 5

end
後續的介紹裡會用到這邊的例子進行解說。
匯入其他套件
讓我們來假設幾種狀況，接下來會討論這些狀況，以及一些解決方法。
子模組與命名空間
using A
如果按照以上的例子，在其他的檔案中 using B 的話，會有什麼呢？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
julia> using B

julia> B
B

julia> B.foo
foo (generic function with 1 method)

julia> methods(B.foo)
# 1 method for generic function "foo":
[1] foo(::Number) in B at /media/yuehhua/Workbench/workspace/B/src/B.jl:7

julia> B.A
A

julia> B.A.foo
foo (generic function with 2 methods)

julia> methods(B.A.foo)
# 2 methods for generic function "foo":
[1] foo(x::String) in A at /home/yuehhua/.julia/packages/A/dbyNq/src/A.jl:6
[2] foo(x) in A at /home/yuehhua/.julia/packages/A/dbyNq/src/A.jl:5

julia> B.A.bar
bar (generic function with 1 method)
如此一來，A 套件就會變成 B 下的其中一個子模組，所以可以使用 B.A 來找到所有 A 底下的函式。也可以進一步發現，在 B 中定義的 foo 跟在 A 中定義的 foo 是分開來的。
import A: foo
那如果我們把 B 套件中的 using A 改成 import A: foo 會發生什麼事情呢？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
julia> using B

julia> B
B

julia> B.A
ERROR: UndefVarError: A not defined
Stacktrace:
 [1] top-level scope
   @ REPL[3]:1

julia> B.foo
foo (generic function with 3 methods)

julia> methods(B.foo)
# 3 methods for generic function "foo":
[1] foo(x::String) in A at /home/yuehhua/.julia/packages/A/dbyNq/src/A.jl:6
[2] foo(::Number) in B at /media/yuehhua/Workbench/workspace/B/src/B.jl:7
[3] foo(x) in A at /home/yuehhua/.julia/packages/A/dbyNq/src/A.jl:5

julia> B.bar
ERROR: UndefVarError: bar not defined
Stacktrace:
 [1] top-level scope
   @ REPL[6]:1
我們可以發現 B 套件中的子模組 A 就消失了，而且所有 A 套件中 foo 都會跑到 B 套件當中。當然，bar 則不會在 B 套件當中。
import A
那如果我們把 B 套件中的 using A 改成 import A 呢？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
julia> using B

julia> B
B

julia> B.foo
foo (generic function with 1 method)

julia> B.bar
ERROR: UndefVarError: bar not defined
Stacktrace:
 [1] top-level scope
   @ REPL[4]:1

julia> B.A
A

julia> B.A.foo
foo (generic function with 2 methods)

julia> B.A.bar
bar (generic function with 1 method)
看來 import A 跟 using A 沒有太大的差別。
有子模組也有所有方法的定義
如果要讓 A 子模組存在，並且可以在 B 套件中使用到所有 A 子模組中的方法，則需要
1
2
3
using A

import A: foo
如此則會變成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
julia> using B

julia> B
B

julia> B.foo
foo (generic function with 3 methods)

julia> B.A
A

julia> B.A.foo
foo (generic function with 3 methods)

julia> B.A.bar
bar (generic function with 1 method)

julia> B.bar
ERROR: UndefVarError: bar not defined
Stacktrace:
 [1] top-level scope
   @ REPL[7]:1
我想定義自己的方法，但是會跟其他的套件衝突
常常發生的問題就是，開發中會用到某 A 套件，而自己定義的函式中有跟 A 套件衝突的部份。
1
using A
例如，A 套件中匯出了 foo 函式，而自己開發的套件也定義了同樣的函式名稱。這時候就會發生衝突，也就是出現類似以下的錯誤：
1
ERROR: error in method definition: function A.foo must be explicitly imported to be extended
這時候就需要明確地延伸定義，也就是修改或是增加以下程式碼：
1
import A: foo
如此一來，就可以定義自己的 foo 了。
不想要 import
會有基於一些緣故不想要匯入 A 套件的功能。這時候很單純，那就是用以上 using A 的方式而已。
為了跟 A 套件的功能區別，可以在 B 套件中，指定要呼叫的套件。
在 src/B.jl 中，
1
2
3
4
5
6
7
8
9
10
module B

using A

foo(::Number) = 5

println(A.foo(4))
println(B.foo(4))

end
載入 B 套件時會有
1
2
3
julia> using B
4
5
讓一個套件去補充其他套件的功能
像我前一陣子的工作是將 scatter 跟 gather 搬到 NNlib 套件下。
主要當然是把 cpu 運算的部份寫在 NNlib 套件中，但是會有 cuda 運算的部份。然而，cuda 運算的部份則是寫在 NNlibCUDA 套件下，NNlibCUDA 套件則是 NNlib 套件的一個依賴套件。
這時候 NNlibCUDA 套件的角色就是去延伸 NNlib 套件下，scatter 與 gather 的 cuda 版本，所以這時候我會在 NNlibCUDA 套件中寫：
1
2
3
4
5
6
7
function NNlib.scatter(::CuArray, ...)
    ...
end

function NNlib.gather(::CuArray, ...)
    ...
end
如此，在載入 NNlibCUDA 套件時，就會自動去延伸scatter 與 gather 的方法了。
結論
這邊整理了一些關於命名空間跟一些基本的模組概念，沒有特別實驗或是在開發套件的朋友可能會一團混亂。
這時候就真的有需要一篇文章來澄清這些行為了呢！
]]>
    
    https://yuehhua.github.io/blog/2021/05/22/namespace-in-julia/
    
    2021-05-21T16:37:40.000Z
    

      基本上，我們知道 Julia 的命名空間的概念不是很強，命名空間的概念是由模組（module）所建構的。

介紹模組前先要介紹幾個比較基本的語法：using、import 跟 include。
]]>
    
    
    2021-05-22T01:39:25.746Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      最近有遇到業界的工程師對 Julia 有點好奇，提了一些問題。
在 Python 到 Julia 的轉換路上，常常不知道原本在 Python 用慣的套件，在 Julia 中要去哪裡找？
Python 的效能優化套件
例如，在 Python 都用 numba 來提升效能，那麼 Julia 有相對應的套件可以用嗎？
簡單地回答是「Julia 除了解決 two language problem 以外，他也是直接有 numba 的效能，內建 numpy 跟一部分 scipy」。
也就是，「Julia = numpy + part of scipy + numba」。
比較複雜的回答則是，Julia 的重點擺在他強大的編譯器跟語言設計上，因為語言設計的緣故，所以他可以在 jit 蒐集各種型別的資訊。
以往動態語言的效能不高，最大的問題在於一個變數一直要到執行時期才有辦法決定他的型別，這導致了編譯器無法事先對他做最佳化，這我們也稱為 type unstable。然而，Julia 的突破就在於這點，他的語言設計及有效的型別推斷，讓他被編譯成 LLVM IR 的時候擁有跟 C 這類靜態語言一樣充足的型別資訊，所以他可以有靜態語言的效能，有完整型別資訊的 LLVM IR 編譯出來的機器碼，就跟用 C 寫沒什麼兩樣了。
另一邊，numba 的本身也是利用編譯最佳化的技術讓效能可以上去，這個本身可以被視為半個編譯器，但是他本身也會有所限制。像是他不能處理巢狀結構的最佳化，當有陣列中含有其他陣列的時候就沒有辦法。相對 Julia 本身就是語言編譯器，所以他本來就可以對這些巢狀結構做最佳化，並且 Julia 的型別本身直接對應 C 的 struct，甚至 alignment 也是一致的，所以也就是 C 的效能了。總結，Julia 編譯器對陣列的行為最佳化產出的成果就是 numba 本身。
那這點不只用在陣列上，歐洲有新創公司在做資料庫引擎，他們利用 Julia 加上他們自家開發的套件，把 Julia 編譯器當成他們引擎的最佳化器，那他們的資料庫引擎就有等同於 C 寫出來的一樣，他們甚至將機器學習套件結合到他們的資料庫中，就等同於可以在資料端訓練模型的引擎。
Python 與 Julia 相對應的套件
既然有這樣的疑問，所以我整理了一系列 Python 套件與 Julia 套件的對應表。
numpy + numba -> Julia
numpy 是 Python 底下的矩陣運算加速套件，其最重要的特色就是他底下使用了 C 實作套件，所以當你使用了 numpy 就等於是使用了 C 的陣列，以及其速度。對於陣列以外的資料結構，則會使用 numba 來做加速。
Julia 在語言設計上也支援陣列，並且在型別的結構上有跟 C struct 有一樣的 alignment。所以使用 Julia 本來就是 Python 中的 numpy + numba + cython。
你不用在 Python 中寫 C-like 的語法啦！
scipy
scipy 是 Python 底下相當知名的科學運算套件，最重要的特色就是他直接整合 numpy，所以科學運算就有了 C 陣列的速度。但由於 scipy 包山包海，沒有一個套件可以直接對應 scipy，不過 Julia 中有對於不同的功能直接對應的套件。以下列出這些套件：
線性代數 Linear algebra (scipy.linalg): Julia 內建標準函式庫 LinearAlgebra
稀疏矩陣 Sparse arrays (scipy.sparse.csgraph): Julia 內建標準函式庫 SparseArrays 以及 SuiteSparse
特徵分解套件 ARPACK: Julia 官方直接支援的 Arpack.jl
特殊函式 Special functions (scipy.special): SpecialFunctions.jl
快速傅立葉轉換 Fourier Transforms (scipy.fft): FFTW.jl
最佳化 Optimization (scipy.optimize): JuMP
數值積分 Integration (scipy.integrate)
一維的積分 QuadGK.jl
高維度的積分 HCubature.jl 或是 NIntegration.jl
Calculus.jl
NumericalMath.jl
教學可以參考這篇文章
github org JuliaApproximation
內插 Interpolation (scipy.interpolate): Interpolations.jl
統計 Statistics (scipy.stats): Distributions.jl
訊號處理 Signal Processing (scipy.signal)
DSP.jl
SignalOperators.jl
教學可以參考這裡
Wavelets.jl
Deconvolution.jl
github org JuliaDSP
空間資料結構 Spatial data structures and algorithms (scipy.spatial): NearestNeighbors.jl
影像處理 Multidimensional image processing (scipy.ndimage): JuliaImages
matplotlib
繪圖套件可以參考以下：
Plots.jl
Gadfly.jl
GPU 繪圖套件 Makie.jl
sympy
Symbolics.jl 是近期推出相當熱門的符號操作套件，他支援的現代的快速電腦代數系統，足以媲美 MATLAB。
pandas
DataFrames.jl 提供了表格類資料的資料結構與運算，實作直接是 Julia 陣列，運算的部份支援絕大多數 pandas 的運算，以及支援類資料庫操作。讀寫檔的操作可以使用 CSV.jl 來讀寫 csv, tsv 類檔案。Tables.jl 是以上套件與資料庫銜接的介面，可以搭配 TableOperations.jl 的串流運算，可以串到 ODBC.jl、LibPQ.jl、MySQL.jl、SQLite.jl 和 Hive.jl 等等資料庫。
statsmodels
HypothesisTests.jl
GLM.jl
MixedModels.jl
TimeSeries.jl
scikit-learn
MLJ.jl 提供了超過 150 種經典機器學習模型，包含了知名的 libsvm、xgboost、scikit-learn 等等套件，這個套件是由知名的 Alan Turing Institute 的團隊所維護。
Deep learning
在 Python 有兩大知名深度學習套件：pytorch 及 tensorflow，Julia 則有 Flux.jl 和 Knet.jl。
使用 Julia 的好處
對比 Python 現有的套件與生態系，Julia 可能都有對應的套件可以使用。不過使用 Julia 有什麼特別的優勢嗎？可能是 code 可以寫得更好維運？統一風格？更好閱讀或更精簡？Python 用上述函式庫有時候就是各自一套 DSL，像是在寫多種不同語言的感覺。
Julia 主要解決所謂的 two language problem 是指，開發的時候需要一個好寫好改的語言，可以快速開發，快速做驗證。在產品上線的時候需要效能，但往往需要另外一個語言的重新實作，但是用 Julia 就可以直接在同一個語言直接開發，並且逐步調整效能，不用重寫。
使用 Julia 在程式碼風格上統一，在開發期間所用的語言就是上線的語言，不會有要上線的語言要將 python/matlab/R 轉換成 C/C++ 這種狀況發生。更有甚者，我個人認為 Julia 在語言設計上，可以讓工程師在寫 code 的時候，code 寫得更為精簡。
相對，DSL 的部分就不會是因為不同的函式庫而有有不同 DSL，而是因為有不同的應用場景 (統計、ML、DL)，因為不同領域的人有不同的習慣或是使用情境去設計適合他們的 DSL。
]]>
    
    https://yuehhua.github.io/blog/2021/04/19/corresponding-packages-in-julia-and-python/
    
    2021-04-19T03:16:56.000Z
    

      最近有遇到業界的工程師對 Julia 有點好奇，提了一些問題。

在 Python 到 Julia 的轉換路上，常常不知道原本在 Python 用慣的套件，在 Julia 中要去哪裡找？
]]>
    
    
    2021-04-19T03:49:27.840Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      常常開發者會需要在，使用者使用不同的語言版本或是套件版本，做不同的處置，有可能是安裝不同的函式庫，或是設定不同的參數。這時候要在程式中自動取得目前的語言版本或是特定套件的版本就很重要。Julia 語言本身就有內建版本字串可以使用，它可以用來比較版本的差異或是大小。
Julia 語言版本
如果要取得目前 Julia 語言版本相當地簡單，有個全域變數 VERSION，它直接提供給你目前的語言版本資訊。
1
2
3
4
5
julia> VERSION
v"1.6.0"

julia> VERSION ≥ v"1.5.0"
true
套件版本
目前官方並沒有提供一個方便查詢套件版本的方式給大家。像 python 有 __version__ 可以使用。
1
2
3
>>> import numpy
>>> numpy.__version__
'1.20.0'
目前在 Julia 不依賴套件的方法是到 Pkg.dependencies() 去找尋，他會回傳給你目前所有套件的相依樹（dependency tree），key 是每個套件的 UUID，而 value 則是其相依的套件資訊。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
julia> Pkg.dependencies()
Dict{Base.UUID, Pkg.Types.PackageInfo} with 584 entries:
  UUID("fb77eaff-e24c-56d4-86b1-d163f2edb164") => PackageInfo("Sundials_jll", v"5.2.0+1", "013ff4504fc1d475aa80c63b455b6b3a58767db2", false, false, false, false, true, noth…
  UUID("4d4711f2-db25-561a-b6b3-d35e7d4047d3") => PackageInfo("MatrixMarket", v"0.3.1", "54d39ccb57d29aefa666418bca8ca5598ebd8225", true, false, false, false, true, nothing…
  UUID("708ec375-b3d6-5a57-a7ce-8257bf98657a") => PackageInfo("Gumbo", v"0.8.0", "e711d08d896018037d6ff0ad4ebe675ca67119d4", false, false, false, false, true, nothing, noth…
  UUID("9bbee03b-0db5-5f46-924f-b5c9c21b8c60") => PackageInfo("NaiveBayes", v"0.4.0", "296d27a455ae074d3cb27f7edeff8e6532865f87", true, false, false, false, true, nothing, …
  UUID("c73af94c-d91f-53ed-93a7-00f77d67a9d7") => PackageInfo("ImageMagick_jll", v"6.9.10-12+3", "1c0a2295cca535fabaf2029062912591e9b61987", false, false, false, false, tru…
  UUID("b99e7846-7c00-51b0-8f62-c81ae34c0232") => PackageInfo("BinaryProvider", v"0.5.10", "ecdec412a9abc8db54c0efc5548c64dfce072058", false, false, false, false, true, not…
  UUID("cc61e674-0454-545c-8b26-ed2c68acab7a") => PackageInfo("Xorg_libxkbfile_jll", v"1.1.0+4", "926af861744212db0eb001d9e40b5d16292080b2", false, false, false, false, tru…
  UUID("112f6efa-9a02-5b7d-90c0-432ed331239a") => PackageInfo("VegaLite", v"2.4.1", "eb937ff65666c83f6c4db40d07d2fecfedeaff7e", true, false, false, false, true, nothing, no…
  UUID("7876af07-990d-54b4-ab0e-23690620f79a") => PackageInfo("Example", v"0.5.3", "46e44e869b4d90b96bd8ed1fdcf32244fddfb6cc", true, false, false, false, true, nothing, not…
  UUID("c84ed2f1-dad5-54f0-aa8e-dbefe2724439") => PackageInfo("Ratios", v"0.4.0", "37d210f612d70f3f7d57d488cb3b6eff56ad4e41", false, false, false, false, true, nothing, not…
  UUID("88cd18e8-d9cc-4ea6-8889-5259c0d15c8b") => PackageInfo("ConsoleProgressMonitor", v"0.1.2", "3ab7b2136722890b9af903859afcf457fa3059e8", false, false, false, false, tr…
  UUID("37e2e46d-f89d-539d-b4ee-838fcccc9c8e") => PackageInfo("LinearAlgebra", nothing, nothing, false, false, false, false, true, nothing, nothing, "/usr/share/julia/stdli…
  UUID("31c24e10-a181-5473-b8eb-7969acd0382f") => PackageInfo("Distributions", v"0.23.8", "9c41285c57c6e0d73a21ed4b65f6eec34805f937", true, false, false, false, true, nothi…
  UUID("1bc83da4-3b8d-516f-aca4-4fe02f6d838f") => PackageInfo("SafeTestsets", v"0.0.1", "36ebc5622c82eb9324005cc75e7e2cc51181d181", false, false, false, false, true, nothin…
  UUID("42fd0dbc-a981-5370-80f2-aaf504508153") => PackageInfo("IterativeSolvers", v"0.8.5", "704eee044a41b0e7e8417f7dd2a6b6b5361afd5f", false, false, false, false, true, no…
  UUID("01680d73-4ee2-5a08-a1aa-533608c188bb") => PackageInfo("GenericSVD", v"0.3.0", "62909c3eda8a25b5673a367d1ad2392ebb265211", false, false, false, false, true, nothing,…
  UUID("9a3f8284-a2c9-5f02-9a11-845980a1fd5c") => PackageInfo("Random", nothing, nothing, true, false, false, false, true, nothing, nothing, "/usr/share/julia/stdlib/v1.6/R…
  ...
這種方法會比較辛苦一點，在當中找到特定的套件版本。
如果是用套件的方法則是，安裝 PkgVersion 這個套件，並且使用 PkgVersion.Version 這個函式來取得已載入的套件版本資訊。
1
2
3
4
5
6
julia> using PkgVersion

julia> using DataFrames

julia> PkgVersion.Version(DataFrames)
v"0.21.8"
]]>
    
    https://yuehhua.github.io/blog/2021/04/04/julia-package-version/
    
    2021-04-03T17:20:56.000Z
    

      常常開發者會需要在，使用者使用不同的語言版本或是套件版本，做不同的處置，有可能是安裝不同的函式庫，或是設定不同的參數。這時候要在程式中自動取得目前的語言版本或是特定套件的版本就很重要。Julia 語言本身就有內建版本字串可以使用，它可以用來比較版本的差異或是大小。
]]>
    
    
    2021-04-03T17:20:52.054Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      
在 v1.6 版中，Julia 有大幅度的效能提昇，效能提昇的部份著重在於預編譯（precompilation）以及編譯的效能改進，而 v1.6 版將成為下一個長期支援（long-term support, LTS）的版本。
根據官方部落格，本次版本更新引進了眾多新的技術，包含 parallel precompilation、消除重複編譯、降低編譯器的 latency、加速二進位檔案的載入，以及改善 stacktrace 的格式等等重大的功能。那我們就來詳細看看有哪些更新吧！
重要功能
平行預編譯
使用者在 using/import 某些套件的時候，總是需要等待長久的預編譯時間，但在 v1.6 版引進了平行預編譯（parallel precompilation）技術來降低套件的載入時間。pkg> precompile 會啟動平行預編譯，並且以深度優先的方式，預編譯其套件下的所有相依套件。只有直接相依的套件（列於 Project.toml 中）會丟出錯誤訊息。平行預編譯會在 manifest 被更新之後自動啟動。平行預編譯也支援多套件同時編譯，它會使用多行程（multi-processed）的方式編譯。Julia 會預設地產生最大 CPU 核心數的預編譯任務並且執行平行預編譯。自動預編譯會記住在特定環境下所發生的錯誤，並且會在環境改變時再次嘗試。自動預編譯可以使用 ctrl-c 中斷，或是設定環境變數 JULIA_PKG_PRECOMPILE_AUTO=0 來關閉。
在 v1.5 版載入 DifferentialEquations.jl。
1
2
3
4
5
(v1.5) pkg> add DifferentialEquations
...
julia> @time using DifferentialEquations
[ Info: Precompiling DifferentialEquations [0c46a032-eb83-5123-abaf-570d42b7fbaa]
  474.288251 seconds …
在 v1.6 版載入 DifferentialEquations.jl。
1
2
3
4
5
6
7
8
(v1.6) pkg> add DifferentialEquations
...
Precompiling project...
  Progress [========================================>]  112/112
112 dependencies successfully precompiled in 72 seconds

julia> @time using DifferentialEquations
  4.995477 seconds …
程式碼取自官方部落格。
避免重複編譯
延展性（extensibility）是 Julia 的重要功能之一，你可以對既有的 function 增加新的 method。有的時候，這些更動會讓 Julia 重新編譯程式碼。Julia 會讓「過期」的程式碼被標記，並且編譯新的程式碼。在 v1.6 版中，標記「過期」的程式碼的方式被改進，變得更為精準，如此可以避免重複編譯的問題。
使用者功能
語法
Types written with where syntax can now be used to define constructors, e.g.
(Foo{T} where T)(x) = ....
增加新的語法 import ... as ...
新增新語法 import A as B，也包含import A: x as y、import A.x as y 和 using A: x as y，可以對載入的模組跟辨識子重新命名。（#1255）
1
2
3
4
5
6
7
julia> import DataFrames as DF

julia> using DataFrames as DF
ERROR: syntax: invalid syntax "using DataFrames as ..."
Stacktrace:
 [1] top-level scope
   @ none:1
注意，using 是不支援 as 的喔！
可以使用 ... 來指定解構的變數
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
julia> a, b... = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> a
1

julia> b
2-element Vector{Int64}:
 2
 3

julia> a, b... = (1,2,3)
(1, 2, 3)

julia> b
(2, 3)

julia> a, b, c... = [1,2,3,4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> c
2-element Vector{Int64}:
 3
 4
陣列與集合
支援 init 關鍵字參數
sum、prod、maximum、minimum，以及 count 現在支援 init 關鍵字參數。（#36188, #35839, #37461）
集合容器支援更多運算子
集合容器現在也支援 ∉(collection)、∋(item)、∌(item) 這些方法。（#38475）
1
2
3
4
5
6
7
8
julia> 1 ∉ [2,3,4]
true

julia> [2,3,4] ∋ 1
false

julia> [2,3,4] ∌ 1
true
新的 NamedTuple 建構子
NamedTuple 有新的建構子，可以用 NamedTuple(iterator) 的方式來支援從 key-value 配對的集合容器中建構 named tuple。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
julia> d = Dict(:a => 1, :b => 2)
Dict{Symbol, Int64} with 2 entries:
  :a => 1
  :b => 2

julia> NamedTuple(d)
(a = 1, b = 2)

julia> a = [:a => 1, :b => 2]
2-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2

julia> NamedTuple(a)
(a = 1, b = 2)
點運算子可以被用於高階函式
1
2
3
4
5
6
7
julia> map(.*, collect(1:5), collect(6:10))
5-element Vector{Int64}:
  6
 14
 24
 36
 50
Range 支援非整數型別
1
2
3
4
5
6
7
8
9
10
11
julia> 1.0:0.1:10.0
1.0:0.1:10.0

julia> typeof(1.0:0.1:10.0)
StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}

julia> 1.0:10.0
1.0:1.0:10.0

julia> typeof(1.0:10.0)
StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}
要指定 x:y 以前都需要是整數型別 <: Integer 才行，現在 LinRange、StepRange 和 StepRangeLen 都支援非整數型別。（#32439）
訊息與呈現
@code_XXX 的格式更新
@code_llvm 及 @code_native 變成彩色的了！
稀疏矩陣的顯示格式更新
稀疏矩陣的顯示變得更直覺了！他自動隱藏非零值。（#33821）
1
2
3
4
5
6
julia> sprand(4, 4, 0.5)
4×4 SparseMatrixCSC{Float64, Int64} with 9 stored entries:
 0.883381  0.990356   ⋅         ⋅ 
 0.344935  0.238646   ⋅        0.218795
 0.583395   ⋅        0.674894   ⋅ 
 0.892346   ⋅         ⋅        0.53169
UUID 用裝置亂數作為亂數產生器
變更 uuid1 和 uuid4 去使用 Random.RandomDevice() 作為預設的亂數產生器。（#35872）
開發者功能
開發
以後不再有 home project 的概念了！執行 julia --project=dir 等同於執行 julia、pkg> activate $dir 以及 julia --project 一系列命令。julia --project 等同於指定了 dir = Base.current_project()。（#36434）
編譯與型別推斷現在可以在模組中被啟用或是關閉，使用 Base.Experimental.@compiler_options 可以達到。（#37041）
二進位檔與函式庫
Pkg.Artifacts 模組目前可以被作為一個獨立的套件（Artifacts）使用，當然 Pkg.Artifacts 也可以。（#37320）
Pkg.BinaryPlatforms 被移動至 Base 成為 Base.BinaryPlatforms。（#37320）
如果要延遲下載 artifacts，LazyArtifacts 一定要被列在相依套件中。（#37844）
測試
@testset 支援新的選項 verbose 來呈現測試結果。（#33755）
效能調校
字串支援 view
現在所有字串（AbstractString）都支援 view 囉！ 也包含 @view 以及 @views，他們會回傳 SubString。（#35879）
1
2
3
4
5
6
7
8
julia> s = "ABCDabcd"
"ABCDabcd"

julia> @view s[2:4]
"BCD"

julia> typeof(@view s[2:4])
SubString{String}
@time 增加編譯時間比例
在執行 @time 時，增加了顯示時間中有多少比例的編譯時間（compile time），@timev 則有更詳盡的資料（#37678）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
julia> A = rand(5, 5)
5×5 Matrix{Float64}:
 0.457416  0.437818   0.562112  0.406917  0.447958
 0.332568  0.947091   0.936427  0.514941  0.692013
 0.590303  0.0198501  0.729961  0.603581  0.333894
 0.380095  0.879258   0.957336  0.640208  0.744337
 0.313589  0.866007   0.207502  0.480253  0.700147

julia> @time A*A
  0.493280 seconds (2.37 M allocations: 127.468 MiB, 7.62% gc time, 97.77% compilation time)
5×5 Matrix{Float64}:
 0.981792  1.3718   1.55993  1.22651  1.31208
 1.4326    2.11323  2.39394  1.85024  1.98484
 1.04164   1.11159  1.53036  1.23779  1.20494
 1.50815   2.22566  2.50318  1.9526   2.09605
 0.956036  1.9902   1.74374  1.3425   1.65672

julia> @time A*A
  0.000007 seconds (1 allocation: 288 bytes)
5×5 Matrix{Float64}:
 0.981792  1.3718   1.55993  1.22651  1.31208
 1.4326    2.11323  2.39394  1.85024  1.98484
 1.04164   1.11159  1.53036  1.23779  1.20494
 1.50815   2.22566  2.50318  1.9526   2.09605
 0.956036  1.9902   1.74374  1.3425   1.65672

julia> @timev A*A
  0.000044 seconds (1 allocation: 288 bytes)
elapsed time (ns): 44371
bytes allocated:   288
pool allocs:       1
5×5 Matrix{Float64}:
 0.981792  1.3718   1.55993  1.22651  1.31208
 1.4326    2.11323  2.39394  1.85024  1.98484
 1.04164   1.11159  1.53036  1.23779  1.20494
 1.50815   2.22566  2.50318  1.9526   2.09605
 0.956036  1.9902   1.74374  1.3425   1.65672
編譯器最佳化的常數傳遞（constant propagation）支援關鍵字參數（keyword arguments）。（#35976）
新功能
新增標準函式庫
在 v1.6 中，新增了兩個標準函式庫：TOML、Downloads。TOML 可以被用來解析 .toml 檔案。Downloads 提供了跨平台、多協定、行程內的下載功能，並使用 libcurl。它取代了原先的 Base.download，並提供 Downloads.download 介面。
陣列與其他集合
新功能 spdiagm([m, n,] v::AbstractVector) 支援由 v 作為對角線來生成稀疏矩陣的對角矩陣，其呼叫 spdiagm([m, n,] 0 => v)，與稠密矩陣的 diagm 有對等的功能。（#37684）
新增 Iterators.map，也新增了 Iterators.map(f, iterators...) 的語法，簡化了 (f(args...) for args in zip(iterators...))。（#34352）
新功能 insorted 來確定一個集合容器中的元素是否是已經排序的。（#37490）
數值計算
現在 isapprox(x,y) 支援 norm 這個關鍵字參數，來計算兩者的範數（norm）是否接近，也支援非陣列的 x 跟 y 參數。（#35883）
新功能 LinearAlgebra.BLAS.get_num_threads() 可以取得 BLAS 的執行緒數量。（#36360）
平行運算
新功能 Base.Threads.foreach(f, channel::Channel) 支援多執行緒的 Channel 消耗。（#34543）
其他
新增 parse(::Type{UUID}, ::AbstractString) 方法。
新支援
陣列與其他集合
現在 append!(vector, collections...) 及 prepend!(vector, collections...) 方法都支援多個集合容器（collections）。（#36227）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
julia> a = rand(10);

julia> b = [rand(10), rand(20)]
2-element Vector{Vector{Float64}}:
 [0.4274732922161779, 0.10937373891763369, 0.5654187553795427, 0.9906034331313402, 0.013972810993100104, 0.9124867642867496, 0.7026800717485269, 0.6919261624138788, 0.6637048817292697, 0.6751652383396913]
 [0.2195233748657055, 0.8611811964575287, 0.5207507597979009, 0.8922624660959817, 0.6598412164100307, 0.5197210219304949, 0.6657337471786067, 0.20595020263413644, 0.9792308729299666, 0.20457512725986682, 0.3964379369245947, 0.9492425568657055, 0.4298200055489003, 0.38595130501514974, 0.9106291942539788, 0.9979619358373388, 0.05452976209666782, 0.7036395889179883, 0.5909806544881551, 0.26667970632080373]

julia> append!(a, b...)
40-element Vector{Float64}:
 0.5841916683652206
 0.054243862919656216
 0.5576101120027053
 0.3870928566144738
 0.1998130659845283
 ...
轉置（adjoint!(::*Triangular)、transpose!(::*Triangular)）一個上（下）三角矩陣 *Triangular 會回傳相反的三角矩陣。套件中含有方法，像是 Adjoint{<:Any,<:LowerTriangular{<:Any,<:OwnMatrixType}} 需要被改為 UpperTriangular{<:Any,<:Adjoint{<:Any,<:OwnMatrixType}}。（#38168）
unique(f, itr; seen=Set{T}()) 現在容許你宣告容器的型別。（#36280）
I/O
redirect_* 函式現在接受 devnull 來拋棄所有輸出的資料，或是作為一個空的輸入來源。（#36146）
redirect_* 函式現在可以呼叫 IOContext 物件。（#36688）
]]>
    
    https://yuehhua.github.io/blog/2021/04/04/julia-v1-6-release/
    
    2021-04-03T17:04:33.000Z
    

      
在 v1.6 版中，Julia 有大幅度的效能提昇，效能提昇的部份著重在於預編譯（precompilation）以及編譯的效能改進，而 v1.6 版將成為下一個長期支援（long-term support, LTS）的版本。
根據官方部落格，本次版本更新引進了眾多新的技術，包含 parallel precompilation、消除重複編譯、降低編譯器的 latency、加速二進位檔案的載入，以及改善 stacktrace 的格式等等重大的功能。那我們就來詳細看看有哪些更新吧！
]]>
    
    
    2026-09-02T04:02:26.116Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      
Julia 作為一個新興的語言，他有眾多的優點，他不僅執行快速，而且像 python 一樣，是動態語言非常容易上手好寫。Julia 本身的套件管理系統也具有足夠高的再現性（reproducible），並且自動安裝內含編譯過的函式庫檔案。作為一個泛用性以及開源的程式語言，這些特色帶來許多優點。
隨著今日科學社群不斷的擴大，科學計算與數值計算相關的軟體也不斷的發展，Julia 作為一個以科學計算為目的的語言，不僅融合了現代的科學計算工具、新穎的演算法、優異的性能，以及平易近人的語法。由於 Julia 優異的語法設計，搭配多重分派以及型別系統，讓獨到的即時編譯（just-in-time compilation）變得自然，型別推斷讓 Julia 的速度得以提升。
現代化
科學計算有長遠的歷史。在歷史悠久的軟體當中很難整合現代的功能，例如 GPU 或 TPU 支援，有的甚至連平行處理都可能沒有。Julia 語言挾著年輕的優勢，在建立微分方程套件時，也整合了 CUDA 的運算。語言的可組合性讓各式各樣的數值計算方法以及模型，可以輕鬆的支援 GPU 以及 TPU 的運算。在同樣的編譯器架構下，相同的原始碼可以被編譯為不同硬體的版本。
優秀的套件管理系統也是近代才有的產物，他可以確保套件的安裝與移除是完整的，並且套件不會有遺失的狀況。Python 的 Anaconda 也是優秀的套件管理系統。Julia 背後支援的 BinaryBuilder.jl，可以整合套件中需要使用到的動態函式庫，以及一些編譯好的執行檔。因此，目前 Julia 的套件，像是 CUDA.jl，所需要的函式庫，例如 CUDA 函式庫，就可以藉由 Julia 的套件管理系統安裝到。使用 CUDA.jl 時，他會自動地而且惰性地（lazy）安裝相對應的 CUDA 函式庫。
機器學習
Python 是目前最大的機器學習語言，他擁有 TensorFlow 以及 PyTorch 兩大深度學習框架，分別由 Google 及 Facebook 維護。然而 Julia 也在深度學習套件上有著不輸 Python 的特色。深度學習框架的一個核心引擎是自動微分，我們訓練模型都需要倒傳遞演算法（backpropagation），倒傳遞演算法計算的則是模型的微分式，面對各式各樣不同的深度學習模型，我們不可能為每一個深度學習模型量身訂製一套他們自己的微分式，所以我們勢必要讓電腦知道怎麼自動推論模型的微分式。Zygote.jl 就是在 Julia 上非常知名的自動微分推論引擎，在開發者積極的開發下，Julia 的自動微分推論引擎已經成爲語言的第一支援，由於語言本身支援的自動微分引擎可以微分任何東西。如此徹底的實現了 LeCun 講的可微分程式設計（differentiable programming）。如此，這樣子的系統在機器學習領域佔有一席之地。
Flux.jl 是在 Julia 上使用 Zygote.jl 作為自動微分引擎的深度學習框架，其中的影像辨識及自然語言處理模型都已經使用這個自動微分引擎自動推論。Flux.jl 是個百分之百純 Julia 寫成的深度學習框架，它支援高階的抽象，以及低階的 API，也就是，要像 Keras 那樣一層一層定義網路架構，或是自己從底層寫起，定義 loss function、定義運算，甚至是梯度或是 normalization 都是可行的。套件裡的函式都可以直接跟語言相容，所以 Flux.jl 讓開發者有非常大的自由度以及彈性可以自由發揮。本身支援 CUDA，但不依賴 CUDA C 函式庫，由 Julia 社群提供的 CUDA 編譯器，可以直接將 Julia 的原始碼編譯為虛擬組合語言並且送至 GPU 執行，所以可以利用 Julia 語言本身的編譯能力最佳化 CUDA 的執行效率。
不只深度學習，在經典的機器學習套件，Julia 有 MLJ 這個由英國的 The Alan Turing Institute 所開發及維護的機器學習套件，目前所支援的模型數在一百五十個以上，足以覆蓋一般商業及工程的應用場景。MLJ 也支援 scikit-learn 套件中的模型在 Julia 使用，
Turing.jl 是 Julia 中支援機率程式設計（probabilistic programming）的知名套件。不只可以自己用機率搭建機器學習模型，還可以訓練機率性深度學習網路，或稱貝氏深度學習（Bayesian deep learning）。目前此套件也跟 Flux 以及 MLJ 整合，可以結合各方所長，打造更加穩固而可信的模型與系統。
資料科學
有了充足的機器學習基礎，資料科學家的得力工具更是不可或缺。
DataFrames.jl 提供了對應於 pandas 的功能，能夠操作表格類（tabular）的資料，並搭配 Statistics 或 StatsBase 提供多樣的統計功能，可以方便地對資料做抽樣、分割、選取欄位，甚至是樞紐分析。如果需要處理時間序列相關的資料，只要搭配 Julia 語言本身的 Dates 及 TimeZones，便可以方便地在 DataFrame 物件中操作時間序列資料。
資料的讀取則由不同的套件負責。CSV.jl 支援 .csv、.tsv 等等相關檔案的讀取，Excel 檔案則由 ExcelFiles.jl 或是 XLSX.jl 負責。不同的讀檔都可以得到 DataFrame 物件，處理完之後儲存成各自的檔案格式中。
Gadfly.jl 支援非常優秀的繪圖功能，不僅有 garmmar of graphics 的語法設計，並且繪圖類似於 R 的 ggplot2。Plots.jl 支援眾多的繪圖引擎後端，包含 GR、plotly、pyplot、UnicodePlots 等等繪圖引擎。可以繪製的圖形種類眾多，搭配上 StatsPlots.jl 或是 GraphPlot.jl，更可以支援 graph 物件的繪製。
CSV.jl 也跟資料庫整合地非常好，有 Tables.jl 作為介面，並且可以將資料流導向 SQLite、MySQL 或是 PostgresQL 等等資料庫系統。如果希望在資料流水線上對資料做處理，TableOperations.jl 可以提供相關的功能，在資料流過時做即時地處理。
微分方程
Julia 也有號稱地表最強大的微分方程套件 DifferentialEquations.jl，支援多種微分方程的計算，包含常微分方程（ordinary differential equations, ODEs）、偏微分方程（partial differential equations, PDEs）、隨機微分方程（Stochastic ordinary differential equations, SDEs）、微分代數方程（Differential algebraic equations, DAEs）等等。同時比較了不同語言的微分方程套件，包含 MATLAB, R, Julia, Python, C, Mathematica, Maple 和 Fortran，Julia 的 DifferentialEquations.jl 有全方位優異的表現。
科學機器學習
由於近年來深度學習及機器學習的興起，Julia 也整合了經典微分方程及深度學習的計算，基於神經微分方程（neural ODE），將所有種類的微分方程以及深度學習模型做了整合，則有了科學機器學習（scientific machine learning, SciML）的新領域。此領域以及相關的套件工具是其他語言社群所沒有的，這同時也彰顯了 Julia 一個非常重要的語言特性：可組合性的威力。
科學機器學習是結合機器學習或深度學習與經典的微分方程的方法。由於目前科學探索還有部分領域，還有未知的部份是尚未可以用微分方程求解的，所以這部分可以先用深度學習或是機器學習模型加以取代，待日後研究更進一步。如此，整合機器學習或是深度學習的科學計算方法，成為了科學機器學習的主軸，並且以神經微分方程為核心出發，攻克各個科學的未知領域。
作業研究及最佳化
JuMP.jl 包含眾多作業研究及最佳化方法的套件，裡頭支援的方法包含一般的線性規劃（linear programming）、混和整數規劃（mixed-integer programming）、二階錐規劃（second-order conic programming）、半定性規劃（semidefinite programming）以及非線性規劃（nonlinear programming）等等。更有 Changhyun Kwon 教授幫這個套件寫書，介紹作業研究這個領域，並且書上的範例為 Julia 程式碼。
Julia 將成為未來科學計算與人工智慧的計算引擎
以上述的科學計算與機器學習套件為基礎，在 Julia 這個可組合性極佳的語言底下，各個套件可以發揮其 1+1 > 2 的能力，不同套件之間可以無縫地整合，不如其他語言的套件之間會有不同的界面或是隔閡存在。在極具彈性的語法跟極佳的效能下，能夠發揮硬體最大的極限。可以想見，Julia 將成為未來科學計算與人工智慧的計算引擎！
除了上述跟學術或是理論相關的套件以外，Julia 也有非常優秀的 MVC 架構的網站框架 – Genie.jl，有 routing 機制，頁面呈現有模板語言（template language），模型與資料庫有物件關係對映（object relational mapping，ORM），可以寫 RESTful API 或是大型網站。在強大的計算模型的基礎之上，也可以提供網頁的應用程式。
目前已經有非常多世界頂尖大學以及研究所在教授 Julia，可以參考官網頁面最底下。在自動控制與最佳化理論領域相當知名的 Stephen Boyd 教授，與 Lieven Vandenberghe 教授，所共同撰寫的 Introduction to Applied Linear Algebra – Vectors, Matrices, and Least Squares，更是將範例程式碼從 MATLAB 轉成 Julia。目前正在從人才端補足 Julia 程式設計師不足的狀態。
目前 Julia 語言已經穩定，而相關套件也正在趨於完善，想必未來能帶給這個世界更加精彩的作品！
]]>
    
    https://yuehhua.github.io/blog/2021/03/28/the-future-of-julialang/
    
    2021-03-28T14:51:51.000Z
    

      
	


Julia 作為一個新興的語言，他有眾多的優點，他不僅執行快速，而且像 python 一樣，是動態語言非常容易上手好寫。Julia 本身的套件管理系統也具有足夠高的再現性（reproducible），並且自動安裝內含編譯過的函式庫檔案。作為一個泛用性以及開源的程式語言，這些特色帶來許多優點。
隨著今日科學社群不斷的擴大，科學計算與數值計算相關的軟體也不斷的發展，Julia 作為一個以科學計算為目的的語言，不僅融合了現代的科學計算工具、新穎的演算法、優異的性能，以及平易近人的語法。由於 Julia 優異的語法設計，搭配多重分派以及型別系統，讓獨到的即時編譯（just-in-time compilation）變得自然，型別推斷讓 Julia 的速度得以提升。
]]>
    
    
    2026-09-02T04:02:26.115Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      對於 Julia 比較不熟悉的使用者或開發者，要怎麼定函式的參數型別是一個大學問。
1
2
3
function average(xs)
    return sum(xs)/length(xs)
end
例如以上的 average 函式，xs 要定成什麼樣的型別比較好？
可能有人會以他所測試的情境去定：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
julia> xs = rand(10)
10-element Array{Float64,1}:
 0.8261912048684596
 0.4466692353358077
 0.6337754306737924
 0.1297961522759261
 0.4699412442087936
 0.6194816490253636
 0.8258926319092839
 0.05094839501664228
 0.21008570113108194
 0.16250331333741275

julia> function average(xs::Array{Float64,1})
           return sum(xs)/length(xs)
       end
average (generic function with 1 method)

julia> average(xs)
0.4375284957782564
這樣當然是沒有錯，但是會過於狹隘。這樣定出來只有一維矩陣可以適用，而且裡頭的元素還必須是 Float64 型別。
思考廣義化
我們能不能讓所有的陣列都適用？那就可以改成這樣：
1
2
3
function average(xs::AbstractArray{Float64})
    return sum(xs)/length(xs)
end
可是這樣又限制了元素的型別，像是 Float32 或是無理數 Irrational 就不適用。
如果我們要將他廣義化到所有的整數跟浮點數都適用，也支援無理數。
那麼我們可以考慮支援實數 Real，可以寫成以下的樣子：
1
2
3
function average(xs::AbstractArray{<:Real})
    return sum(xs)/length(xs)
end
或是也可以考慮將他參數化：
1
2
3
function average(xs::AbstractArray{T}) where {T<:Real}
    return sum(xs)/length(xs)
end
這兩種寫法所編譯出來的 method instance 是一樣的。
這兩種寫法差異在於，如果將他參數化，開發者有機會將參數型別 T 取出來使用。
建議
為了避免大家寫出來的函式太過於狹義，所以在這邊給出一些建議。
如果要支援的型別是所有整數，那麼可以考慮使用 Integer，它可以支援 Bool、Int64、UInt8 之類的型別。
如果要支援的型別是所有的整數以及浮點數等等的，那麼可以考慮使用 Real，它可以支援 Float64、Irrational 等等的型別。
如果還想要支援複數 Complex，那麼就直接使用數字 Number 吧！
思考點
那至於要支援什麼樣的型別以及他的範疇，這是個很好的問題。
那就要問在你的函式當中所用到的函式支援哪些型別？
例如在 average 中有 sum 以及 length 函式。
sum 支援包含 AbstractArray、iterable，甚至是 AbstractRange。
length 則支援所有的陣列 AbstractArray、集合 Set、字典 Dict、所有字串 AbstractString 等等的。
接下來要思考 average 所要提供的功能是什麼？他的語義是什麼？
就字面上的意義而言，他要提供的是「某個集合體的平均」。這時候就可以去定義要支援什麼樣的集合體，以及支援集合體中的元素範疇是什麼。
最後就可以決定這個函式的型別參數應該是什麼了。
自定義型別
如果有人想要自行設計自己的型別，並且這個型別支援 sum 及 length，那理論上，這個型別就自動支援 average。
要讓其他人去自行定義型別，並且自動支援 average，為了避免將這個函式綁得太死，那就乾脆不定義型別。
1
2
3
function average(xs)
    return sum(xs)/length(xs)
end
這樣是可以的。
有沒有發現，與其加一堆型別將函式綁死（加法設計），不如把型別拿掉還來的更好（減法設計）。
]]>
    
    https://yuehhua.github.io/blog/2021/03/19/use-of-numerical-type-in-parametric-functions-in-julia/
    
    2021-03-19T06:21:30.000Z
    

      對於 Julia 比較不熟悉的使用者或開發者，要怎麼定函式的參數型別是一個大學問。

1
2
3
function average(xs)
    return sum(xs)/length(xs)
end

例如以上的 average 函式，xs 要定成什麼樣的型別比較好？
可能有人會以他所測試的情境去定：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
julia> xs = rand(10)
10-element Array{Float64,1}:
 0.8261912048684596
 0.4466692353358077
 0.6337754306737924
 0.1297961522759261
 0.4699412442087936
 0.6194816490253636
 0.8258926319092839
 0.05094839501664228
 0.21008570113108194
 0.16250331333741275

julia> function average(xs::Array{Float64,1})
           return sum(xs)/length(xs)
       end
average (generic function with 1 method)

julia> average(xs)
0.4375284957782564
]]>
    
    
    2021-03-28T05:33:46.442Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      
1
2
3
4
5
6
7
8
9
module Foo

# Some code here

function __init__()
    # Some code here too
end

end
是否曾經疑惑過寫在 module 中的程式碼會在何時被載入呢？
事實上，解答如下囉！
1
2
3
4
5
6
7
8
9
module Foo

println("code here will be printed when you build this module")

function __init__()
    println("code here will be printed when you using this module")
end

end
]]>
    
    https://yuehhua.github.io/blog/2021/01/14/julia-module-code-loading/
    
    2021-01-14T03:50:26.000Z
    

      
1
2
3
4
5
6
7
8
9
module Foo

# Some code here

function __init__()
    # Some code here too
end

end

是否曾經疑惑過寫在 module 中的程式碼會在何時被載入呢？
]]>
    
    
    2021-01-14T03:50:26.514Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      依函式分派（dispatch on function）算是在 Julia 語言中相當常見的一個技巧，它依賴 Julia 的多重分派機制（multiple dispatch），可以依據不同的函式有不一樣的行為。
舉例
在資料分析或是資料庫分析中，常常會需要對資料欄位進行聚合運算，像是加總的 sum、平均的 avg 或是計數的 count。他們都是用同一個欄位的資料，聚合成一個值輸出。當我們需要將資料相加時，我們會寫出以下的程式碼：
1
2
a = [1,2,3,4,5]
sum(a)
這看起來很直觀，但往往在資料庫的設計當中，只會設計一些常用到的聚合函式（aggregate function）。
那麼有沒有一個方式可以得到一個比較廣義的聚合函式呢？
假設我們想要定一個函式叫作 aggregate，其實 sum 就是利用加法（+）來做聚合，所以我們可以寫成這樣：
1
2
3
4
5
6
7
function aggregate(op, data)
    y = data[1]
    for i in 2:length(data)
        y = op(y, data[i])
    end
    y
end
如此一來，下面兩者的結果會一樣。
1
aggregate(+, a) == sum(a)
那如果我們需要一個將所有資料相乘（*）的聚合方式，那我們只需要改寫成以下的方式。
1
aggregate(*, a) == prod(a)
這樣感覺超棒的！
不過這是一般函數式程式設計的寫法，這跟 reduce(*, data) 沒什麼兩樣。
用分派來處理特例
接著，再來實作一個簡單的 aggregate(count, data)，如果你直接呼叫 aggregate(count, a) 是會出錯的。
然而 count 的計算其實是需要重新實作的，所以就不能再走上面的方式了。
要依據參數的不同，執行不同的方法就是多型（polymorphism）的真諦。
1
2
3
4
5
6
7
function aggregate(op::typeof(count), data)
    y = 1
    for i in 2:length(data)
        y += 1
    end
    y
end
或是直接取資料的長度也可以。
1
aggregate(op::typeof(count), data) = length(data)
統計常用函式
這時候如果我們要實作的是一些統計上常用的函式，像是平均、中位數或眾數，就遇到困難了。這邊示範平均的聚合函式，如果像以下的方式寫會發生錯誤：
1
aggregate(mean, a) != mean(a)
因為在這樣的計算之下，它會變成第一項先跟第二項取平均，再跟第三項取平均，再跟第四項取平均，以此類推。
這時候就要將 mean 的實作分開定義。
由於 mean 的行為可以想成是先將資料加總，然後除以資料的數量，所以我們可以計算 aggregate(+, data) 及 aggregate(count, data)，並且將他們兩者相除。
1
2
3
function aggregate(op::typeof(mean), data)
    aggregate(+, data) / aggregate(count, data)
end
如此一來，就可以依據不同的函式名稱來做分派了！
原理
由於在 Julia 中萬物都是物件，即使是函式也如同物件一樣是有型別的，可以取 typeof，而函式 foo 的型別就是 typeof(foo)。
因此，可以將函式 foo 視為實體，函式型別 typeof(foo) 視為型別。
利用一般的多重分派就可以達成 aggregate(op::typeof(mean), data) 囉！
]]>
    
    https://yuehhua.github.io/blog/2021/01/09/dispatch-on-function/
    
    2021-01-09T03:51:45.000Z
    

      依函式分派（dispatch on function）算是在 Julia 語言中相當常見的一個技巧，它依賴 Julia 的多重分派機制（multiple dispatch），可以依據不同的函式有不一樣的行為。

舉例
在資料分析或是資料庫分析中，常常會需要對資料欄位進行聚合運算，像是加總的 sum、平均的 avg 或是計數的 count。他們都是用同一個欄位的資料，聚合成一個值輸出。當我們需要將資料相加時，我們會寫出以下的程式碼：
1
2
a = [1,2,3,4,5]
sum(a)

這看起來很直觀，但往往在資料庫的設計當中，只會設計一些常用到的聚合函式（aggregate function）。
那麼有沒有一個方式可以得到一個比較廣義的聚合函式呢？
]]>
    
    
    2021-01-09T03:52:59.820Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      依型別分派（dispatch on types）算是在 Julia 語言中相當常見的一個技巧，它依賴 Julia 的多重分派機制（multiple dispatch），可以依據不同的型別有不一樣的行為。
依據不同的型別有不同的行為，而不是實體。直觀上看起來會有點像傳統物件導向當中的 class method，不過在 Julia 當中還有更多用途。
Convert
在 Julia 的 Base 中有許多應用到這樣技巧的例子，這邊就舉 convert 為例。
convert 是一個轉換函式，它可以將特定物件轉換成特定的型別，所以物件跟型別就分別是它的參數。
1
convert(Char, 10)
這樣可以將 10 轉換成一個字元的型別，就會變成 '\n'。
1
convert(Array{Float64}, Any[1 2 3; 4 5 6])
或是一個將裝有 Any 型別元素的矩陣，轉成 Float64 型別元素的矩陣。
以上的實作大概會類似：
1
2
3
function convert(T::Type{Char}, val)
    T(val)
end
基本上會試圖呼叫該型別的建構子，而第一個參數上也會加上 Type{...} 的型別。
Read
或是我們也可以在讀取二進制資料當中發現這樣的模式。
1
2
io = IOBuffer("JuliaLang is the best.")
read(io, Char)
在讀取 IOBuffer 的二進制資料當中，可以將資料解析成 Char 的型別。
1
read(io, String)
或是解析成 String 的型別。
在這邊我們看到的都是將型別作為參數給進函式中，函式可以藉由得到的型別做不同的事情。
其中一個目的是依據型別做分派（dispatch），也就是不同的型別會對應到不同的方法實作上。
read(io, Char) 跟 read(io, String) 的實作方式是截然不同的，畢竟要解析成不同的型別，方法會是不同的。
也有可能會像是 convert 一樣，再度利用給進來的參數。由於 Julia 的型別本身也是一個物件，呼叫型別本身也等同於呼叫型別的建構子，所以我們可以看到在 convert(T::Type{Char}, val) 中，呼叫 T 作為建構子的方式來轉換物件的型別。
用在哪裡？
這樣的技術可以被用在哪些場景呢？
通常需要傳型別到其它函式，可以用來呼叫其建構子，而函式則提供一個統一的介面，可以適用於創造物件的場景。
以下就來示範有不同種飲料被製作出來的過程吧！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
abstract type Beverage end

struct MilkTea <: Beverage end
struct GreenTea <: Beverage end
struct BlackTea <: Beverage end

abstract type Topping end

struct TapiocaBall <: Topping end
struct Pudding <: Topping end

struct BubbleMilkTea <: Beverage end
struct PuddingMilkTea <: Beverage end
struct BubbleGreenTea <: Beverage end
struct BubbleBlackTea <: Beverage end
這邊定義了奶茶、綠茶及紅茶幾種飲料，然後還可以對飲料加料，加料之後的飲料就會變成其他種的飲料。
接下來就可以來決定加什麼料會變成什麼樣的飲料。
1
mix(::Type{MilkTea}, ::Type{TapiocaBall}) = BubbleMilkTea()
像是把奶茶跟波霸加在一起，就變成了波霸奶茶。
1
mix(::Type{MilkTea}, ::Type{Pudding}) = PuddingMilkTea()
如果把奶茶跟布丁加在一起就變成布丁奶茶囉~~
1
2
mix(::Type{GreenTea}, ::Type{TapiocaBall}) = BubbleGreenTea()
mix(::Type{BlackTea}, ::Type{TapiocaBall}) = BubbleBlackTea()
我們還有賣波霸綠茶跟波霸紅茶喔！
但是有些組合沒有在菜單上，因為老闆覺得沒有在菜單上的組合喝起來很噁心，所以不打算提供，像是布丁加綠茶這種組合。
1
2
3
4
5
julia> mix(GreenTea, Pudding)
ERROR: MethodError: no method matching mix(::Type{GreenTea}, ::Type{Pudding})
Closest candidates are:
  mix(::Type{MilkTea}, ::Type{Pudding}) at REPL[13]:1
  mix(::Type{GreenTea}, ::Type{TapiocaBall}) at REPL[14]:1
在這邊 mix 就提供了一個統一的介面來混合飲料跟加料的部份。
提供這樣單一的物件創造介面就類似於物件導向中的 factory method pattern。
依參數型別分派（2021.5.24 補充）
如果有個參數化型別 Foo，它帶有一個型別參數 K。
1
julia> struct Foo{K} end
如果有個函式 foo 想依據不同 K 分派，例如，當 K=1 時，可以回傳一個 "BOOM!"，否則就回傳 K 自己。
1
2
3
4
5
julia> foo(::Foo{K}) where K = K
foo (generic function with 1 method)

julia> foo(::Foo{1}) = "BOOM!"
foo (generic function with 2 methods)
這樣會發現我們也可以依據 K 的值分派到不同的函式。
1
2
3
4
5
julia> foo(Foo{1}())
"BOOM!"

julia> foo(Foo{2}())
2
總結
我們可以發現到使用多重分派所帶來的一些好處。如果是在單一分派（single dispatch），也就是一般物件導向的語言中，他只能依據第一個參數做分派。然而，多重分派就可以考慮參數型別的排列組合去做分派，當然參數是型別也是可行的。
類似這樣的機制，也可以對應到在物件導向中的 strategy pattern，strategy pattern 是根據不同的演算法種類來做分派的，我們可以寫成像這樣：
1
2
sort(BubbleSort, xs)
sort(Heapsort, xs)
如此一來，就是一個完整的 strategy pattern 了。
最後，這邊介紹了如何利用多重分派的機制，來依據不同的型別做分派，並且做到不同的應用。
]]>
    
    https://yuehhua.github.io/blog/2021/01/07/dispatch-on-types/
    
    2021-01-07T15:43:49.000Z
    

      依型別分派（dispatch on types）算是在 Julia 語言中相當常見的一個技巧，它依賴 Julia 的多重分派機制（multiple dispatch），可以依據不同的型別有不一樣的行為。

依據不同的型別有不同的行為，而不是實體。直觀上看起來會有點像傳統物件導向當中的 class method，不過在 Julia 當中還有更多用途。
]]>
    
    
    2021-05-24T15:13:56.572Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      
1
2
using Random
Random.default_rng()
Ref. How to get the current “random” seed?
]]>
    
    https://yuehhua.github.io/blog/2020/11/09/get-random-seed-in-julia/
    
    2020-11-09T15:52:17.000Z
    

      ]]>
    2020-11-09T15:54:19.011Z
    
      Yueh-Hua Tu
    
    
    
    
    
      安裝 Julia
首先先確保電腦上已經有安裝 Julia 語言，沒有安裝的話可以到官網下載安裝。
設定環境變數
在 Windows 環境下要將 Julia 的執行檔位置設定到環境變數 PATH 下，可以參考這邊。一般執行檔的路徑會在 C:\Users\你的使用者帳號\AppData\Local\Programs\Julia 1.5.2\bin 下。
我自己是 Linux 系統，所以我會建立一個捷徑到 /usr/bin 下。
1
2

    
    
  
  
1
ln -s /opt/julia-1.5.2/bin/julia /usr/bin/
在 VS code 上安裝 extensions
正式進到安裝 VS code extensions 的環節了。主要要安裝的是這個 Julia language support。
然後這個 Markdown Julia 可以幫你在 Julia 程式碼含有 markdown 的地方標色。
Julia Formatter 可以幫你的程式碼變整齊漂亮。
裝完之後應該是可以用了。
]]>
    
    https://yuehhua.github.io/blog/2020/10/31/vscode-with-julia/
    
    2020-10-31T14:52:57.000Z
    

      安裝 Julia
首先先確保電腦上已經有安裝 Julia 語言，沒有安裝的話可以到官網下載安裝。
]]>
    
    
    2026-09-02T04:02:26.112Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      基本上在 Julia 上跑多執行緒不太困難，在環境中先設定好執行緒的數量，或是在執行 Julia 時增加執行緒數目。
1
julia --threads 4
如果既有的程式碼是 for 迴圈，基本上不難改。
1
2
3
Threads.@threads for i = 1:1000_000
    do something()
end
但是終究會遇到要存取同一個物件的時候，這個時候就會有 race condition。
要避免 race condition 的方式就是使用 lock。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
results = []
splock = Threads.SpinLock()

Threads.@threads for i = 1:1000_000
    y = do_something()

    lock(splock)
    try
        push!(results, y)
    finally
        unlock(splock)
    end
end

在迴圈中計算 do_something，我們想要把計算結果儲存下來，我們將他儲存在 results 中。
這時候我們必須用一個 lock 來把要存取的資源鎖住，一開始會產生一個 SpinLock，當程式執行到 lock(splock) 的時候，如果這個 lock 可以被取用，那這個執行緒就會拿這個 lock 並且進到後續的程式區塊中。如果前面有人拿了 lock，那目前這個想拿 lock 的執行緒就得等到 lock 被釋放才可以。
當程式執行完，unlock(splock) 會將 lock 給釋放掉，這個時候其他的執行緒就可以拿這個 lock 進到程式區塊中。
如此可以保證每次操作 results 物件的只能有一個執行緒，可以避免 race condition。
]]>
    
    https://yuehhua.github.io/blog/2020/10/19/use-threads-lock-in-julia/
    
    2020-10-19T02:27:25.000Z
    

      基本上在 Julia 上跑多執行緒不太困難，在環境中先設定好執行緒的數量，或是在執行 Julia 時增加執行緒數目。

1
julia --threads 4
]]>
    
    
    2020-10-19T02:34:12.711Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      在 Julia 中存取物件的欄位的時候，設計者會想要對於存取的過程中加上一些檢查，這個想法是來自於傳統物件導向 getter/setter 的概念。
例如，在自己設計的物件當中有兩個矩陣，這兩個矩陣可以讓使用者隨意更新，但是需要保證這兩個矩陣的維度是一致的。這個時候就需要在使用者更新矩陣的時候加入檢查，以確保兩個矩陣之間的維度是一致的，如果檢查不通過，可能會跳例外或者是不讓矩陣被更新。
那如果要在 Julia 中，存取物件時加入檢查的程式碼，要怎麼辦呢？
Julia 提供了兩個 setter 來提供設定物件的欄位：setproperty! 跟 setfield!
setfield! 是屬於內部的 API，這個不能覆寫，所以我們要用的是 setproperty!。
setproperty! 的 API 可以藉由查詢文件得知：
1
setproperty!(value, name::Symbol, x)
也就是當你在呼叫 a.b = c 其實就會去呼叫 setproperty!(a, :b, c)。
依據上述的例子，我們可以示範以下程式碼：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
mutable struct Foo
    A::Matrix
    B::Matrix
end

function setproperty!(obj::Foo, name::Symbol, x)
    if name == :A
        if size(obj.B) == size(x)
            setfield!(obj, name, x)
        else
            throw(DimensionMismatch())
        end
    elseif name == :B
        if size(obj.A) == size(x)
            setfield!(obj, name, x)
        else
            throw(DimensionMismatch())
        end
    else
        setfield!(obj, name, x)
    end
end
這邊有幾點需要特別注意，第一是語言中的 setproperty! 第一個參數是 Any 型別，所以第一個參數一定要指定自己的型別是什麼，不然會跟語言本身的衝突。
第二個參數吃進來的是 Symbol 型別，這個也要指定，不然會發生 ambiguous 的狀況。
第三個參數為了廣義，所以是 Any 型別。
函式裡頭要區分開不同的欄位，這邊用 if-else 處理。想要用多重分派的機制處理的也是可以，但會比較麻煩，而且用到 Val() 會有效能降低的現象。
通過檢查後，要真正設定物件欄位，這邊用 setfield!(obj, name, x) 是比較好的作法。如果呼叫 obj.A = x，則會去呼叫 setproperty!(obj, :A, x)，就會變成無限遞迴呼叫了，所以 = 跟 setproperty! 在這邊都沒辦法用。
最後，我們把要檢查的欄位都處理好之後，我們不想要動到其他的欄位設定的行為，那就讓其他的欄位都用 setfield!(obj, name, x) 處理掉吧！
]]>
    
    https://yuehhua.github.io/blog/2020/10/12/julia-setproperty-setfield/
    
    2020-10-12T03:50:07.000Z
    

      在 Julia 中存取物件的欄位的時候，設計者會想要對於存取的過程中加上一些檢查，這個想法是來自於傳統物件導向 getter/setter 的概念。

例如，在自己設計的物件當中有兩個矩陣，這兩個矩陣可以讓使用者隨意更新，但是需要保證這兩個矩陣的維度是一致的。這個時候就需要在使用者更新矩陣的時候加入檢查，以確保兩個矩陣之間的維度是一致的，如果檢查不通過，可能會跳例外或者是不讓矩陣被更新。
]]>
    
    
    2020-10-12T03:52:42.354Z
  
  
    
      Yueh-Hua Tu
    
    
    
      Maximum likelihood estimation is an essential approach to estimate parameters in statistics. It requires statistical assumptions on error pattern. I will introduce this technique with really simple statistical model - linear regression.
We usually want to infer the relationship between input and output. They can be cause and effect of a physical phenomena or some indirect relationship in social science. We always want to realize the truth about our interest. Statistical tools are the tools to help you. The relationship between input and output are formulated as a mathematical function as follow:
$$
y = f(x)
$$
A linear model is assumed in linear regression. The relationship between $x$ and $y$ is assumed to be linear and $w$ and $b$ are introduced as unknown parameters into the model. $w$ denotes the extent of $x$ contributing to $y$ while $b$ denotes an inherent bias in $y$.
$$
y = wx + b
$$
On the other side, data are collected in pair of $(x^i, y^i)$. The superscript $n$ denotes the index for each sample.
$$
\mathcal{D} = {(x^1, y^1), (x^2, y^2), \cdots, (x^n, y^n)}
$$
The maximum likelihood estimation starts from the likelihood function. A likelihood function quantified the likelihood of data generation from the model we specified. That is, how likely the sample $(x_i, y_i)$ are generated from the model. All parameters are reduced into $\theta$. Precisely, $\mathcal{L}(\theta \mid \mathcal{D})$ represents the likelihood of model with parameter $\theta$ given data $\mathcal{D}$. Notably, data is fixed here. Thus, we want the most likely model that fits our samples. The model with maximum likelihood is estimated.
$$
\begin{aligned}
\mathcal{L}(\theta \mid \mathcal{D}) &= f(\mathcal{D} \mid \theta) \\
&= p((x^1, y^1), (x^2, y^2), \cdots, (x^n, y^n) \mid \theta)
\end{aligned}
$$
A probability distribution is used to estimate the likelihood of model $\theta$. The interpretation here is the probability of data generation from the model $\theta$.
$$
\begin{aligned}
\mathcal{L}(\theta \mid \mathcal{D}) &= p((x^1, y^1), (x^2, y^2), \cdots, (x^n, y^n) \mid \theta) \\
&= p((x^1, y^1) \mid \theta) \cdot p((x^2, y^2) \mid \theta) \cdots p((x^n, y^n) \mid \theta)
\end{aligned}
$$
It is formed from the joint probability distributions. A critical statistical assumption is introduced here. Samples $(x^i, y^i)$ are generated independently such that the joint probability can be split into multiplication of probabilities. Further, samples are generated from the same population/model $\theta$. So, we call that data are independently, identically distributed, or iid, generated from some model.
$$
\begin{aligned}
\mathcal{L}(\theta \mid \mathcal{D}) &= p((x^1, y^1) \mid \theta) \cdot p((x^2, y^2) \mid \theta) \cdots p((x^n, y^n) \mid \theta) \\
&= \prod_{i=1}^n p((x^i, y^i) \mid \theta)
\end{aligned}
$$
Normal distribution is used as error pattern in linear regression model. A linear regression model always infers the mean value of $y$ given $x$. The uncertainty of $y$ can be described by normal distribution. We add an error term after the linear regression model.
$$
y = wx + b + \epsilon
$$
$$
\epsilon = y - wx - b = \mathcal{N}(z \mid \mu = 0, \sigma^2)
$$
Or we can rewrite it into
$$
\epsilon = \mathcal{N}(y - wx - b \mid \mu = 0, \sigma^2)
$$
where $\mathcal{N}(x \mid \mu, \sigma^2) = \frac{1}{\sigma \sqrt{2 \pi}} exp(-\frac{1}{2} (\frac{x-\mu}{\sigma})^2)$.
Likelihood function would be
$$
\begin{aligned}
\mathcal{L}(\theta \mid \mathcal{D}) &= \prod_{i=1}^n p((x^i, y^i) \mid \theta) \\
&= \prod_{i=1}^n \mathcal{N}(y^i - wx^i - b \mid \mu = 0, \sigma^2)
\end{aligned}
$$.
Negative log likelihood would be
$$
\begin{aligned}
\mathcal{l}(\theta \mid \mathcal{D}) &= - ln \mathcal{L}(\theta \mid \mathcal{D}) \\
&= - ln \prod_{i=1}^n \mathcal{N}(y^i - wx^i - b \mid \mu = 0, \sigma^2) \\
&= - \sum_{i=1}^n ln \mathcal{N}(y^i - wx^i - b \mid \mu = 0, \sigma^2) \\
&= - \sum_{i=1}^n - \frac{1}{2} (\frac{y^i - wx^i - b - 0}{\sigma})^2 - ln(\sigma \sqrt{2 \pi}) \\
&= \sum_{i=1}^n \frac{1}{2} (\frac{y^i - wx^i - b}{\sigma})^2 + ln(\sigma) + ln(\sqrt{2 \pi})
\end{aligned}
$$
The primal goal is to maximize likelihood function $\arg\max_{\theta} \mathcal{L}(\theta \mid \mathcal{D})$, while we have to minimize the negative log likelihood (NLL) function
$$
\arg\min_{\theta} \mathcal{l}(\theta \mid \mathcal{D})
$$.
To solve this problem, we need to calculate the first-order derivative of NLL. The minimum value happens while $\frac{\partial \mathcal{l}}{\partial w} = 0$ and $\frac{\partial \mathcal{l}}{\partial b} = 0$ are satisfied.
$$
\begin{aligned}
\frac{\partial \mathcal{l}}{\partial w} &= \frac{\partial}{\partial w} \sum_{i=1}^n \frac{1}{2} (\frac{y^i - wx^i - b}{\sigma})^2 + ln(\sigma) + ln(\sqrt{2 \pi}) \\
&= \sum_{i=1}^n \frac{y^i - wx^i - b}{\sigma} \cdot \frac{\partial}{\partial w} \frac{y^i - wx^i - b}{\sigma} \\
&= \sum_{i=1}^n \frac{y^i - wx^i - b}{\sigma} \frac{-x^i}{\sigma} \\
&= \frac{-1}{\sigma^2} \sum_{i=1}^n x^i (y^i - wx^i - b) \\
&= 0
\end{aligned}
$$
$$
\begin{aligned}
\frac{-1}{\sigma^2} \sum_{i=1}^n x^i (y^i - wx^i - b) &= 0 \\
\sum_{i=1}^n x^i (y^i - wx^i - b) &= 0 \\
\sum_{i=1}^n{x^i y^i} - w \sum_{i=1}^n{(x^i)^2} - b \sum_{i=1}^n{x^i} &= 0
\end{aligned}
$$
The same way we can have
$$
\sum_{i=1}^n{y^i} - w \sum_{i=1}^n{x^i} - b = 0
$$
derived from $\frac{\partial \mathcal{l}}{\partial b} = 0$.
Finally, we can estimate the parameters from the following two equations:
$$
\begin{cases}
(\sum_{i=1}^n{(x^i)^2}) w + (\sum_{i=1}^n{x^i}) b = \sum_{i=1}^n{x^i y^i} \\
(\sum_{i=1}^n{x^i}) w + b = \sum_{i=1}^n{y^i}
\end{cases}
$$
$$
\begin{cases}
w = ? \\
b = ?
\end{cases}
$$
]]>
    
    https://yuehhua.github.io/blog/2020/10/12/linear-regression-with-mle/
    
    2020-10-11T17:20:57.000Z
    

      Maximum likelihood estimation is an essential approach to estimate parameters in statistics. It requires statistical assumptions on error pattern. I will introduce this technique with really simple statistical model - linear regression.
]]>
    
    
    2020-10-12T08:39:03.657Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
      這幾年，隨著接觸的東西變多，知道的東西變多，個性上也有點變化。
約莫四五年前，碩班時期接觸到一些很棒的網路技術文章，當時線上課程也非常熱門，很多優秀的大學紛紛把他們的上課內容做成教材釋出。也因為這樣，我自己其實從這些網路資源受惠非常多。當時也是自己在發展自學能力的輝煌時期。
也因為接觸開源文化，所以對於「分享」很有憧憬。覺得能夠分享自己的經驗的人很厲害，除了自己有些東西可以告訴別人，也有這個意願跟熱忱可以將自己所學回饋給社會的感覺。
後來畢業之後在研發替代役的過程中，一邊練習自己的溝通跟演講技術，一邊弄社群跟開一些小型的短期課程，還成為工研院的機器學習講師。過程當中也很開心可以真正可以把自己身上的東西跟大家分享，有的學員是私下來問我的看法或是建議。
漸漸地，隨著接觸的東西跟知道的東西變多，會開始知道有些作法或是想法上是有瑕疵或是問題的。一部份也是受到研替時的老闆的影響，老闆是個急性子，也不斷感受到壓力，久了之後心中也對有問題的方法莫名升起一種煩躁感。
煩躁感的出現，加上有能力表達，也有足夠的知識，變得開始會對身邊的人給建議。
有可能是談話中朋友表達他的某個想法，我會脫口而出這樣的想法背後可能會有什麼潛在的問題，抑或是我覺得這樣的想法好不好。話題範圍從我的專業領域到日常的電視廣告，只要是我有求證過或是我知道的，很多都會直接給出分析的結果。
目前正在博士的訓練路途上，博士的訓練是希望有獨立的分析跟研究能力，所以這樣能夠有批判性思考是很重要的能力。
這樣的分析似乎會困擾我身邊的人，畢竟不是每個人都需要「被建議」，他們或許覺得自己的作法很好，不然就是他就是想要這樣做。雖然我不太介意他是否會採納我的建議，但就是會講出口。有些時候講出口的剎那，對方會有種被否定或是攻擊的感覺，無論我的語氣是用「我覺得」或是「我建議」這種比較不強烈的。
大多數時候我是覺得我在發表自己的意見，對方也可以有自己的意見，我覺得這樣很公平。不過這些意見有時候是衝突，甚至相反的，有些人就會覺得被否定。的確，被否定的感覺很難受，意見被否定乃至於延伸到人格被否定，有些人是會失去自信的。
很多文章跟書本都告訴人不要主動給建議，建議只有當別人問的時候才給。或許該學著睜一隻眼閉一隻眼，即便是身邊再親的人也不要輕易給建議。
事情搞砸就是他的事，與我無關。
]]>
    
    https://yuehhua.github.io/blog/2020/10/12/from-sharing-to-suggestions/
    
    2020-10-11T16:29:36.000Z
    

      這幾年，隨著接觸的東西變多，知道的東西變多，個性上也有點變化。

約莫四五年前，碩班時期接觸到一些很棒的網路技術文章，當時線上課程也非常熱門，很多優秀的大學紛紛把他們的上課內容做成教材釋出。也因為這樣，我自己其實從這些網路資源受惠非常多。當時也是自己在發展自學能力的輝煌時期。
]]>
    
    
    2020-10-11T16:34:30.496Z
  
  
    
      Yueh-Hua Tu
    
    
    
    
    
      這個問題在官方文件中並沒有詳細記載，所以覺得值得紀錄一下。
查閱 @async 的文件會講說，他會用一個 Task 把後面的表達式包裝起來，並且將他掛到排程器的佇列（queue）中。意思就是將表達式包裝成一個任務，並放到佇列中等待 CPU 核心的資源來執行他。
然而通常會搭配 @sync 來使用，@sync 的文件中提到，他會等到後面的 @async、@spawn、@spawnat 及 @distributed 都執行完畢。
使用情境比較像是（修改自這篇 stackoverflow）
1
2
3
@sync for (idx, pid) in enumerate(workers())
    @async a[idx] = remotecall_fetch(do_something, pid, 2)
end
@sync 會等待這個 block 中的 @async 都執行結束才結束，@async 可以讓你指派一些非同步處理的任務，像是多執行緒或是多行程的平行運算。
@sync 就比較像 python 當中的 join()。
]]>
    
    https://yuehhua.github.io/blog/2020/09/06/how-to-use-async-sync-in-julia/
    
    2020-09-06T09:43:04.000Z
    

      這個問題在官方文件中並沒有詳細記載，所以覺得值得紀錄一下。

查閱 @async 的文件會講說，他會用一個 Task 把後面的表達式包裝起來，並且將他掛到排程器的佇列（queue）中。意思就是將表達式包裝成一個任務，並放到佇列中等待 CPU 核心的資源來執行他。
]]>
    
    
    2020-10-11T16:36:42.590Z
  
  
    
      Yueh-Hua Tu
    
    
      之前在 Linux 上測試麥克風，發現錄製的時候總會把背景雜訊給錄進去，會在有人講話的同時聽到雜音。
我用的是 OBS 來做桌面錄製，所以自然想用 OBS 來做音訊的降噪。在 OBS 裡有噪音閥及噪音抑制，似乎噪音閥的效果比較明顯，但是講話聲音背後仍有雜音。
這時候在網路上找了一下，發現可以用系統 pulseaudio 的驅動來做降噪，只是要特別設定開啟，預設是不會開啟的。試了之後效果超好，在這邊紀錄一下。
步驟
首先，編輯以下檔案
1
sudo nano /etc/pulse/default.pa
把以下這行加到檔案中，建議可以加到有個 Echo Cancellation 的地方：
load-module module-echo-cancel
重載 PulseAudio (pulseaudio -k) 就可以囉！
Ref: https://askubuntu.com/questions/18958/realtime-noise-removal-with-pulseaudio
]]>
    
    https://yuehhua.github.io/blog/2020/09/06/linux-system-noise-cancellation/
    
    2020-09-06T09:22:33.000Z
    

      之前在 Linux 上測試麥克風，發現錄製的時候總會把背景雜訊給錄進去，會在有人講話的同時聽到雜音。

我用的是 OBS 來做桌面錄製，所以自然想用 OBS 來做音訊的降噪。在 OBS 裡有噪音閥及噪音抑制，似乎噪音閥的效果比較明顯，但是講話聲音背後仍有雜音。<]]>
    
    
    2020-09-06T09:23:17.999Z