Noteworthy Differences from other Languages

Noteworthy differences from MATLAB

MATLABユーザーにはJuliaの構文がなじみ深く感じられるかもしれませんが、JuliaはMATLABのクローンではありません。構文にも機能にも大きな違いがあります。MATLABに慣れたJuliaユーザーが戸惑う可能性のある主な違いを以下に示します。

  • Juliaの配列は角括弧でインデックス指定します。A[i,j]。

  • Juliaでは、配列を別の変数に代入してもコピーされません。A = Bの後にBの要素を変更すると、Aも変更されます。これを避けるには、A = copy(B)を使います。

  • Juliaでは、関数に値を渡してもコピーされません。関数が配列を変更すると、その変更は呼び出し元からも見えます。

  • Juliaでは、代入文によって配列が自動的に拡張されることはありません。MATLABではa(4) = 3.2で配列a = [0 0 0 3.2]を作成し、a(5) = 7でa = [0 0 0 3.2 7]に拡張できます。一方、Juliaで対応するa[5] = 7を実行すると、aの長さが5未満の場合、またはこの文が識別子aの初回使用である場合にエラーになります。Juliaにはpush!とappend!があり、MATLABのa(end+1) = valよりも効率よくVectorを拡張できます。

  • 虚数単位sqrt(-1)は、Juliaではimで表します。MATLABのようにiやjとはしません。

  • Juliaでは、小数点のない数値リテラル(たとえば42)は浮動小数点数ではなく整数になります。そのため、浮動小数点数を想定する演算の中には、定義域エラーを投げるものがあります。たとえばjulia> a = -1; 2^aは、結果が整数ではないため定義域エラーになります(詳しくはthe FAQ entry on domain errorsを参照)。

  • Juliaでは、複数の値はタプルとして返され、タプルに代入されます。たとえば(a, b) = (1, 2)やa, b = 1, 2のように書きます。返り値の数に応じて任意の処理を行うためにMATLABでよく使われるnargoutは、Juliaにはありません。同様の機能は、オプション引数やキーワード引数で実現できます。

  • Juliaには真の1次元配列があります。列ベクトルのサイズはNであり、Nx1ではありません。たとえばrand(N)は1次元配列を作成します。

  • Juliaでは、[x,y,z]は常に、x、y、zを含む3要素の配列を作成します。

    • 第1(「垂直」)次元に連結するには、vcat(x,y,z)を使うか、セミコロンで区切ります([x; y; z])。
    • 第2(「水平」)次元に連結するには、hcat(x,y,z)を使うか、空白で区切ります([x y z])。
    • ブロック行列(第1・第2次元への連結)を作るには、hvcatを使うか、空白とセミコロンを組み合わせます([a b; c d])。
  • Juliaでは、a:bとa:b:cはAbstractRangeオブジェクトを作成します。MATLABのような通常のベクトルを作るには、collect(a:b)を使います。ただし、一般にはcollectを呼び出す必要はありません。AbstractRangeオブジェクトは多くの場合、通常の配列と同じように使えますが、値を遅延計算するため、より効率的です。完全な配列ではなく、こうした特殊なオブジェクトを作るパターンはよく使われており、rangeなどの関数や、enumerate、zipなどのイテレーターにも見られます。これらの特殊なオブジェクトの多くは、通常の配列と同じように使えます。

  • Juliaの関数は、関数定義で返す変数名を列挙するのではなく、最後の式の値、またはreturnキーワードで値を返します(詳しくはThe return Keywordを参照)。

  • Juliaのスクリプトには任意の数の関数を含められ、ファイルを読み込むとすべての定義が外部から参照可能になります。現在の作業ディレクトリ外にあるファイルからも関数定義を読み込めます。

  • Juliaでは、sum、prod、maximumなどの縮約関数は、sum(A)のように引数を1つだけ指定すると、Aが多次元配列であっても、配列のすべての要素に対して処理を行います。

  • Juliaでは、引数が0個の関数を呼び出す場合も、rand()のように括弧が必要です。

  • Juliaでは、文末のセミコロンの使用は推奨されません。文の結果は自動的には表示されず(対話プロンプトを除く)、コード行をセミコロンで終える必要もありません。特定の出力を表示するには、printlnまたは@printfを使います。

  • Juliaでは、AとBが配列の場合、A == Bのような論理比較演算は真偽値の配列を返しません。代わりにA .== Bを使います。他の論理演算子である<や>についても同様です。

  • Juliaでスカラー値を返す関数を配列の各要素に適用するには、f(A)ではなく、ブロードキャスト構文f.(A)を使います。どちらの演算も定義されていても、意味が異なる場合があります。MATLABではexp(A)は要素ごとの演算で、expm(A)はmatrix exponentialですが、Juliaではexp.(A)が要素ごとの演算で、exp(A)は行列指数関数です。

  • Juliaの演算子&、|、⊻(xor)は、MATLABのand、or、xorに相当するビット演算を行います。優先順位はCではなくPythonのビット演算子に近いものです。配列に対して論理演算(MATLABの&や|の一般的な使い方など)を行うには、Juliaの短絡評価演算子.&&と.||をブロードキャストします。たとえば、配列Aの要素が1または2と等しいかを調べるには、A .== 1 .|| A .== 2を使います。

  • Juliaでは、コレクションの要素をスプラット演算子...で関数の引数として渡せます。たとえばxs=[1,2]; f(xs...)のように書きます。

  • Juliaのsvdは、特異値を密な対角行列ではなくベクトルとして返します。

  • Juliaでは、コード行を継続するために...を使いません。式が未完了であれば、自動的に次の行へ続きます。

  • JuliaとMATLABのどちらでも、対話セッションで最後に実行した式の値が変数ansに設定されます。ただしJuliaでは、MATLABと異なり、非対話モードでコードを実行した場合、ansは設定されません。

  • Juliaのstructは、MATLABのclassと異なり、実行時にフィールドを動的に追加できません。代わりにDictを使います。JuliaのDictには順序がありません。

  • Juliaでは各モジュールが独自のグローバルスコープ/名前空間を持ちますが、MATLABのグローバルスコープは1つだけです。

  • MATLABでは、不要な値を取り除く慣用的な方法として、x(x>3)のような論理インデックス指定や、x(x>3) = []のようにxをインプレースで変更する方法があります。一方、Juliaには高階関数filterとfilter!があり、対応する直訳的な書き方x[x.>3]とx = x[x.>3]の代わりに、filter(z->z>3, x)やfilter!(z->z>3, x)と書けます。filter!を使うと、一時配列の使用を減らせます。

  • 前項に関連して、行列の全要素にしきい値処理を行うなど、特定の条件を満たす値を置き換える処理は、MATLABでは次のように書けます。A(A < threshold) = 0。Juliaでの対応する書き方はA[A .< threshold] .= 0です。

  • MATLABでvertcat(A{:})のようにセル配列の全要素を取り出す(「参照解除」する)操作は、Juliaではスプラット演算子を使って、たとえばvcat(A...)のように書きます。

  • Juliaのadjoint関数は共役転置を行います。一方、MATLABのadjointは「随伴行列」または古典的随伴行列を返します。これは余因子行列の転置です。

  • Juliaではa^b^cはa^(b^c)として評価されますが、MATLABでは(a^b)^cとして評価されます。

Noteworthy differences from R

Juliaの目標の1つは、データ分析や統計プログラミングに適した言語を提供することです。RからJuliaに移行するユーザーが知っておくとよい主な違いを以下に示します。

  • Juliaでは、シングルクォートで囲むのは文字であり、文字列ではありません。

  • Juliaでは、文字列をインデックス指定して部分文字列を作成できます。Rでは、部分文字列を作る前に文字列を文字ベクトルに変換する必要があります。

  • Juliaでは、Pythonと同様に、Rとは異なり、三重引用符""" ... """で文字列を作成できます。改行を含む文字列を作るのに便利な構文です。

  • Juliaでは、可変長引数はスプラット演算子...で指定します。この演算子は必ず特定の変数名の後に置きます。一方、Rでは...を単独で使えます。

  • Juliaでは剰余はmod(a, b)であり、a %% bではありません。Juliaの%は剰余演算子です。

  • Juliaでは角括弧を使ってベクトルを作ります。Juliaの[1, 2, 3]は、Rのc(1, 2, 3)に相当します。

  • Juliaでは、すべてのデータ構造が論理インデックス指定に対応しているわけではありません。また、論理インデックス指定が使えるのは、インデックス対象と同じ長さのベクトルに限られます。たとえば次のとおりです。

    • Rでは、c(1, 2, 3, 4)[c(TRUE, FALSE)]はc(1, 3)に相当します。
    • Rでは、c(1, 2, 3, 4)[c(TRUE, FALSE, TRUE, FALSE)]はc(1, 3)に相当します。
    • Juliaでは、[1, 2, 3, 4][[true, false]]はBoundsErrorを投げます。
    • Juliaでは、[1, 2, 3, 4][[true, false, true, false]]は[1, 3]を生成します。
  • 多くの言語と同様、Juliaでは長さの異なるベクトルに対する演算が常に許されるわけではありません。ベクトルのインデックス範囲が共通していればよいRとは異なります。たとえばc(1, 2, 3, 4) + c(1, 2)はRでは有効ですが、Juliaで対応する[1, 2, 3, 4] + [1, 2]はエラーになります。

  • Juliaでは、コードの意味が変わらない場合、末尾にカンマを付けられます。配列のインデックス指定では、これがRユーザーの混乱を招くことがあります。たとえばRのx[1,]は行列の第1行を返しますが、Juliaではカンマが無視されるため、x[1,] == x[1]は第1要素を返します。行を取り出すには、x[1,:]のように:を使ってください。

  • Juliaのmapは、引数より先に関数を取ります。Rのlapply(<structure>, function, ...)とは順序が逆です。同様に、Rのapply(X, MARGIN, FUN, ...)に相当するJuliaの関数はmapslicesで、関数が第1引数になります。

  • Rの多変量apply(たとえばmapply(choose, 11:13, 1:3))は、Juliaではbroadcast(binomial, 11:13, 1:3)と書けます。同様に、Juliaには関数をベクトル化する短いドット構文binomial.(11:13, 1:3)もあります。

  • Juliaでは、条件ブロック(ifなど)、ループブロック(while/forなど)、関数の終わりを示すのにendを使います。1行で書くif ( cond ) statementの代わりに、if cond; statement; end、cond && statement、!cond || statementの形式で文を書けます。後者2つの構文で代入文を使う場合は、cond && (x = value)のように、明示的に括弧で囲む必要があります。

  • Juliaでは、<-、<<-、->は代入演算子ではありません。

  • Juliaの->は無名関数を作成します。

  • Juliaの*演算子は、Rとは異なり、行列積を計算できます。AとBが行列の場合、JuliaのA * Bは行列積を表し、RのA %*% Bに相当します。Rでは同じ表記が要素ごとの積(アダマール積)を表します。要素ごとの積をJuliaで行うには、A .* Bと書きます。

  • Juliaでは、transpose関数で行列を転置し、'演算子またはadjoint関数で共役転置します。したがって、Juliaのtranspose(A)はRのt(A)に相当します。また、Juliaには再帰しない転置を行うpermutedims関数もあります。

  • Juliaでは、if文やfor/whileループを書くときに括弧は不要です。for (i in c(1, 2, 3))ではなくfor i in [1, 2, 3]を、if (i == 1)ではなくif i == 1を使います。

  • Juliaでは、0と1は真偽値として扱われません。Juliaではif (1)とは書けません。if文が真偽値だけを受け付けるためです。代わりにif true、if Bool(1)、またはif 1==1と書けます。

  • Juliaにはnrowとncolはありません。代わりに、nrow(M)にはsize(M, 1)を、ncol(M)にはsize(M, 2)を使います。

  • Juliaではスカラー、ベクトル、行列を明確に区別します。Rでは1とc(1)は同じですが、Juliaでは相互に置き換えて使えません。

  • Juliaのdiagとdiagmは、Rの同名のものとは異なります。

  • Juliaでは、関数呼び出しの結果を代入演算の左辺に指定できません。つまり、diag(M) = fill(1, n)とは書けません。

  • Juliaでは、メインの名前空間に関数を詰め込むことは推奨されません。Juliaの統計機能の多くは、JuliaStats organizationの下にあるpackagesで提供されています。たとえば次のとおりです。

  • Juliaにはタプルと本格的なハッシュテーブルがありますが、R形式のリストはありません。複数の項目を返す場合は、通常、タプルまたは名前付きタプルを使います。list(a = 1, b = 2)の代わりに、(1, 2)または(a=1, b=2)を使います。

  • Juliaでは、RのS3やS4オブジェクトより扱いやすい独自の型を定義することが推奨されています。Juliaの多重ディスパッチにより、table(x::TypeA)とtable(x::TypeB)は、Rのtable.TypeA(x)とtable.TypeB(x)のように機能します。

  • Juliaでは、値を代入したり関数に渡したりしてもコピーされません。関数が配列を変更すると、その変更は呼び出し元からも見えます。これはRとは大きく異なり、新しい関数が大きなデータ構造をより効率的に処理できる理由でもあります。

  • Juliaでは、ベクトルや行列の連結にhcat、vcat、hvcatを使います。Rのようにc、rbind、cbindは使いません。

  • Juliaでは、a:bのような範囲は、Rのようなベクトルの略記ではなく、反復処理に使う特殊なAbstractRangeオブジェクトです。範囲をベクトルに変換するにはcollect(a:b)を使います。

  • :演算子の優先順位は、RとJuliaで異なります。特にJuliaでは算術演算子の優先順位が:演算子より高いのに対し、Rでは逆です。たとえばJuliaの1:n-1は、Rの1:(n-1)に相当します。

  • Juliaのmaxとminは、それぞれRのpmaxとpminに相当しますが、両方の引数の次元が同じでなければなりません。maximumとminimumはRのmaxとminに代わるものですが、重要な違いがあります。

  • Juliaのsum、prod、maximum、minimumは、Rの対応する関数とは異なります。いずれも、演算対象の次元を指定する省略可能なキーワード引数dimsを受け取ります。たとえば、JuliaのA = [1 2; 3 4]とRのB <- rbind(c(1,2),c(3,4))が同じ行列だとします。このとき、sum(A)はsum(B)と同じ結果になります。一方、sum(A, dims=1)は各列の合計を含む行ベクトルを、sum(A, dims=2)は各行の合計を含む列ベクトルを返します。これは、別々のcolSums(B)関数とrowSums(B)関数で同様の処理を行うRとは異なります。dimsキーワード引数がベクトルの場合、合計を計算するすべての次元を指定し、合計後の配列の次元は保持します。たとえばsum(A, dims=(1,2)) == hcat(10)のようにします。なお、第2引数のエラーチェックは行われません。

  • Juliaには、引数を変更する関数がいくつかあります。たとえばsortとsort!の両方があります。

  • Rでは性能のためにベクトル化が必要ですが、Juliaではほぼ逆です。ベクトル化を避けたループを使うほうが、高速なコードになることがよくあります。

  • Juliaは先行評価を行い、R形式の遅延評価には対応していません。多くのユーザーにとって、引用符で囲まない式や列名を使う場面が非常に少ないことを意味します。

  • JuliaはNULL型に対応していません。最も近いのはnothingですが、リストではなくスカラー値のように振る舞います。is.null(x)の代わりにx === nothingを使います。

  • Juliaでは、欠損値はNAではなくmissingオブジェクトで表します。is.na(x)の代わりにismissing(x)を使います(ベクトルの要素ごとの演算にはismissing.(x)を使います)。通常はna.rm=TRUEではなくskipmissing関数を使います(ただし、特定のケースではskipmissing引数を取る関数もあります)。

  • Juliaには、Rのassignやgetに相当するものはありません。

  • Juliaでは、returnに括弧は不要です。

  • Rでは、不要な値を取り除く慣用的な方法として、x[x>3]のような論理インデックス指定や、x = x[x>3]のようにxをインプレースで変更する方法があります。一方、Juliaには高階関数filterとfilter!があり、対応する直訳的な書き方x[x.>3]とx = x[x.>3]の代わりに、filter(z->z>3, x)やfilter!(z->z>3, x)と書けます。filter!を使うと、一時配列の使用を減らせます。

Noteworthy differences from Python

  • Juliaでは、for、if、whileなどのブロックは、endキーワードで終わります。Pythonとは異なり、インデントの深さは意味を持ちません。また、JuliaにはPythonのpassキーワードに相当するものはありません。
  • Juliaでは文字列を二重引用符("text")で囲みます(複数行文字列では二重引用符を3つ使います)。Pythonでは一重引用符('text')または二重引用符("text")のどちらでも囲めます。Juliaでは一重引用符は文字に使います('c')。
  • Juliaでは文字列の連結に*を使います。Pythonのように+は使いません。同様に、文字列の反復には^を使い、*は使いません。Pythonのように文字列リテラルを暗黙に連結すること(たとえば'ab' 'cd' == 'abcd')は、Juliaでは行われません。
  • 柔軟ですが低速なPythonのリストは、JuliaのVector{Any}型、またはより一般には、Tが具体型でない要素型であるVector{T}に相当します。要素をインプレースに格納するNumPy配列のような「高速」配列(つまり、dtypeがnp.float64、[('f1', np.uint64), ('f2', np.int32)]など)は、Tが具体的な不変要素型であるArray{T}で表せます。これにはFloat64、Int32、Int64などの組み込み型だけでなく、Tuple{UInt64,Float64}のような複雑な型や、多くのユーザー定義型も含まれます。
  • Juliaでは、配列や文字列などのインデックスは1始まりであり、0始まりではありません。
  • Juliaのスライスによるインデックス指定では、最後の要素も含まれます。Juliaのa[2:3]は、Pythonのa[1:3]に相当します。
  • Pythonとは異なり、JuliaではAbstractArrays with arbitrary indexesが可能です。Pythonで負のインデックスに特別な意味を持たせるa[-1]とa[-2]は、Juliaではa[end]とa[end-1]と書きます。
  • Juliaで最後の要素までをインデックス指定するには、endが必要です。Juliaのx[2:end]は、Pythonのx[1:]に相当します。
  • Juliaでは、任意のオブジェクトの前に:を置くと、Symbolを作成するか、式をクォートします。そのため、x[:5]はx[5]と同じです。配列の先頭からn個の要素を取得するには、範囲によるインデックス指定を使います。
  • Juliaの範囲インデックス指定はx[start:step:stop]の形式ですが、Pythonではx[start:(stop+1):step]の形式です。したがって、Pythonのx[0:10:2]はJuliaのx[1:2:10]に相当します。同様に、逆順の配列を表すPythonのx[::-1]は、Juliaのx[end:-1:1]に相当します。
  • Juliaでは、配列のインデックス指定と同じ構文を使って、start:step:stopのように範囲を単独で作成できます。range関数も使えます。
  • Juliaでは、X[[1,2], [1,3]]のように配列で行列をインデックス指定すると、第1・第2行と第1・第3列の交点を含む部分行列を参照します。PythonのX[[1,2], [1,3]]は、行列のセル[1,1]と[2,3]の値を含むベクトルを参照します。JuliaのX[[1,2], [1,3]]はPythonのX[np.ix_([0,1],[0,2])]に相当し、PythonのX[[0,1], [0,2]]はJuliaのX[[CartesianIndex(1,1), CartesianIndex(2,3)]]に相当します。
  • Juliaには行継続構文がありません。行末までの入力が完全な式ならそこで完了とみなされ、そうでなければ入力は次の行へ続きます。式を強制的に続ける方法の1つは、括弧で囲むことです。
  • Juliaの配列は列優先(Fortran順)ですが、NumPy配列は既定で行優先(C順)です。配列をループ処理する際に最適な性能を得るには、NumPyに比べてJuliaではループの順序を逆にします(relevant section of Performance Tipsを参照)。
  • Juliaの更新演算子(たとえば+=、-=など)はインプレースではありませんが、NumPyではインプレースです。つまり、A = [1, 1]; B = A; B += [3, 3]はAの値を変更せず、右辺のB = B + 3の結果(新しい配列)に左辺の名前Bを再束縛します。インプレースで演算するには、B .+= 3(dot operatorsも参照)、明示的なループ、またはInplaceOps.jlを使います。
  • Juliaでは、関数の引数の既定値はメソッドが呼び出されるたびに評価されます。Pythonでは関数定義時に一度だけ評価されます。たとえば、引数なしで呼び出すたびに新しい乱数を返す関数はf(x=rand()) = xです。一方、g(x=[1,2]) = push!(x,3)はg()として呼び出すたびに[1,2,3]を返します。
  • Juliaでは、キーワード引数はキーワードを使って渡す必要があります。通常、位置引数として渡せるPythonとは異なります。キーワード引数を位置引数として渡そうとすると、メソッドシグネチャが変わり、MethodErrorが発生したり、誤ったメソッドが呼び出されたりします。
  • Juliaでは%は剰余演算子ですが、Pythonではモジュロ演算子です。
  • Juliaでよく使われるInt型は、Pythonの任意精度整数intとは異なり、マシン整数型(Int32またはInt64)に相当します。そのため、JuliaのInt型ではオーバーフローが起こり、2^64 == 0となります。より大きな値が必要な場合は、Int128、BigInt、またはFloat64のような浮動小数点型など、適切な型を使います。
  • 虚数単位sqrt(-1)は、Juliaではimで表します。Pythonのjとは異なります。
  • Juliaでは、べき乗演算子は^です。Pythonの**ではありません。
  • Juliaでは、nothingを型Nothingとしてnull値を表します。Pythonでは型NoneTypeのNoneを使います。
  • Juliaでは、行列型に対する標準演算子は行列演算ですが、Pythonでは要素ごとの演算です。AとBが行列の場合、JuliaのA * Bは行列積を計算し、Pythonのような要素ごとの積にはなりません。JuliaのA * BはPythonのA @ Bに相当し、PythonのA * BはJuliaのA .* Bに相当します。
  • Juliaでスカラー値を返す関数を配列の各要素に適用するには、f(A)ではなく、ブロードキャスト構文f.(A)を使います。どちらの演算も定義されていても、意味が異なる場合があります。numpy.exp(A)は要素ごとの演算で、scipy.linalg.expm(A)はmatrix exponentialですが、Juliaではexp.(A)が要素ごとの演算で、exp(A)は行列指数関数です。
  • Juliaの随伴演算子'は、ベクトルの随伴(行ベクトルの遅延表現)を返します。一方、Pythonでベクトルに転置演算子.Tを適用しても、元のベクトルが返されます(何も行われません)。
  • Juliaの関数には、複数の具体的な実装(「メソッド」)を持たせることができます。呼び出し時にすべての引数の型に基づく多重ディスパッチで、適切な実装が選択されます。Pythonの関数は実装が1つで、多相性もありません(ただし、Pythonのメソッド呼び出しは別の構文を使い、メソッドの受け手に基づくディスパッチが可能です)。
  • Juliaにクラスはありません。代わりに、データを持つ構造体(可変または不変)がありますが、メソッドは持ちません。
  • Pythonでクラスのインスタンスのメソッドを呼び出す(x = MyClass(*args); x.f(y))ことは、Juliaでは関数呼び出し(たとえばx = MyType(args...); f(x, y))に相当します。一般に、多重ディスパッチはPythonのクラスシステムより柔軟で強力です。
  • Juliaの構造体が持てる抽象スーパータイプは1つだけですが、Pythonのクラスは1つ以上の(抽象または具象)スーパークラスを継承できます。
  • Juliaのプログラム構造(パッケージとモジュール)はファイル構造から独立していますが、Pythonのコード構造はディレクトリ(パッケージ)とファイル(モジュール)で定義されます。
  • Juliaでは、大きなモジュールのコードを複数のファイルに分割し、ファイルごとに新しいモジュールを作らないのが慣用的です。メインファイル内でincludeを使い、コードを1つのモジュールにまとめます。Pythonで対応するexecはこの用途では一般的ではなく、以前の定義を警告なしに上書きします。Juliaのプログラムはmoduleレベルでusingまたはimportを使って単位として定義され、Pythonのincludeのように、必要になったときに初回だけ実行されます。モジュールを構成する個々のファイルは、意図した順序で一度ずつ列挙し、includeで読み込みます。
  • Juliaの三項演算子x > 0 ? 1 : -1は、Pythonの条件式1 if x > 0 else -1に相当します。
  • Juliaでは@はマクロを表しますが、Pythonではデコレーターを表します。
  • Juliaではtry — catch — finallyを使って例外を処理します。Pythonのtry — except — finallyとは異なります。Pythonとは異なり、Juliaでは通常の処理の一部として例外処理を使うことは推奨されません(通常の制御フローはJuliaのほうが高速ですが、例外の捕捉は遅いためです)。
  • Juliaではループが高速なので、性能のために「ベクトル化」したコードを書く必要はありません。
  • Juliaでは、特にタイトなループ内で、定数でないグローバル変数に注意してください。Pythonとは異なり、Juliaでは機械語に近いコードを書けるため、グローバル変数の影響が非常に大きくなることがあります(Performance Tipsを参照)。
  • Juliaでは、丸めと切り捨てを明示的に行います。Pythonのint(3.7)は、Juliaではfloor(Int, 3.7)またはInt(floor(3.7))と書き、round(Int, 3.7)とは区別されます。floor(x)とround(x)は、単独で使うと、常にIntを返すのではなく、xと同じ型の整数値を返します。
  • Juliaでは、解析を明示的に行います。Pythonのfloat("3.7")は、Juliaではparse(Float64, "3.7")に相当します。
  • Pythonでは、多くの値を論理コンテキストで使えます(たとえばif "a":なら後続のブロックが実行され、if "":なら実行されません)。JuliaではBoolへの明示的な変換が必要です(たとえばif "a"は例外を投げます)。Juliaで空でない文字列かどうかを調べるには、明示的にif !isempty("")と書きます。意外かもしれませんが、Pythonではif "False"とbool("False")はどちらもTrueと評価されます("False"は空でない文字列だからです)。Juliaではparse(Bool, "false")はfalseを返します。
  • Juliaでは、ループやtry — catch — finallyなど、ほとんどのコードブロックが新しいローカルスコープを導入します。内包表記(リスト内包表記、ジェネレーターなど)はPythonとJuliaの両方で新しいローカルスコープを導入しますが、ifブロックはどちらの言語でも新しいローカルスコープを導入しません。

Noteworthy differences from C/C++

  • Juliaの配列は角括弧でインデックス指定でき、複数の次元を持てます。A[i,j]。この構文は、C/C++のようにポインターやアドレスを参照するための単なる糖衣構文ではありません。the manual entry about array constructionを参照してください。
  • Juliaでは、配列や文字列などのインデックスは1始まりであり、0始まりではありません。
  • Juliaでは、配列を別の変数に代入してもコピーされません。A = Bの後にBの要素を変更すると、Aも変更されます。+=のような更新演算子はインプレースで動作せず、A = A + Bと同等です。つまり、右辺の式の結果に左辺を再束縛します。
  • Juliaの配列は列優先(Fortran順)ですが、C/C++の配列は既定で行優先です。配列をループ処理する際に最適な性能を得るには、C/C++に比べてJuliaではループの順序を逆にします(relevant section of Performance Tipsを参照)。
  • Juliaでは、値を代入したり関数に渡したりしてもコピーされません。関数が配列を変更すると、その変更は呼び出し元からも見えます。
  • Juliaでは、C/C++とは異なり、空白が意味を持ちます。そのため、Juliaプログラムで空白を追加・削除する際は注意が必要です。
  • Juliaでは、小数点のない数値リテラル(たとえば42)は符号付き整数(型Int)になります。ただし、マシンワードサイズに収まらない大きさのリテラルは、より大きな型に自動的に昇格します。たとえば、IntがInt32の場合はInt64、またはInt128、任意の大きさを扱えるBigInt型などです。符号付き/符号なしを示すL、LL、U、UL、ULLのような数値リテラルの接尾辞はありません。10進リテラルは常に符号付きで、C/C++と同様に0xで始まる16進リテラルは、128ビットを超える値を表す場合を除き、符号なしです。128ビットを超える場合はBigInt型になります。また、C/C++/JavaやJuliaの10進リテラルとは異なり、16進リテラルの型は先頭の0を含むリテラルの桁数で決まります。たとえば、0x0と0x00はUInt8型、0x000と0x0000はUInt16型です。16進数が5~8桁のリテラルはUInt32型、9~16桁はUInt64型、17~32桁はUInt128型、32桁を超えるものはBigInt型になります。たとえば16進マスクを定義する際には、この点に注意が必要です。~0xf == 0xf0は~0x000f == 0xfff0とは大きく異なります。64ビットのFloat64リテラルと32ビットのFloat32リテラルは、それぞれ1.0と1.0f0と書きます。浮動小数点リテラルは、正確に表現できない場合、BigFloat型に昇格するのではなく丸められます。浮動小数点リテラルの動作はC/C++に近いものです。8進リテラル(0oを接頭辞とする)と2進リテラル(0bを接頭辞とする)も符号なしとして扱われます(128ビットを超える場合はBigInt)。
  • Juliaでは、両方のオペランドが整数型の場合、除算演算子/は浮動小数点数を返します。整数除算にはdivまたは÷を使います。
  • Juliaでは、浮動小数点型を使ってArrayをインデックス指定すると、通常はエラーになります。Cの式a[i / 2]に相当するJuliaの式はa[i ÷ 2 + 1]です。ここでiは整数型です。
  • 文字列リテラルは"または"""で囲めます。"""で囲んだリテラルでは、"文字を"\""のように引用符で囲まずに含められます。文字列リテラルには、$variablenameまたは$(expression)で示すことで、他の変数や式の値を埋め込めます。変数名や式は、関数のコンテキストで評価されます。
  • //はRational数を表し、Juliaの1行コメント(#)ではありません。
  • #=は複数行コメントの開始を示し、=#で終了します。
  • Juliaの関数は、最後の式の値、またはreturnキーワードで値を返します。関数は複数の値を返すことができ、(a, b) = myfunction()やa, b = myfunction()のようにタプルとして代入できます。C/C++のように値へのポインターを渡す必要はありません(つまりa = myfunction(&b))。
  • Juliaでは、文末にセミコロンを付ける必要はありません。式の結果は自動的には表示されず(対話プロンプト、つまりREPLを除く)、コード行をセミコロンで終える必要もありません。特定の出力を表示するにはprintlnまたは@printfを使います。REPLでは、出力を抑制するために;を使えます。また、;は[ ]内では別の意味を持つため、注意が必要です。;を使うと1行に複数の式を記述できますが、多くの場合必須ではなく、主に読みやすさのために使います。
  • Juliaでは、演算子⊻(xor)はビット単位のXOR演算を行います。つまり、C/C++の^に相当します。また、ビット演算子の優先順位はC/C++と同じではないため、括弧が必要になる場合があります。
  • Juliaの^はべき乗(pow)であり、C/C++のようなビット単位のXORではありません。JuliaでXORを行うには⊻またはxorを使います。
  • Juliaには右シフト演算子が2つあり、>>と>>>です。>>は算術シフトを行い、>>>は常に論理シフトを行います。C/C++では、>>の意味はシフト対象の値の型によって異なります。
  • Juliaの->は無名関数を作成します。ポインターを介してメンバーにアクセスするものではありません。
  • Juliaでは、if文やfor/whileループを書くときに括弧は不要です。for (int i=1; i <= 3; i++)ではなくfor i in [1, 2, 3]を、if (i == 1)ではなくif i == 1を使います。
  • Juliaでは、0と1は真偽値として扱われません。Juliaではif (1)とは書けません。if文が真偽値だけを受け付けるためです。代わりにif true、if Bool(1)、またはif 1==1と書けます。
  • Juliaでは、条件ブロック(ifなど)、ループブロック(while/forなど)、関数の終わりを示すのにendを使います。1行で書くif ( cond ) statementの代わりに、if cond; statement; end、cond && statement、!cond || statementの形式で文を書けます。後者2つの構文で代入文を使う場合は、演算子の優先順位のため、cond && (x = value)のように明示的に括弧で囲む必要があります。
  • Juliaには行継続構文がありません。行末までの入力が完全な式ならそこで完了とみなされ、そうでなければ入力は次の行へ続きます。式を強制的に続ける方法の1つは、括弧で囲むことです。
  • Juliaのマクロはプログラムのテキストではなく、解析済みの式を処理するため、Juliaコードを高度に変換できます。マクロ名は@文字で始まり、関数形式の@mymacro(arg1, arg2, arg3)と文形式の@mymacro arg1 arg2 arg3があります。両者は相互に置き換え可能です。関数形式は、マクロが別の式の中に現れる場合に特に便利で、意味も明確になりやすい形式です。文形式は、分散for構文のように、ブロックに注釈を付ける場合によく使われます。@distributed for i in 1:n; #= body =#; end。マクロ構文の終わりが分かりにくい場合は、関数形式を使ってください。
  • Juliaには列挙型があり、@enum(name, value1, value2, ...)マクロで表します。たとえば次のとおりです。@enum(Fruit, banana=1, apple, pear)
  • 慣例として、引数を変更する関数の名前は!で終わります。たとえばpush!です。
  • C++では、既定で静的ディスパッチが使われるため、動的ディスパッチを行うには関数にvirtualを指定する必要があります。一方、Juliaではすべてのメソッドが「仮想」です(ただし、メソッドはthisだけでなく、すべての引数の型に基づいて、最も具体的な宣言を選ぶ規則でディスパッチされるため、より一般的な仕組みです)。

Julia ⇔ C/C++: Namespaces

  • C/C++のnamespaceは、Juliaのmoduleにおおむね相当します。

  • Juliaには、非公開のグローバル変数やフィールドはありません。完全修飾パス(または必要に応じて相対パス)を使えば、すべてにアクセスできます。

  • C++のusing MyNamespace::myfunは、Juliaのimport MyModule: myfunにおおむね相当します。

  • C++のusing namespace MyNamespaceは、Juliaのusing MyModuleにおおむね相当します。

    • Juliaでは、exportされたシンボルだけが呼び出し元のモジュールから利用できます。
    • C++では、インクルードされた(公開)ヘッダーファイルにある要素だけが利用できます。
  • 注意:Juliaのimport/usingキーワードは、モジュールの読み込みも行います(後述)。

  • 注意:Juliaのimport/usingは、グローバルスコープ(modules)でのみ機能します。

    • C++では、using namespace Xは任意のスコープ(例:関数スコープ)内で機能します。

Julia ⇔ C/C++: Module loading

  • C/C++の「ライブラリ」に相当するものを探している場合、Juliaでは「パッケージ」が該当するでしょう。

    • 注意:C/C++のライブラリには複数の「ソフトウェアモジュール」が含まれることがよくありますが、Juliaの「パッケージ」に含まれるのは通常1つです。
    • 補足:Juliaのmodulesはグローバルスコープであり、必ずしも「ソフトウェアモジュール」ではありません。
  • build/makeスクリプトの代わりに、Juliaでは「プロジェクト環境」(「Project」または「Environment」と呼ばれることもあります)を使います。

    • ビルドスクリプトが必要なのは、C/C++の実行ファイルをコンパイルまたはダウンロードするような、より複雑なアプリケーションの場合だけです。
    • Juliaでアプリケーションやプロジェクトを開発するには、ルートディレクトリを「プロジェクト環境」として初期化し、アプリケーション固有のコードやパッケージをそこに置きます。これにより、プロジェクトの依存関係を適切に管理し、将来の再現性を確保できます。
    • 利用可能なパッケージは、Pkg.add()関数またはPkg REPLモードを使って「プロジェクト環境」に追加します。ただし、これによってパッケージが読み込まれるわけではありません。
    • 「プロジェクト環境」で利用できるパッケージ(直接依存関係)の一覧は、Project.tomlファイルに保存されます。
    • 「プロジェクト環境」の依存関係の全情報は、Pkg.resolve()によって自動生成され、Manifest.tomlファイルに保存されます。
  • 「プロジェクト環境」で利用できるパッケージ(「ソフトウェアモジュール」)は、importまたはusingで読み込みます。

    • C/C++では、オブジェクトや関数の宣言を得るために#include <moduleheader>を使い、実行ファイルのビルド時にライブラリをリンクします。
    • Juliaでは、using/importを再度呼び出しても既存のモジュールがスコープに入るだけで、再読み込みはされません(C/C++に非標準の#pragma onceを追加するのに似ています)。
  • ディレクトリベースのパッケージリポジトリ(Julia)は、リポジトリのパスをBase.LOAD_PATH配列に追加すると利用できるようになります。

    • ディレクトリベースのリポジトリにあるパッケージは、importまたはusingで読み込む前にPkg.add()ツールを使う必要はありません。プロジェクトからそのまま利用できます。
    • ディレクトリベースのパッケージリポジトリは、「ソフトウェアモジュール」のローカルライブラリを開発するための最も手軽な方法です。

Julia ⇔ C/C++: Assembling modules

  • C/C++では、.c/.cppファイルをビルド/makeスクリプトでコンパイルし、ライブラリに追加します。

    • Juliaでは、import [PkgName]/using [PkgName]文によって、パッケージの[PkgName]/src/サブディレクトリにある[PkgName].jlを読み込みます。
    • 通常、[PkgName].jlはinclude "[someotherfile].jl"の呼び出しによって、関連するソースファイルを読み込みます。
  • Juliaのinclude "./path/to/somefile.jl"は、C/C++の#include "./path/to/somefile.jl"によく似ています。

    • ただし、Juliaのinclude "..."はヘッダーファイルのインクルードには使いません(その必要もありません)。
    • 他の「ソフトウェアモジュール」のコードを読み込むために、Juliaのinclude "..."を使わないでください(代わりにimport/usingを使います)。
    • Juliaのinclude "path/to/some/module.jl"を使うと、同じコードの複数のバージョンが異なるモジュール内に作られ、同じ名前を持つ型などが別個に生成されます。
    • include "somefile.jl"は通常、同じJuliaパッケージ(「ソフトウェアモジュール」)内の複数のファイルをまとめるために使います。そのため、ファイルが一度だけincludeされるようにするのは比較的簡単です(#ifdefの混乱は起きません)。

Julia ⇔ C/C++: Module interface

  • C++では「public」.h/.hppファイルでインターフェースを公開します。一方、Juliaではmodulesによって、ユーザー向けの特定のシンボルをpublicまたはexportとして指定します。

    • Juliaのmodulesは、既存の関数に新しい「メソッド」を追加することで機能を拡張するだけの場合もよくあります(例:Base.push!)。
    • そのため、Juliaパッケージの開発者は、インターフェースのドキュメントとしてヘッダーファイルを頼りにできません。
    • Juliaパッケージのインターフェースは通常、docstring、README.md、静的なWebページなどで説明されます。
  • パッケージ/モジュールの利用に必要なシンボルをすべてexportしない開発者もいますが、公開されていないユーザー向けシンボルにもpublicを付けるべきです。

    • ユーザーは、パッケージ/モジュール名で関数や構造体などを修飾して、これらの要素にアクセスすることが想定される場合があります(例:MyModule.run_this_task(...))。

Julia ⇔ C/C++: Quick reference

ソフトウェアの概念JuliaC/C++
名前のないスコープbegin ... end{ ... }
関数スコープfunction x() ... endint x() { ... }
グローバルスコープmodule MyMod ... endnamespace MyNS { ... }
ソフトウェアモジュールJuliaの「パッケージ」.h/.hppファイル<br>+コンパイル済みsomelib.a
ソフトウェアモジュールの組み立てSomePkg.jl: ...<br>import("subfile1.jl")<br>import("subfile2.jl")<br>...$(AR) *.o &rArr; somelib.a
ソフトウェアモジュールのインポートimport SomePkg#include <somelib><br>+somelib.aをリンク
モジュールライブラリLOAD_PATH[]、*Gitリポジトリ、<br>**カスタムパッケージレジストリ追加の.h/.hppファイル<br>+より大きなコンパイル済みsomebiglib.a
  • Juliaのパッケージマネージャーは、1つのGitリポジトリから複数のパッケージを登録できます。<br> * これにより、関連するパッケージ群を1つのリポジトリにまとめられます。<br> ** Juliaのレジストリは、主にパッケージのバージョン管理と配布を目的としています。<br> ** カスタムパッケージレジストリを使うと、モジュールライブラリのようなものを作成できます。

Noteworthy differences from Common Lisp

  • Juliaでは、既定で配列に1始まりのインデックスを使います。また、任意のindex offsetsも扱えます。

  • 関数と変数は同じ名前空間を共有します(「Lisp-1」)。

  • Pair型はありますが、COMMON-LISP:CONSとして使うことを意図したものではありません。多くの場面(スプラット、タプルなど)では、さまざまな反復可能コレクションを相互に置き換えて使えます。Tuplesは、短い異種要素コレクションにおいて、Common Lispのリストに最も近いものです。連想リストの代わりにはNamedTuplesを使います。より大きな同種要素のコレクションには、ArraysやDictsを使います。

  • Juliaでの一般的なプロトタイピング作業では、Revise.jlパッケージを使って、イメージを継続的に操作することもあります。

  • 性能のため、Juliaでは演算のtype stabilityが重視されます。Common Lispが基盤となる機械演算を抽象化するのに対し、Juliaはそれらに近い形で扱います。たとえば次のとおりです。

    • /を使った整数除算は、計算結果が正確な場合でも常に浮動小数点数を返します。

      • //は常に有理数を返します。
      • ÷は常に(切り捨てられた)整数を返します。
    • 多倍長整数はサポートされていますが、自動変換は行われません。通常の整数はoverflow。

    • 複素数はサポートされていますが、複素数の結果を得るにはyou need complex inputs。

    • 複素数型と有理数型には、成分の型が異なる複数の種類があります。

  • モジュール(名前空間)は階層化できます。importとusingには、コードを読み込むと同時に名前空間から利用可能にする役割があります。モジュール名だけを対象にimportすることもできます(おおむねASDF:LOAD-OPに相当)。フィールド名を個別にエクスポートする必要はありません。グローバル変数はモジュールの外から代入できません(例外としてeval(mod, :(var = val))を使う方法があります)。

  • マクロ名は@で始まり、Common Lispほど言語にシームレスに統合されていません。そのため、Common Lispほど広く使われてはいません。macrosには、衛生的なマクロに相当する仕組みが言語でサポートされています。表層構文が異なるため、COMMON-LISP:&BODYに相当するものはありません。

  • すべての関数はジェネリックであり、多重ディスパッチを使います。引数リストが同じ形式に従う必要はなく、これによって強力な慣用パターンが生まれます(doを参照)。オプション引数とキーワード引数の扱いは異なります。メソッドの曖昧さはCommon Lisp Object Systemのようには解決されないため、交差部分に対してより具体的なメソッドを定義する必要があります。

  • シンボルはどのパッケージにも属さず、それ自体では値を持ちません。M.varは、モジュールM内のシンボルvarを評価します。

  • クロージャーを含む関数型プログラミングのスタイルは完全にサポートされていますが、Juliaで常に慣用的な解決策とは限りません。捕捉した変数を変更する場合、性能のためにworkaroundsが必要になることがあります。