一般来说,Julia的基于1的数组是一个很好的决定,但有时候希望有类似Fortran的数组,其索引跨越some的某些子范围:

julia> x = FArray(Float64, -1:1,-7:7,-128:512)

哪里有用:

在教程中伴随着"双曲偏微分方程的数值解"一书的代码中.John A. Trangenstein这些负指数被强烈用于鬼细胞的边界条件.对于Clawpack(代表"保护法律包"),教授也是如此.Randall J. LeVeque  http://depts.washington.edu/clawpack/  还有许多其他代码,这些指数很自然.因此,这种辅助类对于快速翻译这些代码是有用的.

我刚开始实施这样一种辅助类型,但由于我对Julia很新,所以我非常感谢你的帮助.

我开始时:

type FArray
    ranges
    array::Array
    function FArray(T, r::Range1{Int}...)
        dims = map((x) -> length(x), r)
        array = Array(T, dims)
        new(r, array)
    end
end

输出:

julia> include ("FortranArray.jl")
julia> x = FArray(Float64, -1:1,-7:7,-128:512)
FArray((-1:1,-7:7,-128:512),3x15x641 Array{Float64,3}:
[:, :, 1] =
6.90321e-310  2.6821e-316   1.96042e-316  0.0  0.0  0.0  9.84474e-317  …  1.83233e-316  2.63285e-316  0.0           9.61618e-317  0.0        
6.90321e-310  6.32404e-322  2.63285e-316  0.0  0.0  0.0  2.63292e-316     2.67975e-316
...
[:, :, 2] =
...

因为我对朱莉娅来说是全新的,所以任何能够提高效率的建议都会受到高度赞赏. …

在R中,dyplr您拥有%>%允许您将函数输出传递给新函数的运算符,从而无需存储中间值.在julia中,您可以通过使用|>运算符实现非常相似的功能.

用法示例

2 |> log |> sqrt 

对我而言,这比阅读更好sqrt(log(2)).特别是当链条变得很长时.我想用这个语法,但也对map,reduce型功能朱莉娅.

建立

from = "abcdefghijklmnopqrstuvwxyz"
to   = "cdefghijklmnopqrstuvwxyzab"
trans = "g fmnc wms bgblr rpylqjyrc gr zw fylb <>"
d = {from[i] => to[i] for i = 1:26}
d[' '] = ' '

什么有效

map(x -> d[x], filter(x -> isalpha(x) || isspace(x), trans))

这样可行,但它读起来并不像我希望的那样好.另一种方法是将中间结果存储到变量中,但这似乎也很冗长:

res1 = filter(x -> isalpha(x) || isspace(x), trans)
map(x -> d[x], res1)

我更喜欢什么

R语法与此类似:

trans |> 
  filter(x …

我有一个数组a=rand(100),我想得到除索引值之外的所有值notidx=[2;50].是否有一种干净的方式来获得a其他价值观？我正在寻找一个复制和视图的好方法.

目前我做的阵列[1;3:49;51:100]通过symdiff(1:100,notidx),但a[symdiff(1:length(a),notidx)]并view(a,a[symdiff(1:length(a),notidx)])是不是很干净(或理解别人)这样做的方法.

假设我有一个n只能输入值的整数[0, 10].我应该声明它n::Int是关于它的一般性,n::Int8还是n::UInt8简约或n::Int6464位系统？

请说明新手的原因,例如风格,表现.

背景:我特林学习朱莉娅并迅速迷失在类的字眼type,immutable,syntactic sugar!我想我读过这个:https://docs.julialang.org/en/release-0.5/manual/integers-and-floating-point-numbers/

I am trying to make a surface plot without the axis and grid lines. I found that I can turn off the grid with grid = false but I can't find a way to remove the axis lines.

surface(x2d, y2d, z2d, fill_z = color_mat, fc = :haline, grid=false)

Thanks!

我正在尝试Julia 1.3使用以下硬件的多线程功能：

Model Name: MacBook Pro
Processor Name: Intel Core i7
Processor Speed:    2.8 GHz
Number of Processors:   1
Total Number of Cores:  4
L2 Cache (per Core):    256 KB
L3 Cache:   6 MB
Hyper-Threading Technology: Enabled
Memory: 16 GB

运行以下脚本时：

function F(n)
if n < 2
    return n
    else
        return F(n-1)+F(n-2)
    end
end
@time F(43)

它给我以下输出

2.229305 seconds (2.00 k allocations: 103.924 KiB)
433494437

但是，当运行下面的代码从Julia页面复制的关于多线程的代码时

import Base.Threads.@spawn

function fib(n::Int)
    if n < 2 …

背景

我自学了机器学习，最近开始深入研究 Julia 机器学习生态系统。

我知道如何使用这样的timeit模块来获取在 python 中执行函数所花费的时间：

#Loading an Image using OpenCV

s = """\
img = cv2.imread('sample_image.png', 1)
"""
setup = """\
import timeit
"""
print(str(round((timeit.timeit(stmt = s, setup = setup, number = 1))*1000, 2)) + " ms")
#printing the time taken in ms rounded to 2 digits

如何使用适当的库（在本例中为JuliaImages）比较在 Julia 中执行相同任务的函数的执行时间。

Julia 是否为 …

我知道 Julia 中的运算符只是标准函数，我可以使用普通的前缀调用语法来使用它们：

julia> +(1, 2)
3

但是，它们也很特殊，因为它们可以（并且通常）用作中缀运算符：

julia> 1+2
3

我可以定义自己的中缀运算符吗？如果是这样，如何？

例如：

julia> ?(x, y) = x+y
? (generic function with 1 method)

julia> ?(1, 2)
3 # as expected

julia> 1?2
# expected result: 3
ERROR: UndefVarError: ?2 not defined
Stacktrace:
 [1] top-level scope at REPL[5]:1

julia> 1 ? 2
# expected result: 3
ERROR: syntax: extra token "?" after end of expression
Stacktrace:
 [1] top-level scope at REPL[5]:0

我试着比较这两个片段，看看一秒钟可以完成多少次迭代。事实证明，Julia 实现了 250 万次迭代，而 Python 实现了 400 万次。朱莉娅不是应该更快吗？或者这两个片段可能不等价？

Python：

t1 = time.time()
i = 0
while True:
    i += 1
    if time.time() - t1 >= 1:
        break

朱莉娅：

function f()
    i = 0
    t1 = now()
    while true
        i += 1
        if now() - t1 >= Base.Dates.Millisecond(1000)
            break
        end
    end
    return i
end

我对 Julia 比较陌生，正在移植一些 C 函数来检查速度差异。我正在努力解决的一个问题是变量的范围。具体来说，有时 Julia 中的函数调用会覆盖局部变量，而有时不会。例如，这是一个计算最小生成树的函数：

function mst(my_X::Array{Float64})
    n = size(my_X)[1]
    N = zeros(Int16,n,n)
    tree = []
    lv = maximum(my_X)+1
    my_X[diagind(my_X)] .=lv
    indexi = 1
    for ijk in 1:(n-1)
        tree = vcat(tree, indexi)
        m = minimum(my_X[:,tree],dims = 1)
        a = zeros(Int64, length(tree))
        print(tree)
        for k in 1:length(tree)
            a[k] = sortperm(my_X[:,tree[k]])[1,]
        end
        b = sortperm(vec(m))[1]
        indexj = tree[b]
        indexi = a[b]
        N[indexi,indexj] = 1
        N[indexj,indexi] = 1
        for j in tree
            my_X[indexi,j] = lv
            my_X[j,indexi] = lv
        end
    end
    return …