全方位对比:Python、Julia、MATLAB、IDL 和 Java (2019 版)

引言

我们使用简单的测试用例来对各种高级编程语言进行比较。我们是从新手程序员的角度来实现测试用例,假设这个新手程序员不熟悉语言中可用的优化技术。我们的目的是突出每一种语言的优缺点,而不是宣称一种语言比其他语言更优越。计时结果以秒为单位,精确到四位数,任何小于 0.0001 的值将被视为 0 秒。

本文提供的测试是在 Intel Xeon Haswell 处理器节点上进行的,每个节点有 28 核(每核 2.6GHz)和 128GB 的可用内存。Python、Java 和 Scala 测试运行在一台 Mac 计算上,该计算机配备了 Intel i7-7700HQ(4 核,每核 2.8GHz),16GB 可用内存,以便与 Xeon 节点进行比较。我们考虑这些语言使用如下版本:

语言

版本号

是否开源

Python

3.7

Julia

0.6.2

Java

10.0.2

Scala

2.13.0

IDL

8.5

R

3.6.1

Matlab

R2017b

GNU Compilers

9.1

Intel Compilers

18.0.5.274

GNU 和 Intel 编译器用于 C 和 Fortran。包含这些语言是为了作为基准,这就是为什么它们的测试也带有优化版本(-O3、-Ofast)的原因。

测试用例分为四类:

  • 循环和向量化
  • 字符串操作
  • 数值计算
  • 输入 / 输出

每个测试都足够“简单”,可以用任何一种语言快速编写,旨在解决以下问题:

  • 非连续内存位置的访问
  • 递归函数的使用
  • 循环或向量化的利用
  • 海量文件的打开
  • 任意长度的字符串的操作
  • 矩阵的乘积
  • 迭代求解的使用
  • 等等

源文件包含在以下目录中:

C\  Fortran\  IDL\  Java\  Julia\  Matlab\  Python\  R\  Scala\

还有一个目录:

Data\

它包含一个 Python 脚本,该脚本在读取大量文件时生成测试用例所需的 NetCDF4 文件。它还有用于“计算文件中唯一单词”测试用例的示例文本文件。

备注:在下面显示的结果中,我们使用了较旧版本的 Julia,因为在 Xeon Haswell 节点上安装最新版本的 Julia(1.1.1) 时我们遇到了困难。此外,Python 实验并不包括 Numba,因为我们有权访问的 Haswell 节点使用的是较旧版本的操作系统,妨碍了 Numba 的正确安装。

循环与向量化

  • 复制多维数组

给定任意 n x n x 3 矩阵 A,我们将执行以下操作:

A(i, j, 1) = A(i, j, 2)
A(i, j, 3) = A(i, j, 1)
A(i, j, 2) = A(i, j, 3)   

循环和向量化的使用。该测试用例旨在测量语言访问连续内存位置的速度,并查看每种语言如何处理循环和向量化。

表 CPA-1.0:在 Xeon 节点上使用循环复制矩阵元素所用的时间。

语言

选项

n=5000

n=7000

n=9000

Python

16.2164

31.7867

52.5485

Julia

0.0722

0.1445

0.2359

Java

0.1810

0.3230

0.5390

Scala

0.2750

0.4810

0.7320

IDL

6.4661

11.9068

19.4499

R

22.9510

44.9760

74.3480

Matlab

0.2849

0.5203

0.8461

Fortran

gfortran

0.1760

0.3480

0.5720

gfortran -O3

0.0680

0.1720

0.2240

ifort

0.0680

0.1360

0.2240

ifort -O3

0.0680

0.1360

0.2800

C

gcc

0.1700

0.3400

0.5600

gcc -Ofast

0.0900

0.1800

0.3100

icc

0.1000

0.1800

0.3000

icc -Ofast

0.1000

0.1800

0.3000

表 CPA-1.1:在 i7 Mac 上使用循环复制矩阵元素所用的时间。

语言

n=5000

n=7000

n=9000

Python

18.6675

36.4046

60.2338

Python (Numba)

0.3398

0.3060

0.3693

Java

0.1260

0.2420

0.4190

Scala

0.2040

0.3450

0.5150

表 CPA-2.0:在 Xeon 节点上使用向量化复制矩阵元素所用的时间。

语言

选项

n=5000

n=7000

n=9000

Python

0.4956

0.9739

1.6078

Julia

0.3173

0.5575

0.9191

IDL

0.3900

0.7641

1.2643

R

3.5290

6.9350

11.4400

Matlab

0.2862

0.5591

0.9188

Fortran

gfortran

0.0960

0.2520

0.3240

gfortran -O3

0.0960

0.2440

0.3120

ifort

0.1400

0.2280

0.3840

ifort -O3

0.1200

0.2360

0.4560

表 CPA-2.1:在 i7 Mac 上使用向量化复制矩阵元素所用的时间。

语言

n=5000

n=7000

n=9000

Python

0.5602

1.0832

1.8077

Python (Numba)

0.8507

1.3650

2.0739

字符串操作

  • 外观数列

外观数列(Look and Say Sequence)读取一个整数。在后续的每个项中,前一个项中每个整数出现的次数连接到该整数的前面。如,一个项 1223,接下来将会是 112213 ,或“一个 1,两个 2,一个 3”。这里,我们从数字开始: 1223334444 ,并确定 n 项(随 n 不同)的外观数列,这个测试用例突出显示了语言如何操作操纵任意长度的字符串。

表 LKS-1.0:在 Xeon 节点上查找 n 项的外观数列所用的时间。

语言

选项

n=40

n=45

n=48

Python

2.0890

44.4155

251.1905

Java

0.0694

0.0899

0.1211

Scala

0.0470

0.1270

0.2170

IDL

20.2926

304.5049

1612.4277

Matlab

423.2241

6292.7255

exceeded time limit

Fortran

gfortran

0.0080

0.0120

0.0120

gfortran -O3

0.0080

0.0120

0.0120

ifort

0.0040

0.0160

0.0120

ifort -O3

0.0080

0.0040

0.0080

C

gcc

0.0600

0.1900

0.4300

gcc -Ofast

0.0400

0.1800

0.4000

icc

0.0600

0.1900

0.4100

icc -Ofast

0.0500

0.1900

0.4100

表 LKS-1.1:在 i7 Mac 上查找 n 项的外观数列所用的时间。

语言

n=40

n=45

n=48

Python

1.7331

22.3870

126.0252

Java

0.0665

0.0912

0.1543

Scala

0.0490

0.0970

0.2040

  • 文件中的唯一单词

我们打开一个任意文件,并计算其中唯一单词的数量,假设单词如下:

ab   Ab   aB   a&*(-b:   17;A#~!b

数量是相同的(在这样的情况下,大小写、特殊字符和数字将被忽略)。在我们的测试中,使用了四个文件:

world192.txt、plrabn12.txt、bible.txt、book1.txt

这些文件取自 Canterbury 语料库

表 UQW-1.0:在 Xeon 节点上计算文件中的唯一单词所用的时间。

语言

world192.txt (19626 个单词)

plrabn12.txt (9408 个单词)

bible.txt (12605 个单词)

book1.txt (12427 个单词)

Python (dictionary method)

0.5002

0.1090

0.8869

0.1850

Python (set method)

0.3814

0.0873

0.7548

0.1458

Julia

0.2190

0.0354

0.3239

0.0615

Java

0.5624

0.2299

1.0135

0.2901

Scala

0.4600

0.2150

0.6930

0.2190

R

104.5820

8.6440

33.8210

17.6720

Matlab

3.0270

0.9657

6.0348

1.0390

表 UQW-1.1:在 i7 Mac 上计算文件中唯一单词所用的时间。

语言

world192.txt (19626 个单词)

plrabn12.txt (9408 个单词)

bible.txt (12605 个单词)

book1.txt (12427 个单词)

Python (dictionary method)

0.3541

0.0866

0.7346

0.1448

Python (set method)

0.3685

0.0820

0.7197

0.1417

Java

0.5129

0.2530

0.9183

0.3220

Scala

0.5810

0.1540

0.6650

0.2330

数值计算

  • 斐波那契数列

斐波那契数列是一个数字序列,其中每个连续的数字是它前面两个数字的和:

它的第一项是:

斐波那契数列在经济学、计算机科学、生物学、组合学等领域都有广泛的应用。我们在计算第 n 个斐波那契数列时测量所用的时间。迭代计算和递归计算都需要计算时间。

表 FBC-1.0:在 Xeon 节点上迭代查找斐波那契数列所用的时间。

语言

选项

n=25

n=35

n=45

Python

0

0

0

Julia

0

0

0

Java

0

0

0

Scala

0

0

0

IDL

0

0

0

R

0.0330

0.0320

0.0320

Matlab

0.0026

0.0034

0.0038

Fortran

gfortran

0

0

0

gfortran -O3

0

0

0

ifort

0

0

0

ifort -O3

0

0

0

C

gcc

0

0

0

gcc -Ofast

0

0

0

icc

0

0

0

icc -Ofast

0

0

0

表 FBC-1.1:在 i7 Mac 上迭代查找斐波那契数列所用的时间。

语言

n=25

n=35

n=45

Python

0

0

0

Python (Numba)

0.1100

0.1095

0.1099

Java

0

0

0

Scala

0

0

0

表 FBC-2.0:在 Xeon 节点上递归查找斐波那契数列所用的时间。

语言

选项

n=25

n=35

n=45

Python

0.0593

7.0291

847.9716

Julia

0.0003

0.0308

3.787

Java

0.0011

0.0410

4.8192

Scala

0.0010

0.0560

5.1400

IDL

0.0238

2.5692

304.2198

R

0.0090

0.0100

0.0100

Matlab

0.0142

1.2631

149.9634

Fortran

gfortran

0

0.0840

10.4327

gfortran -O3

0

0

0

ifort

0

0

0

ifort -O3

0

0

0

C

gcc

0

0.0400

5.0600

gcc -Ofast

0

0.0200

2.2000

icc

0

0.0300

3.1400

icc -Ofast

0

0.0200

3.2800

表 FBC-2.1:在 i7 Mac 上递归查找斐波那契数列所用的时间。

语言

n=25

n=35

n=45

Python

0.0519

6.4022

800.0381

Python (Numba)

0.4172

43.7604

5951.6544

Java

0.0030

0.0442

5.0130

Scala

0.0010

0.0470

5.7720

  • 矩阵乘法

将两个随机生成的 n x n 矩阵 AB 相乘。测量执行乘法的时间。这个问题说明了利用每种语言中可用的内置库的重要性。

表 MXM-1.0:在 Xeon 节点上进行矩阵相乘所用的时间。

语言

选项

n=1500

n=1750

n=2000

Python

intrinsic

0.1560

0.2430

0.3457

Julia

intrinsic

0.1497

0.2398

0.3507

Java

loop

13.8610

17.8600

32.3370

Scala

loop

9.8380

19.1450

32.1310

R

intrinsic

0.1600

0.2460

0.3620

Matlab

intrinsic

1.3672

1.3951

0.4917

IDL

intrinsic

0.1894

0.2309

0.3258

Fortran

gfortran (loop)

17.4371

31.4660

62.1079

gfortran -O3 (loop)

3.3282

5.3003

12.1648

gfortran (matmul)

0.3840

0.6160

0.9241

gfortran -O3 (matmul)

0.3880

0.6160

0.9161

ifort (loop)

1.1401

1.8161

2.9282

ifort -O3 (loop)

1.1481

1.8081

2.9802

ifort (matmul)

1.1441

1.8121

2.9242

ifort -O3 (matmul)

0.5160

0.8281

1.2441

ifort (DGEMM)

0.2160

0.2360

0.3320

C

gcc (loop)

13.2000

20.9800

31.4400

gcc -Ofast (loop)

1.4500

2.3600

4.0400

icc (loop)

1.2300

2.1500

4.0500

icc -Ofast (loop)

1.1500

1.7500

2.5900

表 MXM-1.1:在 i7 Mac 上进行矩阵相乘所用的时间。

语言

选项

n=1500

n=1750

n=2000

Python

intrinsic

0.0906

0.1104

0.1611

Numba (loop)

9.2595

20.2012

35.3174

Java

loop

32.5080

47.7680

82.2810

Scala

loop

23.0540

38.9110

60.3180

  • 置信传播算法

置信传播是一种用于推理的算法,通常用于人工智能、语音识别、计算机视觉、图像处理、医学诊断、奇偶校验码等领域。我们用 5000x5000 元素矩阵来测量算法进行 n 次迭代所用的时间。在 Justin Domke 的博客(Domke 2012)中展示了 MATLAB、C 和 Julia 的代码,该博客指出,这个算法是“矩阵乘法的重复序列,然后进行归一化”。

表 BFP-1.0:在 Xeon 节点上执行置信传播算法所用的时间。

语言

选项

n=250

n=500

n=1000

Python

3.7076

7.0824

13.8950

Julia

4.0280

7.8220

15.1210

Java

63.9240

123.3840

246.5820

Scala

53.5170

106.4950

212.3550

IDL

16.9609

33.2086

65.7071

R

23.4150

45.4160

89.7680

Matlab

1.9760

3.8087

7.4036

Fortran

gfortran

21.0013

41.0106

87.6815

gfortran -O3

4.4923

8.2565

17.5731

ifort

4.7363

9.1086

17.8651

ifort -O3

4.7363

9.1086

21.1973

C

gcc

2.6400

5.2900

10.5800

gcc -Ofast

2.4200

4.8500

9.7100

icc

2.1600

4.3200

8.6500

icc -Ofast

2.1800

4.3400

8.7100

表 BFP-1.1:在 i7 Mac 上执行置信传播算法所用的时间。

语言

n=250

n=500

n=1000

Python

2.4121

4.5422

8.7730

Java

55.3400

107.7890

214.7900

Scala

47.9560

95.3040

189.8340

  • 梅特罗波利斯 - 黑斯廷斯(Metropolis-Hastings)算法

梅特罗波利斯 - 黑斯廷斯算法是一种用于从概率分布中提取随机样本的算法。该实现使用二维分布(Domke 2012),并测量迭代 n 次所用的时间。

表 MTH-1.0:在 Xeon 节点上执行梅特罗波利斯 - 黑斯廷斯算法所用的时间。

语言

选项

n=5000

n=10000

n=15000

Python

0.0404

0.0805

0.1195

Julia

0.0002

0.0004

0.0006

Java

0.0040

0.0050

0.0060

Scala

0.0080

0.0090

0.0100

IDL

0.0134

0.0105

0.0157

R

0.0760

0.1500

0.2230

Matlab

0.0183

0.0211

0.0263

Fortran

gfortran

0

0

0

gfortran -O3

0

0

0

ifort

0.0040

0

0

ifort -O3

0.0040

0.0040

0

C

gcc

0

0

0

gcc -Ofast

0

0

0

icc

0

0

0

icc -Ofast

0

0

0

表 MTH-1.1:在 i7 Mac 上执行梅特罗波利斯 - 黑斯廷斯算法所用的时间。

语言

n=5000

n=10000

n=15000

Python

0.0346

0.0638

0.0989

Java

0.0060

0.0040

0.0060

Scala

0.0090

0.0100

0.0130

  • 快速傅里叶变换

我们创建一个 n x n 矩阵 M ,其中包含随机复值。我们计算了 M 的快速傅里叶变换和结果的绝对值。快速傅里叶变换算法广泛用于各种科学和工程领域的信号处理和图像处理。

表 FFT-1.0:在 Xeon 节点上计算快速傅里叶变换所用的时间。

语言

选项

n=10000

n=15000

n=20000

Python

intrinsic

8.0797

19.6357

34.7400

Julia

intrinsic

3.979

11.490

20.751

IDL

intrinsic

16.6699

38.9857

70.8142

R

intrinsic

58.2550

150.1260

261.5460

Matlab

intrinsic

2.6243

6.0010

10.66232

表 FFT-1.1:在 i7 Mac 上计算快速傅里叶变换所用的时间。

语言

选项

n=10000

n=15000

n=20000

Python

intrinsic

7.9538

21.5355

55.9375

  • 迭代求解器

我们使用雅克比法迭代求解器(Jacobi iterative solver)数值逼近二维拉布拉斯方程(Laplace equation)的解,该解用四阶紧致格式离散(Gupta,1984)。随着网络点数量的变化,我们记录所用的时间。

表 ITS-1.0:在 Xeon 节点上迭代计算近似解所用的时间。

语言

选项

n=100

n=150

n=200

Python

158.2056

786.3425

2437.8560

Julia

1.0308

5.1870

16.1651

Java

0.4130

1.8950

5.2220

Scala

0.540

2.1030

5.7380

IDL

73.2353

364.1329

1127.1094

R

157.1490

774.7080

2414.1030

Matlab

2.8163

5.0543

8.6276

Fortran

gfortran

0.8240

3.7320

10.7290

gfortran -O3

0.6680

3.0720

8.8930

ifort

0.5400

2.4720

7.1560

ifort -O3

0.5400

2.4680

7.1560

C

gcc

0.5000

2.4200

7.7200

gcc -Ofast

0.2200

1.0500

3.1900

icc

0.4600

2.2300

6.7800

icc -Ofast

0.3300

1.6000

4.8700

表 ITS-1.2:在 i7 Mac 上迭代计算近似解所用的时间。

语言

n=100

n=150

n=200

Python

174.7663

865.1203

2666.3496

Python (Numba)

1.3226

5.0324

15.1793

Java

0.4600

1.7690

4.7530

Scala

0.5970

2.0950

5.2830

表 ITS-2.0:在 Xeon 节点上使用向量化计算近似解所用的时间。

语言

选项

n=100

n=150

n=200

Python

2.6272

14.6505

40.2124

Julia

2.4583

13.1918

41.0302

IDL

1.71192

8.6841

28.0683

R

25.2150

121.9870

340.4990

Matlab

3.3291

7.6486

15.9766

Fortran

gfortran

0.8680

4.2040

11.5410

gfortran -O3

0.3600

1.8040

5.0880

ifort

0.2800

1.5360

4.4560

ifort -O3

0.2800

1.5600

4.4160

表 ITS-2.1:在 i7 Mac 上使用向量化计算近似解所用的时间。

语言

n=100

n=150

n=200

Python

1.7051

7.4572

22.0945

Python (Numba)

2.4451

8.5094

21.7833

  • 矩阵的平方根

给定 n x n 矩阵 A,我们寻找这样的矩阵 B,使得:

B * B = A

B 就是平方根。在我们的计算中,我们考虑对角线上为 6,别处为 1 的矩阵 A。

表 SQM-1.0:在 Xeon 节点上计算矩阵的平方根所用的时间。

语言

n=1000

n=2000

n=4000

Python

1.0101

5.2376

44.4574

Julia

0.4207

2.5080

19.0140

R

0.5650

3.0660

19.2660

Matlab

0.3571

1.6552

2.6250

表 SQM-1.1:在 i7 Mac 上计算矩阵的平方根所用的时间。

语言

n=1000

n=2000

n=4000

Python

0.5653

3.3963

25.9180

  • 高斯求积

高斯求积(Gauss-Legendre Quadrature)是逼近定积分的一种数值方法。它使用被积函数的 n 个值的加权和。如果被积函数是 0 到 2 n - 1 次多项式,则结果是精确的。这里我们考虑区间 [-3, 3] 上的指数函数,并记录当 n 变化时执行积分所用的时间。

表 GLQ-1.0:在 Xeon 节点上计算积分近似值所用的时间。

语言

选项

n=50

n=75

n=100

Python

0.0079

0.0095

0.0098

Julia

0.0002

0.0004

0.0007

IDL

0.0043

0.0009

0.0014

R

0.0260

0.0240

0.0250

Matlab

0.7476

0.0731

0.4982

Fortran

gfortran

0

0.0040

0.0080

gfortran -O3

0

0.0120

0.0120

ifort

0.0080

0.0080

0.0080

ifort -O3

0.0080

0.0040

0.0080

表 GLQ-1.1:在 i7 Mac 上计算积分近似值所用的时间。

语言

n=50

n=75

n=100

Python

0.0140

0.0035

0.0077

  • 三角函数

我们在 n 元素值列表上迭代计算三角函数,然后在同一列表上计算反三角函数。当 n 发生变化时,测量完整全部操作所用的时间。

表 TRG-1.0:在 Xeon 节点上计算三角函数所用的时间。

语言

选项

n=80000

n=90000

n=100000

Python

14.6891

16.5084

23.6273

Julia

55.3920

62.9490

69.2560

IDL

37.4413

41.9695

35.2387

R

91.5250

102.8720

113.8600

Matlab

5.2794

5.8649

6.3699

Scala

357.3730

401.8960

446.7080

Java

689.6560

774.9110

865.057

Fortran

gfortran

53.4833

60.0317

66.6921

gfortran -O3

49.9271

56.0235

62.1678

ifort

18.6411

20.9573

23.2654

ifort -O3

18.6451

20.9573

23.2694

C

gcc

107.4400

120.7300

134.0900

gcc -Ofast

93.0400

104.5700

116.0600

icc

76.2600

85.7900

95.3100

icc -Ofast

48.8400

54.9600

61.0600

表 TRG-1.1:在 i7 Mac 上计算三角函数所用的时间。

语言

n=80000

n=90000

n=100000

Python

3.5399

6.1984

6.9207

  • Munchausen 数

Munchausen 数 是一个自然数,等于其自身幂次的位数之和。在以 10 为基数的情况下,有 4 个这样的数字:0、1、3435 和 438579088。我们来确定找到这些数字需要多久。

表 MCH-1.0:在 Xeon 节点上查找 Munchausen 数所用的时间。

语言

选项

所用时间

Python

1130.6220

Julia

102.7760

Java

4.9008

Scala

72.9170

R

exceeded time limit

IDL

exceeded time limit

Matlab

373.9109

Fortran

gfortran

39.7545

gfortran -O3

21.3933

ifort

29.6458

ifort -O3

29.52184

C

gcc

157.3500

gcc -Ofast

126.7900

icc

228.2300

icc -Ofast

228.1900

表 MCH-1.1:在 i7 Mac 上查找 Munchausen 数所用的时间。

语言

所用时间

Python

1013.5649

Java

4.7434

Scala

64.1800

输入 / 输出

  • 读取大量文件

我们有一套涵盖 20 年的每日 NetCDF 文件(7305)。给定年份的文件位于一个标记为 YYYY 的子目录中(例如,Y1990、Y1991、Y1992 等)。我们希望编写一个脚本,打开每个文件,读取一个三维变量(经度 / 维度 / 级别)并对其进行操作。脚本的伪代码如下:

    Loop over the years
        Obtain the list of NetCDF files
        Loop over the files
            Read the variable (longitude/latitude/level)
            Compute the zonal mean average (new array of latitude/level)
            Extract the column array at latitude 86 degree South
            Append the column array to a "master" array (or matrix)

目标是能够生成三维数组(年份 / 级别 / 值)并执行等高线图。这是我们支持的典型用户面临的问题类型:需要对数千个文件进行操作以提取所需信息的集合。拥有能够从文件中快速读取数据(如 NetCDF、HDF4、HDF5、grib 等格式)的工具对我们的工作至关重要。

表 RCF-1.0:在 Xeon 节点上处理 NetCDF 文件所用的时间。

语言

所用时间

Python

660.8084

Julia

787.4500

IDL

711.2615

R

1220.222

Matlab

848.5086

表 RCF-1.1:在 i7 Mac 上处理 NetCDF 文件所用的时间。

语言

所用时间

Python

89.1922

表 RCF-2.0:在 Xeon 节点上利用多核处理器使用 Python 处理 NetCDF 文件所用的时间。

所用时间

1

570.9791

2

317.6108

4

225.4647

8

147.4527

16

84.0102

24

59.7646

28

51.2191

表 RCF-2.1:在 i7 Mac 上利用多核处理器使用 Python 处理 NetCDF 文件所用的时间。

所用时间

1

84.1032

2

63.5322

4

56.6156

图表总结

在下面的图中,我们通过使用 GCC 获得的计时数字(仅在最后一列,即最大问题的大小)作为参考,总结上述计时结果。

研究结果

概述:

  • 没有任何一种语言在所有测试中都优于其他语言。
  • 通过仅在必要时创建变量以及“清空”不再使用的变量来减少内存占用非常重要。
  • 对于相同的任务,使用内置函数会比内联代码带来更高的性能。
  • Julia 和 R 提供了简单的基准测试工具。我们编写了一个简单的 Python 工具,允许我们随心所欲地多次运行 Python 测试用例。

循环和向量化:

  • 与使用循环相比,Python(和 NumPy)、IDL 和 R 在向量化时运行速度更快。
  • 在使用 Numba 时,只要使用 NumPy 数组,Python 就可以更快地处理循环。
  • 对于 Julia,循环比向量化代码运行得更快。
  • 在不涉及计算的情况下,使用循环与向量化相比,MATLAB 在性能上似乎没有显著变化。当进行计算时,向量化 MATLAB 代码要比迭代代码更快。

字符串操作:

  • 与其他语言相比,Java 和 Scala 在操作大型字符串时,似乎具有显著的性能。

数值计算:

  • 与其他语言相比,R 在使用递归时似乎具有显著的性能。
  • 语言在数值计算中相对于其他语言的性能表现取决于具体的任务。
  • MATLAB 的内置快速傅里叶变换函数似乎运行速度最快。

输入 / 输出:

  • 虽然有些语言运行测试的速度比其他语言快,但在本地 Mac 上而不是处理器节点上运行测试的话,可以获得最大的性能提升。因为处理器节点使用机械硬盘,而 Mac 用的是固态硬盘。这表明硬件对 I/O 性能的影响比所使用的语言更大。

参考资料

  1. Julia, Matlab and C,Justin Domke 著,2012 年 9 月 17 日
  2. 四阶泊松求解器,《计算物理学杂志》,55(1):166-172,Murli M. Gupta 著,1984 年

原文链接:

Basic Comparison of Python, Julia, Matlab, IDL and Java (2019 Edition)

  • 发表于:
  • 本文为 InfoQ 中文站特供稿件
  • 首发地址https://www.infoq.cn/article/iHJ9Y3Zxw75SV63v7R62

扫码关注云+社区

领取腾讯云代金券