在将一个程序从Python翻译到Julia之后,我非常不满意:
对于小/非常小的输入,Python更快。
对于中等输入,Julia速度更快(但没有那么大)
对于大输入,Python更快
我认为原因是我不明白内存分配是如何工作的(在这里自动执行操作,没有CS背景)。我会在这里张贴我的代码,但它太长,太具体,它不会对任何人都有益,除了我。因此,我做了一些实验,现在我有一些问题。
考虑一下这个简单的script.jl
function main()
@time begin
a = [1,2,3]
end
end
main()
当我运行它时,我得到:
我的程序需要内存,所以我需要尽可能地节省内存.当将整数值赋值给变量时,值的类型总是Int64,无论它是0还是+2^63-1还是-2^63。我找不到有效分配内存的聪明方法,所以我编写了一个类似于这样的函数(在本例中是整数):
function right_int(n)
types = [Int8,Int16,Int32, Int64, Int128]
for t in reverse(types)
try
n = t(n)
catch InexactError
break
end
在C编程语言中,#define指令允许在源代码中定义宏。这些宏定义允许声明常量值,以便在整个代码中使用。
宏定义不是变量,不能像变量一样被程序代码更改。在创建表示数字、字符串或表达式的常量时,我们通常使用此语法。像这样
#include <stdio.h>
#define NAME "Jack"
#define AGE 10
int main()
{
printf("%s is over %d years old.\n", NAME, AGE);
return 0;
}
好处是,如果代码中有多个函数,我就不需要将常量变量输入到每个函数
在解决代码阻塞问题时,我给朱莉娅一次机会,在本例中,来自2010年第1C轮的Rope Intranet ()
解决办法基本上是:
for tc = 1:int(readline())
n = int(readline())
a = [map(int, split(readline())) for _ = 1:n]
ans = 0
for (i, x) in enumerate(a)
for y in a[i + 1:end]
ans += (x[1] - y[1]) * (x[2] - y[2]) < 0
我对数组的不同类型感到困惑。考虑这两个例子
a = Array{Float64}[]
push!(a,[1, 2])
push!(a,[3, 4])
push!(a,[1 2; 3 4])
b = Array[[1.0, 2.0], [3.0,4.0], [1.0 2.0; 3.0 4.0]]
我不知道a和b有什么不同。假设我打算对a或b中的每个元素运行一个for循环,并将每个元素乘以2。
for i in 1:3 a[i] = a[i]*2 end
for i in 1:3 b[i] = b[i]*2 end
我分别对两行的运行时间进行计时,但它们的运行速度是相同的。a和b是一样的吗?如
请考虑以下代码:
julia> function foo(x::Float64)::Float64
return 2x
end
foo (generic function with 1 method)
julia> typeof(foo)
typeof(foo)
typeof(foo)不返回更有意义的东西肯定有原因,例如(Float64 -> Float64)。那是什么?
我偶然看到这个看着。
为了提高代码的可读性,我试图为函数模板指定更短的名称,如下面的示例所示:
#include <iostream>
template<typename T>
T func(T a, T b)
{
return a + b;
}
int main()
{
using fi = func<int>;
using fd = func<double>;
std::cout << fi(1, 1) << std::endl;
std::cout << fd(1.0, 1.0)
我在读茱莉亚表演技巧,
在开始时,它提到了两个例子。
例1,
julia> x = rand(1000);
julia> function sum_global()
s = 0.0
for i in x
s += i
end
return s
end;
julia> @time sum_global()
0.009639 seconds (7.36 k allocations: 300.310 KiB, 98.32% compilation time)
496.84883432553846
我不明白为什么需要IteratorEltype()。每个迭代都保证生成Any类型的对象,所以如果您不知道任何更好的东西,那么始终可以默认使用它。区分“我知道它可以是什么”(IteratorEltype == HasEltype && eltype = Any)和“我不知道它是什么,因此它可能是什么”(IteratorEltype == EltypeUnknown)有什么意义?
在Base中,我能找到的唯一使用EltypeUnknown()的类型是Generator,它是(f(i) for i in iter)语法背后的工具。我可以想象,如果eltype是非叶类型,那么很难/不可
我正在写一些软件,它涉及到一个量的各种函数形式的库。我想利用Julia的多个分派,但想知道是否有更有效的方法来实现这个过程。 例如,考虑一个包含以下两个函数的库 function firstfunction(x::Float64)
return 2*x
end
function secondfunction(x::Float64)
return x^2
end 我还想实现多个分派方法,这些方法可以将这些函数形式应用于值的向量或向量数组(矩阵)。我可以这样做,如下所示 function firstfunction(x::Float64)
return 2*x
end
我正在阅读一些关于计算机科学中的障碍是什么的想法(特别是功能障碍),并想知道如何在我自己的Julia代码中复制这种东西。我有以下功能: julia> function strange_twos(n)
a = Vector{rand(Bool) ? Int64 : Float64}(undef, n)
for i = 1:n
a[i] = 2
end
return a
end; 我该如何向这个函数添加一个屏障来提高性能呢?
BenchmarkTools文档建议将全局变量插入到基准测试表达式中。但是,它们提供的示例在运行时方面的差距似乎已经大大缩小。在中,它们有一个全局变量A = rand(1000),并将@benchmark [i*i for i in A]与@benchmark [i*i for i in $A]进行比较,并分别获得13.806 μs与1.348 μs。但是,当我现在运行该示例时,运行时间非常接近:
julia> using Statistics, BenchmarkTools
julia> A = rand(1000);
julia> median(@benchmark
如果我有一个结构,
struct MyStruct
a
b
end
是否有办法编写如下所示的函数
function doSomething(x::MyStruct,fieldName::String)
y = x.fieldName
return f(y)
end
我在文档/论坛上找不到这方面的任何信息。
我有一个带有标题的函数
integrateL(f, lb::SArray{Tuple{S},Float64,1, S} where S<:Integer, ub::SArray{Tuple{S},Float64,1, S} where S<:Integer, y::Float64)
return nothing
end
我不分享问题的内容,因为问题不在里面,而且会让人感到困惑。这个问题是可以重复的。该函数在转换变量后与HCubature.jl包进行半无限维积分.在参数中,我按照包文档中的建议使用StaticArrays来实现性能。若要复制错误,请执行以下操作。
lb = z
当我在学习Julia的时候,我想知道如何正确地做我以前在Python、Java或C++中做过的事情。例如,以前我可能使用抽象基类(或接口)通过类定义一系列模型。然后每个类可能都有一个像calculate这样的方法。因此,为了调用它,我可能会使用model.calculate(),其中model是来自某个继承类的对象。 我知道Julia使用多个分派来重载具有不同签名的函数,比如calculate(model)。我的问题是如何创建不同的model。我是否为此使用类型系统并创建不同的类型,如: abstract type Model end
type BlackScholes <: Mode
我只想更改一个元素,如下面的代码所示。
using Flux, CuArrays
a = rand(3,3) |> gpu
CuArrays.allowscalar(false)
a[1, 1] = 1.0f0
因为标量被设置为false,所以它自然会出现在下面。
ERROR: scalar setindex! is disallowed
但是如果去掉了标量,它就会出现在下面。
Performing scalar operations on GPU arrays: This is very slow, consider disallowing these operations with
Julia (v0.5)不会持续传播以下内容,从而导致性能低下:
julia> g(::Int) = true
g (generic function with 1 method)
julia> f(x) = g(x) ? 1 : 1.0
f (generic function with 1 method)
julia> @code_warntype f(1)
Variables:
#self#::#f
x::Int64
Body:
begin
unless $(QuoteNode(true)) goto 3
return 1
我想要一个可以从结构中调用的函数。为此,我尝试在Julia中(在一定程度上)模仿C++类方法。为此,我在Julia结构中添加了一个函数属性,并将该属性分配给我在构造函数阶段传入的函数对象。
问题是,它是有效的,但这种方法确实比直接调用函数慢1000倍。
下面是我的代码的MWE:
struct struct_wh_method{F}
func::F;
function struct_wh_method(func_in)
new{typeof(func_in)}(func_in)
end
end
我目前正在不断地检查无限while循环中的一个条件。我要用几个条件来打破循环。但是,while循环立即中断,调试println()显示代码位于第一个if()语句中。Hoover,从不运行前面的行,if语句需要该信息(polar)来计算。我只得到一个错误时,试图调用极地在以后的程序,它不存在。这句话好像被完全跳过了。
下面是有问题的while循环:
prevSize = 0
sec = 0
n = 5
while true # wait unit the polar file is done changing
polar = readdlm(polarPath,Float64,skips
首先,我不得不说我对并行计算完全陌生(对计算机科学几乎一无所知),所以我对“工作者”或“进程”之类的东西的理解非常有限。但是,我确实有一个关于运行一个简单的for循环的问题,该循环可能在并行迭代之间没有依赖关系。
假设我想要执行以下操作:
for N in 1:5:20
println("The N of this iteration in $N")
end
如果我只是想让这些消息出现在屏幕上,而出现的顺序并不重要,那么如何在Julia 0.6中实现这一点,并在Julia 0.7 (因此是1.0)中供将来参考呢?
我的问题是,如何在朱莉娅中的某个类中重载某些方法?
换句话说,假设我对类有以下定义:
type Sometype
prop::String
setValue::Function
# constructor
function Sometype()
this = new ()
this.prop = ""
####### v1 #######
this.setValue = function(v::Real)
println("Scalar Version was
考虑朱莉娅中的下列函数定义:
plustwo = function(x)
x + 2
end
function addtwo(x)
x + 2
end
令我惊讶的是,这两个定义都是有效的,而且行为也是一样的。即,
typeof(plustwo)
julia> Function
typeof(addtwo)
julia> Function
plustwo(3)
julia> 5
addtwo(3)
julia> 5
对此有什么评论吗?
这是否意味着朱莉娅有几种方言?