@julia中的时间打印不同的时间

我开始将我的一些Matlab脚本翻译给Julia，并尝试比较性能。在这里，我遇到了一个看似简单的问题，但我没有通过快速搜索找到答案。当我从控制台运行Julia脚本时，即键入“Julia test_FAS2SA.jl”，它会在屏幕上打印“3.116226秒”，这几乎是相应matlab脚本运行时间的30倍

然后我进入julia环境并输入“include”（“test_FAS2SA.jl”）”，它会打印“1.368429秒”。但是，当我只键入“@time SA，PF=FAS2SA（FAS1，f_-FAS，10.0，f_-SA，0.05）；”时，它会打印“0.033920秒”。我想知道FAS2SA函数的实际运行时间是多少，打印的时间不同

我的平台是Windows7 professional，Julia 1.10。脚本“test_FAS2SA.jl”和输入文件粘贴如下

# test JuliaFunc
using DelimitedFiles

# import Pkg; Pkg.add("time")
using QuadGK 

function getH_SDF(D,fn,freq)
# PURPOSE
#   get transfer function of a SDOF oscilator
#   acc response to acc excitation
# INPUT
#   D - damping ratio
#   fn - fundamental frequency of the SDOF (Hz)
#   freq - frequency array (Hz)
# OUTPUT
#   absH - Amplitude of the transfer function

N=length(freq)
    H=complex(zeros(N))
for i=1:N
    f=freq[i]
    H[i]=(-fn^2)/((f^2-fn^2)-(2*f*fn*D*1im))
end
return abs.(H)

end

function trapz(x, y)
# Trapezoidal integration rule
local n = length(x)
if (length(y) != n)
    error("Vectors 'x', 'y' must be of same length")
end
r = 0.0
if n == 1; return r; end
for i in 2:n
    r += (x[i] - x[i-1]) * (y[i] + y[i-1])
end

#= correction -h^2/12 * (f'(b) - f'(a))
ha = x[2] - x[1]
he = x[end] - x[end-1]
ra = (y[2] - y[1]) / ha
re = (y[end] - y[end-1]) / he
r/2 - ha*he/12 * (re - ra)
=#

return r/2
end

function getmoment(Y,f,n)

N=length(Y)
S=zeros(N)
for i=1:N
    S[i]=(2.0*pi*f[i])^n*Y[i]^2
end
return 2.0*trapz(f,S)

end

function getXmax(Y,F,T_rms)

moment0=getmoment(Y,F,0)
moment2=getmoment(Y,F,2)
moment4=getmoment(Y,F,4)

Y_rms=(moment0/T_rms)^0.5  # rms value

Ne=1.0/pi*(moment4/moment2)^0.5*T_rms  # number of extrema
xi=(moment2^2/moment0/moment4)^0.5  # number of width
#temp=(2*log(xi*Ne))^0.5 
#PF(i)=temp+0.5772/temp 

Func(x)=1-(1-xi*exp(-x^2))^Ne

#Fun=@(x) 1-(1-xi.*exp(-x.^2)).^Ne
Tmp,e = QuadGK.quadgk(Func,0,Inf)
PF = sqrt(2.0)*Tmp

Ymax=PF*Y_rms
return Ymax
end

function FAS2SA(FAS,F,T_gm,freq, damping)
# INPUT
#   FAS  - Fourier Amplitude Spectrum
#   F    - Frquency array corresponding FAS (Hz)
#   T_gm - ground motion duration (sec)
#   freq - fundametnal frequency of SDOF oscilator (Hz)
#   damping - damping ratio of SDOF oscilator
# OUTPUT
#   SA   - Spectral acceleration (g)
#   PF   - Peak Factor 

n_T=length(freq)
SA=zeros(n_T)
PF=zeros(n_T)

for i=1:n_T

H=getH_SDF(damping,freq[i],F) # get transfer function of SDOF oscilator
Y=FAS.*H  # FAS of acc response of oscilator
Tn=1.0/freq[i]  # fundamantal period
T0=Tn/2.0/pi/damping  #oscilator duration
gamma=T_gm/Tn  

n_val=3.0  
alpha=1.0 / 3.0

T_rms=T_gm+T0*(gamma^n_val/(gamma^n_val+alpha)) # total duration


moment0=getmoment(Y,F,0)
moment2=getmoment(Y,F,2)
moment4=getmoment(Y,F,4)

Y_rms=(moment0/T_rms)^0.5  # rms value

Ne=1/pi*(moment4/moment2)^0.5*T_gm  # number of extrema
# note that here use T_gm not T_rms (Refer to Boore and Joyer, 1984)

xi=(moment2^2/moment0/moment4)^0.5  # number of width
#temp=(2*log(xi*Ne))^0.5 
#PF(i)=temp+0.5772/temp 

Fun(x)= 1-(1-xi*exp(-x^2))^Ne
Q_tmp,e_tmp = QuadGK.quadgk(Fun,0,Inf)
PF1 = 2^0.5*Q_tmp



Ymax=PF1*Y_rms  

SA[i]=Ymax
PF[i]=PF1


end
return (SA,PF)
end 

T=readdlm("period.dat")
f_SA=1.0 ./ T

#println(vs)

FAS=readdlm("FAS.dat")
f_FAS=FAS[:,1]
FAS1=FAS[:,2]

println(@time SA,PF=FAS2SA(FAS1,f_FAS,10.0,f_SA, 0.05))

文件“period.dat”

文件“FAS.dat”

---

第一次运行Julia时，它会编译所有内容，这需要一点时间。第二次调用任何东西时，它已经被编译并快速启动

调用函数两次，第二次调用会快得多

当我运行它时，我的第一个呼叫是

2.750975秒

，第二个呼叫是

0.013358秒

我所说的两个电话是指：

@time SA,PF=FAS2SA(FAS1,f_FAS,10.0,f_SA, 0.05) <---2.750975 seconds
@time SA,PF=FAS2SA(FAS1,f_FAS,10.0,f_SA, 0.05) <---0.013358 seconds

---

@time SA，PF=FAS2SA（FAS1，f_FAS，10.0，f_SA，0.05）第一次运行Julia时，它会编译所有内容，这需要一点时间。第二次调用任何东西时，它已经被编译并快速启动

调用函数两次，第二次调用会快得多

当我运行它时，我的第一个呼叫是
2.750975秒
，第二个呼叫是
0.013358秒

我所说的两个电话是指：

@time SA,PF=FAS2SA(FAS1,f_FAS,10.0,f_SA, 0.05) <---2.750975 seconds
@time SA,PF=FAS2SA(FAS1,f_FAS,10.0,f_SA, 0.05) <---0.013358 seconds

@time-SA，PF=FAS2SA（FAS1，f_-FAS，10.0，f_-SA，0.05）还有一些消除边界检查的方法将有助于提高性能。一个小贴士：创建一个复杂向量
H
只在以后返回
abs.（H）
是浪费。直接计算H[i]=abs（（-fn^2）/（f^2-fn^2）-（2im*f*fn*D））
。或者更快更好：
H[i]=fn^2/sqrt（（f^2-fn^2）^2+（2*f*fn*D）^2）
。对于您的Matlab代码也是如此。不要创建不必要的临时数组。还有一些消除边界检查的方法将有助于提高性能。一个小技巧：创建一个复杂的向量
H
，只在以后返回
abs。（H）
是浪费。直接计算H[i]=abs（（-fn^2）/（f^2-fn^2）-（2im*f*fn*D））

。或者更快更好：

H[i]=fn^2/sqrt（（f^2-fn^2）^2+（2*f*fn*D）^2）

。对于您的Matlab代码也是如此。不要制作不必要的临时数组。

@time SA,PF=FAS2SA(FAS1,f_FAS,10.0,f_SA, 0.05) <---2.750975 seconds
@time SA,PF=FAS2SA(FAS1,f_FAS,10.0,f_SA, 0.05) <---0.013358 seconds