让代码飞起来——高性能Julia学习笔记

最新推荐文章于 2022-08-01 16:48:08 发布
最新推荐文章于 2022-08-01 16:48:08 发布
阅读量366 收藏 2
点赞数
分类专栏： julia机器学习&科学计算 文章标签： 大数据 机器学习
原文链接：https://magicly.me/hpc-julia/
版权

最近有个项目是计算密集型的， 最开始用 TS 快速实现了算法原型， 后来改用 Go 重写， Go 的 goroutine 用起来还是蛮爽的， 很容易把所有 cpu core 跑满。 不过随着代码逐渐复杂， 感觉用 Go 还是没有动态语言写起来爽， 性能也没有达到极致， 跟 C/C++/Rust 还是有一定差距，似乎对 GPU 和 SIMD 支持也不太好（不敢说对 Go 精通， 可能是我没找到合适的打开方式吧）。 一开始打算用 Rust 尝试一下， 之前用过一下， 性能确实可以（毕竟没有 runtime/GC），结果前段时间 Julia 发布 1.0，看了一下语法、性能等各方面都很适合， 遂决定用 Julia 写。

本文记录一下学习 Julia HPC 方面的经历。

 

使用 Julia

网上有很多 Julia 的教程， 推荐几个大家自己去看看吧：

 

High Performance Computing Julia

主要参考《Julia High Performance》，书里用的 Julia0.4， 很多代码已经跑不起来了， 我参考官网文档修改了一下。 后面有时间会根据官网文档再整理一些 HPC 相关的资料。

测试机器为：

julia> versioninfo()
Julia Version 1.0.1
Commit 0d713926f8 (2018-09-29 19:05 UTC)
Platform Info:
  OS: macOS (x86_64-apple-darwin14.5.0)
  CPU: Intel(R) Core(TM) i7-4870HQ CPU @ 2.50GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.0 (ORCJIT, haswell)

 

有多快

参考官网 Benchmark：

benchmarks.svguploading.4e448015.gif转存失败重新上传取消Julia benchmark

让我惊讶的是， LuaJIT 居然比 Rust 还快！！！

 

为什么如此快

Julia 设计之初就重点考虑了速度， 它的快很大程度上来源于 LLVM, JIT 以及类型设计。 Julia 有类型推断，编译的时候会根据不同 type 生成不同的特定代码，叫 code specialization，然后运行的时候会根据参数类型选择最适合的方法，即 Multiple dispatch。

 

性能分析工具

没有分析的优化都是耍流氓！

性能分析工具主要有如下几个：

 

@time

@time sqrt.(rand(1000));

输出结果：

julia> @time sqrt.(rand(1000));
  0.057799 seconds (187.82 k allocations: 9.542 MiB, 9.82% gc time)

julia> @time sqrt.(rand(1000));
  0.000022 seconds (8 allocations: 16.063 KiB)

这里;是为了不输入结果值。 因为rand(1000)返回的是一个 vector， sqrt.即可作用于 vector 中的每一个元素， 类似 numpy 中的 broadcast 吧。

注意， 第一次运行的时候 Julia 会编译代码， 所以时间会长很多， 应该以第二次以及之后的为准！

 

@timev

用法同@time， 功能增加了 memory， 以及时间精确到 ns。

julia> @timev sqrt.(rand(1000));
  0.000025 seconds (8 allocations: 16.063 KiB)
elapsed time (ns): 25340
bytes allocated:   16448
pool allocs:       6
non-pool GC allocs:2

 

Julia profiler

用 profiler 可以分析出那段代码占用了最多时间。

using Profile
using Statistics
function testfunc()
  x = rand(1000000)
  y = std(x)
  return y
end
@profile testfunc()

Profile 会采样搜集 profile 信息，获取信息：

Profile.print();

Profile 的输出不便于分析， 可以采用 ProfileView 输出火焰图（说实话跟 Go 的火焰图差远了）：

Pkg.add("ProfileView");
using ProfileView
ProfileView.view()

 

BenchmarkTools

https://github.com/JuliaCI/BenchmarkTools.jl

julia> Pkg.add("BenchmarkTools")

julia> using BenchmarkTools

julia> @benchmark sqrt.(rand(1000))
BenchmarkTools.Trial:
  memory estimate:  15.88 KiB
  allocs estimate:  2
  --------------
  minimum time:     4.935 μs (0.00% GC)
  median time:      5.598 μs (0.00% GC)
  mean time:        7.027 μs (11.17% GC)
  maximum time:     229.810 μs (97.54% GC)
  --------------
  samples:          10000
  evals/sample:     7

可以看到，包括内存占用、内存分配次数，运行时间统计等， 我们后面很多实验都是用@benchmark。

 

Types

Julia 的类型是在 runtime 检查的， 但是在 compile time 会生成不同类型的方法。

Julia 中， 函数是一个抽象概念， 一个函数名下可能对应多个具体实现，即方法，比如如下代码函数 f 有 2 个方法：

julia> function f(x::Int64)
           x
       end
f (generic function with 1 method)

julia> function f(x::String)
           "string"
       end
f (generic function with 2 methods)

运行的时候， 会根据所有参数个数、类型， 选择最 match 的方法执行， 所以叫 Multiple dispatch。 对比一般的 OO 语言， 只是根据 receiver 来决定 dispatch 哪个方法， 所以叫”single dispatch”。

Julia 中 type 也会形成 hierarchy， 如下图： julia-type-hierarchy.pnguploading.4e448015.gif转存失败重新上传取消Julia type hierarchy

Julia 中，concrete type 不能有 subtypes， 也就是 final 的！

Any是所有的超类， Nothing是所有的子类， Nothing只有一个实例： nothing。

Julia 中的参数类型（类似 Java 的泛型）可以是 value， 比如 Array 的类型为 Array{T, N}， 其中 N 是具体的数字，表示数组的维数：

julia> typeof([1,2])
Array{Int64,1}

Julia 的类型推断不是基于著名的 Hindley-Milner 算法（ML 系语言用的类型推断算法， 比如 Scala）, 它只会尽力推， 最后在 runtime 如果找不到 match 的方法就会报错。

 

Type-stability

Type-stability指的是函数返回值类型只取决于参数类型， 而跟参数的具体值无关。 下面的函数就不符合：

function trunc(x)
  if x < 0
    return 0
  else
    return x
  end
end

julia > trunc(-1.5) |> typeof
Int64

julia > trunc(1.5) |> typeof
Float64

|>是 pipeline 操作符， 把前一个操作的结果传入下一个操作， 类似于 linux 的|， 可以方便的将f(g(h(j(x))))改写成可读性更高的x |> j |> h |> g |> f。

要修复trunc的type-stability问题， 可以用 zero 方法：

function trunc_fixed(x)
  if x < 0
    return zero(x)
  else
    return x
  end
end

julia> -1.5 |> trunc_fixed |> typeof
Float64

julia> 1.5 |> trunc_fixed |> typeof
Float64

如果函数是 type-unstable 的话， Julia 编译器没法编译出特定类型的优化的代码， 我们来测试一下：

julia> @benchmark trunc(-2.5)
BenchmarkTools.Trial:
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     0.020 ns (0.00% GC)
  median time:      0.030 ns (0.00% GC)
  mean time:        0.031 ns (0.00% GC)
  maximum time:     8.802 ns (0.00% GC)
  --------------
  samples:          10000
  evals/sample:     1000

julia> @benchmark trunc_fixed(-2.5)
BenchmarkTools.Trial:
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     0.020 ns (0.00% GC)
  median time:      0.032 ns (0.00% GC)
  mean time:        0.031 ns (0.00% GC)
  maximum time:     8.843 ns (0.00% GC)
  --------------
  samples:          10000
  evals/sample:     1000

1.0 上似乎没有太大区别了，书里的 0.4 版本显示 trunc_fixed 效率是 trunc 的两倍多， 说明 Julia 本身也在不停地改进以及用新版本是很重要的！

如何识别 type-stability 问题呢？ Julia 提供了一个@code_warntype宏：

julia> @code_warntype trunc(2.5)
Body::Union{Float64, Int64}
2 1 ─ %1 = π (0.0, Float64)                                                                                                                                           │╻  <
  │   %2 = (Base.lt_float)(x, %1)::Bool                                                                                                                               ││╻  <
  │   %3 = π (0.0, Float64)                                                                                                                                           ││
  │   %4 = (Base.eq_float)(x, %3)::Bool                                                                                                                               ││╻  ==
  │   %5 = (Base.and_int)(%4, true)::Bool                                                                                                                             ││╻  &
  │   %6 = (Base.and_int)(%5, false)::Bool                                                                                                                            │││
  │   %7 = (Base.or_int)(%2, %6)::Bool                                                                                                                                ││╻  |
  └──      goto #3 if not %7                                                                                                                                          │
3 2 ─      return 0                                                                                                                                                   │
5 3 ─      return x                                                                                                                                                   │

julia> @code_warntype trunc_fixed(2.5)
Body::Float64
2 1 ─ %1 = π (0.0, Float64)                                                                                                                                           │╻  <
  │   %2 = (Base.lt_float)(x, %1)::Bool                                                                                                                               ││╻  <
  │   %3 = π (0.0, Float64)                                                                                                                                           ││
  │   %4 = (Base.eq_float)(x, %3)::Bool                                                                                                                               ││╻  ==
  │   %5 = (Base.and_int)(%4, true)::Bool                                                                                                                             ││╻  &
  │   %6 = (Base.and_int)(%5, false)::Bool                                                                                                                            │││
  │   %7 = (Base.or_int)(%2, %6)::Bool                                                                                                                                ││╻  |
  └──      goto #3 if not %7                                                                                                                                          │
3 2 ─      return 0.0                                                                                                                                                 │
5 3 ─      return x

可以看到 trunc 的返回值类型是 Union{Float64, Int64}。 另外也可以用@code_llvm和@code_native两个宏看函数最后生成的 LLVM IR 指令和机器码， 会发现 type-stabe 的函数生成的指令也要少一些。

 

函数和宏

 

全局变量的问题

全局变量是 bad smell， 在 Julia 中还会影响性能， 因为全局变量可能在任何时候被修改为任何其他类型， 所以 compiler 没法优化。

julia> p = 2;
julia> function pow_array(x::Vector{Float64})
         s = 0.0
         for y in x
           s = s + y^p
         end
         return s
       end
pow_array (generic function with 1 method)

julia> t = rand(100000);

julia> @benchmark pow_array(t)
BenchmarkTools.Trial:
  memory estimate:  4.58 MiB
  allocs estimate:  300000
  --------------
  minimum time:     7.385 ms (0.00% GC)
  median time:      8.052 ms (0.00% GC)
  mean time:        8.261 ms (2.76% GC)
  maximum time:     50.044 ms (85.05% GC)
  --------------
  samples:          604
  evals/sample:     1

可以将全局变量修改为const即可：

julia> const p2 = 2
2

julia> function pow_array2(x::Vector{Float64})
         s = 0.0
         for y in x
           s = s + y^p2
         end
         return s
       end
pow_array2 (generic function with 1 method)

julia> @benchmark pow_array2(t)
BenchmarkTools.Trial:
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     81.324 μs (0.00% GC)
  median time:      83.629 μs (0.00% GC)
  mean time:        87.973 μs (0.00% GC)
  maximum time:     185.029 μs (0.00% GC)
  --------------
  samples:          10000
  evals/sample:     1

性能差距将近 100 倍！！！内存占用和分配也有很大差别。 用@code_warntype 可以看出两者的差别， pow_array 返回值是 Any 类型， 而 pow_array2 是 Float64 类型， 可见 pow_array2 是 type-stable 的。

Julia 中的 const 可以修改值！但是不能修改类型！

 

inline

Julia 使用的 LLVM 编译器， 大部分编译优化都是 LLVM 的功劳， 不过 inline 是在 LLVM 之前做的。 Julia 有一套启发式规则， 将“值得 inline”的函数 inline。 inline 会增大 code 的大小，需要权衡。

julia> trunc2(x) = x < 0 ? zero(x) : x
trunc2 (generic function with 1 method)

julia> function sqrt_sin(x)
         y = trunc2(x)
         return sin(sqrt(y)+1)
       end
sqrt_sin (generic function with 1 method)

julia> @code_typed sqrt_sin(-1)
CodeInfo(
2 1 ─ %1  = (Base.slt_int)(x, 0)::Bool                                                                                                                           │╻╷   trunc2
  └──       goto #3 if not %1                                                                                                                                    ││
  2 ─       goto #4                                                                                                                                              ││
  3 ─       goto #4                                                                                                                                              ││
  4 ┄ %5  = φ (#2 => 0, #3 => _2)::Int64                                                                                                                         │
3 │   %6  = (Base.sitofp)(Float64, %5)::Float64                                                                                                                  │╻╷╷╷ sqrt
  │   %7  = (Base.lt_float)(%6, 0.0)::Bool                                                                                                                       ││╻    sqrt
  └──       goto #6 if not %7                                                                                                                                    │││
  5 ─       invoke Base.Math.throw_complex_domainerror(:sqrt::Symbol, %6::Float64)::Union{}                                                                      │││
  └──       $(Expr(:unreachable))::Union{}                                                                                                                       │││
  6 ─ %11 = (Base.Math.sqrt_llvm)(%6)::Float64                                                                                                                   │││
  └──       goto #7                                                                                                                                              │││
  7 ─       goto #8                                                                                                                                              ││
  8 ─ %14 = (Base.add_float)(%11, 1.0)::Float64                                                                                                                  ││╻    +
  │   %15 = invoke Main.sin(%14::Float64)::Float64                                                                                                               │
  └──       return %15                                                                                                                                           │
) => Float64

从@code_typed 宏的结果可以看出，并没有调用 trun2，而是直接将 trunc2 的代码 inline 了。 可以用julia --inline=no启动 REPL， 结果会是：

julia> @code_typed sqrt_sin(-1)
CodeInfo(
2 1 ─ %1 = (Main.trunc2)(x)::Int64                                                                                                                                          │
3 │   %2 = (Main.sqrt)(%1)::Float64                                                                                                                                         │
  │   %3 = (%2 + 1)::Float64                                                                                                                                                │
  │   %4 = (Main.sin)(%3)::Float64                                                                                                                                          │
  └──      return %4                                                                                                                                                        │
) => Float64

注意， 禁用 inline 会严重影响性能， 只在特殊情况下（比如 debugging 或者 code coverage analysis）才打开。

关掉 inline：

julia> @benchmark sqrt_sin(-1)
BenchmarkTools.Trial:
  memory estimate:  1.45 KiB
  allocs estimate:  77
  --------------
  minimum time:     3.114 μs (0.00% GC)
  median time:      3.410 μs (0.00% GC)
  mean time:        3.749 μs (4.07% GC)
  maximum time:     1.232 ms (99.33% GC)
  --------------
  samples:          10000
  evals/sample:     9

打开 inline：

julia> @benchmark sqrt_sin(-1)
BenchmarkTools.Trial:
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     8.434 ns (0.00% GC)
  median time:      8.682 ns (0.00% GC)
  mean time:        9.083 ns (0.00% GC)
  maximum time:     35.598 ns (0.00% GC)
  --------------
  samples:          10000
  evals/sample:     999

可以看到， 性能差距巨大！

有时候根据 Julia 的默认规则不会 inline， 可以在 function 定义之前手动加上@inline 则可以， 不过最好是经过 profile 之后确定是代码热点才去做。

julia> function f2(x)
         a=x*5
         a=a*5
         d = a
         a=a*5
         b=a+3
         b=b+3
         b=b+3
         c=a-4
         d=b/c
       end
f2 (generic function with 1 method)

julia> g(x) = f2(2x)
g (generic function with 1 method)

julia> @code_llvm g(3)
define double @julia_g_35286(i64) {
top:
  %1 = mul i64 %0, 250
  %2 = add i64 %1, 9
  %3 = add i64 %1, -4
  %4 = sitofp i64 %2 to double
  %5 = sitofp i64 %3 to double
  %6 = fdiv double %4, %5
  ret double %6
}

我们可以看到 LLVM 生成的代码中，第一行是%1 = mul i64 %0, 250， 原因在于 f2 中， a 乘以 3 个 5， 并且 g 的定义中有一个 2 倍， 所以 LLVM 直接优化成了乘以2 * 5 * 5 * 5 = 250。 如果没有 inline 的话，显然是做不到的（5*5*5应该还是可以优化成*125）。

 

macros

macros 就是在 compile time 用 code 生成 code， 能提前做一些事情， 这样在 runtime 的时候就能少做一些， 性能自然高了。

书中举的例子测试无效， 所以暂时不放了。

 

named parameters

有时候 function 参数很多， 可以用 named parameters，可以提高代码可读性。 但是性能有点点影响， 大概是 50% 吧。 影响不是太大， 所以建议代码可读性和可维护性优先， 只在 performance-sensitive 的内部循环才不使用。

julia> named_param(x; y=1, z=1)  =  x^y + x^z
named_param (generic function with 1 method)

julia> pos_param(x,y,z) = x^y + x^z
pos_param (generic function with 1 method)

julia> @benchmark named_param(4, y = 2, z = 3)
BenchmarkTools.Trial:
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     6.535 ns (0.00% GC)
  median time:      6.997 ns (0.00% GC)
  mean time:        7.228 ns (0.00% GC)
  maximum time:     43.993 ns (0.00% GC)
  --------------
  samples:          10000
  evals/sample:     1000

julia> @benchmark pos_param(4, 2, 3)
BenchmarkTools.Trial:
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     4.367 ns (0.00% GC)
  median time:      4.500 ns (0.00% GC)
  mean time:        4.727 ns (0.00% GC)
  maximum time:     38.259 ns (0.00% GC)
  --------------
  samples:          10000
  evals/sample:     1000
October-
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【2017CS231n】第十一讲：图像分割、定位、识别
poulang5786的博客
06-13 1万+
一.语义分割二.图像分类和定位三.对象识别
vector二维数组初始化_我爱Julia之入门-042（数组）
weixin_39883260的博客
12-11 578
数组与大多数技术计算语言一样，Julia 提供原生的数组实现。 大多数技术计算语言非常重视其数组实现，但需要付出使用其它容器的代价。Julia 用同样的方式来处理数组。就像和其它用 Julia 写的代码一样，Julia 的数组库几乎完全是用 Julia 自身实现的，它的性能源自编译器。这样一来，用户就可以通过继承 AbstractArray 的方式来创建自定义数组类型。 实现自定义数组类型的更多详...
Julia篇（外传）-Julia常用函数
weixin_34315189的博客
07-04 3608
为什么80%的码农都做不了架构师？>>> ...
java二维改值_通过反射获取属性值来实现二维数组的替换改写
weixin_39924329的博客
03-08 368
原二维数组赋值：for (int j = 1; j <= 25; j++){if (StringUtil.Trim(StringUtil.ToString(adoDataTable.Rows[num21]["VALUE_" + j.ToString()])) != ""){index++;Array.Resize(ref View_Raw_Data_Out.value_list, index...
julia学习笔记：元编程-宏(macro)
weixin_33937913的博客
09-04 735
宏像是一个函数，这个函数接受一组参数返回一个表达式。一个简单的宏定义： julia> macro sayhello(name) return :( println("Hello, ", $name) ) end @sayhello (macro with 1 method) 这个宏接收一个参数并返...
julia系列3：函数、模块与宏
kittyzc的博客
08-01 791
复合表达式 使用 和 或者使用小括号： 和 为循环关键字，用end结束，没有:符号并且不需要缩进： python中的range(N)在julia中用1:N表示，数据类型为UnitRange或者StepRange，和array一起可用于范围遍历。注意array和range的下标从1开始，和python不一样。 关键字为 和 使用定义函数，用两个冒号来断言具体变量类型（注意不是声明！julia的变量没有类型） 使用@doc funcname可以看到函数前面的注释。 local变量可以强制转类型，需要先声明
fortran语言和python语言_对于科学计算，大家对新出来语言Julia怎么看，相比C、Python和Fortran有什么优势发展？...
weixin_35745604的博客
02-01 462
三更：先抛事实(经与支持julia的 @陈宁聪 同学确认)：julia的抽象类型的容器是被做了派发(aka “模板偏特化”)以非组合类型的方式实现的这个派发(相比于非派发的值语义组合类型)是性能不佳且没有对这种不佳性能warning的设计上，julia接近于java的堆分配类型(即使是标量)，没有栈分配类型，实现上的优化特化(或者说派发，割裂，etc)另讲REPL很不错，是julia一大比cpp强...
llvm libLLVMCore源码分析 09 - Cast Operators
weixin_42654107的博客
03-01 924
源码路径 llvm\include\llvm\IR\Instruction.h llvm\include\llvm\IR\Instruction.def llvm\include\llvm\IR\Instructions.h llvm\include\llvm\IR\InstrTypes.h Cast Operators TruncInst（父类：CastInst） trunc指令将操作数截断为另一个类型。 语法 <result> = trunc <ty> &lt
julia图像处理
微小冷的学习笔记
12-29 4304
juila图像处理入门julia简介与安装 julia简介与安装 julia和python一样是一门动态编程语言，不过据说有媲美C的速度，而且在数据科学领域很吃得开，这谁能顶得住啊，所以果断体验一波。 首先下载安装包：http://julialang.org/ ...
基于Julia云平台的交互式深度学习模式
06-20
为降低深度学习程序的开发难度,提出了一种基于Julia云平台的交互式深度学习模式。设计了一套深度学习原语,用Julia实现原语,为Julia程序员提供调用接口,构建交互分析系统;并提供GPU/CPU实现接口,由云端系统根据用户...
Julia 编程手册
03-12
Julia作为灵活的动态语言，适合科学和数值计算，性能可与传统静态类型语言媲美。由于 Julia 的编译器和其它语言比如 Python 或 R 有所不同，一开始您或许会觉得 Julia 中什么样的代码运行效率高，什么样的代码运行效率低似乎并不很直观。如果您发现 Julia 变慢了，我们非常建议您在尝试其它功能前读一下代码性能优化 。只要您理解 Julia 的工作方式，就会很容易地写出运行效率甚至可以和 C 相媲 美的代码。
Optim.jl, Julia优化函数.zip
09-18
Optim.jl, Julia优化函数 Optim.jlJulia中的单变量和多变量优化。英镑的文档英镑英镑英镑构建状态英镑社会英镑参考引用引用 多目标优化Optim.jl 是函数
精通Julia编程（Mastering Julia）-2015年英文原版，
12-06
精通Julia编程（Mastering Julia）-2015年英文原版—— Develop your analytical and programming skills further in Julia to solve complex data processing problems，Julia 是一个面向科学计算的高性能动态高级程序设计语言。其语法与其他科学计算语言相似。在许多情况下拥有能与编译型语言相媲美的性能。
gpu高性能编程Julia示例代码
02-04
gpu高性能编程（cuda by example）一书中详细介绍了Julia示例，此文件为源代码，方便学习交流使用
matlab代码中向量的点乘-all-about-Julia:Julia学习笔记
05-23
学习笔记 安装 在此下载合适的软件包。 按照说明安装Julia。 IJulia是一种Julia语言后端，结合了交互式环境（也被所使用）。 这种组合使您可以使用Jupyter / IPython的强大功能与Julia语言进行交互，该功能在单个...
Julia中文学习资料
03-02
Julia中文学习资料，入门推荐
CUDA高性能GPU计算Julia集代码
06-01
CUDA高性能GPU计算Julia集代码，可运行CUDA 7.0编译的
Julia 生态发展之路
pl_lab_001的博客
09-09 326
今年 7 月 19 日，Julia 语言创始人成立的 Julia Computing 公司宣布完成了 2400 万美元的 A 轮融资，由 Dorilton Ventures 领投，Menlo Ventures、General Catalyst 和 HighSage Ventures 跟投[1]。融资将被用于 Julia 生态的扩张，继续研发产品让 Julia 语言变得更容易部署、更加好用[2]。 Julia 是一种速度快且使用简单的高级通用编程语言，最初设计用于科学计算领域[3]，2012 年发布以...
julia学习笔记（六）：模块、宏和元编程
weixin_44104200的博客
06-22 623
模块 模块（module）是一些互相隔离的可变工作空间，也就是说它们会引入新的全局作用域。它们在语法上以 module Name … end 界定。模块允许你创建顶层定义（也称为全局变量），而无需担心命名冲突。在模块中，利用导入（importing）可以控制其它模块中的哪些名称是可见的；利用导出（exporting）可以控制你自己的模块中的哪些名称是公开的。 julia> module MyModule export my_add, my_multiply my_add(
Julia代码
最新发布
05-30
以下是一个简单的Julia代码示例，计算从1到100的自然数之和： ```julia # 计算从1到100的自然数之和 sum = 0 for i in 1:100 sum += i end println("从1到100的自然数之和为：$sum") ``` 运行结果为： ``` 从1到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值