Hi Kevin,
Let me explain it with an example.
For example, one-dimensional heat equation.
u_t-u_xx=f
If I discrete time and space in t_0, t_1,...,t_m, and x_0,x_1,...,x_n
respectively. We want to store these points. Then it is a matrix u(t_i,
x_j).
What I am concern is how to store such a big mat
Hello Yi,
Your question is rather open-ended. Can you give an example of the kind of
multi-dimensional data you're interested in, and what you want to visualize
about it?
Cheers,
Kevin
On Sun, May 25, 2014 at 6:40 PM, yi lu wrote:
> In scientific computing, we need multi-dimensional arrays
In scientific computing, we need multi-dimensional arrays to *store* time
and space grid points for computing and for plotting. So, what is best
*recommended* to use in Julia for such requirement? What I mean by best is
fastest, cheapest and so on.
Thanks in advance.
Yi
I wrote a quick PEG Parser for Julia with Packrat capabilities:
https://github.com/abeschneider/PEGParser
It's a first draft and needs a ton of work, testing, etc., but if this is
of interest to anyone else, here is a quick description.
Grammars can be defined using most of the standard EBNF sy
Jason, thank you for that link! After reading much of the prior discussions
on the matter, it's clear Oliver Woodford and I share a similar viewpoint,
and this has already been discussed heavily.
I would still vote for covariance over invariance in this case, since
arguments to functions map fi
See also
https://groups.google.com/forum/#!searchin/julia-users/invariance$20covariance$20contravariance
for discussions of different possibilities for handling inheritance with
typed parameters. I was convinced by Stefan's arguments there that Julia's
invariance is the least bad strategy.
On
> The style guide at
> http://julia.readthedocs.org/en/latest/manual/style-guide/#handle-excess-argument-diversity-in-the-callerseems
> to encourage my approach, and
> http://julia.readthedocs.org/en/latest/manual/style-guide/#don-t-use-unnecessary-static-parametersdirectly
> condemns Iain's reco
I agree to be as generic as possible. I should have used this second
example instead, a quite common scenario where being generic doesn't make
as much sense:
function output(context::Context, strings::Vector{String})
context.something()
# Call the single-string version of the function on
On Sunday, May 25, 2014 2:11:41 PM UTC-7, Adam Smith wrote:
>
> Actually, no. I'm not going to pretend this is a good thing. You're right
> that it is "consistent and logical" when you're using an academic
> type-correctness viewpoint. However, it is not consistent from a developer
> perspective
Your response ignores my strong example. And "not declare types in function
signatures" does not "work just fine most of the time," because multiple
dispatch largely breaks if you don't type your arguments. You simply must
type your function arguments for Julia to be able to resolve the right
m
On Sun, 25 May 2014 14:11:41 -0700 (PDT), Adam Smith wrote:
> Actually, no. I'm not going to pretend this is a good thing. You're right
> that it is "consistent and logical" when you're using an academic
> type-correctness viewpoint. However, it is not consistent from a developer
> perspective,
Actually, no. I'm not going to pretend this is a good thing. You're right
that it is "consistent and logical" when you're using an academic
type-correctness viewpoint. However, it is not consistent from a developer
perspective, and here's why.
On most functions, I don't need to specify parametr
There are improvements planned, which should make it possible to write the
code as you originally wrote. For now though, you will have to write it C
style if you want the highest performance.
-viral
On Monday, May 26, 2014 12:00:50 AM UTC+5:30, Christoph Ortner wrote:
>
>
> Thank you both for t
There are optimized distance calculations for a number of different metrics
in Distance.jl: https://github.com/JuliaStats/Distance.jl
On Sunday, May 25, 2014 1:42:15 AM UTC-7, paul analyst wrote:
>
> How quickly calculate distances arrays etc.
>
> This is an array of quotients, on the diagonal mu
Yep, thanks! I was a bit hasty.
On Sunday, May 25, 2014, Ismael VC wrote:
> It should be:
>
> type Person
> lastname::String
> firstname::String
> end
>
> fullname(p::Person) = "$(p.firstname) $(p.lastname)"
>
> jan = Person("Janssen", "Jan")
>
> println(fullname(jan))
>
>
>
> Thank you both for the suggestions. I've re-written the code >> JULIA3, with
> amazing results. JULIA2 was the previous "optimised" code.
>
>
Test 1, J2: 0.751340928, J3: 0.008927998, C: 0.007420171; max-error = 0.0
Test 2, J2: 0.7136, J3: 0.009042345, C: 0.007583811; max-error = 0.0
Tes
>
> Thank you both for the suggestions. I've re-written the code >> JULIA3, with
> amazing results. JULIA2 was the previous "optimised" code.
>
>
Test 1, J2: 0.751340928, J3: 0.008927998, C: 0.007420171; max-error = 0.0
Test 2, J2: 0.7136, J3: 0.009042345, C: 0.007583811; max-error = 0.0
Te
cool, thanks!
On Monday, May 26, 2014 1:57:28 AM UTC+8, Ethan Anderes wrote:
>
> I love the ... notation. It splats the entries into separate arguments
> separated by commas into the function.
>
> julia> y = "abcd"
> "abcd"
>
> julia> [y...] == ['a', 'b', 'c', 'd']
> true
>
> On Sunday, May 25,
I love the ... notation. It splats the entries into separate arguments
separated by commas into the function.
julia> y = "abcd"
"abcd"
julia> [y...] == ['a', 'b', 'c', 'd']
true
On Sunday, May 25, 2014 10:49:05 AM UTC-7, Freddy Chua wrote:
hang on, what does the "..." in hcat(a...) means
>
You're right, that's not bad at all. Thanks.
On Sunday, May 25, 2014 12:41:04 PM UTC-4, Iain Dunning wrote:
>
> julia> f{T<:String}(strs::Vector{T}) = dump(strs)
> f (generic function with 1 method)
>
> julia> f(["foo"])
> Array(ASCIIString,(1,)) ASCIIString["foo"]
>
>
> Seems fine to me, and more
hang on, what does the "..." in hcat(a...) means
On Monday, May 26, 2014 1:47:21 AM UTC+8, Ethan Anderes wrote:
>
> Right, hcat(a…) does that (up to a transpose since julia stores things in
> column major order ).
>
> julia> a = Array(Array, 0)
> 0-element Array{Array{T,N},1}
>
> julia> push!(a,
Right, hcat(a…) does that (up to a transpose since julia stores things in
column major order ).
julia> a = Array(Array, 0)
0-element Array{Array{T,N},1}
julia> push!(a, [1, 2])
1-element Array{Array{T,N},1}:
[1,2]
julia> push!(a, [3, 4])
2-element Array{Array{T,N},1}:
[1,2]
[3,4]
julia> b
I mean, is there a function that allows me to take in a and return a matrix?
b = convert_to_matrix(a)
b[:, 2] = [2,4]
On Monday, May 26, 2014 1:36:47 AM UTC+8, Freddy Chua wrote:
>
> For example
>
> a = Array(Array, 0)
>
> push!(a, [1, 2])
> push!(a, [3, 4])
>
> Gives me an array of array. Can I
hcat(a...) will return the matrix form of a. Is that what you want?
You can, but probably not without memory allocation since your Array of Array’s
isn’t a continguous block of memory.
— John
On May 25, 2014, at 10:36 AM, Freddy Chua wrote:
> For example
>
> a = Array(Array, 0)
>
> push!(a, [1, 2])
> push!(a, [3, 4])
>
> Gives me an array of array. Can I g
For example
a = Array(Array, 0)
push!(a, [1, 2])
push!(a, [3, 4])
Gives me an array of array. Can I get a matrix easily in this way?
julia> f{T<:String}(strs::Vector{T}) = dump(strs)
f (generic function with 1 method)
julia> f(["foo"])
Array(ASCIIString,(1,)) ASCIIString["foo"]
Seems fine to me, and more importantly (to me), is consistent and logical.
Vector{String} is a concrete type, its a specific thing.
Vector{T},T<:Str
Hard to test without some way of generating data, but I'd guess the problem is
dE[:, k] += dJ
dE[:, n] -= dJ
which (unfortunately) actually expands to
dE[:, k] = dE[:, k] + dJ
dE[:, n] = dE[:, n] - dJ
so there is a new array being created on the right-hand-side - it isn't an
inplace ope
Le dimanche 25 mai 2014 à 07:39 -0700, Christoph Ortner a écrit :
>
>
>
> I just started experimenting with Julia, as a platform for rapid
> prototyping for some more exotic molecular modelling applications
> where no black-box software exists. So far I like very much what I
> find. To test its
I just started experimenting with Julia, as a platform for rapid
prototyping for some more exotic molecular modelling applications where no
black-box software exists. So far I like very much what I find. To test its
performance, I implemented a simple Lennard-Jones energy and force assembly
5
I'd just like to add that this behavior is a real downer when dealing with
strings, too. During testing/debugging inline strings are ASCIIStrings, but
I don't want to hardcode my functions to use ASCIIStrings (or have to make
Unions absolutely every place I want a vector of strings):
julia> f(s
On Sunday, May 25, 2014 5:44:26 PM UTC+2, Pierre-Yves Gérardy wrote:
>
> On Sunday, May 25, 2014 5:10:49 PM UTC+2, James Crist wrote:
>>
>> Yeah, that's what I've been using. My issue with it is that the
>> declarations get long for functions with more than 2 arrays. Was hoping
>> there was a m
On Sunday, May 25, 2014 5:10:49 PM UTC+2, James Crist wrote:
>
> Yeah, that's what I've been using. My issue with it is that the
> declarations get long for functions with more than 2 arrays. Was hoping
> there was a more concise way.
>
You can use typealias Fp FloatingPoint , then
function fo
Is that preferable? The function is only defined for floats (integers or
complex wouldn't make any sense). Checking would have to occur inside the
function then, while I thought that it was more preferable to have the type
dispatch do that.
On Sunday, May 25, 2014 10:20:00 AM UTC-5, Mauro wrote
I think there is nothing shorter, if you need to dispatch on the type (e.g. if
you also have a `foobar` function for say Intergers as well). Otherwise a
function `foobar(a,b)` without type information works just as well and as fast
as it will be compiled for the specific input types.
On Sun,
Yeah, that's what I've been using. My issue with it is that the
declarations get long for functions with more than 2 arrays. Was hoping
there was a more concise way.
On Sunday, May 25, 2014 8:16:58 AM UTC-5, Steven G. Johnson wrote:
>
> On Sunday, May 25, 2014 9:14:46 AM UTC-4, Steven G. Johnson
Just a quick update: the Ubuntu nightlies have had 3 updates since your
post and still no sys.so. There might be plans to fix this, but in the mean
time it looks like the easiest way to get the faster start up time is to
compile from source. It is also possible that with a binary package there
It should be:
type Person
lastname::String
firstname::String
end
fullname(p::Person) = "$(p.firstname) $(p.lastname)"
jan = Person("Janssen", "Jan")
println(fullname(jan))
On Sunday, May 25, 2014 9:14:46 AM UTC-4, Steven G. Johnson wrote:
>
> function foo{T1<:FloatingPoint, T2<:FloatingPoint)(a::Array{T2},
> b::Array{T2})
>
Whoops, two typos. This should be:
function foo{T1<:FloatingPoint, T2<:FloatingPoint}(a::Array{T1},
b::Array{T2})
On Sunday, May 25, 2014 3:39:33 AM UTC-4, gael@gmail.com wrote:
> But,
> function foo(a::Array{FloatingPoint}, b::Array{FloatingPoint})
> a + b
> end
> is unfortunately not working. I don't know whether this is a bug or a
> choice.
>
This is not a bug, it just doesn't mean what you t
This should be reasonably fast:
function dist(F)
s = sum(F,1)
O = reshape(s, length(s)) ./ s
for i = 1:size(O,1); O[i,i] = 0; end
return O
end
when using hulls to calculate Delaunay then you calculate everything in d+1
dimensions, which for 2D has a 4X slower predicate. Also predicates are
mostly precalculated (already implemented in the updated gist above), so
their repeated calculation in the "swap" method should be fast.
Anyway, le
How quickly calculate distances arrays etc.
This is an array of quotients, on the diagonal must be zero.
Are there any features that quickly count this type of arrays?
Data in F...
k=size(F,2);
O=zeros(k,k);
for o=0:k-2;
for i=1:k-1-o j=i+1+o;
O[i,j]=sum(F[:,i])/sum(F[:,j]);
O[j,i]=1/O[i,j];
en
Le dimanche 25 mai 2014 08:29:02 UTC+2, James Crist a écrit :
>
> I've been struggling with this for a while, and haven't found a way to do
> it that I'm happy with. I'm sure there is one though. Basically, I want to
> declare a function that works on an array of floats. Doesn't matter what
>
Le dimanche 25 mai 2014 08:29:02 UTC+2, James Crist a écrit :
>
> I've been struggling with this for a while, and haven't found a way to do
> it that I'm happy with. I'm sure there is one though. Basically, I want to
> declare a function that works on an array of floats. Doesn't matter what
> ki
45 matches
Mail list logo
