我知道Julia在很大程度上依赖于即时静态类型派生(基本上所有代码都需要被认为是c++模板)。我还了解到,这意味着在对不同类型的对象使用单一算法时,只要这些类型在编译时是已知的,就不会产生运行时开销。
当谈到运行时多态性时,我不太清楚它是如何工作的。假设我们有以下情况:
abstract Shape
type Circle <: Shape
radius::Float64
end
type Square <: Shape
width::Float64
end
dist(x::Circle, y::Circle) = ...
dist(x::Circle, y:
当我在学习Julia的时候,我想知道如何正确地做我以前在Python、Java或C++中做过的事情。例如,以前我可能使用抽象基类(或接口)通过类定义一系列模型。然后每个类可能都有一个像calculate这样的方法。因此,为了调用它,我可能会使用model.calculate(),其中model是来自某个继承类的对象。 我知道Julia使用多个分派来重载具有不同签名的函数,比如calculate(model)。我的问题是如何创建不同的model。我是否为此使用类型系统并创建不同的类型,如: abstract type Model end
type BlackScholes <: Mode
在R中,从任何工作目录开始,我都能做到
setwd("~/Desktop")
这与我的linux发行版在命令行解释cd的方式是一致的。但是Julia似乎不能识别~/符号:
julia> cd("~/Desktop")
ERROR: chdir ~/Desktop: No such file or directory
in systemerror at error.jl:38
in cd at file.jl:13
这是一个bug吗?
我想知道是否有可能在Julia中显示字段值。
例如,这个Python程序从使用者类中获取对象变量wealth:
class Consumer:
def __init__(self, w):
"Initialize consumer with w dollars of wealth"
self.wealth = w
def earn(self, y):
"The consumer earns y dollars"
self.wealth += y
def spend
我建立了一个包含很多参数的复杂的计算模型。由于我需要运行许多场景,所以我决定将所有这些输入参数打包到一个巨大的struct中。
using Parameters
@with_kw struct MyModel
a::Int = 5
b::Float64 = 5.5
c::Matrix{Float64} = rand(3,4)
# 40 other parameters go here
end
我有一个对象m作为一个例子:
m = MyModel(a=15)
现在,当我写数学代码时,我不想在每个符号前面写m.。因此,我需要将struct字段变成局部变量。一种方法是
我定义了一个函数如下:
function approx_pi(n)
tot = Float64(0.0)
for i in 1:n
x = rand()
y = rand()
if x^2 + y^2 < 1
tot+=1
end
end
tot / n * 4
end
println(approx_pi(100_000_000))
我想使用相同的函数,但返回一个Float128:
using Quadmath
function approx_pi(n)
t
我的问题是,如何在朱莉娅中的某个类中重载某些方法?
换句话说,假设我对类有以下定义:
type Sometype
prop::String
setValue::Function
# constructor
function Sometype()
this = new ()
this.prop = ""
####### v1 #######
this.setValue = function(v::Real)
println("Scalar Version was
是否有方法连接朱莉娅中的ArrayViews,而不复制底层数据?(如果SubArray解决了问题,我也很乐意使用它。)
例如,在下面的代码中,我希望有一个ArrayView引用y1和y2中的数据。
julia> x = [1:50];
julia> using ArrayViews;
julia> y1 = view(x, 2:5);
julia> y2 = view(x, 44:48);
julia> concat(y1, y2) # I wish there were a function like this
ERROR: concat not de
我注意到在Julia中使用匿名函数会导致性能损失。为了说明这一点,我有两个快速排序实现(取自Julia分发版中的微性能基准)。第一类按升序排列。
function qsort!(a,lo,hi)
i, j = lo, hi
while i < hi
pivot = a[(lo+hi)>>>1]
while i <= j
while a[i] < pivot; i += 1; end
while pivot < a[j]; j -= 1; end
我想将抽象类型的方法扩展为具体类型。我可以用一种新的方法来完成这个任务,但是这会带来更多的复杂性:
abstract type AbstractTask end
function complete(task::AbstractTask)
complete_concrete_task(task)
println("Done!")
end
struct Task <: AbstractTask
name::String
end
complete_concrete_task(task::Task) = println(task.name)
coding
如果我有像f(args...; kwargs...)这样的函数签名,那么如何从kwargs中获得特定的关键字呢?天真地键入kwargs.x是行不通的:
julia> f(args...; kwargs...) = kwargs.x
f (generic function with 1 method)
julia> f(x=1)
ERROR: type Pairs has no field x
Stacktrace:
[1] getproperty(::Base.Iterators.Pairs{Symbol,Int64,Tuple{Symbol},NamedTuple{(:x,)
在许多编程语言中,父类可以要求任何子类包含特定的字段。
如果场是静态的,同样的效果可以通过以下方式在Julia中实现。
julia> abstract Fruit
julia> type Apple <: Fruit end
julia> type Orange <: Fruit end
julia> type Banana <: Fruit end
julia> color(::Apple) = :red
color (generic function with 1 method)
julia> color(::Orange)
我是朱莉娅语言的新手,教程还不够深入,我不知道传递函数参数列表的最佳方法是什么。我的功能如下:
function dxdt(x)
return a*x**2 + b*x - c
end
其中x是变量(2D数组),a、c和d是参数。据我所知,不建议使用Julia中的全局变量。那么,怎样才是正确的方法呢?
我对数组的不同类型感到困惑。考虑这两个例子
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是一样的吗?如
我正试图创建一个图书馆。假设我有一个模型,其中我有一个输出、输入和描述函数的方程。这些投入将是:
x= [1,2,3,4,5,6]
y= [5,2,4,8,9,2]
我把它放在一个函数中:
#=returns y values=#
function fit (x,a,b)
y=ax+b
end
另一个使用描述函数输出摘要:
#=Describes equation fitting=#
function describe(#insert some model with data from the previous functions)
#=Prints the following
在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;
}
好处是,如果代码中有多个函数,我就不需要将常量变量输入到每个函数
我有一个类型AbstractT,对于每个子类型,我想定义一个构造函数T(x::Tuple),但是我找不到一种通用的方法来完成它,因为像这样的朱莉娅中的所有东西都使用分派,但是我不能在构造函数上分派,因为构造函数的名称与类型匹配,所以每个构造函数都是不同的函数。也就是说,如果有一个
construct{T<:AbstractT}(::Type{T},x::Tuple) = # Define all the constructors
我在内部这样做,但是它不能很好地与其他软件包一起工作,这些包将直接调用T(x)和error。朱莉娅是不是以某种我可以利用的方式来利用引擎盖下的调度?
我希望能够在Julia结构中定义一个静态变量。例如,我想这样定义一些东西:
mutable struct MyStruct
global const a = 1
b = 2
end
然后,我希望能够以类似于Java或C++语言中的静态常量的方式访问a,例如:
MyStruct.a
我非常清楚,这种编写代码的方式不是-Julian,我可以使用模块来实现这一目的。
然而,我感兴趣的是可变结构是否可能。例如,我感兴趣的是为什么这是不可能的细节,以及模仿这种编程模式的技术。
我有以下朱莉娅的代码:
X=[(i,i^2) for i in 1:100 if i^2%5==0]
基本上,如果(i,i^2)和5的剩余部分为零,它将从i=1 to 100返回元组的列表。我想要做的是,在数组理解中,如果i^2比1000大,就会跳出for循环。但是,如果我执行
X=[(i,i^2) for i in 1:100 if i^2%5==0 else break end]
我得到了错误:syntax: expected "]"。
有没有任何方法可以轻松地打破这个for循环中的数组?我试过上网,但什么都没发现。
假设我想要编写一个需要任意长度的数组作为参数输入的函数:例如,
f = function(x,y)
z = x * y
outputs = DataFrame(x = x, y = y, z = z)
return(outputs)
end
返回,f.([1,2],[1,2])是两个1x3 DataFrames的2元素数组。但是,在这个场景中,我想要一个2x3 DataFrame。
我可以通过在嵌套for循环之前定义z来实现这一点:
f = function(x,y)
z=fill(0,length(x))
for i in 1:length(x)
z[i] = x