JuliaとScilabの違い

しばらくScilabユーザーだったが, 最近Juliaに乗り換えた.
結構似ている部分が多いけど, 簿妙に違う部分もあるので, そのメモ.

# 配列
## 配列の型
Scilabでは, 配列の型は1つしかない.
Juliaでは, 縦ベクトルに対応する配列だけ, 他の配列と区別される (行列の掛け算などの挙動は同じ).

```lang:Scilab
-->x=[1,2,3,4,5]
 x  =
 
    1.    2.    3.    4.    5.  
 
-->y=[1;2;3;4;5]
 y  =
 
    1.  
    2.  
    3.  
    4.  
    5.  
```

```lang:Julia
julia> x=[1,2,3,4,5]      
5-element Array{Int64,1}: 
 1
 2
 3
 4
 5
                          
julia> y=[1;2;3;4;5]      
5-element Array{Int64,1}: 
 1
 2
 3
 4
 5
```

Juliaの場合は**カンマを使っても縦ベクトルになる**という点に注意.

なお, 次に注意.

```lang:Julia
julia> z1=[1,2,3]
3-element Array{Int64,1}:
 1
 2
 3

julia> z2=z1'
1x3 Array{Int64,2}:
 1  2  3

julia> z3=z2'
3x1 Array{Int64,2}:
 1
 2
 3

julia> size(z1)
(3,)

julia> size(z2)
(1,3)

julia> size(z3)
(3,1)
```

## 行列の生成
要素を横に並べるときの区切りは, Scilabではカンマ, Juliaではスペース.
縦に並べるときはどちらもセミコロン.

```lang:Scilab
-->A=[1,2,3;4,5,6]
 A  =
 
    1.    2.    3.  
    4.    5.    6. 
```

```lang:Julia
julia> A=[1 2 3;4 5 6]
2x3 Array{Int64,2}:
 1  2  3
 4  5  6
```

## 要素の参照
配列の要素を参照するときは, Scilabでは``()``, Juliaでは``[]``.

```lang:Scilab
-->A(1,2)
 ans  =
 
    2.
```

```lang:Julia
julia> A[1,2]
2
```

## 配列の末尾
配列の末尾の参照するときに用いる記号は, Scilabでは``$``, Juliaでは``end``.

```lang:Scilab
-->x=1:5
 x  =
 
    1.    2.    3.    4.    5.  
 
-->x($)
 ans  =
 
    5. 
```

```lang:Julia
julia> x=1:5 
1:5          
             
julia> x[end]
5            
```


## linspace関数
linspace関数の返り値は, Scilabでは横ベクトル, Juliaでは縦ベクトル.

```lang:Scilab
-->x=linspace(0,1,5)
 x  =
 
    0.    0.25    0.5    0.75    1.  
 
-->size(x)
 ans  =
 
    1.    5.  
```

```lang:Julia
julia> x=linspace(0,1,5)
linspace(0.0,1.0,5)

julia> size(x)
(5,)
```

Juliaにはlinspace型というのがある?

## rand, ones, zeros関数
引数を1つだけ入れた時の挙動が異なる.

```lang:Scilab
-->ones(3)
 ans  =
 
    1.
```

``` lang:Julia
julia> ones(3)
3-element Array{Float64,1}:
 1.0
 1.0
 1.0
```

Scilabでは引数3は配列[3]だとみなされる.
一方, Juliaでは引数3は「長さ3のベクトル」という意味になる.


# 文字列
## 文字列の結合
結合に使う演算子は, Scilabでは``+``, Juliaでは``*``.

```lang:Scilab
-->s="pine"
 s  =
 
 pine   
 
-->t="apple"
 t  =
 
 apple   
 
-->s+t
 ans  =
 
 pineapple   
```

```lang:Julia
julia> s="pine"
"pine"

julia> t="apple"
"apple"

julia> s*t
"pineapple"
```


# 関数
## 複数の返り値がある関数
複数の返り値に名前をつけるとき, Scilabでは``[]``, Juliaでは``()``を用いる.

```lang:Scilab
-->A=[1,2,3;4,5,6]
 A  =
 
    1.    2.    3.  
    4.    5.    6.  
 
-->[m,n]=size(A)
 n  =
 
    3.  
 m  =
 
    2. 
```

```lang:Julia
julia> A=[1 2 3;4 5 6]
2x3 Array{Int64,2}:   
 1  2  3              
 4  5  6              
                      
julia> (m,n)=size(A)  
(2,3)                 
```

なお, Juliaにおいて, ``()``で囲まれた組を**タプル型**と呼ぶ.

## ユーザー定義関数
返り値については, 

- Scilabでは関数定義の最初に返り値を宣言する.
- Juliaでは最後に``return``を用いて返り値を宣言する.

``function``を閉じるときは, Scilabでは``endfunction``, Juliaでは``end``を用いる.


```lang:Scilab
function [v,M]=test(N)
    v=1:N
    M=ones(N,N)
endfunction
```

```lang:Julia
function test(N)
    v=1:N
    M=ones(N,N)
    return (v,M)
end
```

なお, Scilabにも[return](https://help.scilab.org/docs/5.5.2/en_US/return.html)という関数 (および等価な[resume](https://help.scilab.org/docs/5.5.1/ja_JP/resume.html)関数) があるが, 非推奨とされている.


# その他
## 円周率など
Scilabでは``%``をつけて``%pi``などとするが, Juliaではそのまま``pi``とする.

```lang:Scilab
-->[%pi,%e,%i]
 ans  =
 
    3.1415927    2.7182818    i    
 
-->[%T,%F]
 ans  =
 
  T F  
 
-->[%inf,%nan]
 ans  =
 
    Inf    Nan
```

```lang:Julia
julia> [pi,e]              
2-element Array{Float64,1}:
 3.14159                   
 2.71828                   
                           
julia> im                  
im                         
                           
julia> [true,false]        
2-element Array{Bool,1}:   
  true                     
 false                     
                           
julia> [Inf,NaN]           
2-element Array{Float64,1}:
 Inf                       
 NaN                       
```

## 複素数の取り扱い
$\sqrt{-1}$ や $\arcsin(2)$ などを計算するとき, Scilabでは勝手に複素数型に拡張されるが, Juliaでは``sqrt(complex(-1))``などと明記しないといけない.

```lang:Scilab
-->sqrt(-1)
 ans  =
 
    i    
 
-->asin(2)
 ans  =
 
    1.5707963 - 1.3169579i
```

```lang:Julia
julia> sqrt(-1)
ERROR: DomainError:
sqrt will only return a complex result if called with a complex argument. Try sqrt(complex(x)).
 in sqrt at math.jl:146

julia> asin(2)
ERROR: DomainError:
 in asin at math.jl:139

julia> sqrt(complex(-1))
0.0 + 1.0im

julia> asin(complex(2))
1.5707963267948966 + 1.3169578969248166im
```

##対角行列の生成
Scilabでは``diag``, Juliaでは``diagm``.

```lang:Scilab
-->v=1:4
 v  =
 
    1.    2.    3.    4.  
 
-->M=diag(v)
 M  =
 
    1.    0.    0.    0.  
    0.    2.    0.    0.  
    0.    0.    3.    0.  
    0.    0.    0.    4.  
```

```lang:Julia
julia> v=1:4       
1:4                
                   
julia> M=diagm(v)  
4x4 Array{Int64,2}:
 1  0  0  0        
 0  2  0  0        
 0  0  3  0        
 0  0  0  4        
```

## 変数の表示
Scilabでは``disp``, Juliaでは``println``.

```lang:Scilab
-->x=1
 x  =
 
    1.  
 
-->disp(x)
 
    1.
```

```lang:Julia
julia> x=1       
1                
                 
julia> println(x)
1                
```

## ファイルの読み込み
プログラムを書いたファイルを読み込むときは, Scilabでは``exec``, Juliaでは``include``.

```lang:Scilab
-->exec("test.sce");
```

```lang:Julia
julia> include("test.jl")
```

## 小数の指数表示
$1.0 \cdot 10^{-5}$ のような表示をするとき, Scilabでは``D``を, Juliaでは``e``を使う.

```lang:Scilab
-->1.0D-5
 ans  =
 
    0.00001
```

```lang:Julia
julia> 1.0e-5
1.0e-5
```


今後も気づいたら追記予定.